d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Regularize the vop_stdlock'ing protocol across all the filesystems

Browse Source 
that use it. Specifically, vop_stdlock uses the lock pointed to by
vp->v_vnlock. By default, getnewvnode sets up vp->v_vnlock to
reference vp->v_lock. Filesystems that wish to use the default
do not need to allocate a lock at the front of their node structure
(as some still did) or do a lockinit. They can simply start using
vn_lock/VOP_UNLOCK. Filesystems that wish to manage their own locks,
but still use the vop_stdlock functions (such as nullfs) can simply
replace vp->v_vnlock with a pointer to the lock that they wish to
have used for the vnode. Such filesystems are responsible for
setting the vp->v_vnlock back to the default in their vop_reclaim
routine (e.g., vp->v_vnlock = &vp->v_lock).

In theory, this set of changes cleans up the existing filesystem
lock interface and should have no function change to the existing
locking scheme.

Sponsored by:	DARPA & NAI Labs.
This commit is contained in:
Kirk McKusick 2002-10-14 03:20:36 +00:00
parent aa23e9c476
commit a5b65058d5
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=105077
33 changed files with 30 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
sys/fs/cd9660/cd9660_node.c
View File

@ -143,7 +143,7 @@ cd9660_ihashins(ip)
*ipp = ip;
mtx_unlock(&cd9660_ihash_mtx);
lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, curthread);
vn_lock(ITOV(ip), LK_EXCLUSIVE | LK_RETRY, curthread);
}
/*
@ -223,7 +223,6 @@ cd9660_reclaim(ap)
vrele(ip->i_devvp);
ip->i_devvp = 0;
}
lockdestroy(&ip->i_vnode->v_lock);
FREE(vp->v_data, M_ISOFSNODE);
vp->v_data = NULL;
return (0);

5
sys/fs/cd9660/cd9660_vfsops.c
View File

@ -714,11 +714,6 @@ cd9660_vget_internal(mp, ino, flags, vpp, relocated, isodir)
}
MALLOC(ip, struct iso_node *, sizeof(struct iso_node), M_ISOFSNODE,
M_WAITOK | M_ZERO);
lockinit(&vp->v_lock, PINOD, "isonode", 0, 0);
/*
* ISOFS uses stdlock and can share lock structure
*/
vp->v_vnlock = &vp->v_lock;
vp->v_data = ip;
ip->i_vnode = vp;
ip->i_dev = dev;

1
sys/fs/hpfs/hpfs.h
View File

@ -333,7 +333,6 @@ struct hpfsmount {
#define H_PARCHANGE 0x0008 /* parent node date was changed */
#define H_INVAL 0x0010 /* Invalid node */
struct hpfsnode {
struct lock h_lock; /* Must be first, for std vops */
struct mtx h_interlock;
LIST_ENTRY(hpfsnode) h_hash;

1
sys/fs/hpfs/hpfs_vfsops.c
View File

@ -512,7 +512,6 @@ hpfs_vget(
mtx_init(&hp->h_interlock, "hpfsnode interlock", NULL, MTX_DEF);
lockinit(&hp->h_lock, PINOD, "hpnode", VLKTIMEOUT, 0);
hp->h_flag = H_INVAL;
hp->h_vp = vp;

1
sys/fs/hpfs/hpfs_vnops.c
View File

@ -643,7 +643,6 @@ hpfs_reclaim(ap)
hp->h_devvp = NULL;
}
lockdestroy(&hp->h_lock);
mtx_destroy(&hp->h_interlock);
vp->v_data = NULL;

3
sys/fs/msdosfs/msdosfs_denode.c
View File

@ -260,8 +260,6 @@ deget(pmp, dirclust, diroffset, depp)
return error;
}
bzero((caddr_t)ldep, sizeof *ldep);
lockinit(&nvp->v_lock, PINOD, "denode", VLKTIMEOUT, 0);
nvp->v_vnlock = &nvp->v_lock;
nvp->v_data = ldep;
ldep->de_vnode = nvp;
ldep->de_flag = 0;
@ -670,7 +668,6 @@ msdosfs_reclaim(ap)
#if 0 /* XXX */
dep->de_flag = 0;
#endif
lockdestroy(&vp->v_lock);
FREE(dep, M_MSDOSFSNODE);
vp->v_data = NULL;

2
sys/fs/ntfs/ntfs_inode.h
View File

@ -69,8 +69,6 @@ struct ntnode {
#define FN_VALID 0x0002
#define FN_AATTRNAME 0x0004 /* space allocated for f_attrname */
struct fnode {
struct lock f_lock; /* fnode lock >Keep this first< */
LIST_ENTRY(fnode) f_fnlist;
struct vnode *f_vp; /* Associatied vnode */
struct ntnode *f_ip; /* Associated ntnode */

1
sys/fs/ntfs/ntfs_subr.c
View File

@ -778,7 +778,6 @@ ntfs_frele(
FREE(fp->f_attrname, M_TEMP);
if (fp->f_dirblbuf)
FREE(fp->f_dirblbuf, M_NTFSDIR);
lockdestroy(&fp->f_lock);
FREE(fp, M_NTFSFNODE);
ntfs_ntrele(ip);
}

1
sys/fs/ntfs/ntfs_vfsops.c
View File

@ -741,7 +741,6 @@ ntfs_vgetex(
}
dprintf(("ntfs_vget: vnode: %p for ntnode: %d\n", vp,ino));
lockinit(&fp->f_lock, PINOD, "fnode", VLKTIMEOUT, 0);
fp->f_vp = vp;
vp->v_data = fp;
vp->v_type = f_type;

3
sys/fs/nullfs/null_subr.c
View File

@ -226,9 +226,6 @@ null_nodeget(mp, lowervp, vpp)
vp->v_type = lowervp->v_type;
vp->v_data = xp;
/* Though v_lock is inited by getnewvnode(), we want our own wmesg */
lockinit(&vp->v_lock, PVFS, "nunode", VLKTIMEOUT, LK_NOPAUSE);
/*
* From NetBSD:
* Now lock the new node. We rely on the fact that we were passed

1
sys/fs/nullfs/null_vnops.c
View File

@ -758,6 +758,7 @@ null_reclaim(ap)
}
vp->v_data = NULL;
vp->v_vnlock = &vp->v_lock;
FREE(xp, M_NULLFSNODE);
return (0);

2
sys/fs/nwfs/nwfs_node.c
View File

@ -185,7 +185,7 @@ nwfs_allocvp(struct mount *mp, ncpfid fid, struct nw_entry_info *fap,
if (dvp) {
np->n_parent = VTONW(dvp)->n_fid;
}
lockinit(&vp->v_lock, PINOD, "nwnode", VLKTIMEOUT, LK_CANRECURSE);
vp->v_vnlock->lk_flags |= LK_CANRECURSE;
lockmgr(&nwhashlock, LK_EXCLUSIVE, NULL, td);
/*
* Another process can create vnode while we blocked in malloc() or

3
sys/fs/pseudofs/pseudofs_vncache.c
View File

@ -179,8 +179,7 @@ pfs_vncache_alloc(struct mount *mp, struct vnode **vpp,
pvd->pvd_next->pvd_prev = pvd;
pfs_vncache = pvd;
mtx_unlock(&pfs_vncache_mutex);
(*vpp)->v_vnlock = &(*vpp)->v_lock;
lockinit((*vpp)->v_vnlock, PINOD, "pfsnod", VLKTIMEOUT, LK_CANRECURSE);
(*vpp)->v_vnlock->lk_flags |= LK_CANRECURSE;
vn_lock(*vpp, LK_RETRY | LK_EXCLUSIVE, curthread);
return (0);
}

2
sys/fs/smbfs/smbfs_io.c
View File

@ -203,7 +203,7 @@ smbfs_readvnode(struct vnode *vp, struct uio *uiop, struct ucred *cred)
return EFBIG;*/
td = uiop->uio_td;
if (vp->v_type == VDIR) {
lks = LK_EXCLUSIVE;/*lockstatus(&vp->v_lock, td);*/
lks = LK_EXCLUSIVE;/*lockstatus(vp->v_vnlock, td);*/
if (lks == LK_SHARED)
vn_lock(vp, LK_UPGRADE | LK_RETRY, td);
error = smbfs_readvdir(vp, uiop, cred);

2
sys/fs/smbfs/smbfs_node.c
View File

@ -244,7 +244,7 @@ smbfs_node_alloc(struct mount *mp, struct vnode *dvp,
} else if (vp->v_type == VREG)
SMBERROR("new vnode '%s' born without parent ?\n", np->n_name);
lockinit(&vp->v_lock, PINOD, "smbnode", VLKTIMEOUT, LK_CANRECURSE);
vp->v_vnlock->lk_flags |= LK_CANRECURSE;
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
smbfs_hash_lock(smp, td);

2
sys/fs/udf/udf_vfsops.c
View File

@ -613,8 +613,6 @@ udf_vget(struct mount *mp, ino_t ino, int flags, struct vnode **vpp)
unode->i_dev = udfmp->im_dev;
unode->udfmp = udfmp;
vp->v_data = unode;
lockinit(&vp->v_lock, PINOD, "udfnode", 0, 0);
vp->v_vnlock = &vp->v_lock;
VREF(udfmp->im_devvp);
udf_hashins(unode);

4
sys/fs/udf/udf_vnops.c
View File

@ -135,8 +135,7 @@ udf_hashins(struct udf_node *node)
mtx_lock(&udfmp->hash_mtx);
TAILQ_INSERT_TAIL(&udfmp->udf_tqh, node, tq);
mtx_unlock(&udfmp->hash_mtx);
lockmgr(&node->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0,
curthread);
vn_lock(node->i_vnode, LK_EXCLUSIVE | LK_RETRY, curthread);
return (0);
}
@ -1028,7 +1027,6 @@ udf_reclaim(struct vop_reclaim_args *a)
if (unode->fentry != NULL)
FREE(unode->fentry, M_UDFFENTRY);
lockdestroy(&unode->i_vnode->v_lock);
uma_zfree(udf_zone_node, unode);
vp->v_data = NULL;
}

5
sys/fs/unionfs/union.h
View File

@ -66,13 +66,8 @@ struct union_mount {
/*
* A cache of vnode references (hangs off v_data)
*
* Placing un_lock as the first elements theoretically allows us to
* use the vop_stdlock functions. However, we need to make sure of
* certain side effects so we will still punch in our own code.
*/
struct union_node {
struct lock un_lock;
LIST_ENTRY(union_node) un_cache; /* Hash chain */
struct vnode *un_vnode; /* Back pointer */
struct vnode *un_uppervp; /* overlaying object */

2
sys/fs/unionfs/union_subr.c
View File

@ -576,7 +576,6 @@ union_allocvp(vpp, mp, dvp, upperdvp, cnp, uppervp, lowervp, docache)
un = VTOUNION(*vpp);
bzero(un, sizeof(*un));
lockinit(&un->un_lock, PVFS, "unlock", VLKTIMEOUT, 0);
vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY, td);
un->un_vnode = *vpp;
@ -643,7 +642,6 @@ union_freevp(vp)
free(un->un_path, M_TEMP);
un->un_path = NULL;
}
lockdestroy(&un->un_lock);
FREE(vp->v_data, M_TEMP);
vp->v_data = 0;

84
sys/fs/unionfs/union_vnops.c
View File

@ -80,7 +80,6 @@ static int union_inactive(struct vop_inactive_args *ap);
static int union_ioctl(struct vop_ioctl_args *ap);
static int union_lease(struct vop_lease_args *ap);
static int union_link(struct vop_link_args *ap);
static int union_lock(struct vop_lock_args *ap);
static int union_lookup(struct vop_lookup_args *ap);
static int union_lookup1(struct vnode *udvp, struct vnode **dvp,
struct vnode **vpp,
@ -103,7 +102,6 @@ static int union_poll(struct vop_poll_args *ap);
static int union_setattr(struct vop_setattr_args *ap);
static int union_strategy(struct vop_strategy_args *ap);
static int union_symlink(struct vop_symlink_args *ap);
static int union_unlock(struct vop_unlock_args *ap);
static int union_whiteout(struct vop_whiteout_args *ap);
static int union_write(struct vop_read_args *ap);
@ -1700,86 +1698,6 @@ union_reclaim(ap)
return (0);
}
static int
union_lock(ap)
struct vop_lock_args *ap;
{
#if 0
struct vnode *vp = ap->a_vp;
struct thread *td = ap->a_td;
int flags = ap->a_flags;
struct union_node *un;
#endif
int error;
error = vop_stdlock(ap);
#if 0
un = VTOUNION(vp);
if (error == 0) {
/*
* Lock the upper if it exists and this is an exclusive lock
* request.
*/
if (un->un_uppervp != NULLVP &&
(flags & LK_TYPE_MASK) == LK_EXCLUSIVE) {
if ((un->un_flags & UN_ULOCK) == 0 && vrefcnt(vp)) {
error = vn_lock(un->un_uppervp, flags, td);
if (error) {
struct vop_unlock_args uap = { 0 };
uap.a_vp = ap->a_vp;
uap.a_flags = ap->a_flags;
uap.a_td = ap->a_td;
vop_stdunlock(&uap);
return (error);
}
un->un_flags |= UN_ULOCK;
}
}
}
#endif
return (error);
}
/*
* union_unlock:
*
* Unlock our union node. This also unlocks uppervp.
*/
static int
union_unlock(ap)
struct vop_unlock_args /* {
struct vnode *a_vp;
int a_flags;
struct thread *a_td;
} */ *ap;
{
#if 0
struct union_node *un = VTOUNION(ap->a_vp);
#endif
int error;
#if 0
KASSERT((un->un_uppervp == NULL || vrefcnt(un->un_uppervp) > 0), ("uppervp usecount is 0"));
#endif
error = vop_stdunlock(ap);
#if 0
/*
* If no exclusive locks remain and we are holding an uppervp lock,
* remove the uppervp lock.
*/
if ((un->un_flags & UN_ULOCK) &&
lockstatus(&un->un_lock, NULL) != LK_EXCLUSIVE) {
un->un_flags &= ~UN_ULOCK;
VOP_UNLOCK(un->un_uppervp, LK_EXCLUSIVE, td);
}
#endif
return(error);
}
/*
* unionvp do not hold a VM object and there is no need to create one for
* upper or lower vp because it is done in the union_open()
@ -1936,7 +1854,6 @@ static struct vnodeopv_entry_desc union_vnodeop_entries[] = {
{ &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_lookup_desc, (vop_t *) union_lookup },
{ &vop_mkdir_desc, (vop_t *) union_mkdir },
{ &vop_mknod_desc, (vop_t *) union_mknod },
@ -1956,7 +1873,6 @@ static struct vnodeopv_entry_desc union_vnodeop_entries[] = {
{ &vop_setattr_desc, (vop_t *) union_setattr },
{ &vop_strategy_desc, (vop_t *) union_strategy },
{ &vop_symlink_desc, (vop_t *) union_symlink },
{ &vop_unlock_desc, (vop_t *) union_unlock },
{ &vop_whiteout_desc, (vop_t *) union_whiteout },
{ &vop_write_desc, (vop_t *) union_write },
{ NULL, NULL }

2
sys/gnu/ext2fs/ext2_ihash.c
View File

@ -148,7 +148,7 @@ ext2_ihashins(ip)
struct ihashhead *ipp;
/* lock the inode, then put it on the appropriate hash list */
lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, td);
vn_lock(ITOV(ip), LK_EXCLUSIVE | LK_RETRY, td);
mtx_lock(&ext2_ihash_mtx);
ipp = INOHASH(ip->i_dev, ip->i_number);

1
sys/gnu/ext2fs/ext2_inode.c
View File

@ -546,7 +546,6 @@ ext2_reclaim(ap)
vrele(ip->i_devvp);
ip->i_devvp = 0;
}
lockdestroy(&vp->v_lock);
FREE(vp->v_data, M_EXT2NODE);
vp->v_data = 0;
return (0);

1
sys/gnu/ext2fs/ext2_vfsops.c
View File

@ -1017,7 +1017,6 @@ ext2_vget(mp, ino, flags, vpp)
return (error);
}
bzero((caddr_t)ip, sizeof(struct inode));
lockinit(&vp->v_lock, PINOD, "ext2in", 0, 0);
vp->v_data = ip;
ip->i_vnode = vp;
ip->i_e2fs = fs = ump->um_e2fs;

1
sys/gnu/fs/ext2fs/ext2_inode.c
View File

@ -546,7 +546,6 @@ ext2_reclaim(ap)
vrele(ip->i_devvp);
ip->i_devvp = 0;
}
lockdestroy(&vp->v_lock);
FREE(vp->v_data, M_EXT2NODE);
vp->v_data = 0;
return (0);

1
sys/gnu/fs/ext2fs/ext2_vfsops.c
View File

@ -1017,7 +1017,6 @@ ext2_vget(mp, ino, flags, vpp)
return (error);
}
bzero((caddr_t)ip, sizeof(struct inode));
lockinit(&vp->v_lock, PINOD, "ext2in", 0, 0);
vp->v_data = ip;
ip->i_vnode = vp;
ip->i_e2fs = fs = ump->um_e2fs;

3
sys/isofs/cd9660/cd9660_node.c
View File

@ -143,7 +143,7 @@ cd9660_ihashins(ip)
*ipp = ip;
mtx_unlock(&cd9660_ihash_mtx);
lockmgr(&ip->i_vnode->v_lock, LK_EXCLUSIVE, (struct mtx *)0, curthread);
vn_lock(ITOV(ip), LK_EXCLUSIVE | LK_RETRY, curthread);
}
/*
@ -223,7 +223,6 @@ cd9660_reclaim(ap)
vrele(ip->i_devvp);
ip->i_devvp = 0;
}
lockdestroy(&ip->i_vnode->v_lock);
FREE(vp->v_data, M_ISOFSNODE);
vp->v_data = NULL;
return (0);

5
sys/isofs/cd9660/cd9660_vfsops.c
View File

@ -714,11 +714,6 @@ cd9660_vget_internal(mp, ino, flags, vpp, relocated, isodir)
}
MALLOC(ip, struct iso_node *, sizeof(struct iso_node), M_ISOFSNODE,
M_WAITOK | M_ZERO);
lockinit(&vp->v_lock, PINOD, "isonode", 0, 0);
/*
* ISOFS uses stdlock and can share lock structure
*/
vp->v_vnlock = &vp->v_lock;
vp->v_data = ip;
ip->i_vnode = vp;
ip->i_dev = dev;

14
sys/kern/vfs_default.c
View File

@ -276,9 +276,9 @@ vop_stdlock(ap)
struct vnode *vp = ap->a_vp;
#ifndef DEBUG_LOCKS
return (lockmgr(&vp->v_lock, ap->a_flags, VI_MTX(vp), ap->a_td));
return (lockmgr(vp->v_vnlock, ap->a_flags, VI_MTX(vp), ap->a_td));
#else
return (debuglockmgr(&vp->v_lock, ap->a_flags, VI_MTX(vp),
return (debuglockmgr(vp->v_vnlock, ap->a_flags, VI_MTX(vp),
ap->a_td, "vop_stdlock", vp->filename, vp->line));
#endif
}
@ -294,7 +294,7 @@ vop_stdunlock(ap)
{
struct vnode *vp = ap->a_vp;
return (lockmgr(&vp->v_lock, ap->a_flags | LK_RELEASE, VI_MTX(vp),
return (lockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE, VI_MTX(vp),
ap->a_td));
}
@ -307,7 +307,7 @@ vop_stdislocked(ap)
} */ *ap;
{
return (lockstatus(&ap->a_vp->v_lock, ap->a_td));
return (lockstatus(ap->a_vp->v_vnlock, ap->a_td));
}
/* Mark the vnode inactive */
@ -423,9 +423,9 @@ vop_sharedlock(ap)
if (flags & LK_INTERLOCK)
vnflags |= LK_INTERLOCK;
#ifndef DEBUG_LOCKS
return (lockmgr(&vp->v_lock, vnflags, VI_MTX(vp), ap->a_td));
return (lockmgr(vp->v_vnlock, vnflags, VI_MTX(vp), ap->a_td));
#else
return (debuglockmgr(&vp->v_lock, vnflags, VI_MTX(vp), ap->a_td,
return (debuglockmgr(vp->v_vnlock, vnflags, VI_MTX(vp), ap->a_td,
"vop_sharedlock", vp->filename, vp->line));
#endif
}
@ -480,7 +480,7 @@ vop_nolock(ap)
}
if (flags & LK_INTERLOCK)
vnflags |= LK_INTERLOCK;
return(lockmgr(&vp->v_lock, vnflags, VI_MTX(vp), ap->a_td));
return(lockmgr(vp->v_vnlock, vnflags, VI_MTX(vp), ap->a_td));
#else /* for now */
/*
* Since we are not using the lock manager, we must clear

17
sys/kern/vfs_subr.c
View File

@ -974,6 +974,8 @@ getnewvnode(tag, mp, vops, vpp)
vp->v_cstart = 0;
vp->v_clen = 0;
vp->v_socket = 0;
lockdestroy(vp->v_vnlock);
lockinit(vp->v_vnlock, PVFS, tag, VLKTIMEOUT, LK_NOPAUSE);
KASSERT(vp->v_cleanblkroot == NULL, ("cleanblkroot not NULL"));
KASSERT(vp->v_dirtyblkroot == NULL, ("dirtyblkroot not NULL"));
} else {
@ -984,6 +986,8 @@ getnewvnode(tag, mp, vops, vpp)
mtx_init(&vp->v_interlock, "vnode interlock", NULL, MTX_DEF);
VI_LOCK(vp);
vp->v_dd = vp;
vp->v_vnlock = &vp->v_lock;
lockinit(vp->v_vnlock, PVFS, tag, VLKTIMEOUT, LK_NOPAUSE);
cache_purge(vp);
LIST_INIT(&vp->v_cache_src);
TAILQ_INIT(&vp->v_cache_dst);
@ -994,7 +998,6 @@ getnewvnode(tag, mp, vops, vpp)
vp->v_type = VNON;
vp->v_tag = tag;
vp->v_op = vops;
lockinit(&vp->v_lock, PVFS, "vnlock", VLKTIMEOUT, LK_NOPAUSE);
*vpp = vp;
vp->v_usecount = 1;
vp->v_data = 0;
@ -1994,10 +1997,9 @@ addaliasu(nvp, nvp_rdev)
ovp->v_data = nvp->v_data;
ovp->v_tag = nvp->v_tag;
nvp->v_data = NULL;
lockinit(&ovp->v_lock, PVFS, nvp->v_lock.lk_wmesg,
nvp->v_lock.lk_timo, nvp->v_lock.lk_flags & LK_EXTFLG_MASK);
if (nvp->v_vnlock)
ovp->v_vnlock = &ovp->v_lock;
lockdestroy(ovp->v_vnlock);
lockinit(ovp->v_vnlock, PVFS, nvp->v_vnlock->lk_wmesg,
nvp->v_vnlock->lk_timo, nvp->v_vnlock->lk_flags & LK_EXTFLG_MASK);
ops = ovp->v_op;
ovp->v_op = nvp->v_op;
if (VOP_ISLOCKED(nvp, curthread)) {
@ -2538,9 +2540,6 @@ vclean(vp, flags, td)
}
cache_purge(vp);
vp->v_vnlock = NULL;
lockdestroy(&vp->v_lock);
VI_LOCK(vp);
if (VSHOULDFREE(vp))
vfree(vp);
@ -2813,7 +2812,7 @@ vprint(label, vp)
strcat(buf, "|VV_OBJBUF");
if (buf[0] != '\0')
printf(" flags (%s),", &buf[1]);
lockmgr_printinfo(&vp->v_lock);
lockmgr_printinfo(vp->v_vnlock);
printf("\n");
if (vp->v_data != NULL) {
printf("\t");

1
sys/nfsclient/nfs_node.c
View File

@ -258,7 +258,6 @@ nfs_nget(struct mount *mntp, nfsfh_t *fhp, int fhsize, struct nfsnode **npp)
bcopy((caddr_t)fhp, (caddr_t)np->n_fhp, fhsize);
np->n_fhsize = fhsize;
lockinit(&np->n_rslock, PVFS | rsflags, "nfrslk", 0, LK_NOPAUSE);
lockinit(&vp->v_lock, PVFS, "nfsnlk", 0, LK_NOPAUSE);
*npp = np;
if (nfs_node_hash_lock < 0)

8
sys/security/lomac/lomacfs_vnops.c
View File

@ -205,7 +205,7 @@ lomacfs_lock(
*/
lvp = VTOLVP(vp);
if (lvp == NULL || flags & LK_THISLAYER)
return (lockmgr(&vp->v_lock, flags, &vp->v_interlock, td));
return (lockmgr(vp->v_vnlock, flags, &vp->v_interlock, td));
if (flags & LK_INTERLOCK) {
mtx_unlock(&vp->v_interlock);
flags &= ~LK_INTERLOCK;
@ -218,7 +218,7 @@ lomacfs_lock(
error = vn_lock(lvp, lflags | LK_CANRECURSE, td);
if (error)
return (error);
error = lockmgr(&vp->v_lock, flags, &vp->v_interlock, td);
error = lockmgr(vp->v_vnlock, flags, &vp->v_interlock, td);
if (error)
VOP_UNLOCK(lvp, 0, td);
return (error);
@ -245,7 +245,7 @@ lomacfs_unlock(
struct vnode *lvp = VTOLVP(vp);
int error;
error = lockmgr(&vp->v_lock, flags | LK_RELEASE, &vp->v_interlock, td);
error = lockmgr(vp->v_vnlock, flags | LK_RELEASE, &vp->v_interlock, td);
if (lvp == NULL || flags & LK_THISLAYER || error)
return (error);
/*
@ -269,7 +269,7 @@ lomacfs_islocked(
struct vnode *vp = ap->a_vp;
struct thread *td = ap->a_td;
return (lockstatus(&vp->v_lock, td));
return (lockstatus(vp->v_vnlock, td));
}
static int

5
sys/ufs/ffs/ffs_vfsops.c
View File

@ -1218,10 +1218,9 @@ ffs_vget(mp, ino, flags, vpp)
}
bzero((caddr_t)ip, sizeof(struct inode));
/*
* FFS supports lock sharing in the stack of vnodes
* FFS supports recursive locking.
*/
vp->v_vnlock = &vp->v_lock;
lockinit(vp->v_vnlock, PINOD, "inode", VLKTIMEOUT, LK_CANRECURSE);
vp->v_vnlock->lk_flags |= LK_CANRECURSE;
vp->v_data = ip;
ip->i_vnode = vp;
ip->i_ump = ump;

1
sys/ufs/ufs/ufs_inode.c
View File

@ -179,7 +179,6 @@ ufs_reclaim(ap)
}
}
#endif
lockdestroy(&vp->v_lock);
#ifdef UFS_DIRHASH
if (ip->i_dirhash != NULL)
ufsdirhash_free(ip);