module/zfs/vdev_indirect_births.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * This file and its contents are supplied under the terms of the
   5  * Common Development and Distribution License ("CDDL"), version 1.0.
   6  * You may only use this file in accordance with the terms of version
   7  * 1.0 of the CDDL.
   8  *
   9  * A full copy of the text of the CDDL should have accompanied this
  10  * source.  A copy of the CDDL is also available via the Internet at
  11  * http://www.illumos.org/license/CDDL.
  12  *
  13  * CDDL HEADER END
  14  */
  15
  16 /*
  17  * Copyright (c) 2015 by Delphix. All rights reserved.
  18  */
  19
  20 #include <sys/dmu_tx.h>
  21 #include <sys/spa.h>
  22 #include <sys/dmu.h>
  23 #include <sys/dsl_pool.h>
  24 #include <sys/vdev_indirect_births.h>
  25
  26 #ifdef ZFS_DEBUG
  27 static boolean_t
  28 vdev_indirect_births_verify(vdev_indirect_births_t *vib)
  29 {
  30         ASSERT(vib != NULL);
  31
  32         ASSERT(vib->vib_object != 0);
  33         ASSERT(vib->vib_objset != NULL);
  34         ASSERT(vib->vib_phys != NULL);
  35         ASSERT(vib->vib_dbuf != NULL);
  36
  37         EQUIV(vib->vib_phys->vib_count > 0, vib->vib_entries != NULL);
  38
  39         return (B_TRUE);
  40 }
  41 #else
  42 #define vdev_indirect_births_verify(vib) ((void) sizeof (vib), B_TRUE)
  43 #endif
  44
  45 uint64_t
  46 vdev_indirect_births_count(vdev_indirect_births_t *vib)
  47 {
  48         ASSERT(vdev_indirect_births_verify(vib));
  49
  50         return (vib->vib_phys->vib_count);
  51 }
  52
  53 uint64_t
  54 vdev_indirect_births_object(vdev_indirect_births_t *vib)
  55 {
  56         ASSERT(vdev_indirect_births_verify(vib));
  57
  58         return (vib->vib_object);
  59 }
  60
  61 static uint64_t
  62 vdev_indirect_births_size_impl(vdev_indirect_births_t *vib)
  63 {
  64         return (vib->vib_phys->vib_count * sizeof (*vib->vib_entries));
  65 }
  66
  67 void
  68 vdev_indirect_births_close(vdev_indirect_births_t *vib)
  69 {
  70         ASSERT(vdev_indirect_births_verify(vib));
  71
  72         if (vib->vib_phys->vib_count > 0) {
  73                 uint64_t births_size = vdev_indirect_births_size_impl(vib);
  74
  75                 vmem_free(vib->vib_entries, births_size);
  76                 vib->vib_entries = NULL;
  77         }
  78
  79         dmu_buf_rele(vib->vib_dbuf, vib);
  80
  81         vib->vib_objset = NULL;
  82         vib->vib_object = 0;
  83         vib->vib_dbuf = NULL;
  84         vib->vib_phys = NULL;
  85
  86         kmem_free(vib, sizeof (*vib));
  87 }
  88
  89 uint64_t
  90 vdev_indirect_births_alloc(objset_t *os, dmu_tx_t *tx)
  91 {
  92         ASSERT(dmu_tx_is_syncing(tx));
  93
  94         return (dmu_object_alloc(os,
  95             DMU_OTN_UINT64_METADATA, SPA_OLD_MAXBLOCKSIZE,
  96             DMU_OTN_UINT64_METADATA, sizeof (vdev_indirect_birth_phys_t),
  97             tx));
  98 }
  99
 100 vdev_indirect_births_t *
 101 vdev_indirect_births_open(objset_t *os, uint64_t births_object)
 102 {
 103         vdev_indirect_births_t *vib = kmem_zalloc(sizeof (*vib), KM_SLEEP);
 104
 105         vib->vib_objset = os;
 106         vib->vib_object = births_object;
 107
 108         VERIFY0(dmu_bonus_hold(os, vib->vib_object, vib, &vib->vib_dbuf));
 109         vib->vib_phys = vib->vib_dbuf->db_data;
 110
 111         if (vib->vib_phys->vib_count > 0) {
 112                 uint64_t births_size = vdev_indirect_births_size_impl(vib);
 113                 vib->vib_entries = vmem_alloc(births_size, KM_SLEEP);
 114                 VERIFY0(dmu_read(vib->vib_objset, vib->vib_object, 0,
 115                     births_size, vib->vib_entries, DMU_READ_PREFETCH));
 116         }
 117
 118         ASSERT(vdev_indirect_births_verify(vib));
 119
 120         return (vib);
 121 }
 122
 123 void
 124 vdev_indirect_births_free(objset_t *os, uint64_t object, dmu_tx_t *tx)
 125 {
 126         VERIFY0(dmu_object_free(os, object, tx));
 127 }
 128
 129 void
 130 vdev_indirect_births_add_entry(vdev_indirect_births_t *vib,
 131     uint64_t max_offset, uint64_t txg, dmu_tx_t *tx)
 132 {
 133         vdev_indirect_birth_entry_phys_t vibe;
 134         uint64_t old_size;
 135         uint64_t new_size;
 136         vdev_indirect_birth_entry_phys_t *new_entries;
 137
 138         ASSERT(dmu_tx_is_syncing(tx));
 139         ASSERT(dsl_pool_sync_context(dmu_tx_pool(tx)));
 140         ASSERT(vdev_indirect_births_verify(vib));
 141
 142         dmu_buf_will_dirty(vib->vib_dbuf, tx);
 143
 144         vibe.vibe_offset = max_offset;
 145         vibe.vibe_phys_birth_txg = txg;
 146
 147         old_size = vdev_indirect_births_size_impl(vib);
 148         dmu_write(vib->vib_objset, vib->vib_object, old_size, sizeof (vibe),
 149             &vibe, tx);
 150         vib->vib_phys->vib_count++;
 151         new_size = vdev_indirect_births_size_impl(vib);
 152
 153         new_entries = vmem_alloc(new_size, KM_SLEEP);
 154         if (old_size > 0) {
 155                 memcpy(new_entries, vib->vib_entries, old_size);
 156                 vmem_free(vib->vib_entries, old_size);
 157         }
 158         new_entries[vib->vib_phys->vib_count - 1] = vibe;
 159         vib->vib_entries = new_entries;
 160 }
 161
 162 uint64_t
 163 vdev_indirect_births_last_entry_txg(vdev_indirect_births_t *vib)
 164 {
 165         ASSERT(vdev_indirect_births_verify(vib));
 166         ASSERT(vib->vib_phys->vib_count > 0);
 167
 168         vdev_indirect_birth_entry_phys_t *last =
 169             &vib->vib_entries[vib->vib_phys->vib_count - 1];
 170         return (last->vibe_phys_birth_txg);
 171 }
 172
 173 /*
 174  * Return the txg in which the given range was copied (i.e. its physical
 175  * birth txg).  The specified offset+asize must be contiguously mapped
 176  * (i.e. not a split block).
 177  *
 178  * The entries are sorted by increasing phys_birth, and also by increasing
 179  * offset.  We find the specified offset by binary search.  Note that we
 180  * can not use bsearch() because looking at each entry independently is
 181  * insufficient to find the correct entry.  Each entry implicitly relies
 182  * on the previous entry: an entry indicates that the offsets from the
 183  * end of the previous entry to the end of this entry were written in the
 184  * specified txg.
 185  */
 186 uint64_t
 187 vdev_indirect_births_physbirth(vdev_indirect_births_t *vib, uint64_t offset,
 188     uint64_t asize)
 189 {
 190         vdev_indirect_birth_entry_phys_t *base;
 191         vdev_indirect_birth_entry_phys_t *last;
 192
 193         ASSERT(vdev_indirect_births_verify(vib));
 194         ASSERT(vib->vib_phys->vib_count > 0);
 195
 196         base = vib->vib_entries;
 197         last = base + vib->vib_phys->vib_count - 1;
 198
 199         ASSERT3U(offset, <, last->vibe_offset);
 200
 201         while (last >= base) {
 202                 vdev_indirect_birth_entry_phys_t *p =
 203                     base + ((last - base) / 2);
 204                 if (offset >= p->vibe_offset) {
 205                         base = p + 1;
 206                 } else if (p == vib->vib_entries ||
 207                     offset >= (p - 1)->vibe_offset) {
 208                         ASSERT3U(offset + asize, <=, p->vibe_offset);
 209                         return (p->vibe_phys_birth_txg);
 210                 } else {
 211                         last = p - 1;
 212                 }
 213         }
 214         ASSERT(!"offset not found");
 215         return (-1);
 216 }
 217
 218 #if defined(_KERNEL)
 219 EXPORT_SYMBOL(vdev_indirect_births_add_entry);
 220 EXPORT_SYMBOL(vdev_indirect_births_alloc);
 221 EXPORT_SYMBOL(vdev_indirect_births_close);
 222 EXPORT_SYMBOL(vdev_indirect_births_count);
 223 EXPORT_SYMBOL(vdev_indirect_births_free);
 224 EXPORT_SYMBOL(vdev_indirect_births_last_entry_txg);
 225 EXPORT_SYMBOL(vdev_indirect_births_object);
 226 EXPORT_SYMBOL(vdev_indirect_births_open);
 227 EXPORT_SYMBOL(vdev_indirect_births_physbirth);
 228 #endif