1 789 ahrens /* 2 789 ahrens * CDDL HEADER START 3 789 ahrens * 4 789 ahrens * The contents of this file are subject to the terms of the 5 1491 ahrens * Common Development and Distribution License (the "License"). 6 1491 ahrens * You may not use this file except in compliance with the License. 7 789 ahrens * 8 789 ahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 789 ahrens * or http://www.opensolaris.org/os/licensing. 10 789 ahrens * See the License for the specific language governing permissions 11 789 ahrens * and limitations under the License. 12 789 ahrens * 13 789 ahrens * When distributing Covered Code, include this CDDL HEADER in each 14 789 ahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 789 ahrens * If applicable, add the following below this CDDL HEADER, with the 16 789 ahrens * fields enclosed by brackets "[]" replaced with your own identifying 17 789 ahrens * information: Portions Copyright [yyyy] [name of copyright owner] 18 789 ahrens * 19 789 ahrens * CDDL HEADER END 20 789 ahrens */ 21 789 ahrens /* 22 8748 Tim * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 789 ahrens * Use is subject to license terms. 24 789 ahrens */ 25 789 ahrens 26 10922 Jeff #include <sys/zio.h> 27 789 ahrens #include <sys/spa.h> 28 789 ahrens #include <sys/dmu.h> 29 789 ahrens #include <sys/zfs_context.h> 30 789 ahrens #include <sys/zap.h> 31 1544 eschrock #include <sys/refcount.h> 32 789 ahrens #include <sys/zap_impl.h> 33 885 ahrens #include <sys/zap_leaf.h> 34 789 ahrens #include <sys/avl.h> 35 5498 timh 36 5498 timh #ifdef _KERNEL 37 5498 timh #include <sys/sunddi.h> 38 5498 timh #endif 39 789 ahrens 40 10922 Jeff static int mzap_upgrade(zap_t **zapp, dmu_tx_t *tx, zap_flags_t flags); 41 789 ahrens 42 10922 Jeff uint64_t 43 10922 Jeff zap_getflags(zap_t *zap) 44 10922 Jeff { 45 10922 Jeff if (zap->zap_ismicro) 46 10922 Jeff return (0); 47 10922 Jeff return (zap->zap_u.zap_fat.zap_phys->zap_flags); 48 10922 Jeff } 49 10922 Jeff 50 10922 Jeff int 51 10922 Jeff zap_hashbits(zap_t *zap) 52 10922 Jeff { 53 10922 Jeff if (zap_getflags(zap) & ZAP_FLAG_HASH64) 54 10922 Jeff return (48); 55 10922 Jeff else 56 10922 Jeff return (28); 57 10922 Jeff } 58 10922 Jeff 59 10922 Jeff uint32_t 60 10922 Jeff zap_maxcd(zap_t *zap) 61 10922 Jeff { 62 10922 Jeff if (zap_getflags(zap) & ZAP_FLAG_HASH64) 63 10922 Jeff return ((1<<16)-1); 64 10922 Jeff else 65 10922 Jeff return (-1U); 66 10922 Jeff } 67 5331 amw 68 5331 amw static uint64_t 69 10922 Jeff zap_hash(zap_name_t *zn) 70 5331 amw { 71 10922 Jeff zap_t *zap = zn->zn_zap; 72 10922 Jeff uint64_t h = 0; 73 5331 amw 74 10922 Jeff if (zap_getflags(zap) & ZAP_FLAG_PRE_HASHED_KEY) { 75 10922 Jeff ASSERT(zap_getflags(zap) & ZAP_FLAG_UINT64_KEY); 76 10922 Jeff h = *(uint64_t *)zn->zn_key_orig; 77 10922 Jeff } else { 78 10922 Jeff h = zap->zap_salt; 79 10922 Jeff ASSERT(h != 0); 80 10922 Jeff ASSERT(zfs_crc64_table[128] == ZFS_CRC64_POLY); 81 10922 Jeff 82 11165 Matthew if (zap_getflags(zap) & ZAP_FLAG_UINT64_KEY) { 83 11165 Matthew int i; 84 11165 Matthew const uint64_t *wp = zn->zn_key_norm; 85 10922 Jeff 86 11165 Matthew ASSERT(zn->zn_key_intlen == 8); 87 11165 Matthew for (i = 0; i < zn->zn_key_norm_numints; wp++, i++) { 88 11165 Matthew int j; 89 11165 Matthew uint64_t word = *wp; 90 10922 Jeff 91 11165 Matthew for (j = 0; j < zn->zn_key_intlen; j++) { 92 11165 Matthew h = (h >> 8) ^ 93 11165 Matthew zfs_crc64_table[(h ^ word) & 0xFF]; 94 11165 Matthew word >>= NBBY; 95 11165 Matthew } 96 11165 Matthew } 97 11165 Matthew } else { 98 11165 Matthew int i, len; 99 11165 Matthew const uint8_t *cp = zn->zn_key_norm; 100 11165 Matthew 101 11165 Matthew /* 102 11165 Matthew * We previously stored the terminating null on 103 11165 Matthew * disk, but didn't hash it, so we need to 104 11165 Matthew * continue to not hash it. (The 105 11165 Matthew * zn_key_*_numints includes the terminating 106 11165 Matthew * null for non-binary keys.) 107 11165 Matthew */ 108 11165 Matthew len = zn->zn_key_norm_numints - 1; 109 11165 Matthew 110 11165 Matthew ASSERT(zn->zn_key_intlen == 1); 111 11165 Matthew for (i = 0; i < len; cp++, i++) { 112 11165 Matthew h = (h >> 8) ^ 113 11165 Matthew zfs_crc64_table[(h ^ *cp) & 0xFF]; 114 11165 Matthew } 115 11165 Matthew } 116 5331 amw } 117 5331 amw /* 118 10922 Jeff * Don't use all 64 bits, since we need some in the cookie for 119 10922 Jeff * the collision differentiator. We MUST use the high bits, 120 10922 Jeff * since those are the ones that we first pay attention to when 121 5331 amw * chosing the bucket. 122 5331 amw */ 123 10922 Jeff h &= ~((1ULL << (64 - zap_hashbits(zap))) - 1); 124 5331 amw 125 10922 Jeff return (h); 126 5331 amw } 127 5331 amw 128 5331 amw static int 129 5331 amw zap_normalize(zap_t *zap, const char *name, char *namenorm) 130 5331 amw { 131 5331 amw size_t inlen, outlen; 132 5331 amw int err; 133 10922 Jeff 134 10922 Jeff ASSERT(!(zap_getflags(zap) & ZAP_FLAG_UINT64_KEY)); 135 5331 amw 136 5331 amw inlen = strlen(name) + 1; 137 5331 amw outlen = ZAP_MAXNAMELEN; 138 5331 amw 139 5331 amw err = 0; 140 5331 amw (void) u8_textprep_str((char *)name, &inlen, namenorm, &outlen, 141 8748 Tim zap->zap_normflags | U8_TEXTPREP_IGNORE_NULL | 142 8748 Tim U8_TEXTPREP_IGNORE_INVALID, U8_UNICODE_LATEST, &err); 143 5331 amw 144 5331 amw return (err); 145 5331 amw } 146 5331 amw 147 5331 amw boolean_t 148 5331 amw zap_match(zap_name_t *zn, const char *matchname) 149 5331 amw { 150 10922 Jeff ASSERT(!(zap_getflags(zn->zn_zap) & ZAP_FLAG_UINT64_KEY)); 151 10922 Jeff 152 5331 amw if (zn->zn_matchtype == MT_FIRST) { 153 5331 amw char norm[ZAP_MAXNAMELEN]; 154 5331 amw 155 5331 amw if (zap_normalize(zn->zn_zap, matchname, norm) != 0) 156 5331 amw return (B_FALSE); 157 5331 amw 158 10922 Jeff return (strcmp(zn->zn_key_norm, norm) == 0); 159 5331 amw } else { 160 5331 amw /* MT_BEST or MT_EXACT */ 161 10922 Jeff return (strcmp(zn->zn_key_orig, matchname) == 0); 162 5331 amw } 163 5331 amw } 164 5331 amw 165 5331 amw void 166 5331 amw zap_name_free(zap_name_t *zn) 167 5331 amw { 168 5331 amw kmem_free(zn, sizeof (zap_name_t)); 169 5331 amw } 170 5331 amw 171 5331 amw zap_name_t * 172 10922 Jeff zap_name_alloc(zap_t *zap, const char *key, matchtype_t mt) 173 5331 amw { 174 5331 amw zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP); 175 5331 amw 176 5331 amw zn->zn_zap = zap; 177 10922 Jeff zn->zn_key_intlen = sizeof (*key); 178 10922 Jeff zn->zn_key_orig = key; 179 11165 Matthew zn->zn_key_orig_numints = strlen(zn->zn_key_orig) + 1; 180 5331 amw zn->zn_matchtype = mt; 181 5331 amw if (zap->zap_normflags) { 182 10922 Jeff if (zap_normalize(zap, key, zn->zn_normbuf) != 0) { 183 5331 amw zap_name_free(zn); 184 5331 amw return (NULL); 185 5331 amw } 186 10922 Jeff zn->zn_key_norm = zn->zn_normbuf; 187 11165 Matthew zn->zn_key_norm_numints = strlen(zn->zn_key_norm) + 1; 188 5331 amw } else { 189 5331 amw if (mt != MT_EXACT) { 190 5331 amw zap_name_free(zn); 191 5331 amw return (NULL); 192 5331 amw } 193 10922 Jeff zn->zn_key_norm = zn->zn_key_orig; 194 11165 Matthew zn->zn_key_norm_numints = zn->zn_key_orig_numints; 195 5331 amw } 196 5331 amw 197 10922 Jeff zn->zn_hash = zap_hash(zn); 198 10922 Jeff return (zn); 199 10922 Jeff } 200 10922 Jeff 201 10922 Jeff zap_name_t * 202 10922 Jeff zap_name_alloc_uint64(zap_t *zap, const uint64_t *key, int numints) 203 10922 Jeff { 204 10922 Jeff zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP); 205 10922 Jeff 206 10922 Jeff ASSERT(zap->zap_normflags == 0); 207 10922 Jeff zn->zn_zap = zap; 208 10922 Jeff zn->zn_key_intlen = sizeof (*key); 209 10922 Jeff zn->zn_key_orig = zn->zn_key_norm = key; 210 11165 Matthew zn->zn_key_orig_numints = zn->zn_key_norm_numints = numints; 211 10922 Jeff zn->zn_matchtype = MT_EXACT; 212 10922 Jeff 213 10922 Jeff zn->zn_hash = zap_hash(zn); 214 5331 amw return (zn); 215 5331 amw } 216 789 ahrens 217 789 ahrens static void 218 789 ahrens mzap_byteswap(mzap_phys_t *buf, size_t size) 219 789 ahrens { 220 789 ahrens int i, max; 221 789 ahrens buf->mz_block_type = BSWAP_64(buf->mz_block_type); 222 789 ahrens buf->mz_salt = BSWAP_64(buf->mz_salt); 223 6492 timh buf->mz_normflags = BSWAP_64(buf->mz_normflags); 224 789 ahrens max = (size / MZAP_ENT_LEN) - 1; 225 789 ahrens for (i = 0; i < max; i++) { 226 789 ahrens buf->mz_chunk[i].mze_value = 227 789 ahrens BSWAP_64(buf->mz_chunk[i].mze_value); 228 789 ahrens buf->mz_chunk[i].mze_cd = 229 789 ahrens BSWAP_32(buf->mz_chunk[i].mze_cd); 230 789 ahrens } 231 789 ahrens } 232 789 ahrens 233 789 ahrens void 234 789 ahrens zap_byteswap(void *buf, size_t size) 235 789 ahrens { 236 789 ahrens uint64_t block_type; 237 789 ahrens 238 789 ahrens block_type = *(uint64_t *)buf; 239 789 ahrens 240 2856 nd150628 if (block_type == ZBT_MICRO || block_type == BSWAP_64(ZBT_MICRO)) { 241 789 ahrens /* ASSERT(magic == ZAP_LEAF_MAGIC); */ 242 789 ahrens mzap_byteswap(buf, size); 243 2856 nd150628 } else { 244 789 ahrens fzap_byteswap(buf, size); 245 789 ahrens } 246 789 ahrens } 247 789 ahrens 248 789 ahrens static int 249 789 ahrens mze_compare(const void *arg1, const void *arg2) 250 789 ahrens { 251 789 ahrens const mzap_ent_t *mze1 = arg1; 252 789 ahrens const mzap_ent_t *mze2 = arg2; 253 789 ahrens 254 789 ahrens if (mze1->mze_hash > mze2->mze_hash) 255 789 ahrens return (+1); 256 789 ahrens if (mze1->mze_hash < mze2->mze_hash) 257 789 ahrens return (-1); 258 789 ahrens if (mze1->mze_phys.mze_cd > mze2->mze_phys.mze_cd) 259 789 ahrens return (+1); 260 789 ahrens if (mze1->mze_phys.mze_cd < mze2->mze_phys.mze_cd) 261 789 ahrens return (-1); 262 789 ahrens return (0); 263 789 ahrens } 264 789 ahrens 265 789 ahrens static void 266 789 ahrens mze_insert(zap_t *zap, int chunkid, uint64_t hash, mzap_ent_phys_t *mzep) 267 789 ahrens { 268 789 ahrens mzap_ent_t *mze; 269 789 ahrens 270 789 ahrens ASSERT(zap->zap_ismicro); 271 789 ahrens ASSERT(RW_WRITE_HELD(&zap->zap_rwlock)); 272 10922 Jeff ASSERT(mzep->mze_cd < zap_maxcd(zap)); 273 789 ahrens 274 789 ahrens mze = kmem_alloc(sizeof (mzap_ent_t), KM_SLEEP); 275 789 ahrens mze->mze_chunkid = chunkid; 276 789 ahrens mze->mze_hash = hash; 277 789 ahrens mze->mze_phys = *mzep; 278 789 ahrens avl_add(&zap->zap_m.zap_avl, mze); 279 789 ahrens } 280 789 ahrens 281 789 ahrens static mzap_ent_t * 282 5331 amw mze_find(zap_name_t *zn) 283 789 ahrens { 284 789 ahrens mzap_ent_t mze_tofind; 285 789 ahrens mzap_ent_t *mze; 286 789 ahrens avl_index_t idx; 287 5331 amw avl_tree_t *avl = &zn->zn_zap->zap_m.zap_avl; 288 789 ahrens 289 5331 amw ASSERT(zn->zn_zap->zap_ismicro); 290 5331 amw ASSERT(RW_LOCK_HELD(&zn->zn_zap->zap_rwlock)); 291 789 ahrens 292 5331 amw mze_tofind.mze_hash = zn->zn_hash; 293 789 ahrens mze_tofind.mze_phys.mze_cd = 0; 294 789 ahrens 295 5331 amw again: 296 789 ahrens mze = avl_find(avl, &mze_tofind, &idx); 297 789 ahrens if (mze == NULL) 298 789 ahrens mze = avl_nearest(avl, idx, AVL_AFTER); 299 5331 amw for (; mze && mze->mze_hash == zn->zn_hash; mze = AVL_NEXT(avl, mze)) { 300 5331 amw if (zap_match(zn, mze->mze_phys.mze_name)) 301 789 ahrens return (mze); 302 5331 amw } 303 5331 amw if (zn->zn_matchtype == MT_BEST) { 304 5331 amw zn->zn_matchtype = MT_FIRST; 305 5331 amw goto again; 306 789 ahrens } 307 789 ahrens return (NULL); 308 789 ahrens } 309 789 ahrens 310 789 ahrens static uint32_t 311 789 ahrens mze_find_unused_cd(zap_t *zap, uint64_t hash) 312 789 ahrens { 313 789 ahrens mzap_ent_t mze_tofind; 314 789 ahrens mzap_ent_t *mze; 315 789 ahrens avl_index_t idx; 316 789 ahrens avl_tree_t *avl = &zap->zap_m.zap_avl; 317 789 ahrens uint32_t cd; 318 789 ahrens 319 789 ahrens ASSERT(zap->zap_ismicro); 320 789 ahrens ASSERT(RW_LOCK_HELD(&zap->zap_rwlock)); 321 789 ahrens 322 789 ahrens mze_tofind.mze_hash = hash; 323 789 ahrens mze_tofind.mze_phys.mze_cd = 0; 324 789 ahrens 325 789 ahrens cd = 0; 326 789 ahrens for (mze = avl_find(avl, &mze_tofind, &idx); 327 789 ahrens mze && mze->mze_hash == hash; mze = AVL_NEXT(avl, mze)) { 328 789 ahrens if (mze->mze_phys.mze_cd != cd) 329 789 ahrens break; 330 789 ahrens cd++; 331 789 ahrens } 332 789 ahrens 333 789 ahrens return (cd); 334 789 ahrens } 335 789 ahrens 336 789 ahrens static void 337 789 ahrens mze_remove(zap_t *zap, mzap_ent_t *mze) 338 789 ahrens { 339 789 ahrens ASSERT(zap->zap_ismicro); 340 789 ahrens ASSERT(RW_WRITE_HELD(&zap->zap_rwlock)); 341 789 ahrens 342 789 ahrens avl_remove(&zap->zap_m.zap_avl, mze); 343 789 ahrens kmem_free(mze, sizeof (mzap_ent_t)); 344 789 ahrens } 345 789 ahrens 346 789 ahrens static void 347 789 ahrens mze_destroy(zap_t *zap) 348 789 ahrens { 349 789 ahrens mzap_ent_t *mze; 350 789 ahrens void *avlcookie = NULL; 351 789 ahrens 352 789 ahrens while (mze = avl_destroy_nodes(&zap->zap_m.zap_avl, &avlcookie)) 353 789 ahrens kmem_free(mze, sizeof (mzap_ent_t)); 354 789 ahrens avl_destroy(&zap->zap_m.zap_avl); 355 789 ahrens } 356 789 ahrens 357 789 ahrens static zap_t * 358 789 ahrens mzap_open(objset_t *os, uint64_t obj, dmu_buf_t *db) 359 789 ahrens { 360 789 ahrens zap_t *winner; 361 789 ahrens zap_t *zap; 362 789 ahrens int i; 363 789 ahrens 364 789 ahrens ASSERT3U(MZAP_ENT_LEN, ==, sizeof (mzap_ent_phys_t)); 365 789 ahrens 366 789 ahrens zap = kmem_zalloc(sizeof (zap_t), KM_SLEEP); 367 789 ahrens rw_init(&zap->zap_rwlock, 0, 0, 0); 368 789 ahrens rw_enter(&zap->zap_rwlock, RW_WRITER); 369 789 ahrens zap->zap_objset = os; 370 789 ahrens zap->zap_object = obj; 371 789 ahrens zap->zap_dbuf = db; 372 789 ahrens 373 5331 amw if (*(uint64_t *)db->db_data != ZBT_MICRO) { 374 789 ahrens mutex_init(&zap->zap_f.zap_num_entries_mtx, 0, 0, 0); 375 1491 ahrens zap->zap_f.zap_block_shift = highbit(db->db_size) - 1; 376 789 ahrens } else { 377 789 ahrens zap->zap_ismicro = TRUE; 378 789 ahrens } 379 789 ahrens 380 789 ahrens /* 381 789 ahrens * Make sure that zap_ismicro is set before we let others see 382 789 ahrens * it, because zap_lockdir() checks zap_ismicro without the lock 383 789 ahrens * held. 384 789 ahrens */ 385 2641 ahrens winner = dmu_buf_set_user(db, zap, &zap->zap_m.zap_phys, zap_evict); 386 789 ahrens 387 789 ahrens if (winner != NULL) { 388 4831 gw25295 rw_exit(&zap->zap_rwlock); 389 4831 gw25295 rw_destroy(&zap->zap_rwlock); 390 4831 gw25295 if (!zap->zap_ismicro) 391 4831 gw25295 mutex_destroy(&zap->zap_f.zap_num_entries_mtx); 392 789 ahrens kmem_free(zap, sizeof (zap_t)); 393 789 ahrens return (winner); 394 789 ahrens } 395 789 ahrens 396 789 ahrens if (zap->zap_ismicro) { 397 789 ahrens zap->zap_salt = zap->zap_m.zap_phys->mz_salt; 398 5331 amw zap->zap_normflags = zap->zap_m.zap_phys->mz_normflags; 399 789 ahrens zap->zap_m.zap_num_chunks = db->db_size / MZAP_ENT_LEN - 1; 400 789 ahrens avl_create(&zap->zap_m.zap_avl, mze_compare, 401 789 ahrens sizeof (mzap_ent_t), offsetof(mzap_ent_t, mze_node)); 402 789 ahrens 403 789 ahrens for (i = 0; i < zap->zap_m.zap_num_chunks; i++) { 404 789 ahrens mzap_ent_phys_t *mze = 405 789 ahrens &zap->zap_m.zap_phys->mz_chunk[i]; 406 789 ahrens if (mze->mze_name[0]) { 407 5331 amw zap_name_t *zn; 408 5331 amw 409 789 ahrens zap->zap_m.zap_num_entries++; 410 5331 amw zn = zap_name_alloc(zap, mze->mze_name, 411 5331 amw MT_EXACT); 412 5331 amw mze_insert(zap, i, zn->zn_hash, mze); 413 5331 amw zap_name_free(zn); 414 789 ahrens } 415 789 ahrens } 416 789 ahrens } else { 417 789 ahrens zap->zap_salt = zap->zap_f.zap_phys->zap_salt; 418 5331 amw zap->zap_normflags = zap->zap_f.zap_phys->zap_normflags; 419 1491 ahrens 420 1491 ahrens ASSERT3U(sizeof (struct zap_leaf_header), ==, 421 1491 ahrens 2*ZAP_LEAF_CHUNKSIZE); 422 1491 ahrens 423 1491 ahrens /* 424 1491 ahrens * The embedded pointer table should not overlap the 425 1491 ahrens * other members. 426 1491 ahrens */ 427 1491 ahrens ASSERT3P(&ZAP_EMBEDDED_PTRTBL_ENT(zap, 0), >, 428 1491 ahrens &zap->zap_f.zap_phys->zap_salt); 429 1491 ahrens 430 1491 ahrens /* 431 1491 ahrens * The embedded pointer table should end at the end of 432 1491 ahrens * the block 433 1491 ahrens */ 434 1491 ahrens ASSERT3U((uintptr_t)&ZAP_EMBEDDED_PTRTBL_ENT(zap, 435 1491 ahrens 1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)) - 436 1491 ahrens (uintptr_t)zap->zap_f.zap_phys, ==, 437 1491 ahrens zap->zap_dbuf->db_size); 438 789 ahrens } 439 789 ahrens rw_exit(&zap->zap_rwlock); 440 789 ahrens return (zap); 441 789 ahrens } 442 789 ahrens 443 789 ahrens int 444 789 ahrens zap_lockdir(objset_t *os, uint64_t obj, dmu_tx_t *tx, 445 5384 ahrens krw_t lti, boolean_t fatreader, boolean_t adding, zap_t **zapp) 446 789 ahrens { 447 789 ahrens zap_t *zap; 448 789 ahrens dmu_buf_t *db; 449 789 ahrens krw_t lt; 450 789 ahrens int err; 451 789 ahrens 452 789 ahrens *zapp = NULL; 453 789 ahrens 454 1544 eschrock err = dmu_buf_hold(os, obj, 0, NULL, &db); 455 1544 eschrock if (err) 456 1544 eschrock return (err); 457 789 ahrens 458 789 ahrens #ifdef ZFS_DEBUG 459 789 ahrens { 460 789 ahrens dmu_object_info_t doi; 461 789 ahrens dmu_object_info_from_db(db, &doi); 462 789 ahrens ASSERT(dmu_ot[doi.doi_type].ot_byteswap == zap_byteswap); 463 789 ahrens } 464 789 ahrens #endif 465 789 ahrens 466 789 ahrens zap = dmu_buf_get_user(db); 467 789 ahrens if (zap == NULL) 468 789 ahrens zap = mzap_open(os, obj, db); 469 789 ahrens 470 789 ahrens /* 471 789 ahrens * We're checking zap_ismicro without the lock held, in order to 472 789 ahrens * tell what type of lock we want. Once we have some sort of 473 789 ahrens * lock, see if it really is the right type. In practice this 474 789 ahrens * can only be different if it was upgraded from micro to fat, 475 789 ahrens * and micro wanted WRITER but fat only needs READER. 476 789 ahrens */ 477 789 ahrens lt = (!zap->zap_ismicro && fatreader) ? RW_READER : lti; 478 789 ahrens rw_enter(&zap->zap_rwlock, lt); 479 789 ahrens if (lt != ((!zap->zap_ismicro && fatreader) ? RW_READER : lti)) { 480 789 ahrens /* it was upgraded, now we only need reader */ 481 789 ahrens ASSERT(lt == RW_WRITER); 482 789 ahrens ASSERT(RW_READER == 483 789 ahrens (!zap->zap_ismicro && fatreader) ? RW_READER : lti); 484 789 ahrens rw_downgrade(&zap->zap_rwlock); 485 789 ahrens lt = RW_READER; 486 789 ahrens } 487 789 ahrens 488 789 ahrens zap->zap_objset = os; 489 789 ahrens 490 789 ahrens if (lt == RW_WRITER) 491 789 ahrens dmu_buf_will_dirty(db, tx); 492 789 ahrens 493 789 ahrens ASSERT3P(zap->zap_dbuf, ==, db); 494 789 ahrens 495 789 ahrens ASSERT(!zap->zap_ismicro || 496 789 ahrens zap->zap_m.zap_num_entries <= zap->zap_m.zap_num_chunks); 497 5384 ahrens if (zap->zap_ismicro && tx && adding && 498 789 ahrens zap->zap_m.zap_num_entries == zap->zap_m.zap_num_chunks) { 499 789 ahrens uint64_t newsz = db->db_size + SPA_MINBLOCKSIZE; 500 789 ahrens if (newsz > MZAP_MAX_BLKSZ) { 501 789 ahrens dprintf("upgrading obj %llu: num_entries=%u\n", 502 789 ahrens obj, zap->zap_m.zap_num_entries); 503 789 ahrens *zapp = zap; 504 10922 Jeff return (mzap_upgrade(zapp, tx, 0)); 505 789 ahrens } 506 789 ahrens err = dmu_object_set_blocksize(os, obj, newsz, 0, tx); 507 789 ahrens ASSERT3U(err, ==, 0); 508 789 ahrens zap->zap_m.zap_num_chunks = 509 789 ahrens db->db_size / MZAP_ENT_LEN - 1; 510 789 ahrens } 511 789 ahrens 512 789 ahrens *zapp = zap; 513 789 ahrens return (0); 514 789 ahrens } 515 789 ahrens 516 789 ahrens void 517 789 ahrens zap_unlockdir(zap_t *zap) 518 789 ahrens { 519 789 ahrens rw_exit(&zap->zap_rwlock); 520 1544 eschrock dmu_buf_rele(zap->zap_dbuf, NULL); 521 789 ahrens } 522 789 ahrens 523 5497 bonwick static int 524 10922 Jeff mzap_upgrade(zap_t **zapp, dmu_tx_t *tx, zap_flags_t flags) 525 789 ahrens { 526 789 ahrens mzap_phys_t *mzp; 527 10922 Jeff int i, sz, nchunks; 528 10922 Jeff int err = 0; 529 5497 bonwick zap_t *zap = *zapp; 530 789 ahrens 531 789 ahrens ASSERT(RW_WRITE_HELD(&zap->zap_rwlock)); 532 789 ahrens 533 789 ahrens sz = zap->zap_dbuf->db_size; 534 789 ahrens mzp = kmem_alloc(sz, KM_SLEEP); 535 789 ahrens bcopy(zap->zap_dbuf->db_data, mzp, sz); 536 789 ahrens nchunks = zap->zap_m.zap_num_chunks; 537 789 ahrens 538 10922 Jeff if (!flags) { 539 10922 Jeff err = dmu_object_set_blocksize(zap->zap_objset, zap->zap_object, 540 10922 Jeff 1ULL << fzap_default_block_shift, 0, tx); 541 10922 Jeff if (err) { 542 10922 Jeff kmem_free(mzp, sz); 543 10922 Jeff return (err); 544 10922 Jeff } 545 5497 bonwick } 546 789 ahrens 547 789 ahrens dprintf("upgrading obj=%llu with %u chunks\n", 548 789 ahrens zap->zap_object, nchunks); 549 5331 amw /* XXX destroy the avl later, so we can use the stored hash value */ 550 789 ahrens mze_destroy(zap); 551 789 ahrens 552 10922 Jeff fzap_upgrade(zap, tx, flags); 553 789 ahrens 554 789 ahrens for (i = 0; i < nchunks; i++) { 555 789 ahrens mzap_ent_phys_t *mze = &mzp->mz_chunk[i]; 556 5331 amw zap_name_t *zn; 557 789 ahrens if (mze->mze_name[0] == 0) 558 789 ahrens continue; 559 789 ahrens dprintf("adding %s=%llu\n", 560 789 ahrens mze->mze_name, mze->mze_value); 561 5331 amw zn = zap_name_alloc(zap, mze->mze_name, MT_EXACT); 562 5497 bonwick err = fzap_add_cd(zn, 8, 1, &mze->mze_value, mze->mze_cd, tx); 563 5497 bonwick zap = zn->zn_zap; /* fzap_add_cd() may change zap */ 564 5331 amw zap_name_free(zn); 565 5497 bonwick if (err) 566 5497 bonwick break; 567 789 ahrens } 568 789 ahrens kmem_free(mzp, sz); 569 5497 bonwick *zapp = zap; 570 5497 bonwick return (err); 571 789 ahrens } 572 789 ahrens 573 789 ahrens static void 574 10922 Jeff mzap_create_impl(objset_t *os, uint64_t obj, int normflags, zap_flags_t flags, 575 10922 Jeff dmu_tx_t *tx) 576 789 ahrens { 577 789 ahrens dmu_buf_t *db; 578 789 ahrens mzap_phys_t *zp; 579 789 ahrens 580 1544 eschrock VERIFY(0 == dmu_buf_hold(os, obj, 0, FTAG, &db)); 581 789 ahrens 582 789 ahrens #ifdef ZFS_DEBUG 583 789 ahrens { 584 789 ahrens dmu_object_info_t doi; 585 789 ahrens dmu_object_info_from_db(db, &doi); 586 789 ahrens ASSERT(dmu_ot[doi.doi_type].ot_byteswap == zap_byteswap); 587 789 ahrens } 588 789 ahrens #endif 589 789 ahrens 590 789 ahrens dmu_buf_will_dirty(db, tx); 591 789 ahrens zp = db->db_data; 592 789 ahrens zp->mz_block_type = ZBT_MICRO; 593 789 ahrens zp->mz_salt = ((uintptr_t)db ^ (uintptr_t)tx ^ (obj << 1)) | 1ULL; 594 5331 amw zp->mz_normflags = normflags; 595 1544 eschrock dmu_buf_rele(db, FTAG); 596 10922 Jeff 597 10922 Jeff if (flags != 0) { 598 10922 Jeff zap_t *zap; 599 10922 Jeff /* Only fat zap supports flags; upgrade immediately. */ 600 10922 Jeff VERIFY(0 == zap_lockdir(os, obj, tx, RW_WRITER, 601 10922 Jeff B_FALSE, B_FALSE, &zap)); 602 10922 Jeff VERIFY3U(0, ==, mzap_upgrade(&zap, tx, flags)); 603 10922 Jeff zap_unlockdir(zap); 604 10922 Jeff } 605 789 ahrens } 606 789 ahrens 607 789 ahrens int 608 789 ahrens zap_create_claim(objset_t *os, uint64_t obj, dmu_object_type_t ot, 609 789 ahrens dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 610 789 ahrens { 611 5331 amw return (zap_create_claim_norm(os, obj, 612 5331 amw 0, ot, bonustype, bonuslen, tx)); 613 5331 amw } 614 5331 amw 615 5331 amw int 616 5331 amw zap_create_claim_norm(objset_t *os, uint64_t obj, int normflags, 617 5331 amw dmu_object_type_t ot, 618 5331 amw dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 619 5331 amw { 620 789 ahrens int err; 621 789 ahrens 622 789 ahrens err = dmu_object_claim(os, obj, ot, 0, bonustype, bonuslen, tx); 623 789 ahrens if (err != 0) 624 789 ahrens return (err); 625 10922 Jeff mzap_create_impl(os, obj, normflags, 0, tx); 626 789 ahrens return (0); 627 789 ahrens } 628 789 ahrens 629 789 ahrens uint64_t 630 789 ahrens zap_create(objset_t *os, dmu_object_type_t ot, 631 789 ahrens dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 632 789 ahrens { 633 5331 amw return (zap_create_norm(os, 0, ot, bonustype, bonuslen, tx)); 634 5331 amw } 635 5331 amw 636 5331 amw uint64_t 637 5331 amw zap_create_norm(objset_t *os, int normflags, dmu_object_type_t ot, 638 5331 amw dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 639 5331 amw { 640 789 ahrens uint64_t obj = dmu_object_alloc(os, ot, 0, bonustype, bonuslen, tx); 641 789 ahrens 642 10922 Jeff mzap_create_impl(os, obj, normflags, 0, tx); 643 10922 Jeff return (obj); 644 10922 Jeff } 645 10922 Jeff 646 10922 Jeff uint64_t 647 10922 Jeff zap_create_flags(objset_t *os, int normflags, zap_flags_t flags, 648 10922 Jeff dmu_object_type_t ot, int leaf_blockshift, int indirect_blockshift, 649 10922 Jeff dmu_object_type_t bonustype, int bonuslen, dmu_tx_t *tx) 650 10922 Jeff { 651 10922 Jeff uint64_t obj = dmu_object_alloc(os, ot, 0, bonustype, bonuslen, tx); 652 10922 Jeff 653 10922 Jeff ASSERT(leaf_blockshift >= SPA_MINBLOCKSHIFT && 654 10922 Jeff leaf_blockshift <= SPA_MAXBLOCKSHIFT && 655 10922 Jeff indirect_blockshift >= SPA_MINBLOCKSHIFT && 656 10922 Jeff indirect_blockshift <= SPA_MAXBLOCKSHIFT); 657 10922 Jeff 658 10922 Jeff VERIFY(dmu_object_set_blocksize(os, obj, 659 10922 Jeff 1ULL << leaf_blockshift, indirect_blockshift, tx) == 0); 660 10922 Jeff 661 10922 Jeff mzap_create_impl(os, obj, normflags, flags, tx); 662 789 ahrens return (obj); 663 789 ahrens } 664 789 ahrens 665 789 ahrens int 666 789 ahrens zap_destroy(objset_t *os, uint64_t zapobj, dmu_tx_t *tx) 667 789 ahrens { 668 789 ahrens /* 669 789 ahrens * dmu_object_free will free the object number and free the 670 789 ahrens * data. Freeing the data will cause our pageout function to be 671 789 ahrens * called, which will destroy our data (zap_leaf_t's and zap_t). 672 789 ahrens */ 673 789 ahrens 674 789 ahrens return (dmu_object_free(os, zapobj, tx)); 675 789 ahrens } 676 789 ahrens 677 789 ahrens _NOTE(ARGSUSED(0)) 678 789 ahrens void 679 2641 ahrens zap_evict(dmu_buf_t *db, void *vzap) 680 789 ahrens { 681 2641 ahrens zap_t *zap = vzap; 682 789 ahrens 683 789 ahrens rw_destroy(&zap->zap_rwlock); 684 789 ahrens 685 1491 ahrens if (zap->zap_ismicro) 686 789 ahrens mze_destroy(zap); 687 4831 gw25295 else 688 4831 gw25295 mutex_destroy(&zap->zap_f.zap_num_entries_mtx); 689 789 ahrens 690 789 ahrens kmem_free(zap, sizeof (zap_t)); 691 789 ahrens } 692 789 ahrens 693 789 ahrens int 694 789 ahrens zap_count(objset_t *os, uint64_t zapobj, uint64_t *count) 695 789 ahrens { 696 789 ahrens zap_t *zap; 697 789 ahrens int err; 698 789 ahrens 699 5384 ahrens err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 700 789 ahrens if (err) 701 789 ahrens return (err); 702 789 ahrens if (!zap->zap_ismicro) { 703 789 ahrens err = fzap_count(zap, count); 704 789 ahrens } else { 705 789 ahrens *count = zap->zap_m.zap_num_entries; 706 789 ahrens } 707 789 ahrens zap_unlockdir(zap); 708 789 ahrens return (err); 709 789 ahrens } 710 789 ahrens 711 789 ahrens /* 712 5331 amw * zn may be NULL; if not specified, it will be computed if needed. 713 5331 amw * See also the comment above zap_entry_normalization_conflict(). 714 5331 amw */ 715 5331 amw static boolean_t 716 5331 amw mzap_normalization_conflict(zap_t *zap, zap_name_t *zn, mzap_ent_t *mze) 717 5331 amw { 718 5331 amw mzap_ent_t *other; 719 5331 amw int direction = AVL_BEFORE; 720 5331 amw boolean_t allocdzn = B_FALSE; 721 5331 amw 722 5331 amw if (zap->zap_normflags == 0) 723 5331 amw return (B_FALSE); 724 5331 amw 725 5331 amw again: 726 5331 amw for (other = avl_walk(&zap->zap_m.zap_avl, mze, direction); 727 5331 amw other && other->mze_hash == mze->mze_hash; 728 5331 amw other = avl_walk(&zap->zap_m.zap_avl, other, direction)) { 729 5331 amw 730 5331 amw if (zn == NULL) { 731 5331 amw zn = zap_name_alloc(zap, mze->mze_phys.mze_name, 732 5331 amw MT_FIRST); 733 5331 amw allocdzn = B_TRUE; 734 5331 amw } 735 5331 amw if (zap_match(zn, other->mze_phys.mze_name)) { 736 5331 amw if (allocdzn) 737 5331 amw zap_name_free(zn); 738 5331 amw return (B_TRUE); 739 5331 amw } 740 5331 amw } 741 5331 amw 742 5331 amw if (direction == AVL_BEFORE) { 743 5331 amw direction = AVL_AFTER; 744 5331 amw goto again; 745 5331 amw } 746 5331 amw 747 5331 amw if (allocdzn) 748 5331 amw zap_name_free(zn); 749 5331 amw return (B_FALSE); 750 5331 amw } 751 5331 amw 752 5331 amw /* 753 5331 amw * Routines for manipulating attributes. 754 789 ahrens */ 755 789 ahrens 756 789 ahrens int 757 789 ahrens zap_lookup(objset_t *os, uint64_t zapobj, const char *name, 758 789 ahrens uint64_t integer_size, uint64_t num_integers, void *buf) 759 789 ahrens { 760 5331 amw return (zap_lookup_norm(os, zapobj, name, integer_size, 761 5331 amw num_integers, buf, MT_EXACT, NULL, 0, NULL)); 762 5331 amw } 763 5331 amw 764 5331 amw int 765 5331 amw zap_lookup_norm(objset_t *os, uint64_t zapobj, const char *name, 766 5331 amw uint64_t integer_size, uint64_t num_integers, void *buf, 767 5331 amw matchtype_t mt, char *realname, int rn_len, 768 5331 amw boolean_t *ncp) 769 5331 amw { 770 789 ahrens zap_t *zap; 771 789 ahrens int err; 772 789 ahrens mzap_ent_t *mze; 773 5331 amw zap_name_t *zn; 774 789 ahrens 775 5384 ahrens err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 776 789 ahrens if (err) 777 789 ahrens return (err); 778 5331 amw zn = zap_name_alloc(zap, name, mt); 779 5331 amw if (zn == NULL) { 780 5331 amw zap_unlockdir(zap); 781 5331 amw return (ENOTSUP); 782 5331 amw } 783 5331 amw 784 789 ahrens if (!zap->zap_ismicro) { 785 5331 amw err = fzap_lookup(zn, integer_size, num_integers, buf, 786 5331 amw realname, rn_len, ncp); 787 789 ahrens } else { 788 5331 amw mze = mze_find(zn); 789 789 ahrens if (mze == NULL) { 790 789 ahrens err = ENOENT; 791 789 ahrens } else { 792 5331 amw if (num_integers < 1) { 793 789 ahrens err = EOVERFLOW; 794 5331 amw } else if (integer_size != 8) { 795 789 ahrens err = EINVAL; 796 5331 amw } else { 797 789 ahrens *(uint64_t *)buf = mze->mze_phys.mze_value; 798 5331 amw (void) strlcpy(realname, 799 5331 amw mze->mze_phys.mze_name, rn_len); 800 5331 amw if (ncp) { 801 5331 amw *ncp = mzap_normalization_conflict(zap, 802 5331 amw zn, mze); 803 5331 amw } 804 5331 amw } 805 789 ahrens } 806 789 ahrens } 807 5331 amw zap_name_free(zn); 808 789 ahrens zap_unlockdir(zap); 809 789 ahrens return (err); 810 789 ahrens } 811 789 ahrens 812 789 ahrens int 813 10922 Jeff zap_lookup_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 814 10922 Jeff int key_numints, uint64_t integer_size, uint64_t num_integers, void *buf) 815 10922 Jeff { 816 10922 Jeff zap_t *zap; 817 10922 Jeff int err; 818 10922 Jeff zap_name_t *zn; 819 10922 Jeff 820 10922 Jeff err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 821 10922 Jeff if (err) 822 10922 Jeff return (err); 823 10922 Jeff zn = zap_name_alloc_uint64(zap, key, key_numints); 824 10922 Jeff if (zn == NULL) { 825 10922 Jeff zap_unlockdir(zap); 826 10922 Jeff return (ENOTSUP); 827 10922 Jeff } 828 10922 Jeff 829 10922 Jeff err = fzap_lookup(zn, integer_size, num_integers, buf, 830 10922 Jeff NULL, 0, NULL); 831 10922 Jeff zap_name_free(zn); 832 10922 Jeff zap_unlockdir(zap); 833 10922 Jeff return (err); 834 10922 Jeff } 835 10922 Jeff 836 10922 Jeff int 837 11022 Tom zap_contains(objset_t *os, uint64_t zapobj, const char *name) 838 11022 Tom { 839 11022 Tom int err = (zap_lookup_norm(os, zapobj, name, 0, 840 11022 Tom 0, NULL, MT_EXACT, NULL, 0, NULL)); 841 11022 Tom if (err == EOVERFLOW || err == EINVAL) 842 11022 Tom err = 0; /* found, but skipped reading the value */ 843 11022 Tom return (err); 844 11022 Tom } 845 11022 Tom 846 11022 Tom int 847 789 ahrens zap_length(objset_t *os, uint64_t zapobj, const char *name, 848 789 ahrens uint64_t *integer_size, uint64_t *num_integers) 849 789 ahrens { 850 789 ahrens zap_t *zap; 851 789 ahrens int err; 852 789 ahrens mzap_ent_t *mze; 853 5331 amw zap_name_t *zn; 854 789 ahrens 855 5384 ahrens err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 856 789 ahrens if (err) 857 789 ahrens return (err); 858 5331 amw zn = zap_name_alloc(zap, name, MT_EXACT); 859 5331 amw if (zn == NULL) { 860 5331 amw zap_unlockdir(zap); 861 5331 amw return (ENOTSUP); 862 5331 amw } 863 789 ahrens if (!zap->zap_ismicro) { 864 5331 amw err = fzap_length(zn, integer_size, num_integers); 865 789 ahrens } else { 866 5331 amw mze = mze_find(zn); 867 789 ahrens if (mze == NULL) { 868 789 ahrens err = ENOENT; 869 789 ahrens } else { 870 789 ahrens if (integer_size) 871 789 ahrens *integer_size = 8; 872 789 ahrens if (num_integers) 873 789 ahrens *num_integers = 1; 874 789 ahrens } 875 789 ahrens } 876 5331 amw zap_name_free(zn); 877 789 ahrens zap_unlockdir(zap); 878 789 ahrens return (err); 879 789 ahrens } 880 789 ahrens 881 10922 Jeff int 882 10922 Jeff zap_length_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 883 10922 Jeff int key_numints, uint64_t *integer_size, uint64_t *num_integers) 884 10922 Jeff { 885 10922 Jeff zap_t *zap; 886 10922 Jeff int err; 887 10922 Jeff zap_name_t *zn; 888 10922 Jeff 889 10922 Jeff err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 890 10922 Jeff if (err) 891 10922 Jeff return (err); 892 10922 Jeff zn = zap_name_alloc_uint64(zap, key, key_numints); 893 10922 Jeff if (zn == NULL) { 894 10922 Jeff zap_unlockdir(zap); 895 10922 Jeff return (ENOTSUP); 896 10922 Jeff } 897 10922 Jeff err = fzap_length(zn, integer_size, num_integers); 898 10922 Jeff zap_name_free(zn); 899 10922 Jeff zap_unlockdir(zap); 900 10922 Jeff return (err); 901 10922 Jeff } 902 10922 Jeff 903 789 ahrens static void 904 5331 amw mzap_addent(zap_name_t *zn, uint64_t value) 905 789 ahrens { 906 789 ahrens int i; 907 5331 amw zap_t *zap = zn->zn_zap; 908 789 ahrens int start = zap->zap_m.zap_alloc_next; 909 789 ahrens uint32_t cd; 910 789 ahrens 911 789 ahrens ASSERT(RW_WRITE_HELD(&zap->zap_rwlock)); 912 789 ahrens 913 789 ahrens #ifdef ZFS_DEBUG 914 789 ahrens for (i = 0; i < zap->zap_m.zap_num_chunks; i++) { 915 789 ahrens mzap_ent_phys_t *mze = &zap->zap_m.zap_phys->mz_chunk[i]; 916 10922 Jeff ASSERT(strcmp(zn->zn_key_orig, mze->mze_name) != 0); 917 789 ahrens } 918 789 ahrens #endif 919 789 ahrens 920 5331 amw cd = mze_find_unused_cd(zap, zn->zn_hash); 921 789 ahrens /* given the limited size of the microzap, this can't happen */ 922 10922 Jeff ASSERT(cd < zap_maxcd(zap)); 923 789 ahrens 924 789 ahrens again: 925 789 ahrens for (i = start; i < zap->zap_m.zap_num_chunks; i++) { 926 789 ahrens mzap_ent_phys_t *mze = &zap->zap_m.zap_phys->mz_chunk[i]; 927 789 ahrens if (mze->mze_name[0] == 0) { 928 789 ahrens mze->mze_value = value; 929 789 ahrens mze->mze_cd = cd; 930 10922 Jeff (void) strcpy(mze->mze_name, zn->zn_key_orig); 931 789 ahrens zap->zap_m.zap_num_entries++; 932 789 ahrens zap->zap_m.zap_alloc_next = i+1; 933 789 ahrens if (zap->zap_m.zap_alloc_next == 934 789 ahrens zap->zap_m.zap_num_chunks) 935 789 ahrens zap->zap_m.zap_alloc_next = 0; 936 5331 amw mze_insert(zap, i, zn->zn_hash, mze); 937 789 ahrens return; 938 789 ahrens } 939 789 ahrens } 940 789 ahrens if (start != 0) { 941 789 ahrens start = 0; 942 789 ahrens goto again; 943 789 ahrens } 944 789 ahrens ASSERT(!"out of entries!"); 945 789 ahrens } 946 789 ahrens 947 789 ahrens int 948 10922 Jeff zap_add(objset_t *os, uint64_t zapobj, const char *key, 949 789 ahrens int integer_size, uint64_t num_integers, 950 789 ahrens const void *val, dmu_tx_t *tx) 951 789 ahrens { 952 789 ahrens zap_t *zap; 953 789 ahrens int err; 954 789 ahrens mzap_ent_t *mze; 955 789 ahrens const uint64_t *intval = val; 956 5331 amw zap_name_t *zn; 957 789 ahrens 958 5384 ahrens err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, &zap); 959 789 ahrens if (err) 960 789 ahrens return (err); 961 10922 Jeff zn = zap_name_alloc(zap, key, MT_EXACT); 962 5331 amw if (zn == NULL) { 963 5331 amw zap_unlockdir(zap); 964 5331 amw return (ENOTSUP); 965 5331 amw } 966 789 ahrens if (!zap->zap_ismicro) { 967 5331 amw err = fzap_add(zn, integer_size, num_integers, val, tx); 968 5497 bonwick zap = zn->zn_zap; /* fzap_add() may change zap */ 969 789 ahrens } else if (integer_size != 8 || num_integers != 1 || 970 10922 Jeff strlen(key) >= MZAP_NAME_LEN) { 971 10922 Jeff err = mzap_upgrade(&zn->zn_zap, tx, 0); 972 5497 bonwick if (err == 0) 973 5497 bonwick err = fzap_add(zn, integer_size, num_integers, val, tx); 974 5497 bonwick zap = zn->zn_zap; /* fzap_add() may change zap */ 975 789 ahrens } else { 976 5331 amw mze = mze_find(zn); 977 789 ahrens if (mze != NULL) { 978 789 ahrens err = EEXIST; 979 789 ahrens } else { 980 5331 amw mzap_addent(zn, *intval); 981 789 ahrens } 982 789 ahrens } 983 5497 bonwick ASSERT(zap == zn->zn_zap); 984 10922 Jeff zap_name_free(zn); 985 10922 Jeff if (zap != NULL) /* may be NULL if fzap_add() failed */ 986 10922 Jeff zap_unlockdir(zap); 987 10922 Jeff return (err); 988 10922 Jeff } 989 10922 Jeff 990 10922 Jeff int 991 10922 Jeff zap_add_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 992 10922 Jeff int key_numints, int integer_size, uint64_t num_integers, 993 10922 Jeff const void *val, dmu_tx_t *tx) 994 10922 Jeff { 995 10922 Jeff zap_t *zap; 996 10922 Jeff int err; 997 10922 Jeff zap_name_t *zn; 998 10922 Jeff 999 10922 Jeff err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, &zap); 1000 10922 Jeff if (err) 1001 10922 Jeff return (err); 1002 10922 Jeff zn = zap_name_alloc_uint64(zap, key, key_numints); 1003 10922 Jeff if (zn == NULL) { 1004 10922 Jeff zap_unlockdir(zap); 1005 10922 Jeff return (ENOTSUP); 1006 10922 Jeff } 1007 10922 Jeff err = fzap_add(zn, integer_size, num_integers, val, tx); 1008 10922 Jeff zap = zn->zn_zap; /* fzap_add() may change zap */ 1009 5331 amw zap_name_free(zn); 1010 5497 bonwick if (zap != NULL) /* may be NULL if fzap_add() failed */ 1011 5497 bonwick zap_unlockdir(zap); 1012 789 ahrens return (err); 1013 789 ahrens } 1014 789 ahrens 1015 789 ahrens int 1016 789 ahrens zap_update(objset_t *os, uint64_t zapobj, const char *name, 1017 789 ahrens int integer_size, uint64_t num_integers, const void *val, dmu_tx_t *tx) 1018 789 ahrens { 1019 789 ahrens zap_t *zap; 1020 789 ahrens mzap_ent_t *mze; 1021 789 ahrens const uint64_t *intval = val; 1022 5331 amw zap_name_t *zn; 1023 789 ahrens int err; 1024 789 ahrens 1025 5384 ahrens err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, &zap); 1026 789 ahrens if (err) 1027 789 ahrens return (err); 1028 5331 amw zn = zap_name_alloc(zap, name, MT_EXACT); 1029 5331 amw if (zn == NULL) { 1030 5331 amw zap_unlockdir(zap); 1031 5331 amw return (ENOTSUP); 1032 5331 amw } 1033 789 ahrens if (!zap->zap_ismicro) { 1034 5331 amw err = fzap_update(zn, integer_size, num_integers, val, tx); 1035 5497 bonwick zap = zn->zn_zap; /* fzap_update() may change zap */ 1036 789 ahrens } else if (integer_size != 8 || num_integers != 1 || 1037 789 ahrens strlen(name) >= MZAP_NAME_LEN) { 1038 789 ahrens dprintf("upgrading obj %llu: intsz=%u numint=%llu name=%s\n", 1039 789 ahrens zapobj, integer_size, num_integers, name); 1040 10922 Jeff err = mzap_upgrade(&zn->zn_zap, tx, 0); 1041 5497 bonwick if (err == 0) 1042 5497 bonwick err = fzap_update(zn, integer_size, num_integers, 1043 5497 bonwick val, tx); 1044 5497 bonwick zap = zn->zn_zap; /* fzap_update() may change zap */ 1045 789 ahrens } else { 1046 5331 amw mze = mze_find(zn); 1047 789 ahrens if (mze != NULL) { 1048 789 ahrens mze->mze_phys.mze_value = *intval; 1049 789 ahrens zap->zap_m.zap_phys->mz_chunk 1050 789 ahrens [mze->mze_chunkid].mze_value = *intval; 1051 789 ahrens } else { 1052 5331 amw mzap_addent(zn, *intval); 1053 789 ahrens } 1054 789 ahrens } 1055 5497 bonwick ASSERT(zap == zn->zn_zap); 1056 10922 Jeff zap_name_free(zn); 1057 10922 Jeff if (zap != NULL) /* may be NULL if fzap_upgrade() failed */ 1058 10922 Jeff zap_unlockdir(zap); 1059 10922 Jeff return (err); 1060 10922 Jeff } 1061 10922 Jeff 1062 10922 Jeff int 1063 10922 Jeff zap_update_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 1064 10922 Jeff int key_numints, 1065 10922 Jeff int integer_size, uint64_t num_integers, const void *val, dmu_tx_t *tx) 1066 10922 Jeff { 1067 10922 Jeff zap_t *zap; 1068 10922 Jeff zap_name_t *zn; 1069 10922 Jeff int err; 1070 10922 Jeff 1071 10922 Jeff err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, &zap); 1072 10922 Jeff if (err) 1073 10922 Jeff return (err); 1074 10922 Jeff zn = zap_name_alloc_uint64(zap, key, key_numints); 1075 10922 Jeff if (zn == NULL) { 1076 10922 Jeff zap_unlockdir(zap); 1077 10922 Jeff return (ENOTSUP); 1078 10922 Jeff } 1079 10922 Jeff err = fzap_update(zn, integer_size, num_integers, val, tx); 1080 10922 Jeff zap = zn->zn_zap; /* fzap_update() may change zap */ 1081 5331 amw zap_name_free(zn); 1082 5497 bonwick if (zap != NULL) /* may be NULL if fzap_upgrade() failed */ 1083 5497 bonwick zap_unlockdir(zap); 1084 2641 ahrens return (err); 1085 789 ahrens } 1086 789 ahrens 1087 789 ahrens int 1088 789 ahrens zap_remove(objset_t *os, uint64_t zapobj, const char *name, dmu_tx_t *tx) 1089 789 ahrens { 1090 5331 amw return (zap_remove_norm(os, zapobj, name, MT_EXACT, tx)); 1091 5331 amw } 1092 5331 amw 1093 5331 amw int 1094 5331 amw zap_remove_norm(objset_t *os, uint64_t zapobj, const char *name, 1095 5331 amw matchtype_t mt, dmu_tx_t *tx) 1096 5331 amw { 1097 789 ahrens zap_t *zap; 1098 789 ahrens int err; 1099 789 ahrens mzap_ent_t *mze; 1100 5331 amw zap_name_t *zn; 1101 789 ahrens 1102 5384 ahrens err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, &zap); 1103 789 ahrens if (err) 1104 789 ahrens return (err); 1105 5331 amw zn = zap_name_alloc(zap, name, mt); 1106 5331 amw if (zn == NULL) { 1107 5331 amw zap_unlockdir(zap); 1108 5331 amw return (ENOTSUP); 1109 5331 amw } 1110 789 ahrens if (!zap->zap_ismicro) { 1111 5331 amw err = fzap_remove(zn, tx); 1112 789 ahrens } else { 1113 5331 amw mze = mze_find(zn); 1114 789 ahrens if (mze == NULL) { 1115 789 ahrens err = ENOENT; 1116 789 ahrens } else { 1117 789 ahrens zap->zap_m.zap_num_entries--; 1118 789 ahrens bzero(&zap->zap_m.zap_phys->mz_chunk[mze->mze_chunkid], 1119 789 ahrens sizeof (mzap_ent_phys_t)); 1120 789 ahrens mze_remove(zap, mze); 1121 789 ahrens } 1122 789 ahrens } 1123 5331 amw zap_name_free(zn); 1124 789 ahrens zap_unlockdir(zap); 1125 789 ahrens return (err); 1126 789 ahrens } 1127 789 ahrens 1128 10922 Jeff int 1129 10922 Jeff zap_remove_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key, 1130 10922 Jeff int key_numints, dmu_tx_t *tx) 1131 10922 Jeff { 1132 10922 Jeff zap_t *zap; 1133 10922 Jeff int err; 1134 10922 Jeff zap_name_t *zn; 1135 10922 Jeff 1136 10922 Jeff err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, &zap); 1137 10922 Jeff if (err) 1138 10922 Jeff return (err); 1139 10922 Jeff zn = zap_name_alloc_uint64(zap, key, key_numints); 1140 10922 Jeff if (zn == NULL) { 1141 10922 Jeff zap_unlockdir(zap); 1142 10922 Jeff return (ENOTSUP); 1143 10922 Jeff } 1144 10922 Jeff err = fzap_remove(zn, tx); 1145 10922 Jeff zap_name_free(zn); 1146 10922 Jeff zap_unlockdir(zap); 1147 10922 Jeff return (err); 1148 10922 Jeff } 1149 10922 Jeff 1150 789 ahrens /* 1151 789 ahrens * Routines for iterating over the attributes. 1152 789 ahrens */ 1153 789 ahrens 1154 789 ahrens void 1155 789 ahrens zap_cursor_init_serialized(zap_cursor_t *zc, objset_t *os, uint64_t zapobj, 1156 789 ahrens uint64_t serialized) 1157 789 ahrens { 1158 789 ahrens zc->zc_objset = os; 1159 885 ahrens zc->zc_zap = NULL; 1160 885 ahrens zc->zc_leaf = NULL; 1161 789 ahrens zc->zc_zapobj = zapobj; 1162 10922 Jeff zc->zc_serialized = serialized; 1163 10922 Jeff zc->zc_hash = 0; 1164 10922 Jeff zc->zc_cd = 0; 1165 885 ahrens } 1166 885 ahrens 1167 885 ahrens void 1168 885 ahrens zap_cursor_init(zap_cursor_t *zc, objset_t *os, uint64_t zapobj) 1169 885 ahrens { 1170 885 ahrens zap_cursor_init_serialized(zc, os, zapobj, 0); 1171 885 ahrens } 1172 885 ahrens 1173 885 ahrens void 1174 885 ahrens zap_cursor_fini(zap_cursor_t *zc) 1175 885 ahrens { 1176 885 ahrens if (zc->zc_zap) { 1177 885 ahrens rw_enter(&zc->zc_zap->zap_rwlock, RW_READER); 1178 885 ahrens zap_unlockdir(zc->zc_zap); 1179 885 ahrens zc->zc_zap = NULL; 1180 885 ahrens } 1181 885 ahrens if (zc->zc_leaf) { 1182 885 ahrens rw_enter(&zc->zc_leaf->l_rwlock, RW_READER); 1183 885 ahrens zap_put_leaf(zc->zc_leaf); 1184 885 ahrens zc->zc_leaf = NULL; 1185 885 ahrens } 1186 885 ahrens zc->zc_objset = NULL; 1187 789 ahrens } 1188 789 ahrens 1189 789 ahrens uint64_t 1190 789 ahrens zap_cursor_serialize(zap_cursor_t *zc) 1191 789 ahrens { 1192 789 ahrens if (zc->zc_hash == -1ULL) 1193 789 ahrens return (-1ULL); 1194 10922 Jeff if (zc->zc_zap == NULL) 1195 10922 Jeff return (zc->zc_serialized); 1196 10922 Jeff ASSERT((zc->zc_hash & zap_maxcd(zc->zc_zap)) == 0); 1197 10922 Jeff ASSERT(zc->zc_cd < zap_maxcd(zc->zc_zap)); 1198 10922 Jeff 1199 10922 Jeff /* 1200 10922 Jeff * We want to keep the high 32 bits of the cursor zero if we can, so 1201 10922 Jeff * that 32-bit programs can access this. So usually use a small 1202 10922 Jeff * (28-bit) hash value so we can fit 4 bits of cd into the low 32-bits 1203 10922 Jeff * of the cursor. 1204 10922 Jeff * 1205 10922 Jeff * [ collision differentiator | zap_hashbits()-bit hash value ] 1206 10922 Jeff */ 1207 10922 Jeff return ((zc->zc_hash >> (64 - zap_hashbits(zc->zc_zap))) | 1208 10922 Jeff ((uint64_t)zc->zc_cd << zap_hashbits(zc->zc_zap))); 1209 789 ahrens } 1210 789 ahrens 1211 789 ahrens int 1212 789 ahrens zap_cursor_retrieve(zap_cursor_t *zc, zap_attribute_t *za) 1213 789 ahrens { 1214 789 ahrens int err; 1215 789 ahrens avl_index_t idx; 1216 789 ahrens mzap_ent_t mze_tofind; 1217 789 ahrens mzap_ent_t *mze; 1218 789 ahrens 1219 789 ahrens if (zc->zc_hash == -1ULL) 1220 789 ahrens return (ENOENT); 1221 789 ahrens 1222 885 ahrens if (zc->zc_zap == NULL) { 1223 10922 Jeff int hb; 1224 885 ahrens err = zap_lockdir(zc->zc_objset, zc->zc_zapobj, NULL, 1225 5384 ahrens RW_READER, TRUE, FALSE, &zc->zc_zap); 1226 885 ahrens if (err) 1227 885 ahrens return (err); 1228 10922 Jeff 1229 10922 Jeff /* 1230 10922 Jeff * To support zap_cursor_init_serialized, advance, retrieve, 1231 10922 Jeff * we must add to the existing zc_cd, which may already 1232 10922 Jeff * be 1 due to the zap_cursor_advance. 1233 10922 Jeff */ 1234 10922 Jeff ASSERT(zc->zc_hash == 0); 1235 10922 Jeff hb = zap_hashbits(zc->zc_zap); 1236 10922 Jeff zc->zc_hash = zc->zc_serialized << (64 - hb); 1237 10922 Jeff zc->zc_cd += zc->zc_serialized >> hb; 1238 10922 Jeff if (zc->zc_cd >= zap_maxcd(zc->zc_zap)) /* corrupt serialized */ 1239 10922 Jeff zc->zc_cd = 0; 1240 885 ahrens } else { 1241 885 ahrens rw_enter(&zc->zc_zap->zap_rwlock, RW_READER); 1242 885 ahrens } 1243 885 ahrens if (!zc->zc_zap->zap_ismicro) { 1244 885 ahrens err = fzap_cursor_retrieve(zc->zc_zap, zc, za); 1245 789 ahrens } else { 1246 789 ahrens err = ENOENT; 1247 789 ahrens 1248 789 ahrens mze_tofind.mze_hash = zc->zc_hash; 1249 789 ahrens mze_tofind.mze_phys.mze_cd = zc->zc_cd; 1250 789 ahrens 1251 885 ahrens mze = avl_find(&zc->zc_zap->zap_m.zap_avl, &mze_tofind, &idx); 1252 885 ahrens if (mze == NULL) { 1253 885 ahrens mze = avl_nearest(&zc->zc_zap->zap_m.zap_avl, 1254 885 ahrens idx, AVL_AFTER); 1255 885 ahrens } 1256 789 ahrens if (mze) { 1257 5331 amw ASSERT(0 == bcmp(&mze->mze_phys, 1258 5331 amw &zc->zc_zap->zap_m.zap_phys->mz_chunk 1259 5331 amw [mze->mze_chunkid], sizeof (mze->mze_phys))); 1260 5331 amw 1261 5331 amw za->za_normalization_conflict = 1262 5331 amw mzap_normalization_conflict(zc->zc_zap, NULL, mze); 1263 789 ahrens za->za_integer_length = 8; 1264 789 ahrens za->za_num_integers = 1; 1265 789 ahrens za->za_first_integer = mze->mze_phys.mze_value; 1266 789 ahrens (void) strcpy(za->za_name, mze->mze_phys.mze_name); 1267 789 ahrens zc->zc_hash = mze->mze_hash; 1268 789 ahrens zc->zc_cd = mze->mze_phys.mze_cd; 1269 789 ahrens err = 0; 1270 789 ahrens } else { 1271 789 ahrens zc->zc_hash = -1ULL; 1272 789 ahrens } 1273 789 ahrens } 1274 885 ahrens rw_exit(&zc->zc_zap->zap_rwlock); 1275 789 ahrens return (err); 1276 789 ahrens } 1277 789 ahrens 1278 789 ahrens void 1279 789 ahrens zap_cursor_advance(zap_cursor_t *zc) 1280 789 ahrens { 1281 789 ahrens if (zc->zc_hash == -1ULL) 1282 789 ahrens return; 1283 789 ahrens zc->zc_cd++; 1284 789 ahrens } 1285 789 ahrens 1286 789 ahrens int 1287 10612 Ricardo zap_cursor_move_to_key(zap_cursor_t *zc, const char *name, matchtype_t mt) 1288 10612 Ricardo { 1289 10612 Ricardo int err = 0; 1290 10612 Ricardo mzap_ent_t *mze; 1291 10612 Ricardo zap_name_t *zn; 1292 10612 Ricardo 1293 10612 Ricardo if (zc->zc_zap == NULL) { 1294 10612 Ricardo err = zap_lockdir(zc->zc_objset, zc->zc_zapobj, NULL, 1295 10612 Ricardo RW_READER, TRUE, FALSE, &zc->zc_zap); 1296 10612 Ricardo if (err) 1297 10612 Ricardo return (err); 1298 10612 Ricardo } else { 1299 10612 Ricardo rw_enter(&zc->zc_zap->zap_rwlock, RW_READER); 1300 10612 Ricardo } 1301 10612 Ricardo 1302 10612 Ricardo zn = zap_name_alloc(zc->zc_zap, name, mt); 1303 10612 Ricardo if (zn == NULL) { 1304 10612 Ricardo rw_exit(&zc->zc_zap->zap_rwlock); 1305 10612 Ricardo return (ENOTSUP); 1306 10612 Ricardo } 1307 10612 Ricardo 1308 10612 Ricardo if (!zc->zc_zap->zap_ismicro) { 1309 10612 Ricardo err = fzap_cursor_move_to_key(zc, zn); 1310 10612 Ricardo } else { 1311 10612 Ricardo mze = mze_find(zn); 1312 10612 Ricardo if (mze == NULL) { 1313 10612 Ricardo err = ENOENT; 1314 10612 Ricardo goto out; 1315 10612 Ricardo } 1316 10612 Ricardo zc->zc_hash = mze->mze_hash; 1317 10612 Ricardo zc->zc_cd = mze->mze_phys.mze_cd; 1318 10612 Ricardo } 1319 10612 Ricardo 1320 10612 Ricardo out: 1321 10612 Ricardo zap_name_free(zn); 1322 10612 Ricardo rw_exit(&zc->zc_zap->zap_rwlock); 1323 10612 Ricardo return (err); 1324 10612 Ricardo } 1325 10612 Ricardo 1326 10612 Ricardo int 1327 789 ahrens zap_get_stats(objset_t *os, uint64_t zapobj, zap_stats_t *zs) 1328 789 ahrens { 1329 789 ahrens int err; 1330 789 ahrens zap_t *zap; 1331 789 ahrens 1332 5384 ahrens err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 1333 789 ahrens if (err) 1334 789 ahrens return (err); 1335 789 ahrens 1336 789 ahrens bzero(zs, sizeof (zap_stats_t)); 1337 789 ahrens 1338 789 ahrens if (zap->zap_ismicro) { 1339 789 ahrens zs->zs_blocksize = zap->zap_dbuf->db_size; 1340 789 ahrens zs->zs_num_entries = zap->zap_m.zap_num_entries; 1341 789 ahrens zs->zs_num_blocks = 1; 1342 789 ahrens } else { 1343 789 ahrens fzap_get_stats(zap, zs); 1344 789 ahrens } 1345 789 ahrens zap_unlockdir(zap); 1346 789 ahrens return (0); 1347 789 ahrens } 1348 9653 Sanjeev 1349 9653 Sanjeev int 1350 9653 Sanjeev zap_count_write(objset_t *os, uint64_t zapobj, const char *name, int add, 1351 9873 Sanjeev uint64_t *towrite, uint64_t *tooverwrite) 1352 9653 Sanjeev { 1353 9653 Sanjeev zap_t *zap; 1354 9653 Sanjeev int err = 0; 1355 9653 Sanjeev 1356 9653 Sanjeev 1357 9653 Sanjeev /* 1358 9653 Sanjeev * Since, we don't have a name, we cannot figure out which blocks will 1359 9653 Sanjeev * be affected in this operation. So, account for the worst case : 1360 9653 Sanjeev * - 3 blocks overwritten: target leaf, ptrtbl block, header block 1361 9653 Sanjeev * - 4 new blocks written if adding: 1362 9653 Sanjeev * - 2 blocks for possibly split leaves, 1363 9653 Sanjeev * - 2 grown ptrtbl blocks 1364 9653 Sanjeev * 1365 9653 Sanjeev * This also accomodates the case where an add operation to a fairly 1366 9653 Sanjeev * large microzap results in a promotion to fatzap. 1367 9653 Sanjeev */ 1368 9653 Sanjeev if (name == NULL) { 1369 9653 Sanjeev *towrite += (3 + (add ? 4 : 0)) * SPA_MAXBLOCKSIZE; 1370 9653 Sanjeev return (err); 1371 9653 Sanjeev } 1372 9653 Sanjeev 1373 9653 Sanjeev /* 1374 9653 Sanjeev * We lock the zap with adding == FALSE. Because, if we pass 1375 9653 Sanjeev * the actual value of add, it could trigger a mzap_upgrade(). 1376 9653 Sanjeev * At present we are just evaluating the possibility of this operation 1377 9653 Sanjeev * and hence we donot want to trigger an upgrade. 1378 9653 Sanjeev */ 1379 9653 Sanjeev err = zap_lockdir(os, zapobj, NULL, RW_READER, TRUE, FALSE, &zap); 1380 9653 Sanjeev if (err) 1381 9653 Sanjeev return (err); 1382 9653 Sanjeev 1383 9653 Sanjeev if (!zap->zap_ismicro) { 1384 9653 Sanjeev zap_name_t *zn = zap_name_alloc(zap, name, MT_EXACT); 1385 9653 Sanjeev if (zn) { 1386 9653 Sanjeev err = fzap_count_write(zn, add, towrite, 1387 9653 Sanjeev tooverwrite); 1388 9653 Sanjeev zap_name_free(zn); 1389 9653 Sanjeev } else { 1390 9653 Sanjeev /* 1391 9653 Sanjeev * We treat this case as similar to (name == NULL) 1392 9653 Sanjeev */ 1393 9653 Sanjeev *towrite += (3 + (add ? 4 : 0)) * SPA_MAXBLOCKSIZE; 1394 9653 Sanjeev } 1395 9653 Sanjeev } else { 1396 9873 Sanjeev /* 1397 9873 Sanjeev * We are here if (name != NULL) and this is a micro-zap. 1398 9873 Sanjeev * We account for the header block depending on whether it 1399 9873 Sanjeev * is freeable. 1400 9873 Sanjeev * 1401 9873 Sanjeev * Incase of an add-operation it is hard to find out 1402 9873 Sanjeev * if this add will promote this microzap to fatzap. 1403 9873 Sanjeev * Hence, we consider the worst case and account for the 1404 9873 Sanjeev * blocks assuming this microzap would be promoted to a 1405 9873 Sanjeev * fatzap. 1406 9873 Sanjeev * 1407 9873 Sanjeev * 1 block overwritten : header block 1408 9873 Sanjeev * 4 new blocks written : 2 new split leaf, 2 grown 1409 9873 Sanjeev * ptrtbl blocks 1410 9873 Sanjeev */ 1411 9873 Sanjeev if (dmu_buf_freeable(zap->zap_dbuf)) 1412 9873 Sanjeev *tooverwrite += SPA_MAXBLOCKSIZE; 1413 9873 Sanjeev else 1414 9873 Sanjeev *towrite += SPA_MAXBLOCKSIZE; 1415 9873 Sanjeev 1416 9873 Sanjeev if (add) { 1417 9873 Sanjeev *towrite += 4 * SPA_MAXBLOCKSIZE; 1418 9653 Sanjeev } 1419 9653 Sanjeev } 1420 9653 Sanjeev 1421 9653 Sanjeev zap_unlockdir(zap); 1422 9653 Sanjeev return (err); 1423 9653 Sanjeev } 1424
Indexes created Thu Nov 26 20:23:21 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.