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();
}
}
-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();
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);
-}