include/sys/space_map.h

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or https://opensource.org/licenses/CDDL-1.0.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*
  27  * Copyright (c) 2012, 2019 by Delphix. All rights reserved.
  28  */
  29
  30 #ifndef _SYS_SPACE_MAP_H
  31 #define _SYS_SPACE_MAP_H
  32
  33 #include <sys/avl.h>
  34 #include <sys/range_tree.h>
  35 #include <sys/dmu.h>
  36
  37 #ifdef  __cplusplus
  38 extern "C" {
  39 #endif
  40
  41 /*
  42  * The size of the space map object has increased to include a histogram.
  43  * The SPACE_MAP_SIZE_V0 designates the original size and is used to
  44  * maintain backward compatibility.
  45  */
  46 #define SPACE_MAP_SIZE_V0       (3 * sizeof (uint64_t))
  47 #define SPACE_MAP_HISTOGRAM_SIZE        32
  48
  49 /*
  50  * The space_map_phys is the on-disk representation of the space map.
  51  * Consumers of space maps should never reference any of the members of this
  52  * structure directly. These members may only be updated in syncing context.
  53  *
  54  * Note the smp_object is no longer used but remains in the structure
  55  * for backward compatibility.
  56  */
  57 typedef struct space_map_phys {
  58         /* object number: not needed but kept for backwards compatibility */
  59         uint64_t        smp_object;
  60
  61         /* length of the object in bytes */
  62         uint64_t        smp_length;
  63
  64         /* space allocated from the map */
  65         int64_t         smp_alloc;
  66
  67         /* reserved */
  68         uint64_t        smp_pad[5];
  69
  70         /*
  71          * The smp_histogram maintains a histogram of free regions. Each
  72          * bucket, smp_histogram[i], contains the number of free regions
  73          * whose size is:
  74          * 2^(i+sm_shift) <= size of free region in bytes < 2^(i+sm_shift+1)
  75          *
  76          * Note that, if log space map feature is enabled, histograms of
  77          * space maps that belong to metaslabs will take into account any
  78          * unflushed changes for their metaslabs, even though the actual
  79          * space map doesn't have entries for these changes.
  80          */
  81         uint64_t        smp_histogram[SPACE_MAP_HISTOGRAM_SIZE];
  82 } space_map_phys_t;
  83
  84 /*
  85  * The space map object defines a region of space, its size, how much is
  86  * allocated, and the on-disk object that stores this information.
  87  * Consumers of space maps may only access the members of this structure.
  88  *
  89  * Note: the space_map may not be accessed concurrently; consumers
  90  * must provide external locking if required.
  91  */
  92 typedef struct space_map {
  93         uint64_t        sm_start;       /* start of map */
  94         uint64_t        sm_size;        /* size of map */
  95         uint8_t         sm_shift;       /* unit shift */
  96         objset_t        *sm_os;         /* objset for this map */
  97         uint64_t        sm_object;      /* object id for this map */
  98         uint32_t        sm_blksz;       /* block size for space map */
  99         dmu_buf_t       *sm_dbuf;       /* space_map_phys_t dbuf */
 100         space_map_phys_t *sm_phys;      /* on-disk space map */
 101 } space_map_t;
 102
 103 /*
 104  * debug entry
 105  *
 106  *     2     2        10                     50
 107  *  +-----+-----+------------+----------------------------------+
 108  *  | 1 0 | act |  syncpass  |        txg (lower bits)          |
 109  *  +-----+-----+------------+----------------------------------+
 110  *   63 62 61 60 59        50 49                                0
 111  *
 112  *
 113  * one-word entry
 114  *
 115  *    1               47                   1           15
 116  *  +-----------------------------------------------------------+
 117  *  | 0 |   offset (sm_shift units)    | type |       run       |
 118  *  +-----------------------------------------------------------+
 119  *   63  62                          16   15   14               0
 120  *
 121  *
 122  * two-word entry
 123  *
 124  *     2     2               36                      24
 125  *  +-----+-----+---------------------------+-------------------+
 126  *  | 1 1 | pad |            run            |       vdev        |
 127  *  +-----+-----+---------------------------+-------------------+
 128  *   63 62 61 60 59                       24 23                 0
 129  *
 130  *     1                            63
 131  *  +------+----------------------------------------------------+
 132  *  | type |                      offset                        |
 133  *  +------+----------------------------------------------------+
 134  *     63   62                                                  0
 135  *
 136  * Note that a two-word entry will not straddle a block boundary.
 137  * If necessary, the last word of a block will be padded with a
 138  * debug entry (with act = syncpass = txg = 0).
 139  */
 140
 141 typedef enum {
 142         SM_ALLOC,
 143         SM_FREE
 144 } maptype_t;
 145
 146 typedef struct space_map_entry {
 147         maptype_t sme_type;
 148         uint32_t sme_vdev;      /* max is 2^24-1; SM_NO_VDEVID if not present */
 149         uint64_t sme_offset;    /* max is 2^63-1; units of sm_shift */
 150         uint64_t sme_run;       /* max is 2^36; units of sm_shift */
 151
 152         /*
 153          * The following fields are not part of the actual space map entry
 154          * on-disk and they are populated with the values from the debug
 155          * entry most recently visited starting from the beginning to the
 156          * end of the space map.
 157          */
 158         uint64_t sme_txg;
 159         uint64_t sme_sync_pass;
 160 } space_map_entry_t;
 161
 162 #define SM_NO_VDEVID    (1 << SPA_VDEVBITS)
 163
 164 /* one-word entry constants */
 165 #define SM_DEBUG_PREFIX 2
 166 #define SM_OFFSET_BITS  47
 167 #define SM_RUN_BITS     15
 168
 169 /* two-word entry constants */
 170 #define SM2_PREFIX      3
 171 #define SM2_OFFSET_BITS 63
 172 #define SM2_RUN_BITS    36
 173
 174 #define SM_PREFIX_DECODE(x)     BF64_DECODE(x, 62, 2)
 175 #define SM_PREFIX_ENCODE(x)     BF64_ENCODE(x, 62, 2)
 176
 177 #define SM_DEBUG_ACTION_DECODE(x)       BF64_DECODE(x, 60, 2)
 178 #define SM_DEBUG_ACTION_ENCODE(x)       BF64_ENCODE(x, 60, 2)
 179 #define SM_DEBUG_SYNCPASS_DECODE(x)     BF64_DECODE(x, 50, 10)
 180 #define SM_DEBUG_SYNCPASS_ENCODE(x)     BF64_ENCODE(x, 50, 10)
 181 #define SM_DEBUG_TXG_DECODE(x)          BF64_DECODE(x, 0, 50)
 182 #define SM_DEBUG_TXG_ENCODE(x)          BF64_ENCODE(x, 0, 50)
 183
 184 #define SM_OFFSET_DECODE(x)     BF64_DECODE(x, 16, SM_OFFSET_BITS)
 185 #define SM_OFFSET_ENCODE(x)     BF64_ENCODE(x, 16, SM_OFFSET_BITS)
 186 #define SM_TYPE_DECODE(x)       BF64_DECODE(x, 15, 1)
 187 #define SM_TYPE_ENCODE(x)       BF64_ENCODE(x, 15, 1)
 188 #define SM_RUN_DECODE(x)        (BF64_DECODE(x, 0, SM_RUN_BITS) + 1)
 189 #define SM_RUN_ENCODE(x)        BF64_ENCODE((x) - 1, 0, SM_RUN_BITS)
 190 #define SM_RUN_MAX              SM_RUN_DECODE(~0ULL)
 191 #define SM_OFFSET_MAX           SM_OFFSET_DECODE(~0ULL)
 192
 193 #define SM2_RUN_DECODE(x)       (BF64_DECODE(x, SPA_VDEVBITS, SM2_RUN_BITS) + 1)
 194 #define SM2_RUN_ENCODE(x)       BF64_ENCODE((x) - 1, SPA_VDEVBITS, SM2_RUN_BITS)
 195 #define SM2_VDEV_DECODE(x)      BF64_DECODE(x, 0, SPA_VDEVBITS)
 196 #define SM2_VDEV_ENCODE(x)      BF64_ENCODE(x, 0, SPA_VDEVBITS)
 197 #define SM2_TYPE_DECODE(x)      BF64_DECODE(x, SM2_OFFSET_BITS, 1)
 198 #define SM2_TYPE_ENCODE(x)      BF64_ENCODE(x, SM2_OFFSET_BITS, 1)
 199 #define SM2_OFFSET_DECODE(x)    BF64_DECODE(x, 0, SM2_OFFSET_BITS)
 200 #define SM2_OFFSET_ENCODE(x)    BF64_ENCODE(x, 0, SM2_OFFSET_BITS)
 201 #define SM2_RUN_MAX             SM2_RUN_DECODE(~0ULL)
 202 #define SM2_OFFSET_MAX          SM2_OFFSET_DECODE(~0ULL)
 203
 204 boolean_t sm_entry_is_debug(uint64_t e);
 205 boolean_t sm_entry_is_single_word(uint64_t e);
 206 boolean_t sm_entry_is_double_word(uint64_t e);
 207
 208 typedef int (*sm_cb_t)(space_map_entry_t *sme, void *arg);
 209
 210 int space_map_load(space_map_t *sm, range_tree_t *rt, maptype_t maptype);
 211 int space_map_load_length(space_map_t *sm, range_tree_t *rt, maptype_t maptype,
 212     uint64_t length);
 213 int space_map_iterate(space_map_t *sm, uint64_t length,
 214     sm_cb_t callback, void *arg);
 215 int space_map_incremental_destroy(space_map_t *sm, sm_cb_t callback, void *arg,
 216     dmu_tx_t *tx);
 217
 218 boolean_t space_map_histogram_verify(space_map_t *sm, range_tree_t *rt);
 219 void space_map_histogram_clear(space_map_t *sm);
 220 void space_map_histogram_add(space_map_t *sm, range_tree_t *rt,
 221     dmu_tx_t *tx);
 222
 223 uint64_t space_map_object(space_map_t *sm);
 224 int64_t space_map_allocated(space_map_t *sm);
 225 uint64_t space_map_length(space_map_t *sm);
 226 uint64_t space_map_entries(space_map_t *sm, range_tree_t *rt);
 227 uint64_t space_map_nblocks(space_map_t *sm);
 228
 229 void space_map_write(space_map_t *sm, range_tree_t *rt, maptype_t maptype,
 230     uint64_t vdev_id, dmu_tx_t *tx);
 231 uint64_t space_map_estimate_optimal_size(space_map_t *sm, range_tree_t *rt,
 232     uint64_t vdev_id);
 233 void space_map_truncate(space_map_t *sm, int blocksize, dmu_tx_t *tx);
 234 uint64_t space_map_alloc(objset_t *os, int blocksize, dmu_tx_t *tx);
 235 void space_map_free(space_map_t *sm, dmu_tx_t *tx);
 236 void space_map_free_obj(objset_t *os, uint64_t smobj, dmu_tx_t *tx);
 237
 238 int space_map_open(space_map_t **smp, objset_t *os, uint64_t object,
 239     uint64_t start, uint64_t size, uint8_t shift);
 240 void space_map_close(space_map_t *sm);
 241
 242 #ifdef  __cplusplus
 243 }
 244 #endif
 245
 246 #endif  /* _SYS_SPACE_MAP_H */