![Jaegeuk Kim](/assets/img/avatar_default.png)
This patch introduces a inode number list in which represents inodes having appended data writes or updated data writes after last checkpoint. This will be used at fsync to determine whether the recovery information should be written or not. Reviewed-by: Chao Yu <chao2.yu@samsung.com> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
252 lines
6 KiB
C
252 lines
6 KiB
C
/*
|
|
* fs/f2fs/inline.c
|
|
* Copyright (c) 2013, Intel Corporation
|
|
* Authors: Huajun Li <huajun.li@intel.com>
|
|
* Haicheng Li <haicheng.li@intel.com>
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
#include <linux/f2fs_fs.h>
|
|
|
|
#include "f2fs.h"
|
|
|
|
bool f2fs_may_inline(struct inode *inode)
|
|
{
|
|
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
|
|
block_t nr_blocks;
|
|
loff_t i_size;
|
|
|
|
if (!test_opt(sbi, INLINE_DATA))
|
|
return false;
|
|
|
|
nr_blocks = F2FS_I(inode)->i_xattr_nid ? 3 : 2;
|
|
if (inode->i_blocks > nr_blocks)
|
|
return false;
|
|
|
|
i_size = i_size_read(inode);
|
|
if (i_size > MAX_INLINE_DATA)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
int f2fs_read_inline_data(struct inode *inode, struct page *page)
|
|
{
|
|
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
|
|
struct page *ipage;
|
|
void *src_addr, *dst_addr;
|
|
|
|
if (page->index) {
|
|
zero_user_segment(page, 0, PAGE_CACHE_SIZE);
|
|
goto out;
|
|
}
|
|
|
|
ipage = get_node_page(sbi, inode->i_ino);
|
|
if (IS_ERR(ipage)) {
|
|
unlock_page(page);
|
|
return PTR_ERR(ipage);
|
|
}
|
|
|
|
zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);
|
|
|
|
/* Copy the whole inline data block */
|
|
src_addr = inline_data_addr(ipage);
|
|
dst_addr = kmap(page);
|
|
memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
|
|
kunmap(page);
|
|
f2fs_put_page(ipage, 1);
|
|
|
|
out:
|
|
SetPageUptodate(page);
|
|
unlock_page(page);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __f2fs_convert_inline_data(struct inode *inode, struct page *page)
|
|
{
|
|
int err;
|
|
struct page *ipage;
|
|
struct dnode_of_data dn;
|
|
void *src_addr, *dst_addr;
|
|
block_t new_blk_addr;
|
|
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
|
|
struct f2fs_io_info fio = {
|
|
.type = DATA,
|
|
.rw = WRITE_SYNC | REQ_PRIO,
|
|
};
|
|
|
|
f2fs_lock_op(sbi);
|
|
ipage = get_node_page(sbi, inode->i_ino);
|
|
if (IS_ERR(ipage)) {
|
|
err = PTR_ERR(ipage);
|
|
goto out;
|
|
}
|
|
|
|
/*
|
|
* i_addr[0] is not used for inline data,
|
|
* so reserving new block will not destroy inline data
|
|
*/
|
|
set_new_dnode(&dn, inode, ipage, NULL, 0);
|
|
err = f2fs_reserve_block(&dn, 0);
|
|
if (err)
|
|
goto out;
|
|
|
|
f2fs_wait_on_page_writeback(page, DATA);
|
|
zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);
|
|
|
|
/* Copy the whole inline data block */
|
|
src_addr = inline_data_addr(ipage);
|
|
dst_addr = kmap(page);
|
|
memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
|
|
kunmap(page);
|
|
SetPageUptodate(page);
|
|
|
|
/* write data page to try to make data consistent */
|
|
set_page_writeback(page);
|
|
write_data_page(page, &dn, &new_blk_addr, &fio);
|
|
update_extent_cache(new_blk_addr, &dn);
|
|
f2fs_wait_on_page_writeback(page, DATA);
|
|
|
|
/* clear inline data and flag after data writeback */
|
|
zero_user_segment(ipage, INLINE_DATA_OFFSET,
|
|
INLINE_DATA_OFFSET + MAX_INLINE_DATA);
|
|
clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
|
|
stat_dec_inline_inode(inode);
|
|
|
|
sync_inode_page(&dn);
|
|
f2fs_put_dnode(&dn);
|
|
out:
|
|
f2fs_unlock_op(sbi);
|
|
return err;
|
|
}
|
|
|
|
int f2fs_convert_inline_data(struct inode *inode, pgoff_t to_size)
|
|
{
|
|
struct page *page;
|
|
int err;
|
|
|
|
if (!f2fs_has_inline_data(inode))
|
|
return 0;
|
|
else if (to_size <= MAX_INLINE_DATA)
|
|
return 0;
|
|
|
|
page = grab_cache_page(inode->i_mapping, 0);
|
|
if (!page)
|
|
return -ENOMEM;
|
|
|
|
err = __f2fs_convert_inline_data(inode, page);
|
|
f2fs_put_page(page, 1);
|
|
return err;
|
|
}
|
|
|
|
int f2fs_write_inline_data(struct inode *inode,
|
|
struct page *page, unsigned size)
|
|
{
|
|
void *src_addr, *dst_addr;
|
|
struct page *ipage;
|
|
struct dnode_of_data dn;
|
|
int err;
|
|
|
|
set_new_dnode(&dn, inode, NULL, NULL, 0);
|
|
err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
|
|
if (err)
|
|
return err;
|
|
ipage = dn.inode_page;
|
|
|
|
f2fs_wait_on_page_writeback(ipage, NODE);
|
|
zero_user_segment(ipage, INLINE_DATA_OFFSET,
|
|
INLINE_DATA_OFFSET + MAX_INLINE_DATA);
|
|
src_addr = kmap(page);
|
|
dst_addr = inline_data_addr(ipage);
|
|
memcpy(dst_addr, src_addr, size);
|
|
kunmap(page);
|
|
|
|
/* Release the first data block if it is allocated */
|
|
if (!f2fs_has_inline_data(inode)) {
|
|
truncate_data_blocks_range(&dn, 1);
|
|
set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
|
|
stat_inc_inline_inode(inode);
|
|
}
|
|
|
|
set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
|
|
sync_inode_page(&dn);
|
|
f2fs_put_dnode(&dn);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void truncate_inline_data(struct inode *inode, u64 from)
|
|
{
|
|
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
|
|
struct page *ipage;
|
|
|
|
if (from >= MAX_INLINE_DATA)
|
|
return;
|
|
|
|
ipage = get_node_page(sbi, inode->i_ino);
|
|
if (IS_ERR(ipage))
|
|
return;
|
|
|
|
f2fs_wait_on_page_writeback(ipage, NODE);
|
|
|
|
zero_user_segment(ipage, INLINE_DATA_OFFSET + from,
|
|
INLINE_DATA_OFFSET + MAX_INLINE_DATA);
|
|
set_page_dirty(ipage);
|
|
f2fs_put_page(ipage, 1);
|
|
}
|
|
|
|
int recover_inline_data(struct inode *inode, struct page *npage)
|
|
{
|
|
struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
|
|
struct f2fs_inode *ri = NULL;
|
|
void *src_addr, *dst_addr;
|
|
struct page *ipage;
|
|
|
|
/*
|
|
* The inline_data recovery policy is as follows.
|
|
* [prev.] [next] of inline_data flag
|
|
* o o -> recover inline_data
|
|
* o x -> remove inline_data, and then recover data blocks
|
|
* x o -> remove inline_data, and then recover inline_data
|
|
* x x -> recover data blocks
|
|
*/
|
|
if (IS_INODE(npage))
|
|
ri = F2FS_INODE(npage);
|
|
|
|
if (f2fs_has_inline_data(inode) &&
|
|
ri && ri->i_inline & F2FS_INLINE_DATA) {
|
|
process_inline:
|
|
ipage = get_node_page(sbi, inode->i_ino);
|
|
f2fs_bug_on(IS_ERR(ipage));
|
|
|
|
f2fs_wait_on_page_writeback(ipage, NODE);
|
|
|
|
src_addr = inline_data_addr(npage);
|
|
dst_addr = inline_data_addr(ipage);
|
|
memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
|
|
update_inode(inode, ipage);
|
|
f2fs_put_page(ipage, 1);
|
|
return -1;
|
|
}
|
|
|
|
if (f2fs_has_inline_data(inode)) {
|
|
ipage = get_node_page(sbi, inode->i_ino);
|
|
f2fs_bug_on(IS_ERR(ipage));
|
|
f2fs_wait_on_page_writeback(ipage, NODE);
|
|
zero_user_segment(ipage, INLINE_DATA_OFFSET,
|
|
INLINE_DATA_OFFSET + MAX_INLINE_DATA);
|
|
clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
|
|
update_inode(inode, ipage);
|
|
f2fs_put_page(ipage, 1);
|
|
} else if (ri && ri->i_inline & F2FS_INLINE_DATA) {
|
|
truncate_blocks(inode, 0);
|
|
set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
|
|
goto process_inline;
|
|
}
|
|
return 0;
|
|
}
|