Home | History | Annotate | Line # | Download | only in mfs
mfs_vnops.c revision 1.3 
      1 /*	$NetBSD: mfs_vnops.c,v 1.3 1994/06/29 06:47:13 cgd Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1989, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *	This product includes software developed by the University of
     18  *	California, Berkeley and its contributors.
     19  * 4. Neither the name of the University nor the names of its contributors
     20  *    may be used to endorse or promote products derived from this software
     21  *    without specific prior written permission.
     22  *
     23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33  * SUCH DAMAGE.
     34  *
     35  *	@(#)mfs_vnops.c	8.3 (Berkeley) 9/21/93
     36  */
     37 
     38 #include <sys/param.h>
     39 #include <sys/systm.h>
     40 #include <sys/time.h>
     41 #include <sys/kernel.h>
     42 #include <sys/proc.h>
     43 #include <sys/buf.h>
     44 #include <sys/map.h>
     45 #include <sys/vnode.h>
     46 #include <sys/malloc.h>
     47 
     48 #include <miscfs/specfs/specdev.h>
     49 
     50 #include <machine/vmparam.h>
     51 
     52 #include <ufs/mfs/mfsnode.h>
     53 #include <ufs/mfs/mfsiom.h>
     54 #include <ufs/mfs/mfs_extern.h>
     55 
     56 /*
     57  * mfs vnode operations.
     58  */
     59 int (**mfs_vnodeop_p)();
     60 struct vnodeopv_entry_desc mfs_vnodeop_entries[] = {
     61 	{ &vop_default_desc, vn_default_error },
     62 	{ &vop_lookup_desc, mfs_lookup },		/* lookup */
     63 	{ &vop_create_desc, mfs_create },		/* create */
     64 	{ &vop_mknod_desc, mfs_mknod },			/* mknod */
     65 	{ &vop_open_desc, mfs_open },			/* open */
     66 	{ &vop_close_desc, mfs_close },			/* close */
     67 	{ &vop_access_desc, mfs_access },		/* access */
     68 	{ &vop_getattr_desc, mfs_getattr },		/* getattr */
     69 	{ &vop_setattr_desc, mfs_setattr },		/* setattr */
     70 	{ &vop_read_desc, mfs_read },			/* read */
     71 	{ &vop_write_desc, mfs_write },			/* write */
     72 	{ &vop_ioctl_desc, mfs_ioctl },			/* ioctl */
     73 	{ &vop_select_desc, mfs_select },		/* select */
     74 	{ &vop_mmap_desc, mfs_mmap },			/* mmap */
     75 	{ &vop_fsync_desc, spec_fsync },		/* fsync */
     76 	{ &vop_seek_desc, mfs_seek },			/* seek */
     77 	{ &vop_remove_desc, mfs_remove },		/* remove */
     78 	{ &vop_link_desc, mfs_link },			/* link */
     79 	{ &vop_rename_desc, mfs_rename },		/* rename */
     80 	{ &vop_mkdir_desc, mfs_mkdir },			/* mkdir */
     81 	{ &vop_rmdir_desc, mfs_rmdir },			/* rmdir */
     82 	{ &vop_symlink_desc, mfs_symlink },		/* symlink */
     83 	{ &vop_readdir_desc, mfs_readdir },		/* readdir */
     84 	{ &vop_readlink_desc, mfs_readlink },		/* readlink */
     85 	{ &vop_abortop_desc, mfs_abortop },		/* abortop */
     86 	{ &vop_inactive_desc, mfs_inactive },		/* inactive */
     87 	{ &vop_reclaim_desc, mfs_reclaim },		/* reclaim */
     88 	{ &vop_lock_desc, mfs_lock },			/* lock */
     89 	{ &vop_unlock_desc, mfs_unlock },		/* unlock */
     90 	{ &vop_bmap_desc, mfs_bmap },			/* bmap */
     91 	{ &vop_strategy_desc, mfs_strategy },		/* strategy */
     92 	{ &vop_print_desc, mfs_print },			/* print */
     93 	{ &vop_islocked_desc, mfs_islocked },		/* islocked */
     94 	{ &vop_pathconf_desc, mfs_pathconf },		/* pathconf */
     95 	{ &vop_advlock_desc, mfs_advlock },		/* advlock */
     96 	{ &vop_blkatoff_desc, mfs_blkatoff },		/* blkatoff */
     97 	{ &vop_valloc_desc, mfs_valloc },		/* valloc */
     98 	{ &vop_vfree_desc, mfs_vfree },			/* vfree */
     99 	{ &vop_truncate_desc, mfs_truncate },		/* truncate */
    100 	{ &vop_update_desc, mfs_update },		/* update */
    101 	{ &vop_bwrite_desc, mfs_bwrite },		/* bwrite */
    102 	{ (struct vnodeop_desc*)NULL, (int(*)())NULL }
    103 };
    104 struct vnodeopv_desc mfs_vnodeop_opv_desc =
    105 	{ &mfs_vnodeop_p, mfs_vnodeop_entries };
    106 
    107 /*
    108  * Vnode Operations.
    109  *
    110  * Open called to allow memory filesystem to initialize and
    111  * validate before actual IO. Record our process identifier
    112  * so we can tell when we are doing I/O to ourself.
    113  */
    114 /* ARGSUSED */
    115 int
    116 mfs_open(ap)
    117 	struct vop_open_args /* {
    118 		struct vnode *a_vp;
    119 		int  a_mode;
    120 		struct ucred *a_cred;
    121 		struct proc *a_p;
    122 	} */ *ap;
    123 {
    124 
    125 	if (ap->a_vp->v_type != VBLK) {
    126 		panic("mfs_ioctl not VBLK");
    127 		/* NOTREACHED */
    128 	}
    129 	return (0);
    130 }
    131 
    132 /*
    133  * Ioctl operation.
    134  */
    135 /* ARGSUSED */
    136 int
    137 mfs_ioctl(ap)
    138 	struct vop_ioctl_args /* {
    139 		struct vnode *a_vp;
    140 		int  a_command;
    141 		caddr_t  a_data;
    142 		int  a_fflag;
    143 		struct ucred *a_cred;
    144 		struct proc *a_p;
    145 	} */ *ap;
    146 {
    147 
    148 	return (ENOTTY);
    149 }
    150 
    151 /*
    152  * Pass I/O requests to the memory filesystem process.
    153  */
    154 int
    155 mfs_strategy(ap)
    156 	struct vop_strategy_args /* {
    157 		struct buf *a_bp;
    158 	} */ *ap;
    159 {
    160 	register struct buf *bp = ap->a_bp;
    161 	register struct mfsnode *mfsp;
    162 	struct vnode *vp;
    163 	struct proc *p = curproc;		/* XXX */
    164 
    165 	if (!vfinddev(bp->b_dev, VBLK, &vp) || vp->v_usecount == 0)
    166 		panic("mfs_strategy: bad dev");
    167 	mfsp = VTOMFS(vp);
    168 	/* check for mini-root access */
    169 	if (mfsp->mfs_pid == 0) {
    170 		caddr_t base;
    171 
    172 		base = mfsp->mfs_baseoff + (bp->b_blkno << DEV_BSHIFT);
    173 		if (bp->b_flags & B_READ)
    174 			bcopy(base, bp->b_data, bp->b_bcount);
    175 		else
    176 			bcopy(bp->b_data, base, bp->b_bcount);
    177 		biodone(bp);
    178 	} else if (mfsp->mfs_pid == p->p_pid) {
    179 		mfs_doio(bp, mfsp->mfs_baseoff);
    180 	} else {
    181 		bp->b_actf = mfsp->mfs_buflist;
    182 		mfsp->mfs_buflist = bp;
    183 		wakeup((caddr_t)vp);
    184 	}
    185 	return (0);
    186 }
    187 
    188 /*
    189  * Memory file system I/O.
    190  *
    191  * Trivial on the HP since buffer has already been mapping into KVA space.
    192  */
    193 void
    194 mfs_doio(bp, base)
    195 	register struct buf *bp;
    196 	caddr_t base;
    197 {
    198 
    199 	base += (bp->b_blkno << DEV_BSHIFT);
    200 	if (bp->b_flags & B_READ)
    201 		bp->b_error = copyin(base, bp->b_data, bp->b_bcount);
    202 	else
    203 		bp->b_error = copyout(bp->b_data, base, bp->b_bcount);
    204 	if (bp->b_error)
    205 		bp->b_flags |= B_ERROR;
    206 	biodone(bp);
    207 }
    208 
    209 /*
    210  * This is a noop, simply returning what one has been given.
    211  */
    212 int
    213 mfs_bmap(ap)
    214 	struct vop_bmap_args /* {
    215 		struct vnode *a_vp;
    216 		daddr_t  a_bn;
    217 		struct vnode **a_vpp;
    218 		daddr_t *a_bnp;
    219 		int *a_runp;
    220 	} */ *ap;
    221 {
    222 
    223 	if (ap->a_vpp != NULL)
    224 		*ap->a_vpp = ap->a_vp;
    225 	if (ap->a_bnp != NULL)
    226 		*ap->a_bnp = ap->a_bn;
    227 	return (0);
    228 }
    229 
    230 /*
    231  * Memory filesystem close routine
    232  */
    233 /* ARGSUSED */
    234 int
    235 mfs_close(ap)
    236 	struct vop_close_args /* {
    237 		struct vnode *a_vp;
    238 		int  a_fflag;
    239 		struct ucred *a_cred;
    240 		struct proc *a_p;
    241 	} */ *ap;
    242 {
    243 	register struct vnode *vp = ap->a_vp;
    244 	register struct mfsnode *mfsp = VTOMFS(vp);
    245 	register struct buf *bp;
    246 	int error;
    247 
    248 	/*
    249 	 * Finish any pending I/O requests.
    250 	 */
    251 	while (bp = mfsp->mfs_buflist) {
    252 		mfsp->mfs_buflist = bp->b_actf;
    253 		mfs_doio(bp, mfsp->mfs_baseoff);
    254 		wakeup((caddr_t)bp);
    255 	}
    256 	/*
    257 	 * On last close of a memory filesystem
    258 	 * we must invalidate any in core blocks, so that
    259 	 * we can, free up its vnode.
    260 	 */
    261 	if (error = vinvalbuf(vp, 1, ap->a_cred, ap->a_p, 0, 0))
    262 		return (error);
    263 	/*
    264 	 * There should be no way to have any more uses of this
    265 	 * vnode, so if we find any other uses, it is a panic.
    266 	 */
    267 	if (vp->v_usecount > 1)
    268 		printf("mfs_close: ref count %d > 1\n", vp->v_usecount);
    269 	if (vp->v_usecount > 1 || mfsp->mfs_buflist)
    270 		panic("mfs_close");
    271 	/*
    272 	 * Send a request to the filesystem server to exit.
    273 	 */
    274 	mfsp->mfs_buflist = (struct buf *)(-1);
    275 	wakeup((caddr_t)vp);
    276 	return (0);
    277 }
    278 
    279 /*
    280  * Memory filesystem inactive routine
    281  */
    282 /* ARGSUSED */
    283 int
    284 mfs_inactive(ap)
    285 	struct vop_inactive_args /* {
    286 		struct vnode *a_vp;
    287 	} */ *ap;
    288 {
    289 	register struct mfsnode *mfsp = VTOMFS(ap->a_vp);
    290 
    291 	if (mfsp->mfs_buflist && mfsp->mfs_buflist != (struct buf *)(-1))
    292 		panic("mfs_inactive: not inactive (mfs_buflist %x)",
    293 			mfsp->mfs_buflist);
    294 	return (0);
    295 }
    296 
    297 /*
    298  * Reclaim a memory filesystem devvp so that it can be reused.
    299  */
    300 int
    301 mfs_reclaim(ap)
    302 	struct vop_reclaim_args /* {
    303 		struct vnode *a_vp;
    304 	} */ *ap;
    305 {
    306 	register struct vnode *vp = ap->a_vp;
    307 #if 0 /* XXX */
    308 	int error;
    309 
    310 	error = ufs_reclaim(vp);
    311 	if (error)
    312 		return (error);
    313 #endif
    314 	FREE(vp->v_data, M_MFSNODE);
    315 	vp->v_data = NULL;
    316 	return (0);
    317 }
    318 
    319 /*
    320  * Print out the contents of an mfsnode.
    321  */
    322 int
    323 mfs_print(ap)
    324 	struct vop_print_args /* {
    325 		struct vnode *a_vp;
    326 	} */ *ap;
    327 {
    328 	register struct mfsnode *mfsp = VTOMFS(ap->a_vp);
    329 
    330 	printf("tag VT_MFS, pid %d, base %d, size %d\n", mfsp->mfs_pid,
    331 		mfsp->mfs_baseoff, mfsp->mfs_size);
    332 	return (0);
    333 }
    334 
    335 /*
    336  * Block device bad operation
    337  */
    338 int
    339 mfs_badop()
    340 {
    341 
    342 	panic("mfs_badop called\n");
    343 	/* NOTREACHED */
    344 }
    345 
    346 /*
    347  * Memory based filesystem initialization.
    348  */
    349 mfs_init()
    350 {
    351 
    352 }
    353