Index: coda/cnode.h =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/coda/cnode.h,v retrieving revision 1.9 diff -u -r1.9 cnode.h --- coda/cnode.h 16 May 2002 21:25:34 -0000 1.9 +++ coda/cnode.h 17 May 2002 00:51:58 -0000 @@ -102,7 +102,6 @@ struct vnode *c_vnode; u_short c_flags; /* flags (see below) */ ViceFid c_fid; /* file handle */ - struct lock c_lock; /* new lock protocol */ struct vnode *c_ovp; /* open vnode pointer */ u_short c_ocount; /* count of openers */ u_short c_owrite; /* count of open for write */ Index: coda/coda_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/coda/coda_vnops.c,v retrieving revision 1.42 diff -u -r1.42 coda_vnops.c --- coda/coda_vnops.c 16 May 2002 21:25:34 -0000 1.42 +++ coda/coda_vnops.c 17 May 2002 00:52:00 -0000 @@ -92,7 +92,6 @@ /* What we are delaying for in printf */ int coda_printf_delay = 0; /* in microseconds */ int coda_vnop_print_entry = 0; -static int coda_lockdebug = 0; /* Definition of the vfs operation vector */ static int (**coda_vnodeop_p)(void *); @@ -132,12 +131,12 @@ { &vop_readlink_desc, coda_readlink }, /* readlink */ { &vop_inactive_desc, coda_inactive }, /* inactive */ { &vop_reclaim_desc, coda_reclaim }, /* reclaim */ - { &vop_lock_desc, coda_lock }, /* lock */ - { &vop_unlock_desc, coda_unlock }, /* unlock */ + { &vop_lock_desc, (vop_t *)vop_stdlock }, /* lock */ + { &vop_locktest_desc, (vop_t *)vop_stdlocktest }, /* locktest */ + { &vop_unlock_desc, (vop_t *)vop_stdunlock }, /* unlock */ { &vop_bmap_desc, coda_bmap }, /* bmap */ { &vop_strategy_desc, coda_strategy }, /* strategy */ { &vop_print_desc, coda_vop_error }, /* print */ - { &vop_islocked_desc, coda_islocked }, /* islocked */ { &vop_pathconf_desc, coda_vop_error }, /* pathconf */ { &vop_advlock_desc, coda_vop_nop }, /* advlock */ { &vop_lease_desc, coda_vop_nop }, /* lease */ @@ -931,7 +930,7 @@ printf("coda_inactive: cp->ovp != NULL use %d: vp %p, cp %p\n", vp->v_usecount, vp, cp); #endif - lockmgr(&cp->c_lock, LK_RELEASE, &vp->v_interlock, td); + VOP_UNLOCK(vp, 0, td); } else { #ifdef OLD_DIAGNOSTIC if (CTOV(cp)->v_usecount) { @@ -1773,72 +1772,11 @@ #endif } cache_purge(vp); - lockdestroy(&(VTOC(vp)->c_lock)); coda_free(VTOC(vp)); VTOC(vp) = NULL; return (0); } -int -coda_lock(v) - void *v; -{ -/* true args */ - struct vop_lock_args *ap = v; - struct vnode *vp = ap->a_vp; - struct cnode *cp = VTOC(vp); - struct thread *td = ap->a_td; -/* upcall decl */ -/* locals */ - - ENTRY; - - if (coda_lockdebug) { - myprintf(("Attempting lock on %lx.%lx.%lx\n", - cp->c_fid.Volume, cp->c_fid.Vnode, cp->c_fid.Unique)); - } - -#ifndef DEBUG_LOCKS - return (lockmgr(&cp->c_lock, ap->a_flags, &vp->v_interlock, td)); -#else - return (debuglockmgr(&cp->c_lock, ap->a_flags, &vp->v_interlock, td, - "coda_lock", vp->filename, vp->line)); -#endif -} - -int -coda_unlock(v) - void *v; -{ -/* true args */ - struct vop_unlock_args *ap = v; - struct vnode *vp = ap->a_vp; - struct cnode *cp = VTOC(vp); - struct thread *td = ap->a_td; -/* upcall decl */ -/* locals */ - - ENTRY; - if (coda_lockdebug) { - myprintf(("Attempting unlock on %lx.%lx.%lx\n", - cp->c_fid.Volume, cp->c_fid.Vnode, cp->c_fid.Unique)); - } - - return (lockmgr(&cp->c_lock, ap->a_flags | LK_RELEASE, &vp->v_interlock, td)); -} - -int -coda_islocked(v) - void *v; -{ -/* true args */ - struct vop_islocked_args *ap = v; - struct cnode *cp = VTOC(ap->a_vp); - ENTRY; - - return (lockstatus(&cp->c_lock, ap->a_td)); -} - /* How one looks up a vnode given a device/inode pair: */ int coda_grab_vnode(dev_t dev, ino_t ino, struct vnode **vpp) @@ -1956,7 +1894,6 @@ struct vnode *vp; cp = coda_alloc(); - lockinit(&cp->c_lock, PINOD, "cnode", 0, 0); cp->c_fid = *fid; err = getnewvnode(VT_CODA, vfsp, coda_vnodeop_p, &vp); Index: coda/coda_vnops.h =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/coda/coda_vnops.h,v retrieving revision 1.11 diff -u -r1.11 coda_vnops.h --- coda/coda_vnops.h 16 May 2002 21:25:34 -0000 1.11 +++ coda/coda_vnops.h 17 May 2002 00:52:00 -0000 @@ -72,9 +72,6 @@ int coda_bmap(void *); int coda_strategy(void *); int coda_reclaim(void *); -int coda_lock(void *); -int coda_unlock(void *); -int coda_islocked(void *); int coda_vop_error(void *); int coda_vop_nop(void *); int coda_fbsd_getpages (void *); Index: fs/devfs/devfs_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/devfs/devfs_vnops.c,v retrieving revision 1.41 diff -u -r1.41 devfs_vnops.c --- fs/devfs/devfs_vnops.c 17 Jul 2002 01:46:48 -0000 1.41 +++ fs/devfs/devfs_vnops.c 27 Jul 2002 16:54:25 -0000 @@ -828,8 +828,8 @@ { &vop_access_desc, (vop_t *) devfs_access }, { &vop_getattr_desc, (vop_t *) devfs_getattr }, { &vop_ioctl_desc, (vop_t *) devfs_ioctl }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_lookup_desc, (vop_t *) devfs_lookup }, { &vop_mknod_desc, (vop_t *) devfs_mknod }, { &vop_pathconf_desc, (vop_t *) devfs_pathconf }, @@ -855,8 +855,8 @@ { &vop_default_desc, (vop_t *) spec_vnoperate }, { &vop_access_desc, (vop_t *) devfs_access }, { &vop_getattr_desc, (vop_t *) devfs_getattr }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_print_desc, (vop_t *) devfs_print }, { &vop_reclaim_desc, (vop_t *) devfs_reclaim }, { &vop_remove_desc, (vop_t *) devfs_remove }, Index: fs/fdescfs/fdesc_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/fdescfs/fdesc_vnops.c,v retrieving revision 1.75 diff -u -r1.75 fdesc_vnops.c --- fs/fdescfs/fdesc_vnops.c 9 Jul 2002 19:43:39 -0000 1.75 +++ fs/fdescfs/fdesc_vnops.c 28 Jul 2002 14:13:44 -0000 @@ -566,7 +566,7 @@ { &vop_setattr_desc, (vop_t *) fdesc_setattr }, { &vop_lock_desc, (vop_t *) vop_stdlock }, { &vop_unlock_desc, (vop_t *) vop_stdunlock }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { NULL, NULL } }; static struct vnodeopv_desc fdesc_vnodeop_opv_desc = Index: fs/hpfs/hpfs_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/hpfs/hpfs_vnops.c,v retrieving revision 1.29 diff -u -r1.29 hpfs_vnops.c --- fs/hpfs/hpfs_vnops.c 16 May 2002 21:25:35 -0000 1.29 +++ fs/hpfs/hpfs_vnops.c 17 May 2002 00:52:47 -0000 @@ -1264,7 +1264,7 @@ { &vop_print_desc, (vop_t *)hpfs_print }, { &vop_create_desc, (vop_t *)hpfs_create }, { &vop_remove_desc, (vop_t *)hpfs_remove }, - { &vop_islocked_desc, (vop_t *)vop_stdislocked }, + { &vop_locktest_desc, (vop_t *)vop_stdlocktest }, { &vop_unlock_desc, (vop_t *)vop_stdunlock }, { &vop_lock_desc, (vop_t *)vop_stdlock }, { &vop_cachedlookup_desc, (vop_t *)hpfs_lookup }, Index: fs/msdosfs/msdosfs_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/msdosfs/msdosfs_vnops.c,v retrieving revision 1.121 diff -u -r1.121 msdosfs_vnops.c --- fs/msdosfs/msdosfs_vnops.c 16 May 2002 21:25:37 -0000 1.121 +++ fs/msdosfs/msdosfs_vnops.c 17 May 2002 00:52:48 -0000 @@ -1879,9 +1879,9 @@ { &vop_fsync_desc, (vop_t *) msdosfs_fsync }, { &vop_getattr_desc, (vop_t *) msdosfs_getattr }, { &vop_inactive_desc, (vop_t *) msdosfs_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_link_desc, (vop_t *) msdosfs_link }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_lookup_desc, (vop_t *) vfs_cache_lookup }, { &vop_mkdir_desc, (vop_t *) msdosfs_mkdir }, { &vop_mknod_desc, (vop_t *) msdosfs_mknod }, Index: fs/ntfs/ntfs_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/ntfs/ntfs_vnops.c,v retrieving revision 1.30 diff -u -r1.30 ntfs_vnops.c --- fs/ntfs/ntfs_vnops.c 16 May 2002 21:25:39 -0000 1.30 +++ fs/ntfs/ntfs_vnops.c 17 May 2002 00:52:49 -0000 @@ -733,7 +733,7 @@ { &vop_print_desc, (vop_t *)ntfs_print }, { &vop_pathconf_desc, ntfs_pathconf }, - { &vop_islocked_desc, (vop_t *)vop_stdislocked }, + { &vop_locktest_desc, (vop_t *)vop_stdlocktest }, { &vop_unlock_desc, (vop_t *)vop_stdunlock }, { &vop_lock_desc, (vop_t *)vop_stdlock }, { &vop_cachedlookup_desc, (vop_t *)ntfs_lookup }, Index: fs/nullfs/null_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/nullfs/null_vnops.c,v retrieving revision 1.56 diff -u -r1.56 null_vnops.c --- fs/nullfs/null_vnops.c 13 Jun 2002 21:49:09 -0000 1.56 +++ fs/nullfs/null_vnops.c 14 Jun 2002 00:04:53 -0000 @@ -202,8 +202,8 @@ static int null_getattr(struct vop_getattr_args *ap); static int null_getvobject(struct vop_getvobject_args *ap); static int null_inactive(struct vop_inactive_args *ap); -static int null_islocked(struct vop_islocked_args *ap); static int null_lock(struct vop_lock_args *ap); +static int null_locktest(struct vop_locktest_args *ap); static int null_lookup(struct vop_lookup_args *ap); static int null_open(struct vop_open_args *ap); static int null_print(struct vop_print_args *ap); @@ -691,18 +691,33 @@ } static int -null_islocked(ap) - struct vop_islocked_args /* { +null_locktest(ap) + struct vop_locktest_args /* { struct vnode *a_vp; + int a_flags; struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; struct thread *td = ap->a_td; + int status; if (vp->v_vnlock != NULL) - return (lockstatus(vp->v_vnlock, td)); - return (lockstatus(&vp->v_lock, td)); + status = lockstatus(vp->v_vnlock, td); + else + status = lockstatus(&vp->v_lock, td); + switch (ap->a_flags) { + case VLKTEST_UNLOCKED: + return (status == 0); + case VLKTEST_LOCKED: + return (status != 0); + case VLKTEST_XLOCKED: + return (status == LK_EXCLUSIVE); + case VLKTEST_SLOCKED: + return (status == LK_SHARED); + default: + panic("null_locktest: bad flags %d", ap->a_flags); + } } /* @@ -842,8 +857,8 @@ { &vop_getvobject_desc, (vop_t *) null_getvobject }, { &vop_getwritemount_desc, (vop_t *) vop_stdgetwritemount}, { &vop_inactive_desc, (vop_t *) null_inactive }, - { &vop_islocked_desc, (vop_t *) null_islocked }, { &vop_lock_desc, (vop_t *) null_lock }, + { &vop_locktest_desc, (vop_t *) null_locktest }, { &vop_lookup_desc, (vop_t *) null_lookup }, { &vop_open_desc, (vop_t *) null_open }, { &vop_print_desc, (vop_t *) null_print }, Index: fs/nwfs/nwfs_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/nwfs/nwfs_vnops.c,v retrieving revision 1.21 diff -u -r1.21 nwfs_vnops.c --- fs/nwfs/nwfs_vnops.c 12 Sep 2001 08:37:19 -0000 1.21 +++ fs/nwfs/nwfs_vnops.c 27 Apr 2002 16:42:52 -0000 @@ -96,9 +96,9 @@ { &vop_putpages_desc, (vop_t *) nwfs_putpages }, { &vop_ioctl_desc, (vop_t *) nwfs_ioctl }, { &vop_inactive_desc, (vop_t *) nwfs_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_link_desc, (vop_t *) nwfs_link }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_lookup_desc, (vop_t *) nwfs_lookup }, { &vop_mkdir_desc, (vop_t *) nwfs_mkdir }, { &vop_mknod_desc, (vop_t *) nwfs_mknod }, Index: fs/pseudofs/pseudofs_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/pseudofs/pseudofs_vnops.c,v retrieving revision 1.29 diff -u -r1.29 pseudofs_vnops.c --- fs/pseudofs/pseudofs_vnops.c 8 Jul 2002 01:50:14 -0000 1.29 +++ fs/pseudofs/pseudofs_vnops.c 27 Jul 2002 19:12:22 -0000 @@ -829,7 +829,7 @@ { &vop_write_desc, (vop_t *)pfs_write }, { &vop_lock_desc, (vop_t *)vop_stdlock }, { &vop_unlock_desc, (vop_t *)vop_stdunlock }, - { &vop_islocked_desc, (vop_t *)vop_stdislocked}, + { &vop_locktest_desc, (vop_t *)vop_stdlocktest}, /* XXX I've probably forgotten a few that need vop_eopnotsupp */ { NULL, (vop_t *)NULL } }; Index: fs/smbfs/smbfs_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/smbfs/smbfs_vnops.c,v retrieving revision 1.18 diff -u -r1.18 smbfs_vnops.c --- fs/smbfs/smbfs_vnops.c 13 Apr 2002 15:33:26 -0000 1.18 +++ fs/smbfs/smbfs_vnops.c 27 Apr 2002 16:43:19 -0000 @@ -99,9 +99,9 @@ { &vop_getpages_desc, (vop_t *) smbfs_getpages }, { &vop_inactive_desc, (vop_t *) smbfs_inactive }, { &vop_ioctl_desc, (vop_t *) smbfs_ioctl }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_link_desc, (vop_t *) smbfs_link }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_lookup_desc, (vop_t *) smbfs_lookup }, { &vop_mkdir_desc, (vop_t *) smbfs_mkdir }, { &vop_mknod_desc, (vop_t *) smbfs_mknod }, Index: fs/specfs/spec_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/specfs/spec_vnops.c,v retrieving revision 1.172 diff -u -r1.172 spec_vnops.c --- fs/specfs/spec_vnops.c 27 Jul 2002 05:14:59 -0000 1.172 +++ fs/specfs/spec_vnops.c 27 Jul 2002 19:14:56 -0000 @@ -106,7 +106,7 @@ { &vop_write_desc, (vop_t *) spec_write }, { &vop_lock_desc, (vop_t *) vop_nolock }, { &vop_unlock_desc, (vop_t *) vop_nounlock }, - { &vop_islocked_desc, (vop_t *) vop_noislocked }, + { &vop_locktest_desc, (vop_t *) vop_nolocktest }, { NULL, NULL } }; static struct vnodeopv_desc spec_vnodeop_opv_desc = Index: fs/udf/udf_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/udf/udf_vnops.c,v retrieving revision 1.7 diff -u -r1.7 udf_vnops.c --- fs/udf/udf_vnops.c 16 May 2002 19:22:39 -0000 1.7 +++ fs/udf/udf_vnops.c 17 May 2002 00:52:51 -0000 @@ -73,8 +73,8 @@ { &vop_cachedlookup_desc, (vop_t *) udf_lookup }, { &vop_getattr_desc, (vop_t *) udf_getattr }, { &vop_ioctl_desc, (vop_t *) udf_ioctl }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_lookup_desc, (vop_t *) vfs_cache_lookup }, { &vop_pathconf_desc, (vop_t *) udf_pathconf }, { &vop_print_desc, (vop_t *) udf_print }, Index: fs/unionfs/union_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/fs/unionfs/union_vnops.c,v retrieving revision 1.88 diff -u -r1.88 union_vnops.c --- fs/unionfs/union_vnops.c 19 Mar 2002 22:20:14 -0000 1.88 +++ fs/unionfs/union_vnops.c 27 Apr 2002 16:44:16 -0000 @@ -1927,10 +1927,10 @@ { &vop_getvobject_desc, (vop_t *) union_getvobject }, { &vop_inactive_desc, (vop_t *) union_inactive }, { &vop_ioctl_desc, (vop_t *) union_ioctl }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lease_desc, (vop_t *) union_lease }, { &vop_link_desc, (vop_t *) union_link }, { &vop_lock_desc, (vop_t *) union_lock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_lookup_desc, (vop_t *) union_lookup }, { &vop_mkdir_desc, (vop_t *) union_mkdir }, { &vop_mknod_desc, (vop_t *) union_mknod }, Index: gnu/ext2fs/ext2_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/gnu/ext2fs/ext2_vnops.c,v retrieving revision 1.65 diff -u -r1.65 ext2_vnops.c --- gnu/ext2fs/ext2_vnops.c 18 May 2002 19:12:38 -0000 1.65 +++ gnu/ext2fs/ext2_vnops.c 18 May 2002 21:17:56 -0000 @@ -136,9 +136,9 @@ { &vop_getattr_desc, (vop_t *) ext2_getattr }, { &vop_getwritemount_desc, (vop_t *) vop_stdgetwritemount }, { &vop_inactive_desc, (vop_t *) ext2_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_link_desc, (vop_t *) ext2_link }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_lookup_desc, (vop_t *) vfs_cache_lookup }, { &vop_mkdir_desc, (vop_t *) ext2_mkdir }, { &vop_mknod_desc, (vop_t *) ext2_mknod }, @@ -173,8 +173,8 @@ { &vop_fsync_desc, (vop_t *) ext2_fsync }, { &vop_getattr_desc, (vop_t *) ext2_getattr }, { &vop_inactive_desc, (vop_t *) ext2_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_print_desc, (vop_t *) ext2_print }, { &vop_read_desc, (vop_t *) ext2spec_read }, { &vop_reclaim_desc, (vop_t *) ext2_reclaim }, @@ -194,9 +194,9 @@ { &vop_fsync_desc, (vop_t *) ext2_fsync }, { &vop_getattr_desc, (vop_t *) ext2_getattr }, { &vop_inactive_desc, (vop_t *) ext2_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_kqfilter_desc, (vop_t *) ext2fifo_kqfilter }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_print_desc, (vop_t *) ext2_print }, { &vop_read_desc, (vop_t *) ext2fifo_read }, { &vop_reclaim_desc, (vop_t *) ext2_reclaim }, Index: isofs/cd9660/cd9660_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/isofs/cd9660/cd9660_vnops.c,v retrieving revision 1.77 diff -u -r1.77 cd9660_vnops.c --- isofs/cd9660/cd9660_vnops.c 22 May 2002 08:50:18 -0000 1.77 +++ isofs/cd9660/cd9660_vnops.c 25 May 2002 20:54:26 -0000 @@ -802,8 +802,8 @@ { &vop_getattr_desc, (vop_t *) cd9660_getattr }, { &vop_inactive_desc, (vop_t *) cd9660_inactive }, { &vop_ioctl_desc, (vop_t *) cd9660_ioctl }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_lookup_desc, (vop_t *) vfs_cache_lookup }, { &vop_pathconf_desc, (vop_t *) cd9660_pathconf }, { &vop_print_desc, (vop_t *) cd9660_print }, @@ -829,8 +829,8 @@ { &vop_access_desc, (vop_t *) cd9660_access }, { &vop_getattr_desc, (vop_t *) cd9660_getattr }, { &vop_inactive_desc, (vop_t *) cd9660_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_print_desc, (vop_t *) cd9660_print }, { &vop_reclaim_desc, (vop_t *) cd9660_reclaim }, { &vop_setattr_desc, (vop_t *) cd9660_setattr }, @@ -847,8 +847,8 @@ { &vop_access_desc, (vop_t *) cd9660_access }, { &vop_getattr_desc, (vop_t *) cd9660_getattr }, { &vop_inactive_desc, (vop_t *) cd9660_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_print_desc, (vop_t *) cd9660_print }, { &vop_reclaim_desc, (vop_t *) cd9660_reclaim }, { &vop_setattr_desc, (vop_t *) cd9660_setattr }, Index: kern/vfs_cache.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/kern/vfs_cache.c,v retrieving revision 1.73 diff -u -r1.73 vfs_cache.c --- kern/vfs_cache.c 28 Jun 2002 23:17:36 -0000 1.73 +++ kern/vfs_cache.c 1 Jul 2002 14:19:51 -0000 @@ -575,19 +575,15 @@ */ error = VOP_CACHEDLOOKUP(dvp, vpp, cnp); if (!error) { - int flock; - - flock = VOP_ISLOCKED(*vpp, td); - if (flock != LK_EXCLUSIVE) { - if (flock == 0) { - if ((flags & ISLASTCN) && - (flags & LOCKSHARED)) - VOP_LOCK(*vpp, LK_SHARED, td); - else - VOP_LOCK(*vpp, LK_EXCLUSIVE, td); - } - } else if ((flags & ISLASTCN) && (flags & LOCKSHARED)) + if (VOP_LOCKTEST(*vpp, VLKTEST_UNLOCKED, td)) { + if ((flags & ISLASTCN) && (flags & LOCKSHARED)) + VOP_LOCK(*vpp, LK_SHARED, td); + else + VOP_LOCK(*vpp, LK_EXCLUSIVE, td); + } else if ((flags & ISLASTCN) && (flags & LOCKSHARED) && + VOP_LOCKTEST(*vpp, VLKTEST_XLOCKED, td)) { VOP_LOCK(*vpp, LK_DOWNGRADE, td); + } } return (error); } @@ -658,18 +654,15 @@ error = VOP_CACHEDLOOKUP(dvp, vpp, cnp); if (!error) { - int flock = 0; - - flock = VOP_ISLOCKED(*vpp, td); - if (flock != LK_EXCLUSIVE) { - if (flock == 0) { - if ((flags & ISLASTCN) && (flags & LOCKSHARED)) - VOP_LOCK(*vpp, LK_SHARED, td); - else - VOP_LOCK(*vpp, LK_EXCLUSIVE, td); - } - } else if ((flags & ISLASTCN) && (flags & LOCKSHARED)) + if (VOP_LOCKTEST(*vpp, VLKTEST_UNLOCKED, td)) { + if ((flags & ISLASTCN) && (flags & LOCKSHARED)) + VOP_LOCK(*vpp, LK_SHARED, td); + else + VOP_LOCK(*vpp, LK_EXCLUSIVE, td); + } else if ((flags & ISLASTCN) && (flags & LOCKSHARED) && + VOP_LOCKTEST(*vpp, VLKTEST_XLOCKED, td)) { VOP_LOCK(*vpp, LK_DOWNGRADE, td); + } } return (error); Index: kern/vfs_default.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/kern/vfs_default.c,v retrieving revision 1.63 diff -u -r1.63 vfs_default.c --- kern/vfs_default.c 27 Jul 2002 05:16:20 -0000 1.63 +++ kern/vfs_default.c 27 Jul 2002 18:19:31 -0000 @@ -88,9 +88,9 @@ { &vop_getvobject_desc, (vop_t *) vop_stdgetvobject }, { &vop_inactive_desc, (vop_t *) vop_stdinactive }, { &vop_ioctl_desc, (vop_t *) vop_enotty }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lease_desc, (vop_t *) vop_null }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_lookup_desc, (vop_t *) vop_nolookup }, { &vop_open_desc, (vop_t *) vop_null }, { &vop_pathconf_desc, (vop_t *) vop_einval }, @@ -263,7 +263,7 @@ } /* - * Standard lock, unlock and islocked functions. + * Standard lock, unlock and locktest functions. */ int vop_stdlock(ap) @@ -300,14 +300,28 @@ /* See above. */ int -vop_stdislocked(ap) - struct vop_islocked_args /* { +vop_stdlocktest(ap) + struct vop_locktest_args /* { struct vnode *a_vp; + int a_flags; struct thread *a_td; } */ *ap; { + int status; - return (lockstatus(&ap->a_vp->v_lock, ap->a_td)); + status = lockstatus(&ap->a_vp->v_lock, ap->a_td); + switch (ap->a_flags) { + case VLKTEST_UNLOCKED: + return (status == 0); + case VLKTEST_LOCKED: + return (status != 0); + case VLKTEST_XLOCKED: + return (status == LK_EXCLUSIVE); + case VLKTEST_SLOCKED: + return (status == LK_SHARED); + default: + panic("vop_stdlocktest: bad flags %d", ap->a_flags); + } } /* Mark the vnode inactive */ @@ -401,14 +415,6 @@ vnflags = LK_DRAIN; break; case LK_EXCLUSIVE: -#ifdef DEBUG_VFS_LOCKS - /* - * Normally, we use shared locks here, but that confuses - * the locking assertions. - */ - vnflags = LK_EXCLUSIVE; - break; -#endif case LK_SHARED: vnflags = LK_SHARED; break; @@ -430,6 +436,30 @@ #endif } +/* Test the vnode lock status for shared locks. */ +int +vop_sharedlocktest(ap) + struct vop_locktest_args /* { + struct vnode *a_vp; + int a_flags; + struct thread *a_td; + } */ *ap; +{ + int status; + + status = lockstatus(&ap->a_vp->v_lock, ap->a_td); + switch (ap->a_flags) { + case VLKTEST_UNLOCKED: + return (status == 0); + case VLKTEST_LOCKED: + case VLKTEST_XLOCKED: + case VLKTEST_SLOCKED: + return (status != 0); + default: + panic("vop_sharedlocktest: bad flags %d", ap->a_flags); + } +} + /* * Stubs to use when there is no locking to be done on the underlying object. * A minimal shared lock is necessary to ensure that the underlying object @@ -514,17 +544,19 @@ } /* - * Return whether or not the node is in use. + * Test the lock status of the node. */ int -vop_noislocked(ap) - struct vop_islocked_args /* { +vop_nolocktest(ap) + struct vop_locktest_args /* { struct vnode *a_vp; + int a_flags; struct thread *a_td; } */ *ap; { - return (0); + /* All tests return true to satisfy asserts. */ + return (1); } /* Index: kern/vfs_subr.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/kern/vfs_subr.c,v retrieving revision 1.382 diff -u -r1.382 vfs_subr.c --- kern/vfs_subr.c 29 Jul 2002 06:26:55 -0000 1.382 +++ kern/vfs_subr.c 29 Jul 2002 18:23:46 -0000 @@ -700,7 +700,8 @@ for (count = 0; count < freevnodes; count++) { vp = TAILQ_FIRST(&vnode_free_list); - if (vp == NULL || vp->v_usecount) + if (vp == NULL || vp->v_usecount || + (vp->v_flag & VINACTIVE)) panic("getnewvnode: free vnode isn't"); TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); @@ -1476,7 +1477,7 @@ splx(s); while ((vp = LIST_FIRST(slp)) != NULL) { - if (VOP_ISLOCKED(vp, NULL) == 0 && + if (VOP_LOCKTEST(vp, VLKTEST_UNLOCKED, NULL) && vn_start_write(vp, &mp, V_NOWAIT) == 0) { vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); (void) VOP_FSYNC(vp, td->td_ucred, MNT_LAZY, td); @@ -1756,7 +1757,7 @@ ovp->v_vnlock = &ovp->v_lock; ops = ovp->v_op; ovp->v_op = nvp->v_op; - if (VOP_ISLOCKED(nvp, curthread)) { + if (VOP_LOCKTEST(nvp, VLKTEST_LOCKED, curthread)) { VOP_UNLOCK(nvp, 0, curthread); vn_lock(ovp, LK_EXCLUSIVE | LK_RETRY, curthread); } @@ -1876,8 +1877,8 @@ KASSERT(vp->v_writecount < vp->v_usecount || vp->v_usecount < 1, ("vrele: missed vn_close")); - if (vp->v_usecount > 1) { - + if (vp->v_usecount > 1 || + ((vp->v_flag & VINACTIVE) && vp->v_usecount == 1)) { vp->v_usecount--; mtx_unlock(&vp->v_interlock); @@ -1886,19 +1887,21 @@ if (vp->v_usecount == 1) { vp->v_usecount--; + KASSERT(VOP_LOCKTEST(vp, VLKTEST_UNLOCKED, td), + ("vrele: locked vnode on last ref")); /* - * We must call VOP_INACTIVE with the node locked. - * If we are doing a vput, the node is already locked, - * but, in the case of vrele, we must explicitly lock - * the vnode before calling VOP_INACTIVE. + * We must call VOP_INACTIVE with the node locked. Mark + * as VINACTIVE to avoid recursion. */ - if (vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, td) == 0) - VOP_INACTIVE(vp, td); + vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, td); + vp->v_flag |= VINACTIVE; + VOP_INACTIVE(vp, td); + KASSERT(vp->v_flag & VINACTIVE, ("vrele: lost VINACTIVE")); + vp->v_flag &= ~VINACTIVE; if (VSHOULDFREE(vp)) vfree(vp); else vlruvp(vp); - } else { #ifdef DIAGNOSTIC vprint("vrele: negative ref count", vp); @@ -1926,8 +1929,11 @@ /* Skip this v_writecount check if we're going to panic below. */ KASSERT(vp->v_writecount < vp->v_usecount || vp->v_usecount < 1, ("vput: missed vn_close")); + KASSERT(VOP_LOCKTEST(vp, VLKTEST_LOCKED, td), + ("vput: vnode %p not locked", vp)); - if (vp->v_usecount > 1) { + if (vp->v_usecount > 1 || + ((vp->v_flag & VINACTIVE) && vp->v_usecount == 1)) { vp->v_usecount--; VOP_UNLOCK(vp, LK_INTERLOCK, td); return; @@ -1936,17 +1942,19 @@ if (vp->v_usecount == 1) { vp->v_usecount--; /* - * We must call VOP_INACTIVE with the node locked. - * If we are doing a vput, the node is already locked, - * so we just need to release the vnode mutex. + * We must call VOP_INACTIVE with the node locked, so + * we just need to release the vnode mutex. Mark as + * as VINACTIVE to avoid recursion. */ + vp->v_flag |= VINACTIVE; mtx_unlock(&vp->v_interlock); VOP_INACTIVE(vp, td); + KASSERT(vp->v_flag & VINACTIVE, ("vput: lost VINACTIVE")); + vp->v_flag &= ~VINACTIVE; if (VSHOULDFREE(vp)) vfree(vp); else vlruvp(vp); - } else { #ifdef DIAGNOSTIC vprint("vput: negative ref count", vp); @@ -2213,12 +2221,15 @@ * deactivated before being reclaimed. Note that the * VOP_INACTIVE will unlock the vnode. */ - if (active) { - if (flags & DOCLOSE) - VOP_CLOSE(vp, FNONBLOCK, NOCRED, td); + if (active && (flags & DOCLOSE)) + VOP_CLOSE(vp, FNONBLOCK, NOCRED, td); + if (active && (vp->v_flag & VINACTIVE) == 0) { + vp->v_flag |= VINACTIVE; if (vn_lock(vp, LK_EXCLUSIVE | LK_NOWAIT, td) != 0) panic("vclean: cannot relock."); VOP_INACTIVE(vp, td); + KASSERT(vp->v_flag & VINACTIVE, ("vclean: lost VINACTIVE")); + vp->v_flag &= ~VINACTIVE; } /* @@ -2234,12 +2245,8 @@ */ mtx_lock(&vp->v_interlock); if (--vp->v_usecount <= 0) { -#ifdef DIAGNOSTIC - if (vp->v_usecount < 0 || vp->v_writecount != 0) { - vprint("vclean: bad ref count", vp); - panic("vclean: ref cnt"); - } -#endif + KASSERT(vp->v_usecount == 0 && vp->v_writecount == 0, + ("vclean: ref cnt")); vfree(vp); } mtx_unlock(&vp->v_interlock); @@ -2249,7 +2256,7 @@ vp->v_vnlock = NULL; lockdestroy(&vp->v_lock); - if (VSHOULDFREE(vp)) + if ((vp->v_flag & VDOOMED) == 0 && VSHOULDFREE(vp)) vfree(vp); /* @@ -2539,7 +2546,8 @@ } mtx_lock(&mntvnode_mtx); TAILQ_FOREACH(vp, &mp->mnt_nvnodelist, v_nmntvnodes) { - if (VOP_ISLOCKED(vp, NULL)) + /* Use !unlocked to avoid printing nolock vnodes. */ + if (!VOP_LOCKTEST(vp, VLKTEST_UNLOCKED, NULL)) vprint((char *)0, vp); } mtx_unlock(&mntvnode_mtx); @@ -2775,8 +2783,8 @@ if (vp->v_flag & VNOSYNC) /* unlinked, skip it */ continue; - if ((vp->v_flag & VOBJDIRTY) && - (flags == MNT_WAIT || VOP_ISLOCKED(vp, NULL) == 0)) { + if ((vp->v_flag & VOBJDIRTY) && (flags == MNT_WAIT || + VOP_LOCKTEST(vp, VLKTEST_UNLOCKED, NULL))) { mtx_unlock(&mntvnode_mtx); if (!vget(vp, LK_EXCLUSIVE | LK_RETRY | LK_NOOBJ, curthread)) { @@ -2971,7 +2979,7 @@ { &vop_lock_desc, (vop_t *) vop_stdlock }, /* lock */ { &vop_unlock_desc, (vop_t *) vop_stdunlock }, /* unlock */ { &vop_print_desc, (vop_t *) sync_print }, /* print */ - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, /* islocked */ + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, /* islocked */ { NULL, NULL } }; static struct vnodeopv_desc sync_vnodeop_opv_desc = Index: kern/vfs_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/kern/vfs_vnops.c,v retrieving revision 1.153 diff -u -r1.153 vfs_vnops.c --- kern/vfs_vnops.c 22 Jul 2002 12:51:06 -0000 1.153 +++ kern/vfs_vnops.c 27 Jul 2002 18:13:13 -0000 @@ -216,8 +216,6 @@ */ if (vn_canvmio(vp) == TRUE) { #ifdef LOOKUP_SHARED - int flock; - if (!exclusive && VOP_GETVOBJECT(vp, NULL) != 0) VOP_LOCK(vp, LK_UPGRADE, td); /* @@ -239,8 +237,7 @@ return (error); } #ifdef LOOKUP_SHARED - flock = VOP_ISLOCKED(vp, td); - if (!exclusive && flock == LK_EXCLUSIVE) + if (!exclusive && VOP_LOCKTEST(vp, VLKTEST_XLOCKED, td)) VOP_LOCK(vp, LK_DOWNGRADE, td); #endif } Index: kern/vnode_if.src =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/kern/vnode_if.src,v retrieving revision 1.52 diff -u -r1.52 vnode_if.src --- kern/vnode_if.src 9 Jul 2002 19:55:06 -0000 1.52 +++ kern/vnode_if.src 17 Jul 2002 16:47:52 -0000 @@ -55,10 +55,11 @@ # # -#% islocked vp = = = +#% locktest vp = = = # -vop_islocked { +vop_locktest { IN struct vnode *vp; + IN int flags; IN struct thread *td; }; Index: nfsclient/nfs_node.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/nfsclient/nfs_node.c,v retrieving revision 1.55 diff -u -r1.55 nfs_node.c --- nfsclient/nfs_node.c 11 Jul 2002 17:54:58 -0000 1.55 +++ nfsclient/nfs_node.c 17 Jul 2002 16:48:36 -0000 @@ -289,21 +289,7 @@ } else sp = NULL; if (sp) { - /* - * We need a reference to keep the vnode from being - * recycled by getnewvnode while we do the I/O - * associated with discarding the buffers unless we - * are being forcibly unmounted in which case we already - * have our own reference. - */ - if (ap->a_vp->v_usecount > 0) - (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, td, 1); - else if (vget(ap->a_vp, 0, td)) - panic("nfs_inactive: lost vnode"); - else { - (void) nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, td, 1); - vrele(ap->a_vp); - } + (void)nfs_vinvalbuf(ap->a_vp, 0, sp->s_cred, td, 1); /* * Remove the silly file that was rename'd earlier */ Index: nfsclient/nfs_vfsops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/nfsclient/nfs_vfsops.c,v retrieving revision 1.119 diff -u -r1.119 nfs_vfsops.c --- nfsclient/nfs_vfsops.c 11 Jul 2002 17:54:58 -0000 1.119 +++ nfsclient/nfs_vfsops.c 17 Jul 2002 16:48:36 -0000 @@ -983,8 +983,8 @@ vnp = TAILQ_NEXT(vp, v_nmntvnodes); mtx_unlock(&mntvnode_mtx); mtx_lock(&vp->v_interlock); - if (VOP_ISLOCKED(vp, NULL) || TAILQ_EMPTY(&vp->v_dirtyblkhd) || - waitfor == MNT_LAZY) { + if (VOP_LOCKTEST(vp, VLKTEST_LOCKED, NULL) || + TAILQ_EMPTY(&vp->v_dirtyblkhd) || waitfor == MNT_LAZY) { mtx_unlock(&vp->v_interlock); mtx_lock(&mntvnode_mtx); continue; Index: nfsclient/nfs_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/nfsclient/nfs_vnops.c,v retrieving revision 1.184 diff -u -r1.184 nfs_vnops.c --- nfsclient/nfs_vnops.c 11 Jul 2002 17:54:58 -0000 1.184 +++ nfsclient/nfs_vnops.c 17 Jul 2002 16:48:36 -0000 @@ -147,10 +147,10 @@ { &vop_getpages_desc, (vop_t *) nfs_getpages }, { &vop_putpages_desc, (vop_t *) nfs_putpages }, { &vop_inactive_desc, (vop_t *) nfs_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lease_desc, (vop_t *) vop_null }, { &vop_link_desc, (vop_t *) nfs_link }, { &vop_lock_desc, (vop_t *) vop_sharedlock }, + { &vop_locktest_desc, (vop_t *) vop_sharedlocktest }, { &vop_lookup_desc, (vop_t *) nfs_lookup }, { &vop_mkdir_desc, (vop_t *) nfs_mkdir }, { &vop_mknod_desc, (vop_t *) nfs_mknod }, @@ -184,9 +184,9 @@ { &vop_close_desc, (vop_t *) nfsspec_close }, { &vop_fsync_desc, (vop_t *) nfs_fsync }, { &vop_getattr_desc, (vop_t *) nfs_getattr }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_inactive_desc, (vop_t *) nfs_inactive }, { &vop_lock_desc, (vop_t *) vop_sharedlock }, + { &vop_locktest_desc, (vop_t *) vop_sharedlocktest }, { &vop_print_desc, (vop_t *) nfs_print }, { &vop_read_desc, (vop_t *) nfsspec_read }, { &vop_reclaim_desc, (vop_t *) nfs_reclaim }, @@ -207,8 +207,8 @@ { &vop_fsync_desc, (vop_t *) nfs_fsync }, { &vop_getattr_desc, (vop_t *) nfs_getattr }, { &vop_inactive_desc, (vop_t *) nfs_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lock_desc, (vop_t *) vop_sharedlock }, + { &vop_locktest_desc, (vop_t *) vop_sharedlocktest }, { &vop_print_desc, (vop_t *) nfs_print }, { &vop_read_desc, (vop_t *) nfsfifo_read }, { &vop_reclaim_desc, (vop_t *) nfs_reclaim }, Index: security/lomac/lomacfs_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/security/lomac/lomacfs_vnops.c,v retrieving revision 1.5 diff -u -r1.5 lomacfs_vnops.c --- security/lomac/lomacfs_vnops.c 16 May 2002 21:28:24 -0000 1.5 +++ security/lomac/lomacfs_vnops.c 17 May 2002 00:54:20 -0000 @@ -259,17 +259,30 @@ } static int -lomacfs_islocked( - struct vop_islocked_args /* { +lomacfs_locktest(ap) + struct vop_locktest_args /* { struct vnode *a_vp; + int a_flags; struct thread *a_td; - } */ *ap -) { - + } */ *ap; +{ struct vnode *vp = ap->a_vp; struct thread *td = ap->a_td; + int status; - return (lockstatus(&vp->v_lock, td)); + status = lockstatus(&vp->v_lock, td); + switch (ap->a_flags) { + case VLKTEST_UNLOCKED: + return (status == 0); + case VLKTEST_LOCKED: + return (status != 0); + case VLKTEST_XLOCKED: + return (status == LK_EXCLUSIVE); + case VLKTEST_SLOCKED: + return (status == LK_SHARED); + default: + panic("lomacfs_locktest: bad flags %d", ap->a_flags); + } } static int @@ -1099,7 +1112,7 @@ { &vop_print_desc, (vop_t *)lomacfs_print }, { &vop_lock_desc, (vop_t *)lomacfs_lock }, { &vop_unlock_desc, (vop_t *)lomacfs_unlock }, - { &vop_islocked_desc, (vop_t *)lomacfs_islocked }, + { &vop_locktest_desc, (vop_t *)lomacfs_locktest }, { &vop_lookup_desc, (vop_t *)lomacfs_lookup }, { &vop_setattr_desc, (vop_t *)lomacfs_setattr }, { &vop_getattr_desc, (vop_t *)lomacfs_getattr }, Index: sys/vnode.h =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/sys/vnode.h,v retrieving revision 1.194 diff -u -r1.194 vnode.h --- sys/vnode.h 29 Jul 2002 07:45:57 -0000 1.194 +++ sys/vnode.h 29 Jul 2002 18:51:32 -0000 @@ -175,7 +175,6 @@ #define VXWANT 0x00200 /* thread is waiting for vnode */ #define VBWAIT 0x00400 /* waiting for output to complete */ #define VNOSYNC 0x01000 /* unlinked, stop syncing */ -/* open for business 0x01000 */ #define VOBJBUF 0x02000 /* Allocate buffers in VM object */ #define VCOPYONWRITE 0x04000 /* vnode is doing copy-on-write */ #define VAGE 0x08000 /* Insert vnode at head of free list */ @@ -187,6 +186,7 @@ #define VONWORKLST 0x200000 /* On syncer work-list */ #define VMOUNT 0x400000 /* Mount in progress */ #define VOBJDIRTY 0x800000 /* object might be dirty */ +#define VINACTIVE 0x1000000 /* VOP_INACTIVE is in progress */ /* * Vnode attributes. A field value of VNOVAL represents a field whose value @@ -293,6 +293,12 @@ #define V_NOWAIT 0x0002 /* vn_start_write: don't sleep for suspend */ #define V_XSLEEP 0x0004 /* vn_start_write: just return after sleep */ +/* Flags for vop_locktest. */ +#define VLKTEST_UNLOCKED 0x0001 /* vnode is unlocked. */ +#define VLKTEST_LOCKED 0x0002 /* vnode is locked. */ +#define VLKTEST_XLOCKED 0x0004 /* vnode is exclusively locked. */ +#define VLKTEST_SLOCKED 0x0008 /* vnode is share locked. */ + #define VREF(vp) vref(vp) @@ -328,13 +334,13 @@ extern void (*lease_updatetime)(int deltat); #define VSHOULDFREE(vp) \ - (!((vp)->v_flag & (VFREE|VDOOMED)) && \ + (!((vp)->v_flag & (VFREE|VDOOMED|VINACTIVE)) && \ !(vp)->v_holdcnt && !(vp)->v_usecount && \ (!(vp)->v_object || \ !((vp)->v_object->ref_count || (vp)->v_object->resident_page_count))) #define VMIGHTFREE(vp) \ - (!((vp)->v_flag & (VFREE|VDOOMED|VXLOCK)) && \ + (!((vp)->v_flag & (VFREE|VDOOMED|VINACTIVE|VXLOCK)) && \ LIST_EMPTY(&(vp)->v_cache_src) && !(vp)->v_usecount) #define VSHOULDBUSY(vp) \ @@ -681,18 +687,19 @@ int vop_stdgetwritemount(struct vop_getwritemount_args *); int vop_stdgetpages(struct vop_getpages_args *); int vop_stdinactive(struct vop_inactive_args *); -int vop_stdislocked(struct vop_islocked_args *); int vop_stdlock(struct vop_lock_args *); +int vop_stdlocktest(struct vop_locktest_args *); int vop_stdputpages(struct vop_putpages_args *); int vop_stdunlock(struct vop_unlock_args *); -int vop_noislocked(struct vop_islocked_args *); int vop_nolock(struct vop_lock_args *); +int vop_nolocktest(struct vop_locktest_args *); int vop_nopoll(struct vop_poll_args *); int vop_nounlock(struct vop_unlock_args *); int vop_stdpathconf(struct vop_pathconf_args *); int vop_stdpoll(struct vop_poll_args *); int vop_revoke(struct vop_revoke_args *); int vop_sharedlock(struct vop_lock_args *); +int vop_sharedlocktest(struct vop_locktest_args *); int vop_eopnotsupp(struct vop_generic_args *ap); int vop_ebadf(struct vop_generic_args *ap); int vop_einval(struct vop_generic_args *ap); Index: ufs/ffs/ffs_softdep.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/ufs/ffs/ffs_softdep.c,v retrieving revision 1.121 diff -u -r1.121 ffs_softdep.c --- ufs/ffs/ffs_softdep.c 20 Jul 2002 01:09:35 -0000 1.121 +++ ufs/ffs/ffs_softdep.c 27 Jul 2002 18:13:57 -0000 @@ -5141,10 +5141,10 @@ * way to accomplish this is to sync the entire filesystem (luckily * this happens rarely). */ - if (vn_isdisk(vp, NULL) && - vp->v_rdev->si_mountpoint && !VOP_ISLOCKED(vp, NULL) && + if (vn_isdisk(vp, NULL) && vp->v_rdev->si_mountpoint && + VOP_LOCKTEST(vp, VLKTEST_UNLOCKED, NULL) && (error = VFS_SYNC(vp->v_rdev->si_mountpoint, MNT_WAIT, ap->a_cred, - ap->a_td)) != 0) + ap->a_td)) != 0) return (error); return (0); } Index: ufs/ufs/ufs_vnops.c =================================================================== RCS file: /dump/FreeBSD-CVS/src/sys/ufs/ufs/ufs_vnops.c,v retrieving revision 1.200 diff -u -r1.200 ufs_vnops.c --- ufs/ufs/ufs_vnops.c 19 Jul 2002 07:29:39 -0000 1.200 +++ ufs/ufs/ufs_vnops.c 27 Jul 2002 18:13:58 -0000 @@ -2628,9 +2633,9 @@ { &vop_create_desc, (vop_t *) ufs_create }, { &vop_getattr_desc, (vop_t *) ufs_getattr }, { &vop_inactive_desc, (vop_t *) ufs_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_link_desc, (vop_t *) ufs_link }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_lookup_desc, (vop_t *) vfs_cache_lookup }, { &vop_mkdir_desc, (vop_t *) ufs_mkdir }, { &vop_mknod_desc, (vop_t *) ufs_mknod }, @@ -2673,8 +2678,8 @@ { &vop_close_desc, (vop_t *) ufsspec_close }, { &vop_getattr_desc, (vop_t *) ufs_getattr }, { &vop_inactive_desc, (vop_t *) ufs_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_print_desc, (vop_t *) ufs_print }, { &vop_read_desc, (vop_t *) ufsspec_read }, { &vop_reclaim_desc, (vop_t *) ufs_reclaim }, @@ -2703,9 +2708,9 @@ { &vop_close_desc, (vop_t *) ufsfifo_close }, { &vop_getattr_desc, (vop_t *) ufs_getattr }, { &vop_inactive_desc, (vop_t *) ufs_inactive }, - { &vop_islocked_desc, (vop_t *) vop_stdislocked }, { &vop_kqfilter_desc, (vop_t *) ufsfifo_kqfilter }, { &vop_lock_desc, (vop_t *) vop_stdlock }, + { &vop_locktest_desc, (vop_t *) vop_stdlocktest }, { &vop_print_desc, (vop_t *) ufs_print }, { &vop_read_desc, (vop_t *) ufsfifo_read }, { &vop_reclaim_desc, (vop_t *) ufs_reclaim },