* Added support for the new "nSupportedDevices" attribute in zudi::headerS.
* Imported the new zudi index header.
Changes to the build system to allow the kernel to spawn only one ZUDI index.

* Removed unnecessary udiprops from IBM-PC chipset dir.
* New common metalanguages for zbz_root and zbz_chipset.
* createRootDevice: Now creates ramdisk as well as chipsets.
  * Should be renamed to createChipsetDevices().
* Fixed bugs in loadDriver() that caused error return value to be sent when
  a driver had 0 of a particular udiprops property.
Began work on libzbzcore; Created paths for Distributary and Driver processes.
Streamlined the kernel's entry points for different exec formats and process
types.

The kernel now proceeds up to __korientationMain4().

To deal with the issue of continuity of access to the response message for a
newly spawned process, we now store a pointer to the process' response message
in its PCB. This message can only be sent once. This enables libzbzcore in
userspace to properly syscall into the kernel and notify the creating process
of the status of the child process.
Because of the changes to the way the kernel enumerates base devices, the
ramdisk is no longer a child device of any bus, but is enumerated directly by
the kernel. This is beneficial, since it means that we can mount the ramdisk
as the first device.

* New folders: commonlibs/metalanguages, commonlibs/drivers.
  ^ Contain metalanguages and drivers which are not chipset specific.

* Floodplainn:
  * New by-id/* root level namespace partitioning:
    ^ by-id/0: Always used to enumerate the kernel's ramdisk.
    ^ by-id/1: Always reserved for the kernel's virtual chipset device.
    ^ by-id/2+: Occupied by chipsets. The kernel supports multi-motherboard
      setups in this manner.
  * createRootDeviceReq: Separated into two synchronous functions that create
    the ramdisk, virtual-chipset device, and the root chipsets separately.
  * enumerateBaseDevices(): Enumerates the __kramdisk and vchipset devices.
  * enumerateChipsets(): Enumerates all chipsets. Most platforms will only have
    one.
* ZUDI Index Server:
  * New API call: loadRequirementsReq(): takes a device, looks at its driver,
    and fills out the locations of all libs it depends on. Should any dependency
    not be satisfiable, returns error. Designed to be used in userspace as well.
  * ZUDI Index parser now has a total number of supported metalanguage names
    (provisions) as per changes to zudiindex.
* Chipset general:
  * Now the udi_init_info list is functional.
* libzbzcore: Now does a full message loop, and calls loadRequirementsReq().
* Process Trib:
  * spawnDriver: no longer takes a schedPolicy argument. All drivers are
    scheduled as real-time processes.
More work on driver spawning. This commit is an intermediate commit before a set
of intrusive changes to the way drivers are spawned. I intend to make all
devices that share the same driver to share the same address space.

That is, there will be one process per driver, and loadDriver() will now spawn
a process. This process will have a listener thread which will pick up requests
from the kernel directly, such as requests to create a new device instance,
etc.

This patch itself introduces the ability for there to be multiple heaps, though
sadly C++'s new/delete operator behaviour limit the seamless integration of this
solution.

* Changes to memReservoirC and memoryBogC to cause them to take a memoryStreamC
  pointer on construction. This stream will serve as the source for their
  page allocations. Introduced several overloads of ::operator new/delete
  to make use of this new feature, but C++ doesn't allow it.
* New drivers and metalanguages introduced:
  * UDI_GIO is now supported by the kernel.
  * ZBZ_ROOT and ZBZ_CHIPSET are now supported by the kernel.
    ^ ZBZ_ROOT is the metalanguage that the kernel enumerates base devices in.
    ^ ZBZ_CHIPSET is the metalanguage that chipset devices enumerate their
      sub-devices in.
* Libzbzcore:
  * Spawns regions.
  * Attempts to spawn internal bind channels.
  * Now provides a region entry path.
* ptrlessListC:
  * IteratorC type implemented.
  * remove() implemented.
* New channel and region types for fplainn::deviceC.
* Added extern "C" guards in udi.h.
driverProcessC objects now carry a pointer to the driver they host.
I've changed the majority of the infrastructure needed to support per-driver
address spaces.

* Globally replaced __KFLAG_* with FLAG_*.
* Re-did the CHIPSET_*_NUMA_* constants, and their compile-time checking.
  ^ Renamed all to remove the _CPU_ and _MEMORY_ parts of their names.
  ^ One single define now covers all defines for __kspace, and the same goes for
    Shbank.
* Introduced fplainn::driverInstanceC.
* Introduced fplainn::driverC::addInstance().
* deviceC objects now take a bankId as one of their constructor arguments.
Split up the fplainn:: namespace:
	* DeviceC now has been purified of instance related metadata.
	* deviceInstanceC now holds all information pertaining to a device
	  instance.
	* driverC now has a list of driver instances.
	* driverInstanceC has been edified to more ably describe a driver
	  instance.

I'm also beginning to code in the design decision that only kernel-index drivers
can be kernel-domain; and that in fact, they must be kernel domain.

* Implemented floodplainnC::instantiateDevice().
* Driver instances now hold their parent bop vector addresses.
* Libzbzcore now waits for instantiateDevice messages.
* FVFS tag names are now 32 chars long.
* Devices now have a requested and a select device index.
* Implemented new floodplainnC::instantiateDeviceAck().
* zudiIndexServer::newDeviceInd() now calls instantiateDevice.
Biggest change in this patch is that driverC now holds the index it was
detected from. This enables spawnDriver to potentially take a driver name
instead of a device name.

* Driver processes now hold a pointer to the device instance they pertain to.
* Skeleton form for instantiateDevice within libzbzcore.
In this patch, I've completed the changes necessary to enable a device
instance to be created, and have its region threads spawned, synchronized with
the main thread, and have their owning device and region information posted to
them.

* Implemented memmove().
* Fixed memcpy() to always copy forward.
* New fake metalanguage mei_init_t entry.
* Driver instance objects now hold a list of pointers to the devices that they
  host.
* State machine cleanups in fplainn:: for all classes.
* Member initialization list cleanups in fplainn:: for all classes.
* New syscall, messageStreamC::postMessage(), used to post messages to other
  threads within the same process. Rejects messages from outside the process.
  ^ Provides a fast way to pass pointers around between threads which don't
    share state.
* loadDriver():
  * Will now fill out information that fills out the udi_meta_info
    pointers for metalanguages in kernel-index drivers.
  * Will do the same for the driver's udi_init_info struct.
Transitional commit.
This patch introduces the kernel primitives for spawning internal bind channels
and also for spawning channels in general. It also sports a prototype for
child bind channel spawning.

* Region threads now receive a device path instead of a device handle.
* Region threads other than the primary region now spawn their internal bind
  channels on startup.
* fplainn::deviceInstanceC::channelS now takes constructor arguments to
  immediately assign its channel endpoint values.
* Implemented fplainn::deviceInstanceC::addChannel() and removeChannel().
* hostedDevices in fplainn::driverInstanceC now stores device paths instead of
  device object addresses.
Corrected driver entry metalanguage exporting: now drivers can correctly
export their child bind ops instead of their parent bind ops.
* Defined the kernel's device classes.
* Defined the kernel's mappings between some metalanguages and the kernel's
  device classes.
* Allocating an object size of 0 from the heap is now a panic()-worthy offense.
* Fixed 2 zero sized allocations.
* Implemented driverC::detectClasses(), used to fill out the kernel's mappings
  for the metalanguages exposed by a driver.
Device objects have pointers to FVFS tag nodes which are their parents.
Main change in this patch is that deviceC objects are now officially directory
inodes for the FVFS. FVFS tag nodes are no longer composite tags and inodes.

* deviceC:
  * No longer holds a shortName member.
  * No longer holds an integer based device ID.
  * Devices will now only hold their longname as identified by the "device" line
    that matched them in detectDriver().
  * Now inherits from vfs::dirInodeC.
    ^ createChild(), getChild() and removeChild(), as well as the private
      wrappers have been moved across accordingly.
* fvfs::tagC: No longer derives from vfs::dirInodeC.
* vfs::dirInodeC: No longer has duplicated metadata for nDirs, nLeaves.
Changes beginning to enable the management channel to be spawned for new
driver instances and device instances.
* Implemented floodplainnC::spawnChildBindChannel().
  ^ Is agnostic of the region that it was called from.
  ^ Supports multiple parents, though that is based on the device name that was
    passed to it.
* New error_t value: ERROR_NON_CONFORMANT.
* New accessor functions for fplain:: namespace classes.
* deviceC::setEnumerationAttribute renamed to deviceC::addEnumerationAttribute.
* Channel endpoints now have an "otherEnd" pointer.
* Fixed heapPtrC misuses.