export RK_PA3

hc

2024-02-19 151fecfb72a0d602dfe79790602ef64b4e241574

 kernel/fs/crypto/bio.c
..
..
@@ -29,9 +29,9 @@
29
29
 void fscrypt_decrypt_bio(struct bio *bio)
30
30
 {
31
31
 	struct bio_vec *bv;
32
-	int i;
32
+	struct bvec_iter_all iter_all;
33
33
 
34
-	bio_for_each_segment_all(bv, bio, i) {
34
+	bio_for_each_segment_all(bv, bio, iter_all) {
35
35
 		struct page *page = bv->bv_page;
36
36
 		int ret = fscrypt_decrypt_pagecache_blocks(page, bv->bv_len,
37
37
 							   bv->bv_offset);
..
..
@@ -41,51 +41,48 @@
41
41
 }
42
42
 EXPORT_SYMBOL(fscrypt_decrypt_bio);
43
43
 
44
-static int fscrypt_zeroout_range_inlinecrypt(const struct inode *inode,
45
-					     pgoff_t lblk,
46
-					     sector_t pblk, unsigned int len)
44
+static int fscrypt_zeroout_range_inline_crypt(const struct inode *inode,
45
+					      pgoff_t lblk, sector_t pblk,
46
+					      unsigned int len)
47
47
 {
48
48
 	const unsigned int blockbits = inode->i_blkbits;
49
-	const unsigned int blocks_per_page_bits = PAGE_SHIFT - blockbits;
50
-	const unsigned int blocks_per_page = 1 << blocks_per_page_bits;
51
-	unsigned int i;
49
+	const unsigned int blocks_per_page = 1 << (PAGE_SHIFT - blockbits);
52
50
 	struct bio *bio;
53
-	int ret, err;
51
+	int ret, err = 0;
52
+	int num_pages = 0;
54
53
 
55
54
 	/* This always succeeds since __GFP_DIRECT_RECLAIM is set. */
56
55
 	bio = bio_alloc(GFP_NOFS, BIO_MAX_PAGES);
57
56
 
58
-	do {
59
-		bio_set_dev(bio, inode->i_sb->s_bdev);
60
-		bio->bi_iter.bi_sector = pblk << (blockbits - 9);
61
-		bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
62
-		fscrypt_set_bio_crypt_ctx(bio, inode, lblk, GFP_NOFS);
57
+	while (len) {
58
+		unsigned int blocks_this_page = min(len, blocks_per_page);
59
+		unsigned int bytes_this_page = blocks_this_page << blockbits;
63
60
 
64
-		i = 0;
65
-		do {
66
-			unsigned int blocks_this_page =
67
-				min(len, blocks_per_page);
68
-			unsigned int bytes_this_page =
69
-				blocks_this_page << blockbits;
70
-
71
-			ret = bio_add_page(bio, ZERO_PAGE(0),
72
-					   bytes_this_page, 0);
73
-			if (WARN_ON(ret != bytes_this_page)) {
74
-				err = -EIO;
75
-				goto out;
76
-			}
77
-			lblk += blocks_this_page;
78
-			pblk += blocks_this_page;
79
-			len -= blocks_this_page;
80
-		} while (++i != BIO_MAX_PAGES && len != 0 &&
81
-			 fscrypt_mergeable_bio(bio, inode, lblk));
82
-
83
-		err = submit_bio_wait(bio);
84
-		if (err)
61
+		if (num_pages == 0) {
62
+			fscrypt_set_bio_crypt_ctx(bio, inode, lblk, GFP_NOFS);
63
+			bio_set_dev(bio, inode->i_sb->s_bdev);
64
+			bio->bi_iter.bi_sector =
65
+					pblk << (blockbits - SECTOR_SHIFT);
66
+			bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
67
+		}
68
+		ret = bio_add_page(bio, ZERO_PAGE(0), bytes_this_page, 0);
69
+		if (WARN_ON(ret != bytes_this_page)) {
70
+			err = -EIO;
85
71
 			goto out;
86
-		bio_reset(bio);
87
-	} while (len != 0);
88
-	err = 0;
72
+		}
73
+		num_pages++;
74
+		len -= blocks_this_page;
75
+		lblk += blocks_this_page;
76
+		pblk += blocks_this_page;
77
+		if (num_pages == BIO_MAX_PAGES || !len ||
78
+		    !fscrypt_mergeable_bio(bio, inode, lblk)) {
79
+			err = submit_bio_wait(bio);
80
+			if (err)
81
+				goto out;
82
+			bio_reset(bio);
83
+			num_pages = 0;
84
+		}
85
+	}
89
86
 out:
90
87
 	bio_put(bio);
91
88
 	return err;
..
..
@@ -126,8 +123,8 @@
126
123
 		return 0;
127
124
 
128
125
 	if (fscrypt_inode_uses_inline_crypto(inode))
129
-		return fscrypt_zeroout_range_inlinecrypt(inode, lblk, pblk,
130
-							 len);
126
+		return fscrypt_zeroout_range_inline_crypt(inode, lblk, pblk,
127
+							  len);
131
128
 
132
129
 	BUILD_BUG_ON(ARRAY_SIZE(pages) > BIO_MAX_PAGES);
133
130
 	nr_pages = min_t(unsigned int, ARRAY_SIZE(pages),