On 12/11, Chao Yu wrote: > Hi Jaegeuk, > > On 2017/12/1 15:36, Jaegeuk Kim wrote: > > Hi Chao, > > > > This is really hard to review and risky a lot to apply it shortly. Do we > > have a > > I can understand your concern. > > > strong reason we have to do this? The original design goal was to minimize > > allocation delay which is almost zero for now. Of course, I agreed that > > there'd > > I agreed, For nid allocation performance there will be no room to improve > since > we have already used memory to exchange performance there. > > After applying this patch, I can encounter slight regression in scenario of > continuous file creation. > > Anyway, goal of this patch is not aiming at performance, instead, it intends > to > reduce code complexity, and maybe, slightly improving performance of > allocation > in low-memory environment. So actually, this is a trade-off problem. > > If we decide to use old approach, I think what can be improved is that if we > run > out-of-memory, we can switch to nid bitmap searching in alloc_nid rather than > preloading free nid entry in build_free_nid whose performance is memory > sensitive. > Thoughts?
Hmm, in terms of performance, do we really suffer from memory pressure when preloading free nids? Thanks, > > Thanks, > > > be some trade-off though, we don't have a critical issue with this, FWIW. > > Can we expect to see some speed gains with this? How much? > > > > Thanks, > > > > On 11/30, Chao Yu wrote: > >> Previously, we use free nid list to manage free nid entry, so during nid > >> allocation, we can just pick up one entry from list header, which has > >> quite low overhead. > >> > >> But sadly, during initialization of free nid list, we should do lookup > >> combining with lots of different inner caches, including NAT page cache, > >> nat entry cache, curseg journal cache and free nid bitmap, so flow became > >> quite complicated. > >> > >> In this patch, we choose to obsolete old free nid management approach, > >> instead, we use existing free nid bitmap which has the same functionality > >> to manage free nid, in order to make free nid management codes more easy > >> to maintain. > >> > >> Signed-off-by: Chao Yu <[email protected]> > >> --- > >> v4: clean up codes. > >> fs/f2fs/checkpoint.c | 1 - > >> fs/f2fs/debug.c | 7 +- > >> fs/f2fs/f2fs.h | 9 +- > >> fs/f2fs/inode.c | 2 + > >> fs/f2fs/node.c | 487 > >> +++++++++++++++++---------------------------------- > >> fs/f2fs/node.h | 22 --- > >> fs/f2fs/segment.c | 5 - > >> fs/f2fs/shrinker.c | 14 -- > >> 8 files changed, 164 insertions(+), 383 deletions(-) > >> > >> diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c > >> index d1f160ae4959..885525a0d981 100644 > >> --- a/fs/f2fs/checkpoint.c > >> +++ b/fs/f2fs/checkpoint.c > >> @@ -1024,7 +1024,6 @@ static void __prepare_cp_block(struct f2fs_sb_info > >> *sbi) > >> struct f2fs_nm_info *nm_i = NM_I(sbi); > >> nid_t last_nid = nm_i->next_scan_nid; > >> > >> - next_free_nid(sbi, &last_nid); > >> ckpt->valid_block_count = cpu_to_le64(valid_user_blocks(sbi)); > >> ckpt->valid_node_count = cpu_to_le32(valid_node_count(sbi)); > >> ckpt->valid_inode_count = cpu_to_le32(valid_inode_count(sbi)); > >> diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c > >> index a66107b5cfff..413e031b10c4 100644 > >> --- a/fs/f2fs/debug.c > >> +++ b/fs/f2fs/debug.c > >> @@ -100,9 +100,8 @@ static void update_general_status(struct f2fs_sb_info > >> *sbi) > >> si->dirty_nats = NM_I(sbi)->dirty_nat_cnt; > >> si->sits = MAIN_SEGS(sbi); > >> si->dirty_sits = SIT_I(sbi)->dirty_sentries; > >> - si->free_nids = NM_I(sbi)->nid_cnt[FREE_NID]; > >> + si->free_nids = NM_I(sbi)->available_free_nids; > >> si->avail_nids = NM_I(sbi)->available_nids; > >> - si->alloc_nids = NM_I(sbi)->nid_cnt[PREALLOC_NID]; > >> si->bg_gc = sbi->bg_gc; > >> si->util_free = (int)(free_user_blocks(sbi) >> sbi->log_blocks_per_seg) > >> * 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg) > >> @@ -233,10 +232,6 @@ static void update_mem_info(struct f2fs_sb_info *sbi) > >> atomic_read(&SM_I(sbi)->dcc_info->discard_cmd_cnt); > >> } > >> > >> - /* free nids */ > >> - si->cache_mem += (NM_I(sbi)->nid_cnt[FREE_NID] + > >> - NM_I(sbi)->nid_cnt[PREALLOC_NID]) * > >> - sizeof(struct free_nid); > >> si->cache_mem += NM_I(sbi)->nat_cnt * sizeof(struct nat_entry); > >> si->cache_mem += NM_I(sbi)->dirty_nat_cnt * > >> sizeof(struct nat_entry_set); > >> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > >> index d92eba66263c..f08e0feb38c1 100644 > >> --- a/fs/f2fs/f2fs.h > >> +++ b/fs/f2fs/f2fs.h > >> @@ -723,14 +723,13 @@ struct f2fs_nm_info { > >> unsigned int nat_blocks; /* # of nat blocks */ > >> > >> /* free node ids management */ > >> - struct radix_tree_root free_nid_root;/* root of the free_nid cache */ > >> - struct list_head free_nid_list; /* list for free nids excluding > >> preallocated nids */ > >> - unsigned int nid_cnt[MAX_NID_STATE]; /* the number of free node id */ > >> - spinlock_t nid_list_lock; /* protect nid lists ops */ > >> + spinlock_t free_nid_lock; /* protect nid lists ops */ > >> struct mutex build_lock; /* lock for build free nids */ > >> unsigned char (*free_nid_bitmap)[NAT_ENTRY_BITMAP_SIZE]; > >> + unsigned char (*prealloc_nid_bitmap)[NAT_ENTRY_BITMAP_SIZE]; > >> unsigned char *nat_block_bitmap; > >> unsigned short *free_nid_count; /* free nid count of NAT block */ > >> + unsigned int available_free_nids; /* available free nid count in > >> bitmaps */ > >> > >> /* for checkpoint */ > >> char *nat_bitmap; /* NAT bitmap pointer */ > >> @@ -2622,11 +2621,9 @@ int fsync_node_pages(struct f2fs_sb_info *sbi, > >> struct inode *inode, > >> struct writeback_control *wbc, bool atomic); > >> int sync_node_pages(struct f2fs_sb_info *sbi, struct writeback_control > >> *wbc, > >> bool do_balance, enum iostat_type io_type); > >> -void build_free_nids(struct f2fs_sb_info *sbi, bool sync, bool mount); > >> bool alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid); > >> void alloc_nid_done(struct f2fs_sb_info *sbi, nid_t nid); > >> void alloc_nid_failed(struct f2fs_sb_info *sbi, nid_t nid); > >> -int try_to_free_nids(struct f2fs_sb_info *sbi, int nr_shrink); > >> void recover_inline_xattr(struct inode *inode, struct page *page); > >> int recover_xattr_data(struct inode *inode, struct page *page); > >> int recover_inode_page(struct f2fs_sb_info *sbi, struct page *page); > >> diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c > >> index 9684d53563f1..82f543e5c35b 100644 > >> --- a/fs/f2fs/inode.c > >> +++ b/fs/f2fs/inode.c > >> @@ -559,7 +559,9 @@ void f2fs_evict_inode(struct inode *inode) > >> add_ino_entry(sbi, inode->i_ino, UPDATE_INO); > >> } > >> if (is_inode_flag_set(inode, FI_FREE_NID)) { > >> + f2fs_lock_op(sbi); > >> alloc_nid_failed(sbi, inode->i_ino); > >> + f2fs_unlock_op(sbi); > >> clear_inode_flag(inode, FI_FREE_NID); > >> } else { > >> f2fs_bug_on(sbi, err && > >> diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c > >> index 80c37a094631..d2c9dcb0cbf8 100644 > >> --- a/fs/f2fs/node.c > >> +++ b/fs/f2fs/node.c > >> @@ -23,10 +23,7 @@ > >> #include "trace.h" > >> #include <trace/events/f2fs.h> > >> > >> -#define on_build_free_nids(nmi) mutex_is_locked(&(nm_i)->build_lock) > >> - > >> static struct kmem_cache *nat_entry_slab; > >> -static struct kmem_cache *free_nid_slab; > >> static struct kmem_cache *nat_entry_set_slab; > >> > >> bool available_free_memory(struct f2fs_sb_info *sbi, int type) > >> @@ -43,13 +40,9 @@ bool available_free_memory(struct f2fs_sb_info *sbi, > >> int type) > >> avail_ram = val.totalram - val.totalhigh; > >> > >> /* > >> - * give 25%, 25%, 50%, 50%, 50% memory for each components respectively > >> + * give 25%, 50%, 50%, 50% memory for each components respectively > >> */ > >> - if (type == FREE_NIDS) { > >> - mem_size = (nm_i->nid_cnt[FREE_NID] * > >> - sizeof(struct free_nid)) >> PAGE_SHIFT; > >> - res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 2); > >> - } else if (type == NAT_ENTRIES) { > >> + if (type == NAT_ENTRIES) { > >> mem_size = (nm_i->nat_cnt * sizeof(struct nat_entry)) >> > >> PAGE_SHIFT; > >> res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 2); > >> @@ -1774,259 +1767,171 @@ const struct address_space_operations > >> f2fs_node_aops = { > >> #endif > >> }; > >> > >> -static struct free_nid *__lookup_free_nid_list(struct f2fs_nm_info *nm_i, > >> - nid_t n) > >> -{ > >> - return radix_tree_lookup(&nm_i->free_nid_root, n); > >> -} > >> - > >> -static int __insert_free_nid(struct f2fs_sb_info *sbi, > >> - struct free_nid *i, enum nid_state state) > >> -{ > >> - struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - > >> - int err = radix_tree_insert(&nm_i->free_nid_root, i->nid, i); > >> - if (err) > >> - return err; > >> - > >> - f2fs_bug_on(sbi, state != i->state); > >> - nm_i->nid_cnt[state]++; > >> - if (state == FREE_NID) > >> - list_add_tail(&i->list, &nm_i->free_nid_list); > >> - return 0; > >> -} > >> - > >> -static void __remove_free_nid(struct f2fs_sb_info *sbi, > >> - struct free_nid *i, enum nid_state state) > >> -{ > >> - struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - > >> - f2fs_bug_on(sbi, state != i->state); > >> - nm_i->nid_cnt[state]--; > >> - if (state == FREE_NID) > >> - list_del(&i->list); > >> - radix_tree_delete(&nm_i->free_nid_root, i->nid); > >> -} > >> - > >> -static void __move_free_nid(struct f2fs_sb_info *sbi, struct free_nid *i, > >> - enum nid_state org_state, enum nid_state dst_state) > >> -{ > >> - struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - > >> - f2fs_bug_on(sbi, org_state != i->state); > >> - i->state = dst_state; > >> - nm_i->nid_cnt[org_state]--; > >> - nm_i->nid_cnt[dst_state]++; > >> - > >> - switch (dst_state) { > >> - case PREALLOC_NID: > >> - list_del(&i->list); > >> - break; > >> - case FREE_NID: > >> - list_add_tail(&i->list, &nm_i->free_nid_list); > >> - break; > >> - default: > >> - BUG_ON(1); > >> - } > >> -} > >> - > >> -static void update_free_nid_bitmap(struct f2fs_sb_info *sbi, nid_t nid, > >> - bool set, bool build) > >> +static bool update_free_nid_bitmap(struct f2fs_sb_info *sbi, > >> + nid_t nid, bool set) > >> { > >> struct f2fs_nm_info *nm_i = NM_I(sbi); > >> unsigned int nat_ofs = NAT_BLOCK_OFFSET(nid); > >> unsigned int nid_ofs = nid - START_NID(nid); > >> > >> if (!test_bit_le(nat_ofs, nm_i->nat_block_bitmap)) > >> - return; > >> + return false; > >> > >> if (set) { > >> if (test_bit_le(nid_ofs, nm_i->free_nid_bitmap[nat_ofs])) > >> - return; > >> + return false; > >> __set_bit_le(nid_ofs, nm_i->free_nid_bitmap[nat_ofs]); > >> nm_i->free_nid_count[nat_ofs]++; > >> + nm_i->available_free_nids++; > >> } else { > >> if (!test_bit_le(nid_ofs, nm_i->free_nid_bitmap[nat_ofs])) > >> - return; > >> + return false; > >> __clear_bit_le(nid_ofs, nm_i->free_nid_bitmap[nat_ofs]); > >> - if (!build) > >> - nm_i->free_nid_count[nat_ofs]--; > >> + nm_i->free_nid_count[nat_ofs]--; > >> + nm_i->available_free_nids--; > >> + } > >> + return true; > >> +} > >> + > >> +static void update_prealloc_nid_bitmap(struct f2fs_sb_info *sbi, > >> + nid_t nid, bool set) > >> +{ > >> + struct f2fs_nm_info *nm_i = NM_I(sbi); > >> + unsigned int nat_ofs = NAT_BLOCK_OFFSET(nid); > >> + unsigned int nid_ofs = nid - START_NID(nid); > >> + > >> + if (set) { > >> + f2fs_bug_on(sbi, test_bit_le(nid_ofs, > >> + nm_i->prealloc_nid_bitmap[nat_ofs])); > >> + __set_bit_le(nid_ofs, nm_i->prealloc_nid_bitmap[nat_ofs]); > >> + } else { > >> + f2fs_bug_on(sbi, !test_bit_le(nid_ofs, > >> + nm_i->prealloc_nid_bitmap[nat_ofs])); > >> + __clear_bit_le(nid_ofs, nm_i->prealloc_nid_bitmap[nat_ofs]); > >> } > >> } > >> > >> /* return if the nid is recognized as free */ > >> -static bool add_free_nid(struct f2fs_sb_info *sbi, > >> - nid_t nid, bool build, bool update) > >> +static bool add_free_nid(struct f2fs_sb_info *sbi, nid_t nid) > >> { > >> struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - struct free_nid *i, *e; > >> struct nat_entry *ne; > >> - int err = -EINVAL; > >> - bool ret = false; > >> + unsigned int nat_ofs, nid_ofs; > >> > >> /* 0 nid should not be used */ > >> if (unlikely(nid == 0)) > >> return false; > >> > >> - i = f2fs_kmem_cache_alloc(free_nid_slab, GFP_NOFS); > >> - i->nid = nid; > >> - i->state = FREE_NID; > >> - > >> - radix_tree_preload(GFP_NOFS | __GFP_NOFAIL); > >> - > >> - spin_lock(&nm_i->nid_list_lock); > >> + ne = __lookup_nat_cache(nm_i, nid); > >> + if (ne && (!get_nat_flag(ne, IS_CHECKPOINTED) || > >> + nat_get_blkaddr(ne) != NULL_ADDR)) > >> + return false; > >> > >> - if (build) { > >> - /* > >> - * Thread A Thread B > >> - * - f2fs_create > >> - * - f2fs_new_inode > >> - * - alloc_nid > >> - * - __insert_nid_to_list(PREALLOC_NID) > >> - * - f2fs_balance_fs_bg > >> - * - build_free_nids > >> - * - __build_free_nids > >> - * - scan_nat_page > >> - * - add_free_nid > >> - * - __lookup_nat_cache > >> - * - f2fs_add_link > >> - * - init_inode_metadata > >> - * - new_inode_page > >> - * - new_node_page > >> - * - set_node_addr > >> - * - alloc_nid_done > >> - * - __remove_nid_from_list(PREALLOC_NID) > >> - * - __insert_nid_to_list(FREE_NID) > >> - */ > >> - ne = __lookup_nat_cache(nm_i, nid); > >> - if (ne && (!get_nat_flag(ne, IS_CHECKPOINTED) || > >> - nat_get_blkaddr(ne) != NULL_ADDR)) > >> - goto err_out; > >> - > >> - e = __lookup_free_nid_list(nm_i, nid); > >> - if (e) { > >> - if (e->state == FREE_NID) > >> - ret = true; > >> - goto err_out; > >> - } > >> - } > >> - ret = true; > >> - err = __insert_free_nid(sbi, i, FREE_NID); > >> -err_out: > >> - if (update) { > >> - update_free_nid_bitmap(sbi, nid, ret, build); > >> - if (!build) > >> - nm_i->available_nids++; > >> - } > >> - spin_unlock(&nm_i->nid_list_lock); > >> - radix_tree_preload_end(); > >> + nat_ofs = NAT_BLOCK_OFFSET(nid); > >> + nid_ofs = nid - START_NID(nid); > >> + if (test_bit_le(nid_ofs, nm_i->prealloc_nid_bitmap[nat_ofs])) > >> + return false; > >> > >> - if (err) > >> - kmem_cache_free(free_nid_slab, i); > >> - return ret; > >> + update_free_nid_bitmap(sbi, nid, true); > >> + return true; > >> } > >> > >> -static void remove_free_nid(struct f2fs_sb_info *sbi, nid_t nid) > >> +static void scan_curseg_cache(struct f2fs_sb_info *sbi, nid_t start_nid, > >> + nid_t end_nid) > >> { > >> - struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - struct free_nid *i; > >> - bool need_free = false; > >> + struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); > >> + struct f2fs_journal *journal = curseg->journal; > >> + int i; > >> > >> - spin_lock(&nm_i->nid_list_lock); > >> - i = __lookup_free_nid_list(nm_i, nid); > >> - if (i && i->state == FREE_NID) { > >> - __remove_free_nid(sbi, i, FREE_NID); > >> - need_free = true; > >> - } > >> - spin_unlock(&nm_i->nid_list_lock); > >> + down_read(&curseg->journal_rwsem); > >> + for (i = 0; i < nats_in_cursum(journal); i++) { > >> + block_t addr; > >> + nid_t nid = le32_to_cpu(nid_in_journal(journal, i)); > >> + > >> + if (nid < start_nid || nid >= end_nid) > >> + continue; > >> + > >> + addr = le32_to_cpu(nat_in_journal(journal, i).block_addr); > >> + > >> + f2fs_bug_on(sbi, addr == NEW_ADDR); > >> > >> - if (need_free) > >> - kmem_cache_free(free_nid_slab, i); > >> + spin_lock(&NM_I(sbi)->free_nid_lock); > >> + if (addr == NULL_ADDR) > >> + add_free_nid(sbi, nid); > >> + else > >> + update_free_nid_bitmap(sbi, nid, false); > >> + spin_unlock(&NM_I(sbi)->free_nid_lock); > >> + } > >> + up_read(&curseg->journal_rwsem); > >> } > >> > >> -static void scan_nat_page(struct f2fs_sb_info *sbi, > >> - struct page *nat_page, nid_t start_nid) > >> +static void scan_nat_page(struct f2fs_sb_info *sbi, nid_t nid) > >> { > >> struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - struct f2fs_nat_block *nat_blk = page_address(nat_page); > >> + struct page *page; > >> + struct f2fs_nat_block *nat_blk; > >> block_t blk_addr; > >> - unsigned int nat_ofs = NAT_BLOCK_OFFSET(start_nid); > >> + unsigned int nat_ofs = NAT_BLOCK_OFFSET(nid); > >> + nid_t start_nid = nid; > >> int i; > >> > >> + if (test_bit_le(nat_ofs, nm_i->nat_block_bitmap)) > >> + return; > >> + > >> + page = get_current_nat_page(sbi, nid); > >> + nat_blk = page_address(page); > >> + > >> __set_bit_le(nat_ofs, nm_i->nat_block_bitmap); > >> > >> - i = start_nid % NAT_ENTRY_PER_BLOCK; > >> + i = nid % NAT_ENTRY_PER_BLOCK; > >> > >> - for (; i < NAT_ENTRY_PER_BLOCK; i++, start_nid++) { > >> - if (unlikely(start_nid >= nm_i->max_nid)) > >> + for (; i < NAT_ENTRY_PER_BLOCK; i++, nid++) { > >> + if (unlikely(nid >= nm_i->max_nid)) > >> break; > >> > >> blk_addr = le32_to_cpu(nat_blk->entries[i].block_addr); > >> f2fs_bug_on(sbi, blk_addr == NEW_ADDR); > >> if (blk_addr == NULL_ADDR) { > >> - add_free_nid(sbi, start_nid, true, true); > >> - } else { > >> - spin_lock(&NM_I(sbi)->nid_list_lock); > >> - update_free_nid_bitmap(sbi, start_nid, false, true); > >> - spin_unlock(&NM_I(sbi)->nid_list_lock); > >> + spin_lock(&nm_i->free_nid_lock); > >> + add_free_nid(sbi, nid); > >> + spin_unlock(&nm_i->free_nid_lock); > >> } > >> } > >> -} > >> - > >> -static void scan_curseg_cache(struct f2fs_sb_info *sbi) > >> -{ > >> - struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); > >> - struct f2fs_journal *journal = curseg->journal; > >> - int i; > >> > >> - down_read(&curseg->journal_rwsem); > >> - for (i = 0; i < nats_in_cursum(journal); i++) { > >> - block_t addr; > >> - nid_t nid; > >> + f2fs_put_page(page, 1); > >> > >> - addr = le32_to_cpu(nat_in_journal(journal, i).block_addr); > >> - nid = le32_to_cpu(nid_in_journal(journal, i)); > >> - if (addr == NULL_ADDR) > >> - add_free_nid(sbi, nid, true, false); > >> - else > >> - remove_free_nid(sbi, nid); > >> - } > >> - up_read(&curseg->journal_rwsem); > >> + /* find free nids from current sum_pages */ > >> + scan_curseg_cache(sbi, start_nid, start_nid + NAT_ENTRY_PER_BLOCK); > >> } > >> > >> -static void scan_free_nid_bits(struct f2fs_sb_info *sbi) > >> +static nid_t lookup_free_nid_bitmap(struct f2fs_sb_info *sbi) > >> { > >> struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - unsigned int i, idx; > >> - nid_t nid; > >> - > >> - down_read(&nm_i->nat_tree_lock); > >> + unsigned int i; > >> + nid_t nid = 0; > >> > >> for (i = 0; i < nm_i->nat_blocks; i++) { > >> + unsigned int idx = 0; > >> + > >> if (!test_bit_le(i, nm_i->nat_block_bitmap)) > >> continue; > >> if (!nm_i->free_nid_count[i]) > >> continue; > >> - for (idx = 0; idx < NAT_ENTRY_PER_BLOCK; idx++) { > >> - idx = find_next_bit_le(nm_i->free_nid_bitmap[i], > >> - NAT_ENTRY_PER_BLOCK, idx); > >> - if (idx >= NAT_ENTRY_PER_BLOCK) > >> - break; > >> > >> - nid = i * NAT_ENTRY_PER_BLOCK + idx; > >> - add_free_nid(sbi, nid, true, false); > >> + idx = find_next_bit_le(nm_i->free_nid_bitmap[i], > >> + NAT_ENTRY_PER_BLOCK, idx); > >> + if (idx >= NAT_ENTRY_PER_BLOCK) > >> + continue; > >> > >> - if (nm_i->nid_cnt[FREE_NID] >= MAX_FREE_NIDS) > >> - goto out; > >> - } > >> + nid = i * NAT_ENTRY_PER_BLOCK + idx; > >> + break; > >> } > >> -out: > >> - scan_curseg_cache(sbi); > >> > >> - up_read(&nm_i->nat_tree_lock); > >> + f2fs_bug_on(sbi, !nid); > >> + return nid; > >> } > >> > >> -static void __build_free_nids(struct f2fs_sb_info *sbi, bool sync, bool > >> mount) > >> +static void __build_free_nids(struct f2fs_sb_info *sbi, bool mount) > >> { > >> struct f2fs_nm_info *nm_i = NM_I(sbi); > >> int i = 0; > >> @@ -2036,59 +1941,36 @@ static void __build_free_nids(struct f2fs_sb_info > >> *sbi, bool sync, bool mount) > >> nid = 0; > >> > >> /* Enough entries */ > >> - if (nm_i->nid_cnt[FREE_NID] >= NAT_ENTRY_PER_BLOCK) > >> - return; > >> - > >> - if (!sync && !available_free_memory(sbi, FREE_NIDS)) > >> + if (!mount && nm_i->available_free_nids >= NAT_ENTRY_PER_BLOCK) > >> return; > >> > >> - if (!mount) { > >> - /* try to find free nids in free_nid_bitmap */ > >> - scan_free_nid_bits(sbi); > >> - > >> - if (nm_i->nid_cnt[FREE_NID] >= NAT_ENTRY_PER_BLOCK) > >> - return; > >> - } > >> - > >> /* readahead nat pages to be scanned */ > >> ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nid), FREE_NID_PAGES, > >> META_NAT, true); > >> > >> down_read(&nm_i->nat_tree_lock); > >> > >> - while (1) { > >> - if (!test_bit_le(NAT_BLOCK_OFFSET(nid), > >> - nm_i->nat_block_bitmap)) { > >> - struct page *page = get_current_nat_page(sbi, nid); > >> - > >> - scan_nat_page(sbi, page, nid); > >> - f2fs_put_page(page, 1); > >> - } > >> + do { > >> + scan_nat_page(sbi, nid); > >> > >> nid += (NAT_ENTRY_PER_BLOCK - (nid % NAT_ENTRY_PER_BLOCK)); > >> if (unlikely(nid >= nm_i->max_nid)) > >> nid = 0; > >> - > >> - if (++i >= FREE_NID_PAGES) > >> - break; > >> - } > >> + } while (++i < FREE_NID_PAGES); > >> > >> /* go to the next free nat pages to find free nids abundantly */ > >> nm_i->next_scan_nid = nid; > >> > >> - /* find free nids from current sum_pages */ > >> - scan_curseg_cache(sbi); > >> - > >> up_read(&nm_i->nat_tree_lock); > >> > >> ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nm_i->next_scan_nid), > >> nm_i->ra_nid_pages, META_NAT, false); > >> } > >> > >> -void build_free_nids(struct f2fs_sb_info *sbi, bool sync, bool mount) > >> +void build_free_nids(struct f2fs_sb_info *sbi, bool mount) > >> { > >> mutex_lock(&NM_I(sbi)->build_lock); > >> - __build_free_nids(sbi, sync, mount); > >> + __build_free_nids(sbi, mount); > >> mutex_unlock(&NM_I(sbi)->build_lock); > >> } > >> > >> @@ -2100,7 +1982,6 @@ void build_free_nids(struct f2fs_sb_info *sbi, bool > >> sync, bool mount) > >> bool alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid) > >> { > >> struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - struct free_nid *i = NULL; > >> retry: > >> #ifdef CONFIG_F2FS_FAULT_INJECTION > >> if (time_to_inject(sbi, FAULT_ALLOC_NID)) { > >> @@ -2108,32 +1989,34 @@ bool alloc_nid(struct f2fs_sb_info *sbi, nid_t > >> *nid) > >> return false; > >> } > >> #endif > >> - spin_lock(&nm_i->nid_list_lock); > >> + > >> + spin_lock(&nm_i->free_nid_lock); > >> > >> if (unlikely(nm_i->available_nids == 0)) { > >> - spin_unlock(&nm_i->nid_list_lock); > >> + spin_unlock(&nm_i->free_nid_lock); > >> return false; > >> } > >> > >> /* We should not use stale free nids created by build_free_nids */ > >> - if (nm_i->nid_cnt[FREE_NID] && !on_build_free_nids(nm_i)) { > >> - f2fs_bug_on(sbi, list_empty(&nm_i->free_nid_list)); > >> - i = list_first_entry(&nm_i->free_nid_list, > >> - struct free_nid, list); > >> - *nid = i->nid; > >> + if (nm_i->available_free_nids && mutex_trylock(&nm_i->build_lock)) { > >> + bool updated; > >> + > >> + *nid = lookup_free_nid_bitmap(sbi); > >> > >> - __move_free_nid(sbi, i, FREE_NID, PREALLOC_NID); > >> + updated = update_free_nid_bitmap(sbi, *nid, false); > >> + f2fs_bug_on(sbi, !updated); > >> nm_i->available_nids--; > >> > >> - update_free_nid_bitmap(sbi, *nid, false, false); > >> + update_prealloc_nid_bitmap(sbi, *nid, true); > >> > >> - spin_unlock(&nm_i->nid_list_lock); > >> + spin_unlock(&nm_i->free_nid_lock); > >> + mutex_unlock(&nm_i->build_lock); > >> return true; > >> } > >> - spin_unlock(&nm_i->nid_list_lock); > >> + spin_unlock(&nm_i->free_nid_lock); > >> > >> /* Let's scan nat pages and its caches to get free nids */ > >> - build_free_nids(sbi, true, false); > >> + build_free_nids(sbi, false); > >> goto retry; > >> } > >> > >> @@ -2143,15 +2026,10 @@ bool alloc_nid(struct f2fs_sb_info *sbi, nid_t > >> *nid) > >> void alloc_nid_done(struct f2fs_sb_info *sbi, nid_t nid) > >> { > >> struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - struct free_nid *i; > >> - > >> - spin_lock(&nm_i->nid_list_lock); > >> - i = __lookup_free_nid_list(nm_i, nid); > >> - f2fs_bug_on(sbi, !i); > >> - __remove_free_nid(sbi, i, PREALLOC_NID); > >> - spin_unlock(&nm_i->nid_list_lock); > >> > >> - kmem_cache_free(free_nid_slab, i); > >> + spin_lock(&nm_i->free_nid_lock); > >> + update_prealloc_nid_bitmap(sbi, nid, false); > >> + spin_unlock(&nm_i->free_nid_lock); > >> } > >> > >> /* > >> @@ -2160,59 +2038,21 @@ void alloc_nid_done(struct f2fs_sb_info *sbi, > >> nid_t nid) > >> void alloc_nid_failed(struct f2fs_sb_info *sbi, nid_t nid) > >> { > >> struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - struct free_nid *i; > >> - bool need_free = false; > >> > >> if (!nid) > >> return; > >> > >> - spin_lock(&nm_i->nid_list_lock); > >> - i = __lookup_free_nid_list(nm_i, nid); > >> - f2fs_bug_on(sbi, !i); > >> - > >> - if (!available_free_memory(sbi, FREE_NIDS)) { > >> - __remove_free_nid(sbi, i, PREALLOC_NID); > >> - need_free = true; > >> - } else { > >> - __move_free_nid(sbi, i, PREALLOC_NID, FREE_NID); > >> - } > >> - > >> - nm_i->available_nids++; > >> - > >> - update_free_nid_bitmap(sbi, nid, true, false); > >> - > >> - spin_unlock(&nm_i->nid_list_lock); > >> - > >> - if (need_free) > >> - kmem_cache_free(free_nid_slab, i); > >> -} > >> - > >> -int try_to_free_nids(struct f2fs_sb_info *sbi, int nr_shrink) > >> -{ > >> - struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - struct free_nid *i, *next; > >> - int nr = nr_shrink; > >> - > >> - if (nm_i->nid_cnt[FREE_NID] <= MAX_FREE_NIDS) > >> - return 0; > >> - > >> - if (!mutex_trylock(&nm_i->build_lock)) > >> - return 0; > >> + mutex_lock(&nm_i->build_lock); > >> + down_read(&nm_i->nat_tree_lock); > >> + spin_lock(&nm_i->free_nid_lock); > >> > >> - spin_lock(&nm_i->nid_list_lock); > >> - list_for_each_entry_safe(i, next, &nm_i->free_nid_list, list) { > >> - if (nr_shrink <= 0 || > >> - nm_i->nid_cnt[FREE_NID] <= MAX_FREE_NIDS) > >> - break; > >> + update_prealloc_nid_bitmap(sbi, nid, false); > >> > >> - __remove_free_nid(sbi, i, FREE_NID); > >> - kmem_cache_free(free_nid_slab, i); > >> - nr_shrink--; > >> - } > >> - spin_unlock(&nm_i->nid_list_lock); > >> + if (add_free_nid(sbi, nid)) > >> + nm_i->available_nids++; > >> + spin_unlock(&nm_i->free_nid_lock); > >> + up_read(&nm_i->nat_tree_lock); > >> mutex_unlock(&nm_i->build_lock); > >> - > >> - return nr - nr_shrink; > >> } > >> > >> void recover_inline_xattr(struct inode *inode, struct page *page) > >> @@ -2303,7 +2143,10 @@ int recover_inode_page(struct f2fs_sb_info *sbi, > >> struct page *page) > >> } > >> > >> /* Should not use this inode from free nid list */ > >> - remove_free_nid(sbi, ino); > >> + spin_lock(&NM_I(sbi)->free_nid_lock); > >> + update_free_nid_bitmap(sbi, ino, false); > >> + NM_I(sbi)->available_nids--; > >> + spin_unlock(&NM_I(sbi)->free_nid_lock); > >> > >> if (!PageUptodate(ipage)) > >> SetPageUptodate(ipage); > >> @@ -2408,9 +2251,9 @@ static void remove_nats_in_journal(struct > >> f2fs_sb_info *sbi) > >> */ > >> if (!get_nat_flag(ne, IS_DIRTY) && > >> le32_to_cpu(raw_ne.block_addr) == NULL_ADDR) { > >> - spin_lock(&nm_i->nid_list_lock); > >> + spin_lock(&nm_i->free_nid_lock); > >> nm_i->available_nids--; > >> - spin_unlock(&nm_i->nid_list_lock); > >> + spin_unlock(&nm_i->free_nid_lock); > >> } > >> > >> __set_nat_cache_dirty(nm_i, ne); > >> @@ -2519,11 +2362,14 @@ static void __flush_nat_entry_set(struct > >> f2fs_sb_info *sbi, > >> nat_reset_flag(ne); > >> __clear_nat_cache_dirty(NM_I(sbi), set, ne); > >> if (nat_get_blkaddr(ne) == NULL_ADDR) { > >> - add_free_nid(sbi, nid, false, true); > >> + spin_lock(&NM_I(sbi)->free_nid_lock); > >> + add_free_nid(sbi, nid); > >> + NM_I(sbi)->available_nids++; > >> + spin_unlock(&NM_I(sbi)->free_nid_lock); > >> } else { > >> - spin_lock(&NM_I(sbi)->nid_list_lock); > >> - update_free_nid_bitmap(sbi, nid, false, false); > >> - spin_unlock(&NM_I(sbi)->nid_list_lock); > >> + spin_lock(&NM_I(sbi)->free_nid_lock); > >> + update_free_nid_bitmap(sbi, nid, false); > >> + spin_unlock(&NM_I(sbi)->free_nid_lock); > >> } > >> } > >> > >> @@ -2647,10 +2493,10 @@ static inline void load_free_nid_bitmap(struct > >> f2fs_sb_info *sbi) > >> nid = i * NAT_ENTRY_PER_BLOCK; > >> last_nid = nid + NAT_ENTRY_PER_BLOCK; > >> > >> - spin_lock(&NM_I(sbi)->nid_list_lock); > >> + spin_lock(&NM_I(sbi)->free_nid_lock); > >> for (; nid < last_nid; nid++) > >> - update_free_nid_bitmap(sbi, nid, true, true); > >> - spin_unlock(&NM_I(sbi)->nid_list_lock); > >> + update_free_nid_bitmap(sbi, nid, true); > >> + spin_unlock(&NM_I(sbi)->free_nid_lock); > >> } > >> > >> for (i = 0; i < nm_i->nat_blocks; i++) { > >> @@ -2660,6 +2506,8 @@ static inline void load_free_nid_bitmap(struct > >> f2fs_sb_info *sbi) > >> > >> __set_bit_le(i, nm_i->nat_block_bitmap); > >> } > >> + > >> + scan_curseg_cache(sbi, 0, nm_i->max_nid); > >> } > >> > >> static int init_node_manager(struct f2fs_sb_info *sbi) > >> @@ -2680,21 +2528,18 @@ static int init_node_manager(struct f2fs_sb_info > >> *sbi) > >> /* not used nids: 0, node, meta, (and root counted as valid node) */ > >> nm_i->available_nids = nm_i->max_nid - sbi->total_valid_node_count - > >> sbi->nquota_files - F2FS_RESERVED_NODE_NUM; > >> - nm_i->nid_cnt[FREE_NID] = 0; > >> - nm_i->nid_cnt[PREALLOC_NID] = 0; > >> + nm_i->available_free_nids = 0; > >> nm_i->nat_cnt = 0; > >> nm_i->ram_thresh = DEF_RAM_THRESHOLD; > >> nm_i->ra_nid_pages = DEF_RA_NID_PAGES; > >> nm_i->dirty_nats_ratio = DEF_DIRTY_NAT_RATIO_THRESHOLD; > >> > >> - INIT_RADIX_TREE(&nm_i->free_nid_root, GFP_ATOMIC); > >> - INIT_LIST_HEAD(&nm_i->free_nid_list); > >> INIT_RADIX_TREE(&nm_i->nat_root, GFP_NOIO); > >> INIT_RADIX_TREE(&nm_i->nat_set_root, GFP_NOIO); > >> INIT_LIST_HEAD(&nm_i->nat_entries); > >> > >> mutex_init(&nm_i->build_lock); > >> - spin_lock_init(&nm_i->nid_list_lock); > >> + spin_lock_init(&nm_i->free_nid_lock); > >> init_rwsem(&nm_i->nat_tree_lock); > >> > >> nm_i->next_scan_nid = le32_to_cpu(sbi->ckpt->next_free_nid); > >> @@ -2731,6 +2576,11 @@ static int init_free_nid_cache(struct f2fs_sb_info > >> *sbi) > >> if (!nm_i->free_nid_bitmap) > >> return -ENOMEM; > >> > >> + nm_i->prealloc_nid_bitmap = f2fs_kvzalloc(sbi, nm_i->nat_blocks * > >> + NAT_ENTRY_BITMAP_SIZE, GFP_KERNEL); > >> + if (!nm_i->prealloc_nid_bitmap) > >> + return -ENOMEM; > >> + > >> nm_i->nat_block_bitmap = f2fs_kvzalloc(sbi, nm_i->nat_blocks / 8, > >> GFP_KERNEL); > >> if (!nm_i->nat_block_bitmap) > >> @@ -2763,14 +2613,13 @@ int build_node_manager(struct f2fs_sb_info *sbi) > >> /* load free nid status from nat_bits table */ > >> load_free_nid_bitmap(sbi); > >> > >> - build_free_nids(sbi, true, true); > >> + build_free_nids(sbi, true); > >> return 0; > >> } > >> > >> void destroy_node_manager(struct f2fs_sb_info *sbi) > >> { > >> struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - struct free_nid *i, *next_i; > >> struct nat_entry *natvec[NATVEC_SIZE]; > >> struct nat_entry_set *setvec[SETVEC_SIZE]; > >> nid_t nid = 0; > >> @@ -2779,19 +2628,6 @@ void destroy_node_manager(struct f2fs_sb_info *sbi) > >> if (!nm_i) > >> return; > >> > >> - /* destroy free nid list */ > >> - spin_lock(&nm_i->nid_list_lock); > >> - list_for_each_entry_safe(i, next_i, &nm_i->free_nid_list, list) { > >> - __remove_free_nid(sbi, i, FREE_NID); > >> - spin_unlock(&nm_i->nid_list_lock); > >> - kmem_cache_free(free_nid_slab, i); > >> - spin_lock(&nm_i->nid_list_lock); > >> - } > >> - f2fs_bug_on(sbi, nm_i->nid_cnt[FREE_NID]); > >> - f2fs_bug_on(sbi, nm_i->nid_cnt[PREALLOC_NID]); > >> - f2fs_bug_on(sbi, !list_empty(&nm_i->free_nid_list)); > >> - spin_unlock(&nm_i->nid_list_lock); > >> - > >> /* destroy nat cache */ > >> down_write(&nm_i->nat_tree_lock); > >> while ((found = __gang_lookup_nat_cache(nm_i, > >> @@ -2822,6 +2658,7 @@ void destroy_node_manager(struct f2fs_sb_info *sbi) > >> > >> kvfree(nm_i->nat_block_bitmap); > >> kvfree(nm_i->free_nid_bitmap); > >> + kvfree(nm_i->prealloc_nid_bitmap); > >> kvfree(nm_i->free_nid_count); > >> > >> kfree(nm_i->nat_bitmap); > >> @@ -2840,19 +2677,12 @@ int __init create_node_manager_caches(void) > >> if (!nat_entry_slab) > >> goto fail; > >> > >> - free_nid_slab = f2fs_kmem_cache_create("free_nid", > >> - sizeof(struct free_nid)); > >> - if (!free_nid_slab) > >> - goto destroy_nat_entry; > >> - > >> nat_entry_set_slab = f2fs_kmem_cache_create("nat_entry_set", > >> sizeof(struct nat_entry_set)); > >> if (!nat_entry_set_slab) > >> - goto destroy_free_nid; > >> + goto destroy_nat_entry; > >> return 0; > >> > >> -destroy_free_nid: > >> - kmem_cache_destroy(free_nid_slab); > >> destroy_nat_entry: > >> kmem_cache_destroy(nat_entry_slab); > >> fail: > >> @@ -2862,6 +2692,5 @@ int __init create_node_manager_caches(void) > >> void destroy_node_manager_caches(void) > >> { > >> kmem_cache_destroy(nat_entry_set_slab); > >> - kmem_cache_destroy(free_nid_slab); > >> kmem_cache_destroy(nat_entry_slab); > >> } > >> diff --git a/fs/f2fs/node.h b/fs/f2fs/node.h > >> index 0ee3e5ff49a3..d5cf8af70c90 100644 > >> --- a/fs/f2fs/node.h > >> +++ b/fs/f2fs/node.h > >> @@ -135,7 +135,6 @@ static inline bool excess_cached_nats(struct > >> f2fs_sb_info *sbi) > >> } > >> > >> enum mem_type { > >> - FREE_NIDS, /* indicates the free nid list */ > >> NAT_ENTRIES, /* indicates the cached nat entry */ > >> DIRTY_DENTS, /* indicates dirty dentry pages */ > >> INO_ENTRIES, /* indicates inode entries */ > >> @@ -151,27 +150,6 @@ struct nat_entry_set { > >> unsigned int entry_cnt; /* the # of nat entries in set */ > >> }; > >> > >> -struct free_nid { > >> - struct list_head list; /* for free node id list */ > >> - nid_t nid; /* node id */ > >> - int state; /* in use or not: FREE_NID or PREALLOC_NID */ > >> -}; > >> - > >> -static inline void next_free_nid(struct f2fs_sb_info *sbi, nid_t *nid) > >> -{ > >> - struct f2fs_nm_info *nm_i = NM_I(sbi); > >> - struct free_nid *fnid; > >> - > >> - spin_lock(&nm_i->nid_list_lock); > >> - if (nm_i->nid_cnt[FREE_NID] <= 0) { > >> - spin_unlock(&nm_i->nid_list_lock); > >> - return; > >> - } > >> - fnid = list_first_entry(&nm_i->free_nid_list, struct free_nid, list); > >> - *nid = fnid->nid; > >> - spin_unlock(&nm_i->nid_list_lock); > >> -} > >> - > >> /* > >> * inline functions > >> */ > >> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c > >> index 176a2b97e6d3..c9a0563907aa 100644 > >> --- a/fs/f2fs/segment.c > >> +++ b/fs/f2fs/segment.c > >> @@ -482,11 +482,6 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi) > >> if (!available_free_memory(sbi, NAT_ENTRIES)) > >> try_to_free_nats(sbi, NAT_ENTRY_PER_BLOCK); > >> > >> - if (!available_free_memory(sbi, FREE_NIDS)) > >> - try_to_free_nids(sbi, MAX_FREE_NIDS); > >> - else > >> - build_free_nids(sbi, false, false); > >> - > >> if (!is_idle(sbi) && !excess_dirty_nats(sbi)) > >> return; > >> > >> diff --git a/fs/f2fs/shrinker.c b/fs/f2fs/shrinker.c > >> index 0b5664a1a6cc..7123bcb3cb62 100644 > >> --- a/fs/f2fs/shrinker.c > >> +++ b/fs/f2fs/shrinker.c > >> @@ -26,13 +26,6 @@ static unsigned long __count_nat_entries(struct > >> f2fs_sb_info *sbi) > >> return count > 0 ? count : 0; > >> } > >> > >> -static unsigned long __count_free_nids(struct f2fs_sb_info *sbi) > >> -{ > >> - long count = NM_I(sbi)->nid_cnt[FREE_NID] - MAX_FREE_NIDS; > >> - > >> - return count > 0 ? count : 0; > >> -} > >> - > >> static unsigned long __count_extent_cache(struct f2fs_sb_info *sbi) > >> { > >> return atomic_read(&sbi->total_zombie_tree) + > >> @@ -64,9 +57,6 @@ unsigned long f2fs_shrink_count(struct shrinker *shrink, > >> /* shrink clean nat cache entries */ > >> count += __count_nat_entries(sbi); > >> > >> - /* count free nids cache entries */ > >> - count += __count_free_nids(sbi); > >> - > >> spin_lock(&f2fs_list_lock); > >> p = p->next; > >> mutex_unlock(&sbi->umount_mutex); > >> @@ -111,10 +101,6 @@ unsigned long f2fs_shrink_scan(struct shrinker > >> *shrink, > >> if (freed < nr) > >> freed += try_to_free_nats(sbi, nr - freed); > >> > >> - /* shrink free nids cache entries */ > >> - if (freed < nr) > >> - freed += try_to_free_nids(sbi, nr - freed); > >> - > >> spin_lock(&f2fs_list_lock); > >> p = p->next; > >> list_move_tail(&sbi->s_list, &f2fs_list); > >> -- > >> 2.15.0.55.gc2ece9dc4de6 > > > > . > >
