cp/include/sched.h

   1 /*
   2  * (C) Copyright 2007-2011  Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
   3  *
   4  * This file is released under the GPLv2.  See the COPYING file for more
   5  * details.
   6  */
   7
   8 #ifndef __SCHED_H
   9 #define __SCHED_H
  10
  11 #include <list.h>
  12 #include <page.h>
  13 #include <dat.h>
  14 #include <clock.h>
  15 #include <interrupt.h>
  16 #include <ldep.h>
  17
  18 #define CAN_SLEEP               1       /* safe to sleep */
  19 #define CAN_LOOP                2       /* safe to busy-wait */
  20
  21 #define TASK_RUNNING            0
  22 #define TASK_SLEEPING           1
  23 #define TASK_LOCKED             2
  24 #define TASK_ZOMBIE             3
  25
  26 #define STACK_FRAME_SIZE        160
  27
  28 #define SCHED_SLICE_MS          30      /* 30ms scheduler slice */
  29 #define SCHED_TICKS_PER_SLICE   (HZ / SCHED_SLICE_MS)
  30
  31 #define HZ                      100     /* number of ticks per second */
  32
  33 /* saved registers for CP tasks */
  34 struct regs {
  35         struct psw psw;
  36         u64 gpr[16];
  37         u64 cr1;
  38 };
  39
  40 #define TASK_NAME_LEN           16
  41
  42 /*
  43  * This structure describes a running process.
  44  */
  45 struct task {
  46         struct regs regs;               /* saved registers */
  47
  48         struct list_head run_queue;     /* runnable list */
  49         struct list_head proc_list;     /* processes list */
  50         struct list_head blocked_list;  /* blocked on mutex/etc. list */
  51
  52         u64 slice_end_time;             /* end of slice time (ticks) */
  53
  54         int state;                      /* state */
  55
  56         void *stack;                    /* the stack */
  57
  58         char name[TASK_NAME_LEN+1];     /* task name */
  59
  60         /* lock dependency tracking */
  61         int nr_locks;
  62         struct held_lock lock_stack[LDEP_STACK_SIZE];
  63 };
  64
  65 extern void init_sched(void);           /* initialize the scheduler */
  66 extern struct task* create_task(char *name, int (*f)(void*), void*);
  67                                         /* create a new task */
  68 extern void __schedule(struct psw *,
  69                        int newstate);   /* scheduler helper - use with caution */
  70 extern void __schedule_svc(void);
  71 extern void __schedule_blocked_svc(void);
  72 extern void __schedule_exit_svc(void);
  73
  74 extern void make_runnable(struct task *task);
  75
  76 extern void list_tasks(void (*f)(struct task*, void*),
  77                        void *priv);
  78
  79 /**
  80  * current - the current task's task struct
  81  */
  82 #define current         extract_task()
  83
  84 #define PSA_CURRENT     ((struct task**) 0x290)
  85
  86 /**
  87  * extract_task - return the current task struct
  88  */
  89 static inline struct task *extract_task(void)
  90 {
  91         return *PSA_CURRENT;
  92 }
  93
  94 /**
  95  * set_task_ptr - set the stack's task struct pointer
  96  * @task:       task struct pointer to be made current
  97  */
  98 static inline void set_task_ptr(struct task *task)
  99 {
 100         *PSA_CURRENT = task;
 101 }
 102
 103 /**
 104  * schedule - used to explicitly yield the cpu
 105  */
 106 static inline void schedule(void)
 107 {
 108         /*
 109          * if we are not interruptable, we shouldn't call any functions that
 110          * may sleep - schedule() is guaranteed to sleep :)
 111          */
 112         BUG_ON(!interruptable());
 113
 114         asm volatile(
 115                 "       svc     %0\n"
 116         : /* output */
 117         : /* input */
 118           "i" (SVC_SCHEDULE)
 119         );
 120 }
 121
 122 /**
 123  * schedule_blocked - used to explicitly yield the cpu without readding the
 124  * task to the runnable queue
 125  */
 126 static inline void schedule_blocked(void)
 127 {
 128         /*
 129          * if we are not interruptable, we shouldn't call any functions that
 130          * may sleep - schedule() is guaranteed to sleep :)
 131          */
 132         BUG_ON(!interruptable());
 133
 134         asm volatile(
 135                 "       svc     %0\n"
 136         : /* output */
 137         : /* input */
 138           "i" (SVC_SCHEDULE_BLOCKED)
 139         );
 140 }
 141
 142 /**
 143  * exit - schedule with the intent to terminate the current task
 144  */
 145 static inline void exit(void)
 146 {
 147         /*
 148          * if we are not interruptable, we shouldn't call any functions that
 149          * may sleep - schedule() is guaranteed to sleep :)
 150          */
 151         BUG_ON(!interruptable());
 152
 153         asm volatile(
 154                 "       svc     %0\n"
 155         : /* output */
 156         : /* input */
 157           "i" (SVC_SCHEDULE_EXIT)
 158         );
 159 }
 160
 161 #endif