In x86-32 page fault code, ensured that getCr2 is called once, asap.
Cleaned up the VFS base types, making them less templated and moving type
information into the tags and out of the inodes.
* Added a short SRAT dumping function in __korientationMain for testing purposes
  on a NUMA testbed machine.
* Distributary Inodes now contain a control queue which the kernel uses to send
  control messages to the distributary on creation, power-management-states,
  and new-device detection.
  ^ Added a syscall for allowing distributaries to obtain a pointer to their
    control queue.
* Small fixes in i8259a.cpp for IBM-PC.
Separated the kernel callback message types into a new header, and
namespaced them ("zcallback").
Renamed some of the macros, re-namespacing them into a ZMESSAGE namespace.
Also tidied up some of the documentation for zmessage.h.
* Callbacks for processTribC::spawnProcess() now return the new process'
  first thread's ID as their "sourceId" member.
* Replaced timerStreamC::requestS with a new request object type that properly
  contains a zrequest::headerS object within itself.
  ^ Cleaned up Timer Stream macros.
  ^ Unified Timer Stream request infrastructure.
* Fixed a bug due to overlapping variable name precedence in
  timerStreamC::createOneshotEvent().
* Defined 4 USER<0-3> callback queues for threads to use for posting custom
  messages to one another.
Unified Timer Stream requests and events into the kernel's ZMessage facility,
and created and integrated the lock descriptor mechanism for auto-unlocking.

* Defined a lockC::operationDescriptorS structure for lock operation description
  meant to be used by the Task Tributary for auto-unlock operations.
* Created a kernel strerror for error_t values.
* Wrote some event looping code which is the first real case of the kernel's
  aynchronous API callback mechanism being truly used.
* Investigated an IRQ performance issue in the Timer Tributary where due to
  Virtual Box's slow execution speed, the timer ISR would fail to queue an IRQ
  event on the Timer Trib's dequeueing thread.
  ^ In conclusion, if we optimize __kprintf(), the problem should go away.
  ^ Another solution is to simply setWaitingThread() on timer-device queues as
    soon as they are consumed by the Timer Trib, instead of letting the Timer
    Trib's DQer thread setWaitingThread() on its own when it is eventually
    switched to.
  ^ Final solution, which is sub-optimal is to yield() as soon as a control
    message is created on the Timer Trib control queue, if that control message
    is a "new timer device enabled" message.
* Task Tributary now uses the lock operation descriptor instead of taking
  up to 4 arguments to an overloaded version of block().
* This is also the patch in which Timer Stream events and requests are unified
  into the kernel's ZMessage infrastructure.
Implemented some basic device tree frameworking and some other stuff in
preparation for the UDI environment.

* Cleanups in debugPipe.h.
  * Split up the format parsers.
  * Added a new format specifier for recursive format string parsing (%r).
  * Cleaned up the kernel's option specifier.
* Improved comments in __korientationMain.cpp.
This patch introduces the first iteration of the design of the Floodplainn VFS.
This is the first step in getting UDI working.

* Improvements to kernel printf:
  ^ Now handles NULL pointer arguments for things like strings.
  ^ Fixed a minor bug introduced by the last patch.
* Fixed a bug in the VFS base classes where tag::initialize() methods weren't
  being called for newly created tags.
* Introduced namespace fvfs:: containing fvfs::tagC.
* Preliminary notes on the kernel's FVFS/device tree.
Prototypes for some of the most essential part of the UDI environment, along
with notes.
The Floodplainn has been added to the kernel officially, and is built along
with the other Tributaries. Furthermore, the kernel's device tree has been
skeleton-hashed out, and inkernal driver processes are now creatable.

The kernel is getting closer and closer to being able to spawn a very basic UDI
driver process.

Fixed the maldesigned anomaly which enabled kernel-space threads to be created
with a userspace stack. Furthermore, the kernel's new policy on how drivers are
managed (separate address space, userspace processes almost removes the problem
entirely.

* Added strnchr() to the kernel C lib.
* Kernel now enumerates the root device early, after the VFSs are initialized.
* Devices now have a "bankId" to enable the kernel to situate them for NUMA
  local optimzation.
* Polished up the FVFS and Floodplainn APIs.
* Basic FVFS/device tree operations added (createDevice, getDevice, getPath,
  etc.).
* New process types: driverProcessC and kernelDriverProcessC.
* New process Tributary major function, processTribC::spawnDriver(), which takes
  a path to a device in the kernel's device tree and tries to create a process
  for it with a driver image to manipulate it.
* Added some preliminary notes on the work-in-progress UDI environment.
processTribC::spawnDriver() has been fleshed out almost fully now; all that
can be done to fill it out is to add calls to the driver-search process. Next
milestone target is the completion of the driver-search process.

Implemented and fleshed out almost all of the *Device() functions in
floodplainnC. The path parsing is pretty robust, and it behaves as required
under a range of unexpect input values.

* Augmented strerror() to return a string "<Unknown error>" when the error
  message is out of bounds for error_t values.
* Fixed a small macro definition problem for some of the error_t values.
* Added __attribute__((noreturn)) to panic().
* The kernel now supports SPAWNPROC_FLAGS_DORMANT for newly created processes.
* Added return status values for processTribC::spawnDriver() that indicate that
  the target device has no loaded driver, or its driver has missing metalanguage
  dependencies.
* Small code redundancy cleanups.
* Fixed a bit of neglect in vfs::dirInodeC, where nDirs and nLeaves weren't
  being updated when vfs::dirInodeC::remove*Tag() was called.
* Wrote a stub for the common kernel driver entry point.
* Updated comments within processTrib.cpp for spawn* and the common entry point.
Re-vitalized distributary process spawning, but it somehow dereferences a NULL
pointer at the moment.

* Augmented dvfs::getPath() to properly handle default node checking within
  the getPath() function, and removed that corner-case from processTribC.
Did some work on the kernel's asynch pulling API, such that now the kernel will
reclaim objects when they are handed off to callers. Callers receive copies.
This (regrettably) introduced the need for an additional 4 bytes to be added to
the message structure.

I'm strongly considering making kernel API messages be no bigger than 256B, and
anything larger can be passed via an IPC API.

Additionally, the kernel no longer considers the per-thread message queues to be
callback queues, but message queues. It will be used as the basis for a generic
messaging system. Changes have been effected in this patch that reflect that.

* Added some new warning flags to the kernel (-Wstrict-overflow=5).
* New iterator type for kernel messages. Will probably be limited to 256 bytes
  max soon.
* Silenced some new warnings from the new flags.
* Got the kernel building in CLang++ again.
* Renamed callbackStreamC to messageStreamC.
* Added two new message queues to the common set for requests to be delivered to
  kernel service threads.
* New kernel service distributary: UDI-indexer.
* New syscall: floodplainnC::loadDriver().
* Renamed messageStreamC::enqueueCallback() to enqueueOnThread().
* Preliminary implementation of floodplainnC::loadDriver().
Renaming __ksyslib.
Renaming __ksyslib again.
The kernel's build process now scans for all UDIProps files and adds them to
the index. Also added some test udiprops for some devices.
Fixups in the definitions of the instance attributes structure.

Also added the udi core headers from udiref. Will add udi_physio soon.
Globally replaced __KNULL with NULL.
Globally replaced __kprintf with printf.