Lines Matching refs:entry
580 struct btrfs_free_space_entry *entry;
585 entry = io_ctl->cur;
586 put_unaligned_le64(offset, &entry->offset);
587 put_unaligned_le64(bytes, &entry->bytes);
588 entry->type = (bitmap) ? BTRFS_FREE_SPACE_BITMAP :
648 struct btrfs_free_space *entry, u8 *type)
660 entry->offset = get_unaligned_le64(&e->offset);
661 entry->bytes = get_unaligned_le64(&e->bytes);
675 struct btrfs_free_space *entry)
683 copy_page(entry->bitmap, io_ctl->cur);
723 * we want the extent entry threshold to always be at most 1/2 the max
1250 struct btrfs_free_space *entry, *next;
1254 list_for_each_entry_safe(entry, next, bitmap_list, list) {
1255 ret = io_ctl_add_bitmap(io_ctl, entry->bitmap);
1258 list_del_init(&entry->list);
1279 struct btrfs_free_space *entry, *next;
1281 list_for_each_entry_safe(entry, next, bitmap_list, list)
1282 list_del_init(&entry->list);
1616 * we could have a bitmap entry and an extent entry
1618 * the extent entry to always be found first if we do a
1622 * if we're inserting a bitmap and we find an entry at
1623 * this offset, we want to go right, or after this entry
1659 * may pick some previous entry that has a smaller ->max_extent_size than we
1661 * ->max_extent_size set to 4K and ->bytes set to 1M. A second entry hasn't set
1664 * that first bitmap entry had ->max_extent_size set, but the second one did
1668 * Consider the other case, we have 2 8K chunks in that second entry and still
1674 static inline u64 get_max_extent_size(const struct btrfs_free_space *entry)
1676 if (entry->bitmap && entry->max_extent_size)
1677 return entry->max_extent_size;
1678 return entry->bytes;
1682 * We want the largest entry to be leftmost, so this is inverted from what you'd
1687 const struct btrfs_free_space *entry, *exist;
1689 entry = rb_entry(node, struct btrfs_free_space, bytes_index);
1691 return get_max_extent_size(exist) < get_max_extent_size(entry);
1706 struct btrfs_free_space *entry = NULL, *prev = NULL;
1710 /* find entry that is closest to the 'offset' */
1712 entry = rb_entry(n, struct btrfs_free_space, offset_index);
1713 prev = entry;
1715 if (offset < entry->offset)
1717 else if (offset > entry->offset)
1722 entry = NULL;
1726 if (!entry)
1728 if (entry->bitmap)
1729 return entry;
1732 * bitmap entry and extent entry may share same offset,
1733 * in that case, bitmap entry comes after extent entry.
1738 entry = rb_entry(n, struct btrfs_free_space, offset_index);
1739 if (entry->offset != offset)
1742 WARN_ON(!entry->bitmap);
1743 return entry;
1744 } else if (entry) {
1745 if (entry->bitmap) {
1747 * if previous extent entry covers the offset,
1748 * we should return it instead of the bitmap entry
1750 n = rb_prev(&entry->offset_index);
1756 entry = prev;
1759 return entry;
1765 /* find last entry before the 'offset' */
1766 entry = prev;
1767 if (entry->offset > offset) {
1768 n = rb_prev(&entry->offset_index);
1770 entry = rb_entry(n, struct btrfs_free_space,
1772 ASSERT(entry->offset <= offset);
1775 return entry;
1781 if (entry->bitmap) {
1782 n = rb_prev(&entry->offset_index);
1790 if (entry->offset + BITS_PER_BITMAP * ctl->unit > offset)
1791 return entry;
1792 } else if (entry->offset + entry->bytes > offset)
1793 return entry;
1799 n = rb_next(&entry->offset_index);
1802 entry = rb_entry(n, struct btrfs_free_space, offset_index);
1803 if (entry->bitmap) {
1804 if (entry->offset + BITS_PER_BITMAP *
1808 if (entry->offset + entry->bytes > offset)
1812 return entry;
1864 * If our entry is empty it's because we're on a cluster and we don't
2012 struct btrfs_free_space *entry;
2024 entry = tree_search_offset(ctl, offset_to_bitmap(ctl, *offset),
2026 if (!entry)
2028 node = &entry->offset_index;
2033 entry = rb_entry(node, struct btrfs_free_space,
2036 entry = rb_entry(node, struct btrfs_free_space,
2047 if (entry->bytes < *bytes) {
2048 *max_extent_size = max(get_max_extent_size(entry),
2059 tmp = entry->offset - ctl->start + align - 1;
2062 align_off = tmp - entry->offset;
2065 tmp = entry->offset;
2070 * may have another entry that has the correct alignment that is
2075 if (entry->bytes < *bytes + align_off) {
2076 *max_extent_size = max(get_max_extent_size(entry),
2081 if (entry->bitmap) {
2085 ret = search_bitmap(ctl, entry, &tmp, &size, true);
2089 return entry;
2092 max(get_max_extent_size(entry),
2108 *bytes = entry->bytes - align_off;
2109 return entry;
2190 * no entry after this bitmap, but we still have bytes to
2200 * if the next entry isn't a bitmap we need to return to let the
2298 * entry.
2338 struct btrfs_free_space *entry;
2350 entry = rb_entry(node, struct btrfs_free_space, offset_index);
2351 if (!entry->bitmap) {
2356 if (entry->offset == offset_to_bitmap(ctl, offset)) {
2357 bytes_added = add_bytes_to_bitmap(ctl, entry, offset,
2587 * entry, try to see if there's adjacent free space in bitmap entries, and if
2590 * because we attempt to satisfy them based on a single cache entry, and never
2592 * region (e.g. 1 extent entry + 1 bitmap entry starting where the extent entry
2664 * attempt to steal space from bitmaps if we're adding an extent entry.
2874 /* Not enough bytes in this entry to satisfy us */
2932 btrfs_crit(fs_info, "entry offset %llu, bytes %llu, bitmap %s",
2993 struct btrfs_free_space *entry;
2995 entry = rb_entry(node, struct btrfs_free_space, offset_index);
2996 node = rb_next(&entry->offset_index);
2997 rb_erase(&entry->offset_index, &cluster->root);
2998 RB_CLEAR_NODE(&entry->offset_index);
3000 if (!entry->bitmap) {
3002 if (!btrfs_free_space_trimmed(entry)) {
3005 entry->bytes;
3008 try_merge_free_space(ctl, entry, false);
3009 steal_from_bitmap(ctl, entry, false);
3012 if (!btrfs_free_space_trimmed(entry)) {
3015 entry->bytes;
3018 tree_insert_offset(ctl, NULL, entry);
3019 rb_add_cached(&entry->bytes_index, &ctl->free_space_bytes,
3085 struct btrfs_free_space *entry = NULL;
3096 entry = find_free_space(ctl, &offset, &bytes_search,
3099 if (!entry)
3103 if (entry->bitmap) {
3104 bitmap_clear_bits(ctl, entry, offset, bytes, true);
3106 if (!btrfs_free_space_trimmed(entry))
3109 if (!entry->bytes)
3110 free_bitmap(ctl, entry);
3112 unlink_free_space(ctl, entry, true);
3113 align_gap_len = offset - entry->offset;
3114 align_gap = entry->offset;
3115 align_gap_trim_state = entry->trim_state;
3117 if (!btrfs_free_space_trimmed(entry))
3120 entry->offset = offset + bytes;
3121 WARN_ON(entry->bytes < bytes + align_gap_len);
3123 entry->bytes -= bytes + align_gap_len;
3124 if (!entry->bytes)
3125 kmem_cache_free(btrfs_free_space_cachep, entry);
3127 link_free_space(ctl, entry);
3184 struct btrfs_free_space *entry,
3197 err = search_bitmap(ctl, entry, &search_start, &search_bytes, true);
3199 *max_extent_size = max(get_max_extent_size(entry),
3205 bitmap_clear_bits(ctl, entry, ret, bytes, false);
3222 struct btrfs_free_space *entry = NULL;
3239 entry = rb_entry(node, struct btrfs_free_space, offset_index);
3241 if (entry->bytes < bytes)
3242 *max_extent_size = max(get_max_extent_size(entry),
3245 if (entry->bytes < bytes ||
3246 (!entry->bitmap && entry->offset < min_start)) {
3247 node = rb_next(&entry->offset_index);
3250 entry = rb_entry(node, struct btrfs_free_space,
3255 if (entry->bitmap) {
3257 cluster, entry, bytes,
3261 node = rb_next(&entry->offset_index);
3264 entry = rb_entry(node, struct btrfs_free_space,
3270 ret = entry->offset;
3272 entry->offset += bytes;
3273 entry->bytes -= bytes;
3286 if (!btrfs_free_space_trimmed(entry))
3290 if (!entry->bitmap && !btrfs_free_space_trimmed(entry))
3294 if (entry->bytes == 0) {
3295 rb_erase(&entry->offset_index, &cluster->root);
3297 if (entry->bitmap) {
3299 entry->bitmap);
3302 } else if (!btrfs_free_space_trimmed(entry)) {
3305 kmem_cache_free(btrfs_free_space_cachep, entry);
3315 struct btrfs_free_space *entry,
3333 i = offset_to_bit(entry->offset, ctl->unit,
3334 max_t(u64, offset, entry->offset));
3342 if (entry->max_extent_size &&
3343 entry->max_extent_size < cont1_bytes)
3347 for_each_set_bit_from(i, entry->bitmap, BITS_PER_BITMAP) {
3348 next_zero = find_next_zero_bit(entry->bitmap,
3362 entry->max_extent_size = (u64)max_bits * ctl->unit;
3381 cluster->window_start = start * ctl->unit + entry->offset;
3382 rb_erase(&entry->offset_index, &ctl->free_space_offset);
3383 rb_erase_cached(&entry->bytes_index, &ctl->free_space_bytes);
3390 * until this bitmap entry is added back into the normal cache.
3392 RB_CLEAR_NODE(&entry->bytes_index);
3394 ret = tree_insert_offset(ctl, cluster, entry);
3415 struct btrfs_free_space *entry = NULL;
3424 entry = tree_search_offset(ctl, offset, 0, 1);
3425 if (!entry)
3430 * extent entry.
3432 while (entry->bitmap || entry->bytes < min_bytes) {
3433 if (entry->bitmap && list_empty(&entry->list))
3434 list_add_tail(&entry->list, bitmaps);
3435 node = rb_next(&entry->offset_index);
3438 entry = rb_entry(node, struct btrfs_free_space, offset_index);
3441 window_free = entry->bytes;
3442 max_extent = entry->bytes;
3443 first = entry;
3444 last = entry;
3446 for (node = rb_next(&entry->offset_index); node;
3447 node = rb_next(&entry->offset_index)) {
3448 entry = rb_entry(node, struct btrfs_free_space, offset_index);
3450 if (entry->bitmap) {
3451 if (list_empty(&entry->list))
3452 list_add_tail(&entry->list, bitmaps);
3456 if (entry->bytes < min_bytes)
3459 last = entry;
3460 window_free += entry->bytes;
3461 if (entry->bytes > max_extent)
3462 max_extent = entry->bytes;
3479 entry = rb_entry(node, struct btrfs_free_space, offset_index);
3480 node = rb_next(&entry->offset_index);
3481 if (entry->bitmap || entry->bytes < min_bytes)
3484 rb_erase(&entry->offset_index, &ctl->free_space_offset);
3485 rb_erase_cached(&entry->bytes_index, &ctl->free_space_bytes);
3486 ret = tree_insert_offset(ctl, cluster, entry);
3487 total_size += entry->bytes;
3489 } while (node && entry != last);
3507 struct btrfs_free_space *entry = NULL;
3519 entry = list_first_entry(bitmaps, struct btrfs_free_space, list);
3521 if (!entry || entry->offset != bitmap_offset) {
3522 entry = tree_search_offset(ctl, bitmap_offset, 1, 0);
3523 if (entry && list_empty(&entry->list))
3524 list_add(&entry->list, bitmaps);
3527 list_for_each_entry(entry, bitmaps, list) {
3528 if (entry->bytes < bytes)
3530 ret = btrfs_bitmap_cluster(block_group, entry, cluster, offset,
3557 struct btrfs_free_space *entry, *tmp;
3611 list_for_each_entry_safe(entry, tmp, &bitmaps, list)
3612 list_del_init(&entry->list);
3711 struct btrfs_free_space *entry;
3729 entry = tree_search_offset(ctl, start, 0, 1);
3730 if (!entry)
3734 while (entry->bitmap ||
3735 (async && btrfs_free_space_trimmed(entry))) {
3736 node = rb_next(&entry->offset_index);
3739 entry = rb_entry(node, struct btrfs_free_space,
3743 if (entry->offset >= end)
3746 extent_start = entry->offset;
3747 extent_bytes = entry->bytes;
3748 extent_trim_state = entry->trim_state;
3750 start = entry->offset;
3751 bytes = entry->bytes;
3757 unlink_free_space(ctl, entry, true);
3768 entry->offset += max_discard_size;
3769 entry->bytes -= max_discard_size;
3770 link_free_space(ctl, entry);
3772 kmem_cache_free(btrfs_free_space_cachep, entry);
3783 unlink_free_space(ctl, entry, true);
3784 kmem_cache_free(btrfs_free_space_cachep, entry);
3840 struct btrfs_free_space *entry;
3843 entry = tree_search_offset(ctl, offset, 1, 0);
3844 if (entry) {
3845 if (btrfs_free_space_trimmed(entry)) {
3847 entry->bitmap_extents;
3848 ctl->discardable_bytes[BTRFS_STAT_CURR] += entry->bytes;
3850 entry->trim_state = BTRFS_TRIM_STATE_UNTRIMMED;
3857 struct btrfs_free_space *entry)
3859 if (btrfs_free_space_trimming_bitmap(entry)) {
3860 entry->trim_state = BTRFS_TRIM_STATE_TRIMMED;
3862 entry->bitmap_extents;
3863 ctl->discardable_bytes[BTRFS_STAT_CURR] -= entry->bytes;
3877 struct btrfs_free_space *entry;
3899 entry = tree_search_offset(ctl, offset, 1, 0);
3908 if (!entry || (async && minlen && start == offset &&
3909 btrfs_free_space_trimmed(entry))) {
3923 entry->trim_state = BTRFS_TRIM_STATE_TRIMMING;
3926 ret2 = search_bitmap(ctl, entry, &start, &bytes, false);
3933 end_trimming_bitmap(ctl, entry);
3935 entry->trim_state = BTRFS_TRIM_STATE_UNTRIMMED;
3970 bitmap_clear_bits(ctl, entry, start, bytes, true);
3971 if (entry->bytes == 0)
3972 free_bitmap(ctl, entry);
4180 * Use this if you need to make a bitmap or extent entry specifically, it