xref: /freebsd/sys/fs/nfs/nfsport.h (revision 6f9c8e5b074419423648ffb89b83fd2f257e90b7)
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  * 4. 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_NFSPORT_H_
36 #define	_NFS_NFSPORT_H_
37 
38 /*
39  * In general, I'm not fond of #includes in .h files, but this seems
40  * to be the cleanest way to handle #include files for the ports.
41  */
42 #ifdef _KERNEL
43 #include <sys/unistd.h>
44 #include <sys/param.h>
45 #include <sys/systm.h>
46 #include <sys/conf.h>
47 #include <sys/dirent.h>
48 #include <sys/domain.h>
49 #include <sys/fcntl.h>
50 #include <sys/file.h>
51 #include <sys/filedesc.h>
52 #include <sys/jail.h>
53 #include <sys/kernel.h>
54 #include <sys/lockf.h>
55 #include <sys/malloc.h>
56 #include <sys/mbuf.h>
57 #include <sys/mount.h>
58 #include <sys/namei.h>
59 #include <sys/proc.h>
60 #include <sys/protosw.h>
61 #include <sys/reboot.h>
62 #include <sys/resourcevar.h>
63 #include <sys/signalvar.h>
64 #include <sys/socket.h>
65 #include <sys/socketvar.h>
66 #include <sys/stat.h>
67 #include <sys/syslog.h>
68 #include <sys/sysproto.h>
69 #include <sys/time.h>
70 #include <sys/uio.h>
71 #include <sys/vnode.h>
72 #include <sys/bio.h>
73 #include <sys/buf.h>
74 #include <sys/acl.h>
75 #include <sys/module.h>
76 #include <sys/sysent.h>
77 #include <sys/syscall.h>
78 #include <sys/priv.h>
79 #include <sys/kthread.h>
80 #include <sys/syscallsubr.h>
81 #include <fs/fifofs/fifo.h>
82 #include <net/if.h>
83 #include <net/radix.h>
84 #include <net/route.h>
85 #include <net/if_dl.h>
86 #include <netinet/in.h>
87 #include <netinet/in_pcb.h>
88 #include <netinet/in_systm.h>
89 #include <netinet/in_var.h>
90 #include <netinet/ip.h>
91 #include <netinet/ip_var.h>
92 #include <netinet/tcp.h>
93 #include <netinet/tcp_fsm.h>
94 #include <netinet/tcp_seq.h>
95 #include <netinet/tcp_timer.h>
96 #include <netinet/tcp_var.h>
97 #include <machine/in_cksum.h>
98 #include <crypto/des/des.h>
99 #include <sys/md5.h>
100 #include <rpc/rpc.h>
101 #include <rpc/rpcsec_gss.h>
102 
103 /*
104  * For Darwin, these functions should be "static" when built in a kext.
105  * (This is always defined as nil otherwise.)
106  */
107 #define	APPLESTATIC
108 #include <ufs/ufs/dir.h>
109 #include <ufs/ufs/quota.h>
110 #include <ufs/ufs/inode.h>
111 #include <ufs/ufs/extattr.h>
112 #include <ufs/ufs/ufsmount.h>
113 #include <vm/uma.h>
114 #include <vm/vm.h>
115 #include <vm/vm_object.h>
116 #include <vm/vm_extern.h>
117 #include <nfs/nfssvc.h>
118 #include "opt_nfs.h"
119 #include "opt_ufs.h"
120 
121 /*
122  * These types must be defined before the nfs includes.
123  */
124 #define	NFSSOCKADDR_T	struct sockaddr *
125 #define	NFSPROC_T	struct thread
126 #define	NFSDEV_T	dev_t
127 #define	NFSSVCARGS	nfssvc_args
128 #define	NFSACL_T	struct acl
129 
130 /*
131  * These should be defined as the types used for the corresponding VOP's
132  * argument type.
133  */
134 #define	NFS_ACCESS_ARGS		struct vop_access_args
135 #define	NFS_OPEN_ARGS		struct vop_open_args
136 #define	NFS_GETATTR_ARGS	struct vop_getattr_args
137 #define	NFS_LOOKUP_ARGS		struct vop_lookup_args
138 #define	NFS_READDIR_ARGS	struct vop_readdir_args
139 
140 /*
141  * Allocate mbufs. Must succeed and never set the mbuf ptr to NULL.
142  */
143 #define	NFSMGET(m)	do { 					\
144 		MGET((m), M_TRYWAIT, MT_DATA); 			\
145 		while ((m) == NULL ) { 				\
146 			(void) nfs_catnap(PZERO, 0, "nfsmget");	\
147 			MGET((m), M_TRYWAIT, MT_DATA); 		\
148 		} 						\
149 	} while (0)
150 #define	NFSMGETHDR(m)	do { 					\
151 		MGETHDR((m), M_TRYWAIT, MT_DATA);		\
152 		while ((m) == NULL ) { 				\
153 			(void) nfs_catnap(PZERO, 0, "nfsmget");	\
154 			MGETHDR((m), M_TRYWAIT, MT_DATA); 	\
155 		} 						\
156 	} while (0)
157 #define	NFSMCLGET(m, w)	do { 					\
158 		MGET((m), M_TRYWAIT, MT_DATA); 			\
159 		while ((m) == NULL ) { 				\
160 			(void) nfs_catnap(PZERO, 0, "nfsmget");	\
161 			MGET((m), M_TRYWAIT, MT_DATA); 		\
162 		} 						\
163 		MCLGET((m), (w));				\
164 	} while (0)
165 #define	NFSMCLGETHDR(m, w) do { 				\
166 		MGETHDR((m), M_TRYWAIT, MT_DATA);		\
167 		while ((m) == NULL ) { 				\
168 			(void) nfs_catnap(PZERO, 0, "nfsmget");	\
169 			MGETHDR((m), M_TRYWAIT, MT_DATA); 	\
170 		} 						\
171 	} while (0)
172 #define	NFSMTOD	mtod
173 
174 /*
175  * Client side constant for size of a lockowner name.
176  */
177 #define	NFSV4CL_LOCKNAMELEN	12
178 
179 /*
180  * Type for a mutex lock.
181  */
182 #define	NFSMUTEX_T		struct mtx
183 
184 #endif	/* _KERNEL */
185 
186 /*
187  * NFSv4 Operation numbers.
188  */
189 #define	NFSV4OP_ACCESS		3
190 #define	NFSV4OP_CLOSE		4
191 #define	NFSV4OP_COMMIT		5
192 #define	NFSV4OP_CREATE		6
193 #define	NFSV4OP_DELEGPURGE	7
194 #define	NFSV4OP_DELEGRETURN	8
195 #define	NFSV4OP_GETATTR		9
196 #define	NFSV4OP_GETFH		10
197 #define	NFSV4OP_LINK		11
198 #define	NFSV4OP_LOCK		12
199 #define	NFSV4OP_LOCKT		13
200 #define	NFSV4OP_LOCKU		14
201 #define	NFSV4OP_LOOKUP		15
202 #define	NFSV4OP_LOOKUPP		16
203 #define	NFSV4OP_NVERIFY		17
204 #define	NFSV4OP_OPEN		18
205 #define	NFSV4OP_OPENATTR	19
206 #define	NFSV4OP_OPENCONFIRM	20
207 #define	NFSV4OP_OPENDOWNGRADE	21
208 #define	NFSV4OP_PUTFH		22
209 #define	NFSV4OP_PUTPUBFH	23
210 #define	NFSV4OP_PUTROOTFH	24
211 #define	NFSV4OP_READ		25
212 #define	NFSV4OP_READDIR		26
213 #define	NFSV4OP_READLINK	27
214 #define	NFSV4OP_REMOVE		28
215 #define	NFSV4OP_RENAME		29
216 #define	NFSV4OP_RENEW		30
217 #define	NFSV4OP_RESTOREFH	31
218 #define	NFSV4OP_SAVEFH		32
219 #define	NFSV4OP_SECINFO		33
220 #define	NFSV4OP_SETATTR		34
221 #define	NFSV4OP_SETCLIENTID	35
222 #define	NFSV4OP_SETCLIENTIDCFRM	36
223 #define	NFSV4OP_VERIFY		37
224 #define	NFSV4OP_WRITE		38
225 #define	NFSV4OP_RELEASELCKOWN	39
226 
227 /*
228  * Must be one greater than the last Operation#.
229  */
230 #define	NFSV4OP_NOPS		40
231 
232 /* Quirky case if the illegal op code */
233 #define	NFSV4OP_OPILLEGAL	10044
234 
235 /*
236  * Fake NFSV4OP_xxx used for nfsstat. Start at NFSV4OP_NOPS.
237  */
238 #define	NFSV4OP_SYMLINK		(NFSV4OP_NOPS)
239 #define	NFSV4OP_MKDIR		(NFSV4OP_NOPS + 1)
240 #define	NFSV4OP_RMDIR		(NFSV4OP_NOPS + 2)
241 #define	NFSV4OP_READDIRPLUS	(NFSV4OP_NOPS + 3)
242 #define	NFSV4OP_MKNOD		(NFSV4OP_NOPS + 4)
243 #define	NFSV4OP_FSSTAT		(NFSV4OP_NOPS + 5)
244 #define	NFSV4OP_FSINFO		(NFSV4OP_NOPS + 6)
245 #define	NFSV4OP_PATHCONF	(NFSV4OP_NOPS + 7)
246 #define	NFSV4OP_V3CREATE	(NFSV4OP_NOPS + 8)
247 
248 /*
249  * This is the count of the fake operations listed above.
250  */
251 #define	NFSV4OP_FAKENOPS	9
252 
253 /*
254  * and the Callback OPs
255  */
256 #define	NFSV4OP_CBGETATTR	3
257 #define	NFSV4OP_CBRECALL	4
258 
259 /*
260  * Must be one greater than the last Callback Operation#.
261  */
262 #define	NFSV4OP_CBNOPS		5
263 
264 /*
265  * The lower numbers -> 21 are used by NFSv2 and v3. These define higher
266  * numbers used by NFSv4.
267  * NFS_V3NPROCS is one greater than the last V3 op and NFS_NPROCS is
268  * one greater than the last number.
269  */
270 #define	NFS_V3NPROCS		22
271 
272 #define	NFSPROC_LOOKUPP		22
273 #define	NFSPROC_SETCLIENTID	23
274 #define	NFSPROC_SETCLIENTIDCFRM	24
275 #define	NFSPROC_LOCK		25
276 #define	NFSPROC_LOCKU		26
277 #define	NFSPROC_OPEN		27
278 #define	NFSPROC_CLOSE		28
279 #define	NFSPROC_OPENCONFIRM	29
280 #define	NFSPROC_LOCKT		30
281 #define	NFSPROC_OPENDOWNGRADE	31
282 #define	NFSPROC_RENEW		32
283 #define	NFSPROC_PUTROOTFH	33
284 #define	NFSPROC_RELEASELCKOWN	34
285 #define	NFSPROC_DELEGRETURN	35
286 #define	NFSPROC_RETDELEGREMOVE	36
287 #define	NFSPROC_RETDELEGRENAME1	37
288 #define	NFSPROC_RETDELEGRENAME2	38
289 #define	NFSPROC_GETACL		39
290 #define	NFSPROC_SETACL		40
291 
292 /*
293  * Must be defined as one higher than the last Proc# above.
294  */
295 #define	NFSV4_NPROCS		41
296 
297 /*
298  * Stats structure
299  */
300 struct ext_nfsstats {
301 	int	attrcache_hits;
302 	int	attrcache_misses;
303 	int	lookupcache_hits;
304 	int	lookupcache_misses;
305 	int	direofcache_hits;
306 	int	direofcache_misses;
307 	int	accesscache_hits;
308 	int	accesscache_misses;
309 	int	biocache_reads;
310 	int	read_bios;
311 	int	read_physios;
312 	int	biocache_writes;
313 	int	write_bios;
314 	int	write_physios;
315 	int	biocache_readlinks;
316 	int	readlink_bios;
317 	int	biocache_readdirs;
318 	int	readdir_bios;
319 	int	rpccnt[NFSV4_NPROCS];
320 	int	rpcretries;
321 	int	srvrpccnt[NFSV4OP_NOPS + NFSV4OP_FAKENOPS];
322 	int	srvrpc_errs;
323 	int	srv_errs;
324 	int	rpcrequests;
325 	int	rpctimeouts;
326 	int	rpcunexpected;
327 	int	rpcinvalid;
328 	int	srvcache_inproghits;
329 	int	srvcache_idemdonehits;
330 	int	srvcache_nonidemdonehits;
331 	int	srvcache_misses;
332 	int	srvcache_tcppeak;
333 	int	srvcache_size;
334 	int	srvclients;
335 	int	srvopenowners;
336 	int	srvopens;
337 	int	srvlockowners;
338 	int	srvlocks;
339 	int	srvdelegates;
340 	int	cbrpccnt[NFSV4OP_CBNOPS];
341 	int	clopenowners;
342 	int	clopens;
343 	int	cllockowners;
344 	int	cllocks;
345 	int	cldelegates;
346 	int	cllocalopenowners;
347 	int	cllocalopens;
348 	int	cllocallockowners;
349 	int	cllocallocks;
350 };
351 
352 #ifdef _KERNEL
353 /*
354  * Define the ext_nfsstats as nfsstats for the kernel code.
355  */
356 #define nfsstats	ext_nfsstats
357 
358 /*
359  * Define NFS_NPROCS as NFSV4_NPROCS for the experimental kernel code.
360  */
361 #define	NFS_NPROCS		NFSV4_NPROCS
362 
363 #include <fs/nfs/nfskpiport.h>
364 #include <fs/nfs/nfsdport.h>
365 #include <fs/nfs/rpcv2.h>
366 #include <fs/nfs/nfsproto.h>
367 #include <fs/nfs/nfs.h>
368 #include <fs/nfs/nfs_var.h>
369 #include <fs/nfs/nfsm_subs.h>
370 #include <fs/nfs/nfsrvcache.h>
371 #include <fs/nfs/nfsrvstate.h>
372 #include <fs/nfs/xdr_subs.h>
373 #include <fs/nfs/nfscl.h>
374 #include <fs/nfs/nfsclstate.h>
375 #include <nfsclient/nfsargs.h>
376 #include <fs/nfsclient/nfsmount.h>
377 
378 /*
379  * Just to keep nfs_var.h happy.
380  */
381 struct nfs_vattr {
382 	int	junk;
383 };
384 
385 struct nfsvattr {
386 	struct vattr	na_vattr;
387 	nfsattrbit_t	na_suppattr;
388 	u_int32_t	na_mntonfileno;
389 	u_int64_t	na_filesid[2];
390 };
391 
392 #define	na_type		na_vattr.va_type
393 #define	na_mode		na_vattr.va_mode
394 #define	na_nlink	na_vattr.va_nlink
395 #define	na_uid		na_vattr.va_uid
396 #define	na_gid		na_vattr.va_gid
397 #define	na_fsid		na_vattr.va_fsid
398 #define	na_fileid	na_vattr.va_fileid
399 #define	na_size		na_vattr.va_size
400 #define	na_blocksize	na_vattr.va_blocksize
401 #define	na_atime	na_vattr.va_atime
402 #define	na_mtime	na_vattr.va_mtime
403 #define	na_ctime	na_vattr.va_ctime
404 #define	na_gen		na_vattr.va_gen
405 #define	na_flags	na_vattr.va_flags
406 #define	na_rdev		na_vattr.va_rdev
407 #define	na_bytes	na_vattr.va_bytes
408 #define	na_filerev	na_vattr.va_filerev
409 #define	na_vaflags	na_vattr.va_vaflags
410 
411 #include <fs/nfsclient/nfsnode.h>
412 
413 /*
414  * This is the header structure used for the lists, etc. (It has the
415  * above record in it.
416  */
417 struct nfsrv_stablefirst {
418 	LIST_HEAD(, nfsrv_stable) nsf_head;	/* Head of nfsrv_stable list */
419 	time_t		nsf_eograce;	/* Time grace period ends */
420 	time_t		*nsf_bootvals;	/* Previous boottime values */
421 	struct file	*nsf_fp;	/* File table pointer */
422 	u_char		nsf_flags;	/* NFSNSF_ flags */
423 	struct nfsf_rec	nsf_rec;	/* and above first record */
424 };
425 #define	nsf_lease	nsf_rec.lease
426 #define	nsf_numboots	nsf_rec.numboots
427 
428 /* NFSNSF_xxx flags */
429 #define	NFSNSF_UPDATEDONE	0x01
430 #define	NFSNSF_GRACEOVER	0x02
431 #define	NFSNSF_NEEDLOCK		0x04
432 #define	NFSNSF_EXPIREDCLIENT	0x08
433 #define	NFSNSF_NOOPENS		0x10
434 #define	NFSNSF_OK		0x20
435 
436 /*
437  * Maximum number of boot times allowed in record. Although there is
438  * really no need for a fixed upper bound, this serves as a sanity check
439  * for a corrupted file.
440  */
441 #define	NFSNSF_MAXNUMBOOTS	10000
442 
443 /*
444  * This structure defines the other records in the file. The
445  * nst_client array is actually the size of the client string name.
446  */
447 struct nfst_rec {
448 	u_int16_t	len;
449 	u_char		flag;
450 	u_char		client[1];
451 };
452 /* and the values for flag */
453 #define	NFSNST_NEWSTATE	0x1
454 #define	NFSNST_REVOKE		0x2
455 #define	NFSNST_GOTSTATE		0x4
456 
457 /*
458  * This structure is linked onto nfsrv_stablefirst for the duration of
459  * reclaim.
460  */
461 struct nfsrv_stable {
462 	LIST_ENTRY(nfsrv_stable) nst_list;
463 	struct nfsclient	*nst_clp;
464 	struct nfst_rec		nst_rec;
465 };
466 #define	nst_timestamp	nst_rec.timestamp
467 #define	nst_len		nst_rec.len
468 #define	nst_flag	nst_rec.flag
469 #define	nst_client	nst_rec.client
470 
471 /*
472  * At some point the server will run out of kernel storage for
473  * state structures. For FreeBSD5.2, this results in a panic
474  * kmem_map is full. It happens at well over 1000000 opens plus
475  * locks on a PIII-800 with 256Mbytes, so that is where I've set
476  * the limit. If your server panics due to too many opens/locks,
477  * decrease the size of NFSRV_V4STATELIMIT. If you find the server
478  * returning NFS4ERR_RESOURCE a lot and have lots of memory, try
479  * increasing it.
480  */
481 #define	NFSRV_V4STATELIMIT	500000	/* Max # of Opens + Locks */
482 
483 /*
484  * The type required differs with BSDen (just the second arg).
485  */
486 void nfsrvd_rcv(struct socket *, void *, int);
487 
488 /*
489  * Macros for handling socket addresses. (Hopefully this makes the code
490  * more portable, since I've noticed some 'BSD don't have sockaddrs in
491  * mbufs any more.)
492  */
493 #define	NFSSOCKADDR(a, t)	((t)(a))
494 #define	NFSSOCKADDRALLOC(a) 					\
495     do {							\
496 	MALLOC((a), struct sockaddr *, sizeof (struct sockaddr), \
497 	    M_SONAME, M_WAITOK); 				\
498 	NFSBZERO((a), sizeof (struct sockaddr)); 		\
499     } while (0)
500 #define	NFSSOCKADDRSIZE(a, s)		((a)->sa_len = (s))
501 #define	NFSSOCKADDRFREE(a) 					\
502 	do { 							\
503 		if (a) 						\
504 			FREE((caddr_t)(a), M_SONAME); 		\
505 	} while (0)
506 
507 /*
508  * These should be defined as a process or thread structure, as required
509  * for signal handling, etc.
510  */
511 #define	NFSNEWCRED(c)		(crdup(c))
512 #define	NFSPROCCRED(p)		((p)->td_ucred)
513 #define	NFSFREECRED(c)		(crfree(c))
514 #define	NFSUIOPROC(u, p)	((u)->uio_td = NULL)
515 #define	NFSPROCP(p)		((p)->td_proc)
516 
517 /*
518  * Define these so that cn_hash and its length is ignored.
519  */
520 #define	NFSCNHASHZERO(c)
521 #define	NFSCNHASH(c, v)
522 #define	NCHNAMLEN	9999999
523 
524 /*
525  * Define these to use the time of day clock.
526  */
527 #define	NFSGETTIME(t)		(getmicrotime(t))
528 #define	NFSGETNANOTIME(t)	(getnanotime(t))
529 
530 /*
531  * These macros are defined to initialize and set the timer routine.
532  */
533 #define	NFS_TIMERINIT \
534 	newnfs_timer(NULL)
535 
536 /*
537  * Handle SMP stuff:
538  */
539 #define	NFSSTATESPINLOCK	extern struct mtx nfs_state_mutex
540 #define	NFSLOCKSTATE()		mtx_lock(&nfs_state_mutex)
541 #define	NFSUNLOCKSTATE()	mtx_unlock(&nfs_state_mutex)
542 #define	NFSSTATEMUTEXPTR	(&nfs_state_mutex)
543 #define	NFSREQSPINLOCK		extern struct mtx nfs_req_mutex
544 #define	NFSLOCKREQ()		mtx_lock(&nfs_req_mutex)
545 #define	NFSUNLOCKREQ()		mtx_unlock(&nfs_req_mutex)
546 #define	NFSCACHEMUTEX		extern struct mtx nfs_cache_mutex
547 #define	NFSCACHEMUTEXPTR	(&nfs_cache_mutex)
548 #define	NFSLOCKCACHE()		mtx_lock(&nfs_cache_mutex)
549 #define	NFSUNLOCKCACHE()	mtx_unlock(&nfs_cache_mutex)
550 #define	NFSCACHELOCKREQUIRED()	mtx_assert(&nfs_cache_mutex, MA_OWNED)
551 #define	NFSSOCKMUTEX		extern struct mtx nfs_slock_mutex
552 #define	NFSSOCKMUTEXPTR		(&nfs_slock_mutex)
553 #define	NFSLOCKSOCK()		mtx_lock(&nfs_slock_mutex)
554 #define	NFSUNLOCKSOCK()		mtx_unlock(&nfs_slock_mutex)
555 #define	NFSNAMEIDMUTEX		extern struct mtx nfs_nameid_mutex
556 #define	NFSLOCKNAMEID()		mtx_lock(&nfs_nameid_mutex)
557 #define	NFSUNLOCKNAMEID()	mtx_unlock(&nfs_nameid_mutex)
558 #define	NFSNAMEIDREQUIRED()	mtx_assert(&nfs_nameid_mutex, MA_OWNED)
559 #define	NFSCLSTATEMUTEX		extern struct mtx nfs_clstate_mutex
560 #define	NFSCLSTATEMUTEXPTR	(&nfs_clstate_mutex)
561 #define	NFSLOCKCLSTATE()	mtx_lock(&nfs_clstate_mutex)
562 #define	NFSUNLOCKCLSTATE()	mtx_unlock(&nfs_clstate_mutex)
563 #define	NFSDLOCKMUTEX		extern struct mtx newnfsd_mtx
564 #define	NFSDLOCKMUTEXPTR	(&newnfsd_mtx)
565 #define	NFSD_LOCK()		mtx_lock(&newnfsd_mtx)
566 #define	NFSD_UNLOCK()		mtx_unlock(&newnfsd_mtx)
567 #define	NFSD_LOCK_ASSERT()	mtx_assert(&newnfsd_mtx, MA_OWNED)
568 #define	NFSD_UNLOCK_ASSERT()	mtx_assert(&newnfsd_mtx, MA_NOTOWNED)
569 #define	NFSV4ROOTLOCKMUTEX	extern struct mtx nfs_v4root_mutex
570 #define	NFSV4ROOTLOCKMUTEXPTR	(&nfs_v4root_mutex)
571 #define	NFSLOCKV4ROOTMUTEX()	mtx_lock(&nfs_v4root_mutex)
572 #define	NFSUNLOCKV4ROOTMUTEX()	mtx_unlock(&nfs_v4root_mutex)
573 #define	NFSLOCKNODE(n)		mtx_lock(&((n)->n_mtx))
574 #define	NFSUNLOCKNODE(n)	mtx_unlock(&((n)->n_mtx))
575 #define	NFSLOCKMNT(m)		mtx_lock(&((m)->nm_mtx))
576 #define	NFSUNLOCKMNT(m)		mtx_unlock(&((m)->nm_mtx))
577 #define	NFSLOCKREQUEST(r)	mtx_lock(&((r)->r_mtx))
578 #define	NFSUNLOCKREQUEST(r)	mtx_unlock(&((r)->r_mtx))
579 #define	NFSPROCLISTLOCK()	sx_slock(&allproc_lock)
580 #define	NFSPROCLISTUNLOCK()	sx_sunlock(&allproc_lock)
581 #define	NFSLOCKSOCKREQ(r)	mtx_lock(&((r)->nr_mtx))
582 #define	NFSUNLOCKSOCKREQ(r)	mtx_unlock(&((r)->nr_mtx))
583 
584 /*
585  * Use these macros to initialize/free a mutex.
586  */
587 #define	NFSINITSOCKMUTEX(m)	mtx_init((m), "nfssock", NULL, MTX_DEF)
588 #define	NFSFREEMUTEX(m)		mtx_destroy((m))
589 
590 int nfsmsleep(void *, void *, int, const char *, struct timespec *);
591 
592 /*
593  * And weird vm stuff in the nfs server.
594  */
595 #define	PDIRUNLOCK	0x0
596 #define	MAX_COMMIT_COUNT	(1024 * 1024)
597 
598 /*
599  * Define these to handle the type of va_rdev.
600  */
601 #define	NFSMAKEDEV(m, n)	makedev((m), (n))
602 #define	NFSMAJOR(d)		major(d)
603 #define	NFSMINOR(d)		minor(d)
604 
605 /*
606  * Define this to be the macro that returns the minimum size required
607  * for a directory entry.
608  */
609 #define	DIRENT_SIZE(dp)		GENERIC_DIRSIZ(dp)
610 
611 /*
612  * The vnode tag for nfsv4root.
613  */
614 #define	VT_NFSV4ROOT		"nfsv4root"
615 
616 /*
617  * Define whatever it takes to do a vn_rdwr().
618  */
619 #define	NFSD_RDWR(r, v, b, l, o, s, i, c, a, p) \
620 	vn_rdwr((r), (v), (b), (l), (o), (s), (i), (c), NULL, (a), (p))
621 
622 /*
623  * Macros for handling memory for different BSDen.
624  * NFSBCOPY(src, dst, len) - copies len bytes, non-overlapping
625  * NFSOVBCOPY(src, dst, len) - ditto, but data areas might overlap
626  * NFSBCMP(cp1, cp2, len) - compare len bytes, return 0 if same
627  * NFSBZERO(cp, len) - set len bytes to 0x0
628  */
629 #define	NFSBCOPY(s, d, l)	bcopy((s), (d), (l))
630 #define	NFSOVBCOPY(s, d, l)	ovbcopy((s), (d), (l))
631 #define	NFSBCMP(s, d, l)	bcmp((s), (d), (l))
632 #define	NFSBZERO(s, l)		bzero((s), (l))
633 
634 /*
635  * Some queue.h files don't have these dfined in them.
636  */
637 #define	LIST_END(head)		NULL
638 #define	SLIST_END(head)		NULL
639 #define	TAILQ_END(head)		NULL
640 
641 /*
642  * This must be defined to be a global variable that increments once
643  * per second, but never stops or goes backwards, even when a "date"
644  * command changes the TOD clock. It is used for delta times for
645  * leases, etc.
646  */
647 #define	NFSD_MONOSEC		time_uptime
648 
649 /*
650  * Declare the malloc types.
651  */
652 MALLOC_DECLARE(M_NEWNFSRVCACHE);
653 MALLOC_DECLARE(M_NEWNFSDCLIENT);
654 MALLOC_DECLARE(M_NEWNFSDSTATE);
655 MALLOC_DECLARE(M_NEWNFSDLOCK);
656 MALLOC_DECLARE(M_NEWNFSDLOCKFILE);
657 MALLOC_DECLARE(M_NEWNFSSTRING);
658 MALLOC_DECLARE(M_NEWNFSUSERGROUP);
659 MALLOC_DECLARE(M_NEWNFSDREQ);
660 MALLOC_DECLARE(M_NEWNFSFH);
661 MALLOC_DECLARE(M_NEWNFSCLOWNER);
662 MALLOC_DECLARE(M_NEWNFSCLOPEN);
663 MALLOC_DECLARE(M_NEWNFSCLDELEG);
664 MALLOC_DECLARE(M_NEWNFSCLCLIENT);
665 MALLOC_DECLARE(M_NEWNFSCLLOCKOWNER);
666 MALLOC_DECLARE(M_NEWNFSCLLOCK);
667 MALLOC_DECLARE(M_NEWNFSDIROFF);
668 MALLOC_DECLARE(M_NEWNFSV4NODE);
669 MALLOC_DECLARE(M_NEWNFSDIRECTIO);
670 MALLOC_DECLARE(M_NEWNFSMNT);
671 MALLOC_DECLARE(M_NEWNFSDROLLBACK);
672 #define	M_NFSRVCACHE	M_NEWNFSRVCACHE
673 #define	M_NFSDCLIENT	M_NEWNFSDCLIENT
674 #define	M_NFSDSTATE	M_NEWNFSDSTATE
675 #define	M_NFSDLOCK	M_NEWNFSDLOCK
676 #define	M_NFSDLOCKFILE	M_NEWNFSDLOCKFILE
677 #define	M_NFSSTRING	M_NEWNFSSTRING
678 #define	M_NFSUSERGROUP	M_NEWNFSUSERGROUP
679 #define	M_NFSDREQ	M_NEWNFSDREQ
680 #define	M_NFSFH		M_NEWNFSFH
681 #define	M_NFSCLOWNER	M_NEWNFSCLOWNER
682 #define	M_NFSCLOPEN	M_NEWNFSCLOPEN
683 #define	M_NFSCLDELEG	M_NEWNFSCLDELEG
684 #define	M_NFSCLCLIENT	M_NEWNFSCLCLIENT
685 #define	M_NFSCLLOCKOWNER M_NEWNFSCLLOCKOWNER
686 #define	M_NFSCLLOCK	M_NEWNFSCLLOCK
687 #define	M_NFSDIROFF	M_NEWNFSDIROFF
688 #define	M_NFSV4NODE	M_NEWNFSV4NODE
689 #define	M_NFSDIRECTIO	M_NEWNFSDIRECTIO
690 #define	M_NFSDROLLBACK	M_NEWNFSDROLLBACK
691 
692 #define	NFSINT_SIGMASK(set) 						\
693 	(SIGISMEMBER(set, SIGINT) || SIGISMEMBER(set, SIGTERM) ||	\
694 	 SIGISMEMBER(set, SIGHUP) || SIGISMEMBER(set, SIGKILL) ||	\
695 	 SIGISMEMBER(set, SIGQUIT))
696 
697 /*
698  * Convert a quota block count to byte count.
699  */
700 #define	NFSQUOTABLKTOBYTE(q, b)	(q) *= (b)
701 
702 /*
703  * Define this as the largest file size supported. (It should probably
704  * be available via a VFS_xxx Op, but it isn't.
705  */
706 #define	NFSRV_MAXFILESIZE	((u_int64_t)0x800000000000)
707 
708 /*
709  * Set this macro to index() or strchr(), whichever is supported.
710  */
711 #define	STRCHR(s, c)	index((s), (c))
712 
713 /*
714  * Set the n_time in the client write rpc, as required.
715  */
716 #define	NFSWRITERPC_SETTIME(w, n, v4)					\
717 	do {								\
718 		if (w) {						\
719 			(n)->n_mtime = (n)->n_vattr.na_vattr.va_mtime; \
720 			if (v4)						\
721 			    (n)->n_change = (n)->n_vattr.na_vattr.va_filerev; \
722 		}							\
723 	} while (0)
724 
725 /*
726  * Fake value, just to make the client work.
727  */
728 #define	NFS_LATTR_NOSHRINK	1
729 
730 /*
731  * Prototypes for functions where the arguments vary for different ports.
732  */
733 int nfscl_loadattrcache(struct vnode **, struct nfsvattr *, void *, void *,
734     int, int);
735 void newnfs_realign(struct mbuf **);
736 
737 /*
738  * If the port runs on an SMP box that can enforce Atomic ops with low
739  * overheads, define these as atomic increments/decrements. If not,
740  * don't worry about it, since these are used for stats that can be
741  * "out by one" without disastrous consequences.
742  */
743 #define	NFSINCRGLOBAL(a)	((a)++)
744 
745 /*
746  * Assorted funky stuff to make things work under Darwin8.
747  */
748 /*
749  * These macros checks for a field in vattr being set.
750  */
751 #define	NFSATTRISSET(t, v, a)	((v)->a != (t)VNOVAL)
752 #define	NFSATTRISSETTIME(v, a)	((v)->a.tv_sec != VNOVAL)
753 
754 /*
755  * Manipulate mount flags.
756  */
757 #define	NFSSTA_HASWRITEVERF	0x00040000  /* Has write verifier */
758 #define	NFSSTA_GOTFSINFO	0x00100000  /* Got the fsinfo */
759 #define	NFSSTA_TIMEO		0x10000000  /* Experiencing a timeout */
760 #define	NFSSTA_LOCKTIMEO	0x20000000  /* Experiencing a lockd timeout */
761 #define	NFSSTA_HASSETFSID	0x40000000  /* Has set the fsid */
762 
763 #define	NFSHASNFSV3(n)		((n)->nm_flag & NFSMNT_NFSV3)
764 #define	NFSHASNFSV4(n)		((n)->nm_flag & NFSMNT_NFSV4)
765 #define	NFSHASNFSV3OR4(n)	((n)->nm_flag & (NFSMNT_NFSV3 | NFSMNT_NFSV4))
766 #define	NFSHASGOTFSINFO(n)	((n)->nm_state & NFSSTA_GOTFSINFO)
767 #define	NFSHASHASSETFSID(n)	((n)->nm_state & NFSSTA_HASSETFSID)
768 #define	NFSHASSTRICT3530(n)	((n)->nm_flag & NFSMNT_STRICT3530)
769 #define	NFSHASWRITEVERF(n)	((n)->nm_state & NFSSTA_HASWRITEVERF)
770 #define	NFSHASINT(n)		((n)->nm_flag & NFSMNT_INT)
771 #define	NFSHASSOFT(n)		((n)->nm_flag & NFSMNT_SOFT)
772 #define	NFSHASINTORSOFT(n)	((n)->nm_flag & (NFSMNT_INT | NFSMNT_SOFT))
773 #define	NFSHASDUMBTIMR(n)	((n)->nm_flag & NFSMNT_DUMBTIMR)
774 #define	NFSHASNOCONN(n)		((n)->nm_flag & NFSMNT_MNTD)
775 #define	NFSHASKERB(n)		((n)->nm_flag & NFSMNT_KERB)
776 #define	NFSHASALLGSSNAME(n)	((n)->nm_flag & NFSMNT_ALLGSSNAME)
777 #define	NFSHASINTEGRITY(n)	((n)->nm_flag & NFSMNT_INTEGRITY)
778 #define	NFSHASPRIVACY(n)	((n)->nm_flag & NFSMNT_PRIVACY)
779 #define	NFSSETWRITEVERF(n)	((n)->nm_state |= NFSSTA_HASWRITEVERF)
780 #define	NFSSETHASSETFSID(n)	((n)->nm_state |= NFSSTA_HASSETFSID)
781 
782 /*
783  * Gets the stats field out of the mount structure.
784  */
785 #define	vfs_statfs(m)	(&((m)->mnt_stat))
786 
787 /*
788  * Set boottime.
789  */
790 #define	NFSSETBOOTTIME(b)	((b) = boottime)
791 
792 /*
793  * The size of directory blocks in the buffer cache.
794  * MUST BE in the range of PAGE_SIZE <= NFS_DIRBLKSIZ <= MAXBSIZE!!
795  */
796 #define	NFS_DIRBLKSIZ	(16 * DIRBLKSIZ) /* Must be a multiple of DIRBLKSIZ */
797 
798 /*
799  * Define these macros to access mnt_flag fields.
800  */
801 #define	NFSMNT_RDONLY(m)	((m)->mnt_flag & MNT_RDONLY)
802 #endif	/* _KERNEL */
803 
804 /*
805  * Define a structure similar to ufs_args for use in exporting the V4 root.
806  */
807 struct nfsex_args {
808 	char	*fspec;
809 	struct export_args	export;
810 };
811 
812 /*
813  * These export flags should be defined, but there are no bits left.
814  * Maybe a separate mnt_exflag field could be added or the mnt_flag
815  * field increased to 64 bits?
816  */
817 #ifndef	MNT_EXSTRICTACCESS
818 #define	MNT_EXSTRICTACCESS	0x0
819 #endif
820 #ifndef MNT_EXV4ONLY
821 #define	MNT_EXV4ONLY		0x0
822 #endif
823 
824 #ifdef _KERNEL
825 /*
826  * Define this to invalidate the attribute cache for the nfs node.
827  */
828 #define	NFSINVALATTRCACHE(n)	((n)->n_attrstamp = 0)
829 
830 /* Used for FreeBSD only */
831 void nfsd_mntinit(void);
832 
833 /*
834  * Define these for vnode lock/unlock ops.
835  */
836 #define	NFSVOPLOCK(v, f, p)	vn_lock((v), (f))
837 #define	NFSVOPUNLOCK(v, f, p)	VOP_UNLOCK((v), (f))
838 #define	NFSVOPISLOCKED(v, p)	VOP_ISLOCKED((v))
839 
840 /*
841  * Define ncl_hash().
842  */
843 #define	ncl_hash(f, l)	(fnv_32_buf((f), (l), FNV1_32_INIT))
844 
845 int newnfs_iosize(struct nfsmount *);
846 
847 #ifdef NFS_DEBUG
848 
849 extern int nfs_debug;
850 #define	NFS_DEBUG_ASYNCIO	1 /* asynchronous i/o */
851 #define	NFS_DEBUG_WG		2 /* server write gathering */
852 #define	NFS_DEBUG_RC		4 /* server request caching */
853 
854 #define	NFS_DPF(cat, args)					\
855 	do {							\
856 		if (nfs_debug & NFS_DEBUG_##cat) printf args;	\
857 	} while (0)
858 
859 #else
860 
861 #define	NFS_DPF(cat, args)
862 
863 #endif
864 
865 int newnfs_vncmpf(struct vnode *, void *);
866 
867 #ifndef NFS_MINDIRATTRTIMO
868 #define	NFS_MINDIRATTRTIMO 3		/* VDIR attrib cache timeout in sec */
869 #endif
870 #ifndef NFS_MAXDIRATTRTIMO
871 #define	NFS_MAXDIRATTRTIMO 60
872 #endif
873 
874 /*
875  * Nfs outstanding request list element
876  */
877 struct nfsreq {
878 	TAILQ_ENTRY(nfsreq) r_chain;
879 	u_int32_t	r_flags;	/* flags on request, see below */
880 	struct nfsmount *r_nmp;		/* Client mnt ptr */
881 	struct mtx	r_mtx;		/* Mutex lock for this structure */
882 };
883 
884 #ifndef NFS_MAXBSIZE
885 #define	NFS_MAXBSIZE	MAXBSIZE
886 #endif
887 
888 /*
889  * This macro checks to see if issuing of delegations is allowed for this
890  * vnode.
891  */
892 #ifdef VV_DISABLEDELEG
893 #define	NFSVNO_DELEGOK(v)						\
894 	((v) == NULL || ((v)->v_vflag & VV_DISABLEDELEG) == 0)
895 #else
896 #define	NFSVNO_DELEGOK(v)	(1)
897 #endif
898 
899 /*
900  * Define this as the flags argument for msleep() when catching signals
901  * while holding a resource that other threads would block for, such as
902  * a vnode lock.
903  */
904 #define	NFS_PCATCH	(PCATCH | PBDRY)
905 
906 #endif	/* _KERNEL */
907 
908 #endif	/* _NFS_NFSPORT_H */
909