Merge branch 'wip-mc' of ssh://cvs.cs.unc.edu/cvs/proj/litmus/repo/litmus2010 into wip-mc

Conflicts:
	include/litmus/trace.h

7 files changed, 129 insertions, 46 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index 2112eecd1dc8..4322d59c0e8f 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -129,6 +129,16 @@ void srp_ceiling_block(void);
 
 #define bheap2task(hn) ((struct task_struct*) hn->value)
 
+static inline struct control_page* get_control_page(struct task_struct *t)
+{
+        return tsk_rt(t)->ctrl_page;
+}
+
+static inline int has_control_page(struct task_struct* t)
+{
+        return tsk_rt(t)->ctrl_page != NULL;
+}
+
 #ifdef CONFIG_NP_SECTION
 
 static inline int is_kernel_np(struct task_struct *t)
@@ -244,4 +254,8 @@ static inline quanta_t time2quanta(lt_t time, enum round round)
 /* By how much is cpu staggered behind CPU 0? */
 u64 cpu_stagger_offset(int cpu);
 
+#define TS_SYSCALL_IN_START                                             \
+        if (has_control_page(current))                                  \
+                __TS_SYSCALL_IN_START(&get_control_page(current)->ts_syscall_start);
+
 #endif
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index e6288e8807f0..221edad83d77 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -63,6 +63,9 @@ struct control_page {
          * its non-preemptive section? */
         int delayed_preemption;
 
+        /* locking overhead tracing: time stamp prior to system call */
+        uint64_t ts_syscall_start; /* Feather-Trace cycles */
+
         /* to be extended */
 };
 
diff --git a/include/litmus/trace.h b/include/litmus/trace.h
index 95e1ee647a8a..d6829c416912 100644
--- a/include/litmus/trace.h
+++ b/include/litmus/trace.h
@@ -28,7 +28,8 @@ feather_callback void save_timestamp(unsigned long event);
 feather_callback void save_timestamp_def(unsigned long event, unsigned long type);
 feather_callback void save_timestamp_task(unsigned long event, unsigned long t_ptr);
 feather_callback void save_timestamp_cpu(unsigned long event, unsigned long cpu);
-
+feather_callback void save_task_latency(unsigned long event, unsigned long when_ptr);
+feather_callback void save_timestamp_time(unsigned long event, unsigned long time_ptr);
 
 #define TIMESTAMP(id) ft_event0(id, save_timestamp)
 
@@ -40,6 +41,14 @@ feather_callback void save_timestamp_cpu(unsigned long event, unsigned long cpu)
 #define CTIMESTAMP(id, cpu) \
         ft_event1(id, save_timestamp_cpu, (unsigned long) cpu)
 
+#define LTIMESTAMP(id, task) \
+        ft_event1(id, save_task_latency, (unsigned long) task)
+
+#define TIMESTAMP_TIME(id, time_ptr) \
+        ft_event1(id, save_timestamp_time, (unsigned long) time_ptr)
+
+#define TIMESTAMP_PID(id) ft_event0(id, save_timestamp_pid)
+
 #else /* !CONFIG_SCHED_OVERHEAD_TRACE */
 
 #define TIMESTAMP(id)        /* no tracing */
@@ -50,6 +59,12 @@ feather_callback void save_timestamp_cpu(unsigned long event, unsigned long cpu)
 
 #define CTIMESTAMP(id, cpu)  /* no tracing */
 
+#define LTIMESTAMP(id, when_ptr) /* no tracing */
+
+#define TIMESTAMP_TIME(id, time_ptr) /* no tracing */
+
+#define TIMESTAMP_PID(id) /* no tracing */
+
 #endif
 
 
@@ -61,6 +76,21 @@ feather_callback void save_timestamp_cpu(unsigned long event, unsigned long cpu)
  * always the next number after the start time event id.
  */
 
+#define __TS_SYSCALL_IN_START(p)        TIMESTAMP_TIME(10, p)
+#define TS_SYSCALL_IN_END               TIMESTAMP_PID(11)
+
+#define TS_SYSCALL_OUT_START            TIMESTAMP_PID(20)
+#define TS_SYSCALL_OUT_END              TIMESTAMP_PID(21)
+
+#define TS_LOCK_START                   TIMESTAMP_PID(30)
+#define TS_LOCK_END                     TIMESTAMP_PID(31)
+
+#define TS_LOCK_SUSPEND                 TIMESTAMP_PID(38)
+#define TS_LOCK_RESUME                  TIMESTAMP_PID(39)
+
+#define TS_UNLOCK_START                 TIMESTAMP_PID(40)
+#define TS_UNLOCK_END                   TIMESTAMP_PID(41)
+
 #define TS_SCHED_START                  DTIMESTAMP(100, TSK_UNKNOWN) /* we only
                                                                       * care
                                                                       * about
@@ -91,12 +121,9 @@ feather_callback void save_timestamp_cpu(unsigned long event, unsigned long cpu)
 #define TS_EXIT_NP_START                TIMESTAMP(150)
 #define TS_EXIT_NP_END                  TIMESTAMP(151)
 
-#define TS_LOCK_START                   TIMESTAMP(170)
-#define TS_LOCK_END                     TIMESTAMP(171)
-#define TS_UNLOCK_START                 TIMESTAMP(172)
-#define TS_UNLOCK_END                   TIMESTAMP(173)
-
 #define TS_SEND_RESCHED_START(c)        CTIMESTAMP(190, c)
 #define TS_SEND_RESCHED_END             DTIMESTAMP(191, TSK_UNKNOWN)
 
+#define TS_RELEASE_LATENCY(when)        LTIMESTAMP(208, &(when))
+
 #endif /* !_SYS_TRACE_H_ */
diff --git a/litmus/ftdev.c b/litmus/ftdev.c
index 4a4b2e3e56c2..e282f8a9c067 100644
--- a/litmus/ftdev.c
+++ b/litmus/ftdev.c
@@ -229,13 +229,20 @@ static ssize_t ftdev_read(struct file *filp,
                          * here with copied data because that data would get
                          * lost if the task is interrupted (e.g., killed).
                          */
+                        mutex_unlock(&ftdm->lock);
                         set_current_state(TASK_INTERRUPTIBLE);
+
                         schedule_timeout(50);
+
                         if (signal_pending(current)) {
                                 if (err == 0)
                                         /* nothing read yet, signal problem */
                                         err = -ERESTARTSYS;
-                                break;
+                                goto out;
+                        }
+                        if (mutex_lock_interruptible(&ftdm->lock)) {
+                                err = -ERESTARTSYS;
+                                goto out;
                         }
                 } else if (copied < 0) {
                         /* page fault */
@@ -250,64 +257,47 @@ out:
         return err;
 }
 
-typedef uint32_t cmd_t;
-
-static ssize_t ftdev_write(struct file *filp, const char __user *from,
-                           size_t len, loff_t *f_pos)
+static long ftdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
+        long err = -ENOIOCTLCMD;
         struct ftdev_minor* ftdm = filp->private_data;
-        ssize_t err = -EINVAL;
-        cmd_t cmd;
-        cmd_t id;
-
-        if (len % sizeof(cmd) || len < 2 * sizeof(cmd))
-                goto out;
-
-        if (copy_from_user(&cmd, from, sizeof(cmd))) {
-                err = -EFAULT;
-                goto out;
-        }
-        len  -= sizeof(cmd);
-        from += sizeof(cmd);
-
-        if (cmd != FTDEV_ENABLE_CMD && cmd != FTDEV_DISABLE_CMD)
-                goto out;
 
         if (mutex_lock_interruptible(&ftdm->lock)) {
                 err = -ERESTARTSYS;
                 goto out;
         }
 
-        err = sizeof(cmd);
-        while (len) {
-                if (copy_from_user(&id, from, sizeof(cmd))) {
-                        err = -EFAULT;
-                        goto out_unlock;
-                }
-                /* FIXME: check id against list of acceptable events */
-                len  -= sizeof(cmd);
-                from += sizeof(cmd);
-                if (cmd == FTDEV_DISABLE_CMD)
-                        deactivate(&ftdm->events, id);
-                else if (activate(&ftdm->events, id) != 0) {
+        /* FIXME: check id against list of acceptable events */
+
+        switch (cmd) {
+        case  FTDEV_ENABLE_CMD:
+                if (activate(&ftdm->events, arg))
                         err = -ENOMEM;
-                        goto out_unlock;
-                }
-                err += sizeof(cmd);
-        }
+                else
+                        err = 0;
+                break;
+
+        case FTDEV_DISABLE_CMD:
+                deactivate(&ftdm->events, arg);
+                err = 0;
+                break;
+
+        default:
+                printk(KERN_DEBUG "ftdev: strange ioctl (%u, %lu)\n", cmd, arg);
+        };
 
-out_unlock:
         mutex_unlock(&ftdm->lock);
 out:
         return err;
 }
 
+
 struct file_operations ftdev_fops = {
         .owner   = THIS_MODULE,
         .open    = ftdev_open,
         .release = ftdev_release,
-        .write   = ftdev_write,
         .read    = ftdev_read,
+        .unlocked_ioctl = ftdev_ioctl,
 };
 
 int ftdev_init( struct ftdev* ftdev, struct module* owner,
diff --git a/litmus/locking.c b/litmus/locking.c
index 728b56835cf7..bc4150804250 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -1,3 +1,5 @@
+#include <linux/sched.h>
+#include <litmus/litmus.h>
 #include <litmus/fdso.h>
 
 #ifdef CONFIG_LITMUS_LOCKING
@@ -69,6 +71,10 @@ asmlinkage long sys_litmus_lock(int lock_od)
         struct od_table_entry* entry;
         struct litmus_lock* l;
 
+        TS_SYSCALL_IN_START;
+
+        TS_SYSCALL_IN_END;
+
         TS_LOCK_START;
 
         entry = get_entry_for_od(lock_od);
@@ -80,7 +86,9 @@ asmlinkage long sys_litmus_lock(int lock_od)
 
         /* Note: task my have been suspended or preempted in between!  Take
          * this into account when computing overheads. */
-        TS_UNLOCK_END;
+        TS_LOCK_END;
+
+        TS_SYSCALL_OUT_START;
 
         return err;
 }
@@ -91,6 +99,10 @@ asmlinkage long sys_litmus_unlock(int lock_od)
         struct od_table_entry* entry;
         struct litmus_lock* l;
 
+        TS_SYSCALL_IN_START;
+
+        TS_SYSCALL_IN_END;
+
         TS_UNLOCK_START;
 
         entry = get_entry_for_od(lock_od);
@@ -104,6 +116,8 @@ asmlinkage long sys_litmus_unlock(int lock_od)
          * account when computing overheads. */
         TS_UNLOCK_END;
 
+        TS_SYSCALL_OUT_START;
+
         return err;
 }
 
diff --git a/litmus/sched_litmus.c b/litmus/sched_litmus.c
index e6952896dc4b..0687be0c8a78 100644
--- a/litmus/sched_litmus.c
+++ b/litmus/sched_litmus.c
@@ -194,6 +194,9 @@ static void dequeue_task_litmus(struct rq *rq, struct task_struct *p,
 
 static void yield_task_litmus(struct rq *rq)
 {
+        TS_SYSCALL_IN_START;
+
+        TS_SYSCALL_OUT_END;
         BUG_ON(rq->curr != current);
         /* sched_yield() is called to trigger delayed preemptions.
          * Thus, mark the current task as needing to be rescheduled.
@@ -202,6 +205,8 @@ static void yield_task_litmus(struct rq *rq)
          */
         clear_exit_np(current);
         litmus_reschedule_local();
+
+        TS_SYSCALL_OUT_START;
 }
 
 /* Plugins are responsible for this.
diff --git a/litmus/trace.c b/litmus/trace.c
index e7ea1c2ab3e4..49f8246cda50 100644
--- a/litmus/trace.c
+++ b/litmus/trace.c
@@ -37,6 +37,36 @@ static inline void __save_timestamp(unsigned long event,
         __save_timestamp_cpu(event, type, raw_smp_processor_id());
 }
 
+/* hack: fake timestamp to user-reported time, and record parts of the PID */
+feather_callback void save_timestamp_time(unsigned long event, unsigned long ptr)
+{
+        uint64_t* time = (uint64_t*) ptr;
+        unsigned int seq_no;
+        struct timestamp *ts;
+        seq_no = fetch_and_inc((int *) &ts_seq_no);
+        if (ft_buffer_start_write(trace_ts_buf, (void**)  &ts)) {
+                ts->event     = event;
+                ts->timestamp = *time;
+                ts->seq_no    = seq_no;
+                /* type takes lowest byte of PID */
+                ts->task_type = (uint8_t) current->pid;
+                /* cpu takes second-lowest byte of PID*/
+                ts->cpu       = (uint8_t) (current->pid >> 8);
+
+                ft_buffer_finish_write(trace_ts_buf, ts);
+        }
+}
+
+feather_callback void save_timestamp_pid(unsigned long event)
+{
+        /* Abuse existing fields to partially export PID. */
+        __save_timestamp_cpu(event,
+                             /* type takes lowest byte of PID */
+                             (uint8_t) current->pid,
+                             /* cpu takes second-lowest byte of PID*/
+                             (uint8_t) (current->pid >> 8));
+}
+
 feather_callback void save_timestamp(unsigned long event)
 {
         __save_timestamp(event, TSK_UNKNOWN);