1 From 6396bb221514d2876fd6dc0aa2a1f240d99b37bb Mon Sep 17 00:00:00 2001
2 From: Kees Cook <keescook@chromium.org>
3 Date: Tue, 12 Jun 2018 14:03:40 -0700
4 Subject: [PATCH 01/15] treewide: kzalloc() -> kcalloc()
6 The kzalloc() function has a 2-factor argument form, kcalloc(). This
7 patch replaces cases of:
14 as well as handling cases of:
16 kzalloc(a * b * c, gfp)
20 kzalloc(array3_size(a, b, c), gfp)
22 as it's slightly less ugly than:
24 kzalloc_array(array_size(a, b), c, gfp)
26 This does, however, attempt to ignore constant size factors like:
28 kzalloc(4 * 1024, gfp)
30 though any constants defined via macros get caught up in the conversion.
32 Any factors with a sizeof() of "unsigned char", "char", and "u8" were
33 dropped, since they're redundant.
35 The Coccinelle script used for this was:
37 // Fix redundant parens around sizeof().
55 // Drop single-byte sizes and redundant parens.
64 - sizeof(u8) * (COUNT)
69 - sizeof(__u8) * (COUNT)
74 - sizeof(char) * (COUNT)
79 - sizeof(unsigned char) * (COUNT)
89 - sizeof(__u8) * COUNT
94 - sizeof(char) * COUNT
99 - sizeof(unsigned char) * COUNT
104 // 2-factor product with sizeof(type/expression) and identifier or constant.
109 constant COUNT_CONST;
116 - sizeof(TYPE) * (COUNT_ID)
117 + COUNT_ID, sizeof(TYPE)
123 - sizeof(TYPE) * COUNT_ID
124 + COUNT_ID, sizeof(TYPE)
130 - sizeof(TYPE) * (COUNT_CONST)
131 + COUNT_CONST, sizeof(TYPE)
137 - sizeof(TYPE) * COUNT_CONST
138 + COUNT_CONST, sizeof(TYPE)
144 - sizeof(THING) * (COUNT_ID)
145 + COUNT_ID, sizeof(THING)
151 - sizeof(THING) * COUNT_ID
152 + COUNT_ID, sizeof(THING)
158 - sizeof(THING) * (COUNT_CONST)
159 + COUNT_CONST, sizeof(THING)
165 - sizeof(THING) * COUNT_CONST
166 + COUNT_CONST, sizeof(THING)
170 // 2-factor product, only identifiers.
172 identifier SIZE, COUNT;
182 // 3-factor product with 1 sizeof(type) or sizeof(expression), with
183 // redundant parens removed.
186 identifier STRIDE, COUNT;
192 - sizeof(TYPE) * (COUNT) * (STRIDE)
193 + array3_size(COUNT, STRIDE, sizeof(TYPE))
197 - sizeof(TYPE) * (COUNT) * STRIDE
198 + array3_size(COUNT, STRIDE, sizeof(TYPE))
202 - sizeof(TYPE) * COUNT * (STRIDE)
203 + array3_size(COUNT, STRIDE, sizeof(TYPE))
207 - sizeof(TYPE) * COUNT * STRIDE
208 + array3_size(COUNT, STRIDE, sizeof(TYPE))
212 - sizeof(THING) * (COUNT) * (STRIDE)
213 + array3_size(COUNT, STRIDE, sizeof(THING))
217 - sizeof(THING) * (COUNT) * STRIDE
218 + array3_size(COUNT, STRIDE, sizeof(THING))
222 - sizeof(THING) * COUNT * (STRIDE)
223 + array3_size(COUNT, STRIDE, sizeof(THING))
227 - sizeof(THING) * COUNT * STRIDE
228 + array3_size(COUNT, STRIDE, sizeof(THING))
232 // 3-factor product with 2 sizeof(variable), with redundant parens removed.
234 expression THING1, THING2;
241 - sizeof(TYPE1) * sizeof(TYPE2) * COUNT
242 + array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
246 - sizeof(TYPE1) * sizeof(THING2) * (COUNT)
247 + array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
251 - sizeof(THING1) * sizeof(THING2) * COUNT
252 + array3_size(COUNT, sizeof(THING1), sizeof(THING2))
256 - sizeof(THING1) * sizeof(THING2) * (COUNT)
257 + array3_size(COUNT, sizeof(THING1), sizeof(THING2))
261 - sizeof(TYPE1) * sizeof(THING2) * COUNT
262 + array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
266 - sizeof(TYPE1) * sizeof(THING2) * (COUNT)
267 + array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
271 // 3-factor product, only identifiers, with redundant parens removed.
273 identifier STRIDE, SIZE, COUNT;
278 - (COUNT) * STRIDE * SIZE
279 + array3_size(COUNT, STRIDE, SIZE)
283 - COUNT * (STRIDE) * SIZE
284 + array3_size(COUNT, STRIDE, SIZE)
288 - COUNT * STRIDE * (SIZE)
289 + array3_size(COUNT, STRIDE, SIZE)
293 - (COUNT) * (STRIDE) * SIZE
294 + array3_size(COUNT, STRIDE, SIZE)
298 - COUNT * (STRIDE) * (SIZE)
299 + array3_size(COUNT, STRIDE, SIZE)
303 - (COUNT) * STRIDE * (SIZE)
304 + array3_size(COUNT, STRIDE, SIZE)
308 - (COUNT) * (STRIDE) * (SIZE)
309 + array3_size(COUNT, STRIDE, SIZE)
313 - COUNT * STRIDE * SIZE
314 + array3_size(COUNT, STRIDE, SIZE)
318 // Any remaining multi-factor products, first at least 3-factor products,
319 // when they're not all constants...
321 expression E1, E2, E3;
326 kzalloc(C1 * C2 * C3, ...)
330 + array3_size(E1, E2, E3)
335 + array3_size(E1, E2, E3)
340 + array3_size(E1, E2, E3)
345 + array3_size(E1, E2, E3)
349 // And then all remaining 2 factors products when they're not all constants,
350 // keeping sizeof() as the second factor argument.
352 expression THING, E1, E2;
358 kzalloc(sizeof(THING) * C2, ...)
360 kzalloc(sizeof(TYPE) * C2, ...)
362 kzalloc(C1 * C2 * C3, ...)
364 kzalloc(C1 * C2, ...)
369 - sizeof(TYPE) * (E2)
383 - sizeof(THING) * (E2)
416 Signed-off-by: Kees Cook <keescook@chromium.org>
418 drivers/crypto/amcc/crypto4xx_core.c | 8 ++++----
419 1 file changed, 4 insertions(+), 4 deletions(-)
421 --- a/drivers/crypto/amcc/crypto4xx_core.c
422 +++ b/drivers/crypto/amcc/crypto4xx_core.c
423 @@ -141,11 +141,11 @@ static void crypto4xx_hw_init(struct cry
425 int crypto4xx_alloc_sa(struct crypto4xx_ctx *ctx, u32 size)
427 - ctx->sa_in = kzalloc(size * 4, GFP_ATOMIC);
428 + ctx->sa_in = kcalloc(size, 4, GFP_ATOMIC);
429 if (ctx->sa_in == NULL)
432 - ctx->sa_out = kzalloc(size * 4, GFP_ATOMIC);
433 + ctx->sa_out = kcalloc(size, 4, GFP_ATOMIC);
434 if (ctx->sa_out == NULL) {
437 @@ -180,8 +180,8 @@ static u32 crypto4xx_build_pdr(struct cr
441 - dev->pdr_uinfo = kzalloc(sizeof(struct pd_uinfo) * PPC4XX_NUM_PD,
443 + dev->pdr_uinfo = kcalloc(PPC4XX_NUM_PD, sizeof(struct pd_uinfo),
445 if (!dev->pdr_uinfo) {
446 dma_free_coherent(dev->core_dev->device,
447 sizeof(struct ce_pd) * PPC4XX_NUM_PD,