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 123typedef void (sa_iterfunc_t)(void *hdr, void *addr, sa_attr_type_t, 124 uint16_t length, int length_idx, boolean_t, void *userp); 125 126static int sa_build_index(sa_handle_t *hdl, sa_buf_type_t buftype); 127static void sa_idx_tab_hold(objset_t *os, sa_idx_tab_t *idx_tab); 128static void *sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype, 129 void *data); 130static void sa_idx_tab_rele(objset_t *os, void *arg); 131static void sa_copy_data(sa_data_locator_t *func, void *start, void *target, 132 int buflen); 133static 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 137arc_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 */ 169sa_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 */ 192sa_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 200sa_attr_type_t sa_dummy_zpl_layout[] = { 0 }; 201 202static int sa_legacy_attr_count = 16; 203static kmem_cache_t *sa_cache = NULL; 204 205/*ARGSUSED*/ 206static int 207sa_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*/ 222static void 223sa_cache_destructor(void *buf, void *unused) 224{ 225 sa_handle_t *hdl = buf; 226 mutex_destroy(&hdl->sa_lock); 227} 228 229void 230sa_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 237void 238sa_cache_fini(void) 239{ 240 if (sa_cache) 241 kmem_cache_destroy(sa_cache); 242} 243 244static int 245layout_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 257static int 258layout_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 274boolean_t 275sa_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 291static uint64_t 292sa_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 303static int 304sa_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 */ 324int 325sa_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 406static sa_lot_t * 407sa_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 464static void 465sa_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 494static int 495sa_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 514static void 515sa_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 */ 547static int 548sa_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 614next: 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 */ 631static int 632sa_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 789static void 790sa_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 809static int 810sa_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); 962bail: 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 969int 970sa_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); 1082fail: 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 1092void 1093sa_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 1128void 1129sa_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 1142static void 1143sa_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*/ 1192void 1193sa_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 1202void 1203sa_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 1243static int 1244sa_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*/ 1277void 1278sa_evict(dmu_buf_t *db, void *sap) 1279{ 1280 panic("evicting sa dbuf %p\n", (void *)db); 1281} 1282 1283static void 1284sa_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 1307static void 1308sa_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 1316void 1317sa_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 1341int 1342sa_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 1381int 1382sa_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 1395int 1396sa_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 1401void 1402sa_buf_rele(dmu_buf_t *db, void *tag) 1403{ 1404 dmu_buf_rele(db, tag); 1405} 1406 1407int 1408sa_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 1415int 1416sa_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 1434int 1435sa_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 1457void * 1458sa_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 1528void 1529sa_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 1538static void 1539sa_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 == NULL) { 1549 mutex_exit(&sa->sa_lock); 1550 return; 1551 } 1552 1553 if (sa->sa_reg_attr_obj == NULL) { 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 */ 1581int 1582sa_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 1592int 1593sa_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 */ 1609static int 1610sa_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 1737static int 1738sa_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 */ 1764int 1765sa_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 1782int 1783sa_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 1804int 1805sa_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 1826int 1827sa_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 1834int 1835sa_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 1846int 1847sa_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 1858int 1859sa_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 1870void 1871sa_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 1876void 1877sa_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 1883void 1884sa_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 1891void 1892sa_set_userp(sa_handle_t *hdl, void *ptr) 1893{ 1894 hdl->sa_userp = ptr; 1895} 1896 1897dmu_buf_t * 1898sa_get_db(sa_handle_t *hdl) 1899{ 1900 return ((dmu_buf_t *)hdl->sa_bonus); 1901} 1902 1903void * 1904sa_get_userdata(sa_handle_t *hdl) 1905{ 1906 return (hdl->sa_userp); 1907} 1908 1909void 1910sa_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 1916void 1917sa_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 1925uint64_t 1926sa_handle_object(sa_handle_t *hdl) 1927{ 1928 return (hdl->sa_bonus->db_object); 1929} 1930 1931boolean_t 1932sa_enabled(objset_t *os) 1933{ 1934 return (os->os_sa == NULL); 1935} 1936 1937int 1938sa_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 1950int 1951sa_hdrsize(void *arg) 1952{ 1953 sa_hdr_phys_t *hdr = arg; 1954 1955 return (SA_HDR_SIZE(hdr)); 1956} 1957 1958void 1959sa_handle_lock(sa_handle_t *hdl) 1960{ 1961 ASSERT(hdl); 1962 mutex_enter(&hdl->sa_lock); 1963} 1964 1965void 1966sa_handle_unlock(sa_handle_t *hdl) 1967{ 1968 ASSERT(hdl); 1969 mutex_exit(&hdl->sa_lock); 1970} 1971