01 Nov, 2011

1 commit


21 Oct, 2010

1 commit


09 Sep, 2010

17 commits

  • Nothing was canceling the send and receive work that might have been
    queued as a conn was being destroyed.

    Signed-off-by: Zach Brown

    Zach Brown
     
  • rds_conn_shutdown() can return before the connection is shut down when
    it encounters an existing state that it doesn't understand. This lets
    rds_conn_destroy() then start tearing down the conn from under paths
    that are still using it.

    It's more reliable the shutdown work and wait for krdsd to complete the
    shutdown callback. This stopped some hangs I was seeing where krdsd was
    trying to shut down a freed conn.

    Signed-off-by: Zach Brown

    Zach Brown
     
  • Right now there's nothing to stop the various paths that use
    rs->rs_transport from racing with rmmod and executing freed transport
    code. The simple fix is to have binding to a transport also hold a
    reference to the transport's module, removing this class of races.

    We already had an unused t_owner field which was set for the modular
    transports and which wasn't set for the built-in loop transport.

    Signed-off-by: Zach Brown

    Zach Brown
     
  • rds_conn_destroy() can race with all other modifications of the
    rds_conn_count but it was modifying the count without locking.

    Signed-off-by: Zach Brown

    Zach Brown
     
  • The trivial amount of memory saved isn't worth the cost of dealing with section
    mismatches.

    Signed-off-by: Zach Brown

    Zach Brown
     
  • Andy Grover
     
  • rds_send_xmit() was changed to hold an interrupt masking spinlock instead of a
    mutex so that it could be called from the IB receive tasklet path. This broke
    the TCP transport because its xmit method can block and masks and unmasks
    interrupts.

    This patch serializes callers to rds_send_xmit() with a simple bit instead of
    the current spinlock or previous mutex. This enables rds_send_xmit() to be
    called from any context and to call functions which block. Getting rid of the
    c_send_lock exposes the bare c_lock acquisitions which are changed to block
    interrupts.

    A waitqueue is added so that rds_conn_shutdown() can wait for callers to leave
    rds_send_xmit() before tearing down partial send state. This lets us get rid
    of c_senders.

    rds_send_xmit() is changed to check the conn state after acquiring the
    RDS_IN_XMIT bit to resolve races with the shutdown path. Previously both
    worked with the conn state and then the lock in the same order, allowing them
    to race and execute the paths concurrently.

    rds_send_reset() isn't racing with rds_send_xmit() now that rds_conn_shutdown()
    properly ensures that rds_send_xmit() can't start once the conn state has been
    changed. We can remove its previous use of the spinlock.

    Finally, c_send_generation is redundant. Callers can race to test the c_flags
    bit by simply retrying instead of racing to test the c_send_generation atomic.

    Signed-off-by: Zach Brown

    Zach Brown
     
  • conn->c_lock is acquired in interrupt context. rds_conn_message_info() is
    called from user context and was acquiring c_lock without blocking interrupts,
    leading to possible deadlocks.

    Signed-off-by: Zach Brown

    Zach Brown
     
  • A few paths had the same block of code to queue a connection's connect work if
    it was in the right state. Let's move this in to a helper function.

    Signed-off-by: Zach Brown

    Zach Brown
     
  • The connection hash was almost entirely RCU ready, this
    just makes the final couple of changes to use RCU instead
    of spinlocks for everything.

    Signed-off-by: Chris Mason

    Chris Mason
     
  • rds_conn_destroy really needs locking while it changes the
    connection hash.

    Signed-off-by: Chris Mason

    Chris Mason
     
  • This is the first in a long line of patches that tries to fix races
    between RDS connection shutdown and RDS traffic.

    Here we are maintaining a count of active senders to make sure
    the connection doesn't go away while they are using it.

    Signed-off-by: Chris Mason

    Chris Mason
     
  • rds_send_xmit is required to loop around after it releases the lock
    because someone else could done a trylock, found someone working on the
    list and backed off.

    But, once we drop our lock, it is possible that someone else does come
    in and make progress on the list. We should detect this and not loop
    around if another process is actually working on the list.

    This patch adds a generation counter that is bumped every time we
    get the lock and do some send work. If the retry notices someone else
    has bumped the generation counter, it does not need to loop around and
    continue working.

    Signed-off-by: Chris Mason
    Signed-off-by: Andy Grover

    Chris Mason
     
  • This change allows us to call rds_send_xmit() from a tasklet,
    which is crucial to our new operating model.

    * Change c_send_lock to a spinlock
    * Update stats fields "sem_" to "_lock"
    * Remove unneeded rds_conn_is_sending()

    About locking between shutdown and send -- send checks if the
    connection is up. Shutdown puts the connection into
    DISCONNECTING. After this, all threads entering send will exit
    immediately. However, a thread could be *in* send_xmit(), so
    shutdown acquires the c_send_lock to ensure everyone is out
    before proceeding with connection shutdown.

    Signed-off-by: Andy Grover

    Andy Grover
     
  • RDMA is now an intrinsic part of RDS, so it's easier to just have
    a single header.

    Signed-off-by: Andy Grover

    Andy Grover
     
  • Favor "if (foo)" style over "if (foo != NULL)".

    Signed-off-by: Andy Grover

    Andy Grover
     
  • This fits better in connection.c, rather than threads.c.

    Signed-off-by: Andy Grover

    Andy Grover
     

30 Mar, 2010

1 commit

  • …it slab.h inclusion from percpu.h

    percpu.h is included by sched.h and module.h and thus ends up being
    included when building most .c files. percpu.h includes slab.h which
    in turn includes gfp.h making everything defined by the two files
    universally available and complicating inclusion dependencies.

    percpu.h -> slab.h dependency is about to be removed. Prepare for
    this change by updating users of gfp and slab facilities include those
    headers directly instead of assuming availability. As this conversion
    needs to touch large number of source files, the following script is
    used as the basis of conversion.

    http://userweb.kernel.org/~tj/misc/slabh-sweep.py

    The script does the followings.

    * Scan files for gfp and slab usages and update includes such that
    only the necessary includes are there. ie. if only gfp is used,
    gfp.h, if slab is used, slab.h.

    * When the script inserts a new include, it looks at the include
    blocks and try to put the new include such that its order conforms
    to its surrounding. It's put in the include block which contains
    core kernel includes, in the same order that the rest are ordered -
    alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
    doesn't seem to be any matching order.

    * If the script can't find a place to put a new include (mostly
    because the file doesn't have fitting include block), it prints out
    an error message indicating which .h file needs to be added to the
    file.

    The conversion was done in the following steps.

    1. The initial automatic conversion of all .c files updated slightly
    over 4000 files, deleting around 700 includes and adding ~480 gfp.h
    and ~3000 slab.h inclusions. The script emitted errors for ~400
    files.

    2. Each error was manually checked. Some didn't need the inclusion,
    some needed manual addition while adding it to implementation .h or
    embedding .c file was more appropriate for others. This step added
    inclusions to around 150 files.

    3. The script was run again and the output was compared to the edits
    from #2 to make sure no file was left behind.

    4. Several build tests were done and a couple of problems were fixed.
    e.g. lib/decompress_*.c used malloc/free() wrappers around slab
    APIs requiring slab.h to be added manually.

    5. The script was run on all .h files but without automatically
    editing them as sprinkling gfp.h and slab.h inclusions around .h
    files could easily lead to inclusion dependency hell. Most gfp.h
    inclusion directives were ignored as stuff from gfp.h was usually
    wildly available and often used in preprocessor macros. Each
    slab.h inclusion directive was examined and added manually as
    necessary.

    6. percpu.h was updated not to include slab.h.

    7. Build test were done on the following configurations and failures
    were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
    distributed build env didn't work with gcov compiles) and a few
    more options had to be turned off depending on archs to make things
    build (like ipr on powerpc/64 which failed due to missing writeq).

    * x86 and x86_64 UP and SMP allmodconfig and a custom test config.
    * powerpc and powerpc64 SMP allmodconfig
    * sparc and sparc64 SMP allmodconfig
    * ia64 SMP allmodconfig
    * s390 SMP allmodconfig
    * alpha SMP allmodconfig
    * um on x86_64 SMP allmodconfig

    8. percpu.h modifications were reverted so that it could be applied as
    a separate patch and serve as bisection point.

    Given the fact that I had only a couple of failures from tests on step
    6, I'm fairly confident about the coverage of this conversion patch.
    If there is a breakage, it's likely to be something in one of the arch
    headers which should be easily discoverable easily on most builds of
    the specific arch.

    Signed-off-by: Tejun Heo <tj@kernel.org>
    Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
    Cc: Ingo Molnar <mingo@redhat.com>
    Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>

    Tejun Heo
     

30 Nov, 2009

1 commit


24 Aug, 2009

1 commit


20 Jul, 2009

2 commits


10 Apr, 2009

1 commit


27 Feb, 2009

1 commit

  • While arguably the fact that the underlying transport needs a
    connection to convey RDS's datagrame reliably is not important
    to rds proper, the transports implemented so far (IB and TCP)
    have both been connection-oriented, and so the connection
    state machine-related code is in the common rds code.

    This patch also includes several work items, to handle connecting,
    sending, receiving, and shutdown.

    Signed-off-by: Andy Grover
    Signed-off-by: David S. Miller

    Andy Grover