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 * 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.
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 * @(#)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>
48 #include <sys/limits.h>
50 #include <sys/malloc.h>
52 #include <sys/module.h>
53 #include <sys/mount.h>
55 #include <sys/socket.h>
56 #include <sys/socketvar.h>
57 #include <sys/sockio.h>
58 #include <sys/sysctl.h>
59 #include <sys/syslog.h>
60 #include <sys/vnode.h>
61 #include <sys/signalvar.h>
64 #include <vm/vm_extern.h>
68 #include <net/route.h>
71 #include <netinet/in.h>
75 #include <nfs/nfsproto.h>
76 #include <nfsclient/nfs.h>
77 #include <nfsclient/nfsnode.h>
78 #include <nfsclient/nfsmount.h>
79 #include <nfs/xdr_subs.h>
80 #include <nfsclient/nfsm_subs.h>
81 #include <nfs/nfsdiskless.h>
83 FEATURE(nfsclient, "NFS client");
85 MALLOC_DEFINE(M_NFSREQ, "nfsclient_req", "NFS request header");
86 MALLOC_DEFINE(M_NFSBIGFH, "nfsclient_bigfh", "NFS version 3 file handle");
87 MALLOC_DEFINE(M_NFSDIROFF, "nfsclient_diroff", "NFS directory offset data");
88 MALLOC_DEFINE(M_NFSHASH, "nfsclient_hash", "NFS hash tables");
89 MALLOC_DEFINE(M_NFSDIRECTIO, "nfsclient_directio", "NFS Direct IO async write state");
91 uma_zone_t nfsmount_zone;
93 struct nfsstats nfsstats;
95 SYSCTL_NODE(_vfs, OID_AUTO, oldnfs, CTLFLAG_RW, 0, "Old NFS filesystem");
96 SYSCTL_STRUCT(_vfs_oldnfs, NFS_NFSSTATS, nfsstats, CTLFLAG_RW,
97 &nfsstats, nfsstats, "S,nfsstats");
98 static int nfs_ip_paranoia = 1;
99 SYSCTL_INT(_vfs_oldnfs, OID_AUTO, nfs_ip_paranoia, CTLFLAG_RW,
101 "Disallow accepting replies from IPs which differ from those sent");
104 SYSCTL_INT(_vfs_oldnfs, OID_AUTO, debug, CTLFLAG_RW, &nfs_debug, 0,
105 "Toggle debug flag");
107 static int nfs_tprintf_initial_delay = NFS_TPRINTF_INITIAL_DELAY;
108 SYSCTL_INT(_vfs_oldnfs, NFS_TPRINTF_INITIAL_DELAY,
109 downdelayinitial, CTLFLAG_RW, &nfs_tprintf_initial_delay, 0,
110 "Delay before printing \"nfs server not responding\" messages");
111 /* how long between console messages "nfs server foo not responding" */
112 static int nfs_tprintf_delay = NFS_TPRINTF_DELAY;
113 SYSCTL_INT(_vfs_oldnfs, NFS_TPRINTF_DELAY,
114 downdelayinterval, CTLFLAG_RW, &nfs_tprintf_delay, 0,
115 "Delay between printing \"nfs server not responding\" messages");
117 static void nfs_decode_args(struct mount *mp, struct nfsmount *nmp,
118 struct nfs_args *argp, const char *hostname);
119 static int mountnfs(struct nfs_args *, struct mount *,
120 struct sockaddr *, char *, struct vnode **,
121 struct ucred *cred, int, int);
122 static void nfs_getnlminfo(struct vnode *, uint8_t *, size_t *,
123 struct sockaddr_storage *, int *, off_t *,
125 static vfs_mount_t nfs_mount;
126 static vfs_cmount_t nfs_cmount;
127 static vfs_unmount_t nfs_unmount;
128 static vfs_root_t nfs_root;
129 static vfs_statfs_t nfs_statfs;
130 static vfs_sync_t nfs_sync;
131 static vfs_sysctl_t nfs_sysctl;
133 static int fake_wchan;
136 * nfs vfs operations.
138 static struct vfsops nfs_vfsops = {
139 .vfs_init = nfs_init,
140 .vfs_mount = nfs_mount,
141 .vfs_cmount = nfs_cmount,
142 .vfs_root = nfs_root,
143 .vfs_statfs = nfs_statfs,
144 .vfs_sync = nfs_sync,
145 .vfs_uninit = nfs_uninit,
146 .vfs_unmount = nfs_unmount,
147 .vfs_sysctl = nfs_sysctl,
149 VFS_SET(nfs_vfsops, oldnfs, VFCF_NETWORK | VFCF_SBDRY);
151 /* So that loader and kldload(2) can find us, wherever we are.. */
152 MODULE_VERSION(oldnfs, 1);
153 MODULE_DEPEND(oldnfs, krpc, 1, 1, 1);
155 MODULE_DEPEND(oldnfs, kgssapi, 1, 1, 1);
157 MODULE_DEPEND(oldnfs, nfs_common, 1, 1, 1);
158 MODULE_DEPEND(oldnfs, nfslock, 1, 1, 1);
160 static struct nfs_rpcops nfs_rpcops = {
170 * This structure is now defined in sys/nfs/nfs_diskless.c so that it
171 * can be shared by both NFS clients. It is declared here so that it
172 * will be defined for kernels built without NFS_ROOT, although it
173 * isn't used in that case.
176 struct nfs_diskless nfs_diskless = { { { 0 } } };
177 struct nfsv3_diskless nfsv3_diskless = { { { 0 } } };
178 int nfs_diskless_valid = 0;
181 SYSCTL_INT(_vfs_oldnfs, OID_AUTO, diskless_valid, CTLFLAG_RD,
182 &nfs_diskless_valid, 0,
183 "Has the diskless struct been filled correctly");
185 SYSCTL_STRING(_vfs_oldnfs, OID_AUTO, diskless_rootpath, CTLFLAG_RD,
186 nfsv3_diskless.root_hostnam, 0, "Path to nfs root");
188 SYSCTL_OPAQUE(_vfs_oldnfs, OID_AUTO, diskless_rootaddr, CTLFLAG_RD,
189 &nfsv3_diskless.root_saddr, sizeof nfsv3_diskless.root_saddr,
190 "%Ssockaddr_in", "Diskless root nfs address");
193 void nfsargs_ntoh(struct nfs_args *);
194 static int nfs_mountdiskless(char *,
195 struct sockaddr_in *, struct nfs_args *,
196 struct thread *, struct vnode **, struct mount *);
197 static void nfs_convert_diskless(void);
198 static void nfs_convert_oargs(struct nfs_args *args,
199 struct onfs_args *oargs);
202 nfs_iosize(struct nfsmount *nmp)
207 * Calculate the size used for io buffers. Use the larger
208 * of the two sizes to minimise nfs requests but make sure
209 * that it is at least one VM page to avoid wasting buffer
212 iosize = imax(nmp->nm_rsize, nmp->nm_wsize);
213 iosize = imax(iosize, PAGE_SIZE);
218 nfs_convert_oargs(struct nfs_args *args, struct onfs_args *oargs)
221 args->version = NFS_ARGSVERSION;
222 args->addr = oargs->addr;
223 args->addrlen = oargs->addrlen;
224 args->sotype = oargs->sotype;
225 args->proto = oargs->proto;
226 args->fh = oargs->fh;
227 args->fhsize = oargs->fhsize;
228 args->flags = oargs->flags;
229 args->wsize = oargs->wsize;
230 args->rsize = oargs->rsize;
231 args->readdirsize = oargs->readdirsize;
232 args->timeo = oargs->timeo;
233 args->retrans = oargs->retrans;
234 args->maxgrouplist = oargs->maxgrouplist;
235 args->readahead = oargs->readahead;
236 args->deadthresh = oargs->deadthresh;
237 args->hostname = oargs->hostname;
241 nfs_convert_diskless(void)
244 bcopy(&nfs_diskless.myif, &nfsv3_diskless.myif,
245 sizeof(struct ifaliasreq));
246 bcopy(&nfs_diskless.mygateway, &nfsv3_diskless.mygateway,
247 sizeof(struct sockaddr_in));
248 nfs_convert_oargs(&nfsv3_diskless.root_args,&nfs_diskless.root_args);
249 if (nfsv3_diskless.root_args.flags & NFSMNT_NFSV3) {
250 nfsv3_diskless.root_fhsize = NFSX_V3FH;
251 bcopy(nfs_diskless.root_fh, nfsv3_diskless.root_fh, NFSX_V3FH);
253 nfsv3_diskless.root_fhsize = NFSX_V2FH;
254 bcopy(nfs_diskless.root_fh, nfsv3_diskless.root_fh, NFSX_V2FH);
256 bcopy(&nfs_diskless.root_saddr,&nfsv3_diskless.root_saddr,
257 sizeof(struct sockaddr_in));
258 bcopy(nfs_diskless.root_hostnam, nfsv3_diskless.root_hostnam, MNAMELEN);
259 nfsv3_diskless.root_time = nfs_diskless.root_time;
260 bcopy(nfs_diskless.my_hostnam, nfsv3_diskless.my_hostnam,
262 nfs_diskless_valid = 3;
269 nfs_statfs(struct mount *mp, struct statfs *sbp)
273 struct nfs_statfs *sfp;
275 struct nfsmount *nmp = VFSTONFS(mp);
276 int error = 0, v3 = (nmp->nm_flag & NFSMNT_NFSV3), retattr;
277 struct mbuf *mreq, *mrep, *md, *mb;
285 error = vfs_busy(mp, MBF_NOWAIT);
288 error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np, LK_EXCLUSIVE);
294 mtx_lock(&nmp->nm_mtx);
295 if (v3 && (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) {
296 mtx_unlock(&nmp->nm_mtx);
297 (void)nfs_fsinfo(nmp, vp, td->td_ucred, td);
299 mtx_unlock(&nmp->nm_mtx);
300 nfsstats.rpccnt[NFSPROC_FSSTAT]++;
301 mreq = nfsm_reqhead(vp, NFSPROC_FSSTAT, NFSX_FH(v3));
303 bpos = mtod(mb, caddr_t);
305 nfsm_request(vp, NFSPROC_FSSTAT, td, td->td_ucred);
307 nfsm_postop_attr(vp, retattr);
313 sfp = nfsm_dissect(struct nfs_statfs *, NFSX_STATFS(v3));
314 mtx_lock(&nmp->nm_mtx);
315 sbp->f_iosize = nfs_iosize(nmp);
316 mtx_unlock(&nmp->nm_mtx);
318 sbp->f_bsize = NFS_FABLKSIZE;
319 tquad = fxdr_hyper(&sfp->sf_tbytes);
320 sbp->f_blocks = tquad / NFS_FABLKSIZE;
321 tquad = fxdr_hyper(&sfp->sf_fbytes);
322 sbp->f_bfree = tquad / NFS_FABLKSIZE;
323 tquad = fxdr_hyper(&sfp->sf_abytes);
324 sbp->f_bavail = tquad / NFS_FABLKSIZE;
325 sbp->f_files = (fxdr_unsigned(int32_t,
326 sfp->sf_tfiles.nfsuquad[1]) & 0x7fffffff);
327 sbp->f_ffree = (fxdr_unsigned(int32_t,
328 sfp->sf_ffiles.nfsuquad[1]) & 0x7fffffff);
330 sbp->f_bsize = fxdr_unsigned(int32_t, sfp->sf_bsize);
331 sbp->f_blocks = fxdr_unsigned(int32_t, sfp->sf_blocks);
332 sbp->f_bfree = fxdr_unsigned(int32_t, sfp->sf_bfree);
333 sbp->f_bavail = fxdr_unsigned(int32_t, sfp->sf_bavail);
345 * nfs version 3 fsinfo rpc call
348 nfs_fsinfo(struct nfsmount *nmp, struct vnode *vp, struct ucred *cred,
351 struct nfsv3_fsinfo *fsp;
354 int error = 0, retattr;
355 struct mbuf *mreq, *mrep, *md, *mb;
358 nfsstats.rpccnt[NFSPROC_FSINFO]++;
359 mreq = nfsm_reqhead(vp, NFSPROC_FSINFO, NFSX_FH(1));
361 bpos = mtod(mb, caddr_t);
363 nfsm_request(vp, NFSPROC_FSINFO, td, cred);
364 nfsm_postop_attr(vp, retattr);
366 fsp = nfsm_dissect(struct nfsv3_fsinfo *, NFSX_V3FSINFO);
367 pref = fxdr_unsigned(u_int32_t, fsp->fs_wtpref);
368 mtx_lock(&nmp->nm_mtx);
369 if (pref < nmp->nm_wsize && pref >= NFS_FABLKSIZE)
370 nmp->nm_wsize = (pref + NFS_FABLKSIZE - 1) &
371 ~(NFS_FABLKSIZE - 1);
372 max = fxdr_unsigned(u_int32_t, fsp->fs_wtmax);
373 if (max < nmp->nm_wsize && max > 0) {
374 nmp->nm_wsize = max & ~(NFS_FABLKSIZE - 1);
375 if (nmp->nm_wsize == 0)
378 pref = fxdr_unsigned(u_int32_t, fsp->fs_rtpref);
379 if (pref < nmp->nm_rsize && pref >= NFS_FABLKSIZE)
380 nmp->nm_rsize = (pref + NFS_FABLKSIZE - 1) &
381 ~(NFS_FABLKSIZE - 1);
382 max = fxdr_unsigned(u_int32_t, fsp->fs_rtmax);
383 if (max < nmp->nm_rsize && max > 0) {
384 nmp->nm_rsize = max & ~(NFS_FABLKSIZE - 1);
385 if (nmp->nm_rsize == 0)
388 pref = fxdr_unsigned(u_int32_t, fsp->fs_dtpref);
389 if (pref < nmp->nm_readdirsize && pref >= NFS_DIRBLKSIZ)
390 nmp->nm_readdirsize = (pref + NFS_DIRBLKSIZ - 1) &
391 ~(NFS_DIRBLKSIZ - 1);
392 if (max < nmp->nm_readdirsize && max > 0) {
393 nmp->nm_readdirsize = max & ~(NFS_DIRBLKSIZ - 1);
394 if (nmp->nm_readdirsize == 0)
395 nmp->nm_readdirsize = max;
397 maxfsize = fxdr_hyper(&fsp->fs_maxfilesize);
398 if (maxfsize > 0 && maxfsize < nmp->nm_maxfilesize)
399 nmp->nm_maxfilesize = maxfsize;
400 nmp->nm_mountp->mnt_stat.f_iosize = nfs_iosize(nmp);
401 nmp->nm_state |= NFSSTA_GOTFSINFO;
402 mtx_unlock(&nmp->nm_mtx);
410 * Mount a remote root fs via. nfs. This depends on the info in the
411 * nfs_diskless structure that has been filled in properly by some primary
413 * It goes something like this:
414 * - do enough of "ifconfig" by calling ifioctl() so that the system
415 * can talk to the server
416 * - If nfs_diskless.mygateway is filled in, use that address as
418 * - build the rootfs mount point and call mountnfs() to do the rest.
420 * It is assumed to be safe to read, modify, and write the nfsv3_diskless
421 * structure, as well as other global NFS client variables here, as
422 * nfs_mountroot() will be called once in the boot before any other NFS
423 * client activity occurs.
426 nfs_mountroot(struct mount *mp)
428 struct thread *td = curthread;
429 struct nfsv3_diskless *nd = &nfsv3_diskless;
439 #if defined(BOOTP_NFSROOT) && defined(BOOTP)
440 bootpc_init(); /* use bootp to get nfs_diskless filled in */
441 #elif defined(NFS_ROOT)
442 nfs_setup_diskless();
445 if (nfs_diskless_valid == 0) {
448 if (nfs_diskless_valid == 1)
449 nfs_convert_diskless();
452 * XXX splnet, so networks will receive...
457 * Do enough of ifconfig(8) so that the critical net interface can
458 * talk to the server.
460 error = socreate(nd->myif.ifra_addr.sa_family, &so, nd->root_args.sotype, 0,
463 panic("nfs_mountroot: socreate(%04x): %d",
464 nd->myif.ifra_addr.sa_family, error);
466 #if 0 /* XXX Bad idea */
468 * We might not have been told the right interface, so we pass
469 * over the first ten interfaces of the same kind, until we get
470 * one of them configured.
473 for (i = strlen(nd->myif.ifra_name) - 1;
474 nd->myif.ifra_name[i] >= '0' &&
475 nd->myif.ifra_name[i] <= '9';
476 nd->myif.ifra_name[i] ++) {
477 error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);
483 error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td);
485 panic("nfs_mountroot: SIOCAIFADDR: %d", error);
487 if ((cp = getenv("boot.netif.mtu")) != NULL) {
488 ir.ifr_mtu = strtol(cp, NULL, 10);
489 bcopy(nd->myif.ifra_name, ir.ifr_name, IFNAMSIZ);
491 error = ifioctl(so, SIOCSIFMTU, (caddr_t)&ir, td);
493 printf("nfs_mountroot: SIOCSIFMTU: %d", error);
498 * If the gateway field is filled in, set it as the default route.
499 * Note that pxeboot will set a default route of 0 if the route
500 * is not set by the DHCP server. Check also for a value of 0
501 * to avoid panicking inappropriately in that situation.
503 if (nd->mygateway.sin_len != 0 &&
504 nd->mygateway.sin_addr.s_addr != 0) {
505 struct sockaddr_in mask, sin;
507 bzero((caddr_t)&mask, sizeof(mask));
509 sin.sin_family = AF_INET;
510 sin.sin_len = sizeof(sin);
511 /* XXX MRT use table 0 for this sort of thing */
512 CURVNET_SET(TD_TO_VNET(td));
513 error = rtrequest_fib(RTM_ADD, (struct sockaddr *)&sin,
514 (struct sockaddr *)&nd->mygateway,
515 (struct sockaddr *)&mask,
516 RTF_UP | RTF_GATEWAY, NULL, RT_DEFAULT_FIB);
519 panic("nfs_mountroot: RTM_ADD: %d", error);
523 * Create the rootfs mount point.
525 nd->root_args.fh = nd->root_fh;
526 nd->root_args.fhsize = nd->root_fhsize;
527 l = ntohl(nd->root_saddr.sin_addr.s_addr);
528 snprintf(buf, sizeof(buf), "%ld.%ld.%ld.%ld:%s",
529 (l >> 24) & 0xff, (l >> 16) & 0xff,
530 (l >> 8) & 0xff, (l >> 0) & 0xff, nd->root_hostnam);
531 printf("NFS ROOT: %s\n", buf);
532 nd->root_args.hostname = buf;
533 if ((error = nfs_mountdiskless(buf,
534 &nd->root_saddr, &nd->root_args, td, &vp, mp)) != 0) {
539 * This is not really an nfs issue, but it is much easier to
540 * set hostname here and then let the "/etc/rc.xxx" files
541 * mount the right /var based upon its preset value.
543 mtx_lock(&prison0.pr_mtx);
544 strlcpy(prison0.pr_hostname, nd->my_hostnam,
545 sizeof (prison0.pr_hostname));
546 mtx_unlock(&prison0.pr_mtx);
547 inittodr(ntohl(nd->root_time));
552 * Internal version of mount system call for diskless setup.
555 nfs_mountdiskless(char *path,
556 struct sockaddr_in *sin, struct nfs_args *args, struct thread *td,
557 struct vnode **vpp, struct mount *mp)
559 struct sockaddr *nam;
562 nam = sodupsockaddr((struct sockaddr *)sin, M_WAITOK);
563 if ((error = mountnfs(args, mp, nam, path, vpp, td->td_ucred,
564 NFS_DEFAULT_NAMETIMEO, NFS_DEFAULT_NEGNAMETIMEO)) != 0) {
565 printf("nfs_mountroot: mount %s on /: %d\n", path, error);
572 nfs_sec_name_to_num(char *sec)
574 if (!strcmp(sec, "krb5"))
575 return (RPCSEC_GSS_KRB5);
576 if (!strcmp(sec, "krb5i"))
577 return (RPCSEC_GSS_KRB5I);
578 if (!strcmp(sec, "krb5p"))
579 return (RPCSEC_GSS_KRB5P);
580 if (!strcmp(sec, "sys"))
583 * Userland should validate the string but we will try and
584 * cope with unexpected values.
590 nfs_decode_args(struct mount *mp, struct nfsmount *nmp, struct nfs_args *argp,
591 const char *hostname)
603 * Set read-only flag if requested; otherwise, clear it if this is
604 * an update. If this is not an update, then either the read-only
605 * flag is already clear, or this is a root mount and it was set
606 * intentionally at some previous point.
608 if (vfs_getopt(mp->mnt_optnew, "ro", NULL, NULL) == 0) {
610 mp->mnt_flag |= MNT_RDONLY;
612 } else if (mp->mnt_flag & MNT_UPDATE) {
614 mp->mnt_flag &= ~MNT_RDONLY;
619 * Silently clear NFSMNT_NOCONN if it's a TCP mount, it makes
620 * no sense in that context. Also, set up appropriate retransmit
621 * and soft timeout behavior.
623 if (argp->sotype == SOCK_STREAM) {
624 nmp->nm_flag &= ~NFSMNT_NOCONN;
625 nmp->nm_flag |= NFSMNT_DUMBTIMR;
626 nmp->nm_timeo = NFS_MAXTIMEO;
627 nmp->nm_retry = NFS_RETRANS_TCP;
630 /* Also clear RDIRPLUS if not NFSv3, it crashes some servers */
631 if ((argp->flags & NFSMNT_NFSV3) == 0)
632 nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
634 /* Re-bind if rsrvd port requested and wasn't on one */
635 adjsock = !(nmp->nm_flag & NFSMNT_RESVPORT)
636 && (argp->flags & NFSMNT_RESVPORT);
637 /* Also re-bind if we're switching to/from a connected UDP socket */
638 adjsock |= ((nmp->nm_flag & NFSMNT_NOCONN) !=
639 (argp->flags & NFSMNT_NOCONN));
641 /* Update flags atomically. Don't change the lock bits. */
642 nmp->nm_flag = argp->flags | nmp->nm_flag;
645 if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) {
646 nmp->nm_timeo = (argp->timeo * NFS_HZ + 5) / 10;
647 if (nmp->nm_timeo < NFS_MINTIMEO)
648 nmp->nm_timeo = NFS_MINTIMEO;
649 else if (nmp->nm_timeo > NFS_MAXTIMEO)
650 nmp->nm_timeo = NFS_MAXTIMEO;
653 if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) {
654 nmp->nm_retry = argp->retrans;
655 if (nmp->nm_retry > NFS_MAXREXMIT)
656 nmp->nm_retry = NFS_MAXREXMIT;
659 if (argp->flags & NFSMNT_NFSV3) {
660 if (argp->sotype == SOCK_DGRAM)
661 maxio = NFS_MAXDGRAMDATA;
665 maxio = NFS_V2MAXDATA;
667 if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) {
668 nmp->nm_wsize = argp->wsize;
669 /* Round down to multiple of blocksize */
670 nmp->nm_wsize &= ~(NFS_FABLKSIZE - 1);
671 if (nmp->nm_wsize <= 0)
672 nmp->nm_wsize = NFS_FABLKSIZE;
674 if (nmp->nm_wsize > maxio)
675 nmp->nm_wsize = maxio;
676 if (nmp->nm_wsize > MAXBSIZE)
677 nmp->nm_wsize = MAXBSIZE;
679 if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) {
680 nmp->nm_rsize = argp->rsize;
681 /* Round down to multiple of blocksize */
682 nmp->nm_rsize &= ~(NFS_FABLKSIZE - 1);
683 if (nmp->nm_rsize <= 0)
684 nmp->nm_rsize = NFS_FABLKSIZE;
686 if (nmp->nm_rsize > maxio)
687 nmp->nm_rsize = maxio;
688 if (nmp->nm_rsize > MAXBSIZE)
689 nmp->nm_rsize = MAXBSIZE;
691 if ((argp->flags & NFSMNT_READDIRSIZE) && argp->readdirsize > 0) {
692 nmp->nm_readdirsize = argp->readdirsize;
694 if (nmp->nm_readdirsize > maxio)
695 nmp->nm_readdirsize = maxio;
696 if (nmp->nm_readdirsize > nmp->nm_rsize)
697 nmp->nm_readdirsize = nmp->nm_rsize;
699 if ((argp->flags & NFSMNT_ACREGMIN) && argp->acregmin >= 0)
700 nmp->nm_acregmin = argp->acregmin;
702 nmp->nm_acregmin = NFS_MINATTRTIMO;
703 if ((argp->flags & NFSMNT_ACREGMAX) && argp->acregmax >= 0)
704 nmp->nm_acregmax = argp->acregmax;
706 nmp->nm_acregmax = NFS_MAXATTRTIMO;
707 if ((argp->flags & NFSMNT_ACDIRMIN) && argp->acdirmin >= 0)
708 nmp->nm_acdirmin = argp->acdirmin;
710 nmp->nm_acdirmin = NFS_MINDIRATTRTIMO;
711 if ((argp->flags & NFSMNT_ACDIRMAX) && argp->acdirmax >= 0)
712 nmp->nm_acdirmax = argp->acdirmax;
714 nmp->nm_acdirmax = NFS_MAXDIRATTRTIMO;
715 if (nmp->nm_acdirmin > nmp->nm_acdirmax)
716 nmp->nm_acdirmin = nmp->nm_acdirmax;
717 if (nmp->nm_acregmin > nmp->nm_acregmax)
718 nmp->nm_acregmin = nmp->nm_acregmax;
720 if ((argp->flags & NFSMNT_MAXGRPS) && argp->maxgrouplist >= 0) {
721 if (argp->maxgrouplist <= NFS_MAXGRPS)
722 nmp->nm_numgrps = argp->maxgrouplist;
724 nmp->nm_numgrps = NFS_MAXGRPS;
726 if ((argp->flags & NFSMNT_READAHEAD) && argp->readahead >= 0) {
727 if (argp->readahead <= NFS_MAXRAHEAD)
728 nmp->nm_readahead = argp->readahead;
730 nmp->nm_readahead = NFS_MAXRAHEAD;
732 if ((argp->flags & NFSMNT_WCOMMITSIZE) && argp->wcommitsize >= 0) {
733 if (argp->wcommitsize < nmp->nm_wsize)
734 nmp->nm_wcommitsize = nmp->nm_wsize;
736 nmp->nm_wcommitsize = argp->wcommitsize;
738 if ((argp->flags & NFSMNT_DEADTHRESH) && argp->deadthresh >= 0) {
739 if (argp->deadthresh <= NFS_MAXDEADTHRESH)
740 nmp->nm_deadthresh = argp->deadthresh;
742 nmp->nm_deadthresh = NFS_MAXDEADTHRESH;
745 adjsock |= ((nmp->nm_sotype != argp->sotype) ||
746 (nmp->nm_soproto != argp->proto));
747 nmp->nm_sotype = argp->sotype;
748 nmp->nm_soproto = argp->proto;
750 if (nmp->nm_client && adjsock) {
751 nfs_safedisconnect(nmp);
752 if (nmp->nm_sotype == SOCK_DGRAM)
753 while (nfs_connect(nmp)) {
754 printf("nfs_args: retrying connect\n");
755 (void) tsleep(&fake_wchan, PSOCK, "nfscon", hz);
760 strlcpy(nmp->nm_hostname, hostname,
761 sizeof(nmp->nm_hostname));
762 p = strchr(nmp->nm_hostname, ':');
767 if (vfs_getopt(mp->mnt_optnew, "sec",
768 (void **) &secname, NULL) == 0) {
769 nmp->nm_secflavor = nfs_sec_name_to_num(secname);
771 nmp->nm_secflavor = AUTH_SYS;
774 if (vfs_getopt(mp->mnt_optnew, "principal",
775 (void **) &principal, NULL) == 0) {
776 strlcpy(nmp->nm_principal, principal,
777 sizeof(nmp->nm_principal));
779 snprintf(nmp->nm_principal, sizeof(nmp->nm_principal),
780 "nfs@%s", nmp->nm_hostname);
784 static const char *nfs_opts[] = { "from", "nfs_args",
785 "noatime", "noexec", "suiddir", "nosuid", "nosymfollow", "union",
786 "noclusterr", "noclusterw", "multilabel", "acls", "force", "update",
787 "async", "dumbtimer", "noconn", "nolockd", "intr", "rdirplus", "resvport",
788 "readahead", "readdirsize", "soft", "hard", "mntudp", "tcp", "udp",
789 "wsize", "rsize", "retrans", "acregmin", "acregmax", "acdirmin",
790 "acdirmax", "deadthresh", "hostname", "timeout", "addr", "fh", "nfsv3",
791 "sec", "maxgroups", "principal", "negnametimeo", "nocto", "wcommitsize",
799 * It seems a bit dumb to copyinstr() the host and path here and then
800 * bcopy() them in mountnfs(), but I wanted to detect errors before
801 * doing the sockargs() call because sockargs() allocates an mbuf and
802 * an error after that means that I have to release the mbuf.
806 nfs_mount(struct mount *mp)
808 struct nfs_args args = {
809 .version = NFS_ARGSVERSION,
811 .addrlen = sizeof (struct sockaddr_in),
812 .sotype = SOCK_STREAM,
816 .flags = NFSMNT_RESVPORT,
819 .readdirsize = NFS_READDIRSIZE,
821 .retrans = NFS_RETRANS,
822 .maxgrouplist = NFS_MAXGRPS,
823 .readahead = NFS_DEFRAHEAD,
824 .wcommitsize = 0, /* was: NQ_DEFLEASE */
825 .deadthresh = NFS_MAXDEADTHRESH, /* was: NQ_DEADTHRESH */
828 .acregmin = NFS_MINATTRTIMO,
829 .acregmax = NFS_MAXATTRTIMO,
830 .acdirmin = NFS_MINDIRATTRTIMO,
831 .acdirmax = NFS_MAXDIRATTRTIMO,
833 int error, ret, has_nfs_args_opt;
834 int has_addr_opt, has_fh_opt, has_hostname_opt;
835 struct sockaddr *nam;
839 u_char nfh[NFSX_V3FHMAX];
841 int nametimeo = NFS_DEFAULT_NAMETIMEO;
842 int negnametimeo = NFS_DEFAULT_NEGNAMETIMEO;
844 has_nfs_args_opt = 0;
847 has_hostname_opt = 0;
849 if (vfs_filteropt(mp->mnt_optnew, nfs_opts)) {
854 if ((mp->mnt_flag & (MNT_ROOTFS | MNT_UPDATE)) == MNT_ROOTFS) {
855 error = nfs_mountroot(mp);
860 * The old mount_nfs program passed the struct nfs_args
861 * from userspace to kernel. The new mount_nfs program
862 * passes string options via nmount() from userspace to kernel
863 * and we populate the struct nfs_args in the kernel.
865 if (vfs_getopt(mp->mnt_optnew, "nfs_args", NULL, NULL) == 0) {
866 error = vfs_copyopt(mp->mnt_optnew, "nfs_args", &args,
871 if (args.version != NFS_ARGSVERSION) {
872 error = EPROGMISMATCH;
875 has_nfs_args_opt = 1;
878 if (vfs_getopt(mp->mnt_optnew, "dumbtimer", NULL, NULL) == 0)
879 args.flags |= NFSMNT_DUMBTIMR;
880 if (vfs_getopt(mp->mnt_optnew, "noconn", NULL, NULL) == 0)
881 args.flags |= NFSMNT_NOCONN;
882 if (vfs_getopt(mp->mnt_optnew, "conn", NULL, NULL) == 0)
883 args.flags |= NFSMNT_NOCONN;
884 if (vfs_getopt(mp->mnt_optnew, "nolockd", NULL, NULL) == 0)
885 args.flags |= NFSMNT_NOLOCKD;
886 if (vfs_getopt(mp->mnt_optnew, "lockd", NULL, NULL) == 0)
887 args.flags &= ~NFSMNT_NOLOCKD;
888 if (vfs_getopt(mp->mnt_optnew, "intr", NULL, NULL) == 0)
889 args.flags |= NFSMNT_INT;
890 if (vfs_getopt(mp->mnt_optnew, "rdirplus", NULL, NULL) == 0)
891 args.flags |= NFSMNT_RDIRPLUS;
892 if (vfs_getopt(mp->mnt_optnew, "resvport", NULL, NULL) == 0)
893 args.flags |= NFSMNT_RESVPORT;
894 if (vfs_getopt(mp->mnt_optnew, "noresvport", NULL, NULL) == 0)
895 args.flags &= ~NFSMNT_RESVPORT;
896 if (vfs_getopt(mp->mnt_optnew, "soft", NULL, NULL) == 0)
897 args.flags |= NFSMNT_SOFT;
898 if (vfs_getopt(mp->mnt_optnew, "hard", NULL, NULL) == 0)
899 args.flags &= ~NFSMNT_SOFT;
900 if (vfs_getopt(mp->mnt_optnew, "mntudp", NULL, NULL) == 0)
901 args.sotype = SOCK_DGRAM;
902 if (vfs_getopt(mp->mnt_optnew, "udp", NULL, NULL) == 0)
903 args.sotype = SOCK_DGRAM;
904 if (vfs_getopt(mp->mnt_optnew, "tcp", NULL, NULL) == 0)
905 args.sotype = SOCK_STREAM;
906 if (vfs_getopt(mp->mnt_optnew, "nfsv3", NULL, NULL) == 0)
907 args.flags |= NFSMNT_NFSV3;
908 if (vfs_getopt(mp->mnt_optnew, "nocto", NULL, NULL) == 0)
909 args.flags |= NFSMNT_NOCTO;
910 if (vfs_getopt(mp->mnt_optnew, "readdirsize", (void **)&opt, NULL) == 0) {
912 vfs_mount_error(mp, "illegal readdirsize");
916 ret = sscanf(opt, "%d", &args.readdirsize);
917 if (ret != 1 || args.readdirsize <= 0) {
918 vfs_mount_error(mp, "illegal readdirsize: %s",
923 args.flags |= NFSMNT_READDIRSIZE;
925 if (vfs_getopt(mp->mnt_optnew, "readahead", (void **)&opt, NULL) == 0) {
927 vfs_mount_error(mp, "illegal readahead");
931 ret = sscanf(opt, "%d", &args.readahead);
932 if (ret != 1 || args.readahead <= 0) {
933 vfs_mount_error(mp, "illegal readahead: %s",
938 args.flags |= NFSMNT_READAHEAD;
940 if (vfs_getopt(mp->mnt_optnew, "wsize", (void **)&opt, NULL) == 0) {
942 vfs_mount_error(mp, "illegal wsize");
946 ret = sscanf(opt, "%d", &args.wsize);
947 if (ret != 1 || args.wsize <= 0) {
948 vfs_mount_error(mp, "illegal wsize: %s",
953 args.flags |= NFSMNT_WSIZE;
955 if (vfs_getopt(mp->mnt_optnew, "rsize", (void **)&opt, NULL) == 0) {
957 vfs_mount_error(mp, "illegal rsize");
961 ret = sscanf(opt, "%d", &args.rsize);
962 if (ret != 1 || args.rsize <= 0) {
963 vfs_mount_error(mp, "illegal wsize: %s",
968 args.flags |= NFSMNT_RSIZE;
970 if (vfs_getopt(mp->mnt_optnew, "retrans", (void **)&opt, NULL) == 0) {
972 vfs_mount_error(mp, "illegal retrans");
976 ret = sscanf(opt, "%d", &args.retrans);
977 if (ret != 1 || args.retrans <= 0) {
978 vfs_mount_error(mp, "illegal retrans: %s",
983 args.flags |= NFSMNT_RETRANS;
985 if (vfs_getopt(mp->mnt_optnew, "acregmin", (void **)&opt, NULL) == 0) {
986 ret = sscanf(opt, "%d", &args.acregmin);
987 if (ret != 1 || args.acregmin < 0) {
988 vfs_mount_error(mp, "illegal acregmin: %s",
993 args.flags |= NFSMNT_ACREGMIN;
995 if (vfs_getopt(mp->mnt_optnew, "acregmax", (void **)&opt, NULL) == 0) {
996 ret = sscanf(opt, "%d", &args.acregmax);
997 if (ret != 1 || args.acregmax < 0) {
998 vfs_mount_error(mp, "illegal acregmax: %s",
1003 args.flags |= NFSMNT_ACREGMAX;
1005 if (vfs_getopt(mp->mnt_optnew, "acdirmin", (void **)&opt, NULL) == 0) {
1006 ret = sscanf(opt, "%d", &args.acdirmin);
1007 if (ret != 1 || args.acdirmin < 0) {
1008 vfs_mount_error(mp, "illegal acdirmin: %s",
1013 args.flags |= NFSMNT_ACDIRMIN;
1015 if (vfs_getopt(mp->mnt_optnew, "acdirmax", (void **)&opt, NULL) == 0) {
1016 ret = sscanf(opt, "%d", &args.acdirmax);
1017 if (ret != 1 || args.acdirmax < 0) {
1018 vfs_mount_error(mp, "illegal acdirmax: %s",
1023 args.flags |= NFSMNT_ACDIRMAX;
1025 if (vfs_getopt(mp->mnt_optnew, "wcommitsize", (void **)&opt, NULL) == 0) {
1026 ret = sscanf(opt, "%d", &args.wcommitsize);
1027 if (ret != 1 || args.wcommitsize < 0) {
1028 vfs_mount_error(mp, "illegal wcommitsize: %s", opt);
1032 args.flags |= NFSMNT_WCOMMITSIZE;
1034 if (vfs_getopt(mp->mnt_optnew, "deadthresh", (void **)&opt, NULL) == 0) {
1035 ret = sscanf(opt, "%d", &args.deadthresh);
1036 if (ret != 1 || args.deadthresh <= 0) {
1037 vfs_mount_error(mp, "illegal deadthresh: %s",
1042 args.flags |= NFSMNT_DEADTHRESH;
1044 if (vfs_getopt(mp->mnt_optnew, "timeout", (void **)&opt, NULL) == 0) {
1045 ret = sscanf(opt, "%d", &args.timeo);
1046 if (ret != 1 || args.timeo <= 0) {
1047 vfs_mount_error(mp, "illegal timeout: %s",
1052 args.flags |= NFSMNT_TIMEO;
1054 if (vfs_getopt(mp->mnt_optnew, "maxgroups", (void **)&opt, NULL) == 0) {
1055 ret = sscanf(opt, "%d", &args.maxgrouplist);
1056 if (ret != 1 || args.maxgrouplist <= 0) {
1057 vfs_mount_error(mp, "illegal maxgroups: %s",
1062 args.flags |= NFSMNT_MAXGRPS;
1064 if (vfs_getopt(mp->mnt_optnew, "nametimeo", (void **)&opt, NULL) == 0) {
1065 ret = sscanf(opt, "%d", &nametimeo);
1066 if (ret != 1 || nametimeo < 0) {
1067 vfs_mount_error(mp, "illegal nametimeo: %s", opt);
1072 if (vfs_getopt(mp->mnt_optnew, "negnametimeo", (void **)&opt, NULL)
1074 ret = sscanf(opt, "%d", &negnametimeo);
1075 if (ret != 1 || negnametimeo < 0) {
1076 vfs_mount_error(mp, "illegal negnametimeo: %s",
1082 if (vfs_getopt(mp->mnt_optnew, "addr", (void **)&args.addr,
1083 &args.addrlen) == 0) {
1085 if (args.addrlen > SOCK_MAXADDRLEN) {
1086 error = ENAMETOOLONG;
1089 nam = malloc(args.addrlen, M_SONAME,
1091 bcopy(args.addr, nam, args.addrlen);
1092 nam->sa_len = args.addrlen;
1094 if (vfs_getopt(mp->mnt_optnew, "fh", (void **)&args.fh,
1095 &args.fhsize) == 0) {
1098 if (vfs_getopt(mp->mnt_optnew, "hostname", (void **)&args.hostname,
1100 has_hostname_opt = 1;
1102 if (args.hostname == NULL) {
1103 vfs_mount_error(mp, "Invalid hostname");
1107 if (args.fhsize < 0 || args.fhsize > NFSX_V3FHMAX) {
1108 vfs_mount_error(mp, "Bad file handle");
1113 if (mp->mnt_flag & MNT_UPDATE) {
1114 struct nfsmount *nmp = VFSTONFS(mp);
1122 * If a change from TCP->UDP is done and there are thread(s)
1123 * that have I/O RPC(s) in progress with a tranfer size
1124 * greater than NFS_MAXDGRAMDATA, those thread(s) will be
1125 * hung, retrying the RPC(s) forever. Usually these threads
1126 * will be seen doing an uninterruptible sleep on wait channel
1127 * "newnfsreq" (truncated to "newnfsre" by procstat).
1129 if (args.sotype == SOCK_DGRAM && nmp->nm_sotype == SOCK_STREAM)
1130 tprintf(curthread->td_proc, LOG_WARNING,
1131 "Warning: mount -u that changes TCP->UDP can result in hung threads\n");
1134 * When doing an update, we can't change from or to
1135 * v3, switch lockd strategies or change cookie translation
1137 args.flags = (args.flags &
1138 ~(NFSMNT_NFSV3 | NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/)) |
1140 (NFSMNT_NFSV3 | NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/));
1141 nfs_decode_args(mp, nmp, &args, NULL);
1146 * Make the nfs_ip_paranoia sysctl serve as the default connection
1147 * or no-connection mode for those protocols that support
1148 * no-connection mode (the flag will be cleared later for protocols
1149 * that do not support no-connection mode). This will allow a client
1150 * to receive replies from a different IP then the request was
1151 * sent to. Note: default value for nfs_ip_paranoia is 1 (paranoid),
1154 if (nfs_ip_paranoia == 0)
1155 args.flags |= NFSMNT_NOCONN;
1157 if (has_nfs_args_opt) {
1159 * In the 'nfs_args' case, the pointers in the args
1160 * structure are in userland - we copy them in here.
1163 error = copyin((caddr_t)args.fh, (caddr_t)nfh,
1170 if (!has_hostname_opt) {
1171 error = copyinstr(args.hostname, hst, MNAMELEN-1, &len);
1175 bzero(&hst[len], MNAMELEN - len);
1176 args.hostname = hst;
1178 if (!has_addr_opt) {
1179 /* sockargs() call must be after above copyin() calls */
1180 error = getsockaddr(&nam, (caddr_t)args.addr,
1186 } else if (has_addr_opt == 0) {
1187 vfs_mount_error(mp, "No server address");
1191 error = mountnfs(&args, mp, nam, args.hostname, &vp,
1192 curthread->td_ucred, nametimeo, negnametimeo);
1196 mp->mnt_kern_flag |= (MNTK_MPSAFE|MNTK_LOOKUP_SHARED);
1207 * It seems a bit dumb to copyinstr() the host and path here and then
1208 * bcopy() them in mountnfs(), but I wanted to detect errors before
1209 * doing the sockargs() call because sockargs() allocates an mbuf and
1210 * an error after that means that I have to release the mbuf.
1214 nfs_cmount(struct mntarg *ma, void *data, uint64_t flags)
1217 struct nfs_args args;
1219 error = copyin(data, &args, sizeof (struct nfs_args));
1223 ma = mount_arg(ma, "nfs_args", &args, sizeof args);
1225 error = kernel_mount(ma, flags);
1230 * Common code for mount and mountroot
1233 mountnfs(struct nfs_args *argp, struct mount *mp, struct sockaddr *nam,
1234 char *hst, struct vnode **vpp, struct ucred *cred, int nametimeo,
1237 struct nfsmount *nmp;
1242 if (mp->mnt_flag & MNT_UPDATE) {
1244 printf("%s: MNT_UPDATE is no longer handled here\n", __func__);
1245 free(nam, M_SONAME);
1248 nmp = uma_zalloc(nfsmount_zone, M_WAITOK);
1249 bzero((caddr_t)nmp, sizeof (struct nfsmount));
1250 TAILQ_INIT(&nmp->nm_bufq);
1252 nmp->nm_getinfo = nfs_getnlminfo;
1253 nmp->nm_vinvalbuf = nfs_vinvalbuf;
1256 nmp->nm_mountp = mp;
1257 mtx_init(&nmp->nm_mtx, "NFSmount lock", NULL, MTX_DEF);
1260 * V2 can only handle 32 bit filesizes. A 4GB-1 limit may be too
1261 * high, depending on whether we end up with negative offsets in
1262 * the client or server somewhere. 2GB-1 may be safer.
1264 * For V3, nfs_fsinfo will adjust this as necessary. Assume maximum
1265 * that we can handle until we find out otherwise.
1267 if ((argp->flags & NFSMNT_NFSV3) == 0)
1268 nmp->nm_maxfilesize = 0xffffffffLL;
1270 nmp->nm_maxfilesize = OFF_MAX;
1272 nmp->nm_timeo = NFS_TIMEO;
1273 nmp->nm_retry = NFS_RETRANS;
1274 if ((argp->flags & NFSMNT_NFSV3) && argp->sotype == SOCK_STREAM) {
1275 nmp->nm_wsize = nmp->nm_rsize = NFS_MAXDATA;
1277 nmp->nm_wsize = NFS_WSIZE;
1278 nmp->nm_rsize = NFS_RSIZE;
1280 nmp->nm_wcommitsize = hibufspace / (desiredvnodes / 1000);
1281 nmp->nm_readdirsize = NFS_READDIRSIZE;
1282 nmp->nm_numgrps = NFS_MAXGRPS;
1283 nmp->nm_readahead = NFS_DEFRAHEAD;
1284 nmp->nm_deadthresh = NFS_MAXDEADTHRESH;
1285 nmp->nm_nametimeo = nametimeo;
1286 nmp->nm_negnametimeo = negnametimeo;
1287 nmp->nm_tprintf_delay = nfs_tprintf_delay;
1288 if (nmp->nm_tprintf_delay < 0)
1289 nmp->nm_tprintf_delay = 0;
1290 nmp->nm_tprintf_initial_delay = nfs_tprintf_initial_delay;
1291 if (nmp->nm_tprintf_initial_delay < 0)
1292 nmp->nm_tprintf_initial_delay = 0;
1293 nmp->nm_fhsize = argp->fhsize;
1294 bcopy((caddr_t)argp->fh, (caddr_t)nmp->nm_fh, argp->fhsize);
1295 bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN);
1297 /* Set up the sockets and per-host congestion */
1298 nmp->nm_sotype = argp->sotype;
1299 nmp->nm_soproto = argp->proto;
1300 nmp->nm_rpcops = &nfs_rpcops;
1302 nfs_decode_args(mp, nmp, argp, hst);
1305 * For Connection based sockets (TCP,...) defer the connect until
1306 * the first request, in case the server is not responding.
1308 if (nmp->nm_sotype == SOCK_DGRAM &&
1309 (error = nfs_connect(nmp)))
1313 * This is silly, but it has to be set so that vinifod() works.
1314 * We do not want to do an nfs_statfs() here since we can get
1315 * stuck on a dead server and we are holding a lock on the mount
1318 mtx_lock(&nmp->nm_mtx);
1319 mp->mnt_stat.f_iosize = nfs_iosize(nmp);
1320 mtx_unlock(&nmp->nm_mtx);
1322 * A reference count is needed on the nfsnode representing the
1323 * remote root. If this object is not persistent, then backward
1324 * traversals of the mount point (i.e. "..") will not work if
1325 * the nfsnode gets flushed out of the cache. Ufs does not have
1326 * this problem, because one can identify root inodes by their
1327 * number == ROOTINO (2).
1329 error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np, LK_EXCLUSIVE);
1335 * Get file attributes and transfer parameters for the
1336 * mountpoint. This has the side effect of filling in
1337 * (*vpp)->v_type with the correct value.
1339 if (argp->flags & NFSMNT_NFSV3)
1340 nfs_fsinfo(nmp, *vpp, curthread->td_ucred, curthread);
1342 VOP_GETATTR(*vpp, &attrs, curthread->td_ucred);
1345 * Lose the lock but keep the ref.
1347 VOP_UNLOCK(*vpp, 0);
1351 nfs_disconnect(nmp);
1352 mtx_destroy(&nmp->nm_mtx);
1353 uma_zfree(nfsmount_zone, nmp);
1354 free(nam, M_SONAME);
1359 * unmount system call
1362 nfs_unmount(struct mount *mp, int mntflags)
1364 struct nfsmount *nmp;
1365 int error, flags = 0, i;
1367 if (mntflags & MNT_FORCE)
1368 flags |= FORCECLOSE;
1371 * Goes something like this..
1372 * - Call vflush() to clear out vnodes for this filesystem
1373 * - Close the socket
1374 * - Free up the data structures
1376 /* In the forced case, cancel any outstanding requests. */
1377 if (flags & FORCECLOSE) {
1378 error = nfs_nmcancelreqs(nmp);
1382 /* We hold 1 extra ref on the root vnode; see comment in mountnfs(). */
1383 error = vflush(mp, 1, flags, curthread);
1388 * We are now committed to the unmount.
1390 /* Make sure no nfsiods are assigned to this mount. */
1391 mtx_lock(&nfs_iod_mtx);
1392 for (i = 0; i < NFS_MAXASYNCDAEMON; i++)
1393 if (nfs_iodmount[i] == nmp) {
1394 nfs_iodwant[i] = NFSIOD_AVAILABLE;
1395 nfs_iodmount[i] = NULL;
1397 mtx_unlock(&nfs_iod_mtx);
1398 nfs_disconnect(nmp);
1399 free(nmp->nm_nam, M_SONAME);
1401 mtx_destroy(&nmp->nm_mtx);
1402 uma_zfree(nfsmount_zone, nmp);
1408 * Return root of a filesystem
1411 nfs_root(struct mount *mp, int flags, struct vnode **vpp)
1414 struct nfsmount *nmp;
1419 error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np, flags);
1424 * Get transfer parameters and attributes for root vnode once.
1426 mtx_lock(&nmp->nm_mtx);
1427 if ((nmp->nm_state & NFSSTA_GOTFSINFO) == 0 &&
1428 (nmp->nm_flag & NFSMNT_NFSV3)) {
1429 mtx_unlock(&nmp->nm_mtx);
1430 nfs_fsinfo(nmp, vp, curthread->td_ucred, curthread);
1432 mtx_unlock(&nmp->nm_mtx);
1433 if (vp->v_type == VNON)
1435 vp->v_vflag |= VV_ROOT;
1441 * Flush out the buffer cache
1445 nfs_sync(struct mount *mp, int waitfor)
1447 struct vnode *vp, *mvp;
1449 int error, allerror = 0;
1455 * If a forced dismount is in progress, return from here so that
1456 * the umount(2) syscall doesn't get stuck in VFS_SYNC() before
1457 * calling VFS_UNMOUNT().
1459 if ((mp->mnt_kern_flag & MNTK_UNMOUNTF) != 0) {
1466 * Force stale buffer cache information to be flushed.
1469 MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
1470 /* XXX Racy bv_cnt check. */
1471 if (VOP_ISLOCKED(vp) || vp->v_bufobj.bo_dirty.bv_cnt == 0 ||
1472 waitfor == MNT_LAZY) {
1476 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
1477 MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
1480 error = VOP_FSYNC(vp, waitfor, td);
1490 nfs_sysctl(struct mount *mp, fsctlop_t op, struct sysctl_req *req)
1492 struct nfsmount *nmp = VFSTONFS(mp);
1496 bzero(&vq, sizeof(vq));
1499 case VFS_CTL_NOLOCKS:
1500 val = (nmp->nm_flag & NFSMNT_NOLOCKS) ? 1 : 0;
1501 if (req->oldptr != NULL) {
1502 error = SYSCTL_OUT(req, &val, sizeof(val));
1506 if (req->newptr != NULL) {
1507 error = SYSCTL_IN(req, &val, sizeof(val));
1511 nmp->nm_flag |= NFSMNT_NOLOCKS;
1513 nmp->nm_flag &= ~NFSMNT_NOLOCKS;
1518 mtx_lock(&nmp->nm_mtx);
1519 if (nmp->nm_state & NFSSTA_TIMEO)
1520 vq.vq_flags |= VQ_NOTRESP;
1521 mtx_unlock(&nmp->nm_mtx);
1523 if (!(nmp->nm_flag & NFSMNT_NOLOCKS) &&
1524 (nmp->nm_state & NFSSTA_LOCKTIMEO))
1525 vq.vq_flags |= VQ_NOTRESPLOCK;
1527 error = SYSCTL_OUT(req, &vq, sizeof(vq));
1530 if (req->oldptr != NULL) {
1531 error = SYSCTL_OUT(req, &nmp->nm_tprintf_initial_delay,
1532 sizeof(nmp->nm_tprintf_initial_delay));
1536 if (req->newptr != NULL) {
1537 error = vfs_suser(mp, req->td);
1540 error = SYSCTL_IN(req, &nmp->nm_tprintf_initial_delay,
1541 sizeof(nmp->nm_tprintf_initial_delay));
1544 if (nmp->nm_tprintf_initial_delay < 0)
1545 nmp->nm_tprintf_initial_delay = 0;
1555 * Extract the information needed by the nlm from the nfs vnode.
1558 nfs_getnlminfo(struct vnode *vp, uint8_t *fhp, size_t *fhlenp,
1559 struct sockaddr_storage *sp, int *is_v3p, off_t *sizep,
1560 struct timeval *timeop)
1562 struct nfsmount *nmp;
1563 struct nfsnode *np = VTONFS(vp);
1565 nmp = VFSTONFS(vp->v_mount);
1567 *fhlenp = (size_t)np->n_fhsize;
1569 bcopy(np->n_fhp, fhp, np->n_fhsize);
1571 bcopy(nmp->nm_nam, sp, min(nmp->nm_nam->sa_len, sizeof(*sp)));
1573 *is_v3p = NFS_ISV3(vp);
1575 *sizep = np->n_size;
1576 if (timeop != NULL) {
1577 timeop->tv_sec = nmp->nm_timeo / NFS_HZ;
1578 timeop->tv_usec = (nmp->nm_timeo % NFS_HZ) * (1000000 / NFS_HZ);