From: Greg Kroah-Hartman Date: Mon, 10 Feb 2014 19:45:06 +0000 (-0800) Subject: 3.12-stable patches X-Git-Tag: v3.4.80~45 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=f0239822fc6d8600390f5632ee0fa4618e96ba79;p=thirdparty%2Fkernel%2Fstable-queue.git 3.12-stable patches added patches: iscsi-target-fix-connection-reset-hang-with-percpu_ida_alloc.patch percpu_ida-make-percpu_ida_alloc-callers-accept-task-state-bitmask.patch --- diff --git a/queue-3.12/iscsi-target-fix-connection-reset-hang-with-percpu_ida_alloc.patch b/queue-3.12/iscsi-target-fix-connection-reset-hang-with-percpu_ida_alloc.patch new file mode 100644 index 00000000000..453745ff9ed --- /dev/null +++ b/queue-3.12/iscsi-target-fix-connection-reset-hang-with-percpu_ida_alloc.patch @@ -0,0 +1,70 @@ +From 555b270e25b0279b98083518a85f4b1da144a181 Mon Sep 17 00:00:00 2001 +From: Nicholas Bellinger +Date: Mon, 20 Jan 2014 03:36:24 +0000 +Subject: iscsi-target: Fix connection reset hang with percpu_ida_alloc + +From: Nicholas Bellinger + +commit 555b270e25b0279b98083518a85f4b1da144a181 upstream. + +This patch addresses a bug where connection reset would hang +indefinately once percpu_ida_alloc() was starved for tags, due +to the fact that it always assumed uninterruptible sleep mode. + +So now make percpu_ida_alloc() check for signal_pending_state() for +making interruptible sleep optional, and convert iscsit_allocate_cmd() +to set TASK_INTERRUPTIBLE for GFP_KERNEL, or TASK_RUNNING for +GFP_ATOMIC. + +Reported-by: Linus Torvalds +Cc: Kent Overstreet +Signed-off-by: Nicholas Bellinger +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/target/iscsi/iscsi_target_util.c | 2 +- + lib/percpu_ida.c | 9 +++++++-- + 2 files changed, 8 insertions(+), 3 deletions(-) + +--- a/drivers/target/iscsi/iscsi_target_util.c ++++ b/drivers/target/iscsi/iscsi_target_util.c +@@ -156,7 +156,7 @@ struct iscsi_cmd *iscsit_allocate_cmd(st + { + struct iscsi_cmd *cmd; + struct se_session *se_sess = conn->sess->se_sess; +- int size, tag, state = (gfp_mask & __GFP_WAIT) ? TASK_UNINTERRUPTIBLE : ++ int size, tag, state = (gfp_mask & __GFP_WAIT) ? TASK_INTERRUPTIBLE : + TASK_RUNNING; + + tag = percpu_ida_alloc(&se_sess->sess_tag_pool, state); +--- a/lib/percpu_ida.c ++++ b/lib/percpu_ida.c +@@ -148,14 +148,14 @@ static inline unsigned alloc_local_tag(s + * tag_pool_init()), or otherwise -ENOSPC on allocation failure. + * + * Safe to be called from interrupt context (assuming it isn't passed +- * TASK_UNINTERRUPTIBLE, of course). ++ * TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, of course). + * + * @gfp indicates whether or not to wait until a free id is available (it's not + * used for internal memory allocations); thus if passed __GFP_WAIT we may sleep + * however long it takes until another thread frees an id (same semantics as a + * mempool). + * +- * Will not fail if passed TASK_UNINTERRUPTIBLE. ++ * Will not fail if passed TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE. + */ + int percpu_ida_alloc(struct percpu_ida *pool, int state) + { +@@ -205,6 +205,11 @@ int percpu_ida_alloc(struct percpu_ida * + if (tag >= 0 || state == TASK_RUNNING) + break; + ++ if (signal_pending_state(state, current)) { ++ tag = -ERESTARTSYS; ++ break; ++ } ++ + schedule(); + + local_irq_save(flags); diff --git a/queue-3.12/percpu_ida-make-percpu_ida_alloc-callers-accept-task-state-bitmask.patch b/queue-3.12/percpu_ida-make-percpu_ida_alloc-callers-accept-task-state-bitmask.patch new file mode 100644 index 00000000000..7e6e4bb178b --- /dev/null +++ b/queue-3.12/percpu_ida-make-percpu_ida_alloc-callers-accept-task-state-bitmask.patch @@ -0,0 +1,147 @@ +From 6f6b5d1ec56acdeab0503d2b823f6f88a0af493e Mon Sep 17 00:00:00 2001 +From: Kent Overstreet +Date: Sun, 19 Jan 2014 08:26:37 +0000 +Subject: percpu_ida: Make percpu_ida_alloc + callers accept task state bitmask + +From: Kent Overstreet + +commit 6f6b5d1ec56acdeab0503d2b823f6f88a0af493e upstream. + +This patch changes percpu_ida_alloc() + callers to accept task state +bitmask for prepare_to_wait() for code like target/iscsi that needs +it for interruptible sleep, that is provided in a subsequent patch. + +It now expects TASK_UNINTERRUPTIBLE when the caller is able to sleep +waiting for a new tag, or TASK_RUNNING when the caller cannot sleep, +and is forced to return a negative value when no tags are available. + +v2 changes: + - Include blk-mq + tcm_fc + vhost/scsi + target/iscsi changes + - Drop signal_pending_state() call +v3 changes: + - Only call prepare_to_wait() + finish_wait() when != TASK_RUNNING + (PeterZ) + +Reported-by: Linus Torvalds +Cc: Linus Torvalds +Cc: Ingo Molnar +Cc: Peter Zijlstra +Cc: Jens Axboe +Signed-off-by: Kent Overstreet +Signed-off-by: Nicholas Bellinger +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/target/iscsi/iscsi_target_util.c | 8 ++++++-- + drivers/vhost/scsi.c | 2 +- + include/linux/percpu_ida.h | 3 ++- + lib/percpu_ida.c | 16 +++++++++------- + 4 files changed, 18 insertions(+), 11 deletions(-) + +--- a/drivers/target/iscsi/iscsi_target_util.c ++++ b/drivers/target/iscsi/iscsi_target_util.c +@@ -156,9 +156,13 @@ struct iscsi_cmd *iscsit_allocate_cmd(st + { + struct iscsi_cmd *cmd; + struct se_session *se_sess = conn->sess->se_sess; +- int size, tag; ++ int size, tag, state = (gfp_mask & __GFP_WAIT) ? TASK_UNINTERRUPTIBLE : ++ TASK_RUNNING; ++ ++ tag = percpu_ida_alloc(&se_sess->sess_tag_pool, state); ++ if (tag < 0) ++ return NULL; + +- tag = percpu_ida_alloc(&se_sess->sess_tag_pool, gfp_mask); + size = sizeof(struct iscsi_cmd) + conn->conn_transport->priv_size; + cmd = (struct iscsi_cmd *)(se_sess->sess_cmd_map + (tag * size)); + memset(cmd, 0, size); +--- a/drivers/vhost/scsi.c ++++ b/drivers/vhost/scsi.c +@@ -728,7 +728,7 @@ vhost_scsi_get_tag(struct vhost_virtqueu + } + se_sess = tv_nexus->tvn_se_sess; + +- tag = percpu_ida_alloc(&se_sess->sess_tag_pool, GFP_ATOMIC); ++ tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + if (tag < 0) { + pr_err("Unable to obtain tag for tcm_vhost_cmd\n"); + return ERR_PTR(-ENOMEM); +--- a/include/linux/percpu_ida.h ++++ b/include/linux/percpu_ida.h +@@ -4,6 +4,7 @@ + #include + #include + #include ++#include + #include + #include + #include +@@ -51,7 +52,7 @@ struct percpu_ida { + } ____cacheline_aligned_in_smp; + }; + +-int percpu_ida_alloc(struct percpu_ida *pool, gfp_t gfp); ++int percpu_ida_alloc(struct percpu_ida *pool, int state); + void percpu_ida_free(struct percpu_ida *pool, unsigned tag); + + void percpu_ida_destroy(struct percpu_ida *pool); +--- a/lib/percpu_ida.c ++++ b/lib/percpu_ida.c +@@ -142,22 +142,22 @@ static inline unsigned alloc_local_tag(s + /** + * percpu_ida_alloc - allocate a tag + * @pool: pool to allocate from +- * @gfp: gfp flags ++ * @state: task state for prepare_to_wait + * + * Returns a tag - an integer in the range [0..nr_tags) (passed to + * tag_pool_init()), or otherwise -ENOSPC on allocation failure. + * + * Safe to be called from interrupt context (assuming it isn't passed +- * __GFP_WAIT, of course). ++ * TASK_UNINTERRUPTIBLE, of course). + * + * @gfp indicates whether or not to wait until a free id is available (it's not + * used for internal memory allocations); thus if passed __GFP_WAIT we may sleep + * however long it takes until another thread frees an id (same semantics as a + * mempool). + * +- * Will not fail if passed __GFP_WAIT. ++ * Will not fail if passed TASK_UNINTERRUPTIBLE. + */ +-int percpu_ida_alloc(struct percpu_ida *pool, gfp_t gfp) ++int percpu_ida_alloc(struct percpu_ida *pool, int state) + { + DEFINE_WAIT(wait); + struct percpu_ida_cpu *tags; +@@ -184,7 +184,8 @@ int percpu_ida_alloc(struct percpu_ida * + * + * global lock held and irqs disabled, don't need percpu lock + */ +- prepare_to_wait(&pool->wait, &wait, TASK_UNINTERRUPTIBLE); ++ if (state != TASK_RUNNING) ++ prepare_to_wait(&pool->wait, &wait, state); + + if (!tags->nr_free) + alloc_global_tags(pool, tags); +@@ -201,7 +202,7 @@ int percpu_ida_alloc(struct percpu_ida * + spin_unlock(&pool->lock); + local_irq_restore(flags); + +- if (tag >= 0 || !(gfp & __GFP_WAIT)) ++ if (tag >= 0 || state == TASK_RUNNING) + break; + + schedule(); +@@ -209,8 +210,9 @@ int percpu_ida_alloc(struct percpu_ida * + local_irq_save(flags); + tags = this_cpu_ptr(pool->tag_cpu); + } ++ if (state != TASK_RUNNING) ++ finish_wait(&pool->wait, &wait); + +- finish_wait(&pool->wait, &wait); + return tag; + } + EXPORT_SYMBOL_GPL(percpu_ida_alloc); diff --git a/queue-3.12/series b/queue-3.12/series index 97032dc005a..6e3779f0540 100644 --- a/queue-3.12/series +++ b/queue-3.12/series @@ -58,3 +58,5 @@ drm-radeon-warn-users-when-hw_i2c-is-enabled-v2.patch drm-radeon-dpm-disable-mclk-switching-on-desktop-rv770.patch radeon-pm-guard-access-to-rdev-pm.power_state-array.patch mei-mei_hbm_dispatch-returns-void.patch +percpu_ida-make-percpu_ida_alloc-callers-accept-task-state-bitmask.patch +iscsi-target-fix-connection-reset-hang-with-percpu_ida_alloc.patch