* Copyright 2022, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#include "device.h"
#include <stdio.h>
#include <compat/sys/callout.h>
#include <compat/sys/taskqueue.h>
#include <compat/sys/haiku-module.h>
static int _taskqueue_start_threads(struct taskqueue **taskQueue,
int count, int priority, const char *name);
static void taskqueue_terminate(struct thread **pp, struct taskqueue *tq);
#define malloc kernel_malloc
#define free kernel_free
#include "fbsd_subr_taskqueue.c"
#undef malloc
#undef free
struct taskqueue *taskqueue_fast = NULL;
struct taskqueue *taskqueue_swi = NULL;
struct taskqueue *taskqueue_thread = NULL;
static int32
tq_handle_thread(void *data)
{
struct taskqueue *tq = data;
taskqueue_run_callback(tq, TASKQUEUE_CALLBACK_TYPE_INIT);
TQ_LOCK(tq);
sem_id sem = tq->tq_sem;
TQ_UNLOCK(tq);
while (acquire_sem(sem) == B_NO_ERROR) {
TQ_LOCK(tq);
taskqueue_run_locked(tq);
TQ_UNLOCK(tq);
}
taskqueue_run_callback(tq, TASKQUEUE_CALLBACK_TYPE_SHUTDOWN);
return 0;
}
static int
_taskqueue_start_threads(struct taskqueue **taskQueue, int count, int priority,
const char *name)
{
struct taskqueue *tq = (*taskQueue);
int i, j;
if (count == 0)
return -1;
if (tq->tq_threads != NULL)
return -1;
if (count == 1) {
tq->tq_threads = &tq->tq_thread_storage;
} else {
tq->tq_threads = malloc(sizeof(thread_id) * count);
if (tq->tq_threads == NULL)
return B_NO_MEMORY;
}
tq->tq_sem = create_sem(0, tq->tq_name);
if (tq->tq_sem < B_OK) {
if (count > 1)
free(tq->tq_threads);
tq->tq_threads = NULL;
return tq->tq_sem;
}
for (i = 0; i < count; i++) {
tq->tq_threads[i] = spawn_kernel_thread(tq_handle_thread, tq->tq_name,
priority, tq);
if (tq->tq_threads[i] < B_OK) {
status_t status = tq->tq_threads[i];
for (j = 0; j < i; j++)
kill_thread(tq->tq_threads[j]);
if (count > 1)
free(tq->tq_threads);
tq->tq_threads = NULL;
delete_sem(tq->tq_sem);
return status;
}
}
tq->tq_threadcount = count;
for (i = 0; i < count; i++)
resume_thread(tq->tq_threads[i]);
return 0;
}
static void
taskqueue_terminate(struct thread **pp, struct taskqueue *tq)
{
if (tq->tq_sem == -1)
return;
TQ_UNLOCK(tq);
delete_sem(tq->tq_sem);
tq->tq_sem = -1;
for (int i = 0; i < tq->tq_threadcount; i++) {
status_t status;
wait_for_thread(tq->tq_threads[i], &status);
}
if (tq->tq_threadcount > 1)
free(tq->tq_threads);
tq->tq_threads = NULL;
TQ_LOCK(tq);
}
void
taskqueue_drain(struct taskqueue *taskQueue, struct task *task)
{
if (taskQueue == NULL)
return;
TQ_LOCK(taskQueue);
while (task->ta_pending != 0 || task_is_running(taskQueue, task)) {
TQ_UNLOCK(taskQueue);
snooze(0);
TQ_LOCK(taskQueue);
}
TQ_UNLOCK(taskQueue);
}
void
taskqueue_drain_all(struct taskqueue *taskQueue)
{
struct task t_barrier;
if (taskQueue == NULL) {
printf("taskqueue_drain_all called with NULL taskqueue\n");
return;
}
TASK_INIT(&t_barrier, USHRT_MAX, taskqueue_task_nop_fn, &t_barrier);
taskqueue_enqueue(taskQueue, &t_barrier);
taskqueue_drain(taskQueue, &t_barrier);
}
void
taskqueue_thread_enqueue(void *context)
{
struct taskqueue **tqp = context;
release_sem_etc((*tqp)->tq_sem, 1, B_DO_NOT_RESCHEDULE);
}
void
_task_init(struct task *task, int prio, task_fn_t handler, void *context)
{
task->ta_priority = prio;
task->ta_flags = 0;
task->ta_func = handler;
task->ta_context = context;
task->ta_pending = 0;
}
status_t
init_taskqueues()
{
status_t status = B_NO_MEMORY;
if (HAIKU_DRIVER_REQUIRES(FBSD_FAST_TASKQUEUE)) {
taskqueue_fast = taskqueue_create_fast("fast taskq", 0,
taskqueue_thread_enqueue, &taskqueue_fast);
if (taskqueue_fast == NULL)
return B_NO_MEMORY;
status = taskqueue_start_threads(&taskqueue_fast, 1,
B_REAL_TIME_PRIORITY, "fast taskq thread");
if (status < B_OK)
goto err_1;
}
if (HAIKU_DRIVER_REQUIRES(FBSD_SWI_TASKQUEUE)) {
taskqueue_swi = taskqueue_create_fast("swi taskq", 0,
taskqueue_thread_enqueue, &taskqueue_swi);
if (taskqueue_swi == NULL) {
status = B_NO_MEMORY;
goto err_1;
}
status = taskqueue_start_threads(&taskqueue_swi, 1,
B_REAL_TIME_PRIORITY, "swi taskq");
if (status < B_OK)
goto err_2;
}
if (HAIKU_DRIVER_REQUIRES(FBSD_THREAD_TASKQUEUE)) {
taskqueue_thread = taskqueue_create("thread taskq", 0,
taskqueue_thread_enqueue, &taskqueue_thread);
if (taskqueue_thread == NULL) {
status = B_NO_MEMORY;
goto err_2;
}
status = taskqueue_start_threads(&taskqueue_thread, 1,
B_REAL_TIME_PRIORITY, "swi taskq");
if (status < B_OK)
goto err_3;
}
return B_OK;
err_3:
if (taskqueue_thread)
taskqueue_free(taskqueue_thread);
err_2:
if (taskqueue_swi)
taskqueue_free(taskqueue_swi);
err_1:
if (taskqueue_fast)
taskqueue_free(taskqueue_fast);
return status;
}
void
uninit_taskqueues()
{
if (HAIKU_DRIVER_REQUIRES(FBSD_THREAD_TASKQUEUE))
taskqueue_free(taskqueue_thread);
if (HAIKU_DRIVER_REQUIRES(FBSD_SWI_TASKQUEUE))
taskqueue_free(taskqueue_swi);
if (HAIKU_DRIVER_REQUIRES(FBSD_FAST_TASKQUEUE))
taskqueue_free(taskqueue_fast);
}
