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