sys/vfs/hammer2/hammer2_subr.c

   1 /*
   2  * Copyright (c) 2011-2012 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@dragonflybsd.org>
   6  * by Venkatesh Srinivas <vsrinivas@dragonflybsd.org>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  * 3. Neither the name of The DragonFly Project nor the names of its
  19  *    contributors may be used to endorse or promote products derived
  20  *    from this software without specific, prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #include <sys/cdefs.h>
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/types.h>
  39 #include <sys/lock.h>
  40 #include <sys/uuid.h>
  41 #include <sys/dirent.h>
  42
  43 #include "hammer2.h"
  44
  45 /*
  46  * HAMMER2 inode locks
  47  *
  48  * HAMMER2 offers shared locks, update locks, and exclusive locks on inodes.
  49  *
  50  * Shared locks allow concurrent access to an inode's fields, but exclude
  51  * access by concurrent exclusive locks.
  52  *
  53  * Update locks are interesting -- an update lock will be taken after all
  54  * shared locks on an inode are released, but once it is in place, shared
  55  * locks may proceed. The update field is signalled by a busy flag in the
  56  * inode. Only one update lock may be in place at a given time on an inode.
  57  *
  58  * Exclusive locks prevent concurrent access to the inode.
  59  *
  60  * XXX: What do we use each for? How is visibility to the inode controlled?
  61  */
  62
  63
  64 void
  65 hammer2_inode_lock_ex(hammer2_inode_t *ip)
  66 {
  67         hammer2_chain_lock(ip->hmp, &ip->chain, HAMMER2_RESOLVE_ALWAYS);
  68 }
  69
  70 void
  71 hammer2_inode_unlock_ex(hammer2_inode_t *ip)
  72 {
  73         hammer2_chain_unlock(ip->hmp, &ip->chain);
  74 }
  75
  76 void
  77 hammer2_inode_lock_sh(hammer2_inode_t *ip)
  78 {
  79         KKASSERT(ip->chain.refs > 0);
  80         lockmgr(&ip->chain.lk, LK_SHARED);
  81 }
  82
  83 void
  84 hammer2_inode_unlock_sh(hammer2_inode_t *ip)
  85 {
  86         lockmgr(&ip->chain.lk, LK_RELEASE);
  87 }
  88
  89 /*
  90  * Soft-busy an inode.
  91  *
  92  * The inode must be exclusively locked while soft-busying or soft-unbusying
  93  * an inode.  Once busied or unbusied the caller can release the lock.
  94  */
  95 void
  96 hammer2_inode_busy(hammer2_inode_t *ip)
  97 {
  98         if (ip->chain.busy++ == 0)
  99                 hammer2_chain_ref(ip->hmp, &ip->chain);
 100 }
 101
 102 void
 103 hammer2_inode_unbusy(hammer2_inode_t *ip)
 104 {
 105         if (--ip->chain.busy == 0)
 106                 hammer2_chain_drop(ip->hmp, &ip->chain);
 107 }
 108
 109 /*
 110  * Mount-wide locks
 111  */
 112
 113 void
 114 hammer2_mount_exlock(hammer2_mount_t *hmp)
 115 {
 116         lockmgr(&hmp->vchain.lk, LK_EXCLUSIVE);
 117 }
 118
 119 void
 120 hammer2_mount_shlock(hammer2_mount_t *hmp)
 121 {
 122         lockmgr(&hmp->vchain.lk, LK_SHARED);
 123 }
 124
 125 void
 126 hammer2_mount_unlock(hammer2_mount_t *hmp)
 127 {
 128         lockmgr(&hmp->vchain.lk, LK_RELEASE);
 129 }
 130
 131 void
 132 hammer2_voldata_lock(hammer2_mount_t *hmp)
 133 {
 134         lockmgr(&hmp->voldatalk, LK_EXCLUSIVE);
 135 }
 136
 137 void
 138 hammer2_voldata_unlock(hammer2_mount_t *hmp)
 139 {
 140         lockmgr(&hmp->voldatalk, LK_RELEASE);
 141 }
 142
 143 /*
 144  * Return the directory entry type for an inode
 145  */
 146 int
 147 hammer2_get_dtype(hammer2_inode_t *ip)
 148 {
 149         switch(ip->ip_data.type) {
 150         case HAMMER2_OBJTYPE_UNKNOWN:
 151                 return (DT_UNKNOWN);
 152         case HAMMER2_OBJTYPE_DIRECTORY:
 153                 return (DT_DIR);
 154         case HAMMER2_OBJTYPE_REGFILE:
 155                 return (DT_REG);
 156         case HAMMER2_OBJTYPE_FIFO:
 157                 return (DT_FIFO);
 158         case HAMMER2_OBJTYPE_CDEV:      /* not supported */
 159                 return (DT_CHR);
 160         case HAMMER2_OBJTYPE_BDEV:      /* not supported */
 161                 return (DT_BLK);
 162         case HAMMER2_OBJTYPE_SOFTLINK:
 163                 return (DT_LNK);
 164         case HAMMER2_OBJTYPE_HARDLINK:  /* (never directly associated w/vp) */
 165                 return (DT_UNKNOWN);
 166         case HAMMER2_OBJTYPE_SOCKET:
 167                 return (DT_SOCK);
 168         case HAMMER2_OBJTYPE_WHITEOUT:  /* not supported */
 169                 return (DT_UNKNOWN);
 170         default:
 171                 return (DT_UNKNOWN);
 172         }
 173         /* not reached */
 174 }
 175
 176 /*
 177  * Return the directory entry type for an inode
 178  */
 179 int
 180 hammer2_get_vtype(hammer2_inode_t *ip)
 181 {
 182         switch(ip->ip_data.type) {
 183         case HAMMER2_OBJTYPE_UNKNOWN:
 184                 return (VBAD);
 185         case HAMMER2_OBJTYPE_DIRECTORY:
 186                 return (VDIR);
 187         case HAMMER2_OBJTYPE_REGFILE:
 188                 return (VREG);
 189         case HAMMER2_OBJTYPE_FIFO:
 190                 return (VFIFO);
 191         case HAMMER2_OBJTYPE_CDEV:      /* not supported */
 192                 return (VCHR);
 193         case HAMMER2_OBJTYPE_BDEV:      /* not supported */
 194                 return (VBLK);
 195         case HAMMER2_OBJTYPE_SOFTLINK:
 196                 return (VLNK);
 197         case HAMMER2_OBJTYPE_HARDLINK:  /* XXX */
 198                 return (VBAD);
 199         case HAMMER2_OBJTYPE_SOCKET:
 200                 return (VSOCK);
 201         case HAMMER2_OBJTYPE_WHITEOUT:  /* not supported */
 202                 return (DT_UNKNOWN);
 203         default:
 204                 return (DT_UNKNOWN);
 205         }
 206         /* not reached */
 207 }
 208
 209 u_int8_t
 210 hammer2_get_obj_type(enum vtype vtype)
 211 {
 212         switch(vtype) {
 213         case VDIR:
 214                 return(HAMMER2_OBJTYPE_DIRECTORY);
 215         case VREG:
 216                 return(HAMMER2_OBJTYPE_REGFILE);
 217         case VFIFO:
 218                 return(HAMMER2_OBJTYPE_FIFO);
 219         case VSOCK:
 220                 return(HAMMER2_OBJTYPE_SOCKET);
 221         case VCHR:
 222                 return(HAMMER2_OBJTYPE_CDEV);
 223         case VBLK:
 224                 return(HAMMER2_OBJTYPE_BDEV);
 225         case VLNK:
 226                 return(HAMMER2_OBJTYPE_SOFTLINK);
 227         default:
 228                 return(HAMMER2_OBJTYPE_UNKNOWN);
 229         }
 230         /* not reached */
 231 }
 232
 233 /*
 234  * Convert a hammer2 64-bit time to a timespec.
 235  */
 236 void
 237 hammer2_time_to_timespec(u_int64_t xtime, struct timespec *ts)
 238 {
 239         ts->tv_sec = (unsigned long)(xtime / 1000000);
 240         ts->tv_nsec = (unsigned int)(xtime % 1000000) * 1000L;
 241 }
 242
 243 u_int64_t
 244 hammer2_timespec_to_time(struct timespec *ts)
 245 {
 246         u_int64_t xtime;
 247
 248         xtime = (unsigned)(ts->tv_nsec / 1000) +
 249                 (unsigned long)ts->tv_sec * 1000000ULL;
 250         return(xtime);
 251 }
 252
 253 /*
 254  * Convert a uuid to a unix uid or gid
 255  */
 256 u_int32_t
 257 hammer2_to_unix_xid(uuid_t *uuid)
 258 {
 259         return(*(u_int32_t *)&uuid->node[2]);
 260 }
 261
 262 void
 263 hammer2_guid_to_uuid(uuid_t *uuid, u_int32_t guid)
 264 {
 265         bzero(uuid, sizeof(*uuid));
 266         *(u_int32_t *)&uuid->node[2] = guid;
 267 }
 268
 269 /*
 270  * Borrow HAMMER1's directory hash algorithm #1 with a few modifications.
 271  * The filename is split into fields which are hashed separately and then
 272  * added together.
 273  *
 274  * Differences include: bit 63 must be set to 1 for HAMMER2 (HAMMER1 sets
 275  * it to 0), this is because bit63=0 is used for hidden hardlinked inodes.
 276  * (This means we do not need to do a 0-check/or-with-0x100000000 either).
 277  *
 278  * Also, the iscsi crc code is used instead of the old crc32 code.
 279  */
 280 hammer2_key_t
 281 hammer2_dirhash(const unsigned char *name, size_t len)
 282 {
 283         const unsigned char *aname = name;
 284         uint32_t crcx;
 285         uint64_t key;
 286         size_t i;
 287         size_t j;
 288
 289         key = 0;
 290
 291         /*
 292          * m32
 293          */
 294         crcx = 0;
 295         for (i = j = 0; i < len; ++i) {
 296                 if (aname[i] == '.' ||
 297                     aname[i] == '-' ||
 298                     aname[i] == '_' ||
 299                     aname[i] == '~') {
 300                         if (i != j)
 301                                 crcx += hammer2_icrc32(aname + j, i - j);
 302                         j = i + 1;
 303                 }
 304         }
 305         if (i != j)
 306                 crcx += hammer2_icrc32(aname + j, i - j);
 307
 308         /*
 309          * The directory hash utilizes the top 32 bits of the 64-bit key.
 310          * Bit 63 must be set to 1.
 311          */
 312         crcx |= 0x80000000U;
 313         key |= (uint64_t)crcx << 32;
 314
 315         /*
 316          * l16 - crc of entire filename
 317          *
 318          * This crc reduces degenerate hash collision conditions
 319          */
 320         crcx = hammer2_icrc32(aname, len);
 321         crcx = crcx ^ (crcx << 16);
 322         key |= crcx & 0xFFFF0000U;
 323
 324         /*
 325          * Set bit 15.  This allows readdir to strip bit 63 so a positive
 326          * 64-bit cookie/offset can always be returned, and still guarantee
 327          * that the values 0x0000-0x7FFF are available for artificial entries.
 328          * ('.' and '..').
 329          */
 330         key |= 0x8000U;
 331
 332         return (key);
 333 }
 334
 335 /*
 336  * Return the power-of-2 radix greater or equal to
 337  * the specified number of bytes.
 338  *
 339  * Always returns at least HAMMER2_MIN_RADIX (2^6).
 340  */
 341 int
 342 hammer2_bytes_to_radix(size_t bytes)
 343 {
 344         int radix;
 345
 346         if (bytes < HAMMER2_MIN_ALLOC)
 347                 bytes = HAMMER2_MIN_ALLOC;
 348         if (bytes == HAMMER2_PBUFSIZE)
 349                 radix = HAMMER2_PBUFRADIX;
 350         else if (bytes >= 1024)
 351                 radix = 10;
 352         else
 353                 radix = HAMMER2_MIN_RADIX;
 354
 355         while (((size_t)1 << radix) < bytes)
 356                 ++radix;
 357         return (radix);
 358 }
 359
 360 int
 361 hammer2_calc_logical(hammer2_inode_t *ip, hammer2_off_t uoff,
 362                      hammer2_key_t *lbasep, hammer2_key_t *leofp)
 363 {
 364         int radix;
 365
 366         *lbasep = uoff & ~HAMMER2_PBUFMASK64;
 367         *leofp = ip->ip_data.size & ~HAMMER2_PBUFMASK;
 368         KKASSERT(*lbasep <= *leofp);
 369         if (*lbasep == *leofp) {
 370                 radix = hammer2_bytes_to_radix(
 371                                 (size_t)(ip->ip_data.size - *leofp));
 372                 if (radix < HAMMER2_MINALLOCRADIX)
 373                         radix = HAMMER2_MINALLOCRADIX;
 374                 *leofp += 1U << radix;
 375                 return (1U << radix);
 376         } else {
 377                 return (HAMMER2_PBUFSIZE);
 378         }
 379 }
 380
 381 void
 382 hammer2_update_time(uint64_t *timep)
 383 {
 384         struct timeval tv;
 385
 386         getmicrotime(&tv);
 387         *timep = (unsigned long)tv.tv_sec * 1000000 + tv.tv_usec;
 388 }