From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Cyrus-Session-Id: sloti22d1t05-2820460-1526400198-2-8613916623562425248 X-Sieve: CMU Sieve 3.0 X-Spam-known-sender: no X-Spam-score: 0.0 X-Spam-hits: BAYES_00 -1.9, HEADER_FROM_DIFFERENT_DOMAINS 0.249, MAILING_LIST_MULTI -1, RCVD_IN_DNSWL_HI -5, LANGUAGES unknown, BAYES_USED global, SA_VERSION 3.4.0 X-Spam-source: IP='209.132.180.67', Host='vger.kernel.org', Country='US', FromHeader='org', MailFrom='org' X-Spam-charsets: X-Resolved-to: greg@kroah.com X-Delivered-to: greg@kroah.com X-Mail-from: linux-usb-owner@vger.kernel.org ARC-Seal: i=1; a=rsa-sha256; cv=none; d=messagingengine.com; s=fm2; t= 1526400197; b=Z/i/JJrjB8KdJXPyYosI1zkDqZ0HjqhUCVT8+EsHhVPbeWU1Tf ZFGlbg3lo57IzNZUSiPKiYQLv6nYIgyBTGNxXs5zJNewRjrTP4X4iJ39nt2itfDT 3vJqVoBtbhWYbL2Oho7MCVdfTXYoTjTLPvv5K+dXp2fJXHy5RZGVTPhpy00Sq/DF iCCoOns1/1HRty2vrvcMgzJCjHMXWv9uWRf2pL+QqTSEE4/N9J5lx+qvKsgQC6f7 5nlDxXk5lKAGiiFCZ6Kc/031b0rLMAEgHvFt2HkhFGeTEWKyC0vHarQ2cQtG4rBg 0ex58tdsXHqQJR43TN6RcQl+bQvgvdkq5rDg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=from:to:cc:subject:date:message-id :in-reply-to:references:sender:list-id; s=fm2; t=1526400197; bh= MTvrwJGhyyXqSAX1PNWffok77ziJ5PzTRzIOG6c0UAk=; b=SGFrnisr5wtjwDwX zBLxpWrJCq2WazWYr0kUhOe/kMeX/LU1MjWG0LaMEDLppXuxV9vnHgirIXthFB1W VGJHZFJrj7IEo0zL/hZuXU1vXtLg1FKU2vhoD+I6l9QuB6xh0/BE1Glb/H1/ZHrt UBj8Jxe2k5bV3eb8qJZxS+uyOa9z5im7GdaAXKjTMBXUz9QLxA52U3k86lfhZhNl v49/R5R4egknj4KnjhouZWCGQ0PRVCKkH3QevnMybQoZZ2d5OZ2hvTz5crxGz/kQ WNZoCZK0jiO3KK3c0it08J2CVQmIUMz4uLWqDgMoTLXsXb6TasgQ+rOBI7+D4bAL ehXoCw== ARC-Authentication-Results: i=1; mx4.messagingengine.com; arc=none (no signatures found); dkim=fail (message has been altered, 2048-bit rsa key sha256) header.d=infradead.org header.i=@infradead.org header.b=UQ2n9jn0 x-bits=2048 x-keytype=rsa x-algorithm=sha256 x-selector=bombadil.20170209; dmarc=none (p=none,has-list-id=yes,d=none) header.from=infradead.org; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=linux-usb-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-cm=none score=0; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=infradead.org header.result=pass header_is_org_domain=yes; x-vs=clean score=-100 state=0 Authentication-Results: mx4.messagingengine.com; arc=none (no signatures found); dkim=fail (message has been altered, 2048-bit rsa key sha256) header.d=infradead.org header.i=@infradead.org header.b=UQ2n9jn0 x-bits=2048 x-keytype=rsa x-algorithm=sha256 x-selector=bombadil.20170209; dmarc=none (p=none,has-list-id=yes,d=none) header.from=infradead.org; iprev=pass policy.iprev=209.132.180.67 (vger.kernel.org); spf=none smtp.mailfrom=linux-usb-owner@vger.kernel.org smtp.helo=vger.kernel.org; x-aligned-from=fail; x-cm=none score=0; x-ptr=pass x-ptr-helo=vger.kernel.org x-ptr-lookup=vger.kernel.org; x-return-mx=pass smtp.domain=vger.kernel.org smtp.result=pass smtp_org.domain=kernel.org smtp_org.result=pass smtp_is_org_domain=no header.domain=infradead.org header.result=pass header_is_org_domain=yes; x-vs=clean score=-100 state=0 X-ME-VSCategory: clean X-CM-Envelope: MS4wfAfWl5knxHsmmV+zkTi/aXs4LZbiy7NKEBxw39FLbv8bTJo41iaXNTiyspCAkYzZ72nZc4AeRMD8eJd6jaToSOOjjTfiNAiGEXKu6rY03nbwU/M8nBC8 ApWHty9rumQ5Pt/qW8jlEb3WMEyaLwjrfEb0434AT9edzMqR+S0GG5QxysJ8AqFd2ID9PsuNc3t81QpxHi2NWD42ffLPenxc7F83mEkCxB0+MhW6bCJPtDpy X-CM-Analysis: v=2.3 cv=JLoVTfCb c=1 sm=1 tr=0 a=UK1r566ZdBxH71SXbqIOeA==:117 a=UK1r566ZdBxH71SXbqIOeA==:17 a=VUJBJC2UJ8kA:10 a=yMhMjlubAAAA:8 a=ZNa7TQ0pAAAA:8 a=VwQbUJbxAAAA:8 a=_jyNjG163UNa4w9HebYA:9 a=snlWHivmDySmj9uY:21 a=W2B1JoGU7TJzd_yx:21 a=x8gzFH9gYPwA:10 a=vJYgOXllGJzHSJiAounk:22 a=AjGcO6oz07-iQ99wixmX:22 X-ME-CMScore: 0 X-ME-CMCategory: none Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753642AbeEOQCw (ORCPT ); Tue, 15 May 2018 12:02:52 -0400 Received: from bombadil.infradead.org ([198.137.202.133]:55484 "EHLO bombadil.infradead.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752632AbeEOQAt (ORCPT ); Tue, 15 May 2018 12:00:49 -0400 From: Matthew Wilcox To: linux-kernel@vger.kernel.org, linux-scsi@vger.kernel.org, target-devel@vger.kernel.org, linux1394-devel@lists.sourceforge.net, linux-usb@vger.kernel.org, kvm@vger.kernel.org, virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, Juergen Gross , qla2xxx-upstream@qlogic.com, Kent Overstreet , Jens Axboe Cc: Matthew Wilcox Subject: [PATCH 1/2] Convert target drivers to use sbitmap Date: Tue, 15 May 2018 09:00:42 -0700 Message-Id: <20180515160043.27044-2-willy@infradead.org> X-Mailer: git-send-email 2.14.3 In-Reply-To: <20180515160043.27044-1-willy@infradead.org> References: <20180515160043.27044-1-willy@infradead.org> Sender: linux-usb-owner@vger.kernel.org X-Mailing-List: linux-usb@vger.kernel.org X-getmail-retrieved-from-mailbox: INBOX X-Mailing-List: linux-kernel@vger.kernel.org List-ID: From: Matthew Wilcox The sbitmap and the percpu_ida perform essentially the same task, allocating tags for commands. Since the sbitmap is more used than the percpu_ida, convert the percpu_ida users to the sbitmap API. Signed-off-by: Matthew Wilcox --- drivers/scsi/qla2xxx/qla_target.c | 16 ++++++----- drivers/target/iscsi/iscsi_target_util.c | 34 +++++++++++++++++++++--- drivers/target/sbp/sbp_target.c | 8 +++--- drivers/target/target_core_transport.c | 5 ++-- drivers/target/tcm_fc/tfc_cmd.c | 11 ++++---- drivers/usb/gadget/function/f_tcm.c | 8 +++--- drivers/vhost/scsi.c | 9 ++++--- drivers/xen/xen-scsiback.c | 8 +++--- include/target/iscsi/iscsi_target_core.h | 1 + include/target/target_core_base.h | 5 ++-- 10 files changed, 73 insertions(+), 32 deletions(-) diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c index 025dc2d3f3de..cdf671c2af61 100644 --- a/drivers/scsi/qla2xxx/qla_target.c +++ b/drivers/scsi/qla2xxx/qla_target.c @@ -3719,7 +3719,8 @@ void qlt_free_cmd(struct qla_tgt_cmd *cmd) return; } cmd->jiffies_at_free = get_jiffies_64(); - percpu_ida_free(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag, + cmd->se_cmd.map_cpu); } EXPORT_SYMBOL(qlt_free_cmd); @@ -4084,7 +4085,8 @@ static void __qlt_do_work(struct qla_tgt_cmd *cmd) qlt_send_term_exchange(qpair, NULL, &cmd->atio, 1, 0); qlt_decr_num_pend_cmds(vha); - percpu_ida_free(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag, + cmd->se_cmd.map_cpu); spin_unlock_irqrestore(qpair->qp_lock_ptr, flags); spin_lock_irqsave(&ha->tgt.sess_lock, flags); @@ -4215,9 +4217,9 @@ static struct qla_tgt_cmd *qlt_get_tag(scsi_qla_host_t *vha, { struct se_session *se_sess = sess->se_sess; struct qla_tgt_cmd *cmd; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return NULL; @@ -4230,6 +4232,7 @@ static struct qla_tgt_cmd *qlt_get_tag(scsi_qla_host_t *vha, qlt_incr_num_pend_cmds(vha); cmd->vha = vha; cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->sess = sess; cmd->loop_id = sess->loop_id; cmd->conf_compl_supported = sess->conf_compl_supported; @@ -5212,7 +5215,7 @@ qlt_alloc_qfull_cmd(struct scsi_qla_host *vha, struct fc_port *sess; struct se_session *se_sess; struct qla_tgt_cmd *cmd; - int tag; + int tag, cpu; unsigned long flags; if (unlikely(tgt->tgt_stop)) { @@ -5244,7 +5247,7 @@ qlt_alloc_qfull_cmd(struct scsi_qla_host *vha, se_sess = sess->se_sess; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return; @@ -5275,6 +5278,7 @@ qlt_alloc_qfull_cmd(struct scsi_qla_host *vha, cmd->reset_count = ha->base_qpair->chip_reset; cmd->q_full = 1; cmd->qpair = ha->base_qpair; + cmd->se_cmd.map_cpu = cpu; if (qfull) { cmd->q_full = 1; diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c index 4435bf374d2d..28bcffae609f 100644 --- a/drivers/target/iscsi/iscsi_target_util.c +++ b/drivers/target/iscsi/iscsi_target_util.c @@ -17,7 +17,7 @@ ******************************************************************************/ #include -#include +#include #include /* ipv6_addr_equal() */ #include #include @@ -147,6 +147,28 @@ void iscsit_free_r2ts_from_list(struct iscsi_cmd *cmd) spin_unlock_bh(&cmd->r2t_lock); } +int iscsit_wait_for_tag(struct se_session *se_sess, int state, int *cpup) +{ + int tag = -1; + DEFINE_WAIT(wait); + struct sbq_wait_state *ws; + + if (state == TASK_RUNNING) + return tag; + + ws = &se_sess->sess_tag_pool.ws[0]; + for (;;) { + prepare_to_wait_exclusive(&ws->wait, &wait, state); + if (signal_pending_state(state, current)) + break; + schedule(); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, cpup); + } + + finish_wait(&ws->wait, &wait); + return tag; +} + /* * May be called from software interrupt (timer) context for allocating * iSCSI NopINs. @@ -155,9 +177,11 @@ 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; + int size, tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, state); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); + if (tag < 0) + tag = iscsit_wait_for_tag(se_sess, state, &cpu); if (tag < 0) return NULL; @@ -166,6 +190,7 @@ struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *conn, int state) memset(cmd, 0, size); cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->conn = conn; cmd->data_direction = DMA_NONE; INIT_LIST_HEAD(&cmd->i_conn_node); @@ -711,7 +736,8 @@ void iscsit_release_cmd(struct iscsi_cmd *cmd) kfree(cmd->iov_data); kfree(cmd->text_in_ptr); - percpu_ida_free(&sess->se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } EXPORT_SYMBOL(iscsit_release_cmd); diff --git a/drivers/target/sbp/sbp_target.c b/drivers/target/sbp/sbp_target.c index fb1003921d85..c58f9f04c6be 100644 --- a/drivers/target/sbp/sbp_target.c +++ b/drivers/target/sbp/sbp_target.c @@ -926,15 +926,16 @@ static struct sbp_target_request *sbp_mgt_get_req(struct sbp_session *sess, { struct se_session *se_sess = sess->se_sess; struct sbp_target_request *req; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return ERR_PTR(-ENOMEM); req = &((struct sbp_target_request *)se_sess->sess_cmd_map)[tag]; memset(req, 0, sizeof(*req)); req->se_cmd.map_tag = tag; + req->se_cmd.map_cpu = cpu; req->se_cmd.tag = next_orb; return req; @@ -1460,7 +1461,8 @@ static void sbp_free_request(struct sbp_target_request *req) kfree(req->pg_tbl); kfree(req->cmd_buf); - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static void sbp_mgt_agent_process(struct work_struct *work) diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c index 4558f2e1fe1b..3103890ed109 100644 --- a/drivers/target/target_core_transport.c +++ b/drivers/target/target_core_transport.c @@ -260,7 +260,8 @@ int transport_alloc_session_tags(struct se_session *se_sess, } } - rc = percpu_ida_init(&se_sess->sess_tag_pool, tag_num); + rc = sbitmap_queue_init_node(&se_sess->sess_tag_pool, tag_num, -1, + false, GFP_KERNEL, NUMA_NO_NODE); if (rc < 0) { pr_err("Unable to init se_sess->sess_tag_pool," " tag_num: %u\n", tag_num); @@ -547,7 +548,7 @@ void transport_free_session(struct se_session *se_sess) target_put_nacl(se_nacl); } if (se_sess->sess_cmd_map) { - percpu_ida_destroy(&se_sess->sess_tag_pool); + sbitmap_queue_free(&se_sess->sess_tag_pool); kvfree(se_sess->sess_cmd_map); } kmem_cache_free(se_sess_cache, se_sess); diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c index ec372860106f..b3e3364b7147 100644 --- a/drivers/target/tcm_fc/tfc_cmd.c +++ b/drivers/target/tcm_fc/tfc_cmd.c @@ -28,7 +28,6 @@ #include #include #include -#include #include #include #include @@ -92,7 +91,8 @@ static void ft_free_cmd(struct ft_cmd *cmd) if (fr_seq(fp)) fc_seq_release(fr_seq(fp)); fc_frame_free(fp); - percpu_ida_free(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag, + cmd->se_cmd.map_cpu); ft_sess_put(sess); /* undo get from lookup at recv */ } @@ -448,9 +448,9 @@ static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp) struct ft_cmd *cmd; struct fc_lport *lport = sess->tport->lport; struct se_session *se_sess = sess->se_sess; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) goto busy; @@ -458,10 +458,11 @@ static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp) memset(cmd, 0, sizeof(struct ft_cmd)); cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->sess = sess; cmd->seq = fc_seq_assign(lport, fp); if (!cmd->seq) { - percpu_ida_free(&se_sess->sess_tag_pool, tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, tag, cpu); goto busy; } cmd->req_frame = fp; /* hold frame during cmd */ diff --git a/drivers/usb/gadget/function/f_tcm.c b/drivers/usb/gadget/function/f_tcm.c index d78dbb73bde8..b335f4f33bc3 100644 --- a/drivers/usb/gadget/function/f_tcm.c +++ b/drivers/usb/gadget/function/f_tcm.c @@ -1071,15 +1071,16 @@ static struct usbg_cmd *usbg_get_cmd(struct f_uas *fu, { struct se_session *se_sess = tv_nexus->tvn_se_sess; struct usbg_cmd *cmd; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return ERR_PTR(-ENOMEM); cmd = &((struct usbg_cmd *)se_sess->sess_cmd_map)[tag]; memset(cmd, 0, sizeof(*cmd)); cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->se_cmd.tag = cmd->tag = scsi_tag; cmd->fu = fu; @@ -1288,7 +1289,8 @@ static void usbg_release_cmd(struct se_cmd *se_cmd) struct se_session *se_sess = se_cmd->se_sess; kfree(cmd->data_buf); - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static u32 usbg_sess_get_index(struct se_session *se_sess) diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c index 7ad57094d736..1fadaa39f322 100644 --- a/drivers/vhost/scsi.c +++ b/drivers/vhost/scsi.c @@ -46,7 +46,6 @@ #include #include #include -#include #include "vhost.h" @@ -324,7 +323,8 @@ static void vhost_scsi_release_cmd(struct se_cmd *se_cmd) } vhost_scsi_put_inflight(tv_cmd->inflight); - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static u32 vhost_scsi_sess_get_index(struct se_session *se_sess) @@ -567,7 +567,7 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg, struct se_session *se_sess; struct scatterlist *sg, *prot_sg; struct page **pages; - int tag; + int tag, cpu; tv_nexus = tpg->tpg_nexus; if (!tv_nexus) { @@ -576,7 +576,7 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg, } se_sess = tv_nexus->tvn_se_sess; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) { pr_err("Unable to obtain tag for vhost_scsi_cmd\n"); return ERR_PTR(-ENOMEM); @@ -591,6 +591,7 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg, cmd->tvc_prot_sgl = prot_sg; cmd->tvc_upages = pages; cmd->tvc_se_cmd.map_tag = tag; + cmd->tvc_se_cmd.map_cpu = cpu; cmd->tvc_tag = scsi_tag; cmd->tvc_lun = lun; cmd->tvc_task_attr = task_attr; diff --git a/drivers/xen/xen-scsiback.c b/drivers/xen/xen-scsiback.c index 7bc88fd43cfc..d2c71b8608f0 100644 --- a/drivers/xen/xen-scsiback.c +++ b/drivers/xen/xen-scsiback.c @@ -654,9 +654,9 @@ static struct vscsibk_pend *scsiback_get_pend_req(struct vscsiif_back_ring *ring struct scsiback_nexus *nexus = tpg->tpg_nexus; struct se_session *se_sess = nexus->tvn_se_sess; struct vscsibk_pend *req; - int tag, i; + int tag, cpu, i; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) { pr_err("Unable to obtain tag for vscsiif_request\n"); return ERR_PTR(-ENOMEM); @@ -665,6 +665,7 @@ static struct vscsibk_pend *scsiback_get_pend_req(struct vscsiif_back_ring *ring req = &((struct vscsibk_pend *)se_sess->sess_cmd_map)[tag]; memset(req, 0, sizeof(*req)); req->se_cmd.map_tag = tag; + req->se_cmd.map_cpu = cpu; for (i = 0; i < VSCSI_MAX_GRANTS; i++) req->grant_handles[i] = SCSIBACK_INVALID_HANDLE; @@ -1379,7 +1380,8 @@ static void scsiback_release_cmd(struct se_cmd *se_cmd) { struct se_session *se_sess = se_cmd->se_sess; - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static u32 scsiback_sess_get_index(struct se_session *se_sess) diff --git a/include/target/iscsi/iscsi_target_core.h b/include/target/iscsi/iscsi_target_core.h index cf5f3fff1f1a..f2e6abea8490 100644 --- a/include/target/iscsi/iscsi_target_core.h +++ b/include/target/iscsi/iscsi_target_core.h @@ -4,6 +4,7 @@ #include /* enum dma_data_direction */ #include /* struct list_head */ +#include #include /* struct sockaddr_storage */ #include /* u8 */ #include /* itt_t */ diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h index 9f9f5902af38..cd417b17fee6 100644 --- a/include/target/target_core_base.h +++ b/include/target/target_core_base.h @@ -4,7 +4,7 @@ #include /* struct config_group */ #include /* enum dma_data_direction */ -#include /* struct percpu_ida */ +#include #include #include /* struct semaphore */ #include @@ -454,6 +454,7 @@ struct se_cmd { int sam_task_attr; /* Used for se_sess->sess_tag_pool */ unsigned int map_tag; + int map_cpu; /* Transport protocol dependent state, see transport_state_table */ enum transport_state_table t_state; /* See se_cmd_flags_table */ @@ -607,7 +608,7 @@ struct se_session { struct list_head sess_wait_list; spinlock_t sess_cmd_lock; void *sess_cmd_map; - struct percpu_ida sess_tag_pool; + struct sbitmap_queue sess_tag_pool; }; struct se_device; -- 2.17.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Matthew Wilcox Subject: [PATCH 1/2] Convert target drivers to use sbitmap Date: Tue, 15 May 2018 09:00:42 -0700 Message-ID: <20180515160043.27044-2-willy@infradead.org> References: <20180515160043.27044-1-willy@infradead.org> Mime-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Cc: Matthew Wilcox To: linux-kernel@vger.kernel.org, linux-scsi@vger.kernel.org, target-devel@vger.kernel.org, linux1394-devel@lists.sourceforge.net, linux-usb@vger.kernel.org, kvm@vger.kernel.org, virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, Juergen Gross , qla2xxx-upstream@qlogic.com, Kent Overstreet , Jens Axboe Return-path: In-Reply-To: <20180515160043.27044-1-willy@infradead.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: linux1394-devel-bounces@lists.sourceforge.net List-Id: netdev.vger.kernel.org From: Matthew Wilcox The sbitmap and the percpu_ida perform essentially the same task, allocating tags for commands. Since the sbitmap is more used than the percpu_ida, convert the percpu_ida users to the sbitmap API. Signed-off-by: Matthew Wilcox --- drivers/scsi/qla2xxx/qla_target.c | 16 ++++++----- drivers/target/iscsi/iscsi_target_util.c | 34 +++++++++++++++++++++--- drivers/target/sbp/sbp_target.c | 8 +++--- drivers/target/target_core_transport.c | 5 ++-- drivers/target/tcm_fc/tfc_cmd.c | 11 ++++---- drivers/usb/gadget/function/f_tcm.c | 8 +++--- drivers/vhost/scsi.c | 9 ++++--- drivers/xen/xen-scsiback.c | 8 +++--- include/target/iscsi/iscsi_target_core.h | 1 + include/target/target_core_base.h | 5 ++-- 10 files changed, 73 insertions(+), 32 deletions(-) diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c index 025dc2d3f3de..cdf671c2af61 100644 --- a/drivers/scsi/qla2xxx/qla_target.c +++ b/drivers/scsi/qla2xxx/qla_target.c @@ -3719,7 +3719,8 @@ void qlt_free_cmd(struct qla_tgt_cmd *cmd) return; } cmd->jiffies_at_free = get_jiffies_64(); - percpu_ida_free(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag, + cmd->se_cmd.map_cpu); } EXPORT_SYMBOL(qlt_free_cmd); @@ -4084,7 +4085,8 @@ static void __qlt_do_work(struct qla_tgt_cmd *cmd) qlt_send_term_exchange(qpair, NULL, &cmd->atio, 1, 0); qlt_decr_num_pend_cmds(vha); - percpu_ida_free(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag, + cmd->se_cmd.map_cpu); spin_unlock_irqrestore(qpair->qp_lock_ptr, flags); spin_lock_irqsave(&ha->tgt.sess_lock, flags); @@ -4215,9 +4217,9 @@ static struct qla_tgt_cmd *qlt_get_tag(scsi_qla_host_t *vha, { struct se_session *se_sess = sess->se_sess; struct qla_tgt_cmd *cmd; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return NULL; @@ -4230,6 +4232,7 @@ static struct qla_tgt_cmd *qlt_get_tag(scsi_qla_host_t *vha, qlt_incr_num_pend_cmds(vha); cmd->vha = vha; cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->sess = sess; cmd->loop_id = sess->loop_id; cmd->conf_compl_supported = sess->conf_compl_supported; @@ -5212,7 +5215,7 @@ qlt_alloc_qfull_cmd(struct scsi_qla_host *vha, struct fc_port *sess; struct se_session *se_sess; struct qla_tgt_cmd *cmd; - int tag; + int tag, cpu; unsigned long flags; if (unlikely(tgt->tgt_stop)) { @@ -5244,7 +5247,7 @@ qlt_alloc_qfull_cmd(struct scsi_qla_host *vha, se_sess = sess->se_sess; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return; @@ -5275,6 +5278,7 @@ qlt_alloc_qfull_cmd(struct scsi_qla_host *vha, cmd->reset_count = ha->base_qpair->chip_reset; cmd->q_full = 1; cmd->qpair = ha->base_qpair; + cmd->se_cmd.map_cpu = cpu; if (qfull) { cmd->q_full = 1; diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c index 4435bf374d2d..28bcffae609f 100644 --- a/drivers/target/iscsi/iscsi_target_util.c +++ b/drivers/target/iscsi/iscsi_target_util.c @@ -17,7 +17,7 @@ ******************************************************************************/ #include -#include +#include #include /* ipv6_addr_equal() */ #include #include @@ -147,6 +147,28 @@ void iscsit_free_r2ts_from_list(struct iscsi_cmd *cmd) spin_unlock_bh(&cmd->r2t_lock); } +int iscsit_wait_for_tag(struct se_session *se_sess, int state, int *cpup) +{ + int tag = -1; + DEFINE_WAIT(wait); + struct sbq_wait_state *ws; + + if (state == TASK_RUNNING) + return tag; + + ws = &se_sess->sess_tag_pool.ws[0]; + for (;;) { + prepare_to_wait_exclusive(&ws->wait, &wait, state); + if (signal_pending_state(state, current)) + break; + schedule(); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, cpup); + } + + finish_wait(&ws->wait, &wait); + return tag; +} + /* * May be called from software interrupt (timer) context for allocating * iSCSI NopINs. @@ -155,9 +177,11 @@ 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; + int size, tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, state); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); + if (tag < 0) + tag = iscsit_wait_for_tag(se_sess, state, &cpu); if (tag < 0) return NULL; @@ -166,6 +190,7 @@ struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *conn, int state) memset(cmd, 0, size); cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->conn = conn; cmd->data_direction = DMA_NONE; INIT_LIST_HEAD(&cmd->i_conn_node); @@ -711,7 +736,8 @@ void iscsit_release_cmd(struct iscsi_cmd *cmd) kfree(cmd->iov_data); kfree(cmd->text_in_ptr); - percpu_ida_free(&sess->se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } EXPORT_SYMBOL(iscsit_release_cmd); diff --git a/drivers/target/sbp/sbp_target.c b/drivers/target/sbp/sbp_target.c index fb1003921d85..c58f9f04c6be 100644 --- a/drivers/target/sbp/sbp_target.c +++ b/drivers/target/sbp/sbp_target.c @@ -926,15 +926,16 @@ static struct sbp_target_request *sbp_mgt_get_req(struct sbp_session *sess, { struct se_session *se_sess = sess->se_sess; struct sbp_target_request *req; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return ERR_PTR(-ENOMEM); req = &((struct sbp_target_request *)se_sess->sess_cmd_map)[tag]; memset(req, 0, sizeof(*req)); req->se_cmd.map_tag = tag; + req->se_cmd.map_cpu = cpu; req->se_cmd.tag = next_orb; return req; @@ -1460,7 +1461,8 @@ static void sbp_free_request(struct sbp_target_request *req) kfree(req->pg_tbl); kfree(req->cmd_buf); - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static void sbp_mgt_agent_process(struct work_struct *work) diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c index 4558f2e1fe1b..3103890ed109 100644 --- a/drivers/target/target_core_transport.c +++ b/drivers/target/target_core_transport.c @@ -260,7 +260,8 @@ int transport_alloc_session_tags(struct se_session *se_sess, } } - rc = percpu_ida_init(&se_sess->sess_tag_pool, tag_num); + rc = sbitmap_queue_init_node(&se_sess->sess_tag_pool, tag_num, -1, + false, GFP_KERNEL, NUMA_NO_NODE); if (rc < 0) { pr_err("Unable to init se_sess->sess_tag_pool," " tag_num: %u\n", tag_num); @@ -547,7 +548,7 @@ void transport_free_session(struct se_session *se_sess) target_put_nacl(se_nacl); } if (se_sess->sess_cmd_map) { - percpu_ida_destroy(&se_sess->sess_tag_pool); + sbitmap_queue_free(&se_sess->sess_tag_pool); kvfree(se_sess->sess_cmd_map); } kmem_cache_free(se_sess_cache, se_sess); diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c index ec372860106f..b3e3364b7147 100644 --- a/drivers/target/tcm_fc/tfc_cmd.c +++ b/drivers/target/tcm_fc/tfc_cmd.c @@ -28,7 +28,6 @@ #include #include #include -#include #include #include #include @@ -92,7 +91,8 @@ static void ft_free_cmd(struct ft_cmd *cmd) if (fr_seq(fp)) fc_seq_release(fr_seq(fp)); fc_frame_free(fp); - percpu_ida_free(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag, + cmd->se_cmd.map_cpu); ft_sess_put(sess); /* undo get from lookup at recv */ } @@ -448,9 +448,9 @@ static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp) struct ft_cmd *cmd; struct fc_lport *lport = sess->tport->lport; struct se_session *se_sess = sess->se_sess; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) goto busy; @@ -458,10 +458,11 @@ static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp) memset(cmd, 0, sizeof(struct ft_cmd)); cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->sess = sess; cmd->seq = fc_seq_assign(lport, fp); if (!cmd->seq) { - percpu_ida_free(&se_sess->sess_tag_pool, tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, tag, cpu); goto busy; } cmd->req_frame = fp; /* hold frame during cmd */ diff --git a/drivers/usb/gadget/function/f_tcm.c b/drivers/usb/gadget/function/f_tcm.c index d78dbb73bde8..b335f4f33bc3 100644 --- a/drivers/usb/gadget/function/f_tcm.c +++ b/drivers/usb/gadget/function/f_tcm.c @@ -1071,15 +1071,16 @@ static struct usbg_cmd *usbg_get_cmd(struct f_uas *fu, { struct se_session *se_sess = tv_nexus->tvn_se_sess; struct usbg_cmd *cmd; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return ERR_PTR(-ENOMEM); cmd = &((struct usbg_cmd *)se_sess->sess_cmd_map)[tag]; memset(cmd, 0, sizeof(*cmd)); cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->se_cmd.tag = cmd->tag = scsi_tag; cmd->fu = fu; @@ -1288,7 +1289,8 @@ static void usbg_release_cmd(struct se_cmd *se_cmd) struct se_session *se_sess = se_cmd->se_sess; kfree(cmd->data_buf); - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static u32 usbg_sess_get_index(struct se_session *se_sess) diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c index 7ad57094d736..1fadaa39f322 100644 --- a/drivers/vhost/scsi.c +++ b/drivers/vhost/scsi.c @@ -46,7 +46,6 @@ #include #include #include -#include #include "vhost.h" @@ -324,7 +323,8 @@ static void vhost_scsi_release_cmd(struct se_cmd *se_cmd) } vhost_scsi_put_inflight(tv_cmd->inflight); - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static u32 vhost_scsi_sess_get_index(struct se_session *se_sess) @@ -567,7 +567,7 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg, struct se_session *se_sess; struct scatterlist *sg, *prot_sg; struct page **pages; - int tag; + int tag, cpu; tv_nexus = tpg->tpg_nexus; if (!tv_nexus) { @@ -576,7 +576,7 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg, } se_sess = tv_nexus->tvn_se_sess; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) { pr_err("Unable to obtain tag for vhost_scsi_cmd\n"); return ERR_PTR(-ENOMEM); @@ -591,6 +591,7 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg, cmd->tvc_prot_sgl = prot_sg; cmd->tvc_upages = pages; cmd->tvc_se_cmd.map_tag = tag; + cmd->tvc_se_cmd.map_cpu = cpu; cmd->tvc_tag = scsi_tag; cmd->tvc_lun = lun; cmd->tvc_task_attr = task_attr; diff --git a/drivers/xen/xen-scsiback.c b/drivers/xen/xen-scsiback.c index 7bc88fd43cfc..d2c71b8608f0 100644 --- a/drivers/xen/xen-scsiback.c +++ b/drivers/xen/xen-scsiback.c @@ -654,9 +654,9 @@ static struct vscsibk_pend *scsiback_get_pend_req(struct vscsiif_back_ring *ring struct scsiback_nexus *nexus = tpg->tpg_nexus; struct se_session *se_sess = nexus->tvn_se_sess; struct vscsibk_pend *req; - int tag, i; + int tag, cpu, i; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) { pr_err("Unable to obtain tag for vscsiif_request\n"); return ERR_PTR(-ENOMEM); @@ -665,6 +665,7 @@ static struct vscsibk_pend *scsiback_get_pend_req(struct vscsiif_back_ring *ring req = &((struct vscsibk_pend *)se_sess->sess_cmd_map)[tag]; memset(req, 0, sizeof(*req)); req->se_cmd.map_tag = tag; + req->se_cmd.map_cpu = cpu; for (i = 0; i < VSCSI_MAX_GRANTS; i++) req->grant_handles[i] = SCSIBACK_INVALID_HANDLE; @@ -1379,7 +1380,8 @@ static void scsiback_release_cmd(struct se_cmd *se_cmd) { struct se_session *se_sess = se_cmd->se_sess; - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static u32 scsiback_sess_get_index(struct se_session *se_sess) diff --git a/include/target/iscsi/iscsi_target_core.h b/include/target/iscsi/iscsi_target_core.h index cf5f3fff1f1a..f2e6abea8490 100644 --- a/include/target/iscsi/iscsi_target_core.h +++ b/include/target/iscsi/iscsi_target_core.h @@ -4,6 +4,7 @@ #include /* enum dma_data_direction */ #include /* struct list_head */ +#include #include /* struct sockaddr_storage */ #include /* u8 */ #include /* itt_t */ diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h index 9f9f5902af38..cd417b17fee6 100644 --- a/include/target/target_core_base.h +++ b/include/target/target_core_base.h @@ -4,7 +4,7 @@ #include /* struct config_group */ #include /* enum dma_data_direction */ -#include /* struct percpu_ida */ +#include #include #include /* struct semaphore */ #include @@ -454,6 +454,7 @@ struct se_cmd { int sam_task_attr; /* Used for se_sess->sess_tag_pool */ unsigned int map_tag; + int map_cpu; /* Transport protocol dependent state, see transport_state_table */ enum transport_state_table t_state; /* See se_cmd_flags_table */ @@ -607,7 +608,7 @@ struct se_session { struct list_head sess_wait_list; spinlock_t sess_cmd_lock; void *sess_cmd_map; - struct percpu_ida sess_tag_pool; + struct sbitmap_queue sess_tag_pool; }; struct se_device; -- 2.17.0 ------------------------------------------------------------------------------ Check out the vibrant tech community on one of the world's most engaging tech sites, Slashdot.org! http://sdm.link/slashdot From mboxrd@z Thu Jan 1 00:00:00 1970 From: Matthew Wilcox Date: Tue, 15 May 2018 16:00:42 +0000 Subject: [PATCH 1/2] Convert target drivers to use sbitmap Message-Id: <20180515160043.27044-2-willy@infradead.org> List-Id: References: <20180515160043.27044-1-willy@infradead.org> In-Reply-To: <20180515160043.27044-1-willy@infradead.org> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: linux-kernel@vger.kernel.org, linux-scsi@vger.kernel.org, target-devel@vger.kernel.org, linux1394-devel@lists.sourceforge.net, linux-usb@vger.kernel.org, kvm@vger.kernel.org, virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, Juergen Gross , qla2xxx-upstream@qlogic.com, Kent Overstreet , Jens Axboe Cc: Matthew Wilcox From: Matthew Wilcox The sbitmap and the percpu_ida perform essentially the same task, allocating tags for commands. Since the sbitmap is more used than the percpu_ida, convert the percpu_ida users to the sbitmap API. Signed-off-by: Matthew Wilcox --- drivers/scsi/qla2xxx/qla_target.c | 16 ++++++----- drivers/target/iscsi/iscsi_target_util.c | 34 +++++++++++++++++++++--- drivers/target/sbp/sbp_target.c | 8 +++--- drivers/target/target_core_transport.c | 5 ++-- drivers/target/tcm_fc/tfc_cmd.c | 11 ++++---- drivers/usb/gadget/function/f_tcm.c | 8 +++--- drivers/vhost/scsi.c | 9 ++++--- drivers/xen/xen-scsiback.c | 8 +++--- include/target/iscsi/iscsi_target_core.h | 1 + include/target/target_core_base.h | 5 ++-- 10 files changed, 73 insertions(+), 32 deletions(-) diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c index 025dc2d3f3de..cdf671c2af61 100644 --- a/drivers/scsi/qla2xxx/qla_target.c +++ b/drivers/scsi/qla2xxx/qla_target.c @@ -3719,7 +3719,8 @@ void qlt_free_cmd(struct qla_tgt_cmd *cmd) return; } cmd->jiffies_at_free = get_jiffies_64(); - percpu_ida_free(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag, + cmd->se_cmd.map_cpu); } EXPORT_SYMBOL(qlt_free_cmd); @@ -4084,7 +4085,8 @@ static void __qlt_do_work(struct qla_tgt_cmd *cmd) qlt_send_term_exchange(qpair, NULL, &cmd->atio, 1, 0); qlt_decr_num_pend_cmds(vha); - percpu_ida_free(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag, + cmd->se_cmd.map_cpu); spin_unlock_irqrestore(qpair->qp_lock_ptr, flags); spin_lock_irqsave(&ha->tgt.sess_lock, flags); @@ -4215,9 +4217,9 @@ static struct qla_tgt_cmd *qlt_get_tag(scsi_qla_host_t *vha, { struct se_session *se_sess = sess->se_sess; struct qla_tgt_cmd *cmd; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return NULL; @@ -4230,6 +4232,7 @@ static struct qla_tgt_cmd *qlt_get_tag(scsi_qla_host_t *vha, qlt_incr_num_pend_cmds(vha); cmd->vha = vha; cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->sess = sess; cmd->loop_id = sess->loop_id; cmd->conf_compl_supported = sess->conf_compl_supported; @@ -5212,7 +5215,7 @@ qlt_alloc_qfull_cmd(struct scsi_qla_host *vha, struct fc_port *sess; struct se_session *se_sess; struct qla_tgt_cmd *cmd; - int tag; + int tag, cpu; unsigned long flags; if (unlikely(tgt->tgt_stop)) { @@ -5244,7 +5247,7 @@ qlt_alloc_qfull_cmd(struct scsi_qla_host *vha, se_sess = sess->se_sess; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return; @@ -5275,6 +5278,7 @@ qlt_alloc_qfull_cmd(struct scsi_qla_host *vha, cmd->reset_count = ha->base_qpair->chip_reset; cmd->q_full = 1; cmd->qpair = ha->base_qpair; + cmd->se_cmd.map_cpu = cpu; if (qfull) { cmd->q_full = 1; diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c index 4435bf374d2d..28bcffae609f 100644 --- a/drivers/target/iscsi/iscsi_target_util.c +++ b/drivers/target/iscsi/iscsi_target_util.c @@ -17,7 +17,7 @@ ******************************************************************************/ #include -#include +#include #include /* ipv6_addr_equal() */ #include #include @@ -147,6 +147,28 @@ void iscsit_free_r2ts_from_list(struct iscsi_cmd *cmd) spin_unlock_bh(&cmd->r2t_lock); } +int iscsit_wait_for_tag(struct se_session *se_sess, int state, int *cpup) +{ + int tag = -1; + DEFINE_WAIT(wait); + struct sbq_wait_state *ws; + + if (state = TASK_RUNNING) + return tag; + + ws = &se_sess->sess_tag_pool.ws[0]; + for (;;) { + prepare_to_wait_exclusive(&ws->wait, &wait, state); + if (signal_pending_state(state, current)) + break; + schedule(); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, cpup); + } + + finish_wait(&ws->wait, &wait); + return tag; +} + /* * May be called from software interrupt (timer) context for allocating * iSCSI NopINs. @@ -155,9 +177,11 @@ 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; + int size, tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, state); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); + if (tag < 0) + tag = iscsit_wait_for_tag(se_sess, state, &cpu); if (tag < 0) return NULL; @@ -166,6 +190,7 @@ struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *conn, int state) memset(cmd, 0, size); cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->conn = conn; cmd->data_direction = DMA_NONE; INIT_LIST_HEAD(&cmd->i_conn_node); @@ -711,7 +736,8 @@ void iscsit_release_cmd(struct iscsi_cmd *cmd) kfree(cmd->iov_data); kfree(cmd->text_in_ptr); - percpu_ida_free(&sess->se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } EXPORT_SYMBOL(iscsit_release_cmd); diff --git a/drivers/target/sbp/sbp_target.c b/drivers/target/sbp/sbp_target.c index fb1003921d85..c58f9f04c6be 100644 --- a/drivers/target/sbp/sbp_target.c +++ b/drivers/target/sbp/sbp_target.c @@ -926,15 +926,16 @@ static struct sbp_target_request *sbp_mgt_get_req(struct sbp_session *sess, { struct se_session *se_sess = sess->se_sess; struct sbp_target_request *req; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return ERR_PTR(-ENOMEM); req = &((struct sbp_target_request *)se_sess->sess_cmd_map)[tag]; memset(req, 0, sizeof(*req)); req->se_cmd.map_tag = tag; + req->se_cmd.map_cpu = cpu; req->se_cmd.tag = next_orb; return req; @@ -1460,7 +1461,8 @@ static void sbp_free_request(struct sbp_target_request *req) kfree(req->pg_tbl); kfree(req->cmd_buf); - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static void sbp_mgt_agent_process(struct work_struct *work) diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c index 4558f2e1fe1b..3103890ed109 100644 --- a/drivers/target/target_core_transport.c +++ b/drivers/target/target_core_transport.c @@ -260,7 +260,8 @@ int transport_alloc_session_tags(struct se_session *se_sess, } } - rc = percpu_ida_init(&se_sess->sess_tag_pool, tag_num); + rc = sbitmap_queue_init_node(&se_sess->sess_tag_pool, tag_num, -1, + false, GFP_KERNEL, NUMA_NO_NODE); if (rc < 0) { pr_err("Unable to init se_sess->sess_tag_pool," " tag_num: %u\n", tag_num); @@ -547,7 +548,7 @@ void transport_free_session(struct se_session *se_sess) target_put_nacl(se_nacl); } if (se_sess->sess_cmd_map) { - percpu_ida_destroy(&se_sess->sess_tag_pool); + sbitmap_queue_free(&se_sess->sess_tag_pool); kvfree(se_sess->sess_cmd_map); } kmem_cache_free(se_sess_cache, se_sess); diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c index ec372860106f..b3e3364b7147 100644 --- a/drivers/target/tcm_fc/tfc_cmd.c +++ b/drivers/target/tcm_fc/tfc_cmd.c @@ -28,7 +28,6 @@ #include #include #include -#include #include #include #include @@ -92,7 +91,8 @@ static void ft_free_cmd(struct ft_cmd *cmd) if (fr_seq(fp)) fc_seq_release(fr_seq(fp)); fc_frame_free(fp); - percpu_ida_free(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag); + sbitmap_queue_clear(&sess->se_sess->sess_tag_pool, cmd->se_cmd.map_tag, + cmd->se_cmd.map_cpu); ft_sess_put(sess); /* undo get from lookup at recv */ } @@ -448,9 +448,9 @@ static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp) struct ft_cmd *cmd; struct fc_lport *lport = sess->tport->lport; struct se_session *se_sess = sess->se_sess; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) goto busy; @@ -458,10 +458,11 @@ static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp) memset(cmd, 0, sizeof(struct ft_cmd)); cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->sess = sess; cmd->seq = fc_seq_assign(lport, fp); if (!cmd->seq) { - percpu_ida_free(&se_sess->sess_tag_pool, tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, tag, cpu); goto busy; } cmd->req_frame = fp; /* hold frame during cmd */ diff --git a/drivers/usb/gadget/function/f_tcm.c b/drivers/usb/gadget/function/f_tcm.c index d78dbb73bde8..b335f4f33bc3 100644 --- a/drivers/usb/gadget/function/f_tcm.c +++ b/drivers/usb/gadget/function/f_tcm.c @@ -1071,15 +1071,16 @@ static struct usbg_cmd *usbg_get_cmd(struct f_uas *fu, { struct se_session *se_sess = tv_nexus->tvn_se_sess; struct usbg_cmd *cmd; - int tag; + int tag, cpu; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) return ERR_PTR(-ENOMEM); cmd = &((struct usbg_cmd *)se_sess->sess_cmd_map)[tag]; memset(cmd, 0, sizeof(*cmd)); cmd->se_cmd.map_tag = tag; + cmd->se_cmd.map_cpu = cpu; cmd->se_cmd.tag = cmd->tag = scsi_tag; cmd->fu = fu; @@ -1288,7 +1289,8 @@ static void usbg_release_cmd(struct se_cmd *se_cmd) struct se_session *se_sess = se_cmd->se_sess; kfree(cmd->data_buf); - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static u32 usbg_sess_get_index(struct se_session *se_sess) diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c index 7ad57094d736..1fadaa39f322 100644 --- a/drivers/vhost/scsi.c +++ b/drivers/vhost/scsi.c @@ -46,7 +46,6 @@ #include #include #include -#include #include "vhost.h" @@ -324,7 +323,8 @@ static void vhost_scsi_release_cmd(struct se_cmd *se_cmd) } vhost_scsi_put_inflight(tv_cmd->inflight); - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static u32 vhost_scsi_sess_get_index(struct se_session *se_sess) @@ -567,7 +567,7 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg, struct se_session *se_sess; struct scatterlist *sg, *prot_sg; struct page **pages; - int tag; + int tag, cpu; tv_nexus = tpg->tpg_nexus; if (!tv_nexus) { @@ -576,7 +576,7 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg, } se_sess = tv_nexus->tvn_se_sess; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) { pr_err("Unable to obtain tag for vhost_scsi_cmd\n"); return ERR_PTR(-ENOMEM); @@ -591,6 +591,7 @@ vhost_scsi_get_tag(struct vhost_virtqueue *vq, struct vhost_scsi_tpg *tpg, cmd->tvc_prot_sgl = prot_sg; cmd->tvc_upages = pages; cmd->tvc_se_cmd.map_tag = tag; + cmd->tvc_se_cmd.map_cpu = cpu; cmd->tvc_tag = scsi_tag; cmd->tvc_lun = lun; cmd->tvc_task_attr = task_attr; diff --git a/drivers/xen/xen-scsiback.c b/drivers/xen/xen-scsiback.c index 7bc88fd43cfc..d2c71b8608f0 100644 --- a/drivers/xen/xen-scsiback.c +++ b/drivers/xen/xen-scsiback.c @@ -654,9 +654,9 @@ static struct vscsibk_pend *scsiback_get_pend_req(struct vscsiif_back_ring *ring struct scsiback_nexus *nexus = tpg->tpg_nexus; struct se_session *se_sess = nexus->tvn_se_sess; struct vscsibk_pend *req; - int tag, i; + int tag, cpu, i; - tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING); + tag = sbitmap_queue_get(&se_sess->sess_tag_pool, &cpu); if (tag < 0) { pr_err("Unable to obtain tag for vscsiif_request\n"); return ERR_PTR(-ENOMEM); @@ -665,6 +665,7 @@ static struct vscsibk_pend *scsiback_get_pend_req(struct vscsiif_back_ring *ring req = &((struct vscsibk_pend *)se_sess->sess_cmd_map)[tag]; memset(req, 0, sizeof(*req)); req->se_cmd.map_tag = tag; + req->se_cmd.map_cpu = cpu; for (i = 0; i < VSCSI_MAX_GRANTS; i++) req->grant_handles[i] = SCSIBACK_INVALID_HANDLE; @@ -1379,7 +1380,8 @@ static void scsiback_release_cmd(struct se_cmd *se_cmd) { struct se_session *se_sess = se_cmd->se_sess; - percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag); + sbitmap_queue_clear(&se_sess->sess_tag_pool, se_cmd->map_tag, + se_cmd->map_cpu); } static u32 scsiback_sess_get_index(struct se_session *se_sess) diff --git a/include/target/iscsi/iscsi_target_core.h b/include/target/iscsi/iscsi_target_core.h index cf5f3fff1f1a..f2e6abea8490 100644 --- a/include/target/iscsi/iscsi_target_core.h +++ b/include/target/iscsi/iscsi_target_core.h @@ -4,6 +4,7 @@ #include /* enum dma_data_direction */ #include /* struct list_head */ +#include #include /* struct sockaddr_storage */ #include /* u8 */ #include /* itt_t */ diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h index 9f9f5902af38..cd417b17fee6 100644 --- a/include/target/target_core_base.h +++ b/include/target/target_core_base.h @@ -4,7 +4,7 @@ #include /* struct config_group */ #include /* enum dma_data_direction */ -#include /* struct percpu_ida */ +#include #include #include /* struct semaphore */ #include @@ -454,6 +454,7 @@ struct se_cmd { int sam_task_attr; /* Used for se_sess->sess_tag_pool */ unsigned int map_tag; + int map_cpu; /* Transport protocol dependent state, see transport_state_table */ enum transport_state_table t_state; /* See se_cmd_flags_table */ @@ -607,7 +608,7 @@ struct se_session { struct list_head sess_wait_list; spinlock_t sess_cmd_lock; void *sess_cmd_map; - struct percpu_ida sess_tag_pool; + struct sbitmap_queue sess_tag_pool; }; struct se_device; -- 2.17.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [1/2] Convert target drivers to use sbitmap From: Matthew Wilcox Message-Id: <20180515160043.27044-2-willy@infradead.org> Date: Tue, 15 May 2018 09:00:42 -0700 To: linux-kernel@vger.kernel.org, linux-scsi@vger.kernel.org, target-devel@vger.kernel.org, linux1394-devel@lists.sourceforge.net, linux-usb@vger.kernel.org, kvm@vger.kernel.org, virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, Juergen Gross , qla2xxx-upstream@qlogic.com, Kent Overstreet , Jens Axboe Cc: Matthew Wilcox List-ID: RnJvbTogTWF0dGhldyBXaWxjb3ggPG1hd2lsY294QG1pY3Jvc29mdC5jb20+CgpUaGUgc2JpdG1h cCBhbmQgdGhlIHBlcmNwdV9pZGEgcGVyZm9ybSBlc3NlbnRpYWxseSB0aGUgc2FtZSB0YXNrLAph bGxvY2F0aW5nIHRhZ3MgZm9yIGNvbW1hbmRzLiAgU2luY2UgdGhlIHNiaXRtYXAgaXMgbW9yZSB1 c2VkIHRoYW4KdGhlIHBlcmNwdV9pZGEsIGNvbnZlcnQgdGhlIHBlcmNwdV9pZGEgdXNlcnMgdG8g dGhlIHNiaXRtYXAgQVBJLgoKU2lnbmVkLW9mZi1ieTogTWF0dGhldyBXaWxjb3ggPG1hd2lsY294 QG1pY3Jvc29mdC5jb20+Ci0tLQogZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX3RhcmdldC5jICAg ICAgICB8IDE2ICsrKysrKy0tLS0tCiBkcml2ZXJzL3RhcmdldC9pc2NzaS9pc2NzaV90YXJnZXRf dXRpbC5jIHwgMzQgKysrKysrKysrKysrKysrKysrKysrLS0tCiBkcml2ZXJzL3RhcmdldC9zYnAv c2JwX3RhcmdldC5jICAgICAgICAgIHwgIDggKysrLS0tCiBkcml2ZXJzL3RhcmdldC90YXJnZXRf Y29yZV90cmFuc3BvcnQuYyAgIHwgIDUgKystLQogZHJpdmVycy90YXJnZXQvdGNtX2ZjL3RmY19j bWQuYyAgICAgICAgICB8IDExICsrKystLS0tCiBkcml2ZXJzL3VzYi9nYWRnZXQvZnVuY3Rpb24v Zl90Y20uYyAgICAgIHwgIDggKysrLS0tCiBkcml2ZXJzL3Zob3N0L3Njc2kuYyAgICAgICAgICAg ICAgICAgICAgIHwgIDkgKysrKy0tLQogZHJpdmVycy94ZW4veGVuLXNjc2liYWNrLmMgICAgICAg ICAgICAgICB8ICA4ICsrKy0tLQogaW5jbHVkZS90YXJnZXQvaXNjc2kvaXNjc2lfdGFyZ2V0X2Nv cmUuaCB8ICAxICsKIGluY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaCAgICAgICAgfCAg NSArKy0tCiAxMCBmaWxlcyBjaGFuZ2VkLCA3MyBpbnNlcnRpb25zKCspLCAzMiBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvcWxhMnh4eC9xbGFfdGFyZ2V0LmMgYi9kcml2 ZXJzL3Njc2kvcWxhMnh4eC9xbGFfdGFyZ2V0LmMKaW5kZXggMDI1ZGMyZDNmM2RlLi5jZGY2NzFj MmFmNjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9xbGEyeHh4L3FsYV90YXJnZXQuYworKysg Yi9kcml2ZXJzL3Njc2kvcWxhMnh4eC9xbGFfdGFyZ2V0LmMKQEAgLTM3MTksNyArMzcxOSw4IEBA IHZvaWQgcWx0X2ZyZWVfY21kKHN0cnVjdCBxbGFfdGd0X2NtZCAqY21kKQogCQlyZXR1cm47CiAJ fQogCWNtZC0+amlmZmllc19hdF9mcmVlID0gZ2V0X2ppZmZpZXNfNjQoKTsKLQlwZXJjcHVfaWRh X2ZyZWUoJnNlc3MtPnNlX3Nlc3MtPnNlc3NfdGFnX3Bvb2wsIGNtZC0+c2VfY21kLm1hcF90YWcp OworCXNiaXRtYXBfcXVldWVfY2xlYXIoJnNlc3MtPnNlX3Nlc3MtPnNlc3NfdGFnX3Bvb2wsIGNt ZC0+c2VfY21kLm1hcF90YWcsCisJCQljbWQtPnNlX2NtZC5tYXBfY3B1KTsKIH0KIEVYUE9SVF9T WU1CT0wocWx0X2ZyZWVfY21kKTsKIApAQCAtNDA4NCw3ICs0MDg1LDggQEAgc3RhdGljIHZvaWQg X19xbHRfZG9fd29yayhzdHJ1Y3QgcWxhX3RndF9jbWQgKmNtZCkKIAlxbHRfc2VuZF90ZXJtX2V4 Y2hhbmdlKHFwYWlyLCBOVUxMLCAmY21kLT5hdGlvLCAxLCAwKTsKIAogCXFsdF9kZWNyX251bV9w ZW5kX2NtZHModmhhKTsKLQlwZXJjcHVfaWRhX2ZyZWUoJnNlc3MtPnNlX3Nlc3MtPnNlc3NfdGFn X3Bvb2wsIGNtZC0+c2VfY21kLm1hcF90YWcpOworCXNiaXRtYXBfcXVldWVfY2xlYXIoJnNlc3Mt PnNlX3Nlc3MtPnNlc3NfdGFnX3Bvb2wsIGNtZC0+c2VfY21kLm1hcF90YWcsCisJCQljbWQtPnNl X2NtZC5tYXBfY3B1KTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKHFwYWlyLT5xcF9sb2NrX3B0 ciwgZmxhZ3MpOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmhhLT50Z3Quc2Vzc19sb2NrLCBmbGFn cyk7CkBAIC00MjE1LDkgKzQyMTcsOSBAQCBzdGF0aWMgc3RydWN0IHFsYV90Z3RfY21kICpxbHRf Z2V0X3RhZyhzY3NpX3FsYV9ob3N0X3QgKnZoYSwKIHsKIAlzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2Vf c2VzcyA9IHNlc3MtPnNlX3Nlc3M7CiAJc3RydWN0IHFsYV90Z3RfY21kICpjbWQ7Ci0JaW50IHRh ZzsKKwlpbnQgdGFnLCBjcHU7CiAKLQl0YWcgPSBwZXJjcHVfaWRhX2FsbG9jKCZzZV9zZXNzLT5z ZXNzX3RhZ19wb29sLCBUQVNLX1JVTk5JTkcpOworCXRhZyA9IHNiaXRtYXBfcXVldWVfZ2V0KCZz ZV9zZXNzLT5zZXNzX3RhZ19wb29sLCAmY3B1KTsKIAlpZiAodGFnIDwgMCkKIAkJcmV0dXJuIE5V TEw7CiAKQEAgLTQyMzAsNiArNDIzMiw3IEBAIHN0YXRpYyBzdHJ1Y3QgcWxhX3RndF9jbWQgKnFs dF9nZXRfdGFnKHNjc2lfcWxhX2hvc3RfdCAqdmhhLAogCXFsdF9pbmNyX251bV9wZW5kX2NtZHMo dmhhKTsKIAljbWQtPnZoYSA9IHZoYTsKIAljbWQtPnNlX2NtZC5tYXBfdGFnID0gdGFnOworCWNt ZC0+c2VfY21kLm1hcF9jcHUgPSBjcHU7CiAJY21kLT5zZXNzID0gc2VzczsKIAljbWQtPmxvb3Bf aWQgPSBzZXNzLT5sb29wX2lkOwogCWNtZC0+Y29uZl9jb21wbF9zdXBwb3J0ZWQgPSBzZXNzLT5j b25mX2NvbXBsX3N1cHBvcnRlZDsKQEAgLTUyMTIsNyArNTIxNSw3IEBAIHFsdF9hbGxvY19xZnVs bF9jbWQoc3RydWN0IHNjc2lfcWxhX2hvc3QgKnZoYSwKIAlzdHJ1Y3QgZmNfcG9ydCAqc2VzczsK IAlzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2Vfc2VzczsKIAlzdHJ1Y3QgcWxhX3RndF9jbWQgKmNtZDsK LQlpbnQgdGFnOworCWludCB0YWcsIGNwdTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJaWYg KHVubGlrZWx5KHRndC0+dGd0X3N0b3ApKSB7CkBAIC01MjQ0LDcgKzUyNDcsNyBAQCBxbHRfYWxs b2NfcWZ1bGxfY21kKHN0cnVjdCBzY3NpX3FsYV9ob3N0ICp2aGEsCiAKIAlzZV9zZXNzID0gc2Vz cy0+c2Vfc2VzczsKIAotCXRhZyA9IHBlcmNwdV9pZGFfYWxsb2MoJnNlX3Nlc3MtPnNlc3NfdGFn X3Bvb2wsIFRBU0tfUlVOTklORyk7CisJdGFnID0gc2JpdG1hcF9xdWV1ZV9nZXQoJnNlX3Nlc3Mt PnNlc3NfdGFnX3Bvb2wsICZjcHUpOwogCWlmICh0YWcgPCAwKQogCQlyZXR1cm47CiAKQEAgLTUy NzUsNiArNTI3OCw3IEBAIHFsdF9hbGxvY19xZnVsbF9jbWQoc3RydWN0IHNjc2lfcWxhX2hvc3Qg KnZoYSwKIAljbWQtPnJlc2V0X2NvdW50ID0gaGEtPmJhc2VfcXBhaXItPmNoaXBfcmVzZXQ7CiAJ Y21kLT5xX2Z1bGwgPSAxOwogCWNtZC0+cXBhaXIgPSBoYS0+YmFzZV9xcGFpcjsKKwljbWQtPnNl X2NtZC5tYXBfY3B1ID0gY3B1OwogCiAJaWYgKHFmdWxsKSB7CiAJCWNtZC0+cV9mdWxsID0gMTsK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0L2lzY3NpL2lzY3NpX3RhcmdldF91dGlsLmMgYi9k cml2ZXJzL3RhcmdldC9pc2NzaS9pc2NzaV90YXJnZXRfdXRpbC5jCmluZGV4IDQ0MzViZjM3NGQy ZC4uMjhiY2ZmYWU2MDlmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3RhcmdldC9pc2NzaS9pc2NzaV90 YXJnZXRfdXRpbC5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0L2lzY3NpL2lzY3NpX3RhcmdldF91dGls LmMKQEAgLTE3LDcgKzE3LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKICNpbmNsdWRl IDxsaW51eC9saXN0Lmg+Ci0jaW5jbHVkZSA8bGludXgvcGVyY3B1X2lkYS5oPgorI2luY2x1ZGUg PGxpbnV4L3NjaGVkL3NpZ25hbC5oPgogI2luY2x1ZGUgPG5ldC9pcHY2Lmg+ICAgICAgICAgLyog aXB2Nl9hZGRyX2VxdWFsKCkgKi8KICNpbmNsdWRlIDxzY3NpL3Njc2lfdGNxLmg+CiAjaW5jbHVk ZSA8c2NzaS9pc2NzaV9wcm90by5oPgpAQCAtMTQ3LDYgKzE0NywyOCBAQCB2b2lkIGlzY3NpdF9m cmVlX3IydHNfZnJvbV9saXN0KHN0cnVjdCBpc2NzaV9jbWQgKmNtZCkKIAlzcGluX3VubG9ja19i aCgmY21kLT5yMnRfbG9jayk7CiB9CiAKK2ludCBpc2NzaXRfd2FpdF9mb3JfdGFnKHN0cnVjdCBz ZV9zZXNzaW9uICpzZV9zZXNzLCBpbnQgc3RhdGUsIGludCAqY3B1cCkKK3sKKwlpbnQgdGFnID0g LTE7CisJREVGSU5FX1dBSVQod2FpdCk7CisJc3RydWN0IHNicV93YWl0X3N0YXRlICp3czsKKwor CWlmIChzdGF0ZSA9PSBUQVNLX1JVTk5JTkcpCisJCXJldHVybiB0YWc7CisKKwl3cyA9ICZzZV9z ZXNzLT5zZXNzX3RhZ19wb29sLndzWzBdOworCWZvciAoOzspIHsKKwkJcHJlcGFyZV90b193YWl0 X2V4Y2x1c2l2ZSgmd3MtPndhaXQsICZ3YWl0LCBzdGF0ZSk7CisJCWlmIChzaWduYWxfcGVuZGlu Z19zdGF0ZShzdGF0ZSwgY3VycmVudCkpCisJCQlicmVhazsKKwkJc2NoZWR1bGUoKTsKKwkJdGFn ID0gc2JpdG1hcF9xdWV1ZV9nZXQoJnNlX3Nlc3MtPnNlc3NfdGFnX3Bvb2wsIGNwdXApOworCX0K KworCWZpbmlzaF93YWl0KCZ3cy0+d2FpdCwgJndhaXQpOworCXJldHVybiB0YWc7Cit9CisKIC8q CiAgKiBNYXkgYmUgY2FsbGVkIGZyb20gc29mdHdhcmUgaW50ZXJydXB0ICh0aW1lcikgY29udGV4 dCBmb3IgYWxsb2NhdGluZwogICogaVNDU0kgTm9wSU5zLgpAQCAtMTU1LDkgKzE3NywxMSBAQCBz dHJ1Y3QgaXNjc2lfY21kICppc2NzaXRfYWxsb2NhdGVfY21kKHN0cnVjdCBpc2NzaV9jb25uICpj b25uLCBpbnQgc3RhdGUpCiB7CiAJc3RydWN0IGlzY3NpX2NtZCAqY21kOwogCXN0cnVjdCBzZV9z ZXNzaW9uICpzZV9zZXNzID0gY29ubi0+c2Vzcy0+c2Vfc2VzczsKLQlpbnQgc2l6ZSwgdGFnOwor CWludCBzaXplLCB0YWcsIGNwdTsKIAotCXRhZyA9IHBlcmNwdV9pZGFfYWxsb2MoJnNlX3Nlc3Mt PnNlc3NfdGFnX3Bvb2wsIHN0YXRlKTsKKwl0YWcgPSBzYml0bWFwX3F1ZXVlX2dldCgmc2Vfc2Vz cy0+c2Vzc190YWdfcG9vbCwgJmNwdSk7CisJaWYgKHRhZyA8IDApCisJCXRhZyA9IGlzY3NpdF93 YWl0X2Zvcl90YWcoc2Vfc2Vzcywgc3RhdGUsICZjcHUpOwogCWlmICh0YWcgPCAwKQogCQlyZXR1 cm4gTlVMTDsKIApAQCAtMTY2LDYgKzE5MCw3IEBAIHN0cnVjdCBpc2NzaV9jbWQgKmlzY3NpdF9h bGxvY2F0ZV9jbWQoc3RydWN0IGlzY3NpX2Nvbm4gKmNvbm4sIGludCBzdGF0ZSkKIAltZW1zZXQo Y21kLCAwLCBzaXplKTsKIAogCWNtZC0+c2VfY21kLm1hcF90YWcgPSB0YWc7CisJY21kLT5zZV9j bWQubWFwX2NwdSA9IGNwdTsKIAljbWQtPmNvbm4gPSBjb25uOwogCWNtZC0+ZGF0YV9kaXJlY3Rp b24gPSBETUFfTk9ORTsKIAlJTklUX0xJU1RfSEVBRCgmY21kLT5pX2Nvbm5fbm9kZSk7CkBAIC03 MTEsNyArNzM2LDggQEAgdm9pZCBpc2NzaXRfcmVsZWFzZV9jbWQoc3RydWN0IGlzY3NpX2NtZCAq Y21kKQogCWtmcmVlKGNtZC0+aW92X2RhdGEpOwogCWtmcmVlKGNtZC0+dGV4dF9pbl9wdHIpOwog Ci0JcGVyY3B1X2lkYV9mcmVlKCZzZXNzLT5zZV9zZXNzLT5zZXNzX3RhZ19wb29sLCBzZV9jbWQt Pm1hcF90YWcpOworCXNiaXRtYXBfcXVldWVfY2xlYXIoJnNlc3MtPnNlX3Nlc3MtPnNlc3NfdGFn X3Bvb2wsIHNlX2NtZC0+bWFwX3RhZywKKwkJCXNlX2NtZC0+bWFwX2NwdSk7CiB9CiBFWFBPUlRf U1lNQk9MKGlzY3NpdF9yZWxlYXNlX2NtZCk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdGFyZ2V0 L3NicC9zYnBfdGFyZ2V0LmMgYi9kcml2ZXJzL3RhcmdldC9zYnAvc2JwX3RhcmdldC5jCmluZGV4 IGZiMTAwMzkyMWQ4NS4uYzU4ZjlmMDRjNmJlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3RhcmdldC9z YnAvc2JwX3RhcmdldC5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0L3NicC9zYnBfdGFyZ2V0LmMKQEAg LTkyNiwxNSArOTI2LDE2IEBAIHN0YXRpYyBzdHJ1Y3Qgc2JwX3RhcmdldF9yZXF1ZXN0ICpzYnBf bWd0X2dldF9yZXEoc3RydWN0IHNicF9zZXNzaW9uICpzZXNzLAogewogCXN0cnVjdCBzZV9zZXNz aW9uICpzZV9zZXNzID0gc2Vzcy0+c2Vfc2VzczsKIAlzdHJ1Y3Qgc2JwX3RhcmdldF9yZXF1ZXN0 ICpyZXE7Ci0JaW50IHRhZzsKKwlpbnQgdGFnLCBjcHU7CiAKLQl0YWcgPSBwZXJjcHVfaWRhX2Fs bG9jKCZzZV9zZXNzLT5zZXNzX3RhZ19wb29sLCBUQVNLX1JVTk5JTkcpOworCXRhZyA9IHNiaXRt YXBfcXVldWVfZ2V0KCZzZV9zZXNzLT5zZXNzX3RhZ19wb29sLCAmY3B1KTsKIAlpZiAodGFnIDwg MCkKIAkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CiAKIAlyZXEgPSAmKChzdHJ1Y3Qgc2JwX3Rh cmdldF9yZXF1ZXN0ICopc2Vfc2Vzcy0+c2Vzc19jbWRfbWFwKVt0YWddOwogCW1lbXNldChyZXEs IDAsIHNpemVvZigqcmVxKSk7CiAJcmVxLT5zZV9jbWQubWFwX3RhZyA9IHRhZzsKKwlyZXEtPnNl X2NtZC5tYXBfY3B1ID0gY3B1OwogCXJlcS0+c2VfY21kLnRhZyA9IG5leHRfb3JiOwogCiAJcmV0 dXJuIHJlcTsKQEAgLTE0NjAsNyArMTQ2MSw4IEBAIHN0YXRpYyB2b2lkIHNicF9mcmVlX3JlcXVl c3Qoc3RydWN0IHNicF90YXJnZXRfcmVxdWVzdCAqcmVxKQogCWtmcmVlKHJlcS0+cGdfdGJsKTsK IAlrZnJlZShyZXEtPmNtZF9idWYpOwogCi0JcGVyY3B1X2lkYV9mcmVlKCZzZV9zZXNzLT5zZXNz X3RhZ19wb29sLCBzZV9jbWQtPm1hcF90YWcpOworCXNiaXRtYXBfcXVldWVfY2xlYXIoJnNlX3Nl c3MtPnNlc3NfdGFnX3Bvb2wsIHNlX2NtZC0+bWFwX3RhZywKKwkJCXNlX2NtZC0+bWFwX2NwdSk7 CiB9CiAKIHN0YXRpYyB2b2lkIHNicF9tZ3RfYWdlbnRfcHJvY2VzcyhzdHJ1Y3Qgd29ya19zdHJ1 Y3QgKndvcmspCmRpZmYgLS1naXQgYS9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV90cmFuc3Bv cnQuYyBiL2RyaXZlcnMvdGFyZ2V0L3RhcmdldF9jb3JlX3RyYW5zcG9ydC5jCmluZGV4IDQ1NThm MmUxZmUxYi4uMzEwMzg5MGVkMTA5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3RhcmdldC90YXJnZXRf Y29yZV90cmFuc3BvcnQuYworKysgYi9kcml2ZXJzL3RhcmdldC90YXJnZXRfY29yZV90cmFuc3Bv cnQuYwpAQCAtMjYwLDcgKzI2MCw4IEBAIGludCB0cmFuc3BvcnRfYWxsb2Nfc2Vzc2lvbl90YWdz KHN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzLAogCQl9CiAJfQogCi0JcmMgPSBwZXJjcHVfaWRh X2luaXQoJnNlX3Nlc3MtPnNlc3NfdGFnX3Bvb2wsIHRhZ19udW0pOworCXJjID0gc2JpdG1hcF9x dWV1ZV9pbml0X25vZGUoJnNlX3Nlc3MtPnNlc3NfdGFnX3Bvb2wsIHRhZ19udW0sIC0xLAorCQkJ ZmFsc2UsIEdGUF9LRVJORUwsIE5VTUFfTk9fTk9ERSk7CiAJaWYgKHJjIDwgMCkgewogCQlwcl9l cnIoIlVuYWJsZSB0byBpbml0IHNlX3Nlc3MtPnNlc3NfdGFnX3Bvb2wsIgogCQkJIiB0YWdfbnVt OiAldVxuIiwgdGFnX251bSk7CkBAIC01NDcsNyArNTQ4LDcgQEAgdm9pZCB0cmFuc3BvcnRfZnJl ZV9zZXNzaW9uKHN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzKQogCQl0YXJnZXRfcHV0X25hY2wo c2VfbmFjbCk7CiAJfQogCWlmIChzZV9zZXNzLT5zZXNzX2NtZF9tYXApIHsKLQkJcGVyY3B1X2lk YV9kZXN0cm95KCZzZV9zZXNzLT5zZXNzX3RhZ19wb29sKTsKKwkJc2JpdG1hcF9xdWV1ZV9mcmVl KCZzZV9zZXNzLT5zZXNzX3RhZ19wb29sKTsKIAkJa3ZmcmVlKHNlX3Nlc3MtPnNlc3NfY21kX21h cCk7CiAJfQogCWttZW1fY2FjaGVfZnJlZShzZV9zZXNzX2NhY2hlLCBzZV9zZXNzKTsKZGlmZiAt LWdpdCBhL2RyaXZlcnMvdGFyZ2V0L3RjbV9mYy90ZmNfY21kLmMgYi9kcml2ZXJzL3RhcmdldC90 Y21fZmMvdGZjX2NtZC5jCmluZGV4IGVjMzcyODYwMTA2Zi4uYjNlMzM2NGI3MTQ3IDEwMDY0NAot LS0gYS9kcml2ZXJzL3RhcmdldC90Y21fZmMvdGZjX2NtZC5jCisrKyBiL2RyaXZlcnMvdGFyZ2V0 L3RjbV9mYy90ZmNfY21kLmMKQEAgLTI4LDcgKzI4LDYgQEAKICNpbmNsdWRlIDxsaW51eC9jb25m aWdmcy5oPgogI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+CiAjaW5jbHVkZSA8bGludXgvaGFzaC5o PgotI2luY2x1ZGUgPGxpbnV4L3BlcmNwdV9pZGEuaD4KICNpbmNsdWRlIDxhc20vdW5hbGlnbmVk Lmg+CiAjaW5jbHVkZSA8c2NzaS9zY3NpX3RjcS5oPgogI2luY2x1ZGUgPHNjc2kvbGliZmMuaD4K QEAgLTkyLDcgKzkxLDggQEAgc3RhdGljIHZvaWQgZnRfZnJlZV9jbWQoc3RydWN0IGZ0X2NtZCAq Y21kKQogCWlmIChmcl9zZXEoZnApKQogCQlmY19zZXFfcmVsZWFzZShmcl9zZXEoZnApKTsKIAlm Y19mcmFtZV9mcmVlKGZwKTsKLQlwZXJjcHVfaWRhX2ZyZWUoJnNlc3MtPnNlX3Nlc3MtPnNlc3Nf dGFnX3Bvb2wsIGNtZC0+c2VfY21kLm1hcF90YWcpOworCXNiaXRtYXBfcXVldWVfY2xlYXIoJnNl c3MtPnNlX3Nlc3MtPnNlc3NfdGFnX3Bvb2wsIGNtZC0+c2VfY21kLm1hcF90YWcsCisJCQljbWQt PnNlX2NtZC5tYXBfY3B1KTsKIAlmdF9zZXNzX3B1dChzZXNzKTsJLyogdW5kbyBnZXQgZnJvbSBs b29rdXAgYXQgcmVjdiAqLwogfQogCkBAIC00NDgsOSArNDQ4LDkgQEAgc3RhdGljIHZvaWQgZnRf cmVjdl9jbWQoc3RydWN0IGZ0X3Nlc3MgKnNlc3MsIHN0cnVjdCBmY19mcmFtZSAqZnApCiAJc3Ry dWN0IGZ0X2NtZCAqY21kOwogCXN0cnVjdCBmY19scG9ydCAqbHBvcnQgPSBzZXNzLT50cG9ydC0+ bHBvcnQ7CiAJc3RydWN0IHNlX3Nlc3Npb24gKnNlX3Nlc3MgPSBzZXNzLT5zZV9zZXNzOwotCWlu dCB0YWc7CisJaW50IHRhZywgY3B1OwogCi0JdGFnID0gcGVyY3B1X2lkYV9hbGxvYygmc2Vfc2Vz cy0+c2Vzc190YWdfcG9vbCwgVEFTS19SVU5OSU5HKTsKKwl0YWcgPSBzYml0bWFwX3F1ZXVlX2dl dCgmc2Vfc2Vzcy0+c2Vzc190YWdfcG9vbCwgJmNwdSk7CiAJaWYgKHRhZyA8IDApCiAJCWdvdG8g YnVzeTsKIApAQCAtNDU4LDEwICs0NTgsMTEgQEAgc3RhdGljIHZvaWQgZnRfcmVjdl9jbWQoc3Ry dWN0IGZ0X3Nlc3MgKnNlc3MsIHN0cnVjdCBmY19mcmFtZSAqZnApCiAJbWVtc2V0KGNtZCwgMCwg c2l6ZW9mKHN0cnVjdCBmdF9jbWQpKTsKIAogCWNtZC0+c2VfY21kLm1hcF90YWcgPSB0YWc7CisJ Y21kLT5zZV9jbWQubWFwX2NwdSA9IGNwdTsKIAljbWQtPnNlc3MgPSBzZXNzOwogCWNtZC0+c2Vx ID0gZmNfc2VxX2Fzc2lnbihscG9ydCwgZnApOwogCWlmICghY21kLT5zZXEpIHsKLQkJcGVyY3B1 X2lkYV9mcmVlKCZzZV9zZXNzLT5zZXNzX3RhZ19wb29sLCB0YWcpOworCQlzYml0bWFwX3F1ZXVl X2NsZWFyKCZzZV9zZXNzLT5zZXNzX3RhZ19wb29sLCB0YWcsIGNwdSk7CiAJCWdvdG8gYnVzeTsK IAl9CiAJY21kLT5yZXFfZnJhbWUgPSBmcDsJCS8qIGhvbGQgZnJhbWUgZHVyaW5nIGNtZCAqLwpk aWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvZ2FkZ2V0L2Z1bmN0aW9uL2ZfdGNtLmMgYi9kcml2ZXJz L3VzYi9nYWRnZXQvZnVuY3Rpb24vZl90Y20uYwppbmRleCBkNzhkYmI3M2JkZTguLmIzMzVmNGYz M2JjMyAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvZ2FkZ2V0L2Z1bmN0aW9uL2ZfdGNtLmMKKysr IGIvZHJpdmVycy91c2IvZ2FkZ2V0L2Z1bmN0aW9uL2ZfdGNtLmMKQEAgLTEwNzEsMTUgKzEwNzEs MTYgQEAgc3RhdGljIHN0cnVjdCB1c2JnX2NtZCAqdXNiZ19nZXRfY21kKHN0cnVjdCBmX3VhcyAq ZnUsCiB7CiAJc3RydWN0IHNlX3Nlc3Npb24gKnNlX3Nlc3MgPSB0dl9uZXh1cy0+dHZuX3NlX3Nl c3M7CiAJc3RydWN0IHVzYmdfY21kICpjbWQ7Ci0JaW50IHRhZzsKKwlpbnQgdGFnLCBjcHU7CiAK LQl0YWcgPSBwZXJjcHVfaWRhX2FsbG9jKCZzZV9zZXNzLT5zZXNzX3RhZ19wb29sLCBUQVNLX1JV Tk5JTkcpOworCXRhZyA9IHNiaXRtYXBfcXVldWVfZ2V0KCZzZV9zZXNzLT5zZXNzX3RhZ19wb29s LCAmY3B1KTsKIAlpZiAodGFnIDwgMCkKIAkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CiAKIAlj bWQgPSAmKChzdHJ1Y3QgdXNiZ19jbWQgKilzZV9zZXNzLT5zZXNzX2NtZF9tYXApW3RhZ107CiAJ bWVtc2V0KGNtZCwgMCwgc2l6ZW9mKCpjbWQpKTsKIAljbWQtPnNlX2NtZC5tYXBfdGFnID0gdGFn OworCWNtZC0+c2VfY21kLm1hcF9jcHUgPSBjcHU7CiAJY21kLT5zZV9jbWQudGFnID0gY21kLT50 YWcgPSBzY3NpX3RhZzsKIAljbWQtPmZ1ID0gZnU7CiAKQEAgLTEyODgsNyArMTI4OSw4IEBAIHN0 YXRpYyB2b2lkIHVzYmdfcmVsZWFzZV9jbWQoc3RydWN0IHNlX2NtZCAqc2VfY21kKQogCXN0cnVj dCBzZV9zZXNzaW9uICpzZV9zZXNzID0gc2VfY21kLT5zZV9zZXNzOwogCiAJa2ZyZWUoY21kLT5k YXRhX2J1Zik7Ci0JcGVyY3B1X2lkYV9mcmVlKCZzZV9zZXNzLT5zZXNzX3RhZ19wb29sLCBzZV9j bWQtPm1hcF90YWcpOworCXNiaXRtYXBfcXVldWVfY2xlYXIoJnNlX3Nlc3MtPnNlc3NfdGFnX3Bv b2wsIHNlX2NtZC0+bWFwX3RhZywKKwkJCXNlX2NtZC0+bWFwX2NwdSk7CiB9CiAKIHN0YXRpYyB1 MzIgdXNiZ19zZXNzX2dldF9pbmRleChzdHJ1Y3Qgc2Vfc2Vzc2lvbiAqc2Vfc2VzcykKZGlmZiAt LWdpdCBhL2RyaXZlcnMvdmhvc3Qvc2NzaS5jIGIvZHJpdmVycy92aG9zdC9zY3NpLmMKaW5kZXgg N2FkNTcwOTRkNzM2Li4xZmFkYWEzOWYzMjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmhvc3Qvc2Nz aS5jCisrKyBiL2RyaXZlcnMvdmhvc3Qvc2NzaS5jCkBAIC00Niw3ICs0Niw2IEBACiAjaW5jbHVk ZSA8bGludXgvdmlydGlvX3Njc2kuaD4KICNpbmNsdWRlIDxsaW51eC9sbGlzdC5oPgogI2luY2x1 ZGUgPGxpbnV4L2JpdG1hcC5oPgotI2luY2x1ZGUgPGxpbnV4L3BlcmNwdV9pZGEuaD4KIAogI2lu Y2x1ZGUgInZob3N0LmgiCiAKQEAgLTMyNCw3ICszMjMsOCBAQCBzdGF0aWMgdm9pZCB2aG9zdF9z Y3NpX3JlbGVhc2VfY21kKHN0cnVjdCBzZV9jbWQgKnNlX2NtZCkKIAl9CiAKIAl2aG9zdF9zY3Np X3B1dF9pbmZsaWdodCh0dl9jbWQtPmluZmxpZ2h0KTsKLQlwZXJjcHVfaWRhX2ZyZWUoJnNlX3Nl c3MtPnNlc3NfdGFnX3Bvb2wsIHNlX2NtZC0+bWFwX3RhZyk7CisJc2JpdG1hcF9xdWV1ZV9jbGVh cigmc2Vfc2Vzcy0+c2Vzc190YWdfcG9vbCwgc2VfY21kLT5tYXBfdGFnLAorCQkJc2VfY21kLT5t YXBfY3B1KTsKIH0KIAogc3RhdGljIHUzMiB2aG9zdF9zY3NpX3Nlc3NfZ2V0X2luZGV4KHN0cnVj dCBzZV9zZXNzaW9uICpzZV9zZXNzKQpAQCAtNTY3LDcgKzU2Nyw3IEBAIHZob3N0X3Njc2lfZ2V0 X3RhZyhzdHJ1Y3Qgdmhvc3RfdmlydHF1ZXVlICp2cSwgc3RydWN0IHZob3N0X3Njc2lfdHBnICp0 cGcsCiAJc3RydWN0IHNlX3Nlc3Npb24gKnNlX3Nlc3M7CiAJc3RydWN0IHNjYXR0ZXJsaXN0ICpz ZywgKnByb3Rfc2c7CiAJc3RydWN0IHBhZ2UgKipwYWdlczsKLQlpbnQgdGFnOworCWludCB0YWcs IGNwdTsKIAogCXR2X25leHVzID0gdHBnLT50cGdfbmV4dXM7CiAJaWYgKCF0dl9uZXh1cykgewpA QCAtNTc2LDcgKzU3Niw3IEBAIHZob3N0X3Njc2lfZ2V0X3RhZyhzdHJ1Y3Qgdmhvc3RfdmlydHF1 ZXVlICp2cSwgc3RydWN0IHZob3N0X3Njc2lfdHBnICp0cGcsCiAJfQogCXNlX3Nlc3MgPSB0dl9u ZXh1cy0+dHZuX3NlX3Nlc3M7CiAKLQl0YWcgPSBwZXJjcHVfaWRhX2FsbG9jKCZzZV9zZXNzLT5z ZXNzX3RhZ19wb29sLCBUQVNLX1JVTk5JTkcpOworCXRhZyA9IHNiaXRtYXBfcXVldWVfZ2V0KCZz ZV9zZXNzLT5zZXNzX3RhZ19wb29sLCAmY3B1KTsKIAlpZiAodGFnIDwgMCkgewogCQlwcl9lcnIo IlVuYWJsZSB0byBvYnRhaW4gdGFnIGZvciB2aG9zdF9zY3NpX2NtZFxuIik7CiAJCXJldHVybiBF UlJfUFRSKC1FTk9NRU0pOwpAQCAtNTkxLDYgKzU5MSw3IEBAIHZob3N0X3Njc2lfZ2V0X3RhZyhz dHJ1Y3Qgdmhvc3RfdmlydHF1ZXVlICp2cSwgc3RydWN0IHZob3N0X3Njc2lfdHBnICp0cGcsCiAJ Y21kLT50dmNfcHJvdF9zZ2wgPSBwcm90X3NnOwogCWNtZC0+dHZjX3VwYWdlcyA9IHBhZ2VzOwog CWNtZC0+dHZjX3NlX2NtZC5tYXBfdGFnID0gdGFnOworCWNtZC0+dHZjX3NlX2NtZC5tYXBfY3B1 ID0gY3B1OwogCWNtZC0+dHZjX3RhZyA9IHNjc2lfdGFnOwogCWNtZC0+dHZjX2x1biA9IGx1bjsK IAljbWQtPnR2Y190YXNrX2F0dHIgPSB0YXNrX2F0dHI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hl bi94ZW4tc2NzaWJhY2suYyBiL2RyaXZlcnMveGVuL3hlbi1zY3NpYmFjay5jCmluZGV4IDdiYzg4 ZmQ0M2NmYy4uZDJjNzFiODYwOGYwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi94ZW4tc2NzaWJh Y2suYworKysgYi9kcml2ZXJzL3hlbi94ZW4tc2NzaWJhY2suYwpAQCAtNjU0LDkgKzY1NCw5IEBA IHN0YXRpYyBzdHJ1Y3QgdnNjc2lia19wZW5kICpzY3NpYmFja19nZXRfcGVuZF9yZXEoc3RydWN0 IHZzY3NpaWZfYmFja19yaW5nICpyaW5nCiAJc3RydWN0IHNjc2liYWNrX25leHVzICpuZXh1cyA9 IHRwZy0+dHBnX25leHVzOwogCXN0cnVjdCBzZV9zZXNzaW9uICpzZV9zZXNzID0gbmV4dXMtPnR2 bl9zZV9zZXNzOwogCXN0cnVjdCB2c2NzaWJrX3BlbmQgKnJlcTsKLQlpbnQgdGFnLCBpOworCWlu dCB0YWcsIGNwdSwgaTsKIAotCXRhZyA9IHBlcmNwdV9pZGFfYWxsb2MoJnNlX3Nlc3MtPnNlc3Nf dGFnX3Bvb2wsIFRBU0tfUlVOTklORyk7CisJdGFnID0gc2JpdG1hcF9xdWV1ZV9nZXQoJnNlX3Nl c3MtPnNlc3NfdGFnX3Bvb2wsICZjcHUpOwogCWlmICh0YWcgPCAwKSB7CiAJCXByX2VycigiVW5h YmxlIHRvIG9idGFpbiB0YWcgZm9yIHZzY3NpaWZfcmVxdWVzdFxuIik7CiAJCXJldHVybiBFUlJf UFRSKC1FTk9NRU0pOwpAQCAtNjY1LDYgKzY2NSw3IEBAIHN0YXRpYyBzdHJ1Y3QgdnNjc2lia19w ZW5kICpzY3NpYmFja19nZXRfcGVuZF9yZXEoc3RydWN0IHZzY3NpaWZfYmFja19yaW5nICpyaW5n CiAJcmVxID0gJigoc3RydWN0IHZzY3NpYmtfcGVuZCAqKXNlX3Nlc3MtPnNlc3NfY21kX21hcClb dGFnXTsKIAltZW1zZXQocmVxLCAwLCBzaXplb2YoKnJlcSkpOwogCXJlcS0+c2VfY21kLm1hcF90 YWcgPSB0YWc7CisJcmVxLT5zZV9jbWQubWFwX2NwdSA9IGNwdTsKIAogCWZvciAoaSA9IDA7IGkg PCBWU0NTSV9NQVhfR1JBTlRTOyBpKyspCiAJCXJlcS0+Z3JhbnRfaGFuZGxlc1tpXSA9IFNDU0lC QUNLX0lOVkFMSURfSEFORExFOwpAQCAtMTM3OSw3ICsxMzgwLDggQEAgc3RhdGljIHZvaWQgc2Nz aWJhY2tfcmVsZWFzZV9jbWQoc3RydWN0IHNlX2NtZCAqc2VfY21kKQogewogCXN0cnVjdCBzZV9z ZXNzaW9uICpzZV9zZXNzID0gc2VfY21kLT5zZV9zZXNzOwogCi0JcGVyY3B1X2lkYV9mcmVlKCZz ZV9zZXNzLT5zZXNzX3RhZ19wb29sLCBzZV9jbWQtPm1hcF90YWcpOworCXNiaXRtYXBfcXVldWVf Y2xlYXIoJnNlX3Nlc3MtPnNlc3NfdGFnX3Bvb2wsIHNlX2NtZC0+bWFwX3RhZywKKwkJCXNlX2Nt ZC0+bWFwX2NwdSk7CiB9CiAKIHN0YXRpYyB1MzIgc2NzaWJhY2tfc2Vzc19nZXRfaW5kZXgoc3Ry dWN0IHNlX3Nlc3Npb24gKnNlX3Nlc3MpCmRpZmYgLS1naXQgYS9pbmNsdWRlL3RhcmdldC9pc2Nz aS9pc2NzaV90YXJnZXRfY29yZS5oIGIvaW5jbHVkZS90YXJnZXQvaXNjc2kvaXNjc2lfdGFyZ2V0 X2NvcmUuaAppbmRleCBjZjVmM2ZmZjFmMWEuLmYyZTZhYmVhODQ5MCAxMDA2NDQKLS0tIGEvaW5j bHVkZS90YXJnZXQvaXNjc2kvaXNjc2lfdGFyZ2V0X2NvcmUuaAorKysgYi9pbmNsdWRlL3Rhcmdl dC9pc2NzaS9pc2NzaV90YXJnZXRfY29yZS5oCkBAIC00LDYgKzQsNyBAQAogCiAjaW5jbHVkZSA8 bGludXgvZG1hLWRpcmVjdGlvbi5oPiAgICAgLyogZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gKi8K ICNpbmNsdWRlIDxsaW51eC9saXN0Lmg+ICAgICAgICAgICAgICAvKiBzdHJ1Y3QgbGlzdF9oZWFk ICovCisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zb2NrZXQuaD4g ICAgICAgICAgICAvKiBzdHJ1Y3Qgc29ja2FkZHJfc3RvcmFnZSAqLwogI2luY2x1ZGUgPGxpbnV4 L3R5cGVzLmg+ICAgICAgICAgICAgIC8qIHU4ICovCiAjaW5jbHVkZSA8c2NzaS9pc2NzaV9wcm90 by5oPiAgICAgICAgLyogaXR0X3QgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvdGFyZ2V0L3Rhcmdl dF9jb3JlX2Jhc2UuaCBiL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaAppbmRleCA5 ZjlmNTkwMmFmMzguLmNkNDE3YjE3ZmVlNiAxMDA2NDQKLS0tIGEvaW5jbHVkZS90YXJnZXQvdGFy Z2V0X2NvcmVfYmFzZS5oCisrKyBiL2luY2x1ZGUvdGFyZ2V0L3RhcmdldF9jb3JlX2Jhc2UuaApA QCAtNCw3ICs0LDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2NvbmZpZ2ZzLmg+ICAgICAgLyogc3Ry dWN0IGNvbmZpZ19ncm91cCAqLwogI2luY2x1ZGUgPGxpbnV4L2RtYS1kaXJlY3Rpb24uaD4gLyog ZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gKi8KLSNpbmNsdWRlIDxsaW51eC9wZXJjcHVfaWRhLmg+ ICAgIC8qIHN0cnVjdCBwZXJjcHVfaWRhICovCisjaW5jbHVkZSA8bGludXgvc2JpdG1hcC5oPgog I2luY2x1ZGUgPGxpbnV4L3BlcmNwdS1yZWZjb3VudC5oPgogI2luY2x1ZGUgPGxpbnV4L3NlbWFw aG9yZS5oPiAgICAgLyogc3RydWN0IHNlbWFwaG9yZSAqLwogI2luY2x1ZGUgPGxpbnV4L2NvbXBs ZXRpb24uaD4KQEAgLTQ1NCw2ICs0NTQsNyBAQCBzdHJ1Y3Qgc2VfY21kIHsKIAlpbnQJCQlzYW1f dGFza19hdHRyOwogCS8qIFVzZWQgZm9yIHNlX3Nlc3MtPnNlc3NfdGFnX3Bvb2wgKi8KIAl1bnNp Z25lZCBpbnQJCW1hcF90YWc7CisJaW50CQkJbWFwX2NwdTsKIAkvKiBUcmFuc3BvcnQgcHJvdG9j b2wgZGVwZW5kZW50IHN0YXRlLCBzZWUgdHJhbnNwb3J0X3N0YXRlX3RhYmxlICovCiAJZW51bSB0 cmFuc3BvcnRfc3RhdGVfdGFibGUgdF9zdGF0ZTsKIAkvKiBTZWUgc2VfY21kX2ZsYWdzX3RhYmxl ICovCkBAIC02MDcsNyArNjA4LDcgQEAgc3RydWN0IHNlX3Nlc3Npb24gewogCXN0cnVjdCBsaXN0 X2hlYWQJc2Vzc193YWl0X2xpc3Q7CiAJc3BpbmxvY2tfdAkJc2Vzc19jbWRfbG9jazsKIAl2b2lk CQkJKnNlc3NfY21kX21hcDsKLQlzdHJ1Y3QgcGVyY3B1X2lkYQlzZXNzX3RhZ19wb29sOworCXN0 cnVjdCBzYml0bWFwX3F1ZXVlCXNlc3NfdGFnX3Bvb2w7CiB9OwogCiBzdHJ1Y3Qgc2VfZGV2aWNl Owo=