DEVFS - remove dev_ops_add(), dev_ops_get(), and get_dev()
[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 $
22eccd77 35 * $DragonFly: src/sys/vfs/mfs/mfs_vfsops.c,v 1.41 2008/07/26 22:31:54 mneumann Exp $
984263bc
MD
36 */
37
38
984263bc
MD
39#include <sys/param.h>
40#include <sys/systm.h>
41#include <sys/conf.h>
fef8985e 42#include <sys/device.h>
984263bc
MD
43#include <sys/kernel.h>
44#include <sys/proc.h>
45#include <sys/buf.h>
46#include <sys/mount.h>
47#include <sys/signalvar.h>
b1b4e5a6 48#include <sys/signal2.h>
984263bc
MD
49#include <sys/vnode.h>
50#include <sys/malloc.h>
51#include <sys/linker.h>
e4c9c0c8 52#include <sys/fcntl.h>
984263bc 53
d39c828b
MD
54#include <vm/vm.h>
55#include <vm/vm_object.h>
56#include <vm/vm_page.h>
57#include <vm/vm_pager.h>
58#include <vm/vnode_pager.h>
3020e3be 59
d39c828b 60#include <sys/buf2.h>
165dba55
DR
61#include <sys/thread2.h>
62
1f2de5d4
MD
63#include <vfs/ufs/quota.h>
64#include <vfs/ufs/inode.h>
65#include <vfs/ufs/ufsmount.h>
66#include <vfs/ufs/ufs_extern.h>
67#include <vfs/ufs/fs.h>
68#include <vfs/ufs/ffs_extern.h>
984263bc 69
1f2de5d4
MD
70#include "mfsnode.h"
71#include "mfs_extern.h"
984263bc
MD
72
73MALLOC_DEFINE(M_MFSNODE, "MFS node", "MFS vnode private part");
74
66a1ddf5 75extern struct vop_ops *mfs_vnode_vops_p;
984263bc 76
a6ee311a 77static int mfs_mount (struct mount *mp,
acde96db
MD
78 char *path, caddr_t data, struct ucred *td);
79static int mfs_start (struct mount *mp, int flags);
80static int mfs_statfs (struct mount *mp, struct statfs *sbp,
81 struct ucred *cred);
a6ee311a 82static int mfs_init (struct vfsconf *);
984263bc 83
e4c9c0c8
MD
84d_open_t mfsopen;
85d_close_t mfsclose;
86d_strategy_t mfsstrategy;
87
fef8985e 88static struct dev_ops mfs_ops = {
0e9b9130 89 { "MFS", -1, D_DISK },
fef8985e
MD
90 .d_open = mfsopen,
91 .d_close = mfsclose,
92 .d_read = physread,
93 .d_write = physwrite,
94 .d_strategy = mfsstrategy,
984263bc
MD
95};
96
97/*
98 * mfs vfs operations.
99 */
100static struct vfsops mfs_vfsops = {
43c45e8f
HP
101 .vfs_mount = mfs_mount,
102 .vfs_start = mfs_start,
103 .vfs_unmount = ffs_unmount,
104 .vfs_root = ufs_root,
105 .vfs_quotactl = ufs_quotactl,
106 .vfs_statfs = mfs_statfs,
107 .vfs_sync = ffs_sync,
108 .vfs_vget = ffs_vget,
109 .vfs_fhtovp = ffs_fhtovp,
110 .vfs_checkexp = ufs_check_export,
111 .vfs_vptofh = ffs_vptofh,
112 .vfs_init = mfs_init
984263bc
MD
113};
114
115VFS_SET(mfs_vfsops, mfs, 0);
116
e4c9c0c8
MD
117/*
118 * We allow the underlying MFS block device to be opened and read.
119 */
120int
fef8985e 121mfsopen(struct dev_open_args *ap)
e4c9c0c8 122{
b13267a5 123 cdev_t dev = ap->a_head.a_dev;
fef8985e
MD
124
125 if (ap->a_oflags & FWRITE)
e4c9c0c8
MD
126 return(EROFS);
127 if (dev->si_drv1)
128 return(0);
129 return(ENXIO);
130}
131
132int
fef8985e 133mfsclose(struct dev_close_args *ap)
e4c9c0c8
MD
134{
135 return(0);
136}
137
fef8985e
MD
138int
139mfsstrategy(struct dev_strategy_args *ap)
e4c9c0c8 140{
b13267a5 141 cdev_t dev = ap->a_head.a_dev;
fef8985e 142 struct bio *bio = ap->a_bio;
81b5c339 143 struct buf *bp = bio->bio_buf;
4414f2c9
MD
144 off_t boff = bio->bio_offset;
145 off_t eoff = boff + bp->b_bcount;
e4c9c0c8
MD
146 struct mfsnode *mfsp;
147
4414f2c9
MD
148 if ((mfsp = dev->si_drv1) == NULL) {
149 bp->b_error = ENXIO;
150 goto error;
151 }
152 if (boff < 0)
153 goto bad;
154 if (eoff > mfsp->mfs_size) {
155 if (boff > mfsp->mfs_size || (bp->b_flags & B_BNOCLIP))
156 goto bad;
157 /*
158 * Return EOF by completing the I/O with 0 bytes transfered.
159 * Set B_INVAL to indicate that any data in the buffer is not
160 * valid.
161 */
162 if (boff == mfsp->mfs_size) {
e4c9c0c8 163 bp->b_resid = bp->b_bcount;
4414f2c9
MD
164 bp->b_flags |= B_INVAL;
165 goto done;
e4c9c0c8 166 }
4414f2c9 167 bp->b_bcount = mfsp->mfs_size - boff;
e4c9c0c8 168 }
4414f2c9
MD
169
170 /*
171 * Initiate I/O
172 */
173 bioq_insert_tail(&mfsp->bio_queue, bio);
174 wakeup((caddr_t)mfsp);
fef8985e 175 return(0);
4414f2c9
MD
176
177 /*
178 * Failure conditions on bio
179 */
180bad:
181 bp->b_error = EINVAL;
182error:
183 bp->b_flags |= B_ERROR | B_INVAL;
184done:
185 biodone(bio);
fef8985e 186 return(0);
e4c9c0c8 187}
984263bc
MD
188
189/*
190 * mfs_mount
191 *
192 * Called when mounting local physical media
193 *
194 * PARAMETERS:
195 * mountroot
196 * mp mount point structure
197 * path NULL (flag for root mount!!!)
198 * data <unused>
199 * ndp <unused>
200 * p process (user credentials check [statfs])
201 *
202 * mount
203 * mp mount point structure
204 * path path to mount point
205 * data pointer to argument struct in user space
206 * ndp mount point namei() return (used for
207 * credentials on reload), reused to look
208 * up block device.
209 * p process (user credentials check)
210 *
211 * RETURNS: 0 Success
212 * !0 error number (errno.h)
213 *
214 * LOCK STATE:
215 *
216 * ENTRY
217 * mount point is locked
218 * EXIT
219 * mount point is locked
220 *
221 * NOTES:
222 * A NULL path can be used for a flag since the mount
223 * system call will fail with EFAULT in copyinstr in
224 * namei() if it is a genuine NULL from the user.
225 */
226/* ARGSUSED */
227static int
acde96db 228mfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
984263bc
MD
229{
230 struct vnode *devvp;
231 struct mfs_args args;
232 struct ufsmount *ump;
233 struct fs *fs;
234 struct mfsnode *mfsp;
235 size_t size;
236 int flags, err;
e4c9c0c8 237 int minnum;
b13267a5 238 cdev_t dev;
984263bc
MD
239
240 /*
241 * Use NULL path to flag a root mount
242 */
22eccd77 243 if (path == NULL) {
984263bc
MD
244 /*
245 ***
246 * Mounting root file system
247 ***
248 */
249
250 /* you lose */
251 panic("mfs_mount: mount MFS as root: not configured!");
252 }
253
254 /*
255 ***
256 * Mounting non-root file system or updating a file system
257 ***
258 */
259
260 /* copy in user arguments*/
261 if ((err = copyin(data, (caddr_t)&args, sizeof (struct mfs_args))) != 0)
262 goto error_1;
263
264 /*
265 * If updating, check whether changing from read-only to
266 * read/write; if there is no device name, that's all we do.
267 */
268 if (mp->mnt_flag & MNT_UPDATE) {
269 /*
270 ********************
271 * UPDATE
272 ********************
273 */
274 ump = VFSTOUFS(mp);
275 fs = ump->um_fs;
276 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
277 flags = WRITECLOSE;
278 if (mp->mnt_flag & MNT_FORCE)
279 flags |= FORCECLOSE;
2aa32050 280 err = ffs_flushfiles(mp, flags);
984263bc
MD
281 if (err)
282 goto error_1;
283 }
8ddc6004
MD
284 if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
285 /* XXX reopen the device vnode read-write */
984263bc 286 fs->fs_ronly = 0;
8ddc6004 287 }
984263bc
MD
288 /* if not updating name...*/
289 if (args.fspec == 0) {
290 /*
291 * Process export requests. Jumping to "success"
292 * will return the vfs_export() error code.
293 */
294 err = vfs_export(mp, &ump->um_export, &args.export);
295 goto success;
296 }
297
298 /* XXX MFS does not support name updating*/
299 goto success;
300 }
301 /*
302 * Do the MALLOC before the getnewvnode since doing so afterward
303 * might cause a bogus v_data pointer to get dereferenced
304 * elsewhere if MALLOC should block.
305 */
306 MALLOC(mfsp, struct mfsnode *, sizeof *mfsp, M_MFSNODE, M_WAITOK);
307
66a1ddf5 308 err = getspecialvnode(VT_MFS, NULL, &mfs_vnode_vops_p, &devvp, 0, 0);
984263bc
MD
309 if (err) {
310 FREE(mfsp, M_MFSNODE);
311 goto error_1;
312 }
e4c9c0c8
MD
313
314 minnum = (curproc->p_pid & 0xFF) |
315 ((curproc->p_pid & ~0xFF) << 8);
316
0cbed593 317 devvp->v_type = VCHR;
fef8985e 318 dev = make_dev(&mfs_ops, minnum, UID_ROOT, GID_WHEEL, 0600,
3e82b46c 319 "MFS%d", minnum >> 16);
984263bc
MD
320 /* It is not clear that these will get initialized otherwise */
321 dev->si_bsize_phys = DEV_BSIZE;
322 dev->si_iosize_max = DFLTPHYS;
e4c9c0c8 323 dev->si_drv1 = mfsp;
0e9b9130 324 addaliasu(devvp, mfs_ops.head.maj, minnum);
984263bc
MD
325 devvp->v_data = mfsp;
326 mfsp->mfs_baseoff = args.base;
327 mfsp->mfs_size = args.size;
328 mfsp->mfs_vnode = devvp;
e4c9c0c8 329 mfsp->mfs_dev = reference_dev(dev);
acde96db 330 mfsp->mfs_td = curthread;
984263bc 331 mfsp->mfs_active = 1;
81b5c339 332 bioq_init(&mfsp->bio_queue);
984263bc 333
d39c828b
MD
334 /*
335 * Our 'block' device must be backed by a VM object. Theoretically
336 * we could use the anonymous memory VM object supplied by userland,
337 * but it would be somewhat of a complex task to deal with it
338 * that way since it would result in I/O requests which supply
339 * the VM pages from our own object.
340 *
341 * vnode_pager_alloc() is typically called when a VM object is
342 * being referenced externally. We have to undo the refs for
343 * the self reference between vnode and object.
344 */
345 vnode_pager_alloc(devvp, args.size, 0, 0);
3c37c940 346 vrele(devvp);
d39c828b
MD
347 --devvp->v_object->ref_count;
348
984263bc
MD
349 /* Save "mounted from" info for mount point (NULL pad)*/
350 copyinstr( args.fspec, /* device name*/
351 mp->mnt_stat.f_mntfromname, /* save area*/
352 MNAMELEN - 1, /* max size*/
353 &size); /* real size*/
354 bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
355
5fd012e0 356 vx_unlock(devvp);
2aa32050 357 if ((err = ffs_mountfs(devvp, mp, M_MFSNODE)) != 0) {
984263bc
MD
358 mfsp->mfs_active = 0;
359 goto error_2;
360 }
361
362 /*
75ffff0d
JS
363 * Initialize FS stat information in mount struct; uses
364 * mp->mnt_stat.f_mntfromname.
984263bc
MD
365 *
366 * This code is common to root and non-root mounts
367 */
acde96db 368 VFS_STATFS(mp, &mp->mnt_stat, cred);
984263bc
MD
369
370 goto success;
371
372error_2: /* error with devvp held*/
373
374 /* release devvp before failing*/
375 vrele(devvp);
376
377error_1: /* no state to back out*/
378
379success:
380 return( err);
381}
382
984263bc
MD
383/*
384 * Used to grab the process and keep it in the kernel to service
385 * memory filesystem I/O requests.
386 *
387 * Loop servicing I/O requests.
388 * Copy the requested data into or out of the memory filesystem
389 * address space.
390 */
391/* ARGSUSED */
392static int
acde96db 393mfs_start(struct mount *mp, int flags)
984263bc 394{
3ff2135f
RG
395 struct vnode *vp = VFSTOUFS(mp)->um_devvp;
396 struct mfsnode *mfsp = VTOMFS(vp);
81b5c339 397 struct bio *bio;
54078292 398 struct buf *bp;
3ff2135f 399 int gotsig = 0, sig;
acde96db 400 thread_t td = curthread;
984263bc
MD
401
402 /*
403 * We must prevent the system from trying to swap
404 * out or kill ( when swap space is low, see vm/pageout.c ) the
405 * process. A deadlock can occur if the process is swapped out,
406 * and the system can loop trying to kill the unkillable ( while
407 * references exist ) MFS process when swap space is low.
408 */
8a8d5d85 409 KKASSERT(curproc);
984263bc
MD
410 PHOLD(curproc);
411
acde96db
MD
412 mfsp->mfs_td = td;
413
984263bc 414 while (mfsp->mfs_active) {
165dba55 415 crit_enter();
984263bc 416
81b5c339
MD
417 while ((bio = bioq_first(&mfsp->bio_queue)) != NULL) {
418 bioq_remove(&mfsp->bio_queue, bio);
165dba55 419 crit_exit();
54078292 420 bp = bio->bio_buf;
81b5c339 421 mfs_doio(bio, mfsp);
54078292 422 wakeup(bp);
165dba55 423 crit_enter();
984263bc
MD
424 }
425
165dba55 426 crit_exit();
984263bc
MD
427
428 /*
429 * If a non-ignored signal is received, try to unmount.
430 * If that fails, clear the signal (it has been "processed"),
431 * otherwise we will loop here, as tsleep will always return
432 * EINTR/ERESTART.
433 */
434 /*
435 * Note that dounmount() may fail if work was queued after
436 * we slept. We have to jump hoops here to make sure that we
437 * process any buffers after the sleep, before we dounmount()
438 */
439 if (gotsig) {
440 gotsig = 0;
acde96db 441 if (dounmount(mp, 0) != 0) {
dadab5e9 442 KKASSERT(td->td_proc);
08f2f1bb 443 sig = CURSIG(td->td_lwp);
984263bc 444 if (sig)
aa6c3de6 445 lwp_delsig(td->td_lwp, sig);
984263bc
MD
446 }
447 }
e4c9c0c8 448 else if (tsleep((caddr_t)mfsp, PCATCH, "mfsidl", 0))
984263bc
MD
449 gotsig++; /* try to unmount in next pass */
450 }
28b802e1 451 PRELE(curproc);
e4c9c0c8
MD
452 v_release_rdev(vp); /* hack because we do not implement CLOSE */
453 /* XXX destroy/release devvp */
984263bc
MD
454 return (0);
455}
456
457/*
458 * Get file system statistics.
459 */
460static int
acde96db 461mfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
984263bc
MD
462{
463 int error;
464
acde96db 465 error = ffs_statfs(mp, sbp, cred);
984263bc
MD
466 sbp->f_type = mp->mnt_vfc->vfc_typenum;
467 return (error);
468}
469
470/*
471 * Memory based filesystem initialization.
472 */
473static int
77cf116b 474mfs_init(struct vfsconf *vfsp)
984263bc 475{
984263bc
MD
476 return (0);
477}