forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-09 95099d4622f8cb224d94e314c7a8e0df60b13f87 
 kernel/fs/f2fs/node.c
....@@ -17,7 +17,6 @@
1717 #include "node.h"
1818 #include "segment.h"
1919 #include "xattr.h"
20
-#include "trace.h"
2120 #include <trace/events/f2fs.h>
2221 
2322 #define on_f2fs_build_free_nids(nmi) mutex_is_locked(&(nm_i)->build_lock)
....@@ -44,10 +43,14 @@
4443 bool f2fs_available_free_memory(struct f2fs_sb_info *sbi, int type)
4544 {
4645 	struct f2fs_nm_info *nm_i = NM_I(sbi);
46
+	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
4747 	struct sysinfo val;
4848 	unsigned long avail_ram;
4949 	unsigned long mem_size = 0;
5050 	bool res = false;
51
+
52
+	if (!nm_i)
53
+		return true;
5154 
5255 	si_meminfo(&val);
5356 
....@@ -55,15 +58,15 @@
5558 	avail_ram = val.totalram - val.totalhigh;
5659 
5760 	/*
58
-	 * give 25%, 25%, 50%, 50%, 50% memory for each components respectively
61
+	 * give 25%, 25%, 50%, 50%, 25%, 25% memory for each components respectively
5962 	 */
6063 	if (type == FREE_NIDS) {
6164 		mem_size = (nm_i->nid_cnt[FREE_NID] *
6265 				sizeof(struct free_nid)) >> PAGE_SHIFT;
6366 		res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 2);
6467 	} else if (type == NAT_ENTRIES) {
65
-		mem_size = (nm_i->nat_cnt * sizeof(struct nat_entry)) >>
66
-							PAGE_SHIFT;
68
+		mem_size = (nm_i->nat_cnt[TOTAL_NAT] *
69
+				sizeof(struct nat_entry)) >> PAGE_SHIFT;
6770 		res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 2);
6871 		if (excess_cached_nats(sbi))
6972 			res = false;
....@@ -80,16 +83,38 @@
8083 						sizeof(struct ino_entry);
8184 		mem_size >>= PAGE_SHIFT;
8285 		res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 1);
83
-	} else if (type == EXTENT_CACHE) {
84
-		mem_size = (atomic_read(&sbi->total_ext_tree) *
86
+	} else if (type == READ_EXTENT_CACHE || type == AGE_EXTENT_CACHE) {
87
+		enum extent_type etype = type == READ_EXTENT_CACHE ?
88
+						EX_READ : EX_BLOCK_AGE;
89
+		struct extent_tree_info *eti = &sbi->extent_tree[etype];
90
+
91
+		mem_size = (atomic_read(&eti->total_ext_tree) *
8592 				sizeof(struct extent_tree) +
86
-				atomic_read(&sbi->total_ext_node) *
93
+				atomic_read(&eti->total_ext_node) *
8794 				sizeof(struct extent_node)) >> PAGE_SHIFT;
88
-		res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 1);
95
+		res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 2);
8996 	} else if (type == INMEM_PAGES) {
9097 		/* it allows 20% / total_ram for inmemory pages */
9198 		mem_size = get_pages(sbi, F2FS_INMEM_PAGES);
9299 		res = mem_size < (val.totalram / 5);
100
+	} else if (type == DISCARD_CACHE) {
101
+		mem_size = (atomic_read(&dcc->discard_cmd_cnt) *
102
+				sizeof(struct discard_cmd)) >> PAGE_SHIFT;
103
+		res = mem_size < (avail_ram * nm_i->ram_thresh / 100);
104
+	} else if (type == COMPRESS_PAGE) {
105
+#ifdef CONFIG_F2FS_FS_COMPRESSION
106
+		unsigned long free_ram = val.freeram;
107
+
108
+		/*
109
+		 * free memory is lower than watermark or cached page count
110
+		 * exceed threshold, deny caching compress page.
111
+		 */
112
+		res = (free_ram > avail_ram * sbi->compress_watermark / 100) &&
113
+			(COMPRESS_MAPPING(sbi)->nrpages <
114
+			 free_ram * sbi->compress_percent / 100);
115
+#else
116
+		res = false;
117
+#endif
93118 	} else {
94119 		if (!sbi->sb->s_bdi->wb.dirty_exceeded)
95120 			return true;
....@@ -100,7 +125,7 @@
100125 static void clear_node_page_dirty(struct page *page)
101126 {
102127 	if (PageDirty(page)) {
103
-		f2fs_clear_radix_tree_dirty_tag(page);
128
+		f2fs_clear_page_cache_dirty_tag(page);
104129 		clear_page_dirty_for_io(page);
105130 		dec_page_count(F2FS_P_SB(page), F2FS_DIRTY_NODES);
106131 	}
....@@ -109,7 +134,7 @@
109134 
110135 static struct page *get_current_nat_page(struct f2fs_sb_info *sbi, nid_t nid)
111136 {
112
-	return f2fs_get_meta_page_nofail(sbi, current_nat_addr(sbi, nid));
137
+	return f2fs_get_meta_page_retry(sbi, current_nat_addr(sbi, nid));
113138 }
114139 
115140 static struct page *get_next_nat_page(struct f2fs_sb_info *sbi, nid_t nid)
....@@ -177,7 +202,8 @@
177202 	list_add_tail(&ne->list, &nm_i->nat_entries);
178203 	spin_unlock(&nm_i->nat_list_lock);
179204 
180
-	nm_i->nat_cnt++;
205
+	nm_i->nat_cnt[TOTAL_NAT]++;
206
+	nm_i->nat_cnt[RECLAIMABLE_NAT]++;
181207 	return ne;
182208 }
183209 
....@@ -207,7 +233,8 @@
207233 static void __del_from_nat_cache(struct f2fs_nm_info *nm_i, struct nat_entry *e)
208234 {
209235 	radix_tree_delete(&nm_i->nat_root, nat_get_nid(e));
210
-	nm_i->nat_cnt--;
236
+	nm_i->nat_cnt[TOTAL_NAT]--;
237
+	nm_i->nat_cnt[RECLAIMABLE_NAT]--;
211238 	__free_nat_entry(e);
212239 }
213240 
....@@ -253,7 +280,8 @@
253280 	if (get_nat_flag(ne, IS_DIRTY))
254281 		goto refresh_list;
255282 
256
-	nm_i->dirty_nat_cnt++;
283
+	nm_i->nat_cnt[DIRTY_NAT]++;
284
+	nm_i->nat_cnt[RECLAIMABLE_NAT]--;
257285 	set_nat_flag(ne, IS_DIRTY, true);
258286 refresh_list:
259287 	spin_lock(&nm_i->nat_list_lock);
....@@ -273,7 +301,8 @@
273301 
274302 	set_nat_flag(ne, IS_DIRTY, false);
275303 	set->entry_cnt--;
276
-	nm_i->dirty_nat_cnt--;
304
+	nm_i->nat_cnt[DIRTY_NAT]--;
305
+	nm_i->nat_cnt[RECLAIMABLE_NAT]++;
277306 }
278307 
279308 static unsigned int __gang_lookup_nat_set(struct f2fs_nm_info *nm_i,
....@@ -355,14 +384,14 @@
355384 	struct nat_entry *e;
356385 	bool need = false;
357386 
358
-	down_read(&nm_i->nat_tree_lock);
387
+	f2fs_down_read(&nm_i->nat_tree_lock);
359388 	e = __lookup_nat_cache(nm_i, nid);
360389 	if (e) {
361390 		if (!get_nat_flag(e, IS_CHECKPOINTED) &&
362391 				!get_nat_flag(e, HAS_FSYNCED_INODE))
363392 			need = true;
364393 	}
365
-	up_read(&nm_i->nat_tree_lock);
394
+	f2fs_up_read(&nm_i->nat_tree_lock);
366395 	return need;
367396 }
368397 
....@@ -372,11 +401,11 @@
372401 	struct nat_entry *e;
373402 	bool is_cp = true;
374403 
375
-	down_read(&nm_i->nat_tree_lock);
404
+	f2fs_down_read(&nm_i->nat_tree_lock);
376405 	e = __lookup_nat_cache(nm_i, nid);
377406 	if (e && !get_nat_flag(e, IS_CHECKPOINTED))
378407 		is_cp = false;
379
-	up_read(&nm_i->nat_tree_lock);
408
+	f2fs_up_read(&nm_i->nat_tree_lock);
380409 	return is_cp;
381410 }
382411 
....@@ -386,13 +415,13 @@
386415 	struct nat_entry *e;
387416 	bool need_update = true;
388417 
389
-	down_read(&nm_i->nat_tree_lock);
418
+	f2fs_down_read(&nm_i->nat_tree_lock);
390419 	e = __lookup_nat_cache(nm_i, ino);
391420 	if (e && get_nat_flag(e, HAS_LAST_FSYNC) &&
392421 			(get_nat_flag(e, IS_CHECKPOINTED) ||
393422 			 get_nat_flag(e, HAS_FSYNCED_INODE)))
394423 		need_update = false;
395
-	up_read(&nm_i->nat_tree_lock);
424
+	f2fs_up_read(&nm_i->nat_tree_lock);
396425 	return need_update;
397426 }
398427 
....@@ -403,11 +432,15 @@
403432 	struct f2fs_nm_info *nm_i = NM_I(sbi);
404433 	struct nat_entry *new, *e;
405434 
435
+	/* Let's mitigate lock contention of nat_tree_lock during checkpoint */
436
+	if (f2fs_rwsem_is_locked(&sbi->cp_global_sem))
437
+		return;
438
+
406439 	new = __alloc_nat_entry(nid, false);
407440 	if (!new)
408441 		return;
409442 
410
-	down_write(&nm_i->nat_tree_lock);
443
+	f2fs_down_write(&nm_i->nat_tree_lock);
411444 	e = __lookup_nat_cache(nm_i, nid);
412445 	if (!e)
413446 		e = __init_nat_entry(nm_i, new, ne, false);
....@@ -416,7 +449,7 @@
416449 				nat_get_blkaddr(e) !=
417450 					le32_to_cpu(ne->block_addr) ||
418451 				nat_get_version(e) != ne->version);
419
-	up_write(&nm_i->nat_tree_lock);
452
+	f2fs_up_write(&nm_i->nat_tree_lock);
420453 	if (e != new)
421454 		__free_nat_entry(new);
422455 }
....@@ -428,7 +461,7 @@
428461 	struct nat_entry *e;
429462 	struct nat_entry *new = __alloc_nat_entry(ni->nid, true);
430463 
431
-	down_write(&nm_i->nat_tree_lock);
464
+	f2fs_down_write(&nm_i->nat_tree_lock);
432465 	e = __lookup_nat_cache(nm_i, ni->nid);
433466 	if (!e) {
434467 		e = __init_nat_entry(nm_i, new, NULL, true);
....@@ -459,6 +492,7 @@
459492 	/* increment version no as node is removed */
460493 	if (nat_get_blkaddr(e) != NEW_ADDR && new_blkaddr == NULL_ADDR) {
461494 		unsigned char version = nat_get_version(e);
495
+
462496 		nat_set_version(e, inc_node_version(version));
463497 	}
464498 
....@@ -476,7 +510,7 @@
476510 			set_nat_flag(e, HAS_FSYNCED_INODE, true);
477511 		set_nat_flag(e, HAS_LAST_FSYNC, fsync_done);
478512 	}
479
-	up_write(&nm_i->nat_tree_lock);
513
+	f2fs_up_write(&nm_i->nat_tree_lock);
480514 }
481515 
482516 int f2fs_try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink)
....@@ -484,7 +518,7 @@
484518 	struct f2fs_nm_info *nm_i = NM_I(sbi);
485519 	int nr = nr_shrink;
486520 
487
-	if (!down_write_trylock(&nm_i->nat_tree_lock))
521
+	if (!f2fs_down_write_trylock(&nm_i->nat_tree_lock))
488522 		return 0;
489523 
490524 	spin_lock(&nm_i->nat_list_lock);
....@@ -506,12 +540,12 @@
506540 	}
507541 	spin_unlock(&nm_i->nat_list_lock);
508542 
509
-	up_write(&nm_i->nat_tree_lock);
543
+	f2fs_up_write(&nm_i->nat_tree_lock);
510544 	return nr - nr_shrink;
511545 }
512546 
513547 int f2fs_get_node_info(struct f2fs_sb_info *sbi, nid_t nid,
514
-						struct node_info *ni)
548
+				struct node_info *ni, bool checkpoint_context)
515549 {
516550 	struct f2fs_nm_info *nm_i = NM_I(sbi);
517551 	struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
....@@ -526,36 +560,46 @@
526560 	int i;
527561 
528562 	ni->nid = nid;
529
-
563
+retry:
530564 	/* Check nat cache */
531
-	down_read(&nm_i->nat_tree_lock);
565
+	f2fs_down_read(&nm_i->nat_tree_lock);
532566 	e = __lookup_nat_cache(nm_i, nid);
533567 	if (e) {
534568 		ni->ino = nat_get_ino(e);
535569 		ni->blk_addr = nat_get_blkaddr(e);
536570 		ni->version = nat_get_version(e);
537
-		up_read(&nm_i->nat_tree_lock);
571
+		f2fs_up_read(&nm_i->nat_tree_lock);
538572 		return 0;
539573 	}
540574 
541
-	memset(&ne, 0, sizeof(struct f2fs_nat_entry));
575
+	/*
576
+	 * Check current segment summary by trying to grab journal_rwsem first.
577
+	 * This sem is on the critical path on the checkpoint requiring the above
578
+	 * nat_tree_lock. Therefore, we should retry, if we failed to grab here
579
+	 * while not bothering checkpoint.
580
+	 */
581
+	if (!f2fs_rwsem_is_locked(&sbi->cp_global_sem) || checkpoint_context) {
582
+		down_read(&curseg->journal_rwsem);
583
+	} else if (f2fs_rwsem_is_contended(&nm_i->nat_tree_lock) ||
584
+				!down_read_trylock(&curseg->journal_rwsem)) {
585
+		f2fs_up_read(&nm_i->nat_tree_lock);
586
+		goto retry;
587
+	}
542588 
543
-	/* Check current segment summary */
544
-	down_read(&curseg->journal_rwsem);
545589 	i = f2fs_lookup_journal_in_cursum(journal, NAT_JOURNAL, nid, 0);
546590 	if (i >= 0) {
547591 		ne = nat_in_journal(journal, i);
548592 		node_info_from_raw_nat(ni, &ne);
549593 	}
550
-	up_read(&curseg->journal_rwsem);
594
+        up_read(&curseg->journal_rwsem);
551595 	if (i >= 0) {
552
-		up_read(&nm_i->nat_tree_lock);
596
+		f2fs_up_read(&nm_i->nat_tree_lock);
553597 		goto cache;
554598 	}
555599 
556600 	/* Fill node_info from nat page */
557601 	index = current_nat_addr(sbi, nid);
558
-	up_read(&nm_i->nat_tree_lock);
602
+	f2fs_up_read(&nm_i->nat_tree_lock);
559603 
560604 	page = f2fs_get_meta_page(sbi, index);
561605 	if (IS_ERR(page))
....@@ -618,8 +662,10 @@
618662 	switch (dn->max_level) {
619663 	case 3:
620664 		base += 2 * indirect_blks;
665
+		fallthrough;
621666 	case 2:
622667 		base += 2 * direct_blks;
668
+		fallthrough;
623669 	case 1:
624670 		base += direct_index;
625671 		break;
....@@ -804,6 +850,26 @@
804850 	dn->ofs_in_node = offset[level];
805851 	dn->node_page = npage[level];
806852 	dn->data_blkaddr = f2fs_data_blkaddr(dn);
853
+
854
+	if (is_inode_flag_set(dn->inode, FI_COMPRESSED_FILE) &&
855
+					f2fs_sb_has_readonly(sbi)) {
856
+		unsigned int c_len = f2fs_cluster_blocks_are_contiguous(dn);
857
+		block_t blkaddr;
858
+
859
+		if (!c_len)
860
+			goto out;
861
+
862
+		blkaddr = f2fs_data_blkaddr(dn);
863
+		if (blkaddr == COMPRESS_ADDR)
864
+			blkaddr = data_blkaddr(dn->inode, dn->node_page,
865
+						dn->ofs_in_node + 1);
866
+
867
+		f2fs_update_read_extent_tree_range_compressed(dn->inode,
868
+					index, blkaddr,
869
+					F2FS_I(dn->inode)->i_cluster_size,
870
+					c_len);
871
+	}
872
+out:
807873 	return 0;
808874 
809875 release_pages:
....@@ -828,7 +894,7 @@
828894 	int err;
829895 	pgoff_t index;
830896 
831
-	err = f2fs_get_node_info(sbi, dn->nid, &ni);
897
+	err = f2fs_get_node_info(sbi, dn->nid, &ni, false);
832898 	if (err)
833899 		return err;
834900 
....@@ -868,7 +934,7 @@
868934 
869935 	/* get direct node */
870936 	page = f2fs_get_node_page(F2FS_I_SB(dn->inode), dn->nid);
871
-	if (IS_ERR(page) && PTR_ERR(page) == -ENOENT)
937
+	if (PTR_ERR(page) == -ENOENT)
872938 		return 1;
873939 	else if (IS_ERR(page))
874940 		return PTR_ERR(page);
....@@ -1039,8 +1105,10 @@
10391105 	trace_f2fs_truncate_inode_blocks_enter(inode, from);
10401106 
10411107 	level = get_node_path(inode, from, offset, noffset);
1042
-	if (level < 0)
1108
+	if (level < 0) {
1109
+		trace_f2fs_truncate_inode_blocks_exit(inode, level);
10431110 		return level;
1111
+	}
10441112 
10451113 	page = f2fs_get_node_page(sbi, inode->i_ino);
10461114 	if (IS_ERR(page)) {
....@@ -1225,12 +1293,16 @@
12251293 		goto fail;
12261294 
12271295 #ifdef CONFIG_F2FS_CHECK_FS
1228
-	err = f2fs_get_node_info(sbi, dn->nid, &new_ni);
1296
+	err = f2fs_get_node_info(sbi, dn->nid, &new_ni, false);
12291297 	if (err) {
12301298 		dec_valid_node_count(sbi, dn->inode, !ofs);
12311299 		goto fail;
12321300 	}
1233
-	f2fs_bug_on(sbi, new_ni.blk_addr != NULL_ADDR);
1301
+	if (unlikely(new_ni.blk_addr != NULL_ADDR)) {
1302
+		err = -EFSCORRUPTED;
1303
+		set_sbi_flag(sbi, SBI_NEED_FSCK);
1304
+		goto fail;
1305
+	}
12341306 #endif
12351307 	new_ni.nid = dn->nid;
12361308 	new_ni.ino = dn->inode->i_ino;
....@@ -1287,12 +1359,12 @@
12871359 		return LOCKED_PAGE;
12881360 	}
12891361 
1290
-	err = f2fs_get_node_info(sbi, page->index, &ni);
1362
+	err = f2fs_get_node_info(sbi, page->index, &ni, false);
12911363 	if (err)
12921364 		return err;
12931365 
1294
-	if (unlikely(ni.blk_addr == NULL_ADDR) ||
1295
-			is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN)) {
1366
+	/* NEW_ADDR can be seen, after cp_error drops some dirty node pages */
1367
+	if (unlikely(ni.blk_addr == NULL_ADDR || ni.blk_addr == NEW_ADDR)) {
12961368 		ClearPageUptodate(page);
12971369 		return -ENOENT;
12981370 	}
....@@ -1320,9 +1392,7 @@
13201392 	if (f2fs_check_nid_range(sbi, nid))
13211393 		return;
13221394 
1323
-	rcu_read_lock();
1324
-	apage = radix_tree_lookup(&NODE_MAPPING(sbi)->i_pages, nid);
1325
-	rcu_read_unlock();
1395
+	apage = xa_load(&NODE_MAPPING(sbi)->i_pages, nid);
13261396 	if (apage)
13271397 		return;
13281398 
....@@ -1378,11 +1448,12 @@
13781448 		goto out_err;
13791449 	}
13801450 page_hit:
1381
-	if(unlikely(nid != nid_of_node(page))) {
1451
+	if (unlikely(nid != nid_of_node(page))) {
13821452 		f2fs_warn(sbi, "inconsistent node block, nid:%lu, node_footer[nid:%u,ino:%u,ofs:%u,cpver:%llu,blkaddr:%u]",
13831453 			  nid, nid_of_node(page), ino_of_node(page),
13841454 			  ofs_of_node(page), cpver_of_node(page),
13851455 			  next_blkaddr_of_node(page));
1456
+		set_sbi_flag(sbi, SBI_NEED_FSCK);
13861457 		err = -EINVAL;
13871458 out_err:
13881459 		ClearPageUptodate(page);
....@@ -1542,21 +1613,21 @@
15421613 	nid = nid_of_node(page);
15431614 	f2fs_bug_on(sbi, page->index != nid);
15441615 
1545
-	if (f2fs_get_node_info(sbi, nid, &ni))
1616
+	if (f2fs_get_node_info(sbi, nid, &ni, !do_balance))
15461617 		goto redirty_out;
15471618 
15481619 	if (wbc->for_reclaim) {
1549
-		if (!down_read_trylock(&sbi->node_write))
1620
+		if (!f2fs_down_read_trylock(&sbi->node_write))
15501621 			goto redirty_out;
15511622 	} else {
1552
-		down_read(&sbi->node_write);
1623
+		f2fs_down_read(&sbi->node_write);
15531624 	}
15541625 
15551626 	/* This page is already truncated */
15561627 	if (unlikely(ni.blk_addr == NULL_ADDR)) {
15571628 		ClearPageUptodate(page);
15581629 		dec_page_count(sbi, F2FS_DIRTY_NODES);
1559
-		up_read(&sbi->node_write);
1630
+		f2fs_up_read(&sbi->node_write);
15601631 		unlock_page(page);
15611632 		return 0;
15621633 	}
....@@ -1564,7 +1635,7 @@
15641635 	if (__is_valid_data_blkaddr(ni.blk_addr) &&
15651636 		!f2fs_is_valid_blkaddr(sbi, ni.blk_addr,
15661637 					DATA_GENERIC_ENHANCE)) {
1567
-		up_read(&sbi->node_write);
1638
+		f2fs_up_read(&sbi->node_write);
15681639 		goto redirty_out;
15691640 	}
15701641 
....@@ -1585,7 +1656,7 @@
15851656 	f2fs_do_write_node_page(nid, &fio);
15861657 	set_node_addr(sbi, &ni, fio.new_blkaddr, is_fsync_dnode(page));
15871658 	dec_page_count(sbi, F2FS_DIRTY_NODES);
1588
-	up_read(&sbi->node_write);
1659
+	f2fs_up_read(&sbi->node_write);
15891660 
15901661 	if (wbc->for_reclaim) {
15911662 		f2fs_submit_merged_write_cond(sbi, NULL, page, 0, NODE);
....@@ -1726,7 +1797,7 @@
17261797 					set_dentry_mark(page,
17271798 						f2fs_need_dentry_mark(sbi, ino));
17281799 				}
1729
-				/*  may be written by other thread */
1800
+				/* may be written by other thread */
17301801 				if (!PageDirty(page))
17311802 					set_page_dirty(page);
17321803 			}
....@@ -1770,7 +1841,7 @@
17701841 out:
17711842 	if (nwritten)
17721843 		f2fs_submit_merged_write_cond(sbi, NULL, NULL, ino, NODE);
1773
-	return ret ? -EIO: 0;
1844
+	return ret ? -EIO : 0;
17741845 }
17751846 
17761847 static int f2fs_match_ino(struct inode *inode, unsigned long ino, void *data)
....@@ -1814,12 +1885,11 @@
18141885 	return true;
18151886 }
18161887 
1817
-int f2fs_flush_inline_data(struct f2fs_sb_info *sbi)
1888
+void f2fs_flush_inline_data(struct f2fs_sb_info *sbi)
18181889 {
18191890 	pgoff_t index = 0;
18201891 	struct pagevec pvec;
18211892 	int nr_pages;
1822
-	int ret = 0;
18231893 
18241894 	pagevec_init(&pvec);
18251895 
....@@ -1847,8 +1917,8 @@
18471917 			}
18481918 
18491919 			/* flush inline_data, if it's async context. */
1850
-			if (is_inline_node(page)) {
1851
-				clear_inline_node(page);
1920
+			if (page_private_inline(page)) {
1921
+				clear_page_private_inline(page);
18521922 				unlock_page(page);
18531923 				flush_inline_data(sbi, ino_of_node(page));
18541924 				continue;
....@@ -1858,7 +1928,6 @@
18581928 		pagevec_release(&pvec);
18591929 		cond_resched();
18601930 	}
1861
-	return ret;
18621931 }
18631932 
18641933 int f2fs_sync_node_pages(struct f2fs_sb_info *sbi,
....@@ -1924,9 +1993,13 @@
19241993 				goto continue_unlock;
19251994 			}
19261995 
1927
-			/* flush inline_data, if it's async context. */
1928
-			if (do_balance && is_inline_node(page)) {
1929
-				clear_inline_node(page);
1996
+			/* flush inline_data/inode, if it's async context. */
1997
+			if (!do_balance)
1998
+				goto write_node;
1999
+
2000
+			/* flush inline_data */
2001
+			if (page_private_inline(page)) {
2002
+				clear_page_private_inline(page);
19302003 				unlock_page(page);
19312004 				flush_inline_data(sbi, ino_of_node(page));
19322005 				goto lock_node;
....@@ -1938,7 +2011,7 @@
19382011 				if (flush_dirty_inode(page))
19392012 					goto lock_node;
19402013 			}
1941
-
2014
+write_node:
19422015 			f2fs_wait_on_page_writeback(page, NODE, true, true);
19432016 
19442017 			if (!clear_page_dirty_for_io(page))
....@@ -2046,8 +2119,12 @@
20462119 
20472120 	if (wbc->sync_mode == WB_SYNC_ALL)
20482121 		atomic_inc(&sbi->wb_sync_req[NODE]);
2049
-	else if (atomic_read(&sbi->wb_sync_req[NODE]))
2122
+	else if (atomic_read(&sbi->wb_sync_req[NODE])) {
2123
+		/* to avoid potential deadlock */
2124
+		if (current->plug)
2125
+			blk_finish_plug(current->plug);
20502126 		goto skip_write;
2127
+	}
20512128 
20522129 	trace_f2fs_writepages(mapping->host, wbc, NODE);
20532130 
....@@ -2080,8 +2157,7 @@
20802157 	if (!PageDirty(page)) {
20812158 		__set_page_dirty_nobuffers(page);
20822159 		inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_NODES);
2083
-		f2fs_set_page_private(page, 0);
2084
-		f2fs_trace_pid(page);
2160
+		set_page_private_reference(page);
20852161 		return 1;
20862162 	}
20872163 	return 0;
....@@ -2097,7 +2173,7 @@
20972173 	.invalidatepage	= f2fs_invalidate_page,
20982174 	.releasepage	= f2fs_release_page,
20992175 #ifdef CONFIG_MIGRATION
2100
-	.migratepage    = f2fs_migrate_page,
2176
+	.migratepage	= f2fs_migrate_page,
21012177 #endif
21022178 };
21032179 
....@@ -2108,18 +2184,16 @@
21082184 }
21092185 
21102186 static int __insert_free_nid(struct f2fs_sb_info *sbi,
2111
-			struct free_nid *i, enum nid_state state)
2187
+				struct free_nid *i)
21122188 {
21132189 	struct f2fs_nm_info *nm_i = NM_I(sbi);
2114
-
21152190 	int err = radix_tree_insert(&nm_i->free_nid_root, i->nid, i);
2191
+
21162192 	if (err)
21172193 		return err;
21182194 
2119
-	f2fs_bug_on(sbi, state != i->state);
2120
-	nm_i->nid_cnt[state]++;
2121
-	if (state == FREE_NID)
2122
-		list_add_tail(&i->list, &nm_i->free_nid_list);
2195
+	nm_i->nid_cnt[FREE_NID]++;
2196
+	list_add_tail(&i->list, &nm_i->free_nid_list);
21232197 	return 0;
21242198 }
21252199 
....@@ -2241,7 +2315,7 @@
22412315 		}
22422316 	}
22432317 	ret = true;
2244
-	err = __insert_free_nid(sbi, i, FREE_NID);
2318
+	err = __insert_free_nid(sbi, i);
22452319 err_out:
22462320 	if (update) {
22472321 		update_free_nid_bitmap(sbi, nid, ret, build);
....@@ -2335,7 +2409,7 @@
23352409 	unsigned int i, idx;
23362410 	nid_t nid;
23372411 
2338
-	down_read(&nm_i->nat_tree_lock);
2412
+	f2fs_down_read(&nm_i->nat_tree_lock);
23392413 
23402414 	for (i = 0; i < nm_i->nat_blocks; i++) {
23412415 		if (!test_bit_le(i, nm_i->nat_block_bitmap))
....@@ -2358,7 +2432,7 @@
23582432 out:
23592433 	scan_curseg_cache(sbi);
23602434 
2361
-	up_read(&nm_i->nat_tree_lock);
2435
+	f2fs_up_read(&nm_i->nat_tree_lock);
23622436 }
23632437 
23642438 static int __f2fs_build_free_nids(struct f2fs_sb_info *sbi,
....@@ -2393,7 +2467,7 @@
23932467 	f2fs_ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nid), FREE_NID_PAGES,
23942468 							META_NAT, true);
23952469 
2396
-	down_read(&nm_i->nat_tree_lock);
2470
+	f2fs_down_read(&nm_i->nat_tree_lock);
23972471 
23982472 	while (1) {
23992473 		if (!test_bit_le(NAT_BLOCK_OFFSET(nid),
....@@ -2408,7 +2482,7 @@
24082482 			}
24092483 
24102484 			if (ret) {
2411
-				up_read(&nm_i->nat_tree_lock);
2485
+				f2fs_up_read(&nm_i->nat_tree_lock);
24122486 				f2fs_err(sbi, "NAT is corrupt, run fsck to fix it");
24132487 				return ret;
24142488 			}
....@@ -2428,7 +2502,7 @@
24282502 	/* find free nids from current sum_pages */
24292503 	scan_curseg_cache(sbi);
24302504 
2431
-	up_read(&nm_i->nat_tree_lock);
2505
+	f2fs_up_read(&nm_i->nat_tree_lock);
24322506 
24332507 	f2fs_ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nm_i->next_scan_nid),
24342508 					nm_i->ra_nid_pages, META_NAT, false);
....@@ -2588,9 +2662,15 @@
25882662 
25892663 	ri = F2FS_INODE(page);
25902664 	if (ri->i_inline & F2FS_INLINE_XATTR) {
2591
-		set_inode_flag(inode, FI_INLINE_XATTR);
2665
+		if (!f2fs_has_inline_xattr(inode)) {
2666
+			set_inode_flag(inode, FI_INLINE_XATTR);
2667
+			stat_inc_inline_xattr(inode);
2668
+		}
25922669 	} else {
2593
-		clear_inode_flag(inode, FI_INLINE_XATTR);
2670
+		if (f2fs_has_inline_xattr(inode)) {
2671
+			stat_dec_inline_xattr(inode);
2672
+			clear_inode_flag(inode, FI_INLINE_XATTR);
2673
+		}
25942674 		goto update_inode;
25952675 	}
25962676 
....@@ -2620,7 +2700,7 @@
26202700 		goto recover_xnid;
26212701 
26222702 	/* 1: invalidate the previous xattr nid */
2623
-	err = f2fs_get_node_info(sbi, prev_xnid, &ni);
2703
+	err = f2fs_get_node_info(sbi, prev_xnid, &ni, false);
26242704 	if (err)
26252705 		return err;
26262706 
....@@ -2660,7 +2740,7 @@
26602740 	struct page *ipage;
26612741 	int err;
26622742 
2663
-	err = f2fs_get_node_info(sbi, ino, &old_ni);
2743
+	err = f2fs_get_node_info(sbi, ino, &old_ni, false);
26642744 	if (err)
26652745 		return err;
26662746 
....@@ -2684,7 +2764,7 @@
26842764 	src = F2FS_INODE(page);
26852765 	dst = F2FS_INODE(ipage);
26862766 
2687
-	memcpy(dst, src, (unsigned long)&src->i_ext - (unsigned long)src);
2767
+	memcpy(dst, src, offsetof(struct f2fs_inode, i_ext));
26882768 	dst->i_size = 0;
26892769 	dst->i_blocks = cpu_to_le64(1);
26902770 	dst->i_links = cpu_to_le32(1);
....@@ -2945,17 +3025,20 @@
29453025 	LIST_HEAD(sets);
29463026 	int err = 0;
29473027 
2948
-	/* during unmount, let's flush nat_bits before checking dirty_nat_cnt */
3028
+	/*
3029
+	 * during unmount, let's flush nat_bits before checking
3030
+	 * nat_cnt[DIRTY_NAT].
3031
+	 */
29493032 	if (enabled_nat_bits(sbi, cpc)) {
2950
-		down_write(&nm_i->nat_tree_lock);
3033
+		f2fs_down_write(&nm_i->nat_tree_lock);
29513034 		remove_nats_in_journal(sbi);
2952
-		up_write(&nm_i->nat_tree_lock);
3035
+		f2fs_up_write(&nm_i->nat_tree_lock);
29533036 	}
29543037 
2955
-	if (!nm_i->dirty_nat_cnt)
3038
+	if (!nm_i->nat_cnt[DIRTY_NAT])
29563039 		return 0;
29573040 
2958
-	down_write(&nm_i->nat_tree_lock);
3041
+	f2fs_down_write(&nm_i->nat_tree_lock);
29593042 
29603043 	/*
29613044 	 * if there are no enough space in journal to store dirty nat
....@@ -2963,12 +3046,14 @@
29633046 	 * into nat entry set.
29643047 	 */
29653048 	if (enabled_nat_bits(sbi, cpc) ||
2966
-		!__has_cursum_space(journal, nm_i->dirty_nat_cnt, NAT_JOURNAL))
3049
+		!__has_cursum_space(journal,
3050
+			nm_i->nat_cnt[DIRTY_NAT], NAT_JOURNAL))
29673051 		remove_nats_in_journal(sbi);
29683052 
29693053 	while ((found = __gang_lookup_nat_set(nm_i,
29703054 					set_idx, SETVEC_SIZE, setvec))) {
29713055 		unsigned idx;
3056
+
29723057 		set_idx = setvec[found - 1]->set + 1;
29733058 		for (idx = 0; idx < found; idx++)
29743059 			__adjust_nat_entry_set(setvec[idx], &sets,
....@@ -2982,7 +3067,7 @@
29823067 			break;
29833068 	}
29843069 
2985
-	up_write(&nm_i->nat_tree_lock);
3070
+	f2fs_up_write(&nm_i->nat_tree_lock);
29863071 	/* Allow dirty nats by node block allocation in write_begin */
29873072 
29883073 	return err;
....@@ -3087,7 +3172,6 @@
30873172 						F2FS_RESERVED_NODE_NUM;
30883173 	nm_i->nid_cnt[FREE_NID] = 0;
30893174 	nm_i->nid_cnt[PREALLOC_NID] = 0;
3090
-	nm_i->nat_cnt = 0;
30913175 	nm_i->ram_thresh = DEF_RAM_THRESHOLD;
30923176 	nm_i->ra_nid_pages = DEF_RA_NID_PAGES;
30933177 	nm_i->dirty_nats_ratio = DEF_DIRTY_NAT_RATIO_THRESHOLD;
....@@ -3101,14 +3185,11 @@
31013185 
31023186 	mutex_init(&nm_i->build_lock);
31033187 	spin_lock_init(&nm_i->nid_list_lock);
3104
-	init_rwsem(&nm_i->nat_tree_lock);
3188
+	init_f2fs_rwsem(&nm_i->nat_tree_lock);
31053189 
31063190 	nm_i->next_scan_nid = le32_to_cpu(sbi->ckpt->next_free_nid);
31073191 	nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP);
31083192 	version_bitmap = __bitmap_ptr(sbi, NAT_BITMAP);
3109
-	if (!version_bitmap)
3110
-		return -EFAULT;
3111
-
31123193 	nm_i->nat_bitmap = kmemdup(version_bitmap, nm_i->bitmap_size,
31133194 					GFP_KERNEL);
31143195 	if (!nm_i->nat_bitmap)
....@@ -3210,7 +3291,7 @@
32103291 	spin_unlock(&nm_i->nid_list_lock);
32113292 
32123293 	/* destroy nat cache */
3213
-	down_write(&nm_i->nat_tree_lock);
3294
+	f2fs_down_write(&nm_i->nat_tree_lock);
32143295 	while ((found = __gang_lookup_nat_cache(nm_i,
32153296 					nid, NATVEC_SIZE, natvec))) {
32163297 		unsigned idx;
....@@ -3224,7 +3305,7 @@
32243305 			__del_from_nat_cache(nm_i, natvec[idx]);
32253306 		}
32263307 	}
3227
-	f2fs_bug_on(sbi, nm_i->nat_cnt);
3308
+	f2fs_bug_on(sbi, nm_i->nat_cnt[TOTAL_NAT]);
32283309 
32293310 	/* destroy nat set cache */
32303311 	nid = 0;
....@@ -3240,7 +3321,7 @@
32403321 			kmem_cache_free(nat_entry_set_slab, setvec[idx]);
32413322 		}
32423323 	}
3243
-	up_write(&nm_i->nat_tree_lock);
3324
+	f2fs_up_write(&nm_i->nat_tree_lock);
32443325 
32453326 	kvfree(nm_i->nat_block_bitmap);
32463327 	if (nm_i->free_nid_bitmap) {
....@@ -3258,7 +3339,7 @@
32583339 	kvfree(nm_i->nat_bitmap_mir);
32593340 #endif
32603341 	sbi->nm_info = NULL;
3261
-	kvfree(nm_i);
3342
+	kfree(nm_i);
32623343 }
32633344 
32643345 int __init f2fs_create_node_manager_caches(void)