Commit 06a60dec authored by Linus Torvalds's avatar Linus Torvalds

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

Pull f2fs updates from Jaegeuk Kim:
 "New features:
   - in-memory extent_cache
   - fs_shutdown to test power-off-recovery
   - use inline_data to store symlink path
   - show f2fs as a non-misc filesystem

  Major fixes:
   - avoid CPU stalls on sync_dirty_dir_inodes
   - fix some power-off-recovery procedure
   - fix handling of broken symlink correctly
   - fix missing dot and dotdot made by sudden power cuts
   - handle wrong data index during roll-forward recovery
   - preallocate data blocks for direct_io

  ... and a bunch of minor bug fixes and cleanups"

* tag 'for-f2fs-4.1' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (71 commits)
  f2fs: pass checkpoint reason on roll-forward recovery
  f2fs: avoid abnormal behavior on broken symlink
  f2fs: flush symlink path to avoid broken symlink after POR
  f2fs: change 0 to false for bool type
  f2fs: do not recover wrong data index
  f2fs: do not increase link count during recovery
  f2fs: assign parent's i_mode for empty dir
  f2fs: add F2FS_INLINE_DOTS to recover missing dot dentries
  f2fs: fix mismatching lock and unlock pages for roll-forward recovery
  f2fs: fix sparse warnings
  f2fs: limit b_size of mapped bh in f2fs_map_bh
  f2fs: persist system.advise into on-disk inode
  f2fs: avoid NULL pointer dereference in f2fs_xattr_advise_get
  f2fs: preallocate fallocated blocks for direct IO
  f2fs: enable inline data by default
  f2fs: preserve extent info for extent cache
  f2fs: initialize extent tree with on-disk extent info of inode
  f2fs: introduce __{find,grab}_extent_tree
  f2fs: split set_data_blkaddr from f2fs_update_extent_cache
  f2fs: enable fast symlink by utilizing inline data
  ...
parents d6a24d06 10027551
...@@ -140,6 +140,12 @@ nobarrier This option can be used if underlying storage guarantees ...@@ -140,6 +140,12 @@ nobarrier This option can be used if underlying storage guarantees
fastboot This option is used when a system wants to reduce mount fastboot This option is used when a system wants to reduce mount
time as much as possible, even though normal performance time as much as possible, even though normal performance
can be sacrificed. can be sacrificed.
extent_cache Enable an extent cache based on rb-tree, it can cache
as many as extent which map between contiguous logical
address and physical address per inode, resulting in
increasing the cache hit ratio.
noinline_data Disable the inline data feature, inline data feature is
enabled by default.
================================================================================ ================================================================================
DEBUGFS ENTRIES DEBUGFS ENTRIES
......
...@@ -32,6 +32,7 @@ source "fs/gfs2/Kconfig" ...@@ -32,6 +32,7 @@ source "fs/gfs2/Kconfig"
source "fs/ocfs2/Kconfig" source "fs/ocfs2/Kconfig"
source "fs/btrfs/Kconfig" source "fs/btrfs/Kconfig"
source "fs/nilfs2/Kconfig" source "fs/nilfs2/Kconfig"
source "fs/f2fs/Kconfig"
config FS_DAX config FS_DAX
bool "Direct Access (DAX) support" bool "Direct Access (DAX) support"
...@@ -217,7 +218,6 @@ source "fs/pstore/Kconfig" ...@@ -217,7 +218,6 @@ source "fs/pstore/Kconfig"
source "fs/sysv/Kconfig" source "fs/sysv/Kconfig"
source "fs/ufs/Kconfig" source "fs/ufs/Kconfig"
source "fs/exofs/Kconfig" source "fs/exofs/Kconfig"
source "fs/f2fs/Kconfig"
endif # MISC_FILESYSTEMS endif # MISC_FILESYSTEMS
......
config F2FS_FS config F2FS_FS
tristate "F2FS filesystem support (EXPERIMENTAL)" tristate "F2FS filesystem support"
depends on BLOCK depends on BLOCK
help help
F2FS is based on Log-structured File System (LFS), which supports F2FS is based on Log-structured File System (LFS), which supports
......
...@@ -351,13 +351,11 @@ static int f2fs_acl_create(struct inode *dir, umode_t *mode, ...@@ -351,13 +351,11 @@ static int f2fs_acl_create(struct inode *dir, umode_t *mode,
*acl = f2fs_acl_clone(p, GFP_NOFS); *acl = f2fs_acl_clone(p, GFP_NOFS);
if (!*acl) if (!*acl)
return -ENOMEM; goto no_mem;
ret = f2fs_acl_create_masq(*acl, mode); ret = f2fs_acl_create_masq(*acl, mode);
if (ret < 0) { if (ret < 0)
posix_acl_release(*acl); goto no_mem_clone;
return -ENOMEM;
}
if (ret == 0) { if (ret == 0) {
posix_acl_release(*acl); posix_acl_release(*acl);
...@@ -378,6 +376,12 @@ static int f2fs_acl_create(struct inode *dir, umode_t *mode, ...@@ -378,6 +376,12 @@ static int f2fs_acl_create(struct inode *dir, umode_t *mode,
*default_acl = NULL; *default_acl = NULL;
*acl = NULL; *acl = NULL;
return 0; return 0;
no_mem_clone:
posix_acl_release(*acl);
no_mem:
posix_acl_release(p);
return -ENOMEM;
} }
int f2fs_init_acl(struct inode *inode, struct inode *dir, struct page *ipage, int f2fs_init_acl(struct inode *inode, struct inode *dir, struct page *ipage,
......
...@@ -276,7 +276,7 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type, ...@@ -276,7 +276,7 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
if (!clear_page_dirty_for_io(page)) if (!clear_page_dirty_for_io(page))
goto continue_unlock; goto continue_unlock;
if (f2fs_write_meta_page(page, &wbc)) { if (mapping->a_ops->writepage(page, &wbc)) {
unlock_page(page); unlock_page(page);
break; break;
} }
...@@ -464,20 +464,19 @@ static void recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) ...@@ -464,20 +464,19 @@ static void recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
void recover_orphan_inodes(struct f2fs_sb_info *sbi) void recover_orphan_inodes(struct f2fs_sb_info *sbi)
{ {
block_t start_blk, orphan_blkaddr, i, j; block_t start_blk, orphan_blocks, i, j;
if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG)) if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG))
return; return;
set_sbi_flag(sbi, SBI_POR_DOING); set_sbi_flag(sbi, SBI_POR_DOING);
start_blk = __start_cp_addr(sbi) + 1 + start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi);
le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload); orphan_blocks = __start_sum_addr(sbi) - 1 - __cp_payload(sbi);
orphan_blkaddr = __start_sum_addr(sbi) - 1;
ra_meta_pages(sbi, start_blk, orphan_blkaddr, META_CP); ra_meta_pages(sbi, start_blk, orphan_blocks, META_CP);
for (i = 0; i < orphan_blkaddr; i++) { for (i = 0; i < orphan_blocks; i++) {
struct page *page = get_meta_page(sbi, start_blk + i); struct page *page = get_meta_page(sbi, start_blk + i);
struct f2fs_orphan_block *orphan_blk; struct f2fs_orphan_block *orphan_blk;
...@@ -615,7 +614,7 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) ...@@ -615,7 +614,7 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi)
unsigned long blk_size = sbi->blocksize; unsigned long blk_size = sbi->blocksize;
unsigned long long cp1_version = 0, cp2_version = 0; unsigned long long cp1_version = 0, cp2_version = 0;
unsigned long long cp_start_blk_no; unsigned long long cp_start_blk_no;
unsigned int cp_blks = 1 + le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload); unsigned int cp_blks = 1 + __cp_payload(sbi);
block_t cp_blk_no; block_t cp_blk_no;
int i; int i;
...@@ -796,6 +795,7 @@ void sync_dirty_dir_inodes(struct f2fs_sb_info *sbi) ...@@ -796,6 +795,7 @@ void sync_dirty_dir_inodes(struct f2fs_sb_info *sbi)
* wribacking dentry pages in the freeing inode. * wribacking dentry pages in the freeing inode.
*/ */
f2fs_submit_merged_bio(sbi, DATA, WRITE); f2fs_submit_merged_bio(sbi, DATA, WRITE);
cond_resched();
} }
goto retry; goto retry;
} }
...@@ -884,7 +884,7 @@ static void do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) ...@@ -884,7 +884,7 @@ static void do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
__u32 crc32 = 0; __u32 crc32 = 0;
void *kaddr; void *kaddr;
int i; int i;
int cp_payload_blks = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload); int cp_payload_blks = __cp_payload(sbi);
/* /*
* This avoids to conduct wrong roll-forward operations and uses * This avoids to conduct wrong roll-forward operations and uses
...@@ -1048,17 +1048,18 @@ void write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) ...@@ -1048,17 +1048,18 @@ void write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
unsigned long long ckpt_ver; unsigned long long ckpt_ver;
trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "start block_ops");
mutex_lock(&sbi->cp_mutex); mutex_lock(&sbi->cp_mutex);
if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) && if (!is_sbi_flag_set(sbi, SBI_IS_DIRTY) &&
cpc->reason != CP_DISCARD && cpc->reason != CP_UMOUNT) (cpc->reason == CP_FASTBOOT || cpc->reason == CP_SYNC))
goto out; goto out;
if (unlikely(f2fs_cp_error(sbi))) if (unlikely(f2fs_cp_error(sbi)))
goto out; goto out;
if (f2fs_readonly(sbi->sb)) if (f2fs_readonly(sbi->sb))
goto out; goto out;
trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "start block_ops");
if (block_operations(sbi)) if (block_operations(sbi))
goto out; goto out;
...@@ -1085,6 +1086,10 @@ void write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) ...@@ -1085,6 +1086,10 @@ void write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
unblock_operations(sbi); unblock_operations(sbi);
stat_inc_cp_count(sbi->stat_info); stat_inc_cp_count(sbi->stat_info);
if (cpc->reason == CP_RECOVERY)
f2fs_msg(sbi->sb, KERN_NOTICE,
"checkpoint: version = %llx", ckpt_ver);
out: out:
mutex_unlock(&sbi->cp_mutex); mutex_unlock(&sbi->cp_mutex);
trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish checkpoint"); trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish checkpoint");
...@@ -1103,14 +1108,9 @@ void init_ino_entry_info(struct f2fs_sb_info *sbi) ...@@ -1103,14 +1108,9 @@ void init_ino_entry_info(struct f2fs_sb_info *sbi)
im->ino_num = 0; im->ino_num = 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->max_orphans = (sbi->blocks_per_seg - F2FS_CP_PACKS - sbi->max_orphans = (sbi->blocks_per_seg - F2FS_CP_PACKS -
NR_CURSEG_TYPE) * F2FS_ORPHANS_PER_BLOCK; NR_CURSEG_TYPE - __cp_payload(sbi)) *
F2FS_ORPHANS_PER_BLOCK;
} }
int __init create_checkpoint_caches(void) int __init create_checkpoint_caches(void)
......
This diff is collapsed.
...@@ -35,6 +35,8 @@ static void update_general_status(struct f2fs_sb_info *sbi) ...@@ -35,6 +35,8 @@ static void update_general_status(struct f2fs_sb_info *sbi)
/* validation check of the segment numbers */ /* validation check of the segment numbers */
si->hit_ext = sbi->read_hit_ext; si->hit_ext = sbi->read_hit_ext;
si->total_ext = sbi->total_hit_ext; si->total_ext = sbi->total_hit_ext;
si->ext_tree = sbi->total_ext_tree;
si->ext_node = atomic_read(&sbi->total_ext_node);
si->ndirty_node = get_pages(sbi, F2FS_DIRTY_NODES); si->ndirty_node = get_pages(sbi, F2FS_DIRTY_NODES);
si->ndirty_dent = get_pages(sbi, F2FS_DIRTY_DENTS); si->ndirty_dent = get_pages(sbi, F2FS_DIRTY_DENTS);
si->ndirty_dirs = sbi->n_dirty_dirs; si->ndirty_dirs = sbi->n_dirty_dirs;
...@@ -185,6 +187,9 @@ static void update_mem_info(struct f2fs_sb_info *sbi) ...@@ -185,6 +187,9 @@ static void update_mem_info(struct f2fs_sb_info *sbi)
si->cache_mem += sbi->n_dirty_dirs * sizeof(struct inode_entry); si->cache_mem += sbi->n_dirty_dirs * sizeof(struct inode_entry);
for (i = 0; i <= UPDATE_INO; i++) for (i = 0; i <= UPDATE_INO; i++)
si->cache_mem += sbi->im[i].ino_num * sizeof(struct ino_entry); si->cache_mem += sbi->im[i].ino_num * sizeof(struct ino_entry);
si->cache_mem += sbi->total_ext_tree * sizeof(struct extent_tree);
si->cache_mem += atomic_read(&sbi->total_ext_node) *
sizeof(struct extent_node);
si->page_mem = 0; si->page_mem = 0;
npages = NODE_MAPPING(sbi)->nrpages; npages = NODE_MAPPING(sbi)->nrpages;
...@@ -260,13 +265,20 @@ static int stat_show(struct seq_file *s, void *v) ...@@ -260,13 +265,20 @@ static int stat_show(struct seq_file *s, void *v)
seq_printf(s, "CP calls: %d\n", si->cp_count); seq_printf(s, "CP calls: %d\n", si->cp_count);
seq_printf(s, "GC calls: %d (BG: %d)\n", seq_printf(s, "GC calls: %d (BG: %d)\n",
si->call_count, si->bg_gc); si->call_count, si->bg_gc);
seq_printf(s, " - data segments : %d\n", si->data_segs); seq_printf(s, " - data segments : %d (%d)\n",
seq_printf(s, " - node segments : %d\n", si->node_segs); si->data_segs, si->bg_data_segs);
seq_printf(s, "Try to move %d blocks\n", si->tot_blks); seq_printf(s, " - node segments : %d (%d)\n",
seq_printf(s, " - data blocks : %d\n", si->data_blks); si->node_segs, si->bg_node_segs);
seq_printf(s, " - node blocks : %d\n", si->node_blks); seq_printf(s, "Try to move %d blocks (BG: %d)\n", si->tot_blks,
si->bg_data_blks + si->bg_node_blks);
seq_printf(s, " - data blocks : %d (%d)\n", si->data_blks,
si->bg_data_blks);
seq_printf(s, " - node blocks : %d (%d)\n", si->node_blks,
si->bg_node_blks);
seq_printf(s, "\nExtent Hit Ratio: %d / %d\n", seq_printf(s, "\nExtent Hit Ratio: %d / %d\n",
si->hit_ext, si->total_ext); si->hit_ext, si->total_ext);
seq_printf(s, "\nExtent Tree Count: %d\n", si->ext_tree);
seq_printf(s, "\nExtent Node Count: %d\n", si->ext_node);
seq_puts(s, "\nBalancing F2FS Async:\n"); seq_puts(s, "\nBalancing F2FS Async:\n");
seq_printf(s, " - inmem: %4d, wb: %4d\n", seq_printf(s, " - inmem: %4d, wb: %4d\n",
si->inmem_pages, si->wb_pages); si->inmem_pages, si->wb_pages);
......
...@@ -59,9 +59,8 @@ static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = { ...@@ -59,9 +59,8 @@ static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = {
[S_IFLNK >> S_SHIFT] = F2FS_FT_SYMLINK, [S_IFLNK >> S_SHIFT] = F2FS_FT_SYMLINK,
}; };
void set_de_type(struct f2fs_dir_entry *de, struct inode *inode) void set_de_type(struct f2fs_dir_entry *de, umode_t mode)
{ {
umode_t mode = inode->i_mode;
de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT]; de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT];
} }
...@@ -127,22 +126,19 @@ struct f2fs_dir_entry *find_target_dentry(struct qstr *name, int *max_slots, ...@@ -127,22 +126,19 @@ struct f2fs_dir_entry *find_target_dentry(struct qstr *name, int *max_slots,
*max_slots = 0; *max_slots = 0;
while (bit_pos < d->max) { while (bit_pos < d->max) {
if (!test_bit_le(bit_pos, d->bitmap)) { if (!test_bit_le(bit_pos, d->bitmap)) {
if (bit_pos == 0)
max_len = 1;
else if (!test_bit_le(bit_pos - 1, d->bitmap))
max_len++;
bit_pos++; bit_pos++;
max_len++;
continue; continue;
} }
de = &d->dentry[bit_pos]; de = &d->dentry[bit_pos];
if (early_match_name(name->len, namehash, de) && if (early_match_name(name->len, namehash, de) &&
!memcmp(d->filename[bit_pos], name->name, name->len)) !memcmp(d->filename[bit_pos], name->name, name->len))
goto found; goto found;
if (max_slots && *max_slots >= 0 && max_len > *max_slots) { if (max_slots && max_len > *max_slots)
*max_slots = max_len; *max_slots = max_len;
max_len = 0; max_len = 0;
}
/* remain bug on condition */ /* remain bug on condition */
if (unlikely(!de->name_len)) if (unlikely(!de->name_len))
...@@ -219,14 +215,14 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir, ...@@ -219,14 +215,14 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
unsigned int max_depth; unsigned int max_depth;
unsigned int level; unsigned int level;
*res_page = NULL;
if (f2fs_has_inline_dentry(dir)) if (f2fs_has_inline_dentry(dir))
return find_in_inline_dir(dir, child, res_page); return find_in_inline_dir(dir, child, res_page);
if (npages == 0) if (npages == 0)
return NULL; return NULL;
*res_page = NULL;
name_hash = f2fs_dentry_hash(child); name_hash = f2fs_dentry_hash(child);
max_depth = F2FS_I(dir)->i_current_depth; max_depth = F2FS_I(dir)->i_current_depth;
...@@ -285,7 +281,7 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de, ...@@ -285,7 +281,7 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
lock_page(page); lock_page(page);
f2fs_wait_on_page_writeback(page, type); f2fs_wait_on_page_writeback(page, type);
de->ino = cpu_to_le32(inode->i_ino); de->ino = cpu_to_le32(inode->i_ino);
set_de_type(de, inode); set_de_type(de, inode->i_mode);
f2fs_dentry_kunmap(dir, page); f2fs_dentry_kunmap(dir, page);
set_page_dirty(page); set_page_dirty(page);
dir->i_mtime = dir->i_ctime = CURRENT_TIME; dir->i_mtime = dir->i_ctime = CURRENT_TIME;
...@@ -331,14 +327,14 @@ void do_make_empty_dir(struct inode *inode, struct inode *parent, ...@@ -331,14 +327,14 @@ void do_make_empty_dir(struct inode *inode, struct inode *parent,
de->hash_code = 0; de->hash_code = 0;
de->ino = cpu_to_le32(inode->i_ino); de->ino = cpu_to_le32(inode->i_ino);
memcpy(d->filename[0], ".", 1); memcpy(d->filename[0], ".", 1);
set_de_type(de, inode); set_de_type(de, inode->i_mode);
de = &d->dentry[1]; de = &d->dentry[1];
de->hash_code = 0; de->hash_code = 0;
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(d->filename[1], "..", 2); memcpy(d->filename[1], "..", 2);
set_de_type(de, inode); set_de_type(de, parent->i_mode);
test_and_set_bit_le(0, (void *)d->bitmap); test_and_set_bit_le(0, (void *)d->bitmap);
test_and_set_bit_le(1, (void *)d->bitmap); test_and_set_bit_le(1, (void *)d->bitmap);
...@@ -435,7 +431,7 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir, ...@@ -435,7 +431,7 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
void update_parent_metadata(struct inode *dir, struct inode *inode, void update_parent_metadata(struct inode *dir, struct inode *inode,
unsigned int current_depth) unsigned int current_depth)
{ {
if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) { if (inode && is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {
if (S_ISDIR(inode->i_mode)) { if (S_ISDIR(inode->i_mode)) {
inc_nlink(dir); inc_nlink(dir);
set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR); set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
...@@ -450,7 +446,7 @@ void update_parent_metadata(struct inode *dir, struct inode *inode, ...@@ -450,7 +446,7 @@ void update_parent_metadata(struct inode *dir, struct inode *inode,
set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR); set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
} }
if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) if (inode && is_inode_flag_set(F2FS_I(inode), FI_INC_LINK))
clear_inode_flag(F2FS_I(inode), FI_INC_LINK); clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
} }
...@@ -474,30 +470,47 @@ int room_for_filename(const void *bitmap, int slots, int max_slots) ...@@ -474,30 +470,47 @@ int room_for_filename(const void *bitmap, int slots, int max_slots)
goto next; goto next;
} }
void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
const struct qstr *name, f2fs_hash_t name_hash,
unsigned int bit_pos)
{
struct f2fs_dir_entry *de;
int slots = GET_DENTRY_SLOTS(name->len);
int i;
de = &d->dentry[bit_pos];
de->hash_code = name_hash;
de->name_len = cpu_to_le16(name->len);
memcpy(d->filename[bit_pos], name->name, name->len);
de->ino = cpu_to_le32(ino);
set_de_type(de, mode);
for (i = 0; i < slots; i++)
test_and_set_bit_le(bit_pos + i, (void *)d->bitmap);
}
/* /*
* Caller should grab and release a rwsem by calling f2fs_lock_op() and * Caller should grab and release a rwsem by calling f2fs_lock_op() and
* f2fs_unlock_op(). * f2fs_unlock_op().
*/ */
int __f2fs_add_link(struct inode *dir, const struct qstr *name, int __f2fs_add_link(struct inode *dir, const struct qstr *name,
struct inode *inode) struct inode *inode, nid_t ino, umode_t mode)
{ {
unsigned int bit_pos; unsigned int bit_pos;
unsigned int level; unsigned int level;
unsigned int current_depth; unsigned int current_depth;
unsigned long bidx, block; unsigned long bidx, block;
f2fs_hash_t dentry_hash; f2fs_hash_t dentry_hash;
struct f2fs_dir_entry *de;
unsigned int nbucket, nblock; unsigned int nbucket, nblock;
size_t namelen = name->len; size_t namelen = 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;
struct f2fs_dentry_ptr d;
int slots = GET_DENTRY_SLOTS(namelen); int slots = GET_DENTRY_SLOTS(namelen);
struct page *page; struct page *page = NULL;
int err = 0; int err = 0;
int i;
if (f2fs_has_inline_dentry(dir)) { if (f2fs_has_inline_dentry(dir)) {
err = f2fs_add_inline_entry(dir, name, inode); err = f2fs_add_inline_entry(dir, name, inode, ino, mode);
if (!err || err != -EAGAIN) if (!err || err != -EAGAIN)
return err; return err;
else else
...@@ -547,30 +560,31 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, ...@@ -547,30 +560,31 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name,
add_dentry: add_dentry:
f2fs_wait_on_page_writeback(dentry_page, DATA); f2fs_wait_on_page_writeback(dentry_page, DATA);
down_write(&F2FS_I(inode)->i_sem); if (inode) {
page = init_inode_metadata(inode, dir, name, NULL); down_write(&F2FS_I(inode)->i_sem);
if (IS_ERR(page)) { page = init_inode_metadata(inode, dir, name, NULL);
err = PTR_ERR(page); if (IS_ERR(page)) {
goto fail; err = PTR_ERR(page);
goto fail;
}
} }
de = &dentry_blk->dentry[bit_pos];
de->hash_code = dentry_hash; make_dentry_ptr(&d, (void *)dentry_blk, 1);
de->name_len = cpu_to_le16(namelen); f2fs_update_dentry(ino, mode, &d, name, dentry_hash, bit_pos);
memcpy(dentry_blk->filename[bit_pos], name->name, name->len);
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);
set_page_dirty(dentry_page); set_page_dirty(dentry_page);
/* we don't need to mark_inode_dirty now */ if (inode) {
F2FS_I(inode)->i_pino = dir->i_ino; /* we don't need to mark_inode_dirty now */
update_inode(inode, page); F2FS_I(inode)->i_pino = dir->i_ino;
f2fs_put_page(page, 1); update_inode(inode, page);
f2fs_put_page(page, 1);
}
update_parent_metadata(dir, inode, current_depth); update_parent_metadata(dir, inode, current_depth);
fail: fail:
up_write(&F2FS_I(inode)->i_sem); if (inode)
up_write(&F2FS_I(inode)->i_sem);
if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) { if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {
update_inode_page(dir); update_inode_page(dir);
...@@ -669,6 +683,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, ...@@ -669,6 +683,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
if (bit_pos == NR_DENTRY_IN_BLOCK) { if (bit_pos == NR_DENTRY_IN_BLOCK) {
truncate_hole(dir, page->index, page->index + 1); truncate_hole(dir, page->index, page->index + 1);
clear_page_dirty_for_io(page); clear_page_dirty_for_io(page);
ClearPagePrivate(page);
ClearPageUptodate(page); ClearPageUptodate(page);
inode_dec_dirty_pages(dir); inode_dec_dirty_pages(dir);
} }
......
This diff is collapsed.
...@@ -241,6 +241,8 @@ int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync) ...@@ -241,6 +241,8 @@ int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
* will be used only for fsynced inodes after checkpoint. * will be used only for fsynced inodes after checkpoint.
*/ */
try_to_fix_pino(inode); try_to_fix_pino(inode);
clear_inode_flag(fi, FI_APPEND_WRITE);
clear_inode_flag(fi, FI_UPDATE_WRITE);
goto out; goto out;
} }
sync_nodes: sync_nodes:
...@@ -433,8 +435,12 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count) ...@@ -433,8 +435,12 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
continue; continue;
dn->data_blkaddr = NULL_ADDR; dn->data_blkaddr = NULL_ADDR;
update_extent_cache(dn); set_data_blkaddr(dn);
f2fs_update_extent_cache(dn);
invalidate_blocks(sbi, blkaddr); invalidate_blocks(sbi, blkaddr);
if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
clear_inode_flag(F2FS_I(dn->inode),
FI_FIRST_BLOCK_WRITTEN);
nr_free++; nr_free++;
} }
if (nr_free) { if (nr_free) {
...@@ -454,15 +460,16 @@ void truncate_data_blocks(struct dnode_of_data *dn) ...@@ -454,15 +460,16 @@ void truncate_data_blocks(struct dnode_of_data *dn)
truncate_data_blocks_range(dn, ADDRS_PER_BLOCK); truncate_data_blocks_range(dn, ADDRS_PER_BLOCK);
} }
static int truncate_partial_data_page(struct inode *inode, u64 from) static int truncate_partial_data_page(struct inode *inode, u64 from,
bool force)
{ {
unsigned offset = from & (PAGE_CACHE_SIZE - 1); unsigned offset = from & (PAGE_CACHE_SIZE - 1);
struct page *page; struct page *page;
if (!offset) if (!offset && !force)
return 0; return 0;
page = find_data_page(inode, from >> PAGE_CACHE_SHIFT, false); page = find_data_page(inode, from >> PAGE_CACHE_SHIFT, force);
if (IS_ERR(page)) if (IS_ERR(page))
return 0; return 0;
...@@ -473,7 +480,8 @@ static int truncate_partial_data_page(struct inode *inode, u64 from) ...@@ -473,7 +480,8 @@ static int truncate_partial_data_page(struct inode *inode, u64 from)
f2fs_wait_on_page_writeback(page, DATA); f2fs_wait_on_page_writeback(page, DATA);
zero_user(page, offset, PAGE_CACHE_SIZE - offset); zero_user(page, offset, PAGE_CACHE_SIZE - offset);
set_page_dirty(page); if (!force)
set_page_dirty(page);
out: out:
f2fs_put_page(page, 1); f2fs_put_page(page, 1);
return 0; return 0;
...@@ -487,6 +495,7 @@ int truncate_blocks(struct inode *inode, u64 from, bool lock) ...@@ -487,6 +495,7 @@ int truncate_blocks(struct inode *inode, u64 from, bool lock)
pgoff_t free_from; pgoff_t free_from;
int count = 0, err = 0; int count = 0, err = 0;
struct page *ipage; struct page *ipage;
bool truncate_page = false;
trace_f2fs_truncate_blocks_enter(inode, from); trace_f2fs_truncate_blocks_enter(inode, from);
...@@ -502,7 +511,10 @@ int truncate_blocks(struct inode *inode, u64 from, bool lock) ...@@ -502,7 +511,10 @@ int truncate_blocks(struct inode *inode, u64 from, bool lock)
} }
if (f2fs_has_inline_data(inode)) { if (f2fs_has_inline_data(inode)) {
if (truncate_inline_inode(ipage, from))
set_page_dirty(ipage);
f2fs_put_page(ipage, 1); f2fs_put_page(ipage, 1);
truncate_page = true;
goto out; goto out;
} }
...@@ -533,7 +545,7 @@ int truncate_blocks(struct inode *inode, u64 from, bool lock) ...@@ -533,7 +545,7 @@ int truncate_blocks(struct inode *inode, u64 from, bool lock)
/* lastly zero out the first data page */ /* lastly zero out the first data page */
if (!err) if (!err)
err = truncate_partial_data_page(inode, from); err = truncate_partial_data_page(inode, from, truncate_page);
trace_f2fs_truncate_blocks_exit(inode, err); trace_f2fs_truncate_blocks_exit(inode, err);
return err; return err;
...@@ -997,6 +1009,9 @@ static int f2fs_ioc_release_volatile_write(struct file *filp) ...@@ -997,6 +1009,9 @@ static int f2fs_ioc_release_volatile_write(struct file *filp)
if (!f2fs_is_volatile_file(inode)) if (!f2fs_is_volatile_file(inode))
return 0; return 0;
if (!f2fs_is_first_block_written(inode))
return truncate_partial_data_page(inode, 0, true);
punch_hole(inode, 0, F2FS_BLKSIZE); punch_hole(inode, 0, F2FS_BLKSIZE);
return 0; return 0;
} }
...@@ -1029,6 +1044,41 @@ static int f2fs_ioc_abort_volatile_write(struct file *filp) ...@@ -1029,6 +1044,41 @@ static int f2fs_ioc_abort_volatile_write(struct file *filp)
return ret; return ret;
} }
static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
{
struct inode *inode = file_inode(filp);
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
struct super_block *sb = sbi->sb;
__u32 in;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
if (get_user(in, (__u32 __user *)arg))
return -EFAULT;
switch (in) {
case F2FS_GOING_DOWN_FULLSYNC:
sb = freeze_bdev(sb->s_bdev);
if (sb && !IS_ERR(sb)) {
f2fs_stop_checkpoint(sbi);
thaw_bdev(sb->s_bdev, sb);
}
break;
case F2FS_GOING_DOWN_METASYNC:
/* do checkpoint only */
f2fs_sync_fs(sb, 1);
f2fs_stop_checkpoint(sbi);
break;
case F2FS_GOING_DOWN_NOSYNC:
f2fs_stop_checkpoint(sbi);
break;
default:
return -EINVAL;
}
return 0;
}
static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg) static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
{ {
struct inode *inode = file_inode(filp); struct inode *inode = file_inode(filp);
...@@ -1078,6 +1128,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) ...@@ -1078,6 +1128,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
return f2fs_ioc_release_volatile_write(filp); return f2fs_ioc_release_volatile_write(filp);
case F2FS_IOC_ABORT_VOLATILE_WRITE: case F2FS_IOC_ABORT_VOLATILE_WRITE:
return f2fs_ioc_abort_volatile_write(filp); return f2fs_ioc_abort_volatile_write(filp);
case F2FS_IOC_SHUTDOWN:
return f2fs_ioc_shutdown(filp, arg);
case FITRIM: case FITRIM:
return f2fs_ioc_fitrim(filp, arg); return f2fs_ioc_fitrim(filp, arg);
default: default:
......
...@@ -435,7 +435,7 @@ static void gc_node_segment(struct f2fs_sb_info *sbi, ...@@ -435,7 +435,7 @@ static void gc_node_segment(struct f2fs_sb_info *sbi,
set_page_dirty(node_page); set_page_dirty(node_page);
} }
f2fs_put_page(node_page, 1); f2fs_put_page(node_page, 1);
stat_inc_node_blk_count(sbi, 1); stat_inc_node_blk_count(sbi, 1, gc_type);
} }
if (initial) { if (initial) {
...@@ -622,7 +622,7 @@ static void gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum, ...@@ -622,7 +622,7 @@ static void gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
if (IS_ERR(data_page)) if (IS_ERR(data_page))
continue; continue;
move_data_page(inode, data_page, gc_type); move_data_page(inode, data_page, gc_type);
stat_inc_data_blk_count(sbi, 1); stat_inc_data_blk_count(sbi, 1, gc_type);
} }
} }
...@@ -680,7 +680,7 @@ static void do_garbage_collect(struct f2fs_sb_info *sbi, unsigned int segno, ...@@ -680,7 +680,7 @@ static void do_garbage_collect(struct f2fs_sb_info *sbi, unsigned int segno,
} }
blk_finish_plug(&plug); blk_finish_plug(&plug);
stat_inc_seg_count(sbi, GET_SUM_TYPE((&sum->footer))); stat_inc_seg_count(sbi, GET_SUM_TYPE((&sum->footer)), gc_type);
stat_inc_call_count(sbi->stat_info); stat_inc_call_count(sbi->stat_info);
f2fs_put_page(sum_page, 1); f2fs_put_page(sum_page, 1);
......
...@@ -21,7 +21,7 @@ bool f2fs_may_inline(struct inode *inode) ...@@ -21,7 +21,7 @@ bool f2fs_may_inline(struct inode *inode)
if (f2fs_is_atomic_file(inode)) if (f2fs_is_atomic_file(inode))
return false; return false;
if (!S_ISREG(inode->i_mode)) if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))
return false; return false;
if (i_size_read(inode) > MAX_INLINE_DATA) if (i_size_read(inode) > MAX_INLINE_DATA)
...@@ -50,10 +50,19 @@ void read_inline_data(struct page *page, struct page *ipage) ...@@ -50,10 +50,19 @@ void read_inline_data(struct page *page, struct page *ipage)
SetPageUptodate(page); SetPageUptodate(page);
} }
static void truncate_inline_data(struct page *ipage) bool truncate_inline_inode(struct page *ipage, u64 from)
{ {
void *addr;
if (from >= MAX_INLINE_DATA)
return false;
addr = inline_data_addr(ipage);
f2fs_wait_on_page_writeback(ipage, NODE); f2fs_wait_on_page_writeback(ipage, NODE);
memset(inline_data_addr(ipage), 0, MAX_INLINE_DATA); memset(addr + from, 0, MAX_INLINE_DATA - from);
return true;
} }
int f2fs_read_inline_data(struct inode *inode, struct page *page) int f2fs_read_inline_data(struct inode *inode, struct page *page)
...@@ -122,7 +131,8 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) ...@@ -122,7 +131,8 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
set_page_writeback(page); set_page_writeback(page);
fio.blk_addr = dn->data_blkaddr; fio.blk_addr = dn->data_blkaddr;
write_data_page(page, dn, &fio); write_data_page(page, dn, &fio);
update_extent_cache(dn); set_data_blkaddr(dn);
f2fs_update_extent_cache(dn);
f2fs_wait_on_page_writeback(page, DATA); f2fs_wait_on_page_writeback(page, DATA);
if (dirty) if (dirty)
inode_dec_dirty_pages(dn->inode); inode_dec_dirty_pages(dn->inode);
...@@ -131,7 +141,7 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) ...@@ -131,7 +141,7 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
set_inode_flag(F2FS_I(dn->inode), FI_APPEND_WRITE); set_inode_flag(F2FS_I(dn->inode), FI_APPEND_WRITE);
/* clear inline data and flag after data writeback */ /* clear inline data and flag after data writeback */
truncate_inline_data(dn->inode_page); truncate_inline_inode(dn->inode_page, 0);
clear_out: clear_out:
stat_dec_inline_inode(dn->inode); stat_dec_inline_inode(dn->inode);
f2fs_clear_inline_inode(dn->inode); f2fs_clear_inline_inode(dn->inode);
...@@ -245,7 +255,7 @@ bool recover_inline_data(struct inode *inode, struct page *npage) ...@@ -245,7 +255,7 @@ bool recover_inline_data(struct inode *inode, struct page *npage)
if (f2fs_has_inline_data(inode)) { if (f2fs_has_inline_data(inode)) {
ipage = get_node_page(sbi, inode->i_ino); ipage = get_node_page(sbi, inode->i_ino);
f2fs_bug_on(sbi, IS_ERR(ipage)); f2fs_bug_on(sbi, IS_ERR(ipage));
truncate_inline_data(ipage); truncate_inline_inode(ipage, 0);
f2fs_clear_inline_inode(inode); f2fs_clear_inline_inode(inode);
update_inode(inode, ipage); update_inode(inode, ipage);
f2fs_put_page(ipage, 1); f2fs_put_page(ipage, 1);
...@@ -363,7 +373,7 @@ static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage, ...@@ -363,7 +373,7 @@ static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
set_page_dirty(page); set_page_dirty(page);
/* clear inline dir and flag after data writeback */ /* clear inline dir and flag after data writeback */
truncate_inline_data(ipage); truncate_inline_inode(ipage, 0);
stat_dec_inline_dir(dir); stat_dec_inline_dir(dir);
clear_inode_flag(F2FS_I(dir), FI_INLINE_DENTRY); clear_inode_flag(F2FS_I(dir), FI_INLINE_DENTRY);
...@@ -380,21 +390,18 @@ static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage, ...@@ -380,21 +390,18 @@ static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
} }
int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name, int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,
struct inode *inode) struct inode *inode, nid_t ino, umode_t mode)
{ {
struct f2fs_sb_info *sbi = F2FS_I_SB(dir); struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
struct page *ipage; struct page *ipage;
unsigned int bit_pos; unsigned int bit_pos;
f2fs_hash_t name_hash; f2fs_hash_t name_hash;
struct f2fs_dir_entry *de;
size_t namelen = name->len; size_t namelen = name->len;
struct f2fs_inline_dentry *dentry_blk = NULL; struct f2fs_inline_dentry *dentry_blk = NULL;
struct f2fs_dentry_ptr d;
int slots = GET_DENTRY_SLOTS(namelen); int slots = GET_DENTRY_SLOTS(namelen);
struct page *page; struct page *page = NULL;
int err = 0; int err = 0;
int i;
name_hash = f2fs_dentry_hash(name);
ipage = get_node_page(sbi, dir->i_ino); ipage = get_node_page(sbi, dir->i_ino);
if (IS_ERR(ipage)) if (IS_ERR(ipage))
...@@ -410,32 +417,34 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name, ...@@ -410,32 +417,34 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,
goto out; goto out;
} }
down_write(&F2FS_I(inode)->i_sem); if (inode) {
page = init_inode_metadata(inode, dir, name, ipage); down_write(&F2FS_I(inode)->i_sem);
if (IS_ERR(page)) { page = init_inode_metadata(inode, dir, name, ipage);
err = PTR_ERR(page); if (IS_ERR(page)) {
goto fail; err = PTR_ERR(page);
goto fail;
}
} }
f2fs_wait_on_page_writeback(ipage, NODE); f2fs_wait_on_page_writeback(ipage, NODE);
de = &dentry_blk->dentry[bit_pos];
de->hash_code = name_hash; name_hash = f2fs_dentry_hash(name);
de->name_len = cpu_to_le16(namelen); make_dentry_ptr(&d, (void *)dentry_blk, 2);
memcpy(dentry_blk->filename[bit_pos], name->name, name->len); f2fs_update_dentry(ino, mode, &d, name, name_hash, bit_pos);
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);
set_page_dirty(ipage); set_page_dirty(ipage);
/* we don't need to mark_inode_dirty now */ /* we don't need to mark_inode_dirty now */
F2FS_I(inode)->i_pino = dir->i_ino; if (inode) {
update_inode(inode, page); F2FS_I(inode)->i_pino = dir->i_ino;
f2fs_put_page(page, 1); update_inode(inode, page);
f2fs_put_page(page, 1);
}
update_parent_metadata(dir, inode, 0); update_parent_metadata(dir, inode, 0);
fail: fail:
up_write(&F2FS_I(inode)->i_sem); if (inode)
up_write(&F2FS_I(inode)->i_sem);
if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) { if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {
update_inode(dir, ipage); update_inode(dir, ipage);
......
...@@ -51,6 +51,15 @@ static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri) ...@@ -51,6 +51,15 @@ static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
} }
} }
static bool __written_first_block(struct f2fs_inode *ri)
{
block_t addr = le32_to_cpu(ri->i_addr[0]);
if (addr != NEW_ADDR && addr != NULL_ADDR)
return true;
return false;
}
static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri) static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
{ {
if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) { if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
...@@ -130,7 +139,8 @@ static int do_read_inode(struct inode *inode) ...@@ -130,7 +139,8 @@ static int do_read_inode(struct inode *inode)
fi->i_pino = le32_to_cpu(ri->i_pino); fi->i_pino = le32_to_cpu(ri->i_pino);
fi->i_dir_level = ri->i_dir_level; fi->i_dir_level = ri->i_dir_level;
get_extent_info(&fi->ext, ri->i_ext); f2fs_init_extent_cache(inode, &ri->i_ext);
get_inline_info(fi, ri); get_inline_info(fi, ri);
/* check data exist */ /* check data exist */
...@@ -140,6 +150,9 @@ static int do_read_inode(struct inode *inode) ...@@ -140,6 +150,9 @@ static int do_read_inode(struct inode *inode)
/* get rdev by using inline_info */ /* get rdev by using inline_info */
__get_inode_rdev(inode, ri); __get_inode_rdev(inode, ri);
if (__written_first_block(ri))
set_inode_flag(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN);
f2fs_put_page(node_page, 1); f2fs_put_page(node_page, 1);
stat_inc_inline_inode(inode); stat_inc_inline_inode(inode);
...@@ -220,7 +233,11 @@ void update_inode(struct inode *inode, struct page *node_page) ...@@ -220,7 +233,11 @@ void update_inode(struct inode *inode, struct page *node_page)
ri->i_links = cpu_to_le32(inode->i_nlink); ri->i_links = cpu_to_le32(inode->i_nlink);
ri->i_size = cpu_to_le64(i_size_read(inode)); ri->i_size = cpu_to_le64(i_size_read(inode));
ri->i_blocks = cpu_to_le64(inode->i_blocks); ri->i_blocks = cpu_to_le64(inode->i_blocks);
read_lock(&F2FS_I(inode)->ext_lock);
set_raw_extent(&F2FS_I(inode)->ext, &ri->i_ext); set_raw_extent(&F2FS_I(inode)->ext, &ri->i_ext);
read_unlock(&F2FS_I(inode)->ext_lock);
set_raw_inline(F2FS_I(inode), ri); set_raw_inline(F2FS_I(inode), ri);
ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec); ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
...@@ -328,6 +345,12 @@ void f2fs_evict_inode(struct inode *inode) ...@@ -328,6 +345,12 @@ void f2fs_evict_inode(struct inode *inode)
no_delete: no_delete:
stat_dec_inline_dir(inode); stat_dec_inline_dir(inode);
stat_dec_inline_inode(inode); stat_dec_inline_inode(inode);
/* update extent info in inode */
if (inode->i_nlink)
f2fs_preserve_extent_tree(inode);
f2fs_destroy_extent_tree(inode);
invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino); invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino);
if (xnid) if (xnid)
invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid); invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);
......
...@@ -14,6 +14,7 @@ ...@@ -14,6 +14,7 @@
#include <linux/sched.h> #include <linux/sched.h>
#include <linux/ctype.h> #include <linux/ctype.h>
#include <linux/dcache.h> #include <linux/dcache.h>
#include <linux/namei.h>
#include "f2fs.h" #include "f2fs.h"
#include "node.h" #include "node.h"
...@@ -187,6 +188,44 @@ struct dentry *f2fs_get_parent(struct dentry *child) ...@@ -187,6 +188,44 @@ struct dentry *f2fs_get_parent(struct dentry *child)
return d_obtain_alias(f2fs_iget(child->d_inode->i_sb, ino)); return d_obtain_alias(f2fs_iget(child->d_inode->i_sb, ino));
} }
static int __recover_dot_dentries(struct inode *dir, nid_t pino)
{
struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
struct qstr dot = QSTR_INIT(".", 1);
struct qstr dotdot = QSTR_INIT("..", 2);
struct f2fs_dir_entry *de;
struct page *page;
int err = 0;
f2fs_lock_op(sbi);
de = f2fs_find_entry(dir, &dot, &page);
if (de) {
f2fs_dentry_kunmap(dir, page);
f2fs_put_page(page, 0);
} else {
err = __f2fs_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);
if (err)
goto out;
}
de = f2fs_find_entry(dir, &dotdot, &page);
if (de) {
f2fs_dentry_kunmap(dir, page);
f2fs_put_page(page, 0);
} else {
err = __f2fs_add_link(dir, &dotdot, NULL, pino, S_IFDIR);
}
out:
if (!err) {
clear_inode_flag(F2FS_I(dir), FI_INLINE_DOTS);
mark_inode_dirty(dir);
}
f2fs_unlock_op(sbi);
return err;
}
static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry, static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
unsigned int flags) unsigned int flags)
{ {
...@@ -206,6 +245,16 @@ static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry, ...@@ -206,6 +245,16 @@ static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
inode = f2fs_iget(dir->i_sb, ino); inode = f2fs_iget(dir->i_sb, ino);
if (IS_ERR(inode)) if (IS_ERR(inode))
return ERR_CAST(inode); return ERR_CAST(inode);
if (f2fs_has_inline_dots(inode)) {
int err;
err = __recover_dot_dentries(inode, dir->i_ino);
if (err) {
iget_failed(inode);
return ERR_PTR(err);
}
}
} }
return d_splice_alias(inode, dentry); return d_splice_alias(inode, dentry);
...@@ -247,6 +296,23 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry) ...@@ -247,6 +296,23 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
return err; return err;
} }
static void *f2fs_follow_link(struct dentry *dentry, struct nameidata *nd)
{
struct page *page;
page = page_follow_link_light(dentry, nd);
if (IS_ERR(page))
return page;
/* this is broken symlink case */
if (*nd_get_link(nd) == 0) {
kunmap(page);
page_cache_release(page);
return ERR_PTR(-ENOENT);
}
return page;
}
static int f2fs_symlink(struct inode *dir, struct dentry *dentry, static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
const char *symname) const char *symname)
{ {
...@@ -276,6 +342,17 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry, ...@@ -276,6 +342,17 @@ 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);
/*
* Let's flush symlink data in order to avoid broken symlink as much as
* possible. Nevertheless, fsyncing is the best way, but there is no
* way to get a file descriptor in order to flush that.
*
* Note that, it needs to do dir->fsync to make this recoverable.
* If the symlink path is stored into inline_data, there is no
* performance regression.
*/
filemap_write_and_wait_range(inode->i_mapping, 0, symlen - 1);
if (IS_DIRSYNC(dir)) if (IS_DIRSYNC(dir))
f2fs_sync_fs(sbi->sb, 1); f2fs_sync_fs(sbi->sb, 1);
return err; return err;
...@@ -693,6 +770,8 @@ static int f2fs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode) ...@@ -693,6 +770,8 @@ static int f2fs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
f2fs_unlock_op(sbi); f2fs_unlock_op(sbi);
alloc_nid_done(sbi, inode->i_ino); alloc_nid_done(sbi, inode->i_ino);
stat_inc_inline_inode(inode);
d_tmpfile(dentry, inode); d_tmpfile(dentry, inode);
unlock_new_inode(inode); unlock_new_inode(inode);
return 0; return 0;
...@@ -729,7 +808,7 @@ const struct inode_operations f2fs_dir_inode_operations = { ...@@ -729,7 +808,7 @@ const struct inode_operations f2fs_dir_inode_operations = {
const struct inode_operations f2fs_symlink_inode_operations = { const struct inode_operations f2fs_symlink_inode_operations = {
.readlink = generic_readlink, .readlink = generic_readlink,
.follow_link = page_follow_link_light, .follow_link = f2fs_follow_link,
.put_link = page_put_link, .put_link = page_put_link,
.getattr = f2fs_getattr, .getattr = f2fs_getattr,
.setattr = f2fs_setattr, .setattr = f2fs_setattr,
......
...@@ -41,7 +41,9 @@ bool available_free_memory(struct f2fs_sb_info *sbi, int type) ...@@ -41,7 +41,9 @@ bool available_free_memory(struct f2fs_sb_info *sbi, int type)
/* only uses low memory */ /* only uses low memory */
avail_ram = val.totalram - val.totalhigh; avail_ram = val.totalram - val.totalhigh;
/* give 25%, 25%, 50%, 50% memory for each components respectively */ /*
* give 25%, 25%, 50%, 50%, 50% memory for each components respectively
*/
if (type == FREE_NIDS) { if (type == FREE_NIDS) {
mem_size = (nm_i->fcnt * sizeof(struct free_nid)) >> mem_size = (nm_i->fcnt * sizeof(struct free_nid)) >>
PAGE_CACHE_SHIFT; PAGE_CACHE_SHIFT;
...@@ -62,6 +64,11 @@ bool available_free_memory(struct f2fs_sb_info *sbi, int type) ...@@ -62,6 +64,11 @@ bool available_free_memory(struct f2fs_sb_info *sbi, int type)
mem_size += (sbi->im[i].ino_num * mem_size += (sbi->im[i].ino_num *
sizeof(struct ino_entry)) >> PAGE_CACHE_SHIFT; sizeof(struct ino_entry)) >> PAGE_CACHE_SHIFT;
res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 1); res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 1);
} else if (type == EXTENT_CACHE) {
mem_size = (sbi->total_ext_tree * sizeof(struct extent_tree) +
atomic_read(&sbi->total_ext_node) *
sizeof(struct extent_node)) >> PAGE_CACHE_SHIFT;
res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 1);
} else { } else {
if (sbi->sb->s_bdi->dirty_exceeded) if (sbi->sb->s_bdi->dirty_exceeded)
return false; return false;
...@@ -494,7 +501,7 @@ int get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode) ...@@ -494,7 +501,7 @@ int get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode)
/* if inline_data is set, should not report any block indices */ /* if inline_data is set, should not report any block indices */
if (f2fs_has_inline_data(dn->inode) && index) { if (f2fs_has_inline_data(dn->inode) && index) {
err = -EINVAL; err = -ENOENT;
f2fs_put_page(npage[0], 1); f2fs_put_page(npage[0], 1);
goto release_out; goto release_out;
} }
...@@ -995,6 +1002,7 @@ static int read_node_page(struct page *page, int rw) ...@@ -995,6 +1002,7 @@ static int read_node_page(struct page *page, int rw)
get_node_info(sbi, page->index, &ni); get_node_info(sbi, page->index, &ni);
if (unlikely(ni.blk_addr == NULL_ADDR)) { if (unlikely(ni.blk_addr == NULL_ADDR)) {
ClearPageUptodate(page);
f2fs_put_page(page, 1); f2fs_put_page(page, 1);
return -ENOENT; return -ENOENT;
} }
...@@ -1306,6 +1314,7 @@ static int f2fs_write_node_page(struct page *page, ...@@ -1306,6 +1314,7 @@ static int f2fs_write_node_page(struct page *page,
/* This page is already truncated */ /* This page is already truncated */
if (unlikely(ni.blk_addr == NULL_ADDR)) { if (unlikely(ni.blk_addr == NULL_ADDR)) {
ClearPageUptodate(page);
dec_page_count(sbi, F2FS_DIRTY_NODES); dec_page_count(sbi, F2FS_DIRTY_NODES);
unlock_page(page); unlock_page(page);
return 0; return 0;
...@@ -1821,6 +1830,7 @@ static void __flush_nat_entry_set(struct f2fs_sb_info *sbi, ...@@ -1821,6 +1830,7 @@ static void __flush_nat_entry_set(struct f2fs_sb_info *sbi,
struct f2fs_nat_block *nat_blk; struct f2fs_nat_block *nat_blk;
struct nat_entry *ne, *cur; struct nat_entry *ne, *cur;
struct page *page = NULL; struct page *page = NULL;
struct f2fs_nm_info *nm_i = NM_I(sbi);
/* /*
* there are two steps to flush nat entries: * there are two steps to flush nat entries:
...@@ -1874,7 +1884,9 @@ static void __flush_nat_entry_set(struct f2fs_sb_info *sbi, ...@@ -1874,7 +1884,9 @@ static void __flush_nat_entry_set(struct f2fs_sb_info *sbi,
f2fs_bug_on(sbi, set->entry_cnt); f2fs_bug_on(sbi, set->entry_cnt);
down_write(&nm_i->nat_tree_lock);
radix_tree_delete(&NM_I(sbi)->nat_set_root, set->set); radix_tree_delete(&NM_I(sbi)->nat_set_root, set->set);
up_write(&nm_i->nat_tree_lock);
kmem_cache_free(nat_entry_set_slab, set); kmem_cache_free(nat_entry_set_slab, set);
} }
...@@ -1902,6 +1914,7 @@ void flush_nat_entries(struct f2fs_sb_info *sbi) ...@@ -1902,6 +1914,7 @@ void flush_nat_entries(struct f2fs_sb_info *sbi)
if (!__has_cursum_space(sum, nm_i->dirty_nat_cnt, NAT_JOURNAL)) if (!__has_cursum_space(sum, nm_i->dirty_nat_cnt, NAT_JOURNAL))
remove_nats_in_journal(sbi); remove_nats_in_journal(sbi);
down_write(&nm_i->nat_tree_lock);
while ((found = __gang_lookup_nat_set(nm_i, while ((found = __gang_lookup_nat_set(nm_i,
set_idx, SETVEC_SIZE, setvec))) { set_idx, SETVEC_SIZE, setvec))) {
unsigned idx; unsigned idx;
...@@ -1910,6 +1923,7 @@ void flush_nat_entries(struct f2fs_sb_info *sbi) ...@@ -1910,6 +1923,7 @@ void flush_nat_entries(struct f2fs_sb_info *sbi)
__adjust_nat_entry_set(setvec[idx], &sets, __adjust_nat_entry_set(setvec[idx], &sets,
MAX_NAT_JENTRIES(sum)); MAX_NAT_JENTRIES(sum));
} }
up_write(&nm_i->nat_tree_lock);
/* flush dirty nats in nat entry set */ /* flush dirty nats in nat entry set */
list_for_each_entry_safe(set, tmp, &sets, set_list) list_for_each_entry_safe(set, tmp, &sets, set_list)
......
...@@ -120,6 +120,7 @@ enum mem_type { ...@@ -120,6 +120,7 @@ enum mem_type {
NAT_ENTRIES, /* indicates the cached nat entry */ NAT_ENTRIES, /* indicates the cached nat entry */
DIRTY_DENTS, /* indicates dirty dentry pages */ DIRTY_DENTS, /* indicates dirty dentry pages */
INO_ENTRIES, /* indicates inode entries */ INO_ENTRIES, /* indicates inode entries */
EXTENT_CACHE, /* indicates extent cache */
BASE_CHECK, /* check kernel status */ BASE_CHECK, /* check kernel status */
}; };
......
...@@ -93,10 +93,9 @@ static int recover_dentry(struct inode *inode, struct page *ipage) ...@@ -93,10 +93,9 @@ static int recover_dentry(struct inode *inode, struct page *ipage)
} }
retry: retry:
de = f2fs_find_entry(dir, &name, &page); de = f2fs_find_entry(dir, &name, &page);
if (de && inode->i_ino == le32_to_cpu(de->ino)) { if (de && inode->i_ino == le32_to_cpu(de->ino))
clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
goto out_unmap_put; goto out_unmap_put;
}
if (de) { if (de) {
einode = f2fs_iget(inode->i_sb, le32_to_cpu(de->ino)); einode = f2fs_iget(inode->i_sb, le32_to_cpu(de->ino));
if (IS_ERR(einode)) { if (IS_ERR(einode)) {
...@@ -115,7 +114,7 @@ static int recover_dentry(struct inode *inode, struct page *ipage) ...@@ -115,7 +114,7 @@ static int recover_dentry(struct inode *inode, struct page *ipage)
iput(einode); iput(einode);
goto retry; goto retry;
} }
err = __f2fs_add_link(dir, &name, inode); err = __f2fs_add_link(dir, &name, inode, inode->i_ino, inode->i_mode);
if (err) if (err)
goto out_err; goto out_err;
...@@ -187,11 +186,7 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head) ...@@ -187,11 +186,7 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
goto next; goto next;
entry = get_fsync_inode(head, ino_of_node(page)); entry = get_fsync_inode(head, ino_of_node(page));
if (entry) { if (!entry) {
if (IS_INODE(page) && is_dent_dnode(page))
set_inode_flag(F2FS_I(entry->inode),
FI_INC_LINK);
} else {
if (IS_INODE(page) && is_dent_dnode(page)) { if (IS_INODE(page) && is_dent_dnode(page)) {
err = recover_inode_page(sbi, page); err = recover_inode_page(sbi, page);
if (err) if (err)
...@@ -212,8 +207,10 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head) ...@@ -212,8 +207,10 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
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); kmem_cache_free(fsync_entry_slab, entry);
if (err == -ENOENT) if (err == -ENOENT) {
err = 0;
goto next; goto next;
}
break; break;
} }
list_add_tail(&entry->list, head); list_add_tail(&entry->list, head);
...@@ -256,6 +253,7 @@ static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi, ...@@ -256,6 +253,7 @@ static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
struct f2fs_summary_block *sum_node; struct f2fs_summary_block *sum_node;
struct f2fs_summary sum; struct f2fs_summary sum;
struct page *sum_page, *node_page; struct page *sum_page, *node_page;
struct dnode_of_data tdn = *dn;
nid_t ino, nid; nid_t ino, nid;
struct inode *inode; struct inode *inode;
unsigned int offset; unsigned int offset;
...@@ -283,17 +281,15 @@ static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi, ...@@ -283,17 +281,15 @@ static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
/* Use the locked dnode page and inode */ /* Use the locked dnode page and inode */
nid = le32_to_cpu(sum.nid); nid = le32_to_cpu(sum.nid);
if (dn->inode->i_ino == nid) { if (dn->inode->i_ino == nid) {
struct dnode_of_data tdn = *dn;
tdn.nid = nid; tdn.nid = nid;
if (!dn->inode_page_locked)
lock_page(dn->inode_page);
tdn.node_page = dn->inode_page; tdn.node_page = dn->inode_page;
tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node); tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
truncate_data_blocks_range(&tdn, 1); goto truncate_out;
return 0;
} else if (dn->nid == nid) { } else if (dn->nid == nid) {
struct dnode_of_data tdn = *dn;
tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node); tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
truncate_data_blocks_range(&tdn, 1); goto truncate_out;
return 0;
} }
/* Get the node page */ /* Get the node page */
...@@ -317,18 +313,33 @@ static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi, ...@@ -317,18 +313,33 @@ static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
bidx = start_bidx_of_node(offset, F2FS_I(inode)) + bidx = start_bidx_of_node(offset, F2FS_I(inode)) +
le16_to_cpu(sum.ofs_in_node); le16_to_cpu(sum.ofs_in_node);
if (ino != dn->inode->i_ino) { /*
truncate_hole(inode, bidx, bidx + 1); * if inode page is locked, unlock temporarily, but its reference
* count keeps alive.
*/
if (ino == dn->inode->i_ino && dn->inode_page_locked)
unlock_page(dn->inode_page);
set_new_dnode(&tdn, inode, NULL, NULL, 0);
if (get_dnode_of_data(&tdn, bidx, LOOKUP_NODE))
goto out;
if (tdn.data_blkaddr == blkaddr)
truncate_data_blocks_range(&tdn, 1);
f2fs_put_dnode(&tdn);
out:
if (ino != dn->inode->i_ino)
iput(inode); iput(inode);
} else { else if (dn->inode_page_locked)
struct dnode_of_data tdn; lock_page(dn->inode_page);
set_new_dnode(&tdn, inode, dn->inode_page, NULL, 0); return 0;
if (get_dnode_of_data(&tdn, bidx, LOOKUP_NODE))
return 0; truncate_out:
if (tdn.data_blkaddr != NULL_ADDR) if (datablock_addr(tdn.node_page, tdn.ofs_in_node) == blkaddr)
truncate_data_blocks_range(&tdn, 1); truncate_data_blocks_range(&tdn, 1);
f2fs_put_page(tdn.node_page, 1); if (dn->inode->i_ino == nid && !dn->inode_page_locked)
} unlock_page(dn->inode_page);
return 0; return 0;
} }
...@@ -384,7 +395,9 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode, ...@@ -384,7 +395,9 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
src = datablock_addr(dn.node_page, dn.ofs_in_node); src = datablock_addr(dn.node_page, dn.ofs_in_node);
dest = datablock_addr(page, dn.ofs_in_node); dest = datablock_addr(page, dn.ofs_in_node);
if (src != dest && dest != NEW_ADDR && dest != NULL_ADDR) { if (src != dest && dest != NEW_ADDR && dest != NULL_ADDR &&
dest >= MAIN_BLKADDR(sbi) && dest < MAX_BLKADDR(sbi)) {
if (src == NULL_ADDR) { if (src == NULL_ADDR) {
err = reserve_new_block(&dn); err = reserve_new_block(&dn);
/* We should not get -ENOSPC */ /* We should not get -ENOSPC */
...@@ -401,14 +414,13 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode, ...@@ -401,14 +414,13 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
/* write dummy data page */ /* write dummy data page */
recover_data_page(sbi, NULL, &sum, src, dest); recover_data_page(sbi, NULL, &sum, src, dest);
dn.data_blkaddr = dest; dn.data_blkaddr = dest;
update_extent_cache(&dn); set_data_blkaddr(&dn);
f2fs_update_extent_cache(&dn);
recovered++; recovered++;
} }
dn.ofs_in_node++; dn.ofs_in_node++;
} }
/* write node page in place */
set_summary(&sum, dn.nid, 0, 0);
if (IS_INODE(dn.node_page)) if (IS_INODE(dn.node_page))
sync_inode_page(&dn); sync_inode_page(&dn);
...@@ -552,7 +564,7 @@ int recover_fsync_data(struct f2fs_sb_info *sbi) ...@@ -552,7 +564,7 @@ int recover_fsync_data(struct f2fs_sb_info *sbi)
mutex_unlock(&sbi->cp_mutex); mutex_unlock(&sbi->cp_mutex);
} else if (need_writecp) { } else if (need_writecp) {
struct cp_control cpc = { struct cp_control cpc = {
.reason = CP_SYNC, .reason = CP_RECOVERY,
}; };
mutex_unlock(&sbi->cp_mutex); mutex_unlock(&sbi->cp_mutex);
write_checkpoint(sbi, &cpc); write_checkpoint(sbi, &cpc);
......
...@@ -205,6 +205,8 @@ void register_inmem_page(struct inode *inode, struct page *page) ...@@ -205,6 +205,8 @@ void register_inmem_page(struct inode *inode, struct page *page)
list_add_tail(&new->list, &fi->inmem_pages); list_add_tail(&new->list, &fi->inmem_pages);
inc_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES); inc_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES);
mutex_unlock(&fi->inmem_lock); mutex_unlock(&fi->inmem_lock);
trace_f2fs_register_inmem_page(page, INMEM);
} }
void commit_inmem_pages(struct inode *inode, bool abort) void commit_inmem_pages(struct inode *inode, bool abort)
...@@ -238,11 +240,13 @@ void commit_inmem_pages(struct inode *inode, bool abort) ...@@ -238,11 +240,13 @@ void commit_inmem_pages(struct inode *inode, bool abort)
f2fs_wait_on_page_writeback(cur->page, DATA); f2fs_wait_on_page_writeback(cur->page, DATA);
if (clear_page_dirty_for_io(cur->page)) if (clear_page_dirty_for_io(cur->page))
inode_dec_dirty_pages(inode); inode_dec_dirty_pages(inode);
trace_f2fs_commit_inmem_page(cur->page, INMEM);
do_write_data_page(cur->page, &fio); do_write_data_page(cur->page, &fio);
submit_bio = true; submit_bio = true;
} }
f2fs_put_page(cur->page, 1); f2fs_put_page(cur->page, 1);
} else { } else {
trace_f2fs_commit_inmem_page(cur->page, INMEM_DROP);
put_page(cur->page); put_page(cur->page);
} }
radix_tree_delete(&fi->inmem_root, cur->page->index); radix_tree_delete(&fi->inmem_root, cur->page->index);
...@@ -277,6 +281,9 @@ void f2fs_balance_fs(struct f2fs_sb_info *sbi) ...@@ -277,6 +281,9 @@ void f2fs_balance_fs(struct f2fs_sb_info *sbi)
void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi) void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi)
{ {
/* try to shrink extent cache when there is no enough memory */
f2fs_shrink_extent_tree(sbi, EXTENT_CACHE_SHRINK_NUMBER);
/* check the # of cached NAT entries and prefree segments */ /* check the # of cached NAT entries and prefree segments */
if (try_to_free_nats(sbi, NAT_ENTRY_PER_BLOCK) || if (try_to_free_nats(sbi, NAT_ENTRY_PER_BLOCK) ||
excess_prefree_segs(sbi) || excess_prefree_segs(sbi) ||
...@@ -549,7 +556,7 @@ static void add_discard_addrs(struct f2fs_sb_info *sbi, struct cp_control *cpc) ...@@ -549,7 +556,7 @@ static void add_discard_addrs(struct f2fs_sb_info *sbi, struct cp_control *cpc)
end = __find_rev_next_zero_bit(dmap, max_blocks, start + 1); end = __find_rev_next_zero_bit(dmap, max_blocks, start + 1);
if (end - start < cpc->trim_minlen) if (force && end - start < cpc->trim_minlen)
continue; continue;
__add_discard_entry(sbi, cpc, start, end); __add_discard_entry(sbi, cpc, start, end);
...@@ -1164,6 +1171,7 @@ void allocate_data_block(struct f2fs_sb_info *sbi, struct page *page, ...@@ -1164,6 +1171,7 @@ void allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
curseg = CURSEG_I(sbi, type); curseg = CURSEG_I(sbi, type);
mutex_lock(&curseg->curseg_mutex); mutex_lock(&curseg->curseg_mutex);
mutex_lock(&sit_i->sentry_lock);
/* direct_io'ed data is aligned to the segment for better performance */ /* direct_io'ed data is aligned to the segment for better performance */
if (direct_io && curseg->next_blkoff) if (direct_io && curseg->next_blkoff)
...@@ -1178,7 +1186,6 @@ void allocate_data_block(struct f2fs_sb_info *sbi, struct page *page, ...@@ -1178,7 +1186,6 @@ void allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
*/ */
__add_sum_entry(sbi, type, sum); __add_sum_entry(sbi, type, sum);
mutex_lock(&sit_i->sentry_lock);
__refresh_next_blkoff(sbi, curseg); __refresh_next_blkoff(sbi, curseg);
stat_inc_block_count(sbi, curseg); stat_inc_block_count(sbi, curseg);
...@@ -1730,6 +1737,9 @@ void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc) ...@@ -1730,6 +1737,9 @@ void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc)
mutex_lock(&curseg->curseg_mutex); mutex_lock(&curseg->curseg_mutex);
mutex_lock(&sit_i->sentry_lock); mutex_lock(&sit_i->sentry_lock);
if (!sit_i->dirty_sentries)
goto out;
/* /*
* add and account sit entries of dirty bitmap in sit entry * add and account sit entries of dirty bitmap in sit entry
* set temporarily * set temporarily
...@@ -1744,9 +1754,6 @@ void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc) ...@@ -1744,9 +1754,6 @@ void flush_sit_entries(struct f2fs_sb_info *sbi, struct cp_control *cpc)
if (!__has_cursum_space(sum, sit_i->dirty_sentries, SIT_JOURNAL)) if (!__has_cursum_space(sum, sit_i->dirty_sentries, SIT_JOURNAL))
remove_sits_in_journal(sbi); remove_sits_in_journal(sbi);
if (!sit_i->dirty_sentries)
goto out;
/* /*
* there are two steps to flush sit entries: * there are two steps to flush sit entries:
* #1, flush sit entries to journal in current cold data summary block. * #1, flush sit entries to journal in current cold data summary block.
......
...@@ -336,7 +336,8 @@ static inline void __set_free(struct f2fs_sb_info *sbi, unsigned int segno) ...@@ -336,7 +336,8 @@ static inline void __set_free(struct f2fs_sb_info *sbi, unsigned int segno)
clear_bit(segno, free_i->free_segmap); clear_bit(segno, free_i->free_segmap);
free_i->free_segments++; free_i->free_segments++;
next = find_next_bit(free_i->free_segmap, MAIN_SEGS(sbi), start_segno); next = find_next_bit(free_i->free_segmap,
start_segno + sbi->segs_per_sec, start_segno);
if (next >= start_segno + sbi->segs_per_sec) { if (next >= start_segno + sbi->segs_per_sec) {
clear_bit(secno, free_i->free_secmap); clear_bit(secno, free_i->free_secmap);
free_i->free_sections++; free_i->free_sections++;
......
...@@ -57,6 +57,8 @@ enum { ...@@ -57,6 +57,8 @@ enum {
Opt_flush_merge, Opt_flush_merge,
Opt_nobarrier, Opt_nobarrier,
Opt_fastboot, Opt_fastboot,
Opt_extent_cache,
Opt_noinline_data,
Opt_err, Opt_err,
}; };
...@@ -78,6 +80,8 @@ static match_table_t f2fs_tokens = { ...@@ -78,6 +80,8 @@ static match_table_t f2fs_tokens = {
{Opt_flush_merge, "flush_merge"}, {Opt_flush_merge, "flush_merge"},
{Opt_nobarrier, "nobarrier"}, {Opt_nobarrier, "nobarrier"},
{Opt_fastboot, "fastboot"}, {Opt_fastboot, "fastboot"},
{Opt_extent_cache, "extent_cache"},
{Opt_noinline_data, "noinline_data"},
{Opt_err, NULL}, {Opt_err, NULL},
}; };
...@@ -367,6 +371,12 @@ static int parse_options(struct super_block *sb, char *options) ...@@ -367,6 +371,12 @@ static int parse_options(struct super_block *sb, char *options)
case Opt_fastboot: case Opt_fastboot:
set_opt(sbi, FASTBOOT); set_opt(sbi, FASTBOOT);
break; break;
case Opt_extent_cache:
set_opt(sbi, EXTENT_CACHE);
break;
case Opt_noinline_data:
clear_opt(sbi, INLINE_DATA);
break;
default: default:
f2fs_msg(sb, KERN_ERR, f2fs_msg(sb, KERN_ERR,
"Unrecognized mount option \"%s\" or missing value", "Unrecognized mount option \"%s\" or missing value",
...@@ -392,7 +402,7 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb) ...@@ -392,7 +402,7 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb)
atomic_set(&fi->dirty_pages, 0); atomic_set(&fi->dirty_pages, 0);
fi->i_current_depth = 1; fi->i_current_depth = 1;
fi->i_advise = 0; fi->i_advise = 0;
rwlock_init(&fi->ext.ext_lock); rwlock_init(&fi->ext_lock);
init_rwsem(&fi->i_sem); init_rwsem(&fi->i_sem);
INIT_RADIX_TREE(&fi->inmem_root, GFP_NOFS); INIT_RADIX_TREE(&fi->inmem_root, GFP_NOFS);
INIT_LIST_HEAD(&fi->inmem_pages); INIT_LIST_HEAD(&fi->inmem_pages);
...@@ -591,6 +601,8 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root) ...@@ -591,6 +601,8 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
seq_puts(seq, ",disable_ext_identify"); seq_puts(seq, ",disable_ext_identify");
if (test_opt(sbi, INLINE_DATA)) if (test_opt(sbi, INLINE_DATA))
seq_puts(seq, ",inline_data"); seq_puts(seq, ",inline_data");
else
seq_puts(seq, ",noinline_data");
if (test_opt(sbi, INLINE_DENTRY)) if (test_opt(sbi, INLINE_DENTRY))
seq_puts(seq, ",inline_dentry"); seq_puts(seq, ",inline_dentry");
if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE)) if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE))
...@@ -599,6 +611,8 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root) ...@@ -599,6 +611,8 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
seq_puts(seq, ",nobarrier"); seq_puts(seq, ",nobarrier");
if (test_opt(sbi, FASTBOOT)) if (test_opt(sbi, FASTBOOT))
seq_puts(seq, ",fastboot"); seq_puts(seq, ",fastboot");
if (test_opt(sbi, EXTENT_CACHE))
seq_puts(seq, ",extent_cache");
seq_printf(seq, ",active_logs=%u", sbi->active_logs); seq_printf(seq, ",active_logs=%u", sbi->active_logs);
return 0; return 0;
...@@ -959,7 +973,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) ...@@ -959,7 +973,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
struct buffer_head *raw_super_buf; struct buffer_head *raw_super_buf;
struct inode *root; struct inode *root;
long err = -EINVAL; long err = -EINVAL;
bool retry = true; bool retry = true, need_fsck = false;
char *options = NULL; char *options = NULL;
int i; int i;
...@@ -984,6 +998,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) ...@@ -984,6 +998,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
sbi->active_logs = NR_CURSEG_TYPE; sbi->active_logs = NR_CURSEG_TYPE;
set_opt(sbi, BG_GC); set_opt(sbi, BG_GC);
set_opt(sbi, INLINE_DATA);
#ifdef CONFIG_F2FS_FS_XATTR #ifdef CONFIG_F2FS_FS_XATTR
set_opt(sbi, XATTR_USER); set_opt(sbi, XATTR_USER);
...@@ -1020,7 +1035,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) ...@@ -1020,7 +1035,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
sbi->raw_super = raw_super; sbi->raw_super = raw_super;
sbi->raw_super_buf = raw_super_buf; sbi->raw_super_buf = raw_super_buf;
mutex_init(&sbi->gc_mutex); mutex_init(&sbi->gc_mutex);
mutex_init(&sbi->writepages);
mutex_init(&sbi->cp_mutex); mutex_init(&sbi->cp_mutex);
init_rwsem(&sbi->node_write); init_rwsem(&sbi->node_write);
clear_sbi_flag(sbi, SBI_POR_DOING); clear_sbi_flag(sbi, SBI_POR_DOING);
...@@ -1072,6 +1086,8 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) ...@@ -1072,6 +1086,8 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
INIT_LIST_HEAD(&sbi->dir_inode_list); INIT_LIST_HEAD(&sbi->dir_inode_list);
spin_lock_init(&sbi->dir_inode_lock); spin_lock_init(&sbi->dir_inode_lock);
init_extent_cache_info(sbi);
init_ino_entry_info(sbi); init_ino_entry_info(sbi);
/* setup f2fs internal modules */ /* setup f2fs internal modules */
...@@ -1146,9 +1162,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) ...@@ -1146,9 +1162,6 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
if (err) if (err)
goto free_proc; goto free_proc;
if (!retry)
set_sbi_flag(sbi, SBI_NEED_FSCK);
/* recover fsynced data */ /* recover fsynced data */
if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) { if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) {
/* /*
...@@ -1160,8 +1173,13 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) ...@@ -1160,8 +1173,13 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
err = -EROFS; err = -EROFS;
goto free_kobj; goto free_kobj;
} }
if (need_fsck)
set_sbi_flag(sbi, SBI_NEED_FSCK);
err = recover_fsync_data(sbi); err = recover_fsync_data(sbi);
if (err) { if (err) {
need_fsck = true;
f2fs_msg(sb, KERN_ERR, f2fs_msg(sb, KERN_ERR,
"Cannot recover all fsync data errno=%ld", err); "Cannot recover all fsync data errno=%ld", err);
goto free_kobj; goto free_kobj;
...@@ -1212,7 +1230,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) ...@@ -1212,7 +1230,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
/* give only one another chance */ /* give only one another chance */
if (retry) { if (retry) {
retry = 0; retry = false;
shrink_dcache_sb(sb); shrink_dcache_sb(sb);
goto try_onemore; goto try_onemore;
} }
...@@ -1278,10 +1296,13 @@ static int __init init_f2fs_fs(void) ...@@ -1278,10 +1296,13 @@ static int __init init_f2fs_fs(void)
err = create_checkpoint_caches(); err = create_checkpoint_caches();
if (err) if (err)
goto free_segment_manager_caches; goto free_segment_manager_caches;
err = create_extent_cache();
if (err)
goto free_checkpoint_caches;
f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj); f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj);
if (!f2fs_kset) { if (!f2fs_kset) {
err = -ENOMEM; err = -ENOMEM;
goto free_checkpoint_caches; goto free_extent_cache;
} }
err = register_filesystem(&f2fs_fs_type); err = register_filesystem(&f2fs_fs_type);
if (err) if (err)
...@@ -1292,6 +1313,8 @@ static int __init init_f2fs_fs(void) ...@@ -1292,6 +1313,8 @@ static int __init init_f2fs_fs(void)
free_kset: free_kset:
kset_unregister(f2fs_kset); kset_unregister(f2fs_kset);
free_extent_cache:
destroy_extent_cache();
free_checkpoint_caches: free_checkpoint_caches:
destroy_checkpoint_caches(); destroy_checkpoint_caches();
free_segment_manager_caches: free_segment_manager_caches:
...@@ -1309,6 +1332,7 @@ static void __exit exit_f2fs_fs(void) ...@@ -1309,6 +1332,7 @@ static void __exit exit_f2fs_fs(void)
remove_proc_entry("fs/f2fs", NULL); remove_proc_entry("fs/f2fs", NULL);
f2fs_destroy_root_stats(); f2fs_destroy_root_stats();
unregister_filesystem(&f2fs_fs_type); unregister_filesystem(&f2fs_fs_type);
destroy_extent_cache();
destroy_checkpoint_caches(); destroy_checkpoint_caches();
destroy_segment_manager_caches(); destroy_segment_manager_caches();
destroy_node_manager_caches(); destroy_node_manager_caches();
......
...@@ -135,7 +135,8 @@ static int f2fs_xattr_advise_get(struct dentry *dentry, const char *name, ...@@ -135,7 +135,8 @@ static int f2fs_xattr_advise_get(struct dentry *dentry, const char *name,
if (strcmp(name, "") != 0) if (strcmp(name, "") != 0)
return -EINVAL; return -EINVAL;
*((char *)buffer) = F2FS_I(inode)->i_advise; if (buffer)
*((char *)buffer) = F2FS_I(inode)->i_advise;
return sizeof(char); return sizeof(char);
} }
...@@ -152,6 +153,7 @@ static int f2fs_xattr_advise_set(struct dentry *dentry, const char *name, ...@@ -152,6 +153,7 @@ static int f2fs_xattr_advise_set(struct dentry *dentry, const char *name,
return -EINVAL; return -EINVAL;
F2FS_I(inode)->i_advise |= *(char *)value; F2FS_I(inode)->i_advise |= *(char *)value;
mark_inode_dirty(inode);
return 0; return 0;
} }
......
...@@ -153,7 +153,7 @@ struct f2fs_orphan_block { ...@@ -153,7 +153,7 @@ struct f2fs_orphan_block {
*/ */
struct f2fs_extent { struct f2fs_extent {
__le32 fofs; /* start file offset of the extent */ __le32 fofs; /* start file offset of the extent */
__le32 blk_addr; /* start block address of the extent */ __le32 blk; /* start block address of the extent */
__le32 len; /* lengh of the extent */ __le32 len; /* lengh of the extent */
} __packed; } __packed;
...@@ -178,6 +178,7 @@ struct f2fs_extent { ...@@ -178,6 +178,7 @@ struct f2fs_extent {
#define F2FS_INLINE_DATA 0x02 /* file inline data flag */ #define F2FS_INLINE_DATA 0x02 /* file inline data flag */
#define F2FS_INLINE_DENTRY 0x04 /* file inline dentry flag */ #define F2FS_INLINE_DENTRY 0x04 /* file inline dentry flag */
#define F2FS_DATA_EXIST 0x08 /* file inline data exist flag */ #define F2FS_DATA_EXIST 0x08 /* file inline data exist flag */
#define F2FS_INLINE_DOTS 0x10 /* file having implicit dot dentries */
#define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ #define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \
F2FS_INLINE_XATTR_ADDRS - 1)) F2FS_INLINE_XATTR_ADDRS - 1))
......
...@@ -44,7 +44,11 @@ TRACE_DEFINE_ENUM(CP_DISCARD); ...@@ -44,7 +44,11 @@ TRACE_DEFINE_ENUM(CP_DISCARD);
{ NODE, "NODE" }, \ { NODE, "NODE" }, \
{ DATA, "DATA" }, \ { DATA, "DATA" }, \
{ META, "META" }, \ { META, "META" }, \
{ META_FLUSH, "META_FLUSH" }) { META_FLUSH, "META_FLUSH" }, \
{ INMEM, "INMEM" }, \
{ INMEM_DROP, "INMEM_DROP" }, \
{ IPU, "IN-PLACE" }, \
{ OPU, "OUT-OF-PLACE" })
#define F2FS_BIO_MASK(t) (t & (READA | WRITE_FLUSH_FUA)) #define F2FS_BIO_MASK(t) (t & (READA | WRITE_FLUSH_FUA))
#define F2FS_BIO_EXTRA_MASK(t) (t & (REQ_META | REQ_PRIO)) #define F2FS_BIO_EXTRA_MASK(t) (t & (REQ_META | REQ_PRIO))
...@@ -104,6 +108,7 @@ TRACE_DEFINE_ENUM(CP_DISCARD); ...@@ -104,6 +108,7 @@ TRACE_DEFINE_ENUM(CP_DISCARD);
{ CP_UMOUNT, "Umount" }, \ { CP_UMOUNT, "Umount" }, \
{ CP_FASTBOOT, "Fastboot" }, \ { CP_FASTBOOT, "Fastboot" }, \
{ CP_SYNC, "Sync" }, \ { CP_SYNC, "Sync" }, \
{ CP_RECOVERY, "Recovery" }, \
{ CP_DISCARD, "Discard" }) { CP_DISCARD, "Discard" })
struct victim_sel_policy; struct victim_sel_policy;
...@@ -884,6 +889,13 @@ DEFINE_EVENT(f2fs__page, f2fs_writepage, ...@@ -884,6 +889,13 @@ DEFINE_EVENT(f2fs__page, f2fs_writepage,
TP_ARGS(page, type) TP_ARGS(page, type)
); );
DEFINE_EVENT(f2fs__page, f2fs_do_write_data_page,
TP_PROTO(struct page *page, int type),
TP_ARGS(page, type)
);
DEFINE_EVENT(f2fs__page, f2fs_readpage, DEFINE_EVENT(f2fs__page, f2fs_readpage,
TP_PROTO(struct page *page, int type), TP_PROTO(struct page *page, int type),
...@@ -905,6 +917,20 @@ DEFINE_EVENT(f2fs__page, f2fs_vm_page_mkwrite, ...@@ -905,6 +917,20 @@ DEFINE_EVENT(f2fs__page, f2fs_vm_page_mkwrite,
TP_ARGS(page, type) TP_ARGS(page, type)
); );
DEFINE_EVENT(f2fs__page, f2fs_register_inmem_page,
TP_PROTO(struct page *page, int type),
TP_ARGS(page, type)
);
DEFINE_EVENT(f2fs__page, f2fs_commit_inmem_page,
TP_PROTO(struct page *page, int type),
TP_ARGS(page, type)
);
TRACE_EVENT(f2fs_writepages, TRACE_EVENT(f2fs_writepages,
TP_PROTO(struct inode *inode, struct writeback_control *wbc, int type), TP_PROTO(struct inode *inode, struct writeback_control *wbc, int type),
...@@ -1041,6 +1067,140 @@ TRACE_EVENT(f2fs_issue_flush, ...@@ -1041,6 +1067,140 @@ TRACE_EVENT(f2fs_issue_flush,
__entry->nobarrier ? "skip (nobarrier)" : "issue", __entry->nobarrier ? "skip (nobarrier)" : "issue",
__entry->flush_merge ? " with flush_merge" : "") __entry->flush_merge ? " with flush_merge" : "")
); );
TRACE_EVENT(f2fs_lookup_extent_tree_start,
TP_PROTO(struct inode *inode, unsigned int pgofs),
TP_ARGS(inode, pgofs),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(ino_t, ino)
__field(unsigned int, pgofs)
),
TP_fast_assign(
__entry->dev = inode->i_sb->s_dev;
__entry->ino = inode->i_ino;
__entry->pgofs = pgofs;
),
TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u",
show_dev_ino(__entry),
__entry->pgofs)
);
TRACE_EVENT_CONDITION(f2fs_lookup_extent_tree_end,
TP_PROTO(struct inode *inode, unsigned int pgofs,
struct extent_node *en),
TP_ARGS(inode, pgofs, en),
TP_CONDITION(en),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(ino_t, ino)
__field(unsigned int, pgofs)
__field(unsigned int, fofs)
__field(u32, blk)
__field(unsigned int, len)
),
TP_fast_assign(
__entry->dev = inode->i_sb->s_dev;
__entry->ino = inode->i_ino;
__entry->pgofs = pgofs;
__entry->fofs = en->ei.fofs;
__entry->blk = en->ei.blk;
__entry->len = en->ei.len;
),
TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, "
"ext_info(fofs: %u, blk: %u, len: %u)",
show_dev_ino(__entry),
__entry->pgofs,
__entry->fofs,
__entry->blk,
__entry->len)
);
TRACE_EVENT(f2fs_update_extent_tree,
TP_PROTO(struct inode *inode, unsigned int pgofs, block_t blkaddr),
TP_ARGS(inode, pgofs, blkaddr),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(ino_t, ino)
__field(unsigned int, pgofs)
__field(u32, blk)
),
TP_fast_assign(
__entry->dev = inode->i_sb->s_dev;
__entry->ino = inode->i_ino;
__entry->pgofs = pgofs;
__entry->blk = blkaddr;
),
TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, blkaddr = %u",
show_dev_ino(__entry),
__entry->pgofs,
__entry->blk)
);
TRACE_EVENT(f2fs_shrink_extent_tree,
TP_PROTO(struct f2fs_sb_info *sbi, unsigned int node_cnt,
unsigned int tree_cnt),
TP_ARGS(sbi, node_cnt, tree_cnt),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(unsigned int, node_cnt)
__field(unsigned int, tree_cnt)
),
TP_fast_assign(
__entry->dev = sbi->sb->s_dev;
__entry->node_cnt = node_cnt;
__entry->tree_cnt = tree_cnt;
),
TP_printk("dev = (%d,%d), shrunk: node_cnt = %u, tree_cnt = %u",
show_dev(__entry),
__entry->node_cnt,
__entry->tree_cnt)
);
TRACE_EVENT(f2fs_destroy_extent_tree,
TP_PROTO(struct inode *inode, unsigned int node_cnt),
TP_ARGS(inode, node_cnt),
TP_STRUCT__entry(
__field(dev_t, dev)
__field(ino_t, ino)
__field(unsigned int, node_cnt)
),
TP_fast_assign(
__entry->dev = inode->i_sb->s_dev;
__entry->ino = inode->i_ino;
__entry->node_cnt = node_cnt;
),
TP_printk("dev = (%d,%d), ino = %lu, destroyed: node_cnt = %u",
show_dev_ino(__entry),
__entry->node_cnt)
);
#endif /* _TRACE_F2FS_H */ #endif /* _TRACE_F2FS_H */
/* This part must be outside protection */ /* This part must be outside protection */
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment