1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1989, 1993, 1995 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Rick Macklem at The University of Guelph. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * from nfs_vfsops.c 8.12 (Berkeley) 5/20/95 35 */ 36 37 #include <sys/cdefs.h> 38 __FBSDID("$FreeBSD$"); 39 40 #include "opt_bootp.h" 41 #include "opt_nfsroot.h" 42 #include "opt_kern_tls.h" 43 44 #include <sys/param.h> 45 #include <sys/systm.h> 46 #include <sys/kernel.h> 47 #include <sys/bio.h> 48 #include <sys/buf.h> 49 #include <sys/clock.h> 50 #include <sys/jail.h> 51 #include <sys/limits.h> 52 #include <sys/lock.h> 53 #include <sys/malloc.h> 54 #include <sys/mbuf.h> 55 #include <sys/module.h> 56 #include <sys/mount.h> 57 #include <sys/proc.h> 58 #include <sys/socket.h> 59 #include <sys/socketvar.h> 60 #include <sys/sockio.h> 61 #include <sys/sysctl.h> 62 #include <sys/vnode.h> 63 #include <sys/signalvar.h> 64 65 #include <vm/vm.h> 66 #include <vm/vm_extern.h> 67 #include <vm/uma.h> 68 69 #include <net/if.h> 70 #include <net/route.h> 71 #include <net/route/route_ctl.h> 72 #include <netinet/in.h> 73 74 #include <fs/nfs/nfsport.h> 75 #include <fs/nfsclient/nfsnode.h> 76 #include <fs/nfsclient/nfsmount.h> 77 #include <fs/nfsclient/nfs.h> 78 #include <nfs/nfsdiskless.h> 79 80 #include <rpc/rpcsec_tls.h> 81 82 FEATURE(nfscl, "NFSv4 client"); 83 84 extern int nfscl_ticks; 85 extern struct timeval nfsboottime; 86 extern int nfsrv_useacl; 87 extern int nfscl_debuglevel; 88 extern enum nfsiod_state ncl_iodwant[NFS_MAXASYNCDAEMON]; 89 extern struct nfsmount *ncl_iodmount[NFS_MAXASYNCDAEMON]; 90 extern struct mtx ncl_iod_mutex; 91 NFSCLSTATEMUTEX; 92 extern struct mtx nfsrv_dslock_mtx; 93 94 MALLOC_DEFINE(M_NEWNFSREQ, "newnfsclient_req", "NFS request header"); 95 MALLOC_DEFINE(M_NEWNFSMNT, "newnfsmnt", "NFS mount struct"); 96 97 SYSCTL_DECL(_vfs_nfs); 98 static int nfs_ip_paranoia = 1; 99 SYSCTL_INT(_vfs_nfs, OID_AUTO, nfs_ip_paranoia, CTLFLAG_RW, 100 &nfs_ip_paranoia, 0, ""); 101 static int nfs_tprintf_initial_delay = NFS_TPRINTF_INITIAL_DELAY; 102 SYSCTL_INT(_vfs_nfs, NFS_TPRINTF_INITIAL_DELAY, 103 downdelayinitial, CTLFLAG_RW, &nfs_tprintf_initial_delay, 0, ""); 104 /* how long between console messages "nfs server foo not responding" */ 105 static int nfs_tprintf_delay = NFS_TPRINTF_DELAY; 106 SYSCTL_INT(_vfs_nfs, NFS_TPRINTF_DELAY, 107 downdelayinterval, CTLFLAG_RW, &nfs_tprintf_delay, 0, ""); 108 #ifdef NFS_DEBUG 109 int nfs_debug; 110 SYSCTL_INT(_vfs_nfs, OID_AUTO, debug, CTLFLAG_RW, &nfs_debug, 0, 111 "Toggle debug flag"); 112 #endif 113 114 static int nfs_mountroot(struct mount *); 115 static void nfs_sec_name(char *, int *); 116 static void nfs_decode_args(struct mount *mp, struct nfsmount *nmp, 117 struct nfs_args *argp, const char *, struct ucred *, 118 struct thread *); 119 static int mountnfs(struct nfs_args *, struct mount *, 120 struct sockaddr *, char *, u_char *, int, u_char *, int, 121 u_char *, int, struct vnode **, struct ucred *, 122 struct thread *, int, int, int, uint32_t); 123 static void nfs_getnlminfo(struct vnode *, uint8_t *, size_t *, 124 struct sockaddr_storage *, int *, off_t *, 125 struct timeval *); 126 static vfs_mount_t nfs_mount; 127 static vfs_cmount_t nfs_cmount; 128 static vfs_unmount_t nfs_unmount; 129 static vfs_root_t nfs_root; 130 static vfs_statfs_t nfs_statfs; 131 static vfs_sync_t nfs_sync; 132 static vfs_sysctl_t nfs_sysctl; 133 static vfs_purge_t nfs_purge; 134 135 /* 136 * nfs vfs operations. 137 */ 138 static struct vfsops nfs_vfsops = { 139 .vfs_init = ncl_init, 140 .vfs_mount = nfs_mount, 141 .vfs_cmount = nfs_cmount, 142 .vfs_root = vfs_cache_root, 143 .vfs_cachedroot = nfs_root, 144 .vfs_statfs = nfs_statfs, 145 .vfs_sync = nfs_sync, 146 .vfs_uninit = ncl_uninit, 147 .vfs_unmount = nfs_unmount, 148 .vfs_sysctl = nfs_sysctl, 149 .vfs_purge = nfs_purge, 150 }; 151 VFS_SET(nfs_vfsops, nfs, VFCF_NETWORK | VFCF_SBDRY); 152 153 /* So that loader and kldload(2) can find us, wherever we are.. */ 154 MODULE_VERSION(nfs, 1); 155 MODULE_DEPEND(nfs, nfscommon, 1, 1, 1); 156 MODULE_DEPEND(nfs, krpc, 1, 1, 1); 157 MODULE_DEPEND(nfs, nfssvc, 1, 1, 1); 158 159 /* 160 * This structure is now defined in sys/nfs/nfs_diskless.c so that it 161 * can be shared by both NFS clients. It is declared here so that it 162 * will be defined for kernels built without NFS_ROOT, although it 163 * isn't used in that case. 164 */ 165 #if !defined(NFS_ROOT) 166 struct nfs_diskless nfs_diskless = { { { 0 } } }; 167 struct nfsv3_diskless nfsv3_diskless = { { { 0 } } }; 168 int nfs_diskless_valid = 0; 169 #endif 170 171 SYSCTL_INT(_vfs_nfs, OID_AUTO, diskless_valid, CTLFLAG_RD, 172 &nfs_diskless_valid, 0, 173 "Has the diskless struct been filled correctly"); 174 175 SYSCTL_STRING(_vfs_nfs, OID_AUTO, diskless_rootpath, CTLFLAG_RD, 176 nfsv3_diskless.root_hostnam, 0, "Path to nfs root"); 177 178 SYSCTL_OPAQUE(_vfs_nfs, OID_AUTO, diskless_rootaddr, CTLFLAG_RD, 179 &nfsv3_diskless.root_saddr, sizeof(nfsv3_diskless.root_saddr), 180 "%Ssockaddr_in", "Diskless root nfs address"); 181 182 void newnfsargs_ntoh(struct nfs_args *); 183 static int nfs_mountdiskless(char *, 184 struct sockaddr_in *, struct nfs_args *, 185 struct thread *, struct vnode **, struct mount *); 186 static void nfs_convert_diskless(void); 187 static void nfs_convert_oargs(struct nfs_args *args, 188 struct onfs_args *oargs); 189 190 int 191 newnfs_iosize(struct nfsmount *nmp) 192 { 193 int iosize, maxio; 194 195 /* First, set the upper limit for iosize */ 196 if (nmp->nm_flag & NFSMNT_NFSV4) { 197 maxio = NFS_MAXBSIZE; 198 } else if (nmp->nm_flag & NFSMNT_NFSV3) { 199 if (nmp->nm_sotype == SOCK_DGRAM) 200 maxio = NFS_MAXDGRAMDATA; 201 else 202 maxio = NFS_MAXBSIZE; 203 } else { 204 maxio = NFS_V2MAXDATA; 205 } 206 if (nmp->nm_rsize > maxio || nmp->nm_rsize == 0) 207 nmp->nm_rsize = maxio; 208 if (nmp->nm_rsize > NFS_MAXBSIZE) 209 nmp->nm_rsize = NFS_MAXBSIZE; 210 if (nmp->nm_readdirsize > maxio || nmp->nm_readdirsize == 0) 211 nmp->nm_readdirsize = maxio; 212 if (nmp->nm_readdirsize > nmp->nm_rsize) 213 nmp->nm_readdirsize = nmp->nm_rsize; 214 if (nmp->nm_wsize > maxio || nmp->nm_wsize == 0) 215 nmp->nm_wsize = maxio; 216 if (nmp->nm_wsize > NFS_MAXBSIZE) 217 nmp->nm_wsize = NFS_MAXBSIZE; 218 219 /* 220 * Calculate the size used for io buffers. Use the larger 221 * of the two sizes to minimise nfs requests but make sure 222 * that it is at least one VM page to avoid wasting buffer 223 * space. It must also be at least NFS_DIRBLKSIZ, since 224 * that is the buffer size used for directories. 225 */ 226 iosize = imax(nmp->nm_rsize, nmp->nm_wsize); 227 iosize = imax(iosize, PAGE_SIZE); 228 iosize = imax(iosize, NFS_DIRBLKSIZ); 229 nmp->nm_mountp->mnt_stat.f_iosize = iosize; 230 return (iosize); 231 } 232 233 static void 234 nfs_convert_oargs(struct nfs_args *args, struct onfs_args *oargs) 235 { 236 237 args->version = NFS_ARGSVERSION; 238 args->addr = oargs->addr; 239 args->addrlen = oargs->addrlen; 240 args->sotype = oargs->sotype; 241 args->proto = oargs->proto; 242 args->fh = oargs->fh; 243 args->fhsize = oargs->fhsize; 244 args->flags = oargs->flags; 245 args->wsize = oargs->wsize; 246 args->rsize = oargs->rsize; 247 args->readdirsize = oargs->readdirsize; 248 args->timeo = oargs->timeo; 249 args->retrans = oargs->retrans; 250 args->readahead = oargs->readahead; 251 args->hostname = oargs->hostname; 252 } 253 254 static void 255 nfs_convert_diskless(void) 256 { 257 258 bcopy(&nfs_diskless.myif, &nfsv3_diskless.myif, 259 sizeof(struct ifaliasreq)); 260 bcopy(&nfs_diskless.mygateway, &nfsv3_diskless.mygateway, 261 sizeof(struct sockaddr_in)); 262 nfs_convert_oargs(&nfsv3_diskless.root_args,&nfs_diskless.root_args); 263 if (nfsv3_diskless.root_args.flags & NFSMNT_NFSV3) { 264 nfsv3_diskless.root_fhsize = NFSX_MYFH; 265 bcopy(nfs_diskless.root_fh, nfsv3_diskless.root_fh, NFSX_MYFH); 266 } else { 267 nfsv3_diskless.root_fhsize = NFSX_V2FH; 268 bcopy(nfs_diskless.root_fh, nfsv3_diskless.root_fh, NFSX_V2FH); 269 } 270 bcopy(&nfs_diskless.root_saddr,&nfsv3_diskless.root_saddr, 271 sizeof(struct sockaddr_in)); 272 bcopy(nfs_diskless.root_hostnam, nfsv3_diskless.root_hostnam, MNAMELEN); 273 nfsv3_diskless.root_time = nfs_diskless.root_time; 274 bcopy(nfs_diskless.my_hostnam, nfsv3_diskless.my_hostnam, 275 MAXHOSTNAMELEN); 276 nfs_diskless_valid = 3; 277 } 278 279 /* 280 * nfs statfs call 281 */ 282 static int 283 nfs_statfs(struct mount *mp, struct statfs *sbp) 284 { 285 struct vnode *vp; 286 struct thread *td; 287 struct nfsmount *nmp = VFSTONFS(mp); 288 struct nfsvattr nfsva; 289 struct nfsfsinfo fs; 290 struct nfsstatfs sb; 291 int error = 0, attrflag, gotfsinfo = 0, ret; 292 struct nfsnode *np; 293 294 td = curthread; 295 296 error = vfs_busy(mp, MBF_NOWAIT); 297 if (error) 298 return (error); 299 error = ncl_nget(mp, nmp->nm_fh, nmp->nm_fhsize, &np, LK_EXCLUSIVE); 300 if (error) { 301 vfs_unbusy(mp); 302 return (error); 303 } 304 vp = NFSTOV(np); 305 mtx_lock(&nmp->nm_mtx); 306 if (NFSHASNFSV3(nmp) && !NFSHASGOTFSINFO(nmp)) { 307 mtx_unlock(&nmp->nm_mtx); 308 error = nfsrpc_fsinfo(vp, &fs, td->td_ucred, td, &nfsva, 309 &attrflag, NULL); 310 if (!error) 311 gotfsinfo = 1; 312 } else 313 mtx_unlock(&nmp->nm_mtx); 314 if (!error) 315 error = nfsrpc_statfs(vp, &sb, &fs, td->td_ucred, td, &nfsva, 316 &attrflag, NULL); 317 if (error != 0) 318 NFSCL_DEBUG(2, "statfs=%d\n", error); 319 if (attrflag == 0) { 320 ret = nfsrpc_getattrnovp(nmp, nmp->nm_fh, nmp->nm_fhsize, 1, 321 td->td_ucred, td, &nfsva, NULL, NULL); 322 if (ret) { 323 /* 324 * Just set default values to get things going. 325 */ 326 NFSBZERO((caddr_t)&nfsva, sizeof (struct nfsvattr)); 327 nfsva.na_vattr.va_type = VDIR; 328 nfsva.na_vattr.va_mode = 0777; 329 nfsva.na_vattr.va_nlink = 100; 330 nfsva.na_vattr.va_uid = (uid_t)0; 331 nfsva.na_vattr.va_gid = (gid_t)0; 332 nfsva.na_vattr.va_fileid = 2; 333 nfsva.na_vattr.va_gen = 1; 334 nfsva.na_vattr.va_blocksize = NFS_FABLKSIZE; 335 nfsva.na_vattr.va_size = 512 * 1024; 336 } 337 } 338 (void) nfscl_loadattrcache(&vp, &nfsva, NULL, NULL, 0, 1); 339 if (!error) { 340 mtx_lock(&nmp->nm_mtx); 341 if (gotfsinfo || (nmp->nm_flag & NFSMNT_NFSV4)) 342 nfscl_loadfsinfo(nmp, &fs); 343 nfscl_loadsbinfo(nmp, &sb, sbp); 344 sbp->f_iosize = newnfs_iosize(nmp); 345 mtx_unlock(&nmp->nm_mtx); 346 if (sbp != &mp->mnt_stat) { 347 bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN); 348 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN); 349 } 350 strncpy(&sbp->f_fstypename[0], mp->mnt_vfc->vfc_name, MFSNAMELEN); 351 } else if (NFS_ISV4(vp)) { 352 error = nfscl_maperr(td, error, (uid_t)0, (gid_t)0); 353 } 354 vput(vp); 355 vfs_unbusy(mp); 356 return (error); 357 } 358 359 /* 360 * nfs version 3 fsinfo rpc call 361 */ 362 int 363 ncl_fsinfo(struct nfsmount *nmp, struct vnode *vp, struct ucred *cred, 364 struct thread *td) 365 { 366 struct nfsfsinfo fs; 367 struct nfsvattr nfsva; 368 int error, attrflag; 369 370 error = nfsrpc_fsinfo(vp, &fs, cred, td, &nfsva, &attrflag, NULL); 371 if (!error) { 372 if (attrflag) 373 (void) nfscl_loadattrcache(&vp, &nfsva, NULL, NULL, 0, 374 1); 375 mtx_lock(&nmp->nm_mtx); 376 nfscl_loadfsinfo(nmp, &fs); 377 mtx_unlock(&nmp->nm_mtx); 378 } 379 return (error); 380 } 381 382 /* 383 * Mount a remote root fs via. nfs. This depends on the info in the 384 * nfs_diskless structure that has been filled in properly by some primary 385 * bootstrap. 386 * It goes something like this: 387 * - do enough of "ifconfig" by calling ifioctl() so that the system 388 * can talk to the server 389 * - If nfs_diskless.mygateway is filled in, use that address as 390 * a default gateway. 391 * - build the rootfs mount point and call mountnfs() to do the rest. 392 * 393 * It is assumed to be safe to read, modify, and write the nfsv3_diskless 394 * structure, as well as other global NFS client variables here, as 395 * nfs_mountroot() will be called once in the boot before any other NFS 396 * client activity occurs. 397 */ 398 static int 399 nfs_mountroot(struct mount *mp) 400 { 401 struct thread *td = curthread; 402 struct nfsv3_diskless *nd = &nfsv3_diskless; 403 struct socket *so; 404 struct vnode *vp; 405 struct ifreq ir; 406 int error; 407 u_long l; 408 char buf[128]; 409 char *cp; 410 411 #if defined(BOOTP_NFSROOT) && defined(BOOTP) 412 bootpc_init(); /* use bootp to get nfs_diskless filled in */ 413 #elif defined(NFS_ROOT) 414 nfs_setup_diskless(); 415 #endif 416 417 if (nfs_diskless_valid == 0) 418 return (-1); 419 if (nfs_diskless_valid == 1) 420 nfs_convert_diskless(); 421 422 /* 423 * Do enough of ifconfig(8) so that the critical net interface can 424 * talk to the server. 425 */ 426 error = socreate(nd->myif.ifra_addr.sa_family, &so, nd->root_args.sotype, 0, 427 td->td_ucred, td); 428 if (error) 429 panic("nfs_mountroot: socreate(%04x): %d", 430 nd->myif.ifra_addr.sa_family, error); 431 432 #if 0 /* XXX Bad idea */ 433 /* 434 * We might not have been told the right interface, so we pass 435 * over the first ten interfaces of the same kind, until we get 436 * one of them configured. 437 */ 438 439 for (i = strlen(nd->myif.ifra_name) - 1; 440 nd->myif.ifra_name[i] >= '0' && 441 nd->myif.ifra_name[i] <= '9'; 442 nd->myif.ifra_name[i] ++) { 443 error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td); 444 if(!error) 445 break; 446 } 447 #endif 448 error = ifioctl(so, SIOCAIFADDR, (caddr_t)&nd->myif, td); 449 if (error) 450 panic("nfs_mountroot: SIOCAIFADDR: %d", error); 451 if ((cp = kern_getenv("boot.netif.mtu")) != NULL) { 452 ir.ifr_mtu = strtol(cp, NULL, 10); 453 bcopy(nd->myif.ifra_name, ir.ifr_name, IFNAMSIZ); 454 freeenv(cp); 455 error = ifioctl(so, SIOCSIFMTU, (caddr_t)&ir, td); 456 if (error) 457 printf("nfs_mountroot: SIOCSIFMTU: %d", error); 458 } 459 soclose(so); 460 461 /* 462 * If the gateway field is filled in, set it as the default route. 463 * Note that pxeboot will set a default route of 0 if the route 464 * is not set by the DHCP server. Check also for a value of 0 465 * to avoid panicking inappropriately in that situation. 466 */ 467 if (nd->mygateway.sin_len != 0 && 468 nd->mygateway.sin_addr.s_addr != 0) { 469 struct sockaddr_in mask, sin; 470 struct epoch_tracker et; 471 struct rt_addrinfo info; 472 struct rib_cmd_info rc; 473 474 bzero((caddr_t)&mask, sizeof(mask)); 475 sin = mask; 476 sin.sin_family = AF_INET; 477 sin.sin_len = sizeof(sin); 478 /* XXX MRT use table 0 for this sort of thing */ 479 NET_EPOCH_ENTER(et); 480 CURVNET_SET(TD_TO_VNET(td)); 481 482 bzero((caddr_t)&info, sizeof(info)); 483 info.rti_flags = RTF_UP | RTF_GATEWAY; 484 info.rti_info[RTAX_DST] = (struct sockaddr *)&sin; 485 info.rti_info[RTAX_GATEWAY] = (struct sockaddr *)&nd->mygateway; 486 info.rti_info[RTAX_NETMASK] = (struct sockaddr *)&mask; 487 488 error = rib_action(RT_DEFAULT_FIB, RTM_ADD, &info, &rc); 489 CURVNET_RESTORE(); 490 NET_EPOCH_EXIT(et); 491 if (error) 492 panic("nfs_mountroot: RTM_ADD: %d", error); 493 } 494 495 /* 496 * Create the rootfs mount point. 497 */ 498 nd->root_args.fh = nd->root_fh; 499 nd->root_args.fhsize = nd->root_fhsize; 500 l = ntohl(nd->root_saddr.sin_addr.s_addr); 501 snprintf(buf, sizeof(buf), "%ld.%ld.%ld.%ld:%s", 502 (l >> 24) & 0xff, (l >> 16) & 0xff, 503 (l >> 8) & 0xff, (l >> 0) & 0xff, nd->root_hostnam); 504 printf("NFS ROOT: %s\n", buf); 505 nd->root_args.hostname = buf; 506 if ((error = nfs_mountdiskless(buf, 507 &nd->root_saddr, &nd->root_args, td, &vp, mp)) != 0) { 508 return (error); 509 } 510 511 /* 512 * This is not really an nfs issue, but it is much easier to 513 * set hostname here and then let the "/etc/rc.xxx" files 514 * mount the right /var based upon its preset value. 515 */ 516 mtx_lock(&prison0.pr_mtx); 517 strlcpy(prison0.pr_hostname, nd->my_hostnam, 518 sizeof(prison0.pr_hostname)); 519 mtx_unlock(&prison0.pr_mtx); 520 inittodr(ntohl(nd->root_time)); 521 return (0); 522 } 523 524 /* 525 * Internal version of mount system call for diskless setup. 526 */ 527 static int 528 nfs_mountdiskless(char *path, 529 struct sockaddr_in *sin, struct nfs_args *args, struct thread *td, 530 struct vnode **vpp, struct mount *mp) 531 { 532 struct sockaddr *nam; 533 int dirlen, error; 534 char *dirpath; 535 536 /* 537 * Find the directory path in "path", which also has the server's 538 * name/ip address in it. 539 */ 540 dirpath = strchr(path, ':'); 541 if (dirpath != NULL) 542 dirlen = strlen(++dirpath); 543 else 544 dirlen = 0; 545 nam = sodupsockaddr((struct sockaddr *)sin, M_WAITOK); 546 if ((error = mountnfs(args, mp, nam, path, NULL, 0, dirpath, dirlen, 547 NULL, 0, vpp, td->td_ucred, td, NFS_DEFAULT_NAMETIMEO, 548 NFS_DEFAULT_NEGNAMETIMEO, 0, 0)) != 0) { 549 printf("nfs_mountroot: mount %s on /: %d\n", path, error); 550 return (error); 551 } 552 return (0); 553 } 554 555 static void 556 nfs_sec_name(char *sec, int *flagsp) 557 { 558 if (!strcmp(sec, "krb5")) 559 *flagsp |= NFSMNT_KERB; 560 else if (!strcmp(sec, "krb5i")) 561 *flagsp |= (NFSMNT_KERB | NFSMNT_INTEGRITY); 562 else if (!strcmp(sec, "krb5p")) 563 *flagsp |= (NFSMNT_KERB | NFSMNT_PRIVACY); 564 } 565 566 static void 567 nfs_decode_args(struct mount *mp, struct nfsmount *nmp, struct nfs_args *argp, 568 const char *hostname, struct ucred *cred, struct thread *td) 569 { 570 int adjsock; 571 char *p; 572 573 /* 574 * Set read-only flag if requested; otherwise, clear it if this is 575 * an update. If this is not an update, then either the read-only 576 * flag is already clear, or this is a root mount and it was set 577 * intentionally at some previous point. 578 */ 579 if (vfs_getopt(mp->mnt_optnew, "ro", NULL, NULL) == 0) { 580 MNT_ILOCK(mp); 581 mp->mnt_flag |= MNT_RDONLY; 582 MNT_IUNLOCK(mp); 583 } else if (mp->mnt_flag & MNT_UPDATE) { 584 MNT_ILOCK(mp); 585 mp->mnt_flag &= ~MNT_RDONLY; 586 MNT_IUNLOCK(mp); 587 } 588 589 /* 590 * Silently clear NFSMNT_NOCONN if it's a TCP mount, it makes 591 * no sense in that context. Also, set up appropriate retransmit 592 * and soft timeout behavior. 593 */ 594 if (argp->sotype == SOCK_STREAM) { 595 nmp->nm_flag &= ~NFSMNT_NOCONN; 596 nmp->nm_timeo = NFS_MAXTIMEO; 597 if ((argp->flags & NFSMNT_NFSV4) != 0) 598 nmp->nm_retry = INT_MAX; 599 else 600 nmp->nm_retry = NFS_RETRANS_TCP; 601 } 602 603 /* Also clear RDIRPLUS if NFSv2, it crashes some servers */ 604 if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0) { 605 argp->flags &= ~NFSMNT_RDIRPLUS; 606 nmp->nm_flag &= ~NFSMNT_RDIRPLUS; 607 } 608 609 /* Clear ONEOPENOWN for NFSv2, 3 and 4.0. */ 610 if (nmp->nm_minorvers == 0) { 611 argp->flags &= ~NFSMNT_ONEOPENOWN; 612 nmp->nm_flag &= ~NFSMNT_ONEOPENOWN; 613 } 614 615 /* Re-bind if rsrvd port requested and wasn't on one */ 616 adjsock = !(nmp->nm_flag & NFSMNT_RESVPORT) 617 && (argp->flags & NFSMNT_RESVPORT); 618 /* Also re-bind if we're switching to/from a connected UDP socket */ 619 adjsock |= ((nmp->nm_flag & NFSMNT_NOCONN) != 620 (argp->flags & NFSMNT_NOCONN)); 621 622 /* Update flags atomically. Don't change the lock bits. */ 623 nmp->nm_flag = argp->flags | nmp->nm_flag; 624 625 if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) { 626 nmp->nm_timeo = (argp->timeo * NFS_HZ + 5) / 10; 627 if (nmp->nm_timeo < NFS_MINTIMEO) 628 nmp->nm_timeo = NFS_MINTIMEO; 629 else if (nmp->nm_timeo > NFS_MAXTIMEO) 630 nmp->nm_timeo = NFS_MAXTIMEO; 631 } 632 633 if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) { 634 nmp->nm_retry = argp->retrans; 635 if (nmp->nm_retry > NFS_MAXREXMIT) 636 nmp->nm_retry = NFS_MAXREXMIT; 637 } 638 639 if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) { 640 nmp->nm_wsize = argp->wsize; 641 /* 642 * Clip at the power of 2 below the size. There is an 643 * issue (not isolated) that causes intermittent page 644 * faults if this is not done. 645 */ 646 if (nmp->nm_wsize > NFS_FABLKSIZE) 647 nmp->nm_wsize = 1 << (fls(nmp->nm_wsize) - 1); 648 else 649 nmp->nm_wsize = NFS_FABLKSIZE; 650 } 651 652 if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) { 653 nmp->nm_rsize = argp->rsize; 654 /* 655 * Clip at the power of 2 below the size. There is an 656 * issue (not isolated) that causes intermittent page 657 * faults if this is not done. 658 */ 659 if (nmp->nm_rsize > NFS_FABLKSIZE) 660 nmp->nm_rsize = 1 << (fls(nmp->nm_rsize) - 1); 661 else 662 nmp->nm_rsize = NFS_FABLKSIZE; 663 } 664 665 if ((argp->flags & NFSMNT_READDIRSIZE) && argp->readdirsize > 0) { 666 nmp->nm_readdirsize = argp->readdirsize; 667 } 668 669 if ((argp->flags & NFSMNT_ACREGMIN) && argp->acregmin >= 0) 670 nmp->nm_acregmin = argp->acregmin; 671 else 672 nmp->nm_acregmin = NFS_MINATTRTIMO; 673 if ((argp->flags & NFSMNT_ACREGMAX) && argp->acregmax >= 0) 674 nmp->nm_acregmax = argp->acregmax; 675 else 676 nmp->nm_acregmax = NFS_MAXATTRTIMO; 677 if ((argp->flags & NFSMNT_ACDIRMIN) && argp->acdirmin >= 0) 678 nmp->nm_acdirmin = argp->acdirmin; 679 else 680 nmp->nm_acdirmin = NFS_MINDIRATTRTIMO; 681 if ((argp->flags & NFSMNT_ACDIRMAX) && argp->acdirmax >= 0) 682 nmp->nm_acdirmax = argp->acdirmax; 683 else 684 nmp->nm_acdirmax = NFS_MAXDIRATTRTIMO; 685 if (nmp->nm_acdirmin > nmp->nm_acdirmax) 686 nmp->nm_acdirmin = nmp->nm_acdirmax; 687 if (nmp->nm_acregmin > nmp->nm_acregmax) 688 nmp->nm_acregmin = nmp->nm_acregmax; 689 690 if ((argp->flags & NFSMNT_READAHEAD) && argp->readahead >= 0) { 691 if (argp->readahead <= NFS_MAXRAHEAD) 692 nmp->nm_readahead = argp->readahead; 693 else 694 nmp->nm_readahead = NFS_MAXRAHEAD; 695 } 696 if ((argp->flags & NFSMNT_WCOMMITSIZE) && argp->wcommitsize >= 0) { 697 if (argp->wcommitsize < nmp->nm_wsize) 698 nmp->nm_wcommitsize = nmp->nm_wsize; 699 else 700 nmp->nm_wcommitsize = argp->wcommitsize; 701 } 702 703 adjsock |= ((nmp->nm_sotype != argp->sotype) || 704 (nmp->nm_soproto != argp->proto)); 705 706 if (nmp->nm_client != NULL && adjsock) { 707 int haslock = 0, error = 0; 708 709 if (nmp->nm_sotype == SOCK_STREAM) { 710 error = newnfs_sndlock(&nmp->nm_sockreq.nr_lock); 711 if (!error) 712 haslock = 1; 713 } 714 if (!error) { 715 newnfs_disconnect(&nmp->nm_sockreq); 716 if (haslock) 717 newnfs_sndunlock(&nmp->nm_sockreq.nr_lock); 718 nmp->nm_sotype = argp->sotype; 719 nmp->nm_soproto = argp->proto; 720 if (nmp->nm_sotype == SOCK_DGRAM) 721 while (newnfs_connect(nmp, &nmp->nm_sockreq, 722 cred, td, 0, false)) { 723 printf("newnfs_args: retrying connect\n"); 724 (void) nfs_catnap(PSOCK, 0, "nfscon"); 725 } 726 } 727 } else { 728 nmp->nm_sotype = argp->sotype; 729 nmp->nm_soproto = argp->proto; 730 } 731 732 if (hostname != NULL) { 733 strlcpy(nmp->nm_hostname, hostname, 734 sizeof(nmp->nm_hostname)); 735 p = strchr(nmp->nm_hostname, ':'); 736 if (p != NULL) 737 *p = '\0'; 738 } 739 } 740 741 static const char *nfs_opts[] = { "from", "nfs_args", 742 "noac", "noatime", "noexec", "suiddir", "nosuid", "nosymfollow", "union", 743 "noclusterr", "noclusterw", "multilabel", "acls", "force", "update", 744 "async", "noconn", "nolockd", "conn", "lockd", "intr", "rdirplus", 745 "readdirsize", "soft", "hard", "mntudp", "tcp", "udp", "wsize", "rsize", 746 "retrans", "actimeo", "acregmin", "acregmax", "acdirmin", "acdirmax", 747 "resvport", "readahead", "hostname", "timeo", "timeout", "addr", "fh", 748 "nfsv3", "sec", "principal", "nfsv4", "gssname", "allgssname", "dirpath", 749 "minorversion", "nametimeo", "negnametimeo", "nocto", "noncontigwr", 750 "pnfs", "wcommitsize", "oneopenown", "tls", 751 NULL }; 752 753 /* 754 * Parse the "from" mountarg, passed by the generic mount(8) program 755 * or the mountroot code. This is used when rerooting into NFS. 756 * 757 * Note that the "hostname" is actually a "hostname:/share/path" string. 758 */ 759 static int 760 nfs_mount_parse_from(struct vfsoptlist *opts, char **hostnamep, 761 struct sockaddr_in **sinp, char *dirpath, size_t dirpathsize, int *dirlenp) 762 { 763 char *nam, *delimp, *hostp, *spec; 764 int error, have_bracket = 0, offset, rv, speclen; 765 struct sockaddr_in *sin; 766 size_t len; 767 768 error = vfs_getopt(opts, "from", (void **)&spec, &speclen); 769 if (error != 0) 770 return (error); 771 nam = malloc(MNAMELEN + 1, M_TEMP, M_WAITOK); 772 773 /* 774 * This part comes from sbin/mount_nfs/mount_nfs.c:getnfsargs(). 775 */ 776 if (*spec == '[' && (delimp = strchr(spec + 1, ']')) != NULL && 777 *(delimp + 1) == ':') { 778 hostp = spec + 1; 779 spec = delimp + 2; 780 have_bracket = 1; 781 } else if ((delimp = strrchr(spec, ':')) != NULL) { 782 hostp = spec; 783 spec = delimp + 1; 784 } else if ((delimp = strrchr(spec, '@')) != NULL) { 785 printf("%s: path@server syntax is deprecated, " 786 "use server:path\n", __func__); 787 hostp = delimp + 1; 788 } else { 789 printf("%s: no <host>:<dirpath> nfs-name\n", __func__); 790 free(nam, M_TEMP); 791 return (EINVAL); 792 } 793 *delimp = '\0'; 794 795 /* 796 * If there has been a trailing slash at mounttime it seems 797 * that some mountd implementations fail to remove the mount 798 * entries from their mountlist while unmounting. 799 */ 800 for (speclen = strlen(spec); 801 speclen > 1 && spec[speclen - 1] == '/'; 802 speclen--) 803 spec[speclen - 1] = '\0'; 804 if (strlen(hostp) + strlen(spec) + 1 > MNAMELEN) { 805 printf("%s: %s:%s: name too long", __func__, hostp, spec); 806 free(nam, M_TEMP); 807 return (EINVAL); 808 } 809 /* Make both '@' and ':' notations equal */ 810 if (*hostp != '\0') { 811 len = strlen(hostp); 812 offset = 0; 813 if (have_bracket) 814 nam[offset++] = '['; 815 memmove(nam + offset, hostp, len); 816 if (have_bracket) 817 nam[len + offset++] = ']'; 818 nam[len + offset++] = ':'; 819 memmove(nam + len + offset, spec, speclen); 820 nam[len + speclen + offset] = '\0'; 821 } else 822 nam[0] = '\0'; 823 824 /* 825 * XXX: IPv6 826 */ 827 sin = malloc(sizeof(*sin), M_SONAME, M_WAITOK); 828 rv = inet_pton(AF_INET, hostp, &sin->sin_addr); 829 if (rv != 1) { 830 printf("%s: cannot parse '%s', inet_pton() returned %d\n", 831 __func__, hostp, rv); 832 free(nam, M_TEMP); 833 free(sin, M_SONAME); 834 return (EINVAL); 835 } 836 837 sin->sin_len = sizeof(*sin); 838 sin->sin_family = AF_INET; 839 /* 840 * XXX: hardcoded port number. 841 */ 842 sin->sin_port = htons(2049); 843 844 *hostnamep = strdup(nam, M_NEWNFSMNT); 845 *sinp = sin; 846 strlcpy(dirpath, spec, dirpathsize); 847 *dirlenp = strlen(dirpath); 848 849 free(nam, M_TEMP); 850 return (0); 851 } 852 853 /* 854 * VFS Operations. 855 * 856 * mount system call 857 * It seems a bit dumb to copyinstr() the host and path here and then 858 * bcopy() them in mountnfs(), but I wanted to detect errors before 859 * doing the getsockaddr() call because getsockaddr() allocates an mbuf and 860 * an error after that means that I have to release the mbuf. 861 */ 862 /* ARGSUSED */ 863 static int 864 nfs_mount(struct mount *mp) 865 { 866 struct nfs_args args = { 867 .version = NFS_ARGSVERSION, 868 .addr = NULL, 869 .addrlen = sizeof (struct sockaddr_in), 870 .sotype = SOCK_STREAM, 871 .proto = 0, 872 .fh = NULL, 873 .fhsize = 0, 874 .flags = NFSMNT_RESVPORT, 875 .wsize = NFS_WSIZE, 876 .rsize = NFS_RSIZE, 877 .readdirsize = NFS_READDIRSIZE, 878 .timeo = 10, 879 .retrans = NFS_RETRANS, 880 .readahead = NFS_DEFRAHEAD, 881 .wcommitsize = 0, /* was: NQ_DEFLEASE */ 882 .hostname = NULL, 883 .acregmin = NFS_MINATTRTIMO, 884 .acregmax = NFS_MAXATTRTIMO, 885 .acdirmin = NFS_MINDIRATTRTIMO, 886 .acdirmax = NFS_MAXDIRATTRTIMO, 887 }; 888 int error = 0, ret, len; 889 struct sockaddr *nam = NULL; 890 struct vnode *vp; 891 struct thread *td; 892 char *hst; 893 u_char nfh[NFSX_FHMAX], krbname[100], dirpath[100], srvkrbname[100]; 894 char *cp, *opt, *name, *secname; 895 int nametimeo = NFS_DEFAULT_NAMETIMEO; 896 int negnametimeo = NFS_DEFAULT_NEGNAMETIMEO; 897 int minvers = 0; 898 int dirlen, has_nfs_args_opt, has_nfs_from_opt, 899 krbnamelen, srvkrbnamelen; 900 size_t hstlen; 901 uint32_t newflag; 902 903 has_nfs_args_opt = 0; 904 has_nfs_from_opt = 0; 905 newflag = 0; 906 hst = malloc(MNAMELEN, M_TEMP, M_WAITOK); 907 if (vfs_filteropt(mp->mnt_optnew, nfs_opts)) { 908 error = EINVAL; 909 goto out; 910 } 911 912 td = curthread; 913 if ((mp->mnt_flag & (MNT_ROOTFS | MNT_UPDATE)) == MNT_ROOTFS && 914 nfs_diskless_valid != 0) { 915 error = nfs_mountroot(mp); 916 goto out; 917 } 918 919 nfscl_init(); 920 921 /* 922 * The old mount_nfs program passed the struct nfs_args 923 * from userspace to kernel. The new mount_nfs program 924 * passes string options via nmount() from userspace to kernel 925 * and we populate the struct nfs_args in the kernel. 926 */ 927 if (vfs_getopt(mp->mnt_optnew, "nfs_args", NULL, NULL) == 0) { 928 error = vfs_copyopt(mp->mnt_optnew, "nfs_args", &args, 929 sizeof(args)); 930 if (error != 0) 931 goto out; 932 933 if (args.version != NFS_ARGSVERSION) { 934 error = EPROGMISMATCH; 935 goto out; 936 } 937 has_nfs_args_opt = 1; 938 } 939 940 /* Handle the new style options. */ 941 if (vfs_getopt(mp->mnt_optnew, "noac", NULL, NULL) == 0) { 942 args.acdirmin = args.acdirmax = 943 args.acregmin = args.acregmax = 0; 944 args.flags |= NFSMNT_ACDIRMIN | NFSMNT_ACDIRMAX | 945 NFSMNT_ACREGMIN | NFSMNT_ACREGMAX; 946 } 947 if (vfs_getopt(mp->mnt_optnew, "noconn", NULL, NULL) == 0) 948 args.flags |= NFSMNT_NOCONN; 949 if (vfs_getopt(mp->mnt_optnew, "conn", NULL, NULL) == 0) 950 args.flags &= ~NFSMNT_NOCONN; 951 if (vfs_getopt(mp->mnt_optnew, "nolockd", NULL, NULL) == 0) 952 args.flags |= NFSMNT_NOLOCKD; 953 if (vfs_getopt(mp->mnt_optnew, "lockd", NULL, NULL) == 0) 954 args.flags &= ~NFSMNT_NOLOCKD; 955 if (vfs_getopt(mp->mnt_optnew, "intr", NULL, NULL) == 0) 956 args.flags |= NFSMNT_INT; 957 if (vfs_getopt(mp->mnt_optnew, "rdirplus", NULL, NULL) == 0) 958 args.flags |= NFSMNT_RDIRPLUS; 959 if (vfs_getopt(mp->mnt_optnew, "resvport", NULL, NULL) == 0) 960 args.flags |= NFSMNT_RESVPORT; 961 if (vfs_getopt(mp->mnt_optnew, "noresvport", NULL, NULL) == 0) 962 args.flags &= ~NFSMNT_RESVPORT; 963 if (vfs_getopt(mp->mnt_optnew, "soft", NULL, NULL) == 0) 964 args.flags |= NFSMNT_SOFT; 965 if (vfs_getopt(mp->mnt_optnew, "hard", NULL, NULL) == 0) 966 args.flags &= ~NFSMNT_SOFT; 967 if (vfs_getopt(mp->mnt_optnew, "mntudp", NULL, NULL) == 0) 968 args.sotype = SOCK_DGRAM; 969 if (vfs_getopt(mp->mnt_optnew, "udp", NULL, NULL) == 0) 970 args.sotype = SOCK_DGRAM; 971 if (vfs_getopt(mp->mnt_optnew, "tcp", NULL, NULL) == 0) 972 args.sotype = SOCK_STREAM; 973 if (vfs_getopt(mp->mnt_optnew, "nfsv3", NULL, NULL) == 0) 974 args.flags |= NFSMNT_NFSV3; 975 if (vfs_getopt(mp->mnt_optnew, "nfsv4", NULL, NULL) == 0) { 976 args.flags |= NFSMNT_NFSV4; 977 args.sotype = SOCK_STREAM; 978 } 979 if (vfs_getopt(mp->mnt_optnew, "allgssname", NULL, NULL) == 0) 980 args.flags |= NFSMNT_ALLGSSNAME; 981 if (vfs_getopt(mp->mnt_optnew, "nocto", NULL, NULL) == 0) 982 args.flags |= NFSMNT_NOCTO; 983 if (vfs_getopt(mp->mnt_optnew, "noncontigwr", NULL, NULL) == 0) 984 args.flags |= NFSMNT_NONCONTIGWR; 985 if (vfs_getopt(mp->mnt_optnew, "pnfs", NULL, NULL) == 0) 986 args.flags |= NFSMNT_PNFS; 987 if (vfs_getopt(mp->mnt_optnew, "oneopenown", NULL, NULL) == 0) 988 args.flags |= NFSMNT_ONEOPENOWN; 989 if (vfs_getopt(mp->mnt_optnew, "tls", NULL, NULL) == 0) 990 newflag |= NFSMNT_TLS; 991 if (vfs_getopt(mp->mnt_optnew, "readdirsize", (void **)&opt, NULL) == 0) { 992 if (opt == NULL) { 993 vfs_mount_error(mp, "illegal readdirsize"); 994 error = EINVAL; 995 goto out; 996 } 997 ret = sscanf(opt, "%d", &args.readdirsize); 998 if (ret != 1 || args.readdirsize <= 0) { 999 vfs_mount_error(mp, "illegal readdirsize: %s", 1000 opt); 1001 error = EINVAL; 1002 goto out; 1003 } 1004 args.flags |= NFSMNT_READDIRSIZE; 1005 } 1006 if (vfs_getopt(mp->mnt_optnew, "readahead", (void **)&opt, NULL) == 0) { 1007 if (opt == NULL) { 1008 vfs_mount_error(mp, "illegal readahead"); 1009 error = EINVAL; 1010 goto out; 1011 } 1012 ret = sscanf(opt, "%d", &args.readahead); 1013 if (ret != 1 || args.readahead <= 0) { 1014 vfs_mount_error(mp, "illegal readahead: %s", 1015 opt); 1016 error = EINVAL; 1017 goto out; 1018 } 1019 args.flags |= NFSMNT_READAHEAD; 1020 } 1021 if (vfs_getopt(mp->mnt_optnew, "wsize", (void **)&opt, NULL) == 0) { 1022 if (opt == NULL) { 1023 vfs_mount_error(mp, "illegal wsize"); 1024 error = EINVAL; 1025 goto out; 1026 } 1027 ret = sscanf(opt, "%d", &args.wsize); 1028 if (ret != 1 || args.wsize <= 0) { 1029 vfs_mount_error(mp, "illegal wsize: %s", 1030 opt); 1031 error = EINVAL; 1032 goto out; 1033 } 1034 args.flags |= NFSMNT_WSIZE; 1035 } 1036 if (vfs_getopt(mp->mnt_optnew, "rsize", (void **)&opt, NULL) == 0) { 1037 if (opt == NULL) { 1038 vfs_mount_error(mp, "illegal rsize"); 1039 error = EINVAL; 1040 goto out; 1041 } 1042 ret = sscanf(opt, "%d", &args.rsize); 1043 if (ret != 1 || args.rsize <= 0) { 1044 vfs_mount_error(mp, "illegal wsize: %s", 1045 opt); 1046 error = EINVAL; 1047 goto out; 1048 } 1049 args.flags |= NFSMNT_RSIZE; 1050 } 1051 if (vfs_getopt(mp->mnt_optnew, "retrans", (void **)&opt, NULL) == 0) { 1052 if (opt == NULL) { 1053 vfs_mount_error(mp, "illegal retrans"); 1054 error = EINVAL; 1055 goto out; 1056 } 1057 ret = sscanf(opt, "%d", &args.retrans); 1058 if (ret != 1 || args.retrans <= 0) { 1059 vfs_mount_error(mp, "illegal retrans: %s", 1060 opt); 1061 error = EINVAL; 1062 goto out; 1063 } 1064 args.flags |= NFSMNT_RETRANS; 1065 } 1066 if (vfs_getopt(mp->mnt_optnew, "actimeo", (void **)&opt, NULL) == 0) { 1067 ret = sscanf(opt, "%d", &args.acregmin); 1068 if (ret != 1 || args.acregmin < 0) { 1069 vfs_mount_error(mp, "illegal actimeo: %s", 1070 opt); 1071 error = EINVAL; 1072 goto out; 1073 } 1074 args.acdirmin = args.acdirmax = args.acregmax = args.acregmin; 1075 args.flags |= NFSMNT_ACDIRMIN | NFSMNT_ACDIRMAX | 1076 NFSMNT_ACREGMIN | NFSMNT_ACREGMAX; 1077 } 1078 if (vfs_getopt(mp->mnt_optnew, "acregmin", (void **)&opt, NULL) == 0) { 1079 ret = sscanf(opt, "%d", &args.acregmin); 1080 if (ret != 1 || args.acregmin < 0) { 1081 vfs_mount_error(mp, "illegal acregmin: %s", 1082 opt); 1083 error = EINVAL; 1084 goto out; 1085 } 1086 args.flags |= NFSMNT_ACREGMIN; 1087 } 1088 if (vfs_getopt(mp->mnt_optnew, "acregmax", (void **)&opt, NULL) == 0) { 1089 ret = sscanf(opt, "%d", &args.acregmax); 1090 if (ret != 1 || args.acregmax < 0) { 1091 vfs_mount_error(mp, "illegal acregmax: %s", 1092 opt); 1093 error = EINVAL; 1094 goto out; 1095 } 1096 args.flags |= NFSMNT_ACREGMAX; 1097 } 1098 if (vfs_getopt(mp->mnt_optnew, "acdirmin", (void **)&opt, NULL) == 0) { 1099 ret = sscanf(opt, "%d", &args.acdirmin); 1100 if (ret != 1 || args.acdirmin < 0) { 1101 vfs_mount_error(mp, "illegal acdirmin: %s", 1102 opt); 1103 error = EINVAL; 1104 goto out; 1105 } 1106 args.flags |= NFSMNT_ACDIRMIN; 1107 } 1108 if (vfs_getopt(mp->mnt_optnew, "acdirmax", (void **)&opt, NULL) == 0) { 1109 ret = sscanf(opt, "%d", &args.acdirmax); 1110 if (ret != 1 || args.acdirmax < 0) { 1111 vfs_mount_error(mp, "illegal acdirmax: %s", 1112 opt); 1113 error = EINVAL; 1114 goto out; 1115 } 1116 args.flags |= NFSMNT_ACDIRMAX; 1117 } 1118 if (vfs_getopt(mp->mnt_optnew, "wcommitsize", (void **)&opt, NULL) == 0) { 1119 ret = sscanf(opt, "%d", &args.wcommitsize); 1120 if (ret != 1 || args.wcommitsize < 0) { 1121 vfs_mount_error(mp, "illegal wcommitsize: %s", opt); 1122 error = EINVAL; 1123 goto out; 1124 } 1125 args.flags |= NFSMNT_WCOMMITSIZE; 1126 } 1127 if (vfs_getopt(mp->mnt_optnew, "timeo", (void **)&opt, NULL) == 0) { 1128 ret = sscanf(opt, "%d", &args.timeo); 1129 if (ret != 1 || args.timeo <= 0) { 1130 vfs_mount_error(mp, "illegal timeo: %s", 1131 opt); 1132 error = EINVAL; 1133 goto out; 1134 } 1135 args.flags |= NFSMNT_TIMEO; 1136 } 1137 if (vfs_getopt(mp->mnt_optnew, "timeout", (void **)&opt, NULL) == 0) { 1138 ret = sscanf(opt, "%d", &args.timeo); 1139 if (ret != 1 || args.timeo <= 0) { 1140 vfs_mount_error(mp, "illegal timeout: %s", 1141 opt); 1142 error = EINVAL; 1143 goto out; 1144 } 1145 args.flags |= NFSMNT_TIMEO; 1146 } 1147 if (vfs_getopt(mp->mnt_optnew, "nametimeo", (void **)&opt, NULL) == 0) { 1148 ret = sscanf(opt, "%d", &nametimeo); 1149 if (ret != 1 || nametimeo < 0) { 1150 vfs_mount_error(mp, "illegal nametimeo: %s", opt); 1151 error = EINVAL; 1152 goto out; 1153 } 1154 } 1155 if (vfs_getopt(mp->mnt_optnew, "negnametimeo", (void **)&opt, NULL) 1156 == 0) { 1157 ret = sscanf(opt, "%d", &negnametimeo); 1158 if (ret != 1 || negnametimeo < 0) { 1159 vfs_mount_error(mp, "illegal negnametimeo: %s", 1160 opt); 1161 error = EINVAL; 1162 goto out; 1163 } 1164 } 1165 if (vfs_getopt(mp->mnt_optnew, "minorversion", (void **)&opt, NULL) == 1166 0) { 1167 ret = sscanf(opt, "%d", &minvers); 1168 if (ret != 1 || minvers < 0 || minvers > 2 || 1169 (args.flags & NFSMNT_NFSV4) == 0) { 1170 vfs_mount_error(mp, "illegal minorversion: %s", opt); 1171 error = EINVAL; 1172 goto out; 1173 } 1174 } 1175 if (vfs_getopt(mp->mnt_optnew, "sec", 1176 (void **) &secname, NULL) == 0) 1177 nfs_sec_name(secname, &args.flags); 1178 1179 if (mp->mnt_flag & MNT_UPDATE) { 1180 struct nfsmount *nmp = VFSTONFS(mp); 1181 1182 if (nmp == NULL) { 1183 error = EIO; 1184 goto out; 1185 } 1186 1187 /* 1188 * If a change from TCP->UDP is done and there are thread(s) 1189 * that have I/O RPC(s) in progress with a transfer size 1190 * greater than NFS_MAXDGRAMDATA, those thread(s) will be 1191 * hung, retrying the RPC(s) forever. Usually these threads 1192 * will be seen doing an uninterruptible sleep on wait channel 1193 * "nfsreq". 1194 */ 1195 if (args.sotype == SOCK_DGRAM && nmp->nm_sotype == SOCK_STREAM) 1196 tprintf(td->td_proc, LOG_WARNING, 1197 "Warning: mount -u that changes TCP->UDP can result in hung threads\n"); 1198 1199 /* 1200 * When doing an update, we can't change version, 1201 * security, switch lockd strategies, change cookie 1202 * translation or switch oneopenown. 1203 */ 1204 args.flags = (args.flags & 1205 ~(NFSMNT_NFSV3 | 1206 NFSMNT_NFSV4 | 1207 NFSMNT_KERB | 1208 NFSMNT_INTEGRITY | 1209 NFSMNT_PRIVACY | 1210 NFSMNT_ONEOPENOWN | 1211 NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/)) | 1212 (nmp->nm_flag & 1213 (NFSMNT_NFSV3 | 1214 NFSMNT_NFSV4 | 1215 NFSMNT_KERB | 1216 NFSMNT_INTEGRITY | 1217 NFSMNT_PRIVACY | 1218 NFSMNT_ONEOPENOWN | 1219 NFSMNT_NOLOCKD /*|NFSMNT_XLATECOOKIE*/)); 1220 nfs_decode_args(mp, nmp, &args, NULL, td->td_ucred, td); 1221 goto out; 1222 } 1223 1224 /* 1225 * Make the nfs_ip_paranoia sysctl serve as the default connection 1226 * or no-connection mode for those protocols that support 1227 * no-connection mode (the flag will be cleared later for protocols 1228 * that do not support no-connection mode). This will allow a client 1229 * to receive replies from a different IP then the request was 1230 * sent to. Note: default value for nfs_ip_paranoia is 1 (paranoid), 1231 * not 0. 1232 */ 1233 if (nfs_ip_paranoia == 0) 1234 args.flags |= NFSMNT_NOCONN; 1235 1236 if (has_nfs_args_opt != 0) { 1237 /* 1238 * In the 'nfs_args' case, the pointers in the args 1239 * structure are in userland - we copy them in here. 1240 */ 1241 if (args.fhsize < 0 || args.fhsize > NFSX_V3FHMAX) { 1242 vfs_mount_error(mp, "Bad file handle"); 1243 error = EINVAL; 1244 goto out; 1245 } 1246 error = copyin((caddr_t)args.fh, (caddr_t)nfh, 1247 args.fhsize); 1248 if (error != 0) 1249 goto out; 1250 error = copyinstr(args.hostname, hst, MNAMELEN - 1, &hstlen); 1251 if (error != 0) 1252 goto out; 1253 bzero(&hst[hstlen], MNAMELEN - hstlen); 1254 args.hostname = hst; 1255 /* getsockaddr() call must be after above copyin() calls */ 1256 error = getsockaddr(&nam, args.addr, args.addrlen); 1257 if (error != 0) 1258 goto out; 1259 } else if (nfs_mount_parse_from(mp->mnt_optnew, 1260 &args.hostname, (struct sockaddr_in **)&nam, dirpath, 1261 sizeof(dirpath), &dirlen) == 0) { 1262 has_nfs_from_opt = 1; 1263 bcopy(args.hostname, hst, MNAMELEN); 1264 hst[MNAMELEN - 1] = '\0'; 1265 1266 /* 1267 * This only works with NFSv4 for now. 1268 */ 1269 args.fhsize = 0; 1270 args.flags |= NFSMNT_NFSV4; 1271 args.sotype = SOCK_STREAM; 1272 } else { 1273 if (vfs_getopt(mp->mnt_optnew, "fh", (void **)&args.fh, 1274 &args.fhsize) == 0) { 1275 if (args.fhsize < 0 || args.fhsize > NFSX_FHMAX) { 1276 vfs_mount_error(mp, "Bad file handle"); 1277 error = EINVAL; 1278 goto out; 1279 } 1280 bcopy(args.fh, nfh, args.fhsize); 1281 } else { 1282 args.fhsize = 0; 1283 } 1284 (void) vfs_getopt(mp->mnt_optnew, "hostname", 1285 (void **)&args.hostname, &len); 1286 if (args.hostname == NULL) { 1287 vfs_mount_error(mp, "Invalid hostname"); 1288 error = EINVAL; 1289 goto out; 1290 } 1291 if (len >= MNAMELEN) { 1292 vfs_mount_error(mp, "Hostname too long"); 1293 error = EINVAL; 1294 goto out; 1295 } 1296 bcopy(args.hostname, hst, len); 1297 hst[len] = '\0'; 1298 } 1299 1300 if (vfs_getopt(mp->mnt_optnew, "principal", (void **)&name, NULL) == 0) 1301 strlcpy(srvkrbname, name, sizeof (srvkrbname)); 1302 else { 1303 snprintf(srvkrbname, sizeof (srvkrbname), "nfs@%s", hst); 1304 cp = strchr(srvkrbname, ':'); 1305 if (cp != NULL) 1306 *cp = '\0'; 1307 } 1308 srvkrbnamelen = strlen(srvkrbname); 1309 1310 if (vfs_getopt(mp->mnt_optnew, "gssname", (void **)&name, NULL) == 0) 1311 strlcpy(krbname, name, sizeof (krbname)); 1312 else 1313 krbname[0] = '\0'; 1314 krbnamelen = strlen(krbname); 1315 1316 if (has_nfs_from_opt == 0) { 1317 if (vfs_getopt(mp->mnt_optnew, 1318 "dirpath", (void **)&name, NULL) == 0) 1319 strlcpy(dirpath, name, sizeof (dirpath)); 1320 else 1321 dirpath[0] = '\0'; 1322 dirlen = strlen(dirpath); 1323 } 1324 1325 if (has_nfs_args_opt == 0 && has_nfs_from_opt == 0) { 1326 if (vfs_getopt(mp->mnt_optnew, "addr", 1327 (void **)&args.addr, &args.addrlen) == 0) { 1328 if (args.addrlen > SOCK_MAXADDRLEN) { 1329 error = ENAMETOOLONG; 1330 goto out; 1331 } 1332 nam = malloc(args.addrlen, M_SONAME, M_WAITOK); 1333 bcopy(args.addr, nam, args.addrlen); 1334 nam->sa_len = args.addrlen; 1335 } else { 1336 vfs_mount_error(mp, "No server address"); 1337 error = EINVAL; 1338 goto out; 1339 } 1340 } 1341 1342 args.fh = nfh; 1343 error = mountnfs(&args, mp, nam, hst, krbname, krbnamelen, dirpath, 1344 dirlen, srvkrbname, srvkrbnamelen, &vp, td->td_ucred, td, 1345 nametimeo, negnametimeo, minvers, newflag); 1346 out: 1347 if (!error) { 1348 MNT_ILOCK(mp); 1349 mp->mnt_kern_flag |= MNTK_LOOKUP_SHARED | MNTK_NO_IOPF | 1350 MNTK_USES_BCACHE; 1351 if ((VFSTONFS(mp)->nm_flag & NFSMNT_NFSV4) != 0) 1352 mp->mnt_kern_flag |= MNTK_NULL_NOCACHE; 1353 MNT_IUNLOCK(mp); 1354 } 1355 free(hst, M_TEMP); 1356 return (error); 1357 } 1358 1359 /* 1360 * VFS Operations. 1361 * 1362 * mount system call 1363 * It seems a bit dumb to copyinstr() the host and path here and then 1364 * bcopy() them in mountnfs(), but I wanted to detect errors before 1365 * doing the getsockaddr() call because getsockaddr() allocates an mbuf and 1366 * an error after that means that I have to release the mbuf. 1367 */ 1368 /* ARGSUSED */ 1369 static int 1370 nfs_cmount(struct mntarg *ma, void *data, uint64_t flags) 1371 { 1372 int error; 1373 struct nfs_args args; 1374 1375 error = copyin(data, &args, sizeof (struct nfs_args)); 1376 if (error) 1377 return error; 1378 1379 ma = mount_arg(ma, "nfs_args", &args, sizeof args); 1380 1381 error = kernel_mount(ma, flags); 1382 return (error); 1383 } 1384 1385 /* 1386 * Common code for mount and mountroot 1387 */ 1388 static int 1389 mountnfs(struct nfs_args *argp, struct mount *mp, struct sockaddr *nam, 1390 char *hst, u_char *krbname, int krbnamelen, u_char *dirpath, int dirlen, 1391 u_char *srvkrbname, int srvkrbnamelen, struct vnode **vpp, 1392 struct ucred *cred, struct thread *td, int nametimeo, int negnametimeo, 1393 int minvers, uint32_t newflag) 1394 { 1395 struct nfsmount *nmp; 1396 struct nfsnode *np; 1397 int error, trycnt, ret; 1398 struct nfsvattr nfsva; 1399 struct nfsclclient *clp; 1400 struct nfsclds *dsp, *tdsp; 1401 uint32_t lease; 1402 static u_int64_t clval = 0; 1403 #ifdef KERN_TLS 1404 u_int maxlen; 1405 #endif 1406 1407 NFSCL_DEBUG(3, "in mnt\n"); 1408 clp = NULL; 1409 if (mp->mnt_flag & MNT_UPDATE) { 1410 nmp = VFSTONFS(mp); 1411 printf("%s: MNT_UPDATE is no longer handled here\n", __func__); 1412 free(nam, M_SONAME); 1413 return (0); 1414 } else { 1415 /* NFS-over-TLS requires that rpctls be functioning. */ 1416 if ((newflag & NFSMNT_TLS) != 0) { 1417 error = EINVAL; 1418 #ifdef KERN_TLS 1419 /* KERN_TLS is only supported for TCP. */ 1420 if (argp->sotype == SOCK_STREAM && 1421 rpctls_getinfo(&maxlen, true, false)) 1422 error = 0; 1423 #endif 1424 if (error != 0) { 1425 free(nam, M_SONAME); 1426 return (error); 1427 } 1428 } 1429 nmp = malloc(sizeof (struct nfsmount) + 1430 krbnamelen + dirlen + srvkrbnamelen + 2, 1431 M_NEWNFSMNT, M_WAITOK | M_ZERO); 1432 nmp->nm_newflag = newflag; 1433 TAILQ_INIT(&nmp->nm_bufq); 1434 TAILQ_INIT(&nmp->nm_sess); 1435 if (clval == 0) 1436 clval = (u_int64_t)nfsboottime.tv_sec; 1437 nmp->nm_clval = clval++; 1438 nmp->nm_krbnamelen = krbnamelen; 1439 nmp->nm_dirpathlen = dirlen; 1440 nmp->nm_srvkrbnamelen = srvkrbnamelen; 1441 if (td->td_ucred->cr_uid != (uid_t)0) { 1442 /* 1443 * nm_uid is used to get KerberosV credentials for 1444 * the nfsv4 state handling operations if there is 1445 * no host based principal set. Use the uid of 1446 * this user if not root, since they are doing the 1447 * mount. I don't think setting this for root will 1448 * work, since root normally does not have user 1449 * credentials in a credentials cache. 1450 */ 1451 nmp->nm_uid = td->td_ucred->cr_uid; 1452 } else { 1453 /* 1454 * Just set to -1, so it won't be used. 1455 */ 1456 nmp->nm_uid = (uid_t)-1; 1457 } 1458 1459 /* Copy and null terminate all the names */ 1460 if (nmp->nm_krbnamelen > 0) { 1461 bcopy(krbname, nmp->nm_krbname, nmp->nm_krbnamelen); 1462 nmp->nm_name[nmp->nm_krbnamelen] = '\0'; 1463 } 1464 if (nmp->nm_dirpathlen > 0) { 1465 bcopy(dirpath, NFSMNT_DIRPATH(nmp), 1466 nmp->nm_dirpathlen); 1467 nmp->nm_name[nmp->nm_krbnamelen + nmp->nm_dirpathlen 1468 + 1] = '\0'; 1469 } 1470 if (nmp->nm_srvkrbnamelen > 0) { 1471 bcopy(srvkrbname, NFSMNT_SRVKRBNAME(nmp), 1472 nmp->nm_srvkrbnamelen); 1473 nmp->nm_name[nmp->nm_krbnamelen + nmp->nm_dirpathlen 1474 + nmp->nm_srvkrbnamelen + 2] = '\0'; 1475 } 1476 nmp->nm_sockreq.nr_cred = crhold(cred); 1477 mtx_init(&nmp->nm_sockreq.nr_mtx, "nfssock", NULL, MTX_DEF); 1478 mp->mnt_data = nmp; 1479 nmp->nm_getinfo = nfs_getnlminfo; 1480 nmp->nm_vinvalbuf = ncl_vinvalbuf; 1481 } 1482 vfs_getnewfsid(mp); 1483 nmp->nm_mountp = mp; 1484 mtx_init(&nmp->nm_mtx, "NFSmount lock", NULL, MTX_DEF | MTX_DUPOK); 1485 1486 /* 1487 * Since nfs_decode_args() might optionally set them, these 1488 * need to be set to defaults before the call, so that the 1489 * optional settings aren't overwritten. 1490 */ 1491 nmp->nm_nametimeo = nametimeo; 1492 nmp->nm_negnametimeo = negnametimeo; 1493 nmp->nm_timeo = NFS_TIMEO; 1494 nmp->nm_retry = NFS_RETRANS; 1495 nmp->nm_readahead = NFS_DEFRAHEAD; 1496 1497 /* This is empirical approximation of sqrt(hibufspace) * 256. */ 1498 nmp->nm_wcommitsize = NFS_MAXBSIZE / 256; 1499 while ((long)nmp->nm_wcommitsize * nmp->nm_wcommitsize < hibufspace) 1500 nmp->nm_wcommitsize *= 2; 1501 nmp->nm_wcommitsize *= 256; 1502 1503 if ((argp->flags & NFSMNT_NFSV4) != 0) 1504 nmp->nm_minorvers = minvers; 1505 else 1506 nmp->nm_minorvers = 0; 1507 1508 nfs_decode_args(mp, nmp, argp, hst, cred, td); 1509 1510 /* 1511 * V2 can only handle 32 bit filesizes. A 4GB-1 limit may be too 1512 * high, depending on whether we end up with negative offsets in 1513 * the client or server somewhere. 2GB-1 may be safer. 1514 * 1515 * For V3, ncl_fsinfo will adjust this as necessary. Assume maximum 1516 * that we can handle until we find out otherwise. 1517 */ 1518 if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0) 1519 nmp->nm_maxfilesize = 0xffffffffLL; 1520 else 1521 nmp->nm_maxfilesize = OFF_MAX; 1522 1523 if ((argp->flags & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0) { 1524 nmp->nm_wsize = NFS_WSIZE; 1525 nmp->nm_rsize = NFS_RSIZE; 1526 nmp->nm_readdirsize = NFS_READDIRSIZE; 1527 } 1528 nmp->nm_numgrps = NFS_MAXGRPS; 1529 nmp->nm_tprintf_delay = nfs_tprintf_delay; 1530 if (nmp->nm_tprintf_delay < 0) 1531 nmp->nm_tprintf_delay = 0; 1532 nmp->nm_tprintf_initial_delay = nfs_tprintf_initial_delay; 1533 if (nmp->nm_tprintf_initial_delay < 0) 1534 nmp->nm_tprintf_initial_delay = 0; 1535 nmp->nm_fhsize = argp->fhsize; 1536 if (nmp->nm_fhsize > 0) 1537 bcopy((caddr_t)argp->fh, (caddr_t)nmp->nm_fh, argp->fhsize); 1538 bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN); 1539 nmp->nm_nam = nam; 1540 /* Set up the sockets and per-host congestion */ 1541 nmp->nm_sotype = argp->sotype; 1542 nmp->nm_soproto = argp->proto; 1543 nmp->nm_sockreq.nr_prog = NFS_PROG; 1544 if ((argp->flags & NFSMNT_NFSV4)) 1545 nmp->nm_sockreq.nr_vers = NFS_VER4; 1546 else if ((argp->flags & NFSMNT_NFSV3)) 1547 nmp->nm_sockreq.nr_vers = NFS_VER3; 1548 else 1549 nmp->nm_sockreq.nr_vers = NFS_VER2; 1550 1551 if ((error = newnfs_connect(nmp, &nmp->nm_sockreq, cred, td, 0, false))) 1552 goto bad; 1553 /* For NFSv4.1, get the clientid now. */ 1554 if (nmp->nm_minorvers > 0) { 1555 NFSCL_DEBUG(3, "at getcl\n"); 1556 error = nfscl_getcl(mp, cred, td, 0, &clp); 1557 NFSCL_DEBUG(3, "aft getcl=%d\n", error); 1558 if (error != 0) 1559 goto bad; 1560 } 1561 1562 if (nmp->nm_fhsize == 0 && (nmp->nm_flag & NFSMNT_NFSV4) && 1563 nmp->nm_dirpathlen > 0) { 1564 NFSCL_DEBUG(3, "in dirp\n"); 1565 /* 1566 * If the fhsize on the mount point == 0 for V4, the mount 1567 * path needs to be looked up. 1568 */ 1569 trycnt = 3; 1570 do { 1571 error = nfsrpc_getdirpath(nmp, NFSMNT_DIRPATH(nmp), 1572 cred, td); 1573 NFSCL_DEBUG(3, "aft dirp=%d\n", error); 1574 if (error) 1575 (void) nfs_catnap(PZERO, error, "nfsgetdirp"); 1576 } while (error && --trycnt > 0); 1577 if (error) 1578 goto bad; 1579 } 1580 1581 /* 1582 * A reference count is needed on the nfsnode representing the 1583 * remote root. If this object is not persistent, then backward 1584 * traversals of the mount point (i.e. "..") will not work if 1585 * the nfsnode gets flushed out of the cache. Ufs does not have 1586 * this problem, because one can identify root inodes by their 1587 * number == UFS_ROOTINO (2). 1588 */ 1589 if (nmp->nm_fhsize > 0) { 1590 /* 1591 * Set f_iosize to NFS_DIRBLKSIZ so that bo_bsize gets set 1592 * non-zero for the root vnode. f_iosize will be set correctly 1593 * by nfs_statfs() before any I/O occurs. 1594 */ 1595 mp->mnt_stat.f_iosize = NFS_DIRBLKSIZ; 1596 error = ncl_nget(mp, nmp->nm_fh, nmp->nm_fhsize, &np, 1597 LK_EXCLUSIVE); 1598 if (error) 1599 goto bad; 1600 *vpp = NFSTOV(np); 1601 1602 /* 1603 * Get file attributes and transfer parameters for the 1604 * mountpoint. This has the side effect of filling in 1605 * (*vpp)->v_type with the correct value. 1606 */ 1607 ret = nfsrpc_getattrnovp(nmp, nmp->nm_fh, nmp->nm_fhsize, 1, 1608 cred, td, &nfsva, NULL, &lease); 1609 if (ret) { 1610 /* 1611 * Just set default values to get things going. 1612 */ 1613 NFSBZERO((caddr_t)&nfsva, sizeof (struct nfsvattr)); 1614 nfsva.na_vattr.va_type = VDIR; 1615 nfsva.na_vattr.va_mode = 0777; 1616 nfsva.na_vattr.va_nlink = 100; 1617 nfsva.na_vattr.va_uid = (uid_t)0; 1618 nfsva.na_vattr.va_gid = (gid_t)0; 1619 nfsva.na_vattr.va_fileid = 2; 1620 nfsva.na_vattr.va_gen = 1; 1621 nfsva.na_vattr.va_blocksize = NFS_FABLKSIZE; 1622 nfsva.na_vattr.va_size = 512 * 1024; 1623 lease = 60; 1624 } 1625 (void) nfscl_loadattrcache(vpp, &nfsva, NULL, NULL, 0, 1); 1626 if (nmp->nm_minorvers > 0) { 1627 NFSCL_DEBUG(3, "lease=%d\n", (int)lease); 1628 NFSLOCKCLSTATE(); 1629 clp->nfsc_renew = NFSCL_RENEW(lease); 1630 clp->nfsc_expire = NFSD_MONOSEC + clp->nfsc_renew; 1631 clp->nfsc_clientidrev++; 1632 if (clp->nfsc_clientidrev == 0) 1633 clp->nfsc_clientidrev++; 1634 NFSUNLOCKCLSTATE(); 1635 /* 1636 * Mount will succeed, so the renew thread can be 1637 * started now. 1638 */ 1639 nfscl_start_renewthread(clp); 1640 nfscl_clientrelease(clp); 1641 } 1642 if (argp->flags & NFSMNT_NFSV3) 1643 ncl_fsinfo(nmp, *vpp, cred, td); 1644 1645 /* Mark if the mount point supports NFSv4 ACLs. */ 1646 if ((argp->flags & NFSMNT_NFSV4) != 0 && nfsrv_useacl != 0 && 1647 ret == 0 && 1648 NFSISSET_ATTRBIT(&nfsva.na_suppattr, NFSATTRBIT_ACL)) { 1649 MNT_ILOCK(mp); 1650 mp->mnt_flag |= MNT_NFS4ACLS; 1651 MNT_IUNLOCK(mp); 1652 } 1653 1654 /* 1655 * Lose the lock but keep the ref. 1656 */ 1657 NFSVOPUNLOCK(*vpp); 1658 vfs_cache_root_set(mp, *vpp); 1659 return (0); 1660 } 1661 error = EIO; 1662 1663 bad: 1664 if (clp != NULL) 1665 nfscl_clientrelease(clp); 1666 newnfs_disconnect(&nmp->nm_sockreq); 1667 crfree(nmp->nm_sockreq.nr_cred); 1668 if (nmp->nm_sockreq.nr_auth != NULL) 1669 AUTH_DESTROY(nmp->nm_sockreq.nr_auth); 1670 mtx_destroy(&nmp->nm_sockreq.nr_mtx); 1671 mtx_destroy(&nmp->nm_mtx); 1672 if (nmp->nm_clp != NULL) { 1673 NFSLOCKCLSTATE(); 1674 LIST_REMOVE(nmp->nm_clp, nfsc_list); 1675 NFSUNLOCKCLSTATE(); 1676 free(nmp->nm_clp, M_NFSCLCLIENT); 1677 } 1678 TAILQ_FOREACH_SAFE(dsp, &nmp->nm_sess, nfsclds_list, tdsp) { 1679 if (dsp != TAILQ_FIRST(&nmp->nm_sess) && 1680 dsp->nfsclds_sockp != NULL) 1681 newnfs_disconnect(dsp->nfsclds_sockp); 1682 nfscl_freenfsclds(dsp); 1683 } 1684 free(nmp, M_NEWNFSMNT); 1685 free(nam, M_SONAME); 1686 return (error); 1687 } 1688 1689 /* 1690 * unmount system call 1691 */ 1692 static int 1693 nfs_unmount(struct mount *mp, int mntflags) 1694 { 1695 struct thread *td; 1696 struct nfsmount *nmp; 1697 int error, flags = 0, i, trycnt = 0; 1698 struct nfsclds *dsp, *tdsp; 1699 1700 td = curthread; 1701 1702 if (mntflags & MNT_FORCE) 1703 flags |= FORCECLOSE; 1704 nmp = VFSTONFS(mp); 1705 error = 0; 1706 /* 1707 * Goes something like this.. 1708 * - Call vflush() to clear out vnodes for this filesystem 1709 * - Close the socket 1710 * - Free up the data structures 1711 */ 1712 /* In the forced case, cancel any outstanding requests. */ 1713 if (mntflags & MNT_FORCE) { 1714 NFSDDSLOCK(); 1715 if (nfsv4_findmirror(nmp) != NULL) 1716 error = ENXIO; 1717 NFSDDSUNLOCK(); 1718 if (error) 1719 goto out; 1720 error = newnfs_nmcancelreqs(nmp); 1721 if (error) 1722 goto out; 1723 /* For a forced close, get rid of the renew thread now */ 1724 nfscl_umount(nmp, td); 1725 } 1726 /* We hold 1 extra ref on the root vnode; see comment in mountnfs(). */ 1727 do { 1728 error = vflush(mp, 1, flags, td); 1729 if ((mntflags & MNT_FORCE) && error != 0 && ++trycnt < 30) 1730 (void) nfs_catnap(PSOCK, error, "newndm"); 1731 } while ((mntflags & MNT_FORCE) && error != 0 && trycnt < 30); 1732 if (error) 1733 goto out; 1734 1735 /* 1736 * We are now committed to the unmount. 1737 */ 1738 if ((mntflags & MNT_FORCE) == 0) 1739 nfscl_umount(nmp, td); 1740 else { 1741 mtx_lock(&nmp->nm_mtx); 1742 nmp->nm_privflag |= NFSMNTP_FORCEDISM; 1743 mtx_unlock(&nmp->nm_mtx); 1744 } 1745 /* Make sure no nfsiods are assigned to this mount. */ 1746 NFSLOCKIOD(); 1747 for (i = 0; i < NFS_MAXASYNCDAEMON; i++) 1748 if (ncl_iodmount[i] == nmp) { 1749 ncl_iodwant[i] = NFSIOD_AVAILABLE; 1750 ncl_iodmount[i] = NULL; 1751 } 1752 NFSUNLOCKIOD(); 1753 1754 /* 1755 * We can now set mnt_data to NULL and wait for 1756 * nfssvc(NFSSVC_FORCEDISM) to complete. 1757 */ 1758 mtx_lock(&mountlist_mtx); 1759 mtx_lock(&nmp->nm_mtx); 1760 mp->mnt_data = NULL; 1761 mtx_unlock(&mountlist_mtx); 1762 while ((nmp->nm_privflag & NFSMNTP_CANCELRPCS) != 0) 1763 msleep(nmp, &nmp->nm_mtx, PVFS, "nfsfdism", 0); 1764 mtx_unlock(&nmp->nm_mtx); 1765 1766 newnfs_disconnect(&nmp->nm_sockreq); 1767 crfree(nmp->nm_sockreq.nr_cred); 1768 free(nmp->nm_nam, M_SONAME); 1769 if (nmp->nm_sockreq.nr_auth != NULL) 1770 AUTH_DESTROY(nmp->nm_sockreq.nr_auth); 1771 mtx_destroy(&nmp->nm_sockreq.nr_mtx); 1772 mtx_destroy(&nmp->nm_mtx); 1773 TAILQ_FOREACH_SAFE(dsp, &nmp->nm_sess, nfsclds_list, tdsp) { 1774 if (dsp != TAILQ_FIRST(&nmp->nm_sess) && 1775 dsp->nfsclds_sockp != NULL) 1776 newnfs_disconnect(dsp->nfsclds_sockp); 1777 nfscl_freenfsclds(dsp); 1778 } 1779 free(nmp, M_NEWNFSMNT); 1780 out: 1781 return (error); 1782 } 1783 1784 /* 1785 * Return root of a filesystem 1786 */ 1787 static int 1788 nfs_root(struct mount *mp, int flags, struct vnode **vpp) 1789 { 1790 struct vnode *vp; 1791 struct nfsmount *nmp; 1792 struct nfsnode *np; 1793 int error; 1794 1795 nmp = VFSTONFS(mp); 1796 error = ncl_nget(mp, nmp->nm_fh, nmp->nm_fhsize, &np, flags); 1797 if (error) 1798 return error; 1799 vp = NFSTOV(np); 1800 /* 1801 * Get transfer parameters and attributes for root vnode once. 1802 */ 1803 mtx_lock(&nmp->nm_mtx); 1804 if (NFSHASNFSV3(nmp) && !NFSHASGOTFSINFO(nmp)) { 1805 mtx_unlock(&nmp->nm_mtx); 1806 ncl_fsinfo(nmp, vp, curthread->td_ucred, curthread); 1807 } else 1808 mtx_unlock(&nmp->nm_mtx); 1809 if (vp->v_type == VNON) 1810 vp->v_type = VDIR; 1811 vp->v_vflag |= VV_ROOT; 1812 *vpp = vp; 1813 return (0); 1814 } 1815 1816 /* 1817 * Flush out the buffer cache 1818 */ 1819 /* ARGSUSED */ 1820 static int 1821 nfs_sync(struct mount *mp, int waitfor) 1822 { 1823 struct vnode *vp, *mvp; 1824 struct thread *td; 1825 int error, allerror = 0; 1826 1827 td = curthread; 1828 1829 MNT_ILOCK(mp); 1830 /* 1831 * If a forced dismount is in progress, return from here so that 1832 * the umount(2) syscall doesn't get stuck in VFS_SYNC() before 1833 * calling VFS_UNMOUNT(). 1834 */ 1835 if (NFSCL_FORCEDISM(mp)) { 1836 MNT_IUNLOCK(mp); 1837 return (EBADF); 1838 } 1839 MNT_IUNLOCK(mp); 1840 1841 /* 1842 * Force stale buffer cache information to be flushed. 1843 */ 1844 loop: 1845 MNT_VNODE_FOREACH_ALL(vp, mp, mvp) { 1846 /* XXX Racy bv_cnt check. */ 1847 if (NFSVOPISLOCKED(vp) || vp->v_bufobj.bo_dirty.bv_cnt == 0 || 1848 waitfor == MNT_LAZY) { 1849 VI_UNLOCK(vp); 1850 continue; 1851 } 1852 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK)) { 1853 MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp); 1854 goto loop; 1855 } 1856 error = VOP_FSYNC(vp, waitfor, td); 1857 if (error) 1858 allerror = error; 1859 NFSVOPUNLOCK(vp); 1860 vrele(vp); 1861 } 1862 return (allerror); 1863 } 1864 1865 static int 1866 nfs_sysctl(struct mount *mp, fsctlop_t op, struct sysctl_req *req) 1867 { 1868 struct nfsmount *nmp = VFSTONFS(mp); 1869 struct vfsquery vq; 1870 int error; 1871 1872 bzero(&vq, sizeof(vq)); 1873 switch (op) { 1874 #if 0 1875 case VFS_CTL_NOLOCKS: 1876 val = (nmp->nm_flag & NFSMNT_NOLOCKS) ? 1 : 0; 1877 if (req->oldptr != NULL) { 1878 error = SYSCTL_OUT(req, &val, sizeof(val)); 1879 if (error) 1880 return (error); 1881 } 1882 if (req->newptr != NULL) { 1883 error = SYSCTL_IN(req, &val, sizeof(val)); 1884 if (error) 1885 return (error); 1886 if (val) 1887 nmp->nm_flag |= NFSMNT_NOLOCKS; 1888 else 1889 nmp->nm_flag &= ~NFSMNT_NOLOCKS; 1890 } 1891 break; 1892 #endif 1893 case VFS_CTL_QUERY: 1894 mtx_lock(&nmp->nm_mtx); 1895 if (nmp->nm_state & NFSSTA_TIMEO) 1896 vq.vq_flags |= VQ_NOTRESP; 1897 mtx_unlock(&nmp->nm_mtx); 1898 #if 0 1899 if (!(nmp->nm_flag & NFSMNT_NOLOCKS) && 1900 (nmp->nm_state & NFSSTA_LOCKTIMEO)) 1901 vq.vq_flags |= VQ_NOTRESPLOCK; 1902 #endif 1903 error = SYSCTL_OUT(req, &vq, sizeof(vq)); 1904 break; 1905 case VFS_CTL_TIMEO: 1906 if (req->oldptr != NULL) { 1907 error = SYSCTL_OUT(req, &nmp->nm_tprintf_initial_delay, 1908 sizeof(nmp->nm_tprintf_initial_delay)); 1909 if (error) 1910 return (error); 1911 } 1912 if (req->newptr != NULL) { 1913 error = vfs_suser(mp, req->td); 1914 if (error) 1915 return (error); 1916 error = SYSCTL_IN(req, &nmp->nm_tprintf_initial_delay, 1917 sizeof(nmp->nm_tprintf_initial_delay)); 1918 if (error) 1919 return (error); 1920 if (nmp->nm_tprintf_initial_delay < 0) 1921 nmp->nm_tprintf_initial_delay = 0; 1922 } 1923 break; 1924 default: 1925 return (ENOTSUP); 1926 } 1927 return (0); 1928 } 1929 1930 /* 1931 * Purge any RPCs in progress, so that they will all return errors. 1932 * This allows dounmount() to continue as far as VFS_UNMOUNT() for a 1933 * forced dismount. 1934 */ 1935 static void 1936 nfs_purge(struct mount *mp) 1937 { 1938 struct nfsmount *nmp = VFSTONFS(mp); 1939 1940 newnfs_nmcancelreqs(nmp); 1941 } 1942 1943 /* 1944 * Extract the information needed by the nlm from the nfs vnode. 1945 */ 1946 static void 1947 nfs_getnlminfo(struct vnode *vp, uint8_t *fhp, size_t *fhlenp, 1948 struct sockaddr_storage *sp, int *is_v3p, off_t *sizep, 1949 struct timeval *timeop) 1950 { 1951 struct nfsmount *nmp; 1952 struct nfsnode *np = VTONFS(vp); 1953 1954 nmp = VFSTONFS(vp->v_mount); 1955 if (fhlenp != NULL) 1956 *fhlenp = (size_t)np->n_fhp->nfh_len; 1957 if (fhp != NULL) 1958 bcopy(np->n_fhp->nfh_fh, fhp, np->n_fhp->nfh_len); 1959 if (sp != NULL) 1960 bcopy(nmp->nm_nam, sp, min(nmp->nm_nam->sa_len, sizeof(*sp))); 1961 if (is_v3p != NULL) 1962 *is_v3p = NFS_ISV3(vp); 1963 if (sizep != NULL) 1964 *sizep = np->n_size; 1965 if (timeop != NULL) { 1966 timeop->tv_sec = nmp->nm_timeo / NFS_HZ; 1967 timeop->tv_usec = (nmp->nm_timeo % NFS_HZ) * (1000000 / NFS_HZ); 1968 } 1969 } 1970 1971 /* 1972 * This function prints out an option name, based on the conditional 1973 * argument. 1974 */ 1975 static __inline void nfscl_printopt(struct nfsmount *nmp, int testval, 1976 char *opt, char **buf, size_t *blen) 1977 { 1978 int len; 1979 1980 if (testval != 0 && *blen > strlen(opt)) { 1981 len = snprintf(*buf, *blen, "%s", opt); 1982 if (len != strlen(opt)) 1983 printf("EEK!!\n"); 1984 *buf += len; 1985 *blen -= len; 1986 } 1987 } 1988 1989 /* 1990 * This function printf out an options integer value. 1991 */ 1992 static __inline void nfscl_printoptval(struct nfsmount *nmp, int optval, 1993 char *opt, char **buf, size_t *blen) 1994 { 1995 int len; 1996 1997 if (*blen > strlen(opt) + 1) { 1998 /* Could result in truncated output string. */ 1999 len = snprintf(*buf, *blen, "%s=%d", opt, optval); 2000 if (len < *blen) { 2001 *buf += len; 2002 *blen -= len; 2003 } 2004 } 2005 } 2006 2007 /* 2008 * Load the option flags and values into the buffer. 2009 */ 2010 void nfscl_retopts(struct nfsmount *nmp, char *buffer, size_t buflen) 2011 { 2012 char *buf; 2013 size_t blen; 2014 2015 buf = buffer; 2016 blen = buflen; 2017 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NFSV4) != 0, "nfsv4", &buf, 2018 &blen); 2019 if ((nmp->nm_flag & NFSMNT_NFSV4) != 0) { 2020 nfscl_printoptval(nmp, nmp->nm_minorvers, ",minorversion", &buf, 2021 &blen); 2022 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_PNFS) != 0, ",pnfs", 2023 &buf, &blen); 2024 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_ONEOPENOWN) != 0 && 2025 nmp->nm_minorvers > 0, ",oneopenown", &buf, &blen); 2026 } 2027 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NFSV3) != 0, "nfsv3", &buf, 2028 &blen); 2029 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NFSV3 | NFSMNT_NFSV4)) == 0, 2030 "nfsv2", &buf, &blen); 2031 nfscl_printopt(nmp, nmp->nm_sotype == SOCK_STREAM, ",tcp", &buf, &blen); 2032 nfscl_printopt(nmp, nmp->nm_sotype != SOCK_STREAM, ",udp", &buf, &blen); 2033 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_RESVPORT) != 0, ",resvport", 2034 &buf, &blen); 2035 nfscl_printopt(nmp, (nmp->nm_newflag & NFSMNT_TLS) != 0, ",tls", &buf, 2036 &blen); 2037 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCONN) != 0, ",noconn", 2038 &buf, &blen); 2039 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_SOFT) == 0, ",hard", &buf, 2040 &blen); 2041 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_SOFT) != 0, ",soft", &buf, 2042 &blen); 2043 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_INT) != 0, ",intr", &buf, 2044 &blen); 2045 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCTO) == 0, ",cto", &buf, 2046 &blen); 2047 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NOCTO) != 0, ",nocto", &buf, 2048 &blen); 2049 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_NONCONTIGWR) != 0, 2050 ",noncontigwr", &buf, &blen); 2051 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NOLOCKD | NFSMNT_NFSV4)) == 2052 0, ",lockd", &buf, &blen); 2053 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_NOLOCKD | NFSMNT_NFSV4)) == 2054 NFSMNT_NOLOCKD, ",nolockd", &buf, &blen); 2055 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_RDIRPLUS) != 0, ",rdirplus", 2056 &buf, &blen); 2057 nfscl_printopt(nmp, (nmp->nm_flag & NFSMNT_KERB) == 0, ",sec=sys", 2058 &buf, &blen); 2059 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY | 2060 NFSMNT_PRIVACY)) == NFSMNT_KERB, ",sec=krb5", &buf, &blen); 2061 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY | 2062 NFSMNT_PRIVACY)) == (NFSMNT_KERB | NFSMNT_INTEGRITY), ",sec=krb5i", 2063 &buf, &blen); 2064 nfscl_printopt(nmp, (nmp->nm_flag & (NFSMNT_KERB | NFSMNT_INTEGRITY | 2065 NFSMNT_PRIVACY)) == (NFSMNT_KERB | NFSMNT_PRIVACY), ",sec=krb5p", 2066 &buf, &blen); 2067 nfscl_printoptval(nmp, nmp->nm_acdirmin, ",acdirmin", &buf, &blen); 2068 nfscl_printoptval(nmp, nmp->nm_acdirmax, ",acdirmax", &buf, &blen); 2069 nfscl_printoptval(nmp, nmp->nm_acregmin, ",acregmin", &buf, &blen); 2070 nfscl_printoptval(nmp, nmp->nm_acregmax, ",acregmax", &buf, &blen); 2071 nfscl_printoptval(nmp, nmp->nm_nametimeo, ",nametimeo", &buf, &blen); 2072 nfscl_printoptval(nmp, nmp->nm_negnametimeo, ",negnametimeo", &buf, 2073 &blen); 2074 nfscl_printoptval(nmp, nmp->nm_rsize, ",rsize", &buf, &blen); 2075 nfscl_printoptval(nmp, nmp->nm_wsize, ",wsize", &buf, &blen); 2076 nfscl_printoptval(nmp, nmp->nm_readdirsize, ",readdirsize", &buf, 2077 &blen); 2078 nfscl_printoptval(nmp, nmp->nm_readahead, ",readahead", &buf, &blen); 2079 nfscl_printoptval(nmp, nmp->nm_wcommitsize, ",wcommitsize", &buf, 2080 &blen); 2081 nfscl_printoptval(nmp, nmp->nm_timeo, ",timeout", &buf, &blen); 2082 nfscl_printoptval(nmp, nmp->nm_retry, ",retrans", &buf, &blen); 2083 } 2084