libsel4camkes: Set virtqueue size on creation

The queue size of a virtqueue is how many entries its rings and
descriptor table have.

libsel4camkes,virtqueue: Link channel ID to name

Giving each channel a name based on the interface name allows components
to bind to channels via naming them rather than knowing their IDs. This
will make it possible to automatically allocate the IDs internally or
allow component configuration to pick a specific ID for backwards
compatibility or for other policy reasons.

libsel4camkes: Create new virtqueue initializers

camkes_virtqueue_driver_init_with_recv and
camkes_virtqueue_device_init_with_recv will also return the receive
notification CPtr and badge information for receiving events from the
other end of a virtqueue.

libsel4camkes: Track receive notifications for vqs

Require virtqueues to be registered with information about how to
recieve events from the other side.

camkes_virtqueue_device_gather_copy_buffer proto.

This function was added without a prototype but should be part of the
public interface.

virtqueue: Remove volatile qualifier

It is not necessary to restrict the compiler in this way.

libsel4camkes,virtqueue: Use same sized pointers

The underlying virtqueue interface uses `unsigned` types for buffer
lengths. This changes the camkes wrapper functions to use the same
types.

Avoid compiler warnings about volatile qualifier

[trivial] fix license

Fix license (2018->2019).

Updated libsel4camkes to the new libvirtqueue

This modules now wraps the new libvirtqueue in projects_libs. The new
libvirtqueue provides scatter gather buffers as well as multi entry
rings, so this camkes lib aims at providing usable wrappers to do all
the plumbing, such as iterating through the scattered buffers,
scattering buffers into chunks, etc.

Since both users of the virtqueue are not necessarily in the same
address space, they need to share buffers as offset into the array of
shared memory. This wrapper also abstracts this as much as possible by
doing the conversion inside the wrapper functions.

So as a summary, this modules provides :

Conversion between pointer and offset in shared memory.

Taking a single buffer, splitting it into chunks and scattering it in
the virtqueue as a single ring entry. (Ex: a driver scatters a big chunk
of empty memory to be filled or read by the device).

Taking a handle (a ring entry) and iterating through it to gather back a
scattered buffer. (Ex: a driver gathers back some memory that was filled
by the device, or a device reads the data sent by the driver to perform
some operation).

Taking a handle (a ring entry) and a buffer, and iterating through the
scatter list, copying the content of the buffer into the scattered
arrays, and enqueuing it back into the used ring. (Ex: a device copies
some memory it has just read from the hardware into the buffers that
were passed for filling by the driver).

libsel4camkes: Rename camkes_virtqueue functions

libsel4camkes: Add better typesafety to virtqueue

This updates to reflect an updated libvirtqueue interface that
encapsulates the virtqueue structure within specific device and driver
interfaces.

virtqueue: Updated with documentation

Updated the virtqueue interface with documentation/comments.

virtqueue: Extern'd global virtqueue variables

Added the extern property to the global 'virtqueue_channels' and
'num_registered_virtqueue_channels' variables.

virtqueue: Renamed buffqueue to virtqueue

Updated the buffqueue source to reflect the change of name. The
library API now uses the name 'virtqueue'.