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.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or https://opensource.org/licenses/CDDL-1.0.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
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]
23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2012, 2020 by Delphix. All rights reserved.
25 * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
26 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
27 * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
28 * Copyright (c) 2015, STRATO AG, Inc. All rights reserved.
29 * Copyright (c) 2016 Actifio, Inc. All rights reserved.
30 * Copyright 2017 Nexenta Systems, Inc.
31 * Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
32 * Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
33 * Copyright (c) 2019, Klara Inc.
34 * Copyright (c) 2019, Allan Jude
35 * Copyright (c) 2022 Hewlett Packard Enterprise Development LP.
38 /* Portions Copyright 2010 Robert Milkowski */
41 #include <sys/zfs_context.h>
42 #include <sys/dmu_objset.h>
43 #include <sys/dsl_dir.h>
44 #include <sys/dsl_dataset.h>
45 #include <sys/dsl_prop.h>
46 #include <sys/dsl_pool.h>
47 #include <sys/dsl_synctask.h>
48 #include <sys/dsl_deleg.h>
49 #include <sys/dnode.h>
52 #include <sys/dmu_tx.h>
55 #include <sys/dmu_impl.h>
56 #include <sys/zfs_ioctl.h>
58 #include <sys/zfs_onexit.h>
59 #include <sys/dsl_destroy.h>
61 #include <sys/zfeature.h>
62 #include <sys/policy.h>
63 #include <sys/spa_impl.h>
64 #include <sys/dmu_recv.h>
65 #include <sys/zfs_project.h>
66 #include "zfs_namecheck.h"
67 #include <sys/vdev_impl.h>
71 * Needed to close a window in dnode_move() that allows the objset to be freed
72 * before it can be safely accessed.
77 * Tunable to overwrite the maximum number of threads for the parallelization
78 * of dmu_objset_find_dp, needed to speed up the import of pools with many
80 * Default is 4 times the number of leaf vdevs.
82 static const int dmu_find_threads
= 0;
85 * Backfill lower metadnode objects after this many have been freed.
86 * Backfilling negatively impacts object creation rates, so only do it
87 * if there are enough holes to fill.
89 static const int dmu_rescan_dnode_threshold
= 1 << DN_MAX_INDBLKSHIFT
;
91 static const char *upgrade_tag
= "upgrade_tag";
93 static void dmu_objset_find_dp_cb(void *arg
);
95 static void dmu_objset_upgrade(objset_t
*os
, dmu_objset_upgrade_cb_t cb
);
96 static void dmu_objset_upgrade_stop(objset_t
*os
);
101 rw_init(&os_lock
, NULL
, RW_DEFAULT
, NULL
);
105 dmu_objset_fini(void)
107 rw_destroy(&os_lock
);
111 dmu_objset_spa(objset_t
*os
)
117 dmu_objset_zil(objset_t
*os
)
123 dmu_objset_pool(objset_t
*os
)
127 if ((ds
= os
->os_dsl_dataset
) != NULL
&& ds
->ds_dir
)
128 return (ds
->ds_dir
->dd_pool
);
130 return (spa_get_dsl(os
->os_spa
));
134 dmu_objset_ds(objset_t
*os
)
136 return (os
->os_dsl_dataset
);
140 dmu_objset_type(objset_t
*os
)
142 return (os
->os_phys
->os_type
);
146 dmu_objset_name(objset_t
*os
, char *buf
)
148 dsl_dataset_name(os
->os_dsl_dataset
, buf
);
152 dmu_objset_id(objset_t
*os
)
154 dsl_dataset_t
*ds
= os
->os_dsl_dataset
;
156 return (ds
? ds
->ds_object
: 0);
160 dmu_objset_dnodesize(objset_t
*os
)
162 return (os
->os_dnodesize
);
166 dmu_objset_syncprop(objset_t
*os
)
168 return (os
->os_sync
);
172 dmu_objset_logbias(objset_t
*os
)
174 return (os
->os_logbias
);
178 checksum_changed_cb(void *arg
, uint64_t newval
)
183 * Inheritance should have been done by now.
185 ASSERT(newval
!= ZIO_CHECKSUM_INHERIT
);
187 os
->os_checksum
= zio_checksum_select(newval
, ZIO_CHECKSUM_ON_VALUE
);
191 compression_changed_cb(void *arg
, uint64_t newval
)
196 * Inheritance and range checking should have been done by now.
198 ASSERT(newval
!= ZIO_COMPRESS_INHERIT
);
200 os
->os_compress
= zio_compress_select(os
->os_spa
,
201 ZIO_COMPRESS_ALGO(newval
), ZIO_COMPRESS_ON
);
202 os
->os_complevel
= zio_complevel_select(os
->os_spa
, os
->os_compress
,
203 ZIO_COMPRESS_LEVEL(newval
), ZIO_COMPLEVEL_DEFAULT
);
207 copies_changed_cb(void *arg
, uint64_t newval
)
212 * Inheritance and range checking should have been done by now.
215 ASSERT(newval
<= spa_max_replication(os
->os_spa
));
217 os
->os_copies
= newval
;
221 dedup_changed_cb(void *arg
, uint64_t newval
)
224 spa_t
*spa
= os
->os_spa
;
225 enum zio_checksum checksum
;
228 * Inheritance should have been done by now.
230 ASSERT(newval
!= ZIO_CHECKSUM_INHERIT
);
232 checksum
= zio_checksum_dedup_select(spa
, newval
, ZIO_CHECKSUM_OFF
);
234 os
->os_dedup_checksum
= checksum
& ZIO_CHECKSUM_MASK
;
235 os
->os_dedup_verify
= !!(checksum
& ZIO_CHECKSUM_VERIFY
);
239 primary_cache_changed_cb(void *arg
, uint64_t newval
)
244 * Inheritance and range checking should have been done by now.
246 ASSERT(newval
== ZFS_CACHE_ALL
|| newval
== ZFS_CACHE_NONE
||
247 newval
== ZFS_CACHE_METADATA
);
249 os
->os_primary_cache
= newval
;
253 secondary_cache_changed_cb(void *arg
, uint64_t newval
)
258 * Inheritance and range checking should have been done by now.
260 ASSERT(newval
== ZFS_CACHE_ALL
|| newval
== ZFS_CACHE_NONE
||
261 newval
== ZFS_CACHE_METADATA
);
263 os
->os_secondary_cache
= newval
;
267 prefetch_changed_cb(void *arg
, uint64_t newval
)
272 * Inheritance should have been done by now.
274 ASSERT(newval
== ZFS_PREFETCH_ALL
|| newval
== ZFS_PREFETCH_NONE
||
275 newval
== ZFS_PREFETCH_METADATA
);
276 os
->os_prefetch
= newval
;
280 sync_changed_cb(void *arg
, uint64_t newval
)
285 * Inheritance and range checking should have been done by now.
287 ASSERT(newval
== ZFS_SYNC_STANDARD
|| newval
== ZFS_SYNC_ALWAYS
||
288 newval
== ZFS_SYNC_DISABLED
);
290 os
->os_sync
= newval
;
292 zil_set_sync(os
->os_zil
, newval
);
296 redundant_metadata_changed_cb(void *arg
, uint64_t newval
)
301 * Inheritance and range checking should have been done by now.
303 ASSERT(newval
== ZFS_REDUNDANT_METADATA_ALL
||
304 newval
== ZFS_REDUNDANT_METADATA_MOST
||
305 newval
== ZFS_REDUNDANT_METADATA_SOME
||
306 newval
== ZFS_REDUNDANT_METADATA_NONE
);
308 os
->os_redundant_metadata
= newval
;
312 dnodesize_changed_cb(void *arg
, uint64_t newval
)
317 case ZFS_DNSIZE_LEGACY
:
318 os
->os_dnodesize
= DNODE_MIN_SIZE
;
320 case ZFS_DNSIZE_AUTO
:
322 * Choose a dnode size that will work well for most
323 * workloads if the user specified "auto". Future code
324 * improvements could dynamically select a dnode size
325 * based on observed workload patterns.
327 os
->os_dnodesize
= DNODE_MIN_SIZE
* 2;
334 os
->os_dnodesize
= newval
;
340 smallblk_changed_cb(void *arg
, uint64_t newval
)
345 * Inheritance and range checking should have been done by now.
347 ASSERT(newval
<= SPA_MAXBLOCKSIZE
);
348 ASSERT(ISP2(newval
));
350 os
->os_zpl_special_smallblock
= newval
;
354 logbias_changed_cb(void *arg
, uint64_t newval
)
358 ASSERT(newval
== ZFS_LOGBIAS_LATENCY
||
359 newval
== ZFS_LOGBIAS_THROUGHPUT
);
360 os
->os_logbias
= newval
;
362 zil_set_logbias(os
->os_zil
, newval
);
366 recordsize_changed_cb(void *arg
, uint64_t newval
)
370 os
->os_recordsize
= newval
;
374 dmu_objset_byteswap(void *buf
, size_t size
)
376 objset_phys_t
*osp
= buf
;
378 ASSERT(size
== OBJSET_PHYS_SIZE_V1
|| size
== OBJSET_PHYS_SIZE_V2
||
379 size
== sizeof (objset_phys_t
));
380 dnode_byteswap(&osp
->os_meta_dnode
);
381 byteswap_uint64_array(&osp
->os_zil_header
, sizeof (zil_header_t
));
382 osp
->os_type
= BSWAP_64(osp
->os_type
);
383 osp
->os_flags
= BSWAP_64(osp
->os_flags
);
384 if (size
>= OBJSET_PHYS_SIZE_V2
) {
385 dnode_byteswap(&osp
->os_userused_dnode
);
386 dnode_byteswap(&osp
->os_groupused_dnode
);
387 if (size
>= sizeof (objset_phys_t
))
388 dnode_byteswap(&osp
->os_projectused_dnode
);
393 * The hash is a CRC-based hash of the objset_t pointer and the object number.
396 dnode_hash(const objset_t
*os
, uint64_t obj
)
398 uintptr_t osv
= (uintptr_t)os
;
399 uint64_t crc
= -1ULL;
401 ASSERT(zfs_crc64_table
[128] == ZFS_CRC64_POLY
);
403 * The lower 11 bits of the pointer don't have much entropy, because
404 * the objset_t is more than 1KB long and so likely aligned to 2KB.
406 crc
= (crc
>> 8) ^ zfs_crc64_table
[(crc
^ (osv
>> 11)) & 0xFF];
407 crc
= (crc
>> 8) ^ zfs_crc64_table
[(crc
^ (obj
>> 0)) & 0xFF];
408 crc
= (crc
>> 8) ^ zfs_crc64_table
[(crc
^ (obj
>> 8)) & 0xFF];
409 crc
= (crc
>> 8) ^ zfs_crc64_table
[(crc
^ (obj
>> 16)) & 0xFF];
411 crc
^= (osv
>>14) ^ (obj
>>24);
417 dnode_multilist_index_func(multilist_t
*ml
, void *obj
)
422 * The low order bits of the hash value are thought to be
423 * distributed evenly. Otherwise, in the case that the multilist
424 * has a power of two number of sublists, each sublists' usage
425 * would not be evenly distributed. In this context full 64bit
426 * division would be a waste of time, so limit it to 32 bits.
428 return ((unsigned int)dnode_hash(dn
->dn_objset
, dn
->dn_object
) %
429 multilist_get_num_sublists(ml
));
432 static inline boolean_t
433 dmu_os_is_l2cacheable(objset_t
*os
)
435 if (os
->os_secondary_cache
== ZFS_CACHE_ALL
||
436 os
->os_secondary_cache
== ZFS_CACHE_METADATA
) {
437 if (l2arc_exclude_special
== 0)
440 blkptr_t
*bp
= os
->os_rootbp
;
441 if (bp
== NULL
|| BP_IS_HOLE(bp
))
443 uint64_t vdev
= DVA_GET_VDEV(bp
->blk_dva
);
444 vdev_t
*rvd
= os
->os_spa
->spa_root_vdev
;
447 if (vdev
< rvd
->vdev_children
)
448 vd
= rvd
->vdev_child
[vdev
];
453 if (vd
->vdev_alloc_bias
!= VDEV_BIAS_SPECIAL
&&
454 vd
->vdev_alloc_bias
!= VDEV_BIAS_DEDUP
)
461 * Instantiates the objset_t in-memory structure corresponding to the
462 * objset_phys_t that's pointed to by the specified blkptr_t.
465 dmu_objset_open_impl(spa_t
*spa
, dsl_dataset_t
*ds
, blkptr_t
*bp
,
471 ASSERT(ds
== NULL
|| MUTEX_HELD(&ds
->ds_opening_lock
));
472 ASSERT(!BP_IS_REDACTED(bp
));
475 * We need the pool config lock to get properties.
477 ASSERT(ds
== NULL
|| dsl_pool_config_held(ds
->ds_dir
->dd_pool
));
480 * The $ORIGIN dataset (if it exists) doesn't have an associated
481 * objset, so there's no reason to open it. The $ORIGIN dataset
482 * will not exist on pools older than SPA_VERSION_ORIGIN.
484 if (ds
!= NULL
&& spa_get_dsl(spa
) != NULL
&&
485 spa_get_dsl(spa
)->dp_origin_snap
!= NULL
) {
486 ASSERT3P(ds
->ds_dir
, !=,
487 spa_get_dsl(spa
)->dp_origin_snap
->ds_dir
);
490 os
= kmem_zalloc(sizeof (objset_t
), KM_SLEEP
);
491 os
->os_dsl_dataset
= ds
;
494 if (!BP_IS_HOLE(os
->os_rootbp
)) {
495 arc_flags_t aflags
= ARC_FLAG_WAIT
;
498 zio_flag_t zio_flags
= ZIO_FLAG_CANFAIL
;
499 SET_BOOKMARK(&zb
, ds
? ds
->ds_object
: DMU_META_OBJSET
,
500 ZB_ROOT_OBJECT
, ZB_ROOT_LEVEL
, ZB_ROOT_BLKID
);
502 if (dmu_os_is_l2cacheable(os
))
503 aflags
|= ARC_FLAG_L2CACHE
;
505 if (ds
!= NULL
&& ds
->ds_dir
->dd_crypto_obj
!= 0) {
506 ASSERT3U(BP_GET_COMPRESS(bp
), ==, ZIO_COMPRESS_OFF
);
507 ASSERT(BP_IS_AUTHENTICATED(bp
));
508 zio_flags
|= ZIO_FLAG_RAW
;
511 dprintf_bp(os
->os_rootbp
, "reading %s", "");
512 err
= arc_read(NULL
, spa
, os
->os_rootbp
,
513 arc_getbuf_func
, &os
->os_phys_buf
,
514 ZIO_PRIORITY_SYNC_READ
, zio_flags
, &aflags
, &zb
);
516 kmem_free(os
, sizeof (objset_t
));
517 /* convert checksum errors into IO errors */
519 err
= SET_ERROR(EIO
);
523 if (spa_version(spa
) < SPA_VERSION_USERSPACE
)
524 size
= OBJSET_PHYS_SIZE_V1
;
525 else if (!spa_feature_is_enabled(spa
,
526 SPA_FEATURE_PROJECT_QUOTA
))
527 size
= OBJSET_PHYS_SIZE_V2
;
529 size
= sizeof (objset_phys_t
);
531 /* Increase the blocksize if we are permitted. */
532 if (arc_buf_size(os
->os_phys_buf
) < size
) {
533 arc_buf_t
*buf
= arc_alloc_buf(spa
, &os
->os_phys_buf
,
534 ARC_BUFC_METADATA
, size
);
535 memset(buf
->b_data
, 0, size
);
536 memcpy(buf
->b_data
, os
->os_phys_buf
->b_data
,
537 arc_buf_size(os
->os_phys_buf
));
538 arc_buf_destroy(os
->os_phys_buf
, &os
->os_phys_buf
);
539 os
->os_phys_buf
= buf
;
542 os
->os_phys
= os
->os_phys_buf
->b_data
;
543 os
->os_flags
= os
->os_phys
->os_flags
;
545 int size
= spa_version(spa
) >= SPA_VERSION_USERSPACE
?
546 sizeof (objset_phys_t
) : OBJSET_PHYS_SIZE_V1
;
547 os
->os_phys_buf
= arc_alloc_buf(spa
, &os
->os_phys_buf
,
548 ARC_BUFC_METADATA
, size
);
549 os
->os_phys
= os
->os_phys_buf
->b_data
;
550 memset(os
->os_phys
, 0, size
);
553 * These properties will be filled in by the logic in zfs_get_zplprop()
554 * when they are queried for the first time.
556 os
->os_version
= OBJSET_PROP_UNINITIALIZED
;
557 os
->os_normalization
= OBJSET_PROP_UNINITIALIZED
;
558 os
->os_utf8only
= OBJSET_PROP_UNINITIALIZED
;
559 os
->os_casesensitivity
= OBJSET_PROP_UNINITIALIZED
;
562 * Note: the changed_cb will be called once before the register
563 * func returns, thus changing the checksum/compression from the
564 * default (fletcher2/off). Snapshots don't need to know about
565 * checksum/compression/copies.
568 os
->os_encrypted
= (ds
->ds_dir
->dd_crypto_obj
!= 0);
570 err
= dsl_prop_register(ds
,
571 zfs_prop_to_name(ZFS_PROP_PRIMARYCACHE
),
572 primary_cache_changed_cb
, os
);
574 err
= dsl_prop_register(ds
,
575 zfs_prop_to_name(ZFS_PROP_SECONDARYCACHE
),
576 secondary_cache_changed_cb
, os
);
579 err
= dsl_prop_register(ds
,
580 zfs_prop_to_name(ZFS_PROP_PREFETCH
),
581 prefetch_changed_cb
, os
);
583 if (!ds
->ds_is_snapshot
) {
585 err
= dsl_prop_register(ds
,
586 zfs_prop_to_name(ZFS_PROP_CHECKSUM
),
587 checksum_changed_cb
, os
);
590 err
= dsl_prop_register(ds
,
591 zfs_prop_to_name(ZFS_PROP_COMPRESSION
),
592 compression_changed_cb
, os
);
595 err
= dsl_prop_register(ds
,
596 zfs_prop_to_name(ZFS_PROP_COPIES
),
597 copies_changed_cb
, os
);
600 err
= dsl_prop_register(ds
,
601 zfs_prop_to_name(ZFS_PROP_DEDUP
),
602 dedup_changed_cb
, os
);
605 err
= dsl_prop_register(ds
,
606 zfs_prop_to_name(ZFS_PROP_LOGBIAS
),
607 logbias_changed_cb
, os
);
610 err
= dsl_prop_register(ds
,
611 zfs_prop_to_name(ZFS_PROP_SYNC
),
612 sync_changed_cb
, os
);
615 err
= dsl_prop_register(ds
,
617 ZFS_PROP_REDUNDANT_METADATA
),
618 redundant_metadata_changed_cb
, os
);
621 err
= dsl_prop_register(ds
,
622 zfs_prop_to_name(ZFS_PROP_RECORDSIZE
),
623 recordsize_changed_cb
, os
);
626 err
= dsl_prop_register(ds
,
627 zfs_prop_to_name(ZFS_PROP_DNODESIZE
),
628 dnodesize_changed_cb
, os
);
631 err
= dsl_prop_register(ds
,
633 ZFS_PROP_SPECIAL_SMALL_BLOCKS
),
634 smallblk_changed_cb
, os
);
638 arc_buf_destroy(os
->os_phys_buf
, &os
->os_phys_buf
);
639 kmem_free(os
, sizeof (objset_t
));
643 /* It's the meta-objset. */
644 os
->os_checksum
= ZIO_CHECKSUM_FLETCHER_4
;
645 os
->os_compress
= ZIO_COMPRESS_ON
;
646 os
->os_complevel
= ZIO_COMPLEVEL_DEFAULT
;
647 os
->os_encrypted
= B_FALSE
;
648 os
->os_copies
= spa_max_replication(spa
);
649 os
->os_dedup_checksum
= ZIO_CHECKSUM_OFF
;
650 os
->os_dedup_verify
= B_FALSE
;
651 os
->os_logbias
= ZFS_LOGBIAS_LATENCY
;
652 os
->os_sync
= ZFS_SYNC_STANDARD
;
653 os
->os_primary_cache
= ZFS_CACHE_ALL
;
654 os
->os_secondary_cache
= ZFS_CACHE_ALL
;
655 os
->os_dnodesize
= DNODE_MIN_SIZE
;
656 os
->os_prefetch
= ZFS_PREFETCH_ALL
;
659 if (ds
== NULL
|| !ds
->ds_is_snapshot
)
660 os
->os_zil_header
= os
->os_phys
->os_zil_header
;
661 os
->os_zil
= zil_alloc(os
, &os
->os_zil_header
);
663 for (i
= 0; i
< TXG_SIZE
; i
++) {
664 multilist_create(&os
->os_dirty_dnodes
[i
], sizeof (dnode_t
),
665 offsetof(dnode_t
, dn_dirty_link
[i
]),
666 dnode_multilist_index_func
);
668 list_create(&os
->os_dnodes
, sizeof (dnode_t
),
669 offsetof(dnode_t
, dn_link
));
670 list_create(&os
->os_downgraded_dbufs
, sizeof (dmu_buf_impl_t
),
671 offsetof(dmu_buf_impl_t
, db_link
));
673 list_link_init(&os
->os_evicting_node
);
675 mutex_init(&os
->os_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
676 mutex_init(&os
->os_userused_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
677 mutex_init(&os
->os_obj_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
678 mutex_init(&os
->os_user_ptr_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
679 os
->os_obj_next_percpu_len
= boot_ncpus
;
680 os
->os_obj_next_percpu
= kmem_zalloc(os
->os_obj_next_percpu_len
*
681 sizeof (os
->os_obj_next_percpu
[0]), KM_SLEEP
);
683 dnode_special_open(os
, &os
->os_phys
->os_meta_dnode
,
684 DMU_META_DNODE_OBJECT
, &os
->os_meta_dnode
);
685 if (OBJSET_BUF_HAS_USERUSED(os
->os_phys_buf
)) {
686 dnode_special_open(os
, &os
->os_phys
->os_userused_dnode
,
687 DMU_USERUSED_OBJECT
, &os
->os_userused_dnode
);
688 dnode_special_open(os
, &os
->os_phys
->os_groupused_dnode
,
689 DMU_GROUPUSED_OBJECT
, &os
->os_groupused_dnode
);
690 if (OBJSET_BUF_HAS_PROJECTUSED(os
->os_phys_buf
))
691 dnode_special_open(os
,
692 &os
->os_phys
->os_projectused_dnode
,
693 DMU_PROJECTUSED_OBJECT
, &os
->os_projectused_dnode
);
696 mutex_init(&os
->os_upgrade_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
703 dmu_objset_from_ds(dsl_dataset_t
*ds
, objset_t
**osp
)
708 * We need the pool_config lock to manipulate the dsl_dataset_t.
709 * Even if the dataset is long-held, we need the pool_config lock
710 * to open the objset, as it needs to get properties.
712 ASSERT(dsl_pool_config_held(ds
->ds_dir
->dd_pool
));
714 mutex_enter(&ds
->ds_opening_lock
);
715 if (ds
->ds_objset
== NULL
) {
717 rrw_enter(&ds
->ds_bp_rwlock
, RW_READER
, FTAG
);
718 err
= dmu_objset_open_impl(dsl_dataset_get_spa(ds
),
719 ds
, dsl_dataset_get_blkptr(ds
), &os
);
720 rrw_exit(&ds
->ds_bp_rwlock
, FTAG
);
723 mutex_enter(&ds
->ds_lock
);
724 ASSERT(ds
->ds_objset
== NULL
);
726 mutex_exit(&ds
->ds_lock
);
729 *osp
= ds
->ds_objset
;
730 mutex_exit(&ds
->ds_opening_lock
);
735 * Holds the pool while the objset is held. Therefore only one objset
736 * can be held at a time.
739 dmu_objset_hold_flags(const char *name
, boolean_t decrypt
, const void *tag
,
745 ds_hold_flags_t flags
;
747 flags
= (decrypt
) ? DS_HOLD_FLAG_DECRYPT
: DS_HOLD_FLAG_NONE
;
748 err
= dsl_pool_hold(name
, tag
, &dp
);
751 err
= dsl_dataset_hold_flags(dp
, name
, flags
, tag
, &ds
);
753 dsl_pool_rele(dp
, tag
);
757 err
= dmu_objset_from_ds(ds
, osp
);
759 dsl_dataset_rele(ds
, tag
);
760 dsl_pool_rele(dp
, tag
);
767 dmu_objset_hold(const char *name
, const void *tag
, objset_t
**osp
)
769 return (dmu_objset_hold_flags(name
, B_FALSE
, tag
, osp
));
773 dmu_objset_own_impl(dsl_dataset_t
*ds
, dmu_objset_type_t type
,
774 boolean_t readonly
, boolean_t decrypt
, const void *tag
, objset_t
**osp
)
778 int err
= dmu_objset_from_ds(ds
, osp
);
781 } else if (type
!= DMU_OST_ANY
&& type
!= (*osp
)->os_phys
->os_type
) {
782 return (SET_ERROR(EINVAL
));
783 } else if (!readonly
&& dsl_dataset_is_snapshot(ds
)) {
784 return (SET_ERROR(EROFS
));
785 } else if (!readonly
&& decrypt
&&
786 dsl_dir_incompatible_encryption_version(ds
->ds_dir
)) {
787 return (SET_ERROR(EROFS
));
790 /* if we are decrypting, we can now check MACs in os->os_phys_buf */
791 if (decrypt
&& arc_is_unauthenticated((*osp
)->os_phys_buf
)) {
794 SET_BOOKMARK(&zb
, ds
->ds_object
, ZB_ROOT_OBJECT
,
795 ZB_ROOT_LEVEL
, ZB_ROOT_BLKID
);
796 err
= arc_untransform((*osp
)->os_phys_buf
, (*osp
)->os_spa
,
801 ASSERT0(arc_is_unauthenticated((*osp
)->os_phys_buf
));
808 * dsl_pool must not be held when this is called.
809 * Upon successful return, there will be a longhold on the dataset,
810 * and the dsl_pool will not be held.
813 dmu_objset_own(const char *name
, dmu_objset_type_t type
,
814 boolean_t readonly
, boolean_t decrypt
, const void *tag
, objset_t
**osp
)
819 ds_hold_flags_t flags
;
821 flags
= (decrypt
) ? DS_HOLD_FLAG_DECRYPT
: DS_HOLD_FLAG_NONE
;
822 err
= dsl_pool_hold(name
, FTAG
, &dp
);
825 err
= dsl_dataset_own(dp
, name
, flags
, tag
, &ds
);
827 dsl_pool_rele(dp
, FTAG
);
830 err
= dmu_objset_own_impl(ds
, type
, readonly
, decrypt
, tag
, osp
);
832 dsl_dataset_disown(ds
, flags
, tag
);
833 dsl_pool_rele(dp
, FTAG
);
838 * User accounting requires the dataset to be decrypted and rw.
839 * We also don't begin user accounting during claiming to help
840 * speed up pool import times and to keep this txg reserved
841 * completely for recovery work.
843 if (!readonly
&& !dp
->dp_spa
->spa_claiming
&&
844 (ds
->ds_dir
->dd_crypto_obj
== 0 || decrypt
)) {
845 if (dmu_objset_userobjspace_upgradable(*osp
) ||
846 dmu_objset_projectquota_upgradable(*osp
)) {
847 dmu_objset_id_quota_upgrade(*osp
);
848 } else if (dmu_objset_userused_enabled(*osp
)) {
849 dmu_objset_userspace_upgrade(*osp
);
853 dsl_pool_rele(dp
, FTAG
);
858 dmu_objset_own_obj(dsl_pool_t
*dp
, uint64_t obj
, dmu_objset_type_t type
,
859 boolean_t readonly
, boolean_t decrypt
, const void *tag
, objset_t
**osp
)
863 ds_hold_flags_t flags
;
865 flags
= (decrypt
) ? DS_HOLD_FLAG_DECRYPT
: DS_HOLD_FLAG_NONE
;
866 err
= dsl_dataset_own_obj(dp
, obj
, flags
, tag
, &ds
);
870 err
= dmu_objset_own_impl(ds
, type
, readonly
, decrypt
, tag
, osp
);
872 dsl_dataset_disown(ds
, flags
, tag
);
880 dmu_objset_rele_flags(objset_t
*os
, boolean_t decrypt
, const void *tag
)
882 ds_hold_flags_t flags
;
883 dsl_pool_t
*dp
= dmu_objset_pool(os
);
885 flags
= (decrypt
) ? DS_HOLD_FLAG_DECRYPT
: DS_HOLD_FLAG_NONE
;
886 dsl_dataset_rele_flags(os
->os_dsl_dataset
, flags
, tag
);
887 dsl_pool_rele(dp
, tag
);
891 dmu_objset_rele(objset_t
*os
, const void *tag
)
893 dmu_objset_rele_flags(os
, B_FALSE
, tag
);
897 * When we are called, os MUST refer to an objset associated with a dataset
898 * that is owned by 'tag'; that is, is held and long held by 'tag' and ds_owner
899 * == tag. We will then release and reacquire ownership of the dataset while
900 * holding the pool config_rwlock to avoid intervening namespace or ownership
903 * This exists solely to accommodate zfs_ioc_userspace_upgrade()'s desire to
904 * release the hold on its dataset and acquire a new one on the dataset of the
905 * same name so that it can be partially torn down and reconstructed.
908 dmu_objset_refresh_ownership(dsl_dataset_t
*ds
, dsl_dataset_t
**newds
,
909 boolean_t decrypt
, const void *tag
)
912 char name
[ZFS_MAX_DATASET_NAME_LEN
];
913 ds_hold_flags_t flags
;
915 flags
= (decrypt
) ? DS_HOLD_FLAG_DECRYPT
: DS_HOLD_FLAG_NONE
;
916 VERIFY3P(ds
, !=, NULL
);
917 VERIFY3P(ds
->ds_owner
, ==, tag
);
918 VERIFY(dsl_dataset_long_held(ds
));
920 dsl_dataset_name(ds
, name
);
921 dp
= ds
->ds_dir
->dd_pool
;
922 dsl_pool_config_enter(dp
, FTAG
);
923 dsl_dataset_disown(ds
, flags
, tag
);
924 VERIFY0(dsl_dataset_own(dp
, name
, flags
, tag
, newds
));
925 dsl_pool_config_exit(dp
, FTAG
);
929 dmu_objset_disown(objset_t
*os
, boolean_t decrypt
, const void *tag
)
931 ds_hold_flags_t flags
;
933 flags
= (decrypt
) ? DS_HOLD_FLAG_DECRYPT
: DS_HOLD_FLAG_NONE
;
935 * Stop upgrading thread
937 dmu_objset_upgrade_stop(os
);
938 dsl_dataset_disown(os
->os_dsl_dataset
, flags
, tag
);
942 dmu_objset_evict_dbufs(objset_t
*os
)
947 dn_marker
= kmem_alloc(sizeof (dnode_t
), KM_SLEEP
);
949 mutex_enter(&os
->os_lock
);
950 dn
= list_head(&os
->os_dnodes
);
953 * Skip dnodes without holds. We have to do this dance
954 * because dnode_add_ref() only works if there is already a
955 * hold. If the dnode has no holds, then it has no dbufs.
957 if (dnode_add_ref(dn
, FTAG
)) {
958 list_insert_after(&os
->os_dnodes
, dn
, dn_marker
);
959 mutex_exit(&os
->os_lock
);
961 dnode_evict_dbufs(dn
);
962 dnode_rele(dn
, FTAG
);
964 mutex_enter(&os
->os_lock
);
965 dn
= list_next(&os
->os_dnodes
, dn_marker
);
966 list_remove(&os
->os_dnodes
, dn_marker
);
968 dn
= list_next(&os
->os_dnodes
, dn
);
971 mutex_exit(&os
->os_lock
);
973 kmem_free(dn_marker
, sizeof (dnode_t
));
975 if (DMU_USERUSED_DNODE(os
) != NULL
) {
976 if (DMU_PROJECTUSED_DNODE(os
) != NULL
)
977 dnode_evict_dbufs(DMU_PROJECTUSED_DNODE(os
));
978 dnode_evict_dbufs(DMU_GROUPUSED_DNODE(os
));
979 dnode_evict_dbufs(DMU_USERUSED_DNODE(os
));
981 dnode_evict_dbufs(DMU_META_DNODE(os
));
985 * Objset eviction processing is split into into two pieces.
986 * The first marks the objset as evicting, evicts any dbufs that
987 * have a refcount of zero, and then queues up the objset for the
988 * second phase of eviction. Once os->os_dnodes has been cleared by
989 * dnode_buf_pageout()->dnode_destroy(), the second phase is executed.
990 * The second phase closes the special dnodes, dequeues the objset from
991 * the list of those undergoing eviction, and finally frees the objset.
993 * NOTE: Due to asynchronous eviction processing (invocation of
994 * dnode_buf_pageout()), it is possible for the meta dnode for the
995 * objset to have no holds even though os->os_dnodes is not empty.
998 dmu_objset_evict(objset_t
*os
)
1000 dsl_dataset_t
*ds
= os
->os_dsl_dataset
;
1002 for (int t
= 0; t
< TXG_SIZE
; t
++)
1003 ASSERT(!dmu_objset_is_dirty(os
, t
));
1006 dsl_prop_unregister_all(ds
, os
);
1011 dmu_objset_evict_dbufs(os
);
1013 mutex_enter(&os
->os_lock
);
1014 spa_evicting_os_register(os
->os_spa
, os
);
1015 if (list_is_empty(&os
->os_dnodes
)) {
1016 mutex_exit(&os
->os_lock
);
1017 dmu_objset_evict_done(os
);
1019 mutex_exit(&os
->os_lock
);
1026 dmu_objset_evict_done(objset_t
*os
)
1028 ASSERT3P(list_head(&os
->os_dnodes
), ==, NULL
);
1030 dnode_special_close(&os
->os_meta_dnode
);
1031 if (DMU_USERUSED_DNODE(os
)) {
1032 if (DMU_PROJECTUSED_DNODE(os
))
1033 dnode_special_close(&os
->os_projectused_dnode
);
1034 dnode_special_close(&os
->os_userused_dnode
);
1035 dnode_special_close(&os
->os_groupused_dnode
);
1037 zil_free(os
->os_zil
);
1039 arc_buf_destroy(os
->os_phys_buf
, &os
->os_phys_buf
);
1042 * This is a barrier to prevent the objset from going away in
1043 * dnode_move() until we can safely ensure that the objset is still in
1044 * use. We consider the objset valid before the barrier and invalid
1045 * after the barrier.
1047 rw_enter(&os_lock
, RW_READER
);
1050 kmem_free(os
->os_obj_next_percpu
,
1051 os
->os_obj_next_percpu_len
* sizeof (os
->os_obj_next_percpu
[0]));
1053 mutex_destroy(&os
->os_lock
);
1054 mutex_destroy(&os
->os_userused_lock
);
1055 mutex_destroy(&os
->os_obj_lock
);
1056 mutex_destroy(&os
->os_user_ptr_lock
);
1057 mutex_destroy(&os
->os_upgrade_lock
);
1058 for (int i
= 0; i
< TXG_SIZE
; i
++)
1059 multilist_destroy(&os
->os_dirty_dnodes
[i
]);
1060 spa_evicting_os_deregister(os
->os_spa
, os
);
1061 kmem_free(os
, sizeof (objset_t
));
1065 dmu_objset_snap_cmtime(objset_t
*os
)
1067 return (dsl_dir_snap_cmtime(os
->os_dsl_dataset
->ds_dir
));
1071 dmu_objset_create_impl_dnstats(spa_t
*spa
, dsl_dataset_t
*ds
, blkptr_t
*bp
,
1072 dmu_objset_type_t type
, int levels
, int blksz
, int ibs
, dmu_tx_t
*tx
)
1077 ASSERT(dmu_tx_is_syncing(tx
));
1080 blksz
= DNODE_BLOCK_SIZE
;
1082 ibs
= DN_MAX_INDBLKSHIFT
;
1085 VERIFY0(dmu_objset_from_ds(ds
, &os
));
1087 VERIFY0(dmu_objset_open_impl(spa
, NULL
, bp
, &os
));
1089 mdn
= DMU_META_DNODE(os
);
1091 dnode_allocate(mdn
, DMU_OT_DNODE
, blksz
, ibs
, DMU_OT_NONE
, 0,
1092 DNODE_MIN_SLOTS
, tx
);
1095 * We don't want to have to increase the meta-dnode's nlevels
1096 * later, because then we could do it in quiescing context while
1097 * we are also accessing it in open context.
1099 * This precaution is not necessary for the MOS (ds == NULL),
1100 * because the MOS is only updated in syncing context.
1101 * This is most fortunate: the MOS is the only objset that
1102 * needs to be synced multiple times as spa_sync() iterates
1103 * to convergence, so minimizing its dn_nlevels matters.
1110 * Determine the number of levels necessary for the
1111 * meta-dnode to contain DN_MAX_OBJECT dnodes. Note
1112 * that in order to ensure that we do not overflow
1113 * 64 bits, there has to be a nlevels that gives us a
1114 * number of blocks > DN_MAX_OBJECT but < 2^64.
1115 * Therefore, (mdn->dn_indblkshift - SPA_BLKPTRSHIFT)
1116 * (10) must be less than (64 - log2(DN_MAX_OBJECT))
1119 while ((uint64_t)mdn
->dn_nblkptr
<<
1120 (mdn
->dn_datablkshift
- DNODE_SHIFT
+ (levels
- 1) *
1121 (mdn
->dn_indblkshift
- SPA_BLKPTRSHIFT
)) <
1126 mdn
->dn_next_nlevels
[tx
->tx_txg
& TXG_MASK
] =
1127 mdn
->dn_nlevels
= levels
;
1130 ASSERT(type
!= DMU_OST_NONE
);
1131 ASSERT(type
!= DMU_OST_ANY
);
1132 ASSERT(type
< DMU_OST_NUMTYPES
);
1133 os
->os_phys
->os_type
= type
;
1136 * Enable user accounting if it is enabled and this is not an
1137 * encrypted receive.
1139 if (dmu_objset_userused_enabled(os
) &&
1140 (!os
->os_encrypted
|| !dmu_objset_is_receiving(os
))) {
1141 os
->os_phys
->os_flags
|= OBJSET_FLAG_USERACCOUNTING_COMPLETE
;
1142 if (dmu_objset_userobjused_enabled(os
)) {
1143 ASSERT3P(ds
, !=, NULL
);
1144 ds
->ds_feature_activation
[
1145 SPA_FEATURE_USEROBJ_ACCOUNTING
] = (void *)B_TRUE
;
1146 os
->os_phys
->os_flags
|=
1147 OBJSET_FLAG_USEROBJACCOUNTING_COMPLETE
;
1149 if (dmu_objset_projectquota_enabled(os
)) {
1150 ASSERT3P(ds
, !=, NULL
);
1151 ds
->ds_feature_activation
[
1152 SPA_FEATURE_PROJECT_QUOTA
] = (void *)B_TRUE
;
1153 os
->os_phys
->os_flags
|=
1154 OBJSET_FLAG_PROJECTQUOTA_COMPLETE
;
1156 os
->os_flags
= os
->os_phys
->os_flags
;
1159 dsl_dataset_dirty(ds
, tx
);
1164 /* called from dsl for meta-objset */
1166 dmu_objset_create_impl(spa_t
*spa
, dsl_dataset_t
*ds
, blkptr_t
*bp
,
1167 dmu_objset_type_t type
, dmu_tx_t
*tx
)
1169 return (dmu_objset_create_impl_dnstats(spa
, ds
, bp
, type
, 0, 0, 0, tx
));
1172 typedef struct dmu_objset_create_arg
{
1173 const char *doca_name
;
1176 void (*doca_userfunc
)(objset_t
*os
, void *arg
,
1177 cred_t
*cr
, dmu_tx_t
*tx
);
1179 dmu_objset_type_t doca_type
;
1180 uint64_t doca_flags
;
1181 dsl_crypto_params_t
*doca_dcp
;
1182 } dmu_objset_create_arg_t
;
1185 dmu_objset_create_check(void *arg
, dmu_tx_t
*tx
)
1187 dmu_objset_create_arg_t
*doca
= arg
;
1188 dsl_pool_t
*dp
= dmu_tx_pool(tx
);
1190 dsl_dataset_t
*parentds
;
1195 if (strchr(doca
->doca_name
, '@') != NULL
)
1196 return (SET_ERROR(EINVAL
));
1198 if (strlen(doca
->doca_name
) >= ZFS_MAX_DATASET_NAME_LEN
)
1199 return (SET_ERROR(ENAMETOOLONG
));
1201 if (dataset_nestcheck(doca
->doca_name
) != 0)
1202 return (SET_ERROR(ENAMETOOLONG
));
1204 error
= dsl_dir_hold(dp
, doca
->doca_name
, FTAG
, &pdd
, &tail
);
1208 dsl_dir_rele(pdd
, FTAG
);
1209 return (SET_ERROR(EEXIST
));
1212 error
= dmu_objset_create_crypt_check(pdd
, doca
->doca_dcp
, NULL
);
1214 dsl_dir_rele(pdd
, FTAG
);
1218 error
= dsl_fs_ss_limit_check(pdd
, 1, ZFS_PROP_FILESYSTEM_LIMIT
, NULL
,
1219 doca
->doca_cred
, doca
->doca_proc
);
1221 dsl_dir_rele(pdd
, FTAG
);
1225 /* can't create below anything but filesystems (eg. no ZVOLs) */
1226 error
= dsl_dataset_hold_obj(pdd
->dd_pool
,
1227 dsl_dir_phys(pdd
)->dd_head_dataset_obj
, FTAG
, &parentds
);
1229 dsl_dir_rele(pdd
, FTAG
);
1232 error
= dmu_objset_from_ds(parentds
, &parentos
);
1234 dsl_dataset_rele(parentds
, FTAG
);
1235 dsl_dir_rele(pdd
, FTAG
);
1238 if (dmu_objset_type(parentos
) != DMU_OST_ZFS
) {
1239 dsl_dataset_rele(parentds
, FTAG
);
1240 dsl_dir_rele(pdd
, FTAG
);
1241 return (SET_ERROR(ZFS_ERR_WRONG_PARENT
));
1243 dsl_dataset_rele(parentds
, FTAG
);
1244 dsl_dir_rele(pdd
, FTAG
);
1250 dmu_objset_create_sync(void *arg
, dmu_tx_t
*tx
)
1252 dmu_objset_create_arg_t
*doca
= arg
;
1253 dsl_pool_t
*dp
= dmu_tx_pool(tx
);
1254 spa_t
*spa
= dp
->dp_spa
;
1263 VERIFY0(dsl_dir_hold(dp
, doca
->doca_name
, FTAG
, &pdd
, &tail
));
1265 obj
= dsl_dataset_create_sync(pdd
, tail
, NULL
, doca
->doca_flags
,
1266 doca
->doca_cred
, doca
->doca_dcp
, tx
);
1268 VERIFY0(dsl_dataset_hold_obj_flags(pdd
->dd_pool
, obj
,
1269 DS_HOLD_FLAG_DECRYPT
, FTAG
, &ds
));
1270 rrw_enter(&ds
->ds_bp_rwlock
, RW_READER
, FTAG
);
1271 bp
= dsl_dataset_get_blkptr(ds
);
1272 os
= dmu_objset_create_impl(spa
, ds
, bp
, doca
->doca_type
, tx
);
1273 rrw_exit(&ds
->ds_bp_rwlock
, FTAG
);
1275 if (doca
->doca_userfunc
!= NULL
) {
1276 doca
->doca_userfunc(os
, doca
->doca_userarg
,
1277 doca
->doca_cred
, tx
);
1281 * The doca_userfunc() may write out some data that needs to be
1282 * encrypted if the dataset is encrypted (specifically the root
1283 * directory). This data must be written out before the encryption
1284 * key mapping is removed by dsl_dataset_rele_flags(). Force the
1285 * I/O to occur immediately by invoking the relevant sections of
1288 if (os
->os_encrypted
) {
1289 dsl_dataset_t
*tmpds
= NULL
;
1290 boolean_t need_sync_done
= B_FALSE
;
1292 mutex_enter(&ds
->ds_lock
);
1293 ds
->ds_owner
= FTAG
;
1294 mutex_exit(&ds
->ds_lock
);
1296 rzio
= zio_root(spa
, NULL
, NULL
, ZIO_FLAG_MUSTSUCCEED
);
1297 tmpds
= txg_list_remove_this(&dp
->dp_dirty_datasets
, ds
,
1299 if (tmpds
!= NULL
) {
1300 dsl_dataset_sync(ds
, rzio
, tx
);
1301 need_sync_done
= B_TRUE
;
1303 VERIFY0(zio_wait(rzio
));
1305 dmu_objset_sync_done(os
, tx
);
1306 taskq_wait(dp
->dp_sync_taskq
);
1307 if (txg_list_member(&dp
->dp_dirty_datasets
, ds
, tx
->tx_txg
)) {
1308 ASSERT3P(ds
->ds_key_mapping
, !=, NULL
);
1309 key_mapping_rele(spa
, ds
->ds_key_mapping
, ds
);
1312 rzio
= zio_root(spa
, NULL
, NULL
, ZIO_FLAG_MUSTSUCCEED
);
1313 tmpds
= txg_list_remove_this(&dp
->dp_dirty_datasets
, ds
,
1315 if (tmpds
!= NULL
) {
1316 dmu_buf_rele(ds
->ds_dbuf
, ds
);
1317 dsl_dataset_sync(ds
, rzio
, tx
);
1319 VERIFY0(zio_wait(rzio
));
1321 if (need_sync_done
) {
1322 ASSERT3P(ds
->ds_key_mapping
, !=, NULL
);
1323 key_mapping_rele(spa
, ds
->ds_key_mapping
, ds
);
1324 dsl_dataset_sync_done(ds
, tx
);
1325 dmu_buf_rele(ds
->ds_dbuf
, ds
);
1328 mutex_enter(&ds
->ds_lock
);
1329 ds
->ds_owner
= NULL
;
1330 mutex_exit(&ds
->ds_lock
);
1333 spa_history_log_internal_ds(ds
, "create", tx
, " ");
1335 dsl_dataset_rele_flags(ds
, DS_HOLD_FLAG_DECRYPT
, FTAG
);
1336 dsl_dir_rele(pdd
, FTAG
);
1340 dmu_objset_create(const char *name
, dmu_objset_type_t type
, uint64_t flags
,
1341 dsl_crypto_params_t
*dcp
, dmu_objset_create_sync_func_t func
, void *arg
)
1343 dmu_objset_create_arg_t doca
;
1344 dsl_crypto_params_t tmp_dcp
= { 0 };
1346 doca
.doca_name
= name
;
1347 doca
.doca_cred
= CRED();
1348 doca
.doca_proc
= curproc
;
1349 doca
.doca_flags
= flags
;
1350 doca
.doca_userfunc
= func
;
1351 doca
.doca_userarg
= arg
;
1352 doca
.doca_type
= type
;
1355 * Some callers (mostly for testing) do not provide a dcp on their
1356 * own but various code inside the sync task will require it to be
1357 * allocated. Rather than adding NULL checks throughout this code
1358 * or adding dummy dcp's to all of the callers we simply create a
1359 * dummy one here and use that. This zero dcp will have the same
1360 * effect as asking for inheritance of all encryption params.
1362 doca
.doca_dcp
= (dcp
!= NULL
) ? dcp
: &tmp_dcp
;
1364 int rv
= dsl_sync_task(name
,
1365 dmu_objset_create_check
, dmu_objset_create_sync
, &doca
,
1366 6, ZFS_SPACE_CHECK_NORMAL
);
1369 zvol_create_minor(name
);
1373 typedef struct dmu_objset_clone_arg
{
1374 const char *doca_clone
;
1375 const char *doca_origin
;
1378 } dmu_objset_clone_arg_t
;
1381 dmu_objset_clone_check(void *arg
, dmu_tx_t
*tx
)
1383 dmu_objset_clone_arg_t
*doca
= arg
;
1387 dsl_dataset_t
*origin
;
1388 dsl_pool_t
*dp
= dmu_tx_pool(tx
);
1390 if (strchr(doca
->doca_clone
, '@') != NULL
)
1391 return (SET_ERROR(EINVAL
));
1393 if (strlen(doca
->doca_clone
) >= ZFS_MAX_DATASET_NAME_LEN
)
1394 return (SET_ERROR(ENAMETOOLONG
));
1396 error
= dsl_dir_hold(dp
, doca
->doca_clone
, FTAG
, &pdd
, &tail
);
1400 dsl_dir_rele(pdd
, FTAG
);
1401 return (SET_ERROR(EEXIST
));
1404 error
= dsl_fs_ss_limit_check(pdd
, 1, ZFS_PROP_FILESYSTEM_LIMIT
, NULL
,
1405 doca
->doca_cred
, doca
->doca_proc
);
1407 dsl_dir_rele(pdd
, FTAG
);
1408 return (SET_ERROR(EDQUOT
));
1411 error
= dsl_dataset_hold(dp
, doca
->doca_origin
, FTAG
, &origin
);
1413 dsl_dir_rele(pdd
, FTAG
);
1417 /* You can only clone snapshots, not the head datasets. */
1418 if (!origin
->ds_is_snapshot
) {
1419 dsl_dataset_rele(origin
, FTAG
);
1420 dsl_dir_rele(pdd
, FTAG
);
1421 return (SET_ERROR(EINVAL
));
1424 dsl_dataset_rele(origin
, FTAG
);
1425 dsl_dir_rele(pdd
, FTAG
);
1431 dmu_objset_clone_sync(void *arg
, dmu_tx_t
*tx
)
1433 dmu_objset_clone_arg_t
*doca
= arg
;
1434 dsl_pool_t
*dp
= dmu_tx_pool(tx
);
1437 dsl_dataset_t
*origin
, *ds
;
1439 char namebuf
[ZFS_MAX_DATASET_NAME_LEN
];
1441 VERIFY0(dsl_dir_hold(dp
, doca
->doca_clone
, FTAG
, &pdd
, &tail
));
1442 VERIFY0(dsl_dataset_hold(dp
, doca
->doca_origin
, FTAG
, &origin
));
1444 obj
= dsl_dataset_create_sync(pdd
, tail
, origin
, 0,
1445 doca
->doca_cred
, NULL
, tx
);
1447 VERIFY0(dsl_dataset_hold_obj(pdd
->dd_pool
, obj
, FTAG
, &ds
));
1448 dsl_dataset_name(origin
, namebuf
);
1449 spa_history_log_internal_ds(ds
, "clone", tx
,
1450 "origin=%s (%llu)", namebuf
, (u_longlong_t
)origin
->ds_object
);
1451 dsl_dataset_rele(ds
, FTAG
);
1452 dsl_dataset_rele(origin
, FTAG
);
1453 dsl_dir_rele(pdd
, FTAG
);
1457 dmu_objset_clone(const char *clone
, const char *origin
)
1459 dmu_objset_clone_arg_t doca
;
1461 doca
.doca_clone
= clone
;
1462 doca
.doca_origin
= origin
;
1463 doca
.doca_cred
= CRED();
1464 doca
.doca_proc
= curproc
;
1466 int rv
= dsl_sync_task(clone
,
1467 dmu_objset_clone_check
, dmu_objset_clone_sync
, &doca
,
1468 6, ZFS_SPACE_CHECK_NORMAL
);
1471 zvol_create_minor(clone
);
1477 dmu_objset_snapshot_one(const char *fsname
, const char *snapname
)
1480 char *longsnap
= kmem_asprintf("%s@%s", fsname
, snapname
);
1481 nvlist_t
*snaps
= fnvlist_alloc();
1483 fnvlist_add_boolean(snaps
, longsnap
);
1484 kmem_strfree(longsnap
);
1485 err
= dsl_dataset_snapshot(snaps
, NULL
, NULL
);
1486 fnvlist_free(snaps
);
1491 dmu_objset_upgrade_task_cb(void *data
)
1493 objset_t
*os
= data
;
1495 mutex_enter(&os
->os_upgrade_lock
);
1496 os
->os_upgrade_status
= EINTR
;
1497 if (!os
->os_upgrade_exit
) {
1500 mutex_exit(&os
->os_upgrade_lock
);
1502 status
= os
->os_upgrade_cb(os
);
1504 mutex_enter(&os
->os_upgrade_lock
);
1506 os
->os_upgrade_status
= status
;
1508 os
->os_upgrade_exit
= B_TRUE
;
1509 os
->os_upgrade_id
= 0;
1510 mutex_exit(&os
->os_upgrade_lock
);
1511 dsl_dataset_long_rele(dmu_objset_ds(os
), upgrade_tag
);
1515 dmu_objset_upgrade(objset_t
*os
, dmu_objset_upgrade_cb_t cb
)
1517 if (os
->os_upgrade_id
!= 0)
1520 ASSERT(dsl_pool_config_held(dmu_objset_pool(os
)));
1521 dsl_dataset_long_hold(dmu_objset_ds(os
), upgrade_tag
);
1523 mutex_enter(&os
->os_upgrade_lock
);
1524 if (os
->os_upgrade_id
== 0 && os
->os_upgrade_status
== 0) {
1525 os
->os_upgrade_exit
= B_FALSE
;
1526 os
->os_upgrade_cb
= cb
;
1527 os
->os_upgrade_id
= taskq_dispatch(
1528 os
->os_spa
->spa_upgrade_taskq
,
1529 dmu_objset_upgrade_task_cb
, os
, TQ_SLEEP
);
1530 if (os
->os_upgrade_id
== TASKQID_INVALID
) {
1531 dsl_dataset_long_rele(dmu_objset_ds(os
), upgrade_tag
);
1532 os
->os_upgrade_status
= ENOMEM
;
1535 dsl_dataset_long_rele(dmu_objset_ds(os
), upgrade_tag
);
1537 mutex_exit(&os
->os_upgrade_lock
);
1541 dmu_objset_upgrade_stop(objset_t
*os
)
1543 mutex_enter(&os
->os_upgrade_lock
);
1544 os
->os_upgrade_exit
= B_TRUE
;
1545 if (os
->os_upgrade_id
!= 0) {
1546 taskqid_t id
= os
->os_upgrade_id
;
1548 os
->os_upgrade_id
= 0;
1549 mutex_exit(&os
->os_upgrade_lock
);
1551 if ((taskq_cancel_id(os
->os_spa
->spa_upgrade_taskq
, id
)) == 0) {
1552 dsl_dataset_long_rele(dmu_objset_ds(os
), upgrade_tag
);
1554 txg_wait_synced(os
->os_spa
->spa_dsl_pool
, 0);
1556 mutex_exit(&os
->os_upgrade_lock
);
1561 dmu_objset_sync_dnodes(multilist_sublist_t
*list
, dmu_tx_t
*tx
)
1565 while ((dn
= multilist_sublist_head(list
)) != NULL
) {
1566 ASSERT(dn
->dn_object
!= DMU_META_DNODE_OBJECT
);
1567 ASSERT(dn
->dn_dbuf
->db_data_pending
);
1569 * Initialize dn_zio outside dnode_sync() because the
1570 * meta-dnode needs to set it outside dnode_sync().
1572 dn
->dn_zio
= dn
->dn_dbuf
->db_data_pending
->dr_zio
;
1575 ASSERT3U(dn
->dn_nlevels
, <=, DN_MAX_LEVELS
);
1576 multilist_sublist_remove(list
, dn
);
1579 * See the comment above dnode_rele_task() for an explanation
1580 * of why this dnode hold is always needed (even when not
1581 * doing user accounting).
1583 multilist_t
*newlist
= &dn
->dn_objset
->os_synced_dnodes
;
1584 (void) dnode_add_ref(dn
, newlist
);
1585 multilist_insert(newlist
, dn
);
1592 dmu_objset_write_ready(zio_t
*zio
, arc_buf_t
*abuf
, void *arg
)
1595 blkptr_t
*bp
= zio
->io_bp
;
1597 dnode_phys_t
*dnp
= &os
->os_phys
->os_meta_dnode
;
1600 ASSERT(!BP_IS_EMBEDDED(bp
));
1601 ASSERT3U(BP_GET_TYPE(bp
), ==, DMU_OT_OBJSET
);
1602 ASSERT0(BP_GET_LEVEL(bp
));
1605 * Update rootbp fill count: it should be the number of objects
1606 * allocated in the object set (not counting the "special"
1607 * objects that are stored in the objset_phys_t -- the meta
1608 * dnode and user/group/project accounting objects).
1610 for (int i
= 0; i
< dnp
->dn_nblkptr
; i
++)
1611 fill
+= BP_GET_FILL(&dnp
->dn_blkptr
[i
]);
1613 BP_SET_FILL(bp
, fill
);
1615 if (os
->os_dsl_dataset
!= NULL
)
1616 rrw_enter(&os
->os_dsl_dataset
->ds_bp_rwlock
, RW_WRITER
, FTAG
);
1617 *os
->os_rootbp
= *bp
;
1618 if (os
->os_dsl_dataset
!= NULL
)
1619 rrw_exit(&os
->os_dsl_dataset
->ds_bp_rwlock
, FTAG
);
1623 dmu_objset_write_done(zio_t
*zio
, arc_buf_t
*abuf
, void *arg
)
1626 blkptr_t
*bp
= zio
->io_bp
;
1627 blkptr_t
*bp_orig
= &zio
->io_bp_orig
;
1630 if (zio
->io_flags
& ZIO_FLAG_IO_REWRITE
) {
1631 ASSERT(BP_EQUAL(bp
, bp_orig
));
1633 dsl_dataset_t
*ds
= os
->os_dsl_dataset
;
1634 dmu_tx_t
*tx
= os
->os_synctx
;
1636 (void) dsl_dataset_block_kill(ds
, bp_orig
, tx
, B_TRUE
);
1637 dsl_dataset_block_born(ds
, bp
, tx
);
1639 kmem_free(bp
, sizeof (*bp
));
1642 typedef struct sync_objset_arg
{
1648 taskq_ent_t soa_tq_ent
;
1649 } sync_objset_arg_t
;
1651 typedef struct sync_dnodes_arg
{
1652 multilist_t
*sda_list
;
1653 int sda_sublist_idx
;
1654 multilist_t
*sda_newlist
;
1655 sync_objset_arg_t
*sda_soa
;
1656 } sync_dnodes_arg_t
;
1658 static void sync_meta_dnode_task(void *arg
);
1661 sync_dnodes_task(void *arg
)
1663 sync_dnodes_arg_t
*sda
= arg
;
1664 sync_objset_arg_t
*soa
= sda
->sda_soa
;
1665 objset_t
*os
= soa
->soa_os
;
1667 uint_t allocator
= spa_acq_allocator(os
->os_spa
);
1668 multilist_sublist_t
*ms
=
1669 multilist_sublist_lock_idx(sda
->sda_list
, sda
->sda_sublist_idx
);
1671 dmu_objset_sync_dnodes(ms
, soa
->soa_tx
);
1673 multilist_sublist_unlock(ms
);
1674 spa_rel_allocator(os
->os_spa
, allocator
);
1676 kmem_free(sda
, sizeof (*sda
));
1678 mutex_enter(&soa
->soa_mutex
);
1679 ASSERT(soa
->soa_count
!= 0);
1680 if (--soa
->soa_count
!= 0) {
1681 mutex_exit(&soa
->soa_mutex
);
1684 mutex_exit(&soa
->soa_mutex
);
1686 taskq_dispatch_ent(dmu_objset_pool(os
)->dp_sync_taskq
,
1687 sync_meta_dnode_task
, soa
, TQ_FRONT
, &soa
->soa_tq_ent
);
1691 * Issue the zio_nowait() for all dirty record zios on the meta dnode,
1692 * then trigger the callback for the zil_sync. This runs once for each
1693 * objset, only after any/all sublists in the objset have been synced.
1696 sync_meta_dnode_task(void *arg
)
1698 sync_objset_arg_t
*soa
= arg
;
1699 objset_t
*os
= soa
->soa_os
;
1700 dmu_tx_t
*tx
= soa
->soa_tx
;
1701 int txgoff
= tx
->tx_txg
& TXG_MASK
;
1702 dbuf_dirty_record_t
*dr
;
1704 ASSERT0(soa
->soa_count
);
1706 list_t
*list
= &DMU_META_DNODE(os
)->dn_dirty_records
[txgoff
];
1707 while ((dr
= list_remove_head(list
)) != NULL
) {
1708 ASSERT0(dr
->dr_dbuf
->db_level
);
1709 zio_nowait(dr
->dr_zio
);
1712 /* Enable dnode backfill if enough objects have been freed. */
1713 if (os
->os_freed_dnodes
>= dmu_rescan_dnode_threshold
) {
1714 os
->os_rescan_dnodes
= B_TRUE
;
1715 os
->os_freed_dnodes
= 0;
1719 * Free intent log blocks up to this tx.
1721 zil_sync(os
->os_zil
, tx
);
1722 os
->os_phys
->os_zil_header
= os
->os_zil_header
;
1723 zio_nowait(soa
->soa_zio
);
1725 mutex_destroy(&soa
->soa_mutex
);
1726 kmem_free(soa
, sizeof (*soa
));
1729 /* called from dsl */
1731 dmu_objset_sync(objset_t
*os
, zio_t
*pio
, dmu_tx_t
*tx
)
1734 zbookmark_phys_t zb
;
1739 blkptr_t
*blkptr_copy
= kmem_alloc(sizeof (*os
->os_rootbp
), KM_SLEEP
);
1740 *blkptr_copy
= *os
->os_rootbp
;
1742 dprintf_ds(os
->os_dsl_dataset
, "txg=%llu\n", (u_longlong_t
)tx
->tx_txg
);
1744 ASSERT(dmu_tx_is_syncing(tx
));
1745 /* XXX the write_done callback should really give us the tx... */
1748 if (os
->os_dsl_dataset
== NULL
) {
1750 * This is the MOS. If we have upgraded,
1751 * spa_max_replication() could change, so reset
1754 os
->os_copies
= spa_max_replication(os
->os_spa
);
1758 * Create the root block IO
1760 SET_BOOKMARK(&zb
, os
->os_dsl_dataset
?
1761 os
->os_dsl_dataset
->ds_object
: DMU_META_OBJSET
,
1762 ZB_ROOT_OBJECT
, ZB_ROOT_LEVEL
, ZB_ROOT_BLKID
);
1763 arc_release(os
->os_phys_buf
, &os
->os_phys_buf
);
1765 dmu_write_policy(os
, NULL
, 0, 0, &zp
);
1768 * If we are either claiming the ZIL or doing a raw receive, write
1769 * out the os_phys_buf raw. Neither of these actions will effect the
1770 * MAC at this point.
1772 if (os
->os_raw_receive
||
1773 os
->os_next_write_raw
[tx
->tx_txg
& TXG_MASK
]) {
1774 ASSERT(os
->os_encrypted
);
1775 arc_convert_to_raw(os
->os_phys_buf
,
1776 os
->os_dsl_dataset
->ds_object
, ZFS_HOST_BYTEORDER
,
1777 DMU_OT_OBJSET
, NULL
, NULL
, NULL
);
1780 zio
= arc_write(pio
, os
->os_spa
, tx
->tx_txg
,
1781 blkptr_copy
, os
->os_phys_buf
, B_FALSE
, dmu_os_is_l2cacheable(os
),
1782 &zp
, dmu_objset_write_ready
, NULL
, dmu_objset_write_done
,
1783 os
, ZIO_PRIORITY_ASYNC_WRITE
, ZIO_FLAG_MUSTSUCCEED
, &zb
);
1786 * Sync special dnodes - the parent IO for the sync is the root block
1788 DMU_META_DNODE(os
)->dn_zio
= zio
;
1789 dnode_sync(DMU_META_DNODE(os
), tx
);
1791 os
->os_phys
->os_flags
= os
->os_flags
;
1793 if (DMU_USERUSED_DNODE(os
) &&
1794 DMU_USERUSED_DNODE(os
)->dn_type
!= DMU_OT_NONE
) {
1795 DMU_USERUSED_DNODE(os
)->dn_zio
= zio
;
1796 dnode_sync(DMU_USERUSED_DNODE(os
), tx
);
1797 DMU_GROUPUSED_DNODE(os
)->dn_zio
= zio
;
1798 dnode_sync(DMU_GROUPUSED_DNODE(os
), tx
);
1801 if (DMU_PROJECTUSED_DNODE(os
) &&
1802 DMU_PROJECTUSED_DNODE(os
)->dn_type
!= DMU_OT_NONE
) {
1803 DMU_PROJECTUSED_DNODE(os
)->dn_zio
= zio
;
1804 dnode_sync(DMU_PROJECTUSED_DNODE(os
), tx
);
1807 txgoff
= tx
->tx_txg
& TXG_MASK
;
1810 * We must create the list here because it uses the
1811 * dn_dirty_link[] of this txg. But it may already
1812 * exist because we call dsl_dataset_sync() twice per txg.
1814 if (os
->os_synced_dnodes
.ml_sublists
== NULL
) {
1815 multilist_create(&os
->os_synced_dnodes
, sizeof (dnode_t
),
1816 offsetof(dnode_t
, dn_dirty_link
[txgoff
]),
1817 dnode_multilist_index_func
);
1819 ASSERT3U(os
->os_synced_dnodes
.ml_offset
, ==,
1820 offsetof(dnode_t
, dn_dirty_link
[txgoff
]));
1824 * zio_nowait(zio) is done after any/all sublist and meta dnode
1825 * zios have been nowaited, and the zil_sync() has been performed.
1826 * The soa is freed at the end of sync_meta_dnode_task.
1828 sync_objset_arg_t
*soa
= kmem_alloc(sizeof (*soa
), KM_SLEEP
);
1832 taskq_init_ent(&soa
->soa_tq_ent
);
1833 mutex_init(&soa
->soa_mutex
, NULL
, MUTEX_DEFAULT
, NULL
);
1835 ml
= &os
->os_dirty_dnodes
[txgoff
];
1836 soa
->soa_count
= num_sublists
= multilist_get_num_sublists(ml
);
1838 for (int i
= 0; i
< num_sublists
; i
++) {
1839 if (multilist_sublist_is_empty_idx(ml
, i
))
1843 if (soa
->soa_count
== 0) {
1844 taskq_dispatch_ent(dmu_objset_pool(os
)->dp_sync_taskq
,
1845 sync_meta_dnode_task
, soa
, TQ_FRONT
, &soa
->soa_tq_ent
);
1848 * Sync sublists in parallel. The last to finish
1849 * (i.e., when soa->soa_count reaches zero) must
1850 * dispatch sync_meta_dnode_task.
1852 for (int i
= 0; i
< num_sublists
; i
++) {
1853 if (multilist_sublist_is_empty_idx(ml
, i
))
1855 sync_dnodes_arg_t
*sda
=
1856 kmem_alloc(sizeof (*sda
), KM_SLEEP
);
1858 sda
->sda_sublist_idx
= i
;
1860 (void) taskq_dispatch(
1861 dmu_objset_pool(os
)->dp_sync_taskq
,
1862 sync_dnodes_task
, sda
, 0);
1863 /* sync_dnodes_task frees sda */
1869 dmu_objset_is_dirty(objset_t
*os
, uint64_t txg
)
1871 return (!multilist_is_empty(&os
->os_dirty_dnodes
[txg
& TXG_MASK
]));
1874 static file_info_cb_t
*file_cbs
[DMU_OST_NUMTYPES
];
1877 dmu_objset_register_type(dmu_objset_type_t ost
, file_info_cb_t
*cb
)
1883 dmu_get_file_info(objset_t
*os
, dmu_object_type_t bonustype
, const void *data
,
1884 zfs_file_info_t
*zfi
)
1886 file_info_cb_t
*cb
= file_cbs
[os
->os_phys
->os_type
];
1889 return (cb(bonustype
, data
, zfi
));
1893 dmu_objset_userused_enabled(objset_t
*os
)
1895 return (spa_version(os
->os_spa
) >= SPA_VERSION_USERSPACE
&&
1896 file_cbs
[os
->os_phys
->os_type
] != NULL
&&
1897 DMU_USERUSED_DNODE(os
) != NULL
);
1901 dmu_objset_userobjused_enabled(objset_t
*os
)
1903 return (dmu_objset_userused_enabled(os
) &&
1904 spa_feature_is_enabled(os
->os_spa
, SPA_FEATURE_USEROBJ_ACCOUNTING
));
1908 dmu_objset_projectquota_enabled(objset_t
*os
)
1910 return (file_cbs
[os
->os_phys
->os_type
] != NULL
&&
1911 DMU_PROJECTUSED_DNODE(os
) != NULL
&&
1912 spa_feature_is_enabled(os
->os_spa
, SPA_FEATURE_PROJECT_QUOTA
));
1915 typedef struct userquota_node
{
1916 /* must be in the first filed, see userquota_update_cache() */
1917 char uqn_id
[20 + DMU_OBJACCT_PREFIX_LEN
];
1919 avl_node_t uqn_node
;
1922 typedef struct userquota_cache
{
1923 avl_tree_t uqc_user_deltas
;
1924 avl_tree_t uqc_group_deltas
;
1925 avl_tree_t uqc_project_deltas
;
1926 } userquota_cache_t
;
1929 userquota_compare(const void *l
, const void *r
)
1931 const userquota_node_t
*luqn
= l
;
1932 const userquota_node_t
*ruqn
= r
;
1936 * NB: can only access uqn_id because userquota_update_cache() doesn't
1937 * pass in an entire userquota_node_t.
1939 rv
= strcmp(luqn
->uqn_id
, ruqn
->uqn_id
);
1941 return (TREE_ISIGN(rv
));
1945 do_userquota_cacheflush(objset_t
*os
, userquota_cache_t
*cache
, dmu_tx_t
*tx
)
1948 userquota_node_t
*uqn
;
1950 ASSERT(dmu_tx_is_syncing(tx
));
1953 while ((uqn
= avl_destroy_nodes(&cache
->uqc_user_deltas
,
1954 &cookie
)) != NULL
) {
1956 * os_userused_lock protects against concurrent calls to
1957 * zap_increment_int(). It's needed because zap_increment_int()
1958 * is not thread-safe (i.e. not atomic).
1960 mutex_enter(&os
->os_userused_lock
);
1961 VERIFY0(zap_increment(os
, DMU_USERUSED_OBJECT
,
1962 uqn
->uqn_id
, uqn
->uqn_delta
, tx
));
1963 mutex_exit(&os
->os_userused_lock
);
1964 kmem_free(uqn
, sizeof (*uqn
));
1966 avl_destroy(&cache
->uqc_user_deltas
);
1969 while ((uqn
= avl_destroy_nodes(&cache
->uqc_group_deltas
,
1970 &cookie
)) != NULL
) {
1971 mutex_enter(&os
->os_userused_lock
);
1972 VERIFY0(zap_increment(os
, DMU_GROUPUSED_OBJECT
,
1973 uqn
->uqn_id
, uqn
->uqn_delta
, tx
));
1974 mutex_exit(&os
->os_userused_lock
);
1975 kmem_free(uqn
, sizeof (*uqn
));
1977 avl_destroy(&cache
->uqc_group_deltas
);
1979 if (dmu_objset_projectquota_enabled(os
)) {
1981 while ((uqn
= avl_destroy_nodes(&cache
->uqc_project_deltas
,
1982 &cookie
)) != NULL
) {
1983 mutex_enter(&os
->os_userused_lock
);
1984 VERIFY0(zap_increment(os
, DMU_PROJECTUSED_OBJECT
,
1985 uqn
->uqn_id
, uqn
->uqn_delta
, tx
));
1986 mutex_exit(&os
->os_userused_lock
);
1987 kmem_free(uqn
, sizeof (*uqn
));
1989 avl_destroy(&cache
->uqc_project_deltas
);
1994 userquota_update_cache(avl_tree_t
*avl
, const char *id
, int64_t delta
)
1996 userquota_node_t
*uqn
;
1999 ASSERT(strlen(id
) < sizeof (uqn
->uqn_id
));
2001 * Use id directly for searching because uqn_id is the first field of
2002 * userquota_node_t and fields after uqn_id won't be accessed in
2005 uqn
= avl_find(avl
, (const void *)id
, &idx
);
2007 uqn
= kmem_zalloc(sizeof (*uqn
), KM_SLEEP
);
2008 strlcpy(uqn
->uqn_id
, id
, sizeof (uqn
->uqn_id
));
2009 avl_insert(avl
, uqn
, idx
);
2011 uqn
->uqn_delta
+= delta
;
2015 do_userquota_update(objset_t
*os
, userquota_cache_t
*cache
, uint64_t used
,
2016 uint64_t flags
, uint64_t user
, uint64_t group
, uint64_t project
,
2019 if (flags
& DNODE_FLAG_USERUSED_ACCOUNTED
) {
2020 int64_t delta
= DNODE_MIN_SIZE
+ used
;
2026 (void) snprintf(name
, sizeof (name
), "%llx", (longlong_t
)user
);
2027 userquota_update_cache(&cache
->uqc_user_deltas
, name
, delta
);
2029 (void) snprintf(name
, sizeof (name
), "%llx", (longlong_t
)group
);
2030 userquota_update_cache(&cache
->uqc_group_deltas
, name
, delta
);
2032 if (dmu_objset_projectquota_enabled(os
)) {
2033 (void) snprintf(name
, sizeof (name
), "%llx",
2034 (longlong_t
)project
);
2035 userquota_update_cache(&cache
->uqc_project_deltas
,
2042 do_userobjquota_update(objset_t
*os
, userquota_cache_t
*cache
, uint64_t flags
,
2043 uint64_t user
, uint64_t group
, uint64_t project
, boolean_t subtract
)
2045 if (flags
& DNODE_FLAG_USEROBJUSED_ACCOUNTED
) {
2046 char name
[20 + DMU_OBJACCT_PREFIX_LEN
];
2047 int delta
= subtract
? -1 : 1;
2049 (void) snprintf(name
, sizeof (name
), DMU_OBJACCT_PREFIX
"%llx",
2051 userquota_update_cache(&cache
->uqc_user_deltas
, name
, delta
);
2053 (void) snprintf(name
, sizeof (name
), DMU_OBJACCT_PREFIX
"%llx",
2055 userquota_update_cache(&cache
->uqc_group_deltas
, name
, delta
);
2057 if (dmu_objset_projectquota_enabled(os
)) {
2058 (void) snprintf(name
, sizeof (name
),
2059 DMU_OBJACCT_PREFIX
"%llx", (longlong_t
)project
);
2060 userquota_update_cache(&cache
->uqc_project_deltas
,
2066 typedef struct userquota_updates_arg
{
2068 int uua_sublist_idx
;
2070 } userquota_updates_arg_t
;
2073 userquota_updates_task(void *arg
)
2075 userquota_updates_arg_t
*uua
= arg
;
2076 objset_t
*os
= uua
->uua_os
;
2077 dmu_tx_t
*tx
= uua
->uua_tx
;
2079 userquota_cache_t cache
= { { 0 } };
2081 multilist_sublist_t
*list
= multilist_sublist_lock_idx(
2082 &os
->os_synced_dnodes
, uua
->uua_sublist_idx
);
2084 ASSERT(multilist_sublist_head(list
) == NULL
||
2085 dmu_objset_userused_enabled(os
));
2086 avl_create(&cache
.uqc_user_deltas
, userquota_compare
,
2087 sizeof (userquota_node_t
), offsetof(userquota_node_t
, uqn_node
));
2088 avl_create(&cache
.uqc_group_deltas
, userquota_compare
,
2089 sizeof (userquota_node_t
), offsetof(userquota_node_t
, uqn_node
));
2090 if (dmu_objset_projectquota_enabled(os
))
2091 avl_create(&cache
.uqc_project_deltas
, userquota_compare
,
2092 sizeof (userquota_node_t
), offsetof(userquota_node_t
,
2095 while ((dn
= multilist_sublist_head(list
)) != NULL
) {
2097 ASSERT(!DMU_OBJECT_IS_SPECIAL(dn
->dn_object
));
2098 ASSERT(dn
->dn_phys
->dn_type
== DMU_OT_NONE
||
2099 dn
->dn_phys
->dn_flags
&
2100 DNODE_FLAG_USERUSED_ACCOUNTED
);
2102 flags
= dn
->dn_id_flags
;
2104 if (flags
& DN_ID_OLD_EXIST
) {
2105 do_userquota_update(os
, &cache
, dn
->dn_oldused
,
2106 dn
->dn_oldflags
, dn
->dn_olduid
, dn
->dn_oldgid
,
2107 dn
->dn_oldprojid
, B_TRUE
);
2108 do_userobjquota_update(os
, &cache
, dn
->dn_oldflags
,
2109 dn
->dn_olduid
, dn
->dn_oldgid
,
2110 dn
->dn_oldprojid
, B_TRUE
);
2112 if (flags
& DN_ID_NEW_EXIST
) {
2113 do_userquota_update(os
, &cache
,
2114 DN_USED_BYTES(dn
->dn_phys
), dn
->dn_phys
->dn_flags
,
2115 dn
->dn_newuid
, dn
->dn_newgid
,
2116 dn
->dn_newprojid
, B_FALSE
);
2117 do_userobjquota_update(os
, &cache
,
2118 dn
->dn_phys
->dn_flags
, dn
->dn_newuid
, dn
->dn_newgid
,
2119 dn
->dn_newprojid
, B_FALSE
);
2122 mutex_enter(&dn
->dn_mtx
);
2124 dn
->dn_oldflags
= 0;
2125 if (dn
->dn_id_flags
& DN_ID_NEW_EXIST
) {
2126 dn
->dn_olduid
= dn
->dn_newuid
;
2127 dn
->dn_oldgid
= dn
->dn_newgid
;
2128 dn
->dn_oldprojid
= dn
->dn_newprojid
;
2129 dn
->dn_id_flags
|= DN_ID_OLD_EXIST
;
2130 if (dn
->dn_bonuslen
== 0)
2131 dn
->dn_id_flags
|= DN_ID_CHKED_SPILL
;
2133 dn
->dn_id_flags
|= DN_ID_CHKED_BONUS
;
2135 dn
->dn_id_flags
&= ~(DN_ID_NEW_EXIST
);
2136 mutex_exit(&dn
->dn_mtx
);
2138 multilist_sublist_remove(list
, dn
);
2139 dnode_rele(dn
, &os
->os_synced_dnodes
);
2141 do_userquota_cacheflush(os
, &cache
, tx
);
2142 multilist_sublist_unlock(list
);
2143 kmem_free(uua
, sizeof (*uua
));
2147 * Release dnode holds from dmu_objset_sync_dnodes(). When the dnode is being
2148 * synced (i.e. we have issued the zio's for blocks in the dnode), it can't be
2149 * evicted because the block containing the dnode can't be evicted until it is
2150 * written out. However, this hold is necessary to prevent the dnode_t from
2151 * being moved (via dnode_move()) while it's still referenced by
2152 * dbuf_dirty_record_t:dr_dnode. And dr_dnode is needed for
2153 * dirty_lightweight_leaf-type dirty records.
2155 * If we are doing user-object accounting, the dnode_rele() happens from
2156 * userquota_updates_task() instead.
2159 dnode_rele_task(void *arg
)
2161 userquota_updates_arg_t
*uua
= arg
;
2162 objset_t
*os
= uua
->uua_os
;
2164 multilist_sublist_t
*list
= multilist_sublist_lock_idx(
2165 &os
->os_synced_dnodes
, uua
->uua_sublist_idx
);
2168 while ((dn
= multilist_sublist_head(list
)) != NULL
) {
2169 multilist_sublist_remove(list
, dn
);
2170 dnode_rele(dn
, &os
->os_synced_dnodes
);
2172 multilist_sublist_unlock(list
);
2173 kmem_free(uua
, sizeof (*uua
));
2177 * Return TRUE if userquota updates are needed.
2180 dmu_objset_do_userquota_updates_prep(objset_t
*os
, dmu_tx_t
*tx
)
2182 if (!dmu_objset_userused_enabled(os
))
2186 * If this is a raw receive just return and handle accounting
2187 * later when we have the keys loaded. We also don't do user
2188 * accounting during claiming since the datasets are not owned
2189 * for the duration of claiming and this txg should only be
2190 * used for recovery.
2192 if (os
->os_encrypted
&& dmu_objset_is_receiving(os
))
2195 if (tx
->tx_txg
<= os
->os_spa
->spa_claim_max_txg
)
2198 /* Allocate the user/group/project used objects if necessary. */
2199 if (DMU_USERUSED_DNODE(os
)->dn_type
== DMU_OT_NONE
) {
2200 VERIFY0(zap_create_claim(os
,
2201 DMU_USERUSED_OBJECT
,
2202 DMU_OT_USERGROUP_USED
, DMU_OT_NONE
, 0, tx
));
2203 VERIFY0(zap_create_claim(os
,
2204 DMU_GROUPUSED_OBJECT
,
2205 DMU_OT_USERGROUP_USED
, DMU_OT_NONE
, 0, tx
));
2208 if (dmu_objset_projectquota_enabled(os
) &&
2209 DMU_PROJECTUSED_DNODE(os
)->dn_type
== DMU_OT_NONE
) {
2210 VERIFY0(zap_create_claim(os
, DMU_PROJECTUSED_OBJECT
,
2211 DMU_OT_USERGROUP_USED
, DMU_OT_NONE
, 0, tx
));
2217 * Dispatch taskq tasks to dp_sync_taskq to update the user accounting, and
2218 * also release the holds on the dnodes from dmu_objset_sync_dnodes().
2219 * The caller must taskq_wait(dp_sync_taskq).
2222 dmu_objset_sync_done(objset_t
*os
, dmu_tx_t
*tx
)
2224 boolean_t need_userquota
= dmu_objset_do_userquota_updates_prep(os
, tx
);
2226 int num_sublists
= multilist_get_num_sublists(&os
->os_synced_dnodes
);
2227 for (int i
= 0; i
< num_sublists
; i
++) {
2228 userquota_updates_arg_t
*uua
=
2229 kmem_alloc(sizeof (*uua
), KM_SLEEP
);
2231 uua
->uua_sublist_idx
= i
;
2235 * If we don't need to update userquotas, use
2236 * dnode_rele_task() to call dnode_rele()
2238 (void) taskq_dispatch(dmu_objset_pool(os
)->dp_sync_taskq
,
2239 need_userquota
? userquota_updates_task
: dnode_rele_task
,
2241 /* callback frees uua */
2247 * Returns a pointer to data to find uid/gid from
2249 * If a dirty record for transaction group that is syncing can't
2250 * be found then NULL is returned. In the NULL case it is assumed
2251 * the uid/gid aren't changing.
2254 dmu_objset_userquota_find_data(dmu_buf_impl_t
*db
, dmu_tx_t
*tx
)
2256 dbuf_dirty_record_t
*dr
;
2259 if (db
->db_dirtycnt
== 0)
2260 return (db
->db
.db_data
); /* Nothing is changing */
2262 dr
= dbuf_find_dirty_eq(db
, tx
->tx_txg
);
2267 if (dr
->dr_dnode
->dn_bonuslen
== 0 &&
2268 dr
->dr_dbuf
->db_blkid
== DMU_SPILL_BLKID
)
2269 data
= dr
->dt
.dl
.dr_data
->b_data
;
2271 data
= dr
->dt
.dl
.dr_data
;
2278 dmu_objset_userquota_get_ids(dnode_t
*dn
, boolean_t before
, dmu_tx_t
*tx
)
2280 objset_t
*os
= dn
->dn_objset
;
2282 dmu_buf_impl_t
*db
= NULL
;
2283 int flags
= dn
->dn_id_flags
;
2285 boolean_t have_spill
= B_FALSE
;
2287 if (!dmu_objset_userused_enabled(dn
->dn_objset
))
2291 * Raw receives introduce a problem with user accounting. Raw
2292 * receives cannot update the user accounting info because the
2293 * user ids and the sizes are encrypted. To guarantee that we
2294 * never end up with bad user accounting, we simply disable it
2295 * during raw receives. We also disable this for normal receives
2296 * so that an incremental raw receive may be done on top of an
2297 * existing non-raw receive.
2299 if (os
->os_encrypted
&& dmu_objset_is_receiving(os
))
2302 if (before
&& (flags
& (DN_ID_CHKED_BONUS
|DN_ID_OLD_EXIST
|
2303 DN_ID_CHKED_SPILL
)))
2306 if (before
&& dn
->dn_bonuslen
!= 0)
2307 data
= DN_BONUS(dn
->dn_phys
);
2308 else if (!before
&& dn
->dn_bonuslen
!= 0) {
2311 mutex_enter(&db
->db_mtx
);
2312 data
= dmu_objset_userquota_find_data(db
, tx
);
2314 data
= DN_BONUS(dn
->dn_phys
);
2316 } else if (dn
->dn_bonuslen
== 0 && dn
->dn_bonustype
== DMU_OT_SA
) {
2319 if (RW_WRITE_HELD(&dn
->dn_struct_rwlock
))
2320 rf
|= DB_RF_HAVESTRUCT
;
2321 error
= dmu_spill_hold_by_dnode(dn
,
2322 rf
| DB_RF_MUST_SUCCEED
,
2323 FTAG
, (dmu_buf_t
**)&db
);
2325 mutex_enter(&db
->db_mtx
);
2326 data
= (before
) ? db
->db
.db_data
:
2327 dmu_objset_userquota_find_data(db
, tx
);
2328 have_spill
= B_TRUE
;
2330 mutex_enter(&dn
->dn_mtx
);
2331 dn
->dn_id_flags
|= DN_ID_CHKED_BONUS
;
2332 mutex_exit(&dn
->dn_mtx
);
2337 * Must always call the callback in case the object
2338 * type has changed and that type isn't an object type to track
2340 zfs_file_info_t zfi
;
2341 error
= file_cbs
[os
->os_phys
->os_type
](dn
->dn_bonustype
, data
, &zfi
);
2345 dn
->dn_olduid
= zfi
.zfi_user
;
2346 dn
->dn_oldgid
= zfi
.zfi_group
;
2347 dn
->dn_oldprojid
= zfi
.zfi_project
;
2349 dn
->dn_newuid
= zfi
.zfi_user
;
2350 dn
->dn_newgid
= zfi
.zfi_group
;
2351 dn
->dn_newprojid
= zfi
.zfi_project
;
2355 * Preserve existing uid/gid when the callback can't determine
2356 * what the new uid/gid are and the callback returned EEXIST.
2357 * The EEXIST error tells us to just use the existing uid/gid.
2358 * If we don't know what the old values are then just assign
2359 * them to 0, since that is a new file being created.
2361 if (!before
&& data
== NULL
&& error
== EEXIST
) {
2362 if (flags
& DN_ID_OLD_EXIST
) {
2363 dn
->dn_newuid
= dn
->dn_olduid
;
2364 dn
->dn_newgid
= dn
->dn_oldgid
;
2365 dn
->dn_newprojid
= dn
->dn_oldprojid
;
2369 dn
->dn_newprojid
= ZFS_DEFAULT_PROJID
;
2375 mutex_exit(&db
->db_mtx
);
2377 mutex_enter(&dn
->dn_mtx
);
2378 if (error
== 0 && before
)
2379 dn
->dn_id_flags
|= DN_ID_OLD_EXIST
;
2380 if (error
== 0 && !before
)
2381 dn
->dn_id_flags
|= DN_ID_NEW_EXIST
;
2384 dn
->dn_id_flags
|= DN_ID_CHKED_SPILL
;
2386 dn
->dn_id_flags
|= DN_ID_CHKED_BONUS
;
2388 mutex_exit(&dn
->dn_mtx
);
2390 dmu_buf_rele((dmu_buf_t
*)db
, FTAG
);
2394 dmu_objset_userspace_present(objset_t
*os
)
2396 return (os
->os_phys
->os_flags
&
2397 OBJSET_FLAG_USERACCOUNTING_COMPLETE
);
2401 dmu_objset_userobjspace_present(objset_t
*os
)
2403 return (os
->os_phys
->os_flags
&
2404 OBJSET_FLAG_USEROBJACCOUNTING_COMPLETE
);
2408 dmu_objset_projectquota_present(objset_t
*os
)
2410 return (os
->os_phys
->os_flags
&
2411 OBJSET_FLAG_PROJECTQUOTA_COMPLETE
);
2415 dmu_objset_space_upgrade(objset_t
*os
)
2421 * We simply need to mark every object dirty, so that it will be
2422 * synced out and now accounted. If this is called
2423 * concurrently, or if we already did some work before crashing,
2424 * that's fine, since we track each object's accounted state
2428 for (obj
= 0; err
== 0; err
= dmu_object_next(os
, &obj
, FALSE
, 0)) {
2433 mutex_enter(&os
->os_upgrade_lock
);
2434 if (os
->os_upgrade_exit
)
2435 err
= SET_ERROR(EINTR
);
2436 mutex_exit(&os
->os_upgrade_lock
);
2440 if (issig(JUSTLOOKING
) && issig(FORREAL
))
2441 return (SET_ERROR(EINTR
));
2443 objerr
= dmu_bonus_hold(os
, obj
, FTAG
, &db
);
2446 tx
= dmu_tx_create(os
);
2447 dmu_tx_hold_bonus(tx
, obj
);
2448 objerr
= dmu_tx_assign(tx
, TXG_WAIT
);
2450 dmu_buf_rele(db
, FTAG
);
2454 dmu_buf_will_dirty(db
, tx
);
2455 dmu_buf_rele(db
, FTAG
);
2462 dmu_objset_userspace_upgrade_cb(objset_t
*os
)
2466 if (dmu_objset_userspace_present(os
))
2468 if (dmu_objset_is_snapshot(os
))
2469 return (SET_ERROR(EINVAL
));
2470 if (!dmu_objset_userused_enabled(os
))
2471 return (SET_ERROR(ENOTSUP
));
2473 err
= dmu_objset_space_upgrade(os
);
2477 os
->os_flags
|= OBJSET_FLAG_USERACCOUNTING_COMPLETE
;
2478 txg_wait_synced(dmu_objset_pool(os
), 0);
2483 dmu_objset_userspace_upgrade(objset_t
*os
)
2485 dmu_objset_upgrade(os
, dmu_objset_userspace_upgrade_cb
);
2489 dmu_objset_id_quota_upgrade_cb(objset_t
*os
)
2493 if (dmu_objset_userobjspace_present(os
) &&
2494 dmu_objset_projectquota_present(os
))
2496 if (dmu_objset_is_snapshot(os
))
2497 return (SET_ERROR(EINVAL
));
2498 if (!dmu_objset_userused_enabled(os
))
2499 return (SET_ERROR(ENOTSUP
));
2500 if (!dmu_objset_projectquota_enabled(os
) &&
2501 dmu_objset_userobjspace_present(os
))
2502 return (SET_ERROR(ENOTSUP
));
2504 if (dmu_objset_userobjused_enabled(os
))
2505 dmu_objset_ds(os
)->ds_feature_activation
[
2506 SPA_FEATURE_USEROBJ_ACCOUNTING
] = (void *)B_TRUE
;
2507 if (dmu_objset_projectquota_enabled(os
))
2508 dmu_objset_ds(os
)->ds_feature_activation
[
2509 SPA_FEATURE_PROJECT_QUOTA
] = (void *)B_TRUE
;
2511 err
= dmu_objset_space_upgrade(os
);
2515 os
->os_flags
|= OBJSET_FLAG_USERACCOUNTING_COMPLETE
;
2516 if (dmu_objset_userobjused_enabled(os
))
2517 os
->os_flags
|= OBJSET_FLAG_USEROBJACCOUNTING_COMPLETE
;
2518 if (dmu_objset_projectquota_enabled(os
))
2519 os
->os_flags
|= OBJSET_FLAG_PROJECTQUOTA_COMPLETE
;
2521 txg_wait_synced(dmu_objset_pool(os
), 0);
2526 dmu_objset_id_quota_upgrade(objset_t
*os
)
2528 dmu_objset_upgrade(os
, dmu_objset_id_quota_upgrade_cb
);
2532 dmu_objset_userobjspace_upgradable(objset_t
*os
)
2534 return (dmu_objset_type(os
) == DMU_OST_ZFS
&&
2535 !dmu_objset_is_snapshot(os
) &&
2536 dmu_objset_userobjused_enabled(os
) &&
2537 !dmu_objset_userobjspace_present(os
) &&
2538 spa_writeable(dmu_objset_spa(os
)));
2542 dmu_objset_projectquota_upgradable(objset_t
*os
)
2544 return (dmu_objset_type(os
) == DMU_OST_ZFS
&&
2545 !dmu_objset_is_snapshot(os
) &&
2546 dmu_objset_projectquota_enabled(os
) &&
2547 !dmu_objset_projectquota_present(os
) &&
2548 spa_writeable(dmu_objset_spa(os
)));
2552 dmu_objset_space(objset_t
*os
, uint64_t *refdbytesp
, uint64_t *availbytesp
,
2553 uint64_t *usedobjsp
, uint64_t *availobjsp
)
2555 dsl_dataset_space(os
->os_dsl_dataset
, refdbytesp
, availbytesp
,
2556 usedobjsp
, availobjsp
);
2560 dmu_objset_fsid_guid(objset_t
*os
)
2562 return (dsl_dataset_fsid_guid(os
->os_dsl_dataset
));
2566 dmu_objset_fast_stat(objset_t
*os
, dmu_objset_stats_t
*stat
)
2568 stat
->dds_type
= os
->os_phys
->os_type
;
2569 if (os
->os_dsl_dataset
)
2570 dsl_dataset_fast_stat(os
->os_dsl_dataset
, stat
);
2574 dmu_objset_stats(objset_t
*os
, nvlist_t
*nv
)
2576 ASSERT(os
->os_dsl_dataset
||
2577 os
->os_phys
->os_type
== DMU_OST_META
);
2579 if (os
->os_dsl_dataset
!= NULL
)
2580 dsl_dataset_stats(os
->os_dsl_dataset
, nv
);
2582 dsl_prop_nvlist_add_uint64(nv
, ZFS_PROP_TYPE
,
2583 os
->os_phys
->os_type
);
2584 dsl_prop_nvlist_add_uint64(nv
, ZFS_PROP_USERACCOUNTING
,
2585 dmu_objset_userspace_present(os
));
2589 dmu_objset_is_snapshot(objset_t
*os
)
2591 if (os
->os_dsl_dataset
!= NULL
)
2592 return (os
->os_dsl_dataset
->ds_is_snapshot
);
2598 dmu_snapshot_realname(objset_t
*os
, const char *name
, char *real
, int maxlen
,
2599 boolean_t
*conflict
)
2601 dsl_dataset_t
*ds
= os
->os_dsl_dataset
;
2604 if (dsl_dataset_phys(ds
)->ds_snapnames_zapobj
== 0)
2605 return (SET_ERROR(ENOENT
));
2607 return (zap_lookup_norm(ds
->ds_dir
->dd_pool
->dp_meta_objset
,
2608 dsl_dataset_phys(ds
)->ds_snapnames_zapobj
, name
, 8, 1, &ignored
,
2609 MT_NORMALIZE
, real
, maxlen
, conflict
));
2613 dmu_snapshot_list_next(objset_t
*os
, int namelen
, char *name
,
2614 uint64_t *idp
, uint64_t *offp
, boolean_t
*case_conflict
)
2616 dsl_dataset_t
*ds
= os
->os_dsl_dataset
;
2617 zap_cursor_t cursor
;
2618 zap_attribute_t attr
;
2620 ASSERT(dsl_pool_config_held(dmu_objset_pool(os
)));
2622 if (dsl_dataset_phys(ds
)->ds_snapnames_zapobj
== 0)
2623 return (SET_ERROR(ENOENT
));
2625 zap_cursor_init_serialized(&cursor
,
2626 ds
->ds_dir
->dd_pool
->dp_meta_objset
,
2627 dsl_dataset_phys(ds
)->ds_snapnames_zapobj
, *offp
);
2629 if (zap_cursor_retrieve(&cursor
, &attr
) != 0) {
2630 zap_cursor_fini(&cursor
);
2631 return (SET_ERROR(ENOENT
));
2634 if (strlen(attr
.za_name
) + 1 > namelen
) {
2635 zap_cursor_fini(&cursor
);
2636 return (SET_ERROR(ENAMETOOLONG
));
2639 (void) strlcpy(name
, attr
.za_name
, namelen
);
2641 *idp
= attr
.za_first_integer
;
2643 *case_conflict
= attr
.za_normalization_conflict
;
2644 zap_cursor_advance(&cursor
);
2645 *offp
= zap_cursor_serialize(&cursor
);
2646 zap_cursor_fini(&cursor
);
2652 dmu_snapshot_lookup(objset_t
*os
, const char *name
, uint64_t *value
)
2654 return (dsl_dataset_snap_lookup(os
->os_dsl_dataset
, name
, value
));
2658 dmu_dir_list_next(objset_t
*os
, int namelen
, char *name
,
2659 uint64_t *idp
, uint64_t *offp
)
2661 dsl_dir_t
*dd
= os
->os_dsl_dataset
->ds_dir
;
2662 zap_cursor_t cursor
;
2663 zap_attribute_t attr
;
2665 /* there is no next dir on a snapshot! */
2666 if (os
->os_dsl_dataset
->ds_object
!=
2667 dsl_dir_phys(dd
)->dd_head_dataset_obj
)
2668 return (SET_ERROR(ENOENT
));
2670 zap_cursor_init_serialized(&cursor
,
2671 dd
->dd_pool
->dp_meta_objset
,
2672 dsl_dir_phys(dd
)->dd_child_dir_zapobj
, *offp
);
2674 if (zap_cursor_retrieve(&cursor
, &attr
) != 0) {
2675 zap_cursor_fini(&cursor
);
2676 return (SET_ERROR(ENOENT
));
2679 if (strlen(attr
.za_name
) + 1 > namelen
) {
2680 zap_cursor_fini(&cursor
);
2681 return (SET_ERROR(ENAMETOOLONG
));
2684 (void) strlcpy(name
, attr
.za_name
, namelen
);
2686 *idp
= attr
.za_first_integer
;
2687 zap_cursor_advance(&cursor
);
2688 *offp
= zap_cursor_serialize(&cursor
);
2689 zap_cursor_fini(&cursor
);
2694 typedef struct dmu_objset_find_ctx
{
2698 char *dc_ddname
; /* last component of ddobj's name */
2699 int (*dc_func
)(dsl_pool_t
*, dsl_dataset_t
*, void *);
2702 kmutex_t
*dc_error_lock
;
2704 } dmu_objset_find_ctx_t
;
2707 dmu_objset_find_dp_impl(dmu_objset_find_ctx_t
*dcp
)
2709 dsl_pool_t
*dp
= dcp
->dc_dp
;
2713 zap_attribute_t
*attr
;
2717 /* don't process if there already was an error */
2718 if (*dcp
->dc_error
!= 0)
2722 * Note: passing the name (dc_ddname) here is optional, but it
2723 * improves performance because we don't need to call
2724 * zap_value_search() to determine the name.
2726 err
= dsl_dir_hold_obj(dp
, dcp
->dc_ddobj
, dcp
->dc_ddname
, FTAG
, &dd
);
2730 /* Don't visit hidden ($MOS & $ORIGIN) objsets. */
2731 if (dd
->dd_myname
[0] == '$') {
2732 dsl_dir_rele(dd
, FTAG
);
2736 thisobj
= dsl_dir_phys(dd
)->dd_head_dataset_obj
;
2737 attr
= kmem_alloc(sizeof (zap_attribute_t
), KM_SLEEP
);
2740 * Iterate over all children.
2742 if (dcp
->dc_flags
& DS_FIND_CHILDREN
) {
2743 for (zap_cursor_init(&zc
, dp
->dp_meta_objset
,
2744 dsl_dir_phys(dd
)->dd_child_dir_zapobj
);
2745 zap_cursor_retrieve(&zc
, attr
) == 0;
2746 (void) zap_cursor_advance(&zc
)) {
2747 ASSERT3U(attr
->za_integer_length
, ==,
2749 ASSERT3U(attr
->za_num_integers
, ==, 1);
2751 dmu_objset_find_ctx_t
*child_dcp
=
2752 kmem_alloc(sizeof (*child_dcp
), KM_SLEEP
);
2754 child_dcp
->dc_ddobj
= attr
->za_first_integer
;
2755 child_dcp
->dc_ddname
= spa_strdup(attr
->za_name
);
2756 if (dcp
->dc_tq
!= NULL
)
2757 (void) taskq_dispatch(dcp
->dc_tq
,
2758 dmu_objset_find_dp_cb
, child_dcp
, TQ_SLEEP
);
2760 dmu_objset_find_dp_impl(child_dcp
);
2762 zap_cursor_fini(&zc
);
2766 * Iterate over all snapshots.
2768 if (dcp
->dc_flags
& DS_FIND_SNAPSHOTS
) {
2770 err
= dsl_dataset_hold_obj(dp
, thisobj
, FTAG
, &ds
);
2775 snapobj
= dsl_dataset_phys(ds
)->ds_snapnames_zapobj
;
2776 dsl_dataset_rele(ds
, FTAG
);
2778 for (zap_cursor_init(&zc
, dp
->dp_meta_objset
, snapobj
);
2779 zap_cursor_retrieve(&zc
, attr
) == 0;
2780 (void) zap_cursor_advance(&zc
)) {
2781 ASSERT3U(attr
->za_integer_length
, ==,
2783 ASSERT3U(attr
->za_num_integers
, ==, 1);
2785 err
= dsl_dataset_hold_obj(dp
,
2786 attr
->za_first_integer
, FTAG
, &ds
);
2789 err
= dcp
->dc_func(dp
, ds
, dcp
->dc_arg
);
2790 dsl_dataset_rele(ds
, FTAG
);
2794 zap_cursor_fini(&zc
);
2798 kmem_free(attr
, sizeof (zap_attribute_t
));
2801 dsl_dir_rele(dd
, FTAG
);
2808 err
= dsl_dataset_hold_obj(dp
, thisobj
, FTAG
, &ds
);
2811 * Note: we hold the dir while calling dsl_dataset_hold_obj() so
2812 * that the dir will remain cached, and we won't have to re-instantiate
2813 * it (which could be expensive due to finding its name via
2814 * zap_value_search()).
2816 dsl_dir_rele(dd
, FTAG
);
2819 err
= dcp
->dc_func(dp
, ds
, dcp
->dc_arg
);
2820 dsl_dataset_rele(ds
, FTAG
);
2824 mutex_enter(dcp
->dc_error_lock
);
2825 /* only keep first error */
2826 if (*dcp
->dc_error
== 0)
2827 *dcp
->dc_error
= err
;
2828 mutex_exit(dcp
->dc_error_lock
);
2831 if (dcp
->dc_ddname
!= NULL
)
2832 spa_strfree(dcp
->dc_ddname
);
2833 kmem_free(dcp
, sizeof (*dcp
));
2837 dmu_objset_find_dp_cb(void *arg
)
2839 dmu_objset_find_ctx_t
*dcp
= arg
;
2840 dsl_pool_t
*dp
= dcp
->dc_dp
;
2843 * We need to get a pool_config_lock here, as there are several
2844 * assert(pool_config_held) down the stack. Getting a lock via
2845 * dsl_pool_config_enter is risky, as it might be stalled by a
2846 * pending writer. This would deadlock, as the write lock can
2847 * only be granted when our parent thread gives up the lock.
2848 * The _prio interface gives us priority over a pending writer.
2850 dsl_pool_config_enter_prio(dp
, FTAG
);
2852 dmu_objset_find_dp_impl(dcp
);
2854 dsl_pool_config_exit(dp
, FTAG
);
2858 * Find objsets under and including ddobj, call func(ds) on each.
2859 * The order for the enumeration is completely undefined.
2860 * func is called with dsl_pool_config held.
2863 dmu_objset_find_dp(dsl_pool_t
*dp
, uint64_t ddobj
,
2864 int func(dsl_pool_t
*, dsl_dataset_t
*, void *), void *arg
, int flags
)
2869 dmu_objset_find_ctx_t
*dcp
;
2872 mutex_init(&err_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
2873 dcp
= kmem_alloc(sizeof (*dcp
), KM_SLEEP
);
2876 dcp
->dc_ddobj
= ddobj
;
2877 dcp
->dc_ddname
= NULL
;
2878 dcp
->dc_func
= func
;
2880 dcp
->dc_flags
= flags
;
2881 dcp
->dc_error_lock
= &err_lock
;
2882 dcp
->dc_error
= &error
;
2884 if ((flags
& DS_FIND_SERIALIZE
) || dsl_pool_config_held_writer(dp
)) {
2886 * In case a write lock is held we can't make use of
2887 * parallelism, as down the stack of the worker threads
2888 * the lock is asserted via dsl_pool_config_held.
2889 * In case of a read lock this is solved by getting a read
2890 * lock in each worker thread, which isn't possible in case
2891 * of a writer lock. So we fall back to the synchronous path
2893 * In the future it might be possible to get some magic into
2894 * dsl_pool_config_held in a way that it returns true for
2895 * the worker threads so that a single lock held from this
2896 * thread suffices. For now, stay single threaded.
2898 dmu_objset_find_dp_impl(dcp
);
2899 mutex_destroy(&err_lock
);
2904 ntasks
= dmu_find_threads
;
2906 ntasks
= vdev_count_leaves(dp
->dp_spa
) * 4;
2907 tq
= taskq_create("dmu_objset_find", ntasks
, maxclsyspri
, ntasks
,
2910 kmem_free(dcp
, sizeof (*dcp
));
2911 mutex_destroy(&err_lock
);
2913 return (SET_ERROR(ENOMEM
));
2917 /* dcp will be freed by task */
2918 (void) taskq_dispatch(tq
, dmu_objset_find_dp_cb
, dcp
, TQ_SLEEP
);
2921 * PORTING: this code relies on the property of taskq_wait to wait
2922 * until no more tasks are queued and no more tasks are active. As
2923 * we always queue new tasks from within other tasks, task_wait
2924 * reliably waits for the full recursion to finish, even though we
2925 * enqueue new tasks after taskq_wait has been called.
2926 * On platforms other than illumos, taskq_wait may not have this
2931 mutex_destroy(&err_lock
);
2937 * Find all objsets under name, and for each, call 'func(child_name, arg)'.
2938 * The dp_config_rwlock must not be held when this is called, and it
2939 * will not be held when the callback is called.
2940 * Therefore this function should only be used when the pool is not changing
2941 * (e.g. in syncing context), or the callback can deal with the possible races.
2944 dmu_objset_find_impl(spa_t
*spa
, const char *name
,
2945 int func(const char *, void *), void *arg
, int flags
)
2948 dsl_pool_t
*dp
= spa_get_dsl(spa
);
2951 zap_attribute_t
*attr
;
2956 dsl_pool_config_enter(dp
, FTAG
);
2958 err
= dsl_dir_hold(dp
, name
, FTAG
, &dd
, NULL
);
2960 dsl_pool_config_exit(dp
, FTAG
);
2964 /* Don't visit hidden ($MOS & $ORIGIN) objsets. */
2965 if (dd
->dd_myname
[0] == '$') {
2966 dsl_dir_rele(dd
, FTAG
);
2967 dsl_pool_config_exit(dp
, FTAG
);
2971 thisobj
= dsl_dir_phys(dd
)->dd_head_dataset_obj
;
2972 attr
= kmem_alloc(sizeof (zap_attribute_t
), KM_SLEEP
);
2975 * Iterate over all children.
2977 if (flags
& DS_FIND_CHILDREN
) {
2978 for (zap_cursor_init(&zc
, dp
->dp_meta_objset
,
2979 dsl_dir_phys(dd
)->dd_child_dir_zapobj
);
2980 zap_cursor_retrieve(&zc
, attr
) == 0;
2981 (void) zap_cursor_advance(&zc
)) {
2982 ASSERT3U(attr
->za_integer_length
, ==,
2984 ASSERT3U(attr
->za_num_integers
, ==, 1);
2986 child
= kmem_asprintf("%s/%s", name
, attr
->za_name
);
2987 dsl_pool_config_exit(dp
, FTAG
);
2988 err
= dmu_objset_find_impl(spa
, child
,
2990 dsl_pool_config_enter(dp
, FTAG
);
2991 kmem_strfree(child
);
2995 zap_cursor_fini(&zc
);
2998 dsl_dir_rele(dd
, FTAG
);
2999 dsl_pool_config_exit(dp
, FTAG
);
3000 kmem_free(attr
, sizeof (zap_attribute_t
));
3006 * Iterate over all snapshots.
3008 if (flags
& DS_FIND_SNAPSHOTS
) {
3009 err
= dsl_dataset_hold_obj(dp
, thisobj
, FTAG
, &ds
);
3014 snapobj
= dsl_dataset_phys(ds
)->ds_snapnames_zapobj
;
3015 dsl_dataset_rele(ds
, FTAG
);
3017 for (zap_cursor_init(&zc
, dp
->dp_meta_objset
, snapobj
);
3018 zap_cursor_retrieve(&zc
, attr
) == 0;
3019 (void) zap_cursor_advance(&zc
)) {
3020 ASSERT3U(attr
->za_integer_length
, ==,
3022 ASSERT3U(attr
->za_num_integers
, ==, 1);
3024 child
= kmem_asprintf("%s@%s",
3025 name
, attr
->za_name
);
3026 dsl_pool_config_exit(dp
, FTAG
);
3027 err
= func(child
, arg
);
3028 dsl_pool_config_enter(dp
, FTAG
);
3029 kmem_strfree(child
);
3033 zap_cursor_fini(&zc
);
3037 dsl_dir_rele(dd
, FTAG
);
3038 kmem_free(attr
, sizeof (zap_attribute_t
));
3039 dsl_pool_config_exit(dp
, FTAG
);
3044 /* Apply to self. */
3045 return (func(name
, arg
));
3049 * See comment above dmu_objset_find_impl().
3052 dmu_objset_find(const char *name
, int func(const char *, void *), void *arg
,
3058 error
= spa_open(name
, &spa
, FTAG
);
3061 error
= dmu_objset_find_impl(spa
, name
, func
, arg
, flags
);
3062 spa_close(spa
, FTAG
);
3067 dmu_objset_incompatible_encryption_version(objset_t
*os
)
3069 return (dsl_dir_incompatible_encryption_version(
3070 os
->os_dsl_dataset
->ds_dir
));
3074 dmu_objset_set_user(objset_t
*os
, void *user_ptr
)
3076 ASSERT(MUTEX_HELD(&os
->os_user_ptr_lock
));
3077 os
->os_user_ptr
= user_ptr
;
3081 dmu_objset_get_user(objset_t
*os
)
3083 ASSERT(MUTEX_HELD(&os
->os_user_ptr_lock
));
3084 return (os
->os_user_ptr
);
3088 * Determine name of filesystem, given name of snapshot.
3089 * buf must be at least ZFS_MAX_DATASET_NAME_LEN bytes
3092 dmu_fsname(const char *snapname
, char *buf
)
3094 char *atp
= strchr(snapname
, '@');
3096 return (SET_ERROR(EINVAL
));
3097 if (atp
- snapname
>= ZFS_MAX_DATASET_NAME_LEN
)
3098 return (SET_ERROR(ENAMETOOLONG
));
3099 (void) strlcpy(buf
, snapname
, atp
- snapname
+ 1);
3104 * Call when we think we're going to write/free space in open context
3105 * to track the amount of dirty data in the open txg, which is also the
3106 * amount of memory that can not be evicted until this txg syncs.
3108 * Note that there are two conditions where this can be called from
3111 * [1] When we just created the dataset, in which case we go on with
3112 * updating any accounting of dirty data as usual.
3113 * [2] When we are dirtying MOS data, in which case we only update the
3114 * pool's accounting of dirty data.
3117 dmu_objset_willuse_space(objset_t
*os
, int64_t space
, dmu_tx_t
*tx
)
3119 dsl_dataset_t
*ds
= os
->os_dsl_dataset
;
3120 int64_t aspace
= spa_get_worst_case_asize(os
->os_spa
, space
);
3123 dsl_dir_willuse_space(ds
->ds_dir
, aspace
, tx
);
3126 dsl_pool_dirty_space(dmu_tx_pool(tx
), space
, tx
);
3129 #if defined(_KERNEL)
3130 EXPORT_SYMBOL(dmu_objset_zil
);
3131 EXPORT_SYMBOL(dmu_objset_pool
);
3132 EXPORT_SYMBOL(dmu_objset_ds
);
3133 EXPORT_SYMBOL(dmu_objset_type
);
3134 EXPORT_SYMBOL(dmu_objset_name
);
3135 EXPORT_SYMBOL(dmu_objset_hold
);
3136 EXPORT_SYMBOL(dmu_objset_hold_flags
);
3137 EXPORT_SYMBOL(dmu_objset_own
);
3138 EXPORT_SYMBOL(dmu_objset_rele
);
3139 EXPORT_SYMBOL(dmu_objset_rele_flags
);
3140 EXPORT_SYMBOL(dmu_objset_disown
);
3141 EXPORT_SYMBOL(dmu_objset_from_ds
);
3142 EXPORT_SYMBOL(dmu_objset_create
);
3143 EXPORT_SYMBOL(dmu_objset_clone
);
3144 EXPORT_SYMBOL(dmu_objset_stats
);
3145 EXPORT_SYMBOL(dmu_objset_fast_stat
);
3146 EXPORT_SYMBOL(dmu_objset_spa
);
3147 EXPORT_SYMBOL(dmu_objset_space
);
3148 EXPORT_SYMBOL(dmu_objset_fsid_guid
);
3149 EXPORT_SYMBOL(dmu_objset_find
);
3150 EXPORT_SYMBOL(dmu_objset_byteswap
);
3151 EXPORT_SYMBOL(dmu_objset_evict_dbufs
);
3152 EXPORT_SYMBOL(dmu_objset_snap_cmtime
);
3153 EXPORT_SYMBOL(dmu_objset_dnodesize
);
3155 EXPORT_SYMBOL(dmu_objset_sync
);
3156 EXPORT_SYMBOL(dmu_objset_is_dirty
);
3157 EXPORT_SYMBOL(dmu_objset_create_impl_dnstats
);
3158 EXPORT_SYMBOL(dmu_objset_create_impl
);
3159 EXPORT_SYMBOL(dmu_objset_open_impl
);
3160 EXPORT_SYMBOL(dmu_objset_evict
);
3161 EXPORT_SYMBOL(dmu_objset_register_type
);
3162 EXPORT_SYMBOL(dmu_objset_sync_done
);
3163 EXPORT_SYMBOL(dmu_objset_userquota_get_ids
);
3164 EXPORT_SYMBOL(dmu_objset_userused_enabled
);
3165 EXPORT_SYMBOL(dmu_objset_userspace_upgrade
);
3166 EXPORT_SYMBOL(dmu_objset_userspace_present
);
3167 EXPORT_SYMBOL(dmu_objset_userobjused_enabled
);
3168 EXPORT_SYMBOL(dmu_objset_userobjspace_upgradable
);
3169 EXPORT_SYMBOL(dmu_objset_userobjspace_present
);
3170 EXPORT_SYMBOL(dmu_objset_projectquota_enabled
);
3171 EXPORT_SYMBOL(dmu_objset_projectquota_present
);
3172 EXPORT_SYMBOL(dmu_objset_projectquota_upgradable
);
3173 EXPORT_SYMBOL(dmu_objset_id_quota_upgrade
);