sa.c revision 1.1
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, 2016 by Delphix. All rights reserved. 26 * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved. 27 * Copyright (c) 2014 Integros [integros.com] 28 */ 29 30#include <sys/zfs_context.h> 31#include <sys/types.h> 32#include <sys/param.h> 33#include <sys/systm.h> 34#include <sys/sysmacros.h> 35#include <sys/dmu.h> 36#include <sys/dmu_impl.h> 37#include <sys/dmu_objset.h> 38#include <sys/dbuf.h> 39#include <sys/dnode.h> 40#include <sys/zap.h> 41#include <sys/sa.h> 42#include <sys/sunddi.h> 43#include <sys/sa_impl.h> 44#include <sys/dnode.h> 45#include <sys/errno.h> 46#include <sys/zfs_context.h> 47 48/* 49 * ZFS System attributes: 50 * 51 * A generic mechanism to allow for arbitrary attributes 52 * to be stored in a dnode. The data will be stored in the bonus buffer of 53 * the dnode and if necessary a special "spill" block will be used to handle 54 * overflow situations. The spill block will be sized to fit the data 55 * from 512 - 128K. When a spill block is used the BP (blkptr_t) for the 56 * spill block is stored at the end of the current bonus buffer. Any 57 * attributes that would be in the way of the blkptr_t will be relocated 58 * into the spill block. 59 * 60 * Attribute registration: 61 * 62 * Stored persistently on a per dataset basis 63 * a mapping between attribute "string" names and their actual attribute 64 * numeric values, length, and byteswap function. The names are only used 65 * during registration. All attributes are known by their unique attribute 66 * id value. If an attribute can have a variable size then the value 67 * 0 will be used to indicate this. 68 * 69 * Attribute Layout: 70 * 71 * Attribute layouts are a way to compactly store multiple attributes, but 72 * without taking the overhead associated with managing each attribute 73 * individually. Since you will typically have the same set of attributes 74 * stored in the same order a single table will be used to represent that 75 * layout. The ZPL for example will usually have only about 10 different 76 * layouts (regular files, device files, symlinks, 77 * regular files + scanstamp, files/dir with extended attributes, and then 78 * you have the possibility of all of those minus ACL, because it would 79 * be kicked out into the spill block) 80 * 81 * Layouts are simply an array of the attributes and their 82 * ordering i.e. [0, 1, 4, 5, 2] 83 * 84 * Each distinct layout is given a unique layout number and that is whats 85 * stored in the header at the beginning of the SA data buffer. 86 * 87 * A layout only covers a single dbuf (bonus or spill). If a set of 88 * attributes is split up between the bonus buffer and a spill buffer then 89 * two different layouts will be used. This allows us to byteswap the 90 * spill without looking at the bonus buffer and keeps the on disk format of 91 * the bonus and spill buffer the same. 92 * 93 * Adding a single attribute will cause the entire set of attributes to 94 * be rewritten and could result in a new layout number being constructed 95 * as part of the rewrite if no such layout exists for the new set of 96 * attribues. The new attribute will be appended to the end of the already 97 * existing attributes. 98 * 99 * Both the attribute registration and attribute layout information are 100 * stored in normal ZAP attributes. Their should be a small number of 101 * known layouts and the set of attributes is assumed to typically be quite 102 * small. 103 * 104 * The registered attributes and layout "table" information is maintained 105 * in core and a special "sa_os_t" is attached to the objset_t. 106 * 107 * A special interface is provided to allow for quickly applying 108 * a large set of attributes at once. sa_replace_all_by_template() is 109 * used to set an array of attributes. This is used by the ZPL when 110 * creating a brand new file. The template that is passed into the function 111 * specifies the attribute, size for variable length attributes, location of 112 * data and special "data locator" function if the data isn't in a contiguous 113 * location. 114 * 115 * Byteswap implications: 116 * 117 * Since the SA attributes are not entirely self describing we can't do 118 * the normal byteswap processing. The special ZAP layout attribute and 119 * attribute registration attributes define the byteswap function and the 120 * size of the attributes, unless it is variable sized. 121 * The normal ZFS byteswapping infrastructure assumes you don't need 122 * to read any objects in order to do the necessary byteswapping. Whereas 123 * SA attributes can only be properly byteswapped if the dataset is opened 124 * and the layout/attribute ZAP attributes are available. Because of this 125 * the SA attributes will be byteswapped when they are first accessed by 126 * the SA code that will read the SA data. 127 */ 128 129typedef void (sa_iterfunc_t)(void *hdr, void *addr, sa_attr_type_t, 130 uint16_t length, int length_idx, boolean_t, void *userp); 131 132static int sa_build_index(sa_handle_t *hdl, sa_buf_type_t buftype); 133static void sa_idx_tab_hold(objset_t *os, sa_idx_tab_t *idx_tab); 134static void *sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype, 135 void *data); 136static void sa_idx_tab_rele(objset_t *os, void *arg); 137static void sa_copy_data(sa_data_locator_t *func, void *start, void *target, 138 int buflen); 139static int sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr, 140 sa_data_op_t action, sa_data_locator_t *locator, void *datastart, 141 uint16_t buflen, dmu_tx_t *tx); 142 143arc_byteswap_func_t *sa_bswap_table[] = { 144 byteswap_uint64_array, 145 byteswap_uint32_array, 146 byteswap_uint16_array, 147 byteswap_uint8_array, 148 zfs_acl_byteswap, 149}; 150 151#define SA_COPY_DATA(f, s, t, l) \ 152 { \ 153 if (f == NULL) { \ 154 if (l == 8) { \ 155 *(uint64_t *)t = *(uint64_t *)s; \ 156 } else if (l == 16) { \ 157 *(uint64_t *)t = *(uint64_t *)s; \ 158 *(uint64_t *)((uintptr_t)t + 8) = \ 159 *(uint64_t *)((uintptr_t)s + 8); \ 160 } else { \ 161 bcopy(s, t, l); \ 162 } \ 163 } else \ 164 sa_copy_data(f, s, t, l); \ 165 } 166 167/* 168 * This table is fixed and cannot be changed. Its purpose is to 169 * allow the SA code to work with both old/new ZPL file systems. 170 * It contains the list of legacy attributes. These attributes aren't 171 * stored in the "attribute" registry zap objects, since older ZPL file systems 172 * won't have the registry. Only objsets of type ZFS_TYPE_FILESYSTEM will 173 * use this static table. 174 */ 175sa_attr_reg_t sa_legacy_attrs[] = { 176 {"ZPL_ATIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 0}, 177 {"ZPL_MTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 1}, 178 {"ZPL_CTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 2}, 179 {"ZPL_CRTIME", sizeof (uint64_t) * 2, SA_UINT64_ARRAY, 3}, 180 {"ZPL_GEN", sizeof (uint64_t), SA_UINT64_ARRAY, 4}, 181 {"ZPL_MODE", sizeof (uint64_t), SA_UINT64_ARRAY, 5}, 182 {"ZPL_SIZE", sizeof (uint64_t), SA_UINT64_ARRAY, 6}, 183 {"ZPL_PARENT", sizeof (uint64_t), SA_UINT64_ARRAY, 7}, 184 {"ZPL_LINKS", sizeof (uint64_t), SA_UINT64_ARRAY, 8}, 185 {"ZPL_XATTR", sizeof (uint64_t), SA_UINT64_ARRAY, 9}, 186 {"ZPL_RDEV", sizeof (uint64_t), SA_UINT64_ARRAY, 10}, 187 {"ZPL_FLAGS", sizeof (uint64_t), SA_UINT64_ARRAY, 11}, 188 {"ZPL_UID", sizeof (uint64_t), SA_UINT64_ARRAY, 12}, 189 {"ZPL_GID", sizeof (uint64_t), SA_UINT64_ARRAY, 13}, 190 {"ZPL_PAD", sizeof (uint64_t) * 4, SA_UINT64_ARRAY, 14}, 191 {"ZPL_ZNODE_ACL", 88, SA_UINT8_ARRAY, 15}, 192}; 193 194/* 195 * This is only used for objects of type DMU_OT_ZNODE 196 */ 197sa_attr_type_t sa_legacy_zpl_layout[] = { 198 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 199}; 200 201/* 202 * Special dummy layout used for buffers with no attributes. 203 */ 204sa_attr_type_t sa_dummy_zpl_layout[] = { 0 }; 205 206static int sa_legacy_attr_count = 16; 207static kmem_cache_t *sa_cache = NULL; 208 209/*ARGSUSED*/ 210static int 211sa_cache_constructor(void *buf, void *unused, int kmflag) 212{ 213 sa_handle_t *hdl = buf; 214 215 mutex_init(&hdl->sa_lock, NULL, MUTEX_DEFAULT, NULL); 216 return (0); 217} 218 219/*ARGSUSED*/ 220static void 221sa_cache_destructor(void *buf, void *unused) 222{ 223 sa_handle_t *hdl = buf; 224 mutex_destroy(&hdl->sa_lock); 225} 226 227void 228sa_cache_init(void) 229{ 230 sa_cache = kmem_cache_create("sa_cache", 231 sizeof (sa_handle_t), 0, sa_cache_constructor, 232 sa_cache_destructor, NULL, NULL, NULL, 0); 233} 234 235void 236sa_cache_fini(void) 237{ 238 if (sa_cache) 239 kmem_cache_destroy(sa_cache); 240} 241 242static int 243layout_num_compare(const void *arg1, const void *arg2) 244{ 245 const sa_lot_t *node1 = arg1; 246 const sa_lot_t *node2 = arg2; 247 248 if (node1->lot_num > node2->lot_num) 249 return (1); 250 else if (node1->lot_num < node2->lot_num) 251 return (-1); 252 return (0); 253} 254 255static int 256layout_hash_compare(const void *arg1, const void *arg2) 257{ 258 const sa_lot_t *node1 = arg1; 259 const sa_lot_t *node2 = arg2; 260 261 if (node1->lot_hash > node2->lot_hash) 262 return (1); 263 if (node1->lot_hash < node2->lot_hash) 264 return (-1); 265 if (node1->lot_instance > node2->lot_instance) 266 return (1); 267 if (node1->lot_instance < node2->lot_instance) 268 return (-1); 269 return (0); 270} 271 272boolean_t 273sa_layout_equal(sa_lot_t *tbf, sa_attr_type_t *attrs, int count) 274{ 275 int i; 276 277 if (count != tbf->lot_attr_count) 278 return (1); 279 280 for (i = 0; i != count; i++) { 281 if (attrs[i] != tbf->lot_attrs[i]) 282 return (1); 283 } 284 return (0); 285} 286 287#define SA_ATTR_HASH(attr) (zfs_crc64_table[(-1ULL ^ attr) & 0xFF]) 288 289static uint64_t 290sa_layout_info_hash(sa_attr_type_t *attrs, int attr_count) 291{ 292 int i; 293 uint64_t crc = -1ULL; 294 295 for (i = 0; i != attr_count; i++) 296 crc ^= SA_ATTR_HASH(attrs[i]); 297 298 return (crc); 299} 300 301static int 302sa_get_spill(sa_handle_t *hdl) 303{ 304 int rc; 305 if (hdl->sa_spill == NULL) { 306 if ((rc = dmu_spill_hold_existing(hdl->sa_bonus, NULL, 307 &hdl->sa_spill)) == 0) 308 VERIFY(0 == sa_build_index(hdl, SA_SPILL)); 309 } else { 310 rc = 0; 311 } 312 313 return (rc); 314} 315 316/* 317 * Main attribute lookup/update function 318 * returns 0 for success or non zero for failures 319 * 320 * Operates on bulk array, first failure will abort further processing 321 */ 322int 323sa_attr_op(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count, 324 sa_data_op_t data_op, dmu_tx_t *tx) 325{ 326 sa_os_t *sa = hdl->sa_os->os_sa; 327 int i; 328 int error = 0; 329 sa_buf_type_t buftypes; 330 331 buftypes = 0; 332 333 ASSERT(count > 0); 334 for (i = 0; i != count; i++) { 335 ASSERT(bulk[i].sa_attr <= hdl->sa_os->os_sa->sa_num_attrs); 336 337 bulk[i].sa_addr = NULL; 338 /* First check the bonus buffer */ 339 340 if (hdl->sa_bonus_tab && TOC_ATTR_PRESENT( 341 hdl->sa_bonus_tab->sa_idx_tab[bulk[i].sa_attr])) { 342 SA_ATTR_INFO(sa, hdl->sa_bonus_tab, 343 SA_GET_HDR(hdl, SA_BONUS), 344 bulk[i].sa_attr, bulk[i], SA_BONUS, hdl); 345 if (tx && !(buftypes & SA_BONUS)) { 346 dmu_buf_will_dirty(hdl->sa_bonus, tx); 347 buftypes |= SA_BONUS; 348 } 349 } 350 if (bulk[i].sa_addr == NULL && 351 ((error = sa_get_spill(hdl)) == 0)) { 352 if (TOC_ATTR_PRESENT( 353 hdl->sa_spill_tab->sa_idx_tab[bulk[i].sa_attr])) { 354 SA_ATTR_INFO(sa, hdl->sa_spill_tab, 355 SA_GET_HDR(hdl, SA_SPILL), 356 bulk[i].sa_attr, bulk[i], SA_SPILL, hdl); 357 if (tx && !(buftypes & SA_SPILL) && 358 bulk[i].sa_size == bulk[i].sa_length) { 359 dmu_buf_will_dirty(hdl->sa_spill, tx); 360 buftypes |= SA_SPILL; 361 } 362 } 363 } 364 if (error && error != ENOENT) { 365 return ((error == ECKSUM) ? EIO : error); 366 } 367 368 switch (data_op) { 369 case SA_LOOKUP: 370 if (bulk[i].sa_addr == NULL) 371 return (SET_ERROR(ENOENT)); 372 if (bulk[i].sa_data) { 373 SA_COPY_DATA(bulk[i].sa_data_func, 374 bulk[i].sa_addr, bulk[i].sa_data, 375 bulk[i].sa_size); 376 } 377 continue; 378 379 case SA_UPDATE: 380 /* existing rewrite of attr */ 381 if (bulk[i].sa_addr && 382 bulk[i].sa_size == bulk[i].sa_length) { 383 SA_COPY_DATA(bulk[i].sa_data_func, 384 bulk[i].sa_data, bulk[i].sa_addr, 385 bulk[i].sa_length); 386 continue; 387 } else if (bulk[i].sa_addr) { /* attr size change */ 388 error = sa_modify_attrs(hdl, bulk[i].sa_attr, 389 SA_REPLACE, bulk[i].sa_data_func, 390 bulk[i].sa_data, bulk[i].sa_length, tx); 391 } else { /* adding new attribute */ 392 error = sa_modify_attrs(hdl, bulk[i].sa_attr, 393 SA_ADD, bulk[i].sa_data_func, 394 bulk[i].sa_data, bulk[i].sa_length, tx); 395 } 396 if (error) 397 return (error); 398 break; 399 } 400 } 401 return (error); 402} 403 404static sa_lot_t * 405sa_add_layout_entry(objset_t *os, sa_attr_type_t *attrs, int attr_count, 406 uint64_t lot_num, uint64_t hash, boolean_t zapadd, dmu_tx_t *tx) 407{ 408 sa_os_t *sa = os->os_sa; 409 sa_lot_t *tb, *findtb; 410 int i; 411 avl_index_t loc; 412 413 ASSERT(MUTEX_HELD(&sa->sa_lock)); 414 tb = kmem_zalloc(sizeof (sa_lot_t), KM_SLEEP); 415 tb->lot_attr_count = attr_count; 416 tb->lot_attrs = kmem_alloc(sizeof (sa_attr_type_t) * attr_count, 417 KM_SLEEP); 418 bcopy(attrs, tb->lot_attrs, sizeof (sa_attr_type_t) * attr_count); 419 tb->lot_num = lot_num; 420 tb->lot_hash = hash; 421 tb->lot_instance = 0; 422 423 if (zapadd) { 424 char attr_name[8]; 425 426 if (sa->sa_layout_attr_obj == 0) { 427 sa->sa_layout_attr_obj = zap_create_link(os, 428 DMU_OT_SA_ATTR_LAYOUTS, 429 sa->sa_master_obj, SA_LAYOUTS, tx); 430 } 431 432 (void) snprintf(attr_name, sizeof (attr_name), 433 "%d", (int)lot_num); 434 VERIFY(0 == zap_update(os, os->os_sa->sa_layout_attr_obj, 435 attr_name, 2, attr_count, attrs, tx)); 436 } 437 438 list_create(&tb->lot_idx_tab, sizeof (sa_idx_tab_t), 439 offsetof(sa_idx_tab_t, sa_next)); 440 441 for (i = 0; i != attr_count; i++) { 442 if (sa->sa_attr_table[tb->lot_attrs[i]].sa_length == 0) 443 tb->lot_var_sizes++; 444 } 445 446 avl_add(&sa->sa_layout_num_tree, tb); 447 448 /* verify we don't have a hash collision */ 449 if ((findtb = avl_find(&sa->sa_layout_hash_tree, tb, &loc)) != NULL) { 450 for (; findtb && findtb->lot_hash == hash; 451 findtb = AVL_NEXT(&sa->sa_layout_hash_tree, findtb)) { 452 if (findtb->lot_instance != tb->lot_instance) 453 break; 454 tb->lot_instance++; 455 } 456 } 457 avl_add(&sa->sa_layout_hash_tree, tb); 458 return (tb); 459} 460 461static void 462sa_find_layout(objset_t *os, uint64_t hash, sa_attr_type_t *attrs, 463 int count, dmu_tx_t *tx, sa_lot_t **lot) 464{ 465 sa_lot_t *tb, tbsearch; 466 avl_index_t loc; 467 sa_os_t *sa = os->os_sa; 468 boolean_t found = B_FALSE; 469 470 mutex_enter(&sa->sa_lock); 471 tbsearch.lot_hash = hash; 472 tbsearch.lot_instance = 0; 473 tb = avl_find(&sa->sa_layout_hash_tree, &tbsearch, &loc); 474 if (tb) { 475 for (; tb && tb->lot_hash == hash; 476 tb = AVL_NEXT(&sa->sa_layout_hash_tree, tb)) { 477 if (sa_layout_equal(tb, attrs, count) == 0) { 478 found = B_TRUE; 479 break; 480 } 481 } 482 } 483 if (!found) { 484 tb = sa_add_layout_entry(os, attrs, count, 485 avl_numnodes(&sa->sa_layout_num_tree), hash, B_TRUE, tx); 486 } 487 mutex_exit(&sa->sa_lock); 488 *lot = tb; 489} 490 491static int 492sa_resize_spill(sa_handle_t *hdl, uint32_t size, dmu_tx_t *tx) 493{ 494 int error; 495 uint32_t blocksize; 496 497 if (size == 0) { 498 blocksize = SPA_MINBLOCKSIZE; 499 } else if (size > SPA_OLD_MAXBLOCKSIZE) { 500 ASSERT(0); 501 return (SET_ERROR(EFBIG)); 502 } else { 503 blocksize = P2ROUNDUP_TYPED(size, SPA_MINBLOCKSIZE, uint32_t); 504 } 505 506 error = dbuf_spill_set_blksz(hdl->sa_spill, blocksize, tx); 507 ASSERT(error == 0); 508 return (error); 509} 510 511static void 512sa_copy_data(sa_data_locator_t *func, void *datastart, void *target, int buflen) 513{ 514 if (func == NULL) { 515 bcopy(datastart, target, buflen); 516 } else { 517 boolean_t start; 518 int bytes; 519 void *dataptr; 520 void *saptr = target; 521 uint32_t length; 522 523 start = B_TRUE; 524 bytes = 0; 525 while (bytes < buflen) { 526 func(&dataptr, &length, buflen, start, datastart); 527 bcopy(dataptr, saptr, length); 528 saptr = (void *)((caddr_t)saptr + length); 529 bytes += length; 530 start = B_FALSE; 531 } 532 } 533} 534 535/* 536 * Determine several different sizes 537 * first the sa header size 538 * the number of bytes to be stored 539 * if spill would occur the index in the attribute array is returned 540 * 541 * the boolean will_spill will be set when spilling is necessary. It 542 * is only set when the buftype is SA_BONUS 543 */ 544static int 545sa_find_sizes(sa_os_t *sa, sa_bulk_attr_t *attr_desc, int attr_count, 546 dmu_buf_t *db, sa_buf_type_t buftype, int *index, int *total, 547 boolean_t *will_spill) 548{ 549 int var_size = 0; 550 int i; 551 int full_space; 552 int hdrsize; 553 int extra_hdrsize; 554 555 if (buftype == SA_BONUS && sa->sa_force_spill) { 556 *total = 0; 557 *index = 0; 558 *will_spill = B_TRUE; 559 return (0); 560 } 561 562 *index = -1; 563 *total = 0; 564 *will_spill = B_FALSE; 565 566 extra_hdrsize = 0; 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 (*will_spill) 579 continue; 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 /* 588 * Don't worry that the spill block might overflow. 589 * It will be resized if needed in sa_build_layouts(). 590 */ 591 if (buftype == SA_SPILL || 592 P2ROUNDUP(hdrsize + sizeof (uint16_t), 8) + 593 *total < full_space) { 594 /* 595 * Account for header space used by array of 596 * optional sizes of variable-length attributes. 597 * Record the extra header size in case this 598 * increase needs to be reversed due to 599 * spill-over. 600 */ 601 hdrsize += sizeof (uint16_t); 602 if (*index != -1) 603 extra_hdrsize += sizeof (uint16_t); 604 } else { 605 ASSERT(buftype == SA_BONUS); 606 if (*index == -1) 607 *index = i; 608 *will_spill = B_TRUE; 609 continue; 610 } 611 } 612 613 /* 614 * find index of where spill *could* occur. 615 * Then continue to count of remainder attribute 616 * space. The sum is used later for sizing bonus 617 * and spill buffer. 618 */ 619 if (buftype == SA_BONUS && *index == -1 && 620 (*total + P2ROUNDUP(hdrsize, 8)) > 621 (full_space - sizeof (blkptr_t))) { 622 *index = i; 623 } 624 625 if ((*total + P2ROUNDUP(hdrsize, 8)) > full_space && 626 buftype == SA_BONUS) 627 *will_spill = B_TRUE; 628 } 629 630 if (*will_spill) 631 hdrsize -= extra_hdrsize; 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*/ 1301static void 1302sa_evict_sync(void *dbu) 1303{ 1304 panic("evicting sa dbuf\n"); 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 dmu_buf_t *db = hdl->sa_bonus; 1344 1345 mutex_enter(&hdl->sa_lock); 1346 (void) dmu_buf_remove_user(db, &hdl->sa_dbu); 1347 1348 if (hdl->sa_bonus_tab) 1349 sa_idx_tab_rele(hdl->sa_os, hdl->sa_bonus_tab); 1350 1351 if (hdl->sa_spill_tab) 1352 sa_idx_tab_rele(hdl->sa_os, hdl->sa_spill_tab); 1353 1354 dmu_buf_rele(hdl->sa_bonus, NULL); 1355 1356 if (hdl->sa_spill) 1357 dmu_buf_rele((dmu_buf_t *)hdl->sa_spill, NULL); 1358 mutex_exit(&hdl->sa_lock); 1359 1360 kmem_cache_free(sa_cache, hdl); 1361} 1362 1363int 1364sa_handle_get_from_db(objset_t *os, dmu_buf_t *db, void *userp, 1365 sa_handle_type_t hdl_type, sa_handle_t **handlepp) 1366{ 1367 int error = 0; 1368 dmu_object_info_t doi; 1369 sa_handle_t *handle = NULL; 1370 1371#ifdef ZFS_DEBUG 1372 dmu_object_info_from_db(db, &doi); 1373 ASSERT(doi.doi_bonus_type == DMU_OT_SA || 1374 doi.doi_bonus_type == DMU_OT_ZNODE); 1375#endif 1376 /* find handle, if it exists */ 1377 /* if one doesn't exist then create a new one, and initialize it */ 1378 1379 if (hdl_type == SA_HDL_SHARED) 1380 handle = dmu_buf_get_user(db); 1381 1382 if (handle == NULL) { 1383 sa_handle_t *winner = NULL; 1384 1385 handle = kmem_cache_alloc(sa_cache, KM_SLEEP); 1386 handle->sa_dbu.dbu_evict_func_sync = NULL; 1387 handle->sa_dbu.dbu_evict_func_async = NULL; 1388 handle->sa_userp = userp; 1389 handle->sa_bonus = db; 1390 handle->sa_os = os; 1391 handle->sa_spill = NULL; 1392 handle->sa_bonus_tab = NULL; 1393 handle->sa_spill_tab = NULL; 1394 1395 error = sa_build_index(handle, SA_BONUS); 1396 1397 if (hdl_type == SA_HDL_SHARED) { 1398 dmu_buf_init_user(&handle->sa_dbu, sa_evict_sync, NULL, 1399 NULL); 1400 winner = dmu_buf_set_user_ie(db, &handle->sa_dbu); 1401 } 1402 1403 if (winner != NULL) { 1404 kmem_cache_free(sa_cache, handle); 1405 handle = winner; 1406 } 1407 } 1408 *handlepp = handle; 1409 1410 return (error); 1411} 1412 1413int 1414sa_handle_get(objset_t *objset, uint64_t objid, void *userp, 1415 sa_handle_type_t hdl_type, sa_handle_t **handlepp) 1416{ 1417 dmu_buf_t *db; 1418 int error; 1419 1420 if (error = dmu_bonus_hold(objset, objid, NULL, &db)) 1421 return (error); 1422 1423 return (sa_handle_get_from_db(objset, db, userp, hdl_type, 1424 handlepp)); 1425} 1426 1427int 1428sa_buf_hold(objset_t *objset, uint64_t obj_num, void *tag, dmu_buf_t **db) 1429{ 1430 return (dmu_bonus_hold(objset, obj_num, tag, db)); 1431} 1432 1433void 1434sa_buf_rele(dmu_buf_t *db, void *tag) 1435{ 1436 dmu_buf_rele(db, tag); 1437} 1438 1439int 1440sa_lookup_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count) 1441{ 1442 ASSERT(hdl); 1443 ASSERT(MUTEX_HELD(&hdl->sa_lock)); 1444 return (sa_attr_op(hdl, bulk, count, SA_LOOKUP, NULL)); 1445} 1446 1447int 1448sa_lookup(sa_handle_t *hdl, sa_attr_type_t attr, void *buf, uint32_t buflen) 1449{ 1450 int error; 1451 sa_bulk_attr_t bulk; 1452 1453 bulk.sa_attr = attr; 1454 bulk.sa_data = buf; 1455 bulk.sa_length = buflen; 1456 bulk.sa_data_func = NULL; 1457 1458 ASSERT(hdl); 1459 mutex_enter(&hdl->sa_lock); 1460 error = sa_lookup_impl(hdl, &bulk, 1); 1461 mutex_exit(&hdl->sa_lock); 1462 return (error); 1463} 1464 1465#ifdef _KERNEL 1466int 1467sa_lookup_uio(sa_handle_t *hdl, sa_attr_type_t attr, uio_t *uio) 1468{ 1469 int error; 1470 sa_bulk_attr_t bulk; 1471 1472 bulk.sa_data = NULL; 1473 bulk.sa_attr = attr; 1474 bulk.sa_data_func = NULL; 1475 1476 ASSERT(hdl); 1477 1478 mutex_enter(&hdl->sa_lock); 1479 if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) == 0) { 1480 error = uiomove((void *)bulk.sa_addr, MIN(bulk.sa_size, 1481 uio->uio_resid), UIO_READ, uio); 1482 } 1483 mutex_exit(&hdl->sa_lock); 1484 return (error); 1485 1486} 1487#endif 1488 1489void * 1490sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype, void *data) 1491{ 1492 sa_idx_tab_t *idx_tab; 1493 sa_hdr_phys_t *hdr = (sa_hdr_phys_t *)data; 1494 sa_os_t *sa = os->os_sa; 1495 sa_lot_t *tb, search; 1496 avl_index_t loc; 1497 1498 /* 1499 * Deterimine layout number. If SA node and header == 0 then 1500 * force the index table to the dummy "1" empty layout. 1501 * 1502 * The layout number would only be zero for a newly created file 1503 * that has not added any attributes yet, or with crypto enabled which 1504 * doesn't write any attributes to the bonus buffer. 1505 */ 1506 1507 search.lot_num = SA_LAYOUT_NUM(hdr, bonustype); 1508 1509 tb = avl_find(&sa->sa_layout_num_tree, &search, &loc); 1510 1511 /* Verify header size is consistent with layout information */ 1512 ASSERT(tb); 1513 ASSERT(IS_SA_BONUSTYPE(bonustype) && 1514 SA_HDR_SIZE_MATCH_LAYOUT(hdr, tb) || !IS_SA_BONUSTYPE(bonustype) || 1515 (IS_SA_BONUSTYPE(bonustype) && hdr->sa_layout_info == 0)); 1516 1517 /* 1518 * See if any of the already existing TOC entries can be reused? 1519 */ 1520 1521 for (idx_tab = list_head(&tb->lot_idx_tab); idx_tab; 1522 idx_tab = list_next(&tb->lot_idx_tab, idx_tab)) { 1523 boolean_t valid_idx = B_TRUE; 1524 int i; 1525 1526 if (tb->lot_var_sizes != 0 && 1527 idx_tab->sa_variable_lengths != NULL) { 1528 for (i = 0; i != tb->lot_var_sizes; i++) { 1529 if (hdr->sa_lengths[i] != 1530 idx_tab->sa_variable_lengths[i]) { 1531 valid_idx = B_FALSE; 1532 break; 1533 } 1534 } 1535 } 1536 if (valid_idx) { 1537 sa_idx_tab_hold(os, idx_tab); 1538 return (idx_tab); 1539 } 1540 } 1541 1542 /* No such luck, create a new entry */ 1543 idx_tab = kmem_zalloc(sizeof (sa_idx_tab_t), KM_SLEEP); 1544 idx_tab->sa_idx_tab = 1545 kmem_zalloc(sizeof (uint32_t) * sa->sa_num_attrs, KM_SLEEP); 1546 idx_tab->sa_layout = tb; 1547 refcount_create(&idx_tab->sa_refcount); 1548 if (tb->lot_var_sizes) 1549 idx_tab->sa_variable_lengths = kmem_alloc(sizeof (uint16_t) * 1550 tb->lot_var_sizes, KM_SLEEP); 1551 1552 sa_attr_iter(os, hdr, bonustype, sa_build_idx_tab, 1553 tb, idx_tab); 1554 sa_idx_tab_hold(os, idx_tab); /* one hold for consumer */ 1555 sa_idx_tab_hold(os, idx_tab); /* one for layout */ 1556 list_insert_tail(&tb->lot_idx_tab, idx_tab); 1557 return (idx_tab); 1558} 1559 1560void 1561sa_default_locator(void **dataptr, uint32_t *len, uint32_t total_len, 1562 boolean_t start, void *userdata) 1563{ 1564 ASSERT(start); 1565 1566 *dataptr = userdata; 1567 *len = total_len; 1568} 1569 1570static void 1571sa_attr_register_sync(sa_handle_t *hdl, dmu_tx_t *tx) 1572{ 1573 uint64_t attr_value = 0; 1574 sa_os_t *sa = hdl->sa_os->os_sa; 1575 sa_attr_table_t *tb = sa->sa_attr_table; 1576 int i; 1577 1578 mutex_enter(&sa->sa_lock); 1579 1580 if (!sa->sa_need_attr_registration || sa->sa_master_obj == 0) { 1581 mutex_exit(&sa->sa_lock); 1582 return; 1583 } 1584 1585 if (sa->sa_reg_attr_obj == 0) { 1586 sa->sa_reg_attr_obj = zap_create_link(hdl->sa_os, 1587 DMU_OT_SA_ATTR_REGISTRATION, 1588 sa->sa_master_obj, SA_REGISTRY, tx); 1589 } 1590 for (i = 0; i != sa->sa_num_attrs; i++) { 1591 if (sa->sa_attr_table[i].sa_registered) 1592 continue; 1593 ATTR_ENCODE(attr_value, tb[i].sa_attr, tb[i].sa_length, 1594 tb[i].sa_byteswap); 1595 VERIFY(0 == zap_update(hdl->sa_os, sa->sa_reg_attr_obj, 1596 tb[i].sa_name, 8, 1, &attr_value, tx)); 1597 tb[i].sa_registered = B_TRUE; 1598 } 1599 sa->sa_need_attr_registration = B_FALSE; 1600 mutex_exit(&sa->sa_lock); 1601} 1602 1603/* 1604 * Replace all attributes with attributes specified in template. 1605 * If dnode had a spill buffer then those attributes will be 1606 * also be replaced, possibly with just an empty spill block 1607 * 1608 * This interface is intended to only be used for bulk adding of 1609 * attributes for a new file. It will also be used by the ZPL 1610 * when converting and old formatted znode to native SA support. 1611 */ 1612int 1613sa_replace_all_by_template_locked(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, 1614 int attr_count, dmu_tx_t *tx) 1615{ 1616 sa_os_t *sa = hdl->sa_os->os_sa; 1617 1618 if (sa->sa_need_attr_registration) 1619 sa_attr_register_sync(hdl, tx); 1620 return (sa_build_layouts(hdl, attr_desc, attr_count, tx)); 1621} 1622 1623int 1624sa_replace_all_by_template(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, 1625 int attr_count, dmu_tx_t *tx) 1626{ 1627 int error; 1628 1629 mutex_enter(&hdl->sa_lock); 1630 error = sa_replace_all_by_template_locked(hdl, attr_desc, 1631 attr_count, tx); 1632 mutex_exit(&hdl->sa_lock); 1633 return (error); 1634} 1635 1636/* 1637 * Add/remove a single attribute or replace a variable-sized attribute value 1638 * with a value of a different size, and then rewrite the entire set 1639 * of attributes. 1640 * Same-length attribute value replacement (including fixed-length attributes) 1641 * is handled more efficiently by the upper layers. 1642 */ 1643static int 1644sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr, 1645 sa_data_op_t action, sa_data_locator_t *locator, void *datastart, 1646 uint16_t buflen, dmu_tx_t *tx) 1647{ 1648 sa_os_t *sa = hdl->sa_os->os_sa; 1649 dmu_buf_impl_t *db = (dmu_buf_impl_t *)hdl->sa_bonus; 1650 dnode_t *dn; 1651 sa_bulk_attr_t *attr_desc; 1652 void *old_data[2]; 1653 int bonus_attr_count = 0; 1654 int bonus_data_size = 0; 1655 int spill_data_size = 0; 1656 int spill_attr_count = 0; 1657 int error; 1658 uint16_t length, reg_length; 1659 int i, j, k, length_idx; 1660 sa_hdr_phys_t *hdr; 1661 sa_idx_tab_t *idx_tab; 1662 int attr_count; 1663 int count; 1664 1665 ASSERT(MUTEX_HELD(&hdl->sa_lock)); 1666 1667 /* First make of copy of the old data */ 1668 1669 DB_DNODE_ENTER(db); 1670 dn = DB_DNODE(db); 1671 if (dn->dn_bonuslen != 0) { 1672 bonus_data_size = hdl->sa_bonus->db_size; 1673 old_data[0] = kmem_alloc(bonus_data_size, KM_SLEEP); 1674 bcopy(hdl->sa_bonus->db_data, old_data[0], 1675 hdl->sa_bonus->db_size); 1676 bonus_attr_count = hdl->sa_bonus_tab->sa_layout->lot_attr_count; 1677 } else { 1678 old_data[0] = NULL; 1679 } 1680 DB_DNODE_EXIT(db); 1681 1682 /* Bring spill buffer online if it isn't currently */ 1683 1684 if ((error = sa_get_spill(hdl)) == 0) { 1685 spill_data_size = hdl->sa_spill->db_size; 1686 old_data[1] = kmem_alloc(spill_data_size, KM_SLEEP); 1687 bcopy(hdl->sa_spill->db_data, old_data[1], 1688 hdl->sa_spill->db_size); 1689 spill_attr_count = 1690 hdl->sa_spill_tab->sa_layout->lot_attr_count; 1691 } else if (error && error != ENOENT) { 1692 if (old_data[0]) 1693 kmem_free(old_data[0], bonus_data_size); 1694 return (error); 1695 } else { 1696 old_data[1] = NULL; 1697 } 1698 1699 /* build descriptor of all attributes */ 1700 1701 attr_count = bonus_attr_count + spill_attr_count; 1702 if (action == SA_ADD) 1703 attr_count++; 1704 else if (action == SA_REMOVE) 1705 attr_count--; 1706 1707 attr_desc = kmem_zalloc(sizeof (sa_bulk_attr_t) * attr_count, KM_SLEEP); 1708 1709 /* 1710 * loop through bonus and spill buffer if it exists, and 1711 * build up new attr_descriptor to reset the attributes 1712 */ 1713 k = j = 0; 1714 count = bonus_attr_count; 1715 hdr = SA_GET_HDR(hdl, SA_BONUS); 1716 idx_tab = SA_IDX_TAB_GET(hdl, SA_BONUS); 1717 for (; k != 2; k++) { 1718 /* 1719 * Iterate over each attribute in layout. Fetch the 1720 * size of variable-length attributes needing rewrite 1721 * from sa_lengths[]. 1722 */ 1723 for (i = 0, length_idx = 0; i != count; i++) { 1724 sa_attr_type_t attr; 1725 1726 attr = idx_tab->sa_layout->lot_attrs[i]; 1727 reg_length = SA_REGISTERED_LEN(sa, attr); 1728 if (reg_length == 0) { 1729 length = hdr->sa_lengths[length_idx]; 1730 length_idx++; 1731 } else { 1732 length = reg_length; 1733 } 1734 if (attr == newattr) { 1735 /* 1736 * There is nothing to do for SA_REMOVE, 1737 * so it is just skipped. 1738 */ 1739 if (action == SA_REMOVE) 1740 continue; 1741 1742 /* 1743 * Duplicate attributes are not allowed, so the 1744 * action can not be SA_ADD here. 1745 */ 1746 ASSERT3S(action, ==, SA_REPLACE); 1747 1748 /* 1749 * Only a variable-sized attribute can be 1750 * replaced here, and its size must be changing. 1751 */ 1752 ASSERT3U(reg_length, ==, 0); 1753 ASSERT3U(length, !=, buflen); 1754 SA_ADD_BULK_ATTR(attr_desc, j, attr, 1755 locator, datastart, buflen); 1756 } else { 1757 SA_ADD_BULK_ATTR(attr_desc, j, attr, 1758 NULL, (void *) 1759 (TOC_OFF(idx_tab->sa_idx_tab[attr]) + 1760 (uintptr_t)old_data[k]), length); 1761 } 1762 } 1763 if (k == 0 && hdl->sa_spill) { 1764 hdr = SA_GET_HDR(hdl, SA_SPILL); 1765 idx_tab = SA_IDX_TAB_GET(hdl, SA_SPILL); 1766 count = spill_attr_count; 1767 } else { 1768 break; 1769 } 1770 } 1771 if (action == SA_ADD) { 1772 reg_length = SA_REGISTERED_LEN(sa, newattr); 1773 IMPLY(reg_length != 0, reg_length == buflen); 1774 SA_ADD_BULK_ATTR(attr_desc, j, newattr, locator, 1775 datastart, buflen); 1776 } 1777 ASSERT3U(j, ==, attr_count); 1778 1779 error = sa_build_layouts(hdl, attr_desc, attr_count, tx); 1780 1781 if (old_data[0]) 1782 kmem_free(old_data[0], bonus_data_size); 1783 if (old_data[1]) 1784 kmem_free(old_data[1], spill_data_size); 1785 kmem_free(attr_desc, sizeof (sa_bulk_attr_t) * attr_count); 1786 1787 return (error); 1788} 1789 1790static int 1791sa_bulk_update_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count, 1792 dmu_tx_t *tx) 1793{ 1794 int error; 1795 sa_os_t *sa = hdl->sa_os->os_sa; 1796 dmu_object_type_t bonustype; 1797 1798 bonustype = SA_BONUSTYPE_FROM_DB(SA_GET_DB(hdl, SA_BONUS)); 1799 1800 ASSERT(hdl); 1801 ASSERT(MUTEX_HELD(&hdl->sa_lock)); 1802 1803 /* sync out registration table if necessary */ 1804 if (sa->sa_need_attr_registration) 1805 sa_attr_register_sync(hdl, tx); 1806 1807 error = sa_attr_op(hdl, bulk, count, SA_UPDATE, tx); 1808 if (error == 0 && !IS_SA_BONUSTYPE(bonustype) && sa->sa_update_cb) 1809 sa->sa_update_cb(hdl, tx); 1810 1811 return (error); 1812} 1813 1814/* 1815 * update or add new attribute 1816 */ 1817int 1818sa_update(sa_handle_t *hdl, sa_attr_type_t type, 1819 void *buf, uint32_t buflen, dmu_tx_t *tx) 1820{ 1821 int error; 1822 sa_bulk_attr_t bulk; 1823 1824 bulk.sa_attr = type; 1825 bulk.sa_data_func = NULL; 1826 bulk.sa_length = buflen; 1827 bulk.sa_data = buf; 1828 1829 mutex_enter(&hdl->sa_lock); 1830 error = sa_bulk_update_impl(hdl, &bulk, 1, tx); 1831 mutex_exit(&hdl->sa_lock); 1832 return (error); 1833} 1834 1835int 1836sa_update_from_cb(sa_handle_t *hdl, sa_attr_type_t attr, 1837 uint32_t buflen, sa_data_locator_t *locator, void *userdata, dmu_tx_t *tx) 1838{ 1839 int error; 1840 sa_bulk_attr_t bulk; 1841 1842 bulk.sa_attr = attr; 1843 bulk.sa_data = userdata; 1844 bulk.sa_data_func = locator; 1845 bulk.sa_length = buflen; 1846 1847 mutex_enter(&hdl->sa_lock); 1848 error = sa_bulk_update_impl(hdl, &bulk, 1, tx); 1849 mutex_exit(&hdl->sa_lock); 1850 return (error); 1851} 1852 1853/* 1854 * Return size of an attribute 1855 */ 1856 1857int 1858sa_size(sa_handle_t *hdl, sa_attr_type_t attr, int *size) 1859{ 1860 sa_bulk_attr_t bulk; 1861 int error; 1862 1863 bulk.sa_data = NULL; 1864 bulk.sa_attr = attr; 1865 bulk.sa_data_func = NULL; 1866 1867 ASSERT(hdl); 1868 mutex_enter(&hdl->sa_lock); 1869 if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) != 0) { 1870 mutex_exit(&hdl->sa_lock); 1871 return (error); 1872 } 1873 *size = bulk.sa_size; 1874 1875 mutex_exit(&hdl->sa_lock); 1876 return (0); 1877} 1878 1879int 1880sa_bulk_lookup_locked(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count) 1881{ 1882 ASSERT(hdl); 1883 ASSERT(MUTEX_HELD(&hdl->sa_lock)); 1884 return (sa_lookup_impl(hdl, attrs, count)); 1885} 1886 1887int 1888sa_bulk_lookup(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count) 1889{ 1890 int error; 1891 1892 ASSERT(hdl); 1893 mutex_enter(&hdl->sa_lock); 1894 error = sa_bulk_lookup_locked(hdl, attrs, count); 1895 mutex_exit(&hdl->sa_lock); 1896 return (error); 1897} 1898 1899int 1900sa_bulk_update(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count, dmu_tx_t *tx) 1901{ 1902 int error; 1903 1904 ASSERT(hdl); 1905 mutex_enter(&hdl->sa_lock); 1906 error = sa_bulk_update_impl(hdl, attrs, count, tx); 1907 mutex_exit(&hdl->sa_lock); 1908 return (error); 1909} 1910 1911int 1912sa_remove(sa_handle_t *hdl, sa_attr_type_t attr, dmu_tx_t *tx) 1913{ 1914 int error; 1915 1916 mutex_enter(&hdl->sa_lock); 1917 error = sa_modify_attrs(hdl, attr, SA_REMOVE, NULL, 1918 NULL, 0, tx); 1919 mutex_exit(&hdl->sa_lock); 1920 return (error); 1921} 1922 1923void 1924sa_object_info(sa_handle_t *hdl, dmu_object_info_t *doi) 1925{ 1926 dmu_object_info_from_db((dmu_buf_t *)hdl->sa_bonus, doi); 1927} 1928 1929void 1930sa_object_size(sa_handle_t *hdl, uint32_t *blksize, u_longlong_t *nblocks) 1931{ 1932 dmu_object_size_from_db((dmu_buf_t *)hdl->sa_bonus, 1933 blksize, nblocks); 1934} 1935 1936void 1937sa_set_userp(sa_handle_t *hdl, void *ptr) 1938{ 1939 hdl->sa_userp = ptr; 1940} 1941 1942dmu_buf_t * 1943sa_get_db(sa_handle_t *hdl) 1944{ 1945 return ((dmu_buf_t *)hdl->sa_bonus); 1946} 1947 1948void * 1949sa_get_userdata(sa_handle_t *hdl) 1950{ 1951 return (hdl->sa_userp); 1952} 1953 1954void 1955sa_register_update_callback_locked(objset_t *os, sa_update_cb_t *func) 1956{ 1957 ASSERT(MUTEX_HELD(&os->os_sa->sa_lock)); 1958 os->os_sa->sa_update_cb = func; 1959} 1960 1961void 1962sa_register_update_callback(objset_t *os, sa_update_cb_t *func) 1963{ 1964 1965 mutex_enter(&os->os_sa->sa_lock); 1966 sa_register_update_callback_locked(os, func); 1967 mutex_exit(&os->os_sa->sa_lock); 1968} 1969 1970uint64_t 1971sa_handle_object(sa_handle_t *hdl) 1972{ 1973 return (hdl->sa_bonus->db_object); 1974} 1975 1976boolean_t 1977sa_enabled(objset_t *os) 1978{ 1979 return (os->os_sa == NULL); 1980} 1981 1982int 1983sa_set_sa_object(objset_t *os, uint64_t sa_object) 1984{ 1985 sa_os_t *sa = os->os_sa; 1986 1987 if (sa->sa_master_obj) 1988 return (1); 1989 1990 sa->sa_master_obj = sa_object; 1991 1992 return (0); 1993} 1994 1995int 1996sa_hdrsize(void *arg) 1997{ 1998 sa_hdr_phys_t *hdr = arg; 1999 2000 return (SA_HDR_SIZE(hdr)); 2001} 2002 2003void 2004sa_handle_lock(sa_handle_t *hdl) 2005{ 2006 ASSERT(hdl); 2007 mutex_enter(&hdl->sa_lock); 2008} 2009 2010void 2011sa_handle_unlock(sa_handle_t *hdl) 2012{ 2013 ASSERT(hdl); 2014 mutex_exit(&hdl->sa_lock); 2015} 2016