* 'master' of github.com:cloudius-systems/osv:
  wire up the read and write methods for virtio-blk
  enable SMP locking in the filesystem code
  add mutex_init/destory and a static initializer

Before we had 2 layes of calls, one in the virtio ring layer and
another in the virtio-blk layer. There wasn't any reall need for that.
The change allows the virtio-vring code to call a callback that the virtio-blk
registers and execute it directly.

Since ->wake() can be called from an interrupt, we cannot to any allocations
there.

Resolved interdependencies later on.

Removed by 9fe982be, likely by accident.

* 'master' of github.com:cloudius-systems/osv:
  re-enable the pthread tests
  provide a spinlock/mutex implementation that is SMP safe and callable from C code

and process pops requests from the ring.

In addition, implement the vfs device callbacks and wire them into virtio-blk
Need to test the later.

At the moment it's hard coded as queue '0' but further on it should be a function
of the device requirements. It is also possible to move it towards the device function
since this thread doesn't do anything other than wake up the driver worker.

They don't cause problems for other tests anymore.

this avoids a clash with the C++ std::list type.

again taken from musl.

For now disabled:

 - floor, ceil: we have an asm implementation, but need to check if it's enough
 - various functions that mess with the floating point exception status.

With this lock type, the hardware irq flag is restored to its previous
state after the lock is released.  Useful when we might be in interrupt
disabled context.

It's somewhat complicated due to the red zone, but there's no way around it.

With this change, every cpu has its own independent runqueue.  Since we don't
support thread migration yet, and since threads inherit the cpu from their
parent, all threads except the smp bringup thread will still run on the boot
cpu.

With the current implementation, where the current cpu is a thread-local
variable, we cannot change the cpu pointer atomically during a context switch,
as we cannot obtain a pointer to a thread-local variable before the thread
has been run.

By moving the cpu pointer to the thread structure, we can change it atomically
by switching the thread-local base register (%fs on x64).

We need a per-cpu interrupt stack to allow smp interrupts; because we use
the IST mechanism, this requires a per-cpu TSS, which in turn suggests
a per-cpu GDT (this last could have been avoided at the expense of some
complexity).

We play with the tss, which is supposedly per-cpu, but this has not been
implemented yet.  Disable it temporarily.  Meanwhile, interrupts and
exceptions may not nest.

During initialization, we create a thread and switch to it immediately.  In
smp bringup, we must create the thread on the boot cpu (since thread local
storage is only initialized there so far), but obviously want to switch into
it on the new cpu.

To avoid too many variants, we simply create a thread that is off the runqueue,
and then either switch to it immediately with switch_to_first(), or defer it
to the smp bringup.

This has no functional benefit, it just allows testing the async
block layer and can be reverted later.

Use more common functionality, and don't attempt to preserve too much state
(tcb/tls) from the non-threaded boot environment.  Later we can unify this
with smp boot as well.

Struct bio gains a condition variable and a mutex to allow waiting for
I/O completions.  Still no support for returning errors, but that can
be added fairly easily.