Without this we get errors reading/writing from larger imageṡ.  Our current
10g usr.img actually is enough to trigger this, but our lack of error handling
papered over it so far.

Once all the bugs vs I/O error handling in virtio-blk are fixed we'll
actually need this.

Disk alloc is a simple function that, well, allocates a disk. It is supposed
to be provided by the device code, but for simplicity I am providing it in
blkfront itself. We have no really better way to put it: device.c is quite generic,
and we seem to have no disk specific file.

If time brings us more users of such function, then I will move it somewhere else.

Xenbus will use BSD taskqueues in the following way:

  taskqueue_enqueue(taskqueue_thread, &xbs->xbs_probe_children);

taskqueue_thread seems to be the main bsd taskqueue, which wasn't ported in our
initial port. So I am definiting it and initializing.

It seems a bit odd to do this in net.cc, but this is where the rest of the BSD
initialization lives anyway (maybe the filename should change?). Let me know if
you feel strongly about it, and I will change. But for me it is okay for now.

BSD devices will use more state than we currently have. Extend the current
device to cope with that.

BSD uses more flags than we define. This patch defines the aditional missing
flags.

Those are the verbatim files, straight from BSD.

BSD register a structure with its per cpu data. We can do the same, using
just the fields we need.

Here are some compile-time definitions that will make importing of BSD code
easier. They should be straightforward and trivially true for our current
setup: x86_64 is our current arch (and when we support others we can just replace
the static -D__x86_64__ with a test that goes precisely here, it makes no sense
to support code that is not SMP, and the id string is included by pretty much
every BSD file - and I believe we have no interest in that.

Xen BSD code will attempt to create processes to serve as deamons for xenstore.
We can basically emulate this by creating threads.

The only thing I am doing differently from the already existent thread creation
layer that we have, is that callers will expect a struct proc to be returned. We
had this as a stub, now I am creating a small struct with just the PID to serve
as a return placeholder. The listener processes in xenstore never dies, so I am
not implementing a deallocate routine for them

bio queue is the name used by BSD. Since it is just a name difference,
I would better change our code, since there are few users (only ramdisk),
than to patch all code I am importing from BSD that uses it.

We take the write version instead of the read version when locking.
Unlocking is fine

__attribute__((cold)) on labels isn't supported by gcc 4.7.  Detect support
for the feature and enable it conditionally.

When netperf is executed, there is high demand for pages.
Here is a table of values for the max constant and the matching
netperf results:

buf size  Throughput Mbps
1024     16700
 512     16800
 256     15500
 128     14500
  64     13680

kvm pveoi support

The feature allowing reuse of an inherited constructor is not available
on in gcc 4.7.

kvm provides a way to EOI without exiting; detect its availability and use it.

Works with xapic, and allows us to hook eoi().

kvm's pv_eoi functionality fails if any vmexits are taken before the EOI
(likely due to a bug).  Work around this by deferring the handler until after
the interrupt has been EOIed.  Since level-triggered interrupts must be acked
at the device level prior to the EOI, add an additional handler to be called
prior to the EOI.

Make sure percpu data is aligned correctly as some hardware features expect it.

RhinoCLI relied on a bunch of global Java variables such as _cx and _args.
This was not only ugly, it also prevents us from running multiple instances
of the CLI on the same JVM - e.g., to support multiple telnet connections.

There isn't actually a need for these JVM-wide global variables. At most,
we need to global use variables in the Javascript interpreter (so each
instance of the interpreter would have its own copy).

This patch puts main's arguments in a new global-per-javascript-interpreter
variable "mainargs" instead of the global-for-entire-JVM _args. "_cx" isn't
needed at all: one of uses was to for Java to convert a String[] into the
equivalent Javascript alternative - but Java should just return String[]
and let Javascript worry about handling that (it seems to work just fine
without change). A second use was for returning an exit code, but a more
appropriate methods to do the same thing without global variables exist.

Based on FreeBSD virtio code
Provides a x7 boost for rx netperf

allows the dhcp worker to see incoming dhcp packets using a simple hook.
no reason to make this kind of hook generic (a BPF alternative) as there
are already many protocol specific hooks in the networking stack.

if we ever need to do more hooking, the pfil interface may be used or we
can implement a generic solution, but it's not reasonable to do so for
a single user (dhcp).

Use DHCP to discover an IP address per each interface, DHCP packets are being hooked
in the networking stack in ip_input and queued for deffered processing using a
dhcp worker thread. Sending dhcp packet is done directly over ethrernet (building
IP and UDP).

There's still alot to be done: setting up lease time, timeouts, more error handling
but it's possible to implement these later on.

Facilities for capturing call stack on arbitrary tracepoints.

New command: 'perf callstack <tracepoint>'

Although we are not expecting to have many interfaces, it is still useful
to print the interface name when we fail to set its parameters. (For starters,
we may very well have plenty, and it is also good for debugging)

Replace the lambda-based with_lock API with a block-based API.