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] 28*f67950b2SNasf-Fan * Copyright 2019 Joyent, Inc. 290a586ceaSMark Shellenbaum */ 300a586ceaSMark Shellenbaum 310a586ceaSMark Shellenbaum #include <sys/zfs_context.h> 320a586ceaSMark Shellenbaum #include <sys/types.h> 330a586ceaSMark Shellenbaum #include <sys/param.h> 340a586ceaSMark Shellenbaum #include <sys/systm.h> 350a586ceaSMark Shellenbaum #include <sys/sysmacros.h> 360a586ceaSMark Shellenbaum #include <sys/dmu.h> 370a586ceaSMark Shellenbaum #include <sys/dmu_impl.h> 380a586ceaSMark Shellenbaum #include <sys/dmu_objset.h> 3954811da5SToomas Soome #include <sys/dmu_tx.h> 400a586ceaSMark Shellenbaum #include <sys/dbuf.h> 410a586ceaSMark Shellenbaum #include <sys/dnode.h> 420a586ceaSMark Shellenbaum #include <sys/zap.h> 430a586ceaSMark Shellenbaum #include <sys/sa.h> 440a586ceaSMark Shellenbaum #include <sys/sunddi.h> 450a586ceaSMark Shellenbaum #include <sys/sa_impl.h> 460a586ceaSMark Shellenbaum #include <sys/dnode.h> 470a586ceaSMark Shellenbaum #include <sys/errno.h> 480a586ceaSMark Shellenbaum #include <sys/zfs_context.h> 490a586ceaSMark Shellenbaum 50*f67950b2SNasf-Fan #ifdef _KERNEL 51*f67950b2SNasf-Fan #include <sys/zfs_znode.h> 52*f67950b2SNasf-Fan #endif 53*f67950b2SNasf-Fan 540a586ceaSMark Shellenbaum /* 550a586ceaSMark Shellenbaum * ZFS System attributes: 560a586ceaSMark Shellenbaum * 570a586ceaSMark Shellenbaum * A generic mechanism to allow for arbitrary attributes 580a586ceaSMark Shellenbaum * to be stored in a dnode. The data will be stored in the bonus buffer of 590a586ceaSMark Shellenbaum * the dnode and if necessary a special "spill" block will be used to handle 600a586ceaSMark Shellenbaum * overflow situations. The spill block will be sized to fit the data 610a586ceaSMark Shellenbaum * from 512 - 128K. When a spill block is used the BP (blkptr_t) for the 620a586ceaSMark Shellenbaum * spill block is stored at the end of the current bonus buffer. Any 630a586ceaSMark Shellenbaum * attributes that would be in the way of the blkptr_t will be relocated 640a586ceaSMark Shellenbaum * into the spill block. 650a586ceaSMark Shellenbaum * 660a586ceaSMark Shellenbaum * Attribute registration: 670a586ceaSMark Shellenbaum * 680a586ceaSMark Shellenbaum * Stored persistently on a per dataset basis 690a586ceaSMark Shellenbaum * a mapping between attribute "string" names and their actual attribute 700a586ceaSMark Shellenbaum * numeric values, length, and byteswap function. The names are only used 710a586ceaSMark Shellenbaum * during registration. All attributes are known by their unique attribute 720a586ceaSMark Shellenbaum * id value. If an attribute can have a variable size then the value 730a586ceaSMark Shellenbaum * 0 will be used to indicate this. 740a586ceaSMark Shellenbaum * 750a586ceaSMark Shellenbaum * Attribute Layout: 760a586ceaSMark Shellenbaum * 770a586ceaSMark Shellenbaum * Attribute layouts are a way to compactly store multiple attributes, but 780a586ceaSMark Shellenbaum * without taking the overhead associated with managing each attribute 790a586ceaSMark Shellenbaum * individually. Since you will typically have the same set of attributes 800a586ceaSMark Shellenbaum * stored in the same order a single table will be used to represent that 810a586ceaSMark Shellenbaum * layout. The ZPL for example will usually have only about 10 different 820a586ceaSMark Shellenbaum * layouts (regular files, device files, symlinks, 830a586ceaSMark Shellenbaum * regular files + scanstamp, files/dir with extended attributes, and then 840a586ceaSMark Shellenbaum * you have the possibility of all of those minus ACL, because it would 850a586ceaSMark Shellenbaum * be kicked out into the spill block) 860a586ceaSMark Shellenbaum * 870a586ceaSMark Shellenbaum * Layouts are simply an array of the attributes and their 880a586ceaSMark Shellenbaum * ordering i.e. [0, 1, 4, 5, 2] 890a586ceaSMark Shellenbaum * 900a586ceaSMark Shellenbaum * Each distinct layout is given a unique layout number and that is whats 910a586ceaSMark Shellenbaum * stored in the header at the beginning of the SA data buffer. 920a586ceaSMark Shellenbaum * 930a586ceaSMark Shellenbaum * A layout only covers a single dbuf (bonus or spill). If a set of 940a586ceaSMark Shellenbaum * attributes is split up between the bonus buffer and a spill buffer then 950a586ceaSMark Shellenbaum * two different layouts will be used. This allows us to byteswap the 960a586ceaSMark Shellenbaum * spill without looking at the bonus buffer and keeps the on disk format of 970a586ceaSMark Shellenbaum * the bonus and spill buffer the same. 980a586ceaSMark Shellenbaum * 990a586ceaSMark Shellenbaum * Adding a single attribute will cause the entire set of attributes to 1000a586ceaSMark Shellenbaum * be rewritten and could result in a new layout number being constructed 1010a586ceaSMark Shellenbaum * as part of the rewrite if no such layout exists for the new set of 1020a586ceaSMark Shellenbaum * attribues. The new attribute will be appended to the end of the already 1030a586ceaSMark Shellenbaum * existing attributes. 1040a586ceaSMark Shellenbaum * 1050a586ceaSMark Shellenbaum * Both the attribute registration and attribute layout information are 1060a586ceaSMark Shellenbaum * stored in normal ZAP attributes. Their should be a small number of 1070a586ceaSMark Shellenbaum * known layouts and the set of attributes is assumed to typically be quite 1080a586ceaSMark Shellenbaum * small. 1090a586ceaSMark Shellenbaum * 1100a586ceaSMark Shellenbaum * The registered attributes and layout "table" information is maintained 1110a586ceaSMark Shellenbaum * in core and a special "sa_os_t" is attached to the objset_t. 1120a586ceaSMark Shellenbaum * 1130a586ceaSMark Shellenbaum * A special interface is provided to allow for quickly applying 1140a586ceaSMark Shellenbaum * a large set of attributes at once. sa_replace_all_by_template() is 1150a586ceaSMark Shellenbaum * used to set an array of attributes. This is used by the ZPL when 1160a586ceaSMark Shellenbaum * creating a brand new file. The template that is passed into the function 1170a586ceaSMark Shellenbaum * specifies the attribute, size for variable length attributes, location of 1180a586ceaSMark Shellenbaum * data and special "data locator" function if the data isn't in a contiguous 1190a586ceaSMark Shellenbaum * location. 1200a586ceaSMark Shellenbaum * 1210a586ceaSMark Shellenbaum * Byteswap implications: 122f7170741SWill Andrews * 1230a586ceaSMark Shellenbaum * Since the SA attributes are not entirely self describing we can't do 1240a586ceaSMark Shellenbaum * the normal byteswap processing. The special ZAP layout attribute and 1250a586ceaSMark Shellenbaum * attribute registration attributes define the byteswap function and the 1260a586ceaSMark Shellenbaum * size of the attributes, unless it is variable sized. 1270a586ceaSMark Shellenbaum * The normal ZFS byteswapping infrastructure assumes you don't need 1280a586ceaSMark Shellenbaum * to read any objects in order to do the necessary byteswapping. Whereas 1290a586ceaSMark Shellenbaum * SA attributes can only be properly byteswapped if the dataset is opened 1300a586ceaSMark Shellenbaum * and the layout/attribute ZAP attributes are available. Because of this 1310a586ceaSMark Shellenbaum * the SA attributes will be byteswapped when they are first accessed by 1320a586ceaSMark Shellenbaum * the SA code that will read the SA data. 1330a586ceaSMark Shellenbaum */ 1340a586ceaSMark Shellenbaum 1350a586ceaSMark Shellenbaum typedef void (sa_iterfunc_t)(void *hdr, void *addr, sa_attr_type_t, 1360a586ceaSMark Shellenbaum uint16_t length, int length_idx, boolean_t, void *userp); 1370a586ceaSMark Shellenbaum 1380a586ceaSMark Shellenbaum static int sa_build_index(sa_handle_t *hdl, sa_buf_type_t buftype); 1390a586ceaSMark Shellenbaum static void sa_idx_tab_hold(objset_t *os, sa_idx_tab_t *idx_tab); 1407f0bdb42SMatthew Ahrens static sa_idx_tab_t *sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype, 1417f0bdb42SMatthew Ahrens sa_hdr_phys_t *hdr); 1420a586ceaSMark Shellenbaum static void sa_idx_tab_rele(objset_t *os, void *arg); 1430a586ceaSMark Shellenbaum static void sa_copy_data(sa_data_locator_t *func, void *start, void *target, 1440a586ceaSMark Shellenbaum int buflen); 1450a586ceaSMark Shellenbaum static int sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr, 1460a586ceaSMark Shellenbaum sa_data_op_t action, sa_data_locator_t *locator, void *datastart, 1470a586ceaSMark Shellenbaum uint16_t buflen, dmu_tx_t *tx); 1480a586ceaSMark Shellenbaum 1490a586ceaSMark Shellenbaum arc_byteswap_func_t *sa_bswap_table[] = { 1500a586ceaSMark Shellenbaum byteswap_uint64_array, 1510a586ceaSMark Shellenbaum byteswap_uint32_array, 1520a586ceaSMark Shellenbaum byteswap_uint16_array, 1530a586ceaSMark Shellenbaum byteswap_uint8_array, 1540a586ceaSMark Shellenbaum zfs_acl_byteswap, 1550a586ceaSMark Shellenbaum }; 1560a586ceaSMark Shellenbaum 1570a586ceaSMark Shellenbaum #define SA_COPY_DATA(f, s, t, l) \ 1580a586ceaSMark Shellenbaum { \ 1590a586ceaSMark Shellenbaum if (f == NULL) { \ 1600a586ceaSMark Shellenbaum if (l == 8) { \ 1610a586ceaSMark Shellenbaum *(uint64_t *)t = *(uint64_t *)s; \ 1620a586ceaSMark Shellenbaum } else if (l == 16) { \ 1630a586ceaSMark Shellenbaum *(uint64_t *)t = *(uint64_t *)s; \ 1640a586ceaSMark Shellenbaum *(uint64_t *)((uintptr_t)t + 8) = \ 1650a586ceaSMark Shellenbaum *(uint64_t *)((uintptr_t)s + 8); \ 1660a586ceaSMark Shellenbaum } else { \ 1670a586ceaSMark Shellenbaum bcopy(s, t, l); \ 1680a586ceaSMark Shellenbaum } \ 1690a586ceaSMark Shellenbaum } else \ 1700a586ceaSMark Shellenbaum sa_copy_data(f, s, t, l); \ 1710a586ceaSMark Shellenbaum } 1720a586ceaSMark Shellenbaum 1730a586ceaSMark Shellenbaum /* 1740a586ceaSMark Shellenbaum * This table is fixed and cannot be changed. Its purpose is to 1750a586ceaSMark Shellenbaum * allow the SA code to work with both old/new ZPL file systems. 1760a586ceaSMark Shellenbaum * It contains the list of legacy attributes. These attributes aren't 1770a586ceaSMark Shellenbaum * stored in the "attribute" registry zap objects, since older ZPL file systems 1780a586ceaSMark Shellenbaum * won't have the registry. Only objsets of type ZFS_TYPE_FILESYSTEM will 1790a586ceaSMark Shellenbaum * use this static table. 1800a586ceaSMark Shellenbaum */ 1810a586ceaSMark Shellenbaum sa_attr_reg_t sa_legacy_attrs[] = { 1820a586ceaSMark Shellenbaum {"ZPL_ATIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 0}, 1830a586ceaSMark Shellenbaum {"ZPL_MTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 1}, 1840a586ceaSMark Shellenbaum {"ZPL_CTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 2}, 1850a586ceaSMark Shellenbaum {"ZPL_CRTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 3}, 1860a586ceaSMark Shellenbaum {"ZPL_GEN", sizeof (uint64_t), SA_UINT64_ARRAY, 4}, 1870a586ceaSMark Shellenbaum {"ZPL_MODE", sizeof (uint64_t), SA_UINT64_ARRAY, 5}, 1880a586ceaSMark Shellenbaum {"ZPL_SIZE", sizeof (uint64_t), SA_UINT64_ARRAY, 6}, 1890a586ceaSMark Shellenbaum {"ZPL_PARENT", sizeof (uint64_t), SA_UINT64_ARRAY, 7}, 1900a586ceaSMark Shellenbaum {"ZPL_LINKS", sizeof (uint64_t), SA_UINT64_ARRAY, 8}, 1910a586ceaSMark Shellenbaum {"ZPL_XATTR", sizeof (uint64_t), SA_UINT64_ARRAY, 9}, 1920a586ceaSMark Shellenbaum {"ZPL_RDEV", sizeof (uint64_t), SA_UINT64_ARRAY, 10}, 1930a586ceaSMark Shellenbaum {"ZPL_FLAGS", sizeof (uint64_t), SA_UINT64_ARRAY, 11}, 1940a586ceaSMark Shellenbaum {"ZPL_UID", sizeof (uint64_t), SA_UINT64_ARRAY, 12}, 1950a586ceaSMark Shellenbaum {"ZPL_GID", sizeof (uint64_t), SA_UINT64_ARRAY, 13}, 1960a586ceaSMark Shellenbaum {"ZPL_PAD", sizeof (uint64_t) * 4, SA_UINT64_ARRAY, 14}, 1970a586ceaSMark Shellenbaum {"ZPL_ZNODE_ACL", 88, SA_UINT8_ARRAY, 15}, 1980a586ceaSMark Shellenbaum }; 1990a586ceaSMark Shellenbaum 2000a586ceaSMark Shellenbaum /* 2010a586ceaSMark Shellenbaum * This is only used for objects of type DMU_OT_ZNODE 2020a586ceaSMark Shellenbaum */ 2030a586ceaSMark Shellenbaum sa_attr_type_t sa_legacy_zpl_layout[] = { 2040a586ceaSMark Shellenbaum 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 2050a586ceaSMark Shellenbaum }; 2060a586ceaSMark Shellenbaum 2070a586ceaSMark Shellenbaum /* 2080a586ceaSMark Shellenbaum * Special dummy layout used for buffers with no attributes. 2090a586ceaSMark Shellenbaum */ 2100a586ceaSMark Shellenbaum sa_attr_type_t sa_dummy_zpl_layout[] = { 0 }; 2110a586ceaSMark Shellenbaum 2120a586ceaSMark Shellenbaum static int sa_legacy_attr_count = 16; 2130a586ceaSMark Shellenbaum static kmem_cache_t *sa_cache = NULL; 2140a586ceaSMark Shellenbaum 2150a586ceaSMark Shellenbaum /*ARGSUSED*/ 2160a586ceaSMark Shellenbaum static int 2170a586ceaSMark Shellenbaum sa_cache_constructor(void *buf, void *unused, int kmflag) 2180a586ceaSMark Shellenbaum { 2190a586ceaSMark Shellenbaum sa_handle_t *hdl = buf; 2200a586ceaSMark Shellenbaum 2210a586ceaSMark Shellenbaum mutex_init(&hdl->sa_lock, NULL, MUTEX_DEFAULT, NULL); 2220a586ceaSMark Shellenbaum return (0); 2230a586ceaSMark Shellenbaum } 2240a586ceaSMark Shellenbaum 2250a586ceaSMark Shellenbaum /*ARGSUSED*/ 2260a586ceaSMark Shellenbaum static void 2270a586ceaSMark Shellenbaum sa_cache_destructor(void *buf, void *unused) 2280a586ceaSMark Shellenbaum { 2290a586ceaSMark Shellenbaum sa_handle_t *hdl = buf; 2300a586ceaSMark Shellenbaum mutex_destroy(&hdl->sa_lock); 2310a586ceaSMark Shellenbaum } 2320a586ceaSMark Shellenbaum 2330a586ceaSMark Shellenbaum void 2340a586ceaSMark Shellenbaum sa_cache_init(void) 2350a586ceaSMark Shellenbaum { 2360a586ceaSMark Shellenbaum sa_cache = kmem_cache_create("sa_cache", 2370a586ceaSMark Shellenbaum sizeof (sa_handle_t), 0, sa_cache_constructor, 2380a586ceaSMark Shellenbaum sa_cache_destructor, NULL, NULL, NULL, 0); 2390a586ceaSMark Shellenbaum } 2400a586ceaSMark Shellenbaum 2410a586ceaSMark Shellenbaum void 2420a586ceaSMark Shellenbaum sa_cache_fini(void) 2430a586ceaSMark Shellenbaum { 2440a586ceaSMark Shellenbaum if (sa_cache) 2450a586ceaSMark Shellenbaum kmem_cache_destroy(sa_cache); 2460a586ceaSMark Shellenbaum } 2470a586ceaSMark Shellenbaum 2480a586ceaSMark Shellenbaum static int 2490a586ceaSMark Shellenbaum layout_num_compare(const void *arg1, const void *arg2) 2500a586ceaSMark Shellenbaum { 251c4ab0d3fSGvozden Neskovic const sa_lot_t *node1 = (const sa_lot_t *)arg1; 252c4ab0d3fSGvozden Neskovic const sa_lot_t *node2 = (const sa_lot_t *)arg2; 2530a586ceaSMark Shellenbaum 254c4ab0d3fSGvozden Neskovic return (AVL_CMP(node1->lot_num, node2->lot_num)); 2550a586ceaSMark Shellenbaum } 2560a586ceaSMark Shellenbaum 2570a586ceaSMark Shellenbaum static int 2580a586ceaSMark Shellenbaum layout_hash_compare(const void *arg1, const void *arg2) 2590a586ceaSMark Shellenbaum { 260c4ab0d3fSGvozden Neskovic const sa_lot_t *node1 = (const sa_lot_t *)arg1; 261c4ab0d3fSGvozden Neskovic const sa_lot_t *node2 = (const sa_lot_t *)arg2; 2620a586ceaSMark Shellenbaum 263c4ab0d3fSGvozden Neskovic int cmp = AVL_CMP(node1->lot_hash, node2->lot_hash); 264c4ab0d3fSGvozden Neskovic if (likely(cmp)) 265c4ab0d3fSGvozden Neskovic return (cmp); 266c4ab0d3fSGvozden Neskovic 267c4ab0d3fSGvozden Neskovic return (AVL_CMP(node1->lot_instance, node2->lot_instance)); 2680a586ceaSMark Shellenbaum } 2690a586ceaSMark Shellenbaum 2700a586ceaSMark Shellenbaum boolean_t 2710a586ceaSMark Shellenbaum sa_layout_equal(sa_lot_t *tbf, sa_attr_type_t *attrs, int count) 2720a586ceaSMark Shellenbaum { 2730a586ceaSMark Shellenbaum int i; 2740a586ceaSMark Shellenbaum 2750a586ceaSMark Shellenbaum if (count != tbf->lot_attr_count) 2760a586ceaSMark Shellenbaum return (1); 2770a586ceaSMark Shellenbaum 2780a586ceaSMark Shellenbaum for (i = 0; i != count; i++) { 2790a586ceaSMark Shellenbaum if (attrs[i] != tbf->lot_attrs[i]) 2800a586ceaSMark Shellenbaum return (1); 2810a586ceaSMark Shellenbaum } 2820a586ceaSMark Shellenbaum return (0); 2830a586ceaSMark Shellenbaum } 2840a586ceaSMark Shellenbaum 2850a586ceaSMark Shellenbaum #define SA_ATTR_HASH(attr) (zfs_crc64_table[(-1ULL ^ attr) & 0xFF]) 2860a586ceaSMark Shellenbaum 2870a586ceaSMark Shellenbaum static uint64_t 2880a586ceaSMark Shellenbaum sa_layout_info_hash(sa_attr_type_t *attrs, int attr_count) 2890a586ceaSMark Shellenbaum { 2900a586ceaSMark Shellenbaum int i; 2910a586ceaSMark Shellenbaum uint64_t crc = -1ULL; 2920a586ceaSMark Shellenbaum 2930a586ceaSMark Shellenbaum for (i = 0; i != attr_count; i++) 2940a586ceaSMark Shellenbaum crc ^= SA_ATTR_HASH(attrs[i]); 2950a586ceaSMark Shellenbaum 2960a586ceaSMark Shellenbaum return (crc); 2970a586ceaSMark Shellenbaum } 2980a586ceaSMark Shellenbaum 2991d8ccc7bSMark Shellenbaum static int 3001d8ccc7bSMark Shellenbaum sa_get_spill(sa_handle_t *hdl) 3010a586ceaSMark Shellenbaum { 3020a586ceaSMark Shellenbaum int rc; 3030a586ceaSMark Shellenbaum if (hdl->sa_spill == NULL) { 3040a586ceaSMark Shellenbaum if ((rc = dmu_spill_hold_existing(hdl->sa_bonus, NULL, 3050a586ceaSMark Shellenbaum &hdl->sa_spill)) == 0) 3060a586ceaSMark Shellenbaum VERIFY(0 == sa_build_index(hdl, SA_SPILL)); 3070a586ceaSMark Shellenbaum } else { 3080a586ceaSMark Shellenbaum rc = 0; 3090a586ceaSMark Shellenbaum } 3100a586ceaSMark Shellenbaum 3111d8ccc7bSMark Shellenbaum return (rc); 3120a586ceaSMark Shellenbaum } 3130a586ceaSMark Shellenbaum 3140a586ceaSMark Shellenbaum /* 3150a586ceaSMark Shellenbaum * Main attribute lookup/update function 3160a586ceaSMark Shellenbaum * returns 0 for success or non zero for failures 3170a586ceaSMark Shellenbaum * 3180a586ceaSMark Shellenbaum * Operates on bulk array, first failure will abort further processing 3190a586ceaSMark Shellenbaum */ 3200a586ceaSMark Shellenbaum int 3210a586ceaSMark Shellenbaum sa_attr_op(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count, 3220a586ceaSMark Shellenbaum sa_data_op_t data_op, dmu_tx_t *tx) 3230a586ceaSMark Shellenbaum { 3240a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 3250a586ceaSMark Shellenbaum int i; 3260a586ceaSMark Shellenbaum int error = 0; 3270a586ceaSMark Shellenbaum sa_buf_type_t buftypes; 3280a586ceaSMark Shellenbaum 3290a586ceaSMark Shellenbaum buftypes = 0; 3300a586ceaSMark Shellenbaum 3310a586ceaSMark Shellenbaum ASSERT(count > 0); 3320a586ceaSMark Shellenbaum for (i = 0; i != count; i++) { 3330a586ceaSMark Shellenbaum ASSERT(bulk[i].sa_attr <= hdl->sa_os->os_sa->sa_num_attrs); 3340a586ceaSMark Shellenbaum 3350a586ceaSMark Shellenbaum bulk[i].sa_addr = NULL; 3360a586ceaSMark Shellenbaum /* First check the bonus buffer */ 3370a586ceaSMark Shellenbaum 3380a586ceaSMark Shellenbaum if (hdl->sa_bonus_tab && TOC_ATTR_PRESENT( 3390a586ceaSMark Shellenbaum hdl->sa_bonus_tab->sa_idx_tab[bulk[i].sa_attr])) { 3400a586ceaSMark Shellenbaum SA_ATTR_INFO(sa, hdl->sa_bonus_tab, 3410a586ceaSMark Shellenbaum SA_GET_HDR(hdl, SA_BONUS), 3420a586ceaSMark Shellenbaum bulk[i].sa_attr, bulk[i], SA_BONUS, hdl); 3430a586ceaSMark Shellenbaum if (tx && !(buftypes & SA_BONUS)) { 3440a586ceaSMark Shellenbaum dmu_buf_will_dirty(hdl->sa_bonus, tx); 3450a586ceaSMark Shellenbaum buftypes |= SA_BONUS; 3460a586ceaSMark Shellenbaum } 3470a586ceaSMark Shellenbaum } 3481d8ccc7bSMark Shellenbaum if (bulk[i].sa_addr == NULL && 3491d8ccc7bSMark Shellenbaum ((error = sa_get_spill(hdl)) == 0)) { 3500a586ceaSMark Shellenbaum if (TOC_ATTR_PRESENT( 3510a586ceaSMark Shellenbaum hdl->sa_spill_tab->sa_idx_tab[bulk[i].sa_attr])) { 3520a586ceaSMark Shellenbaum SA_ATTR_INFO(sa, hdl->sa_spill_tab, 3530a586ceaSMark Shellenbaum SA_GET_HDR(hdl, SA_SPILL), 3540a586ceaSMark Shellenbaum bulk[i].sa_attr, bulk[i], SA_SPILL, hdl); 3550a586ceaSMark Shellenbaum if (tx && !(buftypes & SA_SPILL) && 3560a586ceaSMark Shellenbaum bulk[i].sa_size == bulk[i].sa_length) { 3570a586ceaSMark Shellenbaum dmu_buf_will_dirty(hdl->sa_spill, tx); 3580a586ceaSMark Shellenbaum buftypes |= SA_SPILL; 3590a586ceaSMark Shellenbaum } 3600a586ceaSMark Shellenbaum } 3610a586ceaSMark Shellenbaum } 3621d8ccc7bSMark Shellenbaum if (error && error != ENOENT) { 3631d8ccc7bSMark Shellenbaum return ((error == ECKSUM) ? EIO : error); 3641d8ccc7bSMark Shellenbaum } 3651d8ccc7bSMark Shellenbaum 3660a586ceaSMark Shellenbaum switch (data_op) { 3670a586ceaSMark Shellenbaum case SA_LOOKUP: 3680a586ceaSMark Shellenbaum if (bulk[i].sa_addr == NULL) 369be6fd75aSMatthew Ahrens return (SET_ERROR(ENOENT)); 3700a586ceaSMark Shellenbaum if (bulk[i].sa_data) { 3710a586ceaSMark Shellenbaum SA_COPY_DATA(bulk[i].sa_data_func, 3720a586ceaSMark Shellenbaum bulk[i].sa_addr, bulk[i].sa_data, 3730a586ceaSMark Shellenbaum bulk[i].sa_size); 3740a586ceaSMark Shellenbaum } 3750a586ceaSMark Shellenbaum continue; 3760a586ceaSMark Shellenbaum 3770a586ceaSMark Shellenbaum case SA_UPDATE: 3780a586ceaSMark Shellenbaum /* existing rewrite of attr */ 3790a586ceaSMark Shellenbaum if (bulk[i].sa_addr && 3800a586ceaSMark Shellenbaum bulk[i].sa_size == bulk[i].sa_length) { 3810a586ceaSMark Shellenbaum SA_COPY_DATA(bulk[i].sa_data_func, 3820a586ceaSMark Shellenbaum bulk[i].sa_data, bulk[i].sa_addr, 3830a586ceaSMark Shellenbaum bulk[i].sa_length); 3840a586ceaSMark Shellenbaum continue; 3850a586ceaSMark Shellenbaum } else if (bulk[i].sa_addr) { /* attr size change */ 3860a586ceaSMark Shellenbaum error = sa_modify_attrs(hdl, bulk[i].sa_attr, 3870a586ceaSMark Shellenbaum SA_REPLACE, bulk[i].sa_data_func, 3880a586ceaSMark Shellenbaum bulk[i].sa_data, bulk[i].sa_length, tx); 3890a586ceaSMark Shellenbaum } else { /* adding new attribute */ 3900a586ceaSMark Shellenbaum error = sa_modify_attrs(hdl, bulk[i].sa_attr, 3910a586ceaSMark Shellenbaum SA_ADD, bulk[i].sa_data_func, 3920a586ceaSMark Shellenbaum bulk[i].sa_data, bulk[i].sa_length, tx); 3930a586ceaSMark Shellenbaum } 3940a586ceaSMark Shellenbaum if (error) 3950a586ceaSMark Shellenbaum return (error); 3960a586ceaSMark Shellenbaum break; 3970a586ceaSMark Shellenbaum } 3980a586ceaSMark Shellenbaum } 3990a586ceaSMark Shellenbaum return (error); 4000a586ceaSMark Shellenbaum } 4010a586ceaSMark Shellenbaum 4020a586ceaSMark Shellenbaum static sa_lot_t * 4030a586ceaSMark Shellenbaum sa_add_layout_entry(objset_t *os, sa_attr_type_t *attrs, int attr_count, 4040a586ceaSMark Shellenbaum uint64_t lot_num, uint64_t hash, boolean_t zapadd, dmu_tx_t *tx) 4050a586ceaSMark Shellenbaum { 4060a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 4070a586ceaSMark Shellenbaum sa_lot_t *tb, *findtb; 4080a586ceaSMark Shellenbaum int i; 4090a586ceaSMark Shellenbaum avl_index_t loc; 4100a586ceaSMark Shellenbaum 4110a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&sa->sa_lock)); 4120a586ceaSMark Shellenbaum tb = kmem_zalloc(sizeof (sa_lot_t), KM_SLEEP); 4130a586ceaSMark Shellenbaum tb->lot_attr_count = attr_count; 4140a586ceaSMark Shellenbaum tb->lot_attrs = kmem_alloc(sizeof (sa_attr_type_t) * attr_count, 4150a586ceaSMark Shellenbaum KM_SLEEP); 4160a586ceaSMark Shellenbaum bcopy(attrs, tb->lot_attrs, sizeof (sa_attr_type_t) * attr_count); 4170a586ceaSMark Shellenbaum tb->lot_num = lot_num; 4180a586ceaSMark Shellenbaum tb->lot_hash = hash; 4190a586ceaSMark Shellenbaum tb->lot_instance = 0; 4200a586ceaSMark Shellenbaum 4210a586ceaSMark Shellenbaum if (zapadd) { 4220a586ceaSMark Shellenbaum char attr_name[8]; 4230a586ceaSMark Shellenbaum 4240a586ceaSMark Shellenbaum if (sa->sa_layout_attr_obj == 0) { 425ad135b5dSChristopher Siden sa->sa_layout_attr_obj = zap_create_link(os, 426ad135b5dSChristopher Siden DMU_OT_SA_ATTR_LAYOUTS, 427ad135b5dSChristopher Siden sa->sa_master_obj, SA_LAYOUTS, tx); 4280a586ceaSMark Shellenbaum } 4290a586ceaSMark Shellenbaum 4300a586ceaSMark Shellenbaum (void) snprintf(attr_name, sizeof (attr_name), 4310a586ceaSMark Shellenbaum "%d", (int)lot_num); 4320a586ceaSMark Shellenbaum VERIFY(0 == zap_update(os, os->os_sa->sa_layout_attr_obj, 4330a586ceaSMark Shellenbaum attr_name, 2, attr_count, attrs, tx)); 4340a586ceaSMark Shellenbaum } 4350a586ceaSMark Shellenbaum 4360a586ceaSMark Shellenbaum list_create(&tb->lot_idx_tab, sizeof (sa_idx_tab_t), 4370a586ceaSMark Shellenbaum offsetof(sa_idx_tab_t, sa_next)); 4380a586ceaSMark Shellenbaum 4390a586ceaSMark Shellenbaum for (i = 0; i != attr_count; i++) { 4400a586ceaSMark Shellenbaum if (sa->sa_attr_table[tb->lot_attrs[i]].sa_length == 0) 4410a586ceaSMark Shellenbaum tb->lot_var_sizes++; 4420a586ceaSMark Shellenbaum } 4430a586ceaSMark Shellenbaum 4440a586ceaSMark Shellenbaum avl_add(&sa->sa_layout_num_tree, tb); 4450a586ceaSMark Shellenbaum 4460a586ceaSMark Shellenbaum /* verify we don't have a hash collision */ 4470a586ceaSMark Shellenbaum if ((findtb = avl_find(&sa->sa_layout_hash_tree, tb, &loc)) != NULL) { 4480a586ceaSMark Shellenbaum for (; findtb && findtb->lot_hash == hash; 4490a586ceaSMark Shellenbaum findtb = AVL_NEXT(&sa->sa_layout_hash_tree, findtb)) { 4500a586ceaSMark Shellenbaum if (findtb->lot_instance != tb->lot_instance) 4510a586ceaSMark Shellenbaum break; 4520a586ceaSMark Shellenbaum tb->lot_instance++; 4530a586ceaSMark Shellenbaum } 4540a586ceaSMark Shellenbaum } 4550a586ceaSMark Shellenbaum avl_add(&sa->sa_layout_hash_tree, tb); 4560a586ceaSMark Shellenbaum return (tb); 4570a586ceaSMark Shellenbaum } 4580a586ceaSMark Shellenbaum 4590a586ceaSMark Shellenbaum static void 4600a586ceaSMark Shellenbaum sa_find_layout(objset_t *os, uint64_t hash, sa_attr_type_t *attrs, 4610a586ceaSMark Shellenbaum int count, dmu_tx_t *tx, sa_lot_t **lot) 4620a586ceaSMark Shellenbaum { 4630a586ceaSMark Shellenbaum sa_lot_t *tb, tbsearch; 4640a586ceaSMark Shellenbaum avl_index_t loc; 4650a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 4660a586ceaSMark Shellenbaum boolean_t found = B_FALSE; 4670a586ceaSMark Shellenbaum 4680a586ceaSMark Shellenbaum mutex_enter(&sa->sa_lock); 4690a586ceaSMark Shellenbaum tbsearch.lot_hash = hash; 4700a586ceaSMark Shellenbaum tbsearch.lot_instance = 0; 4710a586ceaSMark Shellenbaum tb = avl_find(&sa->sa_layout_hash_tree, &tbsearch, &loc); 4720a586ceaSMark Shellenbaum if (tb) { 4730a586ceaSMark Shellenbaum for (; tb && tb->lot_hash == hash; 4740a586ceaSMark Shellenbaum tb = AVL_NEXT(&sa->sa_layout_hash_tree, tb)) { 4750a586ceaSMark Shellenbaum if (sa_layout_equal(tb, attrs, count) == 0) { 4760a586ceaSMark Shellenbaum found = B_TRUE; 4770a586ceaSMark Shellenbaum break; 4780a586ceaSMark Shellenbaum } 4790a586ceaSMark Shellenbaum } 4800a586ceaSMark Shellenbaum } 4810a586ceaSMark Shellenbaum if (!found) { 4820a586ceaSMark Shellenbaum tb = sa_add_layout_entry(os, attrs, count, 4830a586ceaSMark Shellenbaum avl_numnodes(&sa->sa_layout_num_tree), hash, B_TRUE, tx); 4840a586ceaSMark Shellenbaum } 4850a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 4860a586ceaSMark Shellenbaum *lot = tb; 4870a586ceaSMark Shellenbaum } 4880a586ceaSMark Shellenbaum 4890a586ceaSMark Shellenbaum static int 4900a586ceaSMark Shellenbaum sa_resize_spill(sa_handle_t *hdl, uint32_t size, dmu_tx_t *tx) 4910a586ceaSMark Shellenbaum { 4920a586ceaSMark Shellenbaum int error; 4930a586ceaSMark Shellenbaum uint32_t blocksize; 4940a586ceaSMark Shellenbaum 4950a586ceaSMark Shellenbaum if (size == 0) { 4960a586ceaSMark Shellenbaum blocksize = SPA_MINBLOCKSIZE; 497b5152584SMatthew Ahrens } else if (size > SPA_OLD_MAXBLOCKSIZE) { 4980a586ceaSMark Shellenbaum ASSERT(0); 499be6fd75aSMatthew Ahrens return (SET_ERROR(EFBIG)); 5000a586ceaSMark Shellenbaum } else { 5010a586ceaSMark Shellenbaum blocksize = P2ROUNDUP_TYPED(size, SPA_MINBLOCKSIZE, uint32_t); 5020a586ceaSMark Shellenbaum } 5030a586ceaSMark Shellenbaum 5040a586ceaSMark Shellenbaum error = dbuf_spill_set_blksz(hdl->sa_spill, blocksize, tx); 5050a586ceaSMark Shellenbaum ASSERT(error == 0); 5060a586ceaSMark Shellenbaum return (error); 5070a586ceaSMark Shellenbaum } 5080a586ceaSMark Shellenbaum 5090a586ceaSMark Shellenbaum static void 5100a586ceaSMark Shellenbaum sa_copy_data(sa_data_locator_t *func, void *datastart, void *target, int buflen) 5110a586ceaSMark Shellenbaum { 5120a586ceaSMark Shellenbaum if (func == NULL) { 5130a586ceaSMark Shellenbaum bcopy(datastart, target, buflen); 5140a586ceaSMark Shellenbaum } else { 5150a586ceaSMark Shellenbaum boolean_t start; 5160a586ceaSMark Shellenbaum int bytes; 5170a586ceaSMark Shellenbaum void *dataptr; 5180a586ceaSMark Shellenbaum void *saptr = target; 5190a586ceaSMark Shellenbaum uint32_t length; 5200a586ceaSMark Shellenbaum 5210a586ceaSMark Shellenbaum start = B_TRUE; 5220a586ceaSMark Shellenbaum bytes = 0; 5230a586ceaSMark Shellenbaum while (bytes < buflen) { 5240a586ceaSMark Shellenbaum func(&dataptr, &length, buflen, start, datastart); 5250a586ceaSMark Shellenbaum bcopy(dataptr, saptr, length); 5260a586ceaSMark Shellenbaum saptr = (void *)((caddr_t)saptr + length); 5270a586ceaSMark Shellenbaum bytes += length; 5280a586ceaSMark Shellenbaum start = B_FALSE; 5290a586ceaSMark Shellenbaum } 5300a586ceaSMark Shellenbaum } 5310a586ceaSMark Shellenbaum } 5320a586ceaSMark Shellenbaum 5330a586ceaSMark Shellenbaum /* 5340a586ceaSMark Shellenbaum * Determine several different sizes 5350a586ceaSMark Shellenbaum * first the sa header size 5360a586ceaSMark Shellenbaum * the number of bytes to be stored 5370a586ceaSMark Shellenbaum * if spill would occur the index in the attribute array is returned 5380a586ceaSMark Shellenbaum * 5390a586ceaSMark Shellenbaum * the boolean will_spill will be set when spilling is necessary. It 5400a586ceaSMark Shellenbaum * is only set when the buftype is SA_BONUS 5410a586ceaSMark Shellenbaum */ 5420a586ceaSMark Shellenbaum static int 5430a586ceaSMark Shellenbaum sa_find_sizes(sa_os_t *sa, sa_bulk_attr_t *attr_desc, int attr_count, 54454811da5SToomas Soome dmu_buf_t *db, sa_buf_type_t buftype, int full_space, int *index, 54554811da5SToomas Soome int *total, boolean_t *will_spill) 5460a586ceaSMark Shellenbaum { 5470a586ceaSMark Shellenbaum int var_size = 0; 5480a586ceaSMark Shellenbaum int i; 5490a586ceaSMark Shellenbaum int hdrsize; 5503502ed6eSJames Pan int extra_hdrsize; 5510a586ceaSMark Shellenbaum 5520a586ceaSMark Shellenbaum if (buftype == SA_BONUS && sa->sa_force_spill) { 5530a586ceaSMark Shellenbaum *total = 0; 5540a586ceaSMark Shellenbaum *index = 0; 5550a586ceaSMark Shellenbaum *will_spill = B_TRUE; 5560a586ceaSMark Shellenbaum return (0); 5570a586ceaSMark Shellenbaum } 5580a586ceaSMark Shellenbaum 5590a586ceaSMark Shellenbaum *index = -1; 5600a586ceaSMark Shellenbaum *total = 0; 5613502ed6eSJames Pan *will_spill = B_FALSE; 5620a586ceaSMark Shellenbaum 5633502ed6eSJames Pan extra_hdrsize = 0; 5640a586ceaSMark Shellenbaum hdrsize = (SA_BONUSTYPE_FROM_DB(db) == DMU_OT_ZNODE) ? 0 : 5650a586ceaSMark Shellenbaum sizeof (sa_hdr_phys_t); 5660a586ceaSMark Shellenbaum 567644b9528SNed Bass ASSERT(IS_P2ALIGNED(full_space, 8)); 5680a586ceaSMark Shellenbaum 5690a586ceaSMark Shellenbaum for (i = 0; i != attr_count; i++) { 5700a586ceaSMark Shellenbaum boolean_t is_var_sz; 5710a586ceaSMark Shellenbaum 572644b9528SNed Bass *total = P2ROUNDUP(*total, 8); 5730a586ceaSMark Shellenbaum *total += attr_desc[i].sa_length; 5743502ed6eSJames Pan if (*will_spill) 5753502ed6eSJames Pan continue; 5760a586ceaSMark Shellenbaum 5770a586ceaSMark Shellenbaum is_var_sz = (SA_REGISTERED_LEN(sa, attr_desc[i].sa_attr) == 0); 5780a586ceaSMark Shellenbaum if (is_var_sz) { 5790a586ceaSMark Shellenbaum var_size++; 5800a586ceaSMark Shellenbaum } 5810a586ceaSMark Shellenbaum 5820a586ceaSMark Shellenbaum if (is_var_sz && var_size > 1) { 5833502ed6eSJames Pan /* 5843502ed6eSJames Pan * Don't worry that the spill block might overflow. 5853502ed6eSJames Pan * It will be resized if needed in sa_build_layouts(). 5863502ed6eSJames Pan */ 5873502ed6eSJames Pan if (buftype == SA_SPILL || 5883502ed6eSJames Pan P2ROUNDUP(hdrsize + sizeof (uint16_t), 8) + 5890a586ceaSMark Shellenbaum *total < full_space) { 590644b9528SNed Bass /* 591644b9528SNed Bass * Account for header space used by array of 592644b9528SNed Bass * optional sizes of variable-length attributes. 5933502ed6eSJames Pan * Record the extra header size in case this 5943502ed6eSJames Pan * increase needs to be reversed due to 5953502ed6eSJames Pan * spill-over. 596644b9528SNed Bass */ 5970a586ceaSMark Shellenbaum hdrsize += sizeof (uint16_t); 5983502ed6eSJames Pan if (*index != -1) 5993502ed6eSJames Pan extra_hdrsize += sizeof (uint16_t); 6000a586ceaSMark Shellenbaum } else { 6013502ed6eSJames Pan ASSERT(buftype == SA_BONUS); 6023502ed6eSJames Pan if (*index == -1) 6033502ed6eSJames Pan *index = i; 6043502ed6eSJames Pan *will_spill = B_TRUE; 6050a586ceaSMark Shellenbaum continue; 6060a586ceaSMark Shellenbaum } 6070a586ceaSMark Shellenbaum } 6080a586ceaSMark Shellenbaum 6090a586ceaSMark Shellenbaum /* 6100a586ceaSMark Shellenbaum * find index of where spill *could* occur. 6110a586ceaSMark Shellenbaum * Then continue to count of remainder attribute 6120a586ceaSMark Shellenbaum * space. The sum is used later for sizing bonus 6130a586ceaSMark Shellenbaum * and spill buffer. 6140a586ceaSMark Shellenbaum */ 6150a586ceaSMark Shellenbaum if (buftype == SA_BONUS && *index == -1 && 616383e7c74SXin Li *total + P2ROUNDUP(hdrsize, 8) > 6170a586ceaSMark Shellenbaum (full_space - sizeof (blkptr_t))) { 6180a586ceaSMark Shellenbaum *index = i; 6190a586ceaSMark Shellenbaum } 6200a586ceaSMark Shellenbaum 621383e7c74SXin Li if (*total + P2ROUNDUP(hdrsize, 8) > full_space && 6220a586ceaSMark Shellenbaum buftype == SA_BONUS) 6230a586ceaSMark Shellenbaum *will_spill = B_TRUE; 6240a586ceaSMark Shellenbaum } 6250a586ceaSMark Shellenbaum 6263502ed6eSJames Pan if (*will_spill) 6273502ed6eSJames Pan hdrsize -= extra_hdrsize; 628644b9528SNed Bass 6290a586ceaSMark Shellenbaum hdrsize = P2ROUNDUP(hdrsize, 8); 6300a586ceaSMark Shellenbaum return (hdrsize); 6310a586ceaSMark Shellenbaum } 6320a586ceaSMark Shellenbaum 6330a586ceaSMark Shellenbaum #define BUF_SPACE_NEEDED(total, header) (total + header) 6340a586ceaSMark Shellenbaum 6350a586ceaSMark Shellenbaum /* 6360a586ceaSMark Shellenbaum * Find layout that corresponds to ordering of attributes 6370a586ceaSMark Shellenbaum * If not found a new layout number is created and added to 6380a586ceaSMark Shellenbaum * persistent layout tables. 6390a586ceaSMark Shellenbaum */ 6400a586ceaSMark Shellenbaum static int 6410a586ceaSMark Shellenbaum sa_build_layouts(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, int attr_count, 6420a586ceaSMark Shellenbaum dmu_tx_t *tx) 6430a586ceaSMark Shellenbaum { 6440a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 6450a586ceaSMark Shellenbaum uint64_t hash; 6460a586ceaSMark Shellenbaum sa_buf_type_t buftype; 6470a586ceaSMark Shellenbaum sa_hdr_phys_t *sahdr; 6480a586ceaSMark Shellenbaum void *data_start; 6490a586ceaSMark Shellenbaum int buf_space; 6500a586ceaSMark Shellenbaum sa_attr_type_t *attrs, *attrs_start; 6510a586ceaSMark Shellenbaum int i, lot_count; 65254811da5SToomas Soome int dnodesize; 653d5285caeSGeorge Wilson int hdrsize; 654d5285caeSGeorge Wilson int spillhdrsize = 0; 6550a586ceaSMark Shellenbaum int used; 6560a586ceaSMark Shellenbaum dmu_object_type_t bonustype; 6570a586ceaSMark Shellenbaum sa_lot_t *lot; 6580a586ceaSMark Shellenbaum int len_idx; 6590a586ceaSMark Shellenbaum int spill_used; 66054811da5SToomas Soome int bonuslen; 6610a586ceaSMark Shellenbaum boolean_t spilling; 6620a586ceaSMark Shellenbaum 6630a586ceaSMark Shellenbaum dmu_buf_will_dirty(hdl->sa_bonus, tx); 6640a586ceaSMark Shellenbaum bonustype = SA_BONUSTYPE_FROM_DB(hdl->sa_bonus); 6650a586ceaSMark Shellenbaum 66654811da5SToomas Soome dmu_object_dnsize_from_db(hdl->sa_bonus, &dnodesize); 66754811da5SToomas Soome bonuslen = DN_BONUS_SIZE(dnodesize); 66854811da5SToomas Soome 6690a586ceaSMark Shellenbaum /* first determine bonus header size and sum of all attributes */ 6700a586ceaSMark Shellenbaum hdrsize = sa_find_sizes(sa, attr_desc, attr_count, hdl->sa_bonus, 67154811da5SToomas Soome SA_BONUS, bonuslen, &i, &used, &spilling); 6720a586ceaSMark Shellenbaum 673b5152584SMatthew Ahrens if (used > SPA_OLD_MAXBLOCKSIZE) 674be6fd75aSMatthew Ahrens return (SET_ERROR(EFBIG)); 6750a586ceaSMark Shellenbaum 6760a586ceaSMark Shellenbaum VERIFY(0 == dmu_set_bonus(hdl->sa_bonus, spilling ? 67754811da5SToomas Soome MIN(bonuslen - sizeof (blkptr_t), used + hdrsize) : 6780a586ceaSMark Shellenbaum used + hdrsize, tx)); 6790a586ceaSMark Shellenbaum 6800a586ceaSMark Shellenbaum ASSERT((bonustype == DMU_OT_ZNODE && spilling == 0) || 6810a586ceaSMark Shellenbaum bonustype == DMU_OT_SA); 6820a586ceaSMark Shellenbaum 6830a586ceaSMark Shellenbaum /* setup and size spill buffer when needed */ 6840a586ceaSMark Shellenbaum if (spilling) { 6850a586ceaSMark Shellenbaum boolean_t dummy; 6860a586ceaSMark Shellenbaum 6870a586ceaSMark Shellenbaum if (hdl->sa_spill == NULL) { 688eb633035STom Caputi VERIFY(dmu_spill_hold_by_bonus(hdl->sa_bonus, 0, NULL, 6891d8ccc7bSMark Shellenbaum &hdl->sa_spill) == 0); 6900a586ceaSMark Shellenbaum } 6910a586ceaSMark Shellenbaum dmu_buf_will_dirty(hdl->sa_spill, tx); 6920a586ceaSMark Shellenbaum 6930a586ceaSMark Shellenbaum spillhdrsize = sa_find_sizes(sa, &attr_desc[i], 69454811da5SToomas Soome attr_count - i, hdl->sa_spill, SA_SPILL, 69554811da5SToomas Soome hdl->sa_spill->db_size, &i, &spill_used, &dummy); 6960a586ceaSMark Shellenbaum 697b5152584SMatthew Ahrens if (spill_used > SPA_OLD_MAXBLOCKSIZE) 698be6fd75aSMatthew Ahrens return (SET_ERROR(EFBIG)); 6990a586ceaSMark Shellenbaum 7000a586ceaSMark Shellenbaum buf_space = hdl->sa_spill->db_size - spillhdrsize; 7010a586ceaSMark Shellenbaum if (BUF_SPACE_NEEDED(spill_used, spillhdrsize) > 7020a586ceaSMark Shellenbaum hdl->sa_spill->db_size) 7030a586ceaSMark Shellenbaum VERIFY(0 == sa_resize_spill(hdl, 7040a586ceaSMark Shellenbaum BUF_SPACE_NEEDED(spill_used, spillhdrsize), tx)); 7050a586ceaSMark Shellenbaum } 7060a586ceaSMark Shellenbaum 7070a586ceaSMark Shellenbaum /* setup starting pointers to lay down data */ 7080a586ceaSMark Shellenbaum data_start = (void *)((uintptr_t)hdl->sa_bonus->db_data + hdrsize); 7090a586ceaSMark Shellenbaum sahdr = (sa_hdr_phys_t *)hdl->sa_bonus->db_data; 7100a586ceaSMark Shellenbaum buftype = SA_BONUS; 7110a586ceaSMark Shellenbaum 7120a586ceaSMark Shellenbaum if (spilling) 7130a586ceaSMark Shellenbaum buf_space = (sa->sa_force_spill) ? 7140a586ceaSMark Shellenbaum 0 : SA_BLKPTR_SPACE - hdrsize; 7150a586ceaSMark Shellenbaum else 7160a586ceaSMark Shellenbaum buf_space = hdl->sa_bonus->db_size - hdrsize; 7170a586ceaSMark Shellenbaum 7180a586ceaSMark Shellenbaum attrs_start = attrs = kmem_alloc(sizeof (sa_attr_type_t) * attr_count, 7190a586ceaSMark Shellenbaum KM_SLEEP); 7200a586ceaSMark Shellenbaum lot_count = 0; 7210a586ceaSMark Shellenbaum 7220a586ceaSMark Shellenbaum for (i = 0, len_idx = 0, hash = -1ULL; i != attr_count; i++) { 7230a586ceaSMark Shellenbaum uint16_t length; 7240a586ceaSMark Shellenbaum 725644b9528SNed Bass ASSERT(IS_P2ALIGNED(data_start, 8)); 726644b9528SNed Bass ASSERT(IS_P2ALIGNED(buf_space, 8)); 7270a586ceaSMark Shellenbaum attrs[i] = attr_desc[i].sa_attr; 7280a586ceaSMark Shellenbaum length = SA_REGISTERED_LEN(sa, attrs[i]); 7290a586ceaSMark Shellenbaum if (length == 0) 7300a586ceaSMark Shellenbaum length = attr_desc[i].sa_length; 7310a586ceaSMark Shellenbaum 7320a586ceaSMark Shellenbaum if (buf_space < length) { /* switch to spill buffer */ 733644b9528SNed Bass VERIFY(spilling); 7341412a1a2SMark Shellenbaum VERIFY(bonustype == DMU_OT_SA); 7350a586ceaSMark Shellenbaum if (buftype == SA_BONUS && !sa->sa_force_spill) { 7360a586ceaSMark Shellenbaum sa_find_layout(hdl->sa_os, hash, attrs_start, 7370a586ceaSMark Shellenbaum lot_count, tx, &lot); 7380a586ceaSMark Shellenbaum SA_SET_HDR(sahdr, lot->lot_num, hdrsize); 7390a586ceaSMark Shellenbaum } 7400a586ceaSMark Shellenbaum 7410a586ceaSMark Shellenbaum buftype = SA_SPILL; 7420a586ceaSMark Shellenbaum hash = -1ULL; 7430a586ceaSMark Shellenbaum len_idx = 0; 7440a586ceaSMark Shellenbaum 7450a586ceaSMark Shellenbaum sahdr = (sa_hdr_phys_t *)hdl->sa_spill->db_data; 7460a586ceaSMark Shellenbaum sahdr->sa_magic = SA_MAGIC; 7470a586ceaSMark Shellenbaum data_start = (void *)((uintptr_t)sahdr + 7480a586ceaSMark Shellenbaum spillhdrsize); 7490a586ceaSMark Shellenbaum attrs_start = &attrs[i]; 7500a586ceaSMark Shellenbaum buf_space = hdl->sa_spill->db_size - spillhdrsize; 7510a586ceaSMark Shellenbaum lot_count = 0; 7520a586ceaSMark Shellenbaum } 7530a586ceaSMark Shellenbaum hash ^= SA_ATTR_HASH(attrs[i]); 7540a586ceaSMark Shellenbaum attr_desc[i].sa_addr = data_start; 7550a586ceaSMark Shellenbaum attr_desc[i].sa_size = length; 7560a586ceaSMark Shellenbaum SA_COPY_DATA(attr_desc[i].sa_data_func, attr_desc[i].sa_data, 7570a586ceaSMark Shellenbaum data_start, length); 7580a586ceaSMark Shellenbaum if (sa->sa_attr_table[attrs[i]].sa_length == 0) { 7590a586ceaSMark Shellenbaum sahdr->sa_lengths[len_idx++] = length; 7600a586ceaSMark Shellenbaum } 7610a586ceaSMark Shellenbaum data_start = (void *)P2ROUNDUP(((uintptr_t)data_start + 7620a586ceaSMark Shellenbaum length), 8); 7630a586ceaSMark Shellenbaum buf_space -= P2ROUNDUP(length, 8); 7640a586ceaSMark Shellenbaum lot_count++; 7650a586ceaSMark Shellenbaum } 7660a586ceaSMark Shellenbaum 7670a586ceaSMark Shellenbaum sa_find_layout(hdl->sa_os, hash, attrs_start, lot_count, tx, &lot); 7681412a1a2SMark Shellenbaum 7691412a1a2SMark Shellenbaum /* 7701412a1a2SMark Shellenbaum * Verify that old znodes always have layout number 0. 7711412a1a2SMark Shellenbaum * Must be DMU_OT_SA for arbitrary layouts 7721412a1a2SMark Shellenbaum */ 7731412a1a2SMark Shellenbaum VERIFY((bonustype == DMU_OT_ZNODE && lot->lot_num == 0) || 7741412a1a2SMark Shellenbaum (bonustype == DMU_OT_SA && lot->lot_num > 1)); 7751412a1a2SMark Shellenbaum 7760a586ceaSMark Shellenbaum if (bonustype == DMU_OT_SA) { 7770a586ceaSMark Shellenbaum SA_SET_HDR(sahdr, lot->lot_num, 7780a586ceaSMark Shellenbaum buftype == SA_BONUS ? hdrsize : spillhdrsize); 7790a586ceaSMark Shellenbaum } 7800a586ceaSMark Shellenbaum 7810a586ceaSMark Shellenbaum kmem_free(attrs, sizeof (sa_attr_type_t) * attr_count); 7820a586ceaSMark Shellenbaum if (hdl->sa_bonus_tab) { 7830a586ceaSMark Shellenbaum sa_idx_tab_rele(hdl->sa_os, hdl->sa_bonus_tab); 7840a586ceaSMark Shellenbaum hdl->sa_bonus_tab = NULL; 7850a586ceaSMark Shellenbaum } 7860a586ceaSMark Shellenbaum if (!sa->sa_force_spill) 7870a586ceaSMark Shellenbaum VERIFY(0 == sa_build_index(hdl, SA_BONUS)); 7880a586ceaSMark Shellenbaum if (hdl->sa_spill) { 7890a586ceaSMark Shellenbaum sa_idx_tab_rele(hdl->sa_os, hdl->sa_spill_tab); 7900a586ceaSMark Shellenbaum if (!spilling) { 7910a586ceaSMark Shellenbaum /* 7920a586ceaSMark Shellenbaum * remove spill block that is no longer needed. 7930a586ceaSMark Shellenbaum */ 7940a586ceaSMark Shellenbaum dmu_buf_rele(hdl->sa_spill, NULL); 7950a586ceaSMark Shellenbaum hdl->sa_spill = NULL; 7960a586ceaSMark Shellenbaum hdl->sa_spill_tab = NULL; 7970a586ceaSMark Shellenbaum VERIFY(0 == dmu_rm_spill(hdl->sa_os, 7980a586ceaSMark Shellenbaum sa_handle_object(hdl), tx)); 7990a586ceaSMark Shellenbaum } else { 8000a586ceaSMark Shellenbaum VERIFY(0 == sa_build_index(hdl, SA_SPILL)); 8010a586ceaSMark Shellenbaum } 8020a586ceaSMark Shellenbaum } 8030a586ceaSMark Shellenbaum 8040a586ceaSMark Shellenbaum return (0); 8050a586ceaSMark Shellenbaum } 8060a586ceaSMark Shellenbaum 8070a586ceaSMark Shellenbaum static void 8081d8ccc7bSMark Shellenbaum sa_free_attr_table(sa_os_t *sa) 8091d8ccc7bSMark Shellenbaum { 8101d8ccc7bSMark Shellenbaum int i; 8111d8ccc7bSMark Shellenbaum 8121d8ccc7bSMark Shellenbaum if (sa->sa_attr_table == NULL) 8131d8ccc7bSMark Shellenbaum return; 8141d8ccc7bSMark Shellenbaum 8151d8ccc7bSMark Shellenbaum for (i = 0; i != sa->sa_num_attrs; i++) { 8161d8ccc7bSMark Shellenbaum if (sa->sa_attr_table[i].sa_name) 8171d8ccc7bSMark Shellenbaum kmem_free(sa->sa_attr_table[i].sa_name, 8181d8ccc7bSMark Shellenbaum strlen(sa->sa_attr_table[i].sa_name) + 1); 8191d8ccc7bSMark Shellenbaum } 8201d8ccc7bSMark Shellenbaum 8211d8ccc7bSMark Shellenbaum kmem_free(sa->sa_attr_table, 8221d8ccc7bSMark Shellenbaum sizeof (sa_attr_table_t) * sa->sa_num_attrs); 8231d8ccc7bSMark Shellenbaum 8241d8ccc7bSMark Shellenbaum sa->sa_attr_table = NULL; 8251d8ccc7bSMark Shellenbaum } 8261d8ccc7bSMark Shellenbaum 8271d8ccc7bSMark Shellenbaum static int 8280a586ceaSMark Shellenbaum sa_attr_table_setup(objset_t *os, sa_attr_reg_t *reg_attrs, int count) 8290a586ceaSMark Shellenbaum { 8300a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 8310a586ceaSMark Shellenbaum uint64_t sa_attr_count = 0; 832d5285caeSGeorge Wilson uint64_t sa_reg_count = 0; 8330a586ceaSMark Shellenbaum int error = 0; 8340a586ceaSMark Shellenbaum uint64_t attr_value; 8350a586ceaSMark Shellenbaum sa_attr_table_t *tb; 8360a586ceaSMark Shellenbaum zap_cursor_t zc; 8370a586ceaSMark Shellenbaum zap_attribute_t za; 8380a586ceaSMark Shellenbaum int registered_count = 0; 8390a586ceaSMark Shellenbaum int i; 8400a586ceaSMark Shellenbaum dmu_objset_type_t ostype = dmu_objset_type(os); 8410a586ceaSMark Shellenbaum 8420a586ceaSMark Shellenbaum sa->sa_user_table = 8430a586ceaSMark Shellenbaum kmem_zalloc(count * sizeof (sa_attr_type_t), KM_SLEEP); 8440a586ceaSMark Shellenbaum sa->sa_user_table_sz = count * sizeof (sa_attr_type_t); 8450a586ceaSMark Shellenbaum 8461d8ccc7bSMark Shellenbaum if (sa->sa_reg_attr_obj != 0) { 8471d8ccc7bSMark Shellenbaum error = zap_count(os, sa->sa_reg_attr_obj, 8481d8ccc7bSMark Shellenbaum &sa_attr_count); 8491d8ccc7bSMark Shellenbaum 8501d8ccc7bSMark Shellenbaum /* 8511d8ccc7bSMark Shellenbaum * Make sure we retrieved a count and that it isn't zero 8521d8ccc7bSMark Shellenbaum */ 8531d8ccc7bSMark Shellenbaum if (error || (error == 0 && sa_attr_count == 0)) { 8541d8ccc7bSMark Shellenbaum if (error == 0) 855be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 8561d8ccc7bSMark Shellenbaum goto bail; 8571d8ccc7bSMark Shellenbaum } 8581d8ccc7bSMark Shellenbaum sa_reg_count = sa_attr_count; 8591d8ccc7bSMark Shellenbaum } 8600a586ceaSMark Shellenbaum 8610a586ceaSMark Shellenbaum if (ostype == DMU_OST_ZFS && sa_attr_count == 0) 8620a586ceaSMark Shellenbaum sa_attr_count += sa_legacy_attr_count; 8630a586ceaSMark Shellenbaum 8640a586ceaSMark Shellenbaum /* Allocate attribute numbers for attributes that aren't registered */ 8650a586ceaSMark Shellenbaum for (i = 0; i != count; i++) { 8660a586ceaSMark Shellenbaum boolean_t found = B_FALSE; 8670a586ceaSMark Shellenbaum int j; 8680a586ceaSMark Shellenbaum 8690a586ceaSMark Shellenbaum if (ostype == DMU_OST_ZFS) { 8700a586ceaSMark Shellenbaum for (j = 0; j != sa_legacy_attr_count; j++) { 8710a586ceaSMark Shellenbaum if (strcmp(reg_attrs[i].sa_name, 8720a586ceaSMark Shellenbaum sa_legacy_attrs[j].sa_name) == 0) { 8730a586ceaSMark Shellenbaum sa->sa_user_table[i] = 8740a586ceaSMark Shellenbaum sa_legacy_attrs[j].sa_attr; 8750a586ceaSMark Shellenbaum found = B_TRUE; 8760a586ceaSMark Shellenbaum } 8770a586ceaSMark Shellenbaum } 8780a586ceaSMark Shellenbaum } 8790a586ceaSMark Shellenbaum if (found) 8800a586ceaSMark Shellenbaum continue; 8810a586ceaSMark Shellenbaum 8820a586ceaSMark Shellenbaum if (sa->sa_reg_attr_obj) 8830a586ceaSMark Shellenbaum error = zap_lookup(os, sa->sa_reg_attr_obj, 8840a586ceaSMark Shellenbaum reg_attrs[i].sa_name, 8, 1, &attr_value); 8850a586ceaSMark Shellenbaum else 886be6fd75aSMatthew Ahrens error = SET_ERROR(ENOENT); 8870a586ceaSMark Shellenbaum switch (error) { 8880a586ceaSMark Shellenbaum case ENOENT: 8890a586ceaSMark Shellenbaum sa->sa_user_table[i] = (sa_attr_type_t)sa_attr_count; 8900a586ceaSMark Shellenbaum sa_attr_count++; 8910a586ceaSMark Shellenbaum break; 8920a586ceaSMark Shellenbaum case 0: 8930a586ceaSMark Shellenbaum sa->sa_user_table[i] = ATTR_NUM(attr_value); 8940a586ceaSMark Shellenbaum break; 8951d8ccc7bSMark Shellenbaum default: 8961d8ccc7bSMark Shellenbaum goto bail; 8970a586ceaSMark Shellenbaum } 8980a586ceaSMark Shellenbaum } 8990a586ceaSMark Shellenbaum 9001d8ccc7bSMark Shellenbaum sa->sa_num_attrs = sa_attr_count; 9011d8ccc7bSMark Shellenbaum tb = sa->sa_attr_table = 9020a586ceaSMark Shellenbaum kmem_zalloc(sizeof (sa_attr_table_t) * sa_attr_count, KM_SLEEP); 9030a586ceaSMark Shellenbaum 9040a586ceaSMark Shellenbaum /* 9050a586ceaSMark Shellenbaum * Attribute table is constructed from requested attribute list, 9060a586ceaSMark Shellenbaum * previously foreign registered attributes, and also the legacy 9070a586ceaSMark Shellenbaum * ZPL set of attributes. 9080a586ceaSMark Shellenbaum */ 9090a586ceaSMark Shellenbaum 9100a586ceaSMark Shellenbaum if (sa->sa_reg_attr_obj) { 9110a586ceaSMark Shellenbaum for (zap_cursor_init(&zc, os, sa->sa_reg_attr_obj); 9121d8ccc7bSMark Shellenbaum (error = zap_cursor_retrieve(&zc, &za)) == 0; 9130a586ceaSMark Shellenbaum zap_cursor_advance(&zc)) { 9140a586ceaSMark Shellenbaum uint64_t value; 9150a586ceaSMark Shellenbaum value = za.za_first_integer; 9160a586ceaSMark Shellenbaum 9170a586ceaSMark Shellenbaum registered_count++; 9180a586ceaSMark Shellenbaum tb[ATTR_NUM(value)].sa_attr = ATTR_NUM(value); 9190a586ceaSMark Shellenbaum tb[ATTR_NUM(value)].sa_length = ATTR_LENGTH(value); 9200a586ceaSMark Shellenbaum tb[ATTR_NUM(value)].sa_byteswap = ATTR_BSWAP(value); 9210a586ceaSMark Shellenbaum tb[ATTR_NUM(value)].sa_registered = B_TRUE; 9220a586ceaSMark Shellenbaum 9230a586ceaSMark Shellenbaum if (tb[ATTR_NUM(value)].sa_name) { 9240a586ceaSMark Shellenbaum continue; 9250a586ceaSMark Shellenbaum } 9260a586ceaSMark Shellenbaum tb[ATTR_NUM(value)].sa_name = 9270a586ceaSMark Shellenbaum kmem_zalloc(strlen(za.za_name) +1, KM_SLEEP); 9280a586ceaSMark Shellenbaum (void) strlcpy(tb[ATTR_NUM(value)].sa_name, za.za_name, 9290a586ceaSMark Shellenbaum strlen(za.za_name) +1); 9300a586ceaSMark Shellenbaum } 9310a586ceaSMark Shellenbaum zap_cursor_fini(&zc); 9321d8ccc7bSMark Shellenbaum /* 9331d8ccc7bSMark Shellenbaum * Make sure we processed the correct number of registered 9341d8ccc7bSMark Shellenbaum * attributes 9351d8ccc7bSMark Shellenbaum */ 9361d8ccc7bSMark Shellenbaum if (registered_count != sa_reg_count) { 9371d8ccc7bSMark Shellenbaum ASSERT(error != 0); 9381d8ccc7bSMark Shellenbaum goto bail; 9391d8ccc7bSMark Shellenbaum } 9401d8ccc7bSMark Shellenbaum 9410a586ceaSMark Shellenbaum } 9420a586ceaSMark Shellenbaum 9430a586ceaSMark Shellenbaum if (ostype == DMU_OST_ZFS) { 9440a586ceaSMark Shellenbaum for (i = 0; i != sa_legacy_attr_count; i++) { 9450a586ceaSMark Shellenbaum if (tb[i].sa_name) 9460a586ceaSMark Shellenbaum continue; 9470a586ceaSMark Shellenbaum tb[i].sa_attr = sa_legacy_attrs[i].sa_attr; 9480a586ceaSMark Shellenbaum tb[i].sa_length = sa_legacy_attrs[i].sa_length; 9490a586ceaSMark Shellenbaum tb[i].sa_byteswap = sa_legacy_attrs[i].sa_byteswap; 9500a586ceaSMark Shellenbaum tb[i].sa_registered = B_FALSE; 9510a586ceaSMark Shellenbaum tb[i].sa_name = 9520a586ceaSMark Shellenbaum kmem_zalloc(strlen(sa_legacy_attrs[i].sa_name) +1, 9530a586ceaSMark Shellenbaum KM_SLEEP); 9540a586ceaSMark Shellenbaum (void) strlcpy(tb[i].sa_name, 9550a586ceaSMark Shellenbaum sa_legacy_attrs[i].sa_name, 9560a586ceaSMark Shellenbaum strlen(sa_legacy_attrs[i].sa_name) + 1); 9570a586ceaSMark Shellenbaum } 9580a586ceaSMark Shellenbaum } 9590a586ceaSMark Shellenbaum 9600a586ceaSMark Shellenbaum for (i = 0; i != count; i++) { 9610a586ceaSMark Shellenbaum sa_attr_type_t attr_id; 9620a586ceaSMark Shellenbaum 9630a586ceaSMark Shellenbaum attr_id = sa->sa_user_table[i]; 9640a586ceaSMark Shellenbaum if (tb[attr_id].sa_name) 9650a586ceaSMark Shellenbaum continue; 9660a586ceaSMark Shellenbaum 9670a586ceaSMark Shellenbaum tb[attr_id].sa_length = reg_attrs[i].sa_length; 9680a586ceaSMark Shellenbaum tb[attr_id].sa_byteswap = reg_attrs[i].sa_byteswap; 9690a586ceaSMark Shellenbaum tb[attr_id].sa_attr = attr_id; 9700a586ceaSMark Shellenbaum tb[attr_id].sa_name = 9710a586ceaSMark Shellenbaum kmem_zalloc(strlen(reg_attrs[i].sa_name) + 1, KM_SLEEP); 9720a586ceaSMark Shellenbaum (void) strlcpy(tb[attr_id].sa_name, reg_attrs[i].sa_name, 9730a586ceaSMark Shellenbaum strlen(reg_attrs[i].sa_name) + 1); 9740a586ceaSMark Shellenbaum } 9750a586ceaSMark Shellenbaum 9761d8ccc7bSMark Shellenbaum sa->sa_need_attr_registration = 9770a586ceaSMark Shellenbaum (sa_attr_count != registered_count); 9781d8ccc7bSMark Shellenbaum 9791d8ccc7bSMark Shellenbaum return (0); 9801d8ccc7bSMark Shellenbaum bail: 9811d8ccc7bSMark Shellenbaum kmem_free(sa->sa_user_table, count * sizeof (sa_attr_type_t)); 9821d8ccc7bSMark Shellenbaum sa->sa_user_table = NULL; 9831d8ccc7bSMark Shellenbaum sa_free_attr_table(sa); 9841d8ccc7bSMark Shellenbaum return ((error != 0) ? error : EINVAL); 9850a586ceaSMark Shellenbaum } 9860a586ceaSMark Shellenbaum 9871d8ccc7bSMark Shellenbaum int 9881d8ccc7bSMark Shellenbaum sa_setup(objset_t *os, uint64_t sa_obj, sa_attr_reg_t *reg_attrs, int count, 9891d8ccc7bSMark Shellenbaum sa_attr_type_t **user_table) 9900a586ceaSMark Shellenbaum { 9910a586ceaSMark Shellenbaum zap_cursor_t zc; 9920a586ceaSMark Shellenbaum zap_attribute_t za; 9930a586ceaSMark Shellenbaum sa_os_t *sa; 9940a586ceaSMark Shellenbaum dmu_objset_type_t ostype = dmu_objset_type(os); 9950a586ceaSMark Shellenbaum sa_attr_type_t *tb; 9961d8ccc7bSMark Shellenbaum int error; 9970a586ceaSMark Shellenbaum 9983b2aab18SMatthew Ahrens mutex_enter(&os->os_user_ptr_lock); 9990a586ceaSMark Shellenbaum if (os->os_sa) { 10000a586ceaSMark Shellenbaum mutex_enter(&os->os_sa->sa_lock); 10013b2aab18SMatthew Ahrens mutex_exit(&os->os_user_ptr_lock); 10020a586ceaSMark Shellenbaum tb = os->os_sa->sa_user_table; 10030a586ceaSMark Shellenbaum mutex_exit(&os->os_sa->sa_lock); 10041d8ccc7bSMark Shellenbaum *user_table = tb; 10051d8ccc7bSMark Shellenbaum return (0); 10060a586ceaSMark Shellenbaum } 10070a586ceaSMark Shellenbaum 10080a586ceaSMark Shellenbaum sa = kmem_zalloc(sizeof (sa_os_t), KM_SLEEP); 10090a586ceaSMark Shellenbaum mutex_init(&sa->sa_lock, NULL, MUTEX_DEFAULT, NULL); 10100a586ceaSMark Shellenbaum sa->sa_master_obj = sa_obj; 10110a586ceaSMark Shellenbaum 10121d8ccc7bSMark Shellenbaum os->os_sa = sa; 10130a586ceaSMark Shellenbaum mutex_enter(&sa->sa_lock); 10143b2aab18SMatthew Ahrens mutex_exit(&os->os_user_ptr_lock); 10150a586ceaSMark Shellenbaum avl_create(&sa->sa_layout_num_tree, layout_num_compare, 10160a586ceaSMark Shellenbaum sizeof (sa_lot_t), offsetof(sa_lot_t, lot_num_node)); 10170a586ceaSMark Shellenbaum avl_create(&sa->sa_layout_hash_tree, layout_hash_compare, 10180a586ceaSMark Shellenbaum sizeof (sa_lot_t), offsetof(sa_lot_t, lot_hash_node)); 10190a586ceaSMark Shellenbaum 10200a586ceaSMark Shellenbaum if (sa_obj) { 10210a586ceaSMark Shellenbaum error = zap_lookup(os, sa_obj, SA_LAYOUTS, 10220a586ceaSMark Shellenbaum 8, 1, &sa->sa_layout_attr_obj); 10231d8ccc7bSMark Shellenbaum if (error != 0 && error != ENOENT) 10241d8ccc7bSMark Shellenbaum goto fail; 10250a586ceaSMark Shellenbaum error = zap_lookup(os, sa_obj, SA_REGISTRY, 10260a586ceaSMark Shellenbaum 8, 1, &sa->sa_reg_attr_obj); 10271d8ccc7bSMark Shellenbaum if (error != 0 && error != ENOENT) 10281d8ccc7bSMark Shellenbaum goto fail; 10290a586ceaSMark Shellenbaum } 10300a586ceaSMark Shellenbaum 10311d8ccc7bSMark Shellenbaum if ((error = sa_attr_table_setup(os, reg_attrs, count)) != 0) 10321d8ccc7bSMark Shellenbaum goto fail; 10330a586ceaSMark Shellenbaum 10340a586ceaSMark Shellenbaum if (sa->sa_layout_attr_obj != 0) { 10351d8ccc7bSMark Shellenbaum uint64_t layout_count; 10361d8ccc7bSMark Shellenbaum 10371d8ccc7bSMark Shellenbaum error = zap_count(os, sa->sa_layout_attr_obj, 10381d8ccc7bSMark Shellenbaum &layout_count); 10391d8ccc7bSMark Shellenbaum 10401d8ccc7bSMark Shellenbaum /* 10411d8ccc7bSMark Shellenbaum * Layout number count should be > 0 10421d8ccc7bSMark Shellenbaum */ 10431d8ccc7bSMark Shellenbaum if (error || (error == 0 && layout_count == 0)) { 10441d8ccc7bSMark Shellenbaum if (error == 0) 1045be6fd75aSMatthew Ahrens error = SET_ERROR(EINVAL); 10461d8ccc7bSMark Shellenbaum goto fail; 10471d8ccc7bSMark Shellenbaum } 10481d8ccc7bSMark Shellenbaum 10490a586ceaSMark Shellenbaum for (zap_cursor_init(&zc, os, sa->sa_layout_attr_obj); 10501d8ccc7bSMark Shellenbaum (error = zap_cursor_retrieve(&zc, &za)) == 0; 10510a586ceaSMark Shellenbaum zap_cursor_advance(&zc)) { 10520a586ceaSMark Shellenbaum sa_attr_type_t *lot_attrs; 10530a586ceaSMark Shellenbaum uint64_t lot_num; 10540a586ceaSMark Shellenbaum 10550a586ceaSMark Shellenbaum lot_attrs = kmem_zalloc(sizeof (sa_attr_type_t) * 10560a586ceaSMark Shellenbaum za.za_num_integers, KM_SLEEP); 10570a586ceaSMark Shellenbaum 10581d8ccc7bSMark Shellenbaum if ((error = (zap_lookup(os, sa->sa_layout_attr_obj, 10591d8ccc7bSMark Shellenbaum za.za_name, 2, za.za_num_integers, 10601d8ccc7bSMark Shellenbaum lot_attrs))) != 0) { 10611d8ccc7bSMark Shellenbaum kmem_free(lot_attrs, sizeof (sa_attr_type_t) * 10621d8ccc7bSMark Shellenbaum za.za_num_integers); 10631d8ccc7bSMark Shellenbaum break; 10641d8ccc7bSMark Shellenbaum } 10650a586ceaSMark Shellenbaum VERIFY(ddi_strtoull(za.za_name, NULL, 10, 10660a586ceaSMark Shellenbaum (unsigned long long *)&lot_num) == 0); 10670a586ceaSMark Shellenbaum 10680a586ceaSMark Shellenbaum (void) sa_add_layout_entry(os, lot_attrs, 10690a586ceaSMark Shellenbaum za.za_num_integers, lot_num, 10700a586ceaSMark Shellenbaum sa_layout_info_hash(lot_attrs, 10710a586ceaSMark Shellenbaum za.za_num_integers), B_FALSE, NULL); 10720a586ceaSMark Shellenbaum kmem_free(lot_attrs, sizeof (sa_attr_type_t) * 10730a586ceaSMark Shellenbaum za.za_num_integers); 10740a586ceaSMark Shellenbaum } 10750a586ceaSMark Shellenbaum zap_cursor_fini(&zc); 10761d8ccc7bSMark Shellenbaum 10771d8ccc7bSMark Shellenbaum /* 10781d8ccc7bSMark Shellenbaum * Make sure layout count matches number of entries added 10791d8ccc7bSMark Shellenbaum * to AVL tree 10801d8ccc7bSMark Shellenbaum */ 10811d8ccc7bSMark Shellenbaum if (avl_numnodes(&sa->sa_layout_num_tree) != layout_count) { 10821d8ccc7bSMark Shellenbaum ASSERT(error != 0); 10831d8ccc7bSMark Shellenbaum goto fail; 10841d8ccc7bSMark Shellenbaum } 10850a586ceaSMark Shellenbaum } 10860a586ceaSMark Shellenbaum 10870a586ceaSMark Shellenbaum /* Add special layout number for old ZNODES */ 10880a586ceaSMark Shellenbaum if (ostype == DMU_OST_ZFS) { 10890a586ceaSMark Shellenbaum (void) sa_add_layout_entry(os, sa_legacy_zpl_layout, 10900a586ceaSMark Shellenbaum sa_legacy_attr_count, 0, 10910a586ceaSMark Shellenbaum sa_layout_info_hash(sa_legacy_zpl_layout, 10920a586ceaSMark Shellenbaum sa_legacy_attr_count), B_FALSE, NULL); 10930a586ceaSMark Shellenbaum 10940a586ceaSMark Shellenbaum (void) sa_add_layout_entry(os, sa_dummy_zpl_layout, 0, 1, 10950a586ceaSMark Shellenbaum 0, B_FALSE, NULL); 10960a586ceaSMark Shellenbaum } 10971d8ccc7bSMark Shellenbaum *user_table = os->os_sa->sa_user_table; 10980a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 10991d8ccc7bSMark Shellenbaum return (0); 11001d8ccc7bSMark Shellenbaum fail: 11011d8ccc7bSMark Shellenbaum os->os_sa = NULL; 11021d8ccc7bSMark Shellenbaum sa_free_attr_table(sa); 11031d8ccc7bSMark Shellenbaum if (sa->sa_user_table) 11041d8ccc7bSMark Shellenbaum kmem_free(sa->sa_user_table, sa->sa_user_table_sz); 11051d8ccc7bSMark Shellenbaum mutex_exit(&sa->sa_lock); 1106d2b3cbbdSJorgen Lundman avl_destroy(&sa->sa_layout_hash_tree); 1107d2b3cbbdSJorgen Lundman avl_destroy(&sa->sa_layout_num_tree); 1108d2b3cbbdSJorgen Lundman mutex_destroy(&sa->sa_lock); 11091d8ccc7bSMark Shellenbaum kmem_free(sa, sizeof (sa_os_t)); 11101d8ccc7bSMark Shellenbaum return ((error == ECKSUM) ? EIO : error); 11110a586ceaSMark Shellenbaum } 11120a586ceaSMark Shellenbaum 11130a586ceaSMark Shellenbaum void 11140a586ceaSMark Shellenbaum sa_tear_down(objset_t *os) 11150a586ceaSMark Shellenbaum { 11160a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 11170a586ceaSMark Shellenbaum sa_lot_t *layout; 11180a586ceaSMark Shellenbaum void *cookie; 11190a586ceaSMark Shellenbaum 11200a586ceaSMark Shellenbaum kmem_free(sa->sa_user_table, sa->sa_user_table_sz); 11210a586ceaSMark Shellenbaum 11220a586ceaSMark Shellenbaum /* Free up attr table */ 11230a586ceaSMark Shellenbaum 11241d8ccc7bSMark Shellenbaum sa_free_attr_table(sa); 11250a586ceaSMark Shellenbaum 11260a586ceaSMark Shellenbaum cookie = NULL; 11270a586ceaSMark Shellenbaum while (layout = avl_destroy_nodes(&sa->sa_layout_hash_tree, &cookie)) { 11280a586ceaSMark Shellenbaum sa_idx_tab_t *tab; 11290a586ceaSMark Shellenbaum while (tab = list_head(&layout->lot_idx_tab)) { 1130e914ace2STim Schumacher ASSERT(zfs_refcount_count(&tab->sa_refcount)); 11310a586ceaSMark Shellenbaum sa_idx_tab_rele(os, tab); 11320a586ceaSMark Shellenbaum } 11330a586ceaSMark Shellenbaum } 11340a586ceaSMark Shellenbaum 11350a586ceaSMark Shellenbaum cookie = NULL; 11360a586ceaSMark Shellenbaum while (layout = avl_destroy_nodes(&sa->sa_layout_num_tree, &cookie)) { 11370a586ceaSMark Shellenbaum kmem_free(layout->lot_attrs, 11380a586ceaSMark Shellenbaum sizeof (sa_attr_type_t) * layout->lot_attr_count); 11390a586ceaSMark Shellenbaum kmem_free(layout, sizeof (sa_lot_t)); 11400a586ceaSMark Shellenbaum } 11410a586ceaSMark Shellenbaum 11420a586ceaSMark Shellenbaum avl_destroy(&sa->sa_layout_hash_tree); 11430a586ceaSMark Shellenbaum avl_destroy(&sa->sa_layout_num_tree); 1144d2b3cbbdSJorgen Lundman mutex_destroy(&sa->sa_lock); 11450a586ceaSMark Shellenbaum 11460a586ceaSMark Shellenbaum kmem_free(sa, sizeof (sa_os_t)); 11470a586ceaSMark Shellenbaum os->os_sa = NULL; 11480a586ceaSMark Shellenbaum } 11490a586ceaSMark Shellenbaum 11500a586ceaSMark Shellenbaum void 11510a586ceaSMark Shellenbaum sa_build_idx_tab(void *hdr, void *attr_addr, sa_attr_type_t attr, 11520a586ceaSMark Shellenbaum uint16_t length, int length_idx, boolean_t var_length, void *userp) 11530a586ceaSMark Shellenbaum { 11540a586ceaSMark Shellenbaum sa_idx_tab_t *idx_tab = userp; 11550a586ceaSMark Shellenbaum 11560a586ceaSMark Shellenbaum if (var_length) { 11570a586ceaSMark Shellenbaum ASSERT(idx_tab->sa_variable_lengths); 11580a586ceaSMark Shellenbaum idx_tab->sa_variable_lengths[length_idx] = length; 11590a586ceaSMark Shellenbaum } 11600a586ceaSMark Shellenbaum TOC_ATTR_ENCODE(idx_tab->sa_idx_tab[attr], length_idx, 11610a586ceaSMark Shellenbaum (uint32_t)((uintptr_t)attr_addr - (uintptr_t)hdr)); 11620a586ceaSMark Shellenbaum } 11630a586ceaSMark Shellenbaum 11640a586ceaSMark Shellenbaum static void 11650a586ceaSMark Shellenbaum sa_attr_iter(objset_t *os, sa_hdr_phys_t *hdr, dmu_object_type_t type, 11660a586ceaSMark Shellenbaum sa_iterfunc_t func, sa_lot_t *tab, void *userp) 11670a586ceaSMark Shellenbaum { 11680a586ceaSMark Shellenbaum void *data_start; 11690a586ceaSMark Shellenbaum sa_lot_t *tb = tab; 11700a586ceaSMark Shellenbaum sa_lot_t search; 11710a586ceaSMark Shellenbaum avl_index_t loc; 11720a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 11730a586ceaSMark Shellenbaum int i; 117406e0070dSMark Shellenbaum uint16_t *length_start = NULL; 11750a586ceaSMark Shellenbaum uint8_t length_idx = 0; 11760a586ceaSMark Shellenbaum 11770a586ceaSMark Shellenbaum if (tab == NULL) { 11780a586ceaSMark Shellenbaum search.lot_num = SA_LAYOUT_NUM(hdr, type); 11790a586ceaSMark Shellenbaum tb = avl_find(&sa->sa_layout_num_tree, &search, &loc); 11800a586ceaSMark Shellenbaum ASSERT(tb); 11810a586ceaSMark Shellenbaum } 11820a586ceaSMark Shellenbaum 11830a586ceaSMark Shellenbaum if (IS_SA_BONUSTYPE(type)) { 11840a586ceaSMark Shellenbaum data_start = (void *)P2ROUNDUP(((uintptr_t)hdr + 11850a586ceaSMark Shellenbaum offsetof(sa_hdr_phys_t, sa_lengths) + 11860a586ceaSMark Shellenbaum (sizeof (uint16_t) * tb->lot_var_sizes)), 8); 11870a586ceaSMark Shellenbaum length_start = hdr->sa_lengths; 11880a586ceaSMark Shellenbaum } else { 11890a586ceaSMark Shellenbaum data_start = hdr; 11900a586ceaSMark Shellenbaum } 11910a586ceaSMark Shellenbaum 11920a586ceaSMark Shellenbaum for (i = 0; i != tb->lot_attr_count; i++) { 11930a586ceaSMark Shellenbaum int attr_length, reg_length; 11940a586ceaSMark Shellenbaum uint8_t idx_len; 11950a586ceaSMark Shellenbaum 11960a586ceaSMark Shellenbaum reg_length = sa->sa_attr_table[tb->lot_attrs[i]].sa_length; 11970a586ceaSMark Shellenbaum if (reg_length) { 11980a586ceaSMark Shellenbaum attr_length = reg_length; 11990a586ceaSMark Shellenbaum idx_len = 0; 12000a586ceaSMark Shellenbaum } else { 12010a586ceaSMark Shellenbaum attr_length = length_start[length_idx]; 12020a586ceaSMark Shellenbaum idx_len = length_idx++; 12030a586ceaSMark Shellenbaum } 12040a586ceaSMark Shellenbaum 12050a586ceaSMark Shellenbaum func(hdr, data_start, tb->lot_attrs[i], attr_length, 12060a586ceaSMark Shellenbaum idx_len, reg_length == 0 ? B_TRUE : B_FALSE, userp); 12070a586ceaSMark Shellenbaum 12080a586ceaSMark Shellenbaum data_start = (void *)P2ROUNDUP(((uintptr_t)data_start + 12090a586ceaSMark Shellenbaum attr_length), 8); 12100a586ceaSMark Shellenbaum } 12110a586ceaSMark Shellenbaum } 12120a586ceaSMark Shellenbaum 12130a586ceaSMark Shellenbaum /*ARGSUSED*/ 12140a586ceaSMark Shellenbaum void 12150a586ceaSMark Shellenbaum sa_byteswap_cb(void *hdr, void *attr_addr, sa_attr_type_t attr, 12160a586ceaSMark Shellenbaum uint16_t length, int length_idx, boolean_t variable_length, void *userp) 12170a586ceaSMark Shellenbaum { 12180a586ceaSMark Shellenbaum sa_handle_t *hdl = userp; 12190a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 12200a586ceaSMark Shellenbaum 12210a586ceaSMark Shellenbaum sa_bswap_table[sa->sa_attr_table[attr].sa_byteswap](attr_addr, length); 12220a586ceaSMark Shellenbaum } 12230a586ceaSMark Shellenbaum 12240a586ceaSMark Shellenbaum void 12250a586ceaSMark Shellenbaum sa_byteswap(sa_handle_t *hdl, sa_buf_type_t buftype) 12260a586ceaSMark Shellenbaum { 12270a586ceaSMark Shellenbaum sa_hdr_phys_t *sa_hdr_phys = SA_GET_HDR(hdl, buftype); 12280a586ceaSMark Shellenbaum dmu_buf_impl_t *db; 12290a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 12300a586ceaSMark Shellenbaum int num_lengths = 1; 12310a586ceaSMark Shellenbaum int i; 12320a586ceaSMark Shellenbaum 12330a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&sa->sa_lock)); 12340a586ceaSMark Shellenbaum if (sa_hdr_phys->sa_magic == SA_MAGIC) 12350a586ceaSMark Shellenbaum return; 12360a586ceaSMark Shellenbaum 12370a586ceaSMark Shellenbaum db = SA_GET_DB(hdl, buftype); 12380a586ceaSMark Shellenbaum 12390a586ceaSMark Shellenbaum if (buftype == SA_SPILL) { 12400a586ceaSMark Shellenbaum arc_release(db->db_buf, NULL); 12410a586ceaSMark Shellenbaum arc_buf_thaw(db->db_buf); 12420a586ceaSMark Shellenbaum } 12430a586ceaSMark Shellenbaum 12440a586ceaSMark Shellenbaum sa_hdr_phys->sa_magic = BSWAP_32(sa_hdr_phys->sa_magic); 12450a586ceaSMark Shellenbaum sa_hdr_phys->sa_layout_info = BSWAP_16(sa_hdr_phys->sa_layout_info); 12460a586ceaSMark Shellenbaum 12470a586ceaSMark Shellenbaum /* 12480a586ceaSMark Shellenbaum * Determine number of variable lenghts in header 12490a586ceaSMark Shellenbaum * The standard 8 byte header has one for free and a 12500a586ceaSMark Shellenbaum * 16 byte header would have 4 + 1; 12510a586ceaSMark Shellenbaum */ 12520a586ceaSMark Shellenbaum if (SA_HDR_SIZE(sa_hdr_phys) > 8) 12530a586ceaSMark Shellenbaum num_lengths += (SA_HDR_SIZE(sa_hdr_phys) - 8) >> 1; 12540a586ceaSMark Shellenbaum for (i = 0; i != num_lengths; i++) 12550a586ceaSMark Shellenbaum sa_hdr_phys->sa_lengths[i] = 12560a586ceaSMark Shellenbaum BSWAP_16(sa_hdr_phys->sa_lengths[i]); 12570a586ceaSMark Shellenbaum 12580a586ceaSMark Shellenbaum sa_attr_iter(hdl->sa_os, sa_hdr_phys, DMU_OT_SA, 12590a586ceaSMark Shellenbaum sa_byteswap_cb, NULL, hdl); 12600a586ceaSMark Shellenbaum 12610a586ceaSMark Shellenbaum if (buftype == SA_SPILL) 12620a586ceaSMark Shellenbaum arc_buf_freeze(((dmu_buf_impl_t *)hdl->sa_spill)->db_buf); 12630a586ceaSMark Shellenbaum } 12640a586ceaSMark Shellenbaum 12650a586ceaSMark Shellenbaum static int 12660a586ceaSMark Shellenbaum sa_build_index(sa_handle_t *hdl, sa_buf_type_t buftype) 12670a586ceaSMark Shellenbaum { 12680a586ceaSMark Shellenbaum sa_hdr_phys_t *sa_hdr_phys; 12690a586ceaSMark Shellenbaum dmu_buf_impl_t *db = SA_GET_DB(hdl, buftype); 12700a586ceaSMark Shellenbaum dmu_object_type_t bonustype = SA_BONUSTYPE_FROM_DB(db); 12710a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 12720a586ceaSMark Shellenbaum sa_idx_tab_t *idx_tab; 12730a586ceaSMark Shellenbaum 12740a586ceaSMark Shellenbaum sa_hdr_phys = SA_GET_HDR(hdl, buftype); 12750a586ceaSMark Shellenbaum 12760a586ceaSMark Shellenbaum mutex_enter(&sa->sa_lock); 12770a586ceaSMark Shellenbaum 12780a586ceaSMark Shellenbaum /* Do we need to byteswap? */ 12790a586ceaSMark Shellenbaum 12800a586ceaSMark Shellenbaum /* only check if not old znode */ 12810a586ceaSMark Shellenbaum if (IS_SA_BONUSTYPE(bonustype) && sa_hdr_phys->sa_magic != SA_MAGIC && 12820a586ceaSMark Shellenbaum sa_hdr_phys->sa_magic != 0) { 12830a586ceaSMark Shellenbaum VERIFY(BSWAP_32(sa_hdr_phys->sa_magic) == SA_MAGIC); 12840a586ceaSMark Shellenbaum sa_byteswap(hdl, buftype); 12850a586ceaSMark Shellenbaum } 12860a586ceaSMark Shellenbaum 12870a586ceaSMark Shellenbaum idx_tab = sa_find_idx_tab(hdl->sa_os, bonustype, sa_hdr_phys); 12880a586ceaSMark Shellenbaum 12890a586ceaSMark Shellenbaum if (buftype == SA_BONUS) 12900a586ceaSMark Shellenbaum hdl->sa_bonus_tab = idx_tab; 12910a586ceaSMark Shellenbaum else 12920a586ceaSMark Shellenbaum hdl->sa_spill_tab = idx_tab; 12930a586ceaSMark Shellenbaum 12940a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 12950a586ceaSMark Shellenbaum return (0); 12960a586ceaSMark Shellenbaum } 12970a586ceaSMark Shellenbaum 12980a586ceaSMark Shellenbaum /*ARGSUSED*/ 1299bc9014e6SJustin Gibbs static void 130040510e8eSJosef 'Jeff' Sipek sa_evict_sync(void *dbu) 13010a586ceaSMark Shellenbaum { 1302bc9014e6SJustin Gibbs panic("evicting sa dbuf\n"); 13030a586ceaSMark Shellenbaum } 13040a586ceaSMark Shellenbaum 13050a586ceaSMark Shellenbaum static void 13060a586ceaSMark Shellenbaum sa_idx_tab_rele(objset_t *os, void *arg) 13070a586ceaSMark Shellenbaum { 13080a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 13090a586ceaSMark Shellenbaum sa_idx_tab_t *idx_tab = arg; 13100a586ceaSMark Shellenbaum 13110a586ceaSMark Shellenbaum if (idx_tab == NULL) 13120a586ceaSMark Shellenbaum return; 13130a586ceaSMark Shellenbaum 13140a586ceaSMark Shellenbaum mutex_enter(&sa->sa_lock); 1315e914ace2STim Schumacher if (zfs_refcount_remove(&idx_tab->sa_refcount, NULL) == 0) { 13160a586ceaSMark Shellenbaum list_remove(&idx_tab->sa_layout->lot_idx_tab, idx_tab); 13170a586ceaSMark Shellenbaum if (idx_tab->sa_variable_lengths) 13180a586ceaSMark Shellenbaum kmem_free(idx_tab->sa_variable_lengths, 13190a586ceaSMark Shellenbaum sizeof (uint16_t) * 13200a586ceaSMark Shellenbaum idx_tab->sa_layout->lot_var_sizes); 1321e914ace2STim Schumacher zfs_refcount_destroy(&idx_tab->sa_refcount); 13220a586ceaSMark Shellenbaum kmem_free(idx_tab->sa_idx_tab, 13230a586ceaSMark Shellenbaum sizeof (uint32_t) * sa->sa_num_attrs); 13240a586ceaSMark Shellenbaum kmem_free(idx_tab, sizeof (sa_idx_tab_t)); 13250a586ceaSMark Shellenbaum } 13260a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 13270a586ceaSMark Shellenbaum } 13280a586ceaSMark Shellenbaum 13290a586ceaSMark Shellenbaum static void 13300a586ceaSMark Shellenbaum sa_idx_tab_hold(objset_t *os, sa_idx_tab_t *idx_tab) 13310a586ceaSMark Shellenbaum { 13320a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 13330a586ceaSMark Shellenbaum 13340a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&sa->sa_lock)); 1335e914ace2STim Schumacher (void) zfs_refcount_add(&idx_tab->sa_refcount, NULL); 13360a586ceaSMark Shellenbaum } 13370a586ceaSMark Shellenbaum 13380a586ceaSMark Shellenbaum void 13390a586ceaSMark Shellenbaum sa_handle_destroy(sa_handle_t *hdl) 13400a586ceaSMark Shellenbaum { 1341bc9014e6SJustin Gibbs dmu_buf_t *db = hdl->sa_bonus; 1342bc9014e6SJustin Gibbs 13430a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 1344bc9014e6SJustin Gibbs (void) dmu_buf_remove_user(db, &hdl->sa_dbu); 13450a586ceaSMark Shellenbaum 13460fda3cc5SJustin T. Gibbs if (hdl->sa_bonus_tab) 13470a586ceaSMark Shellenbaum sa_idx_tab_rele(hdl->sa_os, hdl->sa_bonus_tab); 13480fda3cc5SJustin T. Gibbs 13490fda3cc5SJustin T. Gibbs if (hdl->sa_spill_tab) 13500a586ceaSMark Shellenbaum sa_idx_tab_rele(hdl->sa_os, hdl->sa_spill_tab); 13510a586ceaSMark Shellenbaum 13520a586ceaSMark Shellenbaum dmu_buf_rele(hdl->sa_bonus, NULL); 13530a586ceaSMark Shellenbaum 13540a586ceaSMark Shellenbaum if (hdl->sa_spill) 13550a586ceaSMark Shellenbaum dmu_buf_rele((dmu_buf_t *)hdl->sa_spill, NULL); 13560a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 13570a586ceaSMark Shellenbaum 13580a586ceaSMark Shellenbaum kmem_cache_free(sa_cache, hdl); 13590a586ceaSMark Shellenbaum } 13600a586ceaSMark Shellenbaum 13610a586ceaSMark Shellenbaum int 13620a586ceaSMark Shellenbaum sa_handle_get_from_db(objset_t *os, dmu_buf_t *db, void *userp, 13630a586ceaSMark Shellenbaum sa_handle_type_t hdl_type, sa_handle_t **handlepp) 13640a586ceaSMark Shellenbaum { 13650a586ceaSMark Shellenbaum int error = 0; 13660a586ceaSMark Shellenbaum dmu_object_info_t doi; 1367bc9014e6SJustin Gibbs sa_handle_t *handle = NULL; 13680a586ceaSMark Shellenbaum 13690a586ceaSMark Shellenbaum #ifdef ZFS_DEBUG 13700a586ceaSMark Shellenbaum dmu_object_info_from_db(db, &doi); 13710a586ceaSMark Shellenbaum ASSERT(doi.doi_bonus_type == DMU_OT_SA || 13720a586ceaSMark Shellenbaum doi.doi_bonus_type == DMU_OT_ZNODE); 13730a586ceaSMark Shellenbaum #endif 13740a586ceaSMark Shellenbaum /* find handle, if it exists */ 13750a586ceaSMark Shellenbaum /* if one doesn't exist then create a new one, and initialize it */ 13760a586ceaSMark Shellenbaum 1377bc9014e6SJustin Gibbs if (hdl_type == SA_HDL_SHARED) 1378bc9014e6SJustin Gibbs handle = dmu_buf_get_user(db); 1379bc9014e6SJustin Gibbs 13800a586ceaSMark Shellenbaum if (handle == NULL) { 1381bc9014e6SJustin Gibbs sa_handle_t *winner = NULL; 1382bc9014e6SJustin Gibbs 13830a586ceaSMark Shellenbaum handle = kmem_cache_alloc(sa_cache, KM_SLEEP); 138440510e8eSJosef 'Jeff' Sipek handle->sa_dbu.dbu_evict_func_sync = NULL; 138540510e8eSJosef 'Jeff' Sipek handle->sa_dbu.dbu_evict_func_async = NULL; 13860a586ceaSMark Shellenbaum handle->sa_userp = userp; 13870a586ceaSMark Shellenbaum handle->sa_bonus = db; 13880a586ceaSMark Shellenbaum handle->sa_os = os; 13890a586ceaSMark Shellenbaum handle->sa_spill = NULL; 13900fda3cc5SJustin T. Gibbs handle->sa_bonus_tab = NULL; 13910fda3cc5SJustin T. Gibbs handle->sa_spill_tab = NULL; 13920a586ceaSMark Shellenbaum 13930a586ceaSMark Shellenbaum error = sa_build_index(handle, SA_BONUS); 13940a586ceaSMark Shellenbaum 1395bc9014e6SJustin Gibbs if (hdl_type == SA_HDL_SHARED) { 139640510e8eSJosef 'Jeff' Sipek dmu_buf_init_user(&handle->sa_dbu, sa_evict_sync, NULL, 139740510e8eSJosef 'Jeff' Sipek NULL); 1398bc9014e6SJustin Gibbs winner = dmu_buf_set_user_ie(db, &handle->sa_dbu); 1399bc9014e6SJustin Gibbs } 1400bc9014e6SJustin Gibbs 1401bc9014e6SJustin Gibbs if (winner != NULL) { 14020a586ceaSMark Shellenbaum kmem_cache_free(sa_cache, handle); 1403bc9014e6SJustin Gibbs handle = winner; 14040a586ceaSMark Shellenbaum } 14050a586ceaSMark Shellenbaum } 14060a586ceaSMark Shellenbaum *handlepp = handle; 14070a586ceaSMark Shellenbaum 14080a586ceaSMark Shellenbaum return (error); 14090a586ceaSMark Shellenbaum } 14100a586ceaSMark Shellenbaum 14110a586ceaSMark Shellenbaum int 14120a586ceaSMark Shellenbaum sa_handle_get(objset_t *objset, uint64_t objid, void *userp, 14130a586ceaSMark Shellenbaum sa_handle_type_t hdl_type, sa_handle_t **handlepp) 14140a586ceaSMark Shellenbaum { 14150a586ceaSMark Shellenbaum dmu_buf_t *db; 14160a586ceaSMark Shellenbaum int error; 14170a586ceaSMark Shellenbaum 14180a586ceaSMark Shellenbaum if (error = dmu_bonus_hold(objset, objid, NULL, &db)) 14190a586ceaSMark Shellenbaum return (error); 14200a586ceaSMark Shellenbaum 14210a586ceaSMark Shellenbaum return (sa_handle_get_from_db(objset, db, userp, hdl_type, 14220a586ceaSMark Shellenbaum handlepp)); 14230a586ceaSMark Shellenbaum } 14240a586ceaSMark Shellenbaum 14250a586ceaSMark Shellenbaum int 14260a586ceaSMark Shellenbaum sa_buf_hold(objset_t *objset, uint64_t obj_num, void *tag, dmu_buf_t **db) 14270a586ceaSMark Shellenbaum { 14280a586ceaSMark Shellenbaum return (dmu_bonus_hold(objset, obj_num, tag, db)); 14290a586ceaSMark Shellenbaum } 14300a586ceaSMark Shellenbaum 14310a586ceaSMark Shellenbaum void 14320a586ceaSMark Shellenbaum sa_buf_rele(dmu_buf_t *db, void *tag) 14330a586ceaSMark Shellenbaum { 14340a586ceaSMark Shellenbaum dmu_buf_rele(db, tag); 14350a586ceaSMark Shellenbaum } 14360a586ceaSMark Shellenbaum 14370a586ceaSMark Shellenbaum int 14380a586ceaSMark Shellenbaum sa_lookup_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count) 14390a586ceaSMark Shellenbaum { 14400a586ceaSMark Shellenbaum ASSERT(hdl); 14410a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&hdl->sa_lock)); 14420a586ceaSMark Shellenbaum return (sa_attr_op(hdl, bulk, count, SA_LOOKUP, NULL)); 14430a586ceaSMark Shellenbaum } 14440a586ceaSMark Shellenbaum 1445*f67950b2SNasf-Fan static int 1446*f67950b2SNasf-Fan sa_lookup_locked(sa_handle_t *hdl, sa_attr_type_t attr, void *buf, 1447*f67950b2SNasf-Fan uint32_t buflen) 14480a586ceaSMark Shellenbaum { 14490a586ceaSMark Shellenbaum int error; 14500a586ceaSMark Shellenbaum sa_bulk_attr_t bulk; 14510a586ceaSMark Shellenbaum 14520a586ceaSMark Shellenbaum bulk.sa_attr = attr; 14530a586ceaSMark Shellenbaum bulk.sa_data = buf; 14540a586ceaSMark Shellenbaum bulk.sa_length = buflen; 14550a586ceaSMark Shellenbaum bulk.sa_data_func = NULL; 14560a586ceaSMark Shellenbaum 14570a586ceaSMark Shellenbaum ASSERT(hdl); 14580a586ceaSMark Shellenbaum error = sa_lookup_impl(hdl, &bulk, 1); 1459*f67950b2SNasf-Fan return (error); 1460*f67950b2SNasf-Fan } 1461*f67950b2SNasf-Fan 1462*f67950b2SNasf-Fan int 1463*f67950b2SNasf-Fan sa_lookup(sa_handle_t *hdl, sa_attr_type_t attr, void *buf, uint32_t buflen) 1464*f67950b2SNasf-Fan { 1465*f67950b2SNasf-Fan int error; 1466*f67950b2SNasf-Fan 1467*f67950b2SNasf-Fan mutex_enter(&hdl->sa_lock); 1468*f67950b2SNasf-Fan error = sa_lookup_locked(hdl, attr, buf, buflen); 14690a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 1470*f67950b2SNasf-Fan 14710a586ceaSMark Shellenbaum return (error); 14720a586ceaSMark Shellenbaum } 14730a586ceaSMark Shellenbaum 14740a586ceaSMark Shellenbaum #ifdef _KERNEL 14750a586ceaSMark Shellenbaum int 14760a586ceaSMark Shellenbaum sa_lookup_uio(sa_handle_t *hdl, sa_attr_type_t attr, uio_t *uio) 14770a586ceaSMark Shellenbaum { 14780a586ceaSMark Shellenbaum int error; 14790a586ceaSMark Shellenbaum sa_bulk_attr_t bulk; 14800a586ceaSMark Shellenbaum 14810a586ceaSMark Shellenbaum bulk.sa_data = NULL; 14820a586ceaSMark Shellenbaum bulk.sa_attr = attr; 14830a586ceaSMark Shellenbaum bulk.sa_data_func = NULL; 14840a586ceaSMark Shellenbaum 14850a586ceaSMark Shellenbaum ASSERT(hdl); 14860a586ceaSMark Shellenbaum 14870a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 14881d8ccc7bSMark Shellenbaum if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) == 0) { 14890a586ceaSMark Shellenbaum error = uiomove((void *)bulk.sa_addr, MIN(bulk.sa_size, 14900a586ceaSMark Shellenbaum uio->uio_resid), UIO_READ, uio); 14910a586ceaSMark Shellenbaum } 14920a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 14930a586ceaSMark Shellenbaum return (error); 14940a586ceaSMark Shellenbaum 14950a586ceaSMark Shellenbaum } 1496*f67950b2SNasf-Fan 1497*f67950b2SNasf-Fan /* 1498*f67950b2SNasf-Fan * For the existing object that is upgraded from old system, its ondisk layout 1499*f67950b2SNasf-Fan * has no slot for the project ID attribute. But quota accounting logic needs 1500*f67950b2SNasf-Fan * to access related slots by offset directly. So we need to adjust these old 1501*f67950b2SNasf-Fan * objects' layout to make the project ID to some unified and fixed offset. 1502*f67950b2SNasf-Fan */ 1503*f67950b2SNasf-Fan int 1504*f67950b2SNasf-Fan sa_add_projid(sa_handle_t *hdl, dmu_tx_t *tx, uint64_t projid) 1505*f67950b2SNasf-Fan { 1506*f67950b2SNasf-Fan znode_t *zp = sa_get_userdata(hdl); 1507*f67950b2SNasf-Fan dmu_buf_t *db = sa_get_db(hdl); 1508*f67950b2SNasf-Fan zfsvfs_t *zfsvfs = zp->z_zfsvfs; 1509*f67950b2SNasf-Fan int count = 0, err = 0; 1510*f67950b2SNasf-Fan sa_bulk_attr_t *bulk, *attrs; 1511*f67950b2SNasf-Fan zfs_acl_locator_cb_t locate = { 0 }; 1512*f67950b2SNasf-Fan uint64_t uid, gid, mode, rdev, xattr = 0, parent, gen, links; 1513*f67950b2SNasf-Fan uint64_t crtime[2], mtime[2], ctime[2], atime[2]; 1514*f67950b2SNasf-Fan zfs_acl_phys_t znode_acl = { 0 }; 1515*f67950b2SNasf-Fan char scanstamp[AV_SCANSTAMP_SZ]; 1516*f67950b2SNasf-Fan 1517*f67950b2SNasf-Fan if (zp->z_acl_cached == NULL) { 1518*f67950b2SNasf-Fan zfs_acl_t *aclp; 1519*f67950b2SNasf-Fan 1520*f67950b2SNasf-Fan mutex_enter(&zp->z_acl_lock); 1521*f67950b2SNasf-Fan err = zfs_acl_node_read(zp, B_FALSE, &aclp, B_FALSE); 1522*f67950b2SNasf-Fan mutex_exit(&zp->z_acl_lock); 1523*f67950b2SNasf-Fan if (err != 0 && err != ENOENT) 1524*f67950b2SNasf-Fan return (err); 1525*f67950b2SNasf-Fan } 1526*f67950b2SNasf-Fan 1527*f67950b2SNasf-Fan bulk = kmem_zalloc(sizeof (sa_bulk_attr_t) * ZPL_END, KM_SLEEP); 1528*f67950b2SNasf-Fan attrs = kmem_zalloc(sizeof (sa_bulk_attr_t) * ZPL_END, KM_SLEEP); 1529*f67950b2SNasf-Fan mutex_enter(&hdl->sa_lock); 1530*f67950b2SNasf-Fan mutex_enter(&zp->z_lock); 1531*f67950b2SNasf-Fan 1532*f67950b2SNasf-Fan err = sa_lookup_locked(hdl, SA_ZPL_PROJID(zfsvfs), &projid, 1533*f67950b2SNasf-Fan sizeof (uint64_t)); 1534*f67950b2SNasf-Fan if (unlikely(err == 0)) 1535*f67950b2SNasf-Fan /* Someone has added project ID attr by race. */ 1536*f67950b2SNasf-Fan err = EEXIST; 1537*f67950b2SNasf-Fan if (err != ENOENT) 1538*f67950b2SNasf-Fan goto out; 1539*f67950b2SNasf-Fan 1540*f67950b2SNasf-Fan /* First do a bulk query of the attributes that aren't cached */ 1541*f67950b2SNasf-Fan if (zp->z_is_sa) { 1542*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL, 1543*f67950b2SNasf-Fan &mode, 8); 1544*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GEN(zfsvfs), NULL, 1545*f67950b2SNasf-Fan &gen, 8); 1546*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL, 1547*f67950b2SNasf-Fan &uid, 8); 1548*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs), NULL, 1549*f67950b2SNasf-Fan &gid, 8); 1550*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zfsvfs), NULL, 1551*f67950b2SNasf-Fan &parent, 8); 1552*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zfsvfs), NULL, 1553*f67950b2SNasf-Fan &atime, 16); 1554*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, 1555*f67950b2SNasf-Fan &mtime, 16); 1556*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, 1557*f67950b2SNasf-Fan &ctime, 16); 1558*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CRTIME(zfsvfs), NULL, 1559*f67950b2SNasf-Fan &crtime, 16); 1560*f67950b2SNasf-Fan if (S_ISBLK(zp->z_mode) || S_ISCHR(zp->z_mode)) 1561*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_RDEV(zfsvfs), NULL, 1562*f67950b2SNasf-Fan &rdev, 8); 1563*f67950b2SNasf-Fan } else { 1564*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zfsvfs), NULL, 1565*f67950b2SNasf-Fan &atime, 16); 1566*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, 1567*f67950b2SNasf-Fan &mtime, 16); 1568*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, 1569*f67950b2SNasf-Fan &ctime, 16); 1570*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CRTIME(zfsvfs), NULL, 1571*f67950b2SNasf-Fan &crtime, 16); 1572*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GEN(zfsvfs), NULL, 1573*f67950b2SNasf-Fan &gen, 8); 1574*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL, 1575*f67950b2SNasf-Fan &mode, 8); 1576*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zfsvfs), NULL, 1577*f67950b2SNasf-Fan &parent, 8); 1578*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_XATTR(zfsvfs), NULL, 1579*f67950b2SNasf-Fan &xattr, 8); 1580*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_RDEV(zfsvfs), NULL, 1581*f67950b2SNasf-Fan &rdev, 8); 1582*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL, 1583*f67950b2SNasf-Fan &uid, 8); 1584*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs), NULL, 1585*f67950b2SNasf-Fan &gid, 8); 1586*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ZNODE_ACL(zfsvfs), NULL, 1587*f67950b2SNasf-Fan &znode_acl, 88); 1588*f67950b2SNasf-Fan } 1589*f67950b2SNasf-Fan err = sa_bulk_lookup_locked(hdl, bulk, count); 1590*f67950b2SNasf-Fan if (err != 0) 1591*f67950b2SNasf-Fan goto out; 1592*f67950b2SNasf-Fan 1593*f67950b2SNasf-Fan err = sa_lookup_locked(hdl, SA_ZPL_XATTR(zfsvfs), &xattr, 8); 1594*f67950b2SNasf-Fan if (err != 0 && err != ENOENT) 1595*f67950b2SNasf-Fan goto out; 1596*f67950b2SNasf-Fan 1597*f67950b2SNasf-Fan zp->z_projid = projid; 1598*f67950b2SNasf-Fan zp->z_pflags |= ZFS_PROJID; 1599*f67950b2SNasf-Fan links = zp->z_links; 1600*f67950b2SNasf-Fan count = 0; 1601*f67950b2SNasf-Fan err = 0; 1602*f67950b2SNasf-Fan 1603*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_MODE(zfsvfs), NULL, &mode, 8); 1604*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_SIZE(zfsvfs), NULL, 1605*f67950b2SNasf-Fan &zp->z_size, 8); 1606*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_GEN(zfsvfs), NULL, &gen, 8); 1607*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_UID(zfsvfs), NULL, &uid, 8); 1608*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_GID(zfsvfs), NULL, &gid, 8); 1609*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_PARENT(zfsvfs), NULL, &parent, 8); 1610*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_FLAGS(zfsvfs), NULL, 1611*f67950b2SNasf-Fan &zp->z_pflags, 8); 1612*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_ATIME(zfsvfs), NULL, &atime, 16); 1613*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_MTIME(zfsvfs), NULL, &mtime, 16); 1614*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_CTIME(zfsvfs), NULL, &ctime, 16); 1615*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_CRTIME(zfsvfs), NULL, 1616*f67950b2SNasf-Fan &crtime, 16); 1617*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_LINKS(zfsvfs), NULL, &links, 8); 1618*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_PROJID(zfsvfs), NULL, &projid, 8); 1619*f67950b2SNasf-Fan 1620*f67950b2SNasf-Fan if (S_ISBLK(zp->z_mode) || S_ISCHR(zp->z_mode)) 1621*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_RDEV(zfsvfs), NULL, 1622*f67950b2SNasf-Fan &rdev, 8); 1623*f67950b2SNasf-Fan 1624*f67950b2SNasf-Fan if (zp->z_acl_cached != NULL) { 1625*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_DACL_COUNT(zfsvfs), NULL, 1626*f67950b2SNasf-Fan &zp->z_acl_cached->z_acl_count, 8); 1627*f67950b2SNasf-Fan if (zp->z_acl_cached->z_version < ZFS_ACL_VERSION_FUID) 1628*f67950b2SNasf-Fan zfs_acl_xform(zp, zp->z_acl_cached, CRED()); 1629*f67950b2SNasf-Fan locate.cb_aclp = zp->z_acl_cached; 1630*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_DACL_ACES(zfsvfs), 1631*f67950b2SNasf-Fan zfs_acl_data_locator, &locate, 1632*f67950b2SNasf-Fan zp->z_acl_cached->z_acl_bytes); 1633*f67950b2SNasf-Fan } 1634*f67950b2SNasf-Fan 1635*f67950b2SNasf-Fan if (xattr) 1636*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_XATTR(zfsvfs), NULL, 1637*f67950b2SNasf-Fan &xattr, 8); 1638*f67950b2SNasf-Fan 1639*f67950b2SNasf-Fan if (zp->z_pflags & ZFS_BONUS_SCANSTAMP) { 1640*f67950b2SNasf-Fan bcopy((caddr_t)db->db_data + ZFS_OLD_ZNODE_PHYS_SIZE, 1641*f67950b2SNasf-Fan scanstamp, AV_SCANSTAMP_SZ); 1642*f67950b2SNasf-Fan SA_ADD_BULK_ATTR(attrs, count, SA_ZPL_SCANSTAMP(zfsvfs), NULL, 1643*f67950b2SNasf-Fan scanstamp, AV_SCANSTAMP_SZ); 1644*f67950b2SNasf-Fan zp->z_pflags &= ~ZFS_BONUS_SCANSTAMP; 1645*f67950b2SNasf-Fan } 1646*f67950b2SNasf-Fan 1647*f67950b2SNasf-Fan VERIFY(dmu_set_bonustype(db, DMU_OT_SA, tx) == 0); 1648*f67950b2SNasf-Fan VERIFY(sa_replace_all_by_template_locked(hdl, attrs, count, tx) == 0); 1649*f67950b2SNasf-Fan if (znode_acl.z_acl_extern_obj) { 1650*f67950b2SNasf-Fan VERIFY(0 == dmu_object_free(zfsvfs->z_os, 1651*f67950b2SNasf-Fan znode_acl.z_acl_extern_obj, tx)); 1652*f67950b2SNasf-Fan } 1653*f67950b2SNasf-Fan 1654*f67950b2SNasf-Fan zp->z_is_sa = B_TRUE; 1655*f67950b2SNasf-Fan 1656*f67950b2SNasf-Fan out: 1657*f67950b2SNasf-Fan mutex_exit(&zp->z_lock); 1658*f67950b2SNasf-Fan mutex_exit(&hdl->sa_lock); 1659*f67950b2SNasf-Fan kmem_free(attrs, sizeof (sa_bulk_attr_t) * ZPL_END); 1660*f67950b2SNasf-Fan kmem_free(bulk, sizeof (sa_bulk_attr_t) * ZPL_END); 1661*f67950b2SNasf-Fan return (err); 1662*f67950b2SNasf-Fan } 16630a586ceaSMark Shellenbaum #endif 16640a586ceaSMark Shellenbaum 16657f0bdb42SMatthew Ahrens static sa_idx_tab_t * 16667f0bdb42SMatthew Ahrens sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype, sa_hdr_phys_t *hdr) 16670a586ceaSMark Shellenbaum { 16680a586ceaSMark Shellenbaum sa_idx_tab_t *idx_tab; 16690a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 16700a586ceaSMark Shellenbaum sa_lot_t *tb, search; 16710a586ceaSMark Shellenbaum avl_index_t loc; 16720a586ceaSMark Shellenbaum 16730a586ceaSMark Shellenbaum /* 16740a586ceaSMark Shellenbaum * Deterimine layout number. If SA node and header == 0 then 16750a586ceaSMark Shellenbaum * force the index table to the dummy "1" empty layout. 16760a586ceaSMark Shellenbaum * 16770a586ceaSMark Shellenbaum * The layout number would only be zero for a newly created file 16780a586ceaSMark Shellenbaum * that has not added any attributes yet, or with crypto enabled which 16790a586ceaSMark Shellenbaum * doesn't write any attributes to the bonus buffer. 16800a586ceaSMark Shellenbaum */ 16810a586ceaSMark Shellenbaum 16820a586ceaSMark Shellenbaum search.lot_num = SA_LAYOUT_NUM(hdr, bonustype); 16830a586ceaSMark Shellenbaum 16840a586ceaSMark Shellenbaum tb = avl_find(&sa->sa_layout_num_tree, &search, &loc); 16850a586ceaSMark Shellenbaum 16860a586ceaSMark Shellenbaum /* Verify header size is consistent with layout information */ 16870a586ceaSMark Shellenbaum ASSERT(tb); 16880a586ceaSMark Shellenbaum ASSERT(IS_SA_BONUSTYPE(bonustype) && 16890a586ceaSMark Shellenbaum SA_HDR_SIZE_MATCH_LAYOUT(hdr, tb) || !IS_SA_BONUSTYPE(bonustype) || 16900a586ceaSMark Shellenbaum (IS_SA_BONUSTYPE(bonustype) && hdr->sa_layout_info == 0)); 16910a586ceaSMark Shellenbaum 16920a586ceaSMark Shellenbaum /* 16930a586ceaSMark Shellenbaum * See if any of the already existing TOC entries can be reused? 16940a586ceaSMark Shellenbaum */ 16950a586ceaSMark Shellenbaum 16960a586ceaSMark Shellenbaum for (idx_tab = list_head(&tb->lot_idx_tab); idx_tab; 16970a586ceaSMark Shellenbaum idx_tab = list_next(&tb->lot_idx_tab, idx_tab)) { 16980a586ceaSMark Shellenbaum boolean_t valid_idx = B_TRUE; 16990a586ceaSMark Shellenbaum int i; 17000a586ceaSMark Shellenbaum 17010a586ceaSMark Shellenbaum if (tb->lot_var_sizes != 0 && 17020a586ceaSMark Shellenbaum idx_tab->sa_variable_lengths != NULL) { 17030a586ceaSMark Shellenbaum for (i = 0; i != tb->lot_var_sizes; i++) { 17040a586ceaSMark Shellenbaum if (hdr->sa_lengths[i] != 17050a586ceaSMark Shellenbaum idx_tab->sa_variable_lengths[i]) { 17060a586ceaSMark Shellenbaum valid_idx = B_FALSE; 17070a586ceaSMark Shellenbaum break; 17080a586ceaSMark Shellenbaum } 17090a586ceaSMark Shellenbaum } 17100a586ceaSMark Shellenbaum } 17110a586ceaSMark Shellenbaum if (valid_idx) { 17120a586ceaSMark Shellenbaum sa_idx_tab_hold(os, idx_tab); 17130a586ceaSMark Shellenbaum return (idx_tab); 17140a586ceaSMark Shellenbaum } 17150a586ceaSMark Shellenbaum } 17160a586ceaSMark Shellenbaum 17170a586ceaSMark Shellenbaum /* No such luck, create a new entry */ 17180a586ceaSMark Shellenbaum idx_tab = kmem_zalloc(sizeof (sa_idx_tab_t), KM_SLEEP); 17190a586ceaSMark Shellenbaum idx_tab->sa_idx_tab = 17200a586ceaSMark Shellenbaum kmem_zalloc(sizeof (uint32_t) * sa->sa_num_attrs, KM_SLEEP); 17210a586ceaSMark Shellenbaum idx_tab->sa_layout = tb; 1722e914ace2STim Schumacher zfs_refcount_create(&idx_tab->sa_refcount); 17230a586ceaSMark Shellenbaum if (tb->lot_var_sizes) 17240a586ceaSMark Shellenbaum idx_tab->sa_variable_lengths = kmem_alloc(sizeof (uint16_t) * 17250a586ceaSMark Shellenbaum tb->lot_var_sizes, KM_SLEEP); 17260a586ceaSMark Shellenbaum 17270a586ceaSMark Shellenbaum sa_attr_iter(os, hdr, bonustype, sa_build_idx_tab, 17280a586ceaSMark Shellenbaum tb, idx_tab); 17290a586ceaSMark Shellenbaum sa_idx_tab_hold(os, idx_tab); /* one hold for consumer */ 17300a586ceaSMark Shellenbaum sa_idx_tab_hold(os, idx_tab); /* one for layout */ 17310a586ceaSMark Shellenbaum list_insert_tail(&tb->lot_idx_tab, idx_tab); 17320a586ceaSMark Shellenbaum return (idx_tab); 17330a586ceaSMark Shellenbaum } 17340a586ceaSMark Shellenbaum 17350a586ceaSMark Shellenbaum void 17360a586ceaSMark Shellenbaum sa_default_locator(void **dataptr, uint32_t *len, uint32_t total_len, 17370a586ceaSMark Shellenbaum boolean_t start, void *userdata) 17380a586ceaSMark Shellenbaum { 17390a586ceaSMark Shellenbaum ASSERT(start); 17400a586ceaSMark Shellenbaum 17410a586ceaSMark Shellenbaum *dataptr = userdata; 17420a586ceaSMark Shellenbaum *len = total_len; 17430a586ceaSMark Shellenbaum } 17440a586ceaSMark Shellenbaum 17450a586ceaSMark Shellenbaum static void 17460a586ceaSMark Shellenbaum sa_attr_register_sync(sa_handle_t *hdl, dmu_tx_t *tx) 17470a586ceaSMark Shellenbaum { 17480a586ceaSMark Shellenbaum uint64_t attr_value = 0; 17490a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 17500a586ceaSMark Shellenbaum sa_attr_table_t *tb = sa->sa_attr_table; 17510a586ceaSMark Shellenbaum int i; 17520a586ceaSMark Shellenbaum 17530a586ceaSMark Shellenbaum mutex_enter(&sa->sa_lock); 17540a586ceaSMark Shellenbaum 1755dd328bf6SToomas Soome if (!sa->sa_need_attr_registration || sa->sa_master_obj == 0) { 17560a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 17570a586ceaSMark Shellenbaum return; 17580a586ceaSMark Shellenbaum } 17590a586ceaSMark Shellenbaum 1760dd328bf6SToomas Soome if (sa->sa_reg_attr_obj == 0) { 1761ad135b5dSChristopher Siden sa->sa_reg_attr_obj = zap_create_link(hdl->sa_os, 1762ad135b5dSChristopher Siden DMU_OT_SA_ATTR_REGISTRATION, 1763ad135b5dSChristopher Siden sa->sa_master_obj, SA_REGISTRY, tx); 17640a586ceaSMark Shellenbaum } 17650a586ceaSMark Shellenbaum for (i = 0; i != sa->sa_num_attrs; i++) { 17660a586ceaSMark Shellenbaum if (sa->sa_attr_table[i].sa_registered) 17670a586ceaSMark Shellenbaum continue; 17680a586ceaSMark Shellenbaum ATTR_ENCODE(attr_value, tb[i].sa_attr, tb[i].sa_length, 17690a586ceaSMark Shellenbaum tb[i].sa_byteswap); 17700a586ceaSMark Shellenbaum VERIFY(0 == zap_update(hdl->sa_os, sa->sa_reg_attr_obj, 17710a586ceaSMark Shellenbaum tb[i].sa_name, 8, 1, &attr_value, tx)); 17720a586ceaSMark Shellenbaum tb[i].sa_registered = B_TRUE; 17730a586ceaSMark Shellenbaum } 17740a586ceaSMark Shellenbaum sa->sa_need_attr_registration = B_FALSE; 17750a586ceaSMark Shellenbaum mutex_exit(&sa->sa_lock); 17760a586ceaSMark Shellenbaum } 17770a586ceaSMark Shellenbaum 17780a586ceaSMark Shellenbaum /* 17790a586ceaSMark Shellenbaum * Replace all attributes with attributes specified in template. 17800a586ceaSMark Shellenbaum * If dnode had a spill buffer then those attributes will be 17810a586ceaSMark Shellenbaum * also be replaced, possibly with just an empty spill block 17820a586ceaSMark Shellenbaum * 17830a586ceaSMark Shellenbaum * This interface is intended to only be used for bulk adding of 17840a586ceaSMark Shellenbaum * attributes for a new file. It will also be used by the ZPL 17850a586ceaSMark Shellenbaum * when converting and old formatted znode to native SA support. 17860a586ceaSMark Shellenbaum */ 17870a586ceaSMark Shellenbaum int 17880a586ceaSMark Shellenbaum sa_replace_all_by_template_locked(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, 17890a586ceaSMark Shellenbaum int attr_count, dmu_tx_t *tx) 17900a586ceaSMark Shellenbaum { 17910a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 17920a586ceaSMark Shellenbaum 17930a586ceaSMark Shellenbaum if (sa->sa_need_attr_registration) 17940a586ceaSMark Shellenbaum sa_attr_register_sync(hdl, tx); 17950a586ceaSMark Shellenbaum return (sa_build_layouts(hdl, attr_desc, attr_count, tx)); 17960a586ceaSMark Shellenbaum } 17970a586ceaSMark Shellenbaum 17980a586ceaSMark Shellenbaum int 17990a586ceaSMark Shellenbaum sa_replace_all_by_template(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, 18000a586ceaSMark Shellenbaum int attr_count, dmu_tx_t *tx) 18010a586ceaSMark Shellenbaum { 18020a586ceaSMark Shellenbaum int error; 18030a586ceaSMark Shellenbaum 18040a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 18050a586ceaSMark Shellenbaum error = sa_replace_all_by_template_locked(hdl, attr_desc, 18060a586ceaSMark Shellenbaum attr_count, tx); 18070a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 18080a586ceaSMark Shellenbaum return (error); 18090a586ceaSMark Shellenbaum } 18100a586ceaSMark Shellenbaum 18110a586ceaSMark Shellenbaum /* 1812e7e978b1SAndriy Gapon * Add/remove a single attribute or replace a variable-sized attribute value 1813e7e978b1SAndriy Gapon * with a value of a different size, and then rewrite the entire set 18140a586ceaSMark Shellenbaum * of attributes. 1815e7e978b1SAndriy Gapon * Same-length attribute value replacement (including fixed-length attributes) 1816e7e978b1SAndriy Gapon * is handled more efficiently by the upper layers. 18170a586ceaSMark Shellenbaum */ 18180a586ceaSMark Shellenbaum static int 18190a586ceaSMark Shellenbaum sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr, 18200a586ceaSMark Shellenbaum sa_data_op_t action, sa_data_locator_t *locator, void *datastart, 18210a586ceaSMark Shellenbaum uint16_t buflen, dmu_tx_t *tx) 18220a586ceaSMark Shellenbaum { 18230a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 1824744947dcSTom Erickson dmu_buf_impl_t *db = (dmu_buf_impl_t *)hdl->sa_bonus; 1825744947dcSTom Erickson dnode_t *dn; 18260a586ceaSMark Shellenbaum sa_bulk_attr_t *attr_desc; 18270a586ceaSMark Shellenbaum void *old_data[2]; 18280a586ceaSMark Shellenbaum int bonus_attr_count = 0; 1829d5285caeSGeorge Wilson int bonus_data_size = 0; 1830d5285caeSGeorge Wilson int spill_data_size = 0; 18310a586ceaSMark Shellenbaum int spill_attr_count = 0; 18320a586ceaSMark Shellenbaum int error; 1833e7e978b1SAndriy Gapon uint16_t length, reg_length; 18340a586ceaSMark Shellenbaum int i, j, k, length_idx; 18350a586ceaSMark Shellenbaum sa_hdr_phys_t *hdr; 18360a586ceaSMark Shellenbaum sa_idx_tab_t *idx_tab; 18370a586ceaSMark Shellenbaum int attr_count; 18380a586ceaSMark Shellenbaum int count; 18390a586ceaSMark Shellenbaum 18400a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&hdl->sa_lock)); 18410a586ceaSMark Shellenbaum 18420a586ceaSMark Shellenbaum /* First make of copy of the old data */ 18430a586ceaSMark Shellenbaum 1844744947dcSTom Erickson DB_DNODE_ENTER(db); 1845744947dcSTom Erickson dn = DB_DNODE(db); 1846744947dcSTom Erickson if (dn->dn_bonuslen != 0) { 18470a586ceaSMark Shellenbaum bonus_data_size = hdl->sa_bonus->db_size; 18480a586ceaSMark Shellenbaum old_data[0] = kmem_alloc(bonus_data_size, KM_SLEEP); 18490a586ceaSMark Shellenbaum bcopy(hdl->sa_bonus->db_data, old_data[0], 18500a586ceaSMark Shellenbaum hdl->sa_bonus->db_size); 18510a586ceaSMark Shellenbaum bonus_attr_count = hdl->sa_bonus_tab->sa_layout->lot_attr_count; 18520a586ceaSMark Shellenbaum } else { 18530a586ceaSMark Shellenbaum old_data[0] = NULL; 18540a586ceaSMark Shellenbaum } 1855744947dcSTom Erickson DB_DNODE_EXIT(db); 18560a586ceaSMark Shellenbaum 18570a586ceaSMark Shellenbaum /* Bring spill buffer online if it isn't currently */ 18580a586ceaSMark Shellenbaum 18591d8ccc7bSMark Shellenbaum if ((error = sa_get_spill(hdl)) == 0) { 18600a586ceaSMark Shellenbaum spill_data_size = hdl->sa_spill->db_size; 18610a586ceaSMark Shellenbaum old_data[1] = kmem_alloc(spill_data_size, KM_SLEEP); 18620a586ceaSMark Shellenbaum bcopy(hdl->sa_spill->db_data, old_data[1], 18630a586ceaSMark Shellenbaum hdl->sa_spill->db_size); 18640a586ceaSMark Shellenbaum spill_attr_count = 18650a586ceaSMark Shellenbaum hdl->sa_spill_tab->sa_layout->lot_attr_count; 18661d8ccc7bSMark Shellenbaum } else if (error && error != ENOENT) { 18671d8ccc7bSMark Shellenbaum if (old_data[0]) 18681d8ccc7bSMark Shellenbaum kmem_free(old_data[0], bonus_data_size); 18691d8ccc7bSMark Shellenbaum return (error); 18700a586ceaSMark Shellenbaum } else { 18710a586ceaSMark Shellenbaum old_data[1] = NULL; 18720a586ceaSMark Shellenbaum } 18730a586ceaSMark Shellenbaum 18740a586ceaSMark Shellenbaum /* build descriptor of all attributes */ 18750a586ceaSMark Shellenbaum 18760a586ceaSMark Shellenbaum attr_count = bonus_attr_count + spill_attr_count; 18770a586ceaSMark Shellenbaum if (action == SA_ADD) 18780a586ceaSMark Shellenbaum attr_count++; 18790a586ceaSMark Shellenbaum else if (action == SA_REMOVE) 18800a586ceaSMark Shellenbaum attr_count--; 18810a586ceaSMark Shellenbaum 18820a586ceaSMark Shellenbaum attr_desc = kmem_zalloc(sizeof (sa_bulk_attr_t) * attr_count, KM_SLEEP); 18830a586ceaSMark Shellenbaum 18840a586ceaSMark Shellenbaum /* 18850a586ceaSMark Shellenbaum * loop through bonus and spill buffer if it exists, and 18860a586ceaSMark Shellenbaum * build up new attr_descriptor to reset the attributes 18870a586ceaSMark Shellenbaum */ 18880a586ceaSMark Shellenbaum k = j = 0; 18890a586ceaSMark Shellenbaum count = bonus_attr_count; 18900a586ceaSMark Shellenbaum hdr = SA_GET_HDR(hdl, SA_BONUS); 18910a586ceaSMark Shellenbaum idx_tab = SA_IDX_TAB_GET(hdl, SA_BONUS); 18920a586ceaSMark Shellenbaum for (; k != 2; k++) { 1893e7e978b1SAndriy Gapon /* 1894e7e978b1SAndriy Gapon * Iterate over each attribute in layout. Fetch the 1895e7e978b1SAndriy Gapon * size of variable-length attributes needing rewrite 1896e7e978b1SAndriy Gapon * from sa_lengths[]. 1897e7e978b1SAndriy Gapon */ 18980a586ceaSMark Shellenbaum for (i = 0, length_idx = 0; i != count; i++) { 18990a586ceaSMark Shellenbaum sa_attr_type_t attr; 19000a586ceaSMark Shellenbaum 19010a586ceaSMark Shellenbaum attr = idx_tab->sa_layout->lot_attrs[i]; 1902e7e978b1SAndriy Gapon reg_length = SA_REGISTERED_LEN(sa, attr); 1903e7e978b1SAndriy Gapon if (reg_length == 0) { 1904e7e978b1SAndriy Gapon length = hdr->sa_lengths[length_idx]; 1905e7e978b1SAndriy Gapon length_idx++; 1906e7e978b1SAndriy Gapon } else { 1907e7e978b1SAndriy Gapon length = reg_length; 1908e7e978b1SAndriy Gapon } 19090a586ceaSMark Shellenbaum if (attr == newattr) { 1910e7e978b1SAndriy Gapon /* 1911e7e978b1SAndriy Gapon * There is nothing to do for SA_REMOVE, 1912e7e978b1SAndriy Gapon * so it is just skipped. 1913e7e978b1SAndriy Gapon */ 1914e7e978b1SAndriy Gapon if (action == SA_REMOVE) 19150a586ceaSMark Shellenbaum continue; 1916e7e978b1SAndriy Gapon 1917e7e978b1SAndriy Gapon /* 1918e7e978b1SAndriy Gapon * Duplicate attributes are not allowed, so the 1919e7e978b1SAndriy Gapon * action can not be SA_ADD here. 1920e7e978b1SAndriy Gapon */ 1921e7e978b1SAndriy Gapon ASSERT3S(action, ==, SA_REPLACE); 1922e7e978b1SAndriy Gapon 1923e7e978b1SAndriy Gapon /* 1924e7e978b1SAndriy Gapon * Only a variable-sized attribute can be 1925e7e978b1SAndriy Gapon * replaced here, and its size must be changing. 1926e7e978b1SAndriy Gapon */ 1927e7e978b1SAndriy Gapon ASSERT3U(reg_length, ==, 0); 1928e7e978b1SAndriy Gapon ASSERT3U(length, !=, buflen); 19290a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(attr_desc, j, attr, 19300a586ceaSMark Shellenbaum locator, datastart, buflen); 19310a586ceaSMark Shellenbaum } else { 19320a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(attr_desc, j, attr, 19330a586ceaSMark Shellenbaum NULL, (void *) 19340a586ceaSMark Shellenbaum (TOC_OFF(idx_tab->sa_idx_tab[attr]) + 19350a586ceaSMark Shellenbaum (uintptr_t)old_data[k]), length); 19360a586ceaSMark Shellenbaum } 19370a586ceaSMark Shellenbaum } 19380a586ceaSMark Shellenbaum if (k == 0 && hdl->sa_spill) { 19390a586ceaSMark Shellenbaum hdr = SA_GET_HDR(hdl, SA_SPILL); 19400a586ceaSMark Shellenbaum idx_tab = SA_IDX_TAB_GET(hdl, SA_SPILL); 19410a586ceaSMark Shellenbaum count = spill_attr_count; 19420a586ceaSMark Shellenbaum } else { 19430a586ceaSMark Shellenbaum break; 19440a586ceaSMark Shellenbaum } 19450a586ceaSMark Shellenbaum } 19460a586ceaSMark Shellenbaum if (action == SA_ADD) { 1947e7e978b1SAndriy Gapon reg_length = SA_REGISTERED_LEN(sa, newattr); 1948e7e978b1SAndriy Gapon IMPLY(reg_length != 0, reg_length == buflen); 19490a586ceaSMark Shellenbaum SA_ADD_BULK_ATTR(attr_desc, j, newattr, locator, 19500a586ceaSMark Shellenbaum datastart, buflen); 19510a586ceaSMark Shellenbaum } 1952e7e978b1SAndriy Gapon ASSERT3U(j, ==, attr_count); 19530a586ceaSMark Shellenbaum 19540a586ceaSMark Shellenbaum error = sa_build_layouts(hdl, attr_desc, attr_count, tx); 19550a586ceaSMark Shellenbaum 19560a586ceaSMark Shellenbaum if (old_data[0]) 19570a586ceaSMark Shellenbaum kmem_free(old_data[0], bonus_data_size); 19580a586ceaSMark Shellenbaum if (old_data[1]) 19590a586ceaSMark Shellenbaum kmem_free(old_data[1], spill_data_size); 19600a586ceaSMark Shellenbaum kmem_free(attr_desc, sizeof (sa_bulk_attr_t) * attr_count); 19610a586ceaSMark Shellenbaum 19620a586ceaSMark Shellenbaum return (error); 19630a586ceaSMark Shellenbaum } 19640a586ceaSMark Shellenbaum 19650a586ceaSMark Shellenbaum static int 19660a586ceaSMark Shellenbaum sa_bulk_update_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count, 19670a586ceaSMark Shellenbaum dmu_tx_t *tx) 19680a586ceaSMark Shellenbaum { 19690a586ceaSMark Shellenbaum int error; 19700a586ceaSMark Shellenbaum sa_os_t *sa = hdl->sa_os->os_sa; 19710a586ceaSMark Shellenbaum dmu_object_type_t bonustype; 19720a586ceaSMark Shellenbaum 19730a586ceaSMark Shellenbaum bonustype = SA_BONUSTYPE_FROM_DB(SA_GET_DB(hdl, SA_BONUS)); 19740a586ceaSMark Shellenbaum 19750a586ceaSMark Shellenbaum ASSERT(hdl); 19760a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&hdl->sa_lock)); 19770a586ceaSMark Shellenbaum 19780a586ceaSMark Shellenbaum /* sync out registration table if necessary */ 19790a586ceaSMark Shellenbaum if (sa->sa_need_attr_registration) 19800a586ceaSMark Shellenbaum sa_attr_register_sync(hdl, tx); 19810a586ceaSMark Shellenbaum 19820a586ceaSMark Shellenbaum error = sa_attr_op(hdl, bulk, count, SA_UPDATE, tx); 19830a586ceaSMark Shellenbaum if (error == 0 && !IS_SA_BONUSTYPE(bonustype) && sa->sa_update_cb) 19840a586ceaSMark Shellenbaum sa->sa_update_cb(hdl, tx); 19850a586ceaSMark Shellenbaum 19860a586ceaSMark Shellenbaum return (error); 19870a586ceaSMark Shellenbaum } 19880a586ceaSMark Shellenbaum 19890a586ceaSMark Shellenbaum /* 19900a586ceaSMark Shellenbaum * update or add new attribute 19910a586ceaSMark Shellenbaum */ 19920a586ceaSMark Shellenbaum int 19930a586ceaSMark Shellenbaum sa_update(sa_handle_t *hdl, sa_attr_type_t type, 19940a586ceaSMark Shellenbaum void *buf, uint32_t buflen, dmu_tx_t *tx) 19950a586ceaSMark Shellenbaum { 19960a586ceaSMark Shellenbaum int error; 19970a586ceaSMark Shellenbaum sa_bulk_attr_t bulk; 19980a586ceaSMark Shellenbaum 19990a586ceaSMark Shellenbaum bulk.sa_attr = type; 20000a586ceaSMark Shellenbaum bulk.sa_data_func = NULL; 20010a586ceaSMark Shellenbaum bulk.sa_length = buflen; 20020a586ceaSMark Shellenbaum bulk.sa_data = buf; 20030a586ceaSMark Shellenbaum 20040a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 20050a586ceaSMark Shellenbaum error = sa_bulk_update_impl(hdl, &bulk, 1, tx); 20060a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 20070a586ceaSMark Shellenbaum return (error); 20080a586ceaSMark Shellenbaum } 20090a586ceaSMark Shellenbaum 20100a586ceaSMark Shellenbaum int 20110a586ceaSMark Shellenbaum sa_update_from_cb(sa_handle_t *hdl, sa_attr_type_t attr, 20120a586ceaSMark Shellenbaum uint32_t buflen, sa_data_locator_t *locator, void *userdata, dmu_tx_t *tx) 20130a586ceaSMark Shellenbaum { 20140a586ceaSMark Shellenbaum int error; 20150a586ceaSMark Shellenbaum sa_bulk_attr_t bulk; 20160a586ceaSMark Shellenbaum 20170a586ceaSMark Shellenbaum bulk.sa_attr = attr; 20180a586ceaSMark Shellenbaum bulk.sa_data = userdata; 20190a586ceaSMark Shellenbaum bulk.sa_data_func = locator; 20200a586ceaSMark Shellenbaum bulk.sa_length = buflen; 20210a586ceaSMark Shellenbaum 20220a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 20230a586ceaSMark Shellenbaum error = sa_bulk_update_impl(hdl, &bulk, 1, tx); 20240a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 20250a586ceaSMark Shellenbaum return (error); 20260a586ceaSMark Shellenbaum } 20270a586ceaSMark Shellenbaum 20280a586ceaSMark Shellenbaum /* 20290a586ceaSMark Shellenbaum * Return size of an attribute 20300a586ceaSMark Shellenbaum */ 20310a586ceaSMark Shellenbaum 20320a586ceaSMark Shellenbaum int 20330a586ceaSMark Shellenbaum sa_size(sa_handle_t *hdl, sa_attr_type_t attr, int *size) 20340a586ceaSMark Shellenbaum { 20350a586ceaSMark Shellenbaum sa_bulk_attr_t bulk; 20361d8ccc7bSMark Shellenbaum int error; 20370a586ceaSMark Shellenbaum 20380a586ceaSMark Shellenbaum bulk.sa_data = NULL; 20390a586ceaSMark Shellenbaum bulk.sa_attr = attr; 20400a586ceaSMark Shellenbaum bulk.sa_data_func = NULL; 20410a586ceaSMark Shellenbaum 20420a586ceaSMark Shellenbaum ASSERT(hdl); 20430a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 20441d8ccc7bSMark Shellenbaum if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) != 0) { 20450a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 20461d8ccc7bSMark Shellenbaum return (error); 20470a586ceaSMark Shellenbaum } 20480a586ceaSMark Shellenbaum *size = bulk.sa_size; 20490a586ceaSMark Shellenbaum 20500a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 20510a586ceaSMark Shellenbaum return (0); 20520a586ceaSMark Shellenbaum } 20530a586ceaSMark Shellenbaum 20540a586ceaSMark Shellenbaum int 20550a586ceaSMark Shellenbaum sa_bulk_lookup_locked(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count) 20560a586ceaSMark Shellenbaum { 20570a586ceaSMark Shellenbaum ASSERT(hdl); 20580a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&hdl->sa_lock)); 20590a586ceaSMark Shellenbaum return (sa_lookup_impl(hdl, attrs, count)); 20600a586ceaSMark Shellenbaum } 20610a586ceaSMark Shellenbaum 20620a586ceaSMark Shellenbaum int 20630a586ceaSMark Shellenbaum sa_bulk_lookup(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count) 20640a586ceaSMark Shellenbaum { 20650a586ceaSMark Shellenbaum int error; 20660a586ceaSMark Shellenbaum 20670a586ceaSMark Shellenbaum ASSERT(hdl); 20680a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 20690a586ceaSMark Shellenbaum error = sa_bulk_lookup_locked(hdl, attrs, count); 20700a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 20710a586ceaSMark Shellenbaum return (error); 20720a586ceaSMark Shellenbaum } 20730a586ceaSMark Shellenbaum 20740a586ceaSMark Shellenbaum int 20750a586ceaSMark Shellenbaum sa_bulk_update(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count, dmu_tx_t *tx) 20760a586ceaSMark Shellenbaum { 20770a586ceaSMark Shellenbaum int error; 20780a586ceaSMark Shellenbaum 20790a586ceaSMark Shellenbaum ASSERT(hdl); 20800a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 20810a586ceaSMark Shellenbaum error = sa_bulk_update_impl(hdl, attrs, count, tx); 20820a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 20830a586ceaSMark Shellenbaum return (error); 20840a586ceaSMark Shellenbaum } 20850a586ceaSMark Shellenbaum 20860a586ceaSMark Shellenbaum int 20870a586ceaSMark Shellenbaum sa_remove(sa_handle_t *hdl, sa_attr_type_t attr, dmu_tx_t *tx) 20880a586ceaSMark Shellenbaum { 20890a586ceaSMark Shellenbaum int error; 20900a586ceaSMark Shellenbaum 20910a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 20920a586ceaSMark Shellenbaum error = sa_modify_attrs(hdl, attr, SA_REMOVE, NULL, 20930a586ceaSMark Shellenbaum NULL, 0, tx); 20940a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 20950a586ceaSMark Shellenbaum return (error); 20960a586ceaSMark Shellenbaum } 20970a586ceaSMark Shellenbaum 20980a586ceaSMark Shellenbaum void 20990a586ceaSMark Shellenbaum sa_object_info(sa_handle_t *hdl, dmu_object_info_t *doi) 21000a586ceaSMark Shellenbaum { 21010a586ceaSMark Shellenbaum dmu_object_info_from_db((dmu_buf_t *)hdl->sa_bonus, doi); 21020a586ceaSMark Shellenbaum } 21030a586ceaSMark Shellenbaum 21040a586ceaSMark Shellenbaum void 21050a586ceaSMark Shellenbaum sa_object_size(sa_handle_t *hdl, uint32_t *blksize, u_longlong_t *nblocks) 21060a586ceaSMark Shellenbaum { 21070a586ceaSMark Shellenbaum dmu_object_size_from_db((dmu_buf_t *)hdl->sa_bonus, 21080a586ceaSMark Shellenbaum blksize, nblocks); 21090a586ceaSMark Shellenbaum } 21100a586ceaSMark Shellenbaum 21110a586ceaSMark Shellenbaum void 21120a586ceaSMark Shellenbaum sa_set_userp(sa_handle_t *hdl, void *ptr) 21130a586ceaSMark Shellenbaum { 21140a586ceaSMark Shellenbaum hdl->sa_userp = ptr; 21150a586ceaSMark Shellenbaum } 21160a586ceaSMark Shellenbaum 21170a586ceaSMark Shellenbaum dmu_buf_t * 21180a586ceaSMark Shellenbaum sa_get_db(sa_handle_t *hdl) 21190a586ceaSMark Shellenbaum { 21200a586ceaSMark Shellenbaum return ((dmu_buf_t *)hdl->sa_bonus); 21210a586ceaSMark Shellenbaum } 21220a586ceaSMark Shellenbaum 21230a586ceaSMark Shellenbaum void * 21240a586ceaSMark Shellenbaum sa_get_userdata(sa_handle_t *hdl) 21250a586ceaSMark Shellenbaum { 21260a586ceaSMark Shellenbaum return (hdl->sa_userp); 21270a586ceaSMark Shellenbaum } 21280a586ceaSMark Shellenbaum 21290a586ceaSMark Shellenbaum void 21300a586ceaSMark Shellenbaum sa_register_update_callback_locked(objset_t *os, sa_update_cb_t *func) 21310a586ceaSMark Shellenbaum { 21320a586ceaSMark Shellenbaum ASSERT(MUTEX_HELD(&os->os_sa->sa_lock)); 21330a586ceaSMark Shellenbaum os->os_sa->sa_update_cb = func; 21340a586ceaSMark Shellenbaum } 21350a586ceaSMark Shellenbaum 21360a586ceaSMark Shellenbaum void 21370a586ceaSMark Shellenbaum sa_register_update_callback(objset_t *os, sa_update_cb_t *func) 21380a586ceaSMark Shellenbaum { 21390a586ceaSMark Shellenbaum 21400a586ceaSMark Shellenbaum mutex_enter(&os->os_sa->sa_lock); 21410a586ceaSMark Shellenbaum sa_register_update_callback_locked(os, func); 21420a586ceaSMark Shellenbaum mutex_exit(&os->os_sa->sa_lock); 21430a586ceaSMark Shellenbaum } 21440a586ceaSMark Shellenbaum 21450a586ceaSMark Shellenbaum uint64_t 21460a586ceaSMark Shellenbaum sa_handle_object(sa_handle_t *hdl) 21470a586ceaSMark Shellenbaum { 21480a586ceaSMark Shellenbaum return (hdl->sa_bonus->db_object); 21490a586ceaSMark Shellenbaum } 21500a586ceaSMark Shellenbaum 21510a586ceaSMark Shellenbaum boolean_t 21520a586ceaSMark Shellenbaum sa_enabled(objset_t *os) 21530a586ceaSMark Shellenbaum { 21540a586ceaSMark Shellenbaum return (os->os_sa == NULL); 21550a586ceaSMark Shellenbaum } 21560a586ceaSMark Shellenbaum 21570a586ceaSMark Shellenbaum int 21580a586ceaSMark Shellenbaum sa_set_sa_object(objset_t *os, uint64_t sa_object) 21590a586ceaSMark Shellenbaum { 21600a586ceaSMark Shellenbaum sa_os_t *sa = os->os_sa; 21610a586ceaSMark Shellenbaum 21620a586ceaSMark Shellenbaum if (sa->sa_master_obj) 21630a586ceaSMark Shellenbaum return (1); 21640a586ceaSMark Shellenbaum 21650a586ceaSMark Shellenbaum sa->sa_master_obj = sa_object; 21660a586ceaSMark Shellenbaum 21670a586ceaSMark Shellenbaum return (0); 21680a586ceaSMark Shellenbaum } 21690a586ceaSMark Shellenbaum 21700a586ceaSMark Shellenbaum int 21710a586ceaSMark Shellenbaum sa_hdrsize(void *arg) 21720a586ceaSMark Shellenbaum { 21730a586ceaSMark Shellenbaum sa_hdr_phys_t *hdr = arg; 21740a586ceaSMark Shellenbaum 21750a586ceaSMark Shellenbaum return (SA_HDR_SIZE(hdr)); 21760a586ceaSMark Shellenbaum } 21770a586ceaSMark Shellenbaum 21780a586ceaSMark Shellenbaum void 21790a586ceaSMark Shellenbaum sa_handle_lock(sa_handle_t *hdl) 21800a586ceaSMark Shellenbaum { 21810a586ceaSMark Shellenbaum ASSERT(hdl); 21820a586ceaSMark Shellenbaum mutex_enter(&hdl->sa_lock); 21830a586ceaSMark Shellenbaum } 21840a586ceaSMark Shellenbaum 21850a586ceaSMark Shellenbaum void 21860a586ceaSMark Shellenbaum sa_handle_unlock(sa_handle_t *hdl) 21870a586ceaSMark Shellenbaum { 21880a586ceaSMark Shellenbaum ASSERT(hdl); 21890a586ceaSMark Shellenbaum mutex_exit(&hdl->sa_lock); 21900a586ceaSMark Shellenbaum } 2191