bsd/vfs/vfs_subr.c

197 static void vgone(vnode_t, int flags);
217 		struct vnode_attr *vap, uint32_t flags, int fmode, uint32_t *statusp, vfs_context_t ctx);
510 vnode_umount_preflight(mount_t mp, vnode_t skipvp, int flags)
522 		if ((flags & SKIPSYSTEM) && ((vp->v_flag & VSYSTEM) ||
525 		if ((flags & SKIPSWAP) && (vp->v_flag & VSWAP))
527 		if ((flags & WRITECLOSE) &&
620 vnode_iterate(mount_t mp, int flags, int (*callout)(struct vnode *, void *),
651 		if ( vget_internal(vp, vid, (flags | VNODE_NODEAD| VNODE_WITHID | VNODE_NOSUSPEND))) {
655 		if (flags & VNODE_RELOAD) {
852 vfs_busy(mount_t mp, int flags)
860 		if (flags & LK_NOWAIT)
1525 vnode_ref_ext(vnode_t vp, int fmode, int flags)
1542 	if ((flags & VNODE_REF_FORCE) == 0) {
1908 vflush(struct mount *mp, struct vnode *skipvp, int flags)
1925 	if (((flags & FORCECLOSE)==0)  && ((mp->mnt_kern_flag & MNTK_UNMOUNT_PREFLIGHT) != 0)) {
1926 		if (vnode_umount_preflight(mp, skipvp, flags)) {
1967 		if ((flags & SKIPSYSTEM) && ((vp->v_flag & VSYSTEM) ||
1976 		if ((flags & SKIPSWAP) && (vp->v_flag & VSWAP)) {
1984 		if ((flags & SKIPROOT) && (vp->v_flag & VROOT)) {
1993 		if ((flags & WRITECLOSE) &&
2025 		if (flags & FORCECLOSE) {
2058 	if (busy && ((flags & FORCECLOSE)==0) && reclaimed) {
2068 		if (!(busy && ((flags & FORCECLOSE)==0)))
2074 	if (busy && ((flags & FORCECLOSE)==0))
2085 vclean(vnode_t vp, int flags)
2134 	if (flags & DOCLOSE)
2136 	if (flags & REVOKEALL)
2139 	if (active && (flags & DOCLOSE))
2145 	if (flags & DOCLOSE) {
2238 vn_revoke(vnode_t vp, int flags, __unused vfs_context_t a_context)
2240 vn_revoke(vnode_t vp, __unused int flags, __unused vfs_context_t a_context)
2247 	if ((flags & REVOKEALL) == 0)
2331 vgone(vnode_t vp, int flags)
2341 	vclean(vp, flags | DOCLOSE);
2516 		printf(" flags (%s)", &sbuf[1]);
3299 	int *name, flags, namelen;
3362 		error = SYSCTL_IN(req, &flags, sizeof(flags));
3370 		error = safedounmount(mp, flags, ctx);
3382 		error = SYSCTL_IN(req, &flags, sizeof(flags));
3386 		if (((flags & MNT_NOWAIT) == 0 || (flags & (MNT_WAIT | MNT_DWAIT))) &&
4378 vnode_reclaim_internal(struct vnode * vp, int locked, int reuse, int flags)
4397 		vgone(vp, flags);		/* clean and reclaim the vnode */
4729 vfs_iterate(int flags, int (*callout)(mount_t, void *), void *arg)
4750 	if (flags & VFS_ITERATE_TAIL_FIRST) {
4981 vnode_lookup(const char *path, int flags, vnode_t *vpp, vfs_context_t ctx)
4991 	if (flags & VNODE_LOOKUP_NOFOLLOW)
4996 	if (flags & VNODE_LOOKUP_NOCROSSMOUNT)
4998 	if (flags & VNODE_LOOKUP_DOWHITEOUT)
5014 vnode_open(const char *path, int fmode, int cmode, int flags, vnode_t *vpp, vfs_context_t ctx)
5019 	int lflags = flags;
5051 vnode_close(vnode_t vp, int flags, vfs_context_t ctx)
5059 	error = vn_close(vp, flags, ctx);
5094 vn_create_reg(vnode_t dvp, vnode_t *vpp, struct nameidata *ndp, struct vnode_attr *vap, uint32_t flags, int fmode, uint32_t *statusp, vfs_context_t ctx)
5097 	if (vnode_compound_open_available(dvp) && ((flags & VN_CREATE_DOOPEN) != 0)) {
5119  *		flags			VN_* flags controlling ACL inheritance
5147 vn_create(vnode_t dvp, vnode_t *vpp, struct nameidata *ndp, struct vnode_attr *vap, uint32_t flags, int fmode, uint32_t *statusp, vfs_context_t ctx)
5161 	if (flags & VN_CREATE_NOINHERIT)
5163 	if (flags & VN_CREATE_NOAUTH)
5173 	if (vap->va_type != VREG && (fmode != 0 || (flags & VN_CREATE_DOOPEN) || statusp)) {
5176 	if ((fmode != 0) && ((flags & VN_CREATE_DOOPEN) == 0)) {
5185 		error = vn_create_reg(dvp, vpp, ndp, vap, flags, fmode, statusp, ctx);
5208 	if (!(flags & VN_CREATE_NOLABEL)) {
5258 	int		flags;
5762  * The 'ignore' flag is set when an operation modifying the immutability flags
5764  * immutability flags we can ignore.
5778 	/* ignore only set when authorizing flags changes */
5781 			/* in insecure state, flags do not inhibit changes */
5784 			/* in secure state, user flags don't inhibit */
5788 	KAUTH_DEBUG("IMMUTABLE - file flags 0x%x mask 0x%x append = %d ignore = %d", vap->va_flags, mask, append, ignore);
5887 		result = (vcp->flags & _VAC_IS_OWNER) ? 1 : 0;
5894 			vcp->flags |= _VAC_IS_OWNER;
5896 			vcp->flags &= ~_VAC_IS_OWNER;
5910  *				vcp->flags_valid	Valid flags
5911  *				vcp->flags		Flags values
5930 		*ismember = (vcp->flags & _VAC_IN_GROUP) ? 1 : 0;
5940 				vcp->flags |= _VAC_IN_GROUP;
5942 				vcp->flags &= ~_VAC_IN_GROUP;
5956 		result = (vcp->flags & _VAC_IS_DIR_OWNER) ? 1 : 0;
5963 			vcp->flags |= _VAC_IS_DIR_OWNER;
5965 			vcp->flags &= ~_VAC_IS_DIR_OWNER;
5978  *				vcp->flags_valid	Valid flags
5979  *				vcp->flags		Flags values
5998 		*ismember = (vcp->flags & _VAC_IN_DIR_GROUP) ? 1 : 0;
6008 				vcp->flags |= _VAC_IN_DIR_GROUP;
6010 				vcp->flags &= ~_VAC_IN_DIR_GROUP;
6791 	vcp->flags = vcp->flags_valid = 0;
7345 	 * If flags are being changed, we need the old flags.
7348 		KAUTH_DEBUG("ATTR - flags changing, fetching old flags");
7356 		KAUTH_DEBUG("ATTR - acl changing, fetching old flags");
7504 	 * Validate/mask flags changes.  This checks that only the flags in
7505 	 * the UF_SETTABLE mask are being set, and preserves the flags in
7508 	 * Since flags changes may be made in conjunction with other changes,
7510 	 * the SF_* flags are not set and we are only manipulating the file flags.
7514 		/* compute changing flags bits */
7522 			KAUTH_DEBUG("ATTR - flags changing, requiring WRITE_SECURITY");
7529 				 * flags unless the system securelevel permits it, so just check
7530 				 * for legal flags here.
7545 			 * If the caller has the ability to manipulate file flags,
7548 			 * A more complete test here would consider the 'after' states of the flags
7553 			 * the SF_* flags if securelevel > 0.
8446 vnode_trigger_unresolve(vnode_t vp, int flags, vfs_context_t ctx)
8479 	result = rp->vr_unresolve_func(vp, flags, rp->vr_data, ctx);
8535 	int		flags;
8591 		error = vnode_trigger_unresolve(vp, infop->flags, infop->ctx);
8626 vfs_nested_trigger_unmounts(mount_t mp, int flags, vfs_context_t ctx)
8657 	info.flags = flags;
8669 			(void) vnode_trigger_unresolve(vp, flags, ctx);