xref: /illumos-gate/usr/src/uts/common/fs/zfs/sa.c (revision e914ace2e9d9bf2dbf9a1f1ce81cb776022096f5)
10a586ceaSMark Shellenbaum /*
20a586ceaSMark Shellenbaum  * CDDL HEADER START
30a586ceaSMark Shellenbaum  *
40a586ceaSMark Shellenbaum  * The contents of this file are subject to the terms of the
50a586ceaSMark Shellenbaum  * Common Development and Distribution License (the "License").
60a586ceaSMark Shellenbaum  * You may not use this file except in compliance with the License.
70a586ceaSMark Shellenbaum  *
80a586ceaSMark Shellenbaum  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
90a586ceaSMark Shellenbaum  * or http://www.opensolaris.org/os/licensing.
100a586ceaSMark Shellenbaum  * See the License for the specific language governing permissions
110a586ceaSMark Shellenbaum  * and limitations under the License.
120a586ceaSMark Shellenbaum  *
130a586ceaSMark Shellenbaum  * When distributing Covered Code, include this CDDL HEADER in each
140a586ceaSMark Shellenbaum  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
150a586ceaSMark Shellenbaum  * If applicable, add the following below this CDDL HEADER, with the
160a586ceaSMark Shellenbaum  * fields enclosed by brackets "[]" replaced with your own identifying
170a586ceaSMark Shellenbaum  * information: Portions Copyright [yyyy] [name of copyright owner]
180a586ceaSMark Shellenbaum  *
190a586ceaSMark Shellenbaum  * CDDL HEADER END
200a586ceaSMark Shellenbaum  */
21ad135b5dSChristopher Siden 
220a586ceaSMark Shellenbaum /*
2306e0070dSMark Shellenbaum  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
24383e7c74SXin Li  * Portions Copyright 2011 iXsystems, Inc
257f0bdb42SMatthew Ahrens  * Copyright (c) 2013, 2017 by Delphix. All rights reserved.
26bc9014e6SJustin Gibbs  * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
27c3d26abcSMatthew Ahrens  * Copyright (c) 2014 Integros [integros.com]
280a586ceaSMark Shellenbaum  */
290a586ceaSMark Shellenbaum 
300a586ceaSMark Shellenbaum #include <sys/zfs_context.h>
310a586ceaSMark Shellenbaum #include <sys/types.h>
320a586ceaSMark Shellenbaum #include <sys/param.h>
330a586ceaSMark Shellenbaum #include <sys/systm.h>
340a586ceaSMark Shellenbaum #include <sys/sysmacros.h>
350a586ceaSMark Shellenbaum #include <sys/dmu.h>
360a586ceaSMark Shellenbaum #include <sys/dmu_impl.h>
370a586ceaSMark Shellenbaum #include <sys/dmu_objset.h>
3854811da5SToomas Soome #include <sys/dmu_tx.h>
390a586ceaSMark Shellenbaum #include <sys/dbuf.h>
400a586ceaSMark Shellenbaum #include <sys/dnode.h>
410a586ceaSMark Shellenbaum #include <sys/zap.h>
420a586ceaSMark Shellenbaum #include <sys/sa.h>
430a586ceaSMark Shellenbaum #include <sys/sunddi.h>
440a586ceaSMark Shellenbaum #include <sys/sa_impl.h>
450a586ceaSMark Shellenbaum #include <sys/dnode.h>
460a586ceaSMark Shellenbaum #include <sys/errno.h>
470a586ceaSMark Shellenbaum #include <sys/zfs_context.h>
480a586ceaSMark Shellenbaum 
490a586ceaSMark Shellenbaum /*
500a586ceaSMark Shellenbaum  * ZFS System attributes:
510a586ceaSMark Shellenbaum  *
520a586ceaSMark Shellenbaum  * A generic mechanism to allow for arbitrary attributes
530a586ceaSMark Shellenbaum  * to be stored in a dnode.  The data will be stored in the bonus buffer of
540a586ceaSMark Shellenbaum  * the dnode and if necessary a special "spill" block will be used to handle
550a586ceaSMark Shellenbaum  * overflow situations.  The spill block will be sized to fit the data
560a586ceaSMark Shellenbaum  * from 512 - 128K.  When a spill block is used the BP (blkptr_t) for the
570a586ceaSMark Shellenbaum  * spill block is stored at the end of the current bonus buffer.  Any
580a586ceaSMark Shellenbaum  * attributes that would be in the way of the blkptr_t will be relocated
590a586ceaSMark Shellenbaum  * into the spill block.
600a586ceaSMark Shellenbaum  *
610a586ceaSMark Shellenbaum  * Attribute registration:
620a586ceaSMark Shellenbaum  *
630a586ceaSMark Shellenbaum  * Stored persistently on a per dataset basis
640a586ceaSMark Shellenbaum  * a mapping between attribute "string" names and their actual attribute
650a586ceaSMark Shellenbaum  * numeric values, length, and byteswap function.  The names are only used
660a586ceaSMark Shellenbaum  * during registration.  All  attributes are known by their unique attribute
670a586ceaSMark Shellenbaum  * id value.  If an attribute can have a variable size then the value
680a586ceaSMark Shellenbaum  * 0 will be used to indicate this.
690a586ceaSMark Shellenbaum  *
700a586ceaSMark Shellenbaum  * Attribute Layout:
710a586ceaSMark Shellenbaum  *
720a586ceaSMark Shellenbaum  * Attribute layouts are a way to compactly store multiple attributes, but
730a586ceaSMark Shellenbaum  * without taking the overhead associated with managing each attribute
740a586ceaSMark Shellenbaum  * individually.  Since you will typically have the same set of attributes
750a586ceaSMark Shellenbaum  * stored in the same order a single table will be used to represent that
760a586ceaSMark Shellenbaum  * layout.  The ZPL for example will usually have only about 10 different
770a586ceaSMark Shellenbaum  * layouts (regular files, device files, symlinks,
780a586ceaSMark Shellenbaum  * regular files + scanstamp, files/dir with extended attributes, and then
790a586ceaSMark Shellenbaum  * you have the possibility of all of those minus ACL, because it would
800a586ceaSMark Shellenbaum  * be kicked out into the spill block)
810a586ceaSMark Shellenbaum  *
820a586ceaSMark Shellenbaum  * Layouts are simply an array of the attributes and their
830a586ceaSMark Shellenbaum  * ordering i.e. [0, 1, 4, 5, 2]
840a586ceaSMark Shellenbaum  *
850a586ceaSMark Shellenbaum  * Each distinct layout is given a unique layout number and that is whats
860a586ceaSMark Shellenbaum  * stored in the header at the beginning of the SA data buffer.
870a586ceaSMark Shellenbaum  *
880a586ceaSMark Shellenbaum  * A layout only covers a single dbuf (bonus or spill).  If a set of
890a586ceaSMark Shellenbaum  * attributes is split up between the bonus buffer and a spill buffer then
900a586ceaSMark Shellenbaum  * two different layouts will be used.  This allows us to byteswap the
910a586ceaSMark Shellenbaum  * spill without looking at the bonus buffer and keeps the on disk format of
920a586ceaSMark Shellenbaum  * the bonus and spill buffer the same.
930a586ceaSMark Shellenbaum  *
940a586ceaSMark Shellenbaum  * Adding a single attribute will cause the entire set of attributes to
950a586ceaSMark Shellenbaum  * be rewritten and could result in a new layout number being constructed
960a586ceaSMark Shellenbaum  * as part of the rewrite if no such layout exists for the new set of
970a586ceaSMark Shellenbaum  * attribues.  The new attribute will be appended to the end of the already
980a586ceaSMark Shellenbaum  * existing attributes.
990a586ceaSMark Shellenbaum  *
1000a586ceaSMark Shellenbaum  * Both the attribute registration and attribute layout information are
1010a586ceaSMark Shellenbaum  * stored in normal ZAP attributes.  Their should be a small number of
1020a586ceaSMark Shellenbaum  * known layouts and the set of attributes is assumed to typically be quite
1030a586ceaSMark Shellenbaum  * small.
1040a586ceaSMark Shellenbaum  *
1050a586ceaSMark Shellenbaum  * The registered attributes and layout "table" information is maintained
1060a586ceaSMark Shellenbaum  * in core and a special "sa_os_t" is attached to the objset_t.
1070a586ceaSMark Shellenbaum  *
1080a586ceaSMark Shellenbaum  * A special interface is provided to allow for quickly applying
1090a586ceaSMark Shellenbaum  * a large set of attributes at once.  sa_replace_all_by_template() is
1100a586ceaSMark Shellenbaum  * used to set an array of attributes.  This is used by the ZPL when
1110a586ceaSMark Shellenbaum  * creating a brand new file.  The template that is passed into the function
1120a586ceaSMark Shellenbaum  * specifies the attribute, size for variable length attributes, location of
1130a586ceaSMark Shellenbaum  * data and special "data locator" function if the data isn't in a contiguous
1140a586ceaSMark Shellenbaum  * location.
1150a586ceaSMark Shellenbaum  *
1160a586ceaSMark Shellenbaum  * Byteswap implications:
117f7170741SWill Andrews  *
1180a586ceaSMark Shellenbaum  * Since the SA attributes are not entirely self describing we can't do
1190a586ceaSMark Shellenbaum  * the normal byteswap processing.  The special ZAP layout attribute and
1200a586ceaSMark Shellenbaum  * attribute registration attributes define the byteswap function and the
1210a586ceaSMark Shellenbaum  * size of the attributes, unless it is variable sized.
1220a586ceaSMark Shellenbaum  * The normal ZFS byteswapping infrastructure assumes you don't need
1230a586ceaSMark Shellenbaum  * to read any objects in order to do the necessary byteswapping.  Whereas
1240a586ceaSMark Shellenbaum  * SA attributes can only be properly byteswapped if the dataset is opened
1250a586ceaSMark Shellenbaum  * and the layout/attribute ZAP attributes are available.  Because of this
1260a586ceaSMark Shellenbaum  * the SA attributes will be byteswapped when they are first accessed by
1270a586ceaSMark Shellenbaum  * the SA code that will read the SA data.
1280a586ceaSMark Shellenbaum  */
1290a586ceaSMark Shellenbaum 
1300a586ceaSMark Shellenbaum typedef void (sa_iterfunc_t)(void *hdr, void *addr, sa_attr_type_t,
1310a586ceaSMark Shellenbaum     uint16_t length, int length_idx, boolean_t, void *userp);
1320a586ceaSMark Shellenbaum 
1330a586ceaSMark Shellenbaum static int sa_build_index(sa_handle_t *hdl, sa_buf_type_t buftype);
1340a586ceaSMark Shellenbaum static void sa_idx_tab_hold(objset_t *os, sa_idx_tab_t *idx_tab);
1357f0bdb42SMatthew Ahrens static sa_idx_tab_t *sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype,
1367f0bdb42SMatthew Ahrens     sa_hdr_phys_t *hdr);
1370a586ceaSMark Shellenbaum static void sa_idx_tab_rele(objset_t *os, void *arg);
1380a586ceaSMark Shellenbaum static void sa_copy_data(sa_data_locator_t *func, void *start, void *target,
1390a586ceaSMark Shellenbaum     int buflen);
1400a586ceaSMark Shellenbaum static int sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr,
1410a586ceaSMark Shellenbaum     sa_data_op_t action, sa_data_locator_t *locator, void *datastart,
1420a586ceaSMark Shellenbaum     uint16_t buflen, dmu_tx_t *tx);
1430a586ceaSMark Shellenbaum 
1440a586ceaSMark Shellenbaum arc_byteswap_func_t *sa_bswap_table[] = {
1450a586ceaSMark Shellenbaum 	byteswap_uint64_array,
1460a586ceaSMark Shellenbaum 	byteswap_uint32_array,
1470a586ceaSMark Shellenbaum 	byteswap_uint16_array,
1480a586ceaSMark Shellenbaum 	byteswap_uint8_array,
1490a586ceaSMark Shellenbaum 	zfs_acl_byteswap,
1500a586ceaSMark Shellenbaum };
1510a586ceaSMark Shellenbaum 
1520a586ceaSMark Shellenbaum #define	SA_COPY_DATA(f, s, t, l) \
1530a586ceaSMark Shellenbaum 	{ \
1540a586ceaSMark Shellenbaum 		if (f == NULL) { \
1550a586ceaSMark Shellenbaum 			if (l == 8) { \
1560a586ceaSMark Shellenbaum 				*(uint64_t *)t = *(uint64_t *)s; \
1570a586ceaSMark Shellenbaum 			} else if (l == 16) { \
1580a586ceaSMark Shellenbaum 				*(uint64_t *)t = *(uint64_t *)s; \
1590a586ceaSMark Shellenbaum 				*(uint64_t *)((uintptr_t)t + 8) = \
1600a586ceaSMark Shellenbaum 				    *(uint64_t *)((uintptr_t)s + 8); \
1610a586ceaSMark Shellenbaum 			} else { \
1620a586ceaSMark Shellenbaum 				bcopy(s, t, l); \
1630a586ceaSMark Shellenbaum 			} \
1640a586ceaSMark Shellenbaum 		} else \
1650a586ceaSMark Shellenbaum 			sa_copy_data(f, s, t, l); \
1660a586ceaSMark Shellenbaum 	}
1670a586ceaSMark Shellenbaum 
1680a586ceaSMark Shellenbaum /*
1690a586ceaSMark Shellenbaum  * This table is fixed and cannot be changed.  Its purpose is to
1700a586ceaSMark Shellenbaum  * allow the SA code to work with both old/new ZPL file systems.
1710a586ceaSMark Shellenbaum  * It contains the list of legacy attributes.  These attributes aren't
1720a586ceaSMark Shellenbaum  * stored in the "attribute" registry zap objects, since older ZPL file systems
1730a586ceaSMark Shellenbaum  * won't have the registry.  Only objsets of type ZFS_TYPE_FILESYSTEM will
1740a586ceaSMark Shellenbaum  * use this static table.
1750a586ceaSMark Shellenbaum  */
1760a586ceaSMark Shellenbaum sa_attr_reg_t sa_legacy_attrs[] = {
1770a586ceaSMark Shellenbaum 	{"ZPL_ATIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 0},
1780a586ceaSMark Shellenbaum 	{"ZPL_MTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 1},
1790a586ceaSMark Shellenbaum 	{"ZPL_CTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 2},
1800a586ceaSMark Shellenbaum 	{"ZPL_CRTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 3},
1810a586ceaSMark Shellenbaum 	{"ZPL_GEN", sizeof (uint64_t), SA_UINT64_ARRAY, 4},
1820a586ceaSMark Shellenbaum 	{"ZPL_MODE", sizeof (uint64_t), SA_UINT64_ARRAY, 5},
1830a586ceaSMark Shellenbaum 	{"ZPL_SIZE", sizeof (uint64_t), SA_UINT64_ARRAY, 6},
1840a586ceaSMark Shellenbaum 	{"ZPL_PARENT", sizeof (uint64_t), SA_UINT64_ARRAY, 7},
1850a586ceaSMark Shellenbaum 	{"ZPL_LINKS", sizeof (uint64_t), SA_UINT64_ARRAY, 8},
1860a586ceaSMark Shellenbaum 	{"ZPL_XATTR", sizeof (uint64_t), SA_UINT64_ARRAY, 9},
1870a586ceaSMark Shellenbaum 	{"ZPL_RDEV", sizeof (uint64_t), SA_UINT64_ARRAY, 10},
1880a586ceaSMark Shellenbaum 	{"ZPL_FLAGS", sizeof (uint64_t), SA_UINT64_ARRAY, 11},
1890a586ceaSMark Shellenbaum 	{"ZPL_UID", sizeof (uint64_t), SA_UINT64_ARRAY, 12},
1900a586ceaSMark Shellenbaum 	{"ZPL_GID", sizeof (uint64_t), SA_UINT64_ARRAY, 13},
1910a586ceaSMark Shellenbaum 	{"ZPL_PAD", sizeof (uint64_t) * 4, SA_UINT64_ARRAY, 14},
1920a586ceaSMark Shellenbaum 	{"ZPL_ZNODE_ACL", 88, SA_UINT8_ARRAY, 15},
1930a586ceaSMark Shellenbaum };
1940a586ceaSMark Shellenbaum 
1950a586ceaSMark Shellenbaum /*
1960a586ceaSMark Shellenbaum  * This is only used for objects of type DMU_OT_ZNODE
1970a586ceaSMark Shellenbaum  */
1980a586ceaSMark Shellenbaum sa_attr_type_t sa_legacy_zpl_layout[] = {
1990a586ceaSMark Shellenbaum     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
2000a586ceaSMark Shellenbaum };
2010a586ceaSMark Shellenbaum 
2020a586ceaSMark Shellenbaum /*
2030a586ceaSMark Shellenbaum  * Special dummy layout used for buffers with no attributes.
2040a586ceaSMark Shellenbaum  */
2050a586ceaSMark Shellenbaum sa_attr_type_t sa_dummy_zpl_layout[] = { 0 };
2060a586ceaSMark Shellenbaum 
2070a586ceaSMark Shellenbaum static int sa_legacy_attr_count = 16;
2080a586ceaSMark Shellenbaum static kmem_cache_t *sa_cache = NULL;
2090a586ceaSMark Shellenbaum 
2100a586ceaSMark Shellenbaum /*ARGSUSED*/
2110a586ceaSMark Shellenbaum static int
2120a586ceaSMark Shellenbaum sa_cache_constructor(void *buf, void *unused, int kmflag)
2130a586ceaSMark Shellenbaum {
2140a586ceaSMark Shellenbaum 	sa_handle_t *hdl = buf;
2150a586ceaSMark Shellenbaum 
2160a586ceaSMark Shellenbaum 	mutex_init(&hdl->sa_lock, NULL, MUTEX_DEFAULT, NULL);
2170a586ceaSMark Shellenbaum 	return (0);
2180a586ceaSMark Shellenbaum }
2190a586ceaSMark Shellenbaum 
2200a586ceaSMark Shellenbaum /*ARGSUSED*/
2210a586ceaSMark Shellenbaum static void
2220a586ceaSMark Shellenbaum sa_cache_destructor(void *buf, void *unused)
2230a586ceaSMark Shellenbaum {
2240a586ceaSMark Shellenbaum 	sa_handle_t *hdl = buf;
2250a586ceaSMark Shellenbaum 	mutex_destroy(&hdl->sa_lock);
2260a586ceaSMark Shellenbaum }
2270a586ceaSMark Shellenbaum 
2280a586ceaSMark Shellenbaum void
2290a586ceaSMark Shellenbaum sa_cache_init(void)
2300a586ceaSMark Shellenbaum {
2310a586ceaSMark Shellenbaum 	sa_cache = kmem_cache_create("sa_cache",
2320a586ceaSMark Shellenbaum 	    sizeof (sa_handle_t), 0, sa_cache_constructor,
2330a586ceaSMark Shellenbaum 	    sa_cache_destructor, NULL, NULL, NULL, 0);
2340a586ceaSMark Shellenbaum }
2350a586ceaSMark Shellenbaum 
2360a586ceaSMark Shellenbaum void
2370a586ceaSMark Shellenbaum sa_cache_fini(void)
2380a586ceaSMark Shellenbaum {
2390a586ceaSMark Shellenbaum 	if (sa_cache)
2400a586ceaSMark Shellenbaum 		kmem_cache_destroy(sa_cache);
2410a586ceaSMark Shellenbaum }
2420a586ceaSMark Shellenbaum 
2430a586ceaSMark Shellenbaum static int
2440a586ceaSMark Shellenbaum layout_num_compare(const void *arg1, const void *arg2)
2450a586ceaSMark Shellenbaum {
2460a586ceaSMark Shellenbaum 	const sa_lot_t *node1 = arg1;
2470a586ceaSMark Shellenbaum 	const sa_lot_t *node2 = arg2;
2480a586ceaSMark Shellenbaum 
2490a586ceaSMark Shellenbaum 	if (node1->lot_num > node2->lot_num)
2500a586ceaSMark Shellenbaum 		return (1);
2510a586ceaSMark Shellenbaum 	else if (node1->lot_num < node2->lot_num)
2520a586ceaSMark Shellenbaum 		return (-1);
2530a586ceaSMark Shellenbaum 	return (0);
2540a586ceaSMark Shellenbaum }
2550a586ceaSMark Shellenbaum 
2560a586ceaSMark Shellenbaum static int
2570a586ceaSMark Shellenbaum layout_hash_compare(const void *arg1, const void *arg2)
2580a586ceaSMark Shellenbaum {
2590a586ceaSMark Shellenbaum 	const sa_lot_t *node1 = arg1;
2600a586ceaSMark Shellenbaum 	const sa_lot_t *node2 = arg2;
2610a586ceaSMark Shellenbaum 
2620a586ceaSMark Shellenbaum 	if (node1->lot_hash > node2->lot_hash)
2630a586ceaSMark Shellenbaum 		return (1);
2640a586ceaSMark Shellenbaum 	if (node1->lot_hash < node2->lot_hash)
2650a586ceaSMark Shellenbaum 		return (-1);
2660a586ceaSMark Shellenbaum 	if (node1->lot_instance > node2->lot_instance)
2670a586ceaSMark Shellenbaum 		return (1);
2680a586ceaSMark Shellenbaum 	if (node1->lot_instance < node2->lot_instance)
2690a586ceaSMark Shellenbaum 		return (-1);
2700a586ceaSMark Shellenbaum 	return (0);
2710a586ceaSMark Shellenbaum }
2720a586ceaSMark Shellenbaum 
2730a586ceaSMark Shellenbaum boolean_t
2740a586ceaSMark Shellenbaum sa_layout_equal(sa_lot_t *tbf, sa_attr_type_t *attrs, int count)
2750a586ceaSMark Shellenbaum {
2760a586ceaSMark Shellenbaum 	int i;
2770a586ceaSMark Shellenbaum 
2780a586ceaSMark Shellenbaum 	if (count != tbf->lot_attr_count)
2790a586ceaSMark Shellenbaum 		return (1);
2800a586ceaSMark Shellenbaum 
2810a586ceaSMark Shellenbaum 	for (i = 0; i != count; i++) {
2820a586ceaSMark Shellenbaum 		if (attrs[i] != tbf->lot_attrs[i])
2830a586ceaSMark Shellenbaum 			return (1);
2840a586ceaSMark Shellenbaum 	}
2850a586ceaSMark Shellenbaum 	return (0);
2860a586ceaSMark Shellenbaum }
2870a586ceaSMark Shellenbaum 
2880a586ceaSMark Shellenbaum #define	SA_ATTR_HASH(attr) (zfs_crc64_table[(-1ULL ^ attr) & 0xFF])
2890a586ceaSMark Shellenbaum 
2900a586ceaSMark Shellenbaum static uint64_t
2910a586ceaSMark Shellenbaum sa_layout_info_hash(sa_attr_type_t *attrs, int attr_count)
2920a586ceaSMark Shellenbaum {
2930a586ceaSMark Shellenbaum 	int i;
2940a586ceaSMark Shellenbaum 	uint64_t crc = -1ULL;
2950a586ceaSMark Shellenbaum 
2960a586ceaSMark Shellenbaum 	for (i = 0; i != attr_count; i++)
2970a586ceaSMark Shellenbaum 		crc ^= SA_ATTR_HASH(attrs[i]);
2980a586ceaSMark Shellenbaum 
2990a586ceaSMark Shellenbaum 	return (crc);
3000a586ceaSMark Shellenbaum }
3010a586ceaSMark Shellenbaum 
3021d8ccc7bSMark Shellenbaum static int
3031d8ccc7bSMark Shellenbaum sa_get_spill(sa_handle_t *hdl)
3040a586ceaSMark Shellenbaum {
3050a586ceaSMark Shellenbaum 	int rc;
3060a586ceaSMark Shellenbaum 	if (hdl->sa_spill == NULL) {
3070a586ceaSMark Shellenbaum 		if ((rc = dmu_spill_hold_existing(hdl->sa_bonus, NULL,
3080a586ceaSMark Shellenbaum 		    &hdl->sa_spill)) == 0)
3090a586ceaSMark Shellenbaum 			VERIFY(0 == sa_build_index(hdl, SA_SPILL));
3100a586ceaSMark Shellenbaum 	} else {
3110a586ceaSMark Shellenbaum 		rc = 0;
3120a586ceaSMark Shellenbaum 	}
3130a586ceaSMark Shellenbaum 
3141d8ccc7bSMark Shellenbaum 	return (rc);
3150a586ceaSMark Shellenbaum }
3160a586ceaSMark Shellenbaum 
3170a586ceaSMark Shellenbaum /*
3180a586ceaSMark Shellenbaum  * Main attribute lookup/update function
3190a586ceaSMark Shellenbaum  * returns 0 for success or non zero for failures
3200a586ceaSMark Shellenbaum  *
3210a586ceaSMark Shellenbaum  * Operates on bulk array, first failure will abort further processing
3220a586ceaSMark Shellenbaum  */
3230a586ceaSMark Shellenbaum int
3240a586ceaSMark Shellenbaum sa_attr_op(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count,
3250a586ceaSMark Shellenbaum     sa_data_op_t data_op, dmu_tx_t *tx)
3260a586ceaSMark Shellenbaum {
3270a586ceaSMark Shellenbaum 	sa_os_t *sa = hdl->sa_os->os_sa;
3280a586ceaSMark Shellenbaum 	int i;
3290a586ceaSMark Shellenbaum 	int error = 0;
3300a586ceaSMark Shellenbaum 	sa_buf_type_t buftypes;
3310a586ceaSMark Shellenbaum 
3320a586ceaSMark Shellenbaum 	buftypes = 0;
3330a586ceaSMark Shellenbaum 
3340a586ceaSMark Shellenbaum 	ASSERT(count > 0);
3350a586ceaSMark Shellenbaum 	for (i = 0; i != count; i++) {
3360a586ceaSMark Shellenbaum 		ASSERT(bulk[i].sa_attr <= hdl->sa_os->os_sa->sa_num_attrs);
3370a586ceaSMark Shellenbaum 
3380a586ceaSMark Shellenbaum 		bulk[i].sa_addr = NULL;
3390a586ceaSMark Shellenbaum 		/* First check the bonus buffer */
3400a586ceaSMark Shellenbaum 
3410a586ceaSMark Shellenbaum 		if (hdl->sa_bonus_tab && TOC_ATTR_PRESENT(
3420a586ceaSMark Shellenbaum 		    hdl->sa_bonus_tab->sa_idx_tab[bulk[i].sa_attr])) {
3430a586ceaSMark Shellenbaum 			SA_ATTR_INFO(sa, hdl->sa_bonus_tab,
3440a586ceaSMark Shellenbaum 			    SA_GET_HDR(hdl, SA_BONUS),
3450a586ceaSMark Shellenbaum 			    bulk[i].sa_attr, bulk[i], SA_BONUS, hdl);
3460a586ceaSMark Shellenbaum 			if (tx && !(buftypes & SA_BONUS)) {
3470a586ceaSMark Shellenbaum 				dmu_buf_will_dirty(hdl->sa_bonus, tx);
3480a586ceaSMark Shellenbaum 				buftypes |= SA_BONUS;
3490a586ceaSMark Shellenbaum 			}
3500a586ceaSMark Shellenbaum 		}
3511d8ccc7bSMark Shellenbaum 		if (bulk[i].sa_addr == NULL &&
3521d8ccc7bSMark Shellenbaum 		    ((error = sa_get_spill(hdl)) == 0)) {
3530a586ceaSMark Shellenbaum 			if (TOC_ATTR_PRESENT(
3540a586ceaSMark Shellenbaum 			    hdl->sa_spill_tab->sa_idx_tab[bulk[i].sa_attr])) {
3550a586ceaSMark Shellenbaum 				SA_ATTR_INFO(sa, hdl->sa_spill_tab,
3560a586ceaSMark Shellenbaum 				    SA_GET_HDR(hdl, SA_SPILL),
3570a586ceaSMark Shellenbaum 				    bulk[i].sa_attr, bulk[i], SA_SPILL, hdl);
3580a586ceaSMark Shellenbaum 				if (tx && !(buftypes & SA_SPILL) &&
3590a586ceaSMark Shellenbaum 				    bulk[i].sa_size == bulk[i].sa_length) {
3600a586ceaSMark Shellenbaum 					dmu_buf_will_dirty(hdl->sa_spill, tx);
3610a586ceaSMark Shellenbaum 					buftypes |= SA_SPILL;
3620a586ceaSMark Shellenbaum 				}
3630a586ceaSMark Shellenbaum 			}
3640a586ceaSMark Shellenbaum 		}
3651d8ccc7bSMark Shellenbaum 		if (error && error != ENOENT) {
3661d8ccc7bSMark Shellenbaum 			return ((error == ECKSUM) ? EIO : error);
3671d8ccc7bSMark Shellenbaum 		}
3681d8ccc7bSMark Shellenbaum 
3690a586ceaSMark Shellenbaum 		switch (data_op) {
3700a586ceaSMark Shellenbaum 		case SA_LOOKUP:
3710a586ceaSMark Shellenbaum 			if (bulk[i].sa_addr == NULL)
372be6fd75aSMatthew Ahrens 				return (SET_ERROR(ENOENT));
3730a586ceaSMark Shellenbaum 			if (bulk[i].sa_data) {
3740a586ceaSMark Shellenbaum 				SA_COPY_DATA(bulk[i].sa_data_func,
3750a586ceaSMark Shellenbaum 				    bulk[i].sa_addr, bulk[i].sa_data,
3760a586ceaSMark Shellenbaum 				    bulk[i].sa_size);
3770a586ceaSMark Shellenbaum 			}
3780a586ceaSMark Shellenbaum 			continue;
3790a586ceaSMark Shellenbaum 
3800a586ceaSMark Shellenbaum 		case SA_UPDATE:
3810a586ceaSMark Shellenbaum 			/* existing rewrite of attr */
3820a586ceaSMark Shellenbaum 			if (bulk[i].sa_addr &&
3830a586ceaSMark Shellenbaum 			    bulk[i].sa_size == bulk[i].sa_length) {
3840a586ceaSMark Shellenbaum 				SA_COPY_DATA(bulk[i].sa_data_func,
3850a586ceaSMark Shellenbaum 				    bulk[i].sa_data, bulk[i].sa_addr,
3860a586ceaSMark Shellenbaum 				    bulk[i].sa_length);
3870a586ceaSMark Shellenbaum 				continue;
3880a586ceaSMark Shellenbaum 			} else if (bulk[i].sa_addr) { /* attr size change */
3890a586ceaSMark Shellenbaum 				error = sa_modify_attrs(hdl, bulk[i].sa_attr,
3900a586ceaSMark Shellenbaum 				    SA_REPLACE, bulk[i].sa_data_func,
3910a586ceaSMark Shellenbaum 				    bulk[i].sa_data, bulk[i].sa_length, tx);
3920a586ceaSMark Shellenbaum 			} else { /* adding new attribute */
3930a586ceaSMark Shellenbaum 				error = sa_modify_attrs(hdl, bulk[i].sa_attr,
3940a586ceaSMark Shellenbaum 				    SA_ADD, bulk[i].sa_data_func,
3950a586ceaSMark Shellenbaum 				    bulk[i].sa_data, bulk[i].sa_length, tx);
3960a586ceaSMark Shellenbaum 			}
3970a586ceaSMark Shellenbaum 			if (error)
3980a586ceaSMark Shellenbaum 				return (error);
3990a586ceaSMark Shellenbaum 			break;
4000a586ceaSMark Shellenbaum 		}
4010a586ceaSMark Shellenbaum 	}
4020a586ceaSMark Shellenbaum 	return (error);
4030a586ceaSMark Shellenbaum }
4040a586ceaSMark Shellenbaum 
4050a586ceaSMark Shellenbaum static sa_lot_t *
4060a586ceaSMark Shellenbaum sa_add_layout_entry(objset_t *os, sa_attr_type_t *attrs, int attr_count,
4070a586ceaSMark Shellenbaum     uint64_t lot_num, uint64_t hash, boolean_t zapadd, dmu_tx_t *tx)
4080a586ceaSMark Shellenbaum {
4090a586ceaSMark Shellenbaum 	sa_os_t *sa = os->os_sa;
4100a586ceaSMark Shellenbaum 	sa_lot_t *tb, *findtb;
4110a586ceaSMark Shellenbaum 	int i;
4120a586ceaSMark Shellenbaum 	avl_index_t loc;
4130a586ceaSMark Shellenbaum 
4140a586ceaSMark Shellenbaum 	ASSERT(MUTEX_HELD(&sa->sa_lock));
4150a586ceaSMark Shellenbaum 	tb = kmem_zalloc(sizeof (sa_lot_t), KM_SLEEP);
4160a586ceaSMark Shellenbaum 	tb->lot_attr_count = attr_count;
4170a586ceaSMark Shellenbaum 	tb->lot_attrs = kmem_alloc(sizeof (sa_attr_type_t) * attr_count,
4180a586ceaSMark Shellenbaum 	    KM_SLEEP);
4190a586ceaSMark Shellenbaum 	bcopy(attrs, tb->lot_attrs, sizeof (sa_attr_type_t) * attr_count);
4200a586ceaSMark Shellenbaum 	tb->lot_num = lot_num;
4210a586ceaSMark Shellenbaum 	tb->lot_hash = hash;
4220a586ceaSMark Shellenbaum 	tb->lot_instance = 0;
4230a586ceaSMark Shellenbaum 
4240a586ceaSMark Shellenbaum 	if (zapadd) {
4250a586ceaSMark Shellenbaum 		char attr_name[8];
4260a586ceaSMark Shellenbaum 
4270a586ceaSMark Shellenbaum 		if (sa->sa_layout_attr_obj == 0) {
428ad135b5dSChristopher Siden 			sa->sa_layout_attr_obj = zap_create_link(os,
429ad135b5dSChristopher Siden 			    DMU_OT_SA_ATTR_LAYOUTS,
430ad135b5dSChristopher Siden 			    sa->sa_master_obj, SA_LAYOUTS, tx);
4310a586ceaSMark Shellenbaum 		}
4320a586ceaSMark Shellenbaum 
4330a586ceaSMark Shellenbaum 		(void) snprintf(attr_name, sizeof (attr_name),
4340a586ceaSMark Shellenbaum 		    "%d", (int)lot_num);
4350a586ceaSMark Shellenbaum 		VERIFY(0 == zap_update(os, os->os_sa->sa_layout_attr_obj,
4360a586ceaSMark Shellenbaum 		    attr_name, 2, attr_count, attrs, tx));
4370a586ceaSMark Shellenbaum 	}
4380a586ceaSMark Shellenbaum 
4390a586ceaSMark Shellenbaum 	list_create(&tb->lot_idx_tab, sizeof (sa_idx_tab_t),
4400a586ceaSMark Shellenbaum 	    offsetof(sa_idx_tab_t, sa_next));
4410a586ceaSMark Shellenbaum 
4420a586ceaSMark Shellenbaum 	for (i = 0; i != attr_count; i++) {
4430a586ceaSMark Shellenbaum 		if (sa->sa_attr_table[tb->lot_attrs[i]].sa_length == 0)
4440a586ceaSMark Shellenbaum 			tb->lot_var_sizes++;
4450a586ceaSMark Shellenbaum 	}
4460a586ceaSMark Shellenbaum 
4470a586ceaSMark Shellenbaum 	avl_add(&sa->sa_layout_num_tree, tb);
4480a586ceaSMark Shellenbaum 
4490a586ceaSMark Shellenbaum 	/* verify we don't have a hash collision */
4500a586ceaSMark Shellenbaum 	if ((findtb = avl_find(&sa->sa_layout_hash_tree, tb, &loc)) != NULL) {
4510a586ceaSMark Shellenbaum 		for (; findtb && findtb->lot_hash == hash;
4520a586ceaSMark Shellenbaum 		    findtb = AVL_NEXT(&sa->sa_layout_hash_tree, findtb)) {
4530a586ceaSMark Shellenbaum 			if (findtb->lot_instance != tb->lot_instance)
4540a586ceaSMark Shellenbaum 				break;
4550a586ceaSMark Shellenbaum 			tb->lot_instance++;
4560a586ceaSMark Shellenbaum 		}
4570a586ceaSMark Shellenbaum 	}
4580a586ceaSMark Shellenbaum 	avl_add(&sa->sa_layout_hash_tree, tb);
4590a586ceaSMark Shellenbaum 	return (tb);
4600a586ceaSMark Shellenbaum }
4610a586ceaSMark Shellenbaum 
4620a586ceaSMark Shellenbaum static void
4630a586ceaSMark Shellenbaum sa_find_layout(objset_t *os, uint64_t hash, sa_attr_type_t *attrs,
4640a586ceaSMark Shellenbaum     int count, dmu_tx_t *tx, sa_lot_t **lot)
4650a586ceaSMark Shellenbaum {
4660a586ceaSMark Shellenbaum 	sa_lot_t *tb, tbsearch;
4670a586ceaSMark Shellenbaum 	avl_index_t loc;
4680a586ceaSMark Shellenbaum 	sa_os_t *sa = os->os_sa;
4690a586ceaSMark Shellenbaum 	boolean_t found = B_FALSE;
4700a586ceaSMark Shellenbaum 
4710a586ceaSMark Shellenbaum 	mutex_enter(&sa->sa_lock);
4720a586ceaSMark Shellenbaum 	tbsearch.lot_hash = hash;
4730a586ceaSMark Shellenbaum 	tbsearch.lot_instance = 0;
4740a586ceaSMark Shellenbaum 	tb = avl_find(&sa->sa_layout_hash_tree, &tbsearch, &loc);
4750a586ceaSMark Shellenbaum 	if (tb) {
4760a586ceaSMark Shellenbaum 		for (; tb && tb->lot_hash == hash;
4770a586ceaSMark Shellenbaum 		    tb = AVL_NEXT(&sa->sa_layout_hash_tree, tb)) {
4780a586ceaSMark Shellenbaum 			if (sa_layout_equal(tb, attrs, count) == 0) {
4790a586ceaSMark Shellenbaum 				found = B_TRUE;
4800a586ceaSMark Shellenbaum 				break;
4810a586ceaSMark Shellenbaum 			}
4820a586ceaSMark Shellenbaum 		}
4830a586ceaSMark Shellenbaum 	}
4840a586ceaSMark Shellenbaum 	if (!found) {
4850a586ceaSMark Shellenbaum 		tb = sa_add_layout_entry(os, attrs, count,
4860a586ceaSMark Shellenbaum 		    avl_numnodes(&sa->sa_layout_num_tree), hash, B_TRUE, tx);
4870a586ceaSMark Shellenbaum 	}
4880a586ceaSMark Shellenbaum 	mutex_exit(&sa->sa_lock);
4890a586ceaSMark Shellenbaum 	*lot = tb;
4900a586ceaSMark Shellenbaum }
4910a586ceaSMark Shellenbaum 
4920a586ceaSMark Shellenbaum static int
4930a586ceaSMark Shellenbaum sa_resize_spill(sa_handle_t *hdl, uint32_t size, dmu_tx_t *tx)
4940a586ceaSMark Shellenbaum {
4950a586ceaSMark Shellenbaum 	int error;
4960a586ceaSMark Shellenbaum 	uint32_t blocksize;
4970a586ceaSMark Shellenbaum 
4980a586ceaSMark Shellenbaum 	if (size == 0) {
4990a586ceaSMark Shellenbaum 		blocksize = SPA_MINBLOCKSIZE;
500b5152584SMatthew Ahrens 	} else if (size > SPA_OLD_MAXBLOCKSIZE) {
5010a586ceaSMark Shellenbaum 		ASSERT(0);
502be6fd75aSMatthew Ahrens 		return (SET_ERROR(EFBIG));
5030a586ceaSMark Shellenbaum 	} else {
5040a586ceaSMark Shellenbaum 		blocksize = P2ROUNDUP_TYPED(size, SPA_MINBLOCKSIZE, uint32_t);
5050a586ceaSMark Shellenbaum 	}
5060a586ceaSMark Shellenbaum 
5070a586ceaSMark Shellenbaum 	error = dbuf_spill_set_blksz(hdl->sa_spill, blocksize, tx);
5080a586ceaSMark Shellenbaum 	ASSERT(error == 0);
5090a586ceaSMark Shellenbaum 	return (error);
5100a586ceaSMark Shellenbaum }
5110a586ceaSMark Shellenbaum 
5120a586ceaSMark Shellenbaum static void
5130a586ceaSMark Shellenbaum sa_copy_data(sa_data_locator_t *func, void *datastart, void *target, int buflen)
5140a586ceaSMark Shellenbaum {
5150a586ceaSMark Shellenbaum 	if (func == NULL) {
5160a586ceaSMark Shellenbaum 		bcopy(datastart, target, buflen);
5170a586ceaSMark Shellenbaum 	} else {
5180a586ceaSMark Shellenbaum 		boolean_t start;
5190a586ceaSMark Shellenbaum 		int bytes;
5200a586ceaSMark Shellenbaum 		void *dataptr;
5210a586ceaSMark Shellenbaum 		void *saptr = target;
5220a586ceaSMark Shellenbaum 		uint32_t length;
5230a586ceaSMark Shellenbaum 
5240a586ceaSMark Shellenbaum 		start = B_TRUE;
5250a586ceaSMark Shellenbaum 		bytes = 0;
5260a586ceaSMark Shellenbaum 		while (bytes < buflen) {
5270a586ceaSMark Shellenbaum 			func(&dataptr, &length, buflen, start, datastart);
5280a586ceaSMark Shellenbaum 			bcopy(dataptr, saptr, length);
5290a586ceaSMark Shellenbaum 			saptr = (void *)((caddr_t)saptr + length);
5300a586ceaSMark Shellenbaum 			bytes += length;
5310a586ceaSMark Shellenbaum 			start = B_FALSE;
5320a586ceaSMark Shellenbaum 		}
5330a586ceaSMark Shellenbaum 	}
5340a586ceaSMark Shellenbaum }
5350a586ceaSMark Shellenbaum 
5360a586ceaSMark Shellenbaum /*
5370a586ceaSMark Shellenbaum  * Determine several different sizes
5380a586ceaSMark Shellenbaum  * first the sa header size
5390a586ceaSMark Shellenbaum  * the number of bytes to be stored
5400a586ceaSMark Shellenbaum  * if spill would occur the index in the attribute array is returned
5410a586ceaSMark Shellenbaum  *
5420a586ceaSMark Shellenbaum  * the boolean will_spill will be set when spilling is necessary.  It
5430a586ceaSMark Shellenbaum  * is only set when the buftype is SA_BONUS
5440a586ceaSMark Shellenbaum  */
5450a586ceaSMark Shellenbaum static int
5460a586ceaSMark Shellenbaum sa_find_sizes(sa_os_t *sa, sa_bulk_attr_t *attr_desc, int attr_count,
54754811da5SToomas Soome     dmu_buf_t *db, sa_buf_type_t buftype, int full_space, int *index,
54854811da5SToomas Soome     int *total, boolean_t *will_spill)
5490a586ceaSMark Shellenbaum {
5500a586ceaSMark Shellenbaum 	int var_size = 0;
5510a586ceaSMark Shellenbaum 	int i;
5520a586ceaSMark Shellenbaum 	int hdrsize;
5533502ed6eSJames Pan 	int extra_hdrsize;
5540a586ceaSMark Shellenbaum 
5550a586ceaSMark Shellenbaum 	if (buftype == SA_BONUS && sa->sa_force_spill) {
5560a586ceaSMark Shellenbaum 		*total = 0;
5570a586ceaSMark Shellenbaum 		*index = 0;
5580a586ceaSMark Shellenbaum 		*will_spill = B_TRUE;
5590a586ceaSMark Shellenbaum 		return (0);
5600a586ceaSMark Shellenbaum 	}
5610a586ceaSMark Shellenbaum 
5620a586ceaSMark Shellenbaum 	*index = -1;
5630a586ceaSMark Shellenbaum 	*total = 0;
5643502ed6eSJames Pan 	*will_spill = B_FALSE;
5650a586ceaSMark Shellenbaum 
5663502ed6eSJames Pan 	extra_hdrsize = 0;
5670a586ceaSMark Shellenbaum 	hdrsize = (SA_BONUSTYPE_FROM_DB(db) == DMU_OT_ZNODE) ? 0 :
5680a586ceaSMark Shellenbaum 	    sizeof (sa_hdr_phys_t);
5690a586ceaSMark Shellenbaum 
570644b9528SNed Bass 	ASSERT(IS_P2ALIGNED(full_space, 8));
5710a586ceaSMark Shellenbaum 
5720a586ceaSMark Shellenbaum 	for (i = 0; i != attr_count; i++) {
5730a586ceaSMark Shellenbaum 		boolean_t is_var_sz;
5740a586ceaSMark Shellenbaum 
575644b9528SNed Bass 		*total = P2ROUNDUP(*total, 8);
5760a586ceaSMark Shellenbaum 		*total += attr_desc[i].sa_length;
5773502ed6eSJames Pan 		if (*will_spill)
5783502ed6eSJames Pan 			continue;
5790a586ceaSMark Shellenbaum 
5800a586ceaSMark Shellenbaum 		is_var_sz = (SA_REGISTERED_LEN(sa, attr_desc[i].sa_attr) == 0);
5810a586ceaSMark Shellenbaum 		if (is_var_sz) {
5820a586ceaSMark Shellenbaum 			var_size++;
5830a586ceaSMark Shellenbaum 		}
5840a586ceaSMark Shellenbaum 
5850a586ceaSMark Shellenbaum 		if (is_var_sz && var_size > 1) {
5863502ed6eSJames Pan 			/*
5873502ed6eSJames Pan 			 * Don't worry that the spill block might overflow.
5883502ed6eSJames Pan 			 * It will be resized if needed in sa_build_layouts().
5893502ed6eSJames Pan 			 */
5903502ed6eSJames Pan 			if (buftype == SA_SPILL ||
5913502ed6eSJames Pan 			    P2ROUNDUP(hdrsize + sizeof (uint16_t), 8) +
5920a586ceaSMark Shellenbaum 			    *total < full_space) {
593644b9528SNed Bass 				/*
594644b9528SNed Bass 				 * Account for header space used by array of
595644b9528SNed Bass 				 * optional sizes of variable-length attributes.
5963502ed6eSJames Pan 				 * Record the extra header size in case this
5973502ed6eSJames Pan 				 * increase needs to be reversed due to
5983502ed6eSJames Pan 				 * spill-over.
599644b9528SNed Bass 				 */
6000a586ceaSMark Shellenbaum 				hdrsize += sizeof (uint16_t);
6013502ed6eSJames Pan 				if (*index != -1)
6023502ed6eSJames Pan 					extra_hdrsize += sizeof (uint16_t);
6030a586ceaSMark Shellenbaum 			} else {
6043502ed6eSJames Pan 				ASSERT(buftype == SA_BONUS);
6053502ed6eSJames Pan 				if (*index == -1)
6063502ed6eSJames Pan 					*index = i;
6073502ed6eSJames Pan 				*will_spill = B_TRUE;
6080a586ceaSMark Shellenbaum 				continue;
6090a586ceaSMark Shellenbaum 			}
6100a586ceaSMark Shellenbaum 		}
6110a586ceaSMark Shellenbaum 
6120a586ceaSMark Shellenbaum 		/*
6130a586ceaSMark Shellenbaum 		 * find index of where spill *could* occur.
6140a586ceaSMark Shellenbaum 		 * Then continue to count of remainder attribute
6150a586ceaSMark Shellenbaum 		 * space.  The sum is used later for sizing bonus
6160a586ceaSMark Shellenbaum 		 * and spill buffer.
6170a586ceaSMark Shellenbaum 		 */
6180a586ceaSMark Shellenbaum 		if (buftype == SA_BONUS && *index == -1 &&
619383e7c74SXin Li 		    *total + P2ROUNDUP(hdrsize, 8) >
6200a586ceaSMark Shellenbaum 		    (full_space - sizeof (blkptr_t))) {
6210a586ceaSMark Shellenbaum 			*index = i;
6220a586ceaSMark Shellenbaum 		}
6230a586ceaSMark Shellenbaum 
624383e7c74SXin Li 		if (*total + P2ROUNDUP(hdrsize, 8) > full_space &&
6250a586ceaSMark Shellenbaum 		    buftype == SA_BONUS)
6260a586ceaSMark Shellenbaum 			*will_spill = B_TRUE;
6270a586ceaSMark Shellenbaum 	}
6280a586ceaSMark Shellenbaum 
6293502ed6eSJames Pan 	if (*will_spill)
6303502ed6eSJames Pan 		hdrsize -= extra_hdrsize;
631644b9528SNed Bass 
6320a586ceaSMark Shellenbaum 	hdrsize = P2ROUNDUP(hdrsize, 8);
6330a586ceaSMark Shellenbaum 	return (hdrsize);
6340a586ceaSMark Shellenbaum }
6350a586ceaSMark Shellenbaum 
6360a586ceaSMark Shellenbaum #define	BUF_SPACE_NEEDED(total, header) (total + header)
6370a586ceaSMark Shellenbaum 
6380a586ceaSMark Shellenbaum /*
6390a586ceaSMark Shellenbaum  * Find layout that corresponds to ordering of attributes
6400a586ceaSMark Shellenbaum  * If not found a new layout number is created and added to
6410a586ceaSMark Shellenbaum  * persistent layout tables.
6420a586ceaSMark Shellenbaum  */
6430a586ceaSMark Shellenbaum static int
6440a586ceaSMark Shellenbaum sa_build_layouts(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, int attr_count,
6450a586ceaSMark Shellenbaum     dmu_tx_t *tx)
6460a586ceaSMark Shellenbaum {
6470a586ceaSMark Shellenbaum 	sa_os_t *sa = hdl->sa_os->os_sa;
6480a586ceaSMark Shellenbaum 	uint64_t hash;
6490a586ceaSMark Shellenbaum 	sa_buf_type_t buftype;
6500a586ceaSMark Shellenbaum 	sa_hdr_phys_t *sahdr;
6510a586ceaSMark Shellenbaum 	void *data_start;
6520a586ceaSMark Shellenbaum 	int buf_space;
6530a586ceaSMark Shellenbaum 	sa_attr_type_t *attrs, *attrs_start;
6540a586ceaSMark Shellenbaum 	int i, lot_count;
65554811da5SToomas Soome 	int dnodesize;
656d5285caeSGeorge Wilson 	int hdrsize;
657d5285caeSGeorge Wilson 	int spillhdrsize = 0;
6580a586ceaSMark Shellenbaum 	int used;
6590a586ceaSMark Shellenbaum 	dmu_object_type_t bonustype;
6600a586ceaSMark Shellenbaum 	sa_lot_t *lot;
6610a586ceaSMark Shellenbaum 	int len_idx;
6620a586ceaSMark Shellenbaum 	int spill_used;
66354811da5SToomas Soome 	int bonuslen;
6640a586ceaSMark Shellenbaum 	boolean_t spilling;
6650a586ceaSMark Shellenbaum 
6660a586ceaSMark Shellenbaum 	dmu_buf_will_dirty(hdl->sa_bonus, tx);
6670a586ceaSMark Shellenbaum 	bonustype = SA_BONUSTYPE_FROM_DB(hdl->sa_bonus);
6680a586ceaSMark Shellenbaum 
66954811da5SToomas Soome 	dmu_object_dnsize_from_db(hdl->sa_bonus, &dnodesize);
67054811da5SToomas Soome 	bonuslen = DN_BONUS_SIZE(dnodesize);
67154811da5SToomas Soome 
6720a586ceaSMark Shellenbaum 	/* first determine bonus header size and sum of all attributes */
6730a586ceaSMark Shellenbaum 	hdrsize = sa_find_sizes(sa, attr_desc, attr_count, hdl->sa_bonus,
67454811da5SToomas Soome 	    SA_BONUS, bonuslen, &i, &used, &spilling);
6750a586ceaSMark Shellenbaum 
676b5152584SMatthew Ahrens 	if (used > SPA_OLD_MAXBLOCKSIZE)
677be6fd75aSMatthew Ahrens 		return (SET_ERROR(EFBIG));
6780a586ceaSMark Shellenbaum 
6790a586ceaSMark Shellenbaum 	VERIFY(0 == dmu_set_bonus(hdl->sa_bonus, spilling ?
68054811da5SToomas Soome 	    MIN(bonuslen - sizeof (blkptr_t), used + hdrsize) :
6810a586ceaSMark Shellenbaum 	    used + hdrsize, tx));
6820a586ceaSMark Shellenbaum 
6830a586ceaSMark Shellenbaum 	ASSERT((bonustype == DMU_OT_ZNODE && spilling == 0) ||
6840a586ceaSMark Shellenbaum 	    bonustype == DMU_OT_SA);
6850a586ceaSMark Shellenbaum 
6860a586ceaSMark Shellenbaum 	/* setup and size spill buffer when needed */
6870a586ceaSMark Shellenbaum 	if (spilling) {
6880a586ceaSMark Shellenbaum 		boolean_t dummy;
6890a586ceaSMark Shellenbaum 
6900a586ceaSMark Shellenbaum 		if (hdl->sa_spill == NULL) {
6911d8ccc7bSMark Shellenbaum 			VERIFY(dmu_spill_hold_by_bonus(hdl->sa_bonus, NULL,
6921d8ccc7bSMark Shellenbaum 			    &hdl->sa_spill) == 0);
6930a586ceaSMark Shellenbaum 		}
6940a586ceaSMark Shellenbaum 		dmu_buf_will_dirty(hdl->sa_spill, tx);
6950a586ceaSMark Shellenbaum 
6960a586ceaSMark Shellenbaum 		spillhdrsize = sa_find_sizes(sa, &attr_desc[i],
69754811da5SToomas Soome 		    attr_count - i, hdl->sa_spill, SA_SPILL,
69854811da5SToomas Soome 		    hdl->sa_spill->db_size, &i, &spill_used, &dummy);
6990a586ceaSMark Shellenbaum 
700b5152584SMatthew Ahrens 		if (spill_used > SPA_OLD_MAXBLOCKSIZE)
701be6fd75aSMatthew Ahrens 			return (SET_ERROR(EFBIG));
7020a586ceaSMark Shellenbaum 
7030a586ceaSMark Shellenbaum 		buf_space = hdl->sa_spill->db_size - spillhdrsize;
7040a586ceaSMark Shellenbaum 		if (BUF_SPACE_NEEDED(spill_used, spillhdrsize) >
7050a586ceaSMark Shellenbaum 		    hdl->sa_spill->db_size)
7060a586ceaSMark Shellenbaum 			VERIFY(0 == sa_resize_spill(hdl,
7070a586ceaSMark Shellenbaum 			    BUF_SPACE_NEEDED(spill_used, spillhdrsize), tx));
7080a586ceaSMark Shellenbaum 	}
7090a586ceaSMark Shellenbaum 
7100a586ceaSMark Shellenbaum 	/* setup starting pointers to lay down data */
7110a586ceaSMark Shellenbaum 	data_start = (void *)((uintptr_t)hdl->sa_bonus->db_data + hdrsize);
7120a586ceaSMark Shellenbaum 	sahdr = (sa_hdr_phys_t *)hdl->sa_bonus->db_data;
7130a586ceaSMark Shellenbaum 	buftype = SA_BONUS;
7140a586ceaSMark Shellenbaum 
7150a586ceaSMark Shellenbaum 	if (spilling)
7160a586ceaSMark Shellenbaum 		buf_space = (sa->sa_force_spill) ?
7170a586ceaSMark Shellenbaum 		    0 : SA_BLKPTR_SPACE - hdrsize;
7180a586ceaSMark Shellenbaum 	else
7190a586ceaSMark Shellenbaum 		buf_space = hdl->sa_bonus->db_size - hdrsize;
7200a586ceaSMark Shellenbaum 
7210a586ceaSMark Shellenbaum 	attrs_start = attrs = kmem_alloc(sizeof (sa_attr_type_t) * attr_count,
7220a586ceaSMark Shellenbaum 	    KM_SLEEP);
7230a586ceaSMark Shellenbaum 	lot_count = 0;
7240a586ceaSMark Shellenbaum 
7250a586ceaSMark Shellenbaum 	for (i = 0, len_idx = 0, hash = -1ULL; i != attr_count; i++) {
7260a586ceaSMark Shellenbaum 		uint16_t length;
7270a586ceaSMark Shellenbaum 
728644b9528SNed Bass 		ASSERT(IS_P2ALIGNED(data_start, 8));
729644b9528SNed Bass 		ASSERT(IS_P2ALIGNED(buf_space, 8));
7300a586ceaSMark Shellenbaum 		attrs[i] = attr_desc[i].sa_attr;
7310a586ceaSMark Shellenbaum 		length = SA_REGISTERED_LEN(sa, attrs[i]);
7320a586ceaSMark Shellenbaum 		if (length == 0)
7330a586ceaSMark Shellenbaum 			length = attr_desc[i].sa_length;
7340a586ceaSMark Shellenbaum 
7350a586ceaSMark Shellenbaum 		if (buf_space < length) {  /* switch to spill buffer */
736644b9528SNed Bass 			VERIFY(spilling);
7371412a1a2SMark Shellenbaum 			VERIFY(bonustype == DMU_OT_SA);
7380a586ceaSMark Shellenbaum 			if (buftype == SA_BONUS && !sa->sa_force_spill) {
7390a586ceaSMark Shellenbaum 				sa_find_layout(hdl->sa_os, hash, attrs_start,
7400a586ceaSMark Shellenbaum 				    lot_count, tx, &lot);
7410a586ceaSMark Shellenbaum 				SA_SET_HDR(sahdr, lot->lot_num, hdrsize);
7420a586ceaSMark Shellenbaum 			}
7430a586ceaSMark Shellenbaum 
7440a586ceaSMark Shellenbaum 			buftype = SA_SPILL;
7450a586ceaSMark Shellenbaum 			hash = -1ULL;
7460a586ceaSMark Shellenbaum 			len_idx = 0;
7470a586ceaSMark Shellenbaum 
7480a586ceaSMark Shellenbaum 			sahdr = (sa_hdr_phys_t *)hdl->sa_spill->db_data;
7490a586ceaSMark Shellenbaum 			sahdr->sa_magic = SA_MAGIC;
7500a586ceaSMark Shellenbaum 			data_start = (void *)((uintptr_t)sahdr +
7510a586ceaSMark Shellenbaum 			    spillhdrsize);
7520a586ceaSMark Shellenbaum 			attrs_start = &attrs[i];
7530a586ceaSMark Shellenbaum 			buf_space = hdl->sa_spill->db_size - spillhdrsize;
7540a586ceaSMark Shellenbaum 			lot_count = 0;
7550a586ceaSMark Shellenbaum 		}
7560a586ceaSMark Shellenbaum 		hash ^= SA_ATTR_HASH(attrs[i]);
7570a586ceaSMark Shellenbaum 		attr_desc[i].sa_addr = data_start;
7580a586ceaSMark Shellenbaum 		attr_desc[i].sa_size = length;
7590a586ceaSMark Shellenbaum 		SA_COPY_DATA(attr_desc[i].sa_data_func, attr_desc[i].sa_data,
7600a586ceaSMark Shellenbaum 		    data_start, length);
7610a586ceaSMark Shellenbaum 		if (sa->sa_attr_table[attrs[i]].sa_length == 0) {
7620a586ceaSMark Shellenbaum 			sahdr->sa_lengths[len_idx++] = length;
7630a586ceaSMark Shellenbaum 		}
7640a586ceaSMark Shellenbaum 		data_start = (void *)P2ROUNDUP(((uintptr_t)data_start +
7650a586ceaSMark Shellenbaum 		    length), 8);
7660a586ceaSMark Shellenbaum 		buf_space -= P2ROUNDUP(length, 8);
7670a586ceaSMark Shellenbaum 		lot_count++;
7680a586ceaSMark Shellenbaum 	}
7690a586ceaSMark Shellenbaum 
7700a586ceaSMark Shellenbaum 	sa_find_layout(hdl->sa_os, hash, attrs_start, lot_count, tx, &lot);
7711412a1a2SMark Shellenbaum 
7721412a1a2SMark Shellenbaum 	/*
7731412a1a2SMark Shellenbaum 	 * Verify that old znodes always have layout number 0.
7741412a1a2SMark Shellenbaum 	 * Must be DMU_OT_SA for arbitrary layouts
7751412a1a2SMark Shellenbaum 	 */
7761412a1a2SMark Shellenbaum 	VERIFY((bonustype == DMU_OT_ZNODE && lot->lot_num == 0) ||
7771412a1a2SMark Shellenbaum 	    (bonustype == DMU_OT_SA && lot->lot_num > 1));
7781412a1a2SMark Shellenbaum 
7790a586ceaSMark Shellenbaum 	if (bonustype == DMU_OT_SA) {
7800a586ceaSMark Shellenbaum 		SA_SET_HDR(sahdr, lot->lot_num,
7810a586ceaSMark Shellenbaum 		    buftype == SA_BONUS ? hdrsize : spillhdrsize);
7820a586ceaSMark Shellenbaum 	}
7830a586ceaSMark Shellenbaum 
7840a586ceaSMark Shellenbaum 	kmem_free(attrs, sizeof (sa_attr_type_t) * attr_count);
7850a586ceaSMark Shellenbaum 	if (hdl->sa_bonus_tab) {
7860a586ceaSMark Shellenbaum 		sa_idx_tab_rele(hdl->sa_os, hdl->sa_bonus_tab);
7870a586ceaSMark Shellenbaum 		hdl->sa_bonus_tab = NULL;
7880a586ceaSMark Shellenbaum 	}
7890a586ceaSMark Shellenbaum 	if (!sa->sa_force_spill)
7900a586ceaSMark Shellenbaum 		VERIFY(0 == sa_build_index(hdl, SA_BONUS));
7910a586ceaSMark Shellenbaum 	if (hdl->sa_spill) {
7920a586ceaSMark Shellenbaum 		sa_idx_tab_rele(hdl->sa_os, hdl->sa_spill_tab);
7930a586ceaSMark Shellenbaum 		if (!spilling) {
7940a586ceaSMark Shellenbaum 			/*
7950a586ceaSMark Shellenbaum 			 * remove spill block that is no longer needed.
7960a586ceaSMark Shellenbaum 			 */
7970a586ceaSMark Shellenbaum 			dmu_buf_rele(hdl->sa_spill, NULL);
7980a586ceaSMark Shellenbaum 			hdl->sa_spill = NULL;
7990a586ceaSMark Shellenbaum 			hdl->sa_spill_tab = NULL;
8000a586ceaSMark Shellenbaum 			VERIFY(0 == dmu_rm_spill(hdl->sa_os,
8010a586ceaSMark Shellenbaum 			    sa_handle_object(hdl), tx));
8020a586ceaSMark Shellenbaum 		} else {
8030a586ceaSMark Shellenbaum 			VERIFY(0 == sa_build_index(hdl, SA_SPILL));
8040a586ceaSMark Shellenbaum 		}
8050a586ceaSMark Shellenbaum 	}
8060a586ceaSMark Shellenbaum 
8070a586ceaSMark Shellenbaum 	return (0);
8080a586ceaSMark Shellenbaum }
8090a586ceaSMark Shellenbaum 
8100a586ceaSMark Shellenbaum static void
8111d8ccc7bSMark Shellenbaum sa_free_attr_table(sa_os_t *sa)
8121d8ccc7bSMark Shellenbaum {
8131d8ccc7bSMark Shellenbaum 	int i;
8141d8ccc7bSMark Shellenbaum 
8151d8ccc7bSMark Shellenbaum 	if (sa->sa_attr_table == NULL)
8161d8ccc7bSMark Shellenbaum 		return;
8171d8ccc7bSMark Shellenbaum 
8181d8ccc7bSMark Shellenbaum 	for (i = 0; i != sa->sa_num_attrs; i++) {
8191d8ccc7bSMark Shellenbaum 		if (sa->sa_attr_table[i].sa_name)
8201d8ccc7bSMark Shellenbaum 			kmem_free(sa->sa_attr_table[i].sa_name,
8211d8ccc7bSMark Shellenbaum 			    strlen(sa->sa_attr_table[i].sa_name) + 1);
8221d8ccc7bSMark Shellenbaum 	}
8231d8ccc7bSMark Shellenbaum 
8241d8ccc7bSMark Shellenbaum 	kmem_free(sa->sa_attr_table,
8251d8ccc7bSMark Shellenbaum 	    sizeof (sa_attr_table_t) * sa->sa_num_attrs);
8261d8ccc7bSMark Shellenbaum 
8271d8ccc7bSMark Shellenbaum 	sa->sa_attr_table = NULL;
8281d8ccc7bSMark Shellenbaum }
8291d8ccc7bSMark Shellenbaum 
8301d8ccc7bSMark Shellenbaum static int
8310a586ceaSMark Shellenbaum sa_attr_table_setup(objset_t *os, sa_attr_reg_t *reg_attrs, int count)
8320a586ceaSMark Shellenbaum {
8330a586ceaSMark Shellenbaum 	sa_os_t *sa = os->os_sa;
8340a586ceaSMark Shellenbaum 	uint64_t sa_attr_count = 0;
835d5285caeSGeorge Wilson 	uint64_t sa_reg_count = 0;
8360a586ceaSMark Shellenbaum 	int error = 0;
8370a586ceaSMark Shellenbaum 	uint64_t attr_value;
8380a586ceaSMark Shellenbaum 	sa_attr_table_t *tb;
8390a586ceaSMark Shellenbaum 	zap_cursor_t zc;
8400a586ceaSMark Shellenbaum 	zap_attribute_t za;
8410a586ceaSMark Shellenbaum 	int registered_count = 0;
8420a586ceaSMark Shellenbaum 	int i;
8430a586ceaSMark Shellenbaum 	dmu_objset_type_t ostype = dmu_objset_type(os);
8440a586ceaSMark Shellenbaum 
8450a586ceaSMark Shellenbaum 	sa->sa_user_table =
8460a586ceaSMark Shellenbaum 	    kmem_zalloc(count * sizeof (sa_attr_type_t), KM_SLEEP);
8470a586ceaSMark Shellenbaum 	sa->sa_user_table_sz = count * sizeof (sa_attr_type_t);
8480a586ceaSMark Shellenbaum 
8491d8ccc7bSMark Shellenbaum 	if (sa->sa_reg_attr_obj != 0) {
8501d8ccc7bSMark Shellenbaum 		error = zap_count(os, sa->sa_reg_attr_obj,
8511d8ccc7bSMark Shellenbaum 		    &sa_attr_count);
8521d8ccc7bSMark Shellenbaum 
8531d8ccc7bSMark Shellenbaum 		/*
8541d8ccc7bSMark Shellenbaum 		 * Make sure we retrieved a count and that it isn't zero
8551d8ccc7bSMark Shellenbaum 		 */
8561d8ccc7bSMark Shellenbaum 		if (error || (error == 0 && sa_attr_count == 0)) {
8571d8ccc7bSMark Shellenbaum 			if (error == 0)
858be6fd75aSMatthew Ahrens 				error = SET_ERROR(EINVAL);
8591d8ccc7bSMark Shellenbaum 			goto bail;
8601d8ccc7bSMark Shellenbaum 		}
8611d8ccc7bSMark Shellenbaum 		sa_reg_count = sa_attr_count;
8621d8ccc7bSMark Shellenbaum 	}
8630a586ceaSMark Shellenbaum 
8640a586ceaSMark Shellenbaum 	if (ostype == DMU_OST_ZFS && sa_attr_count == 0)
8650a586ceaSMark Shellenbaum 		sa_attr_count += sa_legacy_attr_count;
8660a586ceaSMark Shellenbaum 
8670a586ceaSMark Shellenbaum 	/* Allocate attribute numbers for attributes that aren't registered */
8680a586ceaSMark Shellenbaum 	for (i = 0; i != count; i++) {
8690a586ceaSMark Shellenbaum 		boolean_t found = B_FALSE;
8700a586ceaSMark Shellenbaum 		int j;
8710a586ceaSMark Shellenbaum 
8720a586ceaSMark Shellenbaum 		if (ostype == DMU_OST_ZFS) {
8730a586ceaSMark Shellenbaum 			for (j = 0; j != sa_legacy_attr_count; j++) {
8740a586ceaSMark Shellenbaum 				if (strcmp(reg_attrs[i].sa_name,
8750a586ceaSMark Shellenbaum 				    sa_legacy_attrs[j].sa_name) == 0) {
8760a586ceaSMark Shellenbaum 					sa->sa_user_table[i] =
8770a586ceaSMark Shellenbaum 					    sa_legacy_attrs[j].sa_attr;
8780a586ceaSMark Shellenbaum 					found = B_TRUE;
8790a586ceaSMark Shellenbaum 				}
8800a586ceaSMark Shellenbaum 			}
8810a586ceaSMark Shellenbaum 		}
8820a586ceaSMark Shellenbaum 		if (found)
8830a586ceaSMark Shellenbaum 			continue;
8840a586ceaSMark Shellenbaum 
8850a586ceaSMark Shellenbaum 		if (sa->sa_reg_attr_obj)
8860a586ceaSMark Shellenbaum 			error = zap_lookup(os, sa->sa_reg_attr_obj,
8870a586ceaSMark Shellenbaum 			    reg_attrs[i].sa_name, 8, 1, &attr_value);
8880a586ceaSMark Shellenbaum 		else
889be6fd75aSMatthew Ahrens 			error = SET_ERROR(ENOENT);
8900a586ceaSMark Shellenbaum 		switch (error) {
8910a586ceaSMark Shellenbaum 		case ENOENT:
8920a586ceaSMark Shellenbaum 			sa->sa_user_table[i] = (sa_attr_type_t)sa_attr_count;
8930a586ceaSMark Shellenbaum 			sa_attr_count++;
8940a586ceaSMark Shellenbaum 			break;
8950a586ceaSMark Shellenbaum 		case 0:
8960a586ceaSMark Shellenbaum 			sa->sa_user_table[i] = ATTR_NUM(attr_value);
8970a586ceaSMark Shellenbaum 			break;
8981d8ccc7bSMark Shellenbaum 		default:
8991d8ccc7bSMark Shellenbaum 			goto bail;
9000a586ceaSMark Shellenbaum 		}
9010a586ceaSMark Shellenbaum 	}
9020a586ceaSMark Shellenbaum 
9031d8ccc7bSMark Shellenbaum 	sa->sa_num_attrs = sa_attr_count;
9041d8ccc7bSMark Shellenbaum 	tb = sa->sa_attr_table =
9050a586ceaSMark Shellenbaum 	    kmem_zalloc(sizeof (sa_attr_table_t) * sa_attr_count, KM_SLEEP);
9060a586ceaSMark Shellenbaum 
9070a586ceaSMark Shellenbaum 	/*
9080a586ceaSMark Shellenbaum 	 * Attribute table is constructed from requested attribute list,
9090a586ceaSMark Shellenbaum 	 * previously foreign registered attributes, and also the legacy
9100a586ceaSMark Shellenbaum 	 * ZPL set of attributes.
9110a586ceaSMark Shellenbaum 	 */
9120a586ceaSMark Shellenbaum 
9130a586ceaSMark Shellenbaum 	if (sa->sa_reg_attr_obj) {
9140a586ceaSMark Shellenbaum 		for (zap_cursor_init(&zc, os, sa->sa_reg_attr_obj);
9151d8ccc7bSMark Shellenbaum 		    (error = zap_cursor_retrieve(&zc, &za)) == 0;
9160a586ceaSMark Shellenbaum 		    zap_cursor_advance(&zc)) {
9170a586ceaSMark Shellenbaum 			uint64_t value;
9180a586ceaSMark Shellenbaum 			value  = za.za_first_integer;
9190a586ceaSMark Shellenbaum 
9200a586ceaSMark Shellenbaum 			registered_count++;
9210a586ceaSMark Shellenbaum 			tb[ATTR_NUM(value)].sa_attr = ATTR_NUM(value);
9220a586ceaSMark Shellenbaum 			tb[ATTR_NUM(value)].sa_length = ATTR_LENGTH(value);
9230a586ceaSMark Shellenbaum 			tb[ATTR_NUM(value)].sa_byteswap = ATTR_BSWAP(value);
9240a586ceaSMark Shellenbaum 			tb[ATTR_NUM(value)].sa_registered = B_TRUE;
9250a586ceaSMark Shellenbaum 
9260a586ceaSMark Shellenbaum 			if (tb[ATTR_NUM(value)].sa_name) {
9270a586ceaSMark Shellenbaum 				continue;
9280a586ceaSMark Shellenbaum 			}
9290a586ceaSMark Shellenbaum 			tb[ATTR_NUM(value)].sa_name =
9300a586ceaSMark Shellenbaum 			    kmem_zalloc(strlen(za.za_name) +1, KM_SLEEP);
9310a586ceaSMark Shellenbaum 			(void) strlcpy(tb[ATTR_NUM(value)].sa_name, za.za_name,
9320a586ceaSMark Shellenbaum 			    strlen(za.za_name) +1);
9330a586ceaSMark Shellenbaum 		}
9340a586ceaSMark Shellenbaum 		zap_cursor_fini(&zc);
9351d8ccc7bSMark Shellenbaum 		/*
9361d8ccc7bSMark Shellenbaum 		 * Make sure we processed the correct number of registered
9371d8ccc7bSMark Shellenbaum 		 * attributes
9381d8ccc7bSMark Shellenbaum 		 */
9391d8ccc7bSMark Shellenbaum 		if (registered_count != sa_reg_count) {
9401d8ccc7bSMark Shellenbaum 			ASSERT(error != 0);
9411d8ccc7bSMark Shellenbaum 			goto bail;
9421d8ccc7bSMark Shellenbaum 		}
9431d8ccc7bSMark Shellenbaum 
9440a586ceaSMark Shellenbaum 	}
9450a586ceaSMark Shellenbaum 
9460a586ceaSMark Shellenbaum 	if (ostype == DMU_OST_ZFS) {
9470a586ceaSMark Shellenbaum 		for (i = 0; i != sa_legacy_attr_count; i++) {
9480a586ceaSMark Shellenbaum 			if (tb[i].sa_name)
9490a586ceaSMark Shellenbaum 				continue;
9500a586ceaSMark Shellenbaum 			tb[i].sa_attr = sa_legacy_attrs[i].sa_attr;
9510a586ceaSMark Shellenbaum 			tb[i].sa_length = sa_legacy_attrs[i].sa_length;
9520a586ceaSMark Shellenbaum 			tb[i].sa_byteswap = sa_legacy_attrs[i].sa_byteswap;
9530a586ceaSMark Shellenbaum 			tb[i].sa_registered = B_FALSE;
9540a586ceaSMark Shellenbaum 			tb[i].sa_name =
9550a586ceaSMark Shellenbaum 			    kmem_zalloc(strlen(sa_legacy_attrs[i].sa_name) +1,
9560a586ceaSMark Shellenbaum 			    KM_SLEEP);
9570a586ceaSMark Shellenbaum 			(void) strlcpy(tb[i].sa_name,
9580a586ceaSMark Shellenbaum 			    sa_legacy_attrs[i].sa_name,
9590a586ceaSMark Shellenbaum 			    strlen(sa_legacy_attrs[i].sa_name) + 1);
9600a586ceaSMark Shellenbaum 		}
9610a586ceaSMark Shellenbaum 	}
9620a586ceaSMark Shellenbaum 
9630a586ceaSMark Shellenbaum 	for (i = 0; i != count; i++) {
9640a586ceaSMark Shellenbaum 		sa_attr_type_t attr_id;
9650a586ceaSMark Shellenbaum 
9660a586ceaSMark Shellenbaum 		attr_id = sa->sa_user_table[i];
9670a586ceaSMark Shellenbaum 		if (tb[attr_id].sa_name)
9680a586ceaSMark Shellenbaum 			continue;
9690a586ceaSMark Shellenbaum 
9700a586ceaSMark Shellenbaum 		tb[attr_id].sa_length = reg_attrs[i].sa_length;
9710a586ceaSMark Shellenbaum 		tb[attr_id].sa_byteswap = reg_attrs[i].sa_byteswap;
9720a586ceaSMark Shellenbaum 		tb[attr_id].sa_attr = attr_id;
9730a586ceaSMark Shellenbaum 		tb[attr_id].sa_name =
9740a586ceaSMark Shellenbaum 		    kmem_zalloc(strlen(reg_attrs[i].sa_name) + 1, KM_SLEEP);
9750a586ceaSMark Shellenbaum 		(void) strlcpy(tb[attr_id].sa_name, reg_attrs[i].sa_name,
9760a586ceaSMark Shellenbaum 		    strlen(reg_attrs[i].sa_name) + 1);
9770a586ceaSMark Shellenbaum 	}
9780a586ceaSMark Shellenbaum 
9791d8ccc7bSMark Shellenbaum 	sa->sa_need_attr_registration =
9800a586ceaSMark Shellenbaum 	    (sa_attr_count != registered_count);
9811d8ccc7bSMark Shellenbaum 
9821d8ccc7bSMark Shellenbaum 	return (0);
9831d8ccc7bSMark Shellenbaum bail:
9841d8ccc7bSMark Shellenbaum 	kmem_free(sa->sa_user_table, count * sizeof (sa_attr_type_t));
9851d8ccc7bSMark Shellenbaum 	sa->sa_user_table = NULL;
9861d8ccc7bSMark Shellenbaum 	sa_free_attr_table(sa);
9871d8ccc7bSMark Shellenbaum 	return ((error != 0) ? error : EINVAL);
9880a586ceaSMark Shellenbaum }
9890a586ceaSMark Shellenbaum 
9901d8ccc7bSMark Shellenbaum int
9911d8ccc7bSMark Shellenbaum sa_setup(objset_t *os, uint64_t sa_obj, sa_attr_reg_t *reg_attrs, int count,
9921d8ccc7bSMark Shellenbaum     sa_attr_type_t **user_table)
9930a586ceaSMark Shellenbaum {
9940a586ceaSMark Shellenbaum 	zap_cursor_t zc;
9950a586ceaSMark Shellenbaum 	zap_attribute_t za;
9960a586ceaSMark Shellenbaum 	sa_os_t *sa;
9970a586ceaSMark Shellenbaum 	dmu_objset_type_t ostype = dmu_objset_type(os);
9980a586ceaSMark Shellenbaum 	sa_attr_type_t *tb;
9991d8ccc7bSMark Shellenbaum 	int error;
10000a586ceaSMark Shellenbaum 
10013b2aab18SMatthew Ahrens 	mutex_enter(&os->os_user_ptr_lock);
10020a586ceaSMark Shellenbaum 	if (os->os_sa) {
10030a586ceaSMark Shellenbaum 		mutex_enter(&os->os_sa->sa_lock);
10043b2aab18SMatthew Ahrens 		mutex_exit(&os->os_user_ptr_lock);
10050a586ceaSMark Shellenbaum 		tb = os->os_sa->sa_user_table;
10060a586ceaSMark Shellenbaum 		mutex_exit(&os->os_sa->sa_lock);
10071d8ccc7bSMark Shellenbaum 		*user_table = tb;
10081d8ccc7bSMark Shellenbaum 		return (0);
10090a586ceaSMark Shellenbaum 	}
10100a586ceaSMark Shellenbaum 
10110a586ceaSMark Shellenbaum 	sa = kmem_zalloc(sizeof (sa_os_t), KM_SLEEP);
10120a586ceaSMark Shellenbaum 	mutex_init(&sa->sa_lock, NULL, MUTEX_DEFAULT, NULL);
10130a586ceaSMark Shellenbaum 	sa->sa_master_obj = sa_obj;
10140a586ceaSMark Shellenbaum 
10151d8ccc7bSMark Shellenbaum 	os->os_sa = sa;
10160a586ceaSMark Shellenbaum 	mutex_enter(&sa->sa_lock);
10173b2aab18SMatthew Ahrens 	mutex_exit(&os->os_user_ptr_lock);
10180a586ceaSMark Shellenbaum 	avl_create(&sa->sa_layout_num_tree, layout_num_compare,
10190a586ceaSMark Shellenbaum 	    sizeof (sa_lot_t), offsetof(sa_lot_t, lot_num_node));
10200a586ceaSMark Shellenbaum 	avl_create(&sa->sa_layout_hash_tree, layout_hash_compare,
10210a586ceaSMark Shellenbaum 	    sizeof (sa_lot_t), offsetof(sa_lot_t, lot_hash_node));
10220a586ceaSMark Shellenbaum 
10230a586ceaSMark Shellenbaum 	if (sa_obj) {
10240a586ceaSMark Shellenbaum 		error = zap_lookup(os, sa_obj, SA_LAYOUTS,
10250a586ceaSMark Shellenbaum 		    8, 1, &sa->sa_layout_attr_obj);
10261d8ccc7bSMark Shellenbaum 		if (error != 0 && error != ENOENT)
10271d8ccc7bSMark Shellenbaum 			goto fail;
10280a586ceaSMark Shellenbaum 		error = zap_lookup(os, sa_obj, SA_REGISTRY,
10290a586ceaSMark Shellenbaum 		    8, 1, &sa->sa_reg_attr_obj);
10301d8ccc7bSMark Shellenbaum 		if (error != 0 && error != ENOENT)
10311d8ccc7bSMark Shellenbaum 			goto fail;
10320a586ceaSMark Shellenbaum 	}
10330a586ceaSMark Shellenbaum 
10341d8ccc7bSMark Shellenbaum 	if ((error = sa_attr_table_setup(os, reg_attrs, count)) != 0)
10351d8ccc7bSMark Shellenbaum 		goto fail;
10360a586ceaSMark Shellenbaum 
10370a586ceaSMark Shellenbaum 	if (sa->sa_layout_attr_obj != 0) {
10381d8ccc7bSMark Shellenbaum 		uint64_t layout_count;
10391d8ccc7bSMark Shellenbaum 
10401d8ccc7bSMark Shellenbaum 		error = zap_count(os, sa->sa_layout_attr_obj,
10411d8ccc7bSMark Shellenbaum 		    &layout_count);
10421d8ccc7bSMark Shellenbaum 
10431d8ccc7bSMark Shellenbaum 		/*
10441d8ccc7bSMark Shellenbaum 		 * Layout number count should be > 0
10451d8ccc7bSMark Shellenbaum 		 */
10461d8ccc7bSMark Shellenbaum 		if (error || (error == 0 && layout_count == 0)) {
10471d8ccc7bSMark Shellenbaum 			if (error == 0)
1048be6fd75aSMatthew Ahrens 				error = SET_ERROR(EINVAL);
10491d8ccc7bSMark Shellenbaum 			goto fail;
10501d8ccc7bSMark Shellenbaum 		}
10511d8ccc7bSMark Shellenbaum 
10520a586ceaSMark Shellenbaum 		for (zap_cursor_init(&zc, os, sa->sa_layout_attr_obj);
10531d8ccc7bSMark Shellenbaum 		    (error = zap_cursor_retrieve(&zc, &za)) == 0;
10540a586ceaSMark Shellenbaum 		    zap_cursor_advance(&zc)) {
10550a586ceaSMark Shellenbaum 			sa_attr_type_t *lot_attrs;
10560a586ceaSMark Shellenbaum 			uint64_t lot_num;
10570a586ceaSMark Shellenbaum 
10580a586ceaSMark Shellenbaum 			lot_attrs = kmem_zalloc(sizeof (sa_attr_type_t) *
10590a586ceaSMark Shellenbaum 			    za.za_num_integers, KM_SLEEP);
10600a586ceaSMark Shellenbaum 
10611d8ccc7bSMark Shellenbaum 			if ((error = (zap_lookup(os, sa->sa_layout_attr_obj,
10621d8ccc7bSMark Shellenbaum 			    za.za_name, 2, za.za_num_integers,
10631d8ccc7bSMark Shellenbaum 			    lot_attrs))) != 0) {
10641d8ccc7bSMark Shellenbaum 				kmem_free(lot_attrs, sizeof (sa_attr_type_t) *
10651d8ccc7bSMark Shellenbaum 				    za.za_num_integers);
10661d8ccc7bSMark Shellenbaum 				break;
10671d8ccc7bSMark Shellenbaum 			}
10680a586ceaSMark Shellenbaum 			VERIFY(ddi_strtoull(za.za_name, NULL, 10,
10690a586ceaSMark Shellenbaum 			    (unsigned long long *)&lot_num) == 0);
10700a586ceaSMark Shellenbaum 
10710a586ceaSMark Shellenbaum 			(void) sa_add_layout_entry(os, lot_attrs,
10720a586ceaSMark Shellenbaum 			    za.za_num_integers, lot_num,
10730a586ceaSMark Shellenbaum 			    sa_layout_info_hash(lot_attrs,
10740a586ceaSMark Shellenbaum 			    za.za_num_integers), B_FALSE, NULL);
10750a586ceaSMark Shellenbaum 			kmem_free(lot_attrs, sizeof (sa_attr_type_t) *
10760a586ceaSMark Shellenbaum 			    za.za_num_integers);
10770a586ceaSMark Shellenbaum 		}
10780a586ceaSMark Shellenbaum 		zap_cursor_fini(&zc);
10791d8ccc7bSMark Shellenbaum 
10801d8ccc7bSMark Shellenbaum 		/*
10811d8ccc7bSMark Shellenbaum 		 * Make sure layout count matches number of entries added
10821d8ccc7bSMark Shellenbaum 		 * to AVL tree
10831d8ccc7bSMark Shellenbaum 		 */
10841d8ccc7bSMark Shellenbaum 		if (avl_numnodes(&sa->sa_layout_num_tree) != layout_count) {
10851d8ccc7bSMark Shellenbaum 			ASSERT(error != 0);
10861d8ccc7bSMark Shellenbaum 			goto fail;
10871d8ccc7bSMark Shellenbaum 		}
10880a586ceaSMark Shellenbaum 	}
10890a586ceaSMark Shellenbaum 
10900a586ceaSMark Shellenbaum 	/* Add special layout number for old ZNODES */
10910a586ceaSMark Shellenbaum 	if (ostype == DMU_OST_ZFS) {
10920a586ceaSMark Shellenbaum 		(void) sa_add_layout_entry(os, sa_legacy_zpl_layout,
10930a586ceaSMark Shellenbaum 		    sa_legacy_attr_count, 0,
10940a586ceaSMark Shellenbaum 		    sa_layout_info_hash(sa_legacy_zpl_layout,
10950a586ceaSMark Shellenbaum 		    sa_legacy_attr_count), B_FALSE, NULL);
10960a586ceaSMark Shellenbaum 
10970a586ceaSMark Shellenbaum 		(void) sa_add_layout_entry(os, sa_dummy_zpl_layout, 0, 1,
10980a586ceaSMark Shellenbaum 		    0, B_FALSE, NULL);
10990a586ceaSMark Shellenbaum 	}
11001d8ccc7bSMark Shellenbaum 	*user_table = os->os_sa->sa_user_table;
11010a586ceaSMark Shellenbaum 	mutex_exit(&sa->sa_lock);
11021d8ccc7bSMark Shellenbaum 	return (0);
11031d8ccc7bSMark Shellenbaum fail:
11041d8ccc7bSMark Shellenbaum 	os->os_sa = NULL;
11051d8ccc7bSMark Shellenbaum 	sa_free_attr_table(sa);
11061d8ccc7bSMark Shellenbaum 	if (sa->sa_user_table)
11071d8ccc7bSMark Shellenbaum 		kmem_free(sa->sa_user_table, sa->sa_user_table_sz);
11081d8ccc7bSMark Shellenbaum 	mutex_exit(&sa->sa_lock);
1109d2b3cbbdSJorgen Lundman 	avl_destroy(&sa->sa_layout_hash_tree);
1110d2b3cbbdSJorgen Lundman 	avl_destroy(&sa->sa_layout_num_tree);
1111d2b3cbbdSJorgen Lundman 	mutex_destroy(&sa->sa_lock);
11121d8ccc7bSMark Shellenbaum 	kmem_free(sa, sizeof (sa_os_t));
11131d8ccc7bSMark Shellenbaum 	return ((error == ECKSUM) ? EIO : error);
11140a586ceaSMark Shellenbaum }
11150a586ceaSMark Shellenbaum 
11160a586ceaSMark Shellenbaum void
11170a586ceaSMark Shellenbaum sa_tear_down(objset_t *os)
11180a586ceaSMark Shellenbaum {
11190a586ceaSMark Shellenbaum 	sa_os_t *sa = os->os_sa;
11200a586ceaSMark Shellenbaum 	sa_lot_t *layout;
11210a586ceaSMark Shellenbaum 	void *cookie;
11220a586ceaSMark Shellenbaum 
11230a586ceaSMark Shellenbaum 	kmem_free(sa->sa_user_table, sa->sa_user_table_sz);
11240a586ceaSMark Shellenbaum 
11250a586ceaSMark Shellenbaum 	/* Free up attr table */
11260a586ceaSMark Shellenbaum 
11271d8ccc7bSMark Shellenbaum 	sa_free_attr_table(sa);
11280a586ceaSMark Shellenbaum 
11290a586ceaSMark Shellenbaum 	cookie = NULL;
11300a586ceaSMark Shellenbaum 	while (layout = avl_destroy_nodes(&sa->sa_layout_hash_tree, &cookie)) {
11310a586ceaSMark Shellenbaum 		sa_idx_tab_t *tab;
11320a586ceaSMark Shellenbaum 		while (tab = list_head(&layout->lot_idx_tab)) {
1133*e914ace2STim Schumacher 			ASSERT(zfs_refcount_count(&tab->sa_refcount));
11340a586ceaSMark Shellenbaum 			sa_idx_tab_rele(os, tab);
11350a586ceaSMark Shellenbaum 		}
11360a586ceaSMark Shellenbaum 	}
11370a586ceaSMark Shellenbaum 
11380a586ceaSMark Shellenbaum 	cookie = NULL;
11390a586ceaSMark Shellenbaum 	while (layout = avl_destroy_nodes(&sa->sa_layout_num_tree, &cookie)) {
11400a586ceaSMark Shellenbaum 		kmem_free(layout->lot_attrs,
11410a586ceaSMark Shellenbaum 		    sizeof (sa_attr_type_t) * layout->lot_attr_count);
11420a586ceaSMark Shellenbaum 		kmem_free(layout, sizeof (sa_lot_t));
11430a586ceaSMark Shellenbaum 	}
11440a586ceaSMark Shellenbaum 
11450a586ceaSMark Shellenbaum 	avl_destroy(&sa->sa_layout_hash_tree);
11460a586ceaSMark Shellenbaum 	avl_destroy(&sa->sa_layout_num_tree);
1147d2b3cbbdSJorgen Lundman 	mutex_destroy(&sa->sa_lock);
11480a586ceaSMark Shellenbaum 
11490a586ceaSMark Shellenbaum 	kmem_free(sa, sizeof (sa_os_t));
11500a586ceaSMark Shellenbaum 	os->os_sa = NULL;
11510a586ceaSMark Shellenbaum }
11520a586ceaSMark Shellenbaum 
11530a586ceaSMark Shellenbaum void
11540a586ceaSMark Shellenbaum sa_build_idx_tab(void *hdr, void *attr_addr, sa_attr_type_t attr,
11550a586ceaSMark Shellenbaum     uint16_t length, int length_idx, boolean_t var_length, void *userp)
11560a586ceaSMark Shellenbaum {
11570a586ceaSMark Shellenbaum 	sa_idx_tab_t *idx_tab = userp;
11580a586ceaSMark Shellenbaum 
11590a586ceaSMark Shellenbaum 	if (var_length) {
11600a586ceaSMark Shellenbaum 		ASSERT(idx_tab->sa_variable_lengths);
11610a586ceaSMark Shellenbaum 		idx_tab->sa_variable_lengths[length_idx] = length;
11620a586ceaSMark Shellenbaum 	}
11630a586ceaSMark Shellenbaum 	TOC_ATTR_ENCODE(idx_tab->sa_idx_tab[attr], length_idx,
11640a586ceaSMark Shellenbaum 	    (uint32_t)((uintptr_t)attr_addr - (uintptr_t)hdr));
11650a586ceaSMark Shellenbaum }
11660a586ceaSMark Shellenbaum 
11670a586ceaSMark Shellenbaum static void
11680a586ceaSMark Shellenbaum sa_attr_iter(objset_t *os, sa_hdr_phys_t *hdr, dmu_object_type_t type,
11690a586ceaSMark Shellenbaum     sa_iterfunc_t func, sa_lot_t *tab, void *userp)
11700a586ceaSMark Shellenbaum {
11710a586ceaSMark Shellenbaum 	void *data_start;
11720a586ceaSMark Shellenbaum 	sa_lot_t *tb = tab;
11730a586ceaSMark Shellenbaum 	sa_lot_t search;
11740a586ceaSMark Shellenbaum 	avl_index_t loc;
11750a586ceaSMark Shellenbaum 	sa_os_t *sa = os->os_sa;
11760a586ceaSMark Shellenbaum 	int i;
117706e0070dSMark Shellenbaum 	uint16_t *length_start = NULL;
11780a586ceaSMark Shellenbaum 	uint8_t length_idx = 0;
11790a586ceaSMark Shellenbaum 
11800a586ceaSMark Shellenbaum 	if (tab == NULL) {
11810a586ceaSMark Shellenbaum 		search.lot_num = SA_LAYOUT_NUM(hdr, type);
11820a586ceaSMark Shellenbaum 		tb = avl_find(&sa->sa_layout_num_tree, &search, &loc);
11830a586ceaSMark Shellenbaum 		ASSERT(tb);
11840a586ceaSMark Shellenbaum 	}
11850a586ceaSMark Shellenbaum 
11860a586ceaSMark Shellenbaum 	if (IS_SA_BONUSTYPE(type)) {
11870a586ceaSMark Shellenbaum 		data_start = (void *)P2ROUNDUP(((uintptr_t)hdr +
11880a586ceaSMark Shellenbaum 		    offsetof(sa_hdr_phys_t, sa_lengths) +
11890a586ceaSMark Shellenbaum 		    (sizeof (uint16_t) * tb->lot_var_sizes)), 8);
11900a586ceaSMark Shellenbaum 		length_start = hdr->sa_lengths;
11910a586ceaSMark Shellenbaum 	} else {
11920a586ceaSMark Shellenbaum 		data_start = hdr;
11930a586ceaSMark Shellenbaum 	}
11940a586ceaSMark Shellenbaum 
11950a586ceaSMark Shellenbaum 	for (i = 0; i != tb->lot_attr_count; i++) {
11960a586ceaSMark Shellenbaum 		int attr_length, reg_length;
11970a586ceaSMark Shellenbaum 		uint8_t idx_len;
11980a586ceaSMark Shellenbaum 
11990a586ceaSMark Shellenbaum 		reg_length = sa->sa_attr_table[tb->lot_attrs[i]].sa_length;
12000a586ceaSMark Shellenbaum 		if (reg_length) {
12010a586ceaSMark Shellenbaum 			attr_length = reg_length;
12020a586ceaSMark Shellenbaum 			idx_len = 0;
12030a586ceaSMark Shellenbaum 		} else {
12040a586ceaSMark Shellenbaum 			attr_length = length_start[length_idx];
12050a586ceaSMark Shellenbaum 			idx_len = length_idx++;
12060a586ceaSMark Shellenbaum 		}
12070a586ceaSMark Shellenbaum 
12080a586ceaSMark Shellenbaum 		func(hdr, data_start, tb->lot_attrs[i], attr_length,
12090a586ceaSMark Shellenbaum 		    idx_len, reg_length == 0 ? B_TRUE : B_FALSE, userp);
12100a586ceaSMark Shellenbaum 
12110a586ceaSMark Shellenbaum 		data_start = (void *)P2ROUNDUP(((uintptr_t)data_start +
12120a586ceaSMark Shellenbaum 		    attr_length), 8);
12130a586ceaSMark Shellenbaum 	}
12140a586ceaSMark Shellenbaum }
12150a586ceaSMark Shellenbaum 
12160a586ceaSMark Shellenbaum /*ARGSUSED*/
12170a586ceaSMark Shellenbaum void
12180a586ceaSMark Shellenbaum sa_byteswap_cb(void *hdr, void *attr_addr, sa_attr_type_t attr,
12190a586ceaSMark Shellenbaum     uint16_t length, int length_idx, boolean_t variable_length, void *userp)
12200a586ceaSMark Shellenbaum {
12210a586ceaSMark Shellenbaum 	sa_handle_t *hdl = userp;
12220a586ceaSMark Shellenbaum 	sa_os_t *sa = hdl->sa_os->os_sa;
12230a586ceaSMark Shellenbaum 
12240a586ceaSMark Shellenbaum 	sa_bswap_table[sa->sa_attr_table[attr].sa_byteswap](attr_addr, length);
12250a586ceaSMark Shellenbaum }
12260a586ceaSMark Shellenbaum 
12270a586ceaSMark Shellenbaum void
12280a586ceaSMark Shellenbaum sa_byteswap(sa_handle_t *hdl, sa_buf_type_t buftype)
12290a586ceaSMark Shellenbaum {
12300a586ceaSMark Shellenbaum 	sa_hdr_phys_t *sa_hdr_phys = SA_GET_HDR(hdl, buftype);
12310a586ceaSMark Shellenbaum 	dmu_buf_impl_t *db;
12320a586ceaSMark Shellenbaum 	sa_os_t *sa = hdl->sa_os->os_sa;
12330a586ceaSMark Shellenbaum 	int num_lengths = 1;
12340a586ceaSMark Shellenbaum 	int i;
12350a586ceaSMark Shellenbaum 
12360a586ceaSMark Shellenbaum 	ASSERT(MUTEX_HELD(&sa->sa_lock));
12370a586ceaSMark Shellenbaum 	if (sa_hdr_phys->sa_magic == SA_MAGIC)
12380a586ceaSMark Shellenbaum 		return;
12390a586ceaSMark Shellenbaum 
12400a586ceaSMark Shellenbaum 	db = SA_GET_DB(hdl, buftype);
12410a586ceaSMark Shellenbaum 
12420a586ceaSMark Shellenbaum 	if (buftype == SA_SPILL) {
12430a586ceaSMark Shellenbaum 		arc_release(db->db_buf, NULL);
12440a586ceaSMark Shellenbaum 		arc_buf_thaw(db->db_buf);
12450a586ceaSMark Shellenbaum 	}
12460a586ceaSMark Shellenbaum 
12470a586ceaSMark Shellenbaum 	sa_hdr_phys->sa_magic = BSWAP_32(sa_hdr_phys->sa_magic);
12480a586ceaSMark Shellenbaum 	sa_hdr_phys->sa_layout_info = BSWAP_16(sa_hdr_phys->sa_layout_info);
12490a586ceaSMark Shellenbaum 
12500a586ceaSMark Shellenbaum 	/*
12510a586ceaSMark Shellenbaum 	 * Determine number of variable lenghts in header
12520a586ceaSMark Shellenbaum 	 * The standard 8 byte header has one for free and a
12530a586ceaSMark Shellenbaum 	 * 16 byte header would have 4 + 1;
12540a586ceaSMark Shellenbaum 	 */
12550a586ceaSMark Shellenbaum 	if (SA_HDR_SIZE(sa_hdr_phys) > 8)
12560a586ceaSMark Shellenbaum 		num_lengths += (SA_HDR_SIZE(sa_hdr_phys) - 8) >> 1;
12570a586ceaSMark Shellenbaum 	for (i = 0; i != num_lengths; i++)
12580a586ceaSMark Shellenbaum 		sa_hdr_phys->sa_lengths[i] =
12590a586ceaSMark Shellenbaum 		    BSWAP_16(sa_hdr_phys->sa_lengths[i]);
12600a586ceaSMark Shellenbaum 
12610a586ceaSMark Shellenbaum 	sa_attr_iter(hdl->sa_os, sa_hdr_phys, DMU_OT_SA,
12620a586ceaSMark Shellenbaum 	    sa_byteswap_cb, NULL, hdl);
12630a586ceaSMark Shellenbaum 
12640a586ceaSMark Shellenbaum 	if (buftype == SA_SPILL)
12650a586ceaSMark Shellenbaum 		arc_buf_freeze(((dmu_buf_impl_t *)hdl->sa_spill)->db_buf);
12660a586ceaSMark Shellenbaum }
12670a586ceaSMark Shellenbaum 
12680a586ceaSMark Shellenbaum static int
12690a586ceaSMark Shellenbaum sa_build_index(sa_handle_t *hdl, sa_buf_type_t buftype)
12700a586ceaSMark Shellenbaum {
12710a586ceaSMark Shellenbaum 	sa_hdr_phys_t *sa_hdr_phys;
12720a586ceaSMark Shellenbaum 	dmu_buf_impl_t *db = SA_GET_DB(hdl, buftype);
12730a586ceaSMark Shellenbaum 	dmu_object_type_t bonustype = SA_BONUSTYPE_FROM_DB(db);
12740a586ceaSMark Shellenbaum 	sa_os_t *sa = hdl->sa_os->os_sa;
12750a586ceaSMark Shellenbaum 	sa_idx_tab_t *idx_tab;
12760a586ceaSMark Shellenbaum 
12770a586ceaSMark Shellenbaum 	sa_hdr_phys = SA_GET_HDR(hdl, buftype);
12780a586ceaSMark Shellenbaum 
12790a586ceaSMark Shellenbaum 	mutex_enter(&sa->sa_lock);
12800a586ceaSMark Shellenbaum 
12810a586ceaSMark Shellenbaum 	/* Do we need to byteswap? */
12820a586ceaSMark Shellenbaum 
12830a586ceaSMark Shellenbaum 	/* only check if not old znode */
12840a586ceaSMark Shellenbaum 	if (IS_SA_BONUSTYPE(bonustype) && sa_hdr_phys->sa_magic != SA_MAGIC &&
12850a586ceaSMark Shellenbaum 	    sa_hdr_phys->sa_magic != 0) {
12860a586ceaSMark Shellenbaum 		VERIFY(BSWAP_32(sa_hdr_phys->sa_magic) == SA_MAGIC);
12870a586ceaSMark Shellenbaum 		sa_byteswap(hdl, buftype);
12880a586ceaSMark Shellenbaum 	}
12890a586ceaSMark Shellenbaum 
12900a586ceaSMark Shellenbaum 	idx_tab = sa_find_idx_tab(hdl->sa_os, bonustype, sa_hdr_phys);
12910a586ceaSMark Shellenbaum 
12920a586ceaSMark Shellenbaum 	if (buftype == SA_BONUS)
12930a586ceaSMark Shellenbaum 		hdl->sa_bonus_tab = idx_tab;
12940a586ceaSMark Shellenbaum 	else
12950a586ceaSMark Shellenbaum 		hdl->sa_spill_tab = idx_tab;
12960a586ceaSMark Shellenbaum 
12970a586ceaSMark Shellenbaum 	mutex_exit(&sa->sa_lock);
12980a586ceaSMark Shellenbaum 	return (0);
12990a586ceaSMark Shellenbaum }
13000a586ceaSMark Shellenbaum 
13010a586ceaSMark Shellenbaum /*ARGSUSED*/
1302bc9014e6SJustin Gibbs static void
130340510e8eSJosef 'Jeff' Sipek sa_evict_sync(void *dbu)
13040a586ceaSMark Shellenbaum {
1305bc9014e6SJustin Gibbs 	panic("evicting sa dbuf\n");
13060a586ceaSMark Shellenbaum }
13070a586ceaSMark Shellenbaum 
13080a586ceaSMark Shellenbaum static void
13090a586ceaSMark Shellenbaum sa_idx_tab_rele(objset_t *os, void *arg)
13100a586ceaSMark Shellenbaum {
13110a586ceaSMark Shellenbaum 	sa_os_t *sa = os->os_sa;
13120a586ceaSMark Shellenbaum 	sa_idx_tab_t *idx_tab = arg;
13130a586ceaSMark Shellenbaum 
13140a586ceaSMark Shellenbaum 	if (idx_tab == NULL)
13150a586ceaSMark Shellenbaum 		return;
13160a586ceaSMark Shellenbaum 
13170a586ceaSMark Shellenbaum 	mutex_enter(&sa->sa_lock);
1318*e914ace2STim Schumacher 	if (zfs_refcount_remove(&idx_tab->sa_refcount, NULL) == 0) {
13190a586ceaSMark Shellenbaum 		list_remove(&idx_tab->sa_layout->lot_idx_tab, idx_tab);
13200a586ceaSMark Shellenbaum 		if (idx_tab->sa_variable_lengths)
13210a586ceaSMark Shellenbaum 			kmem_free(idx_tab->sa_variable_lengths,
13220a586ceaSMark Shellenbaum 			    sizeof (uint16_t) *
13230a586ceaSMark Shellenbaum 			    idx_tab->sa_layout->lot_var_sizes);
1324*e914ace2STim Schumacher 		zfs_refcount_destroy(&idx_tab->sa_refcount);
13250a586ceaSMark Shellenbaum 		kmem_free(idx_tab->sa_idx_tab,
13260a586ceaSMark Shellenbaum 		    sizeof (uint32_t) * sa->sa_num_attrs);
13270a586ceaSMark Shellenbaum 		kmem_free(idx_tab, sizeof (sa_idx_tab_t));
13280a586ceaSMark Shellenbaum 	}
13290a586ceaSMark Shellenbaum 	mutex_exit(&sa->sa_lock);
13300a586ceaSMark Shellenbaum }
13310a586ceaSMark Shellenbaum 
13320a586ceaSMark Shellenbaum static void
13330a586ceaSMark Shellenbaum sa_idx_tab_hold(objset_t *os, sa_idx_tab_t *idx_tab)
13340a586ceaSMark Shellenbaum {
13350a586ceaSMark Shellenbaum 	sa_os_t *sa = os->os_sa;
13360a586ceaSMark Shellenbaum 
13370a586ceaSMark Shellenbaum 	ASSERT(MUTEX_HELD(&sa->sa_lock));
1338*e914ace2STim Schumacher 	(void) zfs_refcount_add(&idx_tab->sa_refcount, NULL);
13390a586ceaSMark Shellenbaum }
13400a586ceaSMark Shellenbaum 
13410a586ceaSMark Shellenbaum void
13420a586ceaSMark Shellenbaum sa_handle_destroy(sa_handle_t *hdl)
13430a586ceaSMark Shellenbaum {
1344bc9014e6SJustin Gibbs 	dmu_buf_t *db = hdl->sa_bonus;
1345bc9014e6SJustin Gibbs 
13460a586ceaSMark Shellenbaum 	mutex_enter(&hdl->sa_lock);
1347bc9014e6SJustin Gibbs 	(void) dmu_buf_remove_user(db, &hdl->sa_dbu);
13480a586ceaSMark Shellenbaum 
13490fda3cc5SJustin T. Gibbs 	if (hdl->sa_bonus_tab)
13500a586ceaSMark Shellenbaum 		sa_idx_tab_rele(hdl->sa_os, hdl->sa_bonus_tab);
13510fda3cc5SJustin T. Gibbs 
13520fda3cc5SJustin T. Gibbs 	if (hdl->sa_spill_tab)
13530a586ceaSMark Shellenbaum 		sa_idx_tab_rele(hdl->sa_os, hdl->sa_spill_tab);
13540a586ceaSMark Shellenbaum 
13550a586ceaSMark Shellenbaum 	dmu_buf_rele(hdl->sa_bonus, NULL);
13560a586ceaSMark Shellenbaum 
13570a586ceaSMark Shellenbaum 	if (hdl->sa_spill)
13580a586ceaSMark Shellenbaum 		dmu_buf_rele((dmu_buf_t *)hdl->sa_spill, NULL);
13590a586ceaSMark Shellenbaum 	mutex_exit(&hdl->sa_lock);
13600a586ceaSMark Shellenbaum 
13610a586ceaSMark Shellenbaum 	kmem_cache_free(sa_cache, hdl);
13620a586ceaSMark Shellenbaum }
13630a586ceaSMark Shellenbaum 
13640a586ceaSMark Shellenbaum int
13650a586ceaSMark Shellenbaum sa_handle_get_from_db(objset_t *os, dmu_buf_t *db, void *userp,
13660a586ceaSMark Shellenbaum     sa_handle_type_t hdl_type, sa_handle_t **handlepp)
13670a586ceaSMark Shellenbaum {
13680a586ceaSMark Shellenbaum 	int error = 0;
13690a586ceaSMark Shellenbaum 	dmu_object_info_t doi;
1370bc9014e6SJustin Gibbs 	sa_handle_t *handle = NULL;
13710a586ceaSMark Shellenbaum 
13720a586ceaSMark Shellenbaum #ifdef ZFS_DEBUG
13730a586ceaSMark Shellenbaum 	dmu_object_info_from_db(db, &doi);
13740a586ceaSMark Shellenbaum 	ASSERT(doi.doi_bonus_type == DMU_OT_SA ||
13750a586ceaSMark Shellenbaum 	    doi.doi_bonus_type == DMU_OT_ZNODE);
13760a586ceaSMark Shellenbaum #endif
13770a586ceaSMark Shellenbaum 	/* find handle, if it exists */
13780a586ceaSMark Shellenbaum 	/* if one doesn't exist then create a new one, and initialize it */
13790a586ceaSMark Shellenbaum 
1380bc9014e6SJustin Gibbs 	if (hdl_type == SA_HDL_SHARED)
1381bc9014e6SJustin Gibbs 		handle = dmu_buf_get_user(db);
1382bc9014e6SJustin Gibbs 
13830a586ceaSMark Shellenbaum 	if (handle == NULL) {
1384bc9014e6SJustin Gibbs 		sa_handle_t *winner = NULL;
1385bc9014e6SJustin Gibbs 
13860a586ceaSMark Shellenbaum 		handle = kmem_cache_alloc(sa_cache, KM_SLEEP);
138740510e8eSJosef 'Jeff' Sipek 		handle->sa_dbu.dbu_evict_func_sync = NULL;
138840510e8eSJosef 'Jeff' Sipek 		handle->sa_dbu.dbu_evict_func_async = NULL;
13890a586ceaSMark Shellenbaum 		handle->sa_userp = userp;
13900a586ceaSMark Shellenbaum 		handle->sa_bonus = db;
13910a586ceaSMark Shellenbaum 		handle->sa_os = os;
13920a586ceaSMark Shellenbaum 		handle->sa_spill = NULL;
13930fda3cc5SJustin T. Gibbs 		handle->sa_bonus_tab = NULL;
13940fda3cc5SJustin T. Gibbs 		handle->sa_spill_tab = NULL;
13950a586ceaSMark Shellenbaum 
13960a586ceaSMark Shellenbaum 		error = sa_build_index(handle, SA_BONUS);
13970a586ceaSMark Shellenbaum 
1398bc9014e6SJustin Gibbs 		if (hdl_type == SA_HDL_SHARED) {
139940510e8eSJosef 'Jeff' Sipek 			dmu_buf_init_user(&handle->sa_dbu, sa_evict_sync, NULL,
140040510e8eSJosef 'Jeff' Sipek 			    NULL);
1401bc9014e6SJustin Gibbs 			winner = dmu_buf_set_user_ie(db, &handle->sa_dbu);
1402bc9014e6SJustin Gibbs 		}
1403bc9014e6SJustin Gibbs 
1404bc9014e6SJustin Gibbs 		if (winner != NULL) {
14050a586ceaSMark Shellenbaum 			kmem_cache_free(sa_cache, handle);
1406bc9014e6SJustin Gibbs 			handle = winner;
14070a586ceaSMark Shellenbaum 		}
14080a586ceaSMark Shellenbaum 	}
14090a586ceaSMark Shellenbaum 	*handlepp = handle;
14100a586ceaSMark Shellenbaum 
14110a586ceaSMark Shellenbaum 	return (error);
14120a586ceaSMark Shellenbaum }
14130a586ceaSMark Shellenbaum 
14140a586ceaSMark Shellenbaum int
14150a586ceaSMark Shellenbaum sa_handle_get(objset_t *objset, uint64_t objid, void *userp,
14160a586ceaSMark Shellenbaum     sa_handle_type_t hdl_type, sa_handle_t **handlepp)
14170a586ceaSMark Shellenbaum {
14180a586ceaSMark Shellenbaum 	dmu_buf_t *db;
14190a586ceaSMark Shellenbaum 	int error;
14200a586ceaSMark Shellenbaum 
14210a586ceaSMark Shellenbaum 	if (error = dmu_bonus_hold(objset, objid, NULL, &db))
14220a586ceaSMark Shellenbaum 		return (error);
14230a586ceaSMark Shellenbaum 
14240a586ceaSMark Shellenbaum 	return (sa_handle_get_from_db(objset, db, userp, hdl_type,
14250a586ceaSMark Shellenbaum 	    handlepp));
14260a586ceaSMark Shellenbaum }
14270a586ceaSMark Shellenbaum 
14280a586ceaSMark Shellenbaum int
14290a586ceaSMark Shellenbaum sa_buf_hold(objset_t *objset, uint64_t obj_num, void *tag, dmu_buf_t **db)
14300a586ceaSMark Shellenbaum {
14310a586ceaSMark Shellenbaum 	return (dmu_bonus_hold(objset, obj_num, tag, db));
14320a586ceaSMark Shellenbaum }
14330a586ceaSMark Shellenbaum 
14340a586ceaSMark Shellenbaum void
14350a586ceaSMark Shellenbaum sa_buf_rele(dmu_buf_t *db, void *tag)
14360a586ceaSMark Shellenbaum {
14370a586ceaSMark Shellenbaum 	dmu_buf_rele(db, tag);
14380a586ceaSMark Shellenbaum }
14390a586ceaSMark Shellenbaum 
14400a586ceaSMark Shellenbaum int
14410a586ceaSMark Shellenbaum sa_lookup_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count)
14420a586ceaSMark Shellenbaum {
14430a586ceaSMark Shellenbaum 	ASSERT(hdl);
14440a586ceaSMark Shellenbaum 	ASSERT(MUTEX_HELD(&hdl->sa_lock));
14450a586ceaSMark Shellenbaum 	return (sa_attr_op(hdl, bulk, count, SA_LOOKUP, NULL));
14460a586ceaSMark Shellenbaum }
14470a586ceaSMark Shellenbaum 
14480a586ceaSMark Shellenbaum int
14490a586ceaSMark Shellenbaum sa_lookup(sa_handle_t *hdl, sa_attr_type_t attr, void *buf, uint32_t buflen)
14500a586ceaSMark Shellenbaum {
14510a586ceaSMark Shellenbaum 	int error;
14520a586ceaSMark Shellenbaum 	sa_bulk_attr_t bulk;
14530a586ceaSMark Shellenbaum 
14540a586ceaSMark Shellenbaum 	bulk.sa_attr = attr;
14550a586ceaSMark Shellenbaum 	bulk.sa_data = buf;
14560a586ceaSMark Shellenbaum 	bulk.sa_length = buflen;
14570a586ceaSMark Shellenbaum 	bulk.sa_data_func = NULL;
14580a586ceaSMark Shellenbaum 
14590a586ceaSMark Shellenbaum 	ASSERT(hdl);
14600a586ceaSMark Shellenbaum 	mutex_enter(&hdl->sa_lock);
14610a586ceaSMark Shellenbaum 	error = sa_lookup_impl(hdl, &bulk, 1);
14620a586ceaSMark Shellenbaum 	mutex_exit(&hdl->sa_lock);
14630a586ceaSMark Shellenbaum 	return (error);
14640a586ceaSMark Shellenbaum }
14650a586ceaSMark Shellenbaum 
14660a586ceaSMark Shellenbaum #ifdef _KERNEL
14670a586ceaSMark Shellenbaum int
14680a586ceaSMark Shellenbaum sa_lookup_uio(sa_handle_t *hdl, sa_attr_type_t attr, uio_t *uio)
14690a586ceaSMark Shellenbaum {
14700a586ceaSMark Shellenbaum 	int error;
14710a586ceaSMark Shellenbaum 	sa_bulk_attr_t bulk;
14720a586ceaSMark Shellenbaum 
14730a586ceaSMark Shellenbaum 	bulk.sa_data = NULL;
14740a586ceaSMark Shellenbaum 	bulk.sa_attr = attr;
14750a586ceaSMark Shellenbaum 	bulk.sa_data_func = NULL;
14760a586ceaSMark Shellenbaum 
14770a586ceaSMark Shellenbaum 	ASSERT(hdl);
14780a586ceaSMark Shellenbaum 
14790a586ceaSMark Shellenbaum 	mutex_enter(&hdl->sa_lock);
14801d8ccc7bSMark Shellenbaum 	if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) == 0) {
14810a586ceaSMark Shellenbaum 		error = uiomove((void *)bulk.sa_addr, MIN(bulk.sa_size,
14820a586ceaSMark Shellenbaum 		    uio->uio_resid), UIO_READ, uio);
14830a586ceaSMark Shellenbaum 	}
14840a586ceaSMark Shellenbaum 	mutex_exit(&hdl->sa_lock);
14850a586ceaSMark Shellenbaum 	return (error);
14860a586ceaSMark Shellenbaum 
14870a586ceaSMark Shellenbaum }
14880a586ceaSMark Shellenbaum #endif
14890a586ceaSMark Shellenbaum 
14907f0bdb42SMatthew Ahrens static sa_idx_tab_t *
14917f0bdb42SMatthew Ahrens sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype, sa_hdr_phys_t *hdr)
14920a586ceaSMark Shellenbaum {
14930a586ceaSMark Shellenbaum 	sa_idx_tab_t *idx_tab;
14940a586ceaSMark Shellenbaum 	sa_os_t *sa = os->os_sa;
14950a586ceaSMark Shellenbaum 	sa_lot_t *tb, search;
14960a586ceaSMark Shellenbaum 	avl_index_t loc;
14970a586ceaSMark Shellenbaum 
14980a586ceaSMark Shellenbaum 	/*
14990a586ceaSMark Shellenbaum 	 * Deterimine layout number.  If SA node and header == 0 then
15000a586ceaSMark Shellenbaum 	 * force the index table to the dummy "1" empty layout.
15010a586ceaSMark Shellenbaum 	 *
15020a586ceaSMark Shellenbaum 	 * The layout number would only be zero for a newly created file
15030a586ceaSMark Shellenbaum 	 * that has not added any attributes yet, or with crypto enabled which
15040a586ceaSMark Shellenbaum 	 * doesn't write any attributes to the bonus buffer.
15050a586ceaSMark Shellenbaum 	 */
15060a586ceaSMark Shellenbaum 
15070a586ceaSMark Shellenbaum 	search.lot_num = SA_LAYOUT_NUM(hdr, bonustype);
15080a586ceaSMark Shellenbaum 
15090a586ceaSMark Shellenbaum 	tb = avl_find(&sa->sa_layout_num_tree, &search, &loc);
15100a586ceaSMark Shellenbaum 
15110a586ceaSMark Shellenbaum 	/* Verify header size is consistent with layout information */
15120a586ceaSMark Shellenbaum 	ASSERT(tb);
15130a586ceaSMark Shellenbaum 	ASSERT(IS_SA_BONUSTYPE(bonustype) &&
15140a586ceaSMark Shellenbaum 	    SA_HDR_SIZE_MATCH_LAYOUT(hdr, tb) || !IS_SA_BONUSTYPE(bonustype) ||
15150a586ceaSMark Shellenbaum 	    (IS_SA_BONUSTYPE(bonustype) && hdr->sa_layout_info == 0));
15160a586ceaSMark Shellenbaum 
15170a586ceaSMark Shellenbaum 	/*
15180a586ceaSMark Shellenbaum 	 * See if any of the already existing TOC entries can be reused?
15190a586ceaSMark Shellenbaum 	 */
15200a586ceaSMark Shellenbaum 
15210a586ceaSMark Shellenbaum 	for (idx_tab = list_head(&tb->lot_idx_tab); idx_tab;
15220a586ceaSMark Shellenbaum 	    idx_tab = list_next(&tb->lot_idx_tab, idx_tab)) {
15230a586ceaSMark Shellenbaum 		boolean_t valid_idx = B_TRUE;
15240a586ceaSMark Shellenbaum 		int i;
15250a586ceaSMark Shellenbaum 
15260a586ceaSMark Shellenbaum 		if (tb->lot_var_sizes != 0 &&
15270a586ceaSMark Shellenbaum 		    idx_tab->sa_variable_lengths != NULL) {
15280a586ceaSMark Shellenbaum 			for (i = 0; i != tb->lot_var_sizes; i++) {
15290a586ceaSMark Shellenbaum 				if (hdr->sa_lengths[i] !=
15300a586ceaSMark Shellenbaum 				    idx_tab->sa_variable_lengths[i]) {
15310a586ceaSMark Shellenbaum 					valid_idx = B_FALSE;
15320a586ceaSMark Shellenbaum 					break;
15330a586ceaSMark Shellenbaum 				}
15340a586ceaSMark Shellenbaum 			}
15350a586ceaSMark Shellenbaum 		}
15360a586ceaSMark Shellenbaum 		if (valid_idx) {
15370a586ceaSMark Shellenbaum 			sa_idx_tab_hold(os, idx_tab);
15380a586ceaSMark Shellenbaum 			return (idx_tab);
15390a586ceaSMark Shellenbaum 		}
15400a586ceaSMark Shellenbaum 	}
15410a586ceaSMark Shellenbaum 
15420a586ceaSMark Shellenbaum 	/* No such luck, create a new entry */
15430a586ceaSMark Shellenbaum 	idx_tab = kmem_zalloc(sizeof (sa_idx_tab_t), KM_SLEEP);
15440a586ceaSMark Shellenbaum 	idx_tab->sa_idx_tab =
15450a586ceaSMark Shellenbaum 	    kmem_zalloc(sizeof (uint32_t) * sa->sa_num_attrs, KM_SLEEP);
15460a586ceaSMark Shellenbaum 	idx_tab->sa_layout = tb;
1547*e914ace2STim Schumacher 	zfs_refcount_create(&idx_tab->sa_refcount);
15480a586ceaSMark Shellenbaum 	if (tb->lot_var_sizes)
15490a586ceaSMark Shellenbaum 		idx_tab->sa_variable_lengths = kmem_alloc(sizeof (uint16_t) *
15500a586ceaSMark Shellenbaum 		    tb->lot_var_sizes, KM_SLEEP);
15510a586ceaSMark Shellenbaum 
15520a586ceaSMark Shellenbaum 	sa_attr_iter(os, hdr, bonustype, sa_build_idx_tab,
15530a586ceaSMark Shellenbaum 	    tb, idx_tab);
15540a586ceaSMark Shellenbaum 	sa_idx_tab_hold(os, idx_tab);   /* one hold for consumer */
15550a586ceaSMark Shellenbaum 	sa_idx_tab_hold(os, idx_tab);	/* one for layout */
15560a586ceaSMark Shellenbaum 	list_insert_tail(&tb->lot_idx_tab, idx_tab);
15570a586ceaSMark Shellenbaum 	return (idx_tab);
15580a586ceaSMark Shellenbaum }
15590a586ceaSMark Shellenbaum 
15600a586ceaSMark Shellenbaum void
15610a586ceaSMark Shellenbaum sa_default_locator(void **dataptr, uint32_t *len, uint32_t total_len,
15620a586ceaSMark Shellenbaum     boolean_t start, void *userdata)
15630a586ceaSMark Shellenbaum {
15640a586ceaSMark Shellenbaum 	ASSERT(start);
15650a586ceaSMark Shellenbaum 
15660a586ceaSMark Shellenbaum 	*dataptr = userdata;
15670a586ceaSMark Shellenbaum 	*len = total_len;
15680a586ceaSMark Shellenbaum }
15690a586ceaSMark Shellenbaum 
15700a586ceaSMark Shellenbaum static void
15710a586ceaSMark Shellenbaum sa_attr_register_sync(sa_handle_t *hdl, dmu_tx_t *tx)
15720a586ceaSMark Shellenbaum {
15730a586ceaSMark Shellenbaum 	uint64_t attr_value = 0;
15740a586ceaSMark Shellenbaum 	sa_os_t *sa = hdl->sa_os->os_sa;
15750a586ceaSMark Shellenbaum 	sa_attr_table_t *tb = sa->sa_attr_table;
15760a586ceaSMark Shellenbaum 	int i;
15770a586ceaSMark Shellenbaum 
15780a586ceaSMark Shellenbaum 	mutex_enter(&sa->sa_lock);
15790a586ceaSMark Shellenbaum 
15800a586ceaSMark Shellenbaum 	if (!sa->sa_need_attr_registration || sa->sa_master_obj == NULL) {
15810a586ceaSMark Shellenbaum 		mutex_exit(&sa->sa_lock);
15820a586ceaSMark Shellenbaum 		return;
15830a586ceaSMark Shellenbaum 	}
15840a586ceaSMark Shellenbaum 
15850a586ceaSMark Shellenbaum 	if (sa->sa_reg_attr_obj == NULL) {
1586ad135b5dSChristopher Siden 		sa->sa_reg_attr_obj = zap_create_link(hdl->sa_os,
1587ad135b5dSChristopher Siden 		    DMU_OT_SA_ATTR_REGISTRATION,
1588ad135b5dSChristopher Siden 		    sa->sa_master_obj, SA_REGISTRY, tx);
15890a586ceaSMark Shellenbaum 	}
15900a586ceaSMark Shellenbaum 	for (i = 0; i != sa->sa_num_attrs; i++) {
15910a586ceaSMark Shellenbaum 		if (sa->sa_attr_table[i].sa_registered)
15920a586ceaSMark Shellenbaum 			continue;
15930a586ceaSMark Shellenbaum 		ATTR_ENCODE(attr_value, tb[i].sa_attr, tb[i].sa_length,
15940a586ceaSMark Shellenbaum 		    tb[i].sa_byteswap);
15950a586ceaSMark Shellenbaum 		VERIFY(0 == zap_update(hdl->sa_os, sa->sa_reg_attr_obj,
15960a586ceaSMark Shellenbaum 		    tb[i].sa_name, 8, 1, &attr_value, tx));
15970a586ceaSMark Shellenbaum 		tb[i].sa_registered = B_TRUE;
15980a586ceaSMark Shellenbaum 	}
15990a586ceaSMark Shellenbaum 	sa->sa_need_attr_registration = B_FALSE;
16000a586ceaSMark Shellenbaum 	mutex_exit(&sa->sa_lock);
16010a586ceaSMark Shellenbaum }
16020a586ceaSMark Shellenbaum 
16030a586ceaSMark Shellenbaum /*
16040a586ceaSMark Shellenbaum  * Replace all attributes with attributes specified in template.
16050a586ceaSMark Shellenbaum  * If dnode had a spill buffer then those attributes will be
16060a586ceaSMark Shellenbaum  * also be replaced, possibly with just an empty spill block
16070a586ceaSMark Shellenbaum  *
16080a586ceaSMark Shellenbaum  * This interface is intended to only be used for bulk adding of
16090a586ceaSMark Shellenbaum  * attributes for a new file.  It will also be used by the ZPL
16100a586ceaSMark Shellenbaum  * when converting and old formatted znode to native SA support.
16110a586ceaSMark Shellenbaum  */
16120a586ceaSMark Shellenbaum int
16130a586ceaSMark Shellenbaum sa_replace_all_by_template_locked(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc,
16140a586ceaSMark Shellenbaum     int attr_count, dmu_tx_t *tx)
16150a586ceaSMark Shellenbaum {
16160a586ceaSMark Shellenbaum 	sa_os_t *sa = hdl->sa_os->os_sa;
16170a586ceaSMark Shellenbaum 
16180a586ceaSMark Shellenbaum 	if (sa->sa_need_attr_registration)
16190a586ceaSMark Shellenbaum 		sa_attr_register_sync(hdl, tx);
16200a586ceaSMark Shellenbaum 	return (sa_build_layouts(hdl, attr_desc, attr_count, tx));
16210a586ceaSMark Shellenbaum }
16220a586ceaSMark Shellenbaum 
16230a586ceaSMark Shellenbaum int
16240a586ceaSMark Shellenbaum sa_replace_all_by_template(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc,
16250a586ceaSMark Shellenbaum     int attr_count, dmu_tx_t *tx)
16260a586ceaSMark Shellenbaum {
16270a586ceaSMark Shellenbaum 	int error;
16280a586ceaSMark Shellenbaum 
16290a586ceaSMark Shellenbaum 	mutex_enter(&hdl->sa_lock);
16300a586ceaSMark Shellenbaum 	error = sa_replace_all_by_template_locked(hdl, attr_desc,
16310a586ceaSMark Shellenbaum 	    attr_count, tx);
16320a586ceaSMark Shellenbaum 	mutex_exit(&hdl->sa_lock);
16330a586ceaSMark Shellenbaum 	return (error);
16340a586ceaSMark Shellenbaum }
16350a586ceaSMark Shellenbaum 
16360a586ceaSMark Shellenbaum /*
1637e7e978b1SAndriy Gapon  * Add/remove a single attribute or replace a variable-sized attribute value
1638e7e978b1SAndriy Gapon  * with a value of a different size, and then rewrite the entire set
16390a586ceaSMark Shellenbaum  * of attributes.
1640e7e978b1SAndriy Gapon  * Same-length attribute value replacement (including fixed-length attributes)
1641e7e978b1SAndriy Gapon  * is handled more efficiently by the upper layers.
16420a586ceaSMark Shellenbaum  */
16430a586ceaSMark Shellenbaum static int
16440a586ceaSMark Shellenbaum sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr,
16450a586ceaSMark Shellenbaum     sa_data_op_t action, sa_data_locator_t *locator, void *datastart,
16460a586ceaSMark Shellenbaum     uint16_t buflen, dmu_tx_t *tx)
16470a586ceaSMark Shellenbaum {
16480a586ceaSMark Shellenbaum 	sa_os_t *sa = hdl->sa_os->os_sa;
1649744947dcSTom Erickson 	dmu_buf_impl_t *db = (dmu_buf_impl_t *)hdl->sa_bonus;
1650744947dcSTom Erickson 	dnode_t *dn;
16510a586ceaSMark Shellenbaum 	sa_bulk_attr_t *attr_desc;
16520a586ceaSMark Shellenbaum 	void *old_data[2];
16530a586ceaSMark Shellenbaum 	int bonus_attr_count = 0;
1654d5285caeSGeorge Wilson 	int bonus_data_size = 0;
1655d5285caeSGeorge Wilson 	int spill_data_size = 0;
16560a586ceaSMark Shellenbaum 	int spill_attr_count = 0;
16570a586ceaSMark Shellenbaum 	int error;
1658e7e978b1SAndriy Gapon 	uint16_t length, reg_length;
16590a586ceaSMark Shellenbaum 	int i, j, k, length_idx;
16600a586ceaSMark Shellenbaum 	sa_hdr_phys_t *hdr;
16610a586ceaSMark Shellenbaum 	sa_idx_tab_t *idx_tab;
16620a586ceaSMark Shellenbaum 	int attr_count;
16630a586ceaSMark Shellenbaum 	int count;
16640a586ceaSMark Shellenbaum 
16650a586ceaSMark Shellenbaum 	ASSERT(MUTEX_HELD(&hdl->sa_lock));
16660a586ceaSMark Shellenbaum 
16670a586ceaSMark Shellenbaum 	/* First make of copy of the old data */
16680a586ceaSMark Shellenbaum 
1669744947dcSTom Erickson 	DB_DNODE_ENTER(db);
1670744947dcSTom Erickson 	dn = DB_DNODE(db);
1671744947dcSTom Erickson 	if (dn->dn_bonuslen != 0) {
16720a586ceaSMark Shellenbaum 		bonus_data_size = hdl->sa_bonus->db_size;
16730a586ceaSMark Shellenbaum 		old_data[0] = kmem_alloc(bonus_data_size, KM_SLEEP);
16740a586ceaSMark Shellenbaum 		bcopy(hdl->sa_bonus->db_data, old_data[0],
16750a586ceaSMark Shellenbaum 		    hdl->sa_bonus->db_size);
16760a586ceaSMark Shellenbaum 		bonus_attr_count = hdl->sa_bonus_tab->sa_layout->lot_attr_count;
16770a586ceaSMark Shellenbaum 	} else {
16780a586ceaSMark Shellenbaum 		old_data[0] = NULL;
16790a586ceaSMark Shellenbaum 	}
1680744947dcSTom Erickson 	DB_DNODE_EXIT(db);
16810a586ceaSMark Shellenbaum 
16820a586ceaSMark Shellenbaum 	/* Bring spill buffer online if it isn't currently */
16830a586ceaSMark Shellenbaum 
16841d8ccc7bSMark Shellenbaum 	if ((error = sa_get_spill(hdl)) == 0) {
16850a586ceaSMark Shellenbaum 		spill_data_size = hdl->sa_spill->db_size;
16860a586ceaSMark Shellenbaum 		old_data[1] = kmem_alloc(spill_data_size, KM_SLEEP);
16870a586ceaSMark Shellenbaum 		bcopy(hdl->sa_spill->db_data, old_data[1],
16880a586ceaSMark Shellenbaum 		    hdl->sa_spill->db_size);
16890a586ceaSMark Shellenbaum 		spill_attr_count =
16900a586ceaSMark Shellenbaum 		    hdl->sa_spill_tab->sa_layout->lot_attr_count;
16911d8ccc7bSMark Shellenbaum 	} else if (error && error != ENOENT) {
16921d8ccc7bSMark Shellenbaum 		if (old_data[0])
16931d8ccc7bSMark Shellenbaum 			kmem_free(old_data[0], bonus_data_size);
16941d8ccc7bSMark Shellenbaum 		return (error);
16950a586ceaSMark Shellenbaum 	} else {
16960a586ceaSMark Shellenbaum 		old_data[1] = NULL;
16970a586ceaSMark Shellenbaum 	}
16980a586ceaSMark Shellenbaum 
16990a586ceaSMark Shellenbaum 	/* build descriptor of all attributes */
17000a586ceaSMark Shellenbaum 
17010a586ceaSMark Shellenbaum 	attr_count = bonus_attr_count + spill_attr_count;
17020a586ceaSMark Shellenbaum 	if (action == SA_ADD)
17030a586ceaSMark Shellenbaum 		attr_count++;
17040a586ceaSMark Shellenbaum 	else if (action == SA_REMOVE)
17050a586ceaSMark Shellenbaum 		attr_count--;
17060a586ceaSMark Shellenbaum 
17070a586ceaSMark Shellenbaum 	attr_desc = kmem_zalloc(sizeof (sa_bulk_attr_t) * attr_count, KM_SLEEP);
17080a586ceaSMark Shellenbaum 
17090a586ceaSMark Shellenbaum 	/*
17100a586ceaSMark Shellenbaum 	 * loop through bonus and spill buffer if it exists, and
17110a586ceaSMark Shellenbaum 	 * build up new attr_descriptor to reset the attributes
17120a586ceaSMark Shellenbaum 	 */
17130a586ceaSMark Shellenbaum 	k = j = 0;
17140a586ceaSMark Shellenbaum 	count = bonus_attr_count;
17150a586ceaSMark Shellenbaum 	hdr = SA_GET_HDR(hdl, SA_BONUS);
17160a586ceaSMark Shellenbaum 	idx_tab = SA_IDX_TAB_GET(hdl, SA_BONUS);
17170a586ceaSMark Shellenbaum 	for (; k != 2; k++) {
1718e7e978b1SAndriy Gapon 		/*
1719e7e978b1SAndriy Gapon 		 * Iterate over each attribute in layout.  Fetch the
1720e7e978b1SAndriy Gapon 		 * size of variable-length attributes needing rewrite
1721e7e978b1SAndriy Gapon 		 * from sa_lengths[].
1722e7e978b1SAndriy Gapon 		 */
17230a586ceaSMark Shellenbaum 		for (i = 0, length_idx = 0; i != count; i++) {
17240a586ceaSMark Shellenbaum 			sa_attr_type_t attr;
17250a586ceaSMark Shellenbaum 
17260a586ceaSMark Shellenbaum 			attr = idx_tab->sa_layout->lot_attrs[i];
1727e7e978b1SAndriy Gapon 			reg_length = SA_REGISTERED_LEN(sa, attr);
1728e7e978b1SAndriy Gapon 			if (reg_length == 0) {
1729e7e978b1SAndriy Gapon 				length = hdr->sa_lengths[length_idx];
1730e7e978b1SAndriy Gapon 				length_idx++;
1731e7e978b1SAndriy Gapon 			} else {
1732e7e978b1SAndriy Gapon 				length = reg_length;
1733e7e978b1SAndriy Gapon 			}
17340a586ceaSMark Shellenbaum 			if (attr == newattr) {
1735e7e978b1SAndriy Gapon 				/*
1736e7e978b1SAndriy Gapon 				 * There is nothing to do for SA_REMOVE,
1737e7e978b1SAndriy Gapon 				 * so it is just skipped.
1738e7e978b1SAndriy Gapon 				 */
1739e7e978b1SAndriy Gapon 				if (action == SA_REMOVE)
17400a586ceaSMark Shellenbaum 					continue;
1741e7e978b1SAndriy Gapon 
1742e7e978b1SAndriy Gapon 				/*
1743e7e978b1SAndriy Gapon 				 * Duplicate attributes are not allowed, so the
1744e7e978b1SAndriy Gapon 				 * action can not be SA_ADD here.
1745e7e978b1SAndriy Gapon 				 */
1746e7e978b1SAndriy Gapon 				ASSERT3S(action, ==, SA_REPLACE);
1747e7e978b1SAndriy Gapon 
1748e7e978b1SAndriy Gapon 				/*
1749e7e978b1SAndriy Gapon 				 * Only a variable-sized attribute can be
1750e7e978b1SAndriy Gapon 				 * replaced here, and its size must be changing.
1751e7e978b1SAndriy Gapon 				 */
1752e7e978b1SAndriy Gapon 				ASSERT3U(reg_length, ==, 0);
1753e7e978b1SAndriy Gapon 				ASSERT3U(length, !=, buflen);
17540a586ceaSMark Shellenbaum 				SA_ADD_BULK_ATTR(attr_desc, j, attr,
17550a586ceaSMark Shellenbaum 				    locator, datastart, buflen);
17560a586ceaSMark Shellenbaum 			} else {
17570a586ceaSMark Shellenbaum 				SA_ADD_BULK_ATTR(attr_desc, j, attr,
17580a586ceaSMark Shellenbaum 				    NULL, (void *)
17590a586ceaSMark Shellenbaum 				    (TOC_OFF(idx_tab->sa_idx_tab[attr]) +
17600a586ceaSMark Shellenbaum 				    (uintptr_t)old_data[k]), length);
17610a586ceaSMark Shellenbaum 			}
17620a586ceaSMark Shellenbaum 		}
17630a586ceaSMark Shellenbaum 		if (k == 0 && hdl->sa_spill) {
17640a586ceaSMark Shellenbaum 			hdr = SA_GET_HDR(hdl, SA_SPILL);
17650a586ceaSMark Shellenbaum 			idx_tab = SA_IDX_TAB_GET(hdl, SA_SPILL);
17660a586ceaSMark Shellenbaum 			count = spill_attr_count;
17670a586ceaSMark Shellenbaum 		} else {
17680a586ceaSMark Shellenbaum 			break;
17690a586ceaSMark Shellenbaum 		}
17700a586ceaSMark Shellenbaum 	}
17710a586ceaSMark Shellenbaum 	if (action == SA_ADD) {
1772e7e978b1SAndriy Gapon 		reg_length = SA_REGISTERED_LEN(sa, newattr);
1773e7e978b1SAndriy Gapon 		IMPLY(reg_length != 0, reg_length == buflen);
17740a586ceaSMark Shellenbaum 		SA_ADD_BULK_ATTR(attr_desc, j, newattr, locator,
17750a586ceaSMark Shellenbaum 		    datastart, buflen);
17760a586ceaSMark Shellenbaum 	}
1777e7e978b1SAndriy Gapon 	ASSERT3U(j, ==, attr_count);
17780a586ceaSMark Shellenbaum 
17790a586ceaSMark Shellenbaum 	error = sa_build_layouts(hdl, attr_desc, attr_count, tx);
17800a586ceaSMark Shellenbaum 
17810a586ceaSMark Shellenbaum 	if (old_data[0])
17820a586ceaSMark Shellenbaum 		kmem_free(old_data[0], bonus_data_size);
17830a586ceaSMark Shellenbaum 	if (old_data[1])
17840a586ceaSMark Shellenbaum 		kmem_free(old_data[1], spill_data_size);
17850a586ceaSMark Shellenbaum 	kmem_free(attr_desc, sizeof (sa_bulk_attr_t) * attr_count);
17860a586ceaSMark Shellenbaum 
17870a586ceaSMark Shellenbaum 	return (error);
17880a586ceaSMark Shellenbaum }
17890a586ceaSMark Shellenbaum 
17900a586ceaSMark Shellenbaum static int
17910a586ceaSMark Shellenbaum sa_bulk_update_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count,
17920a586ceaSMark Shellenbaum     dmu_tx_t *tx)
17930a586ceaSMark Shellenbaum {
17940a586ceaSMark Shellenbaum 	int error;
17950a586ceaSMark Shellenbaum 	sa_os_t *sa = hdl->sa_os->os_sa;
17960a586ceaSMark Shellenbaum 	dmu_object_type_t bonustype;
17970a586ceaSMark Shellenbaum 
17980a586ceaSMark Shellenbaum 	bonustype = SA_BONUSTYPE_FROM_DB(SA_GET_DB(hdl, SA_BONUS));
17990a586ceaSMark Shellenbaum 
18000a586ceaSMark Shellenbaum 	ASSERT(hdl);
18010a586ceaSMark Shellenbaum 	ASSERT(MUTEX_HELD(&hdl->sa_lock));
18020a586ceaSMark Shellenbaum 
18030a586ceaSMark Shellenbaum 	/* sync out registration table if necessary */
18040a586ceaSMark Shellenbaum 	if (sa->sa_need_attr_registration)
18050a586ceaSMark Shellenbaum 		sa_attr_register_sync(hdl, tx);
18060a586ceaSMark Shellenbaum 
18070a586ceaSMark Shellenbaum 	error = sa_attr_op(hdl, bulk, count, SA_UPDATE, tx);
18080a586ceaSMark Shellenbaum 	if (error == 0 && !IS_SA_BONUSTYPE(bonustype) && sa->sa_update_cb)
18090a586ceaSMark Shellenbaum 		sa->sa_update_cb(hdl, tx);
18100a586ceaSMark Shellenbaum 
18110a586ceaSMark Shellenbaum 	return (error);
18120a586ceaSMark Shellenbaum }
18130a586ceaSMark Shellenbaum 
18140a586ceaSMark Shellenbaum /*
18150a586ceaSMark Shellenbaum  * update or add new attribute
18160a586ceaSMark Shellenbaum  */
18170a586ceaSMark Shellenbaum int
18180a586ceaSMark Shellenbaum sa_update(sa_handle_t *hdl, sa_attr_type_t type,
18190a586ceaSMark Shellenbaum     void *buf, uint32_t buflen, dmu_tx_t *tx)
18200a586ceaSMark Shellenbaum {
18210a586ceaSMark Shellenbaum 	int error;
18220a586ceaSMark Shellenbaum 	sa_bulk_attr_t bulk;
18230a586ceaSMark Shellenbaum 
18240a586ceaSMark Shellenbaum 	bulk.sa_attr = type;
18250a586ceaSMark Shellenbaum 	bulk.sa_data_func = NULL;
18260a586ceaSMark Shellenbaum 	bulk.sa_length = buflen;
18270a586ceaSMark Shellenbaum 	bulk.sa_data = buf;
18280a586ceaSMark Shellenbaum 
18290a586ceaSMark Shellenbaum 	mutex_enter(&hdl->sa_lock);
18300a586ceaSMark Shellenbaum 	error = sa_bulk_update_impl(hdl, &bulk, 1, tx);
18310a586ceaSMark Shellenbaum 	mutex_exit(&hdl->sa_lock);
18320a586ceaSMark Shellenbaum 	return (error);
18330a586ceaSMark Shellenbaum }
18340a586ceaSMark Shellenbaum 
18350a586ceaSMark Shellenbaum int
18360a586ceaSMark Shellenbaum sa_update_from_cb(sa_handle_t *hdl, sa_attr_type_t attr,
18370a586ceaSMark Shellenbaum     uint32_t buflen, sa_data_locator_t *locator, void *userdata, dmu_tx_t *tx)
18380a586ceaSMark Shellenbaum {
18390a586ceaSMark Shellenbaum 	int error;
18400a586ceaSMark Shellenbaum 	sa_bulk_attr_t bulk;
18410a586ceaSMark Shellenbaum 
18420a586ceaSMark Shellenbaum 	bulk.sa_attr = attr;
18430a586ceaSMark Shellenbaum 	bulk.sa_data = userdata;
18440a586ceaSMark Shellenbaum 	bulk.sa_data_func = locator;
18450a586ceaSMark Shellenbaum 	bulk.sa_length = buflen;
18460a586ceaSMark Shellenbaum 
18470a586ceaSMark Shellenbaum 	mutex_enter(&hdl->sa_lock);
18480a586ceaSMark Shellenbaum 	error = sa_bulk_update_impl(hdl, &bulk, 1, tx);
18490a586ceaSMark Shellenbaum 	mutex_exit(&hdl->sa_lock);
18500a586ceaSMark Shellenbaum 	return (error);
18510a586ceaSMark Shellenbaum }
18520a586ceaSMark Shellenbaum 
18530a586ceaSMark Shellenbaum /*
18540a586ceaSMark Shellenbaum  * Return size of an attribute
18550a586ceaSMark Shellenbaum  */
18560a586ceaSMark Shellenbaum 
18570a586ceaSMark Shellenbaum int
18580a586ceaSMark Shellenbaum sa_size(sa_handle_t *hdl, sa_attr_type_t attr, int *size)
18590a586ceaSMark Shellenbaum {
18600a586ceaSMark Shellenbaum 	sa_bulk_attr_t bulk;
18611d8ccc7bSMark Shellenbaum 	int error;
18620a586ceaSMark Shellenbaum 
18630a586ceaSMark Shellenbaum 	bulk.sa_data = NULL;
18640a586ceaSMark Shellenbaum 	bulk.sa_attr = attr;
18650a586ceaSMark Shellenbaum 	bulk.sa_data_func = NULL;
18660a586ceaSMark Shellenbaum 
18670a586ceaSMark Shellenbaum 	ASSERT(hdl);
18680a586ceaSMark Shellenbaum 	mutex_enter(&hdl->sa_lock);
18691d8ccc7bSMark Shellenbaum 	if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) != 0) {
18700a586ceaSMark Shellenbaum 		mutex_exit(&hdl->sa_lock);
18711d8ccc7bSMark Shellenbaum 		return (error);
18720a586ceaSMark Shellenbaum 	}
18730a586ceaSMark Shellenbaum 	*size = bulk.sa_size;
18740a586ceaSMark Shellenbaum 
18750a586ceaSMark Shellenbaum 	mutex_exit(&hdl->sa_lock);
18760a586ceaSMark Shellenbaum 	return (0);
18770a586ceaSMark Shellenbaum }
18780a586ceaSMark Shellenbaum 
18790a586ceaSMark Shellenbaum int
18800a586ceaSMark Shellenbaum sa_bulk_lookup_locked(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count)
18810a586ceaSMark Shellenbaum {
18820a586ceaSMark Shellenbaum 	ASSERT(hdl);
18830a586ceaSMark Shellenbaum 	ASSERT(MUTEX_HELD(&hdl->sa_lock));
18840a586ceaSMark Shellenbaum 	return (sa_lookup_impl(hdl, attrs, count));
18850a586ceaSMark Shellenbaum }
18860a586ceaSMark Shellenbaum 
18870a586ceaSMark Shellenbaum int
18880a586ceaSMark Shellenbaum sa_bulk_lookup(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count)
18890a586ceaSMark Shellenbaum {
18900a586ceaSMark Shellenbaum 	int error;
18910a586ceaSMark Shellenbaum 
18920a586ceaSMark Shellenbaum 	ASSERT(hdl);
18930a586ceaSMark Shellenbaum 	mutex_enter(&hdl->sa_lock);
18940a586ceaSMark Shellenbaum 	error = sa_bulk_lookup_locked(hdl, attrs, count);
18950a586ceaSMark Shellenbaum 	mutex_exit(&hdl->sa_lock);
18960a586ceaSMark Shellenbaum 	return (error);
18970a586ceaSMark Shellenbaum }
18980a586ceaSMark Shellenbaum 
18990a586ceaSMark Shellenbaum int
19000a586ceaSMark Shellenbaum sa_bulk_update(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count, dmu_tx_t *tx)
19010a586ceaSMark Shellenbaum {
19020a586ceaSMark Shellenbaum 	int error;
19030a586ceaSMark Shellenbaum 
19040a586ceaSMark Shellenbaum 	ASSERT(hdl);
19050a586ceaSMark Shellenbaum 	mutex_enter(&hdl->sa_lock);
19060a586ceaSMark Shellenbaum 	error = sa_bulk_update_impl(hdl, attrs, count, tx);
19070a586ceaSMark Shellenbaum 	mutex_exit(&hdl->sa_lock);
19080a586ceaSMark Shellenbaum 	return (error);
19090a586ceaSMark Shellenbaum }
19100a586ceaSMark Shellenbaum 
19110a586ceaSMark Shellenbaum int
19120a586ceaSMark Shellenbaum sa_remove(sa_handle_t *hdl, sa_attr_type_t attr, dmu_tx_t *tx)
19130a586ceaSMark Shellenbaum {
19140a586ceaSMark Shellenbaum 	int error;
19150a586ceaSMark Shellenbaum 
19160a586ceaSMark Shellenbaum 	mutex_enter(&hdl->sa_lock);
19170a586ceaSMark Shellenbaum 	error = sa_modify_attrs(hdl, attr, SA_REMOVE, NULL,
19180a586ceaSMark Shellenbaum 	    NULL, 0, tx);
19190a586ceaSMark Shellenbaum 	mutex_exit(&hdl->sa_lock);
19200a586ceaSMark Shellenbaum 	return (error);
19210a586ceaSMark Shellenbaum }
19220a586ceaSMark Shellenbaum 
19230a586ceaSMark Shellenbaum void
19240a586ceaSMark Shellenbaum sa_object_info(sa_handle_t *hdl, dmu_object_info_t *doi)
19250a586ceaSMark Shellenbaum {
19260a586ceaSMark Shellenbaum 	dmu_object_info_from_db((dmu_buf_t *)hdl->sa_bonus, doi);
19270a586ceaSMark Shellenbaum }
19280a586ceaSMark Shellenbaum 
19290a586ceaSMark Shellenbaum void
19300a586ceaSMark Shellenbaum sa_object_size(sa_handle_t *hdl, uint32_t *blksize, u_longlong_t *nblocks)
19310a586ceaSMark Shellenbaum {
19320a586ceaSMark Shellenbaum 	dmu_object_size_from_db((dmu_buf_t *)hdl->sa_bonus,
19330a586ceaSMark Shellenbaum 	    blksize, nblocks);
19340a586ceaSMark Shellenbaum }
19350a586ceaSMark Shellenbaum 
19360a586ceaSMark Shellenbaum void
19370a586ceaSMark Shellenbaum sa_set_userp(sa_handle_t *hdl, void *ptr)
19380a586ceaSMark Shellenbaum {
19390a586ceaSMark Shellenbaum 	hdl->sa_userp = ptr;
19400a586ceaSMark Shellenbaum }
19410a586ceaSMark Shellenbaum 
19420a586ceaSMark Shellenbaum dmu_buf_t *
19430a586ceaSMark Shellenbaum sa_get_db(sa_handle_t *hdl)
19440a586ceaSMark Shellenbaum {
19450a586ceaSMark Shellenbaum 	return ((dmu_buf_t *)hdl->sa_bonus);
19460a586ceaSMark Shellenbaum }
19470a586ceaSMark Shellenbaum 
19480a586ceaSMark Shellenbaum void *
19490a586ceaSMark Shellenbaum sa_get_userdata(sa_handle_t *hdl)
19500a586ceaSMark Shellenbaum {
19510a586ceaSMark Shellenbaum 	return (hdl->sa_userp);
19520a586ceaSMark Shellenbaum }
19530a586ceaSMark Shellenbaum 
19540a586ceaSMark Shellenbaum void
19550a586ceaSMark Shellenbaum sa_register_update_callback_locked(objset_t *os, sa_update_cb_t *func)
19560a586ceaSMark Shellenbaum {
19570a586ceaSMark Shellenbaum 	ASSERT(MUTEX_HELD(&os->os_sa->sa_lock));
19580a586ceaSMark Shellenbaum 	os->os_sa->sa_update_cb = func;
19590a586ceaSMark Shellenbaum }
19600a586ceaSMark Shellenbaum 
19610a586ceaSMark Shellenbaum void
19620a586ceaSMark Shellenbaum sa_register_update_callback(objset_t *os, sa_update_cb_t *func)
19630a586ceaSMark Shellenbaum {
19640a586ceaSMark Shellenbaum 
19650a586ceaSMark Shellenbaum 	mutex_enter(&os->os_sa->sa_lock);
19660a586ceaSMark Shellenbaum 	sa_register_update_callback_locked(os, func);
19670a586ceaSMark Shellenbaum 	mutex_exit(&os->os_sa->sa_lock);
19680a586ceaSMark Shellenbaum }
19690a586ceaSMark Shellenbaum 
19700a586ceaSMark Shellenbaum uint64_t
19710a586ceaSMark Shellenbaum sa_handle_object(sa_handle_t *hdl)
19720a586ceaSMark Shellenbaum {
19730a586ceaSMark Shellenbaum 	return (hdl->sa_bonus->db_object);
19740a586ceaSMark Shellenbaum }
19750a586ceaSMark Shellenbaum 
19760a586ceaSMark Shellenbaum boolean_t
19770a586ceaSMark Shellenbaum sa_enabled(objset_t *os)
19780a586ceaSMark Shellenbaum {
19790a586ceaSMark Shellenbaum 	return (os->os_sa == NULL);
19800a586ceaSMark Shellenbaum }
19810a586ceaSMark Shellenbaum 
19820a586ceaSMark Shellenbaum int
19830a586ceaSMark Shellenbaum sa_set_sa_object(objset_t *os, uint64_t sa_object)
19840a586ceaSMark Shellenbaum {
19850a586ceaSMark Shellenbaum 	sa_os_t *sa = os->os_sa;
19860a586ceaSMark Shellenbaum 
19870a586ceaSMark Shellenbaum 	if (sa->sa_master_obj)
19880a586ceaSMark Shellenbaum 		return (1);
19890a586ceaSMark Shellenbaum 
19900a586ceaSMark Shellenbaum 	sa->sa_master_obj = sa_object;
19910a586ceaSMark Shellenbaum 
19920a586ceaSMark Shellenbaum 	return (0);
19930a586ceaSMark Shellenbaum }
19940a586ceaSMark Shellenbaum 
19950a586ceaSMark Shellenbaum int
19960a586ceaSMark Shellenbaum sa_hdrsize(void *arg)
19970a586ceaSMark Shellenbaum {
19980a586ceaSMark Shellenbaum 	sa_hdr_phys_t *hdr = arg;
19990a586ceaSMark Shellenbaum 
20000a586ceaSMark Shellenbaum 	return (SA_HDR_SIZE(hdr));
20010a586ceaSMark Shellenbaum }
20020a586ceaSMark Shellenbaum 
20030a586ceaSMark Shellenbaum void
20040a586ceaSMark Shellenbaum sa_handle_lock(sa_handle_t *hdl)
20050a586ceaSMark Shellenbaum {
20060a586ceaSMark Shellenbaum 	ASSERT(hdl);
20070a586ceaSMark Shellenbaum 	mutex_enter(&hdl->sa_lock);
20080a586ceaSMark Shellenbaum }
20090a586ceaSMark Shellenbaum 
20100a586ceaSMark Shellenbaum void
20110a586ceaSMark Shellenbaum sa_handle_unlock(sa_handle_t *hdl)
20120a586ceaSMark Shellenbaum {
20130a586ceaSMark Shellenbaum 	ASSERT(hdl);
20140a586ceaSMark Shellenbaum 	mutex_exit(&hdl->sa_lock);
20150a586ceaSMark Shellenbaum }
2016