Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

f2fs: bug fixes for 3.8-rc2

Browse source 
This patch-set includes two major bug fixes:
 - incorrect IUsed provided by *df -i*, and
 - lookup failure of parent inodes in corner cases.
 
 [Other Bug Fixes]
 - Fix error handling routines
 - Trigger recovery process correctly
 - Resolve build failures due to missing header files
 
 [Etc]
 - Add a MAINTAINERS entry for f2fs
 - Fix and clean up variables, functions, and equations
 - Avoid warnings during compilation
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1.4.11 (GNU/Linux)
 
 iQIcBAABAgAGBQJQ3QYaAAoJEEAUqH6CSFDSZwYP/jyx4ilQC5pT85NCBs744JGZ
 zGKcNLlWJcVpSwoepmjEJiMfvYE63imwmsG0gHcnUosvndTivrOkLUPReBE4bLLO
 6KR0J/HWxfRY+FAM6nGfoVDWAG/2mU/cCwDKCwGgAZp//5YmxQZTcp3Xcak6dHUQ
 z64O2XC/roK4w827lwpp7lFBnhY3snpaA+EFGe2Wwm+9r9BrJYP3FyFG9VVRR1Cw
 SQphbZrC2yo+03IN1sJV83QLfKt3+tONhctizAtMzVOVgM2ToVLNbz32SVj8pbnD
 WSMwVWYxVQwC8R9ZhUc2Z3hV+m9m9MswBMyK+U9QF5r/avFK4vKHJYLOcXmpzRcX
 voH5tl7OfVERqfMsle+7X6/Edz5xd4abF4b5yM+3h9pz4LRJYWkp3daeWPY++ZUR
 esM81f0+W55I/mk1STlI7N+KdVn3/Zpqi0UVkcZQ8y15NpOR+5zeLF4+8Skk4NGL
 emYJiho4GB2cpKw7gIQQtnGKSTIPnwRK6Lart7qJ1b2FfNwtJqAgALm7HDxbqSTN
 r3XXJv2E1u9HBu0gEKs5g223Poj7nBLwOQPkmIyx1ozD7bx19vQGnfsHza8a9L1y
 pXQ3dKU3o93+dHjMGky2cpe6B52nuvN+MBicqBSCJAIbSafmp8/JrBiN7hgQFdpj
 x/nXXZd+WPakvjHz03e5
 =dH3T
 -----END PGP SIGNATURE-----

Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs

Pull f2fs bug fixes from Jaegeuk Kim:
 "This patch-set includes two major bug fixes:
   - incorrect IUsed provided by *df -i*, and
   - lookup failure of parent inodes in corner cases.

  [Other Bug Fixes]
   - Fix error handling routines
   - Trigger recovery process correctly
   - Resolve build failures due to missing header files

  [Etc]
   - Add a MAINTAINERS entry for f2fs
   - Fix and clean up variables, functions, and equations
   - Avoid warnings during compilation"

* tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs:
  f2fs: unify string length declarations and usage
  f2fs: clean up unused variables and return values
  f2fs: clean up the start_bidx_of_node function
  f2fs: remove unneeded variable from f2fs_sync_fs
  f2fs: fix fsync_inode list addition logic and avoid invalid access to memory
  f2fs: remove unneeded initialization of nr_dirty in dirty_seglist_info
  f2fs: handle error from f2fs_iget_nowait
  f2fs: fix equation of has_not_enough_free_secs()
  f2fs: add MAINTAINERS entry
  f2fs: return a default value for non-void function
  f2fs: invalidate the node page if allocation is failed
  f2fs: add missing #include <linux/prefetch.h>
  f2fs: do f2fs_balance_fs in front of dir operations
  f2fs: should recover orphan and fsync data
  f2fs: fix handling errors got by f2fs_write_inode
  f2fs: fix up f2fs_get_parent issue to retrieve correct parent inode number
  f2fs: fix wrong calculation on f_files in statfs
  f2fs: remove set_page_dirty for atomic f2fs_end_io_write
This commit is contained in:
Linus Torvalds 2013-01-03 11:41:43 -08:00
commit 2318aa2720
15 changed files with 117 additions and 137 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
MAINTAINERS
View file

@ -3273,6 +3273,16 @@ F: Documentation/filesystems/caching/
F: fs/fscache/ F: fs/fscache/
F: include/linux/fscache*.h F: include/linux/fscache*.h
F2FS FILE SYSTEM
M: Jaegeuk Kim <jaegeuk.kim@samsung.com>
L: linux-f2fs-devel@lists.sourceforge.net
W: http://en.wikipedia.org/wiki/F2FS
T: git git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git
S: Maintained
F: Documentation/filesystems/f2fs.txt
F: fs/f2fs/
F: include/linux/f2fs_fs.h
FUJITSU FR-V (FRV) PORT FUJITSU FR-V (FRV) PORT
M: David Howells <dhowells@redhat.com> M: David Howells <dhowells@redhat.com>
S: Maintained S: Maintained

1
fs/f2fs/data.c
View file

@ -16,6 +16,7 @@
#include <linux/backing-dev.h> #include <linux/backing-dev.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/bio.h> #include <linux/bio.h>
#include <linux/prefetch.h>
#include "f2fs.h" #include "f2fs.h"
#include "node.h" #include "node.h"

16
fs/f2fs/dir.c
View file

@ -11,6 +11,7 @@
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/f2fs_fs.h> #include <linux/f2fs_fs.h>
#include "f2fs.h" #include "f2fs.h"
#include "node.h"
#include "acl.h" #include "acl.h"
static unsigned long dir_blocks(struct inode *inode) static unsigned long dir_blocks(struct inode *inode)
@ -74,7 +75,7 @@ static unsigned long dir_block_index(unsigned int level, unsigned int idx)
return bidx; return bidx;
} }
static bool early_match_name(const char *name, int namelen, static bool early_match_name(const char *name, size_t namelen,
f2fs_hash_t namehash, struct f2fs_dir_entry *de) f2fs_hash_t namehash, struct f2fs_dir_entry *de)
{ {
if (le16_to_cpu(de->name_len) != namelen) if (le16_to_cpu(de->name_len) != namelen)
@ -87,7 +88,7 @@ static bool early_match_name(const char *name, int namelen,
} }
static struct f2fs_dir_entry *find_in_block(struct page *dentry_page, static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
const char *name, int namelen, int *max_slots, const char *name, size_t namelen, int *max_slots,
f2fs_hash_t namehash, struct page **res_page) f2fs_hash_t namehash, struct page **res_page)
{ {
struct f2fs_dir_entry *de; struct f2fs_dir_entry *de;
@ -126,7 +127,7 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
} }
static struct f2fs_dir_entry *find_in_level(struct inode *dir, static struct f2fs_dir_entry *find_in_level(struct inode *dir,
unsigned int level, const char *name, int namelen, unsigned int level, const char *name, size_t namelen,
f2fs_hash_t namehash, struct page **res_page) f2fs_hash_t namehash, struct page **res_page)
{ {
int s = GET_DENTRY_SLOTS(namelen); int s = GET_DENTRY_SLOTS(namelen);
@ -181,7 +182,7 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
struct qstr *child, struct page **res_page) struct qstr *child, struct page **res_page)
{ {
const char *name = child->name; const char *name = child->name;
int namelen = child->len; size_t namelen = child->len;
unsigned long npages = dir_blocks(dir); unsigned long npages = dir_blocks(dir);
struct f2fs_dir_entry *de = NULL; struct f2fs_dir_entry *de = NULL;
f2fs_hash_t name_hash; f2fs_hash_t name_hash;
@ -308,6 +309,7 @@ static int init_inode_metadata(struct inode *inode, struct dentry *dentry)
ipage = get_node_page(F2FS_SB(dir->i_sb), inode->i_ino); ipage = get_node_page(F2FS_SB(dir->i_sb), inode->i_ino);
if (IS_ERR(ipage)) if (IS_ERR(ipage))
return PTR_ERR(ipage); return PTR_ERR(ipage);
set_cold_node(inode, ipage);
init_dent_inode(dentry, ipage); init_dent_inode(dentry, ipage);
f2fs_put_page(ipage, 1); f2fs_put_page(ipage, 1);
} }
@ -381,7 +383,7 @@ int f2fs_add_link(struct dentry *dentry, struct inode *inode)
struct inode *dir = dentry->d_parent->d_inode; struct inode *dir = dentry->d_parent->d_inode;
struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
const char *name = dentry->d_name.name; const char *name = dentry->d_name.name;
int namelen = dentry->d_name.len; size_t namelen = dentry->d_name.len;
struct page *dentry_page = NULL; struct page *dentry_page = NULL;
struct f2fs_dentry_block *dentry_blk = NULL; struct f2fs_dentry_block *dentry_blk = NULL;
int slots = GET_DENTRY_SLOTS(namelen); int slots = GET_DENTRY_SLOTS(namelen);
@ -540,13 +542,13 @@ int f2fs_make_empty(struct inode *inode, struct inode *parent)
de = &dentry_blk->dentry[0]; de = &dentry_blk->dentry[0];
de->name_len = cpu_to_le16(1); de->name_len = cpu_to_le16(1);
de->hash_code = 0; de->hash_code = f2fs_dentry_hash(".", 1);
de->ino = cpu_to_le32(inode->i_ino); de->ino = cpu_to_le32(inode->i_ino);
memcpy(dentry_blk->filename[0], ".", 1); memcpy(dentry_blk->filename[0], ".", 1);
set_de_type(de, inode); set_de_type(de, inode);
de = &dentry_blk->dentry[1]; de = &dentry_blk->dentry[1];
de->hash_code = 0; de->hash_code = f2fs_dentry_hash("..", 2);
de->name_len = cpu_to_le16(2); de->name_len = cpu_to_le16(2);
de->ino = cpu_to_le32(parent->i_ino); de->ino = cpu_to_le32(parent->i_ino);
memcpy(dentry_blk->filename[1], "..", 2); memcpy(dentry_blk->filename[1], "..", 2);

2
fs/f2fs/f2fs.h
View file

@ -881,7 +881,7 @@ int f2fs_sync_fs(struct super_block *, int);
/* /*
* hash.c * hash.c
*/ */
f2fs_hash_t f2fs_dentry_hash(const char *, int); f2fs_hash_t f2fs_dentry_hash(const char *, size_t);
/* /*
* node.c * node.c

10
fs/f2fs/file.c
View file

@ -160,15 +160,17 @@ int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
if (need_to_sync_dir(sbi, inode)) if (need_to_sync_dir(sbi, inode))
need_cp = true; need_cp = true;
f2fs_write_inode(inode, NULL);
if (need_cp) { if (need_cp) {
/* all the dirty node pages should be flushed for POR */ /* all the dirty node pages should be flushed for POR */
ret = f2fs_sync_fs(inode->i_sb, 1); ret = f2fs_sync_fs(inode->i_sb, 1);
clear_inode_flag(F2FS_I(inode), FI_NEED_CP); clear_inode_flag(F2FS_I(inode), FI_NEED_CP);
} else { } else {
while (sync_node_pages(sbi, inode->i_ino, &wbc) == 0) /* if there is no written node page, write its inode page */
f2fs_write_inode(inode, NULL); while (!sync_node_pages(sbi, inode->i_ino, &wbc)) {
ret = f2fs_write_inode(inode, NULL);
if (ret)
goto out;
}
filemap_fdatawait_range(sbi->node_inode->i_mapping, filemap_fdatawait_range(sbi->node_inode->i_mapping,
0, LONG_MAX); 0, LONG_MAX);
} }

34
fs/f2fs/gc.c
View file

@ -390,9 +390,7 @@ static int gc_node_segment(struct f2fs_sb_info *sbi,
} }
err = check_valid_map(sbi, segno, off); err = check_valid_map(sbi, segno, off);
if (err == GC_ERROR) if (err == GC_NEXT)
return err;
else if (err == GC_NEXT)
continue; continue;
if (initial) { if (initial) {
@ -430,28 +428,22 @@ static int gc_node_segment(struct f2fs_sb_info *sbi,
*/ */
block_t start_bidx_of_node(unsigned int node_ofs) block_t start_bidx_of_node(unsigned int node_ofs)
{ {
block_t start_bidx; unsigned int indirect_blks = 2 * NIDS_PER_BLOCK + 4;
unsigned int bidx, indirect_blks; unsigned int bidx;
int dec;
indirect_blks = 2 * NIDS_PER_BLOCK + 4; if (node_ofs == 0)
return 0;
start_bidx = 1; if (node_ofs <= 2) {
if (node_ofs == 0) {
start_bidx = 0;
} else if (node_ofs <= 2) {
bidx = node_ofs - 1; bidx = node_ofs - 1;
} else if (node_ofs <= indirect_blks) { } else if (node_ofs <= indirect_blks) {
dec = (node_ofs - 4) / (NIDS_PER_BLOCK + 1); int dec = (node_ofs - 4) / (NIDS_PER_BLOCK + 1);
bidx = node_ofs - 2 - dec; bidx = node_ofs - 2 - dec;
} else { } else {
dec = (node_ofs - indirect_blks - 3) / (NIDS_PER_BLOCK + 1); int dec = (node_ofs - indirect_blks - 3) / (NIDS_PER_BLOCK + 1);
bidx = node_ofs - 5 - dec; bidx = node_ofs - 5 - dec;
} }
return bidx * ADDRS_PER_BLOCK + ADDRS_PER_INODE;
if (start_bidx)
start_bidx = bidx * ADDRS_PER_BLOCK + ADDRS_PER_INODE;
return start_bidx;
} }
static int check_dnode(struct f2fs_sb_info *sbi, struct f2fs_summary *sum, static int check_dnode(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
@ -556,9 +548,7 @@ static int gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
} }
err = check_valid_map(sbi, segno, off); err = check_valid_map(sbi, segno, off);
if (err == GC_ERROR) if (err == GC_NEXT)
goto stop;
else if (err == GC_NEXT)
continue; continue;
if (phase == 0) { if (phase == 0) {
@ -568,9 +558,7 @@ static int gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
/* Get an inode by ino with checking validity */ /* Get an inode by ino with checking validity */
err = check_dnode(sbi, entry, &dni, start_addr + off, &nofs); err = check_dnode(sbi, entry, &dni, start_addr + off, &nofs);
if (err == GC_ERROR) if (err == GC_NEXT)
goto stop;
else if (err == GC_NEXT)
continue; continue;
if (phase == 1) { if (phase == 1) {

18
fs/f2fs/hash.c
View file

@ -42,7 +42,7 @@ static void TEA_transform(unsigned int buf[4], unsigned int const in[])
buf[1] += b1; buf[1] += b1;
} }
static void str2hashbuf(const char *msg, int len, unsigned int *buf, int num) static void str2hashbuf(const char *msg, size_t len, unsigned int *buf, int num)
{ {
unsigned pad, val; unsigned pad, val;
int i; int i;
@ -69,13 +69,17 @@ static void str2hashbuf(const char *msg, int len, unsigned int *buf, int num)
*buf++ = pad; *buf++ = pad;
} }
f2fs_hash_t f2fs_dentry_hash(const char *name, int len) f2fs_hash_t f2fs_dentry_hash(const char *name, size_t len)
{ {
__u32 hash, minor_hash; __u32 hash;
f2fs_hash_t f2fs_hash; f2fs_hash_t f2fs_hash;
const char *p; const char *p;
__u32 in[8], buf[4]; __u32 in[8], buf[4];
if ((len <= 2) && (name[0] == '.') &&
(name[1] == '.' || name[1] == '\0'))
return 0;
/* Initialize the default seed for the hash checksum functions */ /* Initialize the default seed for the hash checksum functions */
buf[0] = 0x67452301; buf[0] = 0x67452301;
buf[1] = 0xefcdab89; buf[1] = 0xefcdab89;
@ -83,15 +87,15 @@ f2fs_hash_t f2fs_dentry_hash(const char *name, int len)
buf[3] = 0x10325476; buf[3] = 0x10325476;
p = name; p = name;
while (len > 0) { while (1) {
str2hashbuf(p, len, in, 4); str2hashbuf(p, len, in, 4);
TEA_transform(buf, in); TEA_transform(buf, in);
len -= 16;
p += 16; p += 16;
if (len <= 16)
break;
len -= 16;
} }
hash = buf[0]; hash = buf[0];
minor_hash = buf[1];
f2fs_hash = cpu_to_le32(hash & ~F2FS_HASH_COL_BIT); f2fs_hash = cpu_to_le32(hash & ~F2FS_HASH_COL_BIT);
return f2fs_hash; return f2fs_hash;
} }

1
fs/f2fs/inode.c
View file

@ -203,6 +203,7 @@ void update_inode(struct inode *inode, struct page *node_page)
ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags); ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);
ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino); ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);
ri->i_generation = cpu_to_le32(inode->i_generation); ri->i_generation = cpu_to_le32(inode->i_generation);
set_cold_node(inode, node_page);
set_page_dirty(node_page); set_page_dirty(node_page);
} }

34
fs/f2fs/namei.c
View file

@ -77,8 +77,8 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
static int is_multimedia_file(const unsigned char *s, const char *sub) static int is_multimedia_file(const unsigned char *s, const char *sub)
{ {
int slen = strlen(s); size_t slen = strlen(s);
int sublen = strlen(sub); size_t sublen = strlen(sub);
int ret; int ret;
if (sublen > slen) if (sublen > slen)
@ -123,6 +123,8 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
nid_t ino = 0; nid_t ino = 0;
int err; int err;
f2fs_balance_fs(sbi);
inode = f2fs_new_inode(dir, mode); inode = f2fs_new_inode(dir, mode);
if (IS_ERR(inode)) if (IS_ERR(inode))
return PTR_ERR(inode); return PTR_ERR(inode);
@ -144,8 +146,6 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
if (!sbi->por_doing) if (!sbi->por_doing)
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
unlock_new_inode(inode); unlock_new_inode(inode);
f2fs_balance_fs(sbi);
return 0; return 0;
out: out:
clear_nlink(inode); clear_nlink(inode);
@ -163,6 +163,8 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
struct f2fs_sb_info *sbi = F2FS_SB(sb); struct f2fs_sb_info *sbi = F2FS_SB(sb);
int err; int err;
f2fs_balance_fs(sbi);
inode->i_ctime = CURRENT_TIME; inode->i_ctime = CURRENT_TIME;
atomic_inc(&inode->i_count); atomic_inc(&inode->i_count);
@ -172,8 +174,6 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
goto out; goto out;
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
f2fs_balance_fs(sbi);
return 0; return 0;
out: out:
clear_inode_flag(F2FS_I(inode), FI_INC_LINK); clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
@ -223,6 +223,8 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
struct page *page; struct page *page;
int err = -ENOENT; int err = -ENOENT;
f2fs_balance_fs(sbi);
de = f2fs_find_entry(dir, &dentry->d_name, &page); de = f2fs_find_entry(dir, &dentry->d_name, &page);
if (!de) if (!de)
goto fail; goto fail;
@ -238,7 +240,6 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
/* In order to evict this inode, we set it dirty */ /* In order to evict this inode, we set it dirty */
mark_inode_dirty(inode); mark_inode_dirty(inode);
f2fs_balance_fs(sbi);
fail: fail:
return err; return err;
} }
@ -249,9 +250,11 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
struct super_block *sb = dir->i_sb; struct super_block *sb = dir->i_sb;
struct f2fs_sb_info *sbi = F2FS_SB(sb); struct f2fs_sb_info *sbi = F2FS_SB(sb);
struct inode *inode; struct inode *inode;
unsigned symlen = strlen(symname) + 1; size_t symlen = strlen(symname) + 1;
int err; int err;
f2fs_balance_fs(sbi);
inode = f2fs_new_inode(dir, S_IFLNK | S_IRWXUGO); inode = f2fs_new_inode(dir, S_IFLNK | S_IRWXUGO);
if (IS_ERR(inode)) if (IS_ERR(inode))
return PTR_ERR(inode); return PTR_ERR(inode);
@ -268,9 +271,6 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
unlock_new_inode(inode); unlock_new_inode(inode);
f2fs_balance_fs(sbi);
return err; return err;
out: out:
clear_nlink(inode); clear_nlink(inode);
@ -286,6 +286,8 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
struct inode *inode; struct inode *inode;
int err; int err;
f2fs_balance_fs(sbi);
inode = f2fs_new_inode(dir, S_IFDIR | mode); inode = f2fs_new_inode(dir, S_IFDIR | mode);
if (IS_ERR(inode)) if (IS_ERR(inode))
return PTR_ERR(inode); return PTR_ERR(inode);
@ -305,7 +307,6 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
unlock_new_inode(inode); unlock_new_inode(inode);
f2fs_balance_fs(sbi);
return 0; return 0;
out_fail: out_fail:
@ -336,6 +337,8 @@ static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
if (!new_valid_dev(rdev)) if (!new_valid_dev(rdev))
return -EINVAL; return -EINVAL;
f2fs_balance_fs(sbi);
inode = f2fs_new_inode(dir, mode); inode = f2fs_new_inode(dir, mode);
if (IS_ERR(inode)) if (IS_ERR(inode))
return PTR_ERR(inode); return PTR_ERR(inode);
@ -350,9 +353,6 @@ static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
alloc_nid_done(sbi, inode->i_ino); alloc_nid_done(sbi, inode->i_ino);
d_instantiate(dentry, inode); d_instantiate(dentry, inode);
unlock_new_inode(inode); unlock_new_inode(inode);
f2fs_balance_fs(sbi);
return 0; return 0;
out: out:
clear_nlink(inode); clear_nlink(inode);
@ -376,6 +376,8 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
struct f2fs_dir_entry *new_entry; struct f2fs_dir_entry *new_entry;
int err = -ENOENT; int err = -ENOENT;
f2fs_balance_fs(sbi);
old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page); old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
if (!old_entry) if (!old_entry)
goto out; goto out;
@ -441,8 +443,6 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
} }
mutex_unlock_op(sbi, RENAME); mutex_unlock_op(sbi, RENAME);
f2fs_balance_fs(sbi);
return 0; return 0;
out_dir: out_dir:

37
fs/f2fs/node.c
View file

@ -484,12 +484,14 @@ static void truncate_node(struct dnode_of_data *dn)
struct node_info ni; struct node_info ni;
get_node_info(sbi, dn->nid, &ni); get_node_info(sbi, dn->nid, &ni);
if (dn->inode->i_blocks == 0) {
BUG_ON(ni.blk_addr != NULL_ADDR);
goto invalidate;
}
BUG_ON(ni.blk_addr == NULL_ADDR); BUG_ON(ni.blk_addr == NULL_ADDR);
if (ni.blk_addr != NULL_ADDR)
invalidate_blocks(sbi, ni.blk_addr);
/* Deallocate node address */ /* Deallocate node address */
invalidate_blocks(sbi, ni.blk_addr);
dec_valid_node_count(sbi, dn->inode, 1); dec_valid_node_count(sbi, dn->inode, 1);
set_node_addr(sbi, &ni, NULL_ADDR); set_node_addr(sbi, &ni, NULL_ADDR);
@ -499,7 +501,7 @@ static void truncate_node(struct dnode_of_data *dn)
} else { } else {
sync_inode_page(dn); sync_inode_page(dn);
} }
invalidate:
clear_node_page_dirty(dn->node_page); clear_node_page_dirty(dn->node_page);
F2FS_SET_SB_DIRT(sbi); F2FS_SET_SB_DIRT(sbi);
@ -768,20 +770,12 @@ int remove_inode_page(struct inode *inode)
dn.inode_page_locked = 1; dn.inode_page_locked = 1;
truncate_node(&dn); truncate_node(&dn);
} }
if (inode->i_blocks == 1) {
/* inernally call f2fs_put_page() */
set_new_dnode(&dn, inode, page, page, ino);
truncate_node(&dn);
} else if (inode->i_blocks == 0) {
struct node_info ni;
get_node_info(sbi, inode->i_ino, &ni);
/* called after f2fs_new_inode() is failed */ /* 0 is possible, after f2fs_new_inode() is failed */
BUG_ON(ni.blk_addr != NULL_ADDR); BUG_ON(inode->i_blocks != 0 && inode->i_blocks != 1);
f2fs_put_page(page, 1); set_new_dnode(&dn, inode, page, page, ino);
} else { truncate_node(&dn);
BUG();
}
mutex_unlock_op(sbi, NODE_TRUNC); mutex_unlock_op(sbi, NODE_TRUNC);
return 0; return 0;
} }
@ -834,17 +828,18 @@ struct page *new_node_page(struct dnode_of_data *dn, unsigned int ofs)
goto fail; goto fail;
} }
set_node_addr(sbi, &new_ni, NEW_ADDR); set_node_addr(sbi, &new_ni, NEW_ADDR);
set_cold_node(dn->inode, page);
dn->node_page = page; dn->node_page = page;
sync_inode_page(dn); sync_inode_page(dn);
set_page_dirty(page); set_page_dirty(page);
set_cold_node(dn->inode, page);
if (ofs == 0) if (ofs == 0)
inc_valid_inode_count(sbi); inc_valid_inode_count(sbi);
return page; return page;
fail: fail:
clear_node_page_dirty(page);
f2fs_put_page(page, 1); f2fs_put_page(page, 1);
return ERR_PTR(err); return ERR_PTR(err);
} }
@ -1093,7 +1088,6 @@ static int f2fs_write_node_page(struct page *page,
{ {
struct f2fs_sb_info *sbi = F2FS_SB(page->mapping->host->i_sb); struct f2fs_sb_info *sbi = F2FS_SB(page->mapping->host->i_sb);
nid_t nid; nid_t nid;
unsigned int nofs;
block_t new_addr; block_t new_addr;
struct node_info ni; struct node_info ni;
@ -1110,7 +1104,6 @@ static int f2fs_write_node_page(struct page *page,
/* get old block addr of this node page */ /* get old block addr of this node page */
nid = nid_of_node(page); nid = nid_of_node(page);
nofs = ofs_of_node(page);
BUG_ON(page->index != nid); BUG_ON(page->index != nid);
get_node_info(sbi, nid, &ni); get_node_info(sbi, nid, &ni);
@ -1571,7 +1564,7 @@ void flush_nat_entries(struct f2fs_sb_info *sbi)
nid_t nid; nid_t nid;
struct f2fs_nat_entry raw_ne; struct f2fs_nat_entry raw_ne;
int offset = -1; int offset = -1;
block_t old_blkaddr, new_blkaddr; block_t new_blkaddr;
ne = list_entry(cur, struct nat_entry, list); ne = list_entry(cur, struct nat_entry, list);
nid = nat_get_nid(ne); nid = nat_get_nid(ne);
@ -1585,7 +1578,6 @@ void flush_nat_entries(struct f2fs_sb_info *sbi)
offset = lookup_journal_in_cursum(sum, NAT_JOURNAL, nid, 1); offset = lookup_journal_in_cursum(sum, NAT_JOURNAL, nid, 1);
if (offset >= 0) { if (offset >= 0) {
raw_ne = nat_in_journal(sum, offset); raw_ne = nat_in_journal(sum, offset);
old_blkaddr = le32_to_cpu(raw_ne.block_addr);
goto flush_now; goto flush_now;
} }
to_nat_page: to_nat_page:
@ -1607,7 +1599,6 @@ void flush_nat_entries(struct f2fs_sb_info *sbi)
BUG_ON(!nat_blk); BUG_ON(!nat_blk);
raw_ne = nat_blk->entries[nid - start_nid]; raw_ne = nat_blk->entries[nid - start_nid];
old_blkaddr = le32_to_cpu(raw_ne.block_addr);
flush_now: flush_now:
new_blkaddr = nat_get_blkaddr(ne); new_blkaddr = nat_get_blkaddr(ne);

10
fs/f2fs/recovery.c
View file

@ -144,14 +144,15 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
goto out; goto out;
} }
INIT_LIST_HEAD(&entry->list);
list_add_tail(&entry->list, head);
entry->inode = f2fs_iget(sbi->sb, ino_of_node(page)); entry->inode = f2fs_iget(sbi->sb, ino_of_node(page));
if (IS_ERR(entry->inode)) { if (IS_ERR(entry->inode)) {
err = PTR_ERR(entry->inode); err = PTR_ERR(entry->inode);
kmem_cache_free(fsync_entry_slab, entry);
goto out; goto out;
} }
INIT_LIST_HEAD(&entry->list);
list_add_tail(&entry->list, head);
entry->blkaddr = blkaddr; entry->blkaddr = blkaddr;
} }
if (IS_INODE(page)) { if (IS_INODE(page)) {
@ -228,6 +229,9 @@ static void check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
/* Deallocate previous index in the node page */ /* Deallocate previous index in the node page */
inode = f2fs_iget_nowait(sbi->sb, ino); inode = f2fs_iget_nowait(sbi->sb, ino);
if (IS_ERR(inode))
return;
truncate_hole(inode, bidx, bidx + 1); truncate_hole(inode, bidx, bidx + 1);
iput(inode); iput(inode);
} }

46
fs/f2fs/segment.c
View file

@ -12,54 +12,23 @@
#include <linux/f2fs_fs.h> #include <linux/f2fs_fs.h>
#include <linux/bio.h> #include <linux/bio.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/prefetch.h>
#include <linux/vmalloc.h> #include <linux/vmalloc.h>
#include "f2fs.h" #include "f2fs.h"
#include "segment.h" #include "segment.h"
#include "node.h" #include "node.h"
static int need_to_flush(struct f2fs_sb_info *sbi)
{
unsigned int pages_per_sec = (1 << sbi->log_blocks_per_seg) *
sbi->segs_per_sec;
int node_secs = ((get_pages(sbi, F2FS_DIRTY_NODES) + pages_per_sec - 1)
>> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
int dent_secs = ((get_pages(sbi, F2FS_DIRTY_DENTS) + pages_per_sec - 1)
>> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
if (sbi->por_doing)
return 0;
if (free_sections(sbi) <= (node_secs + 2 * dent_secs +
reserved_sections(sbi)))
return 1;
return 0;
}
/* /*
* This function balances dirty node and dentry pages. * This function balances dirty node and dentry pages.
* In addition, it controls garbage collection. * In addition, it controls garbage collection.
*/ */
void f2fs_balance_fs(struct f2fs_sb_info *sbi) void f2fs_balance_fs(struct f2fs_sb_info *sbi)
{ {
struct writeback_control wbc = {
.sync_mode = WB_SYNC_ALL,
.nr_to_write = LONG_MAX,
.for_reclaim = 0,
};
if (sbi->por_doing)
return;
/* /*
* We should do checkpoint when there are so many dirty node pages * We should do GC or end up with checkpoint, if there are so many dirty
* with enough free segments. After then, we should do GC. * dir/node pages without enough free segments.
*/ */
if (need_to_flush(sbi)) {
sync_dirty_dir_inodes(sbi);
sync_node_pages(sbi, 0, &wbc);
}
if (has_not_enough_free_secs(sbi)) { if (has_not_enough_free_secs(sbi)) {
mutex_lock(&sbi->gc_mutex); mutex_lock(&sbi->gc_mutex);
f2fs_gc(sbi, 1); f2fs_gc(sbi, 1);
@ -631,7 +600,6 @@ static void f2fs_end_io_write(struct bio *bio, int err)
if (page->mapping) if (page->mapping)
set_bit(AS_EIO, &page->mapping->flags); set_bit(AS_EIO, &page->mapping->flags);
set_ckpt_flags(p->sbi->ckpt, CP_ERROR_FLAG); set_ckpt_flags(p->sbi->ckpt, CP_ERROR_FLAG);
set_page_dirty(page);
} }
end_page_writeback(page); end_page_writeback(page);
dec_page_count(p->sbi, F2FS_WRITEBACK); dec_page_count(p->sbi, F2FS_WRITEBACK);
@ -791,11 +759,10 @@ static int __get_segment_type(struct page *page, enum page_type p_type)
return __get_segment_type_2(page, p_type); return __get_segment_type_2(page, p_type);
case 4: case 4:
return __get_segment_type_4(page, p_type); return __get_segment_type_4(page, p_type);
case 6:
return __get_segment_type_6(page, p_type);
default:
BUG();
} }
/* NR_CURSEG_TYPE(6) logs by default */
BUG_ON(sbi->active_logs != NR_CURSEG_TYPE);
return __get_segment_type_6(page, p_type);
} }
static void do_write_page(struct f2fs_sb_info *sbi, struct page *page, static void do_write_page(struct f2fs_sb_info *sbi, struct page *page,
@ -1608,7 +1575,6 @@ static int build_dirty_segmap(struct f2fs_sb_info *sbi)
for (i = 0; i < NR_DIRTY_TYPE; i++) { for (i = 0; i < NR_DIRTY_TYPE; i++) {
dirty_i->dirty_segmap[i] = kzalloc(bitmap_size, GFP_KERNEL); dirty_i->dirty_segmap[i] = kzalloc(bitmap_size, GFP_KERNEL);
dirty_i->nr_dirty[i] = 0;
if (!dirty_i->dirty_segmap[i]) if (!dirty_i->dirty_segmap[i])
return -ENOMEM; return -ENOMEM;
} }

15
fs/f2fs/segment.h
View file

@ -459,7 +459,20 @@ static inline int get_ssr_segment(struct f2fs_sb_info *sbi, int type)
static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi) static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi)
{ {
return free_sections(sbi) <= reserved_sections(sbi); unsigned int pages_per_sec = (1 << sbi->log_blocks_per_seg) *
sbi->segs_per_sec;
int node_secs = ((get_pages(sbi, F2FS_DIRTY_NODES) + pages_per_sec - 1)
>> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
int dent_secs = ((get_pages(sbi, F2FS_DIRTY_DENTS) + pages_per_sec - 1)
>> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
if (sbi->por_doing)
return false;
if (free_sections(sbi) <= (node_secs + 2 * dent_secs +
reserved_sections(sbi)))
return true;
return false;
} }
static inline int utilization(struct f2fs_sb_info *sbi) static inline int utilization(struct f2fs_sb_info *sbi)

15
fs/f2fs/super.c
View file

@ -119,7 +119,6 @@ static void f2fs_put_super(struct super_block *sb)
int f2fs_sync_fs(struct super_block *sb, int sync) int f2fs_sync_fs(struct super_block *sb, int sync)
{ {
struct f2fs_sb_info *sbi = F2FS_SB(sb); struct f2fs_sb_info *sbi = F2FS_SB(sb);
int ret = 0;
if (!sbi->s_dirty && !get_pages(sbi, F2FS_DIRTY_NODES)) if (!sbi->s_dirty && !get_pages(sbi, F2FS_DIRTY_NODES))
return 0; return 0;
@ -127,7 +126,7 @@ int f2fs_sync_fs(struct super_block *sb, int sync)
if (sync) if (sync)
write_checkpoint(sbi, false, false); write_checkpoint(sbi, false, false);
return ret; return 0;
} }
static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf) static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
@ -148,8 +147,8 @@ static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
buf->f_bfree = buf->f_blocks - valid_user_blocks(sbi) - ovp_count; buf->f_bfree = buf->f_blocks - valid_user_blocks(sbi) - ovp_count;
buf->f_bavail = user_block_count - valid_user_blocks(sbi); buf->f_bavail = user_block_count - valid_user_blocks(sbi);
buf->f_files = valid_inode_count(sbi); buf->f_files = sbi->total_node_count;
buf->f_ffree = sbi->total_node_count - valid_node_count(sbi); buf->f_ffree = sbi->total_node_count - valid_inode_count(sbi);
buf->f_namelen = F2FS_MAX_NAME_LEN; buf->f_namelen = F2FS_MAX_NAME_LEN;
buf->f_fsid.val[0] = (u32)id; buf->f_fsid.val[0] = (u32)id;
@ -302,7 +301,7 @@ static int parse_options(struct f2fs_sb_info *sbi, char *options)
case Opt_active_logs: case Opt_active_logs:
if (args->from && match_int(args, &arg)) if (args->from && match_int(args, &arg))
return -EINVAL; return -EINVAL;
if (arg != 2 && arg != 4 && arg != 6) if (arg != 2 && arg != 4 && arg != NR_CURSEG_TYPE)
return -EINVAL; return -EINVAL;
sbi->active_logs = arg; sbi->active_logs = arg;
break; break;
@ -528,8 +527,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
/* if there are nt orphan nodes free them */ /* if there are nt orphan nodes free them */
err = -EINVAL; err = -EINVAL;
if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG) && if (recover_orphan_inodes(sbi))
recover_orphan_inodes(sbi))
goto free_node_inode; goto free_node_inode;
/* read root inode and dentry */ /* read root inode and dentry */
@ -548,8 +546,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
} }
/* recover fsynced data */ /* recover fsynced data */
if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG) && if (!test_opt(sbi, DISABLE_ROLL_FORWARD))
!test_opt(sbi, DISABLE_ROLL_FORWARD))
recover_fsync_data(sbi); recover_fsync_data(sbi);
/* After POR, we can run background GC thread */ /* After POR, we can run background GC thread */

5
fs/f2fs/xattr.c
View file

@ -208,7 +208,7 @@ int f2fs_getxattr(struct inode *inode, int name_index, const char *name,
struct page *page; struct page *page;
void *base_addr; void *base_addr;
int error = 0, found = 0; int error = 0, found = 0;
int value_len, name_len; size_t value_len, name_len;
if (name == NULL) if (name == NULL)
return -EINVAL; return -EINVAL;
@ -304,7 +304,8 @@ int f2fs_setxattr(struct inode *inode, int name_index, const char *name,
struct f2fs_xattr_entry *here, *last; struct f2fs_xattr_entry *here, *last;
struct page *page; struct page *page;
void *base_addr; void *base_addr;
int error, found, free, name_len, newsize; int error, found, free, newsize;
size_t name_len;
char *pval; char *pval;
if (name == NULL) if (name == NULL)