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 566c9f83dSowenr * Common Development and Distribution License (the "License"). 666c9f83dSowenr * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22*46ac4468Smishra * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate #include <sys/types.h> 297c478bd9Sstevel@tonic-gate #include <sys/t_lock.h> 307c478bd9Sstevel@tonic-gate #include <sys/param.h> 317c478bd9Sstevel@tonic-gate #include <sys/time.h> 327c478bd9Sstevel@tonic-gate #include <sys/systm.h> 337c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 347c478bd9Sstevel@tonic-gate #include <sys/resource.h> 357c478bd9Sstevel@tonic-gate #include <sys/signal.h> 367c478bd9Sstevel@tonic-gate #include <sys/cred.h> 377c478bd9Sstevel@tonic-gate #include <sys/user.h> 387c478bd9Sstevel@tonic-gate #include <sys/buf.h> 397c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 407c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 417c478bd9Sstevel@tonic-gate #include <sys/proc.h> 427c478bd9Sstevel@tonic-gate #include <sys/disp.h> 437c478bd9Sstevel@tonic-gate #include <sys/file.h> 447c478bd9Sstevel@tonic-gate #include <sys/fcntl.h> 457c478bd9Sstevel@tonic-gate #include <sys/flock.h> 46bc69f433Saguzovsk #include <sys/atomic.h> 477c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 487c478bd9Sstevel@tonic-gate #include <sys/uio.h> 497c478bd9Sstevel@tonic-gate #include <sys/conf.h> 507c478bd9Sstevel@tonic-gate #include <sys/mman.h> 517c478bd9Sstevel@tonic-gate #include <sys/pathname.h> 527c478bd9Sstevel@tonic-gate #include <sys/debug.h> 537c478bd9Sstevel@tonic-gate #include <sys/vmmeter.h> 547c478bd9Sstevel@tonic-gate #include <sys/vmsystm.h> 557c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 567c478bd9Sstevel@tonic-gate #include <sys/vtrace.h> 577c478bd9Sstevel@tonic-gate #include <sys/acct.h> 587c478bd9Sstevel@tonic-gate #include <sys/dnlc.h> 597c478bd9Sstevel@tonic-gate #include <sys/swap.h> 607c478bd9Sstevel@tonic-gate 617c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_fs.h> 627c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_inode.h> 637c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_fsdir.h> 647c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_trans.h> 657c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_panic.h> 667c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_mount.h> 677c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_bio.h> 687c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_log.h> 697c478bd9Sstevel@tonic-gate #include <sys/fs/ufs_quota.h> 707c478bd9Sstevel@tonic-gate #include <sys/dirent.h> /* must be AFTER <sys/fs/fsdir.h>! */ 717c478bd9Sstevel@tonic-gate #include <sys/errno.h> 727c478bd9Sstevel@tonic-gate #include <sys/sysinfo.h> 737c478bd9Sstevel@tonic-gate 747c478bd9Sstevel@tonic-gate #include <vm/hat.h> 757c478bd9Sstevel@tonic-gate #include <vm/pvn.h> 767c478bd9Sstevel@tonic-gate #include <vm/as.h> 777c478bd9Sstevel@tonic-gate #include <vm/seg.h> 787c478bd9Sstevel@tonic-gate #include <vm/seg_map.h> 797c478bd9Sstevel@tonic-gate #include <vm/seg_vn.h> 807c478bd9Sstevel@tonic-gate #include <vm/rm.h> 817c478bd9Sstevel@tonic-gate #include <vm/anon.h> 827c478bd9Sstevel@tonic-gate #include <sys/swap.h> 837c478bd9Sstevel@tonic-gate #include <sys/dnlc.h> 847c478bd9Sstevel@tonic-gate 857c478bd9Sstevel@tonic-gate extern struct vnode *common_specvp(struct vnode *vp); 867c478bd9Sstevel@tonic-gate 877c478bd9Sstevel@tonic-gate /* error lock status */ 887c478bd9Sstevel@tonic-gate #define UN_ERRLCK (-1) 897c478bd9Sstevel@tonic-gate #define SET_ERRLCK 1 907c478bd9Sstevel@tonic-gate #define RE_ERRLCK 2 917c478bd9Sstevel@tonic-gate #define NO_ERRLCK 0 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate /* 947c478bd9Sstevel@tonic-gate * Index to be used in TSD for storing lockfs data 957c478bd9Sstevel@tonic-gate */ 967c478bd9Sstevel@tonic-gate uint_t ufs_lockfs_key; 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate typedef struct _ulockfs_info { 997c478bd9Sstevel@tonic-gate struct _ulockfs_info *next; 1007c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 101303bf60bSsdebnath uint_t flags; 1027c478bd9Sstevel@tonic-gate } ulockfs_info_t; 1037c478bd9Sstevel@tonic-gate 104303bf60bSsdebnath #define ULOCK_INFO_FALLOCATE 0x00000001 /* fallocate thread */ 105303bf60bSsdebnath 1067c478bd9Sstevel@tonic-gate /* 1077c478bd9Sstevel@tonic-gate * Check in TSD that whether we are already doing any VOP on this filesystem 1087c478bd9Sstevel@tonic-gate */ 1097c478bd9Sstevel@tonic-gate #define IS_REC_VOP(found, head, ulp, free) \ 1107c478bd9Sstevel@tonic-gate { \ 1117c478bd9Sstevel@tonic-gate ulockfs_info_t *_curr; \ 1127c478bd9Sstevel@tonic-gate \ 1137c478bd9Sstevel@tonic-gate for (found = 0, free = NULL, _curr = head; \ 1147c478bd9Sstevel@tonic-gate _curr != NULL; _curr = _curr->next) { \ 1157c478bd9Sstevel@tonic-gate if ((free == NULL) && \ 1167c478bd9Sstevel@tonic-gate (_curr->ulp == NULL)) \ 1177c478bd9Sstevel@tonic-gate free = _curr; \ 1187c478bd9Sstevel@tonic-gate if (_curr->ulp == ulp) { \ 1197c478bd9Sstevel@tonic-gate found = 1; \ 1207c478bd9Sstevel@tonic-gate break; \ 1217c478bd9Sstevel@tonic-gate } \ 1227c478bd9Sstevel@tonic-gate } \ 1237c478bd9Sstevel@tonic-gate } 1247c478bd9Sstevel@tonic-gate 1257c478bd9Sstevel@tonic-gate /* 1267c478bd9Sstevel@tonic-gate * Get the lockfs data from TSD so that lockfs handles the recursive VOP 1277c478bd9Sstevel@tonic-gate * properly 1287c478bd9Sstevel@tonic-gate */ 1297c478bd9Sstevel@tonic-gate #define SEARCH_ULOCKFSP(head, ulp, info) \ 1307c478bd9Sstevel@tonic-gate { \ 1317c478bd9Sstevel@tonic-gate ulockfs_info_t *_curr; \ 1327c478bd9Sstevel@tonic-gate \ 1337c478bd9Sstevel@tonic-gate for (_curr = head; _curr != NULL; \ 1347c478bd9Sstevel@tonic-gate _curr = _curr->next) { \ 1357c478bd9Sstevel@tonic-gate if (_curr->ulp == ulp) { \ 1367c478bd9Sstevel@tonic-gate break; \ 1377c478bd9Sstevel@tonic-gate } \ 1387c478bd9Sstevel@tonic-gate } \ 1397c478bd9Sstevel@tonic-gate \ 1407c478bd9Sstevel@tonic-gate info = _curr; \ 1417c478bd9Sstevel@tonic-gate } 1427c478bd9Sstevel@tonic-gate 1437c478bd9Sstevel@tonic-gate /* 1447c478bd9Sstevel@tonic-gate * Validate lockfs request 1457c478bd9Sstevel@tonic-gate */ 1467c478bd9Sstevel@tonic-gate static int 1477c478bd9Sstevel@tonic-gate ufs_getlfd( 1487c478bd9Sstevel@tonic-gate struct lockfs *lockfsp, /* new lock request */ 1497c478bd9Sstevel@tonic-gate struct lockfs *ul_lockfsp) /* old lock state */ 1507c478bd9Sstevel@tonic-gate { 1517c478bd9Sstevel@tonic-gate int error = 0; 1527c478bd9Sstevel@tonic-gate 1537c478bd9Sstevel@tonic-gate /* 1547c478bd9Sstevel@tonic-gate * no input flags defined 1557c478bd9Sstevel@tonic-gate */ 1567c478bd9Sstevel@tonic-gate if (lockfsp->lf_flags != 0) { 1577c478bd9Sstevel@tonic-gate error = EINVAL; 1587c478bd9Sstevel@tonic-gate goto errout; 1597c478bd9Sstevel@tonic-gate } 1607c478bd9Sstevel@tonic-gate 1617c478bd9Sstevel@tonic-gate /* 1627c478bd9Sstevel@tonic-gate * check key 1637c478bd9Sstevel@tonic-gate */ 1647c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_ULOCK(ul_lockfsp)) 1657c478bd9Sstevel@tonic-gate if (lockfsp->lf_key != ul_lockfsp->lf_key) { 1667c478bd9Sstevel@tonic-gate error = EINVAL; 1677c478bd9Sstevel@tonic-gate goto errout; 1687c478bd9Sstevel@tonic-gate } 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate lockfsp->lf_key = ul_lockfsp->lf_key + 1; 1717c478bd9Sstevel@tonic-gate 1727c478bd9Sstevel@tonic-gate errout: 1737c478bd9Sstevel@tonic-gate return (error); 1747c478bd9Sstevel@tonic-gate } 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate /* 1777c478bd9Sstevel@tonic-gate * ufs_checkaccton 1787c478bd9Sstevel@tonic-gate * check if accounting is turned on on this fs 1797c478bd9Sstevel@tonic-gate */ 1807c478bd9Sstevel@tonic-gate 1817c478bd9Sstevel@tonic-gate int 1827c478bd9Sstevel@tonic-gate ufs_checkaccton(struct vnode *vp) 1837c478bd9Sstevel@tonic-gate { 1847c478bd9Sstevel@tonic-gate if (acct_fs_in_use(vp)) 1857c478bd9Sstevel@tonic-gate return (EDEADLK); 1867c478bd9Sstevel@tonic-gate return (0); 1877c478bd9Sstevel@tonic-gate } 1887c478bd9Sstevel@tonic-gate 1897c478bd9Sstevel@tonic-gate /* 1907c478bd9Sstevel@tonic-gate * ufs_checkswapon 1917c478bd9Sstevel@tonic-gate * check if local swapping is to file on this fs 1927c478bd9Sstevel@tonic-gate */ 1937c478bd9Sstevel@tonic-gate int 1947c478bd9Sstevel@tonic-gate ufs_checkswapon(struct vnode *vp) 1957c478bd9Sstevel@tonic-gate { 1967c478bd9Sstevel@tonic-gate struct swapinfo *sip; 1977c478bd9Sstevel@tonic-gate 1987c478bd9Sstevel@tonic-gate mutex_enter(&swapinfo_lock); 1997c478bd9Sstevel@tonic-gate for (sip = swapinfo; sip; sip = sip->si_next) 2007c478bd9Sstevel@tonic-gate if (sip->si_vp->v_vfsp == vp->v_vfsp) { 2017c478bd9Sstevel@tonic-gate mutex_exit(&swapinfo_lock); 2027c478bd9Sstevel@tonic-gate return (EDEADLK); 2037c478bd9Sstevel@tonic-gate } 2047c478bd9Sstevel@tonic-gate mutex_exit(&swapinfo_lock); 2057c478bd9Sstevel@tonic-gate return (0); 2067c478bd9Sstevel@tonic-gate } 2077c478bd9Sstevel@tonic-gate 2087c478bd9Sstevel@tonic-gate /* 2097c478bd9Sstevel@tonic-gate * ufs_freeze 2107c478bd9Sstevel@tonic-gate * pend future accesses for current lock and desired lock 2117c478bd9Sstevel@tonic-gate */ 2127c478bd9Sstevel@tonic-gate void 2137c478bd9Sstevel@tonic-gate ufs_freeze(struct ulockfs *ulp, struct lockfs *lockfsp) 2147c478bd9Sstevel@tonic-gate { 2157c478bd9Sstevel@tonic-gate /* 2167c478bd9Sstevel@tonic-gate * set to new lock type 2177c478bd9Sstevel@tonic-gate */ 2187c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_lock = lockfsp->lf_lock; 2197c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_key = lockfsp->lf_key; 2207c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comlen = lockfsp->lf_comlen; 2217c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comment = lockfsp->lf_comment; 2227c478bd9Sstevel@tonic-gate 2237c478bd9Sstevel@tonic-gate ulp->ul_fs_lock = (1 << ulp->ul_lockfs.lf_lock); 2247c478bd9Sstevel@tonic-gate } 2257c478bd9Sstevel@tonic-gate 226bc69f433Saguzovsk /* 227bc69f433Saguzovsk * All callers of ufs_quiesce() atomically increment ufs_quiesce_pend before 228bc69f433Saguzovsk * starting ufs_quiesce() protocol and decrement it only when a file system no 229bc69f433Saguzovsk * longer has to be in quiescent state. This allows ufs_pageio() to detect 230bc69f433Saguzovsk * that another thread wants to quiesce a file system. See more comments in 231bc69f433Saguzovsk * ufs_pageio(). 232bc69f433Saguzovsk */ 233bc69f433Saguzovsk ulong_t ufs_quiesce_pend = 0; 234bc69f433Saguzovsk 2357c478bd9Sstevel@tonic-gate /* 2367c478bd9Sstevel@tonic-gate * ufs_quiesce 2377c478bd9Sstevel@tonic-gate * wait for outstanding accesses to finish 2387c478bd9Sstevel@tonic-gate */ 2397c478bd9Sstevel@tonic-gate int 2407c478bd9Sstevel@tonic-gate ufs_quiesce(struct ulockfs *ulp) 2417c478bd9Sstevel@tonic-gate { 2427c478bd9Sstevel@tonic-gate int error = 0; 243303bf60bSsdebnath ulockfs_info_t *head; 244303bf60bSsdebnath ulockfs_info_t *info; 245303bf60bSsdebnath 246303bf60bSsdebnath head = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 247303bf60bSsdebnath SEARCH_ULOCKFSP(head, ulp, info); 2487c478bd9Sstevel@tonic-gate 2497c478bd9Sstevel@tonic-gate /* 2507c478bd9Sstevel@tonic-gate * Set a softlock to suspend future ufs_vnops so that 2517c478bd9Sstevel@tonic-gate * this lockfs request will not be starved 2527c478bd9Sstevel@tonic-gate */ 2537c478bd9Sstevel@tonic-gate ULOCKFS_SET_SLOCK(ulp); 254bc69f433Saguzovsk ASSERT(ufs_quiesce_pend); 2557c478bd9Sstevel@tonic-gate 2567c478bd9Sstevel@tonic-gate /* check if there is any outstanding ufs vnodeops calls */ 257303bf60bSsdebnath while (ulp->ul_vnops_cnt || ulp->ul_falloc_cnt) { 258bc69f433Saguzovsk /* 259bc69f433Saguzovsk * use timed version of cv_wait_sig() to make sure we don't 260bc69f433Saguzovsk * miss a wake up call from ufs_pageio() when it doesn't use 261bc69f433Saguzovsk * ul_lock. 262303bf60bSsdebnath * 263303bf60bSsdebnath * when a fallocate thread comes in, the only way it returns 264303bf60bSsdebnath * from this function is if there are no other vnode operations 265303bf60bSsdebnath * going on (remember fallocate threads are tracked using 266303bf60bSsdebnath * ul_falloc_cnt not ul_vnops_cnt), and another fallocate thread 267303bf60bSsdebnath * hasn't already grabbed the fs write lock. 268bc69f433Saguzovsk */ 269303bf60bSsdebnath if (info && (info->flags & ULOCK_INFO_FALLOCATE)) { 270303bf60bSsdebnath if (!ulp->ul_vnops_cnt && !ULOCKFS_IS_FWLOCK(ulp)) 271303bf60bSsdebnath goto out; 272303bf60bSsdebnath } 273bc69f433Saguzovsk if (!cv_timedwait_sig(&ulp->ul_cv, &ulp->ul_lock, lbolt + hz)) { 2747c478bd9Sstevel@tonic-gate error = EINTR; 2757c478bd9Sstevel@tonic-gate goto out; 2767c478bd9Sstevel@tonic-gate } 277303bf60bSsdebnath } 2787c478bd9Sstevel@tonic-gate 2797c478bd9Sstevel@tonic-gate out: 2807c478bd9Sstevel@tonic-gate /* 2817c478bd9Sstevel@tonic-gate * unlock the soft lock 2827c478bd9Sstevel@tonic-gate */ 2837c478bd9Sstevel@tonic-gate ULOCKFS_CLR_SLOCK(ulp); 2847c478bd9Sstevel@tonic-gate 2857c478bd9Sstevel@tonic-gate return (error); 2867c478bd9Sstevel@tonic-gate } 287303bf60bSsdebnath 2887c478bd9Sstevel@tonic-gate /* 2897c478bd9Sstevel@tonic-gate * ufs_flush_inode 2907c478bd9Sstevel@tonic-gate */ 2917c478bd9Sstevel@tonic-gate int 2927c478bd9Sstevel@tonic-gate ufs_flush_inode(struct inode *ip, void *arg) 2937c478bd9Sstevel@tonic-gate { 2947c478bd9Sstevel@tonic-gate int error; 2957c478bd9Sstevel@tonic-gate int saverror = 0; 2967c478bd9Sstevel@tonic-gate 2977c478bd9Sstevel@tonic-gate /* 2987c478bd9Sstevel@tonic-gate * wrong file system; keep looking 2997c478bd9Sstevel@tonic-gate */ 3007c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 3017c478bd9Sstevel@tonic-gate return (0); 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate /* 3047c478bd9Sstevel@tonic-gate * asynchronously push all the dirty pages 3057c478bd9Sstevel@tonic-gate */ 3067c478bd9Sstevel@tonic-gate if (((error = TRANS_SYNCIP(ip, B_ASYNC, 0, TOP_SYNCIP_FLUSHI)) != 0) && 3077c478bd9Sstevel@tonic-gate (error != EAGAIN)) 3087c478bd9Sstevel@tonic-gate saverror = error; 3097c478bd9Sstevel@tonic-gate /* 3107c478bd9Sstevel@tonic-gate * wait for io and discard all mappings 3117c478bd9Sstevel@tonic-gate */ 3127c478bd9Sstevel@tonic-gate if (error = TRANS_SYNCIP(ip, B_INVAL, 0, TOP_SYNCIP_FLUSHI)) 3137c478bd9Sstevel@tonic-gate saverror = error; 3147c478bd9Sstevel@tonic-gate 3157c478bd9Sstevel@tonic-gate if (ITOV(ip)->v_type == VDIR) { 3167c478bd9Sstevel@tonic-gate dnlc_dir_purge(&ip->i_danchor); 3177c478bd9Sstevel@tonic-gate } 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate return (saverror); 3207c478bd9Sstevel@tonic-gate } 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate /* 3237c478bd9Sstevel@tonic-gate * ufs_flush 3247c478bd9Sstevel@tonic-gate * Flush everything that is currently dirty; this includes invalidating 3257c478bd9Sstevel@tonic-gate * any mappings. 3267c478bd9Sstevel@tonic-gate */ 3277c478bd9Sstevel@tonic-gate int 3287c478bd9Sstevel@tonic-gate ufs_flush(struct vfs *vfsp) 3297c478bd9Sstevel@tonic-gate { 3307c478bd9Sstevel@tonic-gate int error; 3317c478bd9Sstevel@tonic-gate int saverror = 0; 3327c478bd9Sstevel@tonic-gate struct ufsvfs *ufsvfsp = (struct ufsvfs *)vfsp->vfs_data; 3337c478bd9Sstevel@tonic-gate struct fs *fs = ufsvfsp->vfs_fs; 334*46ac4468Smishra int tdontblock = 0; 3357c478bd9Sstevel@tonic-gate 3367c478bd9Sstevel@tonic-gate ASSERT(vfs_lock_held(vfsp)); 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate /* 3397c478bd9Sstevel@tonic-gate * purge dnlc 3407c478bd9Sstevel@tonic-gate */ 3417c478bd9Sstevel@tonic-gate (void) dnlc_purge_vfsp(vfsp, 0); 3427c478bd9Sstevel@tonic-gate 3437c478bd9Sstevel@tonic-gate /* 3447c478bd9Sstevel@tonic-gate * drain the delete and idle threads 3457c478bd9Sstevel@tonic-gate */ 3467c478bd9Sstevel@tonic-gate ufs_delete_drain(vfsp, 0, 0); 3477c478bd9Sstevel@tonic-gate ufs_idle_drain(vfsp); 3487c478bd9Sstevel@tonic-gate 3497c478bd9Sstevel@tonic-gate /* 3507c478bd9Sstevel@tonic-gate * flush and invalidate quota records 3517c478bd9Sstevel@tonic-gate */ 3527c478bd9Sstevel@tonic-gate (void) qsync(ufsvfsp); 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate /* 3557c478bd9Sstevel@tonic-gate * flush w/invalidate the inodes for vfsp 3567c478bd9Sstevel@tonic-gate */ 3577c478bd9Sstevel@tonic-gate if (error = ufs_scan_inodes(0, ufs_flush_inode, ufsvfsp, ufsvfsp)) 3587c478bd9Sstevel@tonic-gate saverror = error; 3597c478bd9Sstevel@tonic-gate 3607c478bd9Sstevel@tonic-gate /* 3617c478bd9Sstevel@tonic-gate * synchronously flush superblock and summary info 3627c478bd9Sstevel@tonic-gate */ 3637c478bd9Sstevel@tonic-gate if (fs->fs_ronly == 0 && fs->fs_fmod) { 3647c478bd9Sstevel@tonic-gate fs->fs_fmod = 0; 3657c478bd9Sstevel@tonic-gate TRANS_SBUPDATE(ufsvfsp, vfsp, TOP_SBUPDATE_FLUSH); 3667c478bd9Sstevel@tonic-gate } 3677c478bd9Sstevel@tonic-gate /* 3687c478bd9Sstevel@tonic-gate * flush w/invalidate block device pages and buf cache 3697c478bd9Sstevel@tonic-gate */ 3707c478bd9Sstevel@tonic-gate if ((error = VOP_PUTPAGE(common_specvp(ufsvfsp->vfs_devvp), 3717c478bd9Sstevel@tonic-gate (offset_t)0, 0, B_INVAL, CRED())) > 0) 3727c478bd9Sstevel@tonic-gate saverror = error; 3737c478bd9Sstevel@tonic-gate 3747c478bd9Sstevel@tonic-gate (void) bflush((dev_t)vfsp->vfs_dev); 3757c478bd9Sstevel@tonic-gate (void) bfinval((dev_t)vfsp->vfs_dev, 0); 3767c478bd9Sstevel@tonic-gate 3777c478bd9Sstevel@tonic-gate /* 3787c478bd9Sstevel@tonic-gate * drain the delete and idle threads again 3797c478bd9Sstevel@tonic-gate */ 3807c478bd9Sstevel@tonic-gate ufs_delete_drain(vfsp, 0, 0); 3817c478bd9Sstevel@tonic-gate ufs_idle_drain(vfsp); 3827c478bd9Sstevel@tonic-gate 3837c478bd9Sstevel@tonic-gate /* 3847c478bd9Sstevel@tonic-gate * play with the clean flag 3857c478bd9Sstevel@tonic-gate */ 3867c478bd9Sstevel@tonic-gate if (saverror == 0) 3877c478bd9Sstevel@tonic-gate ufs_checkclean(vfsp); 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate /* 39014c932c0Sbatschul * Flush any outstanding transactions and roll the log 39114c932c0Sbatschul * only if we are supposed to do, i.e. LDL_NOROLL not set. 39214c932c0Sbatschul * We can not simply check for fs_ronly here since fsck also may 39314c932c0Sbatschul * use this code to roll the log on a read-only filesystem, e.g. 39414c932c0Sbatschul * root during early stages of boot, if other then a sanity check is 39514c932c0Sbatschul * done, it will clear LDL_NOROLL before. 39614c932c0Sbatschul * In addition we assert that the deltamap does not contain any deltas 39714c932c0Sbatschul * in case LDL_NOROLL is set since this is not supposed to happen. 3987c478bd9Sstevel@tonic-gate */ 3997c478bd9Sstevel@tonic-gate if (TRANS_ISTRANS(ufsvfsp)) { 40014c932c0Sbatschul ml_unit_t *ul = ufsvfsp->vfs_log; 40114c932c0Sbatschul mt_map_t *mtm = ul->un_deltamap; 40214c932c0Sbatschul 40314c932c0Sbatschul if (ul->un_flags & LDL_NOROLL) { 40414c932c0Sbatschul ASSERT(mtm->mtm_nme == 0); 40514c932c0Sbatschul } else { 406*46ac4468Smishra /* 407*46ac4468Smishra * Do not set T_DONTBLOCK if there is a 408*46ac4468Smishra * transaction opened by caller. 409*46ac4468Smishra */ 410*46ac4468Smishra if (curthread->t_flag & T_DONTBLOCK) 411*46ac4468Smishra tdontblock = 1; 412*46ac4468Smishra else 413*46ac4468Smishra curthread->t_flag |= T_DONTBLOCK; 414*46ac4468Smishra 41514c932c0Sbatschul TRANS_BEGIN_SYNC(ufsvfsp, TOP_COMMIT_FLUSH, 41614c932c0Sbatschul TOP_COMMIT_SIZE, error); 417*46ac4468Smishra 41814c932c0Sbatschul if (!error) { 41914c932c0Sbatschul TRANS_END_SYNC(ufsvfsp, saverror, 42014c932c0Sbatschul TOP_COMMIT_FLUSH, TOP_COMMIT_SIZE); 42114c932c0Sbatschul } 422*46ac4468Smishra 423*46ac4468Smishra if (tdontblock == 0) 424*46ac4468Smishra curthread->t_flag &= ~T_DONTBLOCK; 425*46ac4468Smishra 42614c932c0Sbatschul logmap_roll_dev(ufsvfsp->vfs_log); 4277c478bd9Sstevel@tonic-gate } 4287c478bd9Sstevel@tonic-gate } 4297c478bd9Sstevel@tonic-gate 4307c478bd9Sstevel@tonic-gate return (saverror); 4317c478bd9Sstevel@tonic-gate } 4327c478bd9Sstevel@tonic-gate 4337c478bd9Sstevel@tonic-gate /* 4347c478bd9Sstevel@tonic-gate * ufs_thaw_wlock 4357c478bd9Sstevel@tonic-gate * special processing when thawing down to wlock 4367c478bd9Sstevel@tonic-gate */ 4377c478bd9Sstevel@tonic-gate static int 4387c478bd9Sstevel@tonic-gate ufs_thaw_wlock(struct inode *ip, void *arg) 4397c478bd9Sstevel@tonic-gate { 4407c478bd9Sstevel@tonic-gate /* 4417c478bd9Sstevel@tonic-gate * wrong file system; keep looking 4427c478bd9Sstevel@tonic-gate */ 4437c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 4447c478bd9Sstevel@tonic-gate return (0); 4457c478bd9Sstevel@tonic-gate 4467c478bd9Sstevel@tonic-gate /* 4477c478bd9Sstevel@tonic-gate * iupdat refuses to clear flags if the fs is read only. The fs 4487c478bd9Sstevel@tonic-gate * may become read/write during the lock and we wouldn't want 4497c478bd9Sstevel@tonic-gate * these inodes being written to disk. So clear the flags. 4507c478bd9Sstevel@tonic-gate */ 4517c478bd9Sstevel@tonic-gate rw_enter(&ip->i_contents, RW_WRITER); 4527c478bd9Sstevel@tonic-gate ip->i_flag &= ~(IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG); 4537c478bd9Sstevel@tonic-gate rw_exit(&ip->i_contents); 4547c478bd9Sstevel@tonic-gate 4557c478bd9Sstevel@tonic-gate /* 4567c478bd9Sstevel@tonic-gate * pages are mlocked -- fail wlock 4577c478bd9Sstevel@tonic-gate */ 4587c478bd9Sstevel@tonic-gate if (ITOV(ip)->v_type != VCHR && vn_has_cached_data(ITOV(ip))) 4597c478bd9Sstevel@tonic-gate return (EBUSY); 4607c478bd9Sstevel@tonic-gate 4617c478bd9Sstevel@tonic-gate return (0); 4627c478bd9Sstevel@tonic-gate } 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate /* 4657c478bd9Sstevel@tonic-gate * ufs_thaw_hlock 4667c478bd9Sstevel@tonic-gate * special processing when thawing down to hlock or elock 4677c478bd9Sstevel@tonic-gate */ 4687c478bd9Sstevel@tonic-gate static int 4697c478bd9Sstevel@tonic-gate ufs_thaw_hlock(struct inode *ip, void *arg) 4707c478bd9Sstevel@tonic-gate { 4717c478bd9Sstevel@tonic-gate struct vnode *vp = ITOV(ip); 4727c478bd9Sstevel@tonic-gate 4737c478bd9Sstevel@tonic-gate /* 4747c478bd9Sstevel@tonic-gate * wrong file system; keep looking 4757c478bd9Sstevel@tonic-gate */ 4767c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 4777c478bd9Sstevel@tonic-gate return (0); 4787c478bd9Sstevel@tonic-gate 4797c478bd9Sstevel@tonic-gate /* 4807c478bd9Sstevel@tonic-gate * blow away all pages - even if they are mlocked 4817c478bd9Sstevel@tonic-gate */ 4827c478bd9Sstevel@tonic-gate do { 4837c478bd9Sstevel@tonic-gate (void) TRANS_SYNCIP(ip, B_INVAL | B_FORCE, 0, TOP_SYNCIP_HLOCK); 4847c478bd9Sstevel@tonic-gate } while ((vp->v_type != VCHR) && vn_has_cached_data(vp)); 4857c478bd9Sstevel@tonic-gate rw_enter(&ip->i_contents, RW_WRITER); 4867c478bd9Sstevel@tonic-gate ip->i_flag &= ~(IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG); 4877c478bd9Sstevel@tonic-gate rw_exit(&ip->i_contents); 4887c478bd9Sstevel@tonic-gate 4897c478bd9Sstevel@tonic-gate return (0); 4907c478bd9Sstevel@tonic-gate } 4917c478bd9Sstevel@tonic-gate 4927c478bd9Sstevel@tonic-gate /* 4937c478bd9Sstevel@tonic-gate * ufs_thaw 4947c478bd9Sstevel@tonic-gate * thaw file system lock down to current value 4957c478bd9Sstevel@tonic-gate */ 4967c478bd9Sstevel@tonic-gate int 4977c478bd9Sstevel@tonic-gate ufs_thaw(struct vfs *vfsp, struct ufsvfs *ufsvfsp, struct ulockfs *ulp) 4987c478bd9Sstevel@tonic-gate { 4997c478bd9Sstevel@tonic-gate int error = 0; 5007c478bd9Sstevel@tonic-gate int noidel = (int)(ulp->ul_flag & ULOCKFS_NOIDEL); 5017c478bd9Sstevel@tonic-gate 5027c478bd9Sstevel@tonic-gate /* 5037c478bd9Sstevel@tonic-gate * if wlock or hlock or elock 5047c478bd9Sstevel@tonic-gate */ 5057c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_WLOCK(ulp) || ULOCKFS_IS_HLOCK(ulp) || 5067c478bd9Sstevel@tonic-gate ULOCKFS_IS_ELOCK(ulp)) { 5077c478bd9Sstevel@tonic-gate 5087c478bd9Sstevel@tonic-gate /* 5097c478bd9Sstevel@tonic-gate * don't keep access times 5107c478bd9Sstevel@tonic-gate * don't free deleted files 5117c478bd9Sstevel@tonic-gate * if superblock writes are allowed, limit them to me for now 5127c478bd9Sstevel@tonic-gate */ 5137c478bd9Sstevel@tonic-gate ulp->ul_flag |= (ULOCKFS_NOIACC|ULOCKFS_NOIDEL); 5147c478bd9Sstevel@tonic-gate if (ulp->ul_sbowner != (kthread_id_t)-1) 5157c478bd9Sstevel@tonic-gate ulp->ul_sbowner = curthread; 5167c478bd9Sstevel@tonic-gate 5177c478bd9Sstevel@tonic-gate /* 5187c478bd9Sstevel@tonic-gate * wait for writes for deleted files and superblock updates 5197c478bd9Sstevel@tonic-gate */ 5207c478bd9Sstevel@tonic-gate (void) ufs_flush(vfsp); 5217c478bd9Sstevel@tonic-gate 5227c478bd9Sstevel@tonic-gate /* 5237c478bd9Sstevel@tonic-gate * now make sure the quota file is up-to-date 5247c478bd9Sstevel@tonic-gate * expensive; but effective 5257c478bd9Sstevel@tonic-gate */ 5267c478bd9Sstevel@tonic-gate error = ufs_flush(vfsp); 5277c478bd9Sstevel@tonic-gate /* 5287c478bd9Sstevel@tonic-gate * no one can write the superblock 5297c478bd9Sstevel@tonic-gate */ 5307c478bd9Sstevel@tonic-gate ulp->ul_sbowner = (kthread_id_t)-1; 5317c478bd9Sstevel@tonic-gate 5327c478bd9Sstevel@tonic-gate /* 5337c478bd9Sstevel@tonic-gate * special processing for wlock/hlock/elock 5347c478bd9Sstevel@tonic-gate */ 5357c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_WLOCK(ulp)) { 5367c478bd9Sstevel@tonic-gate if (error) 5377c478bd9Sstevel@tonic-gate goto errout; 5387c478bd9Sstevel@tonic-gate error = bfinval(ufsvfsp->vfs_dev, 0); 5397c478bd9Sstevel@tonic-gate if (error) 5407c478bd9Sstevel@tonic-gate goto errout; 5417c478bd9Sstevel@tonic-gate error = ufs_scan_inodes(0, ufs_thaw_wlock, 5427c478bd9Sstevel@tonic-gate (void *)ufsvfsp, ufsvfsp); 5437c478bd9Sstevel@tonic-gate if (error) 5447c478bd9Sstevel@tonic-gate goto errout; 5457c478bd9Sstevel@tonic-gate } 5467c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(ulp) || ULOCKFS_IS_ELOCK(ulp)) { 5477c478bd9Sstevel@tonic-gate error = 0; 5487c478bd9Sstevel@tonic-gate (void) ufs_scan_inodes(0, ufs_thaw_hlock, 5497c478bd9Sstevel@tonic-gate (void *)ufsvfsp, ufsvfsp); 5507c478bd9Sstevel@tonic-gate (void) bfinval(ufsvfsp->vfs_dev, 1); 5517c478bd9Sstevel@tonic-gate } 5527c478bd9Sstevel@tonic-gate } else { 5537c478bd9Sstevel@tonic-gate 5547c478bd9Sstevel@tonic-gate /* 5557c478bd9Sstevel@tonic-gate * okay to keep access times 5567c478bd9Sstevel@tonic-gate * okay to free deleted files 5577c478bd9Sstevel@tonic-gate * okay to write the superblock 5587c478bd9Sstevel@tonic-gate */ 5597c478bd9Sstevel@tonic-gate ulp->ul_flag &= ~(ULOCKFS_NOIACC|ULOCKFS_NOIDEL); 5607c478bd9Sstevel@tonic-gate ulp->ul_sbowner = NULL; 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate /* 5637c478bd9Sstevel@tonic-gate * flush in case deleted files are in memory 5647c478bd9Sstevel@tonic-gate */ 5657c478bd9Sstevel@tonic-gate if (noidel) { 5667c478bd9Sstevel@tonic-gate if (error = ufs_flush(vfsp)) 5677c478bd9Sstevel@tonic-gate goto errout; 5687c478bd9Sstevel@tonic-gate } 5697c478bd9Sstevel@tonic-gate } 5707c478bd9Sstevel@tonic-gate 5717c478bd9Sstevel@tonic-gate errout: 5727c478bd9Sstevel@tonic-gate cv_broadcast(&ulp->ul_cv); 5737c478bd9Sstevel@tonic-gate return (error); 5747c478bd9Sstevel@tonic-gate } 5757c478bd9Sstevel@tonic-gate 5767c478bd9Sstevel@tonic-gate /* 5777c478bd9Sstevel@tonic-gate * ufs_reconcile_fs 5787c478bd9Sstevel@tonic-gate * reconcile incore superblock with ondisk superblock 5797c478bd9Sstevel@tonic-gate */ 5807c478bd9Sstevel@tonic-gate int 5817c478bd9Sstevel@tonic-gate ufs_reconcile_fs(struct vfs *vfsp, struct ufsvfs *ufsvfsp, int errlck) 5827c478bd9Sstevel@tonic-gate { 5837c478bd9Sstevel@tonic-gate struct fs *mfs; /* in-memory superblock */ 5847c478bd9Sstevel@tonic-gate struct fs *dfs; /* on-disk superblock */ 5857c478bd9Sstevel@tonic-gate struct buf *bp; /* on-disk superblock buf */ 5867c478bd9Sstevel@tonic-gate int needs_unlock; 5877c478bd9Sstevel@tonic-gate char finished_fsclean; 5887c478bd9Sstevel@tonic-gate 5897c478bd9Sstevel@tonic-gate mfs = ufsvfsp->vfs_fs; 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate /* 5927c478bd9Sstevel@tonic-gate * get the on-disk copy of the superblock 5937c478bd9Sstevel@tonic-gate */ 5947c478bd9Sstevel@tonic-gate bp = UFS_BREAD(ufsvfsp, vfsp->vfs_dev, SBLOCK, SBSIZE); 5957c478bd9Sstevel@tonic-gate bp->b_flags |= (B_STALE|B_AGE); 5967c478bd9Sstevel@tonic-gate if (bp->b_flags & B_ERROR) { 5977c478bd9Sstevel@tonic-gate brelse(bp); 5987c478bd9Sstevel@tonic-gate return (EIO); 5997c478bd9Sstevel@tonic-gate } 6007c478bd9Sstevel@tonic-gate dfs = bp->b_un.b_fs; 6017c478bd9Sstevel@tonic-gate 6027c478bd9Sstevel@tonic-gate /* error locks may only unlock after the fs has been made consistent */ 6037c478bd9Sstevel@tonic-gate if (errlck == UN_ERRLCK) { 6047c478bd9Sstevel@tonic-gate if (dfs->fs_clean == FSFIX) { /* being repaired */ 6057c478bd9Sstevel@tonic-gate brelse(bp); 6067c478bd9Sstevel@tonic-gate return (EAGAIN); 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate /* repair not yet started? */ 6097c478bd9Sstevel@tonic-gate finished_fsclean = TRANS_ISTRANS(ufsvfsp)? FSLOG: FSCLEAN; 6107c478bd9Sstevel@tonic-gate if (dfs->fs_clean != finished_fsclean) { 6117c478bd9Sstevel@tonic-gate brelse(bp); 6127c478bd9Sstevel@tonic-gate return (EBUSY); 6137c478bd9Sstevel@tonic-gate } 6147c478bd9Sstevel@tonic-gate } 6157c478bd9Sstevel@tonic-gate 6167c478bd9Sstevel@tonic-gate /* 6177c478bd9Sstevel@tonic-gate * if superblock has changed too much, abort 6187c478bd9Sstevel@tonic-gate */ 6197c478bd9Sstevel@tonic-gate if ((mfs->fs_sblkno != dfs->fs_sblkno) || 6207c478bd9Sstevel@tonic-gate (mfs->fs_cblkno != dfs->fs_cblkno) || 6217c478bd9Sstevel@tonic-gate (mfs->fs_iblkno != dfs->fs_iblkno) || 6227c478bd9Sstevel@tonic-gate (mfs->fs_dblkno != dfs->fs_dblkno) || 6237c478bd9Sstevel@tonic-gate (mfs->fs_cgoffset != dfs->fs_cgoffset) || 6247c478bd9Sstevel@tonic-gate (mfs->fs_cgmask != dfs->fs_cgmask) || 6257c478bd9Sstevel@tonic-gate (mfs->fs_bsize != dfs->fs_bsize) || 6267c478bd9Sstevel@tonic-gate (mfs->fs_fsize != dfs->fs_fsize) || 6277c478bd9Sstevel@tonic-gate (mfs->fs_frag != dfs->fs_frag) || 6287c478bd9Sstevel@tonic-gate (mfs->fs_bmask != dfs->fs_bmask) || 6297c478bd9Sstevel@tonic-gate (mfs->fs_fmask != dfs->fs_fmask) || 6307c478bd9Sstevel@tonic-gate (mfs->fs_bshift != dfs->fs_bshift) || 6317c478bd9Sstevel@tonic-gate (mfs->fs_fshift != dfs->fs_fshift) || 6327c478bd9Sstevel@tonic-gate (mfs->fs_fragshift != dfs->fs_fragshift) || 6337c478bd9Sstevel@tonic-gate (mfs->fs_fsbtodb != dfs->fs_fsbtodb) || 6347c478bd9Sstevel@tonic-gate (mfs->fs_sbsize != dfs->fs_sbsize) || 6357c478bd9Sstevel@tonic-gate (mfs->fs_nindir != dfs->fs_nindir) || 6367c478bd9Sstevel@tonic-gate (mfs->fs_nspf != dfs->fs_nspf) || 6377c478bd9Sstevel@tonic-gate (mfs->fs_trackskew != dfs->fs_trackskew) || 6387c478bd9Sstevel@tonic-gate (mfs->fs_cgsize != dfs->fs_cgsize) || 6397c478bd9Sstevel@tonic-gate (mfs->fs_ntrak != dfs->fs_ntrak) || 6407c478bd9Sstevel@tonic-gate (mfs->fs_nsect != dfs->fs_nsect) || 6417c478bd9Sstevel@tonic-gate (mfs->fs_spc != dfs->fs_spc) || 6427c478bd9Sstevel@tonic-gate (mfs->fs_cpg != dfs->fs_cpg) || 6437c478bd9Sstevel@tonic-gate (mfs->fs_ipg != dfs->fs_ipg) || 6447c478bd9Sstevel@tonic-gate (mfs->fs_fpg != dfs->fs_fpg) || 6457c478bd9Sstevel@tonic-gate (mfs->fs_postblformat != dfs->fs_postblformat) || 6467c478bd9Sstevel@tonic-gate (mfs->fs_magic != dfs->fs_magic)) { 6477c478bd9Sstevel@tonic-gate brelse(bp); 6487c478bd9Sstevel@tonic-gate return (EACCES); 6497c478bd9Sstevel@tonic-gate } 6507c478bd9Sstevel@tonic-gate if (dfs->fs_clean == FSBAD || FSOKAY != dfs->fs_state + dfs->fs_time) 6517c478bd9Sstevel@tonic-gate if (mfs->fs_clean == FSLOG) { 6527c478bd9Sstevel@tonic-gate brelse(bp); 6537c478bd9Sstevel@tonic-gate return (EACCES); 6547c478bd9Sstevel@tonic-gate } 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate /* 6577c478bd9Sstevel@tonic-gate * get new summary info 6587c478bd9Sstevel@tonic-gate */ 6597c478bd9Sstevel@tonic-gate if (ufs_getsummaryinfo(vfsp->vfs_dev, ufsvfsp, dfs)) { 6607c478bd9Sstevel@tonic-gate brelse(bp); 6617c478bd9Sstevel@tonic-gate return (EIO); 6627c478bd9Sstevel@tonic-gate } 6637c478bd9Sstevel@tonic-gate 6647c478bd9Sstevel@tonic-gate /* 6657c478bd9Sstevel@tonic-gate * release old summary info and update in-memory superblock 6667c478bd9Sstevel@tonic-gate */ 6677c478bd9Sstevel@tonic-gate kmem_free(mfs->fs_u.fs_csp, mfs->fs_cssize); 6687c478bd9Sstevel@tonic-gate mfs->fs_u.fs_csp = dfs->fs_u.fs_csp; /* Only entry 0 used */ 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate /* 6717c478bd9Sstevel@tonic-gate * update fields allowed to change 6727c478bd9Sstevel@tonic-gate */ 6737c478bd9Sstevel@tonic-gate mfs->fs_size = dfs->fs_size; 6747c478bd9Sstevel@tonic-gate mfs->fs_dsize = dfs->fs_dsize; 6757c478bd9Sstevel@tonic-gate mfs->fs_ncg = dfs->fs_ncg; 6767c478bd9Sstevel@tonic-gate mfs->fs_minfree = dfs->fs_minfree; 6777c478bd9Sstevel@tonic-gate mfs->fs_rotdelay = dfs->fs_rotdelay; 6787c478bd9Sstevel@tonic-gate mfs->fs_rps = dfs->fs_rps; 6797c478bd9Sstevel@tonic-gate mfs->fs_maxcontig = dfs->fs_maxcontig; 6807c478bd9Sstevel@tonic-gate mfs->fs_maxbpg = dfs->fs_maxbpg; 6817c478bd9Sstevel@tonic-gate mfs->fs_csmask = dfs->fs_csmask; 6827c478bd9Sstevel@tonic-gate mfs->fs_csshift = dfs->fs_csshift; 6837c478bd9Sstevel@tonic-gate mfs->fs_optim = dfs->fs_optim; 6847c478bd9Sstevel@tonic-gate mfs->fs_csaddr = dfs->fs_csaddr; 6857c478bd9Sstevel@tonic-gate mfs->fs_cssize = dfs->fs_cssize; 6867c478bd9Sstevel@tonic-gate mfs->fs_ncyl = dfs->fs_ncyl; 6877c478bd9Sstevel@tonic-gate mfs->fs_cstotal = dfs->fs_cstotal; 6887c478bd9Sstevel@tonic-gate mfs->fs_reclaim = dfs->fs_reclaim; 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate if (mfs->fs_reclaim & (FS_RECLAIM|FS_RECLAIMING)) { 6917c478bd9Sstevel@tonic-gate mfs->fs_reclaim &= ~FS_RECLAIM; 6927c478bd9Sstevel@tonic-gate mfs->fs_reclaim |= FS_RECLAIMING; 6937c478bd9Sstevel@tonic-gate ufs_thread_start(&ufsvfsp->vfs_reclaim, 6947c478bd9Sstevel@tonic-gate ufs_thread_reclaim, vfsp); 6957c478bd9Sstevel@tonic-gate } 6967c478bd9Sstevel@tonic-gate 6977c478bd9Sstevel@tonic-gate /* XXX What to do about sparecon? */ 6987c478bd9Sstevel@tonic-gate 6997c478bd9Sstevel@tonic-gate /* XXX need to copy volume label */ 7007c478bd9Sstevel@tonic-gate 7017c478bd9Sstevel@tonic-gate /* 7027c478bd9Sstevel@tonic-gate * ondisk clean flag overrides inmemory clean flag iff == FSBAD 7037c478bd9Sstevel@tonic-gate * or if error-locked and ondisk is now clean 7047c478bd9Sstevel@tonic-gate */ 7057c478bd9Sstevel@tonic-gate needs_unlock = !MUTEX_HELD(&ufsvfsp->vfs_lock); 7067c478bd9Sstevel@tonic-gate if (needs_unlock) 7077c478bd9Sstevel@tonic-gate mutex_enter(&ufsvfsp->vfs_lock); 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate if (errlck == UN_ERRLCK) { 7107c478bd9Sstevel@tonic-gate if (finished_fsclean == dfs->fs_clean) 7117c478bd9Sstevel@tonic-gate mfs->fs_clean = finished_fsclean; 7127c478bd9Sstevel@tonic-gate else 7137c478bd9Sstevel@tonic-gate mfs->fs_clean = FSBAD; 7147c478bd9Sstevel@tonic-gate mfs->fs_state = FSOKAY - dfs->fs_time; 7157c478bd9Sstevel@tonic-gate } 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate if (FSOKAY != dfs->fs_state + dfs->fs_time || 7187c478bd9Sstevel@tonic-gate (dfs->fs_clean == FSBAD)) 7197c478bd9Sstevel@tonic-gate mfs->fs_clean = FSBAD; 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate if (needs_unlock) 7227c478bd9Sstevel@tonic-gate mutex_exit(&ufsvfsp->vfs_lock); 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate brelse(bp); 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate return (0); 7277c478bd9Sstevel@tonic-gate } 7287c478bd9Sstevel@tonic-gate 7297c478bd9Sstevel@tonic-gate /* 7307c478bd9Sstevel@tonic-gate * ufs_reconcile_inode 7317c478bd9Sstevel@tonic-gate * reconcile ondisk inode with incore inode 7327c478bd9Sstevel@tonic-gate */ 7337c478bd9Sstevel@tonic-gate static int 7347c478bd9Sstevel@tonic-gate ufs_reconcile_inode(struct inode *ip, void *arg) 7357c478bd9Sstevel@tonic-gate { 7367c478bd9Sstevel@tonic-gate int i; 7377c478bd9Sstevel@tonic-gate int ndaddr; 7387c478bd9Sstevel@tonic-gate int niaddr; 7397c478bd9Sstevel@tonic-gate struct dinode *dp; /* ondisk inode */ 7407c478bd9Sstevel@tonic-gate struct buf *bp = NULL; 7417c478bd9Sstevel@tonic-gate uid_t d_uid; 7427c478bd9Sstevel@tonic-gate gid_t d_gid; 7437c478bd9Sstevel@tonic-gate int error = 0; 7447c478bd9Sstevel@tonic-gate struct fs *fs; 7457c478bd9Sstevel@tonic-gate 7467c478bd9Sstevel@tonic-gate /* 7477c478bd9Sstevel@tonic-gate * not an inode we care about 7487c478bd9Sstevel@tonic-gate */ 7497c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 7507c478bd9Sstevel@tonic-gate return (0); 7517c478bd9Sstevel@tonic-gate 7527c478bd9Sstevel@tonic-gate fs = ip->i_fs; 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate /* 7557c478bd9Sstevel@tonic-gate * Inode reconciliation fails: we made the filesystem quiescent 7567c478bd9Sstevel@tonic-gate * and we did a ufs_flush() before calling ufs_reconcile_inode() 7577c478bd9Sstevel@tonic-gate * and thus the inode should not have been changed inbetween. 7587c478bd9Sstevel@tonic-gate * Any discrepancies indicate a logic error and a pretty 7597c478bd9Sstevel@tonic-gate * significant run-state inconsistency we should complain about. 7607c478bd9Sstevel@tonic-gate */ 7617c478bd9Sstevel@tonic-gate if (ip->i_flag & (IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG)) { 7627c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s: Inode reconciliation failed for" 7637c478bd9Sstevel@tonic-gate "inode %llu", fs->fs_fsmnt, (u_longlong_t)ip->i_number); 7647c478bd9Sstevel@tonic-gate return (EINVAL); 7657c478bd9Sstevel@tonic-gate } 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate /* 7687c478bd9Sstevel@tonic-gate * get the dinode 7697c478bd9Sstevel@tonic-gate */ 7707c478bd9Sstevel@tonic-gate bp = UFS_BREAD(ip->i_ufsvfs, 7717c478bd9Sstevel@tonic-gate ip->i_dev, (daddr_t)fsbtodb(fs, itod(fs, ip->i_number)), 7727c478bd9Sstevel@tonic-gate (int)fs->fs_bsize); 7737c478bd9Sstevel@tonic-gate if (bp->b_flags & B_ERROR) { 7747c478bd9Sstevel@tonic-gate brelse(bp); 7757c478bd9Sstevel@tonic-gate return (EIO); 7767c478bd9Sstevel@tonic-gate } 7777c478bd9Sstevel@tonic-gate dp = bp->b_un.b_dino; 7787c478bd9Sstevel@tonic-gate dp += itoo(fs, ip->i_number); 7797c478bd9Sstevel@tonic-gate 7807c478bd9Sstevel@tonic-gate /* 7817c478bd9Sstevel@tonic-gate * handle Sun's implementation of EFT 7827c478bd9Sstevel@tonic-gate */ 7837c478bd9Sstevel@tonic-gate d_uid = (dp->di_suid == UID_LONG) ? dp->di_uid : (uid_t)dp->di_suid; 7847c478bd9Sstevel@tonic-gate d_gid = (dp->di_sgid == GID_LONG) ? dp->di_gid : (uid_t)dp->di_sgid; 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate rw_enter(&ip->i_contents, RW_WRITER); 7877c478bd9Sstevel@tonic-gate 7887c478bd9Sstevel@tonic-gate /* 7897c478bd9Sstevel@tonic-gate * some fields are not allowed to change 7907c478bd9Sstevel@tonic-gate */ 7917c478bd9Sstevel@tonic-gate if ((ip->i_mode != dp->di_mode) || 7927c478bd9Sstevel@tonic-gate (ip->i_gen != dp->di_gen) || 7937c478bd9Sstevel@tonic-gate (ip->i_uid != d_uid) || 7947c478bd9Sstevel@tonic-gate (ip->i_gid != d_gid)) { 7957c478bd9Sstevel@tonic-gate error = EACCES; 7967c478bd9Sstevel@tonic-gate goto out; 7977c478bd9Sstevel@tonic-gate } 7987c478bd9Sstevel@tonic-gate 7997c478bd9Sstevel@tonic-gate /* 8007c478bd9Sstevel@tonic-gate * and some are allowed to change 8017c478bd9Sstevel@tonic-gate */ 8027c478bd9Sstevel@tonic-gate ip->i_size = dp->di_size; 8037c478bd9Sstevel@tonic-gate ip->i_ic.ic_flags = dp->di_ic.ic_flags; 8047c478bd9Sstevel@tonic-gate ip->i_blocks = dp->di_blocks; 8057c478bd9Sstevel@tonic-gate ip->i_nlink = dp->di_nlink; 8067c478bd9Sstevel@tonic-gate if (ip->i_flag & IFASTSYMLNK) { 8077c478bd9Sstevel@tonic-gate ndaddr = 1; 8087c478bd9Sstevel@tonic-gate niaddr = 0; 8097c478bd9Sstevel@tonic-gate } else { 8107c478bd9Sstevel@tonic-gate ndaddr = NDADDR; 8117c478bd9Sstevel@tonic-gate niaddr = NIADDR; 8127c478bd9Sstevel@tonic-gate } 8137c478bd9Sstevel@tonic-gate for (i = 0; i < ndaddr; ++i) 8147c478bd9Sstevel@tonic-gate ip->i_db[i] = dp->di_db[i]; 8157c478bd9Sstevel@tonic-gate for (i = 0; i < niaddr; ++i) 8167c478bd9Sstevel@tonic-gate ip->i_ib[i] = dp->di_ib[i]; 8177c478bd9Sstevel@tonic-gate 8187c478bd9Sstevel@tonic-gate out: 8197c478bd9Sstevel@tonic-gate rw_exit(&ip->i_contents); 8207c478bd9Sstevel@tonic-gate brelse(bp); 8217c478bd9Sstevel@tonic-gate return (error); 8227c478bd9Sstevel@tonic-gate } 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate /* 8257c478bd9Sstevel@tonic-gate * ufs_reconcile 8267c478bd9Sstevel@tonic-gate * reconcile ondisk superblock/inodes with any incore 8277c478bd9Sstevel@tonic-gate */ 8287c478bd9Sstevel@tonic-gate static int 8297c478bd9Sstevel@tonic-gate ufs_reconcile(struct vfs *vfsp, struct ufsvfs *ufsvfsp, int errlck) 8307c478bd9Sstevel@tonic-gate { 8317c478bd9Sstevel@tonic-gate int error = 0; 8327c478bd9Sstevel@tonic-gate 8337c478bd9Sstevel@tonic-gate /* 8347c478bd9Sstevel@tonic-gate * get rid of as much inmemory data as possible 8357c478bd9Sstevel@tonic-gate */ 8367c478bd9Sstevel@tonic-gate (void) ufs_flush(vfsp); 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate /* 8397c478bd9Sstevel@tonic-gate * reconcile the superblock and inodes 8407c478bd9Sstevel@tonic-gate */ 8417c478bd9Sstevel@tonic-gate if (error = ufs_reconcile_fs(vfsp, ufsvfsp, errlck)) 8427c478bd9Sstevel@tonic-gate return (error); 8437c478bd9Sstevel@tonic-gate if (error = ufs_scan_inodes(0, ufs_reconcile_inode, ufsvfsp, ufsvfsp)) 8447c478bd9Sstevel@tonic-gate return (error); 8457c478bd9Sstevel@tonic-gate /* 8467c478bd9Sstevel@tonic-gate * allocation blocks may be incorrect; get rid of them 8477c478bd9Sstevel@tonic-gate */ 8487c478bd9Sstevel@tonic-gate (void) ufs_flush(vfsp); 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate return (error); 8517c478bd9Sstevel@tonic-gate } 8527c478bd9Sstevel@tonic-gate 8537c478bd9Sstevel@tonic-gate /* 8547c478bd9Sstevel@tonic-gate * File system locking 8557c478bd9Sstevel@tonic-gate */ 8567c478bd9Sstevel@tonic-gate int 8577c478bd9Sstevel@tonic-gate ufs_fiolfs(struct vnode *vp, struct lockfs *lockfsp, int from_log) 8587c478bd9Sstevel@tonic-gate { 8597c478bd9Sstevel@tonic-gate return (ufs__fiolfs(vp, lockfsp, /* from_user */ 1, from_log)); 8607c478bd9Sstevel@tonic-gate } 8617c478bd9Sstevel@tonic-gate 8627c478bd9Sstevel@tonic-gate /* kernel-internal interface, also used by fix-on-panic */ 8637c478bd9Sstevel@tonic-gate int 8647c478bd9Sstevel@tonic-gate ufs__fiolfs( 8657c478bd9Sstevel@tonic-gate struct vnode *vp, 8667c478bd9Sstevel@tonic-gate struct lockfs *lockfsp, 8677c478bd9Sstevel@tonic-gate int from_user, 8687c478bd9Sstevel@tonic-gate int from_log) 8697c478bd9Sstevel@tonic-gate { 8707c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 8717c478bd9Sstevel@tonic-gate struct lockfs lfs; 8727c478bd9Sstevel@tonic-gate int error; 8737c478bd9Sstevel@tonic-gate struct vfs *vfsp; 8747c478bd9Sstevel@tonic-gate struct ufsvfs *ufsvfsp; 8757c478bd9Sstevel@tonic-gate int errlck = NO_ERRLCK; 8767c478bd9Sstevel@tonic-gate int poll_events = POLLPRI; 8777c478bd9Sstevel@tonic-gate extern struct pollhead ufs_pollhd; 878303bf60bSsdebnath ulockfs_info_t *head; 879303bf60bSsdebnath ulockfs_info_t *info; 880*46ac4468Smishra int signal = 0; 8817c478bd9Sstevel@tonic-gate 8827c478bd9Sstevel@tonic-gate /* check valid lock type */ 8837c478bd9Sstevel@tonic-gate if (!lockfsp || lockfsp->lf_lock > LOCKFS_MAXLOCK) 8847c478bd9Sstevel@tonic-gate return (EINVAL); 8857c478bd9Sstevel@tonic-gate 8867c478bd9Sstevel@tonic-gate if (!vp || !vp->v_vfsp || !vp->v_vfsp->vfs_data) 8877c478bd9Sstevel@tonic-gate return (EIO); 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate vfsp = vp->v_vfsp; 8907c478bd9Sstevel@tonic-gate ufsvfsp = (struct ufsvfs *)vfsp->vfs_data; 8917c478bd9Sstevel@tonic-gate ulp = &ufsvfsp->vfs_ulockfs; 8927c478bd9Sstevel@tonic-gate 893303bf60bSsdebnath head = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 894303bf60bSsdebnath SEARCH_ULOCKFSP(head, ulp, info); 895303bf60bSsdebnath 8967c478bd9Sstevel@tonic-gate /* 8977c478bd9Sstevel@tonic-gate * Suspend both the reclaim thread and the delete thread. 8987c478bd9Sstevel@tonic-gate * This must be done outside the lockfs locking protocol. 8997c478bd9Sstevel@tonic-gate */ 9007c478bd9Sstevel@tonic-gate ufs_thread_suspend(&ufsvfsp->vfs_reclaim); 9017c478bd9Sstevel@tonic-gate ufs_thread_suspend(&ufsvfsp->vfs_delete); 9027c478bd9Sstevel@tonic-gate 9037c478bd9Sstevel@tonic-gate /* 9047c478bd9Sstevel@tonic-gate * Acquire vfs_reflock around ul_lock to avoid deadlock with 9057c478bd9Sstevel@tonic-gate * umount/remount/sync. 9067c478bd9Sstevel@tonic-gate */ 9077c478bd9Sstevel@tonic-gate vfs_lock_wait(vfsp); 9087c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 909bc69f433Saguzovsk atomic_add_long(&ufs_quiesce_pend, 1); 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate /* 9127c478bd9Sstevel@tonic-gate * Quit if there is another lockfs request in progress 9137c478bd9Sstevel@tonic-gate * that is waiting for existing ufs_vnops to complete. 9147c478bd9Sstevel@tonic-gate */ 9157c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_BUSY(ulp)) { 9167c478bd9Sstevel@tonic-gate error = EBUSY; 9177c478bd9Sstevel@tonic-gate goto errexit; 9187c478bd9Sstevel@tonic-gate } 9197c478bd9Sstevel@tonic-gate 9207c478bd9Sstevel@tonic-gate /* cannot ulocked or downgrade a hard-lock */ 9217c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(ulp)) { 9227c478bd9Sstevel@tonic-gate error = EIO; 9237c478bd9Sstevel@tonic-gate goto errexit; 9247c478bd9Sstevel@tonic-gate } 9257c478bd9Sstevel@tonic-gate 9267c478bd9Sstevel@tonic-gate /* an error lock may be unlocked or relocked, only */ 9277c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_ELOCK(ulp)) { 9287c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_ULOCK(lockfsp) && !LOCKFS_IS_ELOCK(lockfsp)) { 9297c478bd9Sstevel@tonic-gate error = EBUSY; 9307c478bd9Sstevel@tonic-gate goto errexit; 9317c478bd9Sstevel@tonic-gate } 9327c478bd9Sstevel@tonic-gate } 9337c478bd9Sstevel@tonic-gate 9347c478bd9Sstevel@tonic-gate /* 9357c478bd9Sstevel@tonic-gate * a read-only error lock may only be upgraded to an 9367c478bd9Sstevel@tonic-gate * error lock or hard lock 9377c478bd9Sstevel@tonic-gate */ 9387c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_ROELOCK(ulp)) { 9397c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_HLOCK(lockfsp) && !LOCKFS_IS_ELOCK(lockfsp)) { 9407c478bd9Sstevel@tonic-gate error = EBUSY; 9417c478bd9Sstevel@tonic-gate goto errexit; 9427c478bd9Sstevel@tonic-gate } 9437c478bd9Sstevel@tonic-gate } 9447c478bd9Sstevel@tonic-gate 9457c478bd9Sstevel@tonic-gate /* 9467c478bd9Sstevel@tonic-gate * until read-only error locks are fully implemented 9477c478bd9Sstevel@tonic-gate * just return EINVAL 9487c478bd9Sstevel@tonic-gate */ 9497c478bd9Sstevel@tonic-gate if (LOCKFS_IS_ROELOCK(lockfsp)) { 9507c478bd9Sstevel@tonic-gate error = EINVAL; 9517c478bd9Sstevel@tonic-gate goto errexit; 9527c478bd9Sstevel@tonic-gate } 9537c478bd9Sstevel@tonic-gate 9547c478bd9Sstevel@tonic-gate /* 9557c478bd9Sstevel@tonic-gate * an error lock may only be applied if the file system is 9567c478bd9Sstevel@tonic-gate * unlocked or already error locked. 9577c478bd9Sstevel@tonic-gate * (this is to prevent the case where a fs gets changed out from 9587c478bd9Sstevel@tonic-gate * underneath a fs that is locked for backup, 9597c478bd9Sstevel@tonic-gate * that is, name/delete/write-locked.) 9607c478bd9Sstevel@tonic-gate */ 9617c478bd9Sstevel@tonic-gate if ((!ULOCKFS_IS_ULOCK(ulp) && !ULOCKFS_IS_ELOCK(ulp) && 9627c478bd9Sstevel@tonic-gate !ULOCKFS_IS_ROELOCK(ulp)) && 9637c478bd9Sstevel@tonic-gate (LOCKFS_IS_ELOCK(lockfsp) || LOCKFS_IS_ROELOCK(lockfsp))) { 9647c478bd9Sstevel@tonic-gate error = EBUSY; 9657c478bd9Sstevel@tonic-gate goto errexit; 9667c478bd9Sstevel@tonic-gate } 9677c478bd9Sstevel@tonic-gate 9687c478bd9Sstevel@tonic-gate /* get and validate the input lockfs request */ 9697c478bd9Sstevel@tonic-gate if (error = ufs_getlfd(lockfsp, &ulp->ul_lockfs)) 9707c478bd9Sstevel@tonic-gate goto errexit; 9717c478bd9Sstevel@tonic-gate 9727c478bd9Sstevel@tonic-gate /* 9737c478bd9Sstevel@tonic-gate * save current ulockfs struct 9747c478bd9Sstevel@tonic-gate */ 9757c478bd9Sstevel@tonic-gate bcopy(&ulp->ul_lockfs, &lfs, sizeof (struct lockfs)); 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate /* 9787c478bd9Sstevel@tonic-gate * Freeze the file system (pend future accesses) 9797c478bd9Sstevel@tonic-gate */ 9807c478bd9Sstevel@tonic-gate ufs_freeze(ulp, lockfsp); 9817c478bd9Sstevel@tonic-gate 9827c478bd9Sstevel@tonic-gate /* 9837c478bd9Sstevel@tonic-gate * Set locking in progress because ufs_quiesce may free the 9847c478bd9Sstevel@tonic-gate * ul_lock mutex. 9857c478bd9Sstevel@tonic-gate */ 9867c478bd9Sstevel@tonic-gate ULOCKFS_SET_BUSY(ulp); 9877c478bd9Sstevel@tonic-gate /* update the ioctl copy */ 9887c478bd9Sstevel@tonic-gate LOCKFS_SET_BUSY(&ulp->ul_lockfs); 9897c478bd9Sstevel@tonic-gate 990303bf60bSsdebnath /* 991303bf60bSsdebnath * We need to unset FWLOCK status before we call ufs_quiesce 992303bf60bSsdebnath * so that the thread doesnt get suspended. We do this only if 993303bf60bSsdebnath * this (fallocate) thread requested an unlock operation. 994303bf60bSsdebnath */ 995303bf60bSsdebnath if (info && (info->flags & ULOCK_INFO_FALLOCATE)) { 996303bf60bSsdebnath if (!ULOCKFS_IS_WLOCK(ulp)) 997303bf60bSsdebnath ULOCKFS_CLR_FWLOCK(ulp); 998303bf60bSsdebnath } 999303bf60bSsdebnath 10007c478bd9Sstevel@tonic-gate /* 10017c478bd9Sstevel@tonic-gate * Quiesce (wait for outstanding accesses to finish) 10027c478bd9Sstevel@tonic-gate */ 1003*46ac4468Smishra if (error = ufs_quiesce(ulp)) { 1004*46ac4468Smishra /* 1005*46ac4468Smishra * Interrupted due to signal. There could still be 1006*46ac4468Smishra * pending vnops. 1007*46ac4468Smishra */ 1008*46ac4468Smishra signal = 1; 1009*46ac4468Smishra 1010*46ac4468Smishra /* 1011*46ac4468Smishra * We do broadcast because lock-status 1012*46ac4468Smishra * could be reverted to old status. 1013*46ac4468Smishra */ 1014*46ac4468Smishra cv_broadcast(&ulp->ul_cv); 10157c478bd9Sstevel@tonic-gate goto errout; 1016*46ac4468Smishra } 10177c478bd9Sstevel@tonic-gate 1018303bf60bSsdebnath /* 1019303bf60bSsdebnath * If the fallocate thread requested a write fs lock operation 1020303bf60bSsdebnath * then we set fwlock status in the ulp. 1021303bf60bSsdebnath */ 1022303bf60bSsdebnath if (info && (info->flags & ULOCK_INFO_FALLOCATE)) { 1023303bf60bSsdebnath if (ULOCKFS_IS_WLOCK(ulp)) 1024303bf60bSsdebnath ULOCKFS_SET_FWLOCK(ulp); 1025303bf60bSsdebnath } 1026303bf60bSsdebnath 10277c478bd9Sstevel@tonic-gate /* 10287c478bd9Sstevel@tonic-gate * can't wlock or (ro)elock fs with accounting or local swap file 10297c478bd9Sstevel@tonic-gate */ 10307c478bd9Sstevel@tonic-gate if ((ULOCKFS_IS_WLOCK(ulp) || ULOCKFS_IS_ELOCK(ulp) || 10317c478bd9Sstevel@tonic-gate ULOCKFS_IS_ROELOCK(ulp)) && !from_log) { 10327c478bd9Sstevel@tonic-gate if (error = ufs_checkaccton(vp)) 10337c478bd9Sstevel@tonic-gate goto errout; 10347c478bd9Sstevel@tonic-gate if (error = ufs_checkswapon(vp)) 10357c478bd9Sstevel@tonic-gate goto errout; 10367c478bd9Sstevel@tonic-gate } 10377c478bd9Sstevel@tonic-gate 10387c478bd9Sstevel@tonic-gate /* 10397c478bd9Sstevel@tonic-gate * save error lock status to pass down to reconcilation 10407c478bd9Sstevel@tonic-gate * routines and for later cleanup 10417c478bd9Sstevel@tonic-gate */ 10427c478bd9Sstevel@tonic-gate if (LOCKFS_IS_ELOCK(&lfs) && ULOCKFS_IS_ULOCK(ulp)) 10437c478bd9Sstevel@tonic-gate errlck = UN_ERRLCK; 10447c478bd9Sstevel@tonic-gate 10457c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_ELOCK(ulp) || ULOCKFS_IS_ROELOCK(ulp)) { 10467c478bd9Sstevel@tonic-gate int needs_unlock; 10477c478bd9Sstevel@tonic-gate int needs_sbwrite; 10487c478bd9Sstevel@tonic-gate 10497c478bd9Sstevel@tonic-gate poll_events |= POLLERR; 10507c478bd9Sstevel@tonic-gate errlck = LOCKFS_IS_ELOCK(&lfs) || LOCKFS_IS_ROELOCK(&lfs)? 10517c478bd9Sstevel@tonic-gate RE_ERRLCK: SET_ERRLCK; 10527c478bd9Sstevel@tonic-gate 10537c478bd9Sstevel@tonic-gate needs_unlock = !MUTEX_HELD(&ufsvfsp->vfs_lock); 10547c478bd9Sstevel@tonic-gate if (needs_unlock) 10557c478bd9Sstevel@tonic-gate mutex_enter(&ufsvfsp->vfs_lock); 10567c478bd9Sstevel@tonic-gate 10577c478bd9Sstevel@tonic-gate /* disable delayed i/o */ 10587c478bd9Sstevel@tonic-gate needs_sbwrite = 0; 10597c478bd9Sstevel@tonic-gate 10607c478bd9Sstevel@tonic-gate if (errlck == SET_ERRLCK) { 10617c478bd9Sstevel@tonic-gate ufsvfsp->vfs_fs->fs_clean = FSBAD; 10627c478bd9Sstevel@tonic-gate needs_sbwrite = 1; 10637c478bd9Sstevel@tonic-gate } 10647c478bd9Sstevel@tonic-gate 10657c478bd9Sstevel@tonic-gate needs_sbwrite |= ufsvfsp->vfs_dio; 10667c478bd9Sstevel@tonic-gate ufsvfsp->vfs_dio = 0; 10677c478bd9Sstevel@tonic-gate 10687c478bd9Sstevel@tonic-gate if (needs_unlock) 10697c478bd9Sstevel@tonic-gate mutex_exit(&ufsvfsp->vfs_lock); 10707c478bd9Sstevel@tonic-gate 10717c478bd9Sstevel@tonic-gate if (needs_sbwrite) { 10727c478bd9Sstevel@tonic-gate ulp->ul_sbowner = curthread; 10737c478bd9Sstevel@tonic-gate TRANS_SBWRITE(ufsvfsp, TOP_SBWRITE_STABLE); 10747c478bd9Sstevel@tonic-gate 10757c478bd9Sstevel@tonic-gate if (needs_unlock) 10767c478bd9Sstevel@tonic-gate mutex_enter(&ufsvfsp->vfs_lock); 10777c478bd9Sstevel@tonic-gate 10787c478bd9Sstevel@tonic-gate ufsvfsp->vfs_fs->fs_fmod = 0; 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate if (needs_unlock) 10817c478bd9Sstevel@tonic-gate mutex_exit(&ufsvfsp->vfs_lock); 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate } 10847c478bd9Sstevel@tonic-gate 10857c478bd9Sstevel@tonic-gate /* 10867c478bd9Sstevel@tonic-gate * reconcile superblock and inodes if was wlocked 10877c478bd9Sstevel@tonic-gate */ 10887c478bd9Sstevel@tonic-gate if (LOCKFS_IS_WLOCK(&lfs) || LOCKFS_IS_ELOCK(&lfs)) { 10897c478bd9Sstevel@tonic-gate if (error = ufs_reconcile(vfsp, ufsvfsp, errlck)) 10907c478bd9Sstevel@tonic-gate goto errout; 10917c478bd9Sstevel@tonic-gate /* 10927c478bd9Sstevel@tonic-gate * in case the fs grew; reset the metadata map for logging tests 10937c478bd9Sstevel@tonic-gate */ 10947c478bd9Sstevel@tonic-gate TRANS_MATA_UMOUNT(ufsvfsp); 10957c478bd9Sstevel@tonic-gate TRANS_MATA_MOUNT(ufsvfsp); 10967c478bd9Sstevel@tonic-gate TRANS_MATA_SI(ufsvfsp, ufsvfsp->vfs_fs); 10977c478bd9Sstevel@tonic-gate } 10987c478bd9Sstevel@tonic-gate 10997c478bd9Sstevel@tonic-gate /* 11007c478bd9Sstevel@tonic-gate * At least everything *currently* dirty goes out. 11017c478bd9Sstevel@tonic-gate */ 11027c478bd9Sstevel@tonic-gate 11037c478bd9Sstevel@tonic-gate if ((error = ufs_flush(vfsp)) != 0 && !ULOCKFS_IS_HLOCK(ulp) && 11047c478bd9Sstevel@tonic-gate !ULOCKFS_IS_ELOCK(ulp)) 11057c478bd9Sstevel@tonic-gate goto errout; 11067c478bd9Sstevel@tonic-gate 11077c478bd9Sstevel@tonic-gate /* 11087c478bd9Sstevel@tonic-gate * thaw file system and wakeup pended processes 11097c478bd9Sstevel@tonic-gate */ 11107c478bd9Sstevel@tonic-gate if (error = ufs_thaw(vfsp, ufsvfsp, ulp)) 11117c478bd9Sstevel@tonic-gate if (!ULOCKFS_IS_HLOCK(ulp) && !ULOCKFS_IS_ELOCK(ulp)) 11127c478bd9Sstevel@tonic-gate goto errout; 11137c478bd9Sstevel@tonic-gate 11147c478bd9Sstevel@tonic-gate /* 11157c478bd9Sstevel@tonic-gate * reset modified flag if not already write locked 11167c478bd9Sstevel@tonic-gate */ 11177c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_WLOCK(&lfs)) 11187c478bd9Sstevel@tonic-gate ULOCKFS_CLR_MOD(ulp); 11197c478bd9Sstevel@tonic-gate 11207c478bd9Sstevel@tonic-gate /* 11217c478bd9Sstevel@tonic-gate * idle the lock struct 11227c478bd9Sstevel@tonic-gate */ 11237c478bd9Sstevel@tonic-gate ULOCKFS_CLR_BUSY(ulp); 11247c478bd9Sstevel@tonic-gate /* update the ioctl copy */ 11257c478bd9Sstevel@tonic-gate LOCKFS_CLR_BUSY(&ulp->ul_lockfs); 11267c478bd9Sstevel@tonic-gate 11277c478bd9Sstevel@tonic-gate /* 11287c478bd9Sstevel@tonic-gate * free current comment 11297c478bd9Sstevel@tonic-gate */ 11307c478bd9Sstevel@tonic-gate if (lfs.lf_comment && lfs.lf_comlen != 0) { 11317c478bd9Sstevel@tonic-gate kmem_free(lfs.lf_comment, lfs.lf_comlen); 11327c478bd9Sstevel@tonic-gate lfs.lf_comment = NULL; 11337c478bd9Sstevel@tonic-gate lfs.lf_comlen = 0; 11347c478bd9Sstevel@tonic-gate } 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate /* do error lock cleanup */ 11377c478bd9Sstevel@tonic-gate if (errlck == UN_ERRLCK) 11387c478bd9Sstevel@tonic-gate ufsfx_unlockfs(ufsvfsp); 11397c478bd9Sstevel@tonic-gate 11407c478bd9Sstevel@tonic-gate else if (errlck == RE_ERRLCK) 11417c478bd9Sstevel@tonic-gate ufsfx_lockfs(ufsvfsp); 11427c478bd9Sstevel@tonic-gate 11437c478bd9Sstevel@tonic-gate /* don't allow error lock from user to invoke panic */ 11447c478bd9Sstevel@tonic-gate else if (from_user && errlck == SET_ERRLCK && 11457c478bd9Sstevel@tonic-gate !(ufsvfsp->vfs_fsfx.fx_flags & (UFSMNT_ONERROR_PANIC >> 4))) 11467c478bd9Sstevel@tonic-gate (void) ufs_fault(ufsvfsp->vfs_root, 11477c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comment && ulp->ul_lockfs.lf_comlen > 0 ? 11487c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comment: "user-applied error lock"); 11497c478bd9Sstevel@tonic-gate 1150bc69f433Saguzovsk atomic_add_long(&ufs_quiesce_pend, -1); 11517c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 11527c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 11537c478bd9Sstevel@tonic-gate 11547c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(&ufsvfsp->vfs_ulockfs)) 11557c478bd9Sstevel@tonic-gate poll_events |= POLLERR; 11567c478bd9Sstevel@tonic-gate 11577c478bd9Sstevel@tonic-gate pollwakeup(&ufs_pollhd, poll_events); 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate /* 11607c478bd9Sstevel@tonic-gate * Allow both the delete thread and the reclaim thread to 11617c478bd9Sstevel@tonic-gate * continue. 11627c478bd9Sstevel@tonic-gate */ 11637c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_delete); 11647c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_reclaim); 11657c478bd9Sstevel@tonic-gate 11667c478bd9Sstevel@tonic-gate return (0); 11677c478bd9Sstevel@tonic-gate 11687c478bd9Sstevel@tonic-gate errout: 11697c478bd9Sstevel@tonic-gate /* 11707c478bd9Sstevel@tonic-gate * Lock failed. Reset the old lock in ufsvfs if not hard locked. 11717c478bd9Sstevel@tonic-gate */ 11727c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_HLOCK(&ulp->ul_lockfs)) { 11737c478bd9Sstevel@tonic-gate bcopy(&lfs, &ulp->ul_lockfs, sizeof (struct lockfs)); 11747c478bd9Sstevel@tonic-gate ulp->ul_fs_lock = (1 << lfs.lf_lock); 11757c478bd9Sstevel@tonic-gate } 1176*46ac4468Smishra 1177*46ac4468Smishra /* 1178*46ac4468Smishra * Don't call ufs_thaw() when there's a signal during 1179*46ac4468Smishra * ufs quiesce operation as it can lead to deadlock 1180*46ac4468Smishra * with getpage. 1181*46ac4468Smishra */ 1182*46ac4468Smishra if (signal == 0) 1183*46ac4468Smishra (void) ufs_thaw(vfsp, ufsvfsp, ulp); 1184*46ac4468Smishra 11857c478bd9Sstevel@tonic-gate ULOCKFS_CLR_BUSY(ulp); 11867c478bd9Sstevel@tonic-gate LOCKFS_CLR_BUSY(&ulp->ul_lockfs); 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate errexit: 1189bc69f433Saguzovsk atomic_add_long(&ufs_quiesce_pend, -1); 11907c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 11917c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 11927c478bd9Sstevel@tonic-gate 11937c478bd9Sstevel@tonic-gate /* 11947c478bd9Sstevel@tonic-gate * Allow both the delete thread and the reclaim thread to 11957c478bd9Sstevel@tonic-gate * continue. 11967c478bd9Sstevel@tonic-gate */ 11977c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_delete); 11987c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_reclaim); 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate return (error); 12017c478bd9Sstevel@tonic-gate } 12027c478bd9Sstevel@tonic-gate 12037c478bd9Sstevel@tonic-gate /* 12047c478bd9Sstevel@tonic-gate * fiolfss 12057c478bd9Sstevel@tonic-gate * return the current file system locking state info 12067c478bd9Sstevel@tonic-gate */ 12077c478bd9Sstevel@tonic-gate int 12087c478bd9Sstevel@tonic-gate ufs_fiolfss(struct vnode *vp, struct lockfs *lockfsp) 12097c478bd9Sstevel@tonic-gate { 12107c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 12117c478bd9Sstevel@tonic-gate 12127c478bd9Sstevel@tonic-gate if (!vp || !vp->v_vfsp || !VTOI(vp)) 12137c478bd9Sstevel@tonic-gate return (EINVAL); 12147c478bd9Sstevel@tonic-gate 12157c478bd9Sstevel@tonic-gate /* file system has been forcibly unmounted */ 12167c478bd9Sstevel@tonic-gate if (VTOI(vp)->i_ufsvfs == NULL) 12177c478bd9Sstevel@tonic-gate return (EIO); 12187c478bd9Sstevel@tonic-gate 12197c478bd9Sstevel@tonic-gate ulp = VTOUL(vp); 12207c478bd9Sstevel@tonic-gate 12217c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(ulp)) { 12227c478bd9Sstevel@tonic-gate *lockfsp = ulp->ul_lockfs; /* structure assignment */ 12237c478bd9Sstevel@tonic-gate return (0); 12247c478bd9Sstevel@tonic-gate } 12257c478bd9Sstevel@tonic-gate 12267c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 12277c478bd9Sstevel@tonic-gate 12287c478bd9Sstevel@tonic-gate *lockfsp = ulp->ul_lockfs; /* structure assignment */ 12297c478bd9Sstevel@tonic-gate 12307c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_MOD(ulp)) 12317c478bd9Sstevel@tonic-gate lockfsp->lf_flags |= LOCKFS_MOD; 12327c478bd9Sstevel@tonic-gate 12337c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 12347c478bd9Sstevel@tonic-gate 12357c478bd9Sstevel@tonic-gate return (0); 12367c478bd9Sstevel@tonic-gate } 12377c478bd9Sstevel@tonic-gate 12387c478bd9Sstevel@tonic-gate /* 12397c478bd9Sstevel@tonic-gate * ufs_check_lockfs 12407c478bd9Sstevel@tonic-gate * check whether a ufs_vnops conflicts with the file system lock 12417c478bd9Sstevel@tonic-gate */ 12427c478bd9Sstevel@tonic-gate int 12437c478bd9Sstevel@tonic-gate ufs_check_lockfs(struct ufsvfs *ufsvfsp, struct ulockfs *ulp, ulong_t mask) 12447c478bd9Sstevel@tonic-gate { 12457c478bd9Sstevel@tonic-gate k_sigset_t smask; 12467c478bd9Sstevel@tonic-gate int sig, slock; 12477c478bd9Sstevel@tonic-gate 12487c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&ulp->ul_lock)); 12497c478bd9Sstevel@tonic-gate 12507c478bd9Sstevel@tonic-gate while (ulp->ul_fs_lock & mask) { 12517c478bd9Sstevel@tonic-gate slock = (int)ULOCKFS_IS_SLOCK(ulp); 12527c478bd9Sstevel@tonic-gate if ((curthread->t_flag & T_DONTPEND) && !slock) { 12537c478bd9Sstevel@tonic-gate curthread->t_flag |= T_WOULDBLOCK; 12547c478bd9Sstevel@tonic-gate return (EAGAIN); 12557c478bd9Sstevel@tonic-gate } 12567c478bd9Sstevel@tonic-gate curthread->t_flag &= ~T_WOULDBLOCK; 12577c478bd9Sstevel@tonic-gate 125866c9f83dSowenr /* 125966c9f83dSowenr * In the case of an onerr umount of the fs, threads could 126066c9f83dSowenr * have blocked before coming into ufs_check_lockfs and 126166c9f83dSowenr * need to check for the special case of ELOCK and 126266c9f83dSowenr * vfs_dontblock being set which would indicate that the fs 126366c9f83dSowenr * is on its way out and will not return therefore making 126466c9f83dSowenr * EIO the appropriate response. 126566c9f83dSowenr */ 126666c9f83dSowenr if (ULOCKFS_IS_HLOCK(ulp) || 126766c9f83dSowenr (ULOCKFS_IS_ELOCK(ulp) && ufsvfsp->vfs_dontblock)) 12687c478bd9Sstevel@tonic-gate return (EIO); 12697c478bd9Sstevel@tonic-gate 12707c478bd9Sstevel@tonic-gate /* 12717c478bd9Sstevel@tonic-gate * wait for lock status to change 12727c478bd9Sstevel@tonic-gate */ 12737c478bd9Sstevel@tonic-gate if (slock || ufsvfsp->vfs_nointr) { 12747c478bd9Sstevel@tonic-gate cv_wait(&ulp->ul_cv, &ulp->ul_lock); 12757c478bd9Sstevel@tonic-gate } else { 12767c478bd9Sstevel@tonic-gate sigintr(&smask, 1); 12777c478bd9Sstevel@tonic-gate sig = cv_wait_sig(&ulp->ul_cv, &ulp->ul_lock); 12787c478bd9Sstevel@tonic-gate sigunintr(&smask); 12797c478bd9Sstevel@tonic-gate if ((!sig && (ulp->ul_fs_lock & mask)) || 12807c478bd9Sstevel@tonic-gate ufsvfsp->vfs_dontblock) 12817c478bd9Sstevel@tonic-gate return (EINTR); 12827c478bd9Sstevel@tonic-gate } 12837c478bd9Sstevel@tonic-gate } 1284303bf60bSsdebnath 1285303bf60bSsdebnath if (mask & ULOCKFS_FWLOCK) { 1286303bf60bSsdebnath atomic_add_long(&ulp->ul_falloc_cnt, 1); 1287303bf60bSsdebnath ULOCKFS_SET_FALLOC(ulp); 1288303bf60bSsdebnath } else { 1289303bf60bSsdebnath atomic_add_long(&ulp->ul_vnops_cnt, 1); 1290303bf60bSsdebnath } 1291303bf60bSsdebnath 12927c478bd9Sstevel@tonic-gate return (0); 12937c478bd9Sstevel@tonic-gate } 12947c478bd9Sstevel@tonic-gate 12957c478bd9Sstevel@tonic-gate /* 12967c478bd9Sstevel@tonic-gate * Check whether we came across the handcrafted lockfs protocol path. We can't 12977c478bd9Sstevel@tonic-gate * simply check for T_DONTBLOCK here as one would assume since this can also 12987c478bd9Sstevel@tonic-gate * falsely catch recursive VOP's going to a different filesystem, instead we 12997c478bd9Sstevel@tonic-gate * check if we already hold the ulockfs->ul_lock mutex. 13007c478bd9Sstevel@tonic-gate */ 13017c478bd9Sstevel@tonic-gate static int 13027c478bd9Sstevel@tonic-gate ufs_lockfs_is_under_rawlockfs(struct ulockfs *ulp) 13037c478bd9Sstevel@tonic-gate { 13047c478bd9Sstevel@tonic-gate return ((mutex_owner(&ulp->ul_lock) != curthread) ? 0 : 1); 13057c478bd9Sstevel@tonic-gate } 13067c478bd9Sstevel@tonic-gate 13077c478bd9Sstevel@tonic-gate /* 13087c478bd9Sstevel@tonic-gate * ufs_lockfs_begin - start the lockfs locking protocol 13097c478bd9Sstevel@tonic-gate */ 13107c478bd9Sstevel@tonic-gate int 13117c478bd9Sstevel@tonic-gate ufs_lockfs_begin(struct ufsvfs *ufsvfsp, struct ulockfs **ulpp, ulong_t mask) 13127c478bd9Sstevel@tonic-gate { 13137c478bd9Sstevel@tonic-gate int error; 13147c478bd9Sstevel@tonic-gate int rec_vop; 13157c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 13167c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info; 13177c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_free; 13187c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_temp; 13197c478bd9Sstevel@tonic-gate 13207c478bd9Sstevel@tonic-gate /* 13217c478bd9Sstevel@tonic-gate * file system has been forcibly unmounted 13227c478bd9Sstevel@tonic-gate */ 13237c478bd9Sstevel@tonic-gate if (ufsvfsp == NULL) 13247c478bd9Sstevel@tonic-gate return (EIO); 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate *ulpp = ulp = &ufsvfsp->vfs_ulockfs; 13277c478bd9Sstevel@tonic-gate 13287c478bd9Sstevel@tonic-gate /* 13297c478bd9Sstevel@tonic-gate * Do lockfs protocol 13307c478bd9Sstevel@tonic-gate */ 13317c478bd9Sstevel@tonic-gate ulockfs_info = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 13327c478bd9Sstevel@tonic-gate IS_REC_VOP(rec_vop, ulockfs_info, ulp, ulockfs_info_free); 13337c478bd9Sstevel@tonic-gate 13347c478bd9Sstevel@tonic-gate /* 13357c478bd9Sstevel@tonic-gate * Detect recursive VOP call or handcrafted internal lockfs protocol 13367c478bd9Sstevel@tonic-gate * path and bail out in that case. 13377c478bd9Sstevel@tonic-gate */ 13387c478bd9Sstevel@tonic-gate if (rec_vop || ufs_lockfs_is_under_rawlockfs(ulp)) { 13397c478bd9Sstevel@tonic-gate *ulpp = NULL; 13407c478bd9Sstevel@tonic-gate return (0); 13417c478bd9Sstevel@tonic-gate } else { 13427c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) { 13437c478bd9Sstevel@tonic-gate if ((ulockfs_info_temp = (ulockfs_info_t *) 13447c478bd9Sstevel@tonic-gate kmem_zalloc(sizeof (ulockfs_info_t), 13457c478bd9Sstevel@tonic-gate KM_NOSLEEP)) == NULL) { 13467c478bd9Sstevel@tonic-gate *ulpp = NULL; 13477c478bd9Sstevel@tonic-gate return (ENOMEM); 13487c478bd9Sstevel@tonic-gate } 13497c478bd9Sstevel@tonic-gate } 13507c478bd9Sstevel@tonic-gate } 13517c478bd9Sstevel@tonic-gate 13527c478bd9Sstevel@tonic-gate /* 13537c478bd9Sstevel@tonic-gate * First time VOP call 13547c478bd9Sstevel@tonic-gate */ 13557c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 1356303bf60bSsdebnath if (ULOCKFS_IS_JUSTULOCK(ulp)) { 1357303bf60bSsdebnath if (mask & ULOCKFS_FWLOCK) { 1358303bf60bSsdebnath atomic_add_long(&ulp->ul_falloc_cnt, 1); 1359303bf60bSsdebnath ULOCKFS_SET_FALLOC(ulp); 1360303bf60bSsdebnath } else { 1361303bf60bSsdebnath atomic_add_long(&ulp->ul_vnops_cnt, 1); 1362303bf60bSsdebnath } 1363303bf60bSsdebnath } else { 13647c478bd9Sstevel@tonic-gate if (error = ufs_check_lockfs(ufsvfsp, ulp, mask)) { 13657c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 13667c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) 13677c478bd9Sstevel@tonic-gate kmem_free(ulockfs_info_temp, 13687c478bd9Sstevel@tonic-gate sizeof (ulockfs_info_t)); 13697c478bd9Sstevel@tonic-gate return (error); 13707c478bd9Sstevel@tonic-gate } 13717c478bd9Sstevel@tonic-gate } 13727c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 13737c478bd9Sstevel@tonic-gate 13747c478bd9Sstevel@tonic-gate if (ulockfs_info_free != NULL) { 13757c478bd9Sstevel@tonic-gate ulockfs_info_free->ulp = ulp; 1376303bf60bSsdebnath if (mask & ULOCKFS_FWLOCK) 1377303bf60bSsdebnath ulockfs_info_free->flags |= ULOCK_INFO_FALLOCATE; 13787c478bd9Sstevel@tonic-gate } else { 13797c478bd9Sstevel@tonic-gate ulockfs_info_temp->ulp = ulp; 13807c478bd9Sstevel@tonic-gate ulockfs_info_temp->next = ulockfs_info; 1381303bf60bSsdebnath if (mask & ULOCKFS_FWLOCK) 1382303bf60bSsdebnath ulockfs_info_temp->flags |= ULOCK_INFO_FALLOCATE; 13837c478bd9Sstevel@tonic-gate ASSERT(ufs_lockfs_key != 0); 13847c478bd9Sstevel@tonic-gate (void) tsd_set(ufs_lockfs_key, (void *)ulockfs_info_temp); 13857c478bd9Sstevel@tonic-gate } 13867c478bd9Sstevel@tonic-gate 13877c478bd9Sstevel@tonic-gate curthread->t_flag |= T_DONTBLOCK; 13887c478bd9Sstevel@tonic-gate return (0); 13897c478bd9Sstevel@tonic-gate } 13907c478bd9Sstevel@tonic-gate 13917c478bd9Sstevel@tonic-gate /* 13927c478bd9Sstevel@tonic-gate * Check whether we are returning from the top level VOP. 13937c478bd9Sstevel@tonic-gate */ 13947c478bd9Sstevel@tonic-gate static int 13957c478bd9Sstevel@tonic-gate ufs_lockfs_top_vop_return(ulockfs_info_t *head) 13967c478bd9Sstevel@tonic-gate { 13977c478bd9Sstevel@tonic-gate ulockfs_info_t *info; 13987c478bd9Sstevel@tonic-gate int result = 1; 13997c478bd9Sstevel@tonic-gate 14007c478bd9Sstevel@tonic-gate for (info = head; info != NULL; info = info->next) { 14017c478bd9Sstevel@tonic-gate if (info->ulp != NULL) { 14027c478bd9Sstevel@tonic-gate result = 0; 14037c478bd9Sstevel@tonic-gate break; 14047c478bd9Sstevel@tonic-gate } 14057c478bd9Sstevel@tonic-gate } 14067c478bd9Sstevel@tonic-gate 14077c478bd9Sstevel@tonic-gate return (result); 14087c478bd9Sstevel@tonic-gate } 14097c478bd9Sstevel@tonic-gate 14107c478bd9Sstevel@tonic-gate /* 14117c478bd9Sstevel@tonic-gate * ufs_lockfs_end - terminate the lockfs locking protocol 14127c478bd9Sstevel@tonic-gate */ 14137c478bd9Sstevel@tonic-gate void 14147c478bd9Sstevel@tonic-gate ufs_lockfs_end(struct ulockfs *ulp) 14157c478bd9Sstevel@tonic-gate { 14167c478bd9Sstevel@tonic-gate ulockfs_info_t *info; 14177c478bd9Sstevel@tonic-gate ulockfs_info_t *head; 14187c478bd9Sstevel@tonic-gate 14197c478bd9Sstevel@tonic-gate /* 14207c478bd9Sstevel@tonic-gate * end-of-VOP protocol 14217c478bd9Sstevel@tonic-gate */ 14227c478bd9Sstevel@tonic-gate if (ulp == NULL) 14237c478bd9Sstevel@tonic-gate return; 14247c478bd9Sstevel@tonic-gate 14257c478bd9Sstevel@tonic-gate head = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 14267c478bd9Sstevel@tonic-gate SEARCH_ULOCKFSP(head, ulp, info); 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate /* 14297c478bd9Sstevel@tonic-gate * If we're called from a first level VOP, we have to have a 14307c478bd9Sstevel@tonic-gate * valid ulockfs record in the TSD. 14317c478bd9Sstevel@tonic-gate */ 14327c478bd9Sstevel@tonic-gate ASSERT(info != NULL); 14337c478bd9Sstevel@tonic-gate 14347c478bd9Sstevel@tonic-gate /* 14357c478bd9Sstevel@tonic-gate * Invalidate the ulockfs record. 14367c478bd9Sstevel@tonic-gate */ 14377c478bd9Sstevel@tonic-gate info->ulp = NULL; 14387c478bd9Sstevel@tonic-gate 14397c478bd9Sstevel@tonic-gate if (ufs_lockfs_top_vop_return(head)) 14407c478bd9Sstevel@tonic-gate curthread->t_flag &= ~T_DONTBLOCK; 14417c478bd9Sstevel@tonic-gate 14427c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 14437c478bd9Sstevel@tonic-gate 1444303bf60bSsdebnath /* fallocate thread */ 1445303bf60bSsdebnath if (ULOCKFS_IS_FALLOC(ulp) && info->flags & ULOCK_INFO_FALLOCATE) { 1446303bf60bSsdebnath if (!atomic_add_long_nv(&ulp->ul_falloc_cnt, -1)) 1447303bf60bSsdebnath ULOCKFS_CLR_FALLOC(ulp); 1448303bf60bSsdebnath } else { /* normal thread */ 1449303bf60bSsdebnath if (!atomic_add_long_nv(&ulp->ul_vnops_cnt, -1)) 1450303bf60bSsdebnath cv_broadcast(&ulp->ul_cv); 1451303bf60bSsdebnath } 1452303bf60bSsdebnath 1453303bf60bSsdebnath /* Clear the thread's fallocate state */ 1454303bf60bSsdebnath if (info->flags & ULOCK_INFO_FALLOCATE) 1455303bf60bSsdebnath info->flags &= ~ULOCK_INFO_FALLOCATE; 1456303bf60bSsdebnath 1457303bf60bSsdebnath if (ulp->ul_vnops_cnt == 0 && ulp->ul_falloc_cnt) 14587c478bd9Sstevel@tonic-gate cv_broadcast(&ulp->ul_cv); 14597c478bd9Sstevel@tonic-gate 14607c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 14617c478bd9Sstevel@tonic-gate } 14627c478bd9Sstevel@tonic-gate 14637c478bd9Sstevel@tonic-gate /* 14647c478bd9Sstevel@tonic-gate * specialized version of ufs_lockfs_begin() called by ufs_getpage(). 14657c478bd9Sstevel@tonic-gate */ 14667c478bd9Sstevel@tonic-gate int 14677c478bd9Sstevel@tonic-gate ufs_lockfs_begin_getpage( 14687c478bd9Sstevel@tonic-gate struct ufsvfs *ufsvfsp, 14697c478bd9Sstevel@tonic-gate struct ulockfs **ulpp, 14707c478bd9Sstevel@tonic-gate struct seg *seg, 14717c478bd9Sstevel@tonic-gate int read_access, 14727c478bd9Sstevel@tonic-gate uint_t *protp) 14737c478bd9Sstevel@tonic-gate { 14747c478bd9Sstevel@tonic-gate ulong_t mask; 14757c478bd9Sstevel@tonic-gate int error; 14767c478bd9Sstevel@tonic-gate int rec_vop; 14777c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 14787c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info; 14797c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_free; 14807c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_temp; 14817c478bd9Sstevel@tonic-gate 14827c478bd9Sstevel@tonic-gate /* 14837c478bd9Sstevel@tonic-gate * file system has been forcibly unmounted 14847c478bd9Sstevel@tonic-gate */ 14857c478bd9Sstevel@tonic-gate if (ufsvfsp == NULL) 14867c478bd9Sstevel@tonic-gate return (EIO); 14877c478bd9Sstevel@tonic-gate 14887c478bd9Sstevel@tonic-gate *ulpp = ulp = &ufsvfsp->vfs_ulockfs; 14897c478bd9Sstevel@tonic-gate 14907c478bd9Sstevel@tonic-gate /* 14917c478bd9Sstevel@tonic-gate * Do lockfs protocol 14927c478bd9Sstevel@tonic-gate */ 14937c478bd9Sstevel@tonic-gate ulockfs_info = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 14947c478bd9Sstevel@tonic-gate IS_REC_VOP(rec_vop, ulockfs_info, ulp, ulockfs_info_free); 14957c478bd9Sstevel@tonic-gate 14967c478bd9Sstevel@tonic-gate /* 14977c478bd9Sstevel@tonic-gate * Detect recursive VOP call or handcrafted internal lockfs protocol 14987c478bd9Sstevel@tonic-gate * path and bail out in that case. 14997c478bd9Sstevel@tonic-gate */ 15007c478bd9Sstevel@tonic-gate if (rec_vop || ufs_lockfs_is_under_rawlockfs(ulp)) { 15017c478bd9Sstevel@tonic-gate *ulpp = NULL; 15027c478bd9Sstevel@tonic-gate return (0); 15037c478bd9Sstevel@tonic-gate } else { 15047c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) { 15057c478bd9Sstevel@tonic-gate if ((ulockfs_info_temp = (ulockfs_info_t *) 15067c478bd9Sstevel@tonic-gate kmem_zalloc(sizeof (ulockfs_info_t), 15077c478bd9Sstevel@tonic-gate KM_NOSLEEP)) == NULL) { 15087c478bd9Sstevel@tonic-gate *ulpp = NULL; 15097c478bd9Sstevel@tonic-gate return (ENOMEM); 15107c478bd9Sstevel@tonic-gate } 15117c478bd9Sstevel@tonic-gate } 15127c478bd9Sstevel@tonic-gate } 15137c478bd9Sstevel@tonic-gate 15147c478bd9Sstevel@tonic-gate /* 15157c478bd9Sstevel@tonic-gate * First time VOP call 15167c478bd9Sstevel@tonic-gate */ 15177c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 15187c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_JUSTULOCK(ulp)) 15197c478bd9Sstevel@tonic-gate /* 15207c478bd9Sstevel@tonic-gate * fs is not locked, simply inc the active-ops counter 15217c478bd9Sstevel@tonic-gate */ 1522bc69f433Saguzovsk atomic_add_long(&ulp->ul_vnops_cnt, 1); 15237c478bd9Sstevel@tonic-gate else { 15247c478bd9Sstevel@tonic-gate if (seg->s_ops == &segvn_ops && 15257c478bd9Sstevel@tonic-gate ((struct segvn_data *)seg->s_data)->type != MAP_SHARED) { 15267c478bd9Sstevel@tonic-gate mask = (ulong_t)ULOCKFS_GETREAD_MASK; 15277c478bd9Sstevel@tonic-gate } else if (protp && read_access) { 15287c478bd9Sstevel@tonic-gate /* 15297c478bd9Sstevel@tonic-gate * Restrict the mapping to readonly. 15307c478bd9Sstevel@tonic-gate * Writes to this mapping will cause 15317c478bd9Sstevel@tonic-gate * another fault which will then 15327c478bd9Sstevel@tonic-gate * be suspended if fs is write locked 15337c478bd9Sstevel@tonic-gate */ 15347c478bd9Sstevel@tonic-gate *protp &= ~PROT_WRITE; 15357c478bd9Sstevel@tonic-gate mask = (ulong_t)ULOCKFS_GETREAD_MASK; 15367c478bd9Sstevel@tonic-gate } else 15377c478bd9Sstevel@tonic-gate mask = (ulong_t)ULOCKFS_GETWRITE_MASK; 15387c478bd9Sstevel@tonic-gate 15397c478bd9Sstevel@tonic-gate /* 15407c478bd9Sstevel@tonic-gate * will sleep if this fs is locked against this VOP 15417c478bd9Sstevel@tonic-gate */ 15427c478bd9Sstevel@tonic-gate if (error = ufs_check_lockfs(ufsvfsp, ulp, mask)) { 15437c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 15447c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) 15457c478bd9Sstevel@tonic-gate kmem_free(ulockfs_info_temp, 15467c478bd9Sstevel@tonic-gate sizeof (ulockfs_info_t)); 15477c478bd9Sstevel@tonic-gate return (error); 15487c478bd9Sstevel@tonic-gate } 15497c478bd9Sstevel@tonic-gate } 15507c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 15517c478bd9Sstevel@tonic-gate 15527c478bd9Sstevel@tonic-gate if (ulockfs_info_free != NULL) { 15537c478bd9Sstevel@tonic-gate ulockfs_info_free->ulp = ulp; 15547c478bd9Sstevel@tonic-gate } else { 15557c478bd9Sstevel@tonic-gate ulockfs_info_temp->ulp = ulp; 15567c478bd9Sstevel@tonic-gate ulockfs_info_temp->next = ulockfs_info; 15577c478bd9Sstevel@tonic-gate ASSERT(ufs_lockfs_key != 0); 15587c478bd9Sstevel@tonic-gate (void) tsd_set(ufs_lockfs_key, (void *)ulockfs_info_temp); 15597c478bd9Sstevel@tonic-gate } 15607c478bd9Sstevel@tonic-gate 15617c478bd9Sstevel@tonic-gate curthread->t_flag |= T_DONTBLOCK; 15627c478bd9Sstevel@tonic-gate return (0); 15637c478bd9Sstevel@tonic-gate } 15647c478bd9Sstevel@tonic-gate 15657c478bd9Sstevel@tonic-gate void 15667c478bd9Sstevel@tonic-gate ufs_lockfs_tsd_destructor(void *head) 15677c478bd9Sstevel@tonic-gate { 15687c478bd9Sstevel@tonic-gate ulockfs_info_t *curr = (ulockfs_info_t *)head; 15697c478bd9Sstevel@tonic-gate ulockfs_info_t *temp; 15707c478bd9Sstevel@tonic-gate 15717c478bd9Sstevel@tonic-gate for (; curr != NULL; ) { 15727c478bd9Sstevel@tonic-gate /* 15737c478bd9Sstevel@tonic-gate * The TSD destructor is being called when the thread exits 15747c478bd9Sstevel@tonic-gate * (via thread_exit()). At that time it must have cleaned up 15757c478bd9Sstevel@tonic-gate * all VOPs via ufs_lockfs_end() and there must not be a 15767c478bd9Sstevel@tonic-gate * valid ulockfs record exist while a thread is exiting. 15777c478bd9Sstevel@tonic-gate */ 15787c478bd9Sstevel@tonic-gate temp = curr; 15797c478bd9Sstevel@tonic-gate curr = curr->next; 15807c478bd9Sstevel@tonic-gate ASSERT(temp->ulp == NULL); 15817c478bd9Sstevel@tonic-gate kmem_free(temp, sizeof (ulockfs_info_t)); 15827c478bd9Sstevel@tonic-gate } 15837c478bd9Sstevel@tonic-gate } 1584