4c9555492251c20250fd9b60faf96a39bb9e01ed
[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  */
36
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/conf.h>
41 #include <sys/device.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/signal2.h>
48 #include <sys/vnode.h>
49 #include <sys/malloc.h>
50 #include <sys/sysproto.h>
51 #include <sys/mman.h>
52 #include <sys/linker.h>
53 #include <sys/fcntl.h>
54 #include <sys/nlookup.h>
55 #include <sys/devfs.h>
56
57 #include <vm/vm.h>
58 #include <vm/vm_object.h>
59 #include <vm/vm_page.h>
60 #include <vm/vm_pager.h>
61 #include <vm/vnode_pager.h>
62 #include <vm/vm_extern.h>
63
64 #include <sys/buf2.h>
65 #include <sys/thread2.h>
66
67 #include <vfs/ufs/quota.h>
68 #include <vfs/ufs/inode.h>
69 #include <vfs/ufs/ufsmount.h>
70 #include <vfs/ufs/ufs_extern.h>
71 #include <vfs/ufs/fs.h>
72 #include <vfs/ufs/ffs_extern.h>
73
74 #include "mfsnode.h"
75 #include "mfs_extern.h"
76
77 MALLOC_DEFINE(M_MFSNODE, "MFS node", "MFS vnode private part");
78
79 static int      mfs_mount (struct mount *mp,
80                         char *path, caddr_t data, struct ucred *td);
81 static int      mfs_start (struct mount *mp, int flags);
82 static int      mfs_statfs (struct mount *mp, struct statfs *sbp,
83                         struct ucred *cred); 
84 static int      mfs_init (struct vfsconf *);
85 static void     mfs_doio(struct bio *bio, struct mfsnode *mfsp);
86
87 d_open_t        mfsopen;
88 d_close_t       mfsclose;
89 d_strategy_t    mfsstrategy;
90
91 static struct dev_ops mfs_ops = {
92         { "MFS", -1, D_DISK },
93         .d_open =       mfsopen,
94         .d_close =      mfsclose,
95         .d_read =       physread,
96         .d_write =      physwrite,
97         .d_strategy =   mfsstrategy,
98 };
99
100 /*
101  * mfs vfs operations.
102  */
103 static struct vfsops mfs_vfsops = {
104         .vfs_mount =            mfs_mount,
105         .vfs_start =            mfs_start,
106         .vfs_unmount =          ffs_unmount,
107         .vfs_root =             ufs_root,
108         .vfs_quotactl =         ufs_quotactl,
109         .vfs_statfs =           mfs_statfs,
110         .vfs_sync =             ffs_sync,
111         .vfs_vget =             ffs_vget,
112         .vfs_fhtovp =           ffs_fhtovp,
113         .vfs_checkexp =         ufs_check_export,
114         .vfs_vptofh =           ffs_vptofh,
115         .vfs_init =             mfs_init
116 };
117
118 VFS_SET(mfs_vfsops, mfs, 0);
119 MODULE_VERSION(mfs, 1);
120
121 /*
122  * We allow the underlying MFS block device to be opened and read.
123  */
124 int
125 mfsopen(struct dev_open_args *ap)
126 {
127         cdev_t dev = ap->a_head.a_dev;
128
129 #if 0
130         if (ap->a_oflags & FWRITE)
131                 return(EROFS);
132 #endif
133         if (dev->si_drv1)
134                 return(0);
135         return(ENXIO);
136 }
137
138 int
139 mfsclose(struct dev_close_args *ap)
140 {
141         cdev_t dev = ap->a_head.a_dev;
142         struct mfsnode *mfsp;
143
144         if ((mfsp = dev->si_drv1) == NULL)
145                 return(0);
146         mfsp->mfs_active = 0;
147         wakeup((caddr_t)mfsp);
148         return(0);
149 }
150
151 int
152 mfsstrategy(struct dev_strategy_args *ap)
153 {
154         cdev_t dev = ap->a_head.a_dev;
155         struct bio *bio = ap->a_bio;
156         struct buf *bp = bio->bio_buf;
157         off_t boff = bio->bio_offset;
158         off_t eoff = boff + bp->b_bcount;
159         struct mfsnode *mfsp;
160
161         if ((mfsp = dev->si_drv1) == NULL) {
162                 bp->b_error = ENXIO;
163                 goto error;
164         }
165         if (boff < 0)
166                 goto bad;
167         if (eoff > mfsp->mfs_size) {
168                 if (boff > mfsp->mfs_size || (bp->b_flags & B_BNOCLIP))
169                         goto bad;
170                 /*
171                  * Return EOF by completing the I/O with 0 bytes transfered.
172                  * Set B_INVAL to indicate that any data in the buffer is not
173                  * valid.
174                  */
175                 if (boff == mfsp->mfs_size) {
176                         bp->b_resid = bp->b_bcount;
177                         bp->b_flags |= B_INVAL;
178                         goto done;
179                 }
180                 bp->b_bcount = mfsp->mfs_size - boff;
181         }
182
183         /*
184          * Initiate I/O
185          */
186         if (mfsp->mfs_td == curthread) {
187                 mfs_doio(bio, mfsp);
188         } else {
189                 bioq_insert_tail(&mfsp->bio_queue, bio);
190                 wakeup((caddr_t)mfsp);
191         }
192         return(0);
193
194         /*
195          * Failure conditions on bio
196          */
197 bad:
198         bp->b_error = EINVAL;
199 error:
200         bp->b_flags |= B_ERROR | B_INVAL;
201 done:
202         biodone(bio);
203         return(0);
204 }
205
206 /*
207  * mfs_mount
208  *
209  * Called when mounting local physical media
210  *
211  * PARAMETERS:
212  *              mountroot
213  *                      mp      mount point structure
214  *                      path    NULL (flag for root mount!!!)
215  *                      data    <unused>
216  *                      ndp     <unused>
217  *                      p       process (user credentials check [statfs])
218  *
219  *              mount
220  *                      mp      mount point structure
221  *                      path    path to mount point
222  *                      data    pointer to argument struct in user space
223  *                      ndp     mount point namei() return (used for
224  *                              credentials on reload), reused to look
225  *                              up block device.
226  *                      p       process (user credentials check)
227  *
228  * RETURNS:     0       Success
229  *              !0      error number (errno.h)
230  *
231  * LOCK STATE:
232  *
233  *              ENTRY
234  *                      mount point is locked
235  *              EXIT
236  *                      mount point is locked
237  *
238  * NOTES:
239  *              A NULL path can be used for a flag since the mount
240  *              system call will fail with EFAULT in copyinstr in
241  *              namei() if it is a genuine NULL from the user.
242  */
243 /* ARGSUSED */
244 static int
245 mfs_mount(struct mount *mp, char *path, caddr_t data, struct ucred *cred)
246 {
247         struct vnode *devvp;
248         struct mfs_args args;
249         struct ufsmount *ump;
250         struct fs *fs;
251         struct mfsnode *mfsp;
252         struct nlookupdata nd;
253         size_t size;
254         char devname[16];
255         int flags;
256         int minnum;
257         int error;
258         cdev_t dev;
259
260         /*
261          * Use NULL path to flag a root mount
262          */
263         if (path == NULL) {
264                 /*
265                  ***
266                  * Mounting root file system
267                  ***
268                  */
269
270                 /* you lose */
271                 panic("mfs_mount: mount MFS as root: not configured!");
272         }
273
274         mfsp = NULL;
275
276         /*
277          ***
278          * Mounting non-root file system or updating a file system
279          ***
280          */
281
282         /* copy in user arguments*/
283         error = copyin(data, (caddr_t)&args, sizeof (struct mfs_args));
284         if (error)
285                 goto error_1;
286
287         /*
288          * If updating, check whether changing from read-only to
289          * read/write; if there is no device name, that's all we do.
290          */
291         if (mp->mnt_flag & MNT_UPDATE) {
292                 /*
293                  ********************
294                  * UPDATE
295                  ********************
296                  */
297                 ump = VFSTOUFS(mp);
298                 fs = ump->um_fs;
299                 if (fs->fs_ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
300                         flags = WRITECLOSE;
301                         if (mp->mnt_flag & MNT_FORCE)
302                                 flags |= FORCECLOSE;
303                         error = ffs_flushfiles(mp, flags);
304                         if (error)
305                                 goto error_1;
306                 }
307                 if (fs->fs_ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
308                         /* XXX reopen the device vnode read-write */
309                         fs->fs_ronly = 0;
310                 }
311                 /* if not updating name...*/
312                 if (args.fspec == 0) {
313                         /*
314                          * Process export requests.  Jumping to "success"
315                          * will return the vfs_export() error code. 
316                          */
317                         error = vfs_export(mp, &ump->um_export, &args.export);
318                         goto success;
319                 }
320
321                 /* XXX MFS does not support name updating*/
322                 goto success;
323         }
324
325         /*
326          * Do the MALLOC before the make_dev since doing so afterward
327          * might cause a bogus v_data pointer to get dereferenced
328          * elsewhere if MALLOC should block.
329          */
330         mfsp = kmalloc(sizeof *mfsp, M_MFSNODE, M_WAITOK | M_ZERO);
331
332         minnum = (int)curproc->p_pid;
333
334         dev = make_dev(&mfs_ops, minnum, UID_ROOT, GID_WHEEL, 0600,
335                        "mfs%d", minnum);
336         /* It is not clear that these will get initialized otherwise */
337         dev->si_bsize_phys = DEV_BSIZE;
338         dev->si_iosize_max = DFLTPHYS;
339         dev->si_drv1 = mfsp;
340         mfsp->mfs_baseoff = args.base;
341         mfsp->mfs_size = args.size;
342         mfsp->mfs_dev = dev;
343         mfsp->mfs_td = curthread;
344         mfsp->mfs_active = 1;
345         bioq_init(&mfsp->bio_queue);
346
347         devfs_config(); /* sync devfs work */
348         ksnprintf(devname, sizeof(devname), "/dev/mfs%d", minnum);
349         nlookup_init(&nd, devname, UIO_SYSSPACE, 0);
350         devvp = NULL;
351         error = nlookup(&nd);
352         if (error == 0) {
353                 devvp = nd.nl_nch.ncp->nc_vp;
354                 if (devvp == NULL)
355                         error = ENOENT;
356                 error = vget(devvp, LK_SHARED);
357         }
358         nlookup_done(&nd);
359
360         if (error)
361                 goto error_1;
362         vn_unlock(devvp);
363
364         /*
365          * Our 'block' device must be backed by a VM object.  Theoretically
366          * we could use the anonymous memory VM object supplied by userland,
367          * but it would be somewhat of a complex task to deal with it
368          * that way since it would result in I/O requests which supply
369          * the VM pages from our own object.
370          *
371          * vnode_pager_alloc() is typically called when a VM object is
372          * being referenced externally.  We have to undo the refs for
373          * the self reference between vnode and object.
374          */
375         vnode_pager_setsize(devvp, args.size);
376
377         /* Save "mounted from" info for mount point (NULL pad)*/
378         copyinstr(args.fspec,                   /* device name*/
379                   mp->mnt_stat.f_mntfromname,   /* save area*/
380                   MNAMELEN - 1,                 /* max size*/
381                   &size);                       /* real size*/
382         bzero(mp->mnt_stat.f_mntfromname + size, MNAMELEN - size);
383         /* vref is eaten by mount? */
384
385         error = ffs_mountfs(devvp, mp, M_MFSNODE);
386         if (error) {
387                 mfsp->mfs_active = 0;
388                 goto error_2;
389         }
390
391         /*
392          * Initialize FS stat information in mount struct; uses
393          * mp->mnt_stat.f_mntfromname.
394          *
395          * This code is common to root and non-root mounts
396          */
397         VFS_STATFS(mp, &mp->mnt_stat, cred);
398
399         goto success;
400
401 error_2:        /* error with devvp held*/
402         vrele(devvp);
403
404 error_1:        /* no state to back out*/
405         if (mfsp) {
406                 if (mfsp->mfs_dev) {
407                         destroy_dev(mfsp->mfs_dev);
408                         mfsp->mfs_dev = NULL;
409                 }
410                 kfree(mfsp, M_MFSNODE);
411         }
412
413 success:
414         return(error);
415 }
416
417 /*
418  * Used to grab the process and keep it in the kernel to service
419  * memory filesystem I/O requests.
420  *
421  * Loop servicing I/O requests.
422  * Copy the requested data into or out of the memory filesystem
423  * address space.
424  */
425 /* ARGSUSED */
426 static int
427 mfs_start(struct mount *mp, int flags)
428 {
429         struct vnode *vp = VFSTOUFS(mp)->um_devvp;
430         struct mfsnode *mfsp = vp->v_rdev->si_drv1;
431         struct bio *bio;
432         struct buf *bp;
433         int gotsig = 0, sig;
434         thread_t td = curthread;
435
436         /*
437          * We must prevent the system from trying to swap
438          * out or kill ( when swap space is low, see vm/pageout.c ) the
439          * process.  A deadlock can occur if the process is swapped out,
440          * and the system can loop trying to kill the unkillable ( while
441          * references exist ) MFS process when swap space is low.
442          */
443         KKASSERT(curproc);
444         PHOLD(curproc);
445
446         mfsp->mfs_td = td;
447
448         while (mfsp->mfs_active) {
449                 crit_enter();
450
451                 while ((bio = bioq_first(&mfsp->bio_queue)) != NULL) {
452                         bioq_remove(&mfsp->bio_queue, bio);
453                         crit_exit();
454                         bp = bio->bio_buf;
455                         mfs_doio(bio, mfsp);
456                         wakeup(bp);
457                         crit_enter();
458                 }
459
460                 crit_exit();
461
462                 /*
463                  * If a non-ignored signal is received, try to unmount.
464                  * If that fails, clear the signal (it has been "processed"),
465                  * otherwise we will loop here, as tsleep will always return
466                  * EINTR/ERESTART.
467                  */
468                 /*
469                  * Note that dounmount() may fail if work was queued after
470                  * we slept. We have to jump hoops here to make sure that we
471                  * process any buffers after the sleep, before we dounmount()
472                  */
473                 if (gotsig) {
474                         gotsig = 0;
475                         if (dounmount(mp, 0) != 0) {
476                                 KKASSERT(td->td_proc);
477                                 sig = CURSIG(td->td_lwp);
478                                 if (sig) {
479                                         spin_lock(&td->td_lwp->lwp_spin);
480                                         lwp_delsig(td->td_lwp, sig);
481                                         spin_unlock(&td->td_lwp->lwp_spin);
482                                 }
483                         }
484                 }
485                 else if (tsleep((caddr_t)mfsp, PCATCH, "mfsidl", 0))
486                         gotsig++;       /* try to unmount in next pass */
487         }
488         PRELE(curproc);
489         if (mfsp->mfs_dev) {
490                 destroy_dev(mfsp->mfs_dev);
491                 mfsp->mfs_dev = NULL;
492         }
493         kfree(mfsp, M_MFSNODE);
494         return (0);
495 }
496
497 /*
498  * Get file system statistics.
499  */
500 static int
501 mfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
502 {
503         int error;
504
505         error = ffs_statfs(mp, sbp, cred);
506         sbp->f_type = mp->mnt_vfc->vfc_typenum;
507         return (error);
508 }
509
510 /*
511  * Memory based filesystem initialization.
512  */
513 static int
514 mfs_init(struct vfsconf *vfsp)
515 {
516         return (0);
517 }
518
519 /*
520  * Memory file system I/O.
521  *
522  * Trivial on the HP since buffer has already been mapping into KVA space.
523  *
524  * Read and Write are handled with a simple copyin and copyout.
525  *
526  * We also partially support VOP_FREEBLKS().  We can't implement
527  * completely -- for example, on fragments or inode metadata, but we can
528  * implement it for page-aligned requests.
529  */
530 static void
531 mfs_doio(struct bio *bio, struct mfsnode *mfsp)
532 {
533         struct buf *bp = bio->bio_buf;
534         caddr_t base = mfsp->mfs_baseoff + bio->bio_offset;
535         int bytes;
536
537         switch(bp->b_cmd) {
538         case BUF_CMD_FREEBLKS:
539                 /*
540                  * Implement FREEBLKS, which allows the filesystem to tell
541                  * a block device when blocks are no longer needed (like when
542                  * a file is deleted).  We use the hook to MADV_FREE the VM.
543                  * This makes an MFS filesystem work as well or better then
544                  * a sun-style swap-mounted filesystem.
545                  */
546                 bytes = bp->b_bcount;
547
548                 if ((vm_offset_t)base & PAGE_MASK) {
549                         int n = PAGE_SIZE - ((vm_offset_t)base & PAGE_MASK);
550                         bytes -= n;
551                         base += n;
552                 }
553                 if (bytes > 0) {
554                         struct madvise_args uap;
555
556                         bytes &= ~PAGE_MASK;
557                         if (bytes != 0) {
558                                 bzero(&uap, sizeof(uap));
559                                 uap.addr  = base;
560                                 uap.len   = bytes;
561                                 uap.behav = MADV_FREE;
562                                 sys_madvise(&uap);
563                         }
564                 }
565                 bp->b_error = 0;
566                 break;
567         case BUF_CMD_READ:
568                 /*
569                  * Read data from our 'memory' disk
570                  */
571                 bp->b_error = copyin(base, bp->b_data, bp->b_bcount);
572                 break;
573         case BUF_CMD_WRITE:
574                 /*
575                  * Write data to our 'memory' disk
576                  */
577                 bp->b_error = copyout(bp->b_data, base, bp->b_bcount);
578                 break;
579         default:
580                 panic("mfs: bad b_cmd %d\n", bp->b_cmd);
581         }
582         if (bp->b_error)
583                 bp->b_flags |= B_ERROR;
584         biodone(bio);
585 }