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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2011, 2017 by Delphix. All rights reserved.
25 * Copyright (c) 2014, Joyent, Inc. All rights reserved.
26 * Copyright (c) 2014 RackTop Systems.
27 * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
28 * Copyright (c) 2014 Integros [integros.com]
29 * Copyright 2016, OmniTI Computer Consulting, Inc. All rights reserved.
30 * Copyright 2017 Nexenta Systems, Inc.
31 */
32
33 #include <sys/dmu_objset.h>
34 #include <sys/dsl_dataset.h>
35 #include <sys/dsl_dir.h>
36 #include <sys/dsl_prop.h>
37 #include <sys/dsl_synctask.h>
38 #include <sys/dmu_traverse.h>
39 #include <sys/dmu_impl.h>
40 #include <sys/dmu_tx.h>
41 #include <sys/arc.h>
42 #include <sys/zio.h>
43 #include <sys/zap.h>
44 #include <sys/zfeature.h>
45 #include <sys/unique.h>
46 #include <sys/zfs_context.h>
47 #include <sys/zfs_ioctl.h>
48 #include <sys/spa.h>
49 #include <sys/spa_impl.h>
50 #include <sys/vdev.h>
51 #include <sys/zfs_znode.h>
52 #include <sys/zfs_onexit.h>
53 #include <sys/zvol.h>
54 #include <sys/dsl_scan.h>
55 #include <sys/dsl_deadlist.h>
56 #include <sys/dsl_destroy.h>
57 #include <sys/dsl_userhold.h>
58 #include <sys/dsl_bookmark.h>
59 #include <sys/dmu_recv.h>
60 #include <sys/zio_checksum.h>
61 #include <sys/zio_compress.h>
62 #include <zfs_fletcher.h>
63
64 /*
65 * The SPA supports block sizes up to 16MB. However, very large blocks
66 * can have an impact on i/o latency (e.g. tying up a spinning disk for
67 * ~300ms), and also potentially on the memory allocator. Therefore,
68 * we do not allow the recordsize to be set larger than zfs_max_recordsize
69 * (default 1MB). Larger blocks can be created by changing this tunable,
70 * and pools with larger blocks can always be imported and used, regardless
71 * of this setting.
72 */
73 int zfs_max_recordsize = 1 * 1024 * 1024;
74
75 #define SWITCH64(x, y) \
76 { \
77 uint64_t __tmp = (x); \
78 (x) = (y); \
79 (y) = __tmp; \
80 }
81
82 #define DS_REF_MAX (1ULL << 62)
83
84 extern inline dsl_dataset_phys_t *dsl_dataset_phys(dsl_dataset_t *ds);
85
86 static void dsl_dataset_set_remap_deadlist_object(dsl_dataset_t *ds,
87 uint64_t obj, dmu_tx_t *tx);
88 static void dsl_dataset_unset_remap_deadlist_object(dsl_dataset_t *ds,
89 dmu_tx_t *tx);
90
91 extern int spa_asize_inflation;
92
93 static zil_header_t zero_zil;
94
95 /*
96 * Figure out how much of this delta should be propogated to the dsl_dir
97 * layer. If there's a refreservation, that space has already been
98 * partially accounted for in our ancestors.
99 */
100 static int64_t
parent_delta(dsl_dataset_t * ds,int64_t delta)101 parent_delta(dsl_dataset_t *ds, int64_t delta)
102 {
103 dsl_dataset_phys_t *ds_phys;
104 uint64_t old_bytes, new_bytes;
105
106 if (ds->ds_reserved == 0)
107 return (delta);
108
109 ds_phys = dsl_dataset_phys(ds);
110 old_bytes = MAX(ds_phys->ds_unique_bytes, ds->ds_reserved);
111 new_bytes = MAX(ds_phys->ds_unique_bytes + delta, ds->ds_reserved);
112
113 ASSERT3U(ABS((int64_t)(new_bytes - old_bytes)), <=, ABS(delta));
114 return (new_bytes - old_bytes);
115 }
116
117 void
dsl_dataset_block_born(dsl_dataset_t * ds,const blkptr_t * bp,dmu_tx_t * tx)118 dsl_dataset_block_born(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx)
119 {
120 int used = bp_get_dsize_sync(tx->tx_pool->dp_spa, bp);
121 int compressed = BP_GET_PSIZE(bp);
122 int uncompressed = BP_GET_UCSIZE(bp);
123 int64_t delta;
124
125 dprintf_bp(bp, "ds=%p", ds);
126
127 ASSERT(dmu_tx_is_syncing(tx));
128 /* It could have been compressed away to nothing */
129 if (BP_IS_HOLE(bp))
130 return;
131 ASSERT(BP_GET_TYPE(bp) != DMU_OT_NONE);
132 ASSERT(DMU_OT_IS_VALID(BP_GET_TYPE(bp)));
133 if (ds == NULL) {
134 dsl_pool_mos_diduse_space(tx->tx_pool,
135 used, compressed, uncompressed);
136 return;
137 }
138
139 ASSERT3U(bp->blk_birth, >, dsl_dataset_phys(ds)->ds_prev_snap_txg);
140 dmu_buf_will_dirty(ds->ds_dbuf, tx);
141 mutex_enter(&ds->ds_lock);
142 delta = parent_delta(ds, used);
143 dsl_dataset_phys(ds)->ds_referenced_bytes += used;
144 dsl_dataset_phys(ds)->ds_compressed_bytes += compressed;
145 dsl_dataset_phys(ds)->ds_uncompressed_bytes += uncompressed;
146 dsl_dataset_phys(ds)->ds_unique_bytes += used;
147
148 if (BP_GET_LSIZE(bp) > SPA_OLD_MAXBLOCKSIZE) {
149 ds->ds_feature_activation_needed[SPA_FEATURE_LARGE_BLOCKS] =
150 B_TRUE;
151 }
152
153 spa_feature_t f = zio_checksum_to_feature(BP_GET_CHECKSUM(bp));
154 if (f != SPA_FEATURE_NONE)
155 ds->ds_feature_activation_needed[f] = B_TRUE;
156
157 mutex_exit(&ds->ds_lock);
158 dsl_dir_diduse_space(ds->ds_dir, DD_USED_HEAD, delta,
159 compressed, uncompressed, tx);
160 dsl_dir_transfer_space(ds->ds_dir, used - delta,
161 DD_USED_REFRSRV, DD_USED_HEAD, tx);
162 }
163
164 /*
165 * Called when the specified segment has been remapped, and is thus no
166 * longer referenced in the head dataset. The vdev must be indirect.
167 *
168 * If the segment is referenced by a snapshot, put it on the remap deadlist.
169 * Otherwise, add this segment to the obsolete spacemap.
170 */
171 void
dsl_dataset_block_remapped(dsl_dataset_t * ds,uint64_t vdev,uint64_t offset,uint64_t size,uint64_t birth,dmu_tx_t * tx)172 dsl_dataset_block_remapped(dsl_dataset_t *ds, uint64_t vdev, uint64_t offset,
173 uint64_t size, uint64_t birth, dmu_tx_t *tx)
174 {
175 spa_t *spa = ds->ds_dir->dd_pool->dp_spa;
176
177 ASSERT(dmu_tx_is_syncing(tx));
178 ASSERT(birth <= tx->tx_txg);
179 ASSERT(!ds->ds_is_snapshot);
180
181 if (birth > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
182 spa_vdev_indirect_mark_obsolete(spa, vdev, offset, size, tx);
183 } else {
184 blkptr_t fakebp;
185 dva_t *dva = &fakebp.blk_dva[0];
186
187 ASSERT(ds != NULL);
188
189 mutex_enter(&ds->ds_remap_deadlist_lock);
190 if (!dsl_dataset_remap_deadlist_exists(ds)) {
191 dsl_dataset_create_remap_deadlist(ds, tx);
192 }
193 mutex_exit(&ds->ds_remap_deadlist_lock);
194
195 BP_ZERO(&fakebp);
196 fakebp.blk_birth = birth;
197 DVA_SET_VDEV(dva, vdev);
198 DVA_SET_OFFSET(dva, offset);
199 DVA_SET_ASIZE(dva, size);
200
201 dsl_deadlist_insert(&ds->ds_remap_deadlist, &fakebp, tx);
202 }
203 }
204
205 int
dsl_dataset_block_kill(dsl_dataset_t * ds,const blkptr_t * bp,dmu_tx_t * tx,boolean_t async)206 dsl_dataset_block_kill(dsl_dataset_t *ds, const blkptr_t *bp, dmu_tx_t *tx,
207 boolean_t async)
208 {
209 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
210
211 int used = bp_get_dsize_sync(spa, bp);
212 int compressed = BP_GET_PSIZE(bp);
213 int uncompressed = BP_GET_UCSIZE(bp);
214
215 if (BP_IS_HOLE(bp))
216 return (0);
217
218 ASSERT(dmu_tx_is_syncing(tx));
219 ASSERT(bp->blk_birth <= tx->tx_txg);
220
221 if (ds == NULL) {
222 dsl_free(tx->tx_pool, tx->tx_txg, bp);
223 dsl_pool_mos_diduse_space(tx->tx_pool,
224 -used, -compressed, -uncompressed);
225 return (used);
226 }
227 ASSERT3P(tx->tx_pool, ==, ds->ds_dir->dd_pool);
228
229 ASSERT(!ds->ds_is_snapshot);
230 dmu_buf_will_dirty(ds->ds_dbuf, tx);
231
232 if (bp->blk_birth > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
233 int64_t delta;
234
235 dprintf_bp(bp, "freeing ds=%llu", ds->ds_object);
236 dsl_free(tx->tx_pool, tx->tx_txg, bp);
237
238 mutex_enter(&ds->ds_lock);
239 ASSERT(dsl_dataset_phys(ds)->ds_unique_bytes >= used ||
240 !DS_UNIQUE_IS_ACCURATE(ds));
241 delta = parent_delta(ds, -used);
242 dsl_dataset_phys(ds)->ds_unique_bytes -= used;
243 mutex_exit(&ds->ds_lock);
244 dsl_dir_diduse_space(ds->ds_dir, DD_USED_HEAD,
245 delta, -compressed, -uncompressed, tx);
246 dsl_dir_transfer_space(ds->ds_dir, -used - delta,
247 DD_USED_REFRSRV, DD_USED_HEAD, tx);
248 } else {
249 dprintf_bp(bp, "putting on dead list: %s", "");
250 if (async) {
251 /*
252 * We are here as part of zio's write done callback,
253 * which means we're a zio interrupt thread. We can't
254 * call dsl_deadlist_insert() now because it may block
255 * waiting for I/O. Instead, put bp on the deferred
256 * queue and let dsl_pool_sync() finish the job.
257 */
258 bplist_append(&ds->ds_pending_deadlist, bp);
259 } else {
260 dsl_deadlist_insert(&ds->ds_deadlist, bp, tx);
261 }
262 ASSERT3U(ds->ds_prev->ds_object, ==,
263 dsl_dataset_phys(ds)->ds_prev_snap_obj);
264 ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_num_children > 0);
265 /* if (bp->blk_birth > prev prev snap txg) prev unique += bs */
266 if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
267 ds->ds_object && bp->blk_birth >
268 dsl_dataset_phys(ds->ds_prev)->ds_prev_snap_txg) {
269 dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
270 mutex_enter(&ds->ds_prev->ds_lock);
271 dsl_dataset_phys(ds->ds_prev)->ds_unique_bytes += used;
272 mutex_exit(&ds->ds_prev->ds_lock);
273 }
274 if (bp->blk_birth > ds->ds_dir->dd_origin_txg) {
275 dsl_dir_transfer_space(ds->ds_dir, used,
276 DD_USED_HEAD, DD_USED_SNAP, tx);
277 }
278 }
279 mutex_enter(&ds->ds_lock);
280 ASSERT3U(dsl_dataset_phys(ds)->ds_referenced_bytes, >=, used);
281 dsl_dataset_phys(ds)->ds_referenced_bytes -= used;
282 ASSERT3U(dsl_dataset_phys(ds)->ds_compressed_bytes, >=, compressed);
283 dsl_dataset_phys(ds)->ds_compressed_bytes -= compressed;
284 ASSERT3U(dsl_dataset_phys(ds)->ds_uncompressed_bytes, >=, uncompressed);
285 dsl_dataset_phys(ds)->ds_uncompressed_bytes -= uncompressed;
286 mutex_exit(&ds->ds_lock);
287
288 return (used);
289 }
290
291 /*
292 * We have to release the fsid syncronously or we risk that a subsequent
293 * mount of the same dataset will fail to unique_insert the fsid. This
294 * failure would manifest itself as the fsid of this dataset changing
295 * between mounts which makes NFS clients quite unhappy.
296 */
297 static void
dsl_dataset_evict_sync(void * dbu)298 dsl_dataset_evict_sync(void *dbu)
299 {
300 dsl_dataset_t *ds = dbu;
301
302 ASSERT(ds->ds_owner == NULL);
303
304 unique_remove(ds->ds_fsid_guid);
305 }
306
307 static void
dsl_dataset_evict_async(void * dbu)308 dsl_dataset_evict_async(void *dbu)
309 {
310 dsl_dataset_t *ds = dbu;
311
312 ASSERT(ds->ds_owner == NULL);
313
314 ds->ds_dbuf = NULL;
315
316 if (ds->ds_objset != NULL)
317 dmu_objset_evict(ds->ds_objset);
318
319 if (ds->ds_prev) {
320 dsl_dataset_rele(ds->ds_prev, ds);
321 ds->ds_prev = NULL;
322 }
323
324 bplist_destroy(&ds->ds_pending_deadlist);
325 if (dsl_deadlist_is_open(&ds->ds_deadlist))
326 dsl_deadlist_close(&ds->ds_deadlist);
327 if (dsl_deadlist_is_open(&ds->ds_remap_deadlist))
328 dsl_deadlist_close(&ds->ds_remap_deadlist);
329 if (ds->ds_dir)
330 dsl_dir_async_rele(ds->ds_dir, ds);
331
332 ASSERT(!list_link_active(&ds->ds_synced_link));
333
334 list_destroy(&ds->ds_prop_cbs);
335 mutex_destroy(&ds->ds_lock);
336 mutex_destroy(&ds->ds_opening_lock);
337 mutex_destroy(&ds->ds_sendstream_lock);
338 mutex_destroy(&ds->ds_remap_deadlist_lock);
339 zfs_refcount_destroy(&ds->ds_longholds);
340 rrw_destroy(&ds->ds_bp_rwlock);
341
342 kmem_free(ds, sizeof (dsl_dataset_t));
343 }
344
345 int
dsl_dataset_get_snapname(dsl_dataset_t * ds)346 dsl_dataset_get_snapname(dsl_dataset_t *ds)
347 {
348 dsl_dataset_phys_t *headphys;
349 int err;
350 dmu_buf_t *headdbuf;
351 dsl_pool_t *dp = ds->ds_dir->dd_pool;
352 objset_t *mos = dp->dp_meta_objset;
353
354 if (ds->ds_snapname[0])
355 return (0);
356 if (dsl_dataset_phys(ds)->ds_next_snap_obj == 0)
357 return (0);
358
359 err = dmu_bonus_hold(mos, dsl_dir_phys(ds->ds_dir)->dd_head_dataset_obj,
360 FTAG, &headdbuf);
361 if (err != 0)
362 return (err);
363 headphys = headdbuf->db_data;
364 err = zap_value_search(dp->dp_meta_objset,
365 headphys->ds_snapnames_zapobj, ds->ds_object, 0, ds->ds_snapname);
366 dmu_buf_rele(headdbuf, FTAG);
367 return (err);
368 }
369
370 int
dsl_dataset_snap_lookup(dsl_dataset_t * ds,const char * name,uint64_t * value)371 dsl_dataset_snap_lookup(dsl_dataset_t *ds, const char *name, uint64_t *value)
372 {
373 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
374 uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
375 matchtype_t mt = 0;
376 int err;
377
378 if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
379 mt = MT_NORMALIZE;
380
381 err = zap_lookup_norm(mos, snapobj, name, 8, 1,
382 value, mt, NULL, 0, NULL);
383 if (err == ENOTSUP && (mt & MT_NORMALIZE))
384 err = zap_lookup(mos, snapobj, name, 8, 1, value);
385 return (err);
386 }
387
388 int
dsl_dataset_snap_remove(dsl_dataset_t * ds,const char * name,dmu_tx_t * tx,boolean_t adj_cnt)389 dsl_dataset_snap_remove(dsl_dataset_t *ds, const char *name, dmu_tx_t *tx,
390 boolean_t adj_cnt)
391 {
392 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
393 uint64_t snapobj = dsl_dataset_phys(ds)->ds_snapnames_zapobj;
394 matchtype_t mt = 0;
395 int err;
396
397 dsl_dir_snap_cmtime_update(ds->ds_dir);
398
399 if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
400 mt = MT_NORMALIZE;
401
402 err = zap_remove_norm(mos, snapobj, name, mt, tx);
403 if (err == ENOTSUP && (mt & MT_NORMALIZE))
404 err = zap_remove(mos, snapobj, name, tx);
405
406 if (err == 0 && adj_cnt)
407 dsl_fs_ss_count_adjust(ds->ds_dir, -1,
408 DD_FIELD_SNAPSHOT_COUNT, tx);
409
410 return (err);
411 }
412
413 boolean_t
dsl_dataset_try_add_ref(dsl_pool_t * dp,dsl_dataset_t * ds,void * tag)414 dsl_dataset_try_add_ref(dsl_pool_t *dp, dsl_dataset_t *ds, void *tag)
415 {
416 dmu_buf_t *dbuf = ds->ds_dbuf;
417 boolean_t result = B_FALSE;
418
419 if (dbuf != NULL && dmu_buf_try_add_ref(dbuf, dp->dp_meta_objset,
420 ds->ds_object, DMU_BONUS_BLKID, tag)) {
421
422 if (ds == dmu_buf_get_user(dbuf))
423 result = B_TRUE;
424 else
425 dmu_buf_rele(dbuf, tag);
426 }
427
428 return (result);
429 }
430
431 int
dsl_dataset_hold_obj(dsl_pool_t * dp,uint64_t dsobj,void * tag,dsl_dataset_t ** dsp)432 dsl_dataset_hold_obj(dsl_pool_t *dp, uint64_t dsobj, void *tag,
433 dsl_dataset_t **dsp)
434 {
435 objset_t *mos = dp->dp_meta_objset;
436 dmu_buf_t *dbuf;
437 dsl_dataset_t *ds;
438 int err;
439 dmu_object_info_t doi;
440
441 ASSERT(dsl_pool_config_held(dp));
442
443 err = dmu_bonus_hold(mos, dsobj, tag, &dbuf);
444 if (err != 0)
445 return (err);
446
447 /* Make sure dsobj has the correct object type. */
448 dmu_object_info_from_db(dbuf, &doi);
449 if (doi.doi_bonus_type != DMU_OT_DSL_DATASET) {
450 dmu_buf_rele(dbuf, tag);
451 return (SET_ERROR(EINVAL));
452 }
453
454 ds = dmu_buf_get_user(dbuf);
455 if (ds == NULL) {
456 dsl_dataset_t *winner = NULL;
457
458 ds = kmem_zalloc(sizeof (dsl_dataset_t), KM_SLEEP);
459 ds->ds_dbuf = dbuf;
460 ds->ds_object = dsobj;
461 ds->ds_is_snapshot = dsl_dataset_phys(ds)->ds_num_children != 0;
462
463 err = dsl_dir_hold_obj(dp, dsl_dataset_phys(ds)->ds_dir_obj,
464 NULL, ds, &ds->ds_dir);
465 if (err != 0) {
466 kmem_free(ds, sizeof (dsl_dataset_t));
467 dmu_buf_rele(dbuf, tag);
468 return (err);
469 }
470
471 mutex_init(&ds->ds_lock, NULL, MUTEX_DEFAULT, NULL);
472 mutex_init(&ds->ds_opening_lock, NULL, MUTEX_DEFAULT, NULL);
473 mutex_init(&ds->ds_sendstream_lock, NULL, MUTEX_DEFAULT, NULL);
474 mutex_init(&ds->ds_remap_deadlist_lock,
475 NULL, MUTEX_DEFAULT, NULL);
476 rrw_init(&ds->ds_bp_rwlock, B_FALSE);
477 zfs_refcount_create(&ds->ds_longholds);
478
479 bplist_create(&ds->ds_pending_deadlist);
480
481 list_create(&ds->ds_sendstreams, sizeof (dmu_sendarg_t),
482 offsetof(dmu_sendarg_t, dsa_link));
483
484 list_create(&ds->ds_prop_cbs, sizeof (dsl_prop_cb_record_t),
485 offsetof(dsl_prop_cb_record_t, cbr_ds_node));
486
487 if (doi.doi_type == DMU_OTN_ZAP_METADATA) {
488 for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
489 if (!(spa_feature_table[f].fi_flags &
490 ZFEATURE_FLAG_PER_DATASET))
491 continue;
492 err = zap_contains(mos, dsobj,
493 spa_feature_table[f].fi_guid);
494 if (err == 0) {
495 ds->ds_feature_inuse[f] = B_TRUE;
496 } else {
497 ASSERT3U(err, ==, ENOENT);
498 err = 0;
499 }
500 }
501 }
502
503 if (!ds->ds_is_snapshot) {
504 ds->ds_snapname[0] = '\0';
505 if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
506 err = dsl_dataset_hold_obj(dp,
507 dsl_dataset_phys(ds)->ds_prev_snap_obj,
508 ds, &ds->ds_prev);
509 }
510 if (doi.doi_type == DMU_OTN_ZAP_METADATA) {
511 int zaperr = zap_lookup(mos, ds->ds_object,
512 DS_FIELD_BOOKMARK_NAMES,
513 sizeof (ds->ds_bookmarks), 1,
514 &ds->ds_bookmarks);
515 if (zaperr != ENOENT)
516 VERIFY0(zaperr);
517 }
518 } else {
519 if (zfs_flags & ZFS_DEBUG_SNAPNAMES)
520 err = dsl_dataset_get_snapname(ds);
521 if (err == 0 &&
522 dsl_dataset_phys(ds)->ds_userrefs_obj != 0) {
523 err = zap_count(
524 ds->ds_dir->dd_pool->dp_meta_objset,
525 dsl_dataset_phys(ds)->ds_userrefs_obj,
526 &ds->ds_userrefs);
527 }
528 }
529
530 if (err == 0 && !ds->ds_is_snapshot) {
531 err = dsl_prop_get_int_ds(ds,
532 zfs_prop_to_name(ZFS_PROP_REFRESERVATION),
533 &ds->ds_reserved);
534 if (err == 0) {
535 err = dsl_prop_get_int_ds(ds,
536 zfs_prop_to_name(ZFS_PROP_REFQUOTA),
537 &ds->ds_quota);
538 }
539 } else {
540 ds->ds_reserved = ds->ds_quota = 0;
541 }
542
543 if (err == 0 && ds->ds_dir->dd_crypto_obj != 0 &&
544 ds->ds_is_snapshot &&
545 zap_contains(mos, dsobj, DS_FIELD_IVSET_GUID) != 0) {
546 dp->dp_spa->spa_errata =
547 ZPOOL_ERRATA_ZOL_8308_ENCRYPTION;
548 }
549
550 dsl_deadlist_open(&ds->ds_deadlist,
551 mos, dsl_dataset_phys(ds)->ds_deadlist_obj);
552 uint64_t remap_deadlist_obj =
553 dsl_dataset_get_remap_deadlist_object(ds);
554 if (remap_deadlist_obj != 0) {
555 dsl_deadlist_open(&ds->ds_remap_deadlist, mos,
556 remap_deadlist_obj);
557 }
558
559 dmu_buf_init_user(&ds->ds_dbu, dsl_dataset_evict_sync,
560 dsl_dataset_evict_async, &ds->ds_dbuf);
561 if (err == 0)
562 winner = dmu_buf_set_user_ie(dbuf, &ds->ds_dbu);
563
564 if (err != 0 || winner != NULL) {
565 bplist_destroy(&ds->ds_pending_deadlist);
566 dsl_deadlist_close(&ds->ds_deadlist);
567 if (dsl_deadlist_is_open(&ds->ds_remap_deadlist))
568 dsl_deadlist_close(&ds->ds_remap_deadlist);
569 if (ds->ds_prev)
570 dsl_dataset_rele(ds->ds_prev, ds);
571 dsl_dir_rele(ds->ds_dir, ds);
572 list_destroy(&ds->ds_prop_cbs);
573 list_destroy(&ds->ds_sendstreams);
574 mutex_destroy(&ds->ds_lock);
575 mutex_destroy(&ds->ds_opening_lock);
576 mutex_destroy(&ds->ds_sendstream_lock);
577 mutex_destroy(&ds->ds_remap_deadlist_lock);
578 zfs_refcount_destroy(&ds->ds_longholds);
579 rrw_destroy(&ds->ds_bp_rwlock);
580 kmem_free(ds, sizeof (dsl_dataset_t));
581 if (err != 0) {
582 dmu_buf_rele(dbuf, tag);
583 return (err);
584 }
585 ds = winner;
586 } else {
587 ds->ds_fsid_guid =
588 unique_insert(dsl_dataset_phys(ds)->ds_fsid_guid);
589 if (ds->ds_fsid_guid !=
590 dsl_dataset_phys(ds)->ds_fsid_guid) {
591 zfs_dbgmsg("ds_fsid_guid changed from "
592 "%llx to %llx for pool %s dataset id %llu",
593 (long long)
594 dsl_dataset_phys(ds)->ds_fsid_guid,
595 (long long)ds->ds_fsid_guid,
596 spa_name(dp->dp_spa),
597 dsobj);
598 }
599 }
600 }
601
602 ASSERT3P(ds->ds_dbuf, ==, dbuf);
603 ASSERT3P(dsl_dataset_phys(ds), ==, dbuf->db_data);
604 ASSERT(dsl_dataset_phys(ds)->ds_prev_snap_obj != 0 ||
605 spa_version(dp->dp_spa) < SPA_VERSION_ORIGIN ||
606 dp->dp_origin_snap == NULL || ds == dp->dp_origin_snap);
607 *dsp = ds;
608
609 return (0);
610 }
611
612 int
dsl_dataset_create_key_mapping(dsl_dataset_t * ds)613 dsl_dataset_create_key_mapping(dsl_dataset_t *ds)
614 {
615 dsl_dir_t *dd = ds->ds_dir;
616
617 if (dd->dd_crypto_obj == 0)
618 return (0);
619
620 return (spa_keystore_create_mapping(dd->dd_pool->dp_spa,
621 ds, ds, &ds->ds_key_mapping));
622 }
623
624 int
dsl_dataset_hold_obj_flags(dsl_pool_t * dp,uint64_t dsobj,ds_hold_flags_t flags,void * tag,dsl_dataset_t ** dsp)625 dsl_dataset_hold_obj_flags(dsl_pool_t *dp, uint64_t dsobj,
626 ds_hold_flags_t flags, void *tag, dsl_dataset_t **dsp)
627 {
628 int err;
629
630 err = dsl_dataset_hold_obj(dp, dsobj, tag, dsp);
631 if (err != 0)
632 return (err);
633
634 ASSERT3P(*dsp, !=, NULL);
635
636 if (flags & DS_HOLD_FLAG_DECRYPT) {
637 err = dsl_dataset_create_key_mapping(*dsp);
638 if (err != 0)
639 dsl_dataset_rele(*dsp, tag);
640 }
641
642 return (err);
643 }
644
645 int
dsl_dataset_hold_flags(dsl_pool_t * dp,const char * name,ds_hold_flags_t flags,void * tag,dsl_dataset_t ** dsp)646 dsl_dataset_hold_flags(dsl_pool_t *dp, const char *name, ds_hold_flags_t flags,
647 void *tag, dsl_dataset_t **dsp)
648 {
649 dsl_dir_t *dd;
650 const char *snapname;
651 uint64_t obj;
652 int err = 0;
653 dsl_dataset_t *ds;
654
655 err = dsl_dir_hold(dp, name, FTAG, &dd, &snapname);
656 if (err != 0)
657 return (err);
658
659 ASSERT(dsl_pool_config_held(dp));
660 obj = dsl_dir_phys(dd)->dd_head_dataset_obj;
661 if (obj != 0)
662 err = dsl_dataset_hold_obj_flags(dp, obj, flags, tag, &ds);
663 else
664 err = SET_ERROR(ENOENT);
665
666 /* we may be looking for a snapshot */
667 if (err == 0 && snapname != NULL) {
668 dsl_dataset_t *snap_ds;
669
670 if (*snapname++ != '@') {
671 dsl_dataset_rele_flags(ds, flags, tag);
672 dsl_dir_rele(dd, FTAG);
673 return (SET_ERROR(ENOENT));
674 }
675
676 dprintf("looking for snapshot '%s'\n", snapname);
677 err = dsl_dataset_snap_lookup(ds, snapname, &obj);
678 if (err == 0) {
679 err = dsl_dataset_hold_obj_flags(dp, obj, flags, tag,
680 &snap_ds);
681 }
682 dsl_dataset_rele_flags(ds, flags, tag);
683
684 if (err == 0) {
685 mutex_enter(&snap_ds->ds_lock);
686 if (snap_ds->ds_snapname[0] == 0)
687 (void) strlcpy(snap_ds->ds_snapname, snapname,
688 sizeof (snap_ds->ds_snapname));
689 mutex_exit(&snap_ds->ds_lock);
690 ds = snap_ds;
691 }
692 }
693 if (err == 0)
694 *dsp = ds;
695 dsl_dir_rele(dd, FTAG);
696 return (err);
697 }
698
699 int
dsl_dataset_hold(dsl_pool_t * dp,const char * name,void * tag,dsl_dataset_t ** dsp)700 dsl_dataset_hold(dsl_pool_t *dp, const char *name, void *tag,
701 dsl_dataset_t **dsp)
702 {
703 return (dsl_dataset_hold_flags(dp, name, 0, tag, dsp));
704 }
705
706 int
dsl_dataset_own_obj(dsl_pool_t * dp,uint64_t dsobj,ds_hold_flags_t flags,void * tag,dsl_dataset_t ** dsp)707 dsl_dataset_own_obj(dsl_pool_t *dp, uint64_t dsobj, ds_hold_flags_t flags,
708 void *tag, dsl_dataset_t **dsp)
709 {
710 int err = dsl_dataset_hold_obj_flags(dp, dsobj, flags, tag, dsp);
711 if (err != 0)
712 return (err);
713 if (!dsl_dataset_tryown(*dsp, tag)) {
714 dsl_dataset_rele_flags(*dsp, flags, tag);
715 *dsp = NULL;
716 return (SET_ERROR(EBUSY));
717 }
718 return (0);
719 }
720
721 int
dsl_dataset_own(dsl_pool_t * dp,const char * name,ds_hold_flags_t flags,void * tag,dsl_dataset_t ** dsp)722 dsl_dataset_own(dsl_pool_t *dp, const char *name, ds_hold_flags_t flags,
723 void *tag, dsl_dataset_t **dsp)
724 {
725 int err = dsl_dataset_hold_flags(dp, name, flags, tag, dsp);
726 if (err != 0)
727 return (err);
728 if (!dsl_dataset_tryown(*dsp, tag)) {
729 dsl_dataset_rele_flags(*dsp, flags, tag);
730 return (SET_ERROR(EBUSY));
731 }
732 return (0);
733 }
734
735 /*
736 * See the comment above dsl_pool_hold() for details. In summary, a long
737 * hold is used to prevent destruction of a dataset while the pool hold
738 * is dropped, allowing other concurrent operations (e.g. spa_sync()).
739 *
740 * The dataset and pool must be held when this function is called. After it
741 * is called, the pool hold may be released while the dataset is still held
742 * and accessed.
743 */
744 void
dsl_dataset_long_hold(dsl_dataset_t * ds,void * tag)745 dsl_dataset_long_hold(dsl_dataset_t *ds, void *tag)
746 {
747 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
748 (void) zfs_refcount_add(&ds->ds_longholds, tag);
749 }
750
751 void
dsl_dataset_long_rele(dsl_dataset_t * ds,void * tag)752 dsl_dataset_long_rele(dsl_dataset_t *ds, void *tag)
753 {
754 (void) zfs_refcount_remove(&ds->ds_longholds, tag);
755 }
756
757 /* Return B_TRUE if there are any long holds on this dataset. */
758 boolean_t
dsl_dataset_long_held(dsl_dataset_t * ds)759 dsl_dataset_long_held(dsl_dataset_t *ds)
760 {
761 return (!zfs_refcount_is_zero(&ds->ds_longholds));
762 }
763
764 void
dsl_dataset_name(dsl_dataset_t * ds,char * name)765 dsl_dataset_name(dsl_dataset_t *ds, char *name)
766 {
767 if (ds == NULL) {
768 (void) strcpy(name, "mos");
769 } else {
770 dsl_dir_name(ds->ds_dir, name);
771 VERIFY0(dsl_dataset_get_snapname(ds));
772 if (ds->ds_snapname[0]) {
773 VERIFY3U(strlcat(name, "@", ZFS_MAX_DATASET_NAME_LEN),
774 <, ZFS_MAX_DATASET_NAME_LEN);
775 /*
776 * We use a "recursive" mutex so that we
777 * can call dprintf_ds() with ds_lock held.
778 */
779 if (!MUTEX_HELD(&ds->ds_lock)) {
780 mutex_enter(&ds->ds_lock);
781 VERIFY3U(strlcat(name, ds->ds_snapname,
782 ZFS_MAX_DATASET_NAME_LEN), <,
783 ZFS_MAX_DATASET_NAME_LEN);
784 mutex_exit(&ds->ds_lock);
785 } else {
786 VERIFY3U(strlcat(name, ds->ds_snapname,
787 ZFS_MAX_DATASET_NAME_LEN), <,
788 ZFS_MAX_DATASET_NAME_LEN);
789 }
790 }
791 }
792 }
793
794 int
dsl_dataset_namelen(dsl_dataset_t * ds)795 dsl_dataset_namelen(dsl_dataset_t *ds)
796 {
797 VERIFY0(dsl_dataset_get_snapname(ds));
798 mutex_enter(&ds->ds_lock);
799 int len = dsl_dir_namelen(ds->ds_dir) + 1 + strlen(ds->ds_snapname);
800 mutex_exit(&ds->ds_lock);
801 return (len);
802 }
803
804 void
dsl_dataset_rele(dsl_dataset_t * ds,void * tag)805 dsl_dataset_rele(dsl_dataset_t *ds, void *tag)
806 {
807 dmu_buf_rele(ds->ds_dbuf, tag);
808 }
809
810 void
dsl_dataset_remove_key_mapping(dsl_dataset_t * ds)811 dsl_dataset_remove_key_mapping(dsl_dataset_t *ds)
812 {
813 dsl_dir_t *dd = ds->ds_dir;
814
815 if (dd == NULL || dd->dd_crypto_obj == 0)
816 return;
817
818 (void) spa_keystore_remove_mapping(dd->dd_pool->dp_spa,
819 ds->ds_object, ds);
820 }
821
822 void
dsl_dataset_rele_flags(dsl_dataset_t * ds,ds_hold_flags_t flags,void * tag)823 dsl_dataset_rele_flags(dsl_dataset_t *ds, ds_hold_flags_t flags, void *tag)
824 {
825 if (flags & DS_HOLD_FLAG_DECRYPT)
826 dsl_dataset_remove_key_mapping(ds);
827
828 dsl_dataset_rele(ds, tag);
829 }
830
831 void
dsl_dataset_disown(dsl_dataset_t * ds,ds_hold_flags_t flags,void * tag)832 dsl_dataset_disown(dsl_dataset_t *ds, ds_hold_flags_t flags, void *tag)
833 {
834 ASSERT3P(ds->ds_owner, ==, tag);
835 ASSERT(ds->ds_dbuf != NULL);
836
837 mutex_enter(&ds->ds_lock);
838 ds->ds_owner = NULL;
839 mutex_exit(&ds->ds_lock);
840 dsl_dataset_long_rele(ds, tag);
841 dsl_dataset_rele_flags(ds, flags, tag);
842 }
843
844 boolean_t
dsl_dataset_tryown(dsl_dataset_t * ds,void * tag)845 dsl_dataset_tryown(dsl_dataset_t *ds, void *tag)
846 {
847 boolean_t gotit = FALSE;
848
849 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
850 mutex_enter(&ds->ds_lock);
851 if (ds->ds_owner == NULL && !DS_IS_INCONSISTENT(ds)) {
852 ds->ds_owner = tag;
853 dsl_dataset_long_hold(ds, tag);
854 gotit = TRUE;
855 }
856 mutex_exit(&ds->ds_lock);
857 return (gotit);
858 }
859
860 boolean_t
dsl_dataset_has_owner(dsl_dataset_t * ds)861 dsl_dataset_has_owner(dsl_dataset_t *ds)
862 {
863 boolean_t rv;
864 mutex_enter(&ds->ds_lock);
865 rv = (ds->ds_owner != NULL);
866 mutex_exit(&ds->ds_lock);
867 return (rv);
868 }
869
870 void
dsl_dataset_activate_feature(uint64_t dsobj,spa_feature_t f,dmu_tx_t * tx)871 dsl_dataset_activate_feature(uint64_t dsobj, spa_feature_t f, dmu_tx_t *tx)
872 {
873 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
874 objset_t *mos = dmu_tx_pool(tx)->dp_meta_objset;
875 uint64_t zero = 0;
876
877 VERIFY(spa_feature_table[f].fi_flags & ZFEATURE_FLAG_PER_DATASET);
878
879 spa_feature_incr(spa, f, tx);
880 dmu_object_zapify(mos, dsobj, DMU_OT_DSL_DATASET, tx);
881
882 VERIFY0(zap_add(mos, dsobj, spa_feature_table[f].fi_guid,
883 sizeof (zero), 1, &zero, tx));
884 }
885
886 void
dsl_dataset_deactivate_feature(uint64_t dsobj,spa_feature_t f,dmu_tx_t * tx)887 dsl_dataset_deactivate_feature(uint64_t dsobj, spa_feature_t f, dmu_tx_t *tx)
888 {
889 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
890 objset_t *mos = dmu_tx_pool(tx)->dp_meta_objset;
891
892 VERIFY(spa_feature_table[f].fi_flags & ZFEATURE_FLAG_PER_DATASET);
893
894 VERIFY0(zap_remove(mos, dsobj, spa_feature_table[f].fi_guid, tx));
895 spa_feature_decr(spa, f, tx);
896 }
897
898 uint64_t
dsl_dataset_create_sync_dd(dsl_dir_t * dd,dsl_dataset_t * origin,dsl_crypto_params_t * dcp,uint64_t flags,dmu_tx_t * tx)899 dsl_dataset_create_sync_dd(dsl_dir_t *dd, dsl_dataset_t *origin,
900 dsl_crypto_params_t *dcp, uint64_t flags, dmu_tx_t *tx)
901 {
902 dsl_pool_t *dp = dd->dd_pool;
903 dmu_buf_t *dbuf;
904 dsl_dataset_phys_t *dsphys;
905 uint64_t dsobj;
906 objset_t *mos = dp->dp_meta_objset;
907
908 if (origin == NULL)
909 origin = dp->dp_origin_snap;
910
911 ASSERT(origin == NULL || origin->ds_dir->dd_pool == dp);
912 ASSERT(origin == NULL || dsl_dataset_phys(origin)->ds_num_children > 0);
913 ASSERT(dmu_tx_is_syncing(tx));
914 ASSERT(dsl_dir_phys(dd)->dd_head_dataset_obj == 0);
915
916 dsobj = dmu_object_alloc(mos, DMU_OT_DSL_DATASET, 0,
917 DMU_OT_DSL_DATASET, sizeof (dsl_dataset_phys_t), tx);
918 VERIFY0(dmu_bonus_hold(mos, dsobj, FTAG, &dbuf));
919 dmu_buf_will_dirty(dbuf, tx);
920 dsphys = dbuf->db_data;
921 bzero(dsphys, sizeof (dsl_dataset_phys_t));
922 dsphys->ds_dir_obj = dd->dd_object;
923 dsphys->ds_flags = flags;
924 dsphys->ds_fsid_guid = unique_create();
925 (void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
926 sizeof (dsphys->ds_guid));
927 dsphys->ds_snapnames_zapobj =
928 zap_create_norm(mos, U8_TEXTPREP_TOUPPER, DMU_OT_DSL_DS_SNAP_MAP,
929 DMU_OT_NONE, 0, tx);
930 dsphys->ds_creation_time = gethrestime_sec();
931 dsphys->ds_creation_txg = tx->tx_txg == TXG_INITIAL ? 1 : tx->tx_txg;
932
933 if (origin == NULL) {
934 dsphys->ds_deadlist_obj = dsl_deadlist_alloc(mos, tx);
935 } else {
936 dsl_dataset_t *ohds; /* head of the origin snapshot */
937
938 dsphys->ds_prev_snap_obj = origin->ds_object;
939 dsphys->ds_prev_snap_txg =
940 dsl_dataset_phys(origin)->ds_creation_txg;
941 dsphys->ds_referenced_bytes =
942 dsl_dataset_phys(origin)->ds_referenced_bytes;
943 dsphys->ds_compressed_bytes =
944 dsl_dataset_phys(origin)->ds_compressed_bytes;
945 dsphys->ds_uncompressed_bytes =
946 dsl_dataset_phys(origin)->ds_uncompressed_bytes;
947 rrw_enter(&origin->ds_bp_rwlock, RW_READER, FTAG);
948 dsphys->ds_bp = dsl_dataset_phys(origin)->ds_bp;
949 rrw_exit(&origin->ds_bp_rwlock, FTAG);
950
951 /*
952 * Inherit flags that describe the dataset's contents
953 * (INCONSISTENT) or properties (Case Insensitive).
954 */
955 dsphys->ds_flags |= dsl_dataset_phys(origin)->ds_flags &
956 (DS_FLAG_INCONSISTENT | DS_FLAG_CI_DATASET);
957
958 for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
959 if (origin->ds_feature_inuse[f])
960 dsl_dataset_activate_feature(dsobj, f, tx);
961 }
962
963 dmu_buf_will_dirty(origin->ds_dbuf, tx);
964 dsl_dataset_phys(origin)->ds_num_children++;
965
966 VERIFY0(dsl_dataset_hold_obj(dp,
967 dsl_dir_phys(origin->ds_dir)->dd_head_dataset_obj,
968 FTAG, &ohds));
969 dsphys->ds_deadlist_obj = dsl_deadlist_clone(&ohds->ds_deadlist,
970 dsphys->ds_prev_snap_txg, dsphys->ds_prev_snap_obj, tx);
971 dsl_dataset_rele(ohds, FTAG);
972
973 if (spa_version(dp->dp_spa) >= SPA_VERSION_NEXT_CLONES) {
974 if (dsl_dataset_phys(origin)->ds_next_clones_obj == 0) {
975 dsl_dataset_phys(origin)->ds_next_clones_obj =
976 zap_create(mos,
977 DMU_OT_NEXT_CLONES, DMU_OT_NONE, 0, tx);
978 }
979 VERIFY0(zap_add_int(mos,
980 dsl_dataset_phys(origin)->ds_next_clones_obj,
981 dsobj, tx));
982 }
983
984 dmu_buf_will_dirty(dd->dd_dbuf, tx);
985 dsl_dir_phys(dd)->dd_origin_obj = origin->ds_object;
986 if (spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
987 if (dsl_dir_phys(origin->ds_dir)->dd_clones == 0) {
988 dmu_buf_will_dirty(origin->ds_dir->dd_dbuf, tx);
989 dsl_dir_phys(origin->ds_dir)->dd_clones =
990 zap_create(mos,
991 DMU_OT_DSL_CLONES, DMU_OT_NONE, 0, tx);
992 }
993 VERIFY0(zap_add_int(mos,
994 dsl_dir_phys(origin->ds_dir)->dd_clones,
995 dsobj, tx));
996 }
997 }
998
999 /* handle encryption */
1000 dsl_dataset_create_crypt_sync(dsobj, dd, origin, dcp, tx);
1001
1002 if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
1003 dsphys->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1004
1005 dmu_buf_rele(dbuf, FTAG);
1006
1007 dmu_buf_will_dirty(dd->dd_dbuf, tx);
1008 dsl_dir_phys(dd)->dd_head_dataset_obj = dsobj;
1009
1010 return (dsobj);
1011 }
1012
1013 static void
dsl_dataset_zero_zil(dsl_dataset_t * ds,dmu_tx_t * tx)1014 dsl_dataset_zero_zil(dsl_dataset_t *ds, dmu_tx_t *tx)
1015 {
1016 objset_t *os;
1017
1018 VERIFY0(dmu_objset_from_ds(ds, &os));
1019 if (bcmp(&os->os_zil_header, &zero_zil, sizeof (zero_zil)) != 0) {
1020 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1021 zio_t *zio;
1022
1023 bzero(&os->os_zil_header, sizeof (os->os_zil_header));
1024 if (os->os_encrypted)
1025 os->os_next_write_raw[tx->tx_txg & TXG_MASK] = B_TRUE;
1026
1027 zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
1028 dsl_dataset_sync(ds, zio, tx);
1029 VERIFY0(zio_wait(zio));
1030
1031 /* dsl_dataset_sync_done will drop this reference. */
1032 dmu_buf_add_ref(ds->ds_dbuf, ds);
1033 dsl_dataset_sync_done(ds, tx);
1034 }
1035 }
1036
1037 uint64_t
dsl_dataset_create_sync(dsl_dir_t * pdd,const char * lastname,dsl_dataset_t * origin,uint64_t flags,cred_t * cr,dsl_crypto_params_t * dcp,dmu_tx_t * tx)1038 dsl_dataset_create_sync(dsl_dir_t *pdd, const char *lastname,
1039 dsl_dataset_t *origin, uint64_t flags, cred_t *cr,
1040 dsl_crypto_params_t *dcp, dmu_tx_t *tx)
1041 {
1042 dsl_pool_t *dp = pdd->dd_pool;
1043 uint64_t dsobj, ddobj;
1044 dsl_dir_t *dd;
1045
1046 ASSERT(dmu_tx_is_syncing(tx));
1047 ASSERT(lastname[0] != '@');
1048
1049 ddobj = dsl_dir_create_sync(dp, pdd, lastname, tx);
1050 VERIFY0(dsl_dir_hold_obj(dp, ddobj, lastname, FTAG, &dd));
1051
1052 dsobj = dsl_dataset_create_sync_dd(dd, origin, dcp,
1053 flags & ~DS_CREATE_FLAG_NODIRTY, tx);
1054
1055 dsl_deleg_set_create_perms(dd, tx, cr);
1056
1057 /*
1058 * Since we're creating a new node we know it's a leaf, so we can
1059 * initialize the counts if the limit feature is active.
1060 */
1061 if (spa_feature_is_active(dp->dp_spa, SPA_FEATURE_FS_SS_LIMIT)) {
1062 uint64_t cnt = 0;
1063 objset_t *os = dd->dd_pool->dp_meta_objset;
1064
1065 dsl_dir_zapify(dd, tx);
1066 VERIFY0(zap_add(os, dd->dd_object, DD_FIELD_FILESYSTEM_COUNT,
1067 sizeof (cnt), 1, &cnt, tx));
1068 VERIFY0(zap_add(os, dd->dd_object, DD_FIELD_SNAPSHOT_COUNT,
1069 sizeof (cnt), 1, &cnt, tx));
1070 }
1071
1072 dsl_dir_rele(dd, FTAG);
1073
1074 /*
1075 * If we are creating a clone, make sure we zero out any stale
1076 * data from the origin snapshots zil header.
1077 */
1078 if (origin != NULL && !(flags & DS_CREATE_FLAG_NODIRTY)) {
1079 dsl_dataset_t *ds;
1080
1081 VERIFY0(dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
1082 dsl_dataset_zero_zil(ds, tx);
1083 dsl_dataset_rele(ds, FTAG);
1084 }
1085
1086 return (dsobj);
1087 }
1088
1089 /*
1090 * The unique space in the head dataset can be calculated by subtracting
1091 * the space used in the most recent snapshot, that is still being used
1092 * in this file system, from the space currently in use. To figure out
1093 * the space in the most recent snapshot still in use, we need to take
1094 * the total space used in the snapshot and subtract out the space that
1095 * has been freed up since the snapshot was taken.
1096 */
1097 void
dsl_dataset_recalc_head_uniq(dsl_dataset_t * ds)1098 dsl_dataset_recalc_head_uniq(dsl_dataset_t *ds)
1099 {
1100 uint64_t mrs_used;
1101 uint64_t dlused, dlcomp, dluncomp;
1102
1103 ASSERT(!ds->ds_is_snapshot);
1104
1105 if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0)
1106 mrs_used = dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes;
1107 else
1108 mrs_used = 0;
1109
1110 dsl_deadlist_space(&ds->ds_deadlist, &dlused, &dlcomp, &dluncomp);
1111
1112 ASSERT3U(dlused, <=, mrs_used);
1113 dsl_dataset_phys(ds)->ds_unique_bytes =
1114 dsl_dataset_phys(ds)->ds_referenced_bytes - (mrs_used - dlused);
1115
1116 if (spa_version(ds->ds_dir->dd_pool->dp_spa) >=
1117 SPA_VERSION_UNIQUE_ACCURATE)
1118 dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1119 }
1120
1121 void
dsl_dataset_remove_from_next_clones(dsl_dataset_t * ds,uint64_t obj,dmu_tx_t * tx)1122 dsl_dataset_remove_from_next_clones(dsl_dataset_t *ds, uint64_t obj,
1123 dmu_tx_t *tx)
1124 {
1125 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
1126 uint64_t count;
1127 int err;
1128
1129 ASSERT(dsl_dataset_phys(ds)->ds_num_children >= 2);
1130 err = zap_remove_int(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1131 obj, tx);
1132 /*
1133 * The err should not be ENOENT, but a bug in a previous version
1134 * of the code could cause upgrade_clones_cb() to not set
1135 * ds_next_snap_obj when it should, leading to a missing entry.
1136 * If we knew that the pool was created after
1137 * SPA_VERSION_NEXT_CLONES, we could assert that it isn't
1138 * ENOENT. However, at least we can check that we don't have
1139 * too many entries in the next_clones_obj even after failing to
1140 * remove this one.
1141 */
1142 if (err != ENOENT)
1143 VERIFY0(err);
1144 ASSERT0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1145 &count));
1146 ASSERT3U(count, <=, dsl_dataset_phys(ds)->ds_num_children - 2);
1147 }
1148
1149
1150 blkptr_t *
dsl_dataset_get_blkptr(dsl_dataset_t * ds)1151 dsl_dataset_get_blkptr(dsl_dataset_t *ds)
1152 {
1153 return (&dsl_dataset_phys(ds)->ds_bp);
1154 }
1155
1156 spa_t *
dsl_dataset_get_spa(dsl_dataset_t * ds)1157 dsl_dataset_get_spa(dsl_dataset_t *ds)
1158 {
1159 return (ds->ds_dir->dd_pool->dp_spa);
1160 }
1161
1162 void
dsl_dataset_dirty(dsl_dataset_t * ds,dmu_tx_t * tx)1163 dsl_dataset_dirty(dsl_dataset_t *ds, dmu_tx_t *tx)
1164 {
1165 dsl_pool_t *dp;
1166
1167 if (ds == NULL) /* this is the meta-objset */
1168 return;
1169
1170 ASSERT(ds->ds_objset != NULL);
1171
1172 if (dsl_dataset_phys(ds)->ds_next_snap_obj != 0)
1173 panic("dirtying snapshot!");
1174
1175 /* Must not dirty a dataset in the same txg where it got snapshotted. */
1176 ASSERT3U(tx->tx_txg, >, dsl_dataset_phys(ds)->ds_prev_snap_txg);
1177
1178 dp = ds->ds_dir->dd_pool;
1179 if (txg_list_add(&dp->dp_dirty_datasets, ds, tx->tx_txg)) {
1180 objset_t *os = ds->ds_objset;
1181
1182 /* up the hold count until we can be written out */
1183 dmu_buf_add_ref(ds->ds_dbuf, ds);
1184
1185 /* if this dataset is encrypted, grab a reference to the DCK */
1186 if (ds->ds_dir->dd_crypto_obj != 0 &&
1187 !os->os_raw_receive &&
1188 !os->os_next_write_raw[tx->tx_txg & TXG_MASK]) {
1189 ASSERT3P(ds->ds_key_mapping, !=, NULL);
1190 key_mapping_add_ref(ds->ds_key_mapping, ds);
1191 }
1192 }
1193 }
1194
1195 boolean_t
dsl_dataset_is_dirty(dsl_dataset_t * ds)1196 dsl_dataset_is_dirty(dsl_dataset_t *ds)
1197 {
1198 for (int t = 0; t < TXG_SIZE; t++) {
1199 if (txg_list_member(&ds->ds_dir->dd_pool->dp_dirty_datasets,
1200 ds, t))
1201 return (B_TRUE);
1202 }
1203 return (B_FALSE);
1204 }
1205
1206 static int
dsl_dataset_snapshot_reserve_space(dsl_dataset_t * ds,dmu_tx_t * tx)1207 dsl_dataset_snapshot_reserve_space(dsl_dataset_t *ds, dmu_tx_t *tx)
1208 {
1209 uint64_t asize;
1210
1211 if (!dmu_tx_is_syncing(tx))
1212 return (0);
1213
1214 /*
1215 * If there's an fs-only reservation, any blocks that might become
1216 * owned by the snapshot dataset must be accommodated by space
1217 * outside of the reservation.
1218 */
1219 ASSERT(ds->ds_reserved == 0 || DS_UNIQUE_IS_ACCURATE(ds));
1220 asize = MIN(dsl_dataset_phys(ds)->ds_unique_bytes, ds->ds_reserved);
1221 if (asize > dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE))
1222 return (SET_ERROR(ENOSPC));
1223
1224 /*
1225 * Propagate any reserved space for this snapshot to other
1226 * snapshot checks in this sync group.
1227 */
1228 if (asize > 0)
1229 dsl_dir_willuse_space(ds->ds_dir, asize, tx);
1230
1231 return (0);
1232 }
1233
1234 int
dsl_dataset_snapshot_check_impl(dsl_dataset_t * ds,const char * snapname,dmu_tx_t * tx,boolean_t recv,uint64_t cnt,cred_t * cr)1235 dsl_dataset_snapshot_check_impl(dsl_dataset_t *ds, const char *snapname,
1236 dmu_tx_t *tx, boolean_t recv, uint64_t cnt, cred_t *cr)
1237 {
1238 int error;
1239 uint64_t value;
1240
1241 ds->ds_trysnap_txg = tx->tx_txg;
1242
1243 if (!dmu_tx_is_syncing(tx))
1244 return (0);
1245
1246 /*
1247 * We don't allow multiple snapshots of the same txg. If there
1248 * is already one, try again.
1249 */
1250 if (dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg)
1251 return (SET_ERROR(EAGAIN));
1252
1253 /*
1254 * Check for conflicting snapshot name.
1255 */
1256 error = dsl_dataset_snap_lookup(ds, snapname, &value);
1257 if (error == 0)
1258 return (SET_ERROR(EEXIST));
1259 if (error != ENOENT)
1260 return (error);
1261
1262 /*
1263 * We don't allow taking snapshots of inconsistent datasets, such as
1264 * those into which we are currently receiving. However, if we are
1265 * creating this snapshot as part of a receive, this check will be
1266 * executed atomically with respect to the completion of the receive
1267 * itself but prior to the clearing of DS_FLAG_INCONSISTENT; in this
1268 * case we ignore this, knowing it will be fixed up for us shortly in
1269 * dmu_recv_end_sync().
1270 */
1271 if (!recv && DS_IS_INCONSISTENT(ds))
1272 return (SET_ERROR(EBUSY));
1273
1274 /*
1275 * Skip the check for temporary snapshots or if we have already checked
1276 * the counts in dsl_dataset_snapshot_check. This means we really only
1277 * check the count here when we're receiving a stream.
1278 */
1279 if (cnt != 0 && cr != NULL) {
1280 error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1281 ZFS_PROP_SNAPSHOT_LIMIT, NULL, cr);
1282 if (error != 0)
1283 return (error);
1284 }
1285
1286 error = dsl_dataset_snapshot_reserve_space(ds, tx);
1287 if (error != 0)
1288 return (error);
1289
1290 return (0);
1291 }
1292
1293 int
dsl_dataset_snapshot_check(void * arg,dmu_tx_t * tx)1294 dsl_dataset_snapshot_check(void *arg, dmu_tx_t *tx)
1295 {
1296 dsl_dataset_snapshot_arg_t *ddsa = arg;
1297 dsl_pool_t *dp = dmu_tx_pool(tx);
1298 nvpair_t *pair;
1299 int rv = 0;
1300
1301 /*
1302 * Pre-compute how many total new snapshots will be created for each
1303 * level in the tree and below. This is needed for validating the
1304 * snapshot limit when either taking a recursive snapshot or when
1305 * taking multiple snapshots.
1306 *
1307 * The problem is that the counts are not actually adjusted when
1308 * we are checking, only when we finally sync. For a single snapshot,
1309 * this is easy, the count will increase by 1 at each node up the tree,
1310 * but its more complicated for the recursive/multiple snapshot case.
1311 *
1312 * The dsl_fs_ss_limit_check function does recursively check the count
1313 * at each level up the tree but since it is validating each snapshot
1314 * independently we need to be sure that we are validating the complete
1315 * count for the entire set of snapshots. We do this by rolling up the
1316 * counts for each component of the name into an nvlist and then
1317 * checking each of those cases with the aggregated count.
1318 *
1319 * This approach properly handles not only the recursive snapshot
1320 * case (where we get all of those on the ddsa_snaps list) but also
1321 * the sibling case (e.g. snapshot a/b and a/c so that we will also
1322 * validate the limit on 'a' using a count of 2).
1323 *
1324 * We validate the snapshot names in the third loop and only report
1325 * name errors once.
1326 */
1327 if (dmu_tx_is_syncing(tx)) {
1328 nvlist_t *cnt_track = NULL;
1329 cnt_track = fnvlist_alloc();
1330
1331 /* Rollup aggregated counts into the cnt_track list */
1332 for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1333 pair != NULL;
1334 pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1335 char *pdelim;
1336 uint64_t val;
1337 char nm[MAXPATHLEN];
1338
1339 (void) strlcpy(nm, nvpair_name(pair), sizeof (nm));
1340 pdelim = strchr(nm, '@');
1341 if (pdelim == NULL)
1342 continue;
1343 *pdelim = '\0';
1344
1345 do {
1346 if (nvlist_lookup_uint64(cnt_track, nm,
1347 &val) == 0) {
1348 /* update existing entry */
1349 fnvlist_add_uint64(cnt_track, nm,
1350 val + 1);
1351 } else {
1352 /* add to list */
1353 fnvlist_add_uint64(cnt_track, nm, 1);
1354 }
1355
1356 pdelim = strrchr(nm, '/');
1357 if (pdelim != NULL)
1358 *pdelim = '\0';
1359 } while (pdelim != NULL);
1360 }
1361
1362 /* Check aggregated counts at each level */
1363 for (pair = nvlist_next_nvpair(cnt_track, NULL);
1364 pair != NULL; pair = nvlist_next_nvpair(cnt_track, pair)) {
1365 int error = 0;
1366 char *name;
1367 uint64_t cnt = 0;
1368 dsl_dataset_t *ds;
1369
1370 name = nvpair_name(pair);
1371 cnt = fnvpair_value_uint64(pair);
1372 ASSERT(cnt > 0);
1373
1374 error = dsl_dataset_hold(dp, name, FTAG, &ds);
1375 if (error == 0) {
1376 error = dsl_fs_ss_limit_check(ds->ds_dir, cnt,
1377 ZFS_PROP_SNAPSHOT_LIMIT, NULL,
1378 ddsa->ddsa_cr);
1379 dsl_dataset_rele(ds, FTAG);
1380 }
1381
1382 if (error != 0) {
1383 if (ddsa->ddsa_errors != NULL)
1384 fnvlist_add_int32(ddsa->ddsa_errors,
1385 name, error);
1386 rv = error;
1387 /* only report one error for this check */
1388 break;
1389 }
1390 }
1391 nvlist_free(cnt_track);
1392 }
1393
1394 for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1395 pair != NULL; pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1396 int error = 0;
1397 dsl_dataset_t *ds;
1398 char *name, *atp;
1399 char dsname[ZFS_MAX_DATASET_NAME_LEN];
1400
1401 name = nvpair_name(pair);
1402 if (strlen(name) >= ZFS_MAX_DATASET_NAME_LEN)
1403 error = SET_ERROR(ENAMETOOLONG);
1404 if (error == 0) {
1405 atp = strchr(name, '@');
1406 if (atp == NULL)
1407 error = SET_ERROR(EINVAL);
1408 if (error == 0)
1409 (void) strlcpy(dsname, name, atp - name + 1);
1410 }
1411 if (error == 0)
1412 error = dsl_dataset_hold(dp, dsname, FTAG, &ds);
1413 if (error == 0) {
1414 /* passing 0/NULL skips dsl_fs_ss_limit_check */
1415 error = dsl_dataset_snapshot_check_impl(ds,
1416 atp + 1, tx, B_FALSE, 0, NULL);
1417 dsl_dataset_rele(ds, FTAG);
1418 }
1419
1420 if (error != 0) {
1421 if (ddsa->ddsa_errors != NULL) {
1422 fnvlist_add_int32(ddsa->ddsa_errors,
1423 name, error);
1424 }
1425 rv = error;
1426 }
1427 }
1428
1429 return (rv);
1430 }
1431
1432 void
dsl_dataset_snapshot_sync_impl(dsl_dataset_t * ds,const char * snapname,dmu_tx_t * tx)1433 dsl_dataset_snapshot_sync_impl(dsl_dataset_t *ds, const char *snapname,
1434 dmu_tx_t *tx)
1435 {
1436 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1437 dmu_buf_t *dbuf;
1438 dsl_dataset_phys_t *dsphys;
1439 uint64_t dsobj, crtxg;
1440 objset_t *mos = dp->dp_meta_objset;
1441 objset_t *os;
1442
1443 ASSERT(RRW_WRITE_HELD(&dp->dp_config_rwlock));
1444
1445 /*
1446 * If we are on an old pool, the zil must not be active, in which
1447 * case it will be zeroed. Usually zil_suspend() accomplishes this.
1448 */
1449 ASSERT(spa_version(dmu_tx_pool(tx)->dp_spa) >= SPA_VERSION_FAST_SNAP ||
1450 dmu_objset_from_ds(ds, &os) != 0 ||
1451 bcmp(&os->os_phys->os_zil_header, &zero_zil,
1452 sizeof (zero_zil)) == 0);
1453
1454 /* Should not snapshot a dirty dataset. */
1455 ASSERT(!txg_list_member(&ds->ds_dir->dd_pool->dp_dirty_datasets,
1456 ds, tx->tx_txg));
1457
1458 dsl_fs_ss_count_adjust(ds->ds_dir, 1, DD_FIELD_SNAPSHOT_COUNT, tx);
1459
1460 /*
1461 * The origin's ds_creation_txg has to be < TXG_INITIAL
1462 */
1463 if (strcmp(snapname, ORIGIN_DIR_NAME) == 0)
1464 crtxg = 1;
1465 else
1466 crtxg = tx->tx_txg;
1467
1468 dsobj = dmu_object_alloc(mos, DMU_OT_DSL_DATASET, 0,
1469 DMU_OT_DSL_DATASET, sizeof (dsl_dataset_phys_t), tx);
1470 VERIFY0(dmu_bonus_hold(mos, dsobj, FTAG, &dbuf));
1471 dmu_buf_will_dirty(dbuf, tx);
1472 dsphys = dbuf->db_data;
1473 bzero(dsphys, sizeof (dsl_dataset_phys_t));
1474 dsphys->ds_dir_obj = ds->ds_dir->dd_object;
1475 dsphys->ds_fsid_guid = unique_create();
1476 (void) random_get_pseudo_bytes((void*)&dsphys->ds_guid,
1477 sizeof (dsphys->ds_guid));
1478 dsphys->ds_prev_snap_obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;
1479 dsphys->ds_prev_snap_txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
1480 dsphys->ds_next_snap_obj = ds->ds_object;
1481 dsphys->ds_num_children = 1;
1482 dsphys->ds_creation_time = gethrestime_sec();
1483 dsphys->ds_creation_txg = crtxg;
1484 dsphys->ds_deadlist_obj = dsl_dataset_phys(ds)->ds_deadlist_obj;
1485 dsphys->ds_referenced_bytes = dsl_dataset_phys(ds)->ds_referenced_bytes;
1486 dsphys->ds_compressed_bytes = dsl_dataset_phys(ds)->ds_compressed_bytes;
1487 dsphys->ds_uncompressed_bytes =
1488 dsl_dataset_phys(ds)->ds_uncompressed_bytes;
1489 dsphys->ds_flags = dsl_dataset_phys(ds)->ds_flags;
1490 rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
1491 dsphys->ds_bp = dsl_dataset_phys(ds)->ds_bp;
1492 rrw_exit(&ds->ds_bp_rwlock, FTAG);
1493 dmu_buf_rele(dbuf, FTAG);
1494
1495 for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
1496 if (ds->ds_feature_inuse[f])
1497 dsl_dataset_activate_feature(dsobj, f, tx);
1498 }
1499
1500 ASSERT3U(ds->ds_prev != 0, ==,
1501 dsl_dataset_phys(ds)->ds_prev_snap_obj != 0);
1502 if (ds->ds_prev) {
1503 uint64_t next_clones_obj =
1504 dsl_dataset_phys(ds->ds_prev)->ds_next_clones_obj;
1505 ASSERT(dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
1506 ds->ds_object ||
1507 dsl_dataset_phys(ds->ds_prev)->ds_num_children > 1);
1508 if (dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj ==
1509 ds->ds_object) {
1510 dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
1511 ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, ==,
1512 dsl_dataset_phys(ds->ds_prev)->ds_creation_txg);
1513 dsl_dataset_phys(ds->ds_prev)->ds_next_snap_obj = dsobj;
1514 } else if (next_clones_obj != 0) {
1515 dsl_dataset_remove_from_next_clones(ds->ds_prev,
1516 dsphys->ds_next_snap_obj, tx);
1517 VERIFY0(zap_add_int(mos,
1518 next_clones_obj, dsobj, tx));
1519 }
1520 }
1521
1522 /*
1523 * If we have a reference-reservation on this dataset, we will
1524 * need to increase the amount of refreservation being charged
1525 * since our unique space is going to zero.
1526 */
1527 if (ds->ds_reserved) {
1528 int64_t delta;
1529 ASSERT(DS_UNIQUE_IS_ACCURATE(ds));
1530 delta = MIN(dsl_dataset_phys(ds)->ds_unique_bytes,
1531 ds->ds_reserved);
1532 dsl_dir_diduse_space(ds->ds_dir, DD_USED_REFRSRV,
1533 delta, 0, 0, tx);
1534 }
1535
1536 dmu_buf_will_dirty(ds->ds_dbuf, tx);
1537 dsl_dataset_phys(ds)->ds_deadlist_obj =
1538 dsl_deadlist_clone(&ds->ds_deadlist, UINT64_MAX,
1539 dsl_dataset_phys(ds)->ds_prev_snap_obj, tx);
1540 dsl_deadlist_close(&ds->ds_deadlist);
1541 dsl_deadlist_open(&ds->ds_deadlist, mos,
1542 dsl_dataset_phys(ds)->ds_deadlist_obj);
1543 dsl_deadlist_add_key(&ds->ds_deadlist,
1544 dsl_dataset_phys(ds)->ds_prev_snap_txg, tx);
1545
1546 if (dsl_dataset_remap_deadlist_exists(ds)) {
1547 uint64_t remap_deadlist_obj =
1548 dsl_dataset_get_remap_deadlist_object(ds);
1549 /*
1550 * Move the remap_deadlist to the snapshot. The head
1551 * will create a new remap deadlist on demand, from
1552 * dsl_dataset_block_remapped().
1553 */
1554 dsl_dataset_unset_remap_deadlist_object(ds, tx);
1555 dsl_deadlist_close(&ds->ds_remap_deadlist);
1556
1557 dmu_object_zapify(mos, dsobj, DMU_OT_DSL_DATASET, tx);
1558 VERIFY0(zap_add(mos, dsobj, DS_FIELD_REMAP_DEADLIST,
1559 sizeof (remap_deadlist_obj), 1, &remap_deadlist_obj, tx));
1560 }
1561
1562 /*
1563 * Create a ivset guid for this snapshot if the dataset is
1564 * encrypted. This may be overridden by a raw receive. A
1565 * previous implementation of this code did not have this
1566 * field as part of the on-disk format for ZFS encryption
1567 * (see errata #4). As part of the remediation for this
1568 * issue, we ask the user to enable the bookmark_v2 feature
1569 * which is now a dependency of the encryption feature. We
1570 * use this as a heuristic to determine when the user has
1571 * elected to correct any datasets created with the old code.
1572 * As a result, we only do this step if the bookmark_v2
1573 * feature is enabled, which limits the number of states a
1574 * given pool / dataset can be in with regards to terms of
1575 * correcting the issue.
1576 */
1577 if (ds->ds_dir->dd_crypto_obj != 0 &&
1578 spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARK_V2)) {
1579 uint64_t ivset_guid = unique_create();
1580
1581 dmu_object_zapify(mos, dsobj, DMU_OT_DSL_DATASET, tx);
1582 VERIFY0(zap_add(mos, dsobj, DS_FIELD_IVSET_GUID,
1583 sizeof (ivset_guid), 1, &ivset_guid, tx));
1584 }
1585
1586 ASSERT3U(dsl_dataset_phys(ds)->ds_prev_snap_txg, <, tx->tx_txg);
1587 dsl_dataset_phys(ds)->ds_prev_snap_obj = dsobj;
1588 dsl_dataset_phys(ds)->ds_prev_snap_txg = crtxg;
1589 dsl_dataset_phys(ds)->ds_unique_bytes = 0;
1590
1591 if (spa_version(dp->dp_spa) >= SPA_VERSION_UNIQUE_ACCURATE)
1592 dsl_dataset_phys(ds)->ds_flags |= DS_FLAG_UNIQUE_ACCURATE;
1593
1594 VERIFY0(zap_add(mos, dsl_dataset_phys(ds)->ds_snapnames_zapobj,
1595 snapname, 8, 1, &dsobj, tx));
1596
1597 if (ds->ds_prev)
1598 dsl_dataset_rele(ds->ds_prev, ds);
1599 VERIFY0(dsl_dataset_hold_obj(dp,
1600 dsl_dataset_phys(ds)->ds_prev_snap_obj, ds, &ds->ds_prev));
1601
1602 dsl_scan_ds_snapshotted(ds, tx);
1603
1604 dsl_dir_snap_cmtime_update(ds->ds_dir);
1605
1606 spa_history_log_internal_ds(ds->ds_prev, "snapshot", tx, "");
1607 }
1608
1609 void
dsl_dataset_snapshot_sync(void * arg,dmu_tx_t * tx)1610 dsl_dataset_snapshot_sync(void *arg, dmu_tx_t *tx)
1611 {
1612 dsl_dataset_snapshot_arg_t *ddsa = arg;
1613 dsl_pool_t *dp = dmu_tx_pool(tx);
1614 nvpair_t *pair;
1615
1616 for (pair = nvlist_next_nvpair(ddsa->ddsa_snaps, NULL);
1617 pair != NULL; pair = nvlist_next_nvpair(ddsa->ddsa_snaps, pair)) {
1618 dsl_dataset_t *ds;
1619 char *name, *atp;
1620 char dsname[ZFS_MAX_DATASET_NAME_LEN];
1621
1622 name = nvpair_name(pair);
1623 atp = strchr(name, '@');
1624 (void) strlcpy(dsname, name, atp - name + 1);
1625 VERIFY0(dsl_dataset_hold(dp, dsname, FTAG, &ds));
1626
1627 dsl_dataset_snapshot_sync_impl(ds, atp + 1, tx);
1628 if (ddsa->ddsa_props != NULL) {
1629 dsl_props_set_sync_impl(ds->ds_prev,
1630 ZPROP_SRC_LOCAL, ddsa->ddsa_props, tx);
1631 }
1632 dsl_dataset_rele(ds, FTAG);
1633 }
1634 }
1635
1636 /*
1637 * The snapshots must all be in the same pool.
1638 * All-or-nothing: if there are any failures, nothing will be modified.
1639 */
1640 int
dsl_dataset_snapshot(nvlist_t * snaps,nvlist_t * props,nvlist_t * errors)1641 dsl_dataset_snapshot(nvlist_t *snaps, nvlist_t *props, nvlist_t *errors)
1642 {
1643 dsl_dataset_snapshot_arg_t ddsa;
1644 nvpair_t *pair;
1645 boolean_t needsuspend;
1646 int error;
1647 spa_t *spa;
1648 char *firstname;
1649 nvlist_t *suspended = NULL;
1650
1651 pair = nvlist_next_nvpair(snaps, NULL);
1652 if (pair == NULL)
1653 return (0);
1654 firstname = nvpair_name(pair);
1655
1656 error = spa_open(firstname, &spa, FTAG);
1657 if (error != 0)
1658 return (error);
1659 needsuspend = (spa_version(spa) < SPA_VERSION_FAST_SNAP);
1660 spa_close(spa, FTAG);
1661
1662 if (needsuspend) {
1663 suspended = fnvlist_alloc();
1664 for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
1665 pair = nvlist_next_nvpair(snaps, pair)) {
1666 char fsname[ZFS_MAX_DATASET_NAME_LEN];
1667 char *snapname = nvpair_name(pair);
1668 char *atp;
1669 void *cookie;
1670
1671 atp = strchr(snapname, '@');
1672 if (atp == NULL) {
1673 error = SET_ERROR(EINVAL);
1674 break;
1675 }
1676 (void) strlcpy(fsname, snapname, atp - snapname + 1);
1677
1678 error = zil_suspend(fsname, &cookie);
1679 if (error != 0)
1680 break;
1681 fnvlist_add_uint64(suspended, fsname,
1682 (uintptr_t)cookie);
1683 }
1684 }
1685
1686 ddsa.ddsa_snaps = snaps;
1687 ddsa.ddsa_props = props;
1688 ddsa.ddsa_errors = errors;
1689 ddsa.ddsa_cr = CRED();
1690
1691 if (error == 0) {
1692 error = dsl_sync_task(firstname, dsl_dataset_snapshot_check,
1693 dsl_dataset_snapshot_sync, &ddsa,
1694 fnvlist_num_pairs(snaps) * 3, ZFS_SPACE_CHECK_NORMAL);
1695 }
1696
1697 if (suspended != NULL) {
1698 for (pair = nvlist_next_nvpair(suspended, NULL); pair != NULL;
1699 pair = nvlist_next_nvpair(suspended, pair)) {
1700 zil_resume((void *)(uintptr_t)
1701 fnvpair_value_uint64(pair));
1702 }
1703 fnvlist_free(suspended);
1704 }
1705
1706 return (error);
1707 }
1708
1709 typedef struct dsl_dataset_snapshot_tmp_arg {
1710 const char *ddsta_fsname;
1711 const char *ddsta_snapname;
1712 minor_t ddsta_cleanup_minor;
1713 const char *ddsta_htag;
1714 } dsl_dataset_snapshot_tmp_arg_t;
1715
1716 static int
dsl_dataset_snapshot_tmp_check(void * arg,dmu_tx_t * tx)1717 dsl_dataset_snapshot_tmp_check(void *arg, dmu_tx_t *tx)
1718 {
1719 dsl_dataset_snapshot_tmp_arg_t *ddsta = arg;
1720 dsl_pool_t *dp = dmu_tx_pool(tx);
1721 dsl_dataset_t *ds;
1722 int error;
1723
1724 error = dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds);
1725 if (error != 0)
1726 return (error);
1727
1728 /* NULL cred means no limit check for tmp snapshot */
1729 error = dsl_dataset_snapshot_check_impl(ds, ddsta->ddsta_snapname,
1730 tx, B_FALSE, 0, NULL);
1731 if (error != 0) {
1732 dsl_dataset_rele(ds, FTAG);
1733 return (error);
1734 }
1735
1736 if (spa_version(dp->dp_spa) < SPA_VERSION_USERREFS) {
1737 dsl_dataset_rele(ds, FTAG);
1738 return (SET_ERROR(ENOTSUP));
1739 }
1740 error = dsl_dataset_user_hold_check_one(NULL, ddsta->ddsta_htag,
1741 B_TRUE, tx);
1742 if (error != 0) {
1743 dsl_dataset_rele(ds, FTAG);
1744 return (error);
1745 }
1746
1747 dsl_dataset_rele(ds, FTAG);
1748 return (0);
1749 }
1750
1751 static void
dsl_dataset_snapshot_tmp_sync(void * arg,dmu_tx_t * tx)1752 dsl_dataset_snapshot_tmp_sync(void *arg, dmu_tx_t *tx)
1753 {
1754 dsl_dataset_snapshot_tmp_arg_t *ddsta = arg;
1755 dsl_pool_t *dp = dmu_tx_pool(tx);
1756 dsl_dataset_t *ds;
1757
1758 VERIFY0(dsl_dataset_hold(dp, ddsta->ddsta_fsname, FTAG, &ds));
1759
1760 dsl_dataset_snapshot_sync_impl(ds, ddsta->ddsta_snapname, tx);
1761 dsl_dataset_user_hold_sync_one(ds->ds_prev, ddsta->ddsta_htag,
1762 ddsta->ddsta_cleanup_minor, gethrestime_sec(), tx);
1763 dsl_destroy_snapshot_sync_impl(ds->ds_prev, B_TRUE, tx);
1764
1765 dsl_dataset_rele(ds, FTAG);
1766 }
1767
1768 int
dsl_dataset_snapshot_tmp(const char * fsname,const char * snapname,minor_t cleanup_minor,const char * htag)1769 dsl_dataset_snapshot_tmp(const char *fsname, const char *snapname,
1770 minor_t cleanup_minor, const char *htag)
1771 {
1772 dsl_dataset_snapshot_tmp_arg_t ddsta;
1773 int error;
1774 spa_t *spa;
1775 boolean_t needsuspend;
1776 void *cookie;
1777
1778 ddsta.ddsta_fsname = fsname;
1779 ddsta.ddsta_snapname = snapname;
1780 ddsta.ddsta_cleanup_minor = cleanup_minor;
1781 ddsta.ddsta_htag = htag;
1782
1783 error = spa_open(fsname, &spa, FTAG);
1784 if (error != 0)
1785 return (error);
1786 needsuspend = (spa_version(spa) < SPA_VERSION_FAST_SNAP);
1787 spa_close(spa, FTAG);
1788
1789 if (needsuspend) {
1790 error = zil_suspend(fsname, &cookie);
1791 if (error != 0)
1792 return (error);
1793 }
1794
1795 error = dsl_sync_task(fsname, dsl_dataset_snapshot_tmp_check,
1796 dsl_dataset_snapshot_tmp_sync, &ddsta, 3, ZFS_SPACE_CHECK_RESERVED);
1797
1798 if (needsuspend)
1799 zil_resume(cookie);
1800 return (error);
1801 }
1802
1803 void
dsl_dataset_sync(dsl_dataset_t * ds,zio_t * zio,dmu_tx_t * tx)1804 dsl_dataset_sync(dsl_dataset_t *ds, zio_t *zio, dmu_tx_t *tx)
1805 {
1806 ASSERT(dmu_tx_is_syncing(tx));
1807 ASSERT(ds->ds_objset != NULL);
1808 ASSERT(dsl_dataset_phys(ds)->ds_next_snap_obj == 0);
1809
1810 /*
1811 * in case we had to change ds_fsid_guid when we opened it,
1812 * sync it out now.
1813 */
1814 dmu_buf_will_dirty(ds->ds_dbuf, tx);
1815 dsl_dataset_phys(ds)->ds_fsid_guid = ds->ds_fsid_guid;
1816
1817 if (ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] != 0) {
1818 VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
1819 ds->ds_object, DS_FIELD_RESUME_OBJECT, 8, 1,
1820 &ds->ds_resume_object[tx->tx_txg & TXG_MASK], tx));
1821 VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
1822 ds->ds_object, DS_FIELD_RESUME_OFFSET, 8, 1,
1823 &ds->ds_resume_offset[tx->tx_txg & TXG_MASK], tx));
1824 VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
1825 ds->ds_object, DS_FIELD_RESUME_BYTES, 8, 1,
1826 &ds->ds_resume_bytes[tx->tx_txg & TXG_MASK], tx));
1827 ds->ds_resume_object[tx->tx_txg & TXG_MASK] = 0;
1828 ds->ds_resume_offset[tx->tx_txg & TXG_MASK] = 0;
1829 ds->ds_resume_bytes[tx->tx_txg & TXG_MASK] = 0;
1830 }
1831
1832 dmu_objset_sync(ds->ds_objset, zio, tx);
1833
1834 for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
1835 if (ds->ds_feature_activation_needed[f]) {
1836 if (ds->ds_feature_inuse[f])
1837 continue;
1838 dsl_dataset_activate_feature(ds->ds_object, f, tx);
1839 ds->ds_feature_inuse[f] = B_TRUE;
1840 }
1841 }
1842 }
1843
1844 static int
deadlist_enqueue_cb(void * arg,const blkptr_t * bp,dmu_tx_t * tx)1845 deadlist_enqueue_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1846 {
1847 dsl_deadlist_t *dl = arg;
1848 dsl_deadlist_insert(dl, bp, tx);
1849 return (0);
1850 }
1851
1852 void
dsl_dataset_sync_done(dsl_dataset_t * ds,dmu_tx_t * tx)1853 dsl_dataset_sync_done(dsl_dataset_t *ds, dmu_tx_t *tx)
1854 {
1855 objset_t *os = ds->ds_objset;
1856
1857 bplist_iterate(&ds->ds_pending_deadlist,
1858 deadlist_enqueue_cb, &ds->ds_deadlist, tx);
1859
1860 if (os->os_synced_dnodes != NULL) {
1861 multilist_destroy(os->os_synced_dnodes);
1862 os->os_synced_dnodes = NULL;
1863 }
1864
1865 if (os->os_encrypted)
1866 os->os_next_write_raw[tx->tx_txg & TXG_MASK] = B_FALSE;
1867 else
1868 ASSERT0(os->os_next_write_raw[tx->tx_txg & TXG_MASK]);
1869
1870 ASSERT(!dmu_objset_is_dirty(os, dmu_tx_get_txg(tx)));
1871
1872 dmu_buf_rele(ds->ds_dbuf, ds);
1873 }
1874
1875 int
get_clones_stat_impl(dsl_dataset_t * ds,nvlist_t * val)1876 get_clones_stat_impl(dsl_dataset_t *ds, nvlist_t *val)
1877 {
1878 uint64_t count = 0;
1879 objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
1880 zap_cursor_t zc;
1881 zap_attribute_t za;
1882
1883 ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
1884
1885 /*
1886 * There may be missing entries in ds_next_clones_obj
1887 * due to a bug in a previous version of the code.
1888 * Only trust it if it has the right number of entries.
1889 */
1890 if (dsl_dataset_phys(ds)->ds_next_clones_obj != 0) {
1891 VERIFY0(zap_count(mos, dsl_dataset_phys(ds)->ds_next_clones_obj,
1892 &count));
1893 }
1894 if (count != dsl_dataset_phys(ds)->ds_num_children - 1) {
1895 return (ENOENT);
1896 }
1897 for (zap_cursor_init(&zc, mos,
1898 dsl_dataset_phys(ds)->ds_next_clones_obj);
1899 zap_cursor_retrieve(&zc, &za) == 0;
1900 zap_cursor_advance(&zc)) {
1901 dsl_dataset_t *clone;
1902 char buf[ZFS_MAX_DATASET_NAME_LEN];
1903 VERIFY0(dsl_dataset_hold_obj(ds->ds_dir->dd_pool,
1904 za.za_first_integer, FTAG, &clone));
1905 dsl_dir_name(clone->ds_dir, buf);
1906 fnvlist_add_boolean(val, buf);
1907 dsl_dataset_rele(clone, FTAG);
1908 }
1909 zap_cursor_fini(&zc);
1910 return (0);
1911 }
1912
1913 void
get_clones_stat(dsl_dataset_t * ds,nvlist_t * nv)1914 get_clones_stat(dsl_dataset_t *ds, nvlist_t *nv)
1915 {
1916 nvlist_t *propval = fnvlist_alloc();
1917 nvlist_t *val;
1918
1919 /*
1920 * We use nvlist_alloc() instead of fnvlist_alloc() because the
1921 * latter would allocate the list with NV_UNIQUE_NAME flag.
1922 * As a result, every time a clone name is appended to the list
1923 * it would be (linearly) searched for for a duplicate name.
1924 * We already know that all clone names must be unique and we
1925 * want avoid the quadratic complexity of double-checking that
1926 * because we can have a large number of clones.
1927 */
1928 VERIFY0(nvlist_alloc(&val, 0, KM_SLEEP));
1929
1930 if (get_clones_stat_impl(ds, val) == 0) {
1931 fnvlist_add_nvlist(propval, ZPROP_VALUE, val);
1932 fnvlist_add_nvlist(nv, zfs_prop_to_name(ZFS_PROP_CLONES),
1933 propval);
1934 }
1935
1936 nvlist_free(val);
1937 nvlist_free(propval);
1938 }
1939
1940 /*
1941 * Returns a string that represents the receive resume stats token. It should
1942 * be freed with strfree().
1943 */
1944 char *
get_receive_resume_stats_impl(dsl_dataset_t * ds)1945 get_receive_resume_stats_impl(dsl_dataset_t *ds)
1946 {
1947 dsl_pool_t *dp = ds->ds_dir->dd_pool;
1948
1949 if (dsl_dataset_has_resume_receive_state(ds)) {
1950 char *str;
1951 void *packed;
1952 uint8_t *compressed;
1953 uint64_t val;
1954 nvlist_t *token_nv = fnvlist_alloc();
1955 size_t packed_size, compressed_size;
1956
1957 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1958 DS_FIELD_RESUME_FROMGUID, sizeof (val), 1, &val) == 0) {
1959 fnvlist_add_uint64(token_nv, "fromguid", val);
1960 }
1961 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1962 DS_FIELD_RESUME_OBJECT, sizeof (val), 1, &val) == 0) {
1963 fnvlist_add_uint64(token_nv, "object", val);
1964 }
1965 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1966 DS_FIELD_RESUME_OFFSET, sizeof (val), 1, &val) == 0) {
1967 fnvlist_add_uint64(token_nv, "offset", val);
1968 }
1969 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1970 DS_FIELD_RESUME_BYTES, sizeof (val), 1, &val) == 0) {
1971 fnvlist_add_uint64(token_nv, "bytes", val);
1972 }
1973 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1974 DS_FIELD_RESUME_TOGUID, sizeof (val), 1, &val) == 0) {
1975 fnvlist_add_uint64(token_nv, "toguid", val);
1976 }
1977 char buf[256];
1978 if (zap_lookup(dp->dp_meta_objset, ds->ds_object,
1979 DS_FIELD_RESUME_TONAME, 1, sizeof (buf), buf) == 0) {
1980 fnvlist_add_string(token_nv, "toname", buf);
1981 }
1982 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
1983 DS_FIELD_RESUME_LARGEBLOCK) == 0) {
1984 fnvlist_add_boolean(token_nv, "largeblockok");
1985 }
1986 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
1987 DS_FIELD_RESUME_EMBEDOK) == 0) {
1988 fnvlist_add_boolean(token_nv, "embedok");
1989 }
1990 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
1991 DS_FIELD_RESUME_COMPRESSOK) == 0) {
1992 fnvlist_add_boolean(token_nv, "compressok");
1993 }
1994 if (zap_contains(dp->dp_meta_objset, ds->ds_object,
1995 DS_FIELD_RESUME_RAWOK) == 0) {
1996 fnvlist_add_boolean(token_nv, "rawok");
1997 }
1998 packed = fnvlist_pack(token_nv, &packed_size);
1999 fnvlist_free(token_nv);
2000 compressed = kmem_alloc(packed_size, KM_SLEEP);
2001
2002 compressed_size = gzip_compress(packed, compressed,
2003 packed_size, packed_size, 6);
2004
2005 zio_cksum_t cksum;
2006 fletcher_4_native(compressed, compressed_size, NULL, &cksum);
2007
2008 str = kmem_alloc(compressed_size * 2 + 1, KM_SLEEP);
2009 for (int i = 0; i < compressed_size; i++) {
2010 (void) sprintf(str + i * 2, "%02x", compressed[i]);
2011 }
2012 str[compressed_size * 2] = '\0';
2013 char *propval = kmem_asprintf("%u-%llx-%llx-%s",
2014 ZFS_SEND_RESUME_TOKEN_VERSION,
2015 (longlong_t)cksum.zc_word[0],
2016 (longlong_t)packed_size, str);
2017 kmem_free(packed, packed_size);
2018 kmem_free(str, compressed_size * 2 + 1);
2019 kmem_free(compressed, packed_size);
2020 return (propval);
2021 }
2022 return (strdup(""));
2023 }
2024
2025 /*
2026 * Returns a string that represents the receive resume stats token of the
2027 * dataset's child. It should be freed with strfree().
2028 */
2029 char *
get_child_receive_stats(dsl_dataset_t * ds)2030 get_child_receive_stats(dsl_dataset_t *ds)
2031 {
2032 char recvname[ZFS_MAX_DATASET_NAME_LEN + 6];
2033 dsl_dataset_t *recv_ds;
2034 dsl_dataset_name(ds, recvname);
2035 if (strlcat(recvname, "/", sizeof (recvname)) <
2036 sizeof (recvname) &&
2037 strlcat(recvname, recv_clone_name, sizeof (recvname)) <
2038 sizeof (recvname) &&
2039 dsl_dataset_hold(ds->ds_dir->dd_pool, recvname, FTAG,
2040 &recv_ds) == 0) {
2041 char *propval = get_receive_resume_stats_impl(recv_ds);
2042 dsl_dataset_rele(recv_ds, FTAG);
2043 return (propval);
2044 }
2045 return (strdup(""));
2046 }
2047
2048 static void
get_receive_resume_stats(dsl_dataset_t * ds,nvlist_t * nv)2049 get_receive_resume_stats(dsl_dataset_t *ds, nvlist_t *nv)
2050 {
2051 char *propval = get_receive_resume_stats_impl(ds);
2052 if (strcmp(propval, "") != 0) {
2053 dsl_prop_nvlist_add_string(nv,
2054 ZFS_PROP_RECEIVE_RESUME_TOKEN, propval);
2055 } else {
2056 char *childval = get_child_receive_stats(ds);
2057 if (strcmp(childval, "") != 0) {
2058 dsl_prop_nvlist_add_string(nv,
2059 ZFS_PROP_RECEIVE_RESUME_TOKEN, childval);
2060 }
2061 strfree(childval);
2062 }
2063 strfree(propval);
2064 }
2065
2066 uint64_t
dsl_get_refratio(dsl_dataset_t * ds)2067 dsl_get_refratio(dsl_dataset_t *ds)
2068 {
2069 uint64_t ratio = dsl_dataset_phys(ds)->ds_compressed_bytes == 0 ? 100 :
2070 (dsl_dataset_phys(ds)->ds_uncompressed_bytes * 100 /
2071 dsl_dataset_phys(ds)->ds_compressed_bytes);
2072 return (ratio);
2073 }
2074
2075 uint64_t
dsl_get_logicalreferenced(dsl_dataset_t * ds)2076 dsl_get_logicalreferenced(dsl_dataset_t *ds)
2077 {
2078 return (dsl_dataset_phys(ds)->ds_uncompressed_bytes);
2079 }
2080
2081 uint64_t
dsl_get_compressratio(dsl_dataset_t * ds)2082 dsl_get_compressratio(dsl_dataset_t *ds)
2083 {
2084 if (ds->ds_is_snapshot) {
2085 return (dsl_get_refratio(ds));
2086 } else {
2087 dsl_dir_t *dd = ds->ds_dir;
2088 mutex_enter(&dd->dd_lock);
2089 uint64_t val = dsl_dir_get_compressratio(dd);
2090 mutex_exit(&dd->dd_lock);
2091 return (val);
2092 }
2093 }
2094
2095 uint64_t
dsl_get_used(dsl_dataset_t * ds)2096 dsl_get_used(dsl_dataset_t *ds)
2097 {
2098 if (ds->ds_is_snapshot) {
2099 return (dsl_dataset_phys(ds)->ds_unique_bytes);
2100 } else {
2101 dsl_dir_t *dd = ds->ds_dir;
2102 mutex_enter(&dd->dd_lock);
2103 uint64_t val = dsl_dir_get_used(dd);
2104 mutex_exit(&dd->dd_lock);
2105 return (val);
2106 }
2107 }
2108
2109 uint64_t
dsl_get_creation(dsl_dataset_t * ds)2110 dsl_get_creation(dsl_dataset_t *ds)
2111 {
2112 return (dsl_dataset_phys(ds)->ds_creation_time);
2113 }
2114
2115 uint64_t
dsl_get_creationtxg(dsl_dataset_t * ds)2116 dsl_get_creationtxg(dsl_dataset_t *ds)
2117 {
2118 return (dsl_dataset_phys(ds)->ds_creation_txg);
2119 }
2120
2121 uint64_t
dsl_get_refquota(dsl_dataset_t * ds)2122 dsl_get_refquota(dsl_dataset_t *ds)
2123 {
2124 return (ds->ds_quota);
2125 }
2126
2127 uint64_t
dsl_get_refreservation(dsl_dataset_t * ds)2128 dsl_get_refreservation(dsl_dataset_t *ds)
2129 {
2130 return (ds->ds_reserved);
2131 }
2132
2133 uint64_t
dsl_get_guid(dsl_dataset_t * ds)2134 dsl_get_guid(dsl_dataset_t *ds)
2135 {
2136 return (dsl_dataset_phys(ds)->ds_guid);
2137 }
2138
2139 uint64_t
dsl_get_unique(dsl_dataset_t * ds)2140 dsl_get_unique(dsl_dataset_t *ds)
2141 {
2142 return (dsl_dataset_phys(ds)->ds_unique_bytes);
2143 }
2144
2145 uint64_t
dsl_get_objsetid(dsl_dataset_t * ds)2146 dsl_get_objsetid(dsl_dataset_t *ds)
2147 {
2148 return (ds->ds_object);
2149 }
2150
2151 uint64_t
dsl_get_userrefs(dsl_dataset_t * ds)2152 dsl_get_userrefs(dsl_dataset_t *ds)
2153 {
2154 return (ds->ds_userrefs);
2155 }
2156
2157 uint64_t
dsl_get_defer_destroy(dsl_dataset_t * ds)2158 dsl_get_defer_destroy(dsl_dataset_t *ds)
2159 {
2160 return (DS_IS_DEFER_DESTROY(ds) ? 1 : 0);
2161 }
2162
2163 uint64_t
dsl_get_referenced(dsl_dataset_t * ds)2164 dsl_get_referenced(dsl_dataset_t *ds)
2165 {
2166 return (dsl_dataset_phys(ds)->ds_referenced_bytes);
2167 }
2168
2169 uint64_t
dsl_get_numclones(dsl_dataset_t * ds)2170 dsl_get_numclones(dsl_dataset_t *ds)
2171 {
2172 ASSERT(ds->ds_is_snapshot);
2173 return (dsl_dataset_phys(ds)->ds_num_children - 1);
2174 }
2175
2176 uint64_t
dsl_get_inconsistent(dsl_dataset_t * ds)2177 dsl_get_inconsistent(dsl_dataset_t *ds)
2178 {
2179 return ((dsl_dataset_phys(ds)->ds_flags & DS_FLAG_INCONSISTENT) ?
2180 1 : 0);
2181 }
2182
2183 uint64_t
dsl_get_available(dsl_dataset_t * ds)2184 dsl_get_available(dsl_dataset_t *ds)
2185 {
2186 uint64_t refdbytes = dsl_get_referenced(ds);
2187 uint64_t availbytes = dsl_dir_space_available(ds->ds_dir,
2188 NULL, 0, TRUE);
2189 if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes) {
2190 availbytes +=
2191 ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes;
2192 }
2193 if (ds->ds_quota != 0) {
2194 /*
2195 * Adjust available bytes according to refquota
2196 */
2197 if (refdbytes < ds->ds_quota) {
2198 availbytes = MIN(availbytes,
2199 ds->ds_quota - refdbytes);
2200 } else {
2201 availbytes = 0;
2202 }
2203 }
2204 return (availbytes);
2205 }
2206
2207 int
dsl_get_written(dsl_dataset_t * ds,uint64_t * written)2208 dsl_get_written(dsl_dataset_t *ds, uint64_t *written)
2209 {
2210 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2211 dsl_dataset_t *prev;
2212 int err = dsl_dataset_hold_obj(dp,
2213 dsl_dataset_phys(ds)->ds_prev_snap_obj, FTAG, &prev);
2214 if (err == 0) {
2215 uint64_t comp, uncomp;
2216 err = dsl_dataset_space_written(prev, ds, written,
2217 &comp, &uncomp);
2218 dsl_dataset_rele(prev, FTAG);
2219 }
2220 return (err);
2221 }
2222
2223 /*
2224 * 'snap' should be a buffer of size ZFS_MAX_DATASET_NAME_LEN.
2225 */
2226 int
dsl_get_prev_snap(dsl_dataset_t * ds,char * snap)2227 dsl_get_prev_snap(dsl_dataset_t *ds, char *snap)
2228 {
2229 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2230 if (ds->ds_prev != NULL && ds->ds_prev != dp->dp_origin_snap) {
2231 dsl_dataset_name(ds->ds_prev, snap);
2232 return (0);
2233 } else {
2234 return (ENOENT);
2235 }
2236 }
2237
2238 /*
2239 * Returns the mountpoint property and source for the given dataset in the value
2240 * and source buffers. The value buffer must be at least as large as MAXPATHLEN
2241 * and the source buffer as least as large a ZFS_MAX_DATASET_NAME_LEN.
2242 * Returns 0 on success and an error on failure.
2243 */
2244 int
dsl_get_mountpoint(dsl_dataset_t * ds,const char * dsname,char * value,char * source)2245 dsl_get_mountpoint(dsl_dataset_t *ds, const char *dsname, char *value,
2246 char *source)
2247 {
2248 int error;
2249 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2250
2251 /* Retrieve the mountpoint value stored in the zap opbject */
2252 error = dsl_prop_get_ds(ds, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1,
2253 ZAP_MAXVALUELEN, value, source);
2254 if (error != 0) {
2255 return (error);
2256 }
2257
2258 /*
2259 * Process the dsname and source to find the full mountpoint string.
2260 * Can be skipped for 'legacy' or 'none'.
2261 */
2262 if (value[0] == '/') {
2263 char *buf = kmem_alloc(ZAP_MAXVALUELEN, KM_SLEEP);
2264 char *root = buf;
2265 const char *relpath;
2266
2267 /*
2268 * If we inherit the mountpoint, even from a dataset
2269 * with a received value, the source will be the path of
2270 * the dataset we inherit from. If source is
2271 * ZPROP_SOURCE_VAL_RECVD, the received value is not
2272 * inherited.
2273 */
2274 if (strcmp(source, ZPROP_SOURCE_VAL_RECVD) == 0) {
2275 relpath = "";
2276 } else {
2277 ASSERT0(strncmp(dsname, source, strlen(source)));
2278 relpath = dsname + strlen(source);
2279 if (relpath[0] == '/')
2280 relpath++;
2281 }
2282
2283 spa_altroot(dp->dp_spa, root, ZAP_MAXVALUELEN);
2284
2285 /*
2286 * Special case an alternate root of '/'. This will
2287 * avoid having multiple leading slashes in the
2288 * mountpoint path.
2289 */
2290 if (strcmp(root, "/") == 0)
2291 root++;
2292
2293 /*
2294 * If the mountpoint is '/' then skip over this
2295 * if we are obtaining either an alternate root or
2296 * an inherited mountpoint.
2297 */
2298 char *mnt = value;
2299 if (value[1] == '\0' && (root[0] != '\0' ||
2300 relpath[0] != '\0'))
2301 mnt = value + 1;
2302
2303 if (relpath[0] == '\0') {
2304 (void) snprintf(value, ZAP_MAXVALUELEN, "%s%s",
2305 root, mnt);
2306 } else {
2307 (void) snprintf(value, ZAP_MAXVALUELEN, "%s%s%s%s",
2308 root, mnt, relpath[0] == '@' ? "" : "/",
2309 relpath);
2310 }
2311 kmem_free(buf, ZAP_MAXVALUELEN);
2312 }
2313
2314 return (0);
2315 }
2316
2317 void
dsl_dataset_stats(dsl_dataset_t * ds,nvlist_t * nv)2318 dsl_dataset_stats(dsl_dataset_t *ds, nvlist_t *nv)
2319 {
2320 int err;
2321 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2322
2323 ASSERT(dsl_pool_config_held(dp));
2324
2325 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFRATIO,
2326 dsl_get_refratio(ds));
2327 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_LOGICALREFERENCED,
2328 dsl_get_logicalreferenced(ds));
2329 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_COMPRESSRATIO,
2330 dsl_get_compressratio(ds));
2331 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USED,
2332 dsl_get_used(ds));
2333
2334 if (ds->ds_is_snapshot) {
2335 get_clones_stat(ds, nv);
2336 } else {
2337 char buf[ZFS_MAX_DATASET_NAME_LEN];
2338 if (dsl_get_prev_snap(ds, buf) == 0)
2339 dsl_prop_nvlist_add_string(nv, ZFS_PROP_PREV_SNAP,
2340 buf);
2341 dsl_dir_stats(ds->ds_dir, nv);
2342 }
2343
2344 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_AVAILABLE,
2345 dsl_get_available(ds));
2346 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFERENCED,
2347 dsl_get_referenced(ds));
2348 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_CREATION,
2349 dsl_get_creation(ds));
2350 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_CREATETXG,
2351 dsl_get_creationtxg(ds));
2352 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFQUOTA,
2353 dsl_get_refquota(ds));
2354 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_REFRESERVATION,
2355 dsl_get_refreservation(ds));
2356 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_GUID,
2357 dsl_get_guid(ds));
2358 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_UNIQUE,
2359 dsl_get_unique(ds));
2360 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_OBJSETID,
2361 dsl_get_objsetid(ds));
2362 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_USERREFS,
2363 dsl_get_userrefs(ds));
2364 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_DEFER_DESTROY,
2365 DS_IS_DEFER_DESTROY(ds) ? 1 : 0);
2366 dsl_dataset_crypt_stats(ds, nv);
2367
2368 if (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
2369 uint64_t written, comp, uncomp;
2370 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2371 dsl_dataset_t *prev;
2372
2373 err = dsl_dataset_hold_obj(dp,
2374 dsl_dataset_phys(ds)->ds_prev_snap_obj, FTAG, &prev);
2375 if (err == 0) {
2376 err = dsl_dataset_space_written(prev, ds, &written,
2377 &comp, &uncomp);
2378 dsl_dataset_rele(prev, FTAG);
2379 if (err == 0) {
2380 dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_WRITTEN,
2381 written);
2382 }
2383 }
2384 }
2385
2386 if (!dsl_dataset_is_snapshot(ds)) {
2387 /*
2388 * A failed "newfs" (e.g. full) resumable receive leaves
2389 * the stats set on this dataset. Check here for the prop.
2390 */
2391 get_receive_resume_stats(ds, nv);
2392
2393 /*
2394 * A failed incremental resumable receive leaves the
2395 * stats set on our child named "%recv". Check the child
2396 * for the prop.
2397 */
2398 /* 6 extra bytes for /%recv */
2399 char recvname[ZFS_MAX_DATASET_NAME_LEN + 6];
2400 dsl_dataset_t *recv_ds;
2401 dsl_dataset_name(ds, recvname);
2402 if (strlcat(recvname, "/", sizeof (recvname)) <
2403 sizeof (recvname) &&
2404 strlcat(recvname, recv_clone_name, sizeof (recvname)) <
2405 sizeof (recvname) &&
2406 dsl_dataset_hold(dp, recvname, FTAG, &recv_ds) == 0) {
2407 get_receive_resume_stats(recv_ds, nv);
2408 dsl_dataset_rele(recv_ds, FTAG);
2409 }
2410 }
2411 }
2412
2413 void
dsl_dataset_fast_stat(dsl_dataset_t * ds,dmu_objset_stats_t * stat)2414 dsl_dataset_fast_stat(dsl_dataset_t *ds, dmu_objset_stats_t *stat)
2415 {
2416 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2417 ASSERT(dsl_pool_config_held(dp));
2418
2419 stat->dds_creation_txg = dsl_get_creationtxg(ds);
2420 stat->dds_inconsistent = dsl_get_inconsistent(ds);
2421 stat->dds_guid = dsl_get_guid(ds);
2422 stat->dds_origin[0] = '\0';
2423 if (ds->ds_is_snapshot) {
2424 stat->dds_is_snapshot = B_TRUE;
2425 stat->dds_num_clones = dsl_get_numclones(ds);
2426 } else {
2427 stat->dds_is_snapshot = B_FALSE;
2428 stat->dds_num_clones = 0;
2429
2430 if (dsl_dir_is_clone(ds->ds_dir)) {
2431 dsl_dir_get_origin(ds->ds_dir, stat->dds_origin);
2432 }
2433 }
2434 }
2435
2436 uint64_t
dsl_dataset_fsid_guid(dsl_dataset_t * ds)2437 dsl_dataset_fsid_guid(dsl_dataset_t *ds)
2438 {
2439 return (ds->ds_fsid_guid);
2440 }
2441
2442 void
dsl_dataset_space(dsl_dataset_t * ds,uint64_t * refdbytesp,uint64_t * availbytesp,uint64_t * usedobjsp,uint64_t * availobjsp)2443 dsl_dataset_space(dsl_dataset_t *ds,
2444 uint64_t *refdbytesp, uint64_t *availbytesp,
2445 uint64_t *usedobjsp, uint64_t *availobjsp)
2446 {
2447 *refdbytesp = dsl_dataset_phys(ds)->ds_referenced_bytes;
2448 *availbytesp = dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE);
2449 if (ds->ds_reserved > dsl_dataset_phys(ds)->ds_unique_bytes)
2450 *availbytesp +=
2451 ds->ds_reserved - dsl_dataset_phys(ds)->ds_unique_bytes;
2452 if (ds->ds_quota != 0) {
2453 /*
2454 * Adjust available bytes according to refquota
2455 */
2456 if (*refdbytesp < ds->ds_quota)
2457 *availbytesp = MIN(*availbytesp,
2458 ds->ds_quota - *refdbytesp);
2459 else
2460 *availbytesp = 0;
2461 }
2462 rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
2463 *usedobjsp = BP_GET_FILL(&dsl_dataset_phys(ds)->ds_bp);
2464 rrw_exit(&ds->ds_bp_rwlock, FTAG);
2465 *availobjsp = DN_MAX_OBJECT - *usedobjsp;
2466 }
2467
2468 boolean_t
dsl_dataset_modified_since_snap(dsl_dataset_t * ds,dsl_dataset_t * snap)2469 dsl_dataset_modified_since_snap(dsl_dataset_t *ds, dsl_dataset_t *snap)
2470 {
2471 dsl_pool_t *dp = ds->ds_dir->dd_pool;
2472 uint64_t birth;
2473
2474 ASSERT(dsl_pool_config_held(dp));
2475 if (snap == NULL)
2476 return (B_FALSE);
2477 rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
2478 birth = dsl_dataset_get_blkptr(ds)->blk_birth;
2479 rrw_exit(&ds->ds_bp_rwlock, FTAG);
2480 if (birth > dsl_dataset_phys(snap)->ds_creation_txg) {
2481 objset_t *os, *os_snap;
2482 /*
2483 * It may be that only the ZIL differs, because it was
2484 * reset in the head. Don't count that as being
2485 * modified.
2486 */
2487 if (dmu_objset_from_ds(ds, &os) != 0)
2488 return (B_TRUE);
2489 if (dmu_objset_from_ds(snap, &os_snap) != 0)
2490 return (B_TRUE);
2491 return (bcmp(&os->os_phys->os_meta_dnode,
2492 &os_snap->os_phys->os_meta_dnode,
2493 sizeof (os->os_phys->os_meta_dnode)) != 0);
2494 }
2495 return (B_FALSE);
2496 }
2497
2498 typedef struct dsl_dataset_rename_snapshot_arg {
2499 const char *ddrsa_fsname;
2500 const char *ddrsa_oldsnapname;
2501 const char *ddrsa_newsnapname;
2502 boolean_t ddrsa_recursive;
2503 dmu_tx_t *ddrsa_tx;
2504 } dsl_dataset_rename_snapshot_arg_t;
2505
2506 /* ARGSUSED */
2507 static int
dsl_dataset_rename_snapshot_check_impl(dsl_pool_t * dp,dsl_dataset_t * hds,void * arg)2508 dsl_dataset_rename_snapshot_check_impl(dsl_pool_t *dp,
2509 dsl_dataset_t *hds, void *arg)
2510 {
2511 dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2512 int error;
2513 uint64_t val;
2514
2515 error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_oldsnapname, &val);
2516 if (error != 0) {
2517 /* ignore nonexistent snapshots */
2518 return (error == ENOENT ? 0 : error);
2519 }
2520
2521 /* new name should not exist */
2522 error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_newsnapname, &val);
2523 if (error == 0)
2524 error = SET_ERROR(EEXIST);
2525 else if (error == ENOENT)
2526 error = 0;
2527
2528 /* dataset name + 1 for the "@" + the new snapshot name must fit */
2529 if (dsl_dir_namelen(hds->ds_dir) + 1 +
2530 strlen(ddrsa->ddrsa_newsnapname) >= ZFS_MAX_DATASET_NAME_LEN)
2531 error = SET_ERROR(ENAMETOOLONG);
2532
2533 return (error);
2534 }
2535
2536 static int
dsl_dataset_rename_snapshot_check(void * arg,dmu_tx_t * tx)2537 dsl_dataset_rename_snapshot_check(void *arg, dmu_tx_t *tx)
2538 {
2539 dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2540 dsl_pool_t *dp = dmu_tx_pool(tx);
2541 dsl_dataset_t *hds;
2542 int error;
2543
2544 error = dsl_dataset_hold(dp, ddrsa->ddrsa_fsname, FTAG, &hds);
2545 if (error != 0)
2546 return (error);
2547
2548 if (ddrsa->ddrsa_recursive) {
2549 error = dmu_objset_find_dp(dp, hds->ds_dir->dd_object,
2550 dsl_dataset_rename_snapshot_check_impl, ddrsa,
2551 DS_FIND_CHILDREN);
2552 } else {
2553 error = dsl_dataset_rename_snapshot_check_impl(dp, hds, ddrsa);
2554 }
2555 dsl_dataset_rele(hds, FTAG);
2556 return (error);
2557 }
2558
2559 static int
dsl_dataset_rename_snapshot_sync_impl(dsl_pool_t * dp,dsl_dataset_t * hds,void * arg)2560 dsl_dataset_rename_snapshot_sync_impl(dsl_pool_t *dp,
2561 dsl_dataset_t *hds, void *arg)
2562 {
2563 dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2564 dsl_dataset_t *ds;
2565 uint64_t val;
2566 dmu_tx_t *tx = ddrsa->ddrsa_tx;
2567 int error;
2568
2569 error = dsl_dataset_snap_lookup(hds, ddrsa->ddrsa_oldsnapname, &val);
2570 ASSERT(error == 0 || error == ENOENT);
2571 if (error == ENOENT) {
2572 /* ignore nonexistent snapshots */
2573 return (0);
2574 }
2575
2576 VERIFY0(dsl_dataset_hold_obj(dp, val, FTAG, &ds));
2577
2578 /* log before we change the name */
2579 spa_history_log_internal_ds(ds, "rename", tx,
2580 "-> @%s", ddrsa->ddrsa_newsnapname);
2581
2582 VERIFY0(dsl_dataset_snap_remove(hds, ddrsa->ddrsa_oldsnapname, tx,
2583 B_FALSE));
2584 mutex_enter(&ds->ds_lock);
2585 (void) strcpy(ds->ds_snapname, ddrsa->ddrsa_newsnapname);
2586 mutex_exit(&ds->ds_lock);
2587 VERIFY0(zap_add(dp->dp_meta_objset,
2588 dsl_dataset_phys(hds)->ds_snapnames_zapobj,
2589 ds->ds_snapname, 8, 1, &ds->ds_object, tx));
2590
2591 dsl_dataset_rele(ds, FTAG);
2592 return (0);
2593 }
2594
2595 static void
dsl_dataset_rename_snapshot_sync(void * arg,dmu_tx_t * tx)2596 dsl_dataset_rename_snapshot_sync(void *arg, dmu_tx_t *tx)
2597 {
2598 dsl_dataset_rename_snapshot_arg_t *ddrsa = arg;
2599 dsl_pool_t *dp = dmu_tx_pool(tx);
2600 dsl_dataset_t *hds;
2601
2602 VERIFY0(dsl_dataset_hold(dp, ddrsa->ddrsa_fsname, FTAG, &hds));
2603 ddrsa->ddrsa_tx = tx;
2604 if (ddrsa->ddrsa_recursive) {
2605 VERIFY0(dmu_objset_find_dp(dp, hds->ds_dir->dd_object,
2606 dsl_dataset_rename_snapshot_sync_impl, ddrsa,
2607 DS_FIND_CHILDREN));
2608 } else {
2609 VERIFY0(dsl_dataset_rename_snapshot_sync_impl(dp, hds, ddrsa));
2610 }
2611 dsl_dataset_rele(hds, FTAG);
2612 }
2613
2614 int
dsl_dataset_rename_snapshot(const char * fsname,const char * oldsnapname,const char * newsnapname,boolean_t recursive)2615 dsl_dataset_rename_snapshot(const char *fsname,
2616 const char *oldsnapname, const char *newsnapname, boolean_t recursive)
2617 {
2618 dsl_dataset_rename_snapshot_arg_t ddrsa;
2619
2620 ddrsa.ddrsa_fsname = fsname;
2621 ddrsa.ddrsa_oldsnapname = oldsnapname;
2622 ddrsa.ddrsa_newsnapname = newsnapname;
2623 ddrsa.ddrsa_recursive = recursive;
2624
2625 return (dsl_sync_task(fsname, dsl_dataset_rename_snapshot_check,
2626 dsl_dataset_rename_snapshot_sync, &ddrsa,
2627 1, ZFS_SPACE_CHECK_RESERVED));
2628 }
2629
2630 /*
2631 * If we're doing an ownership handoff, we need to make sure that there is
2632 * only one long hold on the dataset. We're not allowed to change anything here
2633 * so we don't permanently release the long hold or regular hold here. We want
2634 * to do this only when syncing to avoid the dataset unexpectedly going away
2635 * when we release the long hold.
2636 */
2637 static int
dsl_dataset_handoff_check(dsl_dataset_t * ds,void * owner,dmu_tx_t * tx)2638 dsl_dataset_handoff_check(dsl_dataset_t *ds, void *owner, dmu_tx_t *tx)
2639 {
2640 boolean_t held;
2641
2642 if (!dmu_tx_is_syncing(tx))
2643 return (0);
2644
2645 if (owner != NULL) {
2646 VERIFY3P(ds->ds_owner, ==, owner);
2647 dsl_dataset_long_rele(ds, owner);
2648 }
2649
2650 held = dsl_dataset_long_held(ds);
2651
2652 if (owner != NULL)
2653 dsl_dataset_long_hold(ds, owner);
2654
2655 if (held)
2656 return (SET_ERROR(EBUSY));
2657
2658 return (0);
2659 }
2660
2661 int
dsl_dataset_rollback_check(void * arg,dmu_tx_t * tx)2662 dsl_dataset_rollback_check(void *arg, dmu_tx_t *tx)
2663 {
2664 dsl_dataset_rollback_arg_t *ddra = arg;
2665 dsl_pool_t *dp = dmu_tx_pool(tx);
2666 dsl_dataset_t *ds;
2667 int64_t unused_refres_delta;
2668 int error;
2669
2670 error = dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds);
2671 if (error != 0)
2672 return (error);
2673
2674 /* must not be a snapshot */
2675 if (ds->ds_is_snapshot) {
2676 dsl_dataset_rele(ds, FTAG);
2677 return (SET_ERROR(EINVAL));
2678 }
2679
2680 /* must have a most recent snapshot */
2681 if (dsl_dataset_phys(ds)->ds_prev_snap_txg < TXG_INITIAL) {
2682 dsl_dataset_rele(ds, FTAG);
2683 return (SET_ERROR(ESRCH));
2684 }
2685
2686 /*
2687 * No rollback to a snapshot created in the current txg, because
2688 * the rollback may dirty the dataset and create blocks that are
2689 * not reachable from the rootbp while having a birth txg that
2690 * falls into the snapshot's range.
2691 */
2692 if (dmu_tx_is_syncing(tx) &&
2693 dsl_dataset_phys(ds)->ds_prev_snap_txg >= tx->tx_txg) {
2694 dsl_dataset_rele(ds, FTAG);
2695 return (SET_ERROR(EAGAIN));
2696 }
2697
2698 /*
2699 * If the expected target snapshot is specified, then check that
2700 * the latest snapshot is it.
2701 */
2702 if (ddra->ddra_tosnap != NULL) {
2703 dsl_dataset_t *snapds;
2704
2705 /* Check if the target snapshot exists at all. */
2706 error = dsl_dataset_hold(dp, ddra->ddra_tosnap, FTAG, &snapds);
2707 if (error != 0) {
2708 /*
2709 * ESRCH is used to signal that the target snapshot does
2710 * not exist, while ENOENT is used to report that
2711 * the rolled back dataset does not exist.
2712 * ESRCH is also used to cover other cases where the
2713 * target snapshot is not related to the dataset being
2714 * rolled back such as being in a different pool.
2715 */
2716 if (error == ENOENT || error == EXDEV)
2717 error = SET_ERROR(ESRCH);
2718 dsl_dataset_rele(ds, FTAG);
2719 return (error);
2720 }
2721 ASSERT(snapds->ds_is_snapshot);
2722
2723 /* Check if the snapshot is the latest snapshot indeed. */
2724 if (snapds != ds->ds_prev) {
2725 /*
2726 * Distinguish between the case where the only problem
2727 * is intervening snapshots (EEXIST) vs the snapshot
2728 * not being a valid target for rollback (ESRCH).
2729 */
2730 if (snapds->ds_dir == ds->ds_dir ||
2731 (dsl_dir_is_clone(ds->ds_dir) &&
2732 dsl_dir_phys(ds->ds_dir)->dd_origin_obj ==
2733 snapds->ds_object)) {
2734 error = SET_ERROR(EEXIST);
2735 } else {
2736 error = SET_ERROR(ESRCH);
2737 }
2738 dsl_dataset_rele(snapds, FTAG);
2739 dsl_dataset_rele(ds, FTAG);
2740 return (error);
2741 }
2742 dsl_dataset_rele(snapds, FTAG);
2743 }
2744
2745 /* must not have any bookmarks after the most recent snapshot */
2746 nvlist_t *proprequest = fnvlist_alloc();
2747 fnvlist_add_boolean(proprequest, zfs_prop_to_name(ZFS_PROP_CREATETXG));
2748 nvlist_t *bookmarks = fnvlist_alloc();
2749 error = dsl_get_bookmarks_impl(ds, proprequest, bookmarks);
2750 fnvlist_free(proprequest);
2751 if (error != 0) {
2752 dsl_dataset_rele(ds, FTAG);
2753 return (error);
2754 }
2755 for (nvpair_t *pair = nvlist_next_nvpair(bookmarks, NULL);
2756 pair != NULL; pair = nvlist_next_nvpair(bookmarks, pair)) {
2757 nvlist_t *valuenv =
2758 fnvlist_lookup_nvlist(fnvpair_value_nvlist(pair),
2759 zfs_prop_to_name(ZFS_PROP_CREATETXG));
2760 uint64_t createtxg = fnvlist_lookup_uint64(valuenv, "value");
2761 if (createtxg > dsl_dataset_phys(ds)->ds_prev_snap_txg) {
2762 fnvlist_free(bookmarks);
2763 dsl_dataset_rele(ds, FTAG);
2764 return (SET_ERROR(EEXIST));
2765 }
2766 }
2767 fnvlist_free(bookmarks);
2768
2769 error = dsl_dataset_handoff_check(ds, ddra->ddra_owner, tx);
2770 if (error != 0) {
2771 dsl_dataset_rele(ds, FTAG);
2772 return (error);
2773 }
2774
2775 /*
2776 * Check if the snap we are rolling back to uses more than
2777 * the refquota.
2778 */
2779 if (ds->ds_quota != 0 &&
2780 dsl_dataset_phys(ds->ds_prev)->ds_referenced_bytes > ds->ds_quota) {
2781 dsl_dataset_rele(ds, FTAG);
2782 return (SET_ERROR(EDQUOT));
2783 }
2784
2785 /*
2786 * When we do the clone swap, we will temporarily use more space
2787 * due to the refreservation (the head will no longer have any
2788 * unique space, so the entire amount of the refreservation will need
2789 * to be free). We will immediately destroy the clone, freeing
2790 * this space, but the freeing happens over many txg's.
2791 */
2792 unused_refres_delta = (int64_t)MIN(ds->ds_reserved,
2793 dsl_dataset_phys(ds)->ds_unique_bytes);
2794
2795 if (unused_refres_delta > 0 &&
2796 unused_refres_delta >
2797 dsl_dir_space_available(ds->ds_dir, NULL, 0, TRUE)) {
2798 dsl_dataset_rele(ds, FTAG);
2799 return (SET_ERROR(ENOSPC));
2800 }
2801
2802 dsl_dataset_rele(ds, FTAG);
2803 return (0);
2804 }
2805
2806 void
dsl_dataset_rollback_sync(void * arg,dmu_tx_t * tx)2807 dsl_dataset_rollback_sync(void *arg, dmu_tx_t *tx)
2808 {
2809 dsl_dataset_rollback_arg_t *ddra = arg;
2810 dsl_pool_t *dp = dmu_tx_pool(tx);
2811 dsl_dataset_t *ds, *clone;
2812 uint64_t cloneobj;
2813 char namebuf[ZFS_MAX_DATASET_NAME_LEN];
2814
2815 VERIFY0(dsl_dataset_hold(dp, ddra->ddra_fsname, FTAG, &ds));
2816
2817 dsl_dataset_name(ds->ds_prev, namebuf);
2818 fnvlist_add_string(ddra->ddra_result, "target", namebuf);
2819
2820 cloneobj = dsl_dataset_create_sync(