forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/fs/f2fs/dir.c
....@@ -16,6 +16,10 @@
1616 #include "xattr.h"
1717 #include <trace/events/f2fs.h>
1818 
19
+#ifdef CONFIG_UNICODE
20
+extern struct kmem_cache *f2fs_cf_name_slab;
21
+#endif
22
+
1923 static unsigned long dir_blocks(struct inode *inode)
2024 {
2125 	return ((unsigned long long) (i_size_read(inode) + PAGE_SIZE - 1))
....@@ -76,21 +80,22 @@
7680 			      struct f2fs_filename *fname)
7781 {
7882 #ifdef CONFIG_UNICODE
79
-	struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
83
+	struct super_block *sb = dir->i_sb;
8084 
81
-	if (IS_CASEFOLDED(dir)) {
82
-		fname->cf_name.name = f2fs_kmalloc(sbi, F2FS_NAME_LEN,
83
-						   GFP_NOFS);
85
+	if (IS_CASEFOLDED(dir) &&
86
+	    !is_dot_dotdot(fname->usr_fname->name, fname->usr_fname->len)) {
87
+		fname->cf_name.name = kmem_cache_alloc(f2fs_cf_name_slab,
88
+								GFP_NOFS);
8489 		if (!fname->cf_name.name)
8590 			return -ENOMEM;
86
-		fname->cf_name.len = utf8_casefold(sbi->sb->s_encoding,
91
+		fname->cf_name.len = utf8_casefold(sb->s_encoding,
8792 						   fname->usr_fname,
8893 						   fname->cf_name.name,
8994 						   F2FS_NAME_LEN);
9095 		if ((int)fname->cf_name.len <= 0) {
91
-			kfree(fname->cf_name.name);
96
+			kmem_cache_free(f2fs_cf_name_slab, fname->cf_name.name);
9297 			fname->cf_name.name = NULL;
93
-			if (sb_has_enc_strict_mode(dir->i_sb))
98
+			if (sb_has_strict_encoding(sb))
9499 				return -EINVAL;
95100 			/* fall back to treating name as opaque byte sequence */
96101 		}
....@@ -112,7 +117,7 @@
112117 #ifdef CONFIG_FS_ENCRYPTION
113118 	fname->crypto_buf = crypt_name->crypto_buf;
114119 #endif
115
-	if (crypt_name->is_ciphertext_name) {
120
+	if (crypt_name->is_nokey_name) {
116121 		/* hash was decoded from the no-key name */
117122 		fname->hash = cpu_to_le32(crypt_name->hash);
118123 	} else {
....@@ -171,8 +176,10 @@
171176 	fname->crypto_buf.name = NULL;
172177 #endif
173178 #ifdef CONFIG_UNICODE
174
-	kfree(fname->cf_name.name);
175
-	fname->cf_name.name = NULL;
179
+	if (fname->cf_name.name) {
180
+		kmem_cache_free(f2fs_cf_name_slab, fname->cf_name.name);
181
+		fname->cf_name.name = NULL;
182
+	}
176183 #endif
177184 }
178185 
....@@ -191,29 +198,25 @@
191198 static struct f2fs_dir_entry *find_in_block(struct inode *dir,
192199 				struct page *dentry_page,
193200 				const struct f2fs_filename *fname,
194
-				int *max_slots,
195
-				struct page **res_page)
201
+				int *max_slots)
196202 {
197203 	struct f2fs_dentry_block *dentry_blk;
198
-	struct f2fs_dir_entry *de;
199204 	struct f2fs_dentry_ptr d;
200205 
201206 	dentry_blk = (struct f2fs_dentry_block *)page_address(dentry_page);
202207 
203208 	make_dentry_ptr_block(dir, &d, dentry_blk);
204
-	de = f2fs_find_target_dentry(&d, fname, max_slots);
205
-	if (de)
206
-		*res_page = dentry_page;
207
-
208
-	return de;
209
+	return f2fs_find_target_dentry(&d, fname, max_slots);
209210 }
210211 
211212 #ifdef CONFIG_UNICODE
212213 /*
213214  * Test whether a case-insensitive directory entry matches the filename
214215  * being searched for.
216
+ *
217
+ * Returns 1 for a match, 0 for no match, and -errno on an error.
215218  */
216
-static bool f2fs_match_ci_name(const struct inode *dir, const struct qstr *name,
219
+static int f2fs_match_ci_name(const struct inode *dir, const struct qstr *name,
217220 			       const u8 *de_name, u32 de_name_len)
218221 {
219222 	const struct super_block *sb = dir->i_sb;
....@@ -227,11 +230,11 @@
227230 			FSTR_INIT((u8 *)de_name, de_name_len);
228231 
229232 		if (WARN_ON_ONCE(!fscrypt_has_encryption_key(dir)))
230
-			return false;
233
+			return -EINVAL;
231234 
232235 		decrypted_name.name = kmalloc(de_name_len, GFP_KERNEL);
233236 		if (!decrypted_name.name)
234
-			return false;
237
+			return -ENOMEM;
235238 		res = fscrypt_fname_disk_to_usr(dir, 0, 0, &encrypted_name,
236239 						&decrypted_name);
237240 		if (res < 0)
....@@ -241,23 +244,24 @@
241244 	}
242245 
243246 	res = utf8_strncasecmp_folded(um, name, &entry);
244
-	if (res < 0) {
245
-		/*
246
-		 * In strict mode, ignore invalid names.  In non-strict mode,
247
-		 * fall back to treating them as opaque byte sequences.
248
-		 */
249
-		if (sb_has_enc_strict_mode(sb) || name->len != entry.len)
250
-			res = 1;
251
-		else
252
-			res = memcmp(name->name, entry.name, name->len);
247
+	/*
248
+	 * In strict mode, ignore invalid names.  In non-strict mode,
249
+	 * fall back to treating them as opaque byte sequences.
250
+	 */
251
+	if (res < 0 && !sb_has_strict_encoding(sb)) {
252
+		res = name->len == entry.len &&
253
+				memcmp(name->name, entry.name, name->len) == 0;
254
+	} else {
255
+		/* utf8_strncasecmp_folded returns 0 on match */
256
+		res = (res == 0);
253257 	}
254258 out:
255259 	kfree(decrypted_name.name);
256
-	return res == 0;
260
+	return res;
257261 }
258262 #endif /* CONFIG_UNICODE */
259263 
260
-static inline bool f2fs_match_name(const struct inode *dir,
264
+static inline int f2fs_match_name(const struct inode *dir,
261265 				   const struct f2fs_filename *fname,
262266 				   const u8 *de_name, u32 de_name_len)
263267 {
....@@ -284,6 +288,7 @@
284288 	struct f2fs_dir_entry *de;
285289 	unsigned long bit_pos = 0;
286290 	int max_len = 0;
291
+	int res = 0;
287292 
288293 	if (max_slots)
289294 		*max_slots = 0;
....@@ -301,10 +306,15 @@
301306 			continue;
302307 		}
303308 
304
-		if (de->hash_code == fname->hash &&
305
-		    f2fs_match_name(d->inode, fname, d->filename[bit_pos],
306
-				    le16_to_cpu(de->name_len)))
307
-			goto found;
309
+		if (de->hash_code == fname->hash) {
310
+			res = f2fs_match_name(d->inode, fname,
311
+					      d->filename[bit_pos],
312
+					      le16_to_cpu(de->name_len));
313
+			if (res < 0)
314
+				return ERR_PTR(res);
315
+			if (res)
316
+				goto found;
317
+		}
308318 
309319 		if (max_slots && max_len > *max_slots)
310320 			*max_slots = max_len;
....@@ -353,10 +363,15 @@
353363 			}
354364 		}
355365 
356
-		de = find_in_block(dir, dentry_page, fname, &max_slots,
357
-				   res_page);
358
-		if (de)
366
+		de = find_in_block(dir, dentry_page, fname, &max_slots);
367
+		if (IS_ERR(de)) {
368
+			*res_page = ERR_CAST(de);
369
+			de = NULL;
359370 			break;
371
+		} else if (de) {
372
+			*res_page = dentry_page;
373
+			break;
374
+		}
360375 
361376 		if (max_slots >= s)
362377 			room = true;
....@@ -464,6 +479,7 @@
464479 		struct page *page, struct inode *inode)
465480 {
466481 	enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA;
482
+
467483 	lock_page(page);
468484 	f2fs_wait_on_page_writeback(page, type, true, true);
469485 	de->ino = cpu_to_le32(inode->i_ino);
....@@ -580,7 +596,7 @@
580596 			goto put_error;
581597 
582598 		if (IS_ENCRYPTED(inode)) {
583
-			err = fscrypt_inherit_context(dir, inode, page, false);
599
+			err = fscrypt_set_context(inode, page);
584600 			if (err)
585601 				goto put_error;
586602 		}
....@@ -753,7 +769,7 @@
753769 	f2fs_wait_on_page_writeback(dentry_page, DATA, true, true);
754770 
755771 	if (inode) {
756
-		down_write(&F2FS_I(inode)->i_sem);
772
+		f2fs_down_write(&F2FS_I(inode)->i_sem);
757773 		page = f2fs_init_inode_metadata(inode, dir, fname, NULL);
758774 		if (IS_ERR(page)) {
759775 			err = PTR_ERR(page);
....@@ -780,7 +796,7 @@
780796 	f2fs_update_parent_metadata(dir, inode, current_depth);
781797 fail:
782798 	if (inode)
783
-		up_write(&F2FS_I(inode)->i_sem);
799
+		f2fs_up_write(&F2FS_I(inode)->i_sem);
784800 
785801 	f2fs_put_page(dentry_page, 1);
786802 
....@@ -818,7 +834,7 @@
818834 		return err;
819835 
820836 	/*
821
-	 * An immature stakable filesystem shows a race condition between lookup
837
+	 * An immature stackable filesystem shows a race condition between lookup
822838 	 * and create. If we have same task when doing lookup and create, it's
823839 	 * definitely fine as expected by VFS normally. Otherwise, let's just
824840 	 * verify on-disk dentry one more time, which guarantees filesystem
....@@ -845,7 +861,7 @@
845861 	struct page *page;
846862 	int err = 0;
847863 
848
-	down_write(&F2FS_I(inode)->i_sem);
864
+	f2fs_down_write(&F2FS_I(inode)->i_sem);
849865 	page = f2fs_init_inode_metadata(inode, dir, NULL, NULL);
850866 	if (IS_ERR(page)) {
851867 		err = PTR_ERR(page);
....@@ -856,7 +872,7 @@
856872 	clear_inode_flag(inode, FI_NEW_INODE);
857873 	f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
858874 fail:
859
-	up_write(&F2FS_I(inode)->i_sem);
875
+	f2fs_up_write(&F2FS_I(inode)->i_sem);
860876 	return err;
861877 }
862878 
....@@ -864,7 +880,7 @@
864880 {
865881 	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
866882 
867
-	down_write(&F2FS_I(inode)->i_sem);
883
+	f2fs_down_write(&F2FS_I(inode)->i_sem);
868884 
869885 	if (S_ISDIR(inode->i_mode))
870886 		f2fs_i_links_write(dir, false);
....@@ -875,7 +891,7 @@
875891 		f2fs_i_links_write(inode, false);
876892 		f2fs_i_size_write(inode, 0);
877893 	}
878
-	up_write(&F2FS_I(inode)->i_sem);
894
+	f2fs_up_write(&F2FS_I(inode)->i_sem);
879895 
880896 	if (inode->i_nlink == 0)
881897 		f2fs_add_orphan_inode(inode);
....@@ -919,13 +935,17 @@
919935 
920936 	if (bit_pos == NR_DENTRY_IN_BLOCK &&
921937 		!f2fs_truncate_hole(dir, page->index, page->index + 1)) {
922
-		f2fs_clear_radix_tree_dirty_tag(page);
938
+		f2fs_clear_page_cache_dirty_tag(page);
923939 		clear_page_dirty_for_io(page);
924
-		f2fs_clear_page_private(page);
925940 		ClearPageUptodate(page);
926
-		clear_cold_data(page);
941
+
942
+		clear_page_private_gcing(page);
943
+
927944 		inode_dec_dirty_pages(dir);
928945 		f2fs_remove_dirty_inode(dir);
946
+
947
+		detach_page_private(page);
948
+		set_page_private(page, 0);
929949 	}
930950 	f2fs_put_page(page, 1);
931951 
....@@ -983,6 +1003,7 @@
9831003 	struct f2fs_sb_info *sbi = F2FS_I_SB(d->inode);
9841004 	struct blk_plug plug;
9851005 	bool readdir_ra = sbi->readdir_ra == 1;
1006
+	bool found_valid_dirent = false;
9861007 	int err = 0;
9871008 
9881009 	bit_pos = ((unsigned long)ctx->pos % d->max);
....@@ -997,13 +1018,15 @@
9971018 
9981019 		de = &d->dentry[bit_pos];
9991020 		if (de->name_len == 0) {
1021
+			if (found_valid_dirent || !bit_pos) {
1022
+				printk_ratelimited(
1023
+					"%sF2FS-fs (%s): invalid namelen(0), ino:%u, run fsck to fix.",
1024
+					KERN_WARNING, sbi->sb->s_id,
1025
+					le32_to_cpu(de->ino));
1026
+				set_sbi_flag(sbi, SBI_NEED_FSCK);
1027
+			}
10001028 			bit_pos++;
10011029 			ctx->pos = start_pos + bit_pos;
1002
-			printk_ratelimited(
1003
-				"%sF2FS-fs (%s): invalid namelen(0), ino:%u, run fsck to fix.",
1004
-				KERN_WARNING, sbi->sb->s_id,
1005
-				le32_to_cpu(de->ino));
1006
-			set_sbi_flag(sbi, SBI_NEED_FSCK);
10071030 			continue;
10081031 		}
10091032 
....@@ -1046,6 +1069,7 @@
10461069 			f2fs_ra_node_page(sbi, le32_to_cpu(de->ino));
10471070 
10481071 		ctx->pos = start_pos + bit_pos;
1072
+		found_valid_dirent = true;
10491073 	}
10501074 out:
10511075 	if (readdir_ra)
....@@ -1067,11 +1091,11 @@
10671091 	int err = 0;
10681092 
10691093 	if (IS_ENCRYPTED(inode)) {
1070
-		err = fscrypt_get_encryption_info(inode);
1094
+		err = fscrypt_prepare_readdir(inode);
10711095 		if (err)
10721096 			goto out;
10731097 
1074
-		err = fscrypt_fname_alloc_buffer(inode, F2FS_NAME_LEN, &fstr);
1098
+		err = fscrypt_fname_alloc_buffer(F2FS_NAME_LEN, &fstr);
10751099 		if (err < 0)
10761100 			goto out;
10771101 	}
....@@ -1126,19 +1150,11 @@
11261150 	return err < 0 ? err : 0;
11271151 }
11281152 
1129
-static int f2fs_dir_open(struct inode *inode, struct file *filp)
1130
-{
1131
-	if (IS_ENCRYPTED(inode))
1132
-		return fscrypt_get_encryption_info(inode) ? -EACCES : 0;
1133
-	return 0;
1134
-}
1135
-
11361153 const struct file_operations f2fs_dir_operations = {
11371154 	.llseek		= generic_file_llseek,
11381155 	.read		= generic_read_dir,
11391156 	.iterate_shared	= f2fs_readdir,
11401157 	.fsync		= f2fs_sync_file,
1141
-	.open		= f2fs_dir_open,
11421158 	.unlocked_ioctl	= f2fs_ioctl,
11431159 #ifdef CONFIG_COMPAT
11441160 	.compat_ioctl   = f2fs_compat_ioctl,