As suggested by Guy

Mostly trivial changes needed to compile the pv event channel.  We need some
type adjustments, but the most complex ones are assembly fixes.  Because BSD
seems to only do this for 32-bit guests, we need to adjust the inline asm
instructions to take quad words for longs, and force int types for double
words.

After this, the evtchn can be compiled.

This file implements the pv and pv-on-hvm event channel mechanism.
Verbatim copy from BSD.

This contains interrupts, devices and bus definitions. Most of them are is bus
files in BSD anyway.

With this patch, the grant table code is compiled into osv.
The edits in the file reflect the fact that we don't need to go through PCI
memory for the Xen special device even for HVM. We have mappings that are
way simpler, so we can just use them. All the rest is kept as unchanged as I
could.

This is for the lack of a better place.

msleep() will fault if mtx is NULL.

Unlike Solaris the znode is a separate structure in OSv and we need a separate
reference count for it.  The implementzation isn't very optimized yet, and
instead of optimizing it it would be better to unify the two structure lifetimes.

Now that vn_stat() supports VOP_GETATTR, wire up the ZFS implementation.

The init and fini functions are fairly expensive (for networking).  Cache
initialized objects in percpu pools to save this cost.

The implementation is imperfect since if we're allocating on one cpu and
freeing on another, reuse is low.  This can be improved in the future, or
made unnecessary with VJ rings.

Increases netperf from ~14.6Gbps to ~17.8Gbps on my machine.

M_ZERO requests zeroing of the object regardless of any constructor; honor it.

It works now because we bzero() all objects unconditionally, but we soon
won't.

We're going to make zones more expensive to allocate, so allocate only
as many as we need.

Allows integrating with our mempools.

M_ZERO requests zeroing of the entire mbuf, which clears the fields initialized
by the init function.  It only works now because we don't honor M_ZERO.

Remove M_ZERO and replace with bzero() for the packet data only.

So after all the BSD code is not buggy, it is just their semantics that is
slightly different from our version of mlock (Thanks Christoph). Whether or not
we will drop the lock will be controlled by the value of the PDROP flag.

Our msleep queues are protected by an internal lock which is not the same lock
the user passed to the msleep call. Therefore, we can just a version of
wait_until that does not take a lock argument, and do the locking manually
ourselves. We may then lock it back or not, depending on the presence of the
PDROP flag.

Only those I plan to use for now. Wrap it into __*_DECLS

This provides a simple msleep implementation that simply calls our own, and
an empty MTX_INIT macro

Most of those files are quasi-empty (just with the usual .h ifdef in case we need
to add things later). When relevant, we also add code to those files, sometimes
including our own files, and providing extra definitions.

Providing those stubs make importing BSD files a lot easier.

Disk alloc is a simple function that, well, allocates a disk. It is supposed
to be provided by the device code, but for simplicity I am providing it in
blkfront itself. We have no really better way to put it: device.c is quite generic,
and we seem to have no disk specific file.

If time brings us more users of such function, then I will move it somewhere else.

Xenbus will use BSD taskqueues in the following way:

  taskqueue_enqueue(taskqueue_thread, &xbs->xbs_probe_children);

taskqueue_thread seems to be the main bsd taskqueue, which wasn't ported in our
initial port. So I am definiting it and initializing.

It seems a bit odd to do this in net.cc, but this is where the rest of the BSD
initialization lives anyway (maybe the filename should change?). Let me know if
you feel strongly about it, and I will change. But for me it is okay for now.

Those are the verbatim files, straight from BSD.

BSD register a structure with its per cpu data. We can do the same, using
just the fields we need.

Xen BSD code will attempt to create processes to serve as deamons for xenstore.
We can basically emulate this by creating threads.

The only thing I am doing differently from the already existent thread creation
layer that we have, is that callers will expect a struct proc to be returned. We
had this as a stub, now I am creating a small struct with just the PID to serve
as a return placeholder. The listener processes in xenstore never dies, so I am
not implementing a deallocate routine for them

We take the write version instead of the read version when locking.
Unlocking is fine

allows the dhcp worker to see incoming dhcp packets using a simple hook.
no reason to make this kind of hook generic (a BPF alternative) as there
are already many protocol specific hooks in the networking stack.

if we ever need to do more hooking, the pfil interface may be used or we
can implement a generic solution, but it's not reasonable to do so for
a single user (dhcp).

Some of our files include headers inside an "extern C"  declaration.  The
problem with that eventually we will have definitions with C linkage - since
they are inside extern "C" - being included in places where __cplusplus is
defined. I specifically worked around this int the sx_xlock implementation,
but it is starting to create bigger problems. Fix it by making all headers
usable from whichever place by themselves, instead of relying in extern inclusions
in the cpp files

Mostly to get the X bits on directories right for lookups, as well
as checks for hard readonly files.