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