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