/*
- * Copyright (C) 2006-2011 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2006-2013 Andre Noll <maan@systemlinux.org>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
/** \file sched.c Paraslash's scheduling functions. */
#include <regex.h>
-#include <dirent.h> /* readdir() */
#include <assert.h>
#include <sys/time.h>
#include "time.h"
#include "error.h"
-static struct list_head pre_select_list, post_select_list;
-static int initialized;
-
static struct timeval now_struct;
struct timeval *now = &now_struct;
*/
static void unregister_task(struct task *t)
{
- if (!initialized)
- return;
+ assert(t->error < 0);
PARA_INFO_LOG("unregistering %s (%s)\n", t->status,
- t->error <0? para_strerror(-t->error) : "shutdown");
+ para_strerror(-t->error));
if (t->pre_select)
list_del(&t->pre_select_node);
if (t->post_select)
list_del(&t->post_select_node);
- t->error = -E_TASK_UNREGISTERED;
}
+static inline bool timeout_is_zero(struct sched *s)
+{
+ struct timeval *tv = &s->select_timeout;
+ return tv->tv_sec == 0 && tv->tv_usec == 0;
+}
static void sched_preselect(struct sched *s)
{
struct task *t, *tmp;
- list_for_each_entry_safe(t, tmp, &pre_select_list, pre_select_node) {
- if (t->error >= 0 && t->pre_select)
+
+ list_for_each_entry_safe(t, tmp, &s->pre_select_list, pre_select_node) {
+ if (t->notification != 0)
+ sched_min_delay(s);
+ if (t->pre_select)
t->pre_select(s, t);
-// PARA_INFO_LOG("%s \n", t->status);
- if (t->error >= 0)
- continue;
- /*
- * We have to check whether the list is empty because the call
- * to ->pre_select() might have called sched_shutdown(). In
- * this case t has been unregistered already, so we must not
- * unregister it again.
- */
- if (list_empty(&pre_select_list))
- return;
- unregister_task(t);
}
}
{
struct task *t, *tmp;
- list_for_each_entry_safe(t, tmp, &post_select_list, post_select_node) {
+ list_for_each_entry_safe(t, tmp, &s->post_select_list, post_select_node) {
if (t->error >= 0)
call_post_select(s, t);
// PARA_INFO_LOG("%s: %d\n", t->status, t->ret);
+ t->notification = 0;
if (t->error >= 0)
continue;
- /* nec., see sched_preselect() */
- if (list_empty(&post_select_list))
- return;
unregister_task(t);
}
}
{
int ret;
- if (!initialized)
- return -E_NOT_INITIALIZED;
if (!s->select_function)
s->select_function = para_select;
again:
s->max_fileno = -1;
gettimeofday(now, NULL);
sched_preselect(s);
- if (list_empty(&pre_select_list) && list_empty(&post_select_list))
- return 0;
ret = s->select_function(s->max_fileno + 1, &s->rfds, &s->wfds,
&s->select_timeout);
if (ret < 0)
}
gettimeofday(now, NULL);
sched_post_select(s);
- if (list_empty(&pre_select_list) && list_empty(&post_select_list))
+ if (list_empty(&s->pre_select_list) && list_empty(&s->post_select_list))
return 0;
goto again;
}
-/*
- * Initialize the paraslash scheduler.
- */
-static void init_sched(void)
-{
- PARA_INFO_LOG("initializing scheduler\n");
- INIT_LIST_HEAD(&pre_select_list);
- INIT_LIST_HEAD(&post_select_list);
- initialized = 1;
-}
-
/**
* Add a task to the scheduler.
*
- * \param t the task to add
+ * \param t The task to add.
+ * \param s The scheduler instance to add the task to.
*
* If the pre_select pointer of \a t is not \p NULL, it is added to
* the pre_select list of the scheduler. Same goes for post_select.
*
* \sa task::pre_select, task::post_select
*/
-void register_task(struct task *t)
+void register_task(struct sched *s, struct task *t)
{
- if (!initialized)
- init_sched();
PARA_INFO_LOG("registering %s (%p)\n", t->status, t);
+ t->notification = 0;
+ if (!s->pre_select_list.next)
+ INIT_LIST_HEAD(&s->pre_select_list);
+ if (!s->post_select_list.next)
+ INIT_LIST_HEAD(&s->post_select_list);
if (t->pre_select) {
PARA_DEBUG_LOG("pre_select: %p\n", &t->pre_select);
- list_add_tail(&t->pre_select_node, &pre_select_list);
+ list_add_tail(&t->pre_select_node, &s->pre_select_list);
}
if (t->post_select) {
PARA_DEBUG_LOG("post_select: %p\n", &t->post_select);
- list_add_tail(&t->post_select_node, &post_select_list);
+ list_add_tail(&t->post_select_node, &s->post_select_list);
}
}
-/**
- * Unregister all tasks.
- *
- * This will cause \a schedule() to return immediately because both the
- * \a pre_select_list and the \a post_select_list are empty.
- */
-void sched_shutdown(void)
-{
- struct task *t, *tmp;
-
- if (!initialized)
- return;
- list_for_each_entry_safe(t, tmp, &pre_select_list, pre_select_node)
- unregister_task(t);
- list_for_each_entry_safe(t, tmp, &post_select_list, post_select_node)
- unregister_task(t);
- initialized = 0;
-}
-
/**
* Get the list of all registered tasks.
*
+ * \param s The scheduler instance to get the task list from.
+ *
* \return The task list.
*
- * Each entry of the list contains an identifier which is simply a hex number
- * that may be used in \a kill_task() to terminate the task.
+ * Each entry of the list contains an identifier which is simply a hex number.
* The result is dynamically allocated and must be freed by the caller.
*/
-char *get_task_list(void)
+char *get_task_list(struct sched *s)
{
struct task *t, *tmp;
char *msg = NULL;
- if (!initialized)
- return NULL;
- list_for_each_entry_safe(t, tmp, &pre_select_list, pre_select_node) {
+ list_for_each_entry_safe(t, tmp, &s->pre_select_list, pre_select_node) {
char *tmp_msg;
tmp_msg = make_message("%s%p\tpre\t%s\n", msg? msg : "", t, t->status);
free(msg);
msg = tmp_msg;
}
- list_for_each_entry_safe(t, tmp, &post_select_list, post_select_node) {
+ list_for_each_entry_safe(t, tmp, &s->post_select_list, post_select_node) {
char *tmp_msg;
// if (t->pre_select)
// continue;
}
/**
- * Simulate an error for the given task.
+ * Set the notification value of a task.
*
- * \param id The task identifier.
+ * \param t The task to notify.
+ * \param err A positive error code.
*
- * Find the task identified by \a id, set the tasks' error value to
- * \p -E_TASK_KILLED and unregister the task.
+ * Tasks which honor notifications are supposed to call \ref
+ * task_get_notification() in their post_select function and act on the
+ * returned notification value.
*
- * \return Positive on success, negative on errors (e.g. if \a id does not
- * correspond to a registered task).
+ * If the scheduler detects during its pre_select loop that at least one task
+ * has been notified, the loop terminates, and the post_select methods of all
+ * taks are immediately called again.
+ *
+ * The notification for a task is reset after the call to its post_select
+ * method.
+ *
+ * \sa \ref task_get_notification().
*/
-int kill_task(char *id)
+void task_notify(struct task *t, int err)
{
- struct task *t, *tmp;
- char buf[20];
+ assert(err > 0);
+ if (t->notification == -err) /* ignore subsequent notifications */
+ return;
+ PARA_INFO_LOG("notifying task %s: %s\n", t->status, para_strerror(err));
+ t->notification = -err;
+}
- if (!initialized)
- return -E_NOT_INITIALIZED;
- list_for_each_entry_safe(t, tmp, &pre_select_list, pre_select_node) {
- sprintf(buf, "%p", t);
- if (strcmp(id, buf))
- continue;
- t->error = -E_TASK_KILLED;
- return 1;
- }
- list_for_each_entry_safe(t, tmp, &post_select_list, post_select_node) {
- sprintf(buf, "%p", t);
- if (strcmp(id, buf))
- continue;
- t->error = -E_TASK_KILLED;
- return 1;
- }
- return -E_NO_SUCH_TASK;
+/**
+ * Return the notification value of a task.
+ *
+ * \param t The task to get the notification value from.
+ *
+ * \return The notification value. If this is negative, the task has been
+ * notified by another task. Tasks are supposed to check for notifications by
+ * calling this function from their post_select method.
+ *
+ * \sa \ref task_notify().
+ */
+int task_get_notification(struct task *t)
+{
+ return t->notification;
+}
+
+/**
+ * Set the notification value of all tasks of a scheduler instance.
+ *
+ * \param s The scheduler instance whose tasks should be notified.
+ * \param err A positive error code.
+ *
+ * This simply iterates over all existing tasks of \a s and sets each
+ * task's notification value to \p -err.
+ */
+void task_notify_all(struct sched *s, int err)
+{
+ struct task *t;
+
+ list_for_each_entry(t, &s->pre_select_list, pre_select_node)
+ task_notify(t, err);
+ list_for_each_entry(t, &s->post_select_list, post_select_node)
+ task_notify(t, err);
}
/**
*/
void sched_min_delay(struct sched *s)
{
- s->select_timeout.tv_sec = 0;
- s->select_timeout.tv_usec = 1;
+ s->select_timeout.tv_sec = s->select_timeout.tv_usec = 0;
}
/**
* \param barrier Absolute time before select() should return.
* \param s Pointer to the scheduler struct.
*
- * If \a barrier is in the past, this function does nothing.
+ * \return If \a barrier is in the past, this function does nothing and returns
+ * zero. Otherwise it returns one.
*
* \sa sched_request_barrier_or_min_delay().
*/
-void sched_request_barrier(struct timeval *barrier, struct sched *s)
+int sched_request_barrier(struct timeval *barrier, struct sched *s)
{
struct timeval diff;
if (tv_diff(now, barrier, &diff) > 0)
- return;
+ return 0;
sched_request_timeout(&diff, s);
+ return 1;
}
/**
* \param barrier Absolute time before select() should return.
* \param s Pointer to the scheduler struct.
*
- * If \a barrier is in the past, this function requests a minimal timeout.
+ * \return If \a barrier is in the past, this function requests a minimal
+ * timeout and returns zero. Otherwise it returns one.
*
* \sa sched_min_delay(), sched_request_barrier().
*/
-void sched_request_barrier_or_min_delay(struct timeval *barrier, struct sched *s)
+int sched_request_barrier_or_min_delay(struct timeval *barrier, struct sched *s)
{
struct timeval diff;
- if (tv_diff(now, barrier, &diff) > 0)
- return sched_min_delay(s);
+ if (tv_diff(now, barrier, &diff) > 0) {
+ sched_min_delay(s);
+ return 0;
+ }
sched_request_timeout(&diff, s);
+ return 1;
}
projects / paraslash.git / blobdiff