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; 102*303bf60bSsdebnath uint_t flags; 1037c478bd9Sstevel@tonic-gate } ulockfs_info_t; 1047c478bd9Sstevel@tonic-gate 105*303bf60bSsdebnath #define ULOCK_INFO_FALLOCATE 0x00000001 /* fallocate thread */ 106*303bf60bSsdebnath 1077c478bd9Sstevel@tonic-gate /* 1087c478bd9Sstevel@tonic-gate * Check in TSD that whether we are already doing any VOP on this filesystem 1097c478bd9Sstevel@tonic-gate */ 1107c478bd9Sstevel@tonic-gate #define IS_REC_VOP(found, head, ulp, free) \ 1117c478bd9Sstevel@tonic-gate { \ 1127c478bd9Sstevel@tonic-gate ulockfs_info_t *_curr; \ 1137c478bd9Sstevel@tonic-gate \ 1147c478bd9Sstevel@tonic-gate for (found = 0, free = NULL, _curr = head; \ 1157c478bd9Sstevel@tonic-gate _curr != NULL; _curr = _curr->next) { \ 1167c478bd9Sstevel@tonic-gate if ((free == NULL) && \ 1177c478bd9Sstevel@tonic-gate (_curr->ulp == NULL)) \ 1187c478bd9Sstevel@tonic-gate free = _curr; \ 1197c478bd9Sstevel@tonic-gate if (_curr->ulp == ulp) { \ 1207c478bd9Sstevel@tonic-gate found = 1; \ 1217c478bd9Sstevel@tonic-gate break; \ 1227c478bd9Sstevel@tonic-gate } \ 1237c478bd9Sstevel@tonic-gate } \ 1247c478bd9Sstevel@tonic-gate } 1257c478bd9Sstevel@tonic-gate 1267c478bd9Sstevel@tonic-gate /* 1277c478bd9Sstevel@tonic-gate * Get the lockfs data from TSD so that lockfs handles the recursive VOP 1287c478bd9Sstevel@tonic-gate * properly 1297c478bd9Sstevel@tonic-gate */ 1307c478bd9Sstevel@tonic-gate #define SEARCH_ULOCKFSP(head, ulp, info) \ 1317c478bd9Sstevel@tonic-gate { \ 1327c478bd9Sstevel@tonic-gate ulockfs_info_t *_curr; \ 1337c478bd9Sstevel@tonic-gate \ 1347c478bd9Sstevel@tonic-gate for (_curr = head; _curr != NULL; \ 1357c478bd9Sstevel@tonic-gate _curr = _curr->next) { \ 1367c478bd9Sstevel@tonic-gate if (_curr->ulp == ulp) { \ 1377c478bd9Sstevel@tonic-gate break; \ 1387c478bd9Sstevel@tonic-gate } \ 1397c478bd9Sstevel@tonic-gate } \ 1407c478bd9Sstevel@tonic-gate \ 1417c478bd9Sstevel@tonic-gate info = _curr; \ 1427c478bd9Sstevel@tonic-gate } 1437c478bd9Sstevel@tonic-gate 1447c478bd9Sstevel@tonic-gate /* 1457c478bd9Sstevel@tonic-gate * Validate lockfs request 1467c478bd9Sstevel@tonic-gate */ 1477c478bd9Sstevel@tonic-gate static int 1487c478bd9Sstevel@tonic-gate ufs_getlfd( 1497c478bd9Sstevel@tonic-gate struct lockfs *lockfsp, /* new lock request */ 1507c478bd9Sstevel@tonic-gate struct lockfs *ul_lockfsp) /* old lock state */ 1517c478bd9Sstevel@tonic-gate { 1527c478bd9Sstevel@tonic-gate int error = 0; 1537c478bd9Sstevel@tonic-gate 1547c478bd9Sstevel@tonic-gate /* 1557c478bd9Sstevel@tonic-gate * no input flags defined 1567c478bd9Sstevel@tonic-gate */ 1577c478bd9Sstevel@tonic-gate if (lockfsp->lf_flags != 0) { 1587c478bd9Sstevel@tonic-gate error = EINVAL; 1597c478bd9Sstevel@tonic-gate goto errout; 1607c478bd9Sstevel@tonic-gate } 1617c478bd9Sstevel@tonic-gate 1627c478bd9Sstevel@tonic-gate /* 1637c478bd9Sstevel@tonic-gate * check key 1647c478bd9Sstevel@tonic-gate */ 1657c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_ULOCK(ul_lockfsp)) 1667c478bd9Sstevel@tonic-gate if (lockfsp->lf_key != ul_lockfsp->lf_key) { 1677c478bd9Sstevel@tonic-gate error = EINVAL; 1687c478bd9Sstevel@tonic-gate goto errout; 1697c478bd9Sstevel@tonic-gate } 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate lockfsp->lf_key = ul_lockfsp->lf_key + 1; 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate errout: 1747c478bd9Sstevel@tonic-gate return (error); 1757c478bd9Sstevel@tonic-gate } 1767c478bd9Sstevel@tonic-gate 1777c478bd9Sstevel@tonic-gate /* 1787c478bd9Sstevel@tonic-gate * ufs_checkaccton 1797c478bd9Sstevel@tonic-gate * check if accounting is turned on on this fs 1807c478bd9Sstevel@tonic-gate */ 1817c478bd9Sstevel@tonic-gate 1827c478bd9Sstevel@tonic-gate int 1837c478bd9Sstevel@tonic-gate ufs_checkaccton(struct vnode *vp) 1847c478bd9Sstevel@tonic-gate { 1857c478bd9Sstevel@tonic-gate if (acct_fs_in_use(vp)) 1867c478bd9Sstevel@tonic-gate return (EDEADLK); 1877c478bd9Sstevel@tonic-gate return (0); 1887c478bd9Sstevel@tonic-gate } 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate /* 1917c478bd9Sstevel@tonic-gate * ufs_checkswapon 1927c478bd9Sstevel@tonic-gate * check if local swapping is to file on this fs 1937c478bd9Sstevel@tonic-gate */ 1947c478bd9Sstevel@tonic-gate int 1957c478bd9Sstevel@tonic-gate ufs_checkswapon(struct vnode *vp) 1967c478bd9Sstevel@tonic-gate { 1977c478bd9Sstevel@tonic-gate struct swapinfo *sip; 1987c478bd9Sstevel@tonic-gate 1997c478bd9Sstevel@tonic-gate mutex_enter(&swapinfo_lock); 2007c478bd9Sstevel@tonic-gate for (sip = swapinfo; sip; sip = sip->si_next) 2017c478bd9Sstevel@tonic-gate if (sip->si_vp->v_vfsp == vp->v_vfsp) { 2027c478bd9Sstevel@tonic-gate mutex_exit(&swapinfo_lock); 2037c478bd9Sstevel@tonic-gate return (EDEADLK); 2047c478bd9Sstevel@tonic-gate } 2057c478bd9Sstevel@tonic-gate mutex_exit(&swapinfo_lock); 2067c478bd9Sstevel@tonic-gate return (0); 2077c478bd9Sstevel@tonic-gate } 2087c478bd9Sstevel@tonic-gate 2097c478bd9Sstevel@tonic-gate /* 2107c478bd9Sstevel@tonic-gate * ufs_freeze 2117c478bd9Sstevel@tonic-gate * pend future accesses for current lock and desired lock 2127c478bd9Sstevel@tonic-gate */ 2137c478bd9Sstevel@tonic-gate void 2147c478bd9Sstevel@tonic-gate ufs_freeze(struct ulockfs *ulp, struct lockfs *lockfsp) 2157c478bd9Sstevel@tonic-gate { 2167c478bd9Sstevel@tonic-gate /* 2177c478bd9Sstevel@tonic-gate * set to new lock type 2187c478bd9Sstevel@tonic-gate */ 2197c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_lock = lockfsp->lf_lock; 2207c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_key = lockfsp->lf_key; 2217c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comlen = lockfsp->lf_comlen; 2227c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comment = lockfsp->lf_comment; 2237c478bd9Sstevel@tonic-gate 2247c478bd9Sstevel@tonic-gate ulp->ul_fs_lock = (1 << ulp->ul_lockfs.lf_lock); 2257c478bd9Sstevel@tonic-gate } 2267c478bd9Sstevel@tonic-gate 2277c478bd9Sstevel@tonic-gate /* 228bc69f433Saguzovsk * All callers of ufs_quiesce() atomically increment ufs_quiesce_pend before 229bc69f433Saguzovsk * starting ufs_quiesce() protocol and decrement it only when a file system no 230bc69f433Saguzovsk * longer has to be in quiescent state. This allows ufs_pageio() to detect 231bc69f433Saguzovsk * that another thread wants to quiesce a file system. See more comments in 232bc69f433Saguzovsk * ufs_pageio(). 233bc69f433Saguzovsk */ 234bc69f433Saguzovsk ulong_t ufs_quiesce_pend = 0; 235bc69f433Saguzovsk 236bc69f433Saguzovsk /* 2377c478bd9Sstevel@tonic-gate * ufs_quiesce 2387c478bd9Sstevel@tonic-gate * wait for outstanding accesses to finish 2397c478bd9Sstevel@tonic-gate */ 2407c478bd9Sstevel@tonic-gate int 2417c478bd9Sstevel@tonic-gate ufs_quiesce(struct ulockfs *ulp) 2427c478bd9Sstevel@tonic-gate { 2437c478bd9Sstevel@tonic-gate int error = 0; 244*303bf60bSsdebnath ulockfs_info_t *head; 245*303bf60bSsdebnath ulockfs_info_t *info; 246*303bf60bSsdebnath 247*303bf60bSsdebnath head = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 248*303bf60bSsdebnath SEARCH_ULOCKFSP(head, ulp, info); 2497c478bd9Sstevel@tonic-gate 2507c478bd9Sstevel@tonic-gate /* 2517c478bd9Sstevel@tonic-gate * Set a softlock to suspend future ufs_vnops so that 2527c478bd9Sstevel@tonic-gate * this lockfs request will not be starved 2537c478bd9Sstevel@tonic-gate */ 2547c478bd9Sstevel@tonic-gate ULOCKFS_SET_SLOCK(ulp); 255bc69f433Saguzovsk ASSERT(ufs_quiesce_pend); 2567c478bd9Sstevel@tonic-gate 2577c478bd9Sstevel@tonic-gate /* check if there is any outstanding ufs vnodeops calls */ 258*303bf60bSsdebnath while (ulp->ul_vnops_cnt || ulp->ul_falloc_cnt) { 259bc69f433Saguzovsk /* 260bc69f433Saguzovsk * use timed version of cv_wait_sig() to make sure we don't 261bc69f433Saguzovsk * miss a wake up call from ufs_pageio() when it doesn't use 262bc69f433Saguzovsk * ul_lock. 263*303bf60bSsdebnath * 264*303bf60bSsdebnath * when a fallocate thread comes in, the only way it returns 265*303bf60bSsdebnath * from this function is if there are no other vnode operations 266*303bf60bSsdebnath * going on (remember fallocate threads are tracked using 267*303bf60bSsdebnath * ul_falloc_cnt not ul_vnops_cnt), and another fallocate thread 268*303bf60bSsdebnath * hasn't already grabbed the fs write lock. 269bc69f433Saguzovsk */ 270*303bf60bSsdebnath if (info && (info->flags & ULOCK_INFO_FALLOCATE)) { 271*303bf60bSsdebnath if (!ulp->ul_vnops_cnt && !ULOCKFS_IS_FWLOCK(ulp)) 272*303bf60bSsdebnath goto out; 273*303bf60bSsdebnath } 274bc69f433Saguzovsk if (!cv_timedwait_sig(&ulp->ul_cv, &ulp->ul_lock, lbolt + hz)) { 2757c478bd9Sstevel@tonic-gate error = EINTR; 2767c478bd9Sstevel@tonic-gate goto out; 2777c478bd9Sstevel@tonic-gate } 278*303bf60bSsdebnath } 2797c478bd9Sstevel@tonic-gate 2807c478bd9Sstevel@tonic-gate out: 2817c478bd9Sstevel@tonic-gate /* 2827c478bd9Sstevel@tonic-gate * unlock the soft lock 2837c478bd9Sstevel@tonic-gate */ 2847c478bd9Sstevel@tonic-gate ULOCKFS_CLR_SLOCK(ulp); 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate return (error); 2877c478bd9Sstevel@tonic-gate } 288*303bf60bSsdebnath 2897c478bd9Sstevel@tonic-gate /* 2907c478bd9Sstevel@tonic-gate * ufs_flush_inode 2917c478bd9Sstevel@tonic-gate */ 2927c478bd9Sstevel@tonic-gate int 2937c478bd9Sstevel@tonic-gate ufs_flush_inode(struct inode *ip, void *arg) 2947c478bd9Sstevel@tonic-gate { 2957c478bd9Sstevel@tonic-gate int error; 2967c478bd9Sstevel@tonic-gate int saverror = 0; 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate /* 2997c478bd9Sstevel@tonic-gate * wrong file system; keep looking 3007c478bd9Sstevel@tonic-gate */ 3017c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 3027c478bd9Sstevel@tonic-gate return (0); 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate /* 3057c478bd9Sstevel@tonic-gate * asynchronously push all the dirty pages 3067c478bd9Sstevel@tonic-gate */ 3077c478bd9Sstevel@tonic-gate if (((error = TRANS_SYNCIP(ip, B_ASYNC, 0, TOP_SYNCIP_FLUSHI)) != 0) && 3087c478bd9Sstevel@tonic-gate (error != EAGAIN)) 3097c478bd9Sstevel@tonic-gate saverror = error; 3107c478bd9Sstevel@tonic-gate /* 3117c478bd9Sstevel@tonic-gate * wait for io and discard all mappings 3127c478bd9Sstevel@tonic-gate */ 3137c478bd9Sstevel@tonic-gate if (error = TRANS_SYNCIP(ip, B_INVAL, 0, TOP_SYNCIP_FLUSHI)) 3147c478bd9Sstevel@tonic-gate saverror = error; 3157c478bd9Sstevel@tonic-gate 3167c478bd9Sstevel@tonic-gate if (ITOV(ip)->v_type == VDIR) { 3177c478bd9Sstevel@tonic-gate dnlc_dir_purge(&ip->i_danchor); 3187c478bd9Sstevel@tonic-gate } 3197c478bd9Sstevel@tonic-gate 3207c478bd9Sstevel@tonic-gate return (saverror); 3217c478bd9Sstevel@tonic-gate } 3227c478bd9Sstevel@tonic-gate 3237c478bd9Sstevel@tonic-gate /* 3247c478bd9Sstevel@tonic-gate * ufs_flush 3257c478bd9Sstevel@tonic-gate * Flush everything that is currently dirty; this includes invalidating 3267c478bd9Sstevel@tonic-gate * any mappings. 3277c478bd9Sstevel@tonic-gate */ 3287c478bd9Sstevel@tonic-gate int 3297c478bd9Sstevel@tonic-gate ufs_flush(struct vfs *vfsp) 3307c478bd9Sstevel@tonic-gate { 3317c478bd9Sstevel@tonic-gate int error; 3327c478bd9Sstevel@tonic-gate int saverror = 0; 3337c478bd9Sstevel@tonic-gate struct ufsvfs *ufsvfsp = (struct ufsvfs *)vfsp->vfs_data; 3347c478bd9Sstevel@tonic-gate struct fs *fs = ufsvfsp->vfs_fs; 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 { 4067c478bd9Sstevel@tonic-gate curthread->t_flag |= T_DONTBLOCK; 40714c932c0Sbatschul TRANS_BEGIN_SYNC(ufsvfsp, TOP_COMMIT_FLUSH, 40814c932c0Sbatschul TOP_COMMIT_SIZE, error); 4097c478bd9Sstevel@tonic-gate if (!error) { 41014c932c0Sbatschul TRANS_END_SYNC(ufsvfsp, saverror, 41114c932c0Sbatschul TOP_COMMIT_FLUSH, TOP_COMMIT_SIZE); 4127c478bd9Sstevel@tonic-gate } 4137c478bd9Sstevel@tonic-gate curthread->t_flag &= ~T_DONTBLOCK; 41414c932c0Sbatschul logmap_roll_dev(ufsvfsp->vfs_log); 41514c932c0Sbatschul } 4167c478bd9Sstevel@tonic-gate } 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate return (saverror); 4197c478bd9Sstevel@tonic-gate } 4207c478bd9Sstevel@tonic-gate 4217c478bd9Sstevel@tonic-gate /* 4227c478bd9Sstevel@tonic-gate * ufs_thaw_wlock 4237c478bd9Sstevel@tonic-gate * special processing when thawing down to wlock 4247c478bd9Sstevel@tonic-gate */ 4257c478bd9Sstevel@tonic-gate static int 4267c478bd9Sstevel@tonic-gate ufs_thaw_wlock(struct inode *ip, void *arg) 4277c478bd9Sstevel@tonic-gate { 4287c478bd9Sstevel@tonic-gate /* 4297c478bd9Sstevel@tonic-gate * wrong file system; keep looking 4307c478bd9Sstevel@tonic-gate */ 4317c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 4327c478bd9Sstevel@tonic-gate return (0); 4337c478bd9Sstevel@tonic-gate 4347c478bd9Sstevel@tonic-gate /* 4357c478bd9Sstevel@tonic-gate * iupdat refuses to clear flags if the fs is read only. The fs 4367c478bd9Sstevel@tonic-gate * may become read/write during the lock and we wouldn't want 4377c478bd9Sstevel@tonic-gate * these inodes being written to disk. So clear the flags. 4387c478bd9Sstevel@tonic-gate */ 4397c478bd9Sstevel@tonic-gate rw_enter(&ip->i_contents, RW_WRITER); 4407c478bd9Sstevel@tonic-gate ip->i_flag &= ~(IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG); 4417c478bd9Sstevel@tonic-gate rw_exit(&ip->i_contents); 4427c478bd9Sstevel@tonic-gate 4437c478bd9Sstevel@tonic-gate /* 4447c478bd9Sstevel@tonic-gate * pages are mlocked -- fail wlock 4457c478bd9Sstevel@tonic-gate */ 4467c478bd9Sstevel@tonic-gate if (ITOV(ip)->v_type != VCHR && vn_has_cached_data(ITOV(ip))) 4477c478bd9Sstevel@tonic-gate return (EBUSY); 4487c478bd9Sstevel@tonic-gate 4497c478bd9Sstevel@tonic-gate return (0); 4507c478bd9Sstevel@tonic-gate } 4517c478bd9Sstevel@tonic-gate 4527c478bd9Sstevel@tonic-gate /* 4537c478bd9Sstevel@tonic-gate * ufs_thaw_hlock 4547c478bd9Sstevel@tonic-gate * special processing when thawing down to hlock or elock 4557c478bd9Sstevel@tonic-gate */ 4567c478bd9Sstevel@tonic-gate static int 4577c478bd9Sstevel@tonic-gate ufs_thaw_hlock(struct inode *ip, void *arg) 4587c478bd9Sstevel@tonic-gate { 4597c478bd9Sstevel@tonic-gate struct vnode *vp = ITOV(ip); 4607c478bd9Sstevel@tonic-gate 4617c478bd9Sstevel@tonic-gate /* 4627c478bd9Sstevel@tonic-gate * wrong file system; keep looking 4637c478bd9Sstevel@tonic-gate */ 4647c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 4657c478bd9Sstevel@tonic-gate return (0); 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate /* 4687c478bd9Sstevel@tonic-gate * blow away all pages - even if they are mlocked 4697c478bd9Sstevel@tonic-gate */ 4707c478bd9Sstevel@tonic-gate do { 4717c478bd9Sstevel@tonic-gate (void) TRANS_SYNCIP(ip, B_INVAL | B_FORCE, 0, TOP_SYNCIP_HLOCK); 4727c478bd9Sstevel@tonic-gate } while ((vp->v_type != VCHR) && vn_has_cached_data(vp)); 4737c478bd9Sstevel@tonic-gate rw_enter(&ip->i_contents, RW_WRITER); 4747c478bd9Sstevel@tonic-gate ip->i_flag &= ~(IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG); 4757c478bd9Sstevel@tonic-gate rw_exit(&ip->i_contents); 4767c478bd9Sstevel@tonic-gate 4777c478bd9Sstevel@tonic-gate return (0); 4787c478bd9Sstevel@tonic-gate } 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate /* 4817c478bd9Sstevel@tonic-gate * ufs_thaw 4827c478bd9Sstevel@tonic-gate * thaw file system lock down to current value 4837c478bd9Sstevel@tonic-gate */ 4847c478bd9Sstevel@tonic-gate int 4857c478bd9Sstevel@tonic-gate ufs_thaw(struct vfs *vfsp, struct ufsvfs *ufsvfsp, struct ulockfs *ulp) 4867c478bd9Sstevel@tonic-gate { 4877c478bd9Sstevel@tonic-gate int error = 0; 4887c478bd9Sstevel@tonic-gate int noidel = (int)(ulp->ul_flag & ULOCKFS_NOIDEL); 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate /* 4917c478bd9Sstevel@tonic-gate * if wlock or hlock or elock 4927c478bd9Sstevel@tonic-gate */ 4937c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_WLOCK(ulp) || ULOCKFS_IS_HLOCK(ulp) || 4947c478bd9Sstevel@tonic-gate ULOCKFS_IS_ELOCK(ulp)) { 4957c478bd9Sstevel@tonic-gate 4967c478bd9Sstevel@tonic-gate /* 4977c478bd9Sstevel@tonic-gate * don't keep access times 4987c478bd9Sstevel@tonic-gate * don't free deleted files 4997c478bd9Sstevel@tonic-gate * if superblock writes are allowed, limit them to me for now 5007c478bd9Sstevel@tonic-gate */ 5017c478bd9Sstevel@tonic-gate ulp->ul_flag |= (ULOCKFS_NOIACC|ULOCKFS_NOIDEL); 5027c478bd9Sstevel@tonic-gate if (ulp->ul_sbowner != (kthread_id_t)-1) 5037c478bd9Sstevel@tonic-gate ulp->ul_sbowner = curthread; 5047c478bd9Sstevel@tonic-gate 5057c478bd9Sstevel@tonic-gate /* 5067c478bd9Sstevel@tonic-gate * wait for writes for deleted files and superblock updates 5077c478bd9Sstevel@tonic-gate */ 5087c478bd9Sstevel@tonic-gate (void) ufs_flush(vfsp); 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate /* 5117c478bd9Sstevel@tonic-gate * now make sure the quota file is up-to-date 5127c478bd9Sstevel@tonic-gate * expensive; but effective 5137c478bd9Sstevel@tonic-gate */ 5147c478bd9Sstevel@tonic-gate error = ufs_flush(vfsp); 5157c478bd9Sstevel@tonic-gate /* 5167c478bd9Sstevel@tonic-gate * no one can write the superblock 5177c478bd9Sstevel@tonic-gate */ 5187c478bd9Sstevel@tonic-gate ulp->ul_sbowner = (kthread_id_t)-1; 5197c478bd9Sstevel@tonic-gate 5207c478bd9Sstevel@tonic-gate /* 5217c478bd9Sstevel@tonic-gate * special processing for wlock/hlock/elock 5227c478bd9Sstevel@tonic-gate */ 5237c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_WLOCK(ulp)) { 5247c478bd9Sstevel@tonic-gate if (error) 5257c478bd9Sstevel@tonic-gate goto errout; 5267c478bd9Sstevel@tonic-gate error = bfinval(ufsvfsp->vfs_dev, 0); 5277c478bd9Sstevel@tonic-gate if (error) 5287c478bd9Sstevel@tonic-gate goto errout; 5297c478bd9Sstevel@tonic-gate error = ufs_scan_inodes(0, ufs_thaw_wlock, 5307c478bd9Sstevel@tonic-gate (void *)ufsvfsp, ufsvfsp); 5317c478bd9Sstevel@tonic-gate if (error) 5327c478bd9Sstevel@tonic-gate goto errout; 5337c478bd9Sstevel@tonic-gate } 5347c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(ulp) || ULOCKFS_IS_ELOCK(ulp)) { 5357c478bd9Sstevel@tonic-gate error = 0; 5367c478bd9Sstevel@tonic-gate (void) ufs_scan_inodes(0, ufs_thaw_hlock, 5377c478bd9Sstevel@tonic-gate (void *)ufsvfsp, ufsvfsp); 5387c478bd9Sstevel@tonic-gate (void) bfinval(ufsvfsp->vfs_dev, 1); 5397c478bd9Sstevel@tonic-gate } 5407c478bd9Sstevel@tonic-gate } else { 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate /* 5437c478bd9Sstevel@tonic-gate * okay to keep access times 5447c478bd9Sstevel@tonic-gate * okay to free deleted files 5457c478bd9Sstevel@tonic-gate * okay to write the superblock 5467c478bd9Sstevel@tonic-gate */ 5477c478bd9Sstevel@tonic-gate ulp->ul_flag &= ~(ULOCKFS_NOIACC|ULOCKFS_NOIDEL); 5487c478bd9Sstevel@tonic-gate ulp->ul_sbowner = NULL; 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate /* 5517c478bd9Sstevel@tonic-gate * flush in case deleted files are in memory 5527c478bd9Sstevel@tonic-gate */ 5537c478bd9Sstevel@tonic-gate if (noidel) { 5547c478bd9Sstevel@tonic-gate if (error = ufs_flush(vfsp)) 5557c478bd9Sstevel@tonic-gate goto errout; 5567c478bd9Sstevel@tonic-gate } 5577c478bd9Sstevel@tonic-gate } 5587c478bd9Sstevel@tonic-gate 5597c478bd9Sstevel@tonic-gate errout: 5607c478bd9Sstevel@tonic-gate cv_broadcast(&ulp->ul_cv); 5617c478bd9Sstevel@tonic-gate return (error); 5627c478bd9Sstevel@tonic-gate } 5637c478bd9Sstevel@tonic-gate 5647c478bd9Sstevel@tonic-gate /* 5657c478bd9Sstevel@tonic-gate * ufs_reconcile_fs 5667c478bd9Sstevel@tonic-gate * reconcile incore superblock with ondisk superblock 5677c478bd9Sstevel@tonic-gate */ 5687c478bd9Sstevel@tonic-gate int 5697c478bd9Sstevel@tonic-gate ufs_reconcile_fs(struct vfs *vfsp, struct ufsvfs *ufsvfsp, int errlck) 5707c478bd9Sstevel@tonic-gate { 5717c478bd9Sstevel@tonic-gate struct fs *mfs; /* in-memory superblock */ 5727c478bd9Sstevel@tonic-gate struct fs *dfs; /* on-disk superblock */ 5737c478bd9Sstevel@tonic-gate struct buf *bp; /* on-disk superblock buf */ 5747c478bd9Sstevel@tonic-gate int needs_unlock; 5757c478bd9Sstevel@tonic-gate char finished_fsclean; 5767c478bd9Sstevel@tonic-gate 5777c478bd9Sstevel@tonic-gate mfs = ufsvfsp->vfs_fs; 5787c478bd9Sstevel@tonic-gate 5797c478bd9Sstevel@tonic-gate /* 5807c478bd9Sstevel@tonic-gate * get the on-disk copy of the superblock 5817c478bd9Sstevel@tonic-gate */ 5827c478bd9Sstevel@tonic-gate bp = UFS_BREAD(ufsvfsp, vfsp->vfs_dev, SBLOCK, SBSIZE); 5837c478bd9Sstevel@tonic-gate bp->b_flags |= (B_STALE|B_AGE); 5847c478bd9Sstevel@tonic-gate if (bp->b_flags & B_ERROR) { 5857c478bd9Sstevel@tonic-gate brelse(bp); 5867c478bd9Sstevel@tonic-gate return (EIO); 5877c478bd9Sstevel@tonic-gate } 5887c478bd9Sstevel@tonic-gate dfs = bp->b_un.b_fs; 5897c478bd9Sstevel@tonic-gate 5907c478bd9Sstevel@tonic-gate /* error locks may only unlock after the fs has been made consistent */ 5917c478bd9Sstevel@tonic-gate if (errlck == UN_ERRLCK) { 5927c478bd9Sstevel@tonic-gate if (dfs->fs_clean == FSFIX) { /* being repaired */ 5937c478bd9Sstevel@tonic-gate brelse(bp); 5947c478bd9Sstevel@tonic-gate return (EAGAIN); 5957c478bd9Sstevel@tonic-gate } 5967c478bd9Sstevel@tonic-gate /* repair not yet started? */ 5977c478bd9Sstevel@tonic-gate finished_fsclean = TRANS_ISTRANS(ufsvfsp)? FSLOG: FSCLEAN; 5987c478bd9Sstevel@tonic-gate if (dfs->fs_clean != finished_fsclean) { 5997c478bd9Sstevel@tonic-gate brelse(bp); 6007c478bd9Sstevel@tonic-gate return (EBUSY); 6017c478bd9Sstevel@tonic-gate } 6027c478bd9Sstevel@tonic-gate } 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate /* 6057c478bd9Sstevel@tonic-gate * if superblock has changed too much, abort 6067c478bd9Sstevel@tonic-gate */ 6077c478bd9Sstevel@tonic-gate if ((mfs->fs_sblkno != dfs->fs_sblkno) || 6087c478bd9Sstevel@tonic-gate (mfs->fs_cblkno != dfs->fs_cblkno) || 6097c478bd9Sstevel@tonic-gate (mfs->fs_iblkno != dfs->fs_iblkno) || 6107c478bd9Sstevel@tonic-gate (mfs->fs_dblkno != dfs->fs_dblkno) || 6117c478bd9Sstevel@tonic-gate (mfs->fs_cgoffset != dfs->fs_cgoffset) || 6127c478bd9Sstevel@tonic-gate (mfs->fs_cgmask != dfs->fs_cgmask) || 6137c478bd9Sstevel@tonic-gate (mfs->fs_bsize != dfs->fs_bsize) || 6147c478bd9Sstevel@tonic-gate (mfs->fs_fsize != dfs->fs_fsize) || 6157c478bd9Sstevel@tonic-gate (mfs->fs_frag != dfs->fs_frag) || 6167c478bd9Sstevel@tonic-gate (mfs->fs_bmask != dfs->fs_bmask) || 6177c478bd9Sstevel@tonic-gate (mfs->fs_fmask != dfs->fs_fmask) || 6187c478bd9Sstevel@tonic-gate (mfs->fs_bshift != dfs->fs_bshift) || 6197c478bd9Sstevel@tonic-gate (mfs->fs_fshift != dfs->fs_fshift) || 6207c478bd9Sstevel@tonic-gate (mfs->fs_fragshift != dfs->fs_fragshift) || 6217c478bd9Sstevel@tonic-gate (mfs->fs_fsbtodb != dfs->fs_fsbtodb) || 6227c478bd9Sstevel@tonic-gate (mfs->fs_sbsize != dfs->fs_sbsize) || 6237c478bd9Sstevel@tonic-gate (mfs->fs_nindir != dfs->fs_nindir) || 6247c478bd9Sstevel@tonic-gate (mfs->fs_nspf != dfs->fs_nspf) || 6257c478bd9Sstevel@tonic-gate (mfs->fs_trackskew != dfs->fs_trackskew) || 6267c478bd9Sstevel@tonic-gate (mfs->fs_cgsize != dfs->fs_cgsize) || 6277c478bd9Sstevel@tonic-gate (mfs->fs_ntrak != dfs->fs_ntrak) || 6287c478bd9Sstevel@tonic-gate (mfs->fs_nsect != dfs->fs_nsect) || 6297c478bd9Sstevel@tonic-gate (mfs->fs_spc != dfs->fs_spc) || 6307c478bd9Sstevel@tonic-gate (mfs->fs_cpg != dfs->fs_cpg) || 6317c478bd9Sstevel@tonic-gate (mfs->fs_ipg != dfs->fs_ipg) || 6327c478bd9Sstevel@tonic-gate (mfs->fs_fpg != dfs->fs_fpg) || 6337c478bd9Sstevel@tonic-gate (mfs->fs_postblformat != dfs->fs_postblformat) || 6347c478bd9Sstevel@tonic-gate (mfs->fs_magic != dfs->fs_magic)) { 6357c478bd9Sstevel@tonic-gate brelse(bp); 6367c478bd9Sstevel@tonic-gate return (EACCES); 6377c478bd9Sstevel@tonic-gate } 6387c478bd9Sstevel@tonic-gate if (dfs->fs_clean == FSBAD || FSOKAY != dfs->fs_state + dfs->fs_time) 6397c478bd9Sstevel@tonic-gate if (mfs->fs_clean == FSLOG) { 6407c478bd9Sstevel@tonic-gate brelse(bp); 6417c478bd9Sstevel@tonic-gate return (EACCES); 6427c478bd9Sstevel@tonic-gate } 6437c478bd9Sstevel@tonic-gate 6447c478bd9Sstevel@tonic-gate /* 6457c478bd9Sstevel@tonic-gate * get new summary info 6467c478bd9Sstevel@tonic-gate */ 6477c478bd9Sstevel@tonic-gate if (ufs_getsummaryinfo(vfsp->vfs_dev, ufsvfsp, dfs)) { 6487c478bd9Sstevel@tonic-gate brelse(bp); 6497c478bd9Sstevel@tonic-gate return (EIO); 6507c478bd9Sstevel@tonic-gate } 6517c478bd9Sstevel@tonic-gate 6527c478bd9Sstevel@tonic-gate /* 6537c478bd9Sstevel@tonic-gate * release old summary info and update in-memory superblock 6547c478bd9Sstevel@tonic-gate */ 6557c478bd9Sstevel@tonic-gate kmem_free(mfs->fs_u.fs_csp, mfs->fs_cssize); 6567c478bd9Sstevel@tonic-gate mfs->fs_u.fs_csp = dfs->fs_u.fs_csp; /* Only entry 0 used */ 6577c478bd9Sstevel@tonic-gate 6587c478bd9Sstevel@tonic-gate /* 6597c478bd9Sstevel@tonic-gate * update fields allowed to change 6607c478bd9Sstevel@tonic-gate */ 6617c478bd9Sstevel@tonic-gate mfs->fs_size = dfs->fs_size; 6627c478bd9Sstevel@tonic-gate mfs->fs_dsize = dfs->fs_dsize; 6637c478bd9Sstevel@tonic-gate mfs->fs_ncg = dfs->fs_ncg; 6647c478bd9Sstevel@tonic-gate mfs->fs_minfree = dfs->fs_minfree; 6657c478bd9Sstevel@tonic-gate mfs->fs_rotdelay = dfs->fs_rotdelay; 6667c478bd9Sstevel@tonic-gate mfs->fs_rps = dfs->fs_rps; 6677c478bd9Sstevel@tonic-gate mfs->fs_maxcontig = dfs->fs_maxcontig; 6687c478bd9Sstevel@tonic-gate mfs->fs_maxbpg = dfs->fs_maxbpg; 6697c478bd9Sstevel@tonic-gate mfs->fs_csmask = dfs->fs_csmask; 6707c478bd9Sstevel@tonic-gate mfs->fs_csshift = dfs->fs_csshift; 6717c478bd9Sstevel@tonic-gate mfs->fs_optim = dfs->fs_optim; 6727c478bd9Sstevel@tonic-gate mfs->fs_csaddr = dfs->fs_csaddr; 6737c478bd9Sstevel@tonic-gate mfs->fs_cssize = dfs->fs_cssize; 6747c478bd9Sstevel@tonic-gate mfs->fs_ncyl = dfs->fs_ncyl; 6757c478bd9Sstevel@tonic-gate mfs->fs_cstotal = dfs->fs_cstotal; 6767c478bd9Sstevel@tonic-gate mfs->fs_reclaim = dfs->fs_reclaim; 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate if (mfs->fs_reclaim & (FS_RECLAIM|FS_RECLAIMING)) { 6797c478bd9Sstevel@tonic-gate mfs->fs_reclaim &= ~FS_RECLAIM; 6807c478bd9Sstevel@tonic-gate mfs->fs_reclaim |= FS_RECLAIMING; 6817c478bd9Sstevel@tonic-gate ufs_thread_start(&ufsvfsp->vfs_reclaim, 6827c478bd9Sstevel@tonic-gate ufs_thread_reclaim, vfsp); 6837c478bd9Sstevel@tonic-gate } 6847c478bd9Sstevel@tonic-gate 6857c478bd9Sstevel@tonic-gate /* XXX What to do about sparecon? */ 6867c478bd9Sstevel@tonic-gate 6877c478bd9Sstevel@tonic-gate /* XXX need to copy volume label */ 6887c478bd9Sstevel@tonic-gate 6897c478bd9Sstevel@tonic-gate /* 6907c478bd9Sstevel@tonic-gate * ondisk clean flag overrides inmemory clean flag iff == FSBAD 6917c478bd9Sstevel@tonic-gate * or if error-locked and ondisk is now clean 6927c478bd9Sstevel@tonic-gate */ 6937c478bd9Sstevel@tonic-gate needs_unlock = !MUTEX_HELD(&ufsvfsp->vfs_lock); 6947c478bd9Sstevel@tonic-gate if (needs_unlock) 6957c478bd9Sstevel@tonic-gate mutex_enter(&ufsvfsp->vfs_lock); 6967c478bd9Sstevel@tonic-gate 6977c478bd9Sstevel@tonic-gate if (errlck == UN_ERRLCK) { 6987c478bd9Sstevel@tonic-gate if (finished_fsclean == dfs->fs_clean) 6997c478bd9Sstevel@tonic-gate mfs->fs_clean = finished_fsclean; 7007c478bd9Sstevel@tonic-gate else 7017c478bd9Sstevel@tonic-gate mfs->fs_clean = FSBAD; 7027c478bd9Sstevel@tonic-gate mfs->fs_state = FSOKAY - dfs->fs_time; 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate if (FSOKAY != dfs->fs_state + dfs->fs_time || 7067c478bd9Sstevel@tonic-gate (dfs->fs_clean == FSBAD)) 7077c478bd9Sstevel@tonic-gate mfs->fs_clean = FSBAD; 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate if (needs_unlock) 7107c478bd9Sstevel@tonic-gate mutex_exit(&ufsvfsp->vfs_lock); 7117c478bd9Sstevel@tonic-gate 7127c478bd9Sstevel@tonic-gate brelse(bp); 7137c478bd9Sstevel@tonic-gate 7147c478bd9Sstevel@tonic-gate return (0); 7157c478bd9Sstevel@tonic-gate } 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate /* 7187c478bd9Sstevel@tonic-gate * ufs_reconcile_inode 7197c478bd9Sstevel@tonic-gate * reconcile ondisk inode with incore inode 7207c478bd9Sstevel@tonic-gate */ 7217c478bd9Sstevel@tonic-gate static int 7227c478bd9Sstevel@tonic-gate ufs_reconcile_inode(struct inode *ip, void *arg) 7237c478bd9Sstevel@tonic-gate { 7247c478bd9Sstevel@tonic-gate int i; 7257c478bd9Sstevel@tonic-gate int ndaddr; 7267c478bd9Sstevel@tonic-gate int niaddr; 7277c478bd9Sstevel@tonic-gate struct dinode *dp; /* ondisk inode */ 7287c478bd9Sstevel@tonic-gate struct buf *bp = NULL; 7297c478bd9Sstevel@tonic-gate uid_t d_uid; 7307c478bd9Sstevel@tonic-gate gid_t d_gid; 7317c478bd9Sstevel@tonic-gate int error = 0; 7327c478bd9Sstevel@tonic-gate struct fs *fs; 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate /* 7357c478bd9Sstevel@tonic-gate * not an inode we care about 7367c478bd9Sstevel@tonic-gate */ 7377c478bd9Sstevel@tonic-gate if (ip->i_ufsvfs != (struct ufsvfs *)arg) 7387c478bd9Sstevel@tonic-gate return (0); 7397c478bd9Sstevel@tonic-gate 7407c478bd9Sstevel@tonic-gate fs = ip->i_fs; 7417c478bd9Sstevel@tonic-gate 7427c478bd9Sstevel@tonic-gate /* 7437c478bd9Sstevel@tonic-gate * Inode reconciliation fails: we made the filesystem quiescent 7447c478bd9Sstevel@tonic-gate * and we did a ufs_flush() before calling ufs_reconcile_inode() 7457c478bd9Sstevel@tonic-gate * and thus the inode should not have been changed inbetween. 7467c478bd9Sstevel@tonic-gate * Any discrepancies indicate a logic error and a pretty 7477c478bd9Sstevel@tonic-gate * significant run-state inconsistency we should complain about. 7487c478bd9Sstevel@tonic-gate */ 7497c478bd9Sstevel@tonic-gate if (ip->i_flag & (IMOD|IMODACC|IACC|IUPD|ICHG|IATTCHG)) { 7507c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "%s: Inode reconciliation failed for" 7517c478bd9Sstevel@tonic-gate "inode %llu", fs->fs_fsmnt, (u_longlong_t)ip->i_number); 7527c478bd9Sstevel@tonic-gate return (EINVAL); 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate /* 7567c478bd9Sstevel@tonic-gate * get the dinode 7577c478bd9Sstevel@tonic-gate */ 7587c478bd9Sstevel@tonic-gate bp = UFS_BREAD(ip->i_ufsvfs, 7597c478bd9Sstevel@tonic-gate ip->i_dev, (daddr_t)fsbtodb(fs, itod(fs, ip->i_number)), 7607c478bd9Sstevel@tonic-gate (int)fs->fs_bsize); 7617c478bd9Sstevel@tonic-gate if (bp->b_flags & B_ERROR) { 7627c478bd9Sstevel@tonic-gate brelse(bp); 7637c478bd9Sstevel@tonic-gate return (EIO); 7647c478bd9Sstevel@tonic-gate } 7657c478bd9Sstevel@tonic-gate dp = bp->b_un.b_dino; 7667c478bd9Sstevel@tonic-gate dp += itoo(fs, ip->i_number); 7677c478bd9Sstevel@tonic-gate 7687c478bd9Sstevel@tonic-gate /* 7697c478bd9Sstevel@tonic-gate * handle Sun's implementation of EFT 7707c478bd9Sstevel@tonic-gate */ 7717c478bd9Sstevel@tonic-gate d_uid = (dp->di_suid == UID_LONG) ? dp->di_uid : (uid_t)dp->di_suid; 7727c478bd9Sstevel@tonic-gate d_gid = (dp->di_sgid == GID_LONG) ? dp->di_gid : (uid_t)dp->di_sgid; 7737c478bd9Sstevel@tonic-gate 7747c478bd9Sstevel@tonic-gate rw_enter(&ip->i_contents, RW_WRITER); 7757c478bd9Sstevel@tonic-gate 7767c478bd9Sstevel@tonic-gate /* 7777c478bd9Sstevel@tonic-gate * some fields are not allowed to change 7787c478bd9Sstevel@tonic-gate */ 7797c478bd9Sstevel@tonic-gate if ((ip->i_mode != dp->di_mode) || 7807c478bd9Sstevel@tonic-gate (ip->i_gen != dp->di_gen) || 7817c478bd9Sstevel@tonic-gate (ip->i_uid != d_uid) || 7827c478bd9Sstevel@tonic-gate (ip->i_gid != d_gid)) { 7837c478bd9Sstevel@tonic-gate error = EACCES; 7847c478bd9Sstevel@tonic-gate goto out; 7857c478bd9Sstevel@tonic-gate } 7867c478bd9Sstevel@tonic-gate 7877c478bd9Sstevel@tonic-gate /* 7887c478bd9Sstevel@tonic-gate * and some are allowed to change 7897c478bd9Sstevel@tonic-gate */ 7907c478bd9Sstevel@tonic-gate ip->i_size = dp->di_size; 7917c478bd9Sstevel@tonic-gate ip->i_ic.ic_flags = dp->di_ic.ic_flags; 7927c478bd9Sstevel@tonic-gate ip->i_blocks = dp->di_blocks; 7937c478bd9Sstevel@tonic-gate ip->i_nlink = dp->di_nlink; 7947c478bd9Sstevel@tonic-gate if (ip->i_flag & IFASTSYMLNK) { 7957c478bd9Sstevel@tonic-gate ndaddr = 1; 7967c478bd9Sstevel@tonic-gate niaddr = 0; 7977c478bd9Sstevel@tonic-gate } else { 7987c478bd9Sstevel@tonic-gate ndaddr = NDADDR; 7997c478bd9Sstevel@tonic-gate niaddr = NIADDR; 8007c478bd9Sstevel@tonic-gate } 8017c478bd9Sstevel@tonic-gate for (i = 0; i < ndaddr; ++i) 8027c478bd9Sstevel@tonic-gate ip->i_db[i] = dp->di_db[i]; 8037c478bd9Sstevel@tonic-gate for (i = 0; i < niaddr; ++i) 8047c478bd9Sstevel@tonic-gate ip->i_ib[i] = dp->di_ib[i]; 8057c478bd9Sstevel@tonic-gate 8067c478bd9Sstevel@tonic-gate out: 8077c478bd9Sstevel@tonic-gate rw_exit(&ip->i_contents); 8087c478bd9Sstevel@tonic-gate brelse(bp); 8097c478bd9Sstevel@tonic-gate return (error); 8107c478bd9Sstevel@tonic-gate } 8117c478bd9Sstevel@tonic-gate 8127c478bd9Sstevel@tonic-gate /* 8137c478bd9Sstevel@tonic-gate * ufs_reconcile 8147c478bd9Sstevel@tonic-gate * reconcile ondisk superblock/inodes with any incore 8157c478bd9Sstevel@tonic-gate */ 8167c478bd9Sstevel@tonic-gate static int 8177c478bd9Sstevel@tonic-gate ufs_reconcile(struct vfs *vfsp, struct ufsvfs *ufsvfsp, int errlck) 8187c478bd9Sstevel@tonic-gate { 8197c478bd9Sstevel@tonic-gate int error = 0; 8207c478bd9Sstevel@tonic-gate 8217c478bd9Sstevel@tonic-gate /* 8227c478bd9Sstevel@tonic-gate * get rid of as much inmemory data as possible 8237c478bd9Sstevel@tonic-gate */ 8247c478bd9Sstevel@tonic-gate (void) ufs_flush(vfsp); 8257c478bd9Sstevel@tonic-gate 8267c478bd9Sstevel@tonic-gate /* 8277c478bd9Sstevel@tonic-gate * reconcile the superblock and inodes 8287c478bd9Sstevel@tonic-gate */ 8297c478bd9Sstevel@tonic-gate if (error = ufs_reconcile_fs(vfsp, ufsvfsp, errlck)) 8307c478bd9Sstevel@tonic-gate return (error); 8317c478bd9Sstevel@tonic-gate if (error = ufs_scan_inodes(0, ufs_reconcile_inode, ufsvfsp, ufsvfsp)) 8327c478bd9Sstevel@tonic-gate return (error); 8337c478bd9Sstevel@tonic-gate /* 8347c478bd9Sstevel@tonic-gate * allocation blocks may be incorrect; get rid of them 8357c478bd9Sstevel@tonic-gate */ 8367c478bd9Sstevel@tonic-gate (void) ufs_flush(vfsp); 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate return (error); 8397c478bd9Sstevel@tonic-gate } 8407c478bd9Sstevel@tonic-gate 8417c478bd9Sstevel@tonic-gate /* 8427c478bd9Sstevel@tonic-gate * File system locking 8437c478bd9Sstevel@tonic-gate */ 8447c478bd9Sstevel@tonic-gate int 8457c478bd9Sstevel@tonic-gate ufs_fiolfs(struct vnode *vp, struct lockfs *lockfsp, int from_log) 8467c478bd9Sstevel@tonic-gate { 8477c478bd9Sstevel@tonic-gate return (ufs__fiolfs(vp, lockfsp, /* from_user */ 1, from_log)); 8487c478bd9Sstevel@tonic-gate } 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate /* kernel-internal interface, also used by fix-on-panic */ 8517c478bd9Sstevel@tonic-gate int 8527c478bd9Sstevel@tonic-gate ufs__fiolfs( 8537c478bd9Sstevel@tonic-gate struct vnode *vp, 8547c478bd9Sstevel@tonic-gate struct lockfs *lockfsp, 8557c478bd9Sstevel@tonic-gate int from_user, 8567c478bd9Sstevel@tonic-gate int from_log) 8577c478bd9Sstevel@tonic-gate { 8587c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 8597c478bd9Sstevel@tonic-gate struct lockfs lfs; 8607c478bd9Sstevel@tonic-gate int error; 8617c478bd9Sstevel@tonic-gate struct vfs *vfsp; 8627c478bd9Sstevel@tonic-gate struct ufsvfs *ufsvfsp; 8637c478bd9Sstevel@tonic-gate int errlck = NO_ERRLCK; 8647c478bd9Sstevel@tonic-gate int poll_events = POLLPRI; 8657c478bd9Sstevel@tonic-gate extern struct pollhead ufs_pollhd; 866*303bf60bSsdebnath ulockfs_info_t *head; 867*303bf60bSsdebnath ulockfs_info_t *info; 8687c478bd9Sstevel@tonic-gate 8697c478bd9Sstevel@tonic-gate /* check valid lock type */ 8707c478bd9Sstevel@tonic-gate if (!lockfsp || lockfsp->lf_lock > LOCKFS_MAXLOCK) 8717c478bd9Sstevel@tonic-gate return (EINVAL); 8727c478bd9Sstevel@tonic-gate 8737c478bd9Sstevel@tonic-gate if (!vp || !vp->v_vfsp || !vp->v_vfsp->vfs_data) 8747c478bd9Sstevel@tonic-gate return (EIO); 8757c478bd9Sstevel@tonic-gate 8767c478bd9Sstevel@tonic-gate vfsp = vp->v_vfsp; 8777c478bd9Sstevel@tonic-gate ufsvfsp = (struct ufsvfs *)vfsp->vfs_data; 8787c478bd9Sstevel@tonic-gate ulp = &ufsvfsp->vfs_ulockfs; 8797c478bd9Sstevel@tonic-gate 880*303bf60bSsdebnath head = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 881*303bf60bSsdebnath SEARCH_ULOCKFSP(head, ulp, info); 882*303bf60bSsdebnath 8837c478bd9Sstevel@tonic-gate /* 8847c478bd9Sstevel@tonic-gate * Suspend both the reclaim thread and the delete thread. 8857c478bd9Sstevel@tonic-gate * This must be done outside the lockfs locking protocol. 8867c478bd9Sstevel@tonic-gate */ 8877c478bd9Sstevel@tonic-gate ufs_thread_suspend(&ufsvfsp->vfs_reclaim); 8887c478bd9Sstevel@tonic-gate ufs_thread_suspend(&ufsvfsp->vfs_delete); 8897c478bd9Sstevel@tonic-gate 8907c478bd9Sstevel@tonic-gate /* 8917c478bd9Sstevel@tonic-gate * Acquire vfs_reflock around ul_lock to avoid deadlock with 8927c478bd9Sstevel@tonic-gate * umount/remount/sync. 8937c478bd9Sstevel@tonic-gate */ 8947c478bd9Sstevel@tonic-gate vfs_lock_wait(vfsp); 8957c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 896bc69f433Saguzovsk atomic_add_long(&ufs_quiesce_pend, 1); 8977c478bd9Sstevel@tonic-gate 8987c478bd9Sstevel@tonic-gate /* 8997c478bd9Sstevel@tonic-gate * Quit if there is another lockfs request in progress 9007c478bd9Sstevel@tonic-gate * that is waiting for existing ufs_vnops to complete. 9017c478bd9Sstevel@tonic-gate */ 9027c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_BUSY(ulp)) { 9037c478bd9Sstevel@tonic-gate error = EBUSY; 9047c478bd9Sstevel@tonic-gate goto errexit; 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate /* cannot ulocked or downgrade a hard-lock */ 9087c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(ulp)) { 9097c478bd9Sstevel@tonic-gate error = EIO; 9107c478bd9Sstevel@tonic-gate goto errexit; 9117c478bd9Sstevel@tonic-gate } 9127c478bd9Sstevel@tonic-gate 9137c478bd9Sstevel@tonic-gate /* an error lock may be unlocked or relocked, only */ 9147c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_ELOCK(ulp)) { 9157c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_ULOCK(lockfsp) && !LOCKFS_IS_ELOCK(lockfsp)) { 9167c478bd9Sstevel@tonic-gate error = EBUSY; 9177c478bd9Sstevel@tonic-gate goto errexit; 9187c478bd9Sstevel@tonic-gate } 9197c478bd9Sstevel@tonic-gate } 9207c478bd9Sstevel@tonic-gate 9217c478bd9Sstevel@tonic-gate /* 9227c478bd9Sstevel@tonic-gate * a read-only error lock may only be upgraded to an 9237c478bd9Sstevel@tonic-gate * error lock or hard lock 9247c478bd9Sstevel@tonic-gate */ 9257c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_ROELOCK(ulp)) { 9267c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_HLOCK(lockfsp) && !LOCKFS_IS_ELOCK(lockfsp)) { 9277c478bd9Sstevel@tonic-gate error = EBUSY; 9287c478bd9Sstevel@tonic-gate goto errexit; 9297c478bd9Sstevel@tonic-gate } 9307c478bd9Sstevel@tonic-gate } 9317c478bd9Sstevel@tonic-gate 9327c478bd9Sstevel@tonic-gate /* 9337c478bd9Sstevel@tonic-gate * until read-only error locks are fully implemented 9347c478bd9Sstevel@tonic-gate * just return EINVAL 9357c478bd9Sstevel@tonic-gate */ 9367c478bd9Sstevel@tonic-gate if (LOCKFS_IS_ROELOCK(lockfsp)) { 9377c478bd9Sstevel@tonic-gate error = EINVAL; 9387c478bd9Sstevel@tonic-gate goto errexit; 9397c478bd9Sstevel@tonic-gate } 9407c478bd9Sstevel@tonic-gate 9417c478bd9Sstevel@tonic-gate /* 9427c478bd9Sstevel@tonic-gate * an error lock may only be applied if the file system is 9437c478bd9Sstevel@tonic-gate * unlocked or already error locked. 9447c478bd9Sstevel@tonic-gate * (this is to prevent the case where a fs gets changed out from 9457c478bd9Sstevel@tonic-gate * underneath a fs that is locked for backup, 9467c478bd9Sstevel@tonic-gate * that is, name/delete/write-locked.) 9477c478bd9Sstevel@tonic-gate */ 9487c478bd9Sstevel@tonic-gate if ((!ULOCKFS_IS_ULOCK(ulp) && !ULOCKFS_IS_ELOCK(ulp) && 9497c478bd9Sstevel@tonic-gate !ULOCKFS_IS_ROELOCK(ulp)) && 9507c478bd9Sstevel@tonic-gate (LOCKFS_IS_ELOCK(lockfsp) || LOCKFS_IS_ROELOCK(lockfsp))) { 9517c478bd9Sstevel@tonic-gate error = EBUSY; 9527c478bd9Sstevel@tonic-gate goto errexit; 9537c478bd9Sstevel@tonic-gate } 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate /* get and validate the input lockfs request */ 9567c478bd9Sstevel@tonic-gate if (error = ufs_getlfd(lockfsp, &ulp->ul_lockfs)) 9577c478bd9Sstevel@tonic-gate goto errexit; 9587c478bd9Sstevel@tonic-gate 9597c478bd9Sstevel@tonic-gate /* 9607c478bd9Sstevel@tonic-gate * save current ulockfs struct 9617c478bd9Sstevel@tonic-gate */ 9627c478bd9Sstevel@tonic-gate bcopy(&ulp->ul_lockfs, &lfs, sizeof (struct lockfs)); 9637c478bd9Sstevel@tonic-gate 9647c478bd9Sstevel@tonic-gate /* 9657c478bd9Sstevel@tonic-gate * Freeze the file system (pend future accesses) 9667c478bd9Sstevel@tonic-gate */ 9677c478bd9Sstevel@tonic-gate ufs_freeze(ulp, lockfsp); 9687c478bd9Sstevel@tonic-gate 9697c478bd9Sstevel@tonic-gate /* 9707c478bd9Sstevel@tonic-gate * Set locking in progress because ufs_quiesce may free the 9717c478bd9Sstevel@tonic-gate * ul_lock mutex. 9727c478bd9Sstevel@tonic-gate */ 9737c478bd9Sstevel@tonic-gate ULOCKFS_SET_BUSY(ulp); 9747c478bd9Sstevel@tonic-gate /* update the ioctl copy */ 9757c478bd9Sstevel@tonic-gate LOCKFS_SET_BUSY(&ulp->ul_lockfs); 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate /* 978*303bf60bSsdebnath * We need to unset FWLOCK status before we call ufs_quiesce 979*303bf60bSsdebnath * so that the thread doesnt get suspended. We do this only if 980*303bf60bSsdebnath * this (fallocate) thread requested an unlock operation. 981*303bf60bSsdebnath */ 982*303bf60bSsdebnath if (info && (info->flags & ULOCK_INFO_FALLOCATE)) { 983*303bf60bSsdebnath if (!ULOCKFS_IS_WLOCK(ulp)) 984*303bf60bSsdebnath ULOCKFS_CLR_FWLOCK(ulp); 985*303bf60bSsdebnath } 986*303bf60bSsdebnath 987*303bf60bSsdebnath /* 9887c478bd9Sstevel@tonic-gate * Quiesce (wait for outstanding accesses to finish) 9897c478bd9Sstevel@tonic-gate */ 9907c478bd9Sstevel@tonic-gate if (error = ufs_quiesce(ulp)) 9917c478bd9Sstevel@tonic-gate goto errout; 9927c478bd9Sstevel@tonic-gate 9937c478bd9Sstevel@tonic-gate /* 994*303bf60bSsdebnath * If the fallocate thread requested a write fs lock operation 995*303bf60bSsdebnath * then we set fwlock status in the ulp. 996*303bf60bSsdebnath */ 997*303bf60bSsdebnath if (info && (info->flags & ULOCK_INFO_FALLOCATE)) { 998*303bf60bSsdebnath if (ULOCKFS_IS_WLOCK(ulp)) 999*303bf60bSsdebnath ULOCKFS_SET_FWLOCK(ulp); 1000*303bf60bSsdebnath } 1001*303bf60bSsdebnath 1002*303bf60bSsdebnath /* 10037c478bd9Sstevel@tonic-gate * can't wlock or (ro)elock fs with accounting or local swap file 10047c478bd9Sstevel@tonic-gate */ 10057c478bd9Sstevel@tonic-gate if ((ULOCKFS_IS_WLOCK(ulp) || ULOCKFS_IS_ELOCK(ulp) || 10067c478bd9Sstevel@tonic-gate ULOCKFS_IS_ROELOCK(ulp)) && !from_log) { 10077c478bd9Sstevel@tonic-gate if (error = ufs_checkaccton(vp)) 10087c478bd9Sstevel@tonic-gate goto errout; 10097c478bd9Sstevel@tonic-gate if (error = ufs_checkswapon(vp)) 10107c478bd9Sstevel@tonic-gate goto errout; 10117c478bd9Sstevel@tonic-gate } 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate /* 10147c478bd9Sstevel@tonic-gate * save error lock status to pass down to reconcilation 10157c478bd9Sstevel@tonic-gate * routines and for later cleanup 10167c478bd9Sstevel@tonic-gate */ 10177c478bd9Sstevel@tonic-gate if (LOCKFS_IS_ELOCK(&lfs) && ULOCKFS_IS_ULOCK(ulp)) 10187c478bd9Sstevel@tonic-gate errlck = UN_ERRLCK; 10197c478bd9Sstevel@tonic-gate 10207c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_ELOCK(ulp) || ULOCKFS_IS_ROELOCK(ulp)) { 10217c478bd9Sstevel@tonic-gate int needs_unlock; 10227c478bd9Sstevel@tonic-gate int needs_sbwrite; 10237c478bd9Sstevel@tonic-gate 10247c478bd9Sstevel@tonic-gate poll_events |= POLLERR; 10257c478bd9Sstevel@tonic-gate errlck = LOCKFS_IS_ELOCK(&lfs) || LOCKFS_IS_ROELOCK(&lfs)? 10267c478bd9Sstevel@tonic-gate RE_ERRLCK: SET_ERRLCK; 10277c478bd9Sstevel@tonic-gate 10287c478bd9Sstevel@tonic-gate needs_unlock = !MUTEX_HELD(&ufsvfsp->vfs_lock); 10297c478bd9Sstevel@tonic-gate if (needs_unlock) 10307c478bd9Sstevel@tonic-gate mutex_enter(&ufsvfsp->vfs_lock); 10317c478bd9Sstevel@tonic-gate 10327c478bd9Sstevel@tonic-gate /* disable delayed i/o */ 10337c478bd9Sstevel@tonic-gate needs_sbwrite = 0; 10347c478bd9Sstevel@tonic-gate 10357c478bd9Sstevel@tonic-gate if (errlck == SET_ERRLCK) { 10367c478bd9Sstevel@tonic-gate ufsvfsp->vfs_fs->fs_clean = FSBAD; 10377c478bd9Sstevel@tonic-gate needs_sbwrite = 1; 10387c478bd9Sstevel@tonic-gate } 10397c478bd9Sstevel@tonic-gate 10407c478bd9Sstevel@tonic-gate needs_sbwrite |= ufsvfsp->vfs_dio; 10417c478bd9Sstevel@tonic-gate ufsvfsp->vfs_dio = 0; 10427c478bd9Sstevel@tonic-gate 10437c478bd9Sstevel@tonic-gate if (needs_unlock) 10447c478bd9Sstevel@tonic-gate mutex_exit(&ufsvfsp->vfs_lock); 10457c478bd9Sstevel@tonic-gate 10467c478bd9Sstevel@tonic-gate if (needs_sbwrite) { 10477c478bd9Sstevel@tonic-gate ulp->ul_sbowner = curthread; 10487c478bd9Sstevel@tonic-gate TRANS_SBWRITE(ufsvfsp, TOP_SBWRITE_STABLE); 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate if (needs_unlock) 10517c478bd9Sstevel@tonic-gate mutex_enter(&ufsvfsp->vfs_lock); 10527c478bd9Sstevel@tonic-gate 10537c478bd9Sstevel@tonic-gate ufsvfsp->vfs_fs->fs_fmod = 0; 10547c478bd9Sstevel@tonic-gate 10557c478bd9Sstevel@tonic-gate if (needs_unlock) 10567c478bd9Sstevel@tonic-gate mutex_exit(&ufsvfsp->vfs_lock); 10577c478bd9Sstevel@tonic-gate } 10587c478bd9Sstevel@tonic-gate } 10597c478bd9Sstevel@tonic-gate 10607c478bd9Sstevel@tonic-gate /* 10617c478bd9Sstevel@tonic-gate * reconcile superblock and inodes if was wlocked 10627c478bd9Sstevel@tonic-gate */ 10637c478bd9Sstevel@tonic-gate if (LOCKFS_IS_WLOCK(&lfs) || LOCKFS_IS_ELOCK(&lfs)) { 10647c478bd9Sstevel@tonic-gate if (error = ufs_reconcile(vfsp, ufsvfsp, errlck)) 10657c478bd9Sstevel@tonic-gate goto errout; 10667c478bd9Sstevel@tonic-gate /* 10677c478bd9Sstevel@tonic-gate * in case the fs grew; reset the metadata map for logging tests 10687c478bd9Sstevel@tonic-gate */ 10697c478bd9Sstevel@tonic-gate TRANS_MATA_UMOUNT(ufsvfsp); 10707c478bd9Sstevel@tonic-gate TRANS_MATA_MOUNT(ufsvfsp); 10717c478bd9Sstevel@tonic-gate TRANS_MATA_SI(ufsvfsp, ufsvfsp->vfs_fs); 10727c478bd9Sstevel@tonic-gate } 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate /* 10757c478bd9Sstevel@tonic-gate * At least everything *currently* dirty goes out. 10767c478bd9Sstevel@tonic-gate */ 10777c478bd9Sstevel@tonic-gate 10787c478bd9Sstevel@tonic-gate if ((error = ufs_flush(vfsp)) != 0 && !ULOCKFS_IS_HLOCK(ulp) && 10797c478bd9Sstevel@tonic-gate !ULOCKFS_IS_ELOCK(ulp)) 10807c478bd9Sstevel@tonic-gate goto errout; 10817c478bd9Sstevel@tonic-gate 10827c478bd9Sstevel@tonic-gate /* 10837c478bd9Sstevel@tonic-gate * thaw file system and wakeup pended processes 10847c478bd9Sstevel@tonic-gate */ 10857c478bd9Sstevel@tonic-gate if (error = ufs_thaw(vfsp, ufsvfsp, ulp)) 10867c478bd9Sstevel@tonic-gate if (!ULOCKFS_IS_HLOCK(ulp) && !ULOCKFS_IS_ELOCK(ulp)) 10877c478bd9Sstevel@tonic-gate goto errout; 10887c478bd9Sstevel@tonic-gate 10897c478bd9Sstevel@tonic-gate /* 10907c478bd9Sstevel@tonic-gate * reset modified flag if not already write locked 10917c478bd9Sstevel@tonic-gate */ 10927c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_WLOCK(&lfs)) 10937c478bd9Sstevel@tonic-gate ULOCKFS_CLR_MOD(ulp); 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate /* 10967c478bd9Sstevel@tonic-gate * idle the lock struct 10977c478bd9Sstevel@tonic-gate */ 10987c478bd9Sstevel@tonic-gate ULOCKFS_CLR_BUSY(ulp); 10997c478bd9Sstevel@tonic-gate /* update the ioctl copy */ 11007c478bd9Sstevel@tonic-gate LOCKFS_CLR_BUSY(&ulp->ul_lockfs); 11017c478bd9Sstevel@tonic-gate 11027c478bd9Sstevel@tonic-gate /* 11037c478bd9Sstevel@tonic-gate * free current comment 11047c478bd9Sstevel@tonic-gate */ 11057c478bd9Sstevel@tonic-gate if (lfs.lf_comment && lfs.lf_comlen != 0) { 11067c478bd9Sstevel@tonic-gate kmem_free(lfs.lf_comment, lfs.lf_comlen); 11077c478bd9Sstevel@tonic-gate lfs.lf_comment = NULL; 11087c478bd9Sstevel@tonic-gate lfs.lf_comlen = 0; 11097c478bd9Sstevel@tonic-gate } 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate /* do error lock cleanup */ 11127c478bd9Sstevel@tonic-gate if (errlck == UN_ERRLCK) 11137c478bd9Sstevel@tonic-gate ufsfx_unlockfs(ufsvfsp); 11147c478bd9Sstevel@tonic-gate 11157c478bd9Sstevel@tonic-gate else if (errlck == RE_ERRLCK) 11167c478bd9Sstevel@tonic-gate ufsfx_lockfs(ufsvfsp); 11177c478bd9Sstevel@tonic-gate 11187c478bd9Sstevel@tonic-gate /* don't allow error lock from user to invoke panic */ 11197c478bd9Sstevel@tonic-gate else if (from_user && errlck == SET_ERRLCK && 11207c478bd9Sstevel@tonic-gate !(ufsvfsp->vfs_fsfx.fx_flags & (UFSMNT_ONERROR_PANIC >> 4))) 11217c478bd9Sstevel@tonic-gate (void) ufs_fault(ufsvfsp->vfs_root, 11227c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comment && ulp->ul_lockfs.lf_comlen > 0 ? 11237c478bd9Sstevel@tonic-gate ulp->ul_lockfs.lf_comment: "user-applied error lock"); 11247c478bd9Sstevel@tonic-gate 1125bc69f433Saguzovsk atomic_add_long(&ufs_quiesce_pend, -1); 11267c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 11277c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(&ufsvfsp->vfs_ulockfs)) 11307c478bd9Sstevel@tonic-gate poll_events |= POLLERR; 11317c478bd9Sstevel@tonic-gate 11327c478bd9Sstevel@tonic-gate pollwakeup(&ufs_pollhd, poll_events); 11337c478bd9Sstevel@tonic-gate 11347c478bd9Sstevel@tonic-gate /* 11357c478bd9Sstevel@tonic-gate * Allow both the delete thread and the reclaim thread to 11367c478bd9Sstevel@tonic-gate * continue. 11377c478bd9Sstevel@tonic-gate */ 11387c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_delete); 11397c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_reclaim); 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate return (0); 11427c478bd9Sstevel@tonic-gate 11437c478bd9Sstevel@tonic-gate errout: 11447c478bd9Sstevel@tonic-gate /* 11457c478bd9Sstevel@tonic-gate * Lock failed. Reset the old lock in ufsvfs if not hard locked. 11467c478bd9Sstevel@tonic-gate */ 11477c478bd9Sstevel@tonic-gate if (!LOCKFS_IS_HLOCK(&ulp->ul_lockfs)) { 11487c478bd9Sstevel@tonic-gate bcopy(&lfs, &ulp->ul_lockfs, sizeof (struct lockfs)); 11497c478bd9Sstevel@tonic-gate ulp->ul_fs_lock = (1 << lfs.lf_lock); 11507c478bd9Sstevel@tonic-gate } 11517c478bd9Sstevel@tonic-gate (void) ufs_thaw(vfsp, ufsvfsp, ulp); 11527c478bd9Sstevel@tonic-gate ULOCKFS_CLR_BUSY(ulp); 11537c478bd9Sstevel@tonic-gate LOCKFS_CLR_BUSY(&ulp->ul_lockfs); 11547c478bd9Sstevel@tonic-gate 11557c478bd9Sstevel@tonic-gate errexit: 1156bc69f433Saguzovsk atomic_add_long(&ufs_quiesce_pend, -1); 11577c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 11587c478bd9Sstevel@tonic-gate vfs_unlock(vfsp); 11597c478bd9Sstevel@tonic-gate 11607c478bd9Sstevel@tonic-gate /* 11617c478bd9Sstevel@tonic-gate * Allow both the delete thread and the reclaim thread to 11627c478bd9Sstevel@tonic-gate * continue. 11637c478bd9Sstevel@tonic-gate */ 11647c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_delete); 11657c478bd9Sstevel@tonic-gate ufs_thread_continue(&ufsvfsp->vfs_reclaim); 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate return (error); 11687c478bd9Sstevel@tonic-gate } 11697c478bd9Sstevel@tonic-gate 11707c478bd9Sstevel@tonic-gate /* 11717c478bd9Sstevel@tonic-gate * fiolfss 11727c478bd9Sstevel@tonic-gate * return the current file system locking state info 11737c478bd9Sstevel@tonic-gate */ 11747c478bd9Sstevel@tonic-gate int 11757c478bd9Sstevel@tonic-gate ufs_fiolfss(struct vnode *vp, struct lockfs *lockfsp) 11767c478bd9Sstevel@tonic-gate { 11777c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 11787c478bd9Sstevel@tonic-gate 11797c478bd9Sstevel@tonic-gate if (!vp || !vp->v_vfsp || !VTOI(vp)) 11807c478bd9Sstevel@tonic-gate return (EINVAL); 11817c478bd9Sstevel@tonic-gate 11827c478bd9Sstevel@tonic-gate /* file system has been forcibly unmounted */ 11837c478bd9Sstevel@tonic-gate if (VTOI(vp)->i_ufsvfs == NULL) 11847c478bd9Sstevel@tonic-gate return (EIO); 11857c478bd9Sstevel@tonic-gate 11867c478bd9Sstevel@tonic-gate ulp = VTOUL(vp); 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(ulp)) { 11897c478bd9Sstevel@tonic-gate *lockfsp = ulp->ul_lockfs; /* structure assignment */ 11907c478bd9Sstevel@tonic-gate return (0); 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate 11937c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 11947c478bd9Sstevel@tonic-gate 11957c478bd9Sstevel@tonic-gate *lockfsp = ulp->ul_lockfs; /* structure assignment */ 11967c478bd9Sstevel@tonic-gate 11977c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_MOD(ulp)) 11987c478bd9Sstevel@tonic-gate lockfsp->lf_flags |= LOCKFS_MOD; 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 12017c478bd9Sstevel@tonic-gate 12027c478bd9Sstevel@tonic-gate return (0); 12037c478bd9Sstevel@tonic-gate } 12047c478bd9Sstevel@tonic-gate 12057c478bd9Sstevel@tonic-gate /* 12067c478bd9Sstevel@tonic-gate * ufs_check_lockfs 12077c478bd9Sstevel@tonic-gate * check whether a ufs_vnops conflicts with the file system lock 12087c478bd9Sstevel@tonic-gate */ 12097c478bd9Sstevel@tonic-gate int 12107c478bd9Sstevel@tonic-gate ufs_check_lockfs(struct ufsvfs *ufsvfsp, struct ulockfs *ulp, ulong_t mask) 12117c478bd9Sstevel@tonic-gate { 12127c478bd9Sstevel@tonic-gate k_sigset_t smask; 12137c478bd9Sstevel@tonic-gate int sig, slock; 12147c478bd9Sstevel@tonic-gate 12157c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&ulp->ul_lock)); 12167c478bd9Sstevel@tonic-gate 12177c478bd9Sstevel@tonic-gate while (ulp->ul_fs_lock & mask) { 12187c478bd9Sstevel@tonic-gate slock = (int)ULOCKFS_IS_SLOCK(ulp); 12197c478bd9Sstevel@tonic-gate if ((curthread->t_flag & T_DONTPEND) && !slock) { 12207c478bd9Sstevel@tonic-gate curthread->t_flag |= T_WOULDBLOCK; 12217c478bd9Sstevel@tonic-gate return (EAGAIN); 12227c478bd9Sstevel@tonic-gate } 12237c478bd9Sstevel@tonic-gate curthread->t_flag &= ~T_WOULDBLOCK; 12247c478bd9Sstevel@tonic-gate 12257c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_HLOCK(ulp)) 12267c478bd9Sstevel@tonic-gate return (EIO); 12277c478bd9Sstevel@tonic-gate 12287c478bd9Sstevel@tonic-gate /* 12297c478bd9Sstevel@tonic-gate * wait for lock status to change 12307c478bd9Sstevel@tonic-gate */ 12317c478bd9Sstevel@tonic-gate if (slock || ufsvfsp->vfs_nointr) { 12327c478bd9Sstevel@tonic-gate cv_wait(&ulp->ul_cv, &ulp->ul_lock); 12337c478bd9Sstevel@tonic-gate } else { 12347c478bd9Sstevel@tonic-gate sigintr(&smask, 1); 12357c478bd9Sstevel@tonic-gate sig = cv_wait_sig(&ulp->ul_cv, &ulp->ul_lock); 12367c478bd9Sstevel@tonic-gate sigunintr(&smask); 12377c478bd9Sstevel@tonic-gate if ((!sig && (ulp->ul_fs_lock & mask)) || 12387c478bd9Sstevel@tonic-gate ufsvfsp->vfs_dontblock) 12397c478bd9Sstevel@tonic-gate return (EINTR); 12407c478bd9Sstevel@tonic-gate } 12417c478bd9Sstevel@tonic-gate } 1242*303bf60bSsdebnath 1243*303bf60bSsdebnath if (mask & ULOCKFS_FWLOCK) { 1244*303bf60bSsdebnath atomic_add_long(&ulp->ul_falloc_cnt, 1); 1245*303bf60bSsdebnath ULOCKFS_SET_FALLOC(ulp); 1246*303bf60bSsdebnath } else { 1247bc69f433Saguzovsk atomic_add_long(&ulp->ul_vnops_cnt, 1); 1248*303bf60bSsdebnath } 1249*303bf60bSsdebnath 12507c478bd9Sstevel@tonic-gate return (0); 12517c478bd9Sstevel@tonic-gate } 12527c478bd9Sstevel@tonic-gate 12537c478bd9Sstevel@tonic-gate /* 12547c478bd9Sstevel@tonic-gate * Check whether we came across the handcrafted lockfs protocol path. We can't 12557c478bd9Sstevel@tonic-gate * simply check for T_DONTBLOCK here as one would assume since this can also 12567c478bd9Sstevel@tonic-gate * falsely catch recursive VOP's going to a different filesystem, instead we 12577c478bd9Sstevel@tonic-gate * check if we already hold the ulockfs->ul_lock mutex. 12587c478bd9Sstevel@tonic-gate */ 12597c478bd9Sstevel@tonic-gate static int 12607c478bd9Sstevel@tonic-gate ufs_lockfs_is_under_rawlockfs(struct ulockfs *ulp) 12617c478bd9Sstevel@tonic-gate { 12627c478bd9Sstevel@tonic-gate return ((mutex_owner(&ulp->ul_lock) != curthread) ? 0 : 1); 12637c478bd9Sstevel@tonic-gate } 12647c478bd9Sstevel@tonic-gate 12657c478bd9Sstevel@tonic-gate /* 12667c478bd9Sstevel@tonic-gate * ufs_lockfs_begin - start the lockfs locking protocol 12677c478bd9Sstevel@tonic-gate */ 12687c478bd9Sstevel@tonic-gate int 12697c478bd9Sstevel@tonic-gate ufs_lockfs_begin(struct ufsvfs *ufsvfsp, struct ulockfs **ulpp, ulong_t mask) 12707c478bd9Sstevel@tonic-gate { 12717c478bd9Sstevel@tonic-gate int error; 12727c478bd9Sstevel@tonic-gate int rec_vop; 12737c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 12747c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info; 12757c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_free; 12767c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_temp; 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate /* 12797c478bd9Sstevel@tonic-gate * file system has been forcibly unmounted 12807c478bd9Sstevel@tonic-gate */ 12817c478bd9Sstevel@tonic-gate if (ufsvfsp == NULL) 12827c478bd9Sstevel@tonic-gate return (EIO); 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate *ulpp = ulp = &ufsvfsp->vfs_ulockfs; 12857c478bd9Sstevel@tonic-gate 12867c478bd9Sstevel@tonic-gate /* 12877c478bd9Sstevel@tonic-gate * Do lockfs protocol 12887c478bd9Sstevel@tonic-gate */ 12897c478bd9Sstevel@tonic-gate ulockfs_info = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 12907c478bd9Sstevel@tonic-gate IS_REC_VOP(rec_vop, ulockfs_info, ulp, ulockfs_info_free); 12917c478bd9Sstevel@tonic-gate 12927c478bd9Sstevel@tonic-gate /* 12937c478bd9Sstevel@tonic-gate * Detect recursive VOP call or handcrafted internal lockfs protocol 12947c478bd9Sstevel@tonic-gate * path and bail out in that case. 12957c478bd9Sstevel@tonic-gate */ 12967c478bd9Sstevel@tonic-gate if (rec_vop || ufs_lockfs_is_under_rawlockfs(ulp)) { 12977c478bd9Sstevel@tonic-gate *ulpp = NULL; 12987c478bd9Sstevel@tonic-gate return (0); 12997c478bd9Sstevel@tonic-gate } else { 13007c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) { 13017c478bd9Sstevel@tonic-gate if ((ulockfs_info_temp = (ulockfs_info_t *) 13027c478bd9Sstevel@tonic-gate kmem_zalloc(sizeof (ulockfs_info_t), 13037c478bd9Sstevel@tonic-gate KM_NOSLEEP)) == NULL) { 13047c478bd9Sstevel@tonic-gate *ulpp = NULL; 13057c478bd9Sstevel@tonic-gate return (ENOMEM); 13067c478bd9Sstevel@tonic-gate } 13077c478bd9Sstevel@tonic-gate } 13087c478bd9Sstevel@tonic-gate } 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate /* 13117c478bd9Sstevel@tonic-gate * First time VOP call 13127c478bd9Sstevel@tonic-gate */ 13137c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 1314*303bf60bSsdebnath if (ULOCKFS_IS_JUSTULOCK(ulp)) { 1315*303bf60bSsdebnath if (mask & ULOCKFS_FWLOCK) { 1316*303bf60bSsdebnath atomic_add_long(&ulp->ul_falloc_cnt, 1); 1317*303bf60bSsdebnath ULOCKFS_SET_FALLOC(ulp); 1318*303bf60bSsdebnath } else { 1319bc69f433Saguzovsk atomic_add_long(&ulp->ul_vnops_cnt, 1); 1320*303bf60bSsdebnath } 1321*303bf60bSsdebnath } else { 13227c478bd9Sstevel@tonic-gate if (error = ufs_check_lockfs(ufsvfsp, ulp, mask)) { 13237c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 13247c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) 13257c478bd9Sstevel@tonic-gate kmem_free(ulockfs_info_temp, 13267c478bd9Sstevel@tonic-gate sizeof (ulockfs_info_t)); 13277c478bd9Sstevel@tonic-gate return (error); 13287c478bd9Sstevel@tonic-gate } 13297c478bd9Sstevel@tonic-gate } 13307c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 13317c478bd9Sstevel@tonic-gate 13327c478bd9Sstevel@tonic-gate if (ulockfs_info_free != NULL) { 13337c478bd9Sstevel@tonic-gate ulockfs_info_free->ulp = ulp; 1334*303bf60bSsdebnath if (mask & ULOCKFS_FWLOCK) 1335*303bf60bSsdebnath ulockfs_info_free->flags |= ULOCK_INFO_FALLOCATE; 13367c478bd9Sstevel@tonic-gate } else { 13377c478bd9Sstevel@tonic-gate ulockfs_info_temp->ulp = ulp; 13387c478bd9Sstevel@tonic-gate ulockfs_info_temp->next = ulockfs_info; 1339*303bf60bSsdebnath if (mask & ULOCKFS_FWLOCK) 1340*303bf60bSsdebnath ulockfs_info_temp->flags |= ULOCK_INFO_FALLOCATE; 13417c478bd9Sstevel@tonic-gate ASSERT(ufs_lockfs_key != 0); 13427c478bd9Sstevel@tonic-gate (void) tsd_set(ufs_lockfs_key, (void *)ulockfs_info_temp); 13437c478bd9Sstevel@tonic-gate } 13447c478bd9Sstevel@tonic-gate 13457c478bd9Sstevel@tonic-gate curthread->t_flag |= T_DONTBLOCK; 13467c478bd9Sstevel@tonic-gate return (0); 13477c478bd9Sstevel@tonic-gate } 13487c478bd9Sstevel@tonic-gate 13497c478bd9Sstevel@tonic-gate /* 13507c478bd9Sstevel@tonic-gate * Check whether we are returning from the top level VOP. 13517c478bd9Sstevel@tonic-gate */ 13527c478bd9Sstevel@tonic-gate static int 13537c478bd9Sstevel@tonic-gate ufs_lockfs_top_vop_return(ulockfs_info_t *head) 13547c478bd9Sstevel@tonic-gate { 13557c478bd9Sstevel@tonic-gate ulockfs_info_t *info; 13567c478bd9Sstevel@tonic-gate int result = 1; 13577c478bd9Sstevel@tonic-gate 13587c478bd9Sstevel@tonic-gate for (info = head; info != NULL; info = info->next) { 13597c478bd9Sstevel@tonic-gate if (info->ulp != NULL) { 13607c478bd9Sstevel@tonic-gate result = 0; 13617c478bd9Sstevel@tonic-gate break; 13627c478bd9Sstevel@tonic-gate } 13637c478bd9Sstevel@tonic-gate } 13647c478bd9Sstevel@tonic-gate 13657c478bd9Sstevel@tonic-gate return (result); 13667c478bd9Sstevel@tonic-gate } 13677c478bd9Sstevel@tonic-gate 13687c478bd9Sstevel@tonic-gate /* 13697c478bd9Sstevel@tonic-gate * ufs_lockfs_end - terminate the lockfs locking protocol 13707c478bd9Sstevel@tonic-gate */ 13717c478bd9Sstevel@tonic-gate void 13727c478bd9Sstevel@tonic-gate ufs_lockfs_end(struct ulockfs *ulp) 13737c478bd9Sstevel@tonic-gate { 13747c478bd9Sstevel@tonic-gate ulockfs_info_t *info; 13757c478bd9Sstevel@tonic-gate ulockfs_info_t *head; 13767c478bd9Sstevel@tonic-gate 13777c478bd9Sstevel@tonic-gate /* 13787c478bd9Sstevel@tonic-gate * end-of-VOP protocol 13797c478bd9Sstevel@tonic-gate */ 13807c478bd9Sstevel@tonic-gate if (ulp == NULL) 13817c478bd9Sstevel@tonic-gate return; 13827c478bd9Sstevel@tonic-gate 13837c478bd9Sstevel@tonic-gate head = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 13847c478bd9Sstevel@tonic-gate SEARCH_ULOCKFSP(head, ulp, info); 13857c478bd9Sstevel@tonic-gate 13867c478bd9Sstevel@tonic-gate /* 13877c478bd9Sstevel@tonic-gate * If we're called from a first level VOP, we have to have a 13887c478bd9Sstevel@tonic-gate * valid ulockfs record in the TSD. 13897c478bd9Sstevel@tonic-gate */ 13907c478bd9Sstevel@tonic-gate ASSERT(info != NULL); 13917c478bd9Sstevel@tonic-gate 13927c478bd9Sstevel@tonic-gate /* 13937c478bd9Sstevel@tonic-gate * Invalidate the ulockfs record. 13947c478bd9Sstevel@tonic-gate */ 13957c478bd9Sstevel@tonic-gate info->ulp = NULL; 13967c478bd9Sstevel@tonic-gate 13977c478bd9Sstevel@tonic-gate if (ufs_lockfs_top_vop_return(head)) 13987c478bd9Sstevel@tonic-gate curthread->t_flag &= ~T_DONTBLOCK; 13997c478bd9Sstevel@tonic-gate 14007c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 14017c478bd9Sstevel@tonic-gate 1402*303bf60bSsdebnath /* fallocate thread */ 1403*303bf60bSsdebnath if (ULOCKFS_IS_FALLOC(ulp) && info->flags & ULOCK_INFO_FALLOCATE) { 1404*303bf60bSsdebnath if (!atomic_add_long_nv(&ulp->ul_falloc_cnt, -1)) 1405*303bf60bSsdebnath ULOCKFS_CLR_FALLOC(ulp); 1406*303bf60bSsdebnath } else { /* normal thread */ 1407bc69f433Saguzovsk if (!atomic_add_long_nv(&ulp->ul_vnops_cnt, -1)) 14087c478bd9Sstevel@tonic-gate cv_broadcast(&ulp->ul_cv); 1409*303bf60bSsdebnath } 1410*303bf60bSsdebnath 1411*303bf60bSsdebnath /* Clear the thread's fallocate state */ 1412*303bf60bSsdebnath if (info->flags & ULOCK_INFO_FALLOCATE) 1413*303bf60bSsdebnath info->flags &= ~ULOCK_INFO_FALLOCATE; 1414*303bf60bSsdebnath 1415*303bf60bSsdebnath if (ulp->ul_vnops_cnt == 0 && ulp->ul_falloc_cnt) 1416*303bf60bSsdebnath cv_broadcast(&ulp->ul_cv); 14177c478bd9Sstevel@tonic-gate 14187c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 14197c478bd9Sstevel@tonic-gate } 14207c478bd9Sstevel@tonic-gate 14217c478bd9Sstevel@tonic-gate /* 14227c478bd9Sstevel@tonic-gate * specialized version of ufs_lockfs_begin() called by ufs_getpage(). 14237c478bd9Sstevel@tonic-gate */ 14247c478bd9Sstevel@tonic-gate int 14257c478bd9Sstevel@tonic-gate ufs_lockfs_begin_getpage( 14267c478bd9Sstevel@tonic-gate struct ufsvfs *ufsvfsp, 14277c478bd9Sstevel@tonic-gate struct ulockfs **ulpp, 14287c478bd9Sstevel@tonic-gate struct seg *seg, 14297c478bd9Sstevel@tonic-gate int read_access, 14307c478bd9Sstevel@tonic-gate uint_t *protp) 14317c478bd9Sstevel@tonic-gate { 14327c478bd9Sstevel@tonic-gate ulong_t mask; 14337c478bd9Sstevel@tonic-gate int error; 14347c478bd9Sstevel@tonic-gate int rec_vop; 14357c478bd9Sstevel@tonic-gate struct ulockfs *ulp; 14367c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info; 14377c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_free; 14387c478bd9Sstevel@tonic-gate ulockfs_info_t *ulockfs_info_temp; 14397c478bd9Sstevel@tonic-gate 14407c478bd9Sstevel@tonic-gate /* 14417c478bd9Sstevel@tonic-gate * file system has been forcibly unmounted 14427c478bd9Sstevel@tonic-gate */ 14437c478bd9Sstevel@tonic-gate if (ufsvfsp == NULL) 14447c478bd9Sstevel@tonic-gate return (EIO); 14457c478bd9Sstevel@tonic-gate 14467c478bd9Sstevel@tonic-gate *ulpp = ulp = &ufsvfsp->vfs_ulockfs; 14477c478bd9Sstevel@tonic-gate 14487c478bd9Sstevel@tonic-gate /* 14497c478bd9Sstevel@tonic-gate * Do lockfs protocol 14507c478bd9Sstevel@tonic-gate */ 14517c478bd9Sstevel@tonic-gate ulockfs_info = (ulockfs_info_t *)tsd_get(ufs_lockfs_key); 14527c478bd9Sstevel@tonic-gate IS_REC_VOP(rec_vop, ulockfs_info, ulp, ulockfs_info_free); 14537c478bd9Sstevel@tonic-gate 14547c478bd9Sstevel@tonic-gate /* 14557c478bd9Sstevel@tonic-gate * Detect recursive VOP call or handcrafted internal lockfs protocol 14567c478bd9Sstevel@tonic-gate * path and bail out in that case. 14577c478bd9Sstevel@tonic-gate */ 14587c478bd9Sstevel@tonic-gate if (rec_vop || ufs_lockfs_is_under_rawlockfs(ulp)) { 14597c478bd9Sstevel@tonic-gate *ulpp = NULL; 14607c478bd9Sstevel@tonic-gate return (0); 14617c478bd9Sstevel@tonic-gate } else { 14627c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) { 14637c478bd9Sstevel@tonic-gate if ((ulockfs_info_temp = (ulockfs_info_t *) 14647c478bd9Sstevel@tonic-gate kmem_zalloc(sizeof (ulockfs_info_t), 14657c478bd9Sstevel@tonic-gate KM_NOSLEEP)) == NULL) { 14667c478bd9Sstevel@tonic-gate *ulpp = NULL; 14677c478bd9Sstevel@tonic-gate return (ENOMEM); 14687c478bd9Sstevel@tonic-gate } 14697c478bd9Sstevel@tonic-gate } 14707c478bd9Sstevel@tonic-gate } 14717c478bd9Sstevel@tonic-gate 14727c478bd9Sstevel@tonic-gate /* 14737c478bd9Sstevel@tonic-gate * First time VOP call 14747c478bd9Sstevel@tonic-gate */ 14757c478bd9Sstevel@tonic-gate mutex_enter(&ulp->ul_lock); 14767c478bd9Sstevel@tonic-gate if (ULOCKFS_IS_JUSTULOCK(ulp)) 14777c478bd9Sstevel@tonic-gate /* 14787c478bd9Sstevel@tonic-gate * fs is not locked, simply inc the active-ops counter 14797c478bd9Sstevel@tonic-gate */ 1480bc69f433Saguzovsk atomic_add_long(&ulp->ul_vnops_cnt, 1); 14817c478bd9Sstevel@tonic-gate else { 14827c478bd9Sstevel@tonic-gate if (seg->s_ops == &segvn_ops && 14837c478bd9Sstevel@tonic-gate ((struct segvn_data *)seg->s_data)->type != MAP_SHARED) { 14847c478bd9Sstevel@tonic-gate mask = (ulong_t)ULOCKFS_GETREAD_MASK; 14857c478bd9Sstevel@tonic-gate } else if (protp && read_access) { 14867c478bd9Sstevel@tonic-gate /* 14877c478bd9Sstevel@tonic-gate * Restrict the mapping to readonly. 14887c478bd9Sstevel@tonic-gate * Writes to this mapping will cause 14897c478bd9Sstevel@tonic-gate * another fault which will then 14907c478bd9Sstevel@tonic-gate * be suspended if fs is write locked 14917c478bd9Sstevel@tonic-gate */ 14927c478bd9Sstevel@tonic-gate *protp &= ~PROT_WRITE; 14937c478bd9Sstevel@tonic-gate mask = (ulong_t)ULOCKFS_GETREAD_MASK; 14947c478bd9Sstevel@tonic-gate } else 14957c478bd9Sstevel@tonic-gate mask = (ulong_t)ULOCKFS_GETWRITE_MASK; 14967c478bd9Sstevel@tonic-gate 14977c478bd9Sstevel@tonic-gate /* 14987c478bd9Sstevel@tonic-gate * will sleep if this fs is locked against this VOP 14997c478bd9Sstevel@tonic-gate */ 15007c478bd9Sstevel@tonic-gate if (error = ufs_check_lockfs(ufsvfsp, ulp, mask)) { 15017c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 15027c478bd9Sstevel@tonic-gate if (ulockfs_info_free == NULL) 15037c478bd9Sstevel@tonic-gate kmem_free(ulockfs_info_temp, 15047c478bd9Sstevel@tonic-gate sizeof (ulockfs_info_t)); 15057c478bd9Sstevel@tonic-gate return (error); 15067c478bd9Sstevel@tonic-gate } 15077c478bd9Sstevel@tonic-gate } 15087c478bd9Sstevel@tonic-gate mutex_exit(&ulp->ul_lock); 15097c478bd9Sstevel@tonic-gate 15107c478bd9Sstevel@tonic-gate if (ulockfs_info_free != NULL) { 15117c478bd9Sstevel@tonic-gate ulockfs_info_free->ulp = ulp; 15127c478bd9Sstevel@tonic-gate } else { 15137c478bd9Sstevel@tonic-gate ulockfs_info_temp->ulp = ulp; 15147c478bd9Sstevel@tonic-gate ulockfs_info_temp->next = ulockfs_info; 15157c478bd9Sstevel@tonic-gate ASSERT(ufs_lockfs_key != 0); 15167c478bd9Sstevel@tonic-gate (void) tsd_set(ufs_lockfs_key, (void *)ulockfs_info_temp); 15177c478bd9Sstevel@tonic-gate } 15187c478bd9Sstevel@tonic-gate 15197c478bd9Sstevel@tonic-gate curthread->t_flag |= T_DONTBLOCK; 15207c478bd9Sstevel@tonic-gate return (0); 15217c478bd9Sstevel@tonic-gate } 15227c478bd9Sstevel@tonic-gate 15237c478bd9Sstevel@tonic-gate void 15247c478bd9Sstevel@tonic-gate ufs_lockfs_tsd_destructor(void *head) 15257c478bd9Sstevel@tonic-gate { 15267c478bd9Sstevel@tonic-gate ulockfs_info_t *curr = (ulockfs_info_t *)head; 15277c478bd9Sstevel@tonic-gate ulockfs_info_t *temp; 15287c478bd9Sstevel@tonic-gate 15297c478bd9Sstevel@tonic-gate for (; curr != NULL; ) { 15307c478bd9Sstevel@tonic-gate /* 15317c478bd9Sstevel@tonic-gate * The TSD destructor is being called when the thread exits 15327c478bd9Sstevel@tonic-gate * (via thread_exit()). At that time it must have cleaned up 15337c478bd9Sstevel@tonic-gate * all VOPs via ufs_lockfs_end() and there must not be a 15347c478bd9Sstevel@tonic-gate * valid ulockfs record exist while a thread is exiting. 15357c478bd9Sstevel@tonic-gate */ 15367c478bd9Sstevel@tonic-gate temp = curr; 15377c478bd9Sstevel@tonic-gate curr = curr->next; 15387c478bd9Sstevel@tonic-gate ASSERT(temp->ulp == NULL); 15397c478bd9Sstevel@tonic-gate kmem_free(temp, sizeof (ulockfs_info_t)); 15407c478bd9Sstevel@tonic-gate } 15417c478bd9Sstevel@tonic-gate } 1542