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