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

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.

If we failed the initial trylock, that does not mean the mutex is locked,
as it could have been unlocked right before we grabbed the wait list lock.

Retry with the wait list lock held, as the unlock path must grab it before
unlocking.

Currently, we have an atomic _waiting state for a thread, and additional
non-atomic _on_runqueue and _terminated states.  This is problematic since
a ->wake() racing with a ->stop_wait() can cause a thread to be
simultaneously running and queued.

Fix by using a single atomic variable for all theses states.

When we migrate a thread, remove its timers from the cpu-local timer list,
and move them back when we complete migration.

A mutex will also call wait_until, which doesn't tolerate nesting.

debug output and do some order

It was triggered when there were debug prints in the middle of these functions that
cause context switch.

If the host supports that it is enabled.
Indirect buffers enalrge the ring by using external descriptors
allocated on the fly.

We need to put ourself back in wait mode after every loop iteration,
otherwise a spurious wakeup can result in the predicate returning false,
and then we will never wait again, instead spinning endlessly.