6 files changed, 51 insertions, 3 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index d515d1af1096..674528eece14 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -9,7 +9,9 @@
 #include <linux/jiffies.h>
 #include <litmus/sched_trace.h>
 
+#ifdef CONFIG_RELEASE_MASTER
 extern atomic_t release_master_cpu;
+#endif
 
 extern atomic_t __log_seq_no;
 
diff --git a/include/litmus/rt_domain.h b/include/litmus/rt_domain.h
index 9bf980713474..59e6b54e9281 100644
--- a/include/litmus/rt_domain.h
+++ b/include/litmus/rt_domain.h
@@ -28,7 +28,10 @@ typedef struct _rt_domain {
         /* real-time tasks waiting for release are in here */
         raw_spinlock_t                  release_lock;
         struct release_queue            release_queue;
+
+#ifdef CONFIG_RELEASE_MASTER
         int                             release_master;
+#endif
 
         /* for moving tasks to the release queue */
         raw_spinlock_t                  tobe_lock;
@@ -52,8 +55,11 @@ struct release_heap {
         struct bheap                    heap;
         /* used to trigger the release */
         struct hrtimer                  timer;
+
+#ifdef CONFIG_RELEASE_MASTER
         /* used to delegate releases */
         struct hrtimer_start_on_info    info;
+#endif
         /* required for the timer callback */
         rt_domain_t*                    dom;
 };
diff --git a/litmus/Kconfig b/litmus/Kconfig
index cc49e1a7f9c7..614e1051fa49 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -1,6 +1,6 @@
 menu "LITMUS^RT"
 
-menu "Plugins"
+menu "Scheduling"
 
 config PLUGIN_CEDF
         bool "Clustered-EDF"
@@ -11,6 +11,16 @@ config PLUGIN_CEDF
           On smaller platforms (e.g., ARM PB11MPCore), using C-EDF
           makes little sense since there aren't any shared caches.
 
+config RELEASE_MASTER
+        bool "Release-master Support"
+        default n
+        help
+           Allow one processor to act as a dedicated interrupt processor
+           that services all timer interrupts, but that does not schedule
+           real-time tasks. See RTSS'09 paper for details
+           (http://www.cs.unc.edu/~anderson/papers.html).
+           Currently only supported by GSN-EDF.
+
 endmenu
 
 menu "Real-Time Synchronization"
diff --git a/litmus/litmus.c b/litmus/litmus.c
index b71fc819eb51..c60423228607 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -30,8 +30,10 @@ atomic_t cannot_use_plugin	= ATOMIC_INIT(0);
 /* Give log messages sequential IDs. */
 atomic_t __log_seq_no = ATOMIC_INIT(0);
 
+#ifdef CONFIG_RELEASE_MASTER
 /* current master CPU for handling timer IRQs */
 atomic_t release_master_cpu = ATOMIC_INIT(NO_CPU);
+#endif
 
 static struct kmem_cache * bheap_node_cache;
 extern struct kmem_cache * release_heap_cache;
@@ -627,6 +629,7 @@ static int proc_write_cluster_size(struct file *file,
         return len;
 }
 
+#ifdef CONFIG_RELEASE_MASTER
 static int proc_read_release_master(char *page, char **start,
                                     off_t off, int count,
                                     int *eof, void *data)
@@ -676,13 +679,16 @@ static int proc_write_release_master(struct file *file,
                 }
         }
 }
+#endif
 
 static struct proc_dir_entry *litmus_dir = NULL,
         *curr_file = NULL,
         *stat_file = NULL,
         *plugs_file = NULL,
-        *clus_cache_idx_file = NULL,
-        *release_master_file = NULL;
+#ifdef CONFIG_RELEASE_MASTER
+        *release_master_file = NULL,
+#endif
+        *clus_cache_idx_file = NULL;
 
 static int __init init_litmus_proc(void)
 {
@@ -702,6 +708,7 @@ static int __init init_litmus_proc(void)
         curr_file->read_proc  = proc_read_curr;
         curr_file->write_proc = proc_write_curr;
 
+#ifdef CONFIG_RELEASE_MASTER
         release_master_file = create_proc_entry("release_master",
                                                 0644, litmus_dir);
         if (!release_master_file) {
@@ -711,6 +718,7 @@ static int __init init_litmus_proc(void)
         }
         release_master_file->read_proc = proc_read_release_master;
         release_master_file->write_proc  = proc_write_release_master;
+#endif
 
         clus_cache_idx_file = create_proc_entry("cluster_cache",
                                                 0644, litmus_dir);
@@ -741,8 +749,10 @@ static void exit_litmus_proc(void)
                 remove_proc_entry("active_plugin", litmus_dir);
         if (clus_cache_idx_file)
                 remove_proc_entry("cluster_cache", litmus_dir);
+#ifdef CONFIG_RELEASE_MASTER
         if (release_master_file)
                 remove_proc_entry("release_master", litmus_dir);
+#endif
         if (litmus_dir)
                 remove_proc_entry("litmus", NULL);
 }
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index 8d5db6050723..26f1cc48f865 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -158,7 +158,9 @@ static void reinit_release_heap(struct task_struct* t)
 
         /* initialize */
         bheap_init(&rh->heap);
+#ifdef __ARCH_HAS_SEND_PULL_TIMERS
         atomic_set(&rh->info.state, HRTIMER_START_ON_INACTIVE);
+#endif
 }
 /* arm_release_timer() - start local release timer or trigger
  *     remote timer (pull timer)
@@ -221,15 +223,19 @@ static void arm_release_timer(rt_domain_t *_rt)
                          *
                          * PINNED mode is ok on both local and remote CPU
                          */
+#ifdef CONFIG_RELEASE_MASTER
                         if (rt->release_master == NO_CPU)
+#endif
                                 __hrtimer_start_range_ns(&rh->timer,
                                                 ns_to_ktime(rh->release_time),
                                                 0, HRTIMER_MODE_ABS_PINNED, 0);
+#ifdef CONFIG_RELEASE_MASTER
                         else
                                 hrtimer_start_on(rt->release_master,
                                                 &rh->info, &rh->timer,
                                                 ns_to_ktime(rh->release_time),
                                                 HRTIMER_MODE_ABS_PINNED);
+#endif
                 } else
                         TRACE_TASK(t, "0x%p is not my timer\n", &rh->timer);
         }
@@ -251,7 +257,9 @@ void rt_domain_init(rt_domain_t *rt,
         if (!order)
                 order = dummy_order;
 
+#ifdef CONFIG_RELEASE_MASTER
         rt->release_master = NO_CPU;
+#endif
 
         bheap_init(&rt->ready_queue);
         INIT_LIST_HEAD(&rt->tobe_released);
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index c0c63eba70ce..e101768740ad 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -382,11 +382,13 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
         int out_of_time, sleep, preempt, np, exists, blocks;
         struct task_struct* next = NULL;
 
+#ifdef CONFIG_RELEASE_MASTER
         /* Bail out early if we are the release master.
          * The release master never schedules any real-time tasks.
          */
         if (gsnedf.release_master == entry->cpu)
                 return NULL;
+#endif
 
         raw_spin_lock(&gsnedf_lock);
         clear_will_schedule();
@@ -518,14 +520,18 @@ static void gsnedf_task_new(struct task_struct * t, int on_rq, int running)
                 entry = &per_cpu(gsnedf_cpu_entries, task_cpu(t));
                 BUG_ON(entry->scheduled);
 
+#ifdef CONFIG_RELEASE_MASTER
                 if (entry->cpu != gsnedf.release_master) {
+#endif
                         entry->scheduled = t;
                         tsk_rt(t)->scheduled_on = task_cpu(t);
+#ifdef CONFIG_RELEASE_MASTER
                 } else {
                         /* do not schedule on release master */
                         preempt(entry); /* force resched */
                         tsk_rt(t)->scheduled_on = NO_CPU;
                 }
+#endif
         } else {
                 t->rt_param.scheduled_on = NO_CPU;
         }
@@ -767,7 +773,9 @@ static long gsnedf_activate_plugin(void)
         cpu_entry_t *entry;
 
         bheap_init(&gsnedf_cpu_heap);
+#ifdef CONFIG_RELEASE_MASTER
         gsnedf.release_master = atomic_read(&release_master_cpu);
+#endif
 
         for_each_online_cpu(cpu) {
                 entry = &per_cpu(gsnedf_cpu_entries, cpu);
@@ -775,12 +783,16 @@ static long gsnedf_activate_plugin(void)
                 atomic_set(&entry->will_schedule, 0);
                 entry->linked    = NULL;
                 entry->scheduled = NULL;
+#ifdef CONFIG_RELEASE_MASTER
                 if (cpu != gsnedf.release_master) {
+#endif
                         TRACE("GSN-EDF: Initializing CPU #%d.\n", cpu);
                         update_cpu_position(entry);
+#ifdef CONFIG_RELEASE_MASTER
                 } else {
                         TRACE("GSN-EDF: CPU %d is release master.\n", cpu);
                 }
+#endif
         }
         return 0;
 }