Home | History | Annotate | Line # | Download | only in mfs
mfs_vnops.c revision 1.61 
      1 /*	$NetBSD: mfs_vnops.c,v 1.61 2020/05/16 18:31:54 christos 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. Neither the name of the University nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  *
     31  *	@(#)mfs_vnops.c	8.11 (Berkeley) 5/22/95
     32  */
     33 
     34 #include <sys/cdefs.h>
     35 __KERNEL_RCSID(0, "$NetBSD: mfs_vnops.c,v 1.61 2020/05/16 18:31:54 christos Exp $");
     36 
     37 #include <sys/param.h>
     38 #include <sys/systm.h>
     39 #include <sys/time.h>
     40 #include <sys/kernel.h>
     41 #include <sys/proc.h>
     42 #include <sys/buf.h>
     43 #include <sys/bufq.h>
     44 #include <sys/vnode.h>
     45 #include <sys/kmem.h>
     46 
     47 #include <miscfs/genfs/genfs.h>
     48 #include <miscfs/specfs/specdev.h>
     49 
     50 #include <machine/vmparam.h>
     51 
     52 #include <ufs/mfs/mfsnode.h>
     53 #include <ufs/mfs/mfs_extern.h>
     54 
     55 /*
     56  * mfs vnode operations.
     57  */
     58 int (**mfs_vnodeop_p)(void *);
     59 const struct vnodeopv_entry_desc mfs_vnodeop_entries[] = {
     60 	{ &vop_default_desc, vn_default_error },
     61 	{ &vop_lookup_desc, mfs_lookup },		/* lookup */
     62 	{ &vop_create_desc, mfs_create },		/* create */
     63 	{ &vop_mknod_desc, mfs_mknod },			/* mknod */
     64 	{ &vop_open_desc, mfs_open },			/* open */
     65 	{ &vop_close_desc, mfs_close },			/* close */
     66 	{ &vop_access_desc, mfs_access },		/* access */
     67 	{ &vop_accessx_desc, genfs_accessx },		/* accessx */
     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_fallocate_desc, genfs_eopnotsupp },	/* fallocate */
     73 	{ &vop_fdiscard_desc, genfs_eopnotsupp },	/* fdiscard */
     74 	{ &vop_ioctl_desc, mfs_ioctl },			/* ioctl */
     75 	{ &vop_poll_desc, mfs_poll },			/* poll */
     76 	{ &vop_revoke_desc, mfs_revoke },		/* revoke */
     77 	{ &vop_mmap_desc, mfs_mmap },			/* mmap */
     78 	{ &vop_fsync_desc, spec_fsync },		/* fsync */
     79 	{ &vop_seek_desc, mfs_seek },			/* seek */
     80 	{ &vop_remove_desc, mfs_remove },		/* remove */
     81 	{ &vop_link_desc, mfs_link },			/* link */
     82 	{ &vop_rename_desc, mfs_rename },		/* rename */
     83 	{ &vop_mkdir_desc, mfs_mkdir },			/* mkdir */
     84 	{ &vop_rmdir_desc, mfs_rmdir },			/* rmdir */
     85 	{ &vop_symlink_desc, mfs_symlink },		/* symlink */
     86 	{ &vop_readdir_desc, mfs_readdir },		/* readdir */
     87 	{ &vop_readlink_desc, mfs_readlink },		/* readlink */
     88 	{ &vop_abortop_desc, mfs_abortop },		/* abortop */
     89 	{ &vop_inactive_desc, mfs_inactive },		/* inactive */
     90 	{ &vop_reclaim_desc, mfs_reclaim },		/* reclaim */
     91 	{ &vop_lock_desc, genfs_nolock },		/* lock */
     92 	{ &vop_unlock_desc, genfs_nounlock },		/* unlock */
     93 	{ &vop_bmap_desc, mfs_bmap },			/* bmap */
     94 	{ &vop_strategy_desc, mfs_strategy },		/* strategy */
     95 	{ &vop_print_desc, mfs_print },			/* print */
     96 	{ &vop_islocked_desc, mfs_islocked },		/* islocked */
     97 	{ &vop_pathconf_desc, mfs_pathconf },		/* pathconf */
     98 	{ &vop_advlock_desc, mfs_advlock },		/* advlock */
     99 	{ &vop_bwrite_desc, mfs_bwrite },		/* bwrite */
    100 	{ &vop_putpages_desc, mfs_putpages },		/* putpages */
    101 	{ NULL, NULL }
    102 };
    103 const struct vnodeopv_desc mfs_vnodeop_opv_desc =
    104 	{ &mfs_vnodeop_p, mfs_vnodeop_entries };
    105 
    106 /*
    107  * Vnode Operations.
    108  *
    109  * Open called to allow memory filesystem to initialize and
    110  * validate before actual IO. Record our process identifier
    111  * so we can tell when we are doing I/O to ourself.
    112  */
    113 /* ARGSUSED */
    114 int
    115 mfs_open(void *v)
    116 {
    117 	struct vop_open_args /* {
    118 		struct vnode *a_vp;
    119 		int  a_mode;
    120 		kauth_cred_t a_cred;
    121 	} */ *ap = v;
    122 
    123 	if (ap->a_vp->v_type != VBLK) {
    124 		panic("mfs_ioctl not VBLK");
    125 		/* NOTREACHED */
    126 	}
    127 	return (0);
    128 }
    129 
    130 /*
    131  * Pass I/O requests to the memory filesystem process.
    132  */
    133 int
    134 mfs_strategy(void *v)
    135 {
    136 	struct vop_strategy_args /* {
    137 		struct vnode *a_vp;
    138 		struct buf *a_bp;
    139 	} */ *ap = v;
    140 	struct vnode *vp = ap->a_vp;
    141 	struct buf *bp = ap->a_bp;
    142 	struct mfsnode *mfsp;
    143 
    144 	if (vp->v_type != VBLK || vrefcnt(vp) == 0)
    145 		panic("mfs_strategy: bad dev");
    146 	mfsp = VTOMFS(vp);
    147 	/* check for mini-root access */
    148 	if (mfsp->mfs_proc == NULL) {
    149 		void *base;
    150 
    151 		base = (char *)mfsp->mfs_baseoff + (bp->b_blkno << DEV_BSHIFT);
    152 		if (bp->b_flags & B_READ)
    153 			memcpy(bp->b_data, base, bp->b_bcount);
    154 		else
    155 			memcpy(base, bp->b_data, bp->b_bcount);
    156 		bp->b_resid = 0;
    157 		biodone(bp);
    158 	} else if (mfsp->mfs_proc == curproc) {
    159 		mfs_doio(bp, mfsp->mfs_baseoff);
    160 	} else if (doing_shutdown) {
    161 		/*
    162 		 * bitbucket I/O during shutdown.
    163 		 * Note that reads should *not* happen here, but..
    164 		 */
    165 		if (bp->b_flags & B_READ)
    166 			printf("warning: mfs read during shutdown\n");
    167 		bp->b_resid = 0;
    168 		biodone(bp);
    169 	} else {
    170 		mutex_enter(&mfs_lock);
    171 		bufq_put(mfsp->mfs_buflist, bp);
    172 		cv_broadcast(&mfsp->mfs_cv);
    173 		mutex_exit(&mfs_lock);
    174 	}
    175 	return (0);
    176 }
    177 
    178 /*
    179  * Memory file system I/O.
    180  */
    181 void
    182 mfs_doio(struct buf *bp, void *base)
    183 {
    184 
    185 	base = (char *)base + (bp->b_blkno << DEV_BSHIFT);
    186 	if (bp->b_flags & B_READ)
    187 		bp->b_error = copyin(base, bp->b_data, bp->b_bcount);
    188 	else
    189 		bp->b_error = copyout(bp->b_data, base, bp->b_bcount);
    190 	if (bp->b_error == 0)
    191 		bp->b_resid = 0;
    192 	biodone(bp);
    193 }
    194 
    195 /*
    196  * This is a noop, simply returning what one has been given.
    197  */
    198 int
    199 mfs_bmap(void *v)
    200 {
    201 	struct vop_bmap_args /* {
    202 		struct vnode *a_vp;
    203 		daddr_t  a_bn;
    204 		struct vnode **a_vpp;
    205 		daddr_t *a_bnp;
    206 		int *a_runp;
    207 	} */ *ap = v;
    208 
    209 	if (ap->a_vpp != NULL)
    210 		*ap->a_vpp = ap->a_vp;
    211 	if (ap->a_bnp != NULL)
    212 		*ap->a_bnp = ap->a_bn;
    213 	if (ap->a_runp != NULL)
    214 		 *ap->a_runp = 0;
    215 	return (0);
    216 }
    217 
    218 /*
    219  * Memory filesystem close routine
    220  */
    221 /* ARGSUSED */
    222 int
    223 mfs_close(void *v)
    224 {
    225 	struct vop_close_args /* {
    226 		struct vnode *a_vp;
    227 		int  a_fflag;
    228 		kauth_cred_t a_cred;
    229 	} */ *ap = v;
    230 	struct vnode *vp = ap->a_vp;
    231 	struct mfsnode *mfsp = VTOMFS(vp);
    232 	struct buf *bp;
    233 	int error;
    234 
    235 	/*
    236 	 * Finish any pending I/O requests.
    237 	 */
    238 	mutex_enter(&mfs_lock);
    239 	while ((bp = bufq_get(mfsp->mfs_buflist)) != NULL) {
    240 		mutex_exit(&mfs_lock);
    241 		mfs_doio(bp, mfsp->mfs_baseoff);
    242 		mutex_enter(&mfs_lock);
    243 	}
    244 	mutex_exit(&mfs_lock);
    245 	/*
    246 	 * On last close of a memory filesystem
    247 	 * we must invalidate any in core blocks, so that
    248 	 * we can, free up its vnode.
    249 	 */
    250 	if ((error = vinvalbuf(vp, V_SAVE, ap->a_cred, curlwp, 0, 0)) != 0)
    251 		return (error);
    252 	/*
    253 	 * There should be no way to have any more uses of this
    254 	 * vnode, so if we find any other uses, it is a panic.
    255 	 */
    256 	if (bufq_peek(mfsp->mfs_buflist) != NULL)
    257 		panic("mfs_close");
    258 	/*
    259 	 * Send a request to the filesystem server to exit.
    260 	 */
    261 	mutex_enter(&mfs_lock);
    262 	mfsp->mfs_shutdown = 1;
    263 	cv_broadcast(&mfsp->mfs_cv);
    264 	mutex_exit(&mfs_lock);
    265 	return (0);
    266 }
    267 
    268 /*
    269  * Memory filesystem inactive routine
    270  */
    271 /* ARGSUSED */
    272 int
    273 mfs_inactive(void *v)
    274 {
    275 	struct vop_inactive_v2_args /* {
    276 		struct vnode *a_vp;
    277 	} */ *ap = v;
    278 	struct vnode *vp = ap->a_vp;
    279 	struct mfsnode *mfsp = VTOMFS(vp);
    280 
    281 	if (bufq_peek(mfsp->mfs_buflist) != NULL)
    282 		panic("mfs_inactive: not inactive (mfs_buflist %p)",
    283 			bufq_peek(mfsp->mfs_buflist));
    284 
    285 	return VOCALL(spec_vnodeop_p,  VOFFSET(vop_inactive), ap);
    286 }
    287 
    288 /*
    289  * Reclaim a memory filesystem devvp so that it can be reused.
    290  */
    291 int
    292 mfs_reclaim(void *v)
    293 {
    294 	struct vop_reclaim_v2_args /* {
    295 		struct vnode *a_vp;
    296 	} */ *ap = v;
    297 	struct vnode *vp = ap->a_vp;
    298 	struct mfsnode *mfsp = VTOMFS(vp);
    299 	int refcnt;
    300 
    301 	mutex_enter(&mfs_lock);
    302 	vp->v_data = NULL;
    303 	refcnt = --mfsp->mfs_refcnt;
    304 	mutex_exit(&mfs_lock);
    305 
    306 	if (refcnt == 0) {
    307 		bufq_free(mfsp->mfs_buflist);
    308 		cv_destroy(&mfsp->mfs_cv);
    309 		kmem_free(mfsp, sizeof(*mfsp));
    310 	}
    311 
    312 	return VOCALL(spec_vnodeop_p,  VOFFSET(vop_reclaim), ap);
    313 }
    314 
    315 /*
    316  * Print out the contents of an mfsnode.
    317  */
    318 int
    319 mfs_print(void *v)
    320 {
    321 	struct vop_print_args /* {
    322 		struct vnode *a_vp;
    323 	} */ *ap = v;
    324 	struct mfsnode *mfsp = VTOMFS(ap->a_vp);
    325 
    326 	printf("tag VT_MFS, pid %d, base %p, size %ld\n",
    327 	    (mfsp->mfs_proc != NULL) ? mfsp->mfs_proc->p_pid : 0,
    328 	    mfsp->mfs_baseoff, mfsp->mfs_size);
    329 	return (0);
    330 }
    331