Remove the thread argument from all mount->vfs_* function vectors,
[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.31 2006/05/06 18:48:53 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 ucred *td);
80 static int      mfs_start (struct mount *mp, int flags);
81 static int      mfs_statfs (struct mount *mp, struct statfs *sbp,
82                         struct ucred *cred); 
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         off_t boff = bio->bio_offset;
154         off_t eoff = boff + bp->b_bcount;
155         struct mfsnode *mfsp;
156
157         if ((mfsp = dev->si_drv1) == NULL) {
158                 bp->b_error = ENXIO;
159                 goto error;
160         }
161         if (boff < 0)
162                 goto bad;
163         if (eoff > mfsp->mfs_size) {
164                 if (boff > mfsp->mfs_size || (bp->b_flags & B_BNOCLIP))
165                         goto bad;
166                 /*
167                  * Return EOF by completing the I/O with 0 bytes transfered.
168                  * Set B_INVAL to indicate that any data in the buffer is not
169                  * valid.
170                  */
171                 if (boff == mfsp->mfs_size) {
172                         bp->b_resid = bp->b_bcount;
173                         bp->b_flags |= B_INVAL;
174                         goto done;
175                 }
176                 bp->b_bcount = mfsp->mfs_size - boff;
177         }
178
179         /*
180          * Initiate I/O
181          */
182         bioq_insert_tail(&mfsp->bio_queue, bio);
183         wakeup((caddr_t)mfsp);
184         return;
185
186         /*
187          * Failure conditions on bio
188          */
189 bad:
190         bp->b_error = EINVAL;
191 error:
192         bp->b_flags |= B_ERROR | B_INVAL;
193 done:
194         biodone(bio);
195 }
196
197 /*
198  * mfs_mount
199  *
200  * Called when mounting local physical media
201  *
202  * PARAMETERS:
203  *              mountroot
204  *                      mp      mount point structure
205  *                      path    NULL (flag for root mount!!!)
206  *                      data    <unused>
207  *                      ndp     <unused>
208  *                      p       process (user credentials check [statfs])
209  *
210  *              mount
211  *                      mp      mount point structure
212  *                      path    path to mount point
213  *                      data    pointer to argument struct in user space
214  *                      ndp     mount point namei() return (used for
215  *                              credentials on reload), reused to look
216  *                              up block device.
217  *                      p       process (user credentials check)
218  *
219  * RETURNS:     0       Success
220  *              !0      error number (errno.h)
221  *
222  * LOCK STATE:
223  *
224  *              ENTRY
225  *                      mount point is locked
226  *              EXIT
227  *                      mount point is locked
228  *
229  * NOTES:
230  *              A NULL path can be used for a flag since the mount
231  *              system call will fail with EFAULT in copyinstr in
232  *              namei() if it is a genuine NULL from the user.
233  */
234 /* ARGSUSED */
235 static int
236 mfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
237 {
238         struct vnode *devvp;
239         struct mfs_args args;
240         struct ufsmount *ump;
241         struct fs *fs;
242         struct mfsnode *mfsp;
243         size_t size;
244         int flags, err;
245         int minnum;
246         dev_t dev;
247
248         /*
249          * Use NULL path to flag a root mount
250          */
251         if( path == NULL) {
252                 /*
253                  ***
254                  * Mounting root file system
255                  ***
256                  */
257
258                 /* you lose */
259                 panic("mfs_mount: mount MFS as root: not configured!");
260         }
261
262         /*
263          ***
264          * Mounting non-root file system or updating a file system
265          ***
266          */
267
268         /* copy in user arguments*/
269         if ((err = copyin(data, (caddr_t)&args, sizeof (struct mfs_args))) != 0)
270                 goto error_1;
271
272         /*
273          * If updating, check whether changing from read-only to
274          * read/write; if there is no device name, that's all we do.
275          */
276         if (mp->mnt_flag & MNT_UPDATE) {
277                 /*
278                  ********************
279                  * UPDATE
280                  ********************
281                  */
282                 ump = VFSTOUFS(mp);
283                 fs = ump->um_fs;
284                 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
285                         flags = WRITECLOSE;
286                         if (mp->mnt_flag & MNT_FORCE)
287                                 flags |= FORCECLOSE;
288                         err = ffs_flushfiles(mp, flags);
289                         if (err)
290                                 goto error_1;
291                 }
292                 if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
293                         /* XXX reopen the device vnode read-write */
294                         fs->fs_ronly = 0;
295                 }
296                 /* if not updating name...*/
297                 if (args.fspec == 0) {
298                         /*
299                          * Process export requests.  Jumping to "success"
300                          * will return the vfs_export() error code. 
301                          */
302                         err = vfs_export(mp, &ump->um_export, &args.export);
303                         goto success;
304                 }
305
306                 /* XXX MFS does not support name updating*/
307                 goto success;
308         }
309         /*
310          * Do the MALLOC before the getnewvnode since doing so afterward
311          * might cause a bogus v_data pointer to get dereferenced
312          * elsewhere if MALLOC should block.
313          */
314         MALLOC(mfsp, struct mfsnode *, sizeof *mfsp, M_MFSNODE, M_WAITOK);
315
316         err = getspecialvnode(VT_MFS, NULL, &mfs_vnode_vops, &devvp, 0, 0);
317         if (err) {
318                 FREE(mfsp, M_MFSNODE);
319                 goto error_1;
320         }
321
322         minnum = (curproc->p_pid & 0xFF) |
323                 ((curproc->p_pid & ~0xFF) << 8);
324
325         devvp->v_type = VCHR;
326         dev = make_dev(&mfs_cdevsw, minnum, UID_ROOT, GID_WHEEL, 0600,
327                         "MFS%d", minnum >> 16);
328         /* It is not clear that these will get initialized otherwise */
329         dev->si_bsize_phys = DEV_BSIZE;
330         dev->si_iosize_max = DFLTPHYS;
331         dev->si_drv1 = mfsp;
332         addaliasu(devvp, makeudev(MFS_CDEV_MAJOR, minnum));
333         devvp->v_data = mfsp;
334         mfsp->mfs_baseoff = args.base;
335         mfsp->mfs_size = args.size;
336         mfsp->mfs_vnode = devvp;
337         mfsp->mfs_dev = reference_dev(dev);
338         mfsp->mfs_td = curthread;
339         mfsp->mfs_active = 1;
340         bioq_init(&mfsp->bio_queue);
341
342         /*
343          * Our 'block' device must be backed by a VM object.  Theoretically
344          * we could use the anonymous memory VM object supplied by userland,
345          * but it would be somewhat of a complex task to deal with it
346          * that way since it would result in I/O requests which supply
347          * the VM pages from our own object.
348          *
349          * vnode_pager_alloc() is typically called when a VM object is
350          * being referenced externally.  We have to undo the refs for
351          * the self reference between vnode and object.
352          */
353         vnode_pager_alloc(devvp, args.size, 0, 0);
354         --devvp->v_usecount;
355         --devvp->v_object->ref_count;
356
357         /* Save "mounted from" info for mount point (NULL pad)*/
358         copyinstr(      args.fspec,                     /* device name*/
359                         mp->mnt_stat.f_mntfromname,     /* save area*/
360                         MNAMELEN - 1,                   /* max size*/
361                         &size);                         /* real size*/
362         bzero( mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
363
364         vx_unlock(devvp);
365         if ((err = ffs_mountfs(devvp, mp, M_MFSNODE)) != 0) { 
366                 mfsp->mfs_active = 0;
367                 goto error_2;
368         }
369
370         /*
371          * Initialize FS stat information in mount struct; uses
372          * mp->mnt_stat.f_mntfromname.
373          *
374          * This code is common to root and non-root mounts
375          */
376         VFS_STATFS(mp, &mp->mnt_stat, cred);
377
378         goto success;
379
380 error_2:        /* error with devvp held*/
381
382         /* release devvp before failing*/
383         vrele(devvp);
384
385 error_1:        /* no state to back out*/
386
387 success:
388         return( err);
389 }
390
391 /*
392  * Used to grab the process and keep it in the kernel to service
393  * memory filesystem I/O requests.
394  *
395  * Loop servicing I/O requests.
396  * Copy the requested data into or out of the memory filesystem
397  * address space.
398  */
399 /* ARGSUSED */
400 static int
401 mfs_start(struct mount *mp, int flags)
402 {
403         struct vnode *vp = VFSTOUFS(mp)->um_devvp;
404         struct mfsnode *mfsp = VTOMFS(vp);
405         struct bio *bio;
406         struct buf *bp;
407         int gotsig = 0, sig;
408         thread_t td = curthread;
409
410         /*
411          * We must prevent the system from trying to swap
412          * out or kill ( when swap space is low, see vm/pageout.c ) the
413          * process.  A deadlock can occur if the process is swapped out,
414          * and the system can loop trying to kill the unkillable ( while
415          * references exist ) MFS process when swap space is low.
416          */
417         KKASSERT(curproc);
418         PHOLD(curproc);
419
420         mfsp->mfs_td = td;
421
422         while (mfsp->mfs_active) {
423                 crit_enter();
424
425                 while ((bio = bioq_first(&mfsp->bio_queue)) != NULL) {
426                         bioq_remove(&mfsp->bio_queue, bio);
427                         crit_exit();
428                         bp = bio->bio_buf;
429                         mfs_doio(bio, mfsp);
430                         wakeup(bp);
431                         crit_enter();
432                 }
433
434                 crit_exit();
435
436                 /*
437                  * If a non-ignored signal is received, try to unmount.
438                  * If that fails, clear the signal (it has been "processed"),
439                  * otherwise we will loop here, as tsleep will always return
440                  * EINTR/ERESTART.
441                  */
442                 /*
443                  * Note that dounmount() may fail if work was queued after
444                  * we slept. We have to jump hoops here to make sure that we
445                  * process any buffers after the sleep, before we dounmount()
446                  */
447                 if (gotsig) {
448                         gotsig = 0;
449                         if (dounmount(mp, 0) != 0) {
450                                 KKASSERT(td->td_proc);
451                                 sig = CURSIG(td->td_proc);
452                                 if (sig)
453                                         SIGDELSET(td->td_proc->p_siglist, sig);
454                         }
455                 }
456                 else if (tsleep((caddr_t)mfsp, PCATCH, "mfsidl", 0))
457                         gotsig++;       /* try to unmount in next pass */
458         }
459         PRELE(curproc);
460         v_release_rdev(vp);     /* hack because we do not implement CLOSE */
461         /* XXX destroy/release devvp */
462         return (0);
463 }
464
465 /*
466  * Get file system statistics.
467  */
468 static int
469 mfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
470 {
471         int error;
472
473         error = ffs_statfs(mp, sbp, cred);
474         sbp->f_type = mp->mnt_vfc->vfc_typenum;
475         return (error);
476 }
477
478 /*
479  * Memory based filesystem initialization.
480  */
481 static int
482 mfs_init(struct vfsconf *vfsp)
483 {
484         cdevsw_add(&mfs_cdevsw, 0, 0);
485         return (0);
486 }