208 int off = (dnp->dn_nblkptr-1) * sizeof (blkptr_t); |
208 int off = (dnp->dn_nblkptr-1) * sizeof (blkptr_t); |
209 size_t len = DN_MAX_BONUSLEN - off; |
209 size_t len = DN_MAX_BONUSLEN - off; |
210 ASSERT3U(dnp->dn_bonustype, <, DMU_OT_NUMTYPES); |
210 ASSERT3U(dnp->dn_bonustype, <, DMU_OT_NUMTYPES); |
211 dmu_ot[dnp->dn_bonustype].ot_byteswap(dnp->dn_bonus + off, len); |
211 dmu_ot[dnp->dn_bonustype].ot_byteswap(dnp->dn_bonus + off, len); |
212 } |
212 } |
|
213 |
|
214 /* Swap SPILL block if we have one */ |
|
215 if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) |
|
216 byteswap_uint64_array(&dnp->dn_spill, sizeof (blkptr_t)); |
|
217 |
213 } |
218 } |
214 |
219 |
215 void |
220 void |
216 dnode_buf_byteswap(void *vbuf, size_t size) |
221 dnode_buf_byteswap(void *vbuf, size_t size) |
217 { |
222 { |
253 dn->dn_bonuslen = newsize; |
258 dn->dn_bonuslen = newsize; |
254 if (newsize == 0) |
259 if (newsize == 0) |
255 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = DN_ZERO_BONUSLEN; |
260 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = DN_ZERO_BONUSLEN; |
256 else |
261 else |
257 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = dn->dn_bonuslen; |
262 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = dn->dn_bonuslen; |
|
263 rw_exit(&dn->dn_struct_rwlock); |
|
264 } |
|
265 |
|
266 void |
|
267 dnode_setbonus_type(dnode_t *dn, dmu_object_type_t newtype, dmu_tx_t *tx) |
|
268 { |
|
269 ASSERT3U(refcount_count(&dn->dn_holds), >=, 1); |
|
270 dnode_setdirty(dn, tx); |
|
271 rw_enter(&dn->dn_struct_rwlock, RW_WRITER); |
|
272 dn->dn_bonustype = newtype; |
|
273 dn->dn_next_bonustype[tx->tx_txg & TXG_MASK] = dn->dn_bonustype; |
|
274 rw_exit(&dn->dn_struct_rwlock); |
|
275 } |
|
276 |
|
277 void |
|
278 dnode_rm_spill(dnode_t *dn, dmu_tx_t *tx) |
|
279 { |
|
280 ASSERT3U(refcount_count(&dn->dn_holds), >=, 1); |
|
281 dnode_setdirty(dn, tx); |
|
282 rw_enter(&dn->dn_struct_rwlock, RW_WRITER); |
|
283 dn->dn_rm_spillblk[tx->tx_txg&TXG_MASK] = DN_KILL_SPILLBLK; |
|
284 dn->dn_have_spill = B_FALSE; |
258 rw_exit(&dn->dn_struct_rwlock); |
285 rw_exit(&dn->dn_struct_rwlock); |
259 } |
286 } |
260 |
287 |
261 static void |
288 static void |
262 dnode_setdblksz(dnode_t *dn, int size) |
289 dnode_setdblksz(dnode_t *dn, int size) |
292 dn->dn_checksum = dnp->dn_checksum; |
319 dn->dn_checksum = dnp->dn_checksum; |
293 dn->dn_compress = dnp->dn_compress; |
320 dn->dn_compress = dnp->dn_compress; |
294 dn->dn_bonustype = dnp->dn_bonustype; |
321 dn->dn_bonustype = dnp->dn_bonustype; |
295 dn->dn_bonuslen = dnp->dn_bonuslen; |
322 dn->dn_bonuslen = dnp->dn_bonuslen; |
296 dn->dn_maxblkid = dnp->dn_maxblkid; |
323 dn->dn_maxblkid = dnp->dn_maxblkid; |
|
324 dn->dn_have_spill = ((dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) != 0); |
297 |
325 |
298 dmu_zfetch_init(&dn->dn_zfetch, dn); |
326 dmu_zfetch_init(&dn->dn_zfetch, dn); |
299 |
327 |
300 ASSERT(dn->dn_phys->dn_type < DMU_OT_NUMTYPES); |
328 ASSERT(dn->dn_phys->dn_type < DMU_OT_NUMTYPES); |
301 mutex_enter(&os->os_lock); |
329 mutex_enter(&os->os_lock); |
319 ASSERT(NULL == list_head(&dn->dn_dirty_records[i])); |
347 ASSERT(NULL == list_head(&dn->dn_dirty_records[i])); |
320 ASSERT(0 == avl_numnodes(&dn->dn_ranges[i])); |
348 ASSERT(0 == avl_numnodes(&dn->dn_ranges[i])); |
321 } |
349 } |
322 ASSERT(NULL == list_head(&dn->dn_dbufs)); |
350 ASSERT(NULL == list_head(&dn->dn_dbufs)); |
323 #endif |
351 #endif |
324 ASSERT(dn->dn_oldphys == NULL); |
352 ASSERT((dn->dn_id_flags & DN_ID_NEW_EXIST) == 0); |
325 |
353 |
326 mutex_enter(&os->os_lock); |
354 mutex_enter(&os->os_lock); |
327 list_remove(&os->os_dnodes, dn); |
355 list_remove(&os->os_dnodes, dn); |
328 mutex_exit(&os->os_lock); |
356 mutex_exit(&os->os_lock); |
329 |
357 |
366 ASSERT(bcmp(dn->dn_phys, &dnode_phys_zero, sizeof (dnode_phys_t)) == 0); |
394 ASSERT(bcmp(dn->dn_phys, &dnode_phys_zero, sizeof (dnode_phys_t)) == 0); |
367 ASSERT(dn->dn_phys->dn_type == DMU_OT_NONE); |
395 ASSERT(dn->dn_phys->dn_type == DMU_OT_NONE); |
368 ASSERT(ot != DMU_OT_NONE); |
396 ASSERT(ot != DMU_OT_NONE); |
369 ASSERT3U(ot, <, DMU_OT_NUMTYPES); |
397 ASSERT3U(ot, <, DMU_OT_NUMTYPES); |
370 ASSERT((bonustype == DMU_OT_NONE && bonuslen == 0) || |
398 ASSERT((bonustype == DMU_OT_NONE && bonuslen == 0) || |
|
399 (bonustype == DMU_OT_SA && bonuslen == 0) || |
371 (bonustype != DMU_OT_NONE && bonuslen != 0)); |
400 (bonustype != DMU_OT_NONE && bonuslen != 0)); |
372 ASSERT3U(bonustype, <, DMU_OT_NUMTYPES); |
401 ASSERT3U(bonustype, <, DMU_OT_NUMTYPES); |
373 ASSERT3U(bonuslen, <=, DN_MAX_BONUSLEN); |
402 ASSERT3U(bonuslen, <=, DN_MAX_BONUSLEN); |
374 ASSERT(dn->dn_type == DMU_OT_NONE); |
403 ASSERT(dn->dn_type == DMU_OT_NONE); |
375 ASSERT3U(dn->dn_maxblkid, ==, 0); |
404 ASSERT3U(dn->dn_maxblkid, ==, 0); |
381 |
410 |
382 for (i = 0; i < TXG_SIZE; i++) { |
411 for (i = 0; i < TXG_SIZE; i++) { |
383 ASSERT3U(dn->dn_next_nlevels[i], ==, 0); |
412 ASSERT3U(dn->dn_next_nlevels[i], ==, 0); |
384 ASSERT3U(dn->dn_next_indblkshift[i], ==, 0); |
413 ASSERT3U(dn->dn_next_indblkshift[i], ==, 0); |
385 ASSERT3U(dn->dn_next_bonuslen[i], ==, 0); |
414 ASSERT3U(dn->dn_next_bonuslen[i], ==, 0); |
|
415 ASSERT3U(dn->dn_next_bonustype[i], ==, 0); |
|
416 ASSERT3U(dn->dn_rm_spillblk[i], ==, 0); |
386 ASSERT3U(dn->dn_next_blksz[i], ==, 0); |
417 ASSERT3U(dn->dn_next_blksz[i], ==, 0); |
387 ASSERT(!list_link_active(&dn->dn_dirty_link[i])); |
418 ASSERT(!list_link_active(&dn->dn_dirty_link[i])); |
388 ASSERT3P(list_head(&dn->dn_dirty_records[i]), ==, NULL); |
419 ASSERT3P(list_head(&dn->dn_dirty_records[i]), ==, NULL); |
389 ASSERT3U(avl_numnodes(&dn->dn_ranges[i]), ==, 0); |
420 ASSERT3U(avl_numnodes(&dn->dn_ranges[i]), ==, 0); |
390 } |
421 } |
391 |
422 |
392 dn->dn_type = ot; |
423 dn->dn_type = ot; |
393 dnode_setdblksz(dn, blocksize); |
424 dnode_setdblksz(dn, blocksize); |
394 dn->dn_indblkshift = ibs; |
425 dn->dn_indblkshift = ibs; |
395 dn->dn_nlevels = 1; |
426 dn->dn_nlevels = 1; |
396 dn->dn_nblkptr = 1 + ((DN_MAX_BONUSLEN - bonuslen) >> SPA_BLKPTRSHIFT); |
427 if (bonustype == DMU_OT_SA) /* Maximize bonus space for SA */ |
|
428 dn->dn_nblkptr = 1; |
|
429 else |
|
430 dn->dn_nblkptr = 1 + |
|
431 ((DN_MAX_BONUSLEN - bonuslen) >> SPA_BLKPTRSHIFT); |
397 dn->dn_bonustype = bonustype; |
432 dn->dn_bonustype = bonustype; |
398 dn->dn_bonuslen = bonuslen; |
433 dn->dn_bonuslen = bonuslen; |
399 dn->dn_checksum = ZIO_CHECKSUM_INHERIT; |
434 dn->dn_checksum = ZIO_CHECKSUM_INHERIT; |
400 dn->dn_compress = ZIO_COMPRESS_INHERIT; |
435 dn->dn_compress = ZIO_COMPRESS_INHERIT; |
401 dn->dn_dirtyctx = 0; |
436 dn->dn_dirtyctx = 0; |
405 kmem_free(dn->dn_dirtyctx_firstset, 1); |
440 kmem_free(dn->dn_dirtyctx_firstset, 1); |
406 dn->dn_dirtyctx_firstset = NULL; |
441 dn->dn_dirtyctx_firstset = NULL; |
407 } |
442 } |
408 |
443 |
409 dn->dn_allocated_txg = tx->tx_txg; |
444 dn->dn_allocated_txg = tx->tx_txg; |
|
445 dn->dn_id_flags = 0; |
410 |
446 |
411 dnode_setdirty(dn, tx); |
447 dnode_setdirty(dn, tx); |
412 dn->dn_next_indblkshift[tx->tx_txg & TXG_MASK] = ibs; |
448 dn->dn_next_indblkshift[tx->tx_txg & TXG_MASK] = ibs; |
413 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = dn->dn_bonuslen; |
449 dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = dn->dn_bonuslen; |
|
450 dn->dn_next_bonustype[tx->tx_txg & TXG_MASK] = dn->dn_bonustype; |
414 dn->dn_next_blksz[tx->tx_txg & TXG_MASK] = dn->dn_datablksz; |
451 dn->dn_next_blksz[tx->tx_txg & TXG_MASK] = dn->dn_datablksz; |
415 } |
452 } |
416 |
453 |
417 void |
454 void |
418 dnode_reallocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, |
455 dnode_reallocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, |
444 dn->dn_next_blksz[tx->tx_txg&TXG_MASK] = blocksize; |
481 dn->dn_next_blksz[tx->tx_txg&TXG_MASK] = blocksize; |
445 } |
482 } |
446 if (dn->dn_bonuslen != bonuslen) |
483 if (dn->dn_bonuslen != bonuslen) |
447 dn->dn_next_bonuslen[tx->tx_txg&TXG_MASK] = bonuslen; |
484 dn->dn_next_bonuslen[tx->tx_txg&TXG_MASK] = bonuslen; |
448 nblkptr = 1 + ((DN_MAX_BONUSLEN - bonuslen) >> SPA_BLKPTRSHIFT); |
485 nblkptr = 1 + ((DN_MAX_BONUSLEN - bonuslen) >> SPA_BLKPTRSHIFT); |
|
486 if (dn->dn_bonustype != bonustype) |
|
487 dn->dn_next_bonustype[tx->tx_txg&TXG_MASK] = bonustype; |
449 if (dn->dn_nblkptr != nblkptr) |
488 if (dn->dn_nblkptr != nblkptr) |
450 dn->dn_next_nblkptr[tx->tx_txg&TXG_MASK] = nblkptr; |
489 dn->dn_next_nblkptr[tx->tx_txg&TXG_MASK] = nblkptr; |
|
490 if (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) { |
|
491 dn->dn_rm_spillblk[tx->tx_txg&TXG_MASK] = DN_KILL_SPILLBLK; |
|
492 dn->dn_have_spill = B_FALSE; |
|
493 } |
451 rw_exit(&dn->dn_struct_rwlock); |
494 rw_exit(&dn->dn_struct_rwlock); |
452 |
495 |
453 /* change type */ |
496 /* change type */ |
454 dn->dn_type = ot; |
497 dn->dn_type = ot; |
455 |
498 |
625 mutex_enter(&dn->dn_mtx); |
668 mutex_enter(&dn->dn_mtx); |
626 type = dn->dn_type; |
669 type = dn->dn_type; |
627 if (dn->dn_free_txg || |
670 if (dn->dn_free_txg || |
628 ((flag & DNODE_MUST_BE_ALLOCATED) && type == DMU_OT_NONE) || |
671 ((flag & DNODE_MUST_BE_ALLOCATED) && type == DMU_OT_NONE) || |
629 ((flag & DNODE_MUST_BE_FREE) && |
672 ((flag & DNODE_MUST_BE_FREE) && |
630 (type != DMU_OT_NONE || dn->dn_oldphys))) { |
673 (type != DMU_OT_NONE || (dn->dn_id_flags & DN_ID_SYNC)))) { |
631 mutex_exit(&dn->dn_mtx); |
674 mutex_exit(&dn->dn_mtx); |
632 dbuf_rele(db, FTAG); |
675 dbuf_rele(db, FTAG); |
633 return (type == DMU_OT_NONE ? ENOENT : EEXIST); |
676 return (type == DMU_OT_NONE ? ENOENT : EEXIST); |
|
677 } |
|
678 if (flag & DNODE_MUST_BE_FREE) { |
|
679 ASSERT(refcount_is_zero(&dn->dn_holds)); |
|
680 ASSERT(!(dn->dn_id_flags & DN_ID_SYNC)); |
634 } |
681 } |
635 mutex_exit(&dn->dn_mtx); |
682 mutex_exit(&dn->dn_mtx); |
636 |
683 |
637 if (refcount_add(&dn->dn_holds, tag) == 1) |
684 if (refcount_add(&dn->dn_holds, tag) == 1) |
638 dbuf_add_ref(db, dn); |
685 dbuf_add_ref(db, dn); |
704 ASSERT(dn->dn_phys->dn_type || dn->dn_allocated_txg); |
751 ASSERT(dn->dn_phys->dn_type || dn->dn_allocated_txg); |
705 /* ASSERT(dn->dn_free_txg == 0 || dn->dn_free_txg >= txg); */ |
752 /* ASSERT(dn->dn_free_txg == 0 || dn->dn_free_txg >= txg); */ |
706 mutex_exit(&dn->dn_mtx); |
753 mutex_exit(&dn->dn_mtx); |
707 #endif |
754 #endif |
708 |
755 |
|
756 /* |
|
757 * Determine old uid/gid when necessary |
|
758 */ |
|
759 dmu_objset_userquota_get_ids(dn, B_TRUE); |
|
760 |
709 mutex_enter(&os->os_lock); |
761 mutex_enter(&os->os_lock); |
710 |
762 |
711 /* |
763 /* |
712 * If we are already marked dirty, we're done. |
764 * If we are already marked dirty, we're done. |
713 */ |
765 */ |
718 |
770 |
719 ASSERT(!refcount_is_zero(&dn->dn_holds) || list_head(&dn->dn_dbufs)); |
771 ASSERT(!refcount_is_zero(&dn->dn_holds) || list_head(&dn->dn_dbufs)); |
720 ASSERT(dn->dn_datablksz != 0); |
772 ASSERT(dn->dn_datablksz != 0); |
721 ASSERT3U(dn->dn_next_bonuslen[txg&TXG_MASK], ==, 0); |
773 ASSERT3U(dn->dn_next_bonuslen[txg&TXG_MASK], ==, 0); |
722 ASSERT3U(dn->dn_next_blksz[txg&TXG_MASK], ==, 0); |
774 ASSERT3U(dn->dn_next_blksz[txg&TXG_MASK], ==, 0); |
|
775 ASSERT3U(dn->dn_next_bonustype[txg&TXG_MASK], ==, 0); |
723 |
776 |
724 dprintf_ds(os->os_dsl_dataset, "obj=%llu txg=%llu\n", |
777 dprintf_ds(os->os_dsl_dataset, "obj=%llu txg=%llu\n", |
725 dn->dn_object, txg); |
778 dn->dn_object, txg); |
726 |
779 |
727 if (dn->dn_free_txg > 0 && dn->dn_free_txg <= txg) { |
780 if (dn->dn_free_txg > 0 && dn->dn_free_txg <= txg) { |
812 |
865 |
813 mutex_enter(&dn->dn_dbufs_mtx); |
866 mutex_enter(&dn->dn_dbufs_mtx); |
814 for (db = list_head(&dn->dn_dbufs); db; db = db_next) { |
867 for (db = list_head(&dn->dn_dbufs); db; db = db_next) { |
815 db_next = list_next(&dn->dn_dbufs, db); |
868 db_next = list_next(&dn->dn_dbufs, db); |
816 |
869 |
817 if (db->db_blkid != 0 && db->db_blkid != DB_BONUS_BLKID) { |
870 if (db->db_blkid != 0 && db->db_blkid != DMU_BONUS_BLKID && |
|
871 db->db_blkid != DMU_SPILL_BLKID) { |
818 mutex_exit(&dn->dn_dbufs_mtx); |
872 mutex_exit(&dn->dn_dbufs_mtx); |
819 goto fail; |
873 goto fail; |
820 } |
874 } |
821 } |
875 } |
822 mutex_exit(&dn->dn_dbufs_mtx); |
876 mutex_exit(&dn->dn_dbufs_mtx); |
856 { |
910 { |
857 uint64_t txgoff = tx->tx_txg & TXG_MASK; |
911 uint64_t txgoff = tx->tx_txg & TXG_MASK; |
858 int epbs, new_nlevels; |
912 int epbs, new_nlevels; |
859 uint64_t sz; |
913 uint64_t sz; |
860 |
914 |
861 ASSERT(blkid != DB_BONUS_BLKID); |
915 ASSERT(blkid != DMU_BONUS_BLKID); |
862 |
916 |
863 ASSERT(have_read ? |
917 ASSERT(have_read ? |
864 RW_READ_HELD(&dn->dn_struct_rwlock) : |
918 RW_READ_HELD(&dn->dn_struct_rwlock) : |
865 RW_WRITE_HELD(&dn->dn_struct_rwlock)); |
919 RW_WRITE_HELD(&dn->dn_struct_rwlock)); |
866 |
920 |
913 mutex_enter(&new->dt.di.dr_mtx); |
967 mutex_enter(&new->dt.di.dr_mtx); |
914 list = &dn->dn_dirty_records[txgoff]; |
968 list = &dn->dn_dirty_records[txgoff]; |
915 for (dr = list_head(list); dr; dr = dr_next) { |
969 for (dr = list_head(list); dr; dr = dr_next) { |
916 dr_next = list_next(&dn->dn_dirty_records[txgoff], dr); |
970 dr_next = list_next(&dn->dn_dirty_records[txgoff], dr); |
917 if (dr->dr_dbuf->db_level != new_nlevels-1 && |
971 if (dr->dr_dbuf->db_level != new_nlevels-1 && |
918 dr->dr_dbuf->db_blkid != DB_BONUS_BLKID) { |
972 dr->dr_dbuf->db_blkid != DMU_BONUS_BLKID && |
|
973 dr->dr_dbuf->db_blkid != DMU_SPILL_BLKID) { |
919 ASSERT(dr->dr_dbuf->db_level == old_nlevels-1); |
974 ASSERT(dr->dr_dbuf->db_level == old_nlevels-1); |
920 list_remove(&dn->dn_dirty_records[txgoff], dr); |
975 list_remove(&dn->dn_dirty_records[txgoff], dr); |
921 list_insert_tail(&new->dt.di.dr_children, dr); |
976 list_insert_tail(&new->dt.di.dr_children, dr); |
922 dr->dr_parent = new; |
977 dr->dr_parent = new; |
923 } |
978 } |
1168 dn->dn_maxblkid = (off >> blkshift ? (off >> blkshift) - 1 : 0); |
1223 dn->dn_maxblkid = (off >> blkshift ? (off >> blkshift) - 1 : 0); |
1169 |
1224 |
1170 rw_exit(&dn->dn_struct_rwlock); |
1225 rw_exit(&dn->dn_struct_rwlock); |
1171 } |
1226 } |
1172 |
1227 |
|
1228 static boolean_t |
|
1229 dnode_spill_freed(dnode_t *dn) |
|
1230 { |
|
1231 int i; |
|
1232 |
|
1233 mutex_enter(&dn->dn_mtx); |
|
1234 for (i = 0; i < TXG_SIZE; i++) { |
|
1235 if (dn->dn_rm_spillblk[i] == DN_KILL_SPILLBLK) |
|
1236 break; |
|
1237 } |
|
1238 mutex_exit(&dn->dn_mtx); |
|
1239 return (i < TXG_SIZE); |
|
1240 } |
|
1241 |
1173 /* return TRUE if this blkid was freed in a recent txg, or FALSE if it wasn't */ |
1242 /* return TRUE if this blkid was freed in a recent txg, or FALSE if it wasn't */ |
1174 uint64_t |
1243 uint64_t |
1175 dnode_block_freed(dnode_t *dn, uint64_t blkid) |
1244 dnode_block_freed(dnode_t *dn, uint64_t blkid) |
1176 { |
1245 { |
1177 free_range_t range_tofind; |
1246 free_range_t range_tofind; |
1178 void *dp = spa_get_dsl(dn->dn_objset->os_spa); |
1247 void *dp = spa_get_dsl(dn->dn_objset->os_spa); |
1179 int i; |
1248 int i; |
1180 |
1249 |
1181 if (blkid == DB_BONUS_BLKID) |
1250 if (blkid == DMU_BONUS_BLKID) |
1182 return (FALSE); |
1251 return (FALSE); |
1183 |
1252 |
1184 /* |
1253 /* |
1185 * If we're in the process of opening the pool, dp will not be |
1254 * If we're in the process of opening the pool, dp will not be |
1186 * set yet, but there shouldn't be anything dirty. |
1255 * set yet, but there shouldn't be anything dirty. |
1188 if (dp == NULL) |
1257 if (dp == NULL) |
1189 return (FALSE); |
1258 return (FALSE); |
1190 |
1259 |
1191 if (dn->dn_free_txg) |
1260 if (dn->dn_free_txg) |
1192 return (TRUE); |
1261 return (TRUE); |
|
1262 |
|
1263 if (blkid == DMU_SPILL_BLKID) |
|
1264 return (dnode_spill_freed(dn)); |
1193 |
1265 |
1194 range_tofind.fr_blkid = blkid; |
1266 range_tofind.fr_blkid = blkid; |
1195 mutex_enter(&dn->dn_mtx); |
1267 mutex_enter(&dn->dn_mtx); |
1196 for (i = 0; i < TXG_SIZE; i++) { |
1268 for (i = 0; i < TXG_SIZE; i++) { |
1197 free_range_t *range_found; |
1269 free_range_t *range_found; |