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 http://www.opensolaris.org/os/licensing.
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]
22 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
25 #include <sys/zfs_context.h>
29 #include <sys/refcount.h>
30 #include <sys/nvpair.h>
32 #include <sys/kidmap.h>
34 #include <sys/zfs_vfsops.h>
35 #include <sys/zfs_znode.h>
37 #include <sys/zfs_fuid.h>
40 * FUID Domain table(s).
42 * The FUID table is stored as a packed nvlist of an array
43 * of nvlists which contain an index, domain string and offset
45 * During file system initialization the nvlist(s) are read and
46 * two AVL trees are created. One tree is keyed by the index number
47 * and the other by the domain string. Nodes are never removed from
48 * trees, but new entries may be added. If a new entry is added then
49 * the zfsvfs->z_fuid_dirty flag is set to true and the caller will then
50 * be responsible for calling zfs_fuid_sync() to sync the changes to disk.
54 #define FUID_IDX "fuid_idx"
55 #define FUID_DOMAIN "fuid_domain"
56 #define FUID_OFFSET "fuid_offset"
57 #define FUID_NVP_ARRAY "fuid_nvlist"
59 typedef struct fuid_domain
{
66 static char *nulldomain
= "";
69 * Compare two indexes.
72 idx_compare(const void *arg1
, const void *arg2
)
74 const fuid_domain_t
*node1
= (const fuid_domain_t
*)arg1
;
75 const fuid_domain_t
*node2
= (const fuid_domain_t
*)arg2
;
77 return (AVL_CMP(node1
->f_idx
, node2
->f_idx
));
81 * Compare two domain strings.
84 domain_compare(const void *arg1
, const void *arg2
)
86 const fuid_domain_t
*node1
= (const fuid_domain_t
*)arg1
;
87 const fuid_domain_t
*node2
= (const fuid_domain_t
*)arg2
;
90 val
= strcmp(node1
->f_ksid
->kd_name
, node2
->f_ksid
->kd_name
);
92 return (AVL_ISIGN(val
));
96 zfs_fuid_avl_tree_create(avl_tree_t
*idx_tree
, avl_tree_t
*domain_tree
)
98 avl_create(idx_tree
, idx_compare
,
99 sizeof (fuid_domain_t
), offsetof(fuid_domain_t
, f_idxnode
));
100 avl_create(domain_tree
, domain_compare
,
101 sizeof (fuid_domain_t
), offsetof(fuid_domain_t
, f_domnode
));
105 * load initial fuid domain and idx trees. This function is used by
106 * both the kernel and zdb.
109 zfs_fuid_table_load(objset_t
*os
, uint64_t fuid_obj
, avl_tree_t
*idx_tree
,
110 avl_tree_t
*domain_tree
)
115 ASSERT(fuid_obj
!= 0);
116 VERIFY(0 == dmu_bonus_hold(os
, fuid_obj
,
118 fuid_size
= *(uint64_t *)db
->db_data
;
119 dmu_buf_rele(db
, FTAG
);
123 nvlist_t
*nvp
= NULL
;
128 packed
= kmem_alloc(fuid_size
, KM_SLEEP
);
129 VERIFY(dmu_read(os
, fuid_obj
, 0,
130 fuid_size
, packed
, DMU_READ_PREFETCH
) == 0);
131 VERIFY(nvlist_unpack(packed
, fuid_size
,
133 VERIFY(nvlist_lookup_nvlist_array(nvp
, FUID_NVP_ARRAY
,
134 &fuidnvp
, &count
) == 0);
136 for (i
= 0; i
!= count
; i
++) {
137 fuid_domain_t
*domnode
;
141 VERIFY(nvlist_lookup_string(fuidnvp
[i
], FUID_DOMAIN
,
143 VERIFY(nvlist_lookup_uint64(fuidnvp
[i
], FUID_IDX
,
146 domnode
= kmem_alloc(sizeof (fuid_domain_t
), KM_SLEEP
);
148 domnode
->f_idx
= idx
;
149 domnode
->f_ksid
= ksid_lookupdomain(domain
);
150 avl_add(idx_tree
, domnode
);
151 avl_add(domain_tree
, domnode
);
154 kmem_free(packed
, fuid_size
);
160 zfs_fuid_table_destroy(avl_tree_t
*idx_tree
, avl_tree_t
*domain_tree
)
162 fuid_domain_t
*domnode
;
166 while ((domnode
= avl_destroy_nodes(domain_tree
, &cookie
)))
167 ksiddomain_rele(domnode
->f_ksid
);
169 avl_destroy(domain_tree
);
171 while ((domnode
= avl_destroy_nodes(idx_tree
, &cookie
)))
172 kmem_free(domnode
, sizeof (fuid_domain_t
));
173 avl_destroy(idx_tree
);
177 zfs_fuid_idx_domain(avl_tree_t
*idx_tree
, uint32_t idx
)
179 fuid_domain_t searchnode
, *findnode
;
182 searchnode
.f_idx
= idx
;
184 findnode
= avl_find(idx_tree
, &searchnode
, &loc
);
186 return (findnode
? findnode
->f_ksid
->kd_name
: nulldomain
);
191 * Load the fuid table(s) into memory.
194 zfs_fuid_init(zfsvfs_t
*zfsvfs
)
196 rw_enter(&zfsvfs
->z_fuid_lock
, RW_WRITER
);
198 if (zfsvfs
->z_fuid_loaded
) {
199 rw_exit(&zfsvfs
->z_fuid_lock
);
203 zfs_fuid_avl_tree_create(&zfsvfs
->z_fuid_idx
, &zfsvfs
->z_fuid_domain
);
205 (void) zap_lookup(zfsvfs
->z_os
, MASTER_NODE_OBJ
,
206 ZFS_FUID_TABLES
, 8, 1, &zfsvfs
->z_fuid_obj
);
207 if (zfsvfs
->z_fuid_obj
!= 0) {
208 zfsvfs
->z_fuid_size
= zfs_fuid_table_load(zfsvfs
->z_os
,
209 zfsvfs
->z_fuid_obj
, &zfsvfs
->z_fuid_idx
,
210 &zfsvfs
->z_fuid_domain
);
213 zfsvfs
->z_fuid_loaded
= B_TRUE
;
214 rw_exit(&zfsvfs
->z_fuid_lock
);
218 * sync out AVL trees to persistent storage.
221 zfs_fuid_sync(zfsvfs_t
*zfsvfs
, dmu_tx_t
*tx
)
228 fuid_domain_t
*domnode
;
232 if (!zfsvfs
->z_fuid_dirty
) {
236 rw_enter(&zfsvfs
->z_fuid_lock
, RW_WRITER
);
239 * First see if table needs to be created?
241 if (zfsvfs
->z_fuid_obj
== 0) {
242 zfsvfs
->z_fuid_obj
= dmu_object_alloc(zfsvfs
->z_os
,
243 DMU_OT_FUID
, 1 << 14, DMU_OT_FUID_SIZE
,
244 sizeof (uint64_t), tx
);
245 VERIFY(zap_add(zfsvfs
->z_os
, MASTER_NODE_OBJ
,
246 ZFS_FUID_TABLES
, sizeof (uint64_t), 1,
247 &zfsvfs
->z_fuid_obj
, tx
) == 0);
250 VERIFY(nvlist_alloc(&nvp
, NV_UNIQUE_NAME
, KM_SLEEP
) == 0);
252 numnodes
= avl_numnodes(&zfsvfs
->z_fuid_idx
);
253 fuids
= kmem_alloc(numnodes
* sizeof (void *), KM_SLEEP
);
254 for (i
= 0, domnode
= avl_first(&zfsvfs
->z_fuid_domain
); domnode
; i
++,
255 domnode
= AVL_NEXT(&zfsvfs
->z_fuid_domain
, domnode
)) {
256 VERIFY(nvlist_alloc(&fuids
[i
], NV_UNIQUE_NAME
, KM_SLEEP
) == 0);
257 VERIFY(nvlist_add_uint64(fuids
[i
], FUID_IDX
,
258 domnode
->f_idx
) == 0);
259 VERIFY(nvlist_add_uint64(fuids
[i
], FUID_OFFSET
, 0) == 0);
260 VERIFY(nvlist_add_string(fuids
[i
], FUID_DOMAIN
,
261 domnode
->f_ksid
->kd_name
) == 0);
263 VERIFY(nvlist_add_nvlist_array(nvp
, FUID_NVP_ARRAY
,
264 fuids
, numnodes
) == 0);
265 for (i
= 0; i
!= numnodes
; i
++)
266 nvlist_free(fuids
[i
]);
267 kmem_free(fuids
, numnodes
* sizeof (void *));
268 VERIFY(nvlist_size(nvp
, &nvsize
, NV_ENCODE_XDR
) == 0);
269 packed
= kmem_alloc(nvsize
, KM_SLEEP
);
270 VERIFY(nvlist_pack(nvp
, &packed
, &nvsize
,
271 NV_ENCODE_XDR
, KM_SLEEP
) == 0);
273 zfsvfs
->z_fuid_size
= nvsize
;
274 dmu_write(zfsvfs
->z_os
, zfsvfs
->z_fuid_obj
, 0,
275 zfsvfs
->z_fuid_size
, packed
, tx
);
276 kmem_free(packed
, zfsvfs
->z_fuid_size
);
277 VERIFY(0 == dmu_bonus_hold(zfsvfs
->z_os
, zfsvfs
->z_fuid_obj
,
279 dmu_buf_will_dirty(db
, tx
);
280 *(uint64_t *)db
->db_data
= zfsvfs
->z_fuid_size
;
281 dmu_buf_rele(db
, FTAG
);
283 zfsvfs
->z_fuid_dirty
= B_FALSE
;
284 rw_exit(&zfsvfs
->z_fuid_lock
);
288 * Query domain table for a given domain.
290 * If domain isn't found and addok is set, it is added to AVL trees and
291 * the zfsvfs->z_fuid_dirty flag will be set to TRUE. It will then be
292 * necessary for the caller or another thread to detect the dirty table
293 * and sync out the changes.
296 zfs_fuid_find_by_domain(zfsvfs_t
*zfsvfs
, const char *domain
,
297 char **retdomain
, boolean_t addok
)
299 fuid_domain_t searchnode
, *findnode
;
301 krw_t rw
= RW_READER
;
304 * If the dummy "nobody" domain then return an index of 0
305 * to cause the created FUID to be a standard POSIX id
306 * for the user nobody.
308 if (domain
[0] == '\0') {
310 *retdomain
= nulldomain
;
314 searchnode
.f_ksid
= ksid_lookupdomain(domain
);
316 *retdomain
= searchnode
.f_ksid
->kd_name
;
317 if (!zfsvfs
->z_fuid_loaded
)
318 zfs_fuid_init(zfsvfs
);
321 rw_enter(&zfsvfs
->z_fuid_lock
, rw
);
322 findnode
= avl_find(&zfsvfs
->z_fuid_domain
, &searchnode
, &loc
);
325 rw_exit(&zfsvfs
->z_fuid_lock
);
326 ksiddomain_rele(searchnode
.f_ksid
);
327 return (findnode
->f_idx
);
329 fuid_domain_t
*domnode
;
332 if (rw
== RW_READER
&& !rw_tryupgrade(&zfsvfs
->z_fuid_lock
)) {
333 rw_exit(&zfsvfs
->z_fuid_lock
);
338 domnode
= kmem_alloc(sizeof (fuid_domain_t
), KM_SLEEP
);
339 domnode
->f_ksid
= searchnode
.f_ksid
;
341 retidx
= domnode
->f_idx
= avl_numnodes(&zfsvfs
->z_fuid_idx
) + 1;
343 avl_add(&zfsvfs
->z_fuid_domain
, domnode
);
344 avl_add(&zfsvfs
->z_fuid_idx
, domnode
);
345 zfsvfs
->z_fuid_dirty
= B_TRUE
;
346 rw_exit(&zfsvfs
->z_fuid_lock
);
349 rw_exit(&zfsvfs
->z_fuid_lock
);
355 * Query domain table by index, returning domain string
357 * Returns a pointer from an avl node of the domain string.
361 zfs_fuid_find_by_idx(zfsvfs_t
*zfsvfs
, uint32_t idx
)
365 if (idx
== 0 || !zfsvfs
->z_use_fuids
)
368 if (!zfsvfs
->z_fuid_loaded
)
369 zfs_fuid_init(zfsvfs
);
371 rw_enter(&zfsvfs
->z_fuid_lock
, RW_READER
);
373 if (zfsvfs
->z_fuid_obj
|| zfsvfs
->z_fuid_dirty
)
374 domain
= zfs_fuid_idx_domain(&zfsvfs
->z_fuid_idx
, idx
);
377 rw_exit(&zfsvfs
->z_fuid_lock
);
384 zfs_fuid_map_ids(znode_t
*zp
, cred_t
*cr
, uid_t
*uidp
, uid_t
*gidp
)
386 *uidp
= zfs_fuid_map_id(ZTOZSB(zp
), KUID_TO_SUID(ZTOI(zp
)->i_uid
),
388 *gidp
= zfs_fuid_map_id(ZTOZSB(zp
), KGID_TO_SGID(ZTOI(zp
)->i_gid
),
393 zfs_fuid_map_id(zfsvfs_t
*zfsvfs
, uint64_t fuid
,
394 cred_t
*cr
, zfs_fuid_type_t type
)
397 uint32_t index
= FUID_INDEX(fuid
);
404 domain
= zfs_fuid_find_by_idx(zfsvfs
, index
);
405 ASSERT(domain
!= NULL
);
407 if (type
== ZFS_OWNER
|| type
== ZFS_ACE_USER
) {
408 (void) kidmap_getuidbysid(crgetzone(cr
), domain
,
409 FUID_RID(fuid
), &id
);
411 (void) kidmap_getgidbysid(crgetzone(cr
), domain
,
412 FUID_RID(fuid
), &id
);
417 * The Linux port only supports POSIX IDs, use the passed id.
420 #endif /* HAVE_KSID */
424 * Add a FUID node to the list of fuid's being created for this
427 * If ACL has multiple domains, then keep only one copy of each unique
431 zfs_fuid_node_add(zfs_fuid_info_t
**fuidpp
, const char *domain
, uint32_t rid
,
432 uint64_t idx
, uint64_t id
, zfs_fuid_type_t type
)
435 zfs_fuid_domain_t
*fuid_domain
;
436 zfs_fuid_info_t
*fuidp
;
438 boolean_t found
= B_FALSE
;
441 *fuidpp
= zfs_fuid_info_alloc();
445 * First find fuid domain index in linked list
447 * If one isn't found then create an entry.
450 for (fuididx
= 1, fuid_domain
= list_head(&fuidp
->z_domains
);
451 fuid_domain
; fuid_domain
= list_next(&fuidp
->z_domains
,
452 fuid_domain
), fuididx
++) {
453 if (idx
== fuid_domain
->z_domidx
) {
460 fuid_domain
= kmem_alloc(sizeof (zfs_fuid_domain_t
), KM_SLEEP
);
461 fuid_domain
->z_domain
= domain
;
462 fuid_domain
->z_domidx
= idx
;
463 list_insert_tail(&fuidp
->z_domains
, fuid_domain
);
464 fuidp
->z_domain_str_sz
+= strlen(domain
) + 1;
465 fuidp
->z_domain_cnt
++;
468 if (type
== ZFS_ACE_USER
|| type
== ZFS_ACE_GROUP
) {
471 * Now allocate fuid entry and add it on the end of the list
474 fuid
= kmem_alloc(sizeof (zfs_fuid_t
), KM_SLEEP
);
476 fuid
->z_domidx
= idx
;
477 fuid
->z_logfuid
= FUID_ENCODE(fuididx
, rid
);
479 list_insert_tail(&fuidp
->z_fuids
, fuid
);
482 if (type
== ZFS_OWNER
)
483 fuidp
->z_fuid_owner
= FUID_ENCODE(fuididx
, rid
);
485 fuidp
->z_fuid_group
= FUID_ENCODE(fuididx
, rid
);
491 * Create a file system FUID, based on information in the users cred
493 * If cred contains KSID_OWNER then it should be used to determine
494 * the uid otherwise cred's uid will be used. By default cred's gid
495 * is used unless it's an ephemeral ID in which case KSID_GROUP will
496 * be used if it exists.
499 zfs_fuid_create_cred(zfsvfs_t
*zfsvfs
, zfs_fuid_type_t type
,
500 cred_t
*cr
, zfs_fuid_info_t
**fuidp
)
509 VERIFY(type
== ZFS_OWNER
|| type
== ZFS_GROUP
);
511 ksid
= crgetsid(cr
, (type
== ZFS_OWNER
) ? KSID_OWNER
: KSID_GROUP
);
513 if (!zfsvfs
->z_use_fuids
|| (ksid
== NULL
)) {
514 id
= (type
== ZFS_OWNER
) ? crgetuid(cr
) : crgetgid(cr
);
516 if (IS_EPHEMERAL(id
))
517 return ((type
== ZFS_OWNER
) ? UID_NOBODY
: GID_NOBODY
);
519 return ((uint64_t)id
);
523 * ksid is present and FUID is supported
525 id
= (type
== ZFS_OWNER
) ? ksid_getid(ksid
) : crgetgid(cr
);
527 if (!IS_EPHEMERAL(id
))
528 return ((uint64_t)id
);
530 if (type
== ZFS_GROUP
)
531 id
= ksid_getid(ksid
);
533 rid
= ksid_getrid(ksid
);
534 domain
= ksid_getdomain(ksid
);
536 idx
= zfs_fuid_find_by_domain(zfsvfs
, domain
, &kdomain
, B_TRUE
);
538 zfs_fuid_node_add(fuidp
, kdomain
, rid
, idx
, id
, type
);
540 return (FUID_ENCODE(idx
, rid
));
542 #endif /* HAVE_KSID */
545 * Create a file system FUID for an ACL ace
546 * or a chown/chgrp of the file.
547 * This is similar to zfs_fuid_create_cred, except that
548 * we can't find the domain + rid information in the
549 * cred. Instead we have to query Winchester for the
552 * During replay operations the domain+rid information is
553 * found in the zfs_fuid_info_t that the replay code has
554 * attached to the zfsvfs of the file system.
557 zfs_fuid_create(zfsvfs_t
*zfsvfs
, uint64_t id
, cred_t
*cr
,
558 zfs_fuid_type_t type
, zfs_fuid_info_t
**fuidpp
)
563 uint32_t fuid_idx
= FUID_INDEX(id
);
567 zfs_fuid_t
*zfuid
= NULL
;
568 zfs_fuid_info_t
*fuidp
= NULL
;
571 * If POSIX ID, or entry is already a FUID then
574 * We may also be handed an already FUID'ized id via
578 if (!zfsvfs
->z_use_fuids
|| !IS_EPHEMERAL(id
) || fuid_idx
!= 0)
581 if (zfsvfs
->z_replay
) {
582 fuidp
= zfsvfs
->z_fuid_replay
;
585 * If we are passed an ephemeral id, but no
586 * fuid_info was logged then return NOBODY.
587 * This is most likely a result of idmap service
588 * not being available.
593 VERIFY3U(type
, >=, ZFS_OWNER
);
594 VERIFY3U(type
, <=, ZFS_ACE_GROUP
);
599 zfuid
= list_head(&fuidp
->z_fuids
);
600 rid
= FUID_RID(zfuid
->z_logfuid
);
601 idx
= FUID_INDEX(zfuid
->z_logfuid
);
604 rid
= FUID_RID(fuidp
->z_fuid_owner
);
605 idx
= FUID_INDEX(fuidp
->z_fuid_owner
);
608 rid
= FUID_RID(fuidp
->z_fuid_group
);
609 idx
= FUID_INDEX(fuidp
->z_fuid_group
);
612 domain
= fuidp
->z_domain_table
[idx
- 1];
614 if (type
== ZFS_OWNER
|| type
== ZFS_ACE_USER
)
615 status
= kidmap_getsidbyuid(crgetzone(cr
), id
,
618 status
= kidmap_getsidbygid(crgetzone(cr
), id
,
623 * When returning nobody we will need to
624 * make a dummy fuid table entry for logging
632 idx
= zfs_fuid_find_by_domain(zfsvfs
, domain
, &kdomain
, B_TRUE
);
634 if (!zfsvfs
->z_replay
)
635 zfs_fuid_node_add(fuidpp
, kdomain
,
637 else if (zfuid
!= NULL
) {
638 list_remove(&fuidp
->z_fuids
, zfuid
);
639 kmem_free(zfuid
, sizeof (zfs_fuid_t
));
641 return (FUID_ENCODE(idx
, rid
));
644 * The Linux port only supports POSIX IDs, use the passed id.
651 zfs_fuid_destroy(zfsvfs_t
*zfsvfs
)
653 rw_enter(&zfsvfs
->z_fuid_lock
, RW_WRITER
);
654 if (!zfsvfs
->z_fuid_loaded
) {
655 rw_exit(&zfsvfs
->z_fuid_lock
);
658 zfs_fuid_table_destroy(&zfsvfs
->z_fuid_idx
, &zfsvfs
->z_fuid_domain
);
659 rw_exit(&zfsvfs
->z_fuid_lock
);
663 * Allocate zfs_fuid_info for tracking FUIDs created during
664 * zfs_mknode, VOP_SETATTR() or VOP_SETSECATTR()
667 zfs_fuid_info_alloc(void)
669 zfs_fuid_info_t
*fuidp
;
671 fuidp
= kmem_zalloc(sizeof (zfs_fuid_info_t
), KM_SLEEP
);
672 list_create(&fuidp
->z_domains
, sizeof (zfs_fuid_domain_t
),
673 offsetof(zfs_fuid_domain_t
, z_next
));
674 list_create(&fuidp
->z_fuids
, sizeof (zfs_fuid_t
),
675 offsetof(zfs_fuid_t
, z_next
));
680 * Release all memory associated with zfs_fuid_info_t
683 zfs_fuid_info_free(zfs_fuid_info_t
*fuidp
)
686 zfs_fuid_domain_t
*zdomain
;
688 while ((zfuid
= list_head(&fuidp
->z_fuids
)) != NULL
) {
689 list_remove(&fuidp
->z_fuids
, zfuid
);
690 kmem_free(zfuid
, sizeof (zfs_fuid_t
));
693 if (fuidp
->z_domain_table
!= NULL
)
694 kmem_free(fuidp
->z_domain_table
,
695 (sizeof (char *)) * fuidp
->z_domain_cnt
);
697 while ((zdomain
= list_head(&fuidp
->z_domains
)) != NULL
) {
698 list_remove(&fuidp
->z_domains
, zdomain
);
699 kmem_free(zdomain
, sizeof (zfs_fuid_domain_t
));
702 kmem_free(fuidp
, sizeof (zfs_fuid_info_t
));
706 * Check to see if id is a groupmember. If cred
707 * has ksid info then sidlist is checked first
708 * and if still not found then POSIX groups are checked
710 * Will use a straight FUID compare when possible.
713 zfs_groupmember(zfsvfs_t
*zfsvfs
, uint64_t id
, cred_t
*cr
)
716 ksid_t
*ksid
= crgetsid(cr
, KSID_GROUP
);
717 ksidlist_t
*ksidlist
= crgetsidlist(cr
);
720 if (ksid
&& ksidlist
) {
723 uint32_t idx
= FUID_INDEX(id
);
724 uint32_t rid
= FUID_RID(id
);
726 ksid_groups
= ksidlist
->ksl_sids
;
728 for (i
= 0; i
!= ksidlist
->ksl_nsid
; i
++) {
730 if (id
!= IDMAP_WK_CREATOR_GROUP_GID
&&
731 id
== ksid_groups
[i
].ks_id
) {
737 domain
= zfs_fuid_find_by_idx(zfsvfs
, idx
);
738 ASSERT(domain
!= NULL
);
741 IDMAP_WK_CREATOR_SID_AUTHORITY
) == 0)
745 ksid_groups
[i
].ks_domain
->kd_name
) == 0) &&
746 rid
== ksid_groups
[i
].ks_rid
)
753 * Not found in ksidlist, check posix groups
755 gid
= zfs_fuid_map_id(zfsvfs
, id
, cr
, ZFS_GROUP
);
756 return (groupmember(gid
, cr
));
763 zfs_fuid_txhold(zfsvfs_t
*zfsvfs
, dmu_tx_t
*tx
)
765 if (zfsvfs
->z_fuid_obj
== 0) {
766 dmu_tx_hold_bonus(tx
, DMU_NEW_OBJECT
);
767 dmu_tx_hold_write(tx
, DMU_NEW_OBJECT
, 0,
768 FUID_SIZE_ESTIMATE(zfsvfs
));
769 dmu_tx_hold_zap(tx
, MASTER_NODE_OBJ
, FALSE
, NULL
);
771 dmu_tx_hold_bonus(tx
, zfsvfs
->z_fuid_obj
);
772 dmu_tx_hold_write(tx
, zfsvfs
->z_fuid_obj
, 0,
773 FUID_SIZE_ESTIMATE(zfsvfs
));