backport f2fs to kernel 2.6.34
Phil Vandry
vandry at TZoNE.ORG
Sun Nov 11 04:05:51 CET 2012
---
fs/f2fs/acl.c | 61 ++++++++++++++++++++------
fs/f2fs/acl.h | 2 +-
fs/f2fs/data.c | 4 +-
fs/f2fs/dir.c | 30 ++++++------
fs/f2fs/f2fs.h | 5 +-
fs/f2fs/file.c | 123 +++++++++++++----------------------------------------
fs/f2fs/gc.h | 2 +-
fs/f2fs/inode.c | 6 +--
fs/f2fs/namei.c | 14 +++---
fs/f2fs/node.c | 8 ++--
fs/f2fs/segment.c | 15 ++++--
fs/f2fs/super.c | 24 ++++------
fs/f2fs/xattr.c | 6 +-
fs/f2fs/xattr.h | 10 ++--
14 files changed, 139 insertions(+), 171 deletions(-)
diff --git a/fs/f2fs/acl.c b/fs/f2fs/acl.c
index ce661ae..bc58644 100644
--- a/fs/f2fs/acl.c
+++ b/fs/f2fs/acl.c
@@ -190,6 +190,23 @@ struct posix_acl *f2fs_get_acl(struct inode *inode, int type)
return acl;
}
+int
+f2fs_check_acl(struct inode *inode, int mask)
+{
+ struct posix_acl *acl;
+
+ acl = f2fs_get_acl(inode, ACL_TYPE_ACCESS);
+ if (IS_ERR(acl))
+ return PTR_ERR(acl);
+ if (acl) {
+ int error = posix_acl_permission(inode, acl, mask);
+ posix_acl_release(acl);
+ return error;
+ }
+
+ return -EAGAIN;
+}
+
static int f2fs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
{
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
@@ -208,9 +225,11 @@ static int f2fs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
case ACL_TYPE_ACCESS:
name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS;
if (acl) {
- error = posix_acl_equiv_mode(acl, &inode->i_mode);
+ mode_t mode = inode->i_mode;
+ error = posix_acl_equiv_mode(acl, &mode);
if (error < 0)
return error;
+ inode->i_mode = mode;
set_acl_inode(fi, inode->i_mode);
if (error == 0)
acl = NULL;
@@ -262,17 +281,28 @@ int f2fs_init_acl(struct inode *inode, struct inode *dir)
}
if (test_opt(sbi, POSIX_ACL) && acl) {
+ struct posix_acl *clone;
+ mode_t mode;
if (S_ISDIR(inode->i_mode)) {
error = f2fs_set_acl(inode, ACL_TYPE_DEFAULT, acl);
if (error)
goto cleanup;
}
- error = posix_acl_create(&acl, GFP_KERNEL, &inode->i_mode);
- if (error < 0)
- return error;
- if (error > 0)
- error = f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl);
+ clone = posix_acl_clone(acl, GFP_KERNEL);
+ error = -ENOMEM;
+ if (!clone)
+ goto cleanup;
+ mode = inode->i_mode;
+ error = posix_acl_create_masq(clone, &mode);
+ if (error >= 0) {
+ inode->i_mode = mode;
+ if (error > 0) {
+ /* This is an extended ACL */
+ error = f2fs_set_acl(inode, ACL_TYPE_ACCESS, clone);
+ }
+ }
+ posix_acl_release(clone);
}
cleanup:
posix_acl_release(acl);
@@ -282,7 +312,7 @@ cleanup:
int f2fs_acl_chmod(struct inode *inode)
{
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
- struct posix_acl *acl;
+ struct posix_acl *acl, *clone;
int error;
mode_t mode = get_inode_mode(inode);
@@ -295,11 +325,14 @@ int f2fs_acl_chmod(struct inode *inode)
if (IS_ERR(acl) || !acl)
return PTR_ERR(acl);
- error = posix_acl_chmod(&acl, GFP_KERNEL, mode);
- if (error)
- return error;
- error = f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl);
+ clone = posix_acl_clone(acl, GFP_KERNEL);
posix_acl_release(acl);
+ if (!clone)
+ return -ENOMEM;
+ error = posix_acl_chmod_masq(clone, inode->i_mode);
+ if (!error)
+ error = f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl);
+ posix_acl_release(clone);
return error;
}
@@ -362,7 +395,7 @@ static int f2fs_xattr_set_acl(struct dentry *dentry, const char *name,
if (strcmp(name, "") != 0)
return -EINVAL;
- if (!inode_owner_or_capable(inode))
+ if (!is_owner_or_cap(inode))
return -EPERM;
if (value) {
@@ -385,7 +418,7 @@ release_and_out:
return error;
}
-const struct xattr_handler f2fs_xattr_acl_default_handler = {
+struct xattr_handler f2fs_xattr_acl_default_handler = {
.prefix = POSIX_ACL_XATTR_DEFAULT,
.flags = ACL_TYPE_DEFAULT,
.list = f2fs_xattr_list_acl,
@@ -393,7 +426,7 @@ const struct xattr_handler f2fs_xattr_acl_default_handler = {
.set = f2fs_xattr_set_acl,
};
-const struct xattr_handler f2fs_xattr_acl_access_handler = {
+struct xattr_handler f2fs_xattr_acl_access_handler = {
.prefix = POSIX_ACL_XATTR_ACCESS,
.flags = ACL_TYPE_ACCESS,
.list = f2fs_xattr_list_acl,
diff --git a/fs/f2fs/acl.h b/fs/f2fs/acl.h
index 336ec0c..369b4ff 100644
--- a/fs/f2fs/acl.h
+++ b/fs/f2fs/acl.h
@@ -36,7 +36,7 @@ struct f2fs_acl_header {
#ifdef CONFIG_F2FS_FS_POSIX_ACL
-extern struct posix_acl *f2fs_get_acl(struct inode *inode, int type);
+extern int f2fs_check_acl(struct inode *inode, int type);
extern int f2fs_acl_chmod(struct inode *inode);
extern int f2fs_init_acl(struct inode *inode, struct inode *dir);
#else
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 0cb9126..bd187d0 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -651,8 +651,8 @@ static ssize_t f2fs_direct_IO(int rw, struct kiocb *iocb,
return 0;
/* Needs synchronization with the cleaner */
- return blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
- get_data_block_ro);
+ return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov, offset, nr_segs,
+ get_data_block_ro, NULL);
}
static void f2fs_invalidate_data_page(struct page *page, unsigned long offset)
diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index 51f895f..487642c 100644
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -95,7 +95,7 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
struct f2fs_dentry_block *dentry_blk = kmap(dentry_page);
int slots;
- bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
+ bit_pos = ext2_find_next_bit(&dentry_blk->dentry_bitmap,
NR_DENTRY_IN_BLOCK, 0);
while (bit_pos < NR_DENTRY_IN_BLOCK) {
de = &dentry_blk->dentry[bit_pos];
@@ -110,7 +110,7 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
}
}
next_pos = bit_pos + slots;
- bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
+ bit_pos = ext2_find_next_bit(&dentry_blk->dentry_bitmap,
NR_DENTRY_IN_BLOCK, next_pos);
if (bit_pos >= NR_DENTRY_IN_BLOCK)
end_pos = NR_DENTRY_IN_BLOCK;
@@ -333,13 +333,13 @@ static int room_for_filename(struct f2fs_dentry_block *dentry_blk, int slots)
int bit_start = 0;
int zero_start, zero_end;
next:
- zero_start = find_next_zero_bit_le(&dentry_blk->dentry_bitmap,
+ zero_start = ext2_find_next_zero_bit(&dentry_blk->dentry_bitmap,
NR_DENTRY_IN_BLOCK,
bit_start);
if (zero_start >= NR_DENTRY_IN_BLOCK)
return NR_DENTRY_IN_BLOCK;
- zero_end = find_next_bit_le(&dentry_blk->dentry_bitmap,
+ zero_end = ext2_find_next_bit(&dentry_blk->dentry_bitmap,
NR_DENTRY_IN_BLOCK,
zero_start);
if (zero_end - zero_start >= slots)
@@ -427,7 +427,7 @@ add_dentry:
de->ino = cpu_to_le32(inode->i_ino);
set_de_type(de, inode);
for (i = 0; i < slots; i++)
- test_and_set_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
+ ext2_set_bit(bit_pos + i, &dentry_blk->dentry_bitmap);
set_page_dirty(dentry_page);
update_parent_metadata(dir, inode, current_depth);
fail:
@@ -462,10 +462,10 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
dentry_blk = (struct f2fs_dentry_block *)kaddr;
bit_pos = dentry - (struct f2fs_dir_entry *)dentry_blk->dentry;
for (i = 0; i < slots; i++)
- test_and_clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
+ ext2_clear_bit(bit_pos + i, &dentry_blk->dentry_bitmap);
/* Let's check and deallocate this dentry page */
- bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
+ bit_pos = ext2_find_next_bit(&dentry_blk->dentry_bitmap,
NR_DENTRY_IN_BLOCK,
0);
kunmap(page); /* kunmap - pair of f2fs_find_entry */
@@ -518,7 +518,7 @@ int f2fs_make_empty(struct inode *inode, struct inode *parent)
if (IS_ERR(dentry_page))
return PTR_ERR(dentry_page);
- kaddr = kmap_atomic(dentry_page);
+ kaddr = kmap_atomic(dentry_page, KM_USER0);
dentry_blk = (struct f2fs_dentry_block *)kaddr;
de = &dentry_blk->dentry[0];
@@ -535,9 +535,9 @@ int f2fs_make_empty(struct inode *inode, struct inode *parent)
memcpy(dentry_blk->filename[1], "..", 2);
set_de_type(de, inode);
- test_and_set_bit_le(0, &dentry_blk->dentry_bitmap);
- test_and_set_bit_le(1, &dentry_blk->dentry_bitmap);
- kunmap_atomic(kaddr);
+ ext2_set_bit(0, &dentry_blk->dentry_bitmap);
+ ext2_set_bit(1, &dentry_blk->dentry_bitmap);
+ kunmap_atomic(kaddr, KM_USER0);
set_page_dirty(dentry_page);
f2fs_put_page(dentry_page, 1);
@@ -562,16 +562,16 @@ bool f2fs_empty_dir(struct inode *dir)
return false;
}
- kaddr = kmap_atomic(dentry_page);
+ kaddr = kmap_atomic(dentry_page, KM_USER0);
dentry_blk = (struct f2fs_dentry_block *)kaddr;
if (bidx == 0)
bit_pos = 2;
else
bit_pos = 0;
- bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
+ bit_pos = ext2_find_next_bit(&dentry_blk->dentry_bitmap,
NR_DENTRY_IN_BLOCK,
bit_pos);
- kunmap_atomic(kaddr);
+ kunmap_atomic(kaddr, KM_USER0);
f2fs_put_page(dentry_page, 1);
@@ -610,7 +610,7 @@ static int f2fs_readdir(struct file *file, void *dirent, filldir_t filldir)
dentry_blk = kmap(dentry_page);
while (bit_pos < NR_DENTRY_IN_BLOCK) {
d_type = DT_UNKNOWN;
- bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
+ bit_pos = ext2_find_next_bit(&dentry_blk->dentry_bitmap,
NR_DENTRY_IN_BLOCK,
bit_pos);
if (bit_pos >= NR_DENTRY_IN_BLOCK)
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 309bd4e..83b00e4 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -17,6 +17,7 @@
#include <linux/version.h>
#include <linux/slab.h>
#include <linux/crc32.h>
+#include <linux/bio.h>
/**
* For mount options
@@ -809,7 +810,7 @@ static inline int cond_clear_inode_flag(struct f2fs_inode_info *fi, int flag)
/**
* file.c
*/
-int f2fs_sync_file(struct file *, loff_t, loff_t, int);
+int f2fs_sync_file(struct file *, struct dentry *, int);
void truncate_data_blocks(struct dnode_of_data *);
void f2fs_truncate(struct inode *);
int f2fs_setattr(struct dentry *, struct iattr *);
@@ -824,7 +825,7 @@ struct inode *f2fs_iget_nowait(struct super_block *, unsigned long);
struct inode *f2fs_iget(struct super_block *, unsigned long);
void update_inode(struct inode *, struct page *);
int f2fs_write_inode(struct inode *, struct writeback_control *);
-void f2fs_evict_inode(struct inode *);
+void f2fs_clear_inode(struct inode *);
/**
* dir.c
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 48bb9f1..399b05b 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -17,6 +17,7 @@
#include <linux/types.h>
#include <linux/uaccess.h>
#include <linux/mount.h>
+#include <linux/dcache.h>
#include "f2fs.h"
#include "node.h"
@@ -105,7 +106,14 @@ static int need_to_sync_dir(struct f2fs_sb_info *sbi, struct inode *inode)
nid_t pino;
inode = igrab(inode);
- dentry = d_find_any_alias(inode);
+ dentry = NULL;
+ spin_lock(&inode->i_lock);
+ if (!list_empty(&inode->i_dentry)) {
+ dentry = list_first_entry(&inode->i_dentry,
+ struct dentry, d_alias);
+ dget(dentry);
+ }
+ spin_unlock(&inode->i_lock);
if (!dentry) {
iput(inode);
return 0;
@@ -116,7 +124,7 @@ static int need_to_sync_dir(struct f2fs_sb_info *sbi, struct inode *inode)
return !is_checkpointed_node(sbi, pino);
}
-int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
+int f2fs_sync_file(struct file *file, struct dentry *unused, int datasync)
{
struct inode *inode = file->f_mapping->host;
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
@@ -129,10 +137,6 @@ int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
.for_reclaim = 0,
};
- ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
- if (ret)
- return ret;
-
mutex_lock(&inode->i_mutex);
if (inode->i_sb->s_flags & MS_RDONLY)
@@ -333,11 +337,11 @@ static void do_attr_copy(struct inode *inode, struct iattr *attr)
struct inode copy_inode;
dup_attr(©_inode, inode, NULL);
- setattr_copy(©_inode, attr);
+ inode_setattr(©_inode, attr);
dup_attr(inode, ©_inode, fi);
}
#else
-#define __do_attr_copy setattr_copy
+#define __do_attr_copy generic_setattr
#endif
int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
@@ -372,37 +376,6 @@ out_err:
return err;
}
-const struct inode_operations f2fs_file_inode_operations = {
- .truncate = f2fs_truncate,
- .getattr = f2fs_getattr,
- .setattr = f2fs_setattr,
- .get_acl = f2fs_get_acl,
-#ifdef CONFIG_F2FS_FS_XATTR
- .setxattr = generic_setxattr,
- .getxattr = generic_getxattr,
- .listxattr = f2fs_listxattr,
- .removexattr = generic_removexattr,
-#endif
-};
-
-static void fill_zero(struct inode *inode, pgoff_t index,
- loff_t start, loff_t len)
-{
- struct page *page;
-
- if (!len)
- return;
-
- page = get_new_data_page(inode, index, false);
-
- if (!IS_ERR(page)) {
- wait_on_page_writeback(page);
- zero_user(page, start, len);
- set_page_dirty(page);
- f2fs_put_page(page, 1);
- }
-}
-
int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
{
pgoff_t index;
@@ -430,49 +403,6 @@ int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
return 0;
}
-static int punch_hole(struct inode *inode, loff_t offset, loff_t len, int mode)
-{
- pgoff_t pg_start, pg_end;
- loff_t off_start, off_end;
- int ret = 0;
-
- pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
- pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
-
- off_start = offset & (PAGE_CACHE_SIZE - 1);
- off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
-
- if (pg_start == pg_end) {
- fill_zero(inode, pg_start, off_start,
- off_end - off_start);
- } else {
- if (off_start)
- fill_zero(inode, pg_start++, off_start,
- PAGE_CACHE_SIZE - off_start);
- if (off_end)
- fill_zero(inode, pg_end, 0, off_end);
-
- if (pg_start < pg_end) {
- struct address_space *mapping = inode->i_mapping;
- loff_t blk_start, blk_end;
-
- blk_start = pg_start << PAGE_CACHE_SHIFT;
- blk_end = pg_end << PAGE_CACHE_SHIFT;
- truncate_inode_pages_range(mapping, blk_start,
- blk_end - 1);
- ret = truncate_hole(inode, pg_start, pg_end);
- }
- }
-
- if (!(mode & FALLOC_FL_KEEP_SIZE) &&
- i_size_read(inode) <= (offset + len)) {
- i_size_write(inode, offset);
- mark_inode_dirty(inode);
- }
-
- return ret;
-}
-
static int expand_inode_data(struct inode *inode, loff_t offset,
loff_t len, int mode)
{
@@ -535,25 +465,33 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
return ret;
}
-static long f2fs_fallocate(struct file *file, int mode,
+static long f2fs_fallocate(struct inode *inode, int mode,
loff_t offset, loff_t len)
{
- struct inode *inode = file->f_path.dentry->d_inode;
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
long ret;
- if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
- return -EOPNOTSUPP;
-
- if (mode & FALLOC_FL_PUNCH_HOLE)
- ret = punch_hole(inode, offset, len, mode);
- else
- ret = expand_inode_data(inode, offset, len, mode);
+ ret = expand_inode_data(inode, offset, len, mode);
f2fs_balance_fs(sbi);
return ret;
}
+
+const struct inode_operations f2fs_file_inode_operations = {
+ .truncate = f2fs_truncate,
+ .getattr = f2fs_getattr,
+ .setattr = f2fs_setattr,
+ .check_acl = f2fs_check_acl,
+ .fallocate = f2fs_fallocate,
+#ifdef CONFIG_F2FS_FS_XATTR
+ .setxattr = generic_setxattr,
+ .getxattr = generic_getxattr,
+ .listxattr = f2fs_listxattr,
+ .removexattr = generic_removexattr,
+#endif
+};
+
#define F2FS_REG_FLMASK (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
#define F2FS_OTHER_FLMASK (FS_NODUMP_FL | FS_NOATIME_FL)
@@ -586,7 +524,7 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
if (ret)
return ret;
- if (!inode_owner_or_capable(inode)) {
+ if (!is_owner_or_cap(inode)) {
ret = -EACCES;
goto out;
}
@@ -636,7 +574,6 @@ const struct file_operations f2fs_file_operations = {
.open = generic_file_open,
.mmap = f2fs_file_mmap,
.fsync = f2fs_sync_file,
- .fallocate = f2fs_fallocate,
.unlocked_ioctl = f2fs_ioctl,
.splice_read = generic_file_splice_read,
.splice_write = generic_file_splice_write,
diff --git a/fs/f2fs/gc.h b/fs/f2fs/gc.h
index 63d9302..99d0055 100644
--- a/fs/f2fs/gc.h
+++ b/fs/f2fs/gc.h
@@ -187,7 +187,7 @@ static inline int is_idle(struct f2fs_sb_info *sbi)
{
struct block_device *bdev = sbi->sb->s_bdev;
struct request_queue *q = bdev_get_queue(bdev);
- struct request_list *rl = &q->root_rl;
+ struct request_list *rl = &q->rq;
return !(rl->count[BLK_RW_SYNC]) && !(rl->count[BLK_RW_ASYNC]);
}
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index c8c84ef..21444c5 100644
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -89,7 +89,7 @@ static int do_read_inode(struct inode *inode)
inode->i_mode = le16_to_cpu(ri->i_mode);
inode->i_uid = le32_to_cpu(ri->i_uid);
inode->i_gid = le32_to_cpu(ri->i_gid);
- set_nlink(inode, le32_to_cpu(ri->i_links));
+ inode->i_nlink = le32_to_cpu(ri->i_links);
inode->i_size = le64_to_cpu(ri->i_size);
inode->i_blocks = le64_to_cpu(ri->i_blocks);
@@ -230,12 +230,10 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
/**
* Called at the last iput() if i_nlink is zero
*/
-void f2fs_evict_inode(struct inode *inode)
+void f2fs_clear_inode(struct inode *inode)
{
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
- truncate_inode_pages(&inode->i_data, 0);
-
if (inode->i_ino == F2FS_NODE_INO(sbi) ||
inode->i_ino == F2FS_META_INO(sbi))
goto no_delete;
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 2c4e767..8451df1 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -140,8 +140,8 @@ static inline void set_cold_file(struct inode *inode, const unsigned char *name)
}
}
-static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
- bool excl)
+static int f2fs_create(struct inode *dir, struct dentry *dentry, int mode,
+ struct nameidata *nd)
{
struct super_block *sb = dir->i_sb;
struct f2fs_sb_info *sbi = F2FS_SB(sb);
@@ -216,7 +216,7 @@ out:
}
static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
- unsigned int flags)
+ struct nameidata *nd)
{
struct inode *inode = NULL;
struct f2fs_dir_entry *de;
@@ -308,7 +308,7 @@ out:
return err;
}
-static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
+static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
struct inode *inode;
@@ -361,7 +361,7 @@ static int f2fs_rmdir(struct inode *dir, struct dentry *dentry)
}
static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
- umode_t mode, dev_t rdev)
+ int mode, dev_t rdev)
{
struct super_block *sb = dir->i_sb;
struct f2fs_sb_info *sbi = F2FS_SB(sb);
@@ -515,7 +515,7 @@ const struct inode_operations f2fs_dir_inode_operations = {
.mknod = f2fs_mknod,
.rename = f2fs_rename,
.setattr = f2fs_setattr,
- .get_acl = f2fs_get_acl,
+ .check_acl = f2fs_check_acl,
#ifdef CONFIG_F2FS_FS_XATTR
.setxattr = generic_setxattr,
.getxattr = generic_getxattr,
@@ -539,7 +539,7 @@ const struct inode_operations f2fs_symlink_inode_operations = {
const struct inode_operations f2fs_special_inode_operations = {
.setattr = f2fs_setattr,
- .get_acl = f2fs_get_acl,
+ .check_acl = f2fs_check_acl,
#ifdef CONFIG_F2FS_FS_XATTR
.setxattr = generic_setxattr,
.getxattr = generic_getxattr,
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index 19eeed9..d1244bc 100644
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1432,8 +1432,8 @@ int recover_inode_page(struct f2fs_sb_info *sbi, struct page *page)
SetPageUptodate(ipage);
fill_node_footer(ipage, ino, ino, 0, true);
- src = kmap_atomic(page);
- dst = kmap_atomic(ipage);
+ src = kmap_atomic(page, KM_USER0);
+ dst = kmap_atomic(ipage, KM_USER0);
memcpy(dst, src, F2FS_INODE_SIZE);
rn = (struct f2fs_node *)dst;
@@ -1441,8 +1441,8 @@ int recover_inode_page(struct f2fs_sb_info *sbi, struct page *page)
rn->i.i_blocks = 1;
rn->i.i_links = 1;
rn->i.i_xattr_nid = 0;
- kunmap_atomic(dst);
- kunmap_atomic(src);
+ kunmap_atomic(dst, KM_USER0);
+ kunmap_atomic(src, KM_USER0);
new_ni = old_ni;
new_ni.ino = ino;
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 64a5499..2191c50 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -12,6 +12,7 @@
#include <linux/f2fs_fs.h>
#include <linux/bio.h>
#include <linux/blkdev.h>
+#include <linux/vmalloc.h>
#include "f2fs.h"
#include "segment.h"
@@ -678,8 +679,8 @@ static void do_submit_bio(struct f2fs_sb_info *sbi,
int rw = sync ? WRITE_SYNC : WRITE;
enum page_type btype = type > META ? META : type;
- if (type >= META_FLUSH)
- rw = WRITE_FLUSH_FUA;
+ /* if (type >= META_FLUSH)
+ rw = WRITE_FLUSH_FUA; XXX not sure what to do about this */
if (sbi->bio[btype]) {
struct bio_private *p = sbi->bio[btype]->bi_private;
@@ -1348,6 +1349,7 @@ static int build_sit_info(struct f2fs_sb_info *sbi)
unsigned int sit_segs, start;
char *src_bitmap, *dst_bitmap;
unsigned int bitmap_size;
+ unsigned long size;
/* allocate memory for SIT information */
sit_i = kzalloc(sizeof(struct sit_info), GFP_KERNEL);
@@ -1356,9 +1358,11 @@ static int build_sit_info(struct f2fs_sb_info *sbi)
SM_I(sbi)->sit_info = sit_i;
- sit_i->sentries = vzalloc(TOTAL_SEGS(sbi) * sizeof(struct seg_entry));
+ size = TOTAL_SEGS(sbi) * sizeof(struct seg_entry);
+ sit_i->sentries = vmalloc(size);
if (!sit_i->sentries)
return -ENOMEM;
+ memset(sit_i->sentries, 0, size);
bitmap_size = f2fs_bitmap_size(TOTAL_SEGS(sbi));
sit_i->dirty_sentries_bitmap = kzalloc(bitmap_size, GFP_KERNEL);
@@ -1376,10 +1380,11 @@ static int build_sit_info(struct f2fs_sb_info *sbi)
}
if (sbi->log_segs_per_sec) {
- sit_i->sec_entries = vzalloc(sbi->total_sections *
- sizeof(struct sec_entry));
+ size = sbi->total_sections * sizeof(struct sec_entry);
+ sit_i->sec_entries = vmalloc(size);
if (!sit_i->sec_entries)
return -ENOMEM;
+ memset(sit_i->sec_entries, 0, size);
}
/* get information related with SIT */
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index e120c234..6ecef55 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -78,15 +78,9 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb)
return &fi->vfs_inode;
}
-static void f2fs_i_callback(struct rcu_head *head)
-{
- struct inode *inode = container_of(head, struct inode, i_rcu);
- kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));
-}
-
void f2fs_destroy_inode(struct inode *inode)
{
- call_rcu(&inode->i_rcu, f2fs_i_callback);
+ kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));
}
static void f2fs_put_super(struct super_block *sb)
@@ -158,9 +152,9 @@ static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
return 0;
}
-static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
+static int f2fs_show_options(struct seq_file *seq, struct vfsmount *vfs)
{
- struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb);
+ struct f2fs_sb_info *sbi = F2FS_SB(vfs->mnt_sb);
if (test_opt(sbi, BG_GC))
seq_puts(seq, ",background_gc_on");
@@ -192,7 +186,7 @@ static struct super_operations f2fs_sops = {
.destroy_inode = f2fs_destroy_inode,
.write_inode = f2fs_write_inode,
.show_options = f2fs_show_options,
- .evict_inode = f2fs_evict_inode,
+ .clear_inode = f2fs_clear_inode,
.put_super = f2fs_put_super,
.sync_fs = f2fs_sync_fs,
.statfs = f2fs_statfs,
@@ -439,7 +433,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size)
goto free_root_inode;
- sb->s_root = d_make_root(root); /* allocate root dentry */
+ sb->s_root = d_alloc_root(root); /* allocate root dentry */
if (!sb->s_root)
goto free_root_inode;
@@ -485,16 +479,16 @@ free_sbi:
return -EINVAL;
}
-static struct dentry *f2fs_mount(struct file_system_type *fs_type, int flags,
- const char *dev_name, void *data)
+static int f2fs_get_sb(struct file_system_type *fs_type, int flags,
+ const char *dev_name, void *data, struct vfsmount *mnt)
{
- return mount_bdev(fs_type, flags, dev_name, data, f2fs_fill_super);
+ return get_sb_bdev(fs_type, flags, dev_name, data, f2fs_fill_super, mnt);
}
static struct file_system_type f2fs_fs_type = {
.owner = THIS_MODULE,
.name = "f2fs",
- .mount = f2fs_mount,
+ .get_sb = f2fs_get_sb,
.kill_sb = kill_block_super,
.fs_flags = FS_REQUIRES_DEV,
};
diff --git a/fs/f2fs/xattr.c b/fs/f2fs/xattr.c
index 3497925..0737419 100644
--- a/fs/f2fs/xattr.c
+++ b/fs/f2fs/xattr.c
@@ -102,7 +102,7 @@ static int f2fs_xattr_generic_set(struct dentry *dentry, const char *name,
return f2fs_setxattr(dentry->d_inode, type, name, value, size);
}
-const struct xattr_handler f2fs_xattr_user_handler = {
+struct xattr_handler f2fs_xattr_user_handler = {
.prefix = XATTR_USER_PREFIX,
.flags = F2FS_XATTR_INDEX_USER,
.list = f2fs_xattr_generic_list,
@@ -110,7 +110,7 @@ const struct xattr_handler f2fs_xattr_user_handler = {
.set = f2fs_xattr_generic_set,
};
-const struct xattr_handler f2fs_xattr_trusted_handler = {
+struct xattr_handler f2fs_xattr_trusted_handler = {
.prefix = XATTR_TRUSTED_PREFIX,
.flags = F2FS_XATTR_INDEX_TRUSTED,
.list = f2fs_xattr_generic_list,
@@ -127,7 +127,7 @@ static const struct xattr_handler *f2fs_xattr_handler_map[] = {
[F2FS_XATTR_INDEX_TRUSTED] = &f2fs_xattr_trusted_handler,
};
-const struct xattr_handler *f2fs_xattr_handlers[] = {
+struct xattr_handler *f2fs_xattr_handlers[] = {
&f2fs_xattr_user_handler,
#ifdef CONFIG_F2FS_FS_POSIX_ACL
&f2fs_xattr_acl_access_handler,
diff --git a/fs/f2fs/xattr.h b/fs/f2fs/xattr.h
index f6c5a97..9aed064 100644
--- a/fs/f2fs/xattr.h
+++ b/fs/f2fs/xattr.h
@@ -105,12 +105,12 @@ struct f2fs_xattr_entry {
**/
#ifdef CONFIG_F2FS_FS_XATTR
-extern const struct xattr_handler f2fs_xattr_user_handler;
-extern const struct xattr_handler f2fs_xattr_trusted_handler;
-extern const struct xattr_handler f2fs_xattr_acl_access_handler;
-extern const struct xattr_handler f2fs_xattr_acl_default_handler;
+extern struct xattr_handler f2fs_xattr_user_handler;
+extern struct xattr_handler f2fs_xattr_trusted_handler;
+extern struct xattr_handler f2fs_xattr_acl_access_handler;
+extern struct xattr_handler f2fs_xattr_acl_default_handler;
-extern const struct xattr_handler *f2fs_xattr_handlers[];
+extern struct xattr_handler *f2fs_xattr_handlers[];
extern int f2fs_setxattr(struct inode *inode, int name_index, const char *name,
const void *value, size_t value_len);
--
1.7.2.5
--------------020806040304040604000301--
More information about the community
mailing list