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()

Minor fixes in xsegbd_get_size().

Remove the useless prep_wait() and cancel_wait() calls in xsegbd_get_size() and
add some comments to document its behavior.

Move segment unmap() in xsegbd module.

We cannot unmap a segment in xseg_destroy(), since the segment may not
be mapped. Since it currently only affects xsegbd, move it in
xsegbd_xseg_quit(), inside the xsegbd module.

Refactor cmd_info() code in xseg-tool.

Refactor cmd_info code in xseg-tool. Use cmd_wait to get the response.

Make xsegbd query peer for disk size(using X_INFO)

xsegbd will now send an X_INFO request to learn the size of the disk it's
mapping, instead of using the sector_size parameter at module load time.

Currently, xsegbd allocates its own segment, and thus it must wait until blockd
(or another peer with X_INFO support) joins the segment to get a response (this
will probably change soon).

Make sure to unmap the segment in xseg_destroy()

Add xops->unmap() in xseg_destroy(). If you don't unmap the segment before
calling xops->deallocate(), xsegdev->callback and xsegdev->callarg are not set
to NULL when rmmoding xsegbd, and lead to an error (or kernel panic) when trying
to insmod xsegbd without rmmoding xsegdev and xseg.

Add (initial) support for X_INFO request operation

Add support for X_INFO request operation, to query information about a
target (X_INFO op support implemented in xseg-tool). Initial blockd
implementation 'returns' only the size of the target / file.

remove race condition on xseg_request state

make blockd loop over pending ios.

remove close with negative file descriptor

Merge branch 'philfix'

initialize lock in xq initialization.

remove obsolete XSEG_{FLUSH,FUA}.

initial commit of sosd

Merge branch 'philfix'

fix buffer handling on incomplete/resubmitted reqs

fix log_io printing beyond end-of-string garbage

Add pthread to linked libraries

relax shared segment access precautions

The shared array of peer type names is by design
append only, therefore no locking or copying strings
is needed to access it (only pointer conversions).
Append-only means that peer type names cannot be unregistered.

Unregistering is complicated because peers "cache"
the information they read from the shared array.

fix invalid shared pointer access and wrong retval

also, lock and copy string from shared segment,
as a precaution.

relax redundant shared access precautions

Shared access to the shared array of peer type names
was designed to be safe without locking or copying
because the peer type name array is append only,
i.e. no peer type names can be unregistered.

Unregistering introduces many other problems
(and not just the lock/copy avoided here),
such as need for "cache" invalidation among peers,
who had previously accessed the shared array.

fix invalid pointer access to shared segment.

Also, add locking and copying shared data, for safety.

initialization from my own repository