Lines Matching defs:space_info
25 * 1) space_info. This is the ultimate arbiter of how much space we can use.
28 * reservations we care about total_bytes - SUM(space_info->bytes_) when
29 * determining if there is space to make an allocation. There is a space_info
35 * much space is accounted for in space_info->bytes_may_use.
41 * values to adjust the space_info counters.
50 * space_info->bytes_may_reserve += num_bytes
54 * space_info->bytes_may_reserve -= num_bytes
55 * space_info->bytes_reserved += extent_bytes
59 * space_info->bytes_reserved -= extent_bytes
60 * space_info->bytes_used += extent_bytes
69 * the tail of space_info->tickets, kick async flush thread
80 * space_info->bytes_may_use, ->bytes_pinned, etc, or adds to the
81 * space_info->total_bytes. This loops through the ->priority_tickets and
83 * completed. If it can the space is added to space_info->bytes_may_use and
94 * space_info->priority_tickets, and we do not use ticket->wait, we simply
180 struct list_head *head = &info->space_info;
218 void btrfs_update_space_info_chunk_size(struct btrfs_space_info *space_info,
221 WRITE_ONCE(space_info->chunk_size, chunk_size);
227 struct btrfs_space_info *space_info;
231 space_info = kzalloc(sizeof(*space_info), GFP_NOFS);
232 if (!space_info)
236 INIT_LIST_HEAD(&space_info->block_groups[i]);
237 init_rwsem(&space_info->groups_sem);
238 spin_lock_init(&space_info->lock);
239 space_info->flags = flags & BTRFS_BLOCK_GROUP_TYPE_MASK;
240 space_info->force_alloc = CHUNK_ALLOC_NO_FORCE;
241 INIT_LIST_HEAD(&space_info->ro_bgs);
242 INIT_LIST_HEAD(&space_info->tickets);
243 INIT_LIST_HEAD(&space_info->priority_tickets);
244 space_info->clamp = 1;
245 btrfs_update_space_info_chunk_size(space_info, calc_chunk_size(info, flags));
248 space_info->bg_reclaim_threshold = BTRFS_DEFAULT_ZONED_RECLAIM_THRESH;
250 ret = btrfs_sysfs_add_space_info_type(info, space_info);
254 list_add(&space_info->list, &info->space_info);
256 info->data_sinfo = space_info;
320 block_group->space_info = found;
331 struct list_head *head = &info->space_info;
344 struct btrfs_space_info *space_info,
353 if (space_info->flags & BTRFS_BLOCK_GROUP_SYSTEM)
372 * Calculate the data_chunk_size, space_info->chunk_size is the
412 struct btrfs_space_info *space_info, u64 bytes,
419 if (space_info->flags & BTRFS_BLOCK_GROUP_DATA)
422 used = btrfs_space_info_used(space_info, true);
423 avail = calc_available_free_space(fs_info, space_info, flush);
425 if (used + bytes < space_info->total_bytes + avail)
430 static void remove_ticket(struct btrfs_space_info *space_info,
435 ASSERT(space_info->reclaim_size >= ticket->bytes);
436 space_info->reclaim_size -= ticket->bytes;
441 * This is for space we already have accounted in space_info->bytes_may_use, so
445 struct btrfs_space_info *space_info)
450 lockdep_assert_held(&space_info->lock);
452 head = &space_info->priority_tickets;
456 u64 used = btrfs_space_info_used(space_info, true);
461 if ((used + ticket->bytes <= space_info->total_bytes) ||
462 btrfs_can_overcommit(fs_info, space_info, ticket->bytes,
465 space_info,
467 remove_ticket(space_info, ticket);
469 space_info->tickets_id++;
476 if (head == &space_info->priority_tickets) {
477 head = &space_info->tickets;
492 static const char *space_info_flag_to_str(const struct btrfs_space_info *space_info)
494 switch (space_info->flags) {
524 btrfs_info(fs_info, "space_info %s has %lld free, is %sfull",
529 "space_info total=%llu, used=%llu, pinned=%llu, reserved=%llu, may_use=%llu, readonly=%llu zone_unusable=%llu",
596 struct btrfs_space_info *space_info,
706 spin_lock(&space_info->lock);
707 if (list_empty(&space_info->tickets) &&
708 list_empty(&space_info->priority_tickets)) {
709 spin_unlock(&space_info->lock);
712 spin_unlock(&space_info->lock);
724 * state of @space_info to detect the outcome.
727 struct btrfs_space_info *space_info, u64 num_bytes,
758 shrink_delalloc(fs_info, space_info, num_bytes,
784 btrfs_get_alloc_profile(fs_info, space_info->flags),
824 trace_btrfs_flush_space(fs_info, space_info->flags, num_bytes, state,
831 struct btrfs_space_info *space_info)
835 u64 to_reclaim = space_info->reclaim_size;
837 lockdep_assert_held(&space_info->lock);
839 avail = calc_available_free_space(fs_info, space_info,
841 used = btrfs_space_info_used(space_info, true);
849 if (space_info->total_bytes + avail < used)
850 to_reclaim += used - (space_info->total_bytes + avail);
856 struct btrfs_space_info *space_info)
863 thresh = mult_perc(space_info->total_bytes, 90);
865 lockdep_assert_held(&space_info->lock);
868 if ((space_info->bytes_used + space_info->bytes_reserved +
872 used = space_info->bytes_may_use + space_info->bytes_pinned;
890 if (space_info->reclaim_size)
903 * of the space_info used by bytes_used and we had 0 available we'd just
922 thresh = calc_available_free_space(fs_info, space_info,
924 used = space_info->bytes_used + space_info->bytes_reserved +
925 space_info->bytes_readonly + global_rsv_size;
926 if (used < space_info->total_bytes)
927 thresh += space_info->total_bytes - used;
928 thresh >>= space_info->clamp;
930 used = space_info->bytes_pinned;
961 used += space_info->bytes_may_use - global_rsv_size;
968 struct btrfs_space_info *space_info,
977 if (global_rsv->space_info != space_info)
987 remove_ticket(space_info, ticket);
990 space_info->tickets_id++;
1002 * @space_info - the space info we were flushing
1015 struct btrfs_space_info *space_info)
1018 u64 tickets_id = space_info->tickets_id;
1021 trace_btrfs_fail_all_tickets(fs_info, space_info);
1025 __btrfs_dump_space_info(fs_info, space_info);
1028 while (!list_empty(&space_info->tickets) &&
1029 tickets_id == space_info->tickets_id) {
1030 ticket = list_first_entry(&space_info->tickets,
1033 if (!aborted && steal_from_global_rsv(fs_info, space_info, ticket))
1040 remove_ticket(space_info, ticket);
1054 btrfs_try_granting_tickets(fs_info, space_info);
1056 return (tickets_id != space_info->tickets_id);
1067 struct btrfs_space_info *space_info;
1074 space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
1076 spin_lock(&space_info->lock);
1077 to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info, space_info);
1079 space_info->flush = 0;
1080 spin_unlock(&space_info->lock);
1083 last_tickets_id = space_info->tickets_id;
1084 spin_unlock(&space_info->lock);
1088 flush_space(fs_info, space_info, to_reclaim, flush_state, false);
1089 spin_lock(&space_info->lock);
1090 if (list_empty(&space_info->tickets)) {
1091 space_info->flush = 0;
1092 spin_unlock(&space_info->lock);
1096 space_info);
1097 if (last_tickets_id == space_info->tickets_id) {
1100 last_tickets_id = space_info->tickets_id;
1130 if (maybe_fail_all_tickets(fs_info, space_info)) {
1134 space_info->flush = 0;
1140 spin_unlock(&space_info->lock);
1155 struct btrfs_space_info *space_info;
1164 space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
1170 spin_lock(&space_info->lock);
1171 while (need_preemptive_reclaim(fs_info, space_info)) {
1190 if (block_rsv_size < space_info->bytes_may_use)
1191 delalloc_size = space_info->bytes_may_use - block_rsv_size;
1208 } else if (space_info->bytes_pinned >
1211 to_reclaim = space_info->bytes_pinned;
1222 spin_unlock(&space_info->lock);
1232 flush_space(fs_info, space_info, to_reclaim, flush, true);
1234 spin_lock(&space_info->lock);
1238 if (loops == 1 && !space_info->reclaim_size)
1239 space_info->clamp = max(1, space_info->clamp - 1);
1240 trace_btrfs_done_preemptive_reclaim(fs_info, space_info);
1241 spin_unlock(&space_info->lock);
1287 struct btrfs_space_info *space_info;
1292 space_info = fs_info->data_sinfo;
1294 spin_lock(&space_info->lock);
1295 if (list_empty(&space_info->tickets)) {
1296 space_info->flush = 0;
1297 spin_unlock(&space_info->lock);
1300 last_tickets_id = space_info->tickets_id;
1301 spin_unlock(&space_info->lock);
1303 while (!space_info->full) {
1304 flush_space(fs_info, space_info, U64_MAX, ALLOC_CHUNK_FORCE, false);
1305 spin_lock(&space_info->lock);
1306 if (list_empty(&space_info->tickets)) {
1307 space_info->flush = 0;
1308 spin_unlock(&space_info->lock);
1315 last_tickets_id = space_info->tickets_id;
1316 spin_unlock(&space_info->lock);
1320 flush_space(fs_info, space_info, U64_MAX,
1322 spin_lock(&space_info->lock);
1323 if (list_empty(&space_info->tickets)) {
1324 space_info->flush = 0;
1325 spin_unlock(&space_info->lock);
1329 if (last_tickets_id == space_info->tickets_id) {
1332 last_tickets_id = space_info->tickets_id;
1337 if (space_info->full) {
1338 if (maybe_fail_all_tickets(fs_info, space_info))
1341 space_info->flush = 0;
1351 spin_unlock(&space_info->lock);
1356 maybe_fail_all_tickets(fs_info, space_info);
1357 space_info->flush = 0;
1358 spin_unlock(&space_info->lock);
1388 struct btrfs_space_info *space_info,
1396 spin_lock(&space_info->lock);
1397 to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info, space_info);
1405 spin_unlock(&space_info->lock);
1410 spin_unlock(&space_info->lock);
1411 flush_space(fs_info, space_info, to_reclaim, states[flush_state],
1414 spin_lock(&space_info->lock);
1416 spin_unlock(&space_info->lock);
1431 remove_ticket(space_info, ticket);
1432 } else if (!steal_from_global_rsv(fs_info, space_info, ticket)) {
1434 remove_ticket(space_info, ticket);
1442 btrfs_try_granting_tickets(fs_info, space_info);
1443 spin_unlock(&space_info->lock);
1447 struct btrfs_space_info *space_info,
1450 spin_lock(&space_info->lock);
1454 spin_unlock(&space_info->lock);
1458 while (!space_info->full) {
1459 spin_unlock(&space_info->lock);
1460 flush_space(fs_info, space_info, U64_MAX, ALLOC_CHUNK_FORCE, false);
1461 spin_lock(&space_info->lock);
1463 spin_unlock(&space_info->lock);
1469 remove_ticket(space_info, ticket);
1470 btrfs_try_granting_tickets(fs_info, space_info);
1471 spin_unlock(&space_info->lock);
1475 struct btrfs_space_info *space_info,
1482 spin_lock(&space_info->lock);
1492 * (bytes_may_use counter of our space_info).
1494 remove_ticket(space_info, ticket);
1498 spin_unlock(&space_info->lock);
1503 spin_lock(&space_info->lock);
1505 spin_unlock(&space_info->lock);
1512 * @space_info: space info for the reservation
1522 struct btrfs_space_info *space_info,
1533 wait_reserve_ticket(fs_info, space_info, ticket);
1536 priority_reclaim_metadata_space(fs_info, space_info, ticket,
1541 priority_reclaim_metadata_space(fs_info, space_info, ticket,
1546 priority_reclaim_data_space(fs_info, space_info, ticket);
1562 trace_btrfs_reserve_ticket(fs_info, space_info->flags, orig_bytes,
1578 struct btrfs_space_info *space_info)
1592 space_info->clamp = min(space_info->clamp + 1, 8);
1615 * @space_info: space info we want to allocate from
1627 struct btrfs_space_info *space_info, u64 orig_bytes,
1656 spin_lock(&space_info->lock);
1657 used = btrfs_space_info_used(space_info, true);
1665 pending_tickets = !list_empty(&space_info->tickets) ||
1666 !list_empty(&space_info->priority_tickets);
1668 pending_tickets = !list_empty(&space_info->priority_tickets);
1675 ((used + orig_bytes <= space_info->total_bytes) ||
1676 btrfs_can_overcommit(fs_info, space_info, orig_bytes, flush))) {
1677 btrfs_space_info_update_bytes_may_use(fs_info, space_info,
1688 used = btrfs_space_info_used(space_info, false);
1689 if (used + orig_bytes <= space_info->total_bytes) {
1690 btrfs_space_info_update_bytes_may_use(fs_info, space_info,
1706 space_info->reclaim_size += ticket.bytes;
1715 list_add_tail(&ticket.list, &space_info->tickets);
1716 if (!space_info->flush) {
1724 maybe_clamp_preempt(fs_info, space_info);
1726 space_info->flush = 1;
1728 space_info->flags,
1735 &space_info->priority_tickets);
1737 } else if (!ret && space_info->flags & BTRFS_BLOCK_GROUP_METADATA) {
1745 need_preemptive_reclaim(fs_info, space_info)) {
1746 trace_btrfs_trigger_flush(fs_info, space_info->flags,
1752 spin_unlock(&space_info->lock);
1756 return handle_reserve_ticket(fs_info, space_info, &ticket, start_ns,
1764 * @space_info: the space_info we're allocating for
1776 struct btrfs_space_info *space_info,
1782 ret = __reserve_bytes(fs_info, space_info, orig_bytes, flush);
1784 trace_btrfs_space_reservation(fs_info, "space_info:enospc",
1785 space_info->flags, orig_bytes, 1);
1788 btrfs_dump_space_info(fs_info, space_info, orig_bytes, 0);
1816 trace_btrfs_space_reservation(fs_info, "space_info:enospc",
1827 struct btrfs_space_info *space_info;
1830 list_for_each_entry(space_info, &fs_info->space_info, list) {
1831 spin_lock(&space_info->lock);
1832 __btrfs_dump_space_info(fs_info, space_info);
1833 spin_unlock(&space_info->lock);
1839 * Account the unused space of all the readonly block group in the space_info.