[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[PATCH v8 20/20] job: remove unused functions
From: |
Emanuele Giuseppe Esposito |
Subject: |
[PATCH v8 20/20] job: remove unused functions |
Date: |
Wed, 29 Jun 2022 10:15:38 -0400 |
These public functions are not used anywhere, thus can be dropped.
Also, since this is the final job API that doesn't use AioContext
lock and replaces it with job_lock, adjust all remaining function
documentation to clearly specify if the job lock is taken or not.
Signed-off-by: Emanuele Giuseppe Esposito <eesposit@redhat.com>
---
include/qemu/job.h | 97 +++++++++++++----------------------
job.c | 122 ++-------------------------------------------
2 files changed, 40 insertions(+), 179 deletions(-)
diff --git a/include/qemu/job.h b/include/qemu/job.h
index 5db35f765c..f3d0694512 100644
--- a/include/qemu/job.h
+++ b/include/qemu/job.h
@@ -361,6 +361,8 @@ JobTxn *job_txn_new(void);
/**
* Release a reference that was previously acquired with job_txn_add_job or
* job_txn_new. If it's the last reference to the object, it will be freed.
+ *
+ * Called with job lock *not* held.
*/
void job_txn_unref(JobTxn *txn);
@@ -387,19 +389,17 @@ void *job_create(const char *job_id, const JobDriver
*driver, JobTxn *txn,
/**
* Add a reference to Job refcnt, it will be decreased with job_unref, and then
* be freed if it comes to be the last reference.
+ *
+ * Called with job lock held.
*/
-void job_ref(Job *job);
-
-/* Same as job_ref(), but called with job lock held. */
void job_ref_locked(Job *job);
/**
* Release a reference that was previously acquired with job_ref() or
* job_create(). If it's the last reference to the object, it will be freed.
+ *
+ * Called with job lock held.
*/
-void job_unref(Job *job);
-
-/* Same as job_unref(), but called with job lock held. */
void job_unref_locked(Job *job);
/**
@@ -445,10 +445,9 @@ void job_progress_increase_remaining(Job *job, uint64_t
delta);
* Conditionally enter the job coroutine if the job is ready to run, not
* already busy and fn() returns true. fn() is called while under the job_lock
* critical section.
+ *
+ * Called with job lock held, but might release it temporarily.
*/
-void job_enter_cond(Job *job, bool(*fn)(Job *job));
-
-/* Same as job_enter_cond(), but called with job lock held. */
void job_enter_cond_locked(Job *job, bool(*fn)(Job *job));
/**
@@ -529,11 +528,8 @@ bool job_cancel_requested(Job *job);
/**
* Returns whether the job is in a completed state.
- * Called with job_mutex *not* held.
+ * Called with job lock held.
*/
-bool job_is_completed(Job *job);
-
-/* Same as job_is_completed(), but called with job lock held. */
bool job_is_completed_locked(Job *job);
/**
@@ -549,40 +545,35 @@ bool job_is_ready_locked(Job *job);
* Request @job to pause at the next pause point. Must be paired with
* job_resume(). If the job is supposed to be resumed by user action, call
* job_user_pause() instead.
+ *
+ * Called with job lock held.
*/
-void job_pause(Job *job);
-
-/* Same as job_pause(), but called with job lock held. */
void job_pause_locked(Job *job);
-/** Resumes a @job paused with job_pause. */
-void job_resume(Job *job);
-
-/* Same as job_resume(), but called with job lock held. */
+/**
+ * Resumes a @job paused with job_pause.
+ * Called with job lock held, but might release it temporarily.
+ */
void job_resume_locked(Job *job);
/**
* Asynchronously pause the specified @job.
* Do not allow a resume until a matching call to job_user_resume.
+ * Called with job lock held.
*/
-void job_user_pause(Job *job, Error **errp);
-
-/* Same as job_user_pause(), but called with job lock held. */
void job_user_pause_locked(Job *job, Error **errp);
-/** Returns true if the job is user-paused. */
-bool job_user_paused(Job *job);
-
-/* Same as job_user_paused(), but called with job lock held. */
+/**
+ * Returns true if the job is user-paused.
+ * Called with job lock held.
+ */
bool job_user_paused_locked(Job *job);
/**
* Resume the specified @job.
* Must be paired with a preceding job_user_pause.
+ * Called with job lock held.
*/
-void job_user_resume(Job *job, Error **errp);
-
-/* Same as job_user_resume(), but called with job lock held. */
void job_user_resume_locked(Job *job, Error **errp);
/**
@@ -590,30 +581,25 @@ void job_user_resume_locked(Job *job, Error **errp);
* first one if @job is %NULL.
*
* Returns the requested job, or %NULL if there are no more jobs left.
+ * Called with job lock held.
*/
-Job *job_next(Job *job);
-
-/* Same as job_next(), but called with job lock held. */
Job *job_next_locked(Job *job);
/**
* Get the job identified by @id (which must not be %NULL).
*
* Returns the requested job, or %NULL if it doesn't exist.
+ * Called with job lock held.
*/
-Job *job_get(const char *id);
-
-/* Same as job_get(), but called with job lock held. */
Job *job_get_locked(const char *id);
/**
* Check whether the verb @verb can be applied to @job in its current state.
* Returns 0 if the verb can be applied; otherwise errp is set and -EPERM
* returned.
+ *
+ * Called with job lock held.
*/
-int job_apply_verb(Job *job, JobVerb verb, Error **errp);
-
-/* Same as job_apply_verb, but called with job lock held. */
int job_apply_verb_locked(Job *job, JobVerb verb, Error **errp);
/**
@@ -628,28 +614,24 @@ void job_early_fail(Job *job);
*/
void job_transition_to_ready(Job *job);
-/** Asynchronously complete the specified @job. */
-void job_complete(Job *job, Error **errp);
-
-/* Same as job_complete(), but called with job lock held. */
+/**
+ * Asynchronously complete the specified @job.
+ * Called with job lock held, but might release it temporarily.
+ */
void job_complete_locked(Job *job, Error **errp);
/**
* Asynchronously cancel the specified @job. If @force is true, the job should
* be cancelled immediately without waiting for a consistent state.
+ * Called with job lock held.
*/
-void job_cancel(Job *job, bool force);
-
-/* Same as job_cancel(), but called with job lock held. */
void job_cancel_locked(Job *job, bool force);
/**
* Cancels the specified job like job_cancel(), but may refuse to do so if the
* operation isn't meaningful in the current state of the job.
+ * Called with job lock held.
*/
-void job_user_cancel(Job *job, bool force, Error **errp);
-
-/* Same as job_user_cancel(), but called with job lock held. */
void job_user_cancel_locked(Job *job, bool force, Error **errp);
/**
@@ -690,9 +672,6 @@ void job_cancel_sync_all(void);
* Returns the return value from the job.
* Called with job_lock held.
*/
-int job_complete_sync(Job *job, Error **errp);
-
-/* Same as job_complete_sync, but called with job lock held. */
int job_complete_sync_locked(Job *job, Error **errp);
/**
@@ -702,19 +681,17 @@ int job_complete_sync_locked(Job *job, Error **errp);
* 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.
+ *
+ * Called with job lock held.
*/
-void job_finalize(Job *job, Error **errp);
-
-/* Same as job_finalize(), but called with job lock held. */
void job_finalize_locked(Job *job, Error **errp);
/**
* Remove the concluded @job from the query list and resets the passed pointer
* to %NULL. Returns an error if the job is not actually concluded.
+ *
+ * Called with job lock held.
*/
-void job_dismiss(Job **job, Error **errp);
-
-/* Same as job_dismiss(), but called with job lock held. */
void job_dismiss_locked(Job **job, Error **errp);
/**
@@ -726,10 +703,6 @@ void job_dismiss_locked(Job **job, Error **errp);
*
* Called with job_lock held.
*/
-int job_finish_sync(Job *job, void (*finish)(Job *, Error **errp),
- Error **errp);
-
-/* Same as job_finish_sync, but called with job lock held. */
int job_finish_sync_locked(Job *job, void (*finish)(Job *, Error **errp),
Error **errp);
diff --git a/job.c b/job.c
index d0ba463803..8fd915ee68 100644
--- a/job.c
+++ b/job.c
@@ -233,12 +233,6 @@ int job_apply_verb_locked(Job *job, JobVerb verb, Error
**errp)
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;
@@ -324,7 +318,7 @@ bool job_is_completed_locked(Job *job)
return false;
}
-bool job_is_completed(Job *job)
+static bool job_is_completed(Job *job)
{
JOB_LOCK_GUARD();
return job_is_completed_locked(job);
@@ -349,12 +343,6 @@ Job *job_next_locked(Job *job)
return QLIST_NEXT(job, job_list);
}
-Job *job_next(Job *job)
-{
- JOB_LOCK_GUARD();
- return job_next_locked(job);
-}
-
Job *job_get_locked(const char *id)
{
Job *job;
@@ -368,12 +356,6 @@ Job *job_get_locked(const char *id)
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 */
@@ -465,12 +447,6 @@ void job_ref_locked(Job *job)
++job->refcnt;
}
-void job_ref(Job *job)
-{
- JOB_LOCK_GUARD();
- job_ref_locked(job);
-}
-
void job_unref_locked(Job *job)
{
GLOBAL_STATE_CODE();
@@ -499,12 +475,6 @@ void job_unref_locked(Job *job)
}
}
-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);
@@ -580,12 +550,6 @@ void job_enter_cond_locked(Job *job, bool(*fn)(Job *job))
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();
@@ -631,7 +595,8 @@ static void coroutine_fn job_do_yield_locked(Job *job,
uint64_t ns)
assert(job->busy);
}
-void coroutine_fn job_pause_point_locked(Job *job)
+/* Called with job lock held */
+static void coroutine_fn job_pause_point_locked(Job *job)
{
assert(job && job_started(job));
@@ -672,8 +637,9 @@ void coroutine_fn job_pause_point(Job *job)
job_pause_point_locked(job);
}
-void job_yield_locked(Job *job)
+void job_yield(Job *job)
{
+ JOB_LOCK_GUARD();
assert(job->busy);
/* Check cancellation *before* setting busy = false, too! */
@@ -688,12 +654,6 @@ void job_yield_locked(Job *job)
job_pause_point_locked(job);
}
-void 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();
@@ -725,12 +685,6 @@ void job_pause_locked(Job *job)
}
}
-void job_pause(Job *job)
-{
- JOB_LOCK_GUARD();
- job_pause_locked(job);
-}
-
void job_resume_locked(Job *job)
{
assert(job->pause_count > 0);
@@ -743,12 +697,6 @@ void job_resume_locked(Job *job)
job_enter_cond_locked(job, job_timer_not_pending_locked);
}
-void job_resume(Job *job)
-{
- JOB_LOCK_GUARD();
- job_resume_locked(job);
-}
-
void job_user_pause_locked(Job *job, Error **errp)
{
if (job_apply_verb_locked(job, JOB_VERB_PAUSE, errp)) {
@@ -762,23 +710,11 @@ void job_user_pause_locked(Job *job, Error **errp)
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);
@@ -799,12 +735,6 @@ void job_user_resume_locked(Job *job, Error **errp)
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. */
static void job_do_dismiss_locked(Job *job)
{
@@ -832,12 +762,6 @@ void job_dismiss_locked(Job **jobptr, Error **errp)
*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();
@@ -1079,12 +1003,6 @@ void job_finalize_locked(Job *job, Error **errp)
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)
{
@@ -1231,12 +1149,6 @@ void job_cancel_locked(Job *job, bool force)
}
}
-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)) {
@@ -1245,12 +1157,6 @@ void job_user_cancel_locked(Job *job, bool force, Error
**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.
@@ -1301,12 +1207,6 @@ int job_complete_sync_locked(Job *job, Error **errp)
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 */
@@ -1326,12 +1226,6 @@ void job_complete_locked(Job *job, Error **errp)
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)
@@ -1361,9 +1255,3 @@ int job_finish_sync_locked(Job *job,
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);
-}
\ No newline at end of file
--
2.31.1
- [PATCH v8 00/20] job: replace AioContext lock with job_mutex, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 01/20] job.c: make job_mutex and job_lock/unlock() public, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 06/20] job.h: define functions called without job lock held, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 08/20] blockjob.h: introduce block_job _locked() APIs, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 05/20] job.c: add job_lock/unlock while keeping job.h intact, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 11/20] jobs: use job locks also in the unit tests, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 07/20] job.h: add _locked public functions, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 04/20] aio-wait.h: introduce AIO_WAIT_WHILE_UNLOCKED, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 02/20] job.h: categorize fields in struct Job, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 10/20] jobs: add job lock in find_* functions, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 20/20] job: remove unused functions,
Emanuele Giuseppe Esposito <=
- [PATCH v8 13/20] jobs: group together API calls under the same job lock, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 03/20] job.c: API functions not used outside should be static, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 12/20] block/mirror.c: use of job helpers in drivers to avoid TOC/TOU, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 19/20] blockjob: remove unused functions, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 17/20] job.c: enable job lock/unlock and remove Aiocontext locks, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 16/20] jobs: protect job.aio_context with BQL and job_mutex, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 09/20] blockjob: rename notifier callbacks as _locked, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 15/20] job: detect change of aiocontext within job coroutine, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 18/20] block_job_query: remove atomic read, Emanuele Giuseppe Esposito, 2022/06/29
- [PATCH v8 14/20] commit and mirror: create new nodes using bdrv_get_aio_context, and not the job aiocontext, Emanuele Giuseppe Esposito, 2022/06/29