drop copyf8 and hack it from go.

we're still doing a copy that we could probably avoid, but this
seems to be good for now.  surprisingly, this doesn't show up as
the dominant component in traces.
get rid of lots of prints / switch them to a Channel.

printing so much can really slow things down.
fix memory leak in heat transfer test program.
set global properly up front.

some code in 'mallocs' needs it, now; just set it up top and thus
be sure it'll be set before we get started.
debug: print out *what* failed out opening in error.

hard to diagnose why it failed to open, otherwise.
bfd: delete some dead code.
Make sure allocations always take up a whole page.

This fixes an error when writing data in the 'heat' test program.
The issue was that we allocated, say, 100 bytes for the data in
the program.  But then fopen / fwrite / etc. would do allocations
internally, and because our allocation was so small, the system
would share the new allocation with the page we used for tracking
the data allocation.

Since we protect things at the page level, we'd protect both the
data AND the internal allocations that libc would do.  But then
when the code inevitably segfaulted, we would look at the address
and think it was a real, actually-buggy segfault, because the
address was not within the data the user allocated.

This fixes things by rewriting allocations to always allocate data
in multiples of 4096 bytes (i.e. a page).  By doing this, it means
the system can't re-use memory from a previous allocation and thus
have a single page used for multiple "things".  In 'heat', the
internal fopen/fwrite/etc. allocation might immediately follow the
data allocation, but now it'll be guaranteed to fall on the next
*page*, so our data protections won't effect these internal
allocations.

Of course, this introduces some internal fragmentation to memory
that would not exist if running the program 'bare'.  We deem that
acceptable.