Switched the virtio-net driver to use if_transmit() instead of legacy
if_start(). This saves us at least 2 additional lock/unlock sequences
per-each mbuf since IF_ENQUEUE() and IF_DEQUEUE() take lock when
pushing/removing the mbuf from the queue if ifnet in a legacy mode.

Signed-off-by: Vlad Zolotarov <vladz@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>

Now, the tx gc thread is gonna. The gc code can only be called in one
place. We do not need the lock anymore.

Signed-off-by: Asias He <asias@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>

We do tx queue gc on the tx path if there is not enough space. The tx
queue gc thread is not a must.

Dropping it saves us a running thread and saves a thread wakeup on every
interrupt.

Signed-off-by: Asias He <asias@cloudius-systems.com>
Signed-off-by: Pekka Enberg <penberg@cloudius-systems.com>

We have _KERNEL defines scattered throughout the code, which makes
understanding it difficult.

Define it just once, and adjust the source to build.

We define it in an overridable variable, so that non-kernel imported code
can undo it.

Add Cloudius copyright and license statement to drivers/*.

A couple of header files were based on Linux's BSD-licensed header files
(e.g., include/uapi/linux/virtio_net.h) so they included the BSD license,
but not any copyright statement, so we can just replace that by our own
statement of the BSD license.

Based on FreeBSD virtio code
Provides a x7 boost for rx netperf

Fix memcached networking issue that was caused by unsecure, parallel device invocation. I wasn't aware that the a device lock has to be held on the tx callback. Will look into it deeper tomorrow. The patch solves the issue

virtio_blk pre-allocates requests into a cache to avoid re-allocation
(possibly an unneeded optimization with the current allocator).  However,
it doesn't take into account that requests can be completed out-of-order,
and simply reuses requests in a cyclic order. Noted by Avi although
I had it made using a peak into the index ring but its too complex
solution. There is no performance degradation w/ smp due to the good
allocator we have today.

virtio-vring and it's users (net/blk) were changed so no request
header will be allocated on run time except for init. In order to
do that, I have to change get_buf and break it into multiple parts:

        // Get the top item from the used ring
        void* get_buf_elem(u32 *len);
        // Let the host know we consumed the used entry
        // We separate that from get_buf_elem so no one
        // will re-cycle the request header location until
        // we're finished with it in the upper layer
        void get_buf_finalize();
        // GC the used items that were already read to be emptied
        // within the ring. Should be called by add_buf
        // It was separated from the get_buf flow to allow parallelism of the two
        void get_buf_gc();

As a result, it was simple to get rid of the shared lock that protected
_avail_head variable before. Today only the thread that calls add_buf
updates this variable (add_buf calls get_buf_gc internally).

There are two new locks instead:
  - virtio-net tx_gc lock - very rarely it can be accessed
    by the tx_gc thread or normally by the tx xmit thread
  - virtio-blk make_requests - there are parallel requests

Trivial: Move code above, preparation for preventing past path allocations for the virtio request data

The feature allows the hypervisor to batch several packets together
as one large SG list. Once such header is received, the guest rx
routine interates over the list and assembles a mega mbuf.

The patch also simplifies the rx path by using a single buffer for
the virtio data and its header. This shrinks the sg list from size of
two into a single one.

The issue is that at the moment I haven't seen packets w/ mbuf > 1
being received. Linux guest does receives such packets here and there.
It may be due to the use of offload features that enalrge the packet size

we have to disable virio interrupts before msix EOI so disabling
must be done in the ISR handler context. This patch adds an std::function
isr to the bindings.

references to the rx and tx queues are saved as well (_rx_queue and _tx_queue),
so they can be used in the ISR context.

this patch reduces virtio net rx interrupts by a factor of 450.

the linux/musl definition is 2 bytes long instead of 1 byte as in
freebsd, this patch is fixing this issue which caused ifconfig to fail

The caller - virtio_if_start already calls kick after it loops
over all the qeueued tx msgs.

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.

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.

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

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.

Created abstract base classes for device and drivers, changed the flow of driver loading / device probing

Now the network driver has 3 queues as it should have