Feather-Trace: add LITMUS^RT overhead tracing infrastructure

This patch adds the main infrastructure for tracing overheads in
LITMUS^RT.  It does not yet introduce any tracepoints into the kernel.
Integrate ft_irq_fired() with Linux

This patch hooks up Feather-Trace's ft_irq_fired() handler with
Linux's interrupt handling infrastructure.
Add SCHED, SCHED2, TICK, and CXS overhead tracepoints

This patch integrates the overhead tracepoints into the Linux
scheduler that are compatible with plain vanilla Linux (i.e., not
specific to LITMUS^RT plugins).  This can be used to measure the
overheads of an otherwise unmodified kernel.
Export x86 cache topology

This patch adds get_shared_cpu_map(), which allows the caller to infer
which CPUs share a cache at a given level.
Add object list to inodes

This patch adds a list of arbitrary objects to inodes.

This is used by Linux's locking API to attach lock objects to inodes
(which represent namespaces in Linux's locking API).
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.