ReactOS 0.4.15-dev-7931-gfd331f1
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)
 
stateid4nfs41_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

◆ createtype4

◆ deleg_claim4

◆ exist_lock_owner4

◆ lock_res_denied

◆ lock_res_ok

◆ locker4

◆ nfs41_access_args

◆ nfs41_access_res

◆ nfs41_bind_conn_to_session_args

◆ nfs41_bind_conn_to_session_res

◆ nfs41_callback_secparms

◆ nfs41_commit_args

◆ nfs41_commit_res

◆ nfs41_create_args

◆ nfs41_create_res

◆ nfs41_create_session_args

◆ nfs41_create_session_res

◆ nfs41_delegpurge_res

◆ nfs41_delegreturn_args

◆ nfs41_delegreturn_res

◆ nfs41_destroy_clientid_args

◆ nfs41_destroy_clientid_res

◆ nfs41_destroy_session_args

◆ nfs41_destroy_session_res

◆ nfs41_exchange_id_args

◆ nfs41_exchange_id_res

◆ nfs41_free_stateid_args

◆ nfs41_free_stateid_res

◆ nfs41_getattr_args

◆ nfs41_getattr_res

◆ nfs41_getfh_res

◆ nfs41_link_args

◆ nfs41_link_res

◆ nfs41_lock_args

◆ nfs41_lock_res

◆ nfs41_lockt_args

◆ nfs41_lockt_res

◆ nfs41_locku_args

◆ nfs41_locku_res

◆ nfs41_lookup_args

◆ nfs41_lookup_res

◆ nfs41_op_close_args

◆ nfs41_op_close_res

◆ nfs41_op_open_args

◆ nfs41_op_open_res

◆ nfs41_op_open_res_ok

◆ nfs41_openattr_args

◆ nfs41_openattr_res

◆ nfs41_putfh_args

◆ nfs41_putfh_res

◆ nfs41_putrootfh_res

◆ nfs41_read_args

◆ nfs41_read_res

◆ nfs41_read_res_ok

◆ nfs41_readdir_args

◆ nfs41_readdir_entry

◆ nfs41_readdir_list

◆ nfs41_readdir_res

◆ nfs41_readlink_res

◆ nfs41_reclaim_complete_res

◆ nfs41_remove_args

◆ nfs41_remove_res

◆ nfs41_rename_args

◆ nfs41_rename_res

◆ nfs41_restorefh_res

◆ nfs41_savefh_res

◆ nfs41_secinfo_args

◆ nfs41_secinfo_info

◆ nfs41_secinfo_noname_args

◆ nfs41_secinfo_noname_res

◆ nfs41_sequence_args

◆ nfs41_sequence_res

◆ nfs41_sequence_res_ok

◆ nfs41_setattr_args

◆ nfs41_setattr_res

◆ nfs41_test_stateid_args

◆ nfs41_test_stateid_res

◆ nfs41_want_delegation_args

◆ nfs41_want_delegation_res

◆ nfs41_write_args

◆ nfs41_write_res

◆ nfs41_write_res_ok

◆ open_claim4

◆ open_to_lock_owner4

◆ openflag4

◆ pnfs_getdeviceinfo_args

◆ pnfs_getdeviceinfo_res

◆ pnfs_getdeviceinfo_res_ok

◆ pnfs_layoutcommit_args

◆ pnfs_layoutcommit_res

◆ pnfs_layoutget_args

◆ pnfs_layoutget_res

◆ pnfs_layoutget_res_ok

◆ pnfs_layoutreturn_args

◆ pnfs_layoutreturn_res

◆ specdata4

◆ state_protect4_a

◆ state_protect4_r

◆ 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.

94 {
97
99
100 EXCHGID4_FLAG_USE_NON_PNFS = 0x00010000,
101 EXCHGID4_FLAG_USE_PNFS_MDS = 0x00020000,
102 EXCHGID4_FLAG_USE_PNFS_DS = 0x00040000,
103
104 EXCHGID4_FLAG_MASK_PNFS = 0x00070000,
105
107 EXCHGID4_FLAG_CONFIRMED_R = 0x80000000
108};
@ EXCHGID4_FLAG_CONFIRMED_R
Definition: nfs41_ops.h:107
@ EXCHGID4_FLAG_UPD_CONFIRMED_REC_A
Definition: nfs41_ops.h:106
@ EXCHGID4_FLAG_SUPP_MOVED_REFER
Definition: nfs41_ops.h:95
@ EXCHGID4_FLAG_USE_PNFS_MDS
Definition: nfs41_ops.h:101
@ EXCHGID4_FLAG_MASK_PNFS
Definition: nfs41_ops.h:104
@ EXCHGID4_FLAG_SUPP_MOVED_MIGR
Definition: nfs41_ops.h:96
@ EXCHGID4_FLAG_USE_NON_PNFS
Definition: nfs41_ops.h:100
@ EXCHGID4_FLAG_BIND_PRINC_STATEID
Definition: nfs41_ops.h:98
@ EXCHGID4_FLAG_USE_PNFS_DS
Definition: nfs41_ops.h:102

◆ 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.

236 {
237 SEQ4_STATUS_CB_PATH_DOWN = 0x00000001,
244 SEQ4_STATUS_LEASE_MOVED = 0x00000080,
248 SEQ4_STATUS_DEVID_CHANGED = 0x00000800,
249 SEQ4_STATUS_DEVID_DELETED = 0x00001000
250};
@ SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED
Definition: nfs41_ops.h:241
@ SEQ4_STATUS_CB_PATH_DOWN_SESSION
Definition: nfs41_ops.h:246
@ SEQ4_STATUS_RESTART_RECLAIM_NEEDED
Definition: nfs41_ops.h:245
@ SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING
Definition: nfs41_ops.h:238
@ SEQ4_STATUS_ADMIN_STATE_REVOKED
Definition: nfs41_ops.h:242
@ SEQ4_STATUS_LEASE_MOVED
Definition: nfs41_ops.h:244
@ SEQ4_STATUS_CB_PATH_DOWN
Definition: nfs41_ops.h:237
@ SEQ4_STATUS_BACKCHANNEL_FAULT
Definition: nfs41_ops.h:247
@ SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED
Definition: nfs41_ops.h:240
@ SEQ4_STATUS_RECALLABLE_STATE_REVOKED
Definition: nfs41_ops.h:243
@ SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED
Definition: nfs41_ops.h:239
@ SEQ4_STATUS_DEVID_DELETED
Definition: nfs41_ops.h:249
@ SEQ4_STATUS_DEVID_CHANGED
Definition: nfs41_ops.h:248

◆ 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.

292 {
293 ACCESS4_READ = 0x00000001,
294 ACCESS4_LOOKUP = 0x00000002,
295 ACCESS4_MODIFY = 0x00000004,
296 ACCESS4_EXTEND = 0x00000008,
297 ACCESS4_DELETE = 0x00000010,
298 ACCESS4_EXECUTE = 0x00000020
299};
@ ACCESS4_LOOKUP
Definition: nfs41_ops.h:294
@ ACCESS4_DELETE
Definition: nfs41_ops.h:297
@ ACCESS4_EXECUTE
Definition: nfs41_ops.h:298
@ ACCESS4_MODIFY
Definition: nfs41_ops.h:295
@ ACCESS4_READ
Definition: nfs41_ops.h:293
@ ACCESS4_EXTEND
Definition: nfs41_ops.h:296

◆ anonymous enum

anonymous enum
Enumerator
READ_LT 
WRITE_LT 
READW_LT 
WRITEW_LT 

Definition at line 398 of file nfs41_ops.h.

398 {
399 READ_LT = 1,
400 WRITE_LT = 2,
401 READW_LT = 3, /* blocking read */
402 WRITEW_LT = 4 /* blocking write */
403};
@ READ_LT
Definition: nfs41_ops.h:399
@ READW_LT
Definition: nfs41_ops.h:401
@ WRITEW_LT
Definition: nfs41_ops.h:402
@ WRITE_LT
Definition: nfs41_ops.h:400

◆ 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.

563 {
564 OPEN4_SHARE_ACCESS_READ = 0x00000001,
565 OPEN4_SHARE_ACCESS_WRITE = 0x00000002,
566 OPEN4_SHARE_ACCESS_BOTH = 0x00000003,
567
568 OPEN4_SHARE_DENY_NONE = 0x00000000,
569 OPEN4_SHARE_DENY_READ = 0x00000001,
570 OPEN4_SHARE_DENY_WRITE = 0x00000002,
571 OPEN4_SHARE_DENY_BOTH = 0x00000003,
572
580
583};
@ OPEN4_SHARE_ACCESS_WANT_READ_DELEG
Definition: nfs41_ops.h:575
@ OPEN4_SHARE_ACCESS_WRITE
Definition: nfs41_ops.h:565
@ OPEN4_SHARE_DENY_READ
Definition: nfs41_ops.h:569
@ OPEN4_SHARE_ACCESS_WANT_PUSH_DELEG_WHEN_UNCONTENDED
Definition: nfs41_ops.h:582
@ OPEN4_SHARE_ACCESS_WANT_NO_DELEG
Definition: nfs41_ops.h:578
@ OPEN4_SHARE_ACCESS_BOTH
Definition: nfs41_ops.h:566
@ OPEN4_SHARE_DENY_WRITE
Definition: nfs41_ops.h:570
@ OPEN4_SHARE_ACCESS_WANT_DELEG_MASK
Definition: nfs41_ops.h:573
@ OPEN4_SHARE_ACCESS_WANT_WRITE_DELEG
Definition: nfs41_ops.h:576
@ OPEN4_SHARE_DENY_NONE
Definition: nfs41_ops.h:568
@ OPEN4_SHARE_ACCESS_READ
Definition: nfs41_ops.h:564
@ OPEN4_SHARE_ACCESS_WANT_SIGNAL_DELEG_WHEN_RESRC_AVAIL
Definition: nfs41_ops.h:581
@ OPEN4_SHARE_ACCESS_WANT_NO_PREFERENCE
Definition: nfs41_ops.h:574
@ OPEN4_SHARE_DENY_BOTH
Definition: nfs41_ops.h:571
@ OPEN4_SHARE_ACCESS_WANT_CANCEL
Definition: nfs41_ops.h:579
@ OPEN4_SHARE_ACCESS_WANT_ANY_DELEG
Definition: nfs41_ops.h:577

◆ 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.

650 {
651 OPEN4_RESULT_CONFIRM = 0x00000002,
652 OPEN4_RESULT_LOCKTYPE_POSIX = 0x00000004,
655};
@ OPEN4_RESULT_MAY_NOTIFY_LOCK
Definition: nfs41_ops.h:654
@ OPEN4_RESULT_CONFIRM
Definition: nfs41_ops.h:651
@ OPEN4_RESULT_PRESERVE_UNLINKED
Definition: nfs41_ops.h:653
@ OPEN4_RESULT_LOCKTYPE_POSIX
Definition: nfs41_ops.h:652

◆ 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.

182 {
183 CDFC4_FORE = 0x1,
184 CDFC4_BACK = 0x2,
185 CDFC4_FORE_OR_BOTH = 0x3,
187};
@ CDFC4_FORE
Definition: nfs41_ops.h:183
@ CDFC4_BACK_OR_BOTH
Definition: nfs41_ops.h:186
@ CDFC4_FORE_OR_BOTH
Definition: nfs41_ops.h:185
@ CDFC4_BACK
Definition: nfs41_ops.h:184

◆ channel_dir_from_server4

Enumerator
CDFS4_FORE 
CDFS4_BACK 
CDFS4_BOTH 

Definition at line 189 of file nfs41_ops.h.

189 {
190 CDFS4_FORE = 0x1,
191 CDFS4_BACK = 0x2,
192 CDFS4_BOTH = 0x3
193};
@ CDFS4_BACK
Definition: nfs41_ops.h:191
@ CDFS4_BOTH
Definition: nfs41_ops.h:192
@ CDFS4_FORE
Definition: nfs41_ops.h:190

◆ createmode4

Enumerator
UNCHECKED4 
GUARDED4 
EXCLUSIVE4 
EXCLUSIVE4_1 

Definition at line 539 of file nfs41_ops.h.

539 {
540 UNCHECKED4 = 0,
541 GUARDED4 = 1,
542 EXCLUSIVE4 = 2,
543 EXCLUSIVE4_1 = 3
544};
@ GUARDED4
Definition: nfs41_ops.h:541
@ EXCLUSIVE4
Definition: nfs41_ops.h:542
@ UNCHECKED4
Definition: nfs41_ops.h:540
@ EXCLUSIVE4_1
Definition: nfs41_ops.h:543

◆ 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.

30 {
31 OP_ACCESS = 3,
32 OP_CLOSE = 4,
33 OP_COMMIT = 5,
34 OP_CREATE = 6,
35 OP_DELEGPURGE = 7,
37 OP_GETATTR = 9,
38 OP_GETFH = 10,
39 OP_LINK = 11,
40 OP_LOCK = 12,
41 OP_LOCKT = 13,
42 OP_LOCKU = 14,
43 OP_LOOKUP = 15,
44 OP_LOOKUPP = 16,
45 OP_NVERIFY = 17,
46 OP_OPEN = 18,
47 OP_OPENATTR = 19,
48 OP_OPEN_CONFIRM = 20, /* Mandatory not-to-implement */
50 OP_PUTFH = 22,
51 OP_PUTPUBFH = 23,
52 OP_PUTROOTFH = 24,
53 OP_READ = 25,
54 OP_READDIR = 26,
55 OP_READLINK = 27,
56 OP_REMOVE = 28,
57 OP_RENAME = 29,
58 OP_RENEW = 30, /* Mandatory not-to-implement */
59 OP_RESTOREFH = 31,
60 OP_SAVEFH = 32,
61 OP_SECINFO = 33,
62 OP_SETATTR = 34,
63 OP_SETCLIENTID = 35, /* Mandatory not-to-implement */
64 OP_SETCLIENTID_CONFIRM = 36, /* Mandatory not-to-implement */
65 OP_VERIFY = 37,
66 OP_WRITE = 38,
67 OP_RELEASE_LOCKOWNER = 39, /* Mandatory not-to-implement */
68
69 /* new operations for NFSv4.1 */
72 OP_EXCHANGE_ID = 42,
75 OP_FREE_STATEID = 45,
79 OP_LAYOUTCOMMIT = 49,
80 OP_LAYOUTGET = 50,
81 OP_LAYOUTRETURN = 51,
83 OP_SEQUENCE = 53,
84 OP_SET_SSV = 54,
85 OP_TEST_STATEID = 55,
89 OP_ILLEGAL = 10044
90};
@ OP_FREE_STATEID
Definition: nfs41_ops.h:75
@ OP_GETDEVICELIST
Definition: nfs41_ops.h:78
@ OP_RESTOREFH
Definition: nfs41_ops.h:59
@ OP_RECLAIM_COMPLETE
Definition: nfs41_ops.h:88
@ OP_WRITE
Definition: nfs41_ops.h:66
@ OP_SETATTR
Definition: nfs41_ops.h:62
@ OP_DELEGPURGE
Definition: nfs41_ops.h:35
@ OP_PUTPUBFH
Definition: nfs41_ops.h:51
@ OP_DESTROY_SESSION
Definition: nfs41_ops.h:74
@ OP_OPEN
Definition: nfs41_ops.h:46
@ OP_ACCESS
Definition: nfs41_ops.h:31
@ OP_SECINFO_NO_NAME
Definition: nfs41_ops.h:82
@ OP_GETFH
Definition: nfs41_ops.h:38
@ OP_LOOKUPP
Definition: nfs41_ops.h:44
@ OP_GET_DIR_DELEGATION
Definition: nfs41_ops.h:76
@ OP_SETCLIENTID
Definition: nfs41_ops.h:63
@ OP_CREATE_SESSION
Definition: nfs41_ops.h:73
@ OP_GETDEVICEINFO
Definition: nfs41_ops.h:77
@ OP_SECINFO
Definition: nfs41_ops.h:61
@ OP_DESTROY_CLIENTID
Definition: nfs41_ops.h:87
@ OP_RENEW
Definition: nfs41_ops.h:58
@ OP_TEST_STATEID
Definition: nfs41_ops.h:85
@ OP_READLINK
Definition: nfs41_ops.h:55
@ OP_LAYOUTCOMMIT
Definition: nfs41_ops.h:79
@ OP_LOCKU
Definition: nfs41_ops.h:42
@ OP_READDIR
Definition: nfs41_ops.h:54
@ OP_LAYOUTRETURN
Definition: nfs41_ops.h:81
@ OP_LAYOUTGET
Definition: nfs41_ops.h:80
@ OP_OPEN_DOWNGRADE
Definition: nfs41_ops.h:49
@ OP_PUTROOTFH
Definition: nfs41_ops.h:52
@ OP_VERIFY
Definition: nfs41_ops.h:65
@ OP_SAVEFH
Definition: nfs41_ops.h:60
@ OP_EXCHANGE_ID
Definition: nfs41_ops.h:72
@ OP_CLOSE
Definition: nfs41_ops.h:32
@ OP_ILLEGAL
Definition: nfs41_ops.h:89
@ OP_LOCKT
Definition: nfs41_ops.h:41
@ OP_CREATE
Definition: nfs41_ops.h:34
@ OP_RENAME
Definition: nfs41_ops.h:57
@ OP_OPEN_CONFIRM
Definition: nfs41_ops.h:48
@ OP_GETATTR
Definition: nfs41_ops.h:37
@ OP_BIND_CONN_TO_SESSION
Definition: nfs41_ops.h:71
@ OP_SEQUENCE
Definition: nfs41_ops.h:83
@ OP_READ
Definition: nfs41_ops.h:53
@ OP_PUTFH
Definition: nfs41_ops.h:50
@ OP_LOOKUP
Definition: nfs41_ops.h:43
@ OP_RELEASE_LOCKOWNER
Definition: nfs41_ops.h:67
@ OP_LOCK
Definition: nfs41_ops.h:40
@ OP_COMMIT
Definition: nfs41_ops.h:33
@ OP_LINK
Definition: nfs41_ops.h:39
@ OP_WANT_DELEGATION
Definition: nfs41_ops.h:86
@ OP_DELEGRETURN
Definition: nfs41_ops.h:36
@ OP_OPENATTR
Definition: nfs41_ops.h:47
@ OP_NVERIFY
Definition: nfs41_ops.h:45
@ OP_REMOVE
Definition: nfs41_ops.h:56
@ OP_SETCLIENTID_CONFIRM
Definition: nfs41_ops.h:64
@ OP_SET_SSV
Definition: nfs41_ops.h:84
@ OP_BACKCHANNEL_CTL
Definition: nfs41_ops.h:70

◆ 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.

592 {
593 CLAIM_NULL = 0,
594 CLAIM_PREVIOUS = 1,
597 CLAIM_FH = 4,
600};
@ CLAIM_NULL
Definition: nfs41_ops.h:593
@ CLAIM_PREVIOUS
Definition: nfs41_ops.h:594
@ CLAIM_DELEG_CUR_FH
Definition: nfs41_ops.h:598
@ CLAIM_DELEGATE_CUR
Definition: nfs41_ops.h:595
@ CLAIM_FH
Definition: nfs41_ops.h:597
@ CLAIM_DELEGATE_PREV
Definition: nfs41_ops.h:596
@ CLAIM_DELEG_PREV_FH
Definition: nfs41_ops.h:599

◆ 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.

585 {
590};
@ OPEN_DELEGATE_NONE_EXT
Definition: nfs41_ops.h:589
@ OPEN_DELEGATE_NONE
Definition: nfs41_ops.h:586
@ OPEN_DELEGATE_READ
Definition: nfs41_ops.h:587
@ OPEN_DELEGATE_WRITE
Definition: nfs41_ops.h:588

◆ opentype4

Enumerator
OPEN4_NOCREATE 
OPEN4_CREATE 

Definition at line 552 of file nfs41_ops.h.

552 {
553 OPEN4_NOCREATE = 0,
554 OPEN4_CREATE = 1
555};
@ OPEN4_CREATE
Definition: nfs41_ops.h:554
@ OPEN4_NOCREATE
Definition: nfs41_ops.h:553

◆ sec_flavor

Enumerator
RPC_GSS_SVC_NONE 
RPC_GSS_SVC_INTEGRITY 
RPC_GSS_SVC_PRIVACY 

Definition at line 861 of file nfs41_ops.h.

861 {
865};
@ RPC_GSS_SVC_NONE
Definition: nfs41_ops.h:862
@ RPC_GSS_SVC_INTEGRITY
Definition: nfs41_ops.h:863
@ RPC_GSS_SVC_PRIVACY
Definition: nfs41_ops.h:864

◆ secinfo_no_name_type

Enumerator
SECINFO_STYLE4_CURRENT_FH 
SECINFO_STYLE4_PARENT 

Definition at line 884 of file nfs41_ops.h.

884 {
887};
@ SECINFO_STYLE4_CURRENT_FH
Definition: nfs41_ops.h:885
@ SECINFO_STYLE4_PARENT
Definition: nfs41_ops.h:886

◆ stable_how4

Enumerator
UNSTABLE4 
DATA_SYNC4 
FILE_SYNC4 

Definition at line 835 of file nfs41_ops.h.

835 {
836 UNSTABLE4 = 0,
837 DATA_SYNC4 = 1,
838 FILE_SYNC4 = 2
839};
@ FILE_SYNC4
Definition: nfs41_ops.h:838
@ DATA_SYNC4
Definition: nfs41_ops.h:837
@ UNSTABLE4
Definition: nfs41_ops.h:836

◆ state_protect_how4

Enumerator
SP4_NONE 
SP4_MACH_CRED 
SP4_SSV 

Definition at line 110 of file nfs41_ops.h.

110 {
111 SP4_NONE = 0,
112 SP4_MACH_CRED = 1,
113 SP4_SSV = 2
state_protect_how4
Definition: nfs41_ops.h:110
@ SP4_NONE
Definition: nfs41_ops.h:111
@ SP4_MACH_CRED
Definition: nfs41_ops.h:112
@ SP4_SSV
Definition: nfs41_ops.h:113

◆ 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.

275 {
282};
@ STATEID_DELEG_DIR
Definition: nfs41_ops.h:279
@ STATEID_LAYOUT
Definition: nfs41_ops.h:280
@ STATEID_LOCK
Definition: nfs41_ops.h:277
@ STATEID_DELEG_FILE
Definition: nfs41_ops.h:278
@ STATEID_SPECIAL
Definition: nfs41_ops.h:281
@ STATEID_OPEN
Definition: nfs41_ops.h:276

◆ time_how4

Enumerator
SET_TO_SERVER_TIME4 
SET_TO_CLIENT_TIME4 

Definition at line 776 of file nfs41_ops.h.

776 {
779};
@ SET_TO_SERVER_TIME4
Definition: nfs41_ops.h:777
@ SET_TO_CLIENT_TIME4
Definition: nfs41_ops.h:778

◆ 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.

602 {
603 WND4_NOT_WANTED = 0,
604 WND4_CONTENTION = 1,
605 WND4_RESOURCE = 2,
610 WND4_CANCELED = 7,
611 WND4_IS_DIR = 8
612};
@ WND4_IS_DIR
Definition: nfs41_ops.h:611
@ WND4_WRITE_DELEG_NOT_SUPP_FTYPE
Definition: nfs41_ops.h:607
@ WND4_NOT_SUPP_UPGRADE
Definition: nfs41_ops.h:608
@ WND4_RESOURCE
Definition: nfs41_ops.h:605
@ WND4_NOT_SUPP_FTYPE
Definition: nfs41_ops.h:606
@ WND4_NOT_WANTED
Definition: nfs41_ops.h:603
@ WND4_CONTENTION
Definition: nfs41_ops.h:604
@ WND4_NOT_SUPP_DOWNGRADE
Definition: nfs41_ops.h:609
@ WND4_CANCELED
Definition: nfs41_ops.h:610

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.

1560{
1561 int status;
1562 nfs41_compound compound;
1563 nfs_argop4 argops[3];
1564 nfs_resop4 resops[3];
1565 nfs41_sequence_args sequence_args;
1566 nfs41_sequence_res sequence_res;
1567 nfs41_putfh_args putfh_args;
1568 nfs41_putfh_res putfh_res;
1569 nfs41_access_args access_args;
1571
1572 compound_init(&compound, argops, resops, "access");
1573
1574 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1575 nfs41_session_sequence(&sequence_args, session, 0);
1576
1577 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1578 putfh_args.file = file;
1579 putfh_args.in_recovery = 0;
1580
1581 compound_add_op(&compound, OP_ACCESS, &access_args, &access_res);
1582 access_args.access = requested;
1583
1585 if (status)
1586 goto out;
1587
1588 if (compound_error(status = compound.res.status))
1589 goto out;
1590
1591 if (supported)
1592 *supported = access_res.supported;
1593 if (access)
1594 *access = access_res.access;
1595out:
1596 return status;
1597}
#define TRUE
Definition: types.h:120
GLuint GLint GLboolean GLint GLenum access
Definition: glext.h:7866
void nfs41_session_sequence(struct __nfs41_sequence_args *args, nfs41_session *session, bool_t cachethis)
void compound_init(nfs41_compound *compound, nfs_argop4 *argops, nfs_resop4 *resops, const char *tag)
int compound_encode_send_decode(nfs41_session *session, nfs41_compound *compound, bool_t try_recovery)
void compound_add_op(nfs41_compound *compound, uint32_t opnum, void *arg, void *res)
int compound_error(int status)
static FILE * out
Definition: regtests2xml.c:44
nfs41_compound_res res
nfs41_path_fh * file
Definition: nfs41_ops.h:510
Definition: fci.c:127
Definition: ps.c:97

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.

189{
190 int status;
191 nfs41_compound compound;
192 nfs_argop4 argop;
193 nfs_resop4 resop;
194 nfs41_bind_conn_to_session_args bind_args = { 0 };
195 nfs41_bind_conn_to_session_res bind_res = { 0 };
196
197 compound_init(&compound, &argop, &resop, "bind_conn_to_session");
198
199 compound_add_op(&compound, OP_BIND_CONN_TO_SESSION, &bind_args, &bind_res);
200 bind_args.sessionid = (unsigned char *)sessionid;
201 bind_args.dir = dir;
202
204 (char*)&compound.args, (char*)&compound.res);
205 if (status)
206 goto out;
207
208 compound_error(status = compound.res.status);
209
210out:
211 return status;
212}
unsigned int dir
Definition: maze.c:112
int nfs41_send_compound(IN nfs41_rpc_clnt *rpc, IN char *inbuf, OUT char *outbuf)
Definition: nfs41_rpc.c:337
enum channel_dir_from_client4 dir
Definition: nfs41_ops.h:197
nfs41_compound_args args

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.

36{
37 int status;
38
39 /* first look for cached attributes */
41 file->fh.fileid, info);
42
43 if (status) {
44 /* fetch attributes from the server */
45 bitmap4 attr_request;
46 nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
47
48 status = nfs41_getattr(session, file, &attr_request, info);
49 if (status) {
50 eprintf("nfs41_getattr() failed with %s\n",
53 }
54 }
55 return status;
56}
int nfs_to_windows_error(int status, int default_error)
Definition: util.c:235
void eprintf(LPCSTR format,...)
Definition: daemon_debug.c:86
const char * nfs_error_string(int status)
Definition: daemon_debug.c:370
int nfs41_attr_cache_lookup(IN struct nfs41_name_cache *cache, IN uint64_t fileid, OUT nfs41_file_info *info_out)
Definition: name_cache.c:859
static __inline struct nfs41_name_cache * session_name_cache(IN nfs41_session *session)
Definition: name_cache.h:34
static __inline void nfs41_superblock_getattr_mask(IN const nfs41_superblock *superblock, OUT bitmap4 *attrs)
Definition: nfs41.h:448
int nfs41_getattr(IN nfs41_session *session, IN OPTIONAL nfs41_path_fh *file, IN bitmap4 *attr_request, OUT nfs41_file_info *info)
Definition: nfs41_ops.c:1063
#define ERROR_BAD_NET_RESP
Definition: winerror.h:150

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.

631{
632 int status;
633 nfs41_compound compound;
634 nfs_argop4 argops[4];
635 nfs_resop4 resops[4];
636 nfs41_sequence_args sequence_args;
637 nfs41_sequence_res sequence_res;
638 nfs41_putfh_args putfh_args;
639 nfs41_putfh_res putfh_res;
640 nfs41_op_close_args close_args;
641 nfs41_op_close_res close_res;
642 nfs41_getattr_args getattr_args;
643 nfs41_getattr_res getattr_res;
644 bitmap4 attr_request;
646
647 nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
648
649 compound_init(&compound, argops, resops, "close");
650
651 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
652 nfs41_session_sequence(&sequence_args, session, 1);
653
654 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
655 putfh_args.file = file;
656 putfh_args.in_recovery = 0;
657
658 compound_add_op(&compound, OP_CLOSE, &close_args, &close_res);
659 close_args.stateid = stateid;
660
661 compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
662 getattr_args.attr_request = &attr_request;
664 getattr_res.info = &info;
665
667 if (status)
668 goto out;
669
670 if (compound_error(status = compound.res.status))
671 goto out;
672
673 if (info.type == NF4NAMEDATTR)
674 goto out;
675
676 /* update the attributes of the parent directory */
677 memcpy(&info.attrmask, &getattr_res.obj_attributes.attrmask,
678 sizeof(bitmap4));
680 file->fh.fileid, &info);
681out:
682 return status;
683}
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
int nfs41_attr_cache_update(IN struct nfs41_name_cache *cache, IN uint64_t fileid, IN const nfs41_file_info *info)
Definition: name_cache.c:891
@ NF4NAMEDATTR
Definition: nfs41_const.h:302
#define NFS4_OPAQUE_LIMIT
Definition: nfs41_const.h:31
uint32_t attr_vals_len
Definition: nfs41_types.h:161
bitmap4 attrmask
Definition: nfs41_types.h:160
bitmap4 * attr_request
Definition: nfs41_ops.h:527
nfs41_file_info * info
Definition: nfs41_ops.h:534
stateid_arg * stateid
Definition: nfs41_ops.h:316

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.

841{
842 int status;
843 nfs41_compound compound;
844 nfs_argop4 argops[4];
845 nfs_resop4 resops[4];
846 nfs41_sequence_args sequence_args;
847 nfs41_sequence_res sequence_res;
848 nfs41_putfh_args putfh_args;
849 nfs41_putfh_res putfh_res;
850 nfs41_commit_args commit_args;
851 nfs41_commit_res commit_res;
852 nfs41_getattr_args getattr_args;
853 nfs41_getattr_res getattr_res = {0};
854 bitmap4 attr_request;
855 nfs41_file_info info, *pinfo;
856
857 compound_init(&compound, argops, resops,
858 do_getattr ? "commit" : "ds commit");
859
860 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
861 nfs41_session_sequence(&sequence_args, session, 1);
862
863 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
864 putfh_args.file = file;
865 putfh_args.in_recovery = 0;
866
867 compound_add_op(&compound, OP_COMMIT, &commit_args, &commit_res);
868 commit_args.offset = offset;
869 commit_args.count = count;
870 commit_res.verf = verf;
871
872 /* send a GETATTR request to update the attribute cache,
873 * but not if we're talking to a data server! */
874 if (cinfo) pinfo = cinfo;
875 else pinfo = &info;
876 if (do_getattr) {
877 nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
878
879 compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
880 getattr_args.attr_request = &attr_request;
882 getattr_res.info = pinfo;
883 }
884
886 if (status)
887 goto out;
888
889 if (compound_error(status = compound.res.status))
890 goto out;
891
892 if (do_getattr) {
893 /* update the attribute cache */
894 memcpy(&pinfo->attrmask, &getattr_res.obj_attributes.attrmask,
895 sizeof(bitmap4));
897 file->fh.fileid, pinfo);
898 }
899 nfs41_superblock_space_changed(file->fh.superblock);
900out:
901 return status;
902}
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLintptr offset
Definition: glext.h:5920
void nfs41_superblock_space_changed(IN nfs41_superblock *superblock)
nfs41_write_verf * verf
Definition: nfs41_ops.h:332

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.

538{
539 int status;
540 nfs41_compound compound;
541 nfs_argop4 argops[8];
542 nfs_resop4 resops[8];
543 nfs41_sequence_args sequence_args;
544 nfs41_sequence_res sequence_res;
545 nfs41_putfh_args putfh_args;
546 nfs41_putfh_res putfh_res;
547 nfs41_create_args create_args;
548 nfs41_create_res create_res;
549 nfs41_getfh_res getfh_res;
550 nfs41_getattr_args getattr_args;
551 nfs41_getattr_res getattr_res, pgetattr_res;
552 bitmap4 attr_request;
553 nfs41_file_info dir_info;
554 nfs41_savefh_res savefh_res;
555 nfs41_restorefh_res restorefh_res;
556
557 nfs41_superblock_getattr_mask(parent->fh.superblock, &attr_request);
558
559 compound_init(&compound, argops, resops, "create");
560
561 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
562 nfs41_session_sequence(&sequence_args, session, 1);
563
564 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
565 putfh_args.file = parent;
566 putfh_args.in_recovery = 0;
567
568 compound_add_op(&compound, OP_SAVEFH, NULL, &savefh_res);
569
570 compound_add_op(&compound, OP_CREATE, &create_args, &create_res);
571 create_args.objtype.type = type;
572 if (type == NF4LNK) {
573 create_args.objtype.u.lnk.linkdata = symlink;
574 create_args.objtype.u.lnk.linkdata_len = (uint32_t)strlen(symlink);
575 }
576 create_args.name = &file->name;
577 create_args.createattrs = createattrs;
579 parent->fh.superblock, &createattrs->attrmask);
580
581 compound_add_op(&compound, OP_GETFH, NULL, &getfh_res);
582 getfh_res.fh = &file->fh;
583
584 compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
585 getattr_args.attr_request = &attr_request;
587 getattr_res.info = info;
588
589 compound_add_op(&compound, OP_RESTOREFH, NULL, &restorefh_res);
590
591 compound_add_op(&compound, OP_GETATTR, &getattr_args, &pgetattr_res);
592 getattr_args.attr_request = &attr_request;
594 pgetattr_res.info = &dir_info;
595
597 if (status)
598 goto out;
599
600 if (compound_error(status = compound.res.status))
601 goto out;
602
603 /* fill in the file handle's fileid and superblock */
604 file->fh.fileid = info->fileid;
605 file->fh.superblock = parent->fh.superblock;
606
607 /* update the attributes of the parent directory */
608 memcpy(&dir_info.attrmask, &pgetattr_res.obj_attributes.attrmask,
609 sizeof(bitmap4));
611 parent->fh.fileid, &dir_info);
612
613 /* add the new file handle and attributes to the name cache */
614 memcpy(&info->attrmask, &getattr_res.obj_attributes.attrmask,
615 sizeof(bitmap4));
618 file->path->path, &file->name, &file->fh,
619 info, &create_res.cinfo, OPEN_DELEGATE_NONE);
621
622 nfs41_superblock_space_changed(file->fh.superblock);
623out:
624 return status;
625}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define NULL
Definition: types.h:112
VOID WINAPI ReleaseSRWLockShared(PSRWLOCK Lock)
Definition: sync.c:89
VOID WINAPI AcquireSRWLockShared(PSRWLOCK Lock)
Definition: sync.c:61
r parent
Definition: btrfs.c:3010
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
int nfs41_name_cache_insert(IN struct nfs41_name_cache *cache, IN const char *path, IN const nfs41_component *name, IN OPTIONAL const nfs41_fh *fh, IN OPTIONAL const nfs41_file_info *info, IN OPTIONAL const change_info4 *cinfo, IN enum open_delegation_type4 delegation)
Definition: name_cache.c:923
static __inline void nfs41_superblock_supported_attrs(IN const nfs41_superblock *superblock, IN OUT bitmap4 *attrs)
Definition: nfs41.h:454
@ NF4LNK
Definition: nfs41_const.h:298
#define uint32_t
Definition: nsiface.idl:61
uint32_t type
Definition: nfs41_ops.h:343
union __createtype4::@47 u
struct __createtype4::@47::__create_type_lnk lnk
createtype4 objtype
Definition: nfs41_ops.h:356
const nfs41_component * name
Definition: nfs41_ops.h:357
nfs41_file_info * createattrs
Definition: nfs41_ops.h:358
change_info4 cinfo
Definition: nfs41_ops.h:364
nfs41_fh * fh
Definition: nfs41_ops.h:504
WCHAR * path
Definition: filesystem.c:122
char name[1]
Definition: fci.c:135

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.

1668{
1669 int status;
1670 nfs41_compound compound;
1671 nfs_argop4 argops[2];
1672 nfs_resop4 resops[2];
1673 nfs41_sequence_args sequence_args;
1674 nfs41_sequence_res sequence_res;
1675 nfs41_delegpurge_res dp_res;
1676
1677 compound_init(&compound, argops, resops, "delegpurge");
1678
1679 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1680 nfs41_session_sequence(&sequence_args, session, 0);
1681
1682 compound_add_op(&compound, OP_DELEGPURGE, NULL, &dp_res);
1683
1685 if (status)
1686 goto out;
1687
1688 compound_error(status = compound.res.status);
1689out:
1690 return status;
1691}

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.

1698{
1699 int status;
1700 nfs41_compound compound;
1701 nfs_argop4 argops[3];
1702 nfs_resop4 resops[3];
1703 nfs41_sequence_args sequence_args;
1704 nfs41_sequence_res sequence_res;
1705 nfs41_putfh_args putfh_args;
1706 nfs41_putfh_res putfh_res;
1707 nfs41_delegreturn_args dr_args;
1708 nfs41_delegreturn_res dr_res;
1709
1710 compound_init(&compound, argops, resops, "delegreturn");
1711
1712 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1713 nfs41_session_sequence(&sequence_args, session, 0);
1714
1715 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1716 putfh_args.file = file;
1717 putfh_args.in_recovery = 0;
1718
1719 compound_add_op(&compound, OP_DELEGRETURN, &dr_args, &dr_res);
1720 dr_args.stateid = stateid;
1721
1722 status = compound_encode_send_decode(session, &compound, try_recovery);
1723 if (status)
1724 goto out;
1725
1726 if (compound_error(status = compound.res.status))
1727 goto out;
1728
1731 file->fh.fileid, file->path->path, &file->name);
1733out:
1734 return status;
1735}
int nfs41_name_cache_delegreturn(IN struct nfs41_name_cache *cache, IN uint64_t fileid, IN const char *path, IN const nfs41_component *name)
Definition: name_cache.c:1012
stateid_arg * stateid
Definition: nfs41_ops.h:377

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.

245{
246 int status;
247 nfs41_compound compound;
248 nfs_argop4 argops;
249 nfs_resop4 resops;
252
253 compound_init(&compound, &argops, &resops, "destroy_clientid");
254
255 compound_add_op(&compound, OP_DESTROY_CLIENTID, &dc_args, &dc_res);
256 dc_args.dca_clientid = clientid;
257
258 status = nfs41_send_compound(rpc, (char *)&compound.args,
259 (char *)&compound.res);
260 if (status)
261 goto out;
262
263 compound_error(status = compound.res.status);
264out:
265 return status;
266}

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.

216{
217 int status;
218 nfs41_compound compound;
219 nfs_argop4 argop;
220 nfs_resop4 resop;
223
224 compound_init(&compound, &argop, &resop, "destroy_session");
225
226 compound_add_op(&compound, OP_DESTROY_SESSION, &ds_args, &ds_res);
227 ds_args.dsa_sessionid = session->session_id;
228
229 /* don't attempt to recover from BADSESSION/STALE_CLIENTID */
231 if (status)
232 goto out;
233
234 status = compound.res.status;
235 if (status)
236 eprintf("%s failed with status %d.\n",
238out:
239 return status;
240}
const char * nfs_opnum_to_string(int opnum)
Definition: daemon_debug.c:305
#define FALSE
Definition: types.h:117
unsigned char * dsa_sessionid
Definition: nfs41_ops.h:209

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.

41{
42 int status = 0;
43 nfs41_compound compound;
44 nfs_argop4 argop;
45 nfs_resop4 resop;
47
48 compound_init(&compound, &argop, &resop, "exchange_id");
49
50 compound_add_op(&compound, OP_EXCHANGE_ID, &ex_id, res_out);
51 ex_id.eia_clientowner = owner;
52 ex_id.eia_flags = flags_in;
55
56 res_out->server_owner.so_major_id_len = NFS4_OPAQUE_LIMIT;
57 res_out->server_scope_len = NFS4_OPAQUE_LIMIT;
58
59 status = nfs41_send_compound(rpc, (char *)&compound.args,
60 (char *)&compound.res);
61 if (status)
62 goto out;
63
64 compound_error(status = compound.res.status);
65out:
66 return status;
67}
client_owner4 * eia_clientowner
Definition: nfs41_ops.h:121
nfs_impl_id4 * eia_client_impl_id
Definition: nfs41_ops.h:124
state_protect4_a eia_state_protect
Definition: nfs41_ops.h:123
state_protect_how4 spa_how
Definition: nfs41_ops.h:117

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.

1873{
1874 enum nfsstat4 status;
1875 nfs41_compound compound;
1876 nfs_argop4 argops[2];
1877 nfs_resop4 resops[2];
1878 nfs41_sequence_args sequence_args;
1879 nfs41_sequence_res sequence_res;
1880 nfs41_free_stateid_args freestateid_args;
1881 nfs41_free_stateid_res freestateid_res;
1882
1883 compound_init(&compound, argops, resops, "free_stateid");
1884
1885 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1886 nfs41_session_sequence(&sequence_args, session, 0);
1887
1888 compound_add_op(&compound, OP_FREE_STATEID, &freestateid_args, &freestateid_res);
1889 freestateid_args.stateid = stateid;
1890
1892 if (status)
1893 goto out;
1894
1895 compound_error(status = compound.res.status);
1896out:
1897 return status;
1898}
nfsstat4
Definition: nfs41_const.h:86

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.

1742{
1743 enum nfsstat4 status;
1744 nfs41_compound compound;
1745 nfs_argop4 argops[4];
1746 nfs_resop4 resops[4];
1747 nfs41_sequence_args sequence_args;
1748 nfs41_sequence_res sequence_res;
1749 nfs41_putfh_args putfh_args;
1750 nfs41_putfh_res putfh_res;
1751 nfs41_lookup_args lookup_args;
1752 nfs41_lookup_res lookup_res;
1753 nfs41_getattr_args getattr_args;
1754 nfs41_getattr_res getattr_res;
1755 bitmap4 attr_request = { 1, { FATTR4_WORD0_FS_LOCATIONS } };
1757
1758 compound_init(&compound, argops, resops, "fs_locations");
1759
1760 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1761 nfs41_session_sequence(&sequence_args, session, 0);
1762
1763 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1764 putfh_args.file = parent;
1765 putfh_args.in_recovery = 0;
1766
1767 compound_add_op(&compound, OP_LOOKUP, &lookup_args, &lookup_res);
1768 lookup_args.name = name;
1769
1770 compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
1771 getattr_args.attr_request = &attr_request;
1772 info.fs_locations = locations;
1774 getattr_res.info = &info;
1775
1777 if (status)
1778 goto out;
1779
1780 compound_error(status = compound.res.status);
1781out:
1782 return status;
1783}
GLsizei const GLint * locations
Definition: glext.h:10542
@ FATTR4_WORD0_FS_LOCATIONS
Definition: nfs41_const.h:236
const nfs41_component * name
Definition: nfs41_ops.h:492
Definition: name.c:39

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.

1068{
1069 int status;
1070 nfs41_compound compound;
1071 nfs_argop4 argops[3];
1072 nfs_resop4 resops[3];
1073 nfs41_sequence_args sequence_args;
1074 nfs41_sequence_res sequence_res;
1075 nfs41_putfh_args putfh_args;
1076 nfs41_putfh_res putfh_res;
1077 nfs41_getattr_args getattr_args;
1078 nfs41_getattr_res getattr_res;
1079
1080 compound_init(&compound, argops, resops, "getattr");
1081
1082 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1083 nfs41_session_sequence(&sequence_args, session, 0);
1084
1085 if (file) {
1086 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1087 putfh_args.file = file;
1088 putfh_args.in_recovery = 0;
1089 } else {
1090 compound_add_op(&compound, OP_PUTROOTFH, NULL, &putfh_res);
1091 }
1092
1093 compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
1094 getattr_args.attr_request = attr_request;
1096 getattr_res.info = info;
1097
1099 if (status)
1100 goto out;
1101
1102 if (compound_error(status = compound.res.status))
1103 goto out;
1104
1105 if (file) {
1106 /* update the name cache with whatever attributes we got */
1107 memcpy(&info->attrmask, &getattr_res.obj_attributes.attrmask,
1108 sizeof(bitmap4));
1110 file->fh.fileid, info);
1111 }
1112out:
1113 return status;
1114}

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.

1413{
1414 int status;
1415 nfs41_compound compound;
1416 nfs_argop4 argops[9];
1417 nfs_resop4 resops[9];
1418 nfs41_sequence_args sequence_args;
1419 nfs41_sequence_res sequence_res;
1420 nfs41_putfh_args putfh_args[2];
1421 nfs41_putfh_res putfh_res[2];
1422 nfs41_savefh_res savefh_res;
1423 nfs41_link_args link_args;
1424 nfs41_link_res link_res;
1425 nfs41_lookup_args lookup_args;
1426 nfs41_lookup_res lookup_res;
1427 nfs41_getfh_res getfh_res;
1428 nfs41_getattr_args getattr_args[2];
1429 nfs41_getattr_res getattr_res[2];
1430 nfs41_file_info info = { 0 };
1432
1433 nfs41_superblock_getattr_mask(src->fh.superblock, &info.attrmask);
1434 nfs41_superblock_getattr_mask(dst_dir->fh.superblock, &cinfo->attrmask);
1435 cinfo->attrmask.arr[0] |= FATTR4_WORD0_FSID;
1436
1437 compound_init(&compound, argops, resops, "link");
1438
1439 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1440 nfs41_session_sequence(&sequence_args, session, 1);
1441
1442 /* PUTFH(src) */
1443 compound_add_op(&compound, OP_PUTFH, &putfh_args[0], &putfh_res[0]);
1444 putfh_args[0].file = src;
1445 putfh_args[0].in_recovery = 0;
1446
1447 compound_add_op(&compound, OP_SAVEFH, NULL, &savefh_res);
1448
1449 /* PUTFH(dst_dir) */
1450 compound_add_op(&compound, OP_PUTFH, &putfh_args[1], &putfh_res[1]);
1451 putfh_args[1].file = dst_dir;
1452 putfh_args[1].in_recovery = 0;
1453
1454 compound_add_op(&compound, OP_LINK, &link_args, &link_res);
1455 link_args.newname = target;
1456
1457 /* GETATTR(dst_dir) */
1458 compound_add_op(&compound, OP_GETATTR, &getattr_args[0], &getattr_res[0]);
1459 getattr_args[0].attr_request = &info.attrmask;
1461 getattr_res[0].info = &info;
1462
1463 /* LOOKUP(target) */
1464 compound_add_op(&compound, OP_LOOKUP, &lookup_args, &lookup_res);
1465 lookup_args.name = target;
1466
1467 /* GETATTR(target) */
1468 compound_add_op(&compound, OP_GETATTR, &getattr_args[1], &getattr_res[1]);
1469 getattr_args[1].attr_request = &cinfo->attrmask;
1471 getattr_res[1].info = cinfo;
1472
1473 /* GETFH(target) */
1474 compound_add_op(&compound, OP_GETFH, NULL, &getfh_res);
1475 getfh_res.fh = &file.fh;
1476
1478 if (status)
1479 goto out;
1480
1481 if (compound_error(status = compound.res.status))
1482 goto out;
1483
1484 /* fill in the file handle's fileid and superblock */
1485 file.fh.fileid = cinfo->fileid;
1487 &cinfo->fsid, &dst_dir->fh, &file);
1488 if (status)
1489 goto out;
1490
1491 /* update the attributes of the destination directory */
1492 memcpy(&info.attrmask, &getattr_res[0].obj_attributes.attrmask,
1493 sizeof(bitmap4));
1495 info.fileid, &info);
1496
1497 /* add the new file handle and attributes to the name cache */
1498 memcpy(&cinfo->attrmask, &getattr_res[1].obj_attributes.attrmask,
1499 sizeof(bitmap4));
1500 AcquireSRWLockShared(&dst_dir->path->lock);
1502 dst_dir->path->path, target, &file.fh,
1503 cinfo, &link_res.cinfo, OPEN_DELEGATE_NONE);
1504 ReleaseSRWLockShared(&dst_dir->path->lock);
1505
1506 nfs41_superblock_space_changed(dst_dir->fh.superblock);
1507out:
1508 return status;
1509}
GLenum src
Definition: glext.h:6340
GLenum target
Definition: glext.h:7315
int nfs41_superblock_for_fh(IN nfs41_session *session, IN const nfs41_fsid *fsid, IN const nfs41_fh *parent OPTIONAL, OUT nfs41_path_fh *file)
@ FATTR4_WORD0_FSID
Definition: nfs41_const.h:215

◆ 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.

914{
915 int status;
916 nfs41_compound compound;
917 nfs_argop4 argops[3];
918 nfs_resop4 resops[3];
919 nfs41_sequence_args sequence_args;
920 nfs41_sequence_res sequence_res;
921 nfs41_putfh_args putfh_args;
922 nfs41_putfh_res putfh_res;
923 nfs41_lock_args lock_args;
924 nfs41_lock_res lock_res;
925
926 compound_init(&compound, argops, resops, "lock");
927
928 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
929 nfs41_session_sequence(&sequence_args, session, 0);
930
931 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
932 putfh_args.file = file;
933 putfh_args.in_recovery = 0;
934
935 compound_add_op(&compound, OP_LOCK, &lock_args, &lock_res);
936 lock_args.locktype = type;
937 lock_args.reclaim = reclaim;
938 lock_args.offset = offset;
939 lock_args.length = length;
940 if (stateid->type == STATEID_LOCK) {
941 lock_args.locker.new_lock_owner = 0;
942 lock_args.locker.u.lock_owner.lock_stateid = stateid;
943 lock_args.locker.u.lock_owner.lock_seqid = 0; /* ignored */
944 } else {
945 lock_args.locker.new_lock_owner = 1;
946 lock_args.locker.u.open_owner.open_seqid = 0; /* ignored */
947 lock_args.locker.u.open_owner.open_stateid = stateid;
948 lock_args.locker.u.open_owner.lock_seqid = 0; /* ignored */
949 lock_args.locker.u.open_owner.lock_owner = owner;
950 }
951 lock_res.u.resok4.lock_stateid = &stateid->stateid;
953
954 status = compound_encode_send_decode(session, &compound, try_recovery);
955 if (status)
956 goto out;
957
958 if (compound_error(status = compound.res.status))
959 goto out;
960
961 stateid->type = STATEID_LOCK; /* returning a lock stateid */
962out:
963 return status;
964}
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
stateid_arg * lock_stateid
Definition: nfs41_ops.h:413
uint32_t lock_seqid
Definition: nfs41_ops.h:414
state_owner4 owner
Definition: nfs41_ops.h:439
stateid4 * lock_stateid
Definition: nfs41_ops.h:443
open_to_lock_owner4 open_owner
Definition: nfs41_ops.h:421
bool_t new_lock_owner
Definition: nfs41_ops.h:418
exist_lock_owner4 lock_owner
Definition: nfs41_ops.h:423
union __locker4::@48 u
uint64_t length
Definition: nfs41_ops.h:431
uint32_t locktype
Definition: nfs41_ops.h:428
uint64_t offset
Definition: nfs41_ops.h:430
lock_res_denied denied
Definition: nfs41_ops.h:452
lock_res_ok resok4
Definition: nfs41_ops.h:450
union __nfs41_lock_res::@49 u
state_owner4 * lock_owner
Definition: nfs41_ops.h:409
stateid_arg * open_stateid
Definition: nfs41_ops.h:407
uint32_t owner_len
Definition: nfs41_types.h:118

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.

432{
436 const char *path_pos, *path_end;
437 struct lookup_referral referral;
438 bool_t negative = 0;
439 int status;
440
441 if (session_out) *session_out = session;
442
443 InitializeSRWLock(&path.lock);
444
445 /* to avoid holding this lock over multiple rpcs,
446 * make a copy of the path and use that instead */
447 AcquireSRWLockShared(&path_inout->lock);
448 abs_path_copy(&path, path_inout);
449 ReleaseSRWLockShared(&path_inout->lock);
450
451 path_pos = path.path;
452 path_end = path.path + path.len;
453
454 dprintf(LULVL, "--> nfs41_lookup('%s')\n", path.path);
455
456 if (parent_out == NULL) parent_out = &parent;
457 if (target_out == NULL) target_out = ⌖
458 parent_out->fh.len = target_out->fh.len = 0;
459
460 status = nfs41_name_cache_lookup(cache, path_pos, path_end, &path_pos,
461 &parent_out->fh, &target_out->fh, info_out, &negative);
462 if (status == NO_ERROR || negative)
463 goto out;
464
465 if (parent_out->fh.len) {
466 /* start where the name cache left off */
467 if (&parent != parent_out) {
468 /* must make a copy for server_start, because
469 * server_lookup_loop() will overwrite parent_out */
470 path_fh_copy(&parent, parent_out);
471 }
473 } else {
474 /* start with PUTROOTFH */
476 }
477
479 &path, path_pos, &referral, parent_out, target_out, info_out);
480
482 nfs41_session *new_session;
483
484 /* create a session to the referred server and
485 * reformat the path relative to that server's root */
487 &referral, path_inout, &new_session);
488 if (status) {
489 eprintf("referral_resolve() failed with %d\n", status);
490 goto out;
491 }
492
493 /* update the positions of the parent and target components */
494 last_component(path_inout->path, path_inout->path + path_inout->len,
495 &target_out->name);
496 last_component(path_inout->path, target_out->name.name,
497 &parent_out->name);
498
499 if (session_out) *session_out = new_session;
500
501 /* look up the new path */
502 status = nfs41_lookup(root, new_session, path_inout,
503 parent_out, target_out, info_out, session_out);
504 }
505out:
506 dprintf(LULVL, "<-- nfs41_lookup() returning %d\n", status);
507 return status;
508}
#define ERROR_FILESYSTEM_ABSENT
Definition: lookup.c:39
static int server_lookup_loop(IN nfs41_session *session, IN OPTIONAL nfs41_path_fh *parent_in, IN nfs41_abs_path *path, IN const char *path_pos, IN struct lookup_referral *referral, OUT OPTIONAL nfs41_path_fh *parent_out, OUT OPTIONAL nfs41_path_fh *target_out, OUT OPTIONAL nfs41_file_info *info_out)
Definition: lookup.c:298
static int referral_resolve(IN nfs41_root *root, IN nfs41_session *session_in, IN struct lookup_referral *referral, OUT nfs41_abs_path *path_out, OUT nfs41_session **session_out)
Definition: lookup.c:373
int nfs41_lookup(IN nfs41_root *root, IN nfs41_session *session, IN OUT nfs41_abs_path *path_inout, 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: lookup.c:424
#define LULVL
Definition: lookup.c:33
bool_t last_component(IN const char *path, IN const char *path_end, OUT nfs41_component *component)
Definition: util.c:317
void abs_path_copy(OUT nfs41_abs_path *dst, IN const nfs41_abs_path *src)
Definition: util.c:338
void path_fh_copy(OUT nfs41_path_fh *dst, IN const nfs41_path_fh *src)
Definition: util.c:364
#define NO_ERROR
Definition: dderror.h:5
int32_t bool_t
Definition: types.h:101
VOID WINAPI InitializeSRWLock(PSRWLOCK Lock)
Definition: sync.c:75
int nfs41_name_cache_lookup(IN struct nfs41_name_cache *cache, IN const char *path, IN const char *path_end, OUT OPTIONAL const char **remaining_path_out, OUT OPTIONAL nfs41_fh *parent_out, OUT OPTIONAL nfs41_fh *target_out, OUT OPTIONAL nfs41_file_info *info_out, OUT OPTIONAL bool_t *is_negative)
Definition: name_cache.c:824
#define dprintf
Definition: regdump.c:33
static void server_start(server_params *par)
Definition: sock.c:521
Definition: cache.c:49

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.

381{
382 int status;
383 nfs41_compound compound;
384 nfs_argop4 argops[8];
385 nfs_resop4 resops[8];
386 nfs41_sequence_args sequence_args;
387 nfs41_sequence_res sequence_res;
388 nfs41_putfh_args putfh_args[2];
389 nfs41_putfh_res putfh_res[2];
390 nfs41_op_open_args open_args;
391 nfs41_op_open_res open_res;
392 nfs41_getfh_res getfh_res;
393 bitmap4 attr_request;
394 nfs41_getattr_args getattr_args;
395 nfs41_getattr_res getattr_res, pgetattr_res;
396 nfs41_savefh_res savefh_res;
397 nfs41_restorefh_res restorefh_res;
398 nfs41_file_info tmp_info, dir_info;
399 bool_t current_fh_is_dir;
400 bool_t already_delegated = delegation->type == OPEN_DELEGATE_READ
401 || delegation->type == OPEN_DELEGATE_WRITE;
402
403 /* depending on the claim type, OPEN expects CURRENT_FH set
404 * to either the parent directory, or to the file itself */
405 switch (claim->claim) {
406 case CLAIM_NULL:
409 /* CURRENT_FH: directory */
410 current_fh_is_dir = TRUE;
411 /* SEQUENCE; PUTFH(dir); SAVEFH; OPEN;
412 * GETFH(file); GETATTR(file); RESTOREFH(dir); GETATTR */
413 nfs41_superblock_getattr_mask(parent->fh.superblock, &attr_request);
414 break;
415 case CLAIM_PREVIOUS:
416 case CLAIM_FH:
419 default:
420 /* CURRENT_FH: file being opened */
421 current_fh_is_dir = FALSE;
422 /* SEQUENCE; PUTFH(file); OPEN; GETATTR(file); PUTFH(dir); GETATTR */
423 nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
424 break;
425 }
426
427 if (info == NULL)
428 info = &tmp_info;
429
430 attr_request.arr[0] |= FATTR4_WORD0_FSID;
431
432 compound_init(&compound, argops, resops, "open");
433
434 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
435 nfs41_session_sequence(&sequence_args, session, 1);
436
437 if (current_fh_is_dir) {
438 /* CURRENT_FH: directory */
439 compound_add_op(&compound, OP_PUTFH, &putfh_args[0], &putfh_res[0]);
440 putfh_args[0].file = parent;
441 putfh_args[0].in_recovery = 0;
442
443 compound_add_op(&compound, OP_SAVEFH, NULL, &savefh_res);
444 } else {
445 /* CURRENT_FH: file being opened */
446 compound_add_op(&compound, OP_PUTFH, &putfh_args[0], &putfh_res[0]);
447 putfh_args[0].file = file;
448 putfh_args[0].in_recovery = 0;
449 }
450
451 compound_add_op(&compound, OP_OPEN, &open_args, &open_res);
452 open_args.seqid = 0;
453#ifdef DISABLE_FILE_DELEGATIONS
455#else
456 open_args.share_access = allow;
457#endif
458 open_args.share_deny = deny;
459 open_args.owner = owner;
460 open_args.openhow.opentype = create;
461 open_args.openhow.how.mode = how_mode;
462 open_args.openhow.how.createattrs = createattrs;
463 if (how_mode == EXCLUSIVE4_1) {
465 time((time_t*)open_args.openhow.how.createverf);
466 memcpy(open_args.openhow.how.createverf+4, &tid, sizeof(tid));
467 /* mask unsupported attributes */
469 parent->fh.superblock, &createattrs->attrmask);
470 } else if (createattrs) {
471 /* mask unsupported attributes */
473 parent->fh.superblock, &createattrs->attrmask);
474 }
475 open_args.claim = claim;
476 open_res.resok4.stateid = stateid;
477 open_res.resok4.delegation = delegation;
478
479 if (current_fh_is_dir) {
480 compound_add_op(&compound, OP_GETFH, NULL, &getfh_res);
481 getfh_res.fh = &file->fh;
482 }
483
484 compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
485 getattr_args.attr_request = &attr_request;
487 getattr_res.info = info;
488
489 if (current_fh_is_dir) {
490 compound_add_op(&compound, OP_RESTOREFH, NULL, &restorefh_res);
491 } else {
492 compound_add_op(&compound, OP_PUTFH, &putfh_args[1], &putfh_res[1]);
493 putfh_args[1].file = parent;
494 putfh_args[1].in_recovery = 0;
495 }
496
497 compound_add_op(&compound, OP_GETATTR, &getattr_args, &pgetattr_res);
498 getattr_args.attr_request = &attr_request;
500 pgetattr_res.info = &dir_info;
501
502 status = compound_encode_send_decode(session, &compound, try_recovery);
503 if (status)
504 goto out;
505
506 if (compound_error(status = compound.res.status))
507 goto out;
508
509 if (dir_info.type == NF4ATTRDIR) {
510 file->fh.superblock = parent->fh.superblock;
511 goto out;
512 }
513
514 /* fill in the file handle's fileid and superblock */
515 file->fh.fileid = info->fileid;
517 if (status)
518 goto out;
519
520 if (create == OPEN4_CREATE)
521 nfs41_superblock_space_changed(file->fh.superblock);
522
523 /* update the name/attr cache with the results */
524 open_update_cache(session, parent, file, try_recovery, delegation,
525 already_delegated, &open_res.resok4.cinfo, &pgetattr_res, &getattr_res);
526out:
527 return status;
528}
__kernel_time_t time_t
Definition: linux.h:252
unsigned long DWORD
Definition: ntddk_ex.h:95
__u16 time
Definition: mkdosfs.c:8
static TfClientId tid
static const struct access_res create[16]
Definition: package.c:7644
static __inline void nfs41_superblock_supported_attrs_exclcreat(IN const nfs41_superblock *superblock, IN OUT bitmap4 *attrs)
Definition: nfs41.h:460
@ NF4ATTRDIR
Definition: nfs41_const.h:301
static void open_update_cache(IN nfs41_session *session, IN nfs41_path_fh *parent, IN nfs41_path_fh *file, IN bool_t try_recovery, IN open_delegation4 *delegation, IN bool_t already_delegated, IN change_info4 *changeinfo, IN nfs41_getattr_res *dir_attrs, IN nfs41_getattr_res *file_attrs)
Definition: nfs41_ops.c:321
uint32_t arr[3]
Definition: nfs41_types.h:97
unsigned char createverf[NFS4_VERIFIER_SIZE]
Definition: nfs41_ops.h:549
nfs41_file_info * createattrs
Definition: nfs41_ops.h:548
uint32_t mode
Definition: nfs41_ops.h:547
state_owner4 * owner
Definition: nfs41_ops.h:645
uint32_t share_access
Definition: nfs41_ops.h:643
open_claim4 * claim
Definition: nfs41_ops.h:647
change_info4 cinfo
Definition: nfs41_ops.h:659
open_delegation4 * delegation
Definition: nfs41_ops.h:662
nfs41_op_open_res_ok resok4
Definition: nfs41_ops.h:668
createhow4 how
Definition: nfs41_ops.h:560
uint32_t opentype
Definition: nfs41_ops.h:558
DWORD WINAPI GetCurrentThreadId(void)
Definition: thread.c:459

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.

783{
784 int status;
785 nfs41_compound compound;
786 nfs_argop4 argops[4];
787 nfs_resop4 resops[4];
788 nfs41_sequence_args sequence_args;
789 nfs41_sequence_res sequence_res;
790 nfs41_putfh_args putfh_args;
791 nfs41_putfh_res putfh_res;
792 nfs41_read_args read_args;
793 nfs41_read_res read_res;
794
795 compound_init(&compound, argops, resops,
796 stateid->stateid.seqid == 0 ? "ds read" : "read");
797
798 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
799 nfs41_session_sequence(&sequence_args, session, 0);
800
801 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
802 putfh_args.file = file;
803 putfh_args.in_recovery = 0;
804
805 compound_add_op(&compound, OP_READ, &read_args, &read_res);
806 read_args.stateid = stateid;
807 read_args.offset = offset;
808 read_args.count = count;
809 read_res.resok4.data_len = count;
810 read_res.resok4.data = data_out;
811
813 if (status)
814 goto out;
815
816 if (compound_error(status = compound.res.status))
817 goto out;
818
819 *data_len_out = read_res.resok4.data_len;
820 *eof_out = read_res.resok4.eof;
821
822 /* we shouldn't ever see this, but a buggy server could
823 * send us into an infinite loop. return NFS4ERR_IO */
824 if (!read_res.resok4.data_len && !read_res.resok4.eof) {
826 eprintf("READ succeeded with len=0 and eof=0; returning %s\n",
828 }
829out:
830 return status;
831}
@ NFS4ERR_IO
Definition: nfs41_const.h:90
stateid_arg * stateid
Definition: nfs41_ops.h:684
uint32_t count
Definition: nfs41_ops.h:686
uint64_t offset
Definition: nfs41_ops.h:685
unsigned char * data
Definition: nfs41_ops.h:692
nfs41_read_res_ok resok4
Definition: nfs41_ops.h:698

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.

1018{
1019 int status;
1020 nfs41_compound compound;
1021 nfs_argop4 argops[3];
1022 nfs_resop4 resops[3];
1023 nfs41_sequence_args sequence_args;
1024 nfs41_sequence_res sequence_res;
1025 nfs41_putfh_args putfh_args;
1026 nfs41_putfh_res putfh_res;
1027 nfs41_readdir_args readdir_args;
1028 nfs41_readdir_res readdir_res;
1029
1030 compound_init(&compound, argops, resops, "readdir");
1031
1032 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1033 nfs41_session_sequence(&sequence_args, session, 0);
1034
1035 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1036 putfh_args.file = file;
1037 putfh_args.in_recovery = 0;
1038
1039 compound_add_op(&compound, OP_READDIR, &readdir_args, &readdir_res);
1040 readdir_args.cookie.cookie = cookie->cookie;
1041 memcpy(readdir_args.cookie.verf, cookie->verf, NFS4_VERIFIER_SIZE);
1042 readdir_args.dircount = *entries_len;
1043 readdir_args.maxcount = *entries_len + sizeof(nfs41_readdir_res);
1044 readdir_args.attr_request = attr_request;
1045 readdir_res.reply.entries_len = *entries_len;
1046 readdir_res.reply.entries = entries;
1047 ZeroMemory(entries, readdir_args.dircount);
1048
1050 if (status)
1051 goto out;
1052
1053 if (compound_error(status = compound.res.status))
1054 goto out;
1055
1056 *entries_len = readdir_res.reply.entries_len;
1057 *eof_out = readdir_res.reply.eof;
1058 memcpy(cookie->verf, readdir_res.cookieverf, NFS4_VERIFIER_SIZE);
1059out:
1060 return status;
1061}
#define NFS4_VERIFIER_SIZE
Definition: nfs41_const.h:30
struct __nfs41_readdir_res nfs41_readdir_res
bitmap4 * attr_request
Definition: nfs41_ops.h:707
nfs41_readdir_cookie cookie
Definition: nfs41_ops.h:704
uint32_t entries_len
Definition: nfs41_ops.h:720
unsigned char * entries
Definition: nfs41_ops.h:721
nfs41_readdir_list reply
Definition: nfs41_ops.h:729
unsigned char cookieverf[NFS4_VERIFIER_SIZE]
Definition: nfs41_ops.h:728
Definition: cookie.c:34
#define ZeroMemory
Definition: winbase.h:1712

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.

1517{
1518 int status;
1519 nfs41_compound compound;
1520 nfs_argop4 argops[3];
1521 nfs_resop4 resops[3];
1522 nfs41_sequence_args sequence_args;
1523 nfs41_sequence_res sequence_res;
1524 nfs41_putfh_args putfh_args;
1525 nfs41_putfh_res putfh_res;
1526 nfs41_readlink_res readlink_res;
1527
1528 compound_init(&compound, argops, resops, "readlink");
1529
1530 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1531 nfs41_session_sequence(&sequence_args, session, 0);
1532
1533 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1534 putfh_args.file = file;
1535 putfh_args.in_recovery = 0;
1536
1537 compound_add_op(&compound, OP_READLINK, NULL, &readlink_res);
1538 readlink_res.link_len = max_len - 1;
1539 readlink_res.link = link_out;
1540
1542 if (status)
1543 goto out;
1544
1545 if (compound_error(status = compound.res.status))
1546 goto out;
1547
1548 link_out[readlink_res.link_len] = '\0';
1549 *len_out = readlink_res.link_len;
1550out:
1551 return status;
1552}

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.

270{
271 enum nfsstat4 status = NFS4_OK;
272 nfs41_compound compound;
273 nfs_argop4 argops[2];
274 nfs_resop4 resops[2];
275 nfs41_sequence_args sequence_args;
276 nfs41_sequence_res sequence_res;
277 nfs41_reclaim_complete_res reclaim_res;
278
279 compound_init(&compound, argops, resops, "reclaim_complete");
280
281 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
282 nfs41_session_sequence(&sequence_args, session, 0);
283
284 compound_add_op(&compound, OP_RECLAIM_COMPLETE, NULL, &reclaim_res);
285
286 /* don't attempt to recover from BADSESSION */
288 if (status)
289 goto out;
290
291 compound_error(status = compound.res.status);
292out:
293 return status;
294}
@ NFS4_OK
Definition: nfs41_const.h:87

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.

1185{
1186 int status;
1187 nfs41_compound compound;
1188 nfs_argop4 argops[4];
1189 nfs_resop4 resops[4];
1190 nfs41_sequence_args sequence_args;
1191 nfs41_sequence_res sequence_res;
1192 nfs41_putfh_args putfh_args;
1193 nfs41_putfh_res putfh_res;
1194 nfs41_remove_args remove_args;
1195 nfs41_remove_res remove_res;
1196 nfs41_getattr_args getattr_args;
1197 nfs41_getattr_res getattr_res;
1198 bitmap4 attr_request;
1200
1201 nfs41_superblock_getattr_mask(parent->fh.superblock, &attr_request);
1202
1203 compound_init(&compound, argops, resops, "remove");
1204
1205 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1206 nfs41_session_sequence(&sequence_args, session, 1);
1207
1208 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1209 putfh_args.file = parent;
1210 putfh_args.in_recovery = 0;
1211
1212 compound_add_op(&compound, OP_REMOVE, &remove_args, &remove_res);
1213 remove_args.target = target;
1214
1215 compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
1216 getattr_args.attr_request = &attr_request;
1218 getattr_res.info = &info;
1219
1221 if (status)
1222 goto out;
1223
1224 if (compound_error(status = compound.res.status))
1225 goto out;
1226
1227 if (info.type == NF4ATTRDIR)
1228 goto out;
1229
1230 /* update the attributes of the parent directory */
1231 memcpy(&info.attrmask, &getattr_res.obj_attributes.attrmask,
1232 sizeof(bitmap4));
1234 parent->fh.fileid, &info);
1235
1236 /* remove the target file from the cache */
1237 AcquireSRWLockShared(&parent->path->lock);
1239 parent->path->path, target, fileid, &remove_res.cinfo);
1240 ReleaseSRWLockShared(&parent->path->lock);
1241
1242 nfs41_superblock_space_changed(parent->fh.superblock);
1243out:
1244 return status;
1245}
int nfs41_name_cache_remove(IN struct nfs41_name_cache *cache, IN const char *path, IN const nfs41_component *name, IN uint64_t fileid, IN const change_info4 *cinfo)
Definition: name_cache.c:1066
const nfs41_component * target
Definition: nfs41_ops.h:744
change_info4 cinfo
Definition: nfs41_ops.h:750

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.

1253{
1254 int status;
1255 nfs41_compound compound;
1256 nfs_argop4 argops[8];
1257 nfs_resop4 resops[8];
1258 nfs41_sequence_args sequence_args;
1259 nfs41_sequence_res sequence_res;
1260 nfs41_putfh_args src_putfh_args;
1261 nfs41_putfh_res src_putfh_res;
1262 nfs41_savefh_res savefh_res;
1263 nfs41_putfh_args dst_putfh_args;
1264 nfs41_putfh_res dst_putfh_res;
1265 nfs41_rename_args rename_args;
1266 nfs41_rename_res rename_res;
1267 nfs41_getattr_args getattr_args;
1268 nfs41_getattr_res src_getattr_res, dst_getattr_res;
1269 nfs41_file_info src_info, dst_info;
1270 bitmap4 attr_request;
1271 nfs41_restorefh_res restorefh_res;
1272
1273 nfs41_superblock_getattr_mask(src_dir->fh.superblock, &attr_request);
1274
1275 compound_init(&compound, argops, resops, "rename");
1276
1277 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1278 nfs41_session_sequence(&sequence_args, session, 1);
1279
1280 compound_add_op(&compound, OP_PUTFH, &src_putfh_args, &src_putfh_res);
1281 src_putfh_args.file = src_dir;
1282 src_putfh_args.in_recovery = 0;
1283
1284 compound_add_op(&compound, OP_SAVEFH, NULL, &savefh_res);
1285
1286 compound_add_op(&compound, OP_PUTFH, &dst_putfh_args, &dst_putfh_res);
1287 dst_putfh_args.file = dst_dir;
1288 dst_putfh_args.in_recovery = 0;
1289
1290 compound_add_op(&compound, OP_RENAME, &rename_args, &rename_res);
1291 rename_args.oldname = src_name;
1292 rename_args.newname = dst_name;
1293
1294 compound_add_op(&compound, OP_GETATTR, &getattr_args, &dst_getattr_res);
1295 getattr_args.attr_request = &attr_request;
1297 dst_getattr_res.info = &dst_info;
1298
1299 compound_add_op(&compound, OP_RESTOREFH, NULL, &restorefh_res);
1300
1301 compound_add_op(&compound, OP_GETATTR, &getattr_args, &src_getattr_res);
1303 src_getattr_res.info = &src_info;
1304
1306 if (status)
1307 goto out;
1308
1309 if (compound_error(status = compound.res.status))
1310 goto out;
1311
1312 /* update the attributes of the source directory */
1313 memcpy(&src_info.attrmask, &src_getattr_res.obj_attributes.attrmask,
1314 sizeof(bitmap4));
1316 src_dir->fh.fileid, &src_info);
1317
1318 /* update the attributes of the destination directory */
1319 memcpy(&dst_info.attrmask, &dst_getattr_res.obj_attributes.attrmask,
1320 sizeof(bitmap4));
1322 dst_dir->fh.fileid, &dst_info);
1323
1324 if (src_dir->path == dst_dir->path) {
1325 /* source and destination are the same, only lock it once */
1326 AcquireSRWLockShared(&src_dir->path->lock);
1327 } else if (src_dir->path < dst_dir->path) {
1328 /* lock the lowest memory address first */
1329 AcquireSRWLockShared(&src_dir->path->lock);
1330 AcquireSRWLockShared(&dst_dir->path->lock);
1331 } else {
1332 AcquireSRWLockShared(&dst_dir->path->lock);
1333 AcquireSRWLockShared(&src_dir->path->lock);
1334 }
1335
1336 /* move/rename the target file's name cache entry */
1338 src_dir->path->path, src_name, &rename_res.source_cinfo,
1339 dst_dir->path->path, dst_name, &rename_res.target_cinfo);
1340
1341 if (src_dir->path == dst_dir->path) {
1342 ReleaseSRWLockShared(&src_dir->path->lock);
1343 } else {
1344 ReleaseSRWLockShared(&src_dir->path->lock);
1345 ReleaseSRWLockShared(&dst_dir->path->lock);
1346 }
1347out:
1348 return status;
1349}
int nfs41_name_cache_rename(IN struct nfs41_name_cache *cache, IN const char *src_path, IN const nfs41_component *src_name, IN const change_info4 *src_cinfo, IN const char *dst_path, IN const nfs41_component *dst_name, IN const change_info4 *dst_cinfo)
Definition: name_cache.c:1122
const nfs41_component * oldname
Definition: nfs41_ops.h:756
const nfs41_component * newname
Definition: nfs41_ops.h:757
change_info4 target_cinfo
Definition: nfs41_ops.h:764
change_info4 source_cinfo
Definition: nfs41_ops.h:763

◆ 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.

2150{
2151 enum nfsstat4 status;
2152 nfs41_compound compound;
2153 nfs_argop4 argops[4];
2154 nfs_resop4 resops[4];
2155 nfs41_sequence_args sequence_args;
2156 nfs41_sequence_res sequence_res;
2157 nfs41_putfh_args putfh_args;
2158 nfs41_putfh_res putfh_res;
2159 nfs41_openattr_args openattr_args;
2160 nfs41_openattr_res openattr_res;
2161 nfs41_getfh_res getfh_res;
2162
2163 compound_init(&compound, argops, resops, "openattr");
2164
2165 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
2166 nfs41_session_sequence(&sequence_args, session, 0);
2167
2168 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
2169 putfh_args.file = file;
2170 putfh_args.in_recovery = FALSE;
2171
2172 compound_add_op(&compound, OP_OPENATTR, &openattr_args, &openattr_res);
2173 openattr_args.createdir = createdir;
2174
2175 compound_add_op(&compound, OP_GETFH, NULL, &getfh_res);
2176 getfh_res.fh = fh_out;
2177
2179 if (status)
2180 goto out;
2181
2182 compound_error(status = compound.res.status);
2183
2184 fh_out->superblock = file->fh.superblock;
2185out:
2186 return status;
2187}

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.

1790{
1791 int status;
1792 nfs41_compound compound;
1793 nfs_argop4 argops[3];
1794 nfs_resop4 resops[3];
1795 nfs41_sequence_args sequence_args;
1796 nfs41_sequence_res sequence_res;
1797 nfs41_putfh_args putfh_args;
1798 nfs41_putfh_res putfh_res;
1799 nfs41_secinfo_args secinfo_args;
1800 nfs41_secinfo_noname_res secinfo_res;
1801
1802 compound_init(&compound, argops, resops, "secinfo");
1803
1804 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1805 nfs41_session_sequence(&sequence_args, session, 0);
1806
1807 if (file == NULL)
1808 compound_add_op(&compound, OP_PUTROOTFH, NULL, &putfh_res);
1809 else {
1810 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1811 putfh_args.file = file;
1812 putfh_args.in_recovery = 0;
1813 }
1814
1815 compound_add_op(&compound, OP_SECINFO, &secinfo_args, &secinfo_res);
1816 secinfo_args.name = name;
1817 secinfo_res.secinfo = secinfo;
1818
1820 if (status)
1821 goto out;
1822
1823 compound_error(status = compound.res.status);
1824out:
1825 return status;
1826}
const nfs41_component * name
Definition: nfs41_ops.h:878
nfs41_secinfo_info * secinfo
Definition: nfs41_ops.h:900

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.

1832{
1833 int status;
1834 nfs41_compound compound;
1835 nfs_argop4 argops[3];
1836 nfs_resop4 resops[3];
1837 nfs41_sequence_args sequence_args;
1838 nfs41_sequence_res sequence_res;
1839 nfs41_putfh_args putfh_args;
1840 nfs41_putfh_res putfh_res;
1841 nfs41_secinfo_noname_args noname_args;
1842 nfs41_secinfo_noname_res noname_res;
1843
1844 compound_init(&compound, argops, resops, "secinfo_no_name");
1845
1846 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1847 nfs41_session_sequence(&sequence_args, session, 0);
1848
1849 if (file == NULL)
1850 compound_add_op(&compound, OP_PUTROOTFH, NULL, &putfh_res);
1851 else {
1852 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1853 putfh_args.file = file;
1854 putfh_args.in_recovery = 0;
1855 }
1856
1857 compound_add_op(&compound, OP_SECINFO_NO_NAME, &noname_args, &noname_res);
1858 noname_args.type = SECINFO_STYLE4_CURRENT_FH;
1859 noname_res.secinfo = secinfo;
1860
1862 if (status)
1863 goto out;
1864
1865 compound_error(status = compound.res.status);
1866out:
1867 return status;
1868}
enum secinfo_noname_type type
Definition: nfs41_ops.h:893

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.

1601{
1602 int status;
1603 nfs41_compound compound;
1604 nfs_argop4 argops[1];
1605 nfs_resop4 resops[1];
1606 nfs41_sequence_args sequence_args;
1607 nfs41_sequence_res sequence_res;
1608
1609 compound_init(&compound, argops, resops, "sequence");
1610
1611 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1612 nfs41_session_sequence(&sequence_args, session, 0);
1613
1615 if (status)
1616 goto out;
1617
1618 if (compound_error(status = compound.res.status))
1619 goto out;
1620out:
1621 return status;
1622}

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.

1356{
1357 int status;
1358 nfs41_compound compound;
1359 nfs_argop4 argops[4];
1360 nfs_resop4 resops[4];
1361 nfs41_sequence_args sequence_args;
1362 nfs41_sequence_res sequence_res;
1363 nfs41_putfh_args putfh_args;
1364 nfs41_putfh_res putfh_res;
1365 nfs41_setattr_args setattr_args;
1366 nfs41_setattr_res setattr_res;
1367 nfs41_getattr_args getattr_args;
1368 nfs41_getattr_res getattr_res;
1369 bitmap4 attr_request;
1370
1371 compound_init(&compound, argops, resops, "setattr");
1372
1373 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1374 nfs41_session_sequence(&sequence_args, session, 0);
1375
1376 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1377 putfh_args.file = file;
1378 putfh_args.in_recovery = 0;
1379
1380 compound_add_op(&compound, OP_SETATTR, &setattr_args, &setattr_res);
1381 setattr_args.stateid = stateid;
1382 setattr_args.info = info;
1383
1384 nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
1385 compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
1386 getattr_args.attr_request = &attr_request;
1388 getattr_res.info = info;
1389
1391 if (status)
1392 goto out;
1393
1394 if (compound_error(status = compound.res.status))
1395 goto out;
1396
1397 memcpy(&info->attrmask, &attr_request, sizeof(bitmap4));
1399 file->fh.fileid, info);
1400
1401 if (setattr_res.attrsset.arr[0] & FATTR4_WORD0_SIZE)
1402 nfs41_superblock_space_changed(file->fh.superblock);
1403out:
1404 return status;
1405}
@ FATTR4_WORD0_SIZE
Definition: nfs41_const.h:211
stateid_arg * stateid
Definition: nfs41_ops.h:782
nfs41_file_info * info
Definition: nfs41_ops.h:783

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.

1122{
1123 int status;
1124 nfs41_compound compound;
1125 nfs_argop4 argops[4];
1126 nfs_resop4 resops[4];
1127 nfs41_sequence_args sequence_args;
1128 nfs41_sequence_res sequence_res;
1129 nfs41_putfh_args putfh_args;
1130 nfs41_putfh_res putfh_res;
1131 nfs41_getattr_args getattr_args;
1132 nfs41_getattr_res getattr_res;
1133 nfs41_openattr_args openattr_args;
1134 nfs41_openattr_res openattr_res;
1135
1136 compound_init(&compound, argops, resops, "getfsattr");
1137
1138 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1139 nfs41_session_sequence(&sequence_args, session, 0);
1140
1141 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1142 putfh_args.file = file;
1143 putfh_args.in_recovery = 0;
1144
1145 compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
1146 getattr_args.attr_request = attr_request;
1148 getattr_res.info = info;
1149
1150 compound_add_op(&compound, OP_OPENATTR, &openattr_args, &openattr_res);
1151 openattr_args.createdir = 0;
1152
1154 if (status)
1155 goto out;
1156
1157 status = sequence_res.sr_status;
1158 if (status) goto out;
1159 status = putfh_res.status;
1160 if (status) goto out;
1161 status = getattr_res.status;
1162 if (status) goto out;
1163
1164 switch (status = openattr_res.status) {
1165 case NFS4ERR_NOTSUPP:
1166 *supports_named_attrs = 0;
1167 status = NFS4_OK;
1168 break;
1169
1170 case NFS4ERR_NOENT:
1171 case NFS4_OK:
1172 *supports_named_attrs = 1;
1173 status = NFS4_OK;
1174 break;
1175 }
1176out:
1177 return status;
1178}
@ NFS4ERR_NOTSUPP
Definition: nfs41_const.h:109
@ NFS4ERR_NOENT
Definition: nfs41_const.h:89
uint32_t status
Definition: nfs41_ops.h:515

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.

151{
154 uint32_t depth = 0;
155 int status = NO_ERROR;
156
157 file.path = &path;
158 InitializeSRWLock(&path.lock);
159
160 dprintf(2, "--> nfs41_symlink_follow('%s')\n", symlink->path->path);
161
162 do {
165 goto out;
166 }
167
168 /* construct the target path */
170 if (status) goto out;
171
172 dprintf(2, "looking up '%s'\n", path.path);
173
174 last_component(path.path, path.path + path.len, &file.name);
175
176 /* get attributes for the target */
178 NULL, &file, info, &session);
179 if (status) goto out;
180
181 symlink = &file;
182 } while (info->type == NF4LNK);
183out:
184 dprintf(2, "<-- nfs41_symlink_follow() returning %d\n", status);
185 return status;
186}
UINT32 uint32_t
Definition: types.h:75
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
#define NFS41_MAX_SYMLINK_DEPTH
Definition: nfs41_const.h:60
#define ERROR_TOO_MANY_LINKS
Definition: winerror.h:671

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.

96{
98 const nfs41_abs_path *path = file->path;
99 ptrdiff_t path_offset;
100 uint32_t link_len;
101 int status;
102
103 /* read the link */
105 if (status) {
106 eprintf("nfs41_readlink() for %s failed with %s\n", file->path->path,
109 goto out;
110 }
111
112 dprintf(2, "--> nfs41_symlink_target('%s', '%s')\n", path->path, link);
113
114 /* append any components after the symlink */
116 file->name.name + file->name.len))) {
118 goto out;
119 }
120 link_len = (uint32_t)strlen(link);
121
122 /* overwrite the last component of the path; get the starting offset */
123 path_offset = file->name.name - path->path;
124
125 /* copy the path and update it with the results from link */
126 if (target != path) {
127 target->len = path->len;
129 path->path, path->len))) {
131 goto out;
132 }
133 }
134 status = abs_path_link(target, target->path + path_offset, link, link_len);
135 if (status) {
136 eprintf("abs_path_link() for path %s with link %s failed with %d\n",
137 target->path, link, status);
138 goto out;
139 }
140out:
141 dprintf(2, "<-- nfs41_symlink_target('%s') returning %d\n",
142 target->path, status);
143 return status;
144}
const WCHAR * link
Definition: db.cpp:997
__kernel_ptrdiff_t ptrdiff_t
Definition: linux.h:247
#define FAILED(hr)
Definition: intsafe.h:51
#define NFS41_MAX_PATH_LEN
Definition: nfs41_const.h:46
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: nfs41_ops.c:1511
STRSAFEAPI StringCchCatA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPCSTR pszSrc)
Definition: strsafe.h:320
STRSAFEAPI StringCchCopyNA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPCSTR pszSrc, size_t cchToCopy)
Definition: strsafe.h:230
#define ERROR_BUFFER_OVERFLOW
Definition: winerror.h:185
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106

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.

1905{
1906 enum nfsstat4 status;
1907 nfs41_compound compound;
1908 nfs_argop4 argops[2];
1909 nfs_resop4 resops[2];
1910 nfs41_sequence_args sequence_args;
1911 nfs41_sequence_res sequence_res;
1912 nfs41_test_stateid_args teststateid_args;
1913 nfs41_test_stateid_res teststateid_res;
1914
1915 compound_init(&compound, argops, resops, "test_stateid");
1916
1917 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1918 nfs41_session_sequence(&sequence_args, session, 0);
1919
1920 compound_add_op(&compound, OP_TEST_STATEID, &teststateid_args, &teststateid_res);
1921 teststateid_args.stateids = stateid_array;
1922 teststateid_args.count = count;
1923 teststateid_res.resok.status = status_array;
1924 teststateid_res.resok.count = count;
1925
1927 if (status)
1928 goto out;
1929
1930 compound_error(status = compound.res.status);
1931out:
1932 return status;
1933}
static uint32_t stateid_array(IN struct list_entry *delegations, IN struct list_entry *opens, OUT stateid_arg **stateids_out, OUT uint32_t **statuses_out)
Definition: recovery.c:547
stateid_arg * stateids
Definition: nfs41_ops.h:822
struct __nfs41_test_stateid_res::@51 resok

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.

972{
973 int status;
974 nfs41_compound compound;
975 nfs_argop4 argops[3];
976 nfs_resop4 resops[3];
977 nfs41_sequence_args sequence_args;
978 nfs41_sequence_res sequence_res;
979 nfs41_putfh_args putfh_args;
980 nfs41_putfh_res putfh_res;
981 nfs41_locku_args locku_args;
982 nfs41_locku_res locku_res;
983
984 compound_init(&compound, argops, resops, "unlock");
985
986 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
987 nfs41_session_sequence(&sequence_args, session, 0);
988
989 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
990 putfh_args.file = file;
991 putfh_args.in_recovery = 0;
992
993 compound_add_op(&compound, OP_LOCKU, &locku_args, &locku_res);
994 /* 18.12.3: the server MUST accept any legal value for locktype */
995 locku_args.locktype = READ_LT;
996 locku_args.offset = offset;
997 locku_args.length = length;
998 locku_args.lock_stateid = stateid;
999 locku_res.lock_stateid = &stateid->stateid;
1000
1002 if (status)
1003 goto out;
1004
1005 compound_error(status = compound.res.status);
1006out:
1007 return status;
1008}
uint32_t locktype
Definition: nfs41_ops.h:476
stateid_arg * lock_stateid
Definition: nfs41_ops.h:478
stateid4 * lock_stateid
Definition: nfs41_ops.h:486

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.

1631{
1632 enum nfsstat4 status;
1633 nfs41_compound compound;
1634 nfs_argop4 argops[3];
1635 nfs_resop4 resops[3];
1636 nfs41_sequence_args sequence_args;
1637 nfs41_sequence_res sequence_res;
1638 nfs41_putfh_args putfh_args;
1639 nfs41_putfh_res putfh_res;
1642
1643 compound_init(&compound, argops, resops, "want_delegation");
1644
1645 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
1646 nfs41_session_sequence(&sequence_args, session, 0);
1647
1648 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
1649 putfh_args.file = file;
1650 putfh_args.in_recovery = 0;
1651
1652 compound_add_op(&compound, OP_WANT_DELEGATION, &wd_args, &wd_res);
1653 wd_args.claim = claim;
1654 wd_args.want = want;
1655 wd_res.delegation = delegation;
1656
1657 status = compound_encode_send_decode(session, &compound, try_recovery);
1658 if (status)
1659 goto out;
1660
1661 compound_error(status = compound.res.status);
1662out:
1663 return status;
1664}
open_delegation4 * delegation
Definition: nfs41_ops.h:807

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.

696{
697 int status;
698 nfs41_compound compound;
699 nfs_argop4 argops[4];
700 nfs_resop4 resops[4];
701 nfs41_sequence_args sequence_args;
702 nfs41_sequence_res sequence_res;
703 nfs41_putfh_args putfh_args;
704 nfs41_putfh_res putfh_res;
706 nfs41_write_res write_res;
707 nfs41_getattr_args getattr_args;
708 nfs41_getattr_res getattr_res = {0};
709 bitmap4 attr_request;
710 nfs41_file_info info = { 0 }, *pinfo;
711
712 nfs41_superblock_getattr_mask(file->fh.superblock, &attr_request);
713
714 compound_init(&compound, argops, resops,
715 stateid->stateid.seqid == 0 ? "ds write" : "write");
716
717 compound_add_op(&compound, OP_SEQUENCE, &sequence_args, &sequence_res);
718 nfs41_session_sequence(&sequence_args, session, 0);
719
720 compound_add_op(&compound, OP_PUTFH, &putfh_args, &putfh_res);
721 putfh_args.file = file;
722 putfh_args.in_recovery = 0;
723
724 compound_add_op(&compound, OP_WRITE, &write_args, &write_res);
725 write_args.stateid = stateid;
726 write_args.offset = offset;
727 write_args.stable = stable;
728 write_args.data_len = data_len;
729 write_args.data = data;
730 write_res.resok4.verf = verf;
731
732 if (cinfo) pinfo = cinfo;
733 else pinfo = &info;
734
735 if (stable != UNSTABLE4) {
736 /* if the write is stable, we can't rely on COMMIT to update
737 * the attribute cache, so we do the GETATTR here */
738 compound_add_op(&compound, OP_GETATTR, &getattr_args, &getattr_res);
739 getattr_args.attr_request = &attr_request;
741 getattr_res.info = pinfo;
742 }
743
745 if (status)
746 goto out;
747
748 if (compound_error(status = compound.res.status))
749 goto out;
750
751 if (stable != UNSTABLE4 && pinfo->type != NF4NAMEDATTR) {
752 /* update the attribute cache */
753 memcpy(&pinfo->attrmask, &getattr_res.obj_attributes.attrmask,
754 sizeof(bitmap4));
755