1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1992, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * John Heidemann of the UCLA Ficus project. 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 * @(#)null_vnops.c 8.6 (Berkeley) 5/27/95 35 * 36 * Ancestors: 37 * @(#)lofs_vnops.c 1.2 (Berkeley) 6/18/92 38 * ...and... 39 * @(#)null_vnodeops.c 1.20 92/07/07 UCLA Ficus project 40 * 41 * $FreeBSD$ 42 */ 43 44 /* 45 * Null Layer 46 * 47 * (See mount_nullfs(8) for more information.) 48 * 49 * The null layer duplicates a portion of the filesystem 50 * name space under a new name. In this respect, it is 51 * similar to the loopback filesystem. It differs from 52 * the loopback fs in two respects: it is implemented using 53 * a stackable layers techniques, and its "null-node"s stack above 54 * all lower-layer vnodes, not just over directory vnodes. 55 * 56 * The null layer has two purposes. First, it serves as a demonstration 57 * of layering by proving a layer which does nothing. (It actually 58 * does everything the loopback filesystem does, which is slightly 59 * more than nothing.) Second, the null layer can serve as a prototype 60 * layer. Since it provides all necessary layer framework, 61 * new filesystem layers can be created very easily be starting 62 * with a null layer. 63 * 64 * The remainder of this man page examines the null layer as a basis 65 * for constructing new layers. 66 * 67 * 68 * INSTANTIATING NEW NULL LAYERS 69 * 70 * New null layers are created with mount_nullfs(8). 71 * Mount_nullfs(8) takes two arguments, the pathname 72 * of the lower vfs (target-pn) and the pathname where the null 73 * layer will appear in the namespace (alias-pn). After 74 * the null layer is put into place, the contents 75 * of target-pn subtree will be aliased under alias-pn. 76 * 77 * 78 * OPERATION OF A NULL LAYER 79 * 80 * The null layer is the minimum filesystem layer, 81 * simply bypassing all possible operations to the lower layer 82 * for processing there. The majority of its activity centers 83 * on the bypass routine, through which nearly all vnode operations 84 * pass. 85 * 86 * The bypass routine accepts arbitrary vnode operations for 87 * handling by the lower layer. It begins by examing vnode 88 * operation arguments and replacing any null-nodes by their 89 * lower-layer equivlants. It then invokes the operation 90 * on the lower layer. Finally, it replaces the null-nodes 91 * in the arguments and, if a vnode is return by the operation, 92 * stacks a null-node on top of the returned vnode. 93 * 94 * Although bypass handles most operations, vop_getattr, vop_lock, 95 * vop_unlock, vop_inactive, vop_reclaim, and vop_print are not 96 * bypassed. Vop_getattr must change the fsid being returned. 97 * Vop_lock and vop_unlock must handle any locking for the 98 * current vnode as well as pass the lock request down. 99 * Vop_inactive and vop_reclaim are not bypassed so that 100 * they can handle freeing null-layer specific data. Vop_print 101 * is not bypassed to avoid excessive debugging information. 102 * Also, certain vnode operations change the locking state within 103 * the operation (create, mknod, remove, link, rename, mkdir, rmdir, 104 * and symlink). Ideally these operations should not change the 105 * lock state, but should be changed to let the caller of the 106 * function unlock them. Otherwise all intermediate vnode layers 107 * (such as union, umapfs, etc) must catch these functions to do 108 * the necessary locking at their layer. 109 * 110 * 111 * INSTANTIATING VNODE STACKS 112 * 113 * Mounting associates the null layer with a lower layer, 114 * effect stacking two VFSes. Vnode stacks are instead 115 * created on demand as files are accessed. 116 * 117 * The initial mount creates a single vnode stack for the 118 * root of the new null layer. All other vnode stacks 119 * are created as a result of vnode operations on 120 * this or other null vnode stacks. 121 * 122 * New vnode stacks come into existence as a result of 123 * an operation which returns a vnode. 124 * The bypass routine stacks a null-node above the new 125 * vnode before returning it to the caller. 126 * 127 * For example, imagine mounting a null layer with 128 * "mount_nullfs /usr/include /dev/layer/null". 129 * Changing directory to /dev/layer/null will assign 130 * the root null-node (which was created when the null layer was mounted). 131 * Now consider opening "sys". A vop_lookup would be 132 * done on the root null-node. This operation would bypass through 133 * to the lower layer which would return a vnode representing 134 * the UFS "sys". Null_bypass then builds a null-node 135 * aliasing the UFS "sys" and returns this to the caller. 136 * Later operations on the null-node "sys" will repeat this 137 * process when constructing other vnode stacks. 138 * 139 * 140 * CREATING OTHER FILE SYSTEM LAYERS 141 * 142 * One of the easiest ways to construct new filesystem layers is to make 143 * a copy of the null layer, rename all files and variables, and 144 * then begin modifing the copy. Sed can be used to easily rename 145 * all variables. 146 * 147 * The umap layer is an example of a layer descended from the 148 * null layer. 149 * 150 * 151 * INVOKING OPERATIONS ON LOWER LAYERS 152 * 153 * There are two techniques to invoke operations on a lower layer 154 * when the operation cannot be completely bypassed. Each method 155 * is appropriate in different situations. In both cases, 156 * it is the responsibility of the aliasing layer to make 157 * the operation arguments "correct" for the lower layer 158 * by mapping a vnode arguments to the lower layer. 159 * 160 * The first approach is to call the aliasing layer's bypass routine. 161 * This method is most suitable when you wish to invoke the operation 162 * currently being handled on the lower layer. It has the advantage 163 * that the bypass routine already must do argument mapping. 164 * An example of this is null_getattrs in the null layer. 165 * 166 * A second approach is to directly invoke vnode operations on 167 * the lower layer with the VOP_OPERATIONNAME interface. 168 * The advantage of this method is that it is easy to invoke 169 * arbitrary operations on the lower layer. The disadvantage 170 * is that vnode arguments must be manualy mapped. 171 * 172 */ 173 174 #include <sys/param.h> 175 #include <sys/systm.h> 176 #include <sys/conf.h> 177 #include <sys/kernel.h> 178 #include <sys/lock.h> 179 #include <sys/malloc.h> 180 #include <sys/mount.h> 181 #include <sys/mutex.h> 182 #include <sys/namei.h> 183 #include <sys/sysctl.h> 184 #include <sys/vnode.h> 185 186 #include <fs/nullfs/null.h> 187 188 #include <vm/vm.h> 189 #include <vm/vm_extern.h> 190 #include <vm/vm_object.h> 191 #include <vm/vnode_pager.h> 192 193 static int null_bug_bypass = 0; /* for debugging: enables bypass printf'ing */ 194 SYSCTL_INT(_debug, OID_AUTO, nullfs_bug_bypass, CTLFLAG_RW, 195 &null_bug_bypass, 0, ""); 196 197 /* 198 * This is the 10-Apr-92 bypass routine. 199 * This version has been optimized for speed, throwing away some 200 * safety checks. It should still always work, but it's not as 201 * robust to programmer errors. 202 * 203 * In general, we map all vnodes going down and unmap them on the way back. 204 * As an exception to this, vnodes can be marked "unmapped" by setting 205 * the Nth bit in operation's vdesc_flags. 206 * 207 * Also, some BSD vnode operations have the side effect of vrele'ing 208 * their arguments. With stacking, the reference counts are held 209 * by the upper node, not the lower one, so we must handle these 210 * side-effects here. This is not of concern in Sun-derived systems 211 * since there are no such side-effects. 212 * 213 * This makes the following assumptions: 214 * - only one returned vpp 215 * - no INOUT vpp's (Sun's vop_open has one of these) 216 * - the vnode operation vector of the first vnode should be used 217 * to determine what implementation of the op should be invoked 218 * - all mapped vnodes are of our vnode-type (NEEDSWORK: 219 * problems on rmdir'ing mount points and renaming?) 220 */ 221 int 222 null_bypass(struct vop_generic_args *ap) 223 { 224 struct vnode **this_vp_p; 225 int error; 226 struct vnode *old_vps[VDESC_MAX_VPS]; 227 struct vnode **vps_p[VDESC_MAX_VPS]; 228 struct vnode ***vppp; 229 struct vnodeop_desc *descp = ap->a_desc; 230 int reles, i; 231 232 if (null_bug_bypass) 233 printf ("null_bypass: %s\n", descp->vdesc_name); 234 235 #ifdef DIAGNOSTIC 236 /* 237 * We require at least one vp. 238 */ 239 if (descp->vdesc_vp_offsets == NULL || 240 descp->vdesc_vp_offsets[0] == VDESC_NO_OFFSET) 241 panic ("null_bypass: no vp's in map"); 242 #endif 243 244 /* 245 * Map the vnodes going in. 246 * Later, we'll invoke the operation based on 247 * the first mapped vnode's operation vector. 248 */ 249 reles = descp->vdesc_flags; 250 for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) { 251 if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET) 252 break; /* bail out at end of list */ 253 vps_p[i] = this_vp_p = 254 VOPARG_OFFSETTO(struct vnode**,descp->vdesc_vp_offsets[i],ap); 255 /* 256 * We're not guaranteed that any but the first vnode 257 * are of our type. Check for and don't map any 258 * that aren't. (We must always map first vp or vclean fails.) 259 */ 260 if (i && (*this_vp_p == NULLVP || 261 (*this_vp_p)->v_op != &null_vnodeops)) { 262 old_vps[i] = NULLVP; 263 } else { 264 old_vps[i] = *this_vp_p; 265 *(vps_p[i]) = NULLVPTOLOWERVP(*this_vp_p); 266 /* 267 * XXX - Several operations have the side effect 268 * of vrele'ing their vp's. We must account for 269 * that. (This should go away in the future.) 270 */ 271 if (reles & VDESC_VP0_WILLRELE) 272 VREF(*this_vp_p); 273 } 274 275 } 276 277 /* 278 * Call the operation on the lower layer 279 * with the modified argument structure. 280 */ 281 if (vps_p[0] && *vps_p[0]) 282 error = VCALL(ap); 283 else { 284 printf("null_bypass: no map for %s\n", descp->vdesc_name); 285 error = EINVAL; 286 } 287 288 /* 289 * Maintain the illusion of call-by-value 290 * by restoring vnodes in the argument structure 291 * to their original value. 292 */ 293 reles = descp->vdesc_flags; 294 for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) { 295 if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET) 296 break; /* bail out at end of list */ 297 if (old_vps[i]) { 298 *(vps_p[i]) = old_vps[i]; 299 #if 0 300 if (reles & VDESC_VP0_WILLUNLOCK) 301 VOP_UNLOCK(*(vps_p[i]), 0); 302 #endif 303 if (reles & VDESC_VP0_WILLRELE) 304 vrele(*(vps_p[i])); 305 } 306 } 307 308 /* 309 * Map the possible out-going vpp 310 * (Assumes that the lower layer always returns 311 * a VREF'ed vpp unless it gets an error.) 312 */ 313 if (descp->vdesc_vpp_offset != VDESC_NO_OFFSET && 314 !(descp->vdesc_flags & VDESC_NOMAP_VPP) && 315 !error) { 316 /* 317 * XXX - even though some ops have vpp returned vp's, 318 * several ops actually vrele this before returning. 319 * We must avoid these ops. 320 * (This should go away when these ops are regularized.) 321 */ 322 if (descp->vdesc_flags & VDESC_VPP_WILLRELE) 323 goto out; 324 vppp = VOPARG_OFFSETTO(struct vnode***, 325 descp->vdesc_vpp_offset,ap); 326 if (*vppp) 327 error = null_nodeget(old_vps[0]->v_mount, **vppp, *vppp); 328 } 329 330 out: 331 return (error); 332 } 333 334 static int 335 null_add_writecount(struct vop_add_writecount_args *ap) 336 { 337 struct vnode *lvp, *vp; 338 int error; 339 340 vp = ap->a_vp; 341 lvp = NULLVPTOLOWERVP(vp); 342 VI_LOCK(vp); 343 /* text refs are bypassed to lowervp */ 344 VNASSERT(vp->v_writecount >= 0, vp, ("wrong null writecount")); 345 VNASSERT(vp->v_writecount + ap->a_inc >= 0, vp, 346 ("wrong writecount inc %d", ap->a_inc)); 347 error = VOP_ADD_WRITECOUNT(lvp, ap->a_inc); 348 if (error == 0) 349 vp->v_writecount += ap->a_inc; 350 VI_UNLOCK(vp); 351 return (error); 352 } 353 354 /* 355 * We have to carry on the locking protocol on the null layer vnodes 356 * as we progress through the tree. We also have to enforce read-only 357 * if this layer is mounted read-only. 358 */ 359 static int 360 null_lookup(struct vop_lookup_args *ap) 361 { 362 struct componentname *cnp = ap->a_cnp; 363 struct vnode *dvp = ap->a_dvp; 364 int flags = cnp->cn_flags; 365 struct vnode *vp, *ldvp, *lvp; 366 struct mount *mp; 367 int error; 368 369 mp = dvp->v_mount; 370 if ((flags & ISLASTCN) != 0 && (mp->mnt_flag & MNT_RDONLY) != 0 && 371 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) 372 return (EROFS); 373 /* 374 * Although it is possible to call null_bypass(), we'll do 375 * a direct call to reduce overhead 376 */ 377 ldvp = NULLVPTOLOWERVP(dvp); 378 vp = lvp = NULL; 379 KASSERT((ldvp->v_vflag & VV_ROOT) == 0 || 380 ((dvp->v_vflag & VV_ROOT) != 0 && (flags & ISDOTDOT) == 0), 381 ("ldvp %p fl %#x dvp %p fl %#x flags %#x", ldvp, ldvp->v_vflag, 382 dvp, dvp->v_vflag, flags)); 383 384 /* 385 * Hold ldvp. The reference on it, owned by dvp, is lost in 386 * case of dvp reclamation, and we need ldvp to move our lock 387 * from ldvp to dvp. 388 */ 389 vhold(ldvp); 390 391 error = VOP_LOOKUP(ldvp, &lvp, cnp); 392 393 /* 394 * VOP_LOOKUP() on lower vnode may unlock ldvp, which allows 395 * dvp to be reclaimed due to shared v_vnlock. Check for the 396 * doomed state and return error. 397 */ 398 if ((error == 0 || error == EJUSTRETURN) && 399 VN_IS_DOOMED(dvp)) { 400 error = ENOENT; 401 if (lvp != NULL) 402 vput(lvp); 403 404 /* 405 * If vgone() did reclaimed dvp before curthread 406 * relocked ldvp, the locks of dvp and ldpv are no 407 * longer shared. In this case, relock of ldvp in 408 * lower fs VOP_LOOKUP() does not restore the locking 409 * state of dvp. Compensate for this by unlocking 410 * ldvp and locking dvp, which is also correct if the 411 * locks are still shared. 412 */ 413 VOP_UNLOCK(ldvp); 414 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY); 415 } 416 vdrop(ldvp); 417 418 if (error == EJUSTRETURN && (flags & ISLASTCN) != 0 && 419 (mp->mnt_flag & MNT_RDONLY) != 0 && 420 (cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME)) 421 error = EROFS; 422 423 if ((error == 0 || error == EJUSTRETURN) && lvp != NULL) { 424 if (ldvp == lvp) { 425 *ap->a_vpp = dvp; 426 VREF(dvp); 427 vrele(lvp); 428 } else { 429 error = null_nodeget(mp, lvp, &vp); 430 if (error == 0) 431 *ap->a_vpp = vp; 432 } 433 } 434 return (error); 435 } 436 437 static int 438 null_open(struct vop_open_args *ap) 439 { 440 int retval; 441 struct vnode *vp, *ldvp; 442 443 vp = ap->a_vp; 444 ldvp = NULLVPTOLOWERVP(vp); 445 retval = null_bypass(&ap->a_gen); 446 if (retval == 0) 447 vp->v_object = ldvp->v_object; 448 return (retval); 449 } 450 451 /* 452 * Setattr call. Disallow write attempts if the layer is mounted read-only. 453 */ 454 static int 455 null_setattr(struct vop_setattr_args *ap) 456 { 457 struct vnode *vp = ap->a_vp; 458 struct vattr *vap = ap->a_vap; 459 460 if ((vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL || 461 vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL || 462 vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) && 463 (vp->v_mount->mnt_flag & MNT_RDONLY)) 464 return (EROFS); 465 if (vap->va_size != VNOVAL) { 466 switch (vp->v_type) { 467 case VDIR: 468 return (EISDIR); 469 case VCHR: 470 case VBLK: 471 case VSOCK: 472 case VFIFO: 473 if (vap->va_flags != VNOVAL) 474 return (EOPNOTSUPP); 475 return (0); 476 case VREG: 477 case VLNK: 478 default: 479 /* 480 * Disallow write attempts if the filesystem is 481 * mounted read-only. 482 */ 483 if (vp->v_mount->mnt_flag & MNT_RDONLY) 484 return (EROFS); 485 } 486 } 487 488 return (null_bypass((struct vop_generic_args *)ap)); 489 } 490 491 /* 492 * We handle getattr only to change the fsid. 493 */ 494 static int 495 null_getattr(struct vop_getattr_args *ap) 496 { 497 int error; 498 499 if ((error = null_bypass((struct vop_generic_args *)ap)) != 0) 500 return (error); 501 502 ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0]; 503 return (0); 504 } 505 506 /* 507 * Handle to disallow write access if mounted read-only. 508 */ 509 static int 510 null_access(struct vop_access_args *ap) 511 { 512 struct vnode *vp = ap->a_vp; 513 accmode_t accmode = ap->a_accmode; 514 515 /* 516 * Disallow write attempts on read-only layers; 517 * unless the file is a socket, fifo, or a block or 518 * character device resident on the filesystem. 519 */ 520 if (accmode & VWRITE) { 521 switch (vp->v_type) { 522 case VDIR: 523 case VLNK: 524 case VREG: 525 if (vp->v_mount->mnt_flag & MNT_RDONLY) 526 return (EROFS); 527 break; 528 default: 529 break; 530 } 531 } 532 return (null_bypass((struct vop_generic_args *)ap)); 533 } 534 535 static int 536 null_accessx(struct vop_accessx_args *ap) 537 { 538 struct vnode *vp = ap->a_vp; 539 accmode_t accmode = ap->a_accmode; 540 541 /* 542 * Disallow write attempts on read-only layers; 543 * unless the file is a socket, fifo, or a block or 544 * character device resident on the filesystem. 545 */ 546 if (accmode & VWRITE) { 547 switch (vp->v_type) { 548 case VDIR: 549 case VLNK: 550 case VREG: 551 if (vp->v_mount->mnt_flag & MNT_RDONLY) 552 return (EROFS); 553 break; 554 default: 555 break; 556 } 557 } 558 return (null_bypass((struct vop_generic_args *)ap)); 559 } 560 561 /* 562 * Increasing refcount of lower vnode is needed at least for the case 563 * when lower FS is NFS to do sillyrename if the file is in use. 564 * Unfortunately v_usecount is incremented in many places in 565 * the kernel and, as such, there may be races that result in 566 * the NFS client doing an extraneous silly rename, but that seems 567 * preferable to not doing a silly rename when it is needed. 568 */ 569 static int 570 null_remove(struct vop_remove_args *ap) 571 { 572 int retval, vreleit; 573 struct vnode *lvp, *vp; 574 575 vp = ap->a_vp; 576 if (vrefcnt(vp) > 1) { 577 lvp = NULLVPTOLOWERVP(vp); 578 VREF(lvp); 579 vreleit = 1; 580 } else 581 vreleit = 0; 582 VTONULL(vp)->null_flags |= NULLV_DROP; 583 retval = null_bypass(&ap->a_gen); 584 if (vreleit != 0) 585 vrele(lvp); 586 return (retval); 587 } 588 589 /* 590 * We handle this to eliminate null FS to lower FS 591 * file moving. Don't know why we don't allow this, 592 * possibly we should. 593 */ 594 static int 595 null_rename(struct vop_rename_args *ap) 596 { 597 struct vnode *tdvp = ap->a_tdvp; 598 struct vnode *fvp = ap->a_fvp; 599 struct vnode *fdvp = ap->a_fdvp; 600 struct vnode *tvp = ap->a_tvp; 601 struct null_node *tnn; 602 603 /* Check for cross-device rename. */ 604 if ((fvp->v_mount != tdvp->v_mount) || 605 (tvp && (fvp->v_mount != tvp->v_mount))) { 606 if (tdvp == tvp) 607 vrele(tdvp); 608 else 609 vput(tdvp); 610 if (tvp) 611 vput(tvp); 612 vrele(fdvp); 613 vrele(fvp); 614 return (EXDEV); 615 } 616 617 if (tvp != NULL) { 618 tnn = VTONULL(tvp); 619 tnn->null_flags |= NULLV_DROP; 620 } 621 return (null_bypass((struct vop_generic_args *)ap)); 622 } 623 624 static int 625 null_rmdir(struct vop_rmdir_args *ap) 626 { 627 628 VTONULL(ap->a_vp)->null_flags |= NULLV_DROP; 629 return (null_bypass(&ap->a_gen)); 630 } 631 632 /* 633 * We need to process our own vnode lock and then clear the 634 * interlock flag as it applies only to our vnode, not the 635 * vnodes below us on the stack. 636 */ 637 static int 638 null_lock(struct vop_lock1_args *ap) 639 { 640 struct vnode *vp = ap->a_vp; 641 int flags; 642 struct null_node *nn; 643 struct vnode *lvp; 644 int error; 645 646 if ((ap->a_flags & LK_INTERLOCK) == 0) 647 VI_LOCK(vp); 648 else 649 ap->a_flags &= ~LK_INTERLOCK; 650 flags = ap->a_flags; 651 nn = VTONULL(vp); 652 /* 653 * If we're still active we must ask the lower layer to 654 * lock as ffs has special lock considerations in its 655 * vop lock. 656 */ 657 if (nn != NULL && (lvp = NULLVPTOLOWERVP(vp)) != NULL) { 658 /* 659 * We have to hold the vnode here to solve a potential 660 * reclaim race. If we're forcibly vgone'd while we 661 * still have refs, a thread could be sleeping inside 662 * the lowervp's vop_lock routine. When we vgone we will 663 * drop our last ref to the lowervp, which would allow it 664 * to be reclaimed. The lowervp could then be recycled, 665 * in which case it is not legal to be sleeping in its VOP. 666 * We prevent it from being recycled by holding the vnode 667 * here. 668 */ 669 vholdnz(lvp); 670 VI_UNLOCK(vp); 671 error = VOP_LOCK(lvp, flags); 672 673 /* 674 * We might have slept to get the lock and someone might have 675 * clean our vnode already, switching vnode lock from one in 676 * lowervp to v_lock in our own vnode structure. Handle this 677 * case by reacquiring correct lock in requested mode. 678 */ 679 if (VTONULL(vp) == NULL && error == 0) { 680 ap->a_flags &= ~LK_TYPE_MASK; 681 switch (flags & LK_TYPE_MASK) { 682 case LK_SHARED: 683 ap->a_flags |= LK_SHARED; 684 break; 685 case LK_UPGRADE: 686 case LK_EXCLUSIVE: 687 ap->a_flags |= LK_EXCLUSIVE; 688 break; 689 default: 690 panic("Unsupported lock request %d\n", 691 ap->a_flags); 692 } 693 VOP_UNLOCK(lvp); 694 error = vop_stdlock(ap); 695 } 696 vdrop(lvp); 697 } else { 698 VI_UNLOCK(vp); 699 error = vop_stdlock(ap); 700 } 701 702 return (error); 703 } 704 705 /* 706 * We need to process our own vnode unlock and then clear the 707 * interlock flag as it applies only to our vnode, not the 708 * vnodes below us on the stack. 709 */ 710 static int 711 null_unlock(struct vop_unlock_args *ap) 712 { 713 struct vnode *vp = ap->a_vp; 714 struct null_node *nn; 715 struct vnode *lvp; 716 int error; 717 718 nn = VTONULL(vp); 719 if (nn != NULL && (lvp = NULLVPTOLOWERVP(vp)) != NULL) { 720 vholdnz(lvp); 721 error = VOP_UNLOCK(lvp); 722 vdrop(lvp); 723 } else { 724 error = vop_stdunlock(ap); 725 } 726 727 return (error); 728 } 729 730 /* 731 * Do not allow the VOP_INACTIVE to be passed to the lower layer, 732 * since the reference count on the lower vnode is not related to 733 * ours. 734 */ 735 static int 736 null_want_recycle(struct vnode *vp) 737 { 738 struct vnode *lvp; 739 struct null_node *xp; 740 struct mount *mp; 741 struct null_mount *xmp; 742 743 xp = VTONULL(vp); 744 lvp = NULLVPTOLOWERVP(vp); 745 mp = vp->v_mount; 746 xmp = MOUNTTONULLMOUNT(mp); 747 if ((xmp->nullm_flags & NULLM_CACHE) == 0 || 748 (xp->null_flags & NULLV_DROP) != 0 || 749 (lvp->v_vflag & VV_NOSYNC) != 0) { 750 /* 751 * If this is the last reference and caching of the 752 * nullfs vnodes is not enabled, or the lower vnode is 753 * deleted, then free up the vnode so as not to tie up 754 * the lower vnodes. 755 */ 756 return (1); 757 } 758 return (0); 759 } 760 761 static int 762 null_inactive(struct vop_inactive_args *ap) 763 { 764 struct vnode *vp; 765 766 vp = ap->a_vp; 767 if (null_want_recycle(vp)) { 768 vp->v_object = NULL; 769 vrecycle(vp); 770 } 771 return (0); 772 } 773 774 static int 775 null_need_inactive(struct vop_need_inactive_args *ap) 776 { 777 778 return (null_want_recycle(ap->a_vp)); 779 } 780 781 /* 782 * Now, the nullfs vnode and, due to the sharing lock, the lower 783 * vnode, are exclusively locked, and we shall destroy the null vnode. 784 */ 785 static int 786 null_reclaim(struct vop_reclaim_args *ap) 787 { 788 struct vnode *vp; 789 struct null_node *xp; 790 struct vnode *lowervp; 791 792 vp = ap->a_vp; 793 xp = VTONULL(vp); 794 lowervp = xp->null_lowervp; 795 796 KASSERT(lowervp != NULL && vp->v_vnlock != &vp->v_lock, 797 ("Reclaiming incomplete null vnode %p", vp)); 798 799 null_hashrem(xp); 800 /* 801 * Use the interlock to protect the clearing of v_data to 802 * prevent faults in null_lock(). 803 */ 804 lockmgr(&vp->v_lock, LK_EXCLUSIVE, NULL); 805 VI_LOCK(vp); 806 vp->v_data = NULL; 807 vp->v_object = NULL; 808 vp->v_vnlock = &vp->v_lock; 809 810 /* 811 * If we were opened for write, we leased the write reference 812 * to the lower vnode. If this is a reclamation due to the 813 * forced unmount, undo the reference now. 814 */ 815 if (vp->v_writecount > 0) 816 VOP_ADD_WRITECOUNT(lowervp, -vp->v_writecount); 817 else if (vp->v_writecount < 0) 818 vp->v_writecount = 0; 819 820 VI_UNLOCK(vp); 821 822 if ((xp->null_flags & NULLV_NOUNLOCK) != 0) 823 vunref(lowervp); 824 else 825 vput(lowervp); 826 free(xp, M_NULLFSNODE); 827 828 return (0); 829 } 830 831 static int 832 null_print(struct vop_print_args *ap) 833 { 834 struct vnode *vp = ap->a_vp; 835 836 printf("\tvp=%p, lowervp=%p\n", vp, VTONULL(vp)->null_lowervp); 837 return (0); 838 } 839 840 /* ARGSUSED */ 841 static int 842 null_getwritemount(struct vop_getwritemount_args *ap) 843 { 844 struct null_node *xp; 845 struct vnode *lowervp; 846 struct vnode *vp; 847 848 vp = ap->a_vp; 849 VI_LOCK(vp); 850 xp = VTONULL(vp); 851 if (xp && (lowervp = xp->null_lowervp)) { 852 vholdnz(lowervp); 853 VI_UNLOCK(vp); 854 VOP_GETWRITEMOUNT(lowervp, ap->a_mpp); 855 vdrop(lowervp); 856 } else { 857 VI_UNLOCK(vp); 858 *(ap->a_mpp) = NULL; 859 } 860 return (0); 861 } 862 863 static int 864 null_vptofh(struct vop_vptofh_args *ap) 865 { 866 struct vnode *lvp; 867 868 lvp = NULLVPTOLOWERVP(ap->a_vp); 869 return VOP_VPTOFH(lvp, ap->a_fhp); 870 } 871 872 static int 873 null_vptocnp(struct vop_vptocnp_args *ap) 874 { 875 struct vnode *vp = ap->a_vp; 876 struct vnode **dvp = ap->a_vpp; 877 struct vnode *lvp, *ldvp; 878 struct ucred *cred = ap->a_cred; 879 struct mount *mp; 880 int error, locked; 881 882 locked = VOP_ISLOCKED(vp); 883 lvp = NULLVPTOLOWERVP(vp); 884 vhold(lvp); 885 mp = vp->v_mount; 886 vfs_ref(mp); 887 VOP_UNLOCK(vp); /* vp is held by vn_vptocnp_locked that called us */ 888 ldvp = lvp; 889 vref(lvp); 890 error = vn_vptocnp(&ldvp, cred, ap->a_buf, ap->a_buflen); 891 vdrop(lvp); 892 if (error != 0) { 893 vn_lock(vp, locked | LK_RETRY); 894 vfs_rel(mp); 895 return (ENOENT); 896 } 897 898 error = vn_lock(ldvp, LK_SHARED); 899 if (error != 0) { 900 vrele(ldvp); 901 vn_lock(vp, locked | LK_RETRY); 902 vfs_rel(mp); 903 return (ENOENT); 904 } 905 error = null_nodeget(mp, ldvp, dvp); 906 if (error == 0) { 907 #ifdef DIAGNOSTIC 908 NULLVPTOLOWERVP(*dvp); 909 #endif 910 VOP_UNLOCK(*dvp); /* keep reference on *dvp */ 911 } 912 vn_lock(vp, locked | LK_RETRY); 913 vfs_rel(mp); 914 return (error); 915 } 916 917 /* 918 * Global vfs data structures 919 */ 920 struct vop_vector null_vnodeops = { 921 .vop_bypass = null_bypass, 922 .vop_access = null_access, 923 .vop_accessx = null_accessx, 924 .vop_advlockpurge = vop_stdadvlockpurge, 925 .vop_bmap = VOP_EOPNOTSUPP, 926 .vop_getattr = null_getattr, 927 .vop_getwritemount = null_getwritemount, 928 .vop_inactive = null_inactive, 929 .vop_need_inactive = null_need_inactive, 930 .vop_islocked = vop_stdislocked, 931 .vop_lock1 = null_lock, 932 .vop_lookup = null_lookup, 933 .vop_open = null_open, 934 .vop_print = null_print, 935 .vop_reclaim = null_reclaim, 936 .vop_remove = null_remove, 937 .vop_rename = null_rename, 938 .vop_rmdir = null_rmdir, 939 .vop_setattr = null_setattr, 940 .vop_strategy = VOP_EOPNOTSUPP, 941 .vop_unlock = null_unlock, 942 .vop_vptocnp = null_vptocnp, 943 .vop_vptofh = null_vptofh, 944 .vop_add_writecount = null_add_writecount, 945 }; 946 VFS_VOP_VECTOR_REGISTER(null_vnodeops); 947