sys/vfs/hammer2/hammer2_freemap.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/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/fcntl.h>
  39 #include <sys/buf.h>
  40 #include <sys/proc.h>
  41 #include <sys/namei.h>
  42 #include <sys/mount.h>
  43 #include <sys/vnode.h>
  44 #include <sys/mountctl.h>
  45
  46 #include "hammer2.h"
  47
  48 /*
  49  * Allocate media space, returning a combined data offset and radix.
  50  *
  51  * XXX when diving a new full block create a clean empty buffer and bqrelse()
  52  *     it, so small data structures do not have to issue read-IO when they
  53  *     do the read-modify-write on the backing store.
  54  */
  55 hammer2_off_t
  56 hammer2_freemap_alloc(hammer2_mount_t *hmp, int type, size_t bytes)
  57 {
  58         hammer2_off_t data_off;
  59         hammer2_off_t data_next;
  60         /*struct buf *bp;*/
  61         int radix;
  62         int fctype;
  63
  64         switch(type) {
  65         case HAMMER2_BREF_TYPE_INODE:
  66                 fctype = HAMMER2_FREECACHE_INODE;
  67                 break;
  68         case HAMMER2_BREF_TYPE_INDIRECT:
  69                 fctype = HAMMER2_FREECACHE_INODE;
  70                 break;
  71         case HAMMER2_BREF_TYPE_DATA:
  72                 fctype = HAMMER2_FREECACHE_DATA;
  73                 break;
  74         default:
  75                 fctype = HAMMER2_FREECACHE_DATA;
  76                 break;
  77         }
  78
  79         /*
  80          * Figure out the base 2 radix of the allocation (rounded up)
  81          */
  82         radix = hammer2_bytes_to_radix(bytes);
  83         bytes = 1 << radix;
  84
  85         lockmgr(&hmp->alloclk, LK_EXCLUSIVE);
  86         if (radix <= HAMMER2_MAX_RADIX && hmp->freecache[fctype][radix]) {
  87                 /*
  88                  * Allocate from our packing cache
  89                  */
  90                 data_off = hmp->freecache[fctype][radix];
  91                 hmp->freecache[fctype][radix] += bytes;
  92                 if ((hmp->freecache[fctype][radix] & HAMMER2_SEGMASK) == 0)
  93                         hmp->freecache[fctype][radix] = 0;
  94         } else {
  95                 /*
  96                  * Allocate from the allocation iterator using a SEGSIZE
  97                  * aligned block and reload the packing cache if possible.
  98                  *
  99                  * Skip reserved areas at the beginning of each zone.
 100                  */
 101                 data_off = hmp->voldata.allocator_beg;
 102                 data_off = (data_off + HAMMER2_SEGMASK64) & ~HAMMER2_SEGMASK64;
 103                 if ((data_off & HAMMER2_ZONE_MASK64) < HAMMER2_ZONE_SEG) {
 104                         KKASSERT((data_off & HAMMER2_ZONE_MASK64) == 0);
 105                         data_off += HAMMER2_ZONE_SEG64;
 106                 }
 107                 data_next = data_off + bytes;
 108
 109                 if ((data_next & HAMMER2_SEGMASK) == 0) {
 110                         hmp->voldata.allocator_beg = data_next;
 111                 } else {
 112                         KKASSERT(radix <= HAMMER2_MAX_RADIX);
 113                         hmp->voldata.allocator_beg =
 114                                         (data_next + HAMMER2_SEGMASK64) &
 115                                         ~HAMMER2_SEGMASK64;
 116                         hmp->freecache[fctype][radix] = data_next;
 117                 }
 118         }
 119         lockmgr(&hmp->alloclk, LK_RELEASE);
 120
 121 #if 0
 122         /*
 123          * Allocations on-media are always in multiples of 64K but
 124          * partial-block allocations can be tracked in-memory.
 125          *
 126          * We can reduce the need for read-modify-write IOs by
 127          * telling the kernel that the contents of a new 64K block is
 128          * initially good (before we use any of it).
 129          *
 130          * Worst case is the kernel evicts the buffer and causes HAMMER2's
 131          * bread later on to actually issue a read I/O.
 132          *
 133          * XXX Maybe do this in SEGSIZE increments? Needs a lot of work.
 134          *     Also watch out for buffer size mismatches.
 135          */
 136         if (bytes < HAMMER2_MINIOSIZE &&
 137             (data_off & (HAMMER2_MINIOSIZE - 1)) == 0) {
 138                 bp = getblk(hmp->devvp, data_off, HAMMER2_MINIOSIZE, 0, 0);
 139                 bp->b_flags |= B_CACHE;
 140                 bp->b_resid = 0;
 141                 bqrelse(bp);
 142         }
 143 #endif
 144
 145         if (hammer2_debug & 0x0001) {
 146                 kprintf("hammer2: allocate %d %016jx: %zd\n",
 147                         type, (intmax_t)data_off, bytes);
 148         }
 149         return (data_off | radix);
 150 }
 151
 152 #if 0
 153 /*
 154  * Allocate media space, returning a combined data offset and radix.
 155  * Also return the related (device) buffer cache buffer.
 156  */
 157 hammer2_off_t
 158 hammer2_freemap_alloc_bp(hammer2_mount_t *hmp, size_t bytes, struct buf **bpp)
 159 {
 160 }
 161
 162 #endif