Differential D25577 Diff 74908 head/sys/kern/vfs_subr.c

Changeset View

Standalone View

head/sys/kern/vfs_subr.c

Show First 20 Lines • Show All 658 Lines • ▼ Show 20 Lines	vntblinit(void *dummy __unused)
mtx_lock(&vnode_list_mtx);		mtx_lock(&vnode_list_mtx);
vnlru_recalc();		vnlru_recalc();
mtx_unlock(&vnode_list_mtx);		mtx_unlock(&vnode_list_mtx);
vnode_list_free_marker = vn_alloc_marker(NULL);		vnode_list_free_marker = vn_alloc_marker(NULL);
TAILQ_INSERT_HEAD(&vnode_list, vnode_list_free_marker, v_vnodelist);		TAILQ_INSERT_HEAD(&vnode_list, vnode_list_free_marker, v_vnodelist);
vnode_list_reclaim_marker = vn_alloc_marker(NULL);		vnode_list_reclaim_marker = vn_alloc_marker(NULL);
TAILQ_INSERT_HEAD(&vnode_list, vnode_list_reclaim_marker, v_vnodelist);		TAILQ_INSERT_HEAD(&vnode_list, vnode_list_reclaim_marker, v_vnodelist);
vnode_zone = uma_zcreate("VNODE", sizeof (struct vnode), NULL, NULL,		vnode_zone = uma_zcreate("VNODE", sizeof (struct vnode), NULL, NULL,
vnode_init, vnode_fini, UMA_ALIGN_PTR, UMA_ZONE_SMR);		vnode_init, vnode_fini, UMA_ALIGN_PTR, 0);
vfs_smr = uma_zone_get_smr(vnode_zone);		uma_zone_set_smr(vnode_zone, vfs_smr);
vnodepoll_zone = uma_zcreate("VNODEPOLL", sizeof (struct vpollinfo),		vnodepoll_zone = uma_zcreate("VNODEPOLL", sizeof (struct vpollinfo),
NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);		NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
/*		/*
* Preallocate enough nodes to support one-per buf so that		* Preallocate enough nodes to support one-per buf so that
* we can not fail an insert. reassignbuf() callers can not		* we can not fail an insert. reassignbuf() callers can not
* tolerate the insertion failure.		* tolerate the insertion failure.
*/		*/
buf_trie_zone = uma_zcreate("BUF TRIE", pctrie_node_size(),		buf_trie_zone = uma_zcreate("BUF TRIE", pctrie_node_size(),
▲ Show 20 Lines • Show All 2,232 Lines • ▼ Show 20 Lines	if (refcount_acquire_if_not_zero(&vp->v_usecount)) {
vs = VGET_USECOUNT;		vs = VGET_USECOUNT;
} else {		} else {
vhold(vp);		vhold(vp);
vs = VGET_HOLDCNT;		vs = VGET_HOLDCNT;
}		}
return (vs);		return (vs);
}		}

		void
		vget_abort(struct vnode *vp, enum vgetstate vs)
		{

		switch (vs) {
		case VGET_USECOUNT:
		vrele(vp);
		break;
		case VGET_HOLDCNT:
		vdrop(vp);
		break;
		default:
		__assert_unreachable();
		}
		}

int		int
vget(struct vnode vp, int flags, struct thread td)		vget(struct vnode vp, int flags, struct thread td)
{		{
enum vgetstate vs;		enum vgetstate vs;

MPASS(td == curthread);		MPASS(td == curthread);

vs = vget_prep(vp);		vs = vget_prep(vp);
return (vget_finish(vp, flags, vs));		return (vget_finish(vp, flags, vs));
}		}

static int __noinline		static void __noinline
vget_finish_vchr(struct vnode *vp)		vget_finish_vchr(struct vnode *vp)
{		{

VNASSERT(vp->v_type == VCHR, vp, ("type != VCHR)"));		VNASSERT(vp->v_type == VCHR, vp, ("type != VCHR)"));

/*		/*
* See the comment in vget_finish before usecount bump.		* See the comment in vget_finish before usecount bump.
*/		*/
if (refcount_acquire_if_not_zero(&vp->v_usecount)) {		if (refcount_acquire_if_not_zero(&vp->v_usecount)) {
#ifdef INVARIANTS		#ifdef INVARIANTS
int old = atomic_fetchadd_int(&vp->v_holdcnt, -1);		int old = atomic_fetchadd_int(&vp->v_holdcnt, -1);
VNASSERT(old > 0, vp, ("%s: wrong hold count %d", __func__, old));		VNASSERT(old > 0, vp, ("%s: wrong hold count %d", __func__, old));
#else		#else
refcount_release(&vp->v_holdcnt);		refcount_release(&vp->v_holdcnt);
#endif		#endif
return (0);		return;
}		}

VI_LOCK(vp);		VI_LOCK(vp);
if (refcount_acquire_if_not_zero(&vp->v_usecount)) {		if (refcount_acquire_if_not_zero(&vp->v_usecount)) {
#ifdef INVARIANTS		#ifdef INVARIANTS
int old = atomic_fetchadd_int(&vp->v_holdcnt, -1);		int old = atomic_fetchadd_int(&vp->v_holdcnt, -1);
VNASSERT(old > 1, vp, ("%s: wrong hold count %d", __func__, old));		VNASSERT(old > 1, vp, ("%s: wrong hold count %d", __func__, old));
#else		#else
refcount_release(&vp->v_holdcnt);		refcount_release(&vp->v_holdcnt);
#endif		#endif
VI_UNLOCK(vp);		VI_UNLOCK(vp);
return (0);		return;
}		}
v_incr_devcount(vp);		v_incr_devcount(vp);
refcount_acquire(&vp->v_usecount);		refcount_acquire(&vp->v_usecount);
VI_UNLOCK(vp);		VI_UNLOCK(vp);
return (0);
}		}

int		int
vget_finish(struct vnode *vp, int flags, enum vgetstate vs)		vget_finish(struct vnode *vp, int flags, enum vgetstate vs)
{		{
int error, old;		int error;

if ((flags & LK_INTERLOCK) != 0)		if ((flags & LK_INTERLOCK) != 0)
ASSERT_VI_LOCKED(vp, __func__);		ASSERT_VI_LOCKED(vp, __func__);
else		else
ASSERT_VI_UNLOCKED(vp, __func__);		ASSERT_VI_UNLOCKED(vp, __func__);
VNPASS(vs == VGET_HOLDCNT \|\| vs == VGET_USECOUNT, vp);		VNPASS(vs == VGET_HOLDCNT \|\| vs == VGET_USECOUNT, vp);
VNPASS(vp->v_holdcnt > 0, vp);		VNPASS(vp->v_holdcnt > 0, vp);
VNPASS(vs == VGET_HOLDCNT \|\| vp->v_usecount > 0, vp);		VNPASS(vs == VGET_HOLDCNT \|\| vp->v_usecount > 0, vp);

error = vn_lock(vp, flags);		error = vn_lock(vp, flags);
if (__predict_false(error != 0)) {		if (__predict_false(error != 0)) {
if (vs == VGET_USECOUNT)		vget_abort(vp, vs);
vrele(vp);
else
vdrop(vp);
CTR2(KTR_VFS, "%s: impossible to lock vnode %p", __func__,		CTR2(KTR_VFS, "%s: impossible to lock vnode %p", __func__,
vp);		vp);
return (error);		return (error);
}		}

if (vs == VGET_USECOUNT)		vget_finish_ref(vp, vs);
return (0);		return (0);
		}

if (__predict_false(vp->v_type == VCHR))		void
return (vget_finish_vchr(vp));		vget_finish_ref(struct vnode *vp, enum vgetstate vs)
		{
		int old;

		VNPASS(vs == VGET_HOLDCNT \|\| vs == VGET_USECOUNT, vp);
		VNPASS(vp->v_holdcnt > 0, vp);
		VNPASS(vs == VGET_HOLDCNT \|\| vp->v_usecount > 0, vp);

		if (vs == VGET_USECOUNT)
		return;

		if (__predict_false(vp->v_type == VCHR)) {
		vget_finish_vchr(vp);
		return;
		}

/*		/*
* We hold the vnode. If the usecount is 0 it will be utilized to keep		* We hold the vnode. If the usecount is 0 it will be utilized to keep
* the vnode around. Otherwise someone else lended their hold count and		* the vnode around. Otherwise someone else lended their hold count and
* we have to drop ours.		* we have to drop ours.
*/		*/
old = atomic_fetchadd_int(&vp->v_usecount, 1);		old = atomic_fetchadd_int(&vp->v_usecount, 1);
VNASSERT(old >= 0, vp, ("%s: wrong use count %d", __func__, old));		VNASSERT(old >= 0, vp, ("%s: wrong use count %d", __func__, old));
if (old != 0) {		if (old != 0) {
#ifdef INVARIANTS		#ifdef INVARIANTS
old = atomic_fetchadd_int(&vp->v_holdcnt, -1);		old = atomic_fetchadd_int(&vp->v_holdcnt, -1);
VNASSERT(old > 1, vp, ("%s: wrong hold count %d", __func__, old));		VNASSERT(old > 1, vp, ("%s: wrong hold count %d", __func__, old));
#else		#else
refcount_release(&vp->v_holdcnt);		refcount_release(&vp->v_holdcnt);
#endif		#endif
}		}
return (0);
}		}

/*		/*
* Increase the reference (use) and hold count of a vnode.		* Increase the reference (use) and hold count of a vnode.
* This will also remove the vnode from the free list if it is presently free.		* This will also remove the vnode from the free list if it is presently free.
*/		*/
static void __noinline		static void __noinline
vref_vchr(struct vnode *vp, bool interlock)		vref_vchr(struct vnode *vp, bool interlock)
▲ Show 20 Lines • Show All 1,401 Lines • ▼ Show 20 Lines	#define MNT_KERN_FLAG(flag) do { \
MNT_KERN_FLAG(MNTK_EXTENDED_SHARED);		MNT_KERN_FLAG(MNTK_EXTENDED_SHARED);
MNT_KERN_FLAG(MNTK_SHARED_WRITES);		MNT_KERN_FLAG(MNTK_SHARED_WRITES);
MNT_KERN_FLAG(MNTK_NO_IOPF);		MNT_KERN_FLAG(MNTK_NO_IOPF);
MNT_KERN_FLAG(MNTK_VGONE_UPPER);		MNT_KERN_FLAG(MNTK_VGONE_UPPER);
MNT_KERN_FLAG(MNTK_VGONE_WAITER);		MNT_KERN_FLAG(MNTK_VGONE_WAITER);
MNT_KERN_FLAG(MNTK_LOOKUP_EXCL_DOTDOT);		MNT_KERN_FLAG(MNTK_LOOKUP_EXCL_DOTDOT);
MNT_KERN_FLAG(MNTK_MARKER);		MNT_KERN_FLAG(MNTK_MARKER);
MNT_KERN_FLAG(MNTK_USES_BCACHE);		MNT_KERN_FLAG(MNTK_USES_BCACHE);
		MNT_KERN_FLAG(MNTK_FPLOOKUP);
MNT_KERN_FLAG(MNTK_NOASYNC);		MNT_KERN_FLAG(MNTK_NOASYNC);
MNT_KERN_FLAG(MNTK_UNMOUNT);		MNT_KERN_FLAG(MNTK_UNMOUNT);
MNT_KERN_FLAG(MNTK_MWAIT);		MNT_KERN_FLAG(MNTK_MWAIT);
MNT_KERN_FLAG(MNTK_SUSPEND);		MNT_KERN_FLAG(MNTK_SUSPEND);
MNT_KERN_FLAG(MNTK_SUSPEND2);		MNT_KERN_FLAG(MNTK_SUSPEND2);
MNT_KERN_FLAG(MNTK_SUSPENDED);		MNT_KERN_FLAG(MNTK_SUSPENDED);
MNT_KERN_FLAG(MNTK_LOOKUP_SHARED);		MNT_KERN_FLAG(MNTK_LOOKUP_SHARED);
MNT_KERN_FLAG(MNTK_NOKNOTE);		MNT_KERN_FLAG(MNTK_NOKNOTE);
▲ Show 20 Lines • Show All 800 Lines • ▼ Show 20 Lines	vn_isdisk(struct vnode vp, int errp)
dev_unlock();		dev_unlock();
out:		out:
if (errp != NULL)		if (errp != NULL)
*errp = error;		*errp = error;
return (error == 0);		return (error == 0);
}		}

/*		/*
		* VOP_FPLOOKUP_VEXEC routines are subject to special circumstances, see
		* the comment above cache_fplookup for details.
		*
		* We never deny as priv_check_cred calls are not yet supported, see vaccess.
		*/
		int
		vaccess_vexec_smr(mode_t file_mode, uid_t file_uid, gid_t file_gid, struct ucred *cred)
		{

		VFS_SMR_ASSERT_ENTERED();

		/* Check the owner. */
		if (cred->cr_uid == file_uid) {
		if (file_mode & S_IXUSR)
		return (0);
		return (EAGAIN);
		}

		/* Otherwise, check the groups (first match) */
		if (groupmember(file_gid, cred)) {
		if (file_mode & S_IXGRP)
		return (0);
		return (EAGAIN);
		}

		/* Otherwise, check everyone else. */
		if (file_mode & S_IXOTH)
		return (0);
		return (EAGAIN);
		}

		/*
* Common filesystem object access control check routine. Accepts a		* Common filesystem object access control check routine. Accepts a
* vnode's type, "mode", uid and gid, requested access mode, credentials,		* vnode's type, "mode", uid and gid, requested access mode, credentials,
* and optional call-by-reference privused argument allowing vaccess()		* and optional call-by-reference privused argument allowing vaccess()
* to indicate to the caller whether privilege was used to satisfy the		* to indicate to the caller whether privilege was used to satisfy the
* request (obsoleted). Returns 0 on success, or an errno on failure.		* request (obsoleted). Returns 0 on success, or an errno on failure.
*/		*/
int		int
vaccess(enum vtype type, mode_t file_mode, uid_t file_uid, gid_t file_gid,		vaccess(enum vtype type, mode_t file_mode, uid_t file_uid, gid_t file_gid,
▲ Show 20 Lines • Show All 281 Lines • ▼ Show 20 Lines	#endif
if (a->a_tvp != a->a_fvp)		if (a->a_tvp != a->a_fvp)
vhold(a->a_fvp);		vhold(a->a_fvp);
vhold(a->a_tdvp);		vhold(a->a_tdvp);
if (a->a_tvp)		if (a->a_tvp)
vhold(a->a_tvp);		vhold(a->a_tvp);
}		}

#ifdef DEBUG_VFS_LOCKS		#ifdef DEBUG_VFS_LOCKS
		void
		vop_fplookup_vexec_pre(void *ap __unused)
		{

		VFS_SMR_ASSERT_ENTERED();
		}

		void
		vop_fplookup_vexec_post(void *ap __unused, int rc __unused)
		{

		VFS_SMR_ASSERT_ENTERED();
		}

void		void
vop_strategy_pre(void *ap)		vop_strategy_pre(void *ap)
{		{
struct vop_strategy_args *a;		struct vop_strategy_args *a;
struct buf *bp;		struct buf *bp;

a = ap;		a = ap;
bp = a->a_bp;		bp = a->a_bp;
▲ Show 20 Lines • Show All 1,304 Lines • Show Last 20 Lines