aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2016-07-27 13:36:31 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2016-07-27 13:36:31 -0400
commit4fc29c1aa375353ffe7c8fa171bf941b71ce29ef (patch)
tree5d4fa5f8c95831655cb89f1a37c0ea5daf847fbd
parent0e6acf0204da5b8705722a5f6806a4f55ed379d6 (diff)
parent5302fb000def84100740a84d7f176c0e167b2141 (diff)
Merge tag 'for-f2fs-4.8' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs
Pull f2fs updates from Jaegeuk Kim: "The major change in this version is mitigating cpu overheads on write paths by replacing redundant inode page updates with mark_inode_dirty calls. And we tried to reduce lock contentions as well to improve filesystem scalability. Other feature is setting F2FS automatically when detecting host-managed SMR. Enhancements: - ioctl to move a range of data between files - inject orphan inode errors - avoid flush commands congestion - support lazytime Bug fixes: - return proper results for some dentry operations - fix deadlock in add_link failure - disable extent_cache for fcollapse/finsert" * tag 'for-f2fs-4.8' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (68 commits) f2fs: clean up coding style and redundancy f2fs: get victim segment again after new cp f2fs: handle error case with f2fs_bug_on f2fs: avoid data race when deciding checkpoin in f2fs_sync_file f2fs: support an ioctl to move a range of data blocks f2fs: fix to report error number of f2fs_find_entry f2fs: avoid memory allocation failure due to a long length f2fs: reset default idle interval value f2fs: use blk_plug in all the possible paths f2fs: fix to avoid data update racing between GC and DIO f2fs: add maximum prefree segments f2fs: disable extent_cache for fcollapse/finsert inodes f2fs: refactor __exchange_data_block for speed up f2fs: fix ERR_PTR returned by bio f2fs: avoid mark_inode_dirty f2fs: move i_size_write in f2fs_write_end f2fs: fix to avoid redundant discard during fstrim f2fs: avoid mismatching block range for discard f2fs: fix incorrect f_bfree calculation in ->statfs f2fs: use percpu_rw_semaphore ...
Diffstat
-rw-r--r--Documentation/filesystems/f2fs.txt7
-rw-r--r--fs/f2fs/acl.c9
-rw-r--r--fs/f2fs/acl.h2
-rw-r--r--fs/f2fs/checkpoint.c80
-rw-r--r--fs/f2fs/data.c311
-rw-r--r--fs/f2fs/debug.c5
-rw-r--r--fs/f2fs/dir.c123
-rw-r--r--fs/f2fs/extent_cache.c50
-rw-r--r--fs/f2fs/f2fs.h286
-rw-r--r--fs/f2fs/file.c499
-rw-r--r--fs/f2fs/gc.c52
-rw-r--r--fs/f2fs/inline.c92
-rw-r--r--fs/f2fs/inode.c53
-rw-r--r--fs/f2fs/namei.c147
-rw-r--r--fs/f2fs/node.c144
-rw-r--r--fs/f2fs/node.h14
-rw-r--r--fs/f2fs/recovery.c23
-rw-r--r--fs/f2fs/segment.c59
-rw-r--r--fs/f2fs/segment.h22
-rw-r--r--fs/f2fs/shrinker.c5
-rw-r--r--fs/f2fs/super.c134
-rw-r--r--fs/f2fs/xattr.c20
22 files changed, 1387 insertions, 750 deletions
diff --git a/Documentation/filesystems/f2fs.txt b/Documentation/filesystems/f2fs.txt
index e1c9f0849da6..ecd808088362 100644
--- a/Documentation/filesystems/f2fs.txt
+++ b/Documentation/filesystems/f2fs.txt
@@ -109,7 +109,9 @@ background_gc=%s Turn on/off cleaning operations, namely garbage
109disable_roll_forward Disable the roll-forward recovery routine 109disable_roll_forward Disable the roll-forward recovery routine
110norecovery Disable the roll-forward recovery routine, mounted read- 110norecovery Disable the roll-forward recovery routine, mounted read-
111 only (i.e., -o ro,disable_roll_forward) 111 only (i.e., -o ro,disable_roll_forward)
112discard Issue discard/TRIM commands when a segment is cleaned. 112discard/nodiscard Enable/disable real-time discard in f2fs, if discard is
113 enabled, f2fs will issue discard/TRIM commands when a
114 segment is cleaned.
113no_heap Disable heap-style segment allocation which finds free 115no_heap Disable heap-style segment allocation which finds free
114 segments for data from the beginning of main area, while 116 segments for data from the beginning of main area, while
115 for node from the end of main area. 117 for node from the end of main area.
@@ -151,6 +153,9 @@ noinline_data Disable the inline data feature, inline data feature is
151 enabled by default. 153 enabled by default.
152data_flush Enable data flushing before checkpoint in order to 154data_flush Enable data flushing before checkpoint in order to
153 persist data of regular and symlink. 155 persist data of regular and symlink.
156mode=%s Control block allocation mode which supports "adaptive"
157 and "lfs". In "lfs" mode, there should be no random
158 writes towards main area.
154 159
155================================================================================ 160================================================================================
156DEBUGFS ENTRIES 161DEBUGFS ENTRIES
diff --git a/fs/f2fs/acl.c b/fs/f2fs/acl.c
index a31c7e859af6..4dcc9e28dc5c 100644
--- a/fs/f2fs/acl.c
+++ b/fs/f2fs/acl.c
@@ -201,7 +201,6 @@ struct posix_acl *f2fs_get_acl(struct inode *inode, int type)
201static int __f2fs_set_acl(struct inode *inode, int type, 201static int __f2fs_set_acl(struct inode *inode, int type,
202 struct posix_acl *acl, struct page *ipage) 202 struct posix_acl *acl, struct page *ipage)
203{ 203{
204 struct f2fs_inode_info *fi = F2FS_I(inode);
205 int name_index; 204 int name_index;
206 void *value = NULL; 205 void *value = NULL;
207 size_t size = 0; 206 size_t size = 0;
@@ -214,7 +213,7 @@ static int __f2fs_set_acl(struct inode *inode, int type,
214 error = posix_acl_equiv_mode(acl, &inode->i_mode); 213 error = posix_acl_equiv_mode(acl, &inode->i_mode);
215 if (error < 0) 214 if (error < 0)
216 return error; 215 return error;
217 set_acl_inode(fi, inode->i_mode); 216 set_acl_inode(inode, inode->i_mode);
218 if (error == 0) 217 if (error == 0)
219 acl = NULL; 218 acl = NULL;
220 } 219 }
@@ -233,7 +232,7 @@ static int __f2fs_set_acl(struct inode *inode, int type,
233 if (acl) { 232 if (acl) {
234 value = f2fs_acl_to_disk(acl, &size); 233 value = f2fs_acl_to_disk(acl, &size);
235 if (IS_ERR(value)) { 234 if (IS_ERR(value)) {
236 clear_inode_flag(fi, FI_ACL_MODE); 235 clear_inode_flag(inode, FI_ACL_MODE);
237 return (int)PTR_ERR(value); 236 return (int)PTR_ERR(value);
238 } 237 }
239 } 238 }
@@ -244,7 +243,7 @@ static int __f2fs_set_acl(struct inode *inode, int type,
244 if (!error) 243 if (!error)
245 set_cached_acl(inode, type, acl); 244 set_cached_acl(inode, type, acl);
246 245
247 clear_inode_flag(fi, FI_ACL_MODE); 246 clear_inode_flag(inode, FI_ACL_MODE);
248 return error; 247 return error;
249} 248}
250 249
@@ -385,6 +384,8 @@ int f2fs_init_acl(struct inode *inode, struct inode *dir, struct page *ipage,
385 if (error) 384 if (error)
386 return error; 385 return error;
387 386
387 f2fs_mark_inode_dirty_sync(inode);
388
388 if (default_acl) { 389 if (default_acl) {
389 error = __f2fs_set_acl(inode, ACL_TYPE_DEFAULT, default_acl, 390 error = __f2fs_set_acl(inode, ACL_TYPE_DEFAULT, default_acl,
390 ipage); 391 ipage);
diff --git a/fs/f2fs/acl.h b/fs/f2fs/acl.h
index 997ca8edb6cb..b2334d11dae8 100644
--- a/fs/f2fs/acl.h
+++ b/fs/f2fs/acl.h
@@ -37,7 +37,7 @@ struct f2fs_acl_header {
37#ifdef CONFIG_F2FS_FS_POSIX_ACL 37#ifdef CONFIG_F2FS_FS_POSIX_ACL
38 38
39extern struct posix_acl *f2fs_get_acl(struct inode *, int); 39extern struct posix_acl *f2fs_get_acl(struct inode *, int);
40extern int f2fs_set_acl(struct inode *inode, struct posix_acl *acl, int type); 40extern 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
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index 124b4a3017b5..f94d01e7d001 100644
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -48,7 +48,8 @@ repeat:
48 goto repeat; 48 goto repeat;
49 } 49 }
50 f2fs_wait_on_page_writeback(page, META, true); 50 f2fs_wait_on_page_writeback(page, META, true);
51 SetPageUptodate(page); 51 if (!PageUptodate(page))
52 SetPageUptodate(page);
52 return page; 53 return page;
53} 54}
54 55
@@ -266,6 +267,7 @@ static int f2fs_write_meta_pages(struct address_space *mapping,
266 struct writeback_control *wbc) 267 struct writeback_control *wbc)
267{ 268{
268 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping); 269 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
270 struct blk_plug plug;
269 long diff, written; 271 long diff, written;
270 272
271 /* collect a number of dirty meta pages and write together */ 273 /* collect a number of dirty meta pages and write together */
@@ -278,7 +280,9 @@ static int f2fs_write_meta_pages(struct address_space *mapping,
278 /* if mounting is failed, skip writing node pages */ 280 /* if mounting is failed, skip writing node pages */
279 mutex_lock(&sbi->cp_mutex); 281 mutex_lock(&sbi->cp_mutex);
280 diff = nr_pages_to_write(sbi, META, wbc); 282 diff = nr_pages_to_write(sbi, META, wbc);
283 blk_start_plug(&plug);
281 written = sync_meta_pages(sbi, META, wbc->nr_to_write); 284 written = sync_meta_pages(sbi, META, wbc->nr_to_write);
285 blk_finish_plug(&plug);
282 mutex_unlock(&sbi->cp_mutex); 286 mutex_unlock(&sbi->cp_mutex);
283 wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff); 287 wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff);
284 return 0; 288 return 0;
@@ -366,9 +370,10 @@ static int f2fs_set_meta_page_dirty(struct page *page)
366{ 370{
367 trace_f2fs_set_page_dirty(page, META); 371 trace_f2fs_set_page_dirty(page, META);
368 372
369 SetPageUptodate(page); 373 if (!PageUptodate(page))
374 SetPageUptodate(page);
370 if (!PageDirty(page)) { 375 if (!PageDirty(page)) {
371 __set_page_dirty_nobuffers(page); 376 f2fs_set_page_dirty_nobuffers(page);
372 inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_META); 377 inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_META);
373 SetPagePrivate(page); 378 SetPagePrivate(page);
374 f2fs_trace_pid(page); 379 f2fs_trace_pid(page);
@@ -510,10 +515,11 @@ void release_orphan_inode(struct f2fs_sb_info *sbi)
510 spin_unlock(&im->ino_lock); 515 spin_unlock(&im->ino_lock);
511} 516}
512 517
513void add_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 518void add_orphan_inode(struct inode *inode)
514{ 519{
515 /* add new orphan ino entry into list */ 520 /* add new orphan ino entry into list */
516 __add_ino_entry(sbi, ino, ORPHAN_INO); 521 __add_ino_entry(F2FS_I_SB(inode), inode->i_ino, ORPHAN_INO);
522 update_inode_page(inode);
517} 523}
518 524
519void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 525void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
@@ -761,28 +767,25 @@ fail_no_cp:
761static void __add_dirty_inode(struct inode *inode, enum inode_type type) 767static void __add_dirty_inode(struct inode *inode, enum inode_type type)
762{ 768{
763 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 769 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
764 struct f2fs_inode_info *fi = F2FS_I(inode);
765 int flag = (type == DIR_INODE) ? FI_DIRTY_DIR : FI_DIRTY_FILE; 770 int flag = (type == DIR_INODE) ? FI_DIRTY_DIR : FI_DIRTY_FILE;
766 771
767 if (is_inode_flag_set(fi, flag)) 772 if (is_inode_flag_set(inode, flag))
768 return; 773 return;
769 774
770 set_inode_flag(fi, flag); 775 set_inode_flag(inode, flag);
771 list_add_tail(&fi->dirty_list, &sbi->inode_list[type]); 776 list_add_tail(&F2FS_I(inode)->dirty_list, &sbi->inode_list[type]);
772 stat_inc_dirty_inode(sbi, type); 777 stat_inc_dirty_inode(sbi, type);
773} 778}
774 779
775static void __remove_dirty_inode(struct inode *inode, enum inode_type type) 780static void __remove_dirty_inode(struct inode *inode, enum inode_type type)
776{ 781{
777 struct f2fs_inode_info *fi = F2FS_I(inode);
778 int flag = (type == DIR_INODE) ? FI_DIRTY_DIR : FI_DIRTY_FILE; 782 int flag = (type == DIR_INODE) ? FI_DIRTY_DIR : FI_DIRTY_FILE;
779 783
780 if (get_dirty_pages(inode) || 784 if (get_dirty_pages(inode) || !is_inode_flag_set(inode, flag))
781 !is_inode_flag_set(F2FS_I(inode), flag))
782 return; 785 return;
783 786
784 list_del_init(&fi->dirty_list); 787 list_del_init(&F2FS_I(inode)->dirty_list);
785 clear_inode_flag(fi, flag); 788 clear_inode_flag(inode, flag);
786 stat_dec_dirty_inode(F2FS_I_SB(inode), type); 789 stat_dec_dirty_inode(F2FS_I_SB(inode), type);
787} 790}
788 791
@@ -795,13 +798,12 @@ void update_dirty_page(struct inode *inode, struct page *page)
795 !S_ISLNK(inode->i_mode)) 798 !S_ISLNK(inode->i_mode))
796 return; 799 return;
797 800
798 if (type != FILE_INODE || test_opt(sbi, DATA_FLUSH)) { 801 spin_lock(&sbi->inode_lock[type]);
799 spin_lock(&sbi->inode_lock[type]); 802 if (type != FILE_INODE || test_opt(sbi, DATA_FLUSH))
800 __add_dirty_inode(inode, type); 803 __add_dirty_inode(inode, type);
801 spin_unlock(&sbi->inode_lock[type]);
802 }
803
804 inode_inc_dirty_pages(inode); 804 inode_inc_dirty_pages(inode);
805 spin_unlock(&sbi->inode_lock[type]);
806
805 SetPagePrivate(page); 807 SetPagePrivate(page);
806 f2fs_trace_pid(page); 808 f2fs_trace_pid(page);
807} 809}
@@ -864,6 +866,34 @@ retry:
864 goto retry; 866 goto retry;
865} 867}
866 868
869int f2fs_sync_inode_meta(struct f2fs_sb_info *sbi)
870{
871 struct list_head *head = &sbi->inode_list[DIRTY_META];
872 struct inode *inode;
873 struct f2fs_inode_info *fi;
874 s64 total = get_pages(sbi, F2FS_DIRTY_IMETA);
875
876 while (total--) {
877 if (unlikely(f2fs_cp_error(sbi)))
878 return -EIO;
879
880 spin_lock(&sbi->inode_lock[DIRTY_META]);
881 if (list_empty(head)) {
882 spin_unlock(&sbi->inode_lock[DIRTY_META]);
883 return 0;
884 }
885 fi = list_entry(head->next, struct f2fs_inode_info,
886 gdirty_list);
887 inode = igrab(&fi->vfs_inode);
888 spin_unlock(&sbi->inode_lock[DIRTY_META]);
889 if (inode) {
890 update_inode_page(inode);
891 iput(inode);
892 }
893 };
894 return 0;
895}
896
867/* 897/*
868 * Freeze all the FS-operations for checkpoint. 898 * Freeze all the FS-operations for checkpoint.
869 */ 899 */
@@ -890,6 +920,14 @@ retry_flush_dents:
890 goto retry_flush_dents; 920 goto retry_flush_dents;
891 } 921 }
892 922
923 if (get_pages(sbi, F2FS_DIRTY_IMETA)) {
924 f2fs_unlock_all(sbi);
925 err = f2fs_sync_inode_meta(sbi);
926 if (err)
927 goto out;
928 goto retry_flush_dents;
929 }
930
893 /* 931 /*
894 * POR: we should ensure that there are no dirty node pages 932 * POR: we should ensure that there are no dirty node pages
895 * until finishing nat/sit flush. 933 * until finishing nat/sit flush.
@@ -914,6 +952,8 @@ out:
914static void unblock_operations(struct f2fs_sb_info *sbi) 952static void unblock_operations(struct f2fs_sb_info *sbi)
915{ 953{
916 up_write(&sbi->node_write); 954 up_write(&sbi->node_write);
955
956 build_free_nids(sbi);
917 f2fs_unlock_all(sbi); 957 f2fs_unlock_all(sbi);
918} 958}
919 959
@@ -954,7 +994,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
954 * This avoids to conduct wrong roll-forward operations and uses 994 * This avoids to conduct wrong roll-forward operations and uses
955 * metapages, so should be called prior to sync_meta_pages below. 995 * metapages, so should be called prior to sync_meta_pages below.
956 */ 996 */
957 if (discard_next_dnode(sbi, discard_blk)) 997 if (!test_opt(sbi, LFS) && discard_next_dnode(sbi, discard_blk))
958 invalidate = true; 998 invalidate = true;
959 999
960 /* Flush all the NAT/SIT pages */ 1000 /* Flush all the NAT/SIT pages */
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index ded224518978..e2624275d828 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -19,6 +19,8 @@
19#include <linux/bio.h> 19#include <linux/bio.h>
20#include <linux/prefetch.h> 20#include <linux/prefetch.h>
21#include <linux/uio.h> 21#include <linux/uio.h>
22#include <linux/mm.h>
23#include <linux/memcontrol.h>
22#include <linux/cleancache.h> 24#include <linux/cleancache.h>
23 25
24#include "f2fs.h" 26#include "f2fs.h"
@@ -45,7 +47,8 @@ static void f2fs_read_end_io(struct bio *bio)
45 struct page *page = bvec->bv_page; 47 struct page *page = bvec->bv_page;
46 48
47 if (!bio->bi_error) { 49 if (!bio->bi_error) {
48 SetPageUptodate(page); 50 if (!PageUptodate(page))
51 SetPageUptodate(page);
49 } else { 52 } else {
50 ClearPageUptodate(page); 53 ClearPageUptodate(page);
51 SetPageError(page); 54 SetPageError(page);
@@ -97,10 +100,15 @@ static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr,
97 return bio; 100 return bio;
98} 101}
99 102
100static inline void __submit_bio(struct f2fs_sb_info *sbi, struct bio *bio) 103static inline void __submit_bio(struct f2fs_sb_info *sbi,
104 struct bio *bio, enum page_type type)
101{ 105{
102 if (!is_read_io(bio_op(bio))) 106 if (!is_read_io(bio_op(bio))) {
103 atomic_inc(&sbi->nr_wb_bios); 107 atomic_inc(&sbi->nr_wb_bios);
108 if (f2fs_sb_mounted_hmsmr(sbi->sb) &&
109 current->plug && (type == DATA || type == NODE))
110 blk_finish_plug(current->plug);
111 }
104 submit_bio(bio); 112 submit_bio(bio);
105} 113}
106 114
@@ -118,7 +126,7 @@ static void __submit_merged_bio(struct f2fs_bio_info *io)
118 126
119 bio_set_op_attrs(io->bio, fio->op, fio->op_flags); 127 bio_set_op_attrs(io->bio, fio->op, fio->op_flags);
120 128
121 __submit_bio(io->sbi, io->bio); 129 __submit_bio(io->sbi, io->bio, fio->type);
122 io->bio = NULL; 130 io->bio = NULL;
123} 131}
124 132
@@ -240,7 +248,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio)
240 bio->bi_rw = fio->op_flags; 248 bio->bi_rw = fio->op_flags;
241 bio_set_op_attrs(bio, fio->op, fio->op_flags); 249 bio_set_op_attrs(bio, fio->op, fio->op_flags);
242 250
243 __submit_bio(fio->sbi, bio); 251 __submit_bio(fio->sbi, bio, fio->type);
244 return 0; 252 return 0;
245} 253}
246 254
@@ -326,7 +334,7 @@ int reserve_new_blocks(struct dnode_of_data *dn, blkcnt_t count)
326 if (!count) 334 if (!count)
327 return 0; 335 return 0;
328 336
329 if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC))) 337 if (unlikely(is_inode_flag_set(dn->inode, FI_NO_ALLOC)))
330 return -EPERM; 338 return -EPERM;
331 if (unlikely(!inc_valid_block_count(sbi, dn->inode, &count))) 339 if (unlikely(!inc_valid_block_count(sbi, dn->inode, &count)))
332 return -ENOSPC; 340 return -ENOSPC;
@@ -348,9 +356,6 @@ int reserve_new_blocks(struct dnode_of_data *dn, blkcnt_t count)
348 356
349 if (set_page_dirty(dn->node_page)) 357 if (set_page_dirty(dn->node_page))
350 dn->node_changed = true; 358 dn->node_changed = true;
351
352 mark_inode_dirty(dn->inode);
353 sync_inode_page(dn);
354 return 0; 359 return 0;
355} 360}
356 361
@@ -446,7 +451,8 @@ got_it:
446 */ 451 */
447 if (dn.data_blkaddr == NEW_ADDR) { 452 if (dn.data_blkaddr == NEW_ADDR) {
448 zero_user_segment(page, 0, PAGE_SIZE); 453 zero_user_segment(page, 0, PAGE_SIZE);
449 SetPageUptodate(page); 454 if (!PageUptodate(page))
455 SetPageUptodate(page);
450 unlock_page(page); 456 unlock_page(page);
451 return page; 457 return page;
452 } 458 }
@@ -505,14 +511,14 @@ repeat:
505 511
506 /* wait for read completion */ 512 /* wait for read completion */
507 lock_page(page); 513 lock_page(page);
508 if (unlikely(!PageUptodate(page))) {
509 f2fs_put_page(page, 1);
510 return ERR_PTR(-EIO);
511 }
512 if (unlikely(page->mapping != mapping)) { 514 if (unlikely(page->mapping != mapping)) {
513 f2fs_put_page(page, 1); 515 f2fs_put_page(page, 1);
514 goto repeat; 516 goto repeat;
515 } 517 }
518 if (unlikely(!PageUptodate(page))) {
519 f2fs_put_page(page, 1);
520 return ERR_PTR(-EIO);
521 }
516 return page; 522 return page;
517} 523}
518 524
@@ -557,7 +563,8 @@ struct page *get_new_data_page(struct inode *inode,
557 563
558 if (dn.data_blkaddr == NEW_ADDR) { 564 if (dn.data_blkaddr == NEW_ADDR) {
559 zero_user_segment(page, 0, PAGE_SIZE); 565 zero_user_segment(page, 0, PAGE_SIZE);
560 SetPageUptodate(page); 566 if (!PageUptodate(page))
567 SetPageUptodate(page);
561 } else { 568 } else {
562 f2fs_put_page(page, 1); 569 f2fs_put_page(page, 1);
563 570
@@ -569,11 +576,8 @@ struct page *get_new_data_page(struct inode *inode,
569 } 576 }
570got_it: 577got_it:
571 if (new_i_size && i_size_read(inode) < 578 if (new_i_size && i_size_read(inode) <
572 ((loff_t)(index + 1) << PAGE_SHIFT)) { 579 ((loff_t)(index + 1) << PAGE_SHIFT))
573 i_size_write(inode, ((loff_t)(index + 1) << PAGE_SHIFT)); 580 f2fs_i_size_write(inode, ((loff_t)(index + 1) << PAGE_SHIFT));
574 /* Only the directory inode sets new_i_size */
575 set_inode_flag(F2FS_I(inode), FI_UPDATE_DIR);
576 }
577 return page; 581 return page;
578} 582}
579 583
@@ -586,7 +590,7 @@ static int __allocate_data_block(struct dnode_of_data *dn)
586 pgoff_t fofs; 590 pgoff_t fofs;
587 blkcnt_t count = 1; 591 blkcnt_t count = 1;
588 592
589 if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC))) 593 if (unlikely(is_inode_flag_set(dn->inode, FI_NO_ALLOC)))
590 return -EPERM; 594 return -EPERM;
591 595
592 dn->data_blkaddr = datablock_addr(dn->node_page, dn->ofs_in_node); 596 dn->data_blkaddr = datablock_addr(dn->node_page, dn->ofs_in_node);
@@ -611,7 +615,7 @@ alloc:
611 fofs = start_bidx_of_node(ofs_of_node(dn->node_page), dn->inode) + 615 fofs = start_bidx_of_node(ofs_of_node(dn->node_page), dn->inode) +
612 dn->ofs_in_node; 616 dn->ofs_in_node;
613 if (i_size_read(dn->inode) < ((loff_t)(fofs + 1) << PAGE_SHIFT)) 617 if (i_size_read(dn->inode) < ((loff_t)(fofs + 1) << PAGE_SHIFT))
614 i_size_write(dn->inode, 618 f2fs_i_size_write(dn->inode,
615 ((loff_t)(fofs + 1) << PAGE_SHIFT)); 619 ((loff_t)(fofs + 1) << PAGE_SHIFT));
616 return 0; 620 return 0;
617} 621}
@@ -660,7 +664,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
660 unsigned int maxblocks = map->m_len; 664 unsigned int maxblocks = map->m_len;
661 struct dnode_of_data dn; 665 struct dnode_of_data dn;
662 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 666 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
663 int mode = create ? ALLOC_NODE : LOOKUP_NODE_RA; 667 int mode = create ? ALLOC_NODE : LOOKUP_NODE;
664 pgoff_t pgofs, end_offset, end; 668 pgoff_t pgofs, end_offset, end;
665 int err = 0, ofs = 1; 669 int err = 0, ofs = 1;
666 unsigned int ofs_in_node, last_ofs_in_node; 670 unsigned int ofs_in_node, last_ofs_in_node;
@@ -723,8 +727,7 @@ next_block:
723 } else { 727 } else {
724 err = __allocate_data_block(&dn); 728 err = __allocate_data_block(&dn);
725 if (!err) { 729 if (!err) {
726 set_inode_flag(F2FS_I(inode), 730 set_inode_flag(inode, FI_APPEND_WRITE);
727 FI_APPEND_WRITE);
728 allocated = true; 731 allocated = true;
729 } 732 }
730 } 733 }
@@ -795,8 +798,6 @@ skip:
795 else if (dn.ofs_in_node < end_offset) 798 else if (dn.ofs_in_node < end_offset)
796 goto next_block; 799 goto next_block;
797 800
798 if (allocated)
799 sync_inode_page(&dn);
800 f2fs_put_dnode(&dn); 801 f2fs_put_dnode(&dn);
801 802
802 if (create) { 803 if (create) {
@@ -807,8 +808,6 @@ skip:
807 goto next_dnode; 808 goto next_dnode;
808 809
809sync_out: 810sync_out:
810 if (allocated)
811 sync_inode_page(&dn);
812 f2fs_put_dnode(&dn); 811 f2fs_put_dnode(&dn);
813unlock_out: 812unlock_out:
814 if (create) { 813 if (create) {
@@ -968,6 +967,37 @@ out:
968 return ret; 967 return ret;
969} 968}
970 969
970struct bio *f2fs_grab_bio(struct inode *inode, block_t blkaddr,
971 unsigned nr_pages)
972{
973 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
974 struct fscrypt_ctx *ctx = NULL;
975 struct block_device *bdev = sbi->sb->s_bdev;
976 struct bio *bio;
977
978 if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) {
979 ctx = fscrypt_get_ctx(inode, GFP_NOFS);
980 if (IS_ERR(ctx))
981 return ERR_CAST(ctx);
982
983 /* wait the page to be moved by cleaning */
984 f2fs_wait_on_encrypted_page_writeback(sbi, blkaddr);
985 }
986
987 bio = bio_alloc(GFP_KERNEL, min_t(int, nr_pages, BIO_MAX_PAGES));
988 if (!bio) {
989 if (ctx)
990 fscrypt_release_ctx(ctx);
991 return ERR_PTR(-ENOMEM);
992 }
993 bio->bi_bdev = bdev;
994 bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(blkaddr);
995 bio->bi_end_io = f2fs_read_end_io;
996 bio->bi_private = ctx;
997
998 return bio;
999}
1000
971/* 1001/*
972 * This function was originally taken from fs/mpage.c, and customized for f2fs. 1002 * This function was originally taken from fs/mpage.c, and customized for f2fs.
973 * Major change was from block_size == page_size in f2fs by default. 1003 * Major change was from block_size == page_size in f2fs by default.
@@ -986,7 +1016,6 @@ static int f2fs_mpage_readpages(struct address_space *mapping,
986 sector_t last_block; 1016 sector_t last_block;
987 sector_t last_block_in_file; 1017 sector_t last_block_in_file;
988 sector_t block_nr; 1018 sector_t block_nr;
989 struct block_device *bdev = inode->i_sb->s_bdev;
990 struct f2fs_map_blocks map; 1019 struct f2fs_map_blocks map;
991 1020
992 map.m_pblk = 0; 1021 map.m_pblk = 0;
@@ -1047,7 +1076,8 @@ got_it:
1047 } 1076 }
1048 } else { 1077 } else {
1049 zero_user_segment(page, 0, PAGE_SIZE); 1078 zero_user_segment(page, 0, PAGE_SIZE);
1050 SetPageUptodate(page); 1079 if (!PageUptodate(page))
1080 SetPageUptodate(page);
1051 unlock_page(page); 1081 unlock_page(page);
1052 goto next_page; 1082 goto next_page;
1053 } 1083 }
@@ -1058,35 +1088,15 @@ got_it:
1058 */ 1088 */
1059 if (bio && (last_block_in_bio != block_nr - 1)) { 1089 if (bio && (last_block_in_bio != block_nr - 1)) {
1060submit_and_realloc: 1090submit_and_realloc:
1061 __submit_bio(F2FS_I_SB(inode), bio); 1091 __submit_bio(F2FS_I_SB(inode), bio, DATA);
1062 bio = NULL; 1092 bio = NULL;
1063 } 1093 }
1064 if (bio == NULL) { 1094 if (bio == NULL) {
1065 struct fscrypt_ctx *ctx = NULL; 1095 bio = f2fs_grab_bio(inode, block_nr, nr_pages);
1066 1096 if (IS_ERR(bio)) {
1067 if (f2fs_encrypted_inode(inode) && 1097 bio = NULL;
1068 S_ISREG(inode->i_mode)) {
1069
1070 ctx = fscrypt_get_ctx(inode, GFP_NOFS);
1071 if (IS_ERR(ctx))
1072 goto set_error_page;
1073
1074 /* wait the page to be moved by cleaning */
1075 f2fs_wait_on_encrypted_page_writeback(
1076 F2FS_I_SB(inode), block_nr);
1077 }
1078
1079 bio = bio_alloc(GFP_KERNEL,
1080 min_t(int, nr_pages, BIO_MAX_PAGES));
1081 if (!bio) {
1082 if (ctx)
1083 fscrypt_release_ctx(ctx);
1084 goto set_error_page; 1098 goto set_error_page;
1085 } 1099 }
1086 bio->bi_bdev = bdev;
1087 bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(block_nr);
1088 bio->bi_end_io = f2fs_read_end_io;
1089 bio->bi_private = ctx;
1090 bio_set_op_attrs(bio, REQ_OP_READ, 0); 1100 bio_set_op_attrs(bio, REQ_OP_READ, 0);
1091 } 1101 }
1092 1102
@@ -1102,7 +1112,7 @@ set_error_page:
1102 goto next_page; 1112 goto next_page;
1103confused: 1113confused:
1104 if (bio) { 1114 if (bio) {
1105 __submit_bio(F2FS_I_SB(inode), bio); 1115 __submit_bio(F2FS_I_SB(inode), bio, DATA);
1106 bio = NULL; 1116 bio = NULL;
1107 } 1117 }
1108 unlock_page(page); 1118 unlock_page(page);
@@ -1112,7 +1122,7 @@ next_page:
1112 } 1122 }
1113 BUG_ON(pages && !list_empty(pages)); 1123 BUG_ON(pages && !list_empty(pages));
1114 if (bio) 1124 if (bio)
1115 __submit_bio(F2FS_I_SB(inode), bio); 1125 __submit_bio(F2FS_I_SB(inode), bio, DATA);
1116 return 0; 1126 return 0;
1117} 1127}
1118 1128
@@ -1201,14 +1211,14 @@ retry_encrypt:
1201 !IS_ATOMIC_WRITTEN_PAGE(page) && 1211 !IS_ATOMIC_WRITTEN_PAGE(page) &&
1202 need_inplace_update(inode))) { 1212 need_inplace_update(inode))) {
1203 rewrite_data_page(fio); 1213 rewrite_data_page(fio);
1204 set_inode_flag(F2FS_I(inode), FI_UPDATE_WRITE); 1214 set_inode_flag(inode, FI_UPDATE_WRITE);
1205 trace_f2fs_do_write_data_page(page, IPU); 1215 trace_f2fs_do_write_data_page(page, IPU);
1206 } else { 1216 } else {
1207 write_data_page(&dn, fio); 1217 write_data_page(&dn, fio);
1208 trace_f2fs_do_write_data_page(page, OPU); 1218 trace_f2fs_do_write_data_page(page, OPU);
1209 set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE); 1219 set_inode_flag(inode, FI_APPEND_WRITE);
1210 if (page->index == 0) 1220 if (page->index == 0)
1211 set_inode_flag(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN); 1221 set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);
1212 } 1222 }
1213out_writepage: 1223out_writepage:
1214 f2fs_put_dnode(&dn); 1224 f2fs_put_dnode(&dn);
@@ -1223,6 +1233,7 @@ static int f2fs_write_data_page(struct page *page,
1223 loff_t i_size = i_size_read(inode); 1233 loff_t i_size = i_size_read(inode);
1224 const pgoff_t end_index = ((unsigned long long) i_size) 1234 const pgoff_t end_index = ((unsigned long long) i_size)
1225 >> PAGE_SHIFT; 1235 >> PAGE_SHIFT;
1236 loff_t psize = (page->index + 1) << PAGE_SHIFT;
1226 unsigned offset = 0; 1237 unsigned offset = 0;
1227 bool need_balance_fs = false; 1238 bool need_balance_fs = false;
1228 int err = 0; 1239 int err = 0;
@@ -1260,20 +1271,18 @@ write:
1260 available_free_memory(sbi, BASE_CHECK)))) 1271 available_free_memory(sbi, BASE_CHECK))))
1261 goto redirty_out; 1272 goto redirty_out;
1262 1273
1274 /* we should bypass data pages to proceed the kworkder jobs */
1275 if (unlikely(f2fs_cp_error(sbi))) {
1276 mapping_set_error(page->mapping, -EIO);
1277 goto out;
1278 }
1279
1263 /* Dentry blocks are controlled by checkpoint */ 1280 /* Dentry blocks are controlled by checkpoint */
1264 if (S_ISDIR(inode->i_mode)) { 1281 if (S_ISDIR(inode->i_mode)) {
1265 if (unlikely(f2fs_cp_error(sbi)))
1266 goto redirty_out;
1267 err = do_write_data_page(&fio); 1282 err = do_write_data_page(&fio);
1268 goto done; 1283 goto done;
1269 } 1284 }
1270 1285
1271 /* we should bypass data pages to proceed the kworkder jobs */
1272 if (unlikely(f2fs_cp_error(sbi))) {
1273 SetPageError(page);
1274 goto out;
1275 }
1276
1277 if (!wbc->for_reclaim) 1286 if (!wbc->for_reclaim)
1278 need_balance_fs = true; 1287 need_balance_fs = true;
1279 else if (has_not_enough_free_secs(sbi, 0)) 1288 else if (has_not_enough_free_secs(sbi, 0))
@@ -1285,6 +1294,8 @@ write:
1285 err = f2fs_write_inline_data(inode, page); 1294 err = f2fs_write_inline_data(inode, page);
1286 if (err == -EAGAIN) 1295 if (err == -EAGAIN)
1287 err = do_write_data_page(&fio); 1296 err = do_write_data_page(&fio);
1297 if (F2FS_I(inode)->last_disk_size < psize)
1298 F2FS_I(inode)->last_disk_size = psize;
1288 f2fs_unlock_op(sbi); 1299 f2fs_unlock_op(sbi);
1289done: 1300done:
1290 if (err && err != -ENOENT) 1301 if (err && err != -ENOENT)
@@ -1311,16 +1322,8 @@ out:
1311 1322
1312redirty_out: 1323redirty_out:
1313 redirty_page_for_writepage(wbc, page); 1324 redirty_page_for_writepage(wbc, page);
1314 return AOP_WRITEPAGE_ACTIVATE; 1325 unlock_page(page);
1315} 1326 return err;
1316
1317static int __f2fs_writepage(struct page *page, struct writeback_control *wbc,
1318 void *data)
1319{
1320 struct address_space *mapping = data;
1321 int ret = mapping->a_ops->writepage(page, wbc);
1322 mapping_set_error(mapping, ret);
1323 return ret;
1324} 1327}
1325 1328
1326/* 1329/*
@@ -1329,8 +1332,7 @@ static int __f2fs_writepage(struct page *page, struct writeback_control *wbc,
1329 * warm/hot data page. 1332 * warm/hot data page.
1330 */ 1333 */
1331static int f2fs_write_cache_pages(struct address_space *mapping, 1334static int f2fs_write_cache_pages(struct address_space *mapping,
1332 struct writeback_control *wbc, writepage_t writepage, 1335 struct writeback_control *wbc)
1333 void *data)
1334{ 1336{
1335 int ret = 0; 1337 int ret = 0;
1336 int done = 0; 1338 int done = 0;
@@ -1343,10 +1345,9 @@ static int f2fs_write_cache_pages(struct address_space *mapping,
1343 int cycled; 1345 int cycled;
1344 int range_whole = 0; 1346 int range_whole = 0;
1345 int tag; 1347 int tag;
1346 int step = 0;
1347 1348
1348 pagevec_init(&pvec, 0); 1349 pagevec_init(&pvec, 0);
1349next: 1350
1350 if (wbc->range_cyclic) { 1351 if (wbc->range_cyclic) {
1351 writeback_index = mapping->writeback_index; /* prev offset */ 1352 writeback_index = mapping->writeback_index; /* prev offset */
1352 index = writeback_index; 1353 index = writeback_index;
@@ -1401,9 +1402,6 @@ continue_unlock:
1401 goto continue_unlock; 1402 goto continue_unlock;
1402 } 1403 }
1403 1404
1404 if (step == is_cold_data(page))
1405 goto continue_unlock;
1406
1407 if (PageWriteback(page)) { 1405 if (PageWriteback(page)) {
1408 if (wbc->sync_mode != WB_SYNC_NONE) 1406 if (wbc->sync_mode != WB_SYNC_NONE)
1409 f2fs_wait_on_page_writeback(page, 1407 f2fs_wait_on_page_writeback(page,
@@ -1416,16 +1414,11 @@ continue_unlock:
1416 if (!clear_page_dirty_for_io(page)) 1414 if (!clear_page_dirty_for_io(page))
1417 goto continue_unlock; 1415 goto continue_unlock;
1418 1416
1419 ret = (*writepage)(page, wbc, data); 1417 ret = mapping->a_ops->writepage(page, wbc);
1420 if (unlikely(ret)) { 1418 if (unlikely(ret)) {
1421 if (ret == AOP_WRITEPAGE_ACTIVATE) { 1419 done_index = page->index + 1;
1422 unlock_page(page); 1420 done = 1;
1423 ret = 0; 1421 break;
1424 } else {
1425 done_index = page->index + 1;
1426 done = 1;
1427 break;
1428 }
1429 } 1422 }
1430 1423
1431 if (--wbc->nr_to_write <= 0 && 1424 if (--wbc->nr_to_write <= 0 &&
@@ -1438,11 +1431,6 @@ continue_unlock:
1438 cond_resched(); 1431 cond_resched();
1439 } 1432 }
1440 1433
1441 if (step < 1) {
1442 step++;
1443 goto next;
1444 }
1445
1446 if (!cycled && !done) { 1434 if (!cycled && !done) {
1447 cycled = 1; 1435 cycled = 1;
1448 index = 0; 1436 index = 0;
@@ -1460,9 +1448,8 @@ static int f2fs_write_data_pages(struct address_space *mapping,
1460{ 1448{
1461 struct inode *inode = mapping->host; 1449 struct inode *inode = mapping->host;
1462 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1450 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1463 bool locked = false; 1451 struct blk_plug plug;
1464 int ret; 1452 int ret;
1465 long diff;
1466 1453
1467 /* deal with chardevs and other special file */ 1454 /* deal with chardevs and other special file */
1468 if (!mapping->a_ops->writepage) 1455 if (!mapping->a_ops->writepage)
@@ -1478,7 +1465,7 @@ static int f2fs_write_data_pages(struct address_space *mapping,
1478 goto skip_write; 1465 goto skip_write;
1479 1466
1480 /* skip writing during file defragment */ 1467 /* skip writing during file defragment */
1481 if (is_inode_flag_set(F2FS_I(inode), FI_DO_DEFRAG)) 1468 if (is_inode_flag_set(inode, FI_DO_DEFRAG))
1482 goto skip_write; 1469 goto skip_write;
1483 1470
1484 /* during POR, we don't need to trigger writepage at all. */ 1471 /* during POR, we don't need to trigger writepage at all. */
@@ -1487,20 +1474,16 @@ static int f2fs_write_data_pages(struct address_space *mapping,
1487 1474
1488 trace_f2fs_writepages(mapping->host, wbc, DATA); 1475 trace_f2fs_writepages(mapping->host, wbc, DATA);
1489 1476
1490 diff = nr_pages_to_write(sbi, DATA, wbc); 1477 blk_start_plug(&plug);
1491 1478 ret = f2fs_write_cache_pages(mapping, wbc);
1492 if (!S_ISDIR(inode->i_mode) && wbc->sync_mode == WB_SYNC_ALL) { 1479 blk_finish_plug(&plug);
1493 mutex_lock(&sbi->writepages); 1480 /*
1494 locked = true; 1481 * if some pages were truncated, we cannot guarantee its mapping->host
1495 } 1482 * to detect pending bios.
1496 ret = f2fs_write_cache_pages(mapping, wbc, __f2fs_writepage, mapping); 1483 */
1497 f2fs_submit_merged_bio_cond(sbi, inode, NULL, 0, DATA, WRITE); 1484 f2fs_submit_merged_bio(sbi, DATA, WRITE);
1498 if (locked)
1499 mutex_unlock(&sbi->writepages);
1500 1485
1501 remove_dirty_inode(inode); 1486 remove_dirty_inode(inode);
1502
1503 wbc->nr_to_write = max((long)0, wbc->nr_to_write - diff);
1504 return ret; 1487 return ret;
1505 1488
1506skip_write: 1489skip_write:
@@ -1558,7 +1541,7 @@ restart:
1558 if (f2fs_has_inline_data(inode)) { 1541 if (f2fs_has_inline_data(inode)) {
1559 if (pos + len <= MAX_INLINE_DATA) { 1542 if (pos + len <= MAX_INLINE_DATA) {
1560 read_inline_data(page, ipage); 1543 read_inline_data(page, ipage);
1561 set_inode_flag(F2FS_I(inode), FI_DATA_EXIST); 1544 set_inode_flag(inode, FI_DATA_EXIST);
1562 if (inode->i_nlink) 1545 if (inode->i_nlink)
1563 set_inline_node(ipage); 1546 set_inline_node(ipage);
1564 } else { 1547 } else {
@@ -1668,39 +1651,35 @@ repeat:
1668 if (blkaddr == NEW_ADDR) { 1651 if (blkaddr == NEW_ADDR) {
1669 zero_user_segment(page, 0, PAGE_SIZE); 1652 zero_user_segment(page, 0, PAGE_SIZE);
1670 } else { 1653 } else {
1671 struct f2fs_io_info fio = { 1654 struct bio *bio;
1672 .sbi = sbi,
1673 .type = DATA,
1674 .op = REQ_OP_READ,
1675 .op_flags = READ_SYNC,
1676 .old_blkaddr = blkaddr,
1677 .new_blkaddr = blkaddr,
1678 .page = page,
1679 .encrypted_page = NULL,
1680 };
1681 err = f2fs_submit_page_bio(&fio);
1682 if (err)
1683 goto fail;
1684 1655
1685 lock_page(page); 1656 bio = f2fs_grab_bio(inode, blkaddr, 1);
1686 if (unlikely(!PageUptodate(page))) { 1657 if (IS_ERR(bio)) {
1687 err = -EIO; 1658 err = PTR_ERR(bio);
1688 goto fail; 1659 goto fail;
1689 } 1660 }
1661 bio_set_op_attrs(bio, REQ_OP_READ, READ_SYNC);
1662 if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
1663 bio_put(bio);
1664 err = -EFAULT;
1665 goto fail;
1666 }
1667
1668 __submit_bio(sbi, bio, DATA);
1669
1670 lock_page(page);
1690 if (unlikely(page->mapping != mapping)) { 1671 if (unlikely(page->mapping != mapping)) {
1691 f2fs_put_page(page, 1); 1672 f2fs_put_page(page, 1);
1692 goto repeat; 1673 goto repeat;
1693 } 1674 }
1694 1675 if (unlikely(!PageUptodate(page))) {
1695 /* avoid symlink page */ 1676 err = -EIO;
1696 if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) { 1677 goto fail;
1697 err = fscrypt_decrypt_page(page);
1698 if (err)
1699 goto fail;
1700 } 1678 }
1701 } 1679 }
1702out_update: 1680out_update:
1703 SetPageUptodate(page); 1681 if (!PageUptodate(page))
1682 SetPageUptodate(page);
1704out_clear: 1683out_clear:
1705 clear_cold_data(page); 1684 clear_cold_data(page);
1706 return 0; 1685 return 0;
@@ -1721,13 +1700,11 @@ static int f2fs_write_end(struct file *file,
1721 trace_f2fs_write_end(inode, pos, len, copied); 1700 trace_f2fs_write_end(inode, pos, len, copied);
1722 1701
1723 set_page_dirty(page); 1702 set_page_dirty(page);
1703 f2fs_put_page(page, 1);
1724 1704
1725 if (pos + copied > i_size_read(inode)) { 1705 if (pos + copied > i_size_read(inode))
1726 i_size_write(inode, pos + copied); 1706 f2fs_i_size_write(inode, pos + copied);
1727 mark_inode_dirty(inode);
1728 }
1729 1707
1730 f2fs_put_page(page, 1);
1731 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 1708 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1732 return copied; 1709 return copied;
1733} 1710}
@@ -1752,6 +1729,7 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
1752 struct inode *inode = mapping->host; 1729 struct inode *inode = mapping->host;
1753 size_t count = iov_iter_count(iter); 1730 size_t count = iov_iter_count(iter);
1754 loff_t offset = iocb->ki_pos; 1731 loff_t offset = iocb->ki_pos;
1732 int rw = iov_iter_rw(iter);
1755 int err; 1733 int err;
1756 1734
1757 err = check_direct_IO(inode, iter, offset); 1735 err = check_direct_IO(inode, iter, offset);
@@ -1760,18 +1738,23 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
1760 1738
1761 if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) 1739 if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
1762 return 0; 1740 return 0;
1741 if (test_opt(F2FS_I_SB(inode), LFS))
1742 return 0;
1763 1743
1764 trace_f2fs_direct_IO_enter(inode, offset, count, iov_iter_rw(iter)); 1744 trace_f2fs_direct_IO_enter(inode, offset, count, rw);
1765 1745
1746 down_read(&F2FS_I(inode)->dio_rwsem[rw]);
1766 err = blockdev_direct_IO(iocb, inode, iter, get_data_block_dio); 1747 err = blockdev_direct_IO(iocb, inode, iter, get_data_block_dio);
1767 if (iov_iter_rw(iter) == WRITE) { 1748 up_read(&F2FS_I(inode)->dio_rwsem[rw]);
1749
1750 if (rw == WRITE) {
1768 if (err > 0) 1751 if (err > 0)
1769 set_inode_flag(F2FS_I(inode), FI_UPDATE_WRITE); 1752 set_inode_flag(inode, FI_UPDATE_WRITE);
1770 else if (err < 0) 1753 else if (err < 0)
1771 f2fs_write_failed(mapping, offset + count); 1754 f2fs_write_failed(mapping, offset + count);
1772 } 1755 }
1773 1756
1774 trace_f2fs_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), err); 1757 trace_f2fs_direct_IO_exit(inode, offset, count, rw, err);
1775 1758
1776 return err; 1759 return err;
1777} 1760}
@@ -1818,6 +1801,35 @@ int f2fs_release_page(struct page *page, gfp_t wait)
1818 return 1; 1801 return 1;
1819} 1802}
1820 1803
1804/*
1805 * This was copied from __set_page_dirty_buffers which gives higher performance
1806 * in very high speed storages. (e.g., pmem)
1807 */
1808void f2fs_set_page_dirty_nobuffers(struct page *page)
1809{
1810 struct address_space *mapping = page->mapping;
1811 unsigned long flags;
1812
1813 if (unlikely(!mapping))
1814 return;
1815
1816 spin_lock(&mapping->private_lock);
1817 lock_page_memcg(page);
1818 SetPageDirty(page);
1819 spin_unlock(&mapping->private_lock);
1820
1821 spin_lock_irqsave(&mapping->tree_lock, flags);
1822 WARN_ON_ONCE(!PageUptodate(page));
1823 account_page_dirtied(page, mapping);
1824 radix_tree_tag_set(&mapping->page_tree,
1825 page_index(page), PAGECACHE_TAG_DIRTY);
1826 spin_unlock_irqrestore(&mapping->tree_lock, flags);
1827 unlock_page_memcg(page);
1828
1829 __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
1830 return;
1831}
1832
1821static int f2fs_set_data_page_dirty(struct page *page) 1833static int f2fs_set_data_page_dirty(struct page *page)
1822{ 1834{
1823 struct address_space *mapping = page->mapping; 1835 struct address_space *mapping = page->mapping;
@@ -1825,7 +1837,8 @@ static int f2fs_set_data_page_dirty(struct page *page)
1825 1837
1826 trace_f2fs_set_page_dirty(page, DATA); 1838 trace_f2fs_set_page_dirty(page, DATA);
1827 1839
1828 SetPageUptodate(page); 1840 if (!PageUptodate(page))
1841 SetPageUptodate(page);
1829 1842
1830 if (f2fs_is_atomic_file(inode)) { 1843 if (f2fs_is_atomic_file(inode)) {
1831 if (!IS_ATOMIC_WRITTEN_PAGE(page)) { 1844 if (!IS_ATOMIC_WRITTEN_PAGE(page)) {
@@ -1840,7 +1853,7 @@ static int f2fs_set_data_page_dirty(struct page *page)
1840 } 1853 }
1841 1854
1842 if (!PageDirty(page)) { 1855 if (!PageDirty(page)) {
1843 __set_page_dirty_nobuffers(page); 1856 f2fs_set_page_dirty_nobuffers(page);
1844 update_dirty_page(inode, page); 1857 update_dirty_page(inode, page);
1845 return 1; 1858 return 1;
1846 } 1859 }
diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index d89a425055d0..badd407bb622 100644
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -47,6 +47,7 @@ static void update_general_status(struct f2fs_sb_info *sbi)
47 si->ndirty_data = get_pages(sbi, F2FS_DIRTY_DATA); 47 si->ndirty_data = get_pages(sbi, F2FS_DIRTY_DATA);
48 si->ndirty_dirs = sbi->ndirty_inode[DIR_INODE]; 48 si->ndirty_dirs = sbi->ndirty_inode[DIR_INODE];
49 si->ndirty_files = sbi->ndirty_inode[FILE_INODE]; 49 si->ndirty_files = sbi->ndirty_inode[FILE_INODE];
50 si->ndirty_all = sbi->ndirty_inode[DIRTY_META];
50 si->inmem_pages = get_pages(sbi, F2FS_INMEM_PAGES); 51 si->inmem_pages = get_pages(sbi, F2FS_INMEM_PAGES);
51 si->wb_bios = atomic_read(&sbi->nr_wb_bios); 52 si->wb_bios = atomic_read(&sbi->nr_wb_bios);
52 si->total_count = (int)sbi->user_block_count / sbi->blocks_per_seg; 53 si->total_count = (int)sbi->user_block_count / sbi->blocks_per_seg;
@@ -304,8 +305,8 @@ static int stat_show(struct seq_file *s, void *v)
304 si->inmem_pages, si->wb_bios); 305 si->inmem_pages, si->wb_bios);
305 seq_printf(s, " - nodes: %4lld in %4d\n", 306 seq_printf(s, " - nodes: %4lld in %4d\n",
306 si->ndirty_node, si->node_pages); 307 si->ndirty_node, si->node_pages);
307 seq_printf(s, " - dents: %4lld in dirs:%4d\n", 308 seq_printf(s, " - dents: %4lld in dirs:%4d (%4d)\n",
308 si->ndirty_dent, si->ndirty_dirs); 309 si->ndirty_dent, si->ndirty_dirs, si->ndirty_all);
309 seq_printf(s, " - datas: %4lld in files:%4d\n", 310 seq_printf(s, " - datas: %4lld in files:%4d\n",
310 si->ndirty_data, si->ndirty_files); 311 si->ndirty_data, si->ndirty_files);
311 seq_printf(s, " - meta: %4lld in %4d\n", 312 seq_printf(s, " - meta: %4lld in %4d\n",
diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index f9313f684540..a485f68a76b1 100644
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -185,8 +185,13 @@ static struct f2fs_dir_entry *find_in_level(struct inode *dir,
185 /* no need to allocate new dentry pages to all the indices */ 185 /* no need to allocate new dentry pages to all the indices */
186 dentry_page = find_data_page(dir, bidx); 186 dentry_page = find_data_page(dir, bidx);
187 if (IS_ERR(dentry_page)) { 187 if (IS_ERR(dentry_page)) {
188 room = true; 188 if (PTR_ERR(dentry_page) == -ENOENT) {
189 continue; 189 room = true;
190 continue;
191 } else {
192 *res_page = dentry_page;
193 break;
194 }
190 } 195 }
191 196
192 de = find_in_block(dentry_page, fname, namehash, &max_slots, 197 de = find_in_block(dentry_page, fname, namehash, &max_slots,
@@ -223,19 +228,22 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
223 struct fscrypt_name fname; 228 struct fscrypt_name fname;
224 int err; 229 int err;
225 230
226 *res_page = NULL;
227
228 err = fscrypt_setup_filename(dir, child, 1, &fname); 231 err = fscrypt_setup_filename(dir, child, 1, &fname);
229 if (err) 232 if (err) {
233 *res_page = ERR_PTR(err);
230 return NULL; 234 return NULL;
235 }
231 236
232 if (f2fs_has_inline_dentry(dir)) { 237 if (f2fs_has_inline_dentry(dir)) {
238 *res_page = NULL;
233 de = find_in_inline_dir(dir, &fname, res_page); 239 de = find_in_inline_dir(dir, &fname, res_page);
234 goto out; 240 goto out;
235 } 241 }
236 242
237 if (npages == 0) 243 if (npages == 0) {
244 *res_page = NULL;
238 goto out; 245 goto out;
246 }
239 247
240 max_depth = F2FS_I(dir)->i_current_depth; 248 max_depth = F2FS_I(dir)->i_current_depth;
241 if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) { 249 if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) {
@@ -243,13 +251,13 @@ struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
243 "Corrupted max_depth of %lu: %u", 251 "Corrupted max_depth of %lu: %u",
244 dir->i_ino, max_depth); 252 dir->i_ino, max_depth);
245 max_depth = MAX_DIR_HASH_DEPTH; 253 max_depth = MAX_DIR_HASH_DEPTH;
246 F2FS_I(dir)->i_current_depth = max_depth; 254 f2fs_i_depth_write(dir, max_depth);
247 mark_inode_dirty(dir);
248 } 255 }
249 256
250 for (level = 0; level < max_depth; level++) { 257 for (level = 0; level < max_depth; level++) {
258 *res_page = NULL;
251 de = find_in_level(dir, level, &fname, res_page); 259 de = find_in_level(dir, level, &fname, res_page);
252 if (de) 260 if (de || IS_ERR(*res_page))
253 break; 261 break;
254 } 262 }
255out: 263out:
@@ -259,35 +267,22 @@ out:
259 267
260struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p) 268struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p)
261{ 269{
262 struct page *page; 270 struct qstr dotdot = QSTR_INIT("..", 2);
263 struct f2fs_dir_entry *de;
264 struct f2fs_dentry_block *dentry_blk;
265
266 if (f2fs_has_inline_dentry(dir))
267 return f2fs_parent_inline_dir(dir, p);
268
269 page = get_lock_data_page(dir, 0, false);
270 if (IS_ERR(page))
271 return NULL;
272 271
273 dentry_blk = kmap(page); 272 return f2fs_find_entry(dir, &dotdot, p);
274 de = &dentry_blk->dentry[1];
275 *p = page;
276 unlock_page(page);
277 return de;
278} 273}
279 274
280ino_t f2fs_inode_by_name(struct inode *dir, struct qstr *qstr) 275ino_t f2fs_inode_by_name(struct inode *dir, struct qstr *qstr,
276 struct page **page)
281{ 277{
282 ino_t res = 0; 278 ino_t res = 0;
283 struct f2fs_dir_entry *de; 279 struct f2fs_dir_entry *de;
284 struct page *page;
285 280
286 de = f2fs_find_entry(dir, qstr, &page); 281 de = f2fs_find_entry(dir, qstr, page);
287 if (de) { 282 if (de) {
288 res = le32_to_cpu(de->ino); 283 res = le32_to_cpu(de->ino);
289 f2fs_dentry_kunmap(dir, page); 284 f2fs_dentry_kunmap(dir, *page);
290 f2fs_put_page(page, 0); 285 f2fs_put_page(*page, 0);
291 } 286 }
292 287
293 return res; 288 return res;
@@ -303,9 +298,9 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
303 set_de_type(de, inode->i_mode); 298 set_de_type(de, inode->i_mode);
304 f2fs_dentry_kunmap(dir, page); 299 f2fs_dentry_kunmap(dir, page);
305 set_page_dirty(page); 300 set_page_dirty(page);
306 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
307 mark_inode_dirty(dir);
308 301
302 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
303 f2fs_mark_inode_dirty_sync(dir);
309 f2fs_put_page(page, 1); 304 f2fs_put_page(page, 1);
310} 305}
311 306
@@ -385,7 +380,7 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
385 struct page *page; 380 struct page *page;
386 int err; 381 int err;
387 382
388 if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) { 383 if (is_inode_flag_set(inode, FI_NEW_INODE)) {
389 page = new_inode_page(inode); 384 page = new_inode_page(inode);
390 if (IS_ERR(page)) 385 if (IS_ERR(page))
391 return page; 386 return page;
@@ -429,7 +424,7 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
429 * This file should be checkpointed during fsync. 424 * This file should be checkpointed during fsync.
430 * We lost i_pino from now on. 425 * We lost i_pino from now on.
431 */ 426 */
432 if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) { 427 if (is_inode_flag_set(inode, FI_INC_LINK)) {
433 file_lost_pino(inode); 428 file_lost_pino(inode);
434 /* 429 /*
435 * If link the tmpfile to alias through linkat path, 430 * If link the tmpfile to alias through linkat path,
@@ -437,14 +432,11 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
437 */ 432 */
438 if (inode->i_nlink == 0) 433 if (inode->i_nlink == 0)
439 remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino); 434 remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);
440 inc_nlink(inode); 435 f2fs_i_links_write(inode, true);
441 } 436 }
442 return page; 437 return page;
443 438
444put_error: 439put_error:
445 /* truncate empty dir pages */
446 truncate_inode_pages(&inode->i_data, 0);
447
448 clear_nlink(inode); 440 clear_nlink(inode);
449 update_inode(inode, page); 441 update_inode(inode, page);
450 f2fs_put_page(page, 1); 442 f2fs_put_page(page, 1);
@@ -454,23 +446,19 @@ put_error:
454void update_parent_metadata(struct inode *dir, struct inode *inode, 446void update_parent_metadata(struct inode *dir, struct inode *inode,
455 unsigned int current_depth) 447 unsigned int current_depth)
456{ 448{
457 if (inode && is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) { 449 if (inode && is_inode_flag_set(inode, FI_NEW_INODE)) {
458 if (S_ISDIR(inode->i_mode)) { 450 if (S_ISDIR(inode->i_mode))
459 inc_nlink(dir); 451 f2fs_i_links_write(dir, true);
460 set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR); 452 clear_inode_flag(inode, FI_NEW_INODE);
461 }
462 clear_inode_flag(F2FS_I(inode), FI_NEW_INODE);
463 } 453 }
464 dir->i_mtime = dir->i_ctime = CURRENT_TIME; 454 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
465 mark_inode_dirty(dir); 455 f2fs_mark_inode_dirty_sync(dir);
466 456
467 if (F2FS_I(dir)->i_current_depth != current_depth) { 457 if (F2FS_I(dir)->i_current_depth != current_depth)
468 F2FS_I(dir)->i_current_depth = current_depth; 458 f2fs_i_depth_write(dir, current_depth);
469 set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
470 }
471 459
472 if (inode && is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) 460 if (inode && is_inode_flag_set(inode, FI_INC_LINK))
473 clear_inode_flag(F2FS_I(inode), FI_INC_LINK); 461 clear_inode_flag(inode, FI_INC_LINK);
474} 462}
475 463
476int room_for_filename(const void *bitmap, int slots, int max_slots) 464int room_for_filename(const void *bitmap, int slots, int max_slots)
@@ -596,9 +584,7 @@ add_dentry:
596 set_page_dirty(dentry_page); 584 set_page_dirty(dentry_page);
597 585
598 if (inode) { 586 if (inode) {
599 /* we don't need to mark_inode_dirty now */ 587 f2fs_i_pino_write(inode, dir->i_ino);
600 F2FS_I(inode)->i_pino = dir->i_ino;
601 update_inode(inode, page);
602 f2fs_put_page(page, 1); 588 f2fs_put_page(page, 1);
603 } 589 }
604 590
@@ -607,10 +593,6 @@ fail:
607 if (inode) 593 if (inode)
608 up_write(&F2FS_I(inode)->i_sem); 594 up_write(&F2FS_I(inode)->i_sem);
609 595
610 if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {
611 update_inode_page(dir);
612 clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
613 }
614 kunmap(dentry_page); 596 kunmap(dentry_page);
615 f2fs_put_page(dentry_page, 1); 597 f2fs_put_page(dentry_page, 1);
616 598
@@ -657,42 +639,34 @@ int f2fs_do_tmpfile(struct inode *inode, struct inode *dir)
657 err = PTR_ERR(page); 639 err = PTR_ERR(page);
658 goto fail; 640 goto fail;
659 } 641 }
660 /* we don't need to mark_inode_dirty now */
661 update_inode(inode, page);
662 f2fs_put_page(page, 1); 642 f2fs_put_page(page, 1);
663 643
664 clear_inode_flag(F2FS_I(inode), FI_NEW_INODE); 644 clear_inode_flag(inode, FI_NEW_INODE);
665fail: 645fail:
666 up_write(&F2FS_I(inode)->i_sem); 646 up_write(&F2FS_I(inode)->i_sem);
667 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 647 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
668 return err; 648 return err;
669} 649}
670 650
671void f2fs_drop_nlink(struct inode *dir, struct inode *inode, struct page *page) 651void f2fs_drop_nlink(struct inode *dir, struct inode *inode)
672{ 652{
673 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 653 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
674 654
675 down_write(&F2FS_I(inode)->i_sem); 655 down_write(&F2FS_I(inode)->i_sem);
676 656
677 if (S_ISDIR(inode->i_mode)) { 657 if (S_ISDIR(inode->i_mode))
678 drop_nlink(dir); 658 f2fs_i_links_write(dir, false);
679 if (page)
680 update_inode(dir, page);
681 else
682 update_inode_page(dir);
683 }
684 inode->i_ctime = CURRENT_TIME; 659 inode->i_ctime = CURRENT_TIME;
685 660
686 drop_nlink(inode); 661 f2fs_i_links_write(inode, false);
687 if (S_ISDIR(inode->i_mode)) { 662 if (S_ISDIR(inode->i_mode)) {
688 drop_nlink(inode); 663 f2fs_i_links_write(inode, false);
689 i_size_write(inode, 0); 664 f2fs_i_size_write(inode, 0);
690 } 665 }
691 up_write(&F2FS_I(inode)->i_sem); 666 up_write(&F2FS_I(inode)->i_sem);
692 update_inode_page(inode);
693 667
694 if (inode->i_nlink == 0) 668 if (inode->i_nlink == 0)
695 add_orphan_inode(sbi, inode->i_ino); 669 add_orphan_inode(inode);
696 else 670 else
697 release_orphan_inode(sbi); 671 release_orphan_inode(sbi);
698} 672}
@@ -730,9 +704,10 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
730 set_page_dirty(page); 704 set_page_dirty(page);
731 705
732 dir->i_ctime = dir->i_mtime = CURRENT_TIME; 706 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
707 f2fs_mark_inode_dirty_sync(dir);
733 708
734 if (inode) 709 if (inode)
735 f2fs_drop_nlink(dir, inode, NULL); 710 f2fs_drop_nlink(dir, inode);
736 711
737 if (bit_pos == NR_DENTRY_IN_BLOCK && 712 if (bit_pos == NR_DENTRY_IN_BLOCK &&
738 !truncate_hole(dir, page->index, page->index + 1)) { 713 !truncate_hole(dir, page->index, page->index + 1)) {
diff --git a/fs/f2fs/extent_cache.c b/fs/f2fs/extent_cache.c
index 5bfcdb9b69f2..2b06d4fcd954 100644
--- a/fs/f2fs/extent_cache.c
+++ b/fs/f2fs/extent_cache.c
@@ -170,8 +170,10 @@ static void __drop_largest_extent(struct inode *inode,
170{ 170{
171 struct extent_info *largest = &F2FS_I(inode)->extent_tree->largest; 171 struct extent_info *largest = &F2FS_I(inode)->extent_tree->largest;
172 172
173 if (fofs < largest->fofs + largest->len && fofs + len > largest->fofs) 173 if (fofs < largest->fofs + largest->len && fofs + len > largest->fofs) {
174 largest->len = 0; 174 largest->len = 0;
175 f2fs_mark_inode_dirty_sync(inode);
176 }
175} 177}
176 178
177/* return true, if inode page is changed */ 179/* return true, if inode page is changed */
@@ -335,11 +337,12 @@ lookup_neighbors:
335 return en; 337 return en;
336} 338}
337 339
338static struct extent_node *__try_merge_extent_node(struct f2fs_sb_info *sbi, 340static struct extent_node *__try_merge_extent_node(struct inode *inode,
339 struct extent_tree *et, struct extent_info *ei, 341 struct extent_tree *et, struct extent_info *ei,
340 struct extent_node *prev_ex, 342 struct extent_node *prev_ex,
341 struct extent_node *next_ex) 343 struct extent_node *next_ex)
342{ 344{
345 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
343 struct extent_node *en = NULL; 346 struct extent_node *en = NULL;
344 347
345 if (prev_ex && __is_back_mergeable(ei, &prev_ex->ei)) { 348 if (prev_ex && __is_back_mergeable(ei, &prev_ex->ei)) {
@@ -360,7 +363,7 @@ static struct extent_node *__try_merge_extent_node(struct f2fs_sb_info *sbi,
360 if (!en) 363 if (!en)
361 return NULL; 364 return NULL;
362 365
363 __try_update_largest_extent(et, en); 366 __try_update_largest_extent(inode, et, en);
364 367
365 spin_lock(&sbi->extent_lock); 368 spin_lock(&sbi->extent_lock);
366 if (!list_empty(&en->list)) { 369 if (!list_empty(&en->list)) {
@@ -371,11 +374,12 @@ static struct extent_node *__try_merge_extent_node(struct f2fs_sb_info *sbi,
371 return en; 374 return en;
372} 375}
373 376
374static struct extent_node *__insert_extent_tree(struct f2fs_sb_info *sbi, 377static struct extent_node *__insert_extent_tree(struct inode *inode,
375 struct extent_tree *et, struct extent_info *ei, 378 struct extent_tree *et, struct extent_info *ei,
376 struct rb_node **insert_p, 379 struct rb_node **insert_p,
377 struct rb_node *insert_parent) 380 struct rb_node *insert_parent)
378{ 381{
382 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
379 struct rb_node **p = &et->root.rb_node; 383 struct rb_node **p = &et->root.rb_node;
380 struct rb_node *parent = NULL; 384 struct rb_node *parent = NULL;
381 struct extent_node *en = NULL; 385 struct extent_node *en = NULL;
@@ -402,7 +406,7 @@ do_insert:
402 if (!en) 406 if (!en)
403 return NULL; 407 return NULL;
404 408
405 __try_update_largest_extent(et, en); 409 __try_update_largest_extent(inode, et, en);
406 410
407 /* update in global extent list */ 411 /* update in global extent list */
408 spin_lock(&sbi->extent_lock); 412 spin_lock(&sbi->extent_lock);
@@ -431,7 +435,7 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
431 435
432 write_lock(&et->lock); 436 write_lock(&et->lock);
433 437
434 if (is_inode_flag_set(F2FS_I(inode), FI_NO_EXTENT)) { 438 if (is_inode_flag_set(inode, FI_NO_EXTENT)) {
435 write_unlock(&et->lock); 439 write_unlock(&et->lock);
436 return false; 440 return false;
437 } 441 }
@@ -473,7 +477,7 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
473 set_extent_info(&ei, end, 477 set_extent_info(&ei, end,
474 end - dei.fofs + dei.blk, 478 end - dei.fofs + dei.blk,
475 org_end - end); 479 org_end - end);
476 en1 = __insert_extent_tree(sbi, et, &ei, 480 en1 = __insert_extent_tree(inode, et, &ei,
477 NULL, NULL); 481 NULL, NULL);
478 next_en = en1; 482 next_en = en1;
479 } else { 483 } else {
@@ -494,7 +498,7 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
494 } 498 }
495 499
496 if (parts) 500 if (parts)
497 __try_update_largest_extent(et, en); 501 __try_update_largest_extent(inode, et, en);
498 else 502 else
499 __release_extent_node(sbi, et, en); 503 __release_extent_node(sbi, et, en);
500 504
@@ -514,20 +518,20 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
514 if (blkaddr) { 518 if (blkaddr) {
515 519
516 set_extent_info(&ei, fofs, blkaddr, len); 520 set_extent_info(&ei, fofs, blkaddr, len);
517 if (!__try_merge_extent_node(sbi, et, &ei, prev_en, next_en)) 521 if (!__try_merge_extent_node(inode, et, &ei, prev_en, next_en))
518 __insert_extent_tree(sbi, et, &ei, 522 __insert_extent_tree(inode, et, &ei,
519 insert_p, insert_parent); 523 insert_p, insert_parent);
520 524
521 /* give up extent_cache, if split and small updates happen */ 525 /* give up extent_cache, if split and small updates happen */
522 if (dei.len >= 1 && 526 if (dei.len >= 1 &&
523 prev.len < F2FS_MIN_EXTENT_LEN && 527 prev.len < F2FS_MIN_EXTENT_LEN &&
524 et->largest.len < F2FS_MIN_EXTENT_LEN) { 528 et->largest.len < F2FS_MIN_EXTENT_LEN) {
525 et->largest.len = 0; 529 __drop_largest_extent(inode, 0, UINT_MAX);
526 set_inode_flag(F2FS_I(inode), FI_NO_EXTENT); 530 set_inode_flag(inode, FI_NO_EXTENT);
527 } 531 }
528 } 532 }
529 533
530 if (is_inode_flag_set(F2FS_I(inode), FI_NO_EXTENT)) 534 if (is_inode_flag_set(inode, FI_NO_EXTENT))
531 __free_extent_tree(sbi, et); 535 __free_extent_tree(sbi, et);
532 536
533 write_unlock(&et->lock); 537 write_unlock(&et->lock);
@@ -627,6 +631,19 @@ unsigned int f2fs_destroy_extent_node(struct inode *inode)
627 return node_cnt; 631 return node_cnt;
628} 632}
629 633
634void f2fs_drop_extent_tree(struct inode *inode)
635{
636 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
637 struct extent_tree *et = F2FS_I(inode)->extent_tree;
638
639 set_inode_flag(inode, FI_NO_EXTENT);
640
641 write_lock(&et->lock);
642 __free_extent_tree(sbi, et);
643 __drop_largest_extent(inode, 0, UINT_MAX);
644 write_unlock(&et->lock);
645}
646
630void f2fs_destroy_extent_tree(struct inode *inode) 647void f2fs_destroy_extent_tree(struct inode *inode)
631{ 648{
632 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 649 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
@@ -685,9 +702,7 @@ void f2fs_update_extent_cache(struct dnode_of_data *dn)
685 702
686 fofs = start_bidx_of_node(ofs_of_node(dn->node_page), dn->inode) + 703 fofs = start_bidx_of_node(ofs_of_node(dn->node_page), dn->inode) +
687 dn->ofs_in_node; 704 dn->ofs_in_node;
688 705 f2fs_update_extent_tree_range(dn->inode, fofs, blkaddr, 1);
689 if (f2fs_update_extent_tree_range(dn->inode, fofs, blkaddr, 1))
690 sync_inode_page(dn);
691} 706}
692 707
693void f2fs_update_extent_cache_range(struct dnode_of_data *dn, 708void f2fs_update_extent_cache_range(struct dnode_of_data *dn,
@@ -697,8 +712,7 @@ void f2fs_update_extent_cache_range(struct dnode_of_data *dn,
697 if (!f2fs_may_extent_tree(dn->inode)) 712 if (!f2fs_may_extent_tree(dn->inode))
698 return; 713 return;
699 714
700 if (f2fs_update_extent_tree_range(dn->inode, fofs, blkaddr, len)) 715 f2fs_update_extent_tree_range(dn->inode, fofs, blkaddr, len);
701 sync_inode_page(dn);
702} 716}
703 717
704void init_extent_cache_info(struct f2fs_sb_info *sbi) 718void init_extent_cache_info(struct f2fs_sb_info *sbi)
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 23ae6a81ccd6..7890e9071499 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -45,6 +45,7 @@ enum {
45 FAULT_ORPHAN, 45 FAULT_ORPHAN,
46 FAULT_BLOCK, 46 FAULT_BLOCK,
47 FAULT_DIR_DEPTH, 47 FAULT_DIR_DEPTH,
48 FAULT_EVICT_INODE,
48 FAULT_MAX, 49 FAULT_MAX,
49}; 50};
50 51
@@ -74,6 +75,8 @@ static inline bool time_to_inject(int type)
74 return false; 75 return false;
75 else if (type == FAULT_DIR_DEPTH && !IS_FAULT_SET(type)) 76 else if (type == FAULT_DIR_DEPTH && !IS_FAULT_SET(type))
76 return false; 77 return false;
78 else if (type == FAULT_EVICT_INODE && !IS_FAULT_SET(type))
79 return false;
77 80
78 atomic_inc(&f2fs_fault.inject_ops); 81 atomic_inc(&f2fs_fault.inject_ops);
79 if (atomic_read(&f2fs_fault.inject_ops) >= f2fs_fault.inject_rate) { 82 if (atomic_read(&f2fs_fault.inject_ops) >= f2fs_fault.inject_rate) {
@@ -108,6 +111,8 @@ static inline bool time_to_inject(int type)
108#define F2FS_MOUNT_FORCE_FG_GC 0x00004000 111#define F2FS_MOUNT_FORCE_FG_GC 0x00004000
109#define F2FS_MOUNT_DATA_FLUSH 0x00008000 112#define F2FS_MOUNT_DATA_FLUSH 0x00008000
110#define F2FS_MOUNT_FAULT_INJECTION 0x00010000 113#define F2FS_MOUNT_FAULT_INJECTION 0x00010000
114#define F2FS_MOUNT_ADAPTIVE 0x00020000
115#define F2FS_MOUNT_LFS 0x00040000
111 116
112#define clear_opt(sbi, option) (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option) 117#define clear_opt(sbi, option) (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option)
113#define set_opt(sbi, option) (sbi->mount_opt.opt |= F2FS_MOUNT_##option) 118#define set_opt(sbi, option) (sbi->mount_opt.opt |= F2FS_MOUNT_##option)
@@ -128,6 +133,7 @@ struct f2fs_mount_info {
128}; 133};
129 134
130#define F2FS_FEATURE_ENCRYPT 0x0001 135#define F2FS_FEATURE_ENCRYPT 0x0001
136#define F2FS_FEATURE_HMSMR 0x0002
131 137
132#define F2FS_HAS_FEATURE(sb, mask) \ 138#define F2FS_HAS_FEATURE(sb, mask) \
133 ((F2FS_SB(sb)->raw_super->feature & cpu_to_le32(mask)) != 0) 139 ((F2FS_SB(sb)->raw_super->feature & cpu_to_le32(mask)) != 0)
@@ -158,7 +164,7 @@ enum {
158#define BATCHED_TRIM_BLOCKS(sbi) \ 164#define BATCHED_TRIM_BLOCKS(sbi) \
159 (BATCHED_TRIM_SEGMENTS(sbi) << (sbi)->log_blocks_per_seg) 165 (BATCHED_TRIM_SEGMENTS(sbi) << (sbi)->log_blocks_per_seg)
160#define DEF_CP_INTERVAL 60 /* 60 secs */ 166#define DEF_CP_INTERVAL 60 /* 60 secs */
161#define DEF_IDLE_INTERVAL 120 /* 2 mins */ 167#define DEF_IDLE_INTERVAL 5 /* 5 secs */
162 168
163struct cp_control { 169struct cp_control {
164 int reason; 170 int reason;
@@ -262,6 +268,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal,
262#define F2FS_IOC_GARBAGE_COLLECT _IO(F2FS_IOCTL_MAGIC, 6) 268#define F2FS_IOC_GARBAGE_COLLECT _IO(F2FS_IOCTL_MAGIC, 6)
263#define F2FS_IOC_WRITE_CHECKPOINT _IO(F2FS_IOCTL_MAGIC, 7) 269#define F2FS_IOC_WRITE_CHECKPOINT _IO(F2FS_IOCTL_MAGIC, 7)
264#define F2FS_IOC_DEFRAGMENT _IO(F2FS_IOCTL_MAGIC, 8) 270#define F2FS_IOC_DEFRAGMENT _IO(F2FS_IOCTL_MAGIC, 8)
271#define F2FS_IOC_MOVE_RANGE _IOWR(F2FS_IOCTL_MAGIC, 9, \
272 struct f2fs_move_range)
265 273
266#define F2FS_IOC_SET_ENCRYPTION_POLICY FS_IOC_SET_ENCRYPTION_POLICY 274#define F2FS_IOC_SET_ENCRYPTION_POLICY FS_IOC_SET_ENCRYPTION_POLICY
267#define F2FS_IOC_GET_ENCRYPTION_POLICY FS_IOC_GET_ENCRYPTION_POLICY 275#define F2FS_IOC_GET_ENCRYPTION_POLICY FS_IOC_GET_ENCRYPTION_POLICY
@@ -291,6 +299,13 @@ struct f2fs_defragment {
291 u64 len; 299 u64 len;
292}; 300};
293 301
302struct f2fs_move_range {
303 u32 dst_fd; /* destination fd */
304 u64 pos_in; /* start position in src_fd */
305 u64 pos_out; /* start position in dst_fd */
306 u64 len; /* size to move */
307};
308
294/* 309/*
295 * For INODE and NODE manager 310 * For INODE and NODE manager
296 */ 311 */
@@ -441,11 +456,14 @@ struct f2fs_inode_info {
441 unsigned int clevel; /* maximum level of given file name */ 456 unsigned int clevel; /* maximum level of given file name */
442 nid_t i_xattr_nid; /* node id that contains xattrs */ 457 nid_t i_xattr_nid; /* node id that contains xattrs */
443 unsigned long long xattr_ver; /* cp version of xattr modification */ 458 unsigned long long xattr_ver; /* cp version of xattr modification */
459 loff_t last_disk_size; /* lastly written file size */
444 460
445 struct list_head dirty_list; /* linked in global dirty list */ 461 struct list_head dirty_list; /* dirty list for dirs and files */
462 struct list_head gdirty_list; /* linked in global dirty list */
446 struct list_head inmem_pages; /* inmemory pages managed by f2fs */ 463 struct list_head inmem_pages; /* inmemory pages managed by f2fs */
447 struct mutex inmem_lock; /* lock for inmemory pages */ 464 struct mutex inmem_lock; /* lock for inmemory pages */
448 struct extent_tree *extent_tree; /* cached extent_tree entry */ 465 struct extent_tree *extent_tree; /* cached extent_tree entry */
466 struct rw_semaphore dio_rwsem[2];/* avoid racing between dio and gc */
449}; 467};
450 468
451static inline void get_extent_info(struct extent_info *ext, 469static inline void get_extent_info(struct extent_info *ext,
@@ -498,11 +516,14 @@ static inline bool __is_front_mergeable(struct extent_info *cur,
498 return __is_extent_mergeable(cur, front); 516 return __is_extent_mergeable(cur, front);
499} 517}
500 518
501static inline void __try_update_largest_extent(struct extent_tree *et, 519extern void f2fs_mark_inode_dirty_sync(struct inode *);
502 struct extent_node *en) 520static inline void __try_update_largest_extent(struct inode *inode,
521 struct extent_tree *et, struct extent_node *en)
503{ 522{
504 if (en->ei.len > et->largest.len) 523 if (en->ei.len > et->largest.len) {
505 et->largest = en->ei; 524 et->largest = en->ei;
525 f2fs_mark_inode_dirty_sync(inode);
526 }
506} 527}
507 528
508struct f2fs_nm_info { 529struct f2fs_nm_info {
@@ -517,7 +538,7 @@ struct f2fs_nm_info {
517 /* NAT cache management */ 538 /* NAT cache management */
518 struct radix_tree_root nat_root;/* root of the nat entry cache */ 539 struct radix_tree_root nat_root;/* root of the nat entry cache */
519 struct radix_tree_root nat_set_root;/* root of the nat set cache */ 540 struct radix_tree_root nat_set_root;/* root of the nat set cache */
520 struct rw_semaphore nat_tree_lock; /* protect nat_tree_lock */ 541 struct percpu_rw_semaphore nat_tree_lock; /* protect nat_tree_lock */
521 struct list_head nat_entries; /* cached nat entry list (clean) */ 542 struct list_head nat_entries; /* cached nat entry list (clean) */
522 unsigned int nat_cnt; /* the # of cached nat entries */ 543 unsigned int nat_cnt; /* the # of cached nat entries */
523 unsigned int dirty_nat_cnt; /* total num of nat entries in set */ 544 unsigned int dirty_nat_cnt; /* total num of nat entries in set */
@@ -599,6 +620,7 @@ struct flush_cmd {
599struct flush_cmd_control { 620struct flush_cmd_control {
600 struct task_struct *f2fs_issue_flush; /* flush thread */ 621 struct task_struct *f2fs_issue_flush; /* flush thread */
601 wait_queue_head_t flush_wait_queue; /* waiting queue for wake-up */ 622 wait_queue_head_t flush_wait_queue; /* waiting queue for wake-up */
623 atomic_t submit_flush; /* # of issued flushes */
602 struct llist_head issue_list; /* list for command issue */ 624 struct llist_head issue_list; /* list for command issue */
603 struct llist_node *dispatch_list; /* list for command dispatch */ 625 struct llist_node *dispatch_list; /* list for command dispatch */
604}; 626};
@@ -655,6 +677,7 @@ enum count_type {
655 F2FS_DIRTY_NODES, 677 F2FS_DIRTY_NODES,
656 F2FS_DIRTY_META, 678 F2FS_DIRTY_META,
657 F2FS_INMEM_PAGES, 679 F2FS_INMEM_PAGES,
680 F2FS_DIRTY_IMETA,
658 NR_COUNT_TYPE, 681 NR_COUNT_TYPE,
659}; 682};
660 683
@@ -706,6 +729,7 @@ struct f2fs_bio_info {
706enum inode_type { 729enum inode_type {
707 DIR_INODE, /* for dirty dir inode */ 730 DIR_INODE, /* for dirty dir inode */
708 FILE_INODE, /* for dirty regular/symlink inode */ 731 FILE_INODE, /* for dirty regular/symlink inode */
732 DIRTY_META, /* for all dirtied inode metadata */
709 NR_INODE_TYPE, 733 NR_INODE_TYPE,
710}; 734};
711 735
@@ -757,14 +781,14 @@ struct f2fs_sb_info {
757 /* for bio operations */ 781 /* for bio operations */
758 struct f2fs_bio_info read_io; /* for read bios */ 782 struct f2fs_bio_info read_io; /* for read bios */
759 struct f2fs_bio_info write_io[NR_PAGE_TYPE]; /* for write bios */ 783 struct f2fs_bio_info write_io[NR_PAGE_TYPE]; /* for write bios */
784 struct mutex wio_mutex[NODE + 1]; /* bio ordering for NODE/DATA */
760 785
761 /* for checkpoint */ 786 /* for checkpoint */
762 struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */ 787 struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */
763 struct inode *meta_inode; /* cache meta blocks */ 788 struct inode *meta_inode; /* cache meta blocks */
764 struct mutex cp_mutex; /* checkpoint procedure lock */ 789 struct mutex cp_mutex; /* checkpoint procedure lock */
765 struct rw_semaphore cp_rwsem; /* blocking FS operations */ 790 struct percpu_rw_semaphore cp_rwsem; /* blocking FS operations */
766 struct rw_semaphore node_write; /* locking node writes */ 791 struct rw_semaphore node_write; /* locking node writes */
767 struct mutex writepages; /* mutex for writepages() */
768 wait_queue_head_t cp_wait; 792 wait_queue_head_t cp_wait;
769 unsigned long last_time[MAX_TIME]; /* to store time in jiffies */ 793 unsigned long last_time[MAX_TIME]; /* to store time in jiffies */
770 long interval_time[MAX_TIME]; /* to store thresholds */ 794 long interval_time[MAX_TIME]; /* to store thresholds */
@@ -1050,22 +1074,22 @@ static inline void clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
1050 1074
1051static inline void f2fs_lock_op(struct f2fs_sb_info *sbi) 1075static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
1052{ 1076{
1053 down_read(&sbi->cp_rwsem); 1077 percpu_down_read(&sbi->cp_rwsem);
1054} 1078}
1055 1079
1056static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi) 1080static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
1057{ 1081{
1058 up_read(&sbi->cp_rwsem); 1082 percpu_up_read(&sbi->cp_rwsem);
1059} 1083}
1060 1084
1061static inline void f2fs_lock_all(struct f2fs_sb_info *sbi) 1085static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
1062{ 1086{
1063 down_write(&sbi->cp_rwsem); 1087 percpu_down_write(&sbi->cp_rwsem);
1064} 1088}
1065 1089
1066static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi) 1090static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
1067{ 1091{
1068 up_write(&sbi->cp_rwsem); 1092 percpu_up_write(&sbi->cp_rwsem);
1069} 1093}
1070 1094
1071static inline int __get_cp_reason(struct f2fs_sb_info *sbi) 1095static inline int __get_cp_reason(struct f2fs_sb_info *sbi)
@@ -1120,34 +1144,37 @@ static inline bool f2fs_has_xattr_block(unsigned int ofs)
1120 return ofs == XATTR_NODE_OFFSET; 1144 return ofs == XATTR_NODE_OFFSET;
1121} 1145}
1122 1146
1147static inline void f2fs_i_blocks_write(struct inode *, blkcnt_t, bool);
1123static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi, 1148static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi,
1124 struct inode *inode, blkcnt_t *count) 1149 struct inode *inode, blkcnt_t *count)
1125{ 1150{
1126 block_t valid_block_count; 1151 blkcnt_t diff;
1127 1152
1128 spin_lock(&sbi->stat_lock);
1129#ifdef CONFIG_F2FS_FAULT_INJECTION 1153#ifdef CONFIG_F2FS_FAULT_INJECTION
1130 if (time_to_inject(FAULT_BLOCK)) { 1154 if (time_to_inject(FAULT_BLOCK))
1131 spin_unlock(&sbi->stat_lock);
1132 return false; 1155 return false;
1133 }
1134#endif 1156#endif
1135 valid_block_count = 1157 /*
1136 sbi->total_valid_block_count + (block_t)(*count); 1158 * let's increase this in prior to actual block count change in order
1137 if (unlikely(valid_block_count > sbi->user_block_count)) { 1159 * for f2fs_sync_file to avoid data races when deciding checkpoint.
1138 *count = sbi->user_block_count - sbi->total_valid_block_count; 1160 */
1161 percpu_counter_add(&sbi->alloc_valid_block_count, (*count));
1162
1163 spin_lock(&sbi->stat_lock);
1164 sbi->total_valid_block_count += (block_t)(*count);
1165 if (unlikely(sbi->total_valid_block_count > sbi->user_block_count)) {
1166 diff = sbi->total_valid_block_count - sbi->user_block_count;
1167 *count -= diff;
1168 sbi->total_valid_block_count = sbi->user_block_count;
1139 if (!*count) { 1169 if (!*count) {
1140 spin_unlock(&sbi->stat_lock); 1170 spin_unlock(&sbi->stat_lock);
1171 percpu_counter_sub(&sbi->alloc_valid_block_count, diff);
1141 return false; 1172 return false;
1142 } 1173 }
1143 } 1174 }
1144 /* *count can be recalculated */
1145 inode->i_blocks += *count;
1146 sbi->total_valid_block_count =
1147 sbi->total_valid_block_count + (block_t)(*count);
1148 spin_unlock(&sbi->stat_lock); 1175 spin_unlock(&sbi->stat_lock);
1149 1176
1150 percpu_counter_add(&sbi->alloc_valid_block_count, (*count)); 1177 f2fs_i_blocks_write(inode, *count, true);
1151 return true; 1178 return true;
1152} 1179}
1153 1180
@@ -1158,9 +1185,9 @@ static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
1158 spin_lock(&sbi->stat_lock); 1185 spin_lock(&sbi->stat_lock);
1159 f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count); 1186 f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);
1160 f2fs_bug_on(sbi, inode->i_blocks < count); 1187 f2fs_bug_on(sbi, inode->i_blocks < count);
1161 inode->i_blocks -= count;
1162 sbi->total_valid_block_count -= (block_t)count; 1188 sbi->total_valid_block_count -= (block_t)count;
1163 spin_unlock(&sbi->stat_lock); 1189 spin_unlock(&sbi->stat_lock);
1190 f2fs_i_blocks_write(inode, count, false);
1164} 1191}
1165 1192
1166static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type) 1193static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
@@ -1295,7 +1322,7 @@ static inline bool inc_valid_node_count(struct f2fs_sb_info *sbi,
1295 } 1322 }
1296 1323
1297 if (inode) 1324 if (inode)
1298 inode->i_blocks++; 1325 f2fs_i_blocks_write(inode, 1, true);
1299 1326
1300 sbi->total_valid_node_count++; 1327 sbi->total_valid_node_count++;
1301 sbi->total_valid_block_count++; 1328 sbi->total_valid_block_count++;
@@ -1314,7 +1341,7 @@ static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
1314 f2fs_bug_on(sbi, !sbi->total_valid_node_count); 1341 f2fs_bug_on(sbi, !sbi->total_valid_node_count);
1315 f2fs_bug_on(sbi, !inode->i_blocks); 1342 f2fs_bug_on(sbi, !inode->i_blocks);
1316 1343
1317 inode->i_blocks--; 1344 f2fs_i_blocks_write(inode, 1, false);
1318 sbi->total_valid_node_count--; 1345 sbi->total_valid_node_count--;
1319 sbi->total_valid_block_count--; 1346 sbi->total_valid_block_count--;
1320 1347
@@ -1511,12 +1538,12 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
1511enum { 1538enum {
1512 FI_NEW_INODE, /* indicate newly allocated inode */ 1539 FI_NEW_INODE, /* indicate newly allocated inode */
1513 FI_DIRTY_INODE, /* indicate inode is dirty or not */ 1540 FI_DIRTY_INODE, /* indicate inode is dirty or not */
1541 FI_AUTO_RECOVER, /* indicate inode is recoverable */
1514 FI_DIRTY_DIR, /* indicate directory has dirty pages */ 1542 FI_DIRTY_DIR, /* indicate directory has dirty pages */
1515 FI_INC_LINK, /* need to increment i_nlink */ 1543 FI_INC_LINK, /* need to increment i_nlink */
1516 FI_ACL_MODE, /* indicate acl mode */ 1544 FI_ACL_MODE, /* indicate acl mode */
1517 FI_NO_ALLOC, /* should not allocate any blocks */ 1545 FI_NO_ALLOC, /* should not allocate any blocks */
1518 FI_FREE_NID, /* free allocated nide */ 1546 FI_FREE_NID, /* free allocated nide */
1519 FI_UPDATE_DIR, /* should update inode block for consistency */
1520 FI_NO_EXTENT, /* not to use the extent cache */ 1547 FI_NO_EXTENT, /* not to use the extent cache */
1521 FI_INLINE_XATTR, /* used for inline xattr */ 1548 FI_INLINE_XATTR, /* used for inline xattr */
1522 FI_INLINE_DATA, /* used for inline data*/ 1549 FI_INLINE_DATA, /* used for inline data*/
@@ -1534,64 +1561,143 @@ enum {
1534 FI_DIRTY_FILE, /* indicate regular/symlink has dirty pages */ 1561 FI_DIRTY_FILE, /* indicate regular/symlink has dirty pages */
1535}; 1562};
1536 1563
1537static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag) 1564static inline void __mark_inode_dirty_flag(struct inode *inode,
1565 int flag, bool set)
1566{
1567 switch (flag) {
1568 case FI_INLINE_XATTR:
1569 case FI_INLINE_DATA:
1570 case FI_INLINE_DENTRY:
1571 if (set)
1572 return;
1573 case FI_DATA_EXIST:
1574 case FI_INLINE_DOTS:
1575 f2fs_mark_inode_dirty_sync(inode);
1576 }
1577}
1578
1579static inline void set_inode_flag(struct inode *inode, int flag)
1580{
1581 if (!test_bit(flag, &F2FS_I(inode)->flags))
1582 set_bit(flag, &F2FS_I(inode)->flags);
1583 __mark_inode_dirty_flag(inode, flag, true);
1584}
1585
1586static inline int is_inode_flag_set(struct inode *inode, int flag)
1587{
1588 return test_bit(flag, &F2FS_I(inode)->flags);
1589}
1590
1591static inline void clear_inode_flag(struct inode *inode, int flag)
1592{
1593 if (test_bit(flag, &F2FS_I(inode)->flags))
1594 clear_bit(flag, &F2FS_I(inode)->flags);
1595 __mark_inode_dirty_flag(inode, flag, false);
1596}
1597
1598static inline void set_acl_inode(struct inode *inode, umode_t mode)
1538{ 1599{
1539 if (!test_bit(flag, &fi->flags)) 1600 F2FS_I(inode)->i_acl_mode = mode;
1540 set_bit(flag, &fi->flags); 1601 set_inode_flag(inode, FI_ACL_MODE);
1602 f2fs_mark_inode_dirty_sync(inode);
1541} 1603}
1542 1604
1543static inline int is_inode_flag_set(struct f2fs_inode_info *fi, int flag) 1605static inline void f2fs_i_links_write(struct inode *inode, bool inc)
1544{ 1606{
1545 return test_bit(flag, &fi->flags); 1607 if (inc)
1608 inc_nlink(inode);
1609 else
1610 drop_nlink(inode);
1611 f2fs_mark_inode_dirty_sync(inode);
1612}
1613
1614static inline void f2fs_i_blocks_write(struct inode *inode,
1615 blkcnt_t diff, bool add)
1616{
1617 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
1618 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
1619
1620 inode->i_blocks = add ? inode->i_blocks + diff :
1621 inode->i_blocks - diff;
1622 f2fs_mark_inode_dirty_sync(inode);
1623 if (clean || recover)
1624 set_inode_flag(inode, FI_AUTO_RECOVER);
1625}
1626
1627static inline void f2fs_i_size_write(struct inode *inode, loff_t i_size)
1628{
1629 bool clean = !is_inode_flag_set(inode, FI_DIRTY_INODE);
1630 bool recover = is_inode_flag_set(inode, FI_AUTO_RECOVER);
1631
1632 if (i_size_read(inode) == i_size)
1633 return;
1634
1635 i_size_write(inode, i_size);
1636 f2fs_mark_inode_dirty_sync(inode);
1637 if (clean || recover)
1638 set_inode_flag(inode, FI_AUTO_RECOVER);
1546} 1639}
1547 1640
1548static inline void clear_inode_flag(struct f2fs_inode_info *fi, int flag) 1641static inline bool f2fs_skip_inode_update(struct inode *inode)
1549{ 1642{
1550 if (test_bit(flag, &fi->flags)) 1643 if (!is_inode_flag_set(inode, FI_AUTO_RECOVER))
1551 clear_bit(flag, &fi->flags); 1644 return false;
1645 return F2FS_I(inode)->last_disk_size == i_size_read(inode);
1552} 1646}
1553 1647
1554static inline void set_acl_inode(struct f2fs_inode_info *fi, umode_t mode) 1648static inline void f2fs_i_depth_write(struct inode *inode, unsigned int depth)
1555{ 1649{
1556 fi->i_acl_mode = mode; 1650 F2FS_I(inode)->i_current_depth = depth;
1557 set_inode_flag(fi, FI_ACL_MODE); 1651 f2fs_mark_inode_dirty_sync(inode);
1558} 1652}
1559 1653
1560static inline void get_inline_info(struct f2fs_inode_info *fi, 1654static inline void f2fs_i_xnid_write(struct inode *inode, nid_t xnid)
1561 struct f2fs_inode *ri)
1562{ 1655{
1656 F2FS_I(inode)->i_xattr_nid = xnid;
1657 f2fs_mark_inode_dirty_sync(inode);
1658}
1659
1660static inline void f2fs_i_pino_write(struct inode *inode, nid_t pino)
1661{
1662 F2FS_I(inode)->i_pino = pino;
1663 f2fs_mark_inode_dirty_sync(inode);
1664}
1665
1666static inline void get_inline_info(struct inode *inode, struct f2fs_inode *ri)
1667{
1668 struct f2fs_inode_info *fi = F2FS_I(inode);
1669
1563 if (ri->i_inline & F2FS_INLINE_XATTR) 1670 if (ri->i_inline & F2FS_INLINE_XATTR)
1564 set_inode_flag(fi, FI_INLINE_XATTR); 1671 set_bit(FI_INLINE_XATTR, &fi->flags);
1565 if (ri->i_inline & F2FS_INLINE_DATA) 1672 if (ri->i_inline & F2FS_INLINE_DATA)
1566 set_inode_flag(fi, FI_INLINE_DATA); 1673 set_bit(FI_INLINE_DATA, &fi->flags);
1567 if (ri->i_inline & F2FS_INLINE_DENTRY) 1674 if (ri->i_inline & F2FS_INLINE_DENTRY)
1568 set_inode_flag(fi, FI_INLINE_DENTRY); 1675 set_bit(FI_INLINE_DENTRY, &fi->flags);
1569 if (ri->i_inline & F2FS_DATA_EXIST) 1676 if (ri->i_inline & F2FS_DATA_EXIST)
1570 set_inode_flag(fi, FI_DATA_EXIST); 1677 set_bit(FI_DATA_EXIST, &fi->flags);
1571 if (ri->i_inline & F2FS_INLINE_DOTS) 1678 if (ri->i_inline & F2FS_INLINE_DOTS)
1572 set_inode_flag(fi, FI_INLINE_DOTS); 1679 set_bit(FI_INLINE_DOTS, &fi->flags);
1573} 1680}
1574 1681
1575static inline void set_raw_inline(struct f2fs_inode_info *fi, 1682static inline void set_raw_inline(struct inode *inode, struct f2fs_inode *ri)
1576 struct f2fs_inode *ri)
1577{ 1683{
1578 ri->i_inline = 0; 1684 ri->i_inline = 0;
1579 1685
1580 if (is_inode_flag_set(fi, FI_INLINE_XATTR)) 1686 if (is_inode_flag_set(inode, FI_INLINE_XATTR))
1581 ri->i_inline |= F2FS_INLINE_XATTR; 1687 ri->i_inline |= F2FS_INLINE_XATTR;
1582 if (is_inode_flag_set(fi, FI_INLINE_DATA)) 1688 if (is_inode_flag_set(inode, FI_INLINE_DATA))
1583 ri->i_inline |= F2FS_INLINE_DATA; 1689 ri->i_inline |= F2FS_INLINE_DATA;
1584 if (is_inode_flag_set(fi, FI_INLINE_DENTRY)) 1690 if (is_inode_flag_set(inode, FI_INLINE_DENTRY))
1585 ri->i_inline |= F2FS_INLINE_DENTRY; 1691 ri->i_inline |= F2FS_INLINE_DENTRY;
1586 if (is_inode_flag_set(fi, FI_DATA_EXIST)) 1692 if (is_inode_flag_set(inode, FI_DATA_EXIST))
1587 ri->i_inline |= F2FS_DATA_EXIST; 1693 ri->i_inline |= F2FS_DATA_EXIST;
1588 if (is_inode_flag_set(fi, FI_INLINE_DOTS)) 1694 if (is_inode_flag_set(inode, FI_INLINE_DOTS))
1589 ri->i_inline |= F2FS_INLINE_DOTS; 1695 ri->i_inline |= F2FS_INLINE_DOTS;
1590} 1696}
1591 1697
1592static inline int f2fs_has_inline_xattr(struct inode *inode) 1698static inline int f2fs_has_inline_xattr(struct inode *inode)
1593{ 1699{
1594 return is_inode_flag_set(F2FS_I(inode), FI_INLINE_XATTR); 1700 return is_inode_flag_set(inode, FI_INLINE_XATTR);
1595} 1701}
1596 1702
1597static inline unsigned int addrs_per_inode(struct inode *inode) 1703static inline unsigned int addrs_per_inode(struct inode *inode)
@@ -1618,43 +1724,43 @@ static inline int inline_xattr_size(struct inode *inode)
1618 1724
1619static inline int f2fs_has_inline_data(struct inode *inode) 1725static inline int f2fs_has_inline_data(struct inode *inode)
1620{ 1726{
1621 return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DATA); 1727 return is_inode_flag_set(inode, FI_INLINE_DATA);
1622} 1728}
1623 1729
1624static inline void f2fs_clear_inline_inode(struct inode *inode) 1730static inline void f2fs_clear_inline_inode(struct inode *inode)
1625{ 1731{
1626 clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA); 1732 clear_inode_flag(inode, FI_INLINE_DATA);
1627 clear_inode_flag(F2FS_I(inode), FI_DATA_EXIST); 1733 clear_inode_flag(inode, FI_DATA_EXIST);
1628} 1734}
1629 1735
1630static inline int f2fs_exist_data(struct inode *inode) 1736static inline int f2fs_exist_data(struct inode *inode)
1631{ 1737{
1632 return is_inode_flag_set(F2FS_I(inode), FI_DATA_EXIST); 1738 return is_inode_flag_set(inode, FI_DATA_EXIST);
1633} 1739}
1634 1740
1635static inline int f2fs_has_inline_dots(struct inode *inode) 1741static inline int f2fs_has_inline_dots(struct inode *inode)
1636{ 1742{
1637 return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DOTS); 1743 return is_inode_flag_set(inode, FI_INLINE_DOTS);
1638} 1744}
1639 1745
1640static inline bool f2fs_is_atomic_file(struct inode *inode) 1746static inline bool f2fs_is_atomic_file(struct inode *inode)
1641{ 1747{
1642 return is_inode_flag_set(F2FS_I(inode), FI_ATOMIC_FILE); 1748 return is_inode_flag_set(inode, FI_ATOMIC_FILE);
1643} 1749}
1644 1750
1645static inline bool f2fs_is_volatile_file(struct inode *inode) 1751static inline bool f2fs_is_volatile_file(struct inode *inode)
1646{ 1752{
1647 return is_inode_flag_set(F2FS_I(inode), FI_VOLATILE_FILE); 1753 return is_inode_flag_set(inode, FI_VOLATILE_FILE);
1648} 1754}
1649 1755
1650static inline bool f2fs_is_first_block_written(struct inode *inode) 1756static inline bool f2fs_is_first_block_written(struct inode *inode)
1651{ 1757{
1652 return is_inode_flag_set(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN); 1758 return is_inode_flag_set(inode, FI_FIRST_BLOCK_WRITTEN);
1653} 1759}
1654 1760
1655static inline bool f2fs_is_drop_cache(struct inode *inode) 1761static inline bool f2fs_is_drop_cache(struct inode *inode)
1656{ 1762{
1657 return is_inode_flag_set(F2FS_I(inode), FI_DROP_CACHE); 1763 return is_inode_flag_set(inode, FI_DROP_CACHE);
1658} 1764}
1659 1765
1660static inline void *inline_data_addr(struct page *page) 1766static inline void *inline_data_addr(struct page *page)
@@ -1665,7 +1771,7 @@ static inline void *inline_data_addr(struct page *page)
1665 1771
1666static inline int f2fs_has_inline_dentry(struct inode *inode) 1772static inline int f2fs_has_inline_dentry(struct inode *inode)
1667{ 1773{
1668 return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DENTRY); 1774 return is_inode_flag_set(inode, FI_INLINE_DENTRY);
1669} 1775}
1670 1776
1671static inline void f2fs_dentry_kunmap(struct inode *dir, struct page *page) 1777static inline void f2fs_dentry_kunmap(struct inode *dir, struct page *page)
@@ -1682,11 +1788,13 @@ static inline int is_file(struct inode *inode, int type)
1682static inline void set_file(struct inode *inode, int type) 1788static inline void set_file(struct inode *inode, int type)
1683{ 1789{
1684 F2FS_I(inode)->i_advise |= type; 1790 F2FS_I(inode)->i_advise |= type;
1791 f2fs_mark_inode_dirty_sync(inode);
1685} 1792}
1686 1793
1687static inline void clear_file(struct inode *inode, int type) 1794static inline void clear_file(struct inode *inode, int type)
1688{ 1795{
1689 F2FS_I(inode)->i_advise &= ~type; 1796 F2FS_I(inode)->i_advise &= ~type;
1797 f2fs_mark_inode_dirty_sync(inode);
1690} 1798}
1691 1799
1692static inline int f2fs_readonly(struct super_block *sb) 1800static inline int f2fs_readonly(struct super_block *sb)
@@ -1713,7 +1821,7 @@ static inline bool is_dot_dotdot(const struct qstr *str)
1713static inline bool f2fs_may_extent_tree(struct inode *inode) 1821static inline bool f2fs_may_extent_tree(struct inode *inode)
1714{ 1822{
1715 if (!test_opt(F2FS_I_SB(inode), EXTENT_CACHE) || 1823 if (!test_opt(F2FS_I_SB(inode), EXTENT_CACHE) ||
1716 is_inode_flag_set(F2FS_I(inode), FI_NO_EXTENT)) 1824 is_inode_flag_set(inode, FI_NO_EXTENT))
1717 return false; 1825 return false;
1718 1826
1719 return S_ISREG(inode->i_mode); 1827 return S_ISREG(inode->i_mode);
@@ -1749,7 +1857,7 @@ static inline void *f2fs_kvzalloc(size_t size, gfp_t flags)
1749} 1857}
1750 1858
1751#define get_inode_mode(i) \ 1859#define get_inode_mode(i) \
1752 ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \ 1860 ((is_inode_flag_set(i, FI_ACL_MODE)) ? \
1753 (F2FS_I(i)->i_acl_mode) : ((i)->i_mode)) 1861 (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))
1754 1862
1755/* get offset of first page in next direct node */ 1863/* get offset of first page in next direct node */
@@ -1764,7 +1872,7 @@ static inline void *f2fs_kvzalloc(size_t size, gfp_t flags)
1764int f2fs_sync_file(struct file *, loff_t, loff_t, int); 1872int f2fs_sync_file(struct file *, loff_t, loff_t, int);
1765void truncate_data_blocks(struct dnode_of_data *); 1873void truncate_data_blocks(struct dnode_of_data *);
1766int truncate_blocks(struct inode *, u64, bool); 1874int truncate_blocks(struct inode *, u64, bool);
1767int f2fs_truncate(struct inode *, bool); 1875int f2fs_truncate(struct inode *);
1768int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *); 1876int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
1769int f2fs_setattr(struct dentry *, struct iattr *); 1877int f2fs_setattr(struct dentry *, struct iattr *);
1770int truncate_hole(struct inode *, pgoff_t, pgoff_t); 1878int truncate_hole(struct inode *, pgoff_t, pgoff_t);
@@ -1805,11 +1913,11 @@ struct page *init_inode_metadata(struct inode *, struct inode *,
1805 const struct qstr *, struct page *); 1913 const struct qstr *, struct page *);
1806void update_parent_metadata(struct inode *, struct inode *, unsigned int); 1914void update_parent_metadata(struct inode *, struct inode *, unsigned int);
1807int room_for_filename(const void *, int, int); 1915int room_for_filename(const void *, int, int);
1808void f2fs_drop_nlink(struct inode *, struct inode *, struct page *); 1916void f2fs_drop_nlink(struct inode *, struct inode *);
1809struct f2fs_dir_entry *f2fs_find_entry(struct inode *, struct qstr *, 1917struct f2fs_dir_entry *f2fs_find_entry(struct inode *, struct qstr *,
1810 struct page **); 1918 struct page **);
1811struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **); 1919struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **);
1812ino_t f2fs_inode_by_name(struct inode *, struct qstr *); 1920ino_t f2fs_inode_by_name(struct inode *, struct qstr *, struct page **);
1813void f2fs_set_link(struct inode *, struct f2fs_dir_entry *, 1921void f2fs_set_link(struct inode *, struct f2fs_dir_entry *,
1814 struct page *, struct inode *); 1922 struct page *, struct inode *);
1815int update_dent_inode(struct inode *, struct inode *, const struct qstr *); 1923int update_dent_inode(struct inode *, struct inode *, const struct qstr *);
@@ -1833,6 +1941,8 @@ static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
1833/* 1941/*
1834 * super.c 1942 * super.c
1835 */ 1943 */
1944int f2fs_inode_dirtied(struct inode *);
1945void f2fs_inode_synced(struct inode *);
1836int f2fs_commit_super(struct f2fs_sb_info *, bool); 1946int f2fs_commit_super(struct f2fs_sb_info *, bool);
1837int f2fs_sync_fs(struct super_block *, int); 1947int f2fs_sync_fs(struct super_block *, int);
1838extern __printf(3, 4) 1948extern __printf(3, 4)
@@ -1866,11 +1976,11 @@ struct page *new_node_page(struct dnode_of_data *, unsigned int, struct page *);
1866void ra_node_page(struct f2fs_sb_info *, nid_t); 1976void ra_node_page(struct f2fs_sb_info *, nid_t);
1867struct page *get_node_page(struct f2fs_sb_info *, pgoff_t); 1977struct page *get_node_page(struct f2fs_sb_info *, pgoff_t);
1868struct page *get_node_page_ra(struct page *, int); 1978struct page *get_node_page_ra(struct page *, int);
1869void sync_inode_page(struct dnode_of_data *);
1870void move_node_page(struct page *, int); 1979void move_node_page(struct page *, int);
1871int fsync_node_pages(struct f2fs_sb_info *, nid_t, struct writeback_control *, 1980int fsync_node_pages(struct f2fs_sb_info *, struct inode *,
1872 bool); 1981 struct writeback_control *, bool);
1873int sync_node_pages(struct f2fs_sb_info *, struct writeback_control *); 1982int sync_node_pages(struct f2fs_sb_info *, struct writeback_control *);
1983void build_free_nids(struct f2fs_sb_info *);
1874bool alloc_nid(struct f2fs_sb_info *, nid_t *); 1984bool alloc_nid(struct f2fs_sb_info *, nid_t *);
1875void alloc_nid_done(struct f2fs_sb_info *, nid_t); 1985void alloc_nid_done(struct f2fs_sb_info *, nid_t);
1876void alloc_nid_failed(struct f2fs_sb_info *, nid_t); 1986void alloc_nid_failed(struct f2fs_sb_info *, nid_t);
@@ -1944,9 +2054,10 @@ void add_ino_entry(struct f2fs_sb_info *, nid_t, int type);
1944void remove_ino_entry(struct f2fs_sb_info *, nid_t, int type); 2054void remove_ino_entry(struct f2fs_sb_info *, nid_t, int type);
1945void release_ino_entry(struct f2fs_sb_info *, bool); 2055void release_ino_entry(struct f2fs_sb_info *, bool);
1946bool exist_written_data(struct f2fs_sb_info *, nid_t, int); 2056bool exist_written_data(struct f2fs_sb_info *, nid_t, int);
2057int f2fs_sync_inode_meta(struct f2fs_sb_info *);
1947int acquire_orphan_inode(struct f2fs_sb_info *); 2058int acquire_orphan_inode(struct f2fs_sb_info *);
1948void release_orphan_inode(struct f2fs_sb_info *); 2059void release_orphan_inode(struct f2fs_sb_info *);
1949void add_orphan_inode(struct f2fs_sb_info *, nid_t); 2060void add_orphan_inode(struct inode *);
1950void remove_orphan_inode(struct f2fs_sb_info *, nid_t); 2061void remove_orphan_inode(struct f2fs_sb_info *, nid_t);
1951int recover_orphan_inodes(struct f2fs_sb_info *); 2062int recover_orphan_inodes(struct f2fs_sb_info *);
1952int get_valid_checkpoint(struct f2fs_sb_info *); 2063int get_valid_checkpoint(struct f2fs_sb_info *);
@@ -1981,6 +2092,7 @@ struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool);
1981int do_write_data_page(struct f2fs_io_info *); 2092int do_write_data_page(struct f2fs_io_info *);
1982int f2fs_map_blocks(struct inode *, struct f2fs_map_blocks *, int, int); 2093int f2fs_map_blocks(struct inode *, struct f2fs_map_blocks *, int, int);
1983int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64); 2094int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64);
2095void f2fs_set_page_dirty_nobuffers(struct page *);
1984void f2fs_invalidate_page(struct page *, unsigned int, unsigned int); 2096void f2fs_invalidate_page(struct page *, unsigned int, unsigned int);
1985int f2fs_release_page(struct page *, gfp_t); 2097int f2fs_release_page(struct page *, gfp_t);
1986 2098
@@ -2012,7 +2124,7 @@ struct f2fs_stat_info {
2012 unsigned long long hit_total, total_ext; 2124 unsigned long long hit_total, total_ext;
2013 int ext_tree, zombie_tree, ext_node; 2125 int ext_tree, zombie_tree, ext_node;
2014 s64 ndirty_node, ndirty_dent, ndirty_meta, ndirty_data, inmem_pages; 2126 s64 ndirty_node, ndirty_dent, ndirty_meta, ndirty_data, inmem_pages;
2015 unsigned int ndirty_dirs, ndirty_files; 2127 unsigned int ndirty_dirs, ndirty_files, ndirty_all;
2016 int nats, dirty_nats, sits, dirty_sits, fnids; 2128 int nats, dirty_nats, sits, dirty_sits, fnids;
2017 int total_count, utilization; 2129 int total_count, utilization;
2018 int bg_gc, wb_bios; 2130 int bg_gc, wb_bios;
@@ -2181,7 +2293,6 @@ int f2fs_write_inline_data(struct inode *, struct page *);
2181bool recover_inline_data(struct inode *, struct page *); 2293bool recover_inline_data(struct inode *, struct page *);
2182struct f2fs_dir_entry *find_in_inline_dir(struct inode *, 2294struct f2fs_dir_entry *find_in_inline_dir(struct inode *,
2183 struct fscrypt_name *, struct page **); 2295 struct fscrypt_name *, struct page **);
2184struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *, struct page **);
2185int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *); 2296int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *);
2186int f2fs_add_inline_entry(struct inode *, const struct qstr *, struct inode *, 2297int f2fs_add_inline_entry(struct inode *, const struct qstr *, struct inode *,
2187 nid_t, umode_t); 2298 nid_t, umode_t);
@@ -2206,6 +2317,7 @@ void f2fs_leave_shrinker(struct f2fs_sb_info *);
2206 */ 2317 */
2207unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *, int); 2318unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *, int);
2208bool f2fs_init_extent_tree(struct inode *, struct f2fs_extent *); 2319bool f2fs_init_extent_tree(struct inode *, struct f2fs_extent *);
2320void f2fs_drop_extent_tree(struct inode *);
2209unsigned int f2fs_destroy_extent_node(struct inode *); 2321unsigned int f2fs_destroy_extent_node(struct inode *);
2210void f2fs_destroy_extent_tree(struct inode *); 2322void f2fs_destroy_extent_tree(struct inode *);
2211bool f2fs_lookup_extent_cache(struct inode *, pgoff_t, struct extent_info *); 2323bool f2fs_lookup_extent_cache(struct inode *, pgoff_t, struct extent_info *);
@@ -2241,6 +2353,26 @@ static inline int f2fs_sb_has_crypto(struct super_block *sb)
2241 return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_ENCRYPT); 2353 return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_ENCRYPT);
2242} 2354}
2243 2355
2356static inline int f2fs_sb_mounted_hmsmr(struct super_block *sb)
2357{
2358 return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_HMSMR);
2359}
2360
2361static inline void set_opt_mode(struct f2fs_sb_info *sbi, unsigned int mt)
2362{
2363 clear_opt(sbi, ADAPTIVE);
2364 clear_opt(sbi, LFS);
2365
2366 switch (mt) {
2367 case F2FS_MOUNT_ADAPTIVE:
2368 set_opt(sbi, ADAPTIVE);
2369 break;
2370 case F2FS_MOUNT_LFS:
2371 set_opt(sbi, LFS);
2372 break;
2373 }
2374}
2375
2244static inline bool f2fs_may_encrypt(struct inode *inode) 2376static inline bool f2fs_may_encrypt(struct inode *inode)
2245{ 2377{
2246#ifdef CONFIG_F2FS_FS_ENCRYPTION 2378#ifdef CONFIG_F2FS_FS_ENCRYPTION
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index f4c0086655c4..0e493f63ea41 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -21,6 +21,7 @@
21#include <linux/mount.h> 21#include <linux/mount.h>
22#include <linux/pagevec.h> 22#include <linux/pagevec.h>
23#include <linux/uuid.h> 23#include <linux/uuid.h>
24#include <linux/file.h>
24 25
25#include "f2fs.h" 26#include "f2fs.h"
26#include "node.h" 27#include "node.h"
@@ -81,7 +82,8 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
81 zero_user_segment(page, offset, PAGE_SIZE); 82 zero_user_segment(page, offset, PAGE_SIZE);
82 } 83 }
83 set_page_dirty(page); 84 set_page_dirty(page);
84 SetPageUptodate(page); 85 if (!PageUptodate(page))
86 SetPageUptodate(page);
85 87
86 trace_f2fs_vm_page_mkwrite(page, DATA); 88 trace_f2fs_vm_page_mkwrite(page, DATA);
87mapped: 89mapped:
@@ -171,22 +173,16 @@ static void try_to_fix_pino(struct inode *inode)
171 fi->xattr_ver = 0; 173 fi->xattr_ver = 0;
172 if (file_wrong_pino(inode) && inode->i_nlink == 1 && 174 if (file_wrong_pino(inode) && inode->i_nlink == 1 &&
173 get_parent_ino(inode, &pino)) { 175 get_parent_ino(inode, &pino)) {
174 fi->i_pino = pino; 176 f2fs_i_pino_write(inode, pino);
175 file_got_pino(inode); 177 file_got_pino(inode);
176 up_write(&fi->i_sem);
177
178 mark_inode_dirty_sync(inode);
179 f2fs_write_inode(inode, NULL);
180 } else {
181 up_write(&fi->i_sem);
182 } 178 }
179 up_write(&fi->i_sem);
183} 180}
184 181
185static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end, 182static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
186 int datasync, bool atomic) 183 int datasync, bool atomic)
187{ 184{
188 struct inode *inode = file->f_mapping->host; 185 struct inode *inode = file->f_mapping->host;
189 struct f2fs_inode_info *fi = F2FS_I(inode);
190 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 186 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
191 nid_t ino = inode->i_ino; 187 nid_t ino = inode->i_ino;
192 int ret = 0; 188 int ret = 0;
@@ -204,9 +200,9 @@ static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
204 200
205 /* if fdatasync is triggered, let's do in-place-update */ 201 /* if fdatasync is triggered, let's do in-place-update */
206 if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks) 202 if (datasync || get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)
207 set_inode_flag(fi, FI_NEED_IPU); 203 set_inode_flag(inode, FI_NEED_IPU);
208 ret = filemap_write_and_wait_range(inode->i_mapping, start, end); 204 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
209 clear_inode_flag(fi, FI_NEED_IPU); 205 clear_inode_flag(inode, FI_NEED_IPU);
210 206
211 if (ret) { 207 if (ret) {
212 trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret); 208 trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
@@ -214,7 +210,7 @@ static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
214 } 210 }
215 211
216 /* if the inode is dirty, let's recover all the time */ 212 /* if the inode is dirty, let's recover all the time */
217 if (!datasync) { 213 if (!datasync && !f2fs_skip_inode_update(inode)) {
218 f2fs_write_inode(inode, NULL); 214 f2fs_write_inode(inode, NULL);
219 goto go_write; 215 goto go_write;
220 } 216 }
@@ -222,14 +218,14 @@ static int f2fs_do_sync_file(struct file *file, loff_t start, loff_t end,
222 /* 218 /*
223 * if there is no written data, don't waste time to write recovery info. 219 * if there is no written data, don't waste time to write recovery info.
224 */ 220 */
225 if (!is_inode_flag_set(fi, FI_APPEND_WRITE) && 221 if (!is_inode_flag_set(inode, FI_APPEND_WRITE) &&
226 !exist_written_data(sbi, ino, APPEND_INO)) { 222 !exist_written_data(sbi, ino, APPEND_INO)) {
227 223
228 /* it may call write_inode just prior to fsync */ 224 /* it may call write_inode just prior to fsync */
229 if (need_inode_page_update(sbi, ino)) 225 if (need_inode_page_update(sbi, ino))
230 goto go_write; 226 goto go_write;
231 227
232 if (is_inode_flag_set(fi, FI_UPDATE_WRITE) || 228 if (is_inode_flag_set(inode, FI_UPDATE_WRITE) ||
233 exist_written_data(sbi, ino, UPDATE_INO)) 229 exist_written_data(sbi, ino, UPDATE_INO))
234 goto flush_out; 230 goto flush_out;
235 goto out; 231 goto out;
@@ -239,9 +235,9 @@ go_write:
239 * Both of fdatasync() and fsync() are able to be recovered from 235 * Both of fdatasync() and fsync() are able to be recovered from
240 * sudden-power-off. 236 * sudden-power-off.
241 */ 237 */
242 down_read(&fi->i_sem); 238 down_read(&F2FS_I(inode)->i_sem);
243 need_cp = need_do_checkpoint(inode); 239 need_cp = need_do_checkpoint(inode);
244 up_read(&fi->i_sem); 240 up_read(&F2FS_I(inode)->i_sem);
245 241
246 if (need_cp) { 242 if (need_cp) {
247 /* all the dirty node pages should be flushed for POR */ 243 /* all the dirty node pages should be flushed for POR */
@@ -252,12 +248,12 @@ go_write:
252 * will be used only for fsynced inodes after checkpoint. 248 * will be used only for fsynced inodes after checkpoint.
253 */ 249 */
254 try_to_fix_pino(inode); 250 try_to_fix_pino(inode);
255 clear_inode_flag(fi, FI_APPEND_WRITE); 251 clear_inode_flag(inode, FI_APPEND_WRITE);
256 clear_inode_flag(fi, FI_UPDATE_WRITE); 252 clear_inode_flag(inode, FI_UPDATE_WRITE);
257 goto out; 253 goto out;
258 } 254 }
259sync_nodes: 255sync_nodes:
260 ret = fsync_node_pages(sbi, ino, &wbc, atomic); 256 ret = fsync_node_pages(sbi, inode, &wbc, atomic);
261 if (ret) 257 if (ret)
262 goto out; 258 goto out;
263 259
@@ -268,7 +264,7 @@ sync_nodes:
268 } 264 }
269 265
270 if (need_inode_block_update(sbi, ino)) { 266 if (need_inode_block_update(sbi, ino)) {
271 mark_inode_dirty_sync(inode); 267 f2fs_mark_inode_dirty_sync(inode);
272 f2fs_write_inode(inode, NULL); 268 f2fs_write_inode(inode, NULL);
273 goto sync_nodes; 269 goto sync_nodes;
274 } 270 }
@@ -279,10 +275,10 @@ sync_nodes:
279 275
280 /* once recovery info is written, don't need to tack this */ 276 /* once recovery info is written, don't need to tack this */
281 remove_ino_entry(sbi, ino, APPEND_INO); 277 remove_ino_entry(sbi, ino, APPEND_INO);
282 clear_inode_flag(fi, FI_APPEND_WRITE); 278 clear_inode_flag(inode, FI_APPEND_WRITE);
283flush_out: 279flush_out:
284 remove_ino_entry(sbi, ino, UPDATE_INO); 280 remove_ino_entry(sbi, ino, UPDATE_INO);
285 clear_inode_flag(fi, FI_UPDATE_WRITE); 281 clear_inode_flag(inode, FI_UPDATE_WRITE);
286 ret = f2fs_issue_flush(sbi); 282 ret = f2fs_issue_flush(sbi);
287 f2fs_update_time(sbi, REQ_TIME); 283 f2fs_update_time(sbi, REQ_TIME);
288out: 284out:
@@ -360,7 +356,7 @@ static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
360 356
361 for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) { 357 for (; data_ofs < isize; data_ofs = (loff_t)pgofs << PAGE_SHIFT) {
362 set_new_dnode(&dn, inode, NULL, NULL, 0); 358 set_new_dnode(&dn, inode, NULL, NULL, 0);
363 err = get_dnode_of_data(&dn, pgofs, LOOKUP_NODE_RA); 359 err = get_dnode_of_data(&dn, pgofs, LOOKUP_NODE);
364 if (err && err != -ENOENT) { 360 if (err && err != -ENOENT) {
365 goto fail; 361 goto fail;
366 } else if (err == -ENOENT) { 362 } else if (err == -ENOENT) {
@@ -487,8 +483,7 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
487 set_data_blkaddr(dn); 483 set_data_blkaddr(dn);
488 invalidate_blocks(sbi, blkaddr); 484 invalidate_blocks(sbi, blkaddr);
489 if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page)) 485 if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
490 clear_inode_flag(F2FS_I(dn->inode), 486 clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN);
491 FI_FIRST_BLOCK_WRITTEN);
492 nr_free++; 487 nr_free++;
493 } 488 }
494 489
@@ -502,7 +497,6 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
502 dn->inode) + ofs; 497 dn->inode) + ofs;
503 f2fs_update_extent_cache_range(dn, fofs, 0, len); 498 f2fs_update_extent_cache_range(dn, fofs, 0, len);
504 dec_valid_block_count(sbi, dn->inode, nr_free); 499 dec_valid_block_count(sbi, dn->inode, nr_free);
505 sync_inode_page(dn);
506 } 500 }
507 dn->ofs_in_node = ofs; 501 dn->ofs_in_node = ofs;
508 502
@@ -616,7 +610,7 @@ free_partial:
616 return err; 610 return err;
617} 611}
618 612
619int f2fs_truncate(struct inode *inode, bool lock) 613int f2fs_truncate(struct inode *inode)
620{ 614{
621 int err; 615 int err;
622 616
@@ -633,12 +627,12 @@ int f2fs_truncate(struct inode *inode, bool lock)
633 return err; 627 return err;
634 } 628 }
635 629
636 err = truncate_blocks(inode, i_size_read(inode), lock); 630 err = truncate_blocks(inode, i_size_read(inode), true);
637 if (err) 631 if (err)
638 return err; 632 return err;
639 633
640 inode->i_mtime = inode->i_ctime = CURRENT_TIME; 634 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
641 mark_inode_dirty(inode); 635 f2fs_mark_inode_dirty_sync(inode);
642 return 0; 636 return 0;
643} 637}
644 638
@@ -654,7 +648,6 @@ int f2fs_getattr(struct vfsmount *mnt,
654#ifdef CONFIG_F2FS_FS_POSIX_ACL 648#ifdef CONFIG_F2FS_FS_POSIX_ACL
655static void __setattr_copy(struct inode *inode, const struct iattr *attr) 649static void __setattr_copy(struct inode *inode, const struct iattr *attr)
656{ 650{
657 struct f2fs_inode_info *fi = F2FS_I(inode);
658 unsigned int ia_valid = attr->ia_valid; 651 unsigned int ia_valid = attr->ia_valid;
659 652
660 if (ia_valid & ATTR_UID) 653 if (ia_valid & ATTR_UID)
@@ -675,7 +668,7 @@ static void __setattr_copy(struct inode *inode, const struct iattr *attr)
675 668
676 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID)) 669 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
677 mode &= ~S_ISGID; 670 mode &= ~S_ISGID;
678 set_acl_inode(fi, mode); 671 set_acl_inode(inode, mode);
679 } 672 }
680} 673}
681#else 674#else
@@ -685,7 +678,6 @@ static void __setattr_copy(struct inode *inode, const struct iattr *attr)
685int f2fs_setattr(struct dentry *dentry, struct iattr *attr) 678int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
686{ 679{
687 struct inode *inode = d_inode(dentry); 680 struct inode *inode = d_inode(dentry);
688 struct f2fs_inode_info *fi = F2FS_I(inode);
689 int err; 681 int err;
690 682
691 err = inode_change_ok(inode, attr); 683 err = inode_change_ok(inode, attr);
@@ -699,7 +691,7 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
699 691
700 if (attr->ia_size <= i_size_read(inode)) { 692 if (attr->ia_size <= i_size_read(inode)) {
701 truncate_setsize(inode, attr->ia_size); 693 truncate_setsize(inode, attr->ia_size);
702 err = f2fs_truncate(inode, true); 694 err = f2fs_truncate(inode);
703 if (err) 695 if (err)
704 return err; 696 return err;
705 f2fs_balance_fs(F2FS_I_SB(inode), true); 697 f2fs_balance_fs(F2FS_I_SB(inode), true);
@@ -724,13 +716,13 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
724 716
725 if (attr->ia_valid & ATTR_MODE) { 717 if (attr->ia_valid & ATTR_MODE) {
726 err = posix_acl_chmod(inode, get_inode_mode(inode)); 718 err = posix_acl_chmod(inode, get_inode_mode(inode));
727 if (err || is_inode_flag_set(fi, FI_ACL_MODE)) { 719 if (err || is_inode_flag_set(inode, FI_ACL_MODE)) {
728 inode->i_mode = fi->i_acl_mode; 720 inode->i_mode = F2FS_I(inode)->i_acl_mode;
729 clear_inode_flag(fi, FI_ACL_MODE); 721 clear_inode_flag(inode, FI_ACL_MODE);
730 } 722 }
731 } 723 }
732 724
733 mark_inode_dirty(inode); 725 f2fs_mark_inode_dirty_sync(inode);
734 return err; 726 return err;
735} 727}
736 728
@@ -859,79 +851,199 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
859 return ret; 851 return ret;
860} 852}
861 853
862static int __exchange_data_block(struct inode *inode, pgoff_t src, 854static int __read_out_blkaddrs(struct inode *inode, block_t *blkaddr,
863 pgoff_t dst, bool full) 855 int *do_replace, pgoff_t off, pgoff_t len)
864{ 856{
865 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 857 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
866 struct dnode_of_data dn; 858 struct dnode_of_data dn;
867 block_t new_addr; 859 int ret, done, i;
868 bool do_replace = false;
869 int ret;
870 860
861next_dnode:
871 set_new_dnode(&dn, inode, NULL, NULL, 0); 862 set_new_dnode(&dn, inode, NULL, NULL, 0);
872 ret = get_dnode_of_data(&dn, src, LOOKUP_NODE_RA); 863 ret = get_dnode_of_data(&dn, off, LOOKUP_NODE_RA);
873 if (ret && ret != -ENOENT) { 864 if (ret && ret != -ENOENT) {
874 return ret; 865 return ret;
875 } else if (ret == -ENOENT) { 866 } else if (ret == -ENOENT) {
876 new_addr = NULL_ADDR; 867 if (dn.max_level == 0)
877 } else { 868 return -ENOENT;
878 new_addr = dn.data_blkaddr; 869 done = min((pgoff_t)ADDRS_PER_BLOCK - dn.ofs_in_node, len);
879 if (!is_checkpointed_data(sbi, new_addr)) { 870 blkaddr += done;
871 do_replace += done;
872 goto next;
873 }
874
875 done = min((pgoff_t)ADDRS_PER_PAGE(dn.node_page, inode) -
876 dn.ofs_in_node, len);
877 for (i = 0; i < done; i++, blkaddr++, do_replace++, dn.ofs_in_node++) {
878 *blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
879 if (!is_checkpointed_data(sbi, *blkaddr)) {
880
881 if (test_opt(sbi, LFS)) {
882 f2fs_put_dnode(&dn);
883 return -ENOTSUPP;
884 }
885
880 /* do not invalidate this block address */ 886 /* do not invalidate this block address */
881 f2fs_update_data_blkaddr(&dn, NULL_ADDR); 887 f2fs_update_data_blkaddr(&dn, NULL_ADDR);
882 do_replace = true; 888 *do_replace = 1;
883 } 889 }
884 f2fs_put_dnode(&dn);
885 } 890 }
891 f2fs_put_dnode(&dn);
892next:
893 len -= done;
894 off += done;
895 if (len)
896 goto next_dnode;
897 return 0;
898}
886 899
887 if (new_addr == NULL_ADDR) 900static int __roll_back_blkaddrs(struct inode *inode, block_t *blkaddr,
888 return full ? truncate_hole(inode, dst, dst + 1) : 0; 901 int *do_replace, pgoff_t off, int len)
902{
903 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
904 struct dnode_of_data dn;
905 int ret, i;
889 906
890 if (do_replace) { 907 for (i = 0; i < len; i++, do_replace++, blkaddr++) {
891 struct page *ipage = get_node_page(sbi, inode->i_ino); 908 if (*do_replace == 0)
892 struct node_info ni; 909 continue;
893 910
894 if (IS_ERR(ipage)) { 911 set_new_dnode(&dn, inode, NULL, NULL, 0);
895 ret = PTR_ERR(ipage); 912 ret = get_dnode_of_data(&dn, off + i, LOOKUP_NODE_RA);
896 goto err_out; 913 if (ret) {
914 dec_valid_block_count(sbi, inode, 1);
915 invalidate_blocks(sbi, *blkaddr);
916 } else {
917 f2fs_update_data_blkaddr(&dn, *blkaddr);
897 } 918 }
919 f2fs_put_dnode(&dn);
920 }
921 return 0;
922}
898 923
899 set_new_dnode(&dn, inode, ipage, NULL, 0); 924static int __clone_blkaddrs(struct inode *src_inode, struct inode *dst_inode,
900 ret = f2fs_reserve_block(&dn, dst); 925 block_t *blkaddr, int *do_replace,
901 if (ret) 926 pgoff_t src, pgoff_t dst, pgoff_t len, bool full)
902 goto err_out; 927{
928 struct f2fs_sb_info *sbi = F2FS_I_SB(src_inode);
929 pgoff_t i = 0;
930 int ret;
931
932 while (i < len) {
933 if (blkaddr[i] == NULL_ADDR && !full) {
934 i++;
935 continue;
936 }
903 937
904 truncate_data_blocks_range(&dn, 1); 938 if (do_replace[i] || blkaddr[i] == NULL_ADDR) {
939 struct dnode_of_data dn;
940 struct node_info ni;
941 size_t new_size;
942 pgoff_t ilen;
905 943
906 get_node_info(sbi, dn.nid, &ni); 944 set_new_dnode(&dn, dst_inode, NULL, NULL, 0);
907 f2fs_replace_block(sbi, &dn, dn.data_blkaddr, new_addr, 945 ret = get_dnode_of_data(&dn, dst + i, ALLOC_NODE);
908 ni.version, true, false); 946 if (ret)
909 f2fs_put_dnode(&dn); 947 return ret;
910 } else { 948
911 struct page *psrc, *pdst; 949 get_node_info(sbi, dn.nid, &ni);
950 ilen = min((pgoff_t)
951 ADDRS_PER_PAGE(dn.node_page, dst_inode) -
952 dn.ofs_in_node, len - i);
953 do {
954 dn.data_blkaddr = datablock_addr(dn.node_page,
955 dn.ofs_in_node);
956 truncate_data_blocks_range(&dn, 1);
957
958 if (do_replace[i]) {
959 f2fs_i_blocks_write(src_inode,
960 1, false);
961 f2fs_i_blocks_write(dst_inode,
962 1, true);
963 f2fs_replace_block(sbi, &dn, dn.data_blkaddr,
964 blkaddr[i], ni.version, true, false);
965
966 do_replace[i] = 0;
967 }
968 dn.ofs_in_node++;
969 i++;
970 new_size = (dst + i) << PAGE_SHIFT;
971 if (dst_inode->i_size < new_size)
972 f2fs_i_size_write(dst_inode, new_size);
973 } while ((do_replace[i] || blkaddr[i] == NULL_ADDR) && --ilen);
912 974
913 psrc = get_lock_data_page(inode, src, true); 975 f2fs_put_dnode(&dn);
914 if (IS_ERR(psrc)) 976 } else {
915 return PTR_ERR(psrc); 977 struct page *psrc, *pdst;
916 pdst = get_new_data_page(inode, NULL, dst, true); 978
917 if (IS_ERR(pdst)) { 979 psrc = get_lock_data_page(src_inode, src + i, true);
980 if (IS_ERR(psrc))
981 return PTR_ERR(psrc);
982 pdst = get_new_data_page(dst_inode, NULL, dst + i,
983 true);
984 if (IS_ERR(pdst)) {
985 f2fs_put_page(psrc, 1);
986 return PTR_ERR(pdst);
987 }
988 f2fs_copy_page(psrc, pdst);
989 set_page_dirty(pdst);
990 f2fs_put_page(pdst, 1);
918 f2fs_put_page(psrc, 1); 991 f2fs_put_page(psrc, 1);
919 return PTR_ERR(pdst);
920 }
921 f2fs_copy_page(psrc, pdst);
922 set_page_dirty(pdst);
923 f2fs_put_page(pdst, 1);
924 f2fs_put_page(psrc, 1);
925 992
926 return truncate_hole(inode, src, src + 1); 993 ret = truncate_hole(src_inode, src + i, src + i + 1);
994 if (ret)
995 return ret;
996 i++;
997 }
927 } 998 }
928 return 0; 999 return 0;
1000}
929 1001
930err_out: 1002static int __exchange_data_block(struct inode *src_inode,
931 if (!get_dnode_of_data(&dn, src, LOOKUP_NODE)) { 1003 struct inode *dst_inode, pgoff_t src, pgoff_t dst,
932 f2fs_update_data_blkaddr(&dn, new_addr); 1004 pgoff_t len, bool full)
933 f2fs_put_dnode(&dn); 1005{
1006 block_t *src_blkaddr;
1007 int *do_replace;
1008 pgoff_t olen;
1009 int ret;
1010
1011 while (len) {
1012 olen = min((pgoff_t)4 * ADDRS_PER_BLOCK, len);
1013
1014 src_blkaddr = f2fs_kvzalloc(sizeof(block_t) * olen, GFP_KERNEL);
1015 if (!src_blkaddr)
1016 return -ENOMEM;
1017
1018 do_replace = f2fs_kvzalloc(sizeof(int) * olen, GFP_KERNEL);
1019 if (!do_replace) {
1020 kvfree(src_blkaddr);
1021 return -ENOMEM;
1022 }
1023
1024 ret = __read_out_blkaddrs(src_inode, src_blkaddr,
1025 do_replace, src, olen);
1026 if (ret)
1027 goto roll_back;
1028
1029 ret = __clone_blkaddrs(src_inode, dst_inode, src_blkaddr,
1030 do_replace, src, dst, olen, full);
1031 if (ret)
1032 goto roll_back;
1033
1034 src += olen;
1035 dst += olen;
1036 len -= olen;
1037
1038 kvfree(src_blkaddr);
1039 kvfree(do_replace);
934 } 1040 }
1041 return 0;
1042
1043roll_back:
1044 __roll_back_blkaddrs(src_inode, src_blkaddr, do_replace, src, len);
1045 kvfree(src_blkaddr);
1046 kvfree(do_replace);
935 return ret; 1047 return ret;
936} 1048}
937 1049
@@ -939,16 +1051,15 @@ static int f2fs_do_collapse(struct inode *inode, pgoff_t start, pgoff_t end)
939{ 1051{
940 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1052 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
941 pgoff_t nrpages = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE; 1053 pgoff_t nrpages = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;
942 int ret = 0; 1054 int ret;
943 1055
944 for (; end < nrpages; start++, end++) { 1056 f2fs_balance_fs(sbi, true);
945 f2fs_balance_fs(sbi, true); 1057 f2fs_lock_op(sbi);
946 f2fs_lock_op(sbi); 1058
947 ret = __exchange_data_block(inode, end, start, true); 1059 f2fs_drop_extent_tree(inode);
948 f2fs_unlock_op(sbi); 1060
949 if (ret) 1061 ret = __exchange_data_block(inode, inode, end, start, nrpages - end, true);
950 break; 1062 f2fs_unlock_op(sbi);
951 }
952 return ret; 1063 return ret;
953} 1064}
954 1065
@@ -992,7 +1103,7 @@ static int f2fs_collapse_range(struct inode *inode, loff_t offset, loff_t len)
992 1103
993 ret = truncate_blocks(inode, new_size, true); 1104 ret = truncate_blocks(inode, new_size, true);
994 if (!ret) 1105 if (!ret)
995 i_size_write(inode, new_size); 1106 f2fs_i_size_write(inode, new_size);
996 1107
997 return ret; 1108 return ret;
998} 1109}
@@ -1128,11 +1239,8 @@ static int f2fs_zero_range(struct inode *inode, loff_t offset, loff_t len,
1128 } 1239 }
1129 1240
1130out: 1241out:
1131 if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size) { 1242 if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size)
1132 i_size_write(inode, new_size); 1243 f2fs_i_size_write(inode, new_size);
1133 mark_inode_dirty(inode);
1134 update_inode_page(inode);
1135 }
1136 1244
1137 return ret; 1245 return ret;
1138} 1246}
@@ -1140,7 +1248,7 @@ out:
1140static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len) 1248static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
1141{ 1249{
1142 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 1250 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1143 pgoff_t pg_start, pg_end, delta, nrpages, idx; 1251 pgoff_t nr, pg_start, pg_end, delta, idx;
1144 loff_t new_size; 1252 loff_t new_size;
1145 int ret = 0; 1253 int ret = 0;
1146 1254
@@ -1175,14 +1283,20 @@ static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
1175 pg_start = offset >> PAGE_SHIFT; 1283 pg_start = offset >> PAGE_SHIFT;
1176 pg_end = (offset + len) >> PAGE_SHIFT; 1284 pg_end = (offset + len) >> PAGE_SHIFT;
1177 delta = pg_end - pg_start; 1285 delta = pg_end - pg_start;
1178 nrpages = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE; 1286 idx = (i_size_read(inode) + PAGE_SIZE - 1) / PAGE_SIZE;
1287
1288 while (!ret && idx > pg_start) {
1289 nr = idx - pg_start;
1290 if (nr > delta)
1291 nr = delta;
1292 idx -= nr;
1179 1293
1180 for (idx = nrpages - 1; idx >= pg_start && idx != -1; idx--) {
1181 f2fs_lock_op(sbi); 1294 f2fs_lock_op(sbi);
1182 ret = __exchange_data_block(inode, idx, idx + delta, false); 1295 f2fs_drop_extent_tree(inode);
1296
1297 ret = __exchange_data_block(inode, inode, idx,
1298 idx + delta, nr, false);
1183 f2fs_unlock_op(sbi); 1299 f2fs_unlock_op(sbi);
1184 if (ret)
1185 break;
1186 } 1300 }
1187 1301
1188 /* write out all moved pages, if possible */ 1302 /* write out all moved pages, if possible */
@@ -1190,7 +1304,7 @@ static int f2fs_insert_range(struct inode *inode, loff_t offset, loff_t len)
1190 truncate_pagecache(inode, offset); 1304 truncate_pagecache(inode, offset);
1191 1305
1192 if (!ret) 1306 if (!ret)
1193 i_size_write(inode, new_size); 1307 f2fs_i_size_write(inode, new_size);
1194 return ret; 1308 return ret;
1195} 1309}
1196 1310
@@ -1238,11 +1352,8 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
1238 new_size = ((loff_t)pg_end << PAGE_SHIFT) + off_end; 1352 new_size = ((loff_t)pg_end << PAGE_SHIFT) + off_end;
1239 } 1353 }
1240 1354
1241 if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size) { 1355 if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size)
1242 i_size_write(inode, new_size); 1356 f2fs_i_size_write(inode, new_size);
1243 mark_inode_dirty(inode);
1244 update_inode_page(inode);
1245 }
1246 1357
1247 return ret; 1358 return ret;
1248} 1359}
@@ -1285,7 +1396,7 @@ static long f2fs_fallocate(struct file *file, int mode,
1285 1396
1286 if (!ret) { 1397 if (!ret) {
1287 inode->i_mtime = inode->i_ctime = CURRENT_TIME; 1398 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
1288 mark_inode_dirty(inode); 1399 f2fs_mark_inode_dirty_sync(inode);
1289 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 1400 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1290 } 1401 }
1291 1402
@@ -1310,10 +1421,10 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
1310 if (f2fs_is_atomic_file(inode)) 1421 if (f2fs_is_atomic_file(inode))
1311 drop_inmem_pages(inode); 1422 drop_inmem_pages(inode);
1312 if (f2fs_is_volatile_file(inode)) { 1423 if (f2fs_is_volatile_file(inode)) {
1313 clear_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE); 1424 clear_inode_flag(inode, FI_VOLATILE_FILE);
1314 set_inode_flag(F2FS_I(inode), FI_DROP_CACHE); 1425 set_inode_flag(inode, FI_DROP_CACHE);
1315 filemap_fdatawrite(inode->i_mapping); 1426 filemap_fdatawrite(inode->i_mapping);
1316 clear_inode_flag(F2FS_I(inode), FI_DROP_CACHE); 1427 clear_inode_flag(inode, FI_DROP_CACHE);
1317 } 1428 }
1318 return 0; 1429 return 0;
1319} 1430}
@@ -1376,9 +1487,8 @@ static int f2fs_ioc_setflags(struct file *filp, unsigned long arg)
1376 fi->i_flags = flags; 1487 fi->i_flags = flags;
1377 inode_unlock(inode); 1488 inode_unlock(inode);
1378 1489
1379 f2fs_set_inode_flags(inode);
1380 inode->i_ctime = CURRENT_TIME; 1490 inode->i_ctime = CURRENT_TIME;
1381 mark_inode_dirty(inode); 1491 f2fs_set_inode_flags(inode);
1382out: 1492out:
1383 mnt_drop_write_file(filp); 1493 mnt_drop_write_file(filp);
1384 return ret; 1494 return ret;
@@ -1412,7 +1522,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
1412 if (ret) 1522 if (ret)
1413 goto out; 1523 goto out;
1414 1524
1415 set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE); 1525 set_inode_flag(inode, FI_ATOMIC_FILE);
1416 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 1526 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1417 1527
1418 if (!get_dirty_pages(inode)) 1528 if (!get_dirty_pages(inode))
@@ -1423,7 +1533,7 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
1423 inode->i_ino, get_dirty_pages(inode)); 1533 inode->i_ino, get_dirty_pages(inode));
1424 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX); 1534 ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
1425 if (ret) 1535 if (ret)
1426 clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE); 1536 clear_inode_flag(inode, FI_ATOMIC_FILE);
1427out: 1537out:
1428 inode_unlock(inode); 1538 inode_unlock(inode);
1429 mnt_drop_write_file(filp); 1539 mnt_drop_write_file(filp);
@@ -1448,10 +1558,10 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
1448 goto err_out; 1558 goto err_out;
1449 1559
1450 if (f2fs_is_atomic_file(inode)) { 1560 if (f2fs_is_atomic_file(inode)) {
1451 clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE); 1561 clear_inode_flag(inode, FI_ATOMIC_FILE);
1452 ret = commit_inmem_pages(inode); 1562 ret = commit_inmem_pages(inode);
1453 if (ret) { 1563 if (ret) {
1454 set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE); 1564 set_inode_flag(inode, FI_ATOMIC_FILE);
1455 goto err_out; 1565 goto err_out;
1456 } 1566 }
1457 } 1567 }
@@ -1484,7 +1594,7 @@ static int f2fs_ioc_start_volatile_write(struct file *filp)
1484 if (ret) 1594 if (ret)
1485 goto out; 1595 goto out;
1486 1596
1487 set_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE); 1597 set_inode_flag(inode, FI_VOLATILE_FILE);
1488 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME); 1598 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
1489out: 1599out:
1490 inode_unlock(inode); 1600 inode_unlock(inode);
@@ -1538,7 +1648,7 @@ static int f2fs_ioc_abort_volatile_write(struct file *filp)
1538 if (f2fs_is_atomic_file(inode)) 1648 if (f2fs_is_atomic_file(inode))
1539 drop_inmem_pages(inode); 1649 drop_inmem_pages(inode);
1540 if (f2fs_is_volatile_file(inode)) { 1650 if (f2fs_is_volatile_file(inode)) {
1541 clear_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE); 1651 clear_inode_flag(inode, FI_VOLATILE_FILE);
1542 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true); 1652 ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
1543 } 1653 }
1544 1654
@@ -1871,7 +1981,7 @@ do_map:
1871 continue; 1981 continue;
1872 } 1982 }
1873 1983
1874 set_inode_flag(F2FS_I(inode), FI_DO_DEFRAG); 1984 set_inode_flag(inode, FI_DO_DEFRAG);
1875 1985
1876 idx = map.m_lblk; 1986 idx = map.m_lblk;
1877 while (idx < map.m_lblk + map.m_len && cnt < blk_per_seg) { 1987 while (idx < map.m_lblk + map.m_len && cnt < blk_per_seg) {
@@ -1896,14 +2006,14 @@ do_map:
1896 if (idx < pg_end && cnt < blk_per_seg) 2006 if (idx < pg_end && cnt < blk_per_seg)
1897 goto do_map; 2007 goto do_map;
1898 2008
1899 clear_inode_flag(F2FS_I(inode), FI_DO_DEFRAG); 2009 clear_inode_flag(inode, FI_DO_DEFRAG);
1900 2010
1901 err = filemap_fdatawrite(inode->i_mapping); 2011 err = filemap_fdatawrite(inode->i_mapping);
1902 if (err) 2012 if (err)
1903 goto out; 2013 goto out;
1904 } 2014 }
1905clear_out: 2015clear_out:
1906 clear_inode_flag(F2FS_I(inode), FI_DO_DEFRAG); 2016 clear_inode_flag(inode, FI_DO_DEFRAG);
1907out: 2017out:
1908 inode_unlock(inode); 2018 inode_unlock(inode);
1909 if (!err) 2019 if (!err)
@@ -1959,6 +2069,133 @@ out:
1959 return err; 2069 return err;
1960} 2070}
1961 2071
2072static int f2fs_move_file_range(struct file *file_in, loff_t pos_in,
2073 struct file *file_out, loff_t pos_out, size_t len)
2074{
2075 struct inode *src = file_inode(file_in);
2076 struct inode *dst = file_inode(file_out);
2077 struct f2fs_sb_info *sbi = F2FS_I_SB(src);
2078 size_t olen = len, dst_max_i_size = 0;
2079 size_t dst_osize;
2080 int ret;
2081
2082 if (file_in->f_path.mnt != file_out->f_path.mnt ||
2083 src->i_sb != dst->i_sb)
2084 return -EXDEV;
2085
2086 if (unlikely(f2fs_readonly(src->i_sb)))
2087 return -EROFS;
2088
2089 if (S_ISDIR(src->i_mode) || S_ISDIR(dst->i_mode))
2090 return -EISDIR;
2091
2092 if (f2fs_encrypted_inode(src) || f2fs_encrypted_inode(dst))
2093 return -EOPNOTSUPP;
2094
2095 inode_lock(src);
2096 if (src != dst)
2097 inode_lock(dst);
2098
2099 ret = -EINVAL;
2100 if (pos_in + len > src->i_size || pos_in + len < pos_in)
2101 goto out_unlock;
2102 if (len == 0)
2103 olen = len = src->i_size - pos_in;
2104 if (pos_in + len == src->i_size)
2105 len = ALIGN(src->i_size, F2FS_BLKSIZE) - pos_in;
2106 if (len == 0) {
2107 ret = 0;
2108 goto out_unlock;
2109 }
2110
2111 dst_osize = dst->i_size;
2112 if (pos_out + olen > dst->i_size)
2113 dst_max_i_size = pos_out + olen;
2114
2115 /* verify the end result is block aligned */
2116 if (!IS_ALIGNED(pos_in, F2FS_BLKSIZE) ||
2117 !IS_ALIGNED(pos_in + len, F2FS_BLKSIZE) ||
2118 !IS_ALIGNED(pos_out, F2FS_BLKSIZE))
2119 goto out_unlock;
2120
2121 ret = f2fs_convert_inline_inode(src);
2122 if (ret)
2123 goto out_unlock;
2124
2125 ret = f2fs_convert_inline_inode(dst);
2126 if (ret)
2127 goto out_unlock;
2128
2129 /* write out all dirty pages from offset */
2130 ret = filemap_write_and_wait_range(src->i_mapping,
2131 pos_in, pos_in + len);
2132 if (ret)
2133 goto out_unlock;
2134
2135 ret = filemap_write_and_wait_range(dst->i_mapping,
2136 pos_out, pos_out + len);
2137 if (ret)
2138 goto out_unlock;
2139
2140 f2fs_balance_fs(sbi, true);
2141 f2fs_lock_op(sbi);
2142 ret = __exchange_data_block(src, dst, pos_in,
2143 pos_out, len >> F2FS_BLKSIZE_BITS, false);
2144
2145 if (!ret) {
2146 if (dst_max_i_size)
2147 f2fs_i_size_write(dst, dst_max_i_size);
2148 else if (dst_osize != dst->i_size)
2149 f2fs_i_size_write(dst, dst_osize);
2150 }
2151 f2fs_unlock_op(sbi);
2152out_unlock:
2153 if (src != dst)
2154 inode_unlock(dst);
2155 inode_unlock(src);
2156 return ret;
2157}
2158
2159static int f2fs_ioc_move_range(struct file *filp, unsigned long arg)
2160{
2161 struct f2fs_move_range range;
2162 struct fd dst;
2163 int err;
2164
2165 if (!(filp->f_mode & FMODE_READ) ||
2166 !(filp->f_mode & FMODE_WRITE))
2167 return -EBADF;
2168
2169 if (copy_from_user(&range, (struct f2fs_move_range __user *)arg,
2170 sizeof(range)))
2171 return -EFAULT;
2172
2173 dst = fdget(range.dst_fd);
2174 if (!dst.file)
2175 return -EBADF;
2176
2177 if (!(dst.file->f_mode & FMODE_WRITE)) {
2178 err = -EBADF;
2179 goto err_out;
2180 }
2181
2182 err = mnt_want_write_file(filp);
2183 if (err)
2184 goto err_out;
2185
2186 err = f2fs_move_file_range(filp, range.pos_in, dst.file,
2187 range.pos_out, range.len);
2188
2189 mnt_drop_write_file(filp);
2190
2191 if (copy_to_user((struct f2fs_move_range __user *)arg,
2192 &range, sizeof(range)))
2193 err = -EFAULT;
2194err_out:
2195 fdput(dst);
2196 return err;
2197}
2198
1962long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 2199long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1963{ 2200{
1964 switch (cmd) { 2201 switch (cmd) {
@@ -1994,6 +2231,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1994 return f2fs_ioc_write_checkpoint(filp, arg); 2231 return f2fs_ioc_write_checkpoint(filp, arg);
1995 case F2FS_IOC_DEFRAGMENT: 2232 case F2FS_IOC_DEFRAGMENT:
1996 return f2fs_ioc_defragment(filp, arg); 2233 return f2fs_ioc_defragment(filp, arg);
2234 case F2FS_IOC_MOVE_RANGE:
2235 return f2fs_ioc_move_range(filp, arg);
1997 default: 2236 default:
1998 return -ENOTTY; 2237 return -ENOTTY;
1999 } 2238 }
@@ -2003,6 +2242,7 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
2003{ 2242{
2004 struct file *file = iocb->ki_filp; 2243 struct file *file = iocb->ki_filp;
2005 struct inode *inode = file_inode(file); 2244 struct inode *inode = file_inode(file);
2245 struct blk_plug plug;
2006 ssize_t ret; 2246 ssize_t ret;
2007 2247
2008 if (f2fs_encrypted_inode(inode) && 2248 if (f2fs_encrypted_inode(inode) &&
@@ -2014,8 +2254,11 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
2014 ret = generic_write_checks(iocb, from); 2254 ret = generic_write_checks(iocb, from);
2015 if (ret > 0) { 2255 if (ret > 0) {
2016 ret = f2fs_preallocate_blocks(iocb, from); 2256 ret = f2fs_preallocate_blocks(iocb, from);
2017 if (!ret) 2257 if (!ret) {
2258 blk_start_plug(&plug);
2018 ret = __generic_file_write_iter(iocb, from); 2259 ret = __generic_file_write_iter(iocb, from);
2260 blk_finish_plug(&plug);
2261 }
2019 } 2262 }
2020 inode_unlock(inode); 2263 inode_unlock(inode);
2021 2264
@@ -2050,6 +2293,8 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2050 case F2FS_IOC_WRITE_CHECKPOINT: 2293 case F2FS_IOC_WRITE_CHECKPOINT:
2051 case F2FS_IOC_DEFRAGMENT: 2294 case F2FS_IOC_DEFRAGMENT:
2052 break; 2295 break;
2296 case F2FS_IOC_MOVE_RANGE:
2297 break;
2053 default: 2298 default:
2054 return -ENOIOCTLCMD; 2299 return -ENOIOCTLCMD;
2055 } 2300 }
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index f06ed73adf99..8f7fa326ce95 100644
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -594,11 +594,11 @@ static void move_encrypted_block(struct inode *inode, block_t bidx)
594 /* write page */ 594 /* write page */
595 lock_page(fio.encrypted_page); 595 lock_page(fio.encrypted_page);
596 596
597 if (unlikely(!PageUptodate(fio.encrypted_page))) { 597 if (unlikely(fio.encrypted_page->mapping != META_MAPPING(fio.sbi))) {
598 err = -EIO; 598 err = -EIO;
599 goto put_page_out; 599 goto put_page_out;
600 } 600 }
601 if (unlikely(fio.encrypted_page->mapping != META_MAPPING(fio.sbi))) { 601 if (unlikely(!PageUptodate(fio.encrypted_page))) {
602 err = -EIO; 602 err = -EIO;
603 goto put_page_out; 603 goto put_page_out;
604 } 604 }
@@ -619,9 +619,9 @@ static void move_encrypted_block(struct inode *inode, block_t bidx)
619 f2fs_submit_page_mbio(&fio); 619 f2fs_submit_page_mbio(&fio);
620 620
621 f2fs_update_data_blkaddr(&dn, newaddr); 621 f2fs_update_data_blkaddr(&dn, newaddr);
622 set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE); 622 set_inode_flag(inode, FI_APPEND_WRITE);
623 if (page->index == 0) 623 if (page->index == 0)
624 set_inode_flag(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN); 624 set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);
625put_page_out: 625put_page_out:
626 f2fs_put_page(fio.encrypted_page, 1); 626 f2fs_put_page(fio.encrypted_page, 1);
627recover_block: 627recover_block:
@@ -656,12 +656,23 @@ static void move_data_page(struct inode *inode, block_t bidx, int gc_type)
656 .page = page, 656 .page = page,
657 .encrypted_page = NULL, 657 .encrypted_page = NULL,
658 }; 658 };
659 bool is_dirty = PageDirty(page);
660 int err;
661
662retry:
659 set_page_dirty(page); 663 set_page_dirty(page);
660 f2fs_wait_on_page_writeback(page, DATA, true); 664 f2fs_wait_on_page_writeback(page, DATA, true);
661 if (clear_page_dirty_for_io(page)) 665 if (clear_page_dirty_for_io(page))
662 inode_dec_dirty_pages(inode); 666 inode_dec_dirty_pages(inode);
667
663 set_cold_data(page); 668 set_cold_data(page);
664 do_write_data_page(&fio); 669
670 err = do_write_data_page(&fio);
671 if (err == -ENOMEM && is_dirty) {
672 congestion_wait(BLK_RW_ASYNC, HZ/50);
673 goto retry;
674 }
675
665 clear_cold_data(page); 676 clear_cold_data(page);
666 } 677 }
667out: 678out:
@@ -748,12 +759,32 @@ next_step:
748 /* phase 3 */ 759 /* phase 3 */
749 inode = find_gc_inode(gc_list, dni.ino); 760 inode = find_gc_inode(gc_list, dni.ino);
750 if (inode) { 761 if (inode) {
762 struct f2fs_inode_info *fi = F2FS_I(inode);
763 bool locked = false;
764
765 if (S_ISREG(inode->i_mode)) {
766 if (!down_write_trylock(&fi->dio_rwsem[READ]))
767 continue;
768 if (!down_write_trylock(
769 &fi->dio_rwsem[WRITE])) {
770 up_write(&fi->dio_rwsem[READ]);
771 continue;
772 }
773 locked = true;
774 }
775
751 start_bidx = start_bidx_of_node(nofs, inode) 776 start_bidx = start_bidx_of_node(nofs, inode)
752 + ofs_in_node; 777 + ofs_in_node;
753 if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) 778 if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
754 move_encrypted_block(inode, start_bidx); 779 move_encrypted_block(inode, start_bidx);
755 else 780 else
756 move_data_page(inode, start_bidx, gc_type); 781 move_data_page(inode, start_bidx, gc_type);
782
783 if (locked) {
784 up_write(&fi->dio_rwsem[WRITE]);
785 up_write(&fi->dio_rwsem[READ]);
786 }
787
757 stat_inc_data_blk_count(sbi, 1, gc_type); 788 stat_inc_data_blk_count(sbi, 1, gc_type);
758 } 789 }
759 } 790 }
@@ -802,6 +833,10 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,
802 blk_start_plug(&plug); 833 blk_start_plug(&plug);
803 834
804 for (segno = start_segno; segno < end_segno; segno++) { 835 for (segno = start_segno; segno < end_segno; segno++) {
836
837 if (get_valid_blocks(sbi, segno, 1) == 0)
838 continue;
839
805 /* find segment summary of victim */ 840 /* find segment summary of victim */
806 sum_page = find_get_page(META_MAPPING(sbi), 841 sum_page = find_get_page(META_MAPPING(sbi),
807 GET_SUM_BLOCK(sbi, segno)); 842 GET_SUM_BLOCK(sbi, segno));
@@ -877,10 +912,13 @@ gc_more:
877 * enough free sections, we should flush dent/node blocks and do 912 * enough free sections, we should flush dent/node blocks and do
878 * garbage collections. 913 * garbage collections.
879 */ 914 */
880 if (__get_victim(sbi, &segno, gc_type) || prefree_segments(sbi)) 915 if (__get_victim(sbi, &segno, gc_type) ||
916 prefree_segments(sbi)) {
881 write_checkpoint(sbi, &cpc); 917 write_checkpoint(sbi, &cpc);
882 else if (has_not_enough_free_secs(sbi, 0)) 918 segno = NULL_SEGNO;
919 } else if (has_not_enough_free_secs(sbi, 0)) {
883 write_checkpoint(sbi, &cpc); 920 write_checkpoint(sbi, &cpc);
921 }
884 } 922 }
885 923
886 if (segno == NULL_SEGNO && !__get_victim(sbi, &segno, gc_type)) 924 if (segno == NULL_SEGNO && !__get_victim(sbi, &segno, gc_type))
diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index c15e53c1d794..ccea8735de59 100644
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -59,7 +59,8 @@ void read_inline_data(struct page *page, struct page *ipage)
59 memcpy(dst_addr, src_addr, MAX_INLINE_DATA); 59 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
60 flush_dcache_page(page); 60 flush_dcache_page(page);
61 kunmap_atomic(dst_addr); 61 kunmap_atomic(dst_addr);
62 SetPageUptodate(page); 62 if (!PageUptodate(page))
63 SetPageUptodate(page);
63} 64}
64 65
65bool truncate_inline_inode(struct page *ipage, u64 from) 66bool truncate_inline_inode(struct page *ipage, u64 from)
@@ -73,7 +74,7 @@ bool truncate_inline_inode(struct page *ipage, u64 from)
73 74
74 f2fs_wait_on_page_writeback(ipage, NODE, true); 75 f2fs_wait_on_page_writeback(ipage, NODE, true);
75 memset(addr + from, 0, MAX_INLINE_DATA - from); 76 memset(addr + from, 0, MAX_INLINE_DATA - from);
76 77 set_page_dirty(ipage);
77 return true; 78 return true;
78} 79}
79 80
@@ -97,7 +98,8 @@ int f2fs_read_inline_data(struct inode *inode, struct page *page)
97 else 98 else
98 read_inline_data(page, ipage); 99 read_inline_data(page, ipage);
99 100
100 SetPageUptodate(page); 101 if (!PageUptodate(page))
102 SetPageUptodate(page);
101 f2fs_put_page(ipage, 1); 103 f2fs_put_page(ipage, 1);
102 unlock_page(page); 104 unlock_page(page);
103 return 0; 105 return 0;
@@ -139,7 +141,7 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
139 inode_dec_dirty_pages(dn->inode); 141 inode_dec_dirty_pages(dn->inode);
140 142
141 /* this converted inline_data should be recovered. */ 143 /* this converted inline_data should be recovered. */
142 set_inode_flag(F2FS_I(dn->inode), FI_APPEND_WRITE); 144 set_inode_flag(dn->inode, FI_APPEND_WRITE);
143 145
144 /* clear inline data and flag after data writeback */ 146 /* clear inline data and flag after data writeback */
145 truncate_inline_inode(dn->inode_page, 0); 147 truncate_inline_inode(dn->inode_page, 0);
@@ -147,7 +149,6 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
147clear_out: 149clear_out:
148 stat_dec_inline_inode(dn->inode); 150 stat_dec_inline_inode(dn->inode);
149 f2fs_clear_inline_inode(dn->inode); 151 f2fs_clear_inline_inode(dn->inode);
150 sync_inode_page(dn);
151 f2fs_put_dnode(dn); 152 f2fs_put_dnode(dn);
152 return 0; 153 return 0;
153} 154}
@@ -213,11 +214,11 @@ int f2fs_write_inline_data(struct inode *inode, struct page *page)
213 dst_addr = inline_data_addr(dn.inode_page); 214 dst_addr = inline_data_addr(dn.inode_page);
214 memcpy(dst_addr, src_addr, MAX_INLINE_DATA); 215 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
215 kunmap_atomic(src_addr); 216 kunmap_atomic(src_addr);
217 set_page_dirty(dn.inode_page);
216 218
217 set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE); 219 set_inode_flag(inode, FI_APPEND_WRITE);
218 set_inode_flag(F2FS_I(inode), FI_DATA_EXIST); 220 set_inode_flag(inode, FI_DATA_EXIST);
219 221
220 sync_inode_page(&dn);
221 clear_inline_node(dn.inode_page); 222 clear_inline_node(dn.inode_page);
222 f2fs_put_dnode(&dn); 223 f2fs_put_dnode(&dn);
223 return 0; 224 return 0;
@@ -253,10 +254,10 @@ process_inline:
253 dst_addr = inline_data_addr(ipage); 254 dst_addr = inline_data_addr(ipage);
254 memcpy(dst_addr, src_addr, MAX_INLINE_DATA); 255 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
255 256
256 set_inode_flag(F2FS_I(inode), FI_INLINE_DATA); 257 set_inode_flag(inode, FI_INLINE_DATA);
257 set_inode_flag(F2FS_I(inode), FI_DATA_EXIST); 258 set_inode_flag(inode, FI_DATA_EXIST);
258 259
259 update_inode(inode, ipage); 260 set_page_dirty(ipage);
260 f2fs_put_page(ipage, 1); 261 f2fs_put_page(ipage, 1);
261 return true; 262 return true;
262 } 263 }
@@ -267,7 +268,6 @@ process_inline:
267 if (!truncate_inline_inode(ipage, 0)) 268 if (!truncate_inline_inode(ipage, 0))
268 return false; 269 return false;
269 f2fs_clear_inline_inode(inode); 270 f2fs_clear_inline_inode(inode);
270 update_inode(inode, ipage);
271 f2fs_put_page(ipage, 1); 271 f2fs_put_page(ipage, 1);
272 } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) { 272 } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
273 if (truncate_blocks(inode, 0, false)) 273 if (truncate_blocks(inode, 0, false))
@@ -289,8 +289,10 @@ struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
289 f2fs_hash_t namehash; 289 f2fs_hash_t namehash;
290 290
291 ipage = get_node_page(sbi, dir->i_ino); 291 ipage = get_node_page(sbi, dir->i_ino);
292 if (IS_ERR(ipage)) 292 if (IS_ERR(ipage)) {
293 *res_page = ipage;
293 return NULL; 294 return NULL;
295 }
294 296
295 namehash = f2fs_dentry_hash(&name); 297 namehash = f2fs_dentry_hash(&name);
296 298
@@ -307,25 +309,6 @@ struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
307 return de; 309 return de;
308} 310}
309 311
310struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *dir,
311 struct page **p)
312{
313 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
314 struct page *ipage;
315 struct f2fs_dir_entry *de;
316 struct f2fs_inline_dentry *dentry_blk;
317
318 ipage = get_node_page(sbi, dir->i_ino);
319 if (IS_ERR(ipage))
320 return NULL;
321
322 dentry_blk = inline_data_addr(ipage);
323 de = &dentry_blk->dentry[1];
324 *p = ipage;
325 unlock_page(ipage);
326 return de;
327}
328
329int make_empty_inline_dir(struct inode *inode, struct inode *parent, 312int make_empty_inline_dir(struct inode *inode, struct inode *parent,
330 struct page *ipage) 313 struct page *ipage)
331{ 314{
@@ -340,10 +323,8 @@ int make_empty_inline_dir(struct inode *inode, struct inode *parent,
340 set_page_dirty(ipage); 323 set_page_dirty(ipage);
341 324
342 /* update i_size to MAX_INLINE_DATA */ 325 /* update i_size to MAX_INLINE_DATA */
343 if (i_size_read(inode) < MAX_INLINE_DATA) { 326 if (i_size_read(inode) < MAX_INLINE_DATA)
344 i_size_write(inode, MAX_INLINE_DATA); 327 f2fs_i_size_write(inode, MAX_INLINE_DATA);
345 set_inode_flag(F2FS_I(inode), FI_UPDATE_DIR);
346 }
347 return 0; 328 return 0;
348} 329}
349 330
@@ -392,22 +373,19 @@ static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,
392 NR_INLINE_DENTRY * F2FS_SLOT_LEN); 373 NR_INLINE_DENTRY * F2FS_SLOT_LEN);
393 374
394 kunmap_atomic(dentry_blk); 375 kunmap_atomic(dentry_blk);
395 SetPageUptodate(page); 376 if (!PageUptodate(page))
377 SetPageUptodate(page);
396 set_page_dirty(page); 378 set_page_dirty(page);
397 379
398 /* clear inline dir and flag after data writeback */ 380 /* clear inline dir and flag after data writeback */
399 truncate_inline_inode(ipage, 0); 381 truncate_inline_inode(ipage, 0);
400 382
401 stat_dec_inline_dir(dir); 383 stat_dec_inline_dir(dir);
402 clear_inode_flag(F2FS_I(dir), FI_INLINE_DENTRY); 384 clear_inode_flag(dir, FI_INLINE_DENTRY);
403 385
404 F2FS_I(dir)->i_current_depth = 1; 386 f2fs_i_depth_write(dir, 1);
405 if (i_size_read(dir) < PAGE_SIZE) { 387 if (i_size_read(dir) < PAGE_SIZE)
406 i_size_write(dir, PAGE_SIZE); 388 f2fs_i_size_write(dir, PAGE_SIZE);
407 set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
408 }
409
410 sync_inode_page(&dn);
411out: 389out:
412 f2fs_put_page(page, 1); 390 f2fs_put_page(page, 1);
413 return err; 391 return err;
@@ -465,7 +443,6 @@ static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
465 struct f2fs_inline_dentry *inline_dentry) 443 struct f2fs_inline_dentry *inline_dentry)
466{ 444{
467 struct f2fs_inline_dentry *backup_dentry; 445 struct f2fs_inline_dentry *backup_dentry;
468 struct f2fs_inode_info *fi = F2FS_I(dir);
469 int err; 446 int err;
470 447
471 backup_dentry = f2fs_kmalloc(sizeof(struct f2fs_inline_dentry), 448 backup_dentry = f2fs_kmalloc(sizeof(struct f2fs_inline_dentry),
@@ -487,16 +464,15 @@ static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
487 lock_page(ipage); 464 lock_page(ipage);
488 465
489 stat_dec_inline_dir(dir); 466 stat_dec_inline_dir(dir);
490 clear_inode_flag(fi, FI_INLINE_DENTRY); 467 clear_inode_flag(dir, FI_INLINE_DENTRY);
491 update_inode(dir, ipage);
492 kfree(backup_dentry); 468 kfree(backup_dentry);
493 return 0; 469 return 0;
494recover: 470recover:
495 lock_page(ipage); 471 lock_page(ipage);
496 memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA); 472 memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA);
497 fi->i_current_depth = 0; 473 f2fs_i_depth_write(dir, 0);
498 i_size_write(dir, MAX_INLINE_DATA); 474 f2fs_i_size_write(dir, MAX_INLINE_DATA);
499 update_inode(dir, ipage); 475 set_page_dirty(ipage);
500 f2fs_put_page(ipage, 1); 476 f2fs_put_page(ipage, 1);
501 477
502 kfree(backup_dentry); 478 kfree(backup_dentry);
@@ -560,8 +536,7 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,
560 536
561 /* we don't need to mark_inode_dirty now */ 537 /* we don't need to mark_inode_dirty now */
562 if (inode) { 538 if (inode) {
563 F2FS_I(inode)->i_pino = dir->i_ino; 539 f2fs_i_pino_write(inode, dir->i_ino);
564 update_inode(inode, page);
565 f2fs_put_page(page, 1); 540 f2fs_put_page(page, 1);
566 } 541 }
567 542
@@ -569,11 +544,6 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,
569fail: 544fail:
570 if (inode) 545 if (inode)
571 up_write(&F2FS_I(inode)->i_sem); 546 up_write(&F2FS_I(inode)->i_sem);
572
573 if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {
574 update_inode(dir, ipage);
575 clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
576 }
577out: 547out:
578 f2fs_put_page(ipage, 1); 548 f2fs_put_page(ipage, 1);
579 return err; 549 return err;
@@ -597,13 +567,13 @@ void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
597 &inline_dentry->dentry_bitmap); 567 &inline_dentry->dentry_bitmap);
598 568
599 set_page_dirty(page); 569 set_page_dirty(page);
570 f2fs_put_page(page, 1);
600 571
601 dir->i_ctime = dir->i_mtime = CURRENT_TIME; 572 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
573 f2fs_mark_inode_dirty_sync(dir);
602 574
603 if (inode) 575 if (inode)
604 f2fs_drop_nlink(dir, inode, page); 576 f2fs_drop_nlink(dir, inode);
605
606 f2fs_put_page(page, 1);
607} 577}
608 578
609bool f2fs_empty_inline_dir(struct inode *dir) 579bool f2fs_empty_inline_dir(struct inode *dir)
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 2e68adab0d64..9ac5efc15347 100644
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -18,6 +18,13 @@
18 18
19#include <trace/events/f2fs.h> 19#include <trace/events/f2fs.h>
20 20
21void f2fs_mark_inode_dirty_sync(struct inode *inode)
22{
23 if (f2fs_inode_dirtied(inode))
24 return;
25 mark_inode_dirty_sync(inode);
26}
27
21void f2fs_set_inode_flags(struct inode *inode) 28void f2fs_set_inode_flags(struct inode *inode)
22{ 29{
23 unsigned int flags = F2FS_I(inode)->i_flags; 30 unsigned int flags = F2FS_I(inode)->i_flags;
@@ -35,6 +42,7 @@ void f2fs_set_inode_flags(struct inode *inode)
35 new_fl |= S_DIRSYNC; 42 new_fl |= S_DIRSYNC;
36 inode_set_flags(inode, new_fl, 43 inode_set_flags(inode, new_fl,
37 S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC); 44 S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
45 f2fs_mark_inode_dirty_sync(inode);
38} 46}
39 47
40static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri) 48static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
@@ -85,8 +93,8 @@ static void __recover_inline_status(struct inode *inode, struct page *ipage)
85 if (*start++) { 93 if (*start++) {
86 f2fs_wait_on_page_writeback(ipage, NODE, true); 94 f2fs_wait_on_page_writeback(ipage, NODE, true);
87 95
88 set_inode_flag(F2FS_I(inode), FI_DATA_EXIST); 96 set_inode_flag(inode, FI_DATA_EXIST);
89 set_raw_inline(F2FS_I(inode), F2FS_INODE(ipage)); 97 set_raw_inline(inode, F2FS_INODE(ipage));
90 set_page_dirty(ipage); 98 set_page_dirty(ipage);
91 return; 99 return;
92 } 100 }
@@ -141,7 +149,7 @@ static int do_read_inode(struct inode *inode)
141 if (f2fs_init_extent_tree(inode, &ri->i_ext)) 149 if (f2fs_init_extent_tree(inode, &ri->i_ext))
142 set_page_dirty(node_page); 150 set_page_dirty(node_page);
143 151
144 get_inline_info(fi, ri); 152 get_inline_info(inode, ri);
145 153
146 /* check data exist */ 154 /* check data exist */
147 if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode)) 155 if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode))
@@ -151,7 +159,10 @@ static int do_read_inode(struct inode *inode)
151 __get_inode_rdev(inode, ri); 159 __get_inode_rdev(inode, ri);
152 160
153 if (__written_first_block(ri)) 161 if (__written_first_block(ri))
154 set_inode_flag(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN); 162 set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);
163
164 if (!need_inode_block_update(sbi, inode->i_ino))
165 fi->last_disk_size = inode->i_size;
155 166
156 f2fs_put_page(node_page, 1); 167 f2fs_put_page(node_page, 1);
157 168
@@ -227,6 +238,8 @@ int update_inode(struct inode *inode, struct page *node_page)
227{ 238{
228 struct f2fs_inode *ri; 239 struct f2fs_inode *ri;
229 240
241 f2fs_inode_synced(inode);
242
230 f2fs_wait_on_page_writeback(node_page, NODE, true); 243 f2fs_wait_on_page_writeback(node_page, NODE, true);
231 244
232 ri = F2FS_INODE(node_page); 245 ri = F2FS_INODE(node_page);
@@ -244,7 +257,7 @@ int update_inode(struct inode *inode, struct page *node_page)
244 &ri->i_ext); 257 &ri->i_ext);
245 else 258 else
246 memset(&ri->i_ext, 0, sizeof(ri->i_ext)); 259 memset(&ri->i_ext, 0, sizeof(ri->i_ext));
247 set_raw_inline(F2FS_I(inode), ri); 260 set_raw_inline(inode, ri);
248 261
249 ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec); 262 ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
250 ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); 263 ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
@@ -261,7 +274,6 @@ int update_inode(struct inode *inode, struct page *node_page)
261 274
262 __set_inode_rdev(inode, ri); 275 __set_inode_rdev(inode, ri);
263 set_cold_node(inode, node_page); 276 set_cold_node(inode, node_page);
264 clear_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);
265 277
266 /* deleted inode */ 278 /* deleted inode */
267 if (inode->i_nlink == 0) 279 if (inode->i_nlink == 0)
@@ -285,6 +297,7 @@ retry:
285 } else if (err != -ENOENT) { 297 } else if (err != -ENOENT) {
286 f2fs_stop_checkpoint(sbi, false); 298 f2fs_stop_checkpoint(sbi, false);
287 } 299 }
300 f2fs_inode_synced(inode);
288 return 0; 301 return 0;
289 } 302 }
290 ret = update_inode(inode, node_page); 303 ret = update_inode(inode, node_page);
@@ -300,7 +313,7 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
300 inode->i_ino == F2FS_META_INO(sbi)) 313 inode->i_ino == F2FS_META_INO(sbi))
301 return 0; 314 return 0;
302 315
303 if (!is_inode_flag_set(F2FS_I(inode), FI_DIRTY_INODE)) 316 if (!is_inode_flag_set(inode, FI_DIRTY_INODE))
304 return 0; 317 return 0;
305 318
306 /* 319 /*
@@ -318,8 +331,7 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
318void f2fs_evict_inode(struct inode *inode) 331void f2fs_evict_inode(struct inode *inode)
319{ 332{
320 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 333 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
321 struct f2fs_inode_info *fi = F2FS_I(inode); 334 nid_t xnid = F2FS_I(inode)->i_xattr_nid;
322 nid_t xnid = fi->i_xattr_nid;
323 int err = 0; 335 int err = 0;
324 336
325 /* some remained atomic pages should discarded */ 337 /* some remained atomic pages should discarded */
@@ -341,12 +353,17 @@ void f2fs_evict_inode(struct inode *inode)
341 if (inode->i_nlink || is_bad_inode(inode)) 353 if (inode->i_nlink || is_bad_inode(inode))
342 goto no_delete; 354 goto no_delete;
343 355
356#ifdef CONFIG_F2FS_FAULT_INJECTION
357 if (time_to_inject(FAULT_EVICT_INODE))
358 goto no_delete;
359#endif
360
344 sb_start_intwrite(inode->i_sb); 361 sb_start_intwrite(inode->i_sb);
345 set_inode_flag(fi, FI_NO_ALLOC); 362 set_inode_flag(inode, FI_NO_ALLOC);
346 i_size_write(inode, 0); 363 i_size_write(inode, 0);
347retry: 364retry:
348 if (F2FS_HAS_BLOCKS(inode)) 365 if (F2FS_HAS_BLOCKS(inode))
349 err = f2fs_truncate(inode, true); 366 err = f2fs_truncate(inode);
350 367
351 if (!err) { 368 if (!err) {
352 f2fs_lock_op(sbi); 369 f2fs_lock_op(sbi);
@@ -360,6 +377,8 @@ retry:
360 goto retry; 377 goto retry;
361 } 378 }
362 379
380 if (err)
381 update_inode_page(inode);
363 sb_end_intwrite(inode->i_sb); 382 sb_end_intwrite(inode->i_sb);
364no_delete: 383no_delete:
365 stat_dec_inline_xattr(inode); 384 stat_dec_inline_xattr(inode);
@@ -369,13 +388,13 @@ no_delete:
369 invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino); 388 invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino);
370 if (xnid) 389 if (xnid)
371 invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid); 390 invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);
372 if (is_inode_flag_set(fi, FI_APPEND_WRITE)) 391 if (is_inode_flag_set(inode, FI_APPEND_WRITE))
373 add_ino_entry(sbi, inode->i_ino, APPEND_INO); 392 add_ino_entry(sbi, inode->i_ino, APPEND_INO);
374 if (is_inode_flag_set(fi, FI_UPDATE_WRITE)) 393 if (is_inode_flag_set(inode, FI_UPDATE_WRITE))
375 add_ino_entry(sbi, inode->i_ino, UPDATE_INO); 394 add_ino_entry(sbi, inode->i_ino, UPDATE_INO);
376 if (is_inode_flag_set(fi, FI_FREE_NID)) { 395 if (is_inode_flag_set(inode, FI_FREE_NID)) {
377 alloc_nid_failed(sbi, inode->i_ino); 396 alloc_nid_failed(sbi, inode->i_ino);
378 clear_inode_flag(fi, FI_FREE_NID); 397 clear_inode_flag(inode, FI_FREE_NID);
379 } 398 }
380 f2fs_bug_on(sbi, err && 399 f2fs_bug_on(sbi, err &&
381 !exist_written_data(sbi, inode->i_ino, ORPHAN_INO)); 400 !exist_written_data(sbi, inode->i_ino, ORPHAN_INO));
@@ -407,11 +426,11 @@ void handle_failed_inode(struct inode *inode)
407 f2fs_msg(sbi->sb, KERN_WARNING, 426 f2fs_msg(sbi->sb, KERN_WARNING,
408 "Too many orphan inodes, run fsck to fix."); 427 "Too many orphan inodes, run fsck to fix.");
409 } else { 428 } else {
410 add_orphan_inode(sbi, inode->i_ino); 429 add_orphan_inode(inode);
411 } 430 }
412 alloc_nid_done(sbi, inode->i_ino); 431 alloc_nid_done(sbi, inode->i_ino);
413 } else { 432 } else {
414 set_inode_flag(F2FS_I(inode), FI_FREE_NID); 433 set_inode_flag(inode, FI_FREE_NID);
415 } 434 }
416 435
417 f2fs_unlock_op(sbi); 436 f2fs_unlock_op(sbi);
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
index 324ed3812f30..73fa356f8fbb 100644
--- a/fs/f2fs/namei.c
+++ b/fs/f2fs/namei.c
@@ -60,10 +60,14 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
60 if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode)) 60 if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode))
61 f2fs_set_encrypted_inode(inode); 61 f2fs_set_encrypted_inode(inode);
62 62
63 set_inode_flag(inode, FI_NEW_INODE);
64
65 if (test_opt(sbi, INLINE_XATTR))
66 set_inode_flag(inode, FI_INLINE_XATTR);
63 if (test_opt(sbi, INLINE_DATA) && f2fs_may_inline_data(inode)) 67 if (test_opt(sbi, INLINE_DATA) && f2fs_may_inline_data(inode))
64 set_inode_flag(F2FS_I(inode), FI_INLINE_DATA); 68 set_inode_flag(inode, FI_INLINE_DATA);
65 if (f2fs_may_inline_dentry(inode)) 69 if (f2fs_may_inline_dentry(inode))
66 set_inode_flag(F2FS_I(inode), FI_INLINE_DENTRY); 70 set_inode_flag(inode, FI_INLINE_DENTRY);
67 71
68 f2fs_init_extent_tree(inode, NULL); 72 f2fs_init_extent_tree(inode, NULL);
69 73
@@ -72,14 +76,13 @@ static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
72 stat_inc_inline_dir(inode); 76 stat_inc_inline_dir(inode);
73 77
74 trace_f2fs_new_inode(inode, 0); 78 trace_f2fs_new_inode(inode, 0);
75 mark_inode_dirty(inode);
76 return inode; 79 return inode;
77 80
78fail: 81fail:
79 trace_f2fs_new_inode(inode, err); 82 trace_f2fs_new_inode(inode, err);
80 make_bad_inode(inode); 83 make_bad_inode(inode);
81 if (nid_free) 84 if (nid_free)
82 set_inode_flag(F2FS_I(inode), FI_FREE_NID); 85 set_inode_flag(inode, FI_FREE_NID);
83 iput(inode); 86 iput(inode);
84 return ERR_PTR(err); 87 return ERR_PTR(err);
85} 88}
@@ -177,7 +180,7 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
177 inode->i_ctime = CURRENT_TIME; 180 inode->i_ctime = CURRENT_TIME;
178 ihold(inode); 181 ihold(inode);
179 182
180 set_inode_flag(F2FS_I(inode), FI_INC_LINK); 183 set_inode_flag(inode, FI_INC_LINK);
181 f2fs_lock_op(sbi); 184 f2fs_lock_op(sbi);
182 err = f2fs_add_link(dentry, inode); 185 err = f2fs_add_link(dentry, inode);
183 if (err) 186 if (err)
@@ -190,7 +193,7 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
190 f2fs_sync_fs(sbi->sb, 1); 193 f2fs_sync_fs(sbi->sb, 1);
191 return 0; 194 return 0;
192out: 195out:
193 clear_inode_flag(F2FS_I(inode), FI_INC_LINK); 196 clear_inode_flag(inode, FI_INC_LINK);
194 iput(inode); 197 iput(inode);
195 f2fs_unlock_op(sbi); 198 f2fs_unlock_op(sbi);
196 return err; 199 return err;
@@ -199,9 +202,13 @@ out:
199struct dentry *f2fs_get_parent(struct dentry *child) 202struct dentry *f2fs_get_parent(struct dentry *child)
200{ 203{
201 struct qstr dotdot = QSTR_INIT("..", 2); 204 struct qstr dotdot = QSTR_INIT("..", 2);
202 unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot); 205 struct page *page;
203 if (!ino) 206 unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot, &page);
207 if (!ino) {
208 if (IS_ERR(page))
209 return ERR_CAST(page);
204 return ERR_PTR(-ENOENT); 210 return ERR_PTR(-ENOENT);
211 }
205 return d_obtain_alias(f2fs_iget(child->d_sb, ino)); 212 return d_obtain_alias(f2fs_iget(child->d_sb, ino));
206} 213}
207 214
@@ -229,6 +236,9 @@ static int __recover_dot_dentries(struct inode *dir, nid_t pino)
229 if (de) { 236 if (de) {
230 f2fs_dentry_kunmap(dir, page); 237 f2fs_dentry_kunmap(dir, page);
231 f2fs_put_page(page, 0); 238 f2fs_put_page(page, 0);
239 } else if (IS_ERR(page)) {
240 err = PTR_ERR(page);
241 goto out;
232 } else { 242 } else {
233 err = __f2fs_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR); 243 err = __f2fs_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);
234 if (err) 244 if (err)
@@ -239,14 +249,14 @@ static int __recover_dot_dentries(struct inode *dir, nid_t pino)
239 if (de) { 249 if (de) {
240 f2fs_dentry_kunmap(dir, page); 250 f2fs_dentry_kunmap(dir, page);
241 f2fs_put_page(page, 0); 251 f2fs_put_page(page, 0);
252 } else if (IS_ERR(page)) {
253 err = PTR_ERR(page);
242 } else { 254 } else {
243 err = __f2fs_add_link(dir, &dotdot, NULL, pino, S_IFDIR); 255 err = __f2fs_add_link(dir, &dotdot, NULL, pino, S_IFDIR);
244 } 256 }
245out: 257out:
246 if (!err) { 258 if (!err)
247 clear_inode_flag(F2FS_I(dir), FI_INLINE_DOTS); 259 clear_inode_flag(dir, FI_INLINE_DOTS);
248 mark_inode_dirty(dir);
249 }
250 260
251 f2fs_unlock_op(sbi); 261 f2fs_unlock_op(sbi);
252 return err; 262 return err;
@@ -281,8 +291,11 @@ static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
281 return ERR_PTR(-ENAMETOOLONG); 291 return ERR_PTR(-ENAMETOOLONG);
282 292
283 de = f2fs_find_entry(dir, &dentry->d_name, &page); 293 de = f2fs_find_entry(dir, &dentry->d_name, &page);
284 if (!de) 294 if (!de) {
295 if (IS_ERR(page))
296 return (struct dentry *)page;
285 return d_splice_alias(inode, dentry); 297 return d_splice_alias(inode, dentry);
298 }
286 299
287 ino = le32_to_cpu(de->ino); 300 ino = le32_to_cpu(de->ino);
288 f2fs_dentry_kunmap(dir, page); 301 f2fs_dentry_kunmap(dir, page);
@@ -329,8 +342,11 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
329 trace_f2fs_unlink_enter(dir, dentry); 342 trace_f2fs_unlink_enter(dir, dentry);
330 343
331 de = f2fs_find_entry(dir, &dentry->d_name, &page); 344 de = f2fs_find_entry(dir, &dentry->d_name, &page);
332 if (!de) 345 if (!de) {
346 if (IS_ERR(page))
347 err = PTR_ERR(page);
333 goto fail; 348 goto fail;
349 }
334 350
335 f2fs_balance_fs(sbi, true); 351 f2fs_balance_fs(sbi, true);
336 352
@@ -345,9 +361,6 @@ static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
345 f2fs_delete_entry(de, page, dir, inode); 361 f2fs_delete_entry(de, page, dir, inode);
346 f2fs_unlock_op(sbi); 362 f2fs_unlock_op(sbi);
347 363
348 /* In order to evict this inode, we set it dirty */
349 mark_inode_dirty(inode);
350
351 if (IS_DIRSYNC(dir)) 364 if (IS_DIRSYNC(dir))
352 f2fs_sync_fs(sbi->sb, 1); 365 f2fs_sync_fs(sbi->sb, 1);
353fail: 366fail:
@@ -492,7 +505,7 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
492 505
493 f2fs_balance_fs(sbi, true); 506 f2fs_balance_fs(sbi, true);
494 507
495 set_inode_flag(F2FS_I(inode), FI_INC_LINK); 508 set_inode_flag(inode, FI_INC_LINK);
496 f2fs_lock_op(sbi); 509 f2fs_lock_op(sbi);
497 err = f2fs_add_link(dentry, inode); 510 err = f2fs_add_link(dentry, inode);
498 if (err) 511 if (err)
@@ -509,7 +522,7 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
509 return 0; 522 return 0;
510 523
511out_fail: 524out_fail:
512 clear_inode_flag(F2FS_I(inode), FI_INC_LINK); 525 clear_inode_flag(inode, FI_INC_LINK);
513 handle_failed_inode(inode); 526 handle_failed_inode(inode);
514 return err; 527 return err;
515} 528}
@@ -592,17 +605,17 @@ static int __f2fs_tmpfile(struct inode *dir, struct dentry *dentry,
592 * add this non-linked tmpfile to orphan list, in this way we could 605 * add this non-linked tmpfile to orphan list, in this way we could
593 * remove all unused data of tmpfile after abnormal power-off. 606 * remove all unused data of tmpfile after abnormal power-off.
594 */ 607 */
595 add_orphan_inode(sbi, inode->i_ino); 608 add_orphan_inode(inode);
596 f2fs_unlock_op(sbi);
597
598 alloc_nid_done(sbi, inode->i_ino); 609 alloc_nid_done(sbi, inode->i_ino);
599 610
600 if (whiteout) { 611 if (whiteout) {
601 inode_dec_link_count(inode); 612 f2fs_i_links_write(inode, false);
602 *whiteout = inode; 613 *whiteout = inode;
603 } else { 614 } else {
604 d_tmpfile(dentry, inode); 615 d_tmpfile(dentry, inode);
605 } 616 }
617 /* link_count was changed by d_tmpfile as well. */
618 f2fs_unlock_op(sbi);
606 unlock_new_inode(inode); 619 unlock_new_inode(inode);
607 return 0; 620 return 0;
608 621
@@ -652,14 +665,19 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
652 } 665 }
653 666
654 old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page); 667 old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
655 if (!old_entry) 668 if (!old_entry) {
669 if (IS_ERR(old_page))
670 err = PTR_ERR(old_page);
656 goto out; 671 goto out;
672 }
657 673
658 if (S_ISDIR(old_inode->i_mode)) { 674 if (S_ISDIR(old_inode->i_mode)) {
659 err = -EIO;
660 old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page); 675 old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page);
661 if (!old_dir_entry) 676 if (!old_dir_entry) {
677 if (IS_ERR(old_dir_page))
678 err = PTR_ERR(old_dir_page);
662 goto out_old; 679 goto out_old;
680 }
663 } 681 }
664 682
665 if (flags & RENAME_WHITEOUT) { 683 if (flags & RENAME_WHITEOUT) {
@@ -677,8 +695,11 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
677 err = -ENOENT; 695 err = -ENOENT;
678 new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, 696 new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,
679 &new_page); 697 &new_page);
680 if (!new_entry) 698 if (!new_entry) {
699 if (IS_ERR(new_page))
700 err = PTR_ERR(new_page);
681 goto out_whiteout; 701 goto out_whiteout;
702 }
682 703
683 f2fs_balance_fs(sbi, true); 704 f2fs_balance_fs(sbi, true);
684 705
@@ -700,19 +721,14 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
700 new_inode->i_ctime = CURRENT_TIME; 721 new_inode->i_ctime = CURRENT_TIME;
701 down_write(&F2FS_I(new_inode)->i_sem); 722 down_write(&F2FS_I(new_inode)->i_sem);
702 if (old_dir_entry) 723 if (old_dir_entry)
703 drop_nlink(new_inode); 724 f2fs_i_links_write(new_inode, false);
704 drop_nlink(new_inode); 725 f2fs_i_links_write(new_inode, false);
705 up_write(&F2FS_I(new_inode)->i_sem); 726 up_write(&F2FS_I(new_inode)->i_sem);
706 727
707 mark_inode_dirty(new_inode);
708
709 if (!new_inode->i_nlink) 728 if (!new_inode->i_nlink)
710 add_orphan_inode(sbi, new_inode->i_ino); 729 add_orphan_inode(new_inode);
711 else 730 else
712 release_orphan_inode(sbi); 731 release_orphan_inode(sbi);
713
714 update_inode_page(old_inode);
715 update_inode_page(new_inode);
716 } else { 732 } else {
717 f2fs_balance_fs(sbi, true); 733 f2fs_balance_fs(sbi, true);
718 734
@@ -724,10 +740,8 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
724 goto out_whiteout; 740 goto out_whiteout;
725 } 741 }
726 742
727 if (old_dir_entry) { 743 if (old_dir_entry)
728 inc_nlink(new_dir); 744 f2fs_i_links_write(new_dir, true);
729 update_inode_page(new_dir);
730 }
731 745
732 /* 746 /*
733 * old entry and new entry can locate in the same inline 747 * old entry and new entry can locate in the same inline
@@ -743,7 +757,9 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
743 old_entry = f2fs_find_entry(old_dir, 757 old_entry = f2fs_find_entry(old_dir,
744 &old_dentry->d_name, &old_page); 758 &old_dentry->d_name, &old_page);
745 if (!old_entry) { 759 if (!old_entry) {
746 err = -EIO; 760 err = -ENOENT;
761 if (IS_ERR(old_page))
762 err = PTR_ERR(old_page);
747 f2fs_unlock_op(sbi); 763 f2fs_unlock_op(sbi);
748 goto out_whiteout; 764 goto out_whiteout;
749 } 765 }
@@ -757,13 +773,13 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
757 up_write(&F2FS_I(old_inode)->i_sem); 773 up_write(&F2FS_I(old_inode)->i_sem);
758 774
759 old_inode->i_ctime = CURRENT_TIME; 775 old_inode->i_ctime = CURRENT_TIME;
760 mark_inode_dirty(old_inode); 776 f2fs_mark_inode_dirty_sync(old_inode);
761 777
762 f2fs_delete_entry(old_entry, old_page, old_dir, NULL); 778 f2fs_delete_entry(old_entry, old_page, old_dir, NULL);
763 779
764 if (whiteout) { 780 if (whiteout) {
765 whiteout->i_state |= I_LINKABLE; 781 whiteout->i_state |= I_LINKABLE;
766 set_inode_flag(F2FS_I(whiteout), FI_INC_LINK); 782 set_inode_flag(whiteout, FI_INC_LINK);
767 err = f2fs_add_link(old_dentry, whiteout); 783 err = f2fs_add_link(old_dentry, whiteout);
768 if (err) 784 if (err)
769 goto put_out_dir; 785 goto put_out_dir;
@@ -775,14 +791,11 @@ static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
775 if (old_dir != new_dir && !whiteout) { 791 if (old_dir != new_dir && !whiteout) {
776 f2fs_set_link(old_inode, old_dir_entry, 792 f2fs_set_link(old_inode, old_dir_entry,
777 old_dir_page, new_dir); 793 old_dir_page, new_dir);
778 update_inode_page(old_inode);
779 } else { 794 } else {
780 f2fs_dentry_kunmap(old_inode, old_dir_page); 795 f2fs_dentry_kunmap(old_inode, old_dir_page);
781 f2fs_put_page(old_dir_page, 0); 796 f2fs_put_page(old_dir_page, 0);
782 } 797 }
783 drop_nlink(old_dir); 798 f2fs_i_links_write(old_dir, false);
784 mark_inode_dirty(old_dir);
785 update_inode_page(old_dir);
786 } 799 }
787 800
788 f2fs_unlock_op(sbi); 801 f2fs_unlock_op(sbi);
@@ -832,29 +845,39 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
832 return -EPERM; 845 return -EPERM;
833 846
834 old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page); 847 old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
835 if (!old_entry) 848 if (!old_entry) {
849 if (IS_ERR(old_page))
850 err = PTR_ERR(old_page);
836 goto out; 851 goto out;
852 }
837 853
838 new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, &new_page); 854 new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, &new_page);
839 if (!new_entry) 855 if (!new_entry) {
856 if (IS_ERR(new_page))
857 err = PTR_ERR(new_page);
840 goto out_old; 858 goto out_old;
859 }
841 860
842 /* prepare for updating ".." directory entry info later */ 861 /* prepare for updating ".." directory entry info later */
843 if (old_dir != new_dir) { 862 if (old_dir != new_dir) {
844 if (S_ISDIR(old_inode->i_mode)) { 863 if (S_ISDIR(old_inode->i_mode)) {
845 err = -EIO;
846 old_dir_entry = f2fs_parent_dir(old_inode, 864 old_dir_entry = f2fs_parent_dir(old_inode,
847 &old_dir_page); 865 &old_dir_page);
848 if (!old_dir_entry) 866 if (!old_dir_entry) {
867 if (IS_ERR(old_dir_page))
868 err = PTR_ERR(old_dir_page);
849 goto out_new; 869 goto out_new;
870 }
850 } 871 }
851 872
852 if (S_ISDIR(new_inode->i_mode)) { 873 if (S_ISDIR(new_inode->i_mode)) {
853 err = -EIO;
854 new_dir_entry = f2fs_parent_dir(new_inode, 874 new_dir_entry = f2fs_parent_dir(new_inode,
855 &new_dir_page); 875 &new_dir_page);
856 if (!new_dir_entry) 876 if (!new_dir_entry) {
877 if (IS_ERR(new_dir_page))
878 err = PTR_ERR(new_dir_page);
857 goto out_old_dir; 879 goto out_old_dir;
880 }
858 } 881 }
859 } 882 }
860 883
@@ -904,19 +927,13 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
904 file_lost_pino(old_inode); 927 file_lost_pino(old_inode);
905 up_write(&F2FS_I(old_inode)->i_sem); 928 up_write(&F2FS_I(old_inode)->i_sem);
906 929
907 update_inode_page(old_inode);
908
909 old_dir->i_ctime = CURRENT_TIME; 930 old_dir->i_ctime = CURRENT_TIME;
910 if (old_nlink) { 931 if (old_nlink) {
911 down_write(&F2FS_I(old_dir)->i_sem); 932 down_write(&F2FS_I(old_dir)->i_sem);
912 if (old_nlink < 0) 933 f2fs_i_links_write(old_dir, old_nlink > 0);
913 drop_nlink(old_dir);
914 else
915 inc_nlink(old_dir);
916 up_write(&F2FS_I(old_dir)->i_sem); 934 up_write(&F2FS_I(old_dir)->i_sem);
917 } 935 }
918 mark_inode_dirty(old_dir); 936 f2fs_mark_inode_dirty_sync(old_dir);
919 update_inode_page(old_dir);
920 937
921 /* update directory entry info of new dir inode */ 938 /* update directory entry info of new dir inode */
922 f2fs_set_link(new_dir, new_entry, new_page, old_inode); 939 f2fs_set_link(new_dir, new_entry, new_page, old_inode);
@@ -925,19 +942,13 @@ static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,
925 file_lost_pino(new_inode); 942 file_lost_pino(new_inode);
926 up_write(&F2FS_I(new_inode)->i_sem); 943 up_write(&F2FS_I(new_inode)->i_sem);
927 944
928 update_inode_page(new_inode);
929
930 new_dir->i_ctime = CURRENT_TIME; 945 new_dir->i_ctime = CURRENT_TIME;
931 if (new_nlink) { 946 if (new_nlink) {
932 down_write(&F2FS_I(new_dir)->i_sem); 947 down_write(&F2FS_I(new_dir)->i_sem);
933 if (new_nlink < 0) 948 f2fs_i_links_write(new_dir, new_nlink > 0);
934 drop_nlink(new_dir);
935 else
936 inc_nlink(new_dir);
937 up_write(&F2FS_I(new_dir)->i_sem); 949 up_write(&F2FS_I(new_dir)->i_sem);
938 } 950 }
939 mark_inode_dirty(new_dir); 951 f2fs_mark_inode_dirty_sync(new_dir);
940 update_inode_page(new_dir);
941 952
942 f2fs_unlock_op(sbi); 953 f2fs_unlock_op(sbi);
943 954
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index d1867698e601..b2fa4b615925 100644
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -52,6 +52,10 @@ bool available_free_memory(struct f2fs_sb_info *sbi, int type)
52 mem_size = (nm_i->nat_cnt * sizeof(struct nat_entry)) >> 52 mem_size = (nm_i->nat_cnt * sizeof(struct nat_entry)) >>
53 PAGE_SHIFT; 53 PAGE_SHIFT;
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))
56 res = false;
57 if (nm_i->nat_cnt > DEF_NAT_CACHE_THRESHOLD)
58 res = false;
55 } else if (type == DIRTY_DENTS) { 59 } else if (type == DIRTY_DENTS) {
56 if (sbi->sb->s_bdi->wb.dirty_exceeded) 60 if (sbi->sb->s_bdi->wb.dirty_exceeded)
57 return false; 61 return false;
@@ -202,14 +206,14 @@ int need_dentry_mark(struct f2fs_sb_info *sbi, nid_t nid)
202 struct nat_entry *e; 206 struct nat_entry *e;
203 bool need = false; 207 bool need = false;
204 208
205 down_read(&nm_i->nat_tree_lock); 209 percpu_down_read(&nm_i->nat_tree_lock);
206 e = __lookup_nat_cache(nm_i, nid); 210 e = __lookup_nat_cache(nm_i, nid);
207 if (e) { 211 if (e) {
208 if (!get_nat_flag(e, IS_CHECKPOINTED) && 212 if (!get_nat_flag(e, IS_CHECKPOINTED) &&
209 !get_nat_flag(e, HAS_FSYNCED_INODE)) 213 !get_nat_flag(e, HAS_FSYNCED_INODE))
210 need = true; 214 need = true;
211 } 215 }
212 up_read(&nm_i->nat_tree_lock); 216 percpu_up_read(&nm_i->nat_tree_lock);
213 return need; 217 return need;
214} 218}
215 219
@@ -219,11 +223,11 @@ bool is_checkpointed_node(struct f2fs_sb_info *sbi, nid_t nid)
219 struct nat_entry *e; 223 struct nat_entry *e;
220 bool is_cp = true; 224 bool is_cp = true;
221 225
222 down_read(&nm_i->nat_tree_lock); 226 percpu_down_read(&nm_i->nat_tree_lock);
223 e = __lookup_nat_cache(nm_i, nid); 227 e = __lookup_nat_cache(nm_i, nid);
224 if (e && !get_nat_flag(e, IS_CHECKPOINTED)) 228 if (e && !get_nat_flag(e, IS_CHECKPOINTED))
225 is_cp = false; 229 is_cp = false;
226 up_read(&nm_i->nat_tree_lock); 230 percpu_up_read(&nm_i->nat_tree_lock);
227 return is_cp; 231 return is_cp;
228} 232}
229 233
@@ -233,13 +237,13 @@ bool need_inode_block_update(struct f2fs_sb_info *sbi, nid_t ino)
233 struct nat_entry *e; 237 struct nat_entry *e;
234 bool need_update = true; 238 bool need_update = true;
235 239
236 down_read(&nm_i->nat_tree_lock); 240 percpu_down_read(&nm_i->nat_tree_lock);
237 e = __lookup_nat_cache(nm_i, ino); 241 e = __lookup_nat_cache(nm_i, ino);
238 if (e && get_nat_flag(e, HAS_LAST_FSYNC) && 242 if (e && get_nat_flag(e, HAS_LAST_FSYNC) &&
239 (get_nat_flag(e, IS_CHECKPOINTED) || 243 (get_nat_flag(e, IS_CHECKPOINTED) ||
240 get_nat_flag(e, HAS_FSYNCED_INODE))) 244 get_nat_flag(e, HAS_FSYNCED_INODE)))
241 need_update = false; 245 need_update = false;
242 up_read(&nm_i->nat_tree_lock); 246 percpu_up_read(&nm_i->nat_tree_lock);
243 return need_update; 247 return need_update;
244} 248}
245 249
@@ -280,7 +284,7 @@ static void set_node_addr(struct f2fs_sb_info *sbi, struct node_info *ni,
280 struct f2fs_nm_info *nm_i = NM_I(sbi); 284 struct f2fs_nm_info *nm_i = NM_I(sbi);
281 struct nat_entry *e; 285 struct nat_entry *e;
282 286
283 down_write(&nm_i->nat_tree_lock); 287 percpu_down_write(&nm_i->nat_tree_lock);
284 e = __lookup_nat_cache(nm_i, ni->nid); 288 e = __lookup_nat_cache(nm_i, ni->nid);
285 if (!e) { 289 if (!e) {
286 e = grab_nat_entry(nm_i, ni->nid); 290 e = grab_nat_entry(nm_i, ni->nid);
@@ -330,7 +334,7 @@ static void set_node_addr(struct f2fs_sb_info *sbi, struct node_info *ni,
330 set_nat_flag(e, HAS_FSYNCED_INODE, true); 334 set_nat_flag(e, HAS_FSYNCED_INODE, true);
331 set_nat_flag(e, HAS_LAST_FSYNC, fsync_done); 335 set_nat_flag(e, HAS_LAST_FSYNC, fsync_done);
332 } 336 }
333 up_write(&nm_i->nat_tree_lock); 337 percpu_up_write(&nm_i->nat_tree_lock);
334} 338}
335 339
336int try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink) 340int try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink)
@@ -338,8 +342,7 @@ int try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink)
338 struct f2fs_nm_info *nm_i = NM_I(sbi); 342 struct f2fs_nm_info *nm_i = NM_I(sbi);
339 int nr = nr_shrink; 343 int nr = nr_shrink;
340 344
341 if (!down_write_trylock(&nm_i->nat_tree_lock)) 345 percpu_down_write(&nm_i->nat_tree_lock);
342 return 0;
343 346
344 while (nr_shrink && !list_empty(&nm_i->nat_entries)) { 347 while (nr_shrink && !list_empty(&nm_i->nat_entries)) {
345 struct nat_entry *ne; 348 struct nat_entry *ne;
@@ -348,7 +351,7 @@ int try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink)
348 __del_from_nat_cache(nm_i, ne); 351 __del_from_nat_cache(nm_i, ne);
349 nr_shrink--; 352 nr_shrink--;
350 } 353 }
351 up_write(&nm_i->nat_tree_lock); 354 percpu_up_write(&nm_i->nat_tree_lock);
352 return nr - nr_shrink; 355 return nr - nr_shrink;
353} 356}
354 357
@@ -370,13 +373,13 @@ void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni)
370 ni->nid = nid; 373 ni->nid = nid;
371 374
372 /* Check nat cache */ 375 /* Check nat cache */
373 down_read(&nm_i->nat_tree_lock); 376 percpu_down_read(&nm_i->nat_tree_lock);
374 e = __lookup_nat_cache(nm_i, nid); 377 e = __lookup_nat_cache(nm_i, nid);
375 if (e) { 378 if (e) {
376 ni->ino = nat_get_ino(e); 379 ni->ino = nat_get_ino(e);
377 ni->blk_addr = nat_get_blkaddr(e); 380 ni->blk_addr = nat_get_blkaddr(e);
378 ni->version = nat_get_version(e); 381 ni->version = nat_get_version(e);
379 up_read(&nm_i->nat_tree_lock); 382 percpu_up_read(&nm_i->nat_tree_lock);
380 return; 383 return;
381 } 384 }
382 385
@@ -400,11 +403,11 @@ void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni)
400 node_info_from_raw_nat(ni, &ne); 403 node_info_from_raw_nat(ni, &ne);
401 f2fs_put_page(page, 1); 404 f2fs_put_page(page, 1);
402cache: 405cache:
403 up_read(&nm_i->nat_tree_lock); 406 percpu_up_read(&nm_i->nat_tree_lock);
404 /* cache nat entry */ 407 /* cache nat entry */
405 down_write(&nm_i->nat_tree_lock); 408 percpu_down_write(&nm_i->nat_tree_lock);
406 cache_nat_entry(sbi, nid, &ne); 409 cache_nat_entry(sbi, nid, &ne);
407 up_write(&nm_i->nat_tree_lock); 410 percpu_up_write(&nm_i->nat_tree_lock);
408} 411}
409 412
410/* 413/*
@@ -646,6 +649,7 @@ release_out:
646 if (err == -ENOENT) { 649 if (err == -ENOENT) {
647 dn->cur_level = i; 650 dn->cur_level = i;
648 dn->max_level = level; 651 dn->max_level = level;
652 dn->ofs_in_node = offset[level];
649 } 653 }
650 return err; 654 return err;
651} 655}
@@ -670,8 +674,7 @@ static void truncate_node(struct dnode_of_data *dn)
670 if (dn->nid == dn->inode->i_ino) { 674 if (dn->nid == dn->inode->i_ino) {
671 remove_orphan_inode(sbi, dn->nid); 675 remove_orphan_inode(sbi, dn->nid);
672 dec_valid_inode_count(sbi); 676 dec_valid_inode_count(sbi);
673 } else { 677 f2fs_inode_synced(dn->inode);
674 sync_inode_page(dn);
675 } 678 }
676invalidate: 679invalidate:
677 clear_node_page_dirty(dn->node_page); 680 clear_node_page_dirty(dn->node_page);
@@ -953,7 +956,7 @@ int truncate_xattr_node(struct inode *inode, struct page *page)
953 if (IS_ERR(npage)) 956 if (IS_ERR(npage))
954 return PTR_ERR(npage); 957 return PTR_ERR(npage);
955 958
956 F2FS_I(inode)->i_xattr_nid = 0; 959 f2fs_i_xnid_write(inode, 0);
957 960
958 /* need to do checkpoint during fsync */ 961 /* need to do checkpoint during fsync */
959 F2FS_I(inode)->xattr_ver = cur_cp_version(F2FS_CKPT(sbi)); 962 F2FS_I(inode)->xattr_ver = cur_cp_version(F2FS_CKPT(sbi));
@@ -1019,7 +1022,7 @@ struct page *new_node_page(struct dnode_of_data *dn,
1019 struct page *page; 1022 struct page *page;
1020 int err; 1023 int err;
1021 1024
1022 if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC))) 1025 if (unlikely(is_inode_flag_set(dn->inode, FI_NO_ALLOC)))
1023 return ERR_PTR(-EPERM); 1026 return ERR_PTR(-EPERM);
1024 1027
1025 page = f2fs_grab_cache_page(NODE_MAPPING(sbi), dn->nid, false); 1028 page = f2fs_grab_cache_page(NODE_MAPPING(sbi), dn->nid, false);
@@ -1042,21 +1045,16 @@ struct page *new_node_page(struct dnode_of_data *dn,
1042 f2fs_wait_on_page_writeback(page, NODE, true); 1045 f2fs_wait_on_page_writeback(page, NODE, true);
1043 fill_node_footer(page, dn->nid, dn->inode->i_ino, ofs, true); 1046 fill_node_footer(page, dn->nid, dn->inode->i_ino, ofs, true);
1044 set_cold_node(dn->inode, page); 1047 set_cold_node(dn->inode, page);
1045 SetPageUptodate(page); 1048 if (!PageUptodate(page))
1049 SetPageUptodate(page);
1046 if (set_page_dirty(page)) 1050 if (set_page_dirty(page))
1047 dn->node_changed = true; 1051 dn->node_changed = true;
1048 1052
1049 if (f2fs_has_xattr_block(ofs)) 1053 if (f2fs_has_xattr_block(ofs))
1050 F2FS_I(dn->inode)->i_xattr_nid = dn->nid; 1054 f2fs_i_xnid_write(dn->inode, dn->nid);
1051 1055
1052 dn->node_page = page;
1053 if (ipage)
1054 update_inode(dn->inode, ipage);
1055 else
1056 sync_inode_page(dn);
1057 if (ofs == 0) 1056 if (ofs == 0)
1058 inc_valid_inode_count(sbi); 1057 inc_valid_inode_count(sbi);
1059
1060 return page; 1058 return page;
1061 1059
1062fail: 1060fail:
@@ -1083,6 +1081,9 @@ static int read_node_page(struct page *page, int op_flags)
1083 .encrypted_page = NULL, 1081 .encrypted_page = NULL,
1084 }; 1082 };
1085 1083
1084 if (PageUptodate(page))
1085 return LOCKED_PAGE;
1086
1086 get_node_info(sbi, page->index, &ni); 1087 get_node_info(sbi, page->index, &ni);
1087 1088
1088 if (unlikely(ni.blk_addr == NULL_ADDR)) { 1089 if (unlikely(ni.blk_addr == NULL_ADDR)) {
@@ -1090,9 +1091,6 @@ static int read_node_page(struct page *page, int op_flags)
1090 return -ENOENT; 1091 return -ENOENT;
1091 } 1092 }
1092 1093
1093 if (PageUptodate(page))
1094 return LOCKED_PAGE;
1095
1096 fio.new_blkaddr = fio.old_blkaddr = ni.blk_addr; 1094 fio.new_blkaddr = fio.old_blkaddr = ni.blk_addr;
1097 return f2fs_submit_page_bio(&fio); 1095 return f2fs_submit_page_bio(&fio);
1098} 1096}
@@ -1150,16 +1148,21 @@ repeat:
1150 1148
1151 lock_page(page); 1149 lock_page(page);
1152 1150
1153 if (unlikely(!PageUptodate(page))) {
1154 f2fs_put_page(page, 1);
1155 return ERR_PTR(-EIO);
1156 }
1157 if (unlikely(page->mapping != NODE_MAPPING(sbi))) { 1151 if (unlikely(page->mapping != NODE_MAPPING(sbi))) {
1158 f2fs_put_page(page, 1); 1152 f2fs_put_page(page, 1);
1159 goto repeat; 1153 goto repeat;
1160 } 1154 }
1155
1156 if (unlikely(!PageUptodate(page)))
1157 goto out_err;
1161page_hit: 1158page_hit:
1162 f2fs_bug_on(sbi, nid != nid_of_node(page)); 1159 if(unlikely(nid != nid_of_node(page))) {
1160 f2fs_bug_on(sbi, 1);
1161 ClearPageUptodate(page);
1162out_err:
1163 f2fs_put_page(page, 1);
1164 return ERR_PTR(-EIO);
1165 }
1163 return page; 1166 return page;
1164} 1167}
1165 1168
@@ -1176,24 +1179,6 @@ struct page *get_node_page_ra(struct page *parent, int start)
1176 return __get_node_page(sbi, nid, parent, start); 1179 return __get_node_page(sbi, nid, parent, start);
1177} 1180}
1178 1181
1179void sync_inode_page(struct dnode_of_data *dn)
1180{
1181 int ret = 0;
1182
1183 if (IS_INODE(dn->node_page) || dn->inode_page == dn->node_page) {
1184 ret = update_inode(dn->inode, dn->node_page);
1185 } else if (dn->inode_page) {
1186 if (!dn->inode_page_locked)
1187 lock_page(dn->inode_page);
1188 ret = update_inode(dn->inode, dn->inode_page);
1189 if (!dn->inode_page_locked)
1190 unlock_page(dn->inode_page);
1191 } else {
1192 ret = update_inode_page(dn->inode);
1193 }
1194 dn->node_changed = ret ? true: false;
1195}
1196
1197static void flush_inline_data(struct f2fs_sb_info *sbi, nid_t ino) 1182static void flush_inline_data(struct f2fs_sb_info *sbi, nid_t ino)
1198{ 1183{
1199 struct inode *inode; 1184 struct inode *inode;
@@ -1319,7 +1304,7 @@ continue_unlock:
1319 return last_page; 1304 return last_page;
1320} 1305}
1321 1306
1322int fsync_node_pages(struct f2fs_sb_info *sbi, nid_t ino, 1307int fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
1323 struct writeback_control *wbc, bool atomic) 1308 struct writeback_control *wbc, bool atomic)
1324{ 1309{
1325 pgoff_t index, end; 1310 pgoff_t index, end;
@@ -1327,6 +1312,7 @@ int fsync_node_pages(struct f2fs_sb_info *sbi, nid_t ino,
1327 int ret = 0; 1312 int ret = 0;
1328 struct page *last_page = NULL; 1313 struct page *last_page = NULL;
1329 bool marked = false; 1314 bool marked = false;
1315 nid_t ino = inode->i_ino;
1330 1316
1331 if (atomic) { 1317 if (atomic) {
1332 last_page = last_fsync_dnode(sbi, ino); 1318 last_page = last_fsync_dnode(sbi, ino);
@@ -1380,9 +1366,13 @@ continue_unlock:
1380 1366
1381 if (!atomic || page == last_page) { 1367 if (!atomic || page == last_page) {
1382 set_fsync_mark(page, 1); 1368 set_fsync_mark(page, 1);
1383 if (IS_INODE(page)) 1369 if (IS_INODE(page)) {
1370 if (is_inode_flag_set(inode,
1371 FI_DIRTY_INODE))
1372 update_inode(inode, page);
1384 set_dentry_mark(page, 1373 set_dentry_mark(page,
1385 need_dentry_mark(sbi, ino)); 1374 need_dentry_mark(sbi, ino));
1375 }
1386 /* may be written by other thread */ 1376 /* may be written by other thread */
1387 if (!PageDirty(page)) 1377 if (!PageDirty(page))
1388 set_page_dirty(page); 1378 set_page_dirty(page);
@@ -1630,6 +1620,7 @@ static int f2fs_write_node_pages(struct address_space *mapping,
1630 struct writeback_control *wbc) 1620 struct writeback_control *wbc)
1631{ 1621{
1632 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping); 1622 struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);
1623 struct blk_plug plug;
1633 long diff; 1624 long diff;
1634 1625
1635 /* balancing f2fs's metadata in background */ 1626 /* balancing f2fs's metadata in background */
@@ -1643,7 +1634,9 @@ static int f2fs_write_node_pages(struct address_space *mapping,
1643 1634
1644 diff = nr_pages_to_write(sbi, NODE, wbc); 1635 diff = nr_pages_to_write(sbi, NODE, wbc);
1645 wbc->sync_mode = WB_SYNC_NONE; 1636 wbc->sync_mode = WB_SYNC_NONE;
1637 blk_start_plug(&plug);
1646 sync_node_pages(sbi, wbc); 1638 sync_node_pages(sbi, wbc);
1639 blk_finish_plug(&plug);
1647 wbc->nr_to_write = max((long)0, wbc->nr_to_write - diff); 1640 wbc->nr_to_write = max((long)0, wbc->nr_to_write - diff);
1648 return 0; 1641 return 0;
1649 1642
@@ -1657,9 +1650,10 @@ static int f2fs_set_node_page_dirty(struct page *page)
1657{ 1650{
1658 trace_f2fs_set_page_dirty(page, NODE); 1651 trace_f2fs_set_page_dirty(page, NODE);
1659 1652
1660 SetPageUptodate(page); 1653 if (!PageUptodate(page))
1654 SetPageUptodate(page);
1661 if (!PageDirty(page)) { 1655 if (!PageDirty(page)) {
1662 __set_page_dirty_nobuffers(page); 1656 f2fs_set_page_dirty_nobuffers(page);
1663 inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_NODES); 1657 inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_NODES);
1664 SetPagePrivate(page); 1658 SetPagePrivate(page);
1665 f2fs_trace_pid(page); 1659 f2fs_trace_pid(page);
@@ -1778,7 +1772,7 @@ static void scan_nat_page(struct f2fs_sb_info *sbi,
1778 } 1772 }
1779} 1773}
1780 1774
1781static void build_free_nids(struct f2fs_sb_info *sbi) 1775void build_free_nids(struct f2fs_sb_info *sbi)
1782{ 1776{
1783 struct f2fs_nm_info *nm_i = NM_I(sbi); 1777 struct f2fs_nm_info *nm_i = NM_I(sbi);
1784 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA); 1778 struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
@@ -1787,14 +1781,14 @@ static void build_free_nids(struct f2fs_sb_info *sbi)
1787 nid_t nid = nm_i->next_scan_nid; 1781 nid_t nid = nm_i->next_scan_nid;
1788 1782
1789 /* Enough entries */ 1783 /* Enough entries */
1790 if (nm_i->fcnt > NAT_ENTRY_PER_BLOCK) 1784 if (nm_i->fcnt >= NAT_ENTRY_PER_BLOCK)
1791 return; 1785 return;
1792 1786
1793 /* readahead nat pages to be scanned */ 1787 /* readahead nat pages to be scanned */
1794 ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nid), FREE_NID_PAGES, 1788 ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nid), FREE_NID_PAGES,
1795 META_NAT, true); 1789 META_NAT, true);
1796 1790
1797 down_read(&nm_i->nat_tree_lock); 1791 percpu_down_read(&nm_i->nat_tree_lock);
1798 1792
1799 while (1) { 1793 while (1) {
1800 struct page *page = get_current_nat_page(sbi, nid); 1794 struct page *page = get_current_nat_page(sbi, nid);
@@ -1826,7 +1820,7 @@ static void build_free_nids(struct f2fs_sb_info *sbi)
1826 remove_free_nid(nm_i, nid); 1820 remove_free_nid(nm_i, nid);
1827 } 1821 }
1828 up_read(&curseg->journal_rwsem); 1822 up_read(&curseg->journal_rwsem);
1829 up_read(&nm_i->nat_tree_lock); 1823 percpu_up_read(&nm_i->nat_tree_lock);
1830 1824
1831 ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nm_i->next_scan_nid), 1825 ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nm_i->next_scan_nid),
1832 nm_i->ra_nid_pages, META_NAT, false); 1826 nm_i->ra_nid_pages, META_NAT, false);
@@ -1925,12 +1919,15 @@ int try_to_free_nids(struct f2fs_sb_info *sbi, int nr_shrink)
1925 struct free_nid *i, *next; 1919 struct free_nid *i, *next;
1926 int nr = nr_shrink; 1920 int nr = nr_shrink;
1927 1921
1922 if (nm_i->fcnt <= MAX_FREE_NIDS)
1923 return 0;
1924
1928 if (!mutex_trylock(&nm_i->build_lock)) 1925 if (!mutex_trylock(&nm_i->build_lock))
1929 return 0; 1926 return 0;
1930 1927
1931 spin_lock(&nm_i->free_nid_list_lock); 1928 spin_lock(&nm_i->free_nid_list_lock);
1932 list_for_each_entry_safe(i, next, &nm_i->free_nid_list, list) { 1929 list_for_each_entry_safe(i, next, &nm_i->free_nid_list, list) {
1933 if (nr_shrink <= 0 || nm_i->fcnt <= NAT_ENTRY_PER_BLOCK) 1930 if (nr_shrink <= 0 || nm_i->fcnt <= MAX_FREE_NIDS)
1934 break; 1931 break;
1935 if (i->state == NID_ALLOC) 1932 if (i->state == NID_ALLOC)
1936 continue; 1933 continue;
@@ -1957,7 +1954,7 @@ void recover_inline_xattr(struct inode *inode, struct page *page)
1957 1954
1958 ri = F2FS_INODE(page); 1955 ri = F2FS_INODE(page);
1959 if (!(ri->i_inline & F2FS_INLINE_XATTR)) { 1956 if (!(ri->i_inline & F2FS_INLINE_XATTR)) {
1960 clear_inode_flag(F2FS_I(inode), FI_INLINE_XATTR); 1957 clear_inode_flag(inode, FI_INLINE_XATTR);
1961 goto update_inode; 1958 goto update_inode;
1962 } 1959 }
1963 1960
@@ -1999,13 +1996,11 @@ recover_xnid:
1999 get_node_info(sbi, new_xnid, &ni); 1996 get_node_info(sbi, new_xnid, &ni);
2000 ni.ino = inode->i_ino; 1997 ni.ino = inode->i_ino;
2001 set_node_addr(sbi, &ni, NEW_ADDR, false); 1998 set_node_addr(sbi, &ni, NEW_ADDR, false);
2002 F2FS_I(inode)->i_xattr_nid = new_xnid; 1999 f2fs_i_xnid_write(inode, new_xnid);
2003 2000
2004 /* 3: update xattr blkaddr */ 2001 /* 3: update xattr blkaddr */
2005 refresh_sit_entry(sbi, NEW_ADDR, blkaddr); 2002 refresh_sit_entry(sbi, NEW_ADDR, blkaddr);
2006 set_node_addr(sbi, &ni, blkaddr, false); 2003 set_node_addr(sbi, &ni, blkaddr, false);
2007
2008 update_inode_page(inode);
2009} 2004}
2010 2005
2011int recover_inode_page(struct f2fs_sb_info *sbi, struct page *page) 2006int recover_inode_page(struct f2fs_sb_info *sbi, struct page *page)
@@ -2027,7 +2022,8 @@ int recover_inode_page(struct f2fs_sb_info *sbi, struct page *page)
2027 /* Should not use this inode from free nid list */ 2022 /* Should not use this inode from free nid list */
2028 remove_free_nid(NM_I(sbi), ino); 2023 remove_free_nid(NM_I(sbi), ino);
2029 2024
2030 SetPageUptodate(ipage); 2025 if (!PageUptodate(ipage))
2026 SetPageUptodate(ipage);
2031 fill_node_footer(ipage, ino, ino, 0, true); 2027 fill_node_footer(ipage, ino, ino, 0, true);
2032 2028
2033 src = F2FS_INODE(page); 2029 src = F2FS_INODE(page);
@@ -2213,7 +2209,7 @@ void flush_nat_entries(struct f2fs_sb_info *sbi)
2213 if (!nm_i->dirty_nat_cnt) 2209 if (!nm_i->dirty_nat_cnt)
2214 return; 2210 return;
2215 2211
2216 down_write(&nm_i->nat_tree_lock); 2212 percpu_down_write(&nm_i->nat_tree_lock);
2217 2213
2218 /* 2214 /*
2219 * if there are no enough space in journal to store dirty nat 2215 * if there are no enough space in journal to store dirty nat
@@ -2236,7 +2232,7 @@ void flush_nat_entries(struct f2fs_sb_info *sbi)
2236 list_for_each_entry_safe(set, tmp, &sets, set_list) 2232 list_for_each_entry_safe(set, tmp, &sets, set_list)
2237 __flush_nat_entry_set(sbi, set); 2233 __flush_nat_entry_set(sbi, set);
2238 2234
2239 up_write(&nm_i->nat_tree_lock); 2235 percpu_up_write(&nm_i->nat_tree_lock);
2240 2236
2241 f2fs_bug_on(sbi, nm_i->dirty_nat_cnt); 2237 f2fs_bug_on(sbi, nm_i->dirty_nat_cnt);
2242} 2238}
@@ -2272,7 +2268,8 @@ static int init_node_manager(struct f2fs_sb_info *sbi)
2272 2268
2273 mutex_init(&nm_i->build_lock); 2269 mutex_init(&nm_i->build_lock);
2274 spin_lock_init(&nm_i->free_nid_list_lock); 2270 spin_lock_init(&nm_i->free_nid_list_lock);
2275 init_rwsem(&nm_i->nat_tree_lock); 2271 if (percpu_init_rwsem(&nm_i->nat_tree_lock))
2272 return -ENOMEM;
2276 2273
2277 nm_i->next_scan_nid = le32_to_cpu(sbi->ckpt->next_free_nid); 2274 nm_i->next_scan_nid = le32_to_cpu(sbi->ckpt->next_free_nid);
2278 nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP); 2275 nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP);
@@ -2329,7 +2326,7 @@ void destroy_node_manager(struct f2fs_sb_info *sbi)
2329 spin_unlock(&nm_i->free_nid_list_lock); 2326 spin_unlock(&nm_i->free_nid_list_lock);
2330 2327
2331 /* destroy nat cache */ 2328 /* destroy nat cache */
2332 down_write(&nm_i->nat_tree_lock); 2329 percpu_down_write(&nm_i->nat_tree_lock);
2333 while ((found = __gang_lookup_nat_cache(nm_i, 2330 while ((found = __gang_lookup_nat_cache(nm_i,
2334 nid, NATVEC_SIZE, natvec))) { 2331 nid, NATVEC_SIZE, natvec))) {
2335 unsigned idx; 2332 unsigned idx;
@@ -2354,8 +2351,9 @@ void destroy_node_manager(struct f2fs_sb_info *sbi)
2354 kmem_cache_free(nat_entry_set_slab, setvec[idx]); 2351 kmem_cache_free(nat_entry_set_slab, setvec[idx]);
2355 } 2352 }
2356 } 2353 }
2357 up_write(&nm_i->nat_tree_lock); 2354 percpu_up_write(&nm_i->nat_tree_lock);
2358 2355
2356 percpu_free_rwsem(&nm_i->nat_tree_lock);
2359 kfree(nm_i->nat_bitmap); 2357 kfree(nm_i->nat_bitmap);
2360 sbi->nm_info = NULL; 2358 sbi->nm_info = NULL;
2361 kfree(nm_i); 2359 kfree(nm_i);
diff --git a/fs/f2fs/node.h b/fs/f2fs/node.h
index 1f4f9d4569d9..fc7684554b1a 100644
--- a/fs/f2fs/node.h
+++ b/fs/f2fs/node.h
@@ -15,18 +15,21 @@
15#define NAT_BLOCK_OFFSET(start_nid) (start_nid / NAT_ENTRY_PER_BLOCK) 15#define NAT_BLOCK_OFFSET(start_nid) (start_nid / NAT_ENTRY_PER_BLOCK)
16 16
17/* # of pages to perform synchronous readahead before building free nids */ 17/* # of pages to perform synchronous readahead before building free nids */
18#define FREE_NID_PAGES 4 18#define FREE_NID_PAGES 8
19#define MAX_FREE_NIDS (NAT_ENTRY_PER_BLOCK * FREE_NID_PAGES)
19 20
20#define DEF_RA_NID_PAGES 4 /* # of nid pages to be readaheaded */ 21#define DEF_RA_NID_PAGES 0 /* # of nid pages to be readaheaded */
21 22
22/* maximum readahead size for node during getting data blocks */ 23/* maximum readahead size for node during getting data blocks */
23#define MAX_RA_NODE 128 24#define MAX_RA_NODE 128
24 25
25/* control the memory footprint threshold (10MB per 1GB ram) */ 26/* control the memory footprint threshold (10MB per 1GB ram) */
26#define DEF_RAM_THRESHOLD 10 27#define DEF_RAM_THRESHOLD 1
27 28
28/* control dirty nats ratio threshold (default: 10% over max nid count) */ 29/* control dirty nats ratio threshold (default: 10% over max nid count) */
29#define DEF_DIRTY_NAT_RATIO_THRESHOLD 10 30#define DEF_DIRTY_NAT_RATIO_THRESHOLD 10
31/* control total # of nats */
32#define DEF_NAT_CACHE_THRESHOLD 100000
30 33
31/* vector size for gang look-up from nat cache that consists of radix tree */ 34/* vector size for gang look-up from nat cache that consists of radix tree */
32#define NATVEC_SIZE 64 35#define NATVEC_SIZE 64
@@ -126,6 +129,11 @@ static inline bool excess_dirty_nats(struct f2fs_sb_info *sbi)
126 NM_I(sbi)->dirty_nats_ratio / 100; 129 NM_I(sbi)->dirty_nats_ratio / 100;
127} 130}
128 131
132static inline bool excess_cached_nats(struct f2fs_sb_info *sbi)
133{
134 return NM_I(sbi)->nat_cnt >= DEF_NAT_CACHE_THRESHOLD;
135}
136
129enum mem_type { 137enum mem_type {
130 FREE_NIDS, /* indicates the free nid list */ 138 FREE_NIDS, /* indicates the free nid list */
131 NAT_ENTRIES, /* indicates the cached nat entry */ 139 NAT_ENTRIES, /* indicates the cached nat entry */
diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c
index 3d7216d7a288..9e652d5a659b 100644
--- a/fs/f2fs/recovery.c
+++ b/fs/f2fs/recovery.c
@@ -153,9 +153,12 @@ retry:
153 f2fs_delete_entry(de, page, dir, einode); 153 f2fs_delete_entry(de, page, dir, einode);
154 iput(einode); 154 iput(einode);
155 goto retry; 155 goto retry;
156 } else if (IS_ERR(page)) {
157 err = PTR_ERR(page);
158 } else {
159 err = __f2fs_add_link(dir, &name, inode,
160 inode->i_ino, inode->i_mode);
156 } 161 }
157 err = __f2fs_add_link(dir, &name, inode, inode->i_ino, inode->i_mode);
158
159 goto out; 162 goto out;
160 163
161out_unmap_put: 164out_unmap_put:
@@ -175,7 +178,7 @@ static void recover_inode(struct inode *inode, struct page *page)
175 char *name; 178 char *name;
176 179
177 inode->i_mode = le16_to_cpu(raw->i_mode); 180 inode->i_mode = le16_to_cpu(raw->i_mode);
178 i_size_write(inode, le64_to_cpu(raw->i_size)); 181 f2fs_i_size_write(inode, le64_to_cpu(raw->i_size));
179 inode->i_atime.tv_sec = le64_to_cpu(raw->i_mtime); 182 inode->i_atime.tv_sec = le64_to_cpu(raw->i_mtime);
180 inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime); 183 inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime);
181 inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime); 184 inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);
@@ -455,6 +458,9 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
455 continue; 458 continue;
456 } 459 }
457 460
461 if ((start + 1) << PAGE_SHIFT > i_size_read(inode))
462 f2fs_i_size_write(inode, (start + 1) << PAGE_SHIFT);
463
458 /* 464 /*
459 * dest is reserved block, invalidate src block 465 * dest is reserved block, invalidate src block
460 * and then reserve one new block in dnode page. 466 * and then reserve one new block in dnode page.
@@ -476,6 +482,8 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
476#endif 482#endif
477 /* We should not get -ENOSPC */ 483 /* We should not get -ENOSPC */
478 f2fs_bug_on(sbi, err); 484 f2fs_bug_on(sbi, err);
485 if (err)
486 goto err;
479 } 487 }
480 488
481 /* Check the previous node page having this index */ 489 /* Check the previous node page having this index */
@@ -490,9 +498,6 @@ static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
490 } 498 }
491 } 499 }
492 500
493 if (IS_INODE(dn.node_page))
494 sync_inode_page(&dn);
495
496 copy_node_footer(dn.node_page, page); 501 copy_node_footer(dn.node_page, page);
497 fill_node_footer(dn.node_page, dn.nid, ni.ino, 502 fill_node_footer(dn.node_page, dn.nid, ni.ino,
498 ofs_of_node(page), false); 503 ofs_of_node(page), false);
@@ -624,8 +629,12 @@ out:
624 if (err) { 629 if (err) {
625 bool invalidate = false; 630 bool invalidate = false;
626 631
627 if (discard_next_dnode(sbi, blkaddr)) 632 if (test_opt(sbi, LFS)) {
633 update_meta_page(sbi, NULL, blkaddr);
634 invalidate = true;
635 } else if (discard_next_dnode(sbi, blkaddr)) {
628 invalidate = true; 636 invalidate = true;
637 }
629 638
630 /* Flush all the NAT/SIT pages */ 639 /* Flush all the NAT/SIT pages */
631 while (get_pages(sbi, F2FS_DIRTY_META)) 640 while (get_pages(sbi, F2FS_DIRTY_META))
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 4c2d1fa1e0e2..a46296f57b02 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -241,7 +241,7 @@ void drop_inmem_pages(struct inode *inode)
241{ 241{
242 struct f2fs_inode_info *fi = F2FS_I(inode); 242 struct f2fs_inode_info *fi = F2FS_I(inode);
243 243
244 clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE); 244 clear_inode_flag(inode, FI_ATOMIC_FILE);
245 245
246 mutex_lock(&fi->inmem_lock); 246 mutex_lock(&fi->inmem_lock);
247 __revoke_inmem_pages(inode, &fi->inmem_pages, true, false); 247 __revoke_inmem_pages(inode, &fi->inmem_pages, true, false);
@@ -346,6 +346,11 @@ void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need)
346{ 346{
347 if (!need) 347 if (!need)
348 return; 348 return;
349
350 /* balance_fs_bg is able to be pending */
351 if (excess_cached_nats(sbi))
352 f2fs_balance_fs_bg(sbi);
353
349 /* 354 /*
350 * We should do GC or end up with checkpoint, if there are so many dirty 355 * We should do GC or end up with checkpoint, if there are so many dirty
351 * dir/node pages without enough free segments. 356 * dir/node pages without enough free segments.
@@ -367,7 +372,9 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi)
367 try_to_free_nats(sbi, NAT_ENTRY_PER_BLOCK); 372 try_to_free_nats(sbi, NAT_ENTRY_PER_BLOCK);
368 373
369 if (!available_free_memory(sbi, FREE_NIDS)) 374 if (!available_free_memory(sbi, FREE_NIDS))
370 try_to_free_nids(sbi, NAT_ENTRY_PER_BLOCK * FREE_NID_PAGES); 375 try_to_free_nids(sbi, MAX_FREE_NIDS);
376 else
377 build_free_nids(sbi);
371 378
372 /* checkpoint is the only way to shrink partial cached entries */ 379 /* checkpoint is the only way to shrink partial cached entries */
373 if (!available_free_memory(sbi, NAT_ENTRIES) || 380 if (!available_free_memory(sbi, NAT_ENTRIES) ||
@@ -435,25 +442,29 @@ int f2fs_issue_flush(struct f2fs_sb_info *sbi)
435 if (test_opt(sbi, NOBARRIER)) 442 if (test_opt(sbi, NOBARRIER))
436 return 0; 443 return 0;
437 444
438 if (!test_opt(sbi, FLUSH_MERGE)) { 445 if (!test_opt(sbi, FLUSH_MERGE) || !atomic_read(&fcc->submit_flush)) {
439 struct bio *bio = f2fs_bio_alloc(0); 446 struct bio *bio = f2fs_bio_alloc(0);
440 int ret; 447 int ret;
441 448
449 atomic_inc(&fcc->submit_flush);
442 bio->bi_bdev = sbi->sb->s_bdev; 450 bio->bi_bdev = sbi->sb->s_bdev;
443 bio_set_op_attrs(bio, REQ_OP_WRITE, WRITE_FLUSH); 451 bio_set_op_attrs(bio, REQ_OP_WRITE, WRITE_FLUSH);
444 ret = submit_bio_wait(bio); 452 ret = submit_bio_wait(bio);
453 atomic_dec(&fcc->submit_flush);
445 bio_put(bio); 454 bio_put(bio);
446 return ret; 455 return ret;
447 } 456 }
448 457
449 init_completion(&cmd.wait); 458 init_completion(&cmd.wait);
450 459
460 atomic_inc(&fcc->submit_flush);
451 llist_add(&cmd.llnode, &fcc->issue_list); 461 llist_add(&cmd.llnode, &fcc->issue_list);
452 462
453 if (!fcc->dispatch_list) 463 if (!fcc->dispatch_list)
454 wake_up(&fcc->flush_wait_queue); 464 wake_up(&fcc->flush_wait_queue);
455 465
456 wait_for_completion(&cmd.wait); 466 wait_for_completion(&cmd.wait);
467 atomic_dec(&fcc->submit_flush);
457 468
458 return cmd.ret; 469 return cmd.ret;
459} 470}
@@ -467,6 +478,7 @@ int create_flush_cmd_control(struct f2fs_sb_info *sbi)
467 fcc = kzalloc(sizeof(struct flush_cmd_control), GFP_KERNEL); 478 fcc = kzalloc(sizeof(struct flush_cmd_control), GFP_KERNEL);
468 if (!fcc) 479 if (!fcc)
469 return -ENOMEM; 480 return -ENOMEM;
481 atomic_set(&fcc->submit_flush, 0);
470 init_waitqueue_head(&fcc->flush_wait_queue); 482 init_waitqueue_head(&fcc->flush_wait_queue);
471 init_llist_head(&fcc->issue_list); 483 init_llist_head(&fcc->issue_list);
472 SM_I(sbi)->cmd_control_info = fcc; 484 SM_I(sbi)->cmd_control_info = fcc;
@@ -668,6 +680,10 @@ static void add_discard_addrs(struct f2fs_sb_info *sbi, struct cp_control *cpc)
668 break; 680 break;
669 681
670 end = __find_rev_next_zero_bit(dmap, max_blocks, start + 1); 682 end = __find_rev_next_zero_bit(dmap, max_blocks, start + 1);
683 if (force && start && end != max_blocks
684 && (end - start) < cpc->trim_minlen)
685 continue;
686
671 __add_discard_entry(sbi, cpc, se, start, end); 687 __add_discard_entry(sbi, cpc, se, start, end);
672 } 688 }
673} 689}
@@ -705,6 +721,8 @@ void clear_prefree_segments(struct f2fs_sb_info *sbi, struct cp_control *cpc)
705 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi); 721 struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
706 unsigned long *prefree_map = dirty_i->dirty_segmap[PRE]; 722 unsigned long *prefree_map = dirty_i->dirty_segmap[PRE];
707 unsigned int start = 0, end = -1; 723 unsigned int start = 0, end = -1;
724 unsigned int secno, start_segno;
725 bool force = (cpc->reason == CP_DISCARD);
708 726
709 mutex_lock(&dirty_i->seglist_lock); 727 mutex_lock(&dirty_i->seglist_lock);
710 728
@@ -721,17 +739,31 @@ void clear_prefree_segments(struct f2fs_sb_info *sbi, struct cp_control *cpc)
721 739
722 dirty_i->nr_dirty[PRE] -= end - start; 740 dirty_i->nr_dirty[PRE] -= end - start;
723 741
724 if (!test_opt(sbi, DISCARD)) 742 if (force || !test_opt(sbi, DISCARD))
725 continue; 743 continue;
726 744
727 f2fs_issue_discard(sbi, START_BLOCK(sbi, start), 745 if (!test_opt(sbi, LFS) || sbi->segs_per_sec == 1) {
746 f2fs_issue_discard(sbi, START_BLOCK(sbi, start),
728 (end - start) << sbi->log_blocks_per_seg); 747 (end - start) << sbi->log_blocks_per_seg);
748 continue;
749 }
750next:
751 secno = GET_SECNO(sbi, start);
752 start_segno = secno * sbi->segs_per_sec;
753 if (!IS_CURSEC(sbi, secno) &&
754 !get_valid_blocks(sbi, start, sbi->segs_per_sec))
755 f2fs_issue_discard(sbi, START_BLOCK(sbi, start_segno),
756 sbi->segs_per_sec << sbi->log_blocks_per_seg);
757
758 start = start_segno + sbi->segs_per_sec;
759 if (start < end)
760 goto next;
729 } 761 }
730 mutex_unlock(&dirty_i->seglist_lock); 762 mutex_unlock(&dirty_i->seglist_lock);
731 763
732 /* send small discards */ 764 /* send small discards */
733 list_for_each_entry_safe(entry, this, head, list) { 765 list_for_each_entry_safe(entry, this, head, list) {
734 if (cpc->reason == CP_DISCARD && entry->len < cpc->trim_minlen) 766 if (force && entry->len < cpc->trim_minlen)
735 goto skip; 767 goto skip;
736 f2fs_issue_discard(sbi, entry->blkaddr, entry->len); 768 f2fs_issue_discard(sbi, entry->blkaddr, entry->len);
737 cpc->trimmed += entry->len; 769 cpc->trimmed += entry->len;
@@ -1219,6 +1251,9 @@ void allocate_new_segments(struct f2fs_sb_info *sbi)
1219{ 1251{
1220 int i; 1252 int i;
1221 1253
1254 if (test_opt(sbi, LFS))
1255 return;
1256
1222 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) 1257 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++)
1223 __allocate_new_segments(sbi, i); 1258 __allocate_new_segments(sbi, i);
1224} 1259}
@@ -1392,11 +1427,17 @@ static void do_write_page(struct f2fs_summary *sum, struct f2fs_io_info *fio)
1392{ 1427{
1393 int type = __get_segment_type(fio->page, fio->type); 1428 int type = __get_segment_type(fio->page, fio->type);
1394 1429
1430 if (fio->type == NODE || fio->type == DATA)
1431 mutex_lock(&fio->sbi->wio_mutex[fio->type]);
1432
1395 allocate_data_block(fio->sbi, fio->page, fio->old_blkaddr, 1433 allocate_data_block(fio->sbi, fio->page, fio->old_blkaddr,
1396 &fio->new_blkaddr, sum, type); 1434 &fio->new_blkaddr, sum, type);
1397 1435
1398 /* writeout dirty page into bdev */ 1436 /* writeout dirty page into bdev */
1399 f2fs_submit_page_mbio(fio); 1437 f2fs_submit_page_mbio(fio);
1438
1439 if (fio->type == NODE || fio->type == DATA)
1440 mutex_unlock(&fio->sbi->wio_mutex[fio->type]);
1400} 1441}
1401 1442
1402void write_meta_page(struct f2fs_sb_info *sbi, struct page *page) 1443void write_meta_page(struct f2fs_sb_info *sbi, struct page *page)
@@ -2377,7 +2418,11 @@ int build_segment_manager(struct f2fs_sb_info *sbi)
2377 sm_info->ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr); 2418 sm_info->ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr);
2378 sm_info->rec_prefree_segments = sm_info->main_segments * 2419 sm_info->rec_prefree_segments = sm_info->main_segments *
2379 DEF_RECLAIM_PREFREE_SEGMENTS / 100; 2420 DEF_RECLAIM_PREFREE_SEGMENTS / 100;
2380 sm_info->ipu_policy = 1 << F2FS_IPU_FSYNC; 2421 if (sm_info->rec_prefree_segments > DEF_MAX_RECLAIM_PREFREE_SEGMENTS)
2422 sm_info->rec_prefree_segments = DEF_MAX_RECLAIM_PREFREE_SEGMENTS;
2423
2424 if (!test_opt(sbi, LFS))
2425 sm_info->ipu_policy = 1 << F2FS_IPU_FSYNC;
2381 sm_info->min_ipu_util = DEF_MIN_IPU_UTIL; 2426 sm_info->min_ipu_util = DEF_MIN_IPU_UTIL;
2382 sm_info->min_fsync_blocks = DEF_MIN_FSYNC_BLOCKS; 2427 sm_info->min_fsync_blocks = DEF_MIN_FSYNC_BLOCKS;
2383 2428
diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index 7a756ff5a36d..b33f73ec60a4 100644
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -16,6 +16,7 @@
16#define NULL_SECNO ((unsigned int)(~0)) 16#define NULL_SECNO ((unsigned int)(~0))
17 17
18#define DEF_RECLAIM_PREFREE_SEGMENTS 5 /* 5% over total segments */ 18#define DEF_RECLAIM_PREFREE_SEGMENTS 5 /* 5% over total segments */
19#define DEF_MAX_RECLAIM_PREFREE_SEGMENTS 4096 /* 8GB in maximum */
19 20
20/* L: Logical segment # in volume, R: Relative segment # in main area */ 21/* L: Logical segment # in volume, R: Relative segment # in main area */
21#define GET_L2R_SEGNO(free_i, segno) (segno - free_i->start_segno) 22#define GET_L2R_SEGNO(free_i, segno) (segno - free_i->start_segno)
@@ -470,6 +471,10 @@ static inline bool need_SSR(struct f2fs_sb_info *sbi)
470{ 471{
471 int node_secs = get_blocktype_secs(sbi, F2FS_DIRTY_NODES); 472 int node_secs = get_blocktype_secs(sbi, F2FS_DIRTY_NODES);
472 int dent_secs = get_blocktype_secs(sbi, F2FS_DIRTY_DENTS); 473 int dent_secs = get_blocktype_secs(sbi, F2FS_DIRTY_DENTS);
474
475 if (test_opt(sbi, LFS))
476 return false;
477
473 return free_sections(sbi) <= (node_secs + 2 * dent_secs + 478 return free_sections(sbi) <= (node_secs + 2 * dent_secs +
474 reserved_sections(sbi) + 1); 479 reserved_sections(sbi) + 1);
475} 480}
@@ -479,6 +484,8 @@ static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi, int freed)
479 int node_secs = get_blocktype_secs(sbi, F2FS_DIRTY_NODES); 484 int node_secs = get_blocktype_secs(sbi, F2FS_DIRTY_NODES);
480 int dent_secs = get_blocktype_secs(sbi, F2FS_DIRTY_DENTS); 485 int dent_secs = get_blocktype_secs(sbi, F2FS_DIRTY_DENTS);
481 486
487 node_secs += get_blocktype_secs(sbi, F2FS_DIRTY_IMETA);
488
482 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING))) 489 if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
483 return false; 490 return false;
484 491
@@ -531,6 +538,9 @@ static inline bool need_inplace_update(struct inode *inode)
531 if (S_ISDIR(inode->i_mode) || f2fs_is_atomic_file(inode)) 538 if (S_ISDIR(inode->i_mode) || f2fs_is_atomic_file(inode))
532 return false; 539 return false;
533 540
541 if (test_opt(sbi, LFS))
542 return false;
543
534 if (policy & (0x1 << F2FS_IPU_FORCE)) 544 if (policy & (0x1 << F2FS_IPU_FORCE))
535 return true; 545 return true;
536 if (policy & (0x1 << F2FS_IPU_SSR) && need_SSR(sbi)) 546 if (policy & (0x1 << F2FS_IPU_SSR) && need_SSR(sbi))
@@ -544,7 +554,7 @@ static inline bool need_inplace_update(struct inode *inode)
544 554
545 /* this is only set during fdatasync */ 555 /* this is only set during fdatasync */
546 if (policy & (0x1 << F2FS_IPU_FSYNC) && 556 if (policy & (0x1 << F2FS_IPU_FSYNC) &&
547 is_inode_flag_set(F2FS_I(inode), FI_NEED_IPU)) 557 is_inode_flag_set(inode, FI_NEED_IPU))
548 return true; 558 return true;
549 559
550 return false; 560 return false;
@@ -706,9 +716,9 @@ static inline int nr_pages_to_skip(struct f2fs_sb_info *sbi, int type)
706 if (type == DATA) 716 if (type == DATA)
707 return sbi->blocks_per_seg; 717 return sbi->blocks_per_seg;
708 else if (type == NODE) 718 else if (type == NODE)
709 return 3 * sbi->blocks_per_seg; 719 return 8 * sbi->blocks_per_seg;
710 else if (type == META) 720 else if (type == META)
711 return MAX_BIO_BLOCKS(sbi); 721 return 8 * MAX_BIO_BLOCKS(sbi);
712 else 722 else
713 return 0; 723 return 0;
714} 724}
@@ -726,10 +736,8 @@ static inline long nr_pages_to_write(struct f2fs_sb_info *sbi, int type,
726 736
727 nr_to_write = wbc->nr_to_write; 737 nr_to_write = wbc->nr_to_write;
728 738
729 if (type == DATA) 739 if (type == NODE)
730 desired = 4096; 740 desired = 2 * max_hw_blocks(sbi);
731 else if (type == NODE)
732 desired = 3 * max_hw_blocks(sbi);
733 else 741 else
734 desired = MAX_BIO_BLOCKS(sbi); 742 desired = MAX_BIO_BLOCKS(sbi);
735 743
diff --git a/fs/f2fs/shrinker.c b/fs/f2fs/shrinker.c
index 93606f281bf9..46c915425923 100644
--- a/fs/f2fs/shrinker.c
+++ b/fs/f2fs/shrinker.c
@@ -13,6 +13,7 @@
13#include <linux/f2fs_fs.h> 13#include <linux/f2fs_fs.h>
14 14
15#include "f2fs.h" 15#include "f2fs.h"
16#include "node.h"
16 17
17static LIST_HEAD(f2fs_list); 18static LIST_HEAD(f2fs_list);
18static DEFINE_SPINLOCK(f2fs_list_lock); 19static DEFINE_SPINLOCK(f2fs_list_lock);
@@ -25,8 +26,8 @@ static unsigned long __count_nat_entries(struct f2fs_sb_info *sbi)
25 26
26static unsigned long __count_free_nids(struct f2fs_sb_info *sbi) 27static unsigned long __count_free_nids(struct f2fs_sb_info *sbi)
27{ 28{
28 if (NM_I(sbi)->fcnt > NAT_ENTRY_PER_BLOCK) 29 if (NM_I(sbi)->fcnt > MAX_FREE_NIDS)
29 return NM_I(sbi)->fcnt - NAT_ENTRY_PER_BLOCK; 30 return NM_I(sbi)->fcnt - MAX_FREE_NIDS;
30 return 0; 31 return 0;
31} 32}
32 33
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 74cc8520b8b1..b97c065cbe74 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -49,6 +49,7 @@ char *fault_name[FAULT_MAX] = {
49 [FAULT_ORPHAN] = "orphan", 49 [FAULT_ORPHAN] = "orphan",
50 [FAULT_BLOCK] = "no more block", 50 [FAULT_BLOCK] = "no more block",
51 [FAULT_DIR_DEPTH] = "too big dir depth", 51 [FAULT_DIR_DEPTH] = "too big dir depth",
52 [FAULT_EVICT_INODE] = "evict_inode fail",
52}; 53};
53 54
54static void f2fs_build_fault_attr(unsigned int rate) 55static void f2fs_build_fault_attr(unsigned int rate)
@@ -75,6 +76,7 @@ enum {
75 Opt_disable_roll_forward, 76 Opt_disable_roll_forward,
76 Opt_norecovery, 77 Opt_norecovery,
77 Opt_discard, 78 Opt_discard,
79 Opt_nodiscard,
78 Opt_noheap, 80 Opt_noheap,
79 Opt_user_xattr, 81 Opt_user_xattr,
80 Opt_nouser_xattr, 82 Opt_nouser_xattr,
@@ -86,13 +88,17 @@ enum {
86 Opt_inline_data, 88 Opt_inline_data,
87 Opt_inline_dentry, 89 Opt_inline_dentry,
88 Opt_flush_merge, 90 Opt_flush_merge,
91 Opt_noflush_merge,
89 Opt_nobarrier, 92 Opt_nobarrier,
90 Opt_fastboot, 93 Opt_fastboot,
91 Opt_extent_cache, 94 Opt_extent_cache,
92 Opt_noextent_cache, 95 Opt_noextent_cache,
93 Opt_noinline_data, 96 Opt_noinline_data,
94 Opt_data_flush, 97 Opt_data_flush,
98 Opt_mode,
95 Opt_fault_injection, 99 Opt_fault_injection,
100 Opt_lazytime,
101 Opt_nolazytime,
96 Opt_err, 102 Opt_err,
97}; 103};
98 104
@@ -101,6 +107,7 @@ static match_table_t f2fs_tokens = {
101 {Opt_disable_roll_forward, "disable_roll_forward"}, 107 {Opt_disable_roll_forward, "disable_roll_forward"},
102 {Opt_norecovery, "norecovery"}, 108 {Opt_norecovery, "norecovery"},
103 {Opt_discard, "discard"}, 109 {Opt_discard, "discard"},
110 {Opt_nodiscard, "nodiscard"},
104 {Opt_noheap, "no_heap"}, 111 {Opt_noheap, "no_heap"},
105 {Opt_user_xattr, "user_xattr"}, 112 {Opt_user_xattr, "user_xattr"},
106 {Opt_nouser_xattr, "nouser_xattr"}, 113 {Opt_nouser_xattr, "nouser_xattr"},
@@ -112,13 +119,17 @@ static match_table_t f2fs_tokens = {
112 {Opt_inline_data, "inline_data"}, 119 {Opt_inline_data, "inline_data"},
113 {Opt_inline_dentry, "inline_dentry"}, 120 {Opt_inline_dentry, "inline_dentry"},
114 {Opt_flush_merge, "flush_merge"}, 121 {Opt_flush_merge, "flush_merge"},
122 {Opt_noflush_merge, "noflush_merge"},
115 {Opt_nobarrier, "nobarrier"}, 123 {Opt_nobarrier, "nobarrier"},
116 {Opt_fastboot, "fastboot"}, 124 {Opt_fastboot, "fastboot"},
117 {Opt_extent_cache, "extent_cache"}, 125 {Opt_extent_cache, "extent_cache"},
118 {Opt_noextent_cache, "noextent_cache"}, 126 {Opt_noextent_cache, "noextent_cache"},
119 {Opt_noinline_data, "noinline_data"}, 127 {Opt_noinline_data, "noinline_data"},
120 {Opt_data_flush, "data_flush"}, 128 {Opt_data_flush, "data_flush"},
129 {Opt_mode, "mode=%s"},
121 {Opt_fault_injection, "fault_injection=%u"}, 130 {Opt_fault_injection, "fault_injection=%u"},
131 {Opt_lazytime, "lazytime"},
132 {Opt_nolazytime, "nolazytime"},
122 {Opt_err, NULL}, 133 {Opt_err, NULL},
123}; 134};
124 135
@@ -417,6 +428,8 @@ static int parse_options(struct super_block *sb, char *options)
417 "the device does not support discard"); 428 "the device does not support discard");
418 } 429 }
419 break; 430 break;
431 case Opt_nodiscard:
432 clear_opt(sbi, DISCARD);
420 case Opt_noheap: 433 case Opt_noheap:
421 set_opt(sbi, NOHEAP); 434 set_opt(sbi, NOHEAP);
422 break; 435 break;
@@ -478,6 +491,9 @@ static int parse_options(struct super_block *sb, char *options)
478 case Opt_flush_merge: 491 case Opt_flush_merge:
479 set_opt(sbi, FLUSH_MERGE); 492 set_opt(sbi, FLUSH_MERGE);
480 break; 493 break;
494 case Opt_noflush_merge:
495 clear_opt(sbi, FLUSH_MERGE);
496 break;
481 case Opt_nobarrier: 497 case Opt_nobarrier:
482 set_opt(sbi, NOBARRIER); 498 set_opt(sbi, NOBARRIER);
483 break; 499 break;
@@ -496,6 +512,23 @@ static int parse_options(struct super_block *sb, char *options)
496 case Opt_data_flush: 512 case Opt_data_flush:
497 set_opt(sbi, DATA_FLUSH); 513 set_opt(sbi, DATA_FLUSH);
498 break; 514 break;
515 case Opt_mode:
516 name = match_strdup(&args[0]);
517
518 if (!name)
519 return -ENOMEM;
520 if (strlen(name) == 8 &&
521 !strncmp(name, "adaptive", 8)) {
522 set_opt_mode(sbi, F2FS_MOUNT_ADAPTIVE);
523 } else if (strlen(name) == 3 &&
524 !strncmp(name, "lfs", 3)) {
525 set_opt_mode(sbi, F2FS_MOUNT_LFS);
526 } else {
527 kfree(name);
528 return -EINVAL;
529 }
530 kfree(name);
531 break;
499 case Opt_fault_injection: 532 case Opt_fault_injection:
500 if (args->from && match_int(args, &arg)) 533 if (args->from && match_int(args, &arg))
501 return -EINVAL; 534 return -EINVAL;
@@ -506,6 +539,12 @@ static int parse_options(struct super_block *sb, char *options)
506 "FAULT_INJECTION was not selected"); 539 "FAULT_INJECTION was not selected");
507#endif 540#endif
508 break; 541 break;
542 case Opt_lazytime:
543 sb->s_flags |= MS_LAZYTIME;
544 break;
545 case Opt_nolazytime:
546 sb->s_flags &= ~MS_LAZYTIME;
547 break;
509 default: 548 default:
510 f2fs_msg(sb, KERN_ERR, 549 f2fs_msg(sb, KERN_ERR,
511 "Unrecognized mount option \"%s\" or missing value", 550 "Unrecognized mount option \"%s\" or missing value",
@@ -537,13 +576,11 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb)
537 fi->i_advise = 0; 576 fi->i_advise = 0;
538 init_rwsem(&fi->i_sem); 577 init_rwsem(&fi->i_sem);
539 INIT_LIST_HEAD(&fi->dirty_list); 578 INIT_LIST_HEAD(&fi->dirty_list);
579 INIT_LIST_HEAD(&fi->gdirty_list);
540 INIT_LIST_HEAD(&fi->inmem_pages); 580 INIT_LIST_HEAD(&fi->inmem_pages);
541 mutex_init(&fi->inmem_lock); 581 mutex_init(&fi->inmem_lock);
542 582 init_rwsem(&fi->dio_rwsem[READ]);
543 set_inode_flag(fi, FI_NEW_INODE); 583 init_rwsem(&fi->dio_rwsem[WRITE]);
544
545 if (test_opt(F2FS_SB(sb), INLINE_XATTR))
546 set_inode_flag(fi, FI_INLINE_XATTR);
547 584
548 /* Will be used by directory only */ 585 /* Will be used by directory only */
549 fi->i_dir_level = F2FS_SB(sb)->dir_level; 586 fi->i_dir_level = F2FS_SB(sb)->dir_level;
@@ -559,7 +596,7 @@ static int f2fs_drop_inode(struct inode *inode)
559 * - f2fs_gc -> iput -> evict 596 * - f2fs_gc -> iput -> evict
560 * - inode_wait_for_writeback(inode) 597 * - inode_wait_for_writeback(inode)
561 */ 598 */
562 if (!inode_unhashed(inode) && inode->i_state & I_SYNC) { 599 if ((!inode_unhashed(inode) && inode->i_state & I_SYNC)) {
563 if (!inode->i_nlink && !is_bad_inode(inode)) { 600 if (!inode->i_nlink && !is_bad_inode(inode)) {
564 /* to avoid evict_inode call simultaneously */ 601 /* to avoid evict_inode call simultaneously */
565 atomic_inc(&inode->i_count); 602 atomic_inc(&inode->i_count);
@@ -573,10 +610,10 @@ static int f2fs_drop_inode(struct inode *inode)
573 f2fs_destroy_extent_node(inode); 610 f2fs_destroy_extent_node(inode);
574 611
575 sb_start_intwrite(inode->i_sb); 612 sb_start_intwrite(inode->i_sb);
576 i_size_write(inode, 0); 613 f2fs_i_size_write(inode, 0);
577 614
578 if (F2FS_HAS_BLOCKS(inode)) 615 if (F2FS_HAS_BLOCKS(inode))
579 f2fs_truncate(inode, true); 616 f2fs_truncate(inode);
580 617
581 sb_end_intwrite(inode->i_sb); 618 sb_end_intwrite(inode->i_sb);
582 619
@@ -586,9 +623,47 @@ static int f2fs_drop_inode(struct inode *inode)
586 } 623 }
587 return 0; 624 return 0;
588 } 625 }
626
589 return generic_drop_inode(inode); 627 return generic_drop_inode(inode);
590} 628}
591 629
630int f2fs_inode_dirtied(struct inode *inode)
631{
632 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
633
634 spin_lock(&sbi->inode_lock[DIRTY_META]);
635 if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
636 spin_unlock(&sbi->inode_lock[DIRTY_META]);
637 return 1;
638 }
639
640 set_inode_flag(inode, FI_DIRTY_INODE);
641 list_add_tail(&F2FS_I(inode)->gdirty_list,
642 &sbi->inode_list[DIRTY_META]);
643 inc_page_count(sbi, F2FS_DIRTY_IMETA);
644 stat_inc_dirty_inode(sbi, DIRTY_META);
645 spin_unlock(&sbi->inode_lock[DIRTY_META]);
646
647 return 0;
648}
649
650void f2fs_inode_synced(struct inode *inode)
651{
652 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
653
654 spin_lock(&sbi->inode_lock[DIRTY_META]);
655 if (!is_inode_flag_set(inode, FI_DIRTY_INODE)) {
656 spin_unlock(&sbi->inode_lock[DIRTY_META]);
657 return;
658 }
659 list_del_init(&F2FS_I(inode)->gdirty_list);
660 clear_inode_flag(inode, FI_DIRTY_INODE);
661 clear_inode_flag(inode, FI_AUTO_RECOVER);
662 dec_page_count(sbi, F2FS_DIRTY_IMETA);
663 stat_dec_dirty_inode(F2FS_I_SB(inode), DIRTY_META);
664 spin_unlock(&sbi->inode_lock[DIRTY_META]);
665}
666
592/* 667/*
593 * f2fs_dirty_inode() is called from __mark_inode_dirty() 668 * f2fs_dirty_inode() is called from __mark_inode_dirty()
594 * 669 *
@@ -596,7 +671,19 @@ static int f2fs_drop_inode(struct inode *inode)
596 */ 671 */
597static void f2fs_dirty_inode(struct inode *inode, int flags) 672static void f2fs_dirty_inode(struct inode *inode, int flags)
598{ 673{
599 set_inode_flag(F2FS_I(inode), FI_DIRTY_INODE); 674 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
675
676 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
677 inode->i_ino == F2FS_META_INO(sbi))
678 return;
679
680 if (flags == I_DIRTY_TIME)
681 return;
682
683 if (is_inode_flag_set(inode, FI_AUTO_RECOVER))
684 clear_inode_flag(inode, FI_AUTO_RECOVER);
685
686 f2fs_inode_dirtied(inode);
600} 687}
601 688
602static void f2fs_i_callback(struct rcu_head *head) 689static void f2fs_i_callback(struct rcu_head *head)
@@ -619,6 +706,8 @@ static void destroy_percpu_info(struct f2fs_sb_info *sbi)
619 percpu_counter_destroy(&sbi->nr_pages[i]); 706 percpu_counter_destroy(&sbi->nr_pages[i]);
620 percpu_counter_destroy(&sbi->alloc_valid_block_count); 707 percpu_counter_destroy(&sbi->alloc_valid_block_count);
621 percpu_counter_destroy(&sbi->total_valid_inode_count); 708 percpu_counter_destroy(&sbi->total_valid_inode_count);
709
710 percpu_free_rwsem(&sbi->cp_rwsem);
622} 711}
623 712
624static void f2fs_put_super(struct super_block *sb) 713static void f2fs_put_super(struct super_block *sb)
@@ -738,7 +827,7 @@ static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
738 buf->f_bsize = sbi->blocksize; 827 buf->f_bsize = sbi->blocksize;
739 828
740 buf->f_blocks = total_count - start_count; 829 buf->f_blocks = total_count - start_count;
741 buf->f_bfree = buf->f_blocks - valid_user_blocks(sbi) - ovp_count; 830 buf->f_bfree = user_block_count - valid_user_blocks(sbi) + ovp_count;
742 buf->f_bavail = user_block_count - valid_user_blocks(sbi); 831 buf->f_bavail = user_block_count - valid_user_blocks(sbi);
743 832
744 buf->f_files = sbi->total_node_count - F2FS_RESERVED_NODE_NUM; 833 buf->f_files = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
@@ -803,6 +892,12 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
803 seq_puts(seq, ",noextent_cache"); 892 seq_puts(seq, ",noextent_cache");
804 if (test_opt(sbi, DATA_FLUSH)) 893 if (test_opt(sbi, DATA_FLUSH))
805 seq_puts(seq, ",data_flush"); 894 seq_puts(seq, ",data_flush");
895
896 seq_puts(seq, ",mode=");
897 if (test_opt(sbi, ADAPTIVE))
898 seq_puts(seq, "adaptive");
899 else if (test_opt(sbi, LFS))
900 seq_puts(seq, "lfs");
806 seq_printf(seq, ",active_logs=%u", sbi->active_logs); 901 seq_printf(seq, ",active_logs=%u", sbi->active_logs);
807 902
808 return 0; 903 return 0;
@@ -884,6 +979,14 @@ static void default_options(struct f2fs_sb_info *sbi)
884 set_opt(sbi, BG_GC); 979 set_opt(sbi, BG_GC);
885 set_opt(sbi, INLINE_DATA); 980 set_opt(sbi, INLINE_DATA);
886 set_opt(sbi, EXTENT_CACHE); 981 set_opt(sbi, EXTENT_CACHE);
982 sbi->sb->s_flags |= MS_LAZYTIME;
983 set_opt(sbi, FLUSH_MERGE);
984 if (f2fs_sb_mounted_hmsmr(sbi->sb)) {
985 set_opt_mode(sbi, F2FS_MOUNT_LFS);
986 set_opt(sbi, DISCARD);
987 } else {
988 set_opt_mode(sbi, F2FS_MOUNT_ADAPTIVE);
989 }
887 990
888#ifdef CONFIG_F2FS_FS_XATTR 991#ifdef CONFIG_F2FS_FS_XATTR
889 set_opt(sbi, XATTR_USER); 992 set_opt(sbi, XATTR_USER);
@@ -1367,6 +1470,8 @@ static void init_sb_info(struct f2fs_sb_info *sbi)
1367 1470
1368 INIT_LIST_HEAD(&sbi->s_list); 1471 INIT_LIST_HEAD(&sbi->s_list);
1369 mutex_init(&sbi->umount_mutex); 1472 mutex_init(&sbi->umount_mutex);
1473 mutex_init(&sbi->wio_mutex[NODE]);
1474 mutex_init(&sbi->wio_mutex[DATA]);
1370 1475
1371#ifdef CONFIG_F2FS_FS_ENCRYPTION 1476#ifdef CONFIG_F2FS_FS_ENCRYPTION
1372 memcpy(sbi->key_prefix, F2FS_KEY_DESC_PREFIX, 1477 memcpy(sbi->key_prefix, F2FS_KEY_DESC_PREFIX,
@@ -1379,6 +1484,9 @@ static int init_percpu_info(struct f2fs_sb_info *sbi)
1379{ 1484{
1380 int i, err; 1485 int i, err;
1381 1486
1487 if (percpu_init_rwsem(&sbi->cp_rwsem))
1488 return -ENOMEM;
1489
1382 for (i = 0; i < NR_COUNT_TYPE; i++) { 1490 for (i = 0; i < NR_COUNT_TYPE; i++) {
1383 err = percpu_counter_init(&sbi->nr_pages[i], 0, GFP_KERNEL); 1491 err = percpu_counter_init(&sbi->nr_pages[i], 0, GFP_KERNEL);
1384 if (err) 1492 if (err)
@@ -1530,6 +1638,8 @@ try_onemore:
1530 goto free_sbi; 1638 goto free_sbi;
1531 1639
1532 sb->s_fs_info = sbi; 1640 sb->s_fs_info = sbi;
1641 sbi->raw_super = raw_super;
1642
1533 default_options(sbi); 1643 default_options(sbi);
1534 /* parse mount options */ 1644 /* parse mount options */
1535 options = kstrdup((const char *)data, GFP_KERNEL); 1645 options = kstrdup((const char *)data, GFP_KERNEL);
@@ -1559,10 +1669,8 @@ try_onemore:
1559 memcpy(sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid)); 1669 memcpy(sb->s_uuid, raw_super->uuid, sizeof(raw_super->uuid));
1560 1670
1561 /* init f2fs-specific super block info */ 1671 /* init f2fs-specific super block info */
1562 sbi->raw_super = raw_super;
1563 sbi->valid_super_block = valid_super_block; 1672 sbi->valid_super_block = valid_super_block;
1564 mutex_init(&sbi->gc_mutex); 1673 mutex_init(&sbi->gc_mutex);
1565 mutex_init(&sbi->writepages);
1566 mutex_init(&sbi->cp_mutex); 1674 mutex_init(&sbi->cp_mutex);
1567 init_rwsem(&sbi->node_write); 1675 init_rwsem(&sbi->node_write);
1568 1676
@@ -1579,7 +1687,6 @@ try_onemore:
1579 sbi->write_io[i].bio = NULL; 1687 sbi->write_io[i].bio = NULL;
1580 } 1688 }
1581 1689
1582 init_rwsem(&sbi->cp_rwsem);
1583 init_waitqueue_head(&sbi->cp_wait); 1690 init_waitqueue_head(&sbi->cp_wait);
1584 init_sb_info(sbi); 1691 init_sb_info(sbi);
1585 1692
@@ -1762,6 +1869,7 @@ try_onemore:
1762 return 0; 1869 return 0;
1763 1870
1764free_kobj: 1871free_kobj:
1872 f2fs_sync_inode_meta(sbi);
1765 kobject_del(&sbi->s_kobj); 1873 kobject_del(&sbi->s_kobj);
1766 kobject_put(&sbi->s_kobj); 1874 kobject_put(&sbi->s_kobj);
1767 wait_for_completion(&sbi->s_kobj_unregister); 1875 wait_for_completion(&sbi->s_kobj_unregister);
diff --git a/fs/f2fs/xattr.c b/fs/f2fs/xattr.c
index e3decae3acfb..c8898b5148eb 100644
--- a/fs/f2fs/xattr.c
+++ b/fs/f2fs/xattr.c
@@ -106,7 +106,7 @@ static int f2fs_xattr_advise_set(const struct xattr_handler *handler,
106 return -EINVAL; 106 return -EINVAL;
107 107
108 F2FS_I(inode)->i_advise |= *(char *)value; 108 F2FS_I(inode)->i_advise |= *(char *)value;
109 mark_inode_dirty(inode); 109 f2fs_mark_inode_dirty_sync(inode);
110 return 0; 110 return 0;
111} 111}
112 112
@@ -299,6 +299,7 @@ static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
299 if (ipage) { 299 if (ipage) {
300 inline_addr = inline_xattr_addr(ipage); 300 inline_addr = inline_xattr_addr(ipage);
301 f2fs_wait_on_page_writeback(ipage, NODE, true); 301 f2fs_wait_on_page_writeback(ipage, NODE, true);
302 set_page_dirty(ipage);
302 } else { 303 } else {
303 page = get_node_page(sbi, inode->i_ino); 304 page = get_node_page(sbi, inode->i_ino);
304 if (IS_ERR(page)) { 305 if (IS_ERR(page)) {
@@ -441,13 +442,12 @@ static int __f2fs_setxattr(struct inode *inode, int index,
441 const char *name, const void *value, size_t size, 442 const char *name, const void *value, size_t size,
442 struct page *ipage, int flags) 443 struct page *ipage, int flags)
443{ 444{
444 struct f2fs_inode_info *fi = F2FS_I(inode);
445 struct f2fs_xattr_entry *here, *last; 445 struct f2fs_xattr_entry *here, *last;
446 void *base_addr; 446 void *base_addr;
447 int found, newsize; 447 int found, newsize;
448 size_t len; 448 size_t len;
449 __u32 new_hsize; 449 __u32 new_hsize;
450 int error = -ENOMEM; 450 int error = 0;
451 451
452 if (name == NULL) 452 if (name == NULL)
453 return -EINVAL; 453 return -EINVAL;
@@ -465,7 +465,7 @@ static int __f2fs_setxattr(struct inode *inode, int index,
465 465
466 base_addr = read_all_xattrs(inode, ipage); 466 base_addr = read_all_xattrs(inode, ipage);
467 if (!base_addr) 467 if (!base_addr)
468 goto exit; 468 return -ENOMEM;
469 469
470 /* find entry with wanted name. */ 470 /* find entry with wanted name. */
471 here = __find_xattr(base_addr, index, len, name); 471 here = __find_xattr(base_addr, index, len, name);
@@ -539,19 +539,15 @@ static int __f2fs_setxattr(struct inode *inode, int index,
539 if (error) 539 if (error)
540 goto exit; 540 goto exit;
541 541
542 if (is_inode_flag_set(fi, FI_ACL_MODE)) { 542 if (is_inode_flag_set(inode, FI_ACL_MODE)) {
543 inode->i_mode = fi->i_acl_mode; 543 inode->i_mode = F2FS_I(inode)->i_acl_mode;
544 inode->i_ctime = CURRENT_TIME; 544 inode->i_ctime = CURRENT_TIME;
545 clear_inode_flag(fi, FI_ACL_MODE); 545 clear_inode_flag(inode, FI_ACL_MODE);
546 } 546 }
547 if (index == F2FS_XATTR_INDEX_ENCRYPTION && 547 if (index == F2FS_XATTR_INDEX_ENCRYPTION &&
548 !strcmp(name, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT)) 548 !strcmp(name, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT))
549 f2fs_set_encrypted_inode(inode); 549 f2fs_set_encrypted_inode(inode);
550 550 f2fs_mark_inode_dirty_sync(inode);
551 if (ipage)
552 update_inode(inode, ipage);
553 else
554 update_inode_page(inode);
555exit: 551exit:
556 kzfree(base_addr); 552 kzfree(base_addr);
557 return error; 553 return error;
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-24 04:47:41 -0400