percpu_ida+Co: Make percpu_ida_alloc accept task state bitmask
Subsystems (8)
cover percpu_ida+Co: Make percpu_ida_alloc accept task state bitmask
From: Nicholas Bellinger <[email protected]>
Hello Linus,
Here is the series for converting percpu_ida_alloc() + consumer usage to accept the task state bitmask parameter, w/o the extra legacy gfp_t wrapper.
Also, given that the first three patches needs to be backported to different kernel versions, the series has been broken up into seperate commits for blk-mq (v3.13.y) and target/* (v3.12.y) with the minimal set of changes marked for stable.
The last two patches propigate task state bitmask usage further up the blk-mq + target/iscsi stack, and as improvements are not marked for stable code.
CC'ing Ingo + Peter for TASK_RUNNING + prepare_to_wait() bit.
Thank you,
--nab
Kent Overstreet (1):
percpu_ida: Make percpu_ida_alloc accept task state bitmask
Nicholas Bellinger (4):
blk-mq: Update percpu_ida_alloc to use task state bitmask
target: Update percpu_ida_alloc to use task state bitmask
blk-mq: Convert gfp_t parameters to task state bitmask target/iscsi: Convert gfp_t parameter to task state bitmask
block/blk-core.c | 4 +++- block/blk-flush.c | 2 +- block/blk-mq-tag.c | 14 +++++++------- block/blk-mq-tag.h | 2 +- block/blk-mq.c | 28 ++++++++++++++-------------- drivers/infiniband/ulp/isert/ib_isert.c | 14 +++++++------- drivers/target/iscsi/iscsi_target.c | 14 +++++++------- drivers/target/iscsi/iscsi_target_util.c | 9 ++++++--- drivers/target/iscsi/iscsi_target_util.h | 2 +- drivers/vhost/scsi.c | 2 +- include/linux/blk-mq.h | 4 ++-- include/linux/percpu_ida.h | 3 ++- include/target/iscsi/iscsi_transport.h | 2 +- lib/percpu_ida.c | 17 +++++++++++------ 14 files changed, 64 insertions(+), 53 deletions(-)
Signature · 1 line
1.7.10.4
PATCH 1/5 percpu_ida: Make percpu_ida_alloc accept task state bitmask
From: Kent Overstreet <[email protected]>
This patch changes percpu_ida_alloc() to accept task state bitmask for prepare_to_wait() to support interruptible sleep for callers that require it.
Previously, this code was assuming uninterruptible sleep for all cases thus preventing signals from being delivered to a scheduled process context in the tag stealing slow path.
It now accepts TASK_INTERRUPTIBLE or 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 tag.
--- include/linux/percpu_ida.h | 3 ++- lib/percpu_ida.c | 17 +++++++++++------ 2 files changed, 13 insertions(+), 7 deletions(-)
include/linux/percpu_ida.h +2 -1
@@ -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);
lib/percpu_ida.c +11 -6
@@ -132,22 +132,22 @@ static inline unsigned alloc_local_tag(struct percpu_ida_cpu *tags)/** * 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_INTERRUPTIBLE | 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_INTERRUPTIBLE | 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,7 @@ int percpu_ida_alloc(struct percpu_ida *pool, gfp_t gfp)* * global lock held and irqs disabled, don't need percpu lock */ -prepare_to_wait (&pool->wait, &wait,TASK_UNINTERRUPTIBLE ); +prepare_to_wait (&pool->wait, &wait, state);if (!tags->nr_free)alloc_global_tags (pool, tags);
@@ -191,9 +191,14 @@ int percpu_ida_alloc(struct percpu_ida *pool, gfp_t gfp)spin_unlock (&pool->lock);local_irq_restore (flags); -if (tag >=0 || !(gfp & __GFP_WAIT)) +if (tag >=0 || state ==TASK_RUNNING )break ; +if (signal_pending_state (state, current)) { + tag = -ERESTARTSYS ; +break ; + } +schedule ();local_irq_save (flags);
Signature · 1 line
1.7.10.4
Re: [PATCH 1/5] percpu_ida: Make percpu_ida_alloc accept task state bitmask
Quoted 4 lines · Nicholas A. Bellinger
This patch changes
percpu_ida_alloc()to accept task state bitmask forprepare_to_wait()to support interruptible sleep for callers that require it.
This patch-series is not bisectable. Afaik, the first patch will break the build (or at least cause the end result to not actually work).
This kind of "split up one large patch into many small patches THAT DON'T ACTUALLY WORK INDIVIDUALLY" model is pure and utter garbage.
So a big NAK on this series as being completely broken.
To fix it, I would suggest:
- make the first patch change all *existing* users (that only have
the atomic vs uninterruptible semantics) pass in either TASK_UNINTERRUPTIBLE or TASK_RUNNING depending on whether they had __GFP_WAIT or not.
So the first patch would not change *any* semantics or behavior, it
would only change the calling convention.
- do the cleanup patches to block/blk-mq-tag.c to not have those
"gfp" calling convention, and instead passing in the state natively
- add the TASK_INTERRUPTIBLE case last (which includes the new
"signal_pending_state()" logic in percpu_ida_alloc())
that way, all patches compile cleanly and should each work individually, and they all do clearly just one thing. And the biggest patch in the series (the first one) doesn't actually make any semantic changes.
Linus
Re: [PATCH 1/5] percpu_ida: Make percpu_ida_alloc accept task state bitmask
Quoted 7 lines · Linus Torvalds
Quoted 4 lines · Nicholas A. Bellinger
This patch changes
percpu_ida_alloc()to accept task state bitmask forprepare_to_wait()to support interruptible sleep for callers that require it.
Quoted 8 lines
This patch-series is not bisectable. Afaik, the first patch will break the build (or at least cause the end result to not actually work).
This kind of "split up one large patch into many small patches THAT DON'T ACTUALLY WORK INDIVIDUALLY" model is pure and utter garbage.
So a big NAK on this series as being completely broken.
So the late night reasoning was to allow the patches to apply cleanly to stable. That was, indeed, a bad decision.
Quoted 13 lines
To fix it, I would suggest:
- make the first patch change all *existing* users (that only have
the atomic vs uninterruptible semantics) pass in eitherTASK_UNINTERRUPTIBLEorTASK_RUNNINGdepending on whether they had__GFP_WAITor not.So the first patch would not change *any* semantics or behavior, it
would only change the calling convention.- do the cleanup patches to
block/blk-mq-tag.cto not have those
"gfp" calling convention, and instead passing in the state natively
Quoted 7 lines
- add the
TASK_INTERRUPTIBLEcase last (which includes the new
"signal_pending_state()" logic inpercpu_ida_alloc())that way, all patches compile cleanly and should each work individually, and they all do clearly just one thing. And the biggest patch in the series (the first one) doesn't actually make any semantic changes.
-v2 sent out. Please review.
Jens, please review the blk-mq specific changes in patch #1, and let me know if you'd like to pick-up #2 via the block tree, or have it included in target-pending/for-next.
Thanks,
--nab
PATCH 2/5 blk-mq: Update percpu_ida_alloc to use task state bitmask
In reply to Nicholas A. BellingerFrom: Nicholas Bellinger <[email protected]>
This patch updates percpu_ida_alloc() usage within blk-mq tag allocation code to use TASK_UNINTERRUPTIBLE (may sleep) or ASK_RUNNING (cannot sleep), following the changes to percpu_ida to allow for task state bitmask to be passed from the caller.
--- block/blk-mq-tag.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
block/blk-mq-tag.c +4 -2
@@ -36,7 +36,8 @@ static unsigned int __blk_mq_get_tag(struct blk_mq_tags *tags, gfp_t gfp) {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_reserved_tag(struct blk_mq_tags *tags,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;
Signature · 1 line
1.7.10.4
PATCH 3/5 target: Update percpu_ida_alloc to use task state bitmask
In reply to Nicholas A. BellingerFrom: Nicholas Bellinger <[email protected]>
This patch updates percpu_ida_alloc() for target/vhost to TASK_RUNNING (cannot sleep) instead of GFP_ATOMIC, and updates iscsi-target to use TASK_INTERRUPTIBLE (may sleep) or TASK_RUNNING (cannot sleep).
Both are following the changes to percpu_ida to allow for task state bitmask to be passed from the caller.
--- drivers/target/iscsi/iscsi_target_util.c | 8 ++++++-- drivers/vhost/scsi.c | 2 +- 2 files changed, 7 insertions(+), 3 deletions(-)
drivers/target/iscsi/iscsi_target_util.c +6 -2
@@ -156,9 +156,13 @@ struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *conn, gfp_t gfp_mask) {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_INTERRUPTIBLE : +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);
drivers/vhost/scsi.c +1 -1
@@ -728,7 +728,7 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, } 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 );
Signature · 1 line
1.7.10.4
PATCH 4/5 blk-mq: Convert gfp_t parameters to task state bitmask
In reply to Nicholas A. BellingerFrom: Nicholas Bellinger <[email protected]>
This patch propigates the use of task state bitmask for percpu_ida_alloc() up the blk-mq callchain, to the point in blk_get_request() where the blk-mq vs. blk-old split occurs.
Along with the obvious parameters changes, there are two cases in mq_flush_work() + blk_mq_make_request() where the original code was using __GFP_WAIT|GFP_ATOMIC that always expect a tag which have been converted to TASK_UNINTERRUPTIBLE.
--- block/blk-core.c | 4 +++- block/blk-flush.c | 2 +- block/blk-mq-tag.c | 16 +++++++--------- block/blk-mq-tag.h | 2 +- block/blk-mq.c | 28 ++++++++++++++-------------- include/linux/blk-mq.h | 4 ++-- 6 files changed, 28 insertions(+), 28 deletions(-)
block/blk-core.c +3 -1
@@ -1112,7 +1112,9 @@ static struct request *blk_old_get_request(struct request_queue *q, int rw,struct request *blk_get_request (struct request_queue *q,int rw,gfp_t gfp_mask) {if (q->mq_ops) -return blk_mq_alloc_request (q, rw, gfp_mask, false); +return blk_mq_alloc_request (q, rw, (gfp_mask & __GFP_WAIT) ? +TASK_UNINTERRUPTIBLE :TASK_RUNNING , + false);else return blk_old_get_request (q, rw, gfp_mask); }
block/blk-flush.c +1 -1
@@ -286,7 +286,7 @@ static void mq_flush_work(struct work_struct *work)/* We don't need set REQ_FLUSH_SEQ, it's for consistency */ rq =blk_mq_alloc_request (q,WRITE_FLUSH |REQ_FLUSH_SEQ , - __GFP_WAIT|GFP_ATOMIC , true); +TASK_UNINTERRUPTIBLE , true); rq->cmd_type =REQ_TYPE_FS ; rq->end_io = flush_end_io;
block/blk-mq-tag.c +7 -9
@@ -32,19 +32,18 @@ bool blk_mq_has_free_tags(struct blk_mq_tags *tags)percpu_ida_free_tags (&tags->free_tags, nr_cpu_ids) !=0 ; } -static unsigned int __blk_mq_get_tag (struct blk_mq_tags *tags,gfp_t gfp) +static unsigned int __blk_mq_get_tag (struct blk_mq_tags *tags,int state) {int tag; - tag =percpu_ida_alloc (&tags->free_tags, (gfp & __GFP_WAIT) ? -TASK_UNINTERRUPTIBLE :TASK_RUNNING ); + tag =percpu_ida_alloc (&tags->free_tags, state);if (tag <0 )return BLK_MQ_TAG_FAIL ;return tag + tags->nr_reserved_tags; }static unsigned int __blk_mq_get_reserved_tag (struct blk_mq_tags *tags, -gfp_t gfp) +int state) {int tag;
@@ -53,19 +52,18 @@ static unsigned int __blk_mq_get_reserved_tag(struct blk_mq_tags *tags,return BLK_MQ_TAG_FAIL ; } - tag =percpu_ida_alloc (&tags->reserved_tags, (gfp & __GFP_WAIT) ? -TASK_UNINTERRUPTIBLE :TASK_RUNNING ); + tag =percpu_ida_alloc (&tags->reserved_tags, state);if (tag <0 )return BLK_MQ_TAG_FAIL ;return tag; } -unsigned int blk_mq_get_tag (struct blk_mq_tags *tags,gfp_t gfp,bool reserved) +unsigned int blk_mq_get_tag (struct blk_mq_tags *tags,int state,bool reserved) {if (!reserved) -return __blk_mq_get_tag (tags, gfp); +return __blk_mq_get_tag (tags, state); -return __blk_mq_get_reserved_tag (tags, gfp); +return __blk_mq_get_reserved_tag (tags, state); }static void __blk_mq_put_tag (struct blk_mq_tags *tags,unsigned int tag)
block/blk-mq-tag.h +1 -1
@@ -6,7 +6,7 @@ struct blk_mq_tags;extern struct blk_mq_tags *blk_mq_init_tags (unsigned int nr_tags,unsigned int reserved_tags,int node);extern void blk_mq_free_tags (struct blk_mq_tags *tags); -extern unsigned int blk_mq_get_tag (struct blk_mq_tags *tags,gfp_t gfp,bool reserved); +extern unsigned int blk_mq_get_tag (struct blk_mq_tags *tags,int state,bool reserved);extern void blk_mq_wait_for_tags (struct blk_mq_tags *tags);extern void blk_mq_put_tag (struct blk_mq_tags *tags,unsigned int tag);extern void blk_mq_tag_busy_iter (struct blk_mq_tags *tags,void (*fn)(void *data,unsigned long *),void *data);
block/blk-mq.c +14 -14
@@ -75,13 +75,13 @@ static void blk_mq_hctx_mark_pending(struct blk_mq_hw_ctx *hctx,set_bit (ctx->index_hw, hctx->ctx_map); } -static struct request *blk_mq_alloc_rq (struct blk_mq_hw_ctx *hctx,gfp_t gfp, +static struct request *blk_mq_alloc_rq (struct blk_mq_hw_ctx *hctx,int state,bool reserved) {struct request *rq;unsigned int tag; - tag =blk_mq_get_tag (hctx->tags, gfp, reserved); + tag =blk_mq_get_tag (hctx->tags, state, reserved);if (tag !=BLK_MQ_TAG_FAIL ) { rq = hctx->rqs[tag]; rq->tag = tag;
@@ -183,13 +183,13 @@ static void blk_mq_rq_ctx_init(struct request_queue *q, struct blk_mq_ctx *ctx, }static struct request *__blk_mq_alloc_request (struct blk_mq_hw_ctx *hctx, -gfp_t gfp,bool reserved) +int state,bool reserved) { -return blk_mq_alloc_rq (hctx, gfp, reserved); +return blk_mq_alloc_rq (hctx, state, reserved); }static struct request *blk_mq_alloc_request_pinned (struct request_queue *q, -int rw,gfp_t gfp, +int rw,int state,bool reserved) {struct request *rq;
@@ -198,14 +198,14 @@ static struct request *blk_mq_alloc_request_pinned(struct request_queue *q,struct blk_mq_ctx *ctx =blk_mq_get_ctx (q);struct blk_mq_hw_ctx *hctx = q->mq_ops->map_queue (q, ctx->cpu); - rq =__blk_mq_alloc_request (hctx, gfp & ~__GFP_WAIT, reserved); + rq =__blk_mq_alloc_request (hctx, state, reserved);if (rq) {blk_mq_rq_ctx_init (q, ctx, rq, rw);break ; }blk_mq_put_ctx (ctx); -if (!(gfp & __GFP_WAIT)) +if (state ==TASK_RUNNING )break ;__blk_mq_run_hw_queue (hctx);
@@ -216,28 +216,28 @@ static struct request *blk_mq_alloc_request_pinned(struct request_queue *q, }struct request *blk_mq_alloc_request (struct request_queue *q,int rw, -gfp_t gfp,bool reserved) +int state,bool reserved) {struct request *rq;if (blk_mq_queue_enter (q))return NULL ; - rq =blk_mq_alloc_request_pinned (q, rw, gfp, reserved); + rq =blk_mq_alloc_request_pinned (q, rw, state, reserved);if (rq)blk_mq_put_ctx (rq->mq_ctx);return rq; }struct request *blk_mq_alloc_reserved_request (struct request_queue *q,int rw, -gfp_t gfp) +int state) {struct request *rq;if (blk_mq_queue_enter (q))return NULL ; - rq =blk_mq_alloc_request_pinned (q, rw, gfp, true); + rq =blk_mq_alloc_request_pinned (q, rw, state, true);if (rq)blk_mq_put_ctx (rq->mq_ctx);return rq;
@@ -928,14 +928,14 @@ static void blk_mq_make_request(struct request_queue *q, struct bio *bio) hctx = q->mq_ops->map_queue (q, ctx->cpu);trace_block_getrq (q, bio, rw); - rq =__blk_mq_alloc_request (hctx,GFP_ATOMIC , false); + rq =__blk_mq_alloc_request (hctx,TASK_RUNNING , false);if (likely (rq))blk_mq_rq_ctx_init (q, ctx, rq, rw);else {blk_mq_put_ctx (ctx);trace_block_sleeprq (q, bio, rw); - rq =blk_mq_alloc_request_pinned (q, rw, __GFP_WAIT|GFP_ATOMIC , - false); + rq =blk_mq_alloc_request_pinned (q, rw,TASK_UNINTERRUPTIBLE , + false); ctx = rq->mq_ctx; hctx = q->mq_ops->map_queue (q, ctx->cpu); }
include/linux/blk-mq.h +2 -2
@@ -124,8 +124,8 @@ void blk_mq_insert_request(struct request_queue *, struct request *, bool);void blk_mq_run_queues (struct request_queue *q,bool async);void blk_mq_free_request (struct request *rq);bool blk_mq_can_queue (struct blk_mq_hw_ctx *); -struct request *blk_mq_alloc_request (struct request_queue *q,int rw,gfp_t gfp,bool reserved); -struct request *blk_mq_alloc_reserved_request (struct request_queue *q,int rw,gfp_t gfp); +struct request *blk_mq_alloc_request (struct request_queue *q,int rw,int state,bool reserved); +struct request *blk_mq_alloc_reserved_request (struct request_queue *q,int rw,int state);struct request *blk_mq_rq_from_tag (struct request_queue *q,unsigned int tag);struct blk_mq_hw_ctx *blk_mq_map_queue (struct request_queue *,const int ctx_index);
Signature · 1 line
1.7.10.4
PATCH 5/5 target/iscsi: Convert gfp_t parameter to task state bitmask
In reply to Nicholas A. BellingerFrom: Nicholas Bellinger <[email protected]>
This patch propigates the use of task state bitmask now used by percpu_ida_alloc() up the iscsi-target callchain, replacing the use of GFP_ATOMIC + GFP_KERNEL.
Also, drop the unnecessary gfp_t parameter to isert_allocate_cmd(), and just pass TASK_INTERRUPTIBLE into iscsit_allocate_cmd().
--- drivers/infiniband/ulp/isert/ib_isert.c | 14 +++++++------- drivers/target/iscsi/iscsi_target.c | 14 +++++++------- drivers/target/iscsi/iscsi_target_util.c | 7 +++---- drivers/target/iscsi/iscsi_target_util.h | 2 +- include/target/iscsi/iscsi_transport.h | 2 +- 5 files changed, 19 insertions(+), 20 deletions(-)
drivers/infiniband/ulp/isert/ib_isert.c +7 -7
@@ -1028,13 +1028,13 @@ isert_rx_login_req(struct iser_rx_desc *rx_desc, int rx_buflen, }static struct iscsi_cmd -*isert_allocate_cmd (struct iscsi_conn *conn,gfp_t gfp) +*isert_allocate_cmd (struct iscsi_conn *conn) {struct isert_conn *isert_conn = (struct isert_conn *)conn->context;struct isert_cmd *isert_cmd;struct iscsi_cmd *cmd; - cmd =iscsit_allocate_cmd (conn, gfp); + cmd =iscsit_allocate_cmd (conn,TASK_INTERRUPTIBLE );if (!cmd) {pr_err ("Unable to allocate iscsi_cmd + isert_cmd\n" );return NULL ;
@@ -1223,7 +1223,7 @@ isert_rx_opcode(struct isert_conn *isert_conn, struct iser_rx_desc *rx_desc,switch (opcode) {case ISCSI_OP_SCSI_CMD : - cmd =isert_allocate_cmd (conn,GFP_KERNEL ); + cmd =isert_allocate_cmd (conn);if (!cmd)break ;
@@ -1237,7 +1237,7 @@ isert_rx_opcode(struct isert_conn *isert_conn, struct iser_rx_desc *rx_desc, rx_desc, (unsigned char *)hdr);break ;case ISCSI_OP_NOOP_OUT : - cmd =isert_allocate_cmd (conn,GFP_KERNEL ); + cmd =isert_allocate_cmd (conn);if (!cmd)break ;
@@ -1250,7 +1250,7 @@ isert_rx_opcode(struct isert_conn *isert_conn, struct iser_rx_desc *rx_desc, (unsigned char *)hdr);break ;case ISCSI_OP_SCSI_TMFUNC : - cmd =isert_allocate_cmd (conn,GFP_KERNEL ); + cmd =isert_allocate_cmd (conn);if (!cmd)break ;
@@ -1258,7 +1258,7 @@ isert_rx_opcode(struct isert_conn *isert_conn, struct iser_rx_desc *rx_desc, (unsigned char *)hdr);break ;case ISCSI_OP_LOGOUT : - cmd =isert_allocate_cmd (conn,GFP_KERNEL ); + cmd =isert_allocate_cmd (conn);if (!cmd)break ;
@@ -1269,7 +1269,7 @@ isert_rx_opcode(struct isert_conn *isert_conn, struct iser_rx_desc *rx_desc, HZ);break ;case ISCSI_OP_TEXT : - cmd =isert_allocate_cmd (conn,GFP_KERNEL ); + cmd =isert_allocate_cmd (conn);if (!cmd)break ;
drivers/target/iscsi/iscsi_target.c +7 -7
@@ -621,7 +621,7 @@ static int iscsit_add_reject( {struct iscsi_cmd *cmd; - cmd =iscsit_allocate_cmd (conn,GFP_KERNEL ); + cmd =iscsit_allocate_cmd (conn,TASK_INTERRUPTIBLE );if (!cmd)return -1 ;
@@ -2476,7 +2476,7 @@ static void iscsit_build_conn_drop_async_message(struct iscsi_conn *conn)if (!conn_p)return ; - cmd =iscsit_allocate_cmd (conn_p,GFP_ATOMIC ); + cmd =iscsit_allocate_cmd (conn_p,TASK_RUNNING );if (!cmd) {iscsit_dec_conn_usage_count (conn_p);return ;
@@ -3952,7 +3952,7 @@ static int iscsi_target_rx_opcode(struct iscsi_conn *conn, unsigned char *buf)switch (hdr->opcode &ISCSI_OPCODE_MASK ) {case ISCSI_OP_SCSI_CMD : - cmd =iscsit_allocate_cmd (conn,GFP_KERNEL ); + cmd =iscsit_allocate_cmd (conn,TASK_INTERRUPTIBLE );if (!cmd) goto reject;
@@ -3964,28 +3964,28 @@ static int iscsi_target_rx_opcode(struct iscsi_conn *conn, unsigned char *buf)case ISCSI_OP_NOOP_OUT : cmd =NULL ;if (hdr->ttt ==cpu_to_be32 (0xFFFFFFFF )) { - cmd =iscsit_allocate_cmd (conn,GFP_KERNEL ); + cmd =iscsit_allocate_cmd (conn,TASK_INTERRUPTIBLE );if (!cmd) goto reject; } ret =iscsit_handle_nop_out (conn, cmd, buf);break ;case ISCSI_OP_SCSI_TMFUNC : - cmd =iscsit_allocate_cmd (conn,GFP_KERNEL ); + cmd =iscsit_allocate_cmd (conn,TASK_INTERRUPTIBLE );if (!cmd) goto reject; ret =iscsit_handle_task_mgt_cmd (conn, cmd, buf);break ;case ISCSI_OP_TEXT : - cmd =iscsit_allocate_cmd (conn,GFP_KERNEL ); + cmd =iscsit_allocate_cmd (conn,TASK_INTERRUPTIBLE );if (!cmd) goto reject; ret =iscsit_handle_text_cmd (conn, cmd, buf);break ;case ISCSI_OP_LOGOUT : - cmd =iscsit_allocate_cmd (conn,GFP_KERNEL ); + cmd =iscsit_allocate_cmd (conn,TASK_INTERRUPTIBLE );if (!cmd) goto reject;
drivers/target/iscsi/iscsi_target_util.c +3 -4
@@ -152,12 +152,11 @@ void iscsit_free_r2ts_from_list(struct iscsi_cmd *cmd)* May be called from software interrupt (timer) context for allocating * iSCSI NopINs. */ -struct iscsi_cmd *iscsit_allocate_cmd (struct iscsi_conn *conn,gfp_t gfp_mask) +struct iscsi_cmd *iscsit_allocate_cmd (struct iscsi_conn *conn,int state) {struct iscsi_cmd *cmd;struct se_session *se_sess = conn->sess->se_sess; -int size, tag, state = (gfp_mask & __GFP_WAIT) ?TASK_INTERRUPTIBLE : -TASK_RUNNING ; +int size, tag; tag =percpu_ida_alloc (&se_sess->sess_tag_pool, state);if (tag <0 )
@@ -930,7 +929,7 @@ static int iscsit_add_nopin(struct iscsi_conn *conn, int want_response)u8 state;struct iscsi_cmd *cmd; - cmd =iscsit_allocate_cmd (conn,GFP_ATOMIC ); + cmd =iscsit_allocate_cmd (conn,TASK_RUNNING );if (!cmd)return -1 ;
drivers/target/iscsi/iscsi_target_util.h +1 -1
@@ -9,7 +9,7 @@ extern struct iscsi_r2t *iscsit_get_r2t_from_list(struct iscsi_cmd *);extern void iscsit_free_r2t (struct iscsi_r2t *,struct iscsi_cmd *);extern void iscsit_free_r2ts_from_list (struct iscsi_cmd *);extern struct iscsi_cmd *iscsit_alloc_cmd (struct iscsi_conn *,gfp_t ); -extern struct iscsi_cmd *iscsit_allocate_cmd (struct iscsi_conn *,gfp_t ); +extern struct iscsi_cmd *iscsit_allocate_cmd (struct iscsi_conn *,int );extern struct iscsi_seq *iscsit_get_seq_holder_for_datain (struct iscsi_cmd *,u32 );extern struct iscsi_seq *iscsit_get_seq_holder_for_r2t (struct iscsi_cmd *);extern struct iscsi_r2t *iscsit_get_holder_for_r2tsn (struct iscsi_cmd *,u32 );
include/target/iscsi/iscsi_transport.h +1 -1
@@ -94,7 +94,7 @@ extern int iscsit_tmr_post_handler(struct iscsi_cmd *, struct iscsi_conn *);/* * From iscsi_target_util.c */ -extern struct iscsi_cmd *iscsit_allocate_cmd (struct iscsi_conn *,gfp_t ); +extern struct iscsi_cmd *iscsit_allocate_cmd (struct iscsi_conn *,int );extern int iscsit_sequence_cmd (struct iscsi_conn *,struct iscsi_cmd *,unsigned char *,__be32 );extern void iscsit_release_cmd (struct iscsi_cmd *);
Signature · 1 line
1.7.10.4