sys/vfs/hammer/hammer_vfsops.c

   1 /*
   2  * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $DragonFly: src/sys/vfs/hammer/hammer_vfsops.c,v 1.10 2007/12/29 09:01:27 dillon Exp $
  35  */
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40 #include <sys/vnode.h>
  41 #include <sys/mount.h>
  42 #include <sys/malloc.h>
  43 #include <sys/nlookup.h>
  44 #include <sys/fcntl.h>
  45 #include <sys/buf.h>
  46 #include <sys/buf2.h>
  47 #include "hammer.h"
  48
  49 /*
  50  * VFS ABI
  51  */
  52 static void     hammer_free_hmp(struct mount *mp);
  53
  54 static int      hammer_vfs_mount(struct mount *mp, char *path, caddr_t data,
  55                                 struct ucred *cred);
  56 static int      hammer_vfs_unmount(struct mount *mp, int mntflags);
  57 static int      hammer_vfs_root(struct mount *mp, struct vnode **vpp);
  58 static int      hammer_vfs_statfs(struct mount *mp, struct statfs *sbp,
  59                                 struct ucred *cred);
  60 static int      hammer_vfs_sync(struct mount *mp, int waitfor);
  61 static int      hammer_vfs_init(struct vfsconf *conf);
  62
  63 static struct vfsops hammer_vfsops = {
  64         .vfs_mount      = hammer_vfs_mount,
  65         .vfs_unmount    = hammer_vfs_unmount,
  66         .vfs_root       = hammer_vfs_root,
  67         .vfs_statfs     = hammer_vfs_statfs,
  68         .vfs_sync       = hammer_vfs_sync,
  69         .vfs_vget       = hammer_vfs_vget,
  70         .vfs_init       = hammer_vfs_init
  71 };
  72
  73 MALLOC_DEFINE(M_HAMMER, "hammer-mount", "hammer mount");
  74
  75 VFS_SET(hammer_vfsops, hammer, 0);
  76 MODULE_VERSION(hammer, 1);
  77
  78 static int
  79 hammer_vfs_init(struct vfsconf *conf)
  80 {
  81         hammer_init_alist_config();
  82         return(0);
  83 }
  84
  85 static int
  86 hammer_vfs_mount(struct mount *mp, char *mntpt, caddr_t data,
  87                  struct ucred *cred)
  88 {
  89         struct hammer_mount_info info;
  90         hammer_mount_t hmp;
  91         hammer_volume_t rootvol;
  92         struct vnode *rootvp;
  93         const char *upath;      /* volume name in userspace */
  94         char *path;             /* volume name in system space */
  95         int error;
  96         int i;
  97
  98         if ((error = copyin(data, &info, sizeof(info))) != 0)
  99                 return (error);
 100         if (info.nvolumes <= 0 || info.nvolumes >= 32768)
 101                 return (EINVAL);
 102
 103         /*
 104          * Interal mount data structure
 105          */
 106         if (mp->mnt_flag & MNT_UPDATE) {
 107                 hmp = (void *)mp->mnt_data;
 108                 KKASSERT(hmp != NULL);
 109         } else {
 110                 hmp = kmalloc(sizeof(*hmp), M_HAMMER, M_WAITOK | M_ZERO);
 111                 mp->mnt_data = (qaddr_t)hmp;
 112                 hmp->mp = mp;
 113                 hmp->zbuf = kmalloc(HAMMER_BUFSIZE, M_HAMMER, M_WAITOK|M_ZERO);
 114                 hmp->namekey_iterator = mycpu->gd_time_seconds;
 115         }
 116         hmp->hflags = info.hflags;
 117         if (info.asof) {
 118                 mp->mnt_flag |= MNT_RDONLY;
 119                 hmp->asof = info.asof;
 120         } else {
 121                 hmp->asof = HAMMER_MAX_TID;
 122         }
 123
 124         /*
 125          * Re-open read-write if originally read-only, or vise-versa XXX
 126          */
 127         if (mp->mnt_flag & MNT_UPDATE) {
 128                 if (hmp->ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
 129                         kprintf("HAMMER read-write -> read-only XXX\n");
 130                         hmp->ronly = 1;
 131                 } else if (hmp->ronly && (mp->mnt_flag & MNT_RDONLY) == 0) {
 132                         kprintf("HAMMER read-only -> read-write XXX\n");
 133                         hmp->ronly = 0;
 134                 }
 135                 return(0);
 136         }
 137
 138         RB_INIT(&hmp->rb_vols_root);
 139         RB_INIT(&hmp->rb_inos_root);
 140         hmp->ronly = ((mp->mnt_flag & MNT_RDONLY) != 0);
 141
 142         /*
 143          * Load volumes
 144          */
 145         path = objcache_get(namei_oc, M_WAITOK);
 146         hmp->nvolumes = info.nvolumes;
 147         for (i = 0; i < info.nvolumes; ++i) {
 148                 error = copyin(&info.volumes[i], &upath, sizeof(char *));
 149                 if (error == 0)
 150                         error = copyinstr(upath, path, MAXPATHLEN, NULL);
 151                 if (error == 0)
 152                         error = hammer_install_volume(hmp, path);
 153                 if (error)
 154                         break;
 155         }
 156         objcache_put(namei_oc, path);
 157
 158         /*
 159          * Make sure we found a root volume
 160          */
 161         if (error == 0 && hmp->rootvol == NULL) {
 162                 kprintf("hammer_mount: No root volume found!\n");
 163                 error = EINVAL;
 164         }
 165         if (error == 0 && hmp->rootcl == NULL) {
 166                 kprintf("hammer_mount: No root cluster found!\n");
 167                 error = EINVAL;
 168         }
 169         if (error) {
 170                 hammer_free_hmp(mp);
 171                 return (error);
 172         }
 173
 174         /*
 175          * No errors, setup enough of the mount point so we can lookup the
 176          * root vnode.
 177          */
 178         mp->mnt_iosize_max = MAXPHYS;
 179         mp->mnt_kern_flag |= MNTK_FSMID;
 180         mp->mnt_stat.f_fsid.val[0] = 0; /* XXX */
 181         mp->mnt_stat.f_fsid.val[1] = 0; /* XXX */
 182
 183         /*
 184          * note: f_iosize is used by vnode_pager_haspage() when constructing
 185          * its VOP_BMAP call.
 186          */
 187         mp->mnt_stat.f_iosize = HAMMER_BUFSIZE;
 188         mp->mnt_stat.f_bsize = HAMMER_BUFSIZE;
 189         vfs_getnewfsid(mp);             /* XXX */
 190         mp->mnt_maxsymlinklen = 255;
 191         mp->mnt_flag |= MNT_LOCAL;
 192
 193         vfs_add_vnodeops(mp, &hammer_vnode_vops, &mp->mnt_vn_norm_ops);
 194
 195         /*
 196          * The root volume's ondisk pointer is only valid if we hold a
 197          * reference to it.
 198          */
 199         rootvol = hammer_get_root_volume(hmp, &error);
 200         if (error)
 201                 goto done;
 202         ksnprintf(mp->mnt_stat.f_mntfromname,
 203                   sizeof(mp->mnt_stat.f_mntfromname), "%s",
 204                   rootvol->ondisk->vol_name);
 205         hammer_rel_volume(rootvol, 0);
 206
 207         /*
 208          * Locate the root directory using the root cluster's B-Tree as a
 209          * starting point.  The root directory uses an obj_id of 1.
 210          *
 211          * FUTURE: Leave the root directory cached referenced but unlocked
 212          * in hmp->rootvp (need to flush it on unmount).
 213          */
 214         error = hammer_vfs_vget(mp, 1, &rootvp);
 215         if (error)
 216                 goto done;
 217         vput(rootvp);
 218         /*vn_unlock(hmp->rootvp);*/
 219
 220 done:
 221         /*
 222          * Cleanup and return.
 223          */
 224         if (error)
 225                 hammer_free_hmp(mp);
 226         return (error);
 227 }
 228
 229 static int
 230 hammer_vfs_unmount(struct mount *mp, int mntflags)
 231 {
 232 #if 0
 233         struct hammer_mount *hmp = (void *)mp->mnt_data;
 234 #endif
 235         int flags;
 236         int error;
 237
 238         /*
 239          * Clean out the vnodes
 240          */
 241         flags = 0;
 242         if (mntflags & MNT_FORCE)
 243                 flags |= FORCECLOSE;
 244         if ((error = vflush(mp, 0, flags)) != 0)
 245                 return (error);
 246
 247         /*
 248          * Clean up the internal mount structure and related entities.  This
 249          * may issue I/O.
 250          */
 251         hammer_free_hmp(mp);
 252         return(0);
 253 }
 254
 255 /*
 256  * Clean up the internal mount structure and disassociate it from the mount.
 257  * This may issue I/O.
 258  */
 259 static void
 260 hammer_free_hmp(struct mount *mp)
 261 {
 262         struct hammer_mount *hmp = (void *)mp->mnt_data;
 263
 264 #if 0
 265         /*
 266          * Clean up the root vnode
 267          */
 268         if (hmp->rootvp) {
 269                 vrele(hmp->rootvp);
 270                 hmp->rootvp = NULL;
 271         }
 272 #endif
 273
 274         /*
 275          * Unload & flush inodes
 276          */
 277         RB_SCAN(hammer_ino_rb_tree, &hmp->rb_inos_root, NULL,
 278                 hammer_unload_inode, NULL);
 279
 280         /*
 281          * Unload & flush volumes
 282          */
 283         RB_SCAN(hammer_vol_rb_tree, &hmp->rb_vols_root, NULL,
 284                 hammer_unload_volume, NULL);
 285
 286         mp->mnt_data = NULL;
 287         mp->mnt_flag &= ~MNT_LOCAL;
 288         hmp->mp = NULL;
 289         kfree(hmp->zbuf, M_HAMMER);
 290         kfree(hmp, M_HAMMER);
 291 }
 292
 293 /*
 294  * Return the root vnode for the filesystem.
 295  *
 296  * HAMMER stores the root vnode in the hammer_mount structure so
 297  * getting it is easy.
 298  */
 299 static int
 300 hammer_vfs_root(struct mount *mp, struct vnode **vpp)
 301 {
 302         struct hammer_mount *hmp = (void *)mp->mnt_data;
 303         int error;
 304
 305         if (hmp->rootcl == NULL)
 306                 error = EIO;
 307         else
 308                 error = hammer_vfs_vget(mp, 1, vpp);
 309         return (error);
 310 #if 0
 311         /* FUTURE - cached root vnode */
 312         if ((vp = hmp->rootvp) != NULL) {
 313                 vref(vp);
 314                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 315                 *vpp = vp;
 316                 return (0);
 317         } else {
 318                 *vpp = NULL;
 319                 return (EIO);
 320         }
 321 #endif
 322 }
 323
 324 static int
 325 hammer_vfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 326 {
 327         struct hammer_mount *hmp = (void *)mp->mnt_data;
 328         hammer_volume_t volume;
 329         hammer_volume_ondisk_t ondisk;
 330         int error;
 331
 332         volume = hammer_get_root_volume(hmp, &error);
 333         if (error)
 334                 return(error);
 335
 336         ondisk = volume->ondisk;
 337
 338         mp->mnt_stat.f_bfree = mp->mnt_stat.f_blocks -
 339                                 ondisk->vol0_stat_idx_bufs -
 340                                 ondisk->vol0_stat_rec_bufs -
 341                                 ondisk->vol0_stat_data_bufs;
 342         if (mp->mnt_stat.f_bfree < 0)
 343                 mp->mnt_stat.f_bfree = 0;
 344         mp->mnt_stat.f_bavail = mp->mnt_stat.f_bfree;
 345         mp->mnt_stat.f_files = ondisk->vol0_stat_inodes;
 346         if (mp->mnt_stat.f_files < 0)
 347                 mp->mnt_stat.f_files = 0;
 348
 349         hammer_rel_volume(volume, 0);
 350         *sbp = mp->mnt_stat;
 351         return(0);
 352 }
 353
 354 static int
 355 hammer_vfs_sync(struct mount *mp, int waitfor)
 356 {
 357         struct hammer_mount *hmp = (void *)mp->mnt_data;
 358         int error;
 359
 360         error = hammer_sync_hmp(hmp, waitfor);
 361         return(error);
 362 }
 363