reactos/base/services/nfsd/nfs41_ops.h

1287 lines
34 KiB
C
Raw Normal View History

/* NFSv4.1 client for Windows
* Copyright <EFBFBD> 2012 The Regents of the University of Michigan
*
* Olga Kornievskaia <aglo@umich.edu>
* Casey Bodley <cbodley@umich.edu>
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or (at
* your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* without any warranty; without even the implied warranty of merchantability
* or fitness for a particular purpose. See the GNU Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA
*/
#ifndef __NFS41_NFS_OPS_H__
#define __NFS41_NFS_OPS_H__
#include "nfs41.h"
#include "pnfs.h"
/* Operation arrays */
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, /* Mandatory not-to-implement */
OP_OPEN_DOWNGRADE = 21,
OP_PUTFH = 22,
OP_PUTPUBFH = 23,
OP_PUTROOTFH = 24,
OP_READ = 25,
OP_READDIR = 26,
OP_READLINK = 27,
OP_REMOVE = 28,
OP_RENAME = 29,
OP_RENEW = 30, /* Mandatory not-to-implement */
OP_RESTOREFH = 31,
OP_SAVEFH = 32,
OP_SECINFO = 33,
OP_SETATTR = 34,
OP_SETCLIENTID = 35, /* Mandatory not-to-implement */
OP_SETCLIENTID_CONFIRM = 36, /* Mandatory not-to-implement */
OP_VERIFY = 37,
OP_WRITE = 38,
OP_RELEASE_LOCKOWNER = 39, /* Mandatory not-to-implement */
/* new operations for NFSv4.1 */
OP_BACKCHANNEL_CTL = 40,
OP_BIND_CONN_TO_SESSION = 41,
OP_EXCHANGE_ID = 42,
OP_CREATE_SESSION = 43,
OP_DESTROY_SESSION = 44,
OP_FREE_STATEID = 45,
OP_GET_DIR_DELEGATION = 46,
OP_GETDEVICEINFO = 47,
OP_GETDEVICELIST = 48,
OP_LAYOUTCOMMIT = 49,
OP_LAYOUTGET = 50,
OP_LAYOUTRETURN = 51,
OP_SECINFO_NO_NAME = 52,
OP_SEQUENCE = 53,
OP_SET_SSV = 54,
OP_TEST_STATEID = 55,
OP_WANT_DELEGATION = 56,
OP_DESTROY_CLIENTID = 57,
OP_RECLAIM_COMPLETE = 58,
OP_ILLEGAL = 10044
};
/* OP_EXCHANGE_ID */
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
};
typedef enum {
SP4_NONE = 0,
SP4_MACH_CRED = 1,
SP4_SSV = 2
} state_protect_how4;
typedef struct __state_protect4_a {
state_protect_how4 spa_how;
} state_protect4_a;
typedef struct __nfs41_exchange_id_args {
client_owner4 *eia_clientowner;
uint32_t eia_flags;
state_protect4_a eia_state_protect;
nfs_impl_id4 *eia_client_impl_id; /* <1> */
} nfs41_exchange_id_args;
typedef struct __state_protect4_r {
state_protect_how4 spr_how;
} state_protect4_r;
typedef struct __nfs41_exchange_id_res {
uint32_t status;
uint64_t clientid;
uint32_t sequenceid;
uint32_t flags;
state_protect4_r state_protect;
server_owner4 server_owner;
uint32_t server_scope_len;
char server_scope[NFS4_OPAQUE_LIMIT];
} nfs41_exchange_id_res;
typedef struct __nfs41_callback_sec_parms {
uint32_t type;
union {
/* case AUTH_SYS */
struct __authsys_parms {
uint32_t stamp;
char *machinename;
} auth_sys;
/* case RPCSEC_GSS */
struct __rpcsec_gss_parms {
uint32_t gss_srv_type;
char *srv_gssctx_handle;
uint32_t srv_gssctx_hdle_len;
char *clnt_gssctx_handle;
uint32_t clnt_gssctx_hdle_len;
} rpcsec_gss;
} u;
} nfs41_callback_secparms;
/* OP_CREATE_SESSION */
typedef struct __nfs41_create_session_args {
uint64_t csa_clientid;
uint32_t csa_sequence;
uint32_t csa_flags;
nfs41_channel_attrs csa_fore_chan_attrs;
nfs41_channel_attrs csa_back_chan_attrs;
uint32_t csa_cb_program;
nfs41_callback_secparms csa_cb_secparams[2];
} nfs41_create_session_args;
typedef struct __nfs41_create_session_res {
unsigned char *csr_sessionid;
uint32_t csr_sequence;
uint32_t csr_flags;
nfs41_channel_attrs *csr_fore_chan_attrs;
nfs41_channel_attrs *csr_back_chan_attrs;
} nfs41_create_session_res;
/* OP_BIND_CONN_TO_SESSION */
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
};
typedef struct __nfs41_bind_conn_to_session_args {
unsigned char *sessionid;
enum channel_dir_from_client4 dir;
} nfs41_bind_conn_to_session_args;
typedef struct __nfs41_bind_conn_to_session_res {
enum nfsstat4 status;
/* case NFS4_OK: */
enum channel_dir_from_server4 dir;
} nfs41_bind_conn_to_session_res;
/* OP_DESTROY_SESSION */
typedef struct __nfs41_destroy_session_args {
unsigned char *dsa_sessionid;
} nfs41_destroy_session_args;
typedef struct __nfs41_destroy_session_res {
uint32_t dsr_status;
} nfs41_destroy_session_res;
/* OP_DESTROY_CLIENTID */
typedef struct __nfs41_destroy_clientid_args {
uint64_t dca_clientid;
} nfs41_destroy_clientid_args;
typedef struct __nfs41_destroy_clientid_res {
uint32_t dcr_status;
} nfs41_destroy_clientid_res;
/* OP_SEQUENCE */
typedef struct __nfs41_sequence_args {
unsigned char *sa_sessionid;
uint32_t sa_sequenceid;
uint32_t sa_slotid;
uint32_t sa_highest_slotid;
bool_t sa_cachethis;
} nfs41_sequence_args;
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
};
typedef struct __nfs41_sequence_res_ok {
unsigned char sr_sessionid[NFS4_SESSIONID_SIZE];
uint32_t sr_sequenceid;
uint32_t sr_slotid;
uint32_t sr_highest_slotid;
uint32_t sr_target_highest_slotid;
uint32_t sr_status_flags;
} nfs41_sequence_res_ok;
typedef struct __nfs41_sequence_res {
uint32_t sr_status;
/* case NFS4_OK: */
nfs41_sequence_res_ok sr_resok4;
} nfs41_sequence_res;
/* OP_RECLAIM_COMPLETE */
typedef struct __nfs41_reclaim_complete_res {
enum nfsstat4 status;
} nfs41_reclaim_complete_res;
/* recoverable stateid argument */
enum stateid_type {
STATEID_OPEN,
STATEID_LOCK,
STATEID_DELEG_FILE,
STATEID_DELEG_DIR,
STATEID_LAYOUT,
STATEID_SPECIAL
};
typedef struct __stateid_arg {
stateid4 stateid;
enum stateid_type type;
nfs41_open_state *open;
nfs41_delegation_state *delegation;
} stateid_arg;
/* OP_ACCESS */
enum {
ACCESS4_READ = 0x00000001,
ACCESS4_LOOKUP = 0x00000002,
ACCESS4_MODIFY = 0x00000004,
ACCESS4_EXTEND = 0x00000008,
ACCESS4_DELETE = 0x00000010,
ACCESS4_EXECUTE = 0x00000020
};
typedef struct __nfs41_access_args {
uint32_t access;
} nfs41_access_args;
typedef struct __nfs41_access_res {
uint32_t status;
/* case NFS4_OK: */
uint32_t supported;
uint32_t access;
} nfs41_access_res;
/* OP_CLOSE */
typedef struct __nfs41_op_close_args {
// uint32_t seqid; // not used, always 0
stateid_arg *stateid;
} nfs41_op_close_args;
typedef struct __nfs41_op_close_res {
uint32_t status;
} nfs41_op_close_res;
/* OP_COMMIT */
typedef struct __nfs41_commit_args {
uint64_t offset;
uint32_t count;
} nfs41_commit_args;
typedef struct __nfs41_commit_res {
uint32_t status;
nfs41_write_verf *verf;
} nfs41_commit_res;
/* OP_CREATE */
typedef struct __specdata4 {
uint32_t specdata1;
uint32_t specdata2;
} specdata4;
typedef struct __createtype4 {
uint32_t type;
union {
/* case NF4LNK: */
struct __create_type_lnk {
uint32_t linkdata_len;
const char *linkdata;
} lnk;
/* case NF4BLK, NF4CHR: */
specdata4 devdata;
} u;
} createtype4;
typedef struct __nfs41_create_args {
createtype4 objtype;
const nfs41_component *name;
nfs41_file_info *createattrs;
} nfs41_create_args;
typedef struct __nfs41_create_res {
uint32_t status;
/* case NFS4_OK: */
change_info4 cinfo;
bitmap4 attrset;
} nfs41_create_res;
/* OP_DELEGPURGE */
typedef struct __nfs41_delegpurge_res {
uint32_t status;
} nfs41_delegpurge_res;
/* OP_DELEGRETURN */
typedef struct __nfs41_delegreturn_args {
stateid_arg *stateid;
} nfs41_delegreturn_args;
typedef struct __nfs41_delegreturn_res {
uint32_t status;
} nfs41_delegreturn_res;
/* OP_LINK */
typedef struct __nfs41_link_args {
const nfs41_component *newname;
} nfs41_link_args;
typedef struct __nfs41_link_res {
uint32_t status;
/* case NFS4_OK */
change_info4 cinfo;
} nfs41_link_res;
/* OP_LOCK */
enum {
READ_LT = 1,
WRITE_LT = 2,
READW_LT = 3, /* blocking read */
WRITEW_LT = 4 /* blocking write */
};
typedef struct __open_to_lock_owner4 {
uint32_t open_seqid;
stateid_arg *open_stateid;
uint32_t lock_seqid;
state_owner4 *lock_owner;
} open_to_lock_owner4;
typedef struct __exist_lock_owner4 {
stateid_arg *lock_stateid;
uint32_t lock_seqid;
} exist_lock_owner4;
typedef struct __locker4 {
bool_t new_lock_owner;
union {
/* case TRUE: */
open_to_lock_owner4 open_owner;
/* case FALSE: */
exist_lock_owner4 lock_owner;
} u;
} locker4;
typedef struct __nfs41_lock_args {
uint32_t locktype;
bool_t reclaim;
uint64_t offset;
uint64_t length;
locker4 locker;
} nfs41_lock_args;
typedef struct __lock_res_denied {
uint64_t offset;
uint64_t length;
uint32_t locktype;
state_owner4 owner;
} lock_res_denied;
typedef struct __lock_res_ok {
stateid4 *lock_stateid;
} lock_res_ok;
typedef struct __nfs41_lock_res {
uint32_t status;
union {
/* case NFS4_OK: */
lock_res_ok resok4;
/* case NFS4ERR_DENIED: */
lock_res_denied denied;
/* default: void; */
} u;
} nfs41_lock_res;
/* OP_LOCKT */
typedef struct __nfs41_lockt_args {
uint32_t locktype;
uint64_t offset;
uint64_t length;
state_owner4 *owner;
} nfs41_lockt_args;
typedef struct __nfs41_lockt_res {
uint32_t status;
/* case NFS4ERR_DENIED: */
lock_res_denied denied;
/* default: void; */
} nfs41_lockt_res;
/* OP_LOCKU */
typedef struct __nfs41_locku_args {
uint32_t locktype;
uint32_t seqid;
stateid_arg *lock_stateid;
uint64_t offset;
uint64_t length;
} nfs41_locku_args;
typedef struct __nfs41_locku_res {
uint32_t status;
/* case NFS4_OK: */
stateid4 *lock_stateid;
} nfs41_locku_res;
/* OP_LOOKUP */
typedef struct __nfs41_lookup_args {
const nfs41_component *name;
} nfs41_lookup_args;
typedef struct __nfs41_lookup_res {
uint32_t status;
} nfs41_lookup_res;
/* OP_GETFH */
typedef struct __nfs41_getfh_res {
uint32_t status;
/* case NFS4_OK: */
nfs41_fh *fh;
} nfs41_getfh_res;
/* OP_PUTFH */
typedef struct __nfs41_putfh_args {
nfs41_path_fh *file;
bool_t in_recovery;
} nfs41_putfh_args;
typedef struct __nfs41_putfh_res {
uint32_t status;
} nfs41_putfh_res;
/* OP_PUTROOTFH */
typedef struct __nfs41_putrootfh_res {
uint32_t status;
} nfs41_putrootfh_res;
/* OP_GETATTR */
typedef struct __nfs41_getattr_args {
bitmap4 *attr_request;
} nfs41_getattr_args;
typedef struct __nfs41_getattr_res {
uint32_t status;
/* case NFS4_OK: */
fattr4 obj_attributes;
nfs41_file_info *info;
} nfs41_getattr_res;
/* OP_OPEN */
enum createmode4 {
UNCHECKED4 = 0,
GUARDED4 = 1,
EXCLUSIVE4 = 2,
EXCLUSIVE4_1 = 3
};
typedef struct __createhow4 {
uint32_t mode;
nfs41_file_info *createattrs;
unsigned char createverf[NFS4_VERIFIER_SIZE];
} createhow4;
enum opentype4 {
OPEN4_NOCREATE = 0,
OPEN4_CREATE = 1
};
typedef struct __openflag4 {
uint32_t opentype;
/* case OPEN4_CREATE: */
createhow4 how;
} openflag4;
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
};
typedef struct __open_claim4 {
uint32_t claim;
union {
/* case CLAIM_NULL: */
struct __open_claim_null {
const nfs41_component *filename;
} null;
/* case CLAIM_PREVIOUS: */
struct __open_claim_prev {
uint32_t delegate_type;
} prev;
/* case CLAIM_DELEGATE_CUR: */
struct __open_claim_deleg_cur {
stateid_arg *delegate_stateid;
nfs41_component *name;
} deleg_cur;
/* case CLAIM_DELEG_CUR_FH: */
struct __open_claim_deleg_cur_fh {
stateid_arg *delegate_stateid;
} deleg_cur_fh;
/* case CLAIM_DELEGATE_PREV: */
struct __open_claim_deleg_prev {
const nfs41_component *filename;
} deleg_prev;
} u;
} open_claim4;
typedef struct __nfs41_op_open_args {
uint32_t seqid;
uint32_t share_access;
uint32_t share_deny;
state_owner4 *owner;
openflag4 openhow;
open_claim4 *claim;
} nfs41_op_open_args;
enum {
OPEN4_RESULT_CONFIRM = 0x00000002,
OPEN4_RESULT_LOCKTYPE_POSIX = 0x00000004,
OPEN4_RESULT_PRESERVE_UNLINKED = 0x00000008,
OPEN4_RESULT_MAY_NOTIFY_LOCK = 0x00000020
};
typedef struct __nfs41_op_open_res_ok {
stateid4 *stateid;
change_info4 cinfo;
uint32_t rflags;
bitmap4 attrset;
open_delegation4 *delegation;
} nfs41_op_open_res_ok;
typedef struct __nfs41_op_open_res {
uint32_t status;
/* case NFS4_OK: */
nfs41_op_open_res_ok resok4;
} nfs41_op_open_res;
/* OP_OPENATTR */
typedef struct __nfs41_openattr_args {
bool_t createdir;
} nfs41_openattr_args;
typedef struct __nfs41_openattr_res {
uint32_t status;
} nfs41_openattr_res;
/* OP_READ */
typedef struct __nfs41_read_args {
stateid_arg *stateid; /* -> nfs41_op_open_res_ok.stateid */
uint64_t offset;
uint32_t count;
} nfs41_read_args;
typedef struct __nfs41_read_res_ok {
bool_t eof;
uint32_t data_len;
unsigned char *data; /* caller-allocated */
} nfs41_read_res_ok;
typedef struct __nfs41_read_res {
uint32_t status;
/* case NFS4_OK: */
nfs41_read_res_ok resok4;
} nfs41_read_res;
/* OP_READDIR */
typedef struct __nfs41_readdir_args {
nfs41_readdir_cookie cookie;
uint32_t dircount;
uint32_t maxcount;
bitmap4 *attr_request;
} nfs41_readdir_args;
typedef struct __nfs41_readdir_entry {
uint64_t cookie;
uint32_t name_len;
uint32_t next_entry_offset;
nfs41_file_info attr_info;
char name[1];
} nfs41_readdir_entry;
typedef struct __nfs41_readdir_list {
bool_t has_entries;
uint32_t entries_len;
unsigned char *entries;
bool_t eof;
} nfs41_readdir_list;
typedef struct __nfs41_readdir_res {
uint32_t status;
/* case NFS4_OK: */
unsigned char cookieverf[NFS4_VERIFIER_SIZE];
nfs41_readdir_list reply;
} nfs41_readdir_res;
/* OP_READLINK */
typedef struct __nfs41_readlink_res {
uint32_t status;
/* case NFS4_OK: */
uint32_t link_len;
char *link;
} nfs41_readlink_res;
/* OP_REMOVE */
typedef struct __nfs41_remove_args {
const nfs41_component *target;
} nfs41_remove_args;
typedef struct __nfs41_remove_res {
uint32_t status;
/* case NFS4_OK: */
change_info4 cinfo;
} nfs41_remove_res;
/* OP_RENAME */
typedef struct __nfs41_rename_args {
const nfs41_component *oldname;
const nfs41_component *newname;
} nfs41_rename_args;
typedef struct __nfs41_rename_res {
uint32_t status;
/* case NFS4_OK: */
change_info4 source_cinfo;
change_info4 target_cinfo;
} nfs41_rename_res;
/* OP_RESTOREFH */
/* OP_SAVEFH */
typedef struct __nfs41_restorefh_savefh_res {
uint32_t status;
} nfs41_restorefh_res, nfs41_savefh_res;
/* OP_SETATTR */
enum time_how4 {
SET_TO_SERVER_TIME4 = 0,
SET_TO_CLIENT_TIME4 = 1
};
typedef struct __nfs41_setattr_args {
stateid_arg *stateid;
nfs41_file_info *info;
} nfs41_setattr_args;
typedef struct __nfs41_setattr_res {
uint32_t status;
bitmap4 attrsset;
} nfs41_setattr_res;
/* OP_WANT_DELEGATION */
typedef struct __deleg_claim4 {
uint32_t claim;
/* case CLAIM_PREVIOUS: */
uint32_t prev_delegate_type;
} deleg_claim4;
typedef struct __nfs41_want_delegation_args {
uint32_t want;
deleg_claim4 *claim;
} nfs41_want_delegation_args;
typedef struct __nfs41_want_delegation_res {
uint32_t status;
/* case NFS4_OK: */
open_delegation4 *delegation;
} nfs41_want_delegation_res;
/* OP_FREE_STATEID */
typedef struct __nfs41_free_stateid_args {
stateid4 *stateid;
} nfs41_free_stateid_args;
typedef struct __nfs41_free_stateid_res {
uint32_t status;
} nfs41_free_stateid_res;
/* OP_TEST_STATEID */
typedef struct __nfs41_test_stateid_args {
uint32_t count;
stateid_arg *stateids; // caller-allocated array
} nfs41_test_stateid_args;
typedef struct __nfs41_test_stateid_res {
uint32_t status;
struct {
uint32_t count;
uint32_t *status; // caller-allocated array
} resok;
} nfs41_test_stateid_res;
/* OP_WRITE */
enum stable_how4 {
UNSTABLE4 = 0,
DATA_SYNC4 = 1,
FILE_SYNC4 = 2
};
typedef struct __nfs41_write_args {
stateid_arg *stateid; /* -> nfs41_op_open_res_ok.stateid */
uint64_t offset;
uint32_t stable; /* stable_how4 */
uint32_t data_len;
unsigned char *data; /* caller-allocated */
} nfs41_write_args;
typedef struct __nfs41_write_res_ok {
uint32_t count;
nfs41_write_verf *verf;
} nfs41_write_res_ok;
typedef struct __nfs41_write_res {
uint32_t status;
/* case NFS4_OK: */
nfs41_write_res_ok resok4;
} nfs41_write_res;
/* OP_SECINFO */
enum sec_flavor {
RPC_GSS_SVC_NONE = 1,
RPC_GSS_SVC_INTEGRITY = 2,
RPC_GSS_SVC_PRIVACY = 3,
};
#define RPCSEC_GSS 6
#define MAX_OID_LEN 128
typedef struct __nfs41_secinfo_info {
char oid[MAX_OID_LEN];
uint32_t oid_len;
uint32_t sec_flavor;
uint32_t qop;
enum sec_flavor type;
} nfs41_secinfo_info;
typedef struct __nfs41_secinfo_args {
const nfs41_component *name;
} nfs41_secinfo_args;
#define MAX_SECINFOS 6
/* OP_SECINFO_NO_NAME */
enum secinfo_no_name_type {
SECINFO_STYLE4_CURRENT_FH = 0,
SECINFO_STYLE4_PARENT = 1
};
typedef struct __nfs41_secinfo_noname_args {
#ifdef __REACTOS__
uint32_t type;
#else
enum secinfo_noname_type type;
#endif
} nfs41_secinfo_noname_args;
typedef struct __nfs41_secinfo_noname_res {
uint32_t status;
/* case NFS4_OK: */
nfs41_secinfo_info *secinfo;
uint32_t count;
} nfs41_secinfo_noname_res;
/* LAYOUTGET */
typedef struct __pnfs_layoutget_args {
bool_t signal_layout_avail;
enum pnfs_layout_type layout_type;
enum pnfs_iomode iomode;
uint64_t offset;
uint64_t length;
uint64_t minlength;
stateid_arg *stateid;
uint32_t maxcount;
} pnfs_layoutget_args;
typedef struct __pnfs_layoutget_res_ok {
bool_t return_on_close;
stateid4 stateid;
uint32_t count;
struct list_entry layouts; /* list of pnfs_layouts */
} pnfs_layoutget_res_ok;
typedef struct __pnfs_layoutget_res {
enum nfsstat4 status;
union {
/* case NFS4_OK: */
pnfs_layoutget_res_ok *res_ok;
/* case NFS4ERR_LAYOUTTRYLATER: */
bool_t will_signal_layout_avail;
/* default: void; */
} u;
} pnfs_layoutget_res;
/* LAYOUTCOMMIT */
typedef struct __pnfs_layoutcommit_args {
uint64_t offset;
uint64_t length;
stateid4 *stateid;
nfstime4 *new_time;
uint64_t *new_offset;
} pnfs_layoutcommit_args;
typedef struct __pnfs_layoutcommit_res {
uint32_t status;
/* case NFS4_OK */
bool_t has_new_size;
/* case TRUE */
uint64_t new_size;
} pnfs_layoutcommit_res;
/* LAYOUTRETURN */
typedef struct __pnfs_layoutreturn_args {
bool_t reclaim;
enum pnfs_layout_type type;
enum pnfs_iomode iomode;
enum pnfs_return_type return_type;
/* case LAYOUTRETURN4_FILE: */
uint64_t offset;
uint64_t length;
stateid4 *stateid;
} pnfs_layoutreturn_args;
typedef struct __pnfs_layoutreturn_res {
enum nfsstat4 status;
/* case NFS4_OK: */
bool_t stateid_present;
/* case true: */
stateid4 stateid;
} pnfs_layoutreturn_res;
/* GETDEVICEINFO */
typedef struct __pnfs_getdeviceinfo_args {
unsigned char *deviceid;
enum pnfs_layout_type layout_type;
uint32_t maxcount;
bitmap4 notify_types;
} pnfs_getdeviceinfo_args;
typedef struct __pnfs_getdeviceinfo_res_ok {
pnfs_file_device *device;
bitmap4 notification;
} pnfs_getdeviceinfo_res_ok;
typedef struct __pnfs_getdeviceinfo_res {
enum nfsstat4 status;
union {
/* case NFS4_OK: */
pnfs_getdeviceinfo_res_ok res_ok;
/* case NFS4ERR_TOOSMALL: */
uint32_t mincount;
/* default: void; */
} u;
} pnfs_getdeviceinfo_res;
/* nfs41_ops.c */
int nfs41_exchange_id(
IN nfs41_rpc_clnt *rpc,
IN client_owner4 *owner,
IN uint32_t flags_in,
OUT nfs41_exchange_id_res *res_out);
int nfs41_create_session(
IN nfs41_client *clnt,
OUT nfs41_session *session,
IN bool_t try_recovery);
enum nfsstat4 nfs41_bind_conn_to_session(
IN nfs41_rpc_clnt *rpc,
IN const unsigned char *sessionid,
IN enum channel_dir_from_client4 dir);
int nfs41_destroy_session(
IN nfs41_session *session);
int nfs41_destroy_clientid(
IN nfs41_rpc_clnt *rpc,
IN uint64_t clientid);
int nfs41_send_sequence(
IN nfs41_session *session);
enum nfsstat4 nfs41_reclaim_complete(
IN nfs41_session *session);
int nfs41_lookup(
IN nfs41_root *root,
IN nfs41_session *session,
IN OUT nfs41_abs_path *path,
OUT OPTIONAL nfs41_path_fh *parent_out,
OUT OPTIONAL nfs41_path_fh *target_out,
OUT OPTIONAL nfs41_file_info *info_out,
OUT nfs41_session **session_out);
int nfs41_open(
IN nfs41_session *session,
IN nfs41_path_fh *parent,
IN nfs41_path_fh *file,
IN state_owner4 *owner,
IN open_claim4 *claim,
IN uint32_t allow,
IN uint32_t deny,
IN uint32_t create,
IN uint32_t how_mode,
IN OPTIONAL nfs41_file_info *createattrs,
IN bool_t try_recovery,
OUT stateid4 *stateid,
OUT open_delegation4 *delegation,
OUT OPTIONAL nfs41_file_info *info);
int nfs41_create(
IN nfs41_session *session,
IN uint32_t type,
IN nfs41_file_info *createattrs,
IN OPTIONAL const char *symlink,
IN nfs41_path_fh *parent,
OUT nfs41_path_fh *file,
OUT nfs41_file_info *info);
int nfs41_close(
IN nfs41_session *session,
IN nfs41_path_fh *file,
IN stateid_arg *stateid);
int nfs41_write(
IN nfs41_session *session,
IN nfs41_path_fh *file,
IN stateid_arg *stateid,
IN unsigned char *data,
IN uint32_t data_len,
IN uint64_t offset,
IN enum stable_how4 stable,
OUT uint32_t *bytes_written,
OUT nfs41_write_verf *verf,
OUT nfs41_file_info *cinfo);
int nfs41_read(
IN nfs41_session *session,
IN nfs41_path_fh *file,
IN stateid_arg *stateid,
IN uint64_t offset,
IN uint32_t count,
OUT unsigned char *data_out,
OUT uint32_t *data_len_out,
OUT bool_t *eof_out);
int nfs41_commit(
IN nfs41_session *session,
IN nfs41_path_fh *file,
IN uint64_t offset,
IN uint32_t count,
IN bool_t do_getattr,
OUT nfs41_write_verf *verf,
OUT nfs41_file_info *cinfo);
int nfs41_lock(
IN nfs41_session *session,
IN nfs41_path_fh *file,
IN state_owner4 *owner,
IN uint32_t type,
IN uint64_t offset,
IN uint64_t length,
IN bool_t reclaim,
IN bool_t try_recovery,
IN OUT stateid_arg *stateid);
int nfs41_unlock(
IN nfs41_session *session,
IN nfs41_path_fh *file,
IN uint64_t offset,
IN uint64_t length,
IN OUT stateid_arg *stateid);
stateid4* nfs41_lock_stateid_copy(
IN nfs41_lock_state *lock_state,
IN OUT stateid4 *dest);
int nfs41_readdir(
IN nfs41_session *session,
IN nfs41_path_fh *file,
IN bitmap4 *attr_request,
IN nfs41_readdir_cookie *cookie,
OUT unsigned char *entries,
IN OUT uint32_t *entries_len,
OUT bool_t *eof_out);
int nfs41_getattr(
IN nfs41_session *session,
IN OPTIONAL nfs41_path_fh *file,
IN bitmap4 *attr_request,
OUT nfs41_file_info *info);
int nfs41_superblock_getattr(
IN nfs41_session *session,
IN nfs41_path_fh *file,
IN bitmap4 *attr_request,
OUT nfs41_file_info *info,
OUT bool_t *supports_named_attrs);
/* getattr.c */
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);
/* symlink.c */
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);
#endif /* !__NFS41_NFS_OPS_H__ */