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 (9 years 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: }
![[BACK]](/icons//back.gif){kind=icon}
Return to mfs_vfsops.c CVS log ![[TXT]](/icons//text.gif){kind=icon}
![[DIR]](/icons//dir.gif){kind=icon}
Up to [DragonFly] / src / sys / vfs / mfs