eventually causing a suspicious segfault.

Now if I can get it down to 32 bytes...

class-static variable, which is not only strange, it also means we
cannot concurrently run several programs in several threads.

Change it so run() returns the (32-bit) return value, and when execution
fails (e.g., file not found), it throws an IOException.

Note that unlike Unix where main()'s return value is limited to 8 bits,
here we decided to allow the full gamut (63-bit) of return values from
main(). main() may return -23 or 2323813 and this does not indicate
an error running it (only an exception indicates an error).

This patch also removes the arbitrary limit of 256 command line arguments
(not that anyone would need more...).

All Java tests need to implement the Test interface and be registered with
TestRunner in order to be available to the test cli command.

TCPEchoServerTest is no longer accessible from javascript, instead, TestRunner is
now the interface of JS for running tests.

note: this class is not yet used by the CLI and will be used in a following
patch

We leave out the taskqueues running in software interrupts (OSv doesn't have
this concept and most likely never will), as well as those having timeouts
(we can add those once needed)

kthread are implemented on top of pthreads for now as they give us
a thread identifier easily usable from C code.

split cloudius.jar to cloudius.jar an cli.jar
the following patch will introduce proper code reusing between the two jars
basically, cli.jar will be dependant on cloudius.jar

we're about to split cloudius.jar into 2 jars:
1. cloudius.jar - holds various utils and interfacing jni
2. cli.jar - wrappers needed for the cli, commuication of js<->java

per Nadav suggestion.

e.g. tst-foo.o when building tst-foo.so

Implement some noisy stubs.

Improved path and RPATH handling.

Record the guard size in the thread attributes, and mprotect() that bit so
the user cannot overflow the stack.

Record stack size in pthread_attr_setstacksize(), and use it when creating
the thread.

We want the size as well, to be able to munmap() pthread stacks.  Pass the
entire stack_info so we have this information.

Clean up the lockfree/mutex.hh code. This introduces no new algorithms or
major bug fixes - what was blocking the lockfree mutex from working were
mainly preemption bugs and a bug in the lockfree queue implementation.

Also introduced a test for the mutex variants (mutex, lockfree::mutex and
spinlock) - several threads do a non-atomic increment to a shared variables,
and unless a mutex is used, the sum ends up being wrong. The test seems to
be working correctly, and also exercising the interesting cases of the code
(the "responsibility hand-off" protocol), but does so very rarely, so we'll
still need more testing before we can fully trust this new code.

The test also begins to do performance testing on the mutex variants.
uncontended lockfree::mutex is currently twice slower than uncontended
mutex, so some more work is needed in this area.

Added constructor to the "spinlock" type (#include <osv/mutex.h>) when
used from C++. This makes it easier to use this type from C++.

Marked constructor as "constexpr" to allow the object to be constructed
in compile time (e.g., a global spinlock variable can be initialized in
bss). Thanks Avi for this trick!

program::add_object() somehow got 3-byte indents instead of 4-byte.  This
has no effect on x86, which allows misaligned loads, but could cause
exceptions on other architectures.

Fixes "could not load libm.so.6".

If we're looking for a module by its soname (rather than a path), first
perform a search in case it's already loaded.

Fixes "could not load libjvm.so", as libjvm.so is not on RPATH or the default
path, but is already loaded anyway.

Some libraries have an extra search path, use it.

Squelches some "could not load libfoo.so" messages.

Spotted by Nadav.

executes external elf files such as the tests

note that the communication between js to java is done via
global js variables because of a shortcoming in arguments passing,
not capable to pass a String [] for example