sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sa.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Portions Copyright 2011 iXsystems, Inc
  25  * Copyright (c) 2013, 2017 by Delphix. All rights reserved.
  26  * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
  27  * Copyright (c) 2014 Integros [integros.com]
  28  */
  29
  30 #include <sys/zfs_context.h>
  31 #include <sys/types.h>
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/sysmacros.h>
  35 #include <sys/dmu.h>
  36 #include <sys/dmu_impl.h>
  37 #include <sys/dmu_objset.h>
  38 #include <sys/dbuf.h>
  39 #include <sys/dnode.h>
  40 #include <sys/zap.h>
  41 #include <sys/sa.h>
  42 #include <sys/sunddi.h>
  43 #include <sys/sa_impl.h>
  44 #include <sys/dnode.h>
  45 #include <sys/errno.h>
  46 #include <sys/zfs_context.h>
  47
  48 /*
  49  * ZFS System attributes:
  50  *
  51  * A generic mechanism to allow for arbitrary attributes
  52  * to be stored in a dnode.  The data will be stored in the bonus buffer of
  53  * the dnode and if necessary a special "spill" block will be used to handle
  54  * overflow situations.  The spill block will be sized to fit the data
  55  * from 512 - 128K.  When a spill block is used the BP (blkptr_t) for the
  56  * spill block is stored at the end of the current bonus buffer.  Any
  57  * attributes that would be in the way of the blkptr_t will be relocated
  58  * into the spill block.
  59  *
  60  * Attribute registration:
  61  *
  62  * Stored persistently on a per dataset basis
  63  * a mapping between attribute "string" names and their actual attribute
  64  * numeric values, length, and byteswap function.  The names are only used
  65  * during registration.  All  attributes are known by their unique attribute
  66  * id value.  If an attribute can have a variable size then the value
  67  * 0 will be used to indicate this.
  68  *
  69  * Attribute Layout:
  70  *
  71  * Attribute layouts are a way to compactly store multiple attributes, but
  72  * without taking the overhead associated with managing each attribute
  73  * individually.  Since you will typically have the same set of attributes
  74  * stored in the same order a single table will be used to represent that
  75  * layout.  The ZPL for example will usually have only about 10 different
  76  * layouts (regular files, device files, symlinks,
  77  * regular files + scanstamp, files/dir with extended attributes, and then
  78  * you have the possibility of all of those minus ACL, because it would
  79  * be kicked out into the spill block)
  80  *
  81  * Layouts are simply an array of the attributes and their
  82  * ordering i.e. [0, 1, 4, 5, 2]
  83  *
  84  * Each distinct layout is given a unique layout number and that is whats
  85  * stored in the header at the beginning of the SA data buffer.
  86  *
  87  * A layout only covers a single dbuf (bonus or spill).  If a set of
  88  * attributes is split up between the bonus buffer and a spill buffer then
  89  * two different layouts will be used.  This allows us to byteswap the
  90  * spill without looking at the bonus buffer and keeps the on disk format of
  91  * the bonus and spill buffer the same.
  92  *
  93  * Adding a single attribute will cause the entire set of attributes to
  94  * be rewritten and could result in a new layout number being constructed
  95  * as part of the rewrite if no such layout exists for the new set of
  96  * attribues.  The new attribute will be appended to the end of the already
  97  * existing attributes.
  98  *
  99  * Both the attribute registration and attribute layout information are
 100  * stored in normal ZAP attributes.  Their should be a small number of
 101  * known layouts and the set of attributes is assumed to typically be quite
 102  * small.
 103  *
 104  * The registered attributes and layout "table" information is maintained
 105  * in core and a special "sa_os_t" is attached to the objset_t.
 106  *
 107  * A special interface is provided to allow for quickly applying
 108  * a large set of attributes at once.  sa_replace_all_by_template() is
 109  * used to set an array of attributes.  This is used by the ZPL when
 110  * creating a brand new file.  The template that is passed into the function
 111  * specifies the attribute, size for variable length attributes, location of
 112  * data and special "data locator" function if the data isn't in a contiguous
 113  * location.
 114  *
 115  * Byteswap implications:
 116  *
 117  * Since the SA attributes are not entirely self describing we can't do
 118  * the normal byteswap processing.  The special ZAP layout attribute and
 119  * attribute registration attributes define the byteswap function and the
 120  * size of the attributes, unless it is variable sized.
 121  * The normal ZFS byteswapping infrastructure assumes you don't need
 122  * to read any objects in order to do the necessary byteswapping.  Whereas
 123  * SA attributes can only be properly byteswapped if the dataset is opened
 124  * and the layout/attribute ZAP attributes are available.  Because of this
 125  * the SA attributes will be byteswapped when they are first accessed by
 126  * the SA code that will read the SA data.
 127  */
 128
 129 typedef void (sa_iterfunc_t)(void *hdr, void *addr, sa_attr_type_t,
 130     uint16_t length, int length_idx, boolean_t, void *userp);
 131
 132 static int sa_build_index(sa_handle_t *hdl, sa_buf_type_t buftype);
 133 static void sa_idx_tab_hold(objset_t *os, sa_idx_tab_t *idx_tab);
 134 static sa_idx_tab_t *sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype,
 135     sa_hdr_phys_t *hdr);
 136 static void sa_idx_tab_rele(objset_t *os, void *arg);
 137 static void sa_copy_data(sa_data_locator_t *func, void *start, void *target,
 138     int buflen);
 139 static int sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr,
 140     sa_data_op_t action, sa_data_locator_t *locator, void *datastart,
 141     uint16_t buflen, dmu_tx_t *tx);
 142
 143 arc_byteswap_func_t *sa_bswap_table[] = {
 144         byteswap_uint64_array,
 145         byteswap_uint32_array,
 146         byteswap_uint16_array,
 147         byteswap_uint8_array,
 148         zfs_acl_byteswap,
 149 };
 150
 151 #define SA_COPY_DATA(f, s, t, l) \
 152         { \
 153                 if (f == NULL) { \
 154                         if (l == 8) { \
 155                                 *(uint64_t *)t = *(uint64_t *)s; \
 156                         } else if (l == 16) { \
 157                                 *(uint64_t *)t = *(uint64_t *)s; \
 158                                 *(uint64_t *)((uintptr_t)t + 8) = \
 159                                     *(uint64_t *)((uintptr_t)s + 8); \
 160                         } else { \
 161                                 bcopy(s, t, l); \
 162                         } \
 163                 } else \
 164                         sa_copy_data(f, s, t, l); \
 165         }
 166
 167 /*
 168  * This table is fixed and cannot be changed.  Its purpose is to
 169  * allow the SA code to work with both old/new ZPL file systems.
 170  * It contains the list of legacy attributes.  These attributes aren't
 171  * stored in the "attribute" registry zap objects, since older ZPL file systems
 172  * won't have the registry.  Only objsets of type ZFS_TYPE_FILESYSTEM will
 173  * use this static table.
 174  */
 175 sa_attr_reg_t sa_legacy_attrs[] = {
 176         {"ZPL_ATIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 0},
 177         {"ZPL_MTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 1},
 178         {"ZPL_CTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 2},
 179         {"ZPL_CRTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 3},
 180         {"ZPL_GEN", sizeof (uint64_t), SA_UINT64_ARRAY, 4},
 181         {"ZPL_MODE", sizeof (uint64_t), SA_UINT64_ARRAY, 5},
 182         {"ZPL_SIZE", sizeof (uint64_t), SA_UINT64_ARRAY, 6},
 183         {"ZPL_PARENT", sizeof (uint64_t), SA_UINT64_ARRAY, 7},
 184         {"ZPL_LINKS", sizeof (uint64_t), SA_UINT64_ARRAY, 8},
 185         {"ZPL_XATTR", sizeof (uint64_t), SA_UINT64_ARRAY, 9},
 186         {"ZPL_RDEV", sizeof (uint64_t), SA_UINT64_ARRAY, 10},
 187         {"ZPL_FLAGS", sizeof (uint64_t), SA_UINT64_ARRAY, 11},
 188         {"ZPL_UID", sizeof (uint64_t), SA_UINT64_ARRAY, 12},
 189         {"ZPL_GID", sizeof (uint64_t), SA_UINT64_ARRAY, 13},
 190         {"ZPL_PAD", sizeof (uint64_t) * 4, SA_UINT64_ARRAY, 14},
 191         {"ZPL_ZNODE_ACL", 88, SA_UINT8_ARRAY, 15},
 192 };
 193
 194 /*
 195  * This is only used for objects of type DMU_OT_ZNODE
 196  */
 197 sa_attr_type_t sa_legacy_zpl_layout[] = {
 198     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
 199 };
 200
 201 /*
 202  * Special dummy layout used for buffers with no attributes.
 203  */
 204 sa_attr_type_t sa_dummy_zpl_layout[] = { 0 };
 205
 206 static int sa_legacy_attr_count = 16;
 207 static kmem_cache_t *sa_cache = NULL;
 208
 209 /*ARGSUSED*/
 210 static int
 211 sa_cache_constructor(void *buf, void *unused, int kmflag)
 212 {
 213         sa_handle_t *hdl = buf;
 214
 215         mutex_init(&hdl->sa_lock, NULL, MUTEX_DEFAULT, NULL);
 216         return (0);
 217 }
 218
 219 /*ARGSUSED*/
 220 static void
 221 sa_cache_destructor(void *buf, void *unused)
 222 {
 223         sa_handle_t *hdl = buf;
 224         mutex_destroy(&hdl->sa_lock);
 225 }
 226
 227 void
 228 sa_cache_init(void)
 229 {
 230         sa_cache = kmem_cache_create("sa_cache",
 231             sizeof (sa_handle_t), 0, sa_cache_constructor,
 232             sa_cache_destructor, NULL, NULL, NULL, 0);
 233 }
 234
 235 void
 236 sa_cache_fini(void)
 237 {
 238         if (sa_cache)
 239                 kmem_cache_destroy(sa_cache);
 240 }
 241
 242 static int
 243 layout_num_compare(const void *arg1, const void *arg2)
 244 {
 245         const sa_lot_t *node1 = (const sa_lot_t *)arg1;
 246         const sa_lot_t *node2 = (const sa_lot_t *)arg2;
 247
 248         return (AVL_CMP(node1->lot_num, node2->lot_num));
 249 }
 250
 251 static int
 252 layout_hash_compare(const void *arg1, const void *arg2)
 253 {
 254         const sa_lot_t *node1 = (const sa_lot_t *)arg1;
 255         const sa_lot_t *node2 = (const sa_lot_t *)arg2;
 256
 257         int cmp = AVL_CMP(node1->lot_hash, node2->lot_hash);
 258         if (likely(cmp))
 259                 return (cmp);
 260
 261         return (AVL_CMP(node1->lot_instance, node2->lot_instance));
 262 }
 263
 264 boolean_t
 265 sa_layout_equal(sa_lot_t *tbf, sa_attr_type_t *attrs, int count)
 266 {
 267         int i;
 268
 269         if (count != tbf->lot_attr_count)
 270                 return (1);
 271
 272         for (i = 0; i != count; i++) {
 273                 if (attrs[i] != tbf->lot_attrs[i])
 274                         return (1);
 275         }
 276         return (0);
 277 }
 278
 279 #define SA_ATTR_HASH(attr) (zfs_crc64_table[(-1ULL ^ attr) & 0xFF])
 280
 281 static uint64_t
 282 sa_layout_info_hash(sa_attr_type_t *attrs, int attr_count)
 283 {
 284         int i;
 285         uint64_t crc = -1ULL;
 286
 287         for (i = 0; i != attr_count; i++)
 288                 crc ^= SA_ATTR_HASH(attrs[i]);
 289
 290         return (crc);
 291 }
 292
 293 static int
 294 sa_get_spill(sa_handle_t *hdl)
 295 {
 296         int rc;
 297         if (hdl->sa_spill == NULL) {
 298                 if ((rc = dmu_spill_hold_existing(hdl->sa_bonus, NULL,
 299                     &hdl->sa_spill)) == 0)
 300                         VERIFY(0 == sa_build_index(hdl, SA_SPILL));
 301         } else {
 302                 rc = 0;
 303         }
 304
 305         return (rc);
 306 }
 307
 308 /*
 309  * Main attribute lookup/update function
 310  * returns 0 for success or non zero for failures
 311  *
 312  * Operates on bulk array, first failure will abort further processing
 313  */
 314 int
 315 sa_attr_op(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count,
 316     sa_data_op_t data_op, dmu_tx_t *tx)
 317 {
 318         sa_os_t *sa = hdl->sa_os->os_sa;
 319         int i;
 320         int error = 0;
 321         sa_buf_type_t buftypes;
 322
 323         buftypes = 0;
 324
 325         ASSERT(count > 0);
 326         for (i = 0; i != count; i++) {
 327                 ASSERT(bulk[i].sa_attr <= hdl->sa_os->os_sa->sa_num_attrs);
 328
 329                 bulk[i].sa_addr = NULL;
 330                 /* First check the bonus buffer */
 331
 332                 if (hdl->sa_bonus_tab && TOC_ATTR_PRESENT(
 333                     hdl->sa_bonus_tab->sa_idx_tab[bulk[i].sa_attr])) {
 334                         SA_ATTR_INFO(sa, hdl->sa_bonus_tab,
 335                             SA_GET_HDR(hdl, SA_BONUS),
 336                             bulk[i].sa_attr, bulk[i], SA_BONUS, hdl);
 337                         if (tx && !(buftypes & SA_BONUS)) {
 338                                 dmu_buf_will_dirty(hdl->sa_bonus, tx);
 339                                 buftypes |= SA_BONUS;
 340                         }
 341                 }
 342                 if (bulk[i].sa_addr == NULL &&
 343                     ((error = sa_get_spill(hdl)) == 0)) {
 344                         if (TOC_ATTR_PRESENT(
 345                             hdl->sa_spill_tab->sa_idx_tab[bulk[i].sa_attr])) {
 346                                 SA_ATTR_INFO(sa, hdl->sa_spill_tab,
 347                                     SA_GET_HDR(hdl, SA_SPILL),
 348                                     bulk[i].sa_attr, bulk[i], SA_SPILL, hdl);
 349                                 if (tx && !(buftypes & SA_SPILL) &&
 350                                     bulk[i].sa_size == bulk[i].sa_length) {
 351                                         dmu_buf_will_dirty(hdl->sa_spill, tx);
 352                                         buftypes |= SA_SPILL;
 353                                 }
 354                         }
 355                 }
 356                 if (error && error != ENOENT) {
 357                         return ((error == ECKSUM) ? EIO : error);
 358                 }
 359
 360                 switch (data_op) {
 361                 case SA_LOOKUP:
 362                         if (bulk[i].sa_addr == NULL)
 363                                 return (SET_ERROR(ENOENT));
 364                         if (bulk[i].sa_data) {
 365                                 SA_COPY_DATA(bulk[i].sa_data_func,
 366                                     bulk[i].sa_addr, bulk[i].sa_data,
 367                                     bulk[i].sa_size);
 368                         }
 369                         continue;
 370
 371                 case SA_UPDATE:
 372                         /* existing rewrite of attr */
 373                         if (bulk[i].sa_addr &&
 374                             bulk[i].sa_size == bulk[i].sa_length) {
 375                                 SA_COPY_DATA(bulk[i].sa_data_func,
 376                                     bulk[i].sa_data, bulk[i].sa_addr,
 377                                     bulk[i].sa_length);
 378                                 continue;
 379                         } else if (bulk[i].sa_addr) { /* attr size change */
 380                                 error = sa_modify_attrs(hdl, bulk[i].sa_attr,
 381                                     SA_REPLACE, bulk[i].sa_data_func,
 382                                     bulk[i].sa_data, bulk[i].sa_length, tx);
 383                         } else { /* adding new attribute */
 384                                 error = sa_modify_attrs(hdl, bulk[i].sa_attr,
 385                                     SA_ADD, bulk[i].sa_data_func,
 386                                     bulk[i].sa_data, bulk[i].sa_length, tx);
 387                         }
 388                         if (error)
 389                                 return (error);
 390                         break;
 391                 }
 392         }
 393         return (error);
 394 }
 395
 396 static sa_lot_t *
 397 sa_add_layout_entry(objset_t *os, sa_attr_type_t *attrs, int attr_count,
 398     uint64_t lot_num, uint64_t hash, boolean_t zapadd, dmu_tx_t *tx)
 399 {
 400         sa_os_t *sa = os->os_sa;
 401         sa_lot_t *tb, *findtb;
 402         int i;
 403         avl_index_t loc;
 404
 405         ASSERT(MUTEX_HELD(&sa->sa_lock));
 406         tb = kmem_zalloc(sizeof (sa_lot_t), KM_SLEEP);
 407         tb->lot_attr_count = attr_count;
 408         tb->lot_attrs = kmem_alloc(sizeof (sa_attr_type_t) * attr_count,
 409             KM_SLEEP);
 410         bcopy(attrs, tb->lot_attrs, sizeof (sa_attr_type_t) * attr_count);
 411         tb->lot_num = lot_num;
 412         tb->lot_hash = hash;
 413         tb->lot_instance = 0;
 414
 415         if (zapadd) {
 416                 char attr_name[8];
 417
 418                 if (sa->sa_layout_attr_obj == 0) {
 419                         sa->sa_layout_attr_obj = zap_create_link(os,
 420                             DMU_OT_SA_ATTR_LAYOUTS,
 421                             sa->sa_master_obj, SA_LAYOUTS, tx);
 422                 }
 423
 424                 (void) snprintf(attr_name, sizeof (attr_name),
 425                     "%d", (int)lot_num);
 426                 VERIFY(0 == zap_update(os, os->os_sa->sa_layout_attr_obj,
 427                     attr_name, 2, attr_count, attrs, tx));
 428         }
 429
 430         list_create(&tb->lot_idx_tab, sizeof (sa_idx_tab_t),
 431             offsetof(sa_idx_tab_t, sa_next));
 432
 433         for (i = 0; i != attr_count; i++) {
 434                 if (sa->sa_attr_table[tb->lot_attrs[i]].sa_length == 0)
 435                         tb->lot_var_sizes++;
 436         }
 437
 438         avl_add(&sa->sa_layout_num_tree, tb);
 439
 440         /* verify we don't have a hash collision */
 441         if ((findtb = avl_find(&sa->sa_layout_hash_tree, tb, &loc)) != NULL) {
 442                 for (; findtb && findtb->lot_hash == hash;
 443                     findtb = AVL_NEXT(&sa->sa_layout_hash_tree, findtb)) {
 444                         if (findtb->lot_instance != tb->lot_instance)
 445                                 break;
 446                         tb->lot_instance++;
 447                 }
 448         }
 449         avl_add(&sa->sa_layout_hash_tree, tb);
 450         return (tb);
 451 }
 452
 453 static void
 454 sa_find_layout(objset_t *os, uint64_t hash, sa_attr_type_t *attrs,
 455     int count, dmu_tx_t *tx, sa_lot_t **lot)
 456 {
 457         sa_lot_t *tb, tbsearch;
 458         avl_index_t loc;
 459         sa_os_t *sa = os->os_sa;
 460         boolean_t found = B_FALSE;
 461
 462         mutex_enter(&sa->sa_lock);
 463         tbsearch.lot_hash = hash;
 464         tbsearch.lot_instance = 0;
 465         tb = avl_find(&sa->sa_layout_hash_tree, &tbsearch, &loc);
 466         if (tb) {
 467                 for (; tb && tb->lot_hash == hash;
 468                     tb = AVL_NEXT(&sa->sa_layout_hash_tree, tb)) {
 469                         if (sa_layout_equal(tb, attrs, count) == 0) {
 470                                 found = B_TRUE;
 471                                 break;
 472                         }
 473                 }
 474         }
 475         if (!found) {
 476                 tb = sa_add_layout_entry(os, attrs, count,
 477                     avl_numnodes(&sa->sa_layout_num_tree), hash, B_TRUE, tx);
 478         }
 479         mutex_exit(&sa->sa_lock);
 480         *lot = tb;
 481 }
 482
 483 static int
 484 sa_resize_spill(sa_handle_t *hdl, uint32_t size, dmu_tx_t *tx)
 485 {
 486         int error;
 487         uint32_t blocksize;
 488
 489         if (size == 0) {
 490                 blocksize = SPA_MINBLOCKSIZE;
 491         } else if (size > SPA_OLD_MAXBLOCKSIZE) {
 492                 ASSERT(0);
 493                 return (SET_ERROR(EFBIG));
 494         } else {
 495                 blocksize = P2ROUNDUP_TYPED(size, SPA_MINBLOCKSIZE, uint32_t);
 496         }
 497
 498         error = dbuf_spill_set_blksz(hdl->sa_spill, blocksize, tx);
 499         ASSERT(error == 0);
 500         return (error);
 501 }
 502
 503 static void
 504 sa_copy_data(sa_data_locator_t *func, void *datastart, void *target, int buflen)
 505 {
 506         if (func == NULL) {
 507                 bcopy(datastart, target, buflen);
 508         } else {
 509                 boolean_t start;
 510                 int bytes;
 511                 void *dataptr;
 512                 void *saptr = target;
 513                 uint32_t length;
 514
 515                 start = B_TRUE;
 516                 bytes = 0;
 517                 while (bytes < buflen) {
 518                         func(&dataptr, &length, buflen, start, datastart);
 519                         bcopy(dataptr, saptr, length);
 520                         saptr = (void *)((caddr_t)saptr + length);
 521                         bytes += length;
 522                         start = B_FALSE;
 523                 }
 524         }
 525 }
 526
 527 /*
 528  * Determine several different sizes
 529  * first the sa header size
 530  * the number of bytes to be stored
 531  * if spill would occur the index in the attribute array is returned
 532  *
 533  * the boolean will_spill will be set when spilling is necessary.  It
 534  * is only set when the buftype is SA_BONUS
 535  */
 536 static int
 537 sa_find_sizes(sa_os_t *sa, sa_bulk_attr_t *attr_desc, int attr_count,
 538     dmu_buf_t *db, sa_buf_type_t buftype, int *index, int *total,
 539     boolean_t *will_spill)
 540 {
 541         int var_size = 0;
 542         int i;
 543         int full_space;
 544         int hdrsize;
 545         int extra_hdrsize;
 546
 547         if (buftype == SA_BONUS && sa->sa_force_spill) {
 548                 *total = 0;
 549                 *index = 0;
 550                 *will_spill = B_TRUE;
 551                 return (0);
 552         }
 553
 554         *index = -1;
 555         *total = 0;
 556         *will_spill = B_FALSE;
 557
 558         extra_hdrsize = 0;
 559         hdrsize = (SA_BONUSTYPE_FROM_DB(db) == DMU_OT_ZNODE) ? 0 :
 560             sizeof (sa_hdr_phys_t);
 561
 562         full_space = (buftype == SA_BONUS) ? DN_MAX_BONUSLEN : db->db_size;
 563         ASSERT(IS_P2ALIGNED(full_space, 8));
 564
 565         for (i = 0; i != attr_count; i++) {
 566                 boolean_t is_var_sz;
 567
 568                 *total = P2ROUNDUP(*total, 8);
 569                 *total += attr_desc[i].sa_length;
 570                 if (*will_spill)
 571                         continue;
 572
 573                 is_var_sz = (SA_REGISTERED_LEN(sa, attr_desc[i].sa_attr) == 0);
 574                 if (is_var_sz) {
 575                         var_size++;
 576                 }
 577
 578                 if (is_var_sz && var_size > 1) {
 579                         /*
 580                          * Don't worry that the spill block might overflow.
 581                          * It will be resized if needed in sa_build_layouts().
 582                          */
 583                         if (buftype == SA_SPILL ||
 584                             P2ROUNDUP(hdrsize + sizeof (uint16_t), 8) +
 585                             *total < full_space) {
 586                                 /*
 587                                  * Account for header space used by array of
 588                                  * optional sizes of variable-length attributes.
 589                                  * Record the extra header size in case this
 590                                  * increase needs to be reversed due to
 591                                  * spill-over.
 592                                  */
 593                                 hdrsize += sizeof (uint16_t);
 594                                 if (*index != -1)
 595                                         extra_hdrsize += sizeof (uint16_t);
 596                         } else {
 597                                 ASSERT(buftype == SA_BONUS);
 598                                 if (*index == -1)
 599                                         *index = i;
 600                                 *will_spill = B_TRUE;
 601                                 continue;
 602                         }
 603                 }
 604
 605                 /*
 606                  * find index of where spill *could* occur.
 607                  * Then continue to count of remainder attribute
 608                  * space.  The sum is used later for sizing bonus
 609                  * and spill buffer.
 610                  */
 611                 if (buftype == SA_BONUS && *index == -1 &&
 612                     (*total + P2ROUNDUP(hdrsize, 8)) >
 613                     (full_space - sizeof (blkptr_t))) {
 614                         *index = i;
 615                 }
 616
 617                 if ((*total + P2ROUNDUP(hdrsize, 8)) > full_space &&
 618                     buftype == SA_BONUS)
 619                         *will_spill = B_TRUE;
 620         }
 621
 622         if (*will_spill)
 623                 hdrsize -= extra_hdrsize;
 624
 625         hdrsize = P2ROUNDUP(hdrsize, 8);
 626         return (hdrsize);
 627 }
 628
 629 #define BUF_SPACE_NEEDED(total, header) (total + header)
 630
 631 /*
 632  * Find layout that corresponds to ordering of attributes
 633  * If not found a new layout number is created and added to
 634  * persistent layout tables.
 635  */
 636 static int
 637 sa_build_layouts(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, int attr_count,
 638     dmu_tx_t *tx)
 639 {
 640         sa_os_t *sa = hdl->sa_os->os_sa;
 641         uint64_t hash;
 642         sa_buf_type_t buftype;
 643         sa_hdr_phys_t *sahdr;
 644         void *data_start;
 645         int buf_space;
 646         sa_attr_type_t *attrs, *attrs_start;
 647         int i, lot_count;
 648         int hdrsize;
 649         int spillhdrsize = 0;
 650         int used;
 651         dmu_object_type_t bonustype;
 652         sa_lot_t *lot;
 653         int len_idx;
 654         int spill_used;
 655         boolean_t spilling;
 656
 657         dmu_buf_will_dirty(hdl->sa_bonus, tx);
 658         bonustype = SA_BONUSTYPE_FROM_DB(hdl->sa_bonus);
 659
 660         /* first determine bonus header size and sum of all attributes */
 661         hdrsize = sa_find_sizes(sa, attr_desc, attr_count, hdl->sa_bonus,
 662             SA_BONUS, &i, &used, &spilling);
 663
 664         if (used > SPA_OLD_MAXBLOCKSIZE)
 665                 return (SET_ERROR(EFBIG));
 666
 667         VERIFY(0 == dmu_set_bonus(hdl->sa_bonus, spilling ?
 668             MIN(DN_MAX_BONUSLEN - sizeof (blkptr_t), used + hdrsize) :
 669             used + hdrsize, tx));
 670
 671         ASSERT((bonustype == DMU_OT_ZNODE && spilling == 0) ||
 672             bonustype == DMU_OT_SA);
 673
 674         /* setup and size spill buffer when needed */
 675         if (spilling) {
 676                 boolean_t dummy;
 677
 678                 if (hdl->sa_spill == NULL) {
 679                         VERIFY(dmu_spill_hold_by_bonus(hdl->sa_bonus, NULL,
 680                             &hdl->sa_spill) == 0);
 681                 }
 682                 dmu_buf_will_dirty(hdl->sa_spill, tx);
 683
 684                 spillhdrsize = sa_find_sizes(sa, &attr_desc[i],
 685                     attr_count - i, hdl->sa_spill, SA_SPILL, &i,
 686                     &spill_used, &dummy);
 687
 688                 if (spill_used > SPA_OLD_MAXBLOCKSIZE)
 689                         return (SET_ERROR(EFBIG));
 690
 691                 buf_space = hdl->sa_spill->db_size - spillhdrsize;
 692                 if (BUF_SPACE_NEEDED(spill_used, spillhdrsize) >
 693                     hdl->sa_spill->db_size)
 694                         VERIFY(0 == sa_resize_spill(hdl,
 695                             BUF_SPACE_NEEDED(spill_used, spillhdrsize), tx));
 696         }
 697
 698         /* setup starting pointers to lay down data */
 699         data_start = (void *)((uintptr_t)hdl->sa_bonus->db_data + hdrsize);
 700         sahdr = (sa_hdr_phys_t *)hdl->sa_bonus->db_data;
 701         buftype = SA_BONUS;
 702
 703         if (spilling)
 704                 buf_space = (sa->sa_force_spill) ?
 705                     0 : SA_BLKPTR_SPACE - hdrsize;
 706         else
 707                 buf_space = hdl->sa_bonus->db_size - hdrsize;
 708
 709         attrs_start = attrs = kmem_alloc(sizeof (sa_attr_type_t) * attr_count,
 710             KM_SLEEP);
 711         lot_count = 0;
 712
 713         for (i = 0, len_idx = 0, hash = -1ULL; i != attr_count; i++) {
 714                 uint16_t length;
 715
 716                 ASSERT(IS_P2ALIGNED(data_start, 8));
 717                 ASSERT(IS_P2ALIGNED(buf_space, 8));
 718                 attrs[i] = attr_desc[i].sa_attr;
 719                 length = SA_REGISTERED_LEN(sa, attrs[i]);
 720                 if (length == 0)
 721                         length = attr_desc[i].sa_length;
 722                 else
 723                         VERIFY(length == attr_desc[i].sa_length);
 724
 725                 if (buf_space < length) {  /* switch to spill buffer */
 726                         VERIFY(spilling);
 727                         VERIFY(bonustype == DMU_OT_SA);
 728                         if (buftype == SA_BONUS && !sa->sa_force_spill) {
 729                                 sa_find_layout(hdl->sa_os, hash, attrs_start,
 730                                     lot_count, tx, &lot);
 731                                 SA_SET_HDR(sahdr, lot->lot_num, hdrsize);
 732                         }
 733
 734                         buftype = SA_SPILL;
 735                         hash = -1ULL;
 736                         len_idx = 0;
 737
 738                         sahdr = (sa_hdr_phys_t *)hdl->sa_spill->db_data;
 739                         sahdr->sa_magic = SA_MAGIC;
 740                         data_start = (void *)((uintptr_t)sahdr +
 741                             spillhdrsize);
 742                         attrs_start = &attrs[i];
 743                         buf_space = hdl->sa_spill->db_size - spillhdrsize;
 744                         lot_count = 0;
 745                 }
 746                 hash ^= SA_ATTR_HASH(attrs[i]);
 747                 attr_desc[i].sa_addr = data_start;
 748                 attr_desc[i].sa_size = length;
 749                 SA_COPY_DATA(attr_desc[i].sa_data_func, attr_desc[i].sa_data,
 750                     data_start, length);
 751                 if (sa->sa_attr_table[attrs[i]].sa_length == 0) {
 752                         sahdr->sa_lengths[len_idx++] = length;
 753                 }
 754                 VERIFY((uintptr_t)data_start % 8 == 0);
 755                 data_start = (void *)P2ROUNDUP(((uintptr_t)data_start +
 756                     length), 8);
 757                 buf_space -= P2ROUNDUP(length, 8);
 758                 lot_count++;
 759         }
 760
 761         sa_find_layout(hdl->sa_os, hash, attrs_start, lot_count, tx, &lot);
 762
 763         /*
 764          * Verify that old znodes always have layout number 0.
 765          * Must be DMU_OT_SA for arbitrary layouts
 766          */
 767         VERIFY((bonustype == DMU_OT_ZNODE && lot->lot_num == 0) ||
 768             (bonustype == DMU_OT_SA && lot->lot_num > 1));
 769
 770         if (bonustype == DMU_OT_SA) {
 771                 SA_SET_HDR(sahdr, lot->lot_num,
 772                     buftype == SA_BONUS ? hdrsize : spillhdrsize);
 773         }
 774
 775         kmem_free(attrs, sizeof (sa_attr_type_t) * attr_count);
 776         if (hdl->sa_bonus_tab) {
 777                 sa_idx_tab_rele(hdl->sa_os, hdl->sa_bonus_tab);
 778                 hdl->sa_bonus_tab = NULL;
 779         }
 780         if (!sa->sa_force_spill)
 781                 VERIFY(0 == sa_build_index(hdl, SA_BONUS));
 782         if (hdl->sa_spill) {
 783                 sa_idx_tab_rele(hdl->sa_os, hdl->sa_spill_tab);
 784                 if (!spilling) {
 785                         /*
 786                          * remove spill block that is no longer needed.
 787                          */
 788                         dmu_buf_rele(hdl->sa_spill, NULL);
 789                         hdl->sa_spill = NULL;
 790                         hdl->sa_spill_tab = NULL;
 791                         VERIFY(0 == dmu_rm_spill(hdl->sa_os,
 792                             sa_handle_object(hdl), tx));
 793                 } else {
 794                         VERIFY(0 == sa_build_index(hdl, SA_SPILL));
 795                 }
 796         }
 797
 798         return (0);
 799 }
 800
 801 static void
 802 sa_free_attr_table(sa_os_t *sa)
 803 {
 804         int i;
 805
 806         if (sa->sa_attr_table == NULL)
 807                 return;
 808
 809         for (i = 0; i != sa->sa_num_attrs; i++) {
 810                 if (sa->sa_attr_table[i].sa_name)
 811                         kmem_free(sa->sa_attr_table[i].sa_name,
 812                             strlen(sa->sa_attr_table[i].sa_name) + 1);
 813         }
 814
 815         kmem_free(sa->sa_attr_table,
 816             sizeof (sa_attr_table_t) * sa->sa_num_attrs);
 817
 818         sa->sa_attr_table = NULL;
 819 }
 820
 821 static int
 822 sa_attr_table_setup(objset_t *os, sa_attr_reg_t *reg_attrs, int count)
 823 {
 824         sa_os_t *sa = os->os_sa;
 825         uint64_t sa_attr_count = 0;
 826         uint64_t sa_reg_count = 0;
 827         int error = 0;
 828         uint64_t attr_value;
 829         sa_attr_table_t *tb;
 830         zap_cursor_t zc;
 831         zap_attribute_t za;
 832         int registered_count = 0;
 833         int i;
 834         dmu_objset_type_t ostype = dmu_objset_type(os);
 835
 836         sa->sa_user_table =
 837             kmem_zalloc(count * sizeof (sa_attr_type_t), KM_SLEEP);
 838         sa->sa_user_table_sz = count * sizeof (sa_attr_type_t);
 839
 840         if (sa->sa_reg_attr_obj != 0) {
 841                 error = zap_count(os, sa->sa_reg_attr_obj,
 842                     &sa_attr_count);
 843
 844                 /*
 845                  * Make sure we retrieved a count and that it isn't zero
 846                  */
 847                 if (error || (error == 0 && sa_attr_count == 0)) {
 848                         if (error == 0)
 849                                 error = SET_ERROR(EINVAL);
 850                         goto bail;
 851                 }
 852                 sa_reg_count = sa_attr_count;
 853         }
 854
 855         if (ostype == DMU_OST_ZFS && sa_attr_count == 0)
 856                 sa_attr_count += sa_legacy_attr_count;
 857
 858         /* Allocate attribute numbers for attributes that aren't registered */
 859         for (i = 0; i != count; i++) {
 860                 boolean_t found = B_FALSE;
 861                 int j;
 862
 863                 if (ostype == DMU_OST_ZFS) {
 864                         for (j = 0; j != sa_legacy_attr_count; j++) {
 865                                 if (strcmp(reg_attrs[i].sa_name,
 866                                     sa_legacy_attrs[j].sa_name) == 0) {
 867                                         sa->sa_user_table[i] =
 868                                             sa_legacy_attrs[j].sa_attr;
 869                                         found = B_TRUE;
 870                                 }
 871                         }
 872                 }
 873                 if (found)
 874                         continue;
 875
 876                 if (sa->sa_reg_attr_obj)
 877                         error = zap_lookup(os, sa->sa_reg_attr_obj,
 878                             reg_attrs[i].sa_name, 8, 1, &attr_value);
 879                 else
 880                         error = SET_ERROR(ENOENT);
 881                 switch (error) {
 882                 case ENOENT:
 883                         sa->sa_user_table[i] = (sa_attr_type_t)sa_attr_count;
 884                         sa_attr_count++;
 885                         break;
 886                 case 0:
 887                         sa->sa_user_table[i] = ATTR_NUM(attr_value);
 888                         break;
 889                 default:
 890                         goto bail;
 891                 }
 892         }
 893
 894         sa->sa_num_attrs = sa_attr_count;
 895         tb = sa->sa_attr_table =
 896             kmem_zalloc(sizeof (sa_attr_table_t) * sa_attr_count, KM_SLEEP);
 897
 898         /*
 899          * Attribute table is constructed from requested attribute list,
 900          * previously foreign registered attributes, and also the legacy
 901          * ZPL set of attributes.
 902          */
 903
 904         if (sa->sa_reg_attr_obj) {
 905                 for (zap_cursor_init(&zc, os, sa->sa_reg_attr_obj);
 906                     (error = zap_cursor_retrieve(&zc, &za)) == 0;
 907                     zap_cursor_advance(&zc)) {
 908                         uint64_t value;
 909                         value  = za.za_first_integer;
 910
 911                         registered_count++;
 912                         tb[ATTR_NUM(value)].sa_attr = ATTR_NUM(value);
 913                         tb[ATTR_NUM(value)].sa_length = ATTR_LENGTH(value);
 914                         tb[ATTR_NUM(value)].sa_byteswap = ATTR_BSWAP(value);
 915                         tb[ATTR_NUM(value)].sa_registered = B_TRUE;
 916
 917                         if (tb[ATTR_NUM(value)].sa_name) {
 918                                 continue;
 919                         }
 920                         tb[ATTR_NUM(value)].sa_name =
 921                             kmem_zalloc(strlen(za.za_name) +1, KM_SLEEP);
 922                         (void) strlcpy(tb[ATTR_NUM(value)].sa_name, za.za_name,
 923                             strlen(za.za_name) +1);
 924                 }
 925                 zap_cursor_fini(&zc);
 926                 /*
 927                  * Make sure we processed the correct number of registered
 928                  * attributes
 929                  */
 930                 if (registered_count != sa_reg_count) {
 931                         ASSERT(error != 0);
 932                         goto bail;
 933                 }
 934
 935         }
 936
 937         if (ostype == DMU_OST_ZFS) {
 938                 for (i = 0; i != sa_legacy_attr_count; i++) {
 939                         if (tb[i].sa_name)
 940                                 continue;
 941                         tb[i].sa_attr = sa_legacy_attrs[i].sa_attr;
 942                         tb[i].sa_length = sa_legacy_attrs[i].sa_length;
 943                         tb[i].sa_byteswap = sa_legacy_attrs[i].sa_byteswap;
 944                         tb[i].sa_registered = B_FALSE;
 945                         tb[i].sa_name =
 946                             kmem_zalloc(strlen(sa_legacy_attrs[i].sa_name) +1,
 947                             KM_SLEEP);
 948                         (void) strlcpy(tb[i].sa_name,
 949                             sa_legacy_attrs[i].sa_name,
 950                             strlen(sa_legacy_attrs[i].sa_name) + 1);
 951                 }
 952         }
 953
 954         for (i = 0; i != count; i++) {
 955                 sa_attr_type_t attr_id;
 956
 957                 attr_id = sa->sa_user_table[i];
 958                 if (tb[attr_id].sa_name)
 959                         continue;
 960
 961                 tb[attr_id].sa_length = reg_attrs[i].sa_length;
 962                 tb[attr_id].sa_byteswap = reg_attrs[i].sa_byteswap;
 963                 tb[attr_id].sa_attr = attr_id;
 964                 tb[attr_id].sa_name =
 965                     kmem_zalloc(strlen(reg_attrs[i].sa_name) + 1, KM_SLEEP);
 966                 (void) strlcpy(tb[attr_id].sa_name, reg_attrs[i].sa_name,
 967                     strlen(reg_attrs[i].sa_name) + 1);
 968         }
 969
 970         sa->sa_need_attr_registration =
 971             (sa_attr_count != registered_count);
 972
 973         return (0);
 974 bail:
 975         kmem_free(sa->sa_user_table, count * sizeof (sa_attr_type_t));
 976         sa->sa_user_table = NULL;
 977         sa_free_attr_table(sa);
 978         return ((error != 0) ? error : EINVAL);
 979 }
 980
 981 int
 982 sa_setup(objset_t *os, uint64_t sa_obj, sa_attr_reg_t *reg_attrs, int count,
 983     sa_attr_type_t **user_table)
 984 {
 985         zap_cursor_t zc;
 986         zap_attribute_t za;
 987         sa_os_t *sa;
 988         dmu_objset_type_t ostype = dmu_objset_type(os);
 989         sa_attr_type_t *tb;
 990         int error;
 991
 992         mutex_enter(&os->os_user_ptr_lock);
 993         if (os->os_sa) {
 994                 mutex_enter(&os->os_sa->sa_lock);
 995                 mutex_exit(&os->os_user_ptr_lock);
 996                 tb = os->os_sa->sa_user_table;
 997                 mutex_exit(&os->os_sa->sa_lock);
 998                 *user_table = tb;
 999                 return (0);
1000         }
1001
1002         sa = kmem_zalloc(sizeof (sa_os_t), KM_SLEEP);
1003         mutex_init(&sa->sa_lock, NULL, MUTEX_DEFAULT, NULL);
1004         sa->sa_master_obj = sa_obj;
1005
1006         os->os_sa = sa;
1007         mutex_enter(&sa->sa_lock);
1008         mutex_exit(&os->os_user_ptr_lock);
1009         avl_create(&sa->sa_layout_num_tree, layout_num_compare,
1010             sizeof (sa_lot_t), offsetof(sa_lot_t, lot_num_node));
1011         avl_create(&sa->sa_layout_hash_tree, layout_hash_compare,
1012             sizeof (sa_lot_t), offsetof(sa_lot_t, lot_hash_node));
1013
1014         if (sa_obj) {
1015                 error = zap_lookup(os, sa_obj, SA_LAYOUTS,
1016                     8, 1, &sa->sa_layout_attr_obj);
1017                 if (error != 0 && error != ENOENT)
1018                         goto fail;
1019                 error = zap_lookup(os, sa_obj, SA_REGISTRY,
1020                     8, 1, &sa->sa_reg_attr_obj);
1021                 if (error != 0 && error != ENOENT)
1022                         goto fail;
1023         }
1024
1025         if ((error = sa_attr_table_setup(os, reg_attrs, count)) != 0)
1026                 goto fail;
1027
1028         if (sa->sa_layout_attr_obj != 0) {
1029                 uint64_t layout_count;
1030
1031                 error = zap_count(os, sa->sa_layout_attr_obj,
1032                     &layout_count);
1033
1034                 /*
1035                  * Layout number count should be > 0
1036                  */
1037                 if (error || (error == 0 && layout_count == 0)) {
1038                         if (error == 0)
1039                                 error = SET_ERROR(EINVAL);
1040                         goto fail;
1041                 }
1042
1043                 for (zap_cursor_init(&zc, os, sa->sa_layout_attr_obj);
1044                     (error = zap_cursor_retrieve(&zc, &za)) == 0;
1045                     zap_cursor_advance(&zc)) {
1046                         sa_attr_type_t *lot_attrs;
1047                         uint64_t lot_num;
1048
1049                         lot_attrs = kmem_zalloc(sizeof (sa_attr_type_t) *
1050                             za.za_num_integers, KM_SLEEP);
1051
1052                         if ((error = (zap_lookup(os, sa->sa_layout_attr_obj,
1053                             za.za_name, 2, za.za_num_integers,
1054                             lot_attrs))) != 0) {
1055                                 kmem_free(lot_attrs, sizeof (sa_attr_type_t) *
1056                                     za.za_num_integers);
1057                                 break;
1058                         }
1059                         VERIFY(ddi_strtoull(za.za_name, NULL, 10,
1060                             (unsigned long long *)&lot_num) == 0);
1061
1062                         (void) sa_add_layout_entry(os, lot_attrs,
1063                             za.za_num_integers, lot_num,
1064                             sa_layout_info_hash(lot_attrs,
1065                             za.za_num_integers), B_FALSE, NULL);
1066                         kmem_free(lot_attrs, sizeof (sa_attr_type_t) *
1067                             za.za_num_integers);
1068                 }
1069                 zap_cursor_fini(&zc);
1070
1071                 /*
1072                  * Make sure layout count matches number of entries added
1073                  * to AVL tree
1074                  */
1075                 if (avl_numnodes(&sa->sa_layout_num_tree) != layout_count) {
1076                         ASSERT(error != 0);
1077                         goto fail;
1078                 }
1079         }
1080
1081         /* Add special layout number for old ZNODES */
1082         if (ostype == DMU_OST_ZFS) {
1083                 (void) sa_add_layout_entry(os, sa_legacy_zpl_layout,
1084                     sa_legacy_attr_count, 0,
1085                     sa_layout_info_hash(sa_legacy_zpl_layout,
1086                     sa_legacy_attr_count), B_FALSE, NULL);
1087
1088                 (void) sa_add_layout_entry(os, sa_dummy_zpl_layout, 0, 1,
1089                     0, B_FALSE, NULL);
1090         }
1091         *user_table = os->os_sa->sa_user_table;
1092         mutex_exit(&sa->sa_lock);
1093         return (0);
1094 fail:
1095         os->os_sa = NULL;
1096         sa_free_attr_table(sa);
1097         if (sa->sa_user_table)
1098                 kmem_free(sa->sa_user_table, sa->sa_user_table_sz);
1099         mutex_exit(&sa->sa_lock);
1100         avl_destroy(&sa->sa_layout_hash_tree);
1101         avl_destroy(&sa->sa_layout_num_tree);
1102         mutex_destroy(&sa->sa_lock);
1103         kmem_free(sa, sizeof (sa_os_t));
1104         return ((error == ECKSUM) ? EIO : error);
1105 }
1106
1107 void
1108 sa_tear_down(objset_t *os)
1109 {
1110         sa_os_t *sa = os->os_sa;
1111         sa_lot_t *layout;
1112         void *cookie;
1113
1114         kmem_free(sa->sa_user_table, sa->sa_user_table_sz);
1115
1116         /* Free up attr table */
1117
1118         sa_free_attr_table(sa);
1119
1120         cookie = NULL;
1121         while (layout = avl_destroy_nodes(&sa->sa_layout_hash_tree, &cookie)) {
1122                 sa_idx_tab_t *tab;
1123                 while (tab = list_head(&layout->lot_idx_tab)) {
1124                         ASSERT(refcount_count(&tab->sa_refcount));
1125                         sa_idx_tab_rele(os, tab);
1126                 }
1127         }
1128
1129         cookie = NULL;
1130         while (layout = avl_destroy_nodes(&sa->sa_layout_num_tree, &cookie)) {
1131                 kmem_free(layout->lot_attrs,
1132                     sizeof (sa_attr_type_t) * layout->lot_attr_count);
1133                 kmem_free(layout, sizeof (sa_lot_t));
1134         }
1135
1136         avl_destroy(&sa->sa_layout_hash_tree);
1137         avl_destroy(&sa->sa_layout_num_tree);
1138         mutex_destroy(&sa->sa_lock);
1139
1140         kmem_free(sa, sizeof (sa_os_t));
1141         os->os_sa = NULL;
1142 }
1143
1144 void
1145 sa_build_idx_tab(void *hdr, void *attr_addr, sa_attr_type_t attr,
1146     uint16_t length, int length_idx, boolean_t var_length, void *userp)
1147 {
1148         sa_idx_tab_t *idx_tab = userp;
1149
1150         if (var_length) {
1151                 ASSERT(idx_tab->sa_variable_lengths);
1152                 idx_tab->sa_variable_lengths[length_idx] = length;
1153         }
1154         TOC_ATTR_ENCODE(idx_tab->sa_idx_tab[attr], length_idx,
1155             (uint32_t)((uintptr_t)attr_addr - (uintptr_t)hdr));
1156 }
1157
1158 static void
1159 sa_attr_iter(objset_t *os, sa_hdr_phys_t *hdr, dmu_object_type_t type,
1160     sa_iterfunc_t func, sa_lot_t *tab, void *userp)
1161 {
1162         void *data_start;
1163         sa_lot_t *tb = tab;
1164         sa_lot_t search;
1165         avl_index_t loc;
1166         sa_os_t *sa = os->os_sa;
1167         int i;
1168         uint16_t *length_start = NULL;
1169         uint8_t length_idx = 0;
1170
1171         if (tab == NULL) {
1172                 search.lot_num = SA_LAYOUT_NUM(hdr, type);
1173                 tb = avl_find(&sa->sa_layout_num_tree, &search, &loc);
1174                 ASSERT(tb);
1175         }
1176
1177         if (IS_SA_BONUSTYPE(type)) {
1178                 data_start = (void *)P2ROUNDUP(((uintptr_t)hdr +
1179                     offsetof(sa_hdr_phys_t, sa_lengths) +
1180                     (sizeof (uint16_t) * tb->lot_var_sizes)), 8);
1181                 length_start = hdr->sa_lengths;
1182         } else {
1183                 data_start = hdr;
1184         }
1185
1186         for (i = 0; i != tb->lot_attr_count; i++) {
1187                 int attr_length, reg_length;
1188                 uint8_t idx_len;
1189
1190                 reg_length = sa->sa_attr_table[tb->lot_attrs[i]].sa_length;
1191                 if (reg_length) {
1192                         attr_length = reg_length;
1193                         idx_len = 0;
1194                 } else {
1195                         attr_length = length_start[length_idx];
1196                         idx_len = length_idx++;
1197                 }
1198
1199                 func(hdr, data_start, tb->lot_attrs[i], attr_length,
1200                     idx_len, reg_length == 0 ? B_TRUE : B_FALSE, userp);
1201
1202                 data_start = (void *)P2ROUNDUP(((uintptr_t)data_start +
1203                     attr_length), 8);
1204         }
1205 }
1206
1207 /*ARGSUSED*/
1208 void
1209 sa_byteswap_cb(void *hdr, void *attr_addr, sa_attr_type_t attr,
1210     uint16_t length, int length_idx, boolean_t variable_length, void *userp)
1211 {
1212         sa_handle_t *hdl = userp;
1213         sa_os_t *sa = hdl->sa_os->os_sa;
1214
1215         sa_bswap_table[sa->sa_attr_table[attr].sa_byteswap](attr_addr, length);
1216 }
1217
1218 void
1219 sa_byteswap(sa_handle_t *hdl, sa_buf_type_t buftype)
1220 {
1221         sa_hdr_phys_t *sa_hdr_phys = SA_GET_HDR(hdl, buftype);
1222         dmu_buf_impl_t *db;
1223         sa_os_t *sa = hdl->sa_os->os_sa;
1224         int num_lengths = 1;
1225         int i;
1226
1227         ASSERT(MUTEX_HELD(&sa->sa_lock));
1228         if (sa_hdr_phys->sa_magic == SA_MAGIC)
1229                 return;
1230
1231         db = SA_GET_DB(hdl, buftype);
1232
1233         if (buftype == SA_SPILL) {
1234                 arc_release(db->db_buf, NULL);
1235                 arc_buf_thaw(db->db_buf);
1236         }
1237
1238         sa_hdr_phys->sa_magic = BSWAP_32(sa_hdr_phys->sa_magic);
1239         sa_hdr_phys->sa_layout_info = BSWAP_16(sa_hdr_phys->sa_layout_info);
1240
1241         /*
1242          * Determine number of variable lenghts in header
1243          * The standard 8 byte header has one for free and a
1244          * 16 byte header would have 4 + 1;
1245          */
1246         if (SA_HDR_SIZE(sa_hdr_phys) > 8)
1247                 num_lengths += (SA_HDR_SIZE(sa_hdr_phys) - 8) >> 1;
1248         for (i = 0; i != num_lengths; i++)
1249                 sa_hdr_phys->sa_lengths[i] =
1250                     BSWAP_16(sa_hdr_phys->sa_lengths[i]);
1251
1252         sa_attr_iter(hdl->sa_os, sa_hdr_phys, DMU_OT_SA,
1253             sa_byteswap_cb, NULL, hdl);
1254
1255         if (buftype == SA_SPILL)
1256                 arc_buf_freeze(((dmu_buf_impl_t *)hdl->sa_spill)->db_buf);
1257 }
1258
1259 static int
1260 sa_build_index(sa_handle_t *hdl, sa_buf_type_t buftype)
1261 {
1262         sa_hdr_phys_t *sa_hdr_phys;
1263         dmu_buf_impl_t *db = SA_GET_DB(hdl, buftype);
1264         dmu_object_type_t bonustype = SA_BONUSTYPE_FROM_DB(db);
1265         sa_os_t *sa = hdl->sa_os->os_sa;
1266         sa_idx_tab_t *idx_tab;
1267
1268         sa_hdr_phys = SA_GET_HDR(hdl, buftype);
1269
1270         mutex_enter(&sa->sa_lock);
1271
1272         /* Do we need to byteswap? */
1273
1274         /* only check if not old znode */
1275         if (IS_SA_BONUSTYPE(bonustype) && sa_hdr_phys->sa_magic != SA_MAGIC &&
1276             sa_hdr_phys->sa_magic != 0) {
1277                 VERIFY(BSWAP_32(sa_hdr_phys->sa_magic) == SA_MAGIC);
1278                 sa_byteswap(hdl, buftype);
1279         }
1280
1281         idx_tab = sa_find_idx_tab(hdl->sa_os, bonustype, sa_hdr_phys);
1282
1283         if (buftype == SA_BONUS)
1284                 hdl->sa_bonus_tab = idx_tab;
1285         else
1286                 hdl->sa_spill_tab = idx_tab;
1287
1288         mutex_exit(&sa->sa_lock);
1289         return (0);
1290 }
1291
1292 /*ARGSUSED*/
1293 static void
1294 sa_evict_sync(void *dbu)
1295 {
1296         panic("evicting sa dbuf\n");
1297 }
1298
1299 static void
1300 sa_idx_tab_rele(objset_t *os, void *arg)
1301 {
1302         sa_os_t *sa = os->os_sa;
1303         sa_idx_tab_t *idx_tab = arg;
1304
1305         if (idx_tab == NULL)
1306                 return;
1307
1308         mutex_enter(&sa->sa_lock);
1309         if (refcount_remove(&idx_tab->sa_refcount, NULL) == 0) {
1310                 list_remove(&idx_tab->sa_layout->lot_idx_tab, idx_tab);
1311                 if (idx_tab->sa_variable_lengths)
1312                         kmem_free(idx_tab->sa_variable_lengths,
1313                             sizeof (uint16_t) *
1314                             idx_tab->sa_layout->lot_var_sizes);
1315                 refcount_destroy(&idx_tab->sa_refcount);
1316                 kmem_free(idx_tab->sa_idx_tab,
1317                     sizeof (uint32_t) * sa->sa_num_attrs);
1318                 kmem_free(idx_tab, sizeof (sa_idx_tab_t));
1319         }
1320         mutex_exit(&sa->sa_lock);
1321 }
1322
1323 static void
1324 sa_idx_tab_hold(objset_t *os, sa_idx_tab_t *idx_tab)
1325 {
1326         sa_os_t *sa = os->os_sa;
1327
1328         ASSERT(MUTEX_HELD(&sa->sa_lock));
1329         (void) refcount_add(&idx_tab->sa_refcount, NULL);
1330 }
1331
1332 void
1333 sa_handle_destroy(sa_handle_t *hdl)
1334 {
1335         dmu_buf_t *db = hdl->sa_bonus;
1336
1337         mutex_enter(&hdl->sa_lock);
1338         (void) dmu_buf_remove_user(db, &hdl->sa_dbu);
1339
1340         if (hdl->sa_bonus_tab)
1341                 sa_idx_tab_rele(hdl->sa_os, hdl->sa_bonus_tab);
1342
1343         if (hdl->sa_spill_tab)
1344                 sa_idx_tab_rele(hdl->sa_os, hdl->sa_spill_tab);
1345
1346         dmu_buf_rele(hdl->sa_bonus, NULL);
1347
1348         if (hdl->sa_spill)
1349                 dmu_buf_rele((dmu_buf_t *)hdl->sa_spill, NULL);
1350         mutex_exit(&hdl->sa_lock);
1351
1352         kmem_cache_free(sa_cache, hdl);
1353 }
1354
1355 int
1356 sa_handle_get_from_db(objset_t *os, dmu_buf_t *db, void *userp,
1357     sa_handle_type_t hdl_type, sa_handle_t **handlepp)
1358 {
1359         int error = 0;
1360         dmu_object_info_t doi;
1361         sa_handle_t *handle = NULL;
1362
1363 #ifdef ZFS_DEBUG
1364         dmu_object_info_from_db(db, &doi);
1365         ASSERT(doi.doi_bonus_type == DMU_OT_SA ||
1366             doi.doi_bonus_type == DMU_OT_ZNODE);
1367 #endif
1368         /* find handle, if it exists */
1369         /* if one doesn't exist then create a new one, and initialize it */
1370
1371         if (hdl_type == SA_HDL_SHARED)
1372                 handle = dmu_buf_get_user(db);
1373
1374         if (handle == NULL) {
1375                 sa_handle_t *winner = NULL;
1376
1377                 handle = kmem_cache_alloc(sa_cache, KM_SLEEP);
1378                 handle->sa_dbu.dbu_evict_func_sync = NULL;
1379                 handle->sa_dbu.dbu_evict_func_async = NULL;
1380                 handle->sa_userp = userp;
1381                 handle->sa_bonus = db;
1382                 handle->sa_os = os;
1383                 handle->sa_spill = NULL;
1384                 handle->sa_bonus_tab = NULL;
1385                 handle->sa_spill_tab = NULL;
1386
1387                 error = sa_build_index(handle, SA_BONUS);
1388
1389                 if (hdl_type == SA_HDL_SHARED) {
1390                         dmu_buf_init_user(&handle->sa_dbu, sa_evict_sync, NULL,
1391                             NULL);
1392                         winner = dmu_buf_set_user_ie(db, &handle->sa_dbu);
1393                 }
1394
1395                 if (winner != NULL) {
1396                         kmem_cache_free(sa_cache, handle);
1397                         handle = winner;
1398                 }
1399         }
1400         *handlepp = handle;
1401
1402         return (error);
1403 }
1404
1405 int
1406 sa_handle_get(objset_t *objset, uint64_t objid, void *userp,
1407     sa_handle_type_t hdl_type, sa_handle_t **handlepp)
1408 {
1409         dmu_buf_t *db;
1410         int error;
1411
1412         if (error = dmu_bonus_hold(objset, objid, NULL, &db))
1413                 return (error);
1414
1415         return (sa_handle_get_from_db(objset, db, userp, hdl_type,
1416             handlepp));
1417 }
1418
1419 int
1420 sa_buf_hold(objset_t *objset, uint64_t obj_num, void *tag, dmu_buf_t **db)
1421 {
1422         return (dmu_bonus_hold(objset, obj_num, tag, db));
1423 }
1424
1425 void
1426 sa_buf_rele(dmu_buf_t *db, void *tag)
1427 {
1428         dmu_buf_rele(db, tag);
1429 }
1430
1431 int
1432 sa_lookup_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count)
1433 {
1434         ASSERT(hdl);
1435         ASSERT(MUTEX_HELD(&hdl->sa_lock));
1436         return (sa_attr_op(hdl, bulk, count, SA_LOOKUP, NULL));
1437 }
1438
1439 int
1440 sa_lookup(sa_handle_t *hdl, sa_attr_type_t attr, void *buf, uint32_t buflen)
1441 {
1442         int error;
1443         sa_bulk_attr_t bulk;
1444
1445         bulk.sa_attr = attr;
1446         bulk.sa_data = buf;
1447         bulk.sa_length = buflen;
1448         bulk.sa_data_func = NULL;
1449
1450         ASSERT(hdl);
1451         mutex_enter(&hdl->sa_lock);
1452         error = sa_lookup_impl(hdl, &bulk, 1);
1453         mutex_exit(&hdl->sa_lock);
1454         return (error);
1455 }
1456
1457 #ifdef _KERNEL
1458 int
1459 sa_lookup_uio(sa_handle_t *hdl, sa_attr_type_t attr, uio_t *uio)
1460 {
1461         int error;
1462         sa_bulk_attr_t bulk;
1463
1464         bulk.sa_data = NULL;
1465         bulk.sa_attr = attr;
1466         bulk.sa_data_func = NULL;
1467
1468         ASSERT(hdl);
1469
1470         mutex_enter(&hdl->sa_lock);
1471         if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) == 0) {
1472                 error = uiomove((void *)bulk.sa_addr, MIN(bulk.sa_size,
1473                     uio->uio_resid), UIO_READ, uio);
1474         }
1475         mutex_exit(&hdl->sa_lock);
1476         return (error);
1477
1478 }
1479 #endif
1480
1481 static sa_idx_tab_t *
1482 sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype, sa_hdr_phys_t *hdr)
1483 {
1484         sa_idx_tab_t *idx_tab;
1485         sa_os_t *sa = os->os_sa;
1486         sa_lot_t *tb, search;
1487         avl_index_t loc;
1488
1489         /*
1490          * Deterimine layout number.  If SA node and header == 0 then
1491          * force the index table to the dummy "1" empty layout.
1492          *
1493          * The layout number would only be zero for a newly created file
1494          * that has not added any attributes yet, or with crypto enabled which
1495          * doesn't write any attributes to the bonus buffer.
1496          */
1497
1498         search.lot_num = SA_LAYOUT_NUM(hdr, bonustype);
1499
1500         tb = avl_find(&sa->sa_layout_num_tree, &search, &loc);
1501
1502         /* Verify header size is consistent with layout information */
1503         ASSERT(tb);
1504         ASSERT(IS_SA_BONUSTYPE(bonustype) &&
1505             SA_HDR_SIZE_MATCH_LAYOUT(hdr, tb) || !IS_SA_BONUSTYPE(bonustype) ||
1506             (IS_SA_BONUSTYPE(bonustype) && hdr->sa_layout_info == 0));
1507
1508         /*
1509          * See if any of the already existing TOC entries can be reused?
1510          */
1511
1512         for (idx_tab = list_head(&tb->lot_idx_tab); idx_tab;
1513             idx_tab = list_next(&tb->lot_idx_tab, idx_tab)) {
1514                 boolean_t valid_idx = B_TRUE;
1515                 int i;
1516
1517                 if (tb->lot_var_sizes != 0 &&
1518                     idx_tab->sa_variable_lengths != NULL) {
1519                         for (i = 0; i != tb->lot_var_sizes; i++) {
1520                                 if (hdr->sa_lengths[i] !=
1521                                     idx_tab->sa_variable_lengths[i]) {
1522                                         valid_idx = B_FALSE;
1523                                         break;
1524                                 }
1525                         }
1526                 }
1527                 if (valid_idx) {
1528                         sa_idx_tab_hold(os, idx_tab);
1529                         return (idx_tab);
1530                 }
1531         }
1532
1533         /* No such luck, create a new entry */
1534         idx_tab = kmem_zalloc(sizeof (sa_idx_tab_t), KM_SLEEP);
1535         idx_tab->sa_idx_tab =
1536             kmem_zalloc(sizeof (uint32_t) * sa->sa_num_attrs, KM_SLEEP);
1537         idx_tab->sa_layout = tb;
1538         refcount_create(&idx_tab->sa_refcount);
1539         if (tb->lot_var_sizes)
1540                 idx_tab->sa_variable_lengths = kmem_alloc(sizeof (uint16_t) *
1541                     tb->lot_var_sizes, KM_SLEEP);
1542
1543         sa_attr_iter(os, hdr, bonustype, sa_build_idx_tab,
1544             tb, idx_tab);
1545         sa_idx_tab_hold(os, idx_tab);   /* one hold for consumer */
1546         sa_idx_tab_hold(os, idx_tab);   /* one for layout */
1547         list_insert_tail(&tb->lot_idx_tab, idx_tab);
1548         return (idx_tab);
1549 }
1550
1551 void
1552 sa_default_locator(void **dataptr, uint32_t *len, uint32_t total_len,
1553     boolean_t start, void *userdata)
1554 {
1555         ASSERT(start);
1556
1557         *dataptr = userdata;
1558         *len = total_len;
1559 }
1560
1561 static void
1562 sa_attr_register_sync(sa_handle_t *hdl, dmu_tx_t *tx)
1563 {
1564         uint64_t attr_value = 0;
1565         sa_os_t *sa = hdl->sa_os->os_sa;
1566         sa_attr_table_t *tb = sa->sa_attr_table;
1567         int i;
1568
1569         mutex_enter(&sa->sa_lock);
1570
1571         if (!sa->sa_need_attr_registration || sa->sa_master_obj == 0) {
1572                 mutex_exit(&sa->sa_lock);
1573                 return;
1574         }
1575
1576         if (sa->sa_reg_attr_obj == 0) {
1577                 sa->sa_reg_attr_obj = zap_create_link(hdl->sa_os,
1578                     DMU_OT_SA_ATTR_REGISTRATION,
1579                     sa->sa_master_obj, SA_REGISTRY, tx);
1580         }
1581         for (i = 0; i != sa->sa_num_attrs; i++) {
1582                 if (sa->sa_attr_table[i].sa_registered)
1583                         continue;
1584                 ATTR_ENCODE(attr_value, tb[i].sa_attr, tb[i].sa_length,
1585                     tb[i].sa_byteswap);
1586                 VERIFY(0 == zap_update(hdl->sa_os, sa->sa_reg_attr_obj,
1587                     tb[i].sa_name, 8, 1, &attr_value, tx));
1588                 tb[i].sa_registered = B_TRUE;
1589         }
1590         sa->sa_need_attr_registration = B_FALSE;
1591         mutex_exit(&sa->sa_lock);
1592 }
1593
1594 /*
1595  * Replace all attributes with attributes specified in template.
1596  * If dnode had a spill buffer then those attributes will be
1597  * also be replaced, possibly with just an empty spill block
1598  *
1599  * This interface is intended to only be used for bulk adding of
1600  * attributes for a new file.  It will also be used by the ZPL
1601  * when converting and old formatted znode to native SA support.
1602  */
1603 int
1604 sa_replace_all_by_template_locked(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc,
1605     int attr_count, dmu_tx_t *tx)
1606 {
1607         sa_os_t *sa = hdl->sa_os->os_sa;
1608
1609         if (sa->sa_need_attr_registration)
1610                 sa_attr_register_sync(hdl, tx);
1611         return (sa_build_layouts(hdl, attr_desc, attr_count, tx));
1612 }
1613
1614 int
1615 sa_replace_all_by_template(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc,
1616     int attr_count, dmu_tx_t *tx)
1617 {
1618         int error;
1619
1620         mutex_enter(&hdl->sa_lock);
1621         error = sa_replace_all_by_template_locked(hdl, attr_desc,
1622             attr_count, tx);
1623         mutex_exit(&hdl->sa_lock);
1624         return (error);
1625 }
1626
1627 /*
1628  * Add/remove a single attribute or replace a variable-sized attribute value
1629  * with a value of a different size, and then rewrite the entire set
1630  * of attributes.
1631  * Same-length attribute value replacement (including fixed-length attributes)
1632  * is handled more efficiently by the upper layers.
1633  */
1634 static int
1635 sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr,
1636     sa_data_op_t action, sa_data_locator_t *locator, void *datastart,
1637     uint16_t buflen, dmu_tx_t *tx)
1638 {
1639         sa_os_t *sa = hdl->sa_os->os_sa;
1640         dmu_buf_impl_t *db = (dmu_buf_impl_t *)hdl->sa_bonus;
1641         dnode_t *dn;
1642         sa_bulk_attr_t *attr_desc;
1643         void *old_data[2];
1644         int bonus_attr_count = 0;
1645         int bonus_data_size = 0;
1646         int spill_data_size = 0;
1647         int spill_attr_count = 0;
1648         int error;
1649         uint16_t length, reg_length;
1650         int i, j, k, length_idx;
1651         sa_hdr_phys_t *hdr;
1652         sa_idx_tab_t *idx_tab;
1653         int attr_count;
1654         int count;
1655
1656         ASSERT(MUTEX_HELD(&hdl->sa_lock));
1657
1658         /* First make of copy of the old data */
1659
1660         DB_DNODE_ENTER(db);
1661         dn = DB_DNODE(db);
1662         if (dn->dn_bonuslen != 0) {
1663                 bonus_data_size = hdl->sa_bonus->db_size;
1664                 old_data[0] = kmem_alloc(bonus_data_size, KM_SLEEP);
1665                 bcopy(hdl->sa_bonus->db_data, old_data[0],
1666                     hdl->sa_bonus->db_size);
1667                 bonus_attr_count = hdl->sa_bonus_tab->sa_layout->lot_attr_count;
1668         } else {
1669                 old_data[0] = NULL;
1670         }
1671         DB_DNODE_EXIT(db);
1672
1673         /* Bring spill buffer online if it isn't currently */
1674
1675         if ((error = sa_get_spill(hdl)) == 0) {
1676                 spill_data_size = hdl->sa_spill->db_size;
1677                 old_data[1] = kmem_alloc(spill_data_size, KM_SLEEP);
1678                 bcopy(hdl->sa_spill->db_data, old_data[1],
1679                     hdl->sa_spill->db_size);
1680                 spill_attr_count =
1681                     hdl->sa_spill_tab->sa_layout->lot_attr_count;
1682         } else if (error && error != ENOENT) {
1683                 if (old_data[0])
1684                         kmem_free(old_data[0], bonus_data_size);
1685                 return (error);
1686         } else {
1687                 old_data[1] = NULL;
1688         }
1689
1690         /* build descriptor of all attributes */
1691
1692         attr_count = bonus_attr_count + spill_attr_count;
1693         if (action == SA_ADD)
1694                 attr_count++;
1695         else if (action == SA_REMOVE)
1696                 attr_count--;
1697
1698         attr_desc = kmem_zalloc(sizeof (sa_bulk_attr_t) * attr_count, KM_SLEEP);
1699
1700         /*
1701          * loop through bonus and spill buffer if it exists, and
1702          * build up new attr_descriptor to reset the attributes
1703          */
1704         k = j = 0;
1705         count = bonus_attr_count;
1706         hdr = SA_GET_HDR(hdl, SA_BONUS);
1707         idx_tab = SA_IDX_TAB_GET(hdl, SA_BONUS);
1708         for (; k != 2; k++) {
1709                 /*
1710                  * Iterate over each attribute in layout.  Fetch the
1711                  * size of variable-length attributes needing rewrite
1712                  * from sa_lengths[].
1713                  */
1714                 for (i = 0, length_idx = 0; i != count; i++) {
1715                         sa_attr_type_t attr;
1716
1717                         attr = idx_tab->sa_layout->lot_attrs[i];
1718                         reg_length = SA_REGISTERED_LEN(sa, attr);
1719                         if (reg_length == 0) {
1720                                 length = hdr->sa_lengths[length_idx];
1721                                 length_idx++;
1722                         } else {
1723                                 length = reg_length;
1724                         }
1725                         if (attr == newattr) {
1726                                 /*
1727                                  * There is nothing to do for SA_REMOVE,
1728                                  * so it is just skipped.
1729                                  */
1730                                 if (action == SA_REMOVE)
1731                                         continue;
1732
1733                                 /*
1734                                  * Duplicate attributes are not allowed, so the
1735                                  * action can not be SA_ADD here.
1736                                  */
1737                                 ASSERT3S(action, ==, SA_REPLACE);
1738
1739                                 /*
1740                                  * Only a variable-sized attribute can be
1741                                  * replaced here, and its size must be changing.
1742                                  */
1743                                 ASSERT3U(reg_length, ==, 0);
1744                                 ASSERT3U(length, !=, buflen);
1745                                 SA_ADD_BULK_ATTR(attr_desc, j, attr,
1746                                     locator, datastart, buflen);
1747                         } else {
1748                                 SA_ADD_BULK_ATTR(attr_desc, j, attr,
1749                                     NULL, (void *)
1750                                     (TOC_OFF(idx_tab->sa_idx_tab[attr]) +
1751                                     (uintptr_t)old_data[k]), length);
1752                         }
1753                 }
1754                 if (k == 0 && hdl->sa_spill) {
1755                         hdr = SA_GET_HDR(hdl, SA_SPILL);
1756                         idx_tab = SA_IDX_TAB_GET(hdl, SA_SPILL);
1757                         count = spill_attr_count;
1758                 } else {
1759                         break;
1760                 }
1761         }
1762         if (action == SA_ADD) {
1763                 reg_length = SA_REGISTERED_LEN(sa, newattr);
1764                 IMPLY(reg_length != 0, reg_length == buflen);
1765                 SA_ADD_BULK_ATTR(attr_desc, j, newattr, locator,
1766                     datastart, buflen);
1767         }
1768         ASSERT3U(j, ==, attr_count);
1769
1770         error = sa_build_layouts(hdl, attr_desc, attr_count, tx);
1771
1772         if (old_data[0])
1773                 kmem_free(old_data[0], bonus_data_size);
1774         if (old_data[1])
1775                 kmem_free(old_data[1], spill_data_size);
1776         kmem_free(attr_desc, sizeof (sa_bulk_attr_t) * attr_count);
1777
1778         return (error);
1779 }
1780
1781 static int
1782 sa_bulk_update_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count,
1783     dmu_tx_t *tx)
1784 {
1785         int error;
1786         sa_os_t *sa = hdl->sa_os->os_sa;
1787         dmu_object_type_t bonustype;
1788
1789         bonustype = SA_BONUSTYPE_FROM_DB(SA_GET_DB(hdl, SA_BONUS));
1790
1791         ASSERT(hdl);
1792         ASSERT(MUTEX_HELD(&hdl->sa_lock));
1793
1794         /* sync out registration table if necessary */
1795         if (sa->sa_need_attr_registration)
1796                 sa_attr_register_sync(hdl, tx);
1797
1798         error = sa_attr_op(hdl, bulk, count, SA_UPDATE, tx);
1799         if (error == 0 && !IS_SA_BONUSTYPE(bonustype) && sa->sa_update_cb)
1800                 sa->sa_update_cb(hdl, tx);
1801
1802         return (error);
1803 }
1804
1805 /*
1806  * update or add new attribute
1807  */
1808 int
1809 sa_update(sa_handle_t *hdl, sa_attr_type_t type,
1810     void *buf, uint32_t buflen, dmu_tx_t *tx)
1811 {
1812         int error;
1813         sa_bulk_attr_t bulk;
1814
1815         bulk.sa_attr = type;
1816         bulk.sa_data_func = NULL;
1817         bulk.sa_length = buflen;
1818         bulk.sa_data = buf;
1819
1820         mutex_enter(&hdl->sa_lock);
1821         error = sa_bulk_update_impl(hdl, &bulk, 1, tx);
1822         mutex_exit(&hdl->sa_lock);
1823         return (error);
1824 }
1825
1826 int
1827 sa_update_from_cb(sa_handle_t *hdl, sa_attr_type_t attr,
1828     uint32_t buflen, sa_data_locator_t *locator, void *userdata, dmu_tx_t *tx)
1829 {
1830         int error;
1831         sa_bulk_attr_t bulk;
1832
1833         bulk.sa_attr = attr;
1834         bulk.sa_data = userdata;
1835         bulk.sa_data_func = locator;
1836         bulk.sa_length = buflen;
1837
1838         mutex_enter(&hdl->sa_lock);
1839         error = sa_bulk_update_impl(hdl, &bulk, 1, tx);
1840         mutex_exit(&hdl->sa_lock);
1841         return (error);
1842 }
1843
1844 /*
1845  * Return size of an attribute
1846  */
1847
1848 int
1849 sa_size(sa_handle_t *hdl, sa_attr_type_t attr, int *size)
1850 {
1851         sa_bulk_attr_t bulk;
1852         int error;
1853
1854         bulk.sa_data = NULL;
1855         bulk.sa_attr = attr;
1856         bulk.sa_data_func = NULL;
1857
1858         ASSERT(hdl);
1859         mutex_enter(&hdl->sa_lock);
1860         if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) != 0) {
1861                 mutex_exit(&hdl->sa_lock);
1862                 return (error);
1863         }
1864         *size = bulk.sa_size;
1865
1866         mutex_exit(&hdl->sa_lock);
1867         return (0);
1868 }
1869
1870 int
1871 sa_bulk_lookup_locked(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count)
1872 {
1873         ASSERT(hdl);
1874         ASSERT(MUTEX_HELD(&hdl->sa_lock));
1875         return (sa_lookup_impl(hdl, attrs, count));
1876 }
1877
1878 int
1879 sa_bulk_lookup(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count)
1880 {
1881         int error;
1882
1883         ASSERT(hdl);
1884         mutex_enter(&hdl->sa_lock);
1885         error = sa_bulk_lookup_locked(hdl, attrs, count);
1886         mutex_exit(&hdl->sa_lock);
1887         return (error);
1888 }
1889
1890 int
1891 sa_bulk_update(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count, dmu_tx_t *tx)
1892 {
1893         int error;
1894
1895         ASSERT(hdl);
1896         mutex_enter(&hdl->sa_lock);
1897         error = sa_bulk_update_impl(hdl, attrs, count, tx);
1898         mutex_exit(&hdl->sa_lock);
1899         return (error);
1900 }
1901
1902 int
1903 sa_remove(sa_handle_t *hdl, sa_attr_type_t attr, dmu_tx_t *tx)
1904 {
1905         int error;
1906
1907         mutex_enter(&hdl->sa_lock);
1908         error = sa_modify_attrs(hdl, attr, SA_REMOVE, NULL,
1909             NULL, 0, tx);
1910         mutex_exit(&hdl->sa_lock);
1911         return (error);
1912 }
1913
1914 void
1915 sa_object_info(sa_handle_t *hdl, dmu_object_info_t *doi)
1916 {
1917         dmu_object_info_from_db((dmu_buf_t *)hdl->sa_bonus, doi);
1918 }
1919
1920 void
1921 sa_object_size(sa_handle_t *hdl, uint32_t *blksize, u_longlong_t *nblocks)
1922 {
1923         dmu_object_size_from_db((dmu_buf_t *)hdl->sa_bonus,
1924             blksize, nblocks);
1925 }
1926
1927 void
1928 sa_set_userp(sa_handle_t *hdl, void *ptr)
1929 {
1930         hdl->sa_userp = ptr;
1931 }
1932
1933 dmu_buf_t *
1934 sa_get_db(sa_handle_t *hdl)
1935 {
1936         return ((dmu_buf_t *)hdl->sa_bonus);
1937 }
1938
1939 void *
1940 sa_get_userdata(sa_handle_t *hdl)
1941 {
1942         return (hdl->sa_userp);
1943 }
1944
1945 void
1946 sa_register_update_callback_locked(objset_t *os, sa_update_cb_t *func)
1947 {
1948         ASSERT(MUTEX_HELD(&os->os_sa->sa_lock));
1949         os->os_sa->sa_update_cb = func;
1950 }
1951
1952 void
1953 sa_register_update_callback(objset_t *os, sa_update_cb_t *func)
1954 {
1955
1956         mutex_enter(&os->os_sa->sa_lock);
1957         sa_register_update_callback_locked(os, func);
1958         mutex_exit(&os->os_sa->sa_lock);
1959 }
1960
1961 uint64_t
1962 sa_handle_object(sa_handle_t *hdl)
1963 {
1964         return (hdl->sa_bonus->db_object);
1965 }
1966
1967 boolean_t
1968 sa_enabled(objset_t *os)
1969 {
1970         return (os->os_sa == NULL);
1971 }
1972
1973 int
1974 sa_set_sa_object(objset_t *os, uint64_t sa_object)
1975 {
1976         sa_os_t *sa = os->os_sa;
1977
1978         if (sa->sa_master_obj)
1979                 return (1);
1980
1981         sa->sa_master_obj = sa_object;
1982
1983         return (0);
1984 }
1985
1986 int
1987 sa_hdrsize(void *arg)
1988 {
1989         sa_hdr_phys_t *hdr = arg;
1990
1991         return (SA_HDR_SIZE(hdr));
1992 }
1993
1994 void
1995 sa_handle_lock(sa_handle_t *hdl)
1996 {
1997         ASSERT(hdl);
1998         mutex_enter(&hdl->sa_lock);
1999 }
2000
2001 void
2002 sa_handle_unlock(sa_handle_t *hdl)
2003 {
2004         ASSERT(hdl);
2005         mutex_exit(&hdl->sa_lock);
2006 }