Update contributors.md
First version of cbufp.  Does NOT work, but maintains backwards
compatibility with tmem cbufs without performance degradation.  All
unit_* and micro_* scripts still work.

Next steps are to add runscripts for testing cbufps, and continue with
development.  The limitations are below, and they need to be phased
out.

1) created the cbufp component.

2) changed cbuf.h to include both cbufs and cbufps.  Calls to the
   separate back ends are made by simply using conditionals in the
   code, and setting the variables that change the conditions in
   outer, static inlined functions.  Relying on function inlining,
   constant propagation and dead code elimination to maintain native
   performance.

3) The cbufp component is dependent on the cbuf component as it uses
   cbufs to deliver the list of cbufps to the client that it can use.

4) Limitations of current code:
   - Only works for <= PAGE_SIZE allocations
   - Does not do intelligent allocation of the number of required
     bufps.
   - Does not do intelligent asynchronous garbage collection (by
     setting RELINQUISH in the cbuf_meta).
   - Does not currently integrate with the memory management of the
     system at large.  Does not integrate with any policy component.
Merge branch 'master' of github.com:gparmer/Composite
Next installation in persistent cbufs:  cbufp.

Fixed bugs including the proper initialization of cbuf_metas, the
proper coordination between cbufp_collect and cbufp_create, and proper
indexing into the meta structure (from 0 not -1).  Added tests for
cbufp.  Got the performance down to cbuf levels.

The micro_cbuf tests include cbufps now and performance is as expected.
Added user-level handers for the divide-by-zero fault.

Other fault handlers can easily be added by following the
divide-by-zero fault handler's example.  They can be added to the
faults inteface, and implemented in the stack trace fault handler.

This was added in expectation that the fault tolerance work will
require invalid instruction, stack segment errors, etc... exception
handlers.  This should make adding those easy.
appnexus meeting notes update
First phase of loading improvements:  partial cos_loader->generic section loading + non-partitioned mem{cpy|set} to initialize components.

1) First phases of adding a generic mechanism for adding new sections
to the loading process.  Will be used in phase 3 (thereabouts) to add
initonce sections, and in phase 4 to add a kernel-mapped section.
Later, we can add the .cons and .dtor sections, etc...

2) In the composite booter, we used to do memcpy and memset page at a
time.  This slowed down the processing as it messed with the
processor's prefetcher.  Much better to simply memcpy or memset the
entire section we are trying to initialize.  This is done in this
patch.  Note that one wouldn't typically care to optimize this, but
when we want to do fast component micro-rebooting, it matters.

3) I moved the cos_component.c library file from a library-loaded
file, to a manditory-included file.  We assume that all components
have a cos_comp_info page.  TODO: remove the scheduler notification
page from this, and place it in scheduler-specific manditory-include
library files.  This will save a page per component (of kernel-shared
memory).
Loader improvements intermediate phase.  Tediously going through the
load_service function and first mimicing the current code with that
which uses the new cos_section structure, and then migrating that to
code that does it the right way.  Because of this, I'm writing two
times as much code as I'd expect, but it is the only way to debug.
Another intermediate commit that enables more intelligent population
of component address spaces.  All addressing in the booter is now done
relative to the start of the vas region/booter memory buffer of
aliased pages.
Yet another partial phase toward the loader being sane.  Have broken
up TEXT and RO, but not yet into separate cobj sections.
Another inter-phase commit...now we initialize all sections in a general loop (finally)
Phase 2 of loader improvements done: general creation of objects from
a sections specification.

- The actual creation of objects is done through loops through the
  section specification.

- The sections specification includes all possible sections, which are
  created for each objects, but actually result in real memory being
  used on when that section is present.

- The size and address specifications are generated programmatically
  rather than in a hard-coded manner.

- Code is now cleaner and easier to understand.  load_service is
  actually hackable now.

TODO: remove special cases of the non-composite-booted components.
Just produce cobjs for all of them and later load the memory manually.
Phase 3: Add the initonce sections for the simple stacks, and added
support to only initialize that memory when first loaded, not on
reboot.
Added documentation on the chal
Remove the scheduler notifications page from non-schedulers.

Previously the `cos_sched_notifications` page was a manditory part of
every component.  This blew up the BSS by a page.  Not the end of the
world, and we've avoided caring about it up till now.  However, this
will add the cost of zeroing out a page for recovery of
non-schedulers.  We'd like to avoid this if possible.  This commit
removes it, and instead adds a `cos_sched_ds.h` file that includes the
data-structure itself.  Almost no component should have to include
this manually as if you're writing a scheduler, you should inherit the
scheduler interface which will include it automatically.
Added new object sections including ctor, dtor, crecov, and cinfo.  Also included support for using these sections (i.e. placing functions pointers in them).

See cos_component.h for CCTOR, CDTOR, and CRECOV to set a function as
belonging to one of these classes.  If it is constructor, then it will
be called on bootup before cos_init.  If it is a destructor, it is
currently not called.  Jiguo will need to add support so that when a
recovery upcall is called, it will invoke the recovery handlers
(i.e. this is used as a notification of needed recovery.

If you define your own cos_init, then you should call
constructors_execute yourself.
Added logic for two new sections:  .cinfo (the component information page), and .kmem (data-structures that must be kernel-visible).

The cinfo section is used to find the cinfo page.

The kmem section is currently not used, but will be (e.g. by John) for
identifying which pages must be kernel visibile (e.g. user-level
capability pages, scheduler event notification pages, etc...)
Phase 1: Making the composite hardware abstraction layer (chal) explicit.

Goal: move all platform specific code from hijack.c and kernel/*.c
into kernel/include/chal.h (prototypes), platform/include/chal_plat.h
(static inline functions), and platform/linux/module/pgtbl.c (and
others, for globally visible functions).

Moved all page table specific code to pgtbl.c in hijack.  Started
moving functions into chal.h and changing their names at all call
points.
Phase 2: finished chal-ing page tables, address translation, and memory allocation

Nothing fancy here...just refactoring.
More chal migrations