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 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 26/* All Rights Reserved */ 27 28#ifndef _NFS_NFS_H 29#define _NFS_NFS_H 30 31/* nfs.h 2.38 88/08/19 SMI */ 32 33#include <sys/isa_defs.h> 34#include <sys/vfs.h> 35#include <sys/stream.h> 36#include <rpc/types.h> 37#include <sys/types32.h> 38#ifdef _KERNEL 39#include <rpc/rpc_rdma.h> 40#include <rpc/rpc.h> 41#include <sys/fcntl.h> 42#include <sys/kstat.h> 43#include <sys/dirent.h> 44#include <sys/zone.h> 45#include <sys/tsol/label.h> 46#include <sys/nvpair.h> 47#include <nfs/mount.h> 48#include <sys/vfs_opreg.h> 49#endif 50#include <vm/page.h> 51#include <rpc/rpc_sztypes.h> 52#include <sys/sysmacros.h> 53#ifdef __cplusplus 54extern "C" { 55#endif 56 57/* 58 * remote file service numbers 59 */ 60#define NFS_PROGRAM ((rpcprog_t)100003) 61#define NFS_VERSMIN ((rpcvers_t)2) 62#define NFS_VERSMAX ((rpcvers_t)4) 63#define NFS_VERSION ((rpcvers_t)2) 64#define NFS_PORT 2049 65 66/* 67 * Used to determine registration and service handling of versions 68 */ 69#define NFS_VERSMIN_DEFAULT ((rpcvers_t)2) 70#define NFS_VERSMAX_DEFAULT ((rpcvers_t)4) 71 72extern rpcvers_t nfs_versmin; 73extern rpcvers_t nfs_versmax; 74 75/* 76 * Default delegation setting for the server ==> "on" 77 */ 78#define NFS_SERVER_DELEGATION_DEFAULT (TRUE) 79 80/* Maximum size of data portion of a remote request */ 81#define NFS_MAXDATA 8192 82#define NFS_MAXNAMLEN 255 83#define NFS_MAXPATHLEN 1024 84 85/* 86 * Rpc retransmission parameters 87 */ 88#define NFS_TIMEO 11 /* initial timeout for clts in 10th of a sec */ 89#define NFS_RETRIES 5 /* times to retry request */ 90#define NFS_COTS_TIMEO 600 /* initial timeout for cots in 10th of a sec */ 91 92/* 93 * The value of UID_NOBODY/GID_NOBODY presented to the world via NFS. 94 * UID_NOBODY/GID_NOBODY is translated to NFS_UID_NOBODY/NFS_GID_NOBODY 95 * when being sent out over the network and NFS_UID_NOBODY/NFS_GID_NOBODY 96 * is translated to UID_NOBODY/GID_NOBODY when received. 97 */ 98#define NFS_UID_NOBODY -2 99#define NFS_GID_NOBODY -2 100 101/* 102 * maximum transfer size for different interfaces 103 */ 104#define ECTSIZE 2048 105#define IETSIZE 8192 106 107/* 108 * WebNFS error status 109 */ 110enum wnfsstat { 111 WNFSERR_CLNT_FLAVOR = 20001 /* invalid client sec flavor */ 112}; 113 114/* 115 * Error status 116 * Should include all possible net errors. 117 * For now we just cast errno into an enum nfsstat. 118 */ 119enum nfsstat { 120 NFS_OK = 0, /* no error */ 121 NFSERR_PERM = 1, /* Not owner */ 122 NFSERR_NOENT = 2, /* No such file or directory */ 123 NFSERR_IO = 5, /* I/O error */ 124 NFSERR_NXIO = 6, /* No such device or address */ 125 NFSERR_ACCES = 13, /* Permission denied */ 126 NFSERR_EXIST = 17, /* File exists */ 127 NFSERR_XDEV = 18, /* Cross-device link */ 128 NFSERR_NODEV = 19, /* No such device */ 129 NFSERR_NOTDIR = 20, /* Not a directory */ 130 NFSERR_ISDIR = 21, /* Is a directory */ 131 NFSERR_INVAL = 22, /* Invalid argument */ 132 NFSERR_FBIG = 27, /* File too large */ 133 NFSERR_NOSPC = 28, /* No space left on device */ 134 NFSERR_ROFS = 30, /* Read-only file system */ 135 NFSERR_OPNOTSUPP = 45, /* Operation not supported */ 136 NFSERR_NAMETOOLONG = 63, /* File name too long */ 137 NFSERR_NOTEMPTY = 66, /* Directory not empty */ 138 NFSERR_DQUOT = 69, /* Disc quota exceeded */ 139 NFSERR_STALE = 70, /* Stale NFS file handle */ 140 NFSERR_REMOTE = 71, /* Object is remote */ 141 NFSERR_WFLUSH = 99 /* write cache flushed */ 142}; 143 144typedef enum nfsstat nfsstat; 145 146/* 147 * File types 148 */ 149enum nfsftype { 150 NFNON, 151 NFREG, /* regular file */ 152 NFDIR, /* directory */ 153 NFBLK, /* block special */ 154 NFCHR, /* character special */ 155 NFLNK, /* symbolic link */ 156 NFSOC /* socket */ 157}; 158 159/* 160 * Macros for converting device numbers to and from the format 161 * SunOS 4.x used. SVR4 uses 14 bit majors and 18 bits minors, 162 * SunOS 4.x used 8 bit majors and 8 bit minors. It isn't sufficient 163 * to use the cmpdev() and expdev() macros because they only compress 164 * 7 bit (and smaller) majors. We must compress 8 bit majors too. 165 * If the major or minor exceeds 8 bits, then we send it out in 166 * full 32 bit format and hope that the peer can deal with it. 167 */ 168 169#define SO4_BITSMAJOR 8 /* # of SunOS 4.x major device bits */ 170#define SO4_BITSMINOR 8 /* # of SunOS 4.x minor device bits */ 171#define SO4_MAXMAJ 0xff /* SunOS 4.x max major value */ 172#define SO4_MAXMIN 0xff /* SunOS 4.x max minor value */ 173 174/* 175 * Convert to over-the-wire device number format 176 */ 177#define nfsv2_cmpdev(x) \ 178 ((uint32_t) \ 179 ((getmajor(x) > SO4_MAXMAJ || getminor(x) > SO4_MAXMIN) ? NODEV : \ 180 ((getmajor(x) << SO4_BITSMINOR) | (getminor(x) & SO4_MAXMIN)))) 181 182/* 183 * Convert from over-the-wire format to SVR4 device number format 184 */ 185#define nfsv2_expdev(x) \ 186 makedevice((((x) >> SO4_BITSMINOR) & SO4_MAXMAJ), (x) & SO4_MAXMIN) 187 188/* 189 * Special kludge for fifos (named pipes) [to adhere to NFS Protocol Spec] 190 * 191 * VFIFO is not in the protocol spec (VNON will be replaced by VFIFO) 192 * so the over-the-wire representation is VCHR with a '-1' device number. 193 * 194 * NOTE: This kludge becomes unnecessary with the Protocol Revision, 195 * but it may be necessary to support it (backwards compatibility). 196 */ 197#define NFS_FIFO_TYPE NFCHR 198#define NFS_FIFO_MODE S_IFCHR 199#define NFS_FIFO_DEV ((uint32_t)-1) 200 201/* identify fifo in nfs attributes */ 202#define NA_ISFIFO(NA) (((NA)->na_type == NFS_FIFO_TYPE) && \ 203 ((NA)->na_rdev == NFS_FIFO_DEV)) 204 205/* set fifo in nfs attributes */ 206#define NA_SETFIFO(NA) { \ 207 (NA)->na_type = NFS_FIFO_TYPE; \ 208 (NA)->na_rdev = NFS_FIFO_DEV; \ 209 (NA)->na_mode = ((NA)->na_mode & ~S_IFMT) | NFS_FIFO_MODE; \ 210 } 211 212/* 213 * Check for time overflow using a kernel tunable to determine whether 214 * we should accept or reject an unsigned 32-bit time value. Time value in NFS 215 * v2/3 protocol is unsigned 32 bit, but ILP32 kernel only allows 31 bits. 216 * In nfsv4, time value is a signed 64 bit, so needs to be checked for 217 * overflow as well (e.g. for setattr). So define the tunable as follows: 218 * nfs_allow_preepoch_time is TRUE if pre-epoch (negative) times are allowed 219 * and is FALSE (the default) otherwise. For nfsv2/3 this means that 220 * if negative times are allowed, the uint32_t time value is interpreted 221 * as a signed int, otherwise as a large positive number. For nfsv4, 222 * we use the value as is - except that if negative times are not allowed, 223 * we will not accept a negative value otw. 224 * 225 * So for nfsv2/3 (uint32_t): 226 * 227 * If nfs_allow_preepoch_time is 228 * FALSE, the maximum time value is INT32_MAX for 32-bit kernels and 229 * UINT32_MAX for 64-bit kernels (to allow times larger than 2038) 230 * and the minimum is zero. Note that in that case, a 32-bit application 231 * running on a 64-bit kernel will not be able to access files with 232 * the larger time values. 233 * If nfs_allow_preepoch_time is TRUE, the maximum time value is INT32_MAX 234 * for both kernel configurations and the minimum is INT32_MIN. 235 * 236 * And for nfsv4 (int64_t): 237 * 238 * nfsv4 allows for negative values in the protocol, and has a 64-bit 239 * time field, so nfs_allow_preepoch_time can be ignored. 240 */ 241#ifdef _KERNEL 242 243extern bool_t nfs_allow_preepoch_time; 244 245#ifdef _LP64 246 247/* 248 * If no negative otw values are allowed, may use the full 32-bits of the 249 * time to represent time later than 2038, by presenting the value as an 250 * unsigned (but this can only be used by 64-bit apps due to cstat32 251 * restrictions). If negative values are allowed, cannot represent times 252 * after 2038. Either way, all 32 bits have a valid representation. 253 */ 254 255/* Check if nfstime4 seconds (int64_t) can be stored in the system time */ 256#define NFS4_TIME_OK(tt) TRUE 257 258 259#define NFS3_TIME_OVERFLOW(tt) (FALSE) 260#define NFS2_TIME_OVERFLOW(tt) (FALSE) 261 262/* 263 * check if a time_t (int64_t) is ok when preepoch times are allowed - 264 * nfsv2/3: every 32-bit value is accepted, but can't overflow 64->32. 265 * nfsv4: every value is valid. 266 */ 267#define NFS_PREEPOCH_TIME_T_OK(tt) \ 268 (((tt) >= (time_t)INT32_MIN) && ((tt) <= (time_t)INT32_MAX)) 269 270/* 271 * check if a time_t (int64_t) is ok when preepoch times are not allowed - 272 * nfsv2/3: every positive 32-bit value is accepted, but can't overflow 64->32. 273 * nfsv4: every value is valid. 274 */ 275#define NFS_NO_PREEPOCH_TIME_T_OK(tt) \ 276 (((tt) >= 0) && ((tt) <= (time_t)(ulong_t)UINT32_MAX)) 277 278#else /* not _LP64 */ 279 280/* 281 * Cannot represent times after 2038 in a 32-bit kernel, but we may wish to 282 * restrict the use of negative values (which violate the protocol). 283 * So if negative times allowed, all uint32 time values are valid. Otherwise 284 * only those which are less than INT32_MAX (msb=0). 285 * 286 * NFSv4 uses int64_t for the time, so in a 32-bit kernel the nfsv4 value 287 * must fit in an int32_t. 288 */ 289 290/* Only allow signed 32-bit time values */ 291 292/* Check if an nfstime4 (int64_t) can be stored in the system time */ 293#define NFS4_TIME_OK(tt) \ 294 (((tt) <= INT32_MAX) && ((tt) >= INT32_MIN)) 295 296#define NFS3_TIME_OVERFLOW(tt) ((tt) > INT32_MAX) 297#define NFS2_TIME_OVERFLOW(tt) ((tt) > INT32_MAX) 298 299/* 300 * check if a time_t (int32_t) is ok when preepoch times are allowed - 301 * every 32-bit value is accepted 302 */ 303#define NFS_PREEPOCH_TIME_T_OK(tt) TRUE 304 305/* 306 * check if a time_t (int32_t) is ok when preepoch times are not allowed - 307 * only positive values are accepted. 308 */ 309#define NFS_NO_PREEPOCH_TIME_T_OK(tt) ((tt) >= 0) 310 311#endif /* _LP64 */ 312 313/* Check if an nfstime3 (uint32_t) can be stored in the system time */ 314#define NFS3_TIME_OK(tt) \ 315 (nfs_allow_preepoch_time || (!NFS3_TIME_OVERFLOW(tt))) 316 317/* Check if an nfs2_timeval (uint32_t) can be stored in the system time. */ 318#define NFS2_TIME_OK(tt) \ 319 (nfs_allow_preepoch_time || (!NFS2_TIME_OVERFLOW(tt))) 320 321/* 322 * Test if time_t (signed long) can be sent over the wire - for v2/3 only if: 323 * 1. The time value can fit in a uint32_t; and 324 * 2. Either the time value is positive or allow preepoch times. 325 * No restrictions for nfsv4. 326 */ 327#define NFS_TIME_T_OK(tt) \ 328 (nfs_allow_preepoch_time ? \ 329 NFS_PREEPOCH_TIME_T_OK(tt) : NFS_NO_PREEPOCH_TIME_T_OK(tt)) 330 331#define NFS4_TIME_T_OK(tt) TRUE 332 333/* Test if all attr times are valid */ 334#define NFS_VAP_TIME_OK(vap) \ 335 (nfs_allow_preepoch_time ? \ 336 (NFS_PREEPOCH_TIME_T_OK((vap)->va_atime.tv_sec) && \ 337 NFS_PREEPOCH_TIME_T_OK((vap)->va_mtime.tv_sec) && \ 338 NFS_PREEPOCH_TIME_T_OK((vap)->va_ctime.tv_sec)) : \ 339 (NFS_NO_PREEPOCH_TIME_T_OK((vap)->va_atime.tv_sec) && \ 340 NFS_NO_PREEPOCH_TIME_T_OK((vap)->va_mtime.tv_sec) && \ 341 NFS_NO_PREEPOCH_TIME_T_OK((vap)->va_ctime.tv_sec))) 342 343#define NFS4_VAP_TIME_OK(vap) TRUE 344 345/* 346 * To extend the sign or not extend the sign, that is the question. 347 * Note: The correct way is to code a macro: 348 * #define NFS_TIME_T_CONVERT(tt) \ 349 * (nfs_allow_preepoch_time ? (int32_t)(tt) : (uint32_t)(tt)) 350 * But the 64-bit compiler does not extend the sign in that case (why?) 351 * so we'll do it the ugly way... 352 */ 353#define NFS_TIME_T_CONVERT(systt, tt) \ 354 if (nfs_allow_preepoch_time) { \ 355 systt = (int32_t)(tt); \ 356 } else { \ 357 systt = (uint32_t)(tt); \ 358 } 359 360/* macro to check for overflowed time attribute fields - version 3 */ 361#define NFS3_FATTR_TIME_OK(attrs) \ 362 (NFS3_TIME_OK((attrs)->atime.seconds) && \ 363 NFS3_TIME_OK((attrs)->mtime.seconds) && \ 364 NFS3_TIME_OK((attrs)->ctime.seconds)) 365 366/* macro to check for overflowed time attribute fields - version 2 */ 367#define NFS2_FATTR_TIME_OK(attrs) \ 368 (NFS2_TIME_OK((attrs)->na_atime.tv_sec) && \ 369 NFS2_TIME_OK((attrs)->na_mtime.tv_sec) && \ 370 NFS2_TIME_OK((attrs)->na_ctime.tv_sec)) 371 372/* Check that a size3 value is not overflowed */ 373#define NFS3_SIZE_OK(size) ((size) <= MAXOFFSET_T) 374 375#endif /* _KERNEL */ 376 377/* 378 * Size of an fhandle in bytes 379 */ 380#define NFS_FHSIZE 32 381 382struct nfs_fid { 383 ushort_t nf_len; 384 ushort_t nf_pad; 385 char nf_data[NFS_FHSIZE]; 386}; 387 388/* 389 * "Legacy" filehandles use NFS_FHMAXDATA (10) byte fids. Filesystems that 390 * return a larger fid than NFS_FHMAXDATA, such as ZFS's .zfs snapshot 391 * directory, can use up to (((64 - 8) / 2) - 2) bytes for their fid. 392 * This currently holds for both NFSv3 and NFSv4. 393 */ 394#define NFS_FHMAXDATA 10 395#define NFS_FH3MAXDATA 26 396#define NFS_FH4MAXDATA 26 397 398/* 399 * The original nfs file handle size for version 3 was 32 which was 400 * the same in version 2; now we're making it bigger to to deal with 401 * ZFS snapshot FIDs. 402 * 403 * If the size of fhandle3_t changes or if Version 3 uses some other 404 * filehandle format, this constant may need to change. 405 */ 406 407#define NFS3_OLDFHSIZE 32 408#define NFS3_MAXFHSIZE 64 409 410/* 411 * This is the actual definition of a legacy filehandle. There is some 412 * dependence on this layout in NFS-related code, particularly in the 413 * user-level lock manager, so be careful about changing it. 414 * 415 * Currently only NFSv2 uses this structure. 416 */ 417 418typedef struct svcfh { 419 fsid_t fh_fsid; /* filesystem id */ 420 ushort_t fh_len; /* file number length */ 421 char fh_data[NFS_FHMAXDATA]; /* and data */ 422 ushort_t fh_xlen; /* export file number length */ 423 char fh_xdata[NFS_FHMAXDATA]; /* and data */ 424} fhandle_t; 425 426/* 427 * This is the in-memory structure for an NFSv3 extended filehandle. 428 */ 429typedef struct { 430 fsid_t _fh3_fsid; /* filesystem id */ 431 ushort_t _fh3_len; /* file number length */ 432 char _fh3_data[NFS_FH3MAXDATA]; /* and data */ 433 ushort_t _fh3_xlen; /* export file number length */ 434 char _fh3_xdata[NFS_FH3MAXDATA]; /* and data */ 435} fhandle3_t; 436 437/* 438 * This is the in-memory structure for an NFSv4 extended filehandle. 439 */ 440typedef struct { 441 fsid_t fhx_fsid; /* filesystem id */ 442 ushort_t fhx_len; /* file number length */ 443 char fhx_data[NFS_FH4MAXDATA]; /* and data */ 444 ushort_t fhx_xlen; /* export file number length */ 445 char fhx_xdata[NFS_FH4MAXDATA]; /* and data */ 446} fhandle4_t; 447 448/* 449 * Arguments to remote write and writecache 450 */ 451/* 452 * The `over the wire' representation of the first four arguments. 453 */ 454struct otw_nfswriteargs { 455 fhandle_t otw_wa_fhandle; 456 uint32_t otw_wa_begoff; 457 uint32_t otw_wa_offset; 458 uint32_t otw_wa_totcount; 459}; 460 461struct nfswriteargs { 462 struct otw_nfswriteargs *wa_args; /* ptr to the otw arguments */ 463 struct otw_nfswriteargs wa_args_buf; /* space for otw arguments */ 464 uint32_t wa_count; 465 char *wa_data; /* data to write (up to NFS_MAXDATA) */ 466 mblk_t *wa_mblk; /* pointer to mblks containing data */ 467#ifdef _KERNEL 468 /* rdma related info */ 469 struct clist *wa_rlist; 470 CONN *wa_conn; 471#endif /* _KERNEL */ 472}; 473#define wa_fhandle wa_args->otw_wa_fhandle 474#define wa_begoff wa_args->otw_wa_begoff 475#define wa_offset wa_args->otw_wa_offset 476#define wa_totcount wa_args->otw_wa_totcount 477 478/* 479 * NFS timeval struct using unsigned int as specified in V2 protocol. 480 * tv_sec and tv_usec used to match existing code. 481 */ 482struct nfs2_timeval { 483 uint32_t tv_sec; 484 uint32_t tv_usec; 485}; 486typedef struct nfs2_timeval nfs2_timeval; 487 488/* 489 * File attributes 490 */ 491struct nfsfattr { 492 enum nfsftype na_type; /* file type */ 493 uint32_t na_mode; /* protection mode bits */ 494 uint32_t na_nlink; /* # hard links */ 495 uint32_t na_uid; /* owner user id */ 496 uint32_t na_gid; /* owner group id */ 497 uint32_t na_size; /* file size in bytes */ 498 uint32_t na_blocksize; /* preferred block size */ 499 uint32_t na_rdev; /* special device # */ 500 uint32_t na_blocks; /* Kb of disk used by file */ 501 uint32_t na_fsid; /* device # */ 502 uint32_t na_nodeid; /* inode # */ 503 struct nfs2_timeval na_atime; /* time of last access */ 504 struct nfs2_timeval na_mtime; /* time of last modification */ 505 struct nfs2_timeval na_ctime; /* time of last change */ 506}; 507 508#define n2v_type(x) (NA_ISFIFO(x) ? VFIFO : nf_to_vt[(x)->na_type]) 509#define n2v_rdev(x) (NA_ISFIFO(x) ? 0 : (x)->na_rdev) 510 511/* 512 * Arguments to remote read 513 */ 514struct nfsreadargs { 515 fhandle_t ra_fhandle; /* handle for file */ 516 uint32_t ra_offset; /* byte offset in file */ 517 uint32_t ra_count; /* immediate read count */ 518 uint32_t ra_totcount; /* total read cnt (from this offset) */ 519#ifdef _KERNEL 520 /* used in rdma transports */ 521 caddr_t ra_data; /* destination for read data */ 522 struct clist *ra_wlist; 523 CONN *ra_conn; 524#endif 525}; 526 527/* 528 * Status OK portion of remote read reply 529 */ 530struct nfsrrok { 531 struct nfsfattr rrok_attr; /* attributes, need for pagin */ 532 uint32_t rrok_count; /* bytes of data */ 533 char *rrok_data; /* data (up to NFS_MAXDATA bytes) */ 534 uint_t rrok_bufsize; /* size of kmem_alloc'd buffer */ 535 mblk_t *rrok_mp; /* mblk_t contains data for reply */ 536#ifdef _KERNEL 537 uint_t rrok_wlist_len; 538 struct clist *rrok_wlist; 539#endif 540}; 541 542/* 543 * Reply from remote read 544 */ 545struct nfsrdresult { 546 nfsstat rr_status; /* status of read */ 547 union { 548 struct nfsrrok rr_ok_u; /* attributes, need for pagin */ 549 } rr_u; 550}; 551#define rr_ok rr_u.rr_ok_u 552#define rr_attr rr_u.rr_ok_u.rrok_attr 553#define rr_count rr_u.rr_ok_u.rrok_count 554#define rr_bufsize rr_u.rr_ok_u.rrok_bufsize 555#define rr_data rr_u.rr_ok_u.rrok_data 556#define rr_mp rr_u.rr_ok_u.rrok_mp 557 558/* 559 * File attributes which can be set 560 */ 561struct nfssattr { 562 uint32_t sa_mode; /* protection mode bits */ 563 uint32_t sa_uid; /* owner user id */ 564 uint32_t sa_gid; /* owner group id */ 565 uint32_t sa_size; /* file size in bytes */ 566 struct nfs2_timeval sa_atime; /* time of last access */ 567 struct nfs2_timeval sa_mtime; /* time of last modification */ 568}; 569 570 571/* 572 * Reply status with file attributes 573 */ 574struct nfsattrstat { 575 nfsstat ns_status; /* reply status */ 576 union { 577 struct nfsfattr ns_attr_u; /* NFS_OK: file attributes */ 578 } ns_u; 579}; 580#define ns_attr ns_u.ns_attr_u 581 582 583/* 584 * NFS_OK part of read sym link reply union 585 */ 586struct nfssrok { 587 uint32_t srok_count; /* size of string */ 588 char *srok_data; /* string (up to NFS_MAXPATHLEN bytes) */ 589}; 590 591/* 592 * Result of reading symbolic link 593 */ 594struct nfsrdlnres { 595 nfsstat rl_status; /* status of symlink read */ 596 union { 597 struct nfssrok rl_srok_u; /* name of linked to */ 598 } rl_u; 599}; 600#define rl_srok rl_u.rl_srok_u 601#define rl_count rl_u.rl_srok_u.srok_count 602#define rl_data rl_u.rl_srok_u.srok_data 603 604 605/* 606 * Arguments to readdir 607 */ 608struct nfsrddirargs { 609 fhandle_t rda_fh; /* directory handle */ 610 uint32_t rda_offset; /* offset in directory (opaque) */ 611 uint32_t rda_count; /* number of directory bytes to read */ 612}; 613 614/* 615 * NFS_OK part of readdir result 616 */ 617struct nfsrdok { 618 uint32_t rdok_offset; /* next offset (opaque) */ 619 uint32_t rdok_size; /* size in bytes of entries */ 620 bool_t rdok_eof; /* true if last entry is in result */ 621 struct dirent64 *rdok_entries; /* variable number of entries */ 622}; 623 624/* 625 * Readdir result 626 */ 627struct nfsrddirres { 628 nfsstat rd_status; 629 uint_t rd_bufsize; /* client request size (not xdr'ed) */ 630 union { 631 struct nfsrdok rd_rdok_u; 632 } rd_u; 633}; 634#define rd_rdok rd_u.rd_rdok_u 635#define rd_offset rd_u.rd_rdok_u.rdok_offset 636#define rd_size rd_u.rd_rdok_u.rdok_size 637#define rd_eof rd_u.rd_rdok_u.rdok_eof 638#define rd_entries rd_u.rd_rdok_u.rdok_entries 639 640 641/* 642 * Arguments for directory operations 643 */ 644struct nfsdiropargs { 645 fhandle_t *da_fhandle; /* pointer to directory file handle */ 646 char *da_name; /* name (up to NFS_MAXNAMLEN bytes) */ 647 fhandle_t da_fhandle_buf; /* directory file handle */ 648 int da_flags; /* flags, see below */ 649}; 650#define DA_FREENAME 1 651 652/* 653 * NFS_OK part of directory operation result 654 */ 655struct nfsdrok { 656 fhandle_t drok_fhandle; /* result file handle */ 657 struct nfsfattr drok_attr; /* result file attributes */ 658}; 659 660/* 661 * Results from directory operation 662 */ 663struct nfsdiropres { 664 nfsstat dr_status; /* result status */ 665 union { 666 struct nfsdrok dr_drok_u; /* NFS_OK result */ 667 } dr_u; 668}; 669#define dr_drok dr_u.dr_drok_u 670#define dr_fhandle dr_u.dr_drok_u.drok_fhandle 671#define dr_attr dr_u.dr_drok_u.drok_attr 672 673/* 674 * arguments to setattr 675 */ 676struct nfssaargs { 677 fhandle_t saa_fh; /* fhandle of file to be set */ 678 struct nfssattr saa_sa; /* new attributes */ 679}; 680 681/* 682 * arguments to create and mkdir 683 */ 684struct nfscreatargs { 685 struct nfsdiropargs ca_da; /* file name to create and parent dir */ 686 struct nfssattr *ca_sa; /* initial attributes */ 687 struct nfssattr ca_sa_buf; /* space to store attributes */ 688}; 689 690/* 691 * arguments to link 692 */ 693struct nfslinkargs { 694 fhandle_t *la_from; /* old file */ 695 fhandle_t la_from_buf; /* old file */ 696 struct nfsdiropargs la_to; /* new file and parent dir */ 697}; 698 699/* 700 * arguments to rename 701 */ 702struct nfsrnmargs { 703 struct nfsdiropargs rna_from; /* old file and parent dir */ 704 struct nfsdiropargs rna_to; /* new file and parent dir */ 705}; 706 707/* 708 * arguments to symlink 709 */ 710struct nfsslargs { 711 struct nfsdiropargs sla_from; /* old file and parent dir */ 712 char *sla_tnm; /* new name */ 713 int sla_tnm_flags; /* flags for name */ 714 struct nfssattr *sla_sa; /* attributes */ 715 struct nfssattr sla_sa_buf; /* attributes buffer */ 716}; 717#define SLA_FREETNM 1 718 719/* 720 * NFS_OK part of statfs operation 721 */ 722struct nfsstatfsok { 723 uint32_t fsok_tsize; /* preferred transfer size in bytes */ 724 uint32_t fsok_bsize; /* fundamental file system block size */ 725 uint32_t fsok_blocks; /* total blocks in file system */ 726 uint32_t fsok_bfree; /* free blocks in fs */ 727 uint32_t fsok_bavail; /* free blocks avail to non-superuser */ 728}; 729 730/* 731 * Results of statfs operation 732 */ 733struct nfsstatfs { 734 nfsstat fs_status; /* result status */ 735 union { 736 struct nfsstatfsok fs_fsok_u; /* NFS_OK result */ 737 } fs_u; 738}; 739#define fs_fsok fs_u.fs_fsok_u 740#define fs_tsize fs_u.fs_fsok_u.fsok_tsize 741#define fs_bsize fs_u.fs_fsok_u.fsok_bsize 742#define fs_blocks fs_u.fs_fsok_u.fsok_blocks 743#define fs_bfree fs_u.fs_fsok_u.fsok_bfree 744#define fs_bavail fs_u.fs_fsok_u.fsok_bavail 745 746#ifdef _KERNEL 747/* 748 * XDR routines for handling structures defined above 749 */ 750extern bool_t xdr_attrstat(XDR *, struct nfsattrstat *); 751extern bool_t xdr_fastattrstat(XDR *, struct nfsattrstat *); 752extern bool_t xdr_creatargs(XDR *, struct nfscreatargs *); 753extern bool_t xdr_diropargs(XDR *, struct nfsdiropargs *); 754extern bool_t xdr_diropres(XDR *, struct nfsdiropres *); 755extern bool_t xdr_fastdiropres(XDR *, struct nfsdiropres *); 756extern bool_t xdr_drok(XDR *, struct nfsdrok *); 757#ifdef _LITTLE_ENDIAN 758extern bool_t xdr_fastdrok(XDR *, struct nfsdrok *); 759extern bool_t xdr_fastfattr(XDR *, struct nfsfattr *); 760#endif 761extern bool_t xdr_fattr(XDR *, struct nfsfattr *); 762extern bool_t xdr_fhandle(XDR *, fhandle_t *); 763extern bool_t xdr_fastfhandle(XDR *, fhandle_t **); 764extern bool_t xdr_linkargs(XDR *, struct nfslinkargs *); 765extern bool_t xdr_rddirargs(XDR *, struct nfsrddirargs *); 766extern bool_t xdr_putrddirres(XDR *, struct nfsrddirres *); 767extern bool_t xdr_getrddirres(XDR *, struct nfsrddirres *); 768extern bool_t xdr_rdlnres(XDR *, struct nfsrdlnres *); 769extern bool_t xdr_rdresult(XDR *, struct nfsrdresult *); 770extern bool_t xdr_readargs(XDR *, struct nfsreadargs *); 771extern bool_t xdr_readlink(XDR *, fhandle_t *); 772extern bool_t xdr_rnmargs(XDR *, struct nfsrnmargs *); 773extern bool_t xdr_rrok(XDR *, struct nfsrrok *); 774extern bool_t xdr_saargs(XDR *, struct nfssaargs *); 775extern bool_t xdr_sattr(XDR *, struct nfssattr *); 776extern bool_t xdr_slargs(XDR *, struct nfsslargs *); 777extern bool_t xdr_srok(XDR *, struct nfssrok *); 778extern bool_t xdr_nfs2_timeval(XDR *, struct nfs2_timeval *); 779extern bool_t xdr_writeargs(XDR *, struct nfswriteargs *); 780extern bool_t xdr_fsok(XDR *, struct nfsstatfsok *); 781#ifdef _LITTLE_ENDIAN 782extern bool_t xdr_fastfsok(XDR *, struct nfsstatfsok *); 783extern bool_t xdr_fastenum(XDR *, enum_t *); 784#endif 785extern bool_t xdr_statfs(XDR *, struct nfsstatfs *); 786extern bool_t xdr_faststatfs(XDR *, struct nfsstatfs *); 787#endif 788 789/* 790 * Remote file service routines 791 */ 792#define RFS_NULL 0 793#define RFS_GETATTR 1 794#define RFS_SETATTR 2 795#define RFS_ROOT 3 796#define RFS_LOOKUP 4 797#define RFS_READLINK 5 798#define RFS_READ 6 799#define RFS_WRITECACHE 7 800#define RFS_WRITE 8 801#define RFS_CREATE 9 802#define RFS_REMOVE 10 803#define RFS_RENAME 11 804#define RFS_LINK 12 805#define RFS_SYMLINK 13 806#define RFS_MKDIR 14 807#define RFS_RMDIR 15 808#define RFS_READDIR 16 809#define RFS_STATFS 17 810#define RFS_NPROC 18 811 812#ifdef _KERNEL 813/* 814 * The NFS Version 2 service procedures 815 */ 816struct exportinfo; /* defined in nfs/export.h */ 817struct servinfo; /* defined in nfs/nfs_clnt.h */ 818struct mntinfo; /* defined in nfs/nfs_clnt.h */ 819 820extern void rfs_getattr(fhandle_t *, struct nfsattrstat *, 821 struct exportinfo *, struct svc_req *, cred_t *); 822extern void *rfs_getattr_getfh(fhandle_t *); 823extern void rfs_setattr(struct nfssaargs *, struct nfsattrstat *, 824 struct exportinfo *, struct svc_req *, cred_t *); 825extern void *rfs_setattr_getfh(struct nfssaargs *); 826extern void rfs_lookup(struct nfsdiropargs *, struct nfsdiropres *, 827 struct exportinfo *, struct svc_req *, cred_t *); 828extern void *rfs_lookup_getfh(struct nfsdiropargs *); 829extern void rfs_readlink(fhandle_t *, struct nfsrdlnres *, 830 struct exportinfo *, struct svc_req *, cred_t *); 831extern void *rfs_readlink_getfh(fhandle_t *); 832extern void rfs_rlfree(struct nfsrdlnres *); 833extern void rfs_read(struct nfsreadargs *, struct nfsrdresult *, 834 struct exportinfo *, struct svc_req *, cred_t *); 835extern void *rfs_read_getfh(struct nfsreadargs *); 836extern void rfs_rdfree(struct nfsrdresult *); 837extern void rfs_write_sync(struct nfswriteargs *, struct nfsattrstat *, 838 struct exportinfo *, struct svc_req *, cred_t *); 839extern void rfs_write(struct nfswriteargs *, struct nfsattrstat *, 840 struct exportinfo *, struct svc_req *, cred_t *); 841extern void *rfs_write_getfh(struct nfswriteargs *); 842extern void rfs_create(struct nfscreatargs *, struct nfsdiropres *, 843 struct exportinfo *, struct svc_req *, cred_t *); 844extern void *rfs_create_getfh(struct nfscreatargs *); 845extern void rfs_remove(struct nfsdiropargs *, enum nfsstat *, 846 struct exportinfo *, struct svc_req *, cred_t *); 847extern void *rfs_remove_getfh(struct nfsdiropargs *); 848extern void rfs_rename(struct nfsrnmargs *, enum nfsstat *, 849 struct exportinfo *, struct svc_req *, cred_t *); 850extern void *rfs_rename_getfh(struct nfsrnmargs *); 851extern void rfs_link(struct nfslinkargs *, enum nfsstat *, 852 struct exportinfo *, struct svc_req *, cred_t *); 853extern void *rfs_link_getfh(struct nfslinkargs *); 854extern void rfs_symlink(struct nfsslargs *, enum nfsstat *, 855 struct exportinfo *, struct svc_req *, cred_t *); 856extern void *rfs_symlink_getfh(struct nfsslargs *); 857extern void rfs_mkdir(struct nfscreatargs *, struct nfsdiropres *, 858 struct exportinfo *, struct svc_req *, cred_t *); 859extern void *rfs_mkdir_getfh(struct nfscreatargs *); 860extern void rfs_rmdir(struct nfsdiropargs *, enum nfsstat *, 861 struct exportinfo *, struct svc_req *, cred_t *); 862extern void *rfs_rmdir_getfh(struct nfsdiropargs *); 863extern void rfs_readdir(struct nfsrddirargs *, struct nfsrddirres *, 864 struct exportinfo *, struct svc_req *, cred_t *); 865extern void *rfs_readdir_getfh(struct nfsrddirargs *); 866extern void rfs_rddirfree(struct nfsrddirres *); 867extern void rfs_statfs(fhandle_t *, struct nfsstatfs *, 868 struct exportinfo *, struct svc_req *, cred_t *); 869extern void *rfs_statfs_getfh(fhandle_t *); 870extern void rfs_srvrinit(void); 871extern void rfs_srvrfini(void); 872 873/* 874 * flags to define path types during Multi Component Lookups 875 * using the public filehandle 876 */ 877#define URLPATH 0x01 /* Universal Resource Locator path */ 878#define NATIVEPATH 0x02 /* Native path, i.e., via mount protocol */ 879#define SECURITY_QUERY 0x04 /* Security query */ 880 881/* index for svstat_ptr */ 882enum nfs_svccounts {NFS_CALLS, NFS_BADCALLS, NFS_REFERRALS, NFS_REFERLINKS}; 883 884/* function defs for NFS kernel */ 885extern int nfs_waitfor_purge_complete(vnode_t *); 886extern int nfs_validate_caches(vnode_t *, cred_t *); 887extern void nfs_purge_caches(vnode_t *, int, cred_t *); 888extern void nfs_purge_rddir_cache(vnode_t *); 889extern void nfs_attrcache(vnode_t *, struct nfsfattr *, hrtime_t); 890extern int nfs_cache_fattr(vnode_t *, struct nfsfattr *, vattr_t *, 891 hrtime_t, cred_t *); 892extern void nfs_attr_cache(vnode_t *, vattr_t *, hrtime_t, cred_t *); 893extern void nfs_attrcache_va(vnode_t *, struct vattr *); 894extern int nfs_getattr_otw(vnode_t *, struct vattr *, cred_t *); 895extern int nfsgetattr(vnode_t *, struct vattr *, cred_t *); 896extern int nattr_to_vattr(vnode_t *, struct nfsfattr *, struct vattr *); 897extern void nfs_async_manager(struct vfs *); 898extern void nfs_async_manager_stop(struct vfs *); 899extern void nfs_async_stop(struct vfs *); 900extern int nfs_async_stop_sig(struct vfs *); 901extern int nfs_clntinit(void); 902extern void nfs_clntfini(void); 903extern int nfstsize(void); 904extern int nfs_srvinit(void); 905extern void nfs_srvfini(void); 906extern int vattr_to_sattr(struct vattr *, struct nfssattr *); 907extern void setdiropargs(struct nfsdiropargs *, char *, vnode_t *); 908extern int setdirgid(vnode_t *, gid_t *, cred_t *); 909extern int setdirmode(vnode_t *, mode_t *, cred_t *); 910extern int newnum(void); 911extern char *newname(void); 912extern int nfs_subrinit(void); 913extern void nfs_subrfini(void); 914extern enum nfsstat puterrno(int); 915extern int geterrno(enum nfsstat); 916extern int nfsinit(int, char *); 917extern void nfsfini(void); 918extern int nfs_vfsinit(void); 919extern void nfs_vfsfini(void); 920extern int nfs_dump(vnode_t *, caddr_t, offset_t, offset_t, 921 caller_context_t *); 922extern void nfs_perror(int error, char *fmt, ...); 923extern void nfs_cmn_err(int error, int level, char *fmt, ...); 924extern int nfs_addcllock(vnode_t *vp, struct flock64 *bfp); 925extern void nfs_rmcllock(vnode_t *vp, struct flock64 *bfp); 926extern void nfs_lockrelease(vnode_t *vp, int flag, 927 offset_t offset, cred_t *credp); 928extern int vattr_to_nattr(struct vattr *, struct nfsfattr *); 929extern int mount_root(char *, char *, int, struct nfs_args *, int *); 930extern void nfs_lockcompletion(vnode_t *vp, int cmd); 931extern void nfs_add_locking_id(vnode_t *, pid_t, int, char *, int); 932extern void nfs3copyfh(caddr_t, vnode_t *); 933extern void nfscopyfh(caddr_t, vnode_t *); 934extern int nfs3lookup(vnode_t *, char *, vnode_t **, struct pathname *, 935 int, vnode_t *, cred_t *, int); 936extern int nfslookup(vnode_t *, char *, vnode_t **, struct pathname *, 937 int, vnode_t *, cred_t *, int); 938extern void sv_free(struct servinfo *); 939extern int nfsauth_access(struct exportinfo *exi, struct svc_req *req); 940extern void nfsauth_init(); 941extern void nfsauth_fini(); 942extern int nfs_setopts(vnode_t *vp, model_t model, struct nfs_args *args); 943extern int nfs_mount_label_policy(vfs_t *vfsp, struct netbuf *addr, 944 struct knetconfig *knconf, cred_t *cr); 945extern boolean_t nfs_has_ctty(void); 946extern void nfs_srv_stop_all(void); 947extern void nfs_srv_quiesce_all(void); 948extern void (*nfs_srv_quiesce_func)(void); 949extern int rfs4_dss_setpaths(char *, size_t); 950extern int (*nfs_srv_dss_func)(char *, size_t); 951extern int nfs_setmod_check(page_t *pp); 952extern time_t rfs4_lease_time; 953extern time_t rfs4_grace_period; 954extern nvlist_t *rfs4_dss_paths, *rfs4_dss_oldpaths; 955 956 957extern kstat_named_t *global_svstat_ptr[]; 958 959extern krwlock_t rroklock; 960extern vtype_t nf_to_vt[]; 961extern kstat_named_t *rfsproccnt_v2_ptr; 962extern kmutex_t nfs_minor_lock; 963extern int nfs_major; 964extern int nfs_minor; 965extern vfsops_t *nfs_vfsops; 966extern struct vnodeops *nfs_vnodeops; 967extern const struct fs_operation_def nfs_vnodeops_template[]; 968extern int nfsfstyp; 969 970/* 971 * Per-zone stats as consumed by nfsstat(1m) 972 */ 973struct nfs_version_stats { 974 kstat_named_t *aclreqcnt_ptr; /* nfs_acl:0:aclreqcnt_v? */ 975 kstat_named_t *aclproccnt_ptr; /* nfs_acl:0:aclproccnt_v? */ 976 kstat_named_t *rfsreqcnt_ptr; /* nfs:0:rfsreqcnt_v? */ 977 kstat_named_t *rfsproccnt_ptr; /* nfs:0:rfsproccnt_v? */ 978}; 979 980/* 981 * A bit of asymmetry: nfs:0:nfs_client isn't part of this structure. 982 */ 983struct nfs_stats { 984 kstat_named_t *nfs_stats_svstat_ptr[NFS_VERSMAX + 1]; 985 struct nfs_version_stats nfs_stats_v2; 986 struct nfs_version_stats nfs_stats_v3; 987 struct nfs_version_stats nfs_stats_v4; 988}; 989 990/* 991 * Key used to retrieve counters. 992 */ 993extern zone_key_t nfsstat_zone_key; 994 995/* 996 * Zone callback functions. 997 */ 998extern void *nfsstat_zone_init(zoneid_t); 999extern void nfsstat_zone_fini(zoneid_t, void *); 1000 1001#endif /* _KERNEL */ 1002 1003/* 1004 * Version 3 declarations and definitions. 1005 */ 1006 1007#define NFS3_FHSIZE 64 1008#define NFS3_COOKIEVERFSIZE 8 1009#define NFS3_CREATEVERFSIZE 8 1010#define NFS3_WRITEVERFSIZE 8 1011 1012typedef char *filename3; 1013 1014typedef char *nfspath3; 1015 1016#define nfs3nametoolong ((char *)-1) 1017 1018typedef uint64 fileid3; 1019 1020typedef uint64 cookie3; 1021 1022typedef uint32 uid3; 1023 1024typedef uint32 gid3; 1025 1026typedef uint64 size3; 1027 1028typedef uint64 offset3; 1029 1030typedef uint32 mode3; 1031 1032typedef uint32 count3; 1033 1034/* 1035 * These three are really opaque arrays, but we treat them as 1036 * uint64 for efficiency sake 1037 */ 1038typedef uint64 cookieverf3; 1039 1040typedef uint64 createverf3; 1041 1042typedef uint64 writeverf3; 1043 1044typedef struct nfs_fh3 { 1045 uint_t fh3_length; 1046 union nfs_fh3_u { 1047 struct nfs_fh3_i { 1048 fhandle3_t fh3_i; 1049 } nfs_fh3_i; 1050 char data[NFS3_FHSIZE]; 1051 } fh3_u; 1052 uint_t fh3_flags; 1053} nfs_fh3; 1054#define fh3_fsid fh3_u.nfs_fh3_i.fh3_i._fh3_fsid 1055#define fh3_len fh3_u.nfs_fh3_i.fh3_i._fh3_len 1056#define fh3_data fh3_u.nfs_fh3_i.fh3_i._fh3_data 1057#define fh3_xlen fh3_u.nfs_fh3_i.fh3_i._fh3_xlen 1058#define fh3_xdata fh3_u.nfs_fh3_i.fh3_i._fh3_xdata 1059#define FH3TOFIDP(fh) ((fid_t *)&((fh)->fh3_len)) 1060#define FH3TOXFIDP(fh) ((fid_t *)&((fh)->fh3_xlen)) 1061 1062/* 1063 * nfs_fh3.fh3_flags values 1064 */ 1065#define FH_WEBNFS 0x1 /* fh is WebNFS overloaded - see makefh3_ol() */ 1066 1067/* 1068 * Two elements were added to the 1069 * diropargs3 structure for performance (xdr-inlining). 1070 * They are not included as part of the args 1071 * that are encoded or decoded: 1072 * dirp - ptr to the nfs_fh3 1073 * flag indicating when to free the name that was 1074 * allocated during decode. 1075 */ 1076struct diropargs3 { 1077 nfs_fh3 *dirp; 1078 nfs_fh3 dir; 1079 filename3 name; 1080 int flags; 1081}; 1082typedef struct diropargs3 diropargs3; 1083 1084struct nfstime3 { 1085 uint32 seconds; 1086 uint32 nseconds; 1087}; 1088typedef struct nfstime3 nfstime3; 1089 1090struct specdata3 { 1091 uint32 specdata1; 1092 uint32 specdata2; 1093}; 1094typedef struct specdata3 specdata3; 1095 1096enum nfsstat3 { 1097 NFS3_OK = 0, 1098 NFS3ERR_PERM = 1, 1099 NFS3ERR_NOENT = 2, 1100 NFS3ERR_IO = 5, 1101 NFS3ERR_NXIO = 6, 1102 NFS3ERR_ACCES = 13, 1103 NFS3ERR_EXIST = 17, 1104 NFS3ERR_XDEV = 18, 1105 NFS3ERR_NODEV = 19, 1106 NFS3ERR_NOTDIR = 20, 1107 NFS3ERR_ISDIR = 21, 1108 NFS3ERR_INVAL = 22, 1109 NFS3ERR_FBIG = 27, 1110 NFS3ERR_NOSPC = 28, 1111 NFS3ERR_ROFS = 30, 1112 NFS3ERR_MLINK = 31, 1113 NFS3ERR_NAMETOOLONG = 63, 1114 NFS3ERR_NOTEMPTY = 66, 1115 NFS3ERR_DQUOT = 69, 1116 NFS3ERR_STALE = 70, 1117 NFS3ERR_REMOTE = 71, 1118 NFS3ERR_BADHANDLE = 10001, 1119 NFS3ERR_NOT_SYNC = 10002, 1120 NFS3ERR_BAD_COOKIE = 10003, 1121 NFS3ERR_NOTSUPP = 10004, 1122 NFS3ERR_TOOSMALL = 10005, 1123 NFS3ERR_SERVERFAULT = 10006, 1124 NFS3ERR_BADTYPE = 10007, 1125 NFS3ERR_JUKEBOX = 10008 1126}; 1127typedef enum nfsstat3 nfsstat3; 1128 1129enum ftype3 { 1130 NF3REG = 1, 1131 NF3DIR = 2, 1132 NF3BLK = 3, 1133 NF3CHR = 4, 1134 NF3LNK = 5, 1135 NF3SOCK = 6, 1136 NF3FIFO = 7 1137}; 1138typedef enum ftype3 ftype3; 1139 1140struct fattr3 { 1141 ftype3 type; 1142 mode3 mode; 1143 uint32 nlink; 1144 uid3 uid; 1145 gid3 gid; 1146 size3 size; 1147 size3 used; 1148 specdata3 rdev; 1149 uint64 fsid; 1150 fileid3 fileid; 1151 nfstime3 atime; 1152 nfstime3 mtime; 1153 nfstime3 ctime; 1154}; 1155typedef struct fattr3 fattr3; 1156 1157#define NFS3_SIZEOF_FATTR3 (21) 1158 1159#ifdef _KERNEL 1160struct fattr3_res { 1161 nfsstat3 status; 1162 vattr_t *vap; 1163 vnode_t *vp; 1164}; 1165typedef struct fattr3_res fattr3_res; 1166#endif /* _KERNEL */ 1167 1168struct post_op_attr { 1169 bool_t attributes; 1170 fattr3 attr; 1171}; 1172typedef struct post_op_attr post_op_attr; 1173 1174#ifdef _KERNEL 1175struct post_op_vattr { 1176 bool_t attributes; 1177 fattr3_res fres; 1178}; 1179typedef struct post_op_vattr post_op_vattr; 1180#endif /* _KERNEL */ 1181 1182struct wcc_attr { 1183 size3 size; 1184 nfstime3 mtime; 1185 nfstime3 ctime; 1186}; 1187typedef struct wcc_attr wcc_attr; 1188 1189struct pre_op_attr { 1190 bool_t attributes; 1191 wcc_attr attr; 1192}; 1193typedef struct pre_op_attr pre_op_attr; 1194 1195struct wcc_data { 1196 pre_op_attr before; 1197 post_op_attr after; 1198}; 1199typedef struct wcc_data wcc_data; 1200 1201struct post_op_fh3 { 1202 bool_t handle_follows; 1203 nfs_fh3 handle; 1204}; 1205typedef struct post_op_fh3 post_op_fh3; 1206 1207enum time_how { 1208 DONT_CHANGE = 0, 1209 SET_TO_SERVER_TIME = 1, 1210 SET_TO_CLIENT_TIME = 2 1211}; 1212typedef enum time_how time_how; 1213 1214struct set_mode3 { 1215 bool_t set_it; 1216 mode3 mode; 1217}; 1218typedef struct set_mode3 set_mode3; 1219 1220struct set_uid3 { 1221 bool_t set_it; 1222 uid3 uid; 1223}; 1224typedef struct set_uid3 set_uid3; 1225 1226struct set_gid3 { 1227 bool_t set_it; 1228 gid3 gid; 1229}; 1230typedef struct set_gid3 set_gid3; 1231 1232struct set_size3 { 1233 bool_t set_it; 1234 size3 size; 1235}; 1236typedef struct set_size3 set_size3; 1237 1238struct set_atime { 1239 time_how set_it; 1240 nfstime3 atime; 1241}; 1242typedef struct set_atime set_atime; 1243 1244struct set_mtime { 1245 time_how set_it; 1246 nfstime3 mtime; 1247}; 1248typedef struct set_mtime set_mtime; 1249 1250struct sattr3 { 1251 set_mode3 mode; 1252 set_uid3 uid; 1253 set_gid3 gid; 1254 set_size3 size; 1255 set_atime atime; 1256 set_mtime mtime; 1257}; 1258typedef struct sattr3 sattr3; 1259 1260/* 1261 * A couple of defines to make resok and resfail look like the 1262 * correct things in a response type independent manner. 1263 */ 1264#define resok res_u.ok 1265#define resfail res_u.fail 1266 1267struct GETATTR3args { 1268 nfs_fh3 object; 1269}; 1270typedef struct GETATTR3args GETATTR3args; 1271 1272struct GETATTR3resok { 1273 fattr3 obj_attributes; 1274}; 1275typedef struct GETATTR3resok GETATTR3resok; 1276 1277struct GETATTR3res { 1278 nfsstat3 status; 1279 union { 1280 GETATTR3resok ok; 1281 } res_u; 1282}; 1283typedef struct GETATTR3res GETATTR3res; 1284 1285#ifdef _KERNEL 1286struct GETATTR3vres { 1287 nfsstat3 status; 1288 fattr3_res fres; 1289}; 1290typedef struct GETATTR3vres GETATTR3vres; 1291#endif /* _KERNEL */ 1292 1293struct sattrguard3 { 1294 bool_t check; 1295 nfstime3 obj_ctime; 1296}; 1297typedef struct sattrguard3 sattrguard3; 1298 1299struct SETATTR3args { 1300 nfs_fh3 object; 1301 sattr3 new_attributes; 1302 sattrguard3 guard; 1303}; 1304typedef struct SETATTR3args SETATTR3args; 1305 1306struct SETATTR3resok { 1307 wcc_data obj_wcc; 1308}; 1309typedef struct SETATTR3resok SETATTR3resok; 1310 1311struct SETATTR3resfail { 1312 wcc_data obj_wcc; 1313}; 1314typedef struct SETATTR3resfail SETATTR3resfail; 1315 1316struct SETATTR3res { 1317 nfsstat3 status; 1318 union { 1319 SETATTR3resok ok; 1320 SETATTR3resfail fail; 1321 } res_u; 1322}; 1323typedef struct SETATTR3res SETATTR3res; 1324 1325struct LOOKUP3args { 1326 diropargs3 what; 1327}; 1328typedef struct LOOKUP3args LOOKUP3args; 1329 1330struct LOOKUP3resok { 1331 nfs_fh3 object; 1332 post_op_attr obj_attributes; 1333 post_op_attr dir_attributes; 1334}; 1335typedef struct LOOKUP3resok LOOKUP3resok; 1336 1337struct LOOKUP3resfail { 1338 post_op_attr dir_attributes; 1339}; 1340typedef struct LOOKUP3resfail LOOKUP3resfail; 1341 1342struct LOOKUP3res { 1343 nfsstat3 status; 1344 union { 1345 LOOKUP3resok ok; 1346 LOOKUP3resfail fail; 1347 } res_u; 1348}; 1349typedef struct LOOKUP3res LOOKUP3res; 1350 1351#ifdef _KERNEL 1352struct LOOKUP3vres { 1353 nfsstat3 status; 1354 nfs_fh3 object; 1355 post_op_vattr dir_attributes; 1356 post_op_vattr obj_attributes; 1357}; 1358typedef struct LOOKUP3vres LOOKUP3vres; 1359#endif /* _KERNEL */ 1360 1361struct ACCESS3args { 1362 nfs_fh3 object; 1363 uint32 access; 1364}; 1365typedef struct ACCESS3args ACCESS3args; 1366#define ACCESS3_READ 0x1 1367#define ACCESS3_LOOKUP 0x2 1368#define ACCESS3_MODIFY 0x4 1369#define ACCESS3_EXTEND 0x8 1370#define ACCESS3_DELETE 0x10 1371#define ACCESS3_EXECUTE 0x20 1372 1373struct ACCESS3resok { 1374 post_op_attr obj_attributes; 1375 uint32 access; 1376}; 1377typedef struct ACCESS3resok ACCESS3resok; 1378 1379struct ACCESS3resfail { 1380 post_op_attr obj_attributes; 1381}; 1382typedef struct ACCESS3resfail ACCESS3resfail; 1383 1384struct ACCESS3res { 1385 nfsstat3 status; 1386 union { 1387 ACCESS3resok ok; 1388 ACCESS3resfail fail; 1389 } res_u; 1390}; 1391typedef struct ACCESS3res ACCESS3res; 1392 1393struct READLINK3args { 1394 nfs_fh3 symlink; 1395}; 1396typedef struct READLINK3args READLINK3args; 1397 1398struct READLINK3resok { 1399 post_op_attr symlink_attributes; 1400 nfspath3 data; 1401}; 1402typedef struct READLINK3resok READLINK3resok; 1403 1404struct READLINK3resfail { 1405 post_op_attr symlink_attributes; 1406}; 1407typedef struct READLINK3resfail READLINK3resfail; 1408 1409struct READLINK3res { 1410 nfsstat3 status; 1411 union { 1412 READLINK3resok ok; 1413 READLINK3resfail fail; 1414 } res_u; 1415}; 1416typedef struct READLINK3res READLINK3res; 1417 1418struct READ3args { 1419 nfs_fh3 file; 1420 offset3 offset; 1421 count3 count; 1422#ifdef _KERNEL 1423 /* for read using rdma */ 1424 char *res_data_val_alt; 1425 struct uio *res_uiop; 1426 struct clist *wlist; 1427 CONN *conn; 1428#endif 1429}; 1430typedef struct READ3args READ3args; 1431 1432struct READ3resok { 1433 post_op_attr file_attributes; 1434 count3 count; 1435 bool_t eof; 1436 struct { 1437 uint_t data_len; 1438 char *data_val; 1439 mblk_t *mp; 1440 } data; 1441 uint_t size; 1442#ifdef _KERNEL 1443 uint_t wlist_len; 1444 struct clist *wlist; 1445 frtn_t zcopy; 1446#endif 1447}; 1448typedef struct READ3resok READ3resok; 1449 1450struct READ3resfail { 1451 post_op_attr file_attributes; 1452}; 1453typedef struct READ3resfail READ3resfail; 1454 1455struct READ3res { 1456 nfsstat3 status; 1457 union { 1458 READ3resok ok; 1459 READ3resfail fail; 1460 } res_u; 1461}; 1462typedef struct READ3res READ3res; 1463 1464#ifdef _KERNEL 1465/* 1466 * READ3 reply that directly decodes fattr3 directly into vattr 1467 */ 1468struct READ3vres { 1469 nfsstat3 status; 1470 struct post_op_vattr pov; 1471 count3 count; 1472 bool_t eof; 1473 struct { 1474 uint_t data_len; 1475 char *data_val; 1476 } data; 1477 uint_t size; 1478 1479 uint_t wlist_len; 1480 struct clist *wlist; 1481}; 1482typedef struct READ3vres READ3vres; 1483#endif /* _KERNEL */ 1484 1485/* 1486 * READ3 reply that uiomoves data directly into a struct uio 1487 * ignores any attributes returned 1488 */ 1489struct READ3uiores { 1490 nfsstat3 status; 1491 count3 count; 1492 bool_t eof; 1493 struct uio *uiop; 1494 uint_t size; /* maximum reply size */ 1495#ifdef _KERNEL 1496 uint_t wlist_len; 1497 struct clist *wlist; 1498#endif 1499}; 1500typedef struct READ3uiores READ3uiores; 1501 1502enum stable_how { 1503 UNSTABLE = 0, 1504 DATA_SYNC = 1, 1505 FILE_SYNC = 2 1506}; 1507typedef enum stable_how stable_how; 1508 1509struct WRITE3args { 1510 nfs_fh3 file; 1511 offset3 offset; 1512 count3 count; 1513 stable_how stable; 1514 struct { 1515 uint_t data_len; 1516 char *data_val; 1517 } data; 1518 mblk_t *mblk; 1519#ifdef _KERNEL 1520 struct clist *rlist; 1521 CONN *conn; 1522#endif 1523}; 1524typedef struct WRITE3args WRITE3args; 1525 1526struct WRITE3resok { 1527 wcc_data file_wcc; 1528 count3 count; 1529 stable_how committed; 1530 writeverf3 verf; 1531}; 1532typedef struct WRITE3resok WRITE3resok; 1533 1534struct WRITE3resfail { 1535 wcc_data file_wcc; 1536}; 1537typedef struct WRITE3resfail WRITE3resfail; 1538 1539struct WRITE3res { 1540 nfsstat3 status; 1541 union { 1542 WRITE3resok ok; 1543 WRITE3resfail fail; 1544 } res_u; 1545}; 1546typedef struct WRITE3res WRITE3res; 1547 1548enum createmode3 { 1549 UNCHECKED = 0, 1550 GUARDED = 1, 1551 EXCLUSIVE = 2 1552}; 1553typedef enum createmode3 createmode3; 1554 1555struct createhow3 { 1556 createmode3 mode; 1557 union { 1558 sattr3 obj_attributes; 1559 createverf3 verf; 1560 } createhow3_u; 1561}; 1562typedef struct createhow3 createhow3; 1563 1564struct CREATE3args { 1565 diropargs3 where; 1566 createhow3 how; 1567}; 1568typedef struct CREATE3args CREATE3args; 1569 1570struct CREATE3resok { 1571 post_op_fh3 obj; 1572 post_op_attr obj_attributes; 1573 wcc_data dir_wcc; 1574}; 1575typedef struct CREATE3resok CREATE3resok; 1576 1577struct CREATE3resfail { 1578 wcc_data dir_wcc; 1579}; 1580typedef struct CREATE3resfail CREATE3resfail; 1581 1582struct CREATE3res { 1583 nfsstat3 status; 1584 union { 1585 CREATE3resok ok; 1586 CREATE3resfail fail; 1587 } res_u; 1588}; 1589typedef struct CREATE3res CREATE3res; 1590 1591struct MKDIR3args { 1592 diropargs3 where; 1593 sattr3 attributes; 1594}; 1595typedef struct MKDIR3args MKDIR3args; 1596 1597struct MKDIR3resok { 1598 post_op_fh3 obj; 1599 post_op_attr obj_attributes; 1600 wcc_data dir_wcc; 1601}; 1602typedef struct MKDIR3resok MKDIR3resok; 1603 1604struct MKDIR3resfail { 1605 wcc_data dir_wcc; 1606}; 1607typedef struct MKDIR3resfail MKDIR3resfail; 1608 1609struct MKDIR3res { 1610 nfsstat3 status; 1611 union { 1612 MKDIR3resok ok; 1613 MKDIR3resfail fail; 1614 } res_u; 1615}; 1616typedef struct MKDIR3res MKDIR3res; 1617 1618struct symlinkdata3 { 1619 sattr3 symlink_attributes; 1620 nfspath3 symlink_data; 1621}; 1622typedef struct symlinkdata3 symlinkdata3; 1623 1624struct SYMLINK3args { 1625 diropargs3 where; 1626 symlinkdata3 symlink; 1627}; 1628typedef struct SYMLINK3args SYMLINK3args; 1629 1630struct SYMLINK3resok { 1631 post_op_fh3 obj; 1632 post_op_attr obj_attributes; 1633 wcc_data dir_wcc; 1634}; 1635typedef struct SYMLINK3resok SYMLINK3resok; 1636 1637struct SYMLINK3resfail { 1638 wcc_data dir_wcc; 1639}; 1640typedef struct SYMLINK3resfail SYMLINK3resfail; 1641 1642struct SYMLINK3res { 1643 nfsstat3 status; 1644 union { 1645 SYMLINK3resok ok; 1646 SYMLINK3resfail fail; 1647 } res_u; 1648}; 1649typedef struct SYMLINK3res SYMLINK3res; 1650 1651struct devicedata3 { 1652 sattr3 dev_attributes; 1653 specdata3 spec; 1654}; 1655typedef struct devicedata3 devicedata3; 1656 1657struct mknoddata3 { 1658 ftype3 type; 1659 union { 1660 devicedata3 device; 1661 sattr3 pipe_attributes; 1662 } mknoddata3_u; 1663}; 1664typedef struct mknoddata3 mknoddata3; 1665 1666struct MKNOD3args { 1667 diropargs3 where; 1668 mknoddata3 what; 1669}; 1670typedef struct MKNOD3args MKNOD3args; 1671 1672struct MKNOD3resok { 1673 post_op_fh3 obj; 1674 post_op_attr obj_attributes; 1675 wcc_data dir_wcc; 1676}; 1677typedef struct MKNOD3resok MKNOD3resok; 1678 1679struct MKNOD3resfail { 1680 wcc_data dir_wcc; 1681}; 1682typedef struct MKNOD3resfail MKNOD3resfail; 1683 1684struct MKNOD3res { 1685 nfsstat3 status; 1686 union { 1687 MKNOD3resok ok; 1688 MKNOD3resfail fail; 1689 } res_u; 1690}; 1691typedef struct MKNOD3res MKNOD3res; 1692 1693struct REMOVE3args { 1694 diropargs3 object; 1695}; 1696typedef struct REMOVE3args REMOVE3args; 1697 1698struct REMOVE3resok { 1699 wcc_data dir_wcc; 1700}; 1701typedef struct REMOVE3resok REMOVE3resok; 1702 1703struct REMOVE3resfail { 1704 wcc_data dir_wcc; 1705}; 1706typedef struct REMOVE3resfail REMOVE3resfail; 1707 1708struct REMOVE3res { 1709 nfsstat3 status; 1710 union { 1711 REMOVE3resok ok; 1712 REMOVE3resfail fail; 1713 } res_u; 1714}; 1715typedef struct REMOVE3res REMOVE3res; 1716 1717struct RMDIR3args { 1718 diropargs3 object; 1719}; 1720typedef struct RMDIR3args RMDIR3args; 1721 1722struct RMDIR3resok { 1723 wcc_data dir_wcc; 1724}; 1725typedef struct RMDIR3resok RMDIR3resok; 1726 1727struct RMDIR3resfail { 1728 wcc_data dir_wcc; 1729}; 1730typedef struct RMDIR3resfail RMDIR3resfail; 1731 1732struct RMDIR3res { 1733 nfsstat3 status; 1734 union { 1735 RMDIR3resok ok; 1736 RMDIR3resfail fail; 1737 } res_u; 1738}; 1739typedef struct RMDIR3res RMDIR3res; 1740 1741struct RENAME3args { 1742 diropargs3 from; 1743 diropargs3 to; 1744}; 1745typedef struct RENAME3args RENAME3args; 1746 1747struct RENAME3resok { 1748 wcc_data fromdir_wcc; 1749 wcc_data todir_wcc; 1750}; 1751typedef struct RENAME3resok RENAME3resok; 1752 1753struct RENAME3resfail { 1754 wcc_data fromdir_wcc; 1755 wcc_data todir_wcc; 1756}; 1757typedef struct RENAME3resfail RENAME3resfail; 1758 1759struct RENAME3res { 1760 nfsstat3 status; 1761 union { 1762 RENAME3resok ok; 1763 RENAME3resfail fail; 1764 } res_u; 1765}; 1766typedef struct RENAME3res RENAME3res; 1767 1768struct LINK3args { 1769 nfs_fh3 file; 1770 diropargs3 link; 1771}; 1772typedef struct LINK3args LINK3args; 1773 1774struct LINK3resok { 1775 post_op_attr file_attributes; 1776 wcc_data linkdir_wcc; 1777}; 1778typedef struct LINK3resok LINK3resok; 1779 1780struct LINK3resfail { 1781 post_op_attr file_attributes; 1782 wcc_data linkdir_wcc; 1783}; 1784typedef struct LINK3resfail LINK3resfail; 1785 1786struct LINK3res { 1787 nfsstat3 status; 1788 union { 1789 LINK3resok ok; 1790 LINK3resfail fail; 1791 } res_u; 1792}; 1793typedef struct LINK3res LINK3res; 1794 1795struct READDIR3args { 1796 nfs_fh3 dir; 1797 cookie3 cookie; 1798 cookieverf3 cookieverf; 1799 count3 count; 1800}; 1801typedef struct READDIR3args READDIR3args; 1802 1803struct entry3 { 1804 fileid3 fileid; 1805 filename3 name; 1806 cookie3 cookie; 1807 struct entry3 *nextentry; 1808}; 1809typedef struct entry3 entry3; 1810 1811struct dirlist3 { 1812 entry3 *entries; 1813 bool_t eof; 1814}; 1815typedef struct dirlist3 dirlist3; 1816 1817struct READDIR3resok { 1818 post_op_attr dir_attributes; 1819 cookieverf3 cookieverf; 1820 dirlist3 reply; 1821 uint_t size; 1822 uint_t count; 1823 uint_t freecount; 1824 cookie3 cookie; 1825}; 1826typedef struct READDIR3resok READDIR3resok; 1827 1828struct READDIR3resfail { 1829 post_op_attr dir_attributes; 1830}; 1831typedef struct READDIR3resfail READDIR3resfail; 1832 1833struct READDIR3res { 1834 nfsstat3 status; 1835 union { 1836 READDIR3resok ok; 1837 READDIR3resfail fail; 1838 } res_u; 1839}; 1840typedef struct READDIR3res READDIR3res; 1841 1842#ifdef _KERNEL 1843struct READDIR3vres { 1844 nfsstat3 status; 1845 post_op_vattr dir_attributes; 1846 cookieverf3 cookieverf; 1847 dirent64_t *entries; /* decoded dirent64s */ 1848 uint_t size; /* actual size of entries */ 1849 uint_t entries_size; /* max size of entries */ 1850 off64_t loff; /* last offset/cookie */ 1851 bool_t eof; /* End of directory */ 1852}; 1853typedef struct READDIR3vres READDIR3vres; 1854#endif /* _KERNEL */ 1855 1856struct READDIRPLUS3args { 1857 nfs_fh3 dir; 1858 cookie3 cookie; 1859 cookieverf3 cookieverf; 1860 count3 dircount; 1861 count3 maxcount; 1862}; 1863typedef struct READDIRPLUS3args READDIRPLUS3args; 1864 1865struct entryplus3 { 1866 fileid3 fileid; 1867 filename3 name; 1868 cookie3 cookie; 1869 post_op_attr name_attributes; 1870 post_op_fh3 name_handle; 1871 struct entryplus3 *nextentry; 1872}; 1873typedef struct entryplus3 entryplus3; 1874 1875struct dirlistplus3 { 1876 entryplus3 *entries; 1877 bool_t eof; 1878}; 1879typedef struct dirlistplus3 dirlistplus3; 1880 1881struct entryplus3_info { 1882 post_op_attr attr; 1883 post_op_fh3 fh; 1884 uint_t namelen; 1885}; 1886typedef struct entryplus3_info entryplus3_info; 1887 1888struct READDIRPLUS3resok { 1889 post_op_attr dir_attributes; 1890 cookieverf3 cookieverf; 1891 dirlistplus3 reply; 1892 uint_t size; 1893 uint_t count; 1894 uint_t maxcount; 1895 entryplus3_info *infop; 1896}; 1897typedef struct READDIRPLUS3resok READDIRPLUS3resok; 1898 1899struct READDIRPLUS3resfail { 1900 post_op_attr dir_attributes; 1901}; 1902typedef struct READDIRPLUS3resfail READDIRPLUS3resfail; 1903 1904struct READDIRPLUS3res { 1905 nfsstat3 status; 1906 union { 1907 READDIRPLUS3resok ok; 1908 READDIRPLUS3resfail fail; 1909 } res_u; 1910}; 1911typedef struct READDIRPLUS3res READDIRPLUS3res; 1912 1913#ifdef _KERNEL 1914struct entryplus3_va_fh { 1915 int va_valid; 1916 int fh_valid; 1917 vattr_t va; 1918 nfs_fh3 fh; 1919 char *d_name; /* back pointer into entries */ 1920}; 1921 1922struct READDIRPLUS3vres { 1923 nfsstat3 status; 1924 post_op_vattr dir_attributes; 1925 cookieverf3 cookieverf; 1926 dirent64_t *entries; /* decoded dirent64s */ 1927 uint_t size; /* actual size of entries */ 1928 uint_t entries_size; /* max size of entries */ 1929 bool_t eof; /* End of directory */ 1930 off64_t loff; /* last offset/cookie */ 1931 cred_t *credentials; /* caller's credentials */ 1932 hrtime_t time; /* time of READDIRPLUS call */ 1933}; 1934typedef struct READDIRPLUS3vres READDIRPLUS3vres; 1935#endif /* _KERNEL */ 1936 1937struct FSSTAT3args { 1938 nfs_fh3 fsroot; 1939}; 1940typedef struct FSSTAT3args FSSTAT3args; 1941 1942struct FSSTAT3resok { 1943 post_op_attr obj_attributes; 1944 size3 tbytes; 1945 size3 fbytes; 1946 size3 abytes; 1947 size3 tfiles; 1948 size3 ffiles; 1949 size3 afiles; 1950 uint32 invarsec; 1951}; 1952typedef struct FSSTAT3resok FSSTAT3resok; 1953 1954struct FSSTAT3resfail { 1955 post_op_attr obj_attributes; 1956}; 1957typedef struct FSSTAT3resfail FSSTAT3resfail; 1958 1959struct FSSTAT3res { 1960 nfsstat3 status; 1961 union { 1962 FSSTAT3resok ok; 1963 FSSTAT3resfail fail; 1964 } res_u; 1965}; 1966typedef struct FSSTAT3res FSSTAT3res; 1967 1968struct FSINFO3args { 1969 nfs_fh3 fsroot; 1970}; 1971typedef struct FSINFO3args FSINFO3args; 1972 1973struct FSINFO3resok { 1974 post_op_attr obj_attributes; 1975 uint32 rtmax; 1976 uint32 rtpref; 1977 uint32 rtmult; 1978 uint32 wtmax; 1979 uint32 wtpref; 1980 uint32 wtmult; 1981 uint32 dtpref; 1982 size3 maxfilesize; 1983 nfstime3 time_delta; 1984 uint32 properties; 1985}; 1986typedef struct FSINFO3resok FSINFO3resok; 1987 1988struct FSINFO3resfail { 1989 post_op_attr obj_attributes; 1990}; 1991typedef struct FSINFO3resfail FSINFO3resfail; 1992#define FSF3_LINK 0x1 1993#define FSF3_SYMLINK 0x2 1994#define FSF3_HOMOGENEOUS 0x8 1995#define FSF3_CANSETTIME 0x10 1996 1997struct FSINFO3res { 1998 nfsstat3 status; 1999 union { 2000 FSINFO3resok ok; 2001 FSINFO3resfail fail; 2002 } res_u; 2003}; 2004typedef struct FSINFO3res FSINFO3res; 2005 2006struct PATHCONF3args { 2007 nfs_fh3 object; 2008}; 2009typedef struct PATHCONF3args PATHCONF3args; 2010 2011struct nfs3_pathconf_info { 2012 uint32 link_max; 2013 uint32 name_max; 2014 bool_t no_trunc; 2015 bool_t chown_restricted; 2016 bool_t case_insensitive; 2017 bool_t case_preserving; 2018}; 2019typedef struct nfs3_pathconf_info nfs3_pathconf_info; 2020 2021struct PATHCONF3resok { 2022 post_op_attr obj_attributes; 2023 nfs3_pathconf_info info; 2024}; 2025typedef struct PATHCONF3resok PATHCONF3resok; 2026 2027struct PATHCONF3resfail { 2028 post_op_attr obj_attributes; 2029}; 2030typedef struct PATHCONF3resfail PATHCONF3resfail; 2031 2032struct PATHCONF3res { 2033 nfsstat3 status; 2034 union { 2035 PATHCONF3resok ok; 2036 PATHCONF3resfail fail; 2037 } res_u; 2038}; 2039typedef struct PATHCONF3res PATHCONF3res; 2040 2041struct COMMIT3args { 2042 nfs_fh3 file; 2043 offset3 offset; 2044 count3 count; 2045}; 2046typedef struct COMMIT3args COMMIT3args; 2047 2048struct COMMIT3resok { 2049 wcc_data file_wcc; 2050 writeverf3 verf; 2051}; 2052typedef struct COMMIT3resok COMMIT3resok; 2053 2054struct COMMIT3resfail { 2055 wcc_data file_wcc; 2056}; 2057typedef struct COMMIT3resfail COMMIT3resfail; 2058 2059struct COMMIT3res { 2060 nfsstat3 status; 2061 union { 2062 COMMIT3resok ok; 2063 COMMIT3resfail fail; 2064 } res_u; 2065}; 2066typedef struct COMMIT3res COMMIT3res; 2067 2068#define NFS3_PROGRAM ((rpcprog_t)100003) 2069#define NFS_V3 ((rpcvers_t)3) 2070#define NFSPROC3_NULL ((rpcproc_t)0) 2071#define NFSPROC3_GETATTR ((rpcproc_t)1) 2072#define NFSPROC3_SETATTR ((rpcproc_t)2) 2073#define NFSPROC3_LOOKUP ((rpcproc_t)3) 2074#define NFSPROC3_ACCESS ((rpcproc_t)4) 2075#define NFSPROC3_READLINK ((rpcproc_t)5) 2076#define NFSPROC3_READ ((rpcproc_t)6) 2077#define NFSPROC3_WRITE ((rpcproc_t)7) 2078#define NFSPROC3_CREATE ((rpcproc_t)8) 2079#define NFSPROC3_MKDIR ((rpcproc_t)9) 2080#define NFSPROC3_SYMLINK ((rpcproc_t)10) 2081#define NFSPROC3_MKNOD ((rpcproc_t)11) 2082#define NFSPROC3_REMOVE ((rpcproc_t)12) 2083#define NFSPROC3_RMDIR ((rpcproc_t)13) 2084#define NFSPROC3_RENAME ((rpcproc_t)14) 2085#define NFSPROC3_LINK ((rpcproc_t)15) 2086#define NFSPROC3_READDIR ((rpcproc_t)16) 2087#define NFSPROC3_READDIRPLUS ((rpcproc_t)17) 2088#define NFSPROC3_FSSTAT ((rpcproc_t)18) 2089#define NFSPROC3_FSINFO ((rpcproc_t)19) 2090#define NFSPROC3_PATHCONF ((rpcproc_t)20) 2091#define NFSPROC3_COMMIT ((rpcproc_t)21) 2092 2093#ifndef _KERNEL 2094extern void * nfsproc3_null_3(); 2095extern GETATTR3res * nfsproc3_getattr_3(); 2096extern SETATTR3res * nfsproc3_setattr_3(); 2097extern LOOKUP3res * nfsproc3_lookup_3(); 2098extern ACCESS3res * nfsproc3_access_3(); 2099extern READLINK3res * nfsproc3_readlink_3(); 2100extern READ3res * nfsproc3_read_3(); 2101extern WRITE3res * nfsproc3_write_3(); 2102extern CREATE3res * nfsproc3_create_3(); 2103extern MKDIR3res * nfsproc3_mkdir_3(); 2104extern SYMLINK3res * nfsproc3_symlink_3(); 2105extern MKNOD3res * nfsproc3_mknod_3(); 2106extern REMOVE3res * nfsproc3_remove_3(); 2107extern RMDIR3res * nfsproc3_rmdir_3(); 2108extern RENAME3res * nfsproc3_rename_3(); 2109extern LINK3res * nfsproc3_link_3(); 2110extern READDIR3res * nfsproc3_readdir_3(); 2111extern READDIRPLUS3res * nfsproc3_readdirplus_3(); 2112extern FSSTAT3res * nfsproc3_fsstat_3(); 2113extern FSINFO3res * nfsproc3_fsinfo_3(); 2114extern PATHCONF3res * nfsproc3_pathconf_3(); 2115extern COMMIT3res * nfsproc3_commit_3(); 2116#endif /* !_KERNEL */ 2117 2118#ifdef _KERNEL 2119/* the NFS Version 3 XDR functions */ 2120 2121extern bool_t xdr_nfs_fh3(XDR *, nfs_fh3 *); 2122extern bool_t xdr_nfslog_nfs_fh3(XDR *, nfs_fh3 *); 2123extern bool_t xdr_nfs_fh3_server(XDR *, nfs_fh3 *); 2124extern bool_t xdr_diropargs3(XDR *, diropargs3 *); 2125extern bool_t xdr_post_op_attr(XDR *, post_op_attr *); 2126extern bool_t xdr_post_op_fh3(XDR *, post_op_fh3 *); 2127extern bool_t xdr_GETATTR3res(XDR *, GETATTR3res *); 2128extern bool_t xdr_GETATTR3vres(XDR *, GETATTR3vres *); 2129extern bool_t xdr_SETATTR3args(XDR *, SETATTR3args *); 2130extern bool_t xdr_SETATTR3res(XDR *, SETATTR3res *); 2131extern bool_t xdr_LOOKUP3res(XDR *, LOOKUP3res *); 2132extern bool_t xdr_LOOKUP3vres(XDR *, LOOKUP3vres *); 2133extern bool_t xdr_ACCESS3args(XDR *, ACCESS3args *); 2134extern bool_t xdr_ACCESS3res(XDR *, ACCESS3res *); 2135extern bool_t xdr_READLINK3args(XDR *, READLINK3args *); 2136extern bool_t xdr_READLINK3res(XDR *, READLINK3res *); 2137extern bool_t xdr_READ3args(XDR *, READ3args *); 2138extern bool_t xdr_READ3res(XDR *, READ3res *); 2139extern bool_t xdr_READ3vres(XDR *, READ3vres *); 2140extern bool_t xdr_READ3uiores(XDR *, READ3uiores *); 2141extern bool_t xdr_WRITE3args(XDR *, WRITE3args *); 2142extern bool_t xdr_WRITE3res(XDR *, WRITE3res *); 2143extern bool_t xdr_CREATE3args(XDR *, CREATE3args *); 2144extern bool_t xdr_CREATE3res(XDR *, CREATE3res *); 2145extern bool_t xdr_MKDIR3args(XDR *, MKDIR3args *); 2146extern bool_t xdr_MKDIR3res(XDR *, MKDIR3res *); 2147extern bool_t xdr_SYMLINK3args(XDR *, SYMLINK3args *); 2148extern bool_t xdr_SYMLINK3res(XDR *, SYMLINK3res *); 2149extern bool_t xdr_MKNOD3args(XDR *, MKNOD3args *); 2150extern bool_t xdr_MKNOD3res(XDR *, MKNOD3res *); 2151extern bool_t xdr_REMOVE3res(XDR *, REMOVE3res *); 2152extern bool_t xdr_RMDIR3resfail(XDR *, RMDIR3resfail *); 2153extern bool_t xdr_RMDIR3res(XDR *, RMDIR3res *); 2154extern bool_t xdr_RENAME3args(XDR *, RENAME3args *); 2155extern bool_t xdr_RENAME3res(XDR *, RENAME3res *); 2156extern bool_t xdr_LINK3args(XDR *, LINK3args *); 2157extern bool_t xdr_LINK3res(XDR *, LINK3res *); 2158extern bool_t xdr_READDIR3args(XDR *, READDIR3args *); 2159extern bool_t xdr_READDIR3res(XDR *, READDIR3res *); 2160extern bool_t xdr_READDIR3vres(XDR *, READDIR3vres *); 2161extern bool_t xdr_READDIRPLUS3args(XDR *, READDIRPLUS3args *); 2162extern bool_t xdr_READDIRPLUS3res(XDR *, READDIRPLUS3res *); 2163extern bool_t xdr_READDIRPLUS3vres(XDR *, READDIRPLUS3vres *); 2164extern bool_t xdr_FSSTAT3res(XDR *, FSSTAT3res *); 2165extern bool_t xdr_FSINFO3res(XDR *, FSINFO3res *); 2166extern bool_t xdr_PATHCONF3res(XDR *, PATHCONF3res *); 2167extern bool_t xdr_COMMIT3args(XDR *, COMMIT3args *); 2168extern bool_t xdr_COMMIT3res(XDR *, COMMIT3res *); 2169extern bool_t xdr_fastnfs_fh3(XDR *, nfs_fh3 **); 2170 2171/* 2172 * The NFS Version 3 service procedures. 2173 */ 2174struct exportinfo; /* defined in nfs/export.h */ 2175struct servinfo; /* defined in nfs/nfs_clnt.h */ 2176struct mntinfo; /* defined in nfs/nfs_clnt.h */ 2177struct sec_ol; /* defined in nfs/export.h */ 2178 2179extern void rfs3_getattr(GETATTR3args *, GETATTR3res *, 2180 struct exportinfo *, struct svc_req *, cred_t *); 2181extern void *rfs3_getattr_getfh(GETATTR3args *); 2182extern void rfs3_setattr(SETATTR3args *, SETATTR3res *, 2183 struct exportinfo *, struct svc_req *, cred_t *); 2184extern void *rfs3_setattr_getfh(SETATTR3args *); 2185extern void rfs3_lookup(LOOKUP3args *, LOOKUP3res *, 2186 struct exportinfo *, struct svc_req *, cred_t *); 2187extern void *rfs3_lookup_getfh(LOOKUP3args *); 2188extern void rfs3_access(ACCESS3args *, ACCESS3res *, 2189 struct exportinfo *, struct svc_req *, cred_t *); 2190extern void *rfs3_access_getfh(ACCESS3args *); 2191extern void rfs3_readlink(READLINK3args *, READLINK3res *, 2192 struct exportinfo *, struct svc_req *, cred_t *); 2193extern void *rfs3_readlink_getfh(READLINK3args *); 2194extern void rfs3_readlink_free(READLINK3res *); 2195extern void rfs3_read(READ3args *, READ3res *, 2196 struct exportinfo *, struct svc_req *, cred_t *); 2197extern void *rfs3_read_getfh(READ3args *); 2198extern void rfs3_read_free(READ3res *); 2199extern void rfs3_write(WRITE3args *, WRITE3res *, 2200 struct exportinfo *, struct svc_req *, cred_t *); 2201extern void *rfs3_write_getfh(WRITE3args *); 2202extern void rfs3_create(CREATE3args *, CREATE3res *, 2203 struct exportinfo *, struct svc_req *, cred_t *); 2204extern void *rfs3_create_getfh(CREATE3args *); 2205extern void rfs3_mkdir(MKDIR3args *, MKDIR3res *, 2206 struct exportinfo *, struct svc_req *, cred_t *); 2207extern void *rfs3_mkdir_getfh(MKDIR3args *); 2208extern void rfs3_symlink(SYMLINK3args *, SYMLINK3res *, 2209 struct exportinfo *, struct svc_req *, cred_t *); 2210extern void *rfs3_symlink_getfh(SYMLINK3args *); 2211extern void rfs3_mknod(MKNOD3args *, MKNOD3res *, 2212 struct exportinfo *, struct svc_req *, cred_t *); 2213extern void *rfs3_mknod_getfh(MKNOD3args *); 2214extern void rfs3_remove(REMOVE3args *, REMOVE3res *, 2215 struct exportinfo *, struct svc_req *, cred_t *); 2216extern void *rfs3_remove_getfh(REMOVE3args *); 2217extern void rfs3_rmdir(RMDIR3args *, RMDIR3res *, 2218 struct exportinfo *, struct svc_req *, cred_t *); 2219extern void *rfs3_rmdir_getfh(RMDIR3args *); 2220extern void rfs3_rename(RENAME3args *, RENAME3res *, 2221 struct exportinfo *, struct svc_req *, cred_t *); 2222extern void *rfs3_rename_getfh(RENAME3args *); 2223extern void rfs3_link(LINK3args *, LINK3res *, 2224 struct exportinfo *, struct svc_req *, cred_t *); 2225extern void *rfs3_link_getfh(LINK3args *); 2226extern void rfs3_readdir(READDIR3args *, READDIR3res *, 2227 struct exportinfo *, struct svc_req *, cred_t *); 2228extern void *rfs3_readdir_getfh(READDIR3args *); 2229extern void rfs3_readdir_free(READDIR3res *); 2230extern void rfs3_readdirplus(READDIRPLUS3args *, READDIRPLUS3res *, 2231 struct exportinfo *, struct svc_req *, cred_t *); 2232extern void *rfs3_readdirplus_getfh(READDIRPLUS3args *); 2233extern void rfs3_readdirplus_free(READDIRPLUS3res *); 2234extern void rfs3_fsstat(FSSTAT3args *, FSSTAT3res *, 2235 struct exportinfo *, struct svc_req *, cred_t *); 2236extern void *rfs3_fsstat_getfh(FSSTAT3args *); 2237extern void rfs3_fsinfo(FSINFO3args *, FSINFO3res *, 2238 struct exportinfo *, struct svc_req *, cred_t *); 2239extern void *rfs3_fsinfo_getfh(FSINFO3args *); 2240extern void rfs3_pathconf(PATHCONF3args *, PATHCONF3res *, 2241 struct exportinfo *, struct svc_req *, cred_t *); 2242extern void *rfs3_pathconf_getfh(PATHCONF3args *); 2243extern void rfs3_commit(COMMIT3args *, COMMIT3res *, 2244 struct exportinfo *, struct svc_req *, cred_t *); 2245extern void *rfs3_commit_getfh(COMMIT3args *); 2246extern void rfs3_srvrinit(void); 2247extern void rfs3_srvrfini(void); 2248 2249extern int nfs3_validate_caches(vnode_t *, cred_t *); 2250extern void nfs3_cache_post_op_attr(vnode_t *, post_op_attr *, hrtime_t, 2251 cred_t *); 2252extern void nfs3_cache_post_op_vattr(vnode_t *, post_op_vattr *, hrtime_t, 2253 cred_t *); 2254extern void nfs3_cache_wcc_data(vnode_t *, wcc_data *, hrtime_t, cred_t *); 2255extern void nfs3_attrcache(vnode_t *, fattr3 *, hrtime_t); 2256extern int nfs3_cache_fattr3(vnode_t *, fattr3 *, vattr_t *, hrtime_t, 2257 cred_t *); 2258extern int nfs3_getattr_otw(vnode_t *, struct vattr *, cred_t *); 2259extern int nfs3getattr(vnode_t *, struct vattr *, cred_t *); 2260extern int fattr3_to_vattr(vnode_t *, fattr3 *, struct vattr *); 2261extern int nfs3tsize(void); 2262extern uint_t nfs3_tsize(struct knetconfig *); 2263extern uint_t rfs3_tsize(struct svc_req *); 2264extern int vattr_to_sattr3(struct vattr *, sattr3 *); 2265extern void setdiropargs3(diropargs3 *, char *, vnode_t *); 2266extern enum nfsstat3 puterrno3(int); 2267extern int geterrno3(enum nfsstat3); 2268extern int nfs3init(int, char *); 2269extern void nfs3fini(void); 2270extern int nfs3_vfsinit(void); 2271extern void nfs3_vfsfini(void); 2272extern void vattr_to_post_op_attr(struct vattr *, post_op_attr *); 2273extern void mblk_to_iov(mblk_t *, int, struct iovec *); 2274extern int rfs_publicfh_mclookup(char *, vnode_t *, cred_t *, 2275 vnode_t **, struct exportinfo **, struct sec_ol *); 2276extern int rfs_pathname(char *, vnode_t **, vnode_t **, 2277 vnode_t *, cred_t *, int); 2278extern vtype_t nf3_to_vt[]; 2279extern kstat_named_t *rfsproccnt_v3_ptr; 2280extern vfsops_t *nfs3_vfsops; 2281extern struct vnodeops *nfs3_vnodeops; 2282extern const struct fs_operation_def nfs3_vnodeops_template[]; 2283#ifdef DEBUG 2284extern int rfs3_do_pre_op_attr; 2285extern int rfs3_do_post_op_attr; 2286extern int rfs3_do_post_op_fh3; 2287#endif 2288/* 2289 * Some servers do not properly update the attributes of the 2290 * directory when changes are made. To allow interoperability 2291 * with these broken servers, the nfs_disable_rddir_cache 2292 * parameter can be used to disable readdir response caching. 2293 */ 2294extern int nfs_disable_rddir_cache; 2295 2296/* 2297 * External functions called by the v2/v3 code into the v4 code 2298 */ 2299extern void nfs4_clnt_init(void); 2300extern void nfs4_clnt_fini(void); 2301 2302/* 2303 * Does NFS4 server have a vnode delegated? TRUE if so, FALSE if not. 2304 */ 2305extern bool_t rfs4_check_delegated(int mode, vnode_t *, bool_t trunc); 2306/* 2307 * VOP_GETATTR call. If a NFS4 delegation is present on the supplied vnode 2308 * call back to the delegated client to get attributes for AT_MTIME and 2309 * AT_SIZE. Invoke VOP_GETATTR to get all other attributes or all attributes 2310 * if no delegation is present. 2311 */ 2312extern int rfs4_delegated_getattr(vnode_t *, vattr_t *, int, cred_t *); 2313extern void rfs4_hold_deleg_policy(void); 2314extern void rfs4_rele_deleg_policy(void); 2315 2316extern int do_xattr_exists_check(vnode_t *, ulong_t *, cred_t *); 2317 2318extern ts_label_t *nfs_getflabel(vnode_t *, struct exportinfo *); 2319extern boolean_t do_rfs_label_check(bslabel_t *, vnode_t *, int, 2320 struct exportinfo *); 2321 2322/* 2323 * Copy Reduction support. 2324 * xuio_t wrapper with additional private data. 2325 */ 2326 2327typedef struct nfs_xuio { 2328 xuio_t nu_uio; 2329 vnode_t *nu_vp; 2330 uint_t nu_ref; 2331 frtn_t nu_frtn; 2332} nfs_xuio_t; 2333 2334xuio_t *rfs_setup_xuio(vnode_t *); 2335mblk_t *uio_to_mblk(uio_t *); 2336void rfs_rndup_mblks(mblk_t *, uint_t, int); 2337void rfs_free_xuio(void *); 2338 2339#endif /* _KERNEL */ 2340 2341#ifdef __cplusplus 2342} 2343#endif 2344 2345#endif /* _NFS_NFS_H */ 2346