* 'master' of github.com:/avikivity/osv: (28 commits)
  dlfcn: implement dlopen()
  elf: fail gracefully if a file is not found
  elf: return the elf_object just added from add()
  pthread: implement pthread_self()
  libc: implement sysconf(_SC_PHYS_PAGES)
  memory: count up total physical memory
  memory: set up free memory from the boot loader
  boot: set up cfi for premain environment
  boot: set up initial stack in allocated memory
  build: link in all .bss sections
  apic: add apic driver
  mutex: add with_lock() function
  scripts: run without SDL display
  main: auto-load gdb script
  sched: switch main thread stack from original stack
  main: add thread test case
  sched: add simple scheduler
  msr: add rdmsr()
  msr: add missing inline to wrmsr()
  elf: add accessor for tls segment info
  ...

Needed for dlopen() (also export the program object for the same reason).

Currently the free memory pool consists of a statically allocated buffer.
Replace it with a dynamic query of the amount of memory we actually booted with.

(currently limited to 1GB since we haven't mapped anything else yet).

Terminate the stack so gdb doesn't get confused trying to unwind it.

The multiboot stack is not guaranteed to be anywhere in particular, don't use
it.

We didn't link in some sections, resulting in not all of bss being cleared.

x2apic only for now

This function allows executing a block of code under a lock, with a guarantee
that any exit from the block will release the lock.

Examples:

    with_lock(my_mutex, [&] { a += b; });

    return with_lock(my_spinlock, [&] {
        return my_list.size();
    });

We no longer put any useful information on the VGA device.

This way everyone's running on a similar sized stack.  Theoretically the
main thread can be destroyed as well.

Uniprocessor, non-preemptive, round-robin.

Describe all sections to gdb, so it can resolve data object addresses
correctly.

We currently leak a pool page, because we cannot unlink the free objects
belonging to the page from the pool's free list.

Fix by having a per-page free list (containing objects only from that page).
The pages are themselves placed on a doubly linked list.  When we identify
an empty page, we can now easily drop it since the local free list only
point within the page.

We kept pool::_free pointing at a freed object.  Naturally things did not
work well.

Fix by nulling the pointer for now, however this leaks the rest of the free
list.

Must be large enough to hold a free_object.

Pages allocated with alloc_page() have no metadata, so we must format the
header before returing it to the free range tree.

This avoids problems with multiple jvm versions (for example due to OS
updates)

gives more power and is more maintainable

* 'master' of github.com:/avikivity/osv:
  runtime: remove dummy 'operator delete'