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 http://www.opensolaris.org/os/licensing. 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 /* 23 * Copyright (c) 2011, 2014 by Delphix. All rights reserved. 24 */ 25 26 #include <sys/arc.h> 27 #include <sys/bptree.h> 28 #include <sys/dmu.h> 29 #include <sys/dmu_objset.h> 30 #include <sys/dmu_tx.h> 31 #include <sys/dmu_traverse.h> 32 #include <sys/dsl_dataset.h> 33 #include <sys/dsl_dir.h> 34 #include <sys/dsl_pool.h> 35 #include <sys/dnode.h> 36 #include <sys/refcount.h> 37 #include <sys/spa.h> 38 39 /* 40 * A bptree is a queue of root block pointers from destroyed datasets. When a 41 * dataset is destroyed its root block pointer is put on the end of the pool's 42 * bptree queue so the dataset's blocks can be freed asynchronously by 43 * dsl_scan_sync. This allows the delete operation to finish without traversing 44 * all the dataset's blocks. 45 * 46 * Note that while bt_begin and bt_end are only ever incremented in this code, 47 * they are effectively reset to 0 every time the entire bptree is freed because 48 * the bptree's object is destroyed and re-created. 49 */ 50 51 struct bptree_args { 52 bptree_phys_t *ba_phys; /* data in bonus buffer, dirtied if freeing */ 53 boolean_t ba_free; /* true if freeing during traversal */ 54 55 bptree_itor_t *ba_func; /* function to call for each blockpointer */ 56 void *ba_arg; /* caller supplied argument to ba_func */ 57 dmu_tx_t *ba_tx; /* caller supplied tx, NULL if not freeing */ 58 } bptree_args_t; 59 60 uint64_t 61 bptree_alloc(objset_t *os, dmu_tx_t *tx) 62 { 63 uint64_t obj; 64 dmu_buf_t *db; 65 bptree_phys_t *bt; 66 67 obj = dmu_object_alloc(os, DMU_OTN_UINT64_METADATA, 68 SPA_OLD_MAXBLOCKSIZE, DMU_OTN_UINT64_METADATA, 69 sizeof (bptree_phys_t), tx); 70 71 /* 72 * Bonus buffer contents are already initialized to 0, but for 73 * readability we make it explicit. 74 */ 75 VERIFY3U(0, ==, dmu_bonus_hold(os, obj, FTAG, &db)); 76 dmu_buf_will_dirty(db, tx); 77 bt = db->db_data; 78 bt->bt_begin = 0; 79 bt->bt_end = 0; 80 bt->bt_bytes = 0; 81 bt->bt_comp = 0; 82 bt->bt_uncomp = 0; 83 dmu_buf_rele(db, FTAG); 84 85 return (obj); 86 } 87 88 int 89 bptree_free(objset_t *os, uint64_t obj, dmu_tx_t *tx) 90 { 91 dmu_buf_t *db; 92 bptree_phys_t *bt; 93 94 VERIFY3U(0, ==, dmu_bonus_hold(os, obj, FTAG, &db)); 95 bt = db->db_data; 96 ASSERT3U(bt->bt_begin, ==, bt->bt_end); 97 ASSERT0(bt->bt_bytes); 98 ASSERT0(bt->bt_comp); 99 ASSERT0(bt->bt_uncomp); 100 dmu_buf_rele(db, FTAG); 101 102 return (dmu_object_free(os, obj, tx)); 103 } 104 105 boolean_t 106 bptree_is_empty(objset_t *os, uint64_t obj) 107 { 108 dmu_buf_t *db; 109 bptree_phys_t *bt; 110 boolean_t rv; 111 112 VERIFY0(dmu_bonus_hold(os, obj, FTAG, &db)); 113 bt = db->db_data; 114 rv = (bt->bt_begin == bt->bt_end); 115 dmu_buf_rele(db, FTAG); 116 return (rv); 117 } 118 119 void 120 bptree_add(objset_t *os, uint64_t obj, blkptr_t *bp, uint64_t birth_txg, 121 uint64_t bytes, uint64_t comp, uint64_t uncomp, dmu_tx_t *tx) 122 { 123 dmu_buf_t *db; 124 bptree_phys_t *bt; 125 bptree_entry_phys_t bte = { 0 }; 126 127 /* 128 * bptree objects are in the pool mos, therefore they can only be 129 * modified in syncing context. Furthermore, this is only modified 130 * by the sync thread, so no locking is necessary. 131 */ 132 ASSERT(dmu_tx_is_syncing(tx)); 133 134 VERIFY3U(0, ==, dmu_bonus_hold(os, obj, FTAG, &db)); 135 bt = db->db_data; 136 137 bte.be_birth_txg = birth_txg; 138 bte.be_bp = *bp; 139 dmu_write(os, obj, bt->bt_end * sizeof (bte), sizeof (bte), &bte, tx); 140 141 dmu_buf_will_dirty(db, tx); 142 bt->bt_end++; 143 bt->bt_bytes += bytes; 144 bt->bt_comp += comp; 145 bt->bt_uncomp += uncomp; 146 dmu_buf_rele(db, FTAG); 147 } 148 149 /* ARGSUSED */ 150 static int 151 bptree_visit_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, 152 const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg) 153 { 154 int err; 155 struct bptree_args *ba = arg; 156 157 if (bp == NULL || BP_IS_HOLE(bp)) 158 return (0); 159 160 err = ba->ba_func(ba->ba_arg, bp, ba->ba_tx); 161 if (err == 0 && ba->ba_free) { 162 ba->ba_phys->bt_bytes -= bp_get_dsize_sync(spa, bp); 163 ba->ba_phys->bt_comp -= BP_GET_PSIZE(bp); 164 ba->ba_phys->bt_uncomp -= BP_GET_UCSIZE(bp); 165 } 166 return (err); 167 } 168 169 /* 170 * If "free" is set: 171 * - It is assumed that "func" will be freeing the block pointers. 172 * - If "func" returns nonzero, the bookmark will be remembered and 173 * iteration will be restarted from this point on next invocation. 174 * - If an i/o error is encountered (e.g. "func" returns EIO or ECKSUM), 175 * bptree_iterate will remember the bookmark, continue traversing 176 * any additional entries, and return 0. 177 * 178 * If "free" is not set, traversal will stop and return an error if 179 * an i/o error is encountered. 180 * 181 * In either case, if zfs_free_leak_on_eio is set, i/o errors will be 182 * ignored and traversal will continue (i.e. TRAVERSE_HARD will be passed to 183 * traverse_dataset_destroyed()). 184 */ 185 int 186 bptree_iterate(objset_t *os, uint64_t obj, boolean_t free, bptree_itor_t func, 187 void *arg, dmu_tx_t *tx) 188 { 189 boolean_t ioerr = B_FALSE; 190 int err; 191 uint64_t i; 192 dmu_buf_t *db; 193 struct bptree_args ba; 194 195 ASSERT(!free || dmu_tx_is_syncing(tx)); 196 197 err = dmu_bonus_hold(os, obj, FTAG, &db); 198 if (err != 0) 199 return (err); 200 201 if (free) 202 dmu_buf_will_dirty(db, tx); 203 204 ba.ba_phys = db->db_data; 205 ba.ba_free = free; 206 ba.ba_func = func; 207 ba.ba_arg = arg; 208 ba.ba_tx = tx; 209 210 err = 0; 211 for (i = ba.ba_phys->bt_begin; i < ba.ba_phys->bt_end; i++) { 212 bptree_entry_phys_t bte; 213 int flags = TRAVERSE_PREFETCH_METADATA | TRAVERSE_POST; 214 215 err = dmu_read(os, obj, i * sizeof (bte), sizeof (bte), 216 &bte, DMU_READ_NO_PREFETCH); 217 if (err != 0) 218 break; 219 220 if (zfs_free_leak_on_eio) 221 flags |= TRAVERSE_HARD; 222 zfs_dbgmsg("bptree index %d: traversing from min_txg=%lld " 223 "bookmark %lld/%lld/%lld/%lld", 224 i, (longlong_t)bte.be_birth_txg, 225 (longlong_t)bte.be_zb.zb_objset, 226 (longlong_t)bte.be_zb.zb_object, 227 (longlong_t)bte.be_zb.zb_level, 228 (longlong_t)bte.be_zb.zb_blkid); 229 err = traverse_dataset_destroyed(os->os_spa, &bte.be_bp, 230 bte.be_birth_txg, &bte.be_zb, flags, 231 bptree_visit_cb, &ba); 232 if (free) { 233 /* 234 * The callback has freed the visited block pointers. 235 * Record our traversal progress on disk, either by 236 * updating this record's bookmark, or by logically 237 * removing this record by advancing bt_begin. 238 */ 239 if (err != 0) { 240 /* save bookmark for future resume */ 241 ASSERT3U(bte.be_zb.zb_objset, ==, 242 ZB_DESTROYED_OBJSET); 243 ASSERT0(bte.be_zb.zb_level); 244 dmu_write(os, obj, i * sizeof (bte), 245 sizeof (bte), &bte, tx); 246 if (err == EIO || err == ECKSUM || 247 err == ENXIO) { 248 /* 249 * Skip the rest of this tree and 250 * continue on to the next entry. 251 */ 252 err = 0; 253 ioerr = B_TRUE; 254 } else { 255 break; 256 } 257 } else if (ioerr) { 258 /* 259 * This entry is finished, but there were 260 * i/o errors on previous entries, so we 261 * can't adjust bt_begin. Set this entry's 262 * be_birth_txg such that it will be 263 * treated as a no-op in future traversals. 264 */ 265 bte.be_birth_txg = UINT64_MAX; 266 dmu_write(os, obj, i * sizeof (bte), 267 sizeof (bte), &bte, tx); 268 } 269 270 if (!ioerr) { 271 ba.ba_phys->bt_begin++; 272 (void) dmu_free_range(os, obj, 273 i * sizeof (bte), sizeof (bte), tx); 274 } 275 } else if (err != 0) { 276 break; 277 } 278 } 279 280 ASSERT(!free || err != 0 || ioerr || 281 ba.ba_phys->bt_begin == ba.ba_phys->bt_end); 282 283 /* if all blocks are free there should be no used space */ 284 if (ba.ba_phys->bt_begin == ba.ba_phys->bt_end) { 285 if (zfs_free_leak_on_eio) { 286 ba.ba_phys->bt_bytes = 0; 287 ba.ba_phys->bt_comp = 0; 288 ba.ba_phys->bt_uncomp = 0; 289 } 290 291 ASSERT0(ba.ba_phys->bt_bytes); 292 ASSERT0(ba.ba_phys->bt_comp); 293 ASSERT0(ba.ba_phys->bt_uncomp); 294 } 295 296 dmu_buf_rele(db, FTAG); 297 298 return (err); 299 } 300