1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1989, 1990, 1993, 1994
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
1997-02-10 02:22:35 +00:00
|
|
|
* @(#)mfs_vfsops.c 8.11 (Berkeley) 6/19/95
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
1998-05-11 19:27:18 +00:00
|
|
|
|
1998-01-24 02:54:56 +00:00
|
|
|
#include "opt_mfs.h"
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
1995-12-14 20:16:15 +00:00
|
|
|
#include <sys/conf.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/proc.h>
|
2000-05-05 09:59:14 +00:00
|
|
|
#include <sys/bio.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/buf.h>
|
|
|
|
#include <sys/mount.h>
|
|
|
|
#include <sys/signalvar.h>
|
|
|
|
#include <sys/vnode.h>
|
|
|
|
#include <sys/malloc.h>
|
1998-10-09 01:40:56 +00:00
|
|
|
#include <sys/linker.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
Introduce extended attribute support for FFS, allowing arbitrary
(name, value) pairs to be associated with inodes. This support is
used for ACLs, MAC labels, and Capabilities in the TrustedBSD
security extensions, which are currently under development.
In this implementation, attributes are backed to data vnodes in the
style of the quota support in FFS. Support for FFS extended
attributes may be enabled using the FFS_EXTATTR kernel option
(disabled by default). Userland utilities and man pages will be
committed in the next batch. VFS interfaces and man pages have
been in the repo since 4.0-RELEASE and are unchanged.
o ufs/ufs/extattr.h: UFS-specific extattr defines
o ufs/ufs/ufs_extattr.c: bulk of support routines
o ufs/{ufs,ffs,mfs}/*.[ch]: hooks and extattr.h includes
o contrib/softupdates/ffs_softdep.c: extattr.h includes
o conf/options, conf/files, i386/conf/LINT: added FFS_EXTATTR
o coda/coda_vfsops.c: XXX required extattr.h due to ufsmount.h
(This should not be the case, and will be fixed in a future commit)
Currently attributes are not supported in MFS. This will be fixed.
Reviewed by: adrian, bp, freebsd-fs, other unthanked souls
Obtained from: TrustedBSD Project
2000-04-15 03:34:27 +00:00
|
|
|
#include <ufs/ufs/extattr.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <ufs/ufs/quota.h>
|
|
|
|
#include <ufs/ufs/inode.h>
|
|
|
|
#include <ufs/ufs/ufsmount.h>
|
|
|
|
#include <ufs/ufs/ufs_extern.h>
|
|
|
|
|
|
|
|
#include <ufs/ffs/fs.h>
|
|
|
|
#include <ufs/ffs/ffs_extern.h>
|
|
|
|
|
|
|
|
#include <ufs/mfs/mfsnode.h>
|
|
|
|
#include <ufs/mfs/mfs_extern.h>
|
|
|
|
|
1997-11-01 20:19:44 +00:00
|
|
|
MALLOC_DEFINE(M_MFSNODE, "MFS node", "MFS vnode private part");
|
1997-10-11 18:31:40 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-05-14 20:40:23 +00:00
|
|
|
static int mfs_minor; /* used for building internal dev_t */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-11-09 08:17:23 +00:00
|
|
|
extern vop_t **mfs_vnodeop_p;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-12-17 21:14:36 +00:00
|
|
|
static int mfs_mount __P((struct mount *mp,
|
|
|
|
char *path, caddr_t data, struct nameidata *ndp,
|
|
|
|
struct proc *p));
|
|
|
|
static int mfs_start __P((struct mount *mp, int flags, struct proc *p));
|
|
|
|
static int mfs_statfs __P((struct mount *mp, struct statfs *sbp,
|
|
|
|
struct proc *p));
|
1997-02-10 02:22:35 +00:00
|
|
|
static int mfs_init __P((struct vfsconf *));
|
1995-12-17 21:14:36 +00:00
|
|
|
|
1999-07-20 09:47:55 +00:00
|
|
|
static struct cdevsw mfs_cdevsw = {
|
|
|
|
/* open */ noopen,
|
|
|
|
/* close */ noclose,
|
|
|
|
/* read */ physread,
|
|
|
|
/* write */ physwrite,
|
|
|
|
/* ioctl */ noioctl,
|
|
|
|
/* poll */ nopoll,
|
|
|
|
/* mmap */ nommap,
|
|
|
|
/* strategy */ nostrategy,
|
|
|
|
/* name */ "MFS",
|
|
|
|
/* maj */ 253,
|
|
|
|
/* dump */ nodump,
|
|
|
|
/* psize */ nopsize,
|
|
|
|
/* flags */ D_DISK,
|
|
|
|
/* bmaj */ 253,
|
|
|
|
};
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* mfs vfs operations.
|
|
|
|
*/
|
1998-02-09 06:11:36 +00:00
|
|
|
static struct vfsops mfs_vfsops = {
|
1994-05-24 10:09:53 +00:00
|
|
|
mfs_mount,
|
|
|
|
mfs_start,
|
|
|
|
ffs_unmount,
|
|
|
|
ufs_root,
|
|
|
|
ufs_quotactl,
|
|
|
|
mfs_statfs,
|
|
|
|
ffs_sync,
|
|
|
|
ffs_vget,
|
|
|
|
ffs_fhtovp,
|
1999-09-11 00:46:08 +00:00
|
|
|
ufs_check_export,
|
1994-05-24 10:09:53 +00:00
|
|
|
ffs_vptofh,
|
|
|
|
mfs_init,
|
1999-12-19 06:08:07 +00:00
|
|
|
vfs_stduninit,
|
|
|
|
vfs_stdextattrctl,
|
1994-05-24 10:09:53 +00:00
|
|
|
};
|
|
|
|
|
1998-09-07 13:17:06 +00:00
|
|
|
VFS_SET(mfs_vfsops, mfs, 0);
|
1994-09-21 03:47:43 +00:00
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
1995-08-28 09:19:25 +00:00
|
|
|
* mfs_mount
|
1994-05-24 10:09:53 +00:00
|
|
|
*
|
1995-08-28 09:19:25 +00:00
|
|
|
* Called when mounting local physical media
|
|
|
|
*
|
|
|
|
* PARAMETERS:
|
|
|
|
* mountroot
|
|
|
|
* mp mount point structure
|
|
|
|
* path NULL (flag for root mount!!!)
|
|
|
|
* data <unused>
|
|
|
|
* ndp <unused>
|
|
|
|
* p process (user credentials check [statfs])
|
|
|
|
*
|
|
|
|
* mount
|
|
|
|
* mp mount point structure
|
|
|
|
* path path to mount point
|
|
|
|
* data pointer to argument struct in user space
|
|
|
|
* ndp mount point namei() return (used for
|
|
|
|
* credentials on reload), reused to look
|
|
|
|
* up block device.
|
|
|
|
* p process (user credentials check)
|
|
|
|
*
|
|
|
|
* RETURNS: 0 Success
|
|
|
|
* !0 error number (errno.h)
|
|
|
|
*
|
|
|
|
* LOCK STATE:
|
|
|
|
*
|
|
|
|
* ENTRY
|
|
|
|
* mount point is locked
|
|
|
|
* EXIT
|
|
|
|
* mount point is locked
|
|
|
|
*
|
|
|
|
* NOTES:
|
|
|
|
* A NULL path can be used for a flag since the mount
|
|
|
|
* system call will fail with EFAULT in copyinstr in
|
|
|
|
* namei() if it is a genuine NULL from the user.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
1995-12-17 21:14:36 +00:00
|
|
|
static int
|
1994-05-24 10:09:53 +00:00
|
|
|
mfs_mount(mp, path, data, ndp, p)
|
|
|
|
register struct mount *mp;
|
|
|
|
char *path;
|
|
|
|
caddr_t data;
|
|
|
|
struct nameidata *ndp;
|
|
|
|
struct proc *p;
|
|
|
|
{
|
|
|
|
struct vnode *devvp;
|
|
|
|
struct mfs_args args;
|
|
|
|
struct ufsmount *ump;
|
1997-02-10 02:22:35 +00:00
|
|
|
struct fs *fs;
|
|
|
|
struct mfsnode *mfsp;
|
1999-04-21 09:41:07 +00:00
|
|
|
size_t size;
|
1995-08-28 09:19:25 +00:00
|
|
|
int flags, err;
|
1999-08-24 18:35:33 +00:00
|
|
|
dev_t dev;
|
1995-08-28 09:19:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Use NULL path to flag a root mount
|
|
|
|
*/
|
|
|
|
if( path == NULL) {
|
|
|
|
/*
|
|
|
|
***
|
|
|
|
* Mounting root file system
|
|
|
|
***
|
|
|
|
*/
|
|
|
|
|
1995-11-28 03:15:58 +00:00
|
|
|
/* you loose */
|
|
|
|
panic("mfs_mount: mount MFS as root: not configured!");
|
1995-08-28 09:19:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
***
|
|
|
|
* Mounting non-root file system or updating a file system
|
|
|
|
***
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
/* copy in user arguments*/
|
1999-01-28 00:57:57 +00:00
|
|
|
if ((err = copyin(data, (caddr_t)&args, sizeof (struct mfs_args))) != 0)
|
1995-08-28 09:19:25 +00:00
|
|
|
goto error_1;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If updating, check whether changing from read-only to
|
|
|
|
* read/write; if there is no device name, that's all we do.
|
|
|
|
*/
|
|
|
|
if (mp->mnt_flag & MNT_UPDATE) {
|
1995-08-28 09:19:25 +00:00
|
|
|
/*
|
|
|
|
********************
|
|
|
|
* UPDATE
|
|
|
|
********************
|
|
|
|
*/
|
1994-05-24 10:09:53 +00:00
|
|
|
ump = VFSTOUFS(mp);
|
|
|
|
fs = ump->um_fs;
|
|
|
|
if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
|
|
|
|
flags = WRITECLOSE;
|
|
|
|
if (mp->mnt_flag & MNT_FORCE)
|
|
|
|
flags |= FORCECLOSE;
|
1995-08-28 09:19:25 +00:00
|
|
|
err = ffs_flushfiles(mp, flags, p);
|
|
|
|
if (err)
|
|
|
|
goto error_1;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1997-11-12 05:42:33 +00:00
|
|
|
if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR))
|
1994-05-24 10:09:53 +00:00
|
|
|
fs->fs_ronly = 0;
|
1995-08-28 09:19:25 +00:00
|
|
|
/* if not updating name...*/
|
|
|
|
if (args.fspec == 0) {
|
|
|
|
/*
|
|
|
|
* Process export requests. Jumping to "success"
|
|
|
|
* will return the vfs_export() error code.
|
|
|
|
*/
|
|
|
|
err = vfs_export(mp, &ump->um_export, &args.export);
|
|
|
|
goto success;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* XXX MFS does not support name updating*/
|
|
|
|
goto success;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1996-06-12 03:37:57 +00:00
|
|
|
/*
|
|
|
|
* Do the MALLOC before the getnewvnode since doing so afterward
|
|
|
|
* might cause a bogus v_data pointer to get dereferenced
|
|
|
|
* elsewhere if MALLOC should block.
|
|
|
|
*/
|
|
|
|
MALLOC(mfsp, struct mfsnode *, sizeof *mfsp, M_MFSNODE, M_WAITOK);
|
|
|
|
|
1997-03-22 03:59:46 +00:00
|
|
|
err = getnewvnode(VT_MFS, (struct mount *)0, mfs_vnodeop_p, &devvp);
|
1996-06-12 03:37:57 +00:00
|
|
|
if (err) {
|
|
|
|
FREE(mfsp, M_MFSNODE);
|
1995-08-28 09:19:25 +00:00
|
|
|
goto error_1;
|
1996-06-12 03:37:57 +00:00
|
|
|
}
|
2000-04-22 05:45:38 +00:00
|
|
|
devvp->v_type = VCHR;
|
2000-08-20 21:34:39 +00:00
|
|
|
dev = makedev(mfs_cdevsw.d_maj, mfs_minor);
|
|
|
|
dev->si_devsw = &mfs_cdevsw;
|
1999-09-09 19:08:44 +00:00
|
|
|
/* It is not clear that these will get initialized otherwise */
|
1999-08-24 18:35:33 +00:00
|
|
|
dev->si_bsize_phys = DEV_BSIZE;
|
1999-09-20 19:57:28 +00:00
|
|
|
dev->si_iosize_max = DFLTPHYS;
|
2000-07-24 05:28:33 +00:00
|
|
|
devvp = addaliasu(devvp, makeudev(253, mfs_minor++));
|
1994-05-24 10:09:53 +00:00
|
|
|
devvp->v_data = mfsp;
|
|
|
|
mfsp->mfs_baseoff = args.base;
|
|
|
|
mfsp->mfs_size = args.size;
|
|
|
|
mfsp->mfs_vnode = devvp;
|
|
|
|
mfsp->mfs_pid = p->p_pid;
|
1996-04-08 07:54:51 +00:00
|
|
|
mfsp->mfs_active = 1;
|
1997-09-21 22:10:02 +00:00
|
|
|
bufq_init(&mfsp->buf_queue);
|
1995-08-28 09:19:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Since this is a new mount, we want the names for
|
|
|
|
* the device and the mount point copied in. If an
|
|
|
|
* error occurs, the mountpoint is discarded by the
|
|
|
|
* upper level code.
|
|
|
|
*/
|
|
|
|
/* Save "last mounted on" info for mount point (NULL pad)*/
|
|
|
|
copyinstr( path, /* mount point*/
|
|
|
|
mp->mnt_stat.f_mntonname, /* save area*/
|
|
|
|
MNAMELEN - 1, /* max size*/
|
|
|
|
&size); /* real size*/
|
|
|
|
bzero( mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
|
|
|
|
|
|
|
|
/* Save "mounted from" info for mount point (NULL pad)*/
|
|
|
|
copyinstr( args.fspec, /* device name*/
|
|
|
|
mp->mnt_stat.f_mntfromname, /* save area*/
|
|
|
|
MNAMELEN - 1, /* max size*/
|
|
|
|
&size); /* real size*/
|
|
|
|
bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
|
|
|
|
|
1999-01-28 00:57:57 +00:00
|
|
|
if ((err = ffs_mountfs(devvp, mp, p, M_MFSNODE)) != 0) {
|
1996-04-08 07:54:51 +00:00
|
|
|
mfsp->mfs_active = 0;
|
1995-08-28 09:19:25 +00:00
|
|
|
goto error_2;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-08-28 09:19:25 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize FS stat information in mount struct; uses both
|
|
|
|
* mp->mnt_stat.f_mntonname and mp->mnt_stat.f_mntfromname
|
|
|
|
*
|
|
|
|
* This code is common to root and non-root mounts
|
|
|
|
*/
|
|
|
|
(void) VFS_STATFS(mp, &mp->mnt_stat, p);
|
|
|
|
|
|
|
|
goto success;
|
|
|
|
|
|
|
|
error_2: /* error with devvp held*/
|
|
|
|
|
|
|
|
/* release devvp before failing*/
|
|
|
|
vrele(devvp);
|
|
|
|
|
|
|
|
error_1: /* no state to back out*/
|
|
|
|
|
|
|
|
success:
|
|
|
|
return( err);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
1995-08-28 09:19:25 +00:00
|
|
|
|
1995-12-17 21:14:36 +00:00
|
|
|
static int mfs_pri = PWAIT | PCATCH; /* XXX prob. temp */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Used to grab the process and keep it in the kernel to service
|
|
|
|
* memory filesystem I/O requests.
|
|
|
|
*
|
|
|
|
* Loop servicing I/O requests.
|
|
|
|
* Copy the requested data into or out of the memory filesystem
|
|
|
|
* address space.
|
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
1995-12-17 21:14:36 +00:00
|
|
|
static int
|
1994-05-24 10:09:53 +00:00
|
|
|
mfs_start(mp, flags, p)
|
|
|
|
struct mount *mp;
|
|
|
|
int flags;
|
|
|
|
struct proc *p;
|
|
|
|
{
|
|
|
|
register struct vnode *vp = VFSTOUFS(mp)->um_devvp;
|
|
|
|
register struct mfsnode *mfsp = VTOMFS(vp);
|
|
|
|
register struct buf *bp;
|
1999-09-29 15:03:48 +00:00
|
|
|
register int gotsig = 0, sig;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-01-01 04:14:11 +00:00
|
|
|
/*
|
1999-04-06 03:08:43 +00:00
|
|
|
* We must prevent the system from trying to swap
|
1999-03-12 00:44:03 +00:00
|
|
|
* out or kill ( when swap space is low, see vm/pageout.c ) the
|
|
|
|
* process. A deadlock can occur if the process is swapped out,
|
|
|
|
* and the system can loop trying to kill the unkillable ( while
|
|
|
|
* references exist ) MFS process when swap space is low.
|
1999-01-01 04:14:11 +00:00
|
|
|
*/
|
1999-04-06 03:08:43 +00:00
|
|
|
PHOLD(curproc);
|
1999-01-01 04:14:11 +00:00
|
|
|
|
1996-04-08 07:54:51 +00:00
|
|
|
while (mfsp->mfs_active) {
|
1999-01-21 08:29:12 +00:00
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splbio();
|
|
|
|
|
1999-01-28 00:57:57 +00:00
|
|
|
while ((bp = bufq_first(&mfsp->buf_queue)) != NULL) {
|
1997-09-21 22:10:02 +00:00
|
|
|
bufq_remove(&mfsp->buf_queue, bp);
|
1999-01-21 08:29:12 +00:00
|
|
|
splx(s);
|
|
|
|
mfs_doio(bp, mfsp);
|
1994-05-24 10:09:53 +00:00
|
|
|
wakeup((caddr_t)bp);
|
1999-01-21 08:29:12 +00:00
|
|
|
s = splbio();
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1999-01-21 08:29:12 +00:00
|
|
|
|
|
|
|
splx(s);
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* If a non-ignored signal is received, try to unmount.
|
|
|
|
* If that fails, clear the signal (it has been "processed"),
|
|
|
|
* otherwise we will loop here, as tsleep will always return
|
|
|
|
* EINTR/ERESTART.
|
|
|
|
*/
|
1995-11-28 02:15:29 +00:00
|
|
|
/*
|
|
|
|
* Note that dounmount() may fail if work was queued after
|
|
|
|
* we slept. We have to jump hoops here to make sure that we
|
|
|
|
* process any buffers after the sleep, before we dounmount()
|
|
|
|
*/
|
|
|
|
if (gotsig) {
|
|
|
|
gotsig = 0;
|
1999-09-29 15:03:48 +00:00
|
|
|
if (dounmount(mp, 0, p) != 0) {
|
|
|
|
sig = CURSIG(p);
|
|
|
|
if (sig)
|
|
|
|
SIGDELSET(p->p_siglist, sig);
|
|
|
|
}
|
1995-11-28 02:15:29 +00:00
|
|
|
}
|
|
|
|
else if (tsleep((caddr_t)vp, mfs_pri, "mfsidl", 0))
|
|
|
|
gotsig++; /* try to unmount in next pass */
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-08-20 10:26:00 +00:00
|
|
|
return (0);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get file system statistics.
|
|
|
|
*/
|
1995-12-17 21:14:36 +00:00
|
|
|
static int
|
1994-05-24 10:09:53 +00:00
|
|
|
mfs_statfs(mp, sbp, p)
|
|
|
|
struct mount *mp;
|
|
|
|
struct statfs *sbp;
|
|
|
|
struct proc *p;
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = ffs_statfs(mp, sbp, p);
|
1997-02-10 02:22:35 +00:00
|
|
|
sbp->f_type = mp->mnt_vfc->vfc_typenum;
|
1994-05-24 10:09:53 +00:00
|
|
|
return (error);
|
|
|
|
}
|
1995-12-17 21:14:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Memory based filesystem initialization.
|
|
|
|
*/
|
|
|
|
static int
|
1997-02-10 02:22:35 +00:00
|
|
|
mfs_init(vfsp)
|
|
|
|
struct vfsconf *vfsp;
|
1995-12-17 21:14:36 +00:00
|
|
|
{
|
1999-08-24 18:35:33 +00:00
|
|
|
|
1999-07-20 09:47:55 +00:00
|
|
|
cdevsw_add(&mfs_cdevsw);
|
1999-11-03 11:02:47 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|