Add TRACE() debug tracing support

This patch adds the infrastructure for the TRACE() debug macro.
Add hrtimer_start_on() support

This patch adds hrtimer_start_on(), which allows arming timers on
remote CPUs.  This is needed to avoided timer interrupts on "shielded"
CPUs and is also useful for implementing semi-partitioned schedulers.
Extend task_struct with rt_param

This patch adds the PCB extensions required for LITMUS^RT.
Introduce main LITMUS^RT header

This patch adds a basic litmus/litmus.h, which is required for basic
LITMUS^RT infrastructure to compile.
Feather-Trace: use proper definition of is_realtime()

Remove dummy implementation of is_realtime() in trace.c.
Feather-Trace: write interrupt counts to control page

This patch exports the interrupt counter to userspace via the control
page.
Add schedule tracing support

This patch introduces the sched_trace infrastructure, which in
principle allows tracing the generated schedule.  However, this patch
does not yet integrate the callbacks with the kernel.
Add tracepoint support

This patch integrates LITMUS^RT's sched_trace_XXX() macros with
Linux's notion of tracepoints. This is useful to visualize schedules
in kernel shark and similar tools. Historically, LITMUS^RT's
sched_trace predates Linux's tracepoint infrastructure.
Add object descriptor table to Linux's task_struct

This table is similar to a file descriptor table. It keeps track of
which "objects" (locks) a real-time task holds a handle to.
Export num_cache_leaves in asm/processor.h

This is required to make litmus/affinity.c compile.
Add LITMUS^RT core implementation

This patch adds the core of LITMUS^RT:

 - library functionality (heaps, rt_domain, prioritization, etc.)
 - budget enforcement logic
 - job management
 - system call backends
 - virtual devices (control page, etc.)
 - scheduler plugin API (and dummy plugin)

This code compiles, but is not yet integrated with the rest of Linux.
Add LITMUS^RT syscalls for ARM
Add LITMUS^RT syscalls for x86
Move trace point definition to litmus/litmus.c

If !CONFIG_SCHED_TASK_TRACE, but CONFIG_SCHED_LITMUS_TRACEPOINT, then
we still need to define the tracepoint structures.

This patch should be integrated with the earlier sched_task_trace.c
patches during one of the next major rebasing efforts.
Record LITMUS^RT timestamp in ftrace records

Patch updates ftrace.h to record a litmus_clock() time stamp
in ftrace records.
Integrate preemption state machine with Linux scheduler

Track when a processor is going to schedule "soon".
Call sched_state_task_picked() from pick_next_task_stop()

Otherwise, the scheduler state machine becomes confused (and goes into
a rescheduling loop) when stop-machine is triggered.
Hook into fork(), exec(), and exit()

Allow LITMUS^RT to do some work when a process is created or
terminated.
Augment rt_task() with is_realtime()

Whenever the kernel checks for rt_task() to avoid delaying real-time
tasks, we want it to also not delay LITMUS^RT tasks.  Hence, most
calls to rt_task() should be matched by an equivalent call to
is_realtime().

Notably, this affects the implementations of select() and nanosleep(),
which use timer_slack_ns when setting up timers for non-real-time
tasks.
Hookup sched_trace_XXX() tracing in Linux scheduler

This patch adds context switch tracing to the main Linux scheduler.