mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

block/crypto: create ciphers on demand

Browse Source 
Ciphers are pre-allocated by qcrypto_block_init_cipher() depending on
the given number of threads. The -device
virtio-blk-pci,iothread-vq-mapping= feature allows users to assign
multiple IOThreads to a virtio-blk device, but the association between
the virtio-blk device and the block driver happens after the block
driver is already open.

When the number of threads given to qcrypto_block_init_cipher() is
smaller than the actual number of threads at runtime, the
block->n_free_ciphers > 0 assertion in qcrypto_block_pop_cipher() can
fail.

Get rid of qcrypto_block_init_cipher() n_thread's argument and allocate
ciphers on demand.

Reported-by: Qing Wang <qinwang@redhat.com>
Buglink: https://issues.redhat.com/browse/RHEL-36159
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-ID: <20240527155851.892885-2-stefanha@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Acked-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Stefan Hajnoczi 2024-05-27 11:58:50 -04:00 committed by Kevin Wolf
parent 24687abf23
commit af206c284e
4 changed files with 78 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
crypto/block-luks.c
View File

@ -1262,7 +1262,6 @@ qcrypto_block_luks_open(QCryptoBlock *block,
luks->cipher_mode,
masterkey,
luks->header.master_key_len,
n_threads,
errp) < 0) {
goto fail;
}
@ -1456,7 +1455,7 @@ qcrypto_block_luks_create(QCryptoBlock *block,
/* Setup the block device payload encryption objects */
if (qcrypto_block_init_cipher(block, luks_opts.cipher_alg,
luks_opts.cipher_mode, masterkey,
luks->header.master_key_len, 1, errp) < 0) {
luks->header.master_key_len, errp) < 0) {
goto error;
}

2
crypto/block-qcow.c
View File

@ -75,7 +75,7 @@ qcrypto_block_qcow_init(QCryptoBlock *block,
ret = qcrypto_block_init_cipher(block, QCRYPTO_CIPHER_ALG_AES_128,
QCRYPTO_CIPHER_MODE_CBC,
keybuf, G_N_ELEMENTS(keybuf),
n_threads, errp);
errp);
if (ret < 0) {
ret = -ENOTSUP;
goto fail;

111
crypto/block.c
View File

@ -20,6 +20,7 @@
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu/lockable.h"
#include "blockpriv.h"
#include "block-qcow.h"
#include "block-luks.h"
@ -57,6 +58,8 @@ QCryptoBlock *qcrypto_block_open(QCryptoBlockOpenOptions *options,
{
QCryptoBlock *block = g_new0(QCryptoBlock, 1);
qemu_mutex_init(&block->mutex);
block->format = options->format;
if (options->format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
@ -76,8 +79,6 @@ QCryptoBlock *qcrypto_block_open(QCryptoBlockOpenOptions *options,
return NULL;
}
qemu_mutex_init(&block->mutex);
return block;
}
@ -92,6 +93,8 @@ QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
{
QCryptoBlock *block = g_new0(QCryptoBlock, 1);
qemu_mutex_init(&block->mutex);
block->format = options->format;
if (options->format >= G_N_ELEMENTS(qcrypto_block_drivers) ||
@ -111,8 +114,6 @@ QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
return NULL;
}
qemu_mutex_init(&block->mutex);
return block;
}
@ -227,37 +228,42 @@ QCryptoCipher *qcrypto_block_get_cipher(QCryptoBlock *block)
* This function is used only in test with one thread (it's safe to skip
* pop/push interface), so it's enough to assert it here:
*/
assert(block->n_ciphers <= 1);
return block->ciphers ? block->ciphers[0] : NULL;
assert(block->max_free_ciphers <= 1);
return block->free_ciphers ? block->free_ciphers[0] : NULL;
}
static QCryptoCipher *qcrypto_block_pop_cipher(QCryptoBlock *block)
static QCryptoCipher *qcrypto_block_pop_cipher(QCryptoBlock *block,
Error **errp)
{
QCryptoCipher *cipher;
/* Usually there is a free cipher available */
WITH_QEMU_LOCK_GUARD(&block->mutex) {
if (block->n_free_ciphers > 0) {
block->n_free_ciphers--;
return block->free_ciphers[block->n_free_ciphers];
}
}
qemu_mutex_lock(&block->mutex);
assert(block->n_free_ciphers > 0);
block->n_free_ciphers--;
cipher = block->ciphers[block->n_free_ciphers];
qemu_mutex_unlock(&block->mutex);
return cipher;
/* Otherwise allocate a new cipher */
return qcrypto_cipher_new(block->alg, block->mode, block->key,
block->nkey, errp);
}
static void qcrypto_block_push_cipher(QCryptoBlock *block,
QCryptoCipher *cipher)
{
qemu_mutex_lock(&block->mutex);
QEMU_LOCK_GUARD(&block->mutex);
assert(block->n_free_ciphers < block->n_ciphers);
block->ciphers[block->n_free_ciphers] = cipher;
if (block->n_free_ciphers == block->max_free_ciphers) {
block->max_free_ciphers++;
block->free_ciphers = g_renew(QCryptoCipher *,
block->free_ciphers,
block->max_free_ciphers);
}
block->free_ciphers[block->n_free_ciphers] = cipher;
block->n_free_ciphers++;
qemu_mutex_unlock(&block->mutex);
}
@ -265,24 +271,31 @@ int qcrypto_block_init_cipher(QCryptoBlock *block,
QCryptoCipherAlgorithm alg,
QCryptoCipherMode mode,
const uint8_t *key, size_t nkey,
size_t n_threads, Error **errp)
Error **errp)
{
size_t i;
QCryptoCipher *cipher;
assert(!block->ciphers && !block->n_ciphers && !block->n_free_ciphers);
assert(!block->free_ciphers && !block->max_free_ciphers &&
!block->n_free_ciphers);
block->ciphers = g_new0(QCryptoCipher *, n_threads);
/* Stash away cipher parameters for qcrypto_block_pop_cipher() */
block->alg = alg;
block->mode = mode;
block->key = g_memdup2(key, nkey);
block->nkey = nkey;
for (i = 0; i < n_threads; i++) {
block->ciphers[i] = qcrypto_cipher_new(alg, mode, key, nkey, errp);
if (!block->ciphers[i]) {
qcrypto_block_free_cipher(block);
return -1;
}
block->n_ciphers++;
block->n_free_ciphers++;
/*
* Create a new cipher to validate the parameters now. This reduces the
* chance of cipher creation failing at I/O time.
*/
cipher = qcrypto_block_pop_cipher(block, errp);
if (!cipher) {
g_free(block->key);
block->key = NULL;
return -1;
}
qcrypto_block_push_cipher(block, cipher);
return 0;
}
@ -291,19 +304,23 @@ void qcrypto_block_free_cipher(QCryptoBlock *block)
{
size_t i;
if (!block->ciphers) {
g_free(block->key);
block->key = NULL;
if (!block->free_ciphers) {
return;
}
assert(block->n_ciphers == block->n_free_ciphers);
/* All popped ciphers were eventually pushed back */
assert(block->n_free_ciphers == block->max_free_ciphers);
for (i = 0; i < block->n_ciphers; i++) {
qcrypto_cipher_free(block->ciphers[i]);
for (i = 0; i < block->max_free_ciphers; i++) {
qcrypto_cipher_free(block->free_ciphers[i]);
}
g_free(block->ciphers);
block->ciphers = NULL;
block->n_ciphers = block->n_free_ciphers = 0;
g_free(block->free_ciphers);
block->free_ciphers = NULL;
block->max_free_ciphers = block->n_free_ciphers = 0;
}
QCryptoIVGen *qcrypto_block_get_ivgen(QCryptoBlock *block)
@ -311,7 +328,7 @@ QCryptoIVGen *qcrypto_block_get_ivgen(QCryptoBlock *block)
/* ivgen should be accessed under mutex. However, this function is used only
* in test with one thread, so it's enough to assert it here:
*/
assert(block->n_ciphers <= 1);
assert(block->max_free_ciphers <= 1);
return block->ivgen;
}
@ -446,7 +463,10 @@ int qcrypto_block_decrypt_helper(QCryptoBlock *block,
Error **errp)
{
int ret;
QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
QCryptoCipher *cipher = qcrypto_block_pop_cipher(block, errp);
if (!cipher) {
return -1;
}
ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
&block->mutex, sectorsize, offset, buf,
@ -465,7 +485,10 @@ int qcrypto_block_encrypt_helper(QCryptoBlock *block,
Error **errp)
{
int ret;
QCryptoCipher *cipher = qcrypto_block_pop_cipher(block);
QCryptoCipher *cipher = qcrypto_block_pop_cipher(block, errp);
if (!cipher) {
return -1;
}
ret = do_qcrypto_block_cipher_encdec(cipher, block->niv, block->ivgen,
&block->mutex, sectorsize, offset, buf,

12
crypto/blockpriv.h
View File

@ -32,8 +32,14 @@ struct QCryptoBlock {
const QCryptoBlockDriver *driver;
void *opaque;
QCryptoCipher **ciphers;
size_t n_ciphers;
/* Cipher parameters */
QCryptoCipherAlgorithm alg;
QCryptoCipherMode mode;
uint8_t *key;
size_t nkey;
QCryptoCipher **free_ciphers;
size_t max_free_ciphers;
size_t n_free_ciphers;
QCryptoIVGen *ivgen;
QemuMutex mutex;
@ -130,7 +136,7 @@ int qcrypto_block_init_cipher(QCryptoBlock *block,
QCryptoCipherAlgorithm alg,
QCryptoCipherMode mode,
const uint8_t *key, size_t nkey,
size_t n_threads, Error **errp);
Error **errp);
void qcrypto_block_free_cipher(QCryptoBlock *block);