}
/*
- * Callback function for asynchrnous crypto API completion notification
+ * Wrapper for crypto_shash_init, which handles verity salting.
*/
-static void verity_op_done(struct crypto_async_request *base, int err)
+static int verity_hash_init(struct dm_verity *v, struct shash_desc *desc)
{
- struct verity_result *res = (struct verity_result *)base->data;
-
- if (err == -EINPROGRESS)
- return;
-
- res->err = err;
- complete(&res->completion);
-}
+ int r;
-/*
- * Wait for async crypto API callback
- */
-static inline int verity_complete_op(struct verity_result *res, int ret)
-{
- switch (ret) {
- case 0:
- break;
+ desc->tfm = v->tfm;
+ desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP;
- case -EINPROGRESS:
- case -EBUSY:
- ret = wait_for_completion_interruptible(&res->completion);
- if (!ret)
- ret = res->err;
- reinit_completion(&res->completion);
- break;
+ r = crypto_shash_init(desc);
- default:
- DMERR("verity_wait_hash: crypto op submission failed: %d", ret);
+ if (unlikely(r < 0)) {
+ DMERR("crypto_shash_init failed: %d", r);
+ return r;
}
- if (unlikely(ret < 0))
- DMERR("verity_wait_hash: crypto op failed: %d", ret);
-
- return ret;
-}
+ if (likely(v->version >= 1)) {
+ r = crypto_shash_update(desc, v->salt, v->salt_size);
-static int verity_hash_update(struct dm_verity *v, struct ahash_request *req,
- const u8 *data, size_t len,
- struct verity_result *res)
-{
- struct scatterlist sg;
-
- sg_init_one(&sg, data, len);
- ahash_request_set_crypt(req, &sg, NULL, len);
+ if (unlikely(r < 0)) {
+ DMERR("crypto_shash_update failed: %d", r);
+ return r;
+ }
+ }
- return verity_complete_op(res, crypto_ahash_update(req));
+ return 0;
}
-/*
- * Wrapper for crypto_ahash_init, which handles verity salting.
- */
-static int verity_hash_init(struct dm_verity *v, struct ahash_request *req,
- struct verity_result *res)
+static int verity_hash_update(struct dm_verity *v, struct shash_desc *desc,
+ const u8 *data, size_t len)
{
- int r;
-
- ahash_request_set_tfm(req, v->tfm);
- ahash_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP |
- CRYPTO_TFM_REQ_MAY_BACKLOG,
- verity_op_done, (void *)res);
- init_completion(&res->completion);
-
- r = verity_complete_op(res, crypto_ahash_init(req));
+ int r = crypto_shash_update(desc, data, len);
- if (unlikely(r < 0)) {
- DMERR("crypto_ahash_init failed: %d", r);
- return r;
- }
-
- if (likely(v->salt_size && (v->version >= 1)))
- r = verity_hash_update(v, req, v->salt, v->salt_size, res);
+ if (unlikely(r < 0))
+ DMERR("crypto_shash_update failed: %d", r);
return r;
}
-static int verity_hash_final(struct dm_verity *v, struct ahash_request *req,
- u8 *digest, struct verity_result *res)
+static int verity_hash_final(struct dm_verity *v, struct shash_desc *desc,
+ u8 *digest)
{
int r;
- if (unlikely(v->salt_size && (!v->version))) {
- r = verity_hash_update(v, req, v->salt, v->salt_size, res);
+ if (unlikely(!v->version)) {
+ r = crypto_shash_update(desc, v->salt, v->salt_size);
if (r < 0) {
- DMERR("verity_hash_final failed updating salt: %d", r);
- goto out;
+ DMERR("crypto_shash_update failed: %d", r);
+ return r;
}
}
- ahash_request_set_crypt(req, NULL, digest, 0);
- r = verity_complete_op(res, crypto_ahash_final(req));
-out:
+ r = crypto_shash_final(desc, digest);
+
+ if (unlikely(r < 0))
+ DMERR("crypto_shash_final failed: %d", r);
+
return r;
}
-int verity_hash(struct dm_verity *v, struct ahash_request *req,
+int verity_hash(struct dm_verity *v, struct shash_desc *desc,
const u8 *data, size_t len, u8 *digest)
{
int r;
- struct verity_result res;
- r = verity_hash_init(v, req, &res);
+ r = verity_hash_init(v, desc);
if (unlikely(r < 0))
- goto out;
+ return r;
- r = verity_hash_update(v, req, data, len, &res);
+ r = verity_hash_update(v, desc, data, len);
if (unlikely(r < 0))
- goto out;
-
- r = verity_hash_final(v, req, digest, &res);
+ return r;
-out:
- return r;
+ return verity_hash_final(v, desc, digest);
}
static void verity_hash_at_level(struct dm_verity *v, sector_t block, int level,
goto release_ret_r;
}
- r = verity_hash(v, verity_io_hash_req(v, io),
+ r = verity_hash(v, verity_io_hash_desc(v, io),
data, 1 << v->hash_dev_block_bits,
verity_io_real_digest(v, io));
if (unlikely(r < 0))
return r;
}
-/*
- * Calculates the digest for the given bio
- */
-int verity_for_io_block(struct dm_verity *v, struct dm_verity_io *io,
- struct bvec_iter *iter, struct verity_result *res)
-{
- unsigned int todo = 1 << v->data_dev_block_bits;
- struct bio *bio = dm_bio_from_per_bio_data(io, v->ti->per_io_data_size);
- struct scatterlist sg;
- struct ahash_request *req = verity_io_hash_req(v, io);
-
- do {
- int r;
- unsigned int len;
- struct bio_vec bv = bio_iter_iovec(bio, *iter);
-
- sg_init_table(&sg, 1);
-
- len = bv.bv_len;
-
- if (likely(len >= todo))
- len = todo;
- /*
- * Operating on a single page at a time looks suboptimal
- * until you consider the typical block size is 4,096B.
- * Going through this loops twice should be very rare.
- */
- sg_set_page(&sg, bv.bv_page, len, bv.bv_offset);
- ahash_request_set_crypt(req, &sg, NULL, len);
- r = verity_complete_op(res, crypto_ahash_update(req));
-
- if (unlikely(r < 0)) {
- DMERR("verity_for_io_block crypto op failed: %d", r);
- return r;
- }
-
- bio_advance_iter(bio, iter, len);
- todo -= len;
- } while (todo);
-
- return 0;
-}
-
/*
* Calls function process for 1 << v->data_dev_block_bits bytes in the bio_vec
* starting from iter.
return 0;
}
+static int verity_bv_hash_update(struct dm_verity *v, struct dm_verity_io *io,
+ u8 *data, size_t len)
+{
+ return verity_hash_update(v, verity_io_hash_desc(v, io), data, len);
+}
+
static int verity_bv_zero(struct dm_verity *v, struct dm_verity_io *io,
u8 *data, size_t len)
{
struct dm_verity *v = io->v;
struct bvec_iter start;
unsigned b;
- struct verity_result res;
for (b = 0; b < io->n_blocks; b++) {
int r;
+ struct shash_desc *desc = verity_io_hash_desc(v, io);
sector_t cur_block = io->block + b;
- struct ahash_request *req = verity_io_hash_req(v, io);
if (v->validated_blocks &&
likely(test_bit(cur_block, v->validated_blocks))) {
continue;
}
- r = verity_hash_init(v, req, &res);
+ r = verity_hash_init(v, desc);
if (unlikely(r < 0))
return r;
start = io->iter;
- r = verity_for_io_block(v, io, &io->iter, &res);
+ r = verity_for_bv_block(v, io, &io->iter, verity_bv_hash_update);
if (unlikely(r < 0))
return r;
- r = verity_hash_final(v, req, verity_io_real_digest(v, io),
- &res);
+ r = verity_hash_final(v, desc, verity_io_real_digest(v, io));
if (unlikely(r < 0))
return r;
kfree(v->zero_digest);
if (v->tfm)
- crypto_free_ahash(v->tfm);
+ crypto_free_shash(v->tfm);
kfree(v->alg_name);
static int verity_alloc_zero_digest(struct dm_verity *v)
{
int r = -ENOMEM;
- struct ahash_request *req;
+ struct shash_desc *desc;
u8 *zero_data;
v->zero_digest = kmalloc(v->digest_size, GFP_KERNEL);
if (!v->zero_digest)
return r;
- req = kmalloc(v->ahash_reqsize, GFP_KERNEL);
+ desc = kmalloc(v->shash_descsize, GFP_KERNEL);
- if (!req)
+ if (!desc)
return r; /* verity_dtr will free zero_digest */
zero_data = kzalloc(1 << v->data_dev_block_bits, GFP_KERNEL);
if (!zero_data)
goto out;
- r = verity_hash(v, req, zero_data, 1 << v->data_dev_block_bits,
+ r = verity_hash(v, desc, zero_data, 1 << v->data_dev_block_bits,
v->zero_digest);
out:
- kfree(req);
+ kfree(desc);
kfree(zero_data);
return r;
goto bad;
}
- v->tfm = crypto_alloc_ahash(v->alg_name, 0, 0);
+ v->tfm = crypto_alloc_shash(v->alg_name, 0, 0);
if (IS_ERR(v->tfm)) {
ti->error = "Cannot initialize hash function";
r = PTR_ERR(v->tfm);
v->tfm = NULL;
goto bad;
}
- v->digest_size = crypto_ahash_digestsize(v->tfm);
+ v->digest_size = crypto_shash_digestsize(v->tfm);
if ((1 << v->hash_dev_block_bits) < v->digest_size * 2) {
ti->error = "Digest size too big";
r = -EINVAL;
goto bad;
}
- v->ahash_reqsize = sizeof(struct ahash_request) +
- crypto_ahash_reqsize(v->tfm);
+ v->shash_descsize =
+ sizeof(struct shash_desc) + crypto_shash_descsize(v->tfm);
v->root_digest = kmalloc(v->digest_size, GFP_KERNEL);
if (!v->root_digest) {
}
ti->per_io_data_size = sizeof(struct dm_verity_io) +
- v->ahash_reqsize + v->digest_size * 2;
+ v->shash_descsize + v->digest_size * 2;
r = verity_fec_ctr(v);
if (r)
struct dm_target *ti;
struct dm_bufio_client *bufio;
char *alg_name;
- struct crypto_ahash *tfm;
+ struct crypto_shash *tfm;
u8 *root_digest; /* digest of the root block */
u8 *salt; /* salt: its size is salt_size */
u8 *zero_digest; /* digest for a zero block */
unsigned char levels; /* the number of tree levels */
unsigned char version;
unsigned digest_size; /* digest size for the current hash algorithm */
- unsigned int ahash_reqsize;/* the size of temporary space for crypto */
+ unsigned shash_descsize;/* the size of temporary space for crypto */
int hash_failed; /* set to 1 if hash of any block failed */
enum verity_mode mode; /* mode for handling verification errors */
unsigned corrupted_errs;/* Number of errors for corrupted blocks */
/*
* Three variably-size fields follow this struct:
*
- * u8 hash_req[v->ahash_reqsize];
+ * u8 hash_desc[v->shash_descsize];
* u8 real_digest[v->digest_size];
* u8 want_digest[v->digest_size];
*
- * To access them use: verity_io_hash_req(), verity_io_real_digest()
+ * To access them use: verity_io_hash_desc(), verity_io_real_digest()
* and verity_io_want_digest().
*/
};
-struct verity_result {
- struct completion completion;
- int err;
-};
-
-static inline struct ahash_request *verity_io_hash_req(struct dm_verity *v,
+static inline struct shash_desc *verity_io_hash_desc(struct dm_verity *v,
struct dm_verity_io *io)
{
- return (struct ahash_request *)(io + 1);
+ return (struct shash_desc *)(io + 1);
}
static inline u8 *verity_io_real_digest(struct dm_verity *v,
struct dm_verity_io *io)
{
- return (u8 *)(io + 1) + v->ahash_reqsize;
+ return (u8 *)(io + 1) + v->shash_descsize;
}
static inline u8 *verity_io_want_digest(struct dm_verity *v,
struct dm_verity_io *io)
{
- return (u8 *)(io + 1) + v->ahash_reqsize + v->digest_size;
+ return (u8 *)(io + 1) + v->shash_descsize + v->digest_size;
}
static inline u8 *verity_io_digest_end(struct dm_verity *v,
struct dm_verity_io *io,
u8 *data, size_t len));
-extern int verity_hash(struct dm_verity *v, struct ahash_request *req,
+extern int verity_hash(struct dm_verity *v, struct shash_desc *desc,
const u8 *data, size_t len, u8 *digest);
extern int verity_hash_for_block(struct dm_verity *v, struct dm_verity_io *io,
projects / GitHub / LineageOS / android_kernel_motorola_exynos9610.git / commitdiff