Lines Matching refs:space_info
22 * 1) space_info. This is the ultimate arbiter of how much space we can use.
25 * reservations we care about total_bytes - SUM(space_info->bytes_) when
26 * determining if there is space to make an allocation. There is a space_info
32 * much space is accounted for in space_info->bytes_may_use.
38 * values to adjust the space_info counters.
47 * space_info->bytes_may_reserve += num_bytes
51 * space_info->bytes_may_reserve -= num_bytes
52 * space_info->bytes_reserved += extent_bytes
56 * space_info->bytes_reserved -= extent_bytes
57 * space_info->bytes_used += extent_bytes
66 * the tail of space_info->tickets, kick async flush thread
77 * space_info->bytes_may_use, ->bytes_pinned, etc, or adds to the
78 * space_info->total_bytes. This loops through the ->priority_tickets and
80 * completed. If it can the space is added to space_info->bytes_may_use and
91 * space_info->priority_tickets, and we do not use ticket->wait, we simply
175 struct list_head *head = &info->space_info;
185 struct btrfs_space_info *space_info;
189 space_info = kzalloc(sizeof(*space_info), GFP_NOFS);
190 if (!space_info)
193 ret = percpu_counter_init(&space_info->total_bytes_pinned, 0,
196 kfree(space_info);
201 INIT_LIST_HEAD(&space_info->block_groups[i]);
202 init_rwsem(&space_info->groups_sem);
203 spin_lock_init(&space_info->lock);
204 space_info->flags = flags & BTRFS_BLOCK_GROUP_TYPE_MASK;
205 space_info->force_alloc = CHUNK_ALLOC_NO_FORCE;
206 INIT_LIST_HEAD(&space_info->ro_bgs);
207 INIT_LIST_HEAD(&space_info->tickets);
208 INIT_LIST_HEAD(&space_info->priority_tickets);
210 ret = btrfs_sysfs_add_space_info_type(info, space_info);
214 list_add(&space_info->list, &info->space_info);
216 info->data_sinfo = space_info;
261 struct btrfs_space_info **space_info)
280 *space_info = found;
286 struct list_head *head = &info->space_info;
299 struct btrfs_space_info *space_info,
306 if (space_info->flags & BTRFS_BLOCK_GROUP_SYSTEM)
335 struct btrfs_space_info *space_info, u64 bytes,
342 if (space_info->flags & BTRFS_BLOCK_GROUP_DATA)
345 used = btrfs_space_info_used(space_info, true);
346 avail = calc_available_free_space(fs_info, space_info, flush);
348 if (used + bytes < space_info->total_bytes + avail)
353 static void remove_ticket(struct btrfs_space_info *space_info,
358 ASSERT(space_info->reclaim_size >= ticket->bytes);
359 space_info->reclaim_size -= ticket->bytes;
364 * This is for space we already have accounted in space_info->bytes_may_use, so
368 struct btrfs_space_info *space_info)
373 lockdep_assert_held(&space_info->lock);
375 head = &space_info->priority_tickets;
379 u64 used = btrfs_space_info_used(space_info, true);
384 if ((used + ticket->bytes <= space_info->total_bytes) ||
385 btrfs_can_overcommit(fs_info, space_info, ticket->bytes,
388 space_info,
390 remove_ticket(space_info, ticket);
392 space_info->tickets_id++;
399 if (head == &space_info->priority_tickets) {
400 head = &space_info->tickets;
421 btrfs_info(fs_info, "space_info %llu has %lld free, is %sfull",
426 "space_info total=%llu, used=%llu, pinned=%llu, reserved=%llu, may_use=%llu, readonly=%llu",
488 struct btrfs_space_info *space_info,
549 spin_lock(&space_info->lock);
550 if (list_empty(&space_info->tickets) &&
551 list_empty(&space_info->priority_tickets)) {
552 spin_unlock(&space_info->lock);
555 spin_unlock(&space_info->lock);
574 struct btrfs_space_info *space_info)
589 spin_lock(&space_info->lock);
590 cur_free_bytes = btrfs_space_info_used(space_info, true);
591 if (cur_free_bytes < space_info->total_bytes)
592 cur_free_bytes = space_info->total_bytes - cur_free_bytes;
596 if (!list_empty(&space_info->priority_tickets))
597 ticket = list_first_entry(&space_info->priority_tickets,
599 else if (!list_empty(&space_info->tickets))
600 ticket = list_first_entry(&space_info->tickets,
609 spin_unlock(&space_info->lock);
624 __percpu_counter_compare(&space_info->total_bytes_pinned,
631 * reservation. If the space_info's don't match (like for DATA or
635 if (space_info != delayed_rsv->space_info)
654 if (__percpu_counter_compare(&space_info->total_bytes_pinned,
669 * state of @space_info to detect the outcome.
672 struct btrfs_space_info *space_info, u64 num_bytes,
698 shrink_delalloc(fs_info, space_info, num_bytes,
723 btrfs_get_alloc_profile(fs_info, space_info->flags),
740 ret = may_commit_transaction(fs_info, space_info);
747 trace_btrfs_flush_space(fs_info, space_info->flags, num_bytes, state,
754 struct btrfs_space_info *space_info)
759 u64 to_reclaim = space_info->reclaim_size;
761 lockdep_assert_held(&space_info->lock);
763 avail = calc_available_free_space(fs_info, space_info,
765 used = btrfs_space_info_used(space_info, true);
773 if (space_info->total_bytes + avail < used)
774 to_reclaim += used - (space_info->total_bytes + avail);
780 if (btrfs_can_overcommit(fs_info, space_info, to_reclaim,
784 used = btrfs_space_info_used(space_info, true);
786 if (btrfs_can_overcommit(fs_info, space_info, SZ_1M,
788 expected = div_factor_fine(space_info->total_bytes, 95);
790 expected = div_factor_fine(space_info->total_bytes, 90);
796 to_reclaim = min(to_reclaim, space_info->bytes_may_use +
797 space_info->bytes_reserved);
802 struct btrfs_space_info *space_info,
805 u64 thresh = div_factor_fine(space_info->total_bytes, 98);
808 if ((space_info->bytes_used + space_info->bytes_reserved) >= thresh)
811 if (!btrfs_calc_reclaim_metadata_size(fs_info, space_info))
819 struct btrfs_space_info *space_info,
825 if (global_rsv->space_info != space_info)
835 remove_ticket(space_info, ticket);
838 space_info->tickets_id++;
849 * @space_info - the space info we were flushing
862 struct btrfs_space_info *space_info)
865 u64 tickets_id = space_info->tickets_id;
870 __btrfs_dump_space_info(fs_info, space_info);
873 while (!list_empty(&space_info->tickets) &&
874 tickets_id == space_info->tickets_id) {
875 ticket = list_first_entry(&space_info->tickets,
879 steal_from_global_rsv(fs_info, space_info, ticket))
901 remove_ticket(space_info, ticket);
911 btrfs_try_granting_tickets(fs_info, space_info);
913 return (tickets_id != space_info->tickets_id);
924 struct btrfs_space_info *space_info;
931 space_info = btrfs_find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
933 spin_lock(&space_info->lock);
934 to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info, space_info);
936 space_info->flush = 0;
937 spin_unlock(&space_info->lock);
940 last_tickets_id = space_info->tickets_id;
941 spin_unlock(&space_info->lock);
945 flush_space(fs_info, space_info, to_reclaim, flush_state);
946 spin_lock(&space_info->lock);
947 if (list_empty(&space_info->tickets)) {
948 space_info->flush = 0;
949 spin_unlock(&space_info->lock);
953 space_info);
954 if (last_tickets_id == space_info->tickets_id) {
957 last_tickets_id = space_info->tickets_id;
979 if (maybe_fail_all_tickets(fs_info, space_info)) {
983 space_info->flush = 0;
989 spin_unlock(&space_info->lock);
1056 struct btrfs_space_info *space_info;
1061 space_info = fs_info->data_sinfo;
1063 spin_lock(&space_info->lock);
1064 if (list_empty(&space_info->tickets)) {
1065 space_info->flush = 0;
1066 spin_unlock(&space_info->lock);
1069 last_tickets_id = space_info->tickets_id;
1070 spin_unlock(&space_info->lock);
1072 while (!space_info->full) {
1073 flush_space(fs_info, space_info, U64_MAX, ALLOC_CHUNK_FORCE);
1074 spin_lock(&space_info->lock);
1075 if (list_empty(&space_info->tickets)) {
1076 space_info->flush = 0;
1077 spin_unlock(&space_info->lock);
1080 last_tickets_id = space_info->tickets_id;
1081 spin_unlock(&space_info->lock);
1085 flush_space(fs_info, space_info, U64_MAX,
1087 spin_lock(&space_info->lock);
1088 if (list_empty(&space_info->tickets)) {
1089 space_info->flush = 0;
1090 spin_unlock(&space_info->lock);
1094 if (last_tickets_id == space_info->tickets_id) {
1097 last_tickets_id = space_info->tickets_id;
1102 if (space_info->full) {
1103 if (maybe_fail_all_tickets(fs_info, space_info))
1106 space_info->flush = 0;
1111 spin_unlock(&space_info->lock);
1139 struct btrfs_space_info *space_info,
1147 spin_lock(&space_info->lock);
1148 to_reclaim = btrfs_calc_reclaim_metadata_size(fs_info, space_info);
1150 spin_unlock(&space_info->lock);
1153 spin_unlock(&space_info->lock);
1157 flush_space(fs_info, space_info, to_reclaim, states[flush_state]);
1159 spin_lock(&space_info->lock);
1161 spin_unlock(&space_info->lock);
1164 spin_unlock(&space_info->lock);
1169 struct btrfs_space_info *space_info,
1172 while (!space_info->full) {
1173 flush_space(fs_info, space_info, U64_MAX, ALLOC_CHUNK_FORCE);
1174 spin_lock(&space_info->lock);
1176 spin_unlock(&space_info->lock);
1179 spin_unlock(&space_info->lock);
1184 struct btrfs_space_info *space_info,
1191 spin_lock(&space_info->lock);
1201 * (bytes_may_use counter of our space_info).
1203 remove_ticket(space_info, ticket);
1207 spin_unlock(&space_info->lock);
1212 spin_lock(&space_info->lock);
1214 spin_unlock(&space_info->lock);
1220 * @space_info - the space_info for the reservation
1228 struct btrfs_space_info *space_info,
1238 wait_reserve_ticket(fs_info, space_info, ticket);
1241 priority_reclaim_metadata_space(fs_info, space_info, ticket,
1246 priority_reclaim_metadata_space(fs_info, space_info, ticket,
1251 priority_reclaim_data_space(fs_info, space_info, ticket);
1258 spin_lock(&space_info->lock);
1269 remove_ticket(space_info, ticket);
1270 btrfs_try_granting_tickets(fs_info, space_info);
1276 spin_unlock(&space_info->lock);
1301 * @space_info - the space info we want to allocate from
1313 struct btrfs_space_info *space_info, u64 orig_bytes,
1330 spin_lock(&space_info->lock);
1332 used = btrfs_space_info_used(space_info, true);
1340 pending_tickets = !list_empty(&space_info->tickets) ||
1341 !list_empty(&space_info->priority_tickets);
1343 pending_tickets = !list_empty(&space_info->priority_tickets);
1350 ((used + orig_bytes <= space_info->total_bytes) ||
1351 btrfs_can_overcommit(fs_info, space_info, orig_bytes, flush))) {
1352 btrfs_space_info_update_bytes_may_use(fs_info, space_info,
1367 space_info->reclaim_size += ticket.bytes;
1373 list_add_tail(&ticket.list, &space_info->tickets);
1374 if (!space_info->flush) {
1375 space_info->flush = 1;
1377 space_info->flags,
1384 &space_info->priority_tickets);
1386 } else if (!ret && space_info->flags & BTRFS_BLOCK_GROUP_METADATA) {
1394 need_do_async_reclaim(fs_info, space_info, used) &&
1396 trace_btrfs_trigger_flush(fs_info, space_info->flags,
1402 spin_unlock(&space_info->lock);
1406 return handle_reserve_ticket(fs_info, space_info, &ticket, flush);
1432 ret = __reserve_bytes(fs_info, block_rsv->space_info, orig_bytes, flush);
1440 trace_btrfs_space_reservation(fs_info, "space_info:enospc",
1441 block_rsv->space_info->flags,
1445 btrfs_dump_space_info(fs_info, block_rsv->space_info,
1472 trace_btrfs_space_reservation(fs_info, "space_info:enospc",