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