RFC 7863
Network File System (NFS) Version 4 Minor Version 2 External Data Representation Standard (XDR) Description
1. Introduction ✨
Okay so bestie, welcome to part 1 of the RFC 7863 glow-up 💅🦋 This one is the XDR description for NFS version 4 minor version 2, which is basically the data-language blueprint for NFSv4.2 🌸 It's by T. Haynes from Primary Data, it's a Standards Track doc from November 2016, and it's ISSN 2070-1721. Its whole job is to be the machine-readable XDR for the protocol, and it's sitting over in the RFC 7862 neighbourhood 🧚
Quick title-block tea ☕ It was written by T. Haynes at Primary Data, and it's an Internet Standards Track document, so it's the real deal, not a draft. Copyright is IETF Trust plus the authors, all rights reserved, and code pulled out of it needs the Simplified BSD License text 🎀 This part is 1 through 2, and the sections after that show up in the later parts 💜
1.1. Requirements Language
Here's the vibe check on the key words 🔥 In this document, "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" are to be read as described in RFC 2119 [RFC2119] 🫶
2. XDR Description of NFSv4.2 💖
Okay so this section is giving "all-in-one" energy 😭 The goal is to support NFSv4.0, NFSv4.1, and NFSv4.2 together, so the description keeps some NFSv4.0 and NFSv4.1 operations and features that don't apply to NFSv4.2 🌈 The XDR is fully compatible with NFSv4.0 [RFC7531], except for clientaddr4, which got replaced by netaddr4 (technically an alias). They have the same members and same purposes, just renamed 👑
The renames:
(r_netid -> na_r_netid, r_addr -> na_r_addr)And this effectively reconverges the NFSv4.0 [RFC7531] and NFSv4.1 [RFC5662] strands of the XDR, which is honestly so iconic ✨
Now the extraction bit 🧚 The XDR is written so you can pull it out and compile it without much fuss. Here's the little shell script that does the work:
#!/bin/sh
grep "^ *///" | sed 's?^ */// ??' | sed 's?^ *///$??'So if you save that as "extract.sh" and the document as "spec.txt", you run:
sh extract.sh < spec.txt > nfs4_prot.xWhat it does is strip the leading whitespace from each line, plus the sentinel "///" 💅 The XDR description, sentinel and all, comes next, and that's where we pick up in Part 2 🦋
Okay, the XDR block is giving everything. Here it is, pasted exactly as the spec wrote it 💅
/// /*
/// * This file was machine generated for [RFC7862].
/// *
/// * Last updated Sun Mar 13 10:58:40 PDT 2016
/// */
///
/// /*
/// * Copyright (c) 2016 IETF Trust and the persons identified
/// * as the authors. All rights reserved.
/// *
/// * Redistribution and use in source and binary forms, with
/// * or without modification, are permitted provided that the
/// * following conditions are met:
/// *
/// * - Redistributions of source code must retain the above
/// * copyright notice, this list of conditions and the
/// * following disclaimer.
/// *
/// * - Redistributions in binary form must reproduce the above
/// * copyright notice, this list of conditions and the
/// * following disclaimer in the documentation and/or other
/// * materials provided with the distribution.
/// *
/// * - Neither the name of Internet Society, IETF or IETF
/// * Trust, nor the names of specific contributors, may be
/// * used to endorse or promote products derived from this
/// * software without specific prior written permission.
/// *
/// * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
/// * AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
/// * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
/// * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
/// * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
/// * EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
/// * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
/// * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
/// * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
/// * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
/// * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
/// * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
/// * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
/// * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
/// * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
///
/// */
///
/// /*
/// * This code was derived from RFC 7863.
/// */
///
/// /*
/// * nfsv42.x
/// */
///
/// %#ifndef _AUTH_SYS_DEFINE_FOR_NFSv42
/// %#define _AUTH_SYS_DEFINE_FOR_NFSv42
/// %#include <rpc/auth_sys.h>
/// %typedef struct authsys_parms authsys_parms;
/// %#endif /* _AUTH_SYS_DEFINE_FOR_NFSv42 */
///
/// /*
/// * Basic typedefs for RFC 1832 data type definitions
/// */
///
/// /*
/// * typedef int int32_t;
/// * typedef unsigned int uint32_t;
/// * typedef hyper int64_t;
/// * typedef unsigned hyper uint64_t;
/// */
///
/// /*
/// * Sizes
/// */
/// const NFS4_FHSIZE = 128;
/// const NFS4_VERIFIER_SIZE = 8;
/// const NFS4_OTHER_SIZE = 12;
/// const NFS4_OPAQUE_LIMIT = 1024;
/// const NFS4_SESSIONID_SIZE = 16;
///
/// const NFS4_INT64_MAX = 0x7fffffffffffffff;
/// const NFS4_UINT64_MAX = 0xffffffffffffffff;
/// const NFS4_INT32_MAX = 0x7fffffff;
/// const NFS4_UINT32_MAX = 0xffffffff;
///
/// const NFS4_MAXFILELEN = 0xffffffffffffffff;
/// const NFS4_MAXFILEOFF = 0xfffffffffffffffe;
///
///
/// /*
/// * File types
/// */
/// enum nfs_ftype4 {
/// NF4REG = 1, /* Regular File */
/// NF4DIR = 2, /* Directory */
/// NF4BLK = 3, /* Special File -- block device */
/// NF4CHR = 4, /* Special File -- character device */
/// NF4LNK = 5, /* Symbolic Link */
/// NF4SOCK = 6, /* Special File -- socket */
/// NF4FIFO = 7, /* Special File -- fifo */
/// NF4ATTRDIR = 8, /* Attribute Directory */
/// NF4NAMEDATTR = 9 /* Named Attribute */
/// };
///
/// /*
/// * Error status
/// */
/// enum nfsstat4 {
/// NFS4_OK = 0, /* everything is okay */
/// NFS4ERR_PERM = 1, /* caller not privileged */
/// NFS4ERR_NOENT = 2, /* no such file/directory */
/// NFS4ERR_IO = 5, /* hard I/O error */
/// NFS4ERR_NXIO = 6, /* no such device */
/// NFS4ERR_ACCESS = 13, /* access denied */
/// NFS4ERR_EXIST = 17, /* file already exists */
/// NFS4ERR_XDEV = 18, /* different file systems */
///
/// /*
/// * Please do not allocate value 19; it was used in NFSv3,
/// * and we do not want a value in NFSv3 to have a different
/// * meaning in NFSv4.x.
/// */
///
/// NFS4ERR_NOTDIR = 20, /* should be a directory */
/// NFS4ERR_ISDIR = 21, /* should not be a directory */
/// NFS4ERR_INVAL = 22, /* invalid argument */
/// NFS4ERR_FBIG = 27, /* file exceeds server max */
/// NFS4ERR_NOSPC = 28, /* no space on file system */
/// NFS4ERR_ROFS = 30, /* read-only file system */
/// NFS4ERR_MLINK = 31, /* too many hard links */
/// NFS4ERR_NAMETOOLONG = 63, /* name exceeds server max */
/// NFS4ERR_NOTEMPTY = 66, /* directory not empty */
/// NFS4ERR_DQUOT = 69, /* hard quota limit reached */
/// NFS4ERR_STALE = 70, /* file no longer exists */
/// NFS4ERR_BADHANDLE = 10001, /* illegal filehandle */
/// NFS4ERR_BAD_COOKIE = 10003, /* READDIR cookie is stale */
/// NFS4ERR_NOTSUPP = 10004, /* operation not supported */
/// NFS4ERR_TOOSMALL = 10005, /* response limit exceeded */
/// NFS4ERR_SERVERFAULT = 10006, /* undefined server error */
/// NFS4ERR_BADTYPE = 10007, /* type invalid for CREATE */
/// NFS4ERR_DELAY = 10008, /* file "busy" -- retry */
/// NFS4ERR_SAME = 10009, /* nverify says attrs same */
/// NFS4ERR_DENIED = 10010, /* lock unavailable */
/// NFS4ERR_EXPIRED = 10011, /* lock lease expired */
/// NFS4ERR_LOCKED = 10012, /* I/O failed due to lock */
/// NFS4ERR_GRACE = 10013, /* in grace period */
/// NFS4ERR_FHEXPIRED = 10014, /* filehandle expired */
/// NFS4ERR_SHARE_DENIED = 10015, /* share reserve denied */
/// NFS4ERR_WRONGSEC = 10016, /* wrong security flavor */
/// NFS4ERR_CLID_INUSE = 10017, /* client ID in use */
///
/// /* NFS4ERR_RESOURCE is not a valid error in NFSv4.1. */
/// NFS4ERR_RESOURCE = 10018, /* resource exhaustion */
///
/// NFS4ERR_MOVED = 10019, /* file system relocated */
/// NFS4ERR_NOFILEHANDLE = 10020, /* current FH is not set */
/// NFS4ERR_MINOR_VERS_MISMATCH= 10021, /* minor vers not supp */
/// NFS4ERR_STALE_CLIENTID = 10022, /* server has rebooted */
/// NFS4ERR_STALE_STATEID = 10023, /* server has rebooted */
/// NFS4ERR_OLD_STATEID = 10024, /* state is out of sync */
/// NFS4ERR_BAD_STATEID = 10025, /* incorrect stateid */
/// NFS4ERR_BAD_SEQID = 10026, /* request is out of seq. */
/// NFS4ERR_NOT_SAME = 10027, /* verify -- attrs not same */
/// NFS4ERR_LOCK_RANGE = 10028, /* overlapping lock range */
/// NFS4ERR_SYMLINK = 10029, /* should be file/directory */
/// NFS4ERR_RESTOREFH = 10030, /* no saved filehandle */
/// NFS4ERR_LEASE_MOVED = 10031, /* some file system moved */
/// NFS4ERR_ATTRNOTSUPP = 10032, /* recommended attr not supp */
/// NFS4ERR_NO_GRACE = 10033, /* reclaim outside of grace */
/// NFS4ERR_RECLAIM_BAD = 10034, /* reclaim error at server */
/// NFS4ERR_RECLAIM_CONFLICT= 10035, /* conflict on reclaim */
/// NFS4ERR_BADXDR = 10036, /* XDR decode failed */
/// NFS4ERR_LOCKS_HELD = 10037, /* file locks held at CLOSE */
/// NFS4ERR_OPENMODE = 10038, /* conflict in OPEN and I/O */
/// NFS4ERR_BADOWNER = 10039, /* owner translation bad */
/// NFS4ERR_BADCHAR = 10040, /* UTF-8 char not supported */
/// NFS4ERR_BADNAME = 10041, /* name not supported */
/// NFS4ERR_BAD_RANGE = 10042, /* lock range not supported */
/// NFS4ERR_LOCK_NOTSUPP = 10043, /* no atomic up/downgrade */
/// NFS4ERR_OP_ILLEGAL = 10044, /* undefined operation */
/// NFS4ERR_DEADLOCK = 10045, /* file-locking deadlock */
/// NFS4ERR_FILE_OPEN = 10046, /* open file blocks op */
/// NFS4ERR_ADMIN_REVOKED = 10047, /* lock-owner state revoked */
/// NFS4ERR_CB_PATH_DOWN = 10048, /* callback path down */
///
/// /* NFSv4.1 errors start here. */
///
/// NFS4ERR_BADIOMODE = 10049,
/// NFS4ERR_BADLAYOUT = 10050,
/// NFS4ERR_BAD_SESSION_DIGEST = 10051,
/// NFS4ERR_BADSESSION = 10052,
/// NFS4ERR_BADSLOT = 10053,
/// NFS4ERR_COMPLETE_ALREADY = 10054,
/// NFS4ERR_CONN_NOT_BOUND_TO_SESSION = 10055,
/// NFS4ERR_DELEG_ALREADY_WANTED = 10056,
/// NFS4ERR_BACK_CHAN_BUSY = 10057, /* backchan reqs outstanding */
/// NFS4ERR_LAYOUTTRYLATER = 10058,
/// NFS4ERR_LAYOUTUNAVAILABLE = 10059,
/// NFS4ERR_NOMATCHING_LAYOUT = 10060,
/// NFS4ERR_RECALLCONFLICT = 10061,
/// NFS4ERR_UNKNOWN_LAYOUTTYPE = 10062,
/// NFS4ERR_SEQ_MISORDERED = 10063, /* unexpected seq. ID in req */
/// NFS4ERR_SEQUENCE_POS = 10064, /* [CB_]SEQ. op not 1st op */
/// NFS4ERR_REQ_TOO_BIG = 10065, /* request too big */
/// NFS4ERR_REP_TOO_BIG = 10066, /* reply too big */
/// NFS4ERR_REP_TOO_BIG_TO_CACHE =10067, /* rep. not all cached */
/// NFS4ERR_RETRY_UNCACHED_REP =10068, /* retry + rep. uncached */
/// NFS4ERR_UNSAFE_COMPOUND =10069, /* retry/recovery too hard */
/// NFS4ERR_TOO_MANY_OPS = 10070, /* too many ops in [CB_]COMP */
/// NFS4ERR_OP_NOT_IN_SESSION =10071, /* op needs [CB_]SEQ. op */
/// NFS4ERR_HASH_ALG_UNSUPP = 10072, /* hash alg. not supp */
/// /* Error 10073 is unused. */
/// NFS4ERR_CLIENTID_BUSY = 10074, /* client ID has state */
/// NFS4ERR_PNFS_IO_HOLE = 10075, /* IO to _SPARSE file hole */
/// NFS4ERR_SEQ_FALSE_RETRY= 10076, /* retry != original req */
/// NFS4ERR_BAD_HIGH_SLOT = 10077, /* req has bad highest_slot */
/// NFS4ERR_DEADSESSION = 10078, /* new req sent to dead sess */
/// NFS4ERR_ENCR_ALG_UNSUPP= 10079, /* encr alg. not supp */
/// NFS4ERR_PNFS_NO_LAYOUT = 10080, /* I/O without a layout */
/// NFS4ERR_NOT_ONLY_OP = 10081, /* addl ops not allowed */
/// NFS4ERR_WRONG_CRED = 10082, /* op done by wrong cred */
/// NFS4ERR_WRONG_TYPE = 10083, /* op on wrong type object */
/// NFS4ERR_DIRDELEG_UNAVAIL=10084, /* delegation not avail. */
/// NFS4ERR_REJECT_DELEG = 10085, /* cb rejected delegation */
/// NFS4ERR_RETURNCONFLICT = 10086, /* layout get before return */
/// NFS4ERR_DELEG_REVOKED = 10087, /* deleg./layout revoked */
///
/// /* NFSv4.2 errors start here. */
///
/// NFS4ERR_PARTNER_NOTSUPP= 10088, /* s2s not supported */
/// NFS4ERR_PARTNER_NO_AUTH= 10089, /* s2s not authorized */
/// NFS4ERR_UNION_NOTSUPP = 10090, /* arm of union not supp */
/// NFS4ERR_OFFLOAD_DENIED = 10091, /* dest not allowing copy *//// NFS4ERR_WRONG_LFS = 10092, /* LFS not supported / /// NFS4ERR_BADLABEL = 10093, / incorrect label / /// NFS4ERR_OFFLOAD_NO_REQS= 10094 / dest not meeting reqs / /// }; /// /// / /// * Basic data types /// / /// typedef opaque attrlist4<>; /// typedef uint32_t bitmap4<>; /// typedef uint64_t changeid4; /// typedef uint64_t clientid4; /// typedef uint32_t count4; /// typedef uint64_t length4; /// typedef uint32_t mode4; /// typedef uint64_t nfs_cookie4; /// typedef opaque nfs_fh4<NFS4_FHSIZE>; /// typedef uint64_t offset4; /// typedef uint32_t qop4; /// typedef opaque sec_oid4<>; /// typedef uint32_t sequenceid4; /// typedef uint32_t seqid4; /// typedef opaque sessionid4[NFS4_SESSIONID_SIZE]; /// typedef uint32_t slotid4; /// typedef opaque utf8string<>; /// typedef utf8string utf8str_cis; /// typedef utf8string utf8str_cs; /// typedef utf8string utf8str_mixed; /// typedef utf8str_cs component4; /// typedef opaque linktext4<>; /// typedef utf8string ascii_REQUIRED4; /// typedef component4 pathname4<>; /// typedef opaque verifier4[NFS4_VERIFIER_SIZE]; /// typedef string secret4<>; /// typedef uint32_t policy4; /// /// / /// * Timeval /// / /// struct nfstime4 { /// int64_t seconds; /// uint32_t nseconds; /// }; /// /// enum time_how4 { /// SET_TO_SERVER_TIME4 = 0, /// SET_TO_CLIENT_TIME4 = 1 /// }; /// /// union settime4 switch (time_how4 set_it) { /// case SET_TO_CLIENT_TIME4: /// nfstime4 time; /// default: /// void; /// }; /// /// /// typedef uint32_t nfs_lease4; /// /// / /// * File attribute definitions /// / /// /// / /// * File System ID (FSID) structure for major/minor /// / /// struct fsid4 { /// uint64_t major; /// uint64_t minor; /// }; /// /// / /// * File system locations attribute /// * for relocation/migration and /// * related attributes /// / /// struct change_policy4 { /// uint64_t cp_major; /// uint64_t cp_minor; /// }; /// /// struct fs_location4 { /// utf8str_cis server<>; /// pathname4 rootpath; /// }; /// /// struct fs_locations4 { /// pathname4 fs_root; /// fs_location4 locations<>; /// }; /// /// / /// * Various Access Control Entry (ACE) definitions /// / /// /// / /// * Mask that indicates which ACEs are supported. /// * Values for the fattr4_aclsupport attribute. /// / /// const ACL4_SUPPORT_ALLOW_ACL = 0x00000001; /// const ACL4_SUPPORT_DENY_ACL = 0x00000002; /// const ACL4_SUPPORT_AUDIT_ACL = 0x00000004; /// const ACL4_SUPPORT_ALARM_ACL = 0x00000008; /// /// /// typedef uint32_t acetype4; /// /// /// / /// * acetype4 values. Others can be added as needed. /// / /// const ACE4_ACCESS_ALLOWED_ACE_TYPE = 0x00000000; /// const ACE4_ACCESS_DENIED_ACE_TYPE = 0x00000001; /// const ACE4_SYSTEM_AUDIT_ACE_TYPE = 0x00000002; /// const ACE4_SYSTEM_ALARM_ACE_TYPE = 0x00000003; /// /// /// /// / /// * ACE flag /// / /// typedef uint32_t aceflag4; /// /// /// / /// * ACE flag values /// / /// const ACE4_FILE_INHERIT_ACE = 0x00000001; /// const ACE4_DIRECTORY_INHERIT_ACE = 0x00000002; /// const ACE4_NO_PROPAGATE_INHERIT_ACE = 0x00000004; /// const ACE4_INHERIT_ONLY_ACE = 0x00000008; /// const ACE4_SUCCESSFUL_ACCESS_ACE_FLAG = 0x00000010; /// const ACE4_FAILED_ACCESS_ACE_FLAG = 0x00000020; /// const ACE4_IDENTIFIER_GROUP = 0x00000040; /// const ACE4_INHERITED_ACE = 0x00000080; /// /// /// /// / /// * ACE mask /// / /// typedef uint32_t acemask4; /// /// /// / /// * ACE mask values /// / /// const ACE4_READ_DATA = 0x00000001; /// const ACE4_LIST_DIRECTORY = 0x00000001; /// const ACE4_WRITE_DATA = 0x00000002; /// const ACE4_ADD_FILE = 0x00000002; /// const ACE4_APPEND_DATA = 0x00000004; /// const ACE4_ADD_SUBDIRECTORY = 0x00000004; /// const ACE4_READ_NAMED_ATTRS = 0x00000008; /// const ACE4_WRITE_NAMED_ATTRS = 0x00000010; /// const ACE4_EXECUTE = 0x00000020; /// const ACE4_DELETE_CHILD = 0x00000040; /// const ACE4_READ_ATTRIBUTES = 0x00000080; /// const ACE4_WRITE_ATTRIBUTES = 0x00000100; /// const ACE4_WRITE_RETENTION = 0x00000200; /// const ACE4_WRITE_RETENTION_HOLD = 0x00000400; /// /// const ACE4_DELETE = 0x00010000; /// const ACE4_READ_ACL = 0x00020000; /// const ACE4_WRITE_ACL = 0x00040000; /// const ACE4_WRITE_OWNER = 0x00080000; /// const ACE4_SYNCHRONIZE = 0x00100000; /// /// /// / /// * ACE4_GENERIC_READ -- defined as a combination of /// * ACE4_READ_ACL | /// * ACE4_READ_DATA | /// * ACE4_READ_ATTRIBUTES | /// * ACE4_SYNCHRONIZE /// / /// /// const ACE4_GENERIC_READ = 0x00120081; /// /// / /// * ACE4_GENERIC_WRITE -- defined as a combination of /// * ACE4_READ_ACL | /// * ACE4_WRITE_DATA | /// * ACE4_WRITE_ATTRIBUTES | /// * ACE4_WRITE_ACL | /// * ACE4_APPEND_DATA | /// * ACE4_SYNCHRONIZE /// / /// const ACE4_GENERIC_WRITE = 0x00160106; /// /// /// / /// * ACE4_GENERIC_EXECUTE -- defined as a combination of /// * ACE4_READ_ACL | /// * ACE4_READ_ATTRIBUTES | /// * ACE4_EXECUTE | /// * ACE4_SYNCHRONIZE /// / /// const ACE4_GENERIC_EXECUTE = 0x001200A0; /// /// /// / /// * ACE definition /// / /// struct nfsace4 { /// acetype4 type; /// aceflag4 flag; /// acemask4 access_mask; /// utf8str_mixed who; /// }; /// /// /// / /// * Access Control List (ACL) flag /// / /// /// typedef uint32_t aclflag4; /// /// / /// * ACL flag values /// / /// const ACL4_AUTO_INHERIT = 0x00000001; /// const ACL4_PROTECTED = 0x00000002; /// const ACL4_DEFAULTED = 0x00000004; /// /// /// / /// * Version 4.1 ACL definition /// / /// struct nfsacl41 { /// aclflag4 na41_flag; /// nfsace4 na41_aces<>; /// }; /// /// /// / /// * Field definitions for the fattr4_mode /// * and fattr4_mode_set_masked attributes /// / /// const MODE4_SUID = 0x800; / set user id on execution / /// const MODE4_SGID = 0x400; / set group id on execution / /// const MODE4_SVTX = 0x200; / save text even after use / /// const MODE4_RUSR = 0x100; / read permission: owner / /// const MODE4_WUSR = 0x080; / write permission: owner / /// const MODE4_XUSR = 0x040; / execute permission: owner / /// const MODE4_RGRP = 0x020; / read permission: group / /// const MODE4_WGRP = 0x010; / write permission: group / /// const MODE4_XGRP = 0x008; / execute permission: group / /// const MODE4_ROTH = 0x004; / read permission: other / /// const MODE4_WOTH = 0x002; / write permission: other / /// const MODE4_XOTH = 0x001; / execute permission: other / /// /// /// / /// * Masked mode for the mode_set_masked attribute /// / /// struct mode_masked4 { /// mode4 mm_value_to_set; / Values of bits /// to set or reset /// in mode / /// /// mode4 mm_mask_bits; / Mask of bits to /// set or reset /// in mode / /// }; /// /// / /// * Special data/attribute associated with /// * file types NF4BLK and NF4CHR /// / /// struct specdata4 { /// uint32_t specdata1; / Major device number / /// uint32_t specdata2; / Minor device number / /// }; /// /// / /// * Values for fattr4_fh_expire_type /// / /// const FH4_PERSISTENT = 0x00000000; /// const FH4_NOEXPIRE_WITH_OPEN = 0x00000001; /// const FH4_VOLATILE_ANY = 0x00000002; /// const FH4_VOL_MIGRATION = 0x00000004; /// const FH4_VOL_RENAME = 0x00000008; /// /// /// struct netaddr4 { /// / See struct rpcb in RFC 1833. / /// string na_r_netid<>; / Network id / /// string na_r_addr<>; / Universal address / /// }; /// /// /// / /// * Data structures new to NFSv4.1 /// / /// /// struct nfs_impl_id4 { /// utf8str_cis nii_domain; /// utf8str_cs nii_name; /// nfstime4 nii_date; /// }; /// /// /// / /// * Stateid /// / /// struct stateid4 { /// uint32_t seqid; /// opaque other[NFS4_OTHER_SIZE]; /// }; /// /// enum layouttype4 { /// LAYOUT4_NFSV4_1_FILES = 0x1, /// LAYOUT4_OSD2_OBJECTS = 0x2, /// LAYOUT4_BLOCK_VOLUME = 0x3 /// }; /// /// struct layout_content4 { /// layouttype4 loc_type; /// opaque loc_body<>; /// }; /// /// /// %/ /// % * LAYOUT4_OSD2_OBJECTS loc_body description /// % * is in a separate .x file. /// % / /// % /// %/ /// % * LAYOUT4_BLOCK_VOLUME loc_body description /// % * is in a separate .x file. /// % / /// /// struct layouthint4 { /// layouttype4 loh_type; /// opaque loh_body<>; /// }; /// /// enum layoutiomode4 { /// LAYOUTIOMODE4_READ = 1, /// LAYOUTIOMODE4_RW = 2, /// LAYOUTIOMODE4_ANY = 3 /// }; /// /// struct layout4 { /// offset4 lo_offset; /// length4 lo_length; /// layoutiomode4 lo_iomode; /// layout_content4 lo_content; /// }; /// /// const NFS4_DEVICEID4_SIZE = 16; /// /// typedef opaque deviceid4[NFS4_DEVICEID4_SIZE]; /// /// struct device_addr4 { /// layouttype4 da_layout_type; /// opaque da_addr_body<>; /// }; /// /// /// struct layoutupdate4 { /// layouttype4 lou_type; /// opaque lou_body<>; /// }; /// /// % /// / Constants used for LAYOUTRETURN and CB_LAYOUTRECALL / /// const LAYOUT4_RET_REC_FILE = 1; /// const LAYOUT4_RET_REC_FSID = 2; /// const LAYOUT4_RET_REC_ALL = 3; /// % /// enum layoutreturn_type4 { /// LAYOUTRETURN4_FILE = LAYOUT4_RET_REC_FILE, /// LAYOUTRETURN4_FSID = LAYOUT4_RET_REC_FSID, /// LAYOUTRETURN4_ALL = LAYOUT4_RET_REC_ALL /// }; /// /// struct layoutreturn_file4 { /// offset4 lrf_offset; /// length4 lrf_length; /// stateid4 lrf_stateid; /// % / layouttype4 specific data */ /// opaque lrf_body<>; /// }; /// /// union layoutreturn4 switch (layoutreturn_type4 lr_returntype) { /// case LAYOUTRETURN4_FILE:
Okay so the XDR keeps going, and this is where NFSv4.2 starts getting extra spicy 💅✨ Let's get into it 🦋
/// layoutreturn_file4 lr_layout;
/// default:
/// void;
/// };
/// %
///
/// enum fs4_status_type {
/// STATUS4_FIXED = 1,
/// STATUS4_UPDATED = 2,
/// STATUS4_VERSIONED = 3,
/// STATUS4_WRITABLE = 4,
/// STATUS4_REFERRAL = 5
/// };
///
/// struct fs4_status {
/// bool fss_absent;
/// fs4_status_type fss_type;
/// utf8str_cs fss_source;
/// utf8str_cs fss_current;
/// int32_t fss_age;
/// nfstime4 fss_version;
/// };
///
///
/// const TH4_READ_SIZE = 0;
/// const TH4_WRITE_SIZE = 1;
/// const TH4_READ_IOSIZE = 2;
/// const TH4_WRITE_IOSIZE = 3;
///
/// typedef length4 threshold4_read_size;
/// typedef length4 threshold4_write_size;
/// typedef length4 threshold4_read_iosize;
/// typedef length4 threshold4_write_iosize;
///
/// struct threshold_item4 {
/// layouttype4 thi_layout_type;
/// bitmap4 thi_hintset;
/// opaque thi_hintlist<>;
/// };
///
/// struct mdsthreshold4 {
/// threshold_item4 mth_hints<>;
/// };
///
/// const RET4_DURATION_INFINITE = 0xffffffffffffffff;
/// struct retention_get4 {
/// uint64_t rg_duration;
/// nfstime4 rg_begin_time<1>;
/// };
///
/// struct retention_set4 {
/// bool rs_enable;
/// uint64_t rs_duration<1>;
/// };
///
/// const FSCHARSET_CAP4_CONTAINS_NON_UTF8 = 0x1;
/// const FSCHARSET_CAP4_ALLOWS_ONLY_UTF8 = 0x2;
///
/// typedef uint32_t fs_charset_cap4;
///
///
/// /*
/// * Data structures new to NFSv4.2
/// */
///
/// enum netloc_type4 {
/// NL4_NAME = 1,
/// NL4_URL = 2,
/// NL4_NETADDR = 3
/// };
/// union netloc4 switch (netloc_type4 nl_type) {
/// case NL4_NAME: utf8str_cis nl_name;
/// case NL4_URL: utf8str_cis nl_url;
/// case NL4_NETADDR: netaddr4 nl_addr;
/// };
///
/// enum change_attr_type4 {
/// NFS4_CHANGE_TYPE_IS_MONOTONIC_INCR = 0,
/// NFS4_CHANGE_TYPE_IS_VERSION_COUNTER = 1,
/// NFS4_CHANGE_TYPE_IS_VERSION_COUNTER_NOPNFS = 2,
/// NFS4_CHANGE_TYPE_IS_TIME_METADATA = 3,
/// NFS4_CHANGE_TYPE_IS_UNDEFINED = 4
/// };
///
/// struct labelformat_spec4 {
/// policy4 lfs_lfs;
/// policy4 lfs_pi;
/// };
///
/// struct sec_label4 {
/// labelformat_spec4 slai_lfs;
/// opaque slai_data<>;
/// };
///
///
/// struct copy_from_auth_priv {
/// secret4 cfap_shared_secret;
/// netloc4 cfap_destination;
/// /* The NFSv4 user name that the user principal maps to */
/// utf8str_mixed cfap_username;
/// };
///
/// struct copy_to_auth_priv {
/// /* Equal to cfap_shared_secret */
/// secret4 ctap_shared_secret;
/// netloc4 ctap_source<>;
/// /* The NFSv4 user name that the user principal maps to */
/// utf8str_mixed ctap_username;
/// };
///
/// struct copy_confirm_auth_priv {
/// /* Equal to GSS_GetMIC() of cfap_shared_secret */
/// opaque ccap_shared_secret_mic<>;
/// /* The NFSv4 user name that the user principal maps to */
/// utf8str_mixed ccap_username;
/// };
///
///
/// struct app_data_block4 {
/// offset4 adb_offset;
/// length4 adb_block_size;
/// length4 adb_block_count;
/// length4 adb_reloff_blocknum;
/// count4 adb_block_num;
/// length4 adb_reloff_pattern;
/// opaque adb_pattern<>;
/// };
///
///
/// struct data4 {
/// offset4 d_offset;
/// opaque d_data<>;
/// };
///
/// struct data_info4 {
/// offset4 di_offset;
/// length4 di_length;
/// };
///
///
/// 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;
/// 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<>;
/// 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;
/// 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;okay so the attribute numbers keep going, and this is where the NFSv4.1 and NFSv4.2 additions show up 🎀✨
/// 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;
/// 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;
///
/// /*
/// * 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;
///
///
/// 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<>;
/// };
/// %
///
/// %
/// %/* 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;
///
/// /*
/// * 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;
///
/// %
///
/// 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<>;
/// };
///
/// %
///
/// %
/// %/*
/// % * 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 */
/// 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,
/// %
/// %/* 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 */Okay bestie, this XDR is where the types get serious 💅✨
/// uint32_t access;
/// };
///
/// struct ACCESS4resok {
/// uint32_t supported;
/// uint32_t access;
/// };
///
/// union ACCESS4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// ACCESS4resok resok4;
/// default:
/// void;
/// };
///
/// 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;
/// };
///
/// 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;
/// };
///
/// 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;
/// };
///
/// /*
/// * 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;
/// };
///
/// 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;
/// };
///
/// 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;
/// };
///
/// union createhow4 switch (createmode4 mode) {
/// case UNCHECKED4:
/// case GUARDED4:
/// fattr4 createattrs;
/// case EXCLUSIVE4:
/// verifier4 createverf;
/// case EXCLUSIVE4_1:
/// creatverfattr ch_createboth;
/// };
///
/// enum opentype4 {
/// OPEN4_NOCREATE = 0,
/// OPEN4_CREATE = 1
/// };
///
/// union openflag4 switch (opentype4 opentype) {
/// case OPEN4_CREATE:
/// createhow4 how;
/// default:
/// void;
/// };
///
/// /* Next definitions used for OPEN delegation */
/// enum limit_by4 {
/// NFS_LIMIT_SIZE = 1,
/// NFS_LIMIT_BLOCKS = 2
/// /* Others as needed */
/// };
///
/// struct nfs_modified_limit4 {
/// uint32_t num_blocks;
/// uint32_t bytes_per_block;
/// };
///
/// union nfs_space_limit4 switch (limit_by4 limitby) {
/// /* Limit specified as file size */
/// case NFS_LIMIT_SIZE:
/// uint64_t filesize;
/// /* Limit specified by number of blocks */
/// case NFS_LIMIT_BLOCKS:
/// nfs_modified_limit4 mod_blocks;
/// };
///
/// /*
/// * Share Access and Deny constants for open argument
/// */
/// const OPEN4_SHARE_ACCESS_READ = 0x00000001;
/// const OPEN4_SHARE_ACCESS_WRITE = 0x00000002;
/// const OPEN4_SHARE_ACCESS_BOTH = 0x00000003;
///
/// const OPEN4_SHARE_DENY_NONE = 0x00000000;
/// const OPEN4_SHARE_DENY_READ = 0x00000001;
/// const OPEN4_SHARE_DENY_WRITE = 0x00000002;
/// const OPEN4_SHARE_DENY_BOTH = 0x00000003;
///
///
/// /* New flags for share_access field of OPEN4args */
/// const OPEN4_SHARE_ACCESS_WANT_DELEG_MASK = 0xFF00;
/// const OPEN4_SHARE_ACCESS_WANT_NO_PREFERENCE = 0x0000;
/// const OPEN4_SHARE_ACCESS_WANT_READ_DELEG = 0x0100;
/// const OPEN4_SHARE_ACCESS_WANT_WRITE_DELEG = 0x0200;
/// const OPEN4_SHARE_ACCESS_WANT_ANY_DELEG = 0x0300;
/// const OPEN4_SHARE_ACCESS_WANT_NO_DELEG = 0x0400;
/// const OPEN4_SHARE_ACCESS_WANT_CANCEL = 0x0500;
///
/// const
/// OPEN4_SHARE_ACCESS_WANT_SIGNAL_DELEG_WHEN_RESRC_AVAIL
/// = 0x10000;
///
/// const
/// 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 /* New to NFSv4.1 */
/// };
///
/// enum open_claim_type4 {
/// /*
/// * Not a reclaim
/// */
/// CLAIM_NULL = 0,
///
/// CLAIM_PREVIOUS = 1,
/// CLAIM_DELEGATE_CUR = 2,
/// CLAIM_DELEGATE_PREV = 3,
///
/// /*
/// * Not a reclaim
/// *
/// * Like CLAIM_NULL, but object identified
/// * by the current filehandle
/// */
/// CLAIM_FH = 4, /* New to NFSv4.1 */
///
/// /*
/// * Like CLAIM_DELEGATE_CUR, but object identified
/// * by current filehandle
/// */
/// CLAIM_DELEG_CUR_FH = 5, /* New to NFSv4.1 */
///
/// /*
/// * Like CLAIM_DELEGATE_PREV, but object identified
/// * by current filehandle
/// */
/// CLAIM_DELEG_PREV_FH = 6 /* New to NFSv4.1 */
/// };
///
/// struct open_claim_delegate_cur4 {
/// stateid4 delegate_stateid;
/// component4 file;
/// };
///
/// union open_claim4 switch (open_claim_type4 claim) {
/// /*
/// * No special rights to file.
/// * Ordinary OPEN of the specified file.
/// */
/// case CLAIM_NULL:
/// /* CURRENT_FH: directory */
/// component4 file;okay so this is where the claim types get spicy 💅 each one answers a different question about who's allowed to open the file, and CLAIM_PREVIOUS is all about getting your file back after a server reboot 🔄✨
/// /*
/// * Right to the file established by an
/// * open previous to server reboot. File
/// * identified by filehandle obtained at
/// * that time rather than by name.
/// */
/// case CLAIM_PREVIOUS:
/// /* CURRENT_FH: file being reclaimed */
/// open_delegation_type4 delegate_type;
///
/// /*
/// * Right to file based on a delegation
/// * granted by the server. File is
/// * specified by name.
/// */
/// case CLAIM_DELEGATE_CUR:
/// /* CURRENT_FH: directory */
/// open_claim_delegate_cur4 delegate_cur_info;
///
/// /*
/// * Right to file based on a delegation
/// * granted to a previous boot instance
/// * of the client. File is specified by name.
/// */
/// case CLAIM_DELEGATE_PREV:
/// /* CURRENT_FH: directory */
/// component4 file_delegate_prev;
///
/// /*
/// * Like CLAIM_NULL. No special rights
/// * to file. Ordinary OPEN of the
/// * specified file by current filehandle.
/// */
/// case CLAIM_FH: /* New to NFSv4.1 */
/// /* CURRENT_FH: regular file to open */
/// void;
///
/// /*
/// * Like CLAIM_DELEGATE_PREV. Right to file based on a
/// * delegation granted to a previous boot
/// * instance of the client. File is identified
/// * by filehandle.
/// */
/// case CLAIM_DELEG_PREV_FH: /* New to NFSv4.1 */
/// /* CURRENT_FH: file being opened */
/// void;
///
/// /*
/// * Like CLAIM_DELEGATE_CUR. Right to file based on
/// * a delegation granted by the server.
/// * File is identified by filehandle.
/// */
/// case CLAIM_DELEG_CUR_FH: /* New to NFSv4.1 */
/// /* CURRENT_FH: file being opened */
/// stateid4 oc_delegate_stateid;
///
/// };
///
/// /*
/// * OPEN: Open a file, potentially receiving an open delegation.
/// */
/// struct OPEN4args {
/// seqid4 seqid;
/// uint32_t share_access;
/// uint32_t share_deny;
/// open_owner4 owner;
/// openflag4 openhow;
/// open_claim4 claim;
/// };
///
/// struct open_read_delegation4 {
/// stateid4 stateid; /* Stateid for delegation */
/// bool recall; /* Pre-recalled flag for
/// delegations obtained
/// by reclaim (CLAIM_PREVIOUS) */
///
/// nfsace4 permissions; /* Defines users who don't
/// need an ACCESS call to
/// open for read */
/// };
///
/// struct open_write_delegation4 {
/// stateid4 stateid; /* Stateid for delegation */
/// bool recall; /* Pre-recalled flag for
/// delegations obtained
/// by reclaim
/// (CLAIM_PREVIOUS) */
///
/// nfs_space_limit4
/// space_limit; /* Defines condition that
/// the client must check to
/// determine whether the
/// file needs to be flushed
/// to the server on close */
///
/// nfsace4 permissions; /* Defines users who don't
/// need an ACCESS call as
/// part of a delegated
/// open */
/// };
///
///
/// enum why_no_delegation4 { /* New to NFSv4.1 */
/// 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_CANCELLED = 7,
/// WND4_IS_DIR = 8
/// };
///
/// union open_none_delegation4 /* New to NFSv4.1 */
/// switch (why_no_delegation4 ond_why) {
/// case WND4_CONTENTION:
/// bool ond_server_will_push_deleg;
/// case WND4_RESOURCE:
/// bool ond_server_will_signal_avail;
/// default:
/// void;
/// };
///
/// union open_delegation4
/// switch (open_delegation_type4 delegation_type) {
/// case OPEN_DELEGATE_NONE:
/// void;
/// case OPEN_DELEGATE_READ:
/// open_read_delegation4 read;
/// case OPEN_DELEGATE_WRITE:
/// open_write_delegation4 write;
/// case OPEN_DELEGATE_NONE_EXT: /* New to NFSv4.1 */
/// open_none_delegation4 od_whynone;
/// };
///
/// /*
/// * Result flags
/// */
///
/// /* Client must confirm open. */
/// const OPEN4_RESULT_CONFIRM = 0x00000002;
/// /* Type of file-locking behavior at the server */
/// const OPEN4_RESULT_LOCKTYPE_POSIX = 0x00000004;
/// /* Server will preserve file if removed while open. */
/// const OPEN4_RESULT_PRESERVE_UNLINKED = 0x00000008;
///
/// /*
/// * Server may use CB_NOTIFY_LOCK on locks
/// * derived from this open.
/// */
/// const OPEN4_RESULT_MAY_NOTIFY_LOCK = 0x00000020;
///
/// struct OPEN4resok {
/// stateid4 stateid; /* Stateid for open */
/// change_info4 cinfo; /* Directory change info */
/// uint32_t rflags; /* Result flags */
/// bitmap4 attrset; /* Attribute set for create */
/// open_delegation4 delegation; /* Info on any open
/// delegation */
/// };
///
/// union OPEN4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// /* New CURRENT_FH: opened file */
/// OPEN4resok resok4;
/// default:
/// void;
/// };
///
/// struct OPENATTR4args {
/// /* CURRENT_FH: object */
/// bool createdir;
/// };
///
/// struct OPENATTR4res {
/// /*
/// * If status is NFS4_OK,
/// * New CURRENT_FH: named attribute
/// * directory
/// */
/// nfsstat4 status;
/// };
///
/// /* Obsolete in NFSv4.1 */
/// struct OPEN_CONFIRM4args {
/// /* CURRENT_FH: opened file */
/// stateid4 open_stateid;
/// seqid4 seqid;
/// };
///
/// struct OPEN_CONFIRM4resok {
/// stateid4 open_stateid;
/// };
///
/// union OPEN_CONFIRM4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// OPEN_CONFIRM4resok resok4;
/// default:
/// void;
/// };
///
/// struct OPEN_DOWNGRADE4args {
/// /* CURRENT_FH: opened file */
/// stateid4 open_stateid;
/// seqid4 seqid;
/// uint32_t share_access;
/// uint32_t share_deny;
/// };
///
/// struct OPEN_DOWNGRADE4resok {
/// stateid4 open_stateid;
/// };
///
/// union OPEN_DOWNGRADE4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// OPEN_DOWNGRADE4resok resok4;
/// default:
/// void;
/// };
///
/// struct PUTFH4args {
/// nfs_fh4 object;
/// };
///
/// struct PUTFH4res {
/// /*
/// * If status is NFS4_OK,
/// * New CURRENT_FH: argument to PUTFH
/// */
/// nfsstat4 status;
/// };
///
/// struct PUTPUBFH4res {
/// /*
/// * If status is NFS4_OK,
/// * New CURRENT_FH: public fh
/// */
/// nfsstat4 status;
/// };
///
/// struct PUTROOTFH4res {
/// /*
/// * If status is NFS4_OK,
/// * New CURRENT_FH: root fh
/// */
/// nfsstat4 status;
/// };
///
/// struct READ4args {
/// /* CURRENT_FH: file */
/// stateid4 stateid;
/// offset4 offset;
/// count4 count;
/// };
///
/// struct READ4resok {
/// bool eof;
/// opaque data<>;
/// };
///
/// union READ4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// READ4resok resok4;
/// default:
/// void;
/// };
///
/// struct READDIR4args {
/// /* CURRENT_FH: directory */
/// nfs_cookie4 cookie;
/// verifier4 cookieverf;
/// count4 dircount;
/// count4 maxcount;
/// bitmap4 attr_request;
/// };
///
/// struct entry4 {
/// nfs_cookie4 cookie;
/// component4 name;
/// fattr4 attrs;
/// entry4 *nextentry;
/// };
///
/// struct dirlist4 {
/// entry4 *entries;
/// bool eof;
/// };
///
/// struct READDIR4resok {
/// verifier4 cookieverf;
/// dirlist4 reply;
/// };
///
///
/// union READDIR4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// READDIR4resok resok4;
/// default:
/// void;
/// };
///
///
/// struct READLINK4resok {
/// linktext4 link;
/// };
///
/// union READLINK4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// READLINK4resok resok4;
/// default:
/// void;
/// };
///
/// struct REMOVE4args {
/// /* CURRENT_FH: directory */
/// component4 target;
/// };
///
/// struct REMOVE4resok {
/// change_info4 cinfo;
/// };
///
/// union REMOVE4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// REMOVE4resok resok4;
/// default:
/// void;
/// };
///
/// struct RENAME4args {
/// /* SAVED_FH: source directory */
/// component4 oldname;
/// /* CURRENT_FH: target directory */
/// component4 newname;
/// };
///
/// struct RENAME4resok {
/// change_info4 source_cinfo;
/// change_info4 target_cinfo;
/// };
///
/// union RENAME4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// RENAME4resok resok4;
/// default:
/// void;
/// };
///
/// /* Obsolete in NFSv4.1 */
/// struct RENEW4args {
/// clientid4 clientid;
/// };
///
/// struct RENEW4res {
/// nfsstat4 status;
/// };
///
/// struct RESTOREFH4res {
/// /*
/// * If status is NFS4_OK,
/// * New CURRENT_FH: value of saved fh
/// */
/// nfsstat4 status;
/// };
///
/// struct SAVEFH4res {
/// /*
/// * If status is NFS4_OK,
/// * New SAVED_FH: value of current fh
/// */
/// nfsstat4 status;
/// };
///
/// struct SECINFO4args {
/// /* CURRENT_FH: directory */
/// component4 name;
/// };
///
/// /*
/// * From RFC 2203
/// */
/// enum rpc_gss_svc_t {
/// RPC_GSS_SVC_NONE = 1,
/// RPC_GSS_SVC_INTEGRITY = 2,
/// RPC_GSS_SVC_PRIVACY = 3
/// };
///
/// struct rpcsec_gss_info {
/// sec_oid4 oid;okay bestie, we're still deep in the XDR era 🧚 these are the structs and unions for the rest of the ops, so keep your eyes peeled 👀✨
/// qop4 qop;
/// rpc_gss_svc_t service;
/// };
///
/// /* RPCSEC_GSS has a value of "6". See RFC 2203. */
/// union secinfo4 switch (uint32_t flavor) {
/// case RPCSEC_GSS:
/// rpcsec_gss_info flavor_info;
/// default:
/// void;
/// };
///
/// typedef secinfo4 SECINFO4resok<>;
///
/// union SECINFO4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// /* CURRENTFH: consumed */
/// SECINFO4resok resok4;
/// default:
/// void;
/// };
///
/// struct SETATTR4args {
/// /* CURRENT_FH: target object */
/// stateid4 stateid;
/// fattr4 obj_attributes;
/// };
///
/// struct SETATTR4res {
/// nfsstat4 status;
/// bitmap4 attrsset;
/// };
///
/// /* Obsolete in NFSv4.1 */
/// struct SETCLIENTID4args {
/// nfs_client_id4 client;
/// cb_client4 callback;
/// uint32_t callback_ident;
/// };
///
/// struct SETCLIENTID4resok {
/// clientid4 clientid;
/// verifier4 setclientid_confirm;
/// };
///
/// union SETCLIENTID4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// SETCLIENTID4resok resok4;
/// case NFS4ERR_CLID_INUSE:
/// clientaddr4 client_using;
/// default:
/// void;
/// };
///
/// /* Obsolete in NFSv4.1 */
/// struct SETCLIENTID_CONFIRM4args {
/// clientid4 clientid;
/// verifier4 setclientid_confirm;
/// };
///
/// struct SETCLIENTID_CONFIRM4res {
/// nfsstat4 status;
/// };
///
/// struct VERIFY4args {
/// /* CURRENT_FH: object */
/// fattr4 obj_attributes;
/// };
///
/// struct VERIFY4res {
/// nfsstat4 status;
/// };
///
/// struct WRITE4args {
/// /* CURRENT_FH: file */
/// stateid4 stateid;
/// offset4 offset;
/// stable_how4 stable;
/// opaque data<>;
/// };
///
/// struct WRITE4resok {
/// count4 count;
/// stable_how4 committed;
/// verifier4 writeverf;
/// };
///
/// union WRITE4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// WRITE4resok resok4;
/// default:
/// void;
/// };
///
/// /* Obsolete in NFSv4.1 */
/// struct RELEASE_LOCKOWNER4args {
/// lock_owner4 lock_owner;
/// };
///
/// struct RELEASE_LOCKOWNER4res {
/// nfsstat4 status;
/// };
///
/// struct ILLEGAL4res {
/// nfsstat4 status;
/// };
///
/// typedef opaque gsshandle4_t<>;
///
/// struct gss_cb_handles4 {
/// rpc_gss_svc_t gcbp_service; /* RFC 2203 */
/// gsshandle4_t gcbp_handle_from_server;
/// gsshandle4_t gcbp_handle_from_client;
/// };
///
/// union callback_sec_parms4 switch (uint32_t cb_secflavor) {
/// case AUTH_NONE:
/// void;
/// case AUTH_SYS:
/// authsys_parms cbsp_sys_cred; /* RFC 5531 */
/// case RPCSEC_GSS:
/// gss_cb_handles4 cbsp_gss_handles;
/// };
///
/// struct BACKCHANNEL_CTL4args {
/// uint32_t bca_cb_program;
/// callback_sec_parms4 bca_sec_parms<>;
/// };
///
/// struct BACKCHANNEL_CTL4res {
/// nfsstat4 bcr_status;
/// };
///
/// enum channel_dir_from_client4 {
/// CDFC4_FORE = 0x1,
/// CDFC4_BACK = 0x2,
/// CDFC4_FORE_OR_BOTH = 0x3,
/// CDFC4_BACK_OR_BOTH = 0x7
/// };
///
/// struct BIND_CONN_TO_SESSION4args {
/// sessionid4 bctsa_sessid;
///
/// channel_dir_from_client4
/// bctsa_dir;
///
/// bool bctsa_use_conn_in_rdma_mode;
/// };
///
/// enum channel_dir_from_server4 {
/// CDFS4_FORE = 0x1,
/// CDFS4_BACK = 0x2,
/// CDFS4_BOTH = 0x3
/// };
///
/// struct BIND_CONN_TO_SESSION4resok {
/// sessionid4 bctsr_sessid;
///
/// channel_dir_from_server4
/// bctsr_dir;
///
/// bool bctsr_use_conn_in_rdma_mode;
/// };
///
/// union BIND_CONN_TO_SESSION4res
/// switch (nfsstat4 bctsr_status) {
/// case NFS4_OK:
/// BIND_CONN_TO_SESSION4resok bctsr_resok4;
/// default:
/// void;
/// };
///
/// const EXCHGID4_FLAG_SUPP_MOVED_REFER = 0x00000001;
/// const EXCHGID4_FLAG_SUPP_MOVED_MIGR = 0x00000002;
/// const EXCHGID4_FLAG_SUPP_FENCE_OPS = 0x00000004;
///
/// const EXCHGID4_FLAG_BIND_PRINC_STATEID = 0x00000100;
///
/// const EXCHGID4_FLAG_USE_NON_PNFS = 0x00010000;
/// const EXCHGID4_FLAG_USE_PNFS_MDS = 0x00020000;
/// const EXCHGID4_FLAG_USE_PNFS_DS = 0x00040000;
///
/// const EXCHGID4_FLAG_MASK_PNFS = 0x00070000;
///
/// const EXCHGID4_FLAG_UPD_CONFIRMED_REC_A = 0x40000000;
/// const EXCHGID4_FLAG_CONFIRMED_R = 0x80000000;
///
/// struct state_protect_ops4 {
/// bitmap4 spo_must_enforce;
/// bitmap4 spo_must_allow;
/// };
///
/// struct ssv_sp_parms4 {
/// state_protect_ops4 ssp_ops;
/// sec_oid4 ssp_hash_algs<>;
/// sec_oid4 ssp_encr_algs<>;
/// uint32_t ssp_window;
/// uint32_t ssp_num_gss_handles;
/// };
///
/// enum state_protect_how4 {
/// SP4_NONE = 0,
/// SP4_MACH_CRED = 1,
/// SP4_SSV = 2
/// };
///
/// union state_protect4_a switch (state_protect_how4 spa_how) {
/// case SP4_NONE:
/// void;
/// case SP4_MACH_CRED:
/// state_protect_ops4 spa_mach_ops;
/// case SP4_SSV:
/// ssv_sp_parms4 spa_ssv_parms;
/// };
///
/// struct EXCHANGE_ID4args {
/// client_owner4 eia_clientowner;
/// uint32_t eia_flags;
/// state_protect4_a eia_state_protect;
/// nfs_impl_id4 eia_client_impl_id<1>;
/// };
///
/// struct ssv_prot_info4 {
/// state_protect_ops4 spi_ops;
/// uint32_t spi_hash_alg;
/// uint32_t spi_encr_alg;
/// uint32_t spi_ssv_len;
/// uint32_t spi_window;
/// gsshandle4_t spi_handles<>;
/// };
///
/// union state_protect4_r switch (state_protect_how4 spr_how) {
/// case SP4_NONE:
/// void;
/// case SP4_MACH_CRED:
/// state_protect_ops4 spr_mach_ops;
/// case SP4_SSV:
/// ssv_prot_info4 spr_ssv_info;
/// };
///
/// struct EXCHANGE_ID4resok {
/// clientid4 eir_clientid;
/// sequenceid4 eir_sequenceid;
/// uint32_t eir_flags;
/// state_protect4_r eir_state_protect;
/// server_owner4 eir_server_owner;
/// opaque eir_server_scope<NFS4_OPAQUE_LIMIT>;
/// nfs_impl_id4 eir_server_impl_id<1>;
/// };
///
/// union EXCHANGE_ID4res switch (nfsstat4 eir_status) {
/// case NFS4_OK:
/// EXCHANGE_ID4resok eir_resok4;
///
/// default:
/// void;
/// };
///
/// struct channel_attrs4 {
/// count4 ca_headerpadsize;
/// count4 ca_maxrequestsize;
/// count4 ca_maxresponsesize;
/// count4 ca_maxresponsesize_cached;
/// count4 ca_maxoperations;
/// count4 ca_maxrequests;
/// uint32_t ca_rdma_ird<1>;
/// };
///
/// const CREATE_SESSION4_FLAG_PERSIST = 0x00000001;
/// const CREATE_SESSION4_FLAG_CONN_BACK_CHAN = 0x00000002;
/// const CREATE_SESSION4_FLAG_CONN_RDMA = 0x00000004;
///
/// struct CREATE_SESSION4args {
/// clientid4 csa_clientid;
/// sequenceid4 csa_sequence;
///
/// uint32_t csa_flags;
///
/// channel_attrs4 csa_fore_chan_attrs;
/// channel_attrs4 csa_back_chan_attrs;
///
/// uint32_t csa_cb_program;
/// callback_sec_parms4 csa_sec_parms<>;
/// };
///
/// struct CREATE_SESSION4resok {
/// sessionid4 csr_sessionid;
/// sequenceid4 csr_sequence;
///
/// uint32_t csr_flags;
///
/// channel_attrs4 csr_fore_chan_attrs;
/// channel_attrs4 csr_back_chan_attrs;
/// };
///
/// union CREATE_SESSION4res switch (nfsstat4 csr_status) {
/// case NFS4_OK:
/// CREATE_SESSION4resok csr_resok4;
/// default:
/// void;
/// };
///
/// struct DESTROY_SESSION4args {
/// sessionid4 dsa_sessionid;
/// };
///
/// struct DESTROY_SESSION4res {
/// nfsstat4 dsr_status;
/// };
///
/// struct FREE_STATEID4args {
/// stateid4 fsa_stateid;
/// };
///
/// struct FREE_STATEID4res {
/// nfsstat4 fsr_status;
/// };
///
///
/// typedef nfstime4 attr_notice4;
///
/// struct GET_DIR_DELEGATION4args {
/// /* CURRENT_FH: delegated directory */
/// bool gdda_signal_deleg_avail;
/// bitmap4 gdda_notification_types;
/// attr_notice4 gdda_child_attr_delay;
/// attr_notice4 gdda_dir_attr_delay;
/// bitmap4 gdda_child_attributes;
/// bitmap4 gdda_dir_attributes;
/// };
/// struct GET_DIR_DELEGATION4resok {
/// verifier4 gddr_cookieverf;
/// /* Stateid for get_dir_delegation */
/// stateid4 gddr_stateid;
/// /* Which notifications can the server support? */
/// bitmap4 gddr_notification;
/// bitmap4 gddr_child_attributes;
/// bitmap4 gddr_dir_attributes;
/// };
///
/// enum gddrnf4_status {
/// GDD4_OK = 0,
/// GDD4_UNAVAIL = 1
/// };
///
/// union GET_DIR_DELEGATION4res_non_fatal
/// switch (gddrnf4_status gddrnf_status) {
/// case GDD4_OK:
/// GET_DIR_DELEGATION4resok gddrnf_resok4;
/// case GDD4_UNAVAIL:
/// bool gddrnf_will_signal_deleg_avail;
/// };
///
/// union GET_DIR_DELEGATION4res
/// switch (nfsstat4 gddr_status) {
/// case NFS4_OK:
/// GET_DIR_DELEGATION4res_non_fatal gddr_res_non_fatal4;
/// default:
/// void;
/// };
///
/// struct GETDEVICEINFO4args {
/// deviceid4 gdia_device_id;
/// layouttype4 gdia_layout_type;
/// count4 gdia_maxcount;
/// bitmap4 gdia_notify_types;
/// };
///
/// struct GETDEVICEINFO4resok {
/// device_addr4 gdir_device_addr;
/// bitmap4 gdir_notification;
/// };
///
/// union GETDEVICEINFO4res switch (nfsstat4 gdir_status) {
/// case NFS4_OK:
/// GETDEVICEINFO4resok gdir_resok4;okay bestie, this part is all XDR definitions, so the code is giving everything 💅✨
/// case NFS4ERR_TOOSMALL:
/// count4 gdir_mincount;
/// default:
/// void;
/// };
///
/// struct GETDEVICELIST4args {
/// /* CURRENT_FH: object belonging to the file system */
/// layouttype4 gdla_layout_type;
///
/// /* Number of device IDs to return */
/// count4 gdla_maxdevices;
///
/// nfs_cookie4 gdla_cookie;
/// verifier4 gdla_cookieverf;
/// };
///
/// struct GETDEVICELIST4resok {
/// nfs_cookie4 gdlr_cookie;
/// verifier4 gdlr_cookieverf;
/// deviceid4 gdlr_deviceid_list<>;
/// bool gdlr_eof;
/// };
///
/// union GETDEVICELIST4res switch (nfsstat4 gdlr_status) {
/// case NFS4_OK:
/// GETDEVICELIST4resok gdlr_resok4;
/// default:
/// void;
/// };
///
/// union newtime4 switch (bool nt_timechanged) {
/// case TRUE:
/// nfstime4 nt_time;
/// case FALSE:
/// void;
/// };
///
/// union newoffset4 switch (bool no_newoffset) {
/// case TRUE:
/// offset4 no_offset;
/// case FALSE:
/// void;
/// };
///
/// struct LAYOUTCOMMIT4args {
/// /* CURRENT_FH: file */
/// offset4 loca_offset;
/// length4 loca_length;
/// bool loca_reclaim;
/// stateid4 loca_stateid;
/// newoffset4 loca_last_write_offset;
/// newtime4 loca_time_modify;
/// layoutupdate4 loca_layoutupdate;
/// };
/// union newsize4 switch (bool ns_sizechanged) {
/// case TRUE:
/// length4 ns_size;
/// case FALSE:
/// void;
/// };
///
/// struct LAYOUTCOMMIT4resok {
/// newsize4 locr_newsize;
/// };
///
/// union LAYOUTCOMMIT4res switch (nfsstat4 locr_status) {
/// case NFS4_OK:
/// LAYOUTCOMMIT4resok locr_resok4;
/// default:
/// void;
/// };
///
/// struct LAYOUTGET4args {
/// /* CURRENT_FH: file */
/// bool loga_signal_layout_avail;
/// layouttype4 loga_layout_type;
/// layoutiomode4 loga_iomode;
/// offset4 loga_offset;
/// length4 loga_length;
/// length4 loga_minlength;
/// stateid4 loga_stateid;
/// count4 loga_maxcount;
/// };
/// struct LAYOUTGET4resok {
/// bool logr_return_on_close;
/// stateid4 logr_stateid;
/// layout4 logr_layout<>;
/// };
///
/// union LAYOUTGET4res switch (nfsstat4 logr_status) {
/// case NFS4_OK:
/// LAYOUTGET4resok logr_resok4;
/// case NFS4ERR_LAYOUTTRYLATER:
/// bool logr_will_signal_layout_avail;
/// default:
/// void;
/// };
///
///
/// struct LAYOUTRETURN4args {
/// /* CURRENT_FH: file */
/// bool lora_reclaim;
/// layouttype4 lora_layout_type;
/// layoutiomode4 lora_iomode;
/// layoutreturn4 lora_layoutreturn;
/// };
///
///
/// union layoutreturn_stateid switch (bool lrs_present) {
/// case TRUE:
/// stateid4 lrs_stateid;
/// case FALSE:
/// void;
/// };
///
/// union LAYOUTRETURN4res switch (nfsstat4 lorr_status) {
/// case NFS4_OK:
/// layoutreturn_stateid lorr_stateid;
/// default:
/// void;
/// };
///
/// enum secinfo_style4 {
/// SECINFO_STYLE4_CURRENT_FH = 0,
/// SECINFO_STYLE4_PARENT = 1
/// };
///
/// /* CURRENT_FH: object or child directory */
/// typedef secinfo_style4 SECINFO_NO_NAME4args;
///
/// /* CURRENTFH: consumed if status is NFS4_OK */
/// typedef SECINFO4res SECINFO_NO_NAME4res;
///
/// struct SEQUENCE4args {
/// sessionid4 sa_sessionid;
/// sequenceid4 sa_sequenceid;
/// slotid4 sa_slotid;
/// slotid4 sa_highest_slotid;
/// bool sa_cachethis;
/// };
///
/// const SEQ4_STATUS_CB_PATH_DOWN = 0x00000001;
/// const SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING = 0x00000002;
/// const SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED = 0x00000004;
/// const SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED = 0x00000008;
/// const SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED = 0x00000010;
/// const SEQ4_STATUS_ADMIN_STATE_REVOKED = 0x00000020;
/// const SEQ4_STATUS_RECALLABLE_STATE_REVOKED = 0x00000040;
/// const SEQ4_STATUS_LEASE_MOVED = 0x00000080;
/// const SEQ4_STATUS_RESTART_RECLAIM_NEEDED = 0x00000100;
/// const SEQ4_STATUS_CB_PATH_DOWN_SESSION = 0x00000200;
/// const SEQ4_STATUS_BACKCHANNEL_FAULT = 0x00000400;
/// const SEQ4_STATUS_DEVID_CHANGED = 0x00000800;
/// const SEQ4_STATUS_DEVID_DELETED = 0x00001000;
///
/// struct SEQUENCE4resok {
/// sessionid4 sr_sessionid;
/// sequenceid4 sr_sequenceid;
/// slotid4 sr_slotid;
/// slotid4 sr_highest_slotid;
/// slotid4 sr_target_highest_slotid;
/// uint32_t sr_status_flags;
/// };
///
/// union SEQUENCE4res switch (nfsstat4 sr_status) {
/// case NFS4_OK:
/// SEQUENCE4resok sr_resok4;
/// default:
/// void;
/// };
///
/// struct ssa_digest_input4 {
/// SEQUENCE4args sdi_seqargs;
/// };
///
/// struct SET_SSV4args {
/// opaque ssa_ssv<>;
/// opaque ssa_digest<>;
/// };
///
/// struct ssr_digest_input4 {
/// SEQUENCE4res sdi_seqres;
/// };
///
/// struct SET_SSV4resok {
/// opaque ssr_digest<>;
/// };
///
/// union SET_SSV4res switch (nfsstat4 ssr_status) {
/// case NFS4_OK:
/// SET_SSV4resok ssr_resok4;
/// default:
/// void;
/// };
///
/// struct TEST_STATEID4args {
/// stateid4 ts_stateids<>;
/// };
///
/// struct TEST_STATEID4resok {
/// nfsstat4 tsr_status_codes<>;
/// };
///
/// union TEST_STATEID4res switch (nfsstat4 tsr_status) {
/// case NFS4_OK:
/// TEST_STATEID4resok tsr_resok4;
/// default:
/// void;
/// };
///
/// union deleg_claim4 switch (open_claim_type4 dc_claim) {
/// /*
/// * No special rights to object. Ordinary delegation
/// * request of the specified object. Object identified
/// * by filehandle.
/// */
/// case CLAIM_FH: /* New to NFSv4.1 */
/// /* CURRENT_FH: object being delegated */
/// void;
///
/// /*
/// * Right to file based on a delegation granted
/// * to a previous boot instance of the client.
/// * File is specified by filehandle.
/// */
/// case CLAIM_DELEG_PREV_FH: /* New to NFSv4.1 */
/// /* CURRENT_FH: object being delegated */
/// void;
///
/// /*
/// * Right to the file established by an open previous
/// * to server reboot. File identified by filehandle.
/// * Used during server reclaim grace period.
/// */
/// case CLAIM_PREVIOUS:
/// /* CURRENT_FH: object being reclaimed */
/// open_delegation_type4 dc_delegate_type;
/// };
///
/// struct WANT_DELEGATION4args {
/// uint32_t wda_want;
/// deleg_claim4 wda_claim;
/// };
///
/// union WANT_DELEGATION4res switch (nfsstat4 wdr_status) {
/// case NFS4_OK:
/// open_delegation4 wdr_resok4;
/// default:
/// void;
/// };
///
/// struct DESTROY_CLIENTID4args {
/// clientid4 dca_clientid;
/// };
///
/// struct DESTROY_CLIENTID4res {
/// nfsstat4 dcr_status;
/// };
///
/// struct RECLAIM_COMPLETE4args {
/// /*
/// * If rca_one_fs TRUE,
/// *
/// * CURRENT_FH: object in
/// * file system for which the
/// * reclaim is complete.
/// */
/// bool rca_one_fs;
/// };
///
/// struct RECLAIM_COMPLETE4res {
/// nfsstat4 rcr_status;
/// };
///
/// struct COPY4args {
/// /* SAVED_FH: source file */
/// /* CURRENT_FH: destination file */
/// stateid4 ca_src_stateid;
/// stateid4 ca_dst_stateid;
/// offset4 ca_src_offset;
/// offset4 ca_dst_offset;
/// length4 ca_count;
/// bool ca_consecutive;
/// bool ca_synchronous;
/// netloc4 ca_source_server<>;
/// };
///
///
/// struct copy_requirements4 {
/// bool cr_consecutive;
/// bool cr_synchronous;
/// };
///
/// struct COPY4resok {
/// write_response4 cr_response;
/// copy_requirements4 cr_requirements;
/// };
///
/// union COPY4res switch (nfsstat4 cr_status) {
/// case NFS4_OK:
/// COPY4resok cr_resok4;
/// case NFS4ERR_OFFLOAD_NO_REQS:
/// copy_requirements4 cr_requirements;
/// default:
/// void;
/// };
///
/// struct COPY_NOTIFY4args {
/// /* CURRENT_FH: source file */
/// stateid4 cna_src_stateid;
/// netloc4 cna_destination_server;
/// };
///
/// struct COPY_NOTIFY4resok {
/// nfstime4 cnr_lease_time;
/// stateid4 cnr_stateid;
/// netloc4 cnr_source_server<>;
/// };
///
/// union COPY_NOTIFY4res switch (nfsstat4 cnr_status) {
/// case NFS4_OK:
/// COPY_NOTIFY4resok resok4;
/// default:
/// void;
/// };
///
/// struct OFFLOAD_CANCEL4args {
/// /* CURRENT_FH: file to cancel */
/// stateid4 oca_stateid;
/// };
///
/// struct OFFLOAD_CANCEL4res {
/// nfsstat4 ocr_status;
/// };
///
///
/// struct OFFLOAD_STATUS4args {
/// /* CURRENT_FH: destination file */
/// stateid4 osa_stateid;
/// };
///
/// struct OFFLOAD_STATUS4resok {
/// length4 osr_count;
/// nfsstat4 osr_complete<1>;
/// };
///
/// union OFFLOAD_STATUS4res switch (nfsstat4 osr_status) {
/// case NFS4_OK:
/// OFFLOAD_STATUS4resok osr_resok4;
/// default:
/// void;
/// };
///
/// struct ALLOCATE4args {
/// /* CURRENT_FH: file */
/// stateid4 aa_stateid;
/// offset4 aa_offset;
/// length4 aa_length;
/// };
/// struct ALLOCATE4res {
/// nfsstat4 ar_status;
/// };
///
/// struct DEALLOCATE4args {
/// /* CURRENT_FH: file */
/// stateid4 da_stateid;
/// offset4 da_offset;
/// length4 da_length;
/// };
///
///
/// struct DEALLOCATE4res {
/// nfsstat4 dr_status;
/// };okay so this part is all XDR, and it's giving operation union energy 💅✨ every op gets its own little slot, and the new NFSv4.2 ones are lined up at the bottom 🦋
/// enum IO_ADVISE_type4 {
/// IO_ADVISE4_NORMAL = 0,
/// IO_ADVISE4_SEQUENTIAL = 1,
/// IO_ADVISE4_SEQUENTIAL_BACKWARDS = 2,
/// IO_ADVISE4_RANDOM = 3,
/// IO_ADVISE4_WILLNEED = 4,
/// IO_ADVISE4_WILLNEED_OPPORTUNISTIC = 5,
/// IO_ADVISE4_DONTNEED = 6,
/// IO_ADVISE4_NOREUSE = 7,
/// IO_ADVISE4_READ = 8,
/// IO_ADVISE4_WRITE = 9,
/// IO_ADVISE4_INIT_PROXIMITY = 10
/// };
///
/// struct IO_ADVISE4args {
/// /* CURRENT_FH: file */
/// stateid4 iaa_stateid;
/// offset4 iaa_offset;
/// length4 iaa_count;
/// bitmap4 iaa_hints;
/// };
///
/// struct IO_ADVISE4resok {
/// bitmap4 ior_hints;
/// };
///
/// union IO_ADVISE4res switch (nfsstat4 ior_status) {
/// case NFS4_OK:
/// IO_ADVISE4resok resok4;
/// default:
/// void;
/// };
///
///
/// struct device_error4 {
/// deviceid4 de_deviceid;
/// nfsstat4 de_status;
/// nfs_opnum4 de_opnum;
/// };
///
///
/// struct LAYOUTERROR4args {
/// /* CURRENT_FH: file */
/// offset4 lea_offset;
/// length4 lea_length;
/// stateid4 lea_stateid;
/// device_error4 lea_errors<>;
/// };
///
/// struct LAYOUTERROR4res {
/// nfsstat4 ler_status;
/// };
///
/// struct io_info4 {
/// uint64_t ii_count;
/// uint64_t ii_bytes;
/// };
///
/// struct LAYOUTSTATS4args {
/// /* CURRENT_FH: file */
/// offset4 lsa_offset;
/// length4 lsa_length;
/// stateid4 lsa_stateid;
/// io_info4 lsa_read;
/// io_info4 lsa_write;
/// deviceid4 lsa_deviceid;
/// layoutupdate4 lsa_layoutupdate;
/// };
///
/// struct LAYOUTSTATS4res {
/// nfsstat4 lsr_status;
/// };
///
/// struct READ_PLUS4args {
/// /* CURRENT_FH: file */
/// stateid4 rpa_stateid;
/// offset4 rpa_offset;
/// count4 rpa_count;
/// };
/// union read_plus_content switch (data_content4 rpc_content) {
/// case NFS4_CONTENT_DATA:
/// data4 rpc_data;
/// case NFS4_CONTENT_HOLE:
/// data_info4 rpc_hole;
/// default:
/// void;
/// };
///
/// /*
/// * Allow a return of an array of contents.
/// */
/// struct read_plus_res4 {
/// bool rpr_eof;
/// read_plus_content rpr_contents<>;
/// };
///
/// union READ_PLUS4res switch (nfsstat4 rp_status) {
/// case NFS4_OK:
/// read_plus_res4 rp_resok4;
/// default:
/// void;
/// };
///
/// struct SEEK4args {
/// /* CURRENT_FH: file */
/// stateid4 sa_stateid;
/// offset4 sa_offset;
/// data_content4 sa_what;
/// };
/// struct seek_res4 {
/// bool sr_eof;
/// offset4 sr_offset;
/// };
/// union SEEK4res switch (nfsstat4 sa_status) {
/// case NFS4_OK:
/// seek_res4 resok4;
/// default:
/// void;
/// };
///
/// struct WRITE_SAME4args {
/// /* CURRENT_FH: file */
/// stateid4 wsa_stateid;
/// stable_how4 wsa_stable;
/// app_data_block4 wsa_adb;
/// };
///
///
/// union WRITE_SAME4res switch (nfsstat4 wsr_status) {
/// case NFS4_OK:
/// write_response4 resok4;
/// default:
/// void;
/// };
///
///
/// /*
/// * Operation arrays (the rest)
/// */
///
/// union nfs_argop4 switch (nfs_opnum4 argop) {
/// case OP_ACCESS: ACCESS4args opaccess;
/// case OP_CLOSE: CLOSE4args opclose;
/// case OP_COMMIT: COMMIT4args opcommit;
/// case OP_CREATE: CREATE4args opcreate;
/// case OP_DELEGPURGE: DELEGPURGE4args opdelegpurge;
/// case OP_DELEGRETURN: DELEGRETURN4args opdelegreturn;
/// case OP_GETATTR: GETATTR4args opgetattr;
/// case OP_GETFH: void;
/// case OP_LINK: LINK4args oplink;
/// case OP_LOCK: LOCK4args oplock;
/// case OP_LOCKT: LOCKT4args oplockt;
/// case OP_LOCKU: LOCKU4args oplocku;
/// case OP_LOOKUP: LOOKUP4args oplookup;
/// case OP_LOOKUPP: void;
/// case OP_NVERIFY: NVERIFY4args opnverify;
/// case OP_OPEN: OPEN4args opopen;
/// case OP_OPENATTR: OPENATTR4args opopenattr;
///
/// /* Not for NFSv4.1 */
/// case OP_OPEN_CONFIRM: OPEN_CONFIRM4args opopen_confirm;
///
/// case OP_OPEN_DOWNGRADE: OPEN_DOWNGRADE4args opopen_downgrade;
///
/// case OP_PUTFH: PUTFH4args opputfh;
/// case OP_PUTPUBFH: void;
/// case OP_PUTROOTFH: void;
/// case OP_READ: READ4args opread;
/// case OP_READDIR: READDIR4args opreaddir;
/// case OP_READLINK: void;
/// case OP_REMOVE: REMOVE4args opremove;
/// case OP_RENAME: RENAME4args oprename;
///
/// /* Not for NFSv4.1 */
/// case OP_RENEW: RENEW4args oprenew;
///
/// case OP_RESTOREFH: void;
/// case OP_SAVEFH: void;
/// case OP_SECINFO: SECINFO4args opsecinfo;
/// case OP_SETATTR: SETATTR4args opsetattr;
///
/// /* Not for NFSv4.1 */
/// case OP_SETCLIENTID: SETCLIENTID4args opsetclientid;
///
/// /* Not for NFSv4.1 */
/// case OP_SETCLIENTID_CONFIRM:
/// SETCLIENTID_CONFIRM4args
/// opsetclientid_confirm;
///
/// case OP_VERIFY: VERIFY4args opverify;
/// case OP_WRITE: WRITE4args opwrite;
///
/// /* Not for NFSv4.1 */
/// case OP_RELEASE_LOCKOWNER:
/// RELEASE_LOCKOWNER4args
/// oprelease_lockowner;
///
/// /* Operations new to NFSv4.1 */
/// case OP_BACKCHANNEL_CTL:
/// BACKCHANNEL_CTL4args opbackchannel_ctl;
///
/// case OP_BIND_CONN_TO_SESSION:
/// BIND_CONN_TO_SESSION4args
/// opbind_conn_to_session;
///
/// case OP_EXCHANGE_ID: EXCHANGE_ID4args opexchange_id;
///
/// case OP_CREATE_SESSION: CREATE_SESSION4args opcreate_session;
///
/// case OP_DESTROY_SESSION:
/// DESTROY_SESSION4args opdestroy_session;
///
/// case OP_FREE_STATEID: FREE_STATEID4args opfree_stateid;
///
/// case OP_GET_DIR_DELEGATION:
/// GET_DIR_DELEGATION4args
/// opget_dir_delegation;
///
/// case OP_GETDEVICEINFO: GETDEVICEINFO4args opgetdeviceinfo;
/// case OP_GETDEVICELIST: GETDEVICELIST4args opgetdevicelist;
/// case OP_LAYOUTCOMMIT: LAYOUTCOMMIT4args oplayoutcommit;
/// case OP_LAYOUTGET: LAYOUTGET4args oplayoutget;
/// case OP_LAYOUTRETURN: LAYOUTRETURN4args oplayoutreturn;
///
/// case OP_SECINFO_NO_NAME:
/// SECINFO_NO_NAME4args opsecinfo_no_name;
///
/// case OP_SEQUENCE: SEQUENCE4args opsequence;
/// case OP_SET_SSV: SET_SSV4args opset_ssv;
/// case OP_TEST_STATEID: TEST_STATEID4args optest_stateid;
///
/// case OP_WANT_DELEGATION:
/// WANT_DELEGATION4args opwant_delegation;
///
/// case OP_DESTROY_CLIENTID:
/// DESTROY_CLIENTID4args
/// opdestroy_clientid;
///
/// case OP_RECLAIM_COMPLETE:
/// RECLAIM_COMPLETE4args
/// opreclaim_complete;
///
/// /* Operations new to NFSv4.2 */
/// case OP_ALLOCATE: ALLOCATE4args opallocate;
/// case OP_COPY: COPY4args opcopy;
/// case OP_COPY_NOTIFY: COPY_NOTIFY4args opoffload_notify;
/// case OP_DEALLOCATE: DEALLOCATE4args opdeallocate;
/// case OP_IO_ADVISE: IO_ADVISE4args opio_advise;
/// case OP_LAYOUTERROR: LAYOUTERROR4args oplayouterror;
/// case OP_LAYOUTSTATS: LAYOUTSTATS4args oplayoutstats;
/// case OP_OFFLOAD_CANCEL: OFFLOAD_CANCEL4args opoffload_cancel;
/// case OP_OFFLOAD_STATUS: OFFLOAD_STATUS4args opoffload_status;
/// case OP_READ_PLUS: READ_PLUS4args opread_plus;
/// case OP_SEEK: SEEK4args opseek;
/// case OP_WRITE_SAME: WRITE_SAME4args opwrite_same;
/// case OP_CLONE: CLONE4args opclone;
///
/// /* Operations not new to NFSv4.1 */
/// case OP_ILLEGAL: void;
/// };
///
/// union nfs_resop4 switch (nfs_opnum4 resop) {
/// case OP_ACCESS: ACCESS4res opaccess;
/// case OP_CLOSE: CLOSE4res opclose;
/// case OP_COMMIT: COMMIT4res opcommit;
/// case OP_CREATE: CREATE4res opcreate;
/// case OP_DELEGPURGE: DELEGPURGE4res opdelegpurge;
/// case OP_DELEGRETURN: DELEGRETURN4res opdelegreturn;
/// case OP_GETATTR: GETATTR4res opgetattr;
/// case OP_GETFH: GETFH4res opgetfh;
/// case OP_LINK: LINK4res oplink;
/// case OP_LOCK: LOCK4res oplock;
/// case OP_LOCKT: LOCKT4res oplockt;
/// case OP_LOCKU: LOCKU4res oplocku;
/// case OP_LOOKUP: LOOKUP4res oplookup;
/// case OP_LOOKUPP: LOOKUPP4res oplookupp;
/// case OP_NVERIFY: NVERIFY4res opnverify;
/// case OP_OPEN: OPEN4res opopen;
/// case OP_OPENATTR: OPENATTR4res opopenattr;
/// /* Not for NFSv4.1 */
/// case OP_OPEN_CONFIRM: OPEN_CONFIRM4res opopen_confirm;
///
/// case OP_OPEN_DOWNGRADE: OPEN_DOWNGRADE4res opopen_downgrade;
///
/// case OP_PUTFH: PUTFH4res opputfh;
/// case OP_PUTPUBFH: PUTPUBFH4res opputpubfh;
/// case OP_PUTROOTFH: PUTROOTFH4res opputrootfh;
/// case OP_READ: READ4res opread;
/// case OP_READDIR: READDIR4res opreaddir;
/// case OP_READLINK: READLINK4res opreadlink;
/// case OP_REMOVE: REMOVE4res opremove;
/// case OP_RENAME: RENAME4res oprename;
/// /* Not for NFSv4.1 */
/// case OP_RENEW: RENEW4res oprenew;
/// case OP_RESTOREFH: RESTOREFH4res oprestorefh;
/// case OP_SAVEFH: SAVEFH4res opsavefh;
/// case OP_SECINFO: SECINFO4res opsecinfo;
/// case OP_SETATTR: SETATTR4res opsetattr;
/// /* Not for NFSv4.1 */
/// case OP_SETCLIENTID: SETCLIENTID4res opsetclientid;
///
/// /* Not for NFSv4.1 */
/// case OP_SETCLIENTID_CONFIRM:
/// SETCLIENTID_CONFIRM4res
/// opsetclientid_confirm;
/// case OP_VERIFY: VERIFY4res opverify;
/// case OP_WRITE: WRITE4res opwrite;
///
/// /* Not for NFSv4.1 */
/// case OP_RELEASE_LOCKOWNER:
/// RELEASE_LOCKOWNER4res
/// oprelease_lockowner;
///Okay bestie, we're picking up right where the NFSv4.2 operation list left off 💅✨
/// /* Operations new to NFSv4.1 */
/// case OP_BACKCHANNEL_CTL:
/// BACKCHANNEL_CTL4res opbackchannel_ctl;
///
/// case OP_BIND_CONN_TO_SESSION:
/// BIND_CONN_TO_SESSION4res
/// opbind_conn_to_session;
///
/// case OP_EXCHANGE_ID: EXCHANGE_ID4res opexchange_id;
///
/// case OP_CREATE_SESSION: CREATE_SESSION4res opcreate_session;
///
/// case OP_DESTROY_SESSION:
/// DESTROY_SESSION4res opdestroy_session;
///
/// case OP_FREE_STATEID: FREE_STATEID4res opfree_stateid;
///
/// case OP_GET_DIR_DELEGATION:
/// GET_DIR_DELEGATION4res
/// opget_dir_delegation;
///
/// case OP_GETDEVICEINFO: GETDEVICEINFO4res opgetdeviceinfo;
/// case OP_GETDEVICELIST: GETDEVICELIST4res opgetdevicelist;
/// case OP_LAYOUTCOMMIT: LAYOUTCOMMIT4res oplayoutcommit;
/// case OP_LAYOUTGET: LAYOUTGET4res oplayoutget;
/// case OP_LAYOUTRETURN: LAYOUTRETURN4res oplayoutreturn;
///
/// case OP_SECINFO_NO_NAME:
/// SECINFO_NO_NAME4res opsecinfo_no_name;
///
/// case OP_SEQUENCE: SEQUENCE4res opsequence;
/// case OP_SET_SSV: SET_SSV4res opset_ssv;
/// case OP_TEST_STATEID: TEST_STATEID4res optest_stateid;
///
/// case OP_WANT_DELEGATION:
/// WANT_DELEGATION4res opwant_delegation;
///
/// case OP_DESTROY_CLIENTID:
/// DESTROY_CLIENTID4res
/// opdestroy_clientid;
///
/// case OP_RECLAIM_COMPLETE:
/// RECLAIM_COMPLETE4res
/// opreclaim_complete;
///
/// /* Operations new to NFSv4.2 */
/// case OP_ALLOCATE: ALLOCATE4res opallocate;
/// case OP_COPY: COPY4res opcopy;
/// case OP_COPY_NOTIFY: COPY_NOTIFY4res opcopy_notify;
/// case OP_DEALLOCATE: DEALLOCATE4res opdeallocate;
/// case OP_IO_ADVISE: IO_ADVISE4res opio_advise;
/// case OP_LAYOUTERROR: LAYOUTERROR4res oplayouterror;
/// case OP_LAYOUTSTATS: LAYOUTSTATS4res oplayoutstats;
/// case OP_OFFLOAD_CANCEL: OFFLOAD_CANCEL4res opoffload_cancel;
/// case OP_OFFLOAD_STATUS: OFFLOAD_STATUS4res opoffload_status;
/// case OP_READ_PLUS: READ_PLUS4res opread_plus;
/// case OP_SEEK: SEEK4res opseek;
/// case OP_WRITE_SAME: WRITE_SAME4res opwrite_same;
/// case OP_CLONE: CLONE4res opclone;
///
/// /* Operations not new to NFSv4.1 */
/// case OP_ILLEGAL: ILLEGAL4res opillegal;
/// };
///
/// struct COMPOUND4args {
/// utf8str_cs tag;
/// uint32_t minorversion;
/// nfs_argop4 argarray<>;
/// };
///
/// struct COMPOUND4res {
/// nfsstat4 status;
/// utf8str_cs tag;
/// nfs_resop4 resarray<>;
/// };
///
///
/// /*
/// * Remote file service routines
/// */
/// program NFS4_PROGRAM {
/// version NFS_V4 {
/// void
/// NFSPROC4_NULL(void) = 0;
///
/// COMPOUND4res
/// NFSPROC4_COMPOUND(COMPOUND4args) = 1;
///
/// } = 4;
/// } = 100003;
///
/// /*
/// * NFS4 callback procedure definitions and program
/// */
/// struct CB_GETATTR4args {
/// nfs_fh4 fh;
/// bitmap4 attr_request;
/// };
///
/// struct CB_GETATTR4resok {
/// fattr4 obj_attributes;
/// };
///
/// union CB_GETATTR4res switch (nfsstat4 status) {
/// case NFS4_OK:
/// CB_GETATTR4resok resok4;
/// default:
/// void;
/// };
///
/// struct CB_RECALL4args {
/// stateid4 stateid;
/// bool truncate;
/// nfs_fh4 fh;
/// };
///
/// struct CB_RECALL4res {
/// nfsstat4 status;
/// };
///
/// /*
/// * CB_ILLEGAL: Response for illegal operation numbers
/// */
/// struct CB_ILLEGAL4res {
/// nfsstat4 status;
/// };
///
/// /*
/// * NFSv4.1 callback arguments and results
/// */
///
/// enum layoutrecall_type4 {
/// LAYOUTRECALL4_FILE = LAYOUT4_RET_REC_FILE,
/// LAYOUTRECALL4_FSID = LAYOUT4_RET_REC_FSID,
/// LAYOUTRECALL4_ALL = LAYOUT4_RET_REC_ALL
/// };
///
/// struct layoutrecall_file4 {
/// nfs_fh4 lor_fh;
/// offset4 lor_offset;
/// length4 lor_length;
/// stateid4 lor_stateid;
/// };
///
/// union layoutrecall4 switch (layoutrecall_type4 lor_recalltype) {
/// case LAYOUTRECALL4_FILE:
/// layoutrecall_file4 lor_layout;
/// case LAYOUTRECALL4_FSID:
/// fsid4 lor_fsid;
/// case LAYOUTRECALL4_ALL:
/// void;
/// };
///
/// struct CB_LAYOUTRECALL4args {
/// layouttype4 clora_type;
/// layoutiomode4 clora_iomode;
/// bool clora_changed;
/// layoutrecall4 clora_recall;
/// };
/// struct CB_LAYOUTRECALL4res {
/// nfsstat4 clorr_status;
/// };
///
/// /*
/// * Directory notification types
/// */
/// enum notify_type4 {
/// NOTIFY4_CHANGE_CHILD_ATTRS = 0,
/// NOTIFY4_CHANGE_DIR_ATTRS = 1,
/// NOTIFY4_REMOVE_ENTRY = 2,
/// NOTIFY4_ADD_ENTRY = 3,
/// NOTIFY4_RENAME_ENTRY = 4,
/// NOTIFY4_CHANGE_COOKIE_VERIFIER = 5
/// };
///
/// /* Changed entry information */
/// struct notify_entry4 {
/// component4 ne_file;
/// fattr4 ne_attrs;
/// };
///
/// /* Previous entry information */
/// struct prev_entry4 {
/// notify_entry4 pe_prev_entry;
/// /* What READDIR returned for this entry */
/// nfs_cookie4 pe_prev_entry_cookie;
/// };
///
/// struct notify_remove4 {
/// notify_entry4 nrm_old_entry;
/// nfs_cookie4 nrm_old_entry_cookie;
/// };
///
/// struct notify_add4 {
/// /*
/// * During a rename, contains
/// * the object that was deleted.
/// */
/// notify_remove4 nad_old_entry<1>;
/// notify_entry4 nad_new_entry;
/// /* What READDIR would have returned for this entry */
/// nfs_cookie4 nad_new_entry_cookie<1>;
/// prev_entry4 nad_prev_entry<1>;
/// bool nad_last_entry;
/// };
///
/// struct notify_attr4 {
/// notify_entry4 na_changed_entry;
/// };
///
/// struct notify_rename4 {
/// notify_remove4 nrn_old_entry;
/// notify_add4 nrn_new_entry;
/// };
///
/// struct notify_verifier4 {
/// verifier4 nv_old_cookieverf;
/// verifier4 nv_new_cookieverf;
/// };
///
/// /*
/// * Objects of type notify_<>4 and
/// * notify_device_<>4 are encoded in this.
/// */
/// typedef opaque notifylist4<>;
///
/// struct notify4 {
/// /* Composed from notify_type4 or notify_deviceid_type4 */
/// bitmap4 notify_mask;
/// notifylist4 notify_vals;
/// };
///
/// struct CB_NOTIFY4args {
/// stateid4 cna_stateid;
/// nfs_fh4 cna_fh;
/// notify4 cna_changes<>;
/// };
///
/// struct CB_NOTIFY4res {
/// nfsstat4 cnr_status;
/// };
///
/// struct CB_PUSH_DELEG4args {
/// nfs_fh4 cpda_fh;
/// open_delegation4 cpda_delegation;
///
/// };
///
/// struct CB_PUSH_DELEG4res {
/// nfsstat4 cpdr_status;
/// };
///
/// const RCA4_TYPE_MASK_RDATA_DLG = 0;
/// const RCA4_TYPE_MASK_WDATA_DLG = 1;
/// const RCA4_TYPE_MASK_DIR_DLG = 2;
/// const RCA4_TYPE_MASK_FILE_LAYOUT = 3;
/// const RCA4_TYPE_MASK_BLK_LAYOUT = 4;
/// const RCA4_TYPE_MASK_OBJ_LAYOUT_MIN = 8;
/// const RCA4_TYPE_MASK_OBJ_LAYOUT_MAX = 9;
/// const RCA4_TYPE_MASK_OTHER_LAYOUT_MIN = 12;
/// const RCA4_TYPE_MASK_OTHER_LAYOUT_MAX = 15;
///
/// struct CB_RECALL_ANY4args {
/// uint32_t craa_objects_to_keep;
/// bitmap4 craa_type_mask;
/// };
///
/// struct CB_RECALL_ANY4res {
/// nfsstat4 crar_status;
/// };
///
/// typedef CB_RECALL_ANY4args CB_RECALLABLE_OBJ_AVAIL4args;
///
/// struct CB_RECALLABLE_OBJ_AVAIL4res {
/// nfsstat4 croa_status;
/// };
///
/// struct CB_RECALL_SLOT4args {
/// slotid4 rsa_target_highest_slotid;
/// };
///
/// struct CB_RECALL_SLOT4res {
/// nfsstat4 rsr_status;
/// };
///
/// struct referring_call4 {
/// sequenceid4 rc_sequenceid;
/// slotid4 rc_slotid;
/// };
///
/// struct referring_call_list4 {
/// sessionid4 rcl_sessionid;
/// referring_call4 rcl_referring_calls<>;
/// };
///
/// struct CB_SEQUENCE4args {
/// sessionid4 csa_sessionid;
/// sequenceid4 csa_sequenceid;
/// slotid4 csa_slotid;
/// slotid4 csa_highest_slotid;
/// bool csa_cachethis;
/// referring_call_list4 csa_referring_call_lists<>;
/// };
///
/// struct CB_SEQUENCE4resok {
/// sessionid4 csr_sessionid;
/// sequenceid4 csr_sequenceid;
/// slotid4 csr_slotid;
/// slotid4 csr_highest_slotid;
/// slotid4 csr_target_highest_slotid;
/// };
///
/// union CB_SEQUENCE4res switch (nfsstat4 csr_status) {
/// case NFS4_OK:
/// CB_SEQUENCE4resok csr_resok4;
/// default:
/// void;
/// };
///
/// struct CB_WANTS_CANCELLED4args {
/// bool cwca_contended_wants_cancelled;
/// bool cwca_resourced_wants_cancelled;
/// };
///
/// struct CB_WANTS_CANCELLED4res {
/// nfsstat4 cwcr_status;
/// };
///
/// struct CB_NOTIFY_LOCK4args {
/// nfs_fh4 cnla_fh;
/// lock_owner4 cnla_lock_owner;
/// };
///
/// struct CB_NOTIFY_LOCK4res {
/// nfsstat4 cnlr_status;
/// };
///
/// /*
/// * Device notification types
/// */
/// enum notify_deviceid_type4 {
/// NOTIFY_DEVICEID4_CHANGE = 1,
/// NOTIFY_DEVICEID4_DELETE = 2
/// };
///
/// /* For NOTIFY4_DEVICEID4_DELETE */
/// struct notify_deviceid_delete4 {
/// layouttype4 ndd_layouttype;
/// deviceid4 ndd_deviceid;
/// };
///
/// /* For NOTIFY4_DEVICEID4_CHANGE */
/// struct notify_deviceid_change4 {
/// layouttype4 ndc_layouttype;
/// deviceid4 ndc_deviceid;
/// bool ndc_immediate;
/// };
///
/// struct CB_NOTIFY_DEVICEID4args {
/// notify4 cnda_changes<>;
/// };
///
/// struct CB_NOTIFY_DEVICEID4res {
/// nfsstat4 cndr_status;
/// };
///
/// union offload_info4 switch (nfsstat4 coa_status) {
/// case NFS4_OK:
/// write_response4 coa_resok4;
/// default:More XDR coming up next, so hold onto your hats 🎀🦋
/// length4 coa_bytes_copied;
/// };
/// struct CB_OFFLOAD4args {
/// nfs_fh4 coa_fh;
/// stateid4 coa_stateid;
/// offload_info4 coa_offload_info;
/// };
/// struct CB_OFFLOAD4res {
/// nfsstat4 cor_status;
/// };
/// /*
/// * Various definitions for CB_COMPOUND
/// */
/// %
/// enum nfs_cb_opnum4 {
/// OP_CB_GETATTR = 3,
/// OP_CB_RECALL = 4,
/// %/* Callback operations new to NFSv4.1 */
/// OP_CB_LAYOUTRECALL = 5,
/// OP_CB_NOTIFY = 6,
/// OP_CB_PUSH_DELEG = 7,
/// OP_CB_RECALL_ANY = 8,
/// OP_CB_RECALLABLE_OBJ_AVAIL = 9,
/// OP_CB_RECALL_SLOT = 10,
/// OP_CB_SEQUENCE = 11,
/// OP_CB_WANTS_CANCELLED = 12,
/// OP_CB_NOTIFY_LOCK = 13,
/// OP_CB_NOTIFY_DEVICEID = 14,
/// %/* Callback operations new to NFSv4.2 */
/// OP_CB_OFFLOAD = 15,
///
/// OP_CB_ILLEGAL = 10044
/// };
///
/// union nfs_cb_argop4 switch (nfs_cb_opnum4 argop) {
/// case OP_CB_GETATTR:
/// CB_GETATTR4args opcbgetattr;
///
/// /* New NFSv4.1 operations */
/// case OP_CB_RECALL:
/// CB_RECALL4args opcbrecall;
/// case OP_CB_LAYOUTRECALL:
/// CB_LAYOUTRECALL4args opcblayoutrecall;
/// case OP_CB_NOTIFY:
/// CB_NOTIFY4args opcbnotify;
/// case OP_CB_PUSH_DELEG:
/// CB_PUSH_DELEG4args opcbpush_deleg;
/// case OP_CB_RECALL_ANY:
/// CB_RECALL_ANY4args opcbrecall_any;
/// case OP_CB_RECALLABLE_OBJ_AVAIL:
/// CB_RECALLABLE_OBJ_AVAIL4args opcbrecallable_obj_avail;
/// case OP_CB_RECALL_SLOT:
/// CB_RECALL_SLOT4args opcbrecall_slot;
/// case OP_CB_SEQUENCE:
/// CB_SEQUENCE4args opcbsequence;
/// case OP_CB_WANTS_CANCELLED:
/// CB_WANTS_CANCELLED4args opcbwants_cancelled;
/// case OP_CB_NOTIFY_LOCK:
/// CB_NOTIFY_LOCK4args opcbnotify_lock;
/// case OP_CB_NOTIFY_DEVICEID:
/// CB_NOTIFY_DEVICEID4args opcbnotify_deviceid;
///
/// /* New NFSv4.2 operations */
/// case OP_CB_OFFLOAD:
/// CB_OFFLOAD4args opcboffload;
///
/// case OP_CB_ILLEGAL: void;
/// };
///
/// union nfs_cb_resop4 switch (nfs_cb_opnum4 resop) {
/// case OP_CB_GETATTR: CB_GETATTR4res opcbgetattr;
/// case OP_CB_RECALL: CB_RECALL4res opcbrecall;
///
/// /* New NFSv4.1 operations */
/// case OP_CB_LAYOUTRECALL:
/// CB_LAYOUTRECALL4res
/// opcblayoutrecall;
///
/// case OP_CB_NOTIFY: CB_NOTIFY4res opcbnotify;
///
/// case OP_CB_PUSH_DELEG: CB_PUSH_DELEG4res
/// opcbpush_deleg;
///
/// case OP_CB_RECALL_ANY: CB_RECALL_ANY4res
/// opcbrecall_any;
///
/// case OP_CB_RECALLABLE_OBJ_AVAIL:
/// CB_RECALLABLE_OBJ_AVAIL4res
/// opcbrecallable_obj_avail;
///
/// case OP_CB_RECALL_SLOT:
/// CB_RECALL_SLOT4res
/// opcbrecall_slot;
///
/// case OP_CB_SEQUENCE: CB_SEQUENCE4res opcbsequence;
///
/// case OP_CB_WANTS_CANCELLED:
/// CB_WANTS_CANCELLED4res
/// opcbwants_cancelled;
///
/// case OP_CB_NOTIFY_LOCK:
/// CB_NOTIFY_LOCK4res
/// opcbnotify_lock;
///
/// case OP_CB_NOTIFY_DEVICEID:
/// CB_NOTIFY_DEVICEID4res
/// opcbnotify_deviceid;
///
/// /* New NFSv4.2 operations */
/// case OP_CB_OFFLOAD: CB_OFFLOAD4res opcboffload;
///
/// /* Not new operation */
/// case OP_CB_ILLEGAL: CB_ILLEGAL4res opcbillegal;
/// };
///
///
/// struct CB_COMPOUND4args {
/// utf8str_cs tag;
/// uint32_t minorversion;
/// uint32_t callback_ident;
/// nfs_cb_argop4 argarray<>;
/// };
///
/// struct CB_COMPOUND4res {
/// nfsstat4 status;
/// utf8str_cs tag;
/// nfs_cb_resop4 resarray<>;
/// };
///
///
///
/// /*
/// * Program number is in the transient range, since the client
/// * will assign the exact transient program number and provide
/// * that to the server via the CREATE_SESSION or
/// * BACKCHANNEL_CTL operations.
/// */
/// program NFS4_CALLBACK {
/// version NFS_CB {
/// void
/// CB_NULL(void) = 0;
/// CB_COMPOUND4res
/// CB_COMPOUND(CB_COMPOUND4args) = 1;
/// } = 1;
/// } = 0x40000000;
<CODE ENDS>3. Security Considerations 🔐
bestie, this part is seriously important 😭 the whole security story lives in the Security Considerations section of [RFC7862], so go read that one. it's the real deal, not vibes 💀
4. IANA Considerations 📋
okay so the IANA stuff? same energy, it's all in the IANA Considerations section of [RFC7862] 🌸
5. Normative References 📚
these are the receipts, bestie 🧾 every single one is listed below with all the details ✨
- [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, March 1997, <http://www.rfc-editor.org/info/rfc2119>.
- [RFC4506] Eisler, M., Ed., "XDR: External Data Representation Standard", STD 67, RFC 4506, DOI 10.17487/RFC4506, May 2006, <http://www.rfc-editor.org/info/rfc4506>.
- [RFC5662] Shepler, S., Ed., Eisler, M., Ed., and D. Noveck, Ed., "Network File System (NFS) Version 4 Minor Version 1 External Data Representation Standard (XDR) Description", RFC 5662, DOI 10.17487/RFC5662, January 2010, <http://www.rfc-editor.org/info/rfc5662>.
- [RFC7531] Haynes, T., Ed., and D. Noveck, Ed., "Network File System (NFS) Version 4 External Data Representation Standard (XDR) Description", RFC 7531, DOI 10.17487/RFC7531, March 2015, <http://www.rfc-editor.org/info/rfc7531>.
- [RFC7862] Haynes, T., "Network File System (NFS) Version 4 Minor Version 2 Protocol", RFC 7862, DOI 10.17487/RFC7862, November 2016, <http://www.rfc-editor.org/info/rfc7862>.
Acknowledgments 🫶
Tom Haynes would like to thank NetApp, Inc. for its funding of his time on this project. so supportive, we love that for him 💖
Author's Address 🎀
Thomas Haynes
Primary Data, Inc.
4300 El Camino Real Ste 100
Los Altos, CA 94022
United States of America
Phone: +1 408 215 1519
Email: thomas.haynes@primarydata.com📦 where this page comes from
- ietf: rfc7863 2016-11
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms