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

from javascript.

it translate the arguments recieved from javascript, invokes the jni method
and return the exit code to javascript

expects to recieve a String[] array as an argument, invokes run_elf()
and communicates the return value by setting a static int of the invoking
class

Avoid duplicate elf objects by making sure paths are canonical.

This happens to fix a few "could not load libfoo.so", but not all of them.

other classes may need to read/write global javascript objects, the run
command which is going to be commited in the next patch deals with it

Fix error handling by using the error-safe fileref and fdesc utility classes.

The fdesc keeps a file descriptor safe from leaks, automatically closing
it unless the release() method is called (usually when the user is ready
to commit state).

This falloc_noinstall() works like the C version, except it either returns
a fileref (which automatically maintains reference counts) or throws an
exception (which means error handling can be consolidated).

The definitions conflict as soon as someone includes <sys/poll.h>.

While this is moving in the opposite direction we want to, this is the
minimal fix to get things to build.

Similar to thread's wait_until, but manages the wake up list using the
condition variable.

Because C++ doesn't like templates within 'extern "C"', those lines were
moved a bit.

This makes it useful in C++.

Absolute symbolic links refer to the host directory structure, while we
want them to refer to the external/ tree.  Since we have several trees,
we can't just rebase them, so walk down the tree trying to find a match.

Fragile and ugly, but seems to work.