There are actually no interactions between msix registrations of different
drivers, so it doesn't help to use a global instance.  We can simplify the
interface by making it local, and also remove locking considerations.

These are subsumed into the driver constructor/destrutor.

Driver enumeration requires instantiating a driver even for devices which
are not present; and if a device is present multiple times, we need to
pre-create multiple driver instances, which is awkward.  Further, driver
life-cycle is complicated, with separation between instantiation and binding
to a device.

Switch (back) to the traditional device-driven model, where we iterate over
all devices, try to find a matching driver factory, and when found, call it
to instantiate the driver and bind to the device.

Don't do this in header files.

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.

driver itself. It removes the hard coded binding to queue 0
and will enable flexibility for the upcoming virtio-net registration.

and call biodone when appropriate

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

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

Found with mode=release.

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.

Discover that bio->bio_offset is zero while the data starts in
the middle of the page so I adjusted the code accordingly.
Will need to sort it out later on.

Time might stop under some hosts without this fix.

The logic is called as callback invoked by virtio interrupts.

In addition, polish the test code. Before all of the write request
had filled the ring and left no space for the read requests. Now I rotate
between the two.

Only it's usage within the array should be within limits.

Add a function for available ring content

This makes it easier to create a thread with no special properties.

This makes it easy to configure a thread with various parameters.  The first
is the existing stack_info parameter.

pushing it into a dummy bio structure. In addition, expand the test some more

The apic needs to be programmed on each cpu that is brought up.

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

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.