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.

filed: Fix lost wakeups between IO-threads

Race condition with free_io() / wait_cond() and alloc_io() /
cond_signal(), results in lost-wakeups between IO threads
and causes threads and eventually filed to deadlock.

Thread 1        Thread 2
free_io x          -
   -            alloc_io x
   -            cond_signal x
lock_cond x        -
wait_cond x        -

Move free_io() inside the mutex locked section before
sleeping, and lock the mutex in wake_iothread before
signalling the thread, to avoid the deadlock.

drop flush support. maybe in the future

sosd output only on verbose

replace blockd names with sosd

remove signal manipulation code

Remove traling whitespace in vlmc_shared

vlmc: Minor fix for prev commit

vlmc: Split common funcs to a separate file

tools: Add configurable NR_OPS for blockd/filed

blockd: Optionally log pending_io()

Yet another typo

vlmc-tool: Fix typo of prev commit

vlmc-tool: Don't use hardcoded reqs number

Enable optional request logging for blockd/filed

Use correct sysfs attr (srcport) when mapping

blockd: Make request logging optional

blockd: Fix cli option/argument for nr_ops

Minor fix for vlmc/xseg-setup

Fix vlmc-filed.py free port scanning

Fixes for vlmc-filed

Add support for filed in the vlmc tool

Merge remote-tracking branch 'origin/xseg' into merger

Conflicts:
xseg/tools/vlmc.py
xseg/tools/xseg_setup.sh

Conflicts Resolution:
vlmc.py:
* Keep the \t -> space changes from the xseg branch
* Keep the new parsing scheme from the tools
xseg_setup.sh:
* Keep the change to sourcing the helpers.sh from
  the tools branch

xsegbd/xsegdev: Fix xsegbd/xsegdev memory leak

xsegdev_get/put and the associated xsegdev->userfield struct member
were incorrectly used, resulting in a memory leak, where xsegdev
segment wasn't (v)freed at xsegdev unload.

Refs #3

Remove incorrect comment

Introduce various fixes, run end-to-end

Introduce various fixes, some aesthetic, to make
the infrastructure run end-to-end, xsegbd-to-filed
after merging of the filed and tools branches.

Initial support for config parsing for vlmc-tool

Minor parsing fixes for vlmc tool

Minor fixes for helpers

Fixes for the vlmc-tool
 * Change the parsing to be compatible with ganeti rbd calls
 * Force python2.7 (needed by subprocess module)

More fixes for helper scripts

Fix two instances of XS_ERROR

Merge branch 'tools' into xseg

Conflicts:
xseg/xq/xq.c

Merge branch 'filed' into xseg

XS_ERROR renamed to XS_FAILED

portable and future-proof locks

relative pointers

relative pointer doubly linked lists

Correct the tests for unset config variables

Helper scripts to setup and test xsge components

Initial commit for the (blockd-specific) vlmc tool

Fix a bug in device id assignment

xsegbd: Add name in sysfs device attrs

Minor fix in request_fn

Correct string handling for target names

Initial support for target names

blockd will now only accept requests based on the target name (ie only for the
file it has opened), and will return an XS_ERROR reqeust otherwise.

xsegbd will now take a target name as an argument when adding a device via
sysfs, and will use that name as the target name for all the subsequent requests
fot that device.

xsegbd: Release and error code paths fixes

Fix issues with the release / exit and error handling code paths.

xq: Fix iteration bug in xq_head_to_tail()

Since __xq_pop_head() decrements head to point to the (new) first
available item in the queue, xq_head_to_tail() should iterate headq
forward (by incrementing head), not backwards. Backward iteration
results in xq corruption, which can easily be triggered using
alloc_requests()/free_requests() functions.

fix broken xq_head_to_tail()

used by xseg_free_requests(),
bug exposed by add/remove device tests by psomas.

Also, refactor so that __xq_append_tail() returns
the index to the leftmost (least) side of the queue buffer,
as is the convention with all other 3 functions
__xq_{append,pop}{head,tail}()

for __xq_append_tail(), the leftmost side of the buffer is
(new tail + 1):
 .---- nr ----.
 XXXXXXXXXXXXXX---------------------
^             ^                     ^
new tail     old tail              head

fix race condition on error when opening the same file from diffrent threads

remove per cache entry lock. replace it with atomic operations in ref count

add xinfo support

get rid of flush. call fsync after write

fix xseg_signal() posix retval and warning

fix bug in cache

initial threaded filed commit

Merge wip-sysfs into xseg, with amendments

Conflicts:
xseg/sys/xsegbd.c

Amendments:
struct completion is now per-request, not per-device.
The xsegbd callback (heuristically) knows when
xreq->priv is an index of an I/O request or a pointer
to a completion struct, and branches out accordingly.

The request is handled by the blocker,
and now, xsegbd_get_size() can cause initialization to fail.

Untested.

Replace busy-wait loop in get_size with completion

Merge branch 'wip-sysfs' into xseg

Conflicts:
xseg/sys/xsegbd.c

There is printk-logging leading up to a lock-up
in get_size(). This is currently broken.

make some field types arch-neutral

Merge branch 'wip-xinfo-fixed' into xseg

Conflicts:
xseg/sys/xsegbd.c [trivial]

Simplify callback req demultiplexing (temp).

Until prepare_wait() is fixed to support an extra
argument, we can manually assign port.waitcue to the address of the
appropriate xsegbd_device struct before submitting the request,
simplifiying the callback request demultiplexing (don't iterate
the devices list).

xsegbd: add multiple 'disk' support via sysfs.

Add initial (not tested/buggy) multiple disk support to xsegbd via a
sysfs interface similar to rbd.

add support for larger than 1 segment requests + xseg_signaling.

xsegbd: Don't destroy the segment, if it exists.

Allow disksize override with sector_size parameter.

Allow a non-zero sector_size module parameter to override the disk
size returned by xsegbd_get_size()