xref: /xnu-11215.41.3/bsd/miscfs/routefs/routefs_ops.c (revision 33de042d024d46de5ff4e89f2471de6608e37fa4) 
1 /*
2  * Copyright (c) 2019 Apple Inc. All rights reserved.
3  *
4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5  *
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.
14  *
15  * Please obtain a copy of the License at
16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
17  *
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.
25  *
26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27  */
28 
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/kernel.h>
32 #include <sys/vnode_internal.h>
33 #include <sys/proc.h>
34 #include <sys/kauth.h>
35 #include <sys/mount_internal.h>
36 #include <sys/fcntl.h>
37 #include <sys/unistd.h>
38 #include <sys/malloc.h>
39 #include <vfs/vfs_support.h>
40 
41 #include <libkern/OSAtomic.h>
42 
43 #if CONFIG_MACF
44 #include <security/mac_framework.h>
45 #endif
46 
47 #include "routefs.h"
48 
49 static int routefs_init(__unused struct vfsconf *vfsp);
50 static int routefs_mount(struct mount *mp, __unused vnode_t devvp, __unused user_addr_t data, vfs_context_t ctx);
51 static int routefs_start(__unused struct mount *mp, __unused int flags, __unused vfs_context_t ctx);
52 static int routefs_unmount( struct mount *mp, int mntflags, __unused vfs_context_t ctx);
53 static int routefs_root(struct mount *mp, struct vnode **vpp, __unused vfs_context_t ctx);
54 static int routefs_statfs( struct mount *mp, struct vfsstatfs *sbp, __unused vfs_context_t ctx);
55 static int routefs_vfs_getattr(__unused mount_t mp, struct vfs_attr *fsap, __unused vfs_context_t ctx);
56 static int routefs_sync(__unused struct mount *mp, __unused int waitfor, __unused vfs_context_t ctx);
57 static int routefs_vget(__unused struct mount *mp, __unused ino64_t ino, __unused struct vnode **vpp, __unused vfs_context_t ctx);
58 static int routefs_fhtovp(__unused struct mount *mp, __unused int fhlen, __unused unsigned char *fhp, __unused struct vnode **vpp, __unused vfs_context_t ctx);
59 static int routefs_vptofh(__unused struct vnode *vp, __unused int *fhlenp, __unused unsigned char *fhp, __unused vfs_context_t ctx);
60 static int routefs_sysctl(__unused int *name, __unused u_int namelen, __unused user_addr_t oldp,
61     __unused size_t *oldlenp, __unused user_addr_t newp,
62     __unused size_t newlen, __unused vfs_context_t ctx);
63 static int routefserr_lookup(__unused struct vnop_lookup_args * args);
64 
65 static int routefserr_setlabel(__unused struct vnop_setlabel_args * args);
66 
67 
68 LCK_GRP_DECLARE(routefs_lck_grp, "routefs_lock");
69 LCK_MTX_DECLARE(routefs_mutex, &routefs_lck_grp);
70 
71 #define ROUTEFS_LOCK()    lck_mtx_lock(&routefs_mutex)
72 #define ROUTEFS_UNLOCK()  lck_mtx_unlock(&routefs_mutex)
73 static boolean_t _fs_alreadyMounted = FALSE;  /* atleast a mount of this filesystem is present */
74 
75 static int
routefs_init(__unused struct vfsconf * vfsp)76 routefs_init(__unused struct vfsconf *vfsp)
77 {
78 	return 0;
79 }
80 
81 static int
routefs_mount(struct mount * mp,__unused vnode_t devvp,user_addr_t data,vfs_context_t ctx)82 routefs_mount(struct mount *mp, __unused vnode_t devvp, user_addr_t data, vfs_context_t ctx)
83 {
84 	struct routefs_mount *routefs_mp_p = NULL; /* routefs specific mount info */
85 	int error = EINVAL;
86 	struct routefs_args * rargs = (struct routefs_args *)data;
87 
88 	/*-
89 	 *  If they just want to update, we don't need to do anything.
90 	 */
91 	if (mp->mnt_flag & MNT_UPDATE) {
92 		return 0;
93 	}
94 
95 
96 	/* check for root mount only */
97 	if ((error = proc_suser(current_proc())) != 0) {
98 		goto out;
99 	}
100 
101 	if (vfs_iskernelmount(mp) == FALSE) {
102 		error = EPERM;
103 		goto out;
104 	}
105 
106 	if (_fs_alreadyMounted == TRUE) {
107 		/* if a filesystem is mounted, it needs to be unmounted prior to mount again */
108 		error = EPERM;
109 		goto out;
110 	}
111 
112 	/* Advisory locking should be handled at the VFS layer */
113 	vfs_setlocklocal(mp);
114 
115 	/*-
116 	 *  Well, it's not an update, it's a real mount request.
117 	 *  Time to get dirty.
118 	 * HERE we should check to see if we are already mounted here.
119 	 */
120 
121 	routefs_mp_p = kalloc_type(struct routefs_mount,
122 	    Z_WAITOK | Z_ZERO | Z_NOFAIL);
123 
124 	routefs_mp_p->route_mount = mp;
125 
126 	if (rargs->route_rvp == NULLVP) {
127 		error = EACCES;
128 		goto out;
129 	}
130 
131 	strlcpy(routefs_mp_p->route_path, rargs->route_path, MAXPATHLEN);
132 	routefs_mp_p->route_rvp = rargs->route_rvp;
133 	routefs_mp_p->route_vpvid = vnode_vid(rargs->route_rvp);
134 
135 	if (vnode_ref(routefs_mp_p->route_rvp) != 0) {
136 		error = EACCES;
137 		goto out;
138 	}
139 
140 	/*
141 	 *  Fill out some fields
142 	 */
143 	__IGNORE_WCASTALIGN(mp->mnt_data = (qaddr_t)routefs_mp_p);
144 	mp->mnt_vfsstat.f_fsid.val[0] = (int32_t)VM_KERNEL_ADDRHASH(routefs_mp_p);
145 	mp->mnt_vfsstat.f_fsid.val[1] = vfs_typenum(mp);
146 	mp->mnt_flag |= MNT_LOCAL;
147 
148 	/*-
149 	 *  Copy in the name of the directory the filesystem
150 	 *  is to be mounted on.
151 	 *  And we clear the remainder of the character strings
152 	 *  to be tidy.
153 	 */
154 
155 	bzero(mp->mnt_vfsstat.f_mntfromname, MAXPATHLEN);
156 	bcopy("routefs", mp->mnt_vfsstat.f_mntfromname, 5);
157 	(void)routefs_statfs(mp, &mp->mnt_vfsstat, ctx);
158 	_fs_alreadyMounted = TRUE;  /* yep, fs is in play now */
159 	error = 0;
160 out:
161 	if (error != 0) {
162 		if (routefs_mp_p != NULL) {
163 			kfree_type(struct routefs_mount, routefs_mp_p);
164 		}
165 	}
166 	return error;
167 }
168 
169 
170 static int
routefs_start(__unused struct mount * mp,__unused int flags,__unused vfs_context_t ctx)171 routefs_start(__unused struct mount *mp, __unused int flags, __unused vfs_context_t ctx)
172 {
173 	return 0;
174 }
175 
176 /*-
177  *  Unmount the filesystem described by mp.
178  */
179 static int
routefs_unmount(struct mount * mp,int mntflags,__unused vfs_context_t ctx)180 routefs_unmount( struct mount *mp, int mntflags, __unused vfs_context_t ctx)
181 {
182 	struct routefs_mount *routefs_mp_p = (struct routefs_mount *)mp->mnt_data;
183 	int flags = 0;
184 	int force = 0;
185 	int error;
186 
187 	/* check for root unmount only */
188 	if ((error = proc_suser(current_proc())) != 0) {
189 		return error;
190 	}
191 
192 	if (mntflags & MNT_FORCE) {
193 		flags |= FORCECLOSE;
194 		force = 1;
195 	}
196 	/* giveup the ioref of vnode, no longer need it */
197 	if (routefs_mp_p->route_rvp != NULLVP) {
198 		if (vnode_getwithref(routefs_mp_p->route_rvp) == 0) {
199 			vnode_rele(routefs_mp_p->route_rvp);
200 			vnode_put(routefs_mp_p->route_rvp);
201 			routefs_mp_p->route_rvp = NULLVP;
202 		}
203 	}
204 	/* no vnodes, ignore any errors */
205 	(void)vflush(mp, NULLVP, flags);
206 	kfree_type(struct routefs_mount, routefs_mp_p);
207 	mp->mnt_data = (qaddr_t)0;
208 	mp->mnt_flag &= ~MNT_LOCAL;
209 	_fs_alreadyMounted = FALSE; /* unmounted the fs, only one allowed at a time */
210 	return 0;
211 }
212 
213 /* return the address of the root vnode  in *vpp */
214 static int
routefs_root(struct mount * mp,struct vnode ** vpp,__unused vfs_context_t ctx)215 routefs_root(struct mount *mp, struct vnode **vpp, __unused vfs_context_t ctx)
216 {
217 	struct routefs_mount *routefs_mp_p = (struct routefs_mount *)(mp->mnt_data);
218 	int error = 0;
219 
220 	/* check for nullvp incase its being rolled */
221 	if (routefs_mp_p->route_rvp == NULLVP) {
222 		ROUTEFS_LOCK();
223 		if (routefs_mp_p->route_rvp == NULLVP) {
224 			ROUTEFS_UNLOCK();
225 			error = EACCES;
226 			goto out;
227 		}
228 		ROUTEFS_UNLOCK();
229 	}
230 	if (vnode_getwithvid(routefs_mp_p->route_rvp, routefs_mp_p->route_vpvid) != 0) {
231 		/* only one in the path., since no vnodes with this, you can hold across this call */
232 		ROUTEFS_LOCK();
233 		if (vnode_getwithref(routefs_mp_p->route_rvp) == 0) {
234 			vnode_rele(routefs_mp_p->route_rvp);
235 			vnode_put(routefs_mp_p->route_rvp);
236 			routefs_mp_p->route_rvp = NULLVP;
237 			routefs_mp_p->route_vpvid = -1;
238 			error = vnode_lookup(routefs_mp_p->route_path, FREAD | O_DIRECTORY, &routefs_mp_p->route_rvp, ctx);
239 			if (error == 0) {
240 				routefs_mp_p->route_vpvid = vnode_vid(routefs_mp_p->route_rvp);
241 			}
242 		} else {
243 			error = EACCES;
244 		}
245 		ROUTEFS_UNLOCK();
246 
247 		if (error != 0) {
248 			goto out;
249 		}
250 	}
251 	*vpp = routefs_mp_p->route_rvp;
252 out:
253 	return error;
254 }
255 
256 static int
routefs_statfs(struct mount * mp,struct vfsstatfs * sbp,__unused vfs_context_t ctx)257 routefs_statfs( struct mount *mp, struct vfsstatfs *sbp, __unused vfs_context_t ctx)
258 {
259 	struct routefs_mount *routefs_mp_p = (struct routefs_mount *)mp->mnt_data;
260 
261 	/*-
262 	 *  Fill in the stat block.
263 	 */
264 	//sbp->f_type   = mp->mnt_vfsstat.f_type;
265 	sbp->f_flags  = 0;              /* XXX */
266 	sbp->f_bsize  = 512;
267 	sbp->f_iosize = 512;
268 	sbp->f_blocks = (sizeof(struct routefs_mount) + sbp->f_bsize) / sbp->f_bsize;
269 	sbp->f_bfree  = 0;
270 	sbp->f_bavail = 0;
271 	sbp->f_files  = 0;
272 	sbp->f_ffree  = 0;
273 	sbp->f_fsid.val[0] = (int32_t)VM_KERNEL_ADDRHASH(routefs_mp_p);
274 	sbp->f_fsid.val[1] = vfs_typenum(mp);
275 
276 	return 0;
277 }
278 
279 static int
routefs_vfs_getattr(__unused mount_t mp,struct vfs_attr * fsap,__unused vfs_context_t ctx)280 routefs_vfs_getattr(__unused mount_t mp, struct vfs_attr *fsap, __unused vfs_context_t ctx)
281 {
282 	VFSATTR_RETURN(fsap, f_objcount, 1);
283 	VFSATTR_RETURN(fsap, f_maxobjcount, 1);
284 	VFSATTR_RETURN(fsap, f_bsize, 512);
285 	VFSATTR_RETURN(fsap, f_iosize, 512);
286 	if (VFSATTR_IS_ACTIVE(fsap, f_blocks) || VFSATTR_IS_ACTIVE(fsap, f_bused)) {
287 		fsap->f_blocks = (sizeof(struct routefs_mount) + fsap->f_bsize) / fsap->f_bsize;
288 		fsap->f_bused = fsap->f_blocks;
289 		VFSATTR_SET_SUPPORTED(fsap, f_blocks);
290 		VFSATTR_SET_SUPPORTED(fsap, f_bused);
291 	}
292 	VFSATTR_RETURN(fsap, f_bfree, 0);
293 	VFSATTR_RETURN(fsap, f_bavail, 0);
294 	VFSATTR_RETURN(fsap, f_files, 0);
295 	VFSATTR_RETURN(fsap, f_ffree, 0);
296 	VFSATTR_RETURN(fsap, f_fssubtype, 0);
297 
298 	if (VFSATTR_IS_ACTIVE(fsap, f_capabilities)) {
299 		fsap->f_capabilities.capabilities[VOL_CAPABILITIES_FORMAT] =
300 		    VOL_CAP_FMT_SYMBOLICLINKS |
301 		    VOL_CAP_FMT_HARDLINKS |
302 		    VOL_CAP_FMT_NO_ROOT_TIMES |
303 		    VOL_CAP_FMT_CASE_SENSITIVE |
304 		    VOL_CAP_FMT_CASE_PRESERVING |
305 		    VOL_CAP_FMT_FAST_STATFS |
306 		    VOL_CAP_FMT_2TB_FILESIZE |
307 		    VOL_CAP_FMT_HIDDEN_FILES;
308 		fsap->f_capabilities.capabilities[VOL_CAPABILITIES_INTERFACES] =
309 		    VOL_CAP_INT_ATTRLIST;
310 		fsap->f_capabilities.capabilities[VOL_CAPABILITIES_RESERVED1] = 0;
311 		fsap->f_capabilities.capabilities[VOL_CAPABILITIES_RESERVED2] = 0;
312 
313 		fsap->f_capabilities.valid[VOL_CAPABILITIES_FORMAT] =
314 		    VOL_CAP_FMT_PERSISTENTOBJECTIDS |
315 		    VOL_CAP_FMT_SYMBOLICLINKS |
316 		    VOL_CAP_FMT_HARDLINKS |
317 		    VOL_CAP_FMT_JOURNAL |
318 		    VOL_CAP_FMT_JOURNAL_ACTIVE |
319 		    VOL_CAP_FMT_NO_ROOT_TIMES |
320 		    VOL_CAP_FMT_SPARSE_FILES |
321 		    VOL_CAP_FMT_ZERO_RUNS |
322 		    VOL_CAP_FMT_CASE_SENSITIVE |
323 		    VOL_CAP_FMT_CASE_PRESERVING |
324 		    VOL_CAP_FMT_FAST_STATFS |
325 		    VOL_CAP_FMT_2TB_FILESIZE |
326 		    VOL_CAP_FMT_OPENDENYMODES |
327 		    VOL_CAP_FMT_HIDDEN_FILES |
328 		    VOL_CAP_FMT_PATH_FROM_ID |
329 		    VOL_CAP_FMT_NO_VOLUME_SIZES;
330 		fsap->f_capabilities.valid[VOL_CAPABILITIES_INTERFACES] =
331 		    VOL_CAP_INT_SEARCHFS |
332 		    VOL_CAP_INT_ATTRLIST |
333 		    VOL_CAP_INT_NFSEXPORT |
334 		    VOL_CAP_INT_READDIRATTR |
335 		    VOL_CAP_INT_EXCHANGEDATA |
336 		    VOL_CAP_INT_COPYFILE |
337 		    VOL_CAP_INT_ALLOCATE |
338 		    VOL_CAP_INT_VOL_RENAME |
339 		    VOL_CAP_INT_ADVLOCK |
340 		    VOL_CAP_INT_FLOCK |
341 		    VOL_CAP_INT_EXTENDED_SECURITY |
342 		    VOL_CAP_INT_USERACCESS |
343 		    VOL_CAP_INT_MANLOCK |
344 		    VOL_CAP_INT_EXTENDED_ATTR |
345 		    VOL_CAP_INT_NAMEDSTREAMS;
346 		fsap->f_capabilities.valid[VOL_CAPABILITIES_RESERVED1] = 0;
347 		fsap->f_capabilities.valid[VOL_CAPABILITIES_RESERVED2] = 0;
348 
349 		VFSATTR_SET_SUPPORTED(fsap, f_capabilities);
350 	}
351 
352 	if (VFSATTR_IS_ACTIVE(fsap, f_attributes)) {
353 		fsap->f_attributes.validattr.commonattr =
354 		    ATTR_CMN_NAME | ATTR_CMN_DEVID | ATTR_CMN_FSID |
355 		    ATTR_CMN_OBJTYPE | ATTR_CMN_OBJTAG | ATTR_CMN_OBJID |
356 		    ATTR_CMN_PAROBJID |
357 		    ATTR_CMN_MODTIME | ATTR_CMN_CHGTIME | ATTR_CMN_ACCTIME |
358 		    ATTR_CMN_OWNERID | ATTR_CMN_GRPID | ATTR_CMN_ACCESSMASK |
359 		    ATTR_CMN_FLAGS | ATTR_CMN_USERACCESS | ATTR_CMN_FILEID;
360 		fsap->f_attributes.validattr.volattr =
361 		    ATTR_VOL_FSTYPE | ATTR_VOL_SIZE | ATTR_VOL_SPACEFREE |
362 		    ATTR_VOL_SPACEAVAIL | ATTR_VOL_MINALLOCATION |
363 		    ATTR_VOL_OBJCOUNT | ATTR_VOL_MAXOBJCOUNT |
364 		    ATTR_VOL_MOUNTPOINT | ATTR_VOL_MOUNTFLAGS |
365 		    ATTR_VOL_MOUNTEDDEVICE | ATTR_VOL_CAPABILITIES |
366 		    ATTR_VOL_ATTRIBUTES;
367 		fsap->f_attributes.validattr.dirattr =
368 		    ATTR_DIR_LINKCOUNT | ATTR_DIR_MOUNTSTATUS;
369 		fsap->f_attributes.validattr.fileattr =
370 		    ATTR_FILE_LINKCOUNT | ATTR_FILE_TOTALSIZE |
371 		    ATTR_FILE_IOBLOCKSIZE | ATTR_FILE_DEVTYPE |
372 		    ATTR_FILE_DATALENGTH;
373 		fsap->f_attributes.validattr.forkattr = 0;
374 
375 		fsap->f_attributes.nativeattr.commonattr =
376 		    ATTR_CMN_NAME | ATTR_CMN_DEVID | ATTR_CMN_FSID |
377 		    ATTR_CMN_OBJTYPE | ATTR_CMN_OBJTAG | ATTR_CMN_OBJID |
378 		    ATTR_CMN_PAROBJID |
379 		    ATTR_CMN_MODTIME | ATTR_CMN_CHGTIME | ATTR_CMN_ACCTIME |
380 		    ATTR_CMN_OWNERID | ATTR_CMN_GRPID | ATTR_CMN_ACCESSMASK |
381 		    ATTR_CMN_FLAGS | ATTR_CMN_USERACCESS | ATTR_CMN_FILEID;
382 		fsap->f_attributes.nativeattr.volattr =
383 		    ATTR_VOL_FSTYPE | ATTR_VOL_SIZE | ATTR_VOL_SPACEFREE |
384 		    ATTR_VOL_SPACEAVAIL | ATTR_VOL_MINALLOCATION |
385 		    ATTR_VOL_OBJCOUNT | ATTR_VOL_MAXOBJCOUNT |
386 		    ATTR_VOL_MOUNTPOINT | ATTR_VOL_MOUNTFLAGS |
387 		    ATTR_VOL_MOUNTEDDEVICE | ATTR_VOL_CAPABILITIES |
388 		    ATTR_VOL_ATTRIBUTES;
389 		fsap->f_attributes.nativeattr.dirattr =
390 		    ATTR_DIR_MOUNTSTATUS;
391 		fsap->f_attributes.nativeattr.fileattr =
392 		    ATTR_FILE_LINKCOUNT | ATTR_FILE_TOTALSIZE |
393 		    ATTR_FILE_IOBLOCKSIZE | ATTR_FILE_DEVTYPE |
394 		    ATTR_FILE_DATALENGTH;
395 		fsap->f_attributes.nativeattr.forkattr = 0;
396 
397 		VFSATTR_SET_SUPPORTED(fsap, f_attributes);
398 	}
399 
400 	return 0;
401 }
402 
403 static int
routefs_sync(__unused struct mount * mp,__unused int waitfor,__unused vfs_context_t ctx)404 routefs_sync(__unused struct mount *mp, __unused int waitfor, __unused vfs_context_t ctx)
405 {
406 	return 0;
407 }
408 
409 
410 static int
routefs_vget(__unused struct mount * mp,__unused ino64_t ino,__unused struct vnode ** vpp,__unused vfs_context_t ctx)411 routefs_vget(__unused struct mount *mp, __unused ino64_t ino, __unused struct vnode **vpp, __unused vfs_context_t ctx)
412 {
413 	return ENOTSUP;
414 }
415 
416 static int
routefs_fhtovp(__unused struct mount * mp,__unused int fhlen,__unused unsigned char * fhp,__unused struct vnode ** vpp,__unused vfs_context_t ctx)417 routefs_fhtovp(__unused struct mount *mp, __unused int fhlen, __unused unsigned char *fhp, __unused struct vnode **vpp, __unused vfs_context_t ctx)
418 {
419 	return EINVAL;
420 }
421 
422 
423 static int
routefs_vptofh(__unused struct vnode * vp,__unused int * fhlenp,__unused unsigned char * fhp,__unused vfs_context_t ctx)424 routefs_vptofh(__unused struct vnode *vp, __unused int *fhlenp, __unused unsigned char *fhp, __unused vfs_context_t ctx)
425 {
426 	return EINVAL;
427 }
428 
429 static int
routefs_sysctl(__unused int * name,__unused u_int namelen,__unused user_addr_t oldp,__unused size_t * oldlenp,__unused user_addr_t newp,__unused size_t newlen,__unused vfs_context_t ctx)430 routefs_sysctl(__unused int *name, __unused u_int namelen, __unused user_addr_t oldp,
431     __unused size_t *oldlenp, __unused user_addr_t newp,
432     __unused size_t newlen, __unused vfs_context_t ctx)
433 {
434 	return ENOTSUP;
435 }
436 
437 #include <sys/namei.h>
438 #define MOBILE_DIR_PATH "/private/var/mobile"
439 /*
440  * Function: routefs_kernel_mount
441  * Purpose:
442  *   Mount routefs at the given mount point from within the kernel.
443  */
444 int
routefs_kernel_mount(char * routepath)445 routefs_kernel_mount(char * routepath)
446 {
447 	int error = EINVAL;
448 	vfs_context_t ctx = vfs_context_kernel();
449 	char fsname[] = "routefs";
450 	struct routefs_args args;
451 	char mounthere[] = MOBILE_DIR_PATH; /* !const because of internal casting */
452 
453 	bzero(&args, sizeof(struct routefs_args));
454 	strlcpy(args.route_path, routepath, MAXPATHLEN);
455 	error = vnode_lookup(args.route_path, FREAD | O_DIRECTORY, &args.route_rvp, ctx);
456 	if (error) {
457 		goto out;
458 	}
459 
460 	if (!vnode_isdir(args.route_rvp)) {
461 		error = EACCES;
462 		goto out;
463 	}
464 
465 	error = kernel_mount(fsname, NULLVP, NULLVP, mounthere, &args, 0, MNT_DONTBROWSE, KERNEL_MOUNT_NOAUTH, ctx);
466 	if (error) {
467 		goto out;
468 	}
469 
470 out:
471 	if (args.route_rvp != NULLVP) {
472 		(void) vnode_put(args.route_rvp);
473 	}
474 	return error;
475 }
476 
477 const struct vfsops routefs_vfsops = {
478 	.vfs_mount = routefs_mount,
479 	.vfs_start = routefs_start,
480 	.vfs_unmount = routefs_unmount,
481 	.vfs_root = routefs_root,
482 	.vfs_getattr = routefs_vfs_getattr,
483 	.vfs_sync = routefs_sync,
484 	.vfs_vget = routefs_vget,
485 	.vfs_fhtovp = routefs_fhtovp,
486 	.vfs_vptofh = routefs_vptofh,
487 	.vfs_init = routefs_init,
488 	.vfs_sysctl = routefs_sysctl,
489 	// There are other VFS ops that we do not support
490 };
491 
492 static int
routefserr_lookup(__unused struct vnop_lookup_args * args)493 routefserr_lookup(__unused struct vnop_lookup_args * args)
494 {
495 	return ENOTSUP;
496 }
497 
498 static int
routefserr_setlabel(__unused struct vnop_setlabel_args * args)499 routefserr_setlabel(__unused struct vnop_setlabel_args * args)
500 {
501 	return ENOTSUP;
502 }
503 
504 #define VOPFUNC int (*)(void *)
505 
506 /* The following ops are used by directories and symlinks */
507 int(**routefs_vnodeop_p)(void *);
508 static const struct vnodeopv_entry_desc routefs_vnodeop_entries[] = {
509 	{ .opve_op = &vnop_default_desc, .opve_impl = (VOPFUNC)(void *)vn_default_error },
510 	{ .opve_op = &vnop_lookup_desc, .opve_impl = (VOPFUNC)routefserr_lookup },      /* lookup */
511 	{ .opve_op = &vnop_create_desc, .opve_impl = (VOPFUNC)err_create },     /* create */
512 	{ .opve_op = &vnop_whiteout_desc, .opve_impl = (VOPFUNC)err_whiteout },         /* whiteout */
513 	{ .opve_op = &vnop_mknod_desc, .opve_impl = (VOPFUNC)err_mknod },       /* mknod */
514 	{ .opve_op = &vnop_open_desc, .opve_impl = (VOPFUNC)err_open },                 /* open */
515 	{ .opve_op = &vnop_close_desc, .opve_impl = (VOPFUNC)err_close },       /* close */
516 	{ .opve_op = &vnop_getattr_desc, .opve_impl = (VOPFUNC)err_getattr },           /* getattr */
517 	{ .opve_op = &vnop_setattr_desc, .opve_impl = (VOPFUNC)err_setattr },           /* setattr */
518 	{ .opve_op = &vnop_read_desc, .opve_impl = (VOPFUNC)err_read },         /* read */
519 	{ .opve_op = &vnop_write_desc, .opve_impl = (VOPFUNC)err_write },       /* write */
520 	{ .opve_op = &vnop_ioctl_desc, .opve_impl = (VOPFUNC)err_ioctl },       /* ioctl */
521 	{ .opve_op = &vnop_select_desc, .opve_impl = (VOPFUNC)err_select },     /* select */
522 	{ .opve_op = &vnop_revoke_desc, .opve_impl = (VOPFUNC)err_revoke },     /* revoke */
523 	{ .opve_op = &vnop_mmap_desc, .opve_impl = (VOPFUNC)err_mmap },                 /* mmap */
524 	{ .opve_op = &vnop_fsync_desc, .opve_impl = (VOPFUNC)nop_fsync },       /* fsync */
525 	{ .opve_op = &vnop_remove_desc, .opve_impl = (VOPFUNC)err_remove }, /* remove */
526 	{ .opve_op = &vnop_link_desc, .opve_impl = (VOPFUNC)err_link },         /* link */
527 	{ .opve_op = &vnop_rename_desc, .opve_impl = (VOPFUNC)err_rename },     /* rename */
528 	{ .opve_op = &vnop_mkdir_desc, .opve_impl = (VOPFUNC)err_mkdir },       /* mkdir */
529 	{ .opve_op = &vnop_rmdir_desc, .opve_impl = (VOPFUNC)err_rmdir },       /* rmdir */
530 	{ .opve_op = &vnop_symlink_desc, .opve_impl = (VOPFUNC)err_symlink },           /* symlink */
531 	{ .opve_op = &vnop_readdir_desc, .opve_impl = (VOPFUNC)err_readdir },           /* readdir */
532 	{ .opve_op = &vnop_readlink_desc, .opve_impl = (VOPFUNC)err_readlink }, /* readlink */
533 	{ .opve_op = &vnop_inactive_desc, .opve_impl = (VOPFUNC)err_inactive }, /* inactive */
534 	{ .opve_op = &vnop_reclaim_desc, .opve_impl = (VOPFUNC)err_reclaim },           /* reclaim */
535 	{ .opve_op = &vnop_strategy_desc, .opve_impl = (VOPFUNC)err_strategy },         /* strategy */
536 	{ .opve_op = &vnop_pathconf_desc, .opve_impl = (VOPFUNC)err_pathconf }, /* pathconf */
537 	{ .opve_op = &vnop_advlock_desc, .opve_impl = (VOPFUNC)err_advlock },           /* advlock */
538 	{ .opve_op = &vnop_bwrite_desc, .opve_impl = (VOPFUNC)err_bwrite },
539 	{ .opve_op = &vnop_pagein_desc, .opve_impl = (VOPFUNC)err_pagein },     /* Pagein */
540 	{ .opve_op = &vnop_pageout_desc, .opve_impl = (VOPFUNC)err_pageout },           /* Pageout */
541 	{ .opve_op = &vnop_copyfile_desc, .opve_impl = (VOPFUNC)err_copyfile },         /* Copyfile */
542 	{ .opve_op = &vnop_blktooff_desc, .opve_impl = (VOPFUNC)err_blktooff },         /* blktooff */
543 	{ .opve_op = &vnop_offtoblk_desc, .opve_impl = (VOPFUNC)err_offtoblk },         /* offtoblk */
544 	{ .opve_op = &vnop_blockmap_desc, .opve_impl = (VOPFUNC)err_blockmap },         /* blockmap */
545 #if CONFIG_MACF
546 	{ .opve_op = &vnop_setlabel_desc, .opve_impl = (VOPFUNC)routefserr_setlabel },   /* setlabel */
547 #endif
548 	{ .opve_op = (struct vnodeop_desc*)NULL, .opve_impl = (int (*)(void *))NULL }
549 };
550 
551 const struct vnodeopv_desc routefs_vnodeop_opv_desc =
552 { .opv_desc_vector_p = &routefs_vnodeop_p, .opv_desc_ops = routefs_vnodeop_entries };
553