Each cpu has its own event timer; we rely on this.  Document the requirement.

Also remove other timers that expired simultaneously.

remote wakeups

current_pthread was somehow not thread-local, so pthread_self() returned
the last thread to initialize itself.  The bug manifested itself with
a jvm thread querying its own stack, finding another thread's stack instead,
and reaching the conclusion that it was in a stack overflow, and throwing
an exception.

Fix by making current_pthread thread local.

Each cpu has a queue (actually an array of queues, one for each "waking" cpu)
of threads that are to be woken.  A thread can be queued locklessly, so a
runqueue lock is not needed.

As we don't IPI yet, the queues are polled at strategic points.

While generally useful, it helps now to avoid wakeups to threads that are
no longer there.

* 'master' of github.com:cloudius-systems/osv:
  stop adding libm.so.6 from glibc to bootfs
  warn when we can't load ELF libraries from DT_NEEDED
  warn on unknown ELF section types
  fix up library pathnames in the ELF loader
  fix sem_wait
  add a __fprintf_chk implementation
  add popen/pclose stubs

Now that we actually look for DT_NEEDED libraries in the right place we
fail loading it because we don't support STT_GNU_IFUNC symbols.  But
by now we already have a feature complete libm implementation in our
tree so we don't actually need it anymore.

We want to look for /usr/lib/libfoo instead of /usr/liblibfoo

We need to use a spinlock to protect the semaphore waiting list as
the wakeups can deadlock otherwise.

Also make sure to only wait when we actually have to.

Found during python bringup.

no actual checking, but at least the code will work

* '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.

Single producer, single consumer.

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

Resolved interdependencies later on.