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.21 2008/02/23 03:01:08 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/sysctl.h>
  46 #include <sys/buf.h>
  47 #include <sys/buf2.h>
  48 #include "hammer.h"
  49
  50 int hammer_debug_general;
  51 int hammer_debug_btree;
  52 int hammer_debug_tid;
  53 int hammer_debug_recover;       /* -1 will disable, +1 will force */
  54 int hammer_debug_recover_faults;
  55 int hammer_count_inodes;
  56 int hammer_count_records;
  57 int hammer_count_record_datas;
  58 int hammer_count_volumes;
  59 int hammer_count_buffers;
  60 int hammer_count_nodes;
  61 int64_t hammer_zone_limit;
  62
  63 SYSCTL_NODE(_vfs, OID_AUTO, hammer, CTLFLAG_RW, 0, "HAMMER filesystem");
  64 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_general, CTLFLAG_RW,
  65            &hammer_debug_general, 0, "");
  66 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_btree, CTLFLAG_RW,
  67            &hammer_debug_btree, 0, "");
  68 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_tid, CTLFLAG_RW,
  69            &hammer_debug_tid, 0, "");
  70 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_recover, CTLFLAG_RW,
  71            &hammer_debug_recover, 0, "");
  72 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_recover_faults, CTLFLAG_RW,
  73            &hammer_debug_recover_faults, 0, "");
  74 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_inodes, CTLFLAG_RD,
  75            &hammer_count_inodes, 0, "");
  76 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_records, CTLFLAG_RD,
  77            &hammer_count_records, 0, "");
  78 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_record_datas, CTLFLAG_RD,
  79            &hammer_count_record_datas, 0, "");
  80 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_volumes, CTLFLAG_RD,
  81            &hammer_count_volumes, 0, "");
  82 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_buffers, CTLFLAG_RD,
  83            &hammer_count_buffers, 0, "");
  84 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_nodes, CTLFLAG_RD,
  85            &hammer_count_nodes, 0, "");
  86 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, zone_limit, CTLFLAG_RW,
  87            &hammer_zone_limit, 0, "");
  88
  89 /*
  90  * VFS ABI
  91  */
  92 static void     hammer_free_hmp(struct mount *mp);
  93
  94 static int      hammer_vfs_mount(struct mount *mp, char *path, caddr_t data,
  95                                 struct ucred *cred);
  96 static int      hammer_vfs_unmount(struct mount *mp, int mntflags);
  97 static int      hammer_vfs_root(struct mount *mp, struct vnode **vpp);
  98 static int      hammer_vfs_statfs(struct mount *mp, struct statfs *sbp,
  99                                 struct ucred *cred);
 100 static int      hammer_vfs_sync(struct mount *mp, int waitfor);
 101 static int      hammer_vfs_vget(struct mount *mp, ino_t ino,
 102                                 struct vnode **vpp);
 103 static int      hammer_vfs_init(struct vfsconf *conf);
 104 static int      hammer_vfs_fhtovp(struct mount *mp, struct fid *fhp,
 105                                 struct vnode **vpp);
 106 static int      hammer_vfs_vptofh(struct vnode *vp, struct fid *fhp);
 107 static int      hammer_vfs_checkexp(struct mount *mp, struct sockaddr *nam,
 108                                 int *exflagsp, struct ucred **credanonp);
 109
 110
 111 static struct vfsops hammer_vfsops = {
 112         .vfs_mount      = hammer_vfs_mount,
 113         .vfs_unmount    = hammer_vfs_unmount,
 114         .vfs_root       = hammer_vfs_root,
 115         .vfs_statfs     = hammer_vfs_statfs,
 116         .vfs_sync       = hammer_vfs_sync,
 117         .vfs_vget       = hammer_vfs_vget,
 118         .vfs_init       = hammer_vfs_init,
 119         .vfs_vptofh     = hammer_vfs_vptofh,
 120         .vfs_fhtovp     = hammer_vfs_fhtovp,
 121         .vfs_checkexp   = hammer_vfs_checkexp
 122 };
 123
 124 MALLOC_DEFINE(M_HAMMER, "hammer-mount", "hammer mount");
 125
 126 VFS_SET(hammer_vfsops, hammer, 0);
 127 MODULE_VERSION(hammer, 1);
 128
 129 static int
 130 hammer_vfs_init(struct vfsconf *conf)
 131 {
 132         /*hammer_init_alist_config();*/
 133         return(0);
 134 }
 135
 136 static int
 137 hammer_vfs_mount(struct mount *mp, char *mntpt, caddr_t data,
 138                  struct ucred *cred)
 139 {
 140         struct hammer_mount_info info;
 141         hammer_mount_t hmp;
 142         hammer_volume_t rootvol;
 143         struct vnode *rootvp;
 144         const char *upath;      /* volume name in userspace */
 145         char *path;             /* volume name in system space */
 146         int error;
 147         int i;
 148
 149         if ((error = copyin(data, &info, sizeof(info))) != 0)
 150                 return (error);
 151         if (info.nvolumes <= 0 || info.nvolumes >= 32768)
 152                 return (EINVAL);
 153
 154         /*
 155          * Interal mount data structure
 156          */
 157         if (mp->mnt_flag & MNT_UPDATE) {
 158                 hmp = (void *)mp->mnt_data;
 159                 KKASSERT(hmp != NULL);
 160         } else {
 161                 hmp = kmalloc(sizeof(*hmp), M_HAMMER, M_WAITOK | M_ZERO);
 162                 mp->mnt_data = (qaddr_t)hmp;
 163                 hmp->mp = mp;
 164                 hmp->zbuf = kmalloc(HAMMER_BUFSIZE, M_HAMMER, M_WAITOK|M_ZERO);
 165                 hmp->namekey_iterator = mycpu->gd_time_seconds;
 166                 /*TAILQ_INIT(&hmp->recycle_list);*/
 167
 168                 hmp->root_btree_beg.obj_id = -0x8000000000000000LL;
 169                 hmp->root_btree_beg.key = -0x8000000000000000LL;
 170                 hmp->root_btree_beg.create_tid = 1;
 171                 hmp->root_btree_beg.delete_tid = 1;
 172                 hmp->root_btree_beg.rec_type = 0;
 173                 hmp->root_btree_beg.obj_type = 0;
 174
 175                 hmp->root_btree_end.obj_id = 0x7FFFFFFFFFFFFFFFLL;
 176                 hmp->root_btree_end.key = 0x7FFFFFFFFFFFFFFFLL;
 177                 hmp->root_btree_end.create_tid = 0xFFFFFFFFFFFFFFFFULL;
 178                 hmp->root_btree_end.delete_tid = 0;   /* special case */
 179                 hmp->root_btree_end.rec_type = 0xFFFFU;
 180                 hmp->root_btree_end.obj_type = 0;
 181                 lockinit(&hmp->blockmap_lock, "blkmap", 0, 0);
 182
 183                 for (i = 0; i < HAMMER_MAX_ZONES; ++i) {
 184                         hmp->zone_limits[i] =
 185                                 HAMMER_ZONE_ENCODE(i, HAMMER_ZONE_LIMIT);
 186                         /*
 187                          * Sysctl override for debugging (force the zone
 188                          * the cycle more quickly then every 2^60 bytes).
 189                          */
 190                         if (hammer_zone_limit) {
 191                                 hmp->zone_limits[i] =
 192                                     HAMMER_ZONE_ENCODE(i, hammer_zone_limit);
 193                         }
 194                 }
 195         }
 196         hmp->hflags = info.hflags;
 197         if (info.asof) {
 198                 mp->mnt_flag |= MNT_RDONLY;
 199                 hmp->asof = info.asof;
 200         } else {
 201                 hmp->asof = HAMMER_MAX_TID;
 202         }
 203
 204         /*
 205          * Re-open read-write if originally read-only, or vise-versa XXX
 206          */
 207         if (mp->mnt_flag & MNT_UPDATE) {
 208                 if (hmp->ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
 209                         kprintf("HAMMER read-write -> read-only XXX\n");
 210                         hmp->ronly = 1;
 211                 } else if (hmp->ronly && (mp->mnt_flag & MNT_RDONLY) == 0) {
 212                         kprintf("HAMMER read-only -> read-write XXX\n");
 213                         hmp->ronly = 0;
 214                 }
 215                 return(0);
 216         }
 217
 218         RB_INIT(&hmp->rb_vols_root);
 219         RB_INIT(&hmp->rb_inos_root);
 220         RB_INIT(&hmp->rb_nods_root);
 221         hmp->ronly = ((mp->mnt_flag & MNT_RDONLY) != 0);
 222
 223         /*
 224          * Load volumes
 225          */
 226         path = objcache_get(namei_oc, M_WAITOK);
 227         hmp->nvolumes = info.nvolumes;
 228         for (i = 0; i < info.nvolumes; ++i) {
 229                 error = copyin(&info.volumes[i], &upath, sizeof(char *));
 230                 if (error == 0)
 231                         error = copyinstr(upath, path, MAXPATHLEN, NULL);
 232                 if (error == 0)
 233                         error = hammer_install_volume(hmp, path);
 234                 if (error)
 235                         break;
 236         }
 237         objcache_put(namei_oc, path);
 238
 239         /*
 240          * Make sure we found a root volume
 241          */
 242         if (error == 0 && hmp->rootvol == NULL) {
 243                 kprintf("hammer_mount: No root volume found!\n");
 244                 error = EINVAL;
 245         }
 246         if (error) {
 247                 hammer_free_hmp(mp);
 248                 return (error);
 249         }
 250
 251         /*
 252          * No errors, setup enough of the mount point so we can lookup the
 253          * root vnode.
 254          */
 255         mp->mnt_iosize_max = MAXPHYS;
 256         mp->mnt_kern_flag |= MNTK_FSMID;
 257
 258         /*
 259          * note: f_iosize is used by vnode_pager_haspage() when constructing
 260          * its VOP_BMAP call.
 261          */
 262         mp->mnt_stat.f_iosize = HAMMER_BUFSIZE;
 263         mp->mnt_stat.f_bsize = HAMMER_BUFSIZE;
 264         mp->mnt_maxsymlinklen = 255;
 265         mp->mnt_flag |= MNT_LOCAL;
 266
 267         vfs_add_vnodeops(mp, &hammer_vnode_vops, &mp->mnt_vn_norm_ops);
 268         vfs_add_vnodeops(mp, &hammer_spec_vops, &mp->mnt_vn_spec_ops);
 269         vfs_add_vnodeops(mp, &hammer_fifo_vops, &mp->mnt_vn_fifo_ops);
 270
 271         /*
 272          * The root volume's ondisk pointer is only valid if we hold a
 273          * reference to it.
 274          */
 275         rootvol = hammer_get_root_volume(hmp, &error);
 276         if (error)
 277                 goto done;
 278         ksnprintf(mp->mnt_stat.f_mntfromname,
 279                   sizeof(mp->mnt_stat.f_mntfromname), "%s",
 280                   rootvol->ondisk->vol_name);
 281         mp->mnt_stat.f_fsid.val[0] =
 282                 crc32((char *)&rootvol->ondisk->vol_fsid + 0, 8);
 283         mp->mnt_stat.f_fsid.val[1] =
 284                 crc32((char *)&rootvol->ondisk->vol_fsid + 8, 8);
 285         hammer_rel_volume(rootvol, 0);
 286
 287         /*
 288          * Locate the root directory using the root cluster's B-Tree as a
 289          * starting point.  The root directory uses an obj_id of 1.
 290          *
 291          * FUTURE: Leave the root directory cached referenced but unlocked
 292          * in hmp->rootvp (need to flush it on unmount).
 293          */
 294         error = hammer_vfs_vget(mp, 1, &rootvp);
 295         if (error)
 296                 goto done;
 297         vput(rootvp);
 298         /*vn_unlock(hmp->rootvp);*/
 299
 300 done:
 301         /*
 302          * Cleanup and return.
 303          */
 304         if (error)
 305                 hammer_free_hmp(mp);
 306         return (error);
 307 }
 308
 309 static int
 310 hammer_vfs_unmount(struct mount *mp, int mntflags)
 311 {
 312 #if 0
 313         struct hammer_mount *hmp = (void *)mp->mnt_data;
 314 #endif
 315         int flags;
 316         int error;
 317
 318         /*
 319          * Clean out the vnodes
 320          */
 321         flags = 0;
 322         if (mntflags & MNT_FORCE)
 323                 flags |= FORCECLOSE;
 324         if ((error = vflush(mp, 0, flags)) != 0)
 325                 return (error);
 326
 327         /*
 328          * Clean up the internal mount structure and related entities.  This
 329          * may issue I/O.
 330          */
 331         hammer_free_hmp(mp);
 332         return(0);
 333 }
 334
 335 /*
 336  * Clean up the internal mount structure and disassociate it from the mount.
 337  * This may issue I/O.
 338  */
 339 static void
 340 hammer_free_hmp(struct mount *mp)
 341 {
 342         struct hammer_mount *hmp = (void *)mp->mnt_data;
 343
 344 #if 0
 345         /*
 346          * Clean up the root vnode
 347          */
 348         if (hmp->rootvp) {
 349                 vrele(hmp->rootvp);
 350                 hmp->rootvp = NULL;
 351         }
 352 #endif
 353
 354         /*
 355          * Unload & flush inodes
 356          */
 357         RB_SCAN(hammer_ino_rb_tree, &hmp->rb_inos_root, NULL,
 358                 hammer_unload_inode, (void *)MNT_WAIT);
 359
 360         /*
 361          * Unload & flush volumes
 362          */
 363         RB_SCAN(hammer_vol_rb_tree, &hmp->rb_vols_root, NULL,
 364                 hammer_unload_volume, NULL);
 365
 366         mp->mnt_data = NULL;
 367         mp->mnt_flag &= ~MNT_LOCAL;
 368         hmp->mp = NULL;
 369         kfree(hmp->zbuf, M_HAMMER);
 370         lockuninit(&hmp->blockmap_lock);
 371         kfree(hmp, M_HAMMER);
 372 }
 373
 374 /*
 375  * Obtain a vnode for the specified inode number.  An exclusively locked
 376  * vnode is returned.
 377  */
 378 int
 379 hammer_vfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
 380 {
 381         struct hammer_mount *hmp = (void *)mp->mnt_data;
 382         struct hammer_inode *ip;
 383         int error;
 384
 385         /*
 386          * Get/allocate the hammer_inode structure.  The structure must be
 387          * unlocked while we manipulate the related vnode to avoid a
 388          * deadlock.
 389          */
 390         ip = hammer_get_inode(hmp, NULL, ino, hmp->asof, 0, &error);
 391         if (ip == NULL) {
 392                 *vpp = NULL;
 393                 return(error);
 394         }
 395         error = hammer_get_vnode(ip, LK_EXCLUSIVE, vpp);
 396         hammer_rel_inode(ip, 0);
 397         return (error);
 398 }
 399
 400 /*
 401  * Return the root vnode for the filesystem.
 402  *
 403  * HAMMER stores the root vnode in the hammer_mount structure so
 404  * getting it is easy.
 405  */
 406 static int
 407 hammer_vfs_root(struct mount *mp, struct vnode **vpp)
 408 {
 409 #if 0
 410         struct hammer_mount *hmp = (void *)mp->mnt_data;
 411 #endif
 412         int error;
 413
 414         error = hammer_vfs_vget(mp, 1, vpp);
 415         return (error);
 416 }
 417
 418 static int
 419 hammer_vfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
 420 {
 421         struct hammer_mount *hmp = (void *)mp->mnt_data;
 422         hammer_volume_t volume;
 423         hammer_volume_ondisk_t ondisk;
 424         int error;
 425         int64_t bfree;
 426
 427         volume = hammer_get_root_volume(hmp, &error);
 428         if (error)
 429                 return(error);
 430         ondisk = volume->ondisk;
 431
 432         /*
 433          * Basic stats
 434          */
 435         mp->mnt_stat.f_files = ondisk->vol0_stat_inodes;
 436         bfree = ondisk->vol0_stat_freebigblocks * HAMMER_LARGEBLOCK_SIZE;
 437         hammer_rel_volume(volume, 0);
 438
 439         mp->mnt_stat.f_bfree = bfree / HAMMER_BUFSIZE;
 440         mp->mnt_stat.f_bavail = mp->mnt_stat.f_bfree;
 441         if (mp->mnt_stat.f_files < 0)
 442                 mp->mnt_stat.f_files = 0;
 443
 444         *sbp = mp->mnt_stat;
 445         return(0);
 446 }
 447
 448 static int
 449 hammer_vfs_sync(struct mount *mp, int waitfor)
 450 {
 451         struct hammer_mount *hmp = (void *)mp->mnt_data;
 452         int error;
 453
 454         error = hammer_sync_hmp(hmp, waitfor);
 455         return(error);
 456 }
 457
 458 /*
 459  * Convert a vnode to a file handle.
 460  */
 461 static int
 462 hammer_vfs_vptofh(struct vnode *vp, struct fid *fhp)
 463 {
 464         hammer_inode_t ip;
 465
 466         KKASSERT(MAXFIDSZ >= 16);
 467         ip = VTOI(vp);
 468         fhp->fid_len = offsetof(struct fid, fid_data[16]);
 469         fhp->fid_reserved = 0;
 470         bcopy(&ip->obj_id, fhp->fid_data + 0, sizeof(ip->obj_id));
 471         bcopy(&ip->obj_asof, fhp->fid_data + 8, sizeof(ip->obj_asof));
 472         return(0);
 473 }
 474
 475
 476 /*
 477  * Convert a file handle back to a vnode.
 478  */
 479 static int
 480 hammer_vfs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
 481 {
 482         struct hammer_mount *hmp = (void *)mp->mnt_data;
 483         struct hammer_inode *ip;
 484         struct hammer_inode_info info;
 485         int error;
 486
 487         bcopy(fhp->fid_data + 0, &info.obj_id, sizeof(info.obj_id));
 488         bcopy(fhp->fid_data + 8, &info.obj_asof, sizeof(info.obj_asof));
 489
 490         /*
 491          * Get/allocate the hammer_inode structure.  The structure must be
 492          * unlocked while we manipulate the related vnode to avoid a
 493          * deadlock.
 494          */
 495         ip = hammer_get_inode(hmp, NULL, info.obj_id, info.obj_asof, 0, &error);
 496         if (ip == NULL) {
 497                 *vpp = NULL;
 498                 return(error);
 499         }
 500         error = hammer_get_vnode(ip, LK_EXCLUSIVE, vpp);
 501         hammer_rel_inode(ip, 0);
 502         return (error);
 503 }
 504
 505 static int
 506 hammer_vfs_checkexp(struct mount *mp, struct sockaddr *nam,
 507                     int *exflagsp, struct ucred **credanonp)
 508 {
 509         hammer_mount_t hmp = (void *)mp->mnt_data;
 510         struct netcred *np;
 511         int error;
 512
 513         np = vfs_export_lookup(mp, &hmp->export, nam);
 514         if (np) {
 515                 *exflagsp = np->netc_exflags;
 516                 *credanonp = &np->netc_anon;
 517                 error = 0;
 518         } else {
 519                 error = EACCES;
 520         }
 521         return (error);
 522
 523 }
 524
 525 int
 526 hammer_vfs_export(struct mount *mp, int op, const struct export_args *export)
 527 {
 528         hammer_mount_t hmp = (void *)mp->mnt_data;
 529         int error;
 530
 531         switch(op) {
 532         case MOUNTCTL_SET_EXPORT:
 533                 error = vfs_export(mp, &hmp->export, export);
 534                 break;
 535         default:
 536                 error = EOPNOTSUPP;
 537                 break;
 538         }
 539         return(error);
 540 }
 541