Rewriten the mmap/unmap/mprotect to be much less repetitive.
There is a new "page_range_operation" class, from which the classes
"populate", "unpopulate", and "protect" classes derive to implement
mmap, munmap and mprotect respectively. The code is now much shorter,
less repetitive, clearer (I hope), and also better conforming to the
new coding conventions.

Note that linear_map is still separate, and page_range_operation keeps
its old algorithm (of starting at the root again for each page). Now
that we have this clean OO structure, it will be easier to change
this algorithm to be similar to linear_map's.

Java uses mprotect(..., PROT_NONE) for guard pages (e.g., to catch stack
overflow). This patch implements it by removing the present bit on these
pages' mappings, which does not mean the pages have been unmapped (their
memory is kept intact, and running mprotect again can make them readable
again.

some of the small pages were allocated twice and one was leaked).
Also, prepare mmap/munmap for supporting PROT_NONE in mprotect: instead
of relying on present-bit to say which pages are free, rely on the
information in vma_list, and double-check this (with assertions added)
against zeroing of the PTE when a page is freed.
I'll add support for mprotect(PROT_NONE) in a following patch.

Now that the context switch code is red zone safe, allow the compiler
to use it.

Due to the "red zone", stack operations may corrupt local variables.
Use ordinary moves and jumps instead.

Causes an early failure for some reason.  Disable until root cause is found.

Since that's what we build by default, that's what we should run.

fpu preemption

Test that preemption does not corrupt fpu registers.

Normal scheduling does not need to save or restore the fpu when switching
threads, since all fpu registers are caller-saved (so calling schedule()) may
clobber the fpu).  However this does not hold on preemption, so we need
to save and restore the fpu state explicitly.

Parse cpuid flag bits relevant to osv.

is not currently supported, and PROT_READ is used instead (i.e., instead of
inaccessible memory, one gets read-only memory). Inaccessible memory
complicates the code because it means using the non-present bit on
still-allocated pages, and then unpopulate() can't use the present bit to
decide which pages are allocated and need to be freed.
To fix this, I'll need to:
1. unpopulate_page() and unpopulate_huge_page() should assume it is only
ever called on allocated pages (evacute() actually ensures that!), and not
return on non-present ptes.
2. change_perm() should use the read_perm to set the present bit.
3. protect() shouldn't rely on present bit to know when to return 0 or 1,
   rather it must be wrapped in something like evacute() which knows to
   find mapped ranges, and only call protect() for actually mapped ranges.
I'll try this tomorrow.

the version at the time of commit. Git is overrated :(

implementation of both was completely broken - not only did evacuate()
never free the physical memory backing the removed mapping, it was
sometimes even called with wrong parameters ;-)
Added tests to check that some of the mmap/munmap combinations no longer
leak memory.

The JVM calls these when running Volanomark.

Also improve debugging of unhandled getrlimit cases.

just like most libc implementations.

We don't use syscall except for gettid which is called directly by java.
If we are going to implement these they should be direct API functions.

Noticed by Nadav.

and instructions on how to run bench.jar

and also to the "osv thread ..." command, you can now use in addition
to the thread's address, also its id - e.g., "osv thread 44" will
go to the thread with id()==44.