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