Add support for ICANON mode a.k.a. "cooked" mode (see termios(3)), where the
user's input only reaches the reader after a newline, and until then, the
erase character case be used to edit the line. This makes it easier for
non-perfect typist to use rhino ;-)

Various line-discipline features such as word-erase, line kill, flow
control and signals, aren't yet supported in this version.

Note how the echo and the line discipline (editing) are now both handled in
the console_poll() thread, while previously the echo was handled in the
read() implementation (console_read()). This means we now have full read-ahead,
i.e., the user can now type before read() starts - even during the OSv boot.

This patch also removes the old debugging read() function, which doesn't do
anything useful.

OSv stalls when using romfs on certain machines so revert back to
using bootfs until romfs get fixed

Make some functions in core/mempool.cc, which should not be accessed
from outside this file, static.

Needlessly aliased std::size_t to size_t (which does nothing but confuse
Eclipse), defined a non-existant function, and exposed a function which
shouldn't have been exposed.

We have four different implementations, one each for:

- no mutex
- C mutex
- C++ mutex
- optional C mutex

Unify them into a single template.  Keep the interface split so people
are forced to pass a mutex, and not some random locking primitive we haven't
tested yet.

Rather than polling.

Edge-triggered interrupts only, at present.

This allows us to initialize it a little later.

Lost during the romfs conversion.

We use a polling thread to collect characters and place them in a queue.

Polling only, no interrupt yet.

fo_read() and fo_write().

sys_read and sys_write used to malloc a 40-byte uio structure, and never
freed it. Fixed it by free()ing before returning from these functions.

object::unload_segments() had a typo - it called load_segment() instead
of unload_segment(). This obviously caused a memory leak.

Implemented a backtrace() function API-compatible with glibc's function with
the same name. I need it for the leak detector (to determine which allocations
come from the same call tree), but it can also be useful for other things, and
perhaps even used by some applications (I am guessing the JVM does not use it,
though).

My implementation uses the "_Unwind*" functions which are part of gcc's runtime
libgcc_s, so they are supposedly correctly synchronized with the way gcc actually
keeps track of the call hierarchy. If I understand correctly, these functions
use a cut-down version of libunwind which is included in libgcc_s. I also wrote
an implementation using libunwind directly (left in the code in #if 0), but
couldn't get it to compile because of library dependency hell.

Minor code simplification.

Avoids a zombie.

If we fail to match the file name, we need to release the buffer
before bailing out.

We drop the buffer and fetch a new one, but we forget
to return the new one to the caller for an eventual
brelse().  This results in an assertion failure later on.

Fix by making sure the caller sees the new buffer.

This allows running either testrunner.so, or one of the tests (e.g.
test/tst-fpu.so), as they now both export the same entry point.

Used when names in an object may conflict with names in other objects.

Python has no pointers, so it doesn't support %p.  Convert it to %016x.

Use:

  debug("foo %s %x\n", foo.x, foo.y);

Instead of:

  debug(boost::format("foo %s %x\n") % foo.x % foo.y);

note this uses boost::format, not *printf(), so size modifers ("%lx") are
unneeded.

This is only causing confusion; change all callers to add '\n' explicitly
and drop the optional argument.

Variable size trace records.

To conserve space, we now use variable size trace records.  To avoid problems
with wrap-arounds, and with recovering a complete entry at the head of the
ring buffer, we don't allow a trace record to cross a 4096-byte boundary.

When out of memory in alloc_page() or malloc_large(), we used to produce
mysterious assertion failures or aborts. Now print a more user-friendly
"out of memory" error (and abort).

To run the debug build, instead of "scripts/run.sh debug", use
"scripts/run -d".

With a ring buffer, we need to know the size before writing to determine
if we wrap around.