Merge branch 'wip-nested-locking' into tegra-nested-lockingwip-nested-locking

Conflicts:
	Makefile
	include/linux/fs.h

7 files changed, 185 insertions, 0 deletions

diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile
index 82f2912155a..c84954ad12f 100644
--- a/arch/x86/kernel/Makefile
+++ b/arch/x86/kernel/Makefile
@@ -99,6 +99,8 @@ obj-$(CONFIG_X86_CHECK_BIOS_CORRUPTION) += check.o
 obj-$(CONFIG_SWIOTLB)                   += pci-swiotlb.o
 obj-$(CONFIG_OF)                        += devicetree.o
 
+obj-$(CONFIG_FEATHER_TRACE)     += ft_event.o
+
 ###
 # 64 bit specific files
 ifeq ($(CONFIG_X86_64),y)
diff --git a/arch/x86/kernel/cpu/intel_cacheinfo.c b/arch/x86/kernel/cpu/intel_cacheinfo.c
index c105c533ed9..0bf12644aa7 100644
--- a/arch/x86/kernel/cpu/intel_cacheinfo.c
+++ b/arch/x86/kernel/cpu/intel_cacheinfo.c
@@ -747,6 +747,23 @@ unsigned int __cpuinit init_intel_cacheinfo(struct cpuinfo_x86 *c)
 static DEFINE_PER_CPU(struct _cpuid4_info *, ici_cpuid4_info);
 #define CPUID4_INFO_IDX(x, y)   (&((per_cpu(ici_cpuid4_info, x))[y]))
 
+/* returns CPUs that share the index cache with cpu */
+int get_shared_cpu_map(cpumask_var_t mask, unsigned int cpu, int index)
+{
+        int ret = 0;
+        struct _cpuid4_info *this_leaf;
+
+        if (index >= num_cache_leaves) {
+                index = num_cache_leaves - 1;
+                ret = index;
+        }
+
+        this_leaf = CPUID4_INFO_IDX(cpu,index);
+        cpumask_copy(mask, to_cpumask(this_leaf->shared_cpu_map));
+
+        return ret;
+}
+
 #ifdef CONFIG_SMP
 static void __cpuinit cache_shared_cpu_map_setup(unsigned int cpu, int index)
 {
diff --git a/arch/x86/kernel/entry_64.S b/arch/x86/kernel/entry_64.S
index 6419bb05ecd..e5d2d3fa7a0 100644
--- a/arch/x86/kernel/entry_64.S
+++ b/arch/x86/kernel/entry_64.S
@@ -993,6 +993,8 @@ apicinterrupt CALL_FUNCTION_VECTOR \
         call_function_interrupt smp_call_function_interrupt
 apicinterrupt RESCHEDULE_VECTOR \
         reschedule_interrupt smp_reschedule_interrupt
+apicinterrupt PULL_TIMERS_VECTOR \
+        pull_timers_interrupt smp_pull_timers_interrupt
 #endif
 
 apicinterrupt ERROR_APIC_VECTOR \
diff --git a/arch/x86/kernel/ft_event.c b/arch/x86/kernel/ft_event.c
new file mode 100644
index 00000000000..37cc3325271
--- /dev/null
+++ b/arch/x86/kernel/ft_event.c
@@ -0,0 +1,118 @@
+#include <linux/types.h>
+
+#include <litmus/feather_trace.h>
+
+/* the feather trace management functions assume
+ * exclusive access to the event table
+ */
+
+#ifndef CONFIG_DEBUG_RODATA
+
+#define BYTE_JUMP      0xeb
+#define BYTE_JUMP_LEN  0x02
+
+/* for each event, there is an entry in the event table */
+struct trace_event {
+        long    id;
+        long    count;
+        long    start_addr;
+        long    end_addr;
+};
+
+extern struct trace_event  __start___event_table[];
+extern struct trace_event  __stop___event_table[];
+
+/* Workaround: if no events are defined, then the event_table section does not
+ * exist and the above references cause linker errors. This could probably be
+ * fixed by adjusting the linker script, but it is easier to maintain for us if
+ * we simply create a dummy symbol in the event table section.
+ */
+int __event_table_dummy[0] __attribute__ ((section("__event_table")));
+
+int ft_enable_event(unsigned long id)
+{
+        struct trace_event* te = __start___event_table;
+        int count = 0;
+        char* delta;
+        unsigned char* instr;
+
+        while (te < __stop___event_table) {
+                if (te->id == id && ++te->count == 1) {
+                        instr  = (unsigned char*) te->start_addr;
+                        /* make sure we don't clobber something wrong */
+                        if (*instr == BYTE_JUMP) {
+                                delta  = (((unsigned char*) te->start_addr) + 1);
+                                *delta = 0;
+                        }
+                }
+                if (te->id == id)
+                        count++;
+                te++;
+        }
+
+        printk(KERN_DEBUG "ft_enable_event: enabled %d events\n", count);
+        return count;
+}
+
+int ft_disable_event(unsigned long id)
+{
+        struct trace_event* te = __start___event_table;
+        int count = 0;
+        char* delta;
+        unsigned char* instr;
+
+        while (te < __stop___event_table) {
+                if (te->id == id && --te->count == 0) {
+                        instr  = (unsigned char*) te->start_addr;
+                        if (*instr == BYTE_JUMP) {
+                                delta  = (((unsigned char*) te->start_addr) + 1);
+                                *delta = te->end_addr - te->start_addr -
+                                        BYTE_JUMP_LEN;
+                        }
+                }
+                if (te->id == id)
+                        count++;
+                te++;
+        }
+
+        printk(KERN_DEBUG "ft_disable_event: disabled %d events\n", count);
+        return count;
+}
+
+int ft_disable_all_events(void)
+{
+        struct trace_event* te = __start___event_table;
+        int count = 0;
+        char* delta;
+        unsigned char* instr;
+
+        while (te < __stop___event_table) {
+                if (te->count) {
+                        instr  = (unsigned char*) te->start_addr;
+                        if (*instr == BYTE_JUMP) {
+                                delta  = (((unsigned char*) te->start_addr)
+                                          + 1);
+                                *delta = te->end_addr - te->start_addr -
+                                        BYTE_JUMP_LEN;
+                                te->count = 0;
+                                count++;
+                        }
+                }
+                te++;
+        }
+        return count;
+}
+
+int ft_is_event_enabled(unsigned long id)
+{
+        struct trace_event* te = __start___event_table;
+
+        while (te < __stop___event_table) {
+                if (te->id == id)
+                        return te->count;
+                te++;
+        }
+        return 0;
+}
+
+#endif
diff --git a/arch/x86/kernel/irqinit.c b/arch/x86/kernel/irqinit.c
index b3300e6bace..f3a90e926f5 100644
--- a/arch/x86/kernel/irqinit.c
+++ b/arch/x86/kernel/irqinit.c
@@ -252,6 +252,9 @@ static void __init smp_intr_init(void)
         alloc_intr_gate(CALL_FUNCTION_SINGLE_VECTOR,
                         call_function_single_interrupt);
 
+        /* IPI for hrtimer pulling on remote cpus */
+        alloc_intr_gate(PULL_TIMERS_VECTOR, pull_timers_interrupt);
+
         /* Low priority IPI to cleanup after moving an irq */
         set_intr_gate(IRQ_MOVE_CLEANUP_VECTOR, irq_move_cleanup_interrupt);
         set_bit(IRQ_MOVE_CLEANUP_VECTOR, used_vectors);
diff --git a/arch/x86/kernel/smp.c b/arch/x86/kernel/smp.c
index 013e7eba83b..7539d84628f 100644
--- a/arch/x86/kernel/smp.c
+++ b/arch/x86/kernel/smp.c
@@ -23,6 +23,9 @@
 #include <linux/cpu.h>
 #include <linux/gfp.h>
 
+#include <litmus/preempt.h>
+#include <litmus/debug_trace.h>
+
 #include <asm/mtrr.h>
 #include <asm/tlbflush.h>
 #include <asm/mmu_context.h>
@@ -147,6 +150,16 @@ void native_send_call_func_ipi(const struct cpumask *mask)
         free_cpumask_var(allbutself);
 }
 
+/* trigger timers on remote cpu */
+void smp_send_pull_timers(int cpu)
+{
+        if (unlikely(cpu_is_offline(cpu))) {
+                WARN_ON(1);
+                return;
+        }
+        apic->send_IPI_mask(cpumask_of(cpu), PULL_TIMERS_VECTOR);
+}
+
 /*
  * this function calls the 'stop' function on all other CPUs in the system.
  */
@@ -204,6 +217,11 @@ void smp_reschedule_interrupt(struct pt_regs *regs)
         /*
          * KVM uses this interrupt to force a cpu out of guest mode
          */
+
+        /* LITMUS^RT: this IPI might need to trigger the sched state machine.
+         * Starting from 3.0 schedule_ipi() actually does something.  This may
+         * increase IPI latencies compared with previous versions. */
+        sched_state_ipi();
 }
 
 void smp_call_function_interrupt(struct pt_regs *regs)
@@ -224,6 +242,17 @@ void smp_call_function_single_interrupt(struct pt_regs *regs)
         irq_exit();
 }
 
+extern void hrtimer_pull(void);
+
+void smp_pull_timers_interrupt(struct pt_regs *regs)
+{
+        ack_APIC_irq();
+        irq_enter();
+        TRACE("pull timer interrupt\n");
+        hrtimer_pull();
+        irq_exit();
+}
+
 struct smp_ops smp_ops = {
         .smp_prepare_boot_cpu   = native_smp_prepare_boot_cpu,
         .smp_prepare_cpus       = native_smp_prepare_cpus,
diff --git a/arch/x86/kernel/syscall_table_32.S b/arch/x86/kernel/syscall_table_32.S
index bc19be332bc..058cac30916 100644
--- a/arch/x86/kernel/syscall_table_32.S
+++ b/arch/x86/kernel/syscall_table_32.S
@@ -346,3 +346,17 @@ ENTRY(sys_call_table)
         .long sys_syncfs
         .long sys_sendmmsg              /* 345 */
         .long sys_setns
+        .long sys_set_rt_task_param     /* LITMUS^RT 347 */
+        .long sys_get_rt_task_param
+        .long sys_complete_job
+        .long sys_od_open
+        .long sys_od_close
+        .long sys_litmus_lock           /* +5 */
+        .long sys_litmus_unlock
+        .long sys_query_job_no
+        .long sys_wait_for_job_release
+        .long sys_wait_for_ts_release
+        .long sys_release_ts            /* +10 */
+        .long sys_null_call
+    .long sys_dynamic_group_lock
+    .long sys_dynamic_group_unlock