17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 57c478bd9Sstevel@tonic-gate * Common Development and Distribution License, Version 1.0 only 67c478bd9Sstevel@tonic-gate * (the "License"). You may not use this file except in compliance 77c478bd9Sstevel@tonic-gate * with the License. 87c478bd9Sstevel@tonic-gate * 97c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 107c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 117c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 127c478bd9Sstevel@tonic-gate * and limitations under the License. 137c478bd9Sstevel@tonic-gate * 147c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 157c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 167c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 177c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 187c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 197c478bd9Sstevel@tonic-gate * 207c478bd9Sstevel@tonic-gate * CDDL HEADER END 217c478bd9Sstevel@tonic-gate */ 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate #include <sys/types.h> 307c478bd9Sstevel@tonic-gate #include <sys/t_lock.h> 317c478bd9Sstevel@tonic-gate #include <sys/param.h> 327c478bd9Sstevel@tonic-gate #include <sys/time.h> 337c478bd9Sstevel@tonic-gate #include <sys/systm.h> 347c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 357c478bd9Sstevel@tonic-gate #include <sys/resource.h> 367c478bd9Sstevel@tonic-gate #include <sys/signal.h> 377c478bd9Sstevel@tonic-gate #include <sys/cred.h> 387c478bd9Sstevel@tonic-gate #include <sys/user.h> 397c478bd9Sstevel@tonic-gate #include <sys/buf.h> 407c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 417c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 427c478bd9Sstevel@tonic-gate #include <sys/proc.h> 437c478bd9Sstevel@tonic-gate #include <sys/disp.h> 447c478bd9Sstevel@tonic-gate #include <sys/file.h> 457c478bd9Sstevel@tonic-gate #include <sys/fcntl.h> 467c478bd9Sstevel@tonic-gate #include <sys/flock.h> 47bc69f433Saguzovsk #include <sys/atomic.h> 487c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 497c478bd9Sstevel@tonic-gate #include <sys/uio.h> 507c478bd9Sstevel@tonic-gate #include <sys/conf.h> 517c478bd9Sstevel@tonic-gate #include <sys/mman.h> 527c478bd9Sstevel@tonic-gate #include <sys/pathname.h> 537c478bd9Sstevel@tonic-gate #include <sys/debug.h> 547c478bd9Sstevel@tonic-gate #include <sys/vmmeter.h> 557c478bd9Sstevel@tonic-gate #include <sys/vmsystm.h> 567c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 577c478bd9Sstevel@tonic-gate #include <sys/vtrace.h> 587c478bd9Sstevel@tonic-gate #include <sys/acct.h> 597c478bd9Sstevel@tonic-gate #include <sys/dnlc.h> 607c478bd9Sstevel@tonic-gate #include <sys/swap.h> 617c478bd9Sstevel@tonic-gate 627c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_fs.h> 637c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_inode.h> 647c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_fsdir.h> 657c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_trans.h> 667c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_panic.h> 677c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_mount.h> 687c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_bio.h> 697c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_log.h> 707c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_quota.h> 717c478bd9Sstevel@tonic-gate #include <sys/dirent.h> /* must be AFTER <sys/fs/fsdir.h>! */ 727c478bd9Sstevel@tonic-gate #include <sys/errno.h> 737c478bd9Sstevel@tonic-gate #include <sys/sysinfo.h> 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate #include <vm/hat.h> 767c478bd9Sstevel@tonic-gate #include <vm/pvn.h> 777c478bd9Sstevel@tonic-gate #include <vm/as.h> 787c478bd9Sstevel@tonic-gate #include <vm/seg.h> 797c478bd9Sstevel@tonic-gate #include <vm/seg_map.h> 807c478bd9Sstevel@tonic-gate #include <vm/seg_vn.h> 817c478bd9Sstevel@tonic-gate #include <vm/rm.h> 827c478bd9Sstevel@tonic-gate #include <vm/anon.h> 837c478bd9Sstevel@tonic-gate #include <sys/swap.h> 847c478bd9Sstevel@tonic-gate #include <sys/dnlc.h> 857c478bd9Sstevel@tonic-gate 867c478bd9Sstevel@tonic-gate extern struct vnode *common_specvp(struct vnode *vp); 877c478bd9Sstevel@tonic-gate 887c478bd9Sstevel@tonic-gate /* error lock status */ 897c478bd9Sstevel@tonic-gate #define UN_ERRLCK (-1) 907c478bd9Sstevel@tonic-gate #define SET_ERRLCK 1 917c478bd9Sstevel@tonic-gate #define RE_ERRLCK 2 927c478bd9Sstevel@tonic-gate #define NO_ERRLCK 0 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate /* 957c478bd9Sstevel@tonic-gate * Index to be used in TSD for storing lockfs data 967c478bd9Sstevel@tonic-gate */ 977c478bd9Sstevel@tonic-gate uint_t ufs_lockfs_key; 987c478bd9Sstevel@tonic-gate 997c478bd9Sstevel@tonic-gate typedef struct _ulockfs_info { 1007c478bd9Sstevel@tonic-gate struct _ulockfs_info *next; 1017c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 1027c478bd9Sstevel@tonic-gate } ulockfs_info_t; 1037c478bd9Sstevel@tonic-gate 1047c478bd9Sstevel@tonic-gate /* 1057c478bd9Sstevel@tonic-gate * Check in TSD that whether we are already doing any VOP on this filesystem 1067c478bd9Sstevel@tonic-gate */ 1077c478bd9Sstevel@tonic-gate #define IS_REC_VOP(found, head, ulp, free) \ 1087c478bd9Sstevel@tonic-gate { \ 1097c478bd9Sstevel@tonic-gate ulockfs_info_t *_curr; \ 1107c478bd9Sstevel@tonic-gate \ 1117c478bd9Sstevel@tonic-gate for (found = 0, free = NULL, _curr = head; \ 1127c478bd9Sstevel@tonic-gate _curr != NULL; _curr = _curr->next) { \ 1137c478bd9Sstevel@tonic-gate if ((free == NULL) && \ 1147c478bd9Sstevel@tonic-gate (_curr->ulp == NULL)) \ 1157c478bd9Sstevel@tonic-gate free = _curr; \ 1167c478bd9Sstevel@tonic-gate if (_curr->ulp == ulp) { \ 1177c478bd9Sstevel@tonic-gate found = 1; \ 1187c478bd9Sstevel@tonic-gate break; \ 1197c478bd9Sstevel@tonic-gate } \ 1207c478bd9Sstevel@tonic-gate } \ 1217c478bd9Sstevel@tonic-gate } 1227c478bd9Sstevel@tonic-gate 1237c478bd9Sstevel@tonic-gate /* 1247c478bd9Sstevel@tonic-gate * Get the lockfs data from TSD so that lockfs handles the recursive VOP 1257c478bd9Sstevel@tonic-gate * properly 1267c478bd9Sstevel@tonic-gate */ 1277c478bd9Sstevel@tonic-gate #define SEARCH_ULOCKFSP(head, ulp, info) \ 1287c478bd9Sstevel@tonic-gate { \ 1297c478bd9Sstevel@tonic-gate ulockfs_info_t *_curr; \ 1307c478bd9Sstevel@tonic-gate \ 1317c478bd9Sstevel@tonic-gate for (_curr = head; _curr != NULL; \ 1327c478bd9Sstevel@tonic-gate _curr = _curr->next) { \ 1337c478bd9Sstevel@tonic-gate if (_curr->ulp == ulp) { \ 1347c478bd9Sstevel@tonic-gate break; \ 1357c478bd9Sstevel@tonic-gate } \ 1367c478bd9Sstevel@tonic-gate } \ 1377c478bd9Sstevel@tonic-gate \ 1387c478bd9Sstevel@tonic-gate info = _curr; \ 1397c478bd9Sstevel@tonic-gate } 1407c478bd9Sstevel@tonic-gate 1417c478bd9Sstevel@tonic-gate /* 1427c478bd9Sstevel@tonic-gate * Validate lockfs request 1437c478bd9Sstevel@tonic-gate */ 1447c478bd9Sstevel@tonic-gate static int 1457c478bd9Sstevel@tonic-gate ufs_getlfd( 1467c478bd9Sstevel@tonic-gate struct lockfs *lockfsp, /* new lock request */ 1477c478bd9Sstevel@tonic-gate struct lockfs *ul_lockfsp) /* old lock state */ 1487c478bd9Sstevel@tonic-gate { 1497c478bd9Sstevel@tonic-gate int error = 0; 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate /* 1527c478bd9Sstevel@tonic-gate * no input flags defined 1537c478bd9Sstevel@tonic-gate */ 1547c478bd9Sstevel@tonic-gate if (lockfsp->lf_flags != 0) { 1557c478bd9Sstevel@tonic-gate error = EINVAL; 1567c478bd9Sstevel@tonic-gate goto errout; 1577c478bd9Sstevel@tonic-gate } 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate /* 1607c478bd9Sstevel@tonic-gate * check key 1617c478bd9Sstevel@tonic-gate */ 1627c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_ULOCK(ul_lockfsp)) 1637c478bd9Sstevel@tonic-gate if (lockfsp->lf_key != ul_lockfsp->lf_key) { 1647c478bd9Sstevel@tonic-gate error = EINVAL; 1657c478bd9Sstevel@tonic-gate goto errout; 1667c478bd9Sstevel@tonic-gate } 1677c478bd9Sstevel@tonic-gate 1687c478bd9Sstevel@tonic-gate lockfsp->lf_key = ul_lockfsp->lf_key + 1; 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate errout: 1717c478bd9Sstevel@tonic-gate return (error); 1727c478bd9Sstevel@tonic-gate } 1737c478bd9Sstevel@tonic-gate 1747c478bd9Sstevel@tonic-gate /* 1757c478bd9Sstevel@tonic-gate * ufs_checkaccton 1767c478bd9Sstevel@tonic-gate * check if accounting is turned on on this fs 1777c478bd9Sstevel@tonic-gate */ 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate int 1807c478bd9Sstevel@tonic-gate ufs_checkaccton(struct vnode *vp) 1817c478bd9Sstevel@tonic-gate { 1827c478bd9Sstevel@tonic-gate if (acct_fs_in_use(vp)) 1837c478bd9Sstevel@tonic-gate return (EDEADLK); 1847c478bd9Sstevel@tonic-gate return (0); 1857c478bd9Sstevel@tonic-gate } 1867c478bd9Sstevel@tonic-gate 1877c478bd9Sstevel@tonic-gate /* 1887c478bd9Sstevel@tonic-gate * ufs_checkswapon 1897c478bd9Sstevel@tonic-gate * check if local swapping is to file on this fs 1907c478bd9Sstevel@tonic-gate */ 1917c478bd9Sstevel@tonic-gate int 1927c478bd9Sstevel@tonic-gate ufs_checkswapon(struct vnode *vp) 1937c478bd9Sstevel@tonic-gate { 1947c478bd9Sstevel@tonic-gate struct swapinfo *sip; 1957c478bd9Sstevel@tonic-gate 1967c478bd9Sstevel@tonic-gate mutex_enter(&swapinfo_lock); 1977c478bd9Sstevel@tonic-gate for (sip = swapinfo; sip; sip = sip->si_next) 1987c478bd9Sstevel@tonic-gate if (sip->si_vp->v_vfsp == vp->v_vfsp) { 1997c478bd9Sstevel@tonic-gate mutex_exit(&swapinfo_lock); 2007c478bd9Sstevel@tonic-gate return (EDEADLK); 2017c478bd9Sstevel@tonic-gate } 2027c478bd9Sstevel@tonic-gate mutex_exit(&swapinfo_lock); 2037c478bd9Sstevel@tonic-gate return (0); 2047c478bd9Sstevel@tonic-gate } 2057c478bd9Sstevel@tonic-gate 2067c478bd9Sstevel@tonic-gate /* 2077c478bd9Sstevel@tonic-gate * ufs_freeze 2087c478bd9Sstevel@tonic-gate * pend future accesses for current lock and desired lock 2097c478bd9Sstevel@tonic-gate */ 2107c478bd9Sstevel@tonic-gate void 2117c478bd9Sstevel@tonic-gate ufs_freeze(struct ulockfs *ulp, struct lockfs *lockfsp) 2127c478bd9Sstevel@tonic-gate { 2137c478bd9Sstevel@tonic-gate /* 2147c478bd9Sstevel@tonic-gate * set to new lock type 2157c478bd9Sstevel@tonic-gate */ 2167c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_lock = lockfsp->lf_lock; 2177c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_key = lockfsp->lf_key; 2187c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comlen = lockfsp->lf_comlen; 2197c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comment = lockfsp->lf_comment; 2207c478bd9Sstevel@tonic-gate 2217c478bd9Sstevel@tonic-gate ulp->ul_fs_lock = (1 << ulp->ul_lockfs.lf_lock); 2227c478bd9Sstevel@tonic-gate } 2237c478bd9Sstevel@tonic-gate 224bc69f433Saguzovsk /* 225bc69f433Saguzovsk * All callers of ufs_quiesce() atomically increment ufs_quiesce_pend before 226bc69f433Saguzovsk * starting ufs_quiesce() protocol and decrement it only when a file system no 227bc69f433Saguzovsk * longer has to be in quiescent state. This allows ufs_pageio() to detect 228bc69f433Saguzovsk * that another thread wants to quiesce a file system. See more comments in 229bc69f433Saguzovsk * ufs_pageio(). 230bc69f433Saguzovsk */ 231bc69f433Saguzovsk ulong_t ufs_quiesce_pend = 0; 232bc69f433Saguzovsk 2337c478bd9Sstevel@tonic-gate /* 2347c478bd9Sstevel@tonic-gate * ufs_quiesce 2357c478bd9Sstevel@tonic-gate * wait for outstanding accesses to finish 2367c478bd9Sstevel@tonic-gate */ 2377c478bd9Sstevel@tonic-gate int 2387c478bd9Sstevel@tonic-gate ufs_quiesce(struct ulockfs *ulp) 2397c478bd9Sstevel@tonic-gate { 2407c478bd9Sstevel@tonic-gate int error = 0; 2417c478bd9Sstevel@tonic-gate 2427c478bd9Sstevel@tonic-gate /* 2437c478bd9Sstevel@tonic-gate * Set a softlock to suspend future ufs_vnops so that 2447c478bd9Sstevel@tonic-gate * this lockfs request will not be starved 2457c478bd9Sstevel@tonic-gate */ 2467c478bd9Sstevel@tonic-gate ULOCKFS_SET_SLOCK(ulp); 247bc69f433Saguzovsk ASSERT(ufs_quiesce_pend); 2487c478bd9Sstevel@tonic-gate 2497c478bd9Sstevel@tonic-gate /* check if there is any outstanding ufs vnodeops calls */ 2507c478bd9Sstevel@tonic-gate while (ulp->ul_vnops_cnt) 251bc69f433Saguzovsk /* 252bc69f433Saguzovsk * use timed version of cv_wait_sig() to make sure we don't 253bc69f433Saguzovsk * miss a wake up call from ufs_pageio() when it doesn't use 254bc69f433Saguzovsk * ul_lock. 255bc69f433Saguzovsk */ 256bc69f433Saguzovsk if (!cv_timedwait_sig(&ulp->ul_cv, &ulp->ul_lock, lbolt + hz)) { 2577c478bd9Sstevel@tonic-gate error = EINTR; 2587c478bd9Sstevel@tonic-gate goto out; 2597c478bd9Sstevel@tonic-gate } 2607c478bd9Sstevel@tonic-gate 2617c478bd9Sstevel@tonic-gate out: 2627c478bd9Sstevel@tonic-gate /* 2637c478bd9Sstevel@tonic-gate * unlock the soft lock 2647c478bd9Sstevel@tonic-gate */ 2657c478bd9Sstevel@tonic-gate ULOCKFS_CLR_SLOCK(ulp); 2667c478bd9Sstevel@tonic-gate 2677c478bd9Sstevel@tonic-gate return (error); 2687c478bd9Sstevel@tonic-gate } 2697c478bd9Sstevel@tonic-gate /* 2707c478bd9Sstevel@tonic-gate * ufs_flush_inode 2717c478bd9Sstevel@tonic-gate */ 2727c478bd9Sstevel@tonic-gate int 2737c478bd9Sstevel@tonic-gate ufs_flush_inode(struct inode *ip, void *arg) 2747c478bd9Sstevel@tonic-gate { 2757c478bd9Sstevel@tonic-gate int error; 2767c478bd9Sstevel@tonic-gate int saverror = 0; 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate /* 2797c478bd9Sstevel@tonic-gate * wrong file system; keep looking 2807c478bd9Sstevel@tonic-gate */ 2817c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 2827c478bd9Sstevel@tonic-gate return (0); 2837c478bd9Sstevel@tonic-gate 2847c478bd9Sstevel@tonic-gate /* 2857c478bd9Sstevel@tonic-gate * asynchronously push all the dirty pages 2867c478bd9Sstevel@tonic-gate */ 2877c478bd9Sstevel@tonic-gate if (((error = TRANS_SYNCIP(ip, B_ASYNC, 0, TOP_SYNCIP_FLUSHI)) != 0) && 2887c478bd9Sstevel@tonic-gate (error != EAGAIN)) 2897c478bd9Sstevel@tonic-gate saverror = error; 2907c478bd9Sstevel@tonic-gate /* 2917c478bd9Sstevel@tonic-gate * wait for io and discard all mappings 2927c478bd9Sstevel@tonic-gate */ 2937c478bd9Sstevel@tonic-gate if (error = TRANS_SYNCIP(ip, B_INVAL, 0, TOP_SYNCIP_FLUSHI)) 2947c478bd9Sstevel@tonic-gate saverror = error; 2957c478bd9Sstevel@tonic-gate 2967c478bd9Sstevel@tonic-gate if (ITOV(ip)->v_type == VDIR) { 2977c478bd9Sstevel@tonic-gate dnlc_dir_purge(&ip->i_danchor); 2987c478bd9Sstevel@tonic-gate } 2997c478bd9Sstevel@tonic-gate 3007c478bd9Sstevel@tonic-gate return (saverror); 3017c478bd9Sstevel@tonic-gate } 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate /* 3047c478bd9Sstevel@tonic-gate * ufs_flush 3057c478bd9Sstevel@tonic-gate * Flush everything that is currently dirty; this includes invalidating 3067c478bd9Sstevel@tonic-gate * any mappings. 3077c478bd9Sstevel@tonic-gate */ 3087c478bd9Sstevel@tonic-gate int 3097c478bd9Sstevel@tonic-gate ufs_flush(struct vfs *vfsp) 3107c478bd9Sstevel@tonic-gate { 3117c478bd9Sstevel@tonic-gate int error; 3127c478bd9Sstevel@tonic-gate int saverror = 0; 3137c478bd9Sstevel@tonic-gate struct ufsvfs *ufsvfsp = (struct ufsvfs *)vfsp->vfs_data; 3147c478bd9Sstevel@tonic-gate struct fs *fs = ufsvfsp->vfs_fs; 3157c478bd9Sstevel@tonic-gate 3167c478bd9Sstevel@tonic-gate ASSERT(vfs_lock_held(vfsp)); 3177c478bd9Sstevel@tonic-gate 3187c478bd9Sstevel@tonic-gate /* 3197c478bd9Sstevel@tonic-gate * purge dnlc 3207c478bd9Sstevel@tonic-gate */ 3217c478bd9Sstevel@tonic-gate (void) dnlc_purge_vfsp(vfsp, 0); 3227c478bd9Sstevel@tonic-gate 3237c478bd9Sstevel@tonic-gate /* 3247c478bd9Sstevel@tonic-gate * drain the delete and idle threads 3257c478bd9Sstevel@tonic-gate */ 3267c478bd9Sstevel@tonic-gate ufs_delete_drain(vfsp, 0, 0); 3277c478bd9Sstevel@tonic-gate ufs_idle_drain(vfsp); 3287c478bd9Sstevel@tonic-gate 3297c478bd9Sstevel@tonic-gate /* 3307c478bd9Sstevel@tonic-gate * flush and invalidate quota records 3317c478bd9Sstevel@tonic-gate */ 3327c478bd9Sstevel@tonic-gate (void) qsync(ufsvfsp); 3337c478bd9Sstevel@tonic-gate 3347c478bd9Sstevel@tonic-gate /* 3357c478bd9Sstevel@tonic-gate * flush w/invalidate the inodes for vfsp 3367c478bd9Sstevel@tonic-gate */ 3377c478bd9Sstevel@tonic-gate if (error = ufs_scan_inodes(0, ufs_flush_inode, ufsvfsp, ufsvfsp)) 3387c478bd9Sstevel@tonic-gate saverror = error; 3397c478bd9Sstevel@tonic-gate 3407c478bd9Sstevel@tonic-gate /* 3417c478bd9Sstevel@tonic-gate * synchronously flush superblock and summary info 3427c478bd9Sstevel@tonic-gate */ 3437c478bd9Sstevel@tonic-gate if (fs->fs_ronly == 0 && fs->fs_fmod) { 3447c478bd9Sstevel@tonic-gate fs->fs_fmod = 0; 3457c478bd9Sstevel@tonic-gate TRANS_SBUPDATE(ufsvfsp, vfsp, TOP_SBUPDATE_FLUSH); 3467c478bd9Sstevel@tonic-gate } 3477c478bd9Sstevel@tonic-gate /* 3487c478bd9Sstevel@tonic-gate * flush w/invalidate block device pages and buf cache 3497c478bd9Sstevel@tonic-gate */ 3507c478bd9Sstevel@tonic-gate if ((error = VOP_PUTPAGE(common_specvp(ufsvfsp->vfs_devvp), 3517c478bd9Sstevel@tonic-gate (offset_t)0, 0, B_INVAL, CRED())) > 0) 3527c478bd9Sstevel@tonic-gate saverror = error; 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate (void) bflush((dev_t)vfsp->vfs_dev); 3557c478bd9Sstevel@tonic-gate (void) bfinval((dev_t)vfsp->vfs_dev, 0); 3567c478bd9Sstevel@tonic-gate 3577c478bd9Sstevel@tonic-gate /* 3587c478bd9Sstevel@tonic-gate * drain the delete and idle threads again 3597c478bd9Sstevel@tonic-gate */ 3607c478bd9Sstevel@tonic-gate ufs_delete_drain(vfsp, 0, 0); 3617c478bd9Sstevel@tonic-gate ufs_idle_drain(vfsp); 3627c478bd9Sstevel@tonic-gate 3637c478bd9Sstevel@tonic-gate /* 3647c478bd9Sstevel@tonic-gate * play with the clean flag 3657c478bd9Sstevel@tonic-gate */ 3667c478bd9Sstevel@tonic-gate if (saverror == 0) 3677c478bd9Sstevel@tonic-gate ufs_checkclean(vfsp); 3687c478bd9Sstevel@tonic-gate 3697c478bd9Sstevel@tonic-gate /* 370*14c932c0Sbatschul * Flush any outstanding transactions and roll the log 371*14c932c0Sbatschul * only if we are supposed to do, i.e. LDL_NOROLL not set. 372*14c932c0Sbatschul * We can not simply check for fs_ronly here since fsck also may 373*14c932c0Sbatschul * use this code to roll the log on a read-only filesystem, e.g. 374*14c932c0Sbatschul * root during early stages of boot, if other then a sanity check is 375*14c932c0Sbatschul * done, it will clear LDL_NOROLL before. 376*14c932c0Sbatschul * In addition we assert that the deltamap does not contain any deltas 377*14c932c0Sbatschul * in case LDL_NOROLL is set since this is not supposed to happen. 3787c478bd9Sstevel@tonic-gate */ 3797c478bd9Sstevel@tonic-gate if (TRANS_ISTRANS(ufsvfsp)) { 380*14c932c0Sbatschul ml_unit_t *ul = ufsvfsp->vfs_log; 381*14c932c0Sbatschul mt_map_t *mtm = ul->un_deltamap; 382*14c932c0Sbatschul 383*14c932c0Sbatschul if (ul->un_flags & LDL_NOROLL) { 384*14c932c0Sbatschul ASSERT(mtm->mtm_nme == 0); 385*14c932c0Sbatschul } else { 386*14c932c0Sbatschul curthread->t_flag |= T_DONTBLOCK; 387*14c932c0Sbatschul TRANS_BEGIN_SYNC(ufsvfsp, TOP_COMMIT_FLUSH, 388*14c932c0Sbatschul TOP_COMMIT_SIZE, error); 389*14c932c0Sbatschul if (!error) { 390*14c932c0Sbatschul TRANS_END_SYNC(ufsvfsp, saverror, 391*14c932c0Sbatschul TOP_COMMIT_FLUSH, TOP_COMMIT_SIZE); 392*14c932c0Sbatschul } 393*14c932c0Sbatschul curthread->t_flag &= ~T_DONTBLOCK; 394*14c932c0Sbatschul logmap_roll_dev(ufsvfsp->vfs_log); 3957c478bd9Sstevel@tonic-gate } 3967c478bd9Sstevel@tonic-gate } 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate return (saverror); 3997c478bd9Sstevel@tonic-gate } 4007c478bd9Sstevel@tonic-gate 4017c478bd9Sstevel@tonic-gate /* 4027c478bd9Sstevel@tonic-gate * ufs_thaw_wlock 4037c478bd9Sstevel@tonic-gate * special processing when thawing down to wlock 4047c478bd9Sstevel@tonic-gate */ 4057c478bd9Sstevel@tonic-gate static int 4067c478bd9Sstevel@tonic-gate ufs_thaw_wlock(struct inode *ip, void *arg) 4077c478bd9Sstevel@tonic-gate { 4087c478bd9Sstevel@tonic-gate /* 4097c478bd9Sstevel@tonic-gate * wrong file system; keep looking 4107c478bd9Sstevel@tonic-gate */ 4117c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 4127c478bd9Sstevel@tonic-gate return (0); 4137c478bd9Sstevel@tonic-gate 4147c478bd9Sstevel@tonic-gate /* 4157c478bd9Sstevel@tonic-gate * iupdat refuses to clear flags if the fs is read only. The fs 4167c478bd9Sstevel@tonic-gate * may become read/write during the lock and we wouldn't want 4177c478bd9Sstevel@tonic-gate * these inodes being written to disk. So clear the flags. 4187c478bd9Sstevel@tonic-gate */ 4197c478bd9Sstevel@tonic-gate rw_enter(&ip->i_contents, RW_WRITER); 4207c478bd9Sstevel@tonic-gate ip->i_flag &= ~(IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG); 4217c478bd9Sstevel@tonic-gate rw_exit(&ip->i_contents); 4227c478bd9Sstevel@tonic-gate 4237c478bd9Sstevel@tonic-gate /* 4247c478bd9Sstevel@tonic-gate * pages are mlocked -- fail wlock 4257c478bd9Sstevel@tonic-gate */ 4267c478bd9Sstevel@tonic-gate if (ITOV(ip)->v_type != VCHR && vn_has_cached_data(ITOV(ip))) 4277c478bd9Sstevel@tonic-gate return (EBUSY); 4287c478bd9Sstevel@tonic-gate 4297c478bd9Sstevel@tonic-gate return (0); 4307c478bd9Sstevel@tonic-gate } 4317c478bd9Sstevel@tonic-gate 4327c478bd9Sstevel@tonic-gate /* 4337c478bd9Sstevel@tonic-gate * ufs_thaw_hlock 4347c478bd9Sstevel@tonic-gate * special processing when thawing down to hlock or elock 4357c478bd9Sstevel@tonic-gate */ 4367c478bd9Sstevel@tonic-gate static int 4377c478bd9Sstevel@tonic-gate ufs_thaw_hlock(struct inode *ip, void *arg) 4387c478bd9Sstevel@tonic-gate { 4397c478bd9Sstevel@tonic-gate struct vnode *vp = ITOV(ip); 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate /* 4427c478bd9Sstevel@tonic-gate * wrong file system; keep looking 4437c478bd9Sstevel@tonic-gate */ 4447c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 4457c478bd9Sstevel@tonic-gate return (0); 4467c478bd9Sstevel@tonic-gate 4477c478bd9Sstevel@tonic-gate /* 4487c478bd9Sstevel@tonic-gate * blow away all pages - even if they are mlocked 4497c478bd9Sstevel@tonic-gate */ 4507c478bd9Sstevel@tonic-gate do { 4517c478bd9Sstevel@tonic-gate (void) TRANS_SYNCIP(ip, B_INVAL | B_FORCE, 0, TOP_SYNCIP_HLOCK); 4527c478bd9Sstevel@tonic-gate } while ((vp->v_type != VCHR) && vn_has_cached_data(vp)); 4537c478bd9Sstevel@tonic-gate rw_enter(&ip->i_contents, RW_WRITER); 4547c478bd9Sstevel@tonic-gate ip->i_flag &= ~(IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG); 4557c478bd9Sstevel@tonic-gate rw_exit(&ip->i_contents); 4567c478bd9Sstevel@tonic-gate 4577c478bd9Sstevel@tonic-gate return (0); 4587c478bd9Sstevel@tonic-gate } 4597c478bd9Sstevel@tonic-gate 4607c478bd9Sstevel@tonic-gate /* 4617c478bd9Sstevel@tonic-gate * ufs_thaw 4627c478bd9Sstevel@tonic-gate * thaw file system lock down to current value 4637c478bd9Sstevel@tonic-gate */ 4647c478bd9Sstevel@tonic-gate int 4657c478bd9Sstevel@tonic-gate ufs_thaw(struct vfs *vfsp, struct ufsvfs *ufsvfsp, struct ulockfs *ulp) 4667c478bd9Sstevel@tonic-gate { 4677c478bd9Sstevel@tonic-gate int error = 0; 4687c478bd9Sstevel@tonic-gate int noidel = (int)(ulp->ul_flag & ULOCKFS_NOIDEL); 4697c478bd9Sstevel@tonic-gate 4707c478bd9Sstevel@tonic-gate /* 4717c478bd9Sstevel@tonic-gate * if wlock or hlock or elock 4727c478bd9Sstevel@tonic-gate */ 4737c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_WLOCK(ulp) || ULOCKFS_IS_HLOCK(ulp) || 4747c478bd9Sstevel@tonic-gate ULOCKFS_IS_ELOCK(ulp)) { 4757c478bd9Sstevel@tonic-gate 4767c478bd9Sstevel@tonic-gate /* 4777c478bd9Sstevel@tonic-gate * don't keep access times 4787c478bd9Sstevel@tonic-gate * don't free deleted files 4797c478bd9Sstevel@tonic-gate * if superblock writes are allowed, limit them to me for now 4807c478bd9Sstevel@tonic-gate */ 4817c478bd9Sstevel@tonic-gate ulp->ul_flag |= (ULOCKFS_NOIACC|ULOCKFS_NOIDEL); 4827c478bd9Sstevel@tonic-gate if (ulp->ul_sbowner != (kthread_id_t)-1) 4837c478bd9Sstevel@tonic-gate ulp->ul_sbowner = curthread; 4847c478bd9Sstevel@tonic-gate 4857c478bd9Sstevel@tonic-gate /* 4867c478bd9Sstevel@tonic-gate * wait for writes for deleted files and superblock updates 4877c478bd9Sstevel@tonic-gate */ 4887c478bd9Sstevel@tonic-gate (void) ufs_flush(vfsp); 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate /* 4917c478bd9Sstevel@tonic-gate * now make sure the quota file is up-to-date 4927c478bd9Sstevel@tonic-gate * expensive; but effective 4937c478bd9Sstevel@tonic-gate */ 4947c478bd9Sstevel@tonic-gate error = ufs_flush(vfsp); 4957c478bd9Sstevel@tonic-gate /* 4967c478bd9Sstevel@tonic-gate * no one can write the superblock 4977c478bd9Sstevel@tonic-gate */ 4987c478bd9Sstevel@tonic-gate ulp->ul_sbowner = (kthread_id_t)-1; 4997c478bd9Sstevel@tonic-gate 5007c478bd9Sstevel@tonic-gate /* 5017c478bd9Sstevel@tonic-gate * special processing for wlock/hlock/elock 5027c478bd9Sstevel@tonic-gate */ 5037c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_WLOCK(ulp)) { 5047c478bd9Sstevel@tonic-gate if (error) 5057c478bd9Sstevel@tonic-gate goto errout; 5067c478bd9Sstevel@tonic-gate error = bfinval(ufsvfsp->vfs_dev, 0); 5077c478bd9Sstevel@tonic-gate if (error) 5087c478bd9Sstevel@tonic-gate goto errout; 5097c478bd9Sstevel@tonic-gate error = ufs_scan_inodes(0, ufs_thaw_wlock, 5107c478bd9Sstevel@tonic-gate (void *)ufsvfsp, ufsvfsp); 5117c478bd9Sstevel@tonic-gate if (error) 5127c478bd9Sstevel@tonic-gate goto errout; 5137c478bd9Sstevel@tonic-gate } 5147c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(ulp) || ULOCKFS_IS_ELOCK(ulp)) { 5157c478bd9Sstevel@tonic-gate error = 0; 5167c478bd9Sstevel@tonic-gate (void) ufs_scan_inodes(0, ufs_thaw_hlock, 5177c478bd9Sstevel@tonic-gate (void *)ufsvfsp, ufsvfsp); 5187c478bd9Sstevel@tonic-gate (void) bfinval(ufsvfsp->vfs_dev, 1); 5197c478bd9Sstevel@tonic-gate } 5207c478bd9Sstevel@tonic-gate } else { 5217c478bd9Sstevel@tonic-gate 5227c478bd9Sstevel@tonic-gate /* 5237c478bd9Sstevel@tonic-gate * okay to keep access times 5247c478bd9Sstevel@tonic-gate * okay to free deleted files 5257c478bd9Sstevel@tonic-gate * okay to write the superblock 5267c478bd9Sstevel@tonic-gate */ 5277c478bd9Sstevel@tonic-gate ulp->ul_flag &= ~(ULOCKFS_NOIACC|ULOCKFS_NOIDEL); 5287c478bd9Sstevel@tonic-gate ulp->ul_sbowner = NULL; 5297c478bd9Sstevel@tonic-gate 5307c478bd9Sstevel@tonic-gate /* 5317c478bd9Sstevel@tonic-gate * flush in case deleted files are in memory 5327c478bd9Sstevel@tonic-gate */ 5337c478bd9Sstevel@tonic-gate if (noidel) { 5347c478bd9Sstevel@tonic-gate if (error = ufs_flush(vfsp)) 5357c478bd9Sstevel@tonic-gate goto errout; 5367c478bd9Sstevel@tonic-gate } 5377c478bd9Sstevel@tonic-gate } 5387c478bd9Sstevel@tonic-gate 5397c478bd9Sstevel@tonic-gate errout: 5407c478bd9Sstevel@tonic-gate cv_broadcast(&ulp->ul_cv); 5417c478bd9Sstevel@tonic-gate return (error); 5427c478bd9Sstevel@tonic-gate } 5437c478bd9Sstevel@tonic-gate 5447c478bd9Sstevel@tonic-gate /* 5457c478bd9Sstevel@tonic-gate * ufs_reconcile_fs 5467c478bd9Sstevel@tonic-gate * reconcile incore superblock with ondisk superblock 5477c478bd9Sstevel@tonic-gate */ 5487c478bd9Sstevel@tonic-gate int 5497c478bd9Sstevel@tonic-gate ufs_reconcile_fs(struct vfs *vfsp, struct ufsvfs *ufsvfsp, int errlck) 5507c478bd9Sstevel@tonic-gate { 5517c478bd9Sstevel@tonic-gate struct fs *mfs; /* in-memory superblock */ 5527c478bd9Sstevel@tonic-gate struct fs *dfs; /* on-disk superblock */ 5537c478bd9Sstevel@tonic-gate struct buf *bp; /* on-disk superblock buf */ 5547c478bd9Sstevel@tonic-gate int needs_unlock; 5557c478bd9Sstevel@tonic-gate char finished_fsclean; 5567c478bd9Sstevel@tonic-gate 5577c478bd9Sstevel@tonic-gate mfs = ufsvfsp->vfs_fs; 5587c478bd9Sstevel@tonic-gate 5597c478bd9Sstevel@tonic-gate /* 5607c478bd9Sstevel@tonic-gate * get the on-disk copy of the superblock 5617c478bd9Sstevel@tonic-gate */ 5627c478bd9Sstevel@tonic-gate bp = UFS_BREAD(ufsvfsp, vfsp->vfs_dev, SBLOCK, SBSIZE); 5637c478bd9Sstevel@tonic-gate bp->b_flags |= (B_STALE|B_AGE); 5647c478bd9Sstevel@tonic-gate if (bp->b_flags & B_ERROR) { 5657c478bd9Sstevel@tonic-gate brelse(bp); 5667c478bd9Sstevel@tonic-gate return (EIO); 5677c478bd9Sstevel@tonic-gate } 5687c478bd9Sstevel@tonic-gate dfs = bp->b_un.b_fs; 5697c478bd9Sstevel@tonic-gate 5707c478bd9Sstevel@tonic-gate /* error locks may only unlock after the fs has been made consistent */ 5717c478bd9Sstevel@tonic-gate if (errlck == UN_ERRLCK) { 5727c478bd9Sstevel@tonic-gate if (dfs->fs_clean == FSFIX) { /* being repaired */ 5737c478bd9Sstevel@tonic-gate brelse(bp); 5747c478bd9Sstevel@tonic-gate return (EAGAIN); 5757c478bd9Sstevel@tonic-gate } 5767c478bd9Sstevel@tonic-gate /* repair not yet started? */ 5777c478bd9Sstevel@tonic-gate finished_fsclean = TRANS_ISTRANS(ufsvfsp)? FSLOG: FSCLEAN; 5787c478bd9Sstevel@tonic-gate if (dfs->fs_clean != finished_fsclean) { 5797c478bd9Sstevel@tonic-gate brelse(bp); 5807c478bd9Sstevel@tonic-gate return (EBUSY); 5817c478bd9Sstevel@tonic-gate } 5827c478bd9Sstevel@tonic-gate } 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate /* 5857c478bd9Sstevel@tonic-gate * if superblock has changed too much, abort 5867c478bd9Sstevel@tonic-gate */ 5877c478bd9Sstevel@tonic-gate if ((mfs->fs_sblkno != dfs->fs_sblkno) || 5887c478bd9Sstevel@tonic-gate (mfs->fs_cblkno != dfs->fs_cblkno) || 5897c478bd9Sstevel@tonic-gate (mfs->fs_iblkno != dfs->fs_iblkno) || 5907c478bd9Sstevel@tonic-gate (mfs->fs_dblkno != dfs->fs_dblkno) || 5917c478bd9Sstevel@tonic-gate (mfs->fs_cgoffset != dfs->fs_cgoffset) || 5927c478bd9Sstevel@tonic-gate (mfs->fs_cgmask != dfs->fs_cgmask) || 5937c478bd9Sstevel@tonic-gate (mfs->fs_bsize != dfs->fs_bsize) || 5947c478bd9Sstevel@tonic-gate (mfs->fs_fsize != dfs->fs_fsize) || 5957c478bd9Sstevel@tonic-gate (mfs->fs_frag != dfs->fs_frag) || 5967c478bd9Sstevel@tonic-gate (mfs->fs_bmask != dfs->fs_bmask) || 5977c478bd9Sstevel@tonic-gate (mfs->fs_fmask != dfs->fs_fmask) || 5987c478bd9Sstevel@tonic-gate (mfs->fs_bshift != dfs->fs_bshift) || 5997c478bd9Sstevel@tonic-gate (mfs->fs_fshift != dfs->fs_fshift) || 6007c478bd9Sstevel@tonic-gate (mfs->fs_fragshift != dfs->fs_fragshift) || 6017c478bd9Sstevel@tonic-gate (mfs->fs_fsbtodb != dfs->fs_fsbtodb) || 6027c478bd9Sstevel@tonic-gate (mfs->fs_sbsize != dfs->fs_sbsize) || 6037c478bd9Sstevel@tonic-gate (mfs->fs_nindir != dfs->fs_nindir) || 6047c478bd9Sstevel@tonic-gate (mfs->fs_nspf != dfs->fs_nspf) || 6057c478bd9Sstevel@tonic-gate (mfs->fs_trackskew != dfs->fs_trackskew) || 6067c478bd9Sstevel@tonic-gate (mfs->fs_cgsize != dfs->fs_cgsize) || 6077c478bd9Sstevel@tonic-gate (mfs->fs_ntrak != dfs->fs_ntrak) || 6087c478bd9Sstevel@tonic-gate (mfs->fs_nsect != dfs->fs_nsect) || 6097c478bd9Sstevel@tonic-gate (mfs->fs_spc != dfs->fs_spc) || 6107c478bd9Sstevel@tonic-gate (mfs->fs_cpg != dfs->fs_cpg) || 6117c478bd9Sstevel@tonic-gate (mfs->fs_ipg != dfs->fs_ipg) || 6127c478bd9Sstevel@tonic-gate (mfs->fs_fpg != dfs->fs_fpg) || 6137c478bd9Sstevel@tonic-gate (mfs->fs_postblformat != dfs->fs_postblformat) || 6147c478bd9Sstevel@tonic-gate (mfs->fs_magic != dfs->fs_magic)) { 6157c478bd9Sstevel@tonic-gate brelse(bp); 6167c478bd9Sstevel@tonic-gate return (EACCES); 6177c478bd9Sstevel@tonic-gate } 6187c478bd9Sstevel@tonic-gate if (dfs->fs_clean == FSBAD || FSOKAY != dfs->fs_state + dfs->fs_time) 6197c478bd9Sstevel@tonic-gate if (mfs->fs_clean == FSLOG) { 6207c478bd9Sstevel@tonic-gate brelse(bp); 6217c478bd9Sstevel@tonic-gate return (EACCES); 6227c478bd9Sstevel@tonic-gate } 6237c478bd9Sstevel@tonic-gate 6247c478bd9Sstevel@tonic-gate /* 6257c478bd9Sstevel@tonic-gate * get new summary info 6267c478bd9Sstevel@tonic-gate */ 6277c478bd9Sstevel@tonic-gate if (ufs_getsummaryinfo(vfsp->vfs_dev, ufsvfsp, dfs)) { 6287c478bd9Sstevel@tonic-gate brelse(bp); 6297c478bd9Sstevel@tonic-gate return (EIO); 6307c478bd9Sstevel@tonic-gate } 6317c478bd9Sstevel@tonic-gate 6327c478bd9Sstevel@tonic-gate /* 6337c478bd9Sstevel@tonic-gate * release old summary info and update in-memory superblock 6347c478bd9Sstevel@tonic-gate */ 6357c478bd9Sstevel@tonic-gate kmem_free(mfs->fs_u.fs_csp, mfs->fs_cssize); 6367c478bd9Sstevel@tonic-gate mfs->fs_u.fs_csp = dfs->fs_u.fs_csp; /* Only entry 0 used */ 6377c478bd9Sstevel@tonic-gate 6387c478bd9Sstevel@tonic-gate /* 6397c478bd9Sstevel@tonic-gate * update fields allowed to change 6407c478bd9Sstevel@tonic-gate */ 6417c478bd9Sstevel@tonic-gate mfs->fs_size = dfs->fs_size; 6427c478bd9Sstevel@tonic-gate mfs->fs_dsize = dfs->fs_dsize; 6437c478bd9Sstevel@tonic-gate mfs->fs_ncg = dfs->fs_ncg; 6447c478bd9Sstevel@tonic-gate mfs->fs_minfree = dfs->fs_minfree; 6457c478bd9Sstevel@tonic-gate mfs->fs_rotdelay = dfs->fs_rotdelay; 6467c478bd9Sstevel@tonic-gate mfs->fs_rps = dfs->fs_rps; 6477c478bd9Sstevel@tonic-gate mfs->fs_maxcontig = dfs->fs_maxcontig; 6487c478bd9Sstevel@tonic-gate mfs->fs_maxbpg = dfs->fs_maxbpg; 6497c478bd9Sstevel@tonic-gate mfs->fs_csmask = dfs->fs_csmask; 6507c478bd9Sstevel@tonic-gate mfs->fs_csshift = dfs->fs_csshift; 6517c478bd9Sstevel@tonic-gate mfs->fs_optim = dfs->fs_optim; 6527c478bd9Sstevel@tonic-gate mfs->fs_csaddr = dfs->fs_csaddr; 6537c478bd9Sstevel@tonic-gate mfs->fs_cssize = dfs->fs_cssize; 6547c478bd9Sstevel@tonic-gate mfs->fs_ncyl = dfs->fs_ncyl; 6557c478bd9Sstevel@tonic-gate mfs->fs_cstotal = dfs->fs_cstotal; 6567c478bd9Sstevel@tonic-gate mfs->fs_reclaim = dfs->fs_reclaim; 6577c478bd9Sstevel@tonic-gate 6587c478bd9Sstevel@tonic-gate if (mfs->fs_reclaim & (FS_RECLAIM|FS_RECLAIMING)) { 6597c478bd9Sstevel@tonic-gate mfs->fs_reclaim &= ~FS_RECLAIM; 6607c478bd9Sstevel@tonic-gate mfs->fs_reclaim |= FS_RECLAIMING; 6617c478bd9Sstevel@tonic-gate ufs_thread_start(&ufsvfsp->vfs_reclaim, 6627c478bd9Sstevel@tonic-gate ufs_thread_reclaim, vfsp); 6637c478bd9Sstevel@tonic-gate } 6647c478bd9Sstevel@tonic-gate 6657c478bd9Sstevel@tonic-gate /* XXX What to do about sparecon? */ 6667c478bd9Sstevel@tonic-gate 6677c478bd9Sstevel@tonic-gate /* XXX need to copy volume label */ 6687c478bd9Sstevel@tonic-gate 6697c478bd9Sstevel@tonic-gate /* 6707c478bd9Sstevel@tonic-gate * ondisk clean flag overrides inmemory clean flag iff == FSBAD 6717c478bd9Sstevel@tonic-gate * or if error-locked and ondisk is now clean 6727c478bd9Sstevel@tonic-gate */ 6737c478bd9Sstevel@tonic-gate needs_unlock = !MUTEX_HELD(&ufsvfsp->vfs_lock); 6747c478bd9Sstevel@tonic-gate if (needs_unlock) 6757c478bd9Sstevel@tonic-gate mutex_enter(&ufsvfsp->vfs_lock); 6767c478bd9Sstevel@tonic-gate 6777c478bd9Sstevel@tonic-gate if (errlck == UN_ERRLCK) { 6787c478bd9Sstevel@tonic-gate if (finished_fsclean == dfs->fs_clean) 6797c478bd9Sstevel@tonic-gate mfs->fs_clean = finished_fsclean; 6807c478bd9Sstevel@tonic-gate else 6817c478bd9Sstevel@tonic-gate mfs->fs_clean = FSBAD; 6827c478bd9Sstevel@tonic-gate mfs->fs_state = FSOKAY - dfs->fs_time; 6837c478bd9Sstevel@tonic-gate } 6847c478bd9Sstevel@tonic-gate 6857c478bd9Sstevel@tonic-gate if (FSOKAY != dfs->fs_state + dfs->fs_time || 6867c478bd9Sstevel@tonic-gate (dfs->fs_clean == FSBAD)) 6877c478bd9Sstevel@tonic-gate mfs->fs_clean = FSBAD; 6887c478bd9Sstevel@tonic-gate 6897c478bd9Sstevel@tonic-gate if (needs_unlock) 6907c478bd9Sstevel@tonic-gate mutex_exit(&ufsvfsp->vfs_lock); 6917c478bd9Sstevel@tonic-gate 6927c478bd9Sstevel@tonic-gate brelse(bp); 6937c478bd9Sstevel@tonic-gate 6947c478bd9Sstevel@tonic-gate return (0); 6957c478bd9Sstevel@tonic-gate } 6967c478bd9Sstevel@tonic-gate 6977c478bd9Sstevel@tonic-gate /* 6987c478bd9Sstevel@tonic-gate * ufs_reconcile_inode 6997c478bd9Sstevel@tonic-gate * reconcile ondisk inode with incore inode 7007c478bd9Sstevel@tonic-gate */ 7017c478bd9Sstevel@tonic-gate static int 7027c478bd9Sstevel@tonic-gate ufs_reconcile_inode(struct inode *ip, void *arg) 7037c478bd9Sstevel@tonic-gate { 7047c478bd9Sstevel@tonic-gate int i; 7057c478bd9Sstevel@tonic-gate int ndaddr; 7067c478bd9Sstevel@tonic-gate int niaddr; 7077c478bd9Sstevel@tonic-gate struct dinode *dp; /* ondisk inode */ 7087c478bd9Sstevel@tonic-gate struct buf *bp = NULL; 7097c478bd9Sstevel@tonic-gate uid_t d_uid; 7107c478bd9Sstevel@tonic-gate gid_t d_gid; 7117c478bd9Sstevel@tonic-gate int error = 0; 7127c478bd9Sstevel@tonic-gate struct fs *fs; 7137c478bd9Sstevel@tonic-gate 7147c478bd9Sstevel@tonic-gate /* 7157c478bd9Sstevel@tonic-gate * not an inode we care about 7167c478bd9Sstevel@tonic-gate */ 7177c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 7187c478bd9Sstevel@tonic-gate return (0); 7197c478bd9Sstevel@tonic-gate 7207c478bd9Sstevel@tonic-gate fs = ip->i_fs; 7217c478bd9Sstevel@tonic-gate 7227c478bd9Sstevel@tonic-gate /* 7237c478bd9Sstevel@tonic-gate * Inode reconciliation fails: we made the filesystem quiescent 7247c478bd9Sstevel@tonic-gate * and we did a ufs_flush() before calling ufs_reconcile_inode() 7257c478bd9Sstevel@tonic-gate * and thus the inode should not have been changed inbetween. 7267c478bd9Sstevel@tonic-gate * Any discrepancies indicate a logic error and a pretty 7277c478bd9Sstevel@tonic-gate * significant run-state inconsistency we should complain about. 7287c478bd9Sstevel@tonic-gate */ 7297c478bd9Sstevel@tonic-gate if (ip->i_flag & (IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG)) { 7307c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s: Inode reconciliation failed for" 7317c478bd9Sstevel@tonic-gate "inode %llu", fs->fs_fsmnt, (u_longlong_t)ip->i_number); 7327c478bd9Sstevel@tonic-gate return (EINVAL); 7337c478bd9Sstevel@tonic-gate } 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate /* 7367c478bd9Sstevel@tonic-gate * get the dinode 7377c478bd9Sstevel@tonic-gate */ 7387c478bd9Sstevel@tonic-gate bp = UFS_BREAD(ip->i_ufsvfs, 7397c478bd9Sstevel@tonic-gate ip->i_dev, (daddr_t)fsbtodb(fs, itod(fs, ip->i_number)), 7407c478bd9Sstevel@tonic-gate (int)fs->fs_bsize); 7417c478bd9Sstevel@tonic-gate if (bp->b_flags & B_ERROR) { 7427c478bd9Sstevel@tonic-gate brelse(bp); 7437c478bd9Sstevel@tonic-gate return (EIO); 7447c478bd9Sstevel@tonic-gate } 7457c478bd9Sstevel@tonic-gate dp = bp->b_un.b_dino; 7467c478bd9Sstevel@tonic-gate dp += itoo(fs, ip->i_number); 7477c478bd9Sstevel@tonic-gate 7487c478bd9Sstevel@tonic-gate /* 7497c478bd9Sstevel@tonic-gate * handle Sun's implementation of EFT 7507c478bd9Sstevel@tonic-gate */ 7517c478bd9Sstevel@tonic-gate d_uid = (dp->di_suid == UID_LONG) ? dp->di_uid : (uid_t)dp->di_suid; 7527c478bd9Sstevel@tonic-gate d_gid = (dp->di_sgid == GID_LONG) ? dp->di_gid : (uid_t)dp->di_sgid; 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate rw_enter(&ip->i_contents, RW_WRITER); 7557c478bd9Sstevel@tonic-gate 7567c478bd9Sstevel@tonic-gate /* 7577c478bd9Sstevel@tonic-gate * some fields are not allowed to change 7587c478bd9Sstevel@tonic-gate */ 7597c478bd9Sstevel@tonic-gate if ((ip->i_mode != dp->di_mode) || 7607c478bd9Sstevel@tonic-gate (ip->i_gen != dp->di_gen) || 7617c478bd9Sstevel@tonic-gate (ip->i_uid != d_uid) || 7627c478bd9Sstevel@tonic-gate (ip->i_gid != d_gid)) { 7637c478bd9Sstevel@tonic-gate error = EACCES; 7647c478bd9Sstevel@tonic-gate goto out; 7657c478bd9Sstevel@tonic-gate } 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate /* 7687c478bd9Sstevel@tonic-gate * and some are allowed to change 7697c478bd9Sstevel@tonic-gate */ 7707c478bd9Sstevel@tonic-gate ip->i_size = dp->di_size; 7717c478bd9Sstevel@tonic-gate ip->i_ic.ic_flags = dp->di_ic.ic_flags; 7727c478bd9Sstevel@tonic-gate ip->i_blocks = dp->di_blocks; 7737c478bd9Sstevel@tonic-gate ip->i_nlink = dp->di_nlink; 7747c478bd9Sstevel@tonic-gate if (ip->i_flag & IFASTSYMLNK) { 7757c478bd9Sstevel@tonic-gate ndaddr = 1; 7767c478bd9Sstevel@tonic-gate niaddr = 0; 7777c478bd9Sstevel@tonic-gate } else { 7787c478bd9Sstevel@tonic-gate ndaddr = NDADDR; 7797c478bd9Sstevel@tonic-gate niaddr = NIADDR; 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate for (i = 0; i < ndaddr; ++i) 7827c478bd9Sstevel@tonic-gate ip->i_db[i] = dp->di_db[i]; 7837c478bd9Sstevel@tonic-gate for (i = 0; i < niaddr; ++i) 7847c478bd9Sstevel@tonic-gate ip->i_ib[i] = dp->di_ib[i]; 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate out: 7877c478bd9Sstevel@tonic-gate rw_exit(&ip->i_contents); 7887c478bd9Sstevel@tonic-gate brelse(bp); 7897c478bd9Sstevel@tonic-gate return (error); 7907c478bd9Sstevel@tonic-gate } 7917c478bd9Sstevel@tonic-gate 7927c478bd9Sstevel@tonic-gate /* 7937c478bd9Sstevel@tonic-gate * ufs_reconcile 7947c478bd9Sstevel@tonic-gate * reconcile ondisk superblock/inodes with any incore 7957c478bd9Sstevel@tonic-gate */ 7967c478bd9Sstevel@tonic-gate static int 7977c478bd9Sstevel@tonic-gate ufs_reconcile(struct vfs *vfsp, struct ufsvfs *ufsvfsp, int errlck) 7987c478bd9Sstevel@tonic-gate { 7997c478bd9Sstevel@tonic-gate int error = 0; 8007c478bd9Sstevel@tonic-gate 8017c478bd9Sstevel@tonic-gate /* 8027c478bd9Sstevel@tonic-gate * get rid of as much inmemory data as possible 8037c478bd9Sstevel@tonic-gate */ 8047c478bd9Sstevel@tonic-gate (void) ufs_flush(vfsp); 8057c478bd9Sstevel@tonic-gate 8067c478bd9Sstevel@tonic-gate /* 8077c478bd9Sstevel@tonic-gate * reconcile the superblock and inodes 8087c478bd9Sstevel@tonic-gate */ 8097c478bd9Sstevel@tonic-gate if (error = ufs_reconcile_fs(vfsp, ufsvfsp, errlck)) 8107c478bd9Sstevel@tonic-gate return (error); 8117c478bd9Sstevel@tonic-gate if (error = ufs_scan_inodes(0, ufs_reconcile_inode, ufsvfsp, ufsvfsp)) 8127c478bd9Sstevel@tonic-gate return (error); 8137c478bd9Sstevel@tonic-gate /* 8147c478bd9Sstevel@tonic-gate * allocation blocks may be incorrect; get rid of them 8157c478bd9Sstevel@tonic-gate */ 8167c478bd9Sstevel@tonic-gate (void) ufs_flush(vfsp); 8177c478bd9Sstevel@tonic-gate 8187c478bd9Sstevel@tonic-gate return (error); 8197c478bd9Sstevel@tonic-gate } 8207c478bd9Sstevel@tonic-gate 8217c478bd9Sstevel@tonic-gate /* 8227c478bd9Sstevel@tonic-gate * File system locking 8237c478bd9Sstevel@tonic-gate */ 8247c478bd9Sstevel@tonic-gate int 8257c478bd9Sstevel@tonic-gate ufs_fiolfs(struct vnode *vp, struct lockfs *lockfsp, int from_log) 8267c478bd9Sstevel@tonic-gate { 8277c478bd9Sstevel@tonic-gate return (ufs__fiolfs(vp, lockfsp, /* from_user */ 1, from_log)); 8287c478bd9Sstevel@tonic-gate } 8297c478bd9Sstevel@tonic-gate 8307c478bd9Sstevel@tonic-gate /* kernel-internal interface, also used by fix-on-panic */ 8317c478bd9Sstevel@tonic-gate int 8327c478bd9Sstevel@tonic-gate ufs__fiolfs( 8337c478bd9Sstevel@tonic-gate struct vnode *vp, 8347c478bd9Sstevel@tonic-gate struct lockfs *lockfsp, 8357c478bd9Sstevel@tonic-gate int from_user, 8367c478bd9Sstevel@tonic-gate int from_log) 8377c478bd9Sstevel@tonic-gate { 8387c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 8397c478bd9Sstevel@tonic-gate struct lockfs lfs; 8407c478bd9Sstevel@tonic-gate int error; 8417c478bd9Sstevel@tonic-gate struct vfs *vfsp; 8427c478bd9Sstevel@tonic-gate struct ufsvfs *ufsvfsp; 8437c478bd9Sstevel@tonic-gate int errlck = NO_ERRLCK; 8447c478bd9Sstevel@tonic-gate int poll_events = POLLPRI; 8457c478bd9Sstevel@tonic-gate extern struct pollhead ufs_pollhd; 8467c478bd9Sstevel@tonic-gate 8477c478bd9Sstevel@tonic-gate /* check valid lock type */ 8487c478bd9Sstevel@tonic-gate if (!lockfsp || lockfsp->lf_lock > LOCKFS_MAXLOCK) 8497c478bd9Sstevel@tonic-gate return (EINVAL); 8507c478bd9Sstevel@tonic-gate 8517c478bd9Sstevel@tonic-gate if (!vp || !vp->v_vfsp || !vp->v_vfsp->vfs_data) 8527c478bd9Sstevel@tonic-gate return (EIO); 8537c478bd9Sstevel@tonic-gate 8547c478bd9Sstevel@tonic-gate vfsp = vp->v_vfsp; 8557c478bd9Sstevel@tonic-gate ufsvfsp = (struct ufsvfs *)vfsp->vfs_data; 8567c478bd9Sstevel@tonic-gate ulp = &ufsvfsp->vfs_ulockfs; 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate /* 8597c478bd9Sstevel@tonic-gate * Suspend both the reclaim thread and the delete thread. 8607c478bd9Sstevel@tonic-gate * This must be done outside the lockfs locking protocol. 8617c478bd9Sstevel@tonic-gate */ 8627c478bd9Sstevel@tonic-gate ufs_thread_suspend(&ufsvfsp->vfs_reclaim); 8637c478bd9Sstevel@tonic-gate ufs_thread_suspend(&ufsvfsp->vfs_delete); 8647c478bd9Sstevel@tonic-gate 8657c478bd9Sstevel@tonic-gate /* 8667c478bd9Sstevel@tonic-gate * Acquire vfs_reflock around ul_lock to avoid deadlock with 8677c478bd9Sstevel@tonic-gate * umount/remount/sync. 8687c478bd9Sstevel@tonic-gate */ 8697c478bd9Sstevel@tonic-gate vfs_lock_wait(vfsp); 8707c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 871bc69f433Saguzovsk atomic_add_long(&ufs_quiesce_pend, 1); 8727c478bd9Sstevel@tonic-gate 8737c478bd9Sstevel@tonic-gate /* 8747c478bd9Sstevel@tonic-gate * Quit if there is another lockfs request in progress 8757c478bd9Sstevel@tonic-gate * that is waiting for existing ufs_vnops to complete. 8767c478bd9Sstevel@tonic-gate */ 8777c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_BUSY(ulp)) { 8787c478bd9Sstevel@tonic-gate error = EBUSY; 8797c478bd9Sstevel@tonic-gate goto errexit; 8807c478bd9Sstevel@tonic-gate } 8817c478bd9Sstevel@tonic-gate 8827c478bd9Sstevel@tonic-gate /* cannot ulocked or downgrade a hard-lock */ 8837c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(ulp)) { 8847c478bd9Sstevel@tonic-gate error = EIO; 8857c478bd9Sstevel@tonic-gate goto errexit; 8867c478bd9Sstevel@tonic-gate } 8877c478bd9Sstevel@tonic-gate 8887c478bd9Sstevel@tonic-gate /* an error lock may be unlocked or relocked, only */ 8897c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_ELOCK(ulp)) { 8907c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_ULOCK(lockfsp) && !LOCKFS_IS_ELOCK(lockfsp)) { 8917c478bd9Sstevel@tonic-gate error = EBUSY; 8927c478bd9Sstevel@tonic-gate goto errexit; 8937c478bd9Sstevel@tonic-gate } 8947c478bd9Sstevel@tonic-gate } 8957c478bd9Sstevel@tonic-gate 8967c478bd9Sstevel@tonic-gate /* 8977c478bd9Sstevel@tonic-gate * a read-only error lock may only be upgraded to an 8987c478bd9Sstevel@tonic-gate * error lock or hard lock 8997c478bd9Sstevel@tonic-gate */ 9007c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_ROELOCK(ulp)) { 9017c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_HLOCK(lockfsp) && !LOCKFS_IS_ELOCK(lockfsp)) { 9027c478bd9Sstevel@tonic-gate error = EBUSY; 9037c478bd9Sstevel@tonic-gate goto errexit; 9047c478bd9Sstevel@tonic-gate } 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate /* 9087c478bd9Sstevel@tonic-gate * until read-only error locks are fully implemented 9097c478bd9Sstevel@tonic-gate * just return EINVAL 9107c478bd9Sstevel@tonic-gate */ 9117c478bd9Sstevel@tonic-gate if (LOCKFS_IS_ROELOCK(lockfsp)) { 9127c478bd9Sstevel@tonic-gate error = EINVAL; 9137c478bd9Sstevel@tonic-gate goto errexit; 9147c478bd9Sstevel@tonic-gate } 9157c478bd9Sstevel@tonic-gate 9167c478bd9Sstevel@tonic-gate /* 9177c478bd9Sstevel@tonic-gate * an error lock may only be applied if the file system is 9187c478bd9Sstevel@tonic-gate * unlocked or already error locked. 9197c478bd9Sstevel@tonic-gate * (this is to prevent the case where a fs gets changed out from 9207c478bd9Sstevel@tonic-gate * underneath a fs that is locked for backup, 9217c478bd9Sstevel@tonic-gate * that is, name/delete/write-locked.) 9227c478bd9Sstevel@tonic-gate */ 9237c478bd9Sstevel@tonic-gate if ((!ULOCKFS_IS_ULOCK(ulp) && !ULOCKFS_IS_ELOCK(ulp) && 9247c478bd9Sstevel@tonic-gate !ULOCKFS_IS_ROELOCK(ulp)) && 9257c478bd9Sstevel@tonic-gate (LOCKFS_IS_ELOCK(lockfsp) || LOCKFS_IS_ROELOCK(lockfsp))) { 9267c478bd9Sstevel@tonic-gate error = EBUSY; 9277c478bd9Sstevel@tonic-gate goto errexit; 9287c478bd9Sstevel@tonic-gate } 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate /* get and validate the input lockfs request */ 9317c478bd9Sstevel@tonic-gate if (error = ufs_getlfd(lockfsp, &ulp->ul_lockfs)) 9327c478bd9Sstevel@tonic-gate goto errexit; 9337c478bd9Sstevel@tonic-gate 9347c478bd9Sstevel@tonic-gate /* 9357c478bd9Sstevel@tonic-gate * save current ulockfs struct 9367c478bd9Sstevel@tonic-gate */ 9377c478bd9Sstevel@tonic-gate bcopy(&ulp->ul_lockfs, &lfs, sizeof (struct lockfs)); 9387c478bd9Sstevel@tonic-gate 9397c478bd9Sstevel@tonic-gate /* 9407c478bd9Sstevel@tonic-gate * Freeze the file system (pend future accesses) 9417c478bd9Sstevel@tonic-gate */ 9427c478bd9Sstevel@tonic-gate ufs_freeze(ulp, lockfsp); 9437c478bd9Sstevel@tonic-gate 9447c478bd9Sstevel@tonic-gate /* 9457c478bd9Sstevel@tonic-gate * Set locking in progress because ufs_quiesce may free the 9467c478bd9Sstevel@tonic-gate * ul_lock mutex. 9477c478bd9Sstevel@tonic-gate */ 9487c478bd9Sstevel@tonic-gate ULOCKFS_SET_BUSY(ulp); 9497c478bd9Sstevel@tonic-gate /* update the ioctl copy */ 9507c478bd9Sstevel@tonic-gate LOCKFS_SET_BUSY(&ulp->ul_lockfs); 9517c478bd9Sstevel@tonic-gate 9527c478bd9Sstevel@tonic-gate /* 9537c478bd9Sstevel@tonic-gate * Quiesce (wait for outstanding accesses to finish) 9547c478bd9Sstevel@tonic-gate */ 9557c478bd9Sstevel@tonic-gate if (error = ufs_quiesce(ulp)) 9567c478bd9Sstevel@tonic-gate goto errout; 9577c478bd9Sstevel@tonic-gate 9587c478bd9Sstevel@tonic-gate /* 9597c478bd9Sstevel@tonic-gate * can't wlock or (ro)elock fs with accounting or local swap file 9607c478bd9Sstevel@tonic-gate */ 9617c478bd9Sstevel@tonic-gate if ((ULOCKFS_IS_WLOCK(ulp) || ULOCKFS_IS_ELOCK(ulp) || 9627c478bd9Sstevel@tonic-gate ULOCKFS_IS_ROELOCK(ulp)) && !from_log) { 9637c478bd9Sstevel@tonic-gate if (error = ufs_checkaccton(vp)) 9647c478bd9Sstevel@tonic-gate goto errout; 9657c478bd9Sstevel@tonic-gate if (error = ufs_checkswapon(vp)) 9667c478bd9Sstevel@tonic-gate goto errout; 9677c478bd9Sstevel@tonic-gate } 9687c478bd9Sstevel@tonic-gate 9697c478bd9Sstevel@tonic-gate /* 9707c478bd9Sstevel@tonic-gate * save error lock status to pass down to reconcilation 9717c478bd9Sstevel@tonic-gate * routines and for later cleanup 9727c478bd9Sstevel@tonic-gate */ 9737c478bd9Sstevel@tonic-gate if (LOCKFS_IS_ELOCK(&lfs) && ULOCKFS_IS_ULOCK(ulp)) 9747c478bd9Sstevel@tonic-gate errlck = UN_ERRLCK; 9757c478bd9Sstevel@tonic-gate 9767c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_ELOCK(ulp) || ULOCKFS_IS_ROELOCK(ulp)) { 9777c478bd9Sstevel@tonic-gate int needs_unlock; 9787c478bd9Sstevel@tonic-gate int needs_sbwrite; 9797c478bd9Sstevel@tonic-gate 9807c478bd9Sstevel@tonic-gate poll_events |= POLLERR; 9817c478bd9Sstevel@tonic-gate errlck = LOCKFS_IS_ELOCK(&lfs) || LOCKFS_IS_ROELOCK(&lfs)? 9827c478bd9Sstevel@tonic-gate RE_ERRLCK: SET_ERRLCK; 9837c478bd9Sstevel@tonic-gate 9847c478bd9Sstevel@tonic-gate needs_unlock = !MUTEX_HELD(&ufsvfsp->vfs_lock); 9857c478bd9Sstevel@tonic-gate if (needs_unlock) 9867c478bd9Sstevel@tonic-gate mutex_enter(&ufsvfsp->vfs_lock); 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate /* disable delayed i/o */ 9897c478bd9Sstevel@tonic-gate needs_sbwrite = 0; 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate if (errlck == SET_ERRLCK) { 9927c478bd9Sstevel@tonic-gate ufsvfsp->vfs_fs->fs_clean = FSBAD; 9937c478bd9Sstevel@tonic-gate needs_sbwrite = 1; 9947c478bd9Sstevel@tonic-gate } 9957c478bd9Sstevel@tonic-gate 9967c478bd9Sstevel@tonic-gate needs_sbwrite |= ufsvfsp->vfs_dio; 9977c478bd9Sstevel@tonic-gate ufsvfsp->vfs_dio = 0; 9987c478bd9Sstevel@tonic-gate 9997c478bd9Sstevel@tonic-gate if (needs_unlock) 10007c478bd9Sstevel@tonic-gate mutex_exit(&ufsvfsp->vfs_lock); 10017c478bd9Sstevel@tonic-gate 10027c478bd9Sstevel@tonic-gate if (needs_sbwrite) { 10037c478bd9Sstevel@tonic-gate ulp->ul_sbowner = curthread; 10047c478bd9Sstevel@tonic-gate TRANS_SBWRITE(ufsvfsp, TOP_SBWRITE_STABLE); 10057c478bd9Sstevel@tonic-gate 10067c478bd9Sstevel@tonic-gate if (needs_unlock) 10077c478bd9Sstevel@tonic-gate mutex_enter(&ufsvfsp->vfs_lock); 10087c478bd9Sstevel@tonic-gate 10097c478bd9Sstevel@tonic-gate ufsvfsp->vfs_fs->fs_fmod = 0; 10107c478bd9Sstevel@tonic-gate 10117c478bd9Sstevel@tonic-gate if (needs_unlock) 10127c478bd9Sstevel@tonic-gate mutex_exit(&ufsvfsp->vfs_lock); 10137c478bd9Sstevel@tonic-gate } 10147c478bd9Sstevel@tonic-gate } 10157c478bd9Sstevel@tonic-gate 10167c478bd9Sstevel@tonic-gate /* 10177c478bd9Sstevel@tonic-gate * reconcile superblock and inodes if was wlocked 10187c478bd9Sstevel@tonic-gate */ 10197c478bd9Sstevel@tonic-gate if (LOCKFS_IS_WLOCK(&lfs) || LOCKFS_IS_ELOCK(&lfs)) { 10207c478bd9Sstevel@tonic-gate if (error = ufs_reconcile(vfsp, ufsvfsp, errlck)) 10217c478bd9Sstevel@tonic-gate goto errout; 10227c478bd9Sstevel@tonic-gate /* 10237c478bd9Sstevel@tonic-gate * in case the fs grew; reset the metadata map for logging tests 10247c478bd9Sstevel@tonic-gate */ 10257c478bd9Sstevel@tonic-gate TRANS_MATA_UMOUNT(ufsvfsp); 10267c478bd9Sstevel@tonic-gate TRANS_MATA_MOUNT(ufsvfsp); 10277c478bd9Sstevel@tonic-gate TRANS_MATA_SI(ufsvfsp, ufsvfsp->vfs_fs); 10287c478bd9Sstevel@tonic-gate } 10297c478bd9Sstevel@tonic-gate 10307c478bd9Sstevel@tonic-gate /* 10317c478bd9Sstevel@tonic-gate * At least everything *currently* dirty goes out. 10327c478bd9Sstevel@tonic-gate */ 10337c478bd9Sstevel@tonic-gate 10347c478bd9Sstevel@tonic-gate if ((error = ufs_flush(vfsp)) != 0 && !ULOCKFS_IS_HLOCK(ulp) && 10357c478bd9Sstevel@tonic-gate !ULOCKFS_IS_ELOCK(ulp)) 10367c478bd9Sstevel@tonic-gate goto errout; 10377c478bd9Sstevel@tonic-gate 10387c478bd9Sstevel@tonic-gate /* 10397c478bd9Sstevel@tonic-gate * thaw file system and wakeup pended processes 10407c478bd9Sstevel@tonic-gate */ 10417c478bd9Sstevel@tonic-gate if (error = ufs_thaw(vfsp, ufsvfsp, ulp)) 10427c478bd9Sstevel@tonic-gate if (!ULOCKFS_IS_HLOCK(ulp) && !ULOCKFS_IS_ELOCK(ulp)) 10437c478bd9Sstevel@tonic-gate goto errout; 10447c478bd9Sstevel@tonic-gate 10457c478bd9Sstevel@tonic-gate /* 10467c478bd9Sstevel@tonic-gate * reset modified flag if not already write locked 10477c478bd9Sstevel@tonic-gate */ 10487c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_WLOCK(&lfs)) 10497c478bd9Sstevel@tonic-gate ULOCKFS_CLR_MOD(ulp); 10507c478bd9Sstevel@tonic-gate 10517c478bd9Sstevel@tonic-gate /* 10527c478bd9Sstevel@tonic-gate * idle the lock struct 10537c478bd9Sstevel@tonic-gate */ 10547c478bd9Sstevel@tonic-gate ULOCKFS_CLR_BUSY(ulp); 10557c478bd9Sstevel@tonic-gate /* update the ioctl copy */ 10567c478bd9Sstevel@tonic-gate LOCKFS_CLR_BUSY(&ulp->ul_lockfs); 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate /* 10597c478bd9Sstevel@tonic-gate * free current comment 10607c478bd9Sstevel@tonic-gate */ 10617c478bd9Sstevel@tonic-gate if (lfs.lf_comment && lfs.lf_comlen != 0) { 10627c478bd9Sstevel@tonic-gate kmem_free(lfs.lf_comment, lfs.lf_comlen); 10637c478bd9Sstevel@tonic-gate lfs.lf_comment = NULL; 10647c478bd9Sstevel@tonic-gate lfs.lf_comlen = 0; 10657c478bd9Sstevel@tonic-gate } 10667c478bd9Sstevel@tonic-gate 10677c478bd9Sstevel@tonic-gate /* do error lock cleanup */ 10687c478bd9Sstevel@tonic-gate if (errlck == UN_ERRLCK) 10697c478bd9Sstevel@tonic-gate ufsfx_unlockfs(ufsvfsp); 10707c478bd9Sstevel@tonic-gate 10717c478bd9Sstevel@tonic-gate else if (errlck == RE_ERRLCK) 10727c478bd9Sstevel@tonic-gate ufsfx_lockfs(ufsvfsp); 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate /* don't allow error lock from user to invoke panic */ 10757c478bd9Sstevel@tonic-gate else if (from_user && errlck == SET_ERRLCK && 10767c478bd9Sstevel@tonic-gate !(ufsvfsp->vfs_fsfx.fx_flags & (UFSMNT_ONERROR_PANIC >> 4))) 10777c478bd9Sstevel@tonic-gate (void) ufs_fault(ufsvfsp->vfs_root, 10787c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comment && ulp->ul_lockfs.lf_comlen > 0 ? 10797c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comment: "user-applied error lock"); 10807c478bd9Sstevel@tonic-gate 1081bc69f433Saguzovsk atomic_add_long(&ufs_quiesce_pend, -1); 10827c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 10837c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 10847c478bd9Sstevel@tonic-gate 10857c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(&ufsvfsp->vfs_ulockfs)) 10867c478bd9Sstevel@tonic-gate poll_events |= POLLERR; 10877c478bd9Sstevel@tonic-gate 10887c478bd9Sstevel@tonic-gate pollwakeup(&ufs_pollhd, poll_events); 10897c478bd9Sstevel@tonic-gate 10907c478bd9Sstevel@tonic-gate /* 10917c478bd9Sstevel@tonic-gate * Allow both the delete thread and the reclaim thread to 10927c478bd9Sstevel@tonic-gate * continue. 10937c478bd9Sstevel@tonic-gate */ 10947c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_delete); 10957c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_reclaim); 10967c478bd9Sstevel@tonic-gate 10977c478bd9Sstevel@tonic-gate return (0); 10987c478bd9Sstevel@tonic-gate 10997c478bd9Sstevel@tonic-gate errout: 11007c478bd9Sstevel@tonic-gate /* 11017c478bd9Sstevel@tonic-gate * Lock failed. Reset the old lock in ufsvfs if not hard locked. 11027c478bd9Sstevel@tonic-gate */ 11037c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_HLOCK(&ulp->ul_lockfs)) { 11047c478bd9Sstevel@tonic-gate bcopy(&lfs, &ulp->ul_lockfs, sizeof (struct lockfs)); 11057c478bd9Sstevel@tonic-gate ulp->ul_fs_lock = (1 << lfs.lf_lock); 11067c478bd9Sstevel@tonic-gate } 11077c478bd9Sstevel@tonic-gate (void) ufs_thaw(vfsp, ufsvfsp, ulp); 11087c478bd9Sstevel@tonic-gate ULOCKFS_CLR_BUSY(ulp); 11097c478bd9Sstevel@tonic-gate LOCKFS_CLR_BUSY(&ulp->ul_lockfs); 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate errexit: 1112bc69f433Saguzovsk atomic_add_long(&ufs_quiesce_pend, -1); 11137c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 11147c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 11157c478bd9Sstevel@tonic-gate 11167c478bd9Sstevel@tonic-gate /* 11177c478bd9Sstevel@tonic-gate * Allow both the delete thread and the reclaim thread to 11187c478bd9Sstevel@tonic-gate * continue. 11197c478bd9Sstevel@tonic-gate */ 11207c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_delete); 11217c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_reclaim); 11227c478bd9Sstevel@tonic-gate 11237c478bd9Sstevel@tonic-gate return (error); 11247c478bd9Sstevel@tonic-gate } 11257c478bd9Sstevel@tonic-gate 11267c478bd9Sstevel@tonic-gate /* 11277c478bd9Sstevel@tonic-gate * fiolfss 11287c478bd9Sstevel@tonic-gate * return the current file system locking state info 11297c478bd9Sstevel@tonic-gate */ 11307c478bd9Sstevel@tonic-gate int 11317c478bd9Sstevel@tonic-gate ufs_fiolfss(struct vnode *vp, struct lockfs *lockfsp) 11327c478bd9Sstevel@tonic-gate { 11337c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 11347c478bd9Sstevel@tonic-gate 11357c478bd9Sstevel@tonic-gate if (!vp || !vp->v_vfsp || !VTOI(vp)) 11367c478bd9Sstevel@tonic-gate return (EINVAL); 11377c478bd9Sstevel@tonic-gate 11387c478bd9Sstevel@tonic-gate /* file system has been forcibly unmounted */ 11397c478bd9Sstevel@tonic-gate if (VTOI(vp)->i_ufsvfs == NULL) 11407c478bd9Sstevel@tonic-gate return (EIO); 11417c478bd9Sstevel@tonic-gate 11427c478bd9Sstevel@tonic-gate ulp = VTOUL(vp); 11437c478bd9Sstevel@tonic-gate 11447c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(ulp)) { 11457c478bd9Sstevel@tonic-gate *lockfsp = ulp->ul_lockfs; /* structure assignment */ 11467c478bd9Sstevel@tonic-gate return (0); 11477c478bd9Sstevel@tonic-gate } 11487c478bd9Sstevel@tonic-gate 11497c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 11507c478bd9Sstevel@tonic-gate 11517c478bd9Sstevel@tonic-gate *lockfsp = ulp->ul_lockfs; /* structure assignment */ 11527c478bd9Sstevel@tonic-gate 11537c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_MOD(ulp)) 11547c478bd9Sstevel@tonic-gate lockfsp->lf_flags |= LOCKFS_MOD; 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 11577c478bd9Sstevel@tonic-gate 11587c478bd9Sstevel@tonic-gate return (0); 11597c478bd9Sstevel@tonic-gate } 11607c478bd9Sstevel@tonic-gate 11617c478bd9Sstevel@tonic-gate /* 11627c478bd9Sstevel@tonic-gate * ufs_check_lockfs 11637c478bd9Sstevel@tonic-gate * check whether a ufs_vnops conflicts with the file system lock 11647c478bd9Sstevel@tonic-gate */ 11657c478bd9Sstevel@tonic-gate int 11667c478bd9Sstevel@tonic-gate ufs_check_lockfs(struct ufsvfs *ufsvfsp, struct ulockfs *ulp, ulong_t mask) 11677c478bd9Sstevel@tonic-gate { 11687c478bd9Sstevel@tonic-gate k_sigset_t smask; 11697c478bd9Sstevel@tonic-gate int sig, slock; 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&ulp->ul_lock)); 11727c478bd9Sstevel@tonic-gate 11737c478bd9Sstevel@tonic-gate while (ulp->ul_fs_lock & mask) { 11747c478bd9Sstevel@tonic-gate slock = (int)ULOCKFS_IS_SLOCK(ulp); 11757c478bd9Sstevel@tonic-gate if ((curthread->t_flag & T_DONTPEND) && !slock) { 11767c478bd9Sstevel@tonic-gate curthread->t_flag |= T_WOULDBLOCK; 11777c478bd9Sstevel@tonic-gate return (EAGAIN); 11787c478bd9Sstevel@tonic-gate } 11797c478bd9Sstevel@tonic-gate curthread->t_flag &= ~T_WOULDBLOCK; 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(ulp)) 11827c478bd9Sstevel@tonic-gate return (EIO); 11837c478bd9Sstevel@tonic-gate 11847c478bd9Sstevel@tonic-gate /* 11857c478bd9Sstevel@tonic-gate * wait for lock status to change 11867c478bd9Sstevel@tonic-gate */ 11877c478bd9Sstevel@tonic-gate if (slock || ufsvfsp->vfs_nointr) { 11887c478bd9Sstevel@tonic-gate cv_wait(&ulp->ul_cv, &ulp->ul_lock); 11897c478bd9Sstevel@tonic-gate } else { 11907c478bd9Sstevel@tonic-gate sigintr(&smask, 1); 11917c478bd9Sstevel@tonic-gate sig = cv_wait_sig(&ulp->ul_cv, &ulp->ul_lock); 11927c478bd9Sstevel@tonic-gate sigunintr(&smask); 11937c478bd9Sstevel@tonic-gate if ((!sig && (ulp->ul_fs_lock & mask)) || 11947c478bd9Sstevel@tonic-gate ufsvfsp->vfs_dontblock) 11957c478bd9Sstevel@tonic-gate return (EINTR); 11967c478bd9Sstevel@tonic-gate } 11977c478bd9Sstevel@tonic-gate } 1198bc69f433Saguzovsk atomic_add_long(&ulp->ul_vnops_cnt, 1); 11997c478bd9Sstevel@tonic-gate return (0); 12007c478bd9Sstevel@tonic-gate } 12017c478bd9Sstevel@tonic-gate 12027c478bd9Sstevel@tonic-gate /* 12037c478bd9Sstevel@tonic-gate * Check whether we came across the handcrafted lockfs protocol path. We can't 12047c478bd9Sstevel@tonic-gate * simply check for T_DONTBLOCK here as one would assume since this can also 12057c478bd9Sstevel@tonic-gate * falsely catch recursive VOP's going to a different filesystem, instead we 12067c478bd9Sstevel@tonic-gate * check if we already hold the ulockfs->ul_lock mutex. 12077c478bd9Sstevel@tonic-gate */ 12087c478bd9Sstevel@tonic-gate static int 12097c478bd9Sstevel@tonic-gate ufs_lockfs_is_under_rawlockfs(struct ulockfs *ulp) 12107c478bd9Sstevel@tonic-gate { 12117c478bd9Sstevel@tonic-gate return ((mutex_owner(&ulp->ul_lock) != curthread) ? 0 : 1); 12127c478bd9Sstevel@tonic-gate } 12137c478bd9Sstevel@tonic-gate 12147c478bd9Sstevel@tonic-gate /* 12157c478bd9Sstevel@tonic-gate * ufs_lockfs_begin - start the lockfs locking protocol 12167c478bd9Sstevel@tonic-gate */ 12177c478bd9Sstevel@tonic-gate int 12187c478bd9Sstevel@tonic-gate ufs_lockfs_begin(struct ufsvfs *ufsvfsp, struct ulockfs **ulpp, ulong_t mask) 12197c478bd9Sstevel@tonic-gate { 12207c478bd9Sstevel@tonic-gate int error; 12217c478bd9Sstevel@tonic-gate int rec_vop; 12227c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 12237c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info; 12247c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_free; 12257c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_temp; 12267c478bd9Sstevel@tonic-gate 12277c478bd9Sstevel@tonic-gate /* 12287c478bd9Sstevel@tonic-gate * file system has been forcibly unmounted 12297c478bd9Sstevel@tonic-gate */ 12307c478bd9Sstevel@tonic-gate if (ufsvfsp == NULL) 12317c478bd9Sstevel@tonic-gate return (EIO); 12327c478bd9Sstevel@tonic-gate 12337c478bd9Sstevel@tonic-gate *ulpp = ulp = &ufsvfsp->vfs_ulockfs; 12347c478bd9Sstevel@tonic-gate 12357c478bd9Sstevel@tonic-gate /* 12367c478bd9Sstevel@tonic-gate * Do lockfs protocol 12377c478bd9Sstevel@tonic-gate */ 12387c478bd9Sstevel@tonic-gate ulockfs_info = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 12397c478bd9Sstevel@tonic-gate IS_REC_VOP(rec_vop, ulockfs_info, ulp, ulockfs_info_free); 12407c478bd9Sstevel@tonic-gate 12417c478bd9Sstevel@tonic-gate /* 12427c478bd9Sstevel@tonic-gate * Detect recursive VOP call or handcrafted internal lockfs protocol 12437c478bd9Sstevel@tonic-gate * path and bail out in that case. 12447c478bd9Sstevel@tonic-gate */ 12457c478bd9Sstevel@tonic-gate if (rec_vop || ufs_lockfs_is_under_rawlockfs(ulp)) { 12467c478bd9Sstevel@tonic-gate *ulpp = NULL; 12477c478bd9Sstevel@tonic-gate return (0); 12487c478bd9Sstevel@tonic-gate } else { 12497c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) { 12507c478bd9Sstevel@tonic-gate if ((ulockfs_info_temp = (ulockfs_info_t *) 12517c478bd9Sstevel@tonic-gate kmem_zalloc(sizeof (ulockfs_info_t), 12527c478bd9Sstevel@tonic-gate KM_NOSLEEP)) == NULL) { 12537c478bd9Sstevel@tonic-gate *ulpp = NULL; 12547c478bd9Sstevel@tonic-gate return (ENOMEM); 12557c478bd9Sstevel@tonic-gate } 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate } 12587c478bd9Sstevel@tonic-gate 12597c478bd9Sstevel@tonic-gate /* 12607c478bd9Sstevel@tonic-gate * First time VOP call 12617c478bd9Sstevel@tonic-gate */ 12627c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 12637c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_JUSTULOCK(ulp)) 1264bc69f433Saguzovsk atomic_add_long(&ulp->ul_vnops_cnt, 1); 12657c478bd9Sstevel@tonic-gate else { 12667c478bd9Sstevel@tonic-gate if (error = ufs_check_lockfs(ufsvfsp, ulp, mask)) { 12677c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 12687c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) 12697c478bd9Sstevel@tonic-gate kmem_free(ulockfs_info_temp, 12707c478bd9Sstevel@tonic-gate sizeof (ulockfs_info_t)); 12717c478bd9Sstevel@tonic-gate return (error); 12727c478bd9Sstevel@tonic-gate } 12737c478bd9Sstevel@tonic-gate } 12747c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate if (ulockfs_info_free != NULL) { 12777c478bd9Sstevel@tonic-gate ulockfs_info_free->ulp = ulp; 12787c478bd9Sstevel@tonic-gate } else { 12797c478bd9Sstevel@tonic-gate ulockfs_info_temp->ulp = ulp; 12807c478bd9Sstevel@tonic-gate ulockfs_info_temp->next = ulockfs_info; 12817c478bd9Sstevel@tonic-gate ASSERT(ufs_lockfs_key != 0); 12827c478bd9Sstevel@tonic-gate (void) tsd_set(ufs_lockfs_key, (void *)ulockfs_info_temp); 12837c478bd9Sstevel@tonic-gate } 12847c478bd9Sstevel@tonic-gate 12857c478bd9Sstevel@tonic-gate curthread->t_flag |= T_DONTBLOCK; 12867c478bd9Sstevel@tonic-gate return (0); 12877c478bd9Sstevel@tonic-gate } 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate /* 12907c478bd9Sstevel@tonic-gate * Check whether we are returning from the top level VOP. 12917c478bd9Sstevel@tonic-gate */ 12927c478bd9Sstevel@tonic-gate static int 12937c478bd9Sstevel@tonic-gate ufs_lockfs_top_vop_return(ulockfs_info_t *head) 12947c478bd9Sstevel@tonic-gate { 12957c478bd9Sstevel@tonic-gate ulockfs_info_t *info; 12967c478bd9Sstevel@tonic-gate int result = 1; 12977c478bd9Sstevel@tonic-gate 12987c478bd9Sstevel@tonic-gate for (info = head; info != NULL; info = info->next) { 12997c478bd9Sstevel@tonic-gate if (info->ulp != NULL) { 13007c478bd9Sstevel@tonic-gate result = 0; 13017c478bd9Sstevel@tonic-gate break; 13027c478bd9Sstevel@tonic-gate } 13037c478bd9Sstevel@tonic-gate } 13047c478bd9Sstevel@tonic-gate 13057c478bd9Sstevel@tonic-gate return (result); 13067c478bd9Sstevel@tonic-gate } 13077c478bd9Sstevel@tonic-gate 13087c478bd9Sstevel@tonic-gate /* 13097c478bd9Sstevel@tonic-gate * ufs_lockfs_end - terminate the lockfs locking protocol 13107c478bd9Sstevel@tonic-gate */ 13117c478bd9Sstevel@tonic-gate void 13127c478bd9Sstevel@tonic-gate ufs_lockfs_end(struct ulockfs *ulp) 13137c478bd9Sstevel@tonic-gate { 13147c478bd9Sstevel@tonic-gate ulockfs_info_t *info; 13157c478bd9Sstevel@tonic-gate ulockfs_info_t *head; 13167c478bd9Sstevel@tonic-gate 13177c478bd9Sstevel@tonic-gate /* 13187c478bd9Sstevel@tonic-gate * end-of-VOP protocol 13197c478bd9Sstevel@tonic-gate */ 13207c478bd9Sstevel@tonic-gate if (ulp == NULL) 13217c478bd9Sstevel@tonic-gate return; 13227c478bd9Sstevel@tonic-gate 13237c478bd9Sstevel@tonic-gate head = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 13247c478bd9Sstevel@tonic-gate SEARCH_ULOCKFSP(head, ulp, info); 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate /* 13277c478bd9Sstevel@tonic-gate * If we're called from a first level VOP, we have to have a 13287c478bd9Sstevel@tonic-gate * valid ulockfs record in the TSD. 13297c478bd9Sstevel@tonic-gate */ 13307c478bd9Sstevel@tonic-gate ASSERT(info != NULL); 13317c478bd9Sstevel@tonic-gate 13327c478bd9Sstevel@tonic-gate /* 13337c478bd9Sstevel@tonic-gate * Invalidate the ulockfs record. 13347c478bd9Sstevel@tonic-gate */ 13357c478bd9Sstevel@tonic-gate info->ulp = NULL; 13367c478bd9Sstevel@tonic-gate 13377c478bd9Sstevel@tonic-gate if (ufs_lockfs_top_vop_return(head)) 13387c478bd9Sstevel@tonic-gate curthread->t_flag &= ~T_DONTBLOCK; 13397c478bd9Sstevel@tonic-gate 13407c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 13417c478bd9Sstevel@tonic-gate 1342bc69f433Saguzovsk if (!atomic_add_long_nv(&ulp->ul_vnops_cnt, -1)) 13437c478bd9Sstevel@tonic-gate cv_broadcast(&ulp->ul_cv); 13447c478bd9Sstevel@tonic-gate 13457c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 13467c478bd9Sstevel@tonic-gate } 13477c478bd9Sstevel@tonic-gate 13487c478bd9Sstevel@tonic-gate /* 13497c478bd9Sstevel@tonic-gate * specialized version of ufs_lockfs_begin() called by ufs_getpage(). 13507c478bd9Sstevel@tonic-gate */ 13517c478bd9Sstevel@tonic-gate int 13527c478bd9Sstevel@tonic-gate ufs_lockfs_begin_getpage( 13537c478bd9Sstevel@tonic-gate struct ufsvfs *ufsvfsp, 13547c478bd9Sstevel@tonic-gate struct ulockfs **ulpp, 13557c478bd9Sstevel@tonic-gate struct seg *seg, 13567c478bd9Sstevel@tonic-gate int read_access, 13577c478bd9Sstevel@tonic-gate uint_t *protp) 13587c478bd9Sstevel@tonic-gate { 13597c478bd9Sstevel@tonic-gate ulong_t mask; 13607c478bd9Sstevel@tonic-gate int error; 13617c478bd9Sstevel@tonic-gate int rec_vop; 13627c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 13637c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info; 13647c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_free; 13657c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_temp; 13667c478bd9Sstevel@tonic-gate 13677c478bd9Sstevel@tonic-gate /* 13687c478bd9Sstevel@tonic-gate * file system has been forcibly unmounted 13697c478bd9Sstevel@tonic-gate */ 13707c478bd9Sstevel@tonic-gate if (ufsvfsp == NULL) 13717c478bd9Sstevel@tonic-gate return (EIO); 13727c478bd9Sstevel@tonic-gate 13737c478bd9Sstevel@tonic-gate *ulpp = ulp = &ufsvfsp->vfs_ulockfs; 13747c478bd9Sstevel@tonic-gate 13757c478bd9Sstevel@tonic-gate /* 13767c478bd9Sstevel@tonic-gate * Do lockfs protocol 13777c478bd9Sstevel@tonic-gate */ 13787c478bd9Sstevel@tonic-gate ulockfs_info = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 13797c478bd9Sstevel@tonic-gate IS_REC_VOP(rec_vop, ulockfs_info, ulp, ulockfs_info_free); 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate /* 13827c478bd9Sstevel@tonic-gate * Detect recursive VOP call or handcrafted internal lockfs protocol 13837c478bd9Sstevel@tonic-gate * path and bail out in that case. 13847c478bd9Sstevel@tonic-gate */ 13857c478bd9Sstevel@tonic-gate if (rec_vop || ufs_lockfs_is_under_rawlockfs(ulp)) { 13867c478bd9Sstevel@tonic-gate *ulpp = NULL; 13877c478bd9Sstevel@tonic-gate return (0); 13887c478bd9Sstevel@tonic-gate } else { 13897c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) { 13907c478bd9Sstevel@tonic-gate if ((ulockfs_info_temp = (ulockfs_info_t *) 13917c478bd9Sstevel@tonic-gate kmem_zalloc(sizeof (ulockfs_info_t), 13927c478bd9Sstevel@tonic-gate KM_NOSLEEP)) == NULL) { 13937c478bd9Sstevel@tonic-gate *ulpp = NULL; 13947c478bd9Sstevel@tonic-gate return (ENOMEM); 13957c478bd9Sstevel@tonic-gate } 13967c478bd9Sstevel@tonic-gate } 13977c478bd9Sstevel@tonic-gate } 13987c478bd9Sstevel@tonic-gate 13997c478bd9Sstevel@tonic-gate /* 14007c478bd9Sstevel@tonic-gate * First time VOP call 14017c478bd9Sstevel@tonic-gate */ 14027c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 14037c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_JUSTULOCK(ulp)) 14047c478bd9Sstevel@tonic-gate /* 14057c478bd9Sstevel@tonic-gate * fs is not locked, simply inc the active-ops counter 14067c478bd9Sstevel@tonic-gate */ 1407bc69f433Saguzovsk atomic_add_long(&ulp->ul_vnops_cnt, 1); 14087c478bd9Sstevel@tonic-gate else { 14097c478bd9Sstevel@tonic-gate if (seg->s_ops == &segvn_ops && 14107c478bd9Sstevel@tonic-gate ((struct segvn_data *)seg->s_data)->type != MAP_SHARED) { 14117c478bd9Sstevel@tonic-gate mask = (ulong_t)ULOCKFS_GETREAD_MASK; 14127c478bd9Sstevel@tonic-gate } else if (protp && read_access) { 14137c478bd9Sstevel@tonic-gate /* 14147c478bd9Sstevel@tonic-gate * Restrict the mapping to readonly. 14157c478bd9Sstevel@tonic-gate * Writes to this mapping will cause 14167c478bd9Sstevel@tonic-gate * another fault which will then 14177c478bd9Sstevel@tonic-gate * be suspended if fs is write locked 14187c478bd9Sstevel@tonic-gate */ 14197c478bd9Sstevel@tonic-gate *protp &= ~PROT_WRITE; 14207c478bd9Sstevel@tonic-gate mask = (ulong_t)ULOCKFS_GETREAD_MASK; 14217c478bd9Sstevel@tonic-gate } else 14227c478bd9Sstevel@tonic-gate mask = (ulong_t)ULOCKFS_GETWRITE_MASK; 14237c478bd9Sstevel@tonic-gate 14247c478bd9Sstevel@tonic-gate /* 14257c478bd9Sstevel@tonic-gate * will sleep if this fs is locked against this VOP 14267c478bd9Sstevel@tonic-gate */ 14277c478bd9Sstevel@tonic-gate if (error = ufs_check_lockfs(ufsvfsp, ulp, mask)) { 14287c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 14297c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) 14307c478bd9Sstevel@tonic-gate kmem_free(ulockfs_info_temp, 14317c478bd9Sstevel@tonic-gate sizeof (ulockfs_info_t)); 14327c478bd9Sstevel@tonic-gate return (error); 14337c478bd9Sstevel@tonic-gate } 14347c478bd9Sstevel@tonic-gate } 14357c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 14367c478bd9Sstevel@tonic-gate 14377c478bd9Sstevel@tonic-gate if (ulockfs_info_free != NULL) { 14387c478bd9Sstevel@tonic-gate ulockfs_info_free->ulp = ulp; 14397c478bd9Sstevel@tonic-gate } else { 14407c478bd9Sstevel@tonic-gate ulockfs_info_temp->ulp = ulp; 14417c478bd9Sstevel@tonic-gate ulockfs_info_temp->next = ulockfs_info; 14427c478bd9Sstevel@tonic-gate ASSERT(ufs_lockfs_key != 0); 14437c478bd9Sstevel@tonic-gate (void) tsd_set(ufs_lockfs_key, (void *)ulockfs_info_temp); 14447c478bd9Sstevel@tonic-gate } 14457c478bd9Sstevel@tonic-gate 14467c478bd9Sstevel@tonic-gate curthread->t_flag |= T_DONTBLOCK; 14477c478bd9Sstevel@tonic-gate return (0); 14487c478bd9Sstevel@tonic-gate } 14497c478bd9Sstevel@tonic-gate 14507c478bd9Sstevel@tonic-gate void 14517c478bd9Sstevel@tonic-gate ufs_lockfs_tsd_destructor(void *head) 14527c478bd9Sstevel@tonic-gate { 14537c478bd9Sstevel@tonic-gate ulockfs_info_t *curr = (ulockfs_info_t *)head; 14547c478bd9Sstevel@tonic-gate ulockfs_info_t *temp; 14557c478bd9Sstevel@tonic-gate 14567c478bd9Sstevel@tonic-gate for (; curr != NULL; ) { 14577c478bd9Sstevel@tonic-gate /* 14587c478bd9Sstevel@tonic-gate * The TSD destructor is being called when the thread exits 14597c478bd9Sstevel@tonic-gate * (via thread_exit()). At that time it must have cleaned up 14607c478bd9Sstevel@tonic-gate * all VOPs via ufs_lockfs_end() and there must not be a 14617c478bd9Sstevel@tonic-gate * valid ulockfs record exist while a thread is exiting. 14627c478bd9Sstevel@tonic-gate */ 14637c478bd9Sstevel@tonic-gate temp = curr; 14647c478bd9Sstevel@tonic-gate curr = curr->next; 14657c478bd9Sstevel@tonic-gate ASSERT(temp->ulp == NULL); 14667c478bd9Sstevel@tonic-gate kmem_free(temp, sizeof (ulockfs_info_t)); 14677c478bd9Sstevel@tonic-gate } 14687c478bd9Sstevel@tonic-gate } 1469