aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2016-10-06 18:30:40 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2016-10-06 18:30:40 -0400
commit4c1fad64eff481982349f5795b9c198c532b0f13 (patch)
treebb9b13935cc92d050b9dc462b8e63c3cca66306a
parent0fb3ca447ddabcfb8dc7e0f719955e500b170cbd (diff)
parente4c5d8489a41209534699220021dab409e4d4f55 (diff)
Merge tag 'for-f2fs-4.9' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs
Pull f2fs updates from Jaegeuk Kim: "In this round, we've investigated how f2fs deals with errors given by our fault injection facility. With this, we could fix several corner cases. And, in order to improve the performance, we set inline_dentry by default and enhance the exisiting discard issue flow. In addition, we added f2fs_migrate_page for better memory management. Enhancements: - set inline_dentry by default - improve discard issue flow - add more fault injection cases in f2fs - allow block preallocation for encrypted files - introduce migrate_page callback function - avoid truncating the next direct node block at every checkpoint Bug fixes: - set page flag correctly between write_begin and write_end - missing error handling cases detected by fault injection - preallocate blocks regarding to 4KB alignement correctly - dentry and filename handling of encryption - lost xattrs of directories" * tag 'for-f2fs-4.9' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (69 commits) f2fs: introduce update_ckpt_flags to clean up f2fs: don't submit irrelevant page f2fs: fix to commit bio cache after flushing node pages f2fs: introduce get_checkpoint_version for cleanup f2fs: remove dead variable f2fs: remove redundant io plug f2fs: support checkpoint error injection f2fs: fix to recover old fault injection config in ->remount_fs f2fs: do fault injection initialization in default_options f2fs: remove redundant value definition f2fs: support configuring fault injection per superblock f2fs: adjust display format of segment bit f2fs: remove dirty inode pages in error path f2fs: do not unnecessarily null-terminate encrypted symlink data f2fs: handle errors during recover_orphan_inodes f2fs: avoid gc in cp_error case f2fs: should put_page for summary page f2fs: assign return value in f2fs_gc f2fs: add customized migrate_page callback f2fs: introduce cp_lock to protect updating of ckpt_flags ...
Diffstat
-rw-r--r--Documentation/filesystems/f2fs.txt1
-rw-r--r--MAINTAINERS5
-rw-r--r--fs/f2fs/acl.c12
-rw-r--r--fs/f2fs/acl.h1
-rw-r--r--fs/f2fs/checkpoint.c205
-rw-r--r--fs/f2fs/data.c131
-rw-r--r--fs/f2fs/debug.c17
-rw-r--r--fs/f2fs/dir.c110
-rw-r--r--fs/f2fs/f2fs.h175
-rw-r--r--fs/f2fs/file.c20
-rw-r--r--fs/f2fs/gc.c90
-rw-r--r--fs/f2fs/inline.c25
-rw-r--r--fs/f2fs/inode.c17
-rw-r--r--fs/f2fs/namei.c15
-rw-r--r--fs/f2fs/node.c33
-rw-r--r--fs/f2fs/node.h77
-rw-r--r--fs/f2fs/recovery.c124
-rw-r--r--fs/f2fs/segment.c219
-rw-r--r--fs/f2fs/segment.h11
-rw-r--r--fs/f2fs/super.c93
-rw-r--r--fs/f2fs/xattr.c39
-rw-r--r--include/linux/f2fs_fs.h1
-rw-r--r--include/trace/events/f2fs.h18
23 files changed, 915 insertions, 524 deletions
diff --git a/Documentation/filesystems/f2fs.txt b/Documentation/filesystems/f2fs.txt
index ecd808088362..753dd4f96afe 100644
--- a/Documentation/filesystems/f2fs.txt
+++ b/Documentation/filesystems/f2fs.txt
@@ -131,6 +131,7 @@ inline_dentry Enable the inline dir feature: data in new created
131 directory entries can be written into inode block. The 131 directory entries can be written into inode block. The
132 space of inode block which is used to store inline 132 space of inode block which is used to store inline
133 dentries is limited to ~3.4k. 133 dentries is limited to ~3.4k.
134noinline_dentry Diable the inline dentry feature.
134flush_merge Merge concurrent cache_flush commands as much as possible 135flush_merge Merge concurrent cache_flush commands as much as possible
135 to eliminate redundant command issues. If the underlying 136 to eliminate redundant command issues. If the underlying
136 device handles the cache_flush command relatively slowly, 137 device handles the cache_flush command relatively slowly,
diff --git a/MAINTAINERS b/MAINTAINERS
index ef4f7c419376..464437dbfa26 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -5105,10 +5105,9 @@ F: include/linux/fscrypto.h
5105 5105
5106F2FS FILE SYSTEM 5106F2FS FILE SYSTEM
5107M: Jaegeuk Kim <jaegeuk@kernel.org> 5107M: Jaegeuk Kim <jaegeuk@kernel.org>
5108M: Changman Lee <cm224.lee@samsung.com> 5108M: Chao Yu <yuchao0@huawei.com>
5109R: Chao Yu <yuchao0@huawei.com>
5110L: linux-f2fs-devel@lists.sourceforge.net 5109L: linux-f2fs-devel@lists.sourceforge.net
5111W: http://en.wikipedia.org/wiki/F2FS 5110W: https://f2fs.wiki.kernel.org/
5112T: git git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git 5111T: git git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git
5113S: Maintained 5112S: Maintained
5114F: Documentation/filesystems/f2fs.txt 5113F: Documentation/filesystems/f2fs.txt
diff --git a/fs/f2fs/acl.c b/fs/f2fs/acl.c
index 4dcc9e28dc5c..1e29630f49c1 100644
--- a/fs/f2fs/acl.c
+++ b/fs/f2fs/acl.c
@@ -109,14 +109,16 @@ fail:
109 return ERR_PTR(-EINVAL); 109 return ERR_PTR(-EINVAL);
110} 110}
111 111
112static void *f2fs_acl_to_disk(const struct posix_acl *acl, size_t *size) 112static void *f2fs_acl_to_disk(struct f2fs_sb_info *sbi,
113 const struct posix_acl *acl, size_t *size)
113{ 114{
114 struct f2fs_acl_header *f2fs_acl; 115 struct f2fs_acl_header *f2fs_acl;
115 struct f2fs_acl_entry *entry; 116 struct f2fs_acl_entry *entry;
116 int i; 117 int i;
117 118
118 f2fs_acl = f2fs_kmalloc(sizeof(struct f2fs_acl_header) + acl->a_count * 119 f2fs_acl = f2fs_kmalloc(sbi, sizeof(struct f2fs_acl_header) +
119 sizeof(struct f2fs_acl_entry), GFP_NOFS); 120 acl->a_count * sizeof(struct f2fs_acl_entry),
121 GFP_NOFS);
120 if (!f2fs_acl) 122 if (!f2fs_acl)
121 return ERR_PTR(-ENOMEM); 123 return ERR_PTR(-ENOMEM);
122 124
@@ -175,7 +177,7 @@ static struct posix_acl *__f2fs_get_acl(struct inode *inode, int type,
175 177
176 retval = f2fs_getxattr(inode, name_index, "", NULL, 0, dpage); 178 retval = f2fs_getxattr(inode, name_index, "", NULL, 0, dpage);
177 if (retval > 0) { 179 if (retval > 0) {
178 value = f2fs_kmalloc(retval, GFP_F2FS_ZERO); 180 value = f2fs_kmalloc(F2FS_I_SB(inode), retval, GFP_F2FS_ZERO);
179 if (!value) 181 if (!value)
180 return ERR_PTR(-ENOMEM); 182 return ERR_PTR(-ENOMEM);
181 retval = f2fs_getxattr(inode, name_index, "", value, 183 retval = f2fs_getxattr(inode, name_index, "", value,
@@ -230,7 +232,7 @@ static int __f2fs_set_acl(struct inode *inode, int type,
230 } 232 }
231 233
232 if (acl) { 234 if (acl) {
233 value = f2fs_acl_to_disk(acl, &size); 235 value = f2fs_acl_to_disk(F2FS_I_SB(inode), acl, &size);
234 if (IS_ERR(value)) { 236 if (IS_ERR(value)) {
235 clear_inode_flag(inode, FI_ACL_MODE); 237 clear_inode_flag(inode, FI_ACL_MODE);
236 return (int)PTR_ERR(value); 238 return (int)PTR_ERR(value);
diff --git a/fs/f2fs/acl.h b/fs/f2fs/acl.h
index b2334d11dae8..2c685185c24d 100644
--- a/fs/f2fs/acl.h
+++ b/fs/f2fs/acl.h
@@ -41,7 +41,6 @@ extern int f2fs_set_acl(struct inode *, struct posix_acl *, int);
41extern int f2fs_init_acl(struct inode *, struct inode *, struct page *, 41extern int f2fs_init_acl(struct inode *, struct inode *, struct page *,
42 struct page *); 42 struct page *);
43#else 43#else
44#define f2fs_check_acl NULL
45#define f2fs_get_acl NULL 44#define f2fs_get_acl NULL
46#define f2fs_set_acl NULL 45#define f2fs_set_acl NULL
47 46
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index f94d01e7d001..7e9b504bd8b2 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -28,7 +28,7 @@ struct kmem_cache *inode_entry_slab;
28 28
29void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io) 29void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io)
30{ 30{
31 set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG); 31 set_ckpt_flags(sbi, CP_ERROR_FLAG);
32 sbi->sb->s_flags |= MS_RDONLY; 32 sbi->sb->s_flags |= MS_RDONLY;
33 if (!end_io) 33 if (!end_io)
34 f2fs_flush_merged_bios(sbi); 34 f2fs_flush_merged_bios(sbi);
@@ -267,7 +267,6 @@ static int f2fs_write_meta_pages(struct address_space *mapping,
267 struct writeback_control *wbc) 267 struct writeback_control *wbc)
268{ 268{
269 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping); 269 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
270 struct blk_plug plug;
271 long diff, written; 270 long diff, written;
272 271
273 /* collect a number of dirty meta pages and write together */ 272 /* collect a number of dirty meta pages and write together */
@@ -280,9 +279,7 @@ static int f2fs_write_meta_pages(struct address_space *mapping,
280 /* if mounting is failed, skip writing node pages */ 279 /* if mounting is failed, skip writing node pages */
281 mutex_lock(&sbi->cp_mutex); 280 mutex_lock(&sbi->cp_mutex);
282 diff = nr_pages_to_write(sbi, META, wbc); 281 diff = nr_pages_to_write(sbi, META, wbc);
283 blk_start_plug(&plug);
284 written = sync_meta_pages(sbi, META, wbc->nr_to_write); 282 written = sync_meta_pages(sbi, META, wbc->nr_to_write);
285 blk_finish_plug(&plug);
286 mutex_unlock(&sbi->cp_mutex); 283 mutex_unlock(&sbi->cp_mutex);
287 wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff); 284 wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff);
288 return 0; 285 return 0;
@@ -388,6 +385,9 @@ const struct address_space_operations f2fs_meta_aops = {
388 .set_page_dirty = f2fs_set_meta_page_dirty, 385 .set_page_dirty = f2fs_set_meta_page_dirty,
389 .invalidatepage = f2fs_invalidate_page, 386 .invalidatepage = f2fs_invalidate_page,
390 .releasepage = f2fs_release_page, 387 .releasepage = f2fs_release_page,
388#ifdef CONFIG_MIGRATION
389 .migratepage = f2fs_migrate_page,
390#endif
391}; 391};
392 392
393static void __add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type) 393static void __add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)
@@ -491,7 +491,7 @@ int acquire_orphan_inode(struct f2fs_sb_info *sbi)
491 spin_lock(&im->ino_lock); 491 spin_lock(&im->ino_lock);
492 492
493#ifdef CONFIG_F2FS_FAULT_INJECTION 493#ifdef CONFIG_F2FS_FAULT_INJECTION
494 if (time_to_inject(FAULT_ORPHAN)) { 494 if (time_to_inject(sbi, FAULT_ORPHAN)) {
495 spin_unlock(&im->ino_lock); 495 spin_unlock(&im->ino_lock);
496 return -ENOSPC; 496 return -ENOSPC;
497 } 497 }
@@ -531,8 +531,20 @@ void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
531static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 531static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
532{ 532{
533 struct inode *inode; 533 struct inode *inode;
534 struct node_info ni;
535 int err = acquire_orphan_inode(sbi);
536
537 if (err) {
538 set_sbi_flag(sbi, SBI_NEED_FSCK);
539 f2fs_msg(sbi->sb, KERN_WARNING,
540 "%s: orphan failed (ino=%x), run fsck to fix.",
541 __func__, ino);
542 return err;
543 }
534 544
535 inode = f2fs_iget(sbi->sb, ino); 545 __add_ino_entry(sbi, ino, ORPHAN_INO);
546
547 inode = f2fs_iget_retry(sbi->sb, ino);
536 if (IS_ERR(inode)) { 548 if (IS_ERR(inode)) {
537 /* 549 /*
538 * there should be a bug that we can't find the entry 550 * there should be a bug that we can't find the entry
@@ -546,6 +558,18 @@ static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
546 558
547 /* truncate all the data during iput */ 559 /* truncate all the data during iput */
548 iput(inode); 560 iput(inode);
561
562 get_node_info(sbi, ino, &ni);
563
564 /* ENOMEM was fully retried in f2fs_evict_inode. */
565 if (ni.blk_addr != NULL_ADDR) {
566 set_sbi_flag(sbi, SBI_NEED_FSCK);
567 f2fs_msg(sbi->sb, KERN_WARNING,
568 "%s: orphan failed (ino=%x), run fsck to fix.",
569 __func__, ino);
570 return -EIO;
571 }
572 __remove_ino_entry(sbi, ino, ORPHAN_INO);
549 return 0; 573 return 0;
550} 574}
551 575
@@ -554,7 +578,7 @@ int recover_orphan_inodes(struct f2fs_sb_info *sbi)
554 block_t start_blk, orphan_blocks, i, j; 578 block_t start_blk, orphan_blocks, i, j;
555 int err; 579 int err;
556 580
557 if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG)) 581 if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG))
558 return 0; 582 return 0;
559 583
560 start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi); 584 start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi);
@@ -578,7 +602,7 @@ int recover_orphan_inodes(struct f2fs_sb_info *sbi)
578 f2fs_put_page(page, 1); 602 f2fs_put_page(page, 1);
579 } 603 }
580 /* clear Orphan Flag */ 604 /* clear Orphan Flag */
581 clear_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG); 605 clear_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG);
582 return 0; 606 return 0;
583} 607}
584 608
@@ -639,45 +663,55 @@ static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk)
639 } 663 }
640} 664}
641 665
642static struct page *validate_checkpoint(struct f2fs_sb_info *sbi, 666static int get_checkpoint_version(struct f2fs_sb_info *sbi, block_t cp_addr,
643 block_t cp_addr, unsigned long long *version) 667 struct f2fs_checkpoint **cp_block, struct page **cp_page,
668 unsigned long long *version)
644{ 669{
645 struct page *cp_page_1, *cp_page_2 = NULL;
646 unsigned long blk_size = sbi->blocksize; 670 unsigned long blk_size = sbi->blocksize;
647 struct f2fs_checkpoint *cp_block; 671 size_t crc_offset = 0;
648 unsigned long long cur_version = 0, pre_version = 0;
649 size_t crc_offset;
650 __u32 crc = 0; 672 __u32 crc = 0;
651 673
652 /* Read the 1st cp block in this CP pack */ 674 *cp_page = get_meta_page(sbi, cp_addr);
653 cp_page_1 = get_meta_page(sbi, cp_addr); 675 *cp_block = (struct f2fs_checkpoint *)page_address(*cp_page);
654 676
655 /* get the version number */ 677 crc_offset = le32_to_cpu((*cp_block)->checksum_offset);
656 cp_block = (struct f2fs_checkpoint *)page_address(cp_page_1); 678 if (crc_offset >= blk_size) {
657 crc_offset = le32_to_cpu(cp_block->checksum_offset); 679 f2fs_msg(sbi->sb, KERN_WARNING,
658 if (crc_offset >= blk_size) 680 "invalid crc_offset: %zu", crc_offset);
659 goto invalid_cp1; 681 return -EINVAL;
682 }
660 683
661 crc = le32_to_cpu(*((__le32 *)((unsigned char *)cp_block + crc_offset))); 684 crc = le32_to_cpu(*((__le32 *)((unsigned char *)*cp_block
662 if (!f2fs_crc_valid(sbi, crc, cp_block, crc_offset)) 685 + crc_offset)));
663 goto invalid_cp1; 686 if (!f2fs_crc_valid(sbi, crc, *cp_block, crc_offset)) {
687 f2fs_msg(sbi->sb, KERN_WARNING, "invalid crc value");
688 return -EINVAL;
689 }
664 690
665 pre_version = cur_cp_version(cp_block); 691 *version = cur_cp_version(*cp_block);
692 return 0;
693}
666 694
667 /* Read the 2nd cp block in this CP pack */ 695static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,
668 cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1; 696 block_t cp_addr, unsigned long long *version)
669 cp_page_2 = get_meta_page(sbi, cp_addr); 697{
698 struct page *cp_page_1 = NULL, *cp_page_2 = NULL;
699 struct f2fs_checkpoint *cp_block = NULL;
700 unsigned long long cur_version = 0, pre_version = 0;
701 int err;
670 702
671 cp_block = (struct f2fs_checkpoint *)page_address(cp_page_2); 703 err = get_checkpoint_version(sbi, cp_addr, &cp_block,
672 crc_offset = le32_to_cpu(cp_block->checksum_offset); 704 &cp_page_1, version);
673 if (crc_offset >= blk_size) 705 if (err)
674 goto invalid_cp2; 706 goto invalid_cp1;
707 pre_version = *version;
675 708
676 crc = le32_to_cpu(*((__le32 *)((unsigned char *)cp_block + crc_offset))); 709 cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
677 if (!f2fs_crc_valid(sbi, crc, cp_block, crc_offset)) 710 err = get_checkpoint_version(sbi, cp_addr, &cp_block,
711 &cp_page_2, version);
712 if (err)
678 goto invalid_cp2; 713 goto invalid_cp2;
679 714 cur_version = *version;
680 cur_version = cur_cp_version(cp_block);
681 715
682 if (cur_version == pre_version) { 716 if (cur_version == pre_version) {
683 *version = cur_version; 717 *version = cur_version;
@@ -972,10 +1006,40 @@ static void wait_on_all_pages_writeback(struct f2fs_sb_info *sbi)
972 finish_wait(&sbi->cp_wait, &wait); 1006 finish_wait(&sbi->cp_wait, &wait);
973} 1007}
974 1008
1009static void update_ckpt_flags(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1010{
1011 unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num;
1012 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1013
1014 spin_lock(&sbi->cp_lock);
1015
1016 if (cpc->reason == CP_UMOUNT)
1017 __set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
1018 else
1019 __clear_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
1020
1021 if (cpc->reason == CP_FASTBOOT)
1022 __set_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);
1023 else
1024 __clear_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);
1025
1026 if (orphan_num)
1027 __set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
1028 else
1029 __clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
1030
1031 if (is_sbi_flag_set(sbi, SBI_NEED_FSCK))
1032 __set_ckpt_flags(ckpt, CP_FSCK_FLAG);
1033
1034 /* set this flag to activate crc|cp_ver for recovery */
1035 __set_ckpt_flags(ckpt, CP_CRC_RECOVERY_FLAG);
1036
1037 spin_unlock(&sbi->cp_lock);
1038}
1039
975static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 1040static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
976{ 1041{
977 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 1042 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
978 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
979 struct f2fs_nm_info *nm_i = NM_I(sbi); 1043 struct f2fs_nm_info *nm_i = NM_I(sbi);
980 unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num; 1044 unsigned long orphan_num = sbi->im[ORPHAN_INO].ino_num;
981 nid_t last_nid = nm_i->next_scan_nid; 1045 nid_t last_nid = nm_i->next_scan_nid;
@@ -984,19 +1048,10 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
984 __u32 crc32 = 0; 1048 __u32 crc32 = 0;
985 int i; 1049 int i;
986 int cp_payload_blks = __cp_payload(sbi); 1050 int cp_payload_blks = __cp_payload(sbi);
987 block_t discard_blk = NEXT_FREE_BLKADDR(sbi, curseg);
988 bool invalidate = false;
989 struct super_block *sb = sbi->sb; 1051 struct super_block *sb = sbi->sb;
990 struct curseg_info *seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE); 1052 struct curseg_info *seg_i = CURSEG_I(sbi, CURSEG_HOT_NODE);
991 u64 kbytes_written; 1053 u64 kbytes_written;
992 1054
993 /*
994 * This avoids to conduct wrong roll-forward operations and uses
995 * metapages, so should be called prior to sync_meta_pages below.
996 */
997 if (!test_opt(sbi, LFS) && discard_next_dnode(sbi, discard_blk))
998 invalidate = true;
999
1000 /* Flush all the NAT/SIT pages */ 1055 /* Flush all the NAT/SIT pages */
1001 while (get_pages(sbi, F2FS_DIRTY_META)) { 1056 while (get_pages(sbi, F2FS_DIRTY_META)) {
1002 sync_meta_pages(sbi, META, LONG_MAX); 1057 sync_meta_pages(sbi, META, LONG_MAX);
@@ -1036,10 +1091,12 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1036 1091
1037 /* 2 cp + n data seg summary + orphan inode blocks */ 1092 /* 2 cp + n data seg summary + orphan inode blocks */
1038 data_sum_blocks = npages_for_summary_flush(sbi, false); 1093 data_sum_blocks = npages_for_summary_flush(sbi, false);
1094 spin_lock(&sbi->cp_lock);
1039 if (data_sum_blocks < NR_CURSEG_DATA_TYPE) 1095 if (data_sum_blocks < NR_CURSEG_DATA_TYPE)
1040 set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG); 1096 __set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
1041 else 1097 else
1042 clear_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG); 1098 __clear_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
1099 spin_unlock(&sbi->cp_lock);
1043 1100
1044 orphan_blocks = GET_ORPHAN_BLOCKS(orphan_num); 1101 orphan_blocks = GET_ORPHAN_BLOCKS(orphan_num);
1045 ckpt->cp_pack_start_sum = cpu_to_le32(1 + cp_payload_blks + 1102 ckpt->cp_pack_start_sum = cpu_to_le32(1 + cp_payload_blks +
@@ -1054,23 +1111,8 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1054 cp_payload_blks + data_sum_blocks + 1111 cp_payload_blks + data_sum_blocks +
1055 orphan_blocks); 1112 orphan_blocks);
1056 1113
1057 if (cpc->reason == CP_UMOUNT) 1114 /* update ckpt flag for checkpoint */
1058 set_ckpt_flags(ckpt, CP_UMOUNT_FLAG); 1115 update_ckpt_flags(sbi, cpc);
1059 else
1060 clear_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
1061
1062 if (cpc->reason == CP_FASTBOOT)
1063 set_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);
1064 else
1065 clear_ckpt_flags(ckpt, CP_FASTBOOT_FLAG);
1066
1067 if (orphan_num)
1068 set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
1069 else
1070 clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
1071
1072 if (is_sbi_flag_set(sbi, SBI_NEED_FSCK))
1073 set_ckpt_flags(ckpt, CP_FSCK_FLAG);
1074 1116
1075 /* update SIT/NAT bitmap */ 1117 /* update SIT/NAT bitmap */
1076 get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP)); 1118 get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP));
@@ -1137,14 +1179,6 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1137 /* wait for previous submitted meta pages writeback */ 1179 /* wait for previous submitted meta pages writeback */
1138 wait_on_all_pages_writeback(sbi); 1180 wait_on_all_pages_writeback(sbi);
1139 1181
1140 /*
1141 * invalidate meta page which is used temporarily for zeroing out
1142 * block at the end of warm node chain.
1143 */
1144 if (invalidate)
1145 invalidate_mapping_pages(META_MAPPING(sbi), discard_blk,
1146 discard_blk);
1147
1148 release_ino_entry(sbi, false); 1182 release_ino_entry(sbi, false);
1149 1183
1150 if (unlikely(f2fs_cp_error(sbi))) 1184 if (unlikely(f2fs_cp_error(sbi)))
@@ -1152,6 +1186,17 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1152 1186
1153 clear_prefree_segments(sbi, cpc); 1187 clear_prefree_segments(sbi, cpc);
1154 clear_sbi_flag(sbi, SBI_IS_DIRTY); 1188 clear_sbi_flag(sbi, SBI_IS_DIRTY);
1189 clear_sbi_flag(sbi, SBI_NEED_CP);
1190
1191 /*
1192 * redirty superblock if metadata like node page or inode cache is
1193 * updated during writing checkpoint.
1194 */
1195 if (get_pages(sbi, F2FS_DIRTY_NODES) ||
1196 get_pages(sbi, F2FS_DIRTY_IMETA))
1197 set_sbi_flag(sbi, SBI_IS_DIRTY);
1198
1199 f2fs_bug_on(sbi, get_pages(sbi, F2FS_DIRTY_DENTS));
1155 1200
1156 return 0; 1201 return 0;
1157} 1202}
@@ -1190,6 +1235,18 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1190 1235
1191 f2fs_flush_merged_bios(sbi); 1236 f2fs_flush_merged_bios(sbi);
1192 1237
1238 /* this is the case of multiple fstrims without any changes */
1239 if (cpc->reason == CP_DISCARD && !is_sbi_flag_set(sbi, SBI_IS_DIRTY)) {
1240 f2fs_bug_on(sbi, NM_I(sbi)->dirty_nat_cnt);
1241 f2fs_bug_on(sbi, SIT_I(sbi)->dirty_sentries);
1242 f2fs_bug_on(sbi, prefree_segments(sbi));
1243 flush_sit_entries(sbi, cpc);
1244 clear_prefree_segments(sbi, cpc);
1245 f2fs_wait_all_discard_bio(sbi);
1246 unblock_operations(sbi);
1247 goto out;
1248 }
1249
1193 /* 1250 /*
1194 * update checkpoint pack index 1251 * update checkpoint pack index
1195 * Increase the version number so that 1252 * Increase the version number so that
@@ -1205,6 +1262,8 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
1205 /* unlock all the fs_lock[] in do_checkpoint() */ 1262 /* unlock all the fs_lock[] in do_checkpoint() */
1206 err = do_checkpoint(sbi, cpc); 1263 err = do_checkpoint(sbi, cpc);
1207 1264
1265 f2fs_wait_all_discard_bio(sbi);
1266
1208 unblock_operations(sbi); 1267 unblock_operations(sbi);
1209 stat_inc_cp_count(sbi->stat_info); 1268 stat_inc_cp_count(sbi->stat_info);
1210 1269
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index ccb401eebc11..0d0177c9149c 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -34,6 +34,11 @@ static void f2fs_read_end_io(struct bio *bio)
34 struct bio_vec *bvec; 34 struct bio_vec *bvec;
35 int i; 35 int i;
36 36
37#ifdef CONFIG_F2FS_FAULT_INJECTION
38 if (time_to_inject(F2FS_P_SB(bio->bi_io_vec->bv_page), FAULT_IO))
39 bio->bi_error = -EIO;
40#endif
41
37 if (f2fs_bio_encrypted(bio)) { 42 if (f2fs_bio_encrypted(bio)) {
38 if (bio->bi_error) { 43 if (bio->bi_error) {
39 fscrypt_release_ctx(bio->bi_private); 44 fscrypt_release_ctx(bio->bi_private);
@@ -626,11 +631,13 @@ ssize_t f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from)
626 ssize_t ret = 0; 631 ssize_t ret = 0;
627 632
628 map.m_lblk = F2FS_BLK_ALIGN(iocb->ki_pos); 633 map.m_lblk = F2FS_BLK_ALIGN(iocb->ki_pos);
629 map.m_len = F2FS_BYTES_TO_BLK(iov_iter_count(from)); 634 map.m_len = F2FS_BYTES_TO_BLK(iocb->ki_pos + iov_iter_count(from));
630 map.m_next_pgofs = NULL; 635 if (map.m_len > map.m_lblk)
636 map.m_len -= map.m_lblk;
637 else
638 map.m_len = 0;
631 639
632 if (f2fs_encrypted_inode(inode)) 640 map.m_next_pgofs = NULL;
633 return 0;
634 641
635 if (iocb->ki_flags & IOCB_DIRECT) { 642 if (iocb->ki_flags & IOCB_DIRECT) {
636 ret = f2fs_convert_inline_inode(inode); 643 ret = f2fs_convert_inline_inode(inode);
@@ -672,6 +679,9 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
672 bool allocated = false; 679 bool allocated = false;
673 block_t blkaddr; 680 block_t blkaddr;
674 681
682 if (!maxblocks)
683 return 0;
684
675 map->m_len = 0; 685 map->m_len = 0;
676 map->m_flags = 0; 686 map->m_flags = 0;
677 687
@@ -783,6 +793,7 @@ skip:
783 err = reserve_new_blocks(&dn, prealloc); 793 err = reserve_new_blocks(&dn, prealloc);
784 if (err) 794 if (err)
785 goto sync_out; 795 goto sync_out;
796 allocated = dn.node_changed;
786 797
787 map->m_len += dn.ofs_in_node - ofs_in_node; 798 map->m_len += dn.ofs_in_node - ofs_in_node;
788 if (prealloc && dn.ofs_in_node != last_ofs_in_node + 1) { 799 if (prealloc && dn.ofs_in_node != last_ofs_in_node + 1) {
@@ -966,8 +977,8 @@ out:
966 return ret; 977 return ret;
967} 978}
968 979
969struct bio *f2fs_grab_bio(struct inode *inode, block_t blkaddr, 980static struct bio *f2fs_grab_bio(struct inode *inode, block_t blkaddr,
970 unsigned nr_pages) 981 unsigned nr_pages)
971{ 982{
972 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 983 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
973 struct fscrypt_ctx *ctx = NULL; 984 struct fscrypt_ctx *ctx = NULL;
@@ -1284,7 +1295,7 @@ write:
1284 1295
1285 if (!wbc->for_reclaim) 1296 if (!wbc->for_reclaim)
1286 need_balance_fs = true; 1297 need_balance_fs = true;
1287 else if (has_not_enough_free_secs(sbi, 0)) 1298 else if (has_not_enough_free_secs(sbi, 0, 0))
1288 goto redirty_out; 1299 goto redirty_out;
1289 1300
1290 err = -EAGAIN; 1301 err = -EAGAIN;
@@ -1344,6 +1355,7 @@ static int f2fs_write_cache_pages(struct address_space *mapping,
1344 int cycled; 1355 int cycled;
1345 int range_whole = 0; 1356 int range_whole = 0;
1346 int tag; 1357 int tag;
1358 int nwritten = 0;
1347 1359
1348 pagevec_init(&pvec, 0); 1360 pagevec_init(&pvec, 0);
1349 1361
@@ -1418,6 +1430,8 @@ continue_unlock:
1418 done_index = page->index + 1; 1430 done_index = page->index + 1;
1419 done = 1; 1431 done = 1;
1420 break; 1432 break;
1433 } else {
1434 nwritten++;
1421 } 1435 }
1422 1436
1423 if (--wbc->nr_to_write <= 0 && 1437 if (--wbc->nr_to_write <= 0 &&
@@ -1439,6 +1453,10 @@ continue_unlock:
1439 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0)) 1453 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1440 mapping->writeback_index = done_index; 1454 mapping->writeback_index = done_index;
1441 1455
1456 if (nwritten)
1457 f2fs_submit_merged_bio_cond(F2FS_M_SB(mapping), mapping->host,
1458 NULL, 0, DATA, WRITE);
1459
1442 return ret; 1460 return ret;
1443} 1461}
1444 1462
@@ -1480,7 +1498,6 @@ static int f2fs_write_data_pages(struct address_space *mapping,
1480 * if some pages were truncated, we cannot guarantee its mapping->host 1498 * if some pages were truncated, we cannot guarantee its mapping->host
1481 * to detect pending bios. 1499 * to detect pending bios.
1482 */ 1500 */
1483 f2fs_submit_merged_bio(sbi, DATA, WRITE);
1484 1501
1485 remove_dirty_inode(inode); 1502 remove_dirty_inode(inode);
1486 return ret; 1503 return ret;
@@ -1518,8 +1535,7 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
1518 * we already allocated all the blocks, so we don't need to get 1535 * we already allocated all the blocks, so we don't need to get
1519 * the block addresses when there is no need to fill the page. 1536 * the block addresses when there is no need to fill the page.
1520 */ 1537 */
1521 if (!f2fs_has_inline_data(inode) && !f2fs_encrypted_inode(inode) && 1538 if (!f2fs_has_inline_data(inode) && len == PAGE_SIZE)
1522 len == PAGE_SIZE)
1523 return 0; 1539 return 0;
1524 1540
1525 if (f2fs_has_inline_data(inode) || 1541 if (f2fs_has_inline_data(inode) ||
@@ -1616,7 +1632,7 @@ repeat:
1616 if (err) 1632 if (err)
1617 goto fail; 1633 goto fail;
1618 1634
1619 if (need_balance && has_not_enough_free_secs(sbi, 0)) { 1635 if (need_balance && has_not_enough_free_secs(sbi, 0, 0)) {
1620 unlock_page(page); 1636 unlock_page(page);
1621 f2fs_balance_fs(sbi, true); 1637 f2fs_balance_fs(sbi, true);
1622 lock_page(page); 1638 lock_page(page);
@@ -1633,22 +1649,12 @@ repeat:
1633 if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) 1649 if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
1634 f2fs_wait_on_encrypted_page_writeback(sbi, blkaddr); 1650 f2fs_wait_on_encrypted_page_writeback(sbi, blkaddr);
1635 1651
1636 if (len == PAGE_SIZE) 1652 if (len == PAGE_SIZE || PageUptodate(page))
1637 goto out_update; 1653 return 0;
1638 if (PageUptodate(page))
1639 goto out_clear;
1640
1641 if ((pos & PAGE_MASK) >= i_size_read(inode)) {
1642 unsigned start = pos & (PAGE_SIZE - 1);
1643 unsigned end = start + len;
1644
1645 /* Reading beyond i_size is simple: memset to zero */
1646 zero_user_segments(page, 0, start, end, PAGE_SIZE);
1647 goto out_update;
1648 }
1649 1654
1650 if (blkaddr == NEW_ADDR) { 1655 if (blkaddr == NEW_ADDR) {
1651 zero_user_segment(page, 0, PAGE_SIZE); 1656 zero_user_segment(page, 0, PAGE_SIZE);
1657 SetPageUptodate(page);
1652 } else { 1658 } else {
1653 struct bio *bio; 1659 struct bio *bio;
1654 1660
@@ -1676,11 +1682,6 @@ repeat:
1676 goto fail; 1682 goto fail;
1677 } 1683 }
1678 } 1684 }
1679out_update:
1680 if (!PageUptodate(page))
1681 SetPageUptodate(page);
1682out_clear:
1683 clear_cold_data(page);
1684 return 0; 1685 return 0;
1685 1686
1686fail: 1687fail:
@@ -1698,11 +1699,26 @@ static int f2fs_write_end(struct file *file,
1698 1699
1699 trace_f2fs_write_end(inode, pos, len, copied); 1700 trace_f2fs_write_end(inode, pos, len, copied);
1700 1701
1702 /*
1703 * This should be come from len == PAGE_SIZE, and we expect copied
1704 * should be PAGE_SIZE. Otherwise, we treat it with zero copied and
1705 * let generic_perform_write() try to copy data again through copied=0.
1706 */
1707 if (!PageUptodate(page)) {
1708 if (unlikely(copied != PAGE_SIZE))
1709 copied = 0;
1710 else
1711 SetPageUptodate(page);
1712 }
1713 if (!copied)
1714 goto unlock_out;
1715
1701 set_page_dirty(page); 1716 set_page_dirty(page);
1717 clear_cold_data(page);
1702 1718
1703 if (pos + copied > i_size_read(inode)) 1719 if (pos + copied > i_size_read(inode))
1704 f2fs_i_size_write(inode, pos + copied); 1720 f2fs_i_size_write(inode, pos + copied);
1705 1721unlock_out:
1706 f2fs_put_page(page, 1); 1722 f2fs_put_page(page, 1);
1707 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 1723 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1708 return copied; 1724 return copied;
@@ -1873,6 +1889,58 @@ static sector_t f2fs_bmap(struct address_space *mapping, sector_t block)
1873 return generic_block_bmap(mapping, block, get_data_block_bmap); 1889 return generic_block_bmap(mapping, block, get_data_block_bmap);
1874} 1890}
1875 1891
1892#ifdef CONFIG_MIGRATION
1893#include <linux/migrate.h>
1894
1895int f2fs_migrate_page(struct address_space *mapping,
1896 struct page *newpage, struct page *page, enum migrate_mode mode)
1897{
1898 int rc, extra_count;
1899 struct f2fs_inode_info *fi = F2FS_I(mapping->host);
1900 bool atomic_written = IS_ATOMIC_WRITTEN_PAGE(page);
1901
1902 BUG_ON(PageWriteback(page));
1903
1904 /* migrating an atomic written page is safe with the inmem_lock hold */
1905 if (atomic_written && !mutex_trylock(&fi->inmem_lock))
1906 return -EAGAIN;
1907
1908 /*
1909 * A reference is expected if PagePrivate set when move mapping,
1910 * however F2FS breaks this for maintaining dirty page counts when
1911 * truncating pages. So here adjusting the 'extra_count' make it work.
1912 */
1913 extra_count = (atomic_written ? 1 : 0) - page_has_private(page);
1914 rc = migrate_page_move_mapping(mapping, newpage,
1915 page, NULL, mode, extra_count);
1916 if (rc != MIGRATEPAGE_SUCCESS) {
1917 if (atomic_written)
1918 mutex_unlock(&fi->inmem_lock);
1919 return rc;
1920 }
1921
1922 if (atomic_written) {
1923 struct inmem_pages *cur;
1924 list_for_each_entry(cur, &fi->inmem_pages, list)
1925 if (cur->page == page) {
1926 cur->page = newpage;
1927 break;
1928 }
1929 mutex_unlock(&fi->inmem_lock);
1930 put_page(page);
1931 get_page(newpage);
1932 }
1933
1934 if (PagePrivate(page))
1935 SetPagePrivate(newpage);
1936 set_page_private(newpage, page_private(page));
1937
1938 migrate_page_copy(newpage, page);
1939
1940 return MIGRATEPAGE_SUCCESS;
1941}
1942#endif
1943
1876const struct address_space_operations f2fs_dblock_aops = { 1944const struct address_space_operations f2fs_dblock_aops = {
1877 .readpage = f2fs_read_data_page, 1945 .readpage = f2fs_read_data_page,
1878 .readpages = f2fs_read_data_pages, 1946 .readpages = f2fs_read_data_pages,
@@ -1885,4 +1953,7 @@ const struct address_space_operations f2fs_dblock_aops = {
1885 .releasepage = f2fs_release_page, 1953 .releasepage = f2fs_release_page,
1886 .direct_IO = f2fs_direct_IO, 1954 .direct_IO = f2fs_direct_IO,
1887 .bmap = f2fs_bmap, 1955 .bmap = f2fs_bmap,
1956#ifdef CONFIG_MIGRATION
1957 .migratepage = f2fs_migrate_page,
1958#endif
1888}; 1959};
diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index badd407bb622..fb245bd302e4 100644
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -45,6 +45,7 @@ static void update_general_status(struct f2fs_sb_info *sbi)
45 si->ndirty_dent = get_pages(sbi, F2FS_DIRTY_DENTS); 45 si->ndirty_dent = get_pages(sbi, F2FS_DIRTY_DENTS);
46 si->ndirty_meta = get_pages(sbi, F2FS_DIRTY_META); 46 si->ndirty_meta = get_pages(sbi, F2FS_DIRTY_META);
47 si->ndirty_data = get_pages(sbi, F2FS_DIRTY_DATA); 47 si->ndirty_data = get_pages(sbi, F2FS_DIRTY_DATA);
48 si->ndirty_imeta = get_pages(sbi, F2FS_DIRTY_IMETA);
48 si->ndirty_dirs = sbi->ndirty_inode[DIR_INODE]; 49 si->ndirty_dirs = sbi->ndirty_inode[DIR_INODE];
49 si->ndirty_files = sbi->ndirty_inode[FILE_INODE]; 50 si->ndirty_files = sbi->ndirty_inode[FILE_INODE];
50 si->ndirty_all = sbi->ndirty_inode[DIRTY_META]; 51 si->ndirty_all = sbi->ndirty_inode[DIRTY_META];
@@ -54,6 +55,7 @@ static void update_general_status(struct f2fs_sb_info *sbi)
54 si->rsvd_segs = reserved_segments(sbi); 55 si->rsvd_segs = reserved_segments(sbi);
55 si->overp_segs = overprovision_segments(sbi); 56 si->overp_segs = overprovision_segments(sbi);
56 si->valid_count = valid_user_blocks(sbi); 57 si->valid_count = valid_user_blocks(sbi);
58 si->discard_blks = discard_blocks(sbi);
57 si->valid_node_count = valid_node_count(sbi); 59 si->valid_node_count = valid_node_count(sbi);
58 si->valid_inode_count = valid_inode_count(sbi); 60 si->valid_inode_count = valid_inode_count(sbi);
59 si->inline_xattr = atomic_read(&sbi->inline_xattr); 61 si->inline_xattr = atomic_read(&sbi->inline_xattr);
@@ -154,7 +156,9 @@ static void update_mem_info(struct f2fs_sb_info *sbi)
154 si->base_mem += sizeof(struct sit_info); 156 si->base_mem += sizeof(struct sit_info);
155 si->base_mem += MAIN_SEGS(sbi) * sizeof(struct seg_entry); 157 si->base_mem += MAIN_SEGS(sbi) * sizeof(struct seg_entry);
156 si->base_mem += f2fs_bitmap_size(MAIN_SEGS(sbi)); 158 si->base_mem += f2fs_bitmap_size(MAIN_SEGS(sbi));
157 si->base_mem += 3 * SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi); 159 si->base_mem += 2 * SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);
160 if (f2fs_discard_en(sbi))
161 si->base_mem += SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);
158 si->base_mem += SIT_VBLOCK_MAP_SIZE; 162 si->base_mem += SIT_VBLOCK_MAP_SIZE;
159 if (sbi->segs_per_sec > 1) 163 if (sbi->segs_per_sec > 1)
160 si->base_mem += MAIN_SECS(sbi) * sizeof(struct sec_entry); 164 si->base_mem += MAIN_SECS(sbi) * sizeof(struct sec_entry);
@@ -228,8 +232,13 @@ static int stat_show(struct seq_file *s, void *v)
228 si->ssa_area_segs, si->main_area_segs); 232 si->ssa_area_segs, si->main_area_segs);
229 seq_printf(s, "(OverProv:%d Resv:%d)]\n\n", 233 seq_printf(s, "(OverProv:%d Resv:%d)]\n\n",
230 si->overp_segs, si->rsvd_segs); 234 si->overp_segs, si->rsvd_segs);
231 seq_printf(s, "Utilization: %d%% (%d valid blocks)\n", 235 if (test_opt(si->sbi, DISCARD))
232 si->utilization, si->valid_count); 236 seq_printf(s, "Utilization: %u%% (%u valid blocks, %u discard blocks)\n",
237 si->utilization, si->valid_count, si->discard_blks);
238 else
239 seq_printf(s, "Utilization: %u%% (%u valid blocks)\n",
240 si->utilization, si->valid_count);
241
233 seq_printf(s, " - Node: %u (Inode: %u, ", 242 seq_printf(s, " - Node: %u (Inode: %u, ",
234 si->valid_node_count, si->valid_inode_count); 243 si->valid_node_count, si->valid_inode_count);
235 seq_printf(s, "Other: %u)\n - Data: %u\n", 244 seq_printf(s, "Other: %u)\n - Data: %u\n",
@@ -311,6 +320,8 @@ static int stat_show(struct seq_file *s, void *v)
311 si->ndirty_data, si->ndirty_files); 320 si->ndirty_data, si->ndirty_files);
312 seq_printf(s, " - meta: %4lld in %4d\n", 321 seq_printf(s, " - meta: %4lld in %4d\n",
313 si->ndirty_meta, si->meta_pages); 322 si->ndirty_meta, si->meta_pages);
323 seq_printf(s, " - imeta: %4lld\n",
324 si->ndirty_imeta);
314 seq_printf(s, " - NATs: %9d/%9d\n - SITs: %9d/%9d\n", 325 seq_printf(s, " - NATs: %9d/%9d\n - SITs: %9d/%9d\n",
315 si->dirty_nats, si->nats, si->dirty_sits, si->sits); 326 si->dirty_nats, si->nats, si->dirty_sits, si->sits);
316 seq_printf(s, " - free_nids: %9d\n", 327 seq_printf(s, " - free_nids: %9d\n",
diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index 9054aeac8015..cbf85f65ba63 100644
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -37,7 +37,7 @@ static unsigned int bucket_blocks(unsigned int level)
37 return 4; 37 return 4;
38} 38}
39 39
40unsigned char f2fs_filetype_table[F2FS_FT_MAX] = { 40static unsigned char f2fs_filetype_table[F2FS_FT_MAX] = {
41 [F2FS_FT_UNKNOWN] = DT_UNKNOWN, 41 [F2FS_FT_UNKNOWN] = DT_UNKNOWN,
42 [F2FS_FT_REG_FILE] = DT_REG, 42 [F2FS_FT_REG_FILE] = DT_REG,
43 [F2FS_FT_DIR] = DT_DIR, 43 [F2FS_FT_DIR] = DT_DIR,
@@ -172,7 +172,10 @@ static struct f2fs_dir_entry *find_in_level(struct inode *dir,
172 int max_slots; 172 int max_slots;
173 f2fs_hash_t namehash; 173 f2fs_hash_t namehash;
174 174
175 namehash = f2fs_dentry_hash(&name); 175 if(fname->hash)
176 namehash = cpu_to_le32(fname->hash);
177 else
178 namehash = f2fs_dentry_hash(&name);
176 179
177 nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level); 180 nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
178 nblock = bucket_blocks(level); 181 nblock = bucket_blocks(level);
@@ -212,31 +215,17 @@ static struct f2fs_dir_entry *find_in_level(struct inode *dir,
212 return de; 215 return de;
213} 216}
214 217
215/* 218struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir,
216 * Find an entry in the specified directory with the wanted name. 219 struct fscrypt_name *fname, struct page **res_page)
217 * It returns the page where the entry was found (as a parameter - res_page),
218 * and the entry itself. Page is returned mapped and unlocked.
219 * Entry is guaranteed to be valid.
220 */
221struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
222 const struct qstr *child, struct page **res_page)
223{ 220{
224 unsigned long npages = dir_blocks(dir); 221 unsigned long npages = dir_blocks(dir);
225 struct f2fs_dir_entry *de = NULL; 222 struct f2fs_dir_entry *de = NULL;
226 unsigned int max_depth; 223 unsigned int max_depth;
227 unsigned int level; 224 unsigned int level;
228 struct fscrypt_name fname;
229 int err;
230
231 err = fscrypt_setup_filename(dir, child, 1, &fname);
232 if (err) {
233 *res_page = ERR_PTR(err);
234 return NULL;
235 }
236 225
237 if (f2fs_has_inline_dentry(dir)) { 226 if (f2fs_has_inline_dentry(dir)) {
238 *res_page = NULL; 227 *res_page = NULL;
239 de = find_in_inline_dir(dir, &fname, res_page); 228 de = find_in_inline_dir(dir, fname, res_page);
240 goto out; 229 goto out;
241 } 230 }
242 231
@@ -256,11 +245,35 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
256 245
257 for (level = 0; level < max_depth; level++) { 246 for (level = 0; level < max_depth; level++) {
258 *res_page = NULL; 247 *res_page = NULL;
259 de = find_in_level(dir, level, &fname, res_page); 248 de = find_in_level(dir, level, fname, res_page);
260 if (de || IS_ERR(*res_page)) 249 if (de || IS_ERR(*res_page))
261 break; 250 break;
262 } 251 }
263out: 252out:
253 return de;
254}
255
256/*
257 * Find an entry in the specified directory with the wanted name.
258 * It returns the page where the entry was found (as a parameter - res_page),
259 * and the entry itself. Page is returned mapped and unlocked.
260 * Entry is guaranteed to be valid.
261 */
262struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
263 const struct qstr *child, struct page **res_page)
264{
265 struct f2fs_dir_entry *de = NULL;
266 struct fscrypt_name fname;
267 int err;
268
269 err = fscrypt_setup_filename(dir, child, 1, &fname);
270 if (err) {
271 *res_page = ERR_PTR(err);
272 return NULL;
273 }
274
275 de = __f2fs_find_entry(dir, &fname, res_page);
276
264 fscrypt_free_filename(&fname); 277 fscrypt_free_filename(&fname);
265 return de; 278 return de;
266} 279}
@@ -375,7 +388,8 @@ static int make_empty_dir(struct inode *inode,
375} 388}
376 389
377struct page *init_inode_metadata(struct inode *inode, struct inode *dir, 390struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
378 const struct qstr *name, struct page *dpage) 391 const struct qstr *new_name, const struct qstr *orig_name,
392 struct page *dpage)
379{ 393{
380 struct page *page; 394 struct page *page;
381 int err; 395 int err;
@@ -400,7 +414,7 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
400 if (err) 414 if (err)
401 goto put_error; 415 goto put_error;
402 416
403 err = f2fs_init_security(inode, dir, name, page); 417 err = f2fs_init_security(inode, dir, orig_name, page);
404 if (err) 418 if (err)
405 goto put_error; 419 goto put_error;
406 420
@@ -417,8 +431,8 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
417 set_cold_node(inode, page); 431 set_cold_node(inode, page);
418 } 432 }
419 433
420 if (name) 434 if (new_name)
421 init_dent_inode(name, page); 435 init_dent_inode(new_name, page);
422 436
423 /* 437 /*
424 * This file should be checkpointed during fsync. 438 * This file should be checkpointed during fsync.
@@ -496,7 +510,7 @@ void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
496 de->ino = cpu_to_le32(ino); 510 de->ino = cpu_to_le32(ino);
497 set_de_type(de, mode); 511 set_de_type(de, mode);
498 for (i = 0; i < slots; i++) { 512 for (i = 0; i < slots; i++) {
499 test_and_set_bit_le(bit_pos + i, (void *)d->bitmap); 513 __set_bit_le(bit_pos + i, (void *)d->bitmap);
500 /* avoid wrong garbage data for readdir */ 514 /* avoid wrong garbage data for readdir */
501 if (i) 515 if (i)
502 (de + i)->name_len = 0; 516 (de + i)->name_len = 0;
@@ -504,6 +518,7 @@ void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
504} 518}
505 519
506int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name, 520int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name,
521 const struct qstr *orig_name,
507 struct inode *inode, nid_t ino, umode_t mode) 522 struct inode *inode, nid_t ino, umode_t mode)
508{ 523{
509 unsigned int bit_pos; 524 unsigned int bit_pos;
@@ -530,7 +545,7 @@ int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name,
530 545
531start: 546start:
532#ifdef CONFIG_F2FS_FAULT_INJECTION 547#ifdef CONFIG_F2FS_FAULT_INJECTION
533 if (time_to_inject(FAULT_DIR_DEPTH)) 548 if (time_to_inject(F2FS_I_SB(dir), FAULT_DIR_DEPTH))
534 return -ENOSPC; 549 return -ENOSPC;
535#endif 550#endif
536 if (unlikely(current_depth == MAX_DIR_HASH_DEPTH)) 551 if (unlikely(current_depth == MAX_DIR_HASH_DEPTH))
@@ -569,7 +584,8 @@ add_dentry:
569 584
570 if (inode) { 585 if (inode) {
571 down_write(&F2FS_I(inode)->i_sem); 586 down_write(&F2FS_I(inode)->i_sem);
572 page = init_inode_metadata(inode, dir, new_name, NULL); 587 page = init_inode_metadata(inode, dir, new_name,
588 orig_name, NULL);
573 if (IS_ERR(page)) { 589 if (IS_ERR(page)) {
574 err = PTR_ERR(page); 590 err = PTR_ERR(page);
575 goto fail; 591 goto fail;
@@ -599,6 +615,26 @@ fail:
599 return err; 615 return err;
600} 616}
601 617
618int __f2fs_do_add_link(struct inode *dir, struct fscrypt_name *fname,
619 struct inode *inode, nid_t ino, umode_t mode)
620{
621 struct qstr new_name;
622 int err = -EAGAIN;
623
624 new_name.name = fname_name(fname);
625 new_name.len = fname_len(fname);
626
627 if (f2fs_has_inline_dentry(dir))
628 err = f2fs_add_inline_entry(dir, &new_name, fname->usr_fname,
629 inode, ino, mode);
630 if (err == -EAGAIN)
631 err = f2fs_add_regular_entry(dir, &new_name, fname->usr_fname,
632 inode, ino, mode);
633
634 f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
635 return err;
636}
637
602/* 638/*
603 * Caller should grab and release a rwsem by calling f2fs_lock_op() and 639 * Caller should grab and release a rwsem by calling f2fs_lock_op() and
604 * f2fs_unlock_op(). 640 * f2fs_unlock_op().
@@ -607,24 +643,15 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name,
607 struct inode *inode, nid_t ino, umode_t mode) 643 struct inode *inode, nid_t ino, umode_t mode)
608{ 644{
609 struct fscrypt_name fname; 645 struct fscrypt_name fname;
610 struct qstr new_name;
611 int err; 646 int err;
612 647
613 err = fscrypt_setup_filename(dir, name, 0, &fname); 648 err = fscrypt_setup_filename(dir, name, 0, &fname);
614 if (err) 649 if (err)
615 return err; 650 return err;
616 651
617 new_name.name = fname_name(&fname); 652 err = __f2fs_do_add_link(dir, &fname, inode, ino, mode);
618 new_name.len = fname_len(&fname);
619
620 err = -EAGAIN;
621 if (f2fs_has_inline_dentry(dir))
622 err = f2fs_add_inline_entry(dir, &new_name, inode, ino, mode);
623 if (err == -EAGAIN)
624 err = f2fs_add_regular_entry(dir, &new_name, inode, ino, mode);
625 653
626 fscrypt_free_filename(&fname); 654 fscrypt_free_filename(&fname);
627 f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
628 return err; 655 return err;
629} 656}
630 657
@@ -634,7 +661,7 @@ int f2fs_do_tmpfile(struct inode *inode, struct inode *dir)
634 int err = 0; 661 int err = 0;
635 662
636 down_write(&F2FS_I(inode)->i_sem); 663 down_write(&F2FS_I(inode)->i_sem);
637 page = init_inode_metadata(inode, dir, NULL, NULL); 664 page = init_inode_metadata(inode, dir, NULL, NULL, NULL);
638 if (IS_ERR(page)) { 665 if (IS_ERR(page)) {
639 err = PTR_ERR(page); 666 err = PTR_ERR(page);
640 goto fail; 667 goto fail;
@@ -788,16 +815,9 @@ bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
788 int save_len = fstr->len; 815 int save_len = fstr->len;
789 int ret; 816 int ret;
790 817
791 de_name.name = f2fs_kmalloc(de_name.len, GFP_NOFS);
792 if (!de_name.name)
793 return false;
794
795 memcpy(de_name.name, d->filename[bit_pos], de_name.len);
796
797 ret = fscrypt_fname_disk_to_usr(d->inode, 818 ret = fscrypt_fname_disk_to_usr(d->inode,
798 (u32)de->hash_code, 0, 819 (u32)de->hash_code, 0,
799 &de_name, fstr); 820 &de_name, fstr);
800 kfree(de_name.name);
801 if (ret < 0) 821 if (ret < 0)
802 return true; 822 return true;
803 823
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 14f5fe2b841e..9e8de18a168a 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -46,6 +46,8 @@ enum {
46 FAULT_BLOCK, 46 FAULT_BLOCK,
47 FAULT_DIR_DEPTH, 47 FAULT_DIR_DEPTH,
48 FAULT_EVICT_INODE, 48 FAULT_EVICT_INODE,
49 FAULT_IO,
50 FAULT_CHECKPOINT,
49 FAULT_MAX, 51 FAULT_MAX,
50}; 52};
51 53
@@ -55,40 +57,8 @@ struct f2fs_fault_info {
55 unsigned int inject_type; 57 unsigned int inject_type;
56}; 58};
57 59
58extern struct f2fs_fault_info f2fs_fault;
59extern char *fault_name[FAULT_MAX]; 60extern char *fault_name[FAULT_MAX];
60#define IS_FAULT_SET(type) (f2fs_fault.inject_type & (1 << (type))) 61#define IS_FAULT_SET(fi, type) (fi->inject_type & (1 << (type)))
61
62static inline bool time_to_inject(int type)
63{
64 if (!f2fs_fault.inject_rate)
65 return false;
66 if (type == FAULT_KMALLOC && !IS_FAULT_SET(type))
67 return false;
68 else if (type == FAULT_PAGE_ALLOC && !IS_FAULT_SET(type))
69 return false;
70 else if (type == FAULT_ALLOC_NID && !IS_FAULT_SET(type))
71 return false;
72 else if (type == FAULT_ORPHAN && !IS_FAULT_SET(type))
73 return false;
74 else if (type == FAULT_BLOCK && !IS_FAULT_SET(type))
75 return false;
76 else if (type == FAULT_DIR_DEPTH && !IS_FAULT_SET(type))
77 return false;
78 else if (type == FAULT_EVICT_INODE && !IS_FAULT_SET(type))
79 return false;
80
81 atomic_inc(&f2fs_fault.inject_ops);
82 if (atomic_read(&f2fs_fault.inject_ops) >= f2fs_fault.inject_rate) {
83 atomic_set(&f2fs_fault.inject_ops, 0);
84 printk("%sF2FS-fs : inject %s in %pF\n",
85 KERN_INFO,
86 fault_name[type],
87 __builtin_return_address(0));
88 return true;
89 }
90 return false;
91}
92#endif 62#endif
93 63
94/* 64/*
@@ -158,7 +128,7 @@ enum {
158 CP_DISCARD, 128 CP_DISCARD,
159}; 129};
160 130
161#define DEF_BATCHED_TRIM_SECTIONS 32 131#define DEF_BATCHED_TRIM_SECTIONS 2
162#define BATCHED_TRIM_SEGMENTS(sbi) \ 132#define BATCHED_TRIM_SEGMENTS(sbi) \
163 (SM_I(sbi)->trim_sections * (sbi)->segs_per_sec) 133 (SM_I(sbi)->trim_sections * (sbi)->segs_per_sec)
164#define BATCHED_TRIM_BLOCKS(sbi) \ 134#define BATCHED_TRIM_BLOCKS(sbi) \
@@ -211,6 +181,13 @@ struct discard_entry {
211 int len; /* # of consecutive blocks of the discard */ 181 int len; /* # of consecutive blocks of the discard */
212}; 182};
213 183
184struct bio_entry {
185 struct list_head list;
186 struct bio *bio;
187 struct completion event;
188 int error;
189};
190
214/* for the list of fsync inodes, used only during recovery */ 191/* for the list of fsync inodes, used only during recovery */
215struct fsync_inode_entry { 192struct fsync_inode_entry {
216 struct list_head list; /* list head */ 193 struct list_head list; /* list head */
@@ -645,6 +622,7 @@ struct f2fs_sm_info {
645 622
646 /* for small discard management */ 623 /* for small discard management */
647 struct list_head discard_list; /* 4KB discard list */ 624 struct list_head discard_list; /* 4KB discard list */
625 struct list_head wait_list; /* linked with issued discard bio */
648 int nr_discards; /* # of discards in the list */ 626 int nr_discards; /* # of discards in the list */
649 int max_discards; /* max. discards to be issued */ 627 int max_discards; /* max. discards to be issued */
650 628
@@ -748,6 +726,7 @@ enum {
748 SBI_NEED_FSCK, /* need fsck.f2fs to fix */ 726 SBI_NEED_FSCK, /* need fsck.f2fs to fix */
749 SBI_POR_DOING, /* recovery is doing or not */ 727 SBI_POR_DOING, /* recovery is doing or not */
750 SBI_NEED_SB_WRITE, /* need to recover superblock */ 728 SBI_NEED_SB_WRITE, /* need to recover superblock */
729 SBI_NEED_CP, /* need to checkpoint */
751}; 730};
752 731
753enum { 732enum {
@@ -765,7 +744,7 @@ struct f2fs_sb_info {
765 struct proc_dir_entry *s_proc; /* proc entry */ 744 struct proc_dir_entry *s_proc; /* proc entry */
766 struct f2fs_super_block *raw_super; /* raw super block pointer */ 745 struct f2fs_super_block *raw_super; /* raw super block pointer */
767 int valid_super_block; /* valid super block no */ 746 int valid_super_block; /* valid super block no */
768 int s_flag; /* flags for sbi */ 747 unsigned long s_flag; /* flags for sbi */
769 748
770#ifdef CONFIG_F2FS_FS_ENCRYPTION 749#ifdef CONFIG_F2FS_FS_ENCRYPTION
771 u8 key_prefix[F2FS_KEY_DESC_PREFIX_SIZE]; 750 u8 key_prefix[F2FS_KEY_DESC_PREFIX_SIZE];
@@ -785,6 +764,7 @@ struct f2fs_sb_info {
785 764
786 /* for checkpoint */ 765 /* for checkpoint */
787 struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */ 766 struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */
767 spinlock_t cp_lock; /* for flag in ckpt */
788 struct inode *meta_inode; /* cache meta blocks */ 768 struct inode *meta_inode; /* cache meta blocks */
789 struct mutex cp_mutex; /* checkpoint procedure lock */ 769 struct mutex cp_mutex; /* checkpoint procedure lock */
790 struct rw_semaphore cp_rwsem; /* blocking FS operations */ 770 struct rw_semaphore cp_rwsem; /* blocking FS operations */
@@ -892,8 +872,37 @@ struct f2fs_sb_info {
892 872
893 /* Reference to checksum algorithm driver via cryptoapi */ 873 /* Reference to checksum algorithm driver via cryptoapi */
894 struct crypto_shash *s_chksum_driver; 874 struct crypto_shash *s_chksum_driver;
875
876 /* For fault injection */
877#ifdef CONFIG_F2FS_FAULT_INJECTION
878 struct f2fs_fault_info fault_info;
879#endif
895}; 880};
896 881
882#ifdef CONFIG_F2FS_FAULT_INJECTION
883static inline bool time_to_inject(struct f2fs_sb_info *sbi, int type)
884{
885 struct f2fs_fault_info *ffi = &sbi->fault_info;
886
887 if (!ffi->inject_rate)
888 return false;
889
890 if (!IS_FAULT_SET(ffi, type))
891 return false;
892
893 atomic_inc(&ffi->inject_ops);
894 if (atomic_read(&ffi->inject_ops) >= ffi->inject_rate) {
895 atomic_set(&ffi->inject_ops, 0);
896 printk("%sF2FS-fs : inject %s in %pF\n",
897 KERN_INFO,
898 fault_name[type],
899 __builtin_return_address(0));
900 return true;
901 }
902 return false;
903}
904#endif
905
897/* For write statistics. Suppose sector size is 512 bytes, 906/* For write statistics. Suppose sector size is 512 bytes,
898 * and the return value is in kbytes. s is of struct f2fs_sb_info. 907 * and the return value is in kbytes. s is of struct f2fs_sb_info.
899 */ 908 */
@@ -1034,17 +1043,17 @@ static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)
1034 1043
1035static inline bool is_sbi_flag_set(struct f2fs_sb_info *sbi, unsigned int type) 1044static inline bool is_sbi_flag_set(struct f2fs_sb_info *sbi, unsigned int type)
1036{ 1045{
1037 return sbi->s_flag & (0x01 << type); 1046 return test_bit(type, &sbi->s_flag);
1038} 1047}
1039 1048
1040static inline void set_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type) 1049static inline void set_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
1041{ 1050{
1042 sbi->s_flag |= (0x01 << type); 1051 set_bit(type, &sbi->s_flag);
1043} 1052}
1044 1053
1045static inline void clear_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type) 1054static inline void clear_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
1046{ 1055{
1047 sbi->s_flag &= ~(0x01 << type); 1056 clear_bit(type, &sbi->s_flag);
1048} 1057}
1049 1058
1050static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp) 1059static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
@@ -1052,26 +1061,57 @@ static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
1052 return le64_to_cpu(cp->checkpoint_ver); 1061 return le64_to_cpu(cp->checkpoint_ver);
1053} 1062}
1054 1063
1055static inline bool is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f) 1064static inline bool __is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
1056{ 1065{
1057 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags); 1066 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
1067
1058 return ckpt_flags & f; 1068 return ckpt_flags & f;
1059} 1069}
1060 1070
1061static inline void set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f) 1071static inline bool is_set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
1062{ 1072{
1063 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags); 1073 return __is_set_ckpt_flags(F2FS_CKPT(sbi), f);
1074}
1075
1076static inline void __set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
1077{
1078 unsigned int ckpt_flags;
1079
1080 ckpt_flags = le32_to_cpu(cp->ckpt_flags);
1064 ckpt_flags |= f; 1081 ckpt_flags |= f;
1065 cp->ckpt_flags = cpu_to_le32(ckpt_flags); 1082 cp->ckpt_flags = cpu_to_le32(ckpt_flags);
1066} 1083}
1067 1084
1068static inline void clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f) 1085static inline void set_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
1069{ 1086{
1070 unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags); 1087 spin_lock(&sbi->cp_lock);
1088 __set_ckpt_flags(F2FS_CKPT(sbi), f);
1089 spin_unlock(&sbi->cp_lock);
1090}
1091
1092static inline void __clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
1093{
1094 unsigned int ckpt_flags;
1095
1096 ckpt_flags = le32_to_cpu(cp->ckpt_flags);
1071 ckpt_flags &= (~f); 1097 ckpt_flags &= (~f);
1072 cp->ckpt_flags = cpu_to_le32(ckpt_flags); 1098 cp->ckpt_flags = cpu_to_le32(ckpt_flags);
1073} 1099}
1074 1100
1101static inline void clear_ckpt_flags(struct f2fs_sb_info *sbi, unsigned int f)
1102{
1103 spin_lock(&sbi->cp_lock);
1104 __clear_ckpt_flags(F2FS_CKPT(sbi), f);
1105 spin_unlock(&sbi->cp_lock);
1106}
1107
1108static inline bool f2fs_discard_en(struct f2fs_sb_info *sbi)
1109{
1110 struct request_queue *q = bdev_get_queue(sbi->sb->s_bdev);
1111
1112 return blk_queue_discard(q);
1113}
1114
1075static inline void f2fs_lock_op(struct f2fs_sb_info *sbi) 1115static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
1076{ 1116{
1077 down_read(&sbi->cp_rwsem); 1117 down_read(&sbi->cp_rwsem);
@@ -1110,8 +1150,8 @@ static inline bool __remain_node_summaries(int reason)
1110 1150
1111static inline bool __exist_node_summaries(struct f2fs_sb_info *sbi) 1151static inline bool __exist_node_summaries(struct f2fs_sb_info *sbi)
1112{ 1152{
1113 return (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG) || 1153 return (is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG) ||
1114 is_set_ckpt_flags(F2FS_CKPT(sbi), CP_FASTBOOT_FLAG)); 1154 is_set_ckpt_flags(sbi, CP_FASTBOOT_FLAG));
1115} 1155}
1116 1156
1117/* 1157/*
@@ -1151,7 +1191,7 @@ static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi,
1151 blkcnt_t diff; 1191 blkcnt_t diff;
1152 1192
1153#ifdef CONFIG_F2FS_FAULT_INJECTION 1193#ifdef CONFIG_F2FS_FAULT_INJECTION
1154 if (time_to_inject(FAULT_BLOCK)) 1194 if (time_to_inject(sbi, FAULT_BLOCK))
1155 return false; 1195 return false;
1156#endif 1196#endif
1157 /* 1197 /*
@@ -1193,6 +1233,10 @@ static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
1193static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type) 1233static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
1194{ 1234{
1195 percpu_counter_inc(&sbi->nr_pages[count_type]); 1235 percpu_counter_inc(&sbi->nr_pages[count_type]);
1236
1237 if (count_type == F2FS_DIRTY_DATA || count_type == F2FS_INMEM_PAGES)
1238 return;
1239
1196 set_sbi_flag(sbi, SBI_IS_DIRTY); 1240 set_sbi_flag(sbi, SBI_IS_DIRTY);
1197} 1241}
1198 1242
@@ -1243,6 +1287,11 @@ static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
1243 return sbi->total_valid_block_count; 1287 return sbi->total_valid_block_count;
1244} 1288}
1245 1289
1290static inline block_t discard_blocks(struct f2fs_sb_info *sbi)
1291{
1292 return sbi->discard_blks;
1293}
1294
1246static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag) 1295static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)
1247{ 1296{
1248 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi); 1297 struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
@@ -1376,7 +1425,7 @@ static inline struct page *f2fs_grab_cache_page(struct address_space *mapping,
1376 if (page) 1425 if (page)
1377 return page; 1426 return page;
1378 1427
1379 if (time_to_inject(FAULT_PAGE_ALLOC)) 1428 if (time_to_inject(F2FS_M_SB(mapping), FAULT_PAGE_ALLOC))
1380 return NULL; 1429 return NULL;
1381#endif 1430#endif
1382 if (!for_write) 1431 if (!for_write)
@@ -1804,7 +1853,7 @@ static inline int f2fs_readonly(struct super_block *sb)
1804 1853
1805static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi) 1854static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)
1806{ 1855{
1807 return is_set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG); 1856 return is_set_ckpt_flags(sbi, CP_ERROR_FLAG);
1808} 1857}
1809 1858
1810static inline bool is_dot_dotdot(const struct qstr *str) 1859static inline bool is_dot_dotdot(const struct qstr *str)
@@ -1827,10 +1876,11 @@ static inline bool f2fs_may_extent_tree(struct inode *inode)
1827 return S_ISREG(inode->i_mode); 1876 return S_ISREG(inode->i_mode);
1828} 1877}
1829 1878
1830static inline void *f2fs_kmalloc(size_t size, gfp_t flags) 1879static inline void *f2fs_kmalloc(struct f2fs_sb_info *sbi,
1880 size_t size, gfp_t flags)
1831{ 1881{
1832#ifdef CONFIG_F2FS_FAULT_INJECTION 1882#ifdef CONFIG_F2FS_FAULT_INJECTION
1833 if (time_to_inject(FAULT_KMALLOC)) 1883 if (time_to_inject(sbi, FAULT_KMALLOC))
1834 return NULL; 1884 return NULL;
1835#endif 1885#endif
1836 return kmalloc(size, flags); 1886 return kmalloc(size, flags);
@@ -1885,6 +1935,7 @@ long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long);
1885 */ 1935 */
1886void f2fs_set_inode_flags(struct inode *); 1936void f2fs_set_inode_flags(struct inode *);
1887struct inode *f2fs_iget(struct super_block *, unsigned long); 1937struct inode *f2fs_iget(struct super_block *, unsigned long);
1938struct inode *f2fs_iget_retry(struct super_block *, unsigned long);
1888int try_to_free_nats(struct f2fs_sb_info *, int); 1939int try_to_free_nats(struct f2fs_sb_info *, int);
1889int update_inode(struct inode *, struct page *); 1940int update_inode(struct inode *, struct page *);
1890int update_inode_page(struct inode *); 1941int update_inode_page(struct inode *);
@@ -1900,7 +1951,6 @@ struct dentry *f2fs_get_parent(struct dentry *child);
1900/* 1951/*
1901 * dir.c 1952 * dir.c
1902 */ 1953 */
1903extern unsigned char f2fs_filetype_table[F2FS_FT_MAX];
1904void set_de_type(struct f2fs_dir_entry *, umode_t); 1954void set_de_type(struct f2fs_dir_entry *, umode_t);
1905unsigned char get_de_type(struct f2fs_dir_entry *); 1955unsigned char get_de_type(struct f2fs_dir_entry *);
1906struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *, 1956struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *,
@@ -1910,10 +1960,12 @@ bool f2fs_fill_dentries(struct dir_context *, struct f2fs_dentry_ptr *,
1910void do_make_empty_dir(struct inode *, struct inode *, 1960void do_make_empty_dir(struct inode *, struct inode *,
1911 struct f2fs_dentry_ptr *); 1961 struct f2fs_dentry_ptr *);
1912struct page *init_inode_metadata(struct inode *, struct inode *, 1962struct page *init_inode_metadata(struct inode *, struct inode *,
1913 const struct qstr *, struct page *); 1963 const struct qstr *, const struct qstr *, struct page *);
1914void update_parent_metadata(struct inode *, struct inode *, unsigned int); 1964void update_parent_metadata(struct inode *, struct inode *, unsigned int);
1915int room_for_filename(const void *, int, int); 1965int room_for_filename(const void *, int, int);
1916void f2fs_drop_nlink(struct inode *, struct inode *); 1966void f2fs_drop_nlink(struct inode *, struct inode *);
1967struct f2fs_dir_entry *__f2fs_find_entry(struct inode *, struct fscrypt_name *,
1968 struct page **);
1917struct f2fs_dir_entry *f2fs_find_entry(struct inode *, const struct qstr *, 1969struct f2fs_dir_entry *f2fs_find_entry(struct inode *, const struct qstr *,
1918 struct page **); 1970 struct page **);
1919struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **); 1971struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **);
@@ -1924,7 +1976,9 @@ int update_dent_inode(struct inode *, struct inode *, const struct qstr *);
1924void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *, 1976void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *,
1925 const struct qstr *, f2fs_hash_t , unsigned int); 1977 const struct qstr *, f2fs_hash_t , unsigned int);
1926int f2fs_add_regular_entry(struct inode *, const struct qstr *, 1978int f2fs_add_regular_entry(struct inode *, const struct qstr *,
1927 struct inode *, nid_t, umode_t); 1979 const struct qstr *, struct inode *, nid_t, umode_t);
1980int __f2fs_do_add_link(struct inode *, struct fscrypt_name*, struct inode *,
1981 nid_t, umode_t);
1928int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *, nid_t, 1982int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *, nid_t,
1929 umode_t); 1983 umode_t);
1930void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *, 1984void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *,
@@ -2010,9 +2064,9 @@ void destroy_flush_cmd_control(struct f2fs_sb_info *);
2010void invalidate_blocks(struct f2fs_sb_info *, block_t); 2064void invalidate_blocks(struct f2fs_sb_info *, block_t);
2011bool is_checkpointed_data(struct f2fs_sb_info *, block_t); 2065bool is_checkpointed_data(struct f2fs_sb_info *, block_t);
2012void refresh_sit_entry(struct f2fs_sb_info *, block_t, block_t); 2066void refresh_sit_entry(struct f2fs_sb_info *, block_t, block_t);
2067void f2fs_wait_all_discard_bio(struct f2fs_sb_info *);
2013void clear_prefree_segments(struct f2fs_sb_info *, struct cp_control *); 2068void clear_prefree_segments(struct f2fs_sb_info *, struct cp_control *);
2014void release_discard_addrs(struct f2fs_sb_info *); 2069void release_discard_addrs(struct f2fs_sb_info *);
2015bool discard_next_dnode(struct f2fs_sb_info *, block_t);
2016int npages_for_summary_flush(struct f2fs_sb_info *, bool); 2070int npages_for_summary_flush(struct f2fs_sb_info *, bool);
2017void allocate_new_segments(struct f2fs_sb_info *); 2071void allocate_new_segments(struct f2fs_sb_info *);
2018int f2fs_trim_fs(struct f2fs_sb_info *, struct fstrim_range *); 2072int f2fs_trim_fs(struct f2fs_sb_info *, struct fstrim_range *);
@@ -2095,6 +2149,10 @@ int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64);
2095void f2fs_set_page_dirty_nobuffers(struct page *); 2149void f2fs_set_page_dirty_nobuffers(struct page *);
2096void f2fs_invalidate_page(struct page *, unsigned int, unsigned int); 2150void f2fs_invalidate_page(struct page *, unsigned int, unsigned int);
2097int f2fs_release_page(struct page *, gfp_t); 2151int f2fs_release_page(struct page *, gfp_t);
2152#ifdef CONFIG_MIGRATION
2153int f2fs_migrate_page(struct address_space *, struct page *, struct page *,
2154 enum migrate_mode);
2155#endif
2098 2156
2099/* 2157/*
2100 * gc.c 2158 * gc.c
@@ -2123,13 +2181,14 @@ struct f2fs_stat_info {
2123 unsigned long long hit_largest, hit_cached, hit_rbtree; 2181 unsigned long long hit_largest, hit_cached, hit_rbtree;
2124 unsigned long long hit_total, total_ext; 2182 unsigned long long hit_total, total_ext;
2125 int ext_tree, zombie_tree, ext_node; 2183 int ext_tree, zombie_tree, ext_node;
2126 s64 ndirty_node, ndirty_dent, ndirty_meta, ndirty_data, inmem_pages; 2184 s64 ndirty_node, ndirty_dent, ndirty_meta, ndirty_data, ndirty_imeta;
2185 s64 inmem_pages;
2127 unsigned int ndirty_dirs, ndirty_files, ndirty_all; 2186 unsigned int ndirty_dirs, ndirty_files, ndirty_all;
2128 int nats, dirty_nats, sits, dirty_sits, fnids; 2187 int nats, dirty_nats, sits, dirty_sits, fnids;
2129 int total_count, utilization; 2188 int total_count, utilization;
2130 int bg_gc, wb_bios; 2189 int bg_gc, wb_bios;
2131 int inline_xattr, inline_inode, inline_dir, orphans; 2190 int inline_xattr, inline_inode, inline_dir, orphans;
2132 unsigned int valid_count, valid_node_count, valid_inode_count; 2191 unsigned int valid_count, valid_node_count, valid_inode_count, discard_blks;
2133 unsigned int bimodal, avg_vblocks; 2192 unsigned int bimodal, avg_vblocks;
2134 int util_free, util_valid, util_invalid; 2193 int util_free, util_valid, util_invalid;
2135 int rsvd_segs, overp_segs; 2194 int rsvd_segs, overp_segs;
@@ -2294,8 +2353,8 @@ bool recover_inline_data(struct inode *, struct page *);
2294struct f2fs_dir_entry *find_in_inline_dir(struct inode *, 2353struct f2fs_dir_entry *find_in_inline_dir(struct inode *,
2295 struct fscrypt_name *, struct page **); 2354 struct fscrypt_name *, struct page **);
2296int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *); 2355int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *);
2297int f2fs_add_inline_entry(struct inode *, const struct qstr *, struct inode *, 2356int f2fs_add_inline_entry(struct inode *, const struct qstr *,
2298 nid_t, umode_t); 2357 const struct qstr *, struct inode *, nid_t, umode_t);
2299void f2fs_delete_inline_entry(struct f2fs_dir_entry *, struct page *, 2358void f2fs_delete_inline_entry(struct f2fs_dir_entry *, struct page *,
2300 struct inode *, struct inode *); 2359 struct inode *, struct inode *);
2301bool f2fs_empty_inline_dir(struct inode *); 2360bool f2fs_empty_inline_dir(struct inode *);
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 28f4f4cbb8d8..f8b4fe05385d 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -135,7 +135,7 @@ static inline bool need_do_checkpoint(struct inode *inode)
135 135
136 if (!S_ISREG(inode->i_mode) || inode->i_nlink != 1) 136 if (!S_ISREG(inode->i_mode) || inode->i_nlink != 1)
137 need_cp = true; 137 need_cp = true;
138 else if (file_enc_name(inode) && need_dentry_mark(sbi, inode->i_ino)) 138 else if (is_sbi_flag_set(sbi, SBI_NEED_CP))
139 need_cp = true; 139 need_cp = true;
140 else if (file_wrong_pino(inode)) 140 else if (file_wrong_pino(inode))
141 need_cp = true; 141 need_cp = true;
@@ -523,7 +523,7 @@ static int truncate_partial_data_page(struct inode *inode, u64 from,
523 return 0; 523 return 0;
524 524
525 if (cache_only) { 525 if (cache_only) {
526 page = f2fs_grab_cache_page(mapping, index, false); 526 page = find_lock_page(mapping, index);
527 if (page && PageUptodate(page)) 527 if (page && PageUptodate(page))
528 goto truncate_out; 528 goto truncate_out;
529 f2fs_put_page(page, 1); 529 f2fs_put_page(page, 1);
@@ -1454,7 +1454,7 @@ static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
1454{ 1454{
1455 struct inode *inode = file_inode(filp); 1455 struct inode *inode = file_inode(filp);
1456 struct f2fs_inode_info *fi = F2FS_I(inode); 1456 struct f2fs_inode_info *fi = F2FS_I(inode);
1457 unsigned int flags = fi->i_flags & FS_FL_USER_VISIBLE; 1457 unsigned int flags;
1458 unsigned int oldflags; 1458 unsigned int oldflags;
1459 int ret; 1459 int ret;
1460 1460
@@ -1954,7 +1954,7 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi,
1954 * avoid defragment running in SSR mode when free section are allocated 1954 * avoid defragment running in SSR mode when free section are allocated
1955 * intensively 1955 * intensively
1956 */ 1956 */
1957 if (has_not_enough_free_secs(sbi, sec_num)) { 1957 if (has_not_enough_free_secs(sbi, 0, sec_num)) {
1958 err = -EAGAIN; 1958 err = -EAGAIN;
1959 goto out; 1959 goto out;
1960 } 1960 }
@@ -2085,6 +2085,13 @@ static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
2085 if (f2fs_encrypted_inode(src) || f2fs_encrypted_inode(dst)) 2085 if (f2fs_encrypted_inode(src) || f2fs_encrypted_inode(dst))
2086 return -EOPNOTSUPP; 2086 return -EOPNOTSUPP;
2087 2087
2088 if (src == dst) {
2089 if (pos_in == pos_out)
2090 return 0;
2091 if (pos_out > pos_in && pos_out < pos_in + len)
2092 return -EINVAL;
2093 }
2094
2088 inode_lock(src); 2095 inode_lock(src);
2089 if (src != dst) { 2096 if (src != dst) {
2090 if (!inode_trylock(dst)) { 2097 if (!inode_trylock(dst)) {
@@ -2136,8 +2143,9 @@ static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
2136 2143
2137 f2fs_balance_fs(sbi, true); 2144 f2fs_balance_fs(sbi, true);
2138 f2fs_lock_op(sbi); 2145 f2fs_lock_op(sbi);
2139 ret = __exchange_data_block(src, dst, pos_in, 2146 ret = __exchange_data_block(src, dst, pos_in >> F2FS_BLKSIZE_BITS,
2140 pos_out, len >> F2FS_BLKSIZE_BITS, false); 2147 pos_out >> F2FS_BLKSIZE_BITS,
2148 len >> F2FS_BLKSIZE_BITS, false);
2141 2149
2142 if (!ret) { 2150 if (!ret) {
2143 if (dst_max_i_size) 2151 if (dst_max_i_size)
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index 8f7fa326ce95..93985c64d8a8 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -47,6 +47,11 @@ static int gc_thread_func(void *data)
47 continue; 47 continue;
48 } 48 }
49 49
50#ifdef CONFIG_F2FS_FAULT_INJECTION
51 if (time_to_inject(sbi, FAULT_CHECKPOINT))
52 f2fs_stop_checkpoint(sbi, false);
53#endif
54
50 /* 55 /*
51 * [GC triggering condition] 56 * [GC triggering condition]
52 * 0. GC is not conducted currently. 57 * 0. GC is not conducted currently.
@@ -96,7 +101,7 @@ int start_gc_thread(struct f2fs_sb_info *sbi)
96 dev_t dev = sbi->sb->s_bdev->bd_dev; 101 dev_t dev = sbi->sb->s_bdev->bd_dev;
97 int err = 0; 102 int err = 0;
98 103
99 gc_th = f2fs_kmalloc(sizeof(struct f2fs_gc_kthread), GFP_KERNEL); 104 gc_th = f2fs_kmalloc(sbi, sizeof(struct f2fs_gc_kthread), GFP_KERNEL);
100 if (!gc_th) { 105 if (!gc_th) {
101 err = -ENOMEM; 106 err = -ENOMEM;
102 goto out; 107 goto out;
@@ -270,7 +275,7 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi,
270{ 275{
271 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); 276 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
272 struct victim_sel_policy p; 277 struct victim_sel_policy p;
273 unsigned int secno, max_cost, last_victim; 278 unsigned int secno, last_victim;
274 unsigned int last_segment = MAIN_SEGS(sbi); 279 unsigned int last_segment = MAIN_SEGS(sbi);
275 unsigned int nsearched = 0; 280 unsigned int nsearched = 0;
276 281
@@ -280,7 +285,7 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi,
280 select_policy(sbi, gc_type, type, &p); 285 select_policy(sbi, gc_type, type, &p);
281 286
282 p.min_segno = NULL_SEGNO; 287 p.min_segno = NULL_SEGNO;
283 p.min_cost = max_cost = get_max_cost(sbi, &p); 288 p.min_cost = get_max_cost(sbi, &p);
284 289
285 if (p.max_search == 0) 290 if (p.max_search == 0)
286 goto out; 291 goto out;
@@ -423,10 +428,10 @@ static int check_valid_map(struct f2fs_sb_info *sbi,
423static void gc_node_segment(struct f2fs_sb_info *sbi, 428static void gc_node_segment(struct f2fs_sb_info *sbi,
424 struct f2fs_summary *sum, unsigned int segno, int gc_type) 429 struct f2fs_summary *sum, unsigned int segno, int gc_type)
425{ 430{
426 bool initial = true;
427 struct f2fs_summary *entry; 431 struct f2fs_summary *entry;
428 block_t start_addr; 432 block_t start_addr;
429 int off; 433 int off;
434 int phase = 0;
430 435
431 start_addr = START_BLOCK(sbi, segno); 436 start_addr = START_BLOCK(sbi, segno);
432 437
@@ -439,16 +444,24 @@ next_step:
439 struct node_info ni; 444 struct node_info ni;
440 445
441 /* stop BG_GC if there is not enough free sections. */ 446 /* stop BG_GC if there is not enough free sections. */
442 if (gc_type == BG_GC && has_not_enough_free_secs(sbi, 0)) 447 if (gc_type == BG_GC && has_not_enough_free_secs(sbi, 0, 0))
443 return; 448 return;
444 449
445 if (check_valid_map(sbi, segno, off) == 0) 450 if (check_valid_map(sbi, segno, off) == 0)
446 continue; 451 continue;
447 452
448 if (initial) { 453 if (phase == 0) {
454 ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nid), 1,
455 META_NAT, true);
456 continue;
457 }
458
459 if (phase == 1) {
449 ra_node_page(sbi, nid); 460 ra_node_page(sbi, nid);
450 continue; 461 continue;
451 } 462 }
463
464 /* phase == 2 */
452 node_page = get_node_page(sbi, nid); 465 node_page = get_node_page(sbi, nid);
453 if (IS_ERR(node_page)) 466 if (IS_ERR(node_page))
454 continue; 467 continue;
@@ -469,10 +482,8 @@ next_step:
469 stat_inc_node_blk_count(sbi, 1, gc_type); 482 stat_inc_node_blk_count(sbi, 1, gc_type);
470 } 483 }
471 484
472 if (initial) { 485 if (++phase < 3)
473 initial = false;
474 goto next_step; 486 goto next_step;
475 }
476} 487}
477 488
478/* 489/*
@@ -706,16 +717,23 @@ next_step:
706 struct node_info dni; /* dnode info for the data */ 717 struct node_info dni; /* dnode info for the data */
707 unsigned int ofs_in_node, nofs; 718 unsigned int ofs_in_node, nofs;
708 block_t start_bidx; 719 block_t start_bidx;
720 nid_t nid = le32_to_cpu(entry->nid);
709 721
710 /* stop BG_GC if there is not enough free sections. */ 722 /* stop BG_GC if there is not enough free sections. */
711 if (gc_type == BG_GC && has_not_enough_free_secs(sbi, 0)) 723 if (gc_type == BG_GC && has_not_enough_free_secs(sbi, 0, 0))
712 return; 724 return;
713 725
714 if (check_valid_map(sbi, segno, off) == 0) 726 if (check_valid_map(sbi, segno, off) == 0)
715 continue; 727 continue;
716 728
717 if (phase == 0) { 729 if (phase == 0) {
718 ra_node_page(sbi, le32_to_cpu(entry->nid)); 730 ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nid), 1,
731 META_NAT, true);
732 continue;
733 }
734
735 if (phase == 1) {
736 ra_node_page(sbi, nid);
719 continue; 737 continue;
720 } 738 }
721 739
@@ -723,14 +741,14 @@ next_step:
723 if (!is_alive(sbi, entry, &dni, start_addr + off, &nofs)) 741 if (!is_alive(sbi, entry, &dni, start_addr + off, &nofs))
724 continue; 742 continue;
725 743
726 if (phase == 1) { 744 if (phase == 2) {
727 ra_node_page(sbi, dni.ino); 745 ra_node_page(sbi, dni.ino);
728 continue; 746 continue;
729 } 747 }
730 748
731 ofs_in_node = le16_to_cpu(entry->ofs_in_node); 749 ofs_in_node = le16_to_cpu(entry->ofs_in_node);
732 750
733 if (phase == 2) { 751 if (phase == 3) {
734 inode = f2fs_iget(sb, dni.ino); 752 inode = f2fs_iget(sb, dni.ino);
735 if (IS_ERR(inode) || is_bad_inode(inode)) 753 if (IS_ERR(inode) || is_bad_inode(inode))
736 continue; 754 continue;
@@ -756,7 +774,7 @@ next_step:
756 continue; 774 continue;
757 } 775 }
758 776
759 /* phase 3 */ 777 /* phase 4 */
760 inode = find_gc_inode(gc_list, dni.ino); 778 inode = find_gc_inode(gc_list, dni.ino);
761 if (inode) { 779 if (inode) {
762 struct f2fs_inode_info *fi = F2FS_I(inode); 780 struct f2fs_inode_info *fi = F2FS_I(inode);
@@ -789,7 +807,7 @@ next_step:
789 } 807 }
790 } 808 }
791 809
792 if (++phase < 4) 810 if (++phase < 5)
793 goto next_step; 811 goto next_step;
794} 812}
795 813
@@ -815,7 +833,7 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,
815 struct blk_plug plug; 833 struct blk_plug plug;
816 unsigned int segno = start_segno; 834 unsigned int segno = start_segno;
817 unsigned int end_segno = start_segno + sbi->segs_per_sec; 835 unsigned int end_segno = start_segno + sbi->segs_per_sec;
818 int seg_freed = 0; 836 int sec_freed = 0;
819 unsigned char type = IS_DATASEG(get_seg_entry(sbi, segno)->type) ? 837 unsigned char type = IS_DATASEG(get_seg_entry(sbi, segno)->type) ?
820 SUM_TYPE_DATA : SUM_TYPE_NODE; 838 SUM_TYPE_DATA : SUM_TYPE_NODE;
821 839
@@ -834,8 +852,9 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,
834 852
835 for (segno = start_segno; segno < end_segno; segno++) { 853 for (segno = start_segno; segno < end_segno; segno++) {
836 854
837 if (get_valid_blocks(sbi, segno, 1) == 0) 855 if (get_valid_blocks(sbi, segno, 1) == 0 ||
838 continue; 856 unlikely(f2fs_cp_error(sbi)))
857 goto next;
839 858
840 /* find segment summary of victim */ 859 /* find segment summary of victim */
841 sum_page = find_get_page(META_MAPPING(sbi), 860 sum_page = find_get_page(META_MAPPING(sbi),
@@ -861,7 +880,7 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,
861 gc_type); 880 gc_type);
862 881
863 stat_inc_seg_count(sbi, type, gc_type); 882 stat_inc_seg_count(sbi, type, gc_type);
864 883next:
865 f2fs_put_page(sum_page, 0); 884 f2fs_put_page(sum_page, 0);
866 } 885 }
867 886
@@ -871,22 +890,20 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,
871 890
872 blk_finish_plug(&plug); 891 blk_finish_plug(&plug);
873 892
874 if (gc_type == FG_GC) { 893 if (gc_type == FG_GC &&
875 while (start_segno < end_segno) 894 get_valid_blocks(sbi, start_segno, sbi->segs_per_sec) == 0)
876 if (get_valid_blocks(sbi, start_segno++, 1) == 0) 895 sec_freed = 1;
877 seg_freed++;
878 }
879 896
880 stat_inc_call_count(sbi->stat_info); 897 stat_inc_call_count(sbi->stat_info);
881 898
882 return seg_freed; 899 return sec_freed;
883} 900}
884 901
885int f2fs_gc(struct f2fs_sb_info *sbi, bool sync) 902int f2fs_gc(struct f2fs_sb_info *sbi, bool sync)
886{ 903{
887 unsigned int segno; 904 unsigned int segno;
888 int gc_type = sync ? FG_GC : BG_GC; 905 int gc_type = sync ? FG_GC : BG_GC;
889 int sec_freed = 0, seg_freed; 906 int sec_freed = 0;
890 int ret = -EINVAL; 907 int ret = -EINVAL;
891 struct cp_control cpc; 908 struct cp_control cpc;
892 struct gc_inode_list gc_list = { 909 struct gc_inode_list gc_list = {
@@ -905,7 +922,7 @@ gc_more:
905 goto stop; 922 goto stop;
906 } 923 }
907 924
908 if (gc_type == BG_GC && has_not_enough_free_secs(sbi, sec_freed)) { 925 if (gc_type == BG_GC && has_not_enough_free_secs(sbi, sec_freed, 0)) {
909 gc_type = FG_GC; 926 gc_type = FG_GC;
910 /* 927 /*
911 * If there is no victim and no prefree segment but still not 928 * If there is no victim and no prefree segment but still not
@@ -914,10 +931,14 @@ gc_more:
914 */ 931 */
915 if (__get_victim(sbi, &segno, gc_type) || 932 if (__get_victim(sbi, &segno, gc_type) ||
916 prefree_segments(sbi)) { 933 prefree_segments(sbi)) {
917 write_checkpoint(sbi, &cpc); 934 ret = write_checkpoint(sbi, &cpc);
935 if (ret)
936 goto stop;
918 segno = NULL_SEGNO; 937 segno = NULL_SEGNO;
919 } else if (has_not_enough_free_secs(sbi, 0)) { 938 } else if (has_not_enough_free_secs(sbi, 0, 0)) {
920 write_checkpoint(sbi, &cpc); 939 ret = write_checkpoint(sbi, &cpc);
940 if (ret)
941 goto stop;
921 } 942 }
922 } 943 }
923 944
@@ -925,20 +946,19 @@ gc_more:
925 goto stop; 946 goto stop;
926 ret = 0; 947 ret = 0;
927 948
928 seg_freed = do_garbage_collect(sbi, segno, &gc_list, gc_type); 949 if (do_garbage_collect(sbi, segno, &gc_list, gc_type) &&
929 950 gc_type == FG_GC)
930 if (gc_type == FG_GC && seg_freed == sbi->segs_per_sec)
931 sec_freed++; 951 sec_freed++;
932 952
933 if (gc_type == FG_GC) 953 if (gc_type == FG_GC)
934 sbi->cur_victim_sec = NULL_SEGNO; 954 sbi->cur_victim_sec = NULL_SEGNO;
935 955
936 if (!sync) { 956 if (!sync) {
937 if (has_not_enough_free_secs(sbi, sec_freed)) 957 if (has_not_enough_free_secs(sbi, sec_freed, 0))
938 goto gc_more; 958 goto gc_more;
939 959
940 if (gc_type == FG_GC) 960 if (gc_type == FG_GC)
941 write_checkpoint(sbi, &cpc); 961 ret = write_checkpoint(sbi, &cpc);
942 } 962 }
943stop: 963stop:
944 mutex_unlock(&sbi->gc_mutex); 964 mutex_unlock(&sbi->gc_mutex);
diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index ccea8735de59..34234d84a38b 100644
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -424,7 +424,7 @@ static int f2fs_add_inline_entries(struct inode *dir,
424 ino = le32_to_cpu(de->ino); 424 ino = le32_to_cpu(de->ino);
425 fake_mode = get_de_type(de) << S_SHIFT; 425 fake_mode = get_de_type(de) << S_SHIFT;
426 426
427 err = f2fs_add_regular_entry(dir, &new_name, NULL, 427 err = f2fs_add_regular_entry(dir, &new_name, NULL, NULL,
428 ino, fake_mode); 428 ino, fake_mode);
429 if (err) 429 if (err)
430 goto punch_dentry_pages; 430 goto punch_dentry_pages;
@@ -445,8 +445,8 @@ static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
445 struct f2fs_inline_dentry *backup_dentry; 445 struct f2fs_inline_dentry *backup_dentry;
446 int err; 446 int err;
447 447
448 backup_dentry = f2fs_kmalloc(sizeof(struct f2fs_inline_dentry), 448 backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir),
449 GFP_F2FS_ZERO); 449 sizeof(struct f2fs_inline_dentry), GFP_F2FS_ZERO);
450 if (!backup_dentry) { 450 if (!backup_dentry) {
451 f2fs_put_page(ipage, 1); 451 f2fs_put_page(ipage, 1);
452 return -ENOMEM; 452 return -ENOMEM;
@@ -488,17 +488,17 @@ static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
488 return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry); 488 return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry);
489} 489}
490 490
491int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name, 491int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
492 struct inode *inode, nid_t ino, umode_t mode) 492 const struct qstr *orig_name,
493 struct inode *inode, nid_t ino, umode_t mode)
493{ 494{
494 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 495 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
495 struct page *ipage; 496 struct page *ipage;
496 unsigned int bit_pos; 497 unsigned int bit_pos;
497 f2fs_hash_t name_hash; 498 f2fs_hash_t name_hash;
498 size_t namelen = name->len;
499 struct f2fs_inline_dentry *dentry_blk = NULL; 499 struct f2fs_inline_dentry *dentry_blk = NULL;
500 struct f2fs_dentry_ptr d; 500 struct f2fs_dentry_ptr d;
501 int slots = GET_DENTRY_SLOTS(namelen); 501 int slots = GET_DENTRY_SLOTS(new_name->len);
502 struct page *page = NULL; 502 struct page *page = NULL;
503 int err = 0; 503 int err = 0;
504 504
@@ -519,18 +519,21 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,
519 519
520 if (inode) { 520 if (inode) {
521 down_write(&F2FS_I(inode)->i_sem); 521 down_write(&F2FS_I(inode)->i_sem);
522 page = init_inode_metadata(inode, dir, name, ipage); 522 page = init_inode_metadata(inode, dir, new_name,
523 orig_name, ipage);
523 if (IS_ERR(page)) { 524 if (IS_ERR(page)) {
524 err = PTR_ERR(page); 525 err = PTR_ERR(page);
525 goto fail; 526 goto fail;
526 } 527 }
528 if (f2fs_encrypted_inode(dir))
529 file_set_enc_name(inode);
527 } 530 }
528 531
529 f2fs_wait_on_page_writeback(ipage, NODE, true); 532 f2fs_wait_on_page_writeback(ipage, NODE, true);
530 533
531 name_hash = f2fs_dentry_hash(name); 534 name_hash = f2fs_dentry_hash(new_name);
532 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2); 535 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
533 f2fs_update_dentry(ino, mode, &d, name, name_hash, bit_pos); 536 f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos);
534 537
535 set_page_dirty(ipage); 538 set_page_dirty(ipage);
536 539
@@ -563,7 +566,7 @@ void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
563 inline_dentry = inline_data_addr(page); 566 inline_dentry = inline_data_addr(page);
564 bit_pos = dentry - inline_dentry->dentry; 567 bit_pos = dentry - inline_dentry->dentry;
565 for (i = 0; i < slots; i++) 568 for (i = 0; i < slots; i++)
566 test_and_clear_bit_le(bit_pos + i, 569 __clear_bit_le(bit_pos + i,
567 &inline_dentry->dentry_bitmap); 570 &inline_dentry->dentry_bitmap);
568 571
569 set_page_dirty(page); 572 set_page_dirty(page);
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 9ac5efc15347..d7369895a78a 100644
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -11,6 +11,7 @@
11#include <linux/fs.h> 11#include <linux/fs.h>
12#include <linux/f2fs_fs.h> 12#include <linux/f2fs_fs.h>
13#include <linux/buffer_head.h> 13#include <linux/buffer_head.h>
14#include <linux/backing-dev.h>
14#include <linux/writeback.h> 15#include <linux/writeback.h>
15 16
16#include "f2fs.h" 17#include "f2fs.h"
@@ -234,6 +235,20 @@ bad_inode:
234 return ERR_PTR(ret); 235 return ERR_PTR(ret);
235} 236}
236 237
238struct inode *f2fs_iget_retry(struct super_block *sb, unsigned long ino)
239{
240 struct inode *inode;
241retry:
242 inode = f2fs_iget(sb, ino);
243 if (IS_ERR(inode)) {
244 if (PTR_ERR(inode) == -ENOMEM) {
245 congestion_wait(BLK_RW_ASYNC, HZ/50);
246 goto retry;
247 }
248 }
249 return inode;
250}
251
237int update_inode(struct inode *inode, struct page *node_page) 252int update_inode(struct inode *inode, struct page *node_page)
238{ 253{
239 struct f2fs_inode *ri; 254 struct f2fs_inode *ri;
@@ -354,7 +369,7 @@ void f2fs_evict_inode(struct inode *inode)
354 goto no_delete; 369 goto no_delete;
355 370
356#ifdef CONFIG_F2FS_FAULT_INJECTION 371#ifdef CONFIG_F2FS_FAULT_INJECTION
357 if (time_to_inject(FAULT_EVICT_INODE)) 372 if (time_to_inject(sbi, FAULT_EVICT_INODE))
358 goto no_delete; 373 goto no_delete;
359#endif 374#endif
360 375
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 73fa356f8fbb..300aef8a2d5f 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -91,18 +91,23 @@ static int is_multimedia_file(const unsigned char *s, const char *sub)
91{ 91{
92 size_t slen = strlen(s); 92 size_t slen = strlen(s);
93 size_t sublen = strlen(sub); 93 size_t sublen = strlen(sub);
94 int i;
94 95
95 /* 96 /*
96 * filename format of multimedia file should be defined as: 97 * filename format of multimedia file should be defined as:
97 * "filename + '.' + extension". 98 * "filename + '.' + extension + (optional: '.' + temp extension)".
98 */ 99 */
99 if (slen < sublen + 2) 100 if (slen < sublen + 2)
100 return 0; 101 return 0;
101 102
102 if (s[slen - sublen - 1] != '.') 103 for (i = 1; i < slen - sublen; i++) {
103 return 0; 104 if (s[i] != '.')
105 continue;
106 if (!strncasecmp(s + i + 1, sub, sublen))
107 return 1;
108 }
104 109
105 return !strncasecmp(s + slen - sublen, sub, sublen); 110 return 0;
106} 111}
107 112
108/* 113/*
@@ -1010,7 +1015,6 @@ static const char *f2fs_encrypted_get_link(struct dentry *dentry,
1010 struct fscrypt_str cstr = FSTR_INIT(NULL, 0); 1015 struct fscrypt_str cstr = FSTR_INIT(NULL, 0);
1011 struct fscrypt_str pstr = FSTR_INIT(NULL, 0); 1016 struct fscrypt_str pstr = FSTR_INIT(NULL, 0);
1012 struct fscrypt_symlink_data *sd; 1017 struct fscrypt_symlink_data *sd;
1013 loff_t size = min_t(loff_t, i_size_read(inode), PAGE_SIZE - 1);
1014 u32 max_size = inode->i_sb->s_blocksize; 1018 u32 max_size = inode->i_sb->s_blocksize;
1015 int res; 1019 int res;
1016 1020
@@ -1025,7 +1029,6 @@ static const char *f2fs_encrypted_get_link(struct dentry *dentry,
1025 if (IS_ERR(cpage)) 1029 if (IS_ERR(cpage))
1026 return ERR_CAST(cpage); 1030 return ERR_CAST(cpage);
1027 caddr = page_address(cpage); 1031 caddr = page_address(cpage);
1028 caddr[size] = 0;
1029 1032
1030 /* Symlink is encrypted */ 1033 /* Symlink is encrypted */
1031 sd = (struct fscrypt_symlink_data *)caddr; 1034 sd = (struct fscrypt_symlink_data *)caddr;
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index f75d197d5beb..883103593f33 100644
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -54,8 +54,6 @@ bool available_free_memory(struct f2fs_sb_info *sbi, int type)
54 res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 2); 54 res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 2);
55 if (excess_cached_nats(sbi)) 55 if (excess_cached_nats(sbi))
56 res = false; 56 res = false;
57 if (nm_i->nat_cnt > DEF_NAT_CACHE_THRESHOLD)
58 res = false;
59 } else if (type == DIRTY_DENTS) { 57 } else if (type == DIRTY_DENTS) {
60 if (sbi->sb->s_bdi->wb.dirty_exceeded) 58 if (sbi->sb->s_bdi->wb.dirty_exceeded)
61 return false; 59 return false;
@@ -1314,6 +1312,7 @@ int fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
1314 struct page *last_page = NULL; 1312 struct page *last_page = NULL;
1315 bool marked = false; 1313 bool marked = false;
1316 nid_t ino = inode->i_ino; 1314 nid_t ino = inode->i_ino;
1315 int nwritten = 0;
1317 1316
1318 if (atomic) { 1317 if (atomic) {
1319 last_page = last_fsync_dnode(sbi, ino); 1318 last_page = last_fsync_dnode(sbi, ino);
@@ -1387,7 +1386,10 @@ continue_unlock:
1387 unlock_page(page); 1386 unlock_page(page);
1388 f2fs_put_page(last_page, 0); 1387 f2fs_put_page(last_page, 0);
1389 break; 1388 break;
1389 } else {
1390 nwritten++;
1390 } 1391 }
1392
1391 if (page == last_page) { 1393 if (page == last_page) {
1392 f2fs_put_page(page, 0); 1394 f2fs_put_page(page, 0);
1393 marked = true; 1395 marked = true;
@@ -1409,6 +1411,9 @@ continue_unlock:
1409 unlock_page(last_page); 1411 unlock_page(last_page);
1410 goto retry; 1412 goto retry;
1411 } 1413 }
1414
1415 if (nwritten)
1416 f2fs_submit_merged_bio_cond(sbi, NULL, NULL, ino, NODE, WRITE);
1412 return ret ? -EIO: 0; 1417 return ret ? -EIO: 0;
1413} 1418}
1414 1419
@@ -1418,6 +1423,7 @@ int sync_node_pages(struct f2fs_sb_info *sbi, struct writeback_control *wbc)
1418 struct pagevec pvec; 1423 struct pagevec pvec;
1419 int step = 0; 1424 int step = 0;
1420 int nwritten = 0; 1425 int nwritten = 0;
1426 int ret = 0;
1421 1427
1422 pagevec_init(&pvec, 0); 1428 pagevec_init(&pvec, 0);
1423 1429
@@ -1438,7 +1444,8 @@ next_step:
1438 1444
1439 if (unlikely(f2fs_cp_error(sbi))) { 1445 if (unlikely(f2fs_cp_error(sbi))) {
1440 pagevec_release(&pvec); 1446 pagevec_release(&pvec);
1441 return -EIO; 1447 ret = -EIO;
1448 goto out;
1442 } 1449 }
1443 1450
1444 /* 1451 /*
@@ -1489,6 +1496,8 @@ continue_unlock:
1489 1496
1490 if (NODE_MAPPING(sbi)->a_ops->writepage(page, wbc)) 1497 if (NODE_MAPPING(sbi)->a_ops->writepage(page, wbc))
1491 unlock_page(page); 1498 unlock_page(page);
1499 else
1500 nwritten++;
1492 1501
1493 if (--wbc->nr_to_write == 0) 1502 if (--wbc->nr_to_write == 0)
1494 break; 1503 break;
@@ -1506,7 +1515,10 @@ continue_unlock:
1506 step++; 1515 step++;
1507 goto next_step; 1516 goto next_step;
1508 } 1517 }
1509 return nwritten; 1518out:
1519 if (nwritten)
1520 f2fs_submit_merged_bio(sbi, NODE, WRITE);
1521 return ret;
1510} 1522}
1511 1523
1512int wait_on_node_pages_writeback(struct f2fs_sb_info *sbi, nid_t ino) 1524int wait_on_node_pages_writeback(struct f2fs_sb_info *sbi, nid_t ino)
@@ -1672,6 +1684,9 @@ const struct address_space_operations f2fs_node_aops = {
1672 .set_page_dirty = f2fs_set_node_page_dirty, 1684 .set_page_dirty = f2fs_set_node_page_dirty,
1673 .invalidatepage = f2fs_invalidate_page, 1685 .invalidatepage = f2fs_invalidate_page,
1674 .releasepage = f2fs_release_page, 1686 .releasepage = f2fs_release_page,
1687#ifdef CONFIG_MIGRATION
1688 .migratepage = f2fs_migrate_page,
1689#endif
1675}; 1690};
1676 1691
1677static struct free_nid *__lookup_free_nid_list(struct f2fs_nm_info *nm_i, 1692static struct free_nid *__lookup_free_nid_list(struct f2fs_nm_info *nm_i,
@@ -1838,7 +1853,7 @@ bool alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid)
1838 struct free_nid *i = NULL; 1853 struct free_nid *i = NULL;
1839retry: 1854retry:
1840#ifdef CONFIG_F2FS_FAULT_INJECTION 1855#ifdef CONFIG_F2FS_FAULT_INJECTION
1841 if (time_to_inject(FAULT_ALLOC_NID)) 1856 if (time_to_inject(sbi, FAULT_ALLOC_NID))
1842 return false; 1857 return false;
1843#endif 1858#endif
1844 if (unlikely(sbi->total_valid_node_count + 1 > nm_i->available_nids)) 1859 if (unlikely(sbi->total_valid_node_count + 1 > nm_i->available_nids))
@@ -2015,10 +2030,12 @@ int recover_inode_page(struct f2fs_sb_info *sbi, struct page *page)
2015 2030
2016 if (unlikely(old_ni.blk_addr != NULL_ADDR)) 2031 if (unlikely(old_ni.blk_addr != NULL_ADDR))
2017 return -EINVAL; 2032 return -EINVAL;
2018 2033retry:
2019 ipage = f2fs_grab_cache_page(NODE_MAPPING(sbi), ino, false); 2034 ipage = f2fs_grab_cache_page(NODE_MAPPING(sbi), ino, false);
2020 if (!ipage) 2035 if (!ipage) {
2021 return -ENOMEM; 2036 congestion_wait(BLK_RW_ASYNC, HZ/50);
2037 goto retry;
2038 }
2022 2039
2023 /* Should not use this inode from free nid list */ 2040 /* Should not use this inode from free nid list */
2024 remove_free_nid(NM_I(sbi), ino); 2041 remove_free_nid(NM_I(sbi), ino);
diff --git a/fs/f2fs/node.h b/fs/f2fs/node.h
index fc7684554b1a..868bec65e51c 100644
--- a/fs/f2fs/node.h
+++ b/fs/f2fs/node.h
@@ -229,6 +229,37 @@ static inline void set_to_next_nat(struct f2fs_nm_info *nm_i, nid_t start_nid)
229 f2fs_change_bit(block_off, nm_i->nat_bitmap); 229 f2fs_change_bit(block_off, nm_i->nat_bitmap);
230} 230}
231 231
232static inline nid_t ino_of_node(struct page *node_page)
233{
234 struct f2fs_node *rn = F2FS_NODE(node_page);
235 return le32_to_cpu(rn->footer.ino);
236}
237
238static inline nid_t nid_of_node(struct page *node_page)
239{
240 struct f2fs_node *rn = F2FS_NODE(node_page);
241 return le32_to_cpu(rn->footer.nid);
242}
243
244static inline unsigned int ofs_of_node(struct page *node_page)
245{
246 struct f2fs_node *rn = F2FS_NODE(node_page);
247 unsigned flag = le32_to_cpu(rn->footer.flag);
248 return flag >> OFFSET_BIT_SHIFT;
249}
250
251static inline __u64 cpver_of_node(struct page *node_page)
252{
253 struct f2fs_node *rn = F2FS_NODE(node_page);
254 return le64_to_cpu(rn->footer.cp_ver);
255}
256
257static inline block_t next_blkaddr_of_node(struct page *node_page)
258{
259 struct f2fs_node *rn = F2FS_NODE(node_page);
260 return le32_to_cpu(rn->footer.next_blkaddr);
261}
262
232static inline void fill_node_footer(struct page *page, nid_t nid, 263static inline void fill_node_footer(struct page *page, nid_t nid,
233 nid_t ino, unsigned int ofs, bool reset) 264 nid_t ino, unsigned int ofs, bool reset)
234{ 265{
@@ -259,40 +290,30 @@ static inline void fill_node_footer_blkaddr(struct page *page, block_t blkaddr)
259{ 290{
260 struct f2fs_checkpoint *ckpt = F2FS_CKPT(F2FS_P_SB(page)); 291 struct f2fs_checkpoint *ckpt = F2FS_CKPT(F2FS_P_SB(page));
261 struct f2fs_node *rn = F2FS_NODE(page); 292 struct f2fs_node *rn = F2FS_NODE(page);
293 size_t crc_offset = le32_to_cpu(ckpt->checksum_offset);
294 __u64 cp_ver = le64_to_cpu(ckpt->checkpoint_ver);
262 295
263 rn->footer.cp_ver = ckpt->checkpoint_ver; 296 if (__is_set_ckpt_flags(ckpt, CP_CRC_RECOVERY_FLAG)) {
297 __u64 crc = le32_to_cpu(*((__le32 *)
298 ((unsigned char *)ckpt + crc_offset)));
299 cp_ver |= (crc << 32);
300 }
301 rn->footer.cp_ver = cpu_to_le64(cp_ver);
264 rn->footer.next_blkaddr = cpu_to_le32(blkaddr); 302 rn->footer.next_blkaddr = cpu_to_le32(blkaddr);
265} 303}
266 304
267static inline nid_t ino_of_node(struct page *node_page) 305static inline bool is_recoverable_dnode(struct page *page)
268{
269 struct f2fs_node *rn = F2FS_NODE(node_page);
270 return le32_to_cpu(rn->footer.ino);
271}
272
273static inline nid_t nid_of_node(struct page *node_page)
274{ 306{
275 struct f2fs_node *rn = F2FS_NODE(node_page); 307 struct f2fs_checkpoint *ckpt = F2FS_CKPT(F2FS_P_SB(page));
276 return le32_to_cpu(rn->footer.nid); 308 size_t crc_offset = le32_to_cpu(ckpt->checksum_offset);
277} 309 __u64 cp_ver = cur_cp_version(ckpt);
278
279static inline unsigned int ofs_of_node(struct page *node_page)
280{
281 struct f2fs_node *rn = F2FS_NODE(node_page);
282 unsigned flag = le32_to_cpu(rn->footer.flag);
283 return flag >> OFFSET_BIT_SHIFT;
284}
285
286static inline unsigned long long cpver_of_node(struct page *node_page)
287{
288 struct f2fs_node *rn = F2FS_NODE(node_page);
289 return le64_to_cpu(rn->footer.cp_ver);
290}
291 310
292static inline block_t next_blkaddr_of_node(struct page *node_page) 311 if (__is_set_ckpt_flags(ckpt, CP_CRC_RECOVERY_FLAG)) {
293{ 312 __u64 crc = le32_to_cpu(*((__le32 *)
294 struct f2fs_node *rn = F2FS_NODE(node_page); 313 ((unsigned char *)ckpt + crc_offset)));
295 return le32_to_cpu(rn->footer.next_blkaddr); 314 cp_ver |= (crc << 32);
315 }
316 return cpu_to_le64(cp_ver) == cpver_of_node(page);
296} 317}
297 318
298/* 319/*
diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 9e652d5a659b..2fc84a991325 100644
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -68,15 +68,17 @@ static struct fsync_inode_entry *get_fsync_inode(struct list_head *head,
68 return NULL; 68 return NULL;
69} 69}
70 70
71static struct fsync_inode_entry *add_fsync_inode(struct list_head *head, 71static struct fsync_inode_entry *add_fsync_inode(struct f2fs_sb_info *sbi,
72 struct inode *inode) 72 struct list_head *head, nid_t ino)
73{ 73{
74 struct inode *inode;
74 struct fsync_inode_entry *entry; 75 struct fsync_inode_entry *entry;
75 76
76 entry = kmem_cache_alloc(fsync_entry_slab, GFP_F2FS_ZERO); 77 inode = f2fs_iget_retry(sbi->sb, ino);
77 if (!entry) 78 if (IS_ERR(inode))
78 return NULL; 79 return ERR_CAST(inode);
79 80
81 entry = f2fs_kmem_cache_alloc(fsync_entry_slab, GFP_F2FS_ZERO);
80 entry->inode = inode; 82 entry->inode = inode;
81 list_add_tail(&entry->list, head); 83 list_add_tail(&entry->list, head);
82 84
@@ -96,48 +98,41 @@ static int recover_dentry(struct inode *inode, struct page *ipage,
96 struct f2fs_inode *raw_inode = F2FS_INODE(ipage); 98 struct f2fs_inode *raw_inode = F2FS_INODE(ipage);
97 nid_t pino = le32_to_cpu(raw_inode->i_pino); 99 nid_t pino = le32_to_cpu(raw_inode->i_pino);
98 struct f2fs_dir_entry *de; 100 struct f2fs_dir_entry *de;
99 struct qstr name; 101 struct fscrypt_name fname;
100 struct page *page; 102 struct page *page;
101 struct inode *dir, *einode; 103 struct inode *dir, *einode;
102 struct fsync_inode_entry *entry; 104 struct fsync_inode_entry *entry;
103 int err = 0; 105 int err = 0;
106 char *name;
104 107
105 entry = get_fsync_inode(dir_list, pino); 108 entry = get_fsync_inode(dir_list, pino);
106 if (!entry) { 109 if (!entry) {
107 dir = f2fs_iget(inode->i_sb, pino); 110 entry = add_fsync_inode(F2FS_I_SB(inode), dir_list, pino);
108 if (IS_ERR(dir)) { 111 if (IS_ERR(entry)) {
109 err = PTR_ERR(dir); 112 dir = ERR_CAST(entry);
110 goto out; 113 err = PTR_ERR(entry);
111 }
112
113 entry = add_fsync_inode(dir_list, dir);
114 if (!entry) {
115 err = -ENOMEM;
116 iput(dir);
117 goto out; 114 goto out;
118 } 115 }
119 } 116 }
120 117
121 dir = entry->inode; 118 dir = entry->inode;
122 119
123 if (file_enc_name(inode)) 120 memset(&fname, 0, sizeof(struct fscrypt_name));
124 return 0; 121 fname.disk_name.len = le32_to_cpu(raw_inode->i_namelen);
122 fname.disk_name.name = raw_inode->i_name;
125 123
126 name.len = le32_to_cpu(raw_inode->i_namelen); 124 if (unlikely(fname.disk_name.len > F2FS_NAME_LEN)) {
127 name.name = raw_inode->i_name;
128
129 if (unlikely(name.len > F2FS_NAME_LEN)) {
130 WARN_ON(1); 125 WARN_ON(1);
131 err = -ENAMETOOLONG; 126 err = -ENAMETOOLONG;
132 goto out; 127 goto out;
133 } 128 }
134retry: 129retry:
135 de = f2fs_find_entry(dir, &name, &page); 130 de = __f2fs_find_entry(dir, &fname, &page);
136 if (de && inode->i_ino == le32_to_cpu(de->ino)) 131 if (de && inode->i_ino == le32_to_cpu(de->ino))
137 goto out_unmap_put; 132 goto out_unmap_put;
138 133
139 if (de) { 134 if (de) {
140 einode = f2fs_iget(inode->i_sb, le32_to_cpu(de->ino)); 135 einode = f2fs_iget_retry(inode->i_sb, le32_to_cpu(de->ino));
141 if (IS_ERR(einode)) { 136 if (IS_ERR(einode)) {
142 WARN_ON(1); 137 WARN_ON(1);
143 err = PTR_ERR(einode); 138 err = PTR_ERR(einode);
@@ -156,18 +151,24 @@ retry:
156 } else if (IS_ERR(page)) { 151 } else if (IS_ERR(page)) {
157 err = PTR_ERR(page); 152 err = PTR_ERR(page);
158 } else { 153 } else {
159 err = __f2fs_add_link(dir, &name, inode, 154 err = __f2fs_do_add_link(dir, &fname, inode,
160 inode->i_ino, inode->i_mode); 155 inode->i_ino, inode->i_mode);
161 } 156 }
157 if (err == -ENOMEM)
158 goto retry;
162 goto out; 159 goto out;
163 160
164out_unmap_put: 161out_unmap_put:
165 f2fs_dentry_kunmap(dir, page); 162 f2fs_dentry_kunmap(dir, page);
166 f2fs_put_page(page, 0); 163 f2fs_put_page(page, 0);
167out: 164out:
165 if (file_enc_name(inode))
166 name = "<encrypted>";
167 else
168 name = raw_inode->i_name;
168 f2fs_msg(inode->i_sb, KERN_NOTICE, 169 f2fs_msg(inode->i_sb, KERN_NOTICE,
169 "%s: ino = %x, name = %s, dir = %lx, err = %d", 170 "%s: ino = %x, name = %s, dir = %lx, err = %d",
170 __func__, ino_of_node(ipage), raw_inode->i_name, 171 __func__, ino_of_node(ipage), name,
171 IS_ERR(dir) ? 0 : dir->i_ino, err); 172 IS_ERR(dir) ? 0 : dir->i_ino, err);
172 return err; 173 return err;
173} 174}
@@ -223,9 +224,7 @@ static bool is_same_inode(struct inode *inode, struct page *ipage)
223 224
224static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head) 225static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
225{ 226{
226 unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));
227 struct curseg_info *curseg; 227 struct curseg_info *curseg;
228 struct inode *inode;
229 struct page *page = NULL; 228 struct page *page = NULL;
230 block_t blkaddr; 229 block_t blkaddr;
231 int err = 0; 230 int err = 0;
@@ -242,7 +241,7 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
242 241
243 page = get_tmp_page(sbi, blkaddr); 242 page = get_tmp_page(sbi, blkaddr);
244 243
245 if (cp_ver != cpver_of_node(page)) 244 if (!is_recoverable_dnode(page))
246 break; 245 break;
247 246
248 if (!is_fsync_dnode(page)) 247 if (!is_fsync_dnode(page))
@@ -263,23 +262,15 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)
263 * CP | dnode(F) | inode(DF) 262 * CP | dnode(F) | inode(DF)
264 * For this case, we should not give up now. 263 * For this case, we should not give up now.
265 */ 264 */
266 inode = f2fs_iget(sbi->sb, ino_of_node(page)); 265 entry = add_fsync_inode(sbi, head, ino_of_node(page));
267 if (IS_ERR(inode)) { 266 if (IS_ERR(entry)) {
268 err = PTR_ERR(inode); 267 err = PTR_ERR(entry);
269 if (err == -ENOENT) { 268 if (err == -ENOENT) {
270 err = 0; 269 err = 0;
271 goto next; 270 goto next;
272 } 271 }
273 break; 272 break;
274 } 273 }
275
276 /* add this fsync inode to the list */
277 entry = add_fsync_inode(head, inode);
278 if (!entry) {
279 err = -ENOMEM;
280 iput(inode);
281 break;
282 }
283 } 274 }
284 entry->blkaddr = blkaddr; 275 entry->blkaddr = blkaddr;
285 276
@@ -363,7 +354,7 @@ got_it:
363 354
364 if (ino != dn->inode->i_ino) { 355 if (ino != dn->inode->i_ino) {
365 /* Deallocate previous index in the node page */ 356 /* Deallocate previous index in the node page */
366 inode = f2fs_iget(sbi->sb, ino); 357 inode = f2fs_iget_retry(sbi->sb, ino);
367 if (IS_ERR(inode)) 358 if (IS_ERR(inode))
368 return PTR_ERR(inode); 359 return PTR_ERR(inode);
369 } else { 360 } else {
@@ -431,10 +422,15 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
431 end = start + ADDRS_PER_PAGE(page, inode); 422 end = start + ADDRS_PER_PAGE(page, inode);
432 423
433 set_new_dnode(&dn, inode, NULL, NULL, 0); 424 set_new_dnode(&dn, inode, NULL, NULL, 0);
434 425retry_dn:
435 err = get_dnode_of_data(&dn, start, ALLOC_NODE); 426 err = get_dnode_of_data(&dn, start, ALLOC_NODE);
436 if (err) 427 if (err) {
428 if (err == -ENOMEM) {
429 congestion_wait(BLK_RW_ASYNC, HZ/50);
430 goto retry_dn;
431 }
437 goto out; 432 goto out;
433 }
438 434
439 f2fs_wait_on_page_writeback(dn.node_page, NODE, true); 435 f2fs_wait_on_page_writeback(dn.node_page, NODE, true);
440 436
@@ -485,11 +481,16 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
485 if (err) 481 if (err)
486 goto err; 482 goto err;
487 } 483 }
488 484retry_prev:
489 /* Check the previous node page having this index */ 485 /* Check the previous node page having this index */
490 err = check_index_in_prev_nodes(sbi, dest, &dn); 486 err = check_index_in_prev_nodes(sbi, dest, &dn);
491 if (err) 487 if (err) {
488 if (err == -ENOMEM) {
489 congestion_wait(BLK_RW_ASYNC, HZ/50);
490 goto retry_prev;
491 }
492 goto err; 492 goto err;
493 }
493 494
494 /* write dummy data page */ 495 /* write dummy data page */
495 f2fs_replace_block(sbi, &dn, src, dest, 496 f2fs_replace_block(sbi, &dn, src, dest,
@@ -514,7 +515,6 @@ out:
514static int recover_data(struct f2fs_sb_info *sbi, struct list_head *inode_list, 515static int recover_data(struct f2fs_sb_info *sbi, struct list_head *inode_list,
515 struct list_head *dir_list) 516 struct list_head *dir_list)
516{ 517{
517 unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));
518 struct curseg_info *curseg; 518 struct curseg_info *curseg;
519 struct page *page = NULL; 519 struct page *page = NULL;
520 int err = 0; 520 int err = 0;
@@ -534,7 +534,7 @@ static int recover_data(struct f2fs_sb_info *sbi, struct list_head *inode_list,
534 534
535 page = get_tmp_page(sbi, blkaddr); 535 page = get_tmp_page(sbi, blkaddr);
536 536
537 if (cp_ver != cpver_of_node(page)) { 537 if (!is_recoverable_dnode(page)) {
538 f2fs_put_page(page, 1); 538 f2fs_put_page(page, 1);
539 break; 539 break;
540 } 540 }
@@ -626,38 +626,20 @@ out:
626 } 626 }
627 627
628 clear_sbi_flag(sbi, SBI_POR_DOING); 628 clear_sbi_flag(sbi, SBI_POR_DOING);
629 if (err) { 629 if (err)
630 bool invalidate = false; 630 set_ckpt_flags(sbi, CP_ERROR_FLAG);
631 631 mutex_unlock(&sbi->cp_mutex);
632 if (test_opt(sbi, LFS)) {
633 update_meta_page(sbi, NULL, blkaddr);
634 invalidate = true;
635 } else if (discard_next_dnode(sbi, blkaddr)) {
636 invalidate = true;
637 }
638
639 /* Flush all the NAT/SIT pages */
640 while (get_pages(sbi, F2FS_DIRTY_META))
641 sync_meta_pages(sbi, META, LONG_MAX);
642 632
643 /* invalidate temporary meta page */ 633 /* let's drop all the directory inodes for clean checkpoint */
644 if (invalidate) 634 destroy_fsync_dnodes(&dir_list);
645 invalidate_mapping_pages(META_MAPPING(sbi),
646 blkaddr, blkaddr);
647 635
648 set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG); 636 if (!err && need_writecp) {
649 mutex_unlock(&sbi->cp_mutex);
650 } else if (need_writecp) {
651 struct cp_control cpc = { 637 struct cp_control cpc = {
652 .reason = CP_RECOVERY, 638 .reason = CP_RECOVERY,
653 }; 639 };
654 mutex_unlock(&sbi->cp_mutex);
655 err = write_checkpoint(sbi, &cpc); 640 err = write_checkpoint(sbi, &cpc);
656 } else {
657 mutex_unlock(&sbi->cp_mutex);
658 } 641 }
659 642
660 destroy_fsync_dnodes(&dir_list);
661 kmem_cache_destroy(fsync_entry_slab); 643 kmem_cache_destroy(fsync_entry_slab);
662 return ret ? ret: err; 644 return ret ? ret: err;
663} 645}
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index a46296f57b02..fc886f008449 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -26,6 +26,7 @@
26#define __reverse_ffz(x) __reverse_ffs(~(x)) 26#define __reverse_ffz(x) __reverse_ffs(~(x))
27 27
28static struct kmem_cache *discard_entry_slab; 28static struct kmem_cache *discard_entry_slab;
29static struct kmem_cache *bio_entry_slab;
29static struct kmem_cache *sit_entry_set_slab; 30static struct kmem_cache *sit_entry_set_slab;
30static struct kmem_cache *inmem_entry_slab; 31static struct kmem_cache *inmem_entry_slab;
31 32
@@ -344,6 +345,11 @@ int commit_inmem_pages(struct inode *inode)
344 */ 345 */
345void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need) 346void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need)
346{ 347{
348#ifdef CONFIG_F2FS_FAULT_INJECTION
349 if (time_to_inject(sbi, FAULT_CHECKPOINT))
350 f2fs_stop_checkpoint(sbi, false);
351#endif
352
347 if (!need) 353 if (!need)
348 return; 354 return;
349 355
@@ -355,7 +361,7 @@ void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need)
355 * We should do GC or end up with checkpoint, if there are so many dirty 361 * We should do GC or end up with checkpoint, if there are so many dirty
356 * dir/node pages without enough free segments. 362 * dir/node pages without enough free segments.
357 */ 363 */
358 if (has_not_enough_free_secs(sbi, 0)) { 364 if (has_not_enough_free_secs(sbi, 0, 0)) {
359 mutex_lock(&sbi->gc_mutex); 365 mutex_lock(&sbi->gc_mutex);
360 f2fs_gc(sbi, false); 366 f2fs_gc(sbi, false);
361 } 367 }
@@ -580,6 +586,74 @@ static void locate_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno)
580 mutex_unlock(&dirty_i->seglist_lock); 586 mutex_unlock(&dirty_i->seglist_lock);
581} 587}
582 588
589static struct bio_entry *__add_bio_entry(struct f2fs_sb_info *sbi,
590 struct bio *bio)
591{
592 struct list_head *wait_list = &(SM_I(sbi)->wait_list);
593 struct bio_entry *be = f2fs_kmem_cache_alloc(bio_entry_slab, GFP_NOFS);
594
595 INIT_LIST_HEAD(&be->list);
596 be->bio = bio;
597 init_completion(&be->event);
598 list_add_tail(&be->list, wait_list);
599
600 return be;
601}
602
603void f2fs_wait_all_discard_bio(struct f2fs_sb_info *sbi)
604{
605 struct list_head *wait_list = &(SM_I(sbi)->wait_list);
606 struct bio_entry *be, *tmp;
607
608 list_for_each_entry_safe(be, tmp, wait_list, list) {
609 struct bio *bio = be->bio;
610 int err;
611
612 wait_for_completion_io(&be->event);
613 err = be->error;
614 if (err == -EOPNOTSUPP)
615 err = 0;
616
617 if (err)
618 f2fs_msg(sbi->sb, KERN_INFO,
619 "Issue discard failed, ret: %d", err);
620
621 bio_put(bio);
622 list_del(&be->list);
623 kmem_cache_free(bio_entry_slab, be);
624 }
625}
626
627static void f2fs_submit_bio_wait_endio(struct bio *bio)
628{
629 struct bio_entry *be = (struct bio_entry *)bio->bi_private;
630
631 be->error = bio->bi_error;
632 complete(&be->event);
633}
634
635/* this function is copied from blkdev_issue_discard from block/blk-lib.c */
636int __f2fs_issue_discard_async(struct f2fs_sb_info *sbi, sector_t sector,
637 sector_t nr_sects, gfp_t gfp_mask, unsigned long flags)
638{
639 struct block_device *bdev = sbi->sb->s_bdev;
640 struct bio *bio = NULL;
641 int err;
642
643 err = __blkdev_issue_discard(bdev, sector, nr_sects, gfp_mask, flags,
644 &bio);
645 if (!err && bio) {
646 struct bio_entry *be = __add_bio_entry(sbi, bio);
647
648 bio->bi_private = be;
649 bio->bi_end_io = f2fs_submit_bio_wait_endio;
650 bio->bi_opf |= REQ_SYNC;
651 submit_bio(bio);
652 }
653
654 return err;
655}
656
583static int f2fs_issue_discard(struct f2fs_sb_info *sbi, 657static int f2fs_issue_discard(struct f2fs_sb_info *sbi,
584 block_t blkstart, block_t blklen) 658 block_t blkstart, block_t blklen)
585{ 659{
@@ -597,29 +671,7 @@ static int f2fs_issue_discard(struct f2fs_sb_info *sbi,
597 sbi->discard_blks--; 671 sbi->discard_blks--;
598 } 672 }
599 trace_f2fs_issue_discard(sbi->sb, blkstart, blklen); 673 trace_f2fs_issue_discard(sbi->sb, blkstart, blklen);
600 return blkdev_issue_discard(sbi->sb->s_bdev, start, len, GFP_NOFS, 0); 674 return __f2fs_issue_discard_async(sbi, start, len, GFP_NOFS, 0);
601}
602
603bool discard_next_dnode(struct f2fs_sb_info *sbi, block_t blkaddr)
604{
605 int err = -EOPNOTSUPP;
606
607 if (test_opt(sbi, DISCARD)) {
608 struct seg_entry *se = get_seg_entry(sbi,
609 GET_SEGNO(sbi, blkaddr));
610 unsigned int offset = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
611
612 if (f2fs_test_bit(offset, se->discard_map))
613 return false;
614
615 err = f2fs_issue_discard(sbi, blkaddr, 1);
616 }
617
618 if (err) {
619 update_meta_page(sbi, NULL, blkaddr);
620 return true;
621 }
622 return false;
623} 675}
624 676
625static void __add_discard_entry(struct f2fs_sb_info *sbi, 677static void __add_discard_entry(struct f2fs_sb_info *sbi,
@@ -660,7 +712,7 @@ static void add_discard_addrs(struct f2fs_sb_info *sbi, struct cp_control *cpc)
660 bool force = (cpc->reason == CP_DISCARD); 712 bool force = (cpc->reason == CP_DISCARD);
661 int i; 713 int i;
662 714
663 if (se->valid_blocks == max_blocks) 715 if (se->valid_blocks == max_blocks || !f2fs_discard_en(sbi))
664 return; 716 return;
665 717
666 if (!force) { 718 if (!force) {
@@ -719,11 +771,14 @@ void clear_prefree_segments(struct f2fs_sb_info *sbi, struct cp_control *cpc)
719 struct list_head *head = &(SM_I(sbi)->discard_list); 771 struct list_head *head = &(SM_I(sbi)->discard_list);
720 struct discard_entry *entry, *this; 772 struct discard_entry *entry, *this;
721 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); 773 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
774 struct blk_plug plug;
722 unsigned long *prefree_map = dirty_i->dirty_segmap[PRE]; 775 unsigned long *prefree_map = dirty_i->dirty_segmap[PRE];
723 unsigned int start = 0, end = -1; 776 unsigned int start = 0, end = -1;
724 unsigned int secno, start_segno; 777 unsigned int secno, start_segno;
725 bool force = (cpc->reason == CP_DISCARD); 778 bool force = (cpc->reason == CP_DISCARD);
726 779
780 blk_start_plug(&plug);
781
727 mutex_lock(&dirty_i->seglist_lock); 782 mutex_lock(&dirty_i->seglist_lock);
728 783
729 while (1) { 784 while (1) {
@@ -772,6 +827,8 @@ skip:
772 SM_I(sbi)->nr_discards -= entry->len; 827 SM_I(sbi)->nr_discards -= entry->len;
773 kmem_cache_free(discard_entry_slab, entry); 828 kmem_cache_free(discard_entry_slab, entry);
774 } 829 }
830
831 blk_finish_plug(&plug);
775} 832}
776 833
777static bool __mark_sit_entry_dirty(struct f2fs_sb_info *sbi, unsigned int segno) 834static bool __mark_sit_entry_dirty(struct f2fs_sb_info *sbi, unsigned int segno)
@@ -818,12 +875,14 @@ static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, int del)
818 if (del > 0) { 875 if (del > 0) {
819 if (f2fs_test_and_set_bit(offset, se->cur_valid_map)) 876 if (f2fs_test_and_set_bit(offset, se->cur_valid_map))
820 f2fs_bug_on(sbi, 1); 877 f2fs_bug_on(sbi, 1);
821 if (!f2fs_test_and_set_bit(offset, se->discard_map)) 878 if (f2fs_discard_en(sbi) &&
879 !f2fs_test_and_set_bit(offset, se->discard_map))
822 sbi->discard_blks--; 880 sbi->discard_blks--;
823 } else { 881 } else {
824 if (!f2fs_test_and_clear_bit(offset, se->cur_valid_map)) 882 if (!f2fs_test_and_clear_bit(offset, se->cur_valid_map))
825 f2fs_bug_on(sbi, 1); 883 f2fs_bug_on(sbi, 1);
826 if (f2fs_test_and_clear_bit(offset, se->discard_map)) 884 if (f2fs_discard_en(sbi) &&
885 f2fs_test_and_clear_bit(offset, se->discard_map))
827 sbi->discard_blks++; 886 sbi->discard_blks++;
828 } 887 }
829 if (!f2fs_test_bit(offset, se->ckpt_valid_map)) 888 if (!f2fs_test_bit(offset, se->ckpt_valid_map))
@@ -1202,7 +1261,7 @@ static int get_ssr_segment(struct f2fs_sb_info *sbi, int type)
1202 struct curseg_info *curseg = CURSEG_I(sbi, type); 1261 struct curseg_info *curseg = CURSEG_I(sbi, type);
1203 const struct victim_selection *v_ops = DIRTY_I(sbi)->v_ops; 1262 const struct victim_selection *v_ops = DIRTY_I(sbi)->v_ops;
1204 1263
1205 if (IS_NODESEG(type) || !has_not_enough_free_secs(sbi, 0)) 1264 if (IS_NODESEG(type) || !has_not_enough_free_secs(sbi, 0, 0))
1206 return v_ops->get_victim(sbi, 1265 return v_ops->get_victim(sbi,
1207 &(curseg)->next_segno, BG_GC, type, SSR); 1266 &(curseg)->next_segno, BG_GC, type, SSR);
1208 1267
@@ -1277,6 +1336,12 @@ int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range)
1277 if (end <= MAIN_BLKADDR(sbi)) 1336 if (end <= MAIN_BLKADDR(sbi))
1278 goto out; 1337 goto out;
1279 1338
1339 if (is_sbi_flag_set(sbi, SBI_NEED_FSCK)) {
1340 f2fs_msg(sbi->sb, KERN_WARNING,
1341 "Found FS corruption, run fsck to fix.");
1342 goto out;
1343 }
1344
1280 /* start/end segment number in main_area */ 1345 /* start/end segment number in main_area */
1281 start_segno = (start <= MAIN_BLKADDR(sbi)) ? 0 : GET_SEGNO(sbi, start); 1346 start_segno = (start <= MAIN_BLKADDR(sbi)) ? 0 : GET_SEGNO(sbi, start);
1282 end_segno = (end >= MAX_BLKADDR(sbi)) ? MAIN_SEGS(sbi) - 1 : 1347 end_segno = (end >= MAX_BLKADDR(sbi)) ? MAIN_SEGS(sbi) - 1 :
@@ -1301,6 +1366,10 @@ int f2fs_trim_fs(struct f2fs_sb_info *sbi, struct fstrim_range *range)
1301 mutex_lock(&sbi->gc_mutex); 1366 mutex_lock(&sbi->gc_mutex);
1302 err = write_checkpoint(sbi, &cpc); 1367 err = write_checkpoint(sbi, &cpc);
1303 mutex_unlock(&sbi->gc_mutex); 1368 mutex_unlock(&sbi->gc_mutex);
1369 if (err)
1370 break;
1371
1372 schedule();
1304 } 1373 }
1305out: 1374out:
1306 range->len = F2FS_BLK_TO_BYTES(cpc.trimmed); 1375 range->len = F2FS_BLK_TO_BYTES(cpc.trimmed);
@@ -1391,7 +1460,7 @@ void allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
1391 1460
1392 /* direct_io'ed data is aligned to the segment for better performance */ 1461 /* direct_io'ed data is aligned to the segment for better performance */
1393 if (direct_io && curseg->next_blkoff && 1462 if (direct_io && curseg->next_blkoff &&
1394 !has_not_enough_free_secs(sbi, 0)) 1463 !has_not_enough_free_secs(sbi, 0, 0))
1395 __allocate_new_segments(sbi, type); 1464 __allocate_new_segments(sbi, type);
1396 1465
1397 *new_blkaddr = NEXT_FREE_BLKADDR(sbi, curseg); 1466 *new_blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
@@ -1589,11 +1658,9 @@ void f2fs_wait_on_encrypted_page_writeback(struct f2fs_sb_info *sbi,
1589{ 1658{
1590 struct page *cpage; 1659 struct page *cpage;
1591 1660
1592 if (blkaddr == NEW_ADDR) 1661 if (blkaddr == NEW_ADDR || blkaddr == NULL_ADDR)
1593 return; 1662 return;
1594 1663
1595 f2fs_bug_on(sbi, blkaddr == NULL_ADDR);
1596
1597 cpage = find_lock_page(META_MAPPING(sbi), blkaddr); 1664 cpage = find_lock_page(META_MAPPING(sbi), blkaddr);
1598 if (cpage) { 1665 if (cpage) {
1599 f2fs_wait_on_page_writeback(cpage, DATA, true); 1666 f2fs_wait_on_page_writeback(cpage, DATA, true);
@@ -1739,7 +1806,7 @@ static int restore_curseg_summaries(struct f2fs_sb_info *sbi)
1739 int type = CURSEG_HOT_DATA; 1806 int type = CURSEG_HOT_DATA;
1740 int err; 1807 int err;
1741 1808
1742 if (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_COMPACT_SUM_FLAG)) { 1809 if (is_set_ckpt_flags(sbi, CP_COMPACT_SUM_FLAG)) {
1743 int npages = npages_for_summary_flush(sbi, true); 1810 int npages = npages_for_summary_flush(sbi, true);
1744 1811
1745 if (npages >= 2) 1812 if (npages >= 2)
@@ -1836,7 +1903,7 @@ static void write_normal_summaries(struct f2fs_sb_info *sbi,
1836 1903
1837void write_data_summaries(struct f2fs_sb_info *sbi, block_t start_blk) 1904void write_data_summaries(struct f2fs_sb_info *sbi, block_t start_blk)
1838{ 1905{
1839 if (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_COMPACT_SUM_FLAG)) 1906 if (is_set_ckpt_flags(sbi, CP_COMPACT_SUM_FLAG))
1840 write_compacted_summaries(sbi, start_blk); 1907 write_compacted_summaries(sbi, start_blk);
1841 else 1908 else
1842 write_normal_summaries(sbi, start_blk, CURSEG_HOT_DATA); 1909 write_normal_summaries(sbi, start_blk, CURSEG_HOT_DATA);
@@ -2127,12 +2194,16 @@ static int build_sit_info(struct f2fs_sb_info *sbi)
2127 = kzalloc(SIT_VBLOCK_MAP_SIZE, GFP_KERNEL); 2194 = kzalloc(SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);
2128 sit_i->sentries[start].ckpt_valid_map 2195 sit_i->sentries[start].ckpt_valid_map
2129 = kzalloc(SIT_VBLOCK_MAP_SIZE, GFP_KERNEL); 2196 = kzalloc(SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);
2130 sit_i->sentries[start].discard_map
2131 = kzalloc(SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);
2132 if (!sit_i->sentries[start].cur_valid_map || 2197 if (!sit_i->sentries[start].cur_valid_map ||
2133 !sit_i->sentries[start].ckpt_valid_map || 2198 !sit_i->sentries[start].ckpt_valid_map)
2134 !sit_i->sentries[start].discard_map)
2135 return -ENOMEM; 2199 return -ENOMEM;
2200
2201 if (f2fs_discard_en(sbi)) {
2202 sit_i->sentries[start].discard_map
2203 = kzalloc(SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);
2204 if (!sit_i->sentries[start].discard_map)
2205 return -ENOMEM;
2206 }
2136 } 2207 }
2137 2208
2138 sit_i->tmp_map = kzalloc(SIT_VBLOCK_MAP_SIZE, GFP_KERNEL); 2209 sit_i->tmp_map = kzalloc(SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);
@@ -2239,6 +2310,8 @@ static void build_sit_entries(struct f2fs_sb_info *sbi)
2239 struct sit_info *sit_i = SIT_I(sbi); 2310 struct sit_info *sit_i = SIT_I(sbi);
2240 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA); 2311 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
2241 struct f2fs_journal *journal = curseg->journal; 2312 struct f2fs_journal *journal = curseg->journal;
2313 struct seg_entry *se;
2314 struct f2fs_sit_entry sit;
2242 int sit_blk_cnt = SIT_BLK_CNT(sbi); 2315 int sit_blk_cnt = SIT_BLK_CNT(sbi);
2243 unsigned int i, start, end; 2316 unsigned int i, start, end;
2244 unsigned int readed, start_blk = 0; 2317 unsigned int readed, start_blk = 0;
@@ -2251,41 +2324,58 @@ static void build_sit_entries(struct f2fs_sb_info *sbi)
2251 end = (start_blk + readed) * sit_i->sents_per_block; 2324 end = (start_blk + readed) * sit_i->sents_per_block;
2252 2325
2253 for (; start < end && start < MAIN_SEGS(sbi); start++) { 2326 for (; start < end && start < MAIN_SEGS(sbi); start++) {
2254 struct seg_entry *se = &sit_i->sentries[start];
2255 struct f2fs_sit_block *sit_blk; 2327 struct f2fs_sit_block *sit_blk;
2256 struct f2fs_sit_entry sit;
2257 struct page *page; 2328 struct page *page;
2258 2329
2259 down_read(&curseg->journal_rwsem); 2330 se = &sit_i->sentries[start];
2260 for (i = 0; i < sits_in_cursum(journal); i++) {
2261 if (le32_to_cpu(segno_in_journal(journal, i))
2262 == start) {
2263 sit = sit_in_journal(journal, i);
2264 up_read(&curseg->journal_rwsem);
2265 goto got_it;
2266 }
2267 }
2268 up_read(&curseg->journal_rwsem);
2269
2270 page = get_current_sit_page(sbi, start); 2331 page = get_current_sit_page(sbi, start);
2271 sit_blk = (struct f2fs_sit_block *)page_address(page); 2332 sit_blk = (struct f2fs_sit_block *)page_address(page);
2272 sit = sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, start)]; 2333 sit = sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, start)];
2273 f2fs_put_page(page, 1); 2334 f2fs_put_page(page, 1);
2274got_it: 2335
2275 check_block_count(sbi, start, &sit); 2336 check_block_count(sbi, start, &sit);
2276 seg_info_from_raw_sit(se, &sit); 2337 seg_info_from_raw_sit(se, &sit);
2277 2338
2278 /* build discard map only one time */ 2339 /* build discard map only one time */
2279 memcpy(se->discard_map, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE); 2340 if (f2fs_discard_en(sbi)) {
2280 sbi->discard_blks += sbi->blocks_per_seg - se->valid_blocks; 2341 memcpy(se->discard_map, se->cur_valid_map,
2281 2342 SIT_VBLOCK_MAP_SIZE);
2282 if (sbi->segs_per_sec > 1) { 2343 sbi->discard_blks += sbi->blocks_per_seg -
2283 struct sec_entry *e = get_sec_entry(sbi, start); 2344 se->valid_blocks;
2284 e->valid_blocks += se->valid_blocks;
2285 } 2345 }
2346
2347 if (sbi->segs_per_sec > 1)
2348 get_sec_entry(sbi, start)->valid_blocks +=
2349 se->valid_blocks;
2286 } 2350 }
2287 start_blk += readed; 2351 start_blk += readed;
2288 } while (start_blk < sit_blk_cnt); 2352 } while (start_blk < sit_blk_cnt);
2353
2354 down_read(&curseg->journal_rwsem);
2355 for (i = 0; i < sits_in_cursum(journal); i++) {
2356 unsigned int old_valid_blocks;
2357
2358 start = le32_to_cpu(segno_in_journal(journal, i));
2359 se = &sit_i->sentries[start];
2360 sit = sit_in_journal(journal, i);
2361
2362 old_valid_blocks = se->valid_blocks;
2363
2364 check_block_count(sbi, start, &sit);
2365 seg_info_from_raw_sit(se, &sit);
2366
2367 if (f2fs_discard_en(sbi)) {
2368 memcpy(se->discard_map, se->cur_valid_map,
2369 SIT_VBLOCK_MAP_SIZE);
2370 sbi->discard_blks += old_valid_blocks -
2371 se->valid_blocks;
2372 }
2373
2374 if (sbi->segs_per_sec > 1)
2375 get_sec_entry(sbi, start)->valid_blocks +=
2376 se->valid_blocks - old_valid_blocks;
2377 }
2378 up_read(&curseg->journal_rwsem);
2289} 2379}
2290 2380
2291static void init_free_segmap(struct f2fs_sb_info *sbi) 2381static void init_free_segmap(struct f2fs_sb_info *sbi)
@@ -2427,6 +2517,7 @@ int build_segment_manager(struct f2fs_sb_info *sbi)
2427 sm_info->min_fsync_blocks = DEF_MIN_FSYNC_BLOCKS; 2517 sm_info->min_fsync_blocks = DEF_MIN_FSYNC_BLOCKS;
2428 2518
2429 INIT_LIST_HEAD(&sm_info->discard_list); 2519 INIT_LIST_HEAD(&sm_info->discard_list);
2520 INIT_LIST_HEAD(&sm_info->wait_list);
2430 sm_info->nr_discards = 0; 2521 sm_info->nr_discards = 0;
2431 sm_info->max_discards = 0; 2522 sm_info->max_discards = 0;
2432 2523
@@ -2570,10 +2661,15 @@ int __init create_segment_manager_caches(void)
2570 if (!discard_entry_slab) 2661 if (!discard_entry_slab)
2571 goto fail; 2662 goto fail;
2572 2663
2664 bio_entry_slab = f2fs_kmem_cache_create("bio_entry",
2665 sizeof(struct bio_entry));
2666 if (!bio_entry_slab)
2667 goto destroy_discard_entry;
2668
2573 sit_entry_set_slab = f2fs_kmem_cache_create("sit_entry_set", 2669 sit_entry_set_slab = f2fs_kmem_cache_create("sit_entry_set",
2574 sizeof(struct sit_entry_set)); 2670 sizeof(struct sit_entry_set));
2575 if (!sit_entry_set_slab) 2671 if (!sit_entry_set_slab)
2576 goto destory_discard_entry; 2672 goto destroy_bio_entry;
2577 2673
2578 inmem_entry_slab = f2fs_kmem_cache_create("inmem_page_entry", 2674 inmem_entry_slab = f2fs_kmem_cache_create("inmem_page_entry",
2579 sizeof(struct inmem_pages)); 2675 sizeof(struct inmem_pages));
@@ -2583,7 +2679,9 @@ int __init create_segment_manager_caches(void)
2583 2679
2584destroy_sit_entry_set: 2680destroy_sit_entry_set:
2585 kmem_cache_destroy(sit_entry_set_slab); 2681 kmem_cache_destroy(sit_entry_set_slab);
2586destory_discard_entry: 2682destroy_bio_entry:
2683 kmem_cache_destroy(bio_entry_slab);
2684destroy_discard_entry:
2587 kmem_cache_destroy(discard_entry_slab); 2685 kmem_cache_destroy(discard_entry_slab);
2588fail: 2686fail:
2589 return -ENOMEM; 2687 return -ENOMEM;
@@ -2592,6 +2690,7 @@ fail:
2592void destroy_segment_manager_caches(void) 2690void destroy_segment_manager_caches(void)
2593{ 2691{
2594 kmem_cache_destroy(sit_entry_set_slab); 2692 kmem_cache_destroy(sit_entry_set_slab);
2693 kmem_cache_destroy(bio_entry_slab);
2595 kmem_cache_destroy(discard_entry_slab); 2694 kmem_cache_destroy(discard_entry_slab);
2596 kmem_cache_destroy(inmem_entry_slab); 2695 kmem_cache_destroy(inmem_entry_slab);
2597} 2696}
diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index b33f73ec60a4..fecb856ad874 100644
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -479,7 +479,8 @@ static inline bool need_SSR(struct f2fs_sb_info *sbi)
479 reserved_sections(sbi) + 1); 479 reserved_sections(sbi) + 1);
480} 480}
481 481
482static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi, int freed) 482static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi,
483 int freed, int needed)
483{ 484{
484 int node_secs = get_blocktype_secs(sbi, F2FS_DIRTY_NODES); 485 int node_secs = get_blocktype_secs(sbi, F2FS_DIRTY_NODES);
485 int dent_secs = get_blocktype_secs(sbi, F2FS_DIRTY_DENTS); 486 int dent_secs = get_blocktype_secs(sbi, F2FS_DIRTY_DENTS);
@@ -489,8 +490,8 @@ static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi, int freed)
489 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING))) 490 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
490 return false; 491 return false;
491 492
492 return (free_sections(sbi) + freed) <= (node_secs + 2 * dent_secs + 493 return (free_sections(sbi) + freed) <=
493 reserved_sections(sbi)); 494 (node_secs + 2 * dent_secs + reserved_sections(sbi) + needed);
494} 495}
495 496
496static inline bool excess_prefree_segs(struct f2fs_sb_info *sbi) 497static inline bool excess_prefree_segs(struct f2fs_sb_info *sbi)
@@ -587,8 +588,8 @@ static inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno)
587 588
588static inline void verify_block_addr(struct f2fs_sb_info *sbi, block_t blk_addr) 589static inline void verify_block_addr(struct f2fs_sb_info *sbi, block_t blk_addr)
589{ 590{
590 f2fs_bug_on(sbi, blk_addr < SEG0_BLKADDR(sbi) 591 BUG_ON(blk_addr < SEG0_BLKADDR(sbi)
591 || blk_addr >= MAX_BLKADDR(sbi)); 592 || blk_addr >= MAX_BLKADDR(sbi));
592} 593}
593 594
594/* 595/*
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 7f863a645ab1..6132b4ce4e4c 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -40,7 +40,6 @@ static struct kmem_cache *f2fs_inode_cachep;
40static struct kset *f2fs_kset; 40static struct kset *f2fs_kset;
41 41
42#ifdef CONFIG_F2FS_FAULT_INJECTION 42#ifdef CONFIG_F2FS_FAULT_INJECTION
43struct f2fs_fault_info f2fs_fault;
44 43
45char *fault_name[FAULT_MAX] = { 44char *fault_name[FAULT_MAX] = {
46 [FAULT_KMALLOC] = "kmalloc", 45 [FAULT_KMALLOC] = "kmalloc",
@@ -50,16 +49,21 @@ char *fault_name[FAULT_MAX] = {
50 [FAULT_BLOCK] = "no more block", 49 [FAULT_BLOCK] = "no more block",
51 [FAULT_DIR_DEPTH] = "too big dir depth", 50 [FAULT_DIR_DEPTH] = "too big dir depth",
52 [FAULT_EVICT_INODE] = "evict_inode fail", 51 [FAULT_EVICT_INODE] = "evict_inode fail",
52 [FAULT_IO] = "IO error",
53 [FAULT_CHECKPOINT] = "checkpoint error",
53}; 54};
54 55
55static void f2fs_build_fault_attr(unsigned int rate) 56static void f2fs_build_fault_attr(struct f2fs_sb_info *sbi,
57 unsigned int rate)
56{ 58{
59 struct f2fs_fault_info *ffi = &sbi->fault_info;
60
57 if (rate) { 61 if (rate) {
58 atomic_set(&f2fs_fault.inject_ops, 0); 62 atomic_set(&ffi->inject_ops, 0);
59 f2fs_fault.inject_rate = rate; 63 ffi->inject_rate = rate;
60 f2fs_fault.inject_type = (1 << FAULT_MAX) - 1; 64 ffi->inject_type = (1 << FAULT_MAX) - 1;
61 } else { 65 } else {
62 memset(&f2fs_fault, 0, sizeof(struct f2fs_fault_info)); 66 memset(ffi, 0, sizeof(struct f2fs_fault_info));
63 } 67 }
64} 68}
65#endif 69#endif
@@ -87,6 +91,7 @@ enum {
87 Opt_inline_xattr, 91 Opt_inline_xattr,
88 Opt_inline_data, 92 Opt_inline_data,
89 Opt_inline_dentry, 93 Opt_inline_dentry,
94 Opt_noinline_dentry,
90 Opt_flush_merge, 95 Opt_flush_merge,
91 Opt_noflush_merge, 96 Opt_noflush_merge,
92 Opt_nobarrier, 97 Opt_nobarrier,
@@ -118,6 +123,7 @@ static match_table_t f2fs_tokens = {
118 {Opt_inline_xattr, "inline_xattr"}, 123 {Opt_inline_xattr, "inline_xattr"},
119 {Opt_inline_data, "inline_data"}, 124 {Opt_inline_data, "inline_data"},
120 {Opt_inline_dentry, "inline_dentry"}, 125 {Opt_inline_dentry, "inline_dentry"},
126 {Opt_noinline_dentry, "noinline_dentry"},
121 {Opt_flush_merge, "flush_merge"}, 127 {Opt_flush_merge, "flush_merge"},
122 {Opt_noflush_merge, "noflush_merge"}, 128 {Opt_noflush_merge, "noflush_merge"},
123 {Opt_nobarrier, "nobarrier"}, 129 {Opt_nobarrier, "nobarrier"},
@@ -167,7 +173,7 @@ static unsigned char *__struct_ptr(struct f2fs_sb_info *sbi, int struct_type)
167#ifdef CONFIG_F2FS_FAULT_INJECTION 173#ifdef CONFIG_F2FS_FAULT_INJECTION
168 else if (struct_type == FAULT_INFO_RATE || 174 else if (struct_type == FAULT_INFO_RATE ||
169 struct_type == FAULT_INFO_TYPE) 175 struct_type == FAULT_INFO_TYPE)
170 return (unsigned char *)&f2fs_fault; 176 return (unsigned char *)&sbi->fault_info;
171#endif 177#endif
172 return NULL; 178 return NULL;
173} 179}
@@ -312,6 +318,10 @@ static struct attribute *f2fs_attrs[] = {
312 ATTR_LIST(dirty_nats_ratio), 318 ATTR_LIST(dirty_nats_ratio),
313 ATTR_LIST(cp_interval), 319 ATTR_LIST(cp_interval),
314 ATTR_LIST(idle_interval), 320 ATTR_LIST(idle_interval),
321#ifdef CONFIG_F2FS_FAULT_INJECTION
322 ATTR_LIST(inject_rate),
323 ATTR_LIST(inject_type),
324#endif
315 ATTR_LIST(lifetime_write_kbytes), 325 ATTR_LIST(lifetime_write_kbytes),
316 NULL, 326 NULL,
317}; 327};
@@ -327,22 +337,6 @@ static struct kobj_type f2fs_ktype = {
327 .release = f2fs_sb_release, 337 .release = f2fs_sb_release,
328}; 338};
329 339
330#ifdef CONFIG_F2FS_FAULT_INJECTION
331/* sysfs for f2fs fault injection */
332static struct kobject f2fs_fault_inject;
333
334static struct attribute *f2fs_fault_attrs[] = {
335 ATTR_LIST(inject_rate),
336 ATTR_LIST(inject_type),
337 NULL
338};
339
340static struct kobj_type f2fs_fault_ktype = {
341 .default_attrs = f2fs_fault_attrs,
342 .sysfs_ops = &f2fs_attr_ops,
343};
344#endif
345
346void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...) 340void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...)
347{ 341{
348 struct va_format vaf; 342 struct va_format vaf;
@@ -370,10 +364,6 @@ static int parse_options(struct super_block *sb, char *options)
370 char *p, *name; 364 char *p, *name;
371 int arg = 0; 365 int arg = 0;
372 366
373#ifdef CONFIG_F2FS_FAULT_INJECTION
374 f2fs_build_fault_attr(0);
375#endif
376
377 if (!options) 367 if (!options)
378 return 0; 368 return 0;
379 369
@@ -488,6 +478,9 @@ static int parse_options(struct super_block *sb, char *options)
488 case Opt_inline_dentry: 478 case Opt_inline_dentry:
489 set_opt(sbi, INLINE_DENTRY); 479 set_opt(sbi, INLINE_DENTRY);
490 break; 480 break;
481 case Opt_noinline_dentry:
482 clear_opt(sbi, INLINE_DENTRY);
483 break;
491 case Opt_flush_merge: 484 case Opt_flush_merge:
492 set_opt(sbi, FLUSH_MERGE); 485 set_opt(sbi, FLUSH_MERGE);
493 break; 486 break;
@@ -533,7 +526,7 @@ static int parse_options(struct super_block *sb, char *options)
533 if (args->from && match_int(args, &arg)) 526 if (args->from && match_int(args, &arg))
534 return -EINVAL; 527 return -EINVAL;
535#ifdef CONFIG_F2FS_FAULT_INJECTION 528#ifdef CONFIG_F2FS_FAULT_INJECTION
536 f2fs_build_fault_attr(arg); 529 f2fs_build_fault_attr(sbi, arg);
537#else 530#else
538 f2fs_msg(sb, KERN_INFO, 531 f2fs_msg(sb, KERN_INFO,
539 "FAULT_INJECTION was not selected"); 532 "FAULT_INJECTION was not selected");
@@ -730,7 +723,7 @@ static void f2fs_put_super(struct super_block *sb)
730 * clean checkpoint again. 723 * clean checkpoint again.
731 */ 724 */
732 if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) || 725 if (is_sbi_flag_set(sbi, SBI_IS_DIRTY) ||
733 !is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG)) { 726 !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
734 struct cp_control cpc = { 727 struct cp_control cpc = {
735 .reason = CP_UMOUNT, 728 .reason = CP_UMOUNT,
736 }; 729 };
@@ -878,6 +871,8 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
878 seq_puts(seq, ",noinline_data"); 871 seq_puts(seq, ",noinline_data");
879 if (test_opt(sbi, INLINE_DENTRY)) 872 if (test_opt(sbi, INLINE_DENTRY))
880 seq_puts(seq, ",inline_dentry"); 873 seq_puts(seq, ",inline_dentry");
874 else
875 seq_puts(seq, ",noinline_dentry");
881 if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE)) 876 if (!f2fs_readonly(sbi->sb) && test_opt(sbi, FLUSH_MERGE))
882 seq_puts(seq, ",flush_merge"); 877 seq_puts(seq, ",flush_merge");
883 if (test_opt(sbi, NOBARRIER)) 878 if (test_opt(sbi, NOBARRIER))
@@ -946,7 +941,7 @@ static int segment_bits_seq_show(struct seq_file *seq, void *offset)
946 seq_printf(seq, "%d|%-3u|", se->type, 941 seq_printf(seq, "%d|%-3u|", se->type,
947 get_valid_blocks(sbi, i, 1)); 942 get_valid_blocks(sbi, i, 1));
948 for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++) 943 for (j = 0; j < SIT_VBLOCK_MAP_SIZE; j++)
949 seq_printf(seq, "%x ", se->cur_valid_map[j]); 944 seq_printf(seq, " %.2x", se->cur_valid_map[j]);
950 seq_putc(seq, '\n'); 945 seq_putc(seq, '\n');
951 } 946 }
952 return 0; 947 return 0;
@@ -975,6 +970,7 @@ static void default_options(struct f2fs_sb_info *sbi)
975 970
976 set_opt(sbi, BG_GC); 971 set_opt(sbi, BG_GC);
977 set_opt(sbi, INLINE_DATA); 972 set_opt(sbi, INLINE_DATA);
973 set_opt(sbi, INLINE_DENTRY);
978 set_opt(sbi, EXTENT_CACHE); 974 set_opt(sbi, EXTENT_CACHE);
979 sbi->sb->s_flags |= MS_LAZYTIME; 975 sbi->sb->s_flags |= MS_LAZYTIME;
980 set_opt(sbi, FLUSH_MERGE); 976 set_opt(sbi, FLUSH_MERGE);
@@ -991,6 +987,10 @@ static void default_options(struct f2fs_sb_info *sbi)
991#ifdef CONFIG_F2FS_FS_POSIX_ACL 987#ifdef CONFIG_F2FS_FS_POSIX_ACL
992 set_opt(sbi, POSIX_ACL); 988 set_opt(sbi, POSIX_ACL);
993#endif 989#endif
990
991#ifdef CONFIG_F2FS_FAULT_INJECTION
992 f2fs_build_fault_attr(sbi, 0);
993#endif
994} 994}
995 995
996static int f2fs_remount(struct super_block *sb, int *flags, char *data) 996static int f2fs_remount(struct super_block *sb, int *flags, char *data)
@@ -1001,6 +1001,9 @@ static int f2fs_remount(struct super_block *sb, int *flags, char *data)
1001 bool need_restart_gc = false; 1001 bool need_restart_gc = false;
1002 bool need_stop_gc = false; 1002 bool need_stop_gc = false;
1003 bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE); 1003 bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
1004#ifdef CONFIG_F2FS_FAULT_INJECTION
1005 struct f2fs_fault_info ffi = sbi->fault_info;
1006#endif
1004 1007
1005 /* 1008 /*
1006 * Save the old mount options in case we 1009 * Save the old mount options in case we
@@ -1096,6 +1099,9 @@ restore_gc:
1096restore_opts: 1099restore_opts:
1097 sbi->mount_opt = org_mount_opt; 1100 sbi->mount_opt = org_mount_opt;
1098 sbi->active_logs = active_logs; 1101 sbi->active_logs = active_logs;
1102#ifdef CONFIG_F2FS_FAULT_INJECTION
1103 sbi->fault_info = ffi;
1104#endif
1099 return err; 1105 return err;
1100} 1106}
1101 1107
@@ -1469,6 +1475,7 @@ static void init_sb_info(struct f2fs_sb_info *sbi)
1469 mutex_init(&sbi->umount_mutex); 1475 mutex_init(&sbi->umount_mutex);
1470 mutex_init(&sbi->wio_mutex[NODE]); 1476 mutex_init(&sbi->wio_mutex[NODE]);
1471 mutex_init(&sbi->wio_mutex[DATA]); 1477 mutex_init(&sbi->wio_mutex[DATA]);
1478 spin_lock_init(&sbi->cp_lock);
1472 1479
1473#ifdef CONFIG_F2FS_FS_ENCRYPTION 1480#ifdef CONFIG_F2FS_FS_ENCRYPTION
1474 memcpy(sbi->key_prefix, F2FS_KEY_DESC_PREFIX, 1481 memcpy(sbi->key_prefix, F2FS_KEY_DESC_PREFIX,
@@ -1810,7 +1817,7 @@ try_onemore:
1810 * previous checkpoint was not done by clean system shutdown. 1817 * previous checkpoint was not done by clean system shutdown.
1811 */ 1818 */
1812 if (bdev_read_only(sb->s_bdev) && 1819 if (bdev_read_only(sb->s_bdev) &&
1813 !is_set_ckpt_flags(sbi->ckpt, CP_UMOUNT_FLAG)) { 1820 !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) {
1814 err = -EROFS; 1821 err = -EROFS;
1815 goto free_kobj; 1822 goto free_kobj;
1816 } 1823 }
@@ -1818,6 +1825,9 @@ try_onemore:
1818 if (need_fsck) 1825 if (need_fsck)
1819 set_sbi_flag(sbi, SBI_NEED_FSCK); 1826 set_sbi_flag(sbi, SBI_NEED_FSCK);
1820 1827
1828 if (!retry)
1829 goto skip_recovery;
1830
1821 err = recover_fsync_data(sbi, false); 1831 err = recover_fsync_data(sbi, false);
1822 if (err < 0) { 1832 if (err < 0) {
1823 need_fsck = true; 1833 need_fsck = true;
@@ -1835,7 +1845,7 @@ try_onemore:
1835 goto free_kobj; 1845 goto free_kobj;
1836 } 1846 }
1837 } 1847 }
1838 1848skip_recovery:
1839 /* recover_fsync_data() cleared this already */ 1849 /* recover_fsync_data() cleared this already */
1840 clear_sbi_flag(sbi, SBI_POR_DOING); 1850 clear_sbi_flag(sbi, SBI_POR_DOING);
1841 1851
@@ -1879,7 +1889,9 @@ free_root_inode:
1879 dput(sb->s_root); 1889 dput(sb->s_root);
1880 sb->s_root = NULL; 1890 sb->s_root = NULL;
1881free_node_inode: 1891free_node_inode:
1892 truncate_inode_pages_final(NODE_MAPPING(sbi));
1882 mutex_lock(&sbi->umount_mutex); 1893 mutex_lock(&sbi->umount_mutex);
1894 release_ino_entry(sbi, true);
1883 f2fs_leave_shrinker(sbi); 1895 f2fs_leave_shrinker(sbi);
1884 iput(sbi->node_inode); 1896 iput(sbi->node_inode);
1885 mutex_unlock(&sbi->umount_mutex); 1897 mutex_unlock(&sbi->umount_mutex);
@@ -1978,16 +1990,6 @@ static int __init init_f2fs_fs(void)
1978 err = -ENOMEM; 1990 err = -ENOMEM;
1979 goto free_extent_cache; 1991 goto free_extent_cache;
1980 } 1992 }
1981#ifdef CONFIG_F2FS_FAULT_INJECTION
1982 f2fs_fault_inject.kset = f2fs_kset;
1983 f2fs_build_fault_attr(0);
1984 err = kobject_init_and_add(&f2fs_fault_inject, &f2fs_fault_ktype,
1985 NULL, "fault_injection");
1986 if (err) {
1987 f2fs_fault_inject.kset = NULL;
1988 goto free_kset;
1989 }
1990#endif
1991 err = register_shrinker(&f2fs_shrinker_info); 1993 err = register_shrinker(&f2fs_shrinker_info);
1992 if (err) 1994 if (err)
1993 goto free_kset; 1995 goto free_kset;
@@ -2006,10 +2008,6 @@ free_filesystem:
2006free_shrinker: 2008free_shrinker:
2007 unregister_shrinker(&f2fs_shrinker_info); 2009 unregister_shrinker(&f2fs_shrinker_info);
2008free_kset: 2010free_kset:
2009#ifdef CONFIG_F2FS_FAULT_INJECTION
2010 if (f2fs_fault_inject.kset)
2011 kobject_put(&f2fs_fault_inject);
2012#endif
2013 kset_unregister(f2fs_kset); 2011 kset_unregister(f2fs_kset);
2014free_extent_cache: 2012free_extent_cache:
2015 destroy_extent_cache(); 2013 destroy_extent_cache();
@@ -2031,9 +2029,6 @@ static void __exit exit_f2fs_fs(void)
2031 f2fs_destroy_root_stats(); 2029 f2fs_destroy_root_stats();
2032 unregister_filesystem(&f2fs_fs_type); 2030 unregister_filesystem(&f2fs_fs_type);
2033 unregister_shrinker(&f2fs_shrinker_info); 2031 unregister_shrinker(&f2fs_shrinker_info);
2034#ifdef CONFIG_F2FS_FAULT_INJECTION
2035 kobject_put(&f2fs_fault_inject);
2036#endif
2037 kset_unregister(f2fs_kset); 2032 kset_unregister(f2fs_kset);
2038 destroy_extent_cache(); 2033 destroy_extent_cache();
2039 destroy_checkpoint_caches(); 2034 destroy_checkpoint_caches();
diff --git a/fs/f2fs/xattr.c b/fs/f2fs/xattr.c
index c8898b5148eb..1f74876233b6 100644
--- a/fs/f2fs/xattr.c
+++ b/fs/f2fs/xattr.c
@@ -217,18 +217,20 @@ static struct f2fs_xattr_entry *__find_xattr(void *base_addr, int index,
217 return entry; 217 return entry;
218} 218}
219 219
220static void *read_all_xattrs(struct inode *inode, struct page *ipage) 220static int read_all_xattrs(struct inode *inode, struct page *ipage,
221 void **base_addr)
221{ 222{
222 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 223 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
223 struct f2fs_xattr_header *header; 224 struct f2fs_xattr_header *header;
224 size_t size = PAGE_SIZE, inline_size = 0; 225 size_t size = PAGE_SIZE, inline_size = 0;
225 void *txattr_addr; 226 void *txattr_addr;
227 int err;
226 228
227 inline_size = inline_xattr_size(inode); 229 inline_size = inline_xattr_size(inode);
228 230
229 txattr_addr = kzalloc(inline_size + size, GFP_F2FS_ZERO); 231 txattr_addr = kzalloc(inline_size + size, GFP_F2FS_ZERO);
230 if (!txattr_addr) 232 if (!txattr_addr)
231 return NULL; 233 return -ENOMEM;
232 234
233 /* read from inline xattr */ 235 /* read from inline xattr */
234 if (inline_size) { 236 if (inline_size) {
@@ -239,8 +241,10 @@ static void *read_all_xattrs(struct inode *inode, struct page *ipage)
239 inline_addr = inline_xattr_addr(ipage); 241 inline_addr = inline_xattr_addr(ipage);
240 } else { 242 } else {
241 page = get_node_page(sbi, inode->i_ino); 243 page = get_node_page(sbi, inode->i_ino);
242 if (IS_ERR(page)) 244 if (IS_ERR(page)) {
245 err = PTR_ERR(page);
243 goto fail; 246 goto fail;
247 }
244 inline_addr = inline_xattr_addr(page); 248 inline_addr = inline_xattr_addr(page);
245 } 249 }
246 memcpy(txattr_addr, inline_addr, inline_size); 250 memcpy(txattr_addr, inline_addr, inline_size);
@@ -254,8 +258,10 @@ static void *read_all_xattrs(struct inode *inode, struct page *ipage)
254 258
255 /* The inode already has an extended attribute block. */ 259 /* The inode already has an extended attribute block. */
256 xpage = get_node_page(sbi, F2FS_I(inode)->i_xattr_nid); 260 xpage = get_node_page(sbi, F2FS_I(inode)->i_xattr_nid);
257 if (IS_ERR(xpage)) 261 if (IS_ERR(xpage)) {
262 err = PTR_ERR(xpage);
258 goto fail; 263 goto fail;
264 }
259 265
260 xattr_addr = page_address(xpage); 266 xattr_addr = page_address(xpage);
261 memcpy(txattr_addr + inline_size, xattr_addr, PAGE_SIZE); 267 memcpy(txattr_addr + inline_size, xattr_addr, PAGE_SIZE);
@@ -269,10 +275,11 @@ static void *read_all_xattrs(struct inode *inode, struct page *ipage)
269 header->h_magic = cpu_to_le32(F2FS_XATTR_MAGIC); 275 header->h_magic = cpu_to_le32(F2FS_XATTR_MAGIC);
270 header->h_refcount = cpu_to_le32(1); 276 header->h_refcount = cpu_to_le32(1);
271 } 277 }
272 return txattr_addr; 278 *base_addr = txattr_addr;
279 return 0;
273fail: 280fail:
274 kzfree(txattr_addr); 281 kzfree(txattr_addr);
275 return NULL; 282 return err;
276} 283}
277 284
278static inline int write_all_xattrs(struct inode *inode, __u32 hsize, 285static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
@@ -366,9 +373,9 @@ int f2fs_getxattr(struct inode *inode, int index, const char *name,
366 if (len > F2FS_NAME_LEN) 373 if (len > F2FS_NAME_LEN)
367 return -ERANGE; 374 return -ERANGE;
368 375
369 base_addr = read_all_xattrs(inode, ipage); 376 error = read_all_xattrs(inode, ipage, &base_addr);
370 if (!base_addr) 377 if (error)
371 return -ENOMEM; 378 return error;
372 379
373 entry = __find_xattr(base_addr, index, len, name); 380 entry = __find_xattr(base_addr, index, len, name);
374 if (IS_XATTR_LAST_ENTRY(entry)) { 381 if (IS_XATTR_LAST_ENTRY(entry)) {
@@ -402,9 +409,9 @@ ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
402 int error = 0; 409 int error = 0;
403 size_t rest = buffer_size; 410 size_t rest = buffer_size;
404 411
405 base_addr = read_all_xattrs(inode, NULL); 412 error = read_all_xattrs(inode, NULL, &base_addr);
406 if (!base_addr) 413 if (error)
407 return -ENOMEM; 414 return error;
408 415
409 list_for_each_xattr(entry, base_addr) { 416 list_for_each_xattr(entry, base_addr) {
410 const struct xattr_handler *handler = 417 const struct xattr_handler *handler =
@@ -463,9 +470,9 @@ static int __f2fs_setxattr(struct inode *inode, int index,
463 if (size > MAX_VALUE_LEN(inode)) 470 if (size > MAX_VALUE_LEN(inode))
464 return -E2BIG; 471 return -E2BIG;
465 472
466 base_addr = read_all_xattrs(inode, ipage); 473 error = read_all_xattrs(inode, ipage, &base_addr);
467 if (!base_addr) 474 if (error)
468 return -ENOMEM; 475 return error;
469 476
470 /* find entry with wanted name. */ 477 /* find entry with wanted name. */
471 here = __find_xattr(base_addr, index, len, name); 478 here = __find_xattr(base_addr, index, len, name);
@@ -548,6 +555,8 @@ static int __f2fs_setxattr(struct inode *inode, int index,
548 !strcmp(name, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT)) 555 !strcmp(name, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT))
549 f2fs_set_encrypted_inode(inode); 556 f2fs_set_encrypted_inode(inode);
550 f2fs_mark_inode_dirty_sync(inode); 557 f2fs_mark_inode_dirty_sync(inode);
558 if (!error && S_ISDIR(inode->i_mode))
559 set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_CP);
551exit: 560exit:
552 kzfree(base_addr); 561 kzfree(base_addr);
553 return error; 562 return error;
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index 4c02c6521fef..422630b8e588 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -100,6 +100,7 @@ struct f2fs_super_block {
100/* 100/*
101 * For checkpoint 101 * For checkpoint
102 */ 102 */
103#define CP_CRC_RECOVERY_FLAG 0x00000040
103#define CP_FASTBOOT_FLAG 0x00000020 104#define CP_FASTBOOT_FLAG 0x00000020
104#define CP_FSCK_FLAG 0x00000010 105#define CP_FSCK_FLAG 0x00000010
105#define CP_ERROR_FLAG 0x00000008 106#define CP_ERROR_FLAG 0x00000008
diff --git a/include/trace/events/f2fs.h b/include/trace/events/f2fs.h
index ff95fd02116f..903a09165bb1 100644
--- a/include/trace/events/f2fs.h
+++ b/include/trace/events/f2fs.h
@@ -58,16 +58,12 @@ TRACE_DEFINE_ENUM(CP_DISCARD);
58#define F2FS_BIO_FLAG_MASK(t) (t & (REQ_RAHEAD | WRITE_FLUSH_FUA)) 58#define F2FS_BIO_FLAG_MASK(t) (t & (REQ_RAHEAD | WRITE_FLUSH_FUA))
59#define F2FS_BIO_EXTRA_MASK(t) (t & (REQ_META | REQ_PRIO)) 59#define F2FS_BIO_EXTRA_MASK(t) (t & (REQ_META | REQ_PRIO))
60 60
61#define show_bio_type(op, op_flags) show_bio_op(op), \ 61#define show_bio_type(op_flags) show_bio_op_flags(op_flags), \
62 show_bio_op_flags(op_flags), show_bio_extra(op_flags) 62 show_bio_extra(op_flags)
63
64#define show_bio_op(op) \
65 __print_symbolic(op, \
66 { READ, "READ" }, \
67 { WRITE, "WRITE" })
68 63
69#define show_bio_op_flags(flags) \ 64#define show_bio_op_flags(flags) \
70 __print_symbolic(F2FS_BIO_FLAG_MASK(flags), \ 65 __print_symbolic(F2FS_BIO_FLAG_MASK(flags), \
66 { 0, "WRITE" }, \
71 { REQ_RAHEAD, "READAHEAD" }, \ 67 { REQ_RAHEAD, "READAHEAD" }, \
72 { READ_SYNC, "READ_SYNC" }, \ 68 { READ_SYNC, "READ_SYNC" }, \
73 { WRITE_SYNC, "WRITE_SYNC" }, \ 69 { WRITE_SYNC, "WRITE_SYNC" }, \
@@ -754,12 +750,12 @@ DECLARE_EVENT_CLASS(f2fs__submit_page_bio,
754 ), 750 ),
755 751
756 TP_printk("dev = (%d,%d), ino = %lu, page_index = 0x%lx, " 752 TP_printk("dev = (%d,%d), ino = %lu, page_index = 0x%lx, "
757 "oldaddr = 0x%llx, newaddr = 0x%llx rw = %s%si%s, type = %s", 753 "oldaddr = 0x%llx, newaddr = 0x%llx, rw = %s%s, type = %s",
758 show_dev_ino(__entry), 754 show_dev_ino(__entry),
759 (unsigned long)__entry->index, 755 (unsigned long)__entry->index,
760 (unsigned long long)__entry->old_blkaddr, 756 (unsigned long long)__entry->old_blkaddr,
761 (unsigned long long)__entry->new_blkaddr, 757 (unsigned long long)__entry->new_blkaddr,
762 show_bio_type(__entry->op, __entry->op_flags), 758 show_bio_type(__entry->op_flags),
763 show_block_type(__entry->type)) 759 show_block_type(__entry->type))
764); 760);
765 761
@@ -806,9 +802,9 @@ DECLARE_EVENT_CLASS(f2fs__submit_bio,
806 __entry->size = bio->bi_iter.bi_size; 802 __entry->size = bio->bi_iter.bi_size;
807 ), 803 ),
808 804
809 TP_printk("dev = (%d,%d), %s%s%s, %s, sector = %lld, size = %u", 805 TP_printk("dev = (%d,%d), rw = %s%s, %s, sector = %lld, size = %u",
810 show_dev(__entry), 806 show_dev(__entry),
811 show_bio_type(__entry->op, __entry->op_flags), 807 show_bio_type(__entry->op_flags),
812 show_block_type(__entry->type), 808 show_block_type(__entry->type),
813 (unsigned long long)__entry->sector, 809 (unsigned long long)__entry->sector,
814 __entry->size) 810 __entry->size)
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-10 16:54:50 -0400