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