2 * Copyright (c) 2000-2016 Apple Inc. All rights reserved.
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
28 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
30 * Copyright (c) 1989, 1993
31 * The Regents of the University of California. All rights reserved.
32 * (c) UNIX System Laboratories, Inc.
33 * All or some portions of this file are derived from material licensed
34 * to the University of California by American Telephone and Telegraph
35 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
36 * the permission of UNIX System Laboratories, Inc.
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. All advertising materials mentioning features or use of this software
47 * must display the following acknowledgement:
48 * This product includes software developed by the University of
49 * California, Berkeley and its contributors.
50 * 4. Neither the name of the University nor the names of its contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
66 * @(#)vfs_subr.c 8.31 (Berkeley) 5/26/95
69 * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
70 * support for mandatory and extensible security protections. This notice
71 * is included in support of clause 2.2 (b) of the Apple Public License,
76 * External virtual filesystem routines
79 #include <sys/param.h>
80 #include <sys/systm.h>
81 #include <sys/proc_internal.h>
82 #include <sys/kauth.h>
83 #include <sys/mount_internal.h>
86 #include <sys/vnode.h>
87 #include <sys/vnode_internal.h>
89 #include <sys/namei.h>
90 #include <sys/ucred.h>
91 #include <sys/buf_internal.h>
92 #include <sys/errno.h>
93 #include <sys/malloc.h>
94 #include <sys/uio_internal.h>
96 #include <sys/domain.h>
98 #include <sys/syslog.h>
99 #include <sys/ubc_internal.h>
101 #include <sys/sysctl.h>
102 #include <sys/filedesc.h>
103 #include <sys/event.h>
104 #include <sys/kdebug.h>
105 #include <sys/kauth.h>
106 #include <sys/user.h>
107 #include <sys/systm.h>
108 #include <sys/kern_memorystatus.h>
109 #include <sys/lockf.h>
110 #include <miscfs/fifofs/fifo.h>
113 #include <machine/spl.h>
114 #include <machine/machine_routines.h>
116 #include <kern/assert.h>
117 #include <mach/kern_return.h>
118 #include <kern/thread.h>
119 #include <kern/sched_prim.h>
121 #include <miscfs/specfs/specdev.h>
123 #include <mach/mach_types.h>
124 #include <mach/memory_object_types.h>
125 #include <mach/memory_object_control.h>
127 #include <kern/kalloc.h> /* kalloc()/kfree() */
128 #include <kern/clock.h> /* delay_for_interval() */
129 #include <libkern/OSAtomic.h> /* OSAddAtomic() */
130 #include <console/video_console.h>
133 #include <libkern/OSDebug.h>
136 #include <vm/vm_protos.h> /* vnode_pager_vrele() */
139 #include <security/mac_framework.h>
142 extern lck_grp_t
*vnode_lck_grp
;
143 extern lck_attr_t
*vnode_lck_attr
;
146 extern lck_grp_t
*trigger_vnode_lck_grp
;
147 extern lck_attr_t
*trigger_vnode_lck_attr
;
150 extern lck_mtx_t
* mnt_list_mtx_lock
;
152 enum vtype iftovt_tab
[16] = {
153 VNON
, VFIFO
, VCHR
, VNON
, VDIR
, VNON
, VBLK
, VNON
,
154 VREG
, VNON
, VLNK
, VNON
, VSOCK
, VNON
, VNON
, VBAD
,
156 int vttoif_tab
[9] = {
157 0, S_IFREG
, S_IFDIR
, S_IFBLK
, S_IFCHR
, S_IFLNK
,
158 S_IFSOCK
, S_IFIFO
, S_IFMT
,
162 /* XXX These should be in a BSD accessible Mach header, but aren't. */
163 extern void memory_object_mark_used(
164 memory_object_control_t control
);
166 extern void memory_object_mark_unused(
167 memory_object_control_t control
,
170 extern void memory_object_mark_io_tracking(
171 memory_object_control_t control
);
173 /* XXX next protptype should be from <nfs/nfs.h> */
174 extern int nfs_vinvalbuf(vnode_t
, int, vfs_context_t
, int);
176 /* XXX next prototytype should be from libsa/stdlib.h> but conflicts libkern */
177 __private_extern__
void qsort(
181 int (*)(const void *, const void *));
183 extern kern_return_t
adjust_vm_object_cache(vm_size_t oval
, vm_size_t nval
);
184 __private_extern__
void vntblinit(void);
185 __private_extern__ kern_return_t
reset_vmobjectcache(unsigned int val1
,
187 __private_extern__
int unlink1(vfs_context_t
, vnode_t
, user_addr_t
,
190 extern int system_inshutdown
;
192 static void vnode_list_add(vnode_t
);
193 static void vnode_async_list_add(vnode_t
);
194 static void vnode_list_remove(vnode_t
);
195 static void vnode_list_remove_locked(vnode_t
);
197 static void vnode_abort_advlocks(vnode_t
);
198 static errno_t
vnode_drain(vnode_t
);
199 static void vgone(vnode_t
, int flags
);
200 static void vclean(vnode_t vp
, int flag
);
201 static void vnode_reclaim_internal(vnode_t
, int, int, int);
203 static void vnode_dropiocount (vnode_t
);
205 static vnode_t
checkalias(vnode_t vp
, dev_t nvp_rdev
);
206 static int vnode_reload(vnode_t
);
207 static int vnode_isinuse_locked(vnode_t
, int, int);
209 static int unmount_callback(mount_t
, __unused
void *);
211 static void insmntque(vnode_t vp
, mount_t mp
);
212 static int mount_getvfscnt(void);
213 static int mount_fillfsids(fsid_t
*, int );
214 static void vnode_iterate_setup(mount_t
);
215 int vnode_umount_preflight(mount_t
, vnode_t
, int);
216 static int vnode_iterate_prepare(mount_t
);
217 static int vnode_iterate_reloadq(mount_t
);
218 static void vnode_iterate_clear(mount_t
);
219 static mount_t
vfs_getvfs_locked(fsid_t
*);
220 static int vn_create_reg(vnode_t dvp
, vnode_t
*vpp
, struct nameidata
*ndp
,
221 struct vnode_attr
*vap
, uint32_t flags
, int fmode
, uint32_t *statusp
, vfs_context_t ctx
);
222 static int vnode_authattr_new_internal(vnode_t dvp
, struct vnode_attr
*vap
, int noauth
, uint32_t *defaulted_fieldsp
, vfs_context_t ctx
);
224 errno_t
rmdir_remove_orphaned_appleDouble(vnode_t
, vfs_context_t
, int *);
227 static void record_vp(vnode_t vp
, int count
);
230 #if CONFIG_JETSAM && (DEVELOPMENT || DEBUG)
231 extern int bootarg_no_vnode_jetsam
; /* from bsd_init.c default value is 0 */
232 #endif /* CONFIG_JETSAM && (DEVELOPMENT || DEBUG) */
234 boolean_t root_is_CF_drive
= FALSE
;
237 static int vnode_resolver_create(mount_t
, vnode_t
, struct vnode_trigger_param
*, boolean_t external
);
238 static void vnode_resolver_detach(vnode_t
);
241 TAILQ_HEAD(freelst
, vnode
) vnode_free_list
; /* vnode free list */
242 TAILQ_HEAD(deadlst
, vnode
) vnode_dead_list
; /* vnode dead list */
243 TAILQ_HEAD(async_work_lst
, vnode
) vnode_async_work_list
;
246 TAILQ_HEAD(ragelst
, vnode
) vnode_rage_list
; /* vnode rapid age list */
247 struct timeval rage_tv
;
251 #define RAGE_LIMIT_MIN 100
252 #define RAGE_TIME_LIMIT 5
254 struct mntlist mountlist
; /* mounted filesystem list */
255 static int nummounts
= 0;
258 #define VLISTCHECK(fun, vp, list) \
259 if ((vp)->v_freelist.tqe_prev == (struct vnode **)0xdeadb) \
260 panic("%s: %s vnode not on %slist", (fun), (list), (list));
262 #define VLISTCHECK(fun, vp, list)
263 #endif /* DIAGNOSTIC */
265 #define VLISTNONE(vp) \
267 (vp)->v_freelist.tqe_next = (struct vnode *)0; \
268 (vp)->v_freelist.tqe_prev = (struct vnode **)0xdeadb; \
271 #define VONLIST(vp) \
272 ((vp)->v_freelist.tqe_prev != (struct vnode **)0xdeadb)
274 /* remove a vnode from free vnode list */
275 #define VREMFREE(fun, vp) \
277 VLISTCHECK((fun), (vp), "free"); \
278 TAILQ_REMOVE(&vnode_free_list, (vp), v_freelist); \
284 /* remove a vnode from dead vnode list */
285 #define VREMDEAD(fun, vp) \
287 VLISTCHECK((fun), (vp), "dead"); \
288 TAILQ_REMOVE(&vnode_dead_list, (vp), v_freelist); \
290 vp->v_listflag &= ~VLIST_DEAD; \
295 /* remove a vnode from async work vnode list */
296 #define VREMASYNC_WORK(fun, vp) \
298 VLISTCHECK((fun), (vp), "async_work"); \
299 TAILQ_REMOVE(&vnode_async_work_list, (vp), v_freelist); \
301 vp->v_listflag &= ~VLIST_ASYNC_WORK; \
302 async_work_vnodes--; \
306 /* remove a vnode from rage vnode list */
307 #define VREMRAGE(fun, vp) \
309 if ( !(vp->v_listflag & VLIST_RAGE)) \
310 panic("VREMRAGE: vp not on rage list"); \
311 VLISTCHECK((fun), (vp), "rage"); \
312 TAILQ_REMOVE(&vnode_rage_list, (vp), v_freelist); \
314 vp->v_listflag &= ~VLIST_RAGE; \
320 * vnodetarget hasn't been used in a long time, but
321 * it was exported for some reason... I'm leaving in
322 * place for now... it should be deprecated out of the
323 * exports and removed eventually.
325 u_int32_t vnodetarget
; /* target for vnreclaim() */
326 #define VNODE_FREE_TARGET 20 /* Default value for vnodetarget */
329 * We need quite a few vnodes on the free list to sustain the
330 * rapid stat() the compilation process does, and still benefit from the name
331 * cache. Having too few vnodes on the free list causes serious disk
332 * thrashing as we cycle through them.
334 #define VNODE_FREE_MIN CONFIG_VNODE_FREE_MIN /* freelist should have at least this many */
337 static void async_work_continue(void);
340 * Initialize the vnode management data structures.
342 __private_extern__
void
345 thread_t thread
= THREAD_NULL
;
347 TAILQ_INIT(&vnode_free_list
);
348 TAILQ_INIT(&vnode_rage_list
);
349 TAILQ_INIT(&vnode_dead_list
);
350 TAILQ_INIT(&vnode_async_work_list
);
351 TAILQ_INIT(&mountlist
);
354 vnodetarget
= VNODE_FREE_TARGET
;
356 microuptime(&rage_tv
);
357 rage_limit
= desiredvnodes
/ 100;
359 if (rage_limit
< RAGE_LIMIT_MIN
)
360 rage_limit
= RAGE_LIMIT_MIN
;
363 * Scale the vm_object_cache to accomodate the vnodes
366 (void) adjust_vm_object_cache(0, desiredvnodes
- VNODE_FREE_MIN
);
369 * create worker threads
371 kernel_thread_start((thread_continue_t
)async_work_continue
, NULL
, &thread
);
372 thread_deallocate(thread
);
375 /* Reset the VM Object Cache with the values passed in */
376 __private_extern__ kern_return_t
377 reset_vmobjectcache(unsigned int val1
, unsigned int val2
)
379 vm_size_t oval
= val1
- VNODE_FREE_MIN
;
386 if(val2
< VNODE_FREE_MIN
)
389 nval
= val2
- VNODE_FREE_MIN
;
391 return(adjust_vm_object_cache(oval
, nval
));
395 /* the timeout is in 10 msecs */
397 vnode_waitforwrites(vnode_t vp
, int output_target
, int slpflag
, int slptimeout
, const char *msg
) {
401 KERNEL_DEBUG(0x3010280 | DBG_FUNC_START
, (int)vp
, output_target
, vp
->v_numoutput
, 0, 0);
403 if (vp
->v_numoutput
> output_target
) {
409 while ((vp
->v_numoutput
> output_target
) && error
== 0) {
411 vp
->v_flag
|= VTHROTTLED
;
413 vp
->v_flag
|= VBWAIT
;
415 ts
.tv_sec
= (slptimeout
/100);
416 ts
.tv_nsec
= (slptimeout
% 1000) * 10 * NSEC_PER_USEC
* 1000 ;
417 error
= msleep((caddr_t
)&vp
->v_numoutput
, &vp
->v_lock
, (slpflag
| (PRIBIO
+ 1)), msg
, &ts
);
423 KERNEL_DEBUG(0x3010280 | DBG_FUNC_END
, (int)vp
, output_target
, vp
->v_numoutput
, error
, 0);
430 vnode_startwrite(vnode_t vp
) {
432 OSAddAtomic(1, &vp
->v_numoutput
);
437 vnode_writedone(vnode_t vp
)
442 OSAddAtomic(-1, &vp
->v_numoutput
);
446 if (vp
->v_numoutput
< 0)
447 panic("vnode_writedone: numoutput < 0");
449 if ((vp
->v_flag
& VTHROTTLED
)) {
450 vp
->v_flag
&= ~VTHROTTLED
;
453 if ((vp
->v_flag
& VBWAIT
) && (vp
->v_numoutput
== 0)) {
454 vp
->v_flag
&= ~VBWAIT
;
460 wakeup((caddr_t
)&vp
->v_numoutput
);
467 vnode_hasdirtyblks(vnode_t vp
)
469 struct cl_writebehind
*wbp
;
472 * Not taking the buf_mtxp as there is little
473 * point doing it. Even if the lock is taken the
474 * state can change right after that. If their
475 * needs to be a synchronization, it must be driven
478 if (vp
->v_dirtyblkhd
.lh_first
)
481 if (!UBCINFOEXISTS(vp
))
484 wbp
= vp
->v_ubcinfo
->cl_wbehind
;
486 if (wbp
&& (wbp
->cl_number
|| wbp
->cl_scmap
))
493 vnode_hascleanblks(vnode_t vp
)
496 * Not taking the buf_mtxp as there is little
497 * point doing it. Even if the lock is taken the
498 * state can change right after that. If their
499 * needs to be a synchronization, it must be driven
502 if (vp
->v_cleanblkhd
.lh_first
)
508 vnode_iterate_setup(mount_t mp
)
510 while (mp
->mnt_lflag
& MNT_LITER
) {
511 mp
->mnt_lflag
|= MNT_LITERWAIT
;
512 msleep((caddr_t
)mp
, &mp
->mnt_mlock
, PVFS
, "vnode_iterate_setup", NULL
);
515 mp
->mnt_lflag
|= MNT_LITER
;
520 vnode_umount_preflight(mount_t mp
, vnode_t skipvp
, int flags
)
524 TAILQ_FOREACH(vp
, &mp
->mnt_vnodelist
, v_mntvnodes
) {
525 if (vp
->v_type
== VDIR
)
529 if ((flags
& SKIPSYSTEM
) && ((vp
->v_flag
& VSYSTEM
) || (vp
->v_flag
& VNOFLUSH
)))
531 if ((flags
& SKIPSWAP
) && (vp
->v_flag
& VSWAP
))
533 if ((flags
& WRITECLOSE
) && (vp
->v_writecount
== 0 || vp
->v_type
!= VREG
))
536 /* Look for busy vnode */
537 if ((vp
->v_usecount
!= 0) && ((vp
->v_usecount
- vp
->v_kusecount
) != 0)) {
540 } else if (vp
->v_iocount
> 0) {
541 /* Busy if iocount is > 0 for more than 3 seconds */
542 tsleep(&vp
->v_iocount
, PVFS
, "vnode_drain_network", 3 * hz
);
543 if (vp
->v_iocount
> 0)
553 * This routine prepares iteration by moving all the vnodes to worker queue
554 * called with mount lock held
557 vnode_iterate_prepare(mount_t mp
)
561 if (TAILQ_EMPTY(&mp
->mnt_vnodelist
)) {
566 vp
= TAILQ_FIRST(&mp
->mnt_vnodelist
);
567 vp
->v_mntvnodes
.tqe_prev
= &(mp
->mnt_workerqueue
.tqh_first
);
568 mp
->mnt_workerqueue
.tqh_first
= mp
->mnt_vnodelist
.tqh_first
;
569 mp
->mnt_workerqueue
.tqh_last
= mp
->mnt_vnodelist
.tqh_last
;
571 TAILQ_INIT(&mp
->mnt_vnodelist
);
572 if (mp
->mnt_newvnodes
.tqh_first
!= NULL
)
573 panic("vnode_iterate_prepare: newvnode when entering vnode");
574 TAILQ_INIT(&mp
->mnt_newvnodes
);
580 /* called with mount lock held */
582 vnode_iterate_reloadq(mount_t mp
)
586 /* add the remaining entries in workerq to the end of mount vnode list */
587 if (!TAILQ_EMPTY(&mp
->mnt_workerqueue
)) {
589 mvp
= TAILQ_LAST(&mp
->mnt_vnodelist
, vnodelst
);
591 /* Joining the workerque entities to mount vnode list */
593 mvp
->v_mntvnodes
.tqe_next
= mp
->mnt_workerqueue
.tqh_first
;
595 mp
->mnt_vnodelist
.tqh_first
= mp
->mnt_workerqueue
.tqh_first
;
596 mp
->mnt_workerqueue
.tqh_first
->v_mntvnodes
.tqe_prev
= mp
->mnt_vnodelist
.tqh_last
;
597 mp
->mnt_vnodelist
.tqh_last
= mp
->mnt_workerqueue
.tqh_last
;
598 TAILQ_INIT(&mp
->mnt_workerqueue
);
601 /* add the newvnodes to the head of mount vnode list */
602 if (!TAILQ_EMPTY(&mp
->mnt_newvnodes
)) {
604 nlvp
= TAILQ_LAST(&mp
->mnt_newvnodes
, vnodelst
);
606 mp
->mnt_newvnodes
.tqh_first
->v_mntvnodes
.tqe_prev
= &mp
->mnt_vnodelist
.tqh_first
;
607 nlvp
->v_mntvnodes
.tqe_next
= mp
->mnt_vnodelist
.tqh_first
;
608 if(mp
->mnt_vnodelist
.tqh_first
)
609 mp
->mnt_vnodelist
.tqh_first
->v_mntvnodes
.tqe_prev
= &nlvp
->v_mntvnodes
.tqe_next
;
611 mp
->mnt_vnodelist
.tqh_last
= mp
->mnt_newvnodes
.tqh_last
;
612 mp
->mnt_vnodelist
.tqh_first
= mp
->mnt_newvnodes
.tqh_first
;
613 TAILQ_INIT(&mp
->mnt_newvnodes
);
622 vnode_iterate_clear(mount_t mp
)
624 mp
->mnt_lflag
&= ~MNT_LITER
;
625 if (mp
->mnt_lflag
& MNT_LITERWAIT
) {
626 mp
->mnt_lflag
&= ~MNT_LITERWAIT
;
632 #include <i386/panic_hooks.h>
634 struct vnode_iterate_panic_hook
{
640 static void vnode_iterate_panic_hook(panic_hook_t
*hook_
)
642 extern int kdb_log(const char *fmt
, ...);
643 struct vnode_iterate_panic_hook
*hook
= (struct vnode_iterate_panic_hook
*)hook_
;
644 panic_phys_range_t range
;
647 if (panic_phys_range_before(hook
->mp
, &phys
, &range
)) {
648 kdb_log("mp = %p, phys = %p, prev (%p: %p-%p)\n",
649 hook
->mp
, phys
, range
.type
, range
.phys_start
,
650 range
.phys_start
+ range
.len
);
652 kdb_log("mp = %p, phys = %p, prev (!)\n", hook
->mp
, phys
);
655 if (panic_phys_range_before(hook
->vp
, &phys
, &range
)) {
656 kdb_log("vp = %p, phys = %p, prev (%p: %p-%p)\n",
657 hook
->vp
, phys
, range
.type
, range
.phys_start
,
658 range
.phys_start
+ range
.len
);
660 kdb_log("vp = %p, phys = %p, prev (!)\n", hook
->vp
, phys
);
662 panic_dump_mem((void *)(((vm_offset_t
)hook
->mp
-4096) & ~4095), 12288);
666 vnode_iterate(mount_t mp
, int flags
, int (*callout
)(struct vnode
*, void *),
675 vnode_iterate_setup(mp
);
677 /* it is returns 0 then there is nothing to do */
678 retval
= vnode_iterate_prepare(mp
);
681 vnode_iterate_clear(mp
);
686 struct vnode_iterate_panic_hook hook
;
689 panic_hook(&hook
.hook
, vnode_iterate_panic_hook
);
690 /* iterate over all the vnodes */
691 while (!TAILQ_EMPTY(&mp
->mnt_workerqueue
)) {
692 vp
= TAILQ_FIRST(&mp
->mnt_workerqueue
);
694 TAILQ_REMOVE(&mp
->mnt_workerqueue
, vp
, v_mntvnodes
);
695 TAILQ_INSERT_TAIL(&mp
->mnt_vnodelist
, vp
, v_mntvnodes
);
697 if ((vp
->v_data
== NULL
) || (vp
->v_type
== VNON
) || (vp
->v_mount
!= mp
)) {
702 if ( vget_internal(vp
, vid
, (flags
| VNODE_NODEAD
| VNODE_WITHID
| VNODE_NOSUSPEND
))) {
706 if (flags
& VNODE_RELOAD
) {
708 * we're reloading the filesystem
709 * cast out any inactive vnodes...
711 if (vnode_reload(vp
)) {
712 /* vnode will be recycled on the refcount drop */
719 retval
= callout(vp
, arg
);
723 case VNODE_RETURNED_DONE
:
725 if (retval
== VNODE_RETURNED_DONE
) {
732 case VNODE_CLAIMED_DONE
:
744 panic_unhook(&hook
.hook
);
745 (void)vnode_iterate_reloadq(mp
);
746 vnode_iterate_clear(mp
);
752 mount_lock_renames(mount_t mp
)
754 lck_mtx_lock(&mp
->mnt_renamelock
);
758 mount_unlock_renames(mount_t mp
)
760 lck_mtx_unlock(&mp
->mnt_renamelock
);
764 mount_lock(mount_t mp
)
766 lck_mtx_lock(&mp
->mnt_mlock
);
770 mount_lock_spin(mount_t mp
)
772 lck_mtx_lock_spin(&mp
->mnt_mlock
);
776 mount_unlock(mount_t mp
)
778 lck_mtx_unlock(&mp
->mnt_mlock
);
783 mount_ref(mount_t mp
, int locked
)
796 mount_drop(mount_t mp
, int locked
)
803 if (mp
->mnt_count
== 0 && (mp
->mnt_lflag
& MNT_LDRAIN
))
804 wakeup(&mp
->mnt_lflag
);
812 mount_iterref(mount_t mp
, int locked
)
818 if (mp
->mnt_iterref
< 0) {
829 mount_isdrained(mount_t mp
, int locked
)
835 if (mp
->mnt_iterref
< 0)
845 mount_iterdrop(mount_t mp
)
849 wakeup(&mp
->mnt_iterref
);
854 mount_iterdrain(mount_t mp
)
857 while (mp
->mnt_iterref
)
858 msleep((caddr_t
)&mp
->mnt_iterref
, mnt_list_mtx_lock
, PVFS
, "mount_iterdrain", NULL
);
859 /* mount iterations drained */
860 mp
->mnt_iterref
= -1;
864 mount_iterreset(mount_t mp
)
867 if (mp
->mnt_iterref
== -1)
872 /* always called with mount lock held */
874 mount_refdrain(mount_t mp
)
876 if (mp
->mnt_lflag
& MNT_LDRAIN
)
877 panic("already in drain");
878 mp
->mnt_lflag
|= MNT_LDRAIN
;
880 while (mp
->mnt_count
)
881 msleep((caddr_t
)&mp
->mnt_lflag
, &mp
->mnt_mlock
, PVFS
, "mount_drain", NULL
);
883 if (mp
->mnt_vnodelist
.tqh_first
!= NULL
)
884 panic("mount_refdrain: dangling vnode");
886 mp
->mnt_lflag
&= ~MNT_LDRAIN
;
891 /* Tags the mount point as not supportine extended readdir for NFS exports */
893 mount_set_noreaddirext(mount_t mp
) {
895 mp
->mnt_kern_flag
|= MNTK_DENY_READDIREXT
;
900 * Mark a mount point as busy. Used to synchronize access and to delay
904 vfs_busy(mount_t mp
, int flags
)
908 if (mp
->mnt_lflag
& MNT_LDEAD
)
913 if (mp
->mnt_lflag
& MNT_LUNMOUNT
) {
914 if (flags
& LK_NOWAIT
|| mp
->mnt_lflag
& MNT_LDEAD
) {
920 * Since all busy locks are shared except the exclusive
921 * lock granted when unmounting, the only place that a
922 * wakeup needs to be done is at the release of the
923 * exclusive lock at the end of dounmount.
925 mp
->mnt_lflag
|= MNT_LWAIT
;
926 msleep((caddr_t
)mp
, &mp
->mnt_mlock
, (PVFS
| PDROP
), "vfsbusy", NULL
);
932 lck_rw_lock_shared(&mp
->mnt_rwlock
);
935 * Until we are granted the rwlock, it's possible for the mount point to
936 * change state, so re-evaluate before granting the vfs_busy.
938 if (mp
->mnt_lflag
& (MNT_LDEAD
| MNT_LUNMOUNT
)) {
939 lck_rw_done(&mp
->mnt_rwlock
);
946 * Free a busy filesystem.
949 vfs_unbusy(mount_t mp
)
951 lck_rw_done(&mp
->mnt_rwlock
);
957 vfs_rootmountfailed(mount_t mp
) {
960 mp
->mnt_vtable
->vfc_refcount
--;
965 mount_lock_destroy(mp
);
968 mac_mount_label_destroy(mp
);
971 FREE_ZONE(mp
, sizeof(struct mount
), M_MOUNT
);
975 * Lookup a filesystem type, and if found allocate and initialize
976 * a mount structure for it.
978 * Devname is usually updated by mount(8) after booting.
981 vfs_rootmountalloc_internal(struct vfstable
*vfsp
, const char *devname
)
985 mp
= _MALLOC_ZONE(sizeof(struct mount
), M_MOUNT
, M_WAITOK
);
986 bzero((char *)mp
, sizeof(struct mount
));
988 /* Initialize the default IO constraints */
989 mp
->mnt_maxreadcnt
= mp
->mnt_maxwritecnt
= MAXPHYS
;
990 mp
->mnt_segreadcnt
= mp
->mnt_segwritecnt
= 32;
991 mp
->mnt_maxsegreadsize
= mp
->mnt_maxreadcnt
;
992 mp
->mnt_maxsegwritesize
= mp
->mnt_maxwritecnt
;
993 mp
->mnt_devblocksize
= DEV_BSIZE
;
994 mp
->mnt_alignmentmask
= PAGE_MASK
;
995 mp
->mnt_ioqueue_depth
= MNT_DEFAULT_IOQUEUE_DEPTH
;
998 mp
->mnt_realrootvp
= NULLVP
;
999 mp
->mnt_authcache_ttl
= CACHED_LOOKUP_RIGHT_TTL
;
1000 mp
->mnt_throttle_mask
= LOWPRI_MAX_NUM_DEV
- 1;
1001 mp
->mnt_devbsdunit
= 0;
1003 mount_lock_init(mp
);
1004 (void)vfs_busy(mp
, LK_NOWAIT
);
1006 TAILQ_INIT(&mp
->mnt_vnodelist
);
1007 TAILQ_INIT(&mp
->mnt_workerqueue
);
1008 TAILQ_INIT(&mp
->mnt_newvnodes
);
1010 mp
->mnt_vtable
= vfsp
;
1011 mp
->mnt_op
= vfsp
->vfc_vfsops
;
1012 mp
->mnt_flag
= MNT_RDONLY
| MNT_ROOTFS
;
1013 mp
->mnt_vnodecovered
= NULLVP
;
1014 //mp->mnt_stat.f_type = vfsp->vfc_typenum;
1015 mp
->mnt_flag
|= vfsp
->vfc_flags
& MNT_VISFLAGMASK
;
1018 vfsp
->vfc_refcount
++;
1019 mount_list_unlock();
1021 strlcpy(mp
->mnt_vfsstat
.f_fstypename
, vfsp
->vfc_name
, MFSTYPENAMELEN
);
1022 mp
->mnt_vfsstat
.f_mntonname
[0] = '/';
1023 /* XXX const poisoning layering violation */
1024 (void) copystr((const void *)devname
, mp
->mnt_vfsstat
.f_mntfromname
, MAXPATHLEN
- 1, NULL
);
1027 mac_mount_label_init(mp
);
1028 mac_mount_label_associate(vfs_context_kernel(), mp
);
1034 vfs_rootmountalloc(const char *fstypename
, const char *devname
, mount_t
*mpp
)
1036 struct vfstable
*vfsp
;
1038 for (vfsp
= vfsconf
; vfsp
; vfsp
= vfsp
->vfc_next
)
1039 if (!strncmp(vfsp
->vfc_name
, fstypename
,
1040 sizeof(vfsp
->vfc_name
)))
1045 *mpp
= vfs_rootmountalloc_internal(vfsp
, devname
);
1055 * Find an appropriate filesystem to use for the root. If a filesystem
1056 * has not been preselected, walk through the list of known filesystems
1057 * trying those that have mountroot routines, and try them until one
1058 * works or we have tried them all.
1060 extern int (*mountroot
)(void);
1068 struct vfstable
*vfsp
;
1069 vfs_context_t ctx
= vfs_context_kernel();
1070 struct vfs_attr vfsattr
;
1073 vnode_t bdevvp_rootvp
;
1075 if (mountroot
!= NULL
) {
1077 * used for netboot which follows a different set of rules
1079 error
= (*mountroot
)();
1082 if ((error
= bdevvp(rootdev
, &rootvp
))) {
1083 printf("vfs_mountroot: can't setup bdevvp\n");
1087 * 4951998 - code we call in vfc_mountroot may replace rootvp
1088 * so keep a local copy for some house keeping.
1090 bdevvp_rootvp
= rootvp
;
1092 for (vfsp
= vfsconf
; vfsp
; vfsp
= vfsp
->vfc_next
) {
1093 if (vfsp
->vfc_mountroot
== NULL
1094 && !ISSET(vfsp
->vfc_vfsflags
, VFC_VFSCANMOUNTROOT
)) {
1098 mp
= vfs_rootmountalloc_internal(vfsp
, "root_device");
1099 mp
->mnt_devvp
= rootvp
;
1101 if (vfsp
->vfc_mountroot
)
1102 error
= (*vfsp
->vfc_mountroot
)(mp
, rootvp
, ctx
);
1104 error
= VFS_MOUNT(mp
, rootvp
, 0, ctx
);
1107 if ( bdevvp_rootvp
!= rootvp
) {
1110 * bump the iocount and fix up mnt_devvp for the
1111 * new rootvp (it will already have a usecount taken)...
1112 * drop the iocount and the usecount on the orignal
1113 * since we are no longer going to use it...
1115 vnode_getwithref(rootvp
);
1116 mp
->mnt_devvp
= rootvp
;
1118 vnode_rele(bdevvp_rootvp
);
1119 vnode_put(bdevvp_rootvp
);
1121 mp
->mnt_devvp
->v_specflags
|= SI_MOUNTEDON
;
1128 * cache the IO attributes for the underlying physical media...
1129 * an error return indicates the underlying driver doesn't
1130 * support all the queries necessary... however, reasonable
1131 * defaults will have been set, so no reason to bail or care
1133 vfs_init_io_attributes(rootvp
, mp
);
1135 if (mp
->mnt_ioflags
& MNT_IOFLAGS_FUSION_DRIVE
) {
1136 root_is_CF_drive
= TRUE
;
1140 * Shadow the VFC_VFSNATIVEXATTR flag to MNTK_EXTENDED_ATTRS.
1142 if (mp
->mnt_vtable
->vfc_vfsflags
& VFC_VFSNATIVEXATTR
) {
1143 mp
->mnt_kern_flag
|= MNTK_EXTENDED_ATTRS
;
1145 if (mp
->mnt_vtable
->vfc_vfsflags
& VFC_VFSPREFLIGHT
) {
1146 mp
->mnt_kern_flag
|= MNTK_UNMOUNT_PREFLIGHT
;
1151 if (MNTK_VIRTUALDEV
& mp
->mnt_kern_flag
) speed
= 128;
1152 else if (MNTK_SSD
& mp
->mnt_kern_flag
) speed
= 7*256;
1154 vc_progress_setdiskspeed(speed
);
1156 * Probe root file system for additional features.
1158 (void)VFS_START(mp
, 0, ctx
);
1160 VFSATTR_INIT(&vfsattr
);
1161 VFSATTR_WANTED(&vfsattr
, f_capabilities
);
1162 if (vfs_getattr(mp
, &vfsattr
, ctx
) == 0 &&
1163 VFSATTR_IS_SUPPORTED(&vfsattr
, f_capabilities
)) {
1164 if ((vfsattr
.f_capabilities
.capabilities
[VOL_CAPABILITIES_INTERFACES
] & VOL_CAP_INT_EXTENDED_ATTR
) &&
1165 (vfsattr
.f_capabilities
.valid
[VOL_CAPABILITIES_INTERFACES
] & VOL_CAP_INT_EXTENDED_ATTR
)) {
1166 mp
->mnt_kern_flag
|= MNTK_EXTENDED_ATTRS
;
1169 if ((vfsattr
.f_capabilities
.capabilities
[VOL_CAPABILITIES_INTERFACES
] & VOL_CAP_INT_NAMEDSTREAMS
) &&
1170 (vfsattr
.f_capabilities
.valid
[VOL_CAPABILITIES_INTERFACES
] & VOL_CAP_INT_NAMEDSTREAMS
)) {
1171 mp
->mnt_kern_flag
|= MNTK_NAMED_STREAMS
;
1174 if ((vfsattr
.f_capabilities
.capabilities
[VOL_CAPABILITIES_FORMAT
] & VOL_CAP_FMT_PATH_FROM_ID
) &&
1175 (vfsattr
.f_capabilities
.valid
[VOL_CAPABILITIES_FORMAT
] & VOL_CAP_FMT_PATH_FROM_ID
)) {
1176 mp
->mnt_kern_flag
|= MNTK_PATH_FROM_ID
;
1179 if ((vfsattr
.f_capabilities
.capabilities
[VOL_CAPABILITIES_FORMAT
] & VOL_CAP_FMT_DIR_HARDLINKS
) &&
1180 (vfsattr
.f_capabilities
.valid
[VOL_CAPABILITIES_FORMAT
] & VOL_CAP_FMT_DIR_HARDLINKS
)) {
1181 mp
->mnt_kern_flag
|= MNTK_DIR_HARDLINKS
;
1186 * get rid of iocount reference returned
1187 * by bdevvp (or picked up by us on the substitued
1188 * rootvp)... it (or we) will have also taken
1189 * a usecount reference which we want to keep
1194 if ((vfs_flags(mp
) & MNT_MULTILABEL
) == 0)
1197 error
= VFS_ROOT(mp
, &vp
, ctx
);
1199 printf("%s() VFS_ROOT() returned %d\n",
1201 dounmount(mp
, MNT_FORCE
, 0, ctx
);
1204 error
= vnode_label(mp
, NULL
, vp
, NULL
, 0, ctx
);
1206 * get rid of reference provided by VFS_ROOT
1211 printf("%s() vnode_label() returned %d\n",
1213 dounmount(mp
, MNT_FORCE
, 0, ctx
);
1222 vfs_rootmountfailed(mp
);
1224 if (error
!= EINVAL
)
1225 printf("%s_mountroot failed: %d\n", vfsp
->vfc_name
, error
);
1231 * Lookup a mount point by filesystem identifier.
1235 vfs_getvfs(fsid_t
*fsid
)
1237 return (mount_list_lookupby_fsid(fsid
, 0, 0));
1240 static struct mount
*
1241 vfs_getvfs_locked(fsid_t
*fsid
)
1243 return(mount_list_lookupby_fsid(fsid
, 1, 0));
1247 vfs_getvfs_by_mntonname(char *path
)
1249 mount_t retmp
= (mount_t
)0;
1253 TAILQ_FOREACH(mp
, &mountlist
, mnt_list
) {
1254 if (!strncmp(mp
->mnt_vfsstat
.f_mntonname
, path
,
1255 sizeof(mp
->mnt_vfsstat
.f_mntonname
))) {
1257 if (mount_iterref(retmp
, 1))
1263 mount_list_unlock();
1267 /* generation number for creation of new fsids */
1268 u_short mntid_gen
= 0;
1270 * Get a new unique fsid
1273 vfs_getnewfsid(struct mount
*mp
)
1281 /* generate a new fsid */
1282 mtype
= mp
->mnt_vtable
->vfc_typenum
;
1283 if (++mntid_gen
== 0)
1285 tfsid
.val
[0] = makedev(nblkdev
+ mtype
, mntid_gen
);
1286 tfsid
.val
[1] = mtype
;
1288 while (vfs_getvfs_locked(&tfsid
)) {
1289 if (++mntid_gen
== 0)
1291 tfsid
.val
[0] = makedev(nblkdev
+ mtype
, mntid_gen
);
1294 mp
->mnt_vfsstat
.f_fsid
.val
[0] = tfsid
.val
[0];
1295 mp
->mnt_vfsstat
.f_fsid
.val
[1] = tfsid
.val
[1];
1296 mount_list_unlock();
1300 * Routines having to do with the management of the vnode table.
1302 extern int (**dead_vnodeop_p
)(void *);
1303 long numvnodes
, freevnodes
, deadvnodes
, async_work_vnodes
;
1306 int async_work_timed_out
= 0;
1307 int async_work_handled
= 0;
1308 int dead_vnode_wanted
= 0;
1309 int dead_vnode_waited
= 0;
1312 * Move a vnode from one mount queue to another.
1315 insmntque(vnode_t vp
, mount_t mp
)
1319 * Delete from old mount point vnode list, if on one.
1321 if ( (lmp
= vp
->v_mount
) != NULL
&& lmp
!= dead_mountp
) {
1322 if ((vp
->v_lflag
& VNAMED_MOUNT
) == 0)
1323 panic("insmntque: vp not in mount vnode list");
1324 vp
->v_lflag
&= ~VNAMED_MOUNT
;
1326 mount_lock_spin(lmp
);
1330 if (vp
->v_mntvnodes
.tqe_next
== NULL
) {
1331 if (TAILQ_LAST(&lmp
->mnt_vnodelist
, vnodelst
) == vp
)
1332 TAILQ_REMOVE(&lmp
->mnt_vnodelist
, vp
, v_mntvnodes
);
1333 else if (TAILQ_LAST(&lmp
->mnt_newvnodes
, vnodelst
) == vp
)
1334 TAILQ_REMOVE(&lmp
->mnt_newvnodes
, vp
, v_mntvnodes
);
1335 else if (TAILQ_LAST(&lmp
->mnt_workerqueue
, vnodelst
) == vp
)
1336 TAILQ_REMOVE(&lmp
->mnt_workerqueue
, vp
, v_mntvnodes
);
1338 vp
->v_mntvnodes
.tqe_next
->v_mntvnodes
.tqe_prev
= vp
->v_mntvnodes
.tqe_prev
;
1339 *vp
->v_mntvnodes
.tqe_prev
= vp
->v_mntvnodes
.tqe_next
;
1341 vp
->v_mntvnodes
.tqe_next
= NULL
;
1342 vp
->v_mntvnodes
.tqe_prev
= NULL
;
1348 * Insert into list of vnodes for the new mount point, if available.
1350 if ((vp
->v_mount
= mp
) != NULL
) {
1351 mount_lock_spin(mp
);
1352 if ((vp
->v_mntvnodes
.tqe_next
!= 0) && (vp
->v_mntvnodes
.tqe_prev
!= 0))
1353 panic("vp already in mount list");
1354 if (mp
->mnt_lflag
& MNT_LITER
)
1355 TAILQ_INSERT_HEAD(&mp
->mnt_newvnodes
, vp
, v_mntvnodes
);
1357 TAILQ_INSERT_HEAD(&mp
->mnt_vnodelist
, vp
, v_mntvnodes
);
1358 if (vp
->v_lflag
& VNAMED_MOUNT
)
1359 panic("insmntque: vp already in mount vnode list");
1360 vp
->v_lflag
|= VNAMED_MOUNT
;
1368 * Create a vnode for a block device.
1369 * Used for root filesystem, argdev, and swap areas.
1370 * Also used for memory file system special devices.
1373 bdevvp(dev_t dev
, vnode_t
*vpp
)
1377 struct vnode_fsparam vfsp
;
1378 struct vfs_context context
;
1385 context
.vc_thread
= current_thread();
1386 context
.vc_ucred
= FSCRED
;
1388 vfsp
.vnfs_mp
= (struct mount
*)0;
1389 vfsp
.vnfs_vtype
= VBLK
;
1390 vfsp
.vnfs_str
= "bdevvp";
1391 vfsp
.vnfs_dvp
= NULL
;
1392 vfsp
.vnfs_fsnode
= NULL
;
1393 vfsp
.vnfs_cnp
= NULL
;
1394 vfsp
.vnfs_vops
= spec_vnodeop_p
;
1395 vfsp
.vnfs_rdev
= dev
;
1396 vfsp
.vnfs_filesize
= 0;
1398 vfsp
.vnfs_flags
= VNFS_NOCACHE
| VNFS_CANTCACHE
;
1400 vfsp
.vnfs_marksystem
= 0;
1401 vfsp
.vnfs_markroot
= 0;
1403 if ( (error
= vnode_create(VNCREATE_FLAVOR
, VCREATESIZE
, &vfsp
, &nvp
)) ) {
1407 vnode_lock_spin(nvp
);
1408 nvp
->v_flag
|= VBDEVVP
;
1409 nvp
->v_tag
= VT_NON
; /* set this to VT_NON so during aliasing it can be replaced */
1411 if ( (error
= vnode_ref(nvp
)) ) {
1412 panic("bdevvp failed: vnode_ref");
1415 if ( (error
= VNOP_FSYNC(nvp
, MNT_WAIT
, &context
)) ) {
1416 panic("bdevvp failed: fsync");
1419 if ( (error
= buf_invalidateblks(nvp
, BUF_WRITE_DATA
, 0, 0)) ) {
1420 panic("bdevvp failed: invalidateblks");
1426 * XXXMAC: We can't put a MAC check here, the system will
1427 * panic without this vnode.
1431 if ( (error
= VNOP_OPEN(nvp
, FREAD
, &context
)) ) {
1432 panic("bdevvp failed: open");
1442 * Check to see if the new vnode represents a special device
1443 * for which we already have a vnode (either because of
1444 * bdevvp() or because of a different vnode representing
1445 * the same block device). If such an alias exists, deallocate
1446 * the existing contents and return the aliased vnode. The
1447 * caller is responsible for filling it with its new contents.
1450 checkalias(struct vnode
*nvp
, dev_t nvp_rdev
)
1454 struct specinfo
*sin
= NULL
;
1457 vpp
= &speclisth
[SPECHASH(nvp_rdev
)];
1461 for (vp
= *vpp
; vp
; vp
= vp
->v_specnext
) {
1462 if (nvp_rdev
== vp
->v_rdev
&& nvp
->v_type
== vp
->v_type
) {
1471 if (vnode_getwithvid(vp
,vid
)) {
1475 * Termination state is checked in vnode_getwithvid
1480 * Alias, but not in use, so flush it out.
1482 if ((vp
->v_iocount
== 1) && (vp
->v_usecount
== 0)) {
1483 vnode_reclaim_internal(vp
, 1, 1, 0);
1484 vnode_put_locked(vp
);
1490 if (vp
== NULL
|| vp
->v_tag
!= VT_NON
) {
1492 MALLOC_ZONE(sin
, struct specinfo
*, sizeof(struct specinfo
),
1493 M_SPECINFO
, M_WAITOK
);
1496 nvp
->v_specinfo
= sin
;
1497 bzero(nvp
->v_specinfo
, sizeof(struct specinfo
));
1498 nvp
->v_rdev
= nvp_rdev
;
1499 nvp
->v_specflags
= 0;
1500 nvp
->v_speclastr
= -1;
1501 nvp
->v_specinfo
->si_opencount
= 0;
1502 nvp
->v_specinfo
->si_initted
= 0;
1503 nvp
->v_specinfo
->si_throttleable
= 0;
1507 /* We dropped the lock, someone could have added */
1509 for (vp
= *vpp
; vp
; vp
= vp
->v_specnext
) {
1510 if (nvp_rdev
== vp
->v_rdev
&& nvp
->v_type
== vp
->v_type
) {
1518 nvp
->v_hashchain
= vpp
;
1519 nvp
->v_specnext
= *vpp
;
1523 nvp
->v_specflags
|= SI_ALIASED
;
1524 vp
->v_specflags
|= SI_ALIASED
;
1526 vnode_put_locked(vp
);
1536 FREE_ZONE(sin
, sizeof(struct specinfo
), M_SPECINFO
);
1539 if ((vp
->v_flag
& (VBDEVVP
| VDEVFLUSH
)) != 0)
1542 panic("checkalias with VT_NON vp that shouldn't: %p", vp
);
1549 * Get a reference on a particular vnode and lock it if requested.
1550 * If the vnode was on the inactive list, remove it from the list.
1551 * If the vnode was on the free list, remove it from the list and
1552 * move it to inactive list as needed.
1553 * The vnode lock bit is set if the vnode is being eliminated in
1554 * vgone. The process is awakened when the transition is completed,
1555 * and an error returned to indicate that the vnode is no longer
1556 * usable (possibly having been changed to a new file system type).
1559 vget_internal(vnode_t vp
, int vid
, int vflags
)
1563 vnode_lock_spin(vp
);
1565 if ((vflags
& VNODE_WRITEABLE
) && (vp
->v_writecount
== 0))
1567 * vnode to be returned only if it has writers opened
1571 error
= vnode_getiocount(vp
, vid
, vflags
);
1579 * Returns: 0 Success
1580 * ENOENT No such file or directory [terminating]
1583 vnode_ref(vnode_t vp
)
1586 return (vnode_ref_ext(vp
, 0, 0));
1590 * Returns: 0 Success
1591 * ENOENT No such file or directory [terminating]
1594 vnode_ref_ext(vnode_t vp
, int fmode
, int flags
)
1598 vnode_lock_spin(vp
);
1601 * once all the current call sites have been fixed to insure they have
1602 * taken an iocount, we can toughen this assert up and insist that the
1603 * iocount is non-zero... a non-zero usecount doesn't insure correctness
1605 if (vp
->v_iocount
<= 0 && vp
->v_usecount
<= 0)
1606 panic("vnode_ref_ext: vp %p has no valid reference %d, %d", vp
, vp
->v_iocount
, vp
->v_usecount
);
1609 * if you are the owner of drain/termination, can acquire usecount
1611 if ((flags
& VNODE_REF_FORCE
) == 0) {
1612 if ((vp
->v_lflag
& (VL_DRAIN
| VL_TERMINATE
| VL_DEAD
))) {
1613 if (vp
->v_owner
!= current_thread()) {
1621 if (fmode
& FWRITE
) {
1622 if (++vp
->v_writecount
<= 0)
1623 panic("vnode_ref_ext: v_writecount");
1625 if (fmode
& O_EVTONLY
) {
1626 if (++vp
->v_kusecount
<= 0)
1627 panic("vnode_ref_ext: v_kusecount");
1629 if (vp
->v_flag
& VRAGE
) {
1632 ut
= get_bsdthread_info(current_thread());
1634 if ( !(current_proc()->p_lflag
& P_LRAGE_VNODES
) &&
1635 !(ut
->uu_flag
& UT_RAGE_VNODES
)) {
1637 * a 'normal' process accessed this vnode
1638 * so make sure its no longer marked
1639 * for rapid aging... also, make sure
1640 * it gets removed from the rage list...
1641 * when v_usecount drops back to 0, it
1642 * will be put back on the real free list
1644 vp
->v_flag
&= ~VRAGE
;
1645 vp
->v_references
= 0;
1646 vnode_list_remove(vp
);
1649 if (vp
->v_usecount
== 1 && vp
->v_type
== VREG
&& !(vp
->v_flag
& VSYSTEM
)) {
1651 if (vp
->v_ubcinfo
) {
1652 vnode_lock_convert(vp
);
1653 memory_object_mark_used(vp
->v_ubcinfo
->ui_control
);
1664 vnode_on_reliable_media(vnode_t vp
)
1666 if ( !(vp
->v_mount
->mnt_kern_flag
& MNTK_VIRTUALDEV
) && (vp
->v_mount
->mnt_flag
& MNT_LOCAL
) )
1672 vnode_async_list_add(vnode_t vp
)
1676 if (VONLIST(vp
) || (vp
->v_lflag
& (VL_TERMINATE
|VL_DEAD
)))
1677 panic("vnode_async_list_add: %p is in wrong state", vp
);
1679 TAILQ_INSERT_HEAD(&vnode_async_work_list
, vp
, v_freelist
);
1680 vp
->v_listflag
|= VLIST_ASYNC_WORK
;
1682 async_work_vnodes
++;
1684 vnode_list_unlock();
1686 wakeup(&vnode_async_work_list
);
1692 * put the vnode on appropriate free list.
1693 * called with vnode LOCKED
1696 vnode_list_add(vnode_t vp
)
1698 boolean_t need_dead_wakeup
= FALSE
;
1701 lck_mtx_assert(&vp
->v_lock
, LCK_MTX_ASSERT_OWNED
);
1707 * if it is already on a list or non zero references return
1709 if (VONLIST(vp
) || (vp
->v_usecount
!= 0) || (vp
->v_iocount
!= 0) || (vp
->v_lflag
& VL_TERMINATE
))
1713 * In vclean, we might have deferred ditching locked buffers
1714 * because something was still referencing them (indicated by
1715 * usecount). We can ditch them now.
1717 if (ISSET(vp
->v_lflag
, VL_DEAD
)
1718 && (!LIST_EMPTY(&vp
->v_cleanblkhd
) || !LIST_EMPTY(&vp
->v_dirtyblkhd
))) {
1719 ++vp
->v_iocount
; // Probably not necessary, but harmless
1724 buf_invalidateblks(vp
, BUF_INVALIDATE_LOCKED
, 0, 0);
1726 vnode_dropiocount(vp
);
1732 if ((vp
->v_flag
& VRAGE
) && !(vp
->v_lflag
& VL_DEAD
)) {
1734 * add the new guy to the appropriate end of the RAGE list
1736 if ((vp
->v_flag
& VAGE
))
1737 TAILQ_INSERT_HEAD(&vnode_rage_list
, vp
, v_freelist
);
1739 TAILQ_INSERT_TAIL(&vnode_rage_list
, vp
, v_freelist
);
1741 vp
->v_listflag
|= VLIST_RAGE
;
1745 * reset the timestamp for the last inserted vp on the RAGE
1746 * queue to let new_vnode know that its not ok to start stealing
1747 * from this list... as long as we're actively adding to this list
1748 * we'll push out the vnodes we want to donate to the real free list
1749 * once we stop pushing, we'll let some time elapse before we start
1750 * stealing them in the new_vnode routine
1752 microuptime(&rage_tv
);
1755 * if VL_DEAD, insert it at head of the dead list
1756 * else insert at tail of LRU list or at head if VAGE is set
1758 if ( (vp
->v_lflag
& VL_DEAD
)) {
1759 TAILQ_INSERT_HEAD(&vnode_dead_list
, vp
, v_freelist
);
1760 vp
->v_listflag
|= VLIST_DEAD
;
1763 if (dead_vnode_wanted
) {
1764 dead_vnode_wanted
--;
1765 need_dead_wakeup
= TRUE
;
1768 } else if ( (vp
->v_flag
& VAGE
) ) {
1769 TAILQ_INSERT_HEAD(&vnode_free_list
, vp
, v_freelist
);
1770 vp
->v_flag
&= ~VAGE
;
1773 TAILQ_INSERT_TAIL(&vnode_free_list
, vp
, v_freelist
);
1777 vnode_list_unlock();
1779 if (need_dead_wakeup
== TRUE
)
1780 wakeup_one((caddr_t
)&dead_vnode_wanted
);
1785 * remove the vnode from appropriate free list.
1786 * called with vnode LOCKED and
1787 * the list lock held
1790 vnode_list_remove_locked(vnode_t vp
)
1794 * the v_listflag field is
1795 * protected by the vnode_list_lock
1797 if (vp
->v_listflag
& VLIST_RAGE
)
1798 VREMRAGE("vnode_list_remove", vp
);
1799 else if (vp
->v_listflag
& VLIST_DEAD
)
1800 VREMDEAD("vnode_list_remove", vp
);
1801 else if (vp
->v_listflag
& VLIST_ASYNC_WORK
)
1802 VREMASYNC_WORK("vnode_list_remove", vp
);
1804 VREMFREE("vnode_list_remove", vp
);
1810 * remove the vnode from appropriate free list.
1811 * called with vnode LOCKED
1814 vnode_list_remove(vnode_t vp
)
1817 lck_mtx_assert(&vp
->v_lock
, LCK_MTX_ASSERT_OWNED
);
1820 * we want to avoid taking the list lock
1821 * in the case where we're not on the free
1822 * list... this will be true for most
1823 * directories and any currently in use files
1825 * we're guaranteed that we can't go from
1826 * the not-on-list state to the on-list
1827 * state since we hold the vnode lock...
1828 * all calls to vnode_list_add are done
1829 * under the vnode lock... so we can
1830 * check for that condition (the prevelant one)
1831 * without taking the list lock
1836 * however, we're not guaranteed that
1837 * we won't go from the on-list state
1838 * to the not-on-list state until we
1839 * hold the vnode_list_lock... this
1840 * is due to "new_vnode" removing vnodes
1841 * from the free list uder the list_lock
1842 * w/o the vnode lock... so we need to
1843 * check again whether we're currently
1846 vnode_list_remove_locked(vp
);
1848 vnode_list_unlock();
1854 vnode_rele(vnode_t vp
)
1856 vnode_rele_internal(vp
, 0, 0, 0);
1861 vnode_rele_ext(vnode_t vp
, int fmode
, int dont_reenter
)
1863 vnode_rele_internal(vp
, fmode
, dont_reenter
, 0);
1868 vnode_rele_internal(vnode_t vp
, int fmode
, int dont_reenter
, int locked
)
1872 vnode_lock_spin(vp
);
1875 lck_mtx_assert(&vp
->v_lock
, LCK_MTX_ASSERT_OWNED
);
1877 if (--vp
->v_usecount
< 0)
1878 panic("vnode_rele_ext: vp %p usecount -ve : %d. v_tag = %d, v_type = %d, v_flag = %x.", vp
, vp
->v_usecount
, vp
->v_tag
, vp
->v_type
, vp
->v_flag
);
1880 if (fmode
& FWRITE
) {
1881 if (--vp
->v_writecount
< 0)
1882 panic("vnode_rele_ext: vp %p writecount -ve : %d. v_tag = %d, v_type = %d, v_flag = %x.", vp
, vp
->v_writecount
, vp
->v_tag
, vp
->v_type
, vp
->v_flag
);
1884 if (fmode
& O_EVTONLY
) {
1885 if (--vp
->v_kusecount
< 0)
1886 panic("vnode_rele_ext: vp %p kusecount -ve : %d. v_tag = %d, v_type = %d, v_flag = %x.", vp
, vp
->v_kusecount
, vp
->v_tag
, vp
->v_type
, vp
->v_flag
);
1888 if (vp
->v_kusecount
> vp
->v_usecount
)
1889 panic("vnode_rele_ext: vp %p kusecount(%d) out of balance with usecount(%d). v_tag = %d, v_type = %d, v_flag = %x.",vp
, vp
->v_kusecount
, vp
->v_usecount
, vp
->v_tag
, vp
->v_type
, vp
->v_flag
);
1891 if ((vp
->v_iocount
> 0) || (vp
->v_usecount
> 0)) {
1893 * vnode is still busy... if we're the last
1894 * usecount, mark for a future call to VNOP_INACTIVE
1895 * when the iocount finally drops to 0
1897 if (vp
->v_usecount
== 0) {
1898 vp
->v_lflag
|= VL_NEEDINACTIVE
;
1899 vp
->v_flag
&= ~(VNOCACHE_DATA
| VRAOFF
| VOPENEVT
);
1903 vp
->v_flag
&= ~(VNOCACHE_DATA
| VRAOFF
| VOPENEVT
);
1905 if (ISSET(vp
->v_lflag
, VL_TERMINATE
| VL_DEAD
) || dont_reenter
) {
1907 * vnode is being cleaned, or
1908 * we've requested that we don't reenter
1909 * the filesystem on this release...in
1910 * the latter case, we'll mark the vnode aged
1913 if ( !(vp
->v_lflag
& (VL_TERMINATE
| VL_DEAD
| VL_MARKTERM
)) ) {
1914 vp
->v_lflag
|= VL_NEEDINACTIVE
;
1916 if (vnode_on_reliable_media(vp
) == FALSE
|| vp
->v_flag
& VISDIRTY
) {
1917 vnode_async_list_add(vp
);
1928 * at this point both the iocount and usecount
1930 * pick up an iocount so that we can call
1931 * VNOP_INACTIVE with the vnode lock unheld
1937 vp
->v_lflag
&= ~VL_NEEDINACTIVE
;
1940 VNOP_INACTIVE(vp
, vfs_context_current());
1942 vnode_lock_spin(vp
);
1944 * because we dropped the vnode lock to call VNOP_INACTIVE
1945 * the state of the vnode may have changed... we may have
1946 * picked up an iocount, usecount or the MARKTERM may have
1947 * been set... we need to reevaluate the reference counts
1948 * to determine if we can call vnode_reclaim_internal at
1949 * this point... if the reference counts are up, we'll pick
1950 * up the MARKTERM state when they get subsequently dropped
1952 if ( (vp
->v_iocount
== 1) && (vp
->v_usecount
== 0) &&
1953 ((vp
->v_lflag
& (VL_MARKTERM
| VL_TERMINATE
| VL_DEAD
)) == VL_MARKTERM
)) {
1956 ut
= get_bsdthread_info(current_thread());
1958 if (ut
->uu_defer_reclaims
) {
1959 vp
->v_defer_reclaimlist
= ut
->uu_vreclaims
;
1960 ut
->uu_vreclaims
= vp
;
1963 vnode_lock_convert(vp
);
1964 vnode_reclaim_internal(vp
, 1, 1, 0);
1966 vnode_dropiocount(vp
);
1969 if (vp
->v_usecount
== 0 && vp
->v_type
== VREG
&& !(vp
->v_flag
& VSYSTEM
)) {
1971 if (vp
->v_ubcinfo
) {
1972 vnode_lock_convert(vp
);
1973 memory_object_mark_unused(vp
->v_ubcinfo
->ui_control
, (vp
->v_flag
& VRAGE
) == VRAGE
);
1982 * Remove any vnodes in the vnode table belonging to mount point mp.
1984 * If MNT_NOFORCE is specified, there should not be any active ones,
1985 * return error if any are found (nb: this is a user error, not a
1986 * system error). If MNT_FORCE is specified, detach any active vnodes
1990 int busyprt
= 0; /* print out busy vnodes */
1994 vflush(struct mount
*mp
, struct vnode
*skipvp
, int flags
)
2003 vnode_iterate_setup(mp
);
2005 * On regular unmounts(not forced) do a
2006 * quick check for vnodes to be in use. This
2007 * preserves the caching of vnodes. automounter
2008 * tries unmounting every so often to see whether
2009 * it is still busy or not.
2011 if (((flags
& FORCECLOSE
)==0) && ((mp
->mnt_kern_flag
& MNTK_UNMOUNT_PREFLIGHT
) != 0)) {
2012 if (vnode_umount_preflight(mp
, skipvp
, flags
)) {
2013 vnode_iterate_clear(mp
);
2019 /* it is returns 0 then there is nothing to do */
2020 retval
= vnode_iterate_prepare(mp
);
2023 vnode_iterate_clear(mp
);
2028 /* iterate over all the vnodes */
2029 while (!TAILQ_EMPTY(&mp
->mnt_workerqueue
)) {
2031 vp
= TAILQ_FIRST(&mp
->mnt_workerqueue
);
2032 TAILQ_REMOVE(&mp
->mnt_workerqueue
, vp
, v_mntvnodes
);
2033 TAILQ_INSERT_TAIL(&mp
->mnt_vnodelist
, vp
, v_mntvnodes
);
2035 if ( (vp
->v_mount
!= mp
) || (vp
== skipvp
)) {
2041 vnode_lock_spin(vp
);
2043 // If vnode is already terminating, wait for it...
2044 while (vp
->v_id
== vid
&& ISSET(vp
->v_lflag
, VL_TERMINATE
)) {
2045 vp
->v_lflag
|= VL_TERMWANT
;
2046 msleep(&vp
->v_lflag
, &vp
->v_lock
, PVFS
, "vflush", NULL
);
2049 if ((vp
->v_id
!= vid
) || ISSET(vp
->v_lflag
, VL_DEAD
)) {
2056 * If requested, skip over vnodes marked VSYSTEM.
2057 * Skip over all vnodes marked VNOFLUSH.
2059 if ((flags
& SKIPSYSTEM
) && ((vp
->v_flag
& VSYSTEM
) ||
2060 (vp
->v_flag
& VNOFLUSH
))) {
2066 * If requested, skip over vnodes marked VSWAP.
2068 if ((flags
& SKIPSWAP
) && (vp
->v_flag
& VSWAP
)) {
2074 * If requested, skip over vnodes marked VROOT.
2076 if ((flags
& SKIPROOT
) && (vp
->v_flag
& VROOT
)) {
2082 * If WRITECLOSE is set, only flush out regular file
2083 * vnodes open for writing.
2085 if ((flags
& WRITECLOSE
) &&
2086 (vp
->v_writecount
== 0 || vp
->v_type
!= VREG
)) {
2092 * If the real usecount is 0, all we need to do is clear
2093 * out the vnode data structures and we are done.
2095 if (((vp
->v_usecount
== 0) ||
2096 ((vp
->v_usecount
- vp
->v_kusecount
) == 0))) {
2098 vnode_lock_convert(vp
);
2099 vp
->v_iocount
++; /* so that drain waits for * other iocounts */
2103 vnode_reclaim_internal(vp
, 1, 1, 0);
2104 vnode_dropiocount(vp
);
2113 * If FORCECLOSE is set, forcibly close the vnode.
2114 * For block or character devices, revert to an
2115 * anonymous device. For all other files, just kill them.
2117 if (flags
& FORCECLOSE
) {
2118 vnode_lock_convert(vp
);
2120 if (vp
->v_type
!= VBLK
&& vp
->v_type
!= VCHR
) {
2121 vp
->v_iocount
++; /* so that drain waits * for other iocounts */
2125 vnode_abort_advlocks(vp
);
2126 vnode_reclaim_internal(vp
, 1, 1, 0);
2127 vnode_dropiocount(vp
);
2132 vp
->v_lflag
&= ~VL_DEAD
;
2133 vp
->v_op
= spec_vnodeop_p
;
2134 vp
->v_flag
|= VDEVFLUSH
;
2142 vprint("vflush: busy vnode", vp
);
2149 /* At this point the worker queue is completed */
2150 if (busy
&& ((flags
& FORCECLOSE
)==0) && reclaimed
) {
2153 (void)vnode_iterate_reloadq(mp
);
2154 /* returned with mount lock held */
2158 /* if new vnodes were created in between retry the reclaim */
2159 if ( vnode_iterate_reloadq(mp
) != 0) {
2160 if (!(busy
&& ((flags
& FORCECLOSE
)==0)))
2163 vnode_iterate_clear(mp
);
2166 if (busy
&& ((flags
& FORCECLOSE
)==0))
2171 long num_recycledvnodes
= 0;
2173 * Disassociate the underlying file system from a vnode.
2174 * The vnode lock is held on entry.
2177 vclean(vnode_t vp
, int flags
)
2179 vfs_context_t ctx
= vfs_context_current();
2182 int already_terminating
;
2189 * Check to see if the vnode is in use.
2190 * If so we have to reference it before we clean it out
2191 * so that its count cannot fall to zero and generate a
2192 * race against ourselves to recycle it.
2194 active
= vp
->v_usecount
;
2197 * just in case we missed sending a needed
2198 * VNOP_INACTIVE, we'll do it now
2200 need_inactive
= (vp
->v_lflag
& VL_NEEDINACTIVE
);
2202 vp
->v_lflag
&= ~VL_NEEDINACTIVE
;
2205 * Prevent the vnode from being recycled or
2206 * brought into use while we clean it out.
2208 already_terminating
= (vp
->v_lflag
& VL_TERMINATE
);
2210 vp
->v_lflag
|= VL_TERMINATE
;
2213 is_namedstream
= vnode_isnamedstream(vp
);
2218 OSAddAtomicLong(1, &num_recycledvnodes
);
2220 if (flags
& DOCLOSE
)
2221 clflags
|= IO_NDELAY
;
2222 if (flags
& REVOKEALL
)
2223 clflags
|= IO_REVOKE
;
2225 if (active
&& (flags
& DOCLOSE
))
2226 VNOP_CLOSE(vp
, clflags
, ctx
);
2229 * Clean out any buffers associated with the vnode.
2231 if (flags
& DOCLOSE
) {
2233 if (vp
->v_tag
== VT_NFS
)
2234 nfs_vinvalbuf(vp
, V_SAVE
, ctx
, 0);
2238 VNOP_FSYNC(vp
, MNT_WAIT
, ctx
);
2241 * If the vnode is still in use (by the journal for
2242 * example) we don't want to invalidate locked buffers
2243 * here. In that case, either the journal will tidy them
2244 * up, or we will deal with it when the usecount is
2245 * finally released in vnode_rele_internal.
2247 buf_invalidateblks(vp
, BUF_WRITE_DATA
| (active
? 0 : BUF_INVALIDATE_LOCKED
), 0, 0);
2249 if (UBCINFOEXISTS(vp
))
2251 * Clean the pages in VM.
2253 (void)ubc_msync(vp
, (off_t
)0, ubc_getsize(vp
), NULL
, UBC_PUSHALL
| UBC_INVALIDATE
| UBC_SYNC
);
2255 if (active
|| need_inactive
)
2256 VNOP_INACTIVE(vp
, ctx
);
2259 if ((is_namedstream
!= 0) && (vp
->v_parent
!= NULLVP
)) {
2260 vnode_t pvp
= vp
->v_parent
;
2262 /* Delete the shadow stream file before we reclaim its vnode */
2263 if (vnode_isshadow(vp
)) {
2264 vnode_relenamedstream(pvp
, vp
);
2268 * No more streams associated with the parent. We
2269 * have a ref on it, so its identity is stable.
2270 * If the parent is on an opaque volume, then we need to know
2271 * whether it has associated named streams.
2273 if (vfs_authopaque(pvp
->v_mount
)) {
2274 vnode_lock_spin(pvp
);
2275 pvp
->v_lflag
&= ~VL_HASSTREAMS
;
2282 * Destroy ubc named reference
2283 * cluster_release is done on this path
2284 * along with dropping the reference on the ucred
2285 * (and in the case of forced unmount of an mmap-ed file,
2286 * the ubc reference on the vnode is dropped here too).
2288 ubc_destroy_named(vp
);
2292 * cleanup trigger info from vnode (if any)
2295 vnode_resolver_detach(vp
);
2299 * Reclaim the vnode.
2301 if (VNOP_RECLAIM(vp
, ctx
))
2302 panic("vclean: cannot reclaim");
2304 // make sure the name & parent ptrs get cleaned out!
2305 vnode_update_identity(vp
, NULLVP
, NULL
, 0, 0, VNODE_UPDATE_PARENT
| VNODE_UPDATE_NAME
| VNODE_UPDATE_PURGE
);
2310 * Remove the vnode from any mount list it might be on. It is not
2311 * safe to do this any earlier because unmount needs to wait for
2312 * any vnodes to terminate and it cannot do that if it cannot find
2315 insmntque(vp
, (struct mount
*)0);
2317 vp
->v_mount
= dead_mountp
;
2318 vp
->v_op
= dead_vnodeop_p
;
2322 vp
->v_lflag
|= VL_DEAD
;
2323 vp
->v_flag
&= ~VISDIRTY
;
2325 if (already_terminating
== 0) {
2326 vp
->v_lflag
&= ~VL_TERMINATE
;
2328 * Done with purge, notify sleepers of the grim news.
2330 if (vp
->v_lflag
& VL_TERMWANT
) {
2331 vp
->v_lflag
&= ~VL_TERMWANT
;
2332 wakeup(&vp
->v_lflag
);
2338 * Eliminate all activity associated with the requested vnode
2339 * and with all vnodes aliased to the requested vnode.
2343 vn_revoke(vnode_t vp
, int flags
, __unused vfs_context_t a_context
)
2345 vn_revoke(vnode_t vp
, __unused
int flags
, __unused vfs_context_t a_context
)
2352 if ((flags
& REVOKEALL
) == 0)
2353 panic("vnop_revoke");
2356 if (vnode_isaliased(vp
)) {
2358 * If a vgone (or vclean) is already in progress,
2359 * return an immediate error
2361 if (vp
->v_lflag
& VL_TERMINATE
)
2365 * Ensure that vp will not be vgone'd while we
2366 * are eliminating its aliases.
2369 while ((vp
->v_specflags
& SI_ALIASED
)) {
2370 for (vq
= *vp
->v_hashchain
; vq
; vq
= vq
->v_specnext
) {
2371 if (vq
->v_rdev
!= vp
->v_rdev
||
2372 vq
->v_type
!= vp
->v_type
|| vp
== vq
)
2376 if (vnode_getwithvid(vq
,vid
)){
2381 if (!(vq
->v_lflag
& VL_TERMINATE
)) {
2382 vnode_reclaim_internal(vq
, 1, 1, 0);
2384 vnode_put_locked(vq
);
2393 if (vp
->v_lflag
& VL_TERMINATE
) {
2397 vnode_reclaim_internal(vp
, 1, 0, REVOKEALL
);
2404 * Recycle an unused vnode to the front of the free list.
2405 * Release the passed interlock if the vnode will be recycled.
2408 vnode_recycle(struct vnode
*vp
)
2410 vnode_lock_spin(vp
);
2412 if (vp
->v_iocount
|| vp
->v_usecount
) {
2413 vp
->v_lflag
|= VL_MARKTERM
;
2417 vnode_lock_convert(vp
);
2418 vnode_reclaim_internal(vp
, 1, 0, 0);
2426 vnode_reload(vnode_t vp
)
2428 vnode_lock_spin(vp
);
2430 if ((vp
->v_iocount
> 1) || vp
->v_usecount
) {
2434 if (vp
->v_iocount
<= 0)
2435 panic("vnode_reload with no iocount %d", vp
->v_iocount
);
2437 /* mark for release when iocount is dopped */
2438 vp
->v_lflag
|= VL_MARKTERM
;
2446 vgone(vnode_t vp
, int flags
)
2452 * Clean out the filesystem specific data.
2453 * vclean also takes care of removing the
2454 * vnode from any mount list it might be on
2456 vclean(vp
, flags
| DOCLOSE
);
2459 * If special device, remove it from special device alias list
2462 if ((vp
->v_type
== VBLK
|| vp
->v_type
== VCHR
) && vp
->v_specinfo
!= 0) {
2464 if (*vp
->v_hashchain
== vp
) {
2465 *vp
->v_hashchain
= vp
->v_specnext
;
2467 for (vq
= *vp
->v_hashchain
; vq
; vq
= vq
->v_specnext
) {
2468 if (vq
->v_specnext
!= vp
)
2470 vq
->v_specnext
= vp
->v_specnext
;
2474 panic("missing bdev");
2476 if (vp
->v_specflags
& SI_ALIASED
) {
2478 for (vq
= *vp
->v_hashchain
; vq
; vq
= vq
->v_specnext
) {
2479 if (vq
->v_rdev
!= vp
->v_rdev
||
2480 vq
->v_type
!= vp
->v_type
)
2487 panic("missing alias");
2489 vx
->v_specflags
&= ~SI_ALIASED
;
2490 vp
->v_specflags
&= ~SI_ALIASED
;
2494 struct specinfo
*tmp
= vp
->v_specinfo
;
2495 vp
->v_specinfo
= NULL
;
2496 FREE_ZONE((void *)tmp
, sizeof(struct specinfo
), M_SPECINFO
);
2502 * Lookup a vnode by device number.
2505 check_mountedon(dev_t dev
, enum vtype type
, int *errorp
)
2513 for (vp
= speclisth
[SPECHASH(dev
)]; vp
; vp
= vp
->v_specnext
) {
2514 if (dev
!= vp
->v_rdev
|| type
!= vp
->v_type
)
2518 if (vnode_getwithvid(vp
,vid
))
2520 vnode_lock_spin(vp
);
2521 if ((vp
->v_usecount
> 0) || (vp
->v_iocount
> 1)) {
2523 if ((*errorp
= vfs_mountedon(vp
)) != 0)
2535 * Calculate the total number of references to a special device.
2544 if (!vnode_isspec(vp
)) {
2545 return (vp
->v_usecount
- vp
->v_kusecount
);
2549 if (!vnode_isaliased(vp
))
2550 return (vp
->v_specinfo
->si_opencount
);
2555 * Grab first vnode and its vid.
2557 vq
= *vp
->v_hashchain
;
2558 vid
= vq
? vq
->v_id
: 0;
2564 * Attempt to get the vnode outside the SPECHASH lock.
2566 if (vnode_getwithvid(vq
, vid
)) {
2571 if (vq
->v_rdev
== vp
->v_rdev
&& vq
->v_type
== vp
->v_type
) {
2572 if ((vq
->v_usecount
== 0) && (vq
->v_iocount
== 1) && vq
!= vp
) {
2574 * Alias, but not in use, so flush it out.
2576 vnode_reclaim_internal(vq
, 1, 1, 0);
2577 vnode_put_locked(vq
);
2581 count
+= vq
->v_specinfo
->si_opencount
;
2587 * must do this with the reference still held on 'vq'
2588 * so that it can't be destroyed while we're poking
2589 * through v_specnext
2591 vnext
= vq
->v_specnext
;
2592 vid
= vnext
? vnext
->v_id
: 0;
2604 int prtactive
= 0; /* 1 => print out reclaim of active vnodes */
2607 * Print out a description of a vnode.
2609 static const char *typename
[] =
2610 { "VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD" };
2613 vprint(const char *label
, struct vnode
*vp
)
2618 printf("%s: ", label
);
2619 printf("type %s, usecount %d, writecount %d",
2620 typename
[vp
->v_type
], vp
->v_usecount
, vp
->v_writecount
);
2622 if (vp
->v_flag
& VROOT
)
2623 strlcat(sbuf
, "|VROOT", sizeof(sbuf
));
2624 if (vp
->v_flag
& VTEXT
)
2625 strlcat(sbuf
, "|VTEXT", sizeof(sbuf
));
2626 if (vp
->v_flag
& VSYSTEM
)
2627 strlcat(sbuf
, "|VSYSTEM", sizeof(sbuf
));
2628 if (vp
->v_flag
& VNOFLUSH
)
2629 strlcat(sbuf
, "|VNOFLUSH", sizeof(sbuf
));
2630 if (vp
->v_flag
& VBWAIT
)
2631 strlcat(sbuf
, "|VBWAIT", sizeof(sbuf
));
2632 if (vnode_isaliased(vp
))
2633 strlcat(sbuf
, "|VALIASED", sizeof(sbuf
));
2634 if (sbuf
[0] != '\0')
2635 printf(" flags (%s)", &sbuf
[1]);
2640 vn_getpath(struct vnode
*vp
, char *pathbuf
, int *len
)
2642 return build_path(vp
, pathbuf
, *len
, len
, BUILDPATH_NO_FS_ENTER
, vfs_context_current());
2646 vn_getpath_fsenter(struct vnode
*vp
, char *pathbuf
, int *len
)
2648 return build_path(vp
, pathbuf
, *len
, len
, 0, vfs_context_current());
2652 vn_getcdhash(struct vnode
*vp
, off_t offset
, unsigned char *cdhash
)
2654 return ubc_cs_getcdhash(vp
, offset
, cdhash
);
2658 static char *extension_table
=NULL
;
2660 static int max_ext_width
;
2663 extension_cmp(const void *a
, const void *b
)
2665 return (strlen((const char *)a
) - strlen((const char *)b
));
2670 // This is the api LaunchServices uses to inform the kernel
2671 // the list of package extensions to ignore.
2673 // Internally we keep the list sorted by the length of the
2674 // the extension (from longest to shortest). We sort the
2675 // list of extensions so that we can speed up our searches
2676 // when comparing file names -- we only compare extensions
2677 // that could possibly fit into the file name, not all of
2678 // them (i.e. a short 8 character name can't have an 8
2679 // character extension).
2681 extern lck_mtx_t
*pkg_extensions_lck
;
2683 __private_extern__
int
2684 set_package_extensions_table(user_addr_t data
, int nentries
, int maxwidth
)
2686 char *new_exts
, *old_exts
;
2689 if (nentries
<= 0 || nentries
> 1024 || maxwidth
<= 0 || maxwidth
> 255) {
2694 // allocate one byte extra so we can guarantee null termination
2695 MALLOC(new_exts
, char *, (nentries
* maxwidth
) + 1, M_TEMP
, M_WAITOK
);
2696 if (new_exts
== NULL
) {
2700 error
= copyin(data
, new_exts
, nentries
* maxwidth
);
2702 FREE(new_exts
, M_TEMP
);
2706 new_exts
[(nentries
* maxwidth
)] = '\0'; // guarantee null termination of the block
2708 qsort(new_exts
, nentries
, maxwidth
, extension_cmp
);
2710 lck_mtx_lock(pkg_extensions_lck
);
2712 old_exts
= extension_table
;
2713 extension_table
= new_exts
;
2715 max_ext_width
= maxwidth
;
2717 lck_mtx_unlock(pkg_extensions_lck
);
2720 FREE(old_exts
, M_TEMP
);
2727 int is_package_name(const char *name
, int len
)
2730 const char *ptr
, *name_ext
;
2737 for(ptr
=name
; *ptr
!= '\0'; ptr
++) {
2743 // if there is no "." extension, it can't match
2744 if (name_ext
== NULL
) {
2748 // advance over the "."
2751 lck_mtx_lock(pkg_extensions_lck
);
2753 // now iterate over all the extensions to see if any match
2754 ptr
= &extension_table
[0];
2755 for(i
=0; i
< nexts
; i
++, ptr
+=max_ext_width
) {
2756 extlen
= strlen(ptr
);
2757 if (strncasecmp(name_ext
, ptr
, extlen
) == 0 && name_ext
[extlen
] == '\0') {
2759 lck_mtx_unlock(pkg_extensions_lck
);
2764 lck_mtx_unlock(pkg_extensions_lck
);
2766 // if we get here, no extension matched
2771 vn_path_package_check(__unused vnode_t vp
, char *path
, int pathlen
, int *component
)
2782 while(end
< path
+ pathlen
&& *end
!= '\0') {
2783 while(end
< path
+ pathlen
&& *end
== '/' && *end
!= '\0') {
2789 while(end
< path
+ pathlen
&& *end
!= '/' && *end
!= '\0') {
2793 if (end
> path
+ pathlen
) {
2794 // hmm, string wasn't null terminated
2799 if (is_package_name(ptr
, end
- ptr
)) {
2812 * Determine if a name is inappropriate for a searchfs query.
2813 * This list consists of /System currently.
2816 int vn_searchfs_inappropriate_name(const char *name
, int len
) {
2817 const char *bad_names
[] = { "System" };
2818 int bad_len
[] = { 6 };
2821 for(i
=0; i
< (int) (sizeof(bad_names
) / sizeof(bad_names
[0])); i
++) {
2822 if (len
== bad_len
[i
] && strncmp(name
, bad_names
[i
], strlen(bad_names
[i
]) + 1) == 0) {
2827 // if we get here, no name matched
2832 * Top level filesystem related information gathering.
2834 extern unsigned int vfs_nummntops
;
2837 * The VFS_NUMMNTOPS shouldn't be at name[1] since
2838 * is a VFS generic variable. Since we no longer support
2839 * VT_UFS, we reserve its value to support this sysctl node.
2841 * It should have been:
2842 * name[0]: VFS_GENERIC
2843 * name[1]: VFS_NUMMNTOPS
2845 SYSCTL_INT(_vfs
, VFS_NUMMNTOPS
, nummntops
,
2846 CTLFLAG_RD
| CTLFLAG_KERN
| CTLFLAG_LOCKED
,
2847 &vfs_nummntops
, 0, "");
2850 vfs_sysctl(int *name __unused
, u_int namelen __unused
,
2851 user_addr_t oldp __unused
, size_t *oldlenp __unused
,
2852 user_addr_t newp __unused
, size_t newlen __unused
, proc_t p __unused
);
2855 vfs_sysctl(int *name __unused
, u_int namelen __unused
,
2856 user_addr_t oldp __unused
, size_t *oldlenp __unused
,
2857 user_addr_t newp __unused
, size_t newlen __unused
, proc_t p __unused
)
2864 // The following code disallows specific sysctl's that came through
2865 // the direct sysctl interface (vfs_sysctl_node) instead of the newer
2866 // sysctl_vfs_ctlbyfsid() interface. We can not allow these selectors
2867 // through vfs_sysctl_node() because it passes the user's oldp pointer
2868 // directly to the file system which (for these selectors) casts it
2869 // back to a struct sysctl_req and then proceed to use SYSCTL_IN()
2870 // which jumps through an arbitrary function pointer. When called
2871 // through the sysctl_vfs_ctlbyfsid() interface this does not happen
2872 // and so it's safe.
2874 // Unfortunately we have to pull in definitions from AFP and SMB and
2875 // perform explicit name checks on the file system to determine if
2876 // these selectors are being used.
2879 #define AFPFS_VFS_CTL_GETID 0x00020001
2880 #define AFPFS_VFS_CTL_NETCHANGE 0x00020002
2881 #define AFPFS_VFS_CTL_VOLCHANGE 0x00020003
2883 #define SMBFS_SYSCTL_REMOUNT 1
2884 #define SMBFS_SYSCTL_REMOUNT_INFO 2
2885 #define SMBFS_SYSCTL_GET_SERVER_SHARE 3
2889 is_bad_sysctl_name(struct vfstable
*vfsp
, int selector_name
)
2891 switch(selector_name
) {
2894 case VFS_CTL_NOLOCKS
:
2895 case VFS_CTL_NSTATUS
:
2898 case VFS_CTL_SERVERINFO
:
2905 // the more complicated check for some of SMB's special values
2906 if (strcmp(vfsp
->vfc_name
, "smbfs") == 0) {
2907 switch(selector_name
) {
2908 case SMBFS_SYSCTL_REMOUNT
:
2909 case SMBFS_SYSCTL_REMOUNT_INFO
:
2910 case SMBFS_SYSCTL_GET_SERVER_SHARE
:
2913 } else if (strcmp(vfsp
->vfc_name
, "afpfs") == 0) {
2914 switch(selector_name
) {
2915 case AFPFS_VFS_CTL_GETID
:
2916 case AFPFS_VFS_CTL_NETCHANGE
:
2917 case AFPFS_VFS_CTL_VOLCHANGE
:
2923 // If we get here we passed all the checks so the selector is ok
2929 int vfs_sysctl_node SYSCTL_HANDLER_ARGS
2932 struct vfstable
*vfsp
;
2936 fstypenum
= oidp
->oid_number
;
2940 /* all sysctl names at this level should have at least one name slot for the FS */
2942 return (EISDIR
); /* overloaded */
2945 for (vfsp
= vfsconf
; vfsp
; vfsp
= vfsp
->vfc_next
)
2946 if (vfsp
->vfc_typenum
== fstypenum
) {
2947 vfsp
->vfc_refcount
++;
2950 mount_list_unlock();
2956 if (is_bad_sysctl_name(vfsp
, name
[0])) {
2957 printf("vfs: bad selector 0x%.8x for old-style sysctl(). use the sysctl-by-fsid interface instead\n", name
[0]);
2961 error
= (vfsp
->vfc_vfsops
->vfs_sysctl
)(name
, namelen
, req
->oldptr
, &req
->oldlen
, req
->newptr
, req
->newlen
, vfs_context_current());
2964 vfsp
->vfc_refcount
--;
2965 mount_list_unlock();
2971 * Check to see if a filesystem is mounted on a block device.
2974 vfs_mountedon(struct vnode
*vp
)
2980 if (vp
->v_specflags
& SI_MOUNTEDON
) {
2984 if (vp
->v_specflags
& SI_ALIASED
) {
2985 for (vq
= *vp
->v_hashchain
; vq
; vq
= vq
->v_specnext
) {
2986 if (vq
->v_rdev
!= vp
->v_rdev
||
2987 vq
->v_type
!= vp
->v_type
)
2989 if (vq
->v_specflags
& SI_MOUNTEDON
) {
3000 struct unmount_info
{
3001 int u_errs
; // Total failed unmounts
3002 int u_busy
; // EBUSY failed unmounts
3006 unmount_callback(mount_t mp
, void *arg
)
3010 struct unmount_info
*uip
= arg
;
3013 mount_iterdrop(mp
); // avoid vfs_iterate deadlock in dounmount()
3015 MALLOC_ZONE(mntname
, void *, MAXPATHLEN
, M_NAMEI
, M_WAITOK
);
3017 strlcpy(mntname
, mp
->mnt_vfsstat
.f_mntonname
, MAXPATHLEN
);
3019 error
= dounmount(mp
, MNT_FORCE
, 1, vfs_context_current());
3022 printf("Unmount of %s failed (%d)\n", mntname
? mntname
:"?", error
);
3027 FREE_ZONE(mntname
, MAXPATHLEN
, M_NAMEI
);
3029 return (VFS_RETURNED
);
3033 * Unmount all filesystems. The list is traversed in reverse order
3034 * of mounting to avoid dependencies.
3035 * Busy mounts are retried.
3037 __private_extern__
void
3038 vfs_unmountall(void)
3040 int mounts
, sec
= 1;
3041 struct unmount_info ui
;
3044 ui
.u_errs
= ui
.u_busy
= 0;
3045 vfs_iterate(VFS_ITERATE_CB_DROPREF
| VFS_ITERATE_TAIL_FIRST
, unmount_callback
, &ui
);
3046 mounts
= mount_getvfscnt();
3050 if (ui
.u_busy
> 0) { // Busy mounts - wait & retry
3051 tsleep(&nummounts
, PVFS
, "busy mount", sec
* hz
);
3055 printf("Unmounting timed out\n");
3056 } else if (ui
.u_errs
< mounts
) {
3057 // If the vfs_iterate missed mounts in progress - wait a bit
3058 tsleep(&nummounts
, PVFS
, "missed mount", 2 * hz
);
3063 * This routine is called from vnode_pager_deallocate out of the VM
3064 * The path to vnode_pager_deallocate can only be initiated by ubc_destroy_named
3065 * on a vnode that has a UBCINFO
3067 __private_extern__
void
3068 vnode_pager_vrele(vnode_t vp
)
3070 struct ubc_info
*uip
;
3072 vnode_lock_spin(vp
);
3074 vp
->v_lflag
&= ~VNAMED_UBC
;
3075 if (vp
->v_usecount
!= 0) {
3077 * At the eleventh hour, just before the ubcinfo is
3078 * destroyed, ensure the ubc-specific v_usecount
3079 * reference has gone. We use v_usecount != 0 as a hint;
3080 * ubc_unmap() does nothing if there's no mapping.
3082 * This case is caused by coming here via forced unmount,
3083 * versus the usual vm_object_deallocate() path.
3084 * In the forced unmount case, ubc_destroy_named()
3085 * releases the pager before memory_object_last_unmap()
3090 vnode_lock_spin(vp
);
3093 uip
= vp
->v_ubcinfo
;
3094 vp
->v_ubcinfo
= UBC_INFO_NULL
;
3098 ubc_info_deallocate(uip
);
3102 #include <sys/disk.h>
3104 u_int32_t rootunit
= (u_int32_t
)-1;
3107 extern int lowpri_throttle_enabled
;
3108 extern int iosched_enabled
;
3112 vfs_init_io_attributes(vnode_t devvp
, mount_t mp
)
3115 off_t readblockcnt
= 0;
3116 off_t writeblockcnt
= 0;
3117 off_t readmaxcnt
= 0;
3118 off_t writemaxcnt
= 0;
3119 off_t readsegcnt
= 0;
3120 off_t writesegcnt
= 0;
3121 off_t readsegsize
= 0;
3122 off_t writesegsize
= 0;
3123 off_t alignment
= 0;
3124 u_int32_t minsaturationbytecount
= 0;
3125 u_int32_t ioqueue_depth
= 0;
3129 vfs_context_t ctx
= vfs_context_current();
3130 dk_corestorage_info_t cs_info
;
3131 boolean_t cs_present
= FALSE
;;
3136 VNOP_IOCTL(devvp
, DKIOCGETTHROTTLEMASK
, (caddr_t
)&mp
->mnt_throttle_mask
, 0, NULL
);
3138 * as a reasonable approximation, only use the lowest bit of the mask
3139 * to generate a disk unit number
3141 mp
->mnt_devbsdunit
= num_trailing_0(mp
->mnt_throttle_mask
);
3143 if (devvp
== rootvp
)
3144 rootunit
= mp
->mnt_devbsdunit
;
3146 if (mp
->mnt_devbsdunit
== rootunit
) {
3148 * this mount point exists on the same device as the root
3149 * partition, so it comes under the hard throttle control...
3150 * this is true even for the root mount point itself
3152 mp
->mnt_kern_flag
|= MNTK_ROOTDEV
;
3155 * force the spec device to re-cache
3156 * the underlying block size in case
3157 * the filesystem overrode the initial value
3159 set_fsblocksize(devvp
);
3162 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETBLOCKSIZE
,
3163 (caddr_t
)&blksize
, 0, ctx
)))
3166 mp
->mnt_devblocksize
= blksize
;
3169 * set the maximum possible I/O size
3170 * this may get clipped to a smaller value
3171 * based on which constraints are being advertised
3172 * and if those advertised constraints result in a smaller
3173 * limit for a given I/O
3175 mp
->mnt_maxreadcnt
= MAX_UPL_SIZE_BYTES
;
3176 mp
->mnt_maxwritecnt
= MAX_UPL_SIZE_BYTES
;
3178 if (VNOP_IOCTL(devvp
, DKIOCISVIRTUAL
, (caddr_t
)&isvirtual
, 0, ctx
) == 0) {
3180 mp
->mnt_kern_flag
|= MNTK_VIRTUALDEV
;
3182 if (VNOP_IOCTL(devvp
, DKIOCISSOLIDSTATE
, (caddr_t
)&isssd
, 0, ctx
) == 0) {
3184 mp
->mnt_kern_flag
|= MNTK_SSD
;
3186 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETFEATURES
,
3187 (caddr_t
)&features
, 0, ctx
)))
3190 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETMAXBLOCKCOUNTREAD
,
3191 (caddr_t
)&readblockcnt
, 0, ctx
)))
3194 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETMAXBLOCKCOUNTWRITE
,
3195 (caddr_t
)&writeblockcnt
, 0, ctx
)))
3198 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETMAXBYTECOUNTREAD
,
3199 (caddr_t
)&readmaxcnt
, 0, ctx
)))
3202 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETMAXBYTECOUNTWRITE
,
3203 (caddr_t
)&writemaxcnt
, 0, ctx
)))
3206 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETMAXSEGMENTCOUNTREAD
,
3207 (caddr_t
)&readsegcnt
, 0, ctx
)))
3210 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETMAXSEGMENTCOUNTWRITE
,
3211 (caddr_t
)&writesegcnt
, 0, ctx
)))
3214 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETMAXSEGMENTBYTECOUNTREAD
,
3215 (caddr_t
)&readsegsize
, 0, ctx
)))
3218 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETMAXSEGMENTBYTECOUNTWRITE
,
3219 (caddr_t
)&writesegsize
, 0, ctx
)))
3222 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETMINSEGMENTALIGNMENTBYTECOUNT
,
3223 (caddr_t
)&alignment
, 0, ctx
)))
3226 if ((error
= VNOP_IOCTL(devvp
, DKIOCGETCOMMANDPOOLSIZE
,
3227 (caddr_t
)&ioqueue_depth
, 0, ctx
)))
3231 mp
->mnt_maxreadcnt
= (readmaxcnt
> UINT32_MAX
) ? UINT32_MAX
: readmaxcnt
;
3234 temp
= readblockcnt
* blksize
;
3235 temp
= (temp
> UINT32_MAX
) ? UINT32_MAX
: temp
;
3237 if (temp
< mp
->mnt_maxreadcnt
)
3238 mp
->mnt_maxreadcnt
= (u_int32_t
)temp
;
3242 mp
->mnt_maxwritecnt
= (writemaxcnt
> UINT32_MAX
) ? UINT32_MAX
: writemaxcnt
;
3244 if (writeblockcnt
) {
3245 temp
= writeblockcnt
* blksize
;
3246 temp
= (temp
> UINT32_MAX
) ? UINT32_MAX
: temp
;
3248 if (temp
< mp
->mnt_maxwritecnt
)
3249 mp
->mnt_maxwritecnt
= (u_int32_t
)temp
;
3253 temp
= (readsegcnt
> UINT16_MAX
) ? UINT16_MAX
: readsegcnt
;
3255 temp
= mp
->mnt_maxreadcnt
/ PAGE_SIZE
;
3257 if (temp
> UINT16_MAX
)
3260 mp
->mnt_segreadcnt
= (u_int16_t
)temp
;
3263 temp
= (writesegcnt
> UINT16_MAX
) ? UINT16_MAX
: writesegcnt
;
3265 temp
= mp
->mnt_maxwritecnt
/ PAGE_SIZE
;
3267 if (temp
> UINT16_MAX
)
3270 mp
->mnt_segwritecnt
= (u_int16_t
)temp
;
3273 temp
= (readsegsize
> UINT32_MAX
) ? UINT32_MAX
: readsegsize
;
3275 temp
= mp
->mnt_maxreadcnt
;
3276 mp
->mnt_maxsegreadsize
= (u_int32_t
)temp
;
3279 temp
= (writesegsize
> UINT32_MAX
) ? UINT32_MAX
: writesegsize
;
3281 temp
= mp
->mnt_maxwritecnt
;
3282 mp
->mnt_maxsegwritesize
= (u_int32_t
)temp
;
3285 temp
= (alignment
> PAGE_SIZE
) ? PAGE_MASK
: alignment
- 1;
3288 mp
->mnt_alignmentmask
= temp
;
3291 if (ioqueue_depth
> MNT_DEFAULT_IOQUEUE_DEPTH
)
3292 temp
= ioqueue_depth
;
3294 temp
= MNT_DEFAULT_IOQUEUE_DEPTH
;
3296 mp
->mnt_ioqueue_depth
= temp
;
3297 mp
->mnt_ioscale
= (mp
->mnt_ioqueue_depth
+ (MNT_DEFAULT_IOQUEUE_DEPTH
- 1)) / MNT_DEFAULT_IOQUEUE_DEPTH
;
3299 if (mp
->mnt_ioscale
> 1)
3300 printf("ioqueue_depth = %d, ioscale = %d\n", (int)mp
->mnt_ioqueue_depth
, (int)mp
->mnt_ioscale
);
3302 if (features
& DK_FEATURE_FORCE_UNIT_ACCESS
)
3303 mp
->mnt_ioflags
|= MNT_IOFLAGS_FUA_SUPPORTED
;
3305 if (VNOP_IOCTL(devvp
, DKIOCGETIOMINSATURATIONBYTECOUNT
, (caddr_t
)&minsaturationbytecount
, 0, ctx
) == 0) {
3306 mp
->mnt_minsaturationbytecount
= minsaturationbytecount
;
3308 mp
->mnt_minsaturationbytecount
= 0;
3311 if (VNOP_IOCTL(devvp
, DKIOCCORESTORAGE
, (caddr_t
)&cs_info
, 0, ctx
) == 0)
3314 if (features
& DK_FEATURE_UNMAP
) {
3315 mp
->mnt_ioflags
|= MNT_IOFLAGS_UNMAP_SUPPORTED
;
3317 if (cs_present
== TRUE
)
3318 mp
->mnt_ioflags
|= MNT_IOFLAGS_CSUNMAP_SUPPORTED
;
3320 if (cs_present
== TRUE
) {
3322 * for now we'll use the following test as a proxy for
3323 * the underlying drive being FUSION in nature
3325 if ((cs_info
.flags
& DK_CORESTORAGE_PIN_YOUR_METADATA
))
3326 mp
->mnt_ioflags
|= MNT_IOFLAGS_FUSION_DRIVE
;
3330 if (iosched_enabled
&& (features
& DK_FEATURE_PRIORITY
)) {
3331 mp
->mnt_ioflags
|= MNT_IOFLAGS_IOSCHED_SUPPORTED
;
3332 throttle_info_disable_throttle(mp
->mnt_devbsdunit
, (mp
->mnt_ioflags
& MNT_IOFLAGS_FUSION_DRIVE
) != 0);
3334 #endif /* CONFIG_IOSCHED */
3338 static struct klist fs_klist
;
3339 lck_grp_t
*fs_klist_lck_grp
;
3340 lck_mtx_t
*fs_klist_lock
;
3343 vfs_event_init(void)
3346 klist_init(&fs_klist
);
3347 fs_klist_lck_grp
= lck_grp_alloc_init("fs_klist", NULL
);
3348 fs_klist_lock
= lck_mtx_alloc_init(fs_klist_lck_grp
, NULL
);
3352 vfs_event_signal(fsid_t
*fsid
, u_int32_t event
, intptr_t data
)
3354 if (event
== VQ_DEAD
|| event
== VQ_NOTRESP
) {
3355 struct mount
*mp
= vfs_getvfs(fsid
);
3357 mount_lock_spin(mp
);
3359 mp
->mnt_kern_flag
&= ~MNT_LNOTRESP
; // Now responding
3361 mp
->mnt_kern_flag
|= MNT_LNOTRESP
; // Not responding
3366 lck_mtx_lock(fs_klist_lock
);
3367 KNOTE(&fs_klist
, event
);
3368 lck_mtx_unlock(fs_klist_lock
);
3372 * return the number of mounted filesystems.
3375 sysctl_vfs_getvfscnt(void)
3377 return(mount_getvfscnt());
3382 mount_getvfscnt(void)
3388 mount_list_unlock();
3396 mount_fillfsids(fsid_t
*fsidlst
, int count
)
3403 TAILQ_FOREACH(mp
, &mountlist
, mnt_list
) {
3404 if (actual
<= count
) {
3405 fsidlst
[actual
] = mp
->mnt_vfsstat
.f_fsid
;
3409 mount_list_unlock();
3415 * fill in the array of fsid_t's up to a max of 'count', the actual
3416 * number filled in will be set in '*actual'. If there are more fsid_t's
3417 * than room in fsidlst then ENOMEM will be returned and '*actual' will
3418 * have the actual count.
3419 * having *actual filled out even in the error case is depended upon.
3422 sysctl_vfs_getvfslist(fsid_t
*fsidlst
, int count
, int *actual
)
3428 TAILQ_FOREACH(mp
, &mountlist
, mnt_list
) {
3430 if (*actual
<= count
)
3431 fsidlst
[(*actual
) - 1] = mp
->mnt_vfsstat
.f_fsid
;
3433 mount_list_unlock();
3434 return (*actual
<= count
? 0 : ENOMEM
);
3438 sysctl_vfs_vfslist(__unused
struct sysctl_oid
*oidp
, __unused
void *arg1
,
3439 __unused
int arg2
, struct sysctl_req
*req
)
3445 /* This is a readonly node. */
3446 if (req
->newptr
!= USER_ADDR_NULL
)
3449 /* they are querying us so just return the space required. */
3450 if (req
->oldptr
== USER_ADDR_NULL
) {
3451 req
->oldidx
= sysctl_vfs_getvfscnt() * sizeof(fsid_t
);
3456 * Retrieve an accurate count of the amount of space required to copy
3457 * out all the fsids in the system.
3459 space
= req
->oldlen
;
3460 req
->oldlen
= sysctl_vfs_getvfscnt() * sizeof(fsid_t
);
3462 /* they didn't give us enough space. */
3463 if (space
< req
->oldlen
)
3466 MALLOC(fsidlst
, fsid_t
*, req
->oldlen
, M_TEMP
, M_WAITOK
);
3467 if (fsidlst
== NULL
) {
3471 error
= sysctl_vfs_getvfslist(fsidlst
, req
->oldlen
/ sizeof(fsid_t
),
3474 * If we get back ENOMEM, then another mount has been added while we
3475 * slept in malloc above. If this is the case then try again.
3477 if (error
== ENOMEM
) {
3478 FREE(fsidlst
, M_TEMP
);
3479 req
->oldlen
= space
;
3483 error
= SYSCTL_OUT(req
, fsidlst
, actual
* sizeof(fsid_t
));
3485 FREE(fsidlst
, M_TEMP
);
3490 * Do a sysctl by fsid.
3493 sysctl_vfs_ctlbyfsid(__unused
struct sysctl_oid
*oidp
, void *arg1
, int arg2
,
3494 struct sysctl_req
*req
)
3496 union union_vfsidctl vc
;
3498 struct vfsstatfs
*sp
;
3499 int *name
, flags
, namelen
;
3500 int error
=0, gotref
=0;
3501 vfs_context_t ctx
= vfs_context_current();
3502 proc_t p
= req
->p
; /* XXX req->p != current_proc()? */
3503 boolean_t is_64_bit
;
3507 is_64_bit
= proc_is64bit(p
);
3509 error
= SYSCTL_IN(req
, &vc
, is_64_bit
? sizeof(vc
.vc64
):sizeof(vc
.vc32
));
3512 if (vc
.vc32
.vc_vers
!= VFS_CTL_VERS1
) { /* works for 32 and 64 */
3516 mp
= mount_list_lookupby_fsid(&vc
.vc32
.vc_fsid
, 0, 1); /* works for 32 and 64 */
3522 /* reset so that the fs specific code can fetch it. */
3525 * Note if this is a VFS_CTL then we pass the actual sysctl req
3526 * in for "oldp" so that the lower layer can DTRT and use the
3527 * SYSCTL_IN/OUT routines.
3529 if (mp
->mnt_op
->vfs_sysctl
!= NULL
) {
3531 if (vfs_64bitready(mp
)) {
3532 error
= mp
->mnt_op
->vfs_sysctl(name
, namelen
,
3533 CAST_USER_ADDR_T(req
),
3534 NULL
, USER_ADDR_NULL
, 0,
3542 error
= mp
->mnt_op
->vfs_sysctl(name
, namelen
,
3543 CAST_USER_ADDR_T(req
),
3544 NULL
, USER_ADDR_NULL
, 0,
3547 if (error
!= ENOTSUP
) {
3552 case VFS_CTL_UMOUNT
:
3555 req
->newptr
= vc
.vc64
.vc_ptr
;
3556 req
->newlen
= (size_t)vc
.vc64
.vc_len
;
3559 req
->newptr
= CAST_USER_ADDR_T(vc
.vc32
.vc_ptr
);
3560 req
->newlen
= vc
.vc32
.vc_len
;
3562 error
= SYSCTL_IN(req
, &flags
, sizeof(flags
));
3569 /* safedounmount consumes a ref */
3570 error
= safedounmount(mp
, flags
, ctx
);
3572 case VFS_CTL_STATFS
:
3575 req
->newptr
= vc
.vc64
.vc_ptr
;
3576 req
->newlen
= (size_t)vc
.vc64
.vc_len
;
3579 req
->newptr
= CAST_USER_ADDR_T(vc
.vc32
.vc_ptr
);
3580 req
->newlen
= vc
.vc32
.vc_len
;
3582 error
= SYSCTL_IN(req
, &flags
, sizeof(flags
));
3585 sp
= &mp
->mnt_vfsstat
;
3586 if (((flags
& MNT_NOWAIT
) == 0 || (flags
& (MNT_WAIT
| MNT_DWAIT
))) &&
3587 (error
= vfs_update_vfsstat(mp
, ctx
, VFS_USER_EVENT
)))
3590 struct user64_statfs sfs
;
3591 bzero(&sfs
, sizeof(sfs
));
3592 sfs
.f_flags
= mp
->mnt_flag
& MNT_VISFLAGMASK
;
3593 sfs
.f_type
= mp
->mnt_vtable
->vfc_typenum
;
3594 sfs
.f_bsize
= (user64_long_t
)sp
->f_bsize
;
3595 sfs
.f_iosize
= (user64_long_t
)sp
->f_iosize
;
3596 sfs
.f_blocks
= (user64_long_t
)sp
->f_blocks
;
3597 sfs
.f_bfree
= (user64_long_t
)sp
->f_bfree
;
3598 sfs
.f_bavail
= (user64_long_t
)sp
->f_bavail
;
3599 sfs
.f_files
= (user64_long_t
)sp
->f_files
;
3600 sfs
.f_ffree
= (user64_long_t
)sp
->f_ffree
;
3601 sfs
.f_fsid
= sp
->f_fsid
;
3602 sfs
.f_owner
= sp
->f_owner
;
3604 if (mp
->mnt_kern_flag
& MNTK_TYPENAME_OVERRIDE
) {
3605 strlcpy(&sfs
.f_fstypename
[0], &mp
->fstypename_override
[0], MFSTYPENAMELEN
);
3609 strlcpy(sfs
.f_fstypename
, sp
->f_fstypename
, MFSNAMELEN
);
3611 strlcpy(sfs
.f_mntonname
, sp
->f_mntonname
, MNAMELEN
);
3612 strlcpy(sfs
.f_mntfromname
, sp
->f_mntfromname
, MNAMELEN
);
3614 error
= SYSCTL_OUT(req
, &sfs
, sizeof(sfs
));
3617 struct user32_statfs sfs
;
3618 bzero(&sfs
, sizeof(sfs
));
3619 sfs
.f_flags
= mp
->mnt_flag
& MNT_VISFLAGMASK
;
3620 sfs
.f_type
= mp
->mnt_vtable
->vfc_typenum
;
3623 * It's possible for there to be more than 2^^31 blocks in the filesystem, so we
3624 * have to fudge the numbers here in that case. We inflate the blocksize in order
3625 * to reflect the filesystem size as best we can.
3627 if (sp
->f_blocks
> INT_MAX
) {
3631 * Work out how far we have to shift the block count down to make it fit.
3632 * Note that it's possible to have to shift so far that the resulting
3633 * blocksize would be unreportably large. At that point, we will clip
3634 * any values that don't fit.
3636 * For safety's sake, we also ensure that f_iosize is never reported as
3637 * being smaller than f_bsize.
3639 for (shift
= 0; shift
< 32; shift
++) {
3640 if ((sp
->f_blocks
>> shift
) <= INT_MAX
)
3642 if ((((long long)sp
->f_bsize
) << (shift
+ 1)) > INT_MAX
)
3645 #define __SHIFT_OR_CLIP(x, s) ((((x) >> (s)) > INT_MAX) ? INT_MAX : ((x) >> (s)))
3646 sfs
.f_blocks
= (user32_long_t
)__SHIFT_OR_CLIP(sp
->f_blocks
, shift
);
3647 sfs
.f_bfree
= (user32_long_t
)__SHIFT_OR_CLIP(sp
->f_bfree
, shift
);
3648 sfs
.f_bavail
= (user32_long_t
)__SHIFT_OR_CLIP(sp
->f_bavail
, shift
);
3649 #undef __SHIFT_OR_CLIP
3650 sfs
.f_bsize
= (user32_long_t
)(sp
->f_bsize
<< shift
);
3651 sfs
.f_iosize
= lmax(sp
->f_iosize
, sp
->f_bsize
);
3653 sfs
.f_bsize
= (user32_long_t
)sp
->f_bsize
;
3654 sfs
.f_iosize
= (user32_long_t
)sp
->f_iosize
;
3655 sfs
.f_blocks
= (user32_long_t
)sp
->f_blocks
;
3656 sfs
.f_bfree
= (user32_long_t
)sp
->f_bfree
;
3657 sfs
.f_bavail
= (user32_long_t
)sp
->f_bavail
;
3659 sfs
.f_files
= (user32_long_t
)sp
->f_files
;
3660 sfs
.f_ffree
= (user32_long_t
)sp
->f_ffree
;
3661 sfs
.f_fsid
= sp
->f_fsid
;
3662 sfs
.f_owner
= sp
->f_owner
;
3665 if (mp
->mnt_kern_flag
& MNTK_TYPENAME_OVERRIDE
) {
3666 strlcpy(&sfs
.f_fstypename
[0], &mp
->fstypename_override
[0], MFSTYPENAMELEN
);
3670 strlcpy(sfs
.f_fstypename
, sp
->f_fstypename
, MFSNAMELEN
);
3672 strlcpy(sfs
.f_mntonname
, sp
->f_mntonname
, MNAMELEN
);
3673 strlcpy(sfs
.f_mntfromname
, sp
->f_mntfromname
, MNAMELEN
);
3675 error
= SYSCTL_OUT(req
, &sfs
, sizeof(sfs
));
3688 static int filt_fsattach(struct knote
*kn
);
3689 static void filt_fsdetach(struct knote
*kn
);
3690 static int filt_fsevent(struct knote
*kn
, long hint
);
3691 static int filt_fstouch(struct knote
*kn
, struct kevent_internal_s
*kev
);
3692 static int filt_fsprocess(struct knote
*kn
, struct filt_process_s
*data
, struct kevent_internal_s
*kev
);
3693 struct filterops fs_filtops
= {
3694 .f_attach
= filt_fsattach
,
3695 .f_detach
= filt_fsdetach
,
3696 .f_event
= filt_fsevent
,
3697 .f_touch
= filt_fstouch
,
3698 .f_process
= filt_fsprocess
,
3702 filt_fsattach(struct knote
*kn
)
3704 lck_mtx_lock(fs_klist_lock
);
3705 KNOTE_ATTACH(&fs_klist
, kn
);
3706 lck_mtx_unlock(fs_klist_lock
);
3709 * filter only sees future events,
3710 * so it can't be fired already.
3716 filt_fsdetach(struct knote
*kn
)
3718 lck_mtx_lock(fs_klist_lock
);
3719 KNOTE_DETACH(&fs_klist
, kn
);
3720 lck_mtx_unlock(fs_klist_lock
);
3724 filt_fsevent(struct knote
*kn
, long hint
)
3727 * Backwards compatibility:
3728 * Other filters would do nothing if kn->kn_sfflags == 0
3731 if ((kn
->kn_sfflags
== 0) || (kn
->kn_sfflags
& hint
)) {
3732 kn
->kn_fflags
|= hint
;
3735 return (kn
->kn_fflags
!= 0);
3739 filt_fstouch(struct knote
*kn
, struct kevent_internal_s
*kev
)
3743 lck_mtx_lock(fs_klist_lock
);
3745 kn
->kn_sfflags
= kev
->fflags
;
3746 if ((kn
->kn_status
& KN_UDATA_SPECIFIC
) == 0)
3747 kn
->kn_udata
= kev
->udata
;
3750 * the above filter function sets bits even if nobody is looking for them.
3751 * Just preserve those bits even in the new mask is more selective
3754 * For compatibility with previous implementations, we leave kn_fflags
3755 * as they were before.
3757 //if (kn->kn_sfflags)
3758 // kn->kn_fflags &= kn->kn_sfflags;
3759 res
= (kn
->kn_fflags
!= 0);
3761 lck_mtx_unlock(fs_klist_lock
);
3767 filt_fsprocess(struct knote
*kn
, struct filt_process_s
*data
, struct kevent_internal_s
*kev
)
3769 #pragma unused(data)
3772 lck_mtx_lock(fs_klist_lock
);
3773 res
= (kn
->kn_fflags
!= 0);
3775 *kev
= kn
->kn_kevent
;
3776 kn
->kn_flags
|= EV_CLEAR
; /* automatic */
3780 lck_mtx_unlock(fs_klist_lock
);
3785 sysctl_vfs_noremotehang(__unused
struct sysctl_oid
*oidp
,
3786 __unused
void *arg1
, __unused
int arg2
, struct sysctl_req
*req
)
3792 /* We need a pid. */
3793 if (req
->newptr
== USER_ADDR_NULL
)
3796 error
= SYSCTL_IN(req
, &pid
, sizeof(pid
));
3800 p
= proc_find(pid
< 0 ? -pid
: pid
);
3805 * Fetching the value is ok, but we only fetch if the old
3808 if (req
->oldptr
!= USER_ADDR_NULL
) {
3809 out
= !((p
->p_flag
& P_NOREMOTEHANG
) == 0);
3811 error
= SYSCTL_OUT(req
, &out
, sizeof(out
));
3815 /* cansignal offers us enough security. */
3816 if (p
!= req
->p
&& proc_suser(req
->p
) != 0) {
3822 OSBitAndAtomic(~((uint32_t)P_NOREMOTEHANG
), &p
->p_flag
);
3824 OSBitOrAtomic(P_NOREMOTEHANG
, &p
->p_flag
);
3831 sysctl_vfs_generic_conf SYSCTL_HANDLER_ARGS
3834 struct vfstable
*vfsp
;
3835 struct vfsconf vfsc
;
3843 } else if (namelen
> 1) {
3848 for (vfsp
= vfsconf
; vfsp
; vfsp
= vfsp
->vfc_next
)
3849 if (vfsp
->vfc_typenum
== name
[0])
3853 mount_list_unlock();
3857 vfsc
.vfc_reserved1
= 0;
3858 bcopy(vfsp
->vfc_name
, vfsc
.vfc_name
, sizeof(vfsc
.vfc_name
));
3859 vfsc
.vfc_typenum
= vfsp
->vfc_typenum
;
3860 vfsc
.vfc_refcount
= vfsp
->vfc_refcount
;
3861 vfsc
.vfc_flags
= vfsp
->vfc_flags
;
3862 vfsc
.vfc_reserved2
= 0;
3863 vfsc
.vfc_reserved3
= 0;
3865 mount_list_unlock();
3866 return (SYSCTL_OUT(req
, &vfsc
, sizeof(struct vfsconf
)));
3869 /* the vfs.generic. branch. */
3870 SYSCTL_NODE(_vfs
, VFS_GENERIC
, generic
, CTLFLAG_RW
| CTLFLAG_LOCKED
, NULL
, "vfs generic hinge");
3871 /* retreive a list of mounted filesystem fsid_t */
3872 SYSCTL_PROC(_vfs_generic
, OID_AUTO
, vfsidlist
,
3873 CTLTYPE_STRUCT
| CTLFLAG_RD
| CTLFLAG_LOCKED
,
3874 NULL
, 0, sysctl_vfs_vfslist
, "S,fsid", "List of mounted filesystem ids");
3875 /* perform operations on filesystem via fsid_t */
3876 SYSCTL_NODE(_vfs_generic
, OID_AUTO
, ctlbyfsid
, CTLFLAG_RW
| CTLFLAG_LOCKED
,
3877 sysctl_vfs_ctlbyfsid
, "ctlbyfsid");
3878 SYSCTL_PROC(_vfs_generic
, OID_AUTO
, noremotehang
, CTLFLAG_RW
| CTLFLAG_ANYBODY
,
3879 NULL
, 0, sysctl_vfs_noremotehang
, "I", "noremotehang");
3880 SYSCTL_INT(_vfs_generic
, VFS_MAXTYPENUM
, maxtypenum
,
3881 CTLFLAG_RD
| CTLFLAG_KERN
| CTLFLAG_LOCKED
,
3882 &maxvfstypenum
, 0, "");
3883 SYSCTL_INT(_vfs_generic
, OID_AUTO
, sync_timeout
, CTLFLAG_RW
| CTLFLAG_LOCKED
, &sync_timeout
, 0, "");
3884 SYSCTL_NODE(_vfs_generic
, VFS_CONF
, conf
,
3885 CTLFLAG_RD
| CTLFLAG_LOCKED
,
3886 sysctl_vfs_generic_conf
, "");
3889 * Print vnode state.
3892 vn_print_state(struct vnode
*vp
, const char *fmt
, ...)
3895 char perm_str
[] = "(VM_KERNEL_ADDRPERM pointer)";
3896 char fs_name
[MFSNAMELEN
];
3901 printf("vp 0x%0llx %s: ", (uint64_t)VM_KERNEL_ADDRPERM(vp
), perm_str
);
3902 printf("tag %d, type %d\n", vp
->v_tag
, vp
->v_type
);
3904 printf(" iocount %d, usecount %d, kusecount %d references %d\n",
3905 vp
->v_iocount
, vp
->v_usecount
, vp
->v_kusecount
, vp
->v_references
);
3906 printf(" writecount %d, numoutput %d\n", vp
->v_writecount
,
3909 printf(" flag 0x%x, lflag 0x%x, listflag 0x%x\n", vp
->v_flag
,
3910 vp
->v_lflag
, vp
->v_listflag
);
3912 if (vp
->v_mount
== NULL
|| vp
->v_mount
== dead_mountp
) {
3913 strlcpy(fs_name
, "deadfs", MFSNAMELEN
);
3915 vfs_name(vp
->v_mount
, fs_name
);
3918 printf(" v_data 0x%0llx %s\n",
3919 (vp
->v_data
? (uint64_t)VM_KERNEL_ADDRPERM(vp
->v_data
) : 0),
3921 printf(" v_mount 0x%0llx %s vfs_name %s\n",
3922 (vp
->v_mount
? (uint64_t)VM_KERNEL_ADDRPERM(vp
->v_mount
) : 0),
3926 long num_reusedvnodes
= 0;
3930 process_vp(vnode_t vp
, int want_vp
, int *deferred
)
3938 vnode_list_remove_locked(vp
);
3940 vnode_list_unlock();
3942 vnode_lock_spin(vp
);
3945 * We could wait for the vnode_lock after removing the vp from the freelist
3946 * and the vid is bumped only at the very end of reclaim. So it is possible
3947 * that we are looking at a vnode that is being terminated. If so skip it.
3949 if ((vpid
!= vp
->v_id
) || (vp
->v_usecount
!= 0) || (vp
->v_iocount
!= 0) ||
3950 VONLIST(vp
) || (vp
->v_lflag
& VL_TERMINATE
)) {
3952 * we lost the race between dropping the list lock
3953 * and picking up the vnode_lock... someone else
3954 * used this vnode and it is now in a new state
3960 if ( (vp
->v_lflag
& (VL_NEEDINACTIVE
| VL_MARKTERM
)) == VL_NEEDINACTIVE
) {
3962 * we did a vnode_rele_ext that asked for
3963 * us not to reenter the filesystem during
3964 * the release even though VL_NEEDINACTIVE was
3965 * set... we'll do it here by doing a
3966 * vnode_get/vnode_put
3968 * pick up an iocount so that we can call
3969 * vnode_put and drive the VNOP_INACTIVE...
3970 * vnode_put will either leave us off
3971 * the freelist if a new ref comes in,
3972 * or put us back on the end of the freelist
3973 * or recycle us if we were marked for termination...
3974 * so we'll just go grab a new candidate
3980 vnode_put_locked(vp
);
3986 * Checks for anyone racing us for recycle
3988 if (vp
->v_type
!= VBAD
) {
3989 if (want_vp
&& (vnode_on_reliable_media(vp
) == FALSE
|| (vp
->v_flag
& VISDIRTY
))) {
3990 vnode_async_list_add(vp
);
3997 if (vp
->v_lflag
& VL_DEAD
)
3998 panic("new_vnode(%p): the vnode is VL_DEAD but not VBAD", vp
);
4000 vnode_lock_convert(vp
);
4001 (void)vnode_reclaim_internal(vp
, 1, want_vp
, 0);
4005 panic("new_vnode(%p): vp on list", vp
);
4006 if (vp
->v_usecount
|| vp
->v_iocount
|| vp
->v_kusecount
||
4007 (vp
->v_lflag
& (VNAMED_UBC
| VNAMED_MOUNT
| VNAMED_FSHASH
)))
4008 panic("new_vnode(%p): free vnode still referenced", vp
);
4009 if ((vp
->v_mntvnodes
.tqe_prev
!= 0) && (vp
->v_mntvnodes
.tqe_next
!= 0))
4010 panic("new_vnode(%p): vnode seems to be on mount list", vp
);
4011 if ( !LIST_EMPTY(&vp
->v_nclinks
) || !TAILQ_EMPTY(&vp
->v_ncchildren
))
4012 panic("new_vnode(%p): vnode still hooked into the name cache", vp
);
4021 __attribute__((noreturn
))
4023 async_work_continue(void)
4025 struct async_work_lst
*q
;
4029 q
= &vnode_async_work_list
;
4035 if ( TAILQ_EMPTY(q
) ) {
4036 assert_wait(q
, (THREAD_UNINT
));
4038 vnode_list_unlock();
4040 thread_block((thread_continue_t
)async_work_continue
);
4044 async_work_handled
++;
4046 vp
= TAILQ_FIRST(q
);
4048 vp
= process_vp(vp
, 0, &deferred
);
4051 panic("found VBAD vp (%p) on async queue", vp
);
4057 new_vnode(vnode_t
*vpp
)
4060 uint32_t retries
= 0, max_retries
= 100; /* retry incase of tablefull */
4061 int force_alloc
= 0, walk_count
= 0;
4062 boolean_t need_reliable_vp
= FALSE
;
4064 struct timeval initial_tv
;
4065 struct timeval current_tv
;
4066 proc_t curproc
= current_proc();
4068 initial_tv
.tv_sec
= 0;
4074 if (need_reliable_vp
== TRUE
)
4075 async_work_timed_out
++;
4077 if ((numvnodes
- deadvnodes
) < desiredvnodes
|| force_alloc
) {
4080 if ( !TAILQ_EMPTY(&vnode_dead_list
)) {
4082 * Can always reuse a dead one
4084 vp
= TAILQ_FIRST(&vnode_dead_list
);
4088 * no dead vnodes available... if we're under
4089 * the limit, we'll create a new vnode
4092 vnode_list_unlock();
4094 MALLOC_ZONE(vp
, struct vnode
*, sizeof(*vp
), M_VNODE
, M_WAITOK
);
4095 bzero((char *)vp
, sizeof(*vp
));
4096 VLISTNONE(vp
); /* avoid double queue removal */
4097 lck_mtx_init(&vp
->v_lock
, vnode_lck_grp
, vnode_lck_attr
);
4099 TAILQ_INIT(&vp
->v_ncchildren
);
4101 klist_init(&vp
->v_knotes
);
4103 vp
->v_id
= ts
.tv_nsec
;
4104 vp
->v_flag
= VSTANDARD
;
4107 if (mac_vnode_label_init_needed(vp
))
4108 mac_vnode_label_init(vp
);
4114 microuptime(¤t_tv
);
4116 #define MAX_WALK_COUNT 1000
4118 if ( !TAILQ_EMPTY(&vnode_rage_list
) &&
4119 (ragevnodes
>= rage_limit
||
4120 (current_tv
.tv_sec
- rage_tv
.tv_sec
) >= RAGE_TIME_LIMIT
)) {
4122 TAILQ_FOREACH(vp
, &vnode_rage_list
, v_freelist
) {
4123 if ( !(vp
->v_listflag
& VLIST_RAGE
))
4124 panic("new_vnode: vp (%p) on RAGE list not marked VLIST_RAGE", vp
);
4126 // if we're a dependency-capable process, skip vnodes that can
4127 // cause recycling deadlocks. (i.e. this process is diskimages
4128 // helper and the vnode is in a disk image). Querying the
4129 // mnt_kern_flag for the mount's virtual device status
4130 // is safer than checking the mnt_dependent_process, which
4131 // may not be updated if there are multiple devnode layers
4132 // in between the disk image and the final consumer.
4134 if ((curproc
->p_flag
& P_DEPENDENCY_CAPABLE
) == 0 || vp
->v_mount
== NULL
||
4135 (vp
->v_mount
->mnt_kern_flag
& MNTK_VIRTUALDEV
) == 0) {
4137 * if need_reliable_vp == TRUE, then we've already sent one or more
4138 * non-reliable vnodes to the async thread for processing and timed
4139 * out waiting for a dead vnode to show up. Use the MAX_WALK_COUNT
4140 * mechanism to first scan for a reliable vnode before forcing
4141 * a new vnode to be created
4143 if (need_reliable_vp
== FALSE
|| vnode_on_reliable_media(vp
) == TRUE
)
4147 // don't iterate more than MAX_WALK_COUNT vnodes to
4148 // avoid keeping the vnode list lock held for too long.
4150 if (walk_count
++ > MAX_WALK_COUNT
) {
4157 if (vp
== NULL
&& !TAILQ_EMPTY(&vnode_free_list
)) {
4159 * Pick the first vp for possible reuse
4162 TAILQ_FOREACH(vp
, &vnode_free_list
, v_freelist
) {
4164 // if we're a dependency-capable process, skip vnodes that can
4165 // cause recycling deadlocks. (i.e. this process is diskimages
4166 // helper and the vnode is in a disk image). Querying the
4167 // mnt_kern_flag for the mount's virtual device status
4168 // is safer than checking the mnt_dependent_process, which
4169 // may not be updated if there are multiple devnode layers
4170 // in between the disk image and the final consumer.
4172 if ((curproc
->p_flag
& P_DEPENDENCY_CAPABLE
) == 0 || vp
->v_mount
== NULL
||
4173 (vp
->v_mount
->mnt_kern_flag
& MNTK_VIRTUALDEV
) == 0) {
4175 * if need_reliable_vp == TRUE, then we've already sent one or more
4176 * non-reliable vnodes to the async thread for processing and timed
4177 * out waiting for a dead vnode to show up. Use the MAX_WALK_COUNT
4178 * mechanism to first scan for a reliable vnode before forcing
4179 * a new vnode to be created
4181 if (need_reliable_vp
== FALSE
|| vnode_on_reliable_media(vp
) == TRUE
)
4185 // don't iterate more than MAX_WALK_COUNT vnodes to
4186 // avoid keeping the vnode list lock held for too long.
4188 if (walk_count
++ > MAX_WALK_COUNT
) {
4196 // if we don't have a vnode and the walk_count is >= MAX_WALK_COUNT
4197 // then we're trying to create a vnode on behalf of a
4198 // process like diskimages-helper that has file systems
4199 // mounted on top of itself (and thus we can't reclaim
4200 // vnodes in the file systems on top of us). if we can't
4201 // find a vnode to reclaim then we'll just have to force
4204 if (vp
== NULL
&& walk_count
>= MAX_WALK_COUNT
) {
4206 vnode_list_unlock();
4212 * we've reached the system imposed maximum number of vnodes
4213 * but there isn't a single one available
4214 * wait a bit and then retry... if we can't get a vnode
4215 * after our target number of retries, than log a complaint
4217 if (++retries
<= max_retries
) {
4218 vnode_list_unlock();
4219 delay_for_interval(1, 1000 * 1000);
4223 vnode_list_unlock();
4225 log(LOG_EMERG
, "%d desired, %d numvnodes, "
4226 "%d free, %d dead, %d async, %d rage\n",
4227 desiredvnodes
, numvnodes
, freevnodes
, deadvnodes
, async_work_vnodes
, ragevnodes
);
4230 #if DEVELOPMENT || DEBUG
4231 if (bootarg_no_vnode_jetsam
)
4232 panic("vnode table is full\n");
4233 #endif /* DEVELOPMENT || DEBUG */
4236 * Running out of vnodes tends to make a system unusable. Start killing
4237 * processes that jetsam knows are killable.
4239 if (memorystatus_kill_on_vnode_limit() == FALSE
) {
4241 * If jetsam can't find any more processes to kill and there
4242 * still aren't any free vnodes, panic. Hopefully we'll get a
4243 * panic log to tell us why we ran out.
4245 panic("vnode table is full\n");
4249 * Now that we've killed someone, wait a bit and continue looking
4250 * (with fewer retries before trying another kill).
4252 delay_for_interval(3, 1000 * 1000);
4262 if ((vp
= process_vp(vp
, 1, &deferred
)) == NULLVP
) {
4265 struct timeval elapsed_tv
;
4267 if (initial_tv
.tv_sec
== 0)
4268 microuptime(&initial_tv
);
4272 dead_vnode_waited
++;
4273 dead_vnode_wanted
++;
4276 * note that we're only going to explicitly wait 10ms
4277 * for a dead vnode to become available, since even if one
4278 * isn't available, a reliable vnode might now be available
4279 * at the head of the VRAGE or free lists... if so, we
4280 * can satisfy the new_vnode request with less latency then waiting
4281 * for the full 100ms duration we're ultimately willing to tolerate
4283 assert_wait_timeout((caddr_t
)&dead_vnode_wanted
, (THREAD_INTERRUPTIBLE
), 10000, NSEC_PER_USEC
);
4285 vnode_list_unlock();
4287 thread_block(THREAD_CONTINUE_NULL
);
4289 microuptime(&elapsed_tv
);
4291 timevalsub(&elapsed_tv
, &initial_tv
);
4292 elapsed_msecs
= elapsed_tv
.tv_sec
* 1000 + elapsed_tv
.tv_usec
/ 1000;
4294 if (elapsed_msecs
>= 100) {
4296 * we've waited long enough... 100ms is
4297 * somewhat arbitrary for this case, but the
4298 * normal worst case latency used for UI
4299 * interaction is 100ms, so I've chosen to
4302 * setting need_reliable_vp to TRUE
4303 * forces us to find a reliable vnode
4304 * that we can process synchronously, or
4305 * to create a new one if the scan for
4306 * a reliable one hits the scan limit
4308 need_reliable_vp
= TRUE
;
4313 OSAddAtomicLong(1, &num_reusedvnodes
);
4318 * We should never see VL_LABELWAIT or VL_LABEL here.
4319 * as those operations hold a reference.
4321 assert ((vp
->v_lflag
& VL_LABELWAIT
) != VL_LABELWAIT
);
4322 assert ((vp
->v_lflag
& VL_LABEL
) != VL_LABEL
);
4323 if (vp
->v_lflag
& VL_LABELED
) {
4324 vnode_lock_convert(vp
);
4325 mac_vnode_label_recycle(vp
);
4326 } else if (mac_vnode_label_init_needed(vp
)) {
4327 vnode_lock_convert(vp
);
4328 mac_vnode_label_init(vp
);
4335 vp
->v_writecount
= 0;
4336 vp
->v_references
= 0;
4337 vp
->v_iterblkflags
= 0;
4338 vp
->v_flag
= VSTANDARD
;
4339 /* vbad vnodes can point to dead_mountp */
4341 vp
->v_defer_reclaimlist
= (vnode_t
)0;
4352 vnode_lock(vnode_t vp
)
4354 lck_mtx_lock(&vp
->v_lock
);
4358 vnode_lock_spin(vnode_t vp
)
4360 lck_mtx_lock_spin(&vp
->v_lock
);
4364 vnode_unlock(vnode_t vp
)
4366 lck_mtx_unlock(&vp
->v_lock
);
4372 vnode_get(struct vnode
*vp
)
4376 vnode_lock_spin(vp
);
4377 retval
= vnode_get_locked(vp
);
4384 vnode_get_locked(struct vnode
*vp
)
4387 lck_mtx_assert(&vp
->v_lock
, LCK_MTX_ASSERT_OWNED
);
4389 if ((vp
->v_iocount
== 0) && (vp
->v_lflag
& (VL_TERMINATE
| VL_DEAD
))) {
4400 * vnode_getwithvid() cuts in line in front of a vnode drain (that is,
4401 * while the vnode is draining, but at no point after that) to prevent
4402 * deadlocks when getting vnodes from filesystem hashes while holding
4403 * resources that may prevent other iocounts from being released.
4406 vnode_getwithvid(vnode_t vp
, uint32_t vid
)
4408 return(vget_internal(vp
, vid
, ( VNODE_NODEAD
| VNODE_WITHID
| VNODE_DRAINO
)));
4412 * vnode_getwithvid_drainok() is like vnode_getwithvid(), but *does* block behind a vnode
4413 * drain; it exists for use in the VFS name cache, where we really do want to block behind
4414 * vnode drain to prevent holding off an unmount.
4417 vnode_getwithvid_drainok(vnode_t vp
, uint32_t vid
)
4419 return(vget_internal(vp
, vid
, ( VNODE_NODEAD
| VNODE_WITHID
)));
4423 vnode_getwithref(vnode_t vp
)
4425 return(vget_internal(vp
, 0, 0));
4429 __private_extern__
int
4430 vnode_getalways(vnode_t vp
)
4432 return(vget_internal(vp
, 0, VNODE_ALWAYS
));
4436 vnode_put(vnode_t vp
)
4440 vnode_lock_spin(vp
);
4441 retval
= vnode_put_locked(vp
);
4448 vn_set_dead(vnode_t vp
)
4451 vp
->v_op
= dead_vnodeop_p
;
4455 vp
->v_lflag
|= VL_DEAD
;
4459 vnode_put_locked(vnode_t vp
)
4461 vfs_context_t ctx
= vfs_context_current(); /* hoist outside loop */
4464 lck_mtx_assert(&vp
->v_lock
, LCK_MTX_ASSERT_OWNED
);
4467 if (vp
->v_iocount
< 1)
4468 panic("vnode_put(%p): iocount < 1", vp
);
4470 if ((vp
->v_usecount
> 0) || (vp
->v_iocount
> 1)) {
4471 vnode_dropiocount(vp
);
4474 if ((vp
->v_lflag
& (VL_DEAD
| VL_NEEDINACTIVE
)) == VL_NEEDINACTIVE
) {
4476 vp
->v_lflag
&= ~VL_NEEDINACTIVE
;
4479 VNOP_INACTIVE(vp
, ctx
);
4481 vnode_lock_spin(vp
);
4483 * because we had to drop the vnode lock before calling
4484 * VNOP_INACTIVE, the state of this vnode may have changed...
4485 * we may pick up both VL_MARTERM and either
4486 * an iocount or a usecount while in the VNOP_INACTIVE call
4487 * we don't want to call vnode_reclaim_internal on a vnode
4488 * that has active references on it... so loop back around
4489 * and reevaluate the state
4493 vp
->v_lflag
&= ~VL_NEEDINACTIVE
;
4495 if ((vp
->v_lflag
& (VL_MARKTERM
| VL_TERMINATE
| VL_DEAD
)) == VL_MARKTERM
) {
4496 vnode_lock_convert(vp
);
4497 vnode_reclaim_internal(vp
, 1, 1, 0);
4499 vnode_dropiocount(vp
);
4505 /* is vnode_t in use by others? */
4507 vnode_isinuse(vnode_t vp
, int refcnt
)
4509 return(vnode_isinuse_locked(vp
, refcnt
, 0));
4512 int vnode_usecount(vnode_t vp
)
4514 return vp
->v_usecount
;
4517 int vnode_iocount(vnode_t vp
)
4519 return vp
->v_iocount
;
4523 vnode_isinuse_locked(vnode_t vp
, int refcnt
, int locked
)
4528 vnode_lock_spin(vp
);
4529 if ((vp
->v_type
!= VREG
) && ((vp
->v_usecount
- vp
->v_kusecount
) > refcnt
)) {
4533 if (vp
->v_type
== VREG
) {
4534 retval
= ubc_isinuse_locked(vp
, refcnt
, 1);
4544 /* resume vnode_t */
4546 vnode_resume(vnode_t vp
)
4548 if ((vp
->v_lflag
& VL_SUSPENDED
) && vp
->v_owner
== current_thread()) {
4550 vnode_lock_spin(vp
);
4551 vp
->v_lflag
&= ~VL_SUSPENDED
;
4555 wakeup(&vp
->v_iocount
);
4561 * Please do not use on more than one vnode at a time as it may
4563 * xxx should we explicity prevent this from happening?
4567 vnode_suspend(vnode_t vp
)
4569 if (vp
->v_lflag
& VL_SUSPENDED
) {
4573 vnode_lock_spin(vp
);
4576 * xxx is this sufficient to check if a vnode_drain is
4580 if (vp
->v_owner
== NULL
) {
4581 vp
->v_lflag
|= VL_SUSPENDED
;
4582 vp
->v_owner
= current_thread();
4590 * Release any blocked locking requests on the vnode.
4591 * Used for forced-unmounts.
4593 * XXX What about network filesystems?
4596 vnode_abort_advlocks(vnode_t vp
)
4598 if (vp
->v_flag
& VLOCKLOCAL
)
4599 lf_abort_advlocks(vp
);
4604 vnode_drain(vnode_t vp
)
4607 if (vp
->v_lflag
& VL_DRAIN
) {
4608 panic("vnode_drain: recursive drain");
4611 vp
->v_lflag
|= VL_DRAIN
;
4612 vp
->v_owner
= current_thread();
4614 while (vp
->v_iocount
> 1)
4615 msleep(&vp
->v_iocount
, &vp
->v_lock
, PVFS
, "vnode_drain", NULL
);
4617 vp
->v_lflag
&= ~VL_DRAIN
;
4624 * if the number of recent references via vnode_getwithvid or vnode_getwithref
4625 * exceeds this threshold, than 'UN-AGE' the vnode by removing it from
4626 * the LRU list if it's currently on it... once the iocount and usecount both drop
4627 * to 0, it will get put back on the end of the list, effectively making it younger
4628 * this allows us to keep actively referenced vnodes in the list without having
4629 * to constantly remove and add to the list each time a vnode w/o a usecount is
4630 * referenced which costs us taking and dropping a global lock twice.
4631 * However, if the vnode is marked DIRTY, we want to pull it out much earlier
4633 #define UNAGE_THRESHHOLD 25
4634 #define UNAGE_DIRTYTHRESHHOLD 6
4637 vnode_getiocount(vnode_t vp
, unsigned int vid
, int vflags
)
4639 int nodead
= vflags
& VNODE_NODEAD
;
4640 int nosusp
= vflags
& VNODE_NOSUSPEND
;
4641 int always
= vflags
& VNODE_ALWAYS
;
4642 int beatdrain
= vflags
& VNODE_DRAINO
;
4643 int withvid
= vflags
& VNODE_WITHID
;
4649 * if it is a dead vnode with deadfs
4651 if (nodead
&& (vp
->v_lflag
& VL_DEAD
) && ((vp
->v_type
== VBAD
) || (vp
->v_data
== 0))) {
4655 * will return VL_DEAD ones
4657 if ((vp
->v_lflag
& (VL_SUSPENDED
| VL_DRAIN
| VL_TERMINATE
)) == 0 ) {
4661 * if suspended vnodes are to be failed
4663 if (nosusp
&& (vp
->v_lflag
& VL_SUSPENDED
)) {
4667 * if you are the owner of drain/suspend/termination , can acquire iocount
4668 * check for VL_TERMINATE; it does not set owner
4670 if ((vp
->v_lflag
& (VL_DRAIN
| VL_SUSPENDED
| VL_TERMINATE
)) &&
4671 (vp
->v_owner
== current_thread())) {
4679 * If this vnode is getting drained, there are some cases where
4680 * we can't block or, in case of tty vnodes, want to be
4683 if (vp
->v_lflag
& VL_DRAIN
) {
4685 * In some situations, we want to get an iocount
4686 * even if the vnode is draining to prevent deadlock,
4687 * e.g. if we're in the filesystem, potentially holding
4688 * resources that could prevent other iocounts from
4694 * Don't block if the vnode's mount point is unmounting as
4695 * we may be the thread the unmount is itself waiting on
4696 * Only callers who pass in vids (at this point, we've already
4697 * handled nosusp and nodead) are expecting error returns
4698 * from this function, so only we can only return errors for
4699 * those. ENODEV is intended to inform callers that the call
4700 * failed because an unmount is in progress.
4702 if (withvid
&& (vp
->v_mount
) && vfs_isunmount(vp
->v_mount
))
4705 if (vnode_istty(vp
)) {
4710 vnode_lock_convert(vp
);
4712 if (vp
->v_lflag
& VL_TERMINATE
) {
4715 vp
->v_lflag
|= VL_TERMWANT
;
4717 error
= msleep(&vp
->v_lflag
, &vp
->v_lock
,
4718 (PVFS
| sleepflg
), "vnode getiocount", NULL
);
4722 msleep(&vp
->v_iocount
, &vp
->v_lock
, PVFS
, "vnode_getiocount", NULL
);
4724 if (withvid
&& vid
!= vp
->v_id
) {
4727 if (++vp
->v_references
>= UNAGE_THRESHHOLD
||
4728 (vp
->v_flag
& VISDIRTY
&& vp
->v_references
>= UNAGE_DIRTYTHRESHHOLD
)) {
4729 vp
->v_references
= 0;
4730 vnode_list_remove(vp
);
4740 vnode_dropiocount (vnode_t vp
)
4742 if (vp
->v_iocount
< 1)
4743 panic("vnode_dropiocount(%p): v_iocount < 1", vp
);
4749 if ((vp
->v_lflag
& (VL_DRAIN
| VL_SUSPENDED
)) && (vp
->v_iocount
<= 1))
4750 wakeup(&vp
->v_iocount
);
4755 vnode_reclaim(struct vnode
* vp
)
4757 vnode_reclaim_internal(vp
, 0, 0, 0);
4762 vnode_reclaim_internal(struct vnode
* vp
, int locked
, int reuse
, int flags
)
4769 if (vp
->v_lflag
& VL_TERMINATE
) {
4770 panic("vnode reclaim in progress");
4772 vp
->v_lflag
|= VL_TERMINATE
;
4774 vn_clearunionwait(vp
, 1);
4778 isfifo
= (vp
->v_type
== VFIFO
);
4780 if (vp
->v_type
!= VBAD
)
4781 vgone(vp
, flags
); /* clean and reclaim the vnode */
4784 * give the vnode a new identity so that vnode_getwithvid will fail
4785 * on any stale cache accesses...
4786 * grab the list_lock so that if we're in "new_vnode"
4787 * behind the list_lock trying to steal this vnode, the v_id is stable...
4788 * once new_vnode drops the list_lock, it will block trying to take
4789 * the vnode lock until we release it... at that point it will evaluate
4790 * whether the v_vid has changed
4791 * also need to make sure that the vnode isn't on a list where "new_vnode"
4792 * can find it after the v_id has been bumped until we are completely done
4793 * with the vnode (i.e. putting it back on a list has to be the very last
4794 * thing we do to this vnode... many of the callers of vnode_reclaim_internal
4795 * are holding an io_count on the vnode... they need to drop the io_count
4796 * BEFORE doing a vnode_list_add or make sure to hold the vnode lock until
4797 * they are completely done with the vnode
4801 vnode_list_remove_locked(vp
);
4804 vnode_list_unlock();
4807 struct fifoinfo
* fip
;
4809 fip
= vp
->v_fifoinfo
;
4810 vp
->v_fifoinfo
= NULL
;
4816 panic("vnode_reclaim_internal: cleaned vnode isn't");
4817 if (vp
->v_numoutput
)
4818 panic("vnode_reclaim_internal: clean vnode has pending I/O's");
4819 if (UBCINFOEXISTS(vp
))
4820 panic("vnode_reclaim_internal: ubcinfo not cleaned");
4822 panic("vnode_reclaim_internal: vparent not removed");
4824 panic("vnode_reclaim_internal: vname not removed");
4826 vp
->v_socket
= NULL
;
4828 vp
->v_lflag
&= ~VL_TERMINATE
;
4831 KNOTE(&vp
->v_knotes
, NOTE_REVOKE
);
4833 /* Make sure that when we reuse the vnode, no knotes left over */
4834 klist_init(&vp
->v_knotes
);
4836 if (vp
->v_lflag
& VL_TERMWANT
) {
4837 vp
->v_lflag
&= ~VL_TERMWANT
;
4838 wakeup(&vp
->v_lflag
);
4842 * make sure we get on the
4843 * dead list if appropriate
4852 vnode_create_internal(uint32_t flavor
, uint32_t size
, void *data
, vnode_t
*vpp
,
4862 struct componentname
*cnp
;
4863 struct vnode_fsparam
*param
= (struct vnode_fsparam
*)data
;
4865 struct vnode_trigger_param
*tinfo
= NULL
;
4876 /* Do quick sanity check on the parameters. */
4877 if ((param
== NULL
) || (param
->vnfs_vtype
== VBAD
)) {
4883 if ((flavor
== VNCREATE_TRIGGER
) && (size
== VNCREATE_TRIGGER_SIZE
)) {
4884 tinfo
= (struct vnode_trigger_param
*)data
;
4886 /* Validate trigger vnode input */
4887 if ((param
->vnfs_vtype
!= VDIR
) ||
4888 (tinfo
->vnt_resolve_func
== NULL
) ||
4889 (tinfo
->vnt_flags
& ~VNT_VALID_MASK
)) {
4893 /* Fall through a normal create (params will be the same) */
4894 flavor
= VNCREATE_FLAVOR
;
4898 if ((flavor
!= VNCREATE_FLAVOR
) || (size
!= VCREATESIZE
)) {
4904 if (!existing_vnode
) {
4905 if ((error
= new_vnode(&vp
)) ) {
4909 /* Make it so that it can be released by a vnode_put) */
4916 * A vnode obtained by vnode_create_empty has been passed to
4917 * vnode_initialize - Unset VL_DEAD set by vn_set_dead. After
4918 * this point, it is set back on any error.
4920 * N.B. vnode locking - We make the same assumptions as the
4921 * "unsplit" vnode_create did - i.e. it is safe to update the
4922 * vnode's fields without the vnode lock. This vnode has been
4923 * out and about with the filesystem and hopefully nothing
4924 * was done to the vnode between the vnode_create_empty and
4925 * now when it has come in through vnode_initialize.
4927 vp
->v_lflag
&= ~VL_DEAD
;
4930 dvp
= param
->vnfs_dvp
;
4931 cnp
= param
->vnfs_cnp
;
4933 vp
->v_op
= param
->vnfs_vops
;
4934 vp
->v_type
= param
->vnfs_vtype
;
4935 vp
->v_data
= param
->vnfs_fsnode
;
4937 if (param
->vnfs_markroot
)
4938 vp
->v_flag
|= VROOT
;
4939 if (param
->vnfs_marksystem
)
4940 vp
->v_flag
|= VSYSTEM
;
4941 if (vp
->v_type
== VREG
) {
4942 error
= ubc_info_init_withsize(vp
, param
->vnfs_filesize
);
4952 if (param
->vnfs_mp
->mnt_ioflags
& MNT_IOFLAGS_IOSCHED_SUPPORTED
)
4953 memory_object_mark_io_tracking(vp
->v_ubcinfo
->ui_control
);
4961 * For trigger vnodes, attach trigger info to vnode
4963 if ((vp
->v_type
== VDIR
) && (tinfo
!= NULL
)) {
4965 * Note: has a side effect of incrementing trigger count on the
4966 * mount if successful, which we would need to undo on a
4967 * subsequent failure.
4972 error
= vnode_resolver_create(param
->vnfs_mp
, vp
, tinfo
, FALSE
);
4974 printf("vnode_create: vnode_resolver_create() err %d\n", error
);
4984 if (vp
->v_type
== VCHR
|| vp
->v_type
== VBLK
) {
4986 vp
->v_tag
= VT_DEVFS
; /* callers will reset if needed (bdevvp) */
4988 if ( (nvp
= checkalias(vp
, param
->vnfs_rdev
)) ) {
4990 * if checkalias returns a vnode, it will be locked
4992 * first get rid of the unneeded vnode we acquired
4995 vp
->v_op
= spec_vnodeop_p
;
4997 vp
->v_lflag
= VL_DEAD
;
5003 * switch to aliased vnode and finish
5009 vp
->v_op
= param
->vnfs_vops
;
5010 vp
->v_type
= param
->vnfs_vtype
;
5011 vp
->v_data
= param
->vnfs_fsnode
;
5014 insmntque(vp
, param
->vnfs_mp
);
5019 if (VCHR
== vp
->v_type
) {
5020 u_int maj
= major(vp
->v_rdev
);
5022 if (maj
< (u_int
)nchrdev
&& cdevsw
[maj
].d_type
== D_TTY
)
5023 vp
->v_flag
|= VISTTY
;
5027 if (vp
->v_type
== VFIFO
) {
5028 struct fifoinfo
*fip
;
5030 MALLOC(fip
, struct fifoinfo
*,
5031 sizeof(*fip
), M_TEMP
, M_WAITOK
);
5032 bzero(fip
, sizeof(struct fifoinfo
));
5033 vp
->v_fifoinfo
= fip
;
5035 /* The file systems must pass the address of the location where
5036 * they store the vnode pointer. When we add the vnode into the mount
5037 * list and name cache they become discoverable. So the file system node
5038 * must have the connection to vnode setup by then
5042 /* Add fs named reference. */
5043 if (param
->vnfs_flags
& VNFS_ADDFSREF
) {
5044 vp
->v_lflag
|= VNAMED_FSHASH
;
5046 if (param
->vnfs_mp
) {
5047 if (param
->vnfs_mp
->mnt_kern_flag
& MNTK_LOCK_LOCAL
)
5048 vp
->v_flag
|= VLOCKLOCAL
;
5050 if ((vp
->v_freelist
.tqe_prev
!= (struct vnode
**)0xdeadb))
5051 panic("insmntque: vp on the free list\n");
5054 * enter in mount vnode list
5056 insmntque(vp
, param
->vnfs_mp
);
5059 if (dvp
&& vnode_ref(dvp
) == 0) {
5063 if (dvp
&& ((param
->vnfs_flags
& (VNFS_NOCACHE
| VNFS_CANTCACHE
)) == 0)) {
5065 * enter into name cache
5066 * we've got the info to enter it into the name cache now
5067 * cache_enter_create will pick up an extra reference on
5068 * the name entered into the string cache
5070 vp
->v_name
= cache_enter_create(dvp
, vp
, cnp
);
5072 vp
->v_name
= vfs_addname(cnp
->cn_nameptr
, cnp
->cn_namelen
, cnp
->cn_hash
, 0);
5074 if ((cnp
->cn_flags
& UNIONCREATED
) == UNIONCREATED
)
5075 vp
->v_flag
|= VISUNION
;
5077 if ((param
->vnfs_flags
& VNFS_CANTCACHE
) == 0) {
5079 * this vnode is being created as cacheable in the name cache
5080 * this allows us to re-enter it in the cache
5082 vp
->v_flag
|= VNCACHEABLE
;
5084 ut
= get_bsdthread_info(current_thread());
5086 if ((current_proc()->p_lflag
& P_LRAGE_VNODES
) ||
5087 (ut
->uu_flag
& UT_RAGE_VNODES
)) {
5089 * process has indicated that it wants any
5090 * vnodes created on its behalf to be rapidly
5091 * aged to reduce the impact on the cached set
5094 vp
->v_flag
|= VRAGE
;
5097 #if CONFIG_SECLUDED_MEMORY
5098 switch (secluded_for_filecache
) {
5101 * secluded_for_filecache == 0:
5102 * + no file contents in secluded pool
5107 * secluded_for_filecache == 1:
5109 * + files from /Applications/ are OK
5110 * + files from /Applications/Camera are not OK
5111 * + no files that are open for write
5113 if (vnode_vtype(vp
) == VREG
&&
5114 vnode_mount(vp
) != NULL
&&
5115 (! (vfs_flags(vnode_mount(vp
)) & MNT_ROOTFS
))) {
5116 /* not from root filesystem: eligible for secluded pages */
5117 memory_object_mark_eligible_for_secluded(
5118 ubc_getobject(vp
, UBC_FLAGS_NONE
),
5124 * secluded_for_filecache == 2:
5125 * + all read-only files OK, except:
5126 * + dyld_shared_cache_arm64*
5130 if (vnode_vtype(vp
) == VREG
) {
5131 memory_object_mark_eligible_for_secluded(
5132 ubc_getobject(vp
, UBC_FLAGS_NONE
),
5139 #endif /* CONFIG_SECLUDED_MEMORY */
5144 if (existing_vnode
) {
5151 * The following api creates a vnode and associates all the parameter specified in vnode_fsparam
5152 * structure and returns a vnode handle with a reference. device aliasing is handled here so checkalias
5153 * is obsoleted by this.
5156 vnode_create(uint32_t flavor
, uint32_t size
, void *data
, vnode_t
*vpp
)
5159 return (vnode_create_internal(flavor
, size
, data
, vpp
, 1));
5163 vnode_create_empty(vnode_t
*vpp
)
5166 return (vnode_create_internal(VNCREATE_FLAVOR
, VCREATESIZE
, NULL
,
5171 vnode_initialize(uint32_t flavor
, uint32_t size
, void *data
, vnode_t
*vpp
)
5173 if (*vpp
== NULLVP
) {
5174 panic("NULL vnode passed to vnode_initialize");
5176 #if DEVELOPMENT || DEBUG
5178 * We lock to check that vnode is fit for unlocked use in
5179 * vnode_create_internal.
5181 vnode_lock_spin(*vpp
);
5182 VNASSERT(((*vpp
)->v_iocount
== 1), *vpp
,
5183 ("vnode_initialize : iocount not 1, is %d", (*vpp
)->v_iocount
));
5184 VNASSERT(((*vpp
)->v_usecount
== 0), *vpp
,
5185 ("vnode_initialize : usecount not 0, is %d", (*vpp
)->v_usecount
));
5186 VNASSERT(((*vpp
)->v_lflag
& VL_DEAD
), *vpp
,
5187 ("vnode_initialize : v_lflag does not have VL_DEAD, is 0x%x",
5189 VNASSERT(((*vpp
)->v_data
== NULL
), *vpp
,
5190 ("vnode_initialize : v_data not NULL"));
5193 return (vnode_create_internal(flavor
, size
, data
, vpp
, 1));
5197 vnode_addfsref(vnode_t vp
)
5199 vnode_lock_spin(vp
);
5200 if (vp
->v_lflag
& VNAMED_FSHASH
)
5201 panic("add_fsref: vp already has named reference");
5202 if ((vp
->v_freelist
.tqe_prev
!= (struct vnode
**)0xdeadb))
5203 panic("addfsref: vp on the free list\n");
5204 vp
->v_lflag
|= VNAMED_FSHASH
;
5210 vnode_removefsref(vnode_t vp
)
5212 vnode_lock_spin(vp
);
5213 if ((vp
->v_lflag
& VNAMED_FSHASH
) == 0)
5214 panic("remove_fsref: no named reference");
5215 vp
->v_lflag
&= ~VNAMED_FSHASH
;
5223 vfs_iterate(int flags
, int (*callout
)(mount_t
, void *), void *arg
)
5228 int count
, actualcount
, i
;
5230 int indx_start
, indx_stop
, indx_incr
;
5231 int cb_dropref
= (flags
& VFS_ITERATE_CB_DROPREF
);
5233 count
= mount_getvfscnt();
5236 fsid_list
= (fsid_t
*)kalloc(count
* sizeof(fsid_t
));
5237 allocmem
= (void *)fsid_list
;
5239 actualcount
= mount_fillfsids(fsid_list
, count
);
5242 * Establish the iteration direction
5243 * VFS_ITERATE_TAIL_FIRST overrides default head first order (oldest first)
5245 if (flags
& VFS_ITERATE_TAIL_FIRST
) {
5246 indx_start
= actualcount
- 1;
5249 } else /* Head first by default */ {
5251 indx_stop
= actualcount
;
5255 for (i
=indx_start
; i
!= indx_stop
; i
+= indx_incr
) {
5257 /* obtain the mount point with iteration reference */
5258 mp
= mount_list_lookupby_fsid(&fsid_list
[i
], 0, 1);
5260 if(mp
== (struct mount
*)0)
5263 if (mp
->mnt_lflag
& (MNT_LDEAD
| MNT_LUNMOUNT
)) {
5271 /* iterate over all the vnodes */
5272 ret
= callout(mp
, arg
);
5275 * Drop the iterref here if the callback didn't do it.
5276 * Note: If cb_dropref is set the mp may no longer exist.
5283 case VFS_RETURNED_DONE
:
5284 if (ret
== VFS_RETURNED_DONE
) {
5290 case VFS_CLAIMED_DONE
:
5301 kfree(allocmem
, (count
* sizeof(fsid_t
)));
5306 * Update the vfsstatfs structure in the mountpoint.
5307 * MAC: Parameter eventtype added, indicating whether the event that
5308 * triggered this update came from user space, via a system call
5309 * (VFS_USER_EVENT) or an internal kernel call (VFS_KERNEL_EVENT).
5312 vfs_update_vfsstat(mount_t mp
, vfs_context_t ctx
, __unused
int eventtype
)
5318 * Request the attributes we want to propagate into
5319 * the per-mount vfsstat structure.
5322 VFSATTR_WANTED(&va
, f_iosize
);
5323 VFSATTR_WANTED(&va
, f_blocks
);
5324 VFSATTR_WANTED(&va
, f_bfree
);
5325 VFSATTR_WANTED(&va
, f_bavail
);
5326 VFSATTR_WANTED(&va
, f_bused
);
5327 VFSATTR_WANTED(&va
, f_files
);
5328 VFSATTR_WANTED(&va
, f_ffree
);
5329 VFSATTR_WANTED(&va
, f_bsize
);
5330 VFSATTR_WANTED(&va
, f_fssubtype
);
5332 if ((error
= vfs_getattr(mp
, &va
, ctx
)) != 0) {
5333 KAUTH_DEBUG("STAT - filesystem returned error %d", error
);
5337 if (eventtype
== VFS_USER_EVENT
) {
5338 error
= mac_mount_check_getattr(ctx
, mp
, &va
);
5344 * Unpack into the per-mount structure.
5346 * We only overwrite these fields, which are likely to change:
5354 * And these which are not, but which the FS has no other way
5355 * of providing to us:
5361 if (VFSATTR_IS_SUPPORTED(&va
, f_bsize
)) {
5362 /* 4822056 - protect against malformed server mount */
5363 mp
->mnt_vfsstat
.f_bsize
= (va
.f_bsize
> 0 ? va
.f_bsize
: 512);
5365 mp
->mnt_vfsstat
.f_bsize
= mp
->mnt_devblocksize
; /* default from the device block size */
5367 if (VFSATTR_IS_SUPPORTED(&va
, f_iosize
)) {
5368 mp
->mnt_vfsstat
.f_iosize
= va
.f_iosize
;
5370 mp
->mnt_vfsstat
.f_iosize
= 1024 * 1024; /* 1MB sensible I/O size */
5372 if (VFSATTR_IS_SUPPORTED(&va
, f_blocks
))
5373 mp
->mnt_vfsstat
.f_blocks
= va
.f_blocks
;
5374 if (VFSATTR_IS_SUPPORTED(&va
, f_bfree
))
5375 mp
->mnt_vfsstat
.f_bfree
= va
.f_bfree
;
5376 if (VFSATTR_IS_SUPPORTED(&va
, f_bavail
))
5377 mp
->mnt_vfsstat
.f_bavail
= va
.f_bavail
;
5378 if (VFSATTR_IS_SUPPORTED(&va
, f_bused
))
5379 mp
->mnt_vfsstat
.f_bused
= va
.f_bused
;
5380 if (VFSATTR_IS_SUPPORTED(&va
, f_files
))
5381 mp
->mnt_vfsstat
.f_files
= va
.f_files
;
5382 if (VFSATTR_IS_SUPPORTED(&va
, f_ffree
))
5383 mp
->mnt_vfsstat
.f_ffree
= va
.f_ffree
;
5385 /* this is unlikely to change, but has to be queried for */
5386 if (VFSATTR_IS_SUPPORTED(&va
, f_fssubtype
))
5387 mp
->mnt_vfsstat
.f_fssubtype
= va
.f_fssubtype
;
5393 mount_list_add(mount_t mp
)
5398 if (system_inshutdown
!= 0) {
5401 TAILQ_INSERT_TAIL(&mountlist
, mp
, mnt_list
);
5405 mount_list_unlock();
5411 mount_list_remove(mount_t mp
)
5414 TAILQ_REMOVE(&mountlist
, mp
, mnt_list
);
5416 mp
->mnt_list
.tqe_next
= NULL
;
5417 mp
->mnt_list
.tqe_prev
= NULL
;
5418 mount_list_unlock();
5422 mount_lookupby_volfsid(int volfs_id
, int withref
)
5424 mount_t cur_mount
= (mount_t
)0;
5428 TAILQ_FOREACH(mp
, &mountlist
, mnt_list
) {
5429 if (!(mp
->mnt_kern_flag
& MNTK_UNMOUNT
) &&
5430 (mp
->mnt_kern_flag
& MNTK_PATH_FROM_ID
) &&
5431 (mp
->mnt_vfsstat
.f_fsid
.val
[0] == volfs_id
)) {
5434 if (mount_iterref(cur_mount
, 1)) {
5435 cur_mount
= (mount_t
)0;
5436 mount_list_unlock();
5443 mount_list_unlock();
5444 if (withref
&& (cur_mount
!= (mount_t
)0)) {
5446 if (vfs_busy(mp
, LK_NOWAIT
) != 0) {
5447 cur_mount
= (mount_t
)0;
5456 mount_list_lookupby_fsid(fsid_t
*fsid
, int locked
, int withref
)
5458 mount_t retmp
= (mount_t
)0;
5463 TAILQ_FOREACH(mp
, &mountlist
, mnt_list
)
5464 if (mp
->mnt_vfsstat
.f_fsid
.val
[0] == fsid
->val
[0] &&
5465 mp
->mnt_vfsstat
.f_fsid
.val
[1] == fsid
->val
[1]) {
5468 if (mount_iterref(retmp
, 1))
5475 mount_list_unlock();
5480 vnode_lookup(const char *path
, int flags
, vnode_t
*vpp
, vfs_context_t ctx
)
5482 struct nameidata nd
;
5484 u_int32_t ndflags
= 0;
5490 if (flags
& VNODE_LOOKUP_NOFOLLOW
)
5495 if (flags
& VNODE_LOOKUP_NOCROSSMOUNT
)
5496 ndflags
|= NOCROSSMOUNT
;
5498 if (flags
& VNODE_LOOKUP_CROSSMOUNTNOWAIT
)
5499 ndflags
|= CN_NBMOUNTLOOK
;
5501 /* XXX AUDITVNPATH1 needed ? */
5502 NDINIT(&nd
, LOOKUP
, OP_LOOKUP
, ndflags
, UIO_SYSSPACE
,
5503 CAST_USER_ADDR_T(path
), ctx
);
5505 if ((error
= namei(&nd
)))
5514 vnode_open(const char *path
, int fmode
, int cmode
, int flags
, vnode_t
*vpp
, vfs_context_t ctx
)
5516 struct nameidata nd
;
5518 u_int32_t ndflags
= 0;
5521 if (ctx
== NULL
) { /* XXX technically an error */
5522 ctx
= vfs_context_current();
5525 if (fmode
& O_NOFOLLOW
)
5526 lflags
|= VNODE_LOOKUP_NOFOLLOW
;
5528 if (lflags
& VNODE_LOOKUP_NOFOLLOW
)
5533 if (lflags
& VNODE_LOOKUP_NOCROSSMOUNT
)
5534 ndflags
|= NOCROSSMOUNT
;
5536 if (lflags
& VNODE_LOOKUP_CROSSMOUNTNOWAIT
)
5537 ndflags
|= CN_NBMOUNTLOOK
;
5539 /* XXX AUDITVNPATH1 needed ? */
5540 NDINIT(&nd
, LOOKUP
, OP_OPEN
, ndflags
, UIO_SYSSPACE
,
5541 CAST_USER_ADDR_T(path
), ctx
);
5543 if ((error
= vn_open(&nd
, fmode
, cmode
)))
5552 vnode_close(vnode_t vp
, int flags
, vfs_context_t ctx
)
5557 ctx
= vfs_context_current();
5560 error
= vn_close(vp
, flags
, ctx
);
5566 vnode_mtime(vnode_t vp
, struct timespec
*mtime
, vfs_context_t ctx
)
5568 struct vnode_attr va
;
5572 VATTR_WANTED(&va
, va_modify_time
);
5573 error
= vnode_getattr(vp
, &va
, ctx
);
5575 *mtime
= va
.va_modify_time
;
5580 vnode_flags(vnode_t vp
, uint32_t *flags
, vfs_context_t ctx
)
5582 struct vnode_attr va
;
5586 VATTR_WANTED(&va
, va_flags
);
5587 error
= vnode_getattr(vp
, &va
, ctx
);
5589 *flags
= va
.va_flags
;
5594 * Returns: 0 Success
5598 vnode_size(vnode_t vp
, off_t
*sizep
, vfs_context_t ctx
)
5600 struct vnode_attr va
;
5604 VATTR_WANTED(&va
, va_data_size
);
5605 error
= vnode_getattr(vp
, &va
, ctx
);
5607 *sizep
= va
.va_data_size
;
5612 vnode_setsize(vnode_t vp
, off_t size
, int ioflag
, vfs_context_t ctx
)
5614 struct vnode_attr va
;
5617 VATTR_SET(&va
, va_data_size
, size
);
5618 va
.va_vaflags
= ioflag
& 0xffff;
5619 return(vnode_setattr(vp
, &va
, ctx
));
5623 vnode_setdirty(vnode_t vp
)
5625 vnode_lock_spin(vp
);
5626 vp
->v_flag
|= VISDIRTY
;
5632 vnode_cleardirty(vnode_t vp
)
5634 vnode_lock_spin(vp
);
5635 vp
->v_flag
&= ~VISDIRTY
;
5641 vnode_isdirty(vnode_t vp
)
5645 vnode_lock_spin(vp
);
5646 dirty
= (vp
->v_flag
& VISDIRTY
) ? 1 : 0;
5653 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
)
5655 /* Only use compound VNOP for compound operation */
5656 if (vnode_compound_open_available(dvp
) && ((flags
& VN_CREATE_DOOPEN
) != 0)) {
5658 return VNOP_COMPOUND_OPEN(dvp
, vpp
, ndp
, O_CREAT
, fmode
, statusp
, vap
, ctx
);
5660 return VNOP_CREATE(dvp
, vpp
, &ndp
->ni_cnd
, vap
, ctx
);
5665 * Create a filesystem object of arbitrary type with arbitrary attributes in
5666 * the spevied directory with the specified name.
5668 * Parameters: dvp Pointer to the vnode of the directory
5669 * in which to create the object.
5670 * vpp Pointer to the area into which to
5671 * return the vnode of the created object.
5672 * cnp Component name pointer from the namei
5673 * data structure, containing the name to
5674 * use for the create object.
5675 * vap Pointer to the vnode_attr structure
5676 * describing the object to be created,
5677 * including the type of object.
5678 * flags VN_* flags controlling ACL inheritance
5679 * and whether or not authorization is to
5680 * be required for the operation.
5682 * Returns: 0 Success
5685 * Implicit: *vpp Contains the vnode of the object that
5686 * was created, if successful.
5687 * *cnp May be modified by the underlying VFS.
5688 * *vap May be modified by the underlying VFS.
5689 * modified by either ACL inheritance or
5692 * be modified, even if the operation is
5695 * Notes: The kauth_filesec_t in 'vap', if any, is in host byte order.
5697 * Modification of '*cnp' and '*vap' by the underlying VFS is
5698 * strongly discouraged.
5700 * XXX: This function is a 'vn_*' function; it belongs in vfs_vnops.c
5702 * XXX: We should enummerate the possible errno values here, and where
5703 * in the code they originated.
5706 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
)
5708 errno_t error
, old_error
;
5709 vnode_t vp
= (vnode_t
)0;
5711 struct componentname
*cnp
;
5716 batched
= namei_compound_available(dvp
, ndp
) ? TRUE
: FALSE
;
5718 KAUTH_DEBUG("%p CREATE - '%s'", dvp
, cnp
->cn_nameptr
);
5720 if (flags
& VN_CREATE_NOINHERIT
)
5721 vap
->va_vaflags
|= VA_NOINHERIT
;
5722 if (flags
& VN_CREATE_NOAUTH
)
5723 vap
->va_vaflags
|= VA_NOAUTH
;
5725 * Handle ACL inheritance, initialize vap.
5727 error
= vn_attribute_prepare(dvp
, vap
, &defaulted
, ctx
);
5732 if (vap
->va_type
!= VREG
&& (fmode
!= 0 || (flags
& VN_CREATE_DOOPEN
) || statusp
)) {
5733 panic("Open parameters, but not a regular file.");
5735 if ((fmode
!= 0) && ((flags
& VN_CREATE_DOOPEN
) == 0)) {
5736 panic("Mode for open, but not trying to open...");
5741 * Create the requested node.
5743 switch(vap
->va_type
) {
5745 error
= vn_create_reg(dvp
, vpp
, ndp
, vap
, flags
, fmode
, statusp
, ctx
);
5748 error
= vn_mkdir(dvp
, vpp
, ndp
, vap
, ctx
);
5754 error
= VNOP_MKNOD(dvp
, vpp
, cnp
, vap
, ctx
);
5757 panic("vnode_create: unknown vtype %d", vap
->va_type
);
5760 KAUTH_DEBUG("%p CREATE - error %d returned by filesystem", dvp
, error
);
5768 if (!(flags
& VN_CREATE_NOLABEL
)) {
5769 error
= vnode_label(vnode_mount(vp
), dvp
, vp
, cnp
, VNODE_LABEL_CREATE
, ctx
);
5776 * If some of the requested attributes weren't handled by the VNOP,
5777 * use our fallback code.
5779 if (!VATTR_ALL_SUPPORTED(vap
) && *vpp
) {
5780 KAUTH_DEBUG(" CREATE - doing fallback with ACL %p", vap
->va_acl
);
5781 error
= vnode_setattr_fallback(*vpp
, vap
, ctx
);
5786 if ((error
!= 0) && (vp
!= (vnode_t
)0)) {
5788 /* If we've done a compound open, close */
5789 if (batched
&& (old_error
== 0) && (vap
->va_type
== VREG
)) {
5790 VNOP_CLOSE(vp
, fmode
, ctx
);
5793 /* Need to provide notifications if a create succeeded */
5801 vn_attribute_cleanup(vap
, defaulted
);
5806 static kauth_scope_t vnode_scope
;
5807 static int vnode_authorize_callback(kauth_cred_t credential
, void *idata
, kauth_action_t action
,
5808 uintptr_t arg0
, uintptr_t arg1
, uintptr_t arg2
, uintptr_t arg3
);
5809 static int vnode_authorize_callback_int(__unused kauth_cred_t credential
, __unused
void *idata
, kauth_action_t action
,
5810 uintptr_t arg0
, uintptr_t arg1
, uintptr_t arg2
, uintptr_t arg3
);
5812 typedef struct _vnode_authorize_context
{
5814 struct vnode_attr
*vap
;
5816 struct vnode_attr
*dvap
;
5820 #define _VAC_IS_OWNER (1<<0)
5821 #define _VAC_IN_GROUP (1<<1)
5822 #define _VAC_IS_DIR_OWNER (1<<2)
5823 #define _VAC_IN_DIR_GROUP (1<<3)
5827 vnode_authorize_init(void)
5829 vnode_scope
= kauth_register_scope(KAUTH_SCOPE_VNODE
, vnode_authorize_callback
, NULL
);
5832 #define VATTR_PREPARE_DEFAULTED_UID 0x1
5833 #define VATTR_PREPARE_DEFAULTED_GID 0x2
5834 #define VATTR_PREPARE_DEFAULTED_MODE 0x4
5837 vn_attribute_prepare(vnode_t dvp
, struct vnode_attr
*vap
, uint32_t *defaulted_fieldsp
, vfs_context_t ctx
)
5839 kauth_acl_t nacl
= NULL
, oacl
= NULL
;
5843 * Handle ACL inheritance.
5845 if (!(vap
->va_vaflags
& VA_NOINHERIT
) && vfs_extendedsecurity(dvp
->v_mount
)) {
5846 /* save the original filesec */
5847 if (VATTR_IS_ACTIVE(vap
, va_acl
)) {
5852 if ((error
= kauth_acl_inherit(dvp
,
5855 vap
->va_type
== VDIR
,
5857 KAUTH_DEBUG("%p CREATE - error %d processing inheritance", dvp
, error
);
5862 * If the generated ACL is NULL, then we can save ourselves some effort
5863 * by clearing the active bit.
5866 VATTR_CLEAR_ACTIVE(vap
, va_acl
);
5868 vap
->va_base_acl
= oacl
;
5869 VATTR_SET(vap
, va_acl
, nacl
);
5873 error
= vnode_authattr_new_internal(dvp
, vap
, (vap
->va_vaflags
& VA_NOAUTH
), defaulted_fieldsp
, ctx
);
5875 vn_attribute_cleanup(vap
, *defaulted_fieldsp
);
5882 vn_attribute_cleanup(struct vnode_attr
*vap
, uint32_t defaulted_fields
)
5885 * If the caller supplied a filesec in vap, it has been replaced
5886 * now by the post-inheritance copy. We need to put the original back
5887 * and free the inherited product.
5889 kauth_acl_t nacl
, oacl
;
5891 if (VATTR_IS_ACTIVE(vap
, va_acl
)) {
5893 oacl
= vap
->va_base_acl
;
5896 VATTR_SET(vap
, va_acl
, oacl
);
5897 vap
->va_base_acl
= NULL
;
5899 VATTR_CLEAR_ACTIVE(vap
, va_acl
);
5903 kauth_acl_free(nacl
);
5907 if ((defaulted_fields
& VATTR_PREPARE_DEFAULTED_MODE
) != 0) {
5908 VATTR_CLEAR_ACTIVE(vap
, va_mode
);
5910 if ((defaulted_fields
& VATTR_PREPARE_DEFAULTED_GID
) != 0) {
5911 VATTR_CLEAR_ACTIVE(vap
, va_gid
);
5913 if ((defaulted_fields
& VATTR_PREPARE_DEFAULTED_UID
) != 0) {
5914 VATTR_CLEAR_ACTIVE(vap
, va_uid
);
5921 vn_authorize_unlink(vnode_t dvp
, vnode_t vp
, struct componentname
*cnp
, vfs_context_t ctx
, __unused
void *reserved
)
5929 * Normally, unlinking of directories is not supported.
5930 * However, some file systems may have limited support.
5932 if ((vp
->v_type
== VDIR
) &&
5933 !(vp
->v_mount
->mnt_kern_flag
& MNTK_DIR_HARDLINKS
)) {
5934 return (EPERM
); /* POSIX */
5937 /* authorize the delete operation */
5940 error
= mac_vnode_check_unlink(ctx
, dvp
, vp
, cnp
);
5943 error
= vnode_authorize(vp
, dvp
, KAUTH_VNODE_DELETE
, ctx
);
5949 vn_authorize_open_existing(vnode_t vp
, struct componentname
*cnp
, int fmode
, vfs_context_t ctx
, void *reserved
)
5951 /* Open of existing case */
5952 kauth_action_t action
;
5954 if (cnp
->cn_ndp
== NULL
) {
5957 if (reserved
!= NULL
) {
5958 panic("reserved not NULL.");
5962 /* XXX may do duplicate work here, but ignore that for now (idempotent) */
5963 if (vfs_flags(vnode_mount(vp
)) & MNT_MULTILABEL
) {
5964 error
= vnode_label(vnode_mount(vp
), NULL
, vp
, NULL
, 0, ctx
);
5970 if ( (fmode
& O_DIRECTORY
) && vp
->v_type
!= VDIR
) {
5974 if (vp
->v_type
== VSOCK
&& vp
->v_tag
!= VT_FDESC
) {
5975 return (EOPNOTSUPP
); /* Operation not supported on socket */
5978 if (vp
->v_type
== VLNK
&& (fmode
& O_NOFOLLOW
) != 0) {
5979 return (ELOOP
); /* O_NOFOLLOW was specified and the target is a symbolic link */
5982 /* disallow write operations on directories */
5983 if (vnode_isdir(vp
) && (fmode
& (FWRITE
| O_TRUNC
))) {
5987 if ((cnp
->cn_ndp
->ni_flag
& NAMEI_TRAILINGSLASH
)) {
5988 if (vp
->v_type
!= VDIR
) {
5994 /* If a file being opened is a shadow file containing
5995 * namedstream data, ignore the macf checks because it
5996 * is a kernel internal file and access should always
5999 if (!(vnode_isshadow(vp
) && vnode_isnamedstream(vp
))) {
6000 error
= mac_vnode_check_open(ctx
, vp
, fmode
);
6007 /* compute action to be authorized */
6009 if (fmode
& FREAD
) {
6010 action
|= KAUTH_VNODE_READ_DATA
;
6012 if (fmode
& (FWRITE
| O_TRUNC
)) {
6014 * If we are writing, appending, and not truncating,
6015 * indicate that we are appending so that if the
6016 * UF_APPEND or SF_APPEND bits are set, we do not deny
6019 if ((fmode
& O_APPEND
) && !(fmode
& O_TRUNC
)) {
6020 action
|= KAUTH_VNODE_APPEND_DATA
;
6022 action
|= KAUTH_VNODE_WRITE_DATA
;
6025 error
= vnode_authorize(vp
, NULL
, action
, ctx
);
6027 if (error
== EACCES
) {
6029 * Shadow files may exist on-disk with a different UID/GID
6030 * than that of the current context. Verify that this file
6031 * is really a shadow file. If it was created successfully
6032 * then it should be authorized.
6034 if (vnode_isshadow(vp
) && vnode_isnamedstream (vp
)) {
6035 error
= vnode_verifynamedstream(vp
);
6044 vn_authorize_create(vnode_t dvp
, struct componentname
*cnp
, struct vnode_attr
*vap
, vfs_context_t ctx
, void *reserved
)
6052 if (cnp
->cn_ndp
== NULL
) {
6053 panic("NULL cn_ndp");
6055 if (reserved
!= NULL
) {
6056 panic("reserved not NULL.");
6059 /* Only validate path for creation if we didn't do a complete lookup */
6060 if (cnp
->cn_ndp
->ni_flag
& NAMEI_UNFINISHED
) {
6061 error
= lookup_validate_creation_path(cnp
->cn_ndp
);
6067 error
= mac_vnode_check_create(ctx
, dvp
, cnp
, vap
);
6070 #endif /* CONFIG_MACF */
6072 return (vnode_authorize(dvp
, NULL
, KAUTH_VNODE_ADD_FILE
, ctx
));
6076 vn_authorize_rename(struct vnode
*fdvp
, struct vnode
*fvp
, struct componentname
*fcnp
,
6077 struct vnode
*tdvp
, struct vnode
*tvp
, struct componentname
*tcnp
,
6078 vfs_context_t ctx
, void *reserved
)
6080 return vn_authorize_renamex(fdvp
, fvp
, fcnp
, tdvp
, tvp
, tcnp
, ctx
, 0, reserved
);
6084 vn_authorize_renamex(struct vnode
*fdvp
, struct vnode
*fvp
, struct componentname
*fcnp
,
6085 struct vnode
*tdvp
, struct vnode
*tvp
, struct componentname
*tcnp
,
6086 vfs_context_t ctx
, vfs_rename_flags_t flags
, void *reserved
)
6090 bool swap
= flags
& VFS_RENAME_SWAP
;
6092 if (reserved
!= NULL
) {
6093 panic("Passed something other than NULL as reserved field!");
6097 * Avoid renaming "." and "..".
6099 * XXX No need to check for this in the FS. We should always have the leaves
6100 * in VFS in this case.
6102 if (fvp
->v_type
== VDIR
&&
6104 (fcnp
->cn_namelen
== 1 && fcnp
->cn_nameptr
[0] == '.') ||
6105 ((fcnp
->cn_flags
| tcnp
->cn_flags
) & ISDOTDOT
)) ) {
6110 if (tvp
== NULLVP
&& vnode_compound_rename_available(tdvp
)) {
6111 error
= lookup_validate_creation_path(tcnp
->cn_ndp
);
6116 /***** <MACF> *****/
6118 error
= mac_vnode_check_rename(ctx
, fdvp
, fvp
, fcnp
, tdvp
, tvp
, tcnp
);
6122 error
= mac_vnode_check_rename(ctx
, tdvp
, tvp
, tcnp
, fdvp
, fvp
, fcnp
);
6127 /***** </MACF> *****/
6129 /***** <MiscChecks> *****/
6132 if (fvp
->v_type
== VDIR
&& tvp
->v_type
!= VDIR
) {
6135 } else if (fvp
->v_type
!= VDIR
&& tvp
->v_type
== VDIR
) {
6142 * Caller should have already checked this and returned
6143 * ENOENT. If we send back ENOENT here, caller will retry
6144 * which isn't what we want so we send back EINVAL here
6157 * The following edge case is caught here:
6158 * (to cannot be a descendent of from)
6171 if (tdvp
->v_parent
== fvp
) {
6176 if (swap
&& fdvp
->v_parent
== tvp
) {
6180 /***** </MiscChecks> *****/
6182 /***** <Kauth> *****/
6185 kauth_action_t f
= 0, t
= 0;
6188 * Directories changing parents need ...ADD_SUBDIR... to
6189 * permit changing ".."
6192 if (vnode_isdir(fvp
))
6193 f
= KAUTH_VNODE_ADD_SUBDIRECTORY
;
6194 if (vnode_isdir(tvp
))
6195 t
= KAUTH_VNODE_ADD_SUBDIRECTORY
;
6197 error
= vnode_authorize(fvp
, fdvp
, KAUTH_VNODE_DELETE
| f
, ctx
);
6200 error
= vnode_authorize(tvp
, tdvp
, KAUTH_VNODE_DELETE
| t
, ctx
);
6203 f
= vnode_isdir(fvp
) ? KAUTH_VNODE_ADD_SUBDIRECTORY
: KAUTH_VNODE_ADD_FILE
;
6204 t
= vnode_isdir(tvp
) ? KAUTH_VNODE_ADD_SUBDIRECTORY
: KAUTH_VNODE_ADD_FILE
;
6206 error
= vnode_authorize(fdvp
, NULL
, f
| t
, ctx
);
6208 error
= vnode_authorize(fdvp
, NULL
, t
, ctx
);
6211 error
= vnode_authorize(tdvp
, NULL
, f
, ctx
);
6217 if ((tvp
!= NULL
) && vnode_isdir(tvp
)) {
6220 } else if (tdvp
!= fdvp
) {
6225 * must have delete rights to remove the old name even in
6226 * the simple case of fdvp == tdvp.
6228 * If fvp is a directory, and we are changing it's parent,
6229 * then we also need rights to rewrite its ".." entry as well.
6231 if (vnode_isdir(fvp
)) {
6232 if ((error
= vnode_authorize(fvp
, fdvp
, KAUTH_VNODE_DELETE
| KAUTH_VNODE_ADD_SUBDIRECTORY
, ctx
)) != 0)
6235 if ((error
= vnode_authorize(fvp
, fdvp
, KAUTH_VNODE_DELETE
, ctx
)) != 0)
6239 /* moving into tdvp or tvp, must have rights to add */
6240 if ((error
= vnode_authorize(((tvp
!= NULL
) && vnode_isdir(tvp
)) ? tvp
: tdvp
,
6242 vnode_isdir(fvp
) ? KAUTH_VNODE_ADD_SUBDIRECTORY
: KAUTH_VNODE_ADD_FILE
,
6247 /* node staying in same directory, must be allowed to add new name */
6248 if ((error
= vnode_authorize(fdvp
, NULL
,
6249 vnode_isdir(fvp
) ? KAUTH_VNODE_ADD_SUBDIRECTORY
: KAUTH_VNODE_ADD_FILE
, ctx
)) != 0)
6252 /* overwriting tvp */
6253 if ((tvp
!= NULL
) && !vnode_isdir(tvp
) &&
6254 ((error
= vnode_authorize(tvp
, tdvp
, KAUTH_VNODE_DELETE
, ctx
)) != 0)) {
6259 /***** </Kauth> *****/
6261 /* XXX more checks? */
6267 vn_authorize_mkdir(vnode_t dvp
, struct componentname
*cnp
, struct vnode_attr
*vap
, vfs_context_t ctx
, void *reserved
)
6274 if (reserved
!= NULL
) {
6275 panic("reserved not NULL in vn_authorize_mkdir()");
6278 /* XXX A hack for now, to make shadow files work */
6279 if (cnp
->cn_ndp
== NULL
) {
6283 if (vnode_compound_mkdir_available(dvp
)) {
6284 error
= lookup_validate_creation_path(cnp
->cn_ndp
);
6290 error
= mac_vnode_check_create(ctx
,
6296 /* authorize addition of a directory to the parent */
6297 if ((error
= vnode_authorize(dvp
, NULL
, KAUTH_VNODE_ADD_SUBDIRECTORY
, ctx
)) != 0)
6305 vn_authorize_rmdir(vnode_t dvp
, vnode_t vp
, struct componentname
*cnp
, vfs_context_t ctx
, void *reserved
)
6312 if (reserved
!= NULL
) {
6313 panic("Non-NULL reserved argument to vn_authorize_rmdir()");
6316 if (vp
->v_type
!= VDIR
) {
6318 * rmdir only deals with directories
6325 * No rmdir "." please.
6331 error
= mac_vnode_check_unlink(ctx
, dvp
,
6337 return vnode_authorize(vp
, dvp
, KAUTH_VNODE_DELETE
, ctx
);
6341 * Authorize an operation on a vnode.
6343 * This is KPI, but here because it needs vnode_scope.
6345 * Returns: 0 Success
6346 * kauth_authorize_action:EPERM ...
6347 * xlate => EACCES Permission denied
6348 * kauth_authorize_action:0 Success
6349 * kauth_authorize_action: Depends on callback return; this is
6350 * usually only vnode_authorize_callback(),
6351 * but may include other listerners, if any
6359 vnode_authorize(vnode_t vp
, vnode_t dvp
, kauth_action_t action
, vfs_context_t ctx
)
6364 * We can't authorize against a dead vnode; allow all operations through so that
6365 * the correct error can be returned.
6367 if (vp
->v_type
== VBAD
)
6371 result
= kauth_authorize_action(vnode_scope
, vfs_context_ucred(ctx
), action
,
6372 (uintptr_t)ctx
, (uintptr_t)vp
, (uintptr_t)dvp
, (uintptr_t)&error
);
6373 if (result
== EPERM
) /* traditional behaviour */
6375 /* did the lower layers give a better error return? */
6376 if ((result
!= 0) && (error
!= 0))
6382 * Test for vnode immutability.
6384 * The 'append' flag is set when the authorization request is constrained
6385 * to operations which only request the right to append to a file.
6387 * The 'ignore' flag is set when an operation modifying the immutability flags
6388 * is being authorized. We check the system securelevel to determine which
6389 * immutability flags we can ignore.
6392 vnode_immutable(struct vnode_attr
*vap
, int append
, int ignore
)
6396 /* start with all bits precluding the operation */
6397 mask
= IMMUTABLE
| APPEND
;
6399 /* if appending only, remove the append-only bits */
6403 /* ignore only set when authorizing flags changes */
6405 if (securelevel
<= 0) {
6406 /* in insecure state, flags do not inhibit changes */
6409 /* in secure state, user flags don't inhibit */
6410 mask
&= ~(UF_IMMUTABLE
| UF_APPEND
);
6413 KAUTH_DEBUG("IMMUTABLE - file flags 0x%x mask 0x%x append = %d ignore = %d", vap
->va_flags
, mask
, append
, ignore
);
6414 if ((vap
->va_flags
& mask
) != 0)
6420 vauth_node_owner(struct vnode_attr
*vap
, kauth_cred_t cred
)
6424 /* default assumption is not-owner */
6428 * If the filesystem has given us a UID, we treat this as authoritative.
6430 if (vap
&& VATTR_IS_SUPPORTED(vap
, va_uid
)) {
6431 result
= (vap
->va_uid
== kauth_cred_getuid(cred
)) ? 1 : 0;
6433 /* we could test the owner UUID here if we had a policy for it */
6441 * Description: Ask if a cred is a member of the group owning the vnode object
6443 * Parameters: vap vnode attribute
6444 * vap->va_gid group owner of vnode object
6445 * cred credential to check
6446 * ismember pointer to where to put the answer
6447 * idontknow Return this if we can't get an answer
6449 * Returns: 0 Success
6450 * idontknow Can't get information
6451 * kauth_cred_ismember_gid:? Error from kauth subsystem
6452 * kauth_cred_ismember_gid:? Error from kauth subsystem
6455 vauth_node_group(struct vnode_attr
*vap
, kauth_cred_t cred
, int *ismember
, int idontknow
)
6464 * The caller is expected to have asked the filesystem for a group
6465 * at some point prior to calling this function. The answer may
6466 * have been that there is no group ownership supported for the
6467 * vnode object, in which case we return
6469 if (vap
&& VATTR_IS_SUPPORTED(vap
, va_gid
)) {
6470 error
= kauth_cred_ismember_gid(cred
, vap
->va_gid
, &result
);
6472 * Credentials which are opted into external group membership
6473 * resolution which are not known to the external resolver
6474 * will result in an ENOENT error. We translate this into
6475 * the appropriate 'idontknow' response for our caller.
6477 * XXX We do not make a distinction here between an ENOENT
6478 * XXX arising from a response from the external resolver,
6479 * XXX and an ENOENT which is internally generated. This is
6480 * XXX a deficiency of the published kauth_cred_ismember_gid()
6481 * XXX KPI which can not be overcome without new KPI. For
6482 * XXX all currently known cases, however, this wil result
6483 * XXX in correct behaviour.
6485 if (error
== ENOENT
)
6489 * XXX We could test the group UUID here if we had a policy for it,
6490 * XXX but this is problematic from the perspective of synchronizing
6491 * XXX group UUID and POSIX GID ownership of a file and keeping the
6492 * XXX values coherent over time. The problem is that the local
6493 * XXX system will vend transient group UUIDs for unknown POSIX GID
6494 * XXX values, and these are not persistent, whereas storage of values
6495 * XXX is persistent. One potential solution to this is a local
6496 * XXX (persistent) replica of remote directory entries and vended
6497 * XXX local ids in a local directory server (think in terms of a
6498 * XXX caching DNS server).
6507 vauth_file_owner(vauth_ctx vcp
)
6511 if (vcp
->flags_valid
& _VAC_IS_OWNER
) {
6512 result
= (vcp
->flags
& _VAC_IS_OWNER
) ? 1 : 0;
6514 result
= vauth_node_owner(vcp
->vap
, vcp
->ctx
->vc_ucred
);
6516 /* cache our result */
6517 vcp
->flags_valid
|= _VAC_IS_OWNER
;
6519 vcp
->flags
|= _VAC_IS_OWNER
;
6521 vcp
->flags
&= ~_VAC_IS_OWNER
;
6529 * vauth_file_ingroup
6531 * Description: Ask if a user is a member of the group owning the directory
6533 * Parameters: vcp The vnode authorization context that
6534 * contains the user and directory info
6535 * vcp->flags_valid Valid flags
6536 * vcp->flags Flags values
6537 * vcp->vap File vnode attributes
6538 * vcp->ctx VFS Context (for user)
6539 * ismember pointer to where to put the answer
6540 * idontknow Return this if we can't get an answer
6542 * Returns: 0 Success
6543 * vauth_node_group:? Error from vauth_node_group()
6545 * Implicit returns: *ismember 0 The user is not a group member
6546 * 1 The user is a group member
6549 vauth_file_ingroup(vauth_ctx vcp
, int *ismember
, int idontknow
)
6553 /* Check for a cached answer first, to avoid the check if possible */
6554 if (vcp
->flags_valid
& _VAC_IN_GROUP
) {
6555 *ismember
= (vcp
->flags
& _VAC_IN_GROUP
) ? 1 : 0;
6558 /* Otherwise, go look for it */
6559 error
= vauth_node_group(vcp
->vap
, vcp
->ctx
->vc_ucred
, ismember
, idontknow
);
6562 /* cache our result */
6563 vcp
->flags_valid
|= _VAC_IN_GROUP
;
6565 vcp
->flags
|= _VAC_IN_GROUP
;
6567 vcp
->flags
&= ~_VAC_IN_GROUP
;
6576 vauth_dir_owner(vauth_ctx vcp
)
6580 if (vcp
->flags_valid
& _VAC_IS_DIR_OWNER
) {
6581 result
= (vcp
->flags
& _VAC_IS_DIR_OWNER
) ? 1 : 0;
6583 result
= vauth_node_owner(vcp
->dvap
, vcp
->ctx
->vc_ucred
);
6585 /* cache our result */
6586 vcp
->flags_valid
|= _VAC_IS_DIR_OWNER
;
6588 vcp
->flags
|= _VAC_IS_DIR_OWNER
;
6590 vcp
->flags
&= ~_VAC_IS_DIR_OWNER
;
6599 * Description: Ask if a user is a member of the group owning the directory
6601 * Parameters: vcp The vnode authorization context that
6602 * contains the user and directory info
6603 * vcp->flags_valid Valid flags
6604 * vcp->flags Flags values
6605 * vcp->dvap Dir vnode attributes
6606 * vcp->ctx VFS Context (for user)
6607 * ismember pointer to where to put the answer
6608 * idontknow Return this if we can't get an answer
6610 * Returns: 0 Success
6611 * vauth_node_group:? Error from vauth_node_group()
6613 * Implicit returns: *ismember 0 The user is not a group member
6614 * 1 The user is a group member
6617 vauth_dir_ingroup(vauth_ctx vcp
, int *ismember
, int idontknow
)
6621 /* Check for a cached answer first, to avoid the check if possible */
6622 if (vcp
->flags_valid
& _VAC_IN_DIR_GROUP
) {
6623 *ismember
= (vcp
->flags
& _VAC_IN_DIR_GROUP
) ? 1 : 0;
6626 /* Otherwise, go look for it */
6627 error
= vauth_node_group(vcp
->dvap
, vcp
->ctx
->vc_ucred
, ismember
, idontknow
);
6630 /* cache our result */
6631 vcp
->flags_valid
|= _VAC_IN_DIR_GROUP
;
6633 vcp
->flags
|= _VAC_IN_DIR_GROUP
;
6635 vcp
->flags
&= ~_VAC_IN_DIR_GROUP
;
6643 * Test the posix permissions in (vap) to determine whether (credential)
6644 * may perform (action)
6647 vnode_authorize_posix(vauth_ctx vcp
, int action
, int on_dir
)
6649 struct vnode_attr
*vap
;
6650 int needed
, error
, owner_ok
, group_ok
, world_ok
, ismember
;
6651 #ifdef KAUTH_DEBUG_ENABLE
6652 const char *where
= "uninitialized";
6653 # define _SETWHERE(c) where = c;
6655 # define _SETWHERE(c)
6658 /* checking file or directory? */
6668 * We want to do as little work here as possible. So first we check
6669 * which sets of permissions grant us the access we need, and avoid checking
6670 * whether specific permissions grant access when more generic ones would.
6673 /* owner permissions */
6677 if (action
& VWRITE
)
6681 owner_ok
= (needed
& vap
->va_mode
) == needed
;
6683 /* group permissions */
6687 if (action
& VWRITE
)
6691 group_ok
= (needed
& vap
->va_mode
) == needed
;
6693 /* world permissions */
6697 if (action
& VWRITE
)
6701 world_ok
= (needed
& vap
->va_mode
) == needed
;
6703 /* If granted/denied by all three, we're done */
6704 if (owner_ok
&& group_ok
&& world_ok
) {
6708 if (!owner_ok
&& !group_ok
&& !world_ok
) {
6714 /* Check ownership (relatively cheap) */
6715 if ((on_dir
&& vauth_dir_owner(vcp
)) ||
6716 (!on_dir
&& vauth_file_owner(vcp
))) {
6723 /* Not owner; if group and world both grant it we're done */
6724 if (group_ok
&& world_ok
) {
6725 _SETWHERE("group/world");
6728 if (!group_ok
&& !world_ok
) {
6729 _SETWHERE("group/world");
6734 /* Check group membership (most expensive) */
6735 ismember
= 0; /* Default to allow, if the target has no group owner */
6738 * In the case we can't get an answer about the user from the call to
6739 * vauth_dir_ingroup() or vauth_file_ingroup(), we want to fail on
6740 * the side of caution, rather than simply granting access, or we will
6741 * fail to correctly implement exclusion groups, so we set the third
6742 * parameter on the basis of the state of 'group_ok'.
6745 error
= vauth_dir_ingroup(vcp
, &ismember
, (!group_ok
? EACCES
: 0));
6747 error
= vauth_file_ingroup(vcp
, &ismember
, (!group_ok
? EACCES
: 0));
6761 /* Not owner, not in group, use world result */
6769 KAUTH_DEBUG("%p %s - posix %s permissions : need %s%s%s %x have %s%s%s%s%s%s%s%s%s UID = %d file = %d,%d",
6770 vcp
->vp
, (error
== 0) ? "ALLOWED" : "DENIED", where
,
6771 (action
& VREAD
) ? "r" : "-",
6772 (action
& VWRITE
) ? "w" : "-",
6773 (action
& VEXEC
) ? "x" : "-",
6775 (vap
->va_mode
& S_IRUSR
) ? "r" : "-",
6776 (vap
->va_mode
& S_IWUSR
) ? "w" : "-",
6777 (vap
->va_mode
& S_IXUSR
) ? "x" : "-",
6778 (vap
->va_mode
& S_IRGRP
) ? "r" : "-",
6779 (vap
->va_mode
& S_IWGRP
) ? "w" : "-",
6780 (vap
->va_mode
& S_IXGRP
) ? "x" : "-",
6781 (vap
->va_mode
& S_IROTH
) ? "r" : "-",
6782 (vap
->va_mode
& S_IWOTH
) ? "w" : "-",
6783 (vap
->va_mode
& S_IXOTH
) ? "x" : "-",
6784 kauth_cred_getuid(vcp
->ctx
->vc_ucred
),
6785 on_dir
? vcp
->dvap
->va_uid
: vcp
->vap
->va_uid
,
6786 on_dir
? vcp
->dvap
->va_gid
: vcp
->vap
->va_gid
);
6791 * Authorize the deletion of the node vp from the directory dvp.
6794 * - Neither the node nor the directory are immutable.
6795 * - The user is not the superuser.
6797 * The precedence of factors for authorizing or denying delete for a credential
6799 * 1) Explicit ACE on the node. (allow or deny DELETE)
6800 * 2) Explicit ACE on the directory (allow or deny DELETE_CHILD).
6802 * If there are conflicting ACEs on the node and the directory, the node
6805 * 3) Sticky bit on the directory.
6806 * Deletion is not permitted if the directory is sticky and the caller is
6807 * not owner of the node or directory. The sticky bit rules are like a deny
6808 * delete ACE except lower in priority than ACL's either allowing or denying
6811 * 4) POSIX permisions on the directory.
6813 * As an optimization, we cache whether or not delete child is permitted
6814 * on directories. This enables us to skip directory ACL and POSIX checks
6815 * as we already have the result from those checks. However, we always check the
6816 * node ACL and, if the directory has the sticky bit set, we always check its
6817 * ACL (even for a directory with an authorized delete child). Furthermore,
6818 * caching the delete child authorization is independent of the sticky bit
6819 * being set as it is only applicable in determining whether the node can be
6823 vnode_authorize_delete(vauth_ctx vcp
, boolean_t cached_delete_child
)
6825 struct vnode_attr
*vap
= vcp
->vap
;
6826 struct vnode_attr
*dvap
= vcp
->dvap
;
6827 kauth_cred_t cred
= vcp
->ctx
->vc_ucred
;
6828 struct kauth_acl_eval eval
;
6829 int error
, ismember
;
6831 /* Check the ACL on the node first */
6832 if (VATTR_IS_NOT(vap
, va_acl
, NULL
)) {
6833 eval
.ae_requested
= KAUTH_VNODE_DELETE
;
6834 eval
.ae_acl
= &vap
->va_acl
->acl_ace
[0];
6835 eval
.ae_count
= vap
->va_acl
->acl_entrycount
;
6836 eval
.ae_options
= 0;
6837 if (vauth_file_owner(vcp
))
6838 eval
.ae_options
|= KAUTH_AEVAL_IS_OWNER
;
6840 * We use ENOENT as a marker to indicate we could not get
6841 * information in order to delay evaluation until after we
6842 * have the ACL evaluation answer. Previously, we would
6843 * always deny the operation at this point.
6845 if ((error
= vauth_file_ingroup(vcp
, &ismember
, ENOENT
)) != 0 && error
!= ENOENT
)
6847 if (error
== ENOENT
)
6848 eval
.ae_options
|= KAUTH_AEVAL_IN_GROUP_UNKNOWN
;
6850 eval
.ae_options
|= KAUTH_AEVAL_IN_GROUP
;
6851 eval
.ae_exp_gall
= KAUTH_VNODE_GENERIC_ALL_BITS
;
6852 eval
.ae_exp_gread
= KAUTH_VNODE_GENERIC_READ_BITS
;
6853 eval
.ae_exp_gwrite
= KAUTH_VNODE_GENERIC_WRITE_BITS
;
6854 eval
.ae_exp_gexec
= KAUTH_VNODE_GENERIC_EXECUTE_BITS
;
6856 if ((error
= kauth_acl_evaluate(cred
, &eval
)) != 0) {
6857 KAUTH_DEBUG("%p ERROR during ACL processing - %d", vcp
->vp
, error
);
6861 switch(eval
.ae_result
) {
6862 case KAUTH_RESULT_DENY
:
6863 KAUTH_DEBUG("%p DENIED - denied by ACL", vcp
->vp
);
6865 case KAUTH_RESULT_ALLOW
:
6866 KAUTH_DEBUG("%p ALLOWED - granted by ACL", vcp
->vp
);
6868 case KAUTH_RESULT_DEFER
:
6870 /* Defer to directory */
6871 KAUTH_DEBUG("%p DEFERRED - by file ACL", vcp
->vp
);
6877 * Without a sticky bit, a previously authorized delete child is
6878 * sufficient to authorize this delete.
6880 * If the sticky bit is set, a directory ACL which allows delete child
6881 * overrides a (potential) sticky bit deny. The authorized delete child
6882 * cannot tell us if it was authorized because of an explicit delete
6883 * child allow ACE or because of POSIX permisions so we have to check
6884 * the directory ACL everytime if the directory has a sticky bit.
6886 if (!(dvap
->va_mode
& S_ISTXT
) && cached_delete_child
) {
6887 KAUTH_DEBUG("%p ALLOWED - granted by directory ACL or POSIX permissions and no sticky bit on directory", vcp
->vp
);
6891 /* check the ACL on the directory */
6892 if (VATTR_IS_NOT(dvap
, va_acl
, NULL
)) {
6893 eval
.ae_requested
= KAUTH_VNODE_DELETE_CHILD
;
6894 eval
.ae_acl
= &dvap
->va_acl
->acl_ace
[0];
6895 eval
.ae_count
= dvap
->va_acl
->acl_entrycount
;
6896 eval
.ae_options
= 0;
6897 if (vauth_dir_owner(vcp
))
6898 eval
.ae_options
|= KAUTH_AEVAL_IS_OWNER
;
6900 * We use ENOENT as a marker to indicate we could not get
6901 * information in order to delay evaluation until after we
6902 * have the ACL evaluation answer. Previously, we would
6903 * always deny the operation at this point.
6905 if ((error
= vauth_dir_ingroup(vcp
, &ismember
, ENOENT
)) != 0 && error
!= ENOENT
)
6907 if (error
== ENOENT
)
6908 eval
.ae_options
|= KAUTH_AEVAL_IN_GROUP_UNKNOWN
;
6910 eval
.ae_options
|= KAUTH_AEVAL_IN_GROUP
;
6911 eval
.ae_exp_gall
= KAUTH_VNODE_GENERIC_ALL_BITS
;
6912 eval
.ae_exp_gread
= KAUTH_VNODE_GENERIC_READ_BITS
;
6913 eval
.ae_exp_gwrite
= KAUTH_VNODE_GENERIC_WRITE_BITS
;
6914 eval
.ae_exp_gexec
= KAUTH_VNODE_GENERIC_EXECUTE_BITS
;
6917 * If there is no entry, we are going to defer to other
6918 * authorization mechanisms.
6920 error
= kauth_acl_evaluate(cred
, &eval
);
6923 KAUTH_DEBUG("%p ERROR during ACL processing - %d", vcp
->vp
, error
);
6926 switch(eval
.ae_result
) {
6927 case KAUTH_RESULT_DENY
:
6928 KAUTH_DEBUG("%p DENIED - denied by directory ACL", vcp
->vp
);
6930 case KAUTH_RESULT_ALLOW
:
6931 KAUTH_DEBUG("%p ALLOWED - granted by directory ACL", vcp
->vp
);
6932 if (!cached_delete_child
&& vcp
->dvp
) {
6933 vnode_cache_authorized_action(vcp
->dvp
,
6934 vcp
->ctx
, KAUTH_VNODE_DELETE_CHILD
);
6937 case KAUTH_RESULT_DEFER
:
6939 /* Deferred by directory ACL */
6940 KAUTH_DEBUG("%p DEFERRED - directory ACL", vcp
->vp
);
6946 * From this point, we can't explicitly allow and if we reach the end
6947 * of the function without a denial, then the delete is authorized.
6949 if (!cached_delete_child
) {
6950 if (vnode_authorize_posix(vcp
, VWRITE
, 1 /* on_dir */) != 0) {
6951 KAUTH_DEBUG("%p DENIED - denied by posix permisssions", vcp
->vp
);
6955 * Cache the authorized action on the vnode if allowed by the
6956 * directory ACL or POSIX permissions. It is correct to cache
6957 * this action even if sticky bit would deny deleting the node.
6960 vnode_cache_authorized_action(vcp
->dvp
, vcp
->ctx
,
6961 KAUTH_VNODE_DELETE_CHILD
);
6965 /* enforce sticky bit behaviour */
6966 if ((dvap
->va_mode
& S_ISTXT
) && !vauth_file_owner(vcp
) && !vauth_dir_owner(vcp
)) {
6967 KAUTH_DEBUG("%p DENIED - sticky bit rules (user %d file %d dir %d)",
6968 vcp
->vp
, cred
->cr_posix
.cr_uid
, vap
->va_uid
, dvap
->va_uid
);
6972 /* not denied, must be OK */
6978 * Authorize an operation based on the node's attributes.
6981 vnode_authorize_simple(vauth_ctx vcp
, kauth_ace_rights_t acl_rights
, kauth_ace_rights_t preauth_rights
, boolean_t
*found_deny
)
6983 struct vnode_attr
*vap
= vcp
->vap
;
6984 kauth_cred_t cred
= vcp
->ctx
->vc_ucred
;
6985 struct kauth_acl_eval eval
;
6986 int error
, ismember
;
6987 mode_t posix_action
;
6990 * If we are the file owner, we automatically have some rights.
6992 * Do we need to expand this to support group ownership?
6994 if (vauth_file_owner(vcp
))
6995 acl_rights
&= ~(KAUTH_VNODE_WRITE_SECURITY
);
6998 * If we are checking both TAKE_OWNERSHIP and WRITE_SECURITY, we can
6999 * mask the latter. If TAKE_OWNERSHIP is requested the caller is about to
7000 * change ownership to themselves, and WRITE_SECURITY is implicitly
7001 * granted to the owner. We need to do this because at this point
7002 * WRITE_SECURITY may not be granted as the caller is not currently
7005 if ((acl_rights
& KAUTH_VNODE_TAKE_OWNERSHIP
) &&
7006 (acl_rights
& KAUTH_VNODE_WRITE_SECURITY
))
7007 acl_rights
&= ~KAUTH_VNODE_WRITE_SECURITY
;
7009 if (acl_rights
== 0) {
7010 KAUTH_DEBUG("%p ALLOWED - implicit or no rights required", vcp
->vp
);
7014 /* if we have an ACL, evaluate it */
7015 if (VATTR_IS_NOT(vap
, va_acl
, NULL
)) {
7016 eval
.ae_requested
= acl_rights
;
7017 eval
.ae_acl
= &vap
->va_acl
->acl_ace
[0];
7018 eval
.ae_count
= vap
->va_acl
->acl_entrycount
;
7019 eval
.ae_options
= 0;
7020 if (vauth_file_owner(vcp
))
7021 eval
.ae_options
|= KAUTH_AEVAL_IS_OWNER
;
7023 * We use ENOENT as a marker to indicate we could not get
7024 * information in order to delay evaluation until after we
7025 * have the ACL evaluation answer. Previously, we would
7026 * always deny the operation at this point.
7028 if ((error
= vauth_file_ingroup(vcp
, &ismember
, ENOENT
)) != 0 && error
!= ENOENT
)
7030 if (error
== ENOENT
)
7031 eval
.ae_options
|= KAUTH_AEVAL_IN_GROUP_UNKNOWN
;
7033 eval
.ae_options
|= KAUTH_AEVAL_IN_GROUP
;
7034 eval
.ae_exp_gall
= KAUTH_VNODE_GENERIC_ALL_BITS
;
7035 eval
.ae_exp_gread
= KAUTH_VNODE_GENERIC_READ_BITS
;
7036 eval
.ae_exp_gwrite
= KAUTH_VNODE_GENERIC_WRITE_BITS
;
7037 eval
.ae_exp_gexec
= KAUTH_VNODE_GENERIC_EXECUTE_BITS
;
7039 if ((error
= kauth_acl_evaluate(cred
, &eval
)) != 0) {
7040 KAUTH_DEBUG("%p ERROR during ACL processing - %d", vcp
->vp
, error
);
7044 switch(eval
.ae_result
) {
7045 case KAUTH_RESULT_DENY
:
7046 KAUTH_DEBUG("%p DENIED - by ACL", vcp
->vp
);
7047 return(EACCES
); /* deny, deny, counter-allege */
7048 case KAUTH_RESULT_ALLOW
:
7049 KAUTH_DEBUG("%p ALLOWED - all rights granted by ACL", vcp
->vp
);
7051 case KAUTH_RESULT_DEFER
:
7053 /* Effectively the same as !delete_child_denied */
7054 KAUTH_DEBUG("%p DEFERRED - directory ACL", vcp
->vp
);
7058 *found_deny
= eval
.ae_found_deny
;
7060 /* fall through and evaluate residual rights */
7062 /* no ACL, everything is residual */
7063 eval
.ae_residual
= acl_rights
;
7067 * Grant residual rights that have been pre-authorized.
7069 eval
.ae_residual
&= ~preauth_rights
;
7072 * We grant WRITE_ATTRIBUTES to the owner if it hasn't been denied.
7074 if (vauth_file_owner(vcp
))
7075 eval
.ae_residual
&= ~KAUTH_VNODE_WRITE_ATTRIBUTES
;
7077 if (eval
.ae_residual
== 0) {
7078 KAUTH_DEBUG("%p ALLOWED - rights already authorized", vcp
->vp
);
7083 * Bail if we have residual rights that can't be granted by posix permissions,
7084 * or aren't presumed granted at this point.
7086 * XXX these can be collapsed for performance
7088 if (eval
.ae_residual
& KAUTH_VNODE_CHANGE_OWNER
) {
7089 KAUTH_DEBUG("%p DENIED - CHANGE_OWNER not permitted", vcp
->vp
);
7092 if (eval
.ae_residual
& KAUTH_VNODE_WRITE_SECURITY
) {
7093 KAUTH_DEBUG("%p DENIED - WRITE_SECURITY not permitted", vcp
->vp
);
7098 if (eval
.ae_residual
& KAUTH_VNODE_DELETE
)
7099 panic("vnode_authorize: can't be checking delete permission here");
7103 * Compute the fallback posix permissions that will satisfy the remaining
7107 if (eval
.ae_residual
& (KAUTH_VNODE_READ_DATA
|
7108 KAUTH_VNODE_LIST_DIRECTORY
|
7109 KAUTH_VNODE_READ_EXTATTRIBUTES
))
7110 posix_action
|= VREAD
;
7111 if (eval
.ae_residual
& (KAUTH_VNODE_WRITE_DATA
|
7112 KAUTH_VNODE_ADD_FILE
|
7113 KAUTH_VNODE_ADD_SUBDIRECTORY
|
7114 KAUTH_VNODE_DELETE_CHILD
|
7115 KAUTH_VNODE_WRITE_ATTRIBUTES
|
7116 KAUTH_VNODE_WRITE_EXTATTRIBUTES
))
7117 posix_action
|= VWRITE
;
7118 if (eval
.ae_residual
& (KAUTH_VNODE_EXECUTE
|
7119 KAUTH_VNODE_SEARCH
))
7120 posix_action
|= VEXEC
;
7122 if (posix_action
!= 0) {
7123 return(vnode_authorize_posix(vcp
, posix_action
, 0 /* !on_dir */));
7125 KAUTH_DEBUG("%p ALLOWED - residual rights %s%s%s%s%s%s%s%s%s%s%s%s%s%s granted due to no posix mapping",
7127 (eval
.ae_residual
& KAUTH_VNODE_READ_DATA
)
7128 ? vnode_isdir(vcp
->vp
) ? " LIST_DIRECTORY" : " READ_DATA" : "",
7129 (eval
.ae_residual
& KAUTH_VNODE_WRITE_DATA
)
7130 ? vnode_isdir(vcp
->vp
) ? " ADD_FILE" : " WRITE_DATA" : "",
7131 (eval
.ae_residual
& KAUTH_VNODE_EXECUTE
)
7132 ? vnode_isdir(vcp
->vp
) ? " SEARCH" : " EXECUTE" : "",
7133 (eval
.ae_residual
& KAUTH_VNODE_DELETE
)
7135 (eval
.ae_residual
& KAUTH_VNODE_APPEND_DATA
)
7136 ? vnode_isdir(vcp
->vp
) ? " ADD_SUBDIRECTORY" : " APPEND_DATA" : "",
7137 (eval
.ae_residual
& KAUTH_VNODE_DELETE_CHILD
)
7138 ? " DELETE_CHILD" : "",
7139 (eval
.ae_residual
& KAUTH_VNODE_READ_ATTRIBUTES
)
7140 ? " READ_ATTRIBUTES" : "",
7141 (eval
.ae_residual
& KAUTH_VNODE_WRITE_ATTRIBUTES
)
7142 ? " WRITE_ATTRIBUTES" : "",
7143 (eval
.ae_residual
& KAUTH_VNODE_READ_EXTATTRIBUTES
)
7144 ? " READ_EXTATTRIBUTES" : "",
7145 (eval
.ae_residual
& KAUTH_VNODE_WRITE_EXTATTRIBUTES
)
7146 ? " WRITE_EXTATTRIBUTES" : "",
7147 (eval
.ae_residual
& KAUTH_VNODE_READ_SECURITY
)
7148 ? " READ_SECURITY" : "",
7149 (eval
.ae_residual
& KAUTH_VNODE_WRITE_SECURITY
)
7150 ? " WRITE_SECURITY" : "",
7151 (eval
.ae_residual
& KAUTH_VNODE_CHECKIMMUTABLE
)
7152 ? " CHECKIMMUTABLE" : "",
7153 (eval
.ae_residual
& KAUTH_VNODE_CHANGE_OWNER
)
7154 ? " CHANGE_OWNER" : "");
7158 * Lack of required Posix permissions implies no reason to deny access.
7164 * Check for file immutability.
7167 vnode_authorize_checkimmutable(vnode_t vp
, struct vnode_attr
*vap
, int rights
, int ignore
)
7174 * Perform immutability checks for operations that change data.
7176 * Sockets, fifos and devices require special handling.
7178 switch(vp
->v_type
) {
7184 * Writing to these nodes does not change the filesystem data,
7185 * so forget that it's being tried.
7187 rights
&= ~KAUTH_VNODE_WRITE_DATA
;
7194 if (rights
& KAUTH_VNODE_WRITE_RIGHTS
) {
7196 /* check per-filesystem options if possible */
7200 /* check for no-EA filesystems */
7201 if ((rights
& KAUTH_VNODE_WRITE_EXTATTRIBUTES
) &&
7202 (vfs_flags(mp
) & MNT_NOUSERXATTR
)) {
7203 KAUTH_DEBUG("%p DENIED - filesystem disallowed extended attributes", vp
);
7204 error
= EACCES
; /* User attributes disabled */
7210 * check for file immutability. first, check if the requested rights are
7211 * allowable for a UF_APPEND file.
7214 if (vp
->v_type
== VDIR
) {
7215 if ((rights
& (KAUTH_VNODE_ADD_FILE
| KAUTH_VNODE_ADD_SUBDIRECTORY
| KAUTH_VNODE_WRITE_EXTATTRIBUTES
)) == rights
)
7218 if ((rights
& (KAUTH_VNODE_APPEND_DATA
| KAUTH_VNODE_WRITE_EXTATTRIBUTES
)) == rights
)
7221 if ((error
= vnode_immutable(vap
, append
, ignore
)) != 0) {
7222 KAUTH_DEBUG("%p DENIED - file is immutable", vp
);
7231 * Handle authorization actions for filesystems that advertise that the
7232 * server will be enforcing.
7234 * Returns: 0 Authorization should be handled locally
7235 * 1 Authorization was handled by the FS
7237 * Note: Imputed returns will only occur if the authorization request
7238 * was handled by the FS.
7240 * Imputed: *resultp, modified Return code from FS when the request is
7241 * handled by the FS.
7246 vnode_authorize_opaque(vnode_t vp
, int *resultp
, kauth_action_t action
, vfs_context_t ctx
)
7251 * If the vp is a device node, socket or FIFO it actually represents a local
7252 * endpoint, so we need to handle it locally.
7254 switch(vp
->v_type
) {
7265 * In the advisory request case, if the filesystem doesn't think it's reliable
7266 * we will attempt to formulate a result ourselves based on VNOP_GETATTR data.
7268 if ((action
& KAUTH_VNODE_ACCESS
) && !vfs_authopaqueaccess(vp
->v_mount
))
7272 * Let the filesystem have a say in the matter. It's OK for it to not implemnent
7273 * VNOP_ACCESS, as most will authorise inline with the actual request.
7275 if ((error
= VNOP_ACCESS(vp
, action
, ctx
)) != ENOTSUP
) {
7277 KAUTH_DEBUG("%p DENIED - opaque filesystem VNOP_ACCESS denied access", vp
);
7282 * Typically opaque filesystems do authorisation in-line, but exec is a special case. In
7283 * order to be reasonably sure that exec will be permitted, we try a bit harder here.
7285 if ((action
& KAUTH_VNODE_EXECUTE
) && (vp
->v_type
== VREG
)) {
7286 /* try a VNOP_OPEN for readonly access */
7287 if ((error
= VNOP_OPEN(vp
, FREAD
, ctx
)) != 0) {
7289 KAUTH_DEBUG("%p DENIED - EXECUTE denied because file could not be opened readonly", vp
);
7292 VNOP_CLOSE(vp
, FREAD
, ctx
);
7296 * We don't have any reason to believe that the request has to be denied at this point,
7297 * so go ahead and allow it.
7300 KAUTH_DEBUG("%p ALLOWED - bypassing access check for non-local filesystem", vp
);
7308 * Returns: KAUTH_RESULT_ALLOW
7311 * Imputed: *arg3, modified Error code in the deny case
7312 * EROFS Read-only file system
7313 * EACCES Permission denied
7314 * EPERM Operation not permitted [no execute]
7315 * vnode_getattr:ENOMEM Not enough space [only if has filesec]
7317 * vnode_authorize_opaque:*arg2 ???
7318 * vnode_authorize_checkimmutable:???
7319 * vnode_authorize_delete:???
7320 * vnode_authorize_simple:???
7325 vnode_authorize_callback(kauth_cred_t cred
, void *idata
, kauth_action_t action
,
7326 uintptr_t arg0
, uintptr_t arg1
, uintptr_t arg2
, uintptr_t arg3
)
7329 vnode_t cvp
= NULLVP
;
7331 int result
= KAUTH_RESULT_DENY
;
7332 int parent_iocount
= 0;
7333 int parent_action
; /* In case we need to use namedstream's data fork for cached rights*/
7335 ctx
= (vfs_context_t
)arg0
;
7337 dvp
= (vnode_t
)arg2
;
7340 * if there are 2 vnodes passed in, we don't know at
7341 * this point which rights to look at based on the
7342 * combined action being passed in... defer until later...
7343 * otherwise check the kauth 'rights' cache hung
7344 * off of the vnode we're interested in... if we've already
7345 * been granted the right we're currently interested in,
7346 * we can just return success... otherwise we'll go through
7347 * the process of authorizing the requested right(s)... if that
7348 * succeeds, we'll add the right(s) to the cache.
7349 * VNOP_SETATTR and VNOP_SETXATTR will invalidate this cache
7357 * For named streams on local-authorization volumes, rights are cached on the parent;
7358 * authorization is determined by looking at the parent's properties anyway, so storing
7359 * on the parent means that we don't recompute for the named stream and that if
7360 * we need to flush rights (e.g. on VNOP_SETATTR()) we don't need to track down the
7361 * stream to flush its cache separately. If we miss in the cache, then we authorize
7362 * as if there were no cached rights (passing the named stream vnode and desired rights to
7363 * vnode_authorize_callback_int()).
7365 * On an opaquely authorized volume, we don't know the relationship between the
7366 * data fork's properties and the rights granted on a stream. Thus, named stream vnodes
7367 * on such a volume are authorized directly (rather than using the parent) and have their
7368 * own caches. When a named stream vnode is created, we mark the parent as having a named
7369 * stream. On a VNOP_SETATTR() for the parent that may invalidate cached authorization, we
7370 * find the stream and flush its cache.
7372 if (vnode_isnamedstream(vp
) && (!vfs_authopaque(vp
->v_mount
))) {
7373 cvp
= vnode_getparent(vp
);
7374 if (cvp
!= NULLVP
) {
7378 goto defer
; /* If we can't use the parent, take the slow path */
7381 /* Have to translate some actions */
7382 parent_action
= action
;
7383 if (parent_action
& KAUTH_VNODE_READ_DATA
) {
7384 parent_action
&= ~KAUTH_VNODE_READ_DATA
;
7385 parent_action
|= KAUTH_VNODE_READ_EXTATTRIBUTES
;
7387 if (parent_action
& KAUTH_VNODE_WRITE_DATA
) {
7388 parent_action
&= ~KAUTH_VNODE_WRITE_DATA
;
7389 parent_action
|= KAUTH_VNODE_WRITE_EXTATTRIBUTES
;
7397 if (vnode_cache_is_authorized(cvp
, ctx
, parent_iocount
? parent_action
: action
) == TRUE
) {
7398 result
= KAUTH_RESULT_ALLOW
;
7402 result
= vnode_authorize_callback_int(cred
, idata
, action
, arg0
, arg1
, arg2
, arg3
);
7404 if (result
== KAUTH_RESULT_ALLOW
&& cvp
!= NULLVP
) {
7405 KAUTH_DEBUG("%p - caching action = %x", cvp
, action
);
7406 vnode_cache_authorized_action(cvp
, ctx
, action
);
7410 if (parent_iocount
) {
7419 vnode_authorize_callback_int(__unused kauth_cred_t unused_cred
, __unused
void *idata
, kauth_action_t action
,
7420 uintptr_t arg0
, uintptr_t arg1
, uintptr_t arg2
, uintptr_t arg3
)
7422 struct _vnode_authorize_context auth_context
;
7427 kauth_ace_rights_t rights
;
7428 struct vnode_attr va
, dva
;
7432 boolean_t parent_authorized_for_delete_child
= FALSE
;
7433 boolean_t found_deny
= FALSE
;
7434 boolean_t parent_ref
= FALSE
;
7435 boolean_t is_suser
= FALSE
;
7437 vcp
= &auth_context
;
7438 ctx
= vcp
->ctx
= (vfs_context_t
)arg0
;
7439 vp
= vcp
->vp
= (vnode_t
)arg1
;
7440 dvp
= vcp
->dvp
= (vnode_t
)arg2
;
7441 errorp
= (int *)arg3
;
7443 * Note that we authorize against the context, not the passed cred
7444 * (the same thing anyway)
7446 cred
= ctx
->vc_ucred
;
7453 vcp
->flags
= vcp
->flags_valid
= 0;
7456 if ((ctx
== NULL
) || (vp
== NULL
) || (cred
== NULL
))
7457 panic("vnode_authorize: bad arguments (context %p vp %p cred %p)", ctx
, vp
, cred
);
7460 KAUTH_DEBUG("%p AUTH - %s %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s on %s '%s' (0x%x:%p/%p)",
7461 vp
, vfs_context_proc(ctx
)->p_comm
,
7462 (action
& KAUTH_VNODE_ACCESS
) ? "access" : "auth",
7463 (action
& KAUTH_VNODE_READ_DATA
) ? vnode_isdir(vp
) ? " LIST_DIRECTORY" : " READ_DATA" : "",
7464 (action
& KAUTH_VNODE_WRITE_DATA
) ? vnode_isdir(vp
) ? " ADD_FILE" : " WRITE_DATA" : "",
7465 (action
& KAUTH_VNODE_EXECUTE
) ? vnode_isdir(vp
) ? " SEARCH" : " EXECUTE" : "",
7466 (action
& KAUTH_VNODE_DELETE
) ? " DELETE" : "",
7467 (action
& KAUTH_VNODE_APPEND_DATA
) ? vnode_isdir(vp
) ? " ADD_SUBDIRECTORY" : " APPEND_DATA" : "",
7468 (action
& KAUTH_VNODE_DELETE_CHILD
) ? " DELETE_CHILD" : "",
7469 (action
& KAUTH_VNODE_READ_ATTRIBUTES
) ? " READ_ATTRIBUTES" : "",
7470 (action
& KAUTH_VNODE_WRITE_ATTRIBUTES
) ? " WRITE_ATTRIBUTES" : "",
7471 (action
& KAUTH_VNODE_READ_EXTATTRIBUTES
) ? " READ_EXTATTRIBUTES" : "",
7472 (action
& KAUTH_VNODE_WRITE_EXTATTRIBUTES
) ? " WRITE_EXTATTRIBUTES" : "",
7473 (action
& KAUTH_VNODE_READ_SECURITY
) ? " READ_SECURITY" : "",
7474 (action
& KAUTH_VNODE_WRITE_SECURITY
) ? " WRITE_SECURITY" : "",
7475 (action
& KAUTH_VNODE_CHANGE_OWNER
) ? " CHANGE_OWNER" : "",
7476 (action
& KAUTH_VNODE_NOIMMUTABLE
) ? " (noimmutable)" : "",
7477 vnode_isdir(vp
) ? "directory" : "file",
7478 vp
->v_name
? vp
->v_name
: "<NULL>", action
, vp
, dvp
);
7481 * Extract the control bits from the action, everything else is
7484 noimmutable
= (action
& KAUTH_VNODE_NOIMMUTABLE
) ? 1 : 0;
7485 rights
= action
& ~(KAUTH_VNODE_ACCESS
| KAUTH_VNODE_NOIMMUTABLE
);
7487 if (rights
& KAUTH_VNODE_DELETE
) {
7490 panic("vnode_authorize: KAUTH_VNODE_DELETE test requires a directory");
7493 * check to see if we've already authorized the parent
7494 * directory for deletion of its children... if so, we
7495 * can skip a whole bunch of work... we will still have to
7496 * authorize that this specific child can be removed
7498 if (vnode_cache_is_authorized(dvp
, ctx
, KAUTH_VNODE_DELETE_CHILD
) == TRUE
)
7499 parent_authorized_for_delete_child
= TRUE
;
7505 * Check for read-only filesystems.
7507 if ((rights
& KAUTH_VNODE_WRITE_RIGHTS
) &&
7508 (vp
->v_mount
->mnt_flag
& MNT_RDONLY
) &&
7509 ((vp
->v_type
== VREG
) || (vp
->v_type
== VDIR
) ||
7510 (vp
->v_type
== VLNK
) || (vp
->v_type
== VCPLX
) ||
7511 (rights
& KAUTH_VNODE_DELETE
) || (rights
& KAUTH_VNODE_DELETE_CHILD
))) {
7517 * Check for noexec filesystems.
7519 if ((rights
& KAUTH_VNODE_EXECUTE
) && (vp
->v_type
== VREG
) && (vp
->v_mount
->mnt_flag
& MNT_NOEXEC
)) {
7525 * Handle cases related to filesystems with non-local enforcement.
7526 * This call can return 0, in which case we will fall through to perform a
7527 * check based on VNOP_GETATTR data. Otherwise it returns 1 and sets
7528 * an appropriate result, at which point we can return immediately.
7530 if ((vp
->v_mount
->mnt_kern_flag
& MNTK_AUTH_OPAQUE
) && vnode_authorize_opaque(vp
, &result
, action
, ctx
))
7534 * If the vnode is a namedstream (extended attribute) data vnode (eg.
7535 * a resource fork), *_DATA becomes *_EXTATTRIBUTES.
7537 if (vnode_isnamedstream(vp
)) {
7538 if (rights
& KAUTH_VNODE_READ_DATA
) {
7539 rights
&= ~KAUTH_VNODE_READ_DATA
;
7540 rights
|= KAUTH_VNODE_READ_EXTATTRIBUTES
;
7542 if (rights
& KAUTH_VNODE_WRITE_DATA
) {
7543 rights
&= ~KAUTH_VNODE_WRITE_DATA
;
7544 rights
|= KAUTH_VNODE_WRITE_EXTATTRIBUTES
;
7548 * Point 'vp' to the namedstream's parent for ACL checking
7550 if ((vp
->v_parent
!= NULL
) &&
7551 (vget_internal(vp
->v_parent
, 0, VNODE_NODEAD
| VNODE_DRAINO
) == 0)) {
7553 vcp
->vp
= vp
= vp
->v_parent
;
7557 if (vfs_context_issuser(ctx
)) {
7559 * if we're not asking for execute permissions or modifications,
7560 * then we're done, this action is authorized.
7562 if (!(rights
& (KAUTH_VNODE_EXECUTE
| KAUTH_VNODE_WRITE_RIGHTS
)))
7569 * Get vnode attributes and extended security information for the vnode
7570 * and directory if required.
7572 * If we're root we only want mode bits and flags for checking
7573 * execute and immutability.
7575 VATTR_WANTED(&va
, va_mode
);
7576 VATTR_WANTED(&va
, va_flags
);
7578 VATTR_WANTED(&va
, va_uid
);
7579 VATTR_WANTED(&va
, va_gid
);
7580 VATTR_WANTED(&va
, va_acl
);
7582 if ((result
= vnode_getattr(vp
, &va
, ctx
)) != 0) {
7583 KAUTH_DEBUG("%p ERROR - failed to get vnode attributes - %d", vp
, result
);
7587 VATTR_WANTED(&dva
, va_mode
);
7588 VATTR_WANTED(&dva
, va_flags
);
7590 VATTR_WANTED(&dva
, va_uid
);
7591 VATTR_WANTED(&dva
, va_gid
);
7592 VATTR_WANTED(&dva
, va_acl
);
7594 if ((result
= vnode_getattr(dvp
, &dva
, ctx
)) != 0) {
7595 KAUTH_DEBUG("%p ERROR - failed to get directory vnode attributes - %d", vp
, result
);
7601 * Check for immutability.
7603 * In the deletion case, parent directory immutability vetoes specific
7606 if ((result
= vnode_authorize_checkimmutable(vp
, &va
, rights
, noimmutable
)) != 0)
7608 if ((rights
& KAUTH_VNODE_DELETE
) &&
7609 parent_authorized_for_delete_child
== FALSE
&&
7610 ((result
= vnode_authorize_checkimmutable(dvp
, &dva
, KAUTH_VNODE_DELETE_CHILD
, 0)) != 0))
7614 * Clear rights that have been authorized by reaching this point, bail if nothing left to
7617 rights
&= ~(KAUTH_VNODE_LINKTARGET
| KAUTH_VNODE_CHECKIMMUTABLE
);
7622 * If we're not the superuser, authorize based on file properties;
7623 * note that even if parent_authorized_for_delete_child is TRUE, we
7624 * need to check on the node itself.
7627 /* process delete rights */
7628 if ((rights
& KAUTH_VNODE_DELETE
) &&
7629 ((result
= vnode_authorize_delete(vcp
, parent_authorized_for_delete_child
)) != 0))
7632 /* process remaining rights */
7633 if ((rights
& ~KAUTH_VNODE_DELETE
) &&
7634 (result
= vnode_authorize_simple(vcp
, rights
, rights
& KAUTH_VNODE_DELETE
, &found_deny
)) != 0)
7639 * Execute is only granted to root if one of the x bits is set. This check only
7640 * makes sense if the posix mode bits are actually supported.
7642 if ((rights
& KAUTH_VNODE_EXECUTE
) &&
7643 (vp
->v_type
== VREG
) &&
7644 VATTR_IS_SUPPORTED(&va
, va_mode
) &&
7645 !(va
.va_mode
& (S_IXUSR
| S_IXGRP
| S_IXOTH
))) {
7647 KAUTH_DEBUG("%p DENIED - root execute requires at least one x bit in 0x%x", vp
, va
.va_mode
);
7651 /* Assume that there were DENYs so we don't wrongly cache KAUTH_VNODE_SEARCHBYANYONE */
7654 KAUTH_DEBUG("%p ALLOWED - caller is superuser", vp
);
7657 if (VATTR_IS_SUPPORTED(&va
, va_acl
) && (va
.va_acl
!= NULL
))
7658 kauth_acl_free(va
.va_acl
);
7659 if (VATTR_IS_SUPPORTED(&dva
, va_acl
) && (dva
.va_acl
!= NULL
))
7660 kauth_acl_free(dva
.va_acl
);
7666 KAUTH_DEBUG("%p DENIED - auth denied", vp
);
7667 return(KAUTH_RESULT_DENY
);
7669 if ((rights
& KAUTH_VNODE_SEARCH
) && found_deny
== FALSE
&& vp
->v_type
== VDIR
) {
7671 * if we were successfully granted the right to search this directory
7672 * and there were NO ACL DENYs for search and the posix permissions also don't
7673 * deny execute, we can synthesize a global right that allows anyone to
7674 * traverse this directory during a pathname lookup without having to
7675 * match the credential associated with this cache of rights.
7677 * Note that we can correctly cache KAUTH_VNODE_SEARCHBYANYONE
7678 * only if we actually check ACLs which we don't for root. As
7679 * a workaround, the lookup fast path checks for root.
7681 if (!VATTR_IS_SUPPORTED(&va
, va_mode
) ||
7682 ((va
.va_mode
& (S_IXUSR
| S_IXGRP
| S_IXOTH
)) ==
7683 (S_IXUSR
| S_IXGRP
| S_IXOTH
))) {
7684 vnode_cache_authorized_action(vp
, ctx
, KAUTH_VNODE_SEARCHBYANYONE
);
7692 * Note that this implies that we will allow requests for no rights, as well as
7693 * for rights that we do not recognise. There should be none of these.
7695 KAUTH_DEBUG("%p ALLOWED - auth granted", vp
);
7696 return(KAUTH_RESULT_ALLOW
);
7700 vnode_authattr_new(vnode_t dvp
, struct vnode_attr
*vap
, int noauth
, vfs_context_t ctx
)
7702 return vnode_authattr_new_internal(dvp
, vap
, noauth
, NULL
, ctx
);
7706 * Check that the attribute information in vattr can be legally applied to
7707 * a new file by the context.
7710 vnode_authattr_new_internal(vnode_t dvp
, struct vnode_attr
*vap
, int noauth
, uint32_t *defaulted_fieldsp
, vfs_context_t ctx
)
7713 int has_priv_suser
, ismember
, defaulted_owner
, defaulted_group
, defaulted_mode
, inherit_restricted
;
7717 struct vnode_attr dva
;
7721 if (defaulted_fieldsp
) {
7722 *defaulted_fieldsp
= 0;
7725 defaulted_owner
= defaulted_group
= defaulted_mode
= 0;
7727 inherit_restricted
= 0;
7730 * Require that the filesystem support extended security to apply any.
7732 if (!vfs_extendedsecurity(dvp
->v_mount
) &&
7733 (VATTR_IS_ACTIVE(vap
, va_acl
) || VATTR_IS_ACTIVE(vap
, va_uuuid
) || VATTR_IS_ACTIVE(vap
, va_guuid
))) {
7739 * Default some fields.
7744 * If the filesystem is mounted IGNORE_OWNERSHIP and an explicit owner is set, that
7745 * owner takes ownership of all new files.
7747 if ((dmp
->mnt_flag
& MNT_IGNORE_OWNERSHIP
) && (dmp
->mnt_fsowner
!= KAUTH_UID_NONE
)) {
7748 VATTR_SET(vap
, va_uid
, dmp
->mnt_fsowner
);
7749 defaulted_owner
= 1;
7751 if (!VATTR_IS_ACTIVE(vap
, va_uid
)) {
7752 /* default owner is current user */
7753 VATTR_SET(vap
, va_uid
, kauth_cred_getuid(vfs_context_ucred(ctx
)));
7754 defaulted_owner
= 1;
7759 * We need the dvp's va_flags and *may* need the gid of the directory,
7760 * we ask for both here.
7763 VATTR_WANTED(&dva
, va_gid
);
7764 VATTR_WANTED(&dva
, va_flags
);
7765 if ((error
= vnode_getattr(dvp
, &dva
, ctx
)) != 0)
7769 * If the filesystem is mounted IGNORE_OWNERSHIP and an explicit grouo is set, that
7770 * group takes ownership of all new files.
7772 if ((dmp
->mnt_flag
& MNT_IGNORE_OWNERSHIP
) && (dmp
->mnt_fsgroup
!= KAUTH_GID_NONE
)) {
7773 VATTR_SET(vap
, va_gid
, dmp
->mnt_fsgroup
);
7774 defaulted_group
= 1;
7776 if (!VATTR_IS_ACTIVE(vap
, va_gid
)) {
7777 /* default group comes from parent object, fallback to current user */
7778 if (VATTR_IS_SUPPORTED(&dva
, va_gid
)) {
7779 VATTR_SET(vap
, va_gid
, dva
.va_gid
);
7781 VATTR_SET(vap
, va_gid
, kauth_cred_getgid(vfs_context_ucred(ctx
)));
7783 defaulted_group
= 1;
7787 if (!VATTR_IS_ACTIVE(vap
, va_flags
))
7788 VATTR_SET(vap
, va_flags
, 0);
7790 /* Determine if SF_RESTRICTED should be inherited from the parent
7792 if (VATTR_IS_SUPPORTED(&dva
, va_flags
) &&
7793 (dva
.va_flags
& SF_RESTRICTED
)) {
7794 inherit_restricted
= 1;
7797 /* default mode is everything, masked with current umask */
7798 if (!VATTR_IS_ACTIVE(vap
, va_mode
)) {
7799 VATTR_SET(vap
, va_mode
, ACCESSPERMS
& ~vfs_context_proc(ctx
)->p_fd
->fd_cmask
);
7800 KAUTH_DEBUG("ATTR - defaulting new file mode to %o from umask %o", vap
->va_mode
, vfs_context_proc(ctx
)->p_fd
->fd_cmask
);
7803 /* set timestamps to now */
7804 if (!VATTR_IS_ACTIVE(vap
, va_create_time
)) {
7805 nanotime(&vap
->va_create_time
);
7806 VATTR_SET_ACTIVE(vap
, va_create_time
);
7810 * Check for attempts to set nonsensical fields.
7812 if (vap
->va_active
& ~VNODE_ATTR_NEWOBJ
) {
7814 KAUTH_DEBUG("ATTR - ERROR - attempt to set unsupported new-file attributes %llx",
7815 vap
->va_active
& ~VNODE_ATTR_NEWOBJ
);
7820 * Quickly check for the applicability of any enforcement here.
7821 * Tests below maintain the integrity of the local security model.
7823 if (vfs_authopaque(dvp
->v_mount
))
7827 * We need to know if the caller is the superuser, or if the work is
7828 * otherwise already authorised.
7830 cred
= vfs_context_ucred(ctx
);
7832 /* doing work for the kernel */
7835 has_priv_suser
= vfs_context_issuser(ctx
);
7839 if (VATTR_IS_ACTIVE(vap
, va_flags
)) {
7840 if (has_priv_suser
) {
7841 if ((vap
->va_flags
& (UF_SETTABLE
| SF_SETTABLE
)) != vap
->va_flags
) {
7843 KAUTH_DEBUG(" DENIED - superuser attempt to set illegal flag(s)");
7847 if ((vap
->va_flags
& UF_SETTABLE
) != vap
->va_flags
) {
7849 KAUTH_DEBUG(" DENIED - user attempt to set illegal flag(s)");
7855 /* if not superuser, validate legality of new-item attributes */
7856 if (!has_priv_suser
) {
7857 if (!defaulted_mode
&& VATTR_IS_ACTIVE(vap
, va_mode
)) {
7859 if (vap
->va_mode
& S_ISGID
) {
7860 if ((error
= kauth_cred_ismember_gid(cred
, vap
->va_gid
, &ismember
)) != 0) {
7861 KAUTH_DEBUG("ATTR - ERROR: got %d checking for membership in %d", error
, vap
->va_gid
);
7865 KAUTH_DEBUG(" DENIED - can't set SGID bit, not a member of %d", vap
->va_gid
);
7872 if ((vap
->va_mode
& S_ISUID
) && (vap
->va_uid
!= kauth_cred_getuid(cred
))) {
7873 KAUTH_DEBUG("ATTR - ERROR: illegal attempt to set the setuid bit");
7878 if (!defaulted_owner
&& (vap
->va_uid
!= kauth_cred_getuid(cred
))) {
7879 KAUTH_DEBUG(" DENIED - cannot create new item owned by %d", vap
->va_uid
);
7883 if (!defaulted_group
) {
7884 if ((error
= kauth_cred_ismember_gid(cred
, vap
->va_gid
, &ismember
)) != 0) {
7885 KAUTH_DEBUG(" ERROR - got %d checking for membership in %d", error
, vap
->va_gid
);
7889 KAUTH_DEBUG(" DENIED - cannot create new item with group %d - not a member", vap
->va_gid
);
7895 /* initialising owner/group UUID */
7896 if (VATTR_IS_ACTIVE(vap
, va_uuuid
)) {
7897 if ((error
= kauth_cred_getguid(cred
, &changer
)) != 0) {
7898 KAUTH_DEBUG(" ERROR - got %d trying to get caller UUID", error
);
7899 /* XXX ENOENT here - no GUID - should perhaps become EPERM */
7902 if (!kauth_guid_equal(&vap
->va_uuuid
, &changer
)) {
7903 KAUTH_DEBUG(" ERROR - cannot create item with supplied owner UUID - not us");
7908 if (VATTR_IS_ACTIVE(vap
, va_guuid
)) {
7909 if ((error
= kauth_cred_ismember_guid(cred
, &vap
->va_guuid
, &ismember
)) != 0) {
7910 KAUTH_DEBUG(" ERROR - got %d trying to check group membership", error
);
7914 KAUTH_DEBUG(" ERROR - cannot create item with supplied group UUID - not a member");
7921 if (inherit_restricted
) {
7922 /* Apply SF_RESTRICTED to the file if its parent directory was
7923 * restricted. This is done at the end so that root is not
7924 * required if this flag is only set due to inheritance. */
7925 VATTR_SET(vap
, va_flags
, (vap
->va_flags
| SF_RESTRICTED
));
7927 if (defaulted_fieldsp
) {
7928 if (defaulted_mode
) {
7929 *defaulted_fieldsp
|= VATTR_PREPARE_DEFAULTED_MODE
;
7931 if (defaulted_group
) {
7932 *defaulted_fieldsp
|= VATTR_PREPARE_DEFAULTED_GID
;
7934 if (defaulted_owner
) {
7935 *defaulted_fieldsp
|= VATTR_PREPARE_DEFAULTED_UID
;
7942 * Check that the attribute information in vap can be legally written by the
7945 * Call this when you're not sure about the vnode_attr; either its contents
7946 * have come from an unknown source, or when they are variable.
7948 * Returns errno, or zero and sets *actionp to the KAUTH_VNODE_* actions that
7949 * must be authorized to be permitted to write the vattr.
7952 vnode_authattr(vnode_t vp
, struct vnode_attr
*vap
, kauth_action_t
*actionp
, vfs_context_t ctx
)
7954 struct vnode_attr ova
;
7955 kauth_action_t required_action
;
7956 int error
, has_priv_suser
, ismember
, chowner
, chgroup
, clear_suid
, clear_sgid
;
7965 required_action
= 0;
7969 * Quickly check for enforcement applicability.
7971 if (vfs_authopaque(vp
->v_mount
))
7975 * Check for attempts to set nonsensical fields.
7977 if (vap
->va_active
& VNODE_ATTR_RDONLY
) {
7978 KAUTH_DEBUG("ATTR - ERROR: attempt to set readonly attribute(s)");
7984 * We need to know if the caller is the superuser.
7986 cred
= vfs_context_ucred(ctx
);
7987 has_priv_suser
= kauth_cred_issuser(cred
);
7990 * If any of the following are changing, we need information from the old file:
7997 if (VATTR_IS_ACTIVE(vap
, va_uid
) ||
7998 VATTR_IS_ACTIVE(vap
, va_gid
) ||
7999 VATTR_IS_ACTIVE(vap
, va_mode
) ||
8000 VATTR_IS_ACTIVE(vap
, va_uuuid
) ||
8001 VATTR_IS_ACTIVE(vap
, va_guuid
)) {
8002 VATTR_WANTED(&ova
, va_mode
);
8003 VATTR_WANTED(&ova
, va_uid
);
8004 VATTR_WANTED(&ova
, va_gid
);
8005 VATTR_WANTED(&ova
, va_uuuid
);
8006 VATTR_WANTED(&ova
, va_guuid
);
8007 KAUTH_DEBUG("ATTR - security information changing, fetching existing attributes");
8011 * If timestamps are being changed, we need to know who the file is owned
8014 if (VATTR_IS_ACTIVE(vap
, va_create_time
) ||
8015 VATTR_IS_ACTIVE(vap
, va_change_time
) ||
8016 VATTR_IS_ACTIVE(vap
, va_modify_time
) ||
8017 VATTR_IS_ACTIVE(vap
, va_access_time
) ||
8018 VATTR_IS_ACTIVE(vap
, va_backup_time
)) {
8020 VATTR_WANTED(&ova
, va_uid
);
8021 #if 0 /* enable this when we support UUIDs as official owners */
8022 VATTR_WANTED(&ova
, va_uuuid
);
8024 KAUTH_DEBUG("ATTR - timestamps changing, fetching uid and GUID");
8028 * If flags are being changed, we need the old flags.
8030 if (VATTR_IS_ACTIVE(vap
, va_flags
)) {
8031 KAUTH_DEBUG("ATTR - flags changing, fetching old flags");
8032 VATTR_WANTED(&ova
, va_flags
);
8036 * If ACLs are being changed, we need the old ACLs.
8038 if (VATTR_IS_ACTIVE(vap
, va_acl
)) {
8039 KAUTH_DEBUG("ATTR - acl changing, fetching old flags");
8040 VATTR_WANTED(&ova
, va_acl
);
8044 * If the size is being set, make sure it's not a directory.
8046 if (VATTR_IS_ACTIVE(vap
, va_data_size
)) {
8047 /* size is only meaningful on regular files, don't permit otherwise */
8048 if (!vnode_isreg(vp
)) {
8049 KAUTH_DEBUG("ATTR - ERROR: size change requested on non-file");
8050 error
= vnode_isdir(vp
) ? EISDIR
: EINVAL
;
8058 KAUTH_DEBUG("ATTR - fetching old attributes %016llx", ova
.va_active
);
8059 if ((error
= vnode_getattr(vp
, &ova
, ctx
)) != 0) {
8060 KAUTH_DEBUG(" ERROR - got %d trying to get attributes", error
);
8065 * Size changes require write access to the file data.
8067 if (VATTR_IS_ACTIVE(vap
, va_data_size
)) {
8068 /* if we can't get the size, or it's different, we need write access */
8069 KAUTH_DEBUG("ATTR - size change, requiring WRITE_DATA");
8070 required_action
|= KAUTH_VNODE_WRITE_DATA
;
8074 * Changing timestamps?
8076 * Note that we are only called to authorize user-requested time changes;
8077 * side-effect time changes are not authorized. Authorisation is only
8078 * required for existing files.
8080 * Non-owners are not permitted to change the time on an existing
8081 * file to anything other than the current time.
8083 if (VATTR_IS_ACTIVE(vap
, va_create_time
) ||
8084 VATTR_IS_ACTIVE(vap
, va_change_time
) ||
8085 VATTR_IS_ACTIVE(vap
, va_modify_time
) ||
8086 VATTR_IS_ACTIVE(vap
, va_access_time
) ||
8087 VATTR_IS_ACTIVE(vap
, va_backup_time
)) {
8089 * The owner and root may set any timestamps they like,
8090 * provided that the file is not immutable. The owner still needs
8091 * WRITE_ATTRIBUTES (implied by ownership but still deniable).
8093 if (has_priv_suser
|| vauth_node_owner(&ova
, cred
)) {
8094 KAUTH_DEBUG("ATTR - root or owner changing timestamps");
8095 required_action
|= KAUTH_VNODE_CHECKIMMUTABLE
| KAUTH_VNODE_WRITE_ATTRIBUTES
;
8097 /* just setting the current time? */
8098 if (vap
->va_vaflags
& VA_UTIMES_NULL
) {
8099 KAUTH_DEBUG("ATTR - non-root/owner changing timestamps, requiring WRITE_ATTRIBUTES");
8100 required_action
|= KAUTH_VNODE_WRITE_ATTRIBUTES
;
8102 KAUTH_DEBUG("ATTR - ERROR: illegal timestamp modification attempted");
8110 * Changing file mode?
8112 if (VATTR_IS_ACTIVE(vap
, va_mode
) && VATTR_IS_SUPPORTED(&ova
, va_mode
) && (ova
.va_mode
!= vap
->va_mode
)) {
8113 KAUTH_DEBUG("ATTR - mode change from %06o to %06o", ova
.va_mode
, vap
->va_mode
);
8116 * Mode changes always have the same basic auth requirements.
8118 if (has_priv_suser
) {
8119 KAUTH_DEBUG("ATTR - superuser mode change, requiring immutability check");
8120 required_action
|= KAUTH_VNODE_CHECKIMMUTABLE
;
8122 /* need WRITE_SECURITY */
8123 KAUTH_DEBUG("ATTR - non-superuser mode change, requiring WRITE_SECURITY");
8124 required_action
|= KAUTH_VNODE_WRITE_SECURITY
;
8128 * Can't set the setgid bit if you're not in the group and not root. Have to have
8129 * existing group information in the case we're not setting it right now.
8131 if (vap
->va_mode
& S_ISGID
) {
8132 required_action
|= KAUTH_VNODE_CHECKIMMUTABLE
; /* always required */
8133 if (!has_priv_suser
) {
8134 if (VATTR_IS_ACTIVE(vap
, va_gid
)) {
8135 group
= vap
->va_gid
;
8136 } else if (VATTR_IS_SUPPORTED(&ova
, va_gid
)) {
8139 KAUTH_DEBUG("ATTR - ERROR: setgid but no gid available");
8144 * This might be too restrictive; WRITE_SECURITY might be implied by
8145 * membership in this case, rather than being an additional requirement.
8147 if ((error
= kauth_cred_ismember_gid(cred
, group
, &ismember
)) != 0) {
8148 KAUTH_DEBUG("ATTR - ERROR: got %d checking for membership in %d", error
, vap
->va_gid
);
8152 KAUTH_DEBUG(" DENIED - can't set SGID bit, not a member of %d", group
);
8160 * Can't set the setuid bit unless you're root or the file's owner.
8162 if (vap
->va_mode
& S_ISUID
) {
8163 required_action
|= KAUTH_VNODE_CHECKIMMUTABLE
; /* always required */
8164 if (!has_priv_suser
) {
8165 if (VATTR_IS_ACTIVE(vap
, va_uid
)) {
8166 owner
= vap
->va_uid
;
8167 } else if (VATTR_IS_SUPPORTED(&ova
, va_uid
)) {
8170 KAUTH_DEBUG("ATTR - ERROR: setuid but no uid available");
8174 if (owner
!= kauth_cred_getuid(cred
)) {
8176 * We could allow this if WRITE_SECURITY is permitted, perhaps.
8178 KAUTH_DEBUG("ATTR - ERROR: illegal attempt to set the setuid bit");
8187 * Validate/mask flags changes. This checks that only the flags in
8188 * the UF_SETTABLE mask are being set, and preserves the flags in
8189 * the SF_SETTABLE case.
8191 * Since flags changes may be made in conjunction with other changes,
8192 * we will ask the auth code to ignore immutability in the case that
8193 * the SF_* flags are not set and we are only manipulating the file flags.
8196 if (VATTR_IS_ACTIVE(vap
, va_flags
)) {
8197 /* compute changing flags bits */
8198 if (VATTR_IS_SUPPORTED(&ova
, va_flags
)) {
8199 fdelta
= vap
->va_flags
^ ova
.va_flags
;
8201 fdelta
= vap
->va_flags
;
8205 KAUTH_DEBUG("ATTR - flags changing, requiring WRITE_SECURITY");
8206 required_action
|= KAUTH_VNODE_WRITE_SECURITY
;
8208 /* check that changing bits are legal */
8209 if (has_priv_suser
) {
8211 * The immutability check will prevent us from clearing the SF_*
8212 * flags unless the system securelevel permits it, so just check
8213 * for legal flags here.
8215 if (fdelta
& ~(UF_SETTABLE
| SF_SETTABLE
)) {
8217 KAUTH_DEBUG(" DENIED - superuser attempt to set illegal flag(s)");
8221 if (fdelta
& ~UF_SETTABLE
) {
8223 KAUTH_DEBUG(" DENIED - user attempt to set illegal flag(s)");
8228 * If the caller has the ability to manipulate file flags,
8229 * security is not reduced by ignoring them for this operation.
8231 * A more complete test here would consider the 'after' states of the flags
8232 * to determine whether it would permit the operation, but this becomes
8235 * Ignoring immutability is conditional on securelevel; this does not bypass
8236 * the SF_* flags if securelevel > 0.
8238 required_action
|= KAUTH_VNODE_NOIMMUTABLE
;
8243 * Validate ownership information.
8252 * Note that if the filesystem didn't give us a UID, we expect that it doesn't
8253 * support them in general, and will ignore it if/when we try to set it.
8254 * We might want to clear the uid out of vap completely here.
8256 if (VATTR_IS_ACTIVE(vap
, va_uid
)) {
8257 if (VATTR_IS_SUPPORTED(&ova
, va_uid
) && (vap
->va_uid
!= ova
.va_uid
)) {
8258 if (!has_priv_suser
&& (kauth_cred_getuid(cred
) != vap
->va_uid
)) {
8259 KAUTH_DEBUG(" DENIED - non-superuser cannot change ownershipt to a third party");
8270 * Note that if the filesystem didn't give us a GID, we expect that it doesn't
8271 * support them in general, and will ignore it if/when we try to set it.
8272 * We might want to clear the gid out of vap completely here.
8274 if (VATTR_IS_ACTIVE(vap
, va_gid
)) {
8275 if (VATTR_IS_SUPPORTED(&ova
, va_gid
) && (vap
->va_gid
!= ova
.va_gid
)) {
8276 if (!has_priv_suser
) {
8277 if ((error
= kauth_cred_ismember_gid(cred
, vap
->va_gid
, &ismember
)) != 0) {
8278 KAUTH_DEBUG(" ERROR - got %d checking for membership in %d", error
, vap
->va_gid
);
8282 KAUTH_DEBUG(" DENIED - group change from %d to %d but not a member of target group",
8283 ova
.va_gid
, vap
->va_gid
);
8294 * Owner UUID being set or changed.
8296 if (VATTR_IS_ACTIVE(vap
, va_uuuid
)) {
8297 /* if the owner UUID is not actually changing ... */
8298 if (VATTR_IS_SUPPORTED(&ova
, va_uuuid
)) {
8299 if (kauth_guid_equal(&vap
->va_uuuid
, &ova
.va_uuuid
))
8300 goto no_uuuid_change
;
8303 * If the current owner UUID is a null GUID, check
8304 * it against the UUID corresponding to the owner UID.
8306 if (kauth_guid_equal(&ova
.va_uuuid
, &kauth_null_guid
) &&
8307 VATTR_IS_SUPPORTED(&ova
, va_uid
)) {
8310 if (kauth_cred_uid2guid(ova
.va_uid
, &uid_guid
) == 0 &&
8311 kauth_guid_equal(&vap
->va_uuuid
, &uid_guid
))
8312 goto no_uuuid_change
;
8317 * The owner UUID cannot be set by a non-superuser to anything other than
8318 * their own or a null GUID (to "unset" the owner UUID).
8319 * Note that file systems must be prepared to handle the
8320 * null UUID case in a manner appropriate for that file
8323 if (!has_priv_suser
) {
8324 if ((error
= kauth_cred_getguid(cred
, &changer
)) != 0) {
8325 KAUTH_DEBUG(" ERROR - got %d trying to get caller UUID", error
);
8326 /* XXX ENOENT here - no UUID - should perhaps become EPERM */
8329 if (!kauth_guid_equal(&vap
->va_uuuid
, &changer
) &&
8330 !kauth_guid_equal(&vap
->va_uuuid
, &kauth_null_guid
)) {
8331 KAUTH_DEBUG(" ERROR - cannot set supplied owner UUID - not us / null");
8341 * Group UUID being set or changed.
8343 if (VATTR_IS_ACTIVE(vap
, va_guuid
)) {
8344 /* if the group UUID is not actually changing ... */
8345 if (VATTR_IS_SUPPORTED(&ova
, va_guuid
)) {
8346 if (kauth_guid_equal(&vap
->va_guuid
, &ova
.va_guuid
))
8347 goto no_guuid_change
;
8350 * If the current group UUID is a null UUID, check
8351 * it against the UUID corresponding to the group GID.
8353 if (kauth_guid_equal(&ova
.va_guuid
, &kauth_null_guid
) &&
8354 VATTR_IS_SUPPORTED(&ova
, va_gid
)) {
8357 if (kauth_cred_gid2guid(ova
.va_gid
, &gid_guid
) == 0 &&
8358 kauth_guid_equal(&vap
->va_guuid
, &gid_guid
))
8359 goto no_guuid_change
;
8364 * The group UUID cannot be set by a non-superuser to anything other than
8365 * one of which they are a member or a null GUID (to "unset"
8367 * Note that file systems must be prepared to handle the
8368 * null UUID case in a manner appropriate for that file
8371 if (!has_priv_suser
) {
8372 if (kauth_guid_equal(&vap
->va_guuid
, &kauth_null_guid
))
8374 else if ((error
= kauth_cred_ismember_guid(cred
, &vap
->va_guuid
, &ismember
)) != 0) {
8375 KAUTH_DEBUG(" ERROR - got %d trying to check group membership", error
);
8379 KAUTH_DEBUG(" ERROR - cannot set supplied group UUID - not a member / null");
8389 * Compute authorisation for group/ownership changes.
8391 if (chowner
|| chgroup
|| clear_suid
|| clear_sgid
) {
8392 if (has_priv_suser
) {
8393 KAUTH_DEBUG("ATTR - superuser changing file owner/group, requiring immutability check");
8394 required_action
|= KAUTH_VNODE_CHECKIMMUTABLE
;
8397 KAUTH_DEBUG("ATTR - ownership change, requiring TAKE_OWNERSHIP");
8398 required_action
|= KAUTH_VNODE_TAKE_OWNERSHIP
;
8400 if (chgroup
&& !chowner
) {
8401 KAUTH_DEBUG("ATTR - group change, requiring WRITE_SECURITY");
8402 required_action
|= KAUTH_VNODE_WRITE_SECURITY
;
8408 * clear set-uid and set-gid bits. POSIX only requires this for
8409 * non-privileged processes but we do it even for root.
8411 if (VATTR_IS_ACTIVE(vap
, va_mode
)) {
8412 newmode
= vap
->va_mode
;
8413 } else if (VATTR_IS_SUPPORTED(&ova
, va_mode
)) {
8414 newmode
= ova
.va_mode
;
8416 KAUTH_DEBUG("CHOWN - trying to change owner but cannot get mode from filesystem to mask setugid bits");
8420 /* chown always clears setuid/gid bits. An exception is made for
8421 * setattrlist executed by a root process to set <uid, gid, mode> on a file:
8422 * setattrlist is allowed to set the new mode on the file and change (chown)
8425 if (newmode
& (S_ISUID
| S_ISGID
)) {
8426 if (!VATTR_IS_ACTIVE(vap
, va_mode
) || !has_priv_suser
) {
8427 KAUTH_DEBUG("CHOWN - masking setugid bits from mode %o to %o",
8428 newmode
, newmode
& ~(S_ISUID
| S_ISGID
));
8429 newmode
&= ~(S_ISUID
| S_ISGID
);
8431 VATTR_SET(vap
, va_mode
, newmode
);
8436 * Authorise changes in the ACL.
8438 if (VATTR_IS_ACTIVE(vap
, va_acl
)) {
8440 /* no existing ACL */
8441 if (!VATTR_IS_ACTIVE(&ova
, va_acl
) || (ova
.va_acl
== NULL
)) {
8444 if (vap
->va_acl
!= NULL
) {
8445 required_action
|= KAUTH_VNODE_WRITE_SECURITY
;
8446 KAUTH_DEBUG("CHMOD - adding ACL");
8449 /* removing an existing ACL */
8450 } else if (vap
->va_acl
== NULL
) {
8451 required_action
|= KAUTH_VNODE_WRITE_SECURITY
;
8452 KAUTH_DEBUG("CHMOD - removing ACL");
8454 /* updating an existing ACL */
8456 if (vap
->va_acl
->acl_entrycount
!= ova
.va_acl
->acl_entrycount
) {
8457 /* entry count changed, must be different */
8458 required_action
|= KAUTH_VNODE_WRITE_SECURITY
;
8459 KAUTH_DEBUG("CHMOD - adding/removing ACL entries");
8460 } else if (vap
->va_acl
->acl_entrycount
> 0) {
8461 /* both ACLs have the same ACE count, said count is 1 or more, bitwise compare ACLs */
8462 if (memcmp(&vap
->va_acl
->acl_ace
[0], &ova
.va_acl
->acl_ace
[0],
8463 sizeof(struct kauth_ace
) * vap
->va_acl
->acl_entrycount
)) {
8464 required_action
|= KAUTH_VNODE_WRITE_SECURITY
;
8465 KAUTH_DEBUG("CHMOD - changing ACL entries");
8472 * Other attributes that require authorisation.
8474 if (VATTR_IS_ACTIVE(vap
, va_encoding
))
8475 required_action
|= KAUTH_VNODE_WRITE_ATTRIBUTES
;
8478 if (VATTR_IS_SUPPORTED(&ova
, va_acl
) && (ova
.va_acl
!= NULL
))
8479 kauth_acl_free(ova
.va_acl
);
8481 *actionp
= required_action
;
8486 setlocklocal_callback(struct vnode
*vp
, __unused
void *cargs
)
8488 vnode_lock_spin(vp
);
8489 vp
->v_flag
|= VLOCKLOCAL
;
8492 return (VNODE_RETURNED
);
8496 vfs_setlocklocal(mount_t mp
)
8498 mount_lock_spin(mp
);
8499 mp
->mnt_kern_flag
|= MNTK_LOCK_LOCAL
;
8503 * The number of active vnodes is expected to be
8504 * very small when vfs_setlocklocal is invoked.
8506 vnode_iterate(mp
, 0, setlocklocal_callback
, NULL
);
8510 vfs_setcompoundopen(mount_t mp
)
8512 mount_lock_spin(mp
);
8513 mp
->mnt_compound_ops
|= COMPOUND_VNOP_OPEN
;
8519 vnode_setswapmount(vnode_t vp
)
8521 mount_lock(vp
->v_mount
);
8522 vp
->v_mount
->mnt_kern_flag
|= MNTK_SWAP_MOUNT
;
8523 mount_unlock(vp
->v_mount
);
8528 vnode_getswappin_avail(vnode_t vp
)
8530 int64_t max_swappin_avail
= 0;
8532 mount_lock(vp
->v_mount
);
8533 if (vp
->v_mount
->mnt_ioflags
& MNT_IOFLAGS_SWAPPIN_SUPPORTED
)
8534 max_swappin_avail
= vp
->v_mount
->mnt_max_swappin_available
;
8535 mount_unlock(vp
->v_mount
);
8537 return (max_swappin_avail
);
8542 vn_setunionwait(vnode_t vp
)
8544 vnode_lock_spin(vp
);
8545 vp
->v_flag
|= VISUNION
;
8551 vn_checkunionwait(vnode_t vp
)
8553 vnode_lock_spin(vp
);
8554 while ((vp
->v_flag
& VISUNION
) == VISUNION
)
8555 msleep((caddr_t
)&vp
->v_flag
, &vp
->v_lock
, 0, 0, 0);
8560 vn_clearunionwait(vnode_t vp
, int locked
)
8563 vnode_lock_spin(vp
);
8564 if((vp
->v_flag
& VISUNION
) == VISUNION
) {
8565 vp
->v_flag
&= ~VISUNION
;
8566 wakeup((caddr_t
)&vp
->v_flag
);
8573 * Removes orphaned apple double files during a rmdir
8575 * 1. vnode_suspend().
8576 * 2. Call VNOP_READDIR() till the end of directory is reached.
8577 * 3. Check if the directory entries returned are regular files with name starting with "._". If not, return ENOTEMPTY.
8578 * 4. Continue (2) and (3) till end of directory is reached.
8579 * 5. If all the entries in the directory were files with "._" name, delete all the files.
8581 * 7. If deletion of all files succeeded, call VNOP_RMDIR() again.
8584 errno_t
rmdir_remove_orphaned_appleDouble(vnode_t vp
, vfs_context_t ctx
, int * restart_flag
)
8587 #define UIO_BUFF_SIZE 2048
8589 int eofflag
, siz
= UIO_BUFF_SIZE
, nentries
= 0;
8590 int open_flag
= 0, full_erase_flag
= 0;
8591 char uio_buf
[ UIO_SIZEOF(1) ];
8598 error
= vnode_suspend(vp
);
8601 * restart_flag is set so that the calling rmdir sleeps and resets
8611 MALLOC(rbuf
, caddr_t
, siz
, M_TEMP
, M_WAITOK
);
8613 auio
= uio_createwithbuffer(1, 0, UIO_SYSSPACE
, UIO_READ
,
8614 &uio_buf
[0], sizeof(uio_buf
));
8615 if (!rbuf
|| !auio
) {
8620 uio_setoffset(auio
,0);
8624 if ((error
= VNOP_OPEN(vp
, FREAD
, ctx
)))
8630 * First pass checks if all files are appleDouble files.
8634 siz
= UIO_BUFF_SIZE
;
8635 uio_reset(auio
, uio_offset(auio
), UIO_SYSSPACE
, UIO_READ
);
8636 uio_addiov(auio
, CAST_USER_ADDR_T(rbuf
), UIO_BUFF_SIZE
);
8638 if((error
= VNOP_READDIR(vp
, auio
, 0, &eofflag
, &nentries
, ctx
)))
8641 if (uio_resid(auio
) != 0)
8642 siz
-= uio_resid(auio
);
8645 * Iterate through directory
8647 dir_pos
= (void*) rbuf
;
8648 dir_end
= (void*) (rbuf
+ siz
);
8649 dp
= (struct dirent
*) (dir_pos
);
8651 if (dir_pos
== dir_end
)
8654 while (dir_pos
< dir_end
) {
8656 * Check for . and .. as well as directories
8658 if (dp
->d_ino
!= 0 &&
8659 !((dp
->d_namlen
== 1 && dp
->d_name
[0] == '.') ||
8660 (dp
->d_namlen
== 2 && dp
->d_name
[0] == '.' && dp
->d_name
[1] == '.'))) {
8662 * Check for irregular files and ._ files
8663 * If there is a ._._ file abort the op
8665 if ( dp
->d_namlen
< 2 ||
8666 strncmp(dp
->d_name
,"._",2) ||
8667 (dp
->d_namlen
>= 4 && !strncmp(&(dp
->d_name
[2]), "._",2))) {
8672 dir_pos
= (void*) ((uint8_t*)dir_pos
+ dp
->d_reclen
);
8673 dp
= (struct dirent
*)dir_pos
;
8677 * workaround for HFS/NFS setting eofflag before end of file
8679 if (vp
->v_tag
== VT_HFS
&& nentries
> 2)
8682 if (vp
->v_tag
== VT_NFS
) {
8683 if (eofflag
&& !full_erase_flag
) {
8684 full_erase_flag
= 1;
8686 uio_reset(auio
, 0, UIO_SYSSPACE
, UIO_READ
);
8688 else if (!eofflag
&& full_erase_flag
)
8689 full_erase_flag
= 0;
8694 * If we've made it here all the files in the dir are ._ files.
8695 * We can delete the files even though the node is suspended
8696 * because we are the owner of the file.
8699 uio_reset(auio
, 0, UIO_SYSSPACE
, UIO_READ
);
8701 full_erase_flag
= 0;
8704 siz
= UIO_BUFF_SIZE
;
8705 uio_reset(auio
, uio_offset(auio
), UIO_SYSSPACE
, UIO_READ
);
8706 uio_addiov(auio
, CAST_USER_ADDR_T(rbuf
), UIO_BUFF_SIZE
);
8708 error
= VNOP_READDIR(vp
, auio
, 0, &eofflag
, &nentries
, ctx
);
8713 if (uio_resid(auio
) != 0)
8714 siz
-= uio_resid(auio
);
8717 * Iterate through directory
8719 dir_pos
= (void*) rbuf
;
8720 dir_end
= (void*) (rbuf
+ siz
);
8721 dp
= (struct dirent
*) dir_pos
;
8723 if (dir_pos
== dir_end
)
8726 while (dir_pos
< dir_end
) {
8728 * Check for . and .. as well as directories
8730 if (dp
->d_ino
!= 0 &&
8731 !((dp
->d_namlen
== 1 && dp
->d_name
[0] == '.') ||
8732 (dp
->d_namlen
== 2 && dp
->d_name
[0] == '.' && dp
->d_name
[1] == '.'))
8735 error
= unlink1(ctx
, vp
,
8736 CAST_USER_ADDR_T(dp
->d_name
), UIO_SYSSPACE
,
8737 VNODE_REMOVE_SKIP_NAMESPACE_EVENT
|
8738 VNODE_REMOVE_NO_AUDIT_PATH
);
8740 if (error
&& error
!= ENOENT
) {
8745 dir_pos
= (void*) ((uint8_t*)dir_pos
+ dp
->d_reclen
);
8746 dp
= (struct dirent
*)dir_pos
;
8750 * workaround for HFS/NFS setting eofflag before end of file
8752 if (vp
->v_tag
== VT_HFS
&& nentries
> 2)
8755 if (vp
->v_tag
== VT_NFS
) {
8756 if (eofflag
&& !full_erase_flag
) {
8757 full_erase_flag
= 1;
8759 uio_reset(auio
, 0, UIO_SYSSPACE
, UIO_READ
);
8761 else if (!eofflag
&& full_erase_flag
)
8762 full_erase_flag
= 0;
8772 VNOP_CLOSE(vp
, FREAD
, ctx
);
8787 lock_vnode_and_post(vnode_t vp
, int kevent_num
)
8789 /* Only take the lock if there's something there! */
8790 if (vp
->v_knotes
.slh_first
!= NULL
) {
8792 KNOTE(&vp
->v_knotes
, kevent_num
);
8797 void panic_print_vnodes(void);
8799 /* define PANIC_PRINTS_VNODES only if investigation is required. */
8800 #ifdef PANIC_PRINTS_VNODES
8802 static const char *__vtype(uint16_t vtype
)
8831 * build a path from the bottom up
8832 * NOTE: called from the panic path - no alloc'ing of memory and no locks!
8834 static char *__vpath(vnode_t vp
, char *str
, int len
, int depth
)
8842 /* str + len is the start of the string we created */
8846 /* follow mount vnodes to get the full path */
8847 if ((vp
->v_flag
& VROOT
)) {
8848 if (vp
->v_mount
!= NULL
&& vp
->v_mount
->mnt_vnodecovered
) {
8849 return __vpath(vp
->v_mount
->mnt_vnodecovered
,
8856 vnm_len
= strlen(src
);
8857 if (vnm_len
> len
) {
8858 /* truncate the name to fit in the string */
8859 src
+= (vnm_len
- len
);
8863 /* start from the back and copy just characters (no NULLs) */
8865 /* this will chop off leaf path (file) names */
8867 dst
= str
+ len
- vnm_len
;
8868 memcpy(dst
, src
, vnm_len
);
8874 if (vp
->v_parent
&& len
> 1) {
8875 /* follow parents up the chain */
8878 return __vpath(vp
->v_parent
, str
, len
, depth
+ 1);
8884 extern int kdb_printf(const char *format
, ...) __printflike(1,2);
8886 #define SANE_VNODE_PRINT_LIMIT 5000
8887 void panic_print_vnodes(void)
8896 kdb_printf("\n***** VNODES *****\n"
8897 "TYPE UREF ICNT PATH\n");
8899 /* NULL-terminate the path name */
8900 vname
[sizeof(vname
)-1] = '\0';
8903 * iterate all vnodelist items in all mounts (mntlist) -> mnt_vnodelist
8905 TAILQ_FOREACH(mnt
, &mountlist
, mnt_list
) {
8907 if (!ml_validate_nofault((vm_offset_t
)mnt
, sizeof(mount_t
))) {
8908 kdb_printf("Unable to iterate the mount list %p - encountered an invalid mount pointer %p \n",
8913 TAILQ_FOREACH(vp
, &mnt
->mnt_vnodelist
, v_mntvnodes
) {
8915 if (!ml_validate_nofault((vm_offset_t
)vp
, sizeof(vnode_t
))) {
8916 kdb_printf("Unable to iterate the vnode list %p - encountered an invalid vnode pointer %p \n",
8917 &mnt
->mnt_vnodelist
, vp
);
8921 if (++nvnodes
> SANE_VNODE_PRINT_LIMIT
)
8923 type
= __vtype(vp
->v_type
);
8924 nm
= __vpath(vp
, vname
, sizeof(vname
)-1, 0);
8925 kdb_printf("%s %0d %0d %s\n",
8926 type
, vp
->v_usecount
, vp
->v_iocount
, nm
);
8931 #else /* !PANIC_PRINTS_VNODES */
8932 void panic_print_vnodes(void)
8940 static void record_vp(vnode_t vp
, int count
) {
8947 if ((vp
->v_flag
& VSYSTEM
))
8950 ut
= get_bsdthread_info(current_thread());
8951 ut
->uu_iocount
+= count
;
8954 if (ut
->uu_vpindex
< 32) {
8955 OSBacktrace((void **)&ut
->uu_pcs
[ut
->uu_vpindex
][0], 10);
8957 ut
->uu_vps
[ut
->uu_vpindex
] = vp
;
8967 #define TRIG_DEBUG 0
8970 #define TRIG_LOG(...) do { printf("%s: ", __FUNCTION__); printf(__VA_ARGS__); } while (0)
8972 #define TRIG_LOG(...)
8976 * Resolver result functions
8980 vfs_resolver_result(uint32_t seq
, enum resolver_status stat
, int aux
)
8983 * |<--- 32 --->|<--- 28 --->|<- 4 ->|
8984 * sequence auxiliary status
8986 return (((uint64_t)seq
) << 32) |
8987 (((uint64_t)(aux
& 0x0fffffff)) << 4) |
8988 (uint64_t)(stat
& 0x0000000F);
8991 enum resolver_status
8992 vfs_resolver_status(resolver_result_t result
)
8994 /* lower 4 bits is status */
8995 return (result
& 0x0000000F);
8999 vfs_resolver_sequence(resolver_result_t result
)
9001 /* upper 32 bits is sequence */
9002 return (uint32_t)(result
>> 32);
9006 vfs_resolver_auxiliary(resolver_result_t result
)
9008 /* 28 bits of auxiliary */
9009 return (int)(((uint32_t)(result
& 0xFFFFFFF0)) >> 4);
9014 * Call in for resolvers to update vnode trigger state
9017 vnode_trigger_update(vnode_t vp
, resolver_result_t result
)
9021 enum resolver_status stat
;
9023 if (vp
->v_resolve
== NULL
) {
9027 stat
= vfs_resolver_status(result
);
9028 seq
= vfs_resolver_sequence(result
);
9030 if ((stat
!= RESOLVER_RESOLVED
) && (stat
!= RESOLVER_UNRESOLVED
)) {
9035 lck_mtx_lock(&rp
->vr_lock
);
9037 if (seq
> rp
->vr_lastseq
) {
9038 if (stat
== RESOLVER_RESOLVED
)
9039 rp
->vr_flags
|= VNT_RESOLVED
;
9041 rp
->vr_flags
&= ~VNT_RESOLVED
;
9043 rp
->vr_lastseq
= seq
;
9046 lck_mtx_unlock(&rp
->vr_lock
);
9052 vnode_resolver_attach(vnode_t vp
, vnode_resolve_t rp
, boolean_t ref
)
9056 vnode_lock_spin(vp
);
9057 if (vp
->v_resolve
!= NULL
) {
9066 error
= vnode_ref_ext(vp
, O_EVTONLY
, VNODE_REF_FORCE
);
9068 panic("VNODE_REF_FORCE didn't help...");
9076 * VFS internal interfaces for vnode triggers
9078 * vnode must already have an io count on entry
9079 * v_resolve is stable when io count is non-zero
9082 vnode_resolver_create(mount_t mp
, vnode_t vp
, struct vnode_trigger_param
*tinfo
, boolean_t external
)
9089 /* minimum pointer test (debugging) */
9090 if (tinfo
->vnt_data
)
9091 byte
= *((char *)tinfo
->vnt_data
);
9093 MALLOC(rp
, vnode_resolve_t
, sizeof(*rp
), M_TEMP
, M_WAITOK
);
9097 lck_mtx_init(&rp
->vr_lock
, trigger_vnode_lck_grp
, trigger_vnode_lck_attr
);
9099 rp
->vr_resolve_func
= tinfo
->vnt_resolve_func
;
9100 rp
->vr_unresolve_func
= tinfo
->vnt_unresolve_func
;
9101 rp
->vr_rearm_func
= tinfo
->vnt_rearm_func
;
9102 rp
->vr_reclaim_func
= tinfo
->vnt_reclaim_func
;
9103 rp
->vr_data
= tinfo
->vnt_data
;
9105 rp
->vr_flags
= tinfo
->vnt_flags
& VNT_VALID_MASK
;
9107 rp
->vr_flags
|= VNT_EXTERNAL
;
9110 result
= vnode_resolver_attach(vp
, rp
, external
);
9116 OSAddAtomic(1, &mp
->mnt_numtriggers
);
9127 vnode_resolver_release(vnode_resolve_t rp
)
9130 * Give them a chance to free any private data
9132 if (rp
->vr_data
&& rp
->vr_reclaim_func
) {
9133 rp
->vr_reclaim_func(NULLVP
, rp
->vr_data
);
9136 lck_mtx_destroy(&rp
->vr_lock
, trigger_vnode_lck_grp
);
9141 /* Called after the vnode has been drained */
9143 vnode_resolver_detach(vnode_t vp
)
9148 mp
= vnode_mount(vp
);
9152 vp
->v_resolve
= NULL
;
9155 if ((rp
->vr_flags
& VNT_EXTERNAL
) != 0) {
9156 vnode_rele_ext(vp
, O_EVTONLY
, 1);
9159 vnode_resolver_release(rp
);
9161 /* Keep count of active trigger vnodes per mount */
9162 OSAddAtomic(-1, &mp
->mnt_numtriggers
);
9167 vnode_trigger_rearm(vnode_t vp
, vfs_context_t ctx
)
9170 resolver_result_t result
;
9171 enum resolver_status status
;
9174 if ((vp
->v_resolve
== NULL
) ||
9175 (vp
->v_resolve
->vr_rearm_func
== NULL
) ||
9176 (vp
->v_resolve
->vr_flags
& VNT_AUTO_REARM
) == 0) {
9181 lck_mtx_lock(&rp
->vr_lock
);
9184 * Check if VFS initiated this unmount. If so, we'll catch it after the unresolve completes.
9186 if (rp
->vr_flags
& VNT_VFS_UNMOUNTED
) {
9187 lck_mtx_unlock(&rp
->vr_lock
);
9191 /* Check if this vnode is already armed */
9192 if ((rp
->vr_flags
& VNT_RESOLVED
) == 0) {
9193 lck_mtx_unlock(&rp
->vr_lock
);
9197 lck_mtx_unlock(&rp
->vr_lock
);
9199 result
= rp
->vr_rearm_func(vp
, 0, rp
->vr_data
, ctx
);
9200 status
= vfs_resolver_status(result
);
9201 seq
= vfs_resolver_sequence(result
);
9203 lck_mtx_lock(&rp
->vr_lock
);
9204 if (seq
> rp
->vr_lastseq
) {
9205 if (status
== RESOLVER_UNRESOLVED
)
9206 rp
->vr_flags
&= ~VNT_RESOLVED
;
9207 rp
->vr_lastseq
= seq
;
9209 lck_mtx_unlock(&rp
->vr_lock
);
9214 vnode_trigger_resolve(vnode_t vp
, struct nameidata
*ndp
, vfs_context_t ctx
)
9217 enum path_operation op
;
9218 resolver_result_t result
;
9219 enum resolver_status status
;
9222 /* Only trigger on topmost vnodes */
9223 if ((vp
->v_resolve
== NULL
) ||
9224 (vp
->v_resolve
->vr_resolve_func
== NULL
) ||
9225 (vp
->v_mountedhere
!= NULL
)) {
9230 lck_mtx_lock(&rp
->vr_lock
);
9232 /* Check if this vnode is already resolved */
9233 if (rp
->vr_flags
& VNT_RESOLVED
) {
9234 lck_mtx_unlock(&rp
->vr_lock
);
9238 lck_mtx_unlock(&rp
->vr_lock
);
9242 * assumes that resolver will not access this trigger vnode (otherwise the kernel will deadlock)
9243 * is there anyway to know this???
9244 * there can also be other legitimate lookups in parallel
9246 * XXX - should we call this on a separate thread with a timeout?
9248 * XXX - should we use ISLASTCN to pick the op value??? Perhaps only leafs should
9249 * get the richer set and non-leafs should get generic OP_LOOKUP? TBD
9251 op
= (ndp
->ni_op
< OP_MAXOP
) ? ndp
->ni_op
: OP_LOOKUP
;
9253 result
= rp
->vr_resolve_func(vp
, &ndp
->ni_cnd
, op
, 0, rp
->vr_data
, ctx
);
9254 status
= vfs_resolver_status(result
);
9255 seq
= vfs_resolver_sequence(result
);
9257 lck_mtx_lock(&rp
->vr_lock
);
9258 if (seq
> rp
->vr_lastseq
) {
9259 if (status
== RESOLVER_RESOLVED
)
9260 rp
->vr_flags
|= VNT_RESOLVED
;
9261 rp
->vr_lastseq
= seq
;
9263 lck_mtx_unlock(&rp
->vr_lock
);
9265 /* On resolver errors, propagate the error back up */
9266 return (status
== RESOLVER_ERROR
? vfs_resolver_auxiliary(result
) : 0);
9270 vnode_trigger_unresolve(vnode_t vp
, int flags
, vfs_context_t ctx
)
9273 resolver_result_t result
;
9274 enum resolver_status status
;
9277 if ((vp
->v_resolve
== NULL
) || (vp
->v_resolve
->vr_unresolve_func
== NULL
)) {
9282 lck_mtx_lock(&rp
->vr_lock
);
9284 /* Check if this vnode is already resolved */
9285 if ((rp
->vr_flags
& VNT_RESOLVED
) == 0) {
9286 printf("vnode_trigger_unresolve: not currently resolved\n");
9287 lck_mtx_unlock(&rp
->vr_lock
);
9291 rp
->vr_flags
|= VNT_VFS_UNMOUNTED
;
9293 lck_mtx_unlock(&rp
->vr_lock
);
9297 * assumes that resolver will not access this trigger vnode (otherwise the kernel will deadlock)
9298 * there can also be other legitimate lookups in parallel
9300 * XXX - should we call this on a separate thread with a timeout?
9303 result
= rp
->vr_unresolve_func(vp
, flags
, rp
->vr_data
, ctx
);
9304 status
= vfs_resolver_status(result
);
9305 seq
= vfs_resolver_sequence(result
);
9307 lck_mtx_lock(&rp
->vr_lock
);
9308 if (seq
> rp
->vr_lastseq
) {
9309 if (status
== RESOLVER_UNRESOLVED
)
9310 rp
->vr_flags
&= ~VNT_RESOLVED
;
9311 rp
->vr_lastseq
= seq
;
9313 rp
->vr_flags
&= ~VNT_VFS_UNMOUNTED
;
9314 lck_mtx_unlock(&rp
->vr_lock
);
9316 /* On resolver errors, propagate the error back up */
9317 return (status
== RESOLVER_ERROR
? vfs_resolver_auxiliary(result
) : 0);
9321 triggerisdescendant(mount_t mp
, mount_t rmp
)
9326 * walk up vnode covered chain looking for a match
9328 name_cache_lock_shared();
9333 /* did we encounter "/" ? */
9334 if (mp
->mnt_flag
& MNT_ROOTFS
)
9337 vp
= mp
->mnt_vnodecovered
;
9348 name_cache_unlock();
9353 struct trigger_unmount_info
{
9358 uint32_t trigger_vid
;
9363 trigger_unmount_callback(mount_t mp
, void * arg
)
9365 struct trigger_unmount_info
* infop
= (struct trigger_unmount_info
*)arg
;
9366 boolean_t mountedtrigger
= FALSE
;
9369 * When we encounter the top level mount we're done
9371 if (mp
== infop
->top_mp
)
9372 return (VFS_RETURNED_DONE
);
9374 if ((mp
->mnt_vnodecovered
== NULL
) ||
9375 (vnode_getwithref(mp
->mnt_vnodecovered
) != 0)) {
9376 return (VFS_RETURNED
);
9379 if ((mp
->mnt_vnodecovered
->v_mountedhere
== mp
) &&
9380 (mp
->mnt_vnodecovered
->v_resolve
!= NULL
) &&
9381 (mp
->mnt_vnodecovered
->v_resolve
->vr_flags
& VNT_RESOLVED
)) {
9382 mountedtrigger
= TRUE
;
9384 vnode_put(mp
->mnt_vnodecovered
);
9387 * When we encounter a mounted trigger, check if its under the top level mount
9389 if ( !mountedtrigger
|| !triggerisdescendant(mp
, infop
->top_mp
) )
9390 return (VFS_RETURNED
);
9393 * Process any pending nested mount (now that its not referenced)
9395 if ((infop
->trigger_vp
!= NULLVP
) &&
9396 (vnode_getwithvid(infop
->trigger_vp
, infop
->trigger_vid
) == 0)) {
9397 vnode_t vp
= infop
->trigger_vp
;
9400 infop
->trigger_vp
= NULLVP
;
9402 if (mp
== vp
->v_mountedhere
) {
9404 printf("trigger_unmount_callback: unexpected match '%s'\n",
9405 mp
->mnt_vfsstat
.f_mntonname
);
9406 return (VFS_RETURNED
);
9408 if (infop
->trigger_mp
!= vp
->v_mountedhere
) {
9410 printf("trigger_unmount_callback: trigger mnt changed! (%p != %p)\n",
9411 infop
->trigger_mp
, vp
->v_mountedhere
);
9415 error
= vnode_trigger_unresolve(vp
, infop
->flags
, infop
->ctx
);
9418 printf("unresolving: '%s', err %d\n",
9419 vp
->v_mountedhere
? vp
->v_mountedhere
->mnt_vfsstat
.f_mntonname
:
9421 return (VFS_RETURNED_DONE
); /* stop iteration on errors */
9426 * We can't call resolver here since we hold a mount iter
9427 * ref on mp so save its covered vp for later processing
9429 infop
->trigger_vp
= mp
->mnt_vnodecovered
;
9430 if ((infop
->trigger_vp
!= NULLVP
) &&
9431 (vnode_getwithref(infop
->trigger_vp
) == 0)) {
9432 if (infop
->trigger_vp
->v_mountedhere
== mp
) {
9433 infop
->trigger_vid
= infop
->trigger_vp
->v_id
;
9434 infop
->trigger_mp
= mp
;
9436 vnode_put(infop
->trigger_vp
);
9439 return (VFS_RETURNED
);
9443 * Attempt to unmount any trigger mounts nested underneath a mount.
9444 * This is a best effort attempt and no retries are performed here.
9446 * Note: mp->mnt_rwlock is held exclusively on entry (so be carefull)
9450 vfs_nested_trigger_unmounts(mount_t mp
, int flags
, vfs_context_t ctx
)
9452 struct trigger_unmount_info info
;
9454 /* Must have trigger vnodes */
9455 if (mp
->mnt_numtriggers
== 0) {
9458 /* Avoid recursive requests (by checking covered vnode) */
9459 if ((mp
->mnt_vnodecovered
!= NULL
) &&
9460 (vnode_getwithref(mp
->mnt_vnodecovered
) == 0)) {
9461 boolean_t recursive
= FALSE
;
9463 if ((mp
->mnt_vnodecovered
->v_mountedhere
== mp
) &&
9464 (mp
->mnt_vnodecovered
->v_resolve
!= NULL
) &&
9465 (mp
->mnt_vnodecovered
->v_resolve
->vr_flags
& VNT_VFS_UNMOUNTED
)) {
9468 vnode_put(mp
->mnt_vnodecovered
);
9474 * Attempt to unmount any nested trigger mounts (best effort)
9478 info
.trigger_vp
= NULLVP
;
9479 info
.trigger_vid
= 0;
9480 info
.trigger_mp
= NULL
;
9483 (void) vfs_iterate(VFS_ITERATE_TAIL_FIRST
, trigger_unmount_callback
, &info
);
9486 * Process remaining nested mount (now that its not referenced)
9488 if ((info
.trigger_vp
!= NULLVP
) &&
9489 (vnode_getwithvid(info
.trigger_vp
, info
.trigger_vid
) == 0)) {
9490 vnode_t vp
= info
.trigger_vp
;
9492 if (info
.trigger_mp
== vp
->v_mountedhere
) {
9493 (void) vnode_trigger_unresolve(vp
, flags
, ctx
);
9500 vfs_addtrigger(mount_t mp
, const char *relpath
, struct vnode_trigger_info
*vtip
, vfs_context_t ctx
)
9502 struct nameidata nd
;
9505 struct vnode_trigger_param vtp
;
9508 * Must be called for trigger callback, wherein rwlock is held
9510 lck_rw_assert(&mp
->mnt_rwlock
, LCK_RW_ASSERT_HELD
);
9512 TRIG_LOG("Adding trigger at %s\n", relpath
);
9513 TRIG_LOG("Trying VFS_ROOT\n");
9516 * We do a lookup starting at the root of the mountpoint, unwilling
9517 * to cross into other mountpoints.
9519 res
= VFS_ROOT(mp
, &rvp
, ctx
);
9524 TRIG_LOG("Trying namei\n");
9526 NDINIT(&nd
, LOOKUP
, OP_LOOKUP
, USEDVP
| NOCROSSMOUNT
| FOLLOW
, UIO_SYSSPACE
,
9527 CAST_USER_ADDR_T(relpath
), ctx
);
9539 TRIG_LOG("Trying vnode_resolver_create()\n");
9542 * Set up blob. vnode_create() takes a larger structure
9543 * with creation info, and we needed something different
9544 * for this case. One needs to win, or we need to munge both;
9545 * vnode_create() wins.
9547 bzero(&vtp
, sizeof(vtp
));
9548 vtp
.vnt_resolve_func
= vtip
->vti_resolve_func
;
9549 vtp
.vnt_unresolve_func
= vtip
->vti_unresolve_func
;
9550 vtp
.vnt_rearm_func
= vtip
->vti_rearm_func
;
9551 vtp
.vnt_reclaim_func
= vtip
->vti_reclaim_func
;
9552 vtp
.vnt_reclaim_func
= vtip
->vti_reclaim_func
;
9553 vtp
.vnt_data
= vtip
->vti_data
;
9554 vtp
.vnt_flags
= vtip
->vti_flags
;
9556 res
= vnode_resolver_create(mp
, vp
, &vtp
, TRUE
);
9559 TRIG_LOG("Returning %d\n", res
);
9563 #endif /* CONFIG_TRIGGERS */
9565 vm_offset_t
kdebug_vnode(vnode_t vp
)
9567 return VM_KERNEL_ADDRPERM(vp
);
9570 static int flush_cache_on_write
= 0;
9571 SYSCTL_INT (_kern
, OID_AUTO
, flush_cache_on_write
,
9572 CTLFLAG_RW
| CTLFLAG_LOCKED
, &flush_cache_on_write
, 0,
9573 "always flush the drive cache on writes to uncached files");
9575 int vnode_should_flush_after_write(vnode_t vp
, int ioflag
)
9577 return (flush_cache_on_write
9578 && (ISSET(ioflag
, IO_NOCACHE
) || vnode_isnocache(vp
)));
9582 * sysctl for use by disk I/O tracing tools to get the list of existing
9586 struct vnode_trace_paths_context
{
9588 long path
[MAXPATHLEN
/ sizeof (long) + 1]; /* + 1 in case sizeof (long) does not divide MAXPATHLEN */
9591 static int vnode_trace_path_callback(struct vnode
*vp
, void *arg
) {
9593 struct vnode_trace_paths_context
*ctx
;
9597 len
= sizeof (ctx
->path
);
9598 rv
= vn_getpath(vp
, (char *)ctx
->path
, &len
);
9599 /* vn_getpath() NUL-terminates, and len includes the NUL */
9602 kdebug_lookup_gen_events(ctx
->path
, len
, vp
, TRUE
);
9604 if (++(ctx
->count
) == 1000) {
9605 thread_yield_to_preemption();
9610 return VNODE_RETURNED
;
9613 static int vfs_trace_paths_callback(mount_t mp
, void *arg
) {
9614 if (mp
->mnt_flag
& MNT_LOCAL
)
9615 vnode_iterate(mp
, VNODE_ITERATE_ALL
, vnode_trace_path_callback
, arg
);
9617 return VFS_RETURNED
;
9620 static int sysctl_vfs_trace_paths SYSCTL_HANDLER_ARGS
{
9621 struct vnode_trace_paths_context ctx
;
9628 if (!kauth_cred_issuser(kauth_cred_get()))
9631 if (!kdebug_enable
|| !kdebug_debugid_enabled(VFS_LOOKUP
))
9634 bzero(&ctx
, sizeof (struct vnode_trace_paths_context
));
9636 vfs_iterate(0, vfs_trace_paths_callback
, &ctx
);
9641 SYSCTL_PROC(_vfs_generic
, OID_AUTO
, trace_paths
, CTLFLAG_RD
| CTLFLAG_LOCKED
| CTLFLAG_MASKED
, NULL
, 0, &sysctl_vfs_trace_paths
, "-", "trace_paths");