Fix tracepoint compilation error

Linux tracepoints for real time tasks were causing
compilation errors. For the tracing data structures to be
properly created, it's necessary to add a #define.
PCP: allow NULL config parameter

When the config parameter is NULL, just default to the local CPU,
which is what we want in 99% of the cases anyway.
Disallow nesting of LITMUS^RT locks

Nesting of locks was never supported in LITMUS^RT since
the required analysis does not exist anyway. That is, as
defined in the literature, the protocols implemented
in LITMUS^RT have not been studied in conjunction with
nested critical sections.

In LITMUS^RT, attempting to nest locks could lead to
silent or not-so-silent bugs. This patch makes this
restriction explicit and returns EBUSY when a process
attempts to nest resources.

This is enforced on a protocol-by-protocol basis,
which means that adding protocols with support for
nesting in future versions is not affected by this
change.

Exception: PCP and SRP resources may be nested,
but not within global critical sections.
uncachedev: mmap memory that is not cached by CPUs

This patch creates a new character device, uncachedev.
Pages of RAM allocated by this device are not cached by
CPUs.

Uses for such pages:
1) Determining *very* pessimistic emperical worst-
   case execution times.
2) Compare against performance with caches (quantify
   the avg. case benefit).
3) Deterministic memory accesses (access cannot cause a
   cache eviction.)
4) Theoretically, increased performance can be achieved
   by storing infrequently accessed data in uncache pages.

uncachedev allocates pages with the pgprot_noncached() page
attribute for user applications. Since pages allocated by
uncachedev are not locked in memory by default, applications
with any access level may mmap pages with uncachedev.

Limitations:
1) Uncache pages must be MAP_PRIVATE.
2) Remapping not supported.

Usage (user level):
	int size = NR_PAGES*PAGE_SIZE;
	int fd = open("/dev/litmus/uncache", O_RDWR);
	char *data = mmap(NULL, size, PROT_READ | PROT_WRITE,
					MAP_PRIVATE, fd, 0);
	<...do stuff...>
	munmap(data, size);
C-EDF: Cluster-aware admission test.

cedf_admit_task() is too restrictive in that the task
to be admitted must be executing on the same CPU as
is set in the task's task_params. This patch allows
the task to be admitted to be executing on the same
cluter as the CPU set in the task's task_params.
EDF schedulers: Support early job releasing.

This patch allows a task to request early releasing
via rt_task parameters to sys_set_task_rt_param().
Note that early releasing can easily peg your CPUs
since early-releasing tasks never suspend to wait for
their next job. As such, early releasing is really
only useful in the context of implementing bandwidth
servers, interrupt handling threads (or any thread that
spends most of its time waiting for an event), or
short-lived computations. If early releasing pegs your
CPUs, then you probably shouldn't be using it.
Differentiate between PERIODIC and SPORADIC tasks.

Tasks can now be PERIODIC or SPORADIC.

PERIODIC tasks do not have their job number incremented
when they wake up and are tardy. PERIODIC jobs must
end with a call to sys_complete_job() to set up their next
release. (Not currently supported by pfair.)

SPORADIC tasks _do_ have their job number incremented when
they wake up and are tardy. SPORADIC is the default task
behavior, carrying forward Litmus's current behavior.
Changed completion flag use to remove race condition in Cedf,Gedf.
Fix enum name conflict

EARLY in release_policy_t was conflicting with
other kernel constants.
Use do_div() for integer division in litmus/sync.c

Breaks without do_div() on ARM.
Define is_priority_boosted() if !CONFIG_LITMUS_LOCKING

To avoid compile errors if locking support is disabled, and to avoid
having to use #ifdef each time is_priority_boosted() is used.