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 static boolean_t 27 vdev_indirect_births_verify(vdev_indirect_births_t *vib) 28 { 29 ASSERT(vib != NULL); 30 31 ASSERT(vib->vib_object != 0); 32 ASSERT(vib->vib_objset != NULL); 33 ASSERT(vib->vib_phys != NULL); 34 ASSERT(vib->vib_dbuf != NULL); 35 36 EQUIV(vib->vib_phys->vib_count > 0, vib->vib_entries != NULL); 37 38 return (B_TRUE); 39 } 40 41 uint64_t 42 vdev_indirect_births_count(vdev_indirect_births_t *vib) 43 { 44 ASSERT(vdev_indirect_births_verify(vib)); 45 46 return (vib->vib_phys->vib_count); 47 } 48 49 uint64_t 50 vdev_indirect_births_object(vdev_indirect_births_t *vib) 51 { 52 ASSERT(vdev_indirect_births_verify(vib)); 53 54 return (vib->vib_object); 55 } 56 57 static uint64_t 58 vdev_indirect_births_size_impl(vdev_indirect_births_t *vib) 59 { 60 return (vib->vib_phys->vib_count * sizeof (*vib->vib_entries)); 61 } 62 63 void 64 vdev_indirect_births_close(vdev_indirect_births_t *vib) 65 { 66 ASSERT(vdev_indirect_births_verify(vib)); 67 68 if (vib->vib_phys->vib_count > 0) { 69 uint64_t births_size = vdev_indirect_births_size_impl(vib); 70 71 kmem_free(vib->vib_entries, births_size); 72 vib->vib_entries = NULL; 73 } 74 75 dmu_buf_rele(vib->vib_dbuf, vib); 76 77 vib->vib_objset = NULL; 78 vib->vib_object = 0; 79 vib->vib_dbuf = NULL; 80 vib->vib_phys = NULL; 81 82 kmem_free(vib, sizeof (*vib)); 83 } 84 85 uint64_t 86 vdev_indirect_births_alloc(objset_t *os, dmu_tx_t *tx) 87 { 88 ASSERT(dmu_tx_is_syncing(tx)); 89 90 return (dmu_object_alloc(os, 91 DMU_OTN_UINT64_METADATA, SPA_OLD_MAXBLOCKSIZE, 92 DMU_OTN_UINT64_METADATA, sizeof (vdev_indirect_birth_phys_t), 93 tx)); 94 } 95 96 vdev_indirect_births_t * 97 vdev_indirect_births_open(objset_t *os, uint64_t births_object) 98 { 99 vdev_indirect_births_t *vib = kmem_zalloc(sizeof (*vib), KM_SLEEP); 100 101 vib->vib_objset = os; 102 vib->vib_object = births_object; 103 104 VERIFY0(dmu_bonus_hold(os, vib->vib_object, vib, &vib->vib_dbuf)); 105 vib->vib_phys = vib->vib_dbuf->db_data; 106 107 if (vib->vib_phys->vib_count > 0) { 108 uint64_t births_size = vdev_indirect_births_size_impl(vib); 109 vib->vib_entries = kmem_alloc(births_size, KM_SLEEP); 110 VERIFY0(dmu_read(vib->vib_objset, vib->vib_object, 0, 111 births_size, vib->vib_entries, DMU_READ_PREFETCH)); 112 } 113 114 ASSERT(vdev_indirect_births_verify(vib)); 115 116 return (vib); 117 } 118 119 void 120 vdev_indirect_births_free(objset_t *os, uint64_t object, dmu_tx_t *tx) 121 { 122 VERIFY0(dmu_object_free(os, object, tx)); 123 } 124 125 void 126 vdev_indirect_births_add_entry(vdev_indirect_births_t *vib, 127 uint64_t max_offset, uint64_t txg, dmu_tx_t *tx) 128 { 129 vdev_indirect_birth_entry_phys_t vibe; 130 uint64_t old_size; 131 uint64_t new_size; 132 vdev_indirect_birth_entry_phys_t *new_entries; 133 134 ASSERT(dmu_tx_is_syncing(tx)); 135 ASSERT(dsl_pool_sync_context(dmu_tx_pool(tx))); 136 ASSERT(vdev_indirect_births_verify(vib)); 137 138 dmu_buf_will_dirty(vib->vib_dbuf, tx); 139 140 vibe.vibe_offset = max_offset; 141 vibe.vibe_phys_birth_txg = txg; 142 143 old_size = vdev_indirect_births_size_impl(vib); 144 dmu_write(vib->vib_objset, vib->vib_object, old_size, sizeof (vibe), 145 &vibe, tx); 146 vib->vib_phys->vib_count++; 147 new_size = vdev_indirect_births_size_impl(vib); 148 149 new_entries = kmem_alloc(new_size, KM_SLEEP); 150 if (old_size > 0) { 151 bcopy(vib->vib_entries, new_entries, old_size); 152 kmem_free(vib->vib_entries, old_size); 153 } 154 new_entries[vib->vib_phys->vib_count - 1] = vibe; 155 vib->vib_entries = new_entries; 156 } 157 158 uint64_t 159 vdev_indirect_births_last_entry_txg(vdev_indirect_births_t *vib) 160 { 161 ASSERT(vdev_indirect_births_verify(vib)); 162 ASSERT(vib->vib_phys->vib_count > 0); 163 164 vdev_indirect_birth_entry_phys_t *last = 165 &vib->vib_entries[vib->vib_phys->vib_count - 1]; 166 return (last->vibe_phys_birth_txg); 167 } 168 169 /* 170 * Return the txg in which the given range was copied (i.e. its physical 171 * birth txg). The specified offset+asize must be contiguously mapped 172 * (i.e. not a split block). 173 * 174 * The entries are sorted by increasing phys_birth, and also by increasing 175 * offset. We find the specified offset by binary search. Note that we 176 * can not use bsearch() because looking at each entry independently is 177 * insufficient to find the correct entry. Each entry implicitly relies 178 * on the previous entry: an entry indicates that the offsets from the 179 * end of the previous entry to the end of this entry were written in the 180 * specified txg. 181 */ 182 uint64_t 183 vdev_indirect_births_physbirth(vdev_indirect_births_t *vib, uint64_t offset, 184 uint64_t asize) 185 { 186 vdev_indirect_birth_entry_phys_t *base; 187 vdev_indirect_birth_entry_phys_t *last; 188 189 ASSERT(vdev_indirect_births_verify(vib)); 190 ASSERT(vib->vib_phys->vib_count > 0); 191 192 base = vib->vib_entries; 193 last = base + vib->vib_phys->vib_count - 1; 194 195 ASSERT3U(offset, <, last->vibe_offset); 196 197 while (last >= base) { 198 vdev_indirect_birth_entry_phys_t *p = 199 base + ((last - base) / 2); 200 if (offset >= p->vibe_offset) { 201 base = p + 1; 202 } else if (p == vib->vib_entries || 203 offset >= (p - 1)->vibe_offset) { 204 ASSERT3U(offset + asize, <=, p->vibe_offset); 205 return (p->vibe_phys_birth_txg); 206 } else { 207 last = p - 1; 208 } 209 } 210 ASSERT(!"offset not found"); 211 return (-1); 212 } 213