1 /* $NetBSD: vfs_subr.c,v 1.459 2017/01/11 14:52:02 hannken Exp $ */ 2 3 /*- 4 * Copyright (c) 1997, 1998, 2004, 2005, 2007, 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 9 * NASA Ames Research Center, by Charles M. Hannum, by Andrew Doran, 10 * by Marshall Kirk McKusick and Greg Ganger at the University of Michigan. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 23 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 /* 35 * Copyright (c) 1989, 1993 36 * The Regents of the University of California. All rights reserved. 37 * (c) UNIX System Laboratories, Inc. 38 * All or some portions of this file are derived from material licensed 39 * to the University of California by American Telephone and Telegraph 40 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 41 * the permission of UNIX System Laboratories, Inc. 42 * 43 * Redistribution and use in source and binary forms, with or without 44 * modification, are permitted provided that the following conditions 45 * are met: 46 * 1. Redistributions of source code must retain the above copyright 47 * notice, this list of conditions and the following disclaimer. 48 * 2. Redistributions in binary form must reproduce the above copyright 49 * notice, this list of conditions and the following disclaimer in the 50 * documentation and/or other materials provided with the distribution. 51 * 3. Neither the name of the University nor the names of its contributors 52 * may be used to endorse or promote products derived from this software 53 * without specific prior written permission. 54 * 55 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 56 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 57 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 58 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 59 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 60 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 61 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 62 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 63 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 64 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 65 * SUCH DAMAGE. 66 * 67 * @(#)vfs_subr.c 8.13 (Berkeley) 4/18/94 68 */ 69 70 #include <sys/cdefs.h> 71 __KERNEL_RCSID(0, "$NetBSD: vfs_subr.c,v 1.459 2017/01/11 14:52:02 hannken Exp $"); 72 73 #ifdef _KERNEL_OPT 74 #include "opt_ddb.h" 75 #include "opt_compat_netbsd.h" 76 #include "opt_compat_43.h" 77 #endif 78 79 #include <sys/param.h> 80 #include <sys/systm.h> 81 #include <sys/conf.h> 82 #include <sys/dirent.h> 83 #include <sys/filedesc.h> 84 #include <sys/kernel.h> 85 #include <sys/mount.h> 86 #include <sys/vnode_impl.h> 87 #include <sys/stat.h> 88 #include <sys/sysctl.h> 89 #include <sys/namei.h> 90 #include <sys/buf.h> 91 #include <sys/errno.h> 92 #include <sys/kmem.h> 93 #include <sys/syscallargs.h> 94 #include <sys/kauth.h> 95 #include <sys/module.h> 96 97 #include <miscfs/genfs/genfs.h> 98 #include <miscfs/specfs/specdev.h> 99 #include <uvm/uvm_ddb.h> 100 101 const enum vtype iftovt_tab[16] = { 102 VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON, 103 VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD, 104 }; 105 const int vttoif_tab[9] = { 106 0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK, 107 S_IFSOCK, S_IFIFO, S_IFMT, 108 }; 109 110 /* 111 * Insq/Remq for the vnode usage lists. 112 */ 113 #define bufinsvn(bp, dp) LIST_INSERT_HEAD(dp, bp, b_vnbufs) 114 #define bufremvn(bp) { \ 115 LIST_REMOVE(bp, b_vnbufs); \ 116 (bp)->b_vnbufs.le_next = NOLIST; \ 117 } 118 119 int doforce = 1; /* 1 => permit forcible unmounting */ 120 int prtactive = 0; /* 1 => print out reclaim of active vnodes */ 121 122 extern struct mount *dead_rootmount; 123 124 /* 125 * Local declarations. 126 */ 127 128 static void vn_initialize_syncerd(void); 129 130 /* 131 * Initialize the vnode management data structures. 132 */ 133 void 134 vntblinit(void) 135 { 136 137 vn_initialize_syncerd(); 138 vfs_mount_sysinit(); 139 vfs_vnode_sysinit(); 140 } 141 142 /* 143 * Flush out and invalidate all buffers associated with a vnode. 144 * Called with the underlying vnode locked, which should prevent new dirty 145 * buffers from being queued. 146 */ 147 int 148 vinvalbuf(struct vnode *vp, int flags, kauth_cred_t cred, struct lwp *l, 149 bool catch_p, int slptimeo) 150 { 151 struct buf *bp, *nbp; 152 int error; 153 int flushflags = PGO_ALLPAGES | PGO_FREE | PGO_SYNCIO | 154 (flags & V_SAVE ? PGO_CLEANIT | PGO_RECLAIM : 0); 155 156 /* XXXUBC this doesn't look at flags or slp* */ 157 mutex_enter(vp->v_interlock); 158 error = VOP_PUTPAGES(vp, 0, 0, flushflags); 159 if (error) { 160 return error; 161 } 162 163 if (flags & V_SAVE) { 164 error = VOP_FSYNC(vp, cred, FSYNC_WAIT|FSYNC_RECLAIM, 0, 0); 165 if (error) 166 return (error); 167 KASSERT(LIST_EMPTY(&vp->v_dirtyblkhd)); 168 } 169 170 mutex_enter(&bufcache_lock); 171 restart: 172 for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) { 173 KASSERT(bp->b_vp == vp); 174 nbp = LIST_NEXT(bp, b_vnbufs); 175 error = bbusy(bp, catch_p, slptimeo, NULL); 176 if (error != 0) { 177 if (error == EPASSTHROUGH) 178 goto restart; 179 mutex_exit(&bufcache_lock); 180 return (error); 181 } 182 brelsel(bp, BC_INVAL | BC_VFLUSH); 183 } 184 185 for (bp = LIST_FIRST(&vp->v_cleanblkhd); bp; bp = nbp) { 186 KASSERT(bp->b_vp == vp); 187 nbp = LIST_NEXT(bp, b_vnbufs); 188 error = bbusy(bp, catch_p, slptimeo, NULL); 189 if (error != 0) { 190 if (error == EPASSTHROUGH) 191 goto restart; 192 mutex_exit(&bufcache_lock); 193 return (error); 194 } 195 /* 196 * XXX Since there are no node locks for NFS, I believe 197 * there is a slight chance that a delayed write will 198 * occur while sleeping just above, so check for it. 199 */ 200 if ((bp->b_oflags & BO_DELWRI) && (flags & V_SAVE)) { 201 #ifdef DEBUG 202 printf("buffer still DELWRI\n"); 203 #endif 204 bp->b_cflags |= BC_BUSY | BC_VFLUSH; 205 mutex_exit(&bufcache_lock); 206 VOP_BWRITE(bp->b_vp, bp); 207 mutex_enter(&bufcache_lock); 208 goto restart; 209 } 210 brelsel(bp, BC_INVAL | BC_VFLUSH); 211 } 212 213 #ifdef DIAGNOSTIC 214 if (!LIST_EMPTY(&vp->v_cleanblkhd) || !LIST_EMPTY(&vp->v_dirtyblkhd)) 215 panic("vinvalbuf: flush failed, vp %p", vp); 216 #endif 217 218 mutex_exit(&bufcache_lock); 219 220 return (0); 221 } 222 223 /* 224 * Destroy any in core blocks past the truncation length. 225 * Called with the underlying vnode locked, which should prevent new dirty 226 * buffers from being queued. 227 */ 228 int 229 vtruncbuf(struct vnode *vp, daddr_t lbn, bool catch_p, int slptimeo) 230 { 231 struct buf *bp, *nbp; 232 int error; 233 voff_t off; 234 235 off = round_page((voff_t)lbn << vp->v_mount->mnt_fs_bshift); 236 mutex_enter(vp->v_interlock); 237 error = VOP_PUTPAGES(vp, off, 0, PGO_FREE | PGO_SYNCIO); 238 if (error) { 239 return error; 240 } 241 242 mutex_enter(&bufcache_lock); 243 restart: 244 for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) { 245 KASSERT(bp->b_vp == vp); 246 nbp = LIST_NEXT(bp, b_vnbufs); 247 if (bp->b_lblkno < lbn) 248 continue; 249 error = bbusy(bp, catch_p, slptimeo, NULL); 250 if (error != 0) { 251 if (error == EPASSTHROUGH) 252 goto restart; 253 mutex_exit(&bufcache_lock); 254 return (error); 255 } 256 brelsel(bp, BC_INVAL | BC_VFLUSH); 257 } 258 259 for (bp = LIST_FIRST(&vp->v_cleanblkhd); bp; bp = nbp) { 260 KASSERT(bp->b_vp == vp); 261 nbp = LIST_NEXT(bp, b_vnbufs); 262 if (bp->b_lblkno < lbn) 263 continue; 264 error = bbusy(bp, catch_p, slptimeo, NULL); 265 if (error != 0) { 266 if (error == EPASSTHROUGH) 267 goto restart; 268 mutex_exit(&bufcache_lock); 269 return (error); 270 } 271 brelsel(bp, BC_INVAL | BC_VFLUSH); 272 } 273 mutex_exit(&bufcache_lock); 274 275 return (0); 276 } 277 278 /* 279 * Flush all dirty buffers from a vnode. 280 * Called with the underlying vnode locked, which should prevent new dirty 281 * buffers from being queued. 282 */ 283 int 284 vflushbuf(struct vnode *vp, int flags) 285 { 286 struct buf *bp, *nbp; 287 int error, pflags; 288 bool dirty, sync; 289 290 sync = (flags & FSYNC_WAIT) != 0; 291 pflags = PGO_CLEANIT | PGO_ALLPAGES | 292 (sync ? PGO_SYNCIO : 0) | 293 ((flags & FSYNC_LAZY) ? PGO_LAZY : 0); 294 mutex_enter(vp->v_interlock); 295 (void) VOP_PUTPAGES(vp, 0, 0, pflags); 296 297 loop: 298 mutex_enter(&bufcache_lock); 299 for (bp = LIST_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) { 300 KASSERT(bp->b_vp == vp); 301 nbp = LIST_NEXT(bp, b_vnbufs); 302 if ((bp->b_cflags & BC_BUSY)) 303 continue; 304 if ((bp->b_oflags & BO_DELWRI) == 0) 305 panic("vflushbuf: not dirty, bp %p", bp); 306 bp->b_cflags |= BC_BUSY | BC_VFLUSH; 307 mutex_exit(&bufcache_lock); 308 /* 309 * Wait for I/O associated with indirect blocks to complete, 310 * since there is no way to quickly wait for them below. 311 */ 312 if (bp->b_vp == vp || !sync) 313 (void) bawrite(bp); 314 else { 315 error = bwrite(bp); 316 if (error) 317 return error; 318 } 319 goto loop; 320 } 321 mutex_exit(&bufcache_lock); 322 323 if (!sync) 324 return 0; 325 326 mutex_enter(vp->v_interlock); 327 while (vp->v_numoutput != 0) 328 cv_wait(&vp->v_cv, vp->v_interlock); 329 dirty = !LIST_EMPTY(&vp->v_dirtyblkhd); 330 mutex_exit(vp->v_interlock); 331 332 if (dirty) { 333 vprint("vflushbuf: dirty", vp); 334 goto loop; 335 } 336 337 return 0; 338 } 339 340 /* 341 * Create a vnode for a block device. 342 * Used for root filesystem and swap areas. 343 * Also used for memory file system special devices. 344 */ 345 int 346 bdevvp(dev_t dev, vnode_t **vpp) 347 { 348 struct vattr va; 349 350 vattr_null(&va); 351 va.va_type = VBLK; 352 va.va_rdev = dev; 353 354 return vcache_new(dead_rootmount, NULL, &va, NOCRED, vpp); 355 } 356 357 /* 358 * Create a vnode for a character device. 359 * Used for kernfs and some console handling. 360 */ 361 int 362 cdevvp(dev_t dev, vnode_t **vpp) 363 { 364 struct vattr va; 365 366 vattr_null(&va); 367 va.va_type = VCHR; 368 va.va_rdev = dev; 369 370 return vcache_new(dead_rootmount, NULL, &va, NOCRED, vpp); 371 } 372 373 /* 374 * Associate a buffer with a vnode. There must already be a hold on 375 * the vnode. 376 */ 377 void 378 bgetvp(struct vnode *vp, struct buf *bp) 379 { 380 381 KASSERT(bp->b_vp == NULL); 382 KASSERT(bp->b_objlock == &buffer_lock); 383 KASSERT(mutex_owned(vp->v_interlock)); 384 KASSERT(mutex_owned(&bufcache_lock)); 385 KASSERT((bp->b_cflags & BC_BUSY) != 0); 386 KASSERT(!cv_has_waiters(&bp->b_done)); 387 388 vholdl(vp); 389 bp->b_vp = vp; 390 if (vp->v_type == VBLK || vp->v_type == VCHR) 391 bp->b_dev = vp->v_rdev; 392 else 393 bp->b_dev = NODEV; 394 395 /* 396 * Insert onto list for new vnode. 397 */ 398 bufinsvn(bp, &vp->v_cleanblkhd); 399 bp->b_objlock = vp->v_interlock; 400 } 401 402 /* 403 * Disassociate a buffer from a vnode. 404 */ 405 void 406 brelvp(struct buf *bp) 407 { 408 struct vnode *vp = bp->b_vp; 409 410 KASSERT(vp != NULL); 411 KASSERT(bp->b_objlock == vp->v_interlock); 412 KASSERT(mutex_owned(vp->v_interlock)); 413 KASSERT(mutex_owned(&bufcache_lock)); 414 KASSERT((bp->b_cflags & BC_BUSY) != 0); 415 KASSERT(!cv_has_waiters(&bp->b_done)); 416 417 /* 418 * Delete from old vnode list, if on one. 419 */ 420 if (LIST_NEXT(bp, b_vnbufs) != NOLIST) 421 bufremvn(bp); 422 423 if (vp->v_uobj.uo_npages == 0 && (vp->v_iflag & VI_ONWORKLST) && 424 LIST_FIRST(&vp->v_dirtyblkhd) == NULL) { 425 vp->v_iflag &= ~VI_WRMAPDIRTY; 426 vn_syncer_remove_from_worklist(vp); 427 } 428 429 bp->b_objlock = &buffer_lock; 430 bp->b_vp = NULL; 431 holdrelel(vp); 432 } 433 434 /* 435 * Reassign a buffer from one vnode list to another. 436 * The list reassignment must be within the same vnode. 437 * Used to assign file specific control information 438 * (indirect blocks) to the list to which they belong. 439 */ 440 void 441 reassignbuf(struct buf *bp, struct vnode *vp) 442 { 443 struct buflists *listheadp; 444 int delayx; 445 446 KASSERT(mutex_owned(&bufcache_lock)); 447 KASSERT(bp->b_objlock == vp->v_interlock); 448 KASSERT(mutex_owned(vp->v_interlock)); 449 KASSERT((bp->b_cflags & BC_BUSY) != 0); 450 451 /* 452 * Delete from old vnode list, if on one. 453 */ 454 if (LIST_NEXT(bp, b_vnbufs) != NOLIST) 455 bufremvn(bp); 456 457 /* 458 * If dirty, put on list of dirty buffers; 459 * otherwise insert onto list of clean buffers. 460 */ 461 if ((bp->b_oflags & BO_DELWRI) == 0) { 462 listheadp = &vp->v_cleanblkhd; 463 if (vp->v_uobj.uo_npages == 0 && 464 (vp->v_iflag & VI_ONWORKLST) && 465 LIST_FIRST(&vp->v_dirtyblkhd) == NULL) { 466 vp->v_iflag &= ~VI_WRMAPDIRTY; 467 vn_syncer_remove_from_worklist(vp); 468 } 469 } else { 470 listheadp = &vp->v_dirtyblkhd; 471 if ((vp->v_iflag & VI_ONWORKLST) == 0) { 472 switch (vp->v_type) { 473 case VDIR: 474 delayx = dirdelay; 475 break; 476 case VBLK: 477 if (spec_node_getmountedfs(vp) != NULL) { 478 delayx = metadelay; 479 break; 480 } 481 /* fall through */ 482 default: 483 delayx = filedelay; 484 break; 485 } 486 if (!vp->v_mount || 487 (vp->v_mount->mnt_flag & MNT_ASYNC) == 0) 488 vn_syncer_add_to_worklist(vp, delayx); 489 } 490 } 491 bufinsvn(bp, listheadp); 492 } 493 494 /* 495 * Lookup a vnode by device number and return it referenced. 496 */ 497 int 498 vfinddev(dev_t dev, enum vtype type, vnode_t **vpp) 499 { 500 501 return (spec_node_lookup_by_dev(type, dev, vpp) == 0); 502 } 503 504 /* 505 * Revoke all the vnodes corresponding to the specified minor number 506 * range (endpoints inclusive) of the specified major. 507 */ 508 void 509 vdevgone(int maj, int minl, int minh, enum vtype type) 510 { 511 vnode_t *vp; 512 dev_t dev; 513 int mn; 514 515 for (mn = minl; mn <= minh; mn++) { 516 dev = makedev(maj, mn); 517 while (spec_node_lookup_by_dev(type, dev, &vp) == 0) { 518 VOP_REVOKE(vp, REVOKEALL); 519 vrele(vp); 520 } 521 } 522 } 523 524 /* 525 * The filesystem synchronizer mechanism - syncer. 526 * 527 * It is useful to delay writes of file data and filesystem metadata for 528 * a certain amount of time so that quickly created and deleted files need 529 * not waste disk bandwidth being created and removed. To implement this, 530 * vnodes are appended to a "workitem" queue. 531 * 532 * Most pending metadata should not wait for more than ten seconds. Thus, 533 * mounted on block devices are delayed only about a half the time that file 534 * data is delayed. Similarly, directory updates are more critical, so are 535 * only delayed about a third the time that file data is delayed. 536 * 537 * There are SYNCER_MAXDELAY queues that are processed in a round-robin 538 * manner at a rate of one each second (driven off the filesystem syner 539 * thread). The syncer_delayno variable indicates the next queue that is 540 * to be processed. Items that need to be processed soon are placed in 541 * this queue: 542 * 543 * syncer_workitem_pending[syncer_delayno] 544 * 545 * A delay of e.g. fifteen seconds is done by placing the request fifteen 546 * entries later in the queue: 547 * 548 * syncer_workitem_pending[(syncer_delayno + 15) & syncer_mask] 549 * 550 * Flag VI_ONWORKLST indicates that vnode is added into the queue. 551 */ 552 553 #define SYNCER_MAXDELAY 32 554 555 typedef TAILQ_HEAD(synclist, vnode_impl) synclist_t; 556 557 static void vn_syncer_add1(struct vnode *, int); 558 static void sysctl_vfs_syncfs_setup(struct sysctllog **); 559 560 /* 561 * Defines and variables for the syncer process. 562 */ 563 int syncer_maxdelay = SYNCER_MAXDELAY; /* maximum delay time */ 564 time_t syncdelay = 30; /* max time to delay syncing data */ 565 time_t filedelay = 30; /* time to delay syncing files */ 566 time_t dirdelay = 15; /* time to delay syncing directories */ 567 time_t metadelay = 10; /* time to delay syncing metadata */ 568 time_t lockdelay = 1; /* time to delay if locking fails */ 569 570 kmutex_t syncer_mutex; /* used to freeze syncer, long term */ 571 static kmutex_t syncer_data_lock; /* short term lock on data structs */ 572 573 static int syncer_delayno = 0; 574 static long syncer_last; 575 static synclist_t * syncer_workitem_pending; 576 577 static void 578 vn_initialize_syncerd(void) 579 { 580 int i; 581 582 syncer_last = SYNCER_MAXDELAY + 2; 583 584 sysctl_vfs_syncfs_setup(NULL); 585 586 syncer_workitem_pending = 587 kmem_alloc(syncer_last * sizeof (struct synclist), KM_SLEEP); 588 589 for (i = 0; i < syncer_last; i++) 590 TAILQ_INIT(&syncer_workitem_pending[i]); 591 592 mutex_init(&syncer_mutex, MUTEX_DEFAULT, IPL_NONE); 593 mutex_init(&syncer_data_lock, MUTEX_DEFAULT, IPL_NONE); 594 } 595 596 /* 597 * Return delay factor appropriate for the given file system. For 598 * WAPBL we use the sync vnode to burst out metadata updates: sync 599 * those file systems more frequently. 600 */ 601 static inline int 602 sync_delay(struct mount *mp) 603 { 604 605 return mp->mnt_wapbl != NULL ? metadelay : syncdelay; 606 } 607 608 /* 609 * Compute the next slot index from delay. 610 */ 611 static inline int 612 sync_delay_slot(int delayx) 613 { 614 615 if (delayx > syncer_maxdelay - 2) 616 delayx = syncer_maxdelay - 2; 617 return (syncer_delayno + delayx) % syncer_last; 618 } 619 620 /* 621 * Add an item to the syncer work queue. 622 */ 623 static void 624 vn_syncer_add1(struct vnode *vp, int delayx) 625 { 626 synclist_t *slp; 627 vnode_impl_t *vip = VNODE_TO_VIMPL(vp); 628 629 KASSERT(mutex_owned(&syncer_data_lock)); 630 631 if (vp->v_iflag & VI_ONWORKLST) { 632 /* 633 * Remove in order to adjust the position of the vnode. 634 * Note: called from sched_sync(), which will not hold 635 * interlock, therefore we cannot modify v_iflag here. 636 */ 637 slp = &syncer_workitem_pending[vip->vi_synclist_slot]; 638 TAILQ_REMOVE(slp, vip, vi_synclist); 639 } else { 640 KASSERT(mutex_owned(vp->v_interlock)); 641 vp->v_iflag |= VI_ONWORKLST; 642 } 643 644 vip->vi_synclist_slot = sync_delay_slot(delayx); 645 646 slp = &syncer_workitem_pending[vip->vi_synclist_slot]; 647 TAILQ_INSERT_TAIL(slp, vip, vi_synclist); 648 } 649 650 void 651 vn_syncer_add_to_worklist(struct vnode *vp, int delayx) 652 { 653 654 KASSERT(mutex_owned(vp->v_interlock)); 655 656 mutex_enter(&syncer_data_lock); 657 vn_syncer_add1(vp, delayx); 658 mutex_exit(&syncer_data_lock); 659 } 660 661 /* 662 * Remove an item from the syncer work queue. 663 */ 664 void 665 vn_syncer_remove_from_worklist(struct vnode *vp) 666 { 667 synclist_t *slp; 668 vnode_impl_t *vip = VNODE_TO_VIMPL(vp); 669 670 KASSERT(mutex_owned(vp->v_interlock)); 671 672 mutex_enter(&syncer_data_lock); 673 if (vp->v_iflag & VI_ONWORKLST) { 674 vp->v_iflag &= ~VI_ONWORKLST; 675 slp = &syncer_workitem_pending[vip->vi_synclist_slot]; 676 TAILQ_REMOVE(slp, vip, vi_synclist); 677 } 678 mutex_exit(&syncer_data_lock); 679 } 680 681 /* 682 * Add this mount point to the syncer. 683 */ 684 void 685 vfs_syncer_add_to_worklist(struct mount *mp) 686 { 687 static int start, incr, next; 688 int vdelay; 689 690 KASSERT(mutex_owned(&mp->mnt_updating)); 691 KASSERT((mp->mnt_iflag & IMNT_ONWORKLIST) == 0); 692 693 /* 694 * We attempt to scatter the mount points on the list 695 * so that they will go off at evenly distributed times 696 * even if all the filesystems are mounted at once. 697 */ 698 699 next += incr; 700 if (next == 0 || next > syncer_maxdelay) { 701 start /= 2; 702 incr /= 2; 703 if (start == 0) { 704 start = syncer_maxdelay / 2; 705 incr = syncer_maxdelay; 706 } 707 next = start; 708 } 709 mp->mnt_iflag |= IMNT_ONWORKLIST; 710 vdelay = sync_delay(mp); 711 mp->mnt_synclist_slot = vdelay > 0 ? next % vdelay : 0; 712 } 713 714 /* 715 * Remove the mount point from the syncer. 716 */ 717 void 718 vfs_syncer_remove_from_worklist(struct mount *mp) 719 { 720 721 KASSERT(mutex_owned(&mp->mnt_updating)); 722 KASSERT((mp->mnt_iflag & IMNT_ONWORKLIST) != 0); 723 724 mp->mnt_iflag &= ~IMNT_ONWORKLIST; 725 } 726 727 /* 728 * Try lazy sync, return true on success. 729 */ 730 static bool 731 lazy_sync_vnode(struct vnode *vp) 732 { 733 bool synced; 734 735 KASSERT(mutex_owned(&syncer_data_lock)); 736 737 synced = false; 738 /* We are locking in the wrong direction. */ 739 if (mutex_tryenter(vp->v_interlock)) { 740 mutex_exit(&syncer_data_lock); 741 if (vcache_tryvget(vp) == 0) { 742 if (vn_lock(vp, LK_EXCLUSIVE | LK_NOWAIT) == 0) { 743 synced = true; 744 (void) VOP_FSYNC(vp, curlwp->l_cred, 745 FSYNC_LAZY, 0, 0); 746 vput(vp); 747 } else 748 vrele(vp); 749 } 750 mutex_enter(&syncer_data_lock); 751 } 752 return synced; 753 } 754 755 /* 756 * System filesystem synchronizer daemon. 757 */ 758 void 759 sched_sync(void *arg) 760 { 761 synclist_t *slp; 762 struct vnode *vp; 763 struct mount *mp, *nmp; 764 time_t starttime; 765 bool synced; 766 767 for (;;) { 768 mutex_enter(&syncer_mutex); 769 770 starttime = time_second; 771 772 /* 773 * Sync mounts whose dirty time has expired. 774 */ 775 mutex_enter(&mountlist_lock); 776 for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) { 777 if ((mp->mnt_iflag & IMNT_ONWORKLIST) == 0 || 778 mp->mnt_synclist_slot != syncer_delayno) { 779 nmp = TAILQ_NEXT(mp, mnt_list); 780 continue; 781 } 782 mp->mnt_synclist_slot = sync_delay_slot(sync_delay(mp)); 783 if (vfs_busy(mp, &nmp)) 784 continue; 785 VFS_SYNC(mp, MNT_LAZY, curlwp->l_cred); 786 vfs_unbusy(mp, false, &nmp); 787 } 788 mutex_exit(&mountlist_lock); 789 790 mutex_enter(&syncer_data_lock); 791 792 /* 793 * Push files whose dirty time has expired. 794 */ 795 slp = &syncer_workitem_pending[syncer_delayno]; 796 syncer_delayno += 1; 797 if (syncer_delayno >= syncer_last) 798 syncer_delayno = 0; 799 800 while ((vp = VIMPL_TO_VNODE(TAILQ_FIRST(slp))) != NULL) { 801 synced = lazy_sync_vnode(vp); 802 803 /* 804 * XXX The vnode may have been recycled, in which 805 * case it may have a new identity. 806 */ 807 if (VIMPL_TO_VNODE(TAILQ_FIRST(slp)) == vp) { 808 /* 809 * Put us back on the worklist. The worklist 810 * routine will remove us from our current 811 * position and then add us back in at a later 812 * position. 813 * 814 * Try again sooner rather than later if 815 * we were unable to lock the vnode. Lock 816 * failure should not prevent us from doing 817 * the sync "soon". 818 * 819 * If we locked it yet arrive here, it's 820 * likely that lazy sync is in progress and 821 * so the vnode still has dirty metadata. 822 * syncdelay is mainly to get this vnode out 823 * of the way so we do not consider it again 824 * "soon" in this loop, so the delay time is 825 * not critical as long as it is not "soon". 826 * While write-back strategy is the file 827 * system's domain, we expect write-back to 828 * occur no later than syncdelay seconds 829 * into the future. 830 */ 831 vn_syncer_add1(vp, 832 synced ? syncdelay : lockdelay); 833 } 834 } 835 mutex_exit(&syncer_mutex); 836 837 /* 838 * If it has taken us less than a second to process the 839 * current work, then wait. Otherwise start right over 840 * again. We can still lose time if any single round 841 * takes more than two seconds, but it does not really 842 * matter as we are just trying to generally pace the 843 * filesystem activity. 844 */ 845 if (time_second == starttime) { 846 kpause("syncer", false, hz, &syncer_data_lock); 847 } 848 mutex_exit(&syncer_data_lock); 849 } 850 } 851 852 static void 853 sysctl_vfs_syncfs_setup(struct sysctllog **clog) 854 { 855 const struct sysctlnode *rnode, *cnode; 856 857 sysctl_createv(clog, 0, NULL, &rnode, 858 CTLFLAG_PERMANENT, 859 CTLTYPE_NODE, "sync", 860 SYSCTL_DESCR("syncer options"), 861 NULL, 0, NULL, 0, 862 CTL_VFS, CTL_CREATE, CTL_EOL); 863 864 sysctl_createv(clog, 0, &rnode, &cnode, 865 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 866 CTLTYPE_QUAD, "delay", 867 SYSCTL_DESCR("max time to delay syncing data"), 868 NULL, 0, &syncdelay, 0, 869 CTL_CREATE, CTL_EOL); 870 871 sysctl_createv(clog, 0, &rnode, &cnode, 872 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 873 CTLTYPE_QUAD, "filedelay", 874 SYSCTL_DESCR("time to delay syncing files"), 875 NULL, 0, &filedelay, 0, 876 CTL_CREATE, CTL_EOL); 877 878 sysctl_createv(clog, 0, &rnode, &cnode, 879 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 880 CTLTYPE_QUAD, "dirdelay", 881 SYSCTL_DESCR("time to delay syncing directories"), 882 NULL, 0, &dirdelay, 0, 883 CTL_CREATE, CTL_EOL); 884 885 sysctl_createv(clog, 0, &rnode, &cnode, 886 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 887 CTLTYPE_QUAD, "metadelay", 888 SYSCTL_DESCR("time to delay syncing metadata"), 889 NULL, 0, &metadelay, 0, 890 CTL_CREATE, CTL_EOL); 891 } 892 893 /* 894 * sysctl helper routine to return list of supported fstypes 895 */ 896 int 897 sysctl_vfs_generic_fstypes(SYSCTLFN_ARGS) 898 { 899 char bf[sizeof(((struct statvfs *)NULL)->f_fstypename)]; 900 char *where = oldp; 901 struct vfsops *v; 902 size_t needed, left, slen; 903 int error, first; 904 905 if (newp != NULL) 906 return (EPERM); 907 if (namelen != 0) 908 return (EINVAL); 909 910 first = 1; 911 error = 0; 912 needed = 0; 913 left = *oldlenp; 914 915 sysctl_unlock(); 916 mutex_enter(&vfs_list_lock); 917 LIST_FOREACH(v, &vfs_list, vfs_list) { 918 if (where == NULL) 919 needed += strlen(v->vfs_name) + 1; 920 else { 921 memset(bf, 0, sizeof(bf)); 922 if (first) { 923 strncpy(bf, v->vfs_name, sizeof(bf)); 924 first = 0; 925 } else { 926 bf[0] = ' '; 927 strncpy(bf + 1, v->vfs_name, sizeof(bf) - 1); 928 } 929 bf[sizeof(bf)-1] = '\0'; 930 slen = strlen(bf); 931 if (left < slen + 1) 932 break; 933 v->vfs_refcount++; 934 mutex_exit(&vfs_list_lock); 935 /* +1 to copy out the trailing NUL byte */ 936 error = copyout(bf, where, slen + 1); 937 mutex_enter(&vfs_list_lock); 938 v->vfs_refcount--; 939 if (error) 940 break; 941 where += slen; 942 needed += slen; 943 left -= slen; 944 } 945 } 946 mutex_exit(&vfs_list_lock); 947 sysctl_relock(); 948 *oldlenp = needed; 949 return (error); 950 } 951 952 int kinfo_vdebug = 1; 953 int kinfo_vgetfailed; 954 955 #define KINFO_VNODESLOP 10 956 957 /* 958 * Dump vnode list (via sysctl). 959 * Copyout address of vnode followed by vnode. 960 */ 961 int 962 sysctl_kern_vnode(SYSCTLFN_ARGS) 963 { 964 char *where = oldp; 965 size_t *sizep = oldlenp; 966 struct mount *mp, *nmp; 967 vnode_t *vp, vbuf; 968 struct vnode_iterator *marker; 969 char *bp = where; 970 char *ewhere; 971 int error; 972 973 if (namelen != 0) 974 return (EOPNOTSUPP); 975 if (newp != NULL) 976 return (EPERM); 977 978 #define VPTRSZ sizeof(vnode_t *) 979 #define VNODESZ sizeof(vnode_t) 980 if (where == NULL) { 981 *sizep = (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ); 982 return (0); 983 } 984 ewhere = where + *sizep; 985 986 sysctl_unlock(); 987 mutex_enter(&mountlist_lock); 988 for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) { 989 if (vfs_busy(mp, &nmp)) { 990 continue; 991 } 992 vfs_vnode_iterator_init(mp, &marker); 993 while ((vp = vfs_vnode_iterator_next(marker, NULL, NULL))) { 994 if (bp + VPTRSZ + VNODESZ > ewhere) { 995 vrele(vp); 996 vfs_vnode_iterator_destroy(marker); 997 vfs_unbusy(mp, false, NULL); 998 sysctl_relock(); 999 *sizep = bp - where; 1000 return (ENOMEM); 1001 } 1002 memcpy(&vbuf, vp, VNODESZ); 1003 if ((error = copyout(&vp, bp, VPTRSZ)) || 1004 (error = copyout(&vbuf, bp + VPTRSZ, VNODESZ))) { 1005 vrele(vp); 1006 vfs_vnode_iterator_destroy(marker); 1007 vfs_unbusy(mp, false, NULL); 1008 sysctl_relock(); 1009 return (error); 1010 } 1011 vrele(vp); 1012 bp += VPTRSZ + VNODESZ; 1013 } 1014 vfs_vnode_iterator_destroy(marker); 1015 vfs_unbusy(mp, false, &nmp); 1016 } 1017 mutex_exit(&mountlist_lock); 1018 sysctl_relock(); 1019 1020 *sizep = bp - where; 1021 return (0); 1022 } 1023 1024 /* 1025 * Set vnode attributes to VNOVAL 1026 */ 1027 void 1028 vattr_null(struct vattr *vap) 1029 { 1030 1031 memset(vap, 0, sizeof(*vap)); 1032 1033 vap->va_type = VNON; 1034 1035 /* 1036 * Assign individually so that it is safe even if size and 1037 * sign of each member are varied. 1038 */ 1039 vap->va_mode = VNOVAL; 1040 vap->va_nlink = VNOVAL; 1041 vap->va_uid = VNOVAL; 1042 vap->va_gid = VNOVAL; 1043 vap->va_fsid = VNOVAL; 1044 vap->va_fileid = VNOVAL; 1045 vap->va_size = VNOVAL; 1046 vap->va_blocksize = VNOVAL; 1047 vap->va_atime.tv_sec = 1048 vap->va_mtime.tv_sec = 1049 vap->va_ctime.tv_sec = 1050 vap->va_birthtime.tv_sec = VNOVAL; 1051 vap->va_atime.tv_nsec = 1052 vap->va_mtime.tv_nsec = 1053 vap->va_ctime.tv_nsec = 1054 vap->va_birthtime.tv_nsec = VNOVAL; 1055 vap->va_gen = VNOVAL; 1056 vap->va_flags = VNOVAL; 1057 vap->va_rdev = VNOVAL; 1058 vap->va_bytes = VNOVAL; 1059 } 1060 1061 /* 1062 * Vnode state to string. 1063 */ 1064 const char * 1065 vstate_name(enum vnode_state state) 1066 { 1067 1068 switch (state) { 1069 case VS_MARKER: 1070 return "MARKER"; 1071 case VS_LOADING: 1072 return "LOADING"; 1073 case VS_ACTIVE: 1074 return "ACTIVE"; 1075 case VS_BLOCKED: 1076 return "BLOCKED"; 1077 case VS_RECLAIMING: 1078 return "RECLAIMING"; 1079 case VS_RECLAIMED: 1080 return "RECLAIMED"; 1081 default: 1082 return "ILLEGAL"; 1083 } 1084 } 1085 1086 /* 1087 * Print a description of a vnode (common part). 1088 */ 1089 static void 1090 vprint_common(struct vnode *vp, const char *prefix, 1091 void (*pr)(const char *, ...) __printflike(1, 2)) 1092 { 1093 int n; 1094 char bf[96]; 1095 const uint8_t *cp; 1096 vnode_impl_t *vip; 1097 const char * const vnode_tags[] = { VNODE_TAGS }; 1098 const char * const vnode_types[] = { VNODE_TYPES }; 1099 const char vnode_flagbits[] = VNODE_FLAGBITS; 1100 1101 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0])) 1102 #define ARRAY_PRINT(idx, arr) \ 1103 ((unsigned int)(idx) < ARRAY_SIZE(arr) ? (arr)[(idx)] : "UNKNOWN") 1104 1105 vip = VNODE_TO_VIMPL(vp); 1106 1107 snprintb(bf, sizeof(bf), 1108 vnode_flagbits, vp->v_iflag | vp->v_vflag | vp->v_uflag); 1109 1110 (*pr)("vnode %p flags %s\n", vp, bf); 1111 (*pr)("%stag %s(%d) type %s(%d) mount %p typedata %p\n", prefix, 1112 ARRAY_PRINT(vp->v_tag, vnode_tags), vp->v_tag, 1113 ARRAY_PRINT(vp->v_type, vnode_types), vp->v_type, 1114 vp->v_mount, vp->v_mountedhere); 1115 (*pr)("%susecount %d writecount %d holdcount %d\n", prefix, 1116 vp->v_usecount, vp->v_writecount, vp->v_holdcnt); 1117 (*pr)("%ssize %" PRIx64 " writesize %" PRIx64 " numoutput %d\n", 1118 prefix, vp->v_size, vp->v_writesize, vp->v_numoutput); 1119 (*pr)("%sdata %p lock %p\n", prefix, vp->v_data, &vip->vi_lock); 1120 1121 (*pr)("%sstate %s key(%p %zd)", prefix, vstate_name(vip->vi_state), 1122 vip->vi_key.vk_mount, vip->vi_key.vk_key_len); 1123 n = vip->vi_key.vk_key_len; 1124 cp = vip->vi_key.vk_key; 1125 while (n-- > 0) 1126 (*pr)(" %02x", *cp++); 1127 (*pr)("\n"); 1128 (*pr)("%slrulisthd %p\n", prefix, vip->vi_lrulisthd); 1129 1130 #undef ARRAY_PRINT 1131 #undef ARRAY_SIZE 1132 } 1133 1134 /* 1135 * Print out a description of a vnode. 1136 */ 1137 void 1138 vprint(const char *label, struct vnode *vp) 1139 { 1140 1141 if (label != NULL) 1142 printf("%s: ", label); 1143 vprint_common(vp, "\t", printf); 1144 if (vp->v_data != NULL) { 1145 printf("\t"); 1146 VOP_PRINT(vp); 1147 } 1148 } 1149 1150 /* Deprecated. Kept for KPI compatibility. */ 1151 int 1152 vaccess(enum vtype type, mode_t file_mode, uid_t uid, gid_t gid, 1153 mode_t acc_mode, kauth_cred_t cred) 1154 { 1155 1156 #ifdef DIAGNOSTIC 1157 printf("vaccess: deprecated interface used.\n"); 1158 #endif /* DIAGNOSTIC */ 1159 1160 return kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(acc_mode, 1161 type, file_mode), NULL /* This may panic. */, NULL, 1162 genfs_can_access(type, file_mode, uid, gid, acc_mode, cred)); 1163 } 1164 1165 /* 1166 * Given a file system name, look up the vfsops for that 1167 * file system, or return NULL if file system isn't present 1168 * in the kernel. 1169 */ 1170 struct vfsops * 1171 vfs_getopsbyname(const char *name) 1172 { 1173 struct vfsops *v; 1174 1175 mutex_enter(&vfs_list_lock); 1176 LIST_FOREACH(v, &vfs_list, vfs_list) { 1177 if (strcmp(v->vfs_name, name) == 0) 1178 break; 1179 } 1180 if (v != NULL) 1181 v->vfs_refcount++; 1182 mutex_exit(&vfs_list_lock); 1183 1184 return (v); 1185 } 1186 1187 void 1188 copy_statvfs_info(struct statvfs *sbp, const struct mount *mp) 1189 { 1190 const struct statvfs *mbp; 1191 1192 if (sbp == (mbp = &mp->mnt_stat)) 1193 return; 1194 1195 (void)memcpy(&sbp->f_fsidx, &mbp->f_fsidx, sizeof(sbp->f_fsidx)); 1196 sbp->f_fsid = mbp->f_fsid; 1197 sbp->f_owner = mbp->f_owner; 1198 sbp->f_flag = mbp->f_flag; 1199 sbp->f_syncwrites = mbp->f_syncwrites; 1200 sbp->f_asyncwrites = mbp->f_asyncwrites; 1201 sbp->f_syncreads = mbp->f_syncreads; 1202 sbp->f_asyncreads = mbp->f_asyncreads; 1203 (void)memcpy(sbp->f_spare, mbp->f_spare, sizeof(mbp->f_spare)); 1204 (void)memcpy(sbp->f_fstypename, mbp->f_fstypename, 1205 sizeof(sbp->f_fstypename)); 1206 (void)memcpy(sbp->f_mntonname, mbp->f_mntonname, 1207 sizeof(sbp->f_mntonname)); 1208 (void)memcpy(sbp->f_mntfromname, mp->mnt_stat.f_mntfromname, 1209 sizeof(sbp->f_mntfromname)); 1210 sbp->f_namemax = mbp->f_namemax; 1211 } 1212 1213 int 1214 set_statvfs_info(const char *onp, int ukon, const char *fromp, int ukfrom, 1215 const char *vfsname, struct mount *mp, struct lwp *l) 1216 { 1217 int error; 1218 size_t size; 1219 struct statvfs *sfs = &mp->mnt_stat; 1220 int (*fun)(const void *, void *, size_t, size_t *); 1221 1222 (void)strlcpy(mp->mnt_stat.f_fstypename, vfsname, 1223 sizeof(mp->mnt_stat.f_fstypename)); 1224 1225 if (onp) { 1226 struct cwdinfo *cwdi = l->l_proc->p_cwdi; 1227 fun = (ukon == UIO_SYSSPACE) ? copystr : copyinstr; 1228 if (cwdi->cwdi_rdir != NULL) { 1229 size_t len; 1230 char *bp; 1231 char *path = PNBUF_GET(); 1232 1233 bp = path + MAXPATHLEN; 1234 *--bp = '\0'; 1235 rw_enter(&cwdi->cwdi_lock, RW_READER); 1236 error = getcwd_common(cwdi->cwdi_rdir, rootvnode, &bp, 1237 path, MAXPATHLEN / 2, 0, l); 1238 rw_exit(&cwdi->cwdi_lock); 1239 if (error) { 1240 PNBUF_PUT(path); 1241 return error; 1242 } 1243 1244 len = strlen(bp); 1245 if (len > sizeof(sfs->f_mntonname) - 1) 1246 len = sizeof(sfs->f_mntonname) - 1; 1247 (void)strncpy(sfs->f_mntonname, bp, len); 1248 PNBUF_PUT(path); 1249 1250 if (len < sizeof(sfs->f_mntonname) - 1) { 1251 error = (*fun)(onp, &sfs->f_mntonname[len], 1252 sizeof(sfs->f_mntonname) - len - 1, &size); 1253 if (error) 1254 return error; 1255 size += len; 1256 } else { 1257 size = len; 1258 } 1259 } else { 1260 error = (*fun)(onp, &sfs->f_mntonname, 1261 sizeof(sfs->f_mntonname) - 1, &size); 1262 if (error) 1263 return error; 1264 } 1265 (void)memset(sfs->f_mntonname + size, 0, 1266 sizeof(sfs->f_mntonname) - size); 1267 } 1268 1269 if (fromp) { 1270 fun = (ukfrom == UIO_SYSSPACE) ? copystr : copyinstr; 1271 error = (*fun)(fromp, sfs->f_mntfromname, 1272 sizeof(sfs->f_mntfromname) - 1, &size); 1273 if (error) 1274 return error; 1275 (void)memset(sfs->f_mntfromname + size, 0, 1276 sizeof(sfs->f_mntfromname) - size); 1277 } 1278 return 0; 1279 } 1280 1281 void 1282 vfs_timestamp(struct timespec *ts) 1283 { 1284 1285 nanotime(ts); 1286 } 1287 1288 time_t rootfstime; /* recorded root fs time, if known */ 1289 void 1290 setrootfstime(time_t t) 1291 { 1292 rootfstime = t; 1293 } 1294 1295 static const uint8_t vttodt_tab[ ] = { 1296 [VNON] = DT_UNKNOWN, 1297 [VREG] = DT_REG, 1298 [VDIR] = DT_DIR, 1299 [VBLK] = DT_BLK, 1300 [VCHR] = DT_CHR, 1301 [VLNK] = DT_LNK, 1302 [VSOCK] = DT_SOCK, 1303 [VFIFO] = DT_FIFO, 1304 [VBAD] = DT_UNKNOWN 1305 }; 1306 1307 uint8_t 1308 vtype2dt(enum vtype vt) 1309 { 1310 1311 CTASSERT(VBAD == __arraycount(vttodt_tab) - 1); 1312 return vttodt_tab[vt]; 1313 } 1314 1315 int 1316 VFS_MOUNT(struct mount *mp, const char *a, void *b, size_t *c) 1317 { 1318 int error; 1319 1320 KERNEL_LOCK(1, NULL); 1321 error = (*(mp->mnt_op->vfs_mount))(mp, a, b, c); 1322 KERNEL_UNLOCK_ONE(NULL); 1323 1324 return error; 1325 } 1326 1327 int 1328 VFS_START(struct mount *mp, int a) 1329 { 1330 int error; 1331 1332 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1333 KERNEL_LOCK(1, NULL); 1334 } 1335 error = (*(mp->mnt_op->vfs_start))(mp, a); 1336 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1337 KERNEL_UNLOCK_ONE(NULL); 1338 } 1339 1340 return error; 1341 } 1342 1343 int 1344 VFS_UNMOUNT(struct mount *mp, int a) 1345 { 1346 int error; 1347 1348 KERNEL_LOCK(1, NULL); 1349 error = (*(mp->mnt_op->vfs_unmount))(mp, a); 1350 KERNEL_UNLOCK_ONE(NULL); 1351 1352 return error; 1353 } 1354 1355 int 1356 VFS_ROOT(struct mount *mp, struct vnode **a) 1357 { 1358 int error; 1359 1360 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1361 KERNEL_LOCK(1, NULL); 1362 } 1363 error = (*(mp->mnt_op->vfs_root))(mp, a); 1364 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1365 KERNEL_UNLOCK_ONE(NULL); 1366 } 1367 1368 return error; 1369 } 1370 1371 int 1372 VFS_QUOTACTL(struct mount *mp, struct quotactl_args *args) 1373 { 1374 int error; 1375 1376 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1377 KERNEL_LOCK(1, NULL); 1378 } 1379 error = (*(mp->mnt_op->vfs_quotactl))(mp, args); 1380 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1381 KERNEL_UNLOCK_ONE(NULL); 1382 } 1383 1384 return error; 1385 } 1386 1387 int 1388 VFS_STATVFS(struct mount *mp, struct statvfs *a) 1389 { 1390 int error; 1391 1392 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1393 KERNEL_LOCK(1, NULL); 1394 } 1395 error = (*(mp->mnt_op->vfs_statvfs))(mp, a); 1396 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1397 KERNEL_UNLOCK_ONE(NULL); 1398 } 1399 1400 return error; 1401 } 1402 1403 int 1404 VFS_SYNC(struct mount *mp, int a, struct kauth_cred *b) 1405 { 1406 int error; 1407 1408 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1409 KERNEL_LOCK(1, NULL); 1410 } 1411 error = (*(mp->mnt_op->vfs_sync))(mp, a, b); 1412 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1413 KERNEL_UNLOCK_ONE(NULL); 1414 } 1415 1416 return error; 1417 } 1418 1419 int 1420 VFS_FHTOVP(struct mount *mp, struct fid *a, struct vnode **b) 1421 { 1422 int error; 1423 1424 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1425 KERNEL_LOCK(1, NULL); 1426 } 1427 error = (*(mp->mnt_op->vfs_fhtovp))(mp, a, b); 1428 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1429 KERNEL_UNLOCK_ONE(NULL); 1430 } 1431 1432 return error; 1433 } 1434 1435 int 1436 VFS_VPTOFH(struct vnode *vp, struct fid *a, size_t *b) 1437 { 1438 int error; 1439 1440 if ((vp->v_vflag & VV_MPSAFE) == 0) { 1441 KERNEL_LOCK(1, NULL); 1442 } 1443 error = (*(vp->v_mount->mnt_op->vfs_vptofh))(vp, a, b); 1444 if ((vp->v_vflag & VV_MPSAFE) == 0) { 1445 KERNEL_UNLOCK_ONE(NULL); 1446 } 1447 1448 return error; 1449 } 1450 1451 int 1452 VFS_SNAPSHOT(struct mount *mp, struct vnode *a, struct timespec *b) 1453 { 1454 int error; 1455 1456 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1457 KERNEL_LOCK(1, NULL); 1458 } 1459 error = (*(mp->mnt_op->vfs_snapshot))(mp, a, b); 1460 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1461 KERNEL_UNLOCK_ONE(NULL); 1462 } 1463 1464 return error; 1465 } 1466 1467 int 1468 VFS_EXTATTRCTL(struct mount *mp, int a, struct vnode *b, int c, const char *d) 1469 { 1470 int error; 1471 1472 KERNEL_LOCK(1, NULL); /* XXXSMP check ffs */ 1473 error = (*(mp->mnt_op->vfs_extattrctl))(mp, a, b, c, d); 1474 KERNEL_UNLOCK_ONE(NULL); /* XXX */ 1475 1476 return error; 1477 } 1478 1479 int 1480 VFS_SUSPENDCTL(struct mount *mp, int a) 1481 { 1482 int error; 1483 1484 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1485 KERNEL_LOCK(1, NULL); 1486 } 1487 error = (*(mp->mnt_op->vfs_suspendctl))(mp, a); 1488 if ((mp->mnt_iflag & IMNT_MPSAFE) == 0) { 1489 KERNEL_UNLOCK_ONE(NULL); 1490 } 1491 1492 return error; 1493 } 1494 1495 #if defined(DDB) || defined(DEBUGPRINT) 1496 static const char buf_flagbits[] = BUF_FLAGBITS; 1497 1498 void 1499 vfs_buf_print(struct buf *bp, int full, void (*pr)(const char *, ...)) 1500 { 1501 char bf[1024]; 1502 1503 (*pr)(" vp %p lblkno 0x%"PRIx64" blkno 0x%"PRIx64" rawblkno 0x%" 1504 PRIx64 " dev 0x%x\n", 1505 bp->b_vp, bp->b_lblkno, bp->b_blkno, bp->b_rawblkno, bp->b_dev); 1506 1507 snprintb(bf, sizeof(bf), 1508 buf_flagbits, bp->b_flags | bp->b_oflags | bp->b_cflags); 1509 (*pr)(" error %d flags 0x%s\n", bp->b_error, bf); 1510 1511 (*pr)(" bufsize 0x%lx bcount 0x%lx resid 0x%lx\n", 1512 bp->b_bufsize, bp->b_bcount, bp->b_resid); 1513 (*pr)(" data %p saveaddr %p\n", 1514 bp->b_data, bp->b_saveaddr); 1515 (*pr)(" iodone %p objlock %p\n", bp->b_iodone, bp->b_objlock); 1516 } 1517 1518 void 1519 vfs_vnode_print(struct vnode *vp, int full, void (*pr)(const char *, ...)) 1520 { 1521 1522 uvm_object_printit(&vp->v_uobj, full, pr); 1523 (*pr)("\n"); 1524 vprint_common(vp, "", printf); 1525 if (full) { 1526 struct buf *bp; 1527 1528 (*pr)("clean bufs:\n"); 1529 LIST_FOREACH(bp, &vp->v_cleanblkhd, b_vnbufs) { 1530 (*pr)(" bp %p\n", bp); 1531 vfs_buf_print(bp, full, pr); 1532 } 1533 1534 (*pr)("dirty bufs:\n"); 1535 LIST_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) { 1536 (*pr)(" bp %p\n", bp); 1537 vfs_buf_print(bp, full, pr); 1538 } 1539 } 1540 } 1541 1542 void 1543 vfs_vnode_lock_print(void *vlock, int full, void (*pr)(const char *, ...)) 1544 { 1545 struct mount *mp; 1546 vnode_impl_t *vip; 1547 1548 TAILQ_FOREACH(mp, &mountlist, mnt_list) { 1549 TAILQ_FOREACH(vip, &mp->mnt_vnodelist, vi_mntvnodes) { 1550 if (&vip->vi_lock != vlock) 1551 continue; 1552 vfs_vnode_print(VIMPL_TO_VNODE(vip), full, pr); 1553 } 1554 } 1555 } 1556 1557 void 1558 vfs_mount_print(struct mount *mp, int full, void (*pr)(const char *, ...)) 1559 { 1560 char sbuf[256]; 1561 1562 (*pr)("vnodecovered = %p data = %p\n", 1563 mp->mnt_vnodecovered,mp->mnt_data); 1564 1565 (*pr)("fs_bshift %d dev_bshift = %d\n", 1566 mp->mnt_fs_bshift,mp->mnt_dev_bshift); 1567 1568 snprintb(sbuf, sizeof(sbuf), __MNT_FLAG_BITS, mp->mnt_flag); 1569 (*pr)("flag = %s\n", sbuf); 1570 1571 snprintb(sbuf, sizeof(sbuf), __IMNT_FLAG_BITS, mp->mnt_iflag); 1572 (*pr)("iflag = %s\n", sbuf); 1573 1574 (*pr)("refcnt = %d unmounting @ %p updating @ %p\n", mp->mnt_refcnt, 1575 &mp->mnt_unmounting, &mp->mnt_updating); 1576 1577 (*pr)("statvfs cache:\n"); 1578 (*pr)("\tbsize = %lu\n",mp->mnt_stat.f_bsize); 1579 (*pr)("\tfrsize = %lu\n",mp->mnt_stat.f_frsize); 1580 (*pr)("\tiosize = %lu\n",mp->mnt_stat.f_iosize); 1581 1582 (*pr)("\tblocks = %"PRIu64"\n",mp->mnt_stat.f_blocks); 1583 (*pr)("\tbfree = %"PRIu64"\n",mp->mnt_stat.f_bfree); 1584 (*pr)("\tbavail = %"PRIu64"\n",mp->mnt_stat.f_bavail); 1585 (*pr)("\tbresvd = %"PRIu64"\n",mp->mnt_stat.f_bresvd); 1586 1587 (*pr)("\tfiles = %"PRIu64"\n",mp->mnt_stat.f_files); 1588 (*pr)("\tffree = %"PRIu64"\n",mp->mnt_stat.f_ffree); 1589 (*pr)("\tfavail = %"PRIu64"\n",mp->mnt_stat.f_favail); 1590 (*pr)("\tfresvd = %"PRIu64"\n",mp->mnt_stat.f_fresvd); 1591 1592 (*pr)("\tf_fsidx = { 0x%"PRIx32", 0x%"PRIx32" }\n", 1593 mp->mnt_stat.f_fsidx.__fsid_val[0], 1594 mp->mnt_stat.f_fsidx.__fsid_val[1]); 1595 1596 (*pr)("\towner = %"PRIu32"\n",mp->mnt_stat.f_owner); 1597 (*pr)("\tnamemax = %lu\n",mp->mnt_stat.f_namemax); 1598 1599 snprintb(sbuf, sizeof(sbuf), __MNT_FLAG_BITS, mp->mnt_stat.f_flag); 1600 1601 (*pr)("\tflag = %s\n",sbuf); 1602 (*pr)("\tsyncwrites = %" PRIu64 "\n",mp->mnt_stat.f_syncwrites); 1603 (*pr)("\tasyncwrites = %" PRIu64 "\n",mp->mnt_stat.f_asyncwrites); 1604 (*pr)("\tsyncreads = %" PRIu64 "\n",mp->mnt_stat.f_syncreads); 1605 (*pr)("\tasyncreads = %" PRIu64 "\n",mp->mnt_stat.f_asyncreads); 1606 (*pr)("\tfstypename = %s\n",mp->mnt_stat.f_fstypename); 1607 (*pr)("\tmntonname = %s\n",mp->mnt_stat.f_mntonname); 1608 (*pr)("\tmntfromname = %s\n",mp->mnt_stat.f_mntfromname); 1609 1610 { 1611 int cnt = 0; 1612 vnode_t *vp; 1613 vnode_impl_t *vip; 1614 (*pr)("locked vnodes ="); 1615 TAILQ_FOREACH(vip, &mp->mnt_vnodelist, vi_mntvnodes) { 1616 vp = VIMPL_TO_VNODE(vip); 1617 if (VOP_ISLOCKED(vp)) { 1618 if ((++cnt % 6) == 0) { 1619 (*pr)(" %p,\n\t", vp); 1620 } else { 1621 (*pr)(" %p,", vp); 1622 } 1623 } 1624 } 1625 (*pr)("\n"); 1626 } 1627 1628 if (full) { 1629 int cnt = 0; 1630 vnode_t *vp; 1631 vnode_impl_t *vip; 1632 (*pr)("all vnodes ="); 1633 TAILQ_FOREACH(vip, &mp->mnt_vnodelist, vi_mntvnodes) { 1634 vp = VIMPL_TO_VNODE(vip); 1635 if (!TAILQ_NEXT(vip, vi_mntvnodes)) { 1636 (*pr)(" %p", vp); 1637 } else if ((++cnt % 6) == 0) { 1638 (*pr)(" %p,\n\t", vp); 1639 } else { 1640 (*pr)(" %p,", vp); 1641 } 1642 } 1643 (*pr)("\n"); 1644 } 1645 } 1646 1647 /* 1648 * List all of the locked vnodes in the system. 1649 */ 1650 void printlockedvnodes(void); 1651 1652 void 1653 printlockedvnodes(void) 1654 { 1655 struct mount *mp, *nmp; 1656 vnode_t *vp; 1657 vnode_impl_t *vip; 1658 1659 printf("Locked vnodes\n"); 1660 mutex_enter(&mountlist_lock); 1661 for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) { 1662 if (vfs_busy(mp, &nmp)) { 1663 continue; 1664 } 1665 TAILQ_FOREACH(vip, &mp->mnt_vnodelist, vi_mntvnodes) { 1666 vp = VIMPL_TO_VNODE(vip); 1667 if (VOP_ISLOCKED(vp)) 1668 vprint(NULL, vp); 1669 } 1670 mutex_enter(&mountlist_lock); 1671 vfs_unbusy(mp, false, &nmp); 1672 } 1673 mutex_exit(&mountlist_lock); 1674 } 1675 1676 #endif /* DDB || DEBUGPRINT */ 1677