1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 #include <sys/types.h> 26 #include <sys/t_lock.h> 27 #include <sys/param.h> 28 #include <sys/time.h> 29 #include <sys/systm.h> 30 #include <sys/sysmacros.h> 31 #include <sys/resource.h> 32 #include <sys/signal.h> 33 #include <sys/cred.h> 34 #include <sys/user.h> 35 #include <sys/buf.h> 36 #include <sys/vfs.h> 37 #include <sys/vnode.h> 38 #include <sys/proc.h> 39 #include <sys/disp.h> 40 #include <sys/file.h> 41 #include <sys/fcntl.h> 42 #include <sys/flock.h> 43 #include <sys/atomic.h> 44 #include <sys/kmem.h> 45 #include <sys/uio.h> 46 #include <sys/conf.h> 47 #include <sys/mman.h> 48 #include <sys/pathname.h> 49 #include <sys/debug.h> 50 #include <sys/vmsystm.h> 51 #include <sys/cmn_err.h> 52 #include <sys/acct.h> 53 #include <sys/dnlc.h> 54 #include <sys/swap.h> 55 56 #include <sys/fs/ufs_fs.h> 57 #include <sys/fs/ufs_inode.h> 58 #include <sys/fs/ufs_fsdir.h> 59 #include <sys/fs/ufs_trans.h> 60 #include <sys/fs/ufs_panic.h> 61 #include <sys/fs/ufs_mount.h> 62 #include <sys/fs/ufs_bio.h> 63 #include <sys/fs/ufs_log.h> 64 #include <sys/fs/ufs_quota.h> 65 #include <sys/dirent.h> /* must be AFTER <sys/fs/fsdir.h>! */ 66 #include <sys/errno.h> 67 #include <sys/sysinfo.h> 68 69 #include <vm/hat.h> 70 #include <vm/pvn.h> 71 #include <vm/as.h> 72 #include <vm/seg.h> 73 #include <vm/seg_map.h> 74 #include <vm/seg_vn.h> 75 #include <vm/rm.h> 76 #include <vm/anon.h> 77 #include <sys/swap.h> 78 #include <sys/dnlc.h> 79 80 extern struct vnode *common_specvp(struct vnode *vp); 81 82 /* error lock status */ 83 #define UN_ERRLCK (-1) 84 #define SET_ERRLCK 1 85 #define RE_ERRLCK 2 86 #define NO_ERRLCK 0 87 88 /* 89 * Index to be used in TSD for storing lockfs data 90 */ 91 uint_t ufs_lockfs_key; 92 93 typedef struct _ulockfs_info { 94 struct _ulockfs_info *next; 95 struct ulockfs *ulp; 96 uint_t flags; 97 } ulockfs_info_t; 98 99 #define ULOCK_INFO_FALLOCATE 0x00000001 /* fallocate thread */ 100 101 /* 102 * Check in TSD that whether we are already doing any VOP on this filesystem 103 */ 104 #define IS_REC_VOP(found, head, ulp, free) \ 105 { \ 106 ulockfs_info_t *_curr; \ 107 \ 108 for (found = 0, free = NULL, _curr = head; \ 109 _curr != NULL; _curr = _curr->next) { \ 110 if ((free == NULL) && \ 111 (_curr->ulp == NULL)) \ 112 free = _curr; \ 113 if (_curr->ulp == ulp) { \ 114 found = 1; \ 115 break; \ 116 } \ 117 } \ 118 } 119 120 /* 121 * Get the lockfs data from TSD so that lockfs handles the recursive VOP 122 * properly 123 */ 124 #define SEARCH_ULOCKFSP(head, ulp, info) \ 125 { \ 126 ulockfs_info_t *_curr; \ 127 \ 128 for (_curr = head; _curr != NULL; \ 129 _curr = _curr->next) { \ 130 if (_curr->ulp == ulp) { \ 131 break; \ 132 } \ 133 } \ 134 \ 135 info = _curr; \ 136 } 137 138 /* 139 * Validate lockfs request 140 */ 141 static int 142 ufs_getlfd( 143 struct lockfs *lockfsp, /* new lock request */ 144 struct lockfs *ul_lockfsp) /* old lock state */ 145 { 146 int error = 0; 147 148 /* 149 * no input flags defined 150 */ 151 if (lockfsp->lf_flags != 0) { 152 error = EINVAL; 153 goto errout; 154 } 155 156 /* 157 * check key 158 */ 159 if (!LOCKFS_IS_ULOCK(ul_lockfsp)) 160 if (lockfsp->lf_key != ul_lockfsp->lf_key) { 161 error = EINVAL; 162 goto errout; 163 } 164 165 lockfsp->lf_key = ul_lockfsp->lf_key + 1; 166 167 errout: 168 return (error); 169 } 170 171 /* 172 * ufs_checkaccton 173 * check if accounting is turned on on this fs 174 */ 175 176 int 177 ufs_checkaccton(struct vnode *vp) 178 { 179 if (acct_fs_in_use(vp)) 180 return (EDEADLK); 181 return (0); 182 } 183 184 /* 185 * ufs_checkswapon 186 * check if local swapping is to file on this fs 187 */ 188 int 189 ufs_checkswapon(struct vnode *vp) 190 { 191 struct swapinfo *sip; 192 193 mutex_enter(&swapinfo_lock); 194 for (sip = swapinfo; sip; sip = sip->si_next) 195 if (sip->si_vp->v_vfsp == vp->v_vfsp) { 196 mutex_exit(&swapinfo_lock); 197 return (EDEADLK); 198 } 199 mutex_exit(&swapinfo_lock); 200 return (0); 201 } 202 203 /* 204 * ufs_freeze 205 * pend future accesses for current lock and desired lock 206 */ 207 void 208 ufs_freeze(struct ulockfs *ulp, struct lockfs *lockfsp) 209 { 210 /* 211 * set to new lock type 212 */ 213 ulp->ul_lockfs.lf_lock = lockfsp->lf_lock; 214 ulp->ul_lockfs.lf_key = lockfsp->lf_key; 215 ulp->ul_lockfs.lf_comlen = lockfsp->lf_comlen; 216 ulp->ul_lockfs.lf_comment = lockfsp->lf_comment; 217 218 ulp->ul_fs_lock = (1 << ulp->ul_lockfs.lf_lock); 219 } 220 221 /* 222 * All callers of ufs_quiesce() atomically increment ufs_quiesce_pend before 223 * starting ufs_quiesce() protocol and decrement it only when a file system no 224 * longer has to be in quiescent state. This allows ufs_pageio() to detect 225 * that another thread wants to quiesce a file system. See more comments in 226 * ufs_pageio(). 227 */ 228 ulong_t ufs_quiesce_pend = 0; 229 230 /* 231 * ufs_quiesce 232 * wait for outstanding accesses to finish 233 */ 234 int 235 ufs_quiesce(struct ulockfs *ulp) 236 { 237 int error = 0; 238 ulockfs_info_t *head; 239 ulockfs_info_t *info; 240 klwp_t *lwp = ttolwp(curthread); 241 242 head = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 243 SEARCH_ULOCKFSP(head, ulp, info); 244 245 /* 246 * We have to keep /proc away from stopping us after we applied 247 * the softlock but before we got a chance to clear it again. 248 * prstop() may pagefault and become stuck on the softlock still 249 * pending. 250 */ 251 if (lwp != NULL) 252 lwp->lwp_nostop++; 253 254 /* 255 * Set a softlock to suspend future ufs_vnops so that 256 * this lockfs request will not be starved 257 */ 258 ULOCKFS_SET_SLOCK(ulp); 259 ASSERT(ufs_quiesce_pend); 260 261 /* check if there is any outstanding ufs vnodeops calls */ 262 while (ulp->ul_vnops_cnt || ulp->ul_falloc_cnt) { 263 /* 264 * use timed version of cv_wait_sig() to make sure we don't 265 * miss a wake up call from ufs_pageio() when it doesn't use 266 * ul_lock. 267 * 268 * when a fallocate thread comes in, the only way it returns 269 * from this function is if there are no other vnode operations 270 * going on (remember fallocate threads are tracked using 271 * ul_falloc_cnt not ul_vnops_cnt), and another fallocate thread 272 * hasn't already grabbed the fs write lock. 273 */ 274 if (info && (info->flags & ULOCK_INFO_FALLOCATE)) { 275 if (!ulp->ul_vnops_cnt && !ULOCKFS_IS_FWLOCK(ulp)) 276 goto out; 277 } 278 if (!cv_reltimedwait_sig(&ulp->ul_cv, &ulp->ul_lock, hz, 279 TR_CLOCK_TICK)) { 280 error = EINTR; 281 goto out; 282 } 283 } 284 285 out: 286 /* 287 * unlock the soft lock 288 */ 289 ULOCKFS_CLR_SLOCK(ulp); 290 291 if (lwp != NULL) 292 lwp->lwp_nostop--; 293 294 return (error); 295 } 296 297 /* 298 * ufs_flush_inode 299 */ 300 int 301 ufs_flush_inode(struct inode *ip, void *arg) 302 { 303 int error; 304 int saverror = 0; 305 306 /* 307 * wrong file system; keep looking 308 */ 309 if (ip->i_ufsvfs != (struct ufsvfs *)arg) 310 return (0); 311 312 /* 313 * asynchronously push all the dirty pages 314 */ 315 if (((error = TRANS_SYNCIP(ip, B_ASYNC, 0, TOP_SYNCIP_FLUSHI)) != 0) && 316 (error != EAGAIN)) 317 saverror = error; 318 /* 319 * wait for io and discard all mappings 320 */ 321 if (error = TRANS_SYNCIP(ip, B_INVAL, 0, TOP_SYNCIP_FLUSHI)) 322 saverror = error; 323 324 if (ITOV(ip)->v_type == VDIR) { 325 dnlc_dir_purge(&ip->i_danchor); 326 } 327 328 return (saverror); 329 } 330 331 /* 332 * ufs_flush 333 * Flush everything that is currently dirty; this includes invalidating 334 * any mappings. 335 */ 336 int 337 ufs_flush(struct vfs *vfsp) 338 { 339 int error; 340 int saverror = 0; 341 struct ufsvfs *ufsvfsp = (struct ufsvfs *)vfsp->vfs_data; 342 struct fs *fs = ufsvfsp->vfs_fs; 343 int tdontblock = 0; 344 345 ASSERT(vfs_lock_held(vfsp)); 346 347 /* 348 * purge dnlc 349 */ 350 (void) dnlc_purge_vfsp(vfsp, 0); 351 352 /* 353 * drain the delete and idle threads 354 */ 355 ufs_delete_drain(vfsp, 0, 0); 356 ufs_idle_drain(vfsp); 357 358 /* 359 * flush and invalidate quota records 360 */ 361 (void) qsync(ufsvfsp); 362 363 /* 364 * flush w/invalidate the inodes for vfsp 365 */ 366 if (error = ufs_scan_inodes(0, ufs_flush_inode, ufsvfsp, ufsvfsp)) 367 saverror = error; 368 369 /* 370 * synchronously flush superblock and summary info 371 */ 372 if (fs->fs_ronly == 0 && fs->fs_fmod) { 373 fs->fs_fmod = 0; 374 TRANS_SBUPDATE(ufsvfsp, vfsp, TOP_SBUPDATE_FLUSH); 375 } 376 /* 377 * flush w/invalidate block device pages and buf cache 378 */ 379 if ((error = VOP_PUTPAGE(common_specvp(ufsvfsp->vfs_devvp), 380 (offset_t)0, 0, B_INVAL, CRED(), NULL)) > 0) 381 saverror = error; 382 383 (void) bflush((dev_t)vfsp->vfs_dev); 384 (void) bfinval((dev_t)vfsp->vfs_dev, 0); 385 386 /* 387 * drain the delete and idle threads again 388 */ 389 ufs_delete_drain(vfsp, 0, 0); 390 ufs_idle_drain(vfsp); 391 392 /* 393 * play with the clean flag 394 */ 395 if (saverror == 0) 396 ufs_checkclean(vfsp); 397 398 /* 399 * Flush any outstanding transactions and roll the log 400 * only if we are supposed to do, i.e. LDL_NOROLL not set. 401 * We can not simply check for fs_ronly here since fsck also may 402 * use this code to roll the log on a read-only filesystem, e.g. 403 * root during early stages of boot, if other then a sanity check is 404 * done, it will clear LDL_NOROLL before. 405 * In addition we assert that the deltamap does not contain any deltas 406 * in case LDL_NOROLL is set since this is not supposed to happen. 407 */ 408 if (TRANS_ISTRANS(ufsvfsp)) { 409 ml_unit_t *ul = ufsvfsp->vfs_log; 410 mt_map_t *mtm = ul->un_deltamap; 411 412 if (ul->un_flags & LDL_NOROLL) { 413 ASSERT(mtm->mtm_nme == 0); 414 } else { 415 /* 416 * Do not set T_DONTBLOCK if there is a 417 * transaction opened by caller. 418 */ 419 if (curthread->t_flag & T_DONTBLOCK) 420 tdontblock = 1; 421 else 422 curthread->t_flag |= T_DONTBLOCK; 423 424 TRANS_BEGIN_SYNC(ufsvfsp, TOP_COMMIT_FLUSH, 425 TOP_COMMIT_SIZE, error); 426 427 if (!error) { 428 TRANS_END_SYNC(ufsvfsp, saverror, 429 TOP_COMMIT_FLUSH, TOP_COMMIT_SIZE); 430 } 431 432 if (tdontblock == 0) 433 curthread->t_flag &= ~T_DONTBLOCK; 434 435 logmap_roll_dev(ufsvfsp->vfs_log); 436 } 437 } 438 439 return (saverror); 440 } 441 442 /* 443 * ufs_thaw_wlock 444 * special processing when thawing down to wlock 445 */ 446 static int 447 ufs_thaw_wlock(struct inode *ip, void *arg) 448 { 449 /* 450 * wrong file system; keep looking 451 */ 452 if (ip->i_ufsvfs != (struct ufsvfs *)arg) 453 return (0); 454 455 /* 456 * iupdat refuses to clear flags if the fs is read only. The fs 457 * may become read/write during the lock and we wouldn't want 458 * these inodes being written to disk. So clear the flags. 459 */ 460 rw_enter(&ip->i_contents, RW_WRITER); 461 ip->i_flag &= ~(IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG); 462 rw_exit(&ip->i_contents); 463 464 /* 465 * pages are mlocked -- fail wlock 466 */ 467 if (ITOV(ip)->v_type != VCHR && vn_has_cached_data(ITOV(ip))) 468 return (EBUSY); 469 470 return (0); 471 } 472 473 /* 474 * ufs_thaw_hlock 475 * special processing when thawing down to hlock or elock 476 */ 477 static int 478 ufs_thaw_hlock(struct inode *ip, void *arg) 479 { 480 struct vnode *vp = ITOV(ip); 481 482 /* 483 * wrong file system; keep looking 484 */ 485 if (ip->i_ufsvfs != (struct ufsvfs *)arg) 486 return (0); 487 488 /* 489 * blow away all pages - even if they are mlocked 490 */ 491 do { 492 (void) TRANS_SYNCIP(ip, B_INVAL | B_FORCE, 0, TOP_SYNCIP_HLOCK); 493 } while ((vp->v_type != VCHR) && vn_has_cached_data(vp)); 494 rw_enter(&ip->i_contents, RW_WRITER); 495 ip->i_flag &= ~(IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG); 496 rw_exit(&ip->i_contents); 497 498 return (0); 499 } 500 501 /* 502 * ufs_thaw 503 * thaw file system lock down to current value 504 */ 505 int 506 ufs_thaw(struct vfs *vfsp, struct ufsvfs *ufsvfsp, struct ulockfs *ulp) 507 { 508 int error = 0; 509 int noidel = (int)(ulp->ul_flag & ULOCKFS_NOIDEL); 510 511 /* 512 * if wlock or hlock or elock 513 */ 514 if (ULOCKFS_IS_WLOCK(ulp) || ULOCKFS_IS_HLOCK(ulp) || 515 ULOCKFS_IS_ELOCK(ulp)) { 516 517 /* 518 * don't keep access times 519 * don't free deleted files 520 * if superblock writes are allowed, limit them to me for now 521 */ 522 ulp->ul_flag |= (ULOCKFS_NOIACC|ULOCKFS_NOIDEL); 523 if (ulp->ul_sbowner != (kthread_id_t)-1) 524 ulp->ul_sbowner = curthread; 525 526 /* 527 * wait for writes for deleted files and superblock updates 528 */ 529 (void) ufs_flush(vfsp); 530 531 /* 532 * now make sure the quota file is up-to-date 533 * expensive; but effective 534 */ 535 error = ufs_flush(vfsp); 536 /* 537 * no one can write the superblock 538 */ 539 ulp->ul_sbowner = (kthread_id_t)-1; 540 541 /* 542 * special processing for wlock/hlock/elock 543 */ 544 if (ULOCKFS_IS_WLOCK(ulp)) { 545 if (error) 546 goto errout; 547 error = bfinval(ufsvfsp->vfs_dev, 0); 548 if (error) 549 goto errout; 550 error = ufs_scan_inodes(0, ufs_thaw_wlock, 551 (void *)ufsvfsp, ufsvfsp); 552 if (error) 553 goto errout; 554 } 555 if (ULOCKFS_IS_HLOCK(ulp) || ULOCKFS_IS_ELOCK(ulp)) { 556 error = 0; 557 (void) ufs_scan_inodes(0, ufs_thaw_hlock, 558 (void *)ufsvfsp, ufsvfsp); 559 (void) bfinval(ufsvfsp->vfs_dev, 1); 560 } 561 } else { 562 563 /* 564 * okay to keep access times 565 * okay to free deleted files 566 * okay to write the superblock 567 */ 568 ulp->ul_flag &= ~(ULOCKFS_NOIACC|ULOCKFS_NOIDEL); 569 ulp->ul_sbowner = NULL; 570 571 /* 572 * flush in case deleted files are in memory 573 */ 574 if (noidel) { 575 if (error = ufs_flush(vfsp)) 576 goto errout; 577 } 578 } 579 580 errout: 581 cv_broadcast(&ulp->ul_cv); 582 return (error); 583 } 584 585 /* 586 * ufs_reconcile_fs 587 * reconcile incore superblock with ondisk superblock 588 */ 589 int 590 ufs_reconcile_fs(struct vfs *vfsp, struct ufsvfs *ufsvfsp, int errlck) 591 { 592 struct fs *mfs; /* in-memory superblock */ 593 struct fs *dfs; /* on-disk superblock */ 594 struct buf *bp; /* on-disk superblock buf */ 595 int needs_unlock; 596 char finished_fsclean; 597 598 mfs = ufsvfsp->vfs_fs; 599 600 /* 601 * get the on-disk copy of the superblock 602 */ 603 bp = UFS_BREAD(ufsvfsp, vfsp->vfs_dev, SBLOCK, SBSIZE); 604 bp->b_flags |= (B_STALE|B_AGE); 605 if (bp->b_flags & B_ERROR) { 606 brelse(bp); 607 return (EIO); 608 } 609 dfs = bp->b_un.b_fs; 610 611 /* error locks may only unlock after the fs has been made consistent */ 612 if (errlck == UN_ERRLCK) { 613 if (dfs->fs_clean == FSFIX) { /* being repaired */ 614 brelse(bp); 615 return (EAGAIN); 616 } 617 /* repair not yet started? */ 618 finished_fsclean = TRANS_ISTRANS(ufsvfsp)? FSLOG: FSCLEAN; 619 if (dfs->fs_clean != finished_fsclean) { 620 brelse(bp); 621 return (EBUSY); 622 } 623 } 624 625 /* 626 * if superblock has changed too much, abort 627 */ 628 if ((mfs->fs_sblkno != dfs->fs_sblkno) || 629 (mfs->fs_cblkno != dfs->fs_cblkno) || 630 (mfs->fs_iblkno != dfs->fs_iblkno) || 631 (mfs->fs_dblkno != dfs->fs_dblkno) || 632 (mfs->fs_cgoffset != dfs->fs_cgoffset) || 633 (mfs->fs_cgmask != dfs->fs_cgmask) || 634 (mfs->fs_bsize != dfs->fs_bsize) || 635 (mfs->fs_fsize != dfs->fs_fsize) || 636 (mfs->fs_frag != dfs->fs_frag) || 637 (mfs->fs_bmask != dfs->fs_bmask) || 638 (mfs->fs_fmask != dfs->fs_fmask) || 639 (mfs->fs_bshift != dfs->fs_bshift) || 640 (mfs->fs_fshift != dfs->fs_fshift) || 641 (mfs->fs_fragshift != dfs->fs_fragshift) || 642 (mfs->fs_fsbtodb != dfs->fs_fsbtodb) || 643 (mfs->fs_sbsize != dfs->fs_sbsize) || 644 (mfs->fs_nindir != dfs->fs_nindir) || 645 (mfs->fs_nspf != dfs->fs_nspf) || 646 (mfs->fs_trackskew != dfs->fs_trackskew) || 647 (mfs->fs_cgsize != dfs->fs_cgsize) || 648 (mfs->fs_ntrak != dfs->fs_ntrak) || 649 (mfs->fs_nsect != dfs->fs_nsect) || 650 (mfs->fs_spc != dfs->fs_spc) || 651 (mfs->fs_cpg != dfs->fs_cpg) || 652 (mfs->fs_ipg != dfs->fs_ipg) || 653 (mfs->fs_fpg != dfs->fs_fpg) || 654 (mfs->fs_postblformat != dfs->fs_postblformat) || 655 (mfs->fs_magic != dfs->fs_magic)) { 656 brelse(bp); 657 return (EACCES); 658 } 659 if (dfs->fs_clean == FSBAD || FSOKAY != dfs->fs_state + dfs->fs_time) 660 if (mfs->fs_clean == FSLOG) { 661 brelse(bp); 662 return (EACCES); 663 } 664 665 /* 666 * get new summary info 667 */ 668 if (ufs_getsummaryinfo(vfsp->vfs_dev, ufsvfsp, dfs)) { 669 brelse(bp); 670 return (EIO); 671 } 672 673 /* 674 * release old summary info and update in-memory superblock 675 */ 676 kmem_free(mfs->fs_u.fs_csp, mfs->fs_cssize); 677 mfs->fs_u.fs_csp = dfs->fs_u.fs_csp; /* Only entry 0 used */ 678 679 /* 680 * update fields allowed to change 681 */ 682 mfs->fs_size = dfs->fs_size; 683 mfs->fs_dsize = dfs->fs_dsize; 684 mfs->fs_ncg = dfs->fs_ncg; 685 mfs->fs_minfree = dfs->fs_minfree; 686 mfs->fs_rotdelay = dfs->fs_rotdelay; 687 mfs->fs_rps = dfs->fs_rps; 688 mfs->fs_maxcontig = dfs->fs_maxcontig; 689 mfs->fs_maxbpg = dfs->fs_maxbpg; 690 mfs->fs_csmask = dfs->fs_csmask; 691 mfs->fs_csshift = dfs->fs_csshift; 692 mfs->fs_optim = dfs->fs_optim; 693 mfs->fs_csaddr = dfs->fs_csaddr; 694 mfs->fs_cssize = dfs->fs_cssize; 695 mfs->fs_ncyl = dfs->fs_ncyl; 696 mfs->fs_cstotal = dfs->fs_cstotal; 697 mfs->fs_reclaim = dfs->fs_reclaim; 698 699 if (mfs->fs_reclaim & (FS_RECLAIM|FS_RECLAIMING)) { 700 mfs->fs_reclaim &= ~FS_RECLAIM; 701 mfs->fs_reclaim |= FS_RECLAIMING; 702 ufs_thread_start(&ufsvfsp->vfs_reclaim, 703 ufs_thread_reclaim, vfsp); 704 } 705 706 /* XXX What to do about sparecon? */ 707 708 /* XXX need to copy volume label */ 709 710 /* 711 * ondisk clean flag overrides inmemory clean flag iff == FSBAD 712 * or if error-locked and ondisk is now clean 713 */ 714 needs_unlock = !MUTEX_HELD(&ufsvfsp->vfs_lock); 715 if (needs_unlock) 716 mutex_enter(&ufsvfsp->vfs_lock); 717 718 if (errlck == UN_ERRLCK) { 719 if (finished_fsclean == dfs->fs_clean) 720 mfs->fs_clean = finished_fsclean; 721 else 722 mfs->fs_clean = FSBAD; 723 mfs->fs_state = FSOKAY - dfs->fs_time; 724 } 725 726 if (FSOKAY != dfs->fs_state + dfs->fs_time || 727 (dfs->fs_clean == FSBAD)) 728 mfs->fs_clean = FSBAD; 729 730 if (needs_unlock) 731 mutex_exit(&ufsvfsp->vfs_lock); 732 733 brelse(bp); 734 735 return (0); 736 } 737 738 /* 739 * ufs_reconcile_inode 740 * reconcile ondisk inode with incore inode 741 */ 742 static int 743 ufs_reconcile_inode(struct inode *ip, void *arg) 744 { 745 int i; 746 int ndaddr; 747 int niaddr; 748 struct dinode *dp; /* ondisk inode */ 749 struct buf *bp = NULL; 750 uid_t d_uid; 751 gid_t d_gid; 752 int error = 0; 753 struct fs *fs; 754 755 /* 756 * not an inode we care about 757 */ 758 if (ip->i_ufsvfs != (struct ufsvfs *)arg) 759 return (0); 760 761 fs = ip->i_fs; 762 763 /* 764 * Inode reconciliation fails: we made the filesystem quiescent 765 * and we did a ufs_flush() before calling ufs_reconcile_inode() 766 * and thus the inode should not have been changed inbetween. 767 * Any discrepancies indicate a logic error and a pretty 768 * significant run-state inconsistency we should complain about. 769 */ 770 if (ip->i_flag & (IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG)) { 771 cmn_err(CE_WARN, "%s: Inode reconciliation failed for" 772 "inode %llu", fs->fs_fsmnt, (u_longlong_t)ip->i_number); 773 return (EINVAL); 774 } 775 776 /* 777 * get the dinode 778 */ 779 bp = UFS_BREAD(ip->i_ufsvfs, 780 ip->i_dev, (daddr_t)fsbtodb(fs, itod(fs, ip->i_number)), 781 (int)fs->fs_bsize); 782 if (bp->b_flags & B_ERROR) { 783 brelse(bp); 784 return (EIO); 785 } 786 dp = bp->b_un.b_dino; 787 dp += itoo(fs, ip->i_number); 788 789 /* 790 * handle Sun's implementation of EFT 791 */ 792 d_uid = (dp->di_suid == UID_LONG) ? dp->di_uid : (uid_t)dp->di_suid; 793 d_gid = (dp->di_sgid == GID_LONG) ? dp->di_gid : (uid_t)dp->di_sgid; 794 795 rw_enter(&ip->i_contents, RW_WRITER); 796 797 /* 798 * some fields are not allowed to change 799 */ 800 if ((ip->i_mode != dp->di_mode) || 801 (ip->i_gen != dp->di_gen) || 802 (ip->i_uid != d_uid) || 803 (ip->i_gid != d_gid)) { 804 error = EACCES; 805 goto out; 806 } 807 808 /* 809 * and some are allowed to change 810 */ 811 ip->i_size = dp->di_size; 812 ip->i_ic.ic_flags = dp->di_ic.ic_flags; 813 ip->i_blocks = dp->di_blocks; 814 ip->i_nlink = dp->di_nlink; 815 if (ip->i_flag & IFASTSYMLNK) { 816 ndaddr = 1; 817 niaddr = 0; 818 } else { 819 ndaddr = NDADDR; 820 niaddr = NIADDR; 821 } 822 for (i = 0; i < ndaddr; ++i) 823 ip->i_db[i] = dp->di_db[i]; 824 for (i = 0; i < niaddr; ++i) 825 ip->i_ib[i] = dp->di_ib[i]; 826 827 out: 828 rw_exit(&ip->i_contents); 829 brelse(bp); 830 return (error); 831 } 832 833 /* 834 * ufs_reconcile 835 * reconcile ondisk superblock/inodes with any incore 836 */ 837 static int 838 ufs_reconcile(struct vfs *vfsp, struct ufsvfs *ufsvfsp, int errlck) 839 { 840 int error = 0; 841 842 /* 843 * get rid of as much inmemory data as possible 844 */ 845 (void) ufs_flush(vfsp); 846 847 /* 848 * reconcile the superblock and inodes 849 */ 850 if (error = ufs_reconcile_fs(vfsp, ufsvfsp, errlck)) 851 return (error); 852 if (error = ufs_scan_inodes(0, ufs_reconcile_inode, ufsvfsp, ufsvfsp)) 853 return (error); 854 /* 855 * allocation blocks may be incorrect; get rid of them 856 */ 857 (void) ufs_flush(vfsp); 858 859 return (error); 860 } 861 862 /* 863 * File system locking 864 */ 865 int 866 ufs_fiolfs(struct vnode *vp, struct lockfs *lockfsp, int from_log) 867 { 868 return (ufs__fiolfs(vp, lockfsp, /* from_user */ 1, from_log)); 869 } 870 871 /* kernel-internal interface, also used by fix-on-panic */ 872 int 873 ufs__fiolfs( 874 struct vnode *vp, 875 struct lockfs *lockfsp, 876 int from_user, 877 int from_log) 878 { 879 struct ulockfs *ulp; 880 struct lockfs lfs; 881 int error; 882 struct vfs *vfsp; 883 struct ufsvfs *ufsvfsp; 884 int errlck = NO_ERRLCK; 885 int poll_events = POLLPRI; 886 extern struct pollhead ufs_pollhd; 887 ulockfs_info_t *head; 888 ulockfs_info_t *info; 889 int signal = 0; 890 891 /* check valid lock type */ 892 if (!lockfsp || lockfsp->lf_lock > LOCKFS_MAXLOCK) 893 return (EINVAL); 894 895 if (!vp || !vp->v_vfsp || !vp->v_vfsp->vfs_data) 896 return (EIO); 897 898 vfsp = vp->v_vfsp; 899 900 if (vfsp->vfs_flag & VFS_UNMOUNTED) /* has been unmounted */ 901 return (EIO); 902 903 /* take the lock and check again */ 904 vfs_lock_wait(vfsp); 905 if (vfsp->vfs_flag & VFS_UNMOUNTED) { 906 vfs_unlock(vfsp); 907 return (EIO); 908 } 909 910 /* 911 * Can't wlock or ro/elock fs with accounting or local swap file 912 * We need to check for this before we grab the ul_lock to avoid 913 * deadlocks with the accounting framework. 914 */ 915 if ((LOCKFS_IS_WLOCK(lockfsp) || LOCKFS_IS_ELOCK(lockfsp) || 916 LOCKFS_IS_ROELOCK(lockfsp)) && !from_log) { 917 if (ufs_checkaccton(vp) || ufs_checkswapon(vp)) { 918 vfs_unlock(vfsp); 919 return (EDEADLK); 920 } 921 } 922 923 ufsvfsp = (struct ufsvfs *)vfsp->vfs_data; 924 ulp = &ufsvfsp->vfs_ulockfs; 925 head = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 926 SEARCH_ULOCKFSP(head, ulp, info); 927 928 /* 929 * Suspend both the reclaim thread and the delete thread. 930 * This must be done outside the lockfs locking protocol. 931 */ 932 ufs_thread_suspend(&ufsvfsp->vfs_reclaim); 933 ufs_thread_suspend(&ufsvfsp->vfs_delete); 934 935 mutex_enter(&ulp->ul_lock); 936 atomic_inc_ulong(&ufs_quiesce_pend); 937 938 /* 939 * Quit if there is another lockfs request in progress 940 * that is waiting for existing ufs_vnops to complete. 941 */ 942 if (ULOCKFS_IS_BUSY(ulp)) { 943 error = EBUSY; 944 goto errexit; 945 } 946 947 /* cannot ulocked or downgrade a hard-lock */ 948 if (ULOCKFS_IS_HLOCK(ulp)) { 949 error = EIO; 950 goto errexit; 951 } 952 953 /* an error lock may be unlocked or relocked, only */ 954 if (ULOCKFS_IS_ELOCK(ulp)) { 955 if (!LOCKFS_IS_ULOCK(lockfsp) && !LOCKFS_IS_ELOCK(lockfsp)) { 956 error = EBUSY; 957 goto errexit; 958 } 959 } 960 961 /* 962 * a read-only error lock may only be upgraded to an 963 * error lock or hard lock 964 */ 965 if (ULOCKFS_IS_ROELOCK(ulp)) { 966 if (!LOCKFS_IS_HLOCK(lockfsp) && !LOCKFS_IS_ELOCK(lockfsp)) { 967 error = EBUSY; 968 goto errexit; 969 } 970 } 971 972 /* 973 * until read-only error locks are fully implemented 974 * just return EINVAL 975 */ 976 if (LOCKFS_IS_ROELOCK(lockfsp)) { 977 error = EINVAL; 978 goto errexit; 979 } 980 981 /* 982 * an error lock may only be applied if the file system is 983 * unlocked or already error locked. 984 * (this is to prevent the case where a fs gets changed out from 985 * underneath a fs that is locked for backup, 986 * that is, name/delete/write-locked.) 987 */ 988 if ((!ULOCKFS_IS_ULOCK(ulp) && !ULOCKFS_IS_ELOCK(ulp) && 989 !ULOCKFS_IS_ROELOCK(ulp)) && 990 (LOCKFS_IS_ELOCK(lockfsp) || LOCKFS_IS_ROELOCK(lockfsp))) { 991 error = EBUSY; 992 goto errexit; 993 } 994 995 /* get and validate the input lockfs request */ 996 if (error = ufs_getlfd(lockfsp, &ulp->ul_lockfs)) 997 goto errexit; 998 999 /* 1000 * save current ulockfs struct 1001 */ 1002 bcopy(&ulp->ul_lockfs, &lfs, sizeof (struct lockfs)); 1003 1004 /* 1005 * Freeze the file system (pend future accesses) 1006 */ 1007 ufs_freeze(ulp, lockfsp); 1008 1009 /* 1010 * Set locking in progress because ufs_quiesce may free the 1011 * ul_lock mutex. 1012 */ 1013 ULOCKFS_SET_BUSY(ulp); 1014 /* update the ioctl copy */ 1015 LOCKFS_SET_BUSY(&ulp->ul_lockfs); 1016 1017 /* 1018 * We need to unset FWLOCK status before we call ufs_quiesce 1019 * so that the thread doesnt get suspended. We do this only if 1020 * this (fallocate) thread requested an unlock operation. 1021 */ 1022 if (info && (info->flags & ULOCK_INFO_FALLOCATE)) { 1023 if (!ULOCKFS_IS_WLOCK(ulp)) 1024 ULOCKFS_CLR_FWLOCK(ulp); 1025 } 1026 1027 /* 1028 * Quiesce (wait for outstanding accesses to finish) 1029 */ 1030 if (error = ufs_quiesce(ulp)) { 1031 /* 1032 * Interrupted due to signal. There could still be 1033 * pending vnops. 1034 */ 1035 signal = 1; 1036 1037 /* 1038 * We do broadcast because lock-status 1039 * could be reverted to old status. 1040 */ 1041 cv_broadcast(&ulp->ul_cv); 1042 goto errout; 1043 } 1044 1045 /* 1046 * If the fallocate thread requested a write fs lock operation 1047 * then we set fwlock status in the ulp. 1048 */ 1049 if (info && (info->flags & ULOCK_INFO_FALLOCATE)) { 1050 if (ULOCKFS_IS_WLOCK(ulp)) 1051 ULOCKFS_SET_FWLOCK(ulp); 1052 } 1053 1054 /* 1055 * save error lock status to pass down to reconcilation 1056 * routines and for later cleanup 1057 */ 1058 if (LOCKFS_IS_ELOCK(&lfs) && ULOCKFS_IS_ULOCK(ulp)) 1059 errlck = UN_ERRLCK; 1060 1061 if (ULOCKFS_IS_ELOCK(ulp) || ULOCKFS_IS_ROELOCK(ulp)) { 1062 int needs_unlock; 1063 int needs_sbwrite; 1064 1065 poll_events |= POLLERR; 1066 errlck = LOCKFS_IS_ELOCK(&lfs) || LOCKFS_IS_ROELOCK(&lfs) ? 1067 RE_ERRLCK : SET_ERRLCK; 1068 1069 needs_unlock = !MUTEX_HELD(&ufsvfsp->vfs_lock); 1070 if (needs_unlock) 1071 mutex_enter(&ufsvfsp->vfs_lock); 1072 1073 /* disable delayed i/o */ 1074 needs_sbwrite = 0; 1075 1076 if (errlck == SET_ERRLCK) { 1077 ufsvfsp->vfs_fs->fs_clean = FSBAD; 1078 needs_sbwrite = 1; 1079 } 1080 1081 needs_sbwrite |= ufsvfsp->vfs_dio; 1082 ufsvfsp->vfs_dio = 0; 1083 1084 if (needs_unlock) 1085 mutex_exit(&ufsvfsp->vfs_lock); 1086 1087 if (needs_sbwrite) { 1088 ulp->ul_sbowner = curthread; 1089 TRANS_SBWRITE(ufsvfsp, TOP_SBWRITE_STABLE); 1090 1091 if (needs_unlock) 1092 mutex_enter(&ufsvfsp->vfs_lock); 1093 1094 ufsvfsp->vfs_fs->fs_fmod = 0; 1095 1096 if (needs_unlock) 1097 mutex_exit(&ufsvfsp->vfs_lock); 1098 } 1099 } 1100 1101 /* 1102 * reconcile superblock and inodes if was wlocked 1103 */ 1104 if (LOCKFS_IS_WLOCK(&lfs) || LOCKFS_IS_ELOCK(&lfs)) { 1105 if (error = ufs_reconcile(vfsp, ufsvfsp, errlck)) 1106 goto errout; 1107 /* 1108 * in case the fs grew; reset the metadata map for logging tests 1109 */ 1110 TRANS_MATA_UMOUNT(ufsvfsp); 1111 TRANS_MATA_MOUNT(ufsvfsp); 1112 TRANS_MATA_SI(ufsvfsp, ufsvfsp->vfs_fs); 1113 } 1114 1115 /* 1116 * At least everything *currently* dirty goes out. 1117 */ 1118 1119 if ((error = ufs_flush(vfsp)) != 0 && !ULOCKFS_IS_HLOCK(ulp) && 1120 !ULOCKFS_IS_ELOCK(ulp)) 1121 goto errout; 1122 1123 /* 1124 * thaw file system and wakeup pended processes 1125 */ 1126 if (error = ufs_thaw(vfsp, ufsvfsp, ulp)) 1127 if (!ULOCKFS_IS_HLOCK(ulp) && !ULOCKFS_IS_ELOCK(ulp)) 1128 goto errout; 1129 1130 /* 1131 * reset modified flag if not already write locked 1132 */ 1133 if (!LOCKFS_IS_WLOCK(&lfs)) 1134 ULOCKFS_CLR_MOD(ulp); 1135 1136 /* 1137 * idle the lock struct 1138 */ 1139 ULOCKFS_CLR_BUSY(ulp); 1140 /* update the ioctl copy */ 1141 LOCKFS_CLR_BUSY(&ulp->ul_lockfs); 1142 1143 /* 1144 * free current comment 1145 */ 1146 if (lfs.lf_comment && lfs.lf_comlen != 0) { 1147 kmem_free(lfs.lf_comment, lfs.lf_comlen); 1148 lfs.lf_comment = NULL; 1149 lfs.lf_comlen = 0; 1150 } 1151 1152 /* do error lock cleanup */ 1153 if (errlck == UN_ERRLCK) 1154 ufsfx_unlockfs(ufsvfsp); 1155 1156 else if (errlck == RE_ERRLCK) 1157 ufsfx_lockfs(ufsvfsp); 1158 1159 /* don't allow error lock from user to invoke panic */ 1160 else if (from_user && errlck == SET_ERRLCK && 1161 !(ufsvfsp->vfs_fsfx.fx_flags & (UFSMNT_ONERROR_PANIC >> 4))) 1162 (void) ufs_fault(ufsvfsp->vfs_root, 1163 ulp->ul_lockfs.lf_comment && ulp->ul_lockfs.lf_comlen > 0 ? 1164 ulp->ul_lockfs.lf_comment: "user-applied error lock"); 1165 1166 atomic_dec_ulong(&ufs_quiesce_pend); 1167 mutex_exit(&ulp->ul_lock); 1168 vfs_unlock(vfsp); 1169 1170 if (ULOCKFS_IS_HLOCK(&ufsvfsp->vfs_ulockfs)) 1171 poll_events |= POLLERR; 1172 1173 pollwakeup(&ufs_pollhd, poll_events); 1174 1175 /* 1176 * Allow both the delete thread and the reclaim thread to 1177 * continue. 1178 */ 1179 ufs_thread_continue(&ufsvfsp->vfs_delete); 1180 ufs_thread_continue(&ufsvfsp->vfs_reclaim); 1181 1182 return (0); 1183 1184 errout: 1185 /* 1186 * Lock failed. Reset the old lock in ufsvfs if not hard locked. 1187 */ 1188 if (!LOCKFS_IS_HLOCK(&ulp->ul_lockfs)) { 1189 bcopy(&lfs, &ulp->ul_lockfs, sizeof (struct lockfs)); 1190 ulp->ul_fs_lock = (1 << lfs.lf_lock); 1191 } 1192 1193 /* 1194 * Don't call ufs_thaw() when there's a signal during 1195 * ufs quiesce operation as it can lead to deadlock 1196 * with getpage. 1197 */ 1198 if (signal == 0) 1199 (void) ufs_thaw(vfsp, ufsvfsp, ulp); 1200 1201 ULOCKFS_CLR_BUSY(ulp); 1202 LOCKFS_CLR_BUSY(&ulp->ul_lockfs); 1203 1204 errexit: 1205 atomic_dec_ulong(&ufs_quiesce_pend); 1206 mutex_exit(&ulp->ul_lock); 1207 vfs_unlock(vfsp); 1208 1209 /* 1210 * Allow both the delete thread and the reclaim thread to 1211 * continue. 1212 */ 1213 ufs_thread_continue(&ufsvfsp->vfs_delete); 1214 ufs_thread_continue(&ufsvfsp->vfs_reclaim); 1215 1216 return (error); 1217 } 1218 1219 /* 1220 * fiolfss 1221 * return the current file system locking state info 1222 */ 1223 int 1224 ufs_fiolfss(struct vnode *vp, struct lockfs *lockfsp) 1225 { 1226 struct ulockfs *ulp; 1227 1228 if (!vp || !vp->v_vfsp || !VTOI(vp)) 1229 return (EINVAL); 1230 1231 /* file system has been forcibly unmounted */ 1232 if (VTOI(vp)->i_ufsvfs == NULL) 1233 return (EIO); 1234 1235 ulp = VTOUL(vp); 1236 1237 if (ULOCKFS_IS_HLOCK(ulp)) { 1238 *lockfsp = ulp->ul_lockfs; /* structure assignment */ 1239 return (0); 1240 } 1241 1242 mutex_enter(&ulp->ul_lock); 1243 1244 *lockfsp = ulp->ul_lockfs; /* structure assignment */ 1245 1246 if (ULOCKFS_IS_MOD(ulp)) 1247 lockfsp->lf_flags |= LOCKFS_MOD; 1248 1249 mutex_exit(&ulp->ul_lock); 1250 1251 return (0); 1252 } 1253 1254 /* 1255 * ufs_check_lockfs 1256 * check whether a ufs_vnops conflicts with the file system lock 1257 */ 1258 int 1259 ufs_check_lockfs(struct ufsvfs *ufsvfsp, struct ulockfs *ulp, ulong_t mask) 1260 { 1261 k_sigset_t smask; 1262 int sig, slock; 1263 1264 ASSERT(MUTEX_HELD(&ulp->ul_lock)); 1265 1266 while (ulp->ul_fs_lock & mask) { 1267 slock = (int)ULOCKFS_IS_SLOCK(ulp); 1268 if ((curthread->t_flag & T_DONTPEND) && !slock) { 1269 curthread->t_flag |= T_WOULDBLOCK; 1270 return (EAGAIN); 1271 } 1272 curthread->t_flag &= ~T_WOULDBLOCK; 1273 1274 /* 1275 * In the case of an onerr umount of the fs, threads could 1276 * have blocked before coming into ufs_check_lockfs and 1277 * need to check for the special case of ELOCK and 1278 * vfs_dontblock being set which would indicate that the fs 1279 * is on its way out and will not return therefore making 1280 * EIO the appropriate response. 1281 */ 1282 if (ULOCKFS_IS_HLOCK(ulp) || 1283 (ULOCKFS_IS_ELOCK(ulp) && ufsvfsp->vfs_dontblock)) 1284 return (EIO); 1285 1286 /* 1287 * wait for lock status to change 1288 */ 1289 if (slock || ufsvfsp->vfs_nointr) { 1290 cv_wait(&ulp->ul_cv, &ulp->ul_lock); 1291 } else { 1292 sigintr(&smask, 1); 1293 sig = cv_wait_sig(&ulp->ul_cv, &ulp->ul_lock); 1294 sigunintr(&smask); 1295 if ((!sig && (ulp->ul_fs_lock & mask)) || 1296 ufsvfsp->vfs_dontblock) 1297 return (EINTR); 1298 } 1299 } 1300 1301 if (mask & ULOCKFS_FWLOCK) { 1302 atomic_inc_ulong(&ulp->ul_falloc_cnt); 1303 ULOCKFS_SET_FALLOC(ulp); 1304 } else { 1305 atomic_inc_ulong(&ulp->ul_vnops_cnt); 1306 } 1307 1308 return (0); 1309 } 1310 1311 /* 1312 * Check whether we came across the handcrafted lockfs protocol path. We can't 1313 * simply check for T_DONTBLOCK here as one would assume since this can also 1314 * falsely catch recursive VOP's going to a different filesystem, instead we 1315 * check if we already hold the ulockfs->ul_lock mutex. 1316 */ 1317 static int 1318 ufs_lockfs_is_under_rawlockfs(struct ulockfs *ulp) 1319 { 1320 return ((mutex_owner(&ulp->ul_lock) != curthread) ? 0 : 1); 1321 } 1322 1323 /* 1324 * ufs_lockfs_begin - start the lockfs locking protocol 1325 */ 1326 int 1327 ufs_lockfs_begin(struct ufsvfs *ufsvfsp, struct ulockfs **ulpp, ulong_t mask) 1328 { 1329 int error; 1330 int rec_vop; 1331 ushort_t op_cnt_incremented = 0; 1332 ulong_t *ctr; 1333 struct ulockfs *ulp; 1334 ulockfs_info_t *ulockfs_info; 1335 ulockfs_info_t *ulockfs_info_free; 1336 ulockfs_info_t *ulockfs_info_temp; 1337 1338 /* 1339 * file system has been forcibly unmounted 1340 */ 1341 if (ufsvfsp == NULL) 1342 return (EIO); 1343 1344 *ulpp = ulp = &ufsvfsp->vfs_ulockfs; 1345 1346 /* 1347 * Do lockfs protocol 1348 */ 1349 ulockfs_info = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 1350 IS_REC_VOP(rec_vop, ulockfs_info, ulp, ulockfs_info_free); 1351 1352 /* 1353 * Detect recursive VOP call or handcrafted internal lockfs protocol 1354 * path and bail out in that case. 1355 */ 1356 if (rec_vop || ufs_lockfs_is_under_rawlockfs(ulp)) { 1357 *ulpp = NULL; 1358 return (0); 1359 } else { 1360 if (ulockfs_info_free == NULL) { 1361 if ((ulockfs_info_temp = (ulockfs_info_t *) 1362 kmem_zalloc(sizeof (ulockfs_info_t), 1363 KM_NOSLEEP)) == NULL) { 1364 *ulpp = NULL; 1365 return (ENOMEM); 1366 } 1367 } 1368 } 1369 1370 /* 1371 * First time VOP call 1372 * 1373 * Increment the ctr irrespective of the lockfs state. If the lockfs 1374 * state is not ULOCKFS_ULOCK, we can decrement it later. However, 1375 * before incrementing we need to check if there is a pending quiesce 1376 * request because if we have a continuous stream of ufs_lockfs_begin 1377 * requests pounding on a few cpu's then the ufs_quiesce thread might 1378 * never see the value of zero for ctr - a livelock kind of scenario. 1379 */ 1380 ctr = (mask & ULOCKFS_FWLOCK) ? 1381 &ulp->ul_falloc_cnt : &ulp->ul_vnops_cnt; 1382 if (!ULOCKFS_IS_SLOCK(ulp)) { 1383 atomic_inc_ulong(ctr); 1384 op_cnt_incremented++; 1385 } 1386 1387 /* 1388 * If the lockfs state (indicated by ul_fs_lock) is not just 1389 * ULOCKFS_ULOCK, then we will be routed through ufs_check_lockfs 1390 * where there is a check with an appropriate mask to selectively allow 1391 * operations permitted for that kind of lockfs state. 1392 * 1393 * Even these selective operations should not be allowed to go through 1394 * if a lockfs request is in progress because that could result in inode 1395 * modifications during a quiesce and could hence result in inode 1396 * reconciliation failures. ULOCKFS_SLOCK alone would not be sufficient, 1397 * so make use of ufs_quiesce_pend to disallow vnode operations when a 1398 * quiesce is in progress. 1399 */ 1400 if (!ULOCKFS_IS_JUSTULOCK(ulp) || ufs_quiesce_pend) { 1401 if (op_cnt_incremented) 1402 if (!atomic_dec_ulong_nv(ctr)) 1403 cv_broadcast(&ulp->ul_cv); 1404 mutex_enter(&ulp->ul_lock); 1405 error = ufs_check_lockfs(ufsvfsp, ulp, mask); 1406 mutex_exit(&ulp->ul_lock); 1407 if (error) { 1408 if (ulockfs_info_free == NULL) 1409 kmem_free(ulockfs_info_temp, 1410 sizeof (ulockfs_info_t)); 1411 return (error); 1412 } 1413 } else { 1414 /* 1415 * This is the common case of file system in a unlocked state. 1416 * 1417 * If a file system is unlocked, we would expect the ctr to have 1418 * been incremented by now. But this will not be true when a 1419 * quiesce is winding up - SLOCK was set when we checked before 1420 * incrementing the ctr, but by the time we checked for 1421 * ULOCKFS_IS_JUSTULOCK, the quiesce thread was gone. It is okay 1422 * to take ul_lock and go through the slow path in this uncommon 1423 * case. 1424 */ 1425 if (op_cnt_incremented == 0) { 1426 mutex_enter(&ulp->ul_lock); 1427 error = ufs_check_lockfs(ufsvfsp, ulp, mask); 1428 if (error) { 1429 mutex_exit(&ulp->ul_lock); 1430 if (ulockfs_info_free == NULL) 1431 kmem_free(ulockfs_info_temp, 1432 sizeof (ulockfs_info_t)); 1433 return (error); 1434 } 1435 if (mask & ULOCKFS_FWLOCK) 1436 ULOCKFS_SET_FALLOC(ulp); 1437 mutex_exit(&ulp->ul_lock); 1438 } else if (mask & ULOCKFS_FWLOCK) { 1439 mutex_enter(&ulp->ul_lock); 1440 ULOCKFS_SET_FALLOC(ulp); 1441 mutex_exit(&ulp->ul_lock); 1442 } 1443 } 1444 1445 if (ulockfs_info_free != NULL) { 1446 ulockfs_info_free->ulp = ulp; 1447 if (mask & ULOCKFS_FWLOCK) 1448 ulockfs_info_free->flags |= ULOCK_INFO_FALLOCATE; 1449 } else { 1450 ulockfs_info_temp->ulp = ulp; 1451 ulockfs_info_temp->next = ulockfs_info; 1452 if (mask & ULOCKFS_FWLOCK) 1453 ulockfs_info_temp->flags |= ULOCK_INFO_FALLOCATE; 1454 ASSERT(ufs_lockfs_key != 0); 1455 (void) tsd_set(ufs_lockfs_key, (void *)ulockfs_info_temp); 1456 } 1457 1458 curthread->t_flag |= T_DONTBLOCK; 1459 return (0); 1460 } 1461 1462 /* 1463 * Check whether we are returning from the top level VOP. 1464 */ 1465 static int 1466 ufs_lockfs_top_vop_return(ulockfs_info_t *head) 1467 { 1468 ulockfs_info_t *info; 1469 int result = 1; 1470 1471 for (info = head; info != NULL; info = info->next) { 1472 if (info->ulp != NULL) { 1473 result = 0; 1474 break; 1475 } 1476 } 1477 1478 return (result); 1479 } 1480 1481 /* 1482 * ufs_lockfs_end - terminate the lockfs locking protocol 1483 */ 1484 void 1485 ufs_lockfs_end(struct ulockfs *ulp) 1486 { 1487 ulockfs_info_t *info; 1488 ulockfs_info_t *head; 1489 1490 /* 1491 * end-of-VOP protocol 1492 */ 1493 if (ulp == NULL) 1494 return; 1495 1496 head = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 1497 SEARCH_ULOCKFSP(head, ulp, info); 1498 1499 /* 1500 * If we're called from a first level VOP, we have to have a 1501 * valid ulockfs record in the TSD. 1502 */ 1503 ASSERT(info != NULL); 1504 1505 /* 1506 * Invalidate the ulockfs record. 1507 */ 1508 info->ulp = NULL; 1509 1510 if (ufs_lockfs_top_vop_return(head)) 1511 curthread->t_flag &= ~T_DONTBLOCK; 1512 1513 /* fallocate thread */ 1514 if (ULOCKFS_IS_FALLOC(ulp) && info->flags & ULOCK_INFO_FALLOCATE) { 1515 /* Clear the thread's fallocate state */ 1516 info->flags &= ~ULOCK_INFO_FALLOCATE; 1517 if (!atomic_dec_ulong_nv(&ulp->ul_falloc_cnt)) { 1518 mutex_enter(&ulp->ul_lock); 1519 ULOCKFS_CLR_FALLOC(ulp); 1520 cv_broadcast(&ulp->ul_cv); 1521 mutex_exit(&ulp->ul_lock); 1522 } 1523 } else { /* normal thread */ 1524 if (!atomic_dec_ulong_nv(&ulp->ul_vnops_cnt)) 1525 cv_broadcast(&ulp->ul_cv); 1526 } 1527 } 1528 1529 /* 1530 * ufs_lockfs_trybegin - try to start the lockfs locking protocol without 1531 * blocking. 1532 */ 1533 int 1534 ufs_lockfs_trybegin(struct ufsvfs *ufsvfsp, struct ulockfs **ulpp, ulong_t mask) 1535 { 1536 int error = 0; 1537 int rec_vop; 1538 ushort_t op_cnt_incremented = 0; 1539 ulong_t *ctr; 1540 struct ulockfs *ulp; 1541 ulockfs_info_t *ulockfs_info; 1542 ulockfs_info_t *ulockfs_info_free; 1543 ulockfs_info_t *ulockfs_info_temp; 1544 1545 /* 1546 * file system has been forcibly unmounted 1547 */ 1548 if (ufsvfsp == NULL) 1549 return (EIO); 1550 1551 *ulpp = ulp = &ufsvfsp->vfs_ulockfs; 1552 1553 /* 1554 * Do lockfs protocol 1555 */ 1556 ulockfs_info = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 1557 IS_REC_VOP(rec_vop, ulockfs_info, ulp, ulockfs_info_free); 1558 1559 /* 1560 * Detect recursive VOP call or handcrafted internal lockfs protocol 1561 * path and bail out in that case. 1562 */ 1563 if (rec_vop || ufs_lockfs_is_under_rawlockfs(ulp)) { 1564 *ulpp = NULL; 1565 return (0); 1566 } else { 1567 if (ulockfs_info_free == NULL) { 1568 if ((ulockfs_info_temp = (ulockfs_info_t *) 1569 kmem_zalloc(sizeof (ulockfs_info_t), 1570 KM_NOSLEEP)) == NULL) { 1571 *ulpp = NULL; 1572 return (ENOMEM); 1573 } 1574 } 1575 } 1576 1577 /* 1578 * First time VOP call 1579 * 1580 * Increment the ctr irrespective of the lockfs state. If the lockfs 1581 * state is not ULOCKFS_ULOCK, we can decrement it later. However, 1582 * before incrementing we need to check if there is a pending quiesce 1583 * request because if we have a continuous stream of ufs_lockfs_begin 1584 * requests pounding on a few cpu's then the ufs_quiesce thread might 1585 * never see the value of zero for ctr - a livelock kind of scenario. 1586 */ 1587 ctr = (mask & ULOCKFS_FWLOCK) ? 1588 &ulp->ul_falloc_cnt : &ulp->ul_vnops_cnt; 1589 if (!ULOCKFS_IS_SLOCK(ulp)) { 1590 atomic_inc_ulong(ctr); 1591 op_cnt_incremented++; 1592 } 1593 1594 if (!ULOCKFS_IS_JUSTULOCK(ulp) || ufs_quiesce_pend) { 1595 /* 1596 * Non-blocking version of ufs_check_lockfs() code. 1597 * 1598 * If the file system is not hard locked or error locked 1599 * and if ulp->ul_fs_lock allows this operation, increment 1600 * the appropriate counter and proceed (For eg., In case the 1601 * file system is delete locked, a mmap can still go through). 1602 */ 1603 if (op_cnt_incremented) 1604 if (!atomic_dec_ulong_nv(ctr)) 1605 cv_broadcast(&ulp->ul_cv); 1606 mutex_enter(&ulp->ul_lock); 1607 if (ULOCKFS_IS_HLOCK(ulp) || 1608 (ULOCKFS_IS_ELOCK(ulp) && ufsvfsp->vfs_dontblock)) 1609 error = EIO; 1610 else if (ulp->ul_fs_lock & mask) 1611 error = EAGAIN; 1612 1613 if (error) { 1614 mutex_exit(&ulp->ul_lock); 1615 if (ulockfs_info_free == NULL) 1616 kmem_free(ulockfs_info_temp, 1617 sizeof (ulockfs_info_t)); 1618 return (error); 1619 } 1620 atomic_inc_ulong(ctr); 1621 if (mask & ULOCKFS_FWLOCK) 1622 ULOCKFS_SET_FALLOC(ulp); 1623 mutex_exit(&ulp->ul_lock); 1624 } else { 1625 /* 1626 * This is the common case of file system in a unlocked state. 1627 * 1628 * If a file system is unlocked, we would expect the ctr to have 1629 * been incremented by now. But this will not be true when a 1630 * quiesce is winding up - SLOCK was set when we checked before 1631 * incrementing the ctr, but by the time we checked for 1632 * ULOCKFS_IS_JUSTULOCK, the quiesce thread was gone. Take 1633 * ul_lock and go through the non-blocking version of 1634 * ufs_check_lockfs() code. 1635 */ 1636 if (op_cnt_incremented == 0) { 1637 mutex_enter(&ulp->ul_lock); 1638 if (ULOCKFS_IS_HLOCK(ulp) || 1639 (ULOCKFS_IS_ELOCK(ulp) && ufsvfsp->vfs_dontblock)) 1640 error = EIO; 1641 else if (ulp->ul_fs_lock & mask) 1642 error = EAGAIN; 1643 1644 if (error) { 1645 mutex_exit(&ulp->ul_lock); 1646 if (ulockfs_info_free == NULL) 1647 kmem_free(ulockfs_info_temp, 1648 sizeof (ulockfs_info_t)); 1649 return (error); 1650 } 1651 atomic_inc_ulong(ctr); 1652 if (mask & ULOCKFS_FWLOCK) 1653 ULOCKFS_SET_FALLOC(ulp); 1654 mutex_exit(&ulp->ul_lock); 1655 } else if (mask & ULOCKFS_FWLOCK) { 1656 mutex_enter(&ulp->ul_lock); 1657 ULOCKFS_SET_FALLOC(ulp); 1658 mutex_exit(&ulp->ul_lock); 1659 } 1660 } 1661 1662 if (ulockfs_info_free != NULL) { 1663 ulockfs_info_free->ulp = ulp; 1664 if (mask & ULOCKFS_FWLOCK) 1665 ulockfs_info_free->flags |= ULOCK_INFO_FALLOCATE; 1666 } else { 1667 ulockfs_info_temp->ulp = ulp; 1668 ulockfs_info_temp->next = ulockfs_info; 1669 if (mask & ULOCKFS_FWLOCK) 1670 ulockfs_info_temp->flags |= ULOCK_INFO_FALLOCATE; 1671 ASSERT(ufs_lockfs_key != 0); 1672 (void) tsd_set(ufs_lockfs_key, (void *)ulockfs_info_temp); 1673 } 1674 1675 curthread->t_flag |= T_DONTBLOCK; 1676 return (0); 1677 } 1678 1679 /* 1680 * specialized version of ufs_lockfs_begin() called by ufs_getpage(). 1681 */ 1682 int 1683 ufs_lockfs_begin_getpage( 1684 struct ufsvfs *ufsvfsp, 1685 struct ulockfs **ulpp, 1686 struct seg *seg, 1687 int read_access, 1688 uint_t *protp) 1689 { 1690 ulong_t mask; 1691 int error; 1692 int rec_vop; 1693 struct ulockfs *ulp; 1694 ulockfs_info_t *ulockfs_info; 1695 ulockfs_info_t *ulockfs_info_free; 1696 ulockfs_info_t *ulockfs_info_temp; 1697 1698 /* 1699 * file system has been forcibly unmounted 1700 */ 1701 if (ufsvfsp == NULL) 1702 return (EIO); 1703 1704 *ulpp = ulp = &ufsvfsp->vfs_ulockfs; 1705 1706 /* 1707 * Do lockfs protocol 1708 */ 1709 ulockfs_info = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 1710 IS_REC_VOP(rec_vop, ulockfs_info, ulp, ulockfs_info_free); 1711 1712 /* 1713 * Detect recursive VOP call or handcrafted internal lockfs protocol 1714 * path and bail out in that case. 1715 */ 1716 if (rec_vop || ufs_lockfs_is_under_rawlockfs(ulp)) { 1717 *ulpp = NULL; 1718 return (0); 1719 } else { 1720 if (ulockfs_info_free == NULL) { 1721 if ((ulockfs_info_temp = (ulockfs_info_t *) 1722 kmem_zalloc(sizeof (ulockfs_info_t), 1723 KM_NOSLEEP)) == NULL) { 1724 *ulpp = NULL; 1725 return (ENOMEM); 1726 } 1727 } 1728 } 1729 1730 /* 1731 * First time VOP call 1732 */ 1733 atomic_inc_ulong(&ulp->ul_vnops_cnt); 1734 if (!ULOCKFS_IS_JUSTULOCK(ulp) || ufs_quiesce_pend) { 1735 if (!atomic_dec_ulong_nv(&ulp->ul_vnops_cnt)) 1736 cv_broadcast(&ulp->ul_cv); 1737 mutex_enter(&ulp->ul_lock); 1738 if (seg->s_ops == &segvn_ops && 1739 ((struct segvn_data *)seg->s_data)->type != MAP_SHARED) { 1740 mask = (ulong_t)ULOCKFS_GETREAD_MASK; 1741 } else if (protp && read_access) { 1742 /* 1743 * Restrict the mapping to readonly. 1744 * Writes to this mapping will cause 1745 * another fault which will then 1746 * be suspended if fs is write locked 1747 */ 1748 *protp &= ~PROT_WRITE; 1749 mask = (ulong_t)ULOCKFS_GETREAD_MASK; 1750 } else 1751 mask = (ulong_t)ULOCKFS_GETWRITE_MASK; 1752 1753 /* 1754 * will sleep if this fs is locked against this VOP 1755 */ 1756 error = ufs_check_lockfs(ufsvfsp, ulp, mask); 1757 mutex_exit(&ulp->ul_lock); 1758 if (error) { 1759 if (ulockfs_info_free == NULL) 1760 kmem_free(ulockfs_info_temp, 1761 sizeof (ulockfs_info_t)); 1762 return (error); 1763 } 1764 } 1765 1766 if (ulockfs_info_free != NULL) { 1767 ulockfs_info_free->ulp = ulp; 1768 } else { 1769 ulockfs_info_temp->ulp = ulp; 1770 ulockfs_info_temp->next = ulockfs_info; 1771 ASSERT(ufs_lockfs_key != 0); 1772 (void) tsd_set(ufs_lockfs_key, (void *)ulockfs_info_temp); 1773 } 1774 1775 curthread->t_flag |= T_DONTBLOCK; 1776 return (0); 1777 } 1778 1779 void 1780 ufs_lockfs_tsd_destructor(void *head) 1781 { 1782 ulockfs_info_t *curr = (ulockfs_info_t *)head; 1783 ulockfs_info_t *temp; 1784 1785 for (; curr != NULL; ) { 1786 /* 1787 * The TSD destructor is being called when the thread exits 1788 * (via thread_exit()). At that time it must have cleaned up 1789 * all VOPs via ufs_lockfs_end() and there must not be a 1790 * valid ulockfs record exist while a thread is exiting. 1791 */ 1792 temp = curr; 1793 curr = curr->next; 1794 ASSERT(temp->ulp == NULL); 1795 kmem_free(temp, sizeof (ulockfs_info_t)); 1796 } 1797 } 1798