Lines Matching +defs:level +defs:list
81 * the total size of all dbufs at each level.
208 * 2. LRU cache of dbufs. The dbuf cache maintains a list of dbufs that
335 #define DBUF_EQUAL(dbuf, os, obj, level, blkid) \
338 (dbuf)->db_level == (level) && \
342 dbuf_find(objset_t *os, uint64_t obj, uint8_t level, uint64_t blkid,
350 hv = dbuf_hash(os, obj, level, blkid);
355 if (DBUF_EQUAL(db, os, obj, level, blkid)) {
400 int level = db->db_level;
406 ASSERT3U(dbuf_hash(os, obj, level, blkid), ==, db->db_hash);
412 if (DBUF_EQUAL(dbf, os, obj, level, blkid)) {
666 dnode_level_is_l2cacheable(blkptr_t *bp, dnode_t *dn, int64_t level)
670 (level > 0 ||
710 * (i.e. it's objset, object, level and blkid fields don't change).
1304 * Calculate which level n block references the data at the level 0 offset
1308 dbuf_whichblock(const dnode_t *dn, const int64_t level, const uint64_t offset)
1312 * The level n blkid is equal to the level 0 blkid divided by
1313 * the number of level 0s in a level n block.
1315 * The level 0 blkid is offset >> datablkshift =
1318 * The number of level 0s in a level n is the number of block
1319 * pointers in an indirect block, raised to the power of level.
1320 * This is 2^(indblkshift - SPA_BLKPTRSHIFT)^level =
1321 * 2^(level*(indblkshift - SPA_BLKPTRSHIFT)).
1323 * Thus, the level n blkid is: offset /
1324 * ((2^datablkshift)*(2^(level*(indblkshift-SPA_BLKPTRSHIFT))))
1325 * = offset / 2^(datablkshift + level *
1327 * = offset >> (datablkshift + level *
1332 level * (dn->dn_indblkshift - SPA_BLKPTRSHIFT);
1335 /* This only happens on the highest indirection level */
1336 ASSERT3U(level, ==, dn->dn_nlevels - 1);
1488 * For level 0 blocks only, if the above check fails:
1685 * the buffer, we just traverse the active dbuf list for the dnode.
1973 * Evict (if its unreferenced) or clear (if its referenced) any level-0
2013 /* found a level 0 buffer in the range */
2603 * where this dirty record may be put on a list.
2670 * level 0 block, we cannot simply redirty it,
3307 dbuf_findbp(dnode_t *dn, int level, uint64_t blkid, int fail_sparse,
3332 ASSERT3U(level * epbs, <, 64);
3349 ASSERT(level >= nlevels ||
3350 ((nlevels - level - 1) * epbs) +
3352 if (level >= nlevels ||
3354 ((nlevels - level - 1) * epbs)) ||
3356 blkid > (dn->dn_phys->dn_maxblkid >> (level * epbs)))) {
3359 } else if (level < nlevels-1) {
3363 err = dbuf_hold_impl(dn, level + 1,
3378 if (blkid > (dn->dn_phys->dn_maxblkid >> (level * epbs)))
3384 ASSERT3U(level, ==, nlevels-1);
3397 dbuf_create(dnode_t *dn, uint8_t level, uint64_t blkid,
3413 db->db_level = level;
3455 * in the hash table *and* added to the dbufs list.
3458 * dn_dbufs list.
3497 dbuf_dnode_findbp(dnode_t *dn, uint64_t level, uint64_t blkid,
3505 err = dbuf_findbp(dn, level, blkid, B_FALSE, &dbp, &bp2);
3524 int dpa_curlevel; /* The current level that we're reading */
3688 * Issue prefetch reads for the given block on the given level. If the indirect
3695 dbuf_prefetch_impl(dnode_t *dn, int64_t level, uint64_t blkid,
3709 if (level == 0 && dnode_block_freed(dn, blkid))
3717 if (level >= nlevels || dn->dn_phys->dn_nblkptr == 0)
3721 if (dn->dn_phys->dn_maxblkid < blkid << (epbs * level))
3725 level, blkid, NULL);
3740 curlevel = level;
3778 dn->dn_object, level, blkid);
3789 if (!DNODE_LEVEL_IS_CACHEABLE(dn, level))
3791 else if (dnode_level_is_l2cacheable(&bp, dn, level))
3797 * a higher level, though, we want to issue the prefetches for all the
3801 if (curlevel == level) {
3809 if (dnode_level_is_l2cacheable(&bp, dn, level))
3828 cb(arg, level, blkid, B_FALSE);
3833 dbuf_prefetch(dnode_t *dn, int64_t level, uint64_t blkid, zio_priority_t prio,
3837 return (dbuf_prefetch_impl(dn, level, blkid, prio, aflags, NULL, NULL));
3886 dbuf_hold_impl(dnode_t *dn, uint8_t level, uint64_t blkid,
3902 ASSERT3U(dn->dn_nlevels, >, level);
3907 db = dbuf_find(dn->dn_objset, dn->dn_object, level, blkid, &hv);
3917 err = dbuf_findbp(dn, level, blkid, fail_sparse, &parent, &bp);
3929 db = dbuf_create(dn, level, blkid, parent, bp, hv);
3994 ASSERT3U(db->db_level, ==, level);
4007 dbuf_hold_level(dnode_t *dn, int level, uint64_t blkid, const void *tag)
4010 int err = dbuf_hold_impl(dn, level, blkid, FALSE, FALSE, tag, &db);
4839 dbuf_sync_list(list_t *list, int level, dmu_tx_t *tx)
4843 while ((dr = list_head(list))) {
4848 * The dbufs for all dnodes are put back on the list
4856 list_remove(list, dr);
4862 VERIFY3U(dr->dr_dbuf->db_level, ==, level);
5295 /* Our parent's buffer is one level closer to the dnode. */