When doing drive mirror to a low speed shared storage, if there was heavy BLK IO write workload in VM after the 'ready' event, drive mirror block job can't be canceled immediately, it would keep running until the heavy BLK IO workload stopped in the VM. Libvirt depends on the current block-job-cancel semantics, which is that when used without a flag after the 'ready' event, the command blocks until data is in sync. However, these semantics are awkward in other situations, for example, people may use drive mirror for realtime backups while still wanting to use block live migration. Libvirt cannot start a block live migration while another drive mirror is in progress, but the user would rather abandon the backup attempt as broken and proceed with the live migration than be stuck waiting for the current drive mirror backup to finish. The drive-mirror command already includes a 'force' flag, which libvirt does not use, although it documented the flag as only being useful to quit a job which is paused. However, since quitting a paused job has the same effect as abandoning a backup in a non-paused job (namely, the destination file is not in sync, and the command completes immediately), we can just improve the documentation to make the force flag obviously useful. Cc: Paolo Bonzini <pbonzini@redhat.com> Cc: Jeff Cody <jcody@redhat.com> Cc: Kevin Wolf <kwolf@redhat.com> Cc: Max Reitz <mreitz@redhat.com> Cc: Eric Blake <eblake@redhat.com> Cc: John Snow <jsnow@redhat.com> Reported-by: Huaitong Han <huanhuaitong@didichuxing.com> Signed-off-by: Huaitong Han <huanhuaitong@didichuxing.com> Signed-off-by: Liang Li <liliangleo@didichuxing.com> Signed-off-by: Jeff Cody <jcody@redhat.com> Signed-off-by: Kevin Wolf <kwolf@redhat.com>
431 lines
12 KiB
C
431 lines
12 KiB
C
/*
|
|
* Declarations for long-running block device operations
|
|
*
|
|
* Copyright (c) 2011 IBM Corp.
|
|
* Copyright (c) 2012 Red Hat, Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#ifndef BLOCKJOB_H
|
|
#define BLOCKJOB_H
|
|
|
|
#include "block/block.h"
|
|
|
|
typedef struct BlockJobDriver BlockJobDriver;
|
|
typedef struct BlockJobTxn BlockJobTxn;
|
|
|
|
/**
|
|
* BlockJob:
|
|
*
|
|
* Long-running operation on a BlockDriverState.
|
|
*/
|
|
typedef struct BlockJob {
|
|
/** The job type, including the job vtable. */
|
|
const BlockJobDriver *driver;
|
|
|
|
/** The block device on which the job is operating. */
|
|
BlockBackend *blk;
|
|
|
|
/**
|
|
* The ID of the block job. May be NULL for internal jobs.
|
|
*/
|
|
char *id;
|
|
|
|
/**
|
|
* The coroutine that executes the job. If not NULL, it is
|
|
* reentered when busy is false and the job is cancelled.
|
|
*/
|
|
Coroutine *co;
|
|
|
|
/**
|
|
* Set to true if the job should cancel itself. The flag must
|
|
* always be tested just before toggling the busy flag from false
|
|
* to true. After a job has been cancelled, it should only yield
|
|
* if #aio_poll will ("sooner or later") reenter the coroutine.
|
|
*/
|
|
bool cancelled;
|
|
|
|
/**
|
|
* Set to true if the job should abort immediately without waiting
|
|
* for data to be in sync.
|
|
*/
|
|
bool force;
|
|
|
|
/**
|
|
* Counter for pause request. If non-zero, the block job is either paused,
|
|
* or if busy == true will pause itself as soon as possible.
|
|
*/
|
|
int pause_count;
|
|
|
|
/**
|
|
* Set to true if the job is paused by user. Can be unpaused with the
|
|
* block-job-resume QMP command.
|
|
*/
|
|
bool user_paused;
|
|
|
|
/**
|
|
* Set to false by the job while the coroutine has yielded and may be
|
|
* re-entered by block_job_enter(). There may still be I/O or event loop
|
|
* activity pending. Accessed under block_job_mutex (in blockjob.c).
|
|
*/
|
|
bool busy;
|
|
|
|
/**
|
|
* Set to true by the job while it is in a quiescent state, where
|
|
* no I/O or event loop activity is pending.
|
|
*/
|
|
bool paused;
|
|
|
|
/**
|
|
* Set to true when the job is ready to be completed.
|
|
*/
|
|
bool ready;
|
|
|
|
/**
|
|
* Set to true when the job has deferred work to the main loop.
|
|
*/
|
|
bool deferred_to_main_loop;
|
|
|
|
/** Element of the list of block jobs */
|
|
QLIST_ENTRY(BlockJob) job_list;
|
|
|
|
/** Status that is published by the query-block-jobs QMP API */
|
|
BlockDeviceIoStatus iostatus;
|
|
|
|
/** Offset that is published by the query-block-jobs QMP API */
|
|
int64_t offset;
|
|
|
|
/** Length that is published by the query-block-jobs QMP API */
|
|
int64_t len;
|
|
|
|
/** Speed that was set with @block_job_set_speed. */
|
|
int64_t speed;
|
|
|
|
/** The completion function that will be called when the job completes. */
|
|
BlockCompletionFunc *cb;
|
|
|
|
/** Block other operations when block job is running */
|
|
Error *blocker;
|
|
|
|
/** BlockDriverStates that are involved in this block job */
|
|
GSList *nodes;
|
|
|
|
/** The opaque value that is passed to the completion function. */
|
|
void *opaque;
|
|
|
|
/** Reference count of the block job */
|
|
int refcnt;
|
|
|
|
/** True when job has reported completion by calling block_job_completed. */
|
|
bool completed;
|
|
|
|
/** ret code passed to block_job_completed. */
|
|
int ret;
|
|
|
|
/**
|
|
* Timer that is used by @block_job_sleep_ns. Accessed under
|
|
* block_job_mutex (in blockjob.c).
|
|
*/
|
|
QEMUTimer sleep_timer;
|
|
|
|
/** Current state; See @BlockJobStatus for details. */
|
|
BlockJobStatus status;
|
|
|
|
/** True if this job should automatically finalize itself */
|
|
bool auto_finalize;
|
|
|
|
/** True if this job should automatically dismiss itself */
|
|
bool auto_dismiss;
|
|
|
|
BlockJobTxn *txn;
|
|
QLIST_ENTRY(BlockJob) txn_list;
|
|
} BlockJob;
|
|
|
|
typedef enum BlockJobCreateFlags {
|
|
/* Default behavior */
|
|
BLOCK_JOB_DEFAULT = 0x00,
|
|
/* BlockJob is not QMP-created and should not send QMP events */
|
|
BLOCK_JOB_INTERNAL = 0x01,
|
|
/* BlockJob requires manual finalize step */
|
|
BLOCK_JOB_MANUAL_FINALIZE = 0x02,
|
|
/* BlockJob requires manual dismiss step */
|
|
BLOCK_JOB_MANUAL_DISMISS = 0x04,
|
|
} BlockJobCreateFlags;
|
|
|
|
/**
|
|
* block_job_next:
|
|
* @job: A block job, or %NULL.
|
|
*
|
|
* Get the next element from the list of block jobs after @job, or the
|
|
* first one if @job is %NULL.
|
|
*
|
|
* Returns the requested job, or %NULL if there are no more jobs left.
|
|
*/
|
|
BlockJob *block_job_next(BlockJob *job);
|
|
|
|
/**
|
|
* block_job_get:
|
|
* @id: The id of the block job.
|
|
*
|
|
* Get the block job identified by @id (which must not be %NULL).
|
|
*
|
|
* Returns the requested job, or %NULL if it doesn't exist.
|
|
*/
|
|
BlockJob *block_job_get(const char *id);
|
|
|
|
/**
|
|
* block_job_add_bdrv:
|
|
* @job: A block job
|
|
* @name: The name to assign to the new BdrvChild
|
|
* @bs: A BlockDriverState that is involved in @job
|
|
* @perm, @shared_perm: Permissions to request on the node
|
|
*
|
|
* Add @bs to the list of BlockDriverState that are involved in
|
|
* @job. This means that all operations will be blocked on @bs while
|
|
* @job exists.
|
|
*/
|
|
int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,
|
|
uint64_t perm, uint64_t shared_perm, Error **errp);
|
|
|
|
/**
|
|
* block_job_remove_all_bdrv:
|
|
* @job: The block job
|
|
*
|
|
* Remove all BlockDriverStates from the list of nodes that are involved in the
|
|
* job. This removes the blockers added with block_job_add_bdrv().
|
|
*/
|
|
void block_job_remove_all_bdrv(BlockJob *job);
|
|
|
|
/**
|
|
* block_job_set_speed:
|
|
* @job: The job to set the speed for.
|
|
* @speed: The new value
|
|
* @errp: Error object.
|
|
*
|
|
* Set a rate-limiting parameter for the job; the actual meaning may
|
|
* vary depending on the job type.
|
|
*/
|
|
void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp);
|
|
|
|
/**
|
|
* block_job_start:
|
|
* @job: A job that has not yet been started.
|
|
*
|
|
* Begins execution of a block job.
|
|
* Takes ownership of one reference to the job object.
|
|
*/
|
|
void block_job_start(BlockJob *job);
|
|
|
|
/**
|
|
* block_job_cancel:
|
|
* @job: The job to be canceled.
|
|
* @force: Quit a job without waiting for data to be in sync.
|
|
*
|
|
* Asynchronously cancel the specified job.
|
|
*/
|
|
void block_job_cancel(BlockJob *job, bool force);
|
|
|
|
/**
|
|
* block_job_complete:
|
|
* @job: The job to be completed.
|
|
* @errp: Error object.
|
|
*
|
|
* Asynchronously complete the specified job.
|
|
*/
|
|
void block_job_complete(BlockJob *job, Error **errp);
|
|
|
|
|
|
/**
|
|
* block_job_finalize:
|
|
* @job: The job to fully commit and finish.
|
|
* @errp: Error object.
|
|
*
|
|
* For jobs that have finished their work and are pending
|
|
* awaiting explicit acknowledgement to commit their work,
|
|
* This will commit that work.
|
|
*
|
|
* FIXME: Make the below statement universally true:
|
|
* For jobs that support the manual workflow mode, all graph
|
|
* changes that occur as a result will occur after this command
|
|
* and before a successful reply.
|
|
*/
|
|
void block_job_finalize(BlockJob *job, Error **errp);
|
|
|
|
/**
|
|
* block_job_dismiss:
|
|
* @job: The job to be dismissed.
|
|
* @errp: Error object.
|
|
*
|
|
* Remove a concluded job from the query list.
|
|
*/
|
|
void block_job_dismiss(BlockJob **job, Error **errp);
|
|
|
|
/**
|
|
* block_job_query:
|
|
* @job: The job to get information about.
|
|
*
|
|
* Return information about a job.
|
|
*/
|
|
BlockJobInfo *block_job_query(BlockJob *job, Error **errp);
|
|
|
|
/**
|
|
* block_job_user_pause:
|
|
* @job: The job to be paused.
|
|
*
|
|
* Asynchronously pause the specified job.
|
|
* Do not allow a resume until a matching call to block_job_user_resume.
|
|
*/
|
|
void block_job_user_pause(BlockJob *job, Error **errp);
|
|
|
|
/**
|
|
* block_job_paused:
|
|
* @job: The job to query.
|
|
*
|
|
* Returns true if the job is user-paused.
|
|
*/
|
|
bool block_job_user_paused(BlockJob *job);
|
|
|
|
/**
|
|
* block_job_user_resume:
|
|
* @job: The job to be resumed.
|
|
*
|
|
* Resume the specified job.
|
|
* Must be paired with a preceding block_job_user_pause.
|
|
*/
|
|
void block_job_user_resume(BlockJob *job, Error **errp);
|
|
|
|
/**
|
|
* block_job_user_cancel:
|
|
* @job: The job to be cancelled.
|
|
* @force: Quit a job without waiting for data to be in sync.
|
|
*
|
|
* Cancels the specified job, but may refuse to do so if the
|
|
* operation isn't currently meaningful.
|
|
*/
|
|
void block_job_user_cancel(BlockJob *job, bool force, Error **errp);
|
|
|
|
/**
|
|
* block_job_cancel_sync:
|
|
* @job: The job to be canceled.
|
|
*
|
|
* Synchronously cancel the job. The completion callback is called
|
|
* before the function returns. The job may actually complete
|
|
* instead of canceling itself; the circumstances under which this
|
|
* happens depend on the kind of job that is active.
|
|
*
|
|
* Returns the return value from the job if the job actually completed
|
|
* during the call, or -ECANCELED if it was canceled.
|
|
*/
|
|
int block_job_cancel_sync(BlockJob *job);
|
|
|
|
/**
|
|
* block_job_cancel_sync_all:
|
|
*
|
|
* Synchronously cancels all jobs using block_job_cancel_sync().
|
|
*/
|
|
void block_job_cancel_sync_all(void);
|
|
|
|
/**
|
|
* block_job_complete_sync:
|
|
* @job: The job to be completed.
|
|
* @errp: Error object which may be set by block_job_complete(); this is not
|
|
* necessarily set on every error, the job return value has to be
|
|
* checked as well.
|
|
*
|
|
* Synchronously complete the job. The completion callback is called before the
|
|
* function returns, unless it is NULL (which is permissible when using this
|
|
* function).
|
|
*
|
|
* Returns the return value from the job.
|
|
*/
|
|
int block_job_complete_sync(BlockJob *job, Error **errp);
|
|
|
|
/**
|
|
* block_job_iostatus_reset:
|
|
* @job: The job whose I/O status should be reset.
|
|
*
|
|
* Reset I/O status on @job and on BlockDriverState objects it uses,
|
|
* other than job->blk.
|
|
*/
|
|
void block_job_iostatus_reset(BlockJob *job);
|
|
|
|
/**
|
|
* block_job_txn_new:
|
|
*
|
|
* Allocate and return a new block job transaction. Jobs can be added to the
|
|
* transaction using block_job_txn_add_job().
|
|
*
|
|
* The transaction is automatically freed when the last job completes or is
|
|
* cancelled.
|
|
*
|
|
* All jobs in the transaction either complete successfully or fail/cancel as a
|
|
* group. Jobs wait for each other before completing. Cancelling one job
|
|
* cancels all jobs in the transaction.
|
|
*/
|
|
BlockJobTxn *block_job_txn_new(void);
|
|
|
|
/**
|
|
* block_job_ref:
|
|
*
|
|
* Add a reference to BlockJob refcnt, it will be decreased with
|
|
* block_job_unref, and then be freed if it comes to be the last
|
|
* reference.
|
|
*/
|
|
void block_job_ref(BlockJob *job);
|
|
|
|
/**
|
|
* block_job_unref:
|
|
*
|
|
* Release a reference that was previously acquired with block_job_ref
|
|
* or block_job_create. If it's the last reference to the object, it will be
|
|
* freed.
|
|
*/
|
|
void block_job_unref(BlockJob *job);
|
|
|
|
/**
|
|
* block_job_txn_unref:
|
|
*
|
|
* Release a reference that was previously acquired with block_job_txn_add_job
|
|
* or block_job_txn_new. If it's the last reference to the object, it will be
|
|
* freed.
|
|
*/
|
|
void block_job_txn_unref(BlockJobTxn *txn);
|
|
|
|
/**
|
|
* block_job_txn_add_job:
|
|
* @txn: The transaction (may be NULL)
|
|
* @job: Job to add to the transaction
|
|
*
|
|
* Add @job to the transaction. The @job must not already be in a transaction.
|
|
* The caller must call either block_job_txn_unref() or block_job_completed()
|
|
* to release the reference that is automatically grabbed here.
|
|
*/
|
|
void block_job_txn_add_job(BlockJobTxn *txn, BlockJob *job);
|
|
|
|
/**
|
|
* block_job_is_internal:
|
|
* @job: The job to determine if it is user-visible or not.
|
|
*
|
|
* Returns true if the job should not be visible to the management layer.
|
|
*/
|
|
bool block_job_is_internal(BlockJob *job);
|
|
|
|
#endif
|