Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
crypto: arm64 - use the new scatterwalk functions
Use scatterwalk_next() which consolidates scatterwalk_clamp() and
scatterwalk_map(), and use scatterwalk_done_src() which consolidates
scatterwalk_unmap(), scatterwalk_advance(), and scatterwalk_done().
Remove unnecessary code that seemed to be intended to advance to the
next sg entry, which is already handled by the scatterwalk functions.
Adjust variable naming slightly to keep things consistent.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
authored by
Eric Biggers
and committed by
Herbert Xu
8fd0eecd
5dc14e0b
+32
-59
+4
-13
arch/arm64/crypto/aes-ce-ccm-glue.c
+4
-13
arch/arm64/crypto/aes-ce-ccm-glue.c
···
156
156
scatterwalk_start(&walk, req->src);
157
157
158
158
do {
159
-
u32 n = scatterwalk_clamp(&walk, len);
160
-
u8 *p;
159
+
unsigned int n;
160
+
const u8 *p;
161
161
162
-
if (!n) {
163
-
scatterwalk_start(&walk, sg_next(walk.sg));
164
-
n = scatterwalk_clamp(&walk, len);
165
-
}
166
-
p = scatterwalk_map(&walk);
167
-
162
+
p = scatterwalk_next(&walk, len, &n);
168
163
macp = ce_aes_ccm_auth_data(mac, p, n, macp, ctx->key_enc,
169
164
num_rounds(ctx));
170
-
165
+
scatterwalk_done_src(&walk, p, n);
171
166
len -= n;
172
-
173
-
scatterwalk_unmap(p);
174
-
scatterwalk_advance(&walk, n);
175
-
scatterwalk_done(&walk, 0, len);
176
167
} while (len);
177
168
}
178
169
+4
-12
arch/arm64/crypto/ghash-ce-glue.c
+4
-12
arch/arm64/crypto/ghash-ce-glue.c
···
308
308
scatterwalk_start(&walk, req->src);
309
309
310
310
do {
311
-
u32 n = scatterwalk_clamp(&walk, len);
312
-
u8 *p;
311
+
unsigned int n;
312
+
const u8 *p;
313
313
314
-
if (!n) {
315
-
scatterwalk_start(&walk, sg_next(walk.sg));
316
-
n = scatterwalk_clamp(&walk, len);
317
-
}
318
-
p = scatterwalk_map(&walk);
319
-
314
+
p = scatterwalk_next(&walk, len, &n);
320
315
gcm_update_mac(dg, p, n, buf, &buf_count, ctx);
316
+
scatterwalk_done_src(&walk, p, n);
321
317
len -= n;
322
-
323
-
scatterwalk_unmap(p);
324
-
scatterwalk_advance(&walk, n);
325
-
scatterwalk_done(&walk, 0, len);
326
318
} while (len);
327
319
328
320
if (buf_count) {
+11
-16
arch/arm64/crypto/sm4-ce-ccm-glue.c
+11
-16
arch/arm64/crypto/sm4-ce-ccm-glue.c
···
112
112
scatterwalk_start(&walk, req->src);
113
113
114
114
do {
115
-
u32 n = scatterwalk_clamp(&walk, assoclen);
116
-
u8 *p, *ptr;
115
+
unsigned int n, orig_n;
116
+
const u8 *p, *orig_p;
117
117
118
-
if (!n) {
119
-
scatterwalk_start(&walk, sg_next(walk.sg));
120
-
n = scatterwalk_clamp(&walk, assoclen);
121
-
}
122
-
123
-
p = ptr = scatterwalk_map(&walk);
124
-
assoclen -= n;
125
-
scatterwalk_advance(&walk, n);
118
+
orig_p = scatterwalk_next(&walk, assoclen, &orig_n);
119
+
p = orig_p;
120
+
n = orig_n;
126
121
127
122
while (n > 0) {
128
123
unsigned int l, nblocks;
···
131
136
} else {
132
137
nblocks = n / SM4_BLOCK_SIZE;
133
138
sm4_ce_cbcmac_update(ctx->rkey_enc,
134
-
mac, ptr, nblocks);
139
+
mac, p, nblocks);
135
140
136
-
ptr += nblocks * SM4_BLOCK_SIZE;
141
+
p += nblocks * SM4_BLOCK_SIZE;
137
142
n %= SM4_BLOCK_SIZE;
138
143
139
144
continue;
···
142
147
143
148
l = min(n, SM4_BLOCK_SIZE - len);
144
149
if (l) {
145
-
crypto_xor(mac + len, ptr, l);
150
+
crypto_xor(mac + len, p, l);
146
151
len += l;
147
-
ptr += l;
152
+
p += l;
148
153
n -= l;
149
154
}
150
155
}
151
156
152
-
scatterwalk_unmap(p);
153
-
scatterwalk_done(&walk, 0, assoclen);
157
+
scatterwalk_done_src(&walk, orig_p, orig_n);
158
+
assoclen -= orig_n;
154
159
} while (assoclen);
155
160
}
156
161
+13
-18
arch/arm64/crypto/sm4-ce-gcm-glue.c
+13
-18
arch/arm64/crypto/sm4-ce-gcm-glue.c
···
82
82
scatterwalk_start(&walk, req->src);
83
83
84
84
do {
85
-
u32 n = scatterwalk_clamp(&walk, assoclen);
86
-
u8 *p, *ptr;
85
+
unsigned int n, orig_n;
86
+
const u8 *p, *orig_p;
87
87
88
-
if (!n) {
89
-
scatterwalk_start(&walk, sg_next(walk.sg));
90
-
n = scatterwalk_clamp(&walk, assoclen);
91
-
}
92
-
93
-
p = ptr = scatterwalk_map(&walk);
94
-
assoclen -= n;
95
-
scatterwalk_advance(&walk, n);
88
+
orig_p = scatterwalk_next(&walk, assoclen, &orig_n);
89
+
p = orig_p;
90
+
n = orig_n;
96
91
97
92
if (n + buflen < GHASH_BLOCK_SIZE) {
98
-
memcpy(&buffer[buflen], ptr, n);
93
+
memcpy(&buffer[buflen], p, n);
99
94
buflen += n;
100
95
} else {
101
96
unsigned int nblocks;
···
98
103
if (buflen) {
99
104
unsigned int l = GHASH_BLOCK_SIZE - buflen;
100
105
101
-
memcpy(&buffer[buflen], ptr, l);
102
-
ptr += l;
106
+
memcpy(&buffer[buflen], p, l);
107
+
p += l;
103
108
n -= l;
104
109
105
110
pmull_ghash_update(ctx->ghash_table, ghash,
···
109
114
nblocks = n / GHASH_BLOCK_SIZE;
110
115
if (nblocks) {
111
116
pmull_ghash_update(ctx->ghash_table, ghash,
112
-
ptr, nblocks);
113
-
ptr += nblocks * GHASH_BLOCK_SIZE;
117
+
p, nblocks);
118
+
p += nblocks * GHASH_BLOCK_SIZE;
114
119
}
115
120
116
121
buflen = n % GHASH_BLOCK_SIZE;
117
122
if (buflen)
118
-
memcpy(&buffer[0], ptr, buflen);
123
+
memcpy(&buffer[0], p, buflen);
119
124
}
120
125
121
-
scatterwalk_unmap(p);
122
-
scatterwalk_done(&walk, 0, assoclen);
126
+
scatterwalk_done_src(&walk, orig_p, orig_n);
127
+
assoclen -= orig_n;
123
128
} while (assoclen);
124
129
125
130
/* padding with '0' */