blockdev.c (8f4699d873bef81cec95db6da53d4c33f8caf4b9) blockdev.c (3d948cdf3760b52238038626a7ffa7d30913060b)
1/*
2 * QEMU host block devices
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2 or
7 * later. See the COPYING file in the top-level directory.
8 *

--- 2361 unchanged lines hidden (view full) ---

2370 block_job_cb, bs, &local_err);
2371 if (local_err != NULL) {
2372 bdrv_unref(target_bs);
2373 error_propagate(errp, local_err);
2374 return;
2375 }
2376}
2377
1/*
2 * QEMU host block devices
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2 or
7 * later. See the COPYING file in the top-level directory.
8 *

--- 2361 unchanged lines hidden (view full) ---

2370 block_job_cb, bs, &local_err);
2371 if (local_err != NULL) {
2372 bdrv_unref(target_bs);
2373 error_propagate(errp, local_err);
2374 return;
2375 }
2376}
2377
2378static BlockJob *find_block_job(const char *device)
2378/* Get the block job for a given device name and acquire its AioContext */
2379static BlockJob *find_block_job(const char *device, AioContext **aio_context)
2379{
2380 BlockDriverState *bs;
2381
2382 bs = bdrv_find(device);
2380{
2381 BlockDriverState *bs;
2382
2383 bs = bdrv_find(device);
2383 if (!bs || !bs->job) {
2384 return NULL;
2384 if (!bs) {
2385 goto notfound;
2385 }
2386 }
2387
2388 *aio_context = bdrv_get_aio_context(bs);
2389 aio_context_acquire(*aio_context);
2390
2391 if (!bs->job) {
2392 aio_context_release(*aio_context);
2393 goto notfound;
2394 }
2395
2386 return bs->job;
2396 return bs->job;
2397
2398notfound:
2399 *aio_context = NULL;
2400 return NULL;
2387}
2388
2389void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp)
2390{
2401}
2402
2403void qmp_block_job_set_speed(const char *device, int64_t speed, Error **errp)
2404{
2391 BlockJob *job = find_block_job(device);
2405 AioContext *aio_context;
2406 BlockJob *job = find_block_job(device, &aio_context);
2392
2393 if (!job) {
2394 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
2395 return;
2396 }
2397
2398 block_job_set_speed(job, speed, errp);
2407
2408 if (!job) {
2409 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
2410 return;
2411 }
2412
2413 block_job_set_speed(job, speed, errp);
2414 aio_context_release(aio_context);
2399}
2400
2401void qmp_block_job_cancel(const char *device,
2402 bool has_force, bool force, Error **errp)
2403{
2415}
2416
2417void qmp_block_job_cancel(const char *device,
2418 bool has_force, bool force, Error **errp)
2419{
2404 BlockJob *job = find_block_job(device);
2420 AioContext *aio_context;
2421 BlockJob *job = find_block_job(device, &aio_context);
2405
2422
2406 if (!has_force) {
2407 force = false;
2408 }
2409
2410 if (!job) {
2411 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
2412 return;
2413 }
2423 if (!job) {
2424 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
2425 return;
2426 }
2427
2428 if (!has_force) {
2429 force = false;
2430 }
2431
2414 if (job->paused && !force) {
2415 error_setg(errp, "The block job for device '%s' is currently paused",
2416 device);
2432 if (job->paused && !force) {
2433 error_setg(errp, "The block job for device '%s' is currently paused",
2434 device);
2417 return;
2435 goto out;
2418 }
2419
2420 trace_qmp_block_job_cancel(job);
2421 block_job_cancel(job);
2436 }
2437
2438 trace_qmp_block_job_cancel(job);
2439 block_job_cancel(job);
2440out:
2441 aio_context_release(aio_context);
2422}
2423
2424void qmp_block_job_pause(const char *device, Error **errp)
2425{
2442}
2443
2444void qmp_block_job_pause(const char *device, Error **errp)
2445{
2426 BlockJob *job = find_block_job(device);
2446 AioContext *aio_context;
2447 BlockJob *job = find_block_job(device, &aio_context);
2427
2428 if (!job) {
2429 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
2430 return;
2431 }
2432
2433 trace_qmp_block_job_pause(job);
2434 block_job_pause(job);
2448
2449 if (!job) {
2450 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
2451 return;
2452 }
2453
2454 trace_qmp_block_job_pause(job);
2455 block_job_pause(job);
2456 aio_context_release(aio_context);
2435}
2436
2437void qmp_block_job_resume(const char *device, Error **errp)
2438{
2457}
2458
2459void qmp_block_job_resume(const char *device, Error **errp)
2460{
2439 BlockJob *job = find_block_job(device);
2461 AioContext *aio_context;
2462 BlockJob *job = find_block_job(device, &aio_context);
2440
2441 if (!job) {
2442 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
2443 return;
2444 }
2445
2446 trace_qmp_block_job_resume(job);
2447 block_job_resume(job);
2463
2464 if (!job) {
2465 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
2466 return;
2467 }
2468
2469 trace_qmp_block_job_resume(job);
2470 block_job_resume(job);
2471 aio_context_release(aio_context);
2448}
2449
2450void qmp_block_job_complete(const char *device, Error **errp)
2451{
2472}
2473
2474void qmp_block_job_complete(const char *device, Error **errp)
2475{
2452 BlockJob *job = find_block_job(device);
2476 AioContext *aio_context;
2477 BlockJob *job = find_block_job(device, &aio_context);
2453
2454 if (!job) {
2455 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
2456 return;
2457 }
2458
2459 trace_qmp_block_job_complete(job);
2460 block_job_complete(job, errp);
2478
2479 if (!job) {
2480 error_set(errp, QERR_BLOCK_JOB_NOT_ACTIVE, device);
2481 return;
2482 }
2483
2484 trace_qmp_block_job_complete(job);
2485 block_job_complete(job, errp);
2486 aio_context_release(aio_context);
2461}
2462
2463void qmp_change_backing_file(const char *device,
2464 const char *image_node_name,
2465 const char *backing_file,
2466 Error **errp)
2467{
2468 BlockDriverState *bs = NULL;

--- 267 unchanged lines hidden --- 		2487}
2488
2489void qmp_change_backing_file(const char *device,
2490 const char *image_node_name,
2491 const char *backing_file,
2492 Error **errp)
2493{
2494 BlockDriverState *bs = NULL;

--- 267 unchanged lines hidden ---