Hi Greg, On Mon, 2014-02-10 at 09:39 -0800, gregkh@xxxxxxxxxxxxxxxxxxx wrote: > This is a note to let you know that I've just added the patch titled > > percpu_ida: Make percpu_ida_alloc + callers accept task state bitmask > > to the 3.13-stable tree which can be found at: > http://www.kernel.org/git/?p=linux/kernel/git/stable/stable-queue.git;a=summary > > The filename of the patch is: > percpu_ida-make-percpu_ida_alloc-callers-accept-task-state-bitmask.patch > and it can be found in the queue-3.13 subdirectory. > > If you, or anyone else, feels it should not be added to the stable tree, > please let <stable@xxxxxxxxxxxxxxx> know about it. > > So this patch is intended to go along with: [for-v3.13.y 2/2] iscsi-target: Fix connection reset hang with percpu_ida_alloc http://www.spinics.net/lists/target-devel/msg06192.html Please include commit 555b270e25b0279b98083518a85f4b1da144a181 for both v3.1[3,2].y code along with this particular percpu_ida patch. Thanks, --nab > From 6f6b5d1ec56acdeab0503d2b823f6f88a0af493e Mon Sep 17 00:00:00 2001 > From: Kent Overstreet <kmo@xxxxxxxxxxxxx> > Date: Sun, 19 Jan 2014 08:26:37 +0000 > Subject: percpu_ida: Make percpu_ida_alloc + callers accept task state bitmask > > From: Kent Overstreet <kmo@xxxxxxxxxxxxx> > > 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 <torvalds@xxxxxxxxxxxxxxxxxxxx> > Cc: Linus Torvalds <torvalds@xxxxxxxxxxxxxxxxxxxx> > Cc: Ingo Molnar <mingo@xxxxxxxxxx> > Cc: Peter Zijlstra <peterz@xxxxxxxxxxxxx> > Cc: Jens Axboe <axboe@xxxxxxxxx> > Signed-off-by: Kent Overstreet <kmo@xxxxxxxxxxxxx> > Signed-off-by: Nicholas Bellinger <nab@xxxxxxxxxxxxxxx> > Signed-off-by: Greg Kroah-Hartman <gregkh@xxxxxxxxxxxxxxxxxxx> > > --- > block/blk-mq-tag.c | 6 ++++-- > drivers/target/iscsi/iscsi_target_util.c | 8 ++++++-- > drivers/target/tcm_fc/tfc_cmd.c | 2 +- > drivers/vhost/scsi.c | 2 +- > include/linux/percpu_ida.h | 3 ++- > lib/percpu_ida.c | 16 +++++++++------- > 6 files changed, 23 insertions(+), 14 deletions(-) > > --- a/block/blk-mq-tag.c > +++ b/block/blk-mq-tag.c > @@ -36,7 +36,8 @@ static unsigned int __blk_mq_get_tag(str > { > int tag; > > - tag = percpu_ida_alloc(&tags->free_tags, gfp); > + tag = percpu_ida_alloc(&tags->free_tags, (gfp & __GFP_WAIT) ? > + TASK_UNINTERRUPTIBLE : TASK_RUNNING); > if (tag < 0) > return BLK_MQ_TAG_FAIL; > return tag + tags->nr_reserved_tags; > @@ -52,7 +53,8 @@ static unsigned int __blk_mq_get_reserve > return BLK_MQ_TAG_FAIL; > } > > - tag = percpu_ida_alloc(&tags->reserved_tags, gfp); > + tag = percpu_ida_alloc(&tags->reserved_tags, (gfp & __GFP_WAIT) ? > + TASK_UNINTERRUPTIBLE : TASK_RUNNING); > if (tag < 0) > return BLK_MQ_TAG_FAIL; > return tag; > --- 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/target/tcm_fc/tfc_cmd.c > +++ b/drivers/target/tcm_fc/tfc_cmd.c > @@ -438,7 +438,7 @@ static void ft_recv_cmd(struct ft_sess * > struct se_session *se_sess = sess->se_sess; > int tag; > > - 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) > goto busy; > > --- 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 <linux/types.h> > #include <linux/bitops.h> > #include <linux/init.h> > +#include <linux/sched.h> > #include <linux/spinlock_types.h> > #include <linux/wait.h> > #include <linux/cpumask.h> > @@ -61,7 +62,7 @@ struct percpu_ida { > /* Max size of percpu freelist, */ > #define IDA_DEFAULT_PCPU_SIZE ((IDA_DEFAULT_PCPU_BATCH_MOVE * 3) / 2) > > -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 > @@ -132,22 +132,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; > @@ -174,7 +174,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); > @@ -191,7 +192,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(); > @@ -199,8 +200,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); > > > Patches currently in stable-queue which might be from kmo@xxxxxxxxxxxxx are > > queue-3.13/percpu_ida-make-percpu_ida_alloc-callers-accept-task-state-bitmask.patch -- To unsubscribe from this list: send the line "unsubscribe stable" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html