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