Two failures at the metadata fill edge under stripe_meta, both seen
with the tiny-file fill test on raid5 metadata.
The first is a transaction abort. A tree block is reserved in bytes
and admitted while claimable whole stripes cover the outstanding
reservations, but it is placed in whole stripes: the open run it would
have joined is closed at the transaction boundary, so every group
claims at least one fresh full stripe per transaction. The last few
megabytes of claimable supply go to those claims, made for reservations
admitted earlier, and the next admitted tree block finds no stripe at
all ("stripe_meta: tree block allocation of 16384 bytes returned
ENOSPC: claimable 0 open
1622016 trapped
1614266368"), which aborts the
transaction. Pre-pay two transactions' worth of claims -- twice the
number of writable groups times the widest full stripe -- in the
space_info's stripe margin, recomputed at each commit scan. Best-fit
run selection opens a fresh run only when a group's runs are full, so
this is a few megabytes, not a fraction of the space_info.
The second is a filesystem that quietly runs out at half capacity.
COW frees trap stripes rather than free them: a stripe is claimable
again only once every tree block in it is dead, which random deaths in
a sixteen-block stripe essentially never achieve, so the METADATA
space_info settles around half used, half trapped and no claimable
stripe left (3.04 GiB metadata, 49% used, fs not writable, deletes
included). Only relocation packs live tree blocks back into whole
stripes, and it needs the moved group's live bytes claimable elsewhere
before it starts -- by the time the trigger fires there is nothing
left. Hold back a reserve of whole stripes -- the largest writable
group's length, capped at a quarter of the space_info, nothing with a
single group -- from every metadata reservation except those made by
the relocation task, identified by a task pointer that reloc_ctl
already implies. Reservations admitted against the reserve reach the
same tickets, so the flag travels with the ticket. The reserve is an
accounting hold-back, not a partition: a committing transaction still
allocates from those stripes when it must, and the next scan restates
the reserve from what remains. Both counters are cleared when
stripe_alloc is turned off, since the scan that maintains them stops
with it.
The reserve is reported through sysfs as bytes_stripe_reserve and in
the space_info dump, whose stripe_claimable and stripe_margin values
were printed under each other's label.
Assisted-by: Claude:claude-fable-5
list_for_each_entry(sinfo, &fs_info->space_info, list) {
int raid;
- if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA))
+ if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA)) {
+ /*
+ * Metadata: the scan that maintains the stripe_meta
+ * margin and reserve stops with the option, so clear
+ * them here or they hold metadata back forever.
+ */
+ if (!arm && (sinfo->flags & BTRFS_BLOCK_GROUP_METADATA)) {
+ spin_lock(&sinfo->lock);
+ sinfo->bytes_stripe_margin = 0;
+ sinfo->bytes_stripe_reserve = 0;
+ btrfs_try_granting_tickets(sinfo);
+ spin_unlock(&sinfo->lock);
+ }
continue;
+ }
down_read(&sinfo->groups_sem);
for (raid = 0; raid < BTRFS_NR_RAID_TYPES; raid++) {
struct btrfs_block_group *bg;
u64 total = 0;
u64 total_claimable = 0;
u64 total_claimable_reloc = 0;
+ u64 largest = 0;
+ u64 unit = 0;
+ u32 nr_rw = 0;
int raid;
/*
if (bg->start == READ_ONCE(fs_info->data_reloc_bg))
total_claimable_reloc +=
READ_ONCE(bg->stripe_claimable);
+ nr_rw++;
+ largest = max(largest, bg->length);
}
+ unit = max(unit, bg->full_stripe_len);
}
}
up_read(&sinfo->groups_sem);
sinfo->bytes_stripe_unusable = total;
sinfo->bytes_stripe_claimable = total_claimable;
sinfo->bytes_stripe_claimable_reloc = total_claimable_reloc;
+ if (!(sinfo->flags & BTRFS_BLOCK_GROUP_DATA)) {
+ u64 reserve = 0;
+
+ /*
+ * stripe_meta. A tree block is reserved in bytes but
+ * placed in whole stripes: the run it would join is
+ * closed at the transaction boundary, so each group
+ * claims at least one fresh stripe per transaction.
+ * Pre-pay two transactions' worth of such claims, or
+ * the last claimable stripes go to claims made for
+ * reservations admitted earlier and an admitted tree
+ * block finds none, which aborts the transaction.
+ */
+ sinfo->bytes_stripe_margin = 2ULL * nr_rw * unit;
+ /*
+ * COW frees trap stripes rather than free them (a
+ * stripe is claimable again only once every block in
+ * it is dead), so the space_info settles around half
+ * used, half trapped. Only relocation packs live tree
+ * blocks back into whole stripes, and it needs the
+ * moved group's live bytes claimable elsewhere first.
+ * Hold back enough for any one group, capped at a
+ * quarter of the space_info, from everyone but the
+ * relocation task. With a single group there is no
+ * elsewhere to hold it for. This is an accounting
+ * hold-back only: a committing transaction still
+ * allocates from these stripes if it must.
+ */
+ if (nr_rw > 1 && unit)
+ reserve = round_up(min(largest,
+ sinfo->total_bytes / 4),
+ unit);
+ sinfo->bytes_stripe_reserve = reserve;
+ }
/*
* The rescan usually lowers the counter (mid-transaction
* incremental adds overcount conservatively); admission
if (READ_ONCE(cache->stripe_unusable_ready))
trapped = min(READ_ONCE(cache->stripe_unusable), num_bytes);
if (btrfs_can_overcommit(sinfo, num_bytes - trapped,
- BTRFS_RESERVE_NO_FLUSH))
+ BTRFS_RESERVE_NO_FLUSH, false))
ret = 0;
}
struct btrfs_space_info *data_sinfo;
struct reloc_control *reloc_ctl;
+ /*
+ * The task running relocation while reloc_ctl is set. Under
+ * stripe_meta it alone may reserve metadata out of the whole stripes
+ * held back in bytes_stripe_reserve, so that a trapped metadata
+ * group can always be relocated (see btrfs_can_overcommit()).
+ */
+ struct task_struct *reloc_task;
/* data_alloc_cluster is only used in ssd_spread mode */
struct btrfs_free_cluster data_alloc_cluster;
spin_lock(&fs_info->reloc_ctl_lock);
fs_info->reloc_ctl = rc;
spin_unlock(&fs_info->reloc_ctl_lock);
+ WRITE_ONCE(fs_info->reloc_task, current);
mutex_unlock(&fs_info->reloc_mutex);
}
spin_lock(&fs_info->reloc_ctl_lock);
fs_info->reloc_ctl = NULL;
spin_unlock(&fs_info->reloc_ctl_lock);
+ WRITE_ONCE(fs_info->reloc_task, NULL);
mutex_unlock(&fs_info->reloc_mutex);
}
u64 bytes;
int error;
bool steal;
+ /* Made by the relocation task: may draw on bytes_stripe_reserve. */
+ bool reloc;
struct list_head list;
wait_queue_head_t wait;
spinlock_t lock;
}
bool btrfs_can_overcommit(const struct btrfs_space_info *space_info, u64 bytes,
- enum btrfs_reserve_flush_enum flush)
+ enum btrfs_reserve_flush_enum flush, bool reloc)
{
u64 used;
return false;
used = btrfs_space_info_used(space_info, true);
+ /*
+ * The stripe_meta reserve exists for relocation: it is the room in
+ * which the live tree blocks of a trapped group are packed into whole
+ * stripes. Everyone else sees it as used.
+ */
+ if (reloc)
+ used -= min(used, space_info->bytes_stripe_reserve);
return check_can_overcommit(space_info, used, bytes, flush);
}
u64 used_after;
ticket = list_first_entry(head, struct reserve_ticket, list);
+ /* Relocation's tickets may draw on the stripe_meta reserve. */
+ if (ticket->reloc)
+ used -= min(used, space_info->bytes_stripe_reserve);
used_after = used + ticket->bytes;
/* Check and see if our ticket can be satisfied now. */
if ((used_after <= space_info->total_bytes ||
can_overcommit(space_info, used, ticket->bytes, flush)) &&
- stripe_claimable_admit(space_info, ticket->bytes, false)) {
+ stripe_claimable_admit(space_info, ticket->bytes, ticket->reloc)) {
btrfs_space_info_update_bytes_may_use(space_info, ticket->bytes);
remove_ticket(space_info, ticket, 0);
space_info->tickets_id++;
(s64)(info->total_bytes - btrfs_space_info_used(info, true)),
info->full ? "" : "not ");
btrfs_info(fs_info,
-"space_info total=%llu, used=%llu, pinned=%llu, reserved=%llu, may_use=%llu, readonly=%llu zone_unusable=%llu stripe_unusable=%llu stripe_open=%llu stripe_margin=%llu stripe_claimable=%llu",
+"space_info total=%llu, used=%llu, pinned=%llu, reserved=%llu, may_use=%llu, readonly=%llu zone_unusable=%llu stripe_unusable=%llu stripe_open=%llu stripe_claimable=%llu stripe_margin=%llu stripe_reserve=%llu",
info->total_bytes, info->bytes_used, info->bytes_pinned,
info->bytes_reserved, info->bytes_may_use,
info->bytes_readonly, info->bytes_zone_unusable,
info->bytes_stripe_unusable, info->bytes_stripe_open,
info->bytes_stripe_claimable,
- info->bytes_stripe_margin);
+ info->bytes_stripe_margin, info->bytes_stripe_reserve);
}
void btrfs_dump_space_info(struct btrfs_space_info *info, u64 bytes,
u64 used;
int ret = -ENOSPC;
bool pending_tickets;
+ const bool reloc = (READ_ONCE(fs_info->reloc_task) == current);
ASSERT(orig_bytes, "orig_bytes=%llu", orig_bytes);
/*
* Carry on if we have enough space (short-circuit) OR call
* can_overcommit() to ensure we can overcommit to continue.
*/
+ if (reloc)
+ used -= min(used, space_info->bytes_stripe_reserve);
if (!pending_tickets &&
((used + orig_bytes <= space_info->total_bytes) ||
can_overcommit(space_info, used, orig_bytes, flush)) &&
init_waitqueue_head(&ticket.wait);
spin_lock_init(&ticket.lock);
ticket.steal = can_steal(flush);
+ ticket.reloc = reloc;
if (trace_btrfs_reserve_ticket_enabled())
start_ns = ktime_get_ns();
writeback can never trap space out
from under an admitted reservation.
Charged and released in lockstep with
- the inodes' outstanding_extents. */
+ the inodes' outstanding_extents.
+ On a stripe_meta METADATA space_info
+ it is instead set at each commit scan
+ to two transactions' worth of whole
+ stripe claims: every group can claim
+ a fresh stripe per transaction for a
+ tree block admitted in bytes. */
+ u64 bytes_stripe_reserve; /* stripe_meta: whole stripes held back
+ from every metadata reservation except
+ the relocation task's, so that any one
+ metadata group's live tree blocks can
+ be moved into whole stripes elsewhere.
+ COW frees trap rather than free
+ stripes, so without it the space_info
+ settles half used, half trapped, with
+ nothing left for reclaim to move
+ into. Counted in
+ btrfs_space_info_used(); recomputed
+ at each commit scan. */
u64 max_extent_size; /* This will hold the maximum extent size of
the space info if we had an ENOSPC in the
s_info->bytes_zone_unusable +
s_info->bytes_stripe_unusable + s_info->bytes_stripe_open +
s_info->bytes_stripe_margin +
+ s_info->bytes_stripe_reserve +
(may_use_included ? s_info->bytes_may_use : 0);
}
enum btrfs_reserve_flush_enum flush);
void btrfs_try_granting_tickets(struct btrfs_space_info *space_info);
bool btrfs_can_overcommit(const struct btrfs_space_info *space_info, u64 bytes,
- enum btrfs_reserve_flush_enum flush);
+ enum btrfs_reserve_flush_enum flush, bool reloc);
static inline void btrfs_space_info_free_bytes_may_use(
struct btrfs_space_info *space_info,
SPACE_INFO_ATTR(bytes_stripe_claimable);
SPACE_INFO_ATTR(bytes_stripe_open);
SPACE_INFO_ATTR(bytes_stripe_margin);
+SPACE_INFO_ATTR(bytes_stripe_reserve);
SPACE_INFO_ATTR(disk_used);
SPACE_INFO_ATTR(disk_total);
SPACE_INFO_ATTR(reclaim_count);
BTRFS_ATTR_PTR(space_info, bytes_stripe_claimable),
BTRFS_ATTR_PTR(space_info, bytes_stripe_open),
BTRFS_ATTR_PTR(space_info, bytes_stripe_margin),
+ BTRFS_ATTR_PTR(space_info, bytes_stripe_reserve),
BTRFS_ATTR_PTR(space_info, disk_used),
BTRFS_ATTR_PTR(space_info, disk_total),
BTRFS_ATTR_PTR(space_info, bg_reclaim_threshold),
projects / linux / commitdiff