move have more work mark before the handler, during the handler execution
another thread may signal the netisr worker thread, avoids a race.

SOCK_RAW should be used with sosend() and not sosend_dgram(),
same for soreceive_dgram()

The bufring was never used by any driver in OSv so it's
not useful

tst-leak.so now enables leak detection, runs a few things of interest,
and disables leak detection. So "osv leak show" after running this test
will show any leaks. I'm using this to confirm fixing the leaks I'm now
trying to fix.

We want to reschedule if we woke a local thread, since it may have higher
priority than us.  However commit 31572c85 broke this by changing the
preemption counter.

Fix by adjusting the check to take this into account.

Noted by Nadav.

Saves ~17MB.

handle_incoming_wakeups() may not be called from preemptible context,
since it manipulates per-cpu variables.

Fix by eliminating these calls.  In one call site, the call is removed,
since it will be called immediately afterwards with interrupts disabled.
In the other call site, push the call into an existing irq disabled region.

Fixes livelocks where a thread is placed into an incoming_wakeups queue
but has the wrong bit set in incoming_wakeups_mask.

Since wake() manipulates per-cpu variables, we need to disable preemption
so the cpu pointers aren't invalidated by migration.

The recording mechanism aligns trace messages; replay needs to follow suit.

Without adding this check, if you change the command line with to run
file.so which doesn't exist, it would start using random garbage in
memory and fail in mysterious ways. Better just let the user know we can't
open the specified program.

Added rudimentary support for leak detection. When memory::tracker_enabled
is true, an alloc_tracker object (see alloctracker.{cc,hh}) object keeps
track of still-living memory allocations and the call chain that led to each.
Using a new command in gdb, "osv leak show", a developer can analyze the
remaining allocations, with the aim of finding memory leaks (noticing that
memory leaks often result in repeptitive allocations from the same call chain).

This implementation is a good start (and already found 8 leaks in our code),
but it's far from being perfect. It severely slows down the workload, the
analysis in gdb is not yet friendly enough (requiring manual inspection to
look for the more serious leaks), and the backtrace() implementation also
appears to be fragile: In more than one occasion, we noticed a yet-unexplained
crash when backtrace() unwinds the stack, calls dl_iterate_hphdr() which throws
exception and unwinds the stack again. So this code will probably need more
work in the future.

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.