sa.c revision 297112
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 * 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(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 = NULL; 1387 handle->sa_userp = userp; 1388 handle->sa_bonus = db; 1389 handle->sa_os = os; 1390 handle->sa_spill = NULL; 1391 handle->sa_bonus_tab = NULL; 1392 handle->sa_spill_tab = NULL; 1393 1394 error = sa_build_index(handle, SA_BONUS); 1395 1396 if (hdl_type == SA_HDL_SHARED) { 1397 dmu_buf_init_user(&handle->sa_dbu, sa_evict, NULL); 1398 winner = dmu_buf_set_user_ie(db, &handle->sa_dbu); 1399 } 1400 1401 if (winner != NULL) { 1402 kmem_cache_free(sa_cache, handle); 1403 handle = winner; 1404 } 1405 } 1406 *handlepp = handle; 1407 1408 return (error); 1409} 1410 1411int 1412sa_handle_get(objset_t *objset, uint64_t objid, void *userp, 1413 sa_handle_type_t hdl_type, sa_handle_t **handlepp) 1414{ 1415 dmu_buf_t *db; 1416 int error; 1417 1418 if (error = dmu_bonus_hold(objset, objid, NULL, &db)) 1419 return (error); 1420 1421 return (sa_handle_get_from_db(objset, db, userp, hdl_type, 1422 handlepp)); 1423} 1424 1425int 1426sa_buf_hold(objset_t *objset, uint64_t obj_num, void *tag, dmu_buf_t **db) 1427{ 1428 return (dmu_bonus_hold(objset, obj_num, tag, db)); 1429} 1430 1431void 1432sa_buf_rele(dmu_buf_t *db, void *tag) 1433{ 1434 dmu_buf_rele(db, tag); 1435} 1436 1437int 1438sa_lookup_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count) 1439{ 1440 ASSERT(hdl); 1441 ASSERT(MUTEX_HELD(&hdl->sa_lock)); 1442 return (sa_attr_op(hdl, bulk, count, SA_LOOKUP, NULL)); 1443} 1444 1445int 1446sa_lookup(sa_handle_t *hdl, sa_attr_type_t attr, void *buf, uint32_t buflen) 1447{ 1448 int error; 1449 sa_bulk_attr_t bulk; 1450 1451 bulk.sa_attr = attr; 1452 bulk.sa_data = buf; 1453 bulk.sa_length = buflen; 1454 bulk.sa_data_func = NULL; 1455 1456 ASSERT(hdl); 1457 mutex_enter(&hdl->sa_lock); 1458 error = sa_lookup_impl(hdl, &bulk, 1); 1459 mutex_exit(&hdl->sa_lock); 1460 return (error); 1461} 1462 1463#ifdef _KERNEL 1464int 1465sa_lookup_uio(sa_handle_t *hdl, sa_attr_type_t attr, uio_t *uio) 1466{ 1467 int error; 1468 sa_bulk_attr_t bulk; 1469 1470 bulk.sa_data = NULL; 1471 bulk.sa_attr = attr; 1472 bulk.sa_data_func = NULL; 1473 1474 ASSERT(hdl); 1475 1476 mutex_enter(&hdl->sa_lock); 1477 if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) == 0) { 1478 error = uiomove((void *)bulk.sa_addr, MIN(bulk.sa_size, 1479 uio->uio_resid), UIO_READ, uio); 1480 } 1481 mutex_exit(&hdl->sa_lock); 1482 return (error); 1483 1484} 1485#endif 1486 1487void * 1488sa_find_idx_tab(objset_t *os, dmu_object_type_t bonustype, void *data) 1489{ 1490 sa_idx_tab_t *idx_tab; 1491 sa_hdr_phys_t *hdr = (sa_hdr_phys_t *)data; 1492 sa_os_t *sa = os->os_sa; 1493 sa_lot_t *tb, search; 1494 avl_index_t loc; 1495 1496 /* 1497 * Deterimine layout number. If SA node and header == 0 then 1498 * force the index table to the dummy "1" empty layout. 1499 * 1500 * The layout number would only be zero for a newly created file 1501 * that has not added any attributes yet, or with crypto enabled which 1502 * doesn't write any attributes to the bonus buffer. 1503 */ 1504 1505 search.lot_num = SA_LAYOUT_NUM(hdr, bonustype); 1506 1507 tb = avl_find(&sa->sa_layout_num_tree, &search, &loc); 1508 1509 /* Verify header size is consistent with layout information */ 1510 ASSERT(tb); 1511 ASSERT(IS_SA_BONUSTYPE(bonustype) && 1512 SA_HDR_SIZE_MATCH_LAYOUT(hdr, tb) || !IS_SA_BONUSTYPE(bonustype) || 1513 (IS_SA_BONUSTYPE(bonustype) && hdr->sa_layout_info == 0)); 1514 1515 /* 1516 * See if any of the already existing TOC entries can be reused? 1517 */ 1518 1519 for (idx_tab = list_head(&tb->lot_idx_tab); idx_tab; 1520 idx_tab = list_next(&tb->lot_idx_tab, idx_tab)) { 1521 boolean_t valid_idx = B_TRUE; 1522 int i; 1523 1524 if (tb->lot_var_sizes != 0 && 1525 idx_tab->sa_variable_lengths != NULL) { 1526 for (i = 0; i != tb->lot_var_sizes; i++) { 1527 if (hdr->sa_lengths[i] != 1528 idx_tab->sa_variable_lengths[i]) { 1529 valid_idx = B_FALSE; 1530 break; 1531 } 1532 } 1533 } 1534 if (valid_idx) { 1535 sa_idx_tab_hold(os, idx_tab); 1536 return (idx_tab); 1537 } 1538 } 1539 1540 /* No such luck, create a new entry */ 1541 idx_tab = kmem_zalloc(sizeof (sa_idx_tab_t), KM_SLEEP); 1542 idx_tab->sa_idx_tab = 1543 kmem_zalloc(sizeof (uint32_t) * sa->sa_num_attrs, KM_SLEEP); 1544 idx_tab->sa_layout = tb; 1545 refcount_create(&idx_tab->sa_refcount); 1546 if (tb->lot_var_sizes) 1547 idx_tab->sa_variable_lengths = kmem_alloc(sizeof (uint16_t) * 1548 tb->lot_var_sizes, KM_SLEEP); 1549 1550 sa_attr_iter(os, hdr, bonustype, sa_build_idx_tab, 1551 tb, idx_tab); 1552 sa_idx_tab_hold(os, idx_tab); /* one hold for consumer */ 1553 sa_idx_tab_hold(os, idx_tab); /* one for layout */ 1554 list_insert_tail(&tb->lot_idx_tab, idx_tab); 1555 return (idx_tab); 1556} 1557 1558void 1559sa_default_locator(void **dataptr, uint32_t *len, uint32_t total_len, 1560 boolean_t start, void *userdata) 1561{ 1562 ASSERT(start); 1563 1564 *dataptr = userdata; 1565 *len = total_len; 1566} 1567 1568static void 1569sa_attr_register_sync(sa_handle_t *hdl, dmu_tx_t *tx) 1570{ 1571 uint64_t attr_value = 0; 1572 sa_os_t *sa = hdl->sa_os->os_sa; 1573 sa_attr_table_t *tb = sa->sa_attr_table; 1574 int i; 1575 1576 mutex_enter(&sa->sa_lock); 1577 1578 if (!sa->sa_need_attr_registration || sa->sa_master_obj == 0) { 1579 mutex_exit(&sa->sa_lock); 1580 return; 1581 } 1582 1583 if (sa->sa_reg_attr_obj == 0) { 1584 sa->sa_reg_attr_obj = zap_create_link(hdl->sa_os, 1585 DMU_OT_SA_ATTR_REGISTRATION, 1586 sa->sa_master_obj, SA_REGISTRY, tx); 1587 } 1588 for (i = 0; i != sa->sa_num_attrs; i++) { 1589 if (sa->sa_attr_table[i].sa_registered) 1590 continue; 1591 ATTR_ENCODE(attr_value, tb[i].sa_attr, tb[i].sa_length, 1592 tb[i].sa_byteswap); 1593 VERIFY(0 == zap_update(hdl->sa_os, sa->sa_reg_attr_obj, 1594 tb[i].sa_name, 8, 1, &attr_value, tx)); 1595 tb[i].sa_registered = B_TRUE; 1596 } 1597 sa->sa_need_attr_registration = B_FALSE; 1598 mutex_exit(&sa->sa_lock); 1599} 1600 1601/* 1602 * Replace all attributes with attributes specified in template. 1603 * If dnode had a spill buffer then those attributes will be 1604 * also be replaced, possibly with just an empty spill block 1605 * 1606 * This interface is intended to only be used for bulk adding of 1607 * attributes for a new file. It will also be used by the ZPL 1608 * when converting and old formatted znode to native SA support. 1609 */ 1610int 1611sa_replace_all_by_template_locked(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, 1612 int attr_count, dmu_tx_t *tx) 1613{ 1614 sa_os_t *sa = hdl->sa_os->os_sa; 1615 1616 if (sa->sa_need_attr_registration) 1617 sa_attr_register_sync(hdl, tx); 1618 return (sa_build_layouts(hdl, attr_desc, attr_count, tx)); 1619} 1620 1621int 1622sa_replace_all_by_template(sa_handle_t *hdl, sa_bulk_attr_t *attr_desc, 1623 int attr_count, dmu_tx_t *tx) 1624{ 1625 int error; 1626 1627 mutex_enter(&hdl->sa_lock); 1628 error = sa_replace_all_by_template_locked(hdl, attr_desc, 1629 attr_count, tx); 1630 mutex_exit(&hdl->sa_lock); 1631 return (error); 1632} 1633 1634/* 1635 * Add/remove a single attribute or replace a variable-sized attribute value 1636 * with a value of a different size, and then rewrite the entire set 1637 * of attributes. 1638 * Same-length attribute value replacement (including fixed-length attributes) 1639 * is handled more efficiently by the upper layers. 1640 */ 1641static int 1642sa_modify_attrs(sa_handle_t *hdl, sa_attr_type_t newattr, 1643 sa_data_op_t action, sa_data_locator_t *locator, void *datastart, 1644 uint16_t buflen, dmu_tx_t *tx) 1645{ 1646 sa_os_t *sa = hdl->sa_os->os_sa; 1647 dmu_buf_impl_t *db = (dmu_buf_impl_t *)hdl->sa_bonus; 1648 dnode_t *dn; 1649 sa_bulk_attr_t *attr_desc; 1650 void *old_data[2]; 1651 int bonus_attr_count = 0; 1652 int bonus_data_size = 0; 1653 int spill_data_size = 0; 1654 int spill_attr_count = 0; 1655 int error; 1656 uint16_t length, reg_length; 1657 int i, j, k, length_idx; 1658 sa_hdr_phys_t *hdr; 1659 sa_idx_tab_t *idx_tab; 1660 int attr_count; 1661 int count; 1662 1663 ASSERT(MUTEX_HELD(&hdl->sa_lock)); 1664 1665 /* First make of copy of the old data */ 1666 1667 DB_DNODE_ENTER(db); 1668 dn = DB_DNODE(db); 1669 if (dn->dn_bonuslen != 0) { 1670 bonus_data_size = hdl->sa_bonus->db_size; 1671 old_data[0] = kmem_alloc(bonus_data_size, KM_SLEEP); 1672 bcopy(hdl->sa_bonus->db_data, old_data[0], 1673 hdl->sa_bonus->db_size); 1674 bonus_attr_count = hdl->sa_bonus_tab->sa_layout->lot_attr_count; 1675 } else { 1676 old_data[0] = NULL; 1677 } 1678 DB_DNODE_EXIT(db); 1679 1680 /* Bring spill buffer online if it isn't currently */ 1681 1682 if ((error = sa_get_spill(hdl)) == 0) { 1683 spill_data_size = hdl->sa_spill->db_size; 1684 old_data[1] = kmem_alloc(spill_data_size, KM_SLEEP); 1685 bcopy(hdl->sa_spill->db_data, old_data[1], 1686 hdl->sa_spill->db_size); 1687 spill_attr_count = 1688 hdl->sa_spill_tab->sa_layout->lot_attr_count; 1689 } else if (error && error != ENOENT) { 1690 if (old_data[0]) 1691 kmem_free(old_data[0], bonus_data_size); 1692 return (error); 1693 } else { 1694 old_data[1] = NULL; 1695 } 1696 1697 /* build descriptor of all attributes */ 1698 1699 attr_count = bonus_attr_count + spill_attr_count; 1700 if (action == SA_ADD) 1701 attr_count++; 1702 else if (action == SA_REMOVE) 1703 attr_count--; 1704 1705 attr_desc = kmem_zalloc(sizeof (sa_bulk_attr_t) * attr_count, KM_SLEEP); 1706 1707 /* 1708 * loop through bonus and spill buffer if it exists, and 1709 * build up new attr_descriptor to reset the attributes 1710 */ 1711 k = j = 0; 1712 count = bonus_attr_count; 1713 hdr = SA_GET_HDR(hdl, SA_BONUS); 1714 idx_tab = SA_IDX_TAB_GET(hdl, SA_BONUS); 1715 for (; k != 2; k++) { 1716 /* 1717 * Iterate over each attribute in layout. Fetch the 1718 * size of variable-length attributes needing rewrite 1719 * from sa_lengths[]. 1720 */ 1721 for (i = 0, length_idx = 0; i != count; i++) { 1722 sa_attr_type_t attr; 1723 1724 attr = idx_tab->sa_layout->lot_attrs[i]; 1725 reg_length = SA_REGISTERED_LEN(sa, attr); 1726 if (reg_length == 0) { 1727 length = hdr->sa_lengths[length_idx]; 1728 length_idx++; 1729 } else { 1730 length = reg_length; 1731 } 1732 if (attr == newattr) { 1733 /* 1734 * There is nothing to do for SA_REMOVE, 1735 * so it is just skipped. 1736 */ 1737 if (action == SA_REMOVE) 1738 continue; 1739 1740 /* 1741 * Duplicate attributes are not allowed, so the 1742 * action can not be SA_ADD here. 1743 */ 1744 ASSERT3S(action, ==, SA_REPLACE); 1745 1746 /* 1747 * Only a variable-sized attribute can be 1748 * replaced here, and its size must be changing. 1749 */ 1750 ASSERT3U(reg_length, ==, 0); 1751 ASSERT3U(length, !=, buflen); 1752 SA_ADD_BULK_ATTR(attr_desc, j, attr, 1753 locator, datastart, buflen); 1754 } else { 1755 SA_ADD_BULK_ATTR(attr_desc, j, attr, 1756 NULL, (void *) 1757 (TOC_OFF(idx_tab->sa_idx_tab[attr]) + 1758 (uintptr_t)old_data[k]), length); 1759 } 1760 } 1761 if (k == 0 && hdl->sa_spill) { 1762 hdr = SA_GET_HDR(hdl, SA_SPILL); 1763 idx_tab = SA_IDX_TAB_GET(hdl, SA_SPILL); 1764 count = spill_attr_count; 1765 } else { 1766 break; 1767 } 1768 } 1769 if (action == SA_ADD) { 1770 reg_length = SA_REGISTERED_LEN(sa, newattr); 1771 IMPLY(reg_length != 0, reg_length == buflen); 1772 SA_ADD_BULK_ATTR(attr_desc, j, newattr, locator, 1773 datastart, buflen); 1774 } 1775 ASSERT3U(j, ==, attr_count); 1776 1777 error = sa_build_layouts(hdl, attr_desc, attr_count, tx); 1778 1779 if (old_data[0]) 1780 kmem_free(old_data[0], bonus_data_size); 1781 if (old_data[1]) 1782 kmem_free(old_data[1], spill_data_size); 1783 kmem_free(attr_desc, sizeof (sa_bulk_attr_t) * attr_count); 1784 1785 return (error); 1786} 1787 1788static int 1789sa_bulk_update_impl(sa_handle_t *hdl, sa_bulk_attr_t *bulk, int count, 1790 dmu_tx_t *tx) 1791{ 1792 int error; 1793 sa_os_t *sa = hdl->sa_os->os_sa; 1794 dmu_object_type_t bonustype; 1795 1796 bonustype = SA_BONUSTYPE_FROM_DB(SA_GET_DB(hdl, SA_BONUS)); 1797 1798 ASSERT(hdl); 1799 ASSERT(MUTEX_HELD(&hdl->sa_lock)); 1800 1801 /* sync out registration table if necessary */ 1802 if (sa->sa_need_attr_registration) 1803 sa_attr_register_sync(hdl, tx); 1804 1805 error = sa_attr_op(hdl, bulk, count, SA_UPDATE, tx); 1806 if (error == 0 && !IS_SA_BONUSTYPE(bonustype) && sa->sa_update_cb) 1807 sa->sa_update_cb(hdl, tx); 1808 1809 return (error); 1810} 1811 1812/* 1813 * update or add new attribute 1814 */ 1815int 1816sa_update(sa_handle_t *hdl, sa_attr_type_t type, 1817 void *buf, uint32_t buflen, dmu_tx_t *tx) 1818{ 1819 int error; 1820 sa_bulk_attr_t bulk; 1821 1822 bulk.sa_attr = type; 1823 bulk.sa_data_func = NULL; 1824 bulk.sa_length = buflen; 1825 bulk.sa_data = buf; 1826 1827 mutex_enter(&hdl->sa_lock); 1828 error = sa_bulk_update_impl(hdl, &bulk, 1, tx); 1829 mutex_exit(&hdl->sa_lock); 1830 return (error); 1831} 1832 1833int 1834sa_update_from_cb(sa_handle_t *hdl, sa_attr_type_t attr, 1835 uint32_t buflen, sa_data_locator_t *locator, void *userdata, dmu_tx_t *tx) 1836{ 1837 int error; 1838 sa_bulk_attr_t bulk; 1839 1840 bulk.sa_attr = attr; 1841 bulk.sa_data = userdata; 1842 bulk.sa_data_func = locator; 1843 bulk.sa_length = buflen; 1844 1845 mutex_enter(&hdl->sa_lock); 1846 error = sa_bulk_update_impl(hdl, &bulk, 1, tx); 1847 mutex_exit(&hdl->sa_lock); 1848 return (error); 1849} 1850 1851/* 1852 * Return size of an attribute 1853 */ 1854 1855int 1856sa_size(sa_handle_t *hdl, sa_attr_type_t attr, int *size) 1857{ 1858 sa_bulk_attr_t bulk; 1859 int error; 1860 1861 bulk.sa_data = NULL; 1862 bulk.sa_attr = attr; 1863 bulk.sa_data_func = NULL; 1864 1865 ASSERT(hdl); 1866 mutex_enter(&hdl->sa_lock); 1867 if ((error = sa_attr_op(hdl, &bulk, 1, SA_LOOKUP, NULL)) != 0) { 1868 mutex_exit(&hdl->sa_lock); 1869 return (error); 1870 } 1871 *size = bulk.sa_size; 1872 1873 mutex_exit(&hdl->sa_lock); 1874 return (0); 1875} 1876 1877int 1878sa_bulk_lookup_locked(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count) 1879{ 1880 ASSERT(hdl); 1881 ASSERT(MUTEX_HELD(&hdl->sa_lock)); 1882 return (sa_lookup_impl(hdl, attrs, count)); 1883} 1884 1885int 1886sa_bulk_lookup(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count) 1887{ 1888 int error; 1889 1890 ASSERT(hdl); 1891 mutex_enter(&hdl->sa_lock); 1892 error = sa_bulk_lookup_locked(hdl, attrs, count); 1893 mutex_exit(&hdl->sa_lock); 1894 return (error); 1895} 1896 1897int 1898sa_bulk_update(sa_handle_t *hdl, sa_bulk_attr_t *attrs, int count, dmu_tx_t *tx) 1899{ 1900 int error; 1901 1902 ASSERT(hdl); 1903 mutex_enter(&hdl->sa_lock); 1904 error = sa_bulk_update_impl(hdl, attrs, count, tx); 1905 mutex_exit(&hdl->sa_lock); 1906 return (error); 1907} 1908 1909int 1910sa_remove(sa_handle_t *hdl, sa_attr_type_t attr, dmu_tx_t *tx) 1911{ 1912 int error; 1913 1914 mutex_enter(&hdl->sa_lock); 1915 error = sa_modify_attrs(hdl, attr, SA_REMOVE, NULL, 1916 NULL, 0, tx); 1917 mutex_exit(&hdl->sa_lock); 1918 return (error); 1919} 1920 1921void 1922sa_object_info(sa_handle_t *hdl, dmu_object_info_t *doi) 1923{ 1924 dmu_object_info_from_db((dmu_buf_t *)hdl->sa_bonus, doi); 1925} 1926 1927void 1928sa_object_size(sa_handle_t *hdl, uint32_t *blksize, u_longlong_t *nblocks) 1929{ 1930 dmu_object_size_from_db((dmu_buf_t *)hdl->sa_bonus, 1931 blksize, nblocks); 1932} 1933 1934void 1935sa_set_userp(sa_handle_t *hdl, void *ptr) 1936{ 1937 hdl->sa_userp = ptr; 1938} 1939 1940dmu_buf_t * 1941sa_get_db(sa_handle_t *hdl) 1942{ 1943 return ((dmu_buf_t *)hdl->sa_bonus); 1944} 1945 1946void * 1947sa_get_userdata(sa_handle_t *hdl) 1948{ 1949 return (hdl->sa_userp); 1950} 1951 1952void 1953sa_register_update_callback_locked(objset_t *os, sa_update_cb_t *func) 1954{ 1955 ASSERT(MUTEX_HELD(&os->os_sa->sa_lock)); 1956 os->os_sa->sa_update_cb = func; 1957} 1958 1959void 1960sa_register_update_callback(objset_t *os, sa_update_cb_t *func) 1961{ 1962 1963 mutex_enter(&os->os_sa->sa_lock); 1964 sa_register_update_callback_locked(os, func); 1965 mutex_exit(&os->os_sa->sa_lock); 1966} 1967 1968uint64_t 1969sa_handle_object(sa_handle_t *hdl) 1970{ 1971 return (hdl->sa_bonus->db_object); 1972} 1973 1974boolean_t 1975sa_enabled(objset_t *os) 1976{ 1977 return (os->os_sa == NULL); 1978} 1979 1980int 1981sa_set_sa_object(objset_t *os, uint64_t sa_object) 1982{ 1983 sa_os_t *sa = os->os_sa; 1984 1985 if (sa->sa_master_obj) 1986 return (1); 1987 1988 sa->sa_master_obj = sa_object; 1989 1990 return (0); 1991} 1992 1993int 1994sa_hdrsize(void *arg) 1995{ 1996 sa_hdr_phys_t *hdr = arg; 1997 1998 return (SA_HDR_SIZE(hdr)); 1999} 2000 2001void 2002sa_handle_lock(sa_handle_t *hdl) 2003{ 2004 ASSERT(hdl); 2005 mutex_enter(&hdl->sa_lock); 2006} 2007 2008void 2009sa_handle_unlock(sa_handle_t *hdl) 2010{ 2011 ASSERT(hdl); 2012 mutex_exit(&hdl->sa_lock); 2013} 2014