Print this page
2619 asynchronous destruction of ZFS file systems
2747 SPA versioning with zfs feature flags
Reviewed by: Matt Ahrens <mahrens@delphix.com>
Reviewed by: George Wilson <gwilson@delphix.com>
Reviewed by: Richard Lowe <richlowe@richlowe.net>
Reviewed by: Dan Kruchinin <dan.kruchinin@gmail.com>
Approved by: Dan McDonald <danmcd@nexenta.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/zfs/dmu_traverse.c
+++ new/usr/src/uts/common/fs/zfs/dmu_traverse.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 + * Copyright (c) 2012 by Delphix. All rights reserved.
23 24 */
24 25
25 26 #include <sys/zfs_context.h>
26 27 #include <sys/dmu_objset.h>
27 28 #include <sys/dmu_traverse.h>
28 29 #include <sys/dsl_dataset.h>
29 30 #include <sys/dsl_dir.h>
30 31 #include <sys/dsl_pool.h>
31 32 #include <sys/dnode.h>
32 33 #include <sys/spa.h>
33 34 #include <sys/zio.h>
34 35 #include <sys/dmu_impl.h>
35 36 #include <sys/sa.h>
36 37 #include <sys/sa_impl.h>
37 38 #include <sys/callb.h>
38 39
39 40 int zfs_pd_blks_max = 100;
40 41
41 42 typedef struct prefetch_data {
42 43 kmutex_t pd_mtx;
43 44 kcondvar_t pd_cv;
44 45 int pd_blks_max;
45 46 int pd_blks_fetched;
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
46 47 int pd_flags;
47 48 boolean_t pd_cancel;
48 49 boolean_t pd_exited;
49 50 } prefetch_data_t;
50 51
51 52 typedef struct traverse_data {
52 53 spa_t *td_spa;
53 54 uint64_t td_objset;
54 55 blkptr_t *td_rootbp;
55 56 uint64_t td_min_txg;
57 + zbookmark_t *td_resume;
56 58 int td_flags;
57 59 prefetch_data_t *td_pfd;
58 60 blkptr_cb_t *td_func;
59 61 void *td_arg;
60 62 } traverse_data_t;
61 63
62 64 static int traverse_dnode(traverse_data_t *td, const dnode_phys_t *dnp,
63 65 arc_buf_t *buf, uint64_t objset, uint64_t object);
64 66
65 67 static int
66 68 traverse_zil_block(zilog_t *zilog, blkptr_t *bp, void *arg, uint64_t claim_txg)
67 69 {
68 70 traverse_data_t *td = arg;
69 71 zbookmark_t zb;
70 72
71 73 if (bp->blk_birth == 0)
72 74 return (0);
73 75
74 76 if (claim_txg == 0 && bp->blk_birth >= spa_first_txg(td->td_spa))
75 77 return (0);
76 78
77 79 SET_BOOKMARK(&zb, td->td_objset, ZB_ZIL_OBJECT, ZB_ZIL_LEVEL,
78 80 bp->blk_cksum.zc_word[ZIL_ZC_SEQ]);
79 81
80 82 (void) td->td_func(td->td_spa, zilog, bp, NULL, &zb, NULL, td->td_arg);
81 83
82 84 return (0);
83 85 }
84 86
85 87 static int
86 88 traverse_zil_record(zilog_t *zilog, lr_t *lrc, void *arg, uint64_t claim_txg)
87 89 {
88 90 traverse_data_t *td = arg;
89 91
90 92 if (lrc->lrc_txtype == TX_WRITE) {
91 93 lr_write_t *lr = (lr_write_t *)lrc;
92 94 blkptr_t *bp = &lr->lr_blkptr;
93 95 zbookmark_t zb;
94 96
95 97 if (bp->blk_birth == 0)
96 98 return (0);
97 99
98 100 if (claim_txg == 0 || bp->blk_birth < claim_txg)
99 101 return (0);
100 102
101 103 SET_BOOKMARK(&zb, td->td_objset, lr->lr_foid,
102 104 ZB_ZIL_LEVEL, lr->lr_offset / BP_GET_LSIZE(bp));
103 105
104 106 (void) td->td_func(td->td_spa, zilog, bp, NULL, &zb, NULL,
105 107 td->td_arg);
106 108 }
107 109 return (0);
108 110 }
109 111
110 112 static void
111 113 traverse_zil(traverse_data_t *td, zil_header_t *zh)
112 114 {
113 115 uint64_t claim_txg = zh->zh_claim_txg;
114 116 zilog_t *zilog;
115 117
116 118 /*
117 119 * We only want to visit blocks that have been claimed but not yet
118 120 * replayed; plus, in read-only mode, blocks that are already stable.
119 121 */
120 122 if (claim_txg == 0 && spa_writeable(td->td_spa))
|
↓ open down ↓ |
55 lines elided |
↑ open up ↑ |
121 123 return;
122 124
123 125 zilog = zil_alloc(spa_get_dsl(td->td_spa)->dp_meta_objset, zh);
124 126
125 127 (void) zil_parse(zilog, traverse_zil_block, traverse_zil_record, td,
126 128 claim_txg);
127 129
128 130 zil_free(zilog);
129 131 }
130 132
133 +typedef enum resume_skip {
134 + RESUME_SKIP_ALL,
135 + RESUME_SKIP_NONE,
136 + RESUME_SKIP_CHILDREN
137 +} resume_skip_t;
138 +
139 +/*
140 + * Returns RESUME_SKIP_ALL if td indicates that we are resuming a traversal and
141 + * the block indicated by zb does not need to be visited at all. Returns
142 + * RESUME_SKIP_CHILDREN if we are resuming a post traversal and we reach the
143 + * resume point. This indicates that this block should be visited but not its
144 + * children (since they must have been visited in a previous traversal).
145 + * Otherwise returns RESUME_SKIP_NONE.
146 + */
147 +static resume_skip_t
148 +resume_skip_check(traverse_data_t *td, const dnode_phys_t *dnp,
149 + const zbookmark_t *zb)
150 +{
151 + if (td->td_resume != NULL && !ZB_IS_ZERO(td->td_resume)) {
152 + /*
153 + * If we already visited this bp & everything below,
154 + * don't bother doing it again.
155 + */
156 + if (zbookmark_is_before(dnp, zb, td->td_resume))
157 + return (RESUME_SKIP_ALL);
158 +
159 + /*
160 + * If we found the block we're trying to resume from, zero
161 + * the bookmark out to indicate that we have resumed.
162 + */
163 + ASSERT3U(zb->zb_object, <=, td->td_resume->zb_object);
164 + if (bcmp(zb, td->td_resume, sizeof (*zb)) == 0) {
165 + bzero(td->td_resume, sizeof (*zb));
166 + if (td->td_flags & TRAVERSE_POST)
167 + return (RESUME_SKIP_CHILDREN);
168 + }
169 + }
170 + return (RESUME_SKIP_NONE);
171 +}
172 +
173 +static void
174 +traverse_pause(traverse_data_t *td, const zbookmark_t *zb)
175 +{
176 + ASSERT(td->td_resume != NULL);
177 + ASSERT3U(zb->zb_level, ==, 0);
178 + bcopy(zb, td->td_resume, sizeof (*td->td_resume));
179 +}
180 +
131 181 static int
132 182 traverse_visitbp(traverse_data_t *td, const dnode_phys_t *dnp,
133 183 arc_buf_t *pbuf, blkptr_t *bp, const zbookmark_t *zb)
134 184 {
135 185 zbookmark_t czb;
136 186 int err = 0, lasterr = 0;
137 187 arc_buf_t *buf = NULL;
138 188 prefetch_data_t *pd = td->td_pfd;
139 189 boolean_t hard = td->td_flags & TRAVERSE_HARD;
190 + boolean_t pause = B_FALSE;
140 191
141 - if (bp->blk_birth == 0) {
192 + switch (resume_skip_check(td, dnp, zb)) {
193 + case RESUME_SKIP_ALL:
194 + return (0);
195 + case RESUME_SKIP_CHILDREN:
196 + goto post;
197 + case RESUME_SKIP_NONE:
198 + break;
199 + default:
200 + ASSERT(0);
201 + }
202 +
203 + if (BP_IS_HOLE(bp)) {
142 204 err = td->td_func(td->td_spa, NULL, NULL, pbuf, zb, dnp,
143 205 td->td_arg);
144 206 return (err);
145 207 }
146 208
147 209 if (bp->blk_birth <= td->td_min_txg)
148 210 return (0);
149 211
150 212 if (pd && !pd->pd_exited &&
151 213 ((pd->pd_flags & TRAVERSE_PREFETCH_DATA) ||
152 214 BP_GET_TYPE(bp) == DMU_OT_DNODE || BP_GET_LEVEL(bp) > 0)) {
153 215 mutex_enter(&pd->pd_mtx);
154 216 ASSERT(pd->pd_blks_fetched >= 0);
155 217 while (pd->pd_blks_fetched == 0 && !pd->pd_exited)
156 218 cv_wait(&pd->pd_cv, &pd->pd_mtx);
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
157 219 pd->pd_blks_fetched--;
158 220 cv_broadcast(&pd->pd_cv);
159 221 mutex_exit(&pd->pd_mtx);
160 222 }
161 223
162 224 if (td->td_flags & TRAVERSE_PRE) {
163 225 err = td->td_func(td->td_spa, NULL, bp, pbuf, zb, dnp,
164 226 td->td_arg);
165 227 if (err == TRAVERSE_VISIT_NO_CHILDREN)
166 228 return (0);
167 - if (err)
168 - return (err);
229 + if (err == ERESTART)
230 + pause = B_TRUE; /* handle pausing at a common point */
231 + if (err != 0)
232 + goto post;
169 233 }
170 234
171 235 if (BP_GET_LEVEL(bp) > 0) {
172 236 uint32_t flags = ARC_WAIT;
173 237 int i;
174 238 blkptr_t *cbp;
175 239 int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
176 240
177 241 err = dsl_read(NULL, td->td_spa, bp, pbuf,
178 242 arc_getbuf_func, &buf,
179 243 ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
180 244 if (err)
181 245 return (err);
182 246
183 247 /* recursively visitbp() blocks below this */
184 248 cbp = buf->b_data;
185 249 for (i = 0; i < epb; i++, cbp++) {
186 250 SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
187 251 zb->zb_level - 1,
188 252 zb->zb_blkid * epb + i);
189 253 err = traverse_visitbp(td, dnp, buf, cbp, &czb);
190 254 if (err) {
191 255 if (!hard)
192 256 break;
193 257 lasterr = err;
194 258 }
195 259 }
196 260 } else if (BP_GET_TYPE(bp) == DMU_OT_DNODE) {
197 261 uint32_t flags = ARC_WAIT;
198 262 int i;
199 263 int epb = BP_GET_LSIZE(bp) >> DNODE_SHIFT;
200 264
201 265 err = dsl_read(NULL, td->td_spa, bp, pbuf,
202 266 arc_getbuf_func, &buf,
203 267 ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
204 268 if (err)
205 269 return (err);
206 270
207 271 /* recursively visitbp() blocks below this */
208 272 dnp = buf->b_data;
209 273 for (i = 0; i < epb; i++, dnp++) {
210 274 err = traverse_dnode(td, dnp, buf, zb->zb_objset,
211 275 zb->zb_blkid * epb + i);
212 276 if (err) {
213 277 if (!hard)
214 278 break;
215 279 lasterr = err;
216 280 }
217 281 }
218 282 } else if (BP_GET_TYPE(bp) == DMU_OT_OBJSET) {
219 283 uint32_t flags = ARC_WAIT;
220 284 objset_phys_t *osp;
221 285 dnode_phys_t *dnp;
222 286
223 287 err = dsl_read_nolock(NULL, td->td_spa, bp,
224 288 arc_getbuf_func, &buf,
225 289 ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
226 290 if (err)
227 291 return (err);
228 292
229 293 osp = buf->b_data;
230 294 dnp = &osp->os_meta_dnode;
231 295 err = traverse_dnode(td, dnp, buf, zb->zb_objset,
232 296 DMU_META_DNODE_OBJECT);
233 297 if (err && hard) {
234 298 lasterr = err;
235 299 err = 0;
236 300 }
237 301 if (err == 0 && arc_buf_size(buf) >= sizeof (objset_phys_t)) {
238 302 dnp = &osp->os_userused_dnode;
239 303 err = traverse_dnode(td, dnp, buf, zb->zb_objset,
240 304 DMU_USERUSED_OBJECT);
241 305 }
242 306 if (err && hard) {
243 307 lasterr = err;
244 308 err = 0;
245 309 }
|
↓ open down ↓ |
67 lines elided |
↑ open up ↑ |
246 310 if (err == 0 && arc_buf_size(buf) >= sizeof (objset_phys_t)) {
247 311 dnp = &osp->os_groupused_dnode;
248 312 err = traverse_dnode(td, dnp, buf, zb->zb_objset,
249 313 DMU_GROUPUSED_OBJECT);
250 314 }
251 315 }
252 316
253 317 if (buf)
254 318 (void) arc_buf_remove_ref(buf, &buf);
255 319
320 +post:
256 321 if (err == 0 && lasterr == 0 && (td->td_flags & TRAVERSE_POST)) {
257 322 err = td->td_func(td->td_spa, NULL, bp, pbuf, zb, dnp,
258 323 td->td_arg);
324 + if (err == ERESTART)
325 + pause = B_TRUE;
259 326 }
260 327
328 + if (pause && td->td_resume != NULL) {
329 + ASSERT3U(err, ==, ERESTART);
330 + ASSERT(!hard);
331 + traverse_pause(td, zb);
332 + }
333 +
261 334 return (err != 0 ? err : lasterr);
262 335 }
263 336
264 337 static int
265 338 traverse_dnode(traverse_data_t *td, const dnode_phys_t *dnp,
266 339 arc_buf_t *buf, uint64_t objset, uint64_t object)
267 340 {
268 341 int j, err = 0, lasterr = 0;
269 342 zbookmark_t czb;
270 343 boolean_t hard = (td->td_flags & TRAVERSE_HARD);
271 344
272 345 for (j = 0; j < dnp->dn_nblkptr; j++) {
273 346 SET_BOOKMARK(&czb, objset, object, dnp->dn_nlevels - 1, j);
274 347 err = traverse_visitbp(td, dnp, buf,
275 348 (blkptr_t *)&dnp->dn_blkptr[j], &czb);
276 349 if (err) {
277 350 if (!hard)
278 351 break;
279 352 lasterr = err;
280 353 }
281 354 }
282 355
283 356 if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
284 357 SET_BOOKMARK(&czb, objset,
285 358 object, 0, DMU_SPILL_BLKID);
286 359 err = traverse_visitbp(td, dnp, buf,
287 360 (blkptr_t *)&dnp->dn_spill, &czb);
288 361 if (err) {
289 362 if (!hard)
290 363 return (err);
291 364 lasterr = err;
292 365 }
293 366 }
294 367 return (err != 0 ? err : lasterr);
295 368 }
296 369
297 370 /* ARGSUSED */
298 371 static int
299 372 traverse_prefetcher(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
300 373 arc_buf_t *pbuf, const zbookmark_t *zb, const dnode_phys_t *dnp,
301 374 void *arg)
302 375 {
303 376 prefetch_data_t *pfd = arg;
304 377 uint32_t aflags = ARC_NOWAIT | ARC_PREFETCH;
305 378
306 379 ASSERT(pfd->pd_blks_fetched >= 0);
307 380 if (pfd->pd_cancel)
308 381 return (EINTR);
309 382
310 383 if (bp == NULL || !((pfd->pd_flags & TRAVERSE_PREFETCH_DATA) ||
311 384 BP_GET_TYPE(bp) == DMU_OT_DNODE || BP_GET_LEVEL(bp) > 0) ||
312 385 BP_GET_TYPE(bp) == DMU_OT_INTENT_LOG)
313 386 return (0);
314 387
315 388 mutex_enter(&pfd->pd_mtx);
316 389 while (!pfd->pd_cancel && pfd->pd_blks_fetched >= pfd->pd_blks_max)
317 390 cv_wait(&pfd->pd_cv, &pfd->pd_mtx);
318 391 pfd->pd_blks_fetched++;
319 392 cv_broadcast(&pfd->pd_cv);
320 393 mutex_exit(&pfd->pd_mtx);
321 394
322 395 (void) dsl_read(NULL, spa, bp, pbuf, NULL, NULL,
323 396 ZIO_PRIORITY_ASYNC_READ,
324 397 ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE,
325 398 &aflags, zb);
326 399
327 400 return (0);
328 401 }
329 402
330 403 static void
331 404 traverse_prefetch_thread(void *arg)
332 405 {
333 406 traverse_data_t *td_main = arg;
334 407 traverse_data_t td = *td_main;
335 408 zbookmark_t czb;
336 409
337 410 td.td_func = traverse_prefetcher;
338 411 td.td_arg = td_main->td_pfd;
339 412 td.td_pfd = NULL;
340 413
341 414 SET_BOOKMARK(&czb, td.td_objset,
342 415 ZB_ROOT_OBJECT, ZB_ROOT_LEVEL, ZB_ROOT_BLKID);
343 416 (void) traverse_visitbp(&td, NULL, NULL, td.td_rootbp, &czb);
344 417
345 418 mutex_enter(&td_main->td_pfd->pd_mtx);
|
↓ open down ↓ |
75 lines elided |
↑ open up ↑ |
346 419 td_main->td_pfd->pd_exited = B_TRUE;
347 420 cv_broadcast(&td_main->td_pfd->pd_cv);
348 421 mutex_exit(&td_main->td_pfd->pd_mtx);
349 422 }
350 423
351 424 /*
352 425 * NB: dataset must not be changing on-disk (eg, is a snapshot or we are
353 426 * in syncing context).
354 427 */
355 428 static int
356 -traverse_impl(spa_t *spa, dsl_dataset_t *ds, blkptr_t *rootbp,
357 - uint64_t txg_start, int flags, blkptr_cb_t func, void *arg)
429 +traverse_impl(spa_t *spa, dsl_dataset_t *ds, uint64_t objset, blkptr_t *rootbp,
430 + uint64_t txg_start, zbookmark_t *resume, int flags,
431 + blkptr_cb_t func, void *arg)
358 432 {
359 433 traverse_data_t td;
360 434 prefetch_data_t pd = { 0 };
361 435 zbookmark_t czb;
362 436 int err;
363 437
438 + ASSERT(ds == NULL || objset == ds->ds_object);
439 + ASSERT(!(flags & TRAVERSE_PRE) || !(flags & TRAVERSE_POST));
440 +
364 441 td.td_spa = spa;
365 - td.td_objset = ds ? ds->ds_object : 0;
442 + td.td_objset = objset;
366 443 td.td_rootbp = rootbp;
367 444 td.td_min_txg = txg_start;
445 + td.td_resume = resume;
368 446 td.td_func = func;
369 447 td.td_arg = arg;
370 448 td.td_pfd = &pd;
371 449 td.td_flags = flags;
372 450
373 451 pd.pd_blks_max = zfs_pd_blks_max;
374 452 pd.pd_flags = flags;
375 453 mutex_init(&pd.pd_mtx, NULL, MUTEX_DEFAULT, NULL);
376 454 cv_init(&pd.pd_cv, NULL, CV_DEFAULT, NULL);
377 455
378 456 /* See comment on ZIL traversal in dsl_scan_visitds. */
379 457 if (ds != NULL && !dsl_dataset_is_snapshot(ds)) {
380 458 objset_t *os;
381 459
382 460 err = dmu_objset_from_ds(ds, &os);
383 461 if (err)
384 462 return (err);
385 463
386 464 traverse_zil(&td, &os->os_zil_header);
387 465 }
388 466
389 467 if (!(flags & TRAVERSE_PREFETCH) ||
390 468 0 == taskq_dispatch(system_taskq, traverse_prefetch_thread,
391 469 &td, TQ_NOQUEUE))
392 470 pd.pd_exited = B_TRUE;
393 471
394 472 SET_BOOKMARK(&czb, td.td_objset,
395 473 ZB_ROOT_OBJECT, ZB_ROOT_LEVEL, ZB_ROOT_BLKID);
396 474 err = traverse_visitbp(&td, NULL, NULL, rootbp, &czb);
397 475
398 476 mutex_enter(&pd.pd_mtx);
399 477 pd.pd_cancel = B_TRUE;
400 478 cv_broadcast(&pd.pd_cv);
401 479 while (!pd.pd_exited)
402 480 cv_wait(&pd.pd_cv, &pd.pd_mtx);
403 481 mutex_exit(&pd.pd_mtx);
404 482
405 483 mutex_destroy(&pd.pd_mtx);
406 484 cv_destroy(&pd.pd_cv);
407 485
408 486 return (err);
|
↓ open down ↓ |
31 lines elided |
↑ open up ↑ |
409 487 }
410 488
411 489 /*
412 490 * NB: dataset must not be changing on-disk (eg, is a snapshot or we are
413 491 * in syncing context).
414 492 */
415 493 int
416 494 traverse_dataset(dsl_dataset_t *ds, uint64_t txg_start, int flags,
417 495 blkptr_cb_t func, void *arg)
418 496 {
419 - return (traverse_impl(ds->ds_dir->dd_pool->dp_spa, ds,
420 - &ds->ds_phys->ds_bp, txg_start, flags, func, arg));
497 + return (traverse_impl(ds->ds_dir->dd_pool->dp_spa, ds, ds->ds_object,
498 + &ds->ds_phys->ds_bp, txg_start, NULL, flags, func, arg));
421 499 }
422 500
501 +int
502 +traverse_dataset_destroyed(spa_t *spa, blkptr_t *blkptr,
503 + uint64_t txg_start, zbookmark_t *resume, int flags,
504 + blkptr_cb_t func, void *arg)
505 +{
506 + return (traverse_impl(spa, NULL, ZB_DESTROYED_OBJSET,
507 + blkptr, txg_start, resume, flags, func, arg));
508 +}
509 +
423 510 /*
424 511 * NB: pool must not be changing on-disk (eg, from zdb or sync context).
425 512 */
426 513 int
427 514 traverse_pool(spa_t *spa, uint64_t txg_start, int flags,
428 515 blkptr_cb_t func, void *arg)
429 516 {
430 517 int err, lasterr = 0;
431 518 uint64_t obj;
432 519 dsl_pool_t *dp = spa_get_dsl(spa);
433 520 objset_t *mos = dp->dp_meta_objset;
434 521 boolean_t hard = (flags & TRAVERSE_HARD);
435 522
436 523 /* visit the MOS */
437 - err = traverse_impl(spa, NULL, spa_get_rootblkptr(spa),
438 - txg_start, flags, func, arg);
524 + err = traverse_impl(spa, NULL, 0, spa_get_rootblkptr(spa),
525 + txg_start, NULL, flags, func, arg);
439 526 if (err)
440 527 return (err);
441 528
442 529 /* visit each dataset */
443 530 for (obj = 1; err == 0 || (err != ESRCH && hard);
444 531 err = dmu_object_next(mos, &obj, FALSE, txg_start)) {
445 532 dmu_object_info_t doi;
446 533
447 534 err = dmu_object_info(mos, obj, &doi);
448 535 if (err) {
449 536 if (!hard)
450 537 return (err);
451 538 lasterr = err;
452 539 continue;
453 540 }
454 541
455 542 if (doi.doi_type == DMU_OT_DSL_DATASET) {
456 543 dsl_dataset_t *ds;
457 544 uint64_t txg = txg_start;
458 545
459 546 rw_enter(&dp->dp_config_rwlock, RW_READER);
460 547 err = dsl_dataset_hold_obj(dp, obj, FTAG, &ds);
461 548 rw_exit(&dp->dp_config_rwlock);
462 549 if (err) {
463 550 if (!hard)
464 551 return (err);
465 552 lasterr = err;
466 553 continue;
467 554 }
468 555 if (ds->ds_phys->ds_prev_snap_txg > txg)
469 556 txg = ds->ds_phys->ds_prev_snap_txg;
470 557 err = traverse_dataset(ds, txg, flags, func, arg);
471 558 dsl_dataset_rele(ds, FTAG);
472 559 if (err) {
473 560 if (!hard)
474 561 return (err);
475 562 lasterr = err;
476 563 }
477 564 }
478 565 }
479 566 if (err == ESRCH)
480 567 err = 0;
481 568 return (err != 0 ? err : lasterr);
482 569 }
|
↓ open down ↓ |
34 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX