1 /* $NetBSD: layer_vnops.c,v 1.35 2008/01/30 09:50:23 ad Exp $ */ 2 3 /* 4 * Copyright (c) 1999 National Aeronautics & Space Administration 5 * All rights reserved. 6 * 7 * This software was written by William Studenmund of the 8 * Numerical Aerospace Simulation Facility, NASA Ames Research Center. 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 National Aeronautics & Space Administration 19 * nor the names of its contributors may be used to endorse or promote 20 * products derived from this software without specific prior written 21 * permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE NATIONAL AERONAUTICS & SPACE ADMINISTRATION 24 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 25 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 26 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ADMINISTRATION OR CONTRIB- 27 * UTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 28 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 * POSSIBILITY OF SUCH DAMAGE. 34 */ 35 /* 36 * Copyright (c) 1992, 1993 37 * The Regents of the University of California. All rights reserved. 38 * 39 * This code is derived from software contributed to Berkeley by 40 * John Heidemann of the UCLA Ficus project. 41 * 42 * Redistribution and use in source and binary forms, with or without 43 * modification, are permitted provided that the following conditions 44 * are met: 45 * 1. Redistributions of source code must retain the above copyright 46 * notice, this list of conditions and the following disclaimer. 47 * 2. Redistributions in binary form must reproduce the above copyright 48 * notice, this list of conditions and the following disclaimer in the 49 * documentation and/or other materials provided with the distribution. 50 * 3. Neither the name of the University nor the names of its contributors 51 * may be used to endorse or promote products derived from this software 52 * without specific prior written permission. 53 * 54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 64 * SUCH DAMAGE. 65 * 66 * @(#)null_vnops.c 8.6 (Berkeley) 5/27/95 67 * 68 * Ancestors: 69 * @(#)lofs_vnops.c 1.2 (Berkeley) 6/18/92 70 * Id: lofs_vnops.c,v 1.11 1992/05/30 10:05:43 jsp Exp jsp 71 * ...and... 72 * @(#)null_vnodeops.c 1.20 92/07/07 UCLA Ficus project 73 */ 74 75 /* 76 * Null Layer vnode routines. 77 * 78 * (See mount_null(8) for more information.) 79 * 80 * The layer.h, layer_extern.h, layer_vfs.c, and layer_vnops.c files provide 81 * the core implementation of the null file system and most other stacked 82 * fs's. The description below refers to the null file system, but the 83 * services provided by the layer* files are useful for all layered fs's. 84 * 85 * The null layer duplicates a portion of the file system 86 * name space under a new name. In this respect, it is 87 * similar to the loopback file system. It differs from 88 * the loopback fs in two respects: it is implemented using 89 * a stackable layers techniques, and it's "null-node"s stack above 90 * all lower-layer vnodes, not just over directory vnodes. 91 * 92 * The null layer has two purposes. First, it serves as a demonstration 93 * of layering by proving a layer which does nothing. (It actually 94 * does everything the loopback file system does, which is slightly 95 * more than nothing.) Second, the null layer can serve as a prototype 96 * layer. Since it provides all necessary layer framework, 97 * new file system layers can be created very easily be starting 98 * with a null layer. 99 * 100 * The remainder of the man page examines the null layer as a basis 101 * for constructing new layers. 102 * 103 * 104 * INSTANTIATING NEW NULL LAYERS 105 * 106 * New null layers are created with mount_null(8). 107 * Mount_null(8) takes two arguments, the pathname 108 * of the lower vfs (target-pn) and the pathname where the null 109 * layer will appear in the namespace (alias-pn). After 110 * the null layer is put into place, the contents 111 * of target-pn subtree will be aliased under alias-pn. 112 * 113 * It is conceivable that other overlay filesystems will take different 114 * parameters. For instance, data migration or access controll layers might 115 * only take one pathname which will serve both as the target-pn and 116 * alias-pn described above. 117 * 118 * 119 * OPERATION OF A NULL LAYER 120 * 121 * The null layer is the minimum file system layer, 122 * simply bypassing all possible operations to the lower layer 123 * for processing there. The majority of its activity centers 124 * on the bypass routine, through which nearly all vnode operations 125 * pass. 126 * 127 * The bypass routine accepts arbitrary vnode operations for 128 * handling by the lower layer. It begins by examing vnode 129 * operation arguments and replacing any layered nodes by their 130 * lower-layer equivalents. It then invokes the operation 131 * on the lower layer. Finally, it replaces the layered nodes 132 * in the arguments and, if a vnode is return by the operation, 133 * stacks a layered node on top of the returned vnode. 134 * 135 * The bypass routine in this file, layer_bypass(), is suitable for use 136 * by many different layered filesystems. It can be used by multiple 137 * filesystems simultaneously. Alternatively, a layered fs may provide 138 * its own bypass routine, in which case layer_bypass() should be used as 139 * a model. For instance, the main functionality provided by umapfs, the user 140 * identity mapping file system, is handled by a custom bypass routine. 141 * 142 * Typically a layered fs registers its selected bypass routine as the 143 * default vnode operation in its vnodeopv_entry_desc table. Additionally 144 * the filesystem must store the bypass entry point in the layerm_bypass 145 * field of struct layer_mount. All other layer routines in this file will 146 * use the layerm_bypass routine. 147 * 148 * Although the bypass routine handles most operations outright, a number 149 * of operations are special cased, and handled by the layered fs. One 150 * group, layer_setattr, layer_getattr, layer_access, layer_open, and 151 * layer_fsync, perform layer-specific manipulation in addition to calling 152 * the bypass routine. The other group 153 154 * Although bypass handles most operations, vop_getattr, vop_lock, 155 * vop_unlock, vop_inactive, vop_reclaim, and vop_print are not 156 * bypassed. Vop_getattr must change the fsid being returned. 157 * Vop_lock and vop_unlock must handle any locking for the 158 * current vnode as well as pass the lock request down. 159 * Vop_inactive and vop_reclaim are not bypassed so that 160 * they can handle freeing null-layer specific data. Vop_print 161 * is not bypassed to avoid excessive debugging information. 162 * Also, certain vnode operations change the locking state within 163 * the operation (create, mknod, remove, link, rename, mkdir, rmdir, 164 * and symlink). Ideally these operations should not change the 165 * lock state, but should be changed to let the caller of the 166 * function unlock them. Otherwise all intermediate vnode layers 167 * (such as union, umapfs, etc) must catch these functions to do 168 * the necessary locking at their layer. 169 * 170 * 171 * INSTANTIATING VNODE STACKS 172 * 173 * Mounting associates the null layer with a lower layer, 174 * effect stacking two VFSes. Vnode stacks are instead 175 * created on demand as files are accessed. 176 * 177 * The initial mount creates a single vnode stack for the 178 * root of the new null layer. All other vnode stacks 179 * are created as a result of vnode operations on 180 * this or other null vnode stacks. 181 * 182 * New vnode stacks come into existence as a result of 183 * an operation which returns a vnode. 184 * The bypass routine stacks a null-node above the new 185 * vnode before returning it to the caller. 186 * 187 * For example, imagine mounting a null layer with 188 * "mount_null /usr/include /dev/layer/null". 189 * Changing directory to /dev/layer/null will assign 190 * the root null-node (which was created when the null layer was mounted). 191 * Now consider opening "sys". A vop_lookup would be 192 * done on the root null-node. This operation would bypass through 193 * to the lower layer which would return a vnode representing 194 * the UFS "sys". layer_bypass then builds a null-node 195 * aliasing the UFS "sys" and returns this to the caller. 196 * Later operations on the null-node "sys" will repeat this 197 * process when constructing other vnode stacks. 198 * 199 * 200 * CREATING OTHER FILE SYSTEM LAYERS 201 * 202 * One of the easiest ways to construct new file system layers is to make 203 * a copy of the null layer, rename all files and variables, and 204 * then begin modifing the copy. Sed can be used to easily rename 205 * all variables. 206 * 207 * The umap layer is an example of a layer descended from the 208 * null layer. 209 * 210 * 211 * INVOKING OPERATIONS ON LOWER LAYERS 212 * 213 * There are two techniques to invoke operations on a lower layer 214 * when the operation cannot be completely bypassed. Each method 215 * is appropriate in different situations. In both cases, 216 * it is the responsibility of the aliasing layer to make 217 * the operation arguments "correct" for the lower layer 218 * by mapping an vnode arguments to the lower layer. 219 * 220 * The first approach is to call the aliasing layer's bypass routine. 221 * This method is most suitable when you wish to invoke the operation 222 * currently being handled on the lower layer. It has the advantage 223 * that the bypass routine already must do argument mapping. 224 * An example of this is null_getattrs in the null layer. 225 * 226 * A second approach is to directly invoke vnode operations on 227 * the lower layer with the VOP_OPERATIONNAME interface. 228 * The advantage of this method is that it is easy to invoke 229 * arbitrary operations on the lower layer. The disadvantage 230 * is that vnodes' arguments must be manually mapped. 231 * 232 */ 233 234 #include <sys/cdefs.h> 235 __KERNEL_RCSID(0, "$NetBSD: layer_vnops.c,v 1.35 2008/01/30 09:50:23 ad Exp $"); 236 237 #include <sys/param.h> 238 #include <sys/systm.h> 239 #include <sys/proc.h> 240 #include <sys/time.h> 241 #include <sys/vnode.h> 242 #include <sys/mount.h> 243 #include <sys/namei.h> 244 #include <sys/kmem.h> 245 #include <sys/buf.h> 246 #include <sys/kauth.h> 247 248 #include <miscfs/genfs/layer.h> 249 #include <miscfs/genfs/layer_extern.h> 250 #include <miscfs/genfs/genfs.h> 251 252 253 /* 254 * This is the 08-June-99 bypass routine, based on the 10-Apr-92 bypass 255 * routine by John Heidemann. 256 * The new element for this version is that the whole nullfs 257 * system gained the concept of locks on the lower node, and locks on 258 * our nodes. When returning from a call to the lower layer, we may 259 * need to update lock state ONLY on our layer. The LAYERFS_UPPER*LOCK() 260 * macros provide this functionality. 261 * The 10-Apr-92 version was optimized for speed, throwing away some 262 * safety checks. It should still always work, but it's not as 263 * robust to programmer errors. 264 * Define SAFETY to include some error checking code. 265 * 266 * In general, we map all vnodes going down and unmap them on the way back. 267 * 268 * Also, some BSD vnode operations have the side effect of vrele'ing 269 * their arguments. With stacking, the reference counts are held 270 * by the upper node, not the lower one, so we must handle these 271 * side-effects here. This is not of concern in Sun-derived systems 272 * since there are no such side-effects. 273 * 274 * New for the 08-June-99 version: we also handle operations which unlock 275 * the passed-in node (typically they vput the node). 276 * 277 * This makes the following assumptions: 278 * - only one returned vpp 279 * - no INOUT vpp's (Sun's vop_open has one of these) 280 * - the vnode operation vector of the first vnode should be used 281 * to determine what implementation of the op should be invoked 282 * - all mapped vnodes are of our vnode-type (NEEDSWORK: 283 * problems on rmdir'ing mount points and renaming?) 284 */ 285 int 286 layer_bypass(v) 287 void *v; 288 { 289 struct vop_generic_args /* { 290 struct vnodeop_desc *a_desc; 291 <other random data follows, presumably> 292 } */ *ap = v; 293 int (**our_vnodeop_p)(void *); 294 struct vnode **this_vp_p; 295 int error, error1; 296 struct vnode *old_vps[VDESC_MAX_VPS], *vp0; 297 struct vnode **vps_p[VDESC_MAX_VPS]; 298 struct vnode ***vppp; 299 struct mount *mp; 300 struct vnodeop_desc *descp = ap->a_desc; 301 int reles, i, flags; 302 303 #ifdef SAFETY 304 /* 305 * We require at least one vp. 306 */ 307 if (descp->vdesc_vp_offsets == NULL || 308 descp->vdesc_vp_offsets[0] == VDESC_NO_OFFSET) 309 panic("%s: no vp's in map.\n", __func__); 310 #endif 311 312 vps_p[0] = 313 VOPARG_OFFSETTO(struct vnode**, descp->vdesc_vp_offsets[0], ap); 314 vp0 = *vps_p[0]; 315 mp = vp0->v_mount; 316 flags = MOUNTTOLAYERMOUNT(mp)->layerm_flags; 317 our_vnodeop_p = vp0->v_op; 318 319 if (flags & LAYERFS_MBYPASSDEBUG) 320 printf("%s: %s\n", __func__, descp->vdesc_name); 321 322 /* 323 * Map the vnodes going in. 324 * Later, we'll invoke the operation based on 325 * the first mapped vnode's operation vector. 326 */ 327 reles = descp->vdesc_flags; 328 for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) { 329 if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET) 330 break; /* bail out at end of list */ 331 vps_p[i] = this_vp_p = 332 VOPARG_OFFSETTO(struct vnode**, descp->vdesc_vp_offsets[i], 333 ap); 334 /* 335 * We're not guaranteed that any but the first vnode 336 * are of our type. Check for and don't map any 337 * that aren't. (We must always map first vp or vclean fails.) 338 */ 339 if (i && (*this_vp_p == NULL || 340 (*this_vp_p)->v_op != our_vnodeop_p)) { 341 old_vps[i] = NULL; 342 } else { 343 old_vps[i] = *this_vp_p; 344 *(vps_p[i]) = LAYERVPTOLOWERVP(*this_vp_p); 345 /* 346 * XXX - Several operations have the side effect 347 * of vrele'ing their vp's. We must account for 348 * that. (This should go away in the future.) 349 */ 350 if (reles & VDESC_VP0_WILLRELE) 351 VREF(*this_vp_p); 352 } 353 354 } 355 356 /* 357 * Call the operation on the lower layer 358 * with the modified argument structure. 359 */ 360 error = VCALL(*vps_p[0], descp->vdesc_offset, ap); 361 362 /* 363 * Maintain the illusion of call-by-value 364 * by restoring vnodes in the argument structure 365 * to their original value. 366 */ 367 reles = descp->vdesc_flags; 368 for (i = 0; i < VDESC_MAX_VPS; reles >>= 1, i++) { 369 if (descp->vdesc_vp_offsets[i] == VDESC_NO_OFFSET) 370 break; /* bail out at end of list */ 371 if (old_vps[i]) { 372 *(vps_p[i]) = old_vps[i]; 373 if (reles & VDESC_VP0_WILLUNLOCK) 374 LAYERFS_UPPERUNLOCK(*(vps_p[i]), 0, error1); 375 if (reles & VDESC_VP0_WILLRELE) 376 vrele(*(vps_p[i])); 377 } 378 } 379 380 /* 381 * Map the possible out-going vpp 382 * (Assumes that the lower layer always returns 383 * a VREF'ed vpp unless it gets an error.) 384 */ 385 if (descp->vdesc_vpp_offset != VDESC_NO_OFFSET && 386 !(descp->vdesc_flags & VDESC_NOMAP_VPP) && 387 !error) { 388 /* 389 * XXX - even though some ops have vpp returned vp's, 390 * several ops actually vrele this before returning. 391 * We must avoid these ops. 392 * (This should go away when these ops are regularized.) 393 */ 394 if (descp->vdesc_flags & VDESC_VPP_WILLRELE) 395 goto out; 396 vppp = VOPARG_OFFSETTO(struct vnode***, 397 descp->vdesc_vpp_offset, ap); 398 /* 399 * Only vop_lookup, vop_create, vop_makedir, vop_bmap, 400 * vop_mknod, and vop_symlink return vpp's. vop_bmap 401 * doesn't call bypass as the lower vpp is fine (we're just 402 * going to do i/o on it). vop_lookup doesn't call bypass 403 * as a lookup on "." would generate a locking error. 404 * So all the calls which get us here have a locked vpp. :-) 405 */ 406 error = layer_node_create(mp, **vppp, *vppp); 407 if (error) { 408 vput(**vppp); 409 **vppp = NULL; 410 } 411 } 412 413 out: 414 return (error); 415 } 416 417 /* 418 * We have to carry on the locking protocol on the layer vnodes 419 * as we progress through the tree. We also have to enforce read-only 420 * if this layer is mounted read-only. 421 */ 422 int 423 layer_lookup(v) 424 void *v; 425 { 426 struct vop_lookup_args /* { 427 struct vnodeop_desc *a_desc; 428 struct vnode * a_dvp; 429 struct vnode ** a_vpp; 430 struct componentname * a_cnp; 431 } */ *ap = v; 432 struct componentname *cnp = ap->a_cnp; 433 int flags = cnp->cn_flags; 434 struct vnode *dvp, *lvp, *ldvp; 435 int error; 436 437 dvp = ap->a_dvp; 438 439 if ((flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) && 440 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) 441 return (EROFS); 442 443 ldvp = LAYERVPTOLOWERVP(dvp); 444 ap->a_dvp = ldvp; 445 error = VCALL(ldvp, ap->a_desc->vdesc_offset, ap); 446 lvp = *ap->a_vpp; 447 *ap->a_vpp = NULL; 448 449 if (error == EJUSTRETURN && (flags & ISLASTCN) && 450 (dvp->v_mount->mnt_flag & MNT_RDONLY) && 451 (cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME)) 452 error = EROFS; 453 454 /* 455 * We must do the same locking and unlocking at this layer as 456 * is done in the layers below us. 457 */ 458 if (ldvp == lvp) { 459 460 /* 461 * Did lookup on "." or ".." in the root node of a mount point. 462 * So we return dvp after a VREF. 463 */ 464 VREF(dvp); 465 *ap->a_vpp = dvp; 466 vrele(lvp); 467 } else if (lvp != NULL) { 468 /* dvp, ldvp and vp are all locked */ 469 error = layer_node_create(dvp->v_mount, lvp, ap->a_vpp); 470 if (error) { 471 vput(lvp); 472 } 473 } 474 return (error); 475 } 476 477 /* 478 * Setattr call. Disallow write attempts if the layer is mounted read-only. 479 */ 480 int 481 layer_setattr(v) 482 void *v; 483 { 484 struct vop_setattr_args /* { 485 struct vnodeop_desc *a_desc; 486 struct vnode *a_vp; 487 struct vattr *a_vap; 488 kauth_cred_t a_cred; 489 struct lwp *a_l; 490 } */ *ap = v; 491 struct vnode *vp = ap->a_vp; 492 struct vattr *vap = ap->a_vap; 493 494 if ((vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL || 495 vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL || 496 vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) && 497 (vp->v_mount->mnt_flag & MNT_RDONLY)) 498 return (EROFS); 499 if (vap->va_size != VNOVAL) { 500 switch (vp->v_type) { 501 case VDIR: 502 return (EISDIR); 503 case VCHR: 504 case VBLK: 505 case VSOCK: 506 case VFIFO: 507 return (0); 508 case VREG: 509 case VLNK: 510 default: 511 /* 512 * Disallow write attempts if the filesystem is 513 * mounted read-only. 514 */ 515 if (vp->v_mount->mnt_flag & MNT_RDONLY) 516 return (EROFS); 517 } 518 } 519 return (LAYERFS_DO_BYPASS(vp, ap)); 520 } 521 522 /* 523 * We handle getattr only to change the fsid. 524 */ 525 int 526 layer_getattr(v) 527 void *v; 528 { 529 struct vop_getattr_args /* { 530 struct vnode *a_vp; 531 struct vattr *a_vap; 532 kauth_cred_t a_cred; 533 struct lwp *a_l; 534 } */ *ap = v; 535 struct vnode *vp = ap->a_vp; 536 int error; 537 538 if ((error = LAYERFS_DO_BYPASS(vp, ap)) != 0) 539 return (error); 540 /* Requires that arguments be restored. */ 541 ap->a_vap->va_fsid = vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0]; 542 return (0); 543 } 544 545 int 546 layer_access(v) 547 void *v; 548 { 549 struct vop_access_args /* { 550 struct vnode *a_vp; 551 int a_mode; 552 kauth_cred_t a_cred; 553 struct lwp *a_l; 554 } */ *ap = v; 555 struct vnode *vp = ap->a_vp; 556 mode_t mode = ap->a_mode; 557 558 /* 559 * Disallow write attempts on read-only layers; 560 * unless the file is a socket, fifo, or a block or 561 * character device resident on the file system. 562 */ 563 if (mode & VWRITE) { 564 switch (vp->v_type) { 565 case VDIR: 566 case VLNK: 567 case VREG: 568 if (vp->v_mount->mnt_flag & MNT_RDONLY) 569 return (EROFS); 570 break; 571 default: 572 break; 573 } 574 } 575 return (LAYERFS_DO_BYPASS(vp, ap)); 576 } 577 578 /* 579 * We must handle open to be able to catch MNT_NODEV and friends. 580 */ 581 int 582 layer_open(v) 583 void *v; 584 { 585 struct vop_open_args *ap = v; 586 struct vnode *vp = ap->a_vp; 587 enum vtype lower_type = LAYERVPTOLOWERVP(vp)->v_type; 588 589 if (((lower_type == VBLK) || (lower_type == VCHR)) && 590 (vp->v_mount->mnt_flag & MNT_NODEV)) 591 return ENXIO; 592 593 return LAYERFS_DO_BYPASS(vp, ap); 594 } 595 596 /* 597 * We need to process our own vnode lock and then clear the 598 * interlock flag as it applies only to our vnode, not the 599 * vnodes below us on the stack. 600 */ 601 int 602 layer_lock(v) 603 void *v; 604 { 605 struct vop_lock_args /* { 606 struct vnode *a_vp; 607 int a_flags; 608 struct proc *a_p; 609 } */ *ap = v; 610 struct vnode *vp = ap->a_vp, *lowervp; 611 int flags = ap->a_flags, error; 612 613 if (flags & LK_INTERLOCK) { 614 mutex_exit(&vp->v_interlock); 615 flags &= ~LK_INTERLOCK; 616 } 617 618 if (vp->v_vnlock != NULL) { 619 /* 620 * The lower level has exported a struct lock to us. Use 621 * it so that all vnodes in the stack lock and unlock 622 * simultaneously. Note: we don't DRAIN the lock as DRAIN 623 * decommissions the lock - just because our vnode is 624 * going away doesn't mean the struct lock below us is. 625 * LK_EXCLUSIVE is fine. 626 */ 627 return (vlockmgr(vp->v_vnlock, flags)); 628 } else { 629 /* 630 * Ahh well. It would be nice if the fs we're over would 631 * export a struct lock for us to use, but it doesn't. 632 * 633 * To prevent race conditions involving doing a lookup 634 * on "..", we have to lock the lower node, then lock our 635 * node. Most of the time it won't matter that we lock our 636 * node (as any locking would need the lower one locked 637 * first). 638 */ 639 lowervp = LAYERVPTOLOWERVP(vp); 640 error = VOP_LOCK(lowervp, flags); 641 if (error) 642 return (error); 643 if ((error = vlockmgr(&vp->v_lock, flags))) { 644 VOP_UNLOCK(lowervp, 0); 645 } 646 return (error); 647 } 648 } 649 650 /* 651 */ 652 int 653 layer_unlock(v) 654 void *v; 655 { 656 struct vop_unlock_args /* { 657 struct vnode *a_vp; 658 int a_flags; 659 struct proc *a_p; 660 } */ *ap = v; 661 struct vnode *vp = ap->a_vp; 662 int flags = ap->a_flags; 663 664 if (flags & LK_INTERLOCK) { 665 mutex_exit(&vp->v_interlock); 666 flags &= ~LK_INTERLOCK; 667 } 668 669 if (vp->v_vnlock != NULL) { 670 return (vlockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE)); 671 } else { 672 VOP_UNLOCK(LAYERVPTOLOWERVP(vp), flags); 673 return (vlockmgr(&vp->v_lock, flags | LK_RELEASE)); 674 } 675 } 676 677 int 678 layer_islocked(v) 679 void *v; 680 { 681 struct vop_islocked_args /* { 682 struct vnode *a_vp; 683 } */ *ap = v; 684 struct vnode *vp = ap->a_vp; 685 int lkstatus; 686 687 if (vp->v_vnlock != NULL) 688 return vlockstatus(vp->v_vnlock); 689 690 lkstatus = VOP_ISLOCKED(LAYERVPTOLOWERVP(vp)); 691 if (lkstatus) 692 return lkstatus; 693 694 return vlockstatus(&vp->v_lock); 695 } 696 697 /* 698 * If vinvalbuf is calling us, it's a "shallow fsync" -- don't bother 699 * syncing the underlying vnodes, since they'll be fsync'ed when 700 * reclaimed; otherwise, 701 * pass it through to the underlying layer. 702 * 703 * XXX Do we still need to worry about shallow fsync? 704 */ 705 706 int 707 layer_fsync(v) 708 void *v; 709 { 710 struct vop_fsync_args /* { 711 struct vnode *a_vp; 712 kauth_cred_t a_cred; 713 int a_flags; 714 off_t offlo; 715 off_t offhi; 716 struct lwp *a_l; 717 } */ *ap = v; 718 719 if (ap->a_flags & FSYNC_RECLAIM) { 720 return 0; 721 } 722 723 return (LAYERFS_DO_BYPASS(ap->a_vp, ap)); 724 } 725 726 727 int 728 layer_inactive(v) 729 void *v; 730 { 731 struct vop_inactive_args /* { 732 struct vnode *a_vp; 733 bool *a_recycle; 734 } */ *ap = v; 735 struct vnode *vp = ap->a_vp; 736 737 /* 738 * ..., but don't cache the device node. Also, if we did a 739 * remove, don't cache the node. 740 */ 741 *ap->a_recycle = (vp->v_type == VBLK || vp->v_type == VCHR 742 || (VTOLAYER(vp)->layer_flags & LAYERFS_REMOVED)); 743 744 /* 745 * Do nothing (and _don't_ bypass). 746 * Wait to vrele lowervp until reclaim, 747 * so that until then our layer_node is in the 748 * cache and reusable. 749 * 750 * NEEDSWORK: Someday, consider inactive'ing 751 * the lowervp and then trying to reactivate it 752 * with capabilities (v_id) 753 * like they do in the name lookup cache code. 754 * That's too much work for now. 755 */ 756 VOP_UNLOCK(vp, 0); 757 758 return (0); 759 } 760 761 int 762 layer_remove(v) 763 void *v; 764 { 765 struct vop_remove_args /* { 766 struct vonde *a_dvp; 767 struct vnode *a_vp; 768 struct componentname *a_cnp; 769 } */ *ap = v; 770 771 int error; 772 struct vnode *vp = ap->a_vp; 773 774 vref(vp); 775 if ((error = LAYERFS_DO_BYPASS(vp, ap)) == 0) 776 VTOLAYER(vp)->layer_flags |= LAYERFS_REMOVED; 777 778 vrele(vp); 779 780 return (error); 781 } 782 783 int 784 layer_rename(v) 785 void *v; 786 { 787 struct vop_rename_args /* { 788 struct vnode *a_fdvp; 789 struct vnode *a_fvp; 790 struct componentname *a_fcnp; 791 struct vnode *a_tdvp; 792 struct vnode *a_tvp; 793 struct componentname *a_tcnp; 794 } */ *ap = v; 795 796 int error; 797 struct vnode *fdvp = ap->a_fdvp; 798 struct vnode *tvp; 799 800 tvp = ap->a_tvp; 801 if (tvp) { 802 if (tvp->v_mount != fdvp->v_mount) 803 tvp = NULL; 804 else 805 vref(tvp); 806 } 807 error = LAYERFS_DO_BYPASS(fdvp, ap); 808 if (tvp) { 809 if (error == 0) 810 VTOLAYER(tvp)->layer_flags |= LAYERFS_REMOVED; 811 vrele(tvp); 812 } 813 814 return (error); 815 } 816 817 int 818 layer_rmdir(v) 819 void *v; 820 { 821 struct vop_rmdir_args /* { 822 struct vnode *a_dvp; 823 struct vnode *a_vp; 824 struct componentname *a_cnp; 825 } */ *ap = v; 826 int error; 827 struct vnode *vp = ap->a_vp; 828 829 vref(vp); 830 if ((error = LAYERFS_DO_BYPASS(vp, ap)) == 0) 831 VTOLAYER(vp)->layer_flags |= LAYERFS_REMOVED; 832 833 vrele(vp); 834 835 return (error); 836 } 837 838 int 839 layer_reclaim(v) 840 void *v; 841 { 842 struct vop_reclaim_args /* { 843 struct vnode *a_vp; 844 struct lwp *a_l; 845 } */ *ap = v; 846 struct vnode *vp = ap->a_vp; 847 struct layer_mount *lmp = MOUNTTOLAYERMOUNT(vp->v_mount); 848 struct layer_node *xp = VTOLAYER(vp); 849 struct vnode *lowervp = xp->layer_lowervp; 850 851 /* 852 * Note: in vop_reclaim, the node's struct lock has been 853 * decomissioned, so we have to be careful about calling 854 * VOP's on ourself. We must be careful as VXLOCK is set. 855 */ 856 /* After this assignment, this node will not be re-used. */ 857 if ((vp == lmp->layerm_rootvp)) { 858 /* 859 * Oops! We no longer have a root node. Most likely reason is 860 * that someone forcably unmunted the underlying fs. 861 * 862 * Now getting the root vnode will fail. We're dead. :-( 863 */ 864 lmp->layerm_rootvp = NULL; 865 } 866 xp->layer_lowervp = NULL; 867 mutex_enter(&lmp->layerm_hashlock); 868 LIST_REMOVE(xp, layer_hash); 869 mutex_exit(&lmp->layerm_hashlock); 870 kmem_free(vp->v_data, lmp->layerm_size); 871 vp->v_data = NULL; 872 vrele(lowervp); 873 874 return (0); 875 } 876 877 /* 878 * We just feed the returned vnode up to the caller - there's no need 879 * to build a layer node on top of the node on which we're going to do 880 * i/o. :-) 881 */ 882 int 883 layer_bmap(v) 884 void *v; 885 { 886 struct vop_bmap_args /* { 887 struct vnode *a_vp; 888 daddr_t a_bn; 889 struct vnode **a_vpp; 890 daddr_t *a_bnp; 891 int *a_runp; 892 } */ *ap = v; 893 struct vnode *vp; 894 895 ap->a_vp = vp = LAYERVPTOLOWERVP(ap->a_vp); 896 897 return (VCALL(vp, ap->a_desc->vdesc_offset, ap)); 898 } 899 900 int 901 layer_print(v) 902 void *v; 903 { 904 struct vop_print_args /* { 905 struct vnode *a_vp; 906 } */ *ap = v; 907 struct vnode *vp = ap->a_vp; 908 printf ("\ttag VT_LAYERFS, vp=%p, lowervp=%p\n", vp, LAYERVPTOLOWERVP(vp)); 909 return (0); 910 } 911 912 /* 913 * XXX - vop_bwrite must be hand coded because it has no 914 * vnode in its arguments. 915 * This goes away with a merged VM/buffer cache. 916 */ 917 int 918 layer_bwrite(v) 919 void *v; 920 { 921 struct vop_bwrite_args /* { 922 struct buf *a_bp; 923 } */ *ap = v; 924 struct buf *bp = ap->a_bp; 925 int error; 926 struct vnode *savedvp; 927 928 savedvp = bp->b_vp; 929 bp->b_vp = LAYERVPTOLOWERVP(bp->b_vp); 930 931 error = VOP_BWRITE(bp); 932 933 bp->b_vp = savedvp; 934 935 return (error); 936 } 937 938 int 939 layer_getpages(v) 940 void *v; 941 { 942 struct vop_getpages_args /* { 943 struct vnode *a_vp; 944 voff_t a_offset; 945 struct vm_page **a_m; 946 int *a_count; 947 int a_centeridx; 948 vm_prot_t a_access_type; 949 int a_advice; 950 int a_flags; 951 } */ *ap = v; 952 struct vnode *vp = ap->a_vp; 953 int error; 954 955 /* 956 * just pass the request on to the underlying layer. 957 */ 958 959 if (ap->a_flags & PGO_LOCKED) { 960 return EBUSY; 961 } 962 ap->a_vp = LAYERVPTOLOWERVP(vp); 963 mutex_exit(&vp->v_interlock); 964 mutex_enter(&ap->a_vp->v_interlock); 965 error = VCALL(ap->a_vp, VOFFSET(vop_getpages), ap); 966 return error; 967 } 968 969 int 970 layer_putpages(v) 971 void *v; 972 { 973 struct vop_putpages_args /* { 974 struct vnode *a_vp; 975 voff_t a_offlo; 976 voff_t a_offhi; 977 int a_flags; 978 } */ *ap = v; 979 struct vnode *vp = ap->a_vp; 980 int error; 981 982 /* 983 * just pass the request on to the underlying layer. 984 */ 985 986 ap->a_vp = LAYERVPTOLOWERVP(vp); 987 mutex_exit(&vp->v_interlock); 988 if (ap->a_flags & PGO_RECLAIM) { 989 return 0; 990 } 991 mutex_enter(&ap->a_vp->v_interlock); 992 error = VCALL(ap->a_vp, VOFFSET(vop_putpages), ap); 993 return error; 994 } 995