1 /* $NetBSD: layer_vnops.c,v 1.36 2009/01/03 04:38:07 dholland 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.36 2009/01/03 04:38:07 dholland 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 * Got the same object back, because we looked up ".", 462 * or ".." in the root node of a mount point. 463 * So we make another reference to dvp and return it. 464 */ 465 VREF(dvp); 466 *ap->a_vpp = dvp; 467 vrele(lvp); 468 } else if (lvp != NULL) { 469 /* dvp, ldvp and vp are all locked */ 470 error = layer_node_create(dvp->v_mount, lvp, ap->a_vpp); 471 if (error) { 472 vput(lvp); 473 } 474 } 475 return (error); 476 } 477 478 /* 479 * Setattr call. Disallow write attempts if the layer is mounted read-only. 480 */ 481 int 482 layer_setattr(v) 483 void *v; 484 { 485 struct vop_setattr_args /* { 486 struct vnodeop_desc *a_desc; 487 struct vnode *a_vp; 488 struct vattr *a_vap; 489 kauth_cred_t a_cred; 490 struct lwp *a_l; 491 } */ *ap = v; 492 struct vnode *vp = ap->a_vp; 493 struct vattr *vap = ap->a_vap; 494 495 if ((vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL || 496 vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL || 497 vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) && 498 (vp->v_mount->mnt_flag & MNT_RDONLY)) 499 return (EROFS); 500 if (vap->va_size != VNOVAL) { 501 switch (vp->v_type) { 502 case VDIR: 503 return (EISDIR); 504 case VCHR: 505 case VBLK: 506 case VSOCK: 507 case VFIFO: 508 return (0); 509 case VREG: 510 case VLNK: 511 default: 512 /* 513 * Disallow write attempts if the filesystem is 514 * mounted read-only. 515 */ 516 if (vp->v_mount->mnt_flag & MNT_RDONLY) 517 return (EROFS); 518 } 519 } 520 return (LAYERFS_DO_BYPASS(vp, ap)); 521 } 522 523 /* 524 * We handle getattr only to change the fsid. 525 */ 526 int 527 layer_getattr(v) 528 void *v; 529 { 530 struct vop_getattr_args /* { 531 struct vnode *a_vp; 532 struct vattr *a_vap; 533 kauth_cred_t a_cred; 534 struct lwp *a_l; 535 } */ *ap = v; 536 struct vnode *vp = ap->a_vp; 537 int error; 538 539 if ((error = LAYERFS_DO_BYPASS(vp, ap)) != 0) 540 return (error); 541 /* Requires that arguments be restored. */ 542 ap->a_vap->va_fsid = vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0]; 543 return (0); 544 } 545 546 int 547 layer_access(v) 548 void *v; 549 { 550 struct vop_access_args /* { 551 struct vnode *a_vp; 552 int a_mode; 553 kauth_cred_t a_cred; 554 struct lwp *a_l; 555 } */ *ap = v; 556 struct vnode *vp = ap->a_vp; 557 mode_t mode = ap->a_mode; 558 559 /* 560 * Disallow write attempts on read-only layers; 561 * unless the file is a socket, fifo, or a block or 562 * character device resident on the file system. 563 */ 564 if (mode & VWRITE) { 565 switch (vp->v_type) { 566 case VDIR: 567 case VLNK: 568 case VREG: 569 if (vp->v_mount->mnt_flag & MNT_RDONLY) 570 return (EROFS); 571 break; 572 default: 573 break; 574 } 575 } 576 return (LAYERFS_DO_BYPASS(vp, ap)); 577 } 578 579 /* 580 * We must handle open to be able to catch MNT_NODEV and friends. 581 */ 582 int 583 layer_open(v) 584 void *v; 585 { 586 struct vop_open_args *ap = v; 587 struct vnode *vp = ap->a_vp; 588 enum vtype lower_type = LAYERVPTOLOWERVP(vp)->v_type; 589 590 if (((lower_type == VBLK) || (lower_type == VCHR)) && 591 (vp->v_mount->mnt_flag & MNT_NODEV)) 592 return ENXIO; 593 594 return LAYERFS_DO_BYPASS(vp, ap); 595 } 596 597 /* 598 * We need to process our own vnode lock and then clear the 599 * interlock flag as it applies only to our vnode, not the 600 * vnodes below us on the stack. 601 */ 602 int 603 layer_lock(v) 604 void *v; 605 { 606 struct vop_lock_args /* { 607 struct vnode *a_vp; 608 int a_flags; 609 struct proc *a_p; 610 } */ *ap = v; 611 struct vnode *vp = ap->a_vp, *lowervp; 612 int flags = ap->a_flags, error; 613 614 if (flags & LK_INTERLOCK) { 615 mutex_exit(&vp->v_interlock); 616 flags &= ~LK_INTERLOCK; 617 } 618 619 if (vp->v_vnlock != NULL) { 620 /* 621 * The lower level has exported a struct lock to us. Use 622 * it so that all vnodes in the stack lock and unlock 623 * simultaneously. Note: we don't DRAIN the lock as DRAIN 624 * decommissions the lock - just because our vnode is 625 * going away doesn't mean the struct lock below us is. 626 * LK_EXCLUSIVE is fine. 627 */ 628 return (vlockmgr(vp->v_vnlock, flags)); 629 } else { 630 /* 631 * Ahh well. It would be nice if the fs we're over would 632 * export a struct lock for us to use, but it doesn't. 633 * 634 * To prevent race conditions involving doing a lookup 635 * on "..", we have to lock the lower node, then lock our 636 * node. Most of the time it won't matter that we lock our 637 * node (as any locking would need the lower one locked 638 * first). 639 */ 640 lowervp = LAYERVPTOLOWERVP(vp); 641 error = VOP_LOCK(lowervp, flags); 642 if (error) 643 return (error); 644 if ((error = vlockmgr(&vp->v_lock, flags))) { 645 VOP_UNLOCK(lowervp, 0); 646 } 647 return (error); 648 } 649 } 650 651 /* 652 */ 653 int 654 layer_unlock(v) 655 void *v; 656 { 657 struct vop_unlock_args /* { 658 struct vnode *a_vp; 659 int a_flags; 660 struct proc *a_p; 661 } */ *ap = v; 662 struct vnode *vp = ap->a_vp; 663 int flags = ap->a_flags; 664 665 if (flags & LK_INTERLOCK) { 666 mutex_exit(&vp->v_interlock); 667 flags &= ~LK_INTERLOCK; 668 } 669 670 if (vp->v_vnlock != NULL) { 671 return (vlockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE)); 672 } else { 673 VOP_UNLOCK(LAYERVPTOLOWERVP(vp), flags); 674 return (vlockmgr(&vp->v_lock, flags | LK_RELEASE)); 675 } 676 } 677 678 int 679 layer_islocked(v) 680 void *v; 681 { 682 struct vop_islocked_args /* { 683 struct vnode *a_vp; 684 } */ *ap = v; 685 struct vnode *vp = ap->a_vp; 686 int lkstatus; 687 688 if (vp->v_vnlock != NULL) 689 return vlockstatus(vp->v_vnlock); 690 691 lkstatus = VOP_ISLOCKED(LAYERVPTOLOWERVP(vp)); 692 if (lkstatus) 693 return lkstatus; 694 695 return vlockstatus(&vp->v_lock); 696 } 697 698 /* 699 * If vinvalbuf is calling us, it's a "shallow fsync" -- don't bother 700 * syncing the underlying vnodes, since they'll be fsync'ed when 701 * reclaimed; otherwise, 702 * pass it through to the underlying layer. 703 * 704 * XXX Do we still need to worry about shallow fsync? 705 */ 706 707 int 708 layer_fsync(v) 709 void *v; 710 { 711 struct vop_fsync_args /* { 712 struct vnode *a_vp; 713 kauth_cred_t a_cred; 714 int a_flags; 715 off_t offlo; 716 off_t offhi; 717 struct lwp *a_l; 718 } */ *ap = v; 719 720 if (ap->a_flags & FSYNC_RECLAIM) { 721 return 0; 722 } 723 724 return (LAYERFS_DO_BYPASS(ap->a_vp, ap)); 725 } 726 727 728 int 729 layer_inactive(v) 730 void *v; 731 { 732 struct vop_inactive_args /* { 733 struct vnode *a_vp; 734 bool *a_recycle; 735 } */ *ap = v; 736 struct vnode *vp = ap->a_vp; 737 738 /* 739 * ..., but don't cache the device node. Also, if we did a 740 * remove, don't cache the node. 741 */ 742 *ap->a_recycle = (vp->v_type == VBLK || vp->v_type == VCHR 743 || (VTOLAYER(vp)->layer_flags & LAYERFS_REMOVED)); 744 745 /* 746 * Do nothing (and _don't_ bypass). 747 * Wait to vrele lowervp until reclaim, 748 * so that until then our layer_node is in the 749 * cache and reusable. 750 * 751 * NEEDSWORK: Someday, consider inactive'ing 752 * the lowervp and then trying to reactivate it 753 * with capabilities (v_id) 754 * like they do in the name lookup cache code. 755 * That's too much work for now. 756 */ 757 VOP_UNLOCK(vp, 0); 758 759 return (0); 760 } 761 762 int 763 layer_remove(v) 764 void *v; 765 { 766 struct vop_remove_args /* { 767 struct vonde *a_dvp; 768 struct vnode *a_vp; 769 struct componentname *a_cnp; 770 } */ *ap = v; 771 772 int error; 773 struct vnode *vp = ap->a_vp; 774 775 vref(vp); 776 if ((error = LAYERFS_DO_BYPASS(vp, ap)) == 0) 777 VTOLAYER(vp)->layer_flags |= LAYERFS_REMOVED; 778 779 vrele(vp); 780 781 return (error); 782 } 783 784 int 785 layer_rename(v) 786 void *v; 787 { 788 struct vop_rename_args /* { 789 struct vnode *a_fdvp; 790 struct vnode *a_fvp; 791 struct componentname *a_fcnp; 792 struct vnode *a_tdvp; 793 struct vnode *a_tvp; 794 struct componentname *a_tcnp; 795 } */ *ap = v; 796 797 int error; 798 struct vnode *fdvp = ap->a_fdvp; 799 struct vnode *tvp; 800 801 tvp = ap->a_tvp; 802 if (tvp) { 803 if (tvp->v_mount != fdvp->v_mount) 804 tvp = NULL; 805 else 806 vref(tvp); 807 } 808 error = LAYERFS_DO_BYPASS(fdvp, ap); 809 if (tvp) { 810 if (error == 0) 811 VTOLAYER(tvp)->layer_flags |= LAYERFS_REMOVED; 812 vrele(tvp); 813 } 814 815 return (error); 816 } 817 818 int 819 layer_rmdir(v) 820 void *v; 821 { 822 struct vop_rmdir_args /* { 823 struct vnode *a_dvp; 824 struct vnode *a_vp; 825 struct componentname *a_cnp; 826 } */ *ap = v; 827 int error; 828 struct vnode *vp = ap->a_vp; 829 830 vref(vp); 831 if ((error = LAYERFS_DO_BYPASS(vp, ap)) == 0) 832 VTOLAYER(vp)->layer_flags |= LAYERFS_REMOVED; 833 834 vrele(vp); 835 836 return (error); 837 } 838 839 int 840 layer_reclaim(v) 841 void *v; 842 { 843 struct vop_reclaim_args /* { 844 struct vnode *a_vp; 845 struct lwp *a_l; 846 } */ *ap = v; 847 struct vnode *vp = ap->a_vp; 848 struct layer_mount *lmp = MOUNTTOLAYERMOUNT(vp->v_mount); 849 struct layer_node *xp = VTOLAYER(vp); 850 struct vnode *lowervp = xp->layer_lowervp; 851 852 /* 853 * Note: in vop_reclaim, the node's struct lock has been 854 * decomissioned, so we have to be careful about calling 855 * VOP's on ourself. We must be careful as VXLOCK is set. 856 */ 857 /* After this assignment, this node will not be re-used. */ 858 if ((vp == lmp->layerm_rootvp)) { 859 /* 860 * Oops! We no longer have a root node. Most likely reason is 861 * that someone forcably unmunted the underlying fs. 862 * 863 * Now getting the root vnode will fail. We're dead. :-( 864 */ 865 lmp->layerm_rootvp = NULL; 866 } 867 xp->layer_lowervp = NULL; 868 mutex_enter(&lmp->layerm_hashlock); 869 LIST_REMOVE(xp, layer_hash); 870 mutex_exit(&lmp->layerm_hashlock); 871 kmem_free(vp->v_data, lmp->layerm_size); 872 vp->v_data = NULL; 873 vrele(lowervp); 874 875 return (0); 876 } 877 878 /* 879 * We just feed the returned vnode up to the caller - there's no need 880 * to build a layer node on top of the node on which we're going to do 881 * i/o. :-) 882 */ 883 int 884 layer_bmap(v) 885 void *v; 886 { 887 struct vop_bmap_args /* { 888 struct vnode *a_vp; 889 daddr_t a_bn; 890 struct vnode **a_vpp; 891 daddr_t *a_bnp; 892 int *a_runp; 893 } */ *ap = v; 894 struct vnode *vp; 895 896 ap->a_vp = vp = LAYERVPTOLOWERVP(ap->a_vp); 897 898 return (VCALL(vp, ap->a_desc->vdesc_offset, ap)); 899 } 900 901 int 902 layer_print(v) 903 void *v; 904 { 905 struct vop_print_args /* { 906 struct vnode *a_vp; 907 } */ *ap = v; 908 struct vnode *vp = ap->a_vp; 909 printf ("\ttag VT_LAYERFS, vp=%p, lowervp=%p\n", vp, LAYERVPTOLOWERVP(vp)); 910 return (0); 911 } 912 913 /* 914 * XXX - vop_bwrite must be hand coded because it has no 915 * vnode in its arguments. 916 * This goes away with a merged VM/buffer cache. 917 */ 918 int 919 layer_bwrite(v) 920 void *v; 921 { 922 struct vop_bwrite_args /* { 923 struct buf *a_bp; 924 } */ *ap = v; 925 struct buf *bp = ap->a_bp; 926 int error; 927 struct vnode *savedvp; 928 929 savedvp = bp->b_vp; 930 bp->b_vp = LAYERVPTOLOWERVP(bp->b_vp); 931 932 error = VOP_BWRITE(bp); 933 934 bp->b_vp = savedvp; 935 936 return (error); 937 } 938 939 int 940 layer_getpages(v) 941 void *v; 942 { 943 struct vop_getpages_args /* { 944 struct vnode *a_vp; 945 voff_t a_offset; 946 struct vm_page **a_m; 947 int *a_count; 948 int a_centeridx; 949 vm_prot_t a_access_type; 950 int a_advice; 951 int a_flags; 952 } */ *ap = v; 953 struct vnode *vp = ap->a_vp; 954 int error; 955 956 /* 957 * just pass the request on to the underlying layer. 958 */ 959 960 if (ap->a_flags & PGO_LOCKED) { 961 return EBUSY; 962 } 963 ap->a_vp = LAYERVPTOLOWERVP(vp); 964 mutex_exit(&vp->v_interlock); 965 mutex_enter(&ap->a_vp->v_interlock); 966 error = VCALL(ap->a_vp, VOFFSET(vop_getpages), ap); 967 return error; 968 } 969 970 int 971 layer_putpages(v) 972 void *v; 973 { 974 struct vop_putpages_args /* { 975 struct vnode *a_vp; 976 voff_t a_offlo; 977 voff_t a_offhi; 978 int a_flags; 979 } */ *ap = v; 980 struct vnode *vp = ap->a_vp; 981 int error; 982 983 /* 984 * just pass the request on to the underlying layer. 985 */ 986 987 ap->a_vp = LAYERVPTOLOWERVP(vp); 988 mutex_exit(&vp->v_interlock); 989 if (ap->a_flags & PGO_RECLAIM) { 990 return 0; 991 } 992 mutex_enter(&ap->a_vp->v_interlock); 993 error = VCALL(ap->a_vp, VOFFSET(vop_putpages), ap); 994 return error; 995 } 996