apm821xx: backport accepted linux-crypto patches

Rather than wait until the patches hit vanilla and
get backported via the stable kernel, this patch
patches the crypto4xx driver with the latest fixes
from the upstream linux-crypto tree.

Signed-off-by: Christian Lamparter <chunkeey@gmail.com>

1 files changed, 447 insertions, 0 deletions

diff --git a/target/linux/apm821xx/patches-4.14/023-0001-treewide-kzalloc-kcalloc.patch b/target/linux/apm821xx/patches-4.14/023-0001-treewide-kzalloc-kcalloc.patch
new file mode 100644
index 0000000000..09206f5050
--- /dev/null
+++ b/target/linux/apm821xx/patches-4.14/023-0001-treewide-kzalloc-kcalloc.patch
@@ -0,0 +1,447 @@
+From 6396bb221514d2876fd6dc0aa2a1f240d99b37bb Mon Sep 17 00:00:00 2001
+From: Kees Cook <keescook@chromium.org>
+Date: Tue, 12 Jun 2018 14:03:40 -0700
+Subject: [PATCH 01/15] treewide: kzalloc() -> kcalloc()
+
+The kzalloc() function has a 2-factor argument form, kcalloc(). This
+patch replaces cases of:
+
+        kzalloc(a * b, gfp)
+
+with:
+        kcalloc(a * b, gfp)
+
+as well as handling cases of:
+
+        kzalloc(a * b * c, gfp)
+
+with:
+
+        kzalloc(array3_size(a, b, c), gfp)
+
+as it's slightly less ugly than:
+
+        kzalloc_array(array_size(a, b), c, gfp)
+
+This does, however, attempt to ignore constant size factors like:
+
+        kzalloc(4 * 1024, gfp)
+
+though any constants defined via macros get caught up in the conversion.
+
+Any factors with a sizeof() of "unsigned char", "char", and "u8" were
+dropped, since they're redundant.
+
+The Coccinelle script used for this was:
+
+// Fix redundant parens around sizeof().
+@@
+type TYPE;
+expression THING, E;
+@@
+
+(
+  kzalloc(
+-	(sizeof(TYPE)) * E
++	sizeof(TYPE) * E
+  , ...)
+|
+  kzalloc(
+-	(sizeof(THING)) * E
++	sizeof(THING) * E
+  , ...)
+)
+
+// Drop single-byte sizes and redundant parens.
+@@
+expression COUNT;
+typedef u8;
+typedef __u8;
+@@
+
+(
+  kzalloc(
+-	sizeof(u8) * (COUNT)
++	COUNT
+  , ...)
+|
+  kzalloc(
+-	sizeof(__u8) * (COUNT)
++	COUNT
+  , ...)
+|
+  kzalloc(
+-	sizeof(char) * (COUNT)
++	COUNT
+  , ...)
+|
+  kzalloc(
+-	sizeof(unsigned char) * (COUNT)
++	COUNT
+  , ...)
+|
+  kzalloc(
+-	sizeof(u8) * COUNT
++	COUNT
+  , ...)
+|
+  kzalloc(
+-	sizeof(__u8) * COUNT
++	COUNT
+  , ...)
+|
+  kzalloc(
+-	sizeof(char) * COUNT
++	COUNT
+  , ...)
+|
+  kzalloc(
+-	sizeof(unsigned char) * COUNT
++	COUNT
+  , ...)
+)
+
+// 2-factor product with sizeof(type/expression) and identifier or constant.
+@@
+type TYPE;
+expression THING;
+identifier COUNT_ID;
+constant COUNT_CONST;
+@@
+
+(
+- kzalloc
++ kcalloc
+  (
+-	sizeof(TYPE) * (COUNT_ID)
++	COUNT_ID, sizeof(TYPE)
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	sizeof(TYPE) * COUNT_ID
++	COUNT_ID, sizeof(TYPE)
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	sizeof(TYPE) * (COUNT_CONST)
++	COUNT_CONST, sizeof(TYPE)
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	sizeof(TYPE) * COUNT_CONST
++	COUNT_CONST, sizeof(TYPE)
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	sizeof(THING) * (COUNT_ID)
++	COUNT_ID, sizeof(THING)
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	sizeof(THING) * COUNT_ID
++	COUNT_ID, sizeof(THING)
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	sizeof(THING) * (COUNT_CONST)
++	COUNT_CONST, sizeof(THING)
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	sizeof(THING) * COUNT_CONST
++	COUNT_CONST, sizeof(THING)
+  , ...)
+)
+
+// 2-factor product, only identifiers.
+@@
+identifier SIZE, COUNT;
+@@
+
+- kzalloc
++ kcalloc
+  (
+-	SIZE * COUNT
++	COUNT, SIZE
+  , ...)
+
+// 3-factor product with 1 sizeof(type) or sizeof(expression), with
+// redundant parens removed.
+@@
+expression THING;
+identifier STRIDE, COUNT;
+type TYPE;
+@@
+
+(
+  kzalloc(
+-	sizeof(TYPE) * (COUNT) * (STRIDE)
++	array3_size(COUNT, STRIDE, sizeof(TYPE))
+  , ...)
+|
+  kzalloc(
+-	sizeof(TYPE) * (COUNT) * STRIDE
++	array3_size(COUNT, STRIDE, sizeof(TYPE))
+  , ...)
+|
+  kzalloc(
+-	sizeof(TYPE) * COUNT * (STRIDE)
++	array3_size(COUNT, STRIDE, sizeof(TYPE))
+  , ...)
+|
+  kzalloc(
+-	sizeof(TYPE) * COUNT * STRIDE
++	array3_size(COUNT, STRIDE, sizeof(TYPE))
+  , ...)
+|
+  kzalloc(
+-	sizeof(THING) * (COUNT) * (STRIDE)
++	array3_size(COUNT, STRIDE, sizeof(THING))
+  , ...)
+|
+  kzalloc(
+-	sizeof(THING) * (COUNT) * STRIDE
++	array3_size(COUNT, STRIDE, sizeof(THING))
+  , ...)
+|
+  kzalloc(
+-	sizeof(THING) * COUNT * (STRIDE)
++	array3_size(COUNT, STRIDE, sizeof(THING))
+  , ...)
+|
+  kzalloc(
+-	sizeof(THING) * COUNT * STRIDE
++	array3_size(COUNT, STRIDE, sizeof(THING))
+  , ...)
+)
+
+// 3-factor product with 2 sizeof(variable), with redundant parens removed.
+@@
+expression THING1, THING2;
+identifier COUNT;
+type TYPE1, TYPE2;
+@@
+
+(
+  kzalloc(
+-	sizeof(TYPE1) * sizeof(TYPE2) * COUNT
++	array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
+  , ...)
+|
+  kzalloc(
+-	sizeof(TYPE1) * sizeof(THING2) * (COUNT)
++	array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
+  , ...)
+|
+  kzalloc(
+-	sizeof(THING1) * sizeof(THING2) * COUNT
++	array3_size(COUNT, sizeof(THING1), sizeof(THING2))
+  , ...)
+|
+  kzalloc(
+-	sizeof(THING1) * sizeof(THING2) * (COUNT)
++	array3_size(COUNT, sizeof(THING1), sizeof(THING2))
+  , ...)
+|
+  kzalloc(
+-	sizeof(TYPE1) * sizeof(THING2) * COUNT
++	array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
+  , ...)
+|
+  kzalloc(
+-	sizeof(TYPE1) * sizeof(THING2) * (COUNT)
++	array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
+  , ...)
+)
+
+// 3-factor product, only identifiers, with redundant parens removed.
+@@
+identifier STRIDE, SIZE, COUNT;
+@@
+
+(
+  kzalloc(
+-	(COUNT) * STRIDE * SIZE
++	array3_size(COUNT, STRIDE, SIZE)
+  , ...)
+|
+  kzalloc(
+-	COUNT * (STRIDE) * SIZE
++	array3_size(COUNT, STRIDE, SIZE)
+  , ...)
+|
+  kzalloc(
+-	COUNT * STRIDE * (SIZE)
++	array3_size(COUNT, STRIDE, SIZE)
+  , ...)
+|
+  kzalloc(
+-	(COUNT) * (STRIDE) * SIZE
++	array3_size(COUNT, STRIDE, SIZE)
+  , ...)
+|
+  kzalloc(
+-	COUNT * (STRIDE) * (SIZE)
++	array3_size(COUNT, STRIDE, SIZE)
+  , ...)
+|
+  kzalloc(
+-	(COUNT) * STRIDE * (SIZE)
++	array3_size(COUNT, STRIDE, SIZE)
+  , ...)
+|
+  kzalloc(
+-	(COUNT) * (STRIDE) * (SIZE)
++	array3_size(COUNT, STRIDE, SIZE)
+  , ...)
+|
+  kzalloc(
+-	COUNT * STRIDE * SIZE
++	array3_size(COUNT, STRIDE, SIZE)
+  , ...)
+)
+
+// Any remaining multi-factor products, first at least 3-factor products,
+// when they're not all constants...
+@@
+expression E1, E2, E3;
+constant C1, C2, C3;
+@@
+
+(
+  kzalloc(C1 * C2 * C3, ...)
+|
+  kzalloc(
+-	(E1) * E2 * E3
++	array3_size(E1, E2, E3)
+  , ...)
+|
+  kzalloc(
+-	(E1) * (E2) * E3
++	array3_size(E1, E2, E3)
+  , ...)
+|
+  kzalloc(
+-	(E1) * (E2) * (E3)
++	array3_size(E1, E2, E3)
+  , ...)
+|
+  kzalloc(
+-	E1 * E2 * E3
++	array3_size(E1, E2, E3)
+  , ...)
+)
+
+// And then all remaining 2 factors products when they're not all constants,
+// keeping sizeof() as the second factor argument.
+@@
+expression THING, E1, E2;
+type TYPE;
+constant C1, C2, C3;
+@@
+
+(
+  kzalloc(sizeof(THING) * C2, ...)
+|
+  kzalloc(sizeof(TYPE) * C2, ...)
+|
+  kzalloc(C1 * C2 * C3, ...)
+|
+  kzalloc(C1 * C2, ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	sizeof(TYPE) * (E2)
++	E2, sizeof(TYPE)
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	sizeof(TYPE) * E2
++	E2, sizeof(TYPE)
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	sizeof(THING) * (E2)
++	E2, sizeof(THING)
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	sizeof(THING) * E2
++	E2, sizeof(THING)
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	(E1) * E2
++	E1, E2
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	(E1) * (E2)
++	E1, E2
+  , ...)
+|
+- kzalloc
++ kcalloc
+  (
+-	E1 * E2
++	E1, E2
+  , ...)
+)
+
+Signed-off-by: Kees Cook <keescook@chromium.org>
+---
+ drivers/crypto/amcc/crypto4xx_core.c | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+--- a/drivers/crypto/amcc/crypto4xx_core.c
++++ b/drivers/crypto/amcc/crypto4xx_core.c
+@@ -141,11 +141,11 @@ static void crypto4xx_hw_init(struct cry
+ 
+ int crypto4xx_alloc_sa(struct crypto4xx_ctx *ctx, u32 size)
+ {
+-	ctx->sa_in = kzalloc(size * 4, GFP_ATOMIC);
++	ctx->sa_in = kcalloc(size, 4, GFP_ATOMIC);
+ 	if (ctx->sa_in == NULL)
+ 		return -ENOMEM;
+ 
+-	ctx->sa_out = kzalloc(size * 4, GFP_ATOMIC);
++	ctx->sa_out = kcalloc(size, 4, GFP_ATOMIC);
+ 	if (ctx->sa_out == NULL) {
+ 		kfree(ctx->sa_in);
+ 		ctx->sa_in = NULL;
+@@ -180,8 +180,8 @@ static u32 crypto4xx_build_pdr(struct cr
+ 	if (!dev->pdr)
+ 		return -ENOMEM;
+ 
+-	dev->pdr_uinfo = kzalloc(sizeof(struct pd_uinfo) * PPC4XX_NUM_PD,
+-				GFP_KERNEL);
++	dev->pdr_uinfo = kcalloc(PPC4XX_NUM_PD, sizeof(struct pd_uinfo),
++				 GFP_KERNEL);
+ 	if (!dev->pdr_uinfo) {
+ 		dma_free_coherent(dev->core_dev->device,
+ 				  sizeof(struct ce_pd) * PPC4XX_NUM_PD,