With atomic status, there is no need to examine the runqueue.

While easy to use, auto-starting threads generates problems when more
complicated initialization takes place.

Rather than making auto-start optional (as Guy suggested), remove it
completely, to keep the API simple.

Use thread::start() to start a thread.  Unstarted threads ignore wakeups
until started.

We don't want to be preempted while manipulating the runqueue, since
the scheduler will do that as well when called during preemption, leading
to corruption.

We don't want to be preempted during a context switch, since thread
state invariants will not be maintained.

We store it in a global rather than passing it on the stack since it's
only useful in a few contexts.  Our interrupts don't nest so it's pretty
simple.

Now it's possible to stress virtio through the external tests so
we do not need this code

These relocations need to are relative to the start of the TLS segment, which
ends in %fs:0, so we need to subtract the segment size.

Imported from prex.  Note that the test isn't wired up yet as we'll need
more infrastructure changes to run it.

Don't waste power during idle.

Wastes power.

Instead, spin for a bit looking for work to do, then enter a low-power
state and wait for an interrupt to pull us out of it.

Also add an arch independent name for it.

The whole idea of namespaces is to prevent namespace pollution, using a
"using namespace" in a header negates that.  Remove.

Noticed by Guy.

Add a detached thread class (with a private destructor, so it can only be
allocated on the heap).  The implementation uses a reaper thread to wait
until the detached thread is dead, and then ->join() and delete it.

fixes loading unit tests with "main" as the entry point.

This is like printf() but prints straight to the console instead of going
through the stdio library, the VFS and the device layer.

To be used for debugging outout in the kernel.

* 'master' of github.com:cloudius-systems/osv:
  interrupt manager: use range-based for loop instead of manually looping
  sched: optimize scanning the incoming_wakeups array
  sched: add an atomic cpu_set type

of the pci virtio config size to a function using the first.

Protect the array with a cpu_set (bit set -> corresponding queue non-empty).
This means we need to scan one word, instead of nr_cpus (plus of course all
the cpus for which an incoming is waiting).

Supporting up to 64 cpus for now.

This fixes an issue where a symbol exists in multiple objects; when just
one is loaded it is resolved to one of the modules, but after the second is
loaded, it resolves to the second.  To the program this appears as if the
address or contents of a static variable has changed.

In our case this was triggered by both statically and dynamically linking
a library.

The glibc headers define those as macros, need to undefine before declaring
as functions.

Found with mode=release.

Found with mode=release.

Atomic thread state and related work.