Call the new poweroff() function after the payload finishes running.
Makes sense on a cloud (why would you want to pay the provider after
your workload is done?) as well as for our benchmarking, where we want
qemu to exit after running the benchmark.

When the "--leak" option is used, instead of calling poweroff(), we
call hang(), so that QEMU continues to run and we can attach the
debugger to run "osv leak show".

Note that before this patch, if the payload spawned threads, they could
continue running after the payload's main() return. This is no longer
the case - after main() returns, the entire virtual machine is shut down
(or just hung). This is reasonable behavior, though: If the payload needs
some threads to continue running, it should join() them before returning.
The behavior on Linux (and Posix threads in general) is identical to our
new behavior: When main() of a multithreaded program returns, all threads
are killed.

Use the generic one instead; the cleanup function allows destroying
the pthread object.

Somehow this worked by accident, but we need to zero the .tbss section
or random data will be used to initialize it.

fontconfig.so is loaded without a fully qualified path; it expects the
search path to be used.

Added to the loader a command-line option "--leak" to enable the leak
detector immediately before running the payload's main(). For example, to
look for leaks in tst-fpu.so (there are none, by the way ;-)), do

	scripts/imgedit.py setargs build/release/loader.img --leak tests/tst-fpu.so

and when it ends, look at the leak detection results:
	$ gdb build/release/loader.elf
	(gdb) connect
	(gdb) osv leak show

Unfortunately, this doesn't work when the payload is Java - I'm still trying
to figure out why.

A pthread created with the attribute
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
Does not need to be pthread_join()ed - and its resources, most importantly
its stack, should be deleted as soon as it is done.

Previously, we ignored this mode, causing its users (Java uses it for all
its threads!) which do not ever pthread_join() on these threads, to leak
the threads' stacks.

This patch adds support for this mode, and adds a test to tst_leak.cc
which verifies that before the patch, we had a leak, and now we don't.

Unfortunately, this patch is a bit ugly, and I was surprised how much time
it took me to actually get it to work :( Because of the convoluted
relationships between pthread_*, pthread_private::pthread, sched::thread
and sched::detached_thread, I ended up, after many rewrites (!) duplicating
the "reaper" code from sched::detached_thread to do something very similar
for detached pthreads. I.e., when a detached pthread finishes, it can't
pthread_join() itself (which would cause a mess as it destroys its own
stack) so instead it tells a different thread, the "reaper" thread, to
run this pthread_join().

In the future it would be nice to create one generic "reaper" which
is used by both detached sched::threads and pthreads, or even find
a way to allow a thread to pthread_join itself as its last action.

This allocator works by giving each allocation its own virtual address
range which is not reused for later allocations.  After a free(), the
range is made inaccessible, forever, so use-after-free will result in a
page fault.

Sub-page overruns are also detected by filling unallocated space with a
pattern, and checking whether the pattern has been altered during free().

Early code may enable interrupts and get hit by a spurious interrupt.

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.

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

Edge-triggered interrupts only, at present.

Minor code simplification.

Avoids a zombie.

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.

usage: --trace=a,b,c,*foo* --trace=bar java.so ...

Will match on tracepoint names.

Driver enumeration requires instantiating a driver even for devices which
are not present; and if a device is present multiple times, we need to
pre-create multiple driver instances, which is awkward.  Further, driver
life-cycle is complicated, with separation between instantiation and binding
to a device.

Switch (back) to the traditional device-driven model, where we iterate over
all devices, try to find a matching driver factory, and when found, call it
to instantiate the driver and bind to the device.

The main thread has a bogus wait_for_interrupts() which consumed wakeups,
so the scheduler on the cpu running it could not schedule stuff.  This
manifested itself in lots of zombies from bsd callouts not getting reaped.

Drop.

Make sure sched::tls is initialized before we create objects of type 'cpu',
so that any threads in those objects (idle thread, etc.) are initialized
correctly.

See README for instructions.

Wastes power.

Add a detached thread class (with a private destructor, so it can only be
allocated on the heap).  The implementation uses a reaper thread to wait
until the detached thread is dead, and then ->join() and delete it.

reduce the verbosity

Running tests is now done by editing the command line in build.mak

This will allow running unmodified tests with a main() entry point even
after splitting the test loader out of the kernel.

Interferes with the scheduler

So it doesn't interfere with the scheduler

The tests themselves didn't change and all the changes their are just
changes of namespace usage and variable movement.

This makes it easier to create a thread with no special properties.

Run 2 threads, one allocated mem, the other deletes the allocation.

This makes it easy to configure a thread with various parameters.  The first
is the existing stack_info parameter.