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