export RK_PA3

hc

2024-02-19 151fecfb72a0d602dfe79790602ef64b4e241574

 kernel/fs/f2fs/xattr.c
..
..
@@ -39,12 +39,12 @@
39
39
 	if (is_inline)
40
40
 		kmem_cache_free(sbi->inline_xattr_slab, xattr_addr);
41
41
 	else
42
-		kvfree(xattr_addr);
42
+		kfree(xattr_addr);
43
43
 }
44
44
 
45
45
 static int f2fs_xattr_generic_get(const struct xattr_handler *handler,
46
46
 		struct dentry *unused, struct inode *inode,
47
-		const char *name, void *buffer, size_t size)
47
+		const char *name, void *buffer, size_t size, int flags)
48
48
 {
49
49
 	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
50
50
 
..
..
@@ -99,7 +99,7 @@
99
99
 
100
100
 static int f2fs_xattr_advise_get(const struct xattr_handler *handler,
101
101
 		struct dentry *unused, struct inode *inode,
102
-		const char *name, void *buffer, size_t size)
102
+		const char *name, void *buffer, size_t size, int flags)
103
103
 {
104
104
 	if (buffer)
105
105
 		*((char *)buffer) = F2FS_I(inode)->i_advise;
..
..
@@ -175,8 +175,8 @@
175
175
 const struct xattr_handler f2fs_xattr_advise_handler = {
176
176
 	.name	= F2FS_SYSTEM_ADVISE_NAME,
177
177
 	.flags	= F2FS_XATTR_INDEX_ADVISE,
178
-	.get    = f2fs_xattr_advise_get,
179
-	.set    = f2fs_xattr_advise_set,
178
+	.get	= f2fs_xattr_advise_get,
179
+	.set	= f2fs_xattr_advise_set,
180
180
 };
181
181
 
182
182
 const struct xattr_handler f2fs_xattr_security_handler = {
..
..
@@ -327,7 +327,7 @@
327
327
 	void *last_addr = NULL;
328
328
 	nid_t xnid = F2FS_I(inode)->i_xattr_nid;
329
329
 	unsigned int inline_size = inline_xattr_size(inode);
330
-	int err = 0;
330
+	int err;
331
331
 
332
332
 	if (!xnid && !inline_size)
333
333
 		return -ENODATA;
..
..
@@ -425,7 +425,7 @@
425
425
 	*base_addr = txattr_addr;
426
426
 	return 0;
427
427
 fail:
428
-	kvfree(txattr_addr);
428
+	kfree(txattr_addr);
429
429
 	return err;
430
430
 }
431
431
 
..
..
@@ -486,6 +486,7 @@
486
486
 		f2fs_wait_on_page_writeback(xpage, NODE, true, true);
487
487
 	} else {
488
488
 		struct dnode_of_data dn;
489
+
489
490
 		set_new_dnode(&dn, inode, NULL, NULL, new_nid);
490
491
 		xpage = f2fs_new_node_page(&dn, XATTR_NODE_OFFSET);
491
492
 		if (IS_ERR(xpage)) {
..
..
@@ -515,7 +516,7 @@
515
516
 		void *buffer, size_t buffer_size, struct page *ipage)
516
517
 {
517
518
 	struct f2fs_xattr_entry *entry = NULL;
518
-	int error = 0;
519
+	int error;
519
520
 	unsigned int size, len;
520
521
 	void *base_addr = NULL;
521
522
 	int base_size;
..
..
@@ -528,10 +529,10 @@
528
529
 	if (len > F2FS_NAME_LEN)
529
530
 		return -ERANGE;
530
531
 
531
-	down_read(&F2FS_I(inode)->i_xattr_sem);
532
+	f2fs_down_read(&F2FS_I(inode)->i_xattr_sem);
532
533
 	error = lookup_all_xattrs(inode, ipage, index, len, name,
533
534
 				&entry, &base_addr, &base_size, &is_inline);
534
-	up_read(&F2FS_I(inode)->i_xattr_sem);
535
+	f2fs_up_read(&F2FS_I(inode)->i_xattr_sem);
535
536
 	if (error)
536
537
 		return error;
537
538
 
..
..
@@ -562,12 +563,12 @@
562
563
 	struct inode *inode = d_inode(dentry);
563
564
 	struct f2fs_xattr_entry *entry;
564
565
 	void *base_addr, *last_base_addr;
565
-	int error = 0;
566
+	int error;
566
567
 	size_t rest = buffer_size;
567
568
 
568
-	down_read(&F2FS_I(inode)->i_xattr_sem);
569
+	f2fs_down_read(&F2FS_I(inode)->i_xattr_sem);
569
570
 	error = read_all_xattrs(inode, NULL, &base_addr);
570
-	up_read(&F2FS_I(inode)->i_xattr_sem);
571
+	f2fs_up_read(&F2FS_I(inode)->i_xattr_sem);
571
572
 	if (error)
572
573
 		return error;
573
574
 
..
..
@@ -610,7 +611,7 @@
610
611
 	}
611
612
 	error = buffer_size - rest;
612
613
 cleanup:
613
-	kvfree(base_addr);
614
+	kfree(base_addr);
614
615
 	return error;
615
616
 }
616
617
 
..
..
@@ -632,7 +633,7 @@
632
633
 	int found, newsize;
633
634
 	size_t len;
634
635
 	__u32 new_hsize;
635
-	int error = 0;
636
+	int error;
636
637
 
637
638
 	if (name == NULL)
638
639
 		return -EINVAL;
..
..
@@ -673,7 +674,7 @@
673
674
 		}
674
675
 
675
676
 		if (value && f2fs_xattr_value_same(here, value, size))
676
-			goto exit;
677
+			goto same;
677
678
 	} else if ((flags & XATTR_REPLACE)) {
678
679
 		error = -ENODATA;
679
680
 		goto exit;
..
..
@@ -683,6 +684,8 @@
683
684
 	while (!IS_XATTR_LAST_ENTRY(last)) {
684
685
 		if ((void *)(last) + sizeof(__u32) > last_base_addr ||
685
686
 			(void *)XATTR_NEXT_ENTRY(last) > last_base_addr) {
687
+			f2fs_err(F2FS_I_SB(inode), "inode (%lu) has invalid last xattr entry, entry_size: %zu",
688
+					inode->i_ino, ENTRY_SIZE(last));
686
689
 			set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
687
690
 			error = -EFSCORRUPTED;
688
691
 			goto exit;
..
..
@@ -745,19 +748,22 @@
745
748
 	if (error)
746
749
 		goto exit;
747
750
 
748
-	if (is_inode_flag_set(inode, FI_ACL_MODE)) {
749
-		inode->i_mode = F2FS_I(inode)->i_acl_mode;
750
-		inode->i_ctime = current_time(inode);
751
-		clear_inode_flag(inode, FI_ACL_MODE);
752
-	}
753
751
 	if (index == F2FS_XATTR_INDEX_ENCRYPTION &&
754
752
 			!strcmp(name, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT))
755
753
 		f2fs_set_encrypted_inode(inode);
756
754
 	f2fs_mark_inode_dirty_sync(inode, true);
757
755
 	if (!error && S_ISDIR(inode->i_mode))
758
756
 		set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_CP);
757
+
758
+same:
759
+	if (is_inode_flag_set(inode, FI_ACL_MODE)) {
760
+		inode->i_mode = F2FS_I(inode)->i_acl_mode;
761
+		inode->i_ctime = current_time(inode);
762
+		clear_inode_flag(inode, FI_ACL_MODE);
763
+	}
764
+
759
765
 exit:
760
-	kvfree(base_addr);
766
+	kfree(base_addr);
761
767
 	return error;
762
768
 }
763
769
 
..
..
@@ -784,9 +790,9 @@
784
790
 	f2fs_balance_fs(sbi, true);
785
791
 
786
792
 	f2fs_lock_op(sbi);
787
-	down_write(&F2FS_I(inode)->i_xattr_sem);
793
+	f2fs_down_write(&F2FS_I(inode)->i_xattr_sem);
788
794
 	err = __f2fs_setxattr(inode, index, name, value, size, ipage, flags);
789
-	up_write(&F2FS_I(inode)->i_xattr_sem);
795
+	f2fs_up_write(&F2FS_I(inode)->i_xattr_sem);
790
796
 	f2fs_unlock_op(sbi);
791
797
 
792
798
 	f2fs_update_time(sbi, REQ_TIME);