nfs_vfsops.c revision 1.1
1 /* 2 * Copyright (c) 1989 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Rick Macklem at The University of Guelph. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed by the University of 19 * California, Berkeley and its contributors. 20 * 4. Neither the name of the University nor the names of its contributors 21 * may be used to endorse or promote products derived from this software 22 * without specific prior written permission. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 * @(#)nfs_vfsops.c 7.31 (Berkeley) 5/6/91 37 */ 38 39 #include "param.h" 40 #include "conf.h" 41 #include "ioctl.h" 42 #include "signal.h" 43 #include "proc.h" 44 #include "namei.h" 45 #include "vnode.h" 46 #include "mount.h" 47 #include "buf.h" 48 #include "mbuf.h" 49 #include "socket.h" 50 #include "systm.h" 51 52 #include "../net/if.h" 53 #include "../net/route.h" 54 #include "../netinet/in.h" 55 56 #include "nfsv2.h" 57 #include "nfsnode.h" 58 #include "nfsmount.h" 59 #include "nfs.h" 60 #include "xdr_subs.h" 61 #include "nfsm_subs.h" 62 #include "nfsdiskless.h" 63 64 /* 65 * nfs vfs operations. 66 */ 67 struct vfsops nfs_vfsops = { 68 nfs_mount, 69 nfs_start, 70 nfs_unmount, 71 nfs_root, 72 nfs_quotactl, 73 nfs_statfs, 74 nfs_sync, 75 nfs_fhtovp, 76 nfs_vptofh, 77 nfs_init, 78 }; 79 80 static u_char nfs_mntid; 81 extern u_long nfs_procids[NFS_NPROCS]; 82 extern u_long nfs_prog, nfs_vers; 83 struct nfs_diskless nfs_diskless; 84 void nfs_disconnect(); 85 86 #define TRUE 1 87 #define FALSE 0 88 89 /* 90 * nfs statfs call 91 */ 92 nfs_statfs(mp, sbp, p) 93 struct mount *mp; 94 register struct statfs *sbp; 95 struct proc *p; 96 { 97 register struct vnode *vp; 98 register struct nfsv2_statfs *sfp; 99 register caddr_t cp; 100 register long t1; 101 caddr_t bpos, dpos, cp2; 102 u_long xid; 103 int error = 0; 104 struct mbuf *mreq, *mrep, *md, *mb, *mb2; 105 struct nfsmount *nmp; 106 struct ucred *cred; 107 struct nfsnode *np; 108 109 nmp = VFSTONFS(mp); 110 if (error = nfs_nget(mp, &nmp->nm_fh, &np)) 111 return (error); 112 vp = NFSTOV(np); 113 nfsstats.rpccnt[NFSPROC_STATFS]++; 114 cred = crget(); 115 cred->cr_ngroups = 1; 116 nfsm_reqhead(nfs_procids[NFSPROC_STATFS], cred, NFSX_FH); 117 nfsm_fhtom(vp); 118 nfsm_request(vp, NFSPROC_STATFS, p, 0); 119 nfsm_disect(sfp, struct nfsv2_statfs *, NFSX_STATFS); 120 sbp->f_type = MOUNT_NFS; 121 sbp->f_flags = nmp->nm_flag; 122 sbp->f_bsize = fxdr_unsigned(long, sfp->sf_tsize); 123 sbp->f_fsize = fxdr_unsigned(long, sfp->sf_bsize); 124 sbp->f_blocks = fxdr_unsigned(long, sfp->sf_blocks); 125 sbp->f_bfree = fxdr_unsigned(long, sfp->sf_bfree); 126 sbp->f_bavail = fxdr_unsigned(long, sfp->sf_bavail); 127 sbp->f_files = 0; 128 sbp->f_ffree = 0; 129 if (sbp != &mp->mnt_stat) { 130 bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN); 131 bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN); 132 } 133 nfsm_reqdone; 134 nfs_nput(vp); 135 crfree(cred); 136 return (error); 137 } 138 139 /* 140 * Mount a remote root fs via. nfs. This depends on the info in the 141 * nfs_diskless structure that has been filled in properly by some primary 142 * bootstrap. 143 * It goes something like this: 144 * - do enough of "ifconfig" by calling ifioctl() so that the system 145 * can talk to the server 146 * - If nfs_diskless.mygateway is filled in, use that address as 147 * a default gateway. 148 * (This is done the 4.3 way with rtioctl() and should be changed) 149 * - hand craft the swap nfs vnode hanging off a fake mount point 150 * - build the rootfs mount point and call mountnfs() to do the rest. 151 */ 152 nfs_mountroot() 153 { 154 register struct mount *mp; 155 register struct mbuf *m; 156 struct socket *so; 157 struct vnode *vp; 158 int error; 159 160 /* 161 * Do enough of ifconfig(8) so that critical net interface can 162 * talk to the server. 163 */ 164 if (socreate(nfs_diskless.myif.ifra_addr.sa_family, &so, SOCK_DGRAM, 0)) 165 panic("nfs ifconf"); 166 if (ifioctl(so, SIOCAIFADDR, &nfs_diskless.myif)) 167 panic("nfs ifconf2"); 168 soclose(so); 169 170 /* 171 * If the gateway field is filled in, set it as the default route. 172 */ 173 #ifdef COMPAT_43 174 if (nfs_diskless.mygateway.sa_family == AF_INET) { 175 struct ortentry rt; 176 struct sockaddr_in *sin; 177 178 sin = (struct sockaddr_in *) &rt.rt_dst; 179 sin->sin_len = sizeof (struct sockaddr_in); 180 sin->sin_family = AF_INET; 181 sin->sin_addr.s_addr = 0; /* default */ 182 bcopy((caddr_t)&nfs_diskless.mygateway, (caddr_t)&rt.rt_gateway, 183 sizeof (struct sockaddr_in)); 184 rt.rt_flags = (RTF_UP | RTF_GATEWAY); 185 if (rtioctl(SIOCADDRT, (caddr_t)&rt)) 186 panic("nfs root route"); 187 } 188 #endif /* COMPAT_43 */ 189 190 /* 191 * If swapping to an nfs node (indicated by swdevt[0].sw_dev == NODEV): 192 * Create a fake mount point just for the swap vnode so that the 193 * swap file can be on a different server from the rootfs. 194 */ 195 if (swdevt[0].sw_dev == NODEV) { 196 mp = (struct mount *)malloc((u_long)sizeof(struct mount), 197 M_MOUNT, M_NOWAIT); 198 if (mp == NULL) 199 panic("nfs root mount"); 200 mp->mnt_op = &nfs_vfsops; 201 mp->mnt_flag = 0; 202 mp->mnt_exroot = 0; 203 mp->mnt_mounth = NULLVP; 204 205 /* 206 * Set up the diskless nfs_args for the swap mount point 207 * and then call mountnfs() to mount it. 208 * Since the swap file is not the root dir of a file system, 209 * hack it to a regular file. 210 */ 211 nfs_diskless.swap_args.fh = (nfsv2fh_t *)nfs_diskless.swap_fh; 212 MGET(m, MT_SONAME, M_DONTWAIT); 213 if (m == NULL) 214 panic("nfs root mbuf"); 215 bcopy((caddr_t)&nfs_diskless.swap_saddr, mtod(m, caddr_t), 216 nfs_diskless.swap_saddr.sa_len); 217 m->m_len = nfs_diskless.swap_saddr.sa_len; 218 if (mountnfs(&nfs_diskless.swap_args, mp, m, "/swap", 219 nfs_diskless.swap_hostnam, &vp)) 220 panic("nfs swap"); 221 vp->v_type = VREG; 222 vp->v_flag = 0; 223 swapdev_vp = vp; 224 VREF(vp); 225 swdevt[0].sw_vp = vp; 226 } 227 228 /* 229 * Create the rootfs mount point. 230 */ 231 mp = (struct mount *)malloc((u_long)sizeof(struct mount), 232 M_MOUNT, M_NOWAIT); 233 if (mp == NULL) 234 panic("nfs root mount2"); 235 mp->mnt_op = &nfs_vfsops; 236 mp->mnt_flag = MNT_RDONLY; 237 mp->mnt_exroot = 0; 238 mp->mnt_mounth = NULLVP; 239 240 /* 241 * Set up the root fs args and call mountnfs() to do the rest. 242 */ 243 nfs_diskless.root_args.fh = (nfsv2fh_t *)nfs_diskless.root_fh; 244 MGET(m, MT_SONAME, M_DONTWAIT); 245 if (m == NULL) 246 panic("nfs root mbuf2"); 247 bcopy((caddr_t)&nfs_diskless.root_saddr, mtod(m, caddr_t), 248 nfs_diskless.root_saddr.sa_len); 249 m->m_len = nfs_diskless.root_saddr.sa_len; 250 if (mountnfs(&nfs_diskless.root_args, mp, m, "/", 251 nfs_diskless.root_hostnam, &vp)) 252 panic("nfs root"); 253 if (vfs_lock(mp)) 254 panic("nfs root2"); 255 rootfs = mp; 256 mp->mnt_next = mp; 257 mp->mnt_prev = mp; 258 mp->mnt_vnodecovered = NULLVP; 259 vfs_unlock(mp); 260 rootvp = vp; 261 inittodr((time_t)0); /* There is no time in the nfs fsstat so ?? */ 262 return (0); 263 } 264 265 /* 266 * VFS Operations. 267 * 268 * mount system call 269 * It seems a bit dumb to copyinstr() the host and path here and then 270 * bcopy() them in mountnfs(), but I wanted to detect errors before 271 * doing the sockargs() call because sockargs() allocates an mbuf and 272 * an error after that means that I have to release the mbuf. 273 */ 274 /* ARGSUSED */ 275 nfs_mount(mp, path, data, ndp, p) 276 struct mount *mp; 277 char *path; 278 caddr_t data; 279 struct nameidata *ndp; 280 struct proc *p; 281 { 282 int error; 283 struct nfs_args args; 284 struct mbuf *nam; 285 struct vnode *vp; 286 char pth[MNAMELEN], hst[MNAMELEN]; 287 u_int len; 288 nfsv2fh_t nfh; 289 290 if (mp->mnt_flag & MNT_UPDATE) 291 return (0); 292 if (error = copyin(data, (caddr_t)&args, sizeof (struct nfs_args))) 293 return (error); 294 if (error = copyin((caddr_t)args.fh, (caddr_t)&nfh, sizeof (nfsv2fh_t))) 295 return (error); 296 if (error = copyinstr(path, pth, MNAMELEN-1, &len)) 297 return (error); 298 bzero(&pth[len], MNAMELEN - len); 299 if (error = copyinstr(args.hostname, hst, MNAMELEN-1, &len)) 300 return (error); 301 bzero(&hst[len], MNAMELEN - len); 302 /* sockargs() call must be after above copyin() calls */ 303 if (error = sockargs(&nam, (caddr_t)args.addr, 304 sizeof (struct sockaddr), MT_SONAME)) 305 return (error); 306 args.fh = &nfh; 307 error = mountnfs(&args, mp, nam, pth, hst, &vp); 308 return (error); 309 } 310 311 /* 312 * Common code for mount and mountroot 313 */ 314 mountnfs(argp, mp, nam, pth, hst, vpp) 315 register struct nfs_args *argp; 316 register struct mount *mp; 317 struct mbuf *nam; 318 char *pth, *hst; 319 struct vnode **vpp; 320 { 321 register struct nfsmount *nmp; 322 struct proc *p = curproc; /* XXX */ 323 struct nfsnode *np; 324 int error; 325 fsid_t tfsid; 326 327 MALLOC(nmp, struct nfsmount *, sizeof *nmp, M_NFSMNT, M_WAITOK); 328 bzero((caddr_t)nmp, sizeof *nmp); 329 mp->mnt_data = (qaddr_t)nmp; 330 /* 331 * Generate a unique nfs mount id. The problem is that a dev number 332 * is not unique across multiple systems. The techique is as follows: 333 * 1) Set to nblkdev,0 which will never be used otherwise 334 * 2) Generate a first guess as nblkdev,nfs_mntid where nfs_mntid is 335 * NOT 0 336 * 3) Loop searching the mount list for another one with same id 337 * If a match, increment val[0] and try again 338 * NB: I increment val[0] { a long } instead of nfs_mntid { a u_char } 339 * so that nfs is not limited to 255 mount points 340 * Incrementing the high order bits does no real harm, since it 341 * simply makes the major dev number tick up. The upper bound is 342 * set to major dev 127 to avoid any sign extention problems 343 */ 344 mp->mnt_stat.f_fsid.val[0] = makedev(nblkdev, 0); 345 mp->mnt_stat.f_fsid.val[1] = MOUNT_NFS; 346 if (++nfs_mntid == 0) 347 ++nfs_mntid; 348 tfsid.val[0] = makedev(nblkdev, nfs_mntid); 349 tfsid.val[1] = MOUNT_NFS; 350 while (rootfs && getvfs(&tfsid)) { 351 tfsid.val[0]++; 352 nfs_mntid++; 353 } 354 if (major(tfsid.val[0]) > 127) { 355 error = ENOENT; 356 goto bad; 357 } 358 mp->mnt_stat.f_fsid.val[0] = tfsid.val[0]; 359 nmp->nm_mountp = mp; 360 nmp->nm_flag = argp->flags; 361 nmp->nm_rto = NFS_TIMEO; 362 nmp->nm_rtt = -1; 363 nmp->nm_rttvar = nmp->nm_rto << 1; 364 nmp->nm_retry = NFS_RETRANS; 365 nmp->nm_wsize = NFS_WSIZE; 366 nmp->nm_rsize = NFS_RSIZE; 367 bcopy((caddr_t)argp->fh, (caddr_t)&nmp->nm_fh, sizeof(nfsv2fh_t)); 368 bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN); 369 bcopy(pth, mp->mnt_stat.f_mntonname, MNAMELEN); 370 nmp->nm_nam = nam; 371 372 if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) { 373 nmp->nm_rto = argp->timeo; 374 /* NFS timeouts are specified in 1/10 sec. */ 375 nmp->nm_rto = (nmp->nm_rto * 10) / NFS_HZ; 376 if (nmp->nm_rto < NFS_MINTIMEO) 377 nmp->nm_rto = NFS_MINTIMEO; 378 else if (nmp->nm_rto > NFS_MAXTIMEO) 379 nmp->nm_rto = NFS_MAXTIMEO; 380 nmp->nm_rttvar = nmp->nm_rto << 1; 381 } 382 383 if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) { 384 nmp->nm_retry = argp->retrans; 385 if (nmp->nm_retry > NFS_MAXREXMIT) 386 nmp->nm_retry = NFS_MAXREXMIT; 387 } 388 389 if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) { 390 nmp->nm_wsize = argp->wsize; 391 /* Round down to multiple of blocksize */ 392 nmp->nm_wsize &= ~0x1ff; 393 if (nmp->nm_wsize <= 0) 394 nmp->nm_wsize = 512; 395 else if (nmp->nm_wsize > NFS_MAXDATA) 396 nmp->nm_wsize = NFS_MAXDATA; 397 } 398 if (nmp->nm_wsize > MAXBSIZE) 399 nmp->nm_wsize = MAXBSIZE; 400 401 if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) { 402 nmp->nm_rsize = argp->rsize; 403 /* Round down to multiple of blocksize */ 404 nmp->nm_rsize &= ~0x1ff; 405 if (nmp->nm_rsize <= 0) 406 nmp->nm_rsize = 512; 407 else if (nmp->nm_rsize > NFS_MAXDATA) 408 nmp->nm_rsize = NFS_MAXDATA; 409 } 410 if (nmp->nm_rsize > MAXBSIZE) 411 nmp->nm_rsize = MAXBSIZE; 412 /* Set up the sockets and per-host congestion */ 413 nmp->nm_sotype = argp->sotype; 414 nmp->nm_soproto = argp->proto; 415 if (error = nfs_connect(nmp)) 416 goto bad; 417 418 if (error = nfs_statfs(mp, &mp->mnt_stat, p)) 419 goto bad; 420 /* 421 * A reference count is needed on the nfsnode representing the 422 * remote root. If this object is not persistent, then backward 423 * traversals of the mount point (i.e. "..") will not work if 424 * the nfsnode gets flushed out of the cache. Ufs does not have 425 * this problem, because one can identify root inodes by their 426 * number == ROOTINO (2). 427 */ 428 if (error = nfs_nget(mp, &nmp->nm_fh, &np)) 429 goto bad; 430 /* 431 * Unlock it, but keep the reference count. 432 */ 433 nfs_unlock(NFSTOV(np)); 434 *vpp = NFSTOV(np); 435 436 return (0); 437 bad: 438 nfs_disconnect(nmp); 439 FREE(nmp, M_NFSMNT); 440 m_freem(nam); 441 return (error); 442 } 443 444 /* 445 * unmount system call 446 */ 447 nfs_unmount(mp, mntflags, p) 448 struct mount *mp; 449 int mntflags; 450 struct proc *p; 451 { 452 register struct nfsmount *nmp; 453 struct nfsnode *np; 454 struct vnode *vp; 455 int error, flags = 0; 456 extern int doforce; 457 458 if (mntflags & MNT_FORCE) { 459 if (!doforce || mp == rootfs) 460 return (EINVAL); 461 flags |= FORCECLOSE; 462 } 463 nmp = VFSTONFS(mp); 464 /* 465 * Clear out the buffer cache 466 */ 467 mntflushbuf(mp, 0); 468 if (mntinvalbuf(mp)) 469 return (EBUSY); 470 /* 471 * Goes something like this.. 472 * - Check for activity on the root vnode (other than ourselves). 473 * - Call vflush() to clear out vnodes for this file system, 474 * except for the root vnode. 475 * - Decrement reference on the vnode representing remote root. 476 * - Close the socket 477 * - Free up the data structures 478 */ 479 /* 480 * We need to decrement the ref. count on the nfsnode representing 481 * the remote root. See comment in mountnfs(). The VFS unmount() 482 * has done vput on this vnode, otherwise we would get deadlock! 483 */ 484 if (error = nfs_nget(mp, &nmp->nm_fh, &np)) 485 return(error); 486 vp = NFSTOV(np); 487 if (vp->v_usecount > 2) { 488 vput(vp); 489 return (EBUSY); 490 } 491 if (error = vflush(mp, vp, flags)) { 492 vput(vp); 493 return (error); 494 } 495 /* 496 * Get rid of two reference counts, and unlock it on the second. 497 */ 498 vrele(vp); 499 vput(vp); 500 nfs_disconnect(nmp); 501 m_freem(nmp->nm_nam); 502 free((caddr_t)nmp, M_NFSMNT); 503 return (0); 504 } 505 506 /* 507 * Return root of a filesystem 508 */ 509 nfs_root(mp, vpp) 510 struct mount *mp; 511 struct vnode **vpp; 512 { 513 register struct vnode *vp; 514 struct nfsmount *nmp; 515 struct nfsnode *np; 516 int error; 517 518 nmp = VFSTONFS(mp); 519 if (error = nfs_nget(mp, &nmp->nm_fh, &np)) 520 return (error); 521 vp = NFSTOV(np); 522 vp->v_type = VDIR; 523 vp->v_flag = VROOT; 524 *vpp = vp; 525 return (0); 526 } 527 528 extern int syncprt; 529 530 /* 531 * Flush out the buffer cache 532 */ 533 /* ARGSUSED */ 534 nfs_sync(mp, waitfor) 535 struct mount *mp; 536 int waitfor; 537 { 538 if (syncprt) 539 bufstats(); 540 /* 541 * Force stale buffer cache information to be flushed. 542 */ 543 mntflushbuf(mp, waitfor == MNT_WAIT ? B_SYNC : 0); 544 return (0); 545 } 546 547 /* 548 * At this point, this should never happen 549 */ 550 /* ARGSUSED */ 551 nfs_fhtovp(mp, fhp, vpp) 552 struct mount *mp; 553 struct fid *fhp; 554 struct vnode **vpp; 555 { 556 557 return (EINVAL); 558 } 559 560 /* 561 * Vnode pointer to File handle, should never happen either 562 */ 563 /* ARGSUSED */ 564 nfs_vptofh(vp, fhp) 565 struct vnode *vp; 566 struct fid *fhp; 567 { 568 569 return (EINVAL); 570 } 571 572 /* 573 * Vfs start routine, a no-op. 574 */ 575 /* ARGSUSED */ 576 nfs_start(mp, flags, p) 577 struct mount *mp; 578 int flags; 579 struct proc *p; 580 { 581 582 return (0); 583 } 584 585 /* 586 * Do operations associated with quotas, not supported 587 */ 588 nfs_quotactl(mp, cmd, uid, arg, p) 589 struct mount *mp; 590 int cmd; 591 uid_t uid; 592 caddr_t arg; 593 struct proc *p; 594 { 595 #ifdef lint 596 mp = mp; cmd = cmd; uid = uid; arg = arg; 597 #endif /* lint */ 598 return (EOPNOTSUPP); 599 } 600
Indexes created Fri Sep 26 08:10:20 GMT 2025