1 /*- 2 * Copyright (c) 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Rick Macklem at The University of Guelph. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the University nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * $FreeBSD$ 33 */ 34 35 #ifndef _NFS_NFS_H_ 36 #define _NFS_NFS_H_ 37 /* 38 * Tunable constants for nfs 39 */ 40 41 #define NFS_MAXIOVEC 34 42 #define NFS_TICKINTVL 500 /* Desired time for a tick (msec) */ 43 #define NFS_HZ (hz / nfscl_ticks) /* Ticks/sec */ 44 #define NFS_TIMEO (1 * NFS_HZ) /* Default timeout = 1 second */ 45 #define NFS_MINTIMEO (1 * NFS_HZ) /* Min timeout to use */ 46 #define NFS_MAXTIMEO (60 * NFS_HZ) /* Max timeout to backoff to */ 47 #define NFS_TCPTIMEO 300 /* TCP timeout */ 48 #define NFS_MAXRCVTIMEO 60 /* 1 minute in seconds */ 49 #define NFS_MINIDEMTIMEO (5 * NFS_HZ) /* Min timeout for non-idempotent ops*/ 50 #define NFS_MAXREXMIT 100 /* Stop counting after this many */ 51 #define NFSV4_CALLBACKTIMEO (2 * NFS_HZ) /* Timeout in ticks */ 52 #define NFSV4_CALLBACKRETRY 5 /* Number of retries before failure */ 53 #define NFSV4_SLOTS 64 /* Number of slots, fore channel */ 54 #define NFSV4_CBSLOTS 8 /* Number of slots, back channel */ 55 #define NFSV4_CBRETRYCNT 4 /* # of CBRecall retries upon err */ 56 #define NFSV4_UPCALLTIMEO (15 * NFS_HZ) /* Timeout in ticks for upcalls */ 57 /* to gssd or nfsuserd */ 58 #define NFSV4_UPCALLRETRY 4 /* Number of retries before failure */ 59 #define NFS_MAXWINDOW 1024 /* Max number of outstanding requests */ 60 #define NFS_RETRANS 10 /* Num of retrans for soft mounts */ 61 #define NFS_RETRANS_TCP 2 /* Num of retrans for TCP soft mounts */ 62 #define NFS_MAXGRPS 16 /* Max. size of groups list */ 63 #define NFS_TRYLATERDEL 15 /* Maximum delay timeout (sec) */ 64 #ifndef NFS_REMOVETIMEO 65 #define NFS_REMOVETIMEO 15 /* # sec to wait for delegret in local syscall */ 66 #endif 67 #ifndef NFS_MINATTRTIMO 68 #define NFS_MINATTRTIMO 5 /* Attribute cache timeout in sec */ 69 #endif 70 #ifndef NFS_MAXATTRTIMO 71 #define NFS_MAXATTRTIMO 60 72 #endif 73 #define NFS_WSIZE 8192 /* Def. write data size <= 8192 */ 74 #define NFS_RSIZE 8192 /* Def. read data size <= 8192 */ 75 #define NFS_READDIRSIZE 8192 /* Def. readdir size */ 76 #define NFS_DEFRAHEAD 1 /* Def. read ahead # blocks */ 77 #define NFS_MAXRAHEAD 16 /* Max. read ahead # blocks */ 78 #define NFS_MAXASYNCDAEMON 64 /* Max. number async_daemons runnable */ 79 #define NFS_MAXUIDHASH 64 /* Max. # of hashed uid entries/mp */ 80 #ifndef NFSRV_LEASE 81 #define NFSRV_LEASE 120 /* Lease time in seconds for V4 */ 82 #endif /* assigned to nfsrv_lease */ 83 #ifndef NFSRV_STALELEASE 84 #define NFSRV_STALELEASE (5 * nfsrv_lease) 85 #endif 86 #ifndef NFSRV_MOULDYLEASE 87 #define NFSRV_MOULDYLEASE 604800 /* One week (in sec) */ 88 #endif 89 #ifndef NFSCLIENTHASHSIZE 90 #define NFSCLIENTHASHSIZE 20 /* Size of server client hash table */ 91 #endif 92 #ifndef NFSLOCKHASHSIZE 93 #define NFSLOCKHASHSIZE 20 /* Size of server nfslock hash table */ 94 #endif 95 #ifndef NFSSESSIONHASHSIZE 96 #define NFSSESSIONHASHSIZE 20 /* Size of server session hash table */ 97 #endif 98 #define NFSSTATEHASHSIZE 10 /* Size of server stateid hash table */ 99 #ifndef NFSCLDELEGHIGHWATER 100 #define NFSCLDELEGHIGHWATER 10000 /* limit for client delegations */ 101 #endif 102 #ifndef NFSCLLAYOUTHIGHWATER 103 #define NFSCLLAYOUTHIGHWATER 10000 /* limit for client pNFS layouts */ 104 #endif 105 #ifndef NFSNOOPEN /* Inactive open owner (sec) */ 106 #define NFSNOOPEN 120 107 #endif 108 #define NFSRV_LEASEDELTA 15 /* # of seconds to delay beyond lease */ 109 #define NFS_IDMAXSIZE 4 /* max sizeof (in_addr_t) */ 110 #ifndef NFSRVCACHE_UDPTIMEOUT 111 #define NFSRVCACHE_UDPTIMEOUT 30 /* # of sec to hold cached rpcs(udp) */ 112 #endif 113 #ifndef NFSRVCACHE_UDPHIGHWATER 114 #define NFSRVCACHE_UDPHIGHWATER 500 /* Max # of udp cache entries */ 115 #endif 116 #ifndef NFSRVCACHE_TCPTIMEOUT 117 #define NFSRVCACHE_TCPTIMEOUT (3600*12) /*#of sec to hold cached rpcs(tcp) */ 118 #endif 119 #ifndef NFSRVCACHE_FLOODLEVEL 120 #define NFSRVCACHE_FLOODLEVEL 16384 /* Very high water mark for cache */ 121 #endif 122 #ifndef NFSRV_CLIENTHIGHWATER 123 #define NFSRV_CLIENTHIGHWATER 1000 124 #endif 125 #ifndef NFSRV_MAXDUMPLIST 126 #define NFSRV_MAXDUMPLIST 10000 127 #endif 128 #ifndef NFS_ACCESSCACHESIZE 129 #define NFS_ACCESSCACHESIZE 8 130 #endif 131 #define NFSV4_CBPORT 7745 /* Callback port for testing */ 132 133 /* 134 * This macro defines the high water mark for issuing V4 delegations. 135 * (It is currently set at a conservative 20% of nfsrv_v4statelimit. This 136 * may want to increase when clients can make more effective use of 137 * delegations.) 138 */ 139 #define NFSRV_V4DELEGLIMIT(c) (((c) * 5) > nfsrv_v4statelimit) 140 141 #define NFS_READDIRBLKSIZ DIRBLKSIZ /* Minimal nm_readdirsize */ 142 143 /* 144 * Oddballs 145 */ 146 #define NFS_CMPFH(n, f, s) \ 147 ((n)->n_fhp->nfh_len == (s) && !NFSBCMP((n)->n_fhp->nfh_fh, (caddr_t)(f), (s))) 148 #define NFSRV_CMPFH(nf, ns, f, s) \ 149 ((ns) == (s) && !NFSBCMP((caddr_t)(nf), (caddr_t)(f), (s))) 150 #define NFS_CMPTIME(t1, t2) \ 151 ((t1).tv_sec == (t2).tv_sec && (t1).tv_nsec == (t2).tv_nsec) 152 #define NFS_SETTIME(t) do { \ 153 (t).tv_sec = time.tv_sec; (t).tv_nsec = 1000 * time.tv_usec; } while (0) 154 #define NFS_SRVMAXDATA(n) \ 155 (((n)->nd_flag & (ND_NFSV3 | ND_NFSV4)) ? \ 156 NFS_SRVMAXIO : NFS_V2MAXDATA) 157 #define NFS64BITSSET 0xffffffffffffffffull 158 #define NFS64BITSMINUS1 0xfffffffffffffffeull 159 160 /* 161 * Structures for the nfssvc(2) syscall. Not that anyone but nfsd, mount_nfs 162 * and nfsloaduser should ever try and use it. 163 */ 164 struct nfsd_addsock_args { 165 int sock; /* Socket to serve */ 166 caddr_t name; /* Client addr for connection based sockets */ 167 int namelen; /* Length of name */ 168 }; 169 170 /* 171 * nfsd argument for new krpc. 172 */ 173 struct nfsd_nfsd_args { 174 const char *principal; /* GSS-API service principal name */ 175 int minthreads; /* minimum service thread count */ 176 int maxthreads; /* maximum service thread count */ 177 }; 178 179 /* 180 * NFSDEV_MIRRORSTR - string of digits that number the DSs 0->999. 181 * (To support more than 1000 DSs on an MDS, this needs to be increased.) 182 * NFSDEV_MAXMIRRORS - Maximum # of mirrors for a DS. 183 * (Most will only have a single mirror, but this setting allows up to 3.) 184 * NFSDEV_MAXVERS - maximum number of NFS versions supported by Flex File. 185 */ 186 #define NFSDEV_MIRRORSTR 3 187 #define NFSDEV_MAXMIRRORS 4 188 #define NFSDEV_MAXVERS 4 189 190 /* 191 * Arguments for use by the callback daemon. 192 */ 193 struct nfsd_nfscbd_args { 194 const char *principal; /* GSS-API service principal name */ 195 }; 196 197 struct nfscbd_args { 198 int sock; /* Socket to serve */ 199 caddr_t name; /* Client addr for connection based sockets */ 200 int namelen; /* Length of name */ 201 u_short port; /* Port# for callbacks */ 202 }; 203 204 struct nfsd_idargs { 205 int nid_flag; /* Flags (see below) */ 206 uid_t nid_uid; /* user/group id */ 207 gid_t nid_gid; 208 int nid_usermax; /* Upper bound on user name cache */ 209 int nid_usertimeout;/* User name timeout (minutes) */ 210 u_char *nid_name; /* Name */ 211 int nid_namelen; /* and its length */ 212 gid_t *nid_grps; /* and the list */ 213 int nid_ngroup; /* Size of groups list */ 214 }; 215 216 struct nfsd_oidargs { 217 int nid_flag; /* Flags (see below) */ 218 uid_t nid_uid; /* user/group id */ 219 gid_t nid_gid; 220 int nid_usermax; /* Upper bound on user name cache */ 221 int nid_usertimeout;/* User name timeout (minutes) */ 222 u_char *nid_name; /* Name */ 223 int nid_namelen; /* and its length */ 224 }; 225 226 struct nfsd_clid { 227 int nclid_idlen; /* Length of client id */ 228 u_char nclid_id[NFSV4_OPAQUELIMIT]; /* and name */ 229 }; 230 231 struct nfsd_dumplist { 232 int ndl_size; /* Number of elements */ 233 void *ndl_list; /* and the list of elements */ 234 }; 235 236 struct nfsd_dumpclients { 237 u_int32_t ndcl_flags; /* LCL_xxx flags */ 238 u_int32_t ndcl_nopenowners; /* Number of openowners */ 239 u_int32_t ndcl_nopens; /* and opens */ 240 u_int32_t ndcl_nlockowners; /* and of lockowners */ 241 u_int32_t ndcl_nlocks; /* and of locks */ 242 u_int32_t ndcl_ndelegs; /* and of delegations */ 243 u_int32_t ndcl_nolddelegs; /* and old delegations */ 244 sa_family_t ndcl_addrfam; /* Callback address */ 245 union { 246 struct in_addr sin_addr; 247 struct in6_addr sin6_addr; 248 } ndcl_cbaddr; 249 struct nfsd_clid ndcl_clid; /* and client id */ 250 }; 251 252 struct nfsd_dumplocklist { 253 char *ndllck_fname; /* File Name */ 254 int ndllck_size; /* Number of elements */ 255 void *ndllck_list; /* and the list of elements */ 256 }; 257 258 struct nfsd_dumplocks { 259 u_int32_t ndlck_flags; /* state flags NFSLCK_xxx */ 260 nfsv4stateid_t ndlck_stateid; /* stateid */ 261 u_int64_t ndlck_first; /* lock byte range */ 262 u_int64_t ndlck_end; 263 struct nfsd_clid ndlck_owner; /* Owner of open/lock */ 264 sa_family_t ndlck_addrfam; /* Callback address */ 265 union { 266 struct in_addr sin_addr; 267 struct in6_addr sin6_addr; 268 } ndlck_cbaddr; 269 struct nfsd_clid ndlck_clid; /* and client id */ 270 }; 271 272 /* 273 * Structure for referral information. 274 */ 275 struct nfsreferral { 276 u_char *nfr_srvlist; /* List of servers */ 277 int nfr_srvcnt; /* number of servers */ 278 vnode_t nfr_vp; /* vnode for referral */ 279 uint64_t nfr_dfileno; /* assigned dir inode# */ 280 }; 281 282 /* 283 * Flags for lc_flags and opsflags for nfsrv_getclient(). 284 */ 285 #define LCL_NEEDSCONFIRM 0x00000001 286 #define LCL_DONTCLEAN 0x00000002 287 #define LCL_WAKEUPWANTED 0x00000004 288 #define LCL_TCPCALLBACK 0x00000008 289 #define LCL_CALLBACKSON 0x00000010 290 #define LCL_INDEXNOTOK 0x00000020 291 #define LCL_STAMPEDSTABLE 0x00000040 292 #define LCL_EXPIREIT 0x00000080 293 #define LCL_CBDOWN 0x00000100 294 #define LCL_KERBV 0x00000400 295 #define LCL_NAME 0x00000800 296 #define LCL_NEEDSCBNULL 0x00001000 297 #define LCL_GSSINTEGRITY 0x00002000 298 #define LCL_GSSPRIVACY 0x00004000 299 #define LCL_ADMINREVOKED 0x00008000 300 #define LCL_RECLAIMCOMPLETE 0x00010000 301 #define LCL_NFSV41 0x00020000 302 303 #define LCL_GSS LCL_KERBV /* Or of all mechs */ 304 305 /* 306 * Bits for flags in nfslock and nfsstate. 307 * The access, deny, NFSLCK_READ and NFSLCK_WRITE bits must be defined as 308 * below, in the correct order, so the shifts work for tests. 309 */ 310 #define NFSLCK_READACCESS 0x00000001 311 #define NFSLCK_WRITEACCESS 0x00000002 312 #define NFSLCK_ACCESSBITS (NFSLCK_READACCESS | NFSLCK_WRITEACCESS) 313 #define NFSLCK_SHIFT 2 314 #define NFSLCK_READDENY 0x00000004 315 #define NFSLCK_WRITEDENY 0x00000008 316 #define NFSLCK_DENYBITS (NFSLCK_READDENY | NFSLCK_WRITEDENY) 317 #define NFSLCK_SHAREBITS \ 318 (NFSLCK_READACCESS|NFSLCK_WRITEACCESS|NFSLCK_READDENY|NFSLCK_WRITEDENY) 319 #define NFSLCK_LOCKSHIFT 4 320 #define NFSLCK_READ 0x00000010 321 #define NFSLCK_WRITE 0x00000020 322 #define NFSLCK_BLOCKING 0x00000040 323 #define NFSLCK_RECLAIM 0x00000080 324 #define NFSLCK_OPENTOLOCK 0x00000100 325 #define NFSLCK_TEST 0x00000200 326 #define NFSLCK_LOCK 0x00000400 327 #define NFSLCK_UNLOCK 0x00000800 328 #define NFSLCK_OPEN 0x00001000 329 #define NFSLCK_CLOSE 0x00002000 330 #define NFSLCK_CHECK 0x00004000 331 #define NFSLCK_RELEASE 0x00008000 332 #define NFSLCK_NEEDSCONFIRM 0x00010000 333 #define NFSLCK_CONFIRM 0x00020000 334 #define NFSLCK_DOWNGRADE 0x00040000 335 #define NFSLCK_DELEGREAD 0x00080000 336 #define NFSLCK_DELEGWRITE 0x00100000 337 #define NFSLCK_DELEGCUR 0x00200000 338 #define NFSLCK_DELEGPREV 0x00400000 339 #define NFSLCK_OLDDELEG 0x00800000 340 #define NFSLCK_DELEGRECALL 0x01000000 341 #define NFSLCK_SETATTR 0x02000000 342 #define NFSLCK_DELEGPURGE 0x04000000 343 #define NFSLCK_DELEGRETURN 0x08000000 344 #define NFSLCK_WANTWDELEG 0x10000000 345 #define NFSLCK_WANTRDELEG 0x20000000 346 #define NFSLCK_WANTNODELEG 0x40000000 347 #define NFSLCK_WANTBITS \ 348 (NFSLCK_WANTWDELEG | NFSLCK_WANTRDELEG | NFSLCK_WANTNODELEG) 349 350 /* And bits for nid_flag */ 351 #define NFSID_INITIALIZE 0x0001 352 #define NFSID_ADDUID 0x0002 353 #define NFSID_DELUID 0x0004 354 #define NFSID_ADDUSERNAME 0x0008 355 #define NFSID_DELUSERNAME 0x0010 356 #define NFSID_ADDGID 0x0020 357 #define NFSID_DELGID 0x0040 358 #define NFSID_ADDGROUPNAME 0x0080 359 #define NFSID_DELGROUPNAME 0x0100 360 361 /* 362 * fs.nfs sysctl(3) identifiers 363 */ 364 #define NFS_NFSSTATS 1 /* struct: struct nfsstats */ 365 366 /* 367 * Here is the definition of the attribute bits array and macros that 368 * manipulate it. 369 * THE MACROS MUST BE MANUALLY MODIFIED IF NFSATTRBIT_MAXWORDS CHANGES!! 370 * It is (NFSATTRBIT_MAX + 31) / 32. 371 */ 372 #define NFSATTRBIT_MAXWORDS 3 373 374 typedef struct { 375 u_int32_t bits[NFSATTRBIT_MAXWORDS]; 376 } nfsattrbit_t; 377 378 #define NFSZERO_ATTRBIT(b) do { \ 379 (b)->bits[0] = 0; \ 380 (b)->bits[1] = 0; \ 381 (b)->bits[2] = 0; \ 382 } while (0) 383 384 #define NFSSET_ATTRBIT(t, f) do { \ 385 (t)->bits[0] = (f)->bits[0]; \ 386 (t)->bits[1] = (f)->bits[1]; \ 387 (t)->bits[2] = (f)->bits[2]; \ 388 } while (0) 389 390 #define NFSSETSUPP_ATTRBIT(b) do { \ 391 (b)->bits[0] = NFSATTRBIT_SUPP0; \ 392 (b)->bits[1] = (NFSATTRBIT_SUPP1 | NFSATTRBIT_SUPPSETONLY); \ 393 (b)->bits[2] = NFSATTRBIT_SUPP2; \ 394 } while (0) 395 396 #define NFSISSET_ATTRBIT(b, p) ((b)->bits[(p) / 32] & (1 << ((p) % 32))) 397 #define NFSSETBIT_ATTRBIT(b, p) ((b)->bits[(p) / 32] |= (1 << ((p) % 32))) 398 #define NFSCLRBIT_ATTRBIT(b, p) ((b)->bits[(p) / 32] &= ~(1 << ((p) % 32))) 399 400 #define NFSCLRALL_ATTRBIT(b, a) do { \ 401 (b)->bits[0] &= ~((a)->bits[0]); \ 402 (b)->bits[1] &= ~((a)->bits[1]); \ 403 (b)->bits[2] &= ~((a)->bits[2]); \ 404 } while (0) 405 406 #define NFSCLRNOT_ATTRBIT(b, a) do { \ 407 (b)->bits[0] &= ((a)->bits[0]); \ 408 (b)->bits[1] &= ((a)->bits[1]); \ 409 (b)->bits[2] &= ((a)->bits[2]); \ 410 } while (0) 411 412 #define NFSCLRNOTFILLABLE_ATTRBIT(b) do { \ 413 (b)->bits[0] &= NFSATTRBIT_SUPP0; \ 414 (b)->bits[1] &= NFSATTRBIT_SUPP1; \ 415 (b)->bits[2] &= NFSATTRBIT_SUPP2; \ 416 } while (0) 417 418 #define NFSCLRNOTSETABLE_ATTRBIT(b) do { \ 419 (b)->bits[0] &= NFSATTRBIT_SETABLE0; \ 420 (b)->bits[1] &= NFSATTRBIT_SETABLE1; \ 421 (b)->bits[2] &= NFSATTRBIT_SETABLE2; \ 422 } while (0) 423 424 #define NFSNONZERO_ATTRBIT(b) ((b)->bits[0] || (b)->bits[1] || (b)->bits[2]) 425 #define NFSEQUAL_ATTRBIT(b, p) ((b)->bits[0] == (p)->bits[0] && \ 426 (b)->bits[1] == (p)->bits[1] && (b)->bits[2] == (p)->bits[2]) 427 428 #define NFSGETATTR_ATTRBIT(b) do { \ 429 (b)->bits[0] = NFSATTRBIT_GETATTR0; \ 430 (b)->bits[1] = NFSATTRBIT_GETATTR1; \ 431 (b)->bits[2] = NFSATTRBIT_GETATTR2; \ 432 } while (0) 433 434 #define NFSWCCATTR_ATTRBIT(b) do { \ 435 (b)->bits[0] = NFSATTRBIT_WCCATTR0; \ 436 (b)->bits[1] = NFSATTRBIT_WCCATTR1; \ 437 (b)->bits[2] = NFSATTRBIT_WCCATTR2; \ 438 } while (0) 439 440 #define NFSWRITEGETATTR_ATTRBIT(b) do { \ 441 (b)->bits[0] = NFSATTRBIT_WRITEGETATTR0; \ 442 (b)->bits[1] = NFSATTRBIT_WRITEGETATTR1; \ 443 (b)->bits[2] = NFSATTRBIT_WRITEGETATTR2; \ 444 } while (0) 445 446 #define NFSCBGETATTR_ATTRBIT(b, c) do { \ 447 (c)->bits[0] = ((b)->bits[0] & NFSATTRBIT_CBGETATTR0); \ 448 (c)->bits[1] = ((b)->bits[1] & NFSATTRBIT_CBGETATTR1); \ 449 (c)->bits[2] = ((b)->bits[2] & NFSATTRBIT_CBGETATTR2); \ 450 } while (0) 451 452 #define NFSPATHCONF_GETATTRBIT(b) do { \ 453 (b)->bits[0] = NFSGETATTRBIT_PATHCONF0; \ 454 (b)->bits[1] = NFSGETATTRBIT_PATHCONF1; \ 455 (b)->bits[2] = NFSGETATTRBIT_PATHCONF2; \ 456 } while (0) 457 458 #define NFSSTATFS_GETATTRBIT(b) do { \ 459 (b)->bits[0] = NFSGETATTRBIT_STATFS0; \ 460 (b)->bits[1] = NFSGETATTRBIT_STATFS1; \ 461 (b)->bits[2] = NFSGETATTRBIT_STATFS2; \ 462 } while (0) 463 464 #define NFSISSETSTATFS_ATTRBIT(b) \ 465 (((b)->bits[0] & NFSATTRBIT_STATFS0) || \ 466 ((b)->bits[1] & NFSATTRBIT_STATFS1) || \ 467 ((b)->bits[2] & NFSATTRBIT_STATFS2)) 468 469 #define NFSCLRSTATFS_ATTRBIT(b) do { \ 470 (b)->bits[0] &= ~NFSATTRBIT_STATFS0; \ 471 (b)->bits[1] &= ~NFSATTRBIT_STATFS1; \ 472 (b)->bits[2] &= ~NFSATTRBIT_STATFS2; \ 473 } while (0) 474 475 #define NFSREADDIRPLUS_ATTRBIT(b) do { \ 476 (b)->bits[0] = NFSATTRBIT_READDIRPLUS0; \ 477 (b)->bits[1] = NFSATTRBIT_READDIRPLUS1; \ 478 (b)->bits[2] = NFSATTRBIT_READDIRPLUS2; \ 479 } while (0) 480 481 #define NFSREFERRAL_ATTRBIT(b) do { \ 482 (b)->bits[0] = NFSATTRBIT_REFERRAL0; \ 483 (b)->bits[1] = NFSATTRBIT_REFERRAL1; \ 484 (b)->bits[2] = NFSATTRBIT_REFERRAL2; \ 485 } while (0) 486 487 /* 488 * Store uid, gid creds that were used when the stateid was acquired. 489 * The RPC layer allows NFS_MAXGRPS + 1 groups to go out on the wire, 490 * so that's how many gets stored here. 491 */ 492 struct nfscred { 493 uid_t nfsc_uid; 494 gid_t nfsc_groups[NFS_MAXGRPS + 1]; 495 int nfsc_ngroups; 496 }; 497 498 /* 499 * Constants that define the file handle for the V4 root directory. 500 * (The FSID must never be used by other file systems that are exported.) 501 */ 502 #define NFSV4ROOT_FSID0 ((int32_t) -1) 503 #define NFSV4ROOT_FSID1 ((int32_t) -1) 504 #define NFSV4ROOT_REFERRAL ((int32_t) -2) 505 #define NFSV4ROOT_INO 2 /* It's traditional */ 506 #define NFSV4ROOT_GEN 1 507 508 /* 509 * The set of signals the interrupt an I/O in progress for NFSMNT_INT mounts. 510 * What should be in this set is open to debate, but I believe that since 511 * I/O system calls on ufs are never interrupted by signals the set should 512 * be minimal. My reasoning is that many current programs that use signals 513 * such as SIGALRM will not expect file I/O system calls to be interrupted 514 * by them and break. 515 */ 516 #if defined(_KERNEL) || defined(KERNEL) 517 518 struct uio; struct buf; struct vattr; struct nameidata; /* XXX */ 519 520 /* 521 * Socket errors ignored for connectionless sockets? 522 * For now, ignore them all 523 */ 524 #define NFSIGNORE_SOERROR(s, e) \ 525 ((e) != EINTR && (e) != ERESTART && (e) != EWOULDBLOCK && \ 526 ((s) & PR_CONNREQUIRED) == 0) 527 528 529 /* 530 * This structure holds socket information for a connection. Used by the 531 * client and the server for callbacks. 532 */ 533 struct nfssockreq { 534 NFSSOCKADDR_T nr_nam; 535 int nr_sotype; 536 int nr_soproto; 537 int nr_soflags; 538 struct ucred *nr_cred; 539 int nr_lock; 540 NFSMUTEX_T nr_mtx; 541 u_int32_t nr_prog; 542 u_int32_t nr_vers; 543 struct __rpc_client *nr_client; 544 AUTH *nr_auth; 545 }; 546 547 /* 548 * And associated nr_lock bits. 549 */ 550 #define NFSR_SNDLOCK 0x01 551 #define NFSR_WANTSND 0x02 552 #define NFSR_RCVLOCK 0x04 553 #define NFSR_WANTRCV 0x08 554 #define NFSR_RESERVEDPORT 0x10 555 #define NFSR_LOCALHOST 0x20 556 557 /* 558 * Queue head for nfsreq's 559 */ 560 TAILQ_HEAD(nfsreqhead, nfsreq); 561 562 /* This is the only nfsreq R_xxx flag still used. */ 563 #define R_DONTRECOVER 0x00000100 /* don't initiate recovery when this 564 rpc gets a stale state reply */ 565 566 /* 567 * Network address hash list element 568 */ 569 union nethostaddr { 570 struct in_addr had_inet; 571 struct in6_addr had_inet6; 572 }; 573 574 /* 575 * Structure of list of mechanisms. 576 */ 577 struct nfsgss_mechlist { 578 int len; 579 const u_char *str; 580 int totlen; 581 }; 582 #define KERBV_MECH 0 /* position in list */ 583 584 /* 585 * This structure is used by the server for describing each request. 586 */ 587 struct nfsrv_descript { 588 mbuf_t nd_mrep; /* Request mbuf list */ 589 mbuf_t nd_md; /* Current dissect mbuf */ 590 mbuf_t nd_mreq; /* Reply mbuf list */ 591 mbuf_t nd_mb; /* Current build mbuf */ 592 NFSSOCKADDR_T nd_nam; /* and socket addr */ 593 NFSSOCKADDR_T nd_nam2; /* return socket addr */ 594 caddr_t nd_dpos; /* Current dissect pos */ 595 caddr_t nd_bpos; /* Current build pos */ 596 u_int16_t nd_procnum; /* RPC # */ 597 u_int32_t nd_flag; /* nd_flag */ 598 u_int32_t nd_repstat; /* Reply status */ 599 int *nd_errp; /* Pointer to ret status */ 600 u_int32_t nd_retxid; /* Reply xid */ 601 struct nfsrvcache *nd_rp; /* Assoc. cache entry */ 602 fhandle_t nd_fh; /* File handle */ 603 struct ucred *nd_cred; /* Credentials */ 604 uid_t nd_saveduid; /* Saved uid */ 605 u_int64_t nd_sockref; /* Rcv socket ref# */ 606 u_int64_t nd_compref; /* Compound RPC ref# */ 607 time_t nd_tcpconntime; /* Time TCP connection est. */ 608 nfsquad_t nd_clientid; /* Implied clientid */ 609 int nd_gssnamelen; /* principal name length */ 610 char *nd_gssname; /* principal name */ 611 uint32_t *nd_slotseq; /* ptr to slot seq# in req */ 612 uint8_t nd_sessionid[NFSX_V4SESSIONID]; /* Session id */ 613 uint32_t nd_slotid; /* Slotid for this RPC */ 614 SVCXPRT *nd_xprt; /* Server RPC handle */ 615 uint32_t *nd_sequence; /* Sequence Op. ptr */ 616 }; 617 618 #define nd_princlen nd_gssnamelen 619 #define nd_principal nd_gssname 620 621 /* Bits for "nd_flag" */ 622 #define ND_DONTSAVEREPLY 0x00000001 623 #define ND_SAVEREPLY 0x00000002 624 #define ND_NFSV2 0x00000004 625 #define ND_NFSV3 0x00000008 626 #define ND_NFSV4 0x00000010 627 #define ND_KERBV 0x00000020 628 #define ND_GSSINTEGRITY 0x00000040 629 #define ND_GSSPRIVACY 0x00000080 630 #define ND_WINDOWVERF 0x00000100 631 #define ND_GSSINITREPLY 0x00000200 632 #define ND_STREAMSOCK 0x00000400 633 #define ND_PUBLOOKUP 0x00000800 634 #define ND_USEGSSNAME 0x00001000 635 #define ND_SAMETCPCONN 0x00002000 636 #define ND_IMPLIEDCLID 0x00004000 637 #define ND_NOMOREDATA 0x00008000 638 #define ND_V4WCCATTR 0x00010000 639 #define ND_NFSCB 0x00020000 640 #define ND_AUTHNONE 0x00040000 641 #define ND_EXAUTHSYS 0x00080000 642 #define ND_EXGSS 0x00100000 643 #define ND_EXGSSINTEGRITY 0x00200000 644 #define ND_EXGSSPRIVACY 0x00400000 645 #define ND_INCRSEQID 0x00800000 646 #define ND_NFSCL 0x01000000 647 #define ND_NFSV41 0x02000000 648 #define ND_HASSEQUENCE 0x04000000 649 #define ND_CACHETHIS 0x08000000 650 #define ND_LASTOP 0x10000000 651 #define ND_LOOPBADSESS 0x20000000 652 653 /* 654 * ND_GSS should be the "or" of all GSS type authentications. 655 */ 656 #define ND_GSS (ND_KERBV) 657 658 struct nfsv4_opflag { 659 int retfh; 660 int needscfh; 661 int savereply; 662 int modifyfs; 663 int lktype; 664 int needsseq; 665 int loopbadsess; 666 }; 667 668 /* 669 * Flags used to indicate what to do w.r.t. seqid checking. 670 */ 671 #define NFSRVSEQID_FIRST 0x01 672 #define NFSRVSEQID_LAST 0x02 673 #define NFSRVSEQID_OPEN 0x04 674 675 /* 676 * assign a doubly linked list to a new head 677 * and prepend one list into another. 678 */ 679 #define LIST_NEWHEAD(nhead, ohead, field) do { \ 680 if (((nhead)->lh_first = (ohead)->lh_first) != NULL) \ 681 (ohead)->lh_first->field.le_prev = &(nhead)->lh_first; \ 682 (ohead)->lh_first = NULL; \ 683 } while (0) 684 685 #define LIST_PREPEND(head, phead, lelm, field) do { \ 686 if ((head)->lh_first != NULL) { \ 687 (lelm)->field.le_next = (head)->lh_first; \ 688 (lelm)->field.le_next->field.le_prev = \ 689 &(lelm)->field.le_next; \ 690 } \ 691 (head)->lh_first = (phead)->lh_first; \ 692 (head)->lh_first->field.le_prev = &(head)->lh_first; \ 693 } while (0) 694 695 /* 696 * File handle structure for client. Malloc'd to the correct length with 697 * malloc type M_NFSFH. 698 */ 699 struct nfsfh { 700 u_int16_t nfh_len; /* Length of file handle */ 701 u_int8_t nfh_fh[1]; /* and the file handle */ 702 }; 703 704 /* 705 * File handle structure for server. The NFSRV_MAXFH constant is 706 * set in nfsdport.h. I use a 32bit length, so that alignment is 707 * preserved. 708 */ 709 struct nfsrvfh { 710 u_int32_t nfsrvfh_len; 711 u_int8_t nfsrvfh_data[NFSRV_MAXFH]; 712 }; 713 714 /* 715 * This structure is used for sleep locks on the NFSv4 nfsd threads and 716 * NFSv4 client data structures. 717 */ 718 struct nfsv4lock { 719 u_int32_t nfslock_usecnt; 720 u_int8_t nfslock_lock; 721 }; 722 #define NFSV4LOCK_LOCK 0x01 723 #define NFSV4LOCK_LOCKWANTED 0x02 724 #define NFSV4LOCK_WANTED 0x04 725 726 /* 727 * Values for the override argument for nfsvno_accchk(). 728 */ 729 #define NFSACCCHK_NOOVERRIDE 0 730 #define NFSACCCHK_ALLOWROOT 1 731 #define NFSACCCHK_ALLOWOWNER 2 732 733 /* 734 * and values for the vpislocked argument for nfsvno_accchk(). 735 */ 736 #define NFSACCCHK_VPNOTLOCKED 0 737 #define NFSACCCHK_VPISLOCKED 1 738 739 /* 740 * Slot for the NFSv4.1 Sequence Op. 741 */ 742 struct nfsslot { 743 int nfssl_inprog; 744 uint32_t nfssl_seq; 745 struct mbuf *nfssl_reply; 746 }; 747 748 #endif /* _KERNEL */ 749 750 #endif /* _NFS_NFS_H */ 751