Merge branch 'master' of ssh://cvs/cvs/proj/litmus/repo/litmus2008

13 files changed, 55 insertions, 36 deletions

diff --git a/arch/sparc64/kernel/systbls.S b/arch/sparc64/kernel/systbls.S
index 7fc7615b57..7dcbac74f7 100644
--- a/arch/sparc64/kernel/systbls.S
+++ b/arch/sparc64/kernel/systbls.S
@@ -165,7 +165,8 @@ sys_call_table:
         .word sys_set_rt_task_param, sys_get_rt_task_param, sys_complete_job, sys_register_np_flag, sys_exit_np
 /*320*/
         .word sys_od_open, sys_od_close, sys_fmlp_down, sys_fmlp_up, sys_srp_down
-/*325*/ .word sys_srp_up, sys_query_job_no, sys_wait_for_job_release, sys_wait_for_ts_release, sys_release_ts
+/*325*/ .word sys_srp_up, sys_query_job_no, sys_wait_for_job_release, sys_wait_for_ts_release
+/*330*/ .word sys_release_ts, sys_null_call
         
 #if defined(CONFIG_SUNOS_EMUL) || defined(CONFIG_SOLARIS_EMUL) || \
     defined(CONFIG_SOLARIS_EMUL_MODULE)
diff --git a/arch/x86/kernel/syscall_table_32.S b/arch/x86/kernel/syscall_table_32.S
index f6fdb0a885..65496c26da 100644
--- a/arch/x86/kernel/syscall_table_32.S
+++ b/arch/x86/kernel/syscall_table_32.S
@@ -339,4 +339,5 @@ ENTRY(sys_call_table)
         .long sys_query_job_no
         .long sys_wait_for_job_release
         .long sys_wait_for_ts_release
-        .long sys_release_ts            /* 339 */
+        .long sys_release_ts
+        .long sys_null_call             /* 340 */
diff --git a/include/litmus/unistd.h b/include/litmus/unistd.h
index 8224235d95..5ef367f491 100644
--- a/include/litmus/unistd.h
+++ b/include/litmus/unistd.h
@@ -16,5 +16,6 @@
 #define __NR_wait_for_job_release __LSC(12)
 #define __NR_wait_for_ts_release __LSC(13)
 #define __NR_release_ts         __LSC(14)
+#define __NR_null_call          __LSC(15)
 
-#define NR_litmus_syscalls 15
+#define NR_litmus_syscalls 16
diff --git a/litmus/fdso.c b/litmus/fdso.c
index 81ab0afff3..bdc0466f9e 100644
--- a/litmus/fdso.c
+++ b/litmus/fdso.c
@@ -67,7 +67,7 @@ static struct inode_obj_id* alloc_inode_obj(struct inode* inode,
         if (!raw_obj)
                 return NULL;
 
-        obj = kmalloc(sizeof(struct inode_obj_id), GFP_KERNEL);
+        obj = kmalloc(sizeof(*obj), GFP_KERNEL);
         if (!obj)
                 return NULL;
         INIT_LIST_HEAD(&obj->list);
@@ -134,9 +134,8 @@ static struct od_table_entry*  get_od_entry(struct task_struct* t)
 
         table = t->od_table;
         if (!table) {
-                table = (struct od_table_entry*)
-                        kzalloc(sizeof(struct  od_table_entry) *
-                                MAX_OBJECT_DESCRIPTORS, GFP_KERNEL);
+                table = kzalloc(sizeof(*table) * MAX_OBJECT_DESCRIPTORS, 
+                                GFP_KERNEL);
                 t->od_table = table;
         }
 
diff --git a/litmus/fmlp.c b/litmus/fmlp.c
index f34eeea9ab..820af8e00e 100644
--- a/litmus/fmlp.c
+++ b/litmus/fmlp.c
@@ -23,7 +23,7 @@ static  void* create_fmlp_semaphore(void)
         struct pi_semaphore* sem;
         int i;
 
-        sem = kmalloc(sizeof(struct pi_semaphore), GFP_KERNEL);
+        sem = kmalloc(sizeof(*sem), GFP_KERNEL);
         if (!sem)
                 return NULL;
         atomic_set(&sem->count, 1);
diff --git a/litmus/ftdev.c b/litmus/ftdev.c
index a62ccecf64..1c1c241a0a 100644
--- a/litmus/ftdev.c
+++ b/litmus/ftdev.c
@@ -15,7 +15,7 @@ struct ft_buffer* alloc_ft_buffer(unsigned int count, size_t size)
         char* mem;
         int order = 0, pages = 1;
 
-        buf = kmalloc(sizeof(struct ft_buffer), GFP_KERNEL);
+        buf = kmalloc(sizeof(*buf), GFP_KERNEL);
         if (!buf)
                 return NULL;
 
@@ -65,7 +65,7 @@ struct ftdev_event {
 
 static int activate(struct ftdev_event** chain, int id)
 {
-        struct ftdev_event* ev = kmalloc(sizeof(struct ftdev_event), GFP_KERNEL);
+        struct ftdev_event* ev = kmalloc(sizeof(*ev), GFP_KERNEL);
         if (ev) {
                 printk(KERN_INFO
                        "Enabling feather-trace event %d.\n", (int) id);
@@ -110,7 +110,7 @@ static int ftdev_open(struct inode *in, struct file *filp)
         }
         if (ftdev->can_open && (err = ftdev->can_open(ftdev, buf_idx)))
                 goto out;
-                
+
         ftdm = ftdev->minor + buf_idx;
         filp->private_data = ftdm;
 
@@ -258,15 +258,15 @@ static ssize_t ftdev_write(struct file *filp, const char __user *from,
         cmd_t cmd;
         cmd_t id;
 
-        if (len % sizeof(cmd_t) || len < 2 * sizeof(cmd_t))
+        if (len % sizeof(cmd) || len < 2 * sizeof(cmd))
                 goto out;
 
-        if (copy_from_user(&cmd, from, sizeof(cmd_t))) {
+        if (copy_from_user(&cmd, from, sizeof(cmd))) {
                 err = -EFAULT;
                 goto out;
         }
-        len  -= sizeof(cmd_t);
-        from += sizeof(cmd_t);
+        len  -= sizeof(cmd);
+        from += sizeof(cmd);
 
         if (cmd != FTDEV_ENABLE_CMD && cmd != FTDEV_DISABLE_CMD)
                 goto out;
@@ -276,22 +276,22 @@ static ssize_t ftdev_write(struct file *filp, const char __user *from,
                 goto out;
         }
 
-        err = sizeof(cmd_t);
+        err = sizeof(cmd);
         while (len) {
-                if (copy_from_user(&id, from, sizeof(cmd_t))) {
+                if (copy_from_user(&id, from, sizeof(cmd))) {
                         err = -EFAULT;
                         goto out_unlock;
                 }
                 /* FIXME: check id against list of acceptable events */
-                len  -= sizeof(cmd_t);
-                from += sizeof(cmd_t);
+                len  -= sizeof(cmd);
+                from += sizeof(cmd);
                 if (cmd == FTDEV_DISABLE_CMD)
                         deactivate(&ftdm->events, id);
                 else if (activate(&ftdm->events, id) != 0) {
                         err = -ENOMEM;
                         goto out_unlock;
                 }
-                err += sizeof(cmd_t);
+                err += sizeof(cmd);
         }
 
 out_unlock:
diff --git a/litmus/litmus.c b/litmus/litmus.c
index f9734c1c2e..911826a386 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -247,7 +247,7 @@ static void __scheduler_signal(struct task_struct *t, unsigned int signo,
 {
         struct sched_sig* sig;
 
-        sig = kmalloc(GFP_ATOMIC, sizeof(struct sched_sig));
+        sig = kmalloc(GFP_ATOMIC, sizeof(*sig));
         if (!sig) {
                 TRACE_TASK(t, "dropping signal: %u\n", t);
                 return;
@@ -479,6 +479,23 @@ asmlinkage long sys_exit_np(void)
 #endif /* CONFIG_NP_SECTION */
 
 
+/* sys_null_call() is only used for determining raw system call
+ * overheads (kernel entry, kernel exit). It has no useful side effects.
+ * If ts is non-NULL, then the current Feather-Trace time is recorded. 
+ */
+asmlinkage long sys_null_call(cycles_t __user *ts)
+{
+        long ret = 0; 
+        cycles_t now;
+
+        if (ts) {
+                now = get_cycles();
+                ret = put_user(now, ts);
+        }
+
+        return ret;
+}
+
 /* p is a real-time task. Re-init its state as a best-effort task. */
 static void reinit_litmus_state(struct task_struct* p, int restore)
 {
@@ -500,7 +517,7 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
 //      __setscheduler(p, p->rt_param.old_policy, p->rt_param.old_prio);
 
         /* Cleanup everything else. */
-        memset(&p->rt_param, 0, sizeof(struct rt_task));
+        memset(&p->rt_param, 0, sizeof(user_config));
 
         /* Restore preserved fields. */
         if (restore) {
@@ -595,7 +612,7 @@ int switch_sched_plugin(struct sched_plugin* plugin)
                         goto out;
                 ret = plugin->activate_plugin();
                 if (0 != ret) {
-                        printk(KERN_INFO "Can't activate %s (%d).\n", 
+                        printk(KERN_INFO "Can't activate %s (%d).\n",
                                plugin->plugin_name, ret);
                         plugin = &linux_sched_plugin;
                 }
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index be4ef5ea6a..d0a243fc6f 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -80,7 +80,7 @@ static struct release_heap* get_release_heap(rt_domain_t *rt, lt_t release_time)
         if (!heap) {
                 /* must create new node */
                 /* FIXME: use a kmemcache_t */
-                rh = kmalloc(sizeof(struct release_heap), GFP_ATOMIC);
+                rh = kmalloc(sizeof(*rh), GFP_ATOMIC);
                 if (unlikely(!rh))
                         /* Should be handled somehow.
                          * For now, let's just hope there is
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 6c32e1c06c..ee5e5c8e07 100755
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -661,7 +661,7 @@ static void cedf_domain_init(int first_cpu, int last_cpu)
         int cpu;
 
         /* Create new domain for this cluster. */
-        cedf_domain_t *new_cedf_domain = kmalloc(sizeof(cedf_domain_t),
+        cedf_domain_t *new_cedf_domain = kmalloc(sizeof(*new_cedf_domain),
                                                      GFP_KERNEL);
 
         /* Initialize cluster domain. */
diff --git a/litmus/sched_pfair.c b/litmus/sched_pfair.c
index d0c06e03a7..053cd27ae4 100755
--- a/litmus/sched_pfair.c
+++ b/litmus/sched_pfair.c
@@ -434,7 +434,7 @@ static void schedule_next_quantum(quanta_t time)
 
         for (cpu = 0; cpu < NR_CPUS; cpu++)
                 if (pstate[cpu]->linked)
-                        PTRACE_TASK(pstate[cpu]->linked, 
+                        PTRACE_TASK(pstate[cpu]->linked,
                                     " linked on %d.\n", cpu);
                 else
                         PTRACE("(null) linked on %d.\n", cpu);
@@ -511,7 +511,7 @@ static void pfair_tick(struct task_struct* t)
                 cur  = current_quantum(state);
                 PTRACE("q %lu at %llu\n", cur, litmus_clock());
 
-                /* Attempt to advance time. First CPU to get here 
+                /* Attempt to advance time. First CPU to get here
                  * will prepare the next quantum.
                  */
                 time = cmpxchg(&pfair_time,
@@ -551,7 +551,7 @@ static void pfair_tick(struct task_struct* t)
 
         if (state->local != current
             && (is_realtime(current) || is_present(state->local)))
-            set_tsk_need_resched(current);          
+            set_tsk_need_resched(current);
 }
 
 static int safe_to_schedule(struct task_struct* t, int cpu)
@@ -802,7 +802,7 @@ static long pfair_admit_task(struct task_struct* t)
                 period = 1;
         }
 
-        param = kmalloc(sizeof(struct pfair_param) +
+        param = kmalloc(sizeof(*param) +
                         quanta * sizeof(struct subtask), GFP_ATOMIC);
 
         if (!param)
diff --git a/litmus/sched_task_trace.c b/litmus/sched_task_trace.c
index 4b546a86d6..913d999dfe 100644
--- a/litmus/sched_task_trace.c
+++ b/litmus/sched_task_trace.c
@@ -148,7 +148,7 @@ feather_callback void do_sched_trace_task_switch_away(unsigned long id, unsigned
         }
 }
 
-feather_callback void do_sched_trace_task_completion(unsigned long id, unsigned long _task, 
+feather_callback void do_sched_trace_task_completion(unsigned long id, unsigned long _task,
                                                      unsigned long forced)
 {
         struct task_struct *t = (struct task_struct*) _task;
diff --git a/litmus/srp.c b/litmus/srp.c
index 6e670f9138..71639b9916 100644
--- a/litmus/srp.c
+++ b/litmus/srp.c
@@ -78,7 +78,7 @@ struct srp_semaphore {
         int cpu; /* cpu associated with this "semaphore" and resource */
 };
 
-#define ceiling2sem(c) container_of(c, struct srp_semaphore, ceiling) 
+#define ceiling2sem(c) container_of(c, struct srp_semaphore, ceiling)
 
 static int srp_exceeds_ceiling(struct task_struct* first,
                                struct srp* srp)
@@ -86,7 +86,7 @@ static int srp_exceeds_ceiling(struct task_struct* first,
         return list_empty(&srp->ceiling) ||
                get_rt_period(first) < system_ceiling(srp)->period ||
                (get_rt_period(first) == system_ceiling(srp)->period &&
-                first->pid < system_ceiling(srp)->pid) || 
+                first->pid < system_ceiling(srp)->pid) ||
                 ceiling2sem(system_ceiling(srp))->owner == first;
 }
 
@@ -176,7 +176,7 @@ static void do_srp_down(struct srp_semaphore* sem)
 }
 
 static void do_srp_up(struct srp_semaphore* sem)
-{       
+{
         /* Determine new system priority ceiling for this CPU. */
         WARN_ON(!in_list(&sem->ceiling.list));
         if (in_list(&sem->ceiling.list))
@@ -296,7 +296,7 @@ void srp_ceiling_block(void)
                         do_ceiling_block(tsk);
                 TRACE_CUR("finally exceeds system ceiling.\n");
         } else
-                TRACE_CUR("is not priority ceiling blocked\n"); 
+                TRACE_CUR("is not priority ceiling blocked\n");
         preempt_enable();
 }
 
diff --git a/litmus/sync.c b/litmus/sync.c
index 8b0ebea49a..9c9941fc27 100644
--- a/litmus/sync.c
+++ b/litmus/sync.c
@@ -44,7 +44,7 @@ static long do_release_ts(lt_t start)
 
         spin_lock_irqsave(&ts_release.wait.lock, flags);
         TRACE("<<<<<< synchronous task system release >>>>>>\n");
-        
+
         sched_trace_sys_release(&start);
         list_for_each(pos, &ts_release.wait.task_list) {
                 t = (struct task_struct*) list_entry(pos,
@@ -82,7 +82,7 @@ asmlinkage long sys_release_ts(lt_t __user *__delay)
 
         /* FIXME: check capabilities... */
 
-        ret = copy_from_user(&delay, __delay, sizeof(lt_t));
+        ret = copy_from_user(&delay, __delay, sizeof(delay));
         if (ret == 0)
                 ret = do_release_ts(litmus_clock() + delay);