write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/fs/f2fs/namei.c
..
..
@@ -28,6 +28,7 @@
28
28
 	nid_t ino;
29
29
 	struct inode *inode;
30
30
 	bool nid_free = false;
31
+	bool encrypt = false;
31
32
 	int xattr_size = 0;
32
33
 	int err;
33
34
 
..
..
@@ -69,13 +70,17 @@
69
70
 		F2FS_I(inode)->i_projid = make_kprojid(&init_user_ns,
70
71
 							F2FS_DEF_PROJID);
71
72
 
73
+	err = fscrypt_prepare_new_inode(dir, inode, &encrypt);
74
+	if (err)
75
+		goto fail_drop;
76
+
72
77
 	err = dquot_initialize(inode);
73
78
 	if (err)
74
79
 		goto fail_drop;
75
80
 
76
81
 	set_inode_flag(inode, FI_NEW_INODE);
77
82
 
78
-	if (f2fs_may_encrypt(dir, inode))
83
+	if (encrypt)
79
84
 		f2fs_set_encrypted_inode(inode);
80
85
 
81
86
 	if (f2fs_sb_has_extra_attr(sbi)) {
..
..
@@ -86,8 +91,6 @@
86
91
 	if (test_opt(sbi, INLINE_XATTR))
87
92
 		set_inode_flag(inode, FI_INLINE_XATTR);
88
93
 
89
-	if (test_opt(sbi, INLINE_DATA) && f2fs_may_inline_data(inode))
90
-		set_inode_flag(inode, FI_INLINE_DATA);
91
94
 	if (f2fs_may_inline_dentry(inode))
92
95
 		set_inode_flag(inode, FI_INLINE_DENTRY);
93
96
 
..
..
@@ -101,12 +104,6 @@
101
104
 		xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
102
105
 	}
103
106
 	F2FS_I(inode)->i_inline_xattr_size = xattr_size;
104
-
105
-	f2fs_init_extent_tree(inode, NULL);
106
-
107
-	stat_inc_inline_xattr(inode);
108
-	stat_inc_inline_inode(inode);
109
-	stat_inc_inline_dir(inode);
110
107
 
111
108
 	F2FS_I(inode)->i_flags =
112
109
 		f2fs_mask_flags(mode, F2FS_I(dir)->i_flags & F2FS_FL_INHERITED);
..
..
@@ -124,7 +121,17 @@
124
121
 			set_compress_context(inode);
125
122
 	}
126
123
 
124
+	/* Should enable inline_data after compression set */
125
+	if (test_opt(sbi, INLINE_DATA) && f2fs_may_inline_data(inode))
126
+		set_inode_flag(inode, FI_INLINE_DATA);
127
+
128
+	stat_inc_inline_xattr(inode);
129
+	stat_inc_inline_inode(inode);
130
+	stat_inc_inline_dir(inode);
131
+
127
132
 	f2fs_set_inode_flags(inode);
133
+
134
+	f2fs_init_extent_tree(inode);
128
135
 
129
136
 	trace_f2fs_new_inode(inode, 0);
130
137
 	return inode;
..
..
@@ -148,7 +155,8 @@
148
155
 	return ERR_PTR(err);
149
156
 }
150
157
 
151
-static inline int is_extension_exist(const unsigned char *s, const char *sub)
158
+static inline int is_extension_exist(const unsigned char *s, const char *sub,
159
+						bool tmp_ext)
152
160
 {
153
161
 	size_t slen = strlen(s);
154
162
 	size_t sublen = strlen(sub);
..
..
@@ -163,6 +171,13 @@
163
171
 	 */
164
172
 	if (slen < sublen + 2)
165
173
 		return 0;
174
+
175
+	if (!tmp_ext) {
176
+		/* file has no temp extension */
177
+		if (s[slen - sublen - 1] != '.')
178
+			return 0;
179
+		return !strncasecmp(s + slen - sublen, sub, sublen);
180
+	}
166
181
 
167
182
 	for (i = 1; i < slen - sublen; i++) {
168
183
 		if (s[i] != '.')
..
..
@@ -183,17 +198,17 @@
183
198
 	__u8 (*extlist)[F2FS_EXTENSION_LEN] = sbi->raw_super->extension_list;
184
199
 	int i, cold_count, hot_count;
185
200
 
186
-	down_read(&sbi->sb_lock);
201
+	f2fs_down_read(&sbi->sb_lock);
187
202
 
188
203
 	cold_count = le32_to_cpu(sbi->raw_super->extension_count);
189
204
 	hot_count = sbi->raw_super->hot_ext_count;
190
205
 
191
206
 	for (i = 0; i < cold_count + hot_count; i++) {
192
-		if (is_extension_exist(name, extlist[i]))
207
+		if (is_extension_exist(name, extlist[i], true))
193
208
 			break;
194
209
 	}
195
210
 
196
-	up_read(&sbi->sb_lock);
211
+	f2fs_up_read(&sbi->sb_lock);
197
212
 
198
213
 	if (i == cold_count + hot_count)
199
214
 		return;
..
..
@@ -284,26 +299,29 @@
284
299
 			!f2fs_may_compress(inode))
285
300
 		return;
286
301
 
287
-	down_read(&sbi->sb_lock);
302
+	f2fs_down_read(&sbi->sb_lock);
288
303
 
289
304
 	cold_count = le32_to_cpu(sbi->raw_super->extension_count);
290
305
 	hot_count = sbi->raw_super->hot_ext_count;
291
306
 
292
307
 	for (i = cold_count; i < cold_count + hot_count; i++) {
293
-		if (is_extension_exist(name, extlist[i])) {
294
-			up_read(&sbi->sb_lock);
308
+		if (is_extension_exist(name, extlist[i], false)) {
309
+			f2fs_up_read(&sbi->sb_lock);
295
310
 			return;
296
311
 		}
297
312
 	}
298
313
 
299
-	up_read(&sbi->sb_lock);
314
+	f2fs_up_read(&sbi->sb_lock);
300
315
 
301
316
 	ext = F2FS_OPTION(sbi).extensions;
302
317
 
303
318
 	for (i = 0; i < ext_cnt; i++) {
304
-		if (!is_extension_exist(name, ext[i]))
319
+		if (!is_extension_exist(name, ext[i], false))
305
320
 			continue;
306
321
 
322
+		/* Do not use inline_data with compression */
323
+		stat_dec_inline_inode(inode);
324
+		clear_inode_flag(inode, FI_INLINE_DATA);
307
325
 		set_compress_context(inode);
308
326
 		return;
309
327
 	}
..
..
@@ -414,6 +432,7 @@
414
432
 	struct qstr dotdot = QSTR_INIT("..", 2);
415
433
 	struct page *page;
416
434
 	unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot, &page);
435
+
417
436
 	if (!ino) {
418
437
 		if (IS_ERR(page))
419
438
 			return ERR_CAST(page);
..
..
@@ -492,7 +511,7 @@
492
511
 	}
493
512
 
494
513
 	err = f2fs_prepare_lookup(dir, dentry, &fname);
495
-	generic_set_encrypted_ci_d_ops(dir, dentry);
514
+	generic_set_encrypted_ci_d_ops(dentry);
496
515
 	if (err == -ENOENT)
497
516
 		goto out_splice;
498
517
 	if (err)
..
..
@@ -570,15 +589,17 @@
570
589
 
571
590
 	trace_f2fs_unlink_enter(dir, dentry);
572
591
 
573
-	if (unlikely(f2fs_cp_error(sbi)))
574
-		return -EIO;
592
+	if (unlikely(f2fs_cp_error(sbi))) {
593
+		err = -EIO;
594
+		goto fail;
595
+	}
575
596
 
576
597
 	err = dquot_initialize(dir);
577
598
 	if (err)
578
-		return err;
599
+		goto fail;
579
600
 	err = dquot_initialize(inode);
580
601
 	if (err)
581
-		return err;
602
+		goto fail;
582
603
 
583
604
 	de = f2fs_find_entry(dir, &dentry->d_name, &page);
584
605
 	if (!de) {
..
..
@@ -597,18 +618,18 @@
597
618
 		goto fail;
598
619
 	}
599
620
 	f2fs_delete_entry(de, page, dir, inode);
621
+	f2fs_unlock_op(sbi);
622
+
600
623
 #ifdef CONFIG_UNICODE
601
624
 	/* VFS negative dentries are incompatible with Encoding and
602
625
 	 * Case-insensitiveness. Eventually we'll want avoid
603
626
 	 * invalidating the dentries here, alongside with returning the
604
-	 * negative dentries at f2fs_lookup(), when it is  better
627
+	 * negative dentries at f2fs_lookup(), when it is better
605
628
 	 * supported by the VFS for the CI case.
606
629
 	 */
607
630
 	if (IS_CASEFOLDED(dir))
608
631
 		d_invalidate(dentry);
609
632
 #endif
610
-	f2fs_unlock_op(sbi);
611
-
612
633
 	if (IS_DIRSYNC(dir))
613
634
 		f2fs_sync_fs(sbi->sb, 1);
614
635
 fail:
..
..
@@ -621,6 +642,7 @@
621
642
 				 struct delayed_call *done)
622
643
 {
623
644
 	const char *link = page_get_link(dentry, inode, done);
645
+
624
646
 	if (!IS_ERR(link) && !*link) {
625
647
 		/* this is broken symlink case */
626
648
 		do_delayed_call(done);
..
..
@@ -706,7 +728,7 @@
706
728
 	f2fs_handle_failed_inode(inode);
707
729
 out_free_encrypted_link:
708
730
 	if (disk_link.name != (unsigned char *)symname)
709
-		kvfree(disk_link.name);
731
+		kfree(disk_link.name);
710
732
 	return err;
711
733
 }
712
734
 
..
..
@@ -758,6 +780,7 @@
758
780
 static int f2fs_rmdir(struct inode *dir, struct dentry *dentry)
759
781
 {
760
782
 	struct inode *inode = d_inode(dentry);
783
+
761
784
 	if (f2fs_empty_dir(inode))
762
785
 		return f2fs_unlink(dir, dentry);
763
786
 	return -ENOTEMPTY;
..
..
@@ -994,11 +1017,11 @@
994
1017
 		new_page = NULL;
995
1018
 
996
1019
 		new_inode->i_ctime = current_time(new_inode);
997
-		down_write(&F2FS_I(new_inode)->i_sem);
1020
+		f2fs_down_write(&F2FS_I(new_inode)->i_sem);
998
1021
 		if (old_dir_entry)
999
1022
 			f2fs_i_links_write(new_inode, false);
1000
1023
 		f2fs_i_links_write(new_inode, false);
1001
-		up_write(&F2FS_I(new_inode)->i_sem);
1024
+		f2fs_up_write(&F2FS_I(new_inode)->i_sem);
1002
1025
 
1003
1026
 		if (!new_inode->i_nlink)
1004
1027
 			f2fs_add_orphan_inode(new_inode);
..
..
@@ -1019,13 +1042,13 @@
1019
1042
 			f2fs_i_links_write(new_dir, true);
1020
1043
 	}
1021
1044
 
1022
-	down_write(&F2FS_I(old_inode)->i_sem);
1045
+	f2fs_down_write(&F2FS_I(old_inode)->i_sem);
1023
1046
 	if (!old_dir_entry || whiteout)
1024
1047
 		file_lost_pino(old_inode);
1025
1048
 	else
1026
1049
 		/* adjust dir's i_pino to pass fsck check */
1027
1050
 		f2fs_i_pino_write(old_inode, new_dir->i_ino);
1028
-	up_write(&F2FS_I(old_inode)->i_sem);
1051
+	f2fs_up_write(&F2FS_I(old_inode)->i_sem);
1029
1052
 
1030
1053
 	old_inode->i_ctime = current_time(old_inode);
1031
1054
 	f2fs_mark_inode_dirty_sync(old_inode, false);
..
..
@@ -1185,38 +1208,38 @@
1185
1208
 	/* update directory entry info of old dir inode */
1186
1209
 	f2fs_set_link(old_dir, old_entry, old_page, new_inode);
1187
1210
 
1188
-	down_write(&F2FS_I(old_inode)->i_sem);
1211
+	f2fs_down_write(&F2FS_I(old_inode)->i_sem);
1189
1212
 	if (!old_dir_entry)
1190
1213
 		file_lost_pino(old_inode);
1191
1214
 	else
1192
1215
 		/* adjust dir's i_pino to pass fsck check */
1193
1216
 		f2fs_i_pino_write(old_inode, new_dir->i_ino);
1194
-	up_write(&F2FS_I(old_inode)->i_sem);
1217
+	f2fs_up_write(&F2FS_I(old_inode)->i_sem);
1195
1218
 
1196
1219
 	old_dir->i_ctime = current_time(old_dir);
1197
1220
 	if (old_nlink) {
1198
-		down_write(&F2FS_I(old_dir)->i_sem);
1221
+		f2fs_down_write(&F2FS_I(old_dir)->i_sem);
1199
1222
 		f2fs_i_links_write(old_dir, old_nlink > 0);
1200
-		up_write(&F2FS_I(old_dir)->i_sem);
1223
+		f2fs_up_write(&F2FS_I(old_dir)->i_sem);
1201
1224
 	}
1202
1225
 	f2fs_mark_inode_dirty_sync(old_dir, false);
1203
1226
 
1204
1227
 	/* update directory entry info of new dir inode */
1205
1228
 	f2fs_set_link(new_dir, new_entry, new_page, old_inode);
1206
1229
 
1207
-	down_write(&F2FS_I(new_inode)->i_sem);
1230
+	f2fs_down_write(&F2FS_I(new_inode)->i_sem);
1208
1231
 	if (!new_dir_entry)
1209
1232
 		file_lost_pino(new_inode);
1210
1233
 	else
1211
1234
 		/* adjust dir's i_pino to pass fsck check */
1212
1235
 		f2fs_i_pino_write(new_inode, old_dir->i_ino);
1213
-	up_write(&F2FS_I(new_inode)->i_sem);
1236
+	f2fs_up_write(&F2FS_I(new_inode)->i_sem);
1214
1237
 
1215
1238
 	new_dir->i_ctime = current_time(new_dir);
1216
1239
 	if (new_nlink) {
1217
-		down_write(&F2FS_I(new_dir)->i_sem);
1240
+		f2fs_down_write(&F2FS_I(new_dir)->i_sem);
1218
1241
 		f2fs_i_links_write(new_dir, new_nlink > 0);
1219
-		up_write(&F2FS_I(new_dir)->i_sem);
1242
+		f2fs_up_write(&F2FS_I(new_dir)->i_sem);
1220
1243
 	}
1221
1244
 	f2fs_mark_inode_dirty_sync(new_dir, false);
1222
1245
 
..
..
@@ -1303,7 +1326,7 @@
1303
1326
 }
1304
1327
 
1305
1328
 const struct inode_operations f2fs_encrypted_symlink_inode_operations = {
1306
-	.get_link       = f2fs_encrypted_get_link,
1329
+	.get_link	= f2fs_encrypted_get_link,
1307
1330
 	.getattr	= f2fs_encrypted_symlink_getattr,
1308
1331
 	.setattr	= f2fs_setattr,
1309
1332
 	.listxattr	= f2fs_listxattr,
..
..
@@ -1329,7 +1352,7 @@
1329
1352
 };
1330
1353
 
1331
1354
 const struct inode_operations f2fs_symlink_inode_operations = {
1332
-	.get_link       = f2fs_get_link,
1355
+	.get_link	= f2fs_get_link,
1333
1356
 	.getattr	= f2fs_getattr,
1334
1357
 	.setattr	= f2fs_setattr,
1335
1358
 	.listxattr	= f2fs_listxattr,
..
..
@@ -1337,7 +1360,7 @@
1337
1360
 
1338
1361
 const struct inode_operations f2fs_special_inode_operations = {
1339
1362
 	.getattr	= f2fs_getattr,
1340
-	.setattr        = f2fs_setattr,
1363
+	.setattr	= f2fs_setattr,
1341
1364
 	.get_acl	= f2fs_get_acl,
1342
1365
 	.set_acl	= f2fs_set_acl,
1343
1366
 	.listxattr	= f2fs_listxattr,