'osv thread' mucks around cpu registers, restore them before resuming the
guest.

This command allows the developer to switch to and examine an osv thread.

Fail the build if not.

Pack the mutex by placing small fields next to each other.  This fixes
sizeof(cond_var) becoming larger than sizeof(pthread_cond_t), and corrupting
memory.

Detect running threads by checking whether any cpu's rsp is within the thread
stack.  If so, the thread is running on that cpu, and the saved context is
ignored as stale.  This improves 'osv info threads' greatly.

It doesn't work all that well for threads taking interrupts though.

We'll collect more osv state there.

(but don't wait for it)

* 'master' of github.com:cloudius-systems/osv:
  apic: mask LVT0 interrupts
  x64: load IDT on non-boot processors
  apic: software-enable the APIC on non-boot processors
  libc: import setjmp/longjmp from musl
  build: rule for compiling .s files
  make printf print directly onto the console before the VFS is up
  update glibc-testsuite

This avoids spurious interrupts from the PIC (even though it has been
disabled).

reduce the verbosity

Needed by bench.jar suddenly.

For musl code.

* 'master' of github.com:cloudius-systems/osv:
  sched: fix race between stop_wait() and wake()
  split the test runner into a separate object
  rename main to osv_main in the payload
  shut up mallopt
  sched: poll wakeups during yield
  gdb: fix exceptions when a thread function/file cannot be decoded
  sched: load balance threads on cpus
  sched: fix _on_runqueue not set during wakeup
  sched: explicity request the runqueue to have constant-time size
  sched: defer thread stack allocation
  smp: mark smp bringup threads as pinned
  sched: add 'pinned' attribute to threads
  sched: clear timer expired flag when re-arming timer
  Remove clock_event test
  mutex: fairness
  main: test clock events earlier

If a wait sequence (prepare_wait() -> wait_until() -> stop_wait()) did not
actually call wait(), and if a wake() was called in the middle, then we
could end up on the runqueue even though we're still the current thread.

Detect this condition and undo the effect.

To be fixed properly later by adding more states to _waiting.

Running tests is now done by editing the command line in build.mak

This will allow running unmodified tests with a main() entry point even
after splitting the test loader out of the kernel.

At present, a trivial algorithm is used: wake up once in a while, look for
a less-loaded cpu, and push a waiting thread from this cpu to the other cpu.

This is very simple wrt. locking, since the waiting thread is guaranteed not
to be running, and to be on the runqueue of the load balancer thread.

Lost when remote wakeups were added.

While it is the default, we'll rely heavily on constant time size
to compute the load (from remote processors, too).  Document it to
avoid having someone "optimize" it away.

This allows copying thread::attr objects around without leaking stacks.

Interferes with the scheduler

Without fairness, the concurrent alloc/free test fails quickly on smp, as
the allocator thread hogs the allocator mutex and quickly exhausts all memory.
While we could fix up the test to avoid this, fairness is a desirable quality,
so implement it.

We do so by adding and owner field, and having the unlocker transfer ownership
of the locked mutex instead of freeing it and letting the waiter race with
a newcomer.

Also simplify the wait list to a singly linked list.  There was some
corruption with the original implementation, and rather than fix it,
simplify it to a singly linked list which is all that is needed.

and verify their content. The image is been run over but the content
is restored after each write