2 * Copyright (c) 1989, 1993, 1995
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
6 * Rick Macklem at The University of Guelph.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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.
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
32 * from nfs_vfsops.c 8.12 (Berkeley) 5/20/95
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD$");
39 #include "opt_bootp.h"
40 #include "opt_nfsroot.h"
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
47 #include <sys/clock.h>
49 #include <sys/limits.h>
51 #include <sys/malloc.h>
53 #include <sys/module.h>
54 #include <sys/mount.h>
56 #include <sys/socket.h>
57 #include <sys/socketvar.h>
58 #include <sys/sockio.h>
59 #include <sys/sysctl.h>
60 #include <sys/vnode.h>
61 #include <sys/signalvar.h>
64 #include <vm/vm_extern.h>
68 #include <net/route.h>
69 #include <netinet/in.h>
71 #include <fs/nfs/nfsport.h>
72 #include <fs/nfsclient/nfsnode.h>
73 #include <fs/nfsclient/nfsmount.h>
74 #include <fs/nfsclient/nfs.h>
75 #include <nfs/nfsdiskless.h>
77 FEATURE(nfscl, "NFSv4 client");
79 extern int nfscl_ticks;
80 extern struct timeval nfsboottime;
81 extern int nfsrv_useacl;
82 extern int nfscl_debuglevel;
83 extern enum nfsiod_state ncl_iodwant[NFS_MAXASYNCDAEMON];
84 extern struct nfsmount *ncl_iodmount[NFS_MAXASYNCDAEMON];
85 extern struct mtx ncl_iod_mutex;
88 MALLOC_DEFINE(M_NEWNFSREQ, "newnfsclient_req", "NFS request header");
89 MALLOC_DEFINE(M_NEWNFSMNT, "newnfsmnt", "NFS mount struct");
91 SYSCTL_DECL(_vfs_nfs);
92 static int nfs_ip_paranoia = 1;
93 SYSCTL_INT(_vfs_nfs, OID_AUTO, nfs_ip_paranoia, CTLFLAG_RW,
94 &nfs_ip_paranoia, 0, "");
95 static int nfs_tprintf_initial_delay = NFS_TPRINTF_INITIAL_DELAY;
96 SYSCTL_INT(_vfs_nfs, NFS_TPRINTF_INITIAL_DELAY,
97 downdelayinitial, CTLFLAG_RW, &nfs_tprintf_initial_delay, 0, "");
98 /* how long between console messages "nfs server foo not responding" */
99 static int nfs_tprintf_delay = NFS_TPRINTF_DELAY;
100 SYSCTL_INT(_vfs_nfs, NFS_TPRINTF_DELAY,
101 downdelayinterval, CTLFLAG_RW, &nfs_tprintf_delay, 0, "");
104 SYSCTL_INT(_vfs_nfs, OID_AUTO, debug, CTLFLAG_RW, &nfs_debug, 0,
105 "Toggle debug flag");
108 static int nfs_mountroot(struct mount *);
109 static void nfs_sec_name(char *, int *);
110 static void nfs_decode_args(struct mount *mp, struct nfsmount *nmp,
111 struct nfs_args *argp, const char *, struct ucred *,
113 static int mountnfs(struct nfs_args *, struct mount *,
114 struct sockaddr *, char *, u_char *, int, u_char *, int,
115 u_char *, int, struct vnode **, struct ucred *,
116 struct thread *, int, int, int);
117 static void nfs_getnlminfo(struct vnode *, uint8_t *, size_t *,
118 struct sockaddr_storage *, int *, off_t *,
120 static vfs_mount_t nfs_mount;
121 static vfs_cmount_t nfs_cmount;
122 static vfs_unmount_t nfs_unmount;
123 static vfs_root_t nfs_root;
124 static vfs_statfs_t nfs_statfs;
125 static vfs_sync_t nfs_sync;
126 static vfs_sysctl_t nfs_sysctl;
127 static vfs_purge_t nfs_purge;
130 * nfs vfs operations.
132 static struct vfsops nfs_vfsops = {
133 .vfs_init = ncl_init,
134 .vfs_mount = nfs_mount,
135 .vfs_cmount = nfs_cmount,
136 .vfs_root = nfs_root,
137 .vfs_statfs = nfs_statfs,
138 .vfs_sync = nfs_sync,
139 .vfs_uninit = ncl_uninit,
140 .vfs_unmount = nfs_unmount,
141 .vfs_sysctl = nfs_sysctl,
142 .vfs_purge = nfs_purge,
144 VFS_SET(nfs_vfsops, nfs, VFCF_NETWORK | VFCF_SBDRY);
146 /* So that loader and kldload(2) can find us, wherever we are.. */
147 MODULE_VERSION(nfs, 1);
148 MODULE_DEPEND(nfs, nfscommon, 1, 1, 1);
149 MODULE_DEPEND(nfs, krpc, 1, 1, 1);
150 MODULE_DEPEND(nfs, nfssvc, 1, 1, 1);
151 MODULE_DEPEND(nfs, nfslock, 1, 1, 1);
154 * This structure is now defined in sys/nfs/nfs_diskless.c so that it
155 * can be shared by both NFS clients. It is declared here so that it
156 * will be defined for kernels built without NFS_ROOT, although it
157 * isn't used in that case.
159 #if !defined(NFS_ROOT)
160 struct nfs_diskless nfs_diskless = { { { 0 } } };
161 struct nfsv3_diskless nfsv3_diskless = { { { 0 } } };
162 int nfs_diskless_valid = 0;
165 SYSCTL_INT(_vfs_nfs, OID_AUTO, diskless_valid, CTLFLAG_RD,
166 &nfs_diskless_valid, 0,
167 "Has the diskless struct been filled correctly");
169 SYSCTL_STRING(_vfs_nfs, OID_AUTO, diskless_rootpath, CTLFLAG_RD,
170 nfsv3_diskless.root_hostnam, 0, "Path to nfs root");
172 SYSCTL_OPAQUE(_vfs_nfs, OID_AUTO, diskless_rootaddr, CTLFLAG_RD,
173 &nfsv3_diskless.root_saddr, sizeof(nfsv3_diskless.root_saddr),
174 "%Ssockaddr_in", "Diskless root nfs address");
177 void newnfsargs_ntoh(struct nfs_args *);
178 static int nfs_mountdiskless(char *,
179 struct sockaddr_in *, struct nfs_args *,
180 struct thread *, struct vnode **, struct mount *);
181 static void nfs_convert_diskless(void);
182 static void nfs_convert_oargs(struct nfs_args *args,
183 struct onfs_args *oargs);
186 newnfs_iosize(struct nfsmount *nmp)
190 /* First, set the upper limit for iosize */
191 if (nmp->nm_flag & NFSMNT_NFSV4) {
192 maxio = NFS_MAXBSIZE;
193 } else if (nmp->nm_flag & NFSMNT_NFSV3) {
194 if (nmp->nm_sotype == SOCK_DGRAM)
195 maxio = NFS_MAXDGRAMDATA;
197 maxio = NFS_MAXBSIZE;
199 maxio = NFS_V2MAXDATA;
201 if (nmp->nm_rsize > maxio || nmp->nm_rsize == 0)
202 nmp->nm_rsize = maxio;
203 if (nmp->nm_rsize > NFS_MAXBSIZE)
204 nmp->nm_rsize = NFS_MAXBSIZE;
205 if (nmp->nm_readdirsize > maxio || nmp->nm_readdirsize == 0)
206 nmp->nm_readdirsize = maxio;
207 if (nmp->nm_readdirsize > nmp->nm_rsize)
208 nmp->nm_readdirsize = nmp->nm_rsize;
209 if (nmp->nm_wsize > maxio || nmp->nm_wsize == 0)
210 nmp->nm_wsize = maxio;
211 if (nmp->nm_wsize > NFS_MAXBSIZE)
212 nmp->nm_wsize = NFS_MAXBSIZE;
215 * Calculate the size used for io buffers. Use the larger
216 * of the two sizes to minimise nfs requests but make sure
217 * that it is at least one VM page to avoid wasting buffer
218 * space. It must also be at least NFS_DIRBLKSIZ, since
219 * that is the buffer size used for directories.
221 iosize = imax(nmp->nm_rsize, nmp->nm_wsize);
222 iosize = imax(iosize, PAGE_SIZE);
223 iosize = imax(iosize, NFS_DIRBLKSIZ);
224 nmp->nm_mountp->mnt_stat.f_iosize = iosize;
229 nfs_convert_oargs(struct nfs_args *args, struct onfs_args *oargs)
232 args->version = NFS_ARGSVERSION;
233 args->addr = oargs->addr;
234 args->addrlen = oargs->addrlen;
235 args->sotype = oargs->sotype;
236 args->proto = oargs->proto;
237 args->fh = oargs->fh;
238 args->fhsize = oargs->fhsize;
239 args->flags = oargs->flags;
240 args->wsize = oargs->wsize;
241 args->rsize = oargs->rsize;
242 args->readdirsize = oargs->readdirsize;
243 args->timeo = oargs->timeo;
244 args->retrans = oargs->retrans;
245 args->readahead = oargs->readahead;
246 args->hostname = oargs->hostname;
250 nfs_convert_diskless(void)
253 bcopy(&nfs_diskless.myif, &nfsv3_diskless.myif,
254 sizeof(struct ifaliasreq));
255 bcopy(&nfs_diskless.mygateway, &nfsv3_diskless.mygateway,
256 sizeof(struct sockaddr_in));
257 nfs_convert_oargs(&nfsv3_diskless.root_args,&nfs_diskless.root_args);
258 if (nfsv3_diskless.root_args.flags & NFSMNT_NFSV3) {
259 nfsv3_diskless.root_fhsize = NFSX_MYFH;
260 bcopy(nfs_diskless.root_fh, nfsv3_diskless.root_fh, NFSX_MYFH);
262 nfsv3_diskless.root_fhsize = NFSX_V2FH;
263 bcopy(nfs_diskless.root_fh, nfsv3_diskless.root_fh, NFSX_V2FH);
265 bcopy(&nfs_diskless.root_saddr,&nfsv3_diskless.root_saddr,
266 sizeof(struct sockaddr_in));
267 bcopy(nfs_diskless.root_hostnam, nfsv3_diskless.root_hostnam, MNAMELEN);
268 nfsv3_diskless.root_time = nfs_diskless.root_time;
269 bcopy(nfs_diskless.my_hostnam, nfsv3_diskless.my_hostnam,
271 nfs_diskless_valid = 3;
278 nfs_statfs(struct mount *mp, struct statfs *sbp)
282 struct nfsmount *nmp = VFSTONFS(mp);
283 struct nfsvattr nfsva;
286 int error = 0, attrflag, gotfsinfo = 0, ret;
291 error = vfs_busy(mp, MBF_NOWAIT);
294 error = ncl_nget(mp, nmp->nm_fh, nmp->nm_fhsize, &np, LK_EXCLUSIVE);
300 mtx_lock(&nmp->nm_mtx);
301 if (NFSHASNFSV3(nmp) && !NFSHASGOTFSINFO(nmp)) {
302 mtx_unlock(&nmp->nm_mtx);
303 error = nfsrpc_fsinfo(vp, &fs, td->td_ucred, td, &nfsva,
308 mtx_unlock(&nmp->nm_mtx);
310 error = nfsrpc_statfs(vp, &sb, &fs, td->td_ucred, td, &nfsva,
313 NFSCL_DEBUG(2, "statfs=%d\n", error);
315 ret = nfsrpc_getattrnovp(nmp, nmp->nm_fh, nmp->nm_fhsize, 1,
316 td->td_ucred, td, &nfsva, NULL, NULL);
319 * Just set default values to get things going.
321 NFSBZERO((caddr_t)&nfsva, sizeof (struct nfsvattr));
322 nfsva.na_vattr.va_type = VDIR;
323 nfsva.na_vattr.va_mode = 0777;
324 nfsva.na_vattr.va_nlink = 100;
325 nfsva.na_vattr.va_uid = (uid_t)0;
326 nfsva.na_vattr.va_gid = (gid_t)0;
327 nfsva.na_vattr.va_fileid = 2;
328 nfsva.na_vattr.va_gen = 1;
329 nfsva.na_vattr.va_blocksize = NFS_FABLKSIZE;
330 nfsva.na_vattr.va_size = 512 * 1024;
333 (void) nfscl_loadattrcache(&vp, &nfsva, NULL, NULL, 0, 1);
335 mtx_lock(&nmp->nm_mtx);
336 if (gotfsinfo || (nmp->nm_flag & NFSMNT_NFSV4))
337 nfscl_loadfsinfo(nmp, &fs);
338 nfscl_loadsbinfo(nmp, &sb, sbp);
339 sbp->f_iosize = newnfs_iosize(nmp);
340 mtx_unlock(&nmp->nm_mtx);
341 if (sbp != &mp->mnt_stat) {
342 bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
343 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
345 strncpy(&sbp->f_fstypename[0], mp->mnt_vfc->vfc_name, MFSNAMELEN);
346 } else if (NFS_ISV4(vp)) {
347 error = nfscl_maperr(td, error, (uid_t)0, (gid_t)0);
355 * nfs version 3 fsinfo rpc call
358 ncl_fsinfo(struct nfsmount *nmp, struct vnode *vp, struct ucred *cred,
362 struct nfsvattr nfsva;
365 error = nfsrpc_fsinfo(vp, &fs, cred, td, &nfsva, &attrflag, NULL);
368 (void) nfscl_loadattrcache(&vp, &nfsva, NULL, NULL, 0,
370 mtx_lock(&nmp->nm_mtx);
371 nfscl_loadfsinfo(nmp, &fs);
372 mtx_unlock(&nmp->nm_mtx);
378 * Mount a remote root fs via. nfs. This depends on the info in the
379 * nfs_diskless structure that has been filled in properly by some primary
381 * It goes something like this:
382 * - do enough of "ifconfig" by calling ifioctl() so that the system
383 * can talk to the server
384 * - If nfs_diskless.mygateway is filled in, use that address as
386 * - build the rootfs mount point and call mountnfs() to do the rest.
388 * It is assumed to be safe to read, modify, and write the nfsv3_diskless
389 * structure, as well as other global NFS client variables here, as
390 * nfs_mountroot() will be called once in the boot before any other NFS
391 * client activity occurs.
394 nfs_mountroot(struct mount *mp)
396 struct thread *td = curthread;
397 struct nfsv3_diskless *nd = &nfsv3_diskless;
406 #if defined(BOOTP_NFSROOT) && defined(BOOTP)
407 bootpc_init(); /* use bootp to get nfs_diskless filled in */
408 #elif defined(NFS_ROOT)
409 nfs_setup_diskless();
412 if (nfs_diskless_valid == 0)
414 if (nfs_diskless_valid == 1)
415 nfs_convert_diskless();
418 * Do enough of ifconfig(8) so that the critical net interface can
419 * talk to the server.
421 error = socreate(nd->myif.ifra_addr.sa_family, &so, nd->root_args.sotype, 0,
424 panic("nfs_mountroot: socreate(%04x): %d",
425 nd->myif.ifra_addr.sa_family, error);
427 #if 0 /* XXX Bad idea */
429 * We might not have been told the right interface, so we pass
430 * over the first ten interfaces of the same kind, until we get
431 * one of them configured.
434 for (i = strlen(nd->myif.ifra_name) - 1;
435 nd->myif.ifra_name[i] >= '0' &&
436 nd->myif.ifra_name[i] <= '9';
437 nd->myif.ifra_name[i] ++) {
438 error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);
443 error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);
445 panic("nfs_mountroot: SIOCAIFADDR: %d", error);
446 if ((cp = kern_getenv("boot.netif.mtu")) != NULL) {
447 ir.ifr_mtu = strtol(cp, NULL, 10);
448 bcopy(nd->myif.ifra_name, ir.ifr_name, IFNAMSIZ);
450 error = ifioctl(so, SIOCSIFMTU, (caddr_t)&ir, td);
452 printf("nfs_mountroot: SIOCSIFMTU: %d", error);
457 * If the gateway field is filled in, set it as the default route.
458 * Note that pxeboot will set a default route of 0 if the route
459 * is not set by the DHCP server. Check also for a value of 0
460 * to avoid panicking inappropriately in that situation.
462 if (nd->mygateway.sin_len != 0 &&
463 nd->mygateway.sin_addr.s_addr != 0) {
464 struct sockaddr_in mask, sin;
466 bzero((caddr_t)&mask, sizeof(mask));
468 sin.sin_family = AF_INET;
469 sin.sin_len = sizeof(sin);
470 /* XXX MRT use table 0 for this sort of thing */
471 CURVNET_SET(TD_TO_VNET(td));
472 error = rtrequest_fib(RTM_ADD, (struct sockaddr *)&sin,
473 (struct sockaddr *)&nd->mygateway,
474 (struct sockaddr *)&mask,
475 RTF_UP | RTF_GATEWAY, NULL, RT_DEFAULT_FIB);
478 panic("nfs_mountroot: RTM_ADD: %d", error);
482 * Create the rootfs mount point.
484 nd->root_args.fh = nd->root_fh;
485 nd->root_args.fhsize = nd->root_fhsize;
486 l = ntohl(nd->root_saddr.sin_addr.s_addr);
487 snprintf(buf, sizeof(buf), "%ld.%ld.%ld.%ld:%s",
488 (l >> 24) & 0xff, (l >> 16) & 0xff,
489 (l >> 8) & 0xff, (l >> 0) & 0xff, nd->root_hostnam);
490 printf("NFS ROOT: %s\n", buf);
491 nd->root_args.hostname = buf;
492 if ((error = nfs_mountdiskless(buf,
493 &nd->root_saddr, &nd->root_args, td, &vp, mp)) != 0) {
498 * This is not really an nfs issue, but it is much easier to
499 * set hostname here and then let the "/etc/rc.xxx" files
500 * mount the right /var based upon its preset value.
502 mtx_lock(&prison0.pr_mtx);
503 strlcpy(prison0.pr_hostname, nd->my_hostnam,
504 sizeof(prison0.pr_hostname));
505 mtx_unlock(&prison0.pr_mtx);
506 inittodr(ntohl(nd->root_time));
511 * Internal version of mount system call for diskless setup.
514 nfs_mountdiskless(char *path,
515 struct sockaddr_in *sin, struct nfs_args *args, struct thread *td,
516 struct vnode **vpp, struct mount *mp)
518 struct sockaddr *nam;
523 * Find the directory path in "path", which also has the server's
524 * name/ip address in it.
526 dirpath = strchr(path, ':');
528 dirlen = strlen(++dirpath);
531 nam = sodupsockaddr((struct sockaddr *)sin, M_WAITOK);
532 if ((error = mountnfs(args, mp, nam, path, NULL, 0, dirpath, dirlen,
533 NULL, 0, vpp, td->td_ucred, td, NFS_DEFAULT_NAMETIMEO,
534 NFS_DEFAULT_NEGNAMETIMEO, 0)) != 0) {
535 printf("nfs_mountroot: mount %s on /: %d\n", path, error);
542 nfs_sec_name(char *sec, int *flagsp)
544 if (!strcmp(sec, "krb5"))
545 *flagsp |= NFSMNT_KERB;
546 else if (!strcmp(sec, "krb5i"))
547 *flagsp |= (NFSMNT_KERB | NFSMNT_INTEGRITY);
548 else if (!strcmp(sec, "krb5p"))
549 *flagsp |= (NFSMNT_KERB | NFSMNT_PRIVACY);
553 nfs_decode_args(struct mount *mp, struct nfsmount *nmp, struct nfs_args *argp,
554 const char *hostname, struct ucred *cred, struct thread *td)
560 * Set read-only flag if requested; otherwise, clear it if this is
561 * an update. If this is not an update, then either the read-only
562 * flag is already clear, or this is a root mount and it was set
563 * intentionally at some previous point.
565 if (vfs_getopt(mp->mnt_optnew, "ro", NULL, NULL) == 0) {
567 mp->mnt_flag |= MNT_RDONLY;
569 } else if (mp->mnt_flag & MNT_UPDATE) {
571 mp->mnt_flag &= ~MNT_RDONLY;
576 * Silently clear NFSMNT_NOCONN if it's a TCP mount, it makes
577 * no sense in that context. Also, set up appropriate retransmit
578 * and soft timeout behavior.
580 if (argp->sotype == SOCK_STREAM) {
581 nmp->nm_flag &= ~NFSMNT_NOCONN;
582 nmp->nm_timeo = NFS_MAXTIMEO;
583 if ((argp->flags & NFSMNT_NFSV4) != 0)
584 nmp->nm_retry = INT_MAX;
586 nmp->nm_retry = NFS_RETRANS_TCP;
589 /* Also clear RDIRPLUS if NFSv2, it crashes some servers */
590 if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0) {
591 argp->flags &= ~NFSMNT_RDIRPLUS;
592 nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
595 /* Clear ONEOPENOWN for NFSv2, 3 and 4.0. */
596 if (nmp->nm_minorvers == 0) {
597 argp->flags &= ~NFSMNT_ONEOPENOWN;
598 nmp->nm_flag &= ~NFSMNT_ONEOPENOWN;
601 /* Re-bind if rsrvd port requested and wasn't on one */
602 adjsock = !(nmp->nm_flag & NFSMNT_RESVPORT)
603 && (argp->flags & NFSMNT_RESVPORT);
604 /* Also re-bind if we're switching to/from a connected UDP socket */
605 adjsock |= ((nmp->nm_flag & NFSMNT_NOCONN) !=
606 (argp->flags & NFSMNT_NOCONN));
608 /* Update flags atomically. Don't change the lock bits. */
609 nmp->nm_flag = argp->flags | nmp->nm_flag;
611 if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) {
612 nmp->nm_timeo = (argp->timeo * NFS_HZ + 5) / 10;
613 if (nmp->nm_timeo < NFS_MINTIMEO)
614 nmp->nm_timeo = NFS_MINTIMEO;
615 else if (nmp->nm_timeo > NFS_MAXTIMEO)
616 nmp->nm_timeo = NFS_MAXTIMEO;
619 if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) {
620 nmp->nm_retry = argp->retrans;
621 if (nmp->nm_retry > NFS_MAXREXMIT)
622 nmp->nm_retry = NFS_MAXREXMIT;
625 if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) {
626 nmp->nm_wsize = argp->wsize;
628 * Clip at the power of 2 below the size. There is an
629 * issue (not isolated) that causes intermittent page
630 * faults if this is not done.
632 if (nmp->nm_wsize > NFS_FABLKSIZE)
633 nmp->nm_wsize = 1 << (fls(nmp->nm_wsize) - 1);
635 nmp->nm_wsize = NFS_FABLKSIZE;
638 if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) {
639 nmp->nm_rsize = argp->rsize;
641 * Clip at the power of 2 below the size. There is an
642 * issue (not isolated) that causes intermittent page
643 * faults if this is not done.
645 if (nmp->nm_rsize > NFS_FABLKSIZE)
646 nmp->nm_rsize = 1 << (fls(nmp->nm_rsize) - 1);
648 nmp->nm_rsize = NFS_FABLKSIZE;
651 if ((argp->flags & NFSMNT_READDIRSIZE) && argp->readdirsize > 0) {
652 nmp->nm_readdirsize = argp->readdirsize;
655 if ((argp->flags & NFSMNT_ACREGMIN) && argp->acregmin >= 0)
656 nmp->nm_acregmin = argp->acregmin;
658 nmp->nm_acregmin = NFS_MINATTRTIMO;
659 if ((argp->flags & NFSMNT_ACREGMAX) && argp->acregmax >= 0)
660 nmp->nm_acregmax = argp->acregmax;
662 nmp->nm_acregmax = NFS_MAXATTRTIMO;
663 if ((argp->flags & NFSMNT_ACDIRMIN) && argp->acdirmin >= 0)
664 nmp->nm_acdirmin = argp->acdirmin;
666 nmp->nm_acdirmin = NFS_MINDIRATTRTIMO;
667 if ((argp->flags & NFSMNT_ACDIRMAX) && argp->acdirmax >= 0)
668 nmp->nm_acdirmax = argp->acdirmax;
670 nmp->nm_acdirmax = NFS_MAXDIRATTRTIMO;
671 if (nmp->nm_acdirmin > nmp->nm_acdirmax)
672 nmp->nm_acdirmin = nmp->nm_acdirmax;
673 if (nmp->nm_acregmin > nmp->nm_acregmax)
674 nmp->nm_acregmin = nmp->nm_acregmax;
676 if ((argp->flags & NFSMNT_READAHEAD) && argp->readahead >= 0) {
677 if (argp->readahead <= NFS_MAXRAHEAD)
678 nmp->nm_readahead = argp->readahead;
680 nmp->nm_readahead = NFS_MAXRAHEAD;
682 if ((argp->flags & NFSMNT_WCOMMITSIZE) && argp->wcommitsize >= 0) {
683 if (argp->wcommitsize < nmp->nm_wsize)
684 nmp->nm_wcommitsize = nmp->nm_wsize;
686 nmp->nm_wcommitsize = argp->wcommitsize;
689 adjsock |= ((nmp->nm_sotype != argp->sotype) ||
690 (nmp->nm_soproto != argp->proto));
692 if (nmp->nm_client != NULL && adjsock) {
693 int haslock = 0, error = 0;
695 if (nmp->nm_sotype == SOCK_STREAM) {
696 error = newnfs_sndlock(&nmp->nm_sockreq.nr_lock);
701 newnfs_disconnect(&nmp->nm_sockreq);
703 newnfs_sndunlock(&nmp->nm_sockreq.nr_lock);
704 nmp->nm_sotype = argp->sotype;
705 nmp->nm_soproto = argp->proto;
706 if (nmp->nm_sotype == SOCK_DGRAM)
707 while (newnfs_connect(nmp, &nmp->nm_sockreq,
709 printf("newnfs_args: retrying connect\n");
710 (void) nfs_catnap(PSOCK, 0, "nfscon");
714 nmp->nm_sotype = argp->sotype;
715 nmp->nm_soproto = argp->proto;
718 if (hostname != NULL) {
719 strlcpy(nmp->nm_hostname, hostname,
720 sizeof(nmp->nm_hostname));
721 p = strchr(nmp->nm_hostname, ':');
727 static const char *nfs_opts[] = { "from", "nfs_args",
728 "noac", "noatime", "noexec", "suiddir", "nosuid", "nosymfollow", "union",
729 "noclusterr", "noclusterw", "multilabel", "acls", "force", "update",
730 "async", "noconn", "nolockd", "conn", "lockd", "intr", "rdirplus",
731 "readdirsize", "soft", "hard", "mntudp", "tcp", "udp", "wsize", "rsize",
732 "retrans", "actimeo", "acregmin", "acregmax", "acdirmin", "acdirmax",
733 "resvport", "readahead", "hostname", "timeo", "timeout", "addr", "fh",
734 "nfsv3", "sec", "principal", "nfsv4", "gssname", "allgssname", "dirpath",
735 "minorversion", "nametimeo", "negnametimeo", "nocto", "noncontigwr",
736 "pnfs", "wcommitsize", "oneopenown",
740 * Parse the "from" mountarg, passed by the generic mount(8) program
741 * or the mountroot code. This is used when rerooting into NFS.
743 * Note that the "hostname" is actually a "hostname:/share/path" string.
746 nfs_mount_parse_from(struct vfsoptlist *opts, char **hostnamep,
747 struct sockaddr_in **sinp, char *dirpath, size_t dirpathsize, int *dirlenp)
749 char *nam, *delimp, *hostp, *spec;
750 int error, have_bracket = 0, offset, rv, speclen;
751 struct sockaddr_in *sin;
754 error = vfs_getopt(opts, "from", (void **)&spec, &speclen);
757 nam = malloc(MNAMELEN + 1, M_TEMP, M_WAITOK);
760 * This part comes from sbin/mount_nfs/mount_nfs.c:getnfsargs().
762 if (*spec == '[' && (delimp = strchr(spec + 1, ']')) != NULL &&
763 *(delimp + 1) == ':') {
767 } else if ((delimp = strrchr(spec, ':')) != NULL) {
770 } else if ((delimp = strrchr(spec, '@')) != NULL) {
771 printf("%s: path@server syntax is deprecated, "
772 "use server:path\n", __func__);
775 printf("%s: no <host>:<dirpath> nfs-name\n", __func__);
782 * If there has been a trailing slash at mounttime it seems
783 * that some mountd implementations fail to remove the mount
784 * entries from their mountlist while unmounting.
786 for (speclen = strlen(spec);
787 speclen > 1 && spec[speclen - 1] == '/';
789 spec[speclen - 1] = '\0';
790 if (strlen(hostp) + strlen(spec) + 1 > MNAMELEN) {
791 printf("%s: %s:%s: name too long", __func__, hostp, spec);
795 /* Make both '@' and ':' notations equal */
796 if (*hostp != '\0') {
801 memmove(nam + offset, hostp, len);
803 nam[len + offset++] = ']';
804 nam[len + offset++] = ':';
805 memmove(nam + len + offset, spec, speclen);
806 nam[len + speclen + offset] = '\0';
813 sin = malloc(sizeof(*sin), M_SONAME, M_WAITOK);
814 rv = inet_pton(AF_INET, hostp, &sin->sin_addr);
816 printf("%s: cannot parse '%s', inet_pton() returned %d\n",
817 __func__, hostp, rv);
823 sin->sin_len = sizeof(*sin);
824 sin->sin_family = AF_INET;
826 * XXX: hardcoded port number.
828 sin->sin_port = htons(2049);
830 *hostnamep = strdup(nam, M_NEWNFSMNT);
832 strlcpy(dirpath, spec, dirpathsize);
833 *dirlenp = strlen(dirpath);
843 * It seems a bit dumb to copyinstr() the host and path here and then
844 * bcopy() them in mountnfs(), but I wanted to detect errors before
845 * doing the getsockaddr() call because getsockaddr() allocates an mbuf and
846 * an error after that means that I have to release the mbuf.
850 nfs_mount(struct mount *mp)
852 struct nfs_args args = {
853 .version = NFS_ARGSVERSION,
855 .addrlen = sizeof (struct sockaddr_in),
856 .sotype = SOCK_STREAM,
860 .flags = NFSMNT_RESVPORT,
863 .readdirsize = NFS_READDIRSIZE,
865 .retrans = NFS_RETRANS,
866 .readahead = NFS_DEFRAHEAD,
867 .wcommitsize = 0, /* was: NQ_DEFLEASE */
869 .acregmin = NFS_MINATTRTIMO,
870 .acregmax = NFS_MAXATTRTIMO,
871 .acdirmin = NFS_MINDIRATTRTIMO,
872 .acdirmax = NFS_MAXDIRATTRTIMO,
874 int error = 0, ret, len;
875 struct sockaddr *nam = NULL;
879 u_char nfh[NFSX_FHMAX], krbname[100], dirpath[100], srvkrbname[100];
880 char *cp, *opt, *name, *secname;
881 int nametimeo = NFS_DEFAULT_NAMETIMEO;
882 int negnametimeo = NFS_DEFAULT_NEGNAMETIMEO;
884 int dirlen, has_nfs_args_opt, has_nfs_from_opt,
885 krbnamelen, srvkrbnamelen;
888 has_nfs_args_opt = 0;
889 has_nfs_from_opt = 0;
890 hst = malloc(MNAMELEN, M_TEMP, M_WAITOK);
891 if (vfs_filteropt(mp->mnt_optnew, nfs_opts)) {
897 if ((mp->mnt_flag & (MNT_ROOTFS | MNT_UPDATE)) == MNT_ROOTFS &&
898 nfs_diskless_valid != 0) {
899 error = nfs_mountroot(mp);
906 * The old mount_nfs program passed the struct nfs_args
907 * from userspace to kernel. The new mount_nfs program
908 * passes string options via nmount() from userspace to kernel
909 * and we populate the struct nfs_args in the kernel.
911 if (vfs_getopt(mp->mnt_optnew, "nfs_args", NULL, NULL) == 0) {
912 error = vfs_copyopt(mp->mnt_optnew, "nfs_args", &args,
917 if (args.version != NFS_ARGSVERSION) {
918 error = EPROGMISMATCH;
921 has_nfs_args_opt = 1;
924 /* Handle the new style options. */
925 if (vfs_getopt(mp->mnt_optnew, "noac", NULL, NULL) == 0) {
926 args.acdirmin = args.acdirmax =
927 args.acregmin = args.acregmax = 0;
928 args.flags |= NFSMNT_ACDIRMIN | NFSMNT_ACDIRMAX |
929 NFSMNT_ACREGMIN | NFSMNT_ACREGMAX;
931 if (vfs_getopt(mp->mnt_optnew, "noconn", NULL, NULL) == 0)
932 args.flags |= NFSMNT_NOCONN;
933 if (vfs_getopt(mp->mnt_optnew, "conn", NULL, NULL) == 0)
934 args.flags &= ~NFSMNT_NOCONN;
935 if (vfs_getopt(mp->mnt_optnew, "nolockd", NULL, NULL) == 0)
936 args.flags |= NFSMNT_NOLOCKD;
937 if (vfs_getopt(mp->mnt_optnew, "lockd", NULL, NULL) == 0)
938 args.flags &= ~NFSMNT_NOLOCKD;
939 if (vfs_getopt(mp->mnt_optnew, "intr", NULL, NULL) == 0)
940 args.flags |= NFSMNT_INT;
941 if (vfs_getopt(mp->mnt_optnew, "rdirplus", NULL, NULL) == 0)
942 args.flags |= NFSMNT_RDIRPLUS;
943 if (vfs_getopt(mp->mnt_optnew, "resvport", NULL, NULL) == 0)
944 args.flags |= NFSMNT_RESVPORT;
945 if (vfs_getopt(mp->mnt_optnew, "noresvport", NULL, NULL) == 0)
946 args.flags &= ~NFSMNT_RESVPORT;
947 if (vfs_getopt(mp->mnt_optnew, "soft", NULL, NULL) == 0)
948 args.flags |= NFSMNT_SOFT;
949 if (vfs_getopt(mp->mnt_optnew, "hard", NULL, NULL) == 0)
950 args.flags &= ~NFSMNT_SOFT;
951 if (vfs_getopt(mp->mnt_optnew, "mntudp", NULL, NULL) == 0)
952 args.sotype = SOCK_DGRAM;
953 if (vfs_getopt(mp->mnt_optnew, "udp", NULL, NULL) == 0)
954 args.sotype = SOCK_DGRAM;
955 if (vfs_getopt(mp->mnt_optnew, "tcp", NULL, NULL) == 0)
956 args.sotype = SOCK_STREAM;
957 if (vfs_getopt(mp->mnt_optnew, "nfsv3", NULL, NULL) == 0)
958 args.flags |= NFSMNT_NFSV3;
959 if (vfs_getopt(mp->mnt_optnew, "nfsv4", NULL, NULL) == 0) {
960 args.flags |= NFSMNT_NFSV4;
961 args.sotype = SOCK_STREAM;
963 if (vfs_getopt(mp->mnt_optnew, "allgssname", NULL, NULL) == 0)
964 args.flags |= NFSMNT_ALLGSSNAME;
965 if (vfs_getopt(mp->mnt_optnew, "nocto", NULL, NULL) == 0)
966 args.flags |= NFSMNT_NOCTO;
967 if (vfs_getopt(mp->mnt_optnew, "noncontigwr", NULL, NULL) == 0)
968 args.flags |= NFSMNT_NONCONTIGWR;
969 if (vfs_getopt(mp->mnt_optnew, "pnfs", NULL, NULL) == 0)
970 args.flags |= NFSMNT_PNFS;
971 if (vfs_getopt(mp->mnt_optnew, "oneopenown", NULL, NULL) == 0)
972 args.flags |= NFSMNT_ONEOPENOWN;
973 if (vfs_getopt(mp->mnt_optnew, "readdirsize", (void **)&opt, NULL) == 0) {
975 vfs_mount_error(mp, "illegal readdirsize");
979 ret = sscanf(opt, "%d", &args.readdirsize);
980 if (ret != 1 || args.readdirsize <= 0) {
981 vfs_mount_error(mp, "illegal readdirsize: %s",
986 args.flags |= NFSMNT_READDIRSIZE;
988 if (vfs_getopt(mp->mnt_optnew, "readahead", (void **)&opt, NULL) == 0) {
990 vfs_mount_error(mp, "illegal readahead");
994 ret = sscanf(opt, "%d", &args.readahead);
995 if (ret != 1 || args.readahead <= 0) {
996 vfs_mount_error(mp, "illegal readahead: %s",
1001 args.flags |= NFSMNT_READAHEAD;
1003 if (vfs_getopt(mp->mnt_optnew, "wsize", (void **)&opt, NULL) == 0) {
1005 vfs_mount_error(mp, "illegal wsize");
1009 ret = sscanf(opt, "%d", &args.wsize);
1010 if (ret != 1 || args.wsize <= 0) {
1011 vfs_mount_error(mp, "illegal wsize: %s",
1016 args.flags |= NFSMNT_WSIZE;
1018 if (vfs_getopt(mp->mnt_optnew, "rsize", (void **)&opt, NULL) == 0) {
1020 vfs_mount_error(mp, "illegal rsize");
1024 ret = sscanf(opt, "%d", &args.rsize);
1025 if (ret != 1 || args.rsize <= 0) {
1026 vfs_mount_error(mp, "illegal wsize: %s",
1031 args.flags |= NFSMNT_RSIZE;
1033 if (vfs_getopt(mp->mnt_optnew, "retrans", (void **)&opt, NULL) == 0) {
1035 vfs_mount_error(mp, "illegal retrans");
1039 ret = sscanf(opt, "%d", &args.retrans);
1040 if (ret != 1 || args.retrans <= 0) {
1041 vfs_mount_error(mp, "illegal retrans: %s",
1046 args.flags |= NFSMNT_RETRANS;
1048 if (vfs_getopt(mp->mnt_optnew, "actimeo", (void **)&opt, NULL) == 0) {
1049 ret = sscanf(opt, "%d", &args.acregmin);
1050 if (ret != 1 || args.acregmin < 0) {
1051 vfs_mount_error(mp, "illegal actimeo: %s",
1056 args.acdirmin = args.acdirmax = args.acregmax = args.acregmin;
1057 args.flags |= NFSMNT_ACDIRMIN | NFSMNT_ACDIRMAX |
1058 NFSMNT_ACREGMIN | NFSMNT_ACREGMAX;
1060 if (vfs_getopt(mp->mnt_optnew, "acregmin", (void **)&opt, NULL) == 0) {
1061 ret = sscanf(opt, "%d", &args.acregmin);
1062 if (ret != 1 || args.acregmin < 0) {
1063 vfs_mount_error(mp, "illegal acregmin: %s",
1068 args.flags |= NFSMNT_ACREGMIN;
1070 if (vfs_getopt(mp->mnt_optnew, "acregmax", (void **)&opt, NULL) == 0) {
1071 ret = sscanf(opt, "%d", &args.acregmax);
1072 if (ret != 1 || args.acregmax < 0) {
1073 vfs_mount_error(mp, "illegal acregmax: %s",
1078 args.flags |= NFSMNT_ACREGMAX;
1080 if (vfs_getopt(mp->mnt_optnew, "acdirmin", (void **)&opt, NULL) == 0) {
1081 ret = sscanf(opt, "%d", &args.acdirmin);
1082 if (ret != 1 || args.acdirmin < 0) {
1083 vfs_mount_error(mp, "illegal acdirmin: %s",
1088 args.flags |= NFSMNT_ACDIRMIN;
1090 if (vfs_getopt(mp->mnt_optnew, "acdirmax", (void **)&opt, NULL) == 0) {
1091 ret = sscanf(opt, "%d", &args.acdirmax);
1092 if (ret != 1 || args.acdirmax < 0) {
1093 vfs_mount_error(mp, "illegal acdirmax: %s",
1098 args.flags |= NFSMNT_ACDIRMAX;
1100 if (vfs_getopt(mp->mnt_optnew, "wcommitsize", (void **)&opt, NULL) == 0) {
1101 ret = sscanf(opt, "%d", &args.wcommitsize);
1102 if (ret != 1 || args.wcommitsize < 0) {
1103 vfs_mount_error(mp, "illegal wcommitsize: %s", opt);
1107 args.flags |= NFSMNT_WCOMMITSIZE;
1109 if (vfs_getopt(mp->mnt_optnew, "timeo", (void **)&opt, NULL) == 0) {
1110 ret = sscanf(opt, "%d", &args.timeo);
1111 if (ret != 1 || args.timeo <= 0) {
1112 vfs_mount_error(mp, "illegal timeo: %s",
1117 args.flags |= NFSMNT_TIMEO;
1119 if (vfs_getopt(mp->mnt_optnew, "timeout", (void **)&opt, NULL) == 0) {
1120 ret = sscanf(opt, "%d", &args.timeo);
1121 if (ret != 1 || args.timeo <= 0) {
1122 vfs_mount_error(mp, "illegal timeout: %s",
1127 args.flags |= NFSMNT_TIMEO;
1129 if (vfs_getopt(mp->mnt_optnew, "nametimeo", (void **)&opt, NULL) == 0) {
1130 ret = sscanf(opt, "%d", &nametimeo);
1131 if (ret != 1 || nametimeo < 0) {
1132 vfs_mount_error(mp, "illegal nametimeo: %s", opt);
1137 if (vfs_getopt(mp->mnt_optnew, "negnametimeo", (void **)&opt, NULL)
1139 ret = sscanf(opt, "%d", &negnametimeo);
1140 if (ret != 1 || negnametimeo < 0) {
1141 vfs_mount_error(mp, "illegal negnametimeo: %s",
1147 if (vfs_getopt(mp->mnt_optnew, "minorversion", (void **)&opt, NULL) ==
1149 ret = sscanf(opt, "%d", &minvers);
1150 if (ret != 1 || minvers < 0 || minvers > 1 ||
1151 (args.flags & NFSMNT_NFSV4) == 0) {
1152 vfs_mount_error(mp, "illegal minorversion: %s", opt);
1157 if (vfs_getopt(mp->mnt_optnew, "sec",
1158 (void **) &secname, NULL) == 0)
1159 nfs_sec_name(secname, &args.flags);
1161 if (mp->mnt_flag & MNT_UPDATE) {
1162 struct nfsmount *nmp = VFSTONFS(mp);
1170 * If a change from TCP->UDP is done and there are thread(s)
1171 * that have I/O RPC(s) in progress with a transfer size
1172 * greater than NFS_MAXDGRAMDATA, those thread(s) will be
1173 * hung, retrying the RPC(s) forever. Usually these threads
1174 * will be seen doing an uninterruptible sleep on wait channel
1177 if (args.sotype == SOCK_DGRAM && nmp->nm_sotype == SOCK_STREAM)
1178 tprintf(td->td_proc, LOG_WARNING,
1179 "Warning: mount -u that changes TCP->UDP can result in hung threads\n");
1182 * When doing an update, we can't change version,
1183 * security, switch lockd strategies, change cookie
1184 * translation or switch oneopenown.
1186 args.flags = (args.flags &
1193 NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/)) |
1201 NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/));
1202 nfs_decode_args(mp, nmp, &args, NULL, td->td_ucred, td);
1207 * Make the nfs_ip_paranoia sysctl serve as the default connection
1208 * or no-connection mode for those protocols that support
1209 * no-connection mode (the flag will be cleared later for protocols
1210 * that do not support no-connection mode). This will allow a client
1211 * to receive replies from a different IP then the request was
1212 * sent to. Note: default value for nfs_ip_paranoia is 1 (paranoid),
1215 if (nfs_ip_paranoia == 0)
1216 args.flags |= NFSMNT_NOCONN;
1218 if (has_nfs_args_opt != 0) {
1220 * In the 'nfs_args' case, the pointers in the args
1221 * structure are in userland - we copy them in here.
1223 if (args.fhsize < 0 || args.fhsize > NFSX_V3FHMAX) {
1224 vfs_mount_error(mp, "Bad file handle");
1228 error = copyin((caddr_t)args.fh, (caddr_t)nfh,
1232 error = copyinstr(args.hostname, hst, MNAMELEN - 1, &hstlen);
1235 bzero(&hst[hstlen], MNAMELEN - hstlen);
1236 args.hostname = hst;
1237 /* getsockaddr() call must be after above copyin() calls */
1238 error = getsockaddr(&nam, (caddr_t)args.addr,
1242 } else if (nfs_mount_parse_from(mp->mnt_optnew,
1243 &args.hostname, (struct sockaddr_in **)&nam, dirpath,
1244 sizeof(dirpath), &dirlen) == 0) {
1245 has_nfs_from_opt = 1;
1246 bcopy(args.hostname, hst, MNAMELEN);
1247 hst[MNAMELEN - 1] = '\0';
1250 * This only works with NFSv4 for now.
1253 args.flags |= NFSMNT_NFSV4;
1254 args.sotype = SOCK_STREAM;
1256 if (vfs_getopt(mp->mnt_optnew, "fh", (void **)&args.fh,
1257 &args.fhsize) == 0) {
1258 if (args.fhsize < 0 || args.fhsize > NFSX_FHMAX) {
1259 vfs_mount_error(mp, "Bad file handle");
1263 bcopy(args.fh, nfh, args.fhsize);
1267 (void) vfs_getopt(mp->mnt_optnew, "hostname",
1268 (void **)&args.hostname, &len);
1269 if (args.hostname == NULL) {
1270 vfs_mount_error(mp, "Invalid hostname");
1274 if (len >= MNAMELEN) {
1275 vfs_mount_error(mp, "Hostname too long");
1279 bcopy(args.hostname, hst, len);
1283 if (vfs_getopt(mp->mnt_optnew, "principal", (void **)&name, NULL) == 0)
1284 strlcpy(srvkrbname, name, sizeof (srvkrbname));
1286 snprintf(srvkrbname, sizeof (srvkrbname), "nfs@%s", hst);
1287 cp = strchr(srvkrbname, ':');
1291 srvkrbnamelen = strlen(srvkrbname);
1293 if (vfs_getopt(mp->mnt_optnew, "gssname", (void **)&name, NULL) == 0)
1294 strlcpy(krbname, name, sizeof (krbname));
1297 krbnamelen = strlen(krbname);
1299 if (has_nfs_from_opt == 0) {
1300 if (vfs_getopt(mp->mnt_optnew,
1301 "dirpath", (void **)&name, NULL) == 0)
1302 strlcpy(dirpath, name, sizeof (dirpath));
1305 dirlen = strlen(dirpath);
1308 if (has_nfs_args_opt == 0 && has_nfs_from_opt == 0) {
1309 if (vfs_getopt(mp->mnt_optnew, "addr",
1310 (void **)&args.addr, &args.addrlen) == 0) {
1311 if (args.addrlen > SOCK_MAXADDRLEN) {
1312 error = ENAMETOOLONG;
1315 nam = malloc(args.addrlen, M_SONAME, M_WAITOK);
1316 bcopy(args.addr, nam, args.addrlen);
1317 nam->sa_len = args.addrlen;
1319 vfs_mount_error(mp, "No server address");
1326 error = mountnfs(&args, mp, nam, hst, krbname, krbnamelen, dirpath,
1327 dirlen, srvkrbname, srvkrbnamelen, &vp, td->td_ucred, td,
1328 nametimeo, negnametimeo, minvers);
1332 mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED | MNTK_NO_IOPF |
1334 if ((VFSTONFS(mp)->nm_flag & NFSMNT_NFSV4) != 0)
1335 mp->mnt_kern_flag |= MNTK_NULL_NOCACHE;
1347 * It seems a bit dumb to copyinstr() the host and path here and then
1348 * bcopy() them in mountnfs(), but I wanted to detect errors before
1349 * doing the getsockaddr() call because getsockaddr() allocates an mbuf and
1350 * an error after that means that I have to release the mbuf.
1354 nfs_cmount(struct mntarg *ma, void *data, uint64_t flags)
1357 struct nfs_args args;
1359 error = copyin(data, &args, sizeof (struct nfs_args));
1363 ma = mount_arg(ma, "nfs_args", &args, sizeof args);
1365 error = kernel_mount(ma, flags);
1370 * Common code for mount and mountroot
1373 mountnfs(struct nfs_args *argp, struct mount *mp, struct sockaddr *nam,
1374 char *hst, u_char *krbname, int krbnamelen, u_char *dirpath, int dirlen,
1375 u_char *srvkrbname, int srvkrbnamelen, struct vnode **vpp,
1376 struct ucred *cred, struct thread *td, int nametimeo, int negnametimeo,
1379 struct nfsmount *nmp;
1381 int error, trycnt, ret;
1382 struct nfsvattr nfsva;
1383 struct nfsclclient *clp;
1384 struct nfsclds *dsp, *tdsp;
1386 static u_int64_t clval = 0;
1388 NFSCL_DEBUG(3, "in mnt\n");
1390 if (mp->mnt_flag & MNT_UPDATE) {
1392 printf("%s: MNT_UPDATE is no longer handled here\n", __func__);
1393 FREE(nam, M_SONAME);
1396 MALLOC(nmp, struct nfsmount *, sizeof (struct nfsmount) +
1397 krbnamelen + dirlen + srvkrbnamelen + 2,
1398 M_NEWNFSMNT, M_WAITOK | M_ZERO);
1399 TAILQ_INIT(&nmp->nm_bufq);
1400 TAILQ_INIT(&nmp->nm_sess);
1402 clval = (u_int64_t)nfsboottime.tv_sec;
1403 nmp->nm_clval = clval++;
1404 nmp->nm_krbnamelen = krbnamelen;
1405 nmp->nm_dirpathlen = dirlen;
1406 nmp->nm_srvkrbnamelen = srvkrbnamelen;
1407 if (td->td_ucred->cr_uid != (uid_t)0) {
1409 * nm_uid is used to get KerberosV credentials for
1410 * the nfsv4 state handling operations if there is
1411 * no host based principal set. Use the uid of
1412 * this user if not root, since they are doing the
1413 * mount. I don't think setting this for root will
1414 * work, since root normally does not have user
1415 * credentials in a credentials cache.
1417 nmp->nm_uid = td->td_ucred->cr_uid;
1420 * Just set to -1, so it won't be used.
1422 nmp->nm_uid = (uid_t)-1;
1425 /* Copy and null terminate all the names */
1426 if (nmp->nm_krbnamelen > 0) {
1427 bcopy(krbname, nmp->nm_krbname, nmp->nm_krbnamelen);
1428 nmp->nm_name[nmp->nm_krbnamelen] = '\0';
1430 if (nmp->nm_dirpathlen > 0) {
1431 bcopy(dirpath, NFSMNT_DIRPATH(nmp),
1432 nmp->nm_dirpathlen);
1433 nmp->nm_name[nmp->nm_krbnamelen + nmp->nm_dirpathlen
1436 if (nmp->nm_srvkrbnamelen > 0) {
1437 bcopy(srvkrbname, NFSMNT_SRVKRBNAME(nmp),
1438 nmp->nm_srvkrbnamelen);
1439 nmp->nm_name[nmp->nm_krbnamelen + nmp->nm_dirpathlen
1440 + nmp->nm_srvkrbnamelen + 2] = '\0';
1442 nmp->nm_sockreq.nr_cred = crhold(cred);
1443 mtx_init(&nmp->nm_sockreq.nr_mtx, "nfssock", NULL, MTX_DEF);
1445 nmp->nm_getinfo = nfs_getnlminfo;
1446 nmp->nm_vinvalbuf = ncl_vinvalbuf;
1449 nmp->nm_mountp = mp;
1450 mtx_init(&nmp->nm_mtx, "NFSmount lock", NULL, MTX_DEF | MTX_DUPOK);
1453 * Since nfs_decode_args() might optionally set them, these
1454 * need to be set to defaults before the call, so that the
1455 * optional settings aren't overwritten.
1457 nmp->nm_nametimeo = nametimeo;
1458 nmp->nm_negnametimeo = negnametimeo;
1459 nmp->nm_timeo = NFS_TIMEO;
1460 nmp->nm_retry = NFS_RETRANS;
1461 nmp->nm_readahead = NFS_DEFRAHEAD;
1463 /* This is empirical approximation of sqrt(hibufspace) * 256. */
1464 nmp->nm_wcommitsize = NFS_MAXBSIZE / 256;
1465 while ((long)nmp->nm_wcommitsize * nmp->nm_wcommitsize < hibufspace)
1466 nmp->nm_wcommitsize *= 2;
1467 nmp->nm_wcommitsize *= 256;
1469 if ((argp->flags & NFSMNT_NFSV4) != 0)
1470 nmp->nm_minorvers = minvers;
1472 nmp->nm_minorvers = 0;
1474 nfs_decode_args(mp, nmp, argp, hst, cred, td);
1477 * V2 can only handle 32 bit filesizes. A 4GB-1 limit may be too
1478 * high, depending on whether we end up with negative offsets in
1479 * the client or server somewhere. 2GB-1 may be safer.
1481 * For V3, ncl_fsinfo will adjust this as necessary. Assume maximum
1482 * that we can handle until we find out otherwise.
1484 if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0)
1485 nmp->nm_maxfilesize = 0xffffffffLL;
1487 nmp->nm_maxfilesize = OFF_MAX;
1489 if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0) {
1490 nmp->nm_wsize = NFS_WSIZE;
1491 nmp->nm_rsize = NFS_RSIZE;
1492 nmp->nm_readdirsize = NFS_READDIRSIZE;
1494 nmp->nm_numgrps = NFS_MAXGRPS;
1495 nmp->nm_tprintf_delay = nfs_tprintf_delay;
1496 if (nmp->nm_tprintf_delay < 0)
1497 nmp->nm_tprintf_delay = 0;
1498 nmp->nm_tprintf_initial_delay = nfs_tprintf_initial_delay;
1499 if (nmp->nm_tprintf_initial_delay < 0)
1500 nmp->nm_tprintf_initial_delay = 0;
1501 nmp->nm_fhsize = argp->fhsize;
1502 if (nmp->nm_fhsize > 0)
1503 bcopy((caddr_t)argp->fh, (caddr_t)nmp->nm_fh, argp->fhsize);
1504 bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN);
1506 /* Set up the sockets and per-host congestion */
1507 nmp->nm_sotype = argp->sotype;
1508 nmp->nm_soproto = argp->proto;
1509 nmp->nm_sockreq.nr_prog = NFS_PROG;
1510 if ((argp->flags & NFSMNT_NFSV4))
1511 nmp->nm_sockreq.nr_vers = NFS_VER4;
1512 else if ((argp->flags & NFSMNT_NFSV3))
1513 nmp->nm_sockreq.nr_vers = NFS_VER3;
1515 nmp->nm_sockreq.nr_vers = NFS_VER2;
1518 if ((error = newnfs_connect(nmp, &nmp->nm_sockreq, cred, td, 0)))
1520 /* For NFSv4.1, get the clientid now. */
1521 if (nmp->nm_minorvers > 0) {
1522 NFSCL_DEBUG(3, "at getcl\n");
1523 error = nfscl_getcl(mp, cred, td, 0, &clp);
1524 NFSCL_DEBUG(3, "aft getcl=%d\n", error);
1529 if (nmp->nm_fhsize == 0 && (nmp->nm_flag & NFSMNT_NFSV4) &&
1530 nmp->nm_dirpathlen > 0) {
1531 NFSCL_DEBUG(3, "in dirp\n");
1533 * If the fhsize on the mount point == 0 for V4, the mount
1534 * path needs to be looked up.
1538 error = nfsrpc_getdirpath(nmp, NFSMNT_DIRPATH(nmp),
1540 NFSCL_DEBUG(3, "aft dirp=%d\n", error);
1542 (void) nfs_catnap(PZERO, error, "nfsgetdirp");
1543 } while (error && --trycnt > 0);
1545 error = nfscl_maperr(td, error, (uid_t)0, (gid_t)0);
1551 * A reference count is needed on the nfsnode representing the
1552 * remote root. If this object is not persistent, then backward
1553 * traversals of the mount point (i.e. "..") will not work if
1554 * the nfsnode gets flushed out of the cache. Ufs does not have
1555 * this problem, because one can identify root inodes by their
1556 * number == UFS_ROOTINO (2).
1558 if (nmp->nm_fhsize > 0) {
1560 * Set f_iosize to NFS_DIRBLKSIZ so that bo_bsize gets set
1561 * non-zero for the root vnode. f_iosize will be set correctly
1562 * by nfs_statfs() before any I/O occurs.
1564 mp->mnt_stat.f_iosize = NFS_DIRBLKSIZ;
1565 error = ncl_nget(mp, nmp->nm_fh, nmp->nm_fhsize, &np,
1572 * Get file attributes and transfer parameters for the
1573 * mountpoint. This has the side effect of filling in
1574 * (*vpp)->v_type with the correct value.
1576 ret = nfsrpc_getattrnovp(nmp, nmp->nm_fh, nmp->nm_fhsize, 1,
1577 cred, td, &nfsva, NULL, &lease);
1580 * Just set default values to get things going.
1582 NFSBZERO((caddr_t)&nfsva, sizeof (struct nfsvattr));
1583 nfsva.na_vattr.va_type = VDIR;
1584 nfsva.na_vattr.va_mode = 0777;
1585 nfsva.na_vattr.va_nlink = 100;
1586 nfsva.na_vattr.va_uid = (uid_t)0;
1587 nfsva.na_vattr.va_gid = (gid_t)0;
1588 nfsva.na_vattr.va_fileid = 2;
1589 nfsva.na_vattr.va_gen = 1;
1590 nfsva.na_vattr.va_blocksize = NFS_FABLKSIZE;
1591 nfsva.na_vattr.va_size = 512 * 1024;
1594 (void) nfscl_loadattrcache(vpp, &nfsva, NULL, NULL, 0, 1);
1595 if (nmp->nm_minorvers > 0) {
1596 NFSCL_DEBUG(3, "lease=%d\n", (int)lease);
1598 clp->nfsc_renew = NFSCL_RENEW(lease);
1599 clp->nfsc_expire = NFSD_MONOSEC + clp->nfsc_renew;
1600 clp->nfsc_clientidrev++;
1601 if (clp->nfsc_clientidrev == 0)
1602 clp->nfsc_clientidrev++;
1605 * Mount will succeed, so the renew thread can be
1608 nfscl_start_renewthread(clp);
1609 nfscl_clientrelease(clp);
1611 if (argp->flags & NFSMNT_NFSV3)
1612 ncl_fsinfo(nmp, *vpp, cred, td);
1614 /* Mark if the mount point supports NFSv4 ACLs. */
1615 if ((argp->flags & NFSMNT_NFSV4) != 0 && nfsrv_useacl != 0 &&
1617 NFSISSET_ATTRBIT(&nfsva.na_suppattr, NFSATTRBIT_ACL)) {
1619 mp->mnt_flag |= MNT_NFS4ACLS;
1624 * Lose the lock but keep the ref.
1626 NFSVOPUNLOCK(*vpp, 0);
1633 nfscl_clientrelease(clp);
1634 newnfs_disconnect(&nmp->nm_sockreq);
1635 crfree(nmp->nm_sockreq.nr_cred);
1636 if (nmp->nm_sockreq.nr_auth != NULL)
1637 AUTH_DESTROY(nmp->nm_sockreq.nr_auth);
1638 mtx_destroy(&nmp->nm_sockreq.nr_mtx);
1639 mtx_destroy(&nmp->nm_mtx);
1640 if (nmp->nm_clp != NULL) {
1642 LIST_REMOVE(nmp->nm_clp, nfsc_list);
1644 free(nmp->nm_clp, M_NFSCLCLIENT);
1646 TAILQ_FOREACH_SAFE(dsp, &nmp->nm_sess, nfsclds_list, tdsp)
1647 nfscl_freenfsclds(dsp);
1648 FREE(nmp, M_NEWNFSMNT);
1649 FREE(nam, M_SONAME);
1654 * unmount system call
1657 nfs_unmount(struct mount *mp, int mntflags)
1660 struct nfsmount *nmp;
1661 int error, flags = 0, i, trycnt = 0;
1662 struct nfsclds *dsp, *tdsp;
1666 if (mntflags & MNT_FORCE)
1667 flags |= FORCECLOSE;
1670 * Goes something like this..
1671 * - Call vflush() to clear out vnodes for this filesystem
1672 * - Close the socket
1673 * - Free up the data structures
1675 /* In the forced case, cancel any outstanding requests. */
1676 if (mntflags & MNT_FORCE) {
1677 error = newnfs_nmcancelreqs(nmp);
1680 /* For a forced close, get rid of the renew thread now */
1681 nfscl_umount(nmp, td);
1683 /* We hold 1 extra ref on the root vnode; see comment in mountnfs(). */
1685 error = vflush(mp, 1, flags, td);
1686 if ((mntflags & MNT_FORCE) && error != 0 && ++trycnt < 30)
1687 (void) nfs_catnap(PSOCK, error, "newndm");
1688 } while ((mntflags & MNT_FORCE) && error != 0 && trycnt < 30);
1693 * We are now committed to the unmount.
1695 if ((mntflags & MNT_FORCE) == 0)
1696 nfscl_umount(nmp, td);
1697 /* Make sure no nfsiods are assigned to this mount. */
1698 mtx_lock(&ncl_iod_mutex);
1699 for (i = 0; i < NFS_MAXASYNCDAEMON; i++)
1700 if (ncl_iodmount[i] == nmp) {
1701 ncl_iodwant[i] = NFSIOD_AVAILABLE;
1702 ncl_iodmount[i] = NULL;
1704 mtx_unlock(&ncl_iod_mutex);
1705 newnfs_disconnect(&nmp->nm_sockreq);
1706 crfree(nmp->nm_sockreq.nr_cred);
1707 FREE(nmp->nm_nam, M_SONAME);
1708 if (nmp->nm_sockreq.nr_auth != NULL)
1709 AUTH_DESTROY(nmp->nm_sockreq.nr_auth);
1710 mtx_destroy(&nmp->nm_sockreq.nr_mtx);
1711 mtx_destroy(&nmp->nm_mtx);
1712 TAILQ_FOREACH_SAFE(dsp, &nmp->nm_sess, nfsclds_list, tdsp)
1713 nfscl_freenfsclds(dsp);
1714 FREE(nmp, M_NEWNFSMNT);
1720 * Return root of a filesystem
1723 nfs_root(struct mount *mp, int flags, struct vnode **vpp)
1726 struct nfsmount *nmp;
1731 error = ncl_nget(mp, nmp->nm_fh, nmp->nm_fhsize, &np, flags);
1736 * Get transfer parameters and attributes for root vnode once.
1738 mtx_lock(&nmp->nm_mtx);
1739 if (NFSHASNFSV3(nmp) && !NFSHASGOTFSINFO(nmp)) {
1740 mtx_unlock(&nmp->nm_mtx);
1741 ncl_fsinfo(nmp, vp, curthread->td_ucred, curthread);
1743 mtx_unlock(&nmp->nm_mtx);
1744 if (vp->v_type == VNON)
1746 vp->v_vflag |= VV_ROOT;
1752 * Flush out the buffer cache
1756 nfs_sync(struct mount *mp, int waitfor)
1758 struct vnode *vp, *mvp;
1760 int error, allerror = 0;
1766 * If a forced dismount is in progress, return from here so that
1767 * the umount(2) syscall doesn't get stuck in VFS_SYNC() before
1768 * calling VFS_UNMOUNT().
1770 if ((mp->mnt_kern_flag & MNTK_UNMOUNTF) != 0) {
1777 * Force stale buffer cache information to be flushed.
1780 MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
1781 /* XXX Racy bv_cnt check. */
1782 if (NFSVOPISLOCKED(vp) || vp->v_bufobj.bo_dirty.bv_cnt == 0 ||
1783 waitfor == MNT_LAZY) {
1787 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
1788 MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
1791 error = VOP_FSYNC(vp, waitfor, td);
1794 NFSVOPUNLOCK(vp, 0);
1801 nfs_sysctl(struct mount *mp, fsctlop_t op, struct sysctl_req *req)
1803 struct nfsmount *nmp = VFSTONFS(mp);
1807 bzero(&vq, sizeof(vq));
1810 case VFS_CTL_NOLOCKS:
1811 val = (nmp->nm_flag & NFSMNT_NOLOCKS) ? 1 : 0;
1812 if (req->oldptr != NULL) {
1813 error = SYSCTL_OUT(req, &val, sizeof(val));
1817 if (req->newptr != NULL) {
1818 error = SYSCTL_IN(req, &val, sizeof(val));
1822 nmp->nm_flag |= NFSMNT_NOLOCKS;
1824 nmp->nm_flag &= ~NFSMNT_NOLOCKS;
1829 mtx_lock(&nmp->nm_mtx);
1830 if (nmp->nm_state & NFSSTA_TIMEO)
1831 vq.vq_flags |= VQ_NOTRESP;
1832 mtx_unlock(&nmp->nm_mtx);
1834 if (!(nmp->nm_flag & NFSMNT_NOLOCKS) &&
1835 (nmp->nm_state & NFSSTA_LOCKTIMEO))
1836 vq.vq_flags |= VQ_NOTRESPLOCK;
1838 error = SYSCTL_OUT(req, &vq, sizeof(vq));
1841 if (req->oldptr != NULL) {
1842 error = SYSCTL_OUT(req, &nmp->nm_tprintf_initial_delay,
1843 sizeof(nmp->nm_tprintf_initial_delay));
1847 if (req->newptr != NULL) {
1848 error = vfs_suser(mp, req->td);
1851 error = SYSCTL_IN(req, &nmp->nm_tprintf_initial_delay,
1852 sizeof(nmp->nm_tprintf_initial_delay));
1855 if (nmp->nm_tprintf_initial_delay < 0)
1856 nmp->nm_tprintf_initial_delay = 0;
1866 * Purge any RPCs in progress, so that they will all return errors.
1867 * This allows dounmount() to continue as far as VFS_UNMOUNT() for a
1871 nfs_purge(struct mount *mp)
1873 struct nfsmount *nmp = VFSTONFS(mp);
1875 newnfs_nmcancelreqs(nmp);
1879 * Extract the information needed by the nlm from the nfs vnode.
1882 nfs_getnlminfo(struct vnode *vp, uint8_t *fhp, size_t *fhlenp,
1883 struct sockaddr_storage *sp, int *is_v3p, off_t *sizep,
1884 struct timeval *timeop)
1886 struct nfsmount *nmp;
1887 struct nfsnode *np = VTONFS(vp);
1889 nmp = VFSTONFS(vp->v_mount);
1891 *fhlenp = (size_t)np->n_fhp->nfh_len;
1893 bcopy(np->n_fhp->nfh_fh, fhp, np->n_fhp->nfh_len);
1895 bcopy(nmp->nm_nam, sp, min(nmp->nm_nam->sa_len, sizeof(*sp)));
1897 *is_v3p = NFS_ISV3(vp);
1899 *sizep = np->n_size;
1900 if (timeop != NULL) {
1901 timeop->tv_sec = nmp->nm_timeo / NFS_HZ;
1902 timeop->tv_usec = (nmp->nm_timeo % NFS_HZ) * (1000000 / NFS_HZ);
1907 * This function prints out an option name, based on the conditional
1910 static __inline void nfscl_printopt(struct nfsmount *nmp, int testval,
1911 char *opt, char **buf, size_t *blen)
1915 if (testval != 0 && *blen > strlen(opt)) {
1916 len = snprintf(*buf, *blen, "%s", opt);
1917 if (len != strlen(opt))
1925 * This function printf out an options integer value.
1927 static __inline void nfscl_printoptval(struct nfsmount *nmp, int optval,
1928 char *opt, char **buf, size_t *blen)
1932 if (*blen > strlen(opt) + 1) {
1933 /* Could result in truncated output string. */
1934 len = snprintf(*buf, *blen, "%s=%d", opt, optval);
1943 * Load the option flags and values into the buffer.
1945 void nfscl_retopts(struct nfsmount *nmp, char *buffer, size_t buflen)
1952 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NFSV4) != 0, "nfsv4", &buf,
1954 if ((nmp->nm_flag & NFSMNT_NFSV4) != 0) {
1955 nfscl_printoptval(nmp, nmp->nm_minorvers, ",minorversion", &buf,
1957 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_PNFS) != 0, ",pnfs",
1959 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_ONEOPENOWN) != 0 &&
1960 nmp->nm_minorvers > 0, ",oneopenown", &buf, &blen);
1962 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NFSV3) != 0, "nfsv3", &buf,
1964 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0,
1965 "nfsv2", &buf, &blen);
1966 nfscl_printopt(nmp, nmp->nm_sotype == SOCK_STREAM, ",tcp", &buf, &blen);
1967 nfscl_printopt(nmp, nmp->nm_sotype != SOCK_STREAM, ",udp", &buf, &blen);
1968 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_RESVPORT) != 0, ",resvport",
1970 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCONN) != 0, ",noconn",
1972 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_SOFT) == 0, ",hard", &buf,
1974 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_SOFT) != 0, ",soft", &buf,
1976 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_INT) != 0, ",intr", &buf,
1978 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCTO) == 0, ",cto", &buf,
1980 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCTO) != 0, ",nocto", &buf,
1982 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NONCONTIGWR) != 0,
1983 ",noncontigwr", &buf, &blen);
1984 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NOLOCKD | NFSMNT_NFSV4)) ==
1985 0, ",lockd", &buf, &blen);
1986 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NOLOCKD | NFSMNT_NFSV4)) ==
1987 NFSMNT_NOLOCKD, ",nolockd", &buf, &blen);
1988 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_RDIRPLUS) != 0, ",rdirplus",
1990 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_KERB) == 0, ",sec=sys",
1992 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY |
1993 NFSMNT_PRIVACY)) == NFSMNT_KERB, ",sec=krb5", &buf, &blen);
1994 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY |
1995 NFSMNT_PRIVACY)) == (NFSMNT_KERB | NFSMNT_INTEGRITY), ",sec=krb5i",
1997 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY |
1998 NFSMNT_PRIVACY)) == (NFSMNT_KERB | NFSMNT_PRIVACY), ",sec=krb5p",
2000 nfscl_printoptval(nmp, nmp->nm_acdirmin, ",acdirmin", &buf, &blen);
2001 nfscl_printoptval(nmp, nmp->nm_acdirmax, ",acdirmax", &buf, &blen);
2002 nfscl_printoptval(nmp, nmp->nm_acregmin, ",acregmin", &buf, &blen);
2003 nfscl_printoptval(nmp, nmp->nm_acregmax, ",acregmax", &buf, &blen);
2004 nfscl_printoptval(nmp, nmp->nm_nametimeo, ",nametimeo", &buf, &blen);
2005 nfscl_printoptval(nmp, nmp->nm_negnametimeo, ",negnametimeo", &buf,
2007 nfscl_printoptval(nmp, nmp->nm_rsize, ",rsize", &buf, &blen);
2008 nfscl_printoptval(nmp, nmp->nm_wsize, ",wsize", &buf, &blen);
2009 nfscl_printoptval(nmp, nmp->nm_readdirsize, ",readdirsize", &buf,
2011 nfscl_printoptval(nmp, nmp->nm_readahead, ",readahead", &buf, &blen);
2012 nfscl_printoptval(nmp, nmp->nm_wcommitsize, ",wcommitsize", &buf,
2014 nfscl_printoptval(nmp, nmp->nm_timeo, ",timeout", &buf, &blen);
2015 nfscl_printoptval(nmp, nmp->nm_retry, ",retrans", &buf, &blen);