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 25be6fd75aSMatthew Ahrens * Copyright (c) 2013 by Delphix. All rights reserved. 260a586ceaSMark Shellenbaum */ 270a586ceaSMark Shellenbaum 280a586ceaSMark Shellenbaum #include <sys/zfs_context.h> 290a586ceaSMark Shellenbaum #include <sys/types.h> 300a586ceaSMark Shellenbaum #include <sys/param.h> 310a586ceaSMark Shellenbaum #include <sys/systm.h> 320a586ceaSMark Shellenbaum #include <sys/sysmacros.h> 330a586ceaSMark Shellenbaum #include <sys/dmu.h> 340a586ceaSMark Shellenbaum #include <sys/dmu_impl.h> 350a586ceaSMark Shellenbaum #include <sys/dmu_objset.h> 360a586ceaSMark Shellenbaum #include <sys/dbuf.h> 370a586ceaSMark Shellenbaum #include <sys/dnode.h> 380a586ceaSMark Shellenbaum #include <sys/zap.h> 390a586ceaSMark Shellenbaum #include <sys/sa.h> 400a586ceaSMark Shellenbaum #include <sys/sunddi.h> 410a586ceaSMark Shellenbaum #include <sys/sa_impl.h> 420a586ceaSMark Shellenbaum #include <sys/dnode.h> 430a586ceaSMark Shellenbaum #include <sys/errno.h> 440a586ceaSMark Shellenbaum #include <sys/zfs_context.h> 450a586ceaSMark Shellenbaum 460a586ceaSMark Shellenbaum /* 470a586ceaSMark Shellenbaum * ZFS System attributes: 480a586ceaSMark Shellenbaum * 490a586ceaSMark Shellenbaum * A generic mechanism to allow for arbitrary attributes 500a586ceaSMark Shellenbaum * to be stored in a dnode. The data will be stored in the bonus buffer of 510a586ceaSMark Shellenbaum * the dnode and if necessary a special "spill" block will be used to handle 520a586ceaSMark Shellenbaum * overflow situations. The spill block will be sized to fit the data 530a586ceaSMark Shellenbaum * from 512 - 128K. When a spill block is used the BP (blkptr_t) for the 540a586ceaSMark Shellenbaum * spill block is stored at the end of the current bonus buffer. Any 550a586ceaSMark Shellenbaum * attributes that would be in the way of the blkptr_t will be relocated 560a586ceaSMark Shellenbaum * into the spill block. 570a586ceaSMark Shellenbaum * 580a586ceaSMark Shellenbaum * Attribute registration: 590a586ceaSMark Shellenbaum * 600a586ceaSMark Shellenbaum * Stored persistently on a per dataset basis 610a586ceaSMark Shellenbaum * a mapping between attribute "string" names and their actual attribute 620a586ceaSMark Shellenbaum * numeric values, length, and byteswap function. The names are only used 630a586ceaSMark Shellenbaum * during registration. All attributes are known by their unique attribute 640a586ceaSMark Shellenbaum * id value. If an attribute can have a variable size then the value 650a586ceaSMark Shellenbaum * 0 will be used to indicate this. 660a586ceaSMark Shellenbaum * 670a586ceaSMark Shellenbaum * Attribute Layout: 680a586ceaSMark Shellenbaum * 690a586ceaSMark Shellenbaum * Attribute layouts are a way to compactly store multiple attributes, but 700a586ceaSMark Shellenbaum * without taking the overhead associated with managing each attribute 710a586ceaSMark Shellenbaum * individually. Since you will typically have the same set of attributes 720a586ceaSMark Shellenbaum * stored in the same order a single table will be used to represent that 730a586ceaSMark Shellenbaum * layout. The ZPL for example will usually have only about 10 different 740a586ceaSMark Shellenbaum * layouts (regular files, device files, symlinks, 750a586ceaSMark Shellenbaum * regular files + scanstamp, files/dir with extended attributes, and then 760a586ceaSMark Shellenbaum * you have the possibility of all of those minus ACL, because it would 770a586ceaSMark Shellenbaum * be kicked out into the spill block) 780a586ceaSMark Shellenbaum * 790a586ceaSMark Shellenbaum * Layouts are simply an array of the attributes and their 800a586ceaSMark Shellenbaum * ordering i.e. [0, 1, 4, 5, 2] 810a586ceaSMark Shellenbaum * 820a586ceaSMark Shellenbaum * Each distinct layout is given a unique layout number and that is whats 830a586ceaSMark Shellenbaum * stored in the header at the beginning of the SA data buffer. 840a586ceaSMark Shellenbaum * 850a586ceaSMark Shellenbaum * A layout only covers a single dbuf (bonus or spill). If a set of 860a586ceaSMark Shellenbaum * attributes is split up between the bonus buffer and a spill buffer then 870a586ceaSMark Shellenbaum * two different layouts will be used. This allows us to byteswap the 880a586ceaSMark Shellenbaum * spill without looking at the bonus buffer and keeps the on disk format of 890a586ceaSMark Shellenbaum * the bonus and spill buffer the same. 900a586ceaSMark Shellenbaum * 910a586ceaSMark Shellenbaum * Adding a single attribute will cause the entire set of attributes to 920a586ceaSMark Shellenbaum * be rewritten and could result in a new layout number being constructed 930a586ceaSMark Shellenbaum * as part of the rewrite if no such layout exists for the new set of 940a586ceaSMark Shellenbaum * attribues. The new attribute will be appended to the end of the already 950a586ceaSMark Shellenbaum * existing attributes. 960a586ceaSMark Shellenbaum * 970a586ceaSMark Shellenbaum * Both the attribute registration and attribute layout information are 980a586ceaSMark Shellenbaum * stored in normal ZAP attributes. Their should be a small number of 990a586ceaSMark Shellenbaum * known layouts and the set of attributes is assumed to typically be quite 1000a586ceaSMark Shellenbaum * small. 1010a586ceaSMark Shellenbaum * 1020a586ceaSMark Shellenbaum * The registered attributes and layout "table" information is maintained 1030a586ceaSMark Shellenbaum * in core and a special "sa_os_t" is attached to the objset_t. 1040a586ceaSMark Shellenbaum * 1050a586ceaSMark Shellenbaum * A special interface is provided to allow for quickly applying 1060a586ceaSMark Shellenbaum * a large set of attributes at once. sa_replace_all_by_template() is 1070a586ceaSMark Shellenbaum * used to set an array of attributes. This is used by the ZPL when 1080a586ceaSMark Shellenbaum * creating a brand new file. The template that is passed into the function 1090a586ceaSMark Shellenbaum * specifies the attribute, size for variable length attributes, location of 1100a586ceaSMark Shellenbaum * data and special "data locator" function if the data isn't in a contiguous 1110a586ceaSMark Shellenbaum * location. 1120a586ceaSMark Shellenbaum * 1130a586ceaSMark Shellenbaum * Byteswap implications: 114f7170741SWill Andrews * 1150a586ceaSMark Shellenbaum * Since the SA attributes are not entirely self describing we can't do 1160a586ceaSMark Shellenbaum * the normal byteswap processing. The special ZAP layout attribute and 1170a586ceaSMark Shellenbaum * attribute registration attributes define the byteswap function and the 1180a586ceaSMark Shellenbaum * size of the attributes, unless it is variable sized. 1190a586ceaSMark Shellenbaum * The normal ZFS byteswapping infrastructure assumes you don't need 1200a586ceaSMark Shellenbaum * to read any objects in order to do the necessary byteswapping. Whereas 1210a586ceaSMark Shellenbaum * SA attributes can only be properly byteswapped if the dataset is opened 1220a586ceaSMark Shellenbaum * and the layout/attribute ZAP attributes are available. Because of this 1230a586ceaSMark Shellenbaum * the SA attributes will be byteswapped when they are first accessed by 1240a586ceaSMark Shellenbaum * the SA code that will read the SA data. 1250a586ceaSMark Shellenbaum */ 1260a586ceaSMark Shellenbaum 1270a586ceaSMark Shellenbaum typedef void (sa_iterfunc_t)(void *hdr, void *addr, sa_attr_type_t, 1280a586ceaSMark Shellenbaum uint16_t length, int length_idx, boolean_t, void *userp); 1290a586ceaSMark Shellenbaum 1300a586ceaSMark Shellenbaum static int sa_build_index(sa_handle_t *hdl, sa_buf_type_t buftype); 1310a586ceaSMark Shellenbaum static void sa_idx_tab_hold(objset_t *os, sa_idx_tab_t *idx_tab); 1320a586ceaSMark Shellenbaum static void *sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype, 1330a586ceaSMark Shellenbaum void *data); 1340a586ceaSMark Shellenbaum static void sa_idx_tab_rele(objset_t *os, void *arg); 1350a586ceaSMark Shellenbaum static void sa_copy_data(sa_data_locator_t *func, void *start, void *target, 1360a586ceaSMark Shellenbaum int buflen); 1370a586ceaSMark Shellenbaum static int sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr, 1380a586ceaSMark Shellenbaum sa_data_op_t action, sa_data_locator_t *locator, void *datastart, 1390a586ceaSMark Shellenbaum uint16_t buflen, dmu_tx_t *tx); 1400a586ceaSMark Shellenbaum 1410a586ceaSMark Shellenbaum arc_byteswap_func_t *sa_bswap_table[] = { 1420a586ceaSMark Shellenbaum byteswap_uint64_array, 1430a586ceaSMark Shellenbaum byteswap_uint32_array, 1440a586ceaSMark Shellenbaum byteswap_uint16_array, 1450a586ceaSMark Shellenbaum byteswap_uint8_array, 1460a586ceaSMark Shellenbaum zfs_acl_byteswap, 1470a586ceaSMark Shellenbaum }; 1480a586ceaSMark Shellenbaum 1490a586ceaSMark Shellenbaum #define SA_COPY_DATA(f, s, t, l) \ 1500a586ceaSMark Shellenbaum { \ 1510a586ceaSMark Shellenbaum if (f == NULL) { \ 1520a586ceaSMark Shellenbaum if (l == 8) { \ 1530a586ceaSMark Shellenbaum *(uint64_t *)t = *(uint64_t *)s; \ 1540a586ceaSMark Shellenbaum } else if (l == 16) { \ 1550a586ceaSMark Shellenbaum *(uint64_t *)t = *(uint64_t *)s; \ 1560a586ceaSMark Shellenbaum *(uint64_t *)((uintptr_t)t + 8) = \ 1570a586ceaSMark Shellenbaum *(uint64_t *)((uintptr_t)s + 8); \ 1580a586ceaSMark Shellenbaum } else { \ 1590a586ceaSMark Shellenbaum bcopy(s, t, l); \ 1600a586ceaSMark Shellenbaum } \ 1610a586ceaSMark Shellenbaum } else \ 1620a586ceaSMark Shellenbaum sa_copy_data(f, s, t, l); \ 1630a586ceaSMark Shellenbaum } 1640a586ceaSMark Shellenbaum 1650a586ceaSMark Shellenbaum /* 1660a586ceaSMark Shellenbaum * This table is fixed and cannot be changed. Its purpose is to 1670a586ceaSMark Shellenbaum * allow the SA code to work with both old/new ZPL file systems. 1680a586ceaSMark Shellenbaum * It contains the list of legacy attributes. These attributes aren't 1690a586ceaSMark Shellenbaum * stored in the "attribute" registry zap objects, since older ZPL file systems 1700a586ceaSMark Shellenbaum * won't have the registry. Only objsets of type ZFS_TYPE_FILESYSTEM will 1710a586ceaSMark Shellenbaum * use this static table. 1720a586ceaSMark Shellenbaum */ 1730a586ceaSMark Shellenbaum sa_attr_reg_t sa_legacy_attrs[] = { 1740a586ceaSMark Shellenbaum {"ZPL_ATIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 0}, 1750a586ceaSMark Shellenbaum {"ZPL_MTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 1}, 1760a586ceaSMark Shellenbaum {"ZPL_CTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 2}, 1770a586ceaSMark Shellenbaum {"ZPL_CRTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 3}, 1780a586ceaSMark Shellenbaum {"ZPL_GEN", sizeof (uint64_t), SA_UINT64_ARRAY, 4}, 1790a586ceaSMark Shellenbaum {"ZPL_MODE", sizeof (uint64_t), SA_UINT64_ARRAY, 5}, 1800a586ceaSMark Shellenbaum {"ZPL_SIZE", sizeof (uint64_t), SA_UINT64_ARRAY, 6}, 1810a586ceaSMark Shellenbaum {"ZPL_PARENT", sizeof (uint64_t), SA_UINT64_ARRAY, 7}, 1820a586ceaSMark Shellenbaum {"ZPL_LINKS", sizeof (uint64_t), SA_UINT64_ARRAY, 8}, 1830a586ceaSMark Shellenbaum {"ZPL_XATTR", sizeof (uint64_t), SA_UINT64_ARRAY, 9}, 1840a586ceaSMark Shellenbaum {"ZPL_RDEV", sizeof (uint64_t), SA_UINT64_ARRAY, 10}, 1850a586ceaSMark Shellenbaum {"ZPL_FLAGS", sizeof (uint64_t), SA_UINT64_ARRAY, 11}, 1860a586ceaSMark Shellenbaum {"ZPL_UID", sizeof (uint64_t), SA_UINT64_ARRAY, 12}, 1870a586ceaSMark Shellenbaum {"ZPL_GID", sizeof (uint64_t), SA_UINT64_ARRAY, 13}, 1880a586ceaSMark Shellenbaum {"ZPL_PAD", sizeof (uint64_t) * 4, SA_UINT64_ARRAY, 14}, 1890a586ceaSMark Shellenbaum {"ZPL_ZNODE_ACL", 88, SA_UINT8_ARRAY, 15}, 1900a586ceaSMark Shellenbaum }; 1910a586ceaSMark Shellenbaum 1920a586ceaSMark Shellenbaum /* 1930a586ceaSMark Shellenbaum * This is only used for objects of type DMU_OT_ZNODE 1940a586ceaSMark Shellenbaum */ 1950a586ceaSMark Shellenbaum sa_attr_type_t sa_legacy_zpl_layout[] = { 1960a586ceaSMark Shellenbaum 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 1970a586ceaSMark Shellenbaum }; 1980a586ceaSMark Shellenbaum 1990a586ceaSMark Shellenbaum /* 2000a586ceaSMark Shellenbaum * Special dummy layout used for buffers with no attributes. 2010a586ceaSMark Shellenbaum */ 2020a586ceaSMark Shellenbaum sa_attr_type_t sa_dummy_zpl_layout[] = { 0 }; 2030a586ceaSMark Shellenbaum 2040a586ceaSMark Shellenbaum static int sa_legacy_attr_count = 16; 2050a586ceaSMark Shellenbaum static kmem_cache_t *sa_cache = NULL; 2060a586ceaSMark Shellenbaum 2070a586ceaSMark Shellenbaum /*ARGSUSED*/ 2080a586ceaSMark Shellenbaum static int 2090a586ceaSMark Shellenbaum sa_cache_constructor(void *buf, void *unused, int kmflag) 2100a586ceaSMark Shellenbaum { 2110a586ceaSMark Shellenbaum sa_handle_t *hdl = buf; 2120a586ceaSMark Shellenbaum 2130a586ceaSMark Shellenbaum hdl->sa_bonus_tab = NULL; 2140a586ceaSMark Shellenbaum hdl->sa_spill_tab = NULL; 2150a586ceaSMark Shellenbaum hdl->sa_os = NULL; 2160a586ceaSMark Shellenbaum hdl->sa_userp = NULL; 2170a586ceaSMark Shellenbaum hdl->sa_bonus = NULL; 2180a586ceaSMark Shellenbaum hdl->sa_spill = NULL; 2190a586ceaSMark Shellenbaum mutex_init(&hdl->sa_lock, NULL, MUTEX_DEFAULT, NULL); 2200a586ceaSMark Shellenbaum return (0); 2210a586ceaSMark Shellenbaum } 2220a586ceaSMark Shellenbaum 2230a586ceaSMark Shellenbaum /*ARGSUSED*/ 2240a586ceaSMark Shellenbaum static void 2250a586ceaSMark Shellenbaum sa_cache_destructor(void *buf, void *unused) 2260a586ceaSMark Shellenbaum { 2270a586ceaSMark Shellenbaum sa_handle_t *hdl = buf; 2280a586ceaSMark Shellenbaum mutex_destroy(&hdl->sa_lock); 2290a586ceaSMark Shellenbaum } 2300a586ceaSMark Shellenbaum 2310a586ceaSMark Shellenbaum void 2320a586ceaSMark Shellenbaum sa_cache_init(void) 2330a586ceaSMark Shellenbaum { 2340a586ceaSMark Shellenbaum sa_cache = kmem_cache_create("sa_cache", 2350a586ceaSMark Shellenbaum sizeof (sa_handle_t), 0, sa_cache_constructor, 2360a586ceaSMark Shellenbaum sa_cache_destructor, NULL, NULL, NULL, 0); 2370a586ceaSMark Shellenbaum } 2380a586ceaSMark Shellenbaum 2390a586ceaSMark Shellenbaum void 2400a586ceaSMark Shellenbaum sa_cache_fini(void) 2410a586ceaSMark Shellenbaum { 2420a586ceaSMark Shellenbaum if (sa_cache) 2430a586ceaSMark Shellenbaum kmem_cache_destroy(sa_cache); 2440a586ceaSMark Shellenbaum } 2450a586ceaSMark Shellenbaum 2460a586ceaSMark Shellenbaum static int 2470a586ceaSMark Shellenbaum layout_num_compare(const void *arg1, const void *arg2) 2480a586ceaSMark Shellenbaum { 2490a586ceaSMark Shellenbaum const sa_lot_t *node1 = arg1; 2500a586ceaSMark Shellenbaum const sa_lot_t *node2 = arg2; 2510a586ceaSMark Shellenbaum 2520a586ceaSMark Shellenbaum if (node1->lot_num > node2->lot_num) 2530a586ceaSMark Shellenbaum return (1); 2540a586ceaSMark Shellenbaum else if (node1->lot_num < node2->lot_num) 2550a586ceaSMark Shellenbaum return (-1); 2560a586ceaSMark Shellenbaum return (0); 2570a586ceaSMark Shellenbaum } 2580a586ceaSMark Shellenbaum 2590a586ceaSMark Shellenbaum static int 2600a586ceaSMark Shellenbaum layout_hash_compare(const void *arg1, const void *arg2) 2610a586ceaSMark Shellenbaum { 2620a586ceaSMark Shellenbaum const sa_lot_t *node1 = arg1; 2630a586ceaSMark Shellenbaum const sa_lot_t *node2 = arg2; 2640a586ceaSMark Shellenbaum 2650a586ceaSMark Shellenbaum if (node1->lot_hash > node2->lot_hash) 2660a586ceaSMark Shellenbaum return (1); 2670a586ceaSMark Shellenbaum if (node1->lot_hash < node2->lot_hash) 2680a586ceaSMark Shellenbaum return (-1); 2690a586ceaSMark Shellenbaum if (node1->lot_instance > node2->lot_instance) 2700a586ceaSMark Shellenbaum return (1); 2710a586ceaSMark Shellenbaum if (node1->lot_instance < node2->lot_instance) 2720a586ceaSMark Shellenbaum return (-1); 2730a586ceaSMark Shellenbaum return (0); 2740a586ceaSMark Shellenbaum } 2750a586ceaSMark Shellenbaum 2760a586ceaSMark Shellenbaum boolean_t 2770a586ceaSMark Shellenbaum sa_layout_equal(sa_lot_t *tbf, sa_attr_type_t *attrs, int count) 2780a586ceaSMark Shellenbaum { 2790a586ceaSMark Shellenbaum int i; 2800a586ceaSMark Shellenbaum 2810a586ceaSMark Shellenbaum if (count != tbf->lot_attr_count) 2820a586ceaSMark Shellenbaum return (1); 2830a586ceaSMark Shellenbaum 2840a586ceaSMark Shellenbaum for (i = 0; i != count; i++) { 2850a586ceaSMark Shellenbaum if (attrs[i] != tbf->lot_attrs[i]) 2860a586ceaSMark Shellenbaum return (1); 2870a586ceaSMark Shellenbaum } 2880a586ceaSMark Shellenbaum return (0); 2890a586ceaSMark Shellenbaum } 2900a586ceaSMark Shellenbaum 2910a586ceaSMark Shellenbaum #define SA_ATTR_HASH(attr) (zfs_crc64_table[(-1ULL ^ attr) & 0xFF]) 2920a586ceaSMark Shellenbaum 2930a586ceaSMark Shellenbaum static uint64_t 2940a586ceaSMark Shellenbaum sa_layout_info_hash(sa_attr_type_t *attrs, int attr_count) 2950a586ceaSMark Shellenbaum { 2960a586ceaSMark Shellenbaum int i; 2970a586ceaSMark Shellenbaum uint64_t crc = -1ULL; 2980a586ceaSMark Shellenbaum 2990a586ceaSMark Shellenbaum for (i = 0; i != attr_count; i++) 3000a586ceaSMark Shellenbaum crc ^= SA_ATTR_HASH(attrs[i]); 3010a586ceaSMark Shellenbaum 3020a586ceaSMark Shellenbaum return (crc); 3030a586ceaSMark Shellenbaum } 3040a586ceaSMark Shellenbaum 3051d8ccc7bSMark Shellenbaum static int 3061d8ccc7bSMark Shellenbaum sa_get_spill(sa_handle_t *hdl) 3070a586ceaSMark Shellenbaum { 3080a586ceaSMark Shellenbaum int rc; 3090a586ceaSMark Shellenbaum if (hdl->sa_spill == NULL) { 3100a586ceaSMark Shellenbaum if ((rc = dmu_spill_hold_existing(hdl->sa_bonus, NULL, 3110a586ceaSMark Shellenbaum &hdl->sa_spill)) == 0) 3120a586ceaSMark Shellenbaum VERIFY(0 == sa_build_index(hdl, SA_SPILL)); 3130a586ceaSMark Shellenbaum } else { 3140a586ceaSMark Shellenbaum rc = 0; 3150a586ceaSMark Shellenbaum } 3160a586ceaSMark Shellenbaum 3171d8ccc7bSMark Shellenbaum return (rc); 3180a586ceaSMark Shellenbaum } 3190a586ceaSMark Shellenbaum 3200a586ceaSMark Shellenbaum /* 3210a586ceaSMark Shellenbaum * Main attribute lookup/update function 3220a586ceaSMark Shellenbaum * returns 0 for success or non zero for failures 3230a586ceaSMark Shellenbaum * 3240a586ceaSMark Shellenbaum * Operates on bulk array, first failure will abort further processing 3250a586ceaSMark Shellenbaum */ 3260a586ceaSMark Shellenbaum int 3270a586ceaSMark Shellenbaum sa_attr_op(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count, 3280a586ceaSMark Shellenbaum sa_data_op_t data_op, dmu_tx_t *tx) 3290a586ceaSMark Shellenbaum { 3300a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 3310a586ceaSMark Shellenbaum int i; 3320a586ceaSMark Shellenbaum int error = 0; 3330a586ceaSMark Shellenbaum sa_buf_type_t buftypes; 3340a586ceaSMark Shellenbaum 3350a586ceaSMark Shellenbaum buftypes = 0; 3360a586ceaSMark Shellenbaum 3370a586ceaSMark Shellenbaum ASSERT(count > 0); 3380a586ceaSMark Shellenbaum for (i = 0; i != count; i++) { 3390a586ceaSMark Shellenbaum ASSERT(bulk[i].sa_attr <= hdl->sa_os->os_sa->sa_num_attrs); 3400a586ceaSMark Shellenbaum 3410a586ceaSMark Shellenbaum bulk[i].sa_addr = NULL; 3420a586ceaSMark Shellenbaum /* First check the bonus buffer */ 3430a586ceaSMark Shellenbaum 3440a586ceaSMark Shellenbaum if (hdl->sa_bonus_tab && TOC_ATTR_PRESENT( 3450a586ceaSMark Shellenbaum hdl->sa_bonus_tab->sa_idx_tab[bulk[i].sa_attr])) { 3460a586ceaSMark Shellenbaum SA_ATTR_INFO(sa, hdl->sa_bonus_tab, 3470a586ceaSMark Shellenbaum SA_GET_HDR(hdl, SA_BONUS), 3480a586ceaSMark Shellenbaum bulk[i].sa_attr, bulk[i], SA_BONUS, hdl); 3490a586ceaSMark Shellenbaum if (tx && !(buftypes & SA_BONUS)) { 3500a586ceaSMark Shellenbaum dmu_buf_will_dirty(hdl->sa_bonus, tx); 3510a586ceaSMark Shellenbaum buftypes |= SA_BONUS; 3520a586ceaSMark Shellenbaum } 3530a586ceaSMark Shellenbaum } 3541d8ccc7bSMark Shellenbaum if (bulk[i].sa_addr == NULL && 3551d8ccc7bSMark Shellenbaum ((error = sa_get_spill(hdl)) == 0)) { 3560a586ceaSMark Shellenbaum if (TOC_ATTR_PRESENT( 3570a586ceaSMark Shellenbaum hdl->sa_spill_tab->sa_idx_tab[bulk[i].sa_attr])) { 3580a586ceaSMark Shellenbaum SA_ATTR_INFO(sa, hdl->sa_spill_tab, 3590a586ceaSMark Shellenbaum SA_GET_HDR(hdl, SA_SPILL), 3600a586ceaSMark Shellenbaum bulk[i].sa_attr, bulk[i], SA_SPILL, hdl); 3610a586ceaSMark Shellenbaum if (tx && !(buftypes & SA_SPILL) && 3620a586ceaSMark Shellenbaum bulk[i].sa_size == bulk[i].sa_length) { 3630a586ceaSMark Shellenbaum dmu_buf_will_dirty(hdl->sa_spill, tx); 3640a586ceaSMark Shellenbaum buftypes |= SA_SPILL; 3650a586ceaSMark Shellenbaum } 3660a586ceaSMark Shellenbaum } 3670a586ceaSMark Shellenbaum } 3681d8ccc7bSMark Shellenbaum if (error && error != ENOENT) { 3691d8ccc7bSMark Shellenbaum return ((error == ECKSUM) ? EIO : error); 3701d8ccc7bSMark Shellenbaum } 3711d8ccc7bSMark Shellenbaum 3720a586ceaSMark Shellenbaum switch (data_op) { 3730a586ceaSMark Shellenbaum case SA_LOOKUP: 3740a586ceaSMark Shellenbaum if (bulk[i].sa_addr == NULL) 375be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT)); 3760a586ceaSMark Shellenbaum if (bulk[i].sa_data) { 3770a586ceaSMark Shellenbaum SA_COPY_DATA(bulk[i].sa_data_func, 3780a586ceaSMark Shellenbaum bulk[i].sa_addr, bulk[i].sa_data, 3790a586ceaSMark Shellenbaum bulk[i].sa_size); 3800a586ceaSMark Shellenbaum } 3810a586ceaSMark Shellenbaum continue; 3820a586ceaSMark Shellenbaum 3830a586ceaSMark Shellenbaum case SA_UPDATE: 3840a586ceaSMark Shellenbaum /* existing rewrite of attr */ 3850a586ceaSMark Shellenbaum if (bulk[i].sa_addr && 3860a586ceaSMark Shellenbaum bulk[i].sa_size == bulk[i].sa_length) { 3870a586ceaSMark Shellenbaum SA_COPY_DATA(bulk[i].sa_data_func, 3880a586ceaSMark Shellenbaum bulk[i].sa_data, bulk[i].sa_addr, 3890a586ceaSMark Shellenbaum bulk[i].sa_length); 3900a586ceaSMark Shellenbaum continue; 3910a586ceaSMark Shellenbaum } else if (bulk[i].sa_addr) { /* attr size change */ 3920a586ceaSMark Shellenbaum error = sa_modify_attrs(hdl, bulk[i].sa_attr, 3930a586ceaSMark Shellenbaum SA_REPLACE, bulk[i].sa_data_func, 3940a586ceaSMark Shellenbaum bulk[i].sa_data, bulk[i].sa_length, tx); 3950a586ceaSMark Shellenbaum } else { /* adding new attribute */ 3960a586ceaSMark Shellenbaum error = sa_modify_attrs(hdl, bulk[i].sa_attr, 3970a586ceaSMark Shellenbaum SA_ADD, bulk[i].sa_data_func, 3980a586ceaSMark Shellenbaum bulk[i].sa_data, bulk[i].sa_length, tx); 3990a586ceaSMark Shellenbaum } 4000a586ceaSMark Shellenbaum if (error) 4010a586ceaSMark Shellenbaum return (error); 4020a586ceaSMark Shellenbaum break; 4030a586ceaSMark Shellenbaum } 4040a586ceaSMark Shellenbaum } 4050a586ceaSMark Shellenbaum return (error); 4060a586ceaSMark Shellenbaum } 4070a586ceaSMark Shellenbaum 4080a586ceaSMark Shellenbaum static sa_lot_t * 4090a586ceaSMark Shellenbaum sa_add_layout_entry(objset_t *os, sa_attr_type_t *attrs, int attr_count, 4100a586ceaSMark Shellenbaum uint64_t lot_num, uint64_t hash, boolean_t zapadd, dmu_tx_t *tx) 4110a586ceaSMark Shellenbaum { 4120a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 4130a586ceaSMark Shellenbaum sa_lot_t *tb, *findtb; 4140a586ceaSMark Shellenbaum int i; 4150a586ceaSMark Shellenbaum avl_index_t loc; 4160a586ceaSMark Shellenbaum 4170a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&sa->sa_lock)); 4180a586ceaSMark Shellenbaum tb = kmem_zalloc(sizeof (sa_lot_t), KM_SLEEP); 4190a586ceaSMark Shellenbaum tb->lot_attr_count = attr_count; 4200a586ceaSMark Shellenbaum tb->lot_attrs = kmem_alloc(sizeof (sa_attr_type_t) * attr_count, 4210a586ceaSMark Shellenbaum KM_SLEEP); 4220a586ceaSMark Shellenbaum bcopy(attrs, tb->lot_attrs, sizeof (sa_attr_type_t) * attr_count); 4230a586ceaSMark Shellenbaum tb->lot_num = lot_num; 4240a586ceaSMark Shellenbaum tb->lot_hash = hash; 4250a586ceaSMark Shellenbaum tb->lot_instance = 0; 4260a586ceaSMark Shellenbaum 4270a586ceaSMark Shellenbaum if (zapadd) { 4280a586ceaSMark Shellenbaum char attr_name[8]; 4290a586ceaSMark Shellenbaum 4300a586ceaSMark Shellenbaum if (sa->sa_layout_attr_obj == 0) { 431ad135b5dSChristopher Siden sa->sa_layout_attr_obj = zap_create_link(os, 432ad135b5dSChristopher Siden DMU_OT_SA_ATTR_LAYOUTS, 433ad135b5dSChristopher Siden sa->sa_master_obj, SA_LAYOUTS, tx); 4340a586ceaSMark Shellenbaum } 4350a586ceaSMark Shellenbaum 4360a586ceaSMark Shellenbaum (void) snprintf(attr_name, sizeof (attr_name), 4370a586ceaSMark Shellenbaum "%d", (int)lot_num); 4380a586ceaSMark Shellenbaum VERIFY(0 == zap_update(os, os->os_sa->sa_layout_attr_obj, 4390a586ceaSMark Shellenbaum attr_name, 2, attr_count, attrs, tx)); 4400a586ceaSMark Shellenbaum } 4410a586ceaSMark Shellenbaum 4420a586ceaSMark Shellenbaum list_create(&tb->lot_idx_tab, sizeof (sa_idx_tab_t), 4430a586ceaSMark Shellenbaum offsetof(sa_idx_tab_t, sa_next)); 4440a586ceaSMark Shellenbaum 4450a586ceaSMark Shellenbaum for (i = 0; i != attr_count; i++) { 4460a586ceaSMark Shellenbaum if (sa->sa_attr_table[tb->lot_attrs[i]].sa_length == 0) 4470a586ceaSMark Shellenbaum tb->lot_var_sizes++; 4480a586ceaSMark Shellenbaum } 4490a586ceaSMark Shellenbaum 4500a586ceaSMark Shellenbaum avl_add(&sa->sa_layout_num_tree, tb); 4510a586ceaSMark Shellenbaum 4520a586ceaSMark Shellenbaum /* verify we don't have a hash collision */ 4530a586ceaSMark Shellenbaum if ((findtb = avl_find(&sa->sa_layout_hash_tree, tb, &loc)) != NULL) { 4540a586ceaSMark Shellenbaum for (; findtb && findtb->lot_hash == hash; 4550a586ceaSMark Shellenbaum findtb = AVL_NEXT(&sa->sa_layout_hash_tree, findtb)) { 4560a586ceaSMark Shellenbaum if (findtb->lot_instance != tb->lot_instance) 4570a586ceaSMark Shellenbaum break; 4580a586ceaSMark Shellenbaum tb->lot_instance++; 4590a586ceaSMark Shellenbaum } 4600a586ceaSMark Shellenbaum } 4610a586ceaSMark Shellenbaum avl_add(&sa->sa_layout_hash_tree, tb); 4620a586ceaSMark Shellenbaum return (tb); 4630a586ceaSMark Shellenbaum } 4640a586ceaSMark Shellenbaum 4650a586ceaSMark Shellenbaum static void 4660a586ceaSMark Shellenbaum sa_find_layout(objset_t *os, uint64_t hash, sa_attr_type_t *attrs, 4670a586ceaSMark Shellenbaum int count, dmu_tx_t *tx, sa_lot_t **lot) 4680a586ceaSMark Shellenbaum { 4690a586ceaSMark Shellenbaum sa_lot_t *tb, tbsearch; 4700a586ceaSMark Shellenbaum avl_index_t loc; 4710a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 4720a586ceaSMark Shellenbaum boolean_t found = B_FALSE; 4730a586ceaSMark Shellenbaum 4740a586ceaSMark Shellenbaum mutex_enter(&sa->sa_lock); 4750a586ceaSMark Shellenbaum tbsearch.lot_hash = hash; 4760a586ceaSMark Shellenbaum tbsearch.lot_instance = 0; 4770a586ceaSMark Shellenbaum tb = avl_find(&sa->sa_layout_hash_tree, &tbsearch, &loc); 4780a586ceaSMark Shellenbaum if (tb) { 4790a586ceaSMark Shellenbaum for (; tb && tb->lot_hash == hash; 4800a586ceaSMark Shellenbaum tb = AVL_NEXT(&sa->sa_layout_hash_tree, tb)) { 4810a586ceaSMark Shellenbaum if (sa_layout_equal(tb, attrs, count) == 0) { 4820a586ceaSMark Shellenbaum found = B_TRUE; 4830a586ceaSMark Shellenbaum break; 4840a586ceaSMark Shellenbaum } 4850a586ceaSMark Shellenbaum } 4860a586ceaSMark Shellenbaum } 4870a586ceaSMark Shellenbaum if (!found) { 4880a586ceaSMark Shellenbaum tb = sa_add_layout_entry(os, attrs, count, 4890a586ceaSMark Shellenbaum avl_numnodes(&sa->sa_layout_num_tree), hash, B_TRUE, tx); 4900a586ceaSMark Shellenbaum } 4910a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 4920a586ceaSMark Shellenbaum *lot = tb; 4930a586ceaSMark Shellenbaum } 4940a586ceaSMark Shellenbaum 4950a586ceaSMark Shellenbaum static int 4960a586ceaSMark Shellenbaum sa_resize_spill(sa_handle_t *hdl, uint32_t size, dmu_tx_t *tx) 4970a586ceaSMark Shellenbaum { 4980a586ceaSMark Shellenbaum int error; 4990a586ceaSMark Shellenbaum uint32_t blocksize; 5000a586ceaSMark Shellenbaum 5010a586ceaSMark Shellenbaum if (size == 0) { 5020a586ceaSMark Shellenbaum blocksize = SPA_MINBLOCKSIZE; 5030a586ceaSMark Shellenbaum } else if (size > SPA_MAXBLOCKSIZE) { 5040a586ceaSMark Shellenbaum ASSERT(0); 505be6fd75aSMatthew Ahrens return (SET_ERROR(EFBIG)); 5060a586ceaSMark Shellenbaum } else { 5070a586ceaSMark Shellenbaum blocksize = P2ROUNDUP_TYPED(size, SPA_MINBLOCKSIZE, uint32_t); 5080a586ceaSMark Shellenbaum } 5090a586ceaSMark Shellenbaum 5100a586ceaSMark Shellenbaum error = dbuf_spill_set_blksz(hdl->sa_spill, blocksize, tx); 5110a586ceaSMark Shellenbaum ASSERT(error == 0); 5120a586ceaSMark Shellenbaum return (error); 5130a586ceaSMark Shellenbaum } 5140a586ceaSMark Shellenbaum 5150a586ceaSMark Shellenbaum static void 5160a586ceaSMark Shellenbaum sa_copy_data(sa_data_locator_t *func, void *datastart, void *target, int buflen) 5170a586ceaSMark Shellenbaum { 5180a586ceaSMark Shellenbaum if (func == NULL) { 5190a586ceaSMark Shellenbaum bcopy(datastart, target, buflen); 5200a586ceaSMark Shellenbaum } else { 5210a586ceaSMark Shellenbaum boolean_t start; 5220a586ceaSMark Shellenbaum int bytes; 5230a586ceaSMark Shellenbaum void *dataptr; 5240a586ceaSMark Shellenbaum void *saptr = target; 5250a586ceaSMark Shellenbaum uint32_t length; 5260a586ceaSMark Shellenbaum 5270a586ceaSMark Shellenbaum start = B_TRUE; 5280a586ceaSMark Shellenbaum bytes = 0; 5290a586ceaSMark Shellenbaum while (bytes < buflen) { 5300a586ceaSMark Shellenbaum func(&dataptr, &length, buflen, start, datastart); 5310a586ceaSMark Shellenbaum bcopy(dataptr, saptr, length); 5320a586ceaSMark Shellenbaum saptr = (void *)((caddr_t)saptr + length); 5330a586ceaSMark Shellenbaum bytes += length; 5340a586ceaSMark Shellenbaum start = B_FALSE; 5350a586ceaSMark Shellenbaum } 5360a586ceaSMark Shellenbaum } 5370a586ceaSMark Shellenbaum } 5380a586ceaSMark Shellenbaum 5390a586ceaSMark Shellenbaum /* 5400a586ceaSMark Shellenbaum * Determine several different sizes 5410a586ceaSMark Shellenbaum * first the sa header size 5420a586ceaSMark Shellenbaum * the number of bytes to be stored 5430a586ceaSMark Shellenbaum * if spill would occur the index in the attribute array is returned 5440a586ceaSMark Shellenbaum * 5450a586ceaSMark Shellenbaum * the boolean will_spill will be set when spilling is necessary. It 5460a586ceaSMark Shellenbaum * is only set when the buftype is SA_BONUS 5470a586ceaSMark Shellenbaum */ 5480a586ceaSMark Shellenbaum static int 5490a586ceaSMark Shellenbaum sa_find_sizes(sa_os_t *sa, sa_bulk_attr_t *attr_desc, int attr_count, 5500a586ceaSMark Shellenbaum dmu_buf_t *db, sa_buf_type_t buftype, int *index, int *total, 5510a586ceaSMark Shellenbaum boolean_t *will_spill) 5520a586ceaSMark Shellenbaum { 5530a586ceaSMark Shellenbaum int var_size = 0; 5540a586ceaSMark Shellenbaum int i; 555644b9528SNed Bass int j = -1; 5560a586ceaSMark Shellenbaum int full_space; 5570a586ceaSMark Shellenbaum int hdrsize; 5580a586ceaSMark Shellenbaum boolean_t done = B_FALSE; 5590a586ceaSMark Shellenbaum 5600a586ceaSMark Shellenbaum if (buftype == SA_BONUS && sa->sa_force_spill) { 5610a586ceaSMark Shellenbaum *total = 0; 5620a586ceaSMark Shellenbaum *index = 0; 5630a586ceaSMark Shellenbaum *will_spill = B_TRUE; 5640a586ceaSMark Shellenbaum return (0); 5650a586ceaSMark Shellenbaum } 5660a586ceaSMark Shellenbaum 5670a586ceaSMark Shellenbaum *index = -1; 5680a586ceaSMark Shellenbaum *total = 0; 5690a586ceaSMark Shellenbaum 5700a586ceaSMark Shellenbaum if (buftype == SA_BONUS) 5710a586ceaSMark Shellenbaum *will_spill = B_FALSE; 5720a586ceaSMark Shellenbaum 5730a586ceaSMark Shellenbaum hdrsize = (SA_BONUSTYPE_FROM_DB(db) == DMU_OT_ZNODE) ? 0 : 5740a586ceaSMark Shellenbaum sizeof (sa_hdr_phys_t); 5750a586ceaSMark Shellenbaum 5760a586ceaSMark Shellenbaum full_space = (buftype == SA_BONUS) ? DN_MAX_BONUSLEN : db->db_size; 577644b9528SNed Bass ASSERT(IS_P2ALIGNED(full_space, 8)); 5780a586ceaSMark Shellenbaum 5790a586ceaSMark Shellenbaum for (i = 0; i != attr_count; i++) { 5800a586ceaSMark Shellenbaum boolean_t is_var_sz; 5810a586ceaSMark Shellenbaum 582644b9528SNed Bass *total = P2ROUNDUP(*total, 8); 5830a586ceaSMark Shellenbaum *total += attr_desc[i].sa_length; 5840a586ceaSMark Shellenbaum if (done) 5850a586ceaSMark Shellenbaum goto next; 5860a586ceaSMark Shellenbaum 5870a586ceaSMark Shellenbaum is_var_sz = (SA_REGISTERED_LEN(sa, attr_desc[i].sa_attr) == 0); 5880a586ceaSMark Shellenbaum if (is_var_sz) { 5890a586ceaSMark Shellenbaum var_size++; 5900a586ceaSMark Shellenbaum } 5910a586ceaSMark Shellenbaum 5920a586ceaSMark Shellenbaum if (is_var_sz && var_size > 1) { 5930a586ceaSMark Shellenbaum if (P2ROUNDUP(hdrsize + sizeof (uint16_t), 8) + 5940a586ceaSMark Shellenbaum *total < full_space) { 595644b9528SNed Bass /* 596644b9528SNed Bass * Account for header space used by array of 597644b9528SNed Bass * optional sizes of variable-length attributes. 598644b9528SNed Bass * Record the index in case this increase needs 599644b9528SNed Bass * to be reversed due to spill-over. 600644b9528SNed Bass */ 6010a586ceaSMark Shellenbaum hdrsize += sizeof (uint16_t); 602644b9528SNed Bass j = i; 6030a586ceaSMark Shellenbaum } else { 6040a586ceaSMark Shellenbaum done = B_TRUE; 6050a586ceaSMark Shellenbaum *index = i; 6060a586ceaSMark Shellenbaum if (buftype == SA_BONUS) 6070a586ceaSMark Shellenbaum *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 done = B_TRUE; 6230a586ceaSMark Shellenbaum } 6240a586ceaSMark Shellenbaum 6250a586ceaSMark Shellenbaum next: 626383e7c74SXin Li if (*total + P2ROUNDUP(hdrsize, 8) > full_space && 6270a586ceaSMark Shellenbaum buftype == SA_BONUS) 6280a586ceaSMark Shellenbaum *will_spill = B_TRUE; 6290a586ceaSMark Shellenbaum } 6300a586ceaSMark Shellenbaum 631644b9528SNed Bass /* 632644b9528SNed Bass * j holds the index of the last variable-sized attribute for 633644b9528SNed Bass * which hdrsize was increased. Reverse the increase if that 634644b9528SNed Bass * attribute will be relocated to the spill block. 635644b9528SNed Bass */ 636644b9528SNed Bass if (*will_spill && j == *index) 637644b9528SNed Bass hdrsize -= sizeof (uint16_t); 638644b9528SNed Bass 6390a586ceaSMark Shellenbaum hdrsize = P2ROUNDUP(hdrsize, 8); 6400a586ceaSMark Shellenbaum return (hdrsize); 6410a586ceaSMark Shellenbaum } 6420a586ceaSMark Shellenbaum 6430a586ceaSMark Shellenbaum #define BUF_SPACE_NEEDED(total, header) (total + header) 6440a586ceaSMark Shellenbaum 6450a586ceaSMark Shellenbaum /* 6460a586ceaSMark Shellenbaum * Find layout that corresponds to ordering of attributes 6470a586ceaSMark Shellenbaum * If not found a new layout number is created and added to 6480a586ceaSMark Shellenbaum * persistent layout tables. 6490a586ceaSMark Shellenbaum */ 6500a586ceaSMark Shellenbaum static int 6510a586ceaSMark Shellenbaum sa_build_layouts(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, int attr_count, 6520a586ceaSMark Shellenbaum dmu_tx_t *tx) 6530a586ceaSMark Shellenbaum { 6540a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 6550a586ceaSMark Shellenbaum uint64_t hash; 6560a586ceaSMark Shellenbaum sa_buf_type_t buftype; 6570a586ceaSMark Shellenbaum sa_hdr_phys_t *sahdr; 6580a586ceaSMark Shellenbaum void *data_start; 6590a586ceaSMark Shellenbaum int buf_space; 6600a586ceaSMark Shellenbaum sa_attr_type_t *attrs, *attrs_start; 6610a586ceaSMark Shellenbaum int i, lot_count; 662d5285caeSGeorge Wilson int hdrsize; 663d5285caeSGeorge Wilson int spillhdrsize = 0; 6640a586ceaSMark Shellenbaum int used; 6650a586ceaSMark Shellenbaum dmu_object_type_t bonustype; 6660a586ceaSMark Shellenbaum sa_lot_t *lot; 6670a586ceaSMark Shellenbaum int len_idx; 6680a586ceaSMark Shellenbaum int spill_used; 6690a586ceaSMark Shellenbaum boolean_t spilling; 6700a586ceaSMark Shellenbaum 6710a586ceaSMark Shellenbaum dmu_buf_will_dirty(hdl->sa_bonus, tx); 6720a586ceaSMark Shellenbaum bonustype = SA_BONUSTYPE_FROM_DB(hdl->sa_bonus); 6730a586ceaSMark Shellenbaum 6740a586ceaSMark Shellenbaum /* first determine bonus header size and sum of all attributes */ 6750a586ceaSMark Shellenbaum hdrsize = sa_find_sizes(sa, attr_desc, attr_count, hdl->sa_bonus, 6760a586ceaSMark Shellenbaum SA_BONUS, &i, &used, &spilling); 6770a586ceaSMark Shellenbaum 6780a586ceaSMark Shellenbaum if (used > SPA_MAXBLOCKSIZE) 679be6fd75aSMatthew Ahrens return (SET_ERROR(EFBIG)); 6800a586ceaSMark Shellenbaum 6810a586ceaSMark Shellenbaum VERIFY(0 == dmu_set_bonus(hdl->sa_bonus, spilling ? 6820a586ceaSMark Shellenbaum MIN(DN_MAX_BONUSLEN - sizeof (blkptr_t), used + hdrsize) : 6830a586ceaSMark Shellenbaum used + hdrsize, tx)); 6840a586ceaSMark Shellenbaum 6850a586ceaSMark Shellenbaum ASSERT((bonustype == DMU_OT_ZNODE && spilling == 0) || 6860a586ceaSMark Shellenbaum bonustype == DMU_OT_SA); 6870a586ceaSMark Shellenbaum 6880a586ceaSMark Shellenbaum /* setup and size spill buffer when needed */ 6890a586ceaSMark Shellenbaum if (spilling) { 6900a586ceaSMark Shellenbaum boolean_t dummy; 6910a586ceaSMark Shellenbaum 6920a586ceaSMark Shellenbaum if (hdl->sa_spill == NULL) { 6931d8ccc7bSMark Shellenbaum VERIFY(dmu_spill_hold_by_bonus(hdl->sa_bonus, NULL, 6941d8ccc7bSMark Shellenbaum &hdl->sa_spill) == 0); 6950a586ceaSMark Shellenbaum } 6960a586ceaSMark Shellenbaum dmu_buf_will_dirty(hdl->sa_spill, tx); 6970a586ceaSMark Shellenbaum 6980a586ceaSMark Shellenbaum spillhdrsize = sa_find_sizes(sa, &attr_desc[i], 6990a586ceaSMark Shellenbaum attr_count - i, hdl->sa_spill, SA_SPILL, &i, 7000a586ceaSMark Shellenbaum &spill_used, &dummy); 7010a586ceaSMark Shellenbaum 7020a586ceaSMark Shellenbaum if (spill_used > SPA_MAXBLOCKSIZE) 703be6fd75aSMatthew Ahrens return (SET_ERROR(EFBIG)); 7040a586ceaSMark Shellenbaum 7050a586ceaSMark Shellenbaum buf_space = hdl->sa_spill->db_size - spillhdrsize; 7060a586ceaSMark Shellenbaum if (BUF_SPACE_NEEDED(spill_used, spillhdrsize) > 7070a586ceaSMark Shellenbaum hdl->sa_spill->db_size) 7080a586ceaSMark Shellenbaum VERIFY(0 == sa_resize_spill(hdl, 7090a586ceaSMark Shellenbaum BUF_SPACE_NEEDED(spill_used, spillhdrsize), tx)); 7100a586ceaSMark Shellenbaum } 7110a586ceaSMark Shellenbaum 7120a586ceaSMark Shellenbaum /* setup starting pointers to lay down data */ 7130a586ceaSMark Shellenbaum data_start = (void *)((uintptr_t)hdl->sa_bonus->db_data + hdrsize); 7140a586ceaSMark Shellenbaum sahdr = (sa_hdr_phys_t *)hdl->sa_bonus->db_data; 7150a586ceaSMark Shellenbaum buftype = SA_BONUS; 7160a586ceaSMark Shellenbaum 7170a586ceaSMark Shellenbaum if (spilling) 7180a586ceaSMark Shellenbaum buf_space = (sa->sa_force_spill) ? 7190a586ceaSMark Shellenbaum 0 : SA_BLKPTR_SPACE - hdrsize; 7200a586ceaSMark Shellenbaum else 7210a586ceaSMark Shellenbaum buf_space = hdl->sa_bonus->db_size - hdrsize; 7220a586ceaSMark Shellenbaum 7230a586ceaSMark Shellenbaum attrs_start = attrs = kmem_alloc(sizeof (sa_attr_type_t) * attr_count, 7240a586ceaSMark Shellenbaum KM_SLEEP); 7250a586ceaSMark Shellenbaum lot_count = 0; 7260a586ceaSMark Shellenbaum 7270a586ceaSMark Shellenbaum for (i = 0, len_idx = 0, hash = -1ULL; i != attr_count; i++) { 7280a586ceaSMark Shellenbaum uint16_t length; 7290a586ceaSMark Shellenbaum 730644b9528SNed Bass ASSERT(IS_P2ALIGNED(data_start, 8)); 731644b9528SNed Bass ASSERT(IS_P2ALIGNED(buf_space, 8)); 7320a586ceaSMark Shellenbaum attrs[i] = attr_desc[i].sa_attr; 7330a586ceaSMark Shellenbaum length = SA_REGISTERED_LEN(sa, attrs[i]); 7340a586ceaSMark Shellenbaum if (length == 0) 7350a586ceaSMark Shellenbaum length = attr_desc[i].sa_length; 7360a586ceaSMark Shellenbaum 7370a586ceaSMark Shellenbaum if (buf_space < length) { /* switch to spill buffer */ 738644b9528SNed Bass VERIFY(spilling); 7391412a1a2SMark Shellenbaum VERIFY(bonustype == DMU_OT_SA); 7400a586ceaSMark Shellenbaum if (buftype == SA_BONUS && !sa->sa_force_spill) { 7410a586ceaSMark Shellenbaum sa_find_layout(hdl->sa_os, hash, attrs_start, 7420a586ceaSMark Shellenbaum lot_count, tx, &lot); 7430a586ceaSMark Shellenbaum SA_SET_HDR(sahdr, lot->lot_num, hdrsize); 7440a586ceaSMark Shellenbaum } 7450a586ceaSMark Shellenbaum 7460a586ceaSMark Shellenbaum buftype = SA_SPILL; 7470a586ceaSMark Shellenbaum hash = -1ULL; 7480a586ceaSMark Shellenbaum len_idx = 0; 7490a586ceaSMark Shellenbaum 7500a586ceaSMark Shellenbaum sahdr = (sa_hdr_phys_t *)hdl->sa_spill->db_data; 7510a586ceaSMark Shellenbaum sahdr->sa_magic = SA_MAGIC; 7520a586ceaSMark Shellenbaum data_start = (void *)((uintptr_t)sahdr + 7530a586ceaSMark Shellenbaum spillhdrsize); 7540a586ceaSMark Shellenbaum attrs_start = &attrs[i]; 7550a586ceaSMark Shellenbaum buf_space = hdl->sa_spill->db_size - spillhdrsize; 7560a586ceaSMark Shellenbaum lot_count = 0; 7570a586ceaSMark Shellenbaum } 7580a586ceaSMark Shellenbaum hash ^= SA_ATTR_HASH(attrs[i]); 7590a586ceaSMark Shellenbaum attr_desc[i].sa_addr = data_start; 7600a586ceaSMark Shellenbaum attr_desc[i].sa_size = length; 7610a586ceaSMark Shellenbaum SA_COPY_DATA(attr_desc[i].sa_data_func, attr_desc[i].sa_data, 7620a586ceaSMark Shellenbaum data_start, length); 7630a586ceaSMark Shellenbaum if (sa->sa_attr_table[attrs[i]].sa_length == 0) { 7640a586ceaSMark Shellenbaum sahdr->sa_lengths[len_idx++] = length; 7650a586ceaSMark Shellenbaum } 7660a586ceaSMark Shellenbaum data_start = (void *)P2ROUNDUP(((uintptr_t)data_start + 7670a586ceaSMark Shellenbaum length), 8); 7680a586ceaSMark Shellenbaum buf_space -= P2ROUNDUP(length, 8); 7690a586ceaSMark Shellenbaum lot_count++; 7700a586ceaSMark Shellenbaum } 7710a586ceaSMark Shellenbaum 7720a586ceaSMark Shellenbaum sa_find_layout(hdl->sa_os, hash, attrs_start, lot_count, tx, &lot); 7731412a1a2SMark Shellenbaum 7741412a1a2SMark Shellenbaum /* 7751412a1a2SMark Shellenbaum * Verify that old znodes always have layout number 0. 7761412a1a2SMark Shellenbaum * Must be DMU_OT_SA for arbitrary layouts 7771412a1a2SMark Shellenbaum */ 7781412a1a2SMark Shellenbaum VERIFY((bonustype == DMU_OT_ZNODE && lot->lot_num == 0) || 7791412a1a2SMark Shellenbaum (bonustype == DMU_OT_SA && lot->lot_num > 1)); 7801412a1a2SMark Shellenbaum 7810a586ceaSMark Shellenbaum if (bonustype == DMU_OT_SA) { 7820a586ceaSMark Shellenbaum SA_SET_HDR(sahdr, lot->lot_num, 7830a586ceaSMark Shellenbaum buftype == SA_BONUS ? hdrsize : spillhdrsize); 7840a586ceaSMark Shellenbaum } 7850a586ceaSMark Shellenbaum 7860a586ceaSMark Shellenbaum kmem_free(attrs, sizeof (sa_attr_type_t) * attr_count); 7870a586ceaSMark Shellenbaum if (hdl->sa_bonus_tab) { 7880a586ceaSMark Shellenbaum sa_idx_tab_rele(hdl->sa_os, hdl->sa_bonus_tab); 7890a586ceaSMark Shellenbaum hdl->sa_bonus_tab = NULL; 7900a586ceaSMark Shellenbaum } 7910a586ceaSMark Shellenbaum if (!sa->sa_force_spill) 7920a586ceaSMark Shellenbaum VERIFY(0 == sa_build_index(hdl, SA_BONUS)); 7930a586ceaSMark Shellenbaum if (hdl->sa_spill) { 7940a586ceaSMark Shellenbaum sa_idx_tab_rele(hdl->sa_os, hdl->sa_spill_tab); 7950a586ceaSMark Shellenbaum if (!spilling) { 7960a586ceaSMark Shellenbaum /* 7970a586ceaSMark Shellenbaum * remove spill block that is no longer needed. 7980a586ceaSMark Shellenbaum */ 7990a586ceaSMark Shellenbaum dmu_buf_rele(hdl->sa_spill, NULL); 8000a586ceaSMark Shellenbaum hdl->sa_spill = NULL; 8010a586ceaSMark Shellenbaum hdl->sa_spill_tab = NULL; 8020a586ceaSMark Shellenbaum VERIFY(0 == dmu_rm_spill(hdl->sa_os, 8030a586ceaSMark Shellenbaum sa_handle_object(hdl), tx)); 8040a586ceaSMark Shellenbaum } else { 8050a586ceaSMark Shellenbaum VERIFY(0 == sa_build_index(hdl, SA_SPILL)); 8060a586ceaSMark Shellenbaum } 8070a586ceaSMark Shellenbaum } 8080a586ceaSMark Shellenbaum 8090a586ceaSMark Shellenbaum return (0); 8100a586ceaSMark Shellenbaum } 8110a586ceaSMark Shellenbaum 8120a586ceaSMark Shellenbaum static void 8131d8ccc7bSMark Shellenbaum sa_free_attr_table(sa_os_t *sa) 8141d8ccc7bSMark Shellenbaum { 8151d8ccc7bSMark Shellenbaum int i; 8161d8ccc7bSMark Shellenbaum 8171d8ccc7bSMark Shellenbaum if (sa->sa_attr_table == NULL) 8181d8ccc7bSMark Shellenbaum return; 8191d8ccc7bSMark Shellenbaum 8201d8ccc7bSMark Shellenbaum for (i = 0; i != sa->sa_num_attrs; i++) { 8211d8ccc7bSMark Shellenbaum if (sa->sa_attr_table[i].sa_name) 8221d8ccc7bSMark Shellenbaum kmem_free(sa->sa_attr_table[i].sa_name, 8231d8ccc7bSMark Shellenbaum strlen(sa->sa_attr_table[i].sa_name) + 1); 8241d8ccc7bSMark Shellenbaum } 8251d8ccc7bSMark Shellenbaum 8261d8ccc7bSMark Shellenbaum kmem_free(sa->sa_attr_table, 8271d8ccc7bSMark Shellenbaum sizeof (sa_attr_table_t) * sa->sa_num_attrs); 8281d8ccc7bSMark Shellenbaum 8291d8ccc7bSMark Shellenbaum sa->sa_attr_table = NULL; 8301d8ccc7bSMark Shellenbaum } 8311d8ccc7bSMark Shellenbaum 8321d8ccc7bSMark Shellenbaum static int 8330a586ceaSMark Shellenbaum sa_attr_table_setup(objset_t *os, sa_attr_reg_t *reg_attrs, int count) 8340a586ceaSMark Shellenbaum { 8350a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 8360a586ceaSMark Shellenbaum uint64_t sa_attr_count = 0; 837d5285caeSGeorge Wilson uint64_t sa_reg_count = 0; 8380a586ceaSMark Shellenbaum int error = 0; 8390a586ceaSMark Shellenbaum uint64_t attr_value; 8400a586ceaSMark Shellenbaum sa_attr_table_t *tb; 8410a586ceaSMark Shellenbaum zap_cursor_t zc; 8420a586ceaSMark Shellenbaum zap_attribute_t za; 8430a586ceaSMark Shellenbaum int registered_count = 0; 8440a586ceaSMark Shellenbaum int i; 8450a586ceaSMark Shellenbaum dmu_objset_type_t ostype = dmu_objset_type(os); 8460a586ceaSMark Shellenbaum 8470a586ceaSMark Shellenbaum sa->sa_user_table = 8480a586ceaSMark Shellenbaum kmem_zalloc(count * sizeof (sa_attr_type_t), KM_SLEEP); 8490a586ceaSMark Shellenbaum sa->sa_user_table_sz = count * sizeof (sa_attr_type_t); 8500a586ceaSMark Shellenbaum 8511d8ccc7bSMark Shellenbaum if (sa->sa_reg_attr_obj != 0) { 8521d8ccc7bSMark Shellenbaum error = zap_count(os, sa->sa_reg_attr_obj, 8531d8ccc7bSMark Shellenbaum &sa_attr_count); 8541d8ccc7bSMark Shellenbaum 8551d8ccc7bSMark Shellenbaum /* 8561d8ccc7bSMark Shellenbaum * Make sure we retrieved a count and that it isn't zero 8571d8ccc7bSMark Shellenbaum */ 8581d8ccc7bSMark Shellenbaum if (error || (error == 0 && sa_attr_count == 0)) { 8591d8ccc7bSMark Shellenbaum if (error == 0) 860be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 8611d8ccc7bSMark Shellenbaum goto bail; 8621d8ccc7bSMark Shellenbaum } 8631d8ccc7bSMark Shellenbaum sa_reg_count = sa_attr_count; 8641d8ccc7bSMark Shellenbaum } 8650a586ceaSMark Shellenbaum 8660a586ceaSMark Shellenbaum if (ostype == DMU_OST_ZFS && sa_attr_count == 0) 8670a586ceaSMark Shellenbaum sa_attr_count += sa_legacy_attr_count; 8680a586ceaSMark Shellenbaum 8690a586ceaSMark Shellenbaum /* Allocate attribute numbers for attributes that aren't registered */ 8700a586ceaSMark Shellenbaum for (i = 0; i != count; i++) { 8710a586ceaSMark Shellenbaum boolean_t found = B_FALSE; 8720a586ceaSMark Shellenbaum int j; 8730a586ceaSMark Shellenbaum 8740a586ceaSMark Shellenbaum if (ostype == DMU_OST_ZFS) { 8750a586ceaSMark Shellenbaum for (j = 0; j != sa_legacy_attr_count; j++) { 8760a586ceaSMark Shellenbaum if (strcmp(reg_attrs[i].sa_name, 8770a586ceaSMark Shellenbaum sa_legacy_attrs[j].sa_name) == 0) { 8780a586ceaSMark Shellenbaum sa->sa_user_table[i] = 8790a586ceaSMark Shellenbaum sa_legacy_attrs[j].sa_attr; 8800a586ceaSMark Shellenbaum found = B_TRUE; 8810a586ceaSMark Shellenbaum } 8820a586ceaSMark Shellenbaum } 8830a586ceaSMark Shellenbaum } 8840a586ceaSMark Shellenbaum if (found) 8850a586ceaSMark Shellenbaum continue; 8860a586ceaSMark Shellenbaum 8870a586ceaSMark Shellenbaum if (sa->sa_reg_attr_obj) 8880a586ceaSMark Shellenbaum error = zap_lookup(os, sa->sa_reg_attr_obj, 8890a586ceaSMark Shellenbaum reg_attrs[i].sa_name, 8, 1, &attr_value); 8900a586ceaSMark Shellenbaum else 891be6fd75aSMatthew Ahrens error = SET_ERROR(ENOENT); 8920a586ceaSMark Shellenbaum switch (error) { 8930a586ceaSMark Shellenbaum case ENOENT: 8940a586ceaSMark Shellenbaum sa->sa_user_table[i] = (sa_attr_type_t)sa_attr_count; 8950a586ceaSMark Shellenbaum sa_attr_count++; 8960a586ceaSMark Shellenbaum break; 8970a586ceaSMark Shellenbaum case 0: 8980a586ceaSMark Shellenbaum sa->sa_user_table[i] = ATTR_NUM(attr_value); 8990a586ceaSMark Shellenbaum break; 9001d8ccc7bSMark Shellenbaum default: 9011d8ccc7bSMark Shellenbaum goto bail; 9020a586ceaSMark Shellenbaum } 9030a586ceaSMark Shellenbaum } 9040a586ceaSMark Shellenbaum 9051d8ccc7bSMark Shellenbaum sa->sa_num_attrs = sa_attr_count; 9061d8ccc7bSMark Shellenbaum tb = sa->sa_attr_table = 9070a586ceaSMark Shellenbaum kmem_zalloc(sizeof (sa_attr_table_t) * sa_attr_count, KM_SLEEP); 9080a586ceaSMark Shellenbaum 9090a586ceaSMark Shellenbaum /* 9100a586ceaSMark Shellenbaum * Attribute table is constructed from requested attribute list, 9110a586ceaSMark Shellenbaum * previously foreign registered attributes, and also the legacy 9120a586ceaSMark Shellenbaum * ZPL set of attributes. 9130a586ceaSMark Shellenbaum */ 9140a586ceaSMark Shellenbaum 9150a586ceaSMark Shellenbaum if (sa->sa_reg_attr_obj) { 9160a586ceaSMark Shellenbaum for (zap_cursor_init(&zc, os, sa->sa_reg_attr_obj); 9171d8ccc7bSMark Shellenbaum (error = zap_cursor_retrieve(&zc, &za)) == 0; 9180a586ceaSMark Shellenbaum zap_cursor_advance(&zc)) { 9190a586ceaSMark Shellenbaum uint64_t value; 9200a586ceaSMark Shellenbaum value = za.za_first_integer; 9210a586ceaSMark Shellenbaum 9220a586ceaSMark Shellenbaum registered_count++; 9230a586ceaSMark Shellenbaum tb[ATTR_NUM(value)].sa_attr = ATTR_NUM(value); 9240a586ceaSMark Shellenbaum tb[ATTR_NUM(value)].sa_length = ATTR_LENGTH(value); 9250a586ceaSMark Shellenbaum tb[ATTR_NUM(value)].sa_byteswap = ATTR_BSWAP(value); 9260a586ceaSMark Shellenbaum tb[ATTR_NUM(value)].sa_registered = B_TRUE; 9270a586ceaSMark Shellenbaum 9280a586ceaSMark Shellenbaum if (tb[ATTR_NUM(value)].sa_name) { 9290a586ceaSMark Shellenbaum continue; 9300a586ceaSMark Shellenbaum } 9310a586ceaSMark Shellenbaum tb[ATTR_NUM(value)].sa_name = 9320a586ceaSMark Shellenbaum kmem_zalloc(strlen(za.za_name) +1, KM_SLEEP); 9330a586ceaSMark Shellenbaum (void) strlcpy(tb[ATTR_NUM(value)].sa_name, za.za_name, 9340a586ceaSMark Shellenbaum strlen(za.za_name) +1); 9350a586ceaSMark Shellenbaum } 9360a586ceaSMark Shellenbaum zap_cursor_fini(&zc); 9371d8ccc7bSMark Shellenbaum /* 9381d8ccc7bSMark Shellenbaum * Make sure we processed the correct number of registered 9391d8ccc7bSMark Shellenbaum * attributes 9401d8ccc7bSMark Shellenbaum */ 9411d8ccc7bSMark Shellenbaum if (registered_count != sa_reg_count) { 9421d8ccc7bSMark Shellenbaum ASSERT(error != 0); 9431d8ccc7bSMark Shellenbaum goto bail; 9441d8ccc7bSMark Shellenbaum } 9451d8ccc7bSMark Shellenbaum 9460a586ceaSMark Shellenbaum } 9470a586ceaSMark Shellenbaum 9480a586ceaSMark Shellenbaum if (ostype == DMU_OST_ZFS) { 9490a586ceaSMark Shellenbaum for (i = 0; i != sa_legacy_attr_count; i++) { 9500a586ceaSMark Shellenbaum if (tb[i].sa_name) 9510a586ceaSMark Shellenbaum continue; 9520a586ceaSMark Shellenbaum tb[i].sa_attr = sa_legacy_attrs[i].sa_attr; 9530a586ceaSMark Shellenbaum tb[i].sa_length = sa_legacy_attrs[i].sa_length; 9540a586ceaSMark Shellenbaum tb[i].sa_byteswap = sa_legacy_attrs[i].sa_byteswap; 9550a586ceaSMark Shellenbaum tb[i].sa_registered = B_FALSE; 9560a586ceaSMark Shellenbaum tb[i].sa_name = 9570a586ceaSMark Shellenbaum kmem_zalloc(strlen(sa_legacy_attrs[i].sa_name) +1, 9580a586ceaSMark Shellenbaum KM_SLEEP); 9590a586ceaSMark Shellenbaum (void) strlcpy(tb[i].sa_name, 9600a586ceaSMark Shellenbaum sa_legacy_attrs[i].sa_name, 9610a586ceaSMark Shellenbaum strlen(sa_legacy_attrs[i].sa_name) + 1); 9620a586ceaSMark Shellenbaum } 9630a586ceaSMark Shellenbaum } 9640a586ceaSMark Shellenbaum 9650a586ceaSMark Shellenbaum for (i = 0; i != count; i++) { 9660a586ceaSMark Shellenbaum sa_attr_type_t attr_id; 9670a586ceaSMark Shellenbaum 9680a586ceaSMark Shellenbaum attr_id = sa->sa_user_table[i]; 9690a586ceaSMark Shellenbaum if (tb[attr_id].sa_name) 9700a586ceaSMark Shellenbaum continue; 9710a586ceaSMark Shellenbaum 9720a586ceaSMark Shellenbaum tb[attr_id].sa_length = reg_attrs[i].sa_length; 9730a586ceaSMark Shellenbaum tb[attr_id].sa_byteswap = reg_attrs[i].sa_byteswap; 9740a586ceaSMark Shellenbaum tb[attr_id].sa_attr = attr_id; 9750a586ceaSMark Shellenbaum tb[attr_id].sa_name = 9760a586ceaSMark Shellenbaum kmem_zalloc(strlen(reg_attrs[i].sa_name) + 1, KM_SLEEP); 9770a586ceaSMark Shellenbaum (void) strlcpy(tb[attr_id].sa_name, reg_attrs[i].sa_name, 9780a586ceaSMark Shellenbaum strlen(reg_attrs[i].sa_name) + 1); 9790a586ceaSMark Shellenbaum } 9800a586ceaSMark Shellenbaum 9811d8ccc7bSMark Shellenbaum sa->sa_need_attr_registration = 9820a586ceaSMark Shellenbaum (sa_attr_count != registered_count); 9831d8ccc7bSMark Shellenbaum 9841d8ccc7bSMark Shellenbaum return (0); 9851d8ccc7bSMark Shellenbaum bail: 9861d8ccc7bSMark Shellenbaum kmem_free(sa->sa_user_table, count * sizeof (sa_attr_type_t)); 9871d8ccc7bSMark Shellenbaum sa->sa_user_table = NULL; 9881d8ccc7bSMark Shellenbaum sa_free_attr_table(sa); 9891d8ccc7bSMark Shellenbaum return ((error != 0) ? error : EINVAL); 9900a586ceaSMark Shellenbaum } 9910a586ceaSMark Shellenbaum 9921d8ccc7bSMark Shellenbaum int 9931d8ccc7bSMark Shellenbaum sa_setup(objset_t *os, uint64_t sa_obj, sa_attr_reg_t *reg_attrs, int count, 9941d8ccc7bSMark Shellenbaum sa_attr_type_t **user_table) 9950a586ceaSMark Shellenbaum { 9960a586ceaSMark Shellenbaum zap_cursor_t zc; 9970a586ceaSMark Shellenbaum zap_attribute_t za; 9980a586ceaSMark Shellenbaum sa_os_t *sa; 9990a586ceaSMark Shellenbaum dmu_objset_type_t ostype = dmu_objset_type(os); 10000a586ceaSMark Shellenbaum sa_attr_type_t *tb; 10011d8ccc7bSMark Shellenbaum int error; 10020a586ceaSMark Shellenbaum 10033b2aab18SMatthew Ahrens mutex_enter(&os->os_user_ptr_lock); 10040a586ceaSMark Shellenbaum if (os->os_sa) { 10050a586ceaSMark Shellenbaum mutex_enter(&os->os_sa->sa_lock); 10063b2aab18SMatthew Ahrens mutex_exit(&os->os_user_ptr_lock); 10070a586ceaSMark Shellenbaum tb = os->os_sa->sa_user_table; 10080a586ceaSMark Shellenbaum mutex_exit(&os->os_sa->sa_lock); 10091d8ccc7bSMark Shellenbaum *user_table = tb; 10101d8ccc7bSMark Shellenbaum return (0); 10110a586ceaSMark Shellenbaum } 10120a586ceaSMark Shellenbaum 10130a586ceaSMark Shellenbaum sa = kmem_zalloc(sizeof (sa_os_t), KM_SLEEP); 10140a586ceaSMark Shellenbaum mutex_init(&sa->sa_lock, NULL, MUTEX_DEFAULT, NULL); 10150a586ceaSMark Shellenbaum sa->sa_master_obj = sa_obj; 10160a586ceaSMark Shellenbaum 10171d8ccc7bSMark Shellenbaum os->os_sa = sa; 10180a586ceaSMark Shellenbaum mutex_enter(&sa->sa_lock); 10193b2aab18SMatthew Ahrens mutex_exit(&os->os_user_ptr_lock); 10200a586ceaSMark Shellenbaum avl_create(&sa->sa_layout_num_tree, layout_num_compare, 10210a586ceaSMark Shellenbaum sizeof (sa_lot_t), offsetof(sa_lot_t, lot_num_node)); 10220a586ceaSMark Shellenbaum avl_create(&sa->sa_layout_hash_tree, layout_hash_compare, 10230a586ceaSMark Shellenbaum sizeof (sa_lot_t), offsetof(sa_lot_t, lot_hash_node)); 10240a586ceaSMark Shellenbaum 10250a586ceaSMark Shellenbaum if (sa_obj) { 10260a586ceaSMark Shellenbaum error = zap_lookup(os, sa_obj, SA_LAYOUTS, 10270a586ceaSMark Shellenbaum 8, 1, &sa->sa_layout_attr_obj); 10281d8ccc7bSMark Shellenbaum if (error != 0 && error != ENOENT) 10291d8ccc7bSMark Shellenbaum goto fail; 10300a586ceaSMark Shellenbaum error = zap_lookup(os, sa_obj, SA_REGISTRY, 10310a586ceaSMark Shellenbaum 8, 1, &sa->sa_reg_attr_obj); 10321d8ccc7bSMark Shellenbaum if (error != 0 && error != ENOENT) 10331d8ccc7bSMark Shellenbaum goto fail; 10340a586ceaSMark Shellenbaum } 10350a586ceaSMark Shellenbaum 10361d8ccc7bSMark Shellenbaum if ((error = sa_attr_table_setup(os, reg_attrs, count)) != 0) 10371d8ccc7bSMark Shellenbaum goto fail; 10380a586ceaSMark Shellenbaum 10390a586ceaSMark Shellenbaum if (sa->sa_layout_attr_obj != 0) { 10401d8ccc7bSMark Shellenbaum uint64_t layout_count; 10411d8ccc7bSMark Shellenbaum 10421d8ccc7bSMark Shellenbaum error = zap_count(os, sa->sa_layout_attr_obj, 10431d8ccc7bSMark Shellenbaum &layout_count); 10441d8ccc7bSMark Shellenbaum 10451d8ccc7bSMark Shellenbaum /* 10461d8ccc7bSMark Shellenbaum * Layout number count should be > 0 10471d8ccc7bSMark Shellenbaum */ 10481d8ccc7bSMark Shellenbaum if (error || (error == 0 && layout_count == 0)) { 10491d8ccc7bSMark Shellenbaum if (error == 0) 1050be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 10511d8ccc7bSMark Shellenbaum goto fail; 10521d8ccc7bSMark Shellenbaum } 10531d8ccc7bSMark Shellenbaum 10540a586ceaSMark Shellenbaum for (zap_cursor_init(&zc, os, sa->sa_layout_attr_obj); 10551d8ccc7bSMark Shellenbaum (error = zap_cursor_retrieve(&zc, &za)) == 0; 10560a586ceaSMark Shellenbaum zap_cursor_advance(&zc)) { 10570a586ceaSMark Shellenbaum sa_attr_type_t *lot_attrs; 10580a586ceaSMark Shellenbaum uint64_t lot_num; 10590a586ceaSMark Shellenbaum 10600a586ceaSMark Shellenbaum lot_attrs = kmem_zalloc(sizeof (sa_attr_type_t) * 10610a586ceaSMark Shellenbaum za.za_num_integers, KM_SLEEP); 10620a586ceaSMark Shellenbaum 10631d8ccc7bSMark Shellenbaum if ((error = (zap_lookup(os, sa->sa_layout_attr_obj, 10641d8ccc7bSMark Shellenbaum za.za_name, 2, za.za_num_integers, 10651d8ccc7bSMark Shellenbaum lot_attrs))) != 0) { 10661d8ccc7bSMark Shellenbaum kmem_free(lot_attrs, sizeof (sa_attr_type_t) * 10671d8ccc7bSMark Shellenbaum za.za_num_integers); 10681d8ccc7bSMark Shellenbaum break; 10691d8ccc7bSMark Shellenbaum } 10700a586ceaSMark Shellenbaum VERIFY(ddi_strtoull(za.za_name, NULL, 10, 10710a586ceaSMark Shellenbaum (unsigned long long *)&lot_num) == 0); 10720a586ceaSMark Shellenbaum 10730a586ceaSMark Shellenbaum (void) sa_add_layout_entry(os, lot_attrs, 10740a586ceaSMark Shellenbaum za.za_num_integers, lot_num, 10750a586ceaSMark Shellenbaum sa_layout_info_hash(lot_attrs, 10760a586ceaSMark Shellenbaum za.za_num_integers), B_FALSE, NULL); 10770a586ceaSMark Shellenbaum kmem_free(lot_attrs, sizeof (sa_attr_type_t) * 10780a586ceaSMark Shellenbaum za.za_num_integers); 10790a586ceaSMark Shellenbaum } 10800a586ceaSMark Shellenbaum zap_cursor_fini(&zc); 10811d8ccc7bSMark Shellenbaum 10821d8ccc7bSMark Shellenbaum /* 10831d8ccc7bSMark Shellenbaum * Make sure layout count matches number of entries added 10841d8ccc7bSMark Shellenbaum * to AVL tree 10851d8ccc7bSMark Shellenbaum */ 10861d8ccc7bSMark Shellenbaum if (avl_numnodes(&sa->sa_layout_num_tree) != layout_count) { 10871d8ccc7bSMark Shellenbaum ASSERT(error != 0); 10881d8ccc7bSMark Shellenbaum goto fail; 10891d8ccc7bSMark Shellenbaum } 10900a586ceaSMark Shellenbaum } 10910a586ceaSMark Shellenbaum 10920a586ceaSMark Shellenbaum /* Add special layout number for old ZNODES */ 10930a586ceaSMark Shellenbaum if (ostype == DMU_OST_ZFS) { 10940a586ceaSMark Shellenbaum (void) sa_add_layout_entry(os, sa_legacy_zpl_layout, 10950a586ceaSMark Shellenbaum sa_legacy_attr_count, 0, 10960a586ceaSMark Shellenbaum sa_layout_info_hash(sa_legacy_zpl_layout, 10970a586ceaSMark Shellenbaum sa_legacy_attr_count), B_FALSE, NULL); 10980a586ceaSMark Shellenbaum 10990a586ceaSMark Shellenbaum (void) sa_add_layout_entry(os, sa_dummy_zpl_layout, 0, 1, 11000a586ceaSMark Shellenbaum 0, B_FALSE, NULL); 11010a586ceaSMark Shellenbaum } 11021d8ccc7bSMark Shellenbaum *user_table = os->os_sa->sa_user_table; 11030a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 11041d8ccc7bSMark Shellenbaum return (0); 11051d8ccc7bSMark Shellenbaum fail: 11061d8ccc7bSMark Shellenbaum os->os_sa = NULL; 11071d8ccc7bSMark Shellenbaum sa_free_attr_table(sa); 11081d8ccc7bSMark Shellenbaum if (sa->sa_user_table) 11091d8ccc7bSMark Shellenbaum kmem_free(sa->sa_user_table, sa->sa_user_table_sz); 11101d8ccc7bSMark Shellenbaum mutex_exit(&sa->sa_lock); 1111*d2b3cbbdSJorgen Lundman avl_destroy(&sa->sa_layout_hash_tree); 1112*d2b3cbbdSJorgen Lundman avl_destroy(&sa->sa_layout_num_tree); 1113*d2b3cbbdSJorgen Lundman mutex_destroy(&sa->sa_lock); 11141d8ccc7bSMark Shellenbaum kmem_free(sa, sizeof (sa_os_t)); 11151d8ccc7bSMark Shellenbaum return ((error == ECKSUM) ? EIO : error); 11160a586ceaSMark Shellenbaum } 11170a586ceaSMark Shellenbaum 11180a586ceaSMark Shellenbaum void 11190a586ceaSMark Shellenbaum sa_tear_down(objset_t *os) 11200a586ceaSMark Shellenbaum { 11210a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 11220a586ceaSMark Shellenbaum sa_lot_t *layout; 11230a586ceaSMark Shellenbaum void *cookie; 11240a586ceaSMark Shellenbaum 11250a586ceaSMark Shellenbaum kmem_free(sa->sa_user_table, sa->sa_user_table_sz); 11260a586ceaSMark Shellenbaum 11270a586ceaSMark Shellenbaum /* Free up attr table */ 11280a586ceaSMark Shellenbaum 11291d8ccc7bSMark Shellenbaum sa_free_attr_table(sa); 11300a586ceaSMark Shellenbaum 11310a586ceaSMark Shellenbaum cookie = NULL; 11320a586ceaSMark Shellenbaum while (layout = avl_destroy_nodes(&sa->sa_layout_hash_tree, &cookie)) { 11330a586ceaSMark Shellenbaum sa_idx_tab_t *tab; 11340a586ceaSMark Shellenbaum while (tab = list_head(&layout->lot_idx_tab)) { 11350a586ceaSMark Shellenbaum ASSERT(refcount_count(&tab->sa_refcount)); 11360a586ceaSMark Shellenbaum sa_idx_tab_rele(os, tab); 11370a586ceaSMark Shellenbaum } 11380a586ceaSMark Shellenbaum } 11390a586ceaSMark Shellenbaum 11400a586ceaSMark Shellenbaum cookie = NULL; 11410a586ceaSMark Shellenbaum while (layout = avl_destroy_nodes(&sa->sa_layout_num_tree, &cookie)) { 11420a586ceaSMark Shellenbaum kmem_free(layout->lot_attrs, 11430a586ceaSMark Shellenbaum sizeof (sa_attr_type_t) * layout->lot_attr_count); 11440a586ceaSMark Shellenbaum kmem_free(layout, sizeof (sa_lot_t)); 11450a586ceaSMark Shellenbaum } 11460a586ceaSMark Shellenbaum 11470a586ceaSMark Shellenbaum avl_destroy(&sa->sa_layout_hash_tree); 11480a586ceaSMark Shellenbaum avl_destroy(&sa->sa_layout_num_tree); 1149*d2b3cbbdSJorgen Lundman mutex_destroy(&sa->sa_lock); 11500a586ceaSMark Shellenbaum 11510a586ceaSMark Shellenbaum kmem_free(sa, sizeof (sa_os_t)); 11520a586ceaSMark Shellenbaum os->os_sa = NULL; 11530a586ceaSMark Shellenbaum } 11540a586ceaSMark Shellenbaum 11550a586ceaSMark Shellenbaum void 11560a586ceaSMark Shellenbaum sa_build_idx_tab(void *hdr, void *attr_addr, sa_attr_type_t attr, 11570a586ceaSMark Shellenbaum uint16_t length, int length_idx, boolean_t var_length, void *userp) 11580a586ceaSMark Shellenbaum { 11590a586ceaSMark Shellenbaum sa_idx_tab_t *idx_tab = userp; 11600a586ceaSMark Shellenbaum 11610a586ceaSMark Shellenbaum if (var_length) { 11620a586ceaSMark Shellenbaum ASSERT(idx_tab->sa_variable_lengths); 11630a586ceaSMark Shellenbaum idx_tab->sa_variable_lengths[length_idx] = length; 11640a586ceaSMark Shellenbaum } 11650a586ceaSMark Shellenbaum TOC_ATTR_ENCODE(idx_tab->sa_idx_tab[attr], length_idx, 11660a586ceaSMark Shellenbaum (uint32_t)((uintptr_t)attr_addr - (uintptr_t)hdr)); 11670a586ceaSMark Shellenbaum } 11680a586ceaSMark Shellenbaum 11690a586ceaSMark Shellenbaum static void 11700a586ceaSMark Shellenbaum sa_attr_iter(objset_t *os, sa_hdr_phys_t *hdr, dmu_object_type_t type, 11710a586ceaSMark Shellenbaum sa_iterfunc_t func, sa_lot_t *tab, void *userp) 11720a586ceaSMark Shellenbaum { 11730a586ceaSMark Shellenbaum void *data_start; 11740a586ceaSMark Shellenbaum sa_lot_t *tb = tab; 11750a586ceaSMark Shellenbaum sa_lot_t search; 11760a586ceaSMark Shellenbaum avl_index_t loc; 11770a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 11780a586ceaSMark Shellenbaum int i; 117906e0070dSMark Shellenbaum uint16_t *length_start = NULL; 11800a586ceaSMark Shellenbaum uint8_t length_idx = 0; 11810a586ceaSMark Shellenbaum 11820a586ceaSMark Shellenbaum if (tab == NULL) { 11830a586ceaSMark Shellenbaum search.lot_num = SA_LAYOUT_NUM(hdr, type); 11840a586ceaSMark Shellenbaum tb = avl_find(&sa->sa_layout_num_tree, &search, &loc); 11850a586ceaSMark Shellenbaum ASSERT(tb); 11860a586ceaSMark Shellenbaum } 11870a586ceaSMark Shellenbaum 11880a586ceaSMark Shellenbaum if (IS_SA_BONUSTYPE(type)) { 11890a586ceaSMark Shellenbaum data_start = (void *)P2ROUNDUP(((uintptr_t)hdr + 11900a586ceaSMark Shellenbaum offsetof(sa_hdr_phys_t, sa_lengths) + 11910a586ceaSMark Shellenbaum (sizeof (uint16_t) * tb->lot_var_sizes)), 8); 11920a586ceaSMark Shellenbaum length_start = hdr->sa_lengths; 11930a586ceaSMark Shellenbaum } else { 11940a586ceaSMark Shellenbaum data_start = hdr; 11950a586ceaSMark Shellenbaum } 11960a586ceaSMark Shellenbaum 11970a586ceaSMark Shellenbaum for (i = 0; i != tb->lot_attr_count; i++) { 11980a586ceaSMark Shellenbaum int attr_length, reg_length; 11990a586ceaSMark Shellenbaum uint8_t idx_len; 12000a586ceaSMark Shellenbaum 12010a586ceaSMark Shellenbaum reg_length = sa->sa_attr_table[tb->lot_attrs[i]].sa_length; 12020a586ceaSMark Shellenbaum if (reg_length) { 12030a586ceaSMark Shellenbaum attr_length = reg_length; 12040a586ceaSMark Shellenbaum idx_len = 0; 12050a586ceaSMark Shellenbaum } else { 12060a586ceaSMark Shellenbaum attr_length = length_start[length_idx]; 12070a586ceaSMark Shellenbaum idx_len = length_idx++; 12080a586ceaSMark Shellenbaum } 12090a586ceaSMark Shellenbaum 12100a586ceaSMark Shellenbaum func(hdr, data_start, tb->lot_attrs[i], attr_length, 12110a586ceaSMark Shellenbaum idx_len, reg_length == 0 ? B_TRUE : B_FALSE, userp); 12120a586ceaSMark Shellenbaum 12130a586ceaSMark Shellenbaum data_start = (void *)P2ROUNDUP(((uintptr_t)data_start + 12140a586ceaSMark Shellenbaum attr_length), 8); 12150a586ceaSMark Shellenbaum } 12160a586ceaSMark Shellenbaum } 12170a586ceaSMark Shellenbaum 12180a586ceaSMark Shellenbaum /*ARGSUSED*/ 12190a586ceaSMark Shellenbaum void 12200a586ceaSMark Shellenbaum sa_byteswap_cb(void *hdr, void *attr_addr, sa_attr_type_t attr, 12210a586ceaSMark Shellenbaum uint16_t length, int length_idx, boolean_t variable_length, void *userp) 12220a586ceaSMark Shellenbaum { 12230a586ceaSMark Shellenbaum sa_handle_t *hdl = userp; 12240a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 12250a586ceaSMark Shellenbaum 12260a586ceaSMark Shellenbaum sa_bswap_table[sa->sa_attr_table[attr].sa_byteswap](attr_addr, length); 12270a586ceaSMark Shellenbaum } 12280a586ceaSMark Shellenbaum 12290a586ceaSMark Shellenbaum void 12300a586ceaSMark Shellenbaum sa_byteswap(sa_handle_t *hdl, sa_buf_type_t buftype) 12310a586ceaSMark Shellenbaum { 12320a586ceaSMark Shellenbaum sa_hdr_phys_t *sa_hdr_phys = SA_GET_HDR(hdl, buftype); 12330a586ceaSMark Shellenbaum dmu_buf_impl_t *db; 12340a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 12350a586ceaSMark Shellenbaum int num_lengths = 1; 12360a586ceaSMark Shellenbaum int i; 12370a586ceaSMark Shellenbaum 12380a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&sa->sa_lock)); 12390a586ceaSMark Shellenbaum if (sa_hdr_phys->sa_magic == SA_MAGIC) 12400a586ceaSMark Shellenbaum return; 12410a586ceaSMark Shellenbaum 12420a586ceaSMark Shellenbaum db = SA_GET_DB(hdl, buftype); 12430a586ceaSMark Shellenbaum 12440a586ceaSMark Shellenbaum if (buftype == SA_SPILL) { 12450a586ceaSMark Shellenbaum arc_release(db->db_buf, NULL); 12460a586ceaSMark Shellenbaum arc_buf_thaw(db->db_buf); 12470a586ceaSMark Shellenbaum } 12480a586ceaSMark Shellenbaum 12490a586ceaSMark Shellenbaum sa_hdr_phys->sa_magic = BSWAP_32(sa_hdr_phys->sa_magic); 12500a586ceaSMark Shellenbaum sa_hdr_phys->sa_layout_info = BSWAP_16(sa_hdr_phys->sa_layout_info); 12510a586ceaSMark Shellenbaum 12520a586ceaSMark Shellenbaum /* 12530a586ceaSMark Shellenbaum * Determine number of variable lenghts in header 12540a586ceaSMark Shellenbaum * The standard 8 byte header has one for free and a 12550a586ceaSMark Shellenbaum * 16 byte header would have 4 + 1; 12560a586ceaSMark Shellenbaum */ 12570a586ceaSMark Shellenbaum if (SA_HDR_SIZE(sa_hdr_phys) > 8) 12580a586ceaSMark Shellenbaum num_lengths += (SA_HDR_SIZE(sa_hdr_phys) - 8) >> 1; 12590a586ceaSMark Shellenbaum for (i = 0; i != num_lengths; i++) 12600a586ceaSMark Shellenbaum sa_hdr_phys->sa_lengths[i] = 12610a586ceaSMark Shellenbaum BSWAP_16(sa_hdr_phys->sa_lengths[i]); 12620a586ceaSMark Shellenbaum 12630a586ceaSMark Shellenbaum sa_attr_iter(hdl->sa_os, sa_hdr_phys, DMU_OT_SA, 12640a586ceaSMark Shellenbaum sa_byteswap_cb, NULL, hdl); 12650a586ceaSMark Shellenbaum 12660a586ceaSMark Shellenbaum if (buftype == SA_SPILL) 12670a586ceaSMark Shellenbaum arc_buf_freeze(((dmu_buf_impl_t *)hdl->sa_spill)->db_buf); 12680a586ceaSMark Shellenbaum } 12690a586ceaSMark Shellenbaum 12700a586ceaSMark Shellenbaum static int 12710a586ceaSMark Shellenbaum sa_build_index(sa_handle_t *hdl, sa_buf_type_t buftype) 12720a586ceaSMark Shellenbaum { 12730a586ceaSMark Shellenbaum sa_hdr_phys_t *sa_hdr_phys; 12740a586ceaSMark Shellenbaum dmu_buf_impl_t *db = SA_GET_DB(hdl, buftype); 12750a586ceaSMark Shellenbaum dmu_object_type_t bonustype = SA_BONUSTYPE_FROM_DB(db); 12760a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 12770a586ceaSMark Shellenbaum sa_idx_tab_t *idx_tab; 12780a586ceaSMark Shellenbaum 12790a586ceaSMark Shellenbaum sa_hdr_phys = SA_GET_HDR(hdl, buftype); 12800a586ceaSMark Shellenbaum 12810a586ceaSMark Shellenbaum mutex_enter(&sa->sa_lock); 12820a586ceaSMark Shellenbaum 12830a586ceaSMark Shellenbaum /* Do we need to byteswap? */ 12840a586ceaSMark Shellenbaum 12850a586ceaSMark Shellenbaum /* only check if not old znode */ 12860a586ceaSMark Shellenbaum if (IS_SA_BONUSTYPE(bonustype) && sa_hdr_phys->sa_magic != SA_MAGIC && 12870a586ceaSMark Shellenbaum sa_hdr_phys->sa_magic != 0) { 12880a586ceaSMark Shellenbaum VERIFY(BSWAP_32(sa_hdr_phys->sa_magic) == SA_MAGIC); 12890a586ceaSMark Shellenbaum sa_byteswap(hdl, buftype); 12900a586ceaSMark Shellenbaum } 12910a586ceaSMark Shellenbaum 12920a586ceaSMark Shellenbaum idx_tab = sa_find_idx_tab(hdl->sa_os, bonustype, sa_hdr_phys); 12930a586ceaSMark Shellenbaum 12940a586ceaSMark Shellenbaum if (buftype == SA_BONUS) 12950a586ceaSMark Shellenbaum hdl->sa_bonus_tab = idx_tab; 12960a586ceaSMark Shellenbaum else 12970a586ceaSMark Shellenbaum hdl->sa_spill_tab = idx_tab; 12980a586ceaSMark Shellenbaum 12990a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 13000a586ceaSMark Shellenbaum return (0); 13010a586ceaSMark Shellenbaum } 13020a586ceaSMark Shellenbaum 13030a586ceaSMark Shellenbaum /*ARGSUSED*/ 13040a586ceaSMark Shellenbaum void 13050a586ceaSMark Shellenbaum sa_evict(dmu_buf_t *db, void *sap) 13060a586ceaSMark Shellenbaum { 13070a586ceaSMark Shellenbaum panic("evicting sa dbuf %p\n", (void *)db); 13080a586ceaSMark Shellenbaum } 13090a586ceaSMark Shellenbaum 13100a586ceaSMark Shellenbaum static void 13110a586ceaSMark Shellenbaum sa_idx_tab_rele(objset_t *os, void *arg) 13120a586ceaSMark Shellenbaum { 13130a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 13140a586ceaSMark Shellenbaum sa_idx_tab_t *idx_tab = arg; 13150a586ceaSMark Shellenbaum 13160a586ceaSMark Shellenbaum if (idx_tab == NULL) 13170a586ceaSMark Shellenbaum return; 13180a586ceaSMark Shellenbaum 13190a586ceaSMark Shellenbaum mutex_enter(&sa->sa_lock); 13200a586ceaSMark Shellenbaum if (refcount_remove(&idx_tab->sa_refcount, NULL) == 0) { 13210a586ceaSMark Shellenbaum list_remove(&idx_tab->sa_layout->lot_idx_tab, idx_tab); 13220a586ceaSMark Shellenbaum if (idx_tab->sa_variable_lengths) 13230a586ceaSMark Shellenbaum kmem_free(idx_tab->sa_variable_lengths, 13240a586ceaSMark Shellenbaum sizeof (uint16_t) * 13250a586ceaSMark Shellenbaum idx_tab->sa_layout->lot_var_sizes); 13260a586ceaSMark Shellenbaum refcount_destroy(&idx_tab->sa_refcount); 13270a586ceaSMark Shellenbaum kmem_free(idx_tab->sa_idx_tab, 13280a586ceaSMark Shellenbaum sizeof (uint32_t) * sa->sa_num_attrs); 13290a586ceaSMark Shellenbaum kmem_free(idx_tab, sizeof (sa_idx_tab_t)); 13300a586ceaSMark Shellenbaum } 13310a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 13320a586ceaSMark Shellenbaum } 13330a586ceaSMark Shellenbaum 13340a586ceaSMark Shellenbaum static void 13350a586ceaSMark Shellenbaum sa_idx_tab_hold(objset_t *os, sa_idx_tab_t *idx_tab) 13360a586ceaSMark Shellenbaum { 13370a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 13380a586ceaSMark Shellenbaum 13390a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&sa->sa_lock)); 13400a586ceaSMark Shellenbaum (void) refcount_add(&idx_tab->sa_refcount, NULL); 13410a586ceaSMark Shellenbaum } 13420a586ceaSMark Shellenbaum 13430a586ceaSMark Shellenbaum void 13440a586ceaSMark Shellenbaum sa_handle_destroy(sa_handle_t *hdl) 13450a586ceaSMark Shellenbaum { 13460a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 13470a586ceaSMark Shellenbaum (void) dmu_buf_update_user((dmu_buf_t *)hdl->sa_bonus, hdl, 13480a586ceaSMark Shellenbaum NULL, NULL, NULL); 13490a586ceaSMark Shellenbaum 13500a586ceaSMark Shellenbaum if (hdl->sa_bonus_tab) { 13510a586ceaSMark Shellenbaum sa_idx_tab_rele(hdl->sa_os, hdl->sa_bonus_tab); 13520a586ceaSMark Shellenbaum hdl->sa_bonus_tab = NULL; 13530a586ceaSMark Shellenbaum } 13540a586ceaSMark Shellenbaum if (hdl->sa_spill_tab) { 13550a586ceaSMark Shellenbaum sa_idx_tab_rele(hdl->sa_os, hdl->sa_spill_tab); 13560a586ceaSMark Shellenbaum hdl->sa_spill_tab = NULL; 13570a586ceaSMark Shellenbaum } 13580a586ceaSMark Shellenbaum 13590a586ceaSMark Shellenbaum dmu_buf_rele(hdl->sa_bonus, NULL); 13600a586ceaSMark Shellenbaum 13610a586ceaSMark Shellenbaum if (hdl->sa_spill) 13620a586ceaSMark Shellenbaum dmu_buf_rele((dmu_buf_t *)hdl->sa_spill, NULL); 13630a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 13640a586ceaSMark Shellenbaum 13650a586ceaSMark Shellenbaum kmem_cache_free(sa_cache, hdl); 13660a586ceaSMark Shellenbaum } 13670a586ceaSMark Shellenbaum 13680a586ceaSMark Shellenbaum int 13690a586ceaSMark Shellenbaum sa_handle_get_from_db(objset_t *os, dmu_buf_t *db, void *userp, 13700a586ceaSMark Shellenbaum sa_handle_type_t hdl_type, sa_handle_t **handlepp) 13710a586ceaSMark Shellenbaum { 13720a586ceaSMark Shellenbaum int error = 0; 13730a586ceaSMark Shellenbaum dmu_object_info_t doi; 13740a586ceaSMark Shellenbaum sa_handle_t *handle; 13750a586ceaSMark Shellenbaum 13760a586ceaSMark Shellenbaum #ifdef ZFS_DEBUG 13770a586ceaSMark Shellenbaum dmu_object_info_from_db(db, &doi); 13780a586ceaSMark Shellenbaum ASSERT(doi.doi_bonus_type == DMU_OT_SA || 13790a586ceaSMark Shellenbaum doi.doi_bonus_type == DMU_OT_ZNODE); 13800a586ceaSMark Shellenbaum #endif 13810a586ceaSMark Shellenbaum /* find handle, if it exists */ 13820a586ceaSMark Shellenbaum /* if one doesn't exist then create a new one, and initialize it */ 13830a586ceaSMark Shellenbaum 13840a586ceaSMark Shellenbaum handle = (hdl_type == SA_HDL_SHARED) ? dmu_buf_get_user(db) : NULL; 13850a586ceaSMark Shellenbaum if (handle == NULL) { 13860a586ceaSMark Shellenbaum sa_handle_t *newhandle; 13870a586ceaSMark Shellenbaum handle = kmem_cache_alloc(sa_cache, KM_SLEEP); 13880a586ceaSMark Shellenbaum handle->sa_userp = userp; 13890a586ceaSMark Shellenbaum handle->sa_bonus = db; 13900a586ceaSMark Shellenbaum handle->sa_os = os; 13910a586ceaSMark Shellenbaum handle->sa_spill = NULL; 13920a586ceaSMark Shellenbaum 13930a586ceaSMark Shellenbaum error = sa_build_index(handle, SA_BONUS); 13940a586ceaSMark Shellenbaum newhandle = (hdl_type == SA_HDL_SHARED) ? 13950a586ceaSMark Shellenbaum dmu_buf_set_user_ie(db, handle, 13960a586ceaSMark Shellenbaum NULL, sa_evict) : NULL; 13970a586ceaSMark Shellenbaum 13980a586ceaSMark Shellenbaum if (newhandle != NULL) { 13990a586ceaSMark Shellenbaum kmem_cache_free(sa_cache, handle); 14000a586ceaSMark Shellenbaum handle = newhandle; 14010a586ceaSMark Shellenbaum } 14020a586ceaSMark Shellenbaum } 14030a586ceaSMark Shellenbaum *handlepp = handle; 14040a586ceaSMark Shellenbaum 14050a586ceaSMark Shellenbaum return (error); 14060a586ceaSMark Shellenbaum } 14070a586ceaSMark Shellenbaum 14080a586ceaSMark Shellenbaum int 14090a586ceaSMark Shellenbaum sa_handle_get(objset_t *objset, uint64_t objid, void *userp, 14100a586ceaSMark Shellenbaum sa_handle_type_t hdl_type, sa_handle_t **handlepp) 14110a586ceaSMark Shellenbaum { 14120a586ceaSMark Shellenbaum dmu_buf_t *db; 14130a586ceaSMark Shellenbaum int error; 14140a586ceaSMark Shellenbaum 14150a586ceaSMark Shellenbaum if (error = dmu_bonus_hold(objset, objid, NULL, &db)) 14160a586ceaSMark Shellenbaum return (error); 14170a586ceaSMark Shellenbaum 14180a586ceaSMark Shellenbaum return (sa_handle_get_from_db(objset, db, userp, hdl_type, 14190a586ceaSMark Shellenbaum handlepp)); 14200a586ceaSMark Shellenbaum } 14210a586ceaSMark Shellenbaum 14220a586ceaSMark Shellenbaum int 14230a586ceaSMark Shellenbaum sa_buf_hold(objset_t *objset, uint64_t obj_num, void *tag, dmu_buf_t **db) 14240a586ceaSMark Shellenbaum { 14250a586ceaSMark Shellenbaum return (dmu_bonus_hold(objset, obj_num, tag, db)); 14260a586ceaSMark Shellenbaum } 14270a586ceaSMark Shellenbaum 14280a586ceaSMark Shellenbaum void 14290a586ceaSMark Shellenbaum sa_buf_rele(dmu_buf_t *db, void *tag) 14300a586ceaSMark Shellenbaum { 14310a586ceaSMark Shellenbaum dmu_buf_rele(db, tag); 14320a586ceaSMark Shellenbaum } 14330a586ceaSMark Shellenbaum 14340a586ceaSMark Shellenbaum int 14350a586ceaSMark Shellenbaum sa_lookup_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count) 14360a586ceaSMark Shellenbaum { 14370a586ceaSMark Shellenbaum ASSERT(hdl); 14380a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&hdl->sa_lock)); 14390a586ceaSMark Shellenbaum return (sa_attr_op(hdl, bulk, count, SA_LOOKUP, NULL)); 14400a586ceaSMark Shellenbaum } 14410a586ceaSMark Shellenbaum 14420a586ceaSMark Shellenbaum int 14430a586ceaSMark Shellenbaum sa_lookup(sa_handle_t *hdl, sa_attr_type_t attr, void *buf, uint32_t buflen) 14440a586ceaSMark Shellenbaum { 14450a586ceaSMark Shellenbaum int error; 14460a586ceaSMark Shellenbaum sa_bulk_attr_t bulk; 14470a586ceaSMark Shellenbaum 14480a586ceaSMark Shellenbaum bulk.sa_attr = attr; 14490a586ceaSMark Shellenbaum bulk.sa_data = buf; 14500a586ceaSMark Shellenbaum bulk.sa_length = buflen; 14510a586ceaSMark Shellenbaum bulk.sa_data_func = NULL; 14520a586ceaSMark Shellenbaum 14530a586ceaSMark Shellenbaum ASSERT(hdl); 14540a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 14550a586ceaSMark Shellenbaum error = sa_lookup_impl(hdl, &bulk, 1); 14560a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 14570a586ceaSMark Shellenbaum return (error); 14580a586ceaSMark Shellenbaum } 14590a586ceaSMark Shellenbaum 14600a586ceaSMark Shellenbaum #ifdef _KERNEL 14610a586ceaSMark Shellenbaum int 14620a586ceaSMark Shellenbaum sa_lookup_uio(sa_handle_t *hdl, sa_attr_type_t attr, uio_t *uio) 14630a586ceaSMark Shellenbaum { 14640a586ceaSMark Shellenbaum int error; 14650a586ceaSMark Shellenbaum sa_bulk_attr_t bulk; 14660a586ceaSMark Shellenbaum 14670a586ceaSMark Shellenbaum bulk.sa_data = NULL; 14680a586ceaSMark Shellenbaum bulk.sa_attr = attr; 14690a586ceaSMark Shellenbaum bulk.sa_data_func = NULL; 14700a586ceaSMark Shellenbaum 14710a586ceaSMark Shellenbaum ASSERT(hdl); 14720a586ceaSMark Shellenbaum 14730a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 14741d8ccc7bSMark Shellenbaum if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) == 0) { 14750a586ceaSMark Shellenbaum error = uiomove((void *)bulk.sa_addr, MIN(bulk.sa_size, 14760a586ceaSMark Shellenbaum uio->uio_resid), UIO_READ, uio); 14770a586ceaSMark Shellenbaum } 14780a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 14790a586ceaSMark Shellenbaum return (error); 14800a586ceaSMark Shellenbaum 14810a586ceaSMark Shellenbaum } 14820a586ceaSMark Shellenbaum #endif 14830a586ceaSMark Shellenbaum 14840a586ceaSMark Shellenbaum void * 14850a586ceaSMark Shellenbaum sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype, void *data) 14860a586ceaSMark Shellenbaum { 14870a586ceaSMark Shellenbaum sa_idx_tab_t *idx_tab; 14880a586ceaSMark Shellenbaum sa_hdr_phys_t *hdr = (sa_hdr_phys_t *)data; 14890a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 14900a586ceaSMark Shellenbaum sa_lot_t *tb, search; 14910a586ceaSMark Shellenbaum avl_index_t loc; 14920a586ceaSMark Shellenbaum 14930a586ceaSMark Shellenbaum /* 14940a586ceaSMark Shellenbaum * Deterimine layout number. If SA node and header == 0 then 14950a586ceaSMark Shellenbaum * force the index table to the dummy "1" empty layout. 14960a586ceaSMark Shellenbaum * 14970a586ceaSMark Shellenbaum * The layout number would only be zero for a newly created file 14980a586ceaSMark Shellenbaum * that has not added any attributes yet, or with crypto enabled which 14990a586ceaSMark Shellenbaum * doesn't write any attributes to the bonus buffer. 15000a586ceaSMark Shellenbaum */ 15010a586ceaSMark Shellenbaum 15020a586ceaSMark Shellenbaum search.lot_num = SA_LAYOUT_NUM(hdr, bonustype); 15030a586ceaSMark Shellenbaum 15040a586ceaSMark Shellenbaum tb = avl_find(&sa->sa_layout_num_tree, &search, &loc); 15050a586ceaSMark Shellenbaum 15060a586ceaSMark Shellenbaum /* Verify header size is consistent with layout information */ 15070a586ceaSMark Shellenbaum ASSERT(tb); 15080a586ceaSMark Shellenbaum ASSERT(IS_SA_BONUSTYPE(bonustype) && 15090a586ceaSMark Shellenbaum SA_HDR_SIZE_MATCH_LAYOUT(hdr, tb) || !IS_SA_BONUSTYPE(bonustype) || 15100a586ceaSMark Shellenbaum (IS_SA_BONUSTYPE(bonustype) && hdr->sa_layout_info == 0)); 15110a586ceaSMark Shellenbaum 15120a586ceaSMark Shellenbaum /* 15130a586ceaSMark Shellenbaum * See if any of the already existing TOC entries can be reused? 15140a586ceaSMark Shellenbaum */ 15150a586ceaSMark Shellenbaum 15160a586ceaSMark Shellenbaum for (idx_tab = list_head(&tb->lot_idx_tab); idx_tab; 15170a586ceaSMark Shellenbaum idx_tab = list_next(&tb->lot_idx_tab, idx_tab)) { 15180a586ceaSMark Shellenbaum boolean_t valid_idx = B_TRUE; 15190a586ceaSMark Shellenbaum int i; 15200a586ceaSMark Shellenbaum 15210a586ceaSMark Shellenbaum if (tb->lot_var_sizes != 0 && 15220a586ceaSMark Shellenbaum idx_tab->sa_variable_lengths != NULL) { 15230a586ceaSMark Shellenbaum for (i = 0; i != tb->lot_var_sizes; i++) { 15240a586ceaSMark Shellenbaum if (hdr->sa_lengths[i] != 15250a586ceaSMark Shellenbaum idx_tab->sa_variable_lengths[i]) { 15260a586ceaSMark Shellenbaum valid_idx = B_FALSE; 15270a586ceaSMark Shellenbaum break; 15280a586ceaSMark Shellenbaum } 15290a586ceaSMark Shellenbaum } 15300a586ceaSMark Shellenbaum } 15310a586ceaSMark Shellenbaum if (valid_idx) { 15320a586ceaSMark Shellenbaum sa_idx_tab_hold(os, idx_tab); 15330a586ceaSMark Shellenbaum return (idx_tab); 15340a586ceaSMark Shellenbaum } 15350a586ceaSMark Shellenbaum } 15360a586ceaSMark Shellenbaum 15370a586ceaSMark Shellenbaum /* No such luck, create a new entry */ 15380a586ceaSMark Shellenbaum idx_tab = kmem_zalloc(sizeof (sa_idx_tab_t), KM_SLEEP); 15390a586ceaSMark Shellenbaum idx_tab->sa_idx_tab = 15400a586ceaSMark Shellenbaum kmem_zalloc(sizeof (uint32_t) * sa->sa_num_attrs, KM_SLEEP); 15410a586ceaSMark Shellenbaum idx_tab->sa_layout = tb; 15420a586ceaSMark Shellenbaum refcount_create(&idx_tab->sa_refcount); 15430a586ceaSMark Shellenbaum if (tb->lot_var_sizes) 15440a586ceaSMark Shellenbaum idx_tab->sa_variable_lengths = kmem_alloc(sizeof (uint16_t) * 15450a586ceaSMark Shellenbaum tb->lot_var_sizes, KM_SLEEP); 15460a586ceaSMark Shellenbaum 15470a586ceaSMark Shellenbaum sa_attr_iter(os, hdr, bonustype, sa_build_idx_tab, 15480a586ceaSMark Shellenbaum tb, idx_tab); 15490a586ceaSMark Shellenbaum sa_idx_tab_hold(os, idx_tab); /* one hold for consumer */ 15500a586ceaSMark Shellenbaum sa_idx_tab_hold(os, idx_tab); /* one for layout */ 15510a586ceaSMark Shellenbaum list_insert_tail(&tb->lot_idx_tab, idx_tab); 15520a586ceaSMark Shellenbaum return (idx_tab); 15530a586ceaSMark Shellenbaum } 15540a586ceaSMark Shellenbaum 15550a586ceaSMark Shellenbaum void 15560a586ceaSMark Shellenbaum sa_default_locator(void **dataptr, uint32_t *len, uint32_t total_len, 15570a586ceaSMark Shellenbaum boolean_t start, void *userdata) 15580a586ceaSMark Shellenbaum { 15590a586ceaSMark Shellenbaum ASSERT(start); 15600a586ceaSMark Shellenbaum 15610a586ceaSMark Shellenbaum *dataptr = userdata; 15620a586ceaSMark Shellenbaum *len = total_len; 15630a586ceaSMark Shellenbaum } 15640a586ceaSMark Shellenbaum 15650a586ceaSMark Shellenbaum static void 15660a586ceaSMark Shellenbaum sa_attr_register_sync(sa_handle_t *hdl, dmu_tx_t *tx) 15670a586ceaSMark Shellenbaum { 15680a586ceaSMark Shellenbaum uint64_t attr_value = 0; 15690a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 15700a586ceaSMark Shellenbaum sa_attr_table_t *tb = sa->sa_attr_table; 15710a586ceaSMark Shellenbaum int i; 15720a586ceaSMark Shellenbaum 15730a586ceaSMark Shellenbaum mutex_enter(&sa->sa_lock); 15740a586ceaSMark Shellenbaum 15750a586ceaSMark Shellenbaum if (!sa->sa_need_attr_registration || sa->sa_master_obj == NULL) { 15760a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 15770a586ceaSMark Shellenbaum return; 15780a586ceaSMark Shellenbaum } 15790a586ceaSMark Shellenbaum 15800a586ceaSMark Shellenbaum if (sa->sa_reg_attr_obj == NULL) { 1581ad135b5dSChristopher Siden sa->sa_reg_attr_obj = zap_create_link(hdl->sa_os, 1582ad135b5dSChristopher Siden DMU_OT_SA_ATTR_REGISTRATION, 1583ad135b5dSChristopher Siden sa->sa_master_obj, SA_REGISTRY, tx); 15840a586ceaSMark Shellenbaum } 15850a586ceaSMark Shellenbaum for (i = 0; i != sa->sa_num_attrs; i++) { 15860a586ceaSMark Shellenbaum if (sa->sa_attr_table[i].sa_registered) 15870a586ceaSMark Shellenbaum continue; 15880a586ceaSMark Shellenbaum ATTR_ENCODE(attr_value, tb[i].sa_attr, tb[i].sa_length, 15890a586ceaSMark Shellenbaum tb[i].sa_byteswap); 15900a586ceaSMark Shellenbaum VERIFY(0 == zap_update(hdl->sa_os, sa->sa_reg_attr_obj, 15910a586ceaSMark Shellenbaum tb[i].sa_name, 8, 1, &attr_value, tx)); 15920a586ceaSMark Shellenbaum tb[i].sa_registered = B_TRUE; 15930a586ceaSMark Shellenbaum } 15940a586ceaSMark Shellenbaum sa->sa_need_attr_registration = B_FALSE; 15950a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 15960a586ceaSMark Shellenbaum } 15970a586ceaSMark Shellenbaum 15980a586ceaSMark Shellenbaum /* 15990a586ceaSMark Shellenbaum * Replace all attributes with attributes specified in template. 16000a586ceaSMark Shellenbaum * If dnode had a spill buffer then those attributes will be 16010a586ceaSMark Shellenbaum * also be replaced, possibly with just an empty spill block 16020a586ceaSMark Shellenbaum * 16030a586ceaSMark Shellenbaum * This interface is intended to only be used for bulk adding of 16040a586ceaSMark Shellenbaum * attributes for a new file. It will also be used by the ZPL 16050a586ceaSMark Shellenbaum * when converting and old formatted znode to native SA support. 16060a586ceaSMark Shellenbaum */ 16070a586ceaSMark Shellenbaum int 16080a586ceaSMark Shellenbaum sa_replace_all_by_template_locked(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, 16090a586ceaSMark Shellenbaum int attr_count, dmu_tx_t *tx) 16100a586ceaSMark Shellenbaum { 16110a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 16120a586ceaSMark Shellenbaum 16130a586ceaSMark Shellenbaum if (sa->sa_need_attr_registration) 16140a586ceaSMark Shellenbaum sa_attr_register_sync(hdl, tx); 16150a586ceaSMark Shellenbaum return (sa_build_layouts(hdl, attr_desc, attr_count, tx)); 16160a586ceaSMark Shellenbaum } 16170a586ceaSMark Shellenbaum 16180a586ceaSMark Shellenbaum int 16190a586ceaSMark Shellenbaum sa_replace_all_by_template(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, 16200a586ceaSMark Shellenbaum int attr_count, dmu_tx_t *tx) 16210a586ceaSMark Shellenbaum { 16220a586ceaSMark Shellenbaum int error; 16230a586ceaSMark Shellenbaum 16240a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 16250a586ceaSMark Shellenbaum error = sa_replace_all_by_template_locked(hdl, attr_desc, 16260a586ceaSMark Shellenbaum attr_count, tx); 16270a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 16280a586ceaSMark Shellenbaum return (error); 16290a586ceaSMark Shellenbaum } 16300a586ceaSMark Shellenbaum 16310a586ceaSMark Shellenbaum /* 16320a586ceaSMark Shellenbaum * add/remove/replace a single attribute and then rewrite the entire set 16330a586ceaSMark Shellenbaum * of attributes. 16340a586ceaSMark Shellenbaum */ 16350a586ceaSMark Shellenbaum static int 16360a586ceaSMark Shellenbaum sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr, 16370a586ceaSMark Shellenbaum sa_data_op_t action, sa_data_locator_t *locator, void *datastart, 16380a586ceaSMark Shellenbaum uint16_t buflen, dmu_tx_t *tx) 16390a586ceaSMark Shellenbaum { 16400a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 1641744947dcSTom Erickson dmu_buf_impl_t *db = (dmu_buf_impl_t *)hdl->sa_bonus; 1642744947dcSTom Erickson dnode_t *dn; 16430a586ceaSMark Shellenbaum sa_bulk_attr_t *attr_desc; 16440a586ceaSMark Shellenbaum void *old_data[2]; 16450a586ceaSMark Shellenbaum int bonus_attr_count = 0; 1646d5285caeSGeorge Wilson int bonus_data_size = 0; 1647d5285caeSGeorge Wilson int spill_data_size = 0; 16480a586ceaSMark Shellenbaum int spill_attr_count = 0; 16490a586ceaSMark Shellenbaum int error; 16500a586ceaSMark Shellenbaum uint16_t length; 16510a586ceaSMark Shellenbaum int i, j, k, length_idx; 16520a586ceaSMark Shellenbaum sa_hdr_phys_t *hdr; 16530a586ceaSMark Shellenbaum sa_idx_tab_t *idx_tab; 16540a586ceaSMark Shellenbaum int attr_count; 16550a586ceaSMark Shellenbaum int count; 16560a586ceaSMark Shellenbaum 16570a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&hdl->sa_lock)); 16580a586ceaSMark Shellenbaum 16590a586ceaSMark Shellenbaum /* First make of copy of the old data */ 16600a586ceaSMark Shellenbaum 1661744947dcSTom Erickson DB_DNODE_ENTER(db); 1662744947dcSTom Erickson dn = DB_DNODE(db); 1663744947dcSTom Erickson if (dn->dn_bonuslen != 0) { 16640a586ceaSMark Shellenbaum bonus_data_size = hdl->sa_bonus->db_size; 16650a586ceaSMark Shellenbaum old_data[0] = kmem_alloc(bonus_data_size, KM_SLEEP); 16660a586ceaSMark Shellenbaum bcopy(hdl->sa_bonus->db_data, old_data[0], 16670a586ceaSMark Shellenbaum hdl->sa_bonus->db_size); 16680a586ceaSMark Shellenbaum bonus_attr_count = hdl->sa_bonus_tab->sa_layout->lot_attr_count; 16690a586ceaSMark Shellenbaum } else { 16700a586ceaSMark Shellenbaum old_data[0] = NULL; 16710a586ceaSMark Shellenbaum } 1672744947dcSTom Erickson DB_DNODE_EXIT(db); 16730a586ceaSMark Shellenbaum 16740a586ceaSMark Shellenbaum /* Bring spill buffer online if it isn't currently */ 16750a586ceaSMark Shellenbaum 16761d8ccc7bSMark Shellenbaum if ((error = sa_get_spill(hdl)) == 0) { 16770a586ceaSMark Shellenbaum spill_data_size = hdl->sa_spill->db_size; 16780a586ceaSMark Shellenbaum old_data[1] = kmem_alloc(spill_data_size, KM_SLEEP); 16790a586ceaSMark Shellenbaum bcopy(hdl->sa_spill->db_data, old_data[1], 16800a586ceaSMark Shellenbaum hdl->sa_spill->db_size); 16810a586ceaSMark Shellenbaum spill_attr_count = 16820a586ceaSMark Shellenbaum hdl->sa_spill_tab->sa_layout->lot_attr_count; 16831d8ccc7bSMark Shellenbaum } else if (error && error != ENOENT) { 16841d8ccc7bSMark Shellenbaum if (old_data[0]) 16851d8ccc7bSMark Shellenbaum kmem_free(old_data[0], bonus_data_size); 16861d8ccc7bSMark Shellenbaum return (error); 16870a586ceaSMark Shellenbaum } else { 16880a586ceaSMark Shellenbaum old_data[1] = NULL; 16890a586ceaSMark Shellenbaum } 16900a586ceaSMark Shellenbaum 16910a586ceaSMark Shellenbaum /* build descriptor of all attributes */ 16920a586ceaSMark Shellenbaum 16930a586ceaSMark Shellenbaum attr_count = bonus_attr_count + spill_attr_count; 16940a586ceaSMark Shellenbaum if (action == SA_ADD) 16950a586ceaSMark Shellenbaum attr_count++; 16960a586ceaSMark Shellenbaum else if (action == SA_REMOVE) 16970a586ceaSMark Shellenbaum attr_count--; 16980a586ceaSMark Shellenbaum 16990a586ceaSMark Shellenbaum attr_desc = kmem_zalloc(sizeof (sa_bulk_attr_t) * attr_count, KM_SLEEP); 17000a586ceaSMark Shellenbaum 17010a586ceaSMark Shellenbaum /* 17020a586ceaSMark Shellenbaum * loop through bonus and spill buffer if it exists, and 17030a586ceaSMark Shellenbaum * build up new attr_descriptor to reset the attributes 17040a586ceaSMark Shellenbaum */ 17050a586ceaSMark Shellenbaum k = j = 0; 17060a586ceaSMark Shellenbaum count = bonus_attr_count; 17070a586ceaSMark Shellenbaum hdr = SA_GET_HDR(hdl, SA_BONUS); 17080a586ceaSMark Shellenbaum idx_tab = SA_IDX_TAB_GET(hdl, SA_BONUS); 17090a586ceaSMark Shellenbaum for (; k != 2; k++) { 17100a586ceaSMark Shellenbaum /* iterate over each attribute in layout */ 17110a586ceaSMark Shellenbaum for (i = 0, length_idx = 0; i != count; i++) { 17120a586ceaSMark Shellenbaum sa_attr_type_t attr; 17130a586ceaSMark Shellenbaum 17140a586ceaSMark Shellenbaum attr = idx_tab->sa_layout->lot_attrs[i]; 17150a586ceaSMark Shellenbaum if (attr == newattr) { 17160a586ceaSMark Shellenbaum if (action == SA_REMOVE) { 17170a586ceaSMark Shellenbaum j++; 17180a586ceaSMark Shellenbaum continue; 17190a586ceaSMark Shellenbaum } 17200a586ceaSMark Shellenbaum ASSERT(SA_REGISTERED_LEN(sa, attr) == 0); 17210a586ceaSMark Shellenbaum ASSERT(action == SA_REPLACE); 17220a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(attr_desc, j, attr, 17230a586ceaSMark Shellenbaum locator, datastart, buflen); 17240a586ceaSMark Shellenbaum } else { 17250a586ceaSMark Shellenbaum length = SA_REGISTERED_LEN(sa, attr); 17260a586ceaSMark Shellenbaum if (length == 0) { 17270a586ceaSMark Shellenbaum length = hdr->sa_lengths[length_idx++]; 17280a586ceaSMark Shellenbaum } 17290a586ceaSMark Shellenbaum 17300a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(attr_desc, j, attr, 17310a586ceaSMark Shellenbaum NULL, (void *) 17320a586ceaSMark Shellenbaum (TOC_OFF(idx_tab->sa_idx_tab[attr]) + 17330a586ceaSMark Shellenbaum (uintptr_t)old_data[k]), length); 17340a586ceaSMark Shellenbaum } 17350a586ceaSMark Shellenbaum } 17360a586ceaSMark Shellenbaum if (k == 0 && hdl->sa_spill) { 17370a586ceaSMark Shellenbaum hdr = SA_GET_HDR(hdl, SA_SPILL); 17380a586ceaSMark Shellenbaum idx_tab = SA_IDX_TAB_GET(hdl, SA_SPILL); 17390a586ceaSMark Shellenbaum count = spill_attr_count; 17400a586ceaSMark Shellenbaum } else { 17410a586ceaSMark Shellenbaum break; 17420a586ceaSMark Shellenbaum } 17430a586ceaSMark Shellenbaum } 17440a586ceaSMark Shellenbaum if (action == SA_ADD) { 17450a586ceaSMark Shellenbaum length = SA_REGISTERED_LEN(sa, newattr); 17460a586ceaSMark Shellenbaum if (length == 0) { 17470a586ceaSMark Shellenbaum length = buflen; 17480a586ceaSMark Shellenbaum } 17490a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(attr_desc, j, newattr, locator, 17500a586ceaSMark Shellenbaum datastart, buflen); 17510a586ceaSMark Shellenbaum } 17520a586ceaSMark Shellenbaum 17530a586ceaSMark Shellenbaum error = sa_build_layouts(hdl, attr_desc, attr_count, tx); 17540a586ceaSMark Shellenbaum 17550a586ceaSMark Shellenbaum if (old_data[0]) 17560a586ceaSMark Shellenbaum kmem_free(old_data[0], bonus_data_size); 17570a586ceaSMark Shellenbaum if (old_data[1]) 17580a586ceaSMark Shellenbaum kmem_free(old_data[1], spill_data_size); 17590a586ceaSMark Shellenbaum kmem_free(attr_desc, sizeof (sa_bulk_attr_t) * attr_count); 17600a586ceaSMark Shellenbaum 17610a586ceaSMark Shellenbaum return (error); 17620a586ceaSMark Shellenbaum } 17630a586ceaSMark Shellenbaum 17640a586ceaSMark Shellenbaum static int 17650a586ceaSMark Shellenbaum sa_bulk_update_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count, 17660a586ceaSMark Shellenbaum dmu_tx_t *tx) 17670a586ceaSMark Shellenbaum { 17680a586ceaSMark Shellenbaum int error; 17690a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 17700a586ceaSMark Shellenbaum dmu_object_type_t bonustype; 17710a586ceaSMark Shellenbaum 17720a586ceaSMark Shellenbaum bonustype = SA_BONUSTYPE_FROM_DB(SA_GET_DB(hdl, SA_BONUS)); 17730a586ceaSMark Shellenbaum 17740a586ceaSMark Shellenbaum ASSERT(hdl); 17750a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&hdl->sa_lock)); 17760a586ceaSMark Shellenbaum 17770a586ceaSMark Shellenbaum /* sync out registration table if necessary */ 17780a586ceaSMark Shellenbaum if (sa->sa_need_attr_registration) 17790a586ceaSMark Shellenbaum sa_attr_register_sync(hdl, tx); 17800a586ceaSMark Shellenbaum 17810a586ceaSMark Shellenbaum error = sa_attr_op(hdl, bulk, count, SA_UPDATE, tx); 17820a586ceaSMark Shellenbaum if (error == 0 && !IS_SA_BONUSTYPE(bonustype) && sa->sa_update_cb) 17830a586ceaSMark Shellenbaum sa->sa_update_cb(hdl, tx); 17840a586ceaSMark Shellenbaum 17850a586ceaSMark Shellenbaum return (error); 17860a586ceaSMark Shellenbaum } 17870a586ceaSMark Shellenbaum 17880a586ceaSMark Shellenbaum /* 17890a586ceaSMark Shellenbaum * update or add new attribute 17900a586ceaSMark Shellenbaum */ 17910a586ceaSMark Shellenbaum int 17920a586ceaSMark Shellenbaum sa_update(sa_handle_t *hdl, sa_attr_type_t type, 17930a586ceaSMark Shellenbaum void *buf, uint32_t buflen, dmu_tx_t *tx) 17940a586ceaSMark Shellenbaum { 17950a586ceaSMark Shellenbaum int error; 17960a586ceaSMark Shellenbaum sa_bulk_attr_t bulk; 17970a586ceaSMark Shellenbaum 17980a586ceaSMark Shellenbaum bulk.sa_attr = type; 17990a586ceaSMark Shellenbaum bulk.sa_data_func = NULL; 18000a586ceaSMark Shellenbaum bulk.sa_length = buflen; 18010a586ceaSMark Shellenbaum bulk.sa_data = buf; 18020a586ceaSMark Shellenbaum 18030a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 18040a586ceaSMark Shellenbaum error = sa_bulk_update_impl(hdl, &bulk, 1, tx); 18050a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 18060a586ceaSMark Shellenbaum return (error); 18070a586ceaSMark Shellenbaum } 18080a586ceaSMark Shellenbaum 18090a586ceaSMark Shellenbaum int 18100a586ceaSMark Shellenbaum sa_update_from_cb(sa_handle_t *hdl, sa_attr_type_t attr, 18110a586ceaSMark Shellenbaum uint32_t buflen, sa_data_locator_t *locator, void *userdata, dmu_tx_t *tx) 18120a586ceaSMark Shellenbaum { 18130a586ceaSMark Shellenbaum int error; 18140a586ceaSMark Shellenbaum sa_bulk_attr_t bulk; 18150a586ceaSMark Shellenbaum 18160a586ceaSMark Shellenbaum bulk.sa_attr = attr; 18170a586ceaSMark Shellenbaum bulk.sa_data = userdata; 18180a586ceaSMark Shellenbaum bulk.sa_data_func = locator; 18190a586ceaSMark Shellenbaum bulk.sa_length = buflen; 18200a586ceaSMark Shellenbaum 18210a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 18220a586ceaSMark Shellenbaum error = sa_bulk_update_impl(hdl, &bulk, 1, tx); 18230a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 18240a586ceaSMark Shellenbaum return (error); 18250a586ceaSMark Shellenbaum } 18260a586ceaSMark Shellenbaum 18270a586ceaSMark Shellenbaum /* 18280a586ceaSMark Shellenbaum * Return size of an attribute 18290a586ceaSMark Shellenbaum */ 18300a586ceaSMark Shellenbaum 18310a586ceaSMark Shellenbaum int 18320a586ceaSMark Shellenbaum sa_size(sa_handle_t *hdl, sa_attr_type_t attr, int *size) 18330a586ceaSMark Shellenbaum { 18340a586ceaSMark Shellenbaum sa_bulk_attr_t bulk; 18351d8ccc7bSMark Shellenbaum int error; 18360a586ceaSMark Shellenbaum 18370a586ceaSMark Shellenbaum bulk.sa_data = NULL; 18380a586ceaSMark Shellenbaum bulk.sa_attr = attr; 18390a586ceaSMark Shellenbaum bulk.sa_data_func = NULL; 18400a586ceaSMark Shellenbaum 18410a586ceaSMark Shellenbaum ASSERT(hdl); 18420a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 18431d8ccc7bSMark Shellenbaum if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) != 0) { 18440a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 18451d8ccc7bSMark Shellenbaum return (error); 18460a586ceaSMark Shellenbaum } 18470a586ceaSMark Shellenbaum *size = bulk.sa_size; 18480a586ceaSMark Shellenbaum 18490a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 18500a586ceaSMark Shellenbaum return (0); 18510a586ceaSMark Shellenbaum } 18520a586ceaSMark Shellenbaum 18530a586ceaSMark Shellenbaum int 18540a586ceaSMark Shellenbaum sa_bulk_lookup_locked(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count) 18550a586ceaSMark Shellenbaum { 18560a586ceaSMark Shellenbaum ASSERT(hdl); 18570a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&hdl->sa_lock)); 18580a586ceaSMark Shellenbaum return (sa_lookup_impl(hdl, attrs, count)); 18590a586ceaSMark Shellenbaum } 18600a586ceaSMark Shellenbaum 18610a586ceaSMark Shellenbaum int 18620a586ceaSMark Shellenbaum sa_bulk_lookup(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count) 18630a586ceaSMark Shellenbaum { 18640a586ceaSMark Shellenbaum int error; 18650a586ceaSMark Shellenbaum 18660a586ceaSMark Shellenbaum ASSERT(hdl); 18670a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 18680a586ceaSMark Shellenbaum error = sa_bulk_lookup_locked(hdl, attrs, count); 18690a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 18700a586ceaSMark Shellenbaum return (error); 18710a586ceaSMark Shellenbaum } 18720a586ceaSMark Shellenbaum 18730a586ceaSMark Shellenbaum int 18740a586ceaSMark Shellenbaum sa_bulk_update(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count, dmu_tx_t *tx) 18750a586ceaSMark Shellenbaum { 18760a586ceaSMark Shellenbaum int error; 18770a586ceaSMark Shellenbaum 18780a586ceaSMark Shellenbaum ASSERT(hdl); 18790a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 18800a586ceaSMark Shellenbaum error = sa_bulk_update_impl(hdl, attrs, count, tx); 18810a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 18820a586ceaSMark Shellenbaum return (error); 18830a586ceaSMark Shellenbaum } 18840a586ceaSMark Shellenbaum 18850a586ceaSMark Shellenbaum int 18860a586ceaSMark Shellenbaum sa_remove(sa_handle_t *hdl, sa_attr_type_t attr, dmu_tx_t *tx) 18870a586ceaSMark Shellenbaum { 18880a586ceaSMark Shellenbaum int error; 18890a586ceaSMark Shellenbaum 18900a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 18910a586ceaSMark Shellenbaum error = sa_modify_attrs(hdl, attr, SA_REMOVE, NULL, 18920a586ceaSMark Shellenbaum NULL, 0, tx); 18930a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 18940a586ceaSMark Shellenbaum return (error); 18950a586ceaSMark Shellenbaum } 18960a586ceaSMark Shellenbaum 18970a586ceaSMark Shellenbaum void 18980a586ceaSMark Shellenbaum sa_object_info(sa_handle_t *hdl, dmu_object_info_t *doi) 18990a586ceaSMark Shellenbaum { 19000a586ceaSMark Shellenbaum dmu_object_info_from_db((dmu_buf_t *)hdl->sa_bonus, doi); 19010a586ceaSMark Shellenbaum } 19020a586ceaSMark Shellenbaum 19030a586ceaSMark Shellenbaum void 19040a586ceaSMark Shellenbaum sa_object_size(sa_handle_t *hdl, uint32_t *blksize, u_longlong_t *nblocks) 19050a586ceaSMark Shellenbaum { 19060a586ceaSMark Shellenbaum dmu_object_size_from_db((dmu_buf_t *)hdl->sa_bonus, 19070a586ceaSMark Shellenbaum blksize, nblocks); 19080a586ceaSMark Shellenbaum } 19090a586ceaSMark Shellenbaum 19100a586ceaSMark Shellenbaum void 19110a586ceaSMark Shellenbaum sa_update_user(sa_handle_t *newhdl, sa_handle_t *oldhdl) 19120a586ceaSMark Shellenbaum { 19130a586ceaSMark Shellenbaum (void) dmu_buf_update_user((dmu_buf_t *)newhdl->sa_bonus, 19140a586ceaSMark Shellenbaum oldhdl, newhdl, NULL, sa_evict); 19150a586ceaSMark Shellenbaum oldhdl->sa_bonus = NULL; 19160a586ceaSMark Shellenbaum } 19170a586ceaSMark Shellenbaum 19180a586ceaSMark Shellenbaum void 19190a586ceaSMark Shellenbaum sa_set_userp(sa_handle_t *hdl, void *ptr) 19200a586ceaSMark Shellenbaum { 19210a586ceaSMark Shellenbaum hdl->sa_userp = ptr; 19220a586ceaSMark Shellenbaum } 19230a586ceaSMark Shellenbaum 19240a586ceaSMark Shellenbaum dmu_buf_t * 19250a586ceaSMark Shellenbaum sa_get_db(sa_handle_t *hdl) 19260a586ceaSMark Shellenbaum { 19270a586ceaSMark Shellenbaum return ((dmu_buf_t *)hdl->sa_bonus); 19280a586ceaSMark Shellenbaum } 19290a586ceaSMark Shellenbaum 19300a586ceaSMark Shellenbaum void * 19310a586ceaSMark Shellenbaum sa_get_userdata(sa_handle_t *hdl) 19320a586ceaSMark Shellenbaum { 19330a586ceaSMark Shellenbaum return (hdl->sa_userp); 19340a586ceaSMark Shellenbaum } 19350a586ceaSMark Shellenbaum 19360a586ceaSMark Shellenbaum void 19370a586ceaSMark Shellenbaum sa_register_update_callback_locked(objset_t *os, sa_update_cb_t *func) 19380a586ceaSMark Shellenbaum { 19390a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&os->os_sa->sa_lock)); 19400a586ceaSMark Shellenbaum os->os_sa->sa_update_cb = func; 19410a586ceaSMark Shellenbaum } 19420a586ceaSMark Shellenbaum 19430a586ceaSMark Shellenbaum void 19440a586ceaSMark Shellenbaum sa_register_update_callback(objset_t *os, sa_update_cb_t *func) 19450a586ceaSMark Shellenbaum { 19460a586ceaSMark Shellenbaum 19470a586ceaSMark Shellenbaum mutex_enter(&os->os_sa->sa_lock); 19480a586ceaSMark Shellenbaum sa_register_update_callback_locked(os, func); 19490a586ceaSMark Shellenbaum mutex_exit(&os->os_sa->sa_lock); 19500a586ceaSMark Shellenbaum } 19510a586ceaSMark Shellenbaum 19520a586ceaSMark Shellenbaum uint64_t 19530a586ceaSMark Shellenbaum sa_handle_object(sa_handle_t *hdl) 19540a586ceaSMark Shellenbaum { 19550a586ceaSMark Shellenbaum return (hdl->sa_bonus->db_object); 19560a586ceaSMark Shellenbaum } 19570a586ceaSMark Shellenbaum 19580a586ceaSMark Shellenbaum boolean_t 19590a586ceaSMark Shellenbaum sa_enabled(objset_t *os) 19600a586ceaSMark Shellenbaum { 19610a586ceaSMark Shellenbaum return (os->os_sa == NULL); 19620a586ceaSMark Shellenbaum } 19630a586ceaSMark Shellenbaum 19640a586ceaSMark Shellenbaum int 19650a586ceaSMark Shellenbaum sa_set_sa_object(objset_t *os, uint64_t sa_object) 19660a586ceaSMark Shellenbaum { 19670a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 19680a586ceaSMark Shellenbaum 19690a586ceaSMark Shellenbaum if (sa->sa_master_obj) 19700a586ceaSMark Shellenbaum return (1); 19710a586ceaSMark Shellenbaum 19720a586ceaSMark Shellenbaum sa->sa_master_obj = sa_object; 19730a586ceaSMark Shellenbaum 19740a586ceaSMark Shellenbaum return (0); 19750a586ceaSMark Shellenbaum } 19760a586ceaSMark Shellenbaum 19770a586ceaSMark Shellenbaum int 19780a586ceaSMark Shellenbaum sa_hdrsize(void *arg) 19790a586ceaSMark Shellenbaum { 19800a586ceaSMark Shellenbaum sa_hdr_phys_t *hdr = arg; 19810a586ceaSMark Shellenbaum 19820a586ceaSMark Shellenbaum return (SA_HDR_SIZE(hdr)); 19830a586ceaSMark Shellenbaum } 19840a586ceaSMark Shellenbaum 19850a586ceaSMark Shellenbaum void 19860a586ceaSMark Shellenbaum sa_handle_lock(sa_handle_t *hdl) 19870a586ceaSMark Shellenbaum { 19880a586ceaSMark Shellenbaum ASSERT(hdl); 19890a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 19900a586ceaSMark Shellenbaum } 19910a586ceaSMark Shellenbaum 19920a586ceaSMark Shellenbaum void 19930a586ceaSMark Shellenbaum sa_handle_unlock(sa_handle_t *hdl) 19940a586ceaSMark Shellenbaum { 19950a586ceaSMark Shellenbaum ASSERT(hdl); 19960a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 19970a586ceaSMark Shellenbaum } 1998