Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / sys / vfs / mfs / mfs_vfsops.c
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.35 2006/09/10 01:26:41 dillon Exp $
36  */
37
38
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/conf.h>
42 #include <sys/device.h>
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>
51 #include <sys/fcntl.h>
52
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>
58
59 #include <sys/buf2.h>
60 #include <sys/thread2.h>
61
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>
68
69 #include "mfsnode.h"
70 #include "mfs_extern.h"
71
72 MALLOC_DEFINE(M_MFSNODE, "MFS node", "MFS vnode private part");
73
74 extern struct vop_ops *mfs_vnode_vops_p;
75
76 static int      mfs_mount (struct mount *mp,
77                         char *path, caddr_t data, struct ucred *td);
78 static int      mfs_start (struct mount *mp, int flags);
79 static int      mfs_statfs (struct mount *mp, struct statfs *sbp,
80                         struct ucred *cred); 
81 static int      mfs_init (struct vfsconf *);
82
83 d_open_t        mfsopen;
84 d_close_t       mfsclose;
85 d_strategy_t    mfsstrategy;
86
87 #define MFS_CDEV_MAJOR  253
88
89 static 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,
96 };
97
98 /*
99  * mfs vfs operations.
100  */
101 static struct vfsops mfs_vfsops = {
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
114 };
115
116 VFS_SET(mfs_vfsops, mfs, 0);
117
118 /*
119  * We allow the underlying MFS block device to be opened and read.
120  */
121 int
122 mfsopen(struct dev_open_args *ap)
123 {
124         cdev_t dev = ap->a_head.a_dev;
125
126         if (ap->a_oflags & FWRITE)
127                 return(EROFS);
128         if (dev->si_drv1)
129                 return(0);
130         return(ENXIO);
131 }
132
133 int
134 mfsclose(struct dev_close_args *ap)
135 {
136         return(0);
137 }
138
139 int
140 mfsstrategy(struct dev_strategy_args *ap)
141 {
142         cdev_t dev = ap->a_head.a_dev;
143         struct bio *bio = ap->a_bio;
144         struct buf *bp = bio->bio_buf;
145         off_t boff = bio->bio_offset;
146         off_t eoff = boff + bp->b_bcount;
147         struct mfsnode *mfsp;
148
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) {
164                         bp->b_resid = bp->b_bcount;
165                         bp->b_flags |= B_INVAL;
166                         goto done;
167                 }
168                 bp->b_bcount = mfsp->mfs_size - boff;
169         }
170
171         /*
172          * Initiate I/O
173          */
174         bioq_insert_tail(&mfsp->bio_queue, bio);
175         wakeup((caddr_t)mfsp);
176         return(0);
177
178         /*
179          * Failure conditions on bio
180          */
181 bad:
182         bp->b_error = EINVAL;
183 error:
184         bp->b_flags |= B_ERROR | B_INVAL;
185 done:
186         biodone(bio);
187         return(0);
188 }
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 */
228 static int
229 mfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
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;
238         int minnum;
239         cdev_t dev;
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;
281                         err = ffs_flushfiles(mp, flags);
282                         if (err)
283                                 goto error_1;
284                 }
285                 if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
286                         /* XXX reopen the device vnode read-write */
287                         fs->fs_ronly = 0;
288                 }
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
309         err = getspecialvnode(VT_MFS, NULL, &mfs_vnode_vops_p, &devvp, 0, 0);
310         if (err) {
311                 FREE(mfsp, M_MFSNODE);
312                 goto error_1;
313         }
314
315         minnum = (curproc->p_pid & 0xFF) |
316                 ((curproc->p_pid & ~0xFF) << 8);
317
318         devvp->v_type = VCHR;
319         dev = make_dev(&mfs_ops, minnum, UID_ROOT, GID_WHEEL, 0600,
320                         "MFS%d", minnum >> 16);
321         /* It is not clear that these will get initialized otherwise */
322         dev->si_bsize_phys = DEV_BSIZE;
323         dev->si_iosize_max = DFLTPHYS;
324         dev->si_drv1 = mfsp;
325         addaliasu(devvp, makeudev(MFS_CDEV_MAJOR, minnum));
326         devvp->v_data = mfsp;
327         mfsp->mfs_baseoff = args.base;
328         mfsp->mfs_size = args.size;
329         mfsp->mfs_vnode = devvp;
330         mfsp->mfs_dev = reference_dev(dev);
331         mfsp->mfs_td = curthread;
332         mfsp->mfs_active = 1;
333         bioq_init(&mfsp->bio_queue);
334
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
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
357         vx_unlock(devvp);
358         if ((err = ffs_mountfs(devvp, mp, M_MFSNODE)) != 0) { 
359                 mfsp->mfs_active = 0;
360                 goto error_2;
361         }
362
363         /*
364          * Initialize FS stat information in mount struct; uses
365          * mp->mnt_stat.f_mntfromname.
366          *
367          * This code is common to root and non-root mounts
368          */
369         VFS_STATFS(mp, &mp->mnt_stat, cred);
370
371         goto success;
372
373 error_2:        /* error with devvp held*/
374
375         /* release devvp before failing*/
376         vrele(devvp);
377
378 error_1:        /* no state to back out*/
379
380 success:
381         return( err);
382 }
383
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 */
393 static int
394 mfs_start(struct mount *mp, int flags)
395 {
396         struct vnode *vp = VFSTOUFS(mp)->um_devvp;
397         struct mfsnode *mfsp = VTOMFS(vp);
398         struct bio *bio;
399         struct buf *bp;
400         int gotsig = 0, sig;
401         thread_t td = curthread;
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          */
410         KKASSERT(curproc);
411         PHOLD(curproc);
412
413         mfsp->mfs_td = td;
414
415         while (mfsp->mfs_active) {
416                 crit_enter();
417
418                 while ((bio = bioq_first(&mfsp->bio_queue)) != NULL) {
419                         bioq_remove(&mfsp->bio_queue, bio);
420                         crit_exit();
421                         bp = bio->bio_buf;
422                         mfs_doio(bio, mfsp);
423                         wakeup(bp);
424                         crit_enter();
425                 }
426
427                 crit_exit();
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;
442                         if (dounmount(mp, 0) != 0) {
443                                 KKASSERT(td->td_proc);
444                                 sig = CURSIG(td->td_proc);
445                                 if (sig)
446                                         SIGDELSET(td->td_proc->p_siglist, sig);
447                         }
448                 }
449                 else if (tsleep((caddr_t)mfsp, PCATCH, "mfsidl", 0))
450                         gotsig++;       /* try to unmount in next pass */
451         }
452         PRELE(curproc);
453         v_release_rdev(vp);     /* hack because we do not implement CLOSE */
454         /* XXX destroy/release devvp */
455         return (0);
456 }
457
458 /*
459  * Get file system statistics.
460  */
461 static int
462 mfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
463 {
464         int error;
465
466         error = ffs_statfs(mp, sbp, cred);
467         sbp->f_type = mp->mnt_vfc->vfc_typenum;
468         return (error);
469 }
470
471 /*
472  * Memory based filesystem initialization.
473  */
474 static int
475 mfs_init(struct vfsconf *vfsp)
476 {
477         dev_ops_add(&mfs_ops, 0, 0);
478         return (0);
479 }