Commit 69e5a122 authored by Herbert Xu's avatar Herbert Xu
Browse files

Revert "crypto: tcrypt - Restore multibuffer ahash tests" 



This reverts commit c664f034.

Remove the multibuffer ahash speed tests again.

Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 64929fe8

crypto/tcrypt.c

+0 −231
Original line number Diff line number Diff line
@@ -716,207 +716,6 @@ static inline int do_one_ahash_op(struct ahash_request *req, int ret) 
	return crypto_wait_req(ret, wait);

}



struct test_mb_ahash_data {

	struct scatterlist sg[XBUFSIZE];

	char result[64];

	struct ahash_request *req;

	struct crypto_wait wait;

	char *xbuf[XBUFSIZE];

};



static inline int do_mult_ahash_op(struct test_mb_ahash_data *data, u32 num_mb,

				   int *rc)

{

	int i, err;



	/* Fire up a bunch of concurrent requests */

	err = crypto_ahash_digest(data[0].req);



	/* Wait for all requests to finish */

	err = crypto_wait_req(err, &data[0].wait);

	if (num_mb < 2)

		return err;



	for (i = 0; i < num_mb; i++) {

		rc[i] = ahash_request_err(data[i].req);

		if (rc[i]) {

			pr_info("concurrent request %d error %d\n", i, rc[i]);

			err = rc[i];

		}

	}



	return err;

}



static int test_mb_ahash_jiffies(struct test_mb_ahash_data *data, int blen,

				 int secs, u32 num_mb)

{

	unsigned long start, end;

	int bcount;

	int ret = 0;

	int *rc;



	rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);

	if (!rc)

		return -ENOMEM;



	for (start = jiffies, end = start + secs * HZ, bcount = 0;

	     time_before(jiffies, end); bcount++) {

		ret = do_mult_ahash_op(data, num_mb, rc);

		if (ret)

			goto out;

	}



	pr_cont("%d operations in %d seconds (%llu bytes)\n",

		bcount * num_mb, secs, (u64)bcount * blen * num_mb);



out:

	kfree(rc);

	return ret;

}



static int test_mb_ahash_cycles(struct test_mb_ahash_data *data, int blen,

				u32 num_mb)

{

	unsigned long cycles = 0;

	int ret = 0;

	int i;

	int *rc;



	rc = kcalloc(num_mb, sizeof(*rc), GFP_KERNEL);

	if (!rc)

		return -ENOMEM;



	/* Warm-up run. */

	for (i = 0; i < 4; i++) {

		ret = do_mult_ahash_op(data, num_mb, rc);

		if (ret)

			goto out;

	}



	/* The real thing. */

	for (i = 0; i < 8; i++) {

		cycles_t start, end;



		start = get_cycles();

		ret = do_mult_ahash_op(data, num_mb, rc);

		end = get_cycles();



		if (ret)

			goto out;



		cycles += end - start;

	}



	pr_cont("1 operation in %lu cycles (%d bytes)\n",

		(cycles + 4) / (8 * num_mb), blen);



out:

	kfree(rc);

	return ret;

}



static void test_mb_ahash_speed(const char *algo, unsigned int secs,

				struct hash_speed *speed, u32 num_mb)

{

	struct test_mb_ahash_data *data;

	struct crypto_ahash *tfm;

	unsigned int i, j, k;

	int ret;



	data = kcalloc(num_mb, sizeof(*data), GFP_KERNEL);

	if (!data)

		return;



	tfm = crypto_alloc_ahash(algo, 0, 0);

	if (IS_ERR(tfm)) {

		pr_err("failed to load transform for %s: %ld\n",

			algo, PTR_ERR(tfm));

		goto free_data;

	}



	for (i = 0; i < num_mb; ++i) {

		if (testmgr_alloc_buf(data[i].xbuf))

			goto out;



		crypto_init_wait(&data[i].wait);



		data[i].req = ahash_request_alloc(tfm, GFP_KERNEL);

		if (!data[i].req) {

			pr_err("alg: hash: Failed to allocate request for %s\n",

			       algo);

			goto out;

		}





		if (i) {

			ahash_request_set_callback(data[i].req, 0, NULL, NULL);

			ahash_request_chain(data[i].req, data[0].req);

		} else

			ahash_request_set_callback(data[0].req, 0,

						   crypto_req_done,

						   &data[0].wait);



		sg_init_table(data[i].sg, XBUFSIZE);

		for (j = 0; j < XBUFSIZE; j++) {

			sg_set_buf(data[i].sg + j, data[i].xbuf[j], PAGE_SIZE);

			memset(data[i].xbuf[j], 0xff, PAGE_SIZE);

		}

	}



	pr_info("\ntesting speed of multibuffer %s (%s)\n", algo,

		get_driver_name(crypto_ahash, tfm));



	for (i = 0; speed[i].blen != 0; i++) {

		/* For some reason this only tests digests. */

		if (speed[i].blen != speed[i].plen)

			continue;



		if (speed[i].blen > XBUFSIZE * PAGE_SIZE) {

			pr_err("template (%u) too big for tvmem (%lu)\n",

			       speed[i].blen, XBUFSIZE * PAGE_SIZE);

			goto out;

		}



		if (klen)

			crypto_ahash_setkey(tfm, tvmem[0], klen);



		for (k = 0; k < num_mb; k++)

			ahash_request_set_crypt(data[k].req, data[k].sg,

						data[k].result, speed[i].blen);



		pr_info("test%3u "

			"(%5u byte blocks,%5u bytes per update,%4u updates): ",

			i, speed[i].blen, speed[i].plen,

			speed[i].blen / speed[i].plen);



		if (secs) {

			ret = test_mb_ahash_jiffies(data, speed[i].blen, secs,

						    num_mb);

			cond_resched();

		} else {

			ret = test_mb_ahash_cycles(data, speed[i].blen, num_mb);

		}





		if (ret) {

			pr_err("At least one hashing failed ret=%d\n", ret);

			break;

		}

	}



out:

	ahash_request_free(data[0].req);



	for (k = 0; k < num_mb; ++k)

		testmgr_free_buf(data[k].xbuf);



	crypto_free_ahash(tfm);



free_data:

	kfree(data);

}



static int test_ahash_jiffies_digest(struct ahash_request *req, int blen,

				     char *out, int secs)

{
@@ -2584,36 +2383,6 @@ static int do_test(const char *alg, u32 type, u32 mask, int m, u32 num_mb) 
		test_ahash_speed("sm3", sec, generic_hash_speed_template);

		if (mode > 400 && mode < 500) break;

		fallthrough;

	case 450:

		test_mb_ahash_speed("sha1", sec, generic_hash_speed_template,

				    num_mb);

		if (mode > 400 && mode < 500) break;

		fallthrough;

	case 451:

		test_mb_ahash_speed("sha256", sec, generic_hash_speed_template,

				    num_mb);

		if (mode > 400 && mode < 500) break;

		fallthrough;

	case 452:

		test_mb_ahash_speed("sha512", sec, generic_hash_speed_template,

				    num_mb);

		if (mode > 400 && mode < 500) break;

		fallthrough;

	case 453:

		test_mb_ahash_speed("sm3", sec, generic_hash_speed_template,

				    num_mb);

		if (mode > 400 && mode < 500) break;

		fallthrough;

	case 454:

		test_mb_ahash_speed("streebog256", sec,

				    generic_hash_speed_template, num_mb);

		if (mode > 400 && mode < 500) break;

		fallthrough;

	case 455:

		test_mb_ahash_speed("streebog512", sec,

				    generic_hash_speed_template, num_mb);

		if (mode > 400 && mode < 500) break;

		fallthrough;

	case 499:

		break;