Now our Isa serial device can read characters.
Using it by calling readln(char *msg, size_t len);
Note that the calls block until the len input chars or a newline.

Additional cleanups and tries are needed.

We cannot relay on the overlay protocol to provide this length and
we must receive it from the hypervisor.

This allows taking BIO_ERROR into the block layer core and remove unsafe
bio_flags manipulations in the virtio-blk driver.

Integrate virtio-net to the tx network stack. Register the interface into the FreeBsd stack and handle tx packets. At the moment the previous tx test function still exist but it should eventually dropped. Along the way remove few compilation hurdles w/ the rest of the system.

Move osv/bio.h into the .cc implementation and along with it move the virtio_blk_req structure that can be hidden from the header.

Rename all 'log' functions of class log into 'wrt'. The reason is that BSD has a #define log line and there was a clash

virtio_device is now a simple set of accessors around pci::device.  Since
the only users of virtio_device are virtio_driver and its subclasses, we
can simply fold it into virtio_driver, eliminating the middleman.

Resolves two FIXMEs where we leaked virtio_device objects created during
probing.

While a great feature, it's not supported in C++.  G++ does support it as an
extension, but eclipse's static code analyzer does not, which causes a lot
of false errors to be reported.

A pci::device is a pci::function, no need to cast it.  Furthermore, this
is a dangerous cast that will compile even if the object model changes.

pci::pci_device is redundant, use pci::device.

The pci layer knows about virtio devices and creates them, even though
virtio is a higher layer.

Fix by making virtio_device contain a reference to the pci device, instead
of inheriting from it.  The functionality could probably be moved to
pci_driver.

structure. The later was already allocated on the heap.

For the moment we cannot translate virt_to_phys of stack addresses
and that failed us.

I can not see the packets yet, probably the header needs to
be configured

it both when there is only 1-2 available discriptors and also to
detect whether we have < half ring and should call re-fill

Instead of requiring the user to construct an msix entry -> thread binding
map, they can now pass it directly:

  _msi.easy_register({ { 0, isr0 },  { 1, isr1 } });

Since the interrupt manager is now local to a device, we can initialize
the device pointer once and remember it.  This simplifies the API.

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