add boot partition size

hc

2023-12-11 d2ccde1c8e90d38cee87a1b0309ad2827f3fd30d

 kernel/arch/arm64/crypto/sha2-ce-glue.c
..
..
@@ -1,17 +1,15 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * sha2-ce-glue.c - SHA-224/SHA-256 using ARMv8 Crypto Extensions
3
4
  *
4
5
  * Copyright (C) 2014 - 2017 Linaro Ltd <ard.biesheuvel@linaro.org>
5
- *
6
- * This program is free software; you can redistribute it and/or modify
7
- * it under the terms of the GNU General Public License version 2 as
8
- * published by the Free Software Foundation.
9
6
  */
10
7
 
11
8
 #include <asm/neon.h>
12
9
 #include <asm/simd.h>
13
10
 #include <asm/unaligned.h>
14
11
 #include <crypto/internal/hash.h>
12
+#include <crypto/internal/simd.h>
15
13
 #include <crypto/sha.h>
16
14
 #include <crypto/sha256_base.h>
17
15
 #include <linux/cpufeature.h>
..
..
@@ -29,16 +27,26 @@
29
27
 	u32			finalize;
30
28
 };
31
29
 
32
-asmlinkage void sha2_ce_transform(struct sha256_ce_state *sst, u8 const *src,
33
-				  int blocks);
34
-#ifdef CONFIG_CFI_CLANG
35
-static inline void __cfi_sha2_ce_transform(struct sha256_state *sst,
36
-					   u8 const *src, int blocks)
30
+extern const u32 sha256_ce_offsetof_count;
31
+extern const u32 sha256_ce_offsetof_finalize;
32
+
33
+asmlinkage int sha2_ce_transform(struct sha256_ce_state *sst, u8 const *src,
34
+				 int blocks);
35
+
36
+static void __sha2_ce_transform(struct sha256_state *sst, u8 const *src,
37
+				int blocks)
37
38
 {
38
-	sha2_ce_transform((struct sha256_ce_state *)sst, src, blocks);
39
+	while (blocks) {
40
+		int rem;
41
+
42
+		kernel_neon_begin();
43
+		rem = sha2_ce_transform(container_of(sst, struct sha256_ce_state,
44
+						     sst), src, blocks);
45
+		kernel_neon_end();
46
+		src += (blocks - rem) * SHA256_BLOCK_SIZE;
47
+		blocks = rem;
48
+	}
39
49
 }
40
-#define sha2_ce_transform __cfi_sha2_ce_transform
41
-#endif
42
50
 
43
51
 const u32 sha256_ce_offsetof_count = offsetof(struct sha256_ce_state,
44
52
 					      sst.count);
..
..
@@ -47,20 +55,23 @@
47
55
 
48
56
 asmlinkage void sha256_block_data_order(u32 *digest, u8 const *src, int blocks);
49
57
 
58
+static void __sha256_block_data_order(struct sha256_state *sst, u8 const *src,
59
+				      int blocks)
60
+{
61
+	sha256_block_data_order(sst->state, src, blocks);
62
+}
63
+
50
64
 static int sha256_ce_update(struct shash_desc *desc, const u8 *data,
51
65
 			    unsigned int len)
52
66
 {
53
67
 	struct sha256_ce_state *sctx = shash_desc_ctx(desc);
54
68
 
55
-	if (!may_use_simd())
69
+	if (!crypto_simd_usable())
56
70
 		return sha256_base_do_update(desc, data, len,
57
-				(sha256_block_fn *)sha256_block_data_order);
71
+				__sha256_block_data_order);
58
72
 
59
73
 	sctx->finalize = 0;
60
-	kernel_neon_begin();
61
-	sha256_base_do_update(desc, data, len,
62
-			      (sha256_block_fn *)sha2_ce_transform);
63
-	kernel_neon_end();
74
+	sha256_base_do_update(desc, data, len, __sha2_ce_transform);
64
75
 
65
76
 	return 0;
66
77
 }
..
..
@@ -71,12 +82,11 @@
71
82
 	struct sha256_ce_state *sctx = shash_desc_ctx(desc);
72
83
 	bool finalize = !sctx->sst.count && !(len % SHA256_BLOCK_SIZE) && len;
73
84
 
74
-	if (!may_use_simd()) {
85
+	if (!crypto_simd_usable()) {
75
86
 		if (len)
76
87
 			sha256_base_do_update(desc, data, len,
77
-				(sha256_block_fn *)sha256_block_data_order);
78
-		sha256_base_do_finalize(desc,
79
-				(sha256_block_fn *)sha256_block_data_order);
88
+				__sha256_block_data_order);
89
+		sha256_base_do_finalize(desc, __sha256_block_data_order);
80
90
 		return sha256_base_finish(desc, out);
81
91
 	}
82
92
 
..
..
@@ -86,13 +96,9 @@
86
96
 	 */
87
97
 	sctx->finalize = finalize;
88
98
 
89
-	kernel_neon_begin();
90
-	sha256_base_do_update(desc, data, len,
91
-			      (sha256_block_fn *)sha2_ce_transform);
99
+	sha256_base_do_update(desc, data, len, __sha2_ce_transform);
92
100
 	if (!finalize)
93
-		sha256_base_do_finalize(desc,
94
-					(sha256_block_fn *)sha2_ce_transform);
95
-	kernel_neon_end();
101
+		sha256_base_do_finalize(desc, __sha2_ce_transform);
96
102
 	return sha256_base_finish(desc, out);
97
103
 }
98
104
 
..
..
@@ -100,17 +106,31 @@
100
106
 {
101
107
 	struct sha256_ce_state *sctx = shash_desc_ctx(desc);
102
108
 
103
-	if (!may_use_simd()) {
104
-		sha256_base_do_finalize(desc,
105
-				(sha256_block_fn *)sha256_block_data_order);
109
+	if (!crypto_simd_usable()) {
110
+		sha256_base_do_finalize(desc, __sha256_block_data_order);
106
111
 		return sha256_base_finish(desc, out);
107
112
 	}
108
113
 
109
114
 	sctx->finalize = 0;
110
-	kernel_neon_begin();
111
-	sha256_base_do_finalize(desc, (sha256_block_fn *)sha2_ce_transform);
112
-	kernel_neon_end();
115
+	sha256_base_do_finalize(desc, __sha2_ce_transform);
113
116
 	return sha256_base_finish(desc, out);
117
+}
118
+
119
+static int sha256_ce_export(struct shash_desc *desc, void *out)
120
+{
121
+	struct sha256_ce_state *sctx = shash_desc_ctx(desc);
122
+
123
+	memcpy(out, &sctx->sst, sizeof(struct sha256_state));
124
+	return 0;
125
+}
126
+
127
+static int sha256_ce_import(struct shash_desc *desc, const void *in)
128
+{
129
+	struct sha256_ce_state *sctx = shash_desc_ctx(desc);
130
+
131
+	memcpy(&sctx->sst, in, sizeof(struct sha256_state));
132
+	sctx->finalize = 0;
133
+	return 0;
114
134
 }
115
135
 
116
136
 static struct shash_alg algs[] = { {
..
..
@@ -118,7 +138,10 @@
118
138
 	.update			= sha256_ce_update,
119
139
 	.final			= sha256_ce_final,
120
140
 	.finup			= sha256_ce_finup,
141
+	.export			= sha256_ce_export,
142
+	.import			= sha256_ce_import,
121
143
 	.descsize		= sizeof(struct sha256_ce_state),
144
+	.statesize		= sizeof(struct sha256_state),
122
145
 	.digestsize		= SHA224_DIGEST_SIZE,
123
146
 	.base			= {
124
147
 		.cra_name		= "sha224",
..
..
@@ -132,7 +155,10 @@
132
155
 	.update			= sha256_ce_update,
133
156
 	.final			= sha256_ce_final,
134
157
 	.finup			= sha256_ce_finup,
158
+	.export			= sha256_ce_export,
159
+	.import			= sha256_ce_import,
135
160
 	.descsize		= sizeof(struct sha256_ce_state),
161
+	.statesize		= sizeof(struct sha256_state),
136
162
 	.digestsize		= SHA256_DIGEST_SIZE,
137
163
 	.base			= {
138
164
 		.cra_name		= "sha256",