target/linux/apm821xx/patches-4.14/023-0001-treewide-kzalloc-kcalloc.patch

   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()
   5
   6 The kzalloc() function has a 2-factor argument form, kcalloc(). This
   7 patch replaces cases of:
   8
   9         kzalloc(a * b, gfp)
  10
  11 with:
  12         kcalloc(a * b, gfp)
  13
  14 as well as handling cases of:
  15
  16         kzalloc(a * b * c, gfp)
  17
  18 with:
  19
  20         kzalloc(array3_size(a, b, c), gfp)
  21
  22 as it's slightly less ugly than:
  23
  24         kzalloc_array(array_size(a, b), c, gfp)
  25
  26 This does, however, attempt to ignore constant size factors like:
  27
  28         kzalloc(4 * 1024, gfp)
  29
  30 though any constants defined via macros get caught up in the conversion.
  31
  32 Any factors with a sizeof() of "unsigned char", "char", and "u8" were
  33 dropped, since they're redundant.
  34
  35 The Coccinelle script used for this was:
  36
  37 // Fix redundant parens around sizeof().
  38 @@
  39 type TYPE;
  40 expression THING, E;
  41 @@
  42
  43 (
  44   kzalloc(
  45 -       (sizeof(TYPE)) * E
  46 +       sizeof(TYPE) * E
  47   , ...)
  48 |
  49   kzalloc(
  50 -       (sizeof(THING)) * E
  51 +       sizeof(THING) * E
  52   , ...)
  53 )
  54
  55 // Drop single-byte sizes and redundant parens.
  56 @@
  57 expression COUNT;
  58 typedef u8;
  59 typedef __u8;
  60 @@
  61
  62 (
  63   kzalloc(
  64 -       sizeof(u8) * (COUNT)
  65 +       COUNT
  66   , ...)
  67 |
  68   kzalloc(
  69 -       sizeof(__u8) * (COUNT)
  70 +       COUNT
  71   , ...)
  72 |
  73   kzalloc(
  74 -       sizeof(char) * (COUNT)
  75 +       COUNT
  76   , ...)
  77 |
  78   kzalloc(
  79 -       sizeof(unsigned char) * (COUNT)
  80 +       COUNT
  81   , ...)
  82 |
  83   kzalloc(
  84 -       sizeof(u8) * COUNT
  85 +       COUNT
  86   , ...)
  87 |
  88   kzalloc(
  89 -       sizeof(__u8) * COUNT
  90 +       COUNT
  91   , ...)
  92 |
  93   kzalloc(
  94 -       sizeof(char) * COUNT
  95 +       COUNT
  96   , ...)
  97 |
  98   kzalloc(
  99 -       sizeof(unsigned char) * COUNT
 100 +       COUNT
 101   , ...)
 102 )
 103
 104 // 2-factor product with sizeof(type/expression) and identifier or constant.
 105 @@
 106 type TYPE;
 107 expression THING;
 108 identifier COUNT_ID;
 109 constant COUNT_CONST;
 110 @@
 111
 112 (
 113 - kzalloc
 114 + kcalloc
 115   (
 116 -       sizeof(TYPE) * (COUNT_ID)
 117 +       COUNT_ID, sizeof(TYPE)
 118   , ...)
 119 |
 120 - kzalloc
 121 + kcalloc
 122   (
 123 -       sizeof(TYPE) * COUNT_ID
 124 +       COUNT_ID, sizeof(TYPE)
 125   , ...)
 126 |
 127 - kzalloc
 128 + kcalloc
 129   (
 130 -       sizeof(TYPE) * (COUNT_CONST)
 131 +       COUNT_CONST, sizeof(TYPE)
 132   , ...)
 133 |
 134 - kzalloc
 135 + kcalloc
 136   (
 137 -       sizeof(TYPE) * COUNT_CONST
 138 +       COUNT_CONST, sizeof(TYPE)
 139   , ...)
 140 |
 141 - kzalloc
 142 + kcalloc
 143   (
 144 -       sizeof(THING) * (COUNT_ID)
 145 +       COUNT_ID, sizeof(THING)
 146   , ...)
 147 |
 148 - kzalloc
 149 + kcalloc
 150   (
 151 -       sizeof(THING) * COUNT_ID
 152 +       COUNT_ID, sizeof(THING)
 153   , ...)
 154 |
 155 - kzalloc
 156 + kcalloc
 157   (
 158 -       sizeof(THING) * (COUNT_CONST)
 159 +       COUNT_CONST, sizeof(THING)
 160   , ...)
 161 |
 162 - kzalloc
 163 + kcalloc
 164   (
 165 -       sizeof(THING) * COUNT_CONST
 166 +       COUNT_CONST, sizeof(THING)
 167   , ...)
 168 )
 169
 170 // 2-factor product, only identifiers.
 171 @@
 172 identifier SIZE, COUNT;
 173 @@
 174
 175 - kzalloc
 176 + kcalloc
 177   (
 178 -       SIZE * COUNT
 179 +       COUNT, SIZE
 180   , ...)
 181
 182 // 3-factor product with 1 sizeof(type) or sizeof(expression), with
 183 // redundant parens removed.
 184 @@
 185 expression THING;
 186 identifier STRIDE, COUNT;
 187 type TYPE;
 188 @@
 189
 190 (
 191   kzalloc(
 192 -       sizeof(TYPE) * (COUNT) * (STRIDE)
 193 +       array3_size(COUNT, STRIDE, sizeof(TYPE))
 194   , ...)
 195 |
 196   kzalloc(
 197 -       sizeof(TYPE) * (COUNT) * STRIDE
 198 +       array3_size(COUNT, STRIDE, sizeof(TYPE))
 199   , ...)
 200 |
 201   kzalloc(
 202 -       sizeof(TYPE) * COUNT * (STRIDE)
 203 +       array3_size(COUNT, STRIDE, sizeof(TYPE))
 204   , ...)
 205 |
 206   kzalloc(
 207 -       sizeof(TYPE) * COUNT * STRIDE
 208 +       array3_size(COUNT, STRIDE, sizeof(TYPE))
 209   , ...)
 210 |
 211   kzalloc(
 212 -       sizeof(THING) * (COUNT) * (STRIDE)
 213 +       array3_size(COUNT, STRIDE, sizeof(THING))
 214   , ...)
 215 |
 216   kzalloc(
 217 -       sizeof(THING) * (COUNT) * STRIDE
 218 +       array3_size(COUNT, STRIDE, sizeof(THING))
 219   , ...)
 220 |
 221   kzalloc(
 222 -       sizeof(THING) * COUNT * (STRIDE)
 223 +       array3_size(COUNT, STRIDE, sizeof(THING))
 224   , ...)
 225 |
 226   kzalloc(
 227 -       sizeof(THING) * COUNT * STRIDE
 228 +       array3_size(COUNT, STRIDE, sizeof(THING))
 229   , ...)
 230 )
 231
 232 // 3-factor product with 2 sizeof(variable), with redundant parens removed.
 233 @@
 234 expression THING1, THING2;
 235 identifier COUNT;
 236 type TYPE1, TYPE2;
 237 @@
 238
 239 (
 240   kzalloc(
 241 -       sizeof(TYPE1) * sizeof(TYPE2) * COUNT
 242 +       array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
 243   , ...)
 244 |
 245   kzalloc(
 246 -       sizeof(TYPE1) * sizeof(THING2) * (COUNT)
 247 +       array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
 248   , ...)
 249 |
 250   kzalloc(
 251 -       sizeof(THING1) * sizeof(THING2) * COUNT
 252 +       array3_size(COUNT, sizeof(THING1), sizeof(THING2))
 253   , ...)
 254 |
 255   kzalloc(
 256 -       sizeof(THING1) * sizeof(THING2) * (COUNT)
 257 +       array3_size(COUNT, sizeof(THING1), sizeof(THING2))
 258   , ...)
 259 |
 260   kzalloc(
 261 -       sizeof(TYPE1) * sizeof(THING2) * COUNT
 262 +       array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
 263   , ...)
 264 |
 265   kzalloc(
 266 -       sizeof(TYPE1) * sizeof(THING2) * (COUNT)
 267 +       array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
 268   , ...)
 269 )
 270
 271 // 3-factor product, only identifiers, with redundant parens removed.
 272 @@
 273 identifier STRIDE, SIZE, COUNT;
 274 @@
 275
 276 (
 277   kzalloc(
 278 -       (COUNT) * STRIDE * SIZE
 279 +       array3_size(COUNT, STRIDE, SIZE)
 280   , ...)
 281 |
 282   kzalloc(
 283 -       COUNT * (STRIDE) * SIZE
 284 +       array3_size(COUNT, STRIDE, SIZE)
 285   , ...)
 286 |
 287   kzalloc(
 288 -       COUNT * STRIDE * (SIZE)
 289 +       array3_size(COUNT, STRIDE, SIZE)
 290   , ...)
 291 |
 292   kzalloc(
 293 -       (COUNT) * (STRIDE) * SIZE
 294 +       array3_size(COUNT, STRIDE, SIZE)
 295   , ...)
 296 |
 297   kzalloc(
 298 -       COUNT * (STRIDE) * (SIZE)
 299 +       array3_size(COUNT, STRIDE, SIZE)
 300   , ...)
 301 |
 302   kzalloc(
 303 -       (COUNT) * STRIDE * (SIZE)
 304 +       array3_size(COUNT, STRIDE, SIZE)
 305   , ...)
 306 |
 307   kzalloc(
 308 -       (COUNT) * (STRIDE) * (SIZE)
 309 +       array3_size(COUNT, STRIDE, SIZE)
 310   , ...)
 311 |
 312   kzalloc(
 313 -       COUNT * STRIDE * SIZE
 314 +       array3_size(COUNT, STRIDE, SIZE)
 315   , ...)
 316 )
 317
 318 // Any remaining multi-factor products, first at least 3-factor products,
 319 // when they're not all constants...
 320 @@
 321 expression E1, E2, E3;
 322 constant C1, C2, C3;
 323 @@
 324
 325 (
 326   kzalloc(C1 * C2 * C3, ...)
 327 |
 328   kzalloc(
 329 -       (E1) * E2 * E3
 330 +       array3_size(E1, E2, E3)
 331   , ...)
 332 |
 333   kzalloc(
 334 -       (E1) * (E2) * E3
 335 +       array3_size(E1, E2, E3)
 336   , ...)
 337 |
 338   kzalloc(
 339 -       (E1) * (E2) * (E3)
 340 +       array3_size(E1, E2, E3)
 341   , ...)
 342 |
 343   kzalloc(
 344 -       E1 * E2 * E3
 345 +       array3_size(E1, E2, E3)
 346   , ...)
 347 )
 348
 349 // And then all remaining 2 factors products when they're not all constants,
 350 // keeping sizeof() as the second factor argument.
 351 @@
 352 expression THING, E1, E2;
 353 type TYPE;
 354 constant C1, C2, C3;
 355 @@
 356
 357 (
 358   kzalloc(sizeof(THING) * C2, ...)
 359 |
 360   kzalloc(sizeof(TYPE) * C2, ...)
 361 |
 362   kzalloc(C1 * C2 * C3, ...)
 363 |
 364   kzalloc(C1 * C2, ...)
 365 |
 366 - kzalloc
 367 + kcalloc
 368   (
 369 -       sizeof(TYPE) * (E2)
 370 +       E2, sizeof(TYPE)
 371   , ...)
 372 |
 373 - kzalloc
 374 + kcalloc
 375   (
 376 -       sizeof(TYPE) * E2
 377 +       E2, sizeof(TYPE)
 378   , ...)
 379 |
 380 - kzalloc
 381 + kcalloc
 382   (
 383 -       sizeof(THING) * (E2)
 384 +       E2, sizeof(THING)
 385   , ...)
 386 |
 387 - kzalloc
 388 + kcalloc
 389   (
 390 -       sizeof(THING) * E2
 391 +       E2, sizeof(THING)
 392   , ...)
 393 |
 394 - kzalloc
 395 + kcalloc
 396   (
 397 -       (E1) * E2
 398 +       E1, E2
 399   , ...)
 400 |
 401 - kzalloc
 402 + kcalloc
 403   (
 404 -       (E1) * (E2)
 405 +       E1, E2
 406   , ...)
 407 |
 408 - kzalloc
 409 + kcalloc
 410   (
 411 -       E1 * E2
 412 +       E1, E2
 413   , ...)
 414 )
 415
 416 Signed-off-by: Kees Cook <keescook@chromium.org>
 417 ---
 418  drivers/crypto/amcc/crypto4xx_core.c | 8 ++++----
 419  1 file changed, 4 insertions(+), 4 deletions(-)
 420
 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
 424
 425  int crypto4xx_alloc_sa(struct crypto4xx_ctx *ctx, u32 size)
 426  {
 427 -       ctx->sa_in = kzalloc(size * 4, GFP_ATOMIC);
 428 +       ctx->sa_in = kcalloc(size, 4, GFP_ATOMIC);
 429         if (ctx->sa_in == NULL)
 430                 return -ENOMEM;
 431
 432 -       ctx->sa_out = kzalloc(size * 4, GFP_ATOMIC);
 433 +       ctx->sa_out = kcalloc(size, 4, GFP_ATOMIC);
 434         if (ctx->sa_out == NULL) {
 435                 kfree(ctx->sa_in);
 436                 ctx->sa_in = NULL;
 437 @@ -180,8 +180,8 @@ static u32 crypto4xx_build_pdr(struct cr
 438         if (!dev->pdr)
 439                 return -ENOMEM;
 440
 441 -       dev->pdr_uinfo = kzalloc(sizeof(struct pd_uinfo) * PPC4XX_NUM_PD,
 442 -                               GFP_KERNEL);
 443 +       dev->pdr_uinfo = kcalloc(PPC4XX_NUM_PD, sizeof(struct pd_uinfo),
 444 +                                GFP_KERNEL);
 445         if (!dev->pdr_uinfo) {
 446                 dma_free_coherent(dev->core_dev->device,
 447                                   sizeof(struct ce_pd) * PPC4XX_NUM_PD,