移去rt

hc

2023-12-08 01573e231f18eb2d99162747186f59511f56b64d

 kernel/fs/f2fs/inline.c
..
..
@@ -8,26 +8,47 @@
8
8
 
9
9
 #include <linux/fs.h>
10
10
 #include <linux/f2fs_fs.h>
11
+#include <linux/fiemap.h>
11
12
 
12
13
 #include "f2fs.h"
13
14
 #include "node.h"
15
+#include <trace/events/f2fs.h>
14
16
 #include <trace/events/android_fs.h>
15
17
 
16
-bool f2fs_may_inline_data(struct inode *inode)
18
+static bool support_inline_data(struct inode *inode)
17
19
 {
18
20
 	if (f2fs_is_atomic_file(inode))
19
21
 		return false;
20
-
21
22
 	if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))
22
23
 		return false;
23
-
24
24
 	if (i_size_read(inode) > MAX_INLINE_DATA(inode))
25
25
 		return false;
26
+	return true;
27
+}
26
28
 
27
-	if (f2fs_post_read_required(inode))
29
+bool f2fs_may_inline_data(struct inode *inode)
30
+{
31
+	if (!support_inline_data(inode))
28
32
 		return false;
29
33
 
30
-	return true;
34
+	return !f2fs_post_read_required(inode);
35
+}
36
+
37
+bool f2fs_sanity_check_inline_data(struct inode *inode)
38
+{
39
+	if (!f2fs_has_inline_data(inode))
40
+		return false;
41
+
42
+	if (!support_inline_data(inode))
43
+		return true;
44
+
45
+	/*
46
+	 * used by sanity_check_inode(), when disk layout fields has not
47
+	 * been synchronized to inmem fields.
48
+	 */
49
+	return (S_ISREG(inode->i_mode) &&
50
+		(file_is_encrypt(inode) || file_is_verity(inode) ||
51
+		(F2FS_I(inode)->i_flags & F2FS_COMPR_FL)));
31
52
 }
32
53
 
33
54
 bool f2fs_may_inline_dentry(struct inode *inode)
..
..
@@ -147,7 +168,7 @@
147
168
 	if (err)
148
169
 		return err;
149
170
 
150
-	err = f2fs_get_node_info(fio.sbi, dn->nid, &ni);
171
+	err = f2fs_get_node_info(fio.sbi, dn->nid, &ni, false);
151
172
 	if (err) {
152
173
 		f2fs_truncate_data_blocks_range(dn, 1);
153
174
 		f2fs_put_dnode(dn);
..
..
@@ -189,7 +210,7 @@
189
210
 
190
211
 	/* clear inline data and flag after data writeback */
191
212
 	f2fs_truncate_inline_inode(dn->inode, dn->inode_page, 0);
192
-	clear_inline_node(dn->inode_page);
213
+	clear_page_private_inline(dn->inode_page);
193
214
 clear_out:
194
215
 	stat_dec_inline_inode(dn->inode);
195
216
 	clear_inode_flag(dn->inode, FI_INLINE_DATA);
..
..
@@ -204,7 +225,8 @@
204
225
 	struct page *ipage, *page;
205
226
 	int err = 0;
206
227
 
207
-	if (!f2fs_has_inline_data(inode))
228
+	if (!f2fs_has_inline_data(inode) ||
229
+			f2fs_hw_is_readonly(sbi) || f2fs_readonly(sbi->sb))
208
230
 		return 0;
209
231
 
210
232
 	err = dquot_initialize(inode);
..
..
@@ -265,12 +287,12 @@
265
287
 	kunmap_atomic(src_addr);
266
288
 	set_page_dirty(dn.inode_page);
267
289
 
268
-	f2fs_clear_radix_tree_dirty_tag(page);
290
+	f2fs_clear_page_cache_dirty_tag(page);
269
291
 
270
292
 	set_inode_flag(inode, FI_APPEND_WRITE);
271
293
 	set_inode_flag(inode, FI_DATA_EXIST);
272
294
 
273
-	clear_inline_node(dn.inode_page);
295
+	clear_page_private_inline(dn.inode_page);
274
296
 	f2fs_put_dnode(&dn);
275
297
 	return 0;
276
298
 }
..
..
@@ -287,7 +309,7 @@
287
309
 	 * [prev.] [next] of inline_data flag
288
310
 	 *    o       o  -> recover inline_data
289
311
 	 *    o       x  -> remove inline_data, and then recover data blocks
290
-	 *    x       o  -> remove inline_data, and then recover inline_data
312
+	 *    x       o  -> remove data blocks, and then recover inline_data
291
313
 	 *    x       x  -> recover data blocks
292
314
 	 */
293
315
 	if (IS_INODE(npage))
..
..
@@ -319,6 +341,7 @@
319
341
 		if (IS_ERR(ipage))
320
342
 			return PTR_ERR(ipage);
321
343
 		f2fs_truncate_inline_inode(inode, ipage, 0);
344
+		stat_dec_inline_inode(inode);
322
345
 		clear_inode_flag(inode, FI_INLINE_DATA);
323
346
 		f2fs_put_page(ipage, 1);
324
347
 	} else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
..
..
@@ -327,6 +350,7 @@
327
350
 		ret = f2fs_truncate_blocks(inode, 0, false);
328
351
 		if (ret)
329
352
 			return ret;
353
+		stat_inc_inline_inode(inode);
330
354
 		goto process_inline;
331
355
 	}
332
356
 	return 0;
..
..
@@ -353,6 +377,10 @@
353
377
 	make_dentry_ptr_inline(dir, &d, inline_dentry);
354
378
 	de = f2fs_find_target_dentry(&d, fname, NULL);
355
379
 	unlock_page(ipage);
380
+	if (IS_ERR(de)) {
381
+		*res_page = ERR_CAST(de);
382
+		de = NULL;
383
+	}
356
384
 	if (de)
357
385
 		*res_page = ipage;
358
386
 	else
..
..
@@ -545,7 +573,7 @@
545
573
 			!f2fs_has_inline_xattr(dir))
546
574
 		F2FS_I(dir)->i_inline_xattr_size = 0;
547
575
 
548
-	kvfree(backup_dentry);
576
+	kfree(backup_dentry);
549
577
 	return 0;
550
578
 recover:
551
579
 	lock_page(ipage);
..
..
@@ -556,7 +584,7 @@
556
584
 	set_page_dirty(ipage);
557
585
 	f2fs_put_page(ipage, 1);
558
586
 
559
-	kvfree(backup_dentry);
587
+	kfree(backup_dentry);
560
588
 	return err;
561
589
 }
562
590
 
..
..
@@ -638,7 +666,7 @@
638
666
 	}
639
667
 
640
668
 	if (inode) {
641
-		down_write(&F2FS_I(inode)->i_sem);
669
+		f2fs_down_write(&F2FS_I(inode)->i_sem);
642
670
 		page = f2fs_init_inode_metadata(inode, dir, fname, ipage);
643
671
 		if (IS_ERR(page)) {
644
672
 			err = PTR_ERR(page);
..
..
@@ -667,7 +695,7 @@
667
695
 	f2fs_update_parent_metadata(dir, inode, 0);
668
696
 fail:
669
697
 	if (inode)
670
-		up_write(&F2FS_I(inode)->i_sem);
698
+		f2fs_up_write(&F2FS_I(inode)->i_sem);
671
699
 out:
672
700
 	f2fs_put_page(ipage, 1);
673
701
 	return err;
..
..
@@ -795,7 +823,7 @@
795
823
 		ilen = start + len;
796
824
 	ilen -= start;
797
825
 
798
-	err = f2fs_get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni);
826
+	err = f2fs_get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni, false);
799
827
 	if (err)
800
828
 		goto out;
801
829
 
..
..
@@ -803,6 +831,7 @@
803
831
 	byteaddr += (char *)inline_data_addr(inode, ipage) -
804
832
 					(char *)F2FS_INODE(ipage);
805
833
 	err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);
834
+	trace_f2fs_fiemap(inode, start, byteaddr, ilen, flags, err);
806
835
 out:
807
836
 	f2fs_put_page(ipage, 1);
808
837
 	return err;