sched.c

   1 /*
   2  * Copyright (C) 2006 Andre Noll <maan@systemlinux.org>
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     This program is distributed in the hope that it will be useful,
  10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *     GNU General Public License for more details.
  13  *
  14  *     You should have received a copy of the GNU General Public License
  15  *     along with this program; if not, write to the Free Software
  16  *     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  17  */
  18
  19 /** \file sched.c paraslash's scheduling functions */
  20
  21 #include <sys/time.h>
  22 #include "para.h"
  23 #include "ipc.h"
  24 #include "fd.h"
  25 #include "list.h"
  26 #include "sched.h"
  27 #include "string.h"
  28 #include "error.h"
  29
  30 /**
  31  * The scheduler manages two lists of tasks.  The pre_select list contains
  32  * pointers to functions that are called before calling select() from the main
  33  * loop. Similarly, \a post_select_list is a list of function pointers each of
  34  * which is called after the select call.
  35  */
  36 struct list_head pre_select_list, post_select_list;
  37
  38 static struct timeval now_struct;
  39
  40 struct timeval *now = &now_struct;
  41
  42 static void sched_preselect(struct sched *s)
  43 {
  44         struct task *t, *tmp;
  45 again:
  46         list_for_each_entry_safe(t, tmp, &pre_select_list, pre_select_node) {
  47                 t->pre_select(s, t);
  48 //              PARA_INFO_LOG("%s \n", t->status);
  49                 if (t->ret > 0)
  50                         continue;
  51                 if (!t->event_handler)
  52                         continue;
  53                 t->event_handler(t);
  54                 goto again;
  55         }
  56 }
  57
  58 static void sched_post_select(struct sched *s)
  59 {
  60         struct task *t, *tmp;
  61
  62         list_for_each_entry_safe(t, tmp, &post_select_list, post_select_node) {
  63                 t->post_select(s, t);
  64 //              PARA_INFO_LOG("%s: %d\n", t->status, t->ret);
  65                 if (t->ret > 0 || !t->event_handler)
  66                         continue;
  67                 t->event_handler(t);
  68         }
  69 }
  70
  71 /**
  72  * the core function for all paraslash programs
  73  *
  74  * Short and sweet. It updates the global \a now pointer, calls all registered
  75  * pre_select hooks which may set the timeout and add any file descriptors to
  76  * the fd sets of \a s.  Next, it calls para_select() and makes the result available
  77  * to the registered tasks by calling their post_select hook.
  78  *
  79  * \return Zero if no more tasks are left in either of the two lists, negative
  80  * if para_select returned an error.
  81  *
  82  * \sa task, now.
  83  */
  84 int sched(struct sched *s)
  85 {
  86
  87         gettimeofday(now, NULL);
  88 again:
  89         FD_ZERO(&s->rfds);
  90         FD_ZERO(&s->wfds);
  91         s->timeout = s->default_timeout;
  92         s->max_fileno = -1;
  93         sched_preselect(s);
  94         s->select_ret = para_select(s->max_fileno + 1, &s->rfds,
  95                 &s->wfds, &s->timeout);
  96         if (s->select_ret < 0)
  97                 return s->select_ret;
  98         gettimeofday(now, NULL);
  99         sched_post_select(s);
 100         if (list_empty(&pre_select_list) && list_empty(&post_select_list))
 101                 return 0;
 102         goto again;
 103 }
 104
 105 /**
 106  * add a task to the scheduler
 107  *
 108  * \param t the task to add
 109  *
 110  * If the pre_select pointer of \a t is not \p NULL, it is added to
 111  * the pre_select list of the scheduler. Same goes for post_select.
 112  *
 113  * \sa task::pre_select, task::post_select
 114  */
 115 void register_task(struct task *t)
 116 {
 117         PARA_INFO_LOG("registering %s (%p)\n", t->status, t);
 118         if (t->pre_select) {
 119                 PARA_DEBUG_LOG("pre_select: %p\n", &t->pre_select);
 120                 list_add(&t->pre_select_node, &pre_select_list);
 121         }
 122         if (t->post_select) {
 123                 PARA_DEBUG_LOG("post_select: %p\n", &t->pre_select);
 124                 list_add(&t->post_select_node, &post_select_list);
 125         }
 126 }
 127
 128 /**
 129  * remove a task from the scheduler
 130  *
 131  * \param t the task to remove
 132  *
 133  * If the pre_select pointer of \a t is not \p NULL, it is removed from
 134  * the pre_select list of the scheduler. Same goes for \a post_select.
 135  */
 136 void unregister_task(struct task *t)
 137 {
 138         PARA_INFO_LOG("unregistering %s (%p)\n", t->status, t);
 139         if (t->pre_select)
 140                 list_del(&t->pre_select_node);
 141         if (t->post_select)
 142                 list_del(&t->post_select_node);
 143 };
 144
 145 /**
 146  * initialize the paraslash scheduler
 147  */
 148 void init_sched(void)
 149 {
 150         INIT_LIST_HEAD(&pre_select_list);
 151         INIT_LIST_HEAD(&post_select_list);
 152 };
 153
 154 /**
 155  * unregister all tasks
 156  *
 157  * This will cause \a sched() to return immediately because both the
 158  * \a pre_select_list and the \a post_select_list are empty.
 159  */
 160 void sched_shutdown(void)
 161 {
 162         struct task *t, *tmp;
 163
 164         list_for_each_entry_safe(t, tmp, &pre_select_list, pre_select_node)
 165                 unregister_task(t);
 166         /* remove tasks which do not have a pre_select hook */
 167         list_for_each_entry_safe(t, tmp, &post_select_list, post_select_node)
 168                 unregister_task(t);
 169 };
 170
 171 /**
 172  * get the list of all registered tasks.
 173  *
 174  * \return the task list
 175  *
 176  * Each entry of the list contains an identifier which is simply a hex number
 177  * that may be used in \a kill_task() to terminate the task.
 178  * The result ist dynamically allocated and must be freed by the caller.
 179  */
 180 char *get_task_list(void)
 181 {
 182         struct task *t, *tmp;
 183         char *msg = NULL;
 184         list_for_each_entry_safe(t, tmp, &pre_select_list, pre_select_node) {
 185                 char *tmp_msg;
 186                 tmp_msg = make_message("%s%p\tpre\t%s\n", msg? msg : "", t, t->status);
 187                 free(msg);
 188                 msg = tmp_msg;
 189         }
 190         list_for_each_entry_safe(t, tmp, &post_select_list, post_select_node) {
 191                 char *tmp_msg;
 192 //              if (t->pre_select)
 193 //                      continue;
 194                 tmp_msg = make_message("%s%p\tpost\t%s\n", msg? msg : "", t, t->status);
 195                 free(msg);
 196                 msg = tmp_msg;
 197         }
 198         //PARA_DEBUG_LOG("task list:\n%s", msg);
 199         return msg;
 200 }
 201
 202 /**
 203  * simulate an error for the given task
 204  *
 205  * \param id the task identifier
 206  *
 207  * Find the task identified by \a id, set the tasks' return value to
 208  * \p -E_TASK_KILLED and call the event handler of the task.
 209  *
 210  * \return Positive on sucess, negative if \a id does not correspond to a
 211  * registered task.
 212  */
 213 int kill_task(char *id)
 214 {
 215         struct task *t, *tmp;
 216         char buf[20];
 217         list_for_each_entry_safe(t, tmp, &pre_select_list, pre_select_node) {
 218                 sprintf(buf, "%p", t);
 219                 if (strcmp(id, buf))
 220                         continue;
 221                 t->ret = -E_TASK_KILLED;
 222                 if (t->event_handler)
 223                         t->event_handler(t);
 224                 return 1;
 225         }
 226         list_for_each_entry_safe(t, tmp, &post_select_list, post_select_node) {
 227                 sprintf(buf, "%p", t);
 228                 if (strcmp(id, buf))
 229                         continue;
 230                 t->ret = -E_TASK_KILLED;
 231                 if (t->event_handler)
 232                         t->event_handler(t);
 233                 return 1;
 234         }
 235         return -E_NO_SUCH_TASK;
 236 }