kvm tools: Modify thread pool API

Modify API function names and type names.

[ penberg@kernel.org: drop virtio net parts ]
Signed-off-by: Sasha Levin <levinsasha928@gmail.com>
Signed-off-by: Pekka Enberg <penberg@kernel.org>

diff --git a/tools/kvm/include/kvm/threadpool.h b/tools/kvm/include/kvm/threadpool.h
index 25b5eb83bc631047bb716c000eeff43b61340dbd..4716411ce7d3e24017762d668b47d8a18bd689cf 100644 (file)
--- a/tools/kvm/include/kvm/threadpool.h
+++ b/tools/kvm/include/kvm/threadpool.h
@@ -9,8 +9,8 @@ typedef void (*kvm_thread_callback_fn_t)(struct kvm *kvm, void *data);
 
 int thread_pool__init(unsigned long thread_count);
 
-void *thread_pool__add_jobtype(struct kvm *kvm, kvm_thread_callback_fn_t callback, void *data);
+void *thread_pool__add_job(struct kvm *kvm, kvm_thread_callback_fn_t callback, void *data);
 
-void thread_pool__signal_work(void *job);
+void thread_pool__do_job(void *job);
 
 #endif

diff --git a/tools/kvm/threadpool.c b/tools/kvm/threadpool.c
index c584ec778a294d951aa1ba08afe2c74ef9a60cde..25d9aad1d5a2c3bb652094b0efe10c9f6e0d838d 100644 (file)
--- a/tools/kvm/threadpool.c
+++ b/tools/kvm/threadpool.c
@@ -6,7 +6,7 @@
 #include <pthread.h>
 #include <stdbool.h>
 
-struct thread_pool__job_info {
+struct thread_pool__job {
        kvm_thread_callback_fn_t        callback;
        struct kvm                      *kvm;
        void                            *data;
@@ -26,42 +26,42 @@ static LIST_HEAD(head);
 static pthread_t       *threads;
 static long            threadcount;
 
-static struct thread_pool__job_info *thread_pool__job_info_pop(void)
+static struct thread_pool__job *thread_pool__job_pop(void)
 {
-       struct thread_pool__job_info *job;
+       struct thread_pool__job *job;
 
        if (list_empty(&head))
                return NULL;
 
-       job = list_first_entry(&head, struct thread_pool__job_info, queue);
+       job = list_first_entry(&head, struct thread_pool__job, queue);
        list_del(&job->queue);
 
        return job;
 }
 
-static void thread_pool__job_info_push(struct thread_pool__job_info *job)
+static void thread_pool__job_push(struct thread_pool__job *job)
 {
        list_add_tail(&job->queue, &head);
 }
 
-static struct thread_pool__job_info *thread_pool__job_info_pop_locked(void)
+static struct thread_pool__job *thread_pool__job_pop_locked(void)
 {
-       struct thread_pool__job_info *job;
+       struct thread_pool__job *job;
 
        mutex_lock(&job_mutex);
-       job = thread_pool__job_info_pop();
+       job = thread_pool__job_pop();
        mutex_unlock(&job_mutex);
        return job;
 }
 
-static void thread_pool__job_info_push_locked(struct thread_pool__job_info *job)
+static void thread_pool__job_push_locked(struct thread_pool__job *job)
 {
        mutex_lock(&job_mutex);
-       thread_pool__job_info_push(job);
+       thread_pool__job_push(job);
        mutex_unlock(&job_mutex);
 }
 
-static void thread_pool__handle_job(struct thread_pool__job_info *job)
+static void thread_pool__handle_job(struct thread_pool__job *job)
 {
        while (job) {
                job->callback(job->kvm, job->data);
@@ -70,11 +70,11 @@ static void thread_pool__handle_job(struct thread_pool__job_info *job)
 
                if (--job->signalcount > 0)
                        /* If the job was signaled again while we were working */
-                       thread_pool__job_info_push_locked(job);
+                       thread_pool__job_push_locked(job);
 
                mutex_unlock(&job->mutex);
 
-               job = thread_pool__job_info_pop_locked();
+               job = thread_pool__job_pop_locked();
        }
 }
 
@@ -88,11 +88,11 @@ static void *thread_pool__threadfunc(void *param)
        pthread_cleanup_push(thread_pool__threadfunc_cleanup, NULL);
 
        for (;;) {
-               struct thread_pool__job_info *curjob;
+               struct thread_pool__job *curjob;
 
                mutex_lock(&job_mutex);
                pthread_cond_wait(&job_cond, &job_mutex);
-               curjob = thread_pool__job_info_pop();
+               curjob = thread_pool__job_pop();
                mutex_unlock(&job_mutex);
 
                if (curjob)
@@ -139,12 +139,12 @@ int thread_pool__init(unsigned long thread_count)
        return i;
 }
 
-void *thread_pool__add_jobtype(struct kvm *kvm,
+void *thread_pool__add_job(struct kvm *kvm,
                               kvm_thread_callback_fn_t callback, void *data)
 {
-       struct thread_pool__job_info *job = calloc(1, sizeof(*job));
+       struct thread_pool__job *job = calloc(1, sizeof(*job));
 
-       *job = (struct thread_pool__job_info) {
+       *job = (struct thread_pool__job) {
                .kvm            = kvm,
                .data           = data,
                .callback       = callback,
@@ -154,16 +154,16 @@ void *thread_pool__add_jobtype(struct kvm *kvm,
        return job;
 }
 
-void thread_pool__signal_work(void *job)
+void thread_pool__do_job(void *job)
 {
-       struct thread_pool__job_info *jobinfo = job;
+       struct thread_pool__job *jobinfo = job;
 
        if (jobinfo == NULL)
                return;
 
        mutex_lock(&jobinfo->mutex);
        if (jobinfo->signalcount++ == 0)
-               thread_pool__job_info_push_locked(job);
+               thread_pool__job_push_locked(job);
        mutex_unlock(&jobinfo->mutex);
 
        pthread_cond_signal(&job_cond);

diff --git a/tools/kvm/virtio-blk.c b/tools/kvm/virtio-blk.c
index 3feabd060e157e996ca2eec25a519cebf1cc88d2..9034abdbe13c94a31bdb1b2b89eb0bd0cc315db4 100644 (file)
--- a/tools/kvm/virtio-blk.c
+++ b/tools/kvm/virtio-blk.c
@@ -188,7 +188,7 @@ static bool virtio_blk_pci_io_out(struct kvm *self, uint16_t port, void *data, i
                vring_init(&queue->vring, VIRTIO_BLK_QUEUE_SIZE, p, 4096);
 
                blk_device.jobs[blk_device.queue_selector] =
-                       thread_pool__add_jobtype(self, virtio_blk_do_io, queue);
+                       thread_pool__add_job(self, virtio_blk_do_io, queue);
 
                break;
        }
@@ -198,7 +198,7 @@ static bool virtio_blk_pci_io_out(struct kvm *self, uint16_t port, void *data, i
        case VIRTIO_PCI_QUEUE_NOTIFY: {
                uint16_t queue_index;
                queue_index             = ioport__read16(data);
-               thread_pool__signal_work(blk_device.jobs[queue_index]);
+               thread_pool__do_job(blk_device.jobs[queue_index]);
                break;
        }
        case VIRTIO_PCI_STATUS:

diff --git a/tools/kvm/virtio-console.c b/tools/kvm/virtio-console.c
index e66d1983aacf9dbf964af7e25aa637ca3971d848..f440ded507911ee8d39b52d88325d5827d156818 100644 (file)
--- a/tools/kvm/virtio-console.c
+++ b/tools/kvm/virtio-console.c
@@ -85,7 +85,7 @@ static void virtio_console__inject_interrupt_callback(struct kvm *self, void *pa
 
 void virtio_console__inject_interrupt(struct kvm *self)
 {
-       thread_pool__signal_work(console_device.jobs[VIRTIO_CONSOLE_RX_QUEUE]);
+       thread_pool__do_job(console_device.jobs[VIRTIO_CONSOLE_RX_QUEUE]);
 }
 
 static bool virtio_console_pci_io_device_specific_in(void *data, unsigned long offset, int size, uint32_t count)
@@ -190,10 +190,10 @@ static bool virtio_console_pci_io_out(struct kvm *self, uint16_t port, void *dat
 
                if (console_device.queue_selector == VIRTIO_CONSOLE_TX_QUEUE)
                        console_device.jobs[console_device.queue_selector] =
-                               thread_pool__add_jobtype(self, virtio_console_handle_callback, queue);
+                               thread_pool__add_job(self, virtio_console_handle_callback, queue);
                else if (console_device.queue_selector == VIRTIO_CONSOLE_RX_QUEUE)
                        console_device.jobs[console_device.queue_selector] =
-                               thread_pool__add_jobtype(self, virtio_console__inject_interrupt_callback, queue);
+                               thread_pool__add_job(self, virtio_console__inject_interrupt_callback, queue);
 
                break;
        }
@@ -203,7 +203,7 @@ static bool virtio_console_pci_io_out(struct kvm *self, uint16_t port, void *dat
        case VIRTIO_PCI_QUEUE_NOTIFY: {
                uint16_t queue_index;
                queue_index     = ioport__read16(data);
-               thread_pool__signal_work(console_device.jobs[queue_index]);
+               thread_pool__do_job(console_device.jobs[queue_index]);
                break;
        }
        case VIRTIO_PCI_STATUS: