stack, even if we don't yet print it out.

At some point, vsprintf() needs to be fixed up so that it can correctly
cope with limited-sized buffers (i.e. vsnprintf), long longs, and
standard format specifiers (e.g. "%04x").  We should also remove the
special types (MAC addresses and IP addresses).  This would then enable
us to use gcc's ability to type-check printf format strings.

interrupts hooked.

devices).

implementation.

Moved to net/

Add method for hooking real-mode interrupt vectors.

Use .text16.data section with "aw" attributes, to avoid section type
conflicts when placing both code and data into .text16.

Add __from_{text16,data16}.

Avoid optimisation errors under -fstrict-aliasing.

between the low half stored in the static variable rm_sp, and the high
half stored on the prot_call() stack, because:

  Just using the stack would screw up when a prot_call()ed routine
  executes a real_call(); it would have no way to find the current top of
  the RM stack.

  Extending rm_sp to rm_esp would not be safe, because the guarantee that
  rm_sp must return to the correct value by the time an external
  real-mode call returns applies only to %sp, not to %esp.

interrupt vectors, for example, will be easiest to handle if placed in
.text16.

from protected-mode code.

Set up %ds to point to .data16 in prot_to_real, so that code specified
via REAL_EXEC() and friends can access variables in .data16.

Move most real-mode librm variables from .text16 to .data16.

.data16.  librm will need to supply "char *data16", i.e. the virtual
address of the start of .data16.

portions such as the stack) during the installation process.

init_fns() are called from main().  We need to think about initial
control flow some more.

install_prealloc.  I *think* these will suffice for all the 16-bit
prefixes.

However, it's worth adding a .size directive so that objdump reports the
correct sizes for the code fragments.

advantage of the fact that we have to have a permanently-resident block
in base memory.

setup.S.

highmem data, so decompress16 will be able to unpack blocks bigger
than 64kB.

running the decompresser in 16:16 protected mode using the real-mode
stack.  However, there's an even simpler way to do it...

closed() method with a reason code.

connection and so legitimately ignores acked() and senddata().

compile, even if it won't yet be safe.

take ownership of the packet, rather than doing so only if they return
success.  This breaks semantic compatibility with Linux's
hard_start_xmit() method, but means that we don't have to worry so much
about error cases.

Split mechanism of processing received packets (net_rx_process()) out
from policy (net_step()), preparatory to putting net_step() in a separate
object.

Yes, you really can do it in 65 bytes.