add an experimental version of mt-vlcmd, and a dummy mapperd

also fix xprotocol.h and change mpeer interface

split signal initialization into local and remote part

fix xseg_pthread user driver {prepare, cancel} wait

add mt-peer skeleton plus mt-sosd, dummy peer.

also expose peer init signal through xseg api,
as needed by pthread peers

do some code clean up. fix xseg callback to only take portno as argument

make drivers respect xsegbd's {prepare, cancel}_wait

fix xsegbd to use req->priv pointer instead of xseg_{get,set} req data

fix xseg request preparation bug

add debug messages, and fix a xheap bug

fix xsegbd to work with the new scheme. needs further testing

also fix xhash shrink bug and xpool exports

fix xsegbd based on the new allocation scheme

fix xsegbd to compile

add pthread kernel driver

add pthread user driver

fix filed, xseg tool to use the new xseg api

add xseg {get,set} req data

initial commit for xpaths code

add max allocated reqs per port. also some other minor fixes

make xheap use a more complex indexing system

xobj: keap xheap chunks instead of each object in allocated hash table

also add additional book keeping info

add support for resizable queues

also fix heap index bug

small fixes in xseg-tool , filed

fix xsegbd according to the new allocation scheme

fix xhash to compile in kernel. also removed numerous compiler warnings

make default reqs per queue a definetion instead of a hardcoded value

remove unneeded {alloc, free}_request functions

make bind port reuse previously unfreed port

add makefiles for xtypes

fix xseg-tool rnd functions to check for error on submit

also changeg type of xqindex to uint64_t

fix remaining bugs from old code

add xtypes to kernel makefile

fix xseg-tool. temp fix to other peers, just to compile

make xhash request for less allocated space

fix filed

added necessary compiler memory barrier to xlock_release

also some makefile fixes

fix numerous compile errors

modify Makefile to include new xtypes

add portno to port struct

fix the way drivers get xseg port

rewrite remaining xseg functions with the new allocation scheme

write more xseg functions based on the new scheme

rewrite xseg initialize skeleton

also some other minor modifications for the new scheme

move heap, obj outside of xseg and make them xtypes

also added absolute pointer manipulation macros to sys/util.h

Merge branch 'xseg-refactor' of ssh://ray/repos/archip into xseg-refactor

sketch for CAS/atomic helpers

seperate malloced struct xseg from mmapped segment

fix obj_h in segment initialization

also replace mistyped xseg_put_request with xseg_put_object
in xseg_put_port

work in progress: xseg allocation, xseg ptr free

also added xlock_try_lock functionality

make code compile. no validity checks

lock owners are unimportant for the time being.
kernel lacks xhash support

initial code commit in data structures

* moved xq folder to xtypes
* moved xq_lock.h to xlock.h
* added xhash
* added xpool
* added owner to xlock
* added lock free versions of xq functions

add explicit non-interactive mode to envsetup

remove obsolete peer blockd

add some verbosity to peer driver locating

enhance helpers, merge with xseg_setup into launch

util_libs/user: Add clean target in Makefile

peers/user: Python 1-1 Mapper

sys/user: Python xseg bindings

xsegbd: Fix a build error after a failed merge

xseg: Export xseg_finalize()

peers/user: Add vlmcd/mapperd in the build system

peers/user: 1-1 Mapper peer (mapperd)

peers/user: The Volume Composer (vlmcd)

Rename typedef'd None to Noneidx

Rename None to Noneidx to avoid (future)  conflicts with xseg python
bindings.

xsegbd: stricter error checks

temporary hack to compile misunderstood code

purge unused variables

C99 compliant __VA_ARGS__ handling

kstrtoul to strict_strtoul for old kernel support

peers/xsegbd: Possible NULL ptr deref in release

peers: Some changes to xseg-tool submit_reqs/complete cmds

doc: Basic commands to test xsegbd/vlmcd/mapperd/filed end-to-end

xseg-tool: Add submit_reqs cli option

xseg: some 'perfcounters' cleanup/changes, and a possible out-of-range index fix

drivers/xseg: Fix signalling for posix peers

 * tkill was called with the arguments in reverse order: (signo, tid)
   instead of (tid, signo).
 * Increase the timeouts for xseg_signal, now that signalling actually
   works. We could as well get rid of the timeout completely.
 * kernel peers could never signal posix peers, since xseg_posix
   driver/module for segdev peers was never built and loaded.

tools: Fix some errors after the name to target renames

(Need a lot more fixes to bring the up-to-date with the new code)

doc: Start documenting xseg terms and operation

xseg: Add some perf counters (request rtt/latency)

xseg: Rename req->name to req->target in xseg_request

Rename req->name to req->target in struct xseg_request, and change
buffersize/namesize/datasize to bufferlen/targetlen/datalen
accordingly.

Also clean sosd

zero out rest of data buffer on end of file

Merge branch 'sosd' into demo

Conflicts:
xseg/peers/Makefile

'Ported' the sosd peer and libsos to the new repo layout and build
system. Also fixed some sosd issues with the recent changes in xseg
API.

xseg-tool: Add req logging support for bridge mode

Add resize support in xsegbd/filed-blockd/vlmc-tool

xsegbd: Make sysfs add/remove more robust

Use a separate spinlock to serialize access on the dev list, instead
of the sysfs/bus mutex, and make sure the device is not removed from
the dev list too early.

The change was 'ported' from Alex Elder's patches for the rbd block
driver.

extstorage vlmc scripts refactoring

Initial import of the ganeti extstorage vlmc scripts

Various fixes to make xseg functional again

 * xseg:
- Make sure the allocated xseg struct in xseg_join is initialized
  correctly
- Initial implementation for xseg_leave()
- Add __lock_domain in xseg_destroy()

 * driver api:
- Add a struct xseg * argument to xseg_operations->map(). It's
  passed to the driver when a peer joins the segment, and it's
  used by xseg_segdev kernel driver (for the initialization of
  xsegments[] array).

 * drivers/kernel/xseg_segdev:
    - Use struct xseg * segdev_map() to initialize the xsegments[]
  array.
- Some minor fixeds

 * sys/segdev:
    - Fix wait_for_event_interruptible condition (this fixes an issue
  with xseg-tool not being able to destroy segdev segments).
- Correct the use of segdev_get/put() in various places.

 * build system:
    - Add distclean target, which cleans lib/user and lib/kernel dirs.
- Fix the clean target in sys/user dir.
- Temp exclude of the vlmc peer (it doesn't compile)

 * tools:
    - Modify the helper/setup/vlmc scripts, to work with the new
  repo/code layout.

 * xsegbd:
    - Minor fix in xseg_callback() (xseg_receive() wasn't fixed after
  the refactoring)

FIx .gitignores for the new build system

Merge remote branch 'origin/xseg' into demo

Conflicts:
xseg/tools/vlmc-blockd.py [trivial]

Fix rc file parsing for the vlmc python tools

Improve error handling for xseg setup scripts

remove spurious include paths from compilation

Merge branch 'vlmcd-as-blockd' into xseg

Conflicts:
xseg/peers/Makefile
Fixes:
fix target autodetection in base.mk
fix issues with vlmcd, still does not build

README placeholder files for lib/ directories

Introduce execution domains in code and building

Only fixed to compile. Untested.

Lots of refactoring, cleanup, and fixing in the process.
This log has three parts:
1. What are execution domains and why we need them
2. What are the API incompatibilities introduced
3. Issues that were discovered in the process,
   and how they were fixed, or how they need fixing.

Note that there are many changes not documented in this log.

1. Execution Domains.

The execution domains are simply the different environments where
the xseg library, drivers and peers are compiled and linked in.
Currently there are two domains, 'user' for userspace processes,
and 'kernel' for kernel modules. The rule of thumb is that if you
need to compile it differently, then you need a new execution domain.

New domains could be introduced, for example,
so that xseg runs inside a hypervisor, another OS/arch, or even
to have two different implementations of xseg run together.
Until now, the kernel domain was all stuffed in sys/,
domain, drivers, and peers together.

The new repository layout defines domains nicely:

sys/${DOMAIN}/    ->    domain specific support code
drivers/${DOMAIN/ ->    drivers available to the domain
peers/${DOMAIN}/  ->    the peers that execute in the domain
lib/${DOMAIN/     ->    built libraries, modules for the domain

The kernel domain has been split into four parts:
a. the xseg.ko library kernel module in sys/kernel.
   (this includes the domain support code in xsegmod.c)
b. the segdev.ko (renamed from xsegdev) character device in sys/kernel
   (this could be part of the driver, but is generic enough
    to be included into the domain to be generally available)
c. the xseg_segdev.ko segdev segment and peer driver in drivers/kernel
d. the xsegbd.ko segdev peer in peers/kernel

Similar is the layout for the user domain.
The domain support code is in sys/user/xseg_user.c

The domain support code finds out what it must implement in
various "domain.h" files in the tree, currently:
xq/domain.h
xseg/domain.h
sys/domain.h

2. API changes
==============

i.   xseg_initialize() no longer takes an argument.
     Instead, the type of the peer is decided at xseg_join().
     This way a program may implement more than one type of peers
     (in the same, or different segments)
     xseg_initialize() is only for library initialization.

ii.  xseg_join takes two more arguments:
     a. the name of the peer type to be initialized
     b. a callback function for fully asynchronous peers,
        such as xsegbd, who can never sleep in wait_for_signal()
        This callback is just registered by the library;
        if the driver does not call it, it will never be.

iii. xseg_wait_signal() no longer takes a portno argument.
     This was a mistake.
     The sleep is intended to be as generic as possible.
     Ideally, the library (through the domain support code)
     should offer a wakeup method in all possible ways
     (e.g. from other peers as with xseg_signal(),
      from the peer context e.g. with select() in user,
      or waitqueues in kernel, signals, timers, ...)

      Right now, the peer has to schedule its wakeup
      by using xseg_signal on itself from another context,
      or by exploiting the same mechanism that the peer driver does
      (e.g. SIGIO)

Deeper in the library, the driver interface for signaling was changed
so that functions take the full segment descriptor plus the portno,
rather than just a pointer to the port.

3. Issues
=========

* Kill security.
  Any peer signaling a segdev peer can send SIGIO to any process in the system.
  There is no infrastructure for signaling security.
  The segment could be limited to a specific uid, so that
  all peers must be run as this user,
  and all kills are made as (with the permissions of) this user.

* Killing threads.
  Posix driver for kernel and user domains kills specific threads with SIGIO,
  and not processes. Before this commit, the kernel driver killed threads,
  while the user driver killed processes.
  It is trivial to change the behavior to one or the other, if we need to.

  Killing processes has the advantage that a multithreaded user peer
  need not have a master peer that will accept and dispatch work.
  The kernel will send a waking signal to one of the sleeping threads.

  However, killing threads provides more flexibility,
  while it can emulate the other way:
  All threads when sleeping, they register the id of the master thread,
  so at all times, only the master thread receives signals.
  Then, the master thread can kill the process and emulate
  a process-killing signal.

  Currently, the posix driver registers the id of the thread
  that initializes the library as the master thread.
  Fine tunings will probably be needed for this to work correctly.

* Callback design & code cleanup.
  xsegbd cannot sleep. So may other peers in the future,
  or so we might decide to implement some otherwise sleepable ones.
  prepare/cancel_wait() and wait_signal() are not used by such peers.
  Instead, a callback is registered at join,
  which takes a segment descriptor and the signalled port as arguments.
  The library only registers the callback in the segment descriptor.
  It is up to the peer drivers to schedule its call upon signaling.

  In the case of xsegbd, the peer driver (xseg_segdev) utilizes
  the kernel domain support character device (segdev).
  The userspace segdev driver calls the kernel segdev driver through
  /dev/segdev, and the kernel segdev calls the xsegbd-registerd callback
  through the xseg descriptor.

  Currently there is support for only one segdev character device,
  and only one kernel segdev peer, but the design is easily extensible.

  xsegdev was renamed to segdev.
  Notice that in the whole segdev code there is no reference to xseg
  (thus the rename). Segdev is considered an independent utility
  that supports the kernel domain.

* Make will pass V=1 to kbuild, so that verbosity can be controlled
  from the top-level make.

* ${XSEG_HOME}/envsetup is an environment-setting tool that will either
  - initialize variables if sourced
  - initialize variables and start a shell if executed with no arguments
  - printout variables if executed with 'show'

  Its intended use is from the command line, to set up a dev shell,
  and it is used by the makefiles to set up/discover the environment.

* The build system was improved.
  (fewer includes, more central configuration, more automation, etc)

  The top-level base.mk is at the heart of it,
  discovering and setting most of the variables,
  while defining global rules.

  It uses envsetup for basic variables and
  tools/xseg-domain-targets to auto-detect what targets are available
  in the tree.

* LOGMSG was renamed to XSEGLOG and promoted to domain-specific.
  The xsegbd-specific XSEGLOG was discarded.

* xsegbd hacks.
  There were some ugly hacks and bad stuff in how xsegbd handled
  its signalling via callbacks, and specifically how it blocked to
  wait for device size. A pointer was overlayed in a private field
  along with an integer, and circulated through the userspace,
  before being intrusively extracted from port->waitcue and
  auto-detected as pointer.

  Now there are are proper structures (struct pending)
  for distinguishing among asynchronous or completion-blocked requests,
  and the callbacks all run through well defined interfaces.

* xsegbd hazards.
  The initialization of xsegbd, both in sysfs and in disk,
  has memory leaks, not freeing memory on failure.

  The loop receiving requests within the callback,
  may receive replies for more than one device,
  and therefore needs to call request_fn's for more than one device.
  This was fixed (not tested).

Merge branch 'xseg' into vlmcd-as-blockd

Initial, completely broken skeleton of a vlmcd

Initial, completely broken skeleton of a vlmcd,
single-threaded, modelled after blockd.

There doesn't seem to be a need for multithreaded
operation if a peer is only interacting with other xseg peers.

sosd: add dummy X_INFO reply. all images to 20GB.

move qa/ to tools/

envsetup script to exec or source for env setup

Sets up XSEG_HOME PATH LD_LIBRARY_PATH etc.

If it is executed, it starts a new $SHELL.
If it is sourced, it just exports the variables.