diff --git a/tools/kvm/include/kvm/threadpool.h b/tools/kvm/include/kvm/threadpool.h
index 25b5eb8..4716411 100644
--- 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 c584ec7..25d9aad 100644
--- 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 3feabd0..9034abd 100644
--- 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 e66d198..f440ded 100644
--- 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:
diff --git a/tools/kvm/virtio-net.c b/tools/kvm/virtio-net.c
index 58b3de4..bbd687c 100644
--- a/tools/kvm/virtio-net.c
+++ b/tools/kvm/virtio-net.c
@@ -161,7 +161,7 @@ static bool virtio_net_pci_io_in(struct kvm *self, uint16_t port, void *data, in
 
 static void virtio_net_handle_callback(struct kvm *self, uint16_t queue_index)
 {
-	thread_pool__signal_work(net_device.jobs[queue_index]);
+	thread_pool__do_job(net_device.jobs[queue_index]);
 }
 
 static bool virtio_net_pci_io_out(struct kvm *self, uint16_t port, void *data, int size, uint32_t count)
@@ -189,10 +189,10 @@ static bool virtio_net_pci_io_out(struct kvm *self, uint16_t port, void *data, i
 
 		if (net_device.queue_selector == VIRTIO_NET_TX_QUEUE)
 			net_device.jobs[net_device.queue_selector] =
-				thread_pool__add_jobtype(self, virtio_net_tx_callback, queue);
+				thread_pool__add_job(self, virtio_net_tx_callback, queue);
 		else if (net_device.queue_selector == VIRTIO_NET_RX_QUEUE)
 			net_device.jobs[net_device.queue_selector] =
-				thread_pool__add_jobtype(self, virtio_net_rx_callback, queue);
+				thread_pool__add_job(self, virtio_net_rx_callback, queue);
 
 		break;
 	}
