cryptodev: update to 6c2b61c

   **include the following changes
	6c2b61c - update copyright notes
	f79d523 - fix: reset finish condition before test start
	e8f7a91 - Merge remote-tracking branch 'upstream/master'
	6818263 - Fix ablkcipher algorithms usage in v4.8+ kernels
	26e167f - zc: Use the power of #elif
	e49fe25 - adjust to API changes in kernel >=4.10
	2b29be8 - adjust to API changes in kernel >=4.10
	c3afb40 - add support for rsa speed tests
	c9b7a80 - close the session after every test
	ba49470 - add support for authenc(hmac(sha1), cbc(aes)) speed tests
	690cd62 - Merge branch 'master' into hpe2016
        5adf04e - Merge remote-tracking branch 'upstream/master'
        840c7ba - remove not used variable
        2dbbb23 - do more strict code checking to avoid maintenance issues
        88223e4 - avoid implicit conversion between signed and unsigned char
        8db6905 - use buf_align macro to reduce code duplication
        b6d0e0f - rename header file to clarify purpose
        1fd6062 - fix warnings of "implicit declaration of function" in async_speed
        ff3c8ab - remove not used local variables
        25a1276 - fix incorrect return code in case of error from openssl_cioccrypt
	e7ef4ea - Merge pull request #17 from michaelweiser/gup_flags
	99c6d21 - fix ignored SIGALRM signals on some platforms
	71975fa - setting KERNEL_DIR is not necessary to build tests
	a96ff97 - fix issues with install target
	07748d3 - Merge branch 'master' into hpe2016
	cc89148 - Fix ablkcipher algorithms usage in v4.8+ kernels
	4d6e4fb - Merge remote-tracking branch 'upstream/master'
	f126e48 - Adjust to another change in the user page API
	4257fce - add -async option to run_crypto_tests.sh
	f953164 - merge sync and async benchmarks into a single program
	e7af57b - add % to cpu idle for convenience
	1883c95 - add a wrapper script for running all tests
	998b66b - add notes about configured limits in SEC driver
	b1a35f3 - fix ignored SIGALRM signals on some platforms
	b754517 - use the same algorithm names in sync_speed as in async_speed
	8baefa4 - force LC_TIME value to avoid mpstat not using ISO8601 format
	d0978b5 - add sync speed tests with the same format as async ones
	15d890b - graceful exit if cryptodev is not built with ASYNC flags
	9a595bf - fix typo, use consistent spacing
	9461878 - remove output line because it does not add clarity to the results
	b09c17f - the C standard used by cryptodev is C90 with GNU extensions
	447808d - exit early if cryptodev tests are not installed
	493afd3 - fix incorrect handling of error cases...
	e0d2c88 - make default output tabular
	abc007a - really fix (again...) the mpstat issue
	2696cd5 - use $(...) instead of `...` for consistency
	e8fb004 - fix the scale of the runtime value
	119151b - remove old results to avoid incorrect reports
	71ac3d5 - fix the reported unit
	8c47a0c - setting KERNEL_DIR is not necessary to build tests
	182b307 - fix issues with install target
	5021828 - do more strict code checking to avoid maintenance issues
	ab239d7 - return error code of the test if there is one
	b5228f2 - remove not used local variables
	90d67ce - avoid implicit conversion between signed and unsigned char
	4b442ca - fix build warnings on implicit function declarations
	2821b92 - add a little space in the output for clarity
	9d0ef05 - more precision in running mpstat
	0180e2b - fix some issues with parsing mpstat output
	4257fce - add -async option to run_crypto_tests.sh
	f953164 - merge sync and async benchmarks into a single program
	e7af57b - add % to cpu idle for convenience
	7d7a733 - sanity check on /dev/crypto availability
	137c0c4 - gracefull stop for async speed tests
	600eb70 - fix: set min value when allocating alligned memory buffers
	18408c9 - add multithreaded wrapper for async speed test
	854cc84 - rename algorithm names for clarity
	216f235 - honor the -m flag in async_speed
	1023ede - add flag to report in a machine friendly format
	219a8b4 - enable async code by default
	9def784 - Merge remote-tracking branch 'radualexe/new_tests`
	149dc1c - add basic optargs support for async_speed test
	9595499 - add support for crc32c hash sync speed test
	83e3840 - add support for aes-256-xts sync speed test
	fff72ae - add support for sha2-256 hash async speed test
	b961800 - add support for sha1 hash async speed test
	fea5006 - add support for crc32c hash async speed test
	8768fad - add aes-256-xts support for async speed test

Signed-off-by: Chunrong Guo <B40290@freescale.com>
Signed-off-by: Otavio Salvador <otavio@ossystems.com.br>

1 files changed, 281 insertions, 0 deletions

diff --git a/recipes-kernel/cryptodev/sdk_patches/0092-Support-skcipher-in-addition-to-ablkcipher-API.patch b/recipes-kernel/cryptodev/sdk_patches/0092-Support-skcipher-in-addition-to-ablkcipher-API.patch
new file mode 100644
index 00000000..4a82955e
--- /dev/null
+++ b/recipes-kernel/cryptodev/sdk_patches/0092-Support-skcipher-in-addition-to-ablkcipher-API.patch
@@ -0,0 +1,281 @@
+From e41e73551c886366d741b5e401a3c4c661aa3020 Mon Sep 17 00:00:00 2001
+From: Michael Weiser <michael.weiser@gmx.de>
+Date: Fri, 5 Aug 2016 17:26:27 +0200
+Subject: [PATCH 092/104] Support skcipher in addition to ablkcipher API
+
+The ablkcipher API is being phased out[1]. The unified skcipher API
+seems to have made its entry with 4.3.[3, 4] By what can be seen from
+migration patches[1.ff.], it's a drop-in replacement.
+
+Also, deallocators such as crypto_free_skcipher() are NULL-safe now[2].
+
+Add a new header cipherapi.h to aid migration from ablkcipher to skcipher and
+retain support for old kernels. Make it decide which API to use and provide
+appropriate function calls and type definitions. Since the ablkcipher and
+skcipher APIs are so similar, those are mainly defines for corresponding
+pseudo-functions in namespace cryptodev_ derived directly from their API
+counterparts.
+
+Compiles and works (i.e. checks pass) with Debian testing 4.6.4 kernel
+as well as 4.8-rc2+ Linus git tree as of today. (Both require a fix for
+changed page access API[5].)
+
+[1] https://www.spinics.net/lists/linux-crypto/msg18133.html
+[2] https://www.spinics.net/lists/linux-crypto/msg18154.html, line 120
+[3] https://www.spinics.net/lists/linux-crypto/msg16373.html
+[4] https://www.spinics.net/lists/linux-crypto/msg16294.html
+[5] https://github.com/cryptodev-linux/cryptodev-linux/pull/14
+---
+ cipherapi.h | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ cryptlib.c  | 40 ++++++++++++++++++----------------------
+ cryptlib.h  |  6 ++++--
+ ioctl.c     |  4 ++--
+ 4 files changed, 84 insertions(+), 26 deletions(-)
+ create mode 100644 cipherapi.h
+
+diff --git a/cipherapi.h b/cipherapi.h
+new file mode 100644
+index 0000000..07d9923
+--- /dev/null
++++ b/cipherapi.h
+@@ -0,0 +1,60 @@
++#ifndef CIPHERAPI_H
++# define CIPHERAPI_H
++
++#include <linux/version.h>
++
++#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 8, 0))
++# include <linux/crypto.h>
++
++typedef struct ablkcipher_alg cryptodev_blkcipher_alg_t;
++typedef struct crypto_ablkcipher cryptodev_crypto_blkcipher_t;
++typedef struct ablkcipher_request cryptodev_blkcipher_request_t;
++
++# define cryptodev_crypto_alloc_blkcipher crypto_alloc_ablkcipher
++# define cryptodev_crypto_blkcipher_alg crypto_ablkcipher_alg
++# define cryptodev_crypto_blkcipher_blocksize crypto_ablkcipher_blocksize
++# define cryptodev_crypto_blkcipher_ivsize crypto_ablkcipher_ivsize
++# define cryptodev_crypto_blkcipher_alignmask crypto_ablkcipher_alignmask
++# define cryptodev_crypto_blkcipher_setkey crypto_ablkcipher_setkey
++
++static inline void cryptodev_crypto_free_blkcipher(cryptodev_crypto_blkcipher_t *c) {
++       if (c)
++               crypto_free_ablkcipher(c);
++}
++
++# define cryptodev_blkcipher_request_alloc ablkcipher_request_alloc
++# define cryptodev_blkcipher_request_set_callback ablkcipher_request_set_callback
++
++static inline void cryptodev_blkcipher_request_free(cryptodev_blkcipher_request_t *r) {
++       if (r)
++               ablkcipher_request_free(r);
++}
++
++# define cryptodev_blkcipher_request_set_crypt ablkcipher_request_set_crypt
++# define cryptodev_crypto_blkcipher_encrypt crypto_ablkcipher_encrypt
++# define cryptodev_crypto_blkcipher_decrypt crypto_ablkcipher_decrypt
++# define cryptodev_crypto_blkcipher_tfm crypto_ablkcipher_tfm
++#else
++#include <crypto/skcipher.h>
++
++typedef struct skcipher_alg cryptodev_blkcipher_alg_t;
++typedef struct crypto_skcipher cryptodev_crypto_blkcipher_t;
++typedef struct skcipher_request cryptodev_blkcipher_request_t;
++
++# define cryptodev_crypto_alloc_blkcipher crypto_alloc_skcipher
++# define cryptodev_crypto_blkcipher_alg crypto_skcipher_alg
++# define cryptodev_crypto_blkcipher_blocksize crypto_skcipher_blocksize
++# define cryptodev_crypto_blkcipher_ivsize crypto_skcipher_ivsize
++# define cryptodev_crypto_blkcipher_alignmask crypto_skcipher_alignmask
++# define cryptodev_crypto_blkcipher_setkey crypto_skcipher_setkey
++# define cryptodev_crypto_free_blkcipher crypto_free_skcipher
++# define cryptodev_blkcipher_request_alloc skcipher_request_alloc
++# define cryptodev_blkcipher_request_set_callback skcipher_request_set_callback
++# define cryptodev_blkcipher_request_free skcipher_request_free
++# define cryptodev_blkcipher_request_set_crypt skcipher_request_set_crypt
++# define cryptodev_crypto_blkcipher_encrypt crypto_skcipher_encrypt
++# define cryptodev_crypto_blkcipher_decrypt crypto_skcipher_decrypt
++# define cryptodev_crypto_blkcipher_tfm crypto_skcipher_tfm
++#endif
++
++#endif
+diff --git a/cryptlib.c b/cryptlib.c
+index 5d1a5a9..558d4b8 100644
+--- a/cryptlib.c
++++ b/cryptlib.c
+@@ -24,7 +24,6 @@
+  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+  */
+ 
+-#include <linux/crypto.h>
+ #include <linux/mm.h>
+ #include <linux/highmem.h>
+ #include <linux/ioctl.h>
+@@ -38,6 +37,7 @@
+ #include <linux/rtnetlink.h>
+ #include <crypto/authenc.h>
+ #include "cryptodev_int.h"
++#include "cipherapi.h"
+ 
+ 
+ static void cryptodev_complete(struct crypto_async_request *req, int err)
+@@ -129,15 +129,15 @@ int cryptodev_cipher_init(struct cipher_data *out, const char *alg_name,
+        int ret;
+ 
+        if (aead == 0) {
+-               struct ablkcipher_alg *alg;
++               cryptodev_blkcipher_alg_t *alg;
+ 
+-               out->async.s = crypto_alloc_ablkcipher(alg_name, 0, 0);
++               out->async.s = cryptodev_crypto_alloc_blkcipher(alg_name, 0, 0);
+                if (unlikely(IS_ERR(out->async.s))) {
+                        ddebug(1, "Failed to load cipher %s", alg_name);
+                                return -EINVAL;
+                }
+ 
+-               alg = crypto_ablkcipher_alg(out->async.s);
++               alg = cryptodev_crypto_blkcipher_alg(out->async.s);
+                if (alg != NULL) {
+                        /* Was correct key length supplied? */
+                        if (alg->max_keysize > 0 &&
+@@ -150,11 +150,11 @@ int cryptodev_cipher_init(struct cipher_data *out, const char *alg_name,
+                        }
+                }
+ 
+-               out->blocksize = crypto_ablkcipher_blocksize(out->async.s);
+-               out->ivsize = crypto_ablkcipher_ivsize(out->async.s);
+-               out->alignmask = crypto_ablkcipher_alignmask(out->async.s);
++               out->blocksize = cryptodev_crypto_blkcipher_blocksize(out->async.s);
++               out->ivsize = cryptodev_crypto_blkcipher_ivsize(out->async.s);
++               out->alignmask = cryptodev_crypto_blkcipher_alignmask(out->async.s);
+ 
+-               ret = crypto_ablkcipher_setkey(out->async.s, keyp, keylen);
++               ret = cryptodev_crypto_blkcipher_setkey(out->async.s, keyp, keylen);
+        } else {
+                out->async.as = crypto_alloc_aead(alg_name, 0, 0);
+                if (unlikely(IS_ERR(out->async.as))) {
+@@ -181,14 +181,14 @@ int cryptodev_cipher_init(struct cipher_data *out, const char *alg_name,
+        init_completion(&out->async.result.completion);
+ 
+        if (aead == 0) {
+-               out->async.request = ablkcipher_request_alloc(out->async.s, GFP_KERNEL);
++               out->async.request = cryptodev_blkcipher_request_alloc(out->async.s, GFP_KERNEL);
+                if (unlikely(!out->async.request)) {
+                        derr(1, "error allocating async crypto request");
+                        ret = -ENOMEM;
+                        goto error;
+                }
+ 
+-               ablkcipher_request_set_callback(out->async.request, 0,
++               cryptodev_blkcipher_request_set_callback(out->async.request, 0,
+                                        cryptodev_complete, &out->async.result);
+        } else {
+                out->async.arequest = aead_request_alloc(out->async.as, GFP_KERNEL);
+@@ -206,10 +206,8 @@ int cryptodev_cipher_init(struct cipher_data *out, const char *alg_name,
+        return 0;
+ error:
+        if (aead == 0) {
+-               if (out->async.request)
+-                       ablkcipher_request_free(out->async.request);
+-               if (out->async.s)
+-                       crypto_free_ablkcipher(out->async.s);
++               cryptodev_blkcipher_request_free(out->async.request);
++               cryptodev_crypto_free_blkcipher(out->async.s);
+        } else {
+                if (out->async.arequest)
+                        aead_request_free(out->async.arequest);
+@@ -224,10 +222,8 @@ void cryptodev_cipher_deinit(struct cipher_data *cdata)
+ {
+        if (cdata->init) {
+                if (cdata->aead == 0) {
+-                       if (cdata->async.request)
+-                               ablkcipher_request_free(cdata->async.request);
+-                       if (cdata->async.s)
+-                               crypto_free_ablkcipher(cdata->async.s);
++                       cryptodev_blkcipher_request_free(cdata->async.request);
++                       cryptodev_crypto_free_blkcipher(cdata->async.s);
+                } else {
+                        if (cdata->async.arequest)
+                                aead_request_free(cdata->async.arequest);
+@@ -274,10 +270,10 @@ ssize_t cryptodev_cipher_encrypt(struct cipher_data *cdata,
+        reinit_completion(&cdata->async.result.completion);
+ 
+        if (cdata->aead == 0) {
+-               ablkcipher_request_set_crypt(cdata->async.request,
++               cryptodev_blkcipher_request_set_crypt(cdata->async.request,
+                        (struct scatterlist *)src, dst,
+                        len, cdata->async.iv);
+-               ret = crypto_ablkcipher_encrypt(cdata->async.request);
++               ret = cryptodev_crypto_blkcipher_encrypt(cdata->async.request);
+        } else {
+                aead_request_set_crypt(cdata->async.arequest,
+                        (struct scatterlist *)src, dst,
+@@ -296,10 +292,10 @@ ssize_t cryptodev_cipher_decrypt(struct cipher_data *cdata,
+ 
+        reinit_completion(&cdata->async.result.completion);
+        if (cdata->aead == 0) {
+-               ablkcipher_request_set_crypt(cdata->async.request,
++               cryptodev_blkcipher_request_set_crypt(cdata->async.request,
+                        (struct scatterlist *)src, dst,
+                        len, cdata->async.iv);
+-               ret = crypto_ablkcipher_decrypt(cdata->async.request);
++               ret = cryptodev_crypto_blkcipher_decrypt(cdata->async.request);
+        } else {
+                aead_request_set_crypt(cdata->async.arequest,
+                        (struct scatterlist *)src, dst,
+diff --git a/cryptlib.h b/cryptlib.h
+index d8e8046..8200a1d 100644
+--- a/cryptlib.h
++++ b/cryptlib.h
+@@ -11,6 +11,8 @@ struct cryptodev_result {
+        int err;
+ };
+ 
++#include "cipherapi.h"
++
+ struct cipher_data {
+        int init; /* 0 uninitialized */
+        int blocksize;
+@@ -20,8 +22,8 @@ struct cipher_data {
+        int alignmask;
+        struct {
+                /* block ciphers */
+-               struct crypto_ablkcipher *s;
+-               struct ablkcipher_request *request;
++               cryptodev_crypto_blkcipher_t *s;
++               cryptodev_blkcipher_request_t *request;
+ 
+                /* AEAD ciphers */
+                struct crypto_aead *as;
+diff --git a/ioctl.c b/ioctl.c
+index 2e2bdeb..e3b8af1 100644
+--- a/ioctl.c
++++ b/ioctl.c
+@@ -35,7 +35,6 @@
+  */
+ 
+ #include <crypto/hash.h>
+-#include <linux/crypto.h>
+ #include <linux/mm.h>
+ #include <linux/highmem.h>
+ #include <linux/ioctl.h>
+@@ -54,6 +53,7 @@
+ #include "cryptodev_int.h"
+ #include "zc.h"
+ #include "version.h"
++#include "cipherapi.h"
+ 
+ MODULE_AUTHOR("Nikos Mavrogiannopoulos <nmav@gnutls.org>");
+ MODULE_DESCRIPTION("CryptoDev driver");
+@@ -1052,7 +1052,7 @@ static int get_session_info(struct fcrypt *fcr, struct session_info_op *siop)
+ 
+        if (ses_ptr->cdata.init) {
+                if (ses_ptr->cdata.aead == 0)
+-                       tfm = crypto_ablkcipher_tfm(ses_ptr->cdata.async.s);
++                       tfm = cryptodev_crypto_blkcipher_tfm(ses_ptr->cdata.async.s);
+                else
+                        tfm = crypto_aead_tfm(ses_ptr->cdata.async.as);
+                tfm_info_to_alg_info(&siop->cipher_info, tfm);
+-- 
+2.10.2
+