runqueue.c File Reference

#include <string.h>
#include <stdio.h>
#include "runqueue.h"

Go to the source code of this file.

Functions
static void	__runqueue_empty_cb (struct uloop_timeout *timeout)
void	runqueue_init (struct runqueue *q)
static void	__runqueue_start_next (struct uloop_timeout *timeout)
static void	runqueue_start_next (struct runqueue *q)
static int	__runqueue_cancel (void *ctx, struct safe_list *list)
void	runqueue_cancel_active (struct runqueue *q)
void	runqueue_cancel_pending (struct runqueue *q)
void	runqueue_cancel (struct runqueue *q)
void	runqueue_kill (struct runqueue *q)
void	runqueue_task_cancel (struct runqueue_task *t, int type)
static void	__runqueue_task_timeout (struct uloop_timeout *timeout)
static void	_runqueue_task_add (struct runqueue *q, struct runqueue_task *t, bool running, bool first)
void	runqueue_task_add (struct runqueue *q, struct runqueue_task *t, bool running)
void	runqueue_task_add_first (struct runqueue *q, struct runqueue_task *t, bool running)
void	runqueue_task_kill (struct runqueue_task *t)
void	runqueue_stop (struct runqueue *q)
void	runqueue_resume (struct runqueue *q)
void	runqueue_task_complete (struct runqueue_task *t)
static void	__runqueue_proc_cb (struct uloop_process *p, int ret)
void	runqueue_process_cancel_cb (struct runqueue *q, struct runqueue_task *t, int type)
void	runqueue_process_kill_cb (struct runqueue *q, struct runqueue_task *t)
void	runqueue_process_add (struct runqueue *q, struct runqueue_process *p, pid_t pid)

Variables
static const struct runqueue_task_type	runqueue_proc_type

Function Documentation

__runqueue_cancel()

static int __runqueue_cancel ( void *  ctx, struct safe_list *  list  )

static

Definition at line 82 of file runqueue.c.

{
        struct runqueue_task *t;
 
        t = container_of(list, struct runqueue_task, list);
        runqueue_task_cancel(t, 0);
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

__runqueue_empty_cb()

static void __runqueue_empty_cb ( struct uloop_timeout *  timeout )

static

Definition at line 24 of file runqueue.c.

{
        struct runqueue *q = container_of(timeout, struct runqueue, timeout);
 
        q->empty_cb(q);
}

Here is the caller graph for this function:

__runqueue_proc_cb()

static void __runqueue_proc_cb ( struct uloop_process *  p, int  ret  )

static

Definition at line 238 of file runqueue.c.

{
        struct runqueue_process *t = container_of(p, struct runqueue_process, proc);
 
        runqueue_task_complete(&t->task);
}

Here is the call graph for this function:

Here is the caller graph for this function:

__runqueue_start_next()

static void __runqueue_start_next ( struct uloop_timeout *  timeout )

static

Definition at line 37 of file runqueue.c.

{
        struct runqueue *q = container_of(timeout, struct runqueue, timeout);
        struct runqueue_task *t;
 
        do {
                if (q->stopped)
                        break;
 
                if (list_empty(&q->tasks_inactive.list))
                        break;
 
                if (q->max_running_tasks && q->running_tasks >= q->max_running_tasks)
                        break;
 
                t = list_first_entry(&q->tasks_inactive.list, struct runqueue_task, list.list);
                safe_list_del(&t->list);
                safe_list_add(&t->list, &q->tasks_active);
                t->running = true;
                q->running_tasks++;
                if (t->run_timeout)
                        uloop_timeout_set(&t->timeout, t->run_timeout);
                t->type->run(q, t);
        } while (1);
 
        if (!q->empty &&
            list_empty(&q->tasks_active.list) &&
            list_empty(&q->tasks_inactive.list)) {
                q->empty = true;
                if (q->empty_cb) {
                        q->timeout.cb = __runqueue_empty_cb;
                        uloop_timeout_set(&q->timeout, 1);
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

__runqueue_task_timeout()

static void __runqueue_task_timeout ( struct uloop_timeout *  timeout )

static

Definition at line 138 of file runqueue.c.

{
        struct runqueue_task *t = container_of(timeout, struct runqueue_task, timeout);
 
        if (t->cancelled)
                runqueue_task_kill(t);
        else
                runqueue_task_cancel(t, t->cancel_type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

_runqueue_task_add()

static void _runqueue_task_add ( struct runqueue *  q, struct runqueue_task *  t, bool  running, bool  first  )

static

Definition at line 148 of file runqueue.c.

{
        struct safe_list *head;
 
        if (t->queued)
                return;
 
        if (!t->type->run && !running) {
                fprintf(stderr, "BUG: inactive task added without run() callback\n");
                return;
        }
 
        if (running) {
                q->running_tasks++;
                head = &q->tasks_active;
        } else {
                head = &q->tasks_inactive;
        }
 
        t->timeout.cb = __runqueue_task_timeout;
        t->q = q;
        if (first)
                safe_list_add_first(&t->list, head);
        else
                safe_list_add(&t->list, head);
        t->cancelled = false;
        t->queued = true;
        t->running = running;
        q->empty = false;
 
        runqueue_start_next(q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

runqueue_cancel()

void runqueue_cancel

(

struct runqueue *

q

)

Definition at line 102 of file runqueue.c.

{
        runqueue_cancel_pending(q);
        runqueue_cancel_active(q);
}

Here is the call graph for this function:

runqueue_cancel_active()

void runqueue_cancel_active

(

struct runqueue *

q

)

Definition at line 92 of file runqueue.c.

{
        safe_list_for_each(&q->tasks_active, __runqueue_cancel, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

runqueue_cancel_pending()

void runqueue_cancel_pending

(

struct runqueue *

q

)

Definition at line 97 of file runqueue.c.

{
        safe_list_for_each(&q->tasks_inactive, __runqueue_cancel, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

runqueue_init()

void runqueue_init

(

struct runqueue *

q

)

Definition at line 31 of file runqueue.c.

{
        INIT_SAFE_LIST(&q->tasks_active);
        INIT_SAFE_LIST(&q->tasks_inactive);
}

Here is the caller graph for this function:

runqueue_kill()

void runqueue_kill

(

struct runqueue *

q

)

Definition at line 108 of file runqueue.c.

{
        struct runqueue_task *t;
 
        while (!list_empty(&q->tasks_active.list)) {
                t = list_first_entry(&q->tasks_active.list, struct runqueue_task, list.list);
                runqueue_task_kill(t);
        }
        runqueue_cancel_pending(q);
        uloop_timeout_cancel(&q->timeout);
}

Here is the call graph for this function:

runqueue_process_add()

void runqueue_process_add	(	struct runqueue *	q,
		struct runqueue_process *	p,
		pid_t	pid
	)

Definition at line 269 of file runqueue.c.

{
        if (p->proc.pending)
                return;
 
        p->proc.pid = pid;
        p->proc.cb = __runqueue_proc_cb;
        if (!p->task.type)
                p->task.type = &runqueue_proc_type;
        uloop_process_add(&p->proc);
        if (!p->task.running)
                runqueue_task_add(q, &p->task, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

runqueue_process_cancel_cb()

void runqueue_process_cancel_cb	(	struct runqueue *	q,
		struct runqueue_task *	t,
		int	type
	)

Definition at line 245 of file runqueue.c.

{
        struct runqueue_process *p = container_of(t, struct runqueue_process, task);
 
        if (!type)
                type = SIGTERM;
 
        kill(p->proc.pid, type);
}

Here is the caller graph for this function:

runqueue_process_kill_cb()

void runqueue_process_kill_cb	(	struct runqueue *	q,
		struct runqueue_task *	t
	)

Definition at line 255 of file runqueue.c.

{
        struct runqueue_process *p = container_of(t, struct runqueue_process, task);
 
        uloop_process_delete(&p->proc);
        kill(p->proc.pid, SIGKILL);
}

Here is the caller graph for this function:

runqueue_resume()

void runqueue_resume

(

struct runqueue *

q

)

Definition at line 210 of file runqueue.c.

{
        q->stopped = false;
        runqueue_start_next(q);
}

Here is the call graph for this function:

runqueue_start_next()

static void runqueue_start_next ( struct runqueue *  q )

static

Definition at line 73 of file runqueue.c.

{
        if (q->empty)
                return;
 
        q->timeout.cb = __runqueue_start_next;
        uloop_timeout_set(&q->timeout, 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

runqueue_stop()

void runqueue_stop

(

struct runqueue *

q

)

Definition at line 205 of file runqueue.c.

{
        q->stopped = true;
}

runqueue_task_add()

void runqueue_task_add	(	struct runqueue *	q,
		struct runqueue_task *	t,
		bool	running
	)

Definition at line 181 of file runqueue.c.

{
        _runqueue_task_add(q, t, running, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

runqueue_task_add_first()

void runqueue_task_add_first	(	struct runqueue *	q,
		struct runqueue_task *	t,
		bool	running
	)

Definition at line 186 of file runqueue.c.

{
        _runqueue_task_add(q, t, running, 1);
}

Here is the call graph for this function:

runqueue_task_cancel()

void runqueue_task_cancel	(	struct runqueue_task *	t,
		int	type
	)

Definition at line 120 of file runqueue.c.

{
        if (!t->queued)
                return;
 
        if (!t->running) {
                runqueue_task_complete(t);
                return;
        }
 
        t->cancelled = true;
        if (t->cancel_timeout)
                uloop_timeout_set(&t->timeout, t->cancel_timeout);
        if (t->type->cancel)
                t->type->cancel(t->q, t, type);
}

Here is the call graph for this function:

Here is the caller graph for this function:

runqueue_task_complete()

void runqueue_task_complete

(

struct runqueue_task *

t

)

Definition at line 216 of file runqueue.c.

{
        struct runqueue *q = t->q;
 
        if (!t->queued)
                return;
 
        if (t->running)
                t->q->running_tasks--;
 
        uloop_timeout_cancel(&t->timeout);
 
        safe_list_del(&t->list);
        t->queued = false;
        t->running = false;
        t->cancelled = false;
        if (t->complete)
                t->complete(q, t);
        runqueue_start_next(q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

runqueue_task_kill()

void runqueue_task_kill

(

struct runqueue_task *

t

)

Definition at line 191 of file runqueue.c.

{
        struct runqueue *q = t->q;
        bool running = t->running;
 
        if (!t->queued)
                return;
 
        if (running && t->type->kill)
                t->type->kill(q, t);
 
        runqueue_task_complete(t);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

runqueue_proc_type

const struct runqueue_task_type runqueue_proc_type

static

Initial value:

= {
        .name = "process",
        .cancel = runqueue_process_cancel_cb,
        .kill = runqueue_process_kill_cb,
}

Definition at line 255 of file runqueue.c.