Revert "f2fs: resync with upstream 3.4 branch (forced update)"
This reverts commit 6a1be380100e402aacca6a0a3ac829c059768d79.
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 6aeed5b..0b4710c 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -22,7 +22,7 @@
#include "segment.h"
#include <trace/events/f2fs.h>
-static struct kmem_cache *ino_entry_slab;
+static struct kmem_cache *orphan_entry_slab;
static struct kmem_cache *inode_entry_slab;
/*
@@ -282,120 +282,72 @@
.set_page_dirty = f2fs_set_meta_page_dirty,
};
-static void __add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
-{
- struct ino_entry *e;
-retry:
- spin_lock(&sbi->ino_lock[type]);
-
- e = radix_tree_lookup(&sbi->ino_root[type], ino);
- if (!e) {
- e = kmem_cache_alloc(ino_entry_slab, GFP_ATOMIC);
- if (!e) {
- spin_unlock(&sbi->ino_lock[type]);
- goto retry;
- }
- if (radix_tree_insert(&sbi->ino_root[type], ino, e)) {
- spin_unlock(&sbi->ino_lock[type]);
- kmem_cache_free(ino_entry_slab, e);
- goto retry;
- }
- memset(e, 0, sizeof(struct ino_entry));
- e->ino = ino;
-
- list_add_tail(&e->list, &sbi->ino_list[type]);
- }
- spin_unlock(&sbi->ino_lock[type]);
-}
-
-static void __remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
-{
- struct ino_entry *e;
-
- spin_lock(&sbi->ino_lock[type]);
- e = radix_tree_lookup(&sbi->ino_root[type], ino);
- if (e) {
- list_del(&e->list);
- radix_tree_delete(&sbi->ino_root[type], ino);
- if (type == ORPHAN_INO)
- sbi->n_orphans--;
- spin_unlock(&sbi->ino_lock[type]);
- kmem_cache_free(ino_entry_slab, e);
- return;
- }
- spin_unlock(&sbi->ino_lock[type]);
-}
-
-void add_dirty_inode(struct f2fs_sb_info *sbi, nid_t ino, int type)
-{
- /* add new dirty ino entry into list */
- __add_ino_entry(sbi, ino, type);
-}
-
-void remove_dirty_inode(struct f2fs_sb_info *sbi, nid_t ino, int type)
-{
- /* remove dirty ino entry from list */
- __remove_ino_entry(sbi, ino, type);
-}
-
-/* mode should be APPEND_INO or UPDATE_INO */
-bool exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode)
-{
- struct ino_entry *e;
- spin_lock(&sbi->ino_lock[mode]);
- e = radix_tree_lookup(&sbi->ino_root[mode], ino);
- spin_unlock(&sbi->ino_lock[mode]);
- return e ? true : false;
-}
-
-static void release_dirty_inode(struct f2fs_sb_info *sbi)
-{
- struct ino_entry *e, *tmp;
- int i;
-
- for (i = APPEND_INO; i <= UPDATE_INO; i++) {
- spin_lock(&sbi->ino_lock[i]);
- list_for_each_entry_safe(e, tmp, &sbi->ino_list[i], list) {
- list_del(&e->list);
- radix_tree_delete(&sbi->ino_root[i], e->ino);
- kmem_cache_free(ino_entry_slab, e);
- }
- spin_unlock(&sbi->ino_lock[i]);
- }
-}
-
int acquire_orphan_inode(struct f2fs_sb_info *sbi)
{
int err = 0;
- spin_lock(&sbi->ino_lock[ORPHAN_INO]);
+ spin_lock(&sbi->orphan_inode_lock);
if (unlikely(sbi->n_orphans >= sbi->max_orphans))
err = -ENOSPC;
else
sbi->n_orphans++;
- spin_unlock(&sbi->ino_lock[ORPHAN_INO]);
+ spin_unlock(&sbi->orphan_inode_lock);
return err;
}
void release_orphan_inode(struct f2fs_sb_info *sbi)
{
- spin_lock(&sbi->ino_lock[ORPHAN_INO]);
+ spin_lock(&sbi->orphan_inode_lock);
f2fs_bug_on(sbi->n_orphans == 0);
sbi->n_orphans--;
- spin_unlock(&sbi->ino_lock[ORPHAN_INO]);
+ spin_unlock(&sbi->orphan_inode_lock);
}
void add_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
{
- /* add new orphan ino entry into list */
- __add_ino_entry(sbi, ino, ORPHAN_INO);
+ struct list_head *head;
+ struct orphan_inode_entry *new, *orphan;
+
+ new = f2fs_kmem_cache_alloc(orphan_entry_slab, GFP_ATOMIC);
+ new->ino = ino;
+
+ spin_lock(&sbi->orphan_inode_lock);
+ head = &sbi->orphan_inode_list;
+ list_for_each_entry(orphan, head, list) {
+ if (orphan->ino == ino) {
+ spin_unlock(&sbi->orphan_inode_lock);
+ kmem_cache_free(orphan_entry_slab, new);
+ return;
+ }
+
+ if (orphan->ino > ino)
+ break;
+ }
+
+ /* add new orphan entry into list which is sorted by inode number */
+ list_add_tail(&new->list, &orphan->list);
+ spin_unlock(&sbi->orphan_inode_lock);
}
void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
{
- /* remove orphan entry from orphan list */
- __remove_ino_entry(sbi, ino, ORPHAN_INO);
+ struct list_head *head;
+ struct orphan_inode_entry *orphan;
+
+ spin_lock(&sbi->orphan_inode_lock);
+ head = &sbi->orphan_inode_list;
+ list_for_each_entry(orphan, head, list) {
+ if (orphan->ino == ino) {
+ list_del(&orphan->list);
+ f2fs_bug_on(sbi->n_orphans == 0);
+ sbi->n_orphans--;
+ spin_unlock(&sbi->orphan_inode_lock);
+ kmem_cache_free(orphan_entry_slab, orphan);
+ return;
+ }
+ }
+ spin_unlock(&sbi->orphan_inode_lock);
}
static void recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
@@ -449,14 +401,14 @@
unsigned short orphan_blocks = (unsigned short)((sbi->n_orphans +
(F2FS_ORPHANS_PER_BLOCK - 1)) / F2FS_ORPHANS_PER_BLOCK);
struct page *page = NULL;
- struct ino_entry *orphan = NULL;
+ struct orphan_inode_entry *orphan = NULL;
for (index = 0; index < orphan_blocks; index++)
grab_meta_page(sbi, start_blk + index);
index = 1;
- spin_lock(&sbi->ino_lock[ORPHAN_INO]);
- head = &sbi->ino_list[ORPHAN_INO];
+ spin_lock(&sbi->orphan_inode_lock);
+ head = &sbi->orphan_inode_list;
/* loop for each orphan inode entry and write them in Jornal block */
list_for_each_entry(orphan, head, list) {
@@ -496,7 +448,7 @@
f2fs_put_page(page, 1);
}
- spin_unlock(&sbi->ino_lock[ORPHAN_INO]);
+ spin_unlock(&sbi->orphan_inode_lock);
}
static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,
@@ -762,10 +714,10 @@
* until finishing nat/sit flush.
*/
retry_flush_nodes:
- down_write(&sbi->node_write);
+ mutex_lock(&sbi->node_write);
if (get_pages(sbi, F2FS_DIRTY_NODES)) {
- up_write(&sbi->node_write);
+ mutex_unlock(&sbi->node_write);
sync_node_pages(sbi, 0, &wbc);
goto retry_flush_nodes;
}
@@ -774,7 +726,7 @@
static void unblock_operations(struct f2fs_sb_info *sbi)
{
- up_write(&sbi->node_write);
+ mutex_unlock(&sbi->node_write);
f2fs_unlock_all(sbi);
}
@@ -796,7 +748,6 @@
static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount)
{
struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
- struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
nid_t last_nid = 0;
block_t start_blk;
struct page *cp_page;
@@ -810,7 +761,7 @@
* This avoids to conduct wrong roll-forward operations and uses
* metapages, so should be called prior to sync_meta_pages below.
*/
- discard_next_dnode(sbi, NEXT_FREE_BLKADDR(sbi, curseg));
+ discard_next_dnode(sbi);
/* Flush all the NAT/SIT pages */
while (get_pages(sbi, F2FS_DIRTY_META))
@@ -934,9 +885,8 @@
/* Here, we only have one bio having CP pack */
sync_meta_pages(sbi, META_FLUSH, LONG_MAX);
- if (!is_set_ckpt_flags(ckpt, CP_ERROR_FLAG)) {
+ if (unlikely(!is_set_ckpt_flags(ckpt, CP_ERROR_FLAG))) {
clear_prefree_segments(sbi);
- release_dirty_inode(sbi);
F2FS_RESET_SB_DIRT(sbi);
}
}
@@ -982,37 +932,31 @@
trace_f2fs_write_checkpoint(sbi->sb, is_umount, "finish checkpoint");
}
-void init_ino_entry_info(struct f2fs_sb_info *sbi)
+void init_orphan_info(struct f2fs_sb_info *sbi)
{
- int i;
-
- for (i = 0; i < MAX_INO_ENTRY; i++) {
- INIT_RADIX_TREE(&sbi->ino_root[i], GFP_ATOMIC);
- spin_lock_init(&sbi->ino_lock[i]);
- INIT_LIST_HEAD(&sbi->ino_list[i]);
- }
-
+ spin_lock_init(&sbi->orphan_inode_lock);
+ INIT_LIST_HEAD(&sbi->orphan_inode_list);
+ sbi->n_orphans = 0;
/*
* considering 512 blocks in a segment 8 blocks are needed for cp
* and log segment summaries. Remaining blocks are used to keep
* orphan entries with the limitation one reserved segment
* for cp pack we can have max 1020*504 orphan entries
*/
- sbi->n_orphans = 0;
sbi->max_orphans = (sbi->blocks_per_seg - 2 - NR_CURSEG_TYPE)
* F2FS_ORPHANS_PER_BLOCK;
}
int __init create_checkpoint_caches(void)
{
- ino_entry_slab = f2fs_kmem_cache_create("f2fs_ino_entry",
- sizeof(struct ino_entry));
- if (!ino_entry_slab)
+ orphan_entry_slab = f2fs_kmem_cache_create("f2fs_orphan_entry",
+ sizeof(struct orphan_inode_entry));
+ if (!orphan_entry_slab)
return -ENOMEM;
inode_entry_slab = f2fs_kmem_cache_create("f2fs_dirty_dir_entry",
sizeof(struct dir_inode_entry));
if (!inode_entry_slab) {
- kmem_cache_destroy(ino_entry_slab);
+ kmem_cache_destroy(orphan_entry_slab);
return -ENOMEM;
}
return 0;
@@ -1020,6 +964,6 @@
void destroy_checkpoint_caches(void)
{
- kmem_cache_destroy(ino_entry_slab);
+ kmem_cache_destroy(orphan_entry_slab);
kmem_cache_destroy(inode_entry_slab);
}
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 65453d2..feb6ca2 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -140,10 +140,7 @@
/* change META to META_FLUSH in the checkpoint procedure */
if (type >= META_FLUSH) {
io->fio.type = META_FLUSH;
- if (test_opt(sbi, NOBARRIER))
- io->fio.rw = WRITE_FLUSH | REQ_META | REQ_PRIO;
- else
- io->fio.rw = WRITE_FLUSH_FUA | REQ_META | REQ_PRIO;
+ io->fio.rw = WRITE_FLUSH_FUA | REQ_META | REQ_PRIO;
}
__submit_merged_bio(io);
up_write(&io->io_rwsem);
@@ -630,10 +627,8 @@
if (check_extent_cache(inode, pgofs, bh_result))
goto out;
- if (create) {
- f2fs_balance_fs(sbi);
+ if (create)
f2fs_lock_op(sbi);
- }
/* When reading holes, we need its node page */
set_new_dnode(&dn, inode, NULL, NULL, 0);
@@ -790,11 +785,9 @@
!is_cold_data(page) &&
need_inplace_update(inode))) {
rewrite_data_page(page, old_blkaddr, fio);
- set_inode_flag(F2FS_I(inode), FI_UPDATE_WRITE);
} else {
write_data_page(page, &dn, &new_blkaddr, fio);
update_extent_cache(new_blkaddr, &dn);
- set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
}
out_writepage:
f2fs_put_dnode(&dn);
@@ -1090,15 +1083,10 @@
/* clear fsync mark to recover these blocks */
fsync_mark_clear(F2FS_SB(inode->i_sb), inode->i_ino);
- trace_f2fs_direct_IO_enter(inode, offset, count, rw);
-
err = blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
get_data_block);
if (err < 0 && (rw & WRITE))
f2fs_write_failed(mapping, offset + count);
-
- trace_f2fs_direct_IO_exit(inode, offset, count, rw, err);
-
return err;
}
diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index a441ba3..3f99266 100644
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -167,7 +167,7 @@
si->cache_mem += npages << PAGE_CACHE_SHIFT;
npages = META_MAPPING(sbi)->nrpages;
si->cache_mem += npages << PAGE_CACHE_SHIFT;
- si->cache_mem += sbi->n_orphans * sizeof(struct ino_entry);
+ si->cache_mem += sbi->n_orphans * sizeof(struct orphan_inode_entry);
si->cache_mem += sbi->n_dirty_dirs * sizeof(struct dir_inode_entry);
}
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index a456212..c791143 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -42,7 +42,6 @@
#define F2FS_MOUNT_INLINE_XATTR 0x00000080
#define F2FS_MOUNT_INLINE_DATA 0x00000100
#define F2FS_MOUNT_FLUSH_MERGE 0x00000200
-#define F2FS_MOUNT_NOBARRIER 0x00000400
#define clear_opt(sbi, option) (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option)
#define set_opt(sbi, option) (sbi->mount_opt.opt |= F2FS_MOUNT_##option)
@@ -101,15 +100,8 @@
META_SSA
};
-/* for the list of ino */
-enum {
- ORPHAN_INO, /* for orphan ino list */
- APPEND_INO, /* for append ino list */
- UPDATE_INO, /* for update ino list */
- MAX_INO_ENTRY, /* max. list */
-};
-
-struct ino_entry {
+/* for the list of orphan inodes */
+struct orphan_inode_entry {
struct list_head list; /* list head */
nid_t ino; /* inode number */
};
@@ -453,17 +445,14 @@
struct inode *meta_inode; /* cache meta blocks */
struct mutex cp_mutex; /* checkpoint procedure lock */
struct rw_semaphore cp_rwsem; /* blocking FS operations */
- struct rw_semaphore node_write; /* locking node writes */
+ struct mutex node_write; /* locking node writes */
struct mutex writepages; /* mutex for writepages() */
bool por_doing; /* recovery is doing or not */
wait_queue_head_t cp_wait;
- /* for inode management */
- struct radix_tree_root ino_root[MAX_INO_ENTRY]; /* ino entry array */
- spinlock_t ino_lock[MAX_INO_ENTRY]; /* for ino entry lock */
- struct list_head ino_list[MAX_INO_ENTRY]; /* inode list head */
-
- /* for orphan inode, use 0'th array */
+ /* for orphan inode management */
+ struct list_head orphan_inode_list; /* orphan inode list */
+ spinlock_t orphan_inode_lock; /* for orphan inode list */
unsigned int n_orphans; /* # of orphan inodes */
unsigned int max_orphans; /* max orphan inodes */
@@ -782,7 +771,7 @@
if (flag == NAT_BITMAP)
return &ckpt->sit_nat_version_bitmap;
else
- return (unsigned char *)ckpt + F2FS_BLKSIZE;
+ return ((unsigned char *)ckpt + F2FS_BLKSIZE);
} else {
offset = (flag == NAT_BITMAP) ?
le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
@@ -997,15 +986,11 @@
FI_NO_EXTENT, /* not to use the extent cache */
FI_INLINE_XATTR, /* used for inline xattr */
FI_INLINE_DATA, /* used for inline data*/
- FI_APPEND_WRITE, /* inode has appended data */
- FI_UPDATE_WRITE, /* inode has in-place-update data */
- FI_NEED_IPU, /* used fo ipu for fdatasync */
};
static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag)
{
- if (!test_bit(flag, &fi->flags))
- set_bit(flag, &fi->flags);
+ set_bit(flag, &fi->flags);
}
static inline int is_inode_flag_set(struct f2fs_inode_info *fi, int flag)
@@ -1015,8 +1000,7 @@
static inline void clear_inode_flag(struct f2fs_inode_info *fi, int flag)
{
- if (test_bit(flag, &fi->flags))
- clear_bit(flag, &fi->flags);
+ clear_bit(flag, &fi->flags);
}
static inline void set_acl_inode(struct f2fs_inode_info *fi, umode_t mode)
@@ -1210,7 +1194,6 @@
void alloc_nid_failed(struct f2fs_sb_info *, nid_t);
void recover_node_page(struct f2fs_sb_info *, struct page *,
struct f2fs_summary *, struct node_info *, block_t);
-void recover_inline_xattr(struct inode *, struct page *);
bool recover_xattr_data(struct inode *, struct page *, block_t);
int recover_inode_page(struct f2fs_sb_info *, struct page *);
int restore_node_summary(struct f2fs_sb_info *, unsigned int,
@@ -1232,7 +1215,7 @@
void invalidate_blocks(struct f2fs_sb_info *, block_t);
void refresh_sit_entry(struct f2fs_sb_info *, block_t, block_t);
void clear_prefree_segments(struct f2fs_sb_info *);
-void discard_next_dnode(struct f2fs_sb_info *, block_t);
+void discard_next_dnode(struct f2fs_sb_info *);
int npages_for_summary_flush(struct f2fs_sb_info *);
void allocate_new_segments(struct f2fs_sb_info *);
struct page *get_sum_page(struct f2fs_sb_info *, unsigned int);
@@ -1266,9 +1249,6 @@
struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t);
int ra_meta_pages(struct f2fs_sb_info *, int, int, int);
long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long);
-void add_dirty_inode(struct f2fs_sb_info *, nid_t, int type);
-void remove_dirty_inode(struct f2fs_sb_info *, nid_t, int type);
-bool exist_written_data(struct f2fs_sb_info *, nid_t, int);
int acquire_orphan_inode(struct f2fs_sb_info *);
void release_orphan_inode(struct f2fs_sb_info *);
void add_orphan_inode(struct f2fs_sb_info *, nid_t);
@@ -1280,7 +1260,7 @@
void remove_dirty_dir_inode(struct inode *);
void sync_dirty_dir_inodes(struct f2fs_sb_info *);
void write_checkpoint(struct f2fs_sb_info *, bool);
-void init_ino_entry_info(struct f2fs_sb_info *);
+void init_orphan_info(struct f2fs_sb_info *);
int __init create_checkpoint_caches(void);
void destroy_checkpoint_caches(void);
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 938591a..0e88a75 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -124,30 +124,12 @@
return 0;
trace_f2fs_sync_file_enter(inode);
-
- /* if fdatasync is triggered, let's do in-place-update */
- if (datasync)
- set_inode_flag(fi, FI_NEED_IPU);
-
ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
- if (datasync)
- clear_inode_flag(fi, FI_NEED_IPU);
if (ret) {
trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
return ret;
}
- /*
- * if there is no written data, don't waste time to write recovery info.
- */
- if (!is_inode_flag_set(fi, FI_APPEND_WRITE) &&
- !exist_written_data(sbi, inode->i_ino, APPEND_INO)) {
- if (is_inode_flag_set(fi, FI_UPDATE_WRITE) ||
- exist_written_data(sbi, inode->i_ino, UPDATE_INO))
- goto flush_out;
- goto out;
- }
-
/* guarantee free sections for fsync */
f2fs_balance_fs(sbi);
@@ -203,13 +185,6 @@
ret = wait_on_node_pages_writeback(sbi, inode->i_ino);
if (ret)
goto out;
-
- /* once recovery info is written, don't need to tack this */
- remove_dirty_inode(sbi, inode->i_ino, APPEND_INO);
- clear_inode_flag(fi, FI_APPEND_WRITE);
-flush_out:
- remove_dirty_inode(sbi, inode->i_ino, UPDATE_INO);
- clear_inode_flag(fi, FI_UPDATE_WRITE);
ret = f2fs_issue_flush(F2FS_SB(inode->i_sb));
}
out:
@@ -228,9 +203,8 @@
/* find first dirty page index */
pagevec_init(&pvec, 0);
- nr_pages = pagevec_lookup_tag(&pvec, mapping, &pgofs,
- PAGECACHE_TAG_DIRTY, 1);
- pgofs = nr_pages ? pvec.pages[0]->index : LONG_MAX;
+ nr_pages = pagevec_lookup_tag(&pvec, mapping, &pgofs, PAGECACHE_TAG_DIRTY, 1);
+ pgofs = nr_pages ? pvec.pages[0]->index: LONG_MAX;
pagevec_release(&pvec);
return pgofs;
}
@@ -687,8 +661,6 @@
loff_t off_start, off_end;
int ret = 0;
- f2fs_balance_fs(sbi);
-
ret = inode_newsize_ok(inode, (len + offset));
if (ret)
return ret;
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index d7b4a5e..47c51ed 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -186,6 +186,7 @@
static unsigned int check_bg_victims(struct f2fs_sb_info *sbi)
{
struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
+ unsigned int hint = 0;
unsigned int secno;
/*
@@ -193,9 +194,11 @@
* selected by background GC before.
* Those segments guarantee they have small valid blocks.
*/
- for_each_set_bit(secno, dirty_i->victim_secmap, TOTAL_SECS(sbi)) {
+next:
+ secno = find_next_bit(dirty_i->victim_secmap, TOTAL_SECS(sbi), hint++);
+ if (secno < TOTAL_SECS(sbi)) {
if (sec_usage_check(sbi, secno))
- continue;
+ goto next;
clear_bit(secno, dirty_i->victim_secmap);
return secno * sbi->segs_per_sec;
}
diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 5beecce..1bba522 100644
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -172,7 +172,6 @@
stat_inc_inline_inode(inode);
}
- set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
sync_inode_page(&dn);
f2fs_put_dnode(&dn);
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index d829f4e..679ee78 100644
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -261,14 +261,13 @@
void f2fs_evict_inode(struct inode *inode)
{
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
- nid_t xnid = F2FS_I(inode)->i_xattr_nid;
trace_f2fs_evict_inode(inode);
truncate_inode_pages(&inode->i_data, 0);
if (inode->i_ino == F2FS_NODE_INO(sbi) ||
inode->i_ino == F2FS_META_INO(sbi))
- goto out_clear;
+ goto no_delete;
f2fs_bug_on(get_dirty_dents(inode));
remove_dirty_dir_inode(inode);
@@ -288,13 +287,6 @@
f2fs_unlock_op(sbi);
no_delete:
- invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino);
- if (xnid)
- invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);
- if (is_inode_flag_set(F2FS_I(inode), FI_APPEND_WRITE))
- add_dirty_inode(sbi, inode->i_ino, APPEND_INO);
- if (is_inode_flag_set(F2FS_I(inode), FI_UPDATE_WRITE))
- add_dirty_inode(sbi, inode->i_ino, UPDATE_INO);
-out_clear:
end_writeback(inode);
+ invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino);
}
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index 5ed4557..fa1e0c9 100644
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1231,12 +1231,12 @@
if (wbc->for_reclaim)
goto redirty_out;
- down_read(&sbi->node_write);
+ mutex_lock(&sbi->node_write);
set_page_writeback(page);
write_node_page(sbi, page, &fio, nid, ni.blk_addr, &new_addr);
set_node_addr(sbi, &ni, new_addr, is_fsync_dnode(page));
dec_page_count(sbi, F2FS_DIRTY_NODES);
- up_read(&sbi->node_write);
+ mutex_unlock(&sbi->node_write);
unlock_page(page);
return 0;
@@ -1548,7 +1548,7 @@
clear_node_page_dirty(page);
}
-void recover_inline_xattr(struct inode *inode, struct page *page)
+static void recover_inline_xattr(struct inode *inode, struct page *page)
{
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
void *src_addr, *dst_addr;
@@ -1587,6 +1587,8 @@
nid_t new_xnid = nid_of_node(page);
struct node_info ni;
+ recover_inline_xattr(inode, page);
+
if (!f2fs_has_xattr_block(ofs_of_node(page)))
return false;
diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 88e9cd9..a112368 100644
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -300,8 +300,6 @@
struct node_info ni;
int err = 0, recovered = 0;
- recover_inline_xattr(inode, page);
-
if (recover_inline_data(inode, page))
goto out;
@@ -436,9 +434,7 @@
int recover_fsync_data(struct f2fs_sb_info *sbi)
{
- struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
struct list_head inode_list;
- block_t blkaddr;
int err;
bool need_writecp = false;
@@ -451,9 +447,6 @@
/* step #1: find fsynced inode numbers */
sbi->por_doing = true;
-
- blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
-
err = find_fsync_dnodes(sbi, &inode_list);
if (err)
goto out;
@@ -469,21 +462,8 @@
out:
destroy_fsync_dnodes(&inode_list);
kmem_cache_destroy(fsync_entry_slab);
-
- if (err) {
- truncate_inode_pages(NODE_MAPPING(sbi), 0);
- truncate_inode_pages(META_MAPPING(sbi), 0);
- }
-
sbi->por_doing = false;
- if (err) {
- discard_next_dnode(sbi, blkaddr);
-
- /* Flush all the NAT/SIT pages */
- while (get_pages(sbi, F2FS_DIRTY_META))
- sync_meta_pages(sbi, META, LONG_MAX);
- } else if (need_writecp) {
+ if (!err && need_writecp)
write_checkpoint(sbi, false);
- }
return err;
}
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 825025b..3461bc1 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -266,12 +266,6 @@
struct flush_cmd_control *fcc = SM_I(sbi)->cmd_control_info;
struct flush_cmd cmd;
- trace_f2fs_issue_flush(sbi->sb, test_opt(sbi, NOBARRIER),
- test_opt(sbi, FLUSH_MERGE));
-
- if (test_opt(sbi, NOBARRIER))
- return 0;
-
if (!test_opt(sbi, FLUSH_MERGE))
return blkdev_issue_flush(sbi->sb->s_bdev, GFP_KERNEL, NULL);
@@ -409,8 +403,11 @@
return blkdev_issue_discard(sbi->sb->s_bdev, start, len, GFP_NOFS, 0);
}
-void discard_next_dnode(struct f2fs_sb_info *sbi, block_t blkaddr)
+void discard_next_dnode(struct f2fs_sb_info *sbi)
{
+ struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
+ block_t blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
+
if (f2fs_issue_discard(sbi, blkaddr, 1)) {
struct page *page = grab_meta_page(sbi, blkaddr);
/* zero-filled page */
@@ -466,12 +463,17 @@
static void set_prefree_as_free_segments(struct f2fs_sb_info *sbi)
{
struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
- unsigned int segno;
+ unsigned int segno = -1;
unsigned int total_segs = TOTAL_SEGS(sbi);
mutex_lock(&dirty_i->seglist_lock);
- for_each_set_bit(segno, dirty_i->dirty_segmap[PRE], total_segs)
+ while (1) {
+ segno = find_next_bit(dirty_i->dirty_segmap[PRE], total_segs,
+ segno + 1);
+ if (segno >= total_segs)
+ break;
__set_test_and_free(sbi, segno);
+ }
mutex_unlock(&dirty_i->seglist_lock);
}
@@ -998,12 +1000,14 @@
{
struct sit_info *sit_i = SIT_I(sbi);
struct curseg_info *curseg;
+ unsigned int old_cursegno;
curseg = CURSEG_I(sbi, type);
mutex_lock(&curseg->curseg_mutex);
*new_blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
+ old_cursegno = curseg->segno;
/*
* __add_sum_entry should be resided under the curseg_mutex
@@ -1024,6 +1028,7 @@
* since SSR needs latest valid block information.
*/
refresh_sit_entry(sbi, old_blkaddr, *new_blkaddr);
+ locate_dirty_segment(sbi, old_cursegno);
mutex_unlock(&sit_i->sentry_lock);
@@ -1553,7 +1558,7 @@
struct page *page = NULL;
struct f2fs_sit_block *raw_sit = NULL;
unsigned int start = 0, end = 0;
- unsigned int segno;
+ unsigned int segno = -1;
bool flushed;
mutex_lock(&curseg->curseg_mutex);
@@ -1565,7 +1570,7 @@
*/
flushed = flush_sits_in_journal(sbi);
- for_each_set_bit(segno, bitmap, nsegs) {
+ while ((segno = find_next_bit(bitmap, nsegs, segno + 1)) < nsegs) {
struct seg_entry *se = get_seg_entry(sbi, segno);
int sit_offset, offset;
diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index 55973f7..7091204 100644
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -347,8 +347,8 @@
if (test_and_clear_bit(segno, free_i->free_segmap)) {
free_i->free_segments++;
- next = find_next_bit(free_i->free_segmap,
- start_segno + sbi->segs_per_sec, start_segno);
+ next = find_next_bit(free_i->free_segmap, TOTAL_SEGS(sbi),
+ start_segno);
if (next >= start_segno + sbi->segs_per_sec) {
if (test_and_clear_bit(secno, free_i->free_secmap))
free_i->free_sections++;
@@ -486,10 +486,6 @@
if (S_ISDIR(inode->i_mode))
return false;
- /* this is only set during fdatasync */
- if (is_inode_flag_set(F2FS_I(inode), FI_NEED_IPU))
- return true;
-
switch (SM_I(sbi)->ipu_policy) {
case F2FS_IPU_FORCE:
return true;
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index ea40788..96c1af2 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -52,7 +52,6 @@
Opt_inline_xattr,
Opt_inline_data,
Opt_flush_merge,
- Opt_nobarrier,
Opt_err,
};
@@ -70,7 +69,6 @@
{Opt_inline_xattr, "inline_xattr"},
{Opt_inline_data, "inline_data"},
{Opt_flush_merge, "flush_merge"},
- {Opt_nobarrier, "nobarrier"},
{Opt_err, NULL},
};
@@ -341,9 +339,6 @@
case Opt_flush_merge:
set_opt(sbi, FLUSH_MERGE);
break;
- case Opt_nobarrier:
- set_opt(sbi, NOBARRIER);
- break;
default:
f2fs_msg(sb, KERN_ERR,
"Unrecognized mount option \"%s\" or missing value",
@@ -549,8 +544,6 @@
seq_puts(seq, ",inline_data");
if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE))
seq_puts(seq, ",flush_merge");
- if (test_opt(sbi, NOBARRIER))
- seq_puts(seq, ",nobarrier");
seq_printf(seq, ",active_logs=%u", sbi->active_logs);
return 0;
@@ -953,7 +946,7 @@
mutex_init(&sbi->gc_mutex);
mutex_init(&sbi->writepages);
mutex_init(&sbi->cp_mutex);
- init_rwsem(&sbi->node_write);
+ mutex_init(&sbi->node_write);
sbi->por_doing = false;
spin_lock_init(&sbi->stat_lock);
@@ -1003,7 +996,7 @@
INIT_LIST_HEAD(&sbi->dir_inode_list);
spin_lock_init(&sbi->dir_inode_lock);
- init_ino_entry_info(sbi);
+ init_orphan_info(sbi);
/* setup f2fs internal modules */
err = build_segment_manager(sbi);
@@ -1040,9 +1033,8 @@
goto free_node_inode;
}
if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
- iput(root);
err = -EINVAL;
- goto free_node_inode;
+ goto free_root_inode;
}
sb->s_root = d_make_root(root); /* allocate root dentry */