glusterfs.git/libglusterfs/src/syncop.h, branch v3.4.1rc1

core: increase the auxillary group limit to 65536

2013-09-10T00:25:38+00:00

Make the allocation of groups dynamic and increase the limit
to 65536.

Change-Id: I702364ff460e3a982e44ccbcb3e337cac9c2df51
BUG: 953694
Signed-off-by: Anand Avati 
Reviewed-on: http://review.gluster.org/5172
Reviewed-by: Xavier Hernandez 
Tested-by: Gluster Build System

gfapi: link inodes in relevant entry FOPs

2013-06-08T21:51:04+00:00

Do not let inode linking to happen only in lookup(). While
that works, it is inefficient.

Change-Id: I51bbfb6255ec4324ab17ff00566375f49d120c06
BUG: 953694
Signed-off-by: Anand Avati 
Reviewed-on: http://review.gluster.org/5162
Tested-by: Gluster Build System 
Reviewed-by: Vijay Bellur

gfapi: POSIX locking support

2013-06-08T21:49:10+00:00

Change-Id: I37d9e1fb4a715094876be6af3856c1b4cf398021
BUG: 953694
Signed-off-by: Anand Avati 
Reviewed-on: http://review.gluster.org/5155
Tested-by: Gluster Build System 
Reviewed-by: Vijay Bellur

syncop: set credentials of running process in @frame

2013-06-08T21:46:32+00:00

Inherit the pid/euid/egid/groups of the running process in the
frame. Do this only in cases where a loaded frame was not
presented to the synctask.

This behavior is required for Samba VFS.

Change-Id: Ib181c90f47c6741197b9ce9f67a19e2914b647d2
BUG: 953694
Signed-off-by: Anand Avati 
Reviewed-on: http://review.gluster.org/5153
Tested-by: Gluster Build System 
Reviewed-by: Vijay Bellur

syncop: synctask shouldn't yawn, it could miss a 'wake'

2013-05-23T14:24:42+00:00

        Backport of http://review.gluster.org/5058

Change-Id: I7731fd33ca0c925cc52f8d105275b44fc625a1e2
BUG: 948686
Signed-off-by: Krishnan Parthasarathi 
Reviewed-on: http://review.gluster.org/5071
Tested-by: Gluster Build System 
Reviewed-by: Jeff Darcy

syncop: Update synctask state appropriately

2013-05-21T13:03:14+00:00

        Backport of http://review.gluster.org/4985

* Earlier, SYNCOP macro, the only consumer of synctask_yield, would set
the task->state to SYNCTASK_SUSPEND. Today, we have glusterd having its
own wrapper macros which don't set task's state. There is also the
syncbarrier and synclock framework, which also participate in a
synctask's scheduling (and need to keep a task's state up to date). It
only makes more sense to leave a synctask's state to the synctask
library, since its an internal affair.

* Need to 'yawn' before 'yield' to avoid re-running tasks to set
  task->woken appropriately.

Change-Id: Ic7a59e6ebcc46f03e53223ca237668d45a3cba40
BUG: 948686
Signed-off-by: Krishnan Parthasarathi 
Reviewed-on: http://review.gluster.org/5053
Tested-by: Gluster Build System 
Reviewed-by: Vijay Bellur

glusterd: Refresh glusterd-syncop fixes from master

2013-05-17T03:44:44+00:00

Following commits were cherry-picked from master,
044f8ce syncop: Remove task from synclock's waitq before 'wake'
cb6aeed glusterd: Give up big lock before performing any RPC
46572fe Revert "glusterd: Fix spurious wakeups in glusterd syncops"
5021e04 synctask: implement barriers around yield, not the other way
4843937 glusterd: Syncop callbks should take big lock too

Change-Id: I5ae71ab98f9a336dc9bbf0e7b2ec50a6ed42b0f5
BUG: 948686
Signed-off-by: Krishnan Parthasarathi 
Reviewed-on: http://review.gluster.org/4938
Reviewed-by: Amar Tumballi 
Tested-by: Gluster Build System 
Reviewed-by: Anand Avati 
Reviewed-on: http://review.gluster.org/5021
Reviewed-by: Vijay Bellur

synctask: introduce synclocks for co-operative locking

2013-04-17T08:53:20+00:00

This patch introduces a synclocks - co-operative locks for synctasks.
Synctasks yield themselves when a lock cannot be acquired at the time
of the lock call, and the unlocker will wake the yielded locker at
the time of unlock.

The implementation is safe in a multi-threaded syncenv framework.

It is also safe for sharing the lock between non-synctasks. i.e, the
same lock can be used for synchronization between a synctask and
a regular thread. In such a situation, waiting synctasks will yield
themselves while non-synctasks will sleep on a cond variable. The
unlocker (which could be either a synctask or a regular thread) will
wake up any type of lock waiter (synctask or regular).

Usage:

    Declaration and Initialization
    ------------------------------

    synclock_t lock;

    ret = synclock_init (&lock);
    if (ret) {
        /* lock could not be allocated */
    }

   Locking and non-blocking lock attempt
   -------------------------------------

   ret = synclock_trylock (&lock);
   if (ret && (errno == EBUSY)) {
      /* lock is held by someone else */
      return;
   }

   synclock_lock (&lock);
   {
      /* critical section */
   }
   synclock_unlock (&lock);

BUG: 763820
Change-Id: I23066f7b66b41d3d9fb2311fdaca333e98dd7442
Signed-off-by: Krishnan Parthasarathi 
Original-author: Anand Avati 
Reviewed-on: http://review.gluster.org/4830
Tested-by: Gluster Build System 
Reviewed-by: Vijay Bellur

glusterd: Increasing throughput of synctask based mgmt ops.

2013-03-07T06:06:30+00:00

Change-Id: Ibd963f78707b157fc4c9729aa87206cfd5ecfe81
BUG: 913662
Signed-off-by: Krishnan Parthasarathi 
Reviewed-on: http://review.gluster.org/4638
Tested-by: Gluster Build System 
Reviewed-by: Jeff Darcy

synctask: support for (assymetric) counted barriers

2013-03-07T05:32:34+00:00

[Backport of Avati's patch on master - http://review.gluster.org/4558]
This patch introduces a new set of primitives:

  - synctask_barrier_init (stub)
  - synctask_barrier_waitfor (stub, count)
  - synctask_barrier_wake (stub)

Unlike pthread_barrier_t, this barrier has an explicit notion of
"waiter" and "waker". The "waiter" waits for @count number of
"wakers" to call synctask_barrier_wake() before returning. The
wait performed by the waiter via synctask_barrier_waitfor() is
co-operative in nature and yields the thread for scheduling other
synctasks in the mean time.

Intended use case:

  Eliminate excessive serialization in glusterd and allow for
concurrent RPC transactions.

  Code which are currently in this format:

---old---

  list_for_each_entry (peerinfo, peers, op_peers_list) {
          ...
          GD_SYNCOP (peerinfo->rpc, stub, rpc_cbk, ...);
  }

  ...

  int rpc_cbk (rpc, stub, ...)
  {
          ...
          __wake (stub);
  }

---old---

  Can be restructred into the format:

---new---

  synctask_barrier_init (stub);
  {
          list_for_each_entry (peerinfo, peers, op_peers_list) {
                  ...
                  rpc_submit (peerinfo->rpc, stub, rpc_cbk, ...);
                  count++;
           }
   }
   synctask_barrier_wait (stub, count);

   ...

   int rpc_cbk (rpc, stub, ...)
   {
           ...
           synctask_barrier_wake (stub);
   }

---new---

  In the above structure, from the synctask's point of view, the region
between synctask_barrier_init() and synctask_barrier_wait() are spawning
off asynchronous "threads" (or RPC) and keep count of how many such
threads have been spawned. Each of those threads are expected to make
one call to synctask_barrier_wake(). The call to synctask_barrier_wait()
makes the synctask thread co-operatively wait/sleep till @count such threads
call their wake function.

  This way, the synctask thread retains the "synchronous" flow in the code,
yet at the same time allows for asynchronous "threads" to acheive parallelism
over RPC.

Change-Id: Ie037f99b2d306b71e63e3a56353daec06fb0bf41
BUG: 913662
Signed-off-by: Anand Avati 
Signed-off-by: Krishnan Parthasarathi 
Reviewed-on: http://review.gluster.org/4636
Reviewed-by: Jeff Darcy 
Tested-by: Gluster Build System