change wifi driver to cypress

hc

2024-01-05 071106ecf68c401173c58808b1cf5f68cc50d390

 kernel/fs/f2fs/inode.c
..
..
@@ -18,6 +18,10 @@
18
18
 
19
19
 #include <trace/events/f2fs.h>
20
20
 
21
+#ifdef CONFIG_F2FS_FS_COMPRESSION
22
+extern const struct address_space_operations f2fs_compress_aops;
23
+#endif
24
+
21
25
 void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)
22
26
 {
23
27
 	if (is_inode_flag_set(inode, FI_NEW_INODE))
..
..
@@ -256,8 +260,8 @@
256
260
 		return false;
257
261
 	}
258
262
 
259
-	if (F2FS_I(inode)->extent_tree) {
260
-		struct extent_info *ei = &F2FS_I(inode)->extent_tree->largest;
263
+	if (fi->extent_tree[EX_READ]) {
264
+		struct extent_info *ei = &fi->extent_tree[EX_READ]->largest;
261
265
 
262
266
 		if (ei->len &&
263
267
 			(!f2fs_is_valid_blkaddr(sbi, ei->blk,
..
..
@@ -272,8 +276,7 @@
272
276
 		}
273
277
 	}
274
278
 
275
-	if (f2fs_has_inline_data(inode) &&
276
-			(!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))) {
279
+	if (f2fs_sanity_check_inline_data(inode)) {
277
280
 		set_sbi_flag(sbi, SBI_NEED_FSCK);
278
281
 		f2fs_warn(sbi, "%s: inode (ino=%lx, mode=%u) should not have inline_data, run fsck to fix",
279
282
 			  __func__, inode->i_ino, inode->i_mode);
..
..
@@ -287,11 +290,19 @@
287
290
 		return false;
288
291
 	}
289
292
 
293
+	if ((fi->i_flags & F2FS_CASEFOLD_FL) && !f2fs_sb_has_casefold(sbi)) {
294
+		set_sbi_flag(sbi, SBI_NEED_FSCK);
295
+		f2fs_warn(sbi, "%s: inode (ino=%lx) has casefold flag, but casefold feature is off",
296
+			  __func__, inode->i_ino);
297
+		return false;
298
+	}
299
+
290
300
 	if (f2fs_has_extra_attr(inode) && f2fs_sb_has_compression(sbi) &&
291
301
 			fi->i_flags & F2FS_COMPR_FL &&
292
302
 			F2FS_FITS_IN_INODE(ri, fi->i_extra_isize,
293
303
 						i_log_cluster_size)) {
294
304
 		if (ri->i_compress_algorithm >= COMPRESS_MAX) {
305
+			set_sbi_flag(sbi, SBI_NEED_FSCK);
295
306
 			f2fs_warn(sbi, "%s: inode (ino=%lx) has unsupported "
296
307
 				"compress algorithm: %u, run fsck to fix",
297
308
 				  __func__, inode->i_ino,
..
..
@@ -300,15 +311,17 @@
300
311
 		}
301
312
 		if (le64_to_cpu(ri->i_compr_blocks) >
302
313
 				SECTOR_TO_BLOCK(inode->i_blocks)) {
314
+			set_sbi_flag(sbi, SBI_NEED_FSCK);
303
315
 			f2fs_warn(sbi, "%s: inode (ino=%lx) has inconsistent "
304
316
 				"i_compr_blocks:%llu, i_blocks:%llu, run fsck to fix",
305
317
 				  __func__, inode->i_ino,
306
318
 				  le64_to_cpu(ri->i_compr_blocks),
307
-				  (u64)SECTOR_TO_BLOCK(inode->i_blocks));
319
+				  SECTOR_TO_BLOCK(inode->i_blocks));
308
320
 			return false;
309
321
 		}
310
322
 		if (ri->i_log_cluster_size < MIN_COMPRESS_LOG_SIZE ||
311
323
 			ri->i_log_cluster_size > MAX_COMPRESS_LOG_SIZE) {
324
+			set_sbi_flag(sbi, SBI_NEED_FSCK);
312
325
 			f2fs_warn(sbi, "%s: inode (ino=%lx) has unsupported "
313
326
 				"log cluster size: %u, run fsck to fix",
314
327
 				  __func__, inode->i_ino,
..
..
@@ -367,9 +380,6 @@
367
380
 	fi->i_pino = le32_to_cpu(ri->i_pino);
368
381
 	fi->i_dir_level = ri->i_dir_level;
369
382
 
370
-	if (f2fs_init_extent_tree(inode, &ri->i_ext))
371
-		set_page_dirty(node_page);
372
-
373
383
 	get_inline_info(inode, ri);
374
384
 
375
385
 	fi->i_extra_isize = f2fs_has_extra_attr(inode) ?
..
..
@@ -391,17 +401,13 @@
391
401
 		fi->i_inline_xattr_size = 0;
392
402
 	}
393
403
 
394
-	if (!sanity_check_inode(inode, node_page)) {
395
-		f2fs_put_page(node_page, 1);
396
-		return -EFSCORRUPTED;
397
-	}
398
-
399
404
 	/* check data exist */
400
405
 	if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode))
401
406
 		__recover_inline_status(inode, node_page);
402
407
 
403
408
 	/* try to recover cold bit for non-dir inode */
404
409
 	if (!S_ISDIR(inode->i_mode) && !is_cold_node(node_page)) {
410
+		f2fs_wait_on_page_writeback(node_page, NODE, true, true);
405
411
 		set_cold_node(node_page, false);
406
412
 		set_page_dirty(node_page);
407
413
 	}
..
..
@@ -442,9 +448,11 @@
442
448
 					(fi->i_flags & F2FS_COMPR_FL)) {
443
449
 		if (F2FS_FITS_IN_INODE(ri, fi->i_extra_isize,
444
450
 					i_log_cluster_size)) {
445
-			fi->i_compr_blocks = le64_to_cpu(ri->i_compr_blocks);
451
+			atomic_set(&fi->i_compr_blocks,
452
+					le64_to_cpu(ri->i_compr_blocks));
446
453
 			fi->i_compress_algorithm = ri->i_compress_algorithm;
447
454
 			fi->i_log_cluster_size = ri->i_log_cluster_size;
455
+			fi->i_compress_flag = le16_to_cpu(ri->i_compress_flag);
448
456
 			fi->i_cluster_size = 1 << fi->i_log_cluster_size;
449
457
 			set_inode_flag(inode, FI_COMPRESSED_FILE);
450
458
 		}
..
..
@@ -454,13 +462,23 @@
454
462
 	F2FS_I(inode)->i_disk_time[1] = inode->i_ctime;
455
463
 	F2FS_I(inode)->i_disk_time[2] = inode->i_mtime;
456
464
 	F2FS_I(inode)->i_disk_time[3] = F2FS_I(inode)->i_crtime;
465
+
466
+	/* Need all the flag bits */
467
+	f2fs_init_read_extent_tree(inode, node_page);
468
+	f2fs_init_age_extent_tree(inode);
469
+
470
+	if (!sanity_check_inode(inode, node_page)) {
471
+		f2fs_put_page(node_page, 1);
472
+		return -EFSCORRUPTED;
473
+	}
474
+
457
475
 	f2fs_put_page(node_page, 1);
458
476
 
459
477
 	stat_inc_inline_xattr(inode);
460
478
 	stat_inc_inline_inode(inode);
461
479
 	stat_inc_inline_dir(inode);
462
480
 	stat_inc_compr_inode(inode);
463
-	stat_add_compr_blocks(inode, F2FS_I(inode)->i_compr_blocks);
481
+	stat_add_compr_blocks(inode, atomic_read(&fi->i_compr_blocks));
464
482
 
465
483
 	return 0;
466
484
 }
..
..
@@ -482,6 +500,11 @@
482
500
 	if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi))
483
501
 		goto make_now;
484
502
 
503
+#ifdef CONFIG_F2FS_FS_COMPRESSION
504
+	if (ino == F2FS_COMPRESS_INO(sbi))
505
+		goto make_now;
506
+#endif
507
+
485
508
 	ret = do_read_inode(inode);
486
509
 	if (ret)
487
510
 		goto bad_inode;
..
..
@@ -492,6 +515,12 @@
492
515
 	} else if (ino == F2FS_META_INO(sbi)) {
493
516
 		inode->i_mapping->a_ops = &f2fs_meta_aops;
494
517
 		mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
518
+	} else if (ino == F2FS_COMPRESS_INO(sbi)) {
519
+#ifdef CONFIG_F2FS_FS_COMPRESSION
520
+		inode->i_mapping->a_ops = &f2fs_compress_aops;
521
+#endif
522
+		mapping_set_gfp_mask(inode->i_mapping,
523
+			GFP_NOFS | __GFP_HIGHMEM | __GFP_MOVABLE);
495
524
 	} else if (S_ISREG(inode->i_mode)) {
496
525
 		inode->i_op = &f2fs_file_inode_operations;
497
526
 		inode->i_fop = &f2fs_file_operations;
..
..
@@ -545,7 +574,7 @@
545
574
 void f2fs_update_inode(struct inode *inode, struct page *node_page)
546
575
 {
547
576
 	struct f2fs_inode *ri;
548
-	struct extent_tree *et = F2FS_I(inode)->extent_tree;
577
+	struct extent_tree *et = F2FS_I(inode)->extent_tree[EX_READ];
549
578
 
550
579
 	f2fs_wait_on_page_writeback(node_page, NODE, true, true);
551
580
 	set_page_dirty(node_page);
..
..
@@ -564,7 +593,7 @@
564
593
 
565
594
 	if (et) {
566
595
 		read_lock(&et->lock);
567
-		set_raw_extent(&et->largest, &ri->i_ext);
596
+		set_raw_read_extent(&et->largest, &ri->i_ext);
568
597
 		read_unlock(&et->lock);
569
598
 	} else {
570
599
 		memset(&ri->i_ext, 0, sizeof(ri->i_ext));
..
..
@@ -619,9 +648,12 @@
619
648
 			F2FS_FITS_IN_INODE(ri, F2FS_I(inode)->i_extra_isize,
620
649
 							i_log_cluster_size)) {
621
650
 			ri->i_compr_blocks =
622
-				cpu_to_le64(F2FS_I(inode)->i_compr_blocks);
651
+				cpu_to_le64(atomic_read(
652
+					&F2FS_I(inode)->i_compr_blocks));
623
653
 			ri->i_compress_algorithm =
624
654
 				F2FS_I(inode)->i_compress_algorithm;
655
+			ri->i_compress_flag =
656
+				cpu_to_le16(F2FS_I(inode)->i_compress_flag);
625
657
 			ri->i_log_cluster_size =
626
658
 				F2FS_I(inode)->i_log_cluster_size;
627
659
 		}
..
..
@@ -631,7 +663,7 @@
631
663
 
632
664
 	/* deleted inode */
633
665
 	if (inode->i_nlink == 0)
634
-		clear_inline_node(node_page);
666
+		clear_page_private_inline(node_page);
635
667
 
636
668
 	F2FS_I(inode)->i_disk_time[0] = inode->i_atime;
637
669
 	F2FS_I(inode)->i_disk_time[1] = inode->i_ctime;
..
..
@@ -651,11 +683,13 @@
651
683
 	node_page = f2fs_get_node_page(sbi, inode->i_ino);
652
684
 	if (IS_ERR(node_page)) {
653
685
 		int err = PTR_ERR(node_page);
686
+
654
687
 		if (err == -ENOMEM) {
655
688
 			cond_resched();
656
689
 			goto retry;
657
690
 		} else if (err != -ENOENT) {
658
-			f2fs_stop_checkpoint(sbi, false);
691
+			f2fs_stop_checkpoint(sbi, false,
692
+					STOP_CP_REASON_UPDATE_INODE);
659
693
 		}
660
694
 		return;
661
695
 	}
..
..
@@ -683,7 +717,7 @@
683
717
 
684
718
 	/*
685
719
 	 * We need to balance fs here to prevent from producing dirty node pages
686
-	 * during the urgent cleaning time when runing out of free sections.
720
+	 * during the urgent cleaning time when running out of free sections.
687
721
 	 */
688
722
 	f2fs_update_inode_page(inode);
689
723
 	if (wbc && wbc->nr_to_write)
..
..
@@ -707,8 +741,12 @@
707
741
 	trace_f2fs_evict_inode(inode);
708
742
 	truncate_inode_pages_final(&inode->i_data);
709
743
 
744
+	if (test_opt(sbi, COMPRESS_CACHE) && f2fs_compressed_file(inode))
745
+		f2fs_invalidate_compress_pages(sbi, inode->i_ino);
746
+
710
747
 	if (inode->i_ino == F2FS_NODE_INO(sbi) ||
711
-			inode->i_ino == F2FS_META_INO(sbi))
748
+			inode->i_ino == F2FS_META_INO(sbi) ||
749
+			inode->i_ino == F2FS_COMPRESS_INO(sbi))
712
750
 		goto out_clear;
713
751
 
714
752
 	f2fs_bug_on(sbi, get_dirty_pages(inode));
..
..
@@ -729,7 +767,8 @@
729
767
 	f2fs_remove_ino_entry(sbi, inode->i_ino, UPDATE_INO);
730
768
 	f2fs_remove_ino_entry(sbi, inode->i_ino, FLUSH_INO);
731
769
 
732
-	sb_start_intwrite(inode->i_sb);
770
+	if (!is_sbi_flag_set(sbi, SBI_IS_FREEZING))
771
+		sb_start_intwrite(inode->i_sb);
733
772
 	set_inode_flag(inode, FI_NO_ALLOC);
734
773
 	i_size_write(inode, 0);
735
774
 retry:
..
..
@@ -745,8 +784,22 @@
745
784
 		f2fs_lock_op(sbi);
746
785
 		err = f2fs_remove_inode_page(inode);
747
786
 		f2fs_unlock_op(sbi);
748
-		if (err == -ENOENT)
787
+		if (err == -ENOENT) {
749
788
 			err = 0;
789
+
790
+			/*
791
+			 * in fuzzed image, another node may has the same
792
+			 * block address as inode's, if it was truncated
793
+			 * previously, truncation of inode node will fail.
794
+			 */
795
+			if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
796
+				f2fs_warn(F2FS_I_SB(inode),
797
+					"f2fs_evict_inode: inconsistent node id, ino:%lu",
798
+					inode->i_ino);
799
+				f2fs_inode_synced(inode);
800
+				set_sbi_flag(sbi, SBI_NEED_FSCK);
801
+			}
802
+		}
750
803
 	}
751
804
 
752
805
 	/* give more chances, if ENOMEM case */
..
..
@@ -760,7 +813,8 @@
760
813
 		if (dquot_initialize_needed(inode))
761
814
 			set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
762
815
 	}
763
-	sb_end_intwrite(inode->i_sb);
816
+	if (!is_sbi_flag_set(sbi, SBI_IS_FREEZING))
817
+		sb_end_intwrite(inode->i_sb);
764
818
 no_delete:
765
819
 	dquot_drop(inode);
766
820
 
..
..
@@ -768,7 +822,8 @@
768
822
 	stat_dec_inline_dir(inode);
769
823
 	stat_dec_inline_inode(inode);
770
824
 	stat_dec_compr_inode(inode);
771
-	stat_sub_compr_blocks(inode, F2FS_I(inode)->i_compr_blocks);
825
+	stat_sub_compr_blocks(inode,
826
+			atomic_read(&F2FS_I(inode)->i_compr_blocks));
772
827
 
773
828
 	if (likely(!f2fs_cp_error(sbi) &&
774
829
 				!is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
..
..
@@ -832,9 +887,10 @@
832
887
 	 * so we can prevent losing this orphan when encoutering checkpoint
833
888
 	 * and following suddenly power-off.
834
889
 	 */
835
-	err = f2fs_get_node_info(sbi, inode->i_ino, &ni);
890
+	err = f2fs_get_node_info(sbi, inode->i_ino, &ni, false);
836
891
 	if (err) {
837
892
 		set_sbi_flag(sbi, SBI_NEED_FSCK);
893
+		set_inode_flag(inode, FI_FREE_NID);
838
894
 		f2fs_warn(sbi, "May loss orphan inode, run fsck to fix.");
839
895
 		goto out;
840
896
 	}