X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=sched.c;h=2c49050cb6408085c02951b170d49d34d11169b2;hp=9356dd0c4d14be11fb1284eae7227a8489acf907;hb=33713473b1051c2d9f487c66a92a5cbdf1277ce3;hpb=f23be61d476e3f354e31072da0e0e77050a8dc56 diff --git a/sched.c b/sched.c index 9356dd0c..2c49050c 100644 --- a/sched.c +++ b/sched.c @@ -1,3 +1,23 @@ +/* + * Copyright (C) 2006-2007 Andre Noll + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + */ + +/** \file sched.c paraslash's scheduling functions */ + #include #include "para.h" #include "ipc.h" @@ -7,8 +27,11 @@ #include "string.h" #include "error.h" -struct list_head pre_select_list; -struct list_head post_select_list; +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 sched_preselect(struct sched *s) { @@ -39,10 +62,26 @@ static void sched_post_select(struct sched *s) } } +/** + * the core function for all paraslash programs + * + * \param s pointer to the scheduler struct + * + * This function updates the global \a now pointer, calls all registered + * pre_select hooks which may set the timeout and add any file descriptors to + * the fd sets of \a s. Next, it calls para_select() and makes the result available + * to the registered tasks by calling their post_select hook. + * + * \return Zero if no more tasks are left in either of the two lists, negative + * if para_select returned an error. + * + * \sa task, now. + */ int sched(struct sched *s) { - - gettimeofday(&s->now, NULL); + if (!initialized) + return -E_NOT_INITIALIZED; + gettimeofday(now, NULL); again: FD_ZERO(&s->rfds); FD_ZERO(&s->wfds); @@ -53,35 +92,61 @@ again: &s->wfds, &s->timeout); if (s->select_ret < 0) return s->select_ret; - gettimeofday(&s->now, NULL); + gettimeofday(now, NULL); sched_post_select(s); if (list_empty(&pre_select_list) && list_empty(&post_select_list)) return 0; goto again; } -void *register_task(struct task *t) +/** + * initialize the paraslash scheduler + */ +static void init_sched(void) +{ + PARA_INFO_LOG("%s", "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 + * + * 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) { + if (!initialized) + init_sched(); PARA_INFO_LOG("registering %s (%p)\n", t->status, t); if (t->pre_select) { PARA_DEBUG_LOG("pre_select: %p\n", &t->pre_select); - if (t->flags & PRE_ADD_TAIL) - list_add_tail(&t->pre_select_node, &pre_select_list); - else - list_add(&t->pre_select_node, &pre_select_list); + para_list_add(&t->pre_select_node, &pre_select_list); } if (t->post_select) { PARA_DEBUG_LOG("post_select: %p\n", &t->pre_select); - if (t->flags & POST_ADD_TAIL) - list_add_tail(&t->post_select_node, &post_select_list); - else - list_add(&t->post_select_node, &post_select_list); + para_list_add(&t->post_select_node, &post_select_list); } - return t; } +/** + * remove a task from the scheduler + * + * \param t the task to remove + * + * If the pre_select pointer of \a t is not \p NULL, it is removed from + * the pre_select list of the scheduler. Same goes for \a post_select. + */ void unregister_task(struct task *t) { + if (!initialized) + return; PARA_INFO_LOG("unregistering %s (%p)\n", t->status, t); if (t->pre_select) list_del(&t->pre_select_node); @@ -89,22 +154,95 @@ void unregister_task(struct task *t) list_del(&t->post_select_node); }; -void init_sched(void) -{ - INIT_LIST_HEAD(&pre_select_list); - INIT_LIST_HEAD(&post_select_list); -}; - +/** + * unregister all tasks + * + * This will cause \a sched() 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); /* remove tasks which do not have a pre_select hook */ 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. + * + * \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. + * The result ist dynamically allocated and must be freed by the caller. + */ +char *get_task_list(void) +{ + struct task *t, *tmp; + char *msg = NULL; + + if (!initialized) + return NULL; + list_for_each_entry_safe(t, tmp, &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) { + char *tmp_msg; +// if (t->pre_select) +// continue; + tmp_msg = make_message("%s%p\tpost\t%s\n", msg? msg : "", t, t->status); + free(msg); + msg = tmp_msg; + } + //PARA_DEBUG_LOG("task list:\n%s", msg); + return msg; +} + +/** + * simulate an error for the given task + * + * \param id the task identifier + * + * Find the task identified by \a id, set the tasks' return value to + * \p -E_TASK_KILLED and call the event handler of the task. + * + * \return Positive on success, negative on errors (e.g. if \a id does not + * correspond to a registered task). + */ +int kill_task(char *id) +{ + struct task *t, *tmp; + char buf[20]; -//char *get_tast_list(); + 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->ret = -E_TASK_KILLED; + if (t->event_handler) + t->event_handler(t); + 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->ret = -E_TASK_KILLED; + if (t->event_handler) + t->event_handler(t); + return 1; + } + return -E_NO_SUCH_TASK; +}