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) 2013, 2018 by Delphix. All rights reserved.
18 * Copyright 2017 Nexenta Systems, Inc.
19 * Copyright 2019, 2020 by Christian Schwarz. All rights reserved.
20 */
21
22 #include <sys/zfs_context.h>
23 #include <sys/dsl_dataset.h>
24 #include <sys/dsl_dir.h>
25 #include <sys/dsl_prop.h>
26 #include <sys/dsl_synctask.h>
27 #include <sys/dsl_destroy.h>
28 #include <sys/dmu_impl.h>
29 #include <sys/dmu_tx.h>
30 #include <sys/arc.h>
31 #include <sys/zap.h>
32 #include <sys/zfeature.h>
33 #include <sys/spa.h>
34 #include <sys/dsl_bookmark.h>
35 #include <zfs_namecheck.h>
36 #include <sys/dmu_send.h>
37
38 static int
dsl_bookmark_hold_ds(dsl_pool_t * dp,const char * fullname,dsl_dataset_t ** dsp,void * tag,char ** shortnamep)39 dsl_bookmark_hold_ds(dsl_pool_t *dp, const char *fullname,
40 dsl_dataset_t **dsp, void *tag, char **shortnamep)
41 {
42 char buf[ZFS_MAX_DATASET_NAME_LEN];
43 char *hashp;
44
45 if (strlen(fullname) >= ZFS_MAX_DATASET_NAME_LEN)
46 return (SET_ERROR(ENAMETOOLONG));
47 hashp = strchr(fullname, '#');
48 if (hashp == NULL)
49 return (SET_ERROR(EINVAL));
50
51 *shortnamep = hashp + 1;
52 if (zfs_component_namecheck(*shortnamep, NULL, NULL))
53 return (SET_ERROR(EINVAL));
54 (void) strlcpy(buf, fullname, hashp - fullname + 1);
55 return (dsl_dataset_hold(dp, buf, tag, dsp));
56 }
57
58 /*
59 * When reading BOOKMARK_V1 bookmarks, the BOOKMARK_V2 fields are guaranteed
60 * to be zeroed.
61 *
62 * Returns ESRCH if bookmark is not found.
63 * Note, we need to use the ZAP rather than the AVL to look up bookmarks
64 * by name, because only the ZAP honors the casesensitivity setting.
65 */
66 int
dsl_bookmark_lookup_impl(dsl_dataset_t * ds,const char * shortname,zfs_bookmark_phys_t * bmark_phys)67 dsl_bookmark_lookup_impl(dsl_dataset_t *ds, const char *shortname,
68 zfs_bookmark_phys_t *bmark_phys)
69 {
70 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
71 uint64_t bmark_zapobj = ds->ds_bookmarks_obj;
72 matchtype_t mt = 0;
73 int err;
74
75 if (bmark_zapobj == 0)
76 return (SET_ERROR(ESRCH));
77
78 if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
79 mt = MT_NORMALIZE;
80
81 /*
82 * Zero out the bookmark in case the one stored on disk
83 * is in an older, shorter format.
84 */
85 bzero(bmark_phys, sizeof (*bmark_phys));
86
87 err = zap_lookup_norm(mos, bmark_zapobj, shortname, sizeof (uint64_t),
88 sizeof (*bmark_phys) / sizeof (uint64_t), bmark_phys, mt, NULL, 0,
89 NULL);
90
91 return (err == ENOENT ? SET_ERROR(ESRCH) : err);
92 }
93
94 /*
95 * If later_ds is non-NULL, this will return EXDEV if the specified bookmark
96 * does not represents an earlier point in later_ds's timeline. However,
97 * bmp will still be filled in if we return EXDEV.
98 *
99 * Returns ENOENT if the dataset containing the bookmark does not exist.
100 * Returns ESRCH if the dataset exists but the bookmark was not found in it.
101 */
102 int
dsl_bookmark_lookup(dsl_pool_t * dp,const char * fullname,dsl_dataset_t * later_ds,zfs_bookmark_phys_t * bmp)103 dsl_bookmark_lookup(dsl_pool_t *dp, const char *fullname,
104 dsl_dataset_t *later_ds, zfs_bookmark_phys_t *bmp)
105 {
106 char *shortname;
107 dsl_dataset_t *ds;
108 int error;
109
110 error = dsl_bookmark_hold_ds(dp, fullname, &ds, FTAG, &shortname);
111 if (error != 0)
112 return (error);
113
114 error = dsl_bookmark_lookup_impl(ds, shortname, bmp);
115 if (error == 0 && later_ds != NULL) {
116 if (!dsl_dataset_is_before(later_ds, ds, bmp->zbm_creation_txg))
117 error = SET_ERROR(EXDEV);
118 }
119 dsl_dataset_rele(ds, FTAG);
120 return (error);
121 }
122
123 /*
124 * Validates that
125 * - bmark is a full dataset path of a bookmark (bookmark_namecheck)
126 * - source is a full path of a snapshot or bookmark
127 * ({bookmark,snapshot}_namecheck)
128 *
129 * Returns 0 if valid, -1 otherwise.
130 */
131 static int
dsl_bookmark_create_nvl_validate_pair(const char * bmark,const char * source)132 dsl_bookmark_create_nvl_validate_pair(const char *bmark, const char *source)
133 {
134 if (bookmark_namecheck(bmark, NULL, NULL) != 0)
135 return (-1);
136
137 int is_bmark, is_snap;
138 is_bmark = bookmark_namecheck(source, NULL, NULL) == 0;
139 is_snap = snapshot_namecheck(source, NULL, NULL) == 0;
140 if (!is_bmark && !is_snap)
141 return (-1);
142
143 return (0);
144 }
145
146 /*
147 * Check that the given nvlist corresponds to the following schema:
148 * { newbookmark -> source, ... }
149 * where
150 * - each pair passes dsl_bookmark_create_nvl_validate_pair
151 * - all newbookmarks are in the same pool
152 * - all newbookmarks have unique names
153 *
154 * Note that this function is only validates above schema. Callers must ensure
155 * that the bookmarks can be created, e.g. that sources exist.
156 *
157 * Returns 0 if the nvlist adheres to above schema.
158 * Returns -1 if it doesn't.
159 */
160 int
dsl_bookmark_create_nvl_validate(nvlist_t * bmarks)161 dsl_bookmark_create_nvl_validate(nvlist_t *bmarks)
162 {
163 char *first;
164 size_t first_len;
165
166 first = NULL;
167 for (nvpair_t *pair = nvlist_next_nvpair(bmarks, NULL);
168 pair != NULL; pair = nvlist_next_nvpair(bmarks, pair)) {
169
170 char *bmark = nvpair_name(pair);
171 char *source;
172
173 /* list structure: values must be snapshots XOR bookmarks */
174 if (nvpair_value_string(pair, &source) != 0)
175 return (-1);
176 if (dsl_bookmark_create_nvl_validate_pair(bmark, source) != 0)
177 return (-1);
178
179 /* same pool check */
180 if (first == NULL) {
181 char *cp = strpbrk(bmark, "/#");
182 if (cp == NULL)
183 return (-1);
184 first = bmark;
185 first_len = cp - bmark;
186 }
187 if (strncmp(first, bmark, first_len) != 0)
188 return (-1);
189 switch (*(bmark + first_len)) {
190 case '/': /* fallthrough */
191 case '#':
192 break;
193 default:
194 return (-1);
195 }
196
197 /* unique newbookmark names; todo: O(n^2) */
198 for (nvpair_t *pair2 = nvlist_next_nvpair(bmarks, pair);
199 pair2 != NULL; pair2 = nvlist_next_nvpair(bmarks, pair2)) {
200 if (strcmp(nvpair_name(pair), nvpair_name(pair2)) == 0)
201 return (-1);
202 }
203
204 }
205 return (0);
206 }
207
208 /*
209 * expects that newbm and source have been validated using
210 * dsl_bookmark_create_nvl_validate_pair
211 */
212 static int
dsl_bookmark_create_check_impl(dsl_pool_t * dp,const char * newbm,const char * source)213 dsl_bookmark_create_check_impl(dsl_pool_t *dp,
214 const char *newbm, const char *source)
215 {
216 ASSERT0(dsl_bookmark_create_nvl_validate_pair(newbm, source));
217 /* defer source namecheck until we know it's a snapshot or bookmark */
218
219 int error;
220 dsl_dataset_t *newbm_ds;
221 char *newbm_short;
222 zfs_bookmark_phys_t bmark_phys;
223
224 error = dsl_bookmark_hold_ds(dp, newbm, &newbm_ds, FTAG, &newbm_short);
225 if (error != 0)
226 return (error);
227
228 /* Verify that the new bookmark does not already exist */
229 error = dsl_bookmark_lookup_impl(newbm_ds, newbm_short, &bmark_phys);
230 switch (error) {
231 case ESRCH:
232 /* happy path: new bmark doesn't exist, proceed after switch */
233 error = 0;
234 break;
235 case 0:
236 error = SET_ERROR(EEXIST);
237 goto eholdnewbmds;
238 default:
239 /* dsl_bookmark_lookup_impl already did SET_ERROR */
240 goto eholdnewbmds;
241 }
242
243 /* error is retval of the following if-cascade */
244 if (strchr(source, '@') != NULL) {
245 dsl_dataset_t *source_snap_ds;
246 ASSERT3S(snapshot_namecheck(source, NULL, NULL), ==, 0);
247 error = dsl_dataset_hold(dp, source, FTAG, &source_snap_ds);
248 if (error == 0) {
249 VERIFY(source_snap_ds->ds_is_snapshot);
250 /*
251 * Verify that source snapshot is an earlier point in
252 * newbm_ds's timeline (source may be newbm_ds's origin)
253 */
254 if (!dsl_dataset_is_before(newbm_ds, source_snap_ds, 0))
255 error = SET_ERROR(
256 ZFS_ERR_BOOKMARK_SOURCE_NOT_ANCESTOR);
257 dsl_dataset_rele(source_snap_ds, FTAG);
258 }
259 } else if (strchr(source, '#') != NULL) {
260 zfs_bookmark_phys_t source_phys;
261 ASSERT3S(bookmark_namecheck(source, NULL, NULL), ==, 0);
262 /*
263 * Source must exists and be an earlier point in newbm_ds's
264 * timeline (newbm_ds's origin may be a snap of source's ds)
265 */
266 error = dsl_bookmark_lookup(dp, source, newbm_ds, &source_phys);
267 switch (error) {
268 case 0:
269 break; /* happy path */
270 case EXDEV:
271 error = SET_ERROR(ZFS_ERR_BOOKMARK_SOURCE_NOT_ANCESTOR);
272 break;
273 default:
274 /* dsl_bookmark_lookup already did SET_ERROR */
275 break;
276 }
277 } else {
278 /*
279 * dsl_bookmark_create_nvl_validate validates that source is
280 * either snapshot or bookmark
281 */
282 panic("unreachable code: %s", source);
283 }
284
285 eholdnewbmds:
286 dsl_dataset_rele(newbm_ds, FTAG);
287 return (error);
288 }
289
290 int
dsl_bookmark_create_check(void * arg,dmu_tx_t * tx)291 dsl_bookmark_create_check(void *arg, dmu_tx_t *tx)
292 {
293 dsl_bookmark_create_arg_t *dbca = arg;
294 int rv = 0;
295 int schema_err = 0;
296 ASSERT3P(dbca, !=, NULL);
297 ASSERT3P(dbca->dbca_bmarks, !=, NULL);
298 /* dbca->dbca_errors is allowed to be NULL */
299
300 dsl_pool_t *dp = dmu_tx_pool(tx);
301
302 if (!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARKS))
303 return (SET_ERROR(ENOTSUP));
304
305 if (dsl_bookmark_create_nvl_validate(dbca->dbca_bmarks) != 0)
306 rv = schema_err = SET_ERROR(EINVAL);
307
308 for (nvpair_t *pair = nvlist_next_nvpair(dbca->dbca_bmarks, NULL);
309 pair != NULL; pair = nvlist_next_nvpair(dbca->dbca_bmarks, pair)) {
310 char *new = nvpair_name(pair);
311
312 int error = schema_err;
313 if (error == 0) {
314 char *source = fnvpair_value_string(pair);
315 error = dsl_bookmark_create_check_impl(dp, new, source);
316 if (error != 0)
317 error = SET_ERROR(error);
318 }
319
320 if (error != 0) {
321 rv = error;
322 if (dbca->dbca_errors != NULL)
323 fnvlist_add_int32(dbca->dbca_errors,
324 new, error);
325 }
326 }
327
328 return (rv);
329 }
330
331 static dsl_bookmark_node_t *
dsl_bookmark_node_alloc(char * shortname)332 dsl_bookmark_node_alloc(char *shortname)
333 {
334 dsl_bookmark_node_t *dbn = kmem_alloc(sizeof (*dbn), KM_SLEEP);
335 dbn->dbn_name = spa_strdup(shortname);
336 dbn->dbn_dirty = B_FALSE;
337 mutex_init(&dbn->dbn_lock, NULL, MUTEX_DEFAULT, NULL);
338 return (dbn);
339 }
340
341 /*
342 * Set the fields in the zfs_bookmark_phys_t based on the specified snapshot.
343 */
344 static void
dsl_bookmark_set_phys(zfs_bookmark_phys_t * zbm,dsl_dataset_t * snap)345 dsl_bookmark_set_phys(zfs_bookmark_phys_t *zbm, dsl_dataset_t *snap)
346 {
347 spa_t *spa = dsl_dataset_get_spa(snap);
348 objset_t *mos = spa_get_dsl(spa)->dp_meta_objset;
349 dsl_dataset_phys_t *dsp = dsl_dataset_phys(snap);
350
351 memset(zbm, 0, sizeof (zfs_bookmark_phys_t));
352 zbm->zbm_guid = dsp->ds_guid;
353 zbm->zbm_creation_txg = dsp->ds_creation_txg;
354 zbm->zbm_creation_time = dsp->ds_creation_time;
355 zbm->zbm_redaction_obj = 0;
356
357 /*
358 * If the dataset is encrypted create a larger bookmark to
359 * accommodate the IVset guid. The IVset guid was added
360 * after the encryption feature to prevent a problem with
361 * raw sends. If we encounter an encrypted dataset without
362 * an IVset guid we fall back to a normal bookmark.
363 */
364 if (snap->ds_dir->dd_crypto_obj != 0 &&
365 spa_feature_is_enabled(spa, SPA_FEATURE_BOOKMARK_V2)) {
366 (void) zap_lookup(mos, snap->ds_object,
367 DS_FIELD_IVSET_GUID, sizeof (uint64_t), 1,
368 &zbm->zbm_ivset_guid);
369 }
370
371 if (spa_feature_is_enabled(spa, SPA_FEATURE_BOOKMARK_WRITTEN)) {
372 zbm->zbm_flags = ZBM_FLAG_SNAPSHOT_EXISTS | ZBM_FLAG_HAS_FBN;
373 zbm->zbm_referenced_bytes_refd = dsp->ds_referenced_bytes;
374 zbm->zbm_compressed_bytes_refd = dsp->ds_compressed_bytes;
375 zbm->zbm_uncompressed_bytes_refd = dsp->ds_uncompressed_bytes;
376
377 dsl_dataset_t *nextds;
378 VERIFY0(dsl_dataset_hold_obj(snap->ds_dir->dd_pool,
379 dsp->ds_next_snap_obj, FTAG, &nextds));
380 dsl_deadlist_space(&nextds->ds_deadlist,
381 &zbm->zbm_referenced_freed_before_next_snap,
382 &zbm->zbm_compressed_freed_before_next_snap,
383 &zbm->zbm_uncompressed_freed_before_next_snap);
384 dsl_dataset_rele(nextds, FTAG);
385 }
386 }
387
388 /*
389 * Add dsl_bookmark_node_t `dbn` to the given dataset and increment appropriate
390 * SPA feature counters.
391 */
392 void
dsl_bookmark_node_add(dsl_dataset_t * hds,dsl_bookmark_node_t * dbn,dmu_tx_t * tx)393 dsl_bookmark_node_add(dsl_dataset_t *hds, dsl_bookmark_node_t *dbn,
394 dmu_tx_t *tx)
395 {
396 dsl_pool_t *dp = dmu_tx_pool(tx);
397 objset_t *mos = dp->dp_meta_objset;
398
399 if (hds->ds_bookmarks_obj == 0) {
400 hds->ds_bookmarks_obj = zap_create_norm(mos,
401 U8_TEXTPREP_TOUPPER, DMU_OTN_ZAP_METADATA, DMU_OT_NONE, 0,
402 tx);
403 spa_feature_incr(dp->dp_spa, SPA_FEATURE_BOOKMARKS, tx);
404
405 dsl_dataset_zapify(hds, tx);
406 VERIFY0(zap_add(mos, hds->ds_object,
407 DS_FIELD_BOOKMARK_NAMES,
408 sizeof (hds->ds_bookmarks_obj), 1,
409 &hds->ds_bookmarks_obj, tx));
410 }
411
412 avl_add(&hds->ds_bookmarks, dbn);
413
414 /*
415 * To maintain backwards compatibility with software that doesn't
416 * understand SPA_FEATURE_BOOKMARK_V2, we need to use the smallest
417 * possible bookmark size.
418 */
419 uint64_t bookmark_phys_size = BOOKMARK_PHYS_SIZE_V1;
420 if (spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARK_V2) &&
421 (dbn->dbn_phys.zbm_ivset_guid != 0 || dbn->dbn_phys.zbm_flags &
422 ZBM_FLAG_HAS_FBN || dbn->dbn_phys.zbm_redaction_obj != 0)) {
423 bookmark_phys_size = BOOKMARK_PHYS_SIZE_V2;
424 spa_feature_incr(dp->dp_spa, SPA_FEATURE_BOOKMARK_V2, tx);
425 }
426
427 __attribute__((unused)) zfs_bookmark_phys_t zero_phys = { 0 };
428 ASSERT0(bcmp(((char *)&dbn->dbn_phys) + bookmark_phys_size,
429 &zero_phys, sizeof (zfs_bookmark_phys_t) - bookmark_phys_size));
430
431 VERIFY0(zap_add(mos, hds->ds_bookmarks_obj, dbn->dbn_name,
432 sizeof (uint64_t), bookmark_phys_size / sizeof (uint64_t),
433 &dbn->dbn_phys, tx));
434 }
435
436 /*
437 * If redaction_list is non-null, we create a redacted bookmark and redaction
438 * list, and store the object number of the redaction list in redact_obj.
439 */
440 static void
dsl_bookmark_create_sync_impl_snap(const char * bookmark,const char * snapshot,dmu_tx_t * tx,uint64_t num_redact_snaps,uint64_t * redact_snaps,void * tag,redaction_list_t ** redaction_list)441 dsl_bookmark_create_sync_impl_snap(const char *bookmark, const char *snapshot,
442 dmu_tx_t *tx, uint64_t num_redact_snaps, uint64_t *redact_snaps, void *tag,
443 redaction_list_t **redaction_list)
444 {
445 dsl_pool_t *dp = dmu_tx_pool(tx);
446 objset_t *mos = dp->dp_meta_objset;
447 dsl_dataset_t *snapds, *bmark_fs;
448 char *shortname;
449 boolean_t bookmark_redacted;
450 uint64_t *dsredactsnaps;
451 uint64_t dsnumsnaps;
452
453 VERIFY0(dsl_dataset_hold(dp, snapshot, FTAG, &snapds));
454 VERIFY0(dsl_bookmark_hold_ds(dp, bookmark, &bmark_fs, FTAG,
455 &shortname));
456
457 dsl_bookmark_node_t *dbn = dsl_bookmark_node_alloc(shortname);
458 dsl_bookmark_set_phys(&dbn->dbn_phys, snapds);
459
460 bookmark_redacted = dsl_dataset_get_uint64_array_feature(snapds,
461 SPA_FEATURE_REDACTED_DATASETS, &dsnumsnaps, &dsredactsnaps);
462 if (redaction_list != NULL || bookmark_redacted) {
463 redaction_list_t *local_rl;
464 if (bookmark_redacted) {
465 redact_snaps = dsredactsnaps;
466 num_redact_snaps = dsnumsnaps;
467 }
468 dbn->dbn_phys.zbm_redaction_obj = dmu_object_alloc(mos,
469 DMU_OTN_UINT64_METADATA, SPA_OLD_MAXBLOCKSIZE,
470 DMU_OTN_UINT64_METADATA, sizeof (redaction_list_phys_t) +
471 num_redact_snaps * sizeof (uint64_t), tx);
472 spa_feature_incr(dp->dp_spa,
473 SPA_FEATURE_REDACTION_BOOKMARKS, tx);
474
475 VERIFY0(dsl_redaction_list_hold_obj(dp,
476 dbn->dbn_phys.zbm_redaction_obj, tag, &local_rl));
477 dsl_redaction_list_long_hold(dp, local_rl, tag);
478
479 ASSERT3U((local_rl)->rl_dbuf->db_size, >=,
480 sizeof (redaction_list_phys_t) + num_redact_snaps *
481 sizeof (uint64_t));
482 dmu_buf_will_dirty(local_rl->rl_dbuf, tx);
483 bcopy(redact_snaps, local_rl->rl_phys->rlp_snaps,
484 sizeof (uint64_t) * num_redact_snaps);
485 local_rl->rl_phys->rlp_num_snaps = num_redact_snaps;
486 if (bookmark_redacted) {
487 ASSERT3P(redaction_list, ==, NULL);
488 local_rl->rl_phys->rlp_last_blkid = UINT64_MAX;
489 local_rl->rl_phys->rlp_last_object = UINT64_MAX;
490 dsl_redaction_list_long_rele(local_rl, tag);
491 dsl_redaction_list_rele(local_rl, tag);
492 } else {
493 *redaction_list = local_rl;
494 }
495 }
496
497 if (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) {
498 spa_feature_incr(dp->dp_spa,
499 SPA_FEATURE_BOOKMARK_WRITTEN, tx);
500 }
501
502 dsl_bookmark_node_add(bmark_fs, dbn, tx);
503
504 spa_history_log_internal_ds(bmark_fs, "bookmark", tx,
505 "name=%s creation_txg=%llu target_snap=%llu redact_obj=%llu",
506 shortname, (longlong_t)dbn->dbn_phys.zbm_creation_txg,
507 (longlong_t)snapds->ds_object,
508 (longlong_t)dbn->dbn_phys.zbm_redaction_obj);
509
510 dsl_dataset_rele(bmark_fs, FTAG);
511 dsl_dataset_rele(snapds, FTAG);
512 }
513
514
515 static void
dsl_bookmark_create_sync_impl_book(const char * new_name,const char * source_name,dmu_tx_t * tx)516 dsl_bookmark_create_sync_impl_book(
517 const char *new_name, const char *source_name, dmu_tx_t *tx)
518 {
519 dsl_pool_t *dp = dmu_tx_pool(tx);
520 dsl_dataset_t *bmark_fs_source, *bmark_fs_new;
521 char *source_shortname, *new_shortname;
522 zfs_bookmark_phys_t source_phys;
523
524 VERIFY0(dsl_bookmark_hold_ds(dp, source_name, &bmark_fs_source, FTAG,
525 &source_shortname));
526 VERIFY0(dsl_bookmark_hold_ds(dp, new_name, &bmark_fs_new, FTAG,
527 &new_shortname));
528
529 /*
530 * create a copy of the source bookmark by copying most of its members
531 *
532 * Caveat: bookmarking a redaction bookmark yields a normal bookmark
533 * -----------------------------------------------------------------
534 * Reasoning:
535 * - The zbm_redaction_obj would be referred to by both source and new
536 * bookmark, but would be destroyed once either source or new is
537 * destroyed, resulting in use-after-free of the referred object.
538 * - User expectation when issuing the `zfs bookmark` command is that
539 * a normal bookmark of the source is created
540 *
541 * Design Alternatives For Full Redaction Bookmark Copying:
542 * - reference-count the redaction object => would require on-disk
543 * format change for existing redaction objects
544 * - Copy the redaction object => cannot be done in syncing context
545 * because the redaction object might be too large
546 */
547
548 VERIFY0(dsl_bookmark_lookup_impl(bmark_fs_source, source_shortname,
549 &source_phys));
550 dsl_bookmark_node_t *new_dbn = dsl_bookmark_node_alloc(new_shortname);
551
552 memcpy(&new_dbn->dbn_phys, &source_phys, sizeof (source_phys));
553 new_dbn->dbn_phys.zbm_redaction_obj = 0;
554
555 /* update feature counters */
556 if (new_dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) {
557 spa_feature_incr(dp->dp_spa,
558 SPA_FEATURE_BOOKMARK_WRITTEN, tx);
559 }
560 /* no need for redaction bookmark counter; nulled zbm_redaction_obj */
561 /* dsl_bookmark_node_add bumps bookmarks and v2-bookmarks counter */
562
563 /*
564 * write new bookmark
565 *
566 * Note that dsl_bookmark_lookup_impl guarantees that, if source is a
567 * v1 bookmark, the v2-only fields are zeroed.
568 * And dsl_bookmark_node_add writes back a v1-sized bookmark if
569 * v2 bookmarks are disabled and/or v2-only fields are zeroed.
570 * => bookmark copying works on pre-bookmark-v2 pools
571 */
572 dsl_bookmark_node_add(bmark_fs_new, new_dbn, tx);
573
574 spa_history_log_internal_ds(bmark_fs_source, "bookmark", tx,
575 "name=%s creation_txg=%llu source_guid=%llu",
576 new_shortname, (longlong_t)new_dbn->dbn_phys.zbm_creation_txg,
577 (longlong_t)source_phys.zbm_guid);
578
579 dsl_dataset_rele(bmark_fs_source, FTAG);
580 dsl_dataset_rele(bmark_fs_new, FTAG);
581 }
582
583 void
dsl_bookmark_create_sync(void * arg,dmu_tx_t * tx)584 dsl_bookmark_create_sync(void *arg, dmu_tx_t *tx)
585 {
586 dsl_bookmark_create_arg_t *dbca = arg;
587
588 ASSERT(spa_feature_is_enabled(dmu_tx_pool(tx)->dp_spa,
589 SPA_FEATURE_BOOKMARKS));
590
591 for (nvpair_t *pair = nvlist_next_nvpair(dbca->dbca_bmarks, NULL);
592 pair != NULL; pair = nvlist_next_nvpair(dbca->dbca_bmarks, pair)) {
593
594 char *new = nvpair_name(pair);
595 char *source = fnvpair_value_string(pair);
596
597 if (strchr(source, '@') != NULL) {
598 dsl_bookmark_create_sync_impl_snap(new, source, tx,
599 0, NULL, NULL, NULL);
600 } else if (strchr(source, '#') != NULL) {
601 dsl_bookmark_create_sync_impl_book(new, source, tx);
602 } else {
603 panic("unreachable code");
604 }
605
606 }
607 }
608
609 /*
610 * The bookmarks must all be in the same pool.
611 */
612 int
dsl_bookmark_create(nvlist_t * bmarks,nvlist_t * errors)613 dsl_bookmark_create(nvlist_t *bmarks, nvlist_t *errors)
614 {
615 nvpair_t *pair;
616 dsl_bookmark_create_arg_t dbca;
617
618 pair = nvlist_next_nvpair(bmarks, NULL);
619 if (pair == NULL)
620 return (0);
621
622 dbca.dbca_bmarks = bmarks;
623 dbca.dbca_errors = errors;
624
625 return (dsl_sync_task(nvpair_name(pair), dsl_bookmark_create_check,
626 dsl_bookmark_create_sync, &dbca,
627 fnvlist_num_pairs(bmarks), ZFS_SPACE_CHECK_NORMAL));
628 }
629
630 static int
dsl_bookmark_create_redacted_check(void * arg,dmu_tx_t * tx)631 dsl_bookmark_create_redacted_check(void *arg, dmu_tx_t *tx)
632 {
633 dsl_bookmark_create_redacted_arg_t *dbcra = arg;
634 dsl_pool_t *dp = dmu_tx_pool(tx);
635 int rv = 0;
636
637 if (!spa_feature_is_enabled(dp->dp_spa,
638 SPA_FEATURE_REDACTION_BOOKMARKS))
639 return (SET_ERROR(ENOTSUP));
640 /*
641 * If the list of redact snaps will not fit in the bonus buffer with
642 * the furthest reached object and offset, fail.
643 */
644 if (dbcra->dbcra_numsnaps > (dmu_bonus_max() -
645 sizeof (redaction_list_phys_t)) / sizeof (uint64_t))
646 return (SET_ERROR(E2BIG));
647
648 if (dsl_bookmark_create_nvl_validate_pair(
649 dbcra->dbcra_bmark, dbcra->dbcra_snap) != 0)
650 return (SET_ERROR(EINVAL));
651
652 rv = dsl_bookmark_create_check_impl(dp,
653 dbcra->dbcra_bmark, dbcra->dbcra_snap);
654 return (rv);
655 }
656
657 static void
dsl_bookmark_create_redacted_sync(void * arg,dmu_tx_t * tx)658 dsl_bookmark_create_redacted_sync(void *arg, dmu_tx_t *tx)
659 {
660 dsl_bookmark_create_redacted_arg_t *dbcra = arg;
661 dsl_bookmark_create_sync_impl_snap(dbcra->dbcra_bmark,
662 dbcra->dbcra_snap, tx, dbcra->dbcra_numsnaps, dbcra->dbcra_snaps,
663 dbcra->dbcra_tag, dbcra->dbcra_rl);
664 }
665
666 int
dsl_bookmark_create_redacted(const char * bookmark,const char * snapshot,uint64_t numsnaps,uint64_t * snapguids,void * tag,redaction_list_t ** rl)667 dsl_bookmark_create_redacted(const char *bookmark, const char *snapshot,
668 uint64_t numsnaps, uint64_t *snapguids, void *tag, redaction_list_t **rl)
669 {
670 dsl_bookmark_create_redacted_arg_t dbcra;
671
672 dbcra.dbcra_bmark = bookmark;
673 dbcra.dbcra_snap = snapshot;
674 dbcra.dbcra_rl = rl;
675 dbcra.dbcra_numsnaps = numsnaps;
676 dbcra.dbcra_snaps = snapguids;
677 dbcra.dbcra_tag = tag;
678
679 return (dsl_sync_task(bookmark, dsl_bookmark_create_redacted_check,
680 dsl_bookmark_create_redacted_sync, &dbcra, 5,
681 ZFS_SPACE_CHECK_NORMAL));
682 }
683
684 /*
685 * Retrieve the list of properties given in the 'props' nvlist for a bookmark.
686 * If 'props' is NULL, retrieves all properties.
687 */
688 static void
dsl_bookmark_fetch_props(dsl_pool_t * dp,zfs_bookmark_phys_t * bmark_phys,nvlist_t * props,nvlist_t * out_props)689 dsl_bookmark_fetch_props(dsl_pool_t *dp, zfs_bookmark_phys_t *bmark_phys,
690 nvlist_t *props, nvlist_t *out_props)
691 {
692 ASSERT3P(dp, !=, NULL);
693 ASSERT3P(bmark_phys, !=, NULL);
694 ASSERT3P(out_props, !=, NULL);
695 ASSERT(RRW_LOCK_HELD(&dp->dp_config_rwlock));
696
697 if (props == NULL || nvlist_exists(props,
698 zfs_prop_to_name(ZFS_PROP_GUID))) {
699 dsl_prop_nvlist_add_uint64(out_props,
700 ZFS_PROP_GUID, bmark_phys->zbm_guid);
701 }
702 if (props == NULL || nvlist_exists(props,
703 zfs_prop_to_name(ZFS_PROP_CREATETXG))) {
704 dsl_prop_nvlist_add_uint64(out_props,
705 ZFS_PROP_CREATETXG, bmark_phys->zbm_creation_txg);
706 }
707 if (props == NULL || nvlist_exists(props,
708 zfs_prop_to_name(ZFS_PROP_CREATION))) {
709 dsl_prop_nvlist_add_uint64(out_props,
710 ZFS_PROP_CREATION, bmark_phys->zbm_creation_time);
711 }
712 if (props == NULL || nvlist_exists(props,
713 zfs_prop_to_name(ZFS_PROP_IVSET_GUID))) {
714 dsl_prop_nvlist_add_uint64(out_props,
715 ZFS_PROP_IVSET_GUID, bmark_phys->zbm_ivset_guid);
716 }
717 if (bmark_phys->zbm_flags & ZBM_FLAG_HAS_FBN) {
718 if (props == NULL || nvlist_exists(props,
719 zfs_prop_to_name(ZFS_PROP_REFERENCED))) {
720 dsl_prop_nvlist_add_uint64(out_props,
721 ZFS_PROP_REFERENCED,
722 bmark_phys->zbm_referenced_bytes_refd);
723 }
724 if (props == NULL || nvlist_exists(props,
725 zfs_prop_to_name(ZFS_PROP_LOGICALREFERENCED))) {
726 dsl_prop_nvlist_add_uint64(out_props,
727 ZFS_PROP_LOGICALREFERENCED,
728 bmark_phys->zbm_uncompressed_bytes_refd);
729 }
730 if (props == NULL || nvlist_exists(props,
731 zfs_prop_to_name(ZFS_PROP_REFRATIO))) {
732 uint64_t ratio =
733 bmark_phys->zbm_compressed_bytes_refd == 0 ? 100 :
734 bmark_phys->zbm_uncompressed_bytes_refd * 100 /
735 bmark_phys->zbm_compressed_bytes_refd;
736 dsl_prop_nvlist_add_uint64(out_props,
737 ZFS_PROP_REFRATIO, ratio);
738 }
739 }
740
741 if ((props == NULL || nvlist_exists(props, "redact_snaps") ||
742 nvlist_exists(props, "redact_complete")) &&
743 bmark_phys->zbm_redaction_obj != 0) {
744 redaction_list_t *rl;
745 int err = dsl_redaction_list_hold_obj(dp,
746 bmark_phys->zbm_redaction_obj, FTAG, &rl);
747 if (err == 0) {
748 if (nvlist_exists(props, "redact_snaps")) {
749 nvlist_t *nvl;
750 nvl = fnvlist_alloc();
751 fnvlist_add_uint64_array(nvl, ZPROP_VALUE,
752 rl->rl_phys->rlp_snaps,
753 rl->rl_phys->rlp_num_snaps);
754 fnvlist_add_nvlist(out_props, "redact_snaps",
755 nvl);
756 nvlist_free(nvl);
757 }
758 if (nvlist_exists(props, "redact_complete")) {
759 nvlist_t *nvl;
760 nvl = fnvlist_alloc();
761 fnvlist_add_boolean_value(nvl, ZPROP_VALUE,
762 rl->rl_phys->rlp_last_blkid == UINT64_MAX &&
763 rl->rl_phys->rlp_last_object == UINT64_MAX);
764 fnvlist_add_nvlist(out_props, "redact_complete",
765 nvl);
766 nvlist_free(nvl);
767 }
768 dsl_redaction_list_rele(rl, FTAG);
769 }
770 }
771 }
772
773 int
dsl_get_bookmarks_impl(dsl_dataset_t * ds,nvlist_t * props,nvlist_t * outnvl)774 dsl_get_bookmarks_impl(dsl_dataset_t *ds, nvlist_t *props, nvlist_t *outnvl)
775 {
776 dsl_pool_t *dp = ds->ds_dir->dd_pool;
777
778 ASSERT(dsl_pool_config_held(dp));
779
780 if (dsl_dataset_is_snapshot(ds))
781 return (SET_ERROR(EINVAL));
782
783 for (dsl_bookmark_node_t *dbn = avl_first(&ds->ds_bookmarks);
784 dbn != NULL; dbn = AVL_NEXT(&ds->ds_bookmarks, dbn)) {
785 nvlist_t *out_props = fnvlist_alloc();
786
787 dsl_bookmark_fetch_props(dp, &dbn->dbn_phys, props, out_props);
788
789 fnvlist_add_nvlist(outnvl, dbn->dbn_name, out_props);
790 fnvlist_free(out_props);
791 }
792 return (0);
793 }
794
795 /*
796 * Comparison func for ds_bookmarks AVL tree. We sort the bookmarks by
797 * their TXG, then by their FBN-ness. The "FBN-ness" component ensures
798 * that all bookmarks at the same TXG that HAS_FBN are adjacent, which
799 * dsl_bookmark_destroy_sync_impl() depends on. Note that there may be
800 * multiple bookmarks at the same TXG (with the same FBN-ness). In this
801 * case we differentiate them by an arbitrary metric (in this case,
802 * their names).
803 */
804 static int
dsl_bookmark_compare(const void * l,const void * r)805 dsl_bookmark_compare(const void *l, const void *r)
806 {
807 const dsl_bookmark_node_t *ldbn = l;
808 const dsl_bookmark_node_t *rdbn = r;
809
810 int64_t cmp = TREE_CMP(ldbn->dbn_phys.zbm_creation_txg,
811 rdbn->dbn_phys.zbm_creation_txg);
812 if (likely(cmp))
813 return (cmp);
814 cmp = TREE_CMP((ldbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN),
815 (rdbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN));
816 if (likely(cmp))
817 return (cmp);
818 cmp = strcmp(ldbn->dbn_name, rdbn->dbn_name);
819 return (TREE_ISIGN(cmp));
820 }
821
822 /*
823 * Cache this (head) dataset's bookmarks in the ds_bookmarks AVL tree.
824 */
825 int
dsl_bookmark_init_ds(dsl_dataset_t * ds)826 dsl_bookmark_init_ds(dsl_dataset_t *ds)
827 {
828 dsl_pool_t *dp = ds->ds_dir->dd_pool;
829 objset_t *mos = dp->dp_meta_objset;
830
831 ASSERT(!ds->ds_is_snapshot);
832
833 avl_create(&ds->ds_bookmarks, dsl_bookmark_compare,
834 sizeof (dsl_bookmark_node_t),
835 offsetof(dsl_bookmark_node_t, dbn_node));
836
837 if (!dsl_dataset_is_zapified(ds))
838 return (0);
839
840 int zaperr = zap_lookup(mos, ds->ds_object, DS_FIELD_BOOKMARK_NAMES,
841 sizeof (ds->ds_bookmarks_obj), 1, &ds->ds_bookmarks_obj);
842 if (zaperr == ENOENT)
843 return (0);
844 if (zaperr != 0)
845 return (zaperr);
846
847 if (ds->ds_bookmarks_obj == 0)
848 return (0);
849
850 int err = 0;
851 zap_cursor_t zc;
852 zap_attribute_t attr;
853
854 for (zap_cursor_init(&zc, mos, ds->ds_bookmarks_obj);
855 (err = zap_cursor_retrieve(&zc, &attr)) == 0;
856 zap_cursor_advance(&zc)) {
857 dsl_bookmark_node_t *dbn =
858 dsl_bookmark_node_alloc(attr.za_name);
859
860 err = dsl_bookmark_lookup_impl(ds,
861 dbn->dbn_name, &dbn->dbn_phys);
862 ASSERT3U(err, !=, ENOENT);
863 if (err != 0) {
864 kmem_free(dbn, sizeof (*dbn));
865 break;
866 }
867 avl_add(&ds->ds_bookmarks, dbn);
868 }
869 zap_cursor_fini(&zc);
870 if (err == ENOENT)
871 err = 0;
872 return (err);
873 }
874
875 void
dsl_bookmark_fini_ds(dsl_dataset_t * ds)876 dsl_bookmark_fini_ds(dsl_dataset_t *ds)
877 {
878 void *cookie = NULL;
879 dsl_bookmark_node_t *dbn;
880
881 if (ds->ds_is_snapshot)
882 return;
883
884 while ((dbn = avl_destroy_nodes(&ds->ds_bookmarks, &cookie)) != NULL) {
885 spa_strfree(dbn->dbn_name);
886 mutex_destroy(&dbn->dbn_lock);
887 kmem_free(dbn, sizeof (*dbn));
888 }
889 avl_destroy(&ds->ds_bookmarks);
890 }
891
892 /*
893 * Retrieve the bookmarks that exist in the specified dataset, and the
894 * requested properties of each bookmark.
895 *
896 * The "props" nvlist specifies which properties are requested.
897 * See lzc_get_bookmarks() for the list of valid properties.
898 */
899 int
dsl_get_bookmarks(const char * dsname,nvlist_t * props,nvlist_t * outnvl)900 dsl_get_bookmarks(const char *dsname, nvlist_t *props, nvlist_t *outnvl)
901 {
902 dsl_pool_t *dp;
903 dsl_dataset_t *ds;
904 int err;
905
906 err = dsl_pool_hold(dsname, FTAG, &dp);
907 if (err != 0)
908 return (err);
909 err = dsl_dataset_hold(dp, dsname, FTAG, &ds);
910 if (err != 0) {
911 dsl_pool_rele(dp, FTAG);
912 return (err);
913 }
914
915 err = dsl_get_bookmarks_impl(ds, props, outnvl);
916
917 dsl_dataset_rele(ds, FTAG);
918 dsl_pool_rele(dp, FTAG);
919 return (err);
920 }
921
922 /*
923 * Retrieve all properties for a single bookmark in the given dataset.
924 */
925 int
dsl_get_bookmark_props(const char * dsname,const char * bmname,nvlist_t * props)926 dsl_get_bookmark_props(const char *dsname, const char *bmname, nvlist_t *props)
927 {
928 dsl_pool_t *dp;
929 dsl_dataset_t *ds;
930 zfs_bookmark_phys_t bmark_phys = { 0 };
931 int err;
932
933 err = dsl_pool_hold(dsname, FTAG, &dp);
934 if (err != 0)
935 return (err);
936 err = dsl_dataset_hold(dp, dsname, FTAG, &ds);
937 if (err != 0) {
938 dsl_pool_rele(dp, FTAG);
939 return (err);
940 }
941
942 err = dsl_bookmark_lookup_impl(ds, bmname, &bmark_phys);
943 if (err != 0)
944 goto out;
945
946 dsl_bookmark_fetch_props(dp, &bmark_phys, NULL, props);
947 out:
948 dsl_dataset_rele(ds, FTAG);
949 dsl_pool_rele(dp, FTAG);
950 return (err);
951 }
952
953 typedef struct dsl_bookmark_destroy_arg {
954 nvlist_t *dbda_bmarks;
955 nvlist_t *dbda_success;
956 nvlist_t *dbda_errors;
957 } dsl_bookmark_destroy_arg_t;
958
959 static void
dsl_bookmark_destroy_sync_impl(dsl_dataset_t * ds,const char * name,dmu_tx_t * tx)960 dsl_bookmark_destroy_sync_impl(dsl_dataset_t *ds, const char *name,
961 dmu_tx_t *tx)
962 {
963 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
964 uint64_t bmark_zapobj = ds->ds_bookmarks_obj;
965 matchtype_t mt = 0;
966 uint64_t int_size, num_ints;
967 /*
968 * 'search' must be zeroed so that dbn_flags (which is used in
969 * dsl_bookmark_compare()) will be zeroed even if the on-disk
970 * (in ZAP) bookmark is shorter than offsetof(dbn_flags).
971 */
972 dsl_bookmark_node_t search = { 0 };
973 char realname[ZFS_MAX_DATASET_NAME_LEN];
974
975 /*
976 * Find the real name of this bookmark, which may be different
977 * from the given name if the dataset is case-insensitive. Then
978 * use the real name to find the node in the ds_bookmarks AVL tree.
979 */
980
981 if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
982 mt = MT_NORMALIZE;
983
984 VERIFY0(zap_length(mos, bmark_zapobj, name, &int_size, &num_ints));
985
986 ASSERT3U(int_size, ==, sizeof (uint64_t));
987
988 if (num_ints * int_size > BOOKMARK_PHYS_SIZE_V1) {
989 spa_feature_decr(dmu_objset_spa(mos),
990 SPA_FEATURE_BOOKMARK_V2, tx);
991 }
992 VERIFY0(zap_lookup_norm(mos, bmark_zapobj, name, sizeof (uint64_t),
993 num_ints, &search.dbn_phys, mt, realname, sizeof (realname), NULL));
994
995 search.dbn_name = realname;
996 dsl_bookmark_node_t *dbn = avl_find(&ds->ds_bookmarks, &search, NULL);
997 ASSERT(dbn != NULL);
998
999 if (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) {
1000 /*
1001 * If this bookmark HAS_FBN, and it is before the most
1002 * recent snapshot, then its TXG is a key in the head's
1003 * deadlist (and all clones' heads' deadlists). If this is
1004 * the last thing keeping the key (i.e. there are no more
1005 * bookmarks with HAS_FBN at this TXG, and there is no
1006 * snapshot at this TXG), then remove the key.
1007 *
1008 * Note that this algorithm depends on ds_bookmarks being
1009 * sorted such that all bookmarks at the same TXG with
1010 * HAS_FBN are adjacent (with no non-HAS_FBN bookmarks
1011 * at the same TXG in between them). If this were not
1012 * the case, we would need to examine *all* bookmarks
1013 * at this TXG, rather than just the adjacent ones.
1014 */
1015
1016 dsl_bookmark_node_t *dbn_prev =
1017 AVL_PREV(&ds->ds_bookmarks, dbn);
1018 dsl_bookmark_node_t *dbn_next =
1019 AVL_NEXT(&ds->ds_bookmarks, dbn);
1020
1021 boolean_t more_bookmarks_at_this_txg =
1022 (dbn_prev != NULL && dbn_prev->dbn_phys.zbm_creation_txg ==
1023 dbn->dbn_phys.zbm_creation_txg &&
1024 (dbn_prev->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN)) ||
1025 (dbn_next != NULL && dbn_next->dbn_phys.zbm_creation_txg ==
1026 dbn->dbn_phys.zbm_creation_txg &&
1027 (dbn_next->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN));
1028
1029 if (!(dbn->dbn_phys.zbm_flags & ZBM_FLAG_SNAPSHOT_EXISTS) &&
1030 !more_bookmarks_at_this_txg &&
1031 dbn->dbn_phys.zbm_creation_txg <
1032 dsl_dataset_phys(ds)->ds_prev_snap_txg) {
1033 dsl_dir_remove_clones_key(ds->ds_dir,
1034 dbn->dbn_phys.zbm_creation_txg, tx);
1035 dsl_deadlist_remove_key(&ds->ds_deadlist,
1036 dbn->dbn_phys.zbm_creation_txg, tx);
1037 }
1038
1039 spa_feature_decr(dmu_objset_spa(mos),
1040 SPA_FEATURE_BOOKMARK_WRITTEN, tx);
1041 }
1042
1043 if (dbn->dbn_phys.zbm_redaction_obj != 0) {
1044 VERIFY0(dmu_object_free(mos,
1045 dbn->dbn_phys.zbm_redaction_obj, tx));
1046 spa_feature_decr(dmu_objset_spa(mos),
1047 SPA_FEATURE_REDACTION_BOOKMARKS, tx);
1048 }
1049
1050 avl_remove(&ds->ds_bookmarks, dbn);
1051 spa_strfree(dbn->dbn_name);
1052 mutex_destroy(&dbn->dbn_lock);
1053 kmem_free(dbn, sizeof (*dbn));
1054
1055 VERIFY0(zap_remove_norm(mos, bmark_zapobj, name, mt, tx));
1056 }
1057
1058 static int
dsl_bookmark_destroy_check(void * arg,dmu_tx_t * tx)1059 dsl_bookmark_destroy_check(void *arg, dmu_tx_t *tx)
1060 {
1061 dsl_bookmark_destroy_arg_t *dbda = arg;
1062 dsl_pool_t *dp = dmu_tx_pool(tx);
1063 int rv = 0;
1064
1065 ASSERT(nvlist_empty(dbda->dbda_success));
1066 ASSERT(nvlist_empty(dbda->dbda_errors));
1067
1068 if (!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARKS))
1069 return (0);
1070
1071 for (nvpair_t *pair = nvlist_next_nvpair(dbda->dbda_bmarks, NULL);
1072 pair != NULL; pair = nvlist_next_nvpair(dbda->dbda_bmarks, pair)) {
1073 const char *fullname = nvpair_name(pair);
1074 dsl_dataset_t *ds;
1075 zfs_bookmark_phys_t bm;
1076 int error;
1077 char *shortname;
1078
1079 error = dsl_bookmark_hold_ds(dp, fullname, &ds,
1080 FTAG, &shortname);
1081 if (error == ENOENT) {
1082 /* ignore it; the bookmark is "already destroyed" */
1083 continue;
1084 }
1085 if (error == 0) {
1086 error = dsl_bookmark_lookup_impl(ds, shortname, &bm);
1087 dsl_dataset_rele(ds, FTAG);
1088 if (error == ESRCH) {
1089 /*
1090 * ignore it; the bookmark is
1091 * "already destroyed"
1092 */
1093 continue;
1094 }
1095 if (error == 0 && bm.zbm_redaction_obj != 0) {
1096 redaction_list_t *rl = NULL;
1097 error = dsl_redaction_list_hold_obj(tx->tx_pool,
1098 bm.zbm_redaction_obj, FTAG, &rl);
1099 if (error == ENOENT) {
1100 error = 0;
1101 } else if (error == 0 &&
1102 dsl_redaction_list_long_held(rl)) {
1103 error = SET_ERROR(EBUSY);
1104 }
1105 if (rl != NULL) {
1106 dsl_redaction_list_rele(rl, FTAG);
1107 }
1108 }
1109 }
1110 if (error == 0) {
1111 if (dmu_tx_is_syncing(tx)) {
1112 fnvlist_add_boolean(dbda->dbda_success,
1113 fullname);
1114 }
1115 } else {
1116 fnvlist_add_int32(dbda->dbda_errors, fullname, error);
1117 rv = error;
1118 }
1119 }
1120 return (rv);
1121 }
1122
1123 static void
dsl_bookmark_destroy_sync(void * arg,dmu_tx_t * tx)1124 dsl_bookmark_destroy_sync(void *arg, dmu_tx_t *tx)
1125 {
1126 dsl_bookmark_destroy_arg_t *dbda = arg;
1127 dsl_pool_t *dp = dmu_tx_pool(tx);
1128 objset_t *mos = dp->dp_meta_objset;
1129
1130 for (nvpair_t *pair = nvlist_next_nvpair(dbda->dbda_success, NULL);
1131 pair != NULL; pair = nvlist_next_nvpair(dbda->dbda_success, pair)) {
1132 dsl_dataset_t *ds;
1133 char *shortname;
1134 uint64_t zap_cnt;
1135
1136 VERIFY0(dsl_bookmark_hold_ds(dp, nvpair_name(pair),
1137 &ds, FTAG, &shortname));
1138 dsl_bookmark_destroy_sync_impl(ds, shortname, tx);
1139
1140 /*
1141 * If all of this dataset's bookmarks have been destroyed,
1142 * free the zap object and decrement the feature's use count.
1143 */
1144 VERIFY0(zap_count(mos, ds->ds_bookmarks_obj, &zap_cnt));
1145 if (zap_cnt == 0) {
1146 dmu_buf_will_dirty(ds->ds_dbuf, tx);
1147 VERIFY0(zap_destroy(mos, ds->ds_bookmarks_obj, tx));
1148 ds->ds_bookmarks_obj = 0;
1149 spa_feature_decr(dp->dp_spa, SPA_FEATURE_BOOKMARKS, tx);
1150 VERIFY0(zap_remove(mos, ds->ds_object,
1151 DS_FIELD_BOOKMARK_NAMES, tx));
1152 }
1153
1154 spa_history_log_internal_ds(ds, "remove bookmark", tx,
1155 "name=%s", shortname);
1156
1157 dsl_dataset_rele(ds, FTAG);
1158 }
1159 }
1160
1161 /*
1162 * The bookmarks must all be in the same pool.
1163 */
1164 int
dsl_bookmark_destroy(nvlist_t * bmarks,nvlist_t * errors)1165 dsl_bookmark_destroy(nvlist_t *bmarks, nvlist_t *errors)
1166 {
1167 int rv;
1168 dsl_bookmark_destroy_arg_t dbda;
1169 nvpair_t *pair = nvlist_next_nvpair(bmarks, NULL);
1170 if (pair == NULL)
1171 return (0);
1172
1173 dbda.dbda_bmarks = bmarks;
1174 dbda.dbda_errors = errors;
1175 dbda.dbda_success = fnvlist_alloc();
1176
1177 rv = dsl_sync_task(nvpair_name(pair), dsl_bookmark_destroy_check,
1178 dsl_bookmark_destroy_sync, &dbda, fnvlist_num_pairs(bmarks),
1179 ZFS_SPACE_CHECK_RESERVED);
1180 fnvlist_free(dbda.dbda_success);
1181 return (rv);
1182 }
1183
1184 /* Return B_TRUE if there are any long holds on this dataset. */
1185 boolean_t
dsl_redaction_list_long_held(redaction_list_t * rl)1186 dsl_redaction_list_long_held(redaction_list_t *rl)
1187 {
1188 return (!zfs_refcount_is_zero(&rl->rl_longholds));
1189 }
1190
1191 void
dsl_redaction_list_long_hold(dsl_pool_t * dp,redaction_list_t * rl,void * tag)1192 dsl_redaction_list_long_hold(dsl_pool_t *dp, redaction_list_t *rl, void *tag)
1193 {
1194 ASSERT(dsl_pool_config_held(dp));
1195 (void) zfs_refcount_add(&rl->rl_longholds, tag);
1196 }
1197
1198 void
dsl_redaction_list_long_rele(redaction_list_t * rl,void * tag)1199 dsl_redaction_list_long_rele(redaction_list_t *rl, void *tag)
1200 {
1201 (void) zfs_refcount_remove(&rl->rl_longholds, tag);
1202 }
1203
1204 static void
redaction_list_evict_sync(void * rlu)1205 redaction_list_evict_sync(void *rlu)
1206 {
1207 redaction_list_t *rl = rlu;
1208 zfs_refcount_destroy(&rl->rl_longholds);
1209
1210 kmem_free(rl, sizeof (redaction_list_t));
1211 }
1212
1213 void
dsl_redaction_list_rele(redaction_list_t * rl,void * tag)1214 dsl_redaction_list_rele(redaction_list_t *rl, void *tag)
1215 {
1216 dmu_buf_rele(rl->rl_dbuf, tag);
1217 }
1218
1219 int
dsl_redaction_list_hold_obj(dsl_pool_t * dp,uint64_t rlobj,void * tag,redaction_list_t ** rlp)1220 dsl_redaction_list_hold_obj(dsl_pool_t *dp, uint64_t rlobj, void *tag,
1221 redaction_list_t **rlp)
1222 {
1223 objset_t *mos = dp->dp_meta_objset;
1224 dmu_buf_t *dbuf;
1225 redaction_list_t *rl;
1226 int err;
1227
1228 ASSERT(dsl_pool_config_held(dp));
1229
1230 err = dmu_bonus_hold(mos, rlobj, tag, &dbuf);
1231 if (err != 0)
1232 return (err);
1233
1234 rl = dmu_buf_get_user(dbuf);
1235 if (rl == NULL) {
1236 redaction_list_t *winner = NULL;
1237
1238 rl = kmem_zalloc(sizeof (redaction_list_t), KM_SLEEP);
1239 rl->rl_dbuf = dbuf;
1240 rl->rl_object = rlobj;
1241 rl->rl_phys = dbuf->db_data;
1242 rl->rl_mos = dp->dp_meta_objset;
1243 zfs_refcount_create(&rl->rl_longholds);
1244 dmu_buf_init_user(&rl->rl_dbu, redaction_list_evict_sync, NULL,
1245 &rl->rl_dbuf);
1246 if ((winner = dmu_buf_set_user_ie(dbuf, &rl->rl_dbu)) != NULL) {
1247 kmem_free(rl, sizeof (*rl));
1248 rl = winner;
1249 }
1250 }
1251 *rlp = rl;
1252 return (0);
1253 }
1254
1255 /*
1256 * Snapshot ds is being destroyed.
1257 *
1258 * Adjust the "freed_before_next" of any bookmarks between this snap
1259 * and the previous snapshot, because their "next snapshot" is changing.
1260 *
1261 * If there are any bookmarks with HAS_FBN at this snapshot, remove
1262 * their HAS_SNAP flag (note: there can be at most one snapshot of
1263 * each filesystem at a given txg), and return B_TRUE. In this case
1264 * the caller can not remove the key in the deadlist at this TXG, because
1265 * the HAS_FBN bookmarks require the key be there.
1266 *
1267 * Returns B_FALSE if there are no bookmarks with HAS_FBN at this
1268 * snapshot's TXG. In this case the caller can remove the key in the
1269 * deadlist at this TXG.
1270 */
1271 boolean_t
dsl_bookmark_ds_destroyed(dsl_dataset_t * ds,dmu_tx_t * tx)1272 dsl_bookmark_ds_destroyed(dsl_dataset_t *ds, dmu_tx_t *tx)
1273 {
1274 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1275
1276 dsl_dataset_t *head, *next;
1277 VERIFY0(dsl_dataset_hold_obj(dp,
1278 dsl_dir_phys(ds->ds_dir)->dd_head_dataset_obj, FTAG, &head));
1279 VERIFY0(dsl_dataset_hold_obj(dp,
1280 dsl_dataset_phys(ds)->ds_next_snap_obj, FTAG, &next));
1281
1282 /*
1283 * Find the first bookmark that HAS_FBN at or after the
1284 * previous snapshot.
1285 */
1286 dsl_bookmark_node_t search = { 0 };
1287 avl_index_t idx;
1288 search.dbn_phys.zbm_creation_txg =
1289 dsl_dataset_phys(ds)->ds_prev_snap_txg;
1290 search.dbn_phys.zbm_flags = ZBM_FLAG_HAS_FBN;
1291 /*
1292 * The empty-string name can't be in the AVL, and it compares
1293 * before any entries with this TXG.
1294 */
1295 search.dbn_name = "";
1296 VERIFY3P(avl_find(&head->ds_bookmarks, &search, &idx), ==, NULL);
1297 dsl_bookmark_node_t *dbn =
1298 avl_nearest(&head->ds_bookmarks, idx, AVL_AFTER);
1299
1300 /*
1301 * Iterate over all bookmarks that are at or after the previous
1302 * snapshot, and before this (being deleted) snapshot. Adjust
1303 * their FBN based on their new next snapshot.
1304 */
1305 for (; dbn != NULL && dbn->dbn_phys.zbm_creation_txg <
1306 dsl_dataset_phys(ds)->ds_creation_txg;
1307 dbn = AVL_NEXT(&head->ds_bookmarks, dbn)) {
1308 if (!(dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN))
1309 continue;
1310 /*
1311 * Increase our FBN by the amount of space that was live
1312 * (referenced) at the time of this bookmark (i.e.
1313 * birth <= zbm_creation_txg), and killed between this
1314 * (being deleted) snapshot and the next snapshot (i.e.
1315 * on the next snapshot's deadlist). (Space killed before
1316 * this are already on our FBN.)
1317 */
1318 uint64_t referenced, compressed, uncompressed;
1319 dsl_deadlist_space_range(&next->ds_deadlist,
1320 0, dbn->dbn_phys.zbm_creation_txg,
1321 &referenced, &compressed, &uncompressed);
1322 dbn->dbn_phys.zbm_referenced_freed_before_next_snap +=
1323 referenced;
1324 dbn->dbn_phys.zbm_compressed_freed_before_next_snap +=
1325 compressed;
1326 dbn->dbn_phys.zbm_uncompressed_freed_before_next_snap +=
1327 uncompressed;
1328 VERIFY0(zap_update(dp->dp_meta_objset, head->ds_bookmarks_obj,
1329 dbn->dbn_name, sizeof (uint64_t),
1330 sizeof (zfs_bookmark_phys_t) / sizeof (uint64_t),
1331 &dbn->dbn_phys, tx));
1332 }
1333 dsl_dataset_rele(next, FTAG);
1334
1335 /*
1336 * There may be several bookmarks at this txg (the TXG of the
1337 * snapshot being deleted). We need to clear the SNAPSHOT_EXISTS
1338 * flag on all of them, and return TRUE if there is at least 1
1339 * bookmark here with HAS_FBN (thus preventing the deadlist
1340 * key from being removed).
1341 */
1342 boolean_t rv = B_FALSE;
1343 for (; dbn != NULL && dbn->dbn_phys.zbm_creation_txg ==
1344 dsl_dataset_phys(ds)->ds_creation_txg;
1345 dbn = AVL_NEXT(&head->ds_bookmarks, dbn)) {
1346 if (!(dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN)) {
1347 ASSERT(!(dbn->dbn_phys.zbm_flags &
1348 ZBM_FLAG_SNAPSHOT_EXISTS));
1349 continue;
1350 }
1351 ASSERT(dbn->dbn_phys.zbm_flags & ZBM_FLAG_SNAPSHOT_EXISTS);
1352 dbn->dbn_phys.zbm_flags &= ~ZBM_FLAG_SNAPSHOT_EXISTS;
1353 VERIFY0(zap_update(dp->dp_meta_objset, head->ds_bookmarks_obj,
1354 dbn->dbn_name, sizeof (uint64_t),
1355 sizeof (zfs_bookmark_phys_t) / sizeof (uint64_t),
1356 &dbn->dbn_phys, tx));
1357 rv = B_TRUE;
1358 }
1359 dsl_dataset_rele(head, FTAG);
1360 return (rv);
1361 }
1362
1363 /*
1364 * A snapshot is being created of this (head) dataset.
1365 *
1366 * We don't keep keys in the deadlist for the most recent snapshot, or any
1367 * bookmarks at or after it, because there can't be any blocks on the
1368 * deadlist in this range. Now that the most recent snapshot is after
1369 * all bookmarks, we need to add these keys. Note that the caller always
1370 * adds a key at the previous snapshot, so we only add keys for bookmarks
1371 * after that.
1372 */
1373 void
dsl_bookmark_snapshotted(dsl_dataset_t * ds,dmu_tx_t * tx)1374 dsl_bookmark_snapshotted(dsl_dataset_t *ds, dmu_tx_t *tx)
1375 {
1376 uint64_t last_key_added = UINT64_MAX;
1377 for (dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
1378 dbn != NULL && dbn->dbn_phys.zbm_creation_txg >
1379 dsl_dataset_phys(ds)->ds_prev_snap_txg;
1380 dbn = AVL_PREV(&ds->ds_bookmarks, dbn)) {
1381 uint64_t creation_txg = dbn->dbn_phys.zbm_creation_txg;
1382 ASSERT3U(creation_txg, <=, last_key_added);
1383 /*
1384 * Note, there may be multiple bookmarks at this TXG,
1385 * and we only want to add the key for this TXG once.
1386 * The ds_bookmarks AVL is sorted by TXG, so we will visit
1387 * these bookmarks in sequence.
1388 */
1389 if ((dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) &&
1390 creation_txg != last_key_added) {
1391 dsl_deadlist_add_key(&ds->ds_deadlist,
1392 creation_txg, tx);
1393 last_key_added = creation_txg;
1394 }
1395 }
1396 }
1397
1398 /*
1399 * The next snapshot of the origin dataset has changed, due to
1400 * promote or clone swap. If there are any bookmarks at this dataset,
1401 * we need to update their zbm_*_freed_before_next_snap to reflect this.
1402 * The head dataset has the relevant bookmarks in ds_bookmarks.
1403 */
1404 void
dsl_bookmark_next_changed(dsl_dataset_t * head,dsl_dataset_t * origin,dmu_tx_t * tx)1405 dsl_bookmark_next_changed(dsl_dataset_t *head, dsl_dataset_t *origin,
1406 dmu_tx_t *tx)
1407 {
1408 dsl_pool_t *dp = dmu_tx_pool(tx);
1409
1410 /*
1411 * Find the first bookmark that HAS_FBN at the origin snapshot.
1412 */
1413 dsl_bookmark_node_t search = { 0 };
1414 avl_index_t idx;
1415 search.dbn_phys.zbm_creation_txg =
1416 dsl_dataset_phys(origin)->ds_creation_txg;
1417 search.dbn_phys.zbm_flags = ZBM_FLAG_HAS_FBN;
1418 /*
1419 * The empty-string name can't be in the AVL, and it compares
1420 * before any entries with this TXG.
1421 */
1422 search.dbn_name = "";
1423 VERIFY3P(avl_find(&head->ds_bookmarks, &search, &idx), ==, NULL);
1424 dsl_bookmark_node_t *dbn =
1425 avl_nearest(&head->ds_bookmarks, idx, AVL_AFTER);
1426
1427 /*
1428 * Iterate over all bookmarks that are at the origin txg.
1429 * Adjust their FBN based on their new next snapshot.
1430 */
1431 for (; dbn != NULL && dbn->dbn_phys.zbm_creation_txg ==
1432 dsl_dataset_phys(origin)->ds_creation_txg &&
1433 (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN);
1434 dbn = AVL_NEXT(&head->ds_bookmarks, dbn)) {
1435
1436 /*
1437 * Bookmark is at the origin, therefore its
1438 * "next dataset" is changing, so we need
1439 * to reset its FBN by recomputing it in
1440 * dsl_bookmark_set_phys().
1441 */
1442 ASSERT3U(dbn->dbn_phys.zbm_guid, ==,
1443 dsl_dataset_phys(origin)->ds_guid);
1444 ASSERT3U(dbn->dbn_phys.zbm_referenced_bytes_refd, ==,
1445 dsl_dataset_phys(origin)->ds_referenced_bytes);
1446 ASSERT(dbn->dbn_phys.zbm_flags &
1447 ZBM_FLAG_SNAPSHOT_EXISTS);
1448 /*
1449 * Save and restore the zbm_redaction_obj, which
1450 * is zeroed by dsl_bookmark_set_phys().
1451 */
1452 uint64_t redaction_obj =
1453 dbn->dbn_phys.zbm_redaction_obj;
1454 dsl_bookmark_set_phys(&dbn->dbn_phys, origin);
1455 dbn->dbn_phys.zbm_redaction_obj = redaction_obj;
1456
1457 VERIFY0(zap_update(dp->dp_meta_objset, head->ds_bookmarks_obj,
1458 dbn->dbn_name, sizeof (uint64_t),
1459 sizeof (zfs_bookmark_phys_t) / sizeof (uint64_t),
1460 &dbn->dbn_phys, tx));
1461 }
1462 }
1463
1464 /*
1465 * This block is no longer referenced by this (head) dataset.
1466 *
1467 * Adjust the FBN of any bookmarks that reference this block, whose "next"
1468 * is the head dataset.
1469 */
1470 void
dsl_bookmark_block_killed(dsl_dataset_t * ds,const blkptr_t * bp,dmu_tx_t * tx)1471 dsl_bookmark_block_killed(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx)
1472 {
1473 (void) tx;
1474
1475 /*
1476 * Iterate over bookmarks whose "next" is the head dataset.
1477 */
1478 for (dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
1479 dbn != NULL && dbn->dbn_phys.zbm_creation_txg >=
1480 dsl_dataset_phys(ds)->ds_prev_snap_txg;
1481 dbn = AVL_PREV(&ds->ds_bookmarks, dbn)) {
1482 /*
1483 * If the block was live (referenced) at the time of this
1484 * bookmark, add its space to the bookmark's FBN.
1485 */
1486 if (bp->blk_birth <= dbn->dbn_phys.zbm_creation_txg &&
1487 (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN)) {
1488 mutex_enter(&dbn->dbn_lock);
1489 dbn->dbn_phys.zbm_referenced_freed_before_next_snap +=
1490 bp_get_dsize_sync(dsl_dataset_get_spa(ds), bp);
1491 dbn->dbn_phys.zbm_compressed_freed_before_next_snap +=
1492 BP_GET_PSIZE(bp);
1493 dbn->dbn_phys.zbm_uncompressed_freed_before_next_snap +=
1494 BP_GET_UCSIZE(bp);
1495 /*
1496 * Changing the ZAP object here would be too
1497 * expensive. Also, we may be called from the zio
1498 * interrupt thread, which can't block on i/o.
1499 * Therefore, we mark this bookmark as dirty and
1500 * modify the ZAP once per txg, in
1501 * dsl_bookmark_sync_done().
1502 */
1503 dbn->dbn_dirty = B_TRUE;
1504 mutex_exit(&dbn->dbn_lock);
1505 }
1506 }
1507 }
1508
1509 void
dsl_bookmark_sync_done(dsl_dataset_t * ds,dmu_tx_t * tx)1510 dsl_bookmark_sync_done(dsl_dataset_t *ds, dmu_tx_t *tx)
1511 {
1512 dsl_pool_t *dp = dmu_tx_pool(tx);
1513
1514 if (dsl_dataset_is_snapshot(ds))
1515 return;
1516
1517 /*
1518 * We only dirty bookmarks that are at or after the most recent
1519 * snapshot. We can't create snapshots between
1520 * dsl_bookmark_block_killed() and dsl_bookmark_sync_done(), so we
1521 * don't need to look at any bookmarks before ds_prev_snap_txg.
1522 */
1523 for (dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
1524 dbn != NULL && dbn->dbn_phys.zbm_creation_txg >=
1525 dsl_dataset_phys(ds)->ds_prev_snap_txg;
1526 dbn = AVL_PREV(&ds->ds_bookmarks, dbn)) {
1527 if (dbn->dbn_dirty) {
1528 /*
1529 * We only dirty nodes with HAS_FBN, therefore
1530 * we can always use the current bookmark struct size.
1531 */
1532 ASSERT(dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN);
1533 VERIFY0(zap_update(dp->dp_meta_objset,
1534 ds->ds_bookmarks_obj,
1535 dbn->dbn_name, sizeof (uint64_t),
1536 sizeof (zfs_bookmark_phys_t) / sizeof (uint64_t),
1537 &dbn->dbn_phys, tx));
1538 dbn->dbn_dirty = B_FALSE;
1539 }
1540 }
1541 #ifdef ZFS_DEBUG
1542 for (dsl_bookmark_node_t *dbn = avl_first(&ds->ds_bookmarks);
1543 dbn != NULL; dbn = AVL_NEXT(&ds->ds_bookmarks, dbn)) {
1544 ASSERT(!dbn->dbn_dirty);
1545 }
1546 #endif
1547 }
1548
1549 /*
1550 * Return the TXG of the most recent bookmark (or 0 if there are no bookmarks).
1551 */
1552 uint64_t
dsl_bookmark_latest_txg(dsl_dataset_t * ds)1553 dsl_bookmark_latest_txg(dsl_dataset_t *ds)
1554 {
1555 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
1556 dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
1557 if (dbn == NULL)
1558 return (0);
1559 return (dbn->dbn_phys.zbm_creation_txg);
1560 }
1561
1562 /*
1563 * Compare the redact_block_phys_t to the bookmark. If the last block in the
1564 * redact_block_phys_t is before the bookmark, return -1. If the first block in
1565 * the redact_block_phys_t is after the bookmark, return 1. Otherwise, the
1566 * bookmark is inside the range of the redact_block_phys_t, and we return 0.
1567 */
1568 static int
redact_block_zb_compare(redact_block_phys_t * first,zbookmark_phys_t * second)1569 redact_block_zb_compare(redact_block_phys_t *first,
1570 zbookmark_phys_t *second)
1571 {
1572 /*
1573 * If the block_phys is for a previous object, or the last block in the
1574 * block_phys is strictly before the block in the bookmark, the
1575 * block_phys is earlier.
1576 */
1577 if (first->rbp_object < second->zb_object ||
1578 (first->rbp_object == second->zb_object &&
1579 first->rbp_blkid + (redact_block_get_count(first) - 1) <
1580 second->zb_blkid)) {
1581 return (-1);
1582 }
1583
1584 /*
1585 * If the bookmark is for a previous object, or the block in the
1586 * bookmark is strictly before the first block in the block_phys, the
1587 * bookmark is earlier.
1588 */
1589 if (first->rbp_object > second->zb_object ||
1590 (first->rbp_object == second->zb_object &&
1591 first->rbp_blkid > second->zb_blkid)) {
1592 return (1);
1593 }
1594
1595 return (0);
1596 }
1597
1598 /*
1599 * Traverse the redaction list in the provided object, and call the callback for
1600 * each entry we find. Don't call the callback for any records before resume.
1601 */
1602 int
dsl_redaction_list_traverse(redaction_list_t * rl,zbookmark_phys_t * resume,rl_traverse_callback_t cb,void * arg)1603 dsl_redaction_list_traverse(redaction_list_t *rl, zbookmark_phys_t *resume,
1604 rl_traverse_callback_t cb, void *arg)
1605 {
1606 objset_t *mos = rl->rl_mos;
1607 int err = 0;
1608
1609 if (rl->rl_phys->rlp_last_object != UINT64_MAX ||
1610 rl->rl_phys->rlp_last_blkid != UINT64_MAX) {
1611 /*
1612 * When we finish a send, we update the last object and offset
1613 * to UINT64_MAX. If a send fails partway through, the last
1614 * object and offset will have some other value, indicating how
1615 * far the send got. The redaction list must be complete before
1616 * it can be traversed, so return EINVAL if the last object and
1617 * blkid are not set to UINT64_MAX.
1618 */
1619 return (SET_ERROR(EINVAL));
1620 }
1621
1622 /*
1623 * This allows us to skip the binary search and resume checking logic
1624 * below, if we're not resuming a redacted send.
1625 */
1626 if (ZB_IS_ZERO(resume))
1627 resume = NULL;
1628
1629 /*
1630 * Binary search for the point to resume from.
1631 */
1632 uint64_t maxidx = rl->rl_phys->rlp_num_entries - 1;
1633 uint64_t minidx = 0;
1634 while (resume != NULL && maxidx > minidx) {
1635 redact_block_phys_t rbp = { 0 };
1636 ASSERT3U(maxidx, >, minidx);
1637 uint64_t mididx = minidx + ((maxidx - minidx) / 2);
1638 err = dmu_read(mos, rl->rl_object, mididx * sizeof (rbp),
1639 sizeof (rbp), &rbp, DMU_READ_NO_PREFETCH);
1640 if (err != 0)
1641 break;
1642
1643 int cmp = redact_block_zb_compare(&rbp, resume);
1644
1645 if (cmp == 0) {
1646 minidx = mididx;
1647 break;
1648 } else if (cmp > 0) {
1649 maxidx =
1650 (mididx == minidx ? minidx : mididx - 1);
1651 } else {
1652 minidx = mididx + 1;
1653 }
1654 }
1655
1656 unsigned int bufsize = SPA_OLD_MAXBLOCKSIZE;
1657 redact_block_phys_t *buf = zio_data_buf_alloc(bufsize);
1658
1659 unsigned int entries_per_buf = bufsize / sizeof (redact_block_phys_t);
1660 uint64_t start_block = minidx / entries_per_buf;
1661 err = dmu_read(mos, rl->rl_object, start_block * bufsize, bufsize, buf,
1662 DMU_READ_PREFETCH);
1663
1664 for (uint64_t curidx = minidx;
1665 err == 0 && curidx < rl->rl_phys->rlp_num_entries;
1666 curidx++) {
1667 /*
1668 * We read in the redaction list one block at a time. Once we
1669 * finish with all the entries in a given block, we read in a
1670 * new one. The predictive prefetcher will take care of any
1671 * prefetching, and this code shouldn't be the bottleneck, so we
1672 * don't need to do manual prefetching.
1673 */
1674 if (curidx % entries_per_buf == 0) {
1675 err = dmu_read(mos, rl->rl_object, curidx *
1676 sizeof (*buf), bufsize, buf,
1677 DMU_READ_PREFETCH);
1678 if (err != 0)
1679 break;
1680 }
1681 redact_block_phys_t *rb = &buf[curidx % entries_per_buf];
1682 /*
1683 * If resume is non-null, we should either not send the data, or
1684 * null out resume so we don't have to keep doing these
1685 * comparisons.
1686 */
1687 if (resume != NULL) {
1688 /*
1689 * It is possible that after the binary search we got
1690 * a record before the resume point. There's two cases
1691 * where this can occur. If the record is the last
1692 * redaction record, and the resume point is after the
1693 * end of the redacted data, curidx will be the last
1694 * redaction record. In that case, the loop will end
1695 * after this iteration. The second case is if the
1696 * resume point is between two redaction records, the
1697 * binary search can return either the record before
1698 * or after the resume point. In that case, the next
1699 * iteration will be greater than the resume point.
1700 */
1701 if (redact_block_zb_compare(rb, resume) < 0) {
1702 ASSERT3U(curidx, ==, minidx);
1703 continue;
1704 } else {
1705 /*
1706 * If the place to resume is in the middle of
1707 * the range described by this
1708 * redact_block_phys, then modify the
1709 * redact_block_phys in memory so we generate
1710 * the right records.
1711 */
1712 if (resume->zb_object == rb->rbp_object &&
1713 resume->zb_blkid > rb->rbp_blkid) {
1714 uint64_t diff = resume->zb_blkid -
1715 rb->rbp_blkid;
1716 rb->rbp_blkid = resume->zb_blkid;
1717 redact_block_set_count(rb,
1718 redact_block_get_count(rb) - diff);
1719 }
1720 resume = NULL;
1721 }
1722 }
1723
1724 if (cb(rb, arg) != 0) {
1725 err = EINTR;
1726 break;
1727 }
1728 }
1729
1730 zio_data_buf_free(buf, bufsize);
1731 return (err);
1732 }
1733