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