Commit 8333c0df authored by Kevin Wolf's avatar Kevin Wolf
Browse files

Merge remote-tracking branch 'mreitz/block' into queue-block 

* mreitz/block:
  block: Eliminate silly QERR_ macros used for encryption keys
  block: New bdrv_add_key(), convert monitor to use it
  blockdev: Eliminate silly QERR_BLOCK_JOB_NOT_ACTIVE macro
  blockdev: Give find_block_job() an Error ** parameter
parents 8c44dfbc b1ca6391

block.c

+30 −0
Original line number Diff line number Diff line
@@ -3713,6 +3713,36 @@ int bdrv_set_key(BlockDriverState *bs, const char *key) 
    return ret;

}



/*

 * Provide an encryption key for @bs.

 * If @key is non-null:

 *     If @bs is not encrypted, fail.

 *     Else if the key is invalid, fail.

 *     Else set @bs's key to @key, replacing the existing key, if any.

 * If @key is null:

 *     If @bs is encrypted and still lacks a key, fail.

 *     Else do nothing.

 * On failure, store an error object through @errp if non-null.

 */

void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp)

{

    if (key) {

        if (!bdrv_is_encrypted(bs)) {

            error_setg(errp, "Device '%s' is not encrypted",

                      bdrv_get_device_name(bs));

        } else if (bdrv_set_key(bs, key) < 0) {

            error_set(errp, QERR_INVALID_PASSWORD);

        }

    } else {

        if (bdrv_key_required(bs)) {

            error_set(errp, ERROR_CLASS_DEVICE_ENCRYPTED,

                      "'%s' (%s) is encrypted",

                      bdrv_get_device_name(bs),

                      bdrv_get_encrypted_filename(bs));

        }

    }

}



const char *bdrv_get_format_name(BlockDriverState *bs)

{

    return bs->drv ? bs->drv->format_name : NULL;

blockdev.c

+11 −33
Original line number Diff line number Diff line
@@ -1793,7 +1793,6 @@ void qmp_block_passwd(bool has_device, const char *device, 
    Error *local_err = NULL;

    BlockDriverState *bs;

    AioContext *aio_context;

    int err;



    bs = bdrv_lookup_bs(has_device ? device : NULL,

                        has_node_name ? node_name : NULL,
@@ -1806,16 +1805,8 @@ void qmp_block_passwd(bool has_device, const char *device, 
    aio_context = bdrv_get_aio_context(bs);

    aio_context_acquire(aio_context);



    err = bdrv_set_key(bs, password);

    if (err == -EINVAL) {

        error_set(errp, QERR_DEVICE_NOT_ENCRYPTED, bdrv_get_device_name(bs));

        goto out;

    } else if (err < 0) {

        error_set(errp, QERR_INVALID_PASSWORD);

        goto out;

    }

    bdrv_add_key(bs, password, errp);



out:

    aio_context_release(aio_context);

}
@@ -1833,18 +1824,7 @@ static void qmp_bdrv_open_encrypted(BlockDriverState *bs, const char *filename, 
        return;

    }



    if (bdrv_key_required(bs)) {

        if (password) {

            if (bdrv_set_key(bs, password) < 0) {

                error_set(errp, QERR_INVALID_PASSWORD);

            }

        } else {

            error_set(errp, QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs),

                      bdrv_get_encrypted_filename(bs));

        }

    } else if (password) {

        error_set(errp, QERR_DEVICE_NOT_ENCRYPTED, bdrv_get_device_name(bs));

    }

    bdrv_add_key(bs, password, errp);

}



void qmp_change_blockdev(const char *device, const char *filename,
@@ -2653,7 +2633,8 @@ out: 
}



/* Get the block job for a given device name and acquire its AioContext */

static BlockJob *find_block_job(const char *device, AioContext **aio_context)

static BlockJob *find_block_job(const char *device, AioContext **aio_context,

                                Error **errp)

{

    BlockDriverState *bs;
@@ -2673,6 +2654,8 @@ static BlockJob *find_block_job(const char *device, AioContext **aio_context) 
    return bs->job;



notfound:

    error_set(errp, ERROR_CLASS_DEVICE_NOT_ACTIVE,

              "No active block job on device '%s'", device);

    *aio_context = NULL;

    return NULL;

}
@@ -2680,10 +2663,9 @@ notfound: 
void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp)

{

    AioContext *aio_context;

    BlockJob *job = find_block_job(device, &aio_context);

    BlockJob *job = find_block_job(device, &aio_context, errp);



    if (!job) {

        error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);

        return;

    }
@@ -2695,10 +2677,9 @@ void qmp_block_job_cancel(const char *device, 
                          bool has_force, bool force, Error **errp)

{

    AioContext *aio_context;

    BlockJob *job = find_block_job(device, &aio_context);

    BlockJob *job = find_block_job(device, &aio_context, errp);



    if (!job) {

        error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);

        return;

    }
@@ -2721,10 +2702,9 @@ out: 
void qmp_block_job_pause(const char *device, Error **errp)

{

    AioContext *aio_context;

    BlockJob *job = find_block_job(device, &aio_context);

    BlockJob *job = find_block_job(device, &aio_context, errp);



    if (!job) {

        error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);

        return;

    }
@@ -2736,10 +2716,9 @@ void qmp_block_job_pause(const char *device, Error **errp) 
void qmp_block_job_resume(const char *device, Error **errp)

{

    AioContext *aio_context;

    BlockJob *job = find_block_job(device, &aio_context);

    BlockJob *job = find_block_job(device, &aio_context, errp);



    if (!job) {

        error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);

        return;

    }
@@ -2751,10 +2730,9 @@ void qmp_block_job_resume(const char *device, Error **errp) 
void qmp_block_job_complete(const char *device, Error **errp)

{

    AioContext *aio_context;

    BlockJob *job = find_block_job(device, &aio_context);

    BlockJob *job = find_block_job(device, &aio_context, errp);



    if (!job) {

        error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);

        return;

    }

include/block/block.h

+1 −0
Original line number Diff line number Diff line
@@ -381,6 +381,7 @@ BlockDriverState *bdrv_next(BlockDriverState *bs); 
int bdrv_is_encrypted(BlockDriverState *bs);

int bdrv_key_required(BlockDriverState *bs);

int bdrv_set_key(BlockDriverState *bs, const char *key);

void bdrv_add_key(BlockDriverState *bs, const char *key, Error **errp);

int bdrv_query_missing_keys(void);

void bdrv_iterate_format(void (*it)(void *opaque, const char *name),

                         void *opaque);

include/qapi/qmp/qerror.h

+0 −9
Original line number Diff line number Diff line
@@ -37,9 +37,6 @@ void qerror_report_err(Error *err); 
#define QERR_BASE_NOT_FOUND \

    ERROR_CLASS_GENERIC_ERROR, "Base '%s' not found"



#define QERR_BLOCK_JOB_NOT_ACTIVE \

    ERROR_CLASS_DEVICE_NOT_ACTIVE, "No active block job on device '%s'"



#define QERR_BLOCK_JOB_NOT_READY \

    ERROR_CLASS_GENERIC_ERROR, "The active block job for device '%s' cannot be completed"
@@ -52,9 +49,6 @@ void qerror_report_err(Error *err); 
#define QERR_BUS_NOT_FOUND \

    ERROR_CLASS_GENERIC_ERROR, "Bus '%s' not found"



#define QERR_DEVICE_ENCRYPTED \

    ERROR_CLASS_DEVICE_ENCRYPTED, "'%s' (%s) is encrypted"



#define QERR_DEVICE_HAS_NO_MEDIUM \

    ERROR_CLASS_GENERIC_ERROR, "Device '%s' has no medium"
@@ -70,9 +64,6 @@ void qerror_report_err(Error *err); 
#define QERR_DEVICE_NO_HOTPLUG \

    ERROR_CLASS_GENERIC_ERROR, "Device '%s' does not support hotplugging"



#define QERR_DEVICE_NOT_ENCRYPTED \

    ERROR_CLASS_GENERIC_ERROR, "Device '%s' is not encrypted"



#define QERR_DEVICE_NOT_FOUND \

    ERROR_CLASS_DEVICE_NOT_FOUND, "Device '%s' not found"

monitor.c

+11 −5
Original line number Diff line number Diff line
@@ -5368,9 +5368,12 @@ static void bdrv_password_cb(void *opaque, const char *password, 
    Monitor *mon = opaque;

    BlockDriverState *bs = readline_opaque;

    int ret = 0;

    Error *local_err = NULL;



    if (bdrv_set_key(bs, password) != 0) {

        monitor_printf(mon, "invalid password\n");

    bdrv_add_key(bs, password, &local_err);

    if (local_err) {

        monitor_printf(mon, "%s\n", error_get_pretty(local_err));

        error_free(local_err);

        ret = -EPERM;

    }

    if (mon->password_completion_cb)
@@ -5388,17 +5391,20 @@ int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs, 
                                BlockCompletionFunc *completion_cb,

                                void *opaque)

{

    Error *local_err = NULL;

    int err;



    if (!bdrv_key_required(bs)) {

    bdrv_add_key(bs, NULL, &local_err);

    if (!local_err) {

        if (completion_cb)

            completion_cb(opaque, 0);

        return 0;

    }



    /* Need a key for @bs */



    if (monitor_ctrl_mode(mon)) {

        qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs),

                      bdrv_get_encrypted_filename(bs));

        qerror_report_err(local_err);

        return -1;

    }