Mutexes are now allocation free and thus safe for use within the allocator.

wait_until(mutex, ...) must be called with the mutex held.

Use the new wait_until() variant that supports dropping a mutex
while sleeping.

We need to make them a little more complicated.

Previously, we performed idle processing in the scheduler, in the context
of the thread that is being scheudled out.  This makes preemption more
complicated, since every thread can potentially be in the idle loop
simultaneously, having been preempted there some time in the past.  Obviously
we can't disable interrupts in the idle loop.

Move idle processing to its own thread to fix this problem.  This is currently
sub-optimal since we don't have priority classes yet (or even just priorities),
so the idle thread can be scheduled before workload threads.  If that happens
it will examine the runqueue and yield if there's anything there.

These variants unlock a mutex while sleeping (but keep it locked while
evaluating the predicate) and thus are suitable for more complicated
predicates that cannot be evaluated atomically.

Will need more interaction with the scheduler.

Otherwise, expect memory corruption.

Make sure sched::tls is initialized before we create objects of type 'cpu',
so that any threads in those objects (idle thread, etc.) are initialized
correctly.

See README for instructions.

net: added raw_cb.c, raw_cb.h, raw_usrreq.c, unmodified. control block implementation for raw sockets

Some mutex work.

prex code depends on this.

TODO: make it optional

It just adds complexity, and doesn't reduce locking overhead, as we must
take the spinlock anyway during unlock.

Remove it, since it makes conversion to a recursive mutex (needed
by fs/vfs/vfs_mount.c) more complicated.