~hc/RK356X_SDK_RELEASE.git

..	..	@@ -6,6 +6,10 @@
6	6	* Copyright (c) 2015 Samsung Electronics
7	7	* Authors: Jaegeuk Kim <jaegeuk@kernel.org>
8	8	* Chao Yu <chao2.yu@samsung.com>
	9	+ *
	10	+ * block_age-based extent cache added by:
	11	+ * Copyright (c) 2022 xiaomi Co., Ltd.
	12	+ * http://www.xiaomi.com/
9	13	*/
10	14
11	15	#include <linux/fs.h>
..	..	@@ -14,6 +18,123 @@
14	18	#include "f2fs.h"
15	19	#include "node.h"
16	20	#include <trace/events/f2fs.h>
	21	+
	22	+static void __set_extent_info(struct extent_info *ei,
	23	+ unsigned int fofs, unsigned int len,
	24	+ block_t blk, bool keep_clen,
	25	+ unsigned long age, unsigned long last_blocks,
	26	+ enum extent_type type)
	27	+{
	28	+ ei->fofs = fofs;
	29	+ ei->len = len;
	30	+
	31	+ if (type == EX_READ) {
	32	+ ei->blk = blk;
	33	+ if (keep_clen)
	34	+ return;
	35	+#ifdef CONFIG_F2FS_FS_COMPRESSION
	36	+ ei->c_len = 0;
	37	+#endif
	38	+ } else if (type == EX_BLOCK_AGE) {
	39	+ ei->age = age;
	40	+ ei->last_blocks = last_blocks;
	41	+ }
	42	+}
	43	+
	44	+static bool __may_read_extent_tree(struct inode *inode)
	45	+{
	46	+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	47	+
	48	+ if (!test_opt(sbi, READ_EXTENT_CACHE))
	49	+ return false;
	50	+ if (is_inode_flag_set(inode, FI_NO_EXTENT))
	51	+ return false;
	52	+ if (is_inode_flag_set(inode, FI_COMPRESSED_FILE) &&
	53	+ !f2fs_sb_has_readonly(sbi))
	54	+ return false;
	55	+ return S_ISREG(inode->i_mode);
	56	+}
	57	+
	58	+static bool __may_age_extent_tree(struct inode *inode)
	59	+{
	60	+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	61	+
	62	+ if (!test_opt(sbi, AGE_EXTENT_CACHE))
	63	+ return false;
	64	+ /* don't cache block age info for cold file */
	65	+ if (is_inode_flag_set(inode, FI_COMPRESSED_FILE))
	66	+ return false;
	67	+ if (file_is_cold(inode))
	68	+ return false;
	69	+
	70	+ return S_ISREG(inode->i_mode) \|\| S_ISDIR(inode->i_mode);
	71	+}
	72	+
	73	+static bool __init_may_extent_tree(struct inode *inode, enum extent_type type)
	74	+{
	75	+ if (type == EX_READ)
	76	+ return __may_read_extent_tree(inode);
	77	+ else if (type == EX_BLOCK_AGE)
	78	+ return __may_age_extent_tree(inode);
	79	+ return false;
	80	+}
	81	+
	82	+static bool __may_extent_tree(struct inode *inode, enum extent_type type)
	83	+{
	84	+ /*
	85	+ * for recovered files during mount do not create extents
	86	+ * if shrinker is not registered.
	87	+ */
	88	+ if (list_empty(&F2FS_I_SB(inode)->s_list))
	89	+ return false;
	90	+
	91	+ return __init_may_extent_tree(inode, type);
	92	+}
	93	+
	94	+static void __try_update_largest_extent(struct extent_tree *et,
	95	+ struct extent_node *en)
	96	+{
	97	+ if (et->type != EX_READ)
	98	+ return;
	99	+ if (en->ei.len <= et->largest.len)
	100	+ return;
	101	+
	102	+ et->largest = en->ei;
	103	+ et->largest_updated = true;
	104	+}
	105	+
	106	+static bool __is_extent_mergeable(struct extent_info *back,
	107	+ struct extent_info *front, enum extent_type type)
	108	+{
	109	+ if (type == EX_READ) {
	110	+#ifdef CONFIG_F2FS_FS_COMPRESSION
	111	+ if (back->c_len && back->len != back->c_len)
	112	+ return false;
	113	+ if (front->c_len && front->len != front->c_len)
	114	+ return false;
	115	+#endif
	116	+ return (back->fofs + back->len == front->fofs &&
	117	+ back->blk + back->len == front->blk);
	118	+ } else if (type == EX_BLOCK_AGE) {
	119	+ return (back->fofs + back->len == front->fofs &&
	120	+ abs(back->age - front->age) <= SAME_AGE_REGION &&
	121	+ abs(back->last_blocks - front->last_blocks) <=
	122	+ SAME_AGE_REGION);
	123	+ }
	124	+ return false;
	125	+}
	126	+
	127	+static bool __is_back_mergeable(struct extent_info *cur,
	128	+ struct extent_info *back, enum extent_type type)
	129	+{
	130	+ return __is_extent_mergeable(back, cur, type);
	131	+}
	132	+
	133	+static bool __is_front_mergeable(struct extent_info *cur,
	134	+ struct extent_info *front, enum extent_type type)
	135	+{
	136	+ return __is_extent_mergeable(cur, front, type);
	137	+}
17	138
18	139	static struct rb_entry __lookup_rb_tree_fast(struct rb_entry cached_re,
19	140	unsigned int ofs)
..	..	@@ -56,6 +177,29 @@
56	177	return __lookup_rb_tree_slow(root, ofs);
57	178
58	179	return re;
	180	+}
	181	+
	182	+struct rb_node *f2fs_lookup_rb_tree_ext(struct f2fs_sb_info sbi,
	183	+ struct rb_root_cached *root,
	184	+ struct rb_node **parent,
	185	+ unsigned long long key, bool *leftmost)
	186	+{
	187	+ struct rb_node **p = &root->rb_root.rb_node;
	188	+ struct rb_entry *re;
	189	+
	190	+ while (*p) {
	191	+ parent = p;
	192	+ re = rb_entry(*parent, struct rb_entry, rb_node);
	193	+
	194	+ if (key < re->key) {
	195	+ p = &(*p)->rb_left;
	196	+ } else {
	197	+ p = &(*p)->rb_right;
	198	+ *leftmost = false;
	199	+ }
	200	+ }
	201	+
	202	+ return p;
59	203	}
60	204
61	205	struct rb_node *f2fs_lookup_rb_tree_for_insert(struct f2fs_sb_info sbi,
..	..	@@ -166,7 +310,7 @@
166	310	}
167	311
168	312	bool f2fs_check_rb_tree_consistence(struct f2fs_sb_info *sbi,
169		- struct rb_root_cached *root)
	313	+ struct rb_root_cached *root, bool check_key)
170	314	{
171	315	#ifdef CONFIG_F2FS_CHECK_FS
172	316	struct rb_node cur = rb_first_cached(root), next;
..	..	@@ -183,13 +327,23 @@
183	327	cur_re = rb_entry(cur, struct rb_entry, rb_node);
184	328	next_re = rb_entry(next, struct rb_entry, rb_node);
185	329
	330	+ if (check_key) {
	331	+ if (cur_re->key > next_re->key) {
	332	+ f2fs_info(sbi, "inconsistent rbtree, "
	333	+ "cur(%llu) next(%llu)",
	334	+ cur_re->key, next_re->key);
	335	+ return false;
	336	+ }
	337	+ goto next;
	338	+ }
	339	+
186	340	if (cur_re->ofs + cur_re->len > next_re->ofs) {
187	341	f2fs_info(sbi, "inconsistent rbtree, cur(%u, %u) next(%u, %u)",
188	342	cur_re->ofs, cur_re->len,
189	343	next_re->ofs, next_re->len);
190	344	return false;
191	345	}
192		-
	346	+next:
193	347	cur = next;
194	348	}
195	349	#endif
..	..	@@ -204,6 +358,7 @@
204	358	struct rb_node parent, struct rb_node *p,
205	359	bool leftmost)
206	360	{
	361	+ struct extent_tree_info *eti = &sbi->extent_tree[et->type];
207	362	struct extent_node *en;
208	363
209	364	en = kmem_cache_alloc(extent_node_slab, GFP_ATOMIC);
..	..	@@ -217,16 +372,18 @@
217	372	rb_link_node(&en->rb_node, parent, p);
218	373	rb_insert_color_cached(&en->rb_node, &et->root, leftmost);
219	374	atomic_inc(&et->node_cnt);
220		- atomic_inc(&sbi->total_ext_node);
	375	+ atomic_inc(&eti->total_ext_node);
221	376	return en;
222	377	}
223	378
224	379	static void __detach_extent_node(struct f2fs_sb_info *sbi,
225	380	struct extent_tree et, struct extent_node en)
226	381	{
	382	+ struct extent_tree_info *eti = &sbi->extent_tree[et->type];
	383	+
227	384	rb_erase_cached(&en->rb_node, &et->root);
228	385	atomic_dec(&et->node_cnt);
229		- atomic_dec(&sbi->total_ext_node);
	386	+ atomic_dec(&eti->total_ext_node);
230	387
231	388	if (et->cached_en == en)
232	389	et->cached_en = NULL;
..	..	@@ -242,58 +399,48 @@
242	399	static void __release_extent_node(struct f2fs_sb_info *sbi,
243	400	struct extent_tree et, struct extent_node en)
244	401	{
245		- spin_lock(&sbi->extent_lock);
	402	+ struct extent_tree_info *eti = &sbi->extent_tree[et->type];
	403	+
	404	+ spin_lock(&eti->extent_lock);
246	405	f2fs_bug_on(sbi, list_empty(&en->list));
247	406	list_del_init(&en->list);
248		- spin_unlock(&sbi->extent_lock);
	407	+ spin_unlock(&eti->extent_lock);
249	408
250	409	__detach_extent_node(sbi, et, en);
251	410	}
252	411
253		-static struct extent_tree __grab_extent_tree(struct inode inode)
	412	+static struct extent_tree __grab_extent_tree(struct inode inode,
	413	+ enum extent_type type)
254	414	{
255	415	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	416	+ struct extent_tree_info *eti = &sbi->extent_tree[type];
256	417	struct extent_tree *et;
257	418	nid_t ino = inode->i_ino;
258	419
259		- mutex_lock(&sbi->extent_tree_lock);
260		- et = radix_tree_lookup(&sbi->extent_tree_root, ino);
	420	+ mutex_lock(&eti->extent_tree_lock);
	421	+ et = radix_tree_lookup(&eti->extent_tree_root, ino);
261	422	if (!et) {
262	423	et = f2fs_kmem_cache_alloc(extent_tree_slab, GFP_NOFS);
263		- f2fs_radix_tree_insert(&sbi->extent_tree_root, ino, et);
	424	+ f2fs_radix_tree_insert(&eti->extent_tree_root, ino, et);
264	425	memset(et, 0, sizeof(struct extent_tree));
265	426	et->ino = ino;
	427	+ et->type = type;
266	428	et->root = RB_ROOT_CACHED;
267	429	et->cached_en = NULL;
268	430	rwlock_init(&et->lock);
269	431	INIT_LIST_HEAD(&et->list);
270	432	atomic_set(&et->node_cnt, 0);
271		- atomic_inc(&sbi->total_ext_tree);
	433	+ atomic_inc(&eti->total_ext_tree);
272	434	} else {
273		- atomic_dec(&sbi->total_zombie_tree);
	435	+ atomic_dec(&eti->total_zombie_tree);
274	436	list_del_init(&et->list);
275	437	}
276		- mutex_unlock(&sbi->extent_tree_lock);
	438	+ mutex_unlock(&eti->extent_tree_lock);
277	439
278	440	/* never died until evict_inode */
279		- F2FS_I(inode)->extent_tree = et;
	441	+ F2FS_I(inode)->extent_tree[type] = et;
280	442
281	443	return et;
282		-}
283		-
284		-static struct extent_node __init_extent_tree(struct f2fs_sb_info sbi,
285		- struct extent_tree et, struct extent_info ei)
286		-{
287		- struct rb_node **p = &et->root.rb_root.rb_node;
288		- struct extent_node *en;
289		-
290		- en = __attach_extent_node(sbi, et, ei, NULL, p, true);
291		- if (!en)
292		- return NULL;
293		-
294		- et->largest = en->ei;
295		- et->cached_en = en;
296		- return en;
297	444	}
298	445
299	446	static unsigned int __free_extent_tree(struct f2fs_sb_info *sbi,
..	..	@@ -324,73 +471,89 @@
324	471	}
325	472	}
326	473
327		-/* return true, if inode page is changed */
328		-static bool __f2fs_init_extent_tree(struct inode inode, struct f2fs_extent i_ext)
	474	+void f2fs_init_read_extent_tree(struct inode inode, struct page ipage)
329	475	{
330	476	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	477	+ struct extent_tree_info *eti = &sbi->extent_tree[EX_READ];
	478	+ struct f2fs_extent *i_ext = &F2FS_INODE(ipage)->i_ext;
331	479	struct extent_tree *et;
332	480	struct extent_node *en;
333	481	struct extent_info ei;
334	482
335		- if (!f2fs_may_extent_tree(inode)) {
336		- /* drop largest extent */
	483	+ if (!__may_extent_tree(inode, EX_READ)) {
	484	+ /* drop largest read extent */
337	485	if (i_ext && i_ext->len) {
	486	+ f2fs_wait_on_page_writeback(ipage, NODE, true, true);
338	487	i_ext->len = 0;
339		- return true;
	488	+ set_page_dirty(ipage);
340	489	}
341		- return false;
	490	+ goto out;
342	491	}
343	492
344		- et = __grab_extent_tree(inode);
	493	+ et = __grab_extent_tree(inode, EX_READ);
345	494
346	495	if (!i_ext \|\| !i_ext->len)
347		- return false;
	496	+ goto out;
348	497
349		- get_extent_info(&ei, i_ext);
	498	+ get_read_extent_info(&ei, i_ext);
350	499
351	500	write_lock(&et->lock);
352	501	if (atomic_read(&et->node_cnt))
353		- goto out;
	502	+ goto unlock_out;
354	503
355		- en = __init_extent_tree(sbi, et, &ei);
	504	+ en = __attach_extent_node(sbi, et, &ei, NULL,
	505	+ &et->root.rb_root.rb_node, true);
356	506	if (en) {
357		- spin_lock(&sbi->extent_lock);
358		- list_add_tail(&en->list, &sbi->extent_list);
359		- spin_unlock(&sbi->extent_lock);
	507	+ et->largest = en->ei;
	508	+ et->cached_en = en;
	509	+
	510	+ spin_lock(&eti->extent_lock);
	511	+ list_add_tail(&en->list, &eti->extent_list);
	512	+ spin_unlock(&eti->extent_lock);
360	513	}
361		-out:
	514	+unlock_out:
362	515	write_unlock(&et->lock);
363		- return false;
364		-}
365		-
366		-bool f2fs_init_extent_tree(struct inode inode, struct f2fs_extent i_ext)
367		-{
368		- bool ret = __f2fs_init_extent_tree(inode, i_ext);
369		-
370		- if (!F2FS_I(inode)->extent_tree)
	516	+out:
	517	+ if (!F2FS_I(inode)->extent_tree[EX_READ])
371	518	set_inode_flag(inode, FI_NO_EXTENT);
372		-
373		- return ret;
374	519	}
375	520
376		-static bool f2fs_lookup_extent_tree(struct inode *inode, pgoff_t pgofs,
377		- struct extent_info *ei)
	521	+void f2fs_init_age_extent_tree(struct inode *inode)
	522	+{
	523	+ if (!__init_may_extent_tree(inode, EX_BLOCK_AGE))
	524	+ return;
	525	+ __grab_extent_tree(inode, EX_BLOCK_AGE);
	526	+}
	527	+
	528	+void f2fs_init_extent_tree(struct inode *inode)
	529	+{
	530	+ /* initialize read cache */
	531	+ if (__init_may_extent_tree(inode, EX_READ))
	532	+ __grab_extent_tree(inode, EX_READ);
	533	+
	534	+ /* initialize block age cache */
	535	+ if (__init_may_extent_tree(inode, EX_BLOCK_AGE))
	536	+ __grab_extent_tree(inode, EX_BLOCK_AGE);
	537	+}
	538	+
	539	+static bool __lookup_extent_tree(struct inode *inode, pgoff_t pgofs,
	540	+ struct extent_info *ei, enum extent_type type)
378	541	{
379	542	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
380		- struct extent_tree *et = F2FS_I(inode)->extent_tree;
	543	+ struct extent_tree_info *eti = &sbi->extent_tree[type];
	544	+ struct extent_tree *et = F2FS_I(inode)->extent_tree[type];
381	545	struct extent_node *en;
382	546	bool ret = false;
383	547
384		- f2fs_bug_on(sbi, !et);
385		-
386	548	if (!et)
387		- return ret;
	549	+ return false;
388	550
389		- trace_f2fs_lookup_extent_tree_start(inode, pgofs);
	551	+ trace_f2fs_lookup_extent_tree_start(inode, pgofs, type);
390	552
391	553	read_lock(&et->lock);
392	554
393		- if (et->largest.fofs <= pgofs &&
	555	+ if (type == EX_READ &&
	556	+ et->largest.fofs <= pgofs &&
394	557	et->largest.fofs + et->largest.len > pgofs) {
395	558	*ei = et->largest;
396	559	ret = true;
..	..	@@ -404,23 +567,26 @@
404	567	goto out;
405	568
406	569	if (en == et->cached_en)
407		- stat_inc_cached_node_hit(sbi);
	570	+ stat_inc_cached_node_hit(sbi, type);
408	571	else
409		- stat_inc_rbtree_node_hit(sbi);
	572	+ stat_inc_rbtree_node_hit(sbi, type);
410	573
411	574	*ei = en->ei;
412		- spin_lock(&sbi->extent_lock);
	575	+ spin_lock(&eti->extent_lock);
413	576	if (!list_empty(&en->list)) {
414		- list_move_tail(&en->list, &sbi->extent_list);
	577	+ list_move_tail(&en->list, &eti->extent_list);
415	578	et->cached_en = en;
416	579	}
417		- spin_unlock(&sbi->extent_lock);
	580	+ spin_unlock(&eti->extent_lock);
418	581	ret = true;
419	582	out:
420		- stat_inc_total_hit(sbi);
	583	+ stat_inc_total_hit(sbi, type);
421	584	read_unlock(&et->lock);
422	585
423		- trace_f2fs_lookup_extent_tree_end(inode, pgofs, ei);
	586	+ if (type == EX_READ)
	587	+ trace_f2fs_lookup_read_extent_tree_end(inode, pgofs, ei);
	588	+ else if (type == EX_BLOCK_AGE)
	589	+ trace_f2fs_lookup_age_extent_tree_end(inode, pgofs, ei);
424	590	return ret;
425	591	}
426	592
..	..	@@ -429,18 +595,20 @@
429	595	struct extent_node *prev_ex,
430	596	struct extent_node *next_ex)
431	597	{
	598	+ struct extent_tree_info *eti = &sbi->extent_tree[et->type];
432	599	struct extent_node *en = NULL;
433	600
434		- if (prev_ex && __is_back_mergeable(ei, &prev_ex->ei)) {
	601	+ if (prev_ex && __is_back_mergeable(ei, &prev_ex->ei, et->type)) {
435	602	prev_ex->ei.len += ei->len;
436	603	ei = &prev_ex->ei;
437	604	en = prev_ex;
438	605	}
439	606
440		- if (next_ex && __is_front_mergeable(ei, &next_ex->ei)) {
	607	+ if (next_ex && __is_front_mergeable(ei, &next_ex->ei, et->type)) {
441	608	next_ex->ei.fofs = ei->fofs;
442		- next_ex->ei.blk = ei->blk;
443	609	next_ex->ei.len += ei->len;
	610	+ if (et->type == EX_READ)
	611	+ next_ex->ei.blk = ei->blk;
444	612	if (en)
445	613	__release_extent_node(sbi, et, prev_ex);
446	614
..	..	@@ -452,12 +620,12 @@
452	620
453	621	__try_update_largest_extent(et, en);
454	622
455		- spin_lock(&sbi->extent_lock);
	623	+ spin_lock(&eti->extent_lock);
456	624	if (!list_empty(&en->list)) {
457		- list_move_tail(&en->list, &sbi->extent_list);
	625	+ list_move_tail(&en->list, &eti->extent_list);
458	626	et->cached_en = en;
459	627	}
460		- spin_unlock(&sbi->extent_lock);
	628	+ spin_unlock(&eti->extent_lock);
461	629	return en;
462	630	}
463	631
..	..	@@ -467,6 +635,7 @@
467	635	struct rb_node *insert_parent,
468	636	bool leftmost)
469	637	{
	638	+ struct extent_tree_info *eti = &sbi->extent_tree[et->type];
470	639	struct rb_node **p;
471	640	struct rb_node *parent = NULL;
472	641	struct extent_node *en = NULL;
..	..	@@ -489,47 +658,54 @@
489	658	__try_update_largest_extent(et, en);
490	659
491	660	/* update in global extent list */
492		- spin_lock(&sbi->extent_lock);
493		- list_add_tail(&en->list, &sbi->extent_list);
	661	+ spin_lock(&eti->extent_lock);
	662	+ list_add_tail(&en->list, &eti->extent_list);
494	663	et->cached_en = en;
495		- spin_unlock(&sbi->extent_lock);
	664	+ spin_unlock(&eti->extent_lock);
496	665	return en;
497	666	}
498	667
499		-static void f2fs_update_extent_tree_range(struct inode *inode,
500		- pgoff_t fofs, block_t blkaddr, unsigned int len)
	668	+static void __update_extent_tree_range(struct inode *inode,
	669	+ struct extent_info *tei, enum extent_type type)
501	670	{
502	671	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
503		- struct extent_tree *et = F2FS_I(inode)->extent_tree;
	672	+ struct extent_tree *et = F2FS_I(inode)->extent_tree[type];
504	673	struct extent_node en = NULL, en1 = NULL;
505	674	struct extent_node prev_en = NULL, next_en = NULL;
506	675	struct extent_info ei, dei, prev;
507	676	struct rb_node *insert_p = NULL, insert_parent = NULL;
	677	+ unsigned int fofs = tei->fofs, len = tei->len;
508	678	unsigned int end = fofs + len;
509		- unsigned int pos = (unsigned int)fofs;
510	679	bool updated = false;
511	680	bool leftmost = false;
512	681
513	682	if (!et)
514	683	return;
515	684
516		- trace_f2fs_update_extent_tree_range(inode, fofs, blkaddr, len);
	685	+ if (type == EX_READ)
	686	+ trace_f2fs_update_read_extent_tree_range(inode, fofs, len,
	687	+ tei->blk, 0);
	688	+ else if (type == EX_BLOCK_AGE)
	689	+ trace_f2fs_update_age_extent_tree_range(inode, fofs, len,
	690	+ tei->age, tei->last_blocks);
517	691
518	692	write_lock(&et->lock);
519	693
520		- if (is_inode_flag_set(inode, FI_NO_EXTENT)) {
521		- write_unlock(&et->lock);
522		- return;
	694	+ if (type == EX_READ) {
	695	+ if (is_inode_flag_set(inode, FI_NO_EXTENT)) {
	696	+ write_unlock(&et->lock);
	697	+ return;
	698	+ }
	699	+
	700	+ prev = et->largest;
	701	+ dei.len = 0;
	702	+
	703	+ /*
	704	+ * drop largest extent before lookup, in case it's already
	705	+ * been shrunk from extent tree
	706	+ */
	707	+ __drop_largest_extent(et, fofs, len);
523	708	}
524		-
525		- prev = et->largest;
526		- dei.len = 0;
527		-
528		- /*
529		- * drop largest extent before lookup, in case it's already
530		- * been shrunk from extent tree
531		- */
532		- __drop_largest_extent(et, fofs, len);
533	709
534	710	/* 1. lookup first extent node in range [fofs, fofs + len - 1] */
535	711	en = (struct extent_node *)f2fs_lookup_rb_tree_ret(&et->root,
..	..	@@ -550,26 +726,32 @@
550	726
551	727	dei = en->ei;
552	728	org_end = dei.fofs + dei.len;
553		- f2fs_bug_on(sbi, pos >= org_end);
	729	+ f2fs_bug_on(sbi, fofs >= org_end);
554	730
555		- if (pos > dei.fofs && pos - dei.fofs >= F2FS_MIN_EXTENT_LEN) {
556		- en->ei.len = pos - en->ei.fofs;
	731	+ if (fofs > dei.fofs && (type != EX_READ \|\|
	732	+ fofs - dei.fofs >= F2FS_MIN_EXTENT_LEN)) {
	733	+ en->ei.len = fofs - en->ei.fofs;
557	734	prev_en = en;
558	735	parts = 1;
559	736	}
560	737
561		- if (end < org_end && org_end - end >= F2FS_MIN_EXTENT_LEN) {
	738	+ if (end < org_end && (type != EX_READ \|\|
	739	+ org_end - end >= F2FS_MIN_EXTENT_LEN)) {
562	740	if (parts) {
563		- set_extent_info(&ei, end,
564		- end - dei.fofs + dei.blk,
565		- org_end - end);
	741	+ __set_extent_info(&ei,
	742	+ end, org_end - end,
	743	+ end - dei.fofs + dei.blk, false,
	744	+ dei.age, dei.last_blocks,
	745	+ type);
566	746	en1 = __insert_extent_tree(sbi, et, &ei,
567	747	NULL, NULL, true);
568	748	next_en = en1;
569	749	} else {
570		- en->ei.fofs = end;
571		- en->ei.blk += end - dei.fofs;
572		- en->ei.len -= end - dei.fofs;
	750	+ __set_extent_info(&en->ei,
	751	+ end, en->ei.len - (end - dei.fofs),
	752	+ en->ei.blk + (end - dei.fofs), true,
	753	+ dei.age, dei.last_blocks,
	754	+ type);
573	755	next_en = en;
574	756	}
575	757	parts++;
..	..	@@ -599,10 +781,15 @@
599	781	en = next_en;
600	782	}
601	783
602		- /* 3. update extent in extent cache */
603		- if (blkaddr) {
	784	+ if (type == EX_BLOCK_AGE)
	785	+ goto update_age_extent_cache;
604	786
605		- set_extent_info(&ei, fofs, blkaddr, len);
	787	+ /* 3. update extent in read extent cache */
	788	+ BUG_ON(type != EX_READ);
	789	+
	790	+ if (tei->blk) {
	791	+ __set_extent_info(&ei, fofs, len, tei->blk, false,
	792	+ 0, 0, EX_READ);
606	793	if (!__try_merge_extent_node(sbi, et, &ei, prev_en, next_en))
607	794	__insert_extent_tree(sbi, et, &ei,
608	795	insert_p, insert_parent, leftmost);
..	..	@@ -624,31 +811,182 @@
624	811	et->largest_updated = false;
625	812	updated = true;
626	813	}
	814	+ goto out_read_extent_cache;
	815	+update_age_extent_cache:
	816	+ if (!tei->last_blocks)
	817	+ goto out_read_extent_cache;
627	818
	819	+ __set_extent_info(&ei, fofs, len, 0, false,
	820	+ tei->age, tei->last_blocks, EX_BLOCK_AGE);
	821	+ if (!__try_merge_extent_node(sbi, et, &ei, prev_en, next_en))
	822	+ __insert_extent_tree(sbi, et, &ei,
	823	+ insert_p, insert_parent, leftmost);
	824	+out_read_extent_cache:
628	825	write_unlock(&et->lock);
629	826
630	827	if (updated)
631	828	f2fs_mark_inode_dirty_sync(inode, true);
632	829	}
633	830
634		-unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink)
	831	+#ifdef CONFIG_F2FS_FS_COMPRESSION
	832	+void f2fs_update_read_extent_tree_range_compressed(struct inode *inode,
	833	+ pgoff_t fofs, block_t blkaddr, unsigned int llen,
	834	+ unsigned int c_len)
635	835	{
	836	+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	837	+ struct extent_tree *et = F2FS_I(inode)->extent_tree[EX_READ];
	838	+ struct extent_node *en = NULL;
	839	+ struct extent_node prev_en = NULL, next_en = NULL;
	840	+ struct extent_info ei;
	841	+ struct rb_node *insert_p = NULL, insert_parent = NULL;
	842	+ bool leftmost = false;
	843	+
	844	+ trace_f2fs_update_read_extent_tree_range(inode, fofs, llen,
	845	+ blkaddr, c_len);
	846	+
	847	+ /* it is safe here to check FI_NO_EXTENT w/o et->lock in ro image */
	848	+ if (is_inode_flag_set(inode, FI_NO_EXTENT))
	849	+ return;
	850	+
	851	+ write_lock(&et->lock);
	852	+
	853	+ en = (struct extent_node *)f2fs_lookup_rb_tree_ret(&et->root,
	854	+ (struct rb_entry *)et->cached_en, fofs,
	855	+ (struct rb_entry **)&prev_en,
	856	+ (struct rb_entry **)&next_en,
	857	+ &insert_p, &insert_parent, false,
	858	+ &leftmost);
	859	+ if (en)
	860	+ goto unlock_out;
	861	+
	862	+ __set_extent_info(&ei, fofs, llen, blkaddr, true, 0, 0, EX_READ);
	863	+ ei.c_len = c_len;
	864	+
	865	+ if (!__try_merge_extent_node(sbi, et, &ei, prev_en, next_en))
	866	+ __insert_extent_tree(sbi, et, &ei,
	867	+ insert_p, insert_parent, leftmost);
	868	+unlock_out:
	869	+ write_unlock(&et->lock);
	870	+}
	871	+#endif
	872	+
	873	+static unsigned long long __calculate_block_age(struct f2fs_sb_info *sbi,
	874	+ unsigned long long new,
	875	+ unsigned long long old)
	876	+{
	877	+ unsigned int rem_old, rem_new;
	878	+ unsigned long long res;
	879	+ unsigned int weight = sbi->last_age_weight;
	880	+
	881	+ res = div_u64_rem(new, 100, &rem_new) * (100 - weight)
	882	+ + div_u64_rem(old, 100, &rem_old) * weight;
	883	+
	884	+ if (rem_new)
	885	+ res += rem_new * (100 - weight) / 100;
	886	+ if (rem_old)
	887	+ res += rem_old * weight / 100;
	888	+
	889	+ return res;
	890	+}
	891	+
	892	+/* This returns a new age and allocated blocks in ei */
	893	+static int __get_new_block_age(struct inode inode, struct extent_info ei,
	894	+ block_t blkaddr)
	895	+{
	896	+ struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	897	+ loff_t f_size = i_size_read(inode);
	898	+ unsigned long long cur_blocks =
	899	+ atomic64_read(&sbi->allocated_data_blocks);
	900	+ struct extent_info tei = ei; / only fofs and len are valid */
	901	+
	902	+ /*
	903	+ * When I/O is not aligned to a PAGE_SIZE, update will happen to the last
	904	+ * file block even in seq write. So don't record age for newly last file
	905	+ * block here.
	906	+ */
	907	+ if ((f_size >> PAGE_SHIFT) == ei->fofs && f_size & (PAGE_SIZE - 1) &&
	908	+ blkaddr == NEW_ADDR)
	909	+ return -EINVAL;
	910	+
	911	+ if (__lookup_extent_tree(inode, ei->fofs, &tei, EX_BLOCK_AGE)) {
	912	+ unsigned long long cur_age;
	913	+
	914	+ if (cur_blocks >= tei.last_blocks)
	915	+ cur_age = cur_blocks - tei.last_blocks;
	916	+ else
	917	+ /* allocated_data_blocks overflow */
	918	+ cur_age = ULLONG_MAX - tei.last_blocks + cur_blocks;
	919	+
	920	+ if (tei.age)
	921	+ ei->age = __calculate_block_age(sbi, cur_age, tei.age);
	922	+ else
	923	+ ei->age = cur_age;
	924	+ ei->last_blocks = cur_blocks;
	925	+ WARN_ON(ei->age > cur_blocks);
	926	+ return 0;
	927	+ }
	928	+
	929	+ f2fs_bug_on(sbi, blkaddr == NULL_ADDR);
	930	+
	931	+ /* the data block was allocated for the first time */
	932	+ if (blkaddr == NEW_ADDR)
	933	+ goto out;
	934	+
	935	+ if (__is_valid_data_blkaddr(blkaddr) &&
	936	+ !f2fs_is_valid_blkaddr(sbi, blkaddr, DATA_GENERIC_ENHANCE)) {
	937	+ f2fs_bug_on(sbi, 1);
	938	+ return -EINVAL;
	939	+ }
	940	+out:
	941	+ /*
	942	+ * init block age with zero, this can happen when the block age extent
	943	+ * was reclaimed due to memory constraint or system reboot
	944	+ */
	945	+ ei->age = 0;
	946	+ ei->last_blocks = cur_blocks;
	947	+ return 0;
	948	+}
	949	+
	950	+static void __update_extent_cache(struct dnode_of_data *dn, enum extent_type type)
	951	+{
	952	+ struct extent_info ei = {};
	953	+
	954	+ if (!__may_extent_tree(dn->inode, type))
	955	+ return;
	956	+
	957	+ ei.fofs = f2fs_start_bidx_of_node(ofs_of_node(dn->node_page), dn->inode) +
	958	+ dn->ofs_in_node;
	959	+ ei.len = 1;
	960	+
	961	+ if (type == EX_READ) {
	962	+ if (dn->data_blkaddr == NEW_ADDR)
	963	+ ei.blk = NULL_ADDR;
	964	+ else
	965	+ ei.blk = dn->data_blkaddr;
	966	+ } else if (type == EX_BLOCK_AGE) {
	967	+ if (__get_new_block_age(dn->inode, &ei, dn->data_blkaddr))
	968	+ return;
	969	+ }
	970	+ __update_extent_tree_range(dn->inode, &ei, type);
	971	+}
	972	+
	973	+static unsigned int __shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink,
	974	+ enum extent_type type)
	975	+{
	976	+ struct extent_tree_info *eti = &sbi->extent_tree[type];
636	977	struct extent_tree et, next;
637	978	struct extent_node *en;
638	979	unsigned int node_cnt = 0, tree_cnt = 0;
639	980	int remained;
640	981
641		- if (!test_opt(sbi, EXTENT_CACHE))
642		- return 0;
643		-
644		- if (!atomic_read(&sbi->total_zombie_tree))
	982	+ if (!atomic_read(&eti->total_zombie_tree))
645	983	goto free_node;
646	984
647		- if (!mutex_trylock(&sbi->extent_tree_lock))
	985	+ if (!mutex_trylock(&eti->extent_tree_lock))
648	986	goto out;
649	987
650	988	/* 1. remove unreferenced extent tree */
651		- list_for_each_entry_safe(et, next, &sbi->zombie_list, list) {
	989	+ list_for_each_entry_safe(et, next, &eti->zombie_list, list) {
652	990	if (atomic_read(&et->node_cnt)) {
653	991	write_lock(&et->lock);
654	992	node_cnt += __free_extent_tree(sbi, et);
..	..	@@ -656,61 +994,137 @@
656	994	}
657	995	f2fs_bug_on(sbi, atomic_read(&et->node_cnt));
658	996	list_del_init(&et->list);
659		- radix_tree_delete(&sbi->extent_tree_root, et->ino);
	997	+ radix_tree_delete(&eti->extent_tree_root, et->ino);
660	998	kmem_cache_free(extent_tree_slab, et);
661		- atomic_dec(&sbi->total_ext_tree);
662		- atomic_dec(&sbi->total_zombie_tree);
	999	+ atomic_dec(&eti->total_ext_tree);
	1000	+ atomic_dec(&eti->total_zombie_tree);
663	1001	tree_cnt++;
664	1002
665	1003	if (node_cnt + tree_cnt >= nr_shrink)
666	1004	goto unlock_out;
667	1005	cond_resched();
668	1006	}
669		- mutex_unlock(&sbi->extent_tree_lock);
	1007	+ mutex_unlock(&eti->extent_tree_lock);
670	1008
671	1009	free_node:
672	1010	/* 2. remove LRU extent entries */
673		- if (!mutex_trylock(&sbi->extent_tree_lock))
	1011	+ if (!mutex_trylock(&eti->extent_tree_lock))
674	1012	goto out;
675	1013
676	1014	remained = nr_shrink - (node_cnt + tree_cnt);
677	1015
678		- spin_lock(&sbi->extent_lock);
	1016	+ spin_lock(&eti->extent_lock);
679	1017	for (; remained > 0; remained--) {
680		- if (list_empty(&sbi->extent_list))
	1018	+ if (list_empty(&eti->extent_list))
681	1019	break;
682		- en = list_first_entry(&sbi->extent_list,
	1020	+ en = list_first_entry(&eti->extent_list,
683	1021	struct extent_node, list);
684	1022	et = en->et;
685	1023	if (!write_trylock(&et->lock)) {
686	1024	/* refresh this extent node's position in extent list */
687		- list_move_tail(&en->list, &sbi->extent_list);
	1025	+ list_move_tail(&en->list, &eti->extent_list);
688	1026	continue;
689	1027	}
690	1028
691	1029	list_del_init(&en->list);
692		- spin_unlock(&sbi->extent_lock);
	1030	+ spin_unlock(&eti->extent_lock);
693	1031
694	1032	__detach_extent_node(sbi, et, en);
695	1033
696	1034	write_unlock(&et->lock);
697	1035	node_cnt++;
698		- spin_lock(&sbi->extent_lock);
	1036	+ spin_lock(&eti->extent_lock);
699	1037	}
700		- spin_unlock(&sbi->extent_lock);
	1038	+ spin_unlock(&eti->extent_lock);
701	1039
702	1040	unlock_out:
703		- mutex_unlock(&sbi->extent_tree_lock);
	1041	+ mutex_unlock(&eti->extent_tree_lock);
704	1042	out:
705		- trace_f2fs_shrink_extent_tree(sbi, node_cnt, tree_cnt);
	1043	+ trace_f2fs_shrink_extent_tree(sbi, node_cnt, tree_cnt, type);
706	1044
707	1045	return node_cnt + tree_cnt;
708	1046	}
709	1047
710		-unsigned int f2fs_destroy_extent_node(struct inode *inode)
	1048	+/* read extent cache operations */
	1049	+bool f2fs_lookup_read_extent_cache(struct inode *inode, pgoff_t pgofs,
	1050	+ struct extent_info *ei)
	1051	+{
	1052	+ if (!__may_extent_tree(inode, EX_READ))
	1053	+ return false;
	1054	+
	1055	+ return __lookup_extent_tree(inode, pgofs, ei, EX_READ);
	1056	+}
	1057	+
	1058	+void f2fs_update_read_extent_cache(struct dnode_of_data *dn)
	1059	+{
	1060	+ return __update_extent_cache(dn, EX_READ);
	1061	+}
	1062	+
	1063	+void f2fs_update_read_extent_cache_range(struct dnode_of_data *dn,
	1064	+ pgoff_t fofs, block_t blkaddr, unsigned int len)
	1065	+{
	1066	+ struct extent_info ei = {
	1067	+ .fofs = fofs,
	1068	+ .len = len,
	1069	+ .blk = blkaddr,
	1070	+ };
	1071	+
	1072	+ if (!__may_extent_tree(dn->inode, EX_READ))
	1073	+ return;
	1074	+
	1075	+ __update_extent_tree_range(dn->inode, &ei, EX_READ);
	1076	+}
	1077	+
	1078	+unsigned int f2fs_shrink_read_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink)
	1079	+{
	1080	+ if (!test_opt(sbi, READ_EXTENT_CACHE))
	1081	+ return 0;
	1082	+
	1083	+ return __shrink_extent_tree(sbi, nr_shrink, EX_READ);
	1084	+}
	1085	+
	1086	+/* block age extent cache operations */
	1087	+bool f2fs_lookup_age_extent_cache(struct inode *inode, pgoff_t pgofs,
	1088	+ struct extent_info *ei)
	1089	+{
	1090	+ if (!__may_extent_tree(inode, EX_BLOCK_AGE))
	1091	+ return false;
	1092	+
	1093	+ return __lookup_extent_tree(inode, pgofs, ei, EX_BLOCK_AGE);
	1094	+}
	1095	+
	1096	+void f2fs_update_age_extent_cache(struct dnode_of_data *dn)
	1097	+{
	1098	+ return __update_extent_cache(dn, EX_BLOCK_AGE);
	1099	+}
	1100	+
	1101	+void f2fs_update_age_extent_cache_range(struct dnode_of_data *dn,
	1102	+ pgoff_t fofs, unsigned int len)
	1103	+{
	1104	+ struct extent_info ei = {
	1105	+ .fofs = fofs,
	1106	+ .len = len,
	1107	+ };
	1108	+
	1109	+ if (!__may_extent_tree(dn->inode, EX_BLOCK_AGE))
	1110	+ return;
	1111	+
	1112	+ __update_extent_tree_range(dn->inode, &ei, EX_BLOCK_AGE);
	1113	+}
	1114	+
	1115	+unsigned int f2fs_shrink_age_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink)
	1116	+{
	1117	+ if (!test_opt(sbi, AGE_EXTENT_CACHE))
	1118	+ return 0;
	1119	+
	1120	+ return __shrink_extent_tree(sbi, nr_shrink, EX_BLOCK_AGE);
	1121	+}
	1122	+
	1123	+static unsigned int __destroy_extent_node(struct inode *inode,
	1124	+ enum extent_type type)
711	1125	{
712	1126	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
713		- struct extent_tree *et = F2FS_I(inode)->extent_tree;
	1127	+ struct extent_tree *et = F2FS_I(inode)->extent_tree[type];
714	1128	unsigned int node_cnt = 0;
715	1129
716	1130	if (!et \|\| !atomic_read(&et->node_cnt))
..	..	@@ -723,32 +1137,47 @@
723	1137	return node_cnt;
724	1138	}
725	1139
726		-void f2fs_drop_extent_tree(struct inode *inode)
	1140	+void f2fs_destroy_extent_node(struct inode *inode)
	1141	+{
	1142	+ __destroy_extent_node(inode, EX_READ);
	1143	+ __destroy_extent_node(inode, EX_BLOCK_AGE);
	1144	+}
	1145	+
	1146	+static void __drop_extent_tree(struct inode *inode, enum extent_type type)
727	1147	{
728	1148	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
729		- struct extent_tree *et = F2FS_I(inode)->extent_tree;
	1149	+ struct extent_tree *et = F2FS_I(inode)->extent_tree[type];
730	1150	bool updated = false;
731	1151
732		- if (!f2fs_may_extent_tree(inode))
	1152	+ if (!__may_extent_tree(inode, type))
733	1153	return;
734	1154
735		- set_inode_flag(inode, FI_NO_EXTENT);
736		-
737	1155	write_lock(&et->lock);
	1156	+ set_inode_flag(inode, FI_NO_EXTENT);
738	1157	__free_extent_tree(sbi, et);
739		- if (et->largest.len) {
740		- et->largest.len = 0;
741		- updated = true;
	1158	+ if (type == EX_READ) {
	1159	+ set_inode_flag(inode, FI_NO_EXTENT);
	1160	+ if (et->largest.len) {
	1161	+ et->largest.len = 0;
	1162	+ updated = true;
	1163	+ }
742	1164	}
743	1165	write_unlock(&et->lock);
744	1166	if (updated)
745	1167	f2fs_mark_inode_dirty_sync(inode, true);
746	1168	}
747	1169
748		-void f2fs_destroy_extent_tree(struct inode *inode)
	1170	+void f2fs_drop_extent_tree(struct inode *inode)
	1171	+{
	1172	+ __drop_extent_tree(inode, EX_READ);
	1173	+ __drop_extent_tree(inode, EX_BLOCK_AGE);
	1174	+}
	1175	+
	1176	+static void __destroy_extent_tree(struct inode *inode, enum extent_type type)
749	1177	{
750	1178	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
751		- struct extent_tree *et = F2FS_I(inode)->extent_tree;
	1179	+ struct extent_tree_info *eti = &sbi->extent_tree[type];
	1180	+ struct extent_tree *et = F2FS_I(inode)->extent_tree[type];
752	1181	unsigned int node_cnt = 0;
753	1182
754	1183	if (!et)
..	..	@@ -756,76 +1185,57 @@
756	1185
757	1186	if (inode->i_nlink && !is_bad_inode(inode) &&
758	1187	atomic_read(&et->node_cnt)) {
759		- mutex_lock(&sbi->extent_tree_lock);
760		- list_add_tail(&et->list, &sbi->zombie_list);
761		- atomic_inc(&sbi->total_zombie_tree);
762		- mutex_unlock(&sbi->extent_tree_lock);
	1188	+ mutex_lock(&eti->extent_tree_lock);
	1189	+ list_add_tail(&et->list, &eti->zombie_list);
	1190	+ atomic_inc(&eti->total_zombie_tree);
	1191	+ mutex_unlock(&eti->extent_tree_lock);
763	1192	return;
764	1193	}
765	1194
766	1195	/* free all extent info belong to this extent tree */
767		- node_cnt = f2fs_destroy_extent_node(inode);
	1196	+ node_cnt = __destroy_extent_node(inode, type);
768	1197
769	1198	/* delete extent tree entry in radix tree */
770		- mutex_lock(&sbi->extent_tree_lock);
	1199	+ mutex_lock(&eti->extent_tree_lock);
771	1200	f2fs_bug_on(sbi, atomic_read(&et->node_cnt));
772		- radix_tree_delete(&sbi->extent_tree_root, inode->i_ino);
	1201	+ radix_tree_delete(&eti->extent_tree_root, inode->i_ino);
773	1202	kmem_cache_free(extent_tree_slab, et);
774		- atomic_dec(&sbi->total_ext_tree);
775		- mutex_unlock(&sbi->extent_tree_lock);
	1203	+ atomic_dec(&eti->total_ext_tree);
	1204	+ mutex_unlock(&eti->extent_tree_lock);
776	1205
777		- F2FS_I(inode)->extent_tree = NULL;
	1206	+ F2FS_I(inode)->extent_tree[type] = NULL;
778	1207
779		- trace_f2fs_destroy_extent_tree(inode, node_cnt);
	1208	+ trace_f2fs_destroy_extent_tree(inode, node_cnt, type);
780	1209	}
781	1210
782		-bool f2fs_lookup_extent_cache(struct inode *inode, pgoff_t pgofs,
783		- struct extent_info *ei)
	1211	+void f2fs_destroy_extent_tree(struct inode *inode)
784	1212	{
785		- if (!f2fs_may_extent_tree(inode))
786		- return false;
787		-
788		- return f2fs_lookup_extent_tree(inode, pgofs, ei);
	1213	+ __destroy_extent_tree(inode, EX_READ);
	1214	+ __destroy_extent_tree(inode, EX_BLOCK_AGE);
789	1215	}
790	1216
791		-void f2fs_update_extent_cache(struct dnode_of_data *dn)
	1217	+static void __init_extent_tree_info(struct extent_tree_info *eti)
792	1218	{
793		- pgoff_t fofs;
794		- block_t blkaddr;
795		-
796		- if (!f2fs_may_extent_tree(dn->inode))
797		- return;
798		-
799		- if (dn->data_blkaddr == NEW_ADDR)
800		- blkaddr = NULL_ADDR;
801		- else
802		- blkaddr = dn->data_blkaddr;
803		-
804		- fofs = f2fs_start_bidx_of_node(ofs_of_node(dn->node_page), dn->inode) +
805		- dn->ofs_in_node;
806		- f2fs_update_extent_tree_range(dn->inode, fofs, blkaddr, 1);
807		-}
808		-
809		-void f2fs_update_extent_cache_range(struct dnode_of_data *dn,
810		- pgoff_t fofs, block_t blkaddr, unsigned int len)
811		-
812		-{
813		- if (!f2fs_may_extent_tree(dn->inode))
814		- return;
815		-
816		- f2fs_update_extent_tree_range(dn->inode, fofs, blkaddr, len);
	1219	+ INIT_RADIX_TREE(&eti->extent_tree_root, GFP_NOIO);
	1220	+ mutex_init(&eti->extent_tree_lock);
	1221	+ INIT_LIST_HEAD(&eti->extent_list);
	1222	+ spin_lock_init(&eti->extent_lock);
	1223	+ atomic_set(&eti->total_ext_tree, 0);
	1224	+ INIT_LIST_HEAD(&eti->zombie_list);
	1225	+ atomic_set(&eti->total_zombie_tree, 0);
	1226	+ atomic_set(&eti->total_ext_node, 0);
817	1227	}
818	1228
819	1229	void f2fs_init_extent_cache_info(struct f2fs_sb_info *sbi)
820	1230	{
821		- INIT_RADIX_TREE(&sbi->extent_tree_root, GFP_NOIO);
822		- mutex_init(&sbi->extent_tree_lock);
823		- INIT_LIST_HEAD(&sbi->extent_list);
824		- spin_lock_init(&sbi->extent_lock);
825		- atomic_set(&sbi->total_ext_tree, 0);
826		- INIT_LIST_HEAD(&sbi->zombie_list);
827		- atomic_set(&sbi->total_zombie_tree, 0);
828		- atomic_set(&sbi->total_ext_node, 0);
	1231	+ __init_extent_tree_info(&sbi->extent_tree[EX_READ]);
	1232	+ __init_extent_tree_info(&sbi->extent_tree[EX_BLOCK_AGE]);
	1233	+
	1234	+ /* initialize for block age extents */
	1235	+ atomic64_set(&sbi->allocated_data_blocks, 0);
	1236	+ sbi->hot_data_age_threshold = DEF_HOT_DATA_AGE_THRESHOLD;
	1237	+ sbi->warm_data_age_threshold = DEF_WARM_DATA_AGE_THRESHOLD;
	1238	+ sbi->last_age_weight = LAST_AGE_WEIGHT;
829	1239	}
830	1240
831	1241	int __init f2fs_create_extent_cache(void)