Tech-invite3GPPspecsGlossariesIETFRFCsGroupsSIPABNFs   Ti+   SearchTech-invite World Map Symbol

RFC 7863

 
 
 

Network File System (NFS) Version 4 Minor Version 2 External Data Representation Standard (XDR) Description

Part 2 of 4, p. 20 to 38
Prev Section       Next Section

 


prevText      Top      ToC       Page 20 
   /// enum data_content4 {
   ///         NFS4_CONTENT_DATA = 0,
   ///         NFS4_CONTENT_HOLE = 1
   /// };
   ///
   ///
   ///
   /// enum stable_how4 {
   ///         UNSTABLE4       = 0,
   ///         DATA_SYNC4      = 1,
   ///         FILE_SYNC4      = 2
   /// };
   ///
   ///
   ///
   /// struct write_response4 {
   ///         stateid4        wr_callback_id<1>;
   ///         length4         wr_count;
   ///         stable_how4     wr_committed;
   ///         verifier4       wr_writeverf;
   /// };
   ///
   ///
   /// /*
   ///  * NFSv4.1 attributes
   ///  */
   /// typedef bitmap4         fattr4_supported_attrs;
   /// typedef nfs_ftype4      fattr4_type;
   /// typedef uint32_t        fattr4_fh_expire_type;
   /// typedef changeid4       fattr4_change;
   /// typedef uint64_t        fattr4_size;
   /// typedef bool            fattr4_link_support;
   /// typedef bool            fattr4_symlink_support;
   /// typedef bool            fattr4_named_attr;
   /// typedef fsid4           fattr4_fsid;
   /// typedef bool            fattr4_unique_handles;
   /// typedef nfs_lease4      fattr4_lease_time;
   /// typedef nfsstat4        fattr4_rdattr_error;
   /// typedef nfsace4         fattr4_acl<>;
   /// typedef uint32_t        fattr4_aclsupport;
   /// typedef bool            fattr4_archive;
   /// typedef bool            fattr4_cansettime;
   /// typedef bool            fattr4_case_insensitive;
   /// typedef bool            fattr4_case_preserving;
   /// typedef bool            fattr4_chown_restricted;
   /// typedef uint64_t        fattr4_fileid;
   /// typedef uint64_t        fattr4_files_avail;
   /// typedef nfs_fh4         fattr4_filehandle;

Top      Up      ToC       Page 21 
   /// typedef uint64_t        fattr4_files_free;
   /// typedef uint64_t        fattr4_files_total;
   /// typedef fs_locations4   fattr4_fs_locations;
   /// typedef bool            fattr4_hidden;
   /// typedef bool            fattr4_homogeneous;
   /// typedef uint64_t        fattr4_maxfilesize;
   /// typedef uint32_t        fattr4_maxlink;
   /// typedef uint32_t        fattr4_maxname;
   /// typedef uint64_t        fattr4_maxread;
   /// typedef uint64_t        fattr4_maxwrite;
   /// typedef ascii_REQUIRED4 fattr4_mimetype;
   /// typedef mode4           fattr4_mode;
   /// typedef mode_masked4    fattr4_mode_set_masked;
   /// typedef uint64_t        fattr4_mounted_on_fileid;
   /// typedef bool            fattr4_no_trunc;
   /// typedef uint32_t        fattr4_numlinks;
   /// typedef utf8str_mixed   fattr4_owner;
   /// typedef utf8str_mixed   fattr4_owner_group;
   /// typedef uint64_t        fattr4_quota_avail_hard;
   /// typedef uint64_t        fattr4_quota_avail_soft;
   /// typedef uint64_t        fattr4_quota_used;
   /// typedef specdata4       fattr4_rawdev;
   /// typedef uint64_t        fattr4_space_avail;
   /// typedef length4         fattr4_space_free;
   /// typedef uint64_t        fattr4_space_total;
   /// typedef uint64_t        fattr4_space_used;
   /// typedef bool            fattr4_system;
   /// typedef nfstime4        fattr4_time_access;
   /// typedef settime4        fattr4_time_access_set;
   /// typedef nfstime4        fattr4_time_backup;
   /// typedef nfstime4        fattr4_time_create;
   /// typedef nfstime4        fattr4_time_delta;
   /// typedef nfstime4        fattr4_time_metadata;
   /// typedef nfstime4        fattr4_time_modify;
   /// typedef settime4        fattr4_time_modify_set;
   /// /*
   ///  * Attributes new to NFSv4.1
   ///  */
   /// typedef bitmap4         fattr4_suppattr_exclcreat;
   /// typedef nfstime4        fattr4_dir_notif_delay;
   /// typedef nfstime4        fattr4_dirent_notif_delay;
   /// typedef layouttype4     fattr4_fs_layout_types<>;
   /// typedef fs4_status      fattr4_fs_status;
   /// typedef fs_charset_cap4 fattr4_fs_charset_cap;
   /// typedef uint32_t        fattr4_layout_alignment;
   /// typedef uint32_t        fattr4_layout_blksize;
   /// typedef layouthint4     fattr4_layout_hint;
   /// typedef layouttype4     fattr4_layout_types<>;

Top      Up      ToC       Page 22 
   /// typedef mdsthreshold4   fattr4_mdsthreshold;
   /// typedef retention_get4  fattr4_retention_get;
   /// typedef retention_set4  fattr4_retention_set;
   /// typedef retention_get4  fattr4_retentevt_get;
   /// typedef retention_set4  fattr4_retentevt_set;
   /// typedef uint64_t        fattr4_retention_hold;
   /// typedef nfsacl41        fattr4_dacl;
   /// typedef nfsacl41        fattr4_sacl;
   /// typedef change_policy4  fattr4_change_policy;
   /// /*
   ///  * Attributes new to NFSv4.2
   ///  */
   /// typedef uint64_t        fattr4_space_freed;
   /// typedef change_attr_type4
   ///                 fattr4_change_attr_type;
   /// typedef sec_label4      fattr4_sec_label;
   /// typedef uint32_t        fattr4_clone_blksize;
   ///
   /// %/*
   /// % * REQUIRED attributes
   /// % */
   /// const FATTR4_SUPPORTED_ATTRS    = 0;
   /// const FATTR4_TYPE               = 1;
   /// const FATTR4_FH_EXPIRE_TYPE     = 2;
   /// const FATTR4_CHANGE             = 3;
   /// const FATTR4_SIZE               = 4;
   /// const FATTR4_LINK_SUPPORT       = 5;
   /// const FATTR4_SYMLINK_SUPPORT    = 6;
   /// const FATTR4_NAMED_ATTR         = 7;
   /// const FATTR4_FSID               = 8;
   /// const FATTR4_UNIQUE_HANDLES     = 9;
   /// const FATTR4_LEASE_TIME         = 10;
   /// const FATTR4_RDATTR_ERROR       = 11;
   /// const FATTR4_FILEHANDLE         = 19;
   ///
   /// %/*
   /// % * New to NFSv4.1
   /// % */
   /// const FATTR4_SUPPATTR_EXCLCREAT = 75;
   ///
   /// %/*
   /// % * RECOMMENDED attributes
   /// % */
   /// const FATTR4_ACL                = 12;
   /// const FATTR4_ACLSUPPORT         = 13;
   /// const FATTR4_ARCHIVE            = 14;
   /// const FATTR4_CANSETTIME         = 15;
   /// const FATTR4_CASE_INSENSITIVE   = 16;

Top      Up      ToC       Page 23 
   /// const FATTR4_CASE_PRESERVING    = 17;
   /// const FATTR4_CHOWN_RESTRICTED   = 18;
   /// const FATTR4_FILEID             = 20;
   /// const FATTR4_FILES_AVAIL        = 21;
   /// const FATTR4_FILES_FREE         = 22;
   /// const FATTR4_FILES_TOTAL        = 23;
   /// const FATTR4_FS_LOCATIONS       = 24;
   /// const FATTR4_HIDDEN             = 25;
   /// const FATTR4_HOMOGENEOUS        = 26;
   /// const FATTR4_MAXFILESIZE        = 27;
   /// const FATTR4_MAXLINK            = 28;
   /// const FATTR4_MAXNAME            = 29;
   /// const FATTR4_MAXREAD            = 30;
   /// const FATTR4_MAXWRITE           = 31;
   /// const FATTR4_MIMETYPE           = 32;
   /// const FATTR4_MODE               = 33;
   /// const FATTR4_NO_TRUNC           = 34;
   /// const FATTR4_NUMLINKS           = 35;
   /// const FATTR4_OWNER              = 36;
   /// const FATTR4_OWNER_GROUP        = 37;
   /// const FATTR4_QUOTA_AVAIL_HARD   = 38;
   /// const FATTR4_QUOTA_AVAIL_SOFT   = 39;
   /// const FATTR4_QUOTA_USED         = 40;
   /// const FATTR4_RAWDEV             = 41;
   /// const FATTR4_SPACE_AVAIL        = 42;
   /// const FATTR4_SPACE_FREE         = 43;
   /// const FATTR4_SPACE_TOTAL        = 44;
   /// const FATTR4_SPACE_USED         = 45;
   /// const FATTR4_SYSTEM             = 46;
   /// const FATTR4_TIME_ACCESS        = 47;
   /// const FATTR4_TIME_ACCESS_SET    = 48;
   /// const FATTR4_TIME_BACKUP        = 49;
   /// const FATTR4_TIME_CREATE        = 50;
   /// const FATTR4_TIME_DELTA         = 51;
   /// const FATTR4_TIME_METADATA      = 52;
   /// const FATTR4_TIME_MODIFY        = 53;
   /// const FATTR4_TIME_MODIFY_SET    = 54;
   /// const FATTR4_MOUNTED_ON_FILEID  = 55;
   ///
   /// %/*
   /// % * New to NFSv4.1
   /// % */
   /// const FATTR4_DIR_NOTIF_DELAY    = 56;
   /// const FATTR4_DIRENT_NOTIF_DELAY = 57;
   /// const FATTR4_DACL               = 58;
   /// const FATTR4_SACL               = 59;
   /// const FATTR4_CHANGE_POLICY      = 60;
   /// const FATTR4_FS_STATUS          = 61;

Top      Up      ToC       Page 24 
   /// const FATTR4_FS_LAYOUT_TYPES    = 62;
   /// const FATTR4_LAYOUT_HINT        = 63;
   /// const FATTR4_LAYOUT_TYPES       = 64;
   /// const FATTR4_LAYOUT_BLKSIZE     = 65;
   /// const FATTR4_LAYOUT_ALIGNMENT   = 66;
   /// const FATTR4_FS_LOCATIONS_INFO  = 67;
   /// const FATTR4_MDSTHRESHOLD       = 68;
   /// const FATTR4_RETENTION_GET      = 69;
   /// const FATTR4_RETENTION_SET      = 70;
   /// const FATTR4_RETENTEVT_GET      = 71;
   /// const FATTR4_RETENTEVT_SET      = 72;
   /// const FATTR4_RETENTION_HOLD     = 73;
   /// const FATTR4_MODE_SET_MASKED    = 74;
   /// const FATTR4_FS_CHARSET_CAP     = 76;
   ///
   /// %/*
   /// % * New to NFSv4.2
   /// % */
   /// const FATTR4_CLONE_BLKSIZE      = 77;
   /// const FATTR4_SPACE_FREED        = 78;
   /// const FATTR4_CHANGE_ATTR_TYPE   = 79;
   /// const FATTR4_SEC_LABEL          = 80;
   ///
   /// /*
   ///  * File attribute container
   ///  */
   /// struct fattr4 {
   ///         bitmap4         attrmask;
   ///         attrlist4       attr_vals;
   /// };
   ///
   /// /*
   ///  * Change info for the client
   ///  */
   /// struct change_info4 {
   ///         bool            atomic;
   ///         changeid4       before;
   ///         changeid4       after;
   /// };
   ///
   /// typedef netaddr4 clientaddr4;
   ///

Top      Up      ToC       Page 25 
   /// /*
   ///  * Callback program info as provided by the client
   ///  */
   /// struct cb_client4 {
   ///         uint32_t        cb_program;
   ///         netaddr4        cb_location;
   /// };
   ///
   /// /*
   ///  * NFSv4.0 long-hand client ID
   ///  */
   /// struct nfs_client_id4 {
   ///         verifier4       verifier;
   ///         opaque          id<NFS4_OPAQUE_LIMIT>;
   /// };
   ///
   /// /*
   ///  * NFSv4.1 client owner (aka long-hand client ID)
   ///  */
   /// struct client_owner4 {
   ///         verifier4       co_verifier;
   ///         opaque          co_ownerid<NFS4_OPAQUE_LIMIT>;
   /// };
   ///
   ///
   /// /*
   ///  * NFSv4.1 server owner
   ///  */
   /// struct server_owner4 {
   ///  uint64_t       so_minor_id;
   ///  opaque         so_major_id<NFS4_OPAQUE_LIMIT>;
   /// };
   ///
   ///
   /// struct state_owner4 {
   ///         clientid4       clientid;
   ///         opaque          owner<NFS4_OPAQUE_LIMIT>;
   /// };
   ///
   /// typedef state_owner4 open_owner4;
   /// typedef state_owner4 lock_owner4;
   ///
   ///

Top      Up      ToC       Page 26 
   /// enum nfs_lock_type4 {
   ///         READ_LT         = 1,
   ///         WRITE_LT        = 2,
   ///         READW_LT        = 3,    /* Blocking read */
   ///         WRITEW_LT       = 4     /* Blocking write */
   /// };
   ///
   ///
   /// %
   /// %/* Input for computing subkeys */
   /// enum ssv_subkey4 {
   ///         SSV4_SUBKEY_MIC_I2T     = 1,
   ///         SSV4_SUBKEY_MIC_T2I     = 2,
   ///         SSV4_SUBKEY_SEAL_I2T    = 3,
   ///         SSV4_SUBKEY_SEAL_T2I    = 4
   /// };
   /// %
   ///
   /// %
   /// %/* Input for computing smt_hmac */
   /// struct ssv_mic_plain_tkn4 {
   ///   uint32_t        smpt_ssv_seq;
   ///   opaque          smpt_orig_plain<>;
   /// };
   /// %
   ///
   /// %
   /// %/*
   /// % * Secret State Verifier Generic Security Service (SSV GSS)
   /// % * PerMsgToken token
   /// % */
   /// struct ssv_mic_tkn4 {
   ///   uint32_t        smt_ssv_seq;
   ///   opaque          smt_hmac<>;
   /// };
   /// %
   ///
   /// %
   /// %/* Input for computing ssct_encr_data and ssct_hmac */
   /// struct ssv_seal_plain_tkn4 {
   ///   opaque          sspt_confounder<>;
   ///   uint32_t        sspt_ssv_seq;
   ///   opaque          sspt_orig_plain<>;
   ///   opaque          sspt_pad<>;
   /// };
   /// %
   ///
   /// %

Top      Up      ToC       Page 27 
   /// %/* SSV GSS SealedMessage token */
   /// struct ssv_seal_cipher_tkn4 {
   ///   uint32_t      ssct_ssv_seq;
   ///   opaque        ssct_iv<>;
   ///   opaque        ssct_encr_data<>;
   ///   opaque        ssct_hmac<>;
   /// };
   /// %
   ///
   /// /*
   ///  * Defines an individual server replica
   ///  */
   /// struct fs_locations_server4 {
   ///        int32_t          fls_currency;
   ///        opaque           fls_info<>;
   ///        utf8str_cis      fls_server;
   /// };
   ///
   /// /*
   ///  * Byte indices of items within
   ///  * fls_info: flag fields, class numbers,
   ///  * bytes indicating ranks and orders
   ///  */
   /// const FSLI4BX_GFLAGS            = 0;
   /// const FSLI4BX_TFLAGS            = 1;
   ///
   /// const FSLI4BX_CLSIMUL           = 2;
   /// const FSLI4BX_CLHANDLE          = 3;
   /// const FSLI4BX_CLFILEID          = 4;
   /// const FSLI4BX_CLWRITEVER        = 5;
   /// const FSLI4BX_CLCHANGE          = 6;
   /// const FSLI4BX_CLREADDIR         = 7;
   ///
   /// const FSLI4BX_READRANK          = 8;
   /// const FSLI4BX_WRITERANK         = 9;
   /// const FSLI4BX_READORDER         = 10;
   /// const FSLI4BX_WRITEORDER        = 11;
   ///
   /// /*
   ///  * Bits defined within the general flag byte
   ///  */
   /// const FSLI4GF_WRITABLE          = 0x01;
   /// const FSLI4GF_CUR_REQ           = 0x02;
   /// const FSLI4GF_ABSENT            = 0x04;
   /// const FSLI4GF_GOING             = 0x08;
   /// const FSLI4GF_SPLIT             = 0x10;
   ///

Top      Up      ToC       Page 28 
   /// /*
   ///  * Bits defined within the transport flag byte
   ///  */
   /// const FSLI4TF_RDMA              = 0x01;
   ///
   /// /*
   ///  * Defines a set of replicas sharing
   ///  * a common value of the root path
   ///  * within the corresponding
   ///  * single-server namespaces
   ///  */
   /// struct fs_locations_item4 {
   ///        fs_locations_server4     fli_entries<>;
   ///        pathname4                fli_rootpath;
   /// };
   ///
   /// /*
   ///  * Defines the overall structure of
   ///  * the fs_locations_info attribute
   ///  */
   /// struct fs_locations_info4 {
   ///        uint32_t                 fli_flags;
   ///        int32_t                  fli_valid_for;
   ///        pathname4                fli_fs_root;
   ///        fs_locations_item4       fli_items<>;
   /// };
   ///
   /// /*
   ///  * Flag bits in fli_flags
   ///  */
   /// const FSLI4IF_VAR_SUB           = 0x00000001;
   ///
   /// typedef fs_locations_info4 fattr4_fs_locations_info;
   ///
   /// const NFL4_UFLG_MASK                    = 0x0000003F;
   /// const NFL4_UFLG_DENSE                   = 0x00000001;
   /// const NFL4_UFLG_COMMIT_THRU_MDS         = 0x00000002;
   /// const NFL42_UFLG_IO_ADVISE_THRU_MDS     = 0x00000004;
   /// const NFL4_UFLG_STRIPE_UNIT_SIZE_MASK   = 0xFFFFFFC0;
   ///
   /// typedef uint32_t nfl_util4;
   ///
   /// %
   ///

Top      Up      ToC       Page 29 
   /// enum filelayout_hint_care4 {
   ///         NFLH4_CARE_DENSE        = NFL4_UFLG_DENSE,
   ///
   ///         NFLH4_CARE_COMMIT_THRU_MDS
   ///                                 = NFL4_UFLG_COMMIT_THRU_MDS,
   ///
   ///         NFL42_CARE_IO_ADVISE_THRU_MDS
   ///                                 = NFL42_UFLG_IO_ADVISE_THRU_MDS,
   ///
   ///         NFLH4_CARE_STRIPE_UNIT_SIZE
   ///                                 = 0x00000040,
   ///
   ///         NFLH4_CARE_STRIPE_COUNT = 0x00000080
   /// };
   /// %
   /// %/*
   /// % * Encoded in the loh_body field of data type layouthint4:
   /// % */
   /// %
   /// struct nfsv4_1_file_layouthint4 {
   ///         uint32_t        nflh_care;
   ///         nfl_util4       nflh_util;
   ///         count4          nflh_stripe_count;
   /// };
   ///
   /// %
   ///
   /// %
   /// typedef netaddr4 multipath_list4<>;
   /// %
   /// %/*
   /// % * Encoded in the da_addr_body field of data type device_addr4:
   /// % */
   /// struct nfsv4_1_file_layout_ds_addr4 {
   ///         uint32_t        nflda_stripe_indices<>;
   ///         multipath_list4 nflda_multipath_ds_list<>;
   /// };
   ///
   /// %
   ///

Top      Up      ToC       Page 30 
   /// %
   /// %/*
   /// % * Encoded in the loc_body field of data type layout_content4:
   /// % */
   /// struct nfsv4_1_file_layout4 {
   ///          deviceid4      nfl_deviceid;
   ///          nfl_util4      nfl_util;
   ///          uint32_t       nfl_first_stripe_index;
   ///          offset4        nfl_pattern_offset;
   ///          nfs_fh4        nfl_fh_list<>;
   /// };
   ///
   /// %
   ///
   ///
   /// /*
   ///  * Operation arrays (the opnum first)
   ///  */
   ///
   /// 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 */

Top      Up      ToC       Page 31 
   ///  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,
   /// %

Top      Up      ToC       Page 32 
   /// %/* New operations for NFSv4.2 */
   /// %
   ///  OP_ALLOCATE             = 59,
   ///  OP_COPY                 = 60,
   ///  OP_COPY_NOTIFY          = 61,
   ///  OP_DEALLOCATE           = 62,
   ///  OP_IO_ADVISE            = 63,
   ///  OP_LAYOUTERROR          = 64,
   ///  OP_LAYOUTSTATS          = 65,
   ///  OP_OFFLOAD_CANCEL       = 66,
   ///  OP_OFFLOAD_STATUS       = 67,
   ///  OP_READ_PLUS            = 68,
   ///  OP_SEEK                 = 69,
   ///  OP_WRITE_SAME           = 70,
   ///  OP_CLONE                = 71,
   ///  OP_ILLEGAL              = 10044
   /// };
   ///
   ///
   ///
   /// const ACCESS4_READ       = 0x00000001;
   /// const ACCESS4_LOOKUP     = 0x00000002;
   /// const ACCESS4_MODIFY     = 0x00000004;
   /// const ACCESS4_EXTEND     = 0x00000008;
   /// const ACCESS4_DELETE     = 0x00000010;
   /// const ACCESS4_EXECUTE    = 0x00000020;
   ///
   /// struct ACCESS4args {
   ///         /* CURRENT_FH: object */
   ///         uint32_t        access;
   /// };
   ///
   /// struct ACCESS4resok {
   ///         uint32_t        supported;
   ///         uint32_t        access;
   /// };
   ///
   /// union ACCESS4res switch (nfsstat4 status) {
   ///  case NFS4_OK:
   ///          ACCESS4resok    resok4;
   ///  default:
   ///          void;
   /// };
   ///

Top      Up      ToC       Page 33 
   /// struct CLONE4args {
   ///         /* SAVED_FH: source file */
   ///         /* CURRENT_FH: destination file */
   ///         stateid4        cl_src_stateid;
   ///         stateid4        cl_dst_stateid;
   ///         offset4         cl_src_offset;
   ///         offset4         cl_dst_offset;
   ///         length4         cl_count;
   /// };
   ///
   /// struct CLONE4res {
   ///         nfsstat4        cl_status;
   /// };
   /// struct CLOSE4args {
   ///         /* CURRENT_FH: object */
   ///         seqid4          seqid;
   ///         stateid4        open_stateid;
   /// };
   ///
   /// union CLOSE4res switch (nfsstat4 status) {
   ///  case NFS4_OK:
   ///          stateid4       open_stateid;
   ///  default:
   ///          void;
   /// };
   ///
   /// struct COMMIT4args {
   ///         /* CURRENT_FH: file */
   ///         offset4         offset;
   ///         count4          count;
   /// };
   ///
   /// struct COMMIT4resok {
   ///         verifier4       writeverf;
   /// };
   ///
   /// union COMMIT4res switch (nfsstat4 status) {
   ///  case NFS4_OK:
   ///          COMMIT4resok   resok4;
   ///  default:
   ///          void;
   /// };
   ///

Top      Up      ToC       Page 34 
   /// union createtype4 switch (nfs_ftype4 type) {
   ///  case NF4LNK:
   ///          linktext4 linkdata;
   ///  case NF4BLK:
   ///  case NF4CHR:
   ///          specdata4 devdata;
   ///  case NF4SOCK:
   ///  case NF4FIFO:
   ///  case NF4DIR:
   ///          void;
   ///  default:
   ///          void;  /* Server should return NFS4ERR_BADTYPE. */
   /// };
   ///
   /// struct CREATE4args {
   ///         /* CURRENT_FH: directory for creation */
   ///         createtype4     objtype;
   ///         component4      objname;
   ///         fattr4          createattrs;
   /// };
   ///
   /// struct CREATE4resok {
   ///         change_info4    cinfo;
   ///         bitmap4         attrset;        /* Attributes set */
   /// };
   ///
   /// union CREATE4res switch (nfsstat4 status) {
   ///  case NFS4_OK:
   ///          /* New CURRENTFH: created object */
   ///          CREATE4resok resok4;
   ///  default:
   ///          void;
   /// };
   ///
   /// struct DELEGPURGE4args {
   ///         clientid4       clientid;
   /// };
   ///
   /// struct DELEGPURGE4res {
   ///         nfsstat4        status;
   /// };
   ///
   /// struct DELEGRETURN4args {
   ///         /* CURRENT_FH: delegated object */
   ///         stateid4        deleg_stateid;
   /// };
   ///

Top      Up      ToC       Page 35 
   /// struct DELEGRETURN4res {
   ///         nfsstat4        status;
   /// };
   ///
   /// struct GETATTR4args {
   ///         /* CURRENT_FH: object */
   ///         bitmap4         attr_request;
   /// };
   ///
   /// struct GETATTR4resok {
   ///         fattr4          obj_attributes;
   /// };
   ///
   /// union GETATTR4res switch (nfsstat4 status) {
   ///  case NFS4_OK:
   ///          GETATTR4resok  resok4;
   ///  default:
   ///          void;
   /// };
   ///
   /// struct GETFH4resok {
   ///         nfs_fh4         object;
   /// };
   ///
   /// union GETFH4res switch (nfsstat4 status) {
   ///  case NFS4_OK:
   ///          GETFH4resok     resok4;
   ///  default:
   ///          void;
   /// };
   ///
   /// struct LINK4args {
   ///         /* SAVED_FH: source object */
   ///         /* CURRENT_FH: target directory */
   ///         component4      newname;
   /// };
   ///
   /// struct LINK4resok {
   ///         change_info4    cinfo;
   /// };
   ///
   /// union LINK4res switch (nfsstat4 status) {
   ///  case NFS4_OK:
   ///          LINK4resok resok4;
   ///  default:
   ///          void;
   /// };
   ///

Top      Up      ToC       Page 36 
   /// /*
   ///  * For LOCK, transition from open_stateid and lock_owner
   ///  * to a lock stateid.
   ///  */
   /// struct open_to_lock_owner4 {
   ///         seqid4          open_seqid;
   ///         stateid4        open_stateid;
   ///         seqid4          lock_seqid;
   ///         lock_owner4     lock_owner;
   /// };
   ///
   /// /*
   ///  * For LOCK, existing lock stateid continues to request new
   ///  * file lock for the same lock_owner and open_stateid.
   ///  */
   /// struct exist_lock_owner4 {
   ///         stateid4        lock_stateid;
   ///         seqid4          lock_seqid;
   /// };
   ///
   /// union locker4 switch (bool new_lock_owner) {
   ///  case TRUE:
   ///         open_to_lock_owner4     open_owner;
   ///  case FALSE:
   ///         exist_lock_owner4       lock_owner;
   /// };
   ///
   /// /*
   ///  * LOCK/LOCKT/LOCKU: Record lock management
   ///  */
   /// struct LOCK4args {
   ///         /* CURRENT_FH: file */
   ///         nfs_lock_type4  locktype;
   ///         bool            reclaim;
   ///         offset4         offset;
   ///         length4         length;
   ///         locker4         locker;
   /// };
   ///
   /// struct LOCK4denied {
   ///         offset4         offset;
   ///         length4         length;
   ///         nfs_lock_type4  locktype;
   ///         lock_owner4     owner;
   /// };
   ///

Top      Up      ToC       Page 37 
   /// struct LOCK4resok {
   ///         stateid4        lock_stateid;
   /// };
   ///
   /// union LOCK4res switch (nfsstat4 status) {
   ///  case NFS4_OK:
   ///          LOCK4resok     resok4;
   ///  case NFS4ERR_DENIED:
   ///          LOCK4denied    denied;
   ///  default:
   ///          void;
   /// };
   ///
   /// struct LOCKT4args {
   ///         /* CURRENT_FH: file */
   ///         nfs_lock_type4  locktype;
   ///         offset4         offset;
   ///         length4         length;
   ///         lock_owner4     owner;
   /// };
   ///
   /// union LOCKT4res switch (nfsstat4 status) {
   ///  case NFS4ERR_DENIED:
   ///          LOCK4denied    denied;
   ///  case NFS4_OK:
   ///          void;
   ///  default:
   ///          void;
   /// };
   ///
   /// struct LOCKU4args {
   ///         /* CURRENT_FH: file */
   ///         nfs_lock_type4  locktype;
   ///         seqid4          seqid;
   ///         stateid4        lock_stateid;
   ///         offset4         offset;
   ///         length4         length;
   /// };
   ///
   /// union LOCKU4res switch (nfsstat4 status) {
   ///  case NFS4_OK:
   ///          stateid4       lock_stateid;
   ///  default:
   ///          void;
   /// };
   ///

Top      Up      ToC       Page 38 
   /// struct LOOKUP4args {
   ///         /* CURRENT_FH: directory */
   ///         component4      objname;
   /// };
   ///
   /// struct LOOKUP4res {
   ///         /* New CURRENT_FH: object */
   ///         nfsstat4        status;
   /// };
   ///
   /// struct LOOKUPP4res {
   ///         /* New CURRENT_FH: parent directory */
   ///         nfsstat4        status;
   /// };
   ///
   /// struct NVERIFY4args {
   ///         /* CURRENT_FH: object */
   ///         fattr4          obj_attributes;
   /// };
   ///
   /// struct NVERIFY4res {
   ///         nfsstat4        status;
   /// };
   ///
   /// /*
   ///  * Various definitions for OPEN
   ///  */
   /// enum createmode4 {
   ///         UNCHECKED4      = 0,
   ///         GUARDED4        = 1,
   ///         /* Deprecated in NFSv4.1 */
   ///         EXCLUSIVE4      = 2,
   ///         /*
   ///          * New to NFSv4.1.  If session is persistent,
   ///          * GUARDED4 MUST be used.  Otherwise, use
   ///          * EXCLUSIVE4_1 instead of EXCLUSIVE4.
   ///          */
   ///         EXCLUSIVE4_1    = 3
   /// };
   ///
   /// struct creatverfattr {
   ///          verifier4      cva_verf;
   ///          fattr4         cva_attrs;
   /// };
   ///


Next Section