btrfs: move the space_info code out of extent-tree.c
cover btrfs: move the space_info code out of extent-tree.c
This is the first pass at making extent-tree.c much smaller. I've purposefully done no other cleanups or changes. The places where I needed to modify callers were done in separate patches. The only time I moved and changed callers in large chunks was the moving of reserve_metadata_bytes out of extent-tree.c, and that was just to rename the users of reserve_metadata_bytes to btrfs_reserve_metadata_bytes.
There is 0 functional change in this series. The next step is to move the other space reservation code that is specific to delayed_refs, inodes, etc. But I wanted to start with this to make sure we're all onboard with this approach before I do other things.
The diffstat for the whole series is the following
fs/btrfs/Makefile | 2 +- fs/btrfs/ctree.h | 97 +--- fs/btrfs/extent-tree.c | 1277 +++---------------------------------------- fs/btrfs/free-space-cache.c | 1 + fs/btrfs/ioctl.c | 1 + fs/btrfs/space-info.c | 1103 +++++++++++++++++++++++++++++++++++++ fs/btrfs/space-info.h | 135 +++++ fs/btrfs/super.c | 1 + fs/btrfs/sysfs.c | 1 + fs/btrfs/volumes.c | 1 + 10 files changed, 1343 insertions(+), 1276 deletions(-)
Thanks,
Josef
PATCH 1/11 btrfs: move space_info to space_info.h
Migrate the struct definition and the one helper that's in ctree.h into space_info.h
--- fs/btrfs/ctree.h | 73 +--------------------------------------- fs/btrfs/extent-tree.c | 1 + fs/btrfs/free-space-cache.c | 1 + fs/btrfs/ioctl.c | 1 + fs/btrfs/space-info.h | 81 +++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/super.c | 1 + fs/btrfs/sysfs.c | 1 + fs/btrfs/volumes.c | 1 + 8 files changed, 88 insertions(+), 72 deletions(-) create mode 100644 fs/btrfs/space-info.h
fs/btrfs/ctree.h +1 -72
@@ -37,6 +37,7 @@ struct btrfs_trans_handle;struct btrfs_transaction ;struct btrfs_pending_snapshot ;struct btrfs_delayed_ref_root ; +struct btrfs_space_info ;extern struct kmem_cache *btrfs_trans_handle_cachep;extern struct kmem_cache *btrfs_bit_radix_cachep;extern struct kmem_cache *btrfs_path_cachep;
@@ -393,72 +394,6 @@ struct raid_kobject {struct list_head list; }; -struct btrfs_space_info { -spinlock_t lock; - -u64 total_bytes;/* total bytes in the space, -this doesn't take mirrors into account */ -u64 bytes_used;/* total bytes used, -this doesn't take mirrors into account */ -u64 bytes_pinned;/* total bytes pinned, will be freed when the -transaction finishes */ -u64 bytes_reserved;/* total bytes the allocator has reserved for -current allocations */ -u64 bytes_may_use;/* number of bytes that may be used for -delalloc/allocations */ -u64 bytes_readonly;/* total bytes that are read only */ - -u64 max_extent_size;/* This will hold the maximum extent size of -the space info if we had an ENOSPC in the -allocator. */ - -unsigned int full:1 ;/* indicates that we cannot allocate any more -chunks for this space */ -unsigned int chunk_alloc:1 ;/* set if we are allocating a chunk */ - -unsigned int flush:1 ;/* set if we are trying to make space */ - -unsigned int force_alloc;/* set if we need to force a chunk -alloc for this space */ - -u64 disk_used;/* total bytes used on disk */ -u64 disk_total;/* total bytes on disk, takes mirrors into -account */ - -u64 flags; - -/* -* bytes_pinned is kept in line with what is actually pinned, as in -* we've called update_block_group and dropped the bytes_used counter -* and increased the bytes_pinned counter. However this means that -* bytes_pinned does not reflect the bytes that will be pinned once the -* delayed refs are flushed, so this counter is inc'ed every time we -* call btrfs_free_extent so it is a realtime count of what will be -* freed once the transaction is committed. It will be zeroed every -* time the transaction commits. -*/ -struct percpu_counter total_bytes_pinned; - -struct list_head list; -/* Protected by the spinlock 'lock'. */ -struct list_head ro_bgs; -struct list_head priority_tickets; -struct list_head tickets; -/* -* tickets_id just indicates the next ticket will be handled, so note -* it's not stored per ticket. -*/ -u64 tickets_id; - -struct rw_semaphore groups_sem; -/* for block groups in our same type */ -struct list_head block_groups[BTRFS_NR_RAID_TYPES ]; -wait_queue_head_t wait; - -struct kobject kobj; -struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES ]; -}; -/* * Types of block reserves */
@@ -2677,12 +2612,6 @@ static inline u64 btrfs_extref_hash(u64 parent_objectid, const char *name,return (u64 )crc32c (parent_objectid, name, len); } -static inline bool btrfs_mixed_space_info (struct btrfs_space_info *space_info) -{ -return ((space_info->flags &BTRFS_BLOCK_GROUP_METADATA ) && - (space_info->flags &BTRFS_BLOCK_GROUP_DATA )); -} -static inline gfp_t btrfs_alloc_write_mask (struct address_space *mapping) {return mapping_gfp_constraint (mapping, ~__GFP_FS);
fs/btrfs/extent-tree.c +1 -0
@@ -28,6 +28,7 @@#include "sysfs.h" #include "qgroup.h" #include "ref-verify.h" +#include "space-info.h" #undef SCRAMBLE_DELAYED_REFS
fs/btrfs/free-space-cache.c +1 -0
@@ -18,6 +18,7 @@#include "extent_io.h" #include "inode-map.h" #include "volumes.h" +#include "space-info.h" #define BITS_PER_BITMAP (PAGE_SIZE * 8UL)#define MAX_CACHE_BYTES_PER_GIG SZ_32K
fs/btrfs/ioctl.c +1 -0
@@ -43,6 +43,7 @@#include "qgroup.h" #include "tree-log.h" #include "compression.h" +#include "space-info.h" #ifdef CONFIG_64BIT /* If we have a 32-bit userspace and 64-bit kernel, then the UAPI
fs/btrfs/space-info.h new file +81 -0
81 lines not on this page · raw message
fs/btrfs/super.c +1 -0
@@ -42,6 +42,7 @@#include "dev-replace.h" #include "free-space-cache.h" #include "backref.h" +#include "space-info.h" #include "tests/btrfs-tests.h" #include "qgroup.h"
fs/btrfs/sysfs.c +1 -0
@@ -16,6 +16,7 @@#include "transaction.h" #include "sysfs.h" #include "volumes.h" +#include "space-info.h" static inline struct btrfs_fs_info *to_fs_info (struct kobject *kobj);static inline struct btrfs_fs_devices *to_fs_devs (struct kobject *kobj);
fs/btrfs/volumes.c +1 -0
@@ -28,6 +28,7 @@#include "dev-replace.h" #include "sysfs.h" #include "tree-checker.h" +#include "space-info.h" const struct btrfs_raid_attr btrfs_raid_array[BTRFS_NR_RAID_TYPES ] = { [BTRFS_RAID_RAID10 ] = {
Signature · 1 line
2.14.3
PATCH 2/11 btrfs: rename do_chunk_alloc to btrfs_chunk_alloc
In reply to Josef BacikReally we just need the enum, but as we break more things up it'll help to have this external to extent-tree.c.
--- fs/btrfs/ctree.h | 22 ++++++++++++++++++++++ fs/btrfs/extent-tree.c | 50 ++++++++++++++------------------------------------ 2 files changed, 36 insertions(+), 36 deletions(-)
fs/btrfs/ctree.h +22 -0
@@ -2764,6 +2764,28 @@ enum btrfs_flush_state { COMMIT_TRANS = 9, }; +/* +* control flags for do_chunk_alloc's force field +* CHUNK_ALLOC_NO_FORCE means to only allocate a chunk +* if we really need one. +* +* CHUNK_ALLOC_LIMITED means to only try and allocate one +* if we have very few chunks already allocated. This is +* used as part of the clustering code to help make sure +* we have a good pool of storage to cluster in, without +* filling the FS with empty chunks +* +* CHUNK_ALLOC_FORCE means it must try to allocate one +* +*/ +enum btrfs_chunk_alloc_enum { +CHUNK_ALLOC_NO_FORCE =0 , +CHUNK_ALLOC_LIMITED =1 , +CHUNK_ALLOC_FORCE =2 , +}; + +int btrfs_chunk_alloc (struct btrfs_trans_handle *trans,u64 flags, +enum btrfs_chunk_alloc_enum force);int btrfs_alloc_data_chunk_ondemand (struct btrfs_inode *inode,u64 bytes);int btrfs_check_data_free_space (struct inode *inode,struct extent_changeset **reserved,u64 start,u64 len);
fs/btrfs/extent-tree.c +14 -36
104 lines not on this page · raw message
Signature · 1 line
2.14.3
PATCH 3/11 btrfs: export space_info_add_*_bytes
In reply to Josef BacikPrep work for consolidating all of the space_info code into one file. We need to export these so multiple files can use them.
--- fs/btrfs/extent-tree.c | 42 ++++++++++++++++++++---------------------- fs/btrfs/space-info.h | 6 ++++++ 2 files changed, 26 insertions(+), 22 deletions(-)
fs/btrfs/extent-tree.c +20 -22
@@ -75,12 +75,6 @@ static void dump_space_info(struct btrfs_fs_info *fs_info, int dump_block_groups);static int block_rsv_use_bytes (struct btrfs_block_rsv *block_rsv,u64 num_bytes); -static void space_info_add_new_bytes (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info, -u64 num_bytes); -static void space_info_add_old_bytes (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info, -u64 num_bytes); static noinline intblock_group_cache_done (struct btrfs_block_group_cache *cache)
@@ -3908,8 +3902,8 @@ static void update_space_info(struct btrfs_fs_info *info, u64 flags, found->bytes_readonly += bytes_readonly;if (total_bytes >0 ) found->full =0 ; -space_info_add_new_bytes (info, found, total_bytes - - bytes_used - bytes_readonly); +btrfs_space_info_add_new_bytes (info, found, total_bytes - + bytes_used - bytes_readonly);spin_unlock (&found->lock); *space_info = found; }
@@ -5110,7 +5104,8 @@ static int wait_reserve_ticket(struct btrfs_fs_info *fs_info,spin_unlock (&space_info->lock);if (reclaim_bytes) -space_info_add_old_bytes (fs_info, space_info, reclaim_bytes); +btrfs_space_info_add_old_bytes (fs_info, space_info, + reclaim_bytes);return ret; }
@@ -5227,7 +5222,8 @@ static int __reserve_metadata_bytes(struct btrfs_fs_info *fs_info,spin_unlock (&space_info->lock);if (reclaim_bytes) -space_info_add_old_bytes (fs_info, space_info, reclaim_bytes); +btrfs_space_info_add_old_bytes (fs_info, space_info, + reclaim_bytes);ASSERT (list_empty (&ticket.list));return ret; }
@@ -5393,8 +5389,9 @@ void btrfs_migrate_to_delayed_refs_rsv(struct btrfs_fs_info *fs_info,trace_btrfs_space_reservation (fs_info,"delayed_refs_rsv" ,0 , num_bytes,1 );if (to_free) -space_info_add_old_bytes (fs_info, delayed_refs_rsv->space_info, - to_free); +btrfs_space_info_add_old_bytes (fs_info, + delayed_refs_rsv->space_info, + to_free); }/**
@@ -5437,9 +5434,9 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,* This is for space we already have accounted in space_info->bytes_may_use, so * basically when we're returning space from block_rsv's. */ -static void space_info_add_old_bytes (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info, -u64 num_bytes) +void btrfs_space_info_add_old_bytes (struct btrfs_fs_info *fs_info, +struct btrfs_space_info *space_info, +u64 num_bytes) {struct reserve_ticket *ticket;struct list_head *head;
@@ -5497,9 +5494,9 @@ static void space_info_add_old_bytes(struct btrfs_fs_info *fs_info,* space_info->bytes_may_use yet. So if we allocate a chunk or unpin an extent * we use this helper. */ -static void space_info_add_new_bytes (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info, -u64 num_bytes) +void btrfs_space_info_add_new_bytes (struct btrfs_fs_info *fs_info, +struct btrfs_space_info *space_info, +u64 num_bytes) {struct reserve_ticket *ticket;struct list_head *head = &space_info->priority_tickets;
@@ -5583,8 +5580,8 @@ static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info,spin_unlock (&dest->lock); }if (num_bytes) -space_info_add_old_bytes (fs_info, space_info, - num_bytes); +btrfs_space_info_add_old_bytes (fs_info, space_info, + num_bytes); }if (qgroup_to_release_ret) *qgroup_to_release_ret = qgroup_to_release;
@@ -6760,8 +6757,9 @@ static int unpin_extent_range(struct btrfs_fs_info *fs_info,spin_unlock (&global_rsv->lock);/* Add to any tickets we may have */ if (len) -space_info_add_new_bytes (fs_info, space_info, - len); +btrfs_space_info_add_new_bytes (fs_info, + space_info, + len); }spin_unlock (&space_info->lock); }
fs/btrfs/space-info.h +6 -0
@@ -78,4 +78,10 @@ static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info) (space_info->flags & BTRFS_BLOCK_GROUP_DATA)); } +void btrfs_space_info_add_new_bytes (struct btrfs_fs_info *fs_info, +struct btrfs_space_info *space_info, +u64 num_bytes); +void btrfs_space_info_add_old_bytes (struct btrfs_fs_info *fs_info, +struct btrfs_space_info *space_info, +u64 num_bytes);#endif /* BTRFS_SPACE_INFO_H */
Signature · 1 line
2.14.3
PATCH 4/11 btrfs: move the space_info handling code to space-info.c
In reply to Josef BacikThese are the basic init and lookup functions and some helper functions, fairly straightforward before the bad stuff starts.
--- fs/btrfs/Makefile | 2 +- fs/btrfs/extent-tree.c | 205 +++++-------------------------------------------- fs/btrfs/space-info.c | 177 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/space-info.h | 11 +++ 4 files changed, 208 insertions(+), 187 deletions(-) create mode 100644 fs/btrfs/space-info.c
fs/btrfs/Makefile +1 -1
@@ -10,7 +10,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \ export.o tree-log.o free-space-cache.o zlib.o lzo.o zstd.o \ compression.o delayed-ref.o relocation.o delayed-inode.o scrub.o \ reada.o backref.o ulist.o qgroup.o send.o dev-replace.o raid56.o \ - uuid-tree.o props.o free-space-tree.o tree-checker.o + uuid-tree.o props.o free-space-tree.o tree-checker.o space-info.o btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o
fs/btrfs/extent-tree.c +19 -186
332 lines not on this page · raw message
fs/btrfs/space-info.c new file +177 -0
177 lines not on this page · raw message
fs/btrfs/space-info.h +11 -0
@@ -84,4 +84,15 @@ void btrfs_space_info_add_new_bytes(struct btrfs_fs_info *fs_info,void btrfs_space_info_add_old_bytes (struct btrfs_fs_info *fs_info,struct btrfs_space_info *space_info,u64 num_bytes); +int btrfs_init_space_info (struct btrfs_fs_info *fs_info); +void btrfs_update_space_info (struct btrfs_fs_info *info,u64 flags, +u64 total_bytes,u64 bytes_used, +u64 bytes_readonly, +struct btrfs_space_info **space_info); +struct btrfs_space_info *btrfs_find_space_info (struct btrfs_fs_info *info, +u64 flags); +u64 btrfs_space_info_used (struct btrfs_space_info *s_info, +bool may_use_included); +void btrfs_clear_space_info_full (struct btrfs_fs_info *info); +#endif /* BTRFS_SPACE_INFO_H */
Signature · 1 line
2.14.3
Re: [PATCH 04/11] btrfs: move the space_info handling code to space-info.c
fs/btrfs/space-info.c line 4
Quoted 7 lines · Josef Bacik
fs/btrfs/space-info.c new file +4
-0@@ -0,0 +1,177 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2019 Facebook. All rights reserved. +*/
How does the copyright claim work here? You're just moving code from a file (extent-tree.c) that has
"Copyright (C) 2007 Oracle. All rights reserved."
Adding company copyright to new files that implement something completely new seems to be fine and I don't object against adding it, though personally I think it's pointless to add the copyrights when there's the Signed-off-by mechanism and full and immutable history of changes tracked in git and newly the SPDX tag to disperse any confusion about licensing of individual files.
Re: [PATCH 04/11] btrfs: move the space_info handling code to space-info.c
Quoted 12 lines · David Sterba
fs/btrfs/space-info.c line 4
Quoted 7 lines · Josef Bacik
fs/btrfs/space-info.c new file +4
-0@@ -0,0 +1,177 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2019 Facebook. All rights reserved. +*/ How does the copyright claim work here? You're just moving code from a file (
extent-tree.c) that has
Quoted 9 lines
"Copyright (C) 2007 Oracle. All rights reserved."
Adding company copyright to new files that implement something completely new seems to be fine and I don't object against adding it, though personally I think it's pointless to add the copyrights when there's the Signed-off-by mechanism and full and immutable history of changes tracked in git and newly the SPDX tag to disperse any confusion about licensing of individual files.
Yeah I agree, fix it however you like, the signed-off chain seems to be what's important. Thanks,
Josef
Re: [PATCH 04/11] btrfs: move the space_info handling code to space-info.c
Quoted 23 lines · Josef Bacik
Quoted 12 lines · David Sterba
fs/btrfs/space-info.c line 4
Quoted 7 lines · Josef Bacik
fs/btrfs/space-info.c new file +4
-0@@ -0,0 +1,177 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2019 Facebook. All rights reserved. +*/ How does the copyright claim work here? You're just moving code from a file (
extent-tree.c) that hasQuoted 9 lines
"Copyright (C) 2007 Oracle. All rights reserved."
Adding company copyright to new files that implement something completely new seems to be fine and I don't object against adding it, though personally I think it's pointless to add the copyrights when there's the Signed-off-by mechanism and full and immutable history of changes tracked in git and newly the SPDX tag to disperse any confusion about licensing of individual files.
Quoted 2 lines
Yeah I agree, fix it however you like, the signed-off chain seems to be what's important. Thanks,
Thanks, I've summarized that on wiki so we can point to that when needed.
https://btrfs.wiki.kernel.org/index.php/Developer%27s_FAQ#Copyright_notices_in_files
PATCH 5/11 btrfs: move and export can_overcommit
In reply to Josef BacikThis is the first piece of moving the space reservation code to space-info.c
--- fs/btrfs/extent-tree.c | 83 +++++--------------------------------------------- fs/btrfs/space-info.c | 68 +++++++++++++++++++++++++++++++++++++++++ fs/btrfs/space-info.h | 4 +++ 3 files changed, 80 insertions(+), 75 deletions(-)
fs/btrfs/extent-tree.c +8 -75
@@ -4147,11 +4147,6 @@ static void force_metadata_allocation(struct btrfs_fs_info *info)rcu_read_unlock (); } -static inline u64 calc_global_rsv_need_space (struct btrfs_block_rsv *global) -{ -return (global->size <<1 ); -} -static int should_alloc_chunk (struct btrfs_fs_info *fs_info,struct btrfs_space_info *sinfo,int force) {
@@ -4378,69 +4373,6 @@ int btrfs_chunk_alloc(struct btrfs_trans_handle *trans, u64 flags,return ret; } -static int can_overcommit (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info,u64 bytes, -enum btrfs_reserve_flush_enum flush, -bool system_chunk) -{ -struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; -u64 profile; -u64 space_size; -u64 avail; -u64 used; -int factor; - -/* Don't overcommit when in mixed mode. */ -if (space_info->flags &BTRFS_BLOCK_GROUP_DATA ) -return 0 ; - -if (system_chunk) - profile =btrfs_system_alloc_profile (fs_info); -else - profile =btrfs_metadata_alloc_profile (fs_info); - - used =btrfs_space_info_used (space_info, false); - -/* -* We only want to allow over committing if we have lots of actual space -* free, but if we don't have enough space to handle the global reserve -* space then we could end up having a real enospc problem when trying -* to allocate a chunk or some other such important allocation. -*/ -spin_lock (&global_rsv->lock); - space_size =calc_global_rsv_need_space (global_rsv); -spin_unlock (&global_rsv->lock); -if (used + space_size >= space_info->total_bytes) -return 0 ; - - used += space_info->bytes_may_use; - - avail =atomic64_read (&fs_info->free_chunk_space); - -/* -* If we have dup, raid1 or raid10 then only half of the free -* space is actually usable. For raid56, the space info used -* doesn't include the parity drive, so we don't have to -* change the math -*/ - factor =btrfs_bg_type_to_factor (profile); - avail =div_u64 (avail, factor); - -/* -* If we aren't flushing all things, let us overcommit up to -* 1/2th of the space. If we can flush, don't let us overcommit -* too much, let it overcommit up to 1/8 of the space. -*/ -if (flush ==BTRFS_RESERVE_FLUSH_ALL ) - avail >>=3 ; -else - avail >>=1 ; - -if (used + bytes < space_info->total_bytes + avail) -return 1 ; -return 0 ; -} -static void btrfs_writeback_inodes_sb_nr (struct btrfs_fs_info *fs_info,unsigned long nr_pages,int nr_items) {
@@ -4768,14 +4700,14 @@ btrfs_calc_reclaim_metadata_size(struct btrfs_fs_info *fs_info,return to_reclaim; to_reclaim =min_t (u64,num_online_cpus () *SZ_1M ,SZ_16M ); -if (can_overcommit (fs_info, space_info, to_reclaim, -BTRFS_RESERVE_FLUSH_ALL , system_chunk)) +if (btrfs_can_overcommit (fs_info, space_info, to_reclaim, +BTRFS_RESERVE_FLUSH_ALL , system_chunk))return 0 ; used =btrfs_space_info_used (space_info, true); -if (can_overcommit (fs_info, space_info,SZ_1M , -BTRFS_RESERVE_FLUSH_ALL , system_chunk)) +if (btrfs_can_overcommit (fs_info, space_info,SZ_1M , +BTRFS_RESERVE_FLUSH_ALL , system_chunk)) expected =div_factor_fine (space_info->total_bytes,95 );else expected =div_factor_fine (space_info->total_bytes,90 );
@@ -5021,8 +4953,8 @@ static int __reserve_metadata_bytes(struct btrfs_fs_info *fs_info,trace_btrfs_space_reservation (fs_info,"space_info" , space_info->flags, orig_bytes,1 ); ret =0 ; - }else if (can_overcommit (fs_info, space_info, orig_bytes, flush, - system_chunk)) { + }else if (btrfs_can_overcommit (fs_info, space_info, orig_bytes, flush, + system_chunk)) {update_bytes_may_use (fs_info, space_info, orig_bytes);trace_btrfs_space_reservation (fs_info,"space_info" , space_info->flags, orig_bytes,1 );
@@ -5334,7 +5266,8 @@ void btrfs_space_info_add_old_bytes(struct btrfs_fs_info *fs_info,* adding the ticket space would be a double count. */ if (check_overcommit && - !can_overcommit (fs_info, space_info,0 , flush, false)) + !btrfs_can_overcommit (fs_info, space_info,0 , flush, + false))break ;if (num_bytes >= ticket->bytes) {list_del_init (&ticket->list);
fs/btrfs/space-info.c +68 -0
71 lines not on this page · raw message
fs/btrfs/space-info.h +4 -0
@@ -94,5 +94,9 @@ struct btrfs_space_info *btrfs_find_space_info(struct btrfs_fs_info *info,u64 btrfs_space_info_used (struct btrfs_space_info *s_info,bool may_use_included);void btrfs_clear_space_info_full (struct btrfs_fs_info *info); +int btrfs_can_overcommit (struct btrfs_fs_info *fs_info, +struct btrfs_space_info *space_info,u64 bytes, +enum btrfs_reserve_flush_enum flush, +bool system_chunk);#endif /* BTRFS_SPACE_INFO_H */
Signature · 1 line
2.14.3
PATCH 6/11 btrfs: move the space info update macro to space-info.h
In reply to Josef BacikAlso rename it to btrfs_space_info_update_* so it's clear what we're updating.
--- fs/btrfs/extent-tree.c | 68 +++++++++++++++++++++++--------------------------- fs/btrfs/space-info.h | 22 ++++++++++++++++ 2 files changed, 53 insertions(+), 37 deletions(-)
fs/btrfs/extent-tree.c +31 -37
@@ -32,26 +32,6 @@#undef SCRAMBLE_DELAYED_REFS -/* -* Declare a helper function to detect underflow of various space info members -*/ -#define DECLARE_SPACE_INFO_UPDATE (name) \ -static inline void update_##name(struct btrfs_fs_info *fs_info, \ - struct btrfs_space_info *sinfo, \ - s64 bytes) \ -{ \ - lockdep_assert_held(&sinfo->lock); \ - trace_update_##name(fs_info, sinfo, sinfo->name, bytes); \ - if (bytes < 0 && sinfo->name < -bytes) { \ - WARN_ON(1); \ - sinfo->name = 0; \ - return; \ - } \ - sinfo->name += bytes; \ -} - -DECLARE_SPACE_INFO_UPDATE (bytes_may_use); -DECLARE_SPACE_INFO_UPDATE (bytes_pinned); static int __btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_delayed_ref_node *node, u64 parent,
@@ -4054,7 +4034,7 @@ int btrfs_alloc_data_chunk_ondemand(struct btrfs_inode *inode, u64 bytes) data_sinfo->flags, bytes, 1);return -ENOSPC ; } -update_bytes_may_use (fs_info, data_sinfo, bytes); +btrfs_space_info_update_bytes_may_use (fs_info, data_sinfo, bytes);trace_btrfs_space_reservation (fs_info,"space_info" , data_sinfo->flags, bytes,1 );spin_unlock (&data_sinfo->lock);
@@ -4107,7 +4087,7 @@ void btrfs_free_reserved_data_space_noquota(struct inode *inode, u64 start, data_sinfo = fs_info->data_sinfo;spin_lock (&data_sinfo->lock); -update_bytes_may_use (fs_info, data_sinfo, -len); +btrfs_space_info_update_bytes_may_use (fs_info, data_sinfo, -len);trace_btrfs_space_reservation (fs_info,"space_info" , data_sinfo->flags, len,0 );spin_unlock (&data_sinfo->lock);
@@ -4949,13 +4929,15 @@ static int __reserve_metadata_bytes(struct btrfs_fs_info *fs_info,* If not things get more complicated. */ if (used + orig_bytes <= space_info->total_bytes) { -update_bytes_may_use (fs_info, space_info, orig_bytes); +btrfs_space_info_update_bytes_may_use (fs_info, space_info, + orig_bytes);trace_btrfs_space_reservation (fs_info,"space_info" , space_info->flags, orig_bytes,1 ); ret =0 ; }else if (btrfs_can_overcommit (fs_info, space_info, orig_bytes, flush, system_chunk)) { -update_bytes_may_use (fs_info, space_info, orig_bytes); +btrfs_space_info_update_bytes_may_use (fs_info, space_info, + orig_bytes);trace_btrfs_space_reservation (fs_info,"space_info" , space_info->flags, orig_bytes,1 ); ret =0 ;
@@ -5286,7 +5268,7 @@ void btrfs_space_info_add_old_bytes(struct btrfs_fs_info *fs_info, flush =BTRFS_RESERVE_FLUSH_ALL ; goto again; } -update_bytes_may_use (fs_info, space_info, -num_bytes); +btrfs_space_info_update_bytes_may_use (fs_info, space_info, -num_bytes);trace_btrfs_space_reservation (fs_info,"space_info" , space_info->flags, num_bytes,0 );spin_unlock (&space_info->lock);
@@ -5314,8 +5296,9 @@ void btrfs_space_info_add_new_bytes(struct btrfs_fs_info *fs_info, ticket->bytes, 1);list_del_init (&ticket->list); num_bytes -= ticket->bytes; -update_bytes_may_use (fs_info, space_info, - ticket->bytes); +btrfs_space_info_update_bytes_may_use (fs_info, + space_info, + ticket->bytes); ticket->bytes =0 ; space_info->tickets_id++;wake_up (&ticket->wait);
@@ -5323,7 +5306,9 @@ void btrfs_space_info_add_new_bytes(struct btrfs_fs_info *fs_info,trace_btrfs_space_reservation (fs_info,"space_info" , space_info->flags, num_bytes,1 ); -update_bytes_may_use (fs_info, space_info, num_bytes); +btrfs_space_info_update_bytes_may_use (fs_info, + space_info, + num_bytes); ticket->bytes -= num_bytes; num_bytes =0 ; }
@@ -5616,14 +5601,16 @@ static void update_global_block_rsv(struct btrfs_fs_info *fs_info) num_bytes =min (num_bytes, block_rsv->size - block_rsv->reserved); block_rsv->reserved += num_bytes; -update_bytes_may_use (fs_info, sinfo, num_bytes); +btrfs_space_info_update_bytes_may_use (fs_info, sinfo, + num_bytes);trace_btrfs_space_reservation (fs_info,"space_info" , sinfo->flags, num_bytes,1 ); } }else if (block_rsv->reserved > block_rsv->size) { num_bytes = block_rsv->reserved - block_rsv->size; -update_bytes_may_use (fs_info, sinfo, -num_bytes); +btrfs_space_info_update_bytes_may_use (fs_info, sinfo, + -num_bytes);trace_btrfs_space_reservation (fs_info,"space_info" , sinfo->flags, num_bytes,0 ); block_rsv->reserved = block_rsv->size;
@@ -6086,7 +6073,9 @@ static int update_block_group(struct btrfs_trans_handle *trans, old_val -= num_bytes;btrfs_set_block_group_used (&cache->item, old_val); cache->pinned += num_bytes; -update_bytes_pinned (info, cache->space_info, num_bytes); +btrfs_space_info_update_bytes_pinned (info, + cache->space_info, + num_bytes); cache->space_info->bytes_used -= num_bytes; cache->space_info->disk_used -= num_bytes * factor;spin_unlock (&cache->lock);
@@ -6161,7 +6150,8 @@ static int pin_down_extent(struct btrfs_block_group_cache *cache,spin_lock (&cache->space_info->lock);spin_lock (&cache->lock); cache->pinned += num_bytes; -update_bytes_pinned (fs_info, cache->space_info, num_bytes); +btrfs_space_info_update_bytes_pinned (fs_info, cache->space_info, + num_bytes);if (reserved) { cache->reserved -= num_bytes; cache->space_info->bytes_reserved -= num_bytes;
@@ -6370,7 +6360,8 @@ static int btrfs_add_reserved_bytes(struct btrfs_block_group_cache *cache, }else { cache->reserved += num_bytes; space_info->bytes_reserved += num_bytes; -update_bytes_may_use (cache->fs_info, space_info, -ram_bytes); +btrfs_space_info_update_bytes_may_use (cache->fs_info, + space_info, -ram_bytes);if (delalloc) cache->delalloc_bytes += num_bytes; }
@@ -6526,7 +6517,8 @@ static int unpin_extent_range(struct btrfs_fs_info *fs_info,spin_lock (&space_info->lock);spin_lock (&cache->lock); cache->pinned -= len; -update_bytes_pinned (fs_info, space_info, -len); +btrfs_space_info_update_bytes_pinned (fs_info, space_info, + -len);trace_btrfs_space_reservation (fs_info,"pinned" , space_info->flags, len,0 );
@@ -6547,8 +6539,9 @@ static int unpin_extent_range(struct btrfs_fs_info *fs_info, to_add =min (len, global_rsv->size - global_rsv->reserved); global_rsv->reserved += to_add; -update_bytes_may_use (fs_info, space_info, - to_add); +btrfs_space_info_update_bytes_may_use (fs_info, + space_info, + to_add);if (global_rsv->reserved >= global_rsv->size) global_rsv->full =1 ; trace_btrfs_space_reservation(fs_info,
@@ -10808,7 +10801,8 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)spin_lock (&space_info->lock);spin_lock (&block_group->lock); -update_bytes_pinned (fs_info, space_info, -block_group->pinned); +btrfs_space_info_update_bytes_pinned (fs_info, space_info, + -block_group->pinned); space_info->bytes_readonly += block_group->pinned; percpu_counter_add_batch(&space_info->total_bytes_pinned, -block_group->pinned,
fs/btrfs/space-info.h +22 -0
@@ -77,6 +77,28 @@ static inline bool btrfs_mixed_space_info(struct btrfs_space_info *space_info)return ((space_info->flags &BTRFS_BLOCK_GROUP_METADATA ) && (space_info->flags &BTRFS_BLOCK_GROUP_DATA )); } +/* +* +* Declare a helper function to detect underflow of various space info members +*/ +#define DECLARE_SPACE_INFO_UPDATE (name) \ +static inline void \ +btrfs_space_info_update_##name(struct btrfs_fs_info *fs_info, \ + struct btrfs_space_info *sinfo, \ + s64 bytes) \ +{ \ + lockdep_assert_held(&sinfo->lock); \ + trace_update_##name(fs_info, sinfo, sinfo->name, bytes); \ + if (bytes < 0 && sinfo->name < -bytes) { \ + WARN_ON(1); \ + sinfo->name = 0; \ + return; \ + } \ + sinfo->name += bytes; \ +} + +DECLARE_SPACE_INFO_UPDATE (bytes_may_use); +DECLARE_SPACE_INFO_UPDATE (bytes_pinned); void btrfs_space_info_add_new_bytes(struct btrfs_fs_info *fs_info, struct btrfs_space_info *space_info,
Signature · 1 line
2.14.3
PATCH 7/11 btrfs: move btrfs_space_info_add_*_bytes to space-info.c
In reply to Josef BacikNow that we've moved all the pre-requisite stuff, move these two functions.
--- fs/btrfs/extent-tree.c | 114 ------------------------------------------------- fs/btrfs/space-info.c | 106 +++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/space-info.h | 8 ++++ 3 files changed, 114 insertions(+), 114 deletions(-)
fs/btrfs/extent-tree.c +0 -114
@@ -4487,14 +4487,6 @@ static void shrink_delalloc(struct btrfs_fs_info *fs_info, u64 to_reclaim, } } -struct reserve_ticket { -u64 orig_bytes; -u64 bytes; -int error; -struct list_head list; -wait_queue_head_t wait; -}; -/** * maybe_commit_transaction - possibly commit the transaction if its ok to * @root - the root we're allocating for
@@ -5214,112 +5206,6 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,return 0 ; } -/* -* This is for space we already have accounted in space_info->bytes_may_use, so -* basically when we're returning space from block_rsv's. -*/ -void btrfs_space_info_add_old_bytes (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info, -u64 num_bytes) -{ -struct reserve_ticket *ticket; -struct list_head *head; -u64 used; -enum btrfs_reserve_flush_enum flush =BTRFS_RESERVE_NO_FLUSH ; -bool check_overcommit = false; - -spin_lock (&space_info->lock); - head = &space_info->priority_tickets; - -/* -* If we are over our limit then we need to check and see if we can -* overcommit, and if we can't then we just need to free up our space -* and not satisfy any requests. -*/ - used =btrfs_space_info_used (space_info, true); -if (used - num_bytes >= space_info->total_bytes) - check_overcommit = true; -again: -while (!list_empty (head) && num_bytes) { - ticket = list_first_entry(head, struct reserve_ticket, - list); -/* -* We use 0 bytes because this space is already reserved, so -* adding the ticket space would be a double count. -*/ -if (check_overcommit && - !btrfs_can_overcommit (fs_info, space_info,0 , flush, - false)) -break ; -if (num_bytes >= ticket->bytes) { -list_del_init (&ticket->list); - num_bytes -= ticket->bytes; - ticket->bytes =0 ; - space_info->tickets_id++; -wake_up (&ticket->wait); - }else { - ticket->bytes -= num_bytes; - num_bytes =0 ; - } - } - -if (num_bytes && head == &space_info->priority_tickets) { - head = &space_info->tickets; - flush =BTRFS_RESERVE_FLUSH_ALL ; - goto again; - } -btrfs_space_info_update_bytes_may_use (fs_info, space_info, -num_bytes); -trace_btrfs_space_reservation (fs_info,"space_info" , - space_info->flags, num_bytes,0 ); -spin_unlock (&space_info->lock); -} - -/* -* This is for newly allocated space that isn't accounted in -* space_info->bytes_may_use yet. So if we allocate a chunk or unpin an extent -* we use this helper. -*/ -void btrfs_space_info_add_new_bytes (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info, -u64 num_bytes) -{ -struct reserve_ticket *ticket; -struct list_head *head = &space_info->priority_tickets; - -again: -while (!list_empty (head) && num_bytes) { - ticket = list_first_entry(head, struct reserve_ticket, - list); -if (num_bytes >= ticket->bytes) { -trace_btrfs_space_reservation (fs_info,"space_info" , - space_info->flags, - ticket->bytes,1 ); -list_del_init (&ticket->list); - num_bytes -= ticket->bytes; -btrfs_space_info_update_bytes_may_use (fs_info, - space_info, - ticket->bytes); - ticket->bytes =0 ; - space_info->tickets_id++; -wake_up (&ticket->wait); - }else { -trace_btrfs_space_reservation (fs_info,"space_info" , - space_info->flags, - num_bytes,1 ); -btrfs_space_info_update_bytes_may_use (fs_info, - space_info, - num_bytes); - ticket->bytes -= num_bytes; - num_bytes =0 ; - } - } - -if (num_bytes && head == &space_info->priority_tickets) { - head = &space_info->tickets; - goto again; - } -} - static u64 block_rsv_release_bytes(struct btrfs_fs_info *fs_info, struct btrfs_block_rsv *block_rsv, struct btrfs_block_rsv *dest, u64 num_bytes,
fs/btrfs/space-info.c +106 -0
109 lines not on this page · raw message
fs/btrfs/space-info.h +8 -0
@@ -72,6 +72,14 @@ struct btrfs_space_info {struct kobject *block_group_kobjs[BTRFS_NR_RAID_TYPES ]; }; +struct reserve_ticket { +u64 orig_bytes; +u64 bytes; +int error; +struct list_head list; +wait_queue_head_t wait; +}; +static inline bool btrfs_mixed_space_info (struct btrfs_space_info *space_info) { return ((space_info->flags & BTRFS_BLOCK_GROUP_METADATA) &&
Signature · 1 line
2.14.3
PATCH 8/11 btrfs: export block_rsv_use_bytes
In reply to Josef BacikWe are going to need this to move the metadata reservation stuff to space_info.c.
--- fs/btrfs/ctree.h | 2 ++ fs/btrfs/extent-tree.c | 14 ++++++-------- 2 files changed, 8 insertions(+), 8 deletions(-)
fs/btrfs/ctree.h +2 -0
@@ -2828,6 +2828,8 @@ int btrfs_block_rsv_refill(struct btrfs_root *root,int btrfs_block_rsv_migrate (struct btrfs_block_rsv *src_rsv,struct btrfs_block_rsv *dst_rsv,u64 num_bytes,bool update_size); +int btrfs_block_rsv_use_bytes (struct btrfs_block_rsv *block_rsv, +u64 num_bytes);int btrfs_cond_migrate_bytes (struct btrfs_fs_info *fs_info,struct btrfs_block_rsv *dest,u64 num_bytes,int min_factor);
fs/btrfs/extent-tree.c +6 -8
@@ -53,8 +53,6 @@ static int find_next_key(struct btrfs_path *path, int level,static void dump_space_info (struct btrfs_fs_info *fs_info,struct btrfs_space_info *info,u64 bytes,int dump_block_groups); -static int block_rsv_use_bytes (struct btrfs_block_rsv *block_rsv, -u64 num_bytes); static noinline intblock_group_cache_done (struct btrfs_block_group_cache *cache)
@@ -5033,7 +5031,7 @@ static int reserve_metadata_bytes(struct btrfs_root *root,if (ret == -ENOSPC &&unlikely (root->orphan_cleanup_state ==ORPHAN_CLEANUP_STARTED )) {if (block_rsv != global_rsv && - !block_rsv_use_bytes (global_rsv, orig_bytes)) + !btrfs_block_rsv_use_bytes (global_rsv, orig_bytes)) ret =0 ; }if (ret == -ENOSPC ) {
@@ -5069,8 +5067,8 @@ static struct btrfs_block_rsv *get_block_rsv(return block_rsv; } -static int block_rsv_use_bytes (struct btrfs_block_rsv *block_rsv, -u64 num_bytes) +int btrfs_block_rsv_use_bytes (struct btrfs_block_rsv *block_rsv, +u64 num_bytes) {int ret = -ENOSPC ;spin_lock (&block_rsv->lock);
@@ -5268,7 +5266,7 @@ int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src, {int ret; - ret =block_rsv_use_bytes (src, num_bytes); + ret =btrfs_block_rsv_use_bytes (src, num_bytes);if (ret)return ret;
@@ -8142,7 +8140,7 @@ use_block_rsv(struct btrfs_trans_handle *trans,if (unlikely (block_rsv->size ==0 )) goto try_reserve; again: - ret =block_rsv_use_bytes (block_rsv, blocksize); + ret =btrfs_block_rsv_use_bytes (block_rsv, blocksize);if (!ret)return block_rsv;
@@ -8180,7 +8178,7 @@ use_block_rsv(struct btrfs_trans_handle *trans,*/ if (block_rsv->type !=BTRFS_BLOCK_RSV_GLOBAL && block_rsv->space_info == global_rsv->space_info) { - ret =block_rsv_use_bytes (global_rsv, blocksize); + ret =btrfs_block_rsv_use_bytes (global_rsv, blocksize);if (!ret)return global_rsv; }
Signature · 1 line
2.14.3
PATCH 9/11 btrfs: move dump_space_info to space-info.c
In reply to Josef BacikWe'll need this exported so we can use it in all the various was we need to use it. This is prep work to move reserve_metadata_bytes.
--- fs/btrfs/extent-tree.c | 70 +++++--------------------------------------------- fs/btrfs/space-info.c | 55 +++++++++++++++++++++++++++++++++++++++ fs/btrfs/space-info.h | 3 +++ 3 files changed, 65 insertions(+), 63 deletions(-)
fs/btrfs/extent-tree.c +7 -63
@@ -50,9 +50,6 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans, struct btrfs_delayed_extent_op *extent_op);static int find_next_key (struct btrfs_path *path,int level,struct btrfs_key *key); -static void dump_space_info (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *info,u64 bytes, -int dump_block_groups); static noinline intblock_group_cache_done (struct btrfs_block_group_cache *cache)
@@ -4196,7 +4193,7 @@ void check_system_chunk(struct btrfs_trans_handle *trans, u64 type)if (left < thresh &&btrfs_test_opt (fs_info,ENOSPC_DEBUG )) {btrfs_info (fs_info,"left=%llu, need=%llu, flags=%llu" , left, thresh, type); -dump_space_info (fs_info, info,0 ,0 ); +btrfs_dump_space_info (fs_info, info,0 ,0 ); }if (left < thresh) {
@@ -5040,8 +5037,8 @@ static int reserve_metadata_bytes(struct btrfs_root *root, orig_bytes, 1);if (btrfs_test_opt (fs_info,ENOSPC_DEBUG )) -dump_space_info (fs_info, block_rsv->space_info, - orig_bytes,0 ); +btrfs_dump_space_info (fs_info, block_rsv->space_info, + orig_bytes,0 ); }return ret; }
@@ -7653,60 +7650,6 @@ static noinline int find_free_extent(struct btrfs_fs_info *fs_info,return ret; } -#define DUMP_BLOCK_RSV (fs_info, rsv_name) \ -do { \ - struct btrfs_block_rsv *__rsv = &(fs_info)->rsv_name; \ - spin_lock(&__rsv->lock); \ - btrfs_info(fs_info, #rsv_name ": size %llu reserved %llu", \ - __rsv->size, __rsv->reserved); \ - spin_unlock(&__rsv->lock); \ -} while (0) - -static void dump_space_info (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *info,u64 bytes, -int dump_block_groups) -{ -struct btrfs_block_group_cache *cache; -int index =0 ; - -spin_lock (&info->lock); -btrfs_info (fs_info,"space_info %llu has %llu free, is %sfull" , - info->flags, - 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" , - info->total_bytes, info->bytes_used, info->bytes_pinned, - info->bytes_reserved, info->bytes_may_use, - info->bytes_readonly); -spin_unlock (&info->lock); - -DUMP_BLOCK_RSV (fs_info, global_block_rsv); -DUMP_BLOCK_RSV (fs_info, trans_block_rsv); -DUMP_BLOCK_RSV (fs_info, chunk_block_rsv); -DUMP_BLOCK_RSV (fs_info, delayed_block_rsv); -DUMP_BLOCK_RSV (fs_info, delayed_refs_rsv); - -if (!dump_block_groups) -return ; - -down_read (&info->groups_sem); -again: -list_for_each_entry (cache, &info->block_groups[index], list) { -spin_lock (&cache->lock); -btrfs_info (fs_info, -"block group %llu has %llu bytes, %llu used %llu pinned %llu reserved %s" , - cache->key.objectid, cache->key.offset, -btrfs_block_group_used (&cache->item), cache->pinned, - cache->reserved, cache->ro ?"[readonly]" :"" ); -btrfs_dump_free_space (cache, bytes); -spin_unlock (&cache->lock); - } -if (++index <BTRFS_NR_RAID_TYPES ) - goto again; -up_read (&info->groups_sem); -} -/* * btrfs_reserve_extent - entry point to the extent allocator. Tries to find a * hole that is at least as big as @num_bytes.
@@ -7787,7 +7730,8 @@ int btrfs_reserve_extent(struct btrfs_root *root, u64 ram_bytes,"allocation failed flags %llu, wanted %llu" , flags, num_bytes);if (sinfo) -dump_space_info (fs_info, sinfo, num_bytes,1 ); +btrfs_dump_space_info (fs_info, sinfo, + num_bytes,1 ); } }
@@ -9305,7 +9249,7 @@ static int inc_block_group_ro(struct btrfs_block_group_cache *cache, int force)btrfs_info (cache->fs_info,"sinfo_used=%llu bg_num_bytes=%llu min_allocable=%llu" , sinfo_used, num_bytes, min_allocable_bytes); -dump_space_info (cache->fs_info, cache->space_info,0 ,0 ); +btrfs_dump_space_info (cache->fs_info, cache->space_info,0 ,0 ); }return ret; }
@@ -9787,7 +9731,7 @@ int btrfs_free_block_groups(struct btrfs_fs_info *info)if (WARN_ON (space_info->bytes_pinned >0 || space_info->bytes_reserved >0 || space_info->bytes_may_use >0 )) -dump_space_info (info, space_info,0 ,0 ); +btrfs_dump_space_info (info, space_info,0 ,0 );list_del (&space_info->list);for (i =0 ; i <BTRFS_NR_RAID_TYPES ; i++) {struct kobject *kobj;
fs/btrfs/space-info.c +55 -0
64 lines not on this page · raw message
fs/btrfs/space-info.h +3 -0
@@ -128,5 +128,8 @@ int btrfs_can_overcommit(struct btrfs_fs_info *fs_info, struct btrfs_space_info *space_info, u64 bytes, enum btrfs_reserve_flush_enum flush, bool system_chunk); +void btrfs_dump_space_info (struct btrfs_fs_info *fs_info, +struct btrfs_space_info *info,u64 bytes, +int dump_block_groups);#endif /* BTRFS_SPACE_INFO_H */
Signature · 1 line
2.14.3
PATCH 10/11 btrfs: move reserve_metadata_bytes and supporting code to space-info.c
In reply to Josef BacikThis moves all of the metadata reservation code into space-info.c.
--- fs/btrfs/extent-tree.c | 710 +------------------------------------------------ fs/btrfs/space-info.c | 698 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/space-info.h | 4 + 3 files changed, 710 insertions(+), 702 deletions(-)
fs/btrfs/extent-tree.c +8 -702
@@ -4348,701 +4348,6 @@ int btrfs_chunk_alloc(struct btrfs_trans_handle *trans, u64 flags,return ret; } -static void btrfs_writeback_inodes_sb_nr (struct btrfs_fs_info *fs_info, -unsigned long nr_pages,int nr_items) -{ -struct super_block *sb = fs_info->sb; - -if (down_read_trylock (&sb->s_umount)) { -writeback_inodes_sb_nr (sb, nr_pages,WB_REASON_FS_FREE_SPACE ); -up_read (&sb->s_umount); - }else { -/* -* We needn't worry the filesystem going from r/w to r/o though -* we don't acquire ->s_umount mutex, because the filesystem -* should guarantee the delalloc inodes list be empty after -* the filesystem is readonly(all dirty pages are written to -* the disk). -*/ -btrfs_start_delalloc_roots (fs_info, nr_items); -if (!current->journal_info) -btrfs_wait_ordered_roots (fs_info, nr_items,0 , (u64)-1 ); - } -} - -static inline u64 calc_reclaim_items_nr (struct btrfs_fs_info *fs_info, -u64 to_reclaim) -{ -u64 bytes; -u64 nr; - - bytes =btrfs_calc_trans_metadata_size (fs_info,1 ); - nr =div64_u64 (to_reclaim, bytes); -if (!nr) - nr =1 ; -return nr; -} - -#define EXTENT_SIZE_PER_ITEM SZ_256K - -/* -* shrink metadata reservation for delalloc -*/ -static void shrink_delalloc (struct btrfs_fs_info *fs_info,u64 to_reclaim, -u64 orig,bool wait_ordered) -{ -struct btrfs_space_info *space_info; -struct btrfs_trans_handle *trans; -u64 delalloc_bytes; -u64 dio_bytes; -u64 async_pages; -u64 items; -long time_left; -unsigned long nr_pages; -int loops; - -/* Calc the number of the pages we need flush for space reservation */ - items =calc_reclaim_items_nr (fs_info, to_reclaim); - to_reclaim = items *EXTENT_SIZE_PER_ITEM ; - - trans = (struct btrfs_trans_handle *)current->journal_info; - space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_METADATA ); - - delalloc_bytes =percpu_counter_sum_positive ( - &fs_info->delalloc_bytes); - dio_bytes =percpu_counter_sum_positive (&fs_info->dio_bytes); -if (delalloc_bytes ==0 && dio_bytes ==0 ) { -if (trans) -return ; -if (wait_ordered) -btrfs_wait_ordered_roots (fs_info, items,0 , (u64)-1 ); -return ; - } - -/* -* If we are doing more ordered than delalloc we need to just wait on -* ordered extents, otherwise we'll waste time trying to flush delalloc -* that likely won't give us the space back we need. -*/ -if (dio_bytes > delalloc_bytes) - wait_ordered = true; - - loops =0 ; -while ((delalloc_bytes || dio_bytes) && loops <3 ) { - nr_pages =min (delalloc_bytes, to_reclaim) >>PAGE_SHIFT ; - -/* -* Triggers inode writeback for up to nr_pages. This will invoke -* ->writepages callback and trigger delalloc filling -* (btrfs_run_delalloc_range()). -*/ -btrfs_writeback_inodes_sb_nr (fs_info, nr_pages, items); - -/* -* We need to wait for the compressed pages to start before -* we continue. -*/ - async_pages =atomic_read (&fs_info->async_delalloc_pages); -if (!async_pages) - goto skip_async; - -/* -* Calculate how many compressed pages we want to be written -* before we continue. I.e if there are more async pages than we -* require wait_event will wait until nr_pages are written. -*/ -if (async_pages <= nr_pages) - async_pages =0 ; -else - async_pages -= nr_pages; - -wait_event (fs_info->async_submit_wait, -atomic_read (&fs_info->async_delalloc_pages) <= - (int )async_pages); -skip_async: -spin_lock (&space_info->lock); -if (list_empty (&space_info->tickets) && -list_empty (&space_info->priority_tickets)) { -spin_unlock (&space_info->lock); -break ; - } -spin_unlock (&space_info->lock); - - loops++; -if (wait_ordered && !trans) { -btrfs_wait_ordered_roots (fs_info, items,0 , (u64)-1 ); - }else { - time_left =schedule_timeout_killable (1 ); -if (time_left) -break ; - } - delalloc_bytes =percpu_counter_sum_positive ( - &fs_info->delalloc_bytes); - dio_bytes =percpu_counter_sum_positive (&fs_info->dio_bytes); - } -} - -/** -* maybe_commit_transaction - possibly commit the transaction if its ok to -* @root - the root we're allocating for -* @bytes - the number of bytes we want to reserve -* @force - force the commit -* -* This will check to make sure that committing the transaction will actually -* get us somewhere and then commit the transaction if it does. Otherwise it -* will return -ENOSPC. -*/ -static int may_commit_transaction (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info) -{ -struct reserve_ticket *ticket =NULL ; -struct btrfs_block_rsv *delayed_rsv = &fs_info->delayed_block_rsv; -struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv; -struct btrfs_trans_handle *trans; -u64 bytes_needed; -u64 reclaim_bytes =0 ; - - trans = (struct btrfs_trans_handle *)current->journal_info; -if (trans) -return -EAGAIN ; - -spin_lock (&space_info->lock); -if (!list_empty (&space_info->priority_tickets)) - ticket =list_first_entry (&space_info->priority_tickets, - struct reserve_ticket, list); -else if (!list_empty (&space_info->tickets)) - ticket =list_first_entry (&space_info->tickets, - struct reserve_ticket, list); - bytes_needed = (ticket) ? ticket->bytes :0 ; -spin_unlock (&space_info->lock); - -if (!bytes_needed) -return 0 ; - - trans =btrfs_join_transaction (fs_info->extent_root); -if (IS_ERR (trans)) -return PTR_ERR (trans); - -/* -* See if there is enough pinned space to make this reservation, or if -* we have block groups that are going to be freed, allowing us to -* possibly do a chunk allocation the next loop through. -*/ -if (test_bit (BTRFS_TRANS_HAVE_FREE_BGS , &trans->transaction->flags) || -__percpu_counter_compare (&space_info->total_bytes_pinned, - bytes_needed, -BTRFS_TOTAL_BYTES_PINNED_BATCH ) >=0 ) - goto commit; - -/* -* See if there is some space in the delayed insertion reservation for -* this reservation. -*/ -if (space_info != delayed_rsv->space_info) - goto enospc; - -spin_lock (&delayed_rsv->lock); - reclaim_bytes += delayed_rsv->reserved; -spin_unlock (&delayed_rsv->lock); - -spin_lock (&delayed_refs_rsv->lock); - reclaim_bytes += delayed_refs_rsv->reserved; -spin_unlock (&delayed_refs_rsv->lock); -if (reclaim_bytes >= bytes_needed) - goto commit; - bytes_needed -= reclaim_bytes; - -if (__percpu_counter_compare (&space_info->total_bytes_pinned, - bytes_needed, -BTRFS_TOTAL_BYTES_PINNED_BATCH ) <0 ) - goto enospc; - -commit: -return btrfs_commit_transaction (trans); -enospc: -btrfs_end_transaction (trans); -return -ENOSPC ; -} - -/* -* Try to flush some data based on policy set by @state. This is only advisory -* and may fail for various reasons. The caller is supposed to examine the -* state of @space_info to detect the outcome. -*/ -static void flush_space (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info,u64 num_bytes, -int state) -{ -struct btrfs_root *root = fs_info->extent_root; -struct btrfs_trans_handle *trans; -int nr; -int ret =0 ; - -switch (state) { -case FLUSH_DELAYED_ITEMS_NR : -case FLUSH_DELAYED_ITEMS : -if (state ==FLUSH_DELAYED_ITEMS_NR ) - nr =calc_reclaim_items_nr (fs_info, num_bytes) *2 ; -else - nr =-1 ; - - trans =btrfs_join_transaction (root); -if (IS_ERR (trans)) { - ret =PTR_ERR (trans); -break ; - } - ret =btrfs_run_delayed_items_nr (trans, nr); -btrfs_end_transaction (trans); -break ; -case FLUSH_DELALLOC : -case FLUSH_DELALLOC_WAIT : -shrink_delalloc (fs_info, num_bytes *2 , num_bytes, - state ==FLUSH_DELALLOC_WAIT ); -break ; -case FLUSH_DELAYED_REFS_NR : -case FLUSH_DELAYED_REFS : - trans =btrfs_join_transaction (root); -if (IS_ERR (trans)) { - ret =PTR_ERR (trans); -break ; - } -if (state ==FLUSH_DELAYED_REFS_NR ) - nr =calc_reclaim_items_nr (fs_info, num_bytes); -else - nr =0 ; -btrfs_run_delayed_refs (trans, nr); -btrfs_end_transaction (trans); -break ; -case ALLOC_CHUNK : -case ALLOC_CHUNK_FORCE : - trans =btrfs_join_transaction (root); -if (IS_ERR (trans)) { - ret =PTR_ERR (trans); -break ; - } - ret =btrfs_chunk_alloc (trans, -btrfs_metadata_alloc_profile (fs_info), - (state ==ALLOC_CHUNK ) ?CHUNK_ALLOC_NO_FORCE : -CHUNK_ALLOC_FORCE ); -btrfs_end_transaction (trans); -if (ret >0 || ret == -ENOSPC ) - ret =0 ; -break ; -case COMMIT_TRANS : -/* -* If we have pending delayed iputs then we could free up a -* bunch of pinned space, so make sure we run the iputs before -* we do our pinned bytes check below. -*/ -btrfs_run_delayed_iputs (fs_info); -btrfs_wait_on_delayed_iputs (fs_info); - - ret =may_commit_transaction (fs_info, space_info); -break ; -default : - ret = -ENOSPC ; -break ; - } - -trace_btrfs_flush_space (fs_info, space_info->flags, num_bytes, state, - ret); -return ; -} - -static inline u64 -btrfs_calc_reclaim_metadata_size (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info, -bool system_chunk) -{ -struct reserve_ticket *ticket; -u64 used; -u64 expected; -u64 to_reclaim =0 ; - -list_for_each_entry (ticket, &space_info->tickets, list) - to_reclaim += ticket->bytes; -list_for_each_entry (ticket, &space_info->priority_tickets, list) - to_reclaim += ticket->bytes; -if (to_reclaim) -return to_reclaim; - - to_reclaim =min_t (u64,num_online_cpus () *SZ_1M ,SZ_16M ); -if (btrfs_can_overcommit (fs_info, space_info, to_reclaim, -BTRFS_RESERVE_FLUSH_ALL , system_chunk)) -return 0 ; - - used =btrfs_space_info_used (space_info, true); - -if (btrfs_can_overcommit (fs_info, space_info,SZ_1M , -BTRFS_RESERVE_FLUSH_ALL , system_chunk)) - expected =div_factor_fine (space_info->total_bytes,95 ); -else - expected =div_factor_fine (space_info->total_bytes,90 ); - -if (used > expected) - to_reclaim = used - expected; -else - to_reclaim =0 ; - to_reclaim =min (to_reclaim, space_info->bytes_may_use + - space_info->bytes_reserved); -return to_reclaim; -} - -static inline int need_do_async_reclaim (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info, -u64 used,bool system_chunk) -{ -u64 thresh =div_factor_fine (space_info->total_bytes,98 ); - -/* If we're just plain full then async reclaim just slows us down. */ -if ((space_info->bytes_used + space_info->bytes_reserved) >= thresh) -return 0 ; - -if (!btrfs_calc_reclaim_metadata_size (fs_info, space_info, - system_chunk)) -return 0 ; - -return (used >= thresh && !btrfs_fs_closing (fs_info) && - !test_bit (BTRFS_FS_STATE_REMOUNTING , &fs_info->fs_state)); -} - -static bool wake_all_tickets (struct list_head *head) -{ -struct reserve_ticket *ticket; - -while (!list_empty (head)) { - ticket = list_first_entry(head, struct reserve_ticket, list); -list_del_init (&ticket->list); - ticket->error = -ENOSPC ; -wake_up (&ticket->wait); -if (ticket->bytes != ticket->orig_bytes) -return true; - } -return false; -} - -/* -* This is for normal flushers, we can wait all goddamned day if we want to. We -* will loop and continuously try to flush as long as we are making progress. -* We count progress as clearing off tickets each time we have to loop. -*/ -static void btrfs_async_reclaim_metadata_space (struct work_struct *work) -{ -struct btrfs_fs_info *fs_info; -struct btrfs_space_info *space_info; -u64 to_reclaim; -int flush_state; -int commit_cycles =0 ; -u64 last_tickets_id; - - fs_info = container_of(work, struct btrfs_fs_info, async_reclaim_work); - space_info =btrfs_find_space_info (fs_info,BTRFS_BLOCK_GROUP_METADATA ); - -spin_lock (&space_info->lock); - to_reclaim =btrfs_calc_reclaim_metadata_size (fs_info, space_info, - false); -if (!to_reclaim) { - space_info->flush =0 ; -spin_unlock (&space_info->lock); -return ; - } - last_tickets_id = space_info->tickets_id; -spin_unlock (&space_info->lock); - - flush_state =FLUSH_DELAYED_ITEMS_NR ; -do { -flush_space (fs_info, space_info, to_reclaim, flush_state); -spin_lock (&space_info->lock); -if (list_empty (&space_info->tickets)) { - space_info->flush =0 ; -spin_unlock (&space_info->lock); -return ; - } - to_reclaim =btrfs_calc_reclaim_metadata_size (fs_info, - space_info, - false); -if (last_tickets_id == space_info->tickets_id) { - flush_state++; - }else { - last_tickets_id = space_info->tickets_id; - flush_state =FLUSH_DELAYED_ITEMS_NR ; -if (commit_cycles) - commit_cycles--; - } - -/* -* We don't want to force a chunk allocation until we've tried -* pretty hard to reclaim space. Think of the case where we -* freed up a bunch of space and so have a lot of pinned space -* to reclaim. We would rather use that than possibly create a -* underutilized metadata chunk. So if this is our first run -* through the flushing state machine skip ALLOC_CHUNK_FORCE and -* commit the transaction. If nothing has changed the next go -* around then we can force a chunk allocation. -*/ -if (flush_state ==ALLOC_CHUNK_FORCE && !commit_cycles) - flush_state++; - -if (flush_state >COMMIT_TRANS ) { - commit_cycles++; -if (commit_cycles >2 ) { -if (wake_all_tickets (&space_info->tickets)) { - flush_state =FLUSH_DELAYED_ITEMS_NR ; - commit_cycles--; - }else { - space_info->flush =0 ; - } - }else { - flush_state =FLUSH_DELAYED_ITEMS_NR ; - } - } -spin_unlock (&space_info->lock); - }while (flush_state <=COMMIT_TRANS ); -} - -void btrfs_init_async_reclaim_work (struct work_struct *work) -{ -INIT_WORK (work, btrfs_async_reclaim_metadata_space); -} - -static const enum btrfs_flush_state priority_flush_states[] = { -FLUSH_DELAYED_ITEMS_NR , -FLUSH_DELAYED_ITEMS , -ALLOC_CHUNK , -}; - -static void priority_reclaim_metadata_space (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info, -struct reserve_ticket *ticket) -{ -u64 to_reclaim; -int flush_state; - -spin_lock (&space_info->lock); - to_reclaim =btrfs_calc_reclaim_metadata_size (fs_info, space_info, - false); -if (!to_reclaim) { -spin_unlock (&space_info->lock); -return ; - } -spin_unlock (&space_info->lock); - - flush_state =0 ; -do { -flush_space (fs_info, space_info, to_reclaim, - priority_flush_states[flush_state]); - flush_state++; -spin_lock (&space_info->lock); -if (ticket->bytes ==0 ) { -spin_unlock (&space_info->lock); -return ; - } -spin_unlock (&space_info->lock); - }while (flush_state <ARRAY_SIZE (priority_flush_states)); -} - -static int wait_reserve_ticket (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info, -struct reserve_ticket *ticket) - -{ -DEFINE_WAIT (wait); -u64 reclaim_bytes =0 ; -int ret =0 ; - -spin_lock (&space_info->lock); -while (ticket->bytes >0 && ticket->error ==0 ) { - ret =prepare_to_wait_event (&ticket->wait, &wait,TASK_KILLABLE ); -if (ret) { - ret = -EINTR ; -break ; - } -spin_unlock (&space_info->lock); - -schedule (); - -finish_wait (&ticket->wait, &wait); -spin_lock (&space_info->lock); - } -if (!ret) - ret = ticket->error; -if (!list_empty (&ticket->list)) -list_del_init (&ticket->list); -if (ticket->bytes && ticket->bytes < ticket->orig_bytes) - reclaim_bytes = ticket->orig_bytes - ticket->bytes; -spin_unlock (&space_info->lock); - -if (reclaim_bytes) -btrfs_space_info_add_old_bytes (fs_info, space_info, - reclaim_bytes); -return ret; -} - -/** -* reserve_metadata_bytes - try to reserve bytes from the block_rsv's space -* @root - the root we're allocating for -* @space_info - the space info we want to allocate from -* @orig_bytes - the number of bytes we want -* @flush - whether or not we can flush to make our reservation -* -* This will reserve orig_bytes number of bytes from the space info associated -* with the block_rsv. If there is not enough space it will make an attempt to -* flush out space to make room. It will do this by flushing delalloc if -* possible or committing the transaction. If flush is 0 then no attempts to -* regain reservations will be made and this will fail if there is not enough -* space already. -*/ -static int __reserve_metadata_bytes (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info, -u64 orig_bytes, -enum btrfs_reserve_flush_enum flush, -bool system_chunk) -{ -struct reserve_ticket ticket; -u64 used; -u64 reclaim_bytes =0 ; -int ret =0 ; - -ASSERT (orig_bytes); -ASSERT (!current->journal_info || flush !=BTRFS_RESERVE_FLUSH_ALL ); - -spin_lock (&space_info->lock); - ret = -ENOSPC ; - used =btrfs_space_info_used (space_info, true); - -/* -* If we have enough space then hooray, make our reservation and carry -* on. If not see if we can overcommit, and if we can, hooray carry on. -* If not things get more complicated. -*/ -if (used + orig_bytes <= space_info->total_bytes) { -btrfs_space_info_update_bytes_may_use (fs_info, space_info, - orig_bytes); -trace_btrfs_space_reservation (fs_info,"space_info" , - space_info->flags, orig_bytes,1 ); - ret =0 ; - }else if (btrfs_can_overcommit (fs_info, space_info, orig_bytes, flush, - system_chunk)) { -btrfs_space_info_update_bytes_may_use (fs_info, space_info, - orig_bytes); -trace_btrfs_space_reservation (fs_info,"space_info" , - space_info->flags, orig_bytes,1 ); - ret =0 ; - } - -/* -* If we couldn't make a reservation then setup our reservation ticket -* and kick the async worker if it's not already running. -* -* If we are a priority flusher then we just need to add our ticket to -* the list and we will do our own flushing further down. -*/ -if (ret && flush !=BTRFS_RESERVE_NO_FLUSH ) { - ticket.orig_bytes = orig_bytes; - ticket.bytes = orig_bytes; - ticket.error =0 ; -init_waitqueue_head (&ticket.wait); -if (flush ==BTRFS_RESERVE_FLUSH_ALL ) { -list_add_tail (&ticket.list, &space_info->tickets); -if (!space_info->flush) { - space_info->flush =1 ; -trace_btrfs_trigger_flush (fs_info, - space_info->flags, - orig_bytes, flush, -"enospc" ); -queue_work (system_unbound_wq, - &fs_info->async_reclaim_work); - } - }else { -list_add_tail (&ticket.list, - &space_info->priority_tickets); - } - }else if (!ret && space_info->flags &BTRFS_BLOCK_GROUP_METADATA ) { - used += orig_bytes; -/* -* We will do the space reservation dance during log replay, -* which means we won't have fs_info->fs_root set, so don't do -* the async reclaim as we will panic. -*/ -if (!test_bit (BTRFS_FS_LOG_RECOVERING , &fs_info->flags) && -need_do_async_reclaim (fs_info, space_info, - used, system_chunk) && - !work_busy (&fs_info->async_reclaim_work)) { -trace_btrfs_trigger_flush (fs_info, space_info->flags, - orig_bytes, flush,"preempt" ); -queue_work (system_unbound_wq, - &fs_info->async_reclaim_work); - } - } -spin_unlock (&space_info->lock); -if (!ret || flush ==BTRFS_RESERVE_NO_FLUSH ) -return ret; - -if (flush ==BTRFS_RESERVE_FLUSH_ALL ) -return wait_reserve_ticket (fs_info, space_info, &ticket); - - ret =0 ; -priority_reclaim_metadata_space (fs_info, space_info, &ticket); -spin_lock (&space_info->lock); -if (ticket.bytes) { -if (ticket.bytes < orig_bytes) - reclaim_bytes = orig_bytes - ticket.bytes; -list_del_init (&ticket.list); - ret = -ENOSPC ; - } -spin_unlock (&space_info->lock); - -if (reclaim_bytes) -btrfs_space_info_add_old_bytes (fs_info, space_info, - reclaim_bytes); -ASSERT (list_empty (&ticket.list)); -return ret; -} - -/** -* reserve_metadata_bytes - try to reserve bytes from the block_rsv's space -* @root - the root we're allocating for -* @block_rsv - the block_rsv we're allocating for -* @orig_bytes - the number of bytes we want -* @flush - whether or not we can flush to make our reservation -* -* This will reserve orig_bytes number of bytes from the space info associated -* with the block_rsv. If there is not enough space it will make an attempt to -* flush out space to make room. It will do this by flushing delalloc if -* possible or committing the transaction. If flush is 0 then no attempts to -* regain reservations will be made and this will fail if there is not enough -* space already. -*/ -static int reserve_metadata_bytes (struct btrfs_root *root, -struct btrfs_block_rsv *block_rsv, -u64 orig_bytes, -enum btrfs_reserve_flush_enum flush) -{ -struct btrfs_fs_info *fs_info = root->fs_info; -struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv; -int ret; -bool system_chunk = (root == fs_info->chunk_root); - - ret =__reserve_metadata_bytes (fs_info, block_rsv->space_info, - orig_bytes, flush, system_chunk); -if (ret == -ENOSPC && -unlikely (root->orphan_cleanup_state ==ORPHAN_CLEANUP_STARTED )) { -if (block_rsv != global_rsv && - !btrfs_block_rsv_use_bytes (global_rsv, orig_bytes)) - ret =0 ; - } -if (ret == -ENOSPC ) { -trace_btrfs_space_reservation (fs_info,"space_info:enospc" , - block_rsv->space_info->flags, - orig_bytes,1 ); - -if (btrfs_test_opt (fs_info,ENOSPC_DEBUG )) -btrfs_dump_space_info (fs_info, block_rsv->space_info, - orig_bytes,0 ); - } -return ret; -} -static struct btrfs_block_rsv *get_block_rsv (const struct btrfs_trans_handle *trans,const struct btrfs_root *root)
@@ -5191,8 +4496,8 @@ int btrfs_delayed_refs_rsv_refill(struct btrfs_fs_info *fs_info,if (!num_bytes)return 0 ; - ret =reserve_metadata_bytes (fs_info->extent_root, block_rsv, - num_bytes, flush); + ret =btrfs_reserve_metadata_bytes (fs_info->extent_root, block_rsv, + num_bytes, flush);if (ret)return ret;block_rsv_add_bytes (block_rsv, num_bytes,0 );
@@ -5318,7 +4623,7 @@ int btrfs_block_rsv_add(struct btrfs_root *root,if (num_bytes ==0 )return 0 ; - ret =reserve_metadata_bytes (root, block_rsv, num_bytes, flush); + ret =btrfs_reserve_metadata_bytes (root, block_rsv, num_bytes, flush);if (!ret)block_rsv_add_bytes (block_rsv, num_bytes, true);
@@ -5363,7 +4668,7 @@ int btrfs_block_rsv_refill(struct btrfs_root *root,if (!ret)return 0 ; - ret =reserve_metadata_bytes (root, block_rsv, num_bytes, flush); + ret =btrfs_reserve_metadata_bytes (root, block_rsv, num_bytes, flush);if (!ret) {block_rsv_add_bytes (block_rsv, num_bytes, false);return 0 ;
@@ -5737,7 +5042,8 @@ int btrfs_delalloc_reserve_metadata(struct btrfs_inode *inode, u64 num_bytes) ret =btrfs_qgroup_reserve_meta_prealloc (root, qgroup_reserve, true);if (ret) goto out_fail; - ret =reserve_metadata_bytes (root, block_rsv, meta_reserve, flush); + ret =btrfs_reserve_metadata_bytes (root, block_rsv, meta_reserve, + flush);if (ret) goto out_qgroup;
@@ -8111,8 +7417,8 @@ use_block_rsv(struct btrfs_trans_handle *trans, "BTRFS: block rsv returned %d\n", ret); } try_reserve: - ret =reserve_metadata_bytes (root, block_rsv, blocksize, -BTRFS_RESERVE_NO_FLUSH ); + ret =btrfs_reserve_metadata_bytes (root, block_rsv, blocksize, +BTRFS_RESERVE_NO_FLUSH );if (!ret)return block_rsv;/*
fs/btrfs/space-info.c +698 -0
707 lines not on this page · raw message
fs/btrfs/space-info.h +4 -0
@@ -131,5 +131,9 @@ int btrfs_can_overcommit(struct btrfs_fs_info *fs_info,void btrfs_dump_space_info (struct btrfs_fs_info *fs_info,struct btrfs_space_info *info,u64 bytes,int dump_block_groups); +int btrfs_reserve_metadata_bytes (struct btrfs_root *root, +struct btrfs_block_rsv *block_rsv, +u64 orig_bytes, +enum btrfs_reserve_flush_enum flush);#endif /* BTRFS_SPACE_INFO_H */
Signature · 1 line
2.14.3
PATCH 11/11 btrfs: unexport can_overcommit
In reply to Josef BacikNow that we've moved all of the users to space-info.c, unexport it and name it back to can_overcommit.
--- fs/btrfs/space-info.c | 23 +++++++++++------------ fs/btrfs/space-info.h | 4 ---- 2 files changed, 11 insertions(+), 16 deletions(-)
fs/btrfs/space-info.c +11 -12
@@ -185,10 +185,10 @@ static inline u64 calc_global_rsv_need_space(struct btrfs_block_rsv *global)return (global->size <<1 ); } -int btrfs_can_overcommit (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info,u64 bytes, -enum btrfs_reserve_flush_enum flush, -bool system_chunk) +static int can_overcommit (struct btrfs_fs_info *fs_info, +struct btrfs_space_info *space_info,u64 bytes, +enum btrfs_reserve_flush_enum flush, +bool system_chunk) {struct btrfs_block_rsv *global_rsv = &fs_info->global_block_rsv;u64 profile;
@@ -282,8 +282,7 @@ void btrfs_space_info_add_old_bytes(struct btrfs_fs_info *fs_info,* adding the ticket space would be a double count. */ if (check_overcommit && - !btrfs_can_overcommit (fs_info, space_info,0 , flush, - false)) + !can_overcommit (fs_info, space_info,0 , flush, false))break ;if (num_bytes >= ticket->bytes) {list_del_init (&ticket->list);
@@ -727,14 +726,14 @@ btrfs_calc_reclaim_metadata_size(struct btrfs_fs_info *fs_info,return to_reclaim; to_reclaim =min_t (u64,num_online_cpus () *SZ_1M ,SZ_16M ); -if (btrfs_can_overcommit (fs_info, space_info, to_reclaim, -BTRFS_RESERVE_FLUSH_ALL , system_chunk)) +if (can_overcommit (fs_info, space_info, to_reclaim, +BTRFS_RESERVE_FLUSH_ALL , system_chunk))return 0 ; used =btrfs_space_info_used (space_info, true); -if (btrfs_can_overcommit (fs_info, space_info,SZ_1M , -BTRFS_RESERVE_FLUSH_ALL , system_chunk)) +if (can_overcommit (fs_info, space_info,SZ_1M , +BTRFS_RESERVE_FLUSH_ALL , system_chunk)) expected =div_factor_fine (space_info->total_bytes,95 );else expected =div_factor_fine (space_info->total_bytes,90 );
@@ -981,8 +980,8 @@ static int __reserve_metadata_bytes(struct btrfs_fs_info *fs_info,trace_btrfs_space_reservation (fs_info,"space_info" , space_info->flags, orig_bytes,1 ); ret =0 ; - }else if (btrfs_can_overcommit (fs_info, space_info, orig_bytes, flush, - system_chunk)) { + }else if (can_overcommit (fs_info, space_info, orig_bytes, flush, + system_chunk)) {btrfs_space_info_update_bytes_may_use (fs_info, space_info, orig_bytes); trace_btrfs_space_reservation(fs_info, "space_info",
fs/btrfs/space-info.h +0 -4
@@ -124,10 +124,6 @@ struct btrfs_space_info *btrfs_find_space_info(struct btrfs_fs_info *info,u64 btrfs_space_info_used (struct btrfs_space_info *s_info,bool may_use_included);void btrfs_clear_space_info_full (struct btrfs_fs_info *info); -int btrfs_can_overcommit (struct btrfs_fs_info *fs_info, -struct btrfs_space_info *space_info,u64 bytes, -enum btrfs_reserve_flush_enum flush, -bool system_chunk);void btrfs_dump_space_info (struct btrfs_fs_info *fs_info,struct btrfs_space_info *info,u64 bytes,int dump_block_groups);
Signature · 1 line
2.14.3
Quoted 7 lines · Josef Bacik
This is the first pass at making
extent-tree.cmuch smaller. I've purposefully done no other cleanups or changes. The places where I needed to modify callers were done in separate patches. The only time I moved and changed callers in large chunks was the moving ofreserve_metadata_bytesout ofextent-tree.c, and that was just to rename the users ofreserve_metadata_bytestobtrfs_reserve_metadata_bytes.
Quoted 6 lines
There is 0 functional change in this series. The next step is to move the other space reservation code that is specific to
delayed_refs, inodes, etc. But I wanted to start with this to make sure we're all onboard with this approach before I do other things.The diffstat for the whole series is the following
Looks good,
Quoted 17 lines
fs/btrfs/Makefile | 2 +- fs/btrfs/ctree.h | 97 +--- fs/btrfs/extent-tree.c | 1277 +++---------------------------------------- fs/btrfs/free-space-cache.c | 1 + fs/btrfs/ioctl.c | 1 + fs/btrfs/space-info.c | 1103 +++++++++++++++++++++++++++++++++++++ fs/btrfs/space-info.h | 135 +++++ fs/btrfs/super.c | 1 + fs/btrfs/sysfs.c | 1 + fs/btrfs/volumes.c | 1 + 10 files changed, 1343 insertions(+), 1276 deletions(-)Thanks,
Josef
Quoted 14 lines · Josef Bacik
This is the first pass at making
extent-tree.cmuch smaller. I've purposefully done no other cleanups or changes. The places where I needed to modify callers were done in separate patches. The only time I moved and changed callers in large chunks was the moving ofreserve_metadata_bytesout ofextent-tree.c, and that was just to rename the users ofreserve_metadata_bytestobtrfs_reserve_metadata_bytes.There is 0 functional change in this series. The next step is to move the other space reservation code that is specific to
delayed_refs, inodes, etc. But I wanted to start with this to make sure we're all onboard with this approach before I do other things.The diffstat for the whole series is the following
Quoted 11 lines
fs/btrfs/Makefile | 2 +- fs/btrfs/ctree.h | 97 +--- fs/btrfs/extent-tree.c | 1277 +++---------------------------------------- fs/btrfs/free-space-cache.c | 1 + fs/btrfs/ioctl.c | 1 + fs/btrfs/space-info.c | 1103 +++++++++++++++++++++++++++++++++++++ fs/btrfs/space-info.h | 135 +++++ fs/btrfs/super.c | 1 + fs/btrfs/sysfs.c | 1 + fs/btrfs/volumes.c | 1 + 10 files changed, 1343 insertions(+), 1276 deletions(-)
With the removed copyright notice, patches added to misc-next.