Added litmus.c, made it compile.

5 files changed, 166 insertions, 4 deletions

diff --git a/include/linux/litmus.h b/include/linux/litmus.h
index 922751424b..5d0a817457 100644
--- a/include/linux/litmus.h
+++ b/include/linux/litmus.h
@@ -98,5 +98,7 @@ extern int sched_type;
 /* CLEANUP: Should be queue_lock, does it really belong here? */
 extern  spinlock_t litmus_task_set_lock;
 
+/* CLEANUP: Remove after porting the trace framework */
+#define TRACE(x) 
 
 #endif  
diff --git a/include/linux/queuelock.h b/include/linux/queuelock.h
new file mode 100644
index 0000000000..0fa396a724
--- /dev/null
+++ b/include/linux/queuelock.h
@@ -0,0 +1,32 @@
+#ifndef _UNC_QUEUE_LOCK_H_

+#define _UNC_QUEUE_LOCK_H_

+/**

+*       Queue lock

+*

+*

+*       CLEANUP: Q-Locks to be re-implemented properly for the new LITMUS.

+*                Until then, we just use spin locks to make the code compile.

+*/

+

+#include <linux/spinlock.h>

+

+typedef spinlock_t queuelock_t;

+

+

+

+/* The new linux-like queue lock API.

+

+  int init_queuelock(queuelock_t* lock, int num_procs);

+  void queue_lock_wipe(queuelock_t * lock);

+  void queue_lock(queuelock_t *);

+  void queue_unlock(queuelock_t *); 

+

+*/

+

+

+#define queue_lock_init(lock, dummy)    spin_lock_init(lock)

+#define queue_lock_wipe(lock)           spin_lock_init(lock)

+#define queue_lock(lock)                spin_lock(lock)

+#define queue_unlock(lock)              spin_unlock(lock)

+

+#endif /*       _UNC_QUEUE_LOCK_H_      */

diff --git a/include/linux/rt_param.h b/include/linux/rt_param.h
new file mode 100644
index 0000000000..a844e754e9
--- /dev/null
+++ b/include/linux/rt_param.h
@@ -0,0 +1,120 @@
+/*
+ * Definition of the scheduler plugin interface.
+ * 
+ */
+#ifndef _LINUX_RT_PARAM_H_
+#define _LINUX_RT_PARAM_H_
+
+typedef unsigned long jiffie_t;
+
+/* different types of clients */
+typedef enum {
+        RT_CLASS_HARD,  
+        RT_CLASS_SOFT,
+        RT_CLASS_BEST_EFFORT
+} task_class_t;
+
+typedef struct rt_param {       
+        unsigned long   exec_cost;      
+        unsigned long   period; 
+        unsigned int    cpu;
+        task_class_t    class;
+} rt_param_t;
+
+/*      RT task parameters for scheduling extensions    
+ *      These parameters are inherited during clone and therefore must
+ *      be explicitly set up before the task set is launched.
+ */
+typedef struct task_rt_param {
+        /* Real-time marker     */
+        int                     is_realtime;    
+        /* user controlled parameters */
+        rt_param_t              basic_params;
+        /* is the task sleeping? */
+        unsigned int            flags;
+        struct {
+                /* when will this task be release the next time? */
+                jiffie_t        release;
+                /* time instant the last job was released  */
+                jiffie_t        last_release;
+                /* what is the current deadline? */
+                jiffie_t        deadline;
+
+                /* how long has this task executed so far? 
+                 * In case of capacity sharing a job completion cannot be
+                 * detected by checking time_slice == 0 as the job may have
+                 * executed while using another capacity. Use this counter
+                 * to keep track of the time spent on a CPU by a job.
+                 *
+                 * In other words: The number of consumed quanta since the
+                 *                  last job release.
+                 */
+                unsigned int    exec_time;
+        } times;
+        
+        /* put information for feedback control stuff and 
+         * information about the performance of the task here
+         */
+        struct {
+                /* How many non-tardy jobs since the last tardy job? */
+                unsigned int    nontardy_jobs_ctr;
+        } stats;
+
+        /* is this task under control of litmus?
+         *
+         * this is necessary because otherwise signal delivery code
+         * may try to wake up a task that is already queued in plugin
+         * data structures.
+         */
+        int                     litmus_controlled;
+} task_rt_param_t;
+
+/*      Possible RT flags       */
+#define RT_F_RUNNING    0x00000000
+#define RT_F_SLEEP      0x00000001
+#define RT_F_EXP_QUANTA 0x00000002
+
+
+/*      Realtime utility macros */
+#define get_passed_quanta(t)    ((t)->rt_param.times.exec_time) 
+#define inc_passed_quanta(t)    ((t)->rt_param.times.exec_time += 1)
+#define get_rt_flags(t)         ((t)->rt_param.flags)
+#define set_rt_flags(t,f)       (t)->rt_param.flags=(f)
+#define get_exec_cost(t)        ((t)->rt_param.basic_params.exec_cost)
+#define get_rt_period(t)        ((t)->rt_param.basic_params.period)
+#define set_rt_period(t,p)      (t)->rt_param.basic_params.period=(p)
+#define set_exec_cost(t,e)      (t)->rt_param.basic_params.exec_cost=(e)
+#define get_partition(t)        (t)->rt_param.basic_params.cpu
+#define get_deadline(t)         ((t)->rt_param.times.deadline)
+#define get_class(t)            ((t)->rt_param.basic_params.class)
+
+#define is_realtime(t)          ((t)->rt_param.is_realtime)
+#define is_hrt(t)               \
+        ((t)->rt_param.basic_params.class == RT_CLASS_HARD)
+#define is_srt(t)               \
+        ((t)->rt_param.basic_params.class == RT_CLASS_SOFT)
+#define is_be(t)                \
+        ((t)->rt_param.basic_params.class == RT_CLASS_BEST_EFFORT)
+
+
+
+#define clear_rt_params(t) \
+memset(&(t)->rt_param,0, sizeof(struct task_rt_param))
+
+#define get_last_release_time(t)   ((t)->rt_param.times.last_release)
+#define set_last_release_time(t,r) ((t)->rt_param.times.last_releasee=(r))
+
+#define is_running(t)   ((t)->state & TASK_RUNNING)
+#define is_released(t)  (time_before_eq((t)->rt_param.times.release, jiffies))
+#define is_tardy(t)     (time_before_eq((t)->rt_param.times.deadline, jiffies))
+
+
+/* real-time comparisn macros */
+#define earlier_deadline(a, b) (time_before(\
+        (a)->rt_param.times.deadline,\
+        (b)->rt_param.times.deadline))
+#define earlier_release(a, b)  (time_before(\
+        (a)->rt_param.times.release,\
+        (b)->rt_param.times.release))
+
+#endif
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 4463735351..9a8eea140a 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -3,6 +3,8 @@
 
 #include <linux/auxvec.h>       /* For AT_VECTOR_SIZE */
 
+#include <linux/rt_param.h>
+
 /*
  * cloning flags:
  */
@@ -1051,6 +1053,12 @@ struct task_struct {
 #ifdef CONFIG_FAULT_INJECTION
         int make_it_fail;
 #endif
+        /* litmus parameters and state */
+        task_rt_param_t rt_param;
+
+        /* allow scheduler plugins to queue in release lists, etc. */
+        struct list_head rt_list;
+
 };
 
 static inline pid_t process_group(struct task_struct *tsk)
diff --git a/include/linux/sched_plugin.h b/include/linux/sched_plugin.h
index 2867234285..f5cd785d84 100644
--- a/include/linux/sched_plugin.h
+++ b/include/linux/sched_plugin.h
@@ -2,8 +2,8 @@
  * Definition of the scheduler plugin interface.
  * 
  */
-#ifndef _LINUX_PLUGIN_DRIVER_H_
-#define _LINUX_PLUGIN_DRIVER_H_
+#ifndef _LINUX_SCHED_PLUGIN_H_
+#define _LINUX_SCHED_PLUGIN_H_
 
 #include <linux/sched.h>
 
@@ -93,11 +93,11 @@ extern sched_plugin_t *curr_sched_plugin;
 
 /*      External linux scheduler facilities */
 extern void deactivate_task(struct task_struct *, runqueue_t *);
-// Put the real-time task into the head of highest-priority RT queue
+/* Put the real-time task into the head of highest-priority RT queue */
 extern void __activate_idle_task(struct task_struct *, runqueue_t *);
 extern void __setscheduler(struct task_struct *, int, int);
 
 extern int get_sched_options(void);
 extern int get_this_ok_sched(void);
 extern void set_this_ok_sched(int);
-#endif                          /* _LINUX_PLUGIN_DRIVER_H_ */
+#endif