Commit cb77cb5a authored by Eric Biggers's avatar Eric Biggers Committed by Jens Axboe
Browse files

blk-crypto: rename blk_keyslot_manager to blk_crypto_profile 



blk_keyslot_manager is misnamed because it doesn't necessarily manage
keyslots.  It actually does several different things:

  - Contains the crypto capabilities of the device.

  - Provides functions to control the inline encryption hardware.
    Originally these were just for programming/evicting keyslots;
    however, new functionality (hardware-wrapped keys) will require new
    functions here which are unrelated to keyslots.  Moreover,
    device-mapper devices already (ab)use "keyslot_evict" to pass key
    eviction requests to their underlying devices even though
    device-mapper devices don't have any keyslots themselves (so it
    really should be "evict_key", not "keyslot_evict").

  - Sometimes (but not always!) it manages keyslots.  Originally it
    always did, but device-mapper devices don't have keyslots
    themselves, so they use a "passthrough keyslot manager" which
    doesn't actually manage keyslots.  This hack works, but the
    terminology is unnatural.  Also, some hardware doesn't have keyslots
    and thus also uses a "passthrough keyslot manager" (support for such
    hardware is yet to be upstreamed, but it will happen eventually).

Let's stop having keyslot managers which don't actually manage keyslots.
Instead, rename blk_keyslot_manager to blk_crypto_profile.

This is a fairly big change, since for consistency it also has to update
keyslot manager-related function names, variable names, and comments --
not just the actual struct name.  However it's still a fairly
straightforward change, as it doesn't change any actual functionality.

Acked-by: Ulf Hansson <ulf.hansson@linaro.org> # For MMC
Reviewed-by: default avatarMike Snitzer <snitzer@redhat.com>
Reviewed-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
Link: https://lore.kernel.org/r/20211018180453.40441-4-ebiggers@kernel.org


Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent 1e8d44bd

block/blk-crypto-fallback.c

+35 −36
Original line number Diff line number Diff line
@@ -78,7 +78,7 @@ static struct blk_crypto_fallback_keyslot { 
	struct crypto_skcipher *tfms[BLK_ENCRYPTION_MODE_MAX];

} *blk_crypto_keyslots;



static struct blk_keyslot_manager blk_crypto_ksm;

static struct blk_crypto_profile blk_crypto_fallback_profile;

static struct workqueue_struct *blk_crypto_wq;

static mempool_t *blk_crypto_bounce_page_pool;

static struct bio_set crypto_bio_split;
@@ -104,7 +104,8 @@ static void blk_crypto_fallback_evict_keyslot(unsigned int slot) 
	slotp->crypto_mode = BLK_ENCRYPTION_MODE_INVALID;

}



static int blk_crypto_fallback_keyslot_program(struct blk_keyslot_manager *ksm,

static int

blk_crypto_fallback_keyslot_program(struct blk_crypto_profile *profile,

				    const struct blk_crypto_key *key,

				    unsigned int slot)

{
@@ -127,7 +128,7 @@ static int blk_crypto_fallback_keyslot_program(struct blk_keyslot_manager *ksm, 
	return 0;

}



static int blk_crypto_fallback_keyslot_evict(struct blk_keyslot_manager *ksm,

static int blk_crypto_fallback_keyslot_evict(struct blk_crypto_profile *profile,

					     const struct blk_crypto_key *key,

					     unsigned int slot)

{
@@ -135,12 +136,7 @@ static int blk_crypto_fallback_keyslot_evict(struct blk_keyslot_manager *ksm, 
	return 0;

}



/*

 * The crypto API fallback KSM ops - only used for a bio when it specifies a

 * blk_crypto_key that was not supported by the device's inline encryption

 * hardware.

 */

static const struct blk_ksm_ll_ops blk_crypto_ksm_ll_ops = {

static const struct blk_crypto_ll_ops blk_crypto_fallback_ll_ops = {

	.keyslot_program        = blk_crypto_fallback_keyslot_program,

	.keyslot_evict          = blk_crypto_fallback_keyslot_evict,

};
@@ -188,13 +184,13 @@ static struct bio *blk_crypto_fallback_clone_bio(struct bio *bio_src) 
}



static bool

blk_crypto_fallback_alloc_cipher_req(struct blk_ksm_keyslot *slot,

blk_crypto_fallback_alloc_cipher_req(struct blk_crypto_keyslot *slot,

				     struct skcipher_request **ciph_req_ret,

				     struct crypto_wait *wait)

{

	struct skcipher_request *ciph_req;

	const struct blk_crypto_fallback_keyslot *slotp;

	int keyslot_idx = blk_ksm_get_slot_idx(slot);

	int keyslot_idx = blk_crypto_keyslot_index(slot);



	slotp = &blk_crypto_keyslots[keyslot_idx];

	ciph_req = skcipher_request_alloc(slotp->tfms[slotp->crypto_mode],
@@ -266,7 +262,7 @@ static bool blk_crypto_fallback_encrypt_bio(struct bio **bio_ptr) 
{

	struct bio *src_bio, *enc_bio;

	struct bio_crypt_ctx *bc;

	struct blk_ksm_keyslot *slot;

	struct blk_crypto_keyslot *slot;

	int data_unit_size;

	struct skcipher_request *ciph_req = NULL;

	DECLARE_CRYPTO_WAIT(wait);
@@ -293,10 +289,11 @@ static bool blk_crypto_fallback_encrypt_bio(struct bio **bio_ptr) 
	}



	/*

	 * Use the crypto API fallback keyslot manager to get a crypto_skcipher

	 * for the algorithm and key specified for this bio.

	 * Get a blk-crypto-fallback keyslot that contains a crypto_skcipher for

	 * this bio's algorithm and key.

	 */

	blk_st = blk_ksm_get_slot_for_key(&blk_crypto_ksm, bc->bc_key, &slot);

	blk_st = blk_crypto_get_keyslot(&blk_crypto_fallback_profile,

					bc->bc_key, &slot);

	if (blk_st != BLK_STS_OK) {

		src_bio->bi_status = blk_st;

		goto out_put_enc_bio;
@@ -364,7 +361,7 @@ static bool blk_crypto_fallback_encrypt_bio(struct bio **bio_ptr) 
out_free_ciph_req:

	skcipher_request_free(ciph_req);

out_release_keyslot:

	blk_ksm_put_slot(slot);

	blk_crypto_put_keyslot(slot);

out_put_enc_bio:

	if (enc_bio)

		bio_put(enc_bio);
@@ -382,7 +379,7 @@ static void blk_crypto_fallback_decrypt_bio(struct work_struct *work) 
		container_of(work, struct bio_fallback_crypt_ctx, work);

	struct bio *bio = f_ctx->bio;

	struct bio_crypt_ctx *bc = &f_ctx->crypt_ctx;

	struct blk_ksm_keyslot *slot;

	struct blk_crypto_keyslot *slot;

	struct skcipher_request *ciph_req = NULL;

	DECLARE_CRYPTO_WAIT(wait);

	u64 curr_dun[BLK_CRYPTO_DUN_ARRAY_SIZE];
@@ -395,10 +392,11 @@ static void blk_crypto_fallback_decrypt_bio(struct work_struct *work) 
	blk_status_t blk_st;



	/*

	 * Use the crypto API fallback keyslot manager to get a crypto_skcipher

	 * for the algorithm and key specified for this bio.

	 * Get a blk-crypto-fallback keyslot that contains a crypto_skcipher for

	 * this bio's algorithm and key.

	 */

	blk_st = blk_ksm_get_slot_for_key(&blk_crypto_ksm, bc->bc_key, &slot);

	blk_st = blk_crypto_get_keyslot(&blk_crypto_fallback_profile,

					bc->bc_key, &slot);

	if (blk_st != BLK_STS_OK) {

		bio->bi_status = blk_st;

		goto out_no_keyslot;
@@ -436,7 +434,7 @@ static void blk_crypto_fallback_decrypt_bio(struct work_struct *work) 


out:

	skcipher_request_free(ciph_req);

	blk_ksm_put_slot(slot);

	blk_crypto_put_keyslot(slot);

out_no_keyslot:

	mempool_free(f_ctx, bio_fallback_crypt_ctx_pool);

	bio_endio(bio);
@@ -501,7 +499,7 @@ bool blk_crypto_fallback_bio_prep(struct bio **bio_ptr) 
		return false;

	}



	if (!blk_ksm_crypto_cfg_supported(&blk_crypto_ksm,

	if (!__blk_crypto_cfg_supported(&blk_crypto_fallback_profile,

					&bc->bc_key->crypto_cfg)) {

		bio->bi_status = BLK_STS_NOTSUPP;

		return false;
@@ -528,7 +526,7 @@ bool blk_crypto_fallback_bio_prep(struct bio **bio_ptr) 


int blk_crypto_fallback_evict_key(const struct blk_crypto_key *key)

{

	return blk_ksm_evict_key(&blk_crypto_ksm, key);

	return __blk_crypto_evict_key(&blk_crypto_fallback_profile, key);

}



static bool blk_crypto_fallback_inited;
@@ -536,6 +534,7 @@ static int blk_crypto_fallback_init(void) 
{

	int i;

	int err;

	struct blk_crypto_profile *profile = &blk_crypto_fallback_profile;



	if (blk_crypto_fallback_inited)

		return 0;
@@ -546,24 +545,24 @@ static int blk_crypto_fallback_init(void) 
	if (err)

		goto out;



	err = blk_ksm_init(&blk_crypto_ksm, blk_crypto_num_keyslots);

	err = blk_crypto_profile_init(profile, blk_crypto_num_keyslots);

	if (err)

		goto fail_free_bioset;

	err = -ENOMEM;



	blk_crypto_ksm.ksm_ll_ops = blk_crypto_ksm_ll_ops;

	blk_crypto_ksm.max_dun_bytes_supported = BLK_CRYPTO_MAX_IV_SIZE;

	profile->ll_ops = blk_crypto_fallback_ll_ops;

	profile->max_dun_bytes_supported = BLK_CRYPTO_MAX_IV_SIZE;



	/* All blk-crypto modes have a crypto API fallback. */

	for (i = 0; i < BLK_ENCRYPTION_MODE_MAX; i++)

		blk_crypto_ksm.crypto_modes_supported[i] = 0xFFFFFFFF;

	blk_crypto_ksm.crypto_modes_supported[BLK_ENCRYPTION_MODE_INVALID] = 0;

		profile->modes_supported[i] = 0xFFFFFFFF;

	profile->modes_supported[BLK_ENCRYPTION_MODE_INVALID] = 0;



	blk_crypto_wq = alloc_workqueue("blk_crypto_wq",

					WQ_UNBOUND | WQ_HIGHPRI |

					WQ_MEM_RECLAIM, num_online_cpus());

	if (!blk_crypto_wq)

		goto fail_free_ksm;

		goto fail_destroy_profile;



	blk_crypto_keyslots = kcalloc(blk_crypto_num_keyslots,

				      sizeof(blk_crypto_keyslots[0]),
@@ -597,8 +596,8 @@ static int blk_crypto_fallback_init(void) 
	kfree(blk_crypto_keyslots);

fail_free_wq:

	destroy_workqueue(blk_crypto_wq);

fail_free_ksm:

	blk_ksm_destroy(&blk_crypto_ksm);

fail_destroy_profile:

	blk_crypto_profile_destroy(profile);

fail_free_bioset:

	bioset_exit(&crypto_bio_split);

out:

block/blk-crypto-profile.c

+253 −267

File changed.

Preview size limit exceeded, changes collapsed.

block/blk-crypto.c

+14 −13
Original line number Diff line number Diff line
@@ -218,7 +218,8 @@ static bool bio_crypt_check_alignment(struct bio *bio) 


blk_status_t __blk_crypto_init_request(struct request *rq)

{

	return blk_ksm_get_slot_for_key(rq->q->ksm, rq->crypt_ctx->bc_key,

	return blk_crypto_get_keyslot(rq->q->crypto_profile,

				      rq->crypt_ctx->bc_key,

				      &rq->crypt_keyslot);

}
@@ -233,7 +234,7 @@ blk_status_t __blk_crypto_init_request(struct request *rq) 
 */

void __blk_crypto_free_request(struct request *rq)

{

	blk_ksm_put_slot(rq->crypt_keyslot);

	blk_crypto_put_keyslot(rq->crypt_keyslot);

	mempool_free(rq->crypt_ctx, bio_crypt_ctx_pool);

	blk_crypto_rq_set_defaults(rq);

}
@@ -264,6 +265,7 @@ bool __blk_crypto_bio_prep(struct bio **bio_ptr) 
{

	struct bio *bio = *bio_ptr;

	const struct blk_crypto_key *bc_key = bio->bi_crypt_context->bc_key;

	struct blk_crypto_profile *profile;



	/* Error if bio has no data. */

	if (WARN_ON_ONCE(!bio_has_data(bio))) {
@@ -280,8 +282,8 @@ bool __blk_crypto_bio_prep(struct bio **bio_ptr) 
	 * Success if device supports the encryption context, or if we succeeded

	 * in falling back to the crypto API.

	 */

	if (blk_ksm_crypto_cfg_supported(bdev_get_queue(bio->bi_bdev)->ksm,

					 &bc_key->crypto_cfg))

	profile = bdev_get_queue(bio->bi_bdev)->crypto_profile;

	if (__blk_crypto_cfg_supported(profile, &bc_key->crypto_cfg))

		return true;



	if (blk_crypto_fallback_bio_prep(bio_ptr))
@@ -357,7 +359,7 @@ bool blk_crypto_config_supported(struct request_queue *q, 
				 const struct blk_crypto_config *cfg)

{

	return IS_ENABLED(CONFIG_BLK_INLINE_ENCRYPTION_FALLBACK) ||

	       blk_ksm_crypto_cfg_supported(q->ksm, cfg);

	       __blk_crypto_cfg_supported(q->crypto_profile, cfg);

}



/**
@@ -378,7 +380,7 @@ bool blk_crypto_config_supported(struct request_queue *q, 
int blk_crypto_start_using_key(const struct blk_crypto_key *key,

			       struct request_queue *q)

{

	if (blk_ksm_crypto_cfg_supported(q->ksm, &key->crypto_cfg))

	if (__blk_crypto_cfg_supported(q->crypto_profile, &key->crypto_cfg))

		return 0;

	return blk_crypto_fallback_start_using_mode(key->crypto_cfg.crypto_mode);

}
@@ -394,18 +396,17 @@ int blk_crypto_start_using_key(const struct blk_crypto_key *key, 
 * evicted from any hardware that it might have been programmed into.  The key

 * must not be in use by any in-flight IO when this function is called.

 *

 * Return: 0 on success or if key is not present in the q's ksm, -err on error.

 * Return: 0 on success or if the key wasn't in any keyslot; -errno on error.

 */

int blk_crypto_evict_key(struct request_queue *q,

			 const struct blk_crypto_key *key)

{

	if (blk_ksm_crypto_cfg_supported(q->ksm, &key->crypto_cfg))

		return blk_ksm_evict_key(q->ksm, key);

	if (__blk_crypto_cfg_supported(q->crypto_profile, &key->crypto_cfg))

		return __blk_crypto_evict_key(q->crypto_profile, key);



	/*

	 * If the request queue's associated inline encryption hardware didn't

	 * have support for the key, then the key might have been programmed

	 * into the fallback keyslot manager, so try to evict from there.

	 * If the request_queue didn't support the key, then blk-crypto-fallback

	 * may have been used, so try to evict the key from blk-crypto-fallback.

	 */

	return blk_crypto_fallback_evict_key(key);

}

block/blk-integrity.c

+2 −2
Original line number Diff line number Diff line
@@ -409,9 +409,9 @@ void blk_integrity_register(struct gendisk *disk, struct blk_integrity *template 
	blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, disk->queue);



#ifdef CONFIG_BLK_INLINE_ENCRYPTION

	if (disk->queue->ksm) {

	if (disk->queue->crypto_profile) {

		pr_warn("blk-integrity: Integrity and hardware inline encryption are not supported together. Disabling hardware inline encryption.\n");

		blk_ksm_unregister(disk->queue);

		blk_crypto_unregister(disk->queue);

	}

#endif

}

drivers/md/dm-core.h

+1 −1
Original line number Diff line number Diff line
@@ -200,7 +200,7 @@ struct dm_table { 
	struct dm_md_mempools *mempools;



#ifdef CONFIG_BLK_INLINE_ENCRYPTION

	struct blk_keyslot_manager *ksm;

	struct blk_crypto_profile *crypto_profile;

#endif

};