We now have the basic wireframing classes for building the UDI channel
abstraction and integrating it into the kernel for the interconnection of both
drivers and application processes.

So far spawnChildBindChannel() is untested, but spawnInternalBindChannel() is
tested (not very rigorously though). We make very heavy use of both polymorphism
and multiple inheritance in the channel manipulation code, so take note.

But all in all, very exciting patch since it means that within a few more
patches, we'll be "blasting" messages about, as someone on the LKML described it
some years back.

* createChannel() functions:
  * Cleaned these up by making them take an Incomplete*Channel pointer, instead
    of passing 6+ arguments on the stack.
  * They are now static methods of their logical container entities.

* Destroyed the older Channel classes which were defined as subclasses of
  DeviceInstance, and moved the entire hierarchy along with class Region out
  into the fplainn:: namespace.
* Prototyped the FloodplainnStream:: namespace channel spawning and control
  APIs.
* Moved some functions around in source files, mostly between
  udiServiceCalls.cpp and zudi.cpp to ensure sane namespacing.
In this patch, we introduce, majorly:
	* LibZUDI and udi_mei_call().
	* FloodplainnStream::connect() (!!!).
	* FloodplainnStream::createChannel().

Essentially we can now connect to drivers (technically, though not practically)
from non-driver processes.

* Wrote a bunch of accessor functions of various kinds.
* Deleted the previous incarnation of udi_usage_res().

* UDI:
  * Now pretty much completed anchoring, and cross-channel sending of
    channel messages (fplainn::sChannelMsg).
  * Implemented FloodplainnStream::createChannel().
  * Added udi_mei_call() to libzudi.
  * Re-namespaced all the udi_mgmt calls that were in fplainn::Zudi.
Main change in this patch is the introduction of FloodplainnStream::send() and
fplainn::Zudi::send(), which are basically mirrors of one another, but simply
to be called from different types of processes.

* Cleaned up fplainn::Endpoint::anchor()'s first argument by adding a union
  to replace the untyped first argument.
* fplainn::sChannelMsg now has a back-end function which is called on by the
  other two send() APIs.
A lot of changes (I'm sorry) in this patch.

I did my own UDI metalanguage libs for udi_bridge and udi_gio. I'm glad I did,
because the official UDI Reference implementation libs had bugs and errors.
<sarcasm>Mine certainly don't of course, because I am invictus latentprion
</sarcasm>. I also ported over the UDI Reference implementation's udi_layout
functions, used to marshal UDI calls and calculate the storage required for
a marshal operation.

Also implemented the code needed to remove dependency on the udi_init_info
pointers currently found in fplainn::Driver, and may soon be removing that
dependency entirely. Now, libzbzcore passes around a per-driver cache of data
that holds a pointer to the udi_init_info, as well as things like the max
scratch requirement for the driver's CBs, etc. This of course, means that we
are now almost ready to begin doing the callee-side of udi_mei_call().

UDI Metalanguages:
* Implemented udi_gio's library and udiprops.
* Implemented udi_bridge's library and udiprops.
* Added them to the list of kernel index udi_mei_init_ts.
* As a matter of course, created some really neat macros for making the
  creation of metalanguage libraries easier.

UDI Syscalls:
* Fleshed out udi_mei_call() within libzudi a bit further. We now /kind of/
  get round to gathering the metadata required to marshal the control blocks and
  calls.

Lib ZBZCore:
* Added a new local service provided by the driver instance's main thread:
  GET_DRIVER_CACHED_INFO.
  ^ This will return to the calling region thread, the information that the
    driver instance cached about itself during its initialization.
  ^ In includes things like the udi_init_t pointer for the driver and the
    max scratch requirements for each meta_idx+meta_cb_num combination.
* Region main now postMessage() requests to the main thread asking it for the
  cached data.
* Added a new per-driver-instance caching class, which can compile all
  necessary cacheable metadata for a driver from its udi_init_info.

MessageStream::postMessage:
* Now uses its own message type, MessageStream::sPostMessage.
* Now takes BOTH a data and a privateData argument, allowing the caller to
  separate the data being sent to the target from the context information it
  needs to preserve across the asynchronous call.

* Added some commentary to zrootdev to describe the child_bind_ops entry points
  we will expose.
  ^ Will only expose a udi_bridge child bop.
  ^ We can use the udi_mgmt metalanguage's udi_enumerate_req() with directed
    enumeration to force the zrootdev instance to enumerate the zramdisk and
    vchipset devices.
* Began work on the idea for the indirection of the channel_context pointer for
  channel endpoints, which will enable us to speed up certain types of lookups
  on the caller and callee side of any UDI call operation.
* Moved over the changes to the UDI ref headers from the ZUDI repo.
Now properly created a callback class for the region::main sequence.
Small patch.

* Improved the complexity of devices' binding to their parents. Now with a
  little more work, we can support multiple parents.
* Some new data types in libzudi, for local metadata.
* Kernel-side channels now hold a privateData pointer instead of a channel
  context pointer.
Very encouraging patch. In this patch I've managed to surmount a really boring
obstacle. There are several more hurdles to go, but this makes the heart glad.

* We now have local endpoint-contexts for channel endpoints.
* We now also have local region metadata for region threads in userspace.
* Fixed negligence in the calculation of rdata size. We now properly take the
  udi_secondary_init_t::rdata_size for each region into account.
* Each region thread now allocates its own rdata, and this is no longer done
  in the DriverInstance's main thread.

* spawnInternalBindChannel and spawnChildBindChannel both now return pointers to
  the child-endpoint of the newly spawned channel. This enables us to construct
  our local userspace metadata.
* We no longer store rdata information within fplainn::Region. This is offloaded
  to userspace.
* New syscall: fplainn::Zudi::setEndpointPrivateData(), used to set a kernel
  endpoint's private data pointer. This pointer is passed in all sChannelMsg
  objects to driver regions, and is used by the region thread to quickly gain
  a context-sensitive pointer to the channel endpoint's data.
Finally overcame a certain obstacle in our UDI environment, where we couldn't
identify how to determine which metalanguage to use to connect to a particular
parent from the child's perspective.

This new revelation also enables us to dramatically cut down the amount of time
it takes to cycle through device lines when trying to match a device against a
driver. It enables us to optimize the sequence we use by only attempting to
compare the device against those device lines which match the Metalanguage which
enumerated the device. Will apply this optimization later.

* Moved the parent-bind-channel spawning sequence into devicePath.cpp
* Corrected the sequence to now properly take into account the metalanguage
  that the parent enumerated the child using.
* Added some commented-off code that will enable us to avoid certain
  synchronization issues between the DriverInstance's main thread and the
  device's region threads by using SPAWNTHREAD_FLAGS_DORMANT to delay the
  execution of the region threads while the main thread sets some metadata.
* Fixed a bug where we were calling for a callback twice, causing two
  response messages to be sent to the ZUI thread instead of one.
  This caused as a result, a double-free.
We no longer have a "detectedDeviceLineMetaName' on devices, in keeping with
our new multi-parent support, and the fact that this information is now
kept in the sParentTag objects within the fplainn::Device object.
* Began fleshing out libzudi.
  * Added prototypes for udi_channel_*.
* Increased the type safety of several functions in the fplainn::Channel domain.
* Renamed fplainn::Zudi::udi_channel_spawn(), to fplainn::Zudi::spawnEndpoint().
* Added prototype for fplainn::Zudi::anchorEndpoint().
* Moved fplainn::Zudi::spawnEndpoint out of udiServiceCalls.cpp and into
  zudi.cpp.

* Endpoints' private data can now be set from any thread, and not just the one
  to which they are anchored.
* Renamed fplainn::Channel::destroyIncompleteChannel to removeIncompleteChannel.
  ^ No longer deletes the incomplete channel. Simply removes it from its list.
  ^ Introduced a new operator delete() custom operator, that will safely delete
    all derivatives of fplainn::Channel, as long as they are deleted via a
    pointer/reference to an fplainn::Channel.
    ^ Might want to force the issue and also overload operator delete in the
      derived classes as well.

* Solved a design issue caused by the fact that we were re-allocating the
  incomplete channels to create base-class Channel derivative objects.
  ^ The problem is that udi_channel_spawn will return a handle to a channel
    even before both ends have been matched up.
  ^ So the pointer we return while the channel is incomplete must also be
    valid after it has been completed.
  ^ Had to stop reallocating, and just downcast.
* Added a stub, dummy udi_mei_init_t for udi_mgmt to the IBM-PC meta init list.
  ^ This will serve as the returned pointer when a call for findMetaInit() is
    made with "udi_mgmt" as the argument.
* DriverInstance metadata now has a list of udi_mei_init_t descriptors which all
  point to meta_inits for the metas that the driver needs.
* There is now a semi-global, per-driver-instance list of region-local metadata
  which allows calls such as udi_channel_spawn() to get their calling region's
  region-local metadata cache.
* Implemented libzudi's udi_channel_spawn().
* Implemented:
  * udi_channel_set_context in libzudi.
  * Zudi::anchorEndpoint.
Implemented udi_channel_anchor() in libzudi.
This patch. THIS patch. This PARTICULAR patch. Eh, boi! When yuh big, yuh large.

This patch introduces all the code necessary to package and marshal a UDI call
into a kernel message and send it across a channel, from endpoint to endpoint.
It can successfully transfer a call across a D2D or a D2S channel. Only
D2S channels have been tested for now.

* Implemented fplainn::Zudi::send().
* Implemented FloodplainnStream::send().

	^ These two function both take a kernel endpoint and marshal a UDI
	  call over it. They first validate the endpoint pointers passed to
	  them, then delegate most of the work over to
	  fplainn::sChannelMsg::send() to actually marshal the call into a
	  message, and eventually post it to the target thread.

* Re-wrote large portions of udi_mei_call().
  ^ Now it properly gathers the layout data required to properly marshal the
    visible, marshal and DRIVER_TYPED portions of a call.

* Wrote some supporting methods that will help us to get proper inline member
  support later on.