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