proc->thread stage 4: rework the VFS and DEVICE subsystems to take thread
[dragonfly.git] / sys / vfs / mfs / mfs_vfsops.c
CommitLineData
984263bc
MD
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 $
dadab5e9 35 * $DragonFly: src/sys/vfs/mfs/mfs_vfsops.c,v 1.4 2003/06/25 03:56:12 dillon Exp $
984263bc
MD
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
3020e3be
MD
53#include <sys/buf2.h>
54
984263bc
MD
55#include <ufs/ufs/quota.h>
56#include <ufs/ufs/inode.h>
57#include <ufs/ufs/ufsmount.h>
58#include <ufs/ufs/ufs_extern.h>
59
60#include <ufs/ffs/fs.h>
61#include <ufs/ffs/ffs_extern.h>
62
63#include <ufs/mfs/mfsnode.h>
64#include <ufs/mfs/mfs_extern.h>
65
66MALLOC_DEFINE(M_MFSNODE, "MFS node", "MFS vnode private part");
67
68
69static int mfs_minor; /* used for building internal dev_t */
70
71extern vop_t **mfs_vnodeop_p;
72
73static int mfs_mount __P((struct mount *mp,
74 char *path, caddr_t data, struct nameidata *ndp,
dadab5e9
MD
75 struct thread *td));
76static int mfs_start __P((struct mount *mp, int flags, struct thread *td));
984263bc 77static int mfs_statfs __P((struct mount *mp, struct statfs *sbp,
dadab5e9 78 struct thread *td));
984263bc
MD
79static int mfs_init __P((struct vfsconf *));
80
81static struct cdevsw mfs_cdevsw = {
82 /* open */ noopen,
83 /* close */ noclose,
84 /* read */ physread,
85 /* write */ physwrite,
86 /* ioctl */ noioctl,
87 /* poll */ nopoll,
88 /* mmap */ nommap,
89 /* strategy */ nostrategy,
90 /* name */ "MFS",
91 /* maj */ 253,
92 /* dump */ nodump,
93 /* psize */ nopsize,
94 /* flags */ D_DISK,
95 /* bmaj */ 253,
96};
97
98/*
99 * mfs vfs operations.
100 */
101static struct vfsops mfs_vfsops = {
102 mfs_mount,
103 mfs_start,
104 ffs_unmount,
105 ufs_root,
106 ufs_quotactl,
107 mfs_statfs,
108 ffs_sync,
109 ffs_vget,
110 ffs_fhtovp,
111 ufs_check_export,
112 ffs_vptofh,
113 mfs_init,
114 vfs_stduninit,
115 vfs_stdextattrctl,
116};
117
118VFS_SET(mfs_vfsops, mfs, 0);
119
120
121/*
122 * mfs_mount
123 *
124 * Called when mounting local physical media
125 *
126 * PARAMETERS:
127 * mountroot
128 * mp mount point structure
129 * path NULL (flag for root mount!!!)
130 * data <unused>
131 * ndp <unused>
132 * p process (user credentials check [statfs])
133 *
134 * mount
135 * mp mount point structure
136 * path path to mount point
137 * data pointer to argument struct in user space
138 * ndp mount point namei() return (used for
139 * credentials on reload), reused to look
140 * up block device.
141 * p process (user credentials check)
142 *
143 * RETURNS: 0 Success
144 * !0 error number (errno.h)
145 *
146 * LOCK STATE:
147 *
148 * ENTRY
149 * mount point is locked
150 * EXIT
151 * mount point is locked
152 *
153 * NOTES:
154 * A NULL path can be used for a flag since the mount
155 * system call will fail with EFAULT in copyinstr in
156 * namei() if it is a genuine NULL from the user.
157 */
158/* ARGSUSED */
159static int
dadab5e9 160mfs_mount(mp, path, data, ndp, td)
984263bc
MD
161 register struct mount *mp;
162 char *path;
163 caddr_t data;
164 struct nameidata *ndp;
dadab5e9 165 struct thread *td;
984263bc
MD
166{
167 struct vnode *devvp;
168 struct mfs_args args;
169 struct ufsmount *ump;
170 struct fs *fs;
171 struct mfsnode *mfsp;
172 size_t size;
173 int flags, err;
174 dev_t dev;
175
176 /*
177 * Use NULL path to flag a root mount
178 */
179 if( path == NULL) {
180 /*
181 ***
182 * Mounting root file system
183 ***
184 */
185
186 /* you lose */
187 panic("mfs_mount: mount MFS as root: not configured!");
188 }
189
190 /*
191 ***
192 * Mounting non-root file system or updating a file system
193 ***
194 */
195
196 /* copy in user arguments*/
197 if ((err = copyin(data, (caddr_t)&args, sizeof (struct mfs_args))) != 0)
198 goto error_1;
199
200 /*
201 * If updating, check whether changing from read-only to
202 * read/write; if there is no device name, that's all we do.
203 */
204 if (mp->mnt_flag & MNT_UPDATE) {
205 /*
206 ********************
207 * UPDATE
208 ********************
209 */
210 ump = VFSTOUFS(mp);
211 fs = ump->um_fs;
212 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
213 flags = WRITECLOSE;
214 if (mp->mnt_flag & MNT_FORCE)
215 flags |= FORCECLOSE;
dadab5e9 216 err = ffs_flushfiles(mp, flags, td);
984263bc
MD
217 if (err)
218 goto error_1;
219 }
220 if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR))
221 fs->fs_ronly = 0;
222 /* if not updating name...*/
223 if (args.fspec == 0) {
224 /*
225 * Process export requests. Jumping to "success"
226 * will return the vfs_export() error code.
227 */
228 err = vfs_export(mp, &ump->um_export, &args.export);
229 goto success;
230 }
231
232 /* XXX MFS does not support name updating*/
233 goto success;
234 }
235 /*
236 * Do the MALLOC before the getnewvnode since doing so afterward
237 * might cause a bogus v_data pointer to get dereferenced
238 * elsewhere if MALLOC should block.
239 */
240 MALLOC(mfsp, struct mfsnode *, sizeof *mfsp, M_MFSNODE, M_WAITOK);
241
242 err = getnewvnode(VT_MFS, (struct mount *)0, mfs_vnodeop_p, &devvp);
243 if (err) {
244 FREE(mfsp, M_MFSNODE);
245 goto error_1;
246 }
247 devvp->v_type = VBLK;
248 dev = make_dev(&mfs_cdevsw, mfs_minor, 0, 0, 0, "MFS%d", mfs_minor);
249 /* It is not clear that these will get initialized otherwise */
250 dev->si_bsize_phys = DEV_BSIZE;
251 dev->si_iosize_max = DFLTPHYS;
252 addaliasu(devvp, makeudev(253, mfs_minor++));
253 devvp->v_data = mfsp;
254 mfsp->mfs_baseoff = args.base;
255 mfsp->mfs_size = args.size;
256 mfsp->mfs_vnode = devvp;
dadab5e9 257 mfsp->mfs_td = td;
984263bc
MD
258 mfsp->mfs_active = 1;
259 bufq_init(&mfsp->buf_queue);
260
261 /*
262 * Since this is a new mount, we want the names for
263 * the device and the mount point copied in. If an
264 * error occurs, the mountpoint is discarded by the
265 * upper level code.
266 */
267 /* Save "last mounted on" info for mount point (NULL pad)*/
268 copyinstr( path, /* mount point*/
269 mp->mnt_stat.f_mntonname, /* save area*/
270 MNAMELEN - 1, /* max size*/
271 &size); /* real size*/
272 bzero( mp->mnt_stat.f_mntonname + size, MNAMELEN - size);
273
274 /* Save "mounted from" info for mount point (NULL pad)*/
275 copyinstr( args.fspec, /* device name*/
276 mp->mnt_stat.f_mntfromname, /* save area*/
277 MNAMELEN - 1, /* max size*/
278 &size); /* real size*/
279 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
280
dadab5e9 281 if ((err = ffs_mountfs(devvp, mp, td, M_MFSNODE)) != 0) {
984263bc
MD
282 mfsp->mfs_active = 0;
283 goto error_2;
284 }
285
286 /*
287 * Initialize FS stat information in mount struct; uses both
288 * mp->mnt_stat.f_mntonname and mp->mnt_stat.f_mntfromname
289 *
290 * This code is common to root and non-root mounts
291 */
dadab5e9 292 (void) VFS_STATFS(mp, &mp->mnt_stat, td);
984263bc
MD
293
294 goto success;
295
296error_2: /* error with devvp held*/
297
298 /* release devvp before failing*/
299 vrele(devvp);
300
301error_1: /* no state to back out*/
302
303success:
304 return( err);
305}
306
307
308static int mfs_pri = PWAIT | PCATCH; /* XXX prob. temp */
309
310/*
311 * Used to grab the process and keep it in the kernel to service
312 * memory filesystem I/O requests.
313 *
314 * Loop servicing I/O requests.
315 * Copy the requested data into or out of the memory filesystem
316 * address space.
317 */
318/* ARGSUSED */
319static int
dadab5e9 320mfs_start(struct mount *mp, int flags, struct thread *td)
984263bc
MD
321{
322 register struct vnode *vp = VFSTOUFS(mp)->um_devvp;
323 register struct mfsnode *mfsp = VTOMFS(vp);
324 register struct buf *bp;
325 register int gotsig = 0, sig;
326
327 /*
328 * We must prevent the system from trying to swap
329 * out or kill ( when swap space is low, see vm/pageout.c ) the
330 * process. A deadlock can occur if the process is swapped out,
331 * and the system can loop trying to kill the unkillable ( while
332 * references exist ) MFS process when swap space is low.
333 */
334 PHOLD(curproc);
335
336 while (mfsp->mfs_active) {
337 int s;
338
339 s = splbio();
340
341 while ((bp = bufq_first(&mfsp->buf_queue)) != NULL) {
342 bufq_remove(&mfsp->buf_queue, bp);
343 splx(s);
344 mfs_doio(bp, mfsp);
345 wakeup((caddr_t)bp);
346 s = splbio();
347 }
348
349 splx(s);
350
351 /*
352 * If a non-ignored signal is received, try to unmount.
353 * If that fails, clear the signal (it has been "processed"),
354 * otherwise we will loop here, as tsleep will always return
355 * EINTR/ERESTART.
356 */
357 /*
358 * Note that dounmount() may fail if work was queued after
359 * we slept. We have to jump hoops here to make sure that we
360 * process any buffers after the sleep, before we dounmount()
361 */
362 if (gotsig) {
363 gotsig = 0;
dadab5e9
MD
364 if (dounmount(mp, 0, td) != 0) {
365 KKASSERT(td->td_proc);
366 sig = CURSIG(td->td_proc);
984263bc 367 if (sig)
dadab5e9 368 SIGDELSET(td->td_proc->p_siglist, sig);
984263bc
MD
369 }
370 }
371 else if (tsleep((caddr_t)vp, mfs_pri, "mfsidl", 0))
372 gotsig++; /* try to unmount in next pass */
373 }
374 return (0);
375}
376
377/*
378 * Get file system statistics.
379 */
380static int
dadab5e9 381mfs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td)
984263bc
MD
382{
383 int error;
384
dadab5e9 385 error = ffs_statfs(mp, sbp, td);
984263bc
MD
386 sbp->f_type = mp->mnt_vfc->vfc_typenum;
387 return (error);
388}
389
390/*
391 * Memory based filesystem initialization.
392 */
393static int
394mfs_init(vfsp)
395 struct vfsconf *vfsp;
396{
397
398 cdevsw_add(&mfs_cdevsw);
399 return (0);
400}
401