[apple/xnu.git] / bsd / miscfs / fdesc / fdesc_vfsops.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
/*
 * Copyright (c) 1992, 1993, 1995
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software donated to Berkeley by
 * Jan-Simon Pendry.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)fdesc_vfsops.c	8.10 (Berkeley) 5/14/95
 *
 */

/*
 * /dev/fd Filesystem
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/proc_internal.h>
#include <sys/resourcevar.h>
#include <sys/filedesc.h>
#include <sys/vnode.h>
#include <sys/mount_internal.h>
#include <sys/namei.h>
#include <sys/malloc.h>
#include <miscfs/fdesc/fdesc.h>

/*
 * Mount the per-process file descriptors (/dev/fd)
 */
int
fdesc_mount(struct mount *mp, vnode_t devvp, __unused user_addr_t data, vfs_context_t context)
{
	int error = 0;
	struct fdescmount *fmp;
	struct vnode *rvp;

	/*
	 * Update is a no-op
	 */
	if (mp->mnt_flag & MNT_UPDATE)
		return (ENOTSUP);

	error = fdesc_allocvp(Froot, FD_ROOT, mp, &rvp, VDIR);
	if (error)
		return (error);

	MALLOC(fmp, struct fdescmount *, sizeof(struct fdescmount),
				M_UFSMNT, M_WAITOK);	/* XXX */

	vnode_setnoflush(rvp);
	vnode_ref(rvp);
	vnode_put(rvp);

	fmp->f_root = rvp;
	/* XXX -- don't mark as local to work around fts() problems */
	/*mp->mnt_flag |= MNT_LOCAL;*/
	mp->mnt_data = (qaddr_t) fmp;
	vfs_getnewfsid(mp);

	bzero(mp->mnt_vfsstat.f_mntfromname, MAXPATHLEN);
	bcopy("fdesc", mp->mnt_vfsstat.f_mntfromname, sizeof("fdesc"));
	return (0);
}

int
fdesc_start(mp, flags, context)
	struct mount *mp;
	int flags;
	vfs_context_t context;
{
	return (0);
}

int
fdesc_unmount(mp, mntflags, context)
	struct mount *mp;
	int mntflags;
	vfs_context_t context;
{
	int error;
	int flags = 0;
	int force = 0;
	struct vnode *rvp = VFSTOFDESC(mp)->f_root;

	if (mntflags & MNT_FORCE) {
		flags |= FORCECLOSE;
		force = 1;
	}

	if ( vnode_isinuse(rvp, 1) && !force )
		return (EBUSY);
	if ( (error = vflush(mp, rvp, flags|SKIPSYSTEM)) && !force )
		return (error);

	/*
	 * And mark for recycle after we drop its reference; it away for future re-use
	 */
	vnode_recycle(rvp);
	/*
	 * Release reference on underlying root vnode
	 */
	vnode_rele(rvp);
	/*
	 * Finally, throw away the fdescmount structure
	 */
	_FREE(mp->mnt_data, M_UFSMNT);	/* XXX */
	mp->mnt_data = 0;

	return (0);
}

int
fdesc_root(mp, vpp, context)
	struct mount *mp;
	struct vnode **vpp;
	vfs_context_t context;
{
	struct vnode *vp;

	/*
	 * Return locked reference to root.
	 */
	vp = VFSTOFDESC(mp)->f_root;
	vnode_get(vp);
	*vpp = vp;
	return (0);
}

int
fdesc_statfs(mp, sbp, context)
	struct mount *mp;
	struct vfsstatfs *sbp;
	vfs_context_t context;
{
	struct proc *p = vfs_context_proc(context);
	struct filedesc *fdp;
	int lim;
	int i;
	int last;
	int freefd;

	/*
	 * Compute number of free file descriptors.
	 * [ Strange results will ensue if the open file
	 * limit is ever reduced below the current number
	 * of open files... ]
	 */
	lim = p->p_rlimit[RLIMIT_NOFILE].rlim_cur;
	fdp = p->p_fd;
	last = min(fdp->fd_nfiles, lim);
	freefd = 0;
	for (i = fdp->fd_freefile; i < last; i++)
		if (fdp->fd_ofiles[i] == NULL &&
				!(fdp->fd_ofileflags[i] & UF_RESERVED))
			freefd++;

	/*
	 * Adjust for the fact that the fdesc array may not
	 * have been fully allocated yet.
	 */
	if (fdp->fd_nfiles < lim)
		freefd += (lim - fdp->fd_nfiles);

	sbp->f_flags = 0;
	sbp->f_bsize = DEV_BSIZE;
	sbp->f_iosize = DEV_BSIZE;
	sbp->f_blocks = (uint64_t)2;		/* 1K to keep df happy */
	sbp->f_bfree = 0;
	sbp->f_bavail = 0;
	sbp->f_files = (uint64_t)((unsigned long)(lim + 1));		/* Allow for "." */
	sbp->f_ffree = (uint64_t)((unsigned long)freefd);		/* See comments above */

	return (0);
}

static int
fdesc_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t context)
{
	VFSATTR_RETURN(fsap, f_bsize, DEV_BSIZE);
	VFSATTR_RETURN(fsap, f_iosize, DEV_BSIZE);
	VFSATTR_RETURN(fsap, f_blocks, 2);
	VFSATTR_RETURN(fsap, f_bfree, 0);
	VFSATTR_RETURN(fsap, f_bavail, 0);
	VFSATTR_RETURN(fsap, f_fssubtype, 0);
	
	if (VFSATTR_IS_ACTIVE(fsap, f_objcount) ||
	    VFSATTR_IS_ACTIVE(fsap, f_maxobjcount) ||
	    VFSATTR_IS_ACTIVE(fsap, f_files) ||
	    VFSATTR_IS_ACTIVE(fsap, f_ffree))
	{
		struct proc *p = vfs_context_proc(context);
		struct filedesc *fdp;
		int lim;
		int i;
		int last;
		int freefd;
	
		/*
		 * Compute number of free file descriptors.
		 * [ Strange results will ensue if the open file
		 * limit is ever reduced below the current number
		 * of open files... ]
		 */
		lim = p->p_rlimit[RLIMIT_NOFILE].rlim_cur;
		fdp = p->p_fd;
		last = min(fdp->fd_nfiles, lim);
		freefd = 0;
		for (i = fdp->fd_freefile; i < last; i++)
			if (fdp->fd_ofiles[i] == NULL &&
					!(fdp->fd_ofileflags[i] & UF_RESERVED))
				freefd++;
	
		/*
		 * Adjust for the fact that the fdesc array may not
		 * have been fully allocated yet.
		 */
		if (fdp->fd_nfiles < lim)
			freefd += (lim - fdp->fd_nfiles);
		
		VFSATTR_RETURN(fsap, f_objcount, lim+1);
		VFSATTR_RETURN(fsap, f_maxobjcount, lim+1);
		VFSATTR_RETURN(fsap, f_files, lim+1);
		VFSATTR_RETURN(fsap, f_ffree, freefd);
	}
	
	return 0;
}

int
fdesc_sync(mp, waitfor, context)
	struct mount *mp;
	int waitfor;
	vfs_context_t context;
{

	return (0);
}

#define fdesc_fhtovp (int (*) (mount_t, int, unsigned char *, vnode_t *, vfs_context_t))eopnotsupp
#define fdesc_sysctl (int (*) (int *, u_int, user_addr_t, size_t *, user_addr_t, size_t, vfs_context_t))eopnotsupp
#define fdesc_vget (int (*) (mount_t, ino64_t, vnode_t *, vfs_context_t))eopnotsupp
#define fdesc_vptofh (int (*) (vnode_t, int *, unsigned char *, vfs_context_t))eopnotsupp

struct vfsops fdesc_vfsops = {
	fdesc_mount,
	fdesc_start,
	fdesc_unmount,
	fdesc_root,
	NULL, 			/* quotactl */
	fdesc_vfs_getattr,
	fdesc_sync,
	fdesc_vget,
	fdesc_fhtovp,
	fdesc_vptofh,
	fdesc_init,
	fdesc_sysctl
};
Commit	Line	Data
1c79356b	1	/*
5d5c5d0d A	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
5d5c5d0d A	3	*
8f6c56a5	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
8f6c56a5 A	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
8ad349bb	24	* limitations under the License.
8f6c56a5 A	25	*
8f6c56a5 A	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
	29	/*
	30	* Copyright (c) 1992, 1993, 1995
	31	* The Regents of the University of California. All rights reserved.
	32	*
	33	* This code is derived from software donated to Berkeley by
	34	* Jan-Simon Pendry.
	35	*
	36	* Redistribution and use in source and binary forms, with or without
	37	* modification, are permitted provided that the following conditions
	38	* are met:
	39	* 1. Redistributions of source code must retain the above copyright
	40	* notice, this list of conditions and the following disclaimer.
	41	* 2. Redistributions in binary form must reproduce the above copyright
	42	* notice, this list of conditions and the following disclaimer in the
	43	* documentation and/or other materials provided with the distribution.
	44	* 3. All advertising materials mentioning features or use of this software
	45	* must display the following acknowledgement:
	46	* This product includes software developed by the University of
	47	* California, Berkeley and its contributors.
	48	* 4. Neither the name of the University nor the names of its contributors
	49	* may be used to endorse or promote products derived from this software
	50	* without specific prior written permission.
	51	*
	52	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	53	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	54	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	55	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	56	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	57	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	58	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	59	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	60	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	61	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	62	* SUCH DAMAGE.
	63	*
	64	* @(#)fdesc_vfsops.c 8.10 (Berkeley) 5/14/95
	65	*
	66	*/
	67
	68	/*
	69	* /dev/fd Filesystem
	70	*/
	71
	72	#include <sys/param.h>
	73	#include <sys/systm.h>
	74	#include <sys/time.h>
	75	#include <sys/types.h>
91447636	76	#include <sys/proc_internal.h>
1c79356b A	77	#include <sys/resourcevar.h>
	78	#include <sys/filedesc.h>
	79	#include <sys/vnode.h>
91447636	80	#include <sys/mount_internal.h>
1c79356b A	81	#include <sys/namei.h>
	82	#include <sys/malloc.h>
	83	#include <miscfs/fdesc/fdesc.h>
	84
	85	/*
	86	* Mount the per-process file descriptors (/dev/fd)
	87	*/
	88	int
91447636	89	fdesc_mount(struct mount *mp, vnode_t devvp, __unused user_addr_t data, vfs_context_t context)
1c79356b A	90	{
1c79356b A	91	int error = 0;
1c79356b A	92	struct fdescmount *fmp;
	93	struct vnode *rvp;
	94
	95	/*
	96	* Update is a no-op
	97	*/
	98	if (mp->mnt_flag & MNT_UPDATE)
91447636	99	return (ENOTSUP);
1c79356b	100
91447636	101	error = fdesc_allocvp(Froot, FD_ROOT, mp, &rvp, VDIR);
1c79356b A	102	if (error)
	103	return (error);
	104
	105	MALLOC(fmp, struct fdescmount *, sizeof(struct fdescmount),
	106	M_UFSMNT, M_WAITOK); /* XXX */
91447636 A	107
	108	vnode_setnoflush(rvp);
	109	vnode_ref(rvp);
	110	vnode_put(rvp);
	111
1c79356b A	112	fmp->f_root = rvp;
	113	/* XXX -- don't mark as local to work around fts() problems */
	114	/mp->mnt_flag \|= MNT_LOCAL;/
	115	mp->mnt_data = (qaddr_t) fmp;
	116	vfs_getnewfsid(mp);
	117
91447636 A	118	bzero(mp->mnt_vfsstat.f_mntfromname, MAXPATHLEN);
91447636 A	119	bcopy("fdesc", mp->mnt_vfsstat.f_mntfromname, sizeof("fdesc"));
1c79356b A	120	return (0);
	121	}
	122
	123	int
91447636	124	fdesc_start(mp, flags, context)
1c79356b A	125	struct mount *mp;
1c79356b A	126	int flags;
91447636	127	vfs_context_t context;
1c79356b A	128	{
	129	return (0);
	130	}
	131
	132	int
91447636	133	fdesc_unmount(mp, mntflags, context)
1c79356b A	134	struct mount *mp;
1c79356b A	135	int mntflags;
91447636	136	vfs_context_t context;
1c79356b A	137	{
	138	int error;
	139	int flags = 0;
9bccf70c	140	int force = 0;
91447636	141	struct vnode *rvp = VFSTOFDESC(mp)->f_root;
1c79356b	142
9bccf70c	143	if (mntflags & MNT_FORCE) {
1c79356b	144	flags \|= FORCECLOSE;
9bccf70c A	145	force = 1;
9bccf70c A	146	}
1c79356b	147
91447636	148	if ( vnode_isinuse(rvp, 1) && !force )
1c79356b	149	return (EBUSY);
91447636	150	if ( (error = vflush(mp, rvp, flags\|SKIPSYSTEM)) && !force )
1c79356b A	151	return (error);
	152
	153	/*
91447636	154	* And mark for recycle after we drop its reference; it away for future re-use
1c79356b	155	*/
91447636	156	vnode_recycle(rvp);
1c79356b	157	/*
91447636	158	* Release reference on underlying root vnode
1c79356b	159	*/
91447636	160	vnode_rele(rvp);
1c79356b A	161	/*
	162	* Finally, throw away the fdescmount structure
	163	*/
	164	_FREE(mp->mnt_data, M_UFSMNT); /* XXX */
	165	mp->mnt_data = 0;
	166
	167	return (0);
	168	}
	169
	170	int
91447636	171	fdesc_root(mp, vpp, context)
1c79356b A	172	struct mount *mp;
1c79356b A	173	struct vnode **vpp;
91447636	174	vfs_context_t context;
1c79356b	175	{
1c79356b A	176	struct vnode *vp;
	177
	178	/*
	179	* Return locked reference to root.
	180	*/
	181	vp = VFSTOFDESC(mp)->f_root;
91447636	182	vnode_get(vp);
1c79356b A	183	*vpp = vp;
	184	return (0);
	185	}
	186
	187	int
91447636	188	fdesc_statfs(mp, sbp, context)
1c79356b	189	struct mount *mp;
91447636 A	190	struct vfsstatfs *sbp;
91447636 A	191	vfs_context_t context;
1c79356b	192	{
91447636	193	struct proc *p = vfs_context_proc(context);
1c79356b A	194	struct filedesc *fdp;
	195	int lim;
	196	int i;
	197	int last;
	198	int freefd;
	199
	200	/*
	201	* Compute number of free file descriptors.
	202	* [ Strange results will ensue if the open file
	203	* limit is ever reduced below the current number
	204	* of open files... ]
	205	*/
	206	lim = p->p_rlimit[RLIMIT_NOFILE].rlim_cur;
	207	fdp = p->p_fd;
	208	last = min(fdp->fd_nfiles, lim);
	209	freefd = 0;
	210	for (i = fdp->fd_freefile; i < last; i++)
	211	if (fdp->fd_ofiles[i] == NULL &&
	212	!(fdp->fd_ofileflags[i] & UF_RESERVED))
	213	freefd++;
	214
	215	/*
	216	* Adjust for the fact that the fdesc array may not
	217	* have been fully allocated yet.
	218	*/
	219	if (fdp->fd_nfiles < lim)
	220	freefd += (lim - fdp->fd_nfiles);
	221
	222	sbp->f_flags = 0;
	223	sbp->f_bsize = DEV_BSIZE;
	224	sbp->f_iosize = DEV_BSIZE;
91447636	225	sbp->f_blocks = (uint64_t)2; /* 1K to keep df happy */
1c79356b A	226	sbp->f_bfree = 0;
1c79356b A	227	sbp->f_bavail = 0;
91447636 A	228	sbp->f_files = (uint64_t)((unsigned long)(lim + 1)); /* Allow for "." */
	229	sbp->f_ffree = (uint64_t)((unsigned long)freefd); /* See comments above */
	230
1c79356b A	231	return (0);
	232	}
	233
91447636 A	234	static int
	235	fdesc_vfs_getattr(mount_t mp, struct vfs_attr *fsap, vfs_context_t context)
	236	{
	237	VFSATTR_RETURN(fsap, f_bsize, DEV_BSIZE);
	238	VFSATTR_RETURN(fsap, f_iosize, DEV_BSIZE);
	239	VFSATTR_RETURN(fsap, f_blocks, 2);
	240	VFSATTR_RETURN(fsap, f_bfree, 0);
	241	VFSATTR_RETURN(fsap, f_bavail, 0);
	242	VFSATTR_RETURN(fsap, f_fssubtype, 0);
	243
	244	if (VFSATTR_IS_ACTIVE(fsap, f_objcount) \|\|
	245	VFSATTR_IS_ACTIVE(fsap, f_maxobjcount) \|\|
	246	VFSATTR_IS_ACTIVE(fsap, f_files) \|\|
	247	VFSATTR_IS_ACTIVE(fsap, f_ffree))
	248	{
	249	struct proc *p = vfs_context_proc(context);
	250	struct filedesc *fdp;
	251	int lim;
	252	int i;
	253	int last;
	254	int freefd;
	255
	256	/*
	257	* Compute number of free file descriptors.
	258	* [ Strange results will ensue if the open file
	259	* limit is ever reduced below the current number
	260	* of open files... ]
	261	*/
	262	lim = p->p_rlimit[RLIMIT_NOFILE].rlim_cur;
	263	fdp = p->p_fd;
	264	last = min(fdp->fd_nfiles, lim);
	265	freefd = 0;
	266	for (i = fdp->fd_freefile; i < last; i++)
	267	if (fdp->fd_ofiles[i] == NULL &&
	268	!(fdp->fd_ofileflags[i] & UF_RESERVED))
	269	freefd++;
	270
	271	/*
	272	* Adjust for the fact that the fdesc array may not
	273	* have been fully allocated yet.
	274	*/
	275	if (fdp->fd_nfiles < lim)
	276	freefd += (lim - fdp->fd_nfiles);
	277
	278	VFSATTR_RETURN(fsap, f_objcount, lim+1);
	279	VFSATTR_RETURN(fsap, f_maxobjcount, lim+1);
	280	VFSATTR_RETURN(fsap, f_files, lim+1);
	281	VFSATTR_RETURN(fsap, f_ffree, freefd);
	282	}
	283
	284	return 0;
	285	}
	286
1c79356b	287	int
91447636	288	fdesc_sync(mp, waitfor, context)
1c79356b A	289	struct mount *mp;
1c79356b A	290	int waitfor;
91447636	291	vfs_context_t context;
1c79356b A	292	{
	293
	294	return (0);
	295	}
	296
91447636 A	297	#define fdesc_fhtovp (int () (mount_t, int, unsigned char , vnode_t *, vfs_context_t))eopnotsupp
	298	#define fdesc_sysctl (int () (int , u_int, user_addr_t, size_t *, user_addr_t, size_t, vfs_context_t))eopnotsupp
	299	#define fdesc_vget (int () (mount_t, ino64_t, vnode_t , vfs_context_t))eopnotsupp
	300	#define fdesc_vptofh (int () (vnode_t, int , unsigned char *, vfs_context_t))eopnotsupp
1c79356b A	301
	302	struct vfsops fdesc_vfsops = {
	303	fdesc_mount,
	304	fdesc_start,
	305	fdesc_unmount,
	306	fdesc_root,
91447636 A	307	NULL, /* quotactl */
91447636 A	308	fdesc_vfs_getattr,
1c79356b A	309	fdesc_sync,
	310	fdesc_vget,
	311	fdesc_fhtovp,
	312	fdesc_vptofh,
	313	fdesc_init,
91447636	314	fdesc_sysctl
1c79356b	315	};