File:  [DragonFly] / src / sys / vfs / mfs / mfs_vfsops.c
Revision 1.14: download - view: text, annotated - select for diffs
Thu May 13 23:49:26 2004 UTC (10 years, 2 months ago) by dillon
Branches: MAIN
CVS tags: HEAD
device switch 1/many: Remove d_autoq, add d_clone (where d_autoq was).

d_autoq was used to allow the device port dispatch to mix old-style synchronous
calls with new style messaging calls within a particular device.  It was never
used for that purpose.

d_clone will be more fully implemented as work continues.  We are going to
install d_port in the dev_t (struct specinfo) structure itself and d_clone
will be needed to allow devices to 'revector' the port on a minor-number
by minor-number basis, in particular allowing minor numbers to be directly
dispatched to distinct threads.  This is something we will be needing later
on.

    1: /*
    2:  * Copyright (c) 1989, 1990, 1993, 1994
    3:  *	The Regents of the University of California.  All rights reserved.
    4:  *
    5:  * Redistribution and use in source and binary forms, with or without
    6:  * modification, are permitted provided that the following conditions
    7:  * are met:
    8:  * 1. Redistributions of source code must retain the above copyright
    9:  *    notice, this list of conditions and the following disclaimer.
   10:  * 2. Redistributions in binary form must reproduce the above copyright
   11:  *    notice, this list of conditions and the following disclaimer in the
   12:  *    documentation and/or other materials provided with the distribution.
   13:  * 3. All advertising materials mentioning features or use of this software
   14:  *    must display the following acknowledgement:
   15:  *	This product includes software developed by the University of
   16:  *	California, Berkeley and its contributors.
   17:  * 4. Neither the name of the University nor the names of its contributors
   18:  *    may be used to endorse or promote products derived from this software
   19:  *    without specific prior written permission.
   20:  *
   21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   31:  * SUCH DAMAGE.
   32:  *
   33:  *	@(#)mfs_vfsops.c	8.11 (Berkeley) 6/19/95
   34:  * $FreeBSD: src/sys/ufs/mfs/mfs_vfsops.c,v 1.81.2.3 2001/07/04 17:35:21 tegge Exp $
   35:  * $DragonFly: src/sys/vfs/mfs/mfs_vfsops.c,v 1.14 2004/05/13 23:49:26 dillon Exp $
   36:  */
   37: 
   38: 
   39: #include "opt_mfs.h"
   40: 
   41: #include <sys/param.h>
   42: #include <sys/systm.h>
   43: #include <sys/conf.h>
   44: #include <sys/kernel.h>
   45: #include <sys/proc.h>
   46: #include <sys/buf.h>
   47: #include <sys/mount.h>
   48: #include <sys/signalvar.h>
   49: #include <sys/vnode.h>
   50: #include <sys/malloc.h>
   51: #include <sys/linker.h>
   52: 
   53: #include <sys/buf2.h>
   54: 
   55: #include <vfs/ufs/quota.h>
   56: #include <vfs/ufs/inode.h>
   57: #include <vfs/ufs/ufsmount.h>
   58: #include <vfs/ufs/ufs_extern.h>
   59: #include <vfs/ufs/fs.h>
   60: #include <vfs/ufs/ffs_extern.h>
   61: 
   62: #include "mfsnode.h"
   63: #include "mfs_extern.h"
   64: 
   65: MALLOC_DEFINE(M_MFSNODE, "MFS node", "MFS vnode private part");
   66: 
   67: 
   68: static int mfs_minor;		/* used for building internal dev_t */
   69: 
   70: extern vop_t **mfs_vnodeop_p;
   71: 
   72: static int	mfs_mount (struct mount *mp,
   73: 			char *path, caddr_t data, struct nameidata *ndp, 
   74: 			struct thread *td);
   75: static int	mfs_start (struct mount *mp, int flags, struct thread *td);
   76: static int	mfs_statfs (struct mount *mp, struct statfs *sbp, 
   77: 			struct thread *td);
   78: static int	mfs_init (struct vfsconf *);
   79: 
   80: #define MFS_CDEV_MAJOR	253
   81: 
   82: static struct cdevsw mfs_cdevsw = {
   83: 	/* name */      "MFS",
   84: 	/* maj */       MFS_CDEV_MAJOR,
   85: 	/* flags */     D_DISK,
   86: 	/* port */	NULL,
   87: 	/* clone */	NULL,
   88: 
   89: 	/* open */      noopen,
   90: 	/* close */     noclose,
   91: 	/* read */      physread,
   92: 	/* write */     physwrite,
   93: 	/* ioctl */     noioctl,
   94: 	/* poll */      nopoll,
   95: 	/* mmap */      nommap,
   96: 	/* strategy */  nostrategy,
   97: 	/* dump */      nodump,
   98: 	/* psize */     nopsize
   99: };
  100: 
  101: /*
  102:  * mfs vfs operations.
  103:  */
  104: static struct vfsops mfs_vfsops = {
  105: 	mfs_mount,
  106: 	mfs_start,
  107: 	ffs_unmount,
  108: 	ufs_root,
  109: 	ufs_quotactl,
  110: 	mfs_statfs,
  111: 	ffs_sync,
  112: 	ffs_vget,
  113: 	ffs_fhtovp,
  114: 	ufs_check_export,
  115: 	ffs_vptofh,
  116: 	mfs_init,
  117: 	vfs_stduninit,
  118: 	vfs_stdextattrctl,
  119: };
  120: 
  121: VFS_SET(mfs_vfsops, mfs, 0);
  122: 
  123: 
  124: /*
  125:  * mfs_mount
  126:  *
  127:  * Called when mounting local physical media
  128:  *
  129:  * PARAMETERS:
  130:  *		mountroot
  131:  *			mp	mount point structure
  132:  *			path	NULL (flag for root mount!!!)
  133:  *			data	<unused>
  134:  *			ndp	<unused>
  135:  *			p	process (user credentials check [statfs])
  136:  *
  137:  *		mount
  138:  *			mp	mount point structure
  139:  *			path	path to mount point
  140:  *			data	pointer to argument struct in user space
  141:  *			ndp	mount point namei() return (used for
  142:  *				credentials on reload), reused to look
  143:  *				up block device.
  144:  *			p	process (user credentials check)
  145:  *
  146:  * RETURNS:	0	Success
  147:  *		!0	error number (errno.h)
  148:  *
  149:  * LOCK STATE:
  150:  *
  151:  *		ENTRY
  152:  *			mount point is locked
  153:  *		EXIT
  154:  *			mount point is locked
  155:  *
  156:  * NOTES:
  157:  *		A NULL path can be used for a flag since the mount
  158:  *		system call will fail with EFAULT in copyinstr in
  159:  *		namei() if it is a genuine NULL from the user.
  160:  */
  161: /* ARGSUSED */
  162: static int
  163: mfs_mount(struct mount *mp, char *path, caddr_t data, struct nameidata *ndp,
  164: 	  struct thread *td)
  165: {
  166: 	struct vnode *devvp;
  167: 	struct mfs_args args;
  168: 	struct ufsmount *ump;
  169: 	struct fs *fs;
  170: 	struct mfsnode *mfsp;
  171: 	size_t size;
  172: 	int flags, err;
  173: 	dev_t dev;
  174: 
  175: 	/*
  176: 	 * Use NULL path to flag a root mount
  177: 	 */
  178: 	if( path == NULL) {
  179: 		/*
  180: 		 ***
  181: 		 * Mounting root file system
  182: 		 ***
  183: 		 */
  184: 
  185: 		/* you lose */
  186: 		panic("mfs_mount: mount MFS as root: not configured!");
  187: 	}
  188: 
  189: 	/*
  190: 	 ***
  191: 	 * Mounting non-root file system or updating a file system
  192: 	 ***
  193: 	 */
  194: 
  195: 	/* copy in user arguments*/
  196: 	if ((err = copyin(data, (caddr_t)&args, sizeof (struct mfs_args))) != 0)
  197: 		goto error_1;
  198: 
  199: 	/*
  200: 	 * If updating, check whether changing from read-only to
  201: 	 * read/write; if there is no device name, that's all we do.
  202: 	 */
  203: 	if (mp->mnt_flag & MNT_UPDATE) {
  204: 		/*
  205: 		 ********************
  206: 		 * UPDATE
  207: 		 ********************
  208: 		 */
  209: 		ump = VFSTOUFS(mp);
  210: 		fs = ump->um_fs;
  211: 		if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
  212: 			flags = WRITECLOSE;
  213: 			if (mp->mnt_flag & MNT_FORCE)
  214: 				flags |= FORCECLOSE;
  215: 			err = ffs_flushfiles(mp, flags, td);
  216: 			if (err)
  217: 				goto error_1;
  218: 		}
  219: 		if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR))
  220: 			fs->fs_ronly = 0;
  221: 		/* if not updating name...*/
  222: 		if (args.fspec == 0) {
  223: 			/*
  224: 			 * Process export requests.  Jumping to "success"
  225: 			 * will return the vfs_export() error code. 
  226: 			 */
  227: 			err = vfs_export(mp, &ump->um_export, &args.export);
  228: 			goto success;
  229: 		}
  230: 
  231: 		/* XXX MFS does not support name updating*/
  232: 		goto success;
  233: 	}
  234: 	/*
  235: 	 * Do the MALLOC before the getnewvnode since doing so afterward
  236: 	 * might cause a bogus v_data pointer to get dereferenced
  237: 	 * elsewhere if MALLOC should block.
  238: 	 */
  239: 	MALLOC(mfsp, struct mfsnode *, sizeof *mfsp, M_MFSNODE, M_WAITOK);
  240: 
  241: 	err = getnewvnode(VT_MFS, (struct mount *)0, mfs_vnodeop_p, &devvp);
  242: 	if (err) {
  243: 		FREE(mfsp, M_MFSNODE);
  244: 		goto error_1;
  245: 	}
  246: 	devvp->v_type = VCHR;
  247: 	dev = make_dev(&mfs_cdevsw, mfs_minor, 0, 0, 0, "MFS%d", mfs_minor);
  248: 	/* It is not clear that these will get initialized otherwise */
  249: 	dev->si_bsize_phys = DEV_BSIZE;
  250: 	dev->si_iosize_max = DFLTPHYS;
  251: 	addaliasu(devvp, makeudev(253, mfs_minor++));
  252: 	devvp->v_data = mfsp;
  253: 	mfsp->mfs_baseoff = args.base;
  254: 	mfsp->mfs_size = args.size;
  255: 	mfsp->mfs_vnode = devvp;
  256: 	mfsp->mfs_td = td;
  257: 	mfsp->mfs_active = 1;
  258: 	bufq_init(&mfsp->buf_queue);
  259: 
  260: 	/*
  261: 	 * Since this is a new mount, we want the names for
  262: 	 * the device and the mount point copied in.  If an
  263: 	 * error occurs,  the mountpoint is discarded by the
  264: 	 * upper level code.
  265: 	 */
  266: 	/* Save "last mounted on" info for mount point (NULL pad)*/
  267: 	copyinstr(	path,				/* mount point*/
  268: 			mp->mnt_stat.f_mntonname,	/* save area*/
  269: 			MNAMELEN - 1,			/* max size*/
  270: 			&size);				/* real size*/
  271: 	bzero( mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
  272: 
  273: 	/* Save "mounted from" info for mount point (NULL pad)*/
  274: 	copyinstr(	args.fspec,			/* device name*/
  275: 			mp->mnt_stat.f_mntfromname,	/* save area*/
  276: 			MNAMELEN - 1,			/* max size*/
  277: 			&size);				/* real size*/
  278: 	bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
  279: 
  280: 	if ((err = ffs_mountfs(devvp, mp, td, M_MFSNODE)) != 0) { 
  281: 		mfsp->mfs_active = 0;
  282: 		goto error_2;
  283: 	}
  284: 
  285: 	/*
  286: 	 * Initialize FS stat information in mount struct; uses both
  287: 	 * mp->mnt_stat.f_mntonname and mp->mnt_stat.f_mntfromname
  288: 	 *
  289: 	 * This code is common to root and non-root mounts
  290: 	 */
  291: 	(void) VFS_STATFS(mp, &mp->mnt_stat, td);
  292: 
  293: 	goto success;
  294: 
  295: error_2:	/* error with devvp held*/
  296: 
  297: 	/* release devvp before failing*/
  298: 	vrele(devvp);
  299: 
  300: error_1:	/* no state to back out*/
  301: 
  302: success:
  303: 	return( err);
  304: }
  305: 
  306: /*
  307:  * Used to grab the process and keep it in the kernel to service
  308:  * memory filesystem I/O requests.
  309:  *
  310:  * Loop servicing I/O requests.
  311:  * Copy the requested data into or out of the memory filesystem
  312:  * address space.
  313:  */
  314: /* ARGSUSED */
  315: static int
  316: mfs_start(struct mount *mp, int flags, struct thread *td)
  317: {
  318: 	struct vnode *vp = VFSTOUFS(mp)->um_devvp;
  319: 	struct mfsnode *mfsp = VTOMFS(vp);
  320: 	struct buf *bp;
  321: 	int gotsig = 0, sig;
  322: 
  323: 	/*
  324: 	 * We must prevent the system from trying to swap
  325: 	 * out or kill ( when swap space is low, see vm/pageout.c ) the
  326: 	 * process.  A deadlock can occur if the process is swapped out,
  327: 	 * and the system can loop trying to kill the unkillable ( while
  328: 	 * references exist ) MFS process when swap space is low.
  329: 	 */
  330: 	KKASSERT(curproc);
  331: 	PHOLD(curproc);
  332: 
  333: 	while (mfsp->mfs_active) {
  334: 		int s;
  335: 
  336: 		s = splbio();
  337: 
  338: 		while ((bp = bufq_first(&mfsp->buf_queue)) != NULL) {
  339: 			bufq_remove(&mfsp->buf_queue, bp);
  340: 			splx(s);
  341: 			mfs_doio(bp, mfsp);
  342: 			wakeup((caddr_t)bp);
  343: 			s = splbio();
  344: 		}
  345: 
  346: 		splx(s);
  347: 
  348: 		/*
  349: 		 * If a non-ignored signal is received, try to unmount.
  350: 		 * If that fails, clear the signal (it has been "processed"),
  351: 		 * otherwise we will loop here, as tsleep will always return
  352: 		 * EINTR/ERESTART.
  353: 		 */
  354: 		/*
  355: 		 * Note that dounmount() may fail if work was queued after
  356: 		 * we slept. We have to jump hoops here to make sure that we
  357: 		 * process any buffers after the sleep, before we dounmount()
  358: 		 */
  359: 		if (gotsig) {
  360: 			gotsig = 0;
  361: 			if (dounmount(mp, 0, td) != 0) {
  362: 				KKASSERT(td->td_proc);
  363: 				sig = CURSIG(td->td_proc);
  364: 				if (sig)
  365: 					SIGDELSET(td->td_proc->p_siglist, sig);
  366: 			}
  367: 		}
  368: 		else if (tsleep((caddr_t)vp, PCATCH, "mfsidl", 0))
  369: 			gotsig++;	/* try to unmount in next pass */
  370: 	}
  371: 	PRELE(curproc);
  372: 	return (0);
  373: }
  374: 
  375: /*
  376:  * Get file system statistics.
  377:  */
  378: static int
  379: mfs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td)
  380: {
  381: 	int error;
  382: 
  383: 	error = ffs_statfs(mp, sbp, td);
  384: 	sbp->f_type = mp->mnt_vfc->vfc_typenum;
  385: 	return (error);
  386: }
  387: 
  388: /*
  389:  * Memory based filesystem initialization.
  390:  */
  391: static int
  392: mfs_init(struct vfsconf *vfsp)
  393: {
  394: 	cdevsw_add(&mfs_cdevsw);
  395: 	return (0);
  396: }