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