[JOB_VERB_COMPLETE] = {0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0},
[JOB_VERB_FINALIZE] = {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
[JOB_VERB_DISMISS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
+ [JOB_VERB_CHANGE] = {0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0},
};
/* Transactional group of jobs */
return -EPERM;
}
-int job_apply_verb(Job *job, JobVerb verb, Error **errp)
-{
- JOB_LOCK_GUARD();
- return job_apply_verb_locked(job, verb, errp);
-}
-
JobType job_type(const Job *job)
{
return job->driver->job_type;
return false;
}
-bool job_is_completed(Job *job)
+static bool job_is_completed(Job *job)
{
JOB_LOCK_GUARD();
return job_is_completed_locked(job);
return NULL;
}
-Job *job_get(const char *id)
-{
- JOB_LOCK_GUARD();
- return job_get_locked(id);
-}
-
void job_set_aio_context(Job *job, AioContext *ctx)
{
/* protect against read in job_finish_sync_locked and job_start */
++job->refcnt;
}
-void job_ref(Job *job)
-{
- JOB_LOCK_GUARD();
- job_ref_locked(job);
-}
-
void job_unref_locked(Job *job)
{
GLOBAL_STATE_CODE();
assert(!job->txn);
if (job->driver->free) {
- AioContext *aio_context = job->aio_context;
job_unlock();
- /* FIXME: aiocontext lock is required because cb calls blk_unref */
- aio_context_acquire(aio_context);
job->driver->free(job);
- aio_context_release(aio_context);
job_lock();
}
}
}
-void job_unref(Job *job)
-{
- JOB_LOCK_GUARD();
- job_unref_locked(job);
-}
-
void job_progress_update(Job *job, uint64_t done)
{
progress_work_done(&job->progress, done);
job_lock();
}
-void job_enter_cond(Job *job, bool(*fn)(Job *job))
-{
- JOB_LOCK_GUARD();
- job_enter_cond_locked(job, fn);
-}
-
void job_enter(Job *job)
{
JOB_LOCK_GUARD();
next_aio_context = job->aio_context;
/*
* Coroutine has resumed, but in the meanwhile the job AioContext
- * might have changed via bdrv_try_set_aio_context(), so we need to move
+ * might have changed via bdrv_try_change_aio_context(), so we need to move
* the coroutine too in the new aiocontext.
*/
while (qemu_get_current_aio_context() != next_aio_context) {
job_pause_point_locked(job);
}
-static void coroutine_fn job_yield_locked(Job *job)
+void coroutine_fn job_yield(Job *job)
{
+ JOB_LOCK_GUARD();
assert(job->busy);
/* Check cancellation *before* setting busy = false, too! */
job_pause_point_locked(job);
}
-void coroutine_fn job_yield(Job *job)
-{
- JOB_LOCK_GUARD();
- job_yield_locked(job);
-}
-
void coroutine_fn job_sleep_ns(Job *job, int64_t ns)
{
JOB_LOCK_GUARD();
job_pause_locked(job);
}
-void job_user_pause(Job *job, Error **errp)
-{
- JOB_LOCK_GUARD();
- job_user_pause_locked(job, errp);
-}
-
bool job_user_paused_locked(Job *job)
{
return job->user_paused;
}
-bool job_user_paused(Job *job)
-{
- JOB_LOCK_GUARD();
- return job_user_paused_locked(job);
-}
-
void job_user_resume_locked(Job *job, Error **errp)
{
assert(job);
job_resume_locked(job);
}
-void job_user_resume(Job *job, Error **errp)
-{
- JOB_LOCK_GUARD();
- job_user_resume_locked(job, errp);
-}
-
/* Called with job_mutex held, but releases it temporarily. */
static void job_do_dismiss_locked(Job *job)
{
*jobptr = NULL;
}
-void job_dismiss(Job **jobptr, Error **errp)
-{
- JOB_LOCK_GUARD();
- job_dismiss_locked(jobptr, errp);
-}
-
void job_early_fail(Job *job)
{
JOB_LOCK_GUARD();
/*
* Called with job_mutex held, but releases it temporarily.
- * Takes AioContext lock internally to invoke a job->driver callback.
*/
static int job_finalize_single_locked(Job *job)
{
int job_ret;
- AioContext *ctx = job->aio_context;
assert(job_is_completed_locked(job));
job_ret = job->ret;
job_unlock();
- aio_context_acquire(ctx);
if (!job_ret) {
job_commit(job);
job->cb(job->opaque, job_ret);
}
- aio_context_release(ctx);
job_lock();
/* Emit events only if we actually started */
/*
* Called with job_mutex held, but releases it temporarily.
- * Takes AioContext lock internally to invoke a job->driver callback.
*/
static void job_cancel_async_locked(Job *job, bool force)
{
- AioContext *ctx = job->aio_context;
GLOBAL_STATE_CODE();
if (job->driver->cancel) {
job_unlock();
- aio_context_acquire(ctx);
force = job->driver->cancel(job, force);
- aio_context_release(ctx);
job_lock();
} else {
/* No .cancel() means the job will behave as if force-cancelled */
/*
* Called with job_mutex held, but releases it temporarily.
- * Takes AioContext lock internally to invoke a job->driver callback.
*/
static void job_completed_txn_abort_locked(Job *job)
{
static int job_prepare_locked(Job *job)
{
int ret;
- AioContext *ctx = job->aio_context;
GLOBAL_STATE_CODE();
if (job->ret == 0 && job->driver->prepare) {
job_unlock();
- aio_context_acquire(ctx);
ret = job->driver->prepare(job);
- aio_context_release(ctx);
job_lock();
job->ret = ret;
job_update_rc_locked(job);
job_do_finalize_locked(job);
}
-void job_finalize(Job *job, Error **errp)
-{
- JOB_LOCK_GUARD();
- job_finalize_locked(job, errp);
-}
-
/* Called with job_mutex held. */
static int job_transition_to_pending_locked(Job *job)
{
}
}
-void job_cancel(Job *job, bool force)
-{
- JOB_LOCK_GUARD();
- job_cancel_locked(job, force);
-}
-
void job_user_cancel_locked(Job *job, bool force, Error **errp)
{
if (job_apply_verb_locked(job, JOB_VERB_CANCEL, errp)) {
job_cancel_locked(job, force);
}
-void job_user_cancel(Job *job, bool force, Error **errp)
-{
- JOB_LOCK_GUARD();
- job_user_cancel_locked(job, force, errp);
-}
-
-/* A wrapper around job_cancel() taking an Error ** parameter so it may be
- * used with job_finish_sync() without the need for (rather nasty) function
- * pointer casts there.
+/* A wrapper around job_cancel_locked() taking an Error ** parameter so it may
+ * be used with job_finish_sync_locked() without the need for (rather nasty)
+ * function pointer casts there.
*
* Called with job_mutex held.
*/
return job_finish_sync_locked(job, job_complete_locked, errp);
}
-int job_complete_sync(Job *job, Error **errp)
-{
- JOB_LOCK_GUARD();
- return job_complete_sync_locked(job, errp);
-}
-
void job_complete_locked(Job *job, Error **errp)
{
/* Should not be reachable via external interface for internal jobs */
job_lock();
}
-void job_complete(Job *job, Error **errp)
-{
- JOB_LOCK_GUARD();
- job_complete_locked(job, errp);
-}
-
int job_finish_sync_locked(Job *job,
void (*finish)(Job *, Error **errp),
Error **errp)
job_unref_locked(job);
return ret;
}
-
-int job_finish_sync(Job *job, void (*finish)(Job *, Error **errp), Error **errp)
-{
- JOB_LOCK_GUARD();
- return job_finish_sync_locked(job, finish, errp);
-}
projects / mirror_qemu.git / blobdiff