nfs41_ops.h File Reference

#include "nfs41.h"
#include "pnfs.h"

Include dependency graph for nfs41_ops.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	__state_protect4_a
struct	__nfs41_exchange_id_args
struct	__state_protect4_r
struct	__nfs41_exchange_id_res
struct	__nfs41_callback_sec_parms
struct	__nfs41_create_session_args
struct	__nfs41_create_session_res
struct	__nfs41_bind_conn_to_session_args
struct	__nfs41_bind_conn_to_session_res
struct	__nfs41_destroy_session_args
struct	__nfs41_destroy_session_res
struct	__nfs41_destroy_clientid_args
struct	__nfs41_destroy_clientid_res
struct	__nfs41_sequence_args
struct	__nfs41_sequence_res_ok
struct	__nfs41_sequence_res
struct	__nfs41_reclaim_complete_res
struct	__stateid_arg
struct	__nfs41_access_args
struct	__nfs41_access_res
struct	__nfs41_op_close_args
struct	__nfs41_op_close_res
struct	__nfs41_commit_args
struct	__nfs41_commit_res
struct	__specdata4
struct	__createtype4
struct	__nfs41_create_args
struct	__nfs41_create_res
struct	__nfs41_delegpurge_res
struct	__nfs41_delegreturn_args
struct	__nfs41_delegreturn_res
struct	__nfs41_link_args
struct	__nfs41_link_res
struct	__open_to_lock_owner4
struct	__exist_lock_owner4
struct	__locker4
struct	__nfs41_lock_args
struct	__lock_res_denied
struct	__lock_res_ok
struct	__nfs41_lock_res
struct	__nfs41_lockt_args
struct	__nfs41_lockt_res
struct	__nfs41_locku_args
struct	__nfs41_locku_res
struct	__nfs41_lookup_args
struct	__nfs41_lookup_res
struct	__nfs41_getfh_res
struct	__nfs41_putfh_args
struct	__nfs41_putfh_res
struct	__nfs41_putrootfh_res
struct	__nfs41_getattr_args
struct	__nfs41_getattr_res
struct	__createhow4
struct	__openflag4
struct	__open_claim4
struct	__nfs41_op_open_args
struct	__nfs41_op_open_res_ok
struct	__nfs41_op_open_res
struct	__nfs41_openattr_args
struct	__nfs41_openattr_res
struct	__nfs41_read_args
struct	__nfs41_read_res_ok
struct	__nfs41_read_res
struct	__nfs41_readdir_args
struct	__nfs41_readdir_entry
struct	__nfs41_readdir_list
struct	__nfs41_readdir_res
struct	__nfs41_readlink_res
struct	__nfs41_remove_args
struct	__nfs41_remove_res
struct	__nfs41_rename_args
struct	__nfs41_rename_res
struct	__nfs41_restorefh_savefh_res
struct	__nfs41_setattr_args
struct	__nfs41_setattr_res
struct	__deleg_claim4
struct	__nfs41_want_delegation_args
struct	__nfs41_want_delegation_res
struct	__nfs41_free_stateid_args
struct	__nfs41_free_stateid_res
struct	__nfs41_test_stateid_args
struct	__nfs41_test_stateid_res
struct	__nfs41_write_args
struct	__nfs41_write_res_ok
struct	__nfs41_write_res
struct	__nfs41_secinfo_info
struct	__nfs41_secinfo_args
struct	__nfs41_secinfo_noname_args
struct	__nfs41_secinfo_noname_res
struct	__pnfs_layoutget_args
struct	__pnfs_layoutget_res_ok
struct	__pnfs_layoutget_res
struct	__pnfs_layoutcommit_args
struct	__pnfs_layoutcommit_res
struct	__pnfs_layoutreturn_args
struct	__pnfs_layoutreturn_res
struct	__pnfs_getdeviceinfo_args
struct	__pnfs_getdeviceinfo_res_ok
struct	__pnfs_getdeviceinfo_res

Macros
#define	RPCSEC_GSS   6
#define	MAX_OID_LEN   128
#define	MAX_SECINFOS   6

Typedefs
typedef struct __state_protect4_a	state_protect4_a
typedef struct __nfs41_exchange_id_args	nfs41_exchange_id_args
typedef struct __state_protect4_r	state_protect4_r
typedef struct __nfs41_exchange_id_res	nfs41_exchange_id_res
typedef struct __nfs41_callback_sec_parms	nfs41_callback_secparms
typedef struct __nfs41_create_session_args	nfs41_create_session_args
typedef struct __nfs41_create_session_res	nfs41_create_session_res
typedef struct __nfs41_bind_conn_to_session_args	nfs41_bind_conn_to_session_args
typedef struct __nfs41_bind_conn_to_session_res	nfs41_bind_conn_to_session_res
typedef struct __nfs41_destroy_session_args	nfs41_destroy_session_args
typedef struct __nfs41_destroy_session_res	nfs41_destroy_session_res
typedef struct __nfs41_destroy_clientid_args	nfs41_destroy_clientid_args
typedef struct __nfs41_destroy_clientid_res	nfs41_destroy_clientid_res
typedef struct __nfs41_sequence_args	nfs41_sequence_args
typedef struct __nfs41_sequence_res_ok	nfs41_sequence_res_ok
typedef struct __nfs41_sequence_res	nfs41_sequence_res
typedef struct __nfs41_reclaim_complete_res	nfs41_reclaim_complete_res
typedef struct __stateid_arg	stateid_arg
typedef struct __nfs41_access_args	nfs41_access_args
typedef struct __nfs41_access_res	nfs41_access_res
typedef struct __nfs41_op_close_args	nfs41_op_close_args
typedef struct __nfs41_op_close_res	nfs41_op_close_res
typedef struct __nfs41_commit_args	nfs41_commit_args
typedef struct __nfs41_commit_res	nfs41_commit_res
typedef struct __specdata4	specdata4
typedef struct __createtype4	createtype4
typedef struct __nfs41_create_args	nfs41_create_args
typedef struct __nfs41_create_res	nfs41_create_res
typedef struct __nfs41_delegpurge_res	nfs41_delegpurge_res
typedef struct __nfs41_delegreturn_args	nfs41_delegreturn_args
typedef struct __nfs41_delegreturn_res	nfs41_delegreturn_res
typedef struct __nfs41_link_args	nfs41_link_args
typedef struct __nfs41_link_res	nfs41_link_res
typedef struct __open_to_lock_owner4	open_to_lock_owner4
typedef struct __exist_lock_owner4	exist_lock_owner4
typedef struct __locker4	locker4
typedef struct __nfs41_lock_args	nfs41_lock_args
typedef struct __lock_res_denied	lock_res_denied
typedef struct __lock_res_ok	lock_res_ok
typedef struct __nfs41_lock_res	nfs41_lock_res
typedef struct __nfs41_lockt_args	nfs41_lockt_args
typedef struct __nfs41_lockt_res	nfs41_lockt_res
typedef struct __nfs41_locku_args	nfs41_locku_args
typedef struct __nfs41_locku_res	nfs41_locku_res
typedef struct __nfs41_lookup_args	nfs41_lookup_args
typedef struct __nfs41_lookup_res	nfs41_lookup_res
typedef struct __nfs41_getfh_res	nfs41_getfh_res
typedef struct __nfs41_putfh_args	nfs41_putfh_args
typedef struct __nfs41_putfh_res	nfs41_putfh_res
typedef struct __nfs41_putrootfh_res	nfs41_putrootfh_res
typedef struct __nfs41_getattr_args	nfs41_getattr_args
typedef struct __nfs41_getattr_res	nfs41_getattr_res
typedef struct __createhow4	createhow4
typedef struct __openflag4	openflag4
typedef struct __open_claim4	open_claim4
typedef struct __nfs41_op_open_args	nfs41_op_open_args
typedef struct __nfs41_op_open_res_ok	nfs41_op_open_res_ok
typedef struct __nfs41_op_open_res	nfs41_op_open_res
typedef struct __nfs41_openattr_args	nfs41_openattr_args
typedef struct __nfs41_openattr_res	nfs41_openattr_res
typedef struct __nfs41_read_args	nfs41_read_args
typedef struct __nfs41_read_res_ok	nfs41_read_res_ok
typedef struct __nfs41_read_res	nfs41_read_res
typedef struct __nfs41_readdir_args	nfs41_readdir_args
typedef struct __nfs41_readdir_entry	nfs41_readdir_entry
typedef struct __nfs41_readdir_list	nfs41_readdir_list
typedef struct __nfs41_readdir_res	nfs41_readdir_res
typedef struct __nfs41_readlink_res	nfs41_readlink_res
typedef struct __nfs41_remove_args	nfs41_remove_args
typedef struct __nfs41_remove_res	nfs41_remove_res
typedef struct __nfs41_rename_args	nfs41_rename_args
typedef struct __nfs41_rename_res	nfs41_rename_res
typedef struct __nfs41_restorefh_savefh_res	nfs41_restorefh_res
typedef struct __nfs41_restorefh_savefh_res	nfs41_savefh_res
typedef struct __nfs41_setattr_args	nfs41_setattr_args
typedef struct __nfs41_setattr_res	nfs41_setattr_res
typedef struct __deleg_claim4	deleg_claim4
typedef struct __nfs41_want_delegation_args	nfs41_want_delegation_args
typedef struct __nfs41_want_delegation_res	nfs41_want_delegation_res
typedef struct __nfs41_free_stateid_args	nfs41_free_stateid_args
typedef struct __nfs41_free_stateid_res	nfs41_free_stateid_res
typedef struct __nfs41_test_stateid_args	nfs41_test_stateid_args
typedef struct __nfs41_test_stateid_res	nfs41_test_stateid_res
typedef struct __nfs41_write_args	nfs41_write_args
typedef struct __nfs41_write_res_ok	nfs41_write_res_ok
typedef struct __nfs41_write_res	nfs41_write_res
typedef struct __nfs41_secinfo_info	nfs41_secinfo_info
typedef struct __nfs41_secinfo_args	nfs41_secinfo_args
typedef struct __nfs41_secinfo_noname_args	nfs41_secinfo_noname_args
typedef struct __nfs41_secinfo_noname_res	nfs41_secinfo_noname_res
typedef struct __pnfs_layoutget_args	pnfs_layoutget_args
typedef struct __pnfs_layoutget_res_ok	pnfs_layoutget_res_ok
typedef struct __pnfs_layoutget_res	pnfs_layoutget_res
typedef struct __pnfs_layoutcommit_args	pnfs_layoutcommit_args
typedef struct __pnfs_layoutcommit_res	pnfs_layoutcommit_res
typedef struct __pnfs_layoutreturn_args	pnfs_layoutreturn_args
typedef struct __pnfs_layoutreturn_res	pnfs_layoutreturn_res
typedef struct __pnfs_getdeviceinfo_args	pnfs_getdeviceinfo_args
typedef struct __pnfs_getdeviceinfo_res_ok	pnfs_getdeviceinfo_res_ok
typedef struct __pnfs_getdeviceinfo_res	pnfs_getdeviceinfo_res

Enumerations
enum	nfs_opnum4 {   OP_ACCESS = 3 , OP_CLOSE = 4 , OP_COMMIT = 5 , OP_CREATE = 6 ,   OP_DELEGPURGE = 7 , OP_DELEGRETURN = 8 , OP_GETATTR = 9 , OP_GETFH = 10 ,   OP_LINK = 11 , OP_LOCK = 12 , OP_LOCKT = 13 , OP_LOCKU = 14 ,   OP_LOOKUP = 15 , OP_LOOKUPP = 16 , OP_NVERIFY = 17 , OP_OPEN = 18 ,   OP_OPENATTR = 19 , OP_OPEN_CONFIRM = 20 , OP_OPEN_DOWNGRADE = 21 , OP_PUTFH = 22 ,   OP_PUTPUBFH = 23 , OP_PUTROOTFH = 24 , OP_READ = 25 , OP_READDIR = 26 ,   OP_READLINK = 27 , OP_REMOVE = 28 , OP_RENAME = 29 , OP_RENEW = 30 ,   OP_RESTOREFH = 31 , OP_SAVEFH = 32 , OP_SECINFO = 33 , OP_SETATTR = 34 ,   OP_SETCLIENTID = 35 , OP_SETCLIENTID_CONFIRM = 36 , OP_VERIFY = 37 , OP_WRITE = 38 ,   OP_RELEASE_LOCKOWNER = 39 , OP_BACKCHANNEL_CTL = 40 , OP_BIND_CONN_TO_SESSION = 41 , OP_EXCHANGE_ID = 42 ,   OP_CREATE_SESSION = 43 , OP_DESTROY_SESSION = 44 , OP_FREE_STATEID = 45 , OP_GET_DIR_DELEGATION = 46 ,   OP_GETDEVICEINFO = 47 , OP_GETDEVICELIST = 48 , OP_LAYOUTCOMMIT = 49 , OP_LAYOUTGET = 50 ,   OP_LAYOUTRETURN = 51 , OP_SECINFO_NO_NAME = 52 , OP_SEQUENCE = 53 , OP_SET_SSV = 54 ,   OP_TEST_STATEID = 55 , OP_WANT_DELEGATION = 56 , OP_DESTROY_CLIENTID = 57 , OP_RECLAIM_COMPLETE = 58 ,   OP_ILLEGAL = 10044 }
enum	{   EXCHGID4_FLAG_SUPP_MOVED_REFER = 0x00000001 , EXCHGID4_FLAG_SUPP_MOVED_MIGR = 0x00000002 , EXCHGID4_FLAG_BIND_PRINC_STATEID = 0x00000100 , EXCHGID4_FLAG_USE_NON_PNFS = 0x00010000 ,   EXCHGID4_FLAG_USE_PNFS_MDS = 0x00020000 , EXCHGID4_FLAG_USE_PNFS_DS = 0x00040000 , EXCHGID4_FLAG_MASK_PNFS = 0x00070000 , EXCHGID4_FLAG_UPD_CONFIRMED_REC_A = 0x40000000 ,   EXCHGID4_FLAG_CONFIRMED_R = 0x80000000 }
enum	state_protect_how4 { SP4_NONE = 0 , SP4_MACH_CRED = 1 , SP4_SSV = 2 }
enum	channel_dir_from_client4 { CDFC4_FORE = 0x1 , CDFC4_BACK = 0x2 , CDFC4_FORE_OR_BOTH = 0x3 , CDFC4_BACK_OR_BOTH = 0x7 }
enum	channel_dir_from_server4 { CDFS4_FORE = 0x1 , CDFS4_BACK = 0x2 , CDFS4_BOTH = 0x3 }
enum	{   SEQ4_STATUS_CB_PATH_DOWN = 0x00000001 , SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING = 0x00000002 , SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED = 0x00000004 , SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED = 0x00000008 ,   SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED = 0x00000010 , SEQ4_STATUS_ADMIN_STATE_REVOKED = 0x00000020 , SEQ4_STATUS_RECALLABLE_STATE_REVOKED = 0x00000040 , SEQ4_STATUS_LEASE_MOVED = 0x00000080 ,   SEQ4_STATUS_RESTART_RECLAIM_NEEDED = 0x00000100 , SEQ4_STATUS_CB_PATH_DOWN_SESSION = 0x00000200 , SEQ4_STATUS_BACKCHANNEL_FAULT = 0x00000400 , SEQ4_STATUS_DEVID_CHANGED = 0x00000800 ,   SEQ4_STATUS_DEVID_DELETED = 0x00001000 }
enum	stateid_type {   STATEID_OPEN , STATEID_LOCK , STATEID_DELEG_FILE , STATEID_DELEG_DIR ,   STATEID_LAYOUT , STATEID_SPECIAL }
enum	{   ACCESS4_READ = 0x00000001 , ACCESS4_LOOKUP = 0x00000002 , ACCESS4_MODIFY = 0x00000004 , ACCESS4_EXTEND = 0x00000008 ,   ACCESS4_DELETE = 0x00000010 , ACCESS4_EXECUTE = 0x00000020 }
enum	{ READ_LT = 1 , WRITE_LT = 2 , READW_LT = 3 , WRITEW_LT = 4 }
enum	createmode4 { UNCHECKED4 = 0 , GUARDED4 = 1 , EXCLUSIVE4 = 2 , EXCLUSIVE4_1 = 3 }
enum	opentype4 { OPEN4_NOCREATE = 0 , OPEN4_CREATE = 1 }
enum	{   OPEN4_SHARE_ACCESS_READ = 0x00000001 , OPEN4_SHARE_ACCESS_WRITE = 0x00000002 , OPEN4_SHARE_ACCESS_BOTH = 0x00000003 , OPEN4_SHARE_DENY_NONE = 0x00000000 ,   OPEN4_SHARE_DENY_READ = 0x00000001 , OPEN4_SHARE_DENY_WRITE = 0x00000002 , OPEN4_SHARE_DENY_BOTH = 0x00000003 , OPEN4_SHARE_ACCESS_WANT_DELEG_MASK = 0xFF00 ,   OPEN4_SHARE_ACCESS_WANT_NO_PREFERENCE = 0x0000 , OPEN4_SHARE_ACCESS_WANT_READ_DELEG = 0x0100 , OPEN4_SHARE_ACCESS_WANT_WRITE_DELEG = 0x0200 , OPEN4_SHARE_ACCESS_WANT_ANY_DELEG = 0x0300 ,   OPEN4_SHARE_ACCESS_WANT_NO_DELEG = 0x0400 , OPEN4_SHARE_ACCESS_WANT_CANCEL = 0x0500 , OPEN4_SHARE_ACCESS_WANT_SIGNAL_DELEG_WHEN_RESRC_AVAIL = 0x10000 , OPEN4_SHARE_ACCESS_WANT_PUSH_DELEG_WHEN_UNCONTENDED = 0x20000 }
enum	open_delegation_type4 { OPEN_DELEGATE_NONE = 0 , OPEN_DELEGATE_READ = 1 , OPEN_DELEGATE_WRITE = 2 , OPEN_DELEGATE_NONE_EXT = 3 }
enum	open_claim_type4 {   CLAIM_NULL = 0 , CLAIM_PREVIOUS = 1 , CLAIM_DELEGATE_CUR = 2 , CLAIM_DELEGATE_PREV = 3 ,   CLAIM_FH = 4 , CLAIM_DELEG_CUR_FH = 5 , CLAIM_DELEG_PREV_FH = 6 }
enum	why_no_delegation4 {   WND4_NOT_WANTED = 0 , WND4_CONTENTION = 1 , WND4_RESOURCE = 2 , WND4_NOT_SUPP_FTYPE = 3 ,   WND4_WRITE_DELEG_NOT_SUPP_FTYPE = 4 , WND4_NOT_SUPP_UPGRADE = 5 , WND4_NOT_SUPP_DOWNGRADE = 6 , WND4_CANCELED = 7 ,   WND4_IS_DIR = 8 }
enum	{ OPEN4_RESULT_CONFIRM = 0x00000002 , OPEN4_RESULT_LOCKTYPE_POSIX = 0x00000004 , OPEN4_RESULT_PRESERVE_UNLINKED = 0x00000008 , OPEN4_RESULT_MAY_NOTIFY_LOCK = 0x00000020 }
enum	time_how4 { SET_TO_SERVER_TIME4 = 0 , SET_TO_CLIENT_TIME4 = 1 }
enum	stable_how4 { UNSTABLE4 = 0 , DATA_SYNC4 = 1 , FILE_SYNC4 = 2 }
enum	sec_flavor { RPC_GSS_SVC_NONE = 1 , RPC_GSS_SVC_INTEGRITY = 2 , RPC_GSS_SVC_PRIVACY = 3 }
enum	secinfo_no_name_type { SECINFO_STYLE4_CURRENT_FH = 0 , SECINFO_STYLE4_PARENT = 1 }

Functions
int	nfs41_exchange_id (IN nfs41_rpc_clnt *rpc, IN client_owner4 *owner, IN uint32_t flags_in, OUT nfs41_exchange_id_res *res_out)
int	nfs41_create_session (IN nfs41_client *clnt, OUT nfs41_session *session, IN bool_t try_recovery)
enum nfsstat4	nfs41_bind_conn_to_session (IN nfs41_rpc_clnt *rpc, IN const unsigned char *sessionid, IN enum channel_dir_from_client4 dir)
int	nfs41_destroy_session (IN nfs41_session *session)
int	nfs41_destroy_clientid (IN nfs41_rpc_clnt *rpc, IN uint64_t clientid)
int	nfs41_send_sequence (IN nfs41_session *session)
enum nfsstat4	nfs41_reclaim_complete (IN nfs41_session *session)
int	nfs41_lookup (IN nfs41_root *root, IN nfs41_session *session, IN OUT nfs41_abs_path *path, OUT OPTIONAL nfs41_path_fh *parent_out, OUT OPTIONAL nfs41_path_fh *target_out, OUT OPTIONAL nfs41_file_info *info_out, OUT nfs41_session **session_out)
int	nfs41_open (IN nfs41_session *session, IN nfs41_path_fh *parent, IN nfs41_path_fh *file, IN state_owner4 *owner, IN open_claim4 *claim, IN uint32_t allow, IN uint32_t deny, IN uint32_t create, IN uint32_t how_mode, IN OPTIONAL nfs41_file_info *createattrs, IN bool_t try_recovery, OUT stateid4 *stateid, OUT open_delegation4 *delegation, OUT OPTIONAL nfs41_file_info *info)
int	nfs41_create (IN nfs41_session *session, IN uint32_t type, IN nfs41_file_info *createattrs, IN OPTIONAL const char *symlink, IN nfs41_path_fh *parent, OUT nfs41_path_fh *file, OUT nfs41_file_info *info)
int	nfs41_close (IN nfs41_session *session, IN nfs41_path_fh *file, IN stateid_arg *stateid)
int	nfs41_write (IN nfs41_session *session, IN nfs41_path_fh *file, IN stateid_arg *stateid, IN unsigned char *data, IN uint32_t data_len, IN uint64_t offset, IN enum stable_how4 stable, OUT uint32_t *bytes_written, OUT nfs41_write_verf *verf, OUT nfs41_file_info *cinfo)
int	nfs41_read (IN nfs41_session *session, IN nfs41_path_fh *file, IN stateid_arg *stateid, IN uint64_t offset, IN uint32_t count, OUT unsigned char *data_out, OUT uint32_t *data_len_out, OUT bool_t *eof_out)
int	nfs41_commit (IN nfs41_session *session, IN nfs41_path_fh *file, IN uint64_t offset, IN uint32_t count, IN bool_t do_getattr, OUT nfs41_write_verf *verf, OUT nfs41_file_info *cinfo)
int	nfs41_lock (IN nfs41_session *session, IN nfs41_path_fh *file, IN state_owner4 *owner, IN uint32_t type, IN uint64_t offset, IN uint64_t length, IN bool_t reclaim, IN bool_t try_recovery, IN OUT stateid_arg *stateid)
int	nfs41_unlock (IN nfs41_session *session, IN nfs41_path_fh *file, IN uint64_t offset, IN uint64_t length, IN OUT stateid_arg *stateid)
stateid4 *	nfs41_lock_stateid_copy (IN nfs41_lock_state *lock_state, IN OUT stateid4 *dest)
int	nfs41_readdir (IN nfs41_session *session, IN nfs41_path_fh *file, IN bitmap4 *attr_request, IN nfs41_readdir_cookie *cookie, OUT unsigned char *entries, IN OUT uint32_t *entries_len, OUT bool_t *eof_out)
int	nfs41_getattr (IN nfs41_session *session, IN OPTIONAL nfs41_path_fh *file, IN bitmap4 *attr_request, OUT nfs41_file_info *info)
int	nfs41_superblock_getattr (IN nfs41_session *session, IN nfs41_path_fh *file, IN bitmap4 *attr_request, OUT nfs41_file_info *info, OUT bool_t *supports_named_attrs)
int	nfs41_cached_getattr (IN nfs41_session *session, IN nfs41_path_fh *file, OUT nfs41_file_info *info)
int	nfs41_remove (IN nfs41_session *session, IN nfs41_path_fh *parent, IN const nfs41_component *target, IN uint64_t fileid)
int	nfs41_rename (IN nfs41_session *session, IN nfs41_path_fh *src_dir, IN const nfs41_component *src_name, IN nfs41_path_fh *dst_dir, IN const nfs41_component *dst_name)
int	nfs41_setattr (IN nfs41_session *session, IN nfs41_path_fh *file, IN stateid_arg *stateid, IN nfs41_file_info *info)
int	nfs41_link (IN nfs41_session *session, IN nfs41_path_fh *src, IN nfs41_path_fh *dst_dir, IN const nfs41_component *target, OUT nfs41_file_info *cinfo)
int	nfs41_symlink_target (IN nfs41_session *session, IN nfs41_path_fh *file, OUT nfs41_abs_path *target)
int	nfs41_symlink_follow (IN nfs41_root *root, IN nfs41_session *session, IN nfs41_path_fh *symlink, OUT nfs41_file_info *info)
int	nfs41_readlink (IN nfs41_session *session, IN nfs41_path_fh *file, IN uint32_t max_len, OUT char *link_out, OUT uint32_t *len_out)
int	nfs41_access (IN nfs41_session *session, IN nfs41_path_fh *file, IN uint32_t requested, OUT uint32_t *supported OPTIONAL, OUT uint32_t *access OPTIONAL)
enum nfsstat4	nfs41_want_delegation (IN nfs41_session *session, IN nfs41_path_fh *file, IN deleg_claim4 *claim, IN uint32_t want, IN bool_t try_recovery, OUT open_delegation4 *delegation)
int	nfs41_delegpurge (IN nfs41_session *session)
int	nfs41_delegreturn (IN nfs41_session *session, IN nfs41_path_fh *file, IN stateid_arg *stateid, IN bool_t try_recovery)
enum nfsstat4	nfs41_fs_locations (IN nfs41_session *session, IN nfs41_path_fh *parent, IN const nfs41_component *name, OUT fs_locations4 *locations)
int	nfs41_secinfo (IN nfs41_session *session, IN nfs41_path_fh *file, IN const nfs41_component *name, OUT nfs41_secinfo_info *secinfo)
int	nfs41_secinfo_noname (IN nfs41_session *session, IN nfs41_path_fh *file, OUT nfs41_secinfo_info *secinfo)
enum nfsstat4	nfs41_free_stateid (IN nfs41_session *session, IN stateid4 *stateid)
enum nfsstat4	nfs41_test_stateid (IN nfs41_session *session, IN stateid_arg *stateid_array, IN uint32_t count, OUT uint32_t *status_array)
enum nfsstat4	pnfs_rpc_layoutget (IN nfs41_session *session, IN nfs41_path_fh *file, IN stateid_arg *stateid, IN enum pnfs_iomode iomode, IN uint64_t offset, IN uint64_t minlength, IN uint64_t length, OUT pnfs_layoutget_res_ok *layoutget_res)
enum nfsstat4	pnfs_rpc_layoutcommit (IN nfs41_session *session, IN nfs41_path_fh *file, IN stateid4 *stateid, IN uint64_t offset, IN uint64_t length, IN OPTIONAL uint64_t *new_last_offset, IN OPTIONAL nfstime4 *new_time_modify, OUT nfs41_file_info *info)
enum nfsstat4	pnfs_rpc_layoutreturn (IN nfs41_session *session, IN nfs41_path_fh *file, IN enum pnfs_layout_type type, IN enum pnfs_iomode iomode, IN uint64_t offset, IN uint64_t length, IN stateid4 *stateid, OUT pnfs_layoutreturn_res *layoutreturn_res)
enum nfsstat4	pnfs_rpc_getdeviceinfo (IN nfs41_session *session, IN unsigned char *deviceid, OUT pnfs_file_device *device)
enum nfsstat4	nfs41_rpc_openattr (IN nfs41_session *session, IN nfs41_path_fh *file, IN bool_t createdir, OUT nfs41_fh *fh_out)

Macro Definition Documentation

MAX_OID_LEN

#define MAX_OID_LEN   128

Definition at line 868 of file nfs41_ops.h.

MAX_SECINFOS

#define MAX_SECINFOS   6

Definition at line 881 of file nfs41_ops.h.

RPCSEC_GSS

#define RPCSEC_GSS   6

Definition at line 867 of file nfs41_ops.h.

Typedef Documentation

createhow4

typedef struct __createhow4 createhow4

createtype4

typedef struct __createtype4 createtype4

deleg_claim4

typedef struct __deleg_claim4 deleg_claim4

exist_lock_owner4

typedef struct __exist_lock_owner4 exist_lock_owner4

lock_res_denied

typedef struct __lock_res_denied lock_res_denied

lock_res_ok

typedef struct __lock_res_ok lock_res_ok

locker4

typedef struct __locker4 locker4

nfs41_access_args

typedef struct __nfs41_access_args nfs41_access_args

nfs41_access_res

typedef struct __nfs41_access_res nfs41_access_res

nfs41_bind_conn_to_session_args

typedef struct __nfs41_bind_conn_to_session_args nfs41_bind_conn_to_session_args

nfs41_bind_conn_to_session_res

typedef struct __nfs41_bind_conn_to_session_res nfs41_bind_conn_to_session_res

nfs41_callback_secparms

typedef struct __nfs41_callback_sec_parms nfs41_callback_secparms

nfs41_commit_args

typedef struct __nfs41_commit_args nfs41_commit_args

nfs41_commit_res

typedef struct __nfs41_commit_res nfs41_commit_res

nfs41_create_args

typedef struct __nfs41_create_args nfs41_create_args

nfs41_create_res

typedef struct __nfs41_create_res nfs41_create_res

nfs41_create_session_args

typedef struct __nfs41_create_session_args nfs41_create_session_args

nfs41_create_session_res

typedef struct __nfs41_create_session_res nfs41_create_session_res

nfs41_delegpurge_res

typedef struct __nfs41_delegpurge_res nfs41_delegpurge_res

nfs41_delegreturn_args

typedef struct __nfs41_delegreturn_args nfs41_delegreturn_args

nfs41_delegreturn_res

typedef struct __nfs41_delegreturn_res nfs41_delegreturn_res

nfs41_destroy_clientid_args

typedef struct __nfs41_destroy_clientid_args nfs41_destroy_clientid_args

nfs41_destroy_clientid_res

typedef struct __nfs41_destroy_clientid_res nfs41_destroy_clientid_res

nfs41_destroy_session_args

typedef struct __nfs41_destroy_session_args nfs41_destroy_session_args

nfs41_destroy_session_res

typedef struct __nfs41_destroy_session_res nfs41_destroy_session_res

nfs41_exchange_id_args

typedef struct __nfs41_exchange_id_args nfs41_exchange_id_args

nfs41_exchange_id_res

typedef struct __nfs41_exchange_id_res nfs41_exchange_id_res

nfs41_free_stateid_args

typedef struct __nfs41_free_stateid_args nfs41_free_stateid_args

nfs41_free_stateid_res

typedef struct __nfs41_free_stateid_res nfs41_free_stateid_res

nfs41_getattr_args

typedef struct __nfs41_getattr_args nfs41_getattr_args

nfs41_getattr_res

typedef struct __nfs41_getattr_res nfs41_getattr_res

nfs41_getfh_res

typedef struct __nfs41_getfh_res nfs41_getfh_res

nfs41_link_args

typedef struct __nfs41_link_args nfs41_link_args

nfs41_link_res

typedef struct __nfs41_link_res nfs41_link_res

nfs41_lock_args

typedef struct __nfs41_lock_args nfs41_lock_args

nfs41_lock_res

typedef struct __nfs41_lock_res nfs41_lock_res

nfs41_lockt_args

typedef struct __nfs41_lockt_args nfs41_lockt_args

nfs41_lockt_res

typedef struct __nfs41_lockt_res nfs41_lockt_res

nfs41_locku_args

typedef struct __nfs41_locku_args nfs41_locku_args

nfs41_locku_res

typedef struct __nfs41_locku_res nfs41_locku_res

nfs41_lookup_args

typedef struct __nfs41_lookup_args nfs41_lookup_args

nfs41_lookup_res

typedef struct __nfs41_lookup_res nfs41_lookup_res

nfs41_op_close_args

typedef struct __nfs41_op_close_args nfs41_op_close_args

nfs41_op_close_res

typedef struct __nfs41_op_close_res nfs41_op_close_res

nfs41_op_open_args

typedef struct __nfs41_op_open_args nfs41_op_open_args

nfs41_op_open_res

typedef struct __nfs41_op_open_res nfs41_op_open_res

nfs41_op_open_res_ok

typedef struct __nfs41_op_open_res_ok nfs41_op_open_res_ok

nfs41_openattr_args

typedef struct __nfs41_openattr_args nfs41_openattr_args

nfs41_openattr_res

typedef struct __nfs41_openattr_res nfs41_openattr_res

nfs41_putfh_args

typedef struct __nfs41_putfh_args nfs41_putfh_args

nfs41_putfh_res

typedef struct __nfs41_putfh_res nfs41_putfh_res

nfs41_putrootfh_res

typedef struct __nfs41_putrootfh_res nfs41_putrootfh_res

nfs41_read_args

typedef struct __nfs41_read_args nfs41_read_args

nfs41_read_res

typedef struct __nfs41_read_res nfs41_read_res

nfs41_read_res_ok

typedef struct __nfs41_read_res_ok nfs41_read_res_ok

nfs41_readdir_args

typedef struct __nfs41_readdir_args nfs41_readdir_args

nfs41_readdir_entry

typedef struct __nfs41_readdir_entry nfs41_readdir_entry

nfs41_readdir_list

typedef struct __nfs41_readdir_list nfs41_readdir_list

nfs41_readdir_res

typedef struct __nfs41_readdir_res nfs41_readdir_res

nfs41_readlink_res

typedef struct __nfs41_readlink_res nfs41_readlink_res

nfs41_reclaim_complete_res

typedef struct __nfs41_reclaim_complete_res nfs41_reclaim_complete_res

nfs41_remove_args

typedef struct __nfs41_remove_args nfs41_remove_args

nfs41_remove_res

typedef struct __nfs41_remove_res nfs41_remove_res

nfs41_rename_args

typedef struct __nfs41_rename_args nfs41_rename_args

nfs41_rename_res

typedef struct __nfs41_rename_res nfs41_rename_res

nfs41_restorefh_res

typedef struct __nfs41_restorefh_savefh_res nfs41_restorefh_res

nfs41_savefh_res

typedef struct __nfs41_restorefh_savefh_res nfs41_savefh_res

nfs41_secinfo_args

typedef struct __nfs41_secinfo_args nfs41_secinfo_args

nfs41_secinfo_info

typedef struct __nfs41_secinfo_info nfs41_secinfo_info

nfs41_secinfo_noname_args

typedef struct __nfs41_secinfo_noname_args nfs41_secinfo_noname_args

nfs41_secinfo_noname_res

typedef struct __nfs41_secinfo_noname_res nfs41_secinfo_noname_res

nfs41_sequence_args

typedef struct __nfs41_sequence_args nfs41_sequence_args

nfs41_sequence_res

typedef struct __nfs41_sequence_res nfs41_sequence_res

nfs41_sequence_res_ok

typedef struct __nfs41_sequence_res_ok nfs41_sequence_res_ok

nfs41_setattr_args

typedef struct __nfs41_setattr_args nfs41_setattr_args

nfs41_setattr_res

typedef struct __nfs41_setattr_res nfs41_setattr_res

nfs41_test_stateid_args

typedef struct __nfs41_test_stateid_args nfs41_test_stateid_args

nfs41_test_stateid_res

typedef struct __nfs41_test_stateid_res nfs41_test_stateid_res

nfs41_want_delegation_args

typedef struct __nfs41_want_delegation_args nfs41_want_delegation_args

nfs41_want_delegation_res

typedef struct __nfs41_want_delegation_res nfs41_want_delegation_res

nfs41_write_args

typedef struct __nfs41_write_args nfs41_write_args

nfs41_write_res

typedef struct __nfs41_write_res nfs41_write_res

nfs41_write_res_ok

typedef struct __nfs41_write_res_ok nfs41_write_res_ok

open_claim4

typedef struct __open_claim4 open_claim4

open_to_lock_owner4

typedef struct __open_to_lock_owner4 open_to_lock_owner4

openflag4

typedef struct __openflag4 openflag4

pnfs_getdeviceinfo_args

typedef struct __pnfs_getdeviceinfo_args pnfs_getdeviceinfo_args

pnfs_getdeviceinfo_res

typedef struct __pnfs_getdeviceinfo_res pnfs_getdeviceinfo_res

pnfs_getdeviceinfo_res_ok

typedef struct __pnfs_getdeviceinfo_res_ok pnfs_getdeviceinfo_res_ok

pnfs_layoutcommit_args

typedef struct __pnfs_layoutcommit_args pnfs_layoutcommit_args

pnfs_layoutcommit_res

typedef struct __pnfs_layoutcommit_res pnfs_layoutcommit_res

pnfs_layoutget_args

typedef struct __pnfs_layoutget_args pnfs_layoutget_args

pnfs_layoutget_res

typedef struct __pnfs_layoutget_res pnfs_layoutget_res

pnfs_layoutget_res_ok

typedef struct __pnfs_layoutget_res_ok pnfs_layoutget_res_ok

pnfs_layoutreturn_args

typedef struct __pnfs_layoutreturn_args pnfs_layoutreturn_args

pnfs_layoutreturn_res

typedef struct __pnfs_layoutreturn_res pnfs_layoutreturn_res

specdata4

typedef struct __specdata4 specdata4

state_protect4_a

typedef struct __state_protect4_a state_protect4_a

state_protect4_r

typedef struct __state_protect4_r state_protect4_r

stateid_arg

typedef struct __stateid_arg stateid_arg

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
EXCHGID4_FLAG_SUPP_MOVED_REFER
EXCHGID4_FLAG_SUPP_MOVED_MIGR
EXCHGID4_FLAG_BIND_PRINC_STATEID
EXCHGID4_FLAG_USE_NON_PNFS
EXCHGID4_FLAG_USE_PNFS_MDS
EXCHGID4_FLAG_USE_PNFS_DS
EXCHGID4_FLAG_MASK_PNFS
EXCHGID4_FLAG_UPD_CONFIRMED_REC_A
EXCHGID4_FLAG_CONFIRMED_R

Definition at line 94 of file nfs41_ops.h.

     {
    EXCHGID4_FLAG_SUPP_MOVED_REFER      = 0x00000001,
    EXCHGID4_FLAG_SUPP_MOVED_MIGR       = 0x00000002,
 
    EXCHGID4_FLAG_BIND_PRINC_STATEID    = 0x00000100,
 
    EXCHGID4_FLAG_USE_NON_PNFS          = 0x00010000,
    EXCHGID4_FLAG_USE_PNFS_MDS          = 0x00020000,
    EXCHGID4_FLAG_USE_PNFS_DS           = 0x00040000,
 
    EXCHGID4_FLAG_MASK_PNFS             = 0x00070000,
 
    EXCHGID4_FLAG_UPD_CONFIRMED_REC_A   = 0x40000000,
    EXCHGID4_FLAG_CONFIRMED_R           = 0x80000000
};

anonymous enum

anonymous enum

Enumerator
SEQ4_STATUS_CB_PATH_DOWN
SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING
SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED
SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED
SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED
SEQ4_STATUS_ADMIN_STATE_REVOKED
SEQ4_STATUS_RECALLABLE_STATE_REVOKED
SEQ4_STATUS_LEASE_MOVED
SEQ4_STATUS_RESTART_RECLAIM_NEEDED
SEQ4_STATUS_CB_PATH_DOWN_SESSION
SEQ4_STATUS_BACKCHANNEL_FAULT
SEQ4_STATUS_DEVID_CHANGED
SEQ4_STATUS_DEVID_DELETED

Definition at line 236 of file nfs41_ops.h.

     {
    SEQ4_STATUS_CB_PATH_DOWN                = 0x00000001,
    SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING    = 0x00000002,
    SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED     = 0x00000004,
    SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED   = 0x00000008,
    SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED  = 0x00000010,
    SEQ4_STATUS_ADMIN_STATE_REVOKED         = 0x00000020,
    SEQ4_STATUS_RECALLABLE_STATE_REVOKED    = 0x00000040,
    SEQ4_STATUS_LEASE_MOVED                 = 0x00000080,
    SEQ4_STATUS_RESTART_RECLAIM_NEEDED      = 0x00000100,
    SEQ4_STATUS_CB_PATH_DOWN_SESSION        = 0x00000200,
    SEQ4_STATUS_BACKCHANNEL_FAULT           = 0x00000400,
    SEQ4_STATUS_DEVID_CHANGED               = 0x00000800,
    SEQ4_STATUS_DEVID_DELETED               = 0x00001000
};

anonymous enum

anonymous enum

Enumerator
ACCESS4_READ
ACCESS4_LOOKUP
ACCESS4_MODIFY
ACCESS4_EXTEND
ACCESS4_DELETE
ACCESS4_EXECUTE

Definition at line 292 of file nfs41_ops.h.

     {
    ACCESS4_READ            = 0x00000001,
    ACCESS4_LOOKUP          = 0x00000002,
    ACCESS4_MODIFY          = 0x00000004,
    ACCESS4_EXTEND          = 0x00000008,
    ACCESS4_DELETE          = 0x00000010,
    ACCESS4_EXECUTE         = 0x00000020
};

anonymous enum

anonymous enum

Enumerator
READ_LT
WRITE_LT
READW_LT
WRITEW_LT

Definition at line 398 of file nfs41_ops.h.

     {
    READ_LT                 = 1,
    WRITE_LT                = 2,
    READW_LT                = 3,    /* blocking read */
    WRITEW_LT               = 4     /* blocking write */
};

anonymous enum

anonymous enum

Enumerator
OPEN4_SHARE_ACCESS_READ
OPEN4_SHARE_ACCESS_WRITE
OPEN4_SHARE_ACCESS_BOTH
OPEN4_SHARE_DENY_NONE
OPEN4_SHARE_DENY_READ
OPEN4_SHARE_DENY_WRITE
OPEN4_SHARE_DENY_BOTH
OPEN4_SHARE_ACCESS_WANT_DELEG_MASK
OPEN4_SHARE_ACCESS_WANT_NO_PREFERENCE
OPEN4_SHARE_ACCESS_WANT_READ_DELEG
OPEN4_SHARE_ACCESS_WANT_WRITE_DELEG
OPEN4_SHARE_ACCESS_WANT_ANY_DELEG
OPEN4_SHARE_ACCESS_WANT_NO_DELEG
OPEN4_SHARE_ACCESS_WANT_CANCEL
OPEN4_SHARE_ACCESS_WANT_SIGNAL_DELEG_WHEN_RESRC_AVAIL
OPEN4_SHARE_ACCESS_WANT_PUSH_DELEG_WHEN_UNCONTENDED

Definition at line 563 of file nfs41_ops.h.

     {
    OPEN4_SHARE_ACCESS_READ     = 0x00000001,
    OPEN4_SHARE_ACCESS_WRITE    = 0x00000002,
    OPEN4_SHARE_ACCESS_BOTH     = 0x00000003,
 
    OPEN4_SHARE_DENY_NONE       = 0x00000000,
    OPEN4_SHARE_DENY_READ       = 0x00000001,
    OPEN4_SHARE_DENY_WRITE      = 0x00000002,
    OPEN4_SHARE_DENY_BOTH       = 0x00000003,
 
    OPEN4_SHARE_ACCESS_WANT_DELEG_MASK      = 0xFF00,
    OPEN4_SHARE_ACCESS_WANT_NO_PREFERENCE   = 0x0000,
    OPEN4_SHARE_ACCESS_WANT_READ_DELEG      = 0x0100,
    OPEN4_SHARE_ACCESS_WANT_WRITE_DELEG     = 0x0200,
    OPEN4_SHARE_ACCESS_WANT_ANY_DELEG       = 0x0300,
    OPEN4_SHARE_ACCESS_WANT_NO_DELEG        = 0x0400,
    OPEN4_SHARE_ACCESS_WANT_CANCEL          = 0x0500,
 
    OPEN4_SHARE_ACCESS_WANT_SIGNAL_DELEG_WHEN_RESRC_AVAIL = 0x10000,
    OPEN4_SHARE_ACCESS_WANT_PUSH_DELEG_WHEN_UNCONTENDED = 0x20000
};

anonymous enum

anonymous enum

Enumerator
OPEN4_RESULT_CONFIRM
OPEN4_RESULT_LOCKTYPE_POSIX
OPEN4_RESULT_PRESERVE_UNLINKED
OPEN4_RESULT_MAY_NOTIFY_LOCK

Definition at line 650 of file nfs41_ops.h.

     {
    OPEN4_RESULT_CONFIRM            = 0x00000002,
    OPEN4_RESULT_LOCKTYPE_POSIX     = 0x00000004,
    OPEN4_RESULT_PRESERVE_UNLINKED  = 0x00000008,
    OPEN4_RESULT_MAY_NOTIFY_LOCK    = 0x00000020
};

channel_dir_from_client4

enum channel_dir_from_client4

Enumerator
CDFC4_FORE
CDFC4_BACK
CDFC4_FORE_OR_BOTH
CDFC4_BACK_OR_BOTH

Definition at line 182 of file nfs41_ops.h.

                              {
    CDFC4_FORE              = 0x1,
    CDFC4_BACK              = 0x2,
    CDFC4_FORE_OR_BOTH      = 0x3,
    CDFC4_BACK_OR_BOTH      = 0x7
};

channel_dir_from_server4

enum channel_dir_from_server4

Enumerator
CDFS4_FORE
CDFS4_BACK
CDFS4_BOTH

Definition at line 189 of file nfs41_ops.h.

                              {
    CDFS4_FORE              = 0x1,
    CDFS4_BACK              = 0x2,
    CDFS4_BOTH              = 0x3
};

createmode4

enum createmode4

Enumerator
UNCHECKED4
GUARDED4
EXCLUSIVE4
EXCLUSIVE4_1

Definition at line 539 of file nfs41_ops.h.

                 {
    UNCHECKED4      = 0,
    GUARDED4        = 1,
    EXCLUSIVE4      = 2,
    EXCLUSIVE4_1    = 3
};

nfs_opnum4

enum nfs_opnum4

Enumerator
OP_ACCESS
OP_CLOSE
OP_COMMIT
OP_CREATE
OP_DELEGPURGE
OP_DELEGRETURN
OP_GETATTR
OP_GETFH
OP_LINK
OP_LOCK
OP_LOCKT
OP_LOCKU
OP_LOOKUP
OP_LOOKUPP
OP_NVERIFY
OP_OPEN
OP_OPENATTR
OP_OPEN_CONFIRM
OP_OPEN_DOWNGRADE
OP_PUTFH
OP_PUTPUBFH
OP_PUTROOTFH
OP_READ
OP_READDIR
OP_READLINK
OP_REMOVE
OP_RENAME
OP_RENEW
OP_RESTOREFH
OP_SAVEFH
OP_SECINFO
OP_SETATTR
OP_SETCLIENTID
OP_SETCLIENTID_CONFIRM
OP_VERIFY
OP_WRITE
OP_RELEASE_LOCKOWNER
OP_BACKCHANNEL_CTL
OP_BIND_CONN_TO_SESSION
OP_EXCHANGE_ID
OP_CREATE_SESSION
OP_DESTROY_SESSION
OP_FREE_STATEID
OP_GET_DIR_DELEGATION
OP_GETDEVICEINFO
OP_GETDEVICELIST
OP_LAYOUTCOMMIT
OP_LAYOUTGET
OP_LAYOUTRETURN
OP_SECINFO_NO_NAME
OP_SEQUENCE
OP_SET_SSV
OP_TEST_STATEID
OP_WANT_DELEGATION
OP_DESTROY_CLIENTID
OP_RECLAIM_COMPLETE
OP_ILLEGAL

Definition at line 30 of file nfs41_ops.h.

                {
    OP_ACCESS               = 3,
    OP_CLOSE                = 4,
    OP_COMMIT               = 5,
    OP_CREATE               = 6,
    OP_DELEGPURGE           = 7,
    OP_DELEGRETURN          = 8,
    OP_GETATTR              = 9,
    OP_GETFH                = 10,
    OP_LINK                 = 11,
    OP_LOCK                 = 12,
    OP_LOCKT                = 13,
    OP_LOCKU                = 14,
    OP_LOOKUP               = 15,
    OP_LOOKUPP              = 16,
    OP_NVERIFY              = 17,
    OP_OPEN                 = 18,
    OP_OPENATTR             = 19,
    OP_OPEN_CONFIRM         = 20, /* Mandatory not-to-implement */
    OP_OPEN_DOWNGRADE       = 21,
    OP_PUTFH                = 22,
    OP_PUTPUBFH             = 23,
    OP_PUTROOTFH            = 24,
    OP_READ                 = 25,
    OP_READDIR              = 26,
    OP_READLINK             = 27,
    OP_REMOVE               = 28,
    OP_RENAME               = 29,
    OP_RENEW                = 30, /* Mandatory not-to-implement */
    OP_RESTOREFH            = 31,
    OP_SAVEFH               = 32,
    OP_SECINFO              = 33,
    OP_SETATTR              = 34,
    OP_SETCLIENTID          = 35, /* Mandatory not-to-implement */
    OP_SETCLIENTID_CONFIRM  = 36, /* Mandatory not-to-implement */
    OP_VERIFY               = 37,
    OP_WRITE                = 38,
    OP_RELEASE_LOCKOWNER    = 39, /* Mandatory not-to-implement */
 
    /* new operations for NFSv4.1 */
    OP_BACKCHANNEL_CTL      = 40,
    OP_BIND_CONN_TO_SESSION = 41,
    OP_EXCHANGE_ID          = 42,
    OP_CREATE_SESSION       = 43,
    OP_DESTROY_SESSION      = 44,
    OP_FREE_STATEID         = 45,
    OP_GET_DIR_DELEGATION   = 46,
    OP_GETDEVICEINFO        = 47,
    OP_GETDEVICELIST        = 48,
    OP_LAYOUTCOMMIT         = 49,
    OP_LAYOUTGET            = 50,
    OP_LAYOUTRETURN         = 51,
    OP_SECINFO_NO_NAME      = 52,
    OP_SEQUENCE             = 53,
    OP_SET_SSV              = 54,
    OP_TEST_STATEID         = 55,
    OP_WANT_DELEGATION      = 56,
    OP_DESTROY_CLIENTID     = 57,
    OP_RECLAIM_COMPLETE     = 58,
    OP_ILLEGAL              = 10044
};

open_claim_type4

enum open_claim_type4

Enumerator
CLAIM_NULL
CLAIM_PREVIOUS
CLAIM_DELEGATE_CUR
CLAIM_DELEGATE_PREV
CLAIM_FH
CLAIM_DELEG_CUR_FH
CLAIM_DELEG_PREV_FH

Definition at line 592 of file nfs41_ops.h.

                      {
    CLAIM_NULL              = 0,
    CLAIM_PREVIOUS          = 1,
    CLAIM_DELEGATE_CUR      = 2,
    CLAIM_DELEGATE_PREV     = 3,
    CLAIM_FH                = 4,
    CLAIM_DELEG_CUR_FH      = 5,
    CLAIM_DELEG_PREV_FH     = 6
};

open_delegation_type4

enum open_delegation_type4

Enumerator
OPEN_DELEGATE_NONE
OPEN_DELEGATE_READ
OPEN_DELEGATE_WRITE
OPEN_DELEGATE_NONE_EXT

Definition at line 585 of file nfs41_ops.h.

                           {
    OPEN_DELEGATE_NONE      = 0,
    OPEN_DELEGATE_READ      = 1,
    OPEN_DELEGATE_WRITE     = 2,
    OPEN_DELEGATE_NONE_EXT  = 3
};

opentype4

enum opentype4

Enumerator
OPEN4_NOCREATE
OPEN4_CREATE

Definition at line 552 of file nfs41_ops.h.

               {
    OPEN4_NOCREATE  = 0,
    OPEN4_CREATE    = 1
};

sec_flavor

enum sec_flavor

Enumerator
RPC_GSS_SVC_NONE
RPC_GSS_SVC_INTEGRITY
RPC_GSS_SVC_PRIVACY

Definition at line 861 of file nfs41_ops.h.

                {
    RPC_GSS_SVC_NONE = 1,
    RPC_GSS_SVC_INTEGRITY = 2,
    RPC_GSS_SVC_PRIVACY = 3,
};

secinfo_no_name_type

enum secinfo_no_name_type

Enumerator
SECINFO_STYLE4_CURRENT_FH
SECINFO_STYLE4_PARENT

Definition at line 884 of file nfs41_ops.h.

                          {
    SECINFO_STYLE4_CURRENT_FH = 0,
    SECINFO_STYLE4_PARENT = 1
};

stable_how4

enum stable_how4

Enumerator
UNSTABLE4
DATA_SYNC4
FILE_SYNC4

Definition at line 835 of file nfs41_ops.h.

                 {
    UNSTABLE4       = 0,
    DATA_SYNC4      = 1,
    FILE_SYNC4      = 2
};

state_protect_how4

enum state_protect_how4

Enumerator
SP4_NONE
SP4_MACH_CRED
SP4_SSV

Definition at line 110 of file nfs41_ops.h.

             {
    SP4_NONE        = 0,
    SP4_MACH_CRED   = 1,
    SP4_SSV         = 2
} state_protect_how4;

stateid_type

enum stateid_type

Enumerator
STATEID_OPEN
STATEID_LOCK
STATEID_DELEG_FILE
STATEID_DELEG_DIR
STATEID_LAYOUT
STATEID_SPECIAL

Definition at line 275 of file nfs41_ops.h.

                  {
    STATEID_OPEN,
    STATEID_LOCK,
    STATEID_DELEG_FILE,
    STATEID_DELEG_DIR,
    STATEID_LAYOUT,
    STATEID_SPECIAL
};

time_how4

enum time_how4

Enumerator
SET_TO_SERVER_TIME4
SET_TO_CLIENT_TIME4

Definition at line 776 of file nfs41_ops.h.

               {
    SET_TO_SERVER_TIME4 = 0,
    SET_TO_CLIENT_TIME4 = 1
};

why_no_delegation4

enum why_no_delegation4

Enumerator
WND4_NOT_WANTED
WND4_CONTENTION
WND4_RESOURCE
WND4_NOT_SUPP_FTYPE
WND4_WRITE_DELEG_NOT_SUPP_FTYPE
WND4_NOT_SUPP_UPGRADE
WND4_NOT_SUPP_DOWNGRADE
WND4_CANCELED
WND4_IS_DIR

Definition at line 602 of file nfs41_ops.h.

                        {
    WND4_NOT_WANTED         = 0,
    WND4_CONTENTION         = 1,
    WND4_RESOURCE           = 2,
    WND4_NOT_SUPP_FTYPE     = 3,
    WND4_WRITE_DELEG_NOT_SUPP_FTYPE = 4,
    WND4_NOT_SUPP_UPGRADE   = 5,
    WND4_NOT_SUPP_DOWNGRADE = 6,
    WND4_CANCELED           = 7,
    WND4_IS_DIR             = 8
};

Function Documentation

nfs41_access()

int nfs41_access	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN uint32_t	requested,
		OUT uint32_t *supported	OPTIONAL,
		OUT uint32_t *access	OPTIONAL
	)

Definition at line 1554 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_access_args access_args;
    nfs41_access_res access_res;
 
    compound_init(&compound, argops, resops, "access");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_ACCESS, &access_args, &access_res);
    access_args.access = requested;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    if (supported)
        *supported = access_res.supported;
    if (access)
        *access = access_res.access;
out:
    return status;
}

Referenced by check_execute_access().

nfs41_bind_conn_to_session()

enum nfsstat4 nfs41_bind_conn_to_session	(	IN nfs41_rpc_clnt *	rpc,
		IN const unsigned char *	sessionid,
		IN enum channel_dir_from_client4	dir
	)

Definition at line 185 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argop;
    nfs_resop4 resop;
    nfs41_bind_conn_to_session_args bind_args = { 0 };
    nfs41_bind_conn_to_session_res bind_res = { 0 };
 
    compound_init(&compound, &argop, &resop, "bind_conn_to_session");
 
    compound_add_op(&compound, OP_BIND_CONN_TO_SESSION, &bind_args, &bind_res);
    bind_args.sessionid = (unsigned char *)sessionid;
    bind_args.dir = dir;
 
    status = nfs41_send_compound(rpc,
        (char*)&compound.args, (char*)&compound.res);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
 
out:
    return status;
}

Referenced by compound_encode_send_decode(), and rpc_reconnect().

nfs41_cached_getattr()

int nfs41_cached_getattr	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		OUT nfs41_file_info *	info
	)

Definition at line 32 of file getattr.c.

{
    int status;
 
    /* first look for cached attributes */
    status = nfs41_attr_cache_lookup(session_name_cache(session),
        file->fh.fileid, info);
 
    if (status) {
        /* fetch attributes from the server */
        bitmap4 attr_request;
        nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
 
        status = nfs41_getattr(session, file, &attr_request, info);
        if (status) {
            eprintf("nfs41_getattr() failed with %s\n",
                nfs_error_string(status));
            status = nfs_to_windows_error(status, ERROR_BAD_NET_RESP);
        }
    }
    return status;
}

Referenced by handle_getattr(), and readdir_add_dots().

nfs41_close()

int nfs41_close	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN stateid_arg *	stateid
	)

Definition at line 627 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[4];
    nfs_resop4 resops[4];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_op_close_args close_args;
    nfs41_op_close_res close_res;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res getattr_res;
    bitmap4 attr_request;
    nfs41_file_info info;
 
    nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
 
    compound_init(&compound, argops, resops, "close");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 1);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_CLOSE, &close_args, &close_res);
    close_args.stateid = stateid;
 
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
    getattr_args.attr_request = &attr_request;
    getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    getattr_res.info = &info;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    if (info.type == NF4NAMEDATTR)
        goto out;
 
    /* update the attributes of the parent directory */
    memcpy(&info.attrmask, &getattr_res.obj_attributes.attrmask,
        sizeof(bitmap4));
    nfs41_attr_cache_update(session_name_cache(session),
        file->fh.fileid, &info);
out:
    return status;
}

Referenced by cancel_open(), do_nfs41_close(), get_ea_value(), recover_delegation_open(), and set_ea_value().

nfs41_commit()

int nfs41_commit	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN uint64_t	offset,
		IN uint32_t	count,
		IN bool_t	do_getattr,
		OUT nfs41_write_verf *	verf,
		OUT nfs41_file_info *	cinfo
	)

Definition at line 833 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[4];
    nfs_resop4 resops[4];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_commit_args commit_args;
    nfs41_commit_res commit_res;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res getattr_res = {0};
    bitmap4 attr_request;
    nfs41_file_info info, *pinfo;
 
    compound_init(&compound, argops, resops,
        do_getattr ? "commit" : "ds commit");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 1);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_COMMIT, &commit_args, &commit_res);
    commit_args.offset = offset;
    commit_args.count = count;
    commit_res.verf = verf;
 
    /* send a GETATTR request to update the attribute cache,
     * but not if we're talking to a data server! */
    if (cinfo) pinfo = cinfo;
    else pinfo = &info;
    if (do_getattr) {
        nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
 
        compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
        getattr_args.attr_request = &attr_request;
        getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
        getattr_res.info = pinfo;
    }
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    if (do_getattr) {
        /* update the attribute cache */
        memcpy(&pinfo->attrmask, &getattr_res.obj_attributes.attrmask,
            sizeof(bitmap4));
        nfs41_attr_cache_update(session_name_cache(session),
            file->fh.fileid, pinfo);
    }
    nfs41_superblock_space_changed(file->fh.superblock);
out:
    return status;
}

Referenced by file_layout_write_thread(), mds_commit(), and write_to_mds().

nfs41_create()

int nfs41_create	(	IN nfs41_session *	session,
		IN uint32_t	type,
		IN nfs41_file_info *	createattrs,
		IN OPTIONAL const char *	symlink,
		IN nfs41_path_fh *	parent,
		OUT nfs41_path_fh *	file,
		OUT nfs41_file_info *	info
	)

Definition at line 530 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[8];
    nfs_resop4 resops[8];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_create_args create_args;
    nfs41_create_res create_res;
    nfs41_getfh_res getfh_res;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res getattr_res, pgetattr_res;
    bitmap4 attr_request;
    nfs41_file_info dir_info;
    nfs41_savefh_res savefh_res;
    nfs41_restorefh_res restorefh_res;
 
    nfs41_superblock_getattr_mask(parent->fh.superblock, &attr_request);
 
    compound_init(&compound, argops, resops, "create");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 1);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = parent;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_SAVEFH, NULL, &savefh_res);
 
    compound_add_op(&compound, OP_CREATE, &create_args, &create_res);
    create_args.objtype.type = type;
    if (type == NF4LNK) {
        create_args.objtype.u.lnk.linkdata = symlink;
        create_args.objtype.u.lnk.linkdata_len = (uint32_t)strlen(symlink);
    }
    create_args.name = &file->name;
    create_args.createattrs = createattrs;
    nfs41_superblock_supported_attrs(
                parent->fh.superblock, &createattrs->attrmask);
 
    compound_add_op(&compound, OP_GETFH, NULL, &getfh_res);
    getfh_res.fh = &file->fh;
 
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
    getattr_args.attr_request = &attr_request;
    getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    getattr_res.info = info;
 
    compound_add_op(&compound, OP_RESTOREFH, NULL, &restorefh_res);
 
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &pgetattr_res);
    getattr_args.attr_request = &attr_request;
    pgetattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    pgetattr_res.info = &dir_info;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    /* fill in the file handle's fileid and superblock */
    file->fh.fileid = info->fileid;
    file->fh.superblock = parent->fh.superblock;
 
    /* update the attributes of the parent directory */
    memcpy(&dir_info.attrmask, &pgetattr_res.obj_attributes.attrmask,
        sizeof(bitmap4));
    nfs41_attr_cache_update(session_name_cache(session),
        parent->fh.fileid, &dir_info);
 
    /* add the new file handle and attributes to the name cache */
    memcpy(&info->attrmask, &getattr_res.obj_attributes.attrmask,
        sizeof(bitmap4));
    AcquireSRWLockShared(&file->path->lock);
    nfs41_name_cache_insert(session_name_cache(session),
        file->path->path, &file->name, &file->fh,
        info, &create_res.cinfo, OPEN_DELEGATE_NONE);
    ReleaseSRWLockShared(&file->path->lock);
 
    nfs41_superblock_space_changed(file->fh.superblock);
out:
    return status;
}

Referenced by handle_open(), and handle_symlink().

nfs41_create_session()

int nfs41_create_session	(	IN nfs41_client *	clnt,
		OUT nfs41_session *	session,
		IN bool_t	try_recovery
	)

nfs41_delegpurge()

int nfs41_delegpurge

(

IN nfs41_session *

session

)

Definition at line 1666 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[2];
    nfs_resop4 resops[2];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_delegpurge_res dp_res;
 
    compound_init(&compound, argops, resops, "delegpurge");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_DELEGPURGE, NULL, &dp_res);
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by nfs41_client_delegation_recovery().

nfs41_delegreturn()

int nfs41_delegreturn	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN stateid_arg *	stateid,
		IN bool_t	try_recovery
	)

Definition at line 1693 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_delegreturn_args dr_args;
    nfs41_delegreturn_res dr_res;
 
    compound_init(&compound, argops, resops, "delegreturn");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_DELEGRETURN, &dr_args, &dr_res);
    dr_args.stateid = stateid;
 
    status = compound_encode_send_decode(session, &compound, try_recovery);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    AcquireSRWLockShared(&file->path->lock);
    nfs41_name_cache_delegreturn(session_name_cache(session),
        file->fh.fileid, file->path->path, &file->name);
    ReleaseSRWLockShared(&file->path->lock);
out:
    return status;
}

Referenced by delegation_return(), nfs41_delegation_granted(), and open_delegation_return().

nfs41_destroy_clientid()

int nfs41_destroy_clientid	(	IN nfs41_rpc_clnt *	rpc,
		IN uint64_t	clientid
	)

Definition at line 242 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops;
    nfs_resop4 resops;
    nfs41_destroy_clientid_args dc_args;
    nfs41_destroy_clientid_res dc_res;
 
    compound_init(&compound, &argops, &resops, "destroy_clientid");
 
    compound_add_op(&compound, OP_DESTROY_CLIENTID, &dc_args, &dc_res);
    dc_args.dca_clientid = clientid;
 
    status = nfs41_send_compound(rpc, (char *)&compound.args,
        (char *)&compound.res);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by nfs41_client_free().

nfs41_destroy_session()

int nfs41_destroy_session

(

IN nfs41_session *

session

)

Definition at line 214 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argop;
    nfs_resop4 resop;
    nfs41_destroy_session_args ds_args;
    nfs41_destroy_session_res ds_res;
 
    compound_init(&compound, &argop, &resop, "destroy_session");
 
    compound_add_op(&compound, OP_DESTROY_SESSION, &ds_args, &ds_res);
    ds_args.dsa_sessionid = session->session_id;
 
    /* don't attempt to recover from BADSESSION/STALE_CLIENTID */
    status = compound_encode_send_decode(session, &compound, FALSE);
    if (status)
        goto out;
 
    status = compound.res.status;
    if (status)
        eprintf("%s failed with status %d.\n",
            nfs_opnum_to_string(OP_DESTROY_SESSION), status);
out:
    return status;
}

Referenced by nfs41_session_free().

nfs41_exchange_id()

int nfs41_exchange_id	(	IN nfs41_rpc_clnt *	rpc,
		IN client_owner4 *	owner,
		IN uint32_t	flags_in,
		OUT nfs41_exchange_id_res *	res_out
	)

Definition at line 36 of file nfs41_ops.c.

{
    int status = 0;
    nfs41_compound compound;
    nfs_argop4 argop;
    nfs_resop4 resop;
    nfs41_exchange_id_args ex_id;
 
    compound_init(&compound, &argop, &resop, "exchange_id");
 
    compound_add_op(&compound, OP_EXCHANGE_ID, &ex_id, res_out);
    ex_id.eia_clientowner = owner;
    ex_id.eia_flags = flags_in;
    ex_id.eia_state_protect.spa_how = SP4_NONE;
    ex_id.eia_client_impl_id = NULL;
 
    res_out->server_owner.so_major_id_len = NFS4_OPAQUE_LIMIT;
    res_out->server_scope_len = NFS4_OPAQUE_LIMIT;
 
    status = nfs41_send_compound(rpc, (char *)&compound.args,
        (char *)&compound.res);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by nfs41_client_renew(), and nfs41_root_mount_addrs().

nfs41_free_stateid()

enum nfsstat4 nfs41_free_stateid	(	IN nfs41_session *	session,
		IN stateid4 *	stateid
	)

Definition at line 1870 of file nfs41_ops.c.

{
    enum nfsstat4 status;
    nfs41_compound compound;
    nfs_argop4 argops[2];
    nfs_resop4 resops[2];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_free_stateid_args freestateid_args;
    nfs41_free_stateid_res freestateid_res;
 
    compound_init(&compound, argops, resops, "free_stateid");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_FREE_STATEID, &freestateid_args, &freestateid_res);
    freestateid_args.stateid = stateid;
 
    status = compound_encode_send_decode(session, &compound, FALSE);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by nfs41_client_state_revoked().

nfs41_fs_locations()

enum nfsstat4 nfs41_fs_locations	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	parent,
		IN const nfs41_component *	name,
		OUT fs_locations4 *	locations
	)

Definition at line 1737 of file nfs41_ops.c.

{
    enum nfsstat4 status;
    nfs41_compound compound;
    nfs_argop4 argops[4];
    nfs_resop4 resops[4];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_lookup_args lookup_args;
    nfs41_lookup_res lookup_res;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res getattr_res;
    bitmap4 attr_request = { 1, { FATTR4_WORD0_FS_LOCATIONS } };
    nfs41_file_info info;
 
    compound_init(&compound, argops, resops, "fs_locations");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = parent;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_LOOKUP, &lookup_args, &lookup_res);
    lookup_args.name = name;
 
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
    getattr_args.attr_request = &attr_request;
    info.fs_locations = locations;
    getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    getattr_res.info = &info;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by referral_resolve().

nfs41_getattr()

int nfs41_getattr	(	IN nfs41_session *	session,
		IN OPTIONAL nfs41_path_fh *	file,
		IN bitmap4 *	attr_request,
		OUT nfs41_file_info *	info
	)

Definition at line 1063 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res getattr_res;
 
    compound_init(&compound, argops, resops, "getattr");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    if (file) {
        compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
        putfh_args.file = file;
        putfh_args.in_recovery = 0;
    } else {
        compound_add_op(&compound, OP_PUTROOTFH, NULL, &putfh_res);
    }
 
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
    getattr_args.attr_request = attr_request;
    getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    getattr_res.info = info;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    if (file) {
        /* update the name cache with whatever attributes we got */
        memcpy(&info->attrmask, &getattr_res.obj_attributes.attrmask,
            sizeof(bitmap4));
        nfs41_attr_cache_update(session_name_cache(session),
            file->fh.fileid, info);
    }
out:
    return status;
}

Referenced by get_volume_size_info(), handle_getacl(), nfs41_cached_getattr(), pnfs_write(), session_get_lease(), and write_to_mds().

nfs41_link()

int nfs41_link	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	src,
		IN nfs41_path_fh *	dst_dir,
		IN const nfs41_component *	target,
		OUT nfs41_file_info *	cinfo
	)

Definition at line 1407 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[9];
    nfs_resop4 resops[9];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args[2];
    nfs41_putfh_res putfh_res[2];
    nfs41_savefh_res savefh_res;
    nfs41_link_args link_args;
    nfs41_link_res link_res;
    nfs41_lookup_args lookup_args;
    nfs41_lookup_res lookup_res;
    nfs41_getfh_res getfh_res;
    nfs41_getattr_args getattr_args[2];
    nfs41_getattr_res getattr_res[2];
    nfs41_file_info info = { 0 };
    nfs41_path_fh file;
 
    nfs41_superblock_getattr_mask(src->fh.superblock, &info.attrmask);
    nfs41_superblock_getattr_mask(dst_dir->fh.superblock, &cinfo->attrmask);
    cinfo->attrmask.arr[0] |= FATTR4_WORD0_FSID;
 
    compound_init(&compound, argops, resops, "link");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 1);
 
    /* PUTFH(src) */
    compound_add_op(&compound, OP_PUTFH, &putfh_args[0], &putfh_res[0]);
    putfh_args[0].file = src;
    putfh_args[0].in_recovery = 0;
 
    compound_add_op(&compound, OP_SAVEFH, NULL, &savefh_res);
 
    /* PUTFH(dst_dir) */
    compound_add_op(&compound, OP_PUTFH, &putfh_args[1], &putfh_res[1]);
    putfh_args[1].file = dst_dir;
    putfh_args[1].in_recovery = 0;
 
    compound_add_op(&compound, OP_LINK, &link_args, &link_res);
    link_args.newname = target;
 
    /* GETATTR(dst_dir) */
    compound_add_op(&compound, OP_GETATTR, &getattr_args[0], &getattr_res[0]);
    getattr_args[0].attr_request = &info.attrmask;
    getattr_res[0].obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    getattr_res[0].info = &info;
 
    /* LOOKUP(target) */
    compound_add_op(&compound, OP_LOOKUP, &lookup_args, &lookup_res);
    lookup_args.name = target;
 
    /* GETATTR(target) */
    compound_add_op(&compound, OP_GETATTR, &getattr_args[1], &getattr_res[1]);
    getattr_args[1].attr_request = &cinfo->attrmask;
    getattr_res[1].obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    getattr_res[1].info = cinfo;
 
    /* GETFH(target) */
    compound_add_op(&compound, OP_GETFH, NULL, &getfh_res);
    getfh_res.fh = &file.fh;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    /* fill in the file handle's fileid and superblock */
    file.fh.fileid = cinfo->fileid;
    status = nfs41_superblock_for_fh(session,
        &cinfo->fsid, &dst_dir->fh, &file);
    if (status)
        goto out;
 
    /* update the attributes of the destination directory */
    memcpy(&info.attrmask, &getattr_res[0].obj_attributes.attrmask,
        sizeof(bitmap4));
    nfs41_attr_cache_update(session_name_cache(session),
        info.fileid, &info);
 
    /* add the new file handle and attributes to the name cache */
    memcpy(&cinfo->attrmask, &getattr_res[1].obj_attributes.attrmask,
        sizeof(bitmap4));
    AcquireSRWLockShared(&dst_dir->path->lock);
    nfs41_name_cache_insert(session_name_cache(session),
        dst_dir->path->path, target, &file.fh,
        cinfo, &link_res.cinfo, OPEN_DELEGATE_NONE);
    ReleaseSRWLockShared(&dst_dir->path->lock);
 
    nfs41_superblock_space_changed(dst_dir->fh.superblock);
out:
    return status;
}

nfs41_lock()

int nfs41_lock	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN state_owner4 *	owner,
		IN uint32_t	type,
		IN uint64_t	offset,
		IN uint64_t	length,
		IN bool_t	reclaim,
		IN bool_t	try_recovery,
		IN OUT stateid_arg *	stateid
	)

Definition at line 904 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_lock_args lock_args;
    nfs41_lock_res lock_res;
 
    compound_init(&compound, argops, resops, "lock");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_LOCK, &lock_args, &lock_res);
    lock_args.locktype = type;
    lock_args.reclaim = reclaim;
    lock_args.offset = offset;
    lock_args.length = length;
    if (stateid->type == STATEID_LOCK) {
        lock_args.locker.new_lock_owner = 0;
        lock_args.locker.u.lock_owner.lock_stateid = stateid;
        lock_args.locker.u.lock_owner.lock_seqid = 0; /* ignored */
    } else {
        lock_args.locker.new_lock_owner = 1;
        lock_args.locker.u.open_owner.open_seqid = 0; /* ignored */
        lock_args.locker.u.open_owner.open_stateid = stateid;
        lock_args.locker.u.open_owner.lock_seqid = 0; /* ignored */
        lock_args.locker.u.open_owner.lock_owner = owner;
    }
    lock_res.u.resok4.lock_stateid = &stateid->stateid;
    lock_res.u.denied.owner.owner_len = NFS4_OPAQUE_LIMIT;
 
    status = compound_encode_send_decode(session, &compound, try_recovery);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    stateid->type = STATEID_LOCK; /* returning a lock stateid */
out:
    return status;
}

Referenced by delegation_flush_locks(), handle_lock(), and recover_locks().

nfs41_lock_stateid_copy()

stateid4 * nfs41_lock_stateid_copy	(	IN nfs41_lock_state *	lock_state,
		IN OUT stateid4 *	dest
	)

nfs41_lookup()

int nfs41_lookup	(	IN nfs41_root *	root,
		IN nfs41_session *	session,
		IN OUT nfs41_abs_path *	path,
		OUT OPTIONAL nfs41_path_fh *	parent_out,
		OUT OPTIONAL nfs41_path_fh *	target_out,
		OUT OPTIONAL nfs41_file_info *	info_out,
		OUT nfs41_session **	session_out
	)

Definition at line 424 of file lookup.c.

{
    nfs41_abs_path path;
    struct nfs41_name_cache *cache = session_name_cache(session);
    nfs41_path_fh parent, target, *server_start;
    const char *path_pos, *path_end;
    struct lookup_referral referral;
    bool_t negative = 0;
    int status;
 
    if (session_out) *session_out = session;
 
    InitializeSRWLock(&path.lock);
 
    /* to avoid holding this lock over multiple rpcs,
     * make a copy of the path and use that instead */
    AcquireSRWLockShared(&path_inout->lock);
    abs_path_copy(&path, path_inout);
    ReleaseSRWLockShared(&path_inout->lock);
 
    path_pos = path.path;
    path_end = path.path + path.len;
 
    dprintf(LULVL, "--> nfs41_lookup('%s')\n", path.path);
 
    if (parent_out == NULL) parent_out = &parent;
    if (target_out == NULL) target_out = ⌖
    parent_out->fh.len = target_out->fh.len = 0;
 
    status = nfs41_name_cache_lookup(cache, path_pos, path_end, &path_pos,
        &parent_out->fh, &target_out->fh, info_out, &negative);
    if (status == NO_ERROR || negative)
        goto out;
 
    if (parent_out->fh.len) {
        /* start where the name cache left off */
        if (&parent != parent_out) {
            /* must make a copy for server_start, because
             * server_lookup_loop() will overwrite parent_out */
            path_fh_copy(&parent, parent_out);
        }
        server_start = &parent;
    } else {
        /* start with PUTROOTFH */
        server_start = NULL;
    }
 
    status = server_lookup_loop(session, server_start,
        &path, path_pos, &referral, parent_out, target_out, info_out);
 
    if (status == ERROR_FILESYSTEM_ABSENT) {
        nfs41_session *new_session;
 
        /* create a session to the referred server and
         * reformat the path relative to that server's root */
        status = referral_resolve(root, session,
            &referral, path_inout, &new_session);
        if (status) {
            eprintf("referral_resolve() failed with %d\n", status);
            goto out;
        }
 
        /* update the positions of the parent and target components */
        last_component(path_inout->path, path_inout->path + path_inout->len,
            &target_out->name);
        last_component(path_inout->path, target_out->name.name,
            &parent_out->name);
 
        if (session_out) *session_out = new_session;
 
        /* look up the new path */
        status = nfs41_lookup(root, new_session, path_inout,
            parent_out, target_out, info_out, session_out);
    }
out:
    dprintf(LULVL, "<-- nfs41_lookup() returning %d\n", status);
    return status;
}

Referenced by handle_mount(), handle_open(), lookup_entry(), lookup_symlink(), nfs41_lookup(), and nfs41_symlink_follow().

nfs41_open()

int nfs41_open	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	parent,
		IN nfs41_path_fh *	file,
		IN state_owner4 *	owner,
		IN open_claim4 *	claim,
		IN uint32_t	allow,
		IN uint32_t	deny,
		IN uint32_t	create,
		IN uint32_t	how_mode,
		IN OPTIONAL nfs41_file_info *	createattrs,
		IN bool_t	try_recovery,
		OUT stateid4 *	stateid,
		OUT open_delegation4 *	delegation,
		OUT OPTIONAL nfs41_file_info *	info
	)

Definition at line 366 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[8];
    nfs_resop4 resops[8];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args[2];
    nfs41_putfh_res putfh_res[2];
    nfs41_op_open_args open_args;
    nfs41_op_open_res open_res;
    nfs41_getfh_res getfh_res;
    bitmap4 attr_request;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res getattr_res, pgetattr_res;
    nfs41_savefh_res savefh_res;
    nfs41_restorefh_res restorefh_res;
    nfs41_file_info tmp_info, dir_info;
    bool_t current_fh_is_dir;
    bool_t already_delegated = delegation->type == OPEN_DELEGATE_READ
        || delegation->type == OPEN_DELEGATE_WRITE;
 
    /* depending on the claim type, OPEN expects CURRENT_FH set
     * to either the parent directory, or to the file itself */
    switch (claim->claim) {
    case CLAIM_NULL:
    case CLAIM_DELEGATE_CUR:
    case CLAIM_DELEGATE_PREV:
        /* CURRENT_FH: directory */
        current_fh_is_dir = TRUE;
        /* SEQUENCE; PUTFH(dir); SAVEFH; OPEN;
         * GETFH(file); GETATTR(file); RESTOREFH(dir); GETATTR */
        nfs41_superblock_getattr_mask(parent->fh.superblock, &attr_request);
        break;
    case CLAIM_PREVIOUS:
    case CLAIM_FH:
    case CLAIM_DELEG_CUR_FH:
    case CLAIM_DELEG_PREV_FH:
    default:
        /* CURRENT_FH: file being opened */
        current_fh_is_dir = FALSE;
        /* SEQUENCE; PUTFH(file); OPEN; GETATTR(file); PUTFH(dir); GETATTR */
        nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
        break;
    }
 
    if (info == NULL)
        info = &tmp_info;
 
    attr_request.arr[0] |= FATTR4_WORD0_FSID;
 
    compound_init(&compound, argops, resops, "open");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 1);
 
    if (current_fh_is_dir) {
        /* CURRENT_FH: directory */
        compound_add_op(&compound, OP_PUTFH, &putfh_args[0], &putfh_res[0]);
        putfh_args[0].file = parent;
        putfh_args[0].in_recovery = 0;
 
        compound_add_op(&compound, OP_SAVEFH, NULL, &savefh_res);
    } else {
        /* CURRENT_FH: file being opened */
        compound_add_op(&compound, OP_PUTFH, &putfh_args[0], &putfh_res[0]);
        putfh_args[0].file = file;
        putfh_args[0].in_recovery = 0;
    }
 
    compound_add_op(&compound, OP_OPEN, &open_args, &open_res);
    open_args.seqid = 0;
#ifdef DISABLE_FILE_DELEGATIONS
    open_args.share_access = allow | OPEN4_SHARE_ACCESS_WANT_NO_DELEG;
#else
    open_args.share_access = allow;
#endif
    open_args.share_deny = deny; 
    open_args.owner = owner;
    open_args.openhow.opentype = create;
    open_args.openhow.how.mode = how_mode;
    open_args.openhow.how.createattrs = createattrs;
    if (how_mode == EXCLUSIVE4_1) {
        DWORD tid = GetCurrentThreadId();
        time((time_t*)open_args.openhow.how.createverf);
        memcpy(open_args.openhow.how.createverf+4, &tid, sizeof(tid));
        /* mask unsupported attributes */
        nfs41_superblock_supported_attrs_exclcreat(
            parent->fh.superblock, &createattrs->attrmask);
    } else if (createattrs) {
        /* mask unsupported attributes */
        nfs41_superblock_supported_attrs(
            parent->fh.superblock, &createattrs->attrmask);
    }
    open_args.claim = claim;
    open_res.resok4.stateid = stateid;
    open_res.resok4.delegation = delegation;
 
    if (current_fh_is_dir) {
        compound_add_op(&compound, OP_GETFH, NULL, &getfh_res);
        getfh_res.fh = &file->fh;
    }
 
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
    getattr_args.attr_request = &attr_request;
    getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    getattr_res.info = info;
 
    if (current_fh_is_dir) {
        compound_add_op(&compound, OP_RESTOREFH, NULL, &restorefh_res);
    } else {
        compound_add_op(&compound, OP_PUTFH, &putfh_args[1], &putfh_res[1]);
        putfh_args[1].file = parent;
        putfh_args[1].in_recovery = 0;
    }
 
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &pgetattr_res);
    getattr_args.attr_request = &attr_request;
    pgetattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    pgetattr_res.info = &dir_info;
 
    status = compound_encode_send_decode(session, &compound, try_recovery);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    if (dir_info.type == NF4ATTRDIR) {
        file->fh.superblock = parent->fh.superblock;
        goto out;
    }
 
    /* fill in the file handle's fileid and superblock */
    file->fh.fileid = info->fileid;
    status = nfs41_superblock_for_fh(session, &info->fsid, &parent->fh, file);
    if (status)
        goto out;
 
    if (create == OPEN4_CREATE)
        nfs41_superblock_space_changed(file->fh.superblock);
 
    /* update the name/attr cache with the results */
    open_update_cache(session, parent, file, try_recovery, delegation,
        already_delegated, &open_res.resok4.cinfo, &pgetattr_res, &getattr_res);
out:
    return status;
}

Referenced by do_open(), get_ea_value(), nfs41_delegation_to_open(), recover_open_grace(), recover_open_no_grace(), and set_ea_value().

nfs41_read()

int nfs41_read	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN stateid_arg *	stateid,
		IN uint64_t	offset,
		IN uint32_t	count,
		OUT unsigned char *	data_out,
		OUT uint32_t *	data_len_out,
		OUT bool_t *	eof_out
	)

Definition at line 774 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[4];
    nfs_resop4 resops[4];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_read_args read_args;
    nfs41_read_res read_res;
 
    compound_init(&compound, argops, resops,
        stateid->stateid.seqid == 0 ? "ds read" : "read");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_READ, &read_args, &read_res);
    read_args.stateid = stateid;
    read_args.offset = offset;
    read_args.count = count;
    read_res.resok4.data_len = count;
    read_res.resok4.data = data_out;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    *data_len_out = read_res.resok4.data_len;
    *eof_out = read_res.resok4.eof;
 
    /* we shouldn't ever see this, but a buggy server could
     * send us into an infinite loop. return NFS4ERR_IO */
    if (!read_res.resok4.data_len && !read_res.resok4.eof) {
        status = NFS4ERR_IO;
        eprintf("READ succeeded with len=0 and eof=0; returning %s\n",
            nfs_error_string(status));
    }
out:
    return status;
}

Referenced by file_layout_read_thread(), get_ea_value(), and read_from_mds().

nfs41_readdir()

int nfs41_readdir	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN bitmap4 *	attr_request,
		IN nfs41_readdir_cookie *	cookie,
		OUT unsigned char *	entries,
		IN OUT uint32_t *	entries_len,
		OUT bool_t *	eof_out
	)

Definition at line 1010 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_readdir_args readdir_args;
    nfs41_readdir_res readdir_res;
 
    compound_init(&compound, argops, resops, "readdir");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_READDIR, &readdir_args, &readdir_res);
    readdir_args.cookie.cookie = cookie->cookie;
    memcpy(readdir_args.cookie.verf, cookie->verf, NFS4_VERIFIER_SIZE);
    readdir_args.dircount = *entries_len;
    readdir_args.maxcount = *entries_len + sizeof(nfs41_readdir_res);
    readdir_args.attr_request = attr_request;
    readdir_res.reply.entries_len = *entries_len;
    readdir_res.reply.entries = entries;
    ZeroMemory(entries, readdir_args.dircount);
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    *entries_len = readdir_res.reply.entries_len;
    *eof_out = readdir_res.reply.eof;
    memcpy(cookie->verf, readdir_res.cookieverf, NFS4_VERIFIER_SIZE);
out:
    return status;
}

Referenced by handle_readdir(), and read_entire_dir().

nfs41_readlink()

int nfs41_readlink	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN uint32_t	max_len,
		OUT char *	link_out,
		OUT uint32_t *	len_out
	)

Definition at line 1511 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_readlink_res readlink_res;
 
    compound_init(&compound, argops, resops, "readlink");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_READLINK, NULL, &readlink_res);
    readlink_res.link_len = max_len - 1;
    readlink_res.link = link_out;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    link_out[readlink_res.link_len] = '\0';
    *len_out = readlink_res.link_len;
out:
    return status;
}

Referenced by handle_symlink(), and nfs41_symlink_target().

nfs41_reclaim_complete()

enum nfsstat4 nfs41_reclaim_complete

(

IN nfs41_session *

session

)

Definition at line 268 of file nfs41_ops.c.

{
    enum nfsstat4 status = NFS4_OK;
    nfs41_compound compound;
    nfs_argop4 argops[2];
    nfs_resop4 resops[2];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_reclaim_complete_res reclaim_res;
 
    compound_init(&compound, argops, resops, "reclaim_complete");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_RECLAIM_COMPLETE, NULL, &reclaim_res);
 
    /* don't attempt to recover from BADSESSION */
    status = compound_encode_send_decode(session, &compound, FALSE);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by nfs41_recover_client_state(), nfs41_recover_sequence_flags(), recover_delegation_open(), recover_delegation_want(), recover_locks(), recover_open(), and root_client_create().

nfs41_remove()

int nfs41_remove	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	parent,
		IN const nfs41_component *	target,
		IN uint64_t	fileid
	)

Definition at line 1180 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[4];
    nfs_resop4 resops[4];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_remove_args remove_args;
    nfs41_remove_res remove_res;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res getattr_res;
    bitmap4 attr_request;
    nfs41_file_info info;
 
    nfs41_superblock_getattr_mask(parent->fh.superblock, &attr_request);
 
    compound_init(&compound, argops, resops, "remove");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 1);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = parent;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_REMOVE, &remove_args, &remove_res);
    remove_args.target = target;
 
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
    getattr_args.attr_request = &attr_request;
    getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    getattr_res.info = &info;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    if (info.type == NF4ATTRDIR)
        goto out;
 
    /* update the attributes of the parent directory */
    memcpy(&info.attrmask, &getattr_res.obj_attributes.attrmask,
        sizeof(bitmap4));
    nfs41_attr_cache_update(session_name_cache(session),
        parent->fh.fileid, &info);
 
    /* remove the target file from the cache */
    AcquireSRWLockShared(&parent->path->lock);
    nfs41_name_cache_remove(session_name_cache(session),
        parent->path->path, target, fileid, &remove_res.cinfo);
    ReleaseSRWLockShared(&parent->path->lock);
 
    nfs41_superblock_space_changed(parent->fh.superblock);
out:
    return status;
}

Referenced by cancel_open(), handle_close(), handle_nfs41_remove(), handle_open(), handle_symlink(), and set_ea_value().

nfs41_rename()

int nfs41_rename	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	src_dir,
		IN const nfs41_component *	src_name,
		IN nfs41_path_fh *	dst_dir,
		IN const nfs41_component *	dst_name
	)

Definition at line 1247 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[8];
    nfs_resop4 resops[8];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args src_putfh_args;
    nfs41_putfh_res src_putfh_res;
    nfs41_savefh_res savefh_res;
    nfs41_putfh_args dst_putfh_args;
    nfs41_putfh_res dst_putfh_res;
    nfs41_rename_args rename_args;
    nfs41_rename_res rename_res;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res src_getattr_res, dst_getattr_res;
    nfs41_file_info src_info, dst_info;
    bitmap4 attr_request;
    nfs41_restorefh_res restorefh_res;
 
    nfs41_superblock_getattr_mask(src_dir->fh.superblock, &attr_request);
 
    compound_init(&compound, argops, resops, "rename");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 1);
 
    compound_add_op(&compound, OP_PUTFH, &src_putfh_args, &src_putfh_res);
    src_putfh_args.file = src_dir;
    src_putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_SAVEFH, NULL, &savefh_res);
 
    compound_add_op(&compound, OP_PUTFH, &dst_putfh_args, &dst_putfh_res);
    dst_putfh_args.file = dst_dir;
    dst_putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_RENAME, &rename_args, &rename_res);
    rename_args.oldname = src_name;
    rename_args.newname = dst_name;
    
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &dst_getattr_res);
    getattr_args.attr_request = &attr_request;
    dst_getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    dst_getattr_res.info = &dst_info;
 
    compound_add_op(&compound, OP_RESTOREFH, NULL, &restorefh_res);
 
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &src_getattr_res);
    src_getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    src_getattr_res.info = &src_info;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    /* update the attributes of the source directory */
    memcpy(&src_info.attrmask, &src_getattr_res.obj_attributes.attrmask,
        sizeof(bitmap4));
    nfs41_attr_cache_update(session_name_cache(session),
        src_dir->fh.fileid, &src_info);
 
    /* update the attributes of the destination directory */
    memcpy(&dst_info.attrmask, &dst_getattr_res.obj_attributes.attrmask,
        sizeof(bitmap4));
    nfs41_attr_cache_update(session_name_cache(session),
        dst_dir->fh.fileid, &dst_info);
 
    if (src_dir->path == dst_dir->path) {
        /* source and destination are the same, only lock it once */
        AcquireSRWLockShared(&src_dir->path->lock);
    } else if (src_dir->path < dst_dir->path) {
        /* lock the lowest memory address first */
        AcquireSRWLockShared(&src_dir->path->lock);
        AcquireSRWLockShared(&dst_dir->path->lock);
    } else {
        AcquireSRWLockShared(&dst_dir->path->lock);
        AcquireSRWLockShared(&src_dir->path->lock);
    }
 
    /* move/rename the target file's name cache entry */
    nfs41_name_cache_rename(session_name_cache(session),
        src_dir->path->path, src_name, &rename_res.source_cinfo,
        dst_dir->path->path, dst_name, &rename_res.target_cinfo);
 
    if (src_dir->path == dst_dir->path) {
        ReleaseSRWLockShared(&src_dir->path->lock);
    } else {
        ReleaseSRWLockShared(&src_dir->path->lock);
        ReleaseSRWLockShared(&dst_dir->path->lock);
    }
out:
    return status;
}

nfs41_rpc_openattr()

enum nfsstat4 nfs41_rpc_openattr	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN bool_t	createdir,
		OUT nfs41_fh *	fh_out
	)

Definition at line 2145 of file nfs41_ops.c.

{
    enum nfsstat4 status;
    nfs41_compound compound;
    nfs_argop4 argops[4];
    nfs_resop4 resops[4];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_openattr_args openattr_args;
    nfs41_openattr_res openattr_res;
    nfs41_getfh_res getfh_res;
 
    compound_init(&compound, argops, resops, "openattr");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = FALSE;
 
    compound_add_op(&compound, OP_OPENATTR, &openattr_args, &openattr_res);
    openattr_args.createdir = createdir;
 
    compound_add_op(&compound, OP_GETFH, NULL, &getfh_res);
    getfh_res.fh = fh_out;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
 
    fh_out->superblock = file->fh.superblock;
out:
    return status;
}

Referenced by nfs41_ea_set().

nfs41_secinfo()

int nfs41_secinfo	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN const nfs41_component *	name,
		OUT nfs41_secinfo_info *	secinfo
	)

Definition at line 1785 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_secinfo_args secinfo_args;
    nfs41_secinfo_noname_res secinfo_res;
 
    compound_init(&compound, argops, resops, "secinfo");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    if (file == NULL) 
        compound_add_op(&compound, OP_PUTROOTFH, NULL, &putfh_res);
    else {
        compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
        putfh_args.file = file;
        putfh_args.in_recovery = 0;
    }
 
    compound_add_op(&compound, OP_SECINFO, &secinfo_args, &secinfo_res);
    secinfo_args.name = name;
    secinfo_res.secinfo = secinfo;
 
    status = compound_encode_send_decode(session, &compound, FALSE);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by compound_encode_send_decode().

nfs41_secinfo_noname()

int nfs41_secinfo_noname	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		OUT nfs41_secinfo_info *	secinfo
	)

Definition at line 1828 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_secinfo_noname_args noname_args;
    nfs41_secinfo_noname_res noname_res;
 
    compound_init(&compound, argops, resops, "secinfo_no_name");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    if (file == NULL) 
        compound_add_op(&compound, OP_PUTROOTFH, NULL, &putfh_res);
    else {
        compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
        putfh_args.file = file;
        putfh_args.in_recovery = 0;
    }
 
    compound_add_op(&compound, OP_SECINFO_NO_NAME, &noname_args, &noname_res);
    noname_args.type = SECINFO_STYLE4_CURRENT_FH;
    noname_res.secinfo = secinfo;
 
    status = compound_encode_send_decode(session, &compound, FALSE);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by compound_encode_send_decode().

nfs41_send_sequence()

int nfs41_send_sequence

(

IN nfs41_session *

session

)

Definition at line 1599 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[1];
    nfs_resop4 resops[1];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
 
    compound_init(&compound, argops, resops, "sequence");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
out:
    return status;
}

Referenced by renew_session().

nfs41_setattr()

int nfs41_setattr	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN stateid_arg *	stateid,
		IN nfs41_file_info *	info
	)

Definition at line 1351 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[4];
    nfs_resop4 resops[4];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_setattr_args setattr_args;
    nfs41_setattr_res setattr_res;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res getattr_res;
    bitmap4 attr_request;
 
    compound_init(&compound, argops, resops, "setattr");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_SETATTR, &setattr_args, &setattr_res);
    setattr_args.stateid = stateid;
    setattr_args.info = info;
 
    nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
    getattr_args.attr_request = &attr_request;
    getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    getattr_res.info = info;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    memcpy(&info->attrmask, &attr_request, sizeof(bitmap4));
    nfs41_attr_cache_update(session_name_cache(session),
        file->fh.fileid, info);
 
    if (setattr_res.attrsset.arr[0] & FATTR4_WORD0_SIZE)
        nfs41_superblock_space_changed(file->fh.superblock);
out:
    return status;
}

Referenced by delegation_truncate(), handle_nfs41_set_size(), handle_setacl(), and handle_setexattr().

nfs41_superblock_getattr()

int nfs41_superblock_getattr	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN bitmap4 *	attr_request,
		OUT nfs41_file_info *	info,
		OUT bool_t *	supports_named_attrs
	)

Definition at line 1116 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[4];
    nfs_resop4 resops[4];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res getattr_res;
    nfs41_openattr_args openattr_args;
    nfs41_openattr_res openattr_res;
 
    compound_init(&compound, argops, resops, "getfsattr");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
    getattr_args.attr_request = attr_request;
    getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    getattr_res.info = info;
 
    compound_add_op(&compound, OP_OPENATTR, &openattr_args, &openattr_res);
    openattr_args.createdir = 0;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    status = sequence_res.sr_status;
    if (status) goto out;
    status = putfh_res.status;
    if (status) goto out;
    status = getattr_res.status;
    if (status) goto out;
 
    switch (status = openattr_res.status) {
    case NFS4ERR_NOTSUPP:
        *supports_named_attrs = 0;
        status = NFS4_OK;
        break;
 
    case NFS4ERR_NOENT:
    case NFS4_OK:
        *supports_named_attrs = 1;
        status = NFS4_OK;
        break;
    }
out:
    return status;
}

Referenced by get_superblock_attrs().

nfs41_symlink_follow()

int nfs41_symlink_follow	(	IN nfs41_root *	root,
		IN nfs41_session *	session,
		IN nfs41_path_fh *	symlink,
		OUT nfs41_file_info *	info
	)

Definition at line 146 of file symlink.c.

{
    nfs41_abs_path path;
    nfs41_path_fh file;
    uint32_t depth = 0;
    int status = NO_ERROR;
 
    file.path = &path;
    InitializeSRWLock(&path.lock);
 
    dprintf(2, "--> nfs41_symlink_follow('%s')\n", symlink->path->path);
 
    do {
        if (++depth > NFS41_MAX_SYMLINK_DEPTH) {
            status = ERROR_TOO_MANY_LINKS;
            goto out;
        }
 
        /* construct the target path */
        status = nfs41_symlink_target(session, symlink, &path);
        if (status) goto out;
 
        dprintf(2, "looking up '%s'\n", path.path);
 
        last_component(path.path, path.path + path.len, &file.name);
 
        /* get attributes for the target */
        status = nfs41_lookup(root, session, &path,
            NULL, &file, info, &session);
        if (status) goto out;
 
        symlink = &file;
    } while (info->type == NF4LNK);
out:
    dprintf(2, "<-- nfs41_symlink_follow() returning %d\n", status);
    return status;
}

Referenced by handle_getattr(), handle_open(), and lookup_symlink().

nfs41_symlink_target()

int nfs41_symlink_target	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		OUT nfs41_abs_path *	target
	)

Definition at line 92 of file symlink.c.

{
    char link[NFS41_MAX_PATH_LEN];
    const nfs41_abs_path *path = file->path;
    ptrdiff_t path_offset;
    uint32_t link_len;
    int status;
 
    /* read the link */
    status = nfs41_readlink(session, file, NFS41_MAX_PATH_LEN, link, &link_len);
    if (status) {
        eprintf("nfs41_readlink() for %s failed with %s\n", file->path->path, 
            nfs_error_string(status));
        status = ERROR_PATH_NOT_FOUND;
        goto out;
    }
 
    dprintf(2, "--> nfs41_symlink_target('%s', '%s')\n", path->path, link);
 
    /* append any components after the symlink */
    if (FAILED(StringCchCatA(link, NFS41_MAX_PATH_LEN,
            file->name.name + file->name.len))) {
        status = ERROR_BUFFER_OVERFLOW;
        goto out;
    }
    link_len = (uint32_t)strlen(link);
 
    /* overwrite the last component of the path; get the starting offset */
    path_offset = file->name.name - path->path;
 
    /* copy the path and update it with the results from link */
    if (target != path) {
        target->len = path->len;
        if (FAILED(StringCchCopyNA(target->path, NFS41_MAX_PATH_LEN,
                path->path, path->len))) {
            status = ERROR_BUFFER_OVERFLOW;
            goto out;
        }
    }
    status = abs_path_link(target, target->path + path_offset, link, link_len);
    if (status) {
        eprintf("abs_path_link() for path %s with link %s failed with %d\n", 
            target->path, link, status);
        goto out;
    }
out:
    dprintf(2, "<-- nfs41_symlink_target('%s') returning %d\n",
        target->path, status);
    return status;
}

Referenced by handle_open(), and nfs41_symlink_follow().

nfs41_test_stateid()

enum nfsstat4 nfs41_test_stateid	(	IN nfs41_session *	session,
		IN stateid_arg *	stateid_array,
		IN uint32_t	count,
		OUT uint32_t *	status_array
	)

Definition at line 1900 of file nfs41_ops.c.

{
    enum nfsstat4 status;
    nfs41_compound compound;
    nfs_argop4 argops[2];
    nfs_resop4 resops[2];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_test_stateid_args teststateid_args;
    nfs41_test_stateid_res teststateid_res;
 
    compound_init(&compound, argops, resops, "test_stateid");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_TEST_STATEID, &teststateid_args, &teststateid_res);
    teststateid_args.stateids = stateid_array;
    teststateid_args.count = count;
    teststateid_res.resok.status = status_array;
    teststateid_res.resok.count = count;
 
    status = compound_encode_send_decode(session, &compound, FALSE);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by nfs41_client_state_revoked().

nfs41_unlock()

int nfs41_unlock	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN uint64_t	offset,
		IN uint64_t	length,
		IN OUT stateid_arg *	stateid
	)

Definition at line 966 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_locku_args locku_args;
    nfs41_locku_res locku_res;
 
    compound_init(&compound, argops, resops, "unlock");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_LOCKU, &locku_args, &locku_res);
    /* 18.12.3: the server MUST accept any legal value for locktype */
    locku_args.locktype = READ_LT;
    locku_args.offset = offset;
    locku_args.length = length;
    locku_args.lock_stateid = stateid;
    locku_res.lock_stateid = &stateid->stateid;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by cancel_lock(), and handle_unlock().

nfs41_want_delegation()

enum nfsstat4 nfs41_want_delegation	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN deleg_claim4 *	claim,
		IN uint32_t	want,
		IN bool_t	try_recovery,
		OUT open_delegation4 *	delegation
	)

Definition at line 1624 of file nfs41_ops.c.

{
    enum nfsstat4 status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_want_delegation_args wd_args;
    nfs41_want_delegation_res wd_res;
 
    compound_init(&compound, argops, resops, "want_delegation");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_WANT_DELEGATION, &wd_args, &wd_res);
    wd_args.claim = claim;
    wd_args.want = want;
    wd_res.delegation = delegation;
 
    status = compound_encode_send_decode(session, &compound, try_recovery);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by recover_delegation_want().

nfs41_write()

int nfs41_write	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN stateid_arg *	stateid,
		IN unsigned char *	data,
		IN uint32_t	data_len,
		IN uint64_t	offset,
		IN enum stable_how4	stable,
		OUT uint32_t *	bytes_written,
		OUT nfs41_write_verf *	verf,
		OUT nfs41_file_info *	cinfo
	)

Definition at line 685 of file nfs41_ops.c.

{
    int status;
    nfs41_compound compound;
    nfs_argop4 argops[4];
    nfs_resop4 resops[4];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    nfs41_write_args write_args;
    nfs41_write_res write_res;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res getattr_res = {0};
    bitmap4 attr_request;
    nfs41_file_info info = { 0 }, *pinfo;
 
    nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
 
    compound_init(&compound, argops, resops,
        stateid->stateid.seqid == 0 ? "ds write" : "write");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_WRITE, &write_args, &write_res);
    write_args.stateid = stateid;
    write_args.offset = offset;
    write_args.stable = stable;
    write_args.data_len = data_len;
    write_args.data = data;
    write_res.resok4.verf = verf;
 
    if (cinfo) pinfo = cinfo;
    else pinfo = &info;
 
    if (stable != UNSTABLE4) {
        /* if the write is stable, we can't rely on COMMIT to update
         * the attribute cache, so we do the GETATTR here */
        compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
        getattr_args.attr_request = &attr_request;
        getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
        getattr_res.info = pinfo;
    }
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    if (stable != UNSTABLE4 && pinfo->type != NF4NAMEDATTR) {
        /* update the attribute cache */
        memcpy(&pinfo->attrmask, &getattr_res.obj_attributes.attrmask,
            sizeof(bitmap4));
        nfs41_attr_cache_update(session_name_cache(session),
            file->fh.fileid, pinfo);
    }
 
    *bytes_written = write_res.resok4.count;
 
    /* we shouldn't ever see this, but a buggy server could
     * send us into an infinite loop. return NFS4ERR_IO */
    if (!write_res.resok4.count) {
        status = NFS4ERR_IO;
        eprintf("WRITE succeeded with count=0; returning %s\n",
            nfs_error_string(status));
    }
 
    nfs41_superblock_space_changed(file->fh.superblock);
out:
    return status;
}

Referenced by file_layout_write_thread(), set_ea_value(), and write_to_mds().

pnfs_rpc_getdeviceinfo()

enum nfsstat4 pnfs_rpc_getdeviceinfo	(	IN nfs41_session *	session,
		IN unsigned char *	deviceid,
		OUT pnfs_file_device *	device
	)

Definition at line 2109 of file nfs41_ops.c.

{
    enum nfsstat4 status;
    nfs41_compound compound;
    nfs_argop4 argops[2];
    nfs_resop4 resops[2];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    pnfs_getdeviceinfo_args getdeviceinfo_args;
    pnfs_getdeviceinfo_res getdeviceinfo_res;
 
    compound_init(&compound, argops, resops, "get_deviceinfo");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_GETDEVICEINFO,
        &getdeviceinfo_args, &getdeviceinfo_res);
    getdeviceinfo_args.deviceid = deviceid;
    getdeviceinfo_args.layout_type = PNFS_LAYOUTTYPE_FILE;
    getdeviceinfo_args.maxcount = NFS41_MAX_SERVER_CACHE; /* XXX */
    getdeviceinfo_args.notify_types.count = 0;
    getdeviceinfo_res.u.res_ok.device = device;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by pnfs_file_device_get().

pnfs_rpc_layoutcommit()

enum nfsstat4 pnfs_rpc_layoutcommit	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN stateid4 *	stateid,
		IN uint64_t	offset,
		IN uint64_t	length,
		IN OPTIONAL uint64_t *	new_last_offset,
		IN OPTIONAL nfstime4 *	new_time_modify,
		OUT nfs41_file_info *	info
	)

Definition at line 1999 of file nfs41_ops.c.

{
    enum nfsstat4 status;
    nfs41_compound compound;
    nfs_argop4 argops[4];
    nfs_resop4 resops[4];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    pnfs_layoutcommit_args lc_args;
    pnfs_layoutcommit_res lc_res;
    nfs41_getattr_args getattr_args;
    nfs41_getattr_res getattr_res;
    bitmap4 attr_request;
 
    nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
 
    compound_init(&compound, argops, resops, "layoutcommit");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_LAYOUTCOMMIT, &lc_args, &lc_res);
    lc_args.offset = offset;
    lc_args.length = length;
    lc_args.stateid = stateid;
    lc_args.new_time = new_time_modify;
    lc_args.new_offset = new_last_offset;
 
    compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
    getattr_args.attr_request = &attr_request;
    getattr_res.obj_attributes.attr_vals_len = NFS4_OPAQUE_LIMIT;
    getattr_res.info = info;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    /* update the attribute cache */
    memcpy(&info->attrmask, &getattr_res.obj_attributes.attrmask,
        sizeof(bitmap4));
    nfs41_attr_cache_update(session_name_cache(session),
        file->fh.fileid, info);
out:
    return status;
}

Referenced by layout_commit().

pnfs_rpc_layoutget()

enum nfsstat4 pnfs_rpc_layoutget	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN stateid_arg *	stateid,
		IN enum pnfs_iomode	iomode,
		IN uint64_t	offset,
		IN uint64_t	minlength,
		IN uint64_t	length,
		OUT pnfs_layoutget_res_ok *	layoutget_res
	)

Definition at line 1935 of file nfs41_ops.c.

{
    enum nfsstat4 status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    pnfs_layoutget_args layoutget_args;
    pnfs_layoutget_res layoutget_res = { 0 };
    uint32_t i;
    struct list_entry *entry;
 
    compound_init(&compound, argops, resops, "layoutget");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_LAYOUTGET, &layoutget_args, &layoutget_res);
    layoutget_args.signal_layout_avail = 0;
    layoutget_args.layout_type = PNFS_LAYOUTTYPE_FILE;
    layoutget_args.iomode = iomode;
    layoutget_args.offset = offset;
    layoutget_args.minlength = minlength;
    layoutget_args.length = length;
    layoutget_args.stateid = stateid;
    layoutget_args.maxcount = session->fore_chan_attrs.ca_maxresponsesize - READ_OVERHEAD;
 
    layoutget_res.u.res_ok = layoutget_res_ok;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    if (compound_error(status = compound.res.status))
        goto out;
 
    /* point each file handle to the meta server's superblock */
    list_for_each(entry, &layoutget_res_ok->layouts) {
        pnfs_layout *base = list_container(entry, pnfs_layout, entry);
        if (base->type == PNFS_LAYOUTTYPE_FILE) {
            pnfs_file_layout *layout = (pnfs_file_layout*)base;
            for (i = 0; i < layout->filehandles.count; i++)
                layout->filehandles.arr[i].fh.superblock = file->fh.superblock;
        }
    }
out:
    return status;
}

Referenced by file_layout_fetch().

pnfs_rpc_layoutreturn()

enum nfsstat4 pnfs_rpc_layoutreturn	(	IN nfs41_session *	session,
		IN nfs41_path_fh *	file,
		IN enum pnfs_layout_type	type,
		IN enum pnfs_iomode	iomode,
		IN uint64_t	offset,
		IN uint64_t	length,
		IN stateid4 *	stateid,
		OUT pnfs_layoutreturn_res *	layoutreturn_res
	)

Definition at line 2062 of file nfs41_ops.c.

{
    enum nfsstat4 status;
    nfs41_compound compound;
    nfs_argop4 argops[3];
    nfs_resop4 resops[3];
    nfs41_sequence_args sequence_args;
    nfs41_sequence_res sequence_res;
    nfs41_putfh_args putfh_args;
    nfs41_putfh_res putfh_res;
    pnfs_layoutreturn_args layoutreturn_args;
 
    compound_init(&compound, argops, resops, "layoutreturn");
 
    compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
    nfs41_session_sequence(&sequence_args, session, 0);
 
    compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
    putfh_args.file = file;
    putfh_args.in_recovery = 0;
 
    compound_add_op(&compound, OP_LAYOUTRETURN, &layoutreturn_args, layoutreturn_res);
    layoutreturn_args.reclaim = 0;
    layoutreturn_args.type = type;
    layoutreturn_args.iomode = iomode;
    layoutreturn_args.return_type = PNFS_RETURN_FILE;
    layoutreturn_args.offset = offset;
    layoutreturn_args.length = length;
    layoutreturn_args.stateid = stateid;
 
    status = compound_encode_send_decode(session, &compound, TRUE);
    if (status)
        goto out;
 
    compound_error(status = compound.res.status);
out:
    return status;
}

Referenced by file_layout_return().