draft-ietf-nfsv4-minorversion2-dot-x-41.txt   rfc7863.txt 
NFSv4 T. Haynes Internet Engineering Task Force (IETF) T. Haynes
Internet-Draft Primary Data Request for Comments: 7863 Primary Data
Intended status: Standards Track January 28, 2016 Category: Standards Track November 2016
Expires: July 31, 2016 ISSN: 2070-1721
NFSv4 Minor Version 2 Protocol External Data Representation Standard Network File System (NFS) Version 4 Minor Version 2
(XDR) Description External Data Representation Standard (XDR) Description
draft-ietf-nfsv4-minorversion2-dot-x-41.txt
Abstract Abstract
This Internet-Draft provides the XDR description for NFSv4 minor This document provides the External Data Representation (XDR)
version two. description for NFS version 4 minor version 2.
Requirements Language
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
document are to be interpreted as described in RFC 2119 [RFC2119].
Status of This Memo Status of This Memo
This Internet-Draft is submitted in full conformance with the This is an Internet Standards Track document.
provisions of BCP 78 and BCP 79.
Internet-Drafts are working documents of the Internet Engineering
Task Force (IETF). Note that other groups may also distribute
working documents as Internet-Drafts. The list of current Internet-
Drafts is at http://datatracker.ietf.org/drafts/current/.
Internet-Drafts are draft documents valid for a maximum of six months This document is a product of the Internet Engineering Task Force
and may be updated, replaced, or obsoleted by other documents at any (IETF). It represents the consensus of the IETF community. It has
time. It is inappropriate to use Internet-Drafts as reference received public review and has been approved for publication by the
material or to cite them other than as "work in progress." Internet Engineering Steering Group (IESG). Further information on
Internet Standards is available in Section 2 of RFC 7841.
This Internet-Draft will expire on July 31, 2016. Information about the current status of this document, any errata,
and how to provide feedback on it may be obtained at
http://www.rfc-editor.org/info/rfc7863.
Copyright Notice Copyright Notice
Copyright (c) 2016 IETF Trust and the persons identified as the Copyright (c) 2016 IETF Trust and the persons identified as the
document authors. All rights reserved. document authors. All rights reserved.
This document is subject to BCP 78 and the IETF Trust's Legal This document is subject to BCP 78 and the IETF Trust's Legal
Provisions Relating to IETF Documents Provisions Relating to IETF Documents
(http://trustee.ietf.org/license-info) in effect on the date of (http://trustee.ietf.org/license-info) in effect on the date of
publication of this document. Please review these documents publication of this document. Please review these documents
carefully, as they describe your rights and restrictions with respect carefully, as they describe your rights and restrictions with respect
to this document. Code Components extracted from this document must to this document. Code Components extracted from this document must
include Simplified BSD License text as described in Section 4.e of include Simplified BSD License text as described in Section 4.e of
the Trust Legal Provisions and are provided without warranty as the Trust Legal Provisions and are provided without warranty as
described in the Simplified BSD License. described in the Simplified BSD License.
Table of Contents Table of Contents
1. XDR Description of NFSv4.2 . . . . . . . . . . . . . . . . . 2 1. Introduction ....................................................2
2. Security Considerations . . . . . . . . . . . . . . . . . . . 81 1.1. Requirements Language ......................................2
3. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 81 2. XDR Description of NFSv4.2 ......................................2
4. Normative References . . . . . . . . . . . . . . . . . . . . 81 3. Security Considerations ........................................86
Appendix A. Acknowledgments . . . . . . . . . . . . . . . . . . 81 4. IANA Considerations ............................................86
Appendix B. RFC Editor Notes . . . . . . . . . . . . . . . . . . 81 5. Normative References ...........................................86
Author's Address . . . . . . . . . . . . . . . . . . . . . . . . 82 Acknowledgments ...................................................87
Author's Address ..................................................87
1. XDR Description of NFSv4.2 1. Introduction
This document contains the XDR ([RFC4506]) description of NFSv4.2 This document contains the External Data Representation (XDR)
protocol ([I-D.ietf-nfsv4-minorversion2]). In order to facilitate [RFC4506] description of the NFSv4.2 protocol [RFC7862].
implementations that support all of NFSv4.0, NFSv4.1, and NFSv4.2,
the description includes operations, and other features of NFSv4.0
and NFSv4.1 that do not apply to NFSv4.2. This XDR specification is
fully compatible with that for NFSv4.0 ([RFC7531]) with the exception
of the clientaddr4 structure which has been replaced by (strictly,
aliased to) netaddr4 which has the same members with the same
purposes but the names have changed
(r_netid -> na_r_netid, r_addr ->na_r_addr). 1.1. Requirements Language
This effectively fully reconverges the NFSv4.0 ([RFC7531]) and The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
NFSv4.1 ([RFC5662]) strands of the XDR. "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
document are to be interpreted as described in RFC 2119 [RFC2119].
2. XDR Description of NFSv4.2
In order to facilitate implementations that support all of NFSv4.0,
NFSv4.1, and NFSv4.2, the description includes operations and other
features of NFSv4.0 and NFSv4.1 that do not apply to NFSv4.2. This
XDR specification is fully compatible with the specification for
NFSv4.0 [RFC7531], with the exception of the clientaddr4 structure,
which has been replaced by (strictly, aliased to) netaddr4, which has
the same members with the same purposes but the names have changed:
(r_netid -> na_r_netid, r_addr -> na_r_addr)
This effectively fully reconverges the NFSv4.0 [RFC7531] and NFSv4.1
[RFC5662] strands of the XDR.
The XDR description is provided in this document in a way that makes The XDR description is provided in this document in a way that makes
it simple for the reader to extract into ready to compile form. The it simple for the reader to extract it into a form that is ready to
reader can feed this document in the following shell script to compile. The reader can feed this document in the following shell
produce the machine readable XDR description of NFSv4.2: script to produce the machine-readable XDR description of NFSv4.2:
<CODE BEGINS> <CODE BEGINS>
#!/bin/sh #!/bin/sh
grep "^ *///" | sed 's?^ */// ??' | sed 's?^ *///$??' grep "^ *///" | sed 's?^ */// ??' | sed 's?^ *///$??'
<CODE ENDS> <CODE ENDS>
That is, if the above script is stored in a file called "extract.sh"
I.e., if the above script is stored in a file called "extract.sh", and this document is in a file called "spec.txt", then the reader
and this document is in a file called "spec.txt", then the reader can can do:
do:
<CODE BEGINS> <CODE BEGINS>
sh extract.sh < spec.txt > nfs4_prot.x sh extract.sh < spec.txt > nfs4_prot.x
<CODE ENDS> <CODE ENDS>
The effect of the script is to remove leading white space from each The effect of the script is to remove leading white space from each
line, plus a sentinel sequence of "///". line, plus a sentinel sequence of "///".
The XDR description, with the sentinel sequence follows: The XDR description, with the sentinel sequence, follows:
<CODE BEGINS> <CODE BEGINS>
/// /* /// /*
/// * This file was machine generated for [draft-ietf-nfsv4-minorversion2-41]. /// * This file was machine generated for [RFC7862].
/// * /// *
/// * Last updated Thu Jan 28 13:40:52 PST 2016 /// * Last updated Sun Mar 13 10:58:40 PDT 2016
/// */ /// */
/// ///
/// /* /// /*
/// * Copyright (c) 2015 IETF Trust and the persons identified /// * Copyright (c) 2016 IETF Trust and the persons identified
/// * as the document authors. All rights reserved. /// * as the authors. All rights reserved.
/// * /// *
/// * The Redistribution and use in source and binary forms, with /// * Redistribution and use in source and binary forms, with
/// * or without modification, are permitted provided that the /// * or without modification, are permitted provided that the
/// * following conditions are met: /// * following conditions are met:
/// * /// *
/// * - Redistributions of source code must retain the above /// * - Redistributions of source code must retain the above
/// * copyright notice, this list of conditions and the /// * copyright notice, this list of conditions and the
/// * following disclaimer. /// * following disclaimer.
/// * /// *
/// * - Redistributions in binary form must reproduce the above /// * - Redistributions in binary form must reproduce the above
/// * copyright notice, this list of conditions and the /// * copyright notice, this list of conditions and the
/// * following disclaimer in the documentation and/or other /// * following disclaimer in the documentation and/or other
skipping to change at page 4, line 16 skipping to change at page 4, line 23
/// * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS /// * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
/// * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF /// * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
/// * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, /// * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
/// * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING /// * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
/// * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF /// * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
/// * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /// * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/// ///
/// */ /// */
/// ///
/// /* /// /*
/// * This code was derived from [draft-ietf-nfsv4-minorversion2-dot-x-41]. /// * This code was derived from RFC 7863.
/// */
///
/// /*
/// * Copyright (C) The IETF Trust (2007-2014)
/// * All Rights Reserved.
/// *
/// * Copyright (C) The Internet Society (1998-2006).
/// * All Rights Reserved.
/// */ /// */
/// ///
/// /* /// /*
/// * nfsv42.x /// * nfsv42.x
/// */ /// */
/// ///
/// %#ifndef _AUTH_SYS_DEFINE_FOR_NFSv42 /// %#ifndef _AUTH_SYS_DEFINE_FOR_NFSv42
/// %#define _AUTH_SYS_DEFINE_FOR_NFSv42 /// %#define _AUTH_SYS_DEFINE_FOR_NFSv42
/// %#include <rpc/auth_sys.h> /// %#include <rpc/auth_sys.h>
/// %typedef struct authsys_parms authsys_parms; /// %typedef struct authsys_parms authsys_parms;
skipping to change at page 5, line 22 skipping to change at page 5, line 26
/// const NFS4_UINT32_MAX = 0xffffffff; /// const NFS4_UINT32_MAX = 0xffffffff;
/// ///
/// const NFS4_MAXFILELEN = 0xffffffffffffffff; /// const NFS4_MAXFILELEN = 0xffffffffffffffff;
/// const NFS4_MAXFILEOFF = 0xfffffffffffffffe; /// const NFS4_MAXFILEOFF = 0xfffffffffffffffe;
/// ///
/// ///
/// /* /// /*
/// * File types /// * File types
/// */ /// */
/// enum nfs_ftype4 { /// enum nfs_ftype4 {
/// NF4REG = 1, /* Regular File */ /// NF4REG = 1, /* Regular File */
/// NF4DIR = 2, /* Directory */ /// NF4DIR = 2, /* Directory */
/// NF4BLK = 3, /* Special File - block device */ /// NF4BLK = 3, /* Special File -- block device */
/// NF4CHR = 4, /* Special File - character device */ /// NF4CHR = 4, /* Special File -- character device */
/// NF4LNK = 5, /* Symbolic Link */ /// NF4LNK = 5, /* Symbolic Link */
/// NF4SOCK = 6, /* Special File - socket */ /// NF4SOCK = 6, /* Special File -- socket */
/// NF4FIFO = 7, /* Special File - fifo */ /// NF4FIFO = 7, /* Special File -- fifo */
/// NF4ATTRDIR /// NF4ATTRDIR = 8, /* Attribute Directory */
/// = 8, /* Attribute Directory */ /// NF4NAMEDATTR = 9 /* Named Attribute */
/// NF4NAMEDATTR
/// = 9 /* Named Attribute */
/// }; /// };
/// ///
/// /* /// /*
/// * Error status /// * Error status
/// */ /// */
/// enum nfsstat4 { /// enum nfsstat4 {
/// NFS4_OK = 0, /* everything is okay */ /// NFS4_OK = 0, /* everything is okay */
/// NFS4ERR_PERM = 1, /* caller not privileged */ /// NFS4ERR_PERM = 1, /* caller not privileged */
/// NFS4ERR_NOENT = 2, /* no such file/directory */ /// NFS4ERR_NOENT = 2, /* no such file/directory */
/// NFS4ERR_IO = 5, /* hard I/O error */ /// NFS4ERR_IO = 5, /* hard I/O error */
/// NFS4ERR_NXIO = 6, /* no such device */ /// NFS4ERR_NXIO = 6, /* no such device */
/// NFS4ERR_ACCESS = 13, /* access denied */ /// NFS4ERR_ACCESS = 13, /* access denied */
/// NFS4ERR_EXIST = 17, /* file already exists */ /// NFS4ERR_EXIST = 17, /* file already exists */
/// NFS4ERR_XDEV = 18, /* different filesystems */ /// NFS4ERR_XDEV = 18, /* different file systems */
/// ///
/// /* /// /*
/// * Please do not allocate value 19; it was used in NFSv3 /// * Please do not allocate value 19; it was used in NFSv3,
/// * and we do not want a value in NFSv3 to have a different /// * and we do not want a value in NFSv3 to have a different
/// * meaning in NFSv4.x. /// * meaning in NFSv4.x.
/// */ /// */
/// ///
/// NFS4ERR_NOTDIR = 20, /* should be a directory */ /// NFS4ERR_NOTDIR = 20, /* should be a directory */
/// NFS4ERR_ISDIR = 21, /* should not be directory */ /// NFS4ERR_ISDIR = 21, /* should not be a directory */
/// NFS4ERR_INVAL = 22, /* invalid argument */ /// NFS4ERR_INVAL = 22, /* invalid argument */
/// NFS4ERR_FBIG = 27, /* file exceeds server max */ /// NFS4ERR_FBIG = 27, /* file exceeds server max */
/// NFS4ERR_NOSPC = 28, /* no space on filesystem */ /// NFS4ERR_NOSPC = 28, /* no space on file system */
/// NFS4ERR_ROFS = 30, /* read-only filesystem */ /// NFS4ERR_ROFS = 30, /* read-only file system */
/// NFS4ERR_MLINK = 31, /* too many hard links */ /// NFS4ERR_MLINK = 31, /* too many hard links */
/// NFS4ERR_NAMETOOLONG = 63, /* name exceeds server max */ /// NFS4ERR_NAMETOOLONG = 63, /* name exceeds server max */
/// NFS4ERR_NOTEMPTY = 66, /* directory not empty */ /// NFS4ERR_NOTEMPTY = 66, /* directory not empty */
/// NFS4ERR_DQUOT = 69, /* hard quota limit reached*/ /// NFS4ERR_DQUOT = 69, /* hard quota limit reached */
/// NFS4ERR_STALE = 70, /* file no longer exists */ /// NFS4ERR_STALE = 70, /* file no longer exists */
/// NFS4ERR_BADHANDLE = 10001,/* Illegal filehandle */ /// NFS4ERR_BADHANDLE = 10001, /* illegal filehandle */
/// NFS4ERR_BAD_COOKIE = 10003,/* READDIR cookie is stale */ /// NFS4ERR_BAD_COOKIE = 10003, /* READDIR cookie is stale */
/// NFS4ERR_NOTSUPP = 10004,/* operation not supported */ /// NFS4ERR_NOTSUPP = 10004, /* operation not supported */
/// NFS4ERR_TOOSMALL = 10005,/* response limit exceeded */ /// NFS4ERR_TOOSMALL = 10005, /* response limit exceeded */
/// NFS4ERR_SERVERFAULT = 10006,/* undefined server error */ /// NFS4ERR_SERVERFAULT = 10006, /* undefined server error */
/// NFS4ERR_BADTYPE = 10007,/* type invalid for CREATE */ /// NFS4ERR_BADTYPE = 10007, /* type invalid for CREATE */
/// NFS4ERR_DELAY = 10008,/* file "busy" - retry */ /// NFS4ERR_DELAY = 10008, /* file "busy" -- retry */
/// NFS4ERR_SAME = 10009,/* nverify says attrs same */ /// NFS4ERR_SAME = 10009, /* nverify says attrs same */
/// NFS4ERR_DENIED = 10010,/* lock unavailable */ /// NFS4ERR_DENIED = 10010, /* lock unavailable */
/// NFS4ERR_EXPIRED = 10011,/* lock lease expired */ /// NFS4ERR_EXPIRED = 10011, /* lock lease expired */
/// NFS4ERR_LOCKED = 10012,/* I/O failed due to lock */ /// NFS4ERR_LOCKED = 10012, /* I/O failed due to lock */
/// NFS4ERR_GRACE = 10013,/* in grace period */ /// NFS4ERR_GRACE = 10013, /* in grace period */
/// NFS4ERR_FHEXPIRED = 10014,/* filehandle expired */ /// NFS4ERR_FHEXPIRED = 10014, /* filehandle expired */
/// NFS4ERR_SHARE_DENIED = 10015,/* share reserve denied */ /// NFS4ERR_SHARE_DENIED = 10015, /* share reserve denied */
/// NFS4ERR_WRONGSEC = 10016,/* wrong security flavor */ /// NFS4ERR_WRONGSEC = 10016, /* wrong security flavor */
/// NFS4ERR_CLID_INUSE = 10017,/* clientid in use */ /// NFS4ERR_CLID_INUSE = 10017, /* client ID in use */
/// ///
/// /* NFS4ERR_RESOURCE is not a valid error in NFSv4.1 */ /// /* NFS4ERR_RESOURCE is not a valid error in NFSv4.1. */
/// NFS4ERR_RESOURCE = 10018,/* resource exhaustion */ /// NFS4ERR_RESOURCE = 10018, /* resource exhaustion */
/// ///
/// NFS4ERR_MOVED = 10019,/* filesystem relocated */ /// NFS4ERR_MOVED = 10019, /* file system relocated */
/// NFS4ERR_NOFILEHANDLE = 10020,/* current FH is not set */ /// NFS4ERR_NOFILEHANDLE = 10020, /* current FH is not set */
/// NFS4ERR_MINOR_VERS_MISMATCH= 10021,/* minor vers not supp */ /// NFS4ERR_MINOR_VERS_MISMATCH= 10021, /* minor vers not supp */
/// NFS4ERR_STALE_CLIENTID = 10022,/* server has rebooted */ /// NFS4ERR_STALE_CLIENTID = 10022, /* server has rebooted */
/// NFS4ERR_STALE_STATEID = 10023,/* server has rebooted */ /// NFS4ERR_STALE_STATEID = 10023, /* server has rebooted */
/// NFS4ERR_OLD_STATEID = 10024,/* state is out of sync */ /// NFS4ERR_OLD_STATEID = 10024, /* state is out of sync */
/// NFS4ERR_BAD_STATEID = 10025,/* incorrect stateid */ /// NFS4ERR_BAD_STATEID = 10025, /* incorrect stateid */
/// NFS4ERR_BAD_SEQID = 10026,/* request is out of seq. */ /// NFS4ERR_BAD_SEQID = 10026, /* request is out of seq. */
/// NFS4ERR_NOT_SAME = 10027,/* verify - attrs not same */ /// NFS4ERR_NOT_SAME = 10027, /* verify -- attrs not same */
/// NFS4ERR_LOCK_RANGE = 10028,/* overlapping lock range */ /// NFS4ERR_LOCK_RANGE = 10028, /* overlapping lock range */
/// NFS4ERR_SYMLINK = 10029,/* should be file/directory*/ /// NFS4ERR_SYMLINK = 10029, /* should be file/directory */
/// NFS4ERR_RESTOREFH = 10030,/* no saved filehandle */ /// NFS4ERR_RESTOREFH = 10030, /* no saved filehandle */
/// NFS4ERR_LEASE_MOVED = 10031,/* some filesystem moved */ /// NFS4ERR_LEASE_MOVED = 10031, /* some file system moved */
/// NFS4ERR_ATTRNOTSUPP = 10032,/* recommended attr not sup*/ /// NFS4ERR_ATTRNOTSUPP = 10032, /* recommended attr not supp */
/// NFS4ERR_NO_GRACE = 10033,/* reclaim outside of grace*/ /// NFS4ERR_NO_GRACE = 10033, /* reclaim outside of grace */
/// NFS4ERR_RECLAIM_BAD = 10034,/* reclaim error at server */ /// NFS4ERR_RECLAIM_BAD = 10034, /* reclaim error at server */
/// NFS4ERR_RECLAIM_CONFLICT= 10035,/* conflict on reclaim */ /// NFS4ERR_RECLAIM_CONFLICT= 10035, /* conflict on reclaim */
/// NFS4ERR_BADXDR = 10036,/* XDR decode failed */ /// NFS4ERR_BADXDR = 10036, /* XDR decode failed */
/// NFS4ERR_LOCKS_HELD = 10037,/* file locks held at CLOSE*/ /// NFS4ERR_LOCKS_HELD = 10037, /* file locks held at CLOSE */
/// NFS4ERR_OPENMODE = 10038,/* conflict in OPEN and I/O*/ /// NFS4ERR_OPENMODE = 10038, /* conflict in OPEN and I/O */
/// NFS4ERR_BADOWNER = 10039,/* owner translation bad */ /// NFS4ERR_BADOWNER = 10039, /* owner translation bad */
/// NFS4ERR_BADCHAR = 10040,/* utf-8 char not supported*/ /// NFS4ERR_BADCHAR = 10040, /* UTF-8 char not supported */
/// NFS4ERR_BADNAME = 10041,/* name not supported */ /// NFS4ERR_BADNAME = 10041, /* name not supported */
/// NFS4ERR_BAD_RANGE = 10042,/* lock range not supported*/ /// NFS4ERR_BAD_RANGE = 10042, /* lock range not supported */
/// NFS4ERR_LOCK_NOTSUPP = 10043,/* no atomic up/downgrade */ /// NFS4ERR_LOCK_NOTSUPP = 10043, /* no atomic up/downgrade */
/// NFS4ERR_OP_ILLEGAL = 10044,/* undefined operation */ /// NFS4ERR_OP_ILLEGAL = 10044, /* undefined operation */
/// NFS4ERR_DEADLOCK = 10045,/* file locking deadlock */ /// NFS4ERR_DEADLOCK = 10045, /* file-locking deadlock */
/// NFS4ERR_FILE_OPEN = 10046,/* open file blocks op. */ /// NFS4ERR_FILE_OPEN = 10046, /* open file blocks op */
/// NFS4ERR_ADMIN_REVOKED = 10047,/* lockowner state revoked */ /// NFS4ERR_ADMIN_REVOKED = 10047, /* lock-owner state revoked */
/// NFS4ERR_CB_PATH_DOWN = 10048,/* callback path down */ /// NFS4ERR_CB_PATH_DOWN = 10048, /* callback path down */
/// ///
/// /* NFSv4.1 errors start here. */ /// /* NFSv4.1 errors start here. */
/// ///
/// NFS4ERR_BADIOMODE = 10049, /// NFS4ERR_BADIOMODE = 10049,
/// NFS4ERR_BADLAYOUT = 10050, /// NFS4ERR_BADLAYOUT = 10050,
/// NFS4ERR_BAD_SESSION_DIGEST = 10051, /// NFS4ERR_BAD_SESSION_DIGEST = 10051,
/// NFS4ERR_BADSESSION = 10052, /// NFS4ERR_BADSESSION = 10052,
/// NFS4ERR_BADSLOT = 10053, /// NFS4ERR_BADSLOT = 10053,
/// NFS4ERR_COMPLETE_ALREADY = 10054, /// NFS4ERR_COMPLETE_ALREADY = 10054,
/// NFS4ERR_CONN_NOT_BOUND_TO_SESSION = 10055, /// NFS4ERR_CONN_NOT_BOUND_TO_SESSION = 10055,
/// NFS4ERR_DELEG_ALREADY_WANTED = 10056, /// NFS4ERR_DELEG_ALREADY_WANTED = 10056,
/// NFS4ERR_BACK_CHAN_BUSY = 10057,/*backchan reqs outstanding*/ /// NFS4ERR_BACK_CHAN_BUSY = 10057, /* backchan reqs outstanding */
/// NFS4ERR_LAYOUTTRYLATER = 10058, /// NFS4ERR_LAYOUTTRYLATER = 10058,
/// NFS4ERR_LAYOUTUNAVAILABLE = 10059, /// NFS4ERR_LAYOUTUNAVAILABLE = 10059,
/// NFS4ERR_NOMATCHING_LAYOUT = 10060, /// NFS4ERR_NOMATCHING_LAYOUT = 10060,
/// NFS4ERR_RECALLCONFLICT = 10061, /// NFS4ERR_RECALLCONFLICT = 10061,
/// NFS4ERR_UNKNOWN_LAYOUTTYPE = 10062, /// NFS4ERR_UNKNOWN_LAYOUTTYPE = 10062,
/// NFS4ERR_SEQ_MISORDERED = 10063,/* unexpected seq.ID in req*/ /// NFS4ERR_SEQ_MISORDERED = 10063, /* unexpected seq. ID in req */
/// NFS4ERR_SEQUENCE_POS = 10064,/* [CB_]SEQ. op not 1st op */ /// NFS4ERR_SEQUENCE_POS = 10064, /* [CB_]SEQ. op not 1st op */
/// NFS4ERR_REQ_TOO_BIG = 10065,/* request too big */ /// NFS4ERR_REQ_TOO_BIG = 10065, /* request too big */
/// NFS4ERR_REP_TOO_BIG = 10066,/* reply too big */ /// NFS4ERR_REP_TOO_BIG = 10066, /* reply too big */
/// NFS4ERR_REP_TOO_BIG_TO_CACHE =10067,/* rep. not all cached*/ /// NFS4ERR_REP_TOO_BIG_TO_CACHE =10067, /* rep. not all cached */
/// NFS4ERR_RETRY_UNCACHED_REP =10068,/* retry + rep. uncached*/ /// NFS4ERR_RETRY_UNCACHED_REP =10068, /* retry + rep. uncached */
/// NFS4ERR_UNSAFE_COMPOUND =10069,/* retry/recovery too hard */ /// NFS4ERR_UNSAFE_COMPOUND =10069, /* retry/recovery too hard */
/// NFS4ERR_TOO_MANY_OPS = 10070,/*too many ops in [CB_]COMP*/ /// NFS4ERR_TOO_MANY_OPS = 10070, /* too many ops in [CB_]COMP */
/// NFS4ERR_OP_NOT_IN_SESSION =10071,/* op needs [CB_]SEQ. op */ /// NFS4ERR_OP_NOT_IN_SESSION =10071, /* op needs [CB_]SEQ. op */
/// NFS4ERR_HASH_ALG_UNSUPP = 10072, /* hash alg. not supp. */ /// NFS4ERR_HASH_ALG_UNSUPP = 10072, /* hash alg. not supp */
/// /* Error 10073 is unused. */ /// /* Error 10073 is unused. */
/// NFS4ERR_CLIENTID_BUSY = 10074,/* clientid has state */ /// NFS4ERR_CLIENTID_BUSY = 10074, /* client ID has state */
/// NFS4ERR_PNFS_IO_HOLE = 10075,/* IO to _SPARSE file hole */ /// NFS4ERR_PNFS_IO_HOLE = 10075, /* IO to _SPARSE file hole */
/// NFS4ERR_SEQ_FALSE_RETRY= 10076,/* Retry != original req. */ /// NFS4ERR_SEQ_FALSE_RETRY= 10076, /* retry != original req */
/// NFS4ERR_BAD_HIGH_SLOT = 10077,/* req has bad highest_slot*/ /// NFS4ERR_BAD_HIGH_SLOT = 10077, /* req has bad highest_slot */
/// NFS4ERR_DEADSESSION = 10078,/*new req sent to dead sess*/ /// NFS4ERR_DEADSESSION = 10078, /* new req sent to dead sess */
/// NFS4ERR_ENCR_ALG_UNSUPP= 10079,/* encr alg. not supp. */ /// NFS4ERR_ENCR_ALG_UNSUPP= 10079, /* encr alg. not supp */
/// NFS4ERR_PNFS_NO_LAYOUT = 10080,/* I/O without a layout */ /// NFS4ERR_PNFS_NO_LAYOUT = 10080, /* I/O without a layout */
/// NFS4ERR_NOT_ONLY_OP = 10081,/* addl ops not allowed */ /// NFS4ERR_NOT_ONLY_OP = 10081, /* addl ops not allowed */
/// NFS4ERR_WRONG_CRED = 10082,/* op done by wrong cred */ /// NFS4ERR_WRONG_CRED = 10082, /* op done by wrong cred */
/// NFS4ERR_WRONG_TYPE = 10083,/* op on wrong type object */ /// NFS4ERR_WRONG_TYPE = 10083, /* op on wrong type object */
/// NFS4ERR_DIRDELEG_UNAVAIL=10084,/* delegation not avail. */ /// NFS4ERR_DIRDELEG_UNAVAIL=10084, /* delegation not avail. */
/// NFS4ERR_REJECT_DELEG = 10085,/* cb rejected delegation */ /// NFS4ERR_REJECT_DELEG = 10085, /* cb rejected delegation */
/// NFS4ERR_RETURNCONFLICT = 10086,/* layout get before return*/ /// NFS4ERR_RETURNCONFLICT = 10086, /* layout get before return */
/// NFS4ERR_DELEG_REVOKED = 10087,/* deleg./layout revoked */ /// NFS4ERR_DELEG_REVOKED = 10087, /* deleg./layout revoked */
/// ///
/// /* NFSv4.2 errors start here. */ /// /* NFSv4.2 errors start here. */
/// ///
/// NFS4ERR_PARTNER_NOTSUPP= 10088,/* s2s not supported */ /// NFS4ERR_PARTNER_NOTSUPP= 10088, /* s2s not supported */
/// NFS4ERR_PARTNER_NO_AUTH= 10089,/* s2s not authorized */ /// NFS4ERR_PARTNER_NO_AUTH= 10089, /* s2s not authorized */
/// NFS4ERR_UNION_NOTSUPP = 10090,/* Arm of union not supp */ /// NFS4ERR_UNION_NOTSUPP = 10090, /* arm of union not supp */
/// NFS4ERR_OFFLOAD_DENIED = 10091,/* dest not allowing copy */ /// NFS4ERR_OFFLOAD_DENIED = 10091, /* dest not allowing copy */
/// NFS4ERR_WRONG_LFS = 10092,/* LFS not supported */ /// NFS4ERR_WRONG_LFS = 10092, /* LFS not supported */
/// NFS4ERR_BADLABEL = 10093,/* incorrect label */ /// NFS4ERR_BADLABEL = 10093, /* incorrect label */
/// NFS4ERR_OFFLOAD_NO_REQS= 10094 /* dest not meeting reqs */ /// NFS4ERR_OFFLOAD_NO_REQS= 10094 /* dest not meeting reqs */
/// }; /// };
/// ///
/// /* /// /*
/// * Basic data types /// * Basic data types
/// */ /// */
/// typedef opaque attrlist4<>; /// typedef opaque attrlist4<>;
/// typedef uint32_t bitmap4<>; /// typedef uint32_t bitmap4<>;
/// typedef uint64_t changeid4; /// typedef uint64_t changeid4;
/// typedef uint64_t clientid4; /// typedef uint64_t clientid4;
/// typedef uint32_t count4; /// typedef uint32_t count4;
skipping to change at page 9, line 36 skipping to change at page 9, line 40
/// }; /// };
/// ///
/// ///
/// typedef uint32_t nfs_lease4; /// typedef uint32_t nfs_lease4;
/// ///
/// /* /// /*
/// * File attribute definitions /// * File attribute definitions
/// */ /// */
/// ///
/// /* /// /*
/// * FSID structure for major/minor /// * File System ID (FSID) structure for major/minor
/// */ /// */
/// struct fsid4 { /// struct fsid4 {
/// uint64_t major; /// uint64_t major;
/// uint64_t minor; /// uint64_t minor;
/// }; /// };
/// ///
/// /* /// /*
/// * Filesystem locations attribute /// * File system locations attribute
/// * for relocation/migration and /// * for relocation/migration and
/// * related attributes. /// * related attributes
/// */ /// */
/// struct change_policy4 { /// struct change_policy4 {
/// uint64_t cp_major; /// uint64_t cp_major;
/// uint64_t cp_minor; /// uint64_t cp_minor;
/// }; /// };
/// ///
/// struct fs_location4 { /// struct fs_location4 {
/// utf8str_cis server<>; /// utf8str_cis server<>;
/// pathname4 rootpath; /// pathname4 rootpath;
/// }; /// };
/// ///
/// struct fs_locations4 { /// struct fs_locations4 {
/// pathname4 fs_root; /// pathname4 fs_root;
/// fs_location4 locations<>; /// fs_location4 locations<>;
/// }; /// };
/// ///
/// /* /// /*
/// * Various Access Control Entry definitions /// * Various Access Control Entry (ACE) definitions
/// */ /// */
/// ///
/// /* /// /*
/// * Mask that indicates which /// * Mask that indicates which ACEs are supported.
/// * Access Control Entries are supported.
/// * Values for the fattr4_aclsupport attribute. /// * Values for the fattr4_aclsupport attribute.
/// */ /// */
/// const ACL4_SUPPORT_ALLOW_ACL = 0x00000001; /// const ACL4_SUPPORT_ALLOW_ACL = 0x00000001;
/// const ACL4_SUPPORT_DENY_ACL = 0x00000002; /// const ACL4_SUPPORT_DENY_ACL = 0x00000002;
/// const ACL4_SUPPORT_AUDIT_ACL = 0x00000004; /// const ACL4_SUPPORT_AUDIT_ACL = 0x00000004;
/// const ACL4_SUPPORT_ALARM_ACL = 0x00000008; /// const ACL4_SUPPORT_ALARM_ACL = 0x00000008;
/// ///
/// ///
/// typedef uint32_t acetype4; /// typedef uint32_t acetype4;
/// ///
/// ///
/// /* /// /*
/// * acetype4 values, others can be added as needed. /// * acetype4 values. Others can be added as needed.
/// */ /// */
/// const ACE4_ACCESS_ALLOWED_ACE_TYPE = 0x00000000; /// const ACE4_ACCESS_ALLOWED_ACE_TYPE = 0x00000000;
/// const ACE4_ACCESS_DENIED_ACE_TYPE = 0x00000001; /// const ACE4_ACCESS_DENIED_ACE_TYPE = 0x00000001;
/// const ACE4_SYSTEM_AUDIT_ACE_TYPE = 0x00000002; /// const ACE4_SYSTEM_AUDIT_ACE_TYPE = 0x00000002;
/// const ACE4_SYSTEM_ALARM_ACE_TYPE = 0x00000003; /// const ACE4_SYSTEM_ALARM_ACE_TYPE = 0x00000003;
/// ///
/// ///
/// ///
/// /* /// /*
/// * ACE flag /// * ACE flag
skipping to change at page 11, line 47 skipping to change at page 12, line 12
/// const ACE4_WRITE_RETENTION_HOLD = 0x00000400; /// const ACE4_WRITE_RETENTION_HOLD = 0x00000400;
/// ///
/// const ACE4_DELETE = 0x00010000; /// const ACE4_DELETE = 0x00010000;
/// const ACE4_READ_ACL = 0x00020000; /// const ACE4_READ_ACL = 0x00020000;
/// const ACE4_WRITE_ACL = 0x00040000; /// const ACE4_WRITE_ACL = 0x00040000;
/// const ACE4_WRITE_OWNER = 0x00080000; /// const ACE4_WRITE_OWNER = 0x00080000;
/// const ACE4_SYNCHRONIZE = 0x00100000; /// const ACE4_SYNCHRONIZE = 0x00100000;
/// ///
/// ///
/// /* /// /*
/// * ACE4_GENERIC_READ -- defined as combination of /// * ACE4_GENERIC_READ -- defined as a combination of
/// * ACE4_READ_ACL | /// * ACE4_READ_ACL |
/// * ACE4_READ_DATA | /// * ACE4_READ_DATA |
/// * ACE4_READ_ATTRIBUTES | /// * ACE4_READ_ATTRIBUTES |
/// * ACE4_SYNCHRONIZE /// * ACE4_SYNCHRONIZE
/// */ /// */
/// ///
/// const ACE4_GENERIC_READ = 0x00120081; /// const ACE4_GENERIC_READ = 0x00120081;
/// ///
/// /* /// /*
/// * ACE4_GENERIC_WRITE -- defined as combination of /// * ACE4_GENERIC_WRITE -- defined as a combination of
/// * ACE4_READ_ACL | /// * ACE4_READ_ACL |
/// * ACE4_WRITE_DATA | /// * ACE4_WRITE_DATA |
/// * ACE4_WRITE_ATTRIBUTES | /// * ACE4_WRITE_ATTRIBUTES |
/// * ACE4_WRITE_ACL | /// * ACE4_WRITE_ACL |
/// * ACE4_APPEND_DATA | /// * ACE4_APPEND_DATA |
/// * ACE4_SYNCHRONIZE /// * ACE4_SYNCHRONIZE
/// */ /// */
/// const ACE4_GENERIC_WRITE = 0x00160106; /// const ACE4_GENERIC_WRITE = 0x00160106;
/// ///
/// ///
/// /* /// /*
/// * ACE4_GENERIC_EXECUTE -- defined as combination of /// * ACE4_GENERIC_EXECUTE -- defined as a combination of
/// * ACE4_READ_ACL /// * ACE4_READ_ACL |
/// * ACE4_READ_ATTRIBUTES /// * ACE4_READ_ATTRIBUTES |
/// * ACE4_EXECUTE /// * ACE4_EXECUTE |
/// * ACE4_SYNCHRONIZE /// * ACE4_SYNCHRONIZE
/// */ /// */
/// const ACE4_GENERIC_EXECUTE = 0x001200A0; /// const ACE4_GENERIC_EXECUTE = 0x001200A0;
/// ///
/// ///
/// /* /// /*
/// * Access Control Entry definition /// * ACE definition
/// */ /// */
/// struct nfsace4 { /// struct nfsace4 {
/// acetype4 type; /// acetype4 type;
/// aceflag4 flag; /// aceflag4 flag;
/// acemask4 access_mask; /// acemask4 access_mask;
/// utf8str_mixed who; /// utf8str_mixed who;
/// }; /// };
/// ///
/// ///
/// /* /// /*
/// * ACL flag /// * Access Control List (ACL) flag
/// */ /// */
/// ///
/// typedef uint32_t aclflag4; /// typedef uint32_t aclflag4;
/// ///
/// /* /// /*
/// * ACL flag values /// * ACL flag values
/// */ /// */
/// const ACL4_AUTO_INHERIT = 0x00000001; /// const ACL4_AUTO_INHERIT = 0x00000001;
/// const ACL4_PROTECTED = 0x00000002; /// const ACL4_PROTECTED = 0x00000002;
/// const ACL4_DEFAULTED = 0x00000004; /// const ACL4_DEFAULTED = 0x00000004;
/// ///
/// ///
/// /* /// /*
/// * Version 4.1 Access Control List definition /// * Version 4.1 ACL definition
/// */ /// */
/// struct nfsacl41 { /// struct nfsacl41 {
/// aclflag4 na41_flag; /// aclflag4 na41_flag;
/// nfsace4 na41_aces<>; /// nfsace4 na41_aces<>;
/// }; /// };
/// ///
/// ///
/// /* /// /*
/// * Field definitions for the fattr4_mode /// * Field definitions for the fattr4_mode
/// * and fattr4_mode_set_masked attributes. /// * and fattr4_mode_set_masked attributes
/// */ /// */
/// const MODE4_SUID = 0x800; /* set user id on execution */ /// const MODE4_SUID = 0x800; /* set user id on execution */
/// const MODE4_SGID = 0x400; /* set group id on execution */ /// const MODE4_SGID = 0x400; /* set group id on execution */
/// const MODE4_SVTX = 0x200; /* save text even after use */ /// const MODE4_SVTX = 0x200; /* save text even after use */
/// const MODE4_RUSR = 0x100; /* read permission: owner */ /// const MODE4_RUSR = 0x100; /* read permission: owner */
/// const MODE4_WUSR = 0x080; /* write permission: owner */ /// const MODE4_WUSR = 0x080; /* write permission: owner */
/// const MODE4_XUSR = 0x040; /* execute permission: owner */ /// const MODE4_XUSR = 0x040; /* execute permission: owner */
/// const MODE4_RGRP = 0x020; /* read permission: group */ /// const MODE4_RGRP = 0x020; /* read permission: group */
/// const MODE4_WGRP = 0x010; /* write permission: group */ /// const MODE4_WGRP = 0x010; /* write permission: group */
/// const MODE4_XGRP = 0x008; /* execute permission: group */ /// const MODE4_XGRP = 0x008; /* execute permission: group */
/// const MODE4_ROTH = 0x004; /* read permission: other */ /// const MODE4_ROTH = 0x004; /* read permission: other */
/// const MODE4_WOTH = 0x002; /* write permission: other */ /// const MODE4_WOTH = 0x002; /* write permission: other */
/// const MODE4_XOTH = 0x001; /* execute permission: other */ /// const MODE4_XOTH = 0x001; /* execute permission: other */
/// ///
/// ///
/// /* /// /*
/// * Masked mode for the mode_set_masked attribute. /// * Masked mode for the mode_set_masked attribute
/// */ /// */
/// struct mode_masked4 { /// struct mode_masked4 {
/// mode4 mm_value_to_set; /* Values of bits /// mode4 mm_value_to_set; /* Values of bits
/// to set or reset /// to set or reset
/// in mode. */ /// in mode */
/// ///
/// mode4 mm_mask_bits; /* Mask of bits to /// mode4 mm_mask_bits; /* Mask of bits to
/// set or reset /// set or reset
/// in mode. */ /// in mode */
/// }; /// };
/// ///
/// /* /// /*
/// * Special data/attribute associated with /// * Special data/attribute associated with
/// * file types NF4BLK and NF4CHR. /// * file types NF4BLK and NF4CHR
/// */ /// */
/// struct specdata4 { /// struct specdata4 {
/// uint32_t specdata1; /* major device number */ /// uint32_t specdata1; /* Major device number */
/// uint32_t specdata2; /* minor device number */ /// uint32_t specdata2; /* Minor device number */
/// }; /// };
/// ///
/// /* /// /*
/// * Values for fattr4_fh_expire_type /// * Values for fattr4_fh_expire_type
/// */ /// */
/// const FH4_PERSISTENT = 0x00000000; /// const FH4_PERSISTENT = 0x00000000;
/// const FH4_NOEXPIRE_WITH_OPEN = 0x00000001; /// const FH4_NOEXPIRE_WITH_OPEN = 0x00000001;
/// const FH4_VOLATILE_ANY = 0x00000002; /// const FH4_VOLATILE_ANY = 0x00000002;
/// const FH4_VOL_MIGRATION = 0x00000004; /// const FH4_VOL_MIGRATION = 0x00000004;
/// const FH4_VOL_RENAME = 0x00000008; /// const FH4_VOL_RENAME = 0x00000008;
/// ///
/// ///
/// struct netaddr4 { /// struct netaddr4 {
/// /* see struct rpcb in RFC 1833 */ /// /* See struct rpcb in RFC 1833. */
/// string na_r_netid<>; /* network id */ /// string na_r_netid<>; /* Network id */
/// string na_r_addr<>; /* universal address */ /// string na_r_addr<>; /* Universal address */
/// }; /// };
/// ///
/// ///
/// /* /// /*
/// * data structures new to NFSv4.1 /// * Data structures new to NFSv4.1
/// */ /// */
/// ///
/// struct nfs_impl_id4 { /// struct nfs_impl_id4 {
/// utf8str_cis nii_domain; /// utf8str_cis nii_domain;
/// utf8str_cs nii_name; /// utf8str_cs nii_name;
/// nfstime4 nii_date; /// nfstime4 nii_date;
/// }; /// };
/// ///
/// ///
/// /* /// /*
skipping to change at page 15, line 10 skipping to change at page 15, line 28
/// }; /// };
/// ///
/// struct layout_content4 { /// struct layout_content4 {
/// layouttype4 loc_type; /// layouttype4 loc_type;
/// opaque loc_body<>; /// opaque loc_body<>;
/// }; /// };
/// ///
/// ///
/// %/* /// %/*
/// % * LAYOUT4_OSD2_OBJECTS loc_body description /// % * LAYOUT4_OSD2_OBJECTS loc_body description
/// % * is in a separate .x file /// % * is in a separate .x file.
/// % */ /// % */
/// % /// %
/// %/* /// %/*
/// % * LAYOUT4_BLOCK_VOLUME loc_body description /// % * LAYOUT4_BLOCK_VOLUME loc_body description
/// % * is in a separate .x file /// % * is in a separate .x file.
/// % */ /// % */
/// ///
/// struct layouthint4 { /// struct layouthint4 {
/// layouttype4 loh_type; /// layouttype4 loh_type;
/// opaque loh_body<>; /// opaque loh_body<>;
/// }; /// };
/// ///
/// enum layoutiomode4 { /// enum layoutiomode4 {
/// LAYOUTIOMODE4_READ = 1, /// LAYOUTIOMODE4_READ = 1,
/// LAYOUTIOMODE4_RW = 2, /// LAYOUTIOMODE4_RW = 2,
skipping to change at page 16, line 23 skipping to change at page 16, line 46
/// }; /// };
/// ///
/// struct layoutreturn_file4 { /// struct layoutreturn_file4 {
/// offset4 lrf_offset; /// offset4 lrf_offset;
/// length4 lrf_length; /// length4 lrf_length;
/// stateid4 lrf_stateid; /// stateid4 lrf_stateid;
/// % /* layouttype4 specific data */ /// % /* layouttype4 specific data */
/// opaque lrf_body<>; /// opaque lrf_body<>;
/// }; /// };
/// ///
/// union layoutreturn4 switch(layoutreturn_type4 lr_returntype) { /// union layoutreturn4 switch (layoutreturn_type4 lr_returntype) {
/// case LAYOUTRETURN4_FILE: /// case LAYOUTRETURN4_FILE:
/// layoutreturn_file4 lr_layout; /// layoutreturn_file4 lr_layout;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// % /// %
/// ///
/// enum fs4_status_type { /// enum fs4_status_type {
/// STATUS4_FIXED = 1, /// STATUS4_FIXED = 1,
/// STATUS4_UPDATED = 2, /// STATUS4_UPDATED = 2,
/// STATUS4_VERSIONED = 3, /// STATUS4_VERSIONED = 3,
/// STATUS4_WRITABLE = 4, /// STATUS4_WRITABLE = 4,
/// STATUS4_REFERRAL = 5 /// STATUS4_REFERRAL = 5
/// }; /// };
/// ///
/// struct fs4_status { /// struct fs4_status {
/// bool fss_absent; /// bool fss_absent;
/// fs4_status_type fss_type; /// fs4_status_type fss_type;
/// utf8str_cs fss_source; /// utf8str_cs fss_source;
/// utf8str_cs fss_current; /// utf8str_cs fss_current;
/// int32_t fss_age; /// int32_t fss_age;
/// nfstime4 fss_version; /// nfstime4 fss_version;
/// }; /// };
skipping to change at page 17, line 39 skipping to change at page 18, line 16
/// uint64_t rs_duration<1>; /// uint64_t rs_duration<1>;
/// }; /// };
/// ///
/// const FSCHARSET_CAP4_CONTAINS_NON_UTF8 = 0x1; /// const FSCHARSET_CAP4_CONTAINS_NON_UTF8 = 0x1;
/// const FSCHARSET_CAP4_ALLOWS_ONLY_UTF8 = 0x2; /// const FSCHARSET_CAP4_ALLOWS_ONLY_UTF8 = 0x2;
/// ///
/// typedef uint32_t fs_charset_cap4; /// typedef uint32_t fs_charset_cap4;
/// ///
/// ///
/// /* /// /*
/// * data structures new to NFSv4.2 /// * Data structures new to NFSv4.2
/// */ /// */
/// ///
/// enum netloc_type4 { /// enum netloc_type4 {
/// NL4_NAME = 1, /// NL4_NAME = 1,
/// NL4_URL = 2, /// NL4_URL = 2,
/// NL4_NETADDR = 3 /// NL4_NETADDR = 3
/// }; /// };
/// union netloc4 switch (netloc_type4 nl_type) { /// union netloc4 switch (netloc_type4 nl_type) {
/// case NL4_NAME: utf8str_cis nl_name; /// case NL4_NAME: utf8str_cis nl_name;
/// case NL4_URL: utf8str_cis nl_url; /// case NL4_URL: utf8str_cis nl_url;
skipping to change at page 18, line 27 skipping to change at page 19, line 7
/// ///
/// struct sec_label4 { /// struct sec_label4 {
/// labelformat_spec4 slai_lfs; /// labelformat_spec4 slai_lfs;
/// opaque slai_data<>; /// opaque slai_data<>;
/// }; /// };
/// ///
/// ///
/// struct copy_from_auth_priv { /// struct copy_from_auth_priv {
/// secret4 cfap_shared_secret; /// secret4 cfap_shared_secret;
/// netloc4 cfap_destination; /// netloc4 cfap_destination;
/// /* the NFSv4 user name that the user principal maps to */ /// /* The NFSv4 user name that the user principal maps to */
/// utf8str_mixed cfap_username; /// utf8str_mixed cfap_username;
/// }; /// };
/// ///
/// struct copy_to_auth_priv { /// struct copy_to_auth_priv {
/// /* equal to cfap_shared_secret */ /// /* Equal to cfap_shared_secret */
/// secret4 ctap_shared_secret; /// secret4 ctap_shared_secret;
/// netloc4 ctap_source<>; /// netloc4 ctap_source<>;
/// /* the NFSv4 user name that the user principal maps to */ /// /* The NFSv4 user name that the user principal maps to */
/// utf8str_mixed ctap_username; /// utf8str_mixed ctap_username;
/// }; /// };
/// ///
/// struct copy_confirm_auth_priv { /// struct copy_confirm_auth_priv {
/// /* equal to GSS_GetMIC() of cfap_shared_secret */ /// /* Equal to GSS_GetMIC() of cfap_shared_secret */
/// opaque ccap_shared_secret_mic<>; /// opaque ccap_shared_secret_mic<>;
/// /* the NFSv4 user name that the user principal maps to */ /// /* The NFSv4 user name that the user principal maps to */
/// utf8str_mixed ccap_username; /// utf8str_mixed ccap_username;
/// }; /// };
/// ///
/// ///
/// struct app_data_block4 { /// struct app_data_block4 {
/// offset4 adb_offset; /// offset4 adb_offset;
/// length4 adb_block_size; /// length4 adb_block_size;
/// length4 adb_block_count; /// length4 adb_block_count;
/// length4 adb_reloff_blocknum; /// length4 adb_reloff_blocknum;
/// count4 adb_block_num; /// count4 adb_block_num;
skipping to change at page 21, line 9 skipping to change at page 21, line 40
/// typedef bool fattr4_system; /// typedef bool fattr4_system;
/// typedef nfstime4 fattr4_time_access; /// typedef nfstime4 fattr4_time_access;
/// typedef settime4 fattr4_time_access_set; /// typedef settime4 fattr4_time_access_set;
/// typedef nfstime4 fattr4_time_backup; /// typedef nfstime4 fattr4_time_backup;
/// typedef nfstime4 fattr4_time_create; /// typedef nfstime4 fattr4_time_create;
/// typedef nfstime4 fattr4_time_delta; /// typedef nfstime4 fattr4_time_delta;
/// typedef nfstime4 fattr4_time_metadata; /// typedef nfstime4 fattr4_time_metadata;
/// typedef nfstime4 fattr4_time_modify; /// typedef nfstime4 fattr4_time_modify;
/// typedef settime4 fattr4_time_modify_set; /// typedef settime4 fattr4_time_modify_set;
/// /* /// /*
/// * attributes new to NFSv4.1 /// * Attributes new to NFSv4.1
/// */ /// */
/// typedef bitmap4 fattr4_suppattr_exclcreat; /// typedef bitmap4 fattr4_suppattr_exclcreat;
/// typedef nfstime4 fattr4_dir_notif_delay; /// typedef nfstime4 fattr4_dir_notif_delay;
/// typedef nfstime4 fattr4_dirent_notif_delay; /// typedef nfstime4 fattr4_dirent_notif_delay;
/// typedef layouttype4 fattr4_fs_layout_types<>; /// typedef layouttype4 fattr4_fs_layout_types<>;
/// typedef fs4_status fattr4_fs_status; /// typedef fs4_status fattr4_fs_status;
/// typedef fs_charset_cap4 fattr4_fs_charset_cap; /// typedef fs_charset_cap4 fattr4_fs_charset_cap;
/// typedef uint32_t fattr4_layout_alignment; /// typedef uint32_t fattr4_layout_alignment;
/// typedef uint32_t fattr4_layout_blksize; /// typedef uint32_t fattr4_layout_blksize;
/// typedef layouthint4 fattr4_layout_hint; /// typedef layouthint4 fattr4_layout_hint;
skipping to change at page 21, line 31 skipping to change at page 22, line 14
/// typedef mdsthreshold4 fattr4_mdsthreshold; /// typedef mdsthreshold4 fattr4_mdsthreshold;
/// typedef retention_get4 fattr4_retention_get; /// typedef retention_get4 fattr4_retention_get;
/// typedef retention_set4 fattr4_retention_set; /// typedef retention_set4 fattr4_retention_set;
/// typedef retention_get4 fattr4_retentevt_get; /// typedef retention_get4 fattr4_retentevt_get;
/// typedef retention_set4 fattr4_retentevt_set; /// typedef retention_set4 fattr4_retentevt_set;
/// typedef uint64_t fattr4_retention_hold; /// typedef uint64_t fattr4_retention_hold;
/// typedef nfsacl41 fattr4_dacl; /// typedef nfsacl41 fattr4_dacl;
/// typedef nfsacl41 fattr4_sacl; /// typedef nfsacl41 fattr4_sacl;
/// typedef change_policy4 fattr4_change_policy; /// typedef change_policy4 fattr4_change_policy;
/// /* /// /*
/// * attributes new to NFSv4.2 /// * Attributes new to NFSv4.2
/// */ /// */
/// typedef uint64_t fattr4_space_freed; /// typedef uint64_t fattr4_space_freed;
/// typedef change_attr_type4 /// typedef change_attr_type4
/// fattr4_change_attr_type; /// fattr4_change_attr_type;
/// typedef sec_label4 fattr4_sec_label; /// typedef sec_label4 fattr4_sec_label;
/// typedef uint32_t fattr4_clone_blksize; /// typedef uint32_t fattr4_clone_blksize;
/// ///
/// %/* /// %/*
/// % * REQUIRED Attributes /// % * REQUIRED attributes
/// % */ /// % */
/// const FATTR4_SUPPORTED_ATTRS = 0; /// const FATTR4_SUPPORTED_ATTRS = 0;
/// const FATTR4_TYPE = 1; /// const FATTR4_TYPE = 1;
/// const FATTR4_FH_EXPIRE_TYPE = 2; /// const FATTR4_FH_EXPIRE_TYPE = 2;
/// const FATTR4_CHANGE = 3; /// const FATTR4_CHANGE = 3;
/// const FATTR4_SIZE = 4; /// const FATTR4_SIZE = 4;
/// const FATTR4_LINK_SUPPORT = 5; /// const FATTR4_LINK_SUPPORT = 5;
/// const FATTR4_SYMLINK_SUPPORT = 6; /// const FATTR4_SYMLINK_SUPPORT = 6;
/// const FATTR4_NAMED_ATTR = 7; /// const FATTR4_NAMED_ATTR = 7;
/// const FATTR4_FSID = 8; /// const FATTR4_FSID = 8;
/// const FATTR4_UNIQUE_HANDLES = 9; /// const FATTR4_UNIQUE_HANDLES = 9;
/// const FATTR4_LEASE_TIME = 10; /// const FATTR4_LEASE_TIME = 10;
/// const FATTR4_RDATTR_ERROR = 11; /// const FATTR4_RDATTR_ERROR = 11;
/// const FATTR4_FILEHANDLE = 19; /// const FATTR4_FILEHANDLE = 19;
/// ///
/// %/* /// %/*
/// % * new to NFSV4.1 /// % * New to NFSv4.1
/// % */ /// % */
/// const FATTR4_SUPPATTR_EXCLCREAT = 75; /// const FATTR4_SUPPATTR_EXCLCREAT = 75;
/// ///
/// %/* /// %/*
/// % * RECOMMENDED Attributes /// % * RECOMMENDED attributes
/// % */ /// % */
/// const FATTR4_ACL = 12; /// const FATTR4_ACL = 12;
/// const FATTR4_ACLSUPPORT = 13; /// const FATTR4_ACLSUPPORT = 13;
/// const FATTR4_ARCHIVE = 14; /// const FATTR4_ARCHIVE = 14;
/// const FATTR4_CANSETTIME = 15; /// const FATTR4_CANSETTIME = 15;
/// const FATTR4_CASE_INSENSITIVE = 16; /// const FATTR4_CASE_INSENSITIVE = 16;
/// const FATTR4_CASE_PRESERVING = 17; /// const FATTR4_CASE_PRESERVING = 17;
/// const FATTR4_CHOWN_RESTRICTED = 18; /// const FATTR4_CHOWN_RESTRICTED = 18;
/// const FATTR4_FILEID = 20; /// const FATTR4_FILEID = 20;
/// const FATTR4_FILES_AVAIL = 21; /// const FATTR4_FILES_AVAIL = 21;
skipping to change at page 23, line 13 skipping to change at page 23, line 44
/// const FATTR4_TIME_ACCESS_SET = 48; /// const FATTR4_TIME_ACCESS_SET = 48;
/// const FATTR4_TIME_BACKUP = 49; /// const FATTR4_TIME_BACKUP = 49;
/// const FATTR4_TIME_CREATE = 50; /// const FATTR4_TIME_CREATE = 50;
/// const FATTR4_TIME_DELTA = 51; /// const FATTR4_TIME_DELTA = 51;
/// const FATTR4_TIME_METADATA = 52; /// const FATTR4_TIME_METADATA = 52;
/// const FATTR4_TIME_MODIFY = 53; /// const FATTR4_TIME_MODIFY = 53;
/// const FATTR4_TIME_MODIFY_SET = 54; /// const FATTR4_TIME_MODIFY_SET = 54;
/// const FATTR4_MOUNTED_ON_FILEID = 55; /// const FATTR4_MOUNTED_ON_FILEID = 55;
/// ///
/// %/* /// %/*
/// % * new to NFSV4.1 /// % * New to NFSv4.1
/// % */ /// % */
/// const FATTR4_DIR_NOTIF_DELAY = 56; /// const FATTR4_DIR_NOTIF_DELAY = 56;
/// const FATTR4_DIRENT_NOTIF_DELAY = 57; /// const FATTR4_DIRENT_NOTIF_DELAY = 57;
/// const FATTR4_DACL = 58; /// const FATTR4_DACL = 58;
/// const FATTR4_SACL = 59; /// const FATTR4_SACL = 59;
/// const FATTR4_CHANGE_POLICY = 60; /// const FATTR4_CHANGE_POLICY = 60;
/// const FATTR4_FS_STATUS = 61; /// const FATTR4_FS_STATUS = 61;
/// const FATTR4_FS_LAYOUT_TYPES = 62; /// const FATTR4_FS_LAYOUT_TYPES = 62;
/// const FATTR4_LAYOUT_HINT = 63; /// const FATTR4_LAYOUT_HINT = 63;
/// const FATTR4_LAYOUT_TYPES = 64; /// const FATTR4_LAYOUT_TYPES = 64;
skipping to change at page 23, line 37 skipping to change at page 24, line 20
/// const FATTR4_MDSTHRESHOLD = 68; /// const FATTR4_MDSTHRESHOLD = 68;
/// const FATTR4_RETENTION_GET = 69; /// const FATTR4_RETENTION_GET = 69;
/// const FATTR4_RETENTION_SET = 70; /// const FATTR4_RETENTION_SET = 70;
/// const FATTR4_RETENTEVT_GET = 71; /// const FATTR4_RETENTEVT_GET = 71;
/// const FATTR4_RETENTEVT_SET = 72; /// const FATTR4_RETENTEVT_SET = 72;
/// const FATTR4_RETENTION_HOLD = 73; /// const FATTR4_RETENTION_HOLD = 73;
/// const FATTR4_MODE_SET_MASKED = 74; /// const FATTR4_MODE_SET_MASKED = 74;
/// const FATTR4_FS_CHARSET_CAP = 76; /// const FATTR4_FS_CHARSET_CAP = 76;
/// ///
/// %/* /// %/*
/// % * new to NFSV4.2 /// % * New to NFSv4.2
/// % */ /// % */
/// const FATTR4_CLONE_BLKSIZE = 77; /// const FATTR4_CLONE_BLKSIZE = 77;
/// const FATTR4_SPACE_FREED = 78; /// const FATTR4_SPACE_FREED = 78;
/// const FATTR4_CHANGE_ATTR_TYPE = 79; /// const FATTR4_CHANGE_ATTR_TYPE = 79;
/// const FATTR4_SEC_LABEL = 80; /// const FATTR4_SEC_LABEL = 80;
/// ///
/// /* /// /*
/// * File attribute container /// * File attribute container
/// */ /// */
/// struct fattr4 { /// struct fattr4 {
skipping to change at page 24, line 24 skipping to change at page 25, line 13
/// ///
/// /* /// /*
/// * Callback program info as provided by the client /// * Callback program info as provided by the client
/// */ /// */
/// struct cb_client4 { /// struct cb_client4 {
/// uint32_t cb_program; /// uint32_t cb_program;
/// netaddr4 cb_location; /// netaddr4 cb_location;
/// }; /// };
/// ///
/// /* /// /*
/// * NFSv4.0 Long Hand Client ID /// * NFSv4.0 long-hand client ID
/// */ /// */
/// struct nfs_client_id4 { /// struct nfs_client_id4 {
/// verifier4 verifier; /// verifier4 verifier;
/// opaque id<NFS4_OPAQUE_LIMIT>; /// opaque id<NFS4_OPAQUE_LIMIT>;
/// }; /// };
/// ///
/// /* /// /*
/// * NFSv4.1 Client Owner (aka long hand client ID) /// * NFSv4.1 client owner (aka long-hand client ID)
/// */ /// */
/// struct client_owner4 { /// struct client_owner4 {
/// verifier4 co_verifier; /// verifier4 co_verifier;
/// opaque co_ownerid<NFS4_OPAQUE_LIMIT>; /// opaque co_ownerid<NFS4_OPAQUE_LIMIT>;
/// }; /// };
/// ///
/// ///
/// /* /// /*
/// * NFSv4.1 server Owner /// * NFSv4.1 server owner
/// */ /// */
/// struct server_owner4 { /// struct server_owner4 {
/// uint64_t so_minor_id; /// uint64_t so_minor_id;
/// opaque so_major_id<NFS4_OPAQUE_LIMIT>; /// opaque so_major_id<NFS4_OPAQUE_LIMIT>;
/// }; /// };
/// ///
/// ///
/// struct state_owner4 { /// struct state_owner4 {
/// clientid4 clientid; /// clientid4 clientid;
/// opaque owner<NFS4_OPAQUE_LIMIT>; /// opaque owner<NFS4_OPAQUE_LIMIT>;
/// }; /// };
/// ///
/// typedef state_owner4 open_owner4; /// typedef state_owner4 open_owner4;
/// typedef state_owner4 lock_owner4; /// typedef state_owner4 lock_owner4;
/// ///
/// ///
/// enum nfs_lock_type4 { /// enum nfs_lock_type4 {
/// READ_LT = 1, /// READ_LT = 1,
/// WRITE_LT = 2, /// WRITE_LT = 2,
/// READW_LT = 3, /* blocking read */ /// READW_LT = 3, /* Blocking read */
/// WRITEW_LT = 4 /* blocking write */ /// WRITEW_LT = 4 /* Blocking write */
/// }; /// };
/// ///
/// ///
/// % /// %
/// %/* Input for computing subkeys */ /// %/* Input for computing subkeys */
/// enum ssv_subkey4 { /// enum ssv_subkey4 {
/// SSV4_SUBKEY_MIC_I2T = 1, /// SSV4_SUBKEY_MIC_I2T = 1,
/// SSV4_SUBKEY_MIC_T2I = 2, /// SSV4_SUBKEY_MIC_T2I = 2,
/// SSV4_SUBKEY_SEAL_I2T = 3, /// SSV4_SUBKEY_SEAL_I2T = 3,
/// SSV4_SUBKEY_SEAL_T2I = 4 /// SSV4_SUBKEY_SEAL_T2I = 4
skipping to change at page 25, line 37 skipping to change at page 26, line 31
/// ///
/// % /// %
/// %/* Input for computing smt_hmac */ /// %/* Input for computing smt_hmac */
/// struct ssv_mic_plain_tkn4 { /// struct ssv_mic_plain_tkn4 {
/// uint32_t smpt_ssv_seq; /// uint32_t smpt_ssv_seq;
/// opaque smpt_orig_plain<>; /// opaque smpt_orig_plain<>;
/// }; /// };
/// % /// %
/// ///
/// % /// %
/// %/* SSV GSS PerMsgToken token */ /// %/*
/// % * Secret State Verifier Generic Security Service (SSV GSS)
/// % * PerMsgToken token
/// % */
/// struct ssv_mic_tkn4 { /// struct ssv_mic_tkn4 {
/// uint32_t smt_ssv_seq; /// uint32_t smt_ssv_seq;
/// opaque smt_hmac<>; /// opaque smt_hmac<>;
/// }; /// };
/// % /// %
/// ///
/// % /// %
/// %/* Input for computing ssct_encr_data and ssct_hmac */ /// %/* Input for computing ssct_encr_data and ssct_hmac */
/// struct ssv_seal_plain_tkn4 { /// struct ssv_seal_plain_tkn4 {
/// opaque sspt_confounder<>; /// opaque sspt_confounder<>;
skipping to change at page 26, line 19 skipping to change at page 27, line 16
/// uint32_t ssct_ssv_seq; /// uint32_t ssct_ssv_seq;
/// opaque ssct_iv<>; /// opaque ssct_iv<>;
/// opaque ssct_encr_data<>; /// opaque ssct_encr_data<>;
/// opaque ssct_hmac<>; /// opaque ssct_hmac<>;
/// }; /// };
/// % /// %
/// ///
/// /* /// /*
/// * Defines an individual server replica /// * Defines an individual server replica
/// */ /// */
/// struct fs_locations_server4 { /// struct fs_locations_server4 {
/// int32_t fls_currency; /// int32_t fls_currency;
/// opaque fls_info<>; /// opaque fls_info<>;
/// utf8str_cis fls_server; /// utf8str_cis fls_server;
/// }; /// };
/// ///
/// /* /// /*
/// * Byte indices of items within /// * Byte indices of items within
/// * fls_info: flag fields, class numbers, /// * fls_info: flag fields, class numbers,
/// * bytes indicating ranks and orders. /// * bytes indicating ranks and orders
/// */ /// */
/// const FSLI4BX_GFLAGS = 0; /// const FSLI4BX_GFLAGS = 0;
/// const FSLI4BX_TFLAGS = 1; /// const FSLI4BX_TFLAGS = 1;
/// ///
/// const FSLI4BX_CLSIMUL = 2; /// const FSLI4BX_CLSIMUL = 2;
/// const FSLI4BX_CLHANDLE = 3; /// const FSLI4BX_CLHANDLE = 3;
/// const FSLI4BX_CLFILEID = 4; /// const FSLI4BX_CLFILEID = 4;
/// const FSLI4BX_CLWRITEVER = 5; /// const FSLI4BX_CLWRITEVER = 5;
/// const FSLI4BX_CLCHANGE = 6; /// const FSLI4BX_CLCHANGE = 6;
/// const FSLI4BX_CLREADDIR = 7; /// const FSLI4BX_CLREADDIR = 7;
/// ///
/// const FSLI4BX_READRANK = 8; /// const FSLI4BX_READRANK = 8;
/// const FSLI4BX_WRITERANK = 9; /// const FSLI4BX_WRITERANK = 9;
/// const FSLI4BX_READORDER = 10; /// const FSLI4BX_READORDER = 10;
/// const FSLI4BX_WRITEORDER = 11; /// const FSLI4BX_WRITEORDER = 11;
/// ///
/// /* /// /*
/// * Bits defined within the general flag byte. /// * Bits defined within the general flag byte
/// */ /// */
/// const FSLI4GF_WRITABLE = 0x01; /// const FSLI4GF_WRITABLE = 0x01;
/// const FSLI4GF_CUR_REQ = 0x02; /// const FSLI4GF_CUR_REQ = 0x02;
/// const FSLI4GF_ABSENT = 0x04; /// const FSLI4GF_ABSENT = 0x04;
/// const FSLI4GF_GOING = 0x08; /// const FSLI4GF_GOING = 0x08;
/// const FSLI4GF_SPLIT = 0x10; /// const FSLI4GF_SPLIT = 0x10;
/// ///
/// /* /// /*
/// * Bits defined within the transport flag byte. /// * Bits defined within the transport flag byte
/// */ /// */
/// const FSLI4TF_RDMA = 0x01; /// const FSLI4TF_RDMA = 0x01;
/// ///
/// /* /// /*
/// * Defines a set of replicas sharing /// * Defines a set of replicas sharing
/// * a common value of the root path /// * a common value of the root path
/// * with in the corresponding /// * within the corresponding
/// * single-server namespaces. /// * single-server namespaces
/// */ /// */
/// struct fs_locations_item4 { /// struct fs_locations_item4 {
/// fs_locations_server4 fli_entries<>; /// fs_locations_server4 fli_entries<>;
/// pathname4 fli_rootpath; /// pathname4 fli_rootpath;
/// }; /// };
/// ///
/// /* /// /*
/// * Defines the overall structure of /// * Defines the overall structure of
/// * the fs_locations_info attribute. /// * the fs_locations_info attribute
/// */ /// */
/// struct fs_locations_info4 { /// struct fs_locations_info4 {
/// uint32_t fli_flags; /// uint32_t fli_flags;
/// int32_t fli_valid_for; /// int32_t fli_valid_for;
/// pathname4 fli_fs_root; /// pathname4 fli_fs_root;
/// fs_locations_item4 fli_items<>; /// fs_locations_item4 fli_items<>;
/// }; /// };
/// ///
/// /* /// /*
/// * Flag bits in fli_flags. /// * Flag bits in fli_flags
/// */ /// */
/// const FSLI4IF_VAR_SUB = 0x00000001; /// const FSLI4IF_VAR_SUB = 0x00000001;
/// ///
/// typedef fs_locations_info4 fattr4_fs_locations_info; /// typedef fs_locations_info4 fattr4_fs_locations_info;
/// ///
/// const NFL4_UFLG_MASK = 0x0000003F; /// const NFL4_UFLG_MASK = 0x0000003F;
/// const NFL4_UFLG_DENSE = 0x00000001; /// const NFL4_UFLG_DENSE = 0x00000001;
/// const NFL4_UFLG_COMMIT_THRU_MDS = 0x00000002; /// const NFL4_UFLG_COMMIT_THRU_MDS = 0x00000002;
/// const NFL42_UFLG_IO_ADVISE_THRU_MDS = 0x00000004; /// const NFL42_UFLG_IO_ADVISE_THRU_MDS = 0x00000004;
/// const NFL4_UFLG_STRIPE_UNIT_SIZE_MASK = 0xFFFFFFC0; /// const NFL4_UFLG_STRIPE_UNIT_SIZE_MASK = 0xFFFFFFC0;
skipping to change at page 28, line 19 skipping to change at page 29, line 21
/// = NFL42_UFLG_IO_ADVISE_THRU_MDS, /// = NFL42_UFLG_IO_ADVISE_THRU_MDS,
/// ///
/// NFLH4_CARE_STRIPE_UNIT_SIZE /// NFLH4_CARE_STRIPE_UNIT_SIZE
/// = 0x00000040, /// = 0x00000040,
/// ///
/// NFLH4_CARE_STRIPE_COUNT = 0x00000080 /// NFLH4_CARE_STRIPE_COUNT = 0x00000080
/// }; /// };
/// % /// %
/// %/* /// %/*
/// % * Encoded in the loh_body field of data type layouthint4: /// % * Encoded in the loh_body field of data type layouthint4:
/// %*/ /// % */
/// % /// %
/// struct nfsv4_1_file_layouthint4 { /// struct nfsv4_1_file_layouthint4 {
/// uint32_t nflh_care; /// uint32_t nflh_care;
/// nfl_util4 nflh_util; /// nfl_util4 nflh_util;
/// count4 nflh_stripe_count; /// count4 nflh_stripe_count;
/// }; /// };
/// ///
/// % /// %
/// ///
/// % /// %
/// typedef netaddr4 multipath_list4<>; /// typedef netaddr4 multipath_list4<>;
/// % /// %
/// %/* /// %/*
/// % * Encoded in the da_addr_body field of data type device_addr4: /// % * Encoded in the da_addr_body field of data type device_addr4:
/// %*/ /// % */
/// struct nfsv4_1_file_layout_ds_addr4 { /// struct nfsv4_1_file_layout_ds_addr4 {
/// uint32_t nflda_stripe_indices<>; /// uint32_t nflda_stripe_indices<>;
/// multipath_list4 nflda_multipath_ds_list<>; /// multipath_list4 nflda_multipath_ds_list<>;
/// }; /// };
/// ///
/// % /// %
/// ///
/// % /// %
/// %/* /// %/*
/// % * Encoded in the loc_body field of data type layout_content4: /// % * Encoded in the loc_body field of data type layout_content4:
/// %*/ /// % */
/// struct nfsv4_1_file_layout4 { /// struct nfsv4_1_file_layout4 {
/// deviceid4 nfl_deviceid; /// deviceid4 nfl_deviceid;
/// nfl_util4 nfl_util; /// nfl_util4 nfl_util;
/// uint32_t nfl_first_stripe_index; /// uint32_t nfl_first_stripe_index;
/// offset4 nfl_pattern_offset; /// offset4 nfl_pattern_offset;
/// nfs_fh4 nfl_fh_list<>; /// nfs_fh4 nfl_fh_list<>;
/// }; /// };
/// ///
/// % /// %
/// ///
/// ///
/// /* /// /*
/// * Operation arrays (the opnum first) /// * Operation arrays (the opnum first)
/// */ /// */
/// ///
/// enum nfs_opnum4 { /// enum nfs_opnum4 {
/// OP_ACCESS = 3, /// OP_ACCESS = 3,
/// OP_CLOSE = 4, /// OP_CLOSE = 4,
/// OP_COMMIT = 5, /// OP_COMMIT = 5,
/// OP_CREATE = 6, /// OP_CREATE = 6,
/// OP_DELEGPURGE = 7, /// OP_DELEGPURGE = 7,
/// OP_DELEGRETURN = 8, /// OP_DELEGRETURN = 8,
/// OP_GETATTR = 9, /// OP_GETATTR = 9,
/// OP_GETFH = 10, /// OP_GETFH = 10,
/// OP_LINK = 11, /// OP_LINK = 11,
/// OP_LOCK = 12, /// OP_LOCK = 12,
/// OP_LOCKT = 13, /// OP_LOCKT = 13,
/// OP_LOCKU = 14, /// OP_LOCKU = 14,
/// OP_LOOKUP = 15, /// OP_LOOKUP = 15,
/// OP_LOOKUPP = 16, /// OP_LOOKUPP = 16,
/// OP_NVERIFY = 17, /// OP_NVERIFY = 17,
/// OP_OPEN = 18, /// OP_OPEN = 18,
/// OP_OPENATTR = 19, /// OP_OPENATTR = 19,
/// OP_OPEN_CONFIRM = 20, /* Mandatory not-to-implement */ /// OP_OPEN_CONFIRM = 20, /* Mandatory not-to-implement */
/// OP_OPEN_DOWNGRADE = 21, /// OP_OPEN_DOWNGRADE = 21,
/// OP_PUTFH = 22, /// OP_PUTFH = 22,
/// OP_PUTPUBFH = 23, /// OP_PUTPUBFH = 23,
/// OP_PUTROOTFH = 24, /// OP_PUTROOTFH = 24,
/// OP_READ = 25, /// OP_READ = 25,
/// OP_READDIR = 26, /// OP_READDIR = 26,
/// OP_READLINK = 27, /// OP_READLINK = 27,
/// OP_REMOVE = 28, /// OP_REMOVE = 28,
/// OP_RENAME = 29, /// OP_RENAME = 29,
/// OP_RENEW = 30, /* Mandatory not-to-implement */ /// OP_RENEW = 30, /* Mandatory not-to-implement */
/// OP_RESTOREFH = 31, /// OP_RESTOREFH = 31,
/// OP_SAVEFH = 32, /// OP_SAVEFH = 32,
/// OP_SECINFO = 33, /// OP_SECINFO = 33,
/// OP_SETATTR = 34, /// OP_SETATTR = 34,
/// OP_SETCLIENTID = 35, /* Mandatory not-to-implement */ /// OP_SETCLIENTID = 35, /* Mandatory not-to-implement */
/// OP_SETCLIENTID_CONFIRM = 36, /* Mandatory not-to-implement */ /// OP_SETCLIENTID_CONFIRM = 36, /* Mandatory not-to-implement */
/// OP_VERIFY = 37, /// OP_VERIFY = 37,
/// OP_WRITE = 38, /// OP_WRITE = 38,
/// OP_RELEASE_LOCKOWNER = 39, /* Mandatory not-to-implement */ /// OP_RELEASE_LOCKOWNER = 39, /* Mandatory not-to-implement */
/// % /// %
/// %/* new operations for NFSv4.1 */ /// %/* New operations for NFSv4.1 */
/// % /// %
/// OP_BACKCHANNEL_CTL = 40, /// OP_BACKCHANNEL_CTL = 40,
/// OP_BIND_CONN_TO_SESSION = 41, /// OP_BIND_CONN_TO_SESSION = 41,
/// OP_EXCHANGE_ID = 42, /// OP_EXCHANGE_ID = 42,
/// OP_CREATE_SESSION = 43, /// OP_CREATE_SESSION = 43,
/// OP_DESTROY_SESSION = 44, /// OP_DESTROY_SESSION = 44,
/// OP_FREE_STATEID = 45, /// OP_FREE_STATEID = 45,
/// OP_GET_DIR_DELEGATION = 46, /// OP_GET_DIR_DELEGATION = 46,
/// OP_GETDEVICEINFO = 47, /// OP_GETDEVICEINFO = 47,
/// OP_GETDEVICELIST = 48, /// OP_GETDEVICELIST = 48,
/// OP_LAYOUTCOMMIT = 49, /// OP_LAYOUTCOMMIT = 49,
/// OP_LAYOUTGET = 50, /// OP_LAYOUTGET = 50,
/// OP_LAYOUTRETURN = 51, /// OP_LAYOUTRETURN = 51,
/// OP_SECINFO_NO_NAME = 52, /// OP_SECINFO_NO_NAME = 52,
/// OP_SEQUENCE = 53, /// OP_SEQUENCE = 53,
/// OP_SET_SSV = 54, /// OP_SET_SSV = 54,
/// OP_TEST_STATEID = 55, /// OP_TEST_STATEID = 55,
/// OP_WANT_DELEGATION = 56, /// OP_WANT_DELEGATION = 56,
/// OP_DESTROY_CLIENTID = 57, /// OP_DESTROY_CLIENTID = 57,
/// OP_RECLAIM_COMPLETE = 58, /// OP_RECLAIM_COMPLETE = 58,
/// % /// %
/// %/* new operations for NFSv4.2 */ /// %/* New operations for NFSv4.2 */
/// % /// %
/// OP_ALLOCATE = 59, /// OP_ALLOCATE = 59,
/// OP_COPY = 60, /// OP_COPY = 60,
/// OP_COPY_NOTIFY = 61, /// OP_COPY_NOTIFY = 61,
/// OP_DEALLOCATE = 62, /// OP_DEALLOCATE = 62,
/// OP_IO_ADVISE = 63, /// OP_IO_ADVISE = 63,
/// OP_LAYOUTERROR = 64, /// OP_LAYOUTERROR = 64,
/// OP_LAYOUTSTATS = 65, /// OP_LAYOUTSTATS = 65,
/// OP_OFFLOAD_CANCEL = 66, /// OP_OFFLOAD_CANCEL = 66,
/// OP_OFFLOAD_STATUS = 67, /// OP_OFFLOAD_STATUS = 67,
/// OP_READ_PLUS = 68, /// OP_READ_PLUS = 68,
/// OP_SEEK = 69, /// OP_SEEK = 69,
/// OP_WRITE_SAME = 70, /// OP_WRITE_SAME = 70,
/// OP_CLONE = 71, /// OP_CLONE = 71,
/// OP_ILLEGAL = 10044 /// OP_ILLEGAL = 10044
/// }; /// };
/// ///
/// ///
/// ///
/// const ACCESS4_READ = 0x00000001; /// const ACCESS4_READ = 0x00000001;
/// const ACCESS4_LOOKUP = 0x00000002; /// const ACCESS4_LOOKUP = 0x00000002;
/// const ACCESS4_MODIFY = 0x00000004; /// const ACCESS4_MODIFY = 0x00000004;
/// const ACCESS4_EXTEND = 0x00000008; /// const ACCESS4_EXTEND = 0x00000008;
/// const ACCESS4_DELETE = 0x00000010; /// const ACCESS4_DELETE = 0x00000010;
/// const ACCESS4_EXECUTE = 0x00000020; /// const ACCESS4_EXECUTE = 0x00000020;
/// ///
/// struct ACCESS4args { /// struct ACCESS4args {
/// /* CURRENT_FH: object */ /// /* CURRENT_FH: object */
/// uint32_t access; /// uint32_t access;
/// }; /// };
/// ///
/// struct ACCESS4resok { /// struct ACCESS4resok {
/// uint32_t supported; /// uint32_t supported;
/// uint32_t access; /// uint32_t access;
/// }; /// };
/// ///
/// union ACCESS4res switch (nfsstat4 status) { /// union ACCESS4res switch (nfsstat4 status) {
/// case NFS4_OK: /// case NFS4_OK:
/// ACCESS4resok resok4; /// ACCESS4resok resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct CLONE4args { /// struct CLONE4args {
/// /* SAVED_FH: source file */ /// /* SAVED_FH: source file */
/// /* CURRENT_FH: destination file */ /// /* CURRENT_FH: destination file */
/// stateid4 cl_src_stateid; /// stateid4 cl_src_stateid;
/// stateid4 cl_dst_stateid; /// stateid4 cl_dst_stateid;
/// offset4 cl_src_offset; /// offset4 cl_src_offset;
/// offset4 cl_dst_offset; /// offset4 cl_dst_offset;
/// length4 cl_count; /// length4 cl_count;
skipping to change at page 32, line 28 skipping to change at page 34, line 15
/// case NF4LNK: /// case NF4LNK:
/// linktext4 linkdata; /// linktext4 linkdata;
/// case NF4BLK: /// case NF4BLK:
/// case NF4CHR: /// case NF4CHR:
/// specdata4 devdata; /// specdata4 devdata;
/// case NF4SOCK: /// case NF4SOCK:
/// case NF4FIFO: /// case NF4FIFO:
/// case NF4DIR: /// case NF4DIR:
/// void; /// void;
/// default: /// default:
/// void; /* server should return NFS4ERR_BADTYPE */ /// void; /* Server should return NFS4ERR_BADTYPE. */
/// }; /// };
/// ///
/// struct CREATE4args { /// struct CREATE4args {
/// /* CURRENT_FH: directory for creation */ /// /* CURRENT_FH: directory for creation */
/// createtype4 objtype; /// createtype4 objtype;
/// component4 objname; /// component4 objname;
/// fattr4 createattrs; /// fattr4 createattrs;
/// }; /// };
/// ///
/// struct CREATE4resok { /// struct CREATE4resok {
/// change_info4 cinfo; /// change_info4 cinfo;
/// bitmap4 attrset; /* attributes set */ /// bitmap4 attrset; /* Attributes set */
/// }; /// };
/// ///
/// union CREATE4res switch (nfsstat4 status) { /// union CREATE4res switch (nfsstat4 status) {
/// case NFS4_OK: /// case NFS4_OK:
/// /* new CURRENTFH: created object */ /// /* New CURRENTFH: created object */
/// CREATE4resok resok4; /// CREATE4resok resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct DELEGPURGE4args { /// struct DELEGPURGE4args {
/// clientid4 clientid; /// clientid4 clientid;
/// }; /// };
/// ///
/// struct DELEGPURGE4res { /// struct DELEGPURGE4res {
skipping to change at page 33, line 42 skipping to change at page 35, line 30
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct GETFH4resok { /// struct GETFH4resok {
/// nfs_fh4 object; /// nfs_fh4 object;
/// }; /// };
/// ///
/// union GETFH4res switch (nfsstat4 status) { /// union GETFH4res switch (nfsstat4 status) {
/// case NFS4_OK: /// case NFS4_OK:
/// GETFH4resok resok4; /// GETFH4resok resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct LINK4args { /// struct LINK4args {
/// /* SAVED_FH: source object */ /// /* SAVED_FH: source object */
/// /* CURRENT_FH: target directory */ /// /* CURRENT_FH: target directory */
/// component4 newname; /// component4 newname;
/// }; /// };
/// ///
/// struct LINK4resok { /// struct LINK4resok {
/// change_info4 cinfo; /// change_info4 cinfo;
skipping to change at page 34, line 28 skipping to change at page 36, line 16
/// * to a lock stateid. /// * to a lock stateid.
/// */ /// */
/// struct open_to_lock_owner4 { /// struct open_to_lock_owner4 {
/// seqid4 open_seqid; /// seqid4 open_seqid;
/// stateid4 open_stateid; /// stateid4 open_stateid;
/// seqid4 lock_seqid; /// seqid4 lock_seqid;
/// lock_owner4 lock_owner; /// lock_owner4 lock_owner;
/// }; /// };
/// ///
/// /* /// /*
/// * For LOCK, existing lock stateid continues to request new /// * For LOCK, existing lock stateid continues to request new
/// * file lock for the same lock_owner and open_stateid. /// * file lock for the same lock_owner and open_stateid.
/// */ /// */
/// struct exist_lock_owner4 { /// struct exist_lock_owner4 {
/// stateid4 lock_stateid; /// stateid4 lock_stateid;
/// seqid4 lock_seqid; /// seqid4 lock_seqid;
/// }; /// };
/// ///
/// union locker4 switch (bool new_lock_owner) { /// union locker4 switch (bool new_lock_owner) {
/// case TRUE: /// case TRUE:
/// open_to_lock_owner4 open_owner; /// open_to_lock_owner4 open_owner;
skipping to change at page 36, line 6 skipping to change at page 37, line 44
/// struct LOCKU4args { /// struct LOCKU4args {
/// /* CURRENT_FH: file */ /// /* CURRENT_FH: file */
/// nfs_lock_type4 locktype; /// nfs_lock_type4 locktype;
/// seqid4 seqid; /// seqid4 seqid;
/// stateid4 lock_stateid; /// stateid4 lock_stateid;
/// offset4 offset; /// offset4 offset;
/// length4 length; /// length4 length;
/// }; /// };
/// ///
/// union LOCKU4res switch (nfsstat4 status) { /// union LOCKU4res switch (nfsstat4 status) {
/// case NFS4_OK: /// case NFS4_OK:
/// stateid4 lock_stateid; /// stateid4 lock_stateid;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct LOOKUP4args { /// struct LOOKUP4args {
/// /* CURRENT_FH: directory */ /// /* CURRENT_FH: directory */
/// component4 objname; /// component4 objname;
/// }; /// };
/// ///
/// struct LOOKUP4res { /// struct LOOKUP4res {
/// /* New CURRENT_FH: object */ /// /* New CURRENT_FH: object */
/// nfsstat4 status; /// nfsstat4 status;
/// }; /// };
/// ///
/// struct LOOKUPP4res { /// struct LOOKUPP4res {
/// /* new CURRENT_FH: parent directory */ /// /* New CURRENT_FH: parent directory */
/// nfsstat4 status; /// nfsstat4 status;
/// }; /// };
/// ///
/// struct NVERIFY4args { /// struct NVERIFY4args {
/// /* CURRENT_FH: object */ /// /* CURRENT_FH: object */
/// fattr4 obj_attributes; /// fattr4 obj_attributes;
/// }; /// };
/// ///
/// struct NVERIFY4res { /// struct NVERIFY4res {
/// nfsstat4 status; /// nfsstat4 status;
/// }; /// };
/// ///
/// /* /// /*
/// * Various definitions for OPEN /// * Various definitions for OPEN
/// */ /// */
/// enum createmode4 { /// enum createmode4 {
/// UNCHECKED4 = 0, /// UNCHECKED4 = 0,
/// GUARDED4 = 1, /// GUARDED4 = 1,
/// /* Deprecated in NFSv4.1. */ /// /* Deprecated in NFSv4.1 */
/// EXCLUSIVE4 = 2, /// EXCLUSIVE4 = 2,
/// /* /// /*
/// * New to NFSv4.1. If session is persistent, /// * New to NFSv4.1. If session is persistent,
/// * GUARDED4 MUST be used. Otherwise, use /// * GUARDED4 MUST be used. Otherwise, use
/// * EXCLUSIVE4_1 instead of EXCLUSIVE4. /// * EXCLUSIVE4_1 instead of EXCLUSIVE4.
/// */ /// */
/// EXCLUSIVE4_1 = 3 /// EXCLUSIVE4_1 = 3
/// }; /// };
/// ///
/// struct creatverfattr { /// struct creatverfattr {
/// verifier4 cva_verf; /// verifier4 cva_verf;
/// fattr4 cva_attrs; /// fattr4 cva_attrs;
/// }; /// };
/// ///
skipping to change at page 37, line 35 skipping to change at page 39, line 30
/// case OPEN4_CREATE: /// case OPEN4_CREATE:
/// createhow4 how; /// createhow4 how;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// /* Next definitions used for OPEN delegation */ /// /* Next definitions used for OPEN delegation */
/// enum limit_by4 { /// enum limit_by4 {
/// NFS_LIMIT_SIZE = 1, /// NFS_LIMIT_SIZE = 1,
/// NFS_LIMIT_BLOCKS = 2 /// NFS_LIMIT_BLOCKS = 2
/// /* others as needed */ /// /* Others as needed */
/// }; /// };
/// ///
/// struct nfs_modified_limit4 { /// struct nfs_modified_limit4 {
/// uint32_t num_blocks; /// uint32_t num_blocks;
/// uint32_t bytes_per_block; /// uint32_t bytes_per_block;
/// }; /// };
/// ///
/// union nfs_space_limit4 switch (limit_by4 limitby) { /// union nfs_space_limit4 switch (limit_by4 limitby) {
/// /* limit specified as file size */ /// /* Limit specified as file size */
/// case NFS_LIMIT_SIZE: /// case NFS_LIMIT_SIZE:
/// uint64_t filesize; /// uint64_t filesize;
/// /* limit specified by number of blocks */ /// /* Limit specified by number of blocks */
/// case NFS_LIMIT_BLOCKS: /// case NFS_LIMIT_BLOCKS:
/// nfs_modified_limit4 mod_blocks; /// nfs_modified_limit4 mod_blocks;
/// } ; /// };
/// ///
/// /* /// /*
/// * Share Access and Deny constants for open argument /// * Share Access and Deny constants for open argument
/// */ /// */
/// const OPEN4_SHARE_ACCESS_READ = 0x00000001; /// const OPEN4_SHARE_ACCESS_READ = 0x00000001;
/// const OPEN4_SHARE_ACCESS_WRITE = 0x00000002; /// const OPEN4_SHARE_ACCESS_WRITE = 0x00000002;
/// const OPEN4_SHARE_ACCESS_BOTH = 0x00000003; /// const OPEN4_SHARE_ACCESS_BOTH = 0x00000003;
/// ///
/// const OPEN4_SHARE_DENY_NONE = 0x00000000; /// const OPEN4_SHARE_DENY_NONE = 0x00000000;
/// const OPEN4_SHARE_DENY_READ = 0x00000001; /// const OPEN4_SHARE_DENY_READ = 0x00000001;
/// const OPEN4_SHARE_DENY_WRITE = 0x00000002; /// const OPEN4_SHARE_DENY_WRITE = 0x00000002;
/// const OPEN4_SHARE_DENY_BOTH = 0x00000003; /// const OPEN4_SHARE_DENY_BOTH = 0x00000003;
/// ///
/// ///
/// /* new flags for share_access field of OPEN4args */ /// /* New flags for share_access field of OPEN4args */
/// const OPEN4_SHARE_ACCESS_WANT_DELEG_MASK = 0xFF00; /// const OPEN4_SHARE_ACCESS_WANT_DELEG_MASK = 0xFF00;
/// const OPEN4_SHARE_ACCESS_WANT_NO_PREFERENCE = 0x0000; /// const OPEN4_SHARE_ACCESS_WANT_NO_PREFERENCE = 0x0000;
/// const OPEN4_SHARE_ACCESS_WANT_READ_DELEG = 0x0100; /// const OPEN4_SHARE_ACCESS_WANT_READ_DELEG = 0x0100;
/// const OPEN4_SHARE_ACCESS_WANT_WRITE_DELEG = 0x0200; /// const OPEN4_SHARE_ACCESS_WANT_WRITE_DELEG = 0x0200;
/// const OPEN4_SHARE_ACCESS_WANT_ANY_DELEG = 0x0300; /// const OPEN4_SHARE_ACCESS_WANT_ANY_DELEG = 0x0300;
/// const OPEN4_SHARE_ACCESS_WANT_NO_DELEG = 0x0400; /// const OPEN4_SHARE_ACCESS_WANT_NO_DELEG = 0x0400;
/// const OPEN4_SHARE_ACCESS_WANT_CANCEL = 0x0500; /// const OPEN4_SHARE_ACCESS_WANT_CANCEL = 0x0500;
/// ///
/// const /// const
/// OPEN4_SHARE_ACCESS_WANT_SIGNAL_DELEG_WHEN_RESRC_AVAIL /// OPEN4_SHARE_ACCESS_WANT_SIGNAL_DELEG_WHEN_RESRC_AVAIL
/// = 0x10000; /// = 0x10000;
/// ///
/// const /// const
/// OPEN4_SHARE_ACCESS_WANT_PUSH_DELEG_WHEN_UNCONTENDED /// OPEN4_SHARE_ACCESS_WANT_PUSH_DELEG_WHEN_UNCONTENDED
/// = 0x20000; /// = 0x20000;
/// ///
/// enum open_delegation_type4 { /// enum open_delegation_type4 {
/// OPEN_DELEGATE_NONE = 0, /// OPEN_DELEGATE_NONE = 0,
/// OPEN_DELEGATE_READ = 1, /// OPEN_DELEGATE_READ = 1,
/// OPEN_DELEGATE_WRITE = 2, /// OPEN_DELEGATE_WRITE = 2,
/// OPEN_DELEGATE_NONE_EXT = 3 /* new to v4.1 */ /// OPEN_DELEGATE_NONE_EXT = 3 /* New to NFSv4.1 */
/// }; /// };
/// ///
/// enum open_claim_type4 { /// enum open_claim_type4 {
/// /* /// /*
/// * Not a reclaim. /// * Not a reclaim
/// */ /// */
/// CLAIM_NULL = 0, /// CLAIM_NULL = 0,
/// ///
/// CLAIM_PREVIOUS = 1, /// CLAIM_PREVIOUS = 1,
/// CLAIM_DELEGATE_CUR = 2, /// CLAIM_DELEGATE_CUR = 2,
/// CLAIM_DELEGATE_PREV = 3, /// CLAIM_DELEGATE_PREV = 3,
/// ///
/// /* /// /*
/// * Not a reclaim. /// * Not a reclaim
/// * /// *
/// * Like CLAIM_NULL, but object identified /// * Like CLAIM_NULL, but object identified
/// * by the current filehandle. /// * by the current filehandle
/// */ /// */
/// CLAIM_FH = 4, /* new to v4.1 */ /// CLAIM_FH = 4, /* New to NFSv4.1 */
/// ///
/// /* /// /*
/// * Like CLAIM_DELEGATE_CUR, but object identified /// * Like CLAIM_DELEGATE_CUR, but object identified
/// * by current filehandle. /// * by current filehandle
/// */ /// */
/// CLAIM_DELEG_CUR_FH = 5, /* new to v4.1 */ /// CLAIM_DELEG_CUR_FH = 5, /* New to NFSv4.1 */
/// ///
/// /* /// /*
/// * Like CLAIM_DELEGATE_PREV, but object identified /// * Like CLAIM_DELEGATE_PREV, but object identified
/// * by current filehandle. /// * by current filehandle
/// */ /// */
/// CLAIM_DELEG_PREV_FH = 6 /* new to v4.1 */ /// CLAIM_DELEG_PREV_FH = 6 /* New to NFSv4.1 */
/// }; /// };
/// ///
/// struct open_claim_delegate_cur4 { /// struct open_claim_delegate_cur4 {
/// stateid4 delegate_stateid; /// stateid4 delegate_stateid;
/// component4 file; /// component4 file;
/// }; /// };
/// ///
/// union open_claim4 switch (open_claim_type4 claim) { /// union open_claim4 switch (open_claim_type4 claim) {
/// /* /// /*
/// * No special rights to file. /// * No special rights to file.
/// * Ordinary OPEN of the specified file. /// * Ordinary OPEN of the specified file.
/// */ /// */
/// case CLAIM_NULL: /// case CLAIM_NULL:
/// /* CURRENT_FH: directory */ /// /* CURRENT_FH: directory */
/// component4 file; /// component4 file;
/// /* /// /*
/// * Right to the file established by an /// * Right to the file established by an
/// * open previous to server reboot. File /// * open previous to server reboot. File
/// * identified by filehandle obtained at /// * identified by filehandle obtained at
/// * that time rather than by name. /// * that time rather than by name.
/// */ /// */
/// case CLAIM_PREVIOUS: /// case CLAIM_PREVIOUS:
/// /* CURRENT_FH: file being reclaimed */ /// /* CURRENT_FH: file being reclaimed */
/// open_delegation_type4 delegate_type; /// open_delegation_type4 delegate_type;
/// ///
/// /* /// /*
/// * Right to file based on a delegation /// * Right to file based on a delegation
/// * granted by the server. File is /// * granted by the server. File is
/// * specified by name. /// * specified by name.
/// */ /// */
/// case CLAIM_DELEGATE_CUR: /// case CLAIM_DELEGATE_CUR:
/// /* CURRENT_FH: directory */ /// /* CURRENT_FH: directory */
/// open_claim_delegate_cur4 delegate_cur_info; /// open_claim_delegate_cur4 delegate_cur_info;
/// ///
/// /* /// /*
/// * Right to file based on a delegation /// * Right to file based on a delegation
/// * granted to a previous boot instance /// * granted to a previous boot instance
/// * of the client. File is specified by name. /// * of the client. File is specified by name.
/// */ /// */
/// case CLAIM_DELEGATE_PREV: /// case CLAIM_DELEGATE_PREV:
/// /* CURRENT_FH: directory */ /// /* CURRENT_FH: directory */
/// component4 file_delegate_prev; /// component4 file_delegate_prev;
/// ///
/// /* /// /*
/// * Like CLAIM_NULL. No special rights /// * Like CLAIM_NULL. No special rights
/// * to file. Ordinary OPEN of the /// * to file. Ordinary OPEN of the
/// * specified file by current filehandle. /// * specified file by current filehandle.
/// */ /// */
/// case CLAIM_FH: /* new to v4.1 */ /// case CLAIM_FH: /* New to NFSv4.1 */
/// /* CURRENT_FH: regular file to open */ /// /* CURRENT_FH: regular file to open */
/// void; /// void;
/// ///
/// /* /// /*
/// * Like CLAIM_DELEGATE_PREV. Right to file based on a /// * Like CLAIM_DELEGATE_PREV. Right to file based on a
/// * delegation granted to a previous boot /// * delegation granted to a previous boot
/// * instance of the client. File is identified by /// * instance of the client. File is identified
/// * by filehandle. /// * by filehandle.
/// */ /// */
/// case CLAIM_DELEG_PREV_FH: /* new to v4.1 */ /// case CLAIM_DELEG_PREV_FH: /* New to NFSv4.1 */
/// /* CURRENT_FH: file being opened */ /// /* CURRENT_FH: file being opened */
/// void; /// void;
/// ///
/// /* /// /*
/// * Like CLAIM_DELEGATE_CUR. Right to file based on /// * Like CLAIM_DELEGATE_CUR. Right to file based on
/// * a delegation granted by the server. /// * a delegation granted by the server.
/// * File is identified by filehandle. /// * File is identified by filehandle.
/// */ /// */
/// case CLAIM_DELEG_CUR_FH: /* new to v4.1 */ /// case CLAIM_DELEG_CUR_FH: /* New to NFSv4.1 */
/// /* CURRENT_FH: file being opened */ /// /* CURRENT_FH: file being opened */
/// stateid4 oc_delegate_stateid; /// stateid4 oc_delegate_stateid;
/// ///
/// }; /// };
/// ///
/// /* /// /*
/// * OPEN: Open a file, potentially receiving an open delegation /// * OPEN: Open a file, potentially receiving an open delegation.
/// */ /// */
/// struct OPEN4args { /// struct OPEN4args {
/// seqid4 seqid; /// seqid4 seqid;
/// uint32_t share_access; /// uint32_t share_access;
/// uint32_t share_deny; /// uint32_t share_deny;
/// open_owner4 owner; /// open_owner4 owner;
/// openflag4 openhow; /// openflag4 openhow;
/// open_claim4 claim; /// open_claim4 claim;
/// }; /// };
/// ///
/// struct open_read_delegation4 { /// struct open_read_delegation4 {
/// stateid4 stateid; /* Stateid for delegation*/ /// stateid4 stateid; /* Stateid for delegation */
/// bool recall; /* Pre-recalled flag for /// bool recall; /* Pre-recalled flag for
/// delegations obtained /// delegations obtained
/// by reclaim (CLAIM_PREVIOUS) */ /// by reclaim (CLAIM_PREVIOUS) */
/// ///
/// nfsace4 permissions; /* Defines users who don't /// nfsace4 permissions; /* Defines users who don't
/// need an ACCESS call to /// need an ACCESS call to
/// open for read */ /// open for read */
/// }; /// };
/// ///
/// struct open_write_delegation4 { /// struct open_write_delegation4 {
skipping to change at page 41, line 34 skipping to change at page 43, line 50
/// bool recall; /* Pre-recalled flag for /// bool recall; /* Pre-recalled flag for
/// delegations obtained /// delegations obtained
/// by reclaim /// by reclaim
/// (CLAIM_PREVIOUS) */ /// (CLAIM_PREVIOUS) */
/// ///
/// nfs_space_limit4 /// nfs_space_limit4
/// space_limit; /* Defines condition that /// space_limit; /* Defines condition that
/// the client must check to /// the client must check to
/// determine whether the /// determine whether the
/// file needs to be flushed /// file needs to be flushed
/// to the server on close. */ /// to the server on close */
/// ///
/// nfsace4 permissions; /* Defines users who don't /// nfsace4 permissions; /* Defines users who don't
/// need an ACCESS call as /// need an ACCESS call as
/// part of a delegated /// part of a delegated
/// open. */ /// open */
/// }; /// };
/// ///
/// ///
/// enum why_no_delegation4 { /* new to v4.1 */ /// enum why_no_delegation4 { /* New to NFSv4.1 */
/// WND4_NOT_WANTED = 0, /// WND4_NOT_WANTED = 0,
/// WND4_CONTENTION = 1, /// WND4_CONTENTION = 1,
/// WND4_RESOURCE = 2, /// WND4_RESOURCE = 2,
/// WND4_NOT_SUPP_FTYPE = 3, /// WND4_NOT_SUPP_FTYPE = 3,
/// WND4_WRITE_DELEG_NOT_SUPP_FTYPE = 4, /// WND4_WRITE_DELEG_NOT_SUPP_FTYPE = 4,
/// WND4_NOT_SUPP_UPGRADE = 5, /// WND4_NOT_SUPP_UPGRADE = 5,
/// WND4_NOT_SUPP_DOWNGRADE = 6, /// WND4_NOT_SUPP_DOWNGRADE = 6,
/// WND4_CANCELLED = 7, /// WND4_CANCELLED = 7,
/// WND4_IS_DIR = 8 /// WND4_IS_DIR = 8
/// }; /// };
/// ///
/// union open_none_delegation4 /* new to v4.1 */ /// union open_none_delegation4 /* New to NFSv4.1 */
/// switch (why_no_delegation4 ond_why) { /// switch (why_no_delegation4 ond_why) {
/// case WND4_CONTENTION: /// case WND4_CONTENTION:
/// bool ond_server_will_push_deleg; /// bool ond_server_will_push_deleg;
/// case WND4_RESOURCE: /// case WND4_RESOURCE:
/// bool ond_server_will_signal_avail; /// bool ond_server_will_signal_avail;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// union open_delegation4 /// union open_delegation4
/// switch (open_delegation_type4 delegation_type) { /// switch (open_delegation_type4 delegation_type) {
/// case OPEN_DELEGATE_NONE: /// case OPEN_DELEGATE_NONE:
/// void; /// void;
/// case OPEN_DELEGATE_READ: /// case OPEN_DELEGATE_READ:
/// open_read_delegation4 read; /// open_read_delegation4 read;
/// case OPEN_DELEGATE_WRITE: /// case OPEN_DELEGATE_WRITE:
/// open_write_delegation4 write; /// open_write_delegation4 write;
/// case OPEN_DELEGATE_NONE_EXT: /* new to v4.1 */ /// case OPEN_DELEGATE_NONE_EXT: /* New to NFSv4.1 */
/// open_none_delegation4 od_whynone; /// open_none_delegation4 od_whynone;
/// }; /// };
/// ///
/// /* /// /*
/// * Result flags /// * Result flags
/// */ /// */
/// ///
/// /* Client must confirm open */ /// /* Client must confirm open. */
/// const OPEN4_RESULT_CONFIRM = 0x00000002; /// const OPEN4_RESULT_CONFIRM = 0x00000002;
/// /* Type of file locking behavior at the server */ /// /* Type of file-locking behavior at the server */
/// const OPEN4_RESULT_LOCKTYPE_POSIX = 0x00000004; /// const OPEN4_RESULT_LOCKTYPE_POSIX = 0x00000004;
/// /* Server will preserve file if removed while open */ /// /* Server will preserve file if removed while open. */
/// const OPEN4_RESULT_PRESERVE_UNLINKED = 0x00000008; /// const OPEN4_RESULT_PRESERVE_UNLINKED = 0x00000008;
/// ///
/// /* /// /*
/// * Server may use CB_NOTIFY_LOCK on locks /// * Server may use CB_NOTIFY_LOCK on locks
/// * derived from this open /// * derived from this open.
/// */ /// */
/// const OPEN4_RESULT_MAY_NOTIFY_LOCK = 0x00000020; /// const OPEN4_RESULT_MAY_NOTIFY_LOCK = 0x00000020;
/// ///
/// struct OPEN4resok { /// struct OPEN4resok {
/// stateid4 stateid; /* Stateid for open */ /// stateid4 stateid; /* Stateid for open */
/// change_info4 cinfo; /* Directory Change Info */ /// change_info4 cinfo; /* Directory change info */
/// uint32_t rflags; /* Result flags */ /// uint32_t rflags; /* Result flags */
/// bitmap4 attrset; /* attribute set for create*/ /// bitmap4 attrset; /* Attribute set for create */
/// open_delegation4 delegation; /* Info on any open /// open_delegation4 delegation; /* Info on any open
/// delegation */ /// delegation */
/// }; /// };
/// ///
/// union OPEN4res switch (nfsstat4 status) { /// union OPEN4res switch (nfsstat4 status) {
/// case NFS4_OK: /// case NFS4_OK:
/// /* New CURRENT_FH: opened file */ /// /* New CURRENT_FH: opened file */
/// OPEN4resok resok4; /// OPEN4resok resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct OPENATTR4args { /// struct OPENATTR4args {
/// /* CURRENT_FH: object */ /// /* CURRENT_FH: object */
/// bool createdir; /// bool createdir;
/// }; /// };
/// ///
/// struct OPENATTR4res { /// struct OPENATTR4res {
/// /* /// /*
/// * If status is NFS4_OK, /// * If status is NFS4_OK,
/// * new CURRENT_FH: named attribute /// * New CURRENT_FH: named attribute
/// * directory /// * directory
/// */ /// */
/// nfsstat4 status; /// nfsstat4 status;
/// }; /// };
/// ///
/// /* obsolete in NFSv4.1 */ /// /* Obsolete in NFSv4.1 */
/// struct OPEN_CONFIRM4args { /// struct OPEN_CONFIRM4args {
/// /* CURRENT_FH: opened file */ /// /* CURRENT_FH: opened file */
/// stateid4 open_stateid; /// stateid4 open_stateid;
/// seqid4 seqid; /// seqid4 seqid;
/// }; /// };
/// ///
/// struct OPEN_CONFIRM4resok { /// struct OPEN_CONFIRM4resok {
/// stateid4 open_stateid; /// stateid4 open_stateid;
/// }; /// };
/// ///
skipping to change at page 44, line 11 skipping to change at page 46, line 34
/// stateid4 open_stateid; /// stateid4 open_stateid;
/// seqid4 seqid; /// seqid4 seqid;
/// uint32_t share_access; /// uint32_t share_access;
/// uint32_t share_deny; /// uint32_t share_deny;
/// }; /// };
/// ///
/// struct OPEN_DOWNGRADE4resok { /// struct OPEN_DOWNGRADE4resok {
/// stateid4 open_stateid; /// stateid4 open_stateid;
/// }; /// };
/// ///
/// union OPEN_DOWNGRADE4res switch(nfsstat4 status) { /// union OPEN_DOWNGRADE4res switch (nfsstat4 status) {
/// case NFS4_OK: /// case NFS4_OK:
/// OPEN_DOWNGRADE4resok resok4; /// OPEN_DOWNGRADE4resok resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct PUTFH4args { /// struct PUTFH4args {
/// nfs_fh4 object; /// nfs_fh4 object;
/// }; /// };
/// ///
/// struct PUTFH4res { /// struct PUTFH4res {
/// /* /// /*
/// * If status is NFS4_OK, /// * If status is NFS4_OK,
/// * new CURRENT_FH: argument to PUTFH /// * New CURRENT_FH: argument to PUTFH
/// */ /// */
/// nfsstat4 status; /// nfsstat4 status;
/// }; /// };
/// ///
/// struct PUTPUBFH4res { /// struct PUTPUBFH4res {
/// /* /// /*
/// * If status is NFS4_OK, /// * If status is NFS4_OK,
/// * new CURRENT_FH: public fh /// * New CURRENT_FH: public fh
/// */ /// */
/// nfsstat4 status; /// nfsstat4 status;
/// }; /// };
/// ///
/// struct PUTROOTFH4res { /// struct PUTROOTFH4res {
/// /* /// /*
/// * If status is NFS4_OK, /// * If status is NFS4_OK,
/// * new CURRENT_FH: root fh /// * New CURRENT_FH: root fh
/// */ /// */
/// nfsstat4 status; /// nfsstat4 status;
/// }; /// };
/// ///
/// struct READ4args { /// struct READ4args {
/// /* CURRENT_FH: file */ /// /* CURRENT_FH: file */
/// stateid4 stateid; /// stateid4 stateid;
/// offset4 offset; /// offset4 offset;
/// count4 count; /// count4 count;
/// }; /// };
skipping to change at page 46, line 45 skipping to change at page 49, line 25
/// component4 newname; /// component4 newname;
/// }; /// };
/// ///
/// struct RENAME4resok { /// struct RENAME4resok {
/// change_info4 source_cinfo; /// change_info4 source_cinfo;
/// change_info4 target_cinfo; /// change_info4 target_cinfo;
/// }; /// };
/// ///
/// union RENAME4res switch (nfsstat4 status) { /// union RENAME4res switch (nfsstat4 status) {
/// case NFS4_OK: /// case NFS4_OK:
/// RENAME4resok resok4; /// RENAME4resok resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// /* Obsolete in NFSv4.1 */ /// /* Obsolete in NFSv4.1 */
/// struct RENEW4args { /// struct RENEW4args {
/// clientid4 clientid; /// clientid4 clientid;
/// }; /// };
/// ///
/// struct RENEW4res { /// struct RENEW4res {
/// nfsstat4 status; /// nfsstat4 status;
/// }; /// };
/// ///
/// struct RESTOREFH4res { /// struct RESTOREFH4res {
/// /* /// /*
/// * If status is NFS4_OK, /// * If status is NFS4_OK,
/// * new CURRENT_FH: value of saved fh /// * New CURRENT_FH: value of saved fh
/// */ /// */
/// nfsstat4 status; /// nfsstat4 status;
/// }; /// };
/// ///
/// struct SAVEFH4res { /// struct SAVEFH4res {
/// /* /// /*
/// * If status is NFS4_OK, /// * If status is NFS4_OK,
/// * new SAVED_FH: value of current fh /// * New SAVED_FH: value of current fh
/// */ /// */
/// nfsstat4 status; /// nfsstat4 status;
/// }; /// };
/// ///
/// struct SECINFO4args { /// struct SECINFO4args {
/// /* CURRENT_FH: directory */ /// /* CURRENT_FH: directory */
/// component4 name; /// component4 name;
/// }; /// };
/// ///
/// /* /// /*
skipping to change at page 47, line 47 skipping to change at page 50, line 32
/// RPC_GSS_SVC_INTEGRITY = 2, /// RPC_GSS_SVC_INTEGRITY = 2,
/// RPC_GSS_SVC_PRIVACY = 3 /// RPC_GSS_SVC_PRIVACY = 3
/// }; /// };
/// ///
/// struct rpcsec_gss_info { /// struct rpcsec_gss_info {
/// sec_oid4 oid; /// sec_oid4 oid;
/// qop4 qop; /// qop4 qop;
/// rpc_gss_svc_t service; /// rpc_gss_svc_t service;
/// }; /// };
/// ///
/// /* RPCSEC_GSS has a value of '6' - See RFC 2203 */ /// /* RPCSEC_GSS has a value of "6". See RFC 2203. */
/// union secinfo4 switch (uint32_t flavor) { /// union secinfo4 switch (uint32_t flavor) {
/// case RPCSEC_GSS: /// case RPCSEC_GSS:
/// rpcsec_gss_info flavor_info; /// rpcsec_gss_info flavor_info;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// typedef secinfo4 SECINFO4resok<>; /// typedef secinfo4 SECINFO4resok<>;
/// ///
/// union SECINFO4res switch (nfsstat4 status) { /// union SECINFO4res switch (nfsstat4 status) {
/// case NFS4_OK: /// case NFS4_OK:
/// /* CURRENTFH: consumed */ /// /* CURRENTFH: consumed */
/// SECINFO4resok resok4; /// SECINFO4resok resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct SETATTR4args { /// struct SETATTR4args {
/// /* CURRENT_FH: target object */ /// /* CURRENT_FH: target object */
/// stateid4 stateid; /// stateid4 stateid;
/// fattr4 obj_attributes; /// fattr4 obj_attributes;
/// }; /// };
skipping to change at page 50, line 15 skipping to change at page 53, line 5
/// ///
/// typedef opaque gsshandle4_t<>; /// typedef opaque gsshandle4_t<>;
/// ///
/// struct gss_cb_handles4 { /// struct gss_cb_handles4 {
/// rpc_gss_svc_t gcbp_service; /* RFC 2203 */ /// rpc_gss_svc_t gcbp_service; /* RFC 2203 */
/// gsshandle4_t gcbp_handle_from_server; /// gsshandle4_t gcbp_handle_from_server;
/// gsshandle4_t gcbp_handle_from_client; /// gsshandle4_t gcbp_handle_from_client;
/// }; /// };
/// ///
/// union callback_sec_parms4 switch (uint32_t cb_secflavor) { /// union callback_sec_parms4 switch (uint32_t cb_secflavor) {
/// case AUTH_NONE: /// case AUTH_NONE:
/// void; /// void;
/// case AUTH_SYS: /// case AUTH_SYS:
/// authsys_parms cbsp_sys_cred; /* RFC 1831 */ /// authsys_parms cbsp_sys_cred; /* RFC 5531 */
/// case RPCSEC_GSS: /// case RPCSEC_GSS:
/// gss_cb_handles4 cbsp_gss_handles; /// gss_cb_handles4 cbsp_gss_handles;
/// }; /// };
/// ///
/// struct BACKCHANNEL_CTL4args { /// struct BACKCHANNEL_CTL4args {
/// uint32_t bca_cb_program; /// uint32_t bca_cb_program;
/// callback_sec_parms4 bca_sec_parms<>; /// callback_sec_parms4 bca_sec_parms<>;
/// }; /// };
/// ///
/// struct BACKCHANNEL_CTL4res { /// struct BACKCHANNEL_CTL4res {
/// nfsstat4 bcr_status; /// nfsstat4 bcr_status;
/// }; /// };
skipping to change at page 51, line 17 skipping to change at page 54, line 7
/// sessionid4 bctsr_sessid; /// sessionid4 bctsr_sessid;
/// ///
/// channel_dir_from_server4 /// channel_dir_from_server4
/// bctsr_dir; /// bctsr_dir;
/// ///
/// bool bctsr_use_conn_in_rdma_mode; /// bool bctsr_use_conn_in_rdma_mode;
/// }; /// };
/// ///
/// union BIND_CONN_TO_SESSION4res /// union BIND_CONN_TO_SESSION4res
/// switch (nfsstat4 bctsr_status) { /// switch (nfsstat4 bctsr_status) {
/// /// case NFS4_OK:
/// case NFS4_OK: /// BIND_CONN_TO_SESSION4resok bctsr_resok4;
/// BIND_CONN_TO_SESSION4resok /// default:
/// bctsr_resok4; /// void;
///
/// default: void;
/// }; /// };
/// ///
/// const EXCHGID4_FLAG_SUPP_MOVED_REFER = 0x00000001; /// const EXCHGID4_FLAG_SUPP_MOVED_REFER = 0x00000001;
/// const EXCHGID4_FLAG_SUPP_MOVED_MIGR = 0x00000002; /// const EXCHGID4_FLAG_SUPP_MOVED_MIGR = 0x00000002;
/// const EXCHGID4_FLAG_SUPP_FENCE_OPS = 0x00000004; /// const EXCHGID4_FLAG_SUPP_FENCE_OPS = 0x00000004;
/// ///
/// const EXCHGID4_FLAG_BIND_PRINC_STATEID = 0x00000100; /// const EXCHGID4_FLAG_BIND_PRINC_STATEID = 0x00000100;
/// ///
/// const EXCHGID4_FLAG_USE_NON_PNFS = 0x00010000; /// const EXCHGID4_FLAG_USE_NON_PNFS = 0x00010000;
/// const EXCHGID4_FLAG_USE_PNFS_MDS = 0x00020000; /// const EXCHGID4_FLAG_USE_PNFS_MDS = 0x00020000;
skipping to change at page 52, line 6 skipping to change at page 54, line 42
/// ///
/// struct ssv_sp_parms4 { /// struct ssv_sp_parms4 {
/// state_protect_ops4 ssp_ops; /// state_protect_ops4 ssp_ops;
/// sec_oid4 ssp_hash_algs<>; /// sec_oid4 ssp_hash_algs<>;
/// sec_oid4 ssp_encr_algs<>; /// sec_oid4 ssp_encr_algs<>;
/// uint32_t ssp_window; /// uint32_t ssp_window;
/// uint32_t ssp_num_gss_handles; /// uint32_t ssp_num_gss_handles;
/// }; /// };
/// ///
/// enum state_protect_how4 { /// enum state_protect_how4 {
/// SP4_NONE = 0, /// SP4_NONE = 0,
/// SP4_MACH_CRED = 1, /// SP4_MACH_CRED = 1,
/// SP4_SSV = 2 /// SP4_SSV = 2
/// }; /// };
/// ///
/// union state_protect4_a switch(state_protect_how4 spa_how) { /// union state_protect4_a switch (state_protect_how4 spa_how) {
/// case SP4_NONE: /// case SP4_NONE:
/// void; /// void;
/// case SP4_MACH_CRED: /// case SP4_MACH_CRED:
/// state_protect_ops4 spa_mach_ops; /// state_protect_ops4 spa_mach_ops;
/// case SP4_SSV: /// case SP4_SSV:
/// ssv_sp_parms4 spa_ssv_parms; /// ssv_sp_parms4 spa_ssv_parms;
/// }; /// };
/// ///
/// struct EXCHANGE_ID4args { /// struct EXCHANGE_ID4args {
/// client_owner4 eia_clientowner; /// client_owner4 eia_clientowner;
skipping to change at page 52, line 36 skipping to change at page 55, line 29
/// ///
/// struct ssv_prot_info4 { /// struct ssv_prot_info4 {
/// state_protect_ops4 spi_ops; /// state_protect_ops4 spi_ops;
/// uint32_t spi_hash_alg; /// uint32_t spi_hash_alg;
/// uint32_t spi_encr_alg; /// uint32_t spi_encr_alg;
/// uint32_t spi_ssv_len; /// uint32_t spi_ssv_len;
/// uint32_t spi_window; /// uint32_t spi_window;
/// gsshandle4_t spi_handles<>; /// gsshandle4_t spi_handles<>;
/// }; /// };
/// ///
/// union state_protect4_r switch(state_protect_how4 spr_how) { /// union state_protect4_r switch (state_protect_how4 spr_how) {
/// case SP4_NONE: /// case SP4_NONE:
/// void; /// void;
/// case SP4_MACH_CRED: /// case SP4_MACH_CRED:
/// state_protect_ops4 spr_mach_ops; /// state_protect_ops4 spr_mach_ops;
/// case SP4_SSV: /// case SP4_SSV:
/// ssv_prot_info4 spr_ssv_info; /// ssv_prot_info4 spr_ssv_info;
/// }; /// };
/// ///
/// struct EXCHANGE_ID4resok { /// struct EXCHANGE_ID4resok {
/// clientid4 eir_clientid; /// clientid4 eir_clientid;
/// sequenceid4 eir_sequenceid; /// sequenceid4 eir_sequenceid;
/// uint32_t eir_flags; /// uint32_t eir_flags;
/// state_protect4_r eir_state_protect; /// state_protect4_r eir_state_protect;
/// server_owner4 eir_server_owner; /// server_owner4 eir_server_owner;
/// opaque eir_server_scope<NFS4_OPAQUE_LIMIT>; /// opaque eir_server_scope<NFS4_OPAQUE_LIMIT>;
/// nfs_impl_id4 eir_server_impl_id<1>; /// nfs_impl_id4 eir_server_impl_id<1>;
/// }; /// };
/// ///
/// union EXCHANGE_ID4res switch (nfsstat4 eir_status) { /// union EXCHANGE_ID4res switch (nfsstat4 eir_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// EXCHANGE_ID4resok eir_resok4; /// EXCHANGE_ID4resok eir_resok4;
/// ///
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct channel_attrs4 { /// struct channel_attrs4 {
/// count4 ca_headerpadsize; /// count4 ca_headerpadsize;
/// count4 ca_maxrequestsize; /// count4 ca_maxrequestsize;
/// count4 ca_maxresponsesize; /// count4 ca_maxresponsesize;
/// count4 ca_maxresponsesize_cached; /// count4 ca_maxresponsesize_cached;
/// count4 ca_maxoperations; /// count4 ca_maxoperations;
/// count4 ca_maxrequests; /// count4 ca_maxrequests;
/// uint32_t ca_rdma_ird<1>; /// uint32_t ca_rdma_ird<1>;
skipping to change at page 54, line 5 skipping to change at page 57, line 5
/// sessionid4 csr_sessionid; /// sessionid4 csr_sessionid;
/// sequenceid4 csr_sequence; /// sequenceid4 csr_sequence;
/// ///
/// uint32_t csr_flags; /// uint32_t csr_flags;
/// ///
/// channel_attrs4 csr_fore_chan_attrs; /// channel_attrs4 csr_fore_chan_attrs;
/// channel_attrs4 csr_back_chan_attrs; /// channel_attrs4 csr_back_chan_attrs;
/// }; /// };
/// ///
/// union CREATE_SESSION4res switch (nfsstat4 csr_status) { /// union CREATE_SESSION4res switch (nfsstat4 csr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// CREATE_SESSION4resok csr_resok4; /// CREATE_SESSION4resok csr_resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct DESTROY_SESSION4args { /// struct DESTROY_SESSION4args {
/// sessionid4 dsa_sessionid; /// sessionid4 dsa_sessionid;
/// }; /// };
/// ///
/// struct DESTROY_SESSION4res { /// struct DESTROY_SESSION4res {
/// nfsstat4 dsr_status; /// nfsstat4 dsr_status;
/// }; /// };
/// ///
skipping to change at page 54, line 43 skipping to change at page 57, line 43
/// bitmap4 gdda_notification_types; /// bitmap4 gdda_notification_types;
/// attr_notice4 gdda_child_attr_delay; /// attr_notice4 gdda_child_attr_delay;
/// attr_notice4 gdda_dir_attr_delay; /// attr_notice4 gdda_dir_attr_delay;
/// bitmap4 gdda_child_attributes; /// bitmap4 gdda_child_attributes;
/// bitmap4 gdda_dir_attributes; /// bitmap4 gdda_dir_attributes;
/// }; /// };
/// struct GET_DIR_DELEGATION4resok { /// struct GET_DIR_DELEGATION4resok {
/// verifier4 gddr_cookieverf; /// verifier4 gddr_cookieverf;
/// /* Stateid for get_dir_delegation */ /// /* Stateid for get_dir_delegation */
/// stateid4 gddr_stateid; /// stateid4 gddr_stateid;
/// /* Which notifications can the server support */ /// /* Which notifications can the server support? */
/// bitmap4 gddr_notification; /// bitmap4 gddr_notification;
/// bitmap4 gddr_child_attributes; /// bitmap4 gddr_child_attributes;
/// bitmap4 gddr_dir_attributes; /// bitmap4 gddr_dir_attributes;
/// }; /// };
/// ///
/// enum gddrnf4_status { /// enum gddrnf4_status {
/// GDD4_OK = 0, /// GDD4_OK = 0,
/// GDD4_UNAVAIL = 1 /// GDD4_UNAVAIL = 1
/// }; /// };
/// ///
/// union GET_DIR_DELEGATION4res_non_fatal /// union GET_DIR_DELEGATION4res_non_fatal
/// switch (gddrnf4_status gddrnf_status) { /// switch (gddrnf4_status gddrnf_status) {
/// case GDD4_OK: /// case GDD4_OK:
/// GET_DIR_DELEGATION4resok gddrnf_resok4; /// GET_DIR_DELEGATION4resok gddrnf_resok4;
/// case GDD4_UNAVAIL: /// case GDD4_UNAVAIL:
/// bool gddrnf_will_signal_deleg_avail; /// bool gddrnf_will_signal_deleg_avail;
/// }; /// };
/// ///
/// union GET_DIR_DELEGATION4res /// union GET_DIR_DELEGATION4res
/// switch (nfsstat4 gddr_status) { /// switch (nfsstat4 gddr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// GET_DIR_DELEGATION4res_non_fatal gddr_res_non_fatal4; /// GET_DIR_DELEGATION4res_non_fatal gddr_res_non_fatal4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct GETDEVICEINFO4args { /// struct GETDEVICEINFO4args {
/// deviceid4 gdia_device_id; /// deviceid4 gdia_device_id;
/// layouttype4 gdia_layout_type; /// layouttype4 gdia_layout_type;
/// count4 gdia_maxcount; /// count4 gdia_maxcount;
/// bitmap4 gdia_notify_types; /// bitmap4 gdia_notify_types;
/// }; /// };
/// ///
/// struct GETDEVICEINFO4resok { /// struct GETDEVICEINFO4resok {
/// device_addr4 gdir_device_addr; /// device_addr4 gdir_device_addr;
/// bitmap4 gdir_notification; /// bitmap4 gdir_notification;
/// }; /// };
/// ///
/// union GETDEVICEINFO4res switch (nfsstat4 gdir_status) { /// union GETDEVICEINFO4res switch (nfsstat4 gdir_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// GETDEVICEINFO4resok gdir_resok4; /// GETDEVICEINFO4resok gdir_resok4;
/// case NFS4ERR_TOOSMALL: /// case NFS4ERR_TOOSMALL:
/// count4 gdir_mincount; /// count4 gdir_mincount;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct GETDEVICELIST4args { /// struct GETDEVICELIST4args {
/// /* CURRENT_FH: object belonging to the file system */ /// /* CURRENT_FH: object belonging to the file system */
/// layouttype4 gdla_layout_type; /// layouttype4 gdla_layout_type;
/// ///
/// /* number of deviceIDs to return */ /// /* Number of device IDs to return */
/// count4 gdla_maxdevices; /// count4 gdla_maxdevices;
/// ///
/// nfs_cookie4 gdla_cookie; /// nfs_cookie4 gdla_cookie;
/// verifier4 gdla_cookieverf; /// verifier4 gdla_cookieverf;
/// }; /// };
/// ///
/// struct GETDEVICELIST4resok { /// struct GETDEVICELIST4resok {
/// nfs_cookie4 gdlr_cookie; /// nfs_cookie4 gdlr_cookie;
/// verifier4 gdlr_cookieverf; /// verifier4 gdlr_cookieverf;
/// deviceid4 gdlr_deviceid_list<>; /// deviceid4 gdlr_deviceid_list<>;
/// bool gdlr_eof; /// bool gdlr_eof;
/// }; /// };
/// ///
/// union GETDEVICELIST4res switch (nfsstat4 gdlr_status) { /// union GETDEVICELIST4res switch (nfsstat4 gdlr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// GETDEVICELIST4resok gdlr_resok4; /// GETDEVICELIST4resok gdlr_resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// union newtime4 switch (bool nt_timechanged) { /// union newtime4 switch (bool nt_timechanged) {
/// case TRUE: /// case TRUE:
/// nfstime4 nt_time; /// nfstime4 nt_time;
/// case FALSE: /// case FALSE:
/// void; /// void;
/// }; /// };
/// ///
/// union newoffset4 switch (bool no_newoffset) { /// union newoffset4 switch (bool no_newoffset) {
/// case TRUE: /// case TRUE:
/// offset4 no_offset; /// offset4 no_offset;
/// case FALSE: /// case FALSE:
/// void; /// void;
/// }; /// };
/// ///
/// struct LAYOUTCOMMIT4args { /// struct LAYOUTCOMMIT4args {
/// /* CURRENT_FH: file */ /// /* CURRENT_FH: file */
/// offset4 loca_offset; /// offset4 loca_offset;
/// length4 loca_length; /// length4 loca_length;
/// bool loca_reclaim; /// bool loca_reclaim;
/// stateid4 loca_stateid; /// stateid4 loca_stateid;
/// newoffset4 loca_last_write_offset; /// newoffset4 loca_last_write_offset;
/// newtime4 loca_time_modify; /// newtime4 loca_time_modify;
/// layoutupdate4 loca_layoutupdate; /// layoutupdate4 loca_layoutupdate;
/// }; /// };
/// union newsize4 switch (bool ns_sizechanged) { /// union newsize4 switch (bool ns_sizechanged) {
/// case TRUE: /// case TRUE:
/// length4 ns_size; /// length4 ns_size;
/// case FALSE: /// case FALSE:
/// void; /// void;
/// }; /// };
/// ///
/// struct LAYOUTCOMMIT4resok { /// struct LAYOUTCOMMIT4resok {
/// newsize4 locr_newsize; /// newsize4 locr_newsize;
/// }; /// };
/// ///
/// union LAYOUTCOMMIT4res switch (nfsstat4 locr_status) { /// union LAYOUTCOMMIT4res switch (nfsstat4 locr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// LAYOUTCOMMIT4resok locr_resok4; /// LAYOUTCOMMIT4resok locr_resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct LAYOUTGET4args { /// struct LAYOUTGET4args {
/// /* CURRENT_FH: file */ /// /* CURRENT_FH: file */
/// bool loga_signal_layout_avail; /// bool loga_signal_layout_avail;
/// layouttype4 loga_layout_type; /// layouttype4 loga_layout_type;
/// layoutiomode4 loga_iomode; /// layoutiomode4 loga_iomode;
/// offset4 loga_offset; /// offset4 loga_offset;
/// length4 loga_length; /// length4 loga_length;
/// length4 loga_minlength; /// length4 loga_minlength;
/// stateid4 loga_stateid; /// stateid4 loga_stateid;
/// count4 loga_maxcount; /// count4 loga_maxcount;
/// }; /// };
/// struct LAYOUTGET4resok { /// struct LAYOUTGET4resok {
/// bool logr_return_on_close; /// bool logr_return_on_close;
/// stateid4 logr_stateid; /// stateid4 logr_stateid;
/// layout4 logr_layout<>; /// layout4 logr_layout<>;
/// }; /// };
/// ///
/// union LAYOUTGET4res switch (nfsstat4 logr_status) { /// union LAYOUTGET4res switch (nfsstat4 logr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// LAYOUTGET4resok logr_resok4; /// LAYOUTGET4resok logr_resok4;
/// case NFS4ERR_LAYOUTTRYLATER: /// case NFS4ERR_LAYOUTTRYLATER:
/// bool logr_will_signal_layout_avail; /// bool logr_will_signal_layout_avail;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// ///
/// struct LAYOUTRETURN4args { /// struct LAYOUTRETURN4args {
/// /* CURRENT_FH: file */ /// /* CURRENT_FH: file */
/// bool lora_reclaim; /// bool lora_reclaim;
/// layouttype4 lora_layout_type; /// layouttype4 lora_layout_type;
/// layoutiomode4 lora_iomode; /// layoutiomode4 lora_iomode;
/// layoutreturn4 lora_layoutreturn; /// layoutreturn4 lora_layoutreturn;
/// }; /// };
/// ///
/// ///
/// union layoutreturn_stateid switch (bool lrs_present) { /// union layoutreturn_stateid switch (bool lrs_present) {
/// case TRUE: /// case TRUE:
/// stateid4 lrs_stateid;
/// stateid4 lrs_stateid; /// case FALSE:
/// case FALSE: /// void;
/// void;
/// }; /// };
/// ///
/// union LAYOUTRETURN4res switch (nfsstat4 lorr_status) { /// union LAYOUTRETURN4res switch (nfsstat4 lorr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// layoutreturn_stateid lorr_stateid; /// layoutreturn_stateid lorr_stateid;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// enum secinfo_style4 { /// enum secinfo_style4 {
/// SECINFO_STYLE4_CURRENT_FH = 0, /// SECINFO_STYLE4_CURRENT_FH = 0,
/// SECINFO_STYLE4_PARENT = 1 /// SECINFO_STYLE4_PARENT = 1
/// }; /// };
/// ///
/// /* CURRENT_FH: object or child directory */ /// /* CURRENT_FH: object or child directory */
/// typedef secinfo_style4 SECINFO_NO_NAME4args; /// typedef secinfo_style4 SECINFO_NO_NAME4args;
/// ///
skipping to change at page 59, line 11 skipping to change at page 62, line 36
/// struct SEQUENCE4resok { /// struct SEQUENCE4resok {
/// sessionid4 sr_sessionid; /// sessionid4 sr_sessionid;
/// sequenceid4 sr_sequenceid; /// sequenceid4 sr_sequenceid;
/// slotid4 sr_slotid; /// slotid4 sr_slotid;
/// slotid4 sr_highest_slotid; /// slotid4 sr_highest_slotid;
/// slotid4 sr_target_highest_slotid; /// slotid4 sr_target_highest_slotid;
/// uint32_t sr_status_flags; /// uint32_t sr_status_flags;
/// }; /// };
/// ///
/// union SEQUENCE4res switch (nfsstat4 sr_status) { /// union SEQUENCE4res switch (nfsstat4 sr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// SEQUENCE4resok sr_resok4; /// SEQUENCE4resok sr_resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct ssa_digest_input4 { /// struct ssa_digest_input4 {
/// SEQUENCE4args sdi_seqargs; /// SEQUENCE4args sdi_seqargs;
/// }; /// };
/// ///
/// struct SET_SSV4args { /// struct SET_SSV4args {
/// opaque ssa_ssv<>; /// opaque ssa_ssv<>;
/// opaque ssa_digest<>; /// opaque ssa_digest<>;
/// }; /// };
/// ///
/// struct ssr_digest_input4 { /// struct ssr_digest_input4 {
/// SEQUENCE4res sdi_seqres; /// SEQUENCE4res sdi_seqres;
/// }; /// };
/// ///
/// struct SET_SSV4resok { /// struct SET_SSV4resok {
/// opaque ssr_digest<>; /// opaque ssr_digest<>;
/// }; /// };
/// ///
/// union SET_SSV4res switch (nfsstat4 ssr_status) { /// union SET_SSV4res switch (nfsstat4 ssr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// SET_SSV4resok ssr_resok4; /// SET_SSV4resok ssr_resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct TEST_STATEID4args { /// struct TEST_STATEID4args {
/// stateid4 ts_stateids<>; /// stateid4 ts_stateids<>;
/// }; /// };
/// ///
/// struct TEST_STATEID4resok { /// struct TEST_STATEID4resok {
/// nfsstat4 tsr_status_codes<>; /// nfsstat4 tsr_status_codes<>;
/// }; /// };
/// ///
/// union TEST_STATEID4res switch (nfsstat4 tsr_status) { /// union TEST_STATEID4res switch (nfsstat4 tsr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// TEST_STATEID4resok tsr_resok4; /// TEST_STATEID4resok tsr_resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// union deleg_claim4 switch (open_claim_type4 dc_claim) { /// union deleg_claim4 switch (open_claim_type4 dc_claim) {
/// /* /// /*
/// * No special rights to object. Ordinary delegation /// * No special rights to object. Ordinary delegation
/// * request of the specified object. Object identified /// * request of the specified object. Object identified
/// * by filehandle. /// * by filehandle.
/// */ /// */
/// case CLAIM_FH: /* new to v4.1 */ /// case CLAIM_FH: /* New to NFSv4.1 */
/// /* CURRENT_FH: object being delegated */ /// /* CURRENT_FH: object being delegated */
/// void; /// void;
/// ///
/// /* /// /*
/// * Right to file based on a delegation granted /// * Right to file based on a delegation granted
/// * to a previous boot instance of the client. /// * to a previous boot instance of the client.
/// * File is specified by filehandle. /// * File is specified by filehandle.
/// */ /// */
/// case CLAIM_DELEG_PREV_FH: /* new to v4.1 */ /// case CLAIM_DELEG_PREV_FH: /* New to NFSv4.1 */
/// /* CURRENT_FH: object being delegated */ /// /* CURRENT_FH: object being delegated */
/// void; /// void;
/// ///
/// /* /// /*
/// * Right to the file established by an open previous /// * Right to the file established by an open previous
/// * to server reboot. File identified by filehandle. /// * to server reboot. File identified by filehandle.
/// * Used during server reclaim grace period. /// * Used during server reclaim grace period.
/// */ /// */
/// case CLAIM_PREVIOUS: /// case CLAIM_PREVIOUS:
/// /* CURRENT_FH: object being reclaimed */ /// /* CURRENT_FH: object being reclaimed */
/// open_delegation_type4 dc_delegate_type; /// open_delegation_type4 dc_delegate_type;
/// }; /// };
/// ///
/// struct WANT_DELEGATION4args { /// struct WANT_DELEGATION4args {
/// uint32_t wda_want; /// uint32_t wda_want;
/// deleg_claim4 wda_claim; /// deleg_claim4 wda_claim;
/// }; /// };
/// ///
/// union WANT_DELEGATION4res switch (nfsstat4 wdr_status) { /// union WANT_DELEGATION4res switch (nfsstat4 wdr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// open_delegation4 wdr_resok4; /// open_delegation4 wdr_resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct DESTROY_CLIENTID4args { /// struct DESTROY_CLIENTID4args {
/// clientid4 dca_clientid; /// clientid4 dca_clientid;
/// }; /// };
/// ///
/// struct DESTROY_CLIENTID4res { /// struct DESTROY_CLIENTID4res {
/// nfsstat4 dcr_status; /// nfsstat4 dcr_status;
/// }; /// };
/// ///
/// struct RECLAIM_COMPLETE4args { /// struct RECLAIM_COMPLETE4args {
/// /* /// /*
/// * If rca_one_fs TRUE, /// * If rca_one_fs TRUE,
/// * /// *
/// * CURRENT_FH: object in /// * CURRENT_FH: object in
/// * filesystem reclaim is /// * file system for which the
/// * complete for. /// * reclaim is complete.
/// */ /// */
/// bool rca_one_fs; /// bool rca_one_fs;
/// }; /// };
/// ///
/// struct RECLAIM_COMPLETE4res { /// struct RECLAIM_COMPLETE4res {
/// nfsstat4 rcr_status; /// nfsstat4 rcr_status;
/// }; /// };
/// ///
/// struct COPY4args { /// struct COPY4args {
/// /* SAVED_FH: source file */ /// /* SAVED_FH: source file */
skipping to change at page 61, line 49 skipping to change at page 65, line 29
/// bool cr_consecutive; /// bool cr_consecutive;
/// bool cr_synchronous; /// bool cr_synchronous;
/// }; /// };
/// ///
/// struct COPY4resok { /// struct COPY4resok {
/// write_response4 cr_response; /// write_response4 cr_response;
/// copy_requirements4 cr_requirements; /// copy_requirements4 cr_requirements;
/// }; /// };
/// ///
/// union COPY4res switch (nfsstat4 cr_status) { /// union COPY4res switch (nfsstat4 cr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// COPY4resok cr_resok4; /// COPY4resok cr_resok4;
/// case NFS4ERR_OFFLOAD_NO_REQS: /// case NFS4ERR_OFFLOAD_NO_REQS:
/// copy_requirements4 cr_requirements;
/// copy_requirements4 cr_requirements; /// default:
/// default: /// void;
/// void;
/// }; /// };
/// ///
/// struct COPY_NOTIFY4args { /// struct COPY_NOTIFY4args {
/// /* CURRENT_FH: source file */ /// /* CURRENT_FH: source file */
/// stateid4 cna_src_stateid; /// stateid4 cna_src_stateid;
/// netloc4 cna_destination_server; /// netloc4 cna_destination_server;
/// }; /// };
/// ///
/// struct COPY_NOTIFY4resok { /// struct COPY_NOTIFY4resok {
/// nfstime4 cnr_lease_time; /// nfstime4 cnr_lease_time;
/// stateid4 cnr_stateid; /// stateid4 cnr_stateid;
/// netloc4 cnr_source_server<>; /// netloc4 cnr_source_server<>;
/// }; /// };
/// ///
/// union COPY_NOTIFY4res switch (nfsstat4 cnr_status) { /// union COPY_NOTIFY4res switch (nfsstat4 cnr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// COPY_NOTIFY4resok resok4; /// COPY_NOTIFY4resok resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct OFFLOAD_CANCEL4args { /// struct OFFLOAD_CANCEL4args {
/// /* CURRENT_FH: file to cancel */ /// /* CURRENT_FH: file to cancel */
/// stateid4 oca_stateid; /// stateid4 oca_stateid;
/// }; /// };
/// ///
/// struct OFFLOAD_CANCEL4res { /// struct OFFLOAD_CANCEL4res {
/// nfsstat4 ocr_status; /// nfsstat4 ocr_status;
/// }; /// };
skipping to change at page 62, line 50 skipping to change at page 66, line 32
/// /* CURRENT_FH: destination file */ /// /* CURRENT_FH: destination file */
/// stateid4 osa_stateid; /// stateid4 osa_stateid;
/// }; /// };
/// ///
/// struct OFFLOAD_STATUS4resok { /// struct OFFLOAD_STATUS4resok {
/// length4 osr_count; /// length4 osr_count;
/// nfsstat4 osr_complete<1>; /// nfsstat4 osr_complete<1>;
/// }; /// };
/// ///
/// union OFFLOAD_STATUS4res switch (nfsstat4 osr_status) { /// union OFFLOAD_STATUS4res switch (nfsstat4 osr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// OFFLOAD_STATUS4resok osr_resok4; /// OFFLOAD_STATUS4resok osr_resok4;
/// default: /// default:
/// void;
/// void;
/// }; /// };
/// ///
/// struct ALLOCATE4args { /// struct ALLOCATE4args {
/// /* CURRENT_FH: file */ /// /* CURRENT_FH: file */
/// stateid4 aa_stateid; /// stateid4 aa_stateid;
/// offset4 aa_offset; /// offset4 aa_offset;
/// length4 aa_length; /// length4 aa_length;
/// }; /// };
/// struct ALLOCATE4res { /// struct ALLOCATE4res {
/// nfsstat4 ar_status; /// nfsstat4 ar_status;
skipping to change at page 64, line 7 skipping to change at page 67, line 42
/// offset4 iaa_offset; /// offset4 iaa_offset;
/// length4 iaa_count; /// length4 iaa_count;
/// bitmap4 iaa_hints; /// bitmap4 iaa_hints;
/// }; /// };
/// ///
/// struct IO_ADVISE4resok { /// struct IO_ADVISE4resok {
/// bitmap4 ior_hints; /// bitmap4 ior_hints;
/// }; /// };
/// ///
/// union IO_ADVISE4res switch (nfsstat4 ior_status) { /// union IO_ADVISE4res switch (nfsstat4 ior_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// IO_ADVISE4resok resok4; /// IO_ADVISE4resok resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// ///
/// struct device_error4 { /// struct device_error4 {
/// deviceid4 de_deviceid; /// deviceid4 de_deviceid;
/// nfsstat4 de_status; /// nfsstat4 de_status;
/// nfs_opnum4 de_opnum; /// nfs_opnum4 de_opnum;
/// }; /// };
/// ///
/// ///
skipping to change at page 65, line 12 skipping to change at page 69, line 5
/// nfsstat4 lsr_status; /// nfsstat4 lsr_status;
/// }; /// };
/// ///
/// struct READ_PLUS4args { /// struct READ_PLUS4args {
/// /* CURRENT_FH: file */ /// /* CURRENT_FH: file */
/// stateid4 rpa_stateid; /// stateid4 rpa_stateid;
/// offset4 rpa_offset; /// offset4 rpa_offset;
/// count4 rpa_count; /// count4 rpa_count;
/// }; /// };
/// union read_plus_content switch (data_content4 rpc_content) { /// union read_plus_content switch (data_content4 rpc_content) {
/// case NFS4_CONTENT_DATA: /// case NFS4_CONTENT_DATA:
/// data4 rpc_data; /// data4 rpc_data;
/// case NFS4_CONTENT_HOLE: /// case NFS4_CONTENT_HOLE:
/// data_info4 rpc_hole; /// data_info4 rpc_hole;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// /* /// /*
/// * Allow a return of an array of contents. /// * Allow a return of an array of contents.
/// */ /// */
/// struct read_plus_res4 { /// struct read_plus_res4 {
/// bool rpr_eof; /// bool rpr_eof;
/// read_plus_content rpr_contents<>; /// read_plus_content rpr_contents<>;
/// }; /// };
/// ///
/// union READ_PLUS4res switch (nfsstat4 rp_status) { /// union READ_PLUS4res switch (nfsstat4 rp_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// read_plus_res4 rp_resok4; /// read_plus_res4 rp_resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct SEEK4args { /// struct SEEK4args {
/// /* CURRENT_FH: file */ /// /* CURRENT_FH: file */
/// stateid4 sa_stateid; /// stateid4 sa_stateid;
/// offset4 sa_offset; /// offset4 sa_offset;
/// data_content4 sa_what; /// data_content4 sa_what;
/// }; /// };
/// struct seek_res4 { /// struct seek_res4 {
/// bool sr_eof; /// bool sr_eof;
/// offset4 sr_offset; /// offset4 sr_offset;
/// }; /// };
/// union SEEK4res switch (nfsstat4 sa_status) { /// union SEEK4res switch (nfsstat4 sa_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// seek_res4 resok4; /// seek_res4 resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct WRITE_SAME4args { /// struct WRITE_SAME4args {
/// /* CURRENT_FH: file */ /// /* CURRENT_FH: file */
/// stateid4 wsa_stateid; /// stateid4 wsa_stateid;
/// stable_how4 wsa_stable; /// stable_how4 wsa_stable;
/// app_data_block4 wsa_adb; /// app_data_block4 wsa_adb;
/// }; /// };
/// ///
/// ///
/// union WRITE_SAME4res switch (nfsstat4 wsr_status) { /// union WRITE_SAME4res switch (nfsstat4 wsr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// write_response4 resok4; /// write_response4 resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// ///
/// /* /// /*
/// * Operation arrays (the rest) /// * Operation arrays (the rest)
/// */ /// */
/// ///
/// union nfs_argop4 switch (nfs_opnum4 argop) { /// union nfs_argop4 switch (nfs_opnum4 argop) {
/// case OP_ACCESS: ACCESS4args opaccess; /// case OP_ACCESS: ACCESS4args opaccess;
/// case OP_CLOSE: CLOSE4args opclose; /// case OP_CLOSE: CLOSE4args opclose;
/// case OP_COMMIT: COMMIT4args opcommit; /// case OP_COMMIT: COMMIT4args opcommit;
/// case OP_CREATE: CREATE4args opcreate; /// case OP_CREATE: CREATE4args opcreate;
/// case OP_DELEGPURGE: DELEGPURGE4args opdelegpurge; /// case OP_DELEGPURGE: DELEGPURGE4args opdelegpurge;
/// case OP_DELEGRETURN: DELEGRETURN4args opdelegreturn; /// case OP_DELEGRETURN: DELEGRETURN4args opdelegreturn;
/// case OP_GETATTR: GETATTR4args opgetattr; /// case OP_GETATTR: GETATTR4args opgetattr;
/// case OP_GETFH: void; /// case OP_GETFH: void;
/// case OP_LINK: LINK4args oplink; /// case OP_LINK: LINK4args oplink;
/// case OP_LOCK: LOCK4args oplock; /// case OP_LOCK: LOCK4args oplock;
/// case OP_LOCKT: LOCKT4args oplockt; /// case OP_LOCKT: LOCKT4args oplockt;
/// case OP_LOCKU: LOCKU4args oplocku; /// case OP_LOCKU: LOCKU4args oplocku;
/// case OP_LOOKUP: LOOKUP4args oplookup; /// case OP_LOOKUP: LOOKUP4args oplookup;
/// case OP_LOOKUPP: void; /// case OP_LOOKUPP: void;
/// case OP_NVERIFY: NVERIFY4args opnverify; /// case OP_NVERIFY: NVERIFY4args opnverify;
/// case OP_OPEN: OPEN4args opopen; /// case OP_OPEN: OPEN4args opopen;
/// case OP_OPENATTR: OPENATTR4args opopenattr; /// case OP_OPENATTR: OPENATTR4args opopenattr;
/// ///
/// /* Not for NFSv4.1 */ /// /* Not for NFSv4.1 */
/// case OP_OPEN_CONFIRM: OPEN_CONFIRM4args opopen_confirm; /// case OP_OPEN_CONFIRM: OPEN_CONFIRM4args opopen_confirm;
/// ///
/// case OP_OPEN_DOWNGRADE: /// case OP_OPEN_DOWNGRADE: OPEN_DOWNGRADE4args opopen_downgrade;
/// OPEN_DOWNGRADE4args opopen_downgrade;
/// ///
/// case OP_PUTFH: PUTFH4args opputfh; /// case OP_PUTFH: PUTFH4args opputfh;
/// case OP_PUTPUBFH: void; /// case OP_PUTPUBFH: void;
/// case OP_PUTROOTFH: void; /// case OP_PUTROOTFH: void;
/// case OP_READ: READ4args opread; /// case OP_READ: READ4args opread;
/// case OP_READDIR: READDIR4args opreaddir; /// case OP_READDIR: READDIR4args opreaddir;
/// case OP_READLINK: void; /// case OP_READLINK: void;
/// case OP_REMOVE: REMOVE4args opremove; /// case OP_REMOVE: REMOVE4args opremove;
/// case OP_RENAME: RENAME4args oprename; /// case OP_RENAME: RENAME4args oprename;
/// ///
/// /* Not for NFSv4.1 */ /// /* Not for NFSv4.1 */
/// case OP_RENEW: RENEW4args oprenew; /// case OP_RENEW: RENEW4args oprenew;
/// ///
/// case OP_RESTOREFH: void; /// case OP_RESTOREFH: void;
/// case OP_SAVEFH: void; /// case OP_SAVEFH: void;
/// case OP_SECINFO: SECINFO4args opsecinfo; /// case OP_SECINFO: SECINFO4args opsecinfo;
/// case OP_SETATTR: SETATTR4args opsetattr; /// case OP_SETATTR: SETATTR4args opsetattr;
/// ///
/// /* Not for NFSv4.1 */ /// /* Not for NFSv4.1 */
/// case OP_SETCLIENTID: SETCLIENTID4args opsetclientid; /// case OP_SETCLIENTID: SETCLIENTID4args opsetclientid;
/// ///
/// /* Not for NFSv4.1 */ /// /* Not for NFSv4.1 */
/// case OP_SETCLIENTID_CONFIRM: SETCLIENTID_CONFIRM4args /// case OP_SETCLIENTID_CONFIRM:
/// opsetclientid_confirm; /// SETCLIENTID_CONFIRM4args
/// case OP_VERIFY: VERIFY4args opverify; /// opsetclientid_confirm;
/// case OP_WRITE: WRITE4args opwrite; ///
/// case OP_VERIFY: VERIFY4args opverify;
/// case OP_WRITE: WRITE4args opwrite;
/// ///
/// /* Not for NFSv4.1 */ /// /* Not for NFSv4.1 */
/// case OP_RELEASE_LOCKOWNER: /// case OP_RELEASE_LOCKOWNER:
/// RELEASE_LOCKOWNER4args /// RELEASE_LOCKOWNER4args
/// oprelease_lockowner; /// oprelease_lockowner;
/// ///
/// /* Operations new to NFSv4.1 */ /// /* Operations new to NFSv4.1 */
/// case OP_BACKCHANNEL_CTL: /// case OP_BACKCHANNEL_CTL:
/// BACKCHANNEL_CTL4args opbackchannel_ctl; /// BACKCHANNEL_CTL4args opbackchannel_ctl;
/// ///
/// case OP_BIND_CONN_TO_SESSION: /// case OP_BIND_CONN_TO_SESSION:
/// BIND_CONN_TO_SESSION4args /// BIND_CONN_TO_SESSION4args
/// opbind_conn_to_session; /// opbind_conn_to_session;
/// ///
/// case OP_EXCHANGE_ID: EXCHANGE_ID4args opexchange_id; /// case OP_EXCHANGE_ID: EXCHANGE_ID4args opexchange_id;
/// ///
/// case OP_CREATE_SESSION: /// case OP_CREATE_SESSION: CREATE_SESSION4args opcreate_session;
/// CREATE_SESSION4args opcreate_session;
/// ///
/// case OP_DESTROY_SESSION: /// case OP_DESTROY_SESSION:
/// DESTROY_SESSION4args opdestroy_session; /// DESTROY_SESSION4args opdestroy_session;
/// ///
/// case OP_FREE_STATEID: FREE_STATEID4args opfree_stateid; /// case OP_FREE_STATEID: FREE_STATEID4args opfree_stateid;
/// ///
/// case OP_GET_DIR_DELEGATION: /// case OP_GET_DIR_DELEGATION:
/// GET_DIR_DELEGATION4args /// GET_DIR_DELEGATION4args
/// opget_dir_delegation; /// opget_dir_delegation;
/// ///
/// case OP_GETDEVICEINFO: GETDEVICEINFO4args opgetdeviceinfo; /// case OP_GETDEVICEINFO: GETDEVICEINFO4args opgetdeviceinfo;
/// case OP_GETDEVICELIST: GETDEVICELIST4args opgetdevicelist; /// case OP_GETDEVICELIST: GETDEVICELIST4args opgetdevicelist;
/// case OP_LAYOUTCOMMIT: LAYOUTCOMMIT4args oplayoutcommit; /// case OP_LAYOUTCOMMIT: LAYOUTCOMMIT4args oplayoutcommit;
/// case OP_LAYOUTGET: LAYOUTGET4args oplayoutget; /// case OP_LAYOUTGET: LAYOUTGET4args oplayoutget;
/// case OP_LAYOUTRETURN: LAYOUTRETURN4args oplayoutreturn; /// case OP_LAYOUTRETURN: LAYOUTRETURN4args oplayoutreturn;
/// ///
/// case OP_SECINFO_NO_NAME: /// case OP_SECINFO_NO_NAME:
/// SECINFO_NO_NAME4args opsecinfo_no_name; /// SECINFO_NO_NAME4args opsecinfo_no_name;
/// ///
/// case OP_SEQUENCE: SEQUENCE4args opsequence; /// case OP_SEQUENCE: SEQUENCE4args opsequence;
/// case OP_SET_SSV: SET_SSV4args opset_ssv; /// case OP_SET_SSV: SET_SSV4args opset_ssv;
/// case OP_TEST_STATEID: TEST_STATEID4args optest_stateid; /// case OP_TEST_STATEID: TEST_STATEID4args optest_stateid;
/// ///
/// case OP_WANT_DELEGATION: /// case OP_WANT_DELEGATION:
/// WANT_DELEGATION4args opwant_delegation; /// WANT_DELEGATION4args opwant_delegation;
/// ///
/// case OP_DESTROY_CLIENTID: /// case OP_DESTROY_CLIENTID:
/// DESTROY_CLIENTID4args /// DESTROY_CLIENTID4args
/// opdestroy_clientid; /// opdestroy_clientid;
/// ///
/// case OP_RECLAIM_COMPLETE: /// case OP_RECLAIM_COMPLETE:
/// RECLAIM_COMPLETE4args /// RECLAIM_COMPLETE4args
/// opreclaim_complete; /// opreclaim_complete;
/// ///
/// /* Operations new to NFSv4.2 */ /// /* Operations new to NFSv4.2 */
/// case OP_ALLOCATE: ALLOCATE4args opallocate; /// case OP_ALLOCATE: ALLOCATE4args opallocate;
/// case OP_COPY: COPY4args opcopy; /// case OP_COPY: COPY4args opcopy;
/// case OP_COPY_NOTIFY: COPY_NOTIFY4args opoffload_notify; /// case OP_COPY_NOTIFY: COPY_NOTIFY4args opoffload_notify;
/// case OP_DEALLOCATE: DEALLOCATE4args opdeallocate; /// case OP_DEALLOCATE: DEALLOCATE4args opdeallocate;
/// case OP_IO_ADVISE: IO_ADVISE4args opio_advise; /// case OP_IO_ADVISE: IO_ADVISE4args opio_advise;
/// case OP_LAYOUTERROR: LAYOUTERROR4args oplayouterror; /// case OP_LAYOUTERROR: LAYOUTERROR4args oplayouterror;
/// case OP_LAYOUTSTATS: LAYOUTSTATS4args oplayoutstats; /// case OP_LAYOUTSTATS: LAYOUTSTATS4args oplayoutstats;
/// case OP_OFFLOAD_CANCEL: OFFLOAD_CANCEL4args opoffload_cancel; /// case OP_OFFLOAD_CANCEL: OFFLOAD_CANCEL4args opoffload_cancel;
/// case OP_OFFLOAD_STATUS: OFFLOAD_STATUS4args opoffload_status; /// case OP_OFFLOAD_STATUS: OFFLOAD_STATUS4args opoffload_status;
/// case OP_READ_PLUS: READ_PLUS4args opread_plus; /// case OP_READ_PLUS: READ_PLUS4args opread_plus;
/// case OP_SEEK: SEEK4args opseek; /// case OP_SEEK: SEEK4args opseek;
/// case OP_WRITE_SAME: WRITE_SAME4args opwrite_same; /// case OP_WRITE_SAME: WRITE_SAME4args opwrite_same;
/// case OP_CLONE: CLONE4args opclone; /// case OP_CLONE: CLONE4args opclone;
/// ///
/// /* Operations not new to NFSv4.1 */ /// /* Operations not new to NFSv4.1 */
/// case OP_ILLEGAL: void; /// case OP_ILLEGAL: void;
/// }; /// };
/// ///
/// union nfs_resop4 switch (nfs_opnum4 resop) { /// union nfs_resop4 switch (nfs_opnum4 resop) {
/// case OP_ACCESS: ACCESS4res opaccess; /// case OP_ACCESS: ACCESS4res opaccess;
/// case OP_CLOSE: CLOSE4res opclose; /// case OP_CLOSE: CLOSE4res opclose;
/// case OP_COMMIT: COMMIT4res opcommit; /// case OP_COMMIT: COMMIT4res opcommit;
/// case OP_CREATE: CREATE4res opcreate; /// case OP_CREATE: CREATE4res opcreate;
/// case OP_DELEGPURGE: DELEGPURGE4res opdelegpurge; /// case OP_DELEGPURGE: DELEGPURGE4res opdelegpurge;
/// case OP_DELEGRETURN: DELEGRETURN4res opdelegreturn; /// case OP_DELEGRETURN: DELEGRETURN4res opdelegreturn;
/// case OP_GETATTR: GETATTR4res opgetattr; /// case OP_GETATTR: GETATTR4res opgetattr;
/// case OP_GETFH: GETFH4res opgetfh; /// case OP_GETFH: GETFH4res opgetfh;
/// case OP_LINK: LINK4res oplink; /// case OP_LINK: LINK4res oplink;
/// case OP_LOCK: LOCK4res oplock; /// case OP_LOCK: LOCK4res oplock;
/// case OP_LOCKT: LOCKT4res oplockt; /// case OP_LOCKT: LOCKT4res oplockt;
/// case OP_LOCKU: LOCKU4res oplocku; /// case OP_LOCKU: LOCKU4res oplocku;
/// case OP_LOOKUP: LOOKUP4res oplookup; /// case OP_LOOKUP: LOOKUP4res oplookup;
/// case OP_LOOKUPP: LOOKUPP4res oplookupp; /// case OP_LOOKUPP: LOOKUPP4res oplookupp;
/// case OP_NVERIFY: NVERIFY4res opnverify; /// case OP_NVERIFY: NVERIFY4res opnverify;
/// case OP_OPEN: OPEN4res opopen; /// case OP_OPEN: OPEN4res opopen;
/// case OP_OPENATTR: OPENATTR4res opopenattr; /// case OP_OPENATTR: OPENATTR4res opopenattr;
/// /* Not for NFSv4.1 */ /// /* Not for NFSv4.1 */
/// case OP_OPEN_CONFIRM: OPEN_CONFIRM4res opopen_confirm; /// case OP_OPEN_CONFIRM: OPEN_CONFIRM4res opopen_confirm;
/// ///
/// case OP_OPEN_DOWNGRADE: /// case OP_OPEN_DOWNGRADE: OPEN_DOWNGRADE4res opopen_downgrade;
/// OPEN_DOWNGRADE4res
/// opopen_downgrade;
/// ///
/// case OP_PUTFH: PUTFH4res opputfh; /// case OP_PUTFH: PUTFH4res opputfh;
/// case OP_PUTPUBFH: PUTPUBFH4res opputpubfh; /// case OP_PUTPUBFH: PUTPUBFH4res opputpubfh;
/// case OP_PUTROOTFH: PUTROOTFH4res opputrootfh; /// case OP_PUTROOTFH: PUTROOTFH4res opputrootfh;
/// case OP_READ: READ4res opread; /// case OP_READ: READ4res opread;
/// case OP_READDIR: READDIR4res opreaddir; /// case OP_READDIR: READDIR4res opreaddir;
/// case OP_READLINK: READLINK4res opreadlink; /// case OP_READLINK: READLINK4res opreadlink;
/// case OP_REMOVE: REMOVE4res opremove; /// case OP_REMOVE: REMOVE4res opremove;
/// case OP_RENAME: RENAME4res oprename; /// case OP_RENAME: RENAME4res oprename;
/// /* Not for NFSv4.1 */ /// /* Not for NFSv4.1 */
/// case OP_RENEW: RENEW4res oprenew; /// case OP_RENEW: RENEW4res oprenew;
/// case OP_RESTOREFH: RESTOREFH4res oprestorefh; /// case OP_RESTOREFH: RESTOREFH4res oprestorefh;
/// case OP_SAVEFH: SAVEFH4res opsavefh; /// case OP_SAVEFH: SAVEFH4res opsavefh;
/// case OP_SECINFO: SECINFO4res opsecinfo; /// case OP_SECINFO: SECINFO4res opsecinfo;
/// case OP_SETATTR: SETATTR4res opsetattr; /// case OP_SETATTR: SETATTR4res opsetattr;
/// /* Not for NFSv4.1 */ /// /* Not for NFSv4.1 */
/// case OP_SETCLIENTID: SETCLIENTID4res opsetclientid; /// case OP_SETCLIENTID: SETCLIENTID4res opsetclientid;
/// ///
/// /* Not for NFSv4.1 */ /// /* Not for NFSv4.1 */
/// case OP_SETCLIENTID_CONFIRM: /// case OP_SETCLIENTID_CONFIRM:
/// SETCLIENTID_CONFIRM4res /// SETCLIENTID_CONFIRM4res
/// opsetclientid_confirm; /// opsetclientid_confirm;
/// case OP_VERIFY: VERIFY4res opverify; /// case OP_VERIFY: VERIFY4res opverify;
/// case OP_WRITE: WRITE4res opwrite; /// case OP_WRITE: WRITE4res opwrite;
/// ///
/// /* Not for NFSv4.1 */ /// /* Not for NFSv4.1 */
/// case OP_RELEASE_LOCKOWNER: /// case OP_RELEASE_LOCKOWNER:
/// RELEASE_LOCKOWNER4res
/// RELEASE_LOCKOWNER4res /// oprelease_lockowner;
/// oprelease_lockowner;
/// ///
/// /* Operations new to NFSv4.1 */ /// /* Operations new to NFSv4.1 */
/// case OP_BACKCHANNEL_CTL: /// case OP_BACKCHANNEL_CTL:
/// BACKCHANNEL_CTL4res /// BACKCHANNEL_CTL4res opbackchannel_ctl;
/// opbackchannel_ctl;
/// ///
/// case OP_BIND_CONN_TO_SESSION: /// case OP_BIND_CONN_TO_SESSION:
/// BIND_CONN_TO_SESSION4res /// BIND_CONN_TO_SESSION4res
/// opbind_conn_to_session; /// opbind_conn_to_session;
/// ///
/// case OP_EXCHANGE_ID: EXCHANGE_ID4res opexchange_id; /// case OP_EXCHANGE_ID: EXCHANGE_ID4res opexchange_id;
/// ///
/// case OP_CREATE_SESSION: /// case OP_CREATE_SESSION: CREATE_SESSION4res opcreate_session;
/// CREATE_SESSION4res
/// opcreate_session;
/// ///
/// case OP_DESTROY_SESSION: /// case OP_DESTROY_SESSION:
/// DESTROY_SESSION4res /// DESTROY_SESSION4res opdestroy_session;
/// opdestroy_session;
/// ///
/// case OP_FREE_STATEID: FREE_STATEID4res /// case OP_FREE_STATEID: FREE_STATEID4res opfree_stateid;
/// opfree_stateid;
/// ///
/// case OP_GET_DIR_DELEGATION: /// case OP_GET_DIR_DELEGATION:
/// GET_DIR_DELEGATION4res /// GET_DIR_DELEGATION4res
/// opget_dir_delegation; /// opget_dir_delegation;
///
/// case OP_GETDEVICEINFO: GETDEVICEINFO4res
/// opgetdeviceinfo;
///
/// case OP_GETDEVICELIST: GETDEVICELIST4res
/// opgetdevicelist;
/// ///
/// case OP_LAYOUTCOMMIT: LAYOUTCOMMIT4res oplayoutcommit; /// case OP_GETDEVICEINFO: GETDEVICEINFO4res opgetdeviceinfo;
/// case OP_LAYOUTGET: LAYOUTGET4res oplayoutget; /// case OP_GETDEVICELIST: GETDEVICELIST4res opgetdevicelist;
/// case OP_LAYOUTRETURN: LAYOUTRETURN4res oplayoutreturn; /// case OP_LAYOUTCOMMIT: LAYOUTCOMMIT4res oplayoutcommit;
/// case OP_LAYOUTGET: LAYOUTGET4res oplayoutget;
/// case OP_LAYOUTRETURN: LAYOUTRETURN4res oplayoutreturn;
/// ///
/// case OP_SECINFO_NO_NAME: /// case OP_SECINFO_NO_NAME:
/// SECINFO_NO_NAME4res /// SECINFO_NO_NAME4res opsecinfo_no_name;
/// opsecinfo_no_name;
/// ///
/// case OP_SEQUENCE: SEQUENCE4res opsequence; /// case OP_SEQUENCE: SEQUENCE4res opsequence;
/// case OP_SET_SSV: SET_SSV4res opset_ssv; /// case OP_SET_SSV: SET_SSV4res opset_ssv;
/// case OP_TEST_STATEID: TEST_STATEID4res optest_stateid; /// case OP_TEST_STATEID: TEST_STATEID4res optest_stateid;
/// ///
/// case OP_WANT_DELEGATION: /// case OP_WANT_DELEGATION:
/// WANT_DELEGATION4res opwant_delegation;
/// WANT_DELEGATION4res
/// opwant_delegation;
/// ///
/// case OP_DESTROY_CLIENTID: /// case OP_DESTROY_CLIENTID:
/// DESTROY_CLIENTID4res /// DESTROY_CLIENTID4res
/// opdestroy_clientid; /// opdestroy_clientid;
/// ///
/// case OP_RECLAIM_COMPLETE: /// case OP_RECLAIM_COMPLETE:
/// RECLAIM_COMPLETE4res /// RECLAIM_COMPLETE4res
/// opreclaim_complete; /// opreclaim_complete;
/// ///
/// /* Operations new to NFSv4.2 */ /// /* Operations new to NFSv4.2 */
/// case OP_ALLOCATE: ALLOCATE4res opallocate; /// case OP_ALLOCATE: ALLOCATE4res opallocate;
/// case OP_COPY: COPY4res opcopy; /// case OP_COPY: COPY4res opcopy;
/// case OP_COPY_NOTIFY: COPY_NOTIFY4res opcopy_notify; /// case OP_COPY_NOTIFY: COPY_NOTIFY4res opcopy_notify;
/// case OP_DEALLOCATE: DEALLOCATE4res opdeallocate; /// case OP_DEALLOCATE: DEALLOCATE4res opdeallocate;
/// case OP_IO_ADVISE: IO_ADVISE4res opio_advise; /// case OP_IO_ADVISE: IO_ADVISE4res opio_advise;
/// case OP_LAYOUTERROR: LAYOUTERROR4res oplayouterror; /// case OP_LAYOUTERROR: LAYOUTERROR4res oplayouterror;
/// case OP_LAYOUTSTATS: LAYOUTSTATS4res oplayoutstats; /// case OP_LAYOUTSTATS: LAYOUTSTATS4res oplayoutstats;
/// case OP_OFFLOAD_CANCEL: OFFLOAD_CANCEL4res opoffload_cancel; /// case OP_OFFLOAD_CANCEL: OFFLOAD_CANCEL4res opoffload_cancel;
/// case OP_OFFLOAD_STATUS: OFFLOAD_STATUS4res opoffload_status; /// case OP_OFFLOAD_STATUS: OFFLOAD_STATUS4res opoffload_status;
/// case OP_READ_PLUS: READ_PLUS4res opread_plus; /// case OP_READ_PLUS: READ_PLUS4res opread_plus;
/// case OP_SEEK: SEEK4res opseek; /// case OP_SEEK: SEEK4res opseek;
/// case OP_WRITE_SAME: WRITE_SAME4res opwrite_same; /// case OP_WRITE_SAME: WRITE_SAME4res opwrite_same;
/// case OP_CLONE: CLONE4res opclone; /// case OP_CLONE: CLONE4res opclone;
/// ///
/// /* Operations not new to NFSv4.1 */ /// /* Operations not new to NFSv4.1 */
/// case OP_ILLEGAL: ILLEGAL4res opillegal; /// case OP_ILLEGAL: ILLEGAL4res opillegal;
/// }; /// };
/// ///
/// struct COMPOUND4args { /// struct COMPOUND4args {
/// utf8str_cs tag; /// utf8str_cs tag;
/// uint32_t minorversion; /// uint32_t minorversion;
/// nfs_argop4 argarray<>; /// nfs_argop4 argarray<>;
/// }; /// };
/// ///
/// struct COMPOUND4res { /// struct COMPOUND4res {
/// nfsstat4 status; /// nfsstat4 status;
/// utf8str_cs tag; /// utf8str_cs tag;
/// nfs_resop4 resarray<>; /// nfs_resop4 resarray<>;
/// }; /// };
/// ///
/// ///
/// /* /// /*
/// * Remote file service routines /// * Remote file service routines
/// */ /// */
/// program NFS4_PROGRAM { /// program NFS4_PROGRAM {
/// version NFS_V4 { /// version NFS_V4 {
/// void /// void
/// NFSPROC4_NULL(void) = 0; /// NFSPROC4_NULL(void) = 0;
/// ///
/// COMPOUND4res /// COMPOUND4res
/// NFSPROC4_COMPOUND(COMPOUND4args) = 1; /// NFSPROC4_COMPOUND(COMPOUND4args) = 1;
/// ///
/// } = 4; /// } = 4;
/// } = 100003; /// } = 100003;
/// ///
/// /* /// /*
/// * NFS4 Callback Procedure Definitions and Program /// * NFS4 callback procedure definitions and program
/// */ /// */
/// struct CB_GETATTR4args { /// struct CB_GETATTR4args {
/// nfs_fh4 fh; /// nfs_fh4 fh;
/// bitmap4 attr_request; /// bitmap4 attr_request;
/// }; /// };
/// ///
/// struct CB_GETATTR4resok { /// struct CB_GETATTR4resok {
/// fattr4 obj_attributes; /// fattr4 obj_attributes;
/// }; /// };
/// ///
skipping to change at page 73, line 18 skipping to change at page 77, line 28
/// LAYOUTRECALL4_ALL = LAYOUT4_RET_REC_ALL /// LAYOUTRECALL4_ALL = LAYOUT4_RET_REC_ALL
/// }; /// };
/// ///
/// struct layoutrecall_file4 { /// struct layoutrecall_file4 {
/// nfs_fh4 lor_fh; /// nfs_fh4 lor_fh;
/// offset4 lor_offset; /// offset4 lor_offset;
/// length4 lor_length; /// length4 lor_length;
/// stateid4 lor_stateid; /// stateid4 lor_stateid;
/// }; /// };
/// ///
/// union layoutrecall4 switch(layoutrecall_type4 lor_recalltype) { /// union layoutrecall4 switch (layoutrecall_type4 lor_recalltype) {
/// case LAYOUTRECALL4_FILE: /// case LAYOUTRECALL4_FILE:
/// layoutrecall_file4 lor_layout; /// layoutrecall_file4 lor_layout;
/// case LAYOUTRECALL4_FSID: /// case LAYOUTRECALL4_FSID:
/// fsid4 lor_fsid; /// fsid4 lor_fsid;
/// case LAYOUTRECALL4_ALL: /// case LAYOUTRECALL4_ALL:
/// void; /// void;
/// }; /// };
/// ///
/// struct CB_LAYOUTRECALL4args { /// struct CB_LAYOUTRECALL4args {
/// layouttype4 clora_type; /// layouttype4 clora_type;
/// layoutiomode4 clora_iomode; /// layoutiomode4 clora_iomode;
/// bool clora_changed; /// bool clora_changed;
/// layoutrecall4 clora_recall; /// layoutrecall4 clora_recall;
/// }; /// };
/// struct CB_LAYOUTRECALL4res { /// struct CB_LAYOUTRECALL4res {
/// nfsstat4 clorr_status; /// nfsstat4 clorr_status;
/// }; /// };
/// ///
/// /* /// /*
/// * Directory notification types. /// * Directory notification types
/// */ /// */
/// enum notify_type4 { /// enum notify_type4 {
/// NOTIFY4_CHANGE_CHILD_ATTRS = 0, /// NOTIFY4_CHANGE_CHILD_ATTRS = 0,
/// NOTIFY4_CHANGE_DIR_ATTRS = 1, /// NOTIFY4_CHANGE_DIR_ATTRS = 1,
/// NOTIFY4_REMOVE_ENTRY = 2, /// NOTIFY4_REMOVE_ENTRY = 2,
/// NOTIFY4_ADD_ENTRY = 3, /// NOTIFY4_ADD_ENTRY = 3,
/// NOTIFY4_RENAME_ENTRY = 4, /// NOTIFY4_RENAME_ENTRY = 4,
/// NOTIFY4_CHANGE_COOKIE_VERIFIER = 5 /// NOTIFY4_CHANGE_COOKIE_VERIFIER = 5
/// }; /// };
/// ///
/// /* Changed entry information. */ /// /* Changed entry information */
/// struct notify_entry4 { /// struct notify_entry4 {
/// component4 ne_file; /// component4 ne_file;
/// fattr4 ne_attrs; /// fattr4 ne_attrs;
/// }; /// };
/// ///
/// /* Previous entry information */ /// /* Previous entry information */
/// struct prev_entry4 { /// struct prev_entry4 {
/// notify_entry4 pe_prev_entry; /// notify_entry4 pe_prev_entry;
/// /* what READDIR returned for this entry */ /// /* What READDIR returned for this entry */
/// nfs_cookie4 pe_prev_entry_cookie; /// nfs_cookie4 pe_prev_entry_cookie;
/// }; /// };
/// ///
/// struct notify_remove4 { /// struct notify_remove4 {
/// notify_entry4 nrm_old_entry; /// notify_entry4 nrm_old_entry;
/// nfs_cookie4 nrm_old_entry_cookie; /// nfs_cookie4 nrm_old_entry_cookie;
/// }; /// };
/// ///
/// struct notify_add4 { /// struct notify_add4 {
/// /* /// /*
/// * Information on object /// * During a rename, contains
/// * possibly renamed over. /// * the object that was deleted.
/// */ /// */
/// notify_remove4 nad_old_entry<1>; /// notify_remove4 nad_old_entry<1>;
/// notify_entry4 nad_new_entry; /// notify_entry4 nad_new_entry;
/// /* what READDIR would have returned for this entry */ /// /* What READDIR would have returned for this entry */
/// nfs_cookie4 nad_new_entry_cookie<1>; /// nfs_cookie4 nad_new_entry_cookie<1>;
/// prev_entry4 nad_prev_entry<1>; /// prev_entry4 nad_prev_entry<1>;
/// bool nad_last_entry; /// bool nad_last_entry;
/// }; /// };
/// ///
/// struct notify_attr4 { /// struct notify_attr4 {
/// notify_entry4 na_changed_entry; /// notify_entry4 na_changed_entry;
/// }; /// };
/// ///
/// struct notify_rename4 { /// struct notify_rename4 {
skipping to change at page 75, line 5 skipping to change at page 79, line 21
/// verifier4 nv_new_cookieverf; /// verifier4 nv_new_cookieverf;
/// }; /// };
/// ///
/// /* /// /*
/// * Objects of type notify_<>4 and /// * Objects of type notify_<>4 and
/// * notify_device_<>4 are encoded in this. /// * notify_device_<>4 are encoded in this.
/// */ /// */
/// typedef opaque notifylist4<>; /// typedef opaque notifylist4<>;
/// ///
/// struct notify4 { /// struct notify4 {
/// /* composed from notify_type4 or notify_deviceid_type4 */ /// /* Composed from notify_type4 or notify_deviceid_type4 */
/// bitmap4 notify_mask; /// bitmap4 notify_mask;
/// notifylist4 notify_vals; /// notifylist4 notify_vals;
/// }; /// };
/// ///
/// struct CB_NOTIFY4args { /// struct CB_NOTIFY4args {
/// stateid4 cna_stateid; /// stateid4 cna_stateid;
/// nfs_fh4 cna_fh; /// nfs_fh4 cna_fh;
/// notify4 cna_changes<>; /// notify4 cna_changes<>;
/// }; /// };
/// ///
skipping to change at page 75, line 40 skipping to change at page 80, line 14
/// const RCA4_TYPE_MASK_RDATA_DLG = 0; /// const RCA4_TYPE_MASK_RDATA_DLG = 0;
/// const RCA4_TYPE_MASK_WDATA_DLG = 1; /// const RCA4_TYPE_MASK_WDATA_DLG = 1;
/// const RCA4_TYPE_MASK_DIR_DLG = 2; /// const RCA4_TYPE_MASK_DIR_DLG = 2;
/// const RCA4_TYPE_MASK_FILE_LAYOUT = 3; /// const RCA4_TYPE_MASK_FILE_LAYOUT = 3;
/// const RCA4_TYPE_MASK_BLK_LAYOUT = 4; /// const RCA4_TYPE_MASK_BLK_LAYOUT = 4;
/// const RCA4_TYPE_MASK_OBJ_LAYOUT_MIN = 8; /// const RCA4_TYPE_MASK_OBJ_LAYOUT_MIN = 8;
/// const RCA4_TYPE_MASK_OBJ_LAYOUT_MAX = 9; /// const RCA4_TYPE_MASK_OBJ_LAYOUT_MAX = 9;
/// const RCA4_TYPE_MASK_OTHER_LAYOUT_MIN = 12; /// const RCA4_TYPE_MASK_OTHER_LAYOUT_MIN = 12;
/// const RCA4_TYPE_MASK_OTHER_LAYOUT_MAX = 15; /// const RCA4_TYPE_MASK_OTHER_LAYOUT_MAX = 15;
/// ///
/// struct CB_RECALL_ANY4args { /// struct CB_RECALL_ANY4args {
/// uint32_t craa_objects_to_keep; /// uint32_t craa_objects_to_keep;
/// bitmap4 craa_type_mask; /// bitmap4 craa_type_mask;
/// }; /// };
/// ///
/// struct CB_RECALL_ANY4res { /// struct CB_RECALL_ANY4res {
/// nfsstat4 crar_status; /// nfsstat4 crar_status;
/// }; /// };
/// ///
/// typedef CB_RECALL_ANY4args CB_RECALLABLE_OBJ_AVAIL4args; /// typedef CB_RECALL_ANY4args CB_RECALLABLE_OBJ_AVAIL4args;
/// ///
/// struct CB_RECALLABLE_OBJ_AVAIL4res { /// struct CB_RECALLABLE_OBJ_AVAIL4res {
/// nfsstat4 croa_status; /// nfsstat4 croa_status;
skipping to change at page 76, line 43 skipping to change at page 81, line 22
/// ///
/// struct CB_SEQUENCE4resok { /// struct CB_SEQUENCE4resok {
/// sessionid4 csr_sessionid; /// sessionid4 csr_sessionid;
/// sequenceid4 csr_sequenceid; /// sequenceid4 csr_sequenceid;
/// slotid4 csr_slotid; /// slotid4 csr_slotid;
/// slotid4 csr_highest_slotid; /// slotid4 csr_highest_slotid;
/// slotid4 csr_target_highest_slotid; /// slotid4 csr_target_highest_slotid;
/// }; /// };
/// ///
/// union CB_SEQUENCE4res switch (nfsstat4 csr_status) { /// union CB_SEQUENCE4res switch (nfsstat4 csr_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// CB_SEQUENCE4resok csr_resok4; /// CB_SEQUENCE4resok csr_resok4;
/// default: /// default:
/// void; /// void;
/// }; /// };
/// ///
/// struct CB_WANTS_CANCELLED4args { /// struct CB_WANTS_CANCELLED4args {
/// bool cwca_contended_wants_cancelled; /// bool cwca_contended_wants_cancelled;
/// bool cwca_resourced_wants_cancelled; /// bool cwca_resourced_wants_cancelled;
/// }; /// };
/// ///
/// struct CB_WANTS_CANCELLED4res { /// struct CB_WANTS_CANCELLED4res {
/// nfsstat4 cwcr_status; /// nfsstat4 cwcr_status;
/// }; /// };
skipping to change at page 77, line 20 skipping to change at page 82, line 5
/// struct CB_NOTIFY_LOCK4args { /// struct CB_NOTIFY_LOCK4args {
/// nfs_fh4 cnla_fh; /// nfs_fh4 cnla_fh;
/// lock_owner4 cnla_lock_owner; /// lock_owner4 cnla_lock_owner;
/// }; /// };
/// ///
/// struct CB_NOTIFY_LOCK4res { /// struct CB_NOTIFY_LOCK4res {
/// nfsstat4 cnlr_status; /// nfsstat4 cnlr_status;
/// }; /// };
/// ///
/// /* /// /*
/// * Device notification types. /// * Device notification types
/// */ /// */
/// enum notify_deviceid_type4 { /// enum notify_deviceid_type4 {
/// NOTIFY_DEVICEID4_CHANGE = 1, /// NOTIFY_DEVICEID4_CHANGE = 1,
/// NOTIFY_DEVICEID4_DELETE = 2 /// NOTIFY_DEVICEID4_DELETE = 2
/// }; /// };
/// ///
/// /* For NOTIFY4_DEVICEID4_DELETE */ /// /* For NOTIFY4_DEVICEID4_DELETE */
/// struct notify_deviceid_delete4 { /// struct notify_deviceid_delete4 {
/// layouttype4 ndd_layouttype; /// layouttype4 ndd_layouttype;
/// deviceid4 ndd_deviceid; /// deviceid4 ndd_deviceid;
skipping to change at page 77, line 49 skipping to change at page 82, line 34
/// ///
/// struct CB_NOTIFY_DEVICEID4args { /// struct CB_NOTIFY_DEVICEID4args {
/// notify4 cnda_changes<>; /// notify4 cnda_changes<>;
/// }; /// };
/// ///
/// struct CB_NOTIFY_DEVICEID4res { /// struct CB_NOTIFY_DEVICEID4res {
/// nfsstat4 cndr_status; /// nfsstat4 cndr_status;
/// }; /// };
/// ///
/// union offload_info4 switch (nfsstat4 coa_status) { /// union offload_info4 switch (nfsstat4 coa_status) {
/// case NFS4_OK: /// case NFS4_OK:
/// write_response4 coa_resok4; /// write_response4 coa_resok4;
/// default: /// default:
/// length4 coa_bytes_copied;
/// length4 coa_bytes_copied;
/// }; /// };
/// struct CB_OFFLOAD4args { /// struct CB_OFFLOAD4args {
/// nfs_fh4 coa_fh; /// nfs_fh4 coa_fh;
/// stateid4 coa_stateid; /// stateid4 coa_stateid;
/// offload_info4 coa_offload_info; /// offload_info4 coa_offload_info;
/// }; /// };
/// struct CB_OFFLOAD4res { /// struct CB_OFFLOAD4res {
/// nfsstat4 cor_status; /// nfsstat4 cor_status;
/// }; /// };
/// /* /// /*
skipping to change at page 78, line 43 skipping to change at page 83, line 32
/// %/* Callback operations new to NFSv4.2 */ /// %/* Callback operations new to NFSv4.2 */
/// OP_CB_OFFLOAD = 15, /// OP_CB_OFFLOAD = 15,
/// ///
/// OP_CB_ILLEGAL = 10044 /// OP_CB_ILLEGAL = 10044
/// }; /// };
/// ///
/// union nfs_cb_argop4 switch (nfs_cb_opnum4 argop) { /// union nfs_cb_argop4 switch (nfs_cb_opnum4 argop) {
/// case OP_CB_GETATTR: /// case OP_CB_GETATTR:
/// CB_GETATTR4args opcbgetattr; /// CB_GETATTR4args opcbgetattr;
/// ///
/// /* new NFSv4.1 operations */ /// /* New NFSv4.1 operations */
/// case OP_CB_RECALL: /// case OP_CB_RECALL:
/// CB_RECALL4args opcbrecall; /// CB_RECALL4args opcbrecall;
/// case OP_CB_LAYOUTRECALL: /// case OP_CB_LAYOUTRECALL:
/// CB_LAYOUTRECALL4args opcblayoutrecall; /// CB_LAYOUTRECALL4args opcblayoutrecall;
/// case OP_CB_NOTIFY: /// case OP_CB_NOTIFY:
/// CB_NOTIFY4args opcbnotify; /// CB_NOTIFY4args opcbnotify;
/// case OP_CB_PUSH_DELEG: /// case OP_CB_PUSH_DELEG:
/// CB_PUSH_DELEG4args opcbpush_deleg; /// CB_PUSH_DELEG4args opcbpush_deleg;
/// case OP_CB_RECALL_ANY: /// case OP_CB_RECALL_ANY:
/// CB_RECALL_ANY4args opcbrecall_any; /// CB_RECALL_ANY4args opcbrecall_any;
/// case OP_CB_RECALLABLE_OBJ_AVAIL: /// case OP_CB_RECALLABLE_OBJ_AVAIL:
/// CB_RECALLABLE_OBJ_AVAIL4args opcbrecallable_obj_avail; /// CB_RECALLABLE_OBJ_AVAIL4args opcbrecallable_obj_avail;
/// case OP_CB_RECALL_SLOT: /// case OP_CB_RECALL_SLOT:
/// CB_RECALL_SLOT4args opcbrecall_slot; /// CB_RECALL_SLOT4args opcbrecall_slot;
/// case OP_CB_SEQUENCE: /// case OP_CB_SEQUENCE:
/// CB_SEQUENCE4args opcbsequence; /// CB_SEQUENCE4args opcbsequence;
/// case OP_CB_WANTS_CANCELLED: /// case OP_CB_WANTS_CANCELLED:
/// CB_WANTS_CANCELLED4args opcbwants_cancelled; /// CB_WANTS_CANCELLED4args opcbwants_cancelled;
/// case OP_CB_NOTIFY_LOCK: /// case OP_CB_NOTIFY_LOCK:
skipping to change at page 79, line 19 skipping to change at page 84, line 11
/// CB_RECALL_SLOT4args opcbrecall_slot; /// CB_RECALL_SLOT4args opcbrecall_slot;
/// case OP_CB_SEQUENCE: /// case OP_CB_SEQUENCE:
/// CB_SEQUENCE4args opcbsequence; /// CB_SEQUENCE4args opcbsequence;
/// case OP_CB_WANTS_CANCELLED: /// case OP_CB_WANTS_CANCELLED:
/// CB_WANTS_CANCELLED4args opcbwants_cancelled; /// CB_WANTS_CANCELLED4args opcbwants_cancelled;
/// case OP_CB_NOTIFY_LOCK: /// case OP_CB_NOTIFY_LOCK:
/// CB_NOTIFY_LOCK4args opcbnotify_lock; /// CB_NOTIFY_LOCK4args opcbnotify_lock;
/// case OP_CB_NOTIFY_DEVICEID: /// case OP_CB_NOTIFY_DEVICEID:
/// CB_NOTIFY_DEVICEID4args opcbnotify_deviceid; /// CB_NOTIFY_DEVICEID4args opcbnotify_deviceid;
/// ///
/// /* new NFSv4.2 operations */ /// /* New NFSv4.2 operations */
/// case OP_CB_OFFLOAD: /// case OP_CB_OFFLOAD:
/// CB_OFFLOAD4args opcboffload; /// CB_OFFLOAD4args opcboffload;
/// ///
/// case OP_CB_ILLEGAL: void; /// case OP_CB_ILLEGAL: void;
/// }; /// };
/// ///
/// union nfs_cb_resop4 switch (nfs_cb_opnum4 resop) { /// union nfs_cb_resop4 switch (nfs_cb_opnum4 resop) {
/// case OP_CB_GETATTR: CB_GETATTR4res opcbgetattr; /// case OP_CB_GETATTR: CB_GETATTR4res opcbgetattr;
/// case OP_CB_RECALL: CB_RECALL4res opcbrecall; /// case OP_CB_RECALL: CB_RECALL4res opcbrecall;
/// ///
/// /* new NFSv4.1 operations */ /// /* New NFSv4.1 operations */
/// case OP_CB_LAYOUTRECALL: /// case OP_CB_LAYOUTRECALL:
/// CB_LAYOUTRECALL4res /// CB_LAYOUTRECALL4res
/// opcblayoutrecall; /// opcblayoutrecall;
/// ///
/// case OP_CB_NOTIFY: CB_NOTIFY4res opcbnotify; /// case OP_CB_NOTIFY: CB_NOTIFY4res opcbnotify;
/// ///
/// case OP_CB_PUSH_DELEG: CB_PUSH_DELEG4res /// case OP_CB_PUSH_DELEG: CB_PUSH_DELEG4res
/// opcbpush_deleg; /// opcbpush_deleg;
/// ///
/// case OP_CB_RECALL_ANY: CB_RECALL_ANY4res /// case OP_CB_RECALL_ANY: CB_RECALL_ANY4res
skipping to change at page 80, line 16 skipping to change at page 85, line 12
/// opcbwants_cancelled; /// opcbwants_cancelled;
/// ///
/// case OP_CB_NOTIFY_LOCK: /// case OP_CB_NOTIFY_LOCK:
/// CB_NOTIFY_LOCK4res /// CB_NOTIFY_LOCK4res
/// opcbnotify_lock; /// opcbnotify_lock;
/// ///
/// case OP_CB_NOTIFY_DEVICEID: /// case OP_CB_NOTIFY_DEVICEID:
/// CB_NOTIFY_DEVICEID4res /// CB_NOTIFY_DEVICEID4res
/// opcbnotify_deviceid; /// opcbnotify_deviceid;
/// ///
/// /* new NFSv4.2 operations */ /// /* New NFSv4.2 operations */
/// case OP_CB_OFFLOAD: CB_OFFLOAD4res opcboffload; /// case OP_CB_OFFLOAD: CB_OFFLOAD4res opcboffload;
/// ///
/// /* Not new operation */ /// /* Not new operation */
/// case OP_CB_ILLEGAL: CB_ILLEGAL4res opcbillegal; /// case OP_CB_ILLEGAL: CB_ILLEGAL4res opcbillegal;
/// }; /// };
/// ///
/// ///
/// struct CB_COMPOUND4args { /// struct CB_COMPOUND4args {
/// utf8str_cs tag; /// utf8str_cs tag;
/// uint32_t minorversion; /// uint32_t minorversion;
skipping to change at page 80, line 40 skipping to change at page 85, line 36
/// ///
/// struct CB_COMPOUND4res { /// struct CB_COMPOUND4res {
/// nfsstat4 status; /// nfsstat4 status;
/// utf8str_cs tag; /// utf8str_cs tag;
/// nfs_cb_resop4 resarray<>; /// nfs_cb_resop4 resarray<>;
/// }; /// };
/// ///
/// ///
/// ///
/// /* /// /*
/// * Program number is in the transient range since the client /// * Program number is in the transient range, since the client
/// * will assign the exact transient program number and provide /// * will assign the exact transient program number and provide
/// * that to the server via the CREATE_SESSION or /// * that to the server via the CREATE_SESSION or
/// * BACKCHANNEL_CTL operations. /// * BACKCHANNEL_CTL operations.
/// */ /// */
/// program NFS4_CALLBACK { /// program NFS4_CALLBACK {
/// version NFS_CB { /// version NFS_CB {
/// void /// void
/// CB_NULL(void) = 0; /// CB_NULL(void) = 0;
/// CB_COMPOUND4res /// CB_COMPOUND4res
/// CB_COMPOUND(CB_COMPOUND4args) = 1; /// CB_COMPOUND(CB_COMPOUND4args) = 1;
/// } = 1; /// } = 1;
/// } = 0x40000000; /// } = 0x40000000;
<CODE ENDS> <CODE ENDS>
2. Security Considerations 3. Security Considerations
See the Security Considerations section of
[I-D.ietf-nfsv4-minorversion2].
3. IANA Considerations See the Security Considerations section of [RFC7862].
See the IANA Considerations section of 4. IANA Considerations
[I-D.ietf-nfsv4-minorversion2].
4. Normative References See the IANA Considerations section of [RFC7862].
[I-D.ietf-nfsv4-minorversion2] 5. Normative References
Haynes, T., "NFS Version 4 Minor Version 2", draft-ietf-
nfsv4-minorversion2-40 (work in progress), January 2016.
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", March 1997. Requirement Levels", BCP 14, RFC 2119,
DOI 10.17487/RFC2119, March 1997,
<http://www.rfc-editor.org/info/rfc2119>.
[RFC4506] Eisler, M., "XDR: External Data Representation Standard", [RFC4506] Eisler, M., Ed., "XDR: External Data Representation
STD 67, RFC 4506, May 2006. Standard", STD 67, RFC 4506, DOI 10.17487/RFC4506,
May 2006, <http://www.rfc-editor.org/info/rfc4506>.
[RFC5662] Shepler, S., Eisler, M., and D. Noveck, "Network File [RFC5662] Shepler, S., Ed., Eisler, M., Ed., and D. Noveck, Ed.,
System (NFS) Version 4 Minor Version 1 External Data "Network File System (NFS) Version 4 Minor Version 1
Representation Standard (XDR) Description", RFC 5662, External Data Representation Standard (XDR) Description",
January 2010. RFC 5662, DOI 10.17487/RFC5662, January 2010,
<http://www.rfc-editor.org/info/rfc5662>.
[RFC7531] Haynes, T. and D. Noveck, "Network File System (NFS) [RFC7531] Haynes, T., Ed., and D. Noveck, Ed., "Network File System
version 4 Protocol External Data Representation Standard (NFS) Version 4 External Data Representation Standard
(XDR) Description", RFC 7531, March 2015. (XDR) Description", RFC 7531, DOI 10.17487/RFC7531,
March 2015, <http://www.rfc-editor.org/info/rfc7531>.
Appendix A. Acknowledgments [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 Tom Haynes would like to thank NetApp, Inc. for its funding of his
time on this project. time on this project.
Appendix B. RFC Editor Notes
[RFC Editor: please remove this section prior to publishing this
document as an RFC]
[RFC Editor: prior to publishing this document as an RFC, please
replace all occurrences of I-D.ietf-nfsv4-minorversion2 with RFCxxxx
where xxxx is the RFC number of the companion document]
Author's Address Author's Address
Thomas Haynes Thomas Haynes
Primary Data, Inc. Primary Data, Inc.
4300 El Camino Real Ste 100 4300 El Camino Real Ste 100
Los Altos, CA 94022 Los Altos, CA 94022
USA United States of America
Phone: +1-408-215-1519 Phone: +1 408 215 1519
Email: thomas.haynes@primarydata.com Email: thomas.haynes@primarydata.com
 End of changes. 276 change blocks. 
813 lines changed or deleted 774 lines changed or added

This html diff was produced by rfcdiff 1.45. The latest version is available from http://tools.ietf.org/tools/rfcdiff/