usr/src/uts/common/nfs/nfs4_kprot.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
  24  */
  25
  26 /*
  27  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30
  31 #ifndef _NFS4_KPROT_H
  32 #define _NFS4_KPROT_H
  33
  34 /*
  35  * Kernel specific version.
  36  * NFS Version 4 protocol definitions.  From nfs4_prot.x rev 1.119.
  37  */
  38
  39 #ifdef __cplusplus
  40 extern "C" {
  41 #endif
  42
  43 #include <rpc/rpc.h>
  44 #ifdef _KERNEL
  45 #include <rpc/rpc_rdma.h>
  46 #endif
  47 #include <sys/stream.h>
  48
  49 #define NFS4_FHSIZE 128
  50 #define NFS4_VERIFIER_SIZE 8
  51 #define NFS4_OTHER_SIZE 12
  52
  53 /*
  54  * Reasonable upper bounds to catch badly behaving partners
  55  */
  56 #define NFS4_OPAQUE_LIMIT       1024
  57 #define NFS4_COMPOUND_LIMIT     2048
  58 #define NFS4_FS_LOCATIONS_LIMIT 65536
  59 #define NFS4_ACL_LIMIT          65536
  60 #define NFS4_SECINFO_LIMIT      65536
  61 #define NFS4_FATTR4_LIMIT       1048576
  62 #define NFS4_DATA_LIMIT         134217728
  63
  64 enum nfs_ftype4 {
  65         NF4REG = 1,
  66         NF4DIR = 2,
  67         NF4BLK = 3,
  68         NF4CHR = 4,
  69         NF4LNK = 5,
  70         NF4SOCK = 6,
  71         NF4FIFO = 7,
  72         NF4ATTRDIR = 8,
  73         NF4NAMEDATTR = 9
  74 };
  75 typedef enum nfs_ftype4 nfs_ftype4;
  76
  77 enum nfsstat4 {
  78         NFS4_OK = 0,
  79         NFS4ERR_PERM = 1,
  80         NFS4ERR_NOENT = 2,
  81         NFS4ERR_IO = 5,
  82         NFS4ERR_NXIO = 6,
  83         NFS4ERR_ACCESS = 13,
  84         NFS4ERR_EXIST = 17,
  85         NFS4ERR_XDEV = 18,
  86         NFS4ERR_NOTDIR = 20,
  87         NFS4ERR_ISDIR = 21,
  88         NFS4ERR_INVAL = 22,
  89         NFS4ERR_FBIG = 27,
  90         NFS4ERR_NOSPC = 28,
  91         NFS4ERR_ROFS = 30,
  92         NFS4ERR_MLINK = 31,
  93         NFS4ERR_NAMETOOLONG = 63,
  94         NFS4ERR_NOTEMPTY = 66,
  95         NFS4ERR_DQUOT = 69,
  96         NFS4ERR_STALE = 70,
  97         NFS4ERR_BADHANDLE = 10001,
  98         NFS4ERR_BAD_COOKIE = 10003,
  99         NFS4ERR_NOTSUPP = 10004,
 100         NFS4ERR_TOOSMALL = 10005,
 101         NFS4ERR_SERVERFAULT = 10006,
 102         NFS4ERR_BADTYPE = 10007,
 103         NFS4ERR_DELAY = 10008,
 104         NFS4ERR_SAME = 10009,
 105         NFS4ERR_DENIED = 10010,
 106         NFS4ERR_EXPIRED = 10011,
 107         NFS4ERR_LOCKED = 10012,
 108         NFS4ERR_GRACE = 10013,
 109         NFS4ERR_FHEXPIRED = 10014,
 110         NFS4ERR_SHARE_DENIED = 10015,
 111         NFS4ERR_WRONGSEC = 10016,
 112         NFS4ERR_CLID_INUSE = 10017,
 113         NFS4ERR_RESOURCE = 10018,
 114         NFS4ERR_MOVED = 10019,
 115         NFS4ERR_NOFILEHANDLE = 10020,
 116         NFS4ERR_MINOR_VERS_MISMATCH = 10021,
 117         NFS4ERR_STALE_CLIENTID = 10022,
 118         NFS4ERR_STALE_STATEID = 10023,
 119         NFS4ERR_OLD_STATEID = 10024,
 120         NFS4ERR_BAD_STATEID = 10025,
 121         NFS4ERR_BAD_SEQID = 10026,
 122         NFS4ERR_NOT_SAME = 10027,
 123         NFS4ERR_LOCK_RANGE = 10028,
 124         NFS4ERR_SYMLINK = 10029,
 125         NFS4ERR_RESTOREFH = 10030,
 126         NFS4ERR_LEASE_MOVED = 10031,
 127         NFS4ERR_ATTRNOTSUPP = 10032,
 128         NFS4ERR_NO_GRACE = 10033,
 129         NFS4ERR_RECLAIM_BAD = 10034,
 130         NFS4ERR_RECLAIM_CONFLICT = 10035,
 131         NFS4ERR_BADXDR = 10036,
 132         NFS4ERR_LOCKS_HELD = 10037,
 133         NFS4ERR_OPENMODE = 10038,
 134         NFS4ERR_BADOWNER = 10039,
 135         NFS4ERR_BADCHAR = 10040,
 136         NFS4ERR_BADNAME = 10041,
 137         NFS4ERR_BAD_RANGE = 10042,
 138         NFS4ERR_LOCK_NOTSUPP = 10043,
 139         NFS4ERR_OP_ILLEGAL = 10044,
 140         NFS4ERR_DEADLOCK = 10045,
 141         NFS4ERR_FILE_OPEN = 10046,
 142         NFS4ERR_ADMIN_REVOKED = 10047,
 143         NFS4ERR_CB_PATH_DOWN = 10048
 144 };
 145 typedef enum nfsstat4 nfsstat4;
 146
 147 /*
 148  * A bitmap can only be 56 bits, treat it as a uint64_t for now
 149  */
 150 typedef uint64_t bitmap4;
 151
 152 typedef uint64_t offset4;
 153
 154 typedef uint32_t count4;
 155
 156 typedef uint64_t length4;
 157
 158 typedef uint64_t clientid4;
 159
 160 typedef uint32_t nfs_lease4;
 161
 162 typedef uint32_t seqid4;
 163
 164 typedef struct {
 165         uint_t utf8string_len;
 166         char *utf8string_val;
 167 } utf8string;
 168
 169 typedef utf8string component4;
 170
 171 typedef struct {
 172         uint_t pathname4_len;
 173         component4 *pathname4_val;
 174 } pathname4;
 175
 176 typedef uint64_t nfs_lockid4;
 177
 178 typedef uint64_t nfs_cookie4;
 179
 180 typedef struct {
 181         uint_t linktext4_len;
 182         char *linktext4_val;
 183 } linktext4;
 184
 185 typedef utf8string ascii_REQUIRED4;
 186
 187 typedef struct {
 188         uint_t sec_oid4_len;
 189         char *sec_oid4_val;
 190 } sec_oid4;
 191
 192 typedef uint32_t qop4;
 193
 194 typedef uint32_t mode4;
 195
 196 typedef uint64_t changeid4;
 197
 198 typedef uint64_t verifier4;
 199
 200 struct nfstime4 {
 201         int64_t seconds;
 202         uint32_t nseconds;
 203 };
 204 typedef struct nfstime4 nfstime4;
 205
 206 enum time_how4 {
 207         SET_TO_SERVER_TIME4 = 0,
 208         SET_TO_CLIENT_TIME4 = 1
 209 };
 210 typedef enum time_how4 time_how4;
 211
 212 struct settime4 {
 213         time_how4 set_it;
 214         nfstime4 time;
 215 };
 216 typedef struct settime4 settime4;
 217
 218 typedef struct {
 219         uint_t nfs_fh4_len;
 220         char *nfs_fh4_val;
 221 } nfs_fh4;
 222
 223 struct fsid4 {
 224         uint64_t major;
 225         uint64_t minor;
 226 };
 227 typedef struct fsid4 fsid4;
 228
 229 struct fs_location4 {
 230         uint_t server_len;
 231         utf8string *server_val;
 232         pathname4 rootpath;
 233 };
 234 typedef struct fs_location4 fs_location4;
 235
 236 struct fs_locations4 {
 237         pathname4 fs_root;
 238         uint_t locations_len;
 239         fs_location4 *locations_val;
 240 };
 241 typedef struct fs_locations4 fs_locations4;
 242
 243 /*
 244  * This structure is declared in nfs4.h
 245  */
 246 struct nfs_fsl_info;
 247
 248 /*
 249  * ACL support
 250  */
 251
 252 #define ACL4_SUPPORT_ALLOW_ACL 0x00000001
 253 #define ACL4_SUPPORT_DENY_ACL 0x00000002
 254 #define ACL4_SUPPORT_AUDIT_ACL 0x00000004
 255 #define ACL4_SUPPORT_ALARM_ACL 0x00000008
 256
 257 typedef uint32_t acetype4;
 258 #define ACE4_ACCESS_ALLOWED_ACE_TYPE 0x00000000
 259 #define ACE4_ACCESS_DENIED_ACE_TYPE 0x00000001
 260 #define ACE4_SYSTEM_AUDIT_ACE_TYPE 0x00000002
 261 #define ACE4_SYSTEM_ALARM_ACE_TYPE 0x00000003
 262
 263 typedef uint32_t aceflag4;
 264 #define ACE4_FILE_INHERIT_ACE 0x00000001
 265 #define ACE4_DIRECTORY_INHERIT_ACE 0x00000002
 266 #define ACE4_NO_PROPAGATE_INHERIT_ACE 0x00000004
 267 #define ACE4_INHERIT_ONLY_ACE 0x00000008
 268 #define ACE4_SUCCESSFUL_ACCESS_ACE_FLAG 0x00000010
 269 #define ACE4_FAILED_ACCESS_ACE_FLAG 0x00000020
 270 #define ACE4_IDENTIFIER_GROUP 0x00000040
 271 /*
 272  * This defines all valid flag bits, as defined by RFC 3530.  If
 273  * any additional flag bits are deemed part of the NFSv4 spec,
 274  * you must also add them to the definition below.
 275  */
 276 #define ACE4_VALID_FLAG_BITS (\
 277     ACE4_FILE_INHERIT_ACE | \
 278     ACE4_DIRECTORY_INHERIT_ACE | \
 279     ACE4_NO_PROPAGATE_INHERIT_ACE | \
 280     ACE4_INHERIT_ONLY_ACE | \
 281     ACE4_SUCCESSFUL_ACCESS_ACE_FLAG | \
 282     ACE4_FAILED_ACCESS_ACE_FLAG | \
 283     ACE4_IDENTIFIER_GROUP)
 284
 285 typedef uint32_t acemask4;
 286 #define ACE4_READ_DATA 0x00000001
 287 #define ACE4_LIST_DIRECTORY 0x00000001
 288 #define ACE4_WRITE_DATA 0x00000002
 289 #define ACE4_ADD_FILE 0x00000002
 290 #define ACE4_APPEND_DATA 0x00000004
 291 #define ACE4_ADD_SUBDIRECTORY 0x00000004
 292 #define ACE4_READ_NAMED_ATTRS 0x00000008
 293 #define ACE4_WRITE_NAMED_ATTRS 0x00000010
 294 #define ACE4_EXECUTE 0x00000020
 295 #define ACE4_DELETE_CHILD 0x00000040
 296 #define ACE4_READ_ATTRIBUTES 0x00000080
 297 #define ACE4_WRITE_ATTRIBUTES 0x00000100
 298 #define ACE4_DELETE 0x00010000
 299 #define ACE4_READ_ACL 0x00020000
 300 #define ACE4_WRITE_ACL 0x00040000
 301 #define ACE4_WRITE_OWNER 0x00080000
 302 #define ACE4_SYNCHRONIZE 0x00100000
 303 #define ACE4_GENERIC_READ 0x00120081
 304 #define ACE4_GENERIC_WRITE 0x00160106
 305 #define ACE4_GENERIC_EXECUTE 0x001200A0
 306 /*
 307  * This defines all valid access mask bits, as defined by RFC 3530.  If
 308  * any additional access mask bits are deemed part of the NFSv4 spec,
 309  * you must also add them to the definition below.
 310  */
 311 #define ACE4_VALID_MASK_BITS (\
 312     ACE4_READ_DATA | \
 313     ACE4_LIST_DIRECTORY | \
 314     ACE4_WRITE_DATA | \
 315     ACE4_ADD_FILE | \
 316     ACE4_APPEND_DATA | \
 317     ACE4_ADD_SUBDIRECTORY | \
 318     ACE4_READ_NAMED_ATTRS | \
 319     ACE4_WRITE_NAMED_ATTRS | \
 320     ACE4_EXECUTE | \
 321     ACE4_DELETE_CHILD | \
 322     ACE4_READ_ATTRIBUTES | \
 323     ACE4_WRITE_ATTRIBUTES | \
 324     ACE4_DELETE | \
 325     ACE4_READ_ACL | \
 326     ACE4_WRITE_ACL | \
 327     ACE4_WRITE_OWNER | \
 328     ACE4_SYNCHRONIZE)
 329
 330 /* Used to signify an undefined value for an acemask4 */
 331 #define ACE4_MASK_UNDEFINED 0x80000000
 332
 333 #define ACE4_WHO_OWNER          "OWNER@"
 334 #define ACE4_WHO_GROUP          "GROUP@"
 335 #define ACE4_WHO_EVERYONE       "EVERYONE@"
 336
 337 struct nfsace4 {
 338         acetype4 type;
 339         aceflag4 flag;
 340         acemask4 access_mask;
 341         utf8string who;
 342 };
 343 typedef struct nfsace4 nfsace4;
 344 #define MODE4_SUID 0x800
 345 #define MODE4_SGID 0x400
 346 #define MODE4_SVTX 0x200
 347 #define MODE4_RUSR 0x100
 348 #define MODE4_WUSR 0x080
 349 #define MODE4_XUSR 0x040
 350 #define MODE4_RGRP 0x020
 351 #define MODE4_WGRP 0x010
 352 #define MODE4_XGRP 0x008
 353 #define MODE4_ROTH 0x004
 354 #define MODE4_WOTH 0x002
 355 #define MODE4_XOTH 0x001
 356
 357 /*
 358  * ACL conversion helpers
 359  */
 360
 361 typedef enum {
 362         ace4_unused,
 363         ace4_user_obj,
 364         ace4_user,
 365         ace4_group, /* includes GROUP and GROUP_OBJ */
 366         ace4_other_obj
 367 } ace4_to_aent_state_t;
 368
 369 typedef struct ace4vals {
 370         utf8string *key; /* NB: not allocated here; points to existing utf8 */
 371         avl_node_t avl;
 372         acemask4 mask;
 373         acemask4 allowed;
 374         acemask4 denied;
 375         int aent_type;
 376 } ace4vals_t;
 377
 378 typedef struct ace4_list {
 379         ace4vals_t user_obj;
 380         avl_tree_t user;
 381         int numusers;
 382         ace4vals_t group_obj;
 383         avl_tree_t group;
 384         int numgroups;
 385         ace4vals_t other_obj;
 386         acemask4 acl_mask;
 387         int hasmask;
 388         int dfacl_flag;
 389         ace4_to_aent_state_t state;
 390         int seen; /* bitmask of all aclent_t a_type values seen */
 391 } ace4_list_t;
 392
 393 struct specdata4 {
 394         uint32_t specdata1;
 395         uint32_t specdata2;
 396 };
 397 typedef struct specdata4 specdata4;
 398 #define FH4_PERSISTENT 0x00000000
 399 #define FH4_NOEXPIRE_WITH_OPEN 0x00000001
 400 #define FH4_VOLATILE_ANY 0x00000002
 401 #define FH4_VOL_MIGRATION 0x00000004
 402 #define FH4_VOL_RENAME 0x00000008
 403
 404 typedef bitmap4 fattr4_supported_attrs;
 405
 406 typedef nfs_ftype4 fattr4_type;
 407
 408 typedef uint32_t fattr4_fh_expire_type;
 409
 410 typedef changeid4 fattr4_change;
 411
 412 typedef uint64_t fattr4_size;
 413
 414 typedef bool_t fattr4_link_support;
 415
 416 typedef bool_t fattr4_symlink_support;
 417
 418 typedef bool_t fattr4_named_attr;
 419
 420 typedef fsid4 fattr4_fsid;
 421
 422 typedef bool_t fattr4_unique_handles;
 423
 424 typedef nfs_lease4 fattr4_lease_time;
 425
 426 typedef nfsstat4 fattr4_rdattr_error;
 427
 428 typedef struct {
 429         uint_t fattr4_acl_len;
 430         nfsace4 *fattr4_acl_val;
 431 } fattr4_acl;
 432
 433 typedef uint32_t fattr4_aclsupport;
 434
 435 typedef bool_t fattr4_archive;
 436
 437 typedef bool_t fattr4_cansettime;
 438
 439 typedef bool_t fattr4_case_insensitive;
 440
 441 typedef bool_t fattr4_case_preserving;
 442
 443 typedef bool_t fattr4_chown_restricted;
 444
 445 typedef uint64_t fattr4_fileid;
 446
 447 typedef uint64_t fattr4_files_avail;
 448
 449 typedef nfs_fh4 fattr4_filehandle;
 450
 451 typedef uint64_t fattr4_files_free;
 452
 453 typedef uint64_t fattr4_files_total;
 454
 455 typedef fs_locations4 fattr4_fs_locations;
 456
 457 typedef bool_t fattr4_hidden;
 458
 459 typedef bool_t fattr4_homogeneous;
 460
 461 typedef uint64_t fattr4_maxfilesize;
 462
 463 typedef uint32_t fattr4_maxlink;
 464
 465 typedef uint32_t fattr4_maxname;
 466
 467 typedef uint64_t fattr4_maxread;
 468
 469 typedef uint64_t fattr4_maxwrite;
 470
 471 typedef ascii_REQUIRED4 fattr4_mimetype;
 472
 473 typedef mode4 fattr4_mode;
 474
 475 typedef uint64_t fattr4_mounted_on_fileid;
 476
 477 typedef bool_t fattr4_no_trunc;
 478
 479 typedef uint32_t fattr4_numlinks;
 480
 481 typedef utf8string fattr4_owner;
 482
 483 typedef utf8string fattr4_owner_group;
 484
 485 typedef uint64_t fattr4_quota_avail_hard;
 486
 487 typedef uint64_t fattr4_quota_avail_soft;
 488
 489 typedef uint64_t fattr4_quota_used;
 490
 491 typedef specdata4 fattr4_rawdev;
 492
 493 typedef uint64_t fattr4_space_avail;
 494
 495 typedef uint64_t fattr4_space_free;
 496
 497 typedef uint64_t fattr4_space_total;
 498
 499 typedef uint64_t fattr4_space_used;
 500
 501 typedef bool_t fattr4_system;
 502
 503 typedef nfstime4 fattr4_time_access;
 504
 505 typedef settime4 fattr4_time_access_set;
 506
 507 typedef nfstime4 fattr4_time_backup;
 508
 509 typedef nfstime4 fattr4_time_create;
 510
 511 typedef nfstime4 fattr4_time_delta;
 512
 513 typedef nfstime4 fattr4_time_metadata;
 514
 515 typedef nfstime4 fattr4_time_modify;
 516
 517 typedef settime4 fattr4_time_modify_set;
 518 #define FATTR4_SUPPORTED_ATTRS 0
 519 #define FATTR4_TYPE 1
 520 #define FATTR4_FH_EXPIRE_TYPE 2
 521 #define FATTR4_CHANGE 3
 522 #define FATTR4_SIZE 4
 523 #define FATTR4_LINK_SUPPORT 5
 524 #define FATTR4_SYMLINK_SUPPORT 6
 525 #define FATTR4_NAMED_ATTR 7
 526 #define FATTR4_FSID 8
 527 #define FATTR4_UNIQUE_HANDLES 9
 528 #define FATTR4_LEASE_TIME 10
 529 #define FATTR4_RDATTR_ERROR 11
 530 #define FATTR4_FILEHANDLE 19
 531 #define FATTR4_ACL 12
 532 #define FATTR4_ACLSUPPORT 13
 533 #define FATTR4_ARCHIVE 14
 534 #define FATTR4_CANSETTIME 15
 535 #define FATTR4_CASE_INSENSITIVE 16
 536 #define FATTR4_CASE_PRESERVING 17
 537 #define FATTR4_CHOWN_RESTRICTED 18
 538 #define FATTR4_FILEID 20
 539 #define FATTR4_FILES_AVAIL 21
 540 #define FATTR4_FILES_FREE 22
 541 #define FATTR4_FILES_TOTAL 23
 542 #define FATTR4_FS_LOCATIONS 24
 543 #define FATTR4_HIDDEN 25
 544 #define FATTR4_HOMOGENEOUS 26
 545 #define FATTR4_MAXFILESIZE 27
 546 #define FATTR4_MAXLINK 28
 547 #define FATTR4_MAXNAME 29
 548 #define FATTR4_MAXREAD 30
 549 #define FATTR4_MAXWRITE 31
 550 #define FATTR4_MIMETYPE 32
 551 #define FATTR4_MODE 33
 552 #define FATTR4_NO_TRUNC 34
 553 #define FATTR4_NUMLINKS 35
 554 #define FATTR4_OWNER 36
 555 #define FATTR4_OWNER_GROUP 37
 556 #define FATTR4_QUOTA_AVAIL_HARD 38
 557 #define FATTR4_QUOTA_AVAIL_SOFT 39
 558 #define FATTR4_QUOTA_USED 40
 559 #define FATTR4_RAWDEV 41
 560 #define FATTR4_SPACE_AVAIL 42
 561 #define FATTR4_SPACE_FREE 43
 562 #define FATTR4_SPACE_TOTAL 44
 563 #define FATTR4_SPACE_USED 45
 564 #define FATTR4_SYSTEM 46
 565 #define FATTR4_TIME_ACCESS 47
 566 #define FATTR4_TIME_ACCESS_SET 48
 567 #define FATTR4_TIME_BACKUP 49
 568 #define FATTR4_TIME_CREATE 50
 569 #define FATTR4_TIME_DELTA 51
 570 #define FATTR4_TIME_METADATA 52
 571 #define FATTR4_TIME_MODIFY 53
 572 #define FATTR4_TIME_MODIFY_SET 54
 573 #define FATTR4_MOUNTED_ON_FILEID 55
 574
 575 struct fattr4 {
 576         bitmap4 attrmask;
 577         char *attrlist4;
 578         uint_t attrlist4_len;
 579 };
 580 typedef struct fattr4 fattr4;
 581
 582 struct change_info4 {
 583         bool_t atomic;
 584         changeid4 before;
 585         changeid4 after;
 586 };
 587 typedef struct change_info4 change_info4;
 588
 589 struct clientaddr4 {
 590         char *r_netid;
 591         char *r_addr;
 592 };
 593 typedef struct clientaddr4 clientaddr4;
 594
 595 struct cb_client4 {
 596         uint_t cb_program;
 597         clientaddr4 cb_location;
 598 };
 599 typedef struct cb_client4 cb_client4;
 600
 601 struct stateid4 {
 602         uint32_t seqid;
 603         char other[NFS4_OTHER_SIZE];
 604 };
 605 typedef struct stateid4 stateid4;
 606
 607 struct nfs_client_id4 {
 608         verifier4 verifier;
 609         uint_t id_len;
 610         char *id_val;
 611         struct sockaddr *cl_addr;
 612 };
 613 typedef struct nfs_client_id4 nfs_client_id4;
 614
 615 struct open_owner4 {
 616         clientid4 clientid;
 617         uint_t owner_len;
 618         char *owner_val;
 619 };
 620 typedef struct open_owner4 open_owner4;
 621
 622 struct lock_owner4 {
 623         clientid4 clientid;
 624         uint_t owner_len;
 625         char *owner_val;
 626 };
 627 typedef struct lock_owner4 lock_owner4;
 628
 629 enum nfs_lock_type4 {
 630         READ_LT = 1,
 631         WRITE_LT = 2,
 632         READW_LT = 3,
 633         WRITEW_LT = 4
 634 };
 635 typedef enum nfs_lock_type4 nfs_lock_type4;
 636 #define ACCESS4_READ 0x00000001
 637 #define ACCESS4_LOOKUP 0x00000002
 638 #define ACCESS4_MODIFY 0x00000004
 639 #define ACCESS4_EXTEND 0x00000008
 640 #define ACCESS4_DELETE 0x00000010
 641 #define ACCESS4_EXECUTE 0x00000020
 642
 643 struct ACCESS4args {
 644         uint32_t access;
 645 };
 646 typedef struct ACCESS4args ACCESS4args;
 647
 648 struct ACCESS4res {
 649         nfsstat4 status;
 650         uint32_t supported;
 651         uint32_t access;
 652 };
 653 typedef struct ACCESS4res ACCESS4res;
 654
 655 struct CLOSE4args {
 656         seqid4 seqid;
 657         stateid4 open_stateid;
 658 };
 659 typedef struct CLOSE4args CLOSE4args;
 660
 661 struct CLOSE4res {
 662         nfsstat4 status;
 663         stateid4 open_stateid;
 664 };
 665 typedef struct CLOSE4res CLOSE4res;
 666
 667 struct COMMIT4args {
 668         offset4 offset;
 669         count4 count;
 670 };
 671 typedef struct COMMIT4args COMMIT4args;
 672
 673 struct COMMIT4res {
 674         nfsstat4 status;
 675         verifier4 writeverf;
 676 };
 677 typedef struct COMMIT4res COMMIT4res;
 678
 679 struct CREATE4args {
 680         nfs_ftype4 type;
 681         union {
 682                 linktext4 linkdata;
 683                 specdata4 devdata;
 684         } ftype4_u;
 685         component4 objname;
 686         fattr4 createattrs;
 687 };
 688 typedef struct CREATE4args CREATE4args;
 689
 690 struct CREATE4cargs {
 691         nfs_ftype4 type;
 692         union {
 693                 char *clinkdata;
 694                 specdata4 devdata;
 695         } ftype4_u;
 696         char *cname;
 697         fattr4 createattrs;
 698 };
 699 typedef struct CREATE4cargs CREATE4cargs;
 700
 701 struct CREATE4res {
 702         nfsstat4 status;
 703         change_info4 cinfo;
 704         bitmap4 attrset;
 705 };
 706 typedef struct CREATE4res CREATE4res;
 707
 708 struct DELEGPURGE4args {
 709         clientid4 clientid;
 710 };
 711 typedef struct DELEGPURGE4args DELEGPURGE4args;
 712
 713 struct DELEGPURGE4res {
 714         nfsstat4 status;
 715 };
 716 typedef struct DELEGPURGE4res DELEGPURGE4res;
 717
 718 struct DELEGRETURN4args {
 719         stateid4 deleg_stateid;
 720 };
 721 typedef struct DELEGRETURN4args DELEGRETURN4args;
 722
 723 struct DELEGRETURN4res {
 724         nfsstat4 status;
 725 };
 726 typedef struct DELEGRETURN4res DELEGRETURN4res;
 727
 728 struct mntinfo4;
 729
 730 struct GETATTR4args {
 731         bitmap4 attr_request;
 732         struct mntinfo4 *mi;
 733 };
 734 typedef struct GETATTR4args GETATTR4args;
 735
 736 struct nfs4_ga_ext_res;
 737
 738 struct nfs4_ga_res {
 739         vattr_t                         n4g_va;
 740         unsigned                        n4g_change_valid:1;
 741         unsigned                        n4g_mon_fid_valid:1;
 742         unsigned                        n4g_fsid_valid:1;
 743         uint_t                          n4g_attrerr;
 744         uint_t                          n4g_attrwhy;
 745         bitmap4                         n4g_resbmap;
 746         fattr4_change                   n4g_change;
 747         fattr4_fsid                     n4g_fsid;
 748         fattr4_mounted_on_fileid        n4g_mon_fid;
 749         struct nfs4_ga_ext_res          *n4g_ext_res;
 750         vsecattr_t                      n4g_vsa;
 751 };
 752 typedef struct nfs4_ga_res nfs4_ga_res_t;
 753
 754 struct GETATTR4res {
 755         nfsstat4 status;
 756         fattr4 obj_attributes;
 757         nfsstat4        ga_status;
 758         struct nfs4_ga_res ga_res;
 759 };
 760 typedef struct GETATTR4res GETATTR4res;
 761
 762 struct GETFH4res {
 763         nfsstat4 status;
 764         nfs_fh4 object;
 765 };
 766 typedef struct GETFH4res GETFH4res;
 767
 768 struct LINK4args {
 769         component4 newname;
 770 };
 771 typedef struct LINK4args LINK4args;
 772
 773 struct LINK4cargs {
 774         char *cnewname;
 775 };
 776 typedef struct LINK4cargs LINK4cargs;
 777
 778 struct LINK4res {
 779         nfsstat4 status;
 780         change_info4 cinfo;
 781 };
 782 typedef struct LINK4res LINK4res;
 783
 784 struct open_to_lock_owner4 {
 785         seqid4 open_seqid;
 786         stateid4 open_stateid;
 787         seqid4 lock_seqid;
 788         lock_owner4 lock_owner;
 789 };
 790 typedef struct open_to_lock_owner4 open_to_lock_owner4;
 791
 792 struct exist_lock_owner4 {
 793         stateid4 lock_stateid;
 794         seqid4 lock_seqid;
 795 };
 796 typedef struct exist_lock_owner4 exist_lock_owner4;
 797
 798 struct locker4 {
 799         bool_t new_lock_owner;
 800         union {
 801                 open_to_lock_owner4 open_owner;
 802                 exist_lock_owner4 lock_owner;
 803         } locker4_u;
 804 };
 805 typedef struct locker4 locker4;
 806
 807 struct LOCK4args {
 808         nfs_lock_type4 locktype;
 809         bool_t reclaim;
 810         offset4 offset;
 811         length4 length;
 812         locker4 locker;
 813 };
 814 typedef struct LOCK4args LOCK4args;
 815
 816 struct LOCK4denied {
 817         offset4 offset;
 818         length4 length;
 819         nfs_lock_type4 locktype;
 820         lock_owner4 owner;
 821 };
 822 typedef struct LOCK4denied LOCK4denied;
 823
 824 struct LOCK4res {
 825         nfsstat4 status;
 826         union {
 827                 stateid4 lock_stateid;
 828                 LOCK4denied denied;
 829         } LOCK4res_u;
 830 };
 831 typedef struct LOCK4res LOCK4res;
 832
 833 struct LOCKT4args {
 834         nfs_lock_type4 locktype;
 835         offset4 offset;
 836         length4 length;
 837         lock_owner4 owner;
 838 };
 839 typedef struct LOCKT4args LOCKT4args;
 840
 841 struct LOCKT4res {
 842         nfsstat4 status;
 843         LOCK4denied denied;
 844 };
 845 typedef struct LOCKT4res LOCKT4res;
 846
 847 struct LOCKU4args {
 848         nfs_lock_type4 locktype;
 849         seqid4 seqid;
 850         stateid4 lock_stateid;
 851         offset4 offset;
 852         length4 length;
 853 };
 854 typedef struct LOCKU4args LOCKU4args;
 855
 856 struct LOCKU4res {
 857         nfsstat4 status;
 858         stateid4 lock_stateid;
 859 };
 860 typedef struct LOCKU4res LOCKU4res;
 861
 862 struct LOOKUP4args {
 863         component4 objname;
 864 };
 865 typedef struct LOOKUP4args LOOKUP4args;
 866
 867 struct LOOKUP4cargs {
 868         char *cname;
 869 };
 870 typedef struct LOOKUP4cargs LOOKUP4cargs;
 871
 872 struct LOOKUP4res {
 873         nfsstat4 status;
 874 };
 875 typedef struct LOOKUP4res LOOKUP4res;
 876
 877 struct LOOKUPP4res {
 878         nfsstat4 status;
 879 };
 880 typedef struct LOOKUPP4res LOOKUPP4res;
 881
 882 struct NVERIFY4args {
 883         fattr4 obj_attributes;
 884 };
 885 typedef struct NVERIFY4args NVERIFY4args;
 886
 887 struct NVERIFY4res {
 888         nfsstat4 status;
 889 };
 890 typedef struct NVERIFY4res NVERIFY4res;
 891
 892 enum createmode4 {
 893         UNCHECKED4 = 0,
 894         GUARDED4 = 1,
 895         EXCLUSIVE4 = 2
 896 };
 897 typedef enum createmode4 createmode4;
 898
 899 enum opentype4 {
 900         OPEN4_NOCREATE = 0,
 901         OPEN4_CREATE = 1
 902 };
 903 typedef enum opentype4 opentype4;
 904
 905 enum limit_by4 {
 906         NFS_LIMIT_SIZE = 1,
 907         NFS_LIMIT_BLOCKS = 2
 908 };
 909 typedef enum limit_by4 limit_by4;
 910
 911 struct nfs_modified_limit4 {
 912         uint32_t num_blocks;
 913         uint32_t bytes_per_block;
 914 };
 915 typedef struct nfs_modified_limit4 nfs_modified_limit4;
 916
 917 struct nfs_space_limit4 {
 918         limit_by4 limitby;
 919         union {
 920                 uint64_t filesize;
 921                 nfs_modified_limit4 mod_blocks;
 922         } nfs_space_limit4_u;
 923 };
 924 typedef struct nfs_space_limit4 nfs_space_limit4;
 925 #define OPEN4_SHARE_ACCESS_READ 0x00000001
 926 #define OPEN4_SHARE_ACCESS_WRITE 0x00000002
 927 #define OPEN4_SHARE_ACCESS_BOTH 0x00000003
 928 #define OPEN4_SHARE_DENY_NONE 0x00000000
 929 #define OPEN4_SHARE_DENY_READ 0x00000001
 930 #define OPEN4_SHARE_DENY_WRITE 0x00000002
 931 #define OPEN4_SHARE_DENY_BOTH 0x00000003
 932
 933 enum open_delegation_type4 {
 934         OPEN_DELEGATE_NONE = 0,
 935         OPEN_DELEGATE_READ = 1,
 936         OPEN_DELEGATE_WRITE = 2
 937 };
 938 typedef enum open_delegation_type4 open_delegation_type4;
 939
 940 enum open_claim_type4 {
 941         CLAIM_NULL = 0,
 942         CLAIM_PREVIOUS = 1,
 943         CLAIM_DELEGATE_CUR = 2,
 944         CLAIM_DELEGATE_PREV = 3
 945 };
 946 typedef enum open_claim_type4 open_claim_type4;
 947
 948 struct open_claim_delegate_cur4 {
 949         stateid4 delegate_stateid;
 950         component4 file;
 951 };
 952 typedef struct open_claim_delegate_cur4 open_claim_delegate_cur4;
 953
 954 struct copen_claim_delegate_cur4 {
 955         stateid4 delegate_stateid;
 956         char *cfile;
 957 };
 958 typedef struct copen_claim_delegate_cur4 copen_claim_delegate_cur4;
 959
 960 struct OPEN4args {
 961         seqid4 seqid;
 962         uint32_t share_access;
 963         uint32_t share_deny;
 964         open_owner4 owner;
 965         opentype4 opentype;
 966         createmode4 mode;
 967         union {
 968                 fattr4 createattrs;
 969                 verifier4 createverf;
 970         } createhow4_u;
 971         open_claim_type4 claim;
 972         union {
 973                 component4 file;
 974                 open_delegation_type4 delegate_type;
 975                 open_claim_delegate_cur4 delegate_cur_info;
 976                 component4 file_delegate_prev;
 977         } open_claim4_u;
 978 };
 979 typedef struct OPEN4args OPEN4args;
 980
 981 struct OPEN4cargs {
 982         seqid4 seqid;
 983         uint32_t share_access;
 984         uint32_t share_deny;
 985         open_owner4 owner;
 986         opentype4 opentype;
 987         createmode4 mode;
 988         union {
 989                 fattr4 createattrs;
 990                 verifier4 createverf;
 991         } createhow4_u;
 992         open_claim_type4 claim;
 993         union {
 994                 char *cfile;
 995                 open_delegation_type4 delegate_type;
 996                 copen_claim_delegate_cur4 delegate_cur_info;
 997                 char *cfile_delegate_prev;
 998         } open_claim4_u;
 999 };
1000 typedef struct OPEN4cargs OPEN4cargs;
1001
1002 struct open_read_delegation4 {
1003         stateid4 stateid;
1004         bool_t recall;
1005         nfsace4 permissions;
1006 };
1007 typedef struct open_read_delegation4 open_read_delegation4;
1008
1009 struct open_write_delegation4 {
1010         stateid4 stateid;
1011         bool_t recall;
1012         nfs_space_limit4 space_limit;
1013         nfsace4 permissions;
1014 };
1015 typedef struct open_write_delegation4 open_write_delegation4;
1016
1017 struct open_delegation4 {
1018         open_delegation_type4 delegation_type;
1019         union {
1020                 open_read_delegation4 read;
1021                 open_write_delegation4 write;
1022         } open_delegation4_u;
1023 };
1024 typedef struct open_delegation4 open_delegation4;
1025 #define OPEN4_RESULT_CONFIRM 0x00000002
1026 #define OPEN4_RESULT_LOCKTYPE_POSIX 0x00000004
1027
1028 struct OPEN4res {
1029         nfsstat4 status;
1030         stateid4 stateid;
1031         change_info4 cinfo;
1032         uint32_t rflags;
1033         bitmap4 attrset;
1034         open_delegation4 delegation;
1035 };
1036 typedef struct OPEN4res OPEN4res;
1037
1038 struct OPENATTR4args {
1039         bool_t createdir;
1040 };
1041 typedef struct OPENATTR4args OPENATTR4args;
1042
1043 struct OPENATTR4res {
1044         nfsstat4 status;
1045 };
1046 typedef struct OPENATTR4res OPENATTR4res;
1047
1048 struct OPEN_CONFIRM4args {
1049         stateid4 open_stateid;
1050         seqid4 seqid;
1051 };
1052 typedef struct OPEN_CONFIRM4args OPEN_CONFIRM4args;
1053
1054 struct OPEN_CONFIRM4res {
1055         nfsstat4 status;
1056         stateid4 open_stateid;
1057 };
1058 typedef struct OPEN_CONFIRM4res OPEN_CONFIRM4res;
1059
1060 struct OPEN_DOWNGRADE4args {
1061         stateid4 open_stateid;
1062         seqid4 seqid;
1063         uint32_t share_access;
1064         uint32_t share_deny;
1065 };
1066 typedef struct OPEN_DOWNGRADE4args OPEN_DOWNGRADE4args;
1067
1068 struct OPEN_DOWNGRADE4res {
1069         nfsstat4 status;
1070         stateid4 open_stateid;
1071 };
1072 typedef struct OPEN_DOWNGRADE4res OPEN_DOWNGRADE4res;
1073
1074 struct PUTFH4args {
1075         nfs_fh4 object;
1076 };
1077 typedef struct PUTFH4args PUTFH4args;
1078
1079 /*
1080  * Client only side PUTFH arguments
1081  * This is really a nfs4_sharedfh_t * but the forward declaration
1082  * is problematic;
1083  */
1084 struct PUTFH4cargs {
1085         void *sfh;
1086 };
1087 typedef struct PUTFH4cargs PUTFH4cargs;
1088
1089 struct PUTFH4res {
1090         nfsstat4 status;
1091 };
1092 typedef struct PUTFH4res PUTFH4res;
1093
1094 struct PUTPUBFH4res {
1095         nfsstat4 status;
1096 };
1097 typedef struct PUTPUBFH4res PUTPUBFH4res;
1098
1099 struct PUTROOTFH4res {
1100         nfsstat4 status;
1101 };
1102 typedef struct PUTROOTFH4res PUTROOTFH4res;
1103
1104 struct READ4args {
1105         stateid4 stateid;
1106         offset4 offset;
1107         count4 count;
1108         /* The following are used for the XDR decode path */
1109         char *res_data_val_alt;
1110         mblk_t *res_mblk;
1111         struct uio *res_uiop;
1112         uint_t res_maxsize;
1113 #ifdef _KERNEL
1114         struct clist *wlist;
1115         CONN *conn;
1116 #endif
1117 };
1118 typedef struct READ4args READ4args;
1119
1120 struct READ4res {
1121         nfsstat4 status;
1122         bool_t eof;
1123         uint_t data_len;
1124         char *data_val;
1125         mblk_t *mblk;
1126 #ifdef _KERNEL
1127         struct clist *wlist;
1128         uint_t wlist_len;
1129 #endif
1130 };
1131 typedef struct READ4res READ4res;
1132
1133 struct rddir4_cache;
1134
1135 struct READDIR4args {
1136         nfs_cookie4 cookie;
1137         verifier4 cookieverf;
1138         count4 dircount;
1139         count4 maxcount;
1140         bitmap4 attr_request;
1141         vnode_t *dvp;
1142         struct mntinfo4 *mi;
1143         cred_t *cr;
1144         struct rddir4_cache *rdc;
1145         hrtime_t t;
1146 };
1147 typedef struct READDIR4args READDIR4args;
1148
1149 struct READDIR4res_clnt {
1150         nfsstat4 status;
1151         verifier4 cookieverf;
1152         bool_t eof;
1153         struct dirent64 *dotp, *dotdotp;
1154         struct rddir4_cache *rdc;
1155 };
1156 typedef struct READDIR4res_clnt READDIR4res_clnt;
1157
1158 struct READDIR4res {
1159         nfsstat4 status;
1160         verifier4 cookieverf;
1161         mblk_t *mblk;
1162         uint_t data_len;
1163 };
1164 typedef struct READDIR4res READDIR4res;
1165
1166 struct READLINK4res {
1167         nfsstat4 status;
1168         linktext4 link;
1169 };
1170 typedef struct READLINK4res READLINK4res;
1171
1172 struct REMOVE4args {
1173         component4 target;
1174 };
1175 typedef struct REMOVE4args REMOVE4args;
1176
1177 struct REMOVE4cargs {
1178         char *ctarget;
1179 };
1180 typedef struct REMOVE4cargs REMOVE4cargs;
1181
1182 struct REMOVE4res {
1183         nfsstat4 status;
1184         change_info4 cinfo;
1185 };
1186 typedef struct REMOVE4res REMOVE4res;
1187
1188 struct RENAME4args {
1189         component4 oldname;
1190         component4 newname;
1191 };
1192 typedef struct RENAME4args RENAME4args;
1193
1194 struct RENAME4cargs {
1195         char *coldname;
1196         char *cnewname;
1197 };
1198 typedef struct RENAME4cargs RENAME4cargs;
1199
1200 struct RENAME4res {
1201         nfsstat4 status;
1202         change_info4 source_cinfo;
1203         change_info4 target_cinfo;
1204 };
1205 typedef struct RENAME4res RENAME4res;
1206
1207 struct RENEW4args {
1208         clientid4 clientid;
1209 };
1210 typedef struct RENEW4args RENEW4args;
1211
1212 struct RENEW4res {
1213         nfsstat4 status;
1214 };
1215 typedef struct RENEW4res RENEW4res;
1216
1217 struct RESTOREFH4res {
1218         nfsstat4 status;
1219 };
1220 typedef struct RESTOREFH4res RESTOREFH4res;
1221
1222 struct SAVEFH4res {
1223         nfsstat4 status;
1224 };
1225 typedef struct SAVEFH4res SAVEFH4res;
1226
1227 struct SECINFO4args {
1228         component4 name;
1229 };
1230 typedef struct SECINFO4args SECINFO4args;
1231
1232 struct SECINFO4cargs {
1233         char *cname;
1234 };
1235 typedef struct SECINFO4cargs SECINFO4cargs;
1236
1237 enum rpc_gss_svc_t {
1238         RPC_GSS_SVC_NONE = 1,
1239         RPC_GSS_SVC_INTEGRITY = 2,
1240         RPC_GSS_SVC_PRIVACY = 3
1241 };
1242 typedef enum rpc_gss_svc_t rpc_gss_svc_t;
1243
1244 struct rpcsec_gss_info {
1245         sec_oid4 oid;
1246         qop4 qop;
1247         rpc_gss_svc_t service;
1248 };
1249 typedef struct rpcsec_gss_info rpcsec_gss_info;
1250
1251 struct secinfo4 {
1252         uint32_t flavor;
1253         rpcsec_gss_info flavor_info;
1254 };
1255 typedef struct secinfo4 secinfo4;
1256
1257 struct SECINFO4res {
1258         nfsstat4 status;
1259         uint_t SECINFO4resok_len;
1260         secinfo4 *SECINFO4resok_val;
1261 };
1262 typedef struct SECINFO4res SECINFO4res;
1263
1264 struct SETATTR4args {
1265         stateid4 stateid;
1266         fattr4 obj_attributes;
1267 };
1268 typedef struct SETATTR4args SETATTR4args;
1269
1270 struct SETATTR4res {
1271         nfsstat4 status;
1272         bitmap4 attrsset;
1273 };
1274 typedef struct SETATTR4res SETATTR4res;
1275
1276 struct SETCLIENTID4args {
1277         nfs_client_id4 client;
1278         cb_client4 callback;
1279         uint32_t callback_ident;
1280 };
1281 typedef struct SETCLIENTID4args SETCLIENTID4args;
1282
1283 struct SETCLIENTID4resok {
1284         clientid4 clientid;
1285         verifier4 setclientid_confirm;
1286 };
1287 typedef struct SETCLIENTID4resok SETCLIENTID4resok;
1288
1289 struct SETCLIENTID4res {
1290         nfsstat4 status;
1291         union {
1292                 SETCLIENTID4resok resok4;
1293                 clientaddr4 client_using;
1294         } SETCLIENTID4res_u;
1295 };
1296 typedef struct SETCLIENTID4res SETCLIENTID4res;
1297
1298 struct SETCLIENTID_CONFIRM4args {
1299         clientid4 clientid;
1300         verifier4 setclientid_confirm;
1301 };
1302 typedef struct SETCLIENTID_CONFIRM4args SETCLIENTID_CONFIRM4args;
1303
1304 struct SETCLIENTID_CONFIRM4res {
1305         nfsstat4 status;
1306 };
1307 typedef struct SETCLIENTID_CONFIRM4res SETCLIENTID_CONFIRM4res;
1308
1309 struct VERIFY4args {
1310         fattr4 obj_attributes;
1311 };
1312 typedef struct VERIFY4args VERIFY4args;
1313
1314 struct VERIFY4res {
1315         nfsstat4 status;
1316 };
1317 typedef struct VERIFY4res VERIFY4res;
1318
1319 enum stable_how4 {
1320         UNSTABLE4 = 0,
1321         DATA_SYNC4 = 1,
1322         FILE_SYNC4 = 2
1323 };
1324 typedef enum stable_how4 stable_how4;
1325
1326 /*
1327  * mblk doesn't go over the wire.  If non-NULL, it points to an mblk chain
1328  * for the write data.
1329  */
1330
1331 struct WRITE4args {
1332         stateid4 stateid;
1333         offset4 offset;
1334         stable_how4 stable;
1335         uint_t data_len;
1336         char *data_val;
1337         mblk_t *mblk;
1338 #ifdef _KERNEL
1339         struct clist *rlist;
1340         CONN *conn;
1341 #endif
1342 };
1343 typedef struct WRITE4args WRITE4args;
1344
1345 struct WRITE4res {
1346         nfsstat4 status;
1347         count4 count;
1348         stable_how4 committed;
1349         verifier4 writeverf;
1350 };
1351 typedef struct WRITE4res WRITE4res;
1352
1353 struct RELEASE_LOCKOWNER4args {
1354         lock_owner4 lock_owner;
1355 };
1356 typedef struct RELEASE_LOCKOWNER4args RELEASE_LOCKOWNER4args;
1357
1358 struct RELEASE_LOCKOWNER4res {
1359         nfsstat4 status;
1360 };
1361 typedef struct RELEASE_LOCKOWNER4res RELEASE_LOCKOWNER4res;
1362
1363 struct ILLEGAL4res {
1364         nfsstat4 status;
1365 };
1366 typedef struct ILLEGAL4res ILLEGAL4res;
1367
1368 enum nfs_opnum4 {
1369         OP_ACCESS = 3,
1370         OP_CLOSE = 4,
1371         OP_COMMIT = 5,
1372         OP_CREATE = 6,
1373         OP_DELEGPURGE = 7,
1374         OP_DELEGRETURN = 8,
1375         OP_GETATTR = 9,
1376         OP_GETFH = 10,
1377         OP_LINK = 11,
1378         OP_LOCK = 12,
1379         OP_LOCKT = 13,
1380         OP_LOCKU = 14,
1381         OP_LOOKUP = 15,
1382         OP_LOOKUPP = 16,
1383         OP_NVERIFY = 17,
1384         OP_OPEN = 18,
1385         OP_OPENATTR = 19,
1386         OP_OPEN_CONFIRM = 20,
1387         OP_OPEN_DOWNGRADE = 21,
1388         OP_PUTFH = 22,
1389         OP_PUTPUBFH = 23,
1390         OP_PUTROOTFH = 24,
1391         OP_READ = 25,
1392         OP_READDIR = 26,
1393         OP_READLINK = 27,
1394         OP_REMOVE = 28,
1395         OP_RENAME = 29,
1396         OP_RENEW = 30,
1397         OP_RESTOREFH = 31,
1398         OP_SAVEFH = 32,
1399         OP_SECINFO = 33,
1400         OP_SETATTR = 34,
1401         OP_SETCLIENTID = 35,
1402         OP_SETCLIENTID_CONFIRM = 36,
1403         OP_VERIFY = 37,
1404         OP_WRITE = 38,
1405         OP_RELEASE_LOCKOWNER = 39,
1406         OP_ILLEGAL = 10044,
1407 /*
1408  * These are internal client pseudo ops that *MUST* never go over the wire
1409  */
1410 #define SUNW_PRIVATE_OP 0x10000000
1411 #define REAL_OP4(op)    ((op) & ~SUNW_PRIVATE_OP)
1412         OP_CCREATE = OP_CREATE | SUNW_PRIVATE_OP,
1413         OP_CLINK = OP_LINK | SUNW_PRIVATE_OP,
1414         OP_CLOOKUP = OP_LOOKUP | SUNW_PRIVATE_OP,
1415         OP_COPEN = OP_OPEN | SUNW_PRIVATE_OP,
1416         OP_CPUTFH = OP_PUTFH | SUNW_PRIVATE_OP,
1417         OP_CREMOVE = OP_REMOVE | SUNW_PRIVATE_OP,
1418         OP_CRENAME = OP_RENAME | SUNW_PRIVATE_OP,
1419         OP_CSECINFO = OP_SECINFO | SUNW_PRIVATE_OP
1420 };
1421 typedef enum nfs_opnum4 nfs_opnum4;
1422
1423 struct nfs_argop4 {
1424         nfs_opnum4 argop;
1425         union {
1426                 ACCESS4args opaccess;
1427                 CLOSE4args opclose;
1428                 COMMIT4args opcommit;
1429                 CREATE4args opcreate;
1430                 CREATE4cargs opccreate;
1431                 DELEGPURGE4args opdelegpurge;
1432                 DELEGRETURN4args opdelegreturn;
1433                 GETATTR4args opgetattr;
1434                 LINK4args oplink;
1435                 LINK4cargs opclink;
1436                 LOCK4args oplock;
1437                 LOCKT4args oplockt;
1438                 LOCKU4args oplocku;
1439                 LOOKUP4args oplookup;
1440                 LOOKUP4cargs opclookup;
1441                 NVERIFY4args opnverify;
1442                 OPEN4args opopen;
1443                 OPEN4cargs opcopen;
1444                 OPENATTR4args opopenattr;
1445                 OPEN_CONFIRM4args opopen_confirm;
1446                 OPEN_DOWNGRADE4args opopen_downgrade;
1447                 PUTFH4args opputfh;
1448                 PUTFH4cargs opcputfh;
1449                 READ4args opread;
1450                 READDIR4args opreaddir;
1451                 REMOVE4args opremove;
1452                 REMOVE4cargs opcremove;
1453                 RENAME4args oprename;
1454                 RENAME4cargs opcrename;
1455                 RENEW4args oprenew;
1456                 SECINFO4args opsecinfo;
1457                 SECINFO4cargs opcsecinfo;
1458                 SETATTR4args opsetattr;
1459                 SETCLIENTID4args opsetclientid;
1460                 SETCLIENTID_CONFIRM4args opsetclientid_confirm;
1461                 VERIFY4args opverify;
1462                 WRITE4args opwrite;
1463                 RELEASE_LOCKOWNER4args oprelease_lockowner;
1464         } nfs_argop4_u;
1465         size_t opsize;          /* the number of bytes occupied by the */
1466                                 /* particular operation in the XDR stream */
1467                                 /* (set during the decode only) */
1468 };
1469 typedef struct nfs_argop4 nfs_argop4;
1470
1471 struct nfs_resop4 {
1472         nfs_opnum4 resop;
1473         union {
1474                 ACCESS4res opaccess;
1475                 CLOSE4res opclose;
1476                 COMMIT4res opcommit;
1477                 CREATE4res opcreate;
1478                 DELEGPURGE4res opdelegpurge;
1479                 DELEGRETURN4res opdelegreturn;
1480                 GETATTR4res opgetattr;
1481                 GETFH4res opgetfh;
1482                 LINK4res oplink;
1483                 LOCK4res oplock;
1484                 LOCKT4res oplockt;
1485                 LOCKU4res oplocku;
1486                 LOOKUP4res oplookup;
1487                 LOOKUPP4res oplookupp;
1488                 NVERIFY4res opnverify;
1489                 OPEN4res opopen;
1490                 OPENATTR4res opopenattr;
1491                 OPEN_CONFIRM4res opopen_confirm;
1492                 OPEN_DOWNGRADE4res opopen_downgrade;
1493                 PUTFH4res opputfh;
1494                 PUTPUBFH4res opputpubfh;
1495                 PUTROOTFH4res opputrootfh;
1496                 READ4res opread;
1497                 READDIR4res opreaddir;
1498                 READDIR4res_clnt opreaddirclnt;
1499                 READLINK4res opreadlink;
1500                 REMOVE4res opremove;
1501                 RENAME4res oprename;
1502                 RENEW4res oprenew;
1503                 RESTOREFH4res oprestorefh;
1504                 SAVEFH4res opsavefh;
1505                 SECINFO4res opsecinfo;
1506                 SETATTR4res opsetattr;
1507                 SETCLIENTID4res opsetclientid;
1508                 SETCLIENTID_CONFIRM4res opsetclientid_confirm;
1509                 VERIFY4res opverify;
1510                 WRITE4res opwrite;
1511                 RELEASE_LOCKOWNER4res oprelease_lockowner;
1512                 ILLEGAL4res opillegal;
1513         } nfs_resop4_u;
1514         size_t opsize;          /* the number of bytes occupied by the */
1515                                 /* particular operation in the XDR stream */
1516                                 /* (set during the encode only) */
1517         struct exportinfo *exi; /* the exportinfo where the operation should */
1518                                 /* be counted in (support for per-exportinfo */
1519                                 /* kstats) */
1520 };
1521 typedef struct nfs_resop4 nfs_resop4;
1522
1523 /*
1524  * Fixed size tag string for easy client encoding
1525  */
1526 struct _ctag {
1527         int ct_type;
1528         char *ct_str;
1529         uint32_t ct_tag[3];
1530 };
1531 typedef struct _ctag ctag_t;
1532
1533 /*
1534  * Client-only encode-only version
1535  */
1536 struct COMPOUND4args_clnt {
1537         int ctag;
1538         uint_t array_len;
1539         nfs_argop4 *array;
1540 };
1541 typedef struct COMPOUND4args_clnt COMPOUND4args_clnt;
1542
1543 struct COMPOUND4args {
1544         utf8string tag;
1545         uint32_t minorversion;
1546         uint_t array_len;
1547         nfs_argop4 *array;
1548 };
1549 typedef struct COMPOUND4args COMPOUND4args;
1550
1551 struct COMPOUND4res_clnt {
1552         nfsstat4 status;
1553         uint_t array_len;
1554         uint_t decode_len;
1555         nfs_resop4 *array;
1556         COMPOUND4args_clnt *argsp;
1557 };
1558 typedef struct COMPOUND4res_clnt COMPOUND4res_clnt;
1559
1560 struct COMPOUND4res {
1561         nfsstat4 status;
1562         utf8string tag;
1563         uint_t array_len;
1564         nfs_resop4 *array;
1565 };
1566 typedef struct COMPOUND4res COMPOUND4res;
1567
1568 struct CB_GETATTR4args {
1569         nfs_fh4 fh;
1570         bitmap4 attr_request;
1571 };
1572 typedef struct CB_GETATTR4args CB_GETATTR4args;
1573
1574 struct CB_GETATTR4res {
1575         nfsstat4 status;
1576         fattr4 obj_attributes;
1577 };
1578 typedef struct CB_GETATTR4res CB_GETATTR4res;
1579
1580 struct CB_RECALL4args {
1581         stateid4 stateid;
1582         bool_t truncate;
1583         nfs_fh4 fh;
1584 };
1585 typedef struct CB_RECALL4args CB_RECALL4args;
1586
1587 struct CB_RECALL4res {
1588         nfsstat4 status;
1589 };
1590 typedef struct CB_RECALL4res CB_RECALL4res;
1591
1592 struct CB_ILLEGAL4res {
1593         nfsstat4 status;
1594 };
1595 typedef struct CB_ILLEGAL4res CB_ILLEGAL4res;
1596
1597 enum nfs_cb_opnum4 {
1598         OP_CB_GETATTR = 3,
1599         OP_CB_RECALL = 4,
1600         OP_CB_ILLEGAL = 10044
1601 };
1602 typedef enum nfs_cb_opnum4 nfs_cb_opnum4;
1603
1604 struct nfs_cb_argop4 {
1605         uint_t argop;
1606         union {
1607                 CB_GETATTR4args opcbgetattr;
1608                 CB_RECALL4args opcbrecall;
1609         } nfs_cb_argop4_u;
1610 };
1611 typedef struct nfs_cb_argop4 nfs_cb_argop4;
1612
1613 struct nfs_cb_resop4 {
1614         uint_t resop;
1615         union {
1616                 CB_GETATTR4res opcbgetattr;
1617                 CB_RECALL4res opcbrecall;
1618                 CB_ILLEGAL4res opcbillegal;
1619         } nfs_cb_resop4_u;
1620 };
1621 typedef struct nfs_cb_resop4 nfs_cb_resop4;
1622
1623 struct CB_COMPOUND4args {
1624         utf8string tag;
1625         uint32_t minorversion;
1626         uint32_t callback_ident;
1627         uint_t array_len;
1628         nfs_cb_argop4 *array;
1629 };
1630 typedef struct CB_COMPOUND4args CB_COMPOUND4args;
1631
1632 struct CB_COMPOUND4res {
1633         nfsstat4 status;
1634         utf8string tag;
1635         uint_t array_len;
1636         nfs_cb_resop4 *array;
1637 };
1638 typedef struct CB_COMPOUND4res CB_COMPOUND4res;
1639
1640 #define NFS4_PROGRAM            100003
1641 #define NFS_V4                  4
1642 #define NFSPROC4_NULL           0
1643 #define NFSPROC4_COMPOUND       1
1644
1645 #define NFS4_CALLBACK           0x40000000
1646 #define NFS_CB                  1
1647 #define CB_NULL                 0
1648 #define CB_COMPOUND             1
1649
1650 extern  bool_t xdr_bitmap4(XDR *, bitmap4 *);
1651 extern  bool_t xdr_utf8string(XDR *, utf8string *);
1652 extern  bool_t xdr_nfs_fh4(XDR *, nfs_fh4 *);
1653 extern  bool_t xdr_fattr4_fsid(XDR *, fattr4_fsid *);
1654 extern  bool_t xdr_fattr4_acl(XDR *, fattr4_acl *);
1655 extern  bool_t xdr_fattr4_fs_locations(XDR *, fattr4_fs_locations *);
1656 extern  bool_t xdr_fattr4_rawdev(XDR *, fattr4_rawdev *);
1657 extern  bool_t xdr_nfstime4(XDR *, nfstime4 *);
1658 extern  bool_t xdr_settime4(XDR *, settime4 *);
1659 extern  bool_t xdr_COMPOUND4args_clnt(XDR *, COMPOUND4args_clnt *);
1660 extern  bool_t xdr_COMPOUND4args_srv(XDR *, COMPOUND4args *);
1661 extern  bool_t xdr_COMPOUND4res_clnt(XDR *, COMPOUND4res_clnt *);
1662 extern  bool_t xdr_COMPOUND4res_srv(XDR *, COMPOUND4res *);
1663 extern  bool_t xdr_CB_COMPOUND4args_clnt(XDR *, CB_COMPOUND4args *);
1664 extern  bool_t xdr_CB_COMPOUND4args_srv(XDR *, CB_COMPOUND4args *);
1665 extern  bool_t xdr_CB_COMPOUND4res(XDR *, CB_COMPOUND4res *);
1666
1667 /*
1668  * xdr for referrrals upcall
1669  */
1670 extern  bool_t xdr_knetconfig(XDR *, struct knetconfig *);
1671 extern  bool_t xdr_nfs_fsl_info(XDR *, struct nfs_fsl_info *);
1672
1673
1674 #ifdef __cplusplus
1675 }
1676 #endif
1677
1678 #endif /* _NFS4_KPROT_H */