From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-10.1 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id ACEFEC433DF for ; Mon, 29 Jun 2020 19:06:55 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 8F20220723 for ; Mon, 29 Jun 2020 19:06:55 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1593457615; bh=3xClpJBPNLC08/oirvKhxgs8ayLaUb+vP83nGBXxTsw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:List-ID:From; b=u/wHxXAZXcrsddx1s6N02lqqqkgfKPXwOClr9Kzqt14tkjb42pGUQm9smkqneNR/6 dBQxQSS95UttfbsILgOgfN0lntFE5a9JBjp+w0P6+wlCzFV3xL6EHgdDMy2uJS/hk/ aeY4o4CMaTwYzg9P562zAyxQdSuL7iJzouVuQQ3s= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728941AbgF2TGy (ORCPT ); Mon, 29 Jun 2020 15:06:54 -0400 Received: from mail.kernel.org ([198.145.29.99]:49508 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730559AbgF2TGu (ORCPT ); Mon, 29 Jun 2020 15:06:50 -0400 Received: from dhcp-10-100-145-180.wdl.wdc.com (unknown [199.255.45.60]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id 2F33920702; Mon, 29 Jun 2020 19:06:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1593457609; bh=3xClpJBPNLC08/oirvKhxgs8ayLaUb+vP83nGBXxTsw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=NXClzJcvoFZZy/07zx7KPVoBEtwKXQ5ZkYg9GrGfAVXPgKlZ4jjbgAs/IGBDfg2V+ exHUx8XjOxijIWjg/d1gdYO5sU90u9KP5m6+t5joVReDzgXPeYVu31UPhPBCUlNdTu tNjy/uF/ss3DU9mtrxTxUZ46Nhj3/LNLadYCP8dw= From: Keith Busch To: linux-nvme@lists.infradead.org, hch@lst.de, sagi@grimberg.me, linux-block@vger.kernel.org Cc: axboe@kernel.dk, Keith Busch , =?UTF-8?q?Javier=20Gonz=C3=A1lez?= , "Martin K . Petersen" , Johannes Thumshirn , =?UTF-8?q?Matias=20Bj=C3=B8rling?= , Hannes Reinecke , Daniel Wagner Subject: [PATCHv4 4/5] nvme: support for multi-command set effects Date: Mon, 29 Jun 2020 12:06:40 -0700 Message-Id: <20200629190641.1986462-5-kbusch@kernel.org> X-Mailer: git-send-email 2.24.1 In-Reply-To: <20200629190641.1986462-1-kbusch@kernel.org> References: <20200629190641.1986462-1-kbusch@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-block-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Keith Busch The Commands Supported and Effects log page was extended with a CSI field that enables the host to query the log page for each command set supported. Retrieve this log page for each command set that an attached namespace supports, and save a pointer to that log in the namespace head. Reviewed-by: Javier González Reviewed-by: Martin K. Petersen Reviewed-by: Johannes Thumshirn Reviewed-by: Matias Bjørling Reviewed-by: Hannes Reinecke Reviewed-by: Daniel Wagner Signed-off-by: Keith Busch --- drivers/nvme/host/core.c | 79 ++++++++++++++++++++++++++--------- drivers/nvme/host/hwmon.c | 2 +- drivers/nvme/host/lightnvm.c | 4 +- drivers/nvme/host/multipath.c | 2 +- drivers/nvme/host/nvme.h | 10 ++++- include/linux/nvme.h | 4 +- 6 files changed, 76 insertions(+), 25 deletions(-) diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c index b7d12eb42fd8..a4a61d7e793d 100644 --- a/drivers/nvme/host/core.c +++ b/drivers/nvme/host/core.c @@ -1370,8 +1370,8 @@ static u32 nvme_passthru_start(struct nvme_ctrl *ctrl, struct nvme_ns *ns, u32 effects = 0; if (ns) { - if (ctrl->effects) - effects = le32_to_cpu(ctrl->effects->iocs[opcode]); + if (ns->head->effects) + effects = le32_to_cpu(ns->head->effects->iocs[opcode]); if (effects & ~(NVME_CMD_EFFECTS_CSUPP | NVME_CMD_EFFECTS_LBCC)) dev_warn(ctrl->device, "IO command:%02x has unhandled effects:%08x\n", @@ -2850,7 +2850,7 @@ static int nvme_init_subsystem(struct nvme_ctrl *ctrl, struct nvme_id_ctrl *id) return ret; } -int nvme_get_log(struct nvme_ctrl *ctrl, u32 nsid, u8 log_page, u8 lsp, +int nvme_get_log(struct nvme_ctrl *ctrl, u32 nsid, u8 log_page, u8 lsp, u8 csi, void *log, size_t size, u64 offset) { struct nvme_command c = { }; @@ -2864,27 +2864,55 @@ int nvme_get_log(struct nvme_ctrl *ctrl, u32 nsid, u8 log_page, u8 lsp, c.get_log_page.numdu = cpu_to_le16(dwlen >> 16); c.get_log_page.lpol = cpu_to_le32(lower_32_bits(offset)); c.get_log_page.lpou = cpu_to_le32(upper_32_bits(offset)); + c.get_log_page.csi = csi; return nvme_submit_sync_cmd(ctrl->admin_q, &c, log, size); } -static int nvme_get_effects_log(struct nvme_ctrl *ctrl) +struct nvme_cel *nvme_find_cel(struct nvme_ctrl *ctrl, u8 csi) { + struct nvme_cel *cel, *ret = NULL; + + spin_lock(&ctrl->lock); + list_for_each_entry(cel, &ctrl->cels, entry) { + if (cel->csi == csi) { + ret = cel; + break; + } + } + spin_unlock(&ctrl->lock); + + return ret; +} + +static int nvme_get_effects_log(struct nvme_ctrl *ctrl, u8 csi, + struct nvme_effects_log **log) +{ + struct nvme_cel *cel = nvme_find_cel(ctrl, csi); int ret; - if (!ctrl->effects) - ctrl->effects = kzalloc(sizeof(*ctrl->effects), GFP_KERNEL); + if (cel) + goto out; - if (!ctrl->effects) - return 0; + cel = kzalloc(sizeof(*cel), GFP_KERNEL); + if (!cel) + return -ENOMEM; - ret = nvme_get_log(ctrl, NVME_NSID_ALL, NVME_LOG_CMD_EFFECTS, 0, - ctrl->effects, sizeof(*ctrl->effects), 0); + ret = nvme_get_log(ctrl, NVME_NSID_ALL, NVME_LOG_CMD_EFFECTS, 0, csi, + &cel->log, sizeof(cel->log), 0); if (ret) { - kfree(ctrl->effects); - ctrl->effects = NULL; + kfree(cel); + return ret; } - return ret; + + cel->csi = csi; + + spin_lock(&ctrl->lock); + list_add_tail(&cel->entry, &ctrl->cels); + spin_unlock(&ctrl->lock); +out: + *log = &cel->log; + return 0; } /* @@ -2917,7 +2945,7 @@ int nvme_init_identify(struct nvme_ctrl *ctrl) } if (id->lpa & NVME_CTRL_LPA_CMD_EFFECTS_LOG) { - ret = nvme_get_effects_log(ctrl); + ret = nvme_get_effects_log(ctrl, NVME_CSI_NVM, &ctrl->effects); if (ret < 0) goto out_free; } @@ -3550,6 +3578,13 @@ static struct nvme_ns_head *nvme_alloc_ns_head(struct nvme_ctrl *ctrl, goto out_cleanup_srcu; } + if (head->ids.csi) { + ret = nvme_get_effects_log(ctrl, head->ids.csi, &head->effects); + if (ret) + goto out_cleanup_srcu; + } else + head->effects = ctrl->effects; + ret = nvme_mpath_alloc_disk(ctrl, head); if (ret) goto out_cleanup_srcu; @@ -3890,8 +3925,8 @@ static void nvme_clear_changed_ns_log(struct nvme_ctrl *ctrl) * raced with us in reading the log page, which could cause us to miss * updates. */ - error = nvme_get_log(ctrl, NVME_NSID_ALL, NVME_LOG_CHANGED_NS, 0, log, - log_size, 0); + error = nvme_get_log(ctrl, NVME_NSID_ALL, NVME_LOG_CHANGED_NS, 0, + NVME_CSI_NVM, log, log_size, 0); if (error) dev_warn(ctrl->device, "reading changed ns log failed: %d\n", error); @@ -4035,8 +4070,8 @@ static void nvme_get_fw_slot_info(struct nvme_ctrl *ctrl) if (!log) return; - if (nvme_get_log(ctrl, NVME_NSID_ALL, NVME_LOG_FW_SLOT, 0, log, - sizeof(*log), 0)) + if (nvme_get_log(ctrl, NVME_NSID_ALL, NVME_LOG_FW_SLOT, 0, NVME_CSI_NVM, + log, sizeof(*log), 0)) dev_warn(ctrl->device, "Get FW SLOT INFO log error\n"); kfree(log); } @@ -4173,11 +4208,16 @@ static void nvme_free_ctrl(struct device *dev) struct nvme_ctrl *ctrl = container_of(dev, struct nvme_ctrl, ctrl_device); struct nvme_subsystem *subsys = ctrl->subsys; + struct nvme_cel *cel, *next; if (subsys && ctrl->instance != subsys->instance) ida_simple_remove(&nvme_instance_ida, ctrl->instance); - kfree(ctrl->effects); + list_for_each_entry_safe(cel, next, &ctrl->cels, entry) { + list_del(&cel->entry); + kfree(cel); + } + nvme_mpath_uninit(ctrl); __free_page(ctrl->discard_page); @@ -4208,6 +4248,7 @@ int nvme_init_ctrl(struct nvme_ctrl *ctrl, struct device *dev, spin_lock_init(&ctrl->lock); mutex_init(&ctrl->scan_lock); INIT_LIST_HEAD(&ctrl->namespaces); + INIT_LIST_HEAD(&ctrl->cels); init_rwsem(&ctrl->namespaces_rwsem); ctrl->dev = dev; ctrl->ops = ops; diff --git a/drivers/nvme/host/hwmon.c b/drivers/nvme/host/hwmon.c index 2e6477ed420f..23ba8bf678ae 100644 --- a/drivers/nvme/host/hwmon.c +++ b/drivers/nvme/host/hwmon.c @@ -62,7 +62,7 @@ static int nvme_hwmon_get_smart_log(struct nvme_hwmon_data *data) int ret; ret = nvme_get_log(data->ctrl, NVME_NSID_ALL, NVME_LOG_SMART, 0, - &data->log, sizeof(data->log), 0); + NVME_CSI_NVM, &data->log, sizeof(data->log), 0); return ret <= 0 ? ret : -EIO; } diff --git a/drivers/nvme/host/lightnvm.c b/drivers/nvme/host/lightnvm.c index 69608755d415..8e562d0f2c30 100644 --- a/drivers/nvme/host/lightnvm.c +++ b/drivers/nvme/host/lightnvm.c @@ -593,8 +593,8 @@ static int nvme_nvm_get_chk_meta(struct nvm_dev *ndev, dev_meta_off = dev_meta; ret = nvme_get_log(ctrl, ns->head->ns_id, - NVME_NVM_LOG_REPORT_CHUNK, 0, dev_meta, len, - offset); + NVME_NVM_LOG_REPORT_CHUNK, 0, NVME_CSI_NVM, + dev_meta, len, offset); if (ret) { dev_err(ctrl->device, "Get REPORT CHUNK log error\n"); break; diff --git a/drivers/nvme/host/multipath.c b/drivers/nvme/host/multipath.c index 18d084ed497e..b551e9884430 100644 --- a/drivers/nvme/host/multipath.c +++ b/drivers/nvme/host/multipath.c @@ -529,7 +529,7 @@ static int nvme_read_ana_log(struct nvme_ctrl *ctrl) int error; mutex_lock(&ctrl->ana_lock); - error = nvme_get_log(ctrl, NVME_NSID_ALL, NVME_LOG_ANA, 0, + error = nvme_get_log(ctrl, NVME_NSID_ALL, NVME_LOG_ANA, 0, NVME_CSI_NVM, ctrl->ana_log_buf, ctrl->ana_log_size, 0); if (error) { dev_warn(ctrl->device, "Failed to get ANA log: %d\n", error); diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h index 4aa321b16eaa..dd24a94c42ff 100644 --- a/drivers/nvme/host/nvme.h +++ b/drivers/nvme/host/nvme.h @@ -191,6 +191,12 @@ struct nvme_fault_inject { #endif }; +struct nvme_cel { + struct list_head entry; + struct nvme_effects_log log; + u8 csi; +}; + struct nvme_ctrl { bool comp_seen; enum nvme_ctrl_state state; @@ -257,6 +263,7 @@ struct nvme_ctrl { unsigned long quirks; struct nvme_id_power_state psd[32]; struct nvme_effects_log *effects; + struct list_head cels; struct work_struct scan_work; struct work_struct async_event_work; struct delayed_work ka_work; @@ -359,6 +366,7 @@ struct nvme_ns_head { struct kref ref; bool shared; int instance; + struct nvme_effects_log *effects; #ifdef CONFIG_NVME_MULTIPATH struct gendisk *disk; struct bio_list requeue_list; @@ -561,7 +569,7 @@ int nvme_reset_ctrl_sync(struct nvme_ctrl *ctrl); int nvme_try_sched_reset(struct nvme_ctrl *ctrl); int nvme_delete_ctrl(struct nvme_ctrl *ctrl); -int nvme_get_log(struct nvme_ctrl *ctrl, u32 nsid, u8 log_page, u8 lsp, +int nvme_get_log(struct nvme_ctrl *ctrl, u32 nsid, u8 log_page, u8 lsp, u8 csi, void *log, size_t size, u64 offset); extern const struct attribute_group *nvme_ns_id_attr_groups[]; diff --git a/include/linux/nvme.h b/include/linux/nvme.h index 81ffe5247505..95cd03e240a1 100644 --- a/include/linux/nvme.h +++ b/include/linux/nvme.h @@ -1101,7 +1101,9 @@ struct nvme_get_log_page_command { }; __le64 lpo; }; - __u32 rsvd14[2]; + __u8 rsvd14[3]; + __u8 csi; + __u32 rsvd15; }; struct nvme_directive_cmd { -- 2.24.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-10.0 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE, SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id BBD3EC433E0 for ; Mon, 29 Jun 2020 19:07:01 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 8604720663 for ; Mon, 29 Jun 2020 19:07:01 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="wuyOqBF8"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=kernel.org header.i=@kernel.org header.b="NXClzJcv" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8604720663 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-nvme-bounces+linux-nvme=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-Id:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=hrDYnngI+GTSTYWvBR86rcOR4rjF31dGOTxgPd5Y01I=; b=wuyOqBF8TBC6oUFSsaXmPUefo GwCI/PX1YoKQcX4oYbQqYBvoLiIjPF+OA6HOHg/QPFDQBRAbAkhdEa3sM5zOslXF7NlrxaGjO97HK mEYH4dt8tS8uEPKRcDxExk1mTXRQrVcuBBqAy6ON1UIkxV0JeMxkP5zyPsnBuECLYMhFrWZuA1KE2 UIE93bLonlaFgpk1ZWf9EcHTOCGpGXOTqYdDvqPn9OIMhTOXchHaAnEzTL9MHhUZPFkbgL1mwi1AO GDkmMkoOGN6kco10APbOV7NlVni0NDKofu/BI4Je8T7M4ZgchK7wMgoD00RdppXZmjrXBh67ZepQQ MVUPl8Rrg==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jpz7I-0006sP-52; Mon, 29 Jun 2020 19:06:56 +0000 Received: from mail.kernel.org ([198.145.29.99]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jpz7B-0006qJ-HS for linux-nvme@lists.infradead.org; Mon, 29 Jun 2020 19:06:52 +0000 Received: from dhcp-10-100-145-180.wdl.wdc.com (unknown [199.255.45.60]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id 2F33920702; Mon, 29 Jun 2020 19:06:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1593457609; bh=3xClpJBPNLC08/oirvKhxgs8ayLaUb+vP83nGBXxTsw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=NXClzJcvoFZZy/07zx7KPVoBEtwKXQ5ZkYg9GrGfAVXPgKlZ4jjbgAs/IGBDfg2V+ exHUx8XjOxijIWjg/d1gdYO5sU90u9KP5m6+t5joVReDzgXPeYVu31UPhPBCUlNdTu tNjy/uF/ss3DU9mtrxTxUZ46Nhj3/LNLadYCP8dw= From: Keith Busch To: linux-nvme@lists.infradead.org, hch@lst.de, sagi@grimberg.me, linux-block@vger.kernel.org Subject: [PATCHv4 4/5] nvme: support for multi-command set effects Date: Mon, 29 Jun 2020 12:06:40 -0700 Message-Id: <20200629190641.1986462-5-kbusch@kernel.org> X-Mailer: git-send-email 2.24.1 In-Reply-To: <20200629190641.1986462-1-kbusch@kernel.org> References: <20200629190641.1986462-1-kbusch@kernel.org> MIME-Version: 1.0 X-BeenThere: linux-nvme@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: axboe@kernel.dk, Keith Busch , "Martin K . Petersen" , Johannes Thumshirn , Hannes Reinecke , =?UTF-8?q?Javier=20Gonz=C3=A1lez?= , Daniel Wagner , =?UTF-8?q?Matias=20Bj=C3=B8rling?= Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-nvme" Errors-To: linux-nvme-bounces+linux-nvme=archiver.kernel.org@lists.infradead.org RnJvbTogS2VpdGggQnVzY2ggPGtlaXRoLmJ1c2NoQHdkYy5jb20+CgpUaGUgQ29tbWFuZHMgU3Vw cG9ydGVkIGFuZCBFZmZlY3RzIGxvZyBwYWdlIHdhcyBleHRlbmRlZCB3aXRoIGEgQ1NJCmZpZWxk IHRoYXQgZW5hYmxlcyB0aGUgaG9zdCB0byBxdWVyeSB0aGUgbG9nIHBhZ2UgZm9yIGVhY2ggY29t bWFuZCBzZXQKc3VwcG9ydGVkLiBSZXRyaWV2ZSB0aGlzIGxvZyBwYWdlIGZvciBlYWNoIGNvbW1h bmQgc2V0IHRoYXQgYW4gYXR0YWNoZWQKbmFtZXNwYWNlIHN1cHBvcnRzLCBhbmQgc2F2ZSBhIHBv aW50ZXIgdG8gdGhhdCBsb2cgaW4gdGhlIG5hbWVzcGFjZSBoZWFkLgoKUmV2aWV3ZWQtYnk6IEph dmllciBHb256w6FsZXogPGphdmllci5nb256QHNhbXN1bmcuY29tPgpSZXZpZXdlZC1ieTogTWFy dGluIEsuIFBldGVyc2VuIDxtYXJ0aW4ucGV0ZXJzZW5Ab3JhY2xlLmNvbT4KUmV2aWV3ZWQtYnk6 IEpvaGFubmVzIFRodW1zaGlybiA8am9oYW5uZXMudGh1bXNoaXJuQHdkYy5jb20+ClJldmlld2Vk LWJ5OiBNYXRpYXMgQmrDuHJsaW5nIDxtYXRpYXMuYmpvcmxpbmdAd2RjLmNvbT4KUmV2aWV3ZWQt Ynk6IEhhbm5lcyBSZWluZWNrZSA8aGFyZUBzdXNlLmRlPgpSZXZpZXdlZC1ieTogRGFuaWVsIFdh Z25lciA8ZHdhZ25lckBzdXNlLmRlPgpTaWduZWQtb2ZmLWJ5OiBLZWl0aCBCdXNjaCA8a2VpdGgu YnVzY2hAd2RjLmNvbT4KLS0tCiBkcml2ZXJzL252bWUvaG9zdC9jb3JlLmMgICAgICB8IDc5ICsr KysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tCiBkcml2ZXJzL252bWUvaG9zdC9od21v bi5jICAgICB8ICAyICstCiBkcml2ZXJzL252bWUvaG9zdC9saWdodG52bS5jICB8ICA0ICstCiBk cml2ZXJzL252bWUvaG9zdC9tdWx0aXBhdGguYyB8ICAyICstCiBkcml2ZXJzL252bWUvaG9zdC9u dm1lLmggICAgICB8IDEwICsrKystCiBpbmNsdWRlL2xpbnV4L252bWUuaCAgICAgICAgICB8ICA0 ICstCiA2IGZpbGVzIGNoYW5nZWQsIDc2IGluc2VydGlvbnMoKyksIDI1IGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYyBiL2RyaXZlcnMvbnZtZS9ob3N0 L2NvcmUuYwppbmRleCBiN2QxMmViNDJmZDguLmE0YTYxZDdlNzkzZCAxMDA2NDQKLS0tIGEvZHJp dmVycy9udm1lL2hvc3QvY29yZS5jCisrKyBiL2RyaXZlcnMvbnZtZS9ob3N0L2NvcmUuYwpAQCAt MTM3MCw4ICsxMzcwLDggQEAgc3RhdGljIHUzMiBudm1lX3Bhc3N0aHJ1X3N0YXJ0KHN0cnVjdCBu dm1lX2N0cmwgKmN0cmwsIHN0cnVjdCBudm1lX25zICpucywKIAl1MzIgZWZmZWN0cyA9IDA7CiAK IAlpZiAobnMpIHsKLQkJaWYgKGN0cmwtPmVmZmVjdHMpCi0JCQllZmZlY3RzID0gbGUzMl90b19j cHUoY3RybC0+ZWZmZWN0cy0+aW9jc1tvcGNvZGVdKTsKKwkJaWYgKG5zLT5oZWFkLT5lZmZlY3Rz KQorCQkJZWZmZWN0cyA9IGxlMzJfdG9fY3B1KG5zLT5oZWFkLT5lZmZlY3RzLT5pb2NzW29wY29k ZV0pOwogCQlpZiAoZWZmZWN0cyAmIH4oTlZNRV9DTURfRUZGRUNUU19DU1VQUCB8IE5WTUVfQ01E X0VGRkVDVFNfTEJDQykpCiAJCQlkZXZfd2FybihjdHJsLT5kZXZpY2UsCiAJCQkJICJJTyBjb21t YW5kOiUwMnggaGFzIHVuaGFuZGxlZCBlZmZlY3RzOiUwOHhcbiIsCkBAIC0yODUwLDcgKzI4NTAs NyBAQCBzdGF0aWMgaW50IG52bWVfaW5pdF9zdWJzeXN0ZW0oc3RydWN0IG52bWVfY3RybCAqY3Ry bCwgc3RydWN0IG52bWVfaWRfY3RybCAqaWQpCiAJcmV0dXJuIHJldDsKIH0KIAotaW50IG52bWVf Z2V0X2xvZyhzdHJ1Y3QgbnZtZV9jdHJsICpjdHJsLCB1MzIgbnNpZCwgdTggbG9nX3BhZ2UsIHU4 IGxzcCwKK2ludCBudm1lX2dldF9sb2coc3RydWN0IG52bWVfY3RybCAqY3RybCwgdTMyIG5zaWQs IHU4IGxvZ19wYWdlLCB1OCBsc3AsIHU4IGNzaSwKIAkJdm9pZCAqbG9nLCBzaXplX3Qgc2l6ZSwg dTY0IG9mZnNldCkKIHsKIAlzdHJ1Y3QgbnZtZV9jb21tYW5kIGMgPSB7IH07CkBAIC0yODY0LDI3 ICsyODY0LDU1IEBAIGludCBudm1lX2dldF9sb2coc3RydWN0IG52bWVfY3RybCAqY3RybCwgdTMy IG5zaWQsIHU4IGxvZ19wYWdlLCB1OCBsc3AsCiAJYy5nZXRfbG9nX3BhZ2UubnVtZHUgPSBjcHVf dG9fbGUxNihkd2xlbiA+PiAxNik7CiAJYy5nZXRfbG9nX3BhZ2UubHBvbCA9IGNwdV90b19sZTMy KGxvd2VyXzMyX2JpdHMob2Zmc2V0KSk7CiAJYy5nZXRfbG9nX3BhZ2UubHBvdSA9IGNwdV90b19s ZTMyKHVwcGVyXzMyX2JpdHMob2Zmc2V0KSk7CisJYy5nZXRfbG9nX3BhZ2UuY3NpID0gY3NpOwog CiAJcmV0dXJuIG52bWVfc3VibWl0X3N5bmNfY21kKGN0cmwtPmFkbWluX3EsICZjLCBsb2csIHNp emUpOwogfQogCi1zdGF0aWMgaW50IG52bWVfZ2V0X2VmZmVjdHNfbG9nKHN0cnVjdCBudm1lX2N0 cmwgKmN0cmwpCitzdHJ1Y3QgbnZtZV9jZWwgKm52bWVfZmluZF9jZWwoc3RydWN0IG52bWVfY3Ry bCAqY3RybCwgdTggY3NpKQogeworCXN0cnVjdCBudm1lX2NlbCAqY2VsLCAqcmV0ID0gTlVMTDsK KworCXNwaW5fbG9jaygmY3RybC0+bG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShjZWwsICZj dHJsLT5jZWxzLCBlbnRyeSkgeworCQlpZiAoY2VsLT5jc2kgPT0gY3NpKSB7CisJCQlyZXQgPSBj ZWw7CisJCQlicmVhazsKKwkJfQorCX0KKwlzcGluX3VubG9jaygmY3RybC0+bG9jayk7CisKKwly ZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IG52bWVfZ2V0X2VmZmVjdHNfbG9nKHN0cnVjdCBu dm1lX2N0cmwgKmN0cmwsIHU4IGNzaSwKKwkJCQlzdHJ1Y3QgbnZtZV9lZmZlY3RzX2xvZyAqKmxv ZykKK3sKKwlzdHJ1Y3QgbnZtZV9jZWwgKmNlbCA9IG52bWVfZmluZF9jZWwoY3RybCwgY3NpKTsK IAlpbnQgcmV0OwogCi0JaWYgKCFjdHJsLT5lZmZlY3RzKQotCQljdHJsLT5lZmZlY3RzID0ga3ph bGxvYyhzaXplb2YoKmN0cmwtPmVmZmVjdHMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoY2VsKQorCQln b3RvIG91dDsKIAotCWlmICghY3RybC0+ZWZmZWN0cykKLQkJcmV0dXJuIDA7CisJY2VsID0ga3ph bGxvYyhzaXplb2YoKmNlbCksIEdGUF9LRVJORUwpOworCWlmICghY2VsKQorCQlyZXR1cm4gLUVO T01FTTsKIAotCXJldCA9IG52bWVfZ2V0X2xvZyhjdHJsLCBOVk1FX05TSURfQUxMLCBOVk1FX0xP R19DTURfRUZGRUNUUywgMCwKLQkJCWN0cmwtPmVmZmVjdHMsIHNpemVvZigqY3RybC0+ZWZmZWN0 cyksIDApOworCXJldCA9IG52bWVfZ2V0X2xvZyhjdHJsLCBOVk1FX05TSURfQUxMLCBOVk1FX0xP R19DTURfRUZGRUNUUywgMCwgY3NpLAorCQkJJmNlbC0+bG9nLCBzaXplb2YoY2VsLT5sb2cpLCAw KTsKIAlpZiAocmV0KSB7Ci0JCWtmcmVlKGN0cmwtPmVmZmVjdHMpOwotCQljdHJsLT5lZmZlY3Rz ID0gTlVMTDsKKwkJa2ZyZWUoY2VsKTsKKwkJcmV0dXJuIHJldDsKIAl9Ci0JcmV0dXJuIHJldDsK KworCWNlbC0+Y3NpID0gY3NpOworCisJc3Bpbl9sb2NrKCZjdHJsLT5sb2NrKTsKKwlsaXN0X2Fk ZF90YWlsKCZjZWwtPmVudHJ5LCAmY3RybC0+Y2Vscyk7CisJc3Bpbl91bmxvY2soJmN0cmwtPmxv Y2spOworb3V0OgorCSpsb2cgPSAmY2VsLT5sb2c7CisJcmV0dXJuIDA7CiB9CiAKIC8qCkBAIC0y OTE3LDcgKzI5NDUsNyBAQCBpbnQgbnZtZV9pbml0X2lkZW50aWZ5KHN0cnVjdCBudm1lX2N0cmwg KmN0cmwpCiAJfQogCiAJaWYgKGlkLT5scGEgJiBOVk1FX0NUUkxfTFBBX0NNRF9FRkZFQ1RTX0xP RykgewotCQlyZXQgPSBudm1lX2dldF9lZmZlY3RzX2xvZyhjdHJsKTsKKwkJcmV0ID0gbnZtZV9n ZXRfZWZmZWN0c19sb2coY3RybCwgTlZNRV9DU0lfTlZNLCAmY3RybC0+ZWZmZWN0cyk7CiAJCWlm IChyZXQgPCAwKQogCQkJZ290byBvdXRfZnJlZTsKIAl9CkBAIC0zNTUwLDYgKzM1NzgsMTMgQEAg c3RhdGljIHN0cnVjdCBudm1lX25zX2hlYWQgKm52bWVfYWxsb2NfbnNfaGVhZChzdHJ1Y3QgbnZt ZV9jdHJsICpjdHJsLAogCQlnb3RvIG91dF9jbGVhbnVwX3NyY3U7CiAJfQogCisJaWYgKGhlYWQt Pmlkcy5jc2kpIHsKKwkJcmV0ID0gbnZtZV9nZXRfZWZmZWN0c19sb2coY3RybCwgaGVhZC0+aWRz LmNzaSwgJmhlYWQtPmVmZmVjdHMpOworCQlpZiAocmV0KQorCQkJZ290byBvdXRfY2xlYW51cF9z cmN1OworCX0gZWxzZQorCQloZWFkLT5lZmZlY3RzID0gY3RybC0+ZWZmZWN0czsKKwogCXJldCA9 IG52bWVfbXBhdGhfYWxsb2NfZGlzayhjdHJsLCBoZWFkKTsKIAlpZiAocmV0KQogCQlnb3RvIG91 dF9jbGVhbnVwX3NyY3U7CkBAIC0zODkwLDggKzM5MjUsOCBAQCBzdGF0aWMgdm9pZCBudm1lX2Ns ZWFyX2NoYW5nZWRfbnNfbG9nKHN0cnVjdCBudm1lX2N0cmwgKmN0cmwpCiAJICogcmFjZWQgd2l0 aCB1cyBpbiByZWFkaW5nIHRoZSBsb2cgcGFnZSwgd2hpY2ggY291bGQgY2F1c2UgdXMgdG8gbWlz cwogCSAqIHVwZGF0ZXMuCiAJICovCi0JZXJyb3IgPSBudm1lX2dldF9sb2coY3RybCwgTlZNRV9O U0lEX0FMTCwgTlZNRV9MT0dfQ0hBTkdFRF9OUywgMCwgbG9nLAotCQkJbG9nX3NpemUsIDApOwor CWVycm9yID0gbnZtZV9nZXRfbG9nKGN0cmwsIE5WTUVfTlNJRF9BTEwsIE5WTUVfTE9HX0NIQU5H RURfTlMsIDAsCisJCQlOVk1FX0NTSV9OVk0sIGxvZywgbG9nX3NpemUsIDApOwogCWlmIChlcnJv cikKIAkJZGV2X3dhcm4oY3RybC0+ZGV2aWNlLAogCQkJInJlYWRpbmcgY2hhbmdlZCBucyBsb2cg ZmFpbGVkOiAlZFxuIiwgZXJyb3IpOwpAQCAtNDAzNSw4ICs0MDcwLDggQEAgc3RhdGljIHZvaWQg bnZtZV9nZXRfZndfc2xvdF9pbmZvKHN0cnVjdCBudm1lX2N0cmwgKmN0cmwpCiAJaWYgKCFsb2cp CiAJCXJldHVybjsKIAotCWlmIChudm1lX2dldF9sb2coY3RybCwgTlZNRV9OU0lEX0FMTCwgTlZN RV9MT0dfRldfU0xPVCwgMCwgbG9nLAotCQkJc2l6ZW9mKCpsb2cpLCAwKSkKKwlpZiAobnZtZV9n ZXRfbG9nKGN0cmwsIE5WTUVfTlNJRF9BTEwsIE5WTUVfTE9HX0ZXX1NMT1QsIDAsIE5WTUVfQ1NJ X05WTSwKKwkJCWxvZywgc2l6ZW9mKCpsb2cpLCAwKSkKIAkJZGV2X3dhcm4oY3RybC0+ZGV2aWNl LCAiR2V0IEZXIFNMT1QgSU5GTyBsb2cgZXJyb3JcbiIpOwogCWtmcmVlKGxvZyk7CiB9CkBAIC00 MTczLDExICs0MjA4LDE2IEBAIHN0YXRpYyB2b2lkIG52bWVfZnJlZV9jdHJsKHN0cnVjdCBkZXZp Y2UgKmRldikKIAlzdHJ1Y3QgbnZtZV9jdHJsICpjdHJsID0KIAkJY29udGFpbmVyX29mKGRldiwg c3RydWN0IG52bWVfY3RybCwgY3RybF9kZXZpY2UpOwogCXN0cnVjdCBudm1lX3N1YnN5c3RlbSAq c3Vic3lzID0gY3RybC0+c3Vic3lzOworCXN0cnVjdCBudm1lX2NlbCAqY2VsLCAqbmV4dDsKIAog CWlmIChzdWJzeXMgJiYgY3RybC0+aW5zdGFuY2UgIT0gc3Vic3lzLT5pbnN0YW5jZSkKIAkJaWRh X3NpbXBsZV9yZW1vdmUoJm52bWVfaW5zdGFuY2VfaWRhLCBjdHJsLT5pbnN0YW5jZSk7CiAKLQlr ZnJlZShjdHJsLT5lZmZlY3RzKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoY2VsLCBuZXh0 LCAmY3RybC0+Y2VscywgZW50cnkpIHsKKwkJbGlzdF9kZWwoJmNlbC0+ZW50cnkpOworCQlrZnJl ZShjZWwpOworCX0KKwogCW52bWVfbXBhdGhfdW5pbml0KGN0cmwpOwogCV9fZnJlZV9wYWdlKGN0 cmwtPmRpc2NhcmRfcGFnZSk7CiAKQEAgLTQyMDgsNiArNDI0OCw3IEBAIGludCBudm1lX2luaXRf Y3RybChzdHJ1Y3QgbnZtZV9jdHJsICpjdHJsLCBzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJc3Bpbl9s b2NrX2luaXQoJmN0cmwtPmxvY2spOwogCW11dGV4X2luaXQoJmN0cmwtPnNjYW5fbG9jayk7CiAJ SU5JVF9MSVNUX0hFQUQoJmN0cmwtPm5hbWVzcGFjZXMpOworCUlOSVRfTElTVF9IRUFEKCZjdHJs LT5jZWxzKTsKIAlpbml0X3J3c2VtKCZjdHJsLT5uYW1lc3BhY2VzX3J3c2VtKTsKIAljdHJsLT5k ZXYgPSBkZXY7CiAJY3RybC0+b3BzID0gb3BzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9udm1lL2hv c3QvaHdtb24uYyBiL2RyaXZlcnMvbnZtZS9ob3N0L2h3bW9uLmMKaW5kZXggMmU2NDc3ZWQ0MjBm Li4yM2JhOGJmNjc4YWUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbnZtZS9ob3N0L2h3bW9uLmMKKysr IGIvZHJpdmVycy9udm1lL2hvc3QvaHdtb24uYwpAQCAtNjIsNyArNjIsNyBAQCBzdGF0aWMgaW50 IG52bWVfaHdtb25fZ2V0X3NtYXJ0X2xvZyhzdHJ1Y3QgbnZtZV9od21vbl9kYXRhICpkYXRhKQog CWludCByZXQ7CiAKIAlyZXQgPSBudm1lX2dldF9sb2coZGF0YS0+Y3RybCwgTlZNRV9OU0lEX0FM TCwgTlZNRV9MT0dfU01BUlQsIDAsCi0JCQkgICAmZGF0YS0+bG9nLCBzaXplb2YoZGF0YS0+bG9n KSwgMCk7CisJCQkgICBOVk1FX0NTSV9OVk0sICZkYXRhLT5sb2csIHNpemVvZihkYXRhLT5sb2cp LCAwKTsKIAogCXJldHVybiByZXQgPD0gMCA/IHJldCA6IC1FSU87CiB9CmRpZmYgLS1naXQgYS9k cml2ZXJzL252bWUvaG9zdC9saWdodG52bS5jIGIvZHJpdmVycy9udm1lL2hvc3QvbGlnaHRudm0u YwppbmRleCA2OTYwODc1NWQ0MTUuLjhlNTYyZDBmMmMzMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9u dm1lL2hvc3QvbGlnaHRudm0uYworKysgYi9kcml2ZXJzL252bWUvaG9zdC9saWdodG52bS5jCkBA IC01OTMsOCArNTkzLDggQEAgc3RhdGljIGludCBudm1lX252bV9nZXRfY2hrX21ldGEoc3RydWN0 IG52bV9kZXYgKm5kZXYsCiAJCWRldl9tZXRhX29mZiA9IGRldl9tZXRhOwogCiAJCXJldCA9IG52 bWVfZ2V0X2xvZyhjdHJsLCBucy0+aGVhZC0+bnNfaWQsCi0JCQkJTlZNRV9OVk1fTE9HX1JFUE9S VF9DSFVOSywgMCwgZGV2X21ldGEsIGxlbiwKLQkJCQlvZmZzZXQpOworCQkJCU5WTUVfTlZNX0xP R19SRVBPUlRfQ0hVTkssIDAsIE5WTUVfQ1NJX05WTSwKKwkJCQlkZXZfbWV0YSwgbGVuLCBvZmZz ZXQpOwogCQlpZiAocmV0KSB7CiAJCQlkZXZfZXJyKGN0cmwtPmRldmljZSwgIkdldCBSRVBPUlQg Q0hVTksgbG9nIGVycm9yXG4iKTsKIAkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9udm1l L2hvc3QvbXVsdGlwYXRoLmMgYi9kcml2ZXJzL252bWUvaG9zdC9tdWx0aXBhdGguYwppbmRleCAx OGQwODRlZDQ5N2UuLmI1NTFlOTg4NDQzMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9udm1lL2hvc3Qv bXVsdGlwYXRoLmMKKysrIGIvZHJpdmVycy9udm1lL2hvc3QvbXVsdGlwYXRoLmMKQEAgLTUyOSw3 ICs1MjksNyBAQCBzdGF0aWMgaW50IG52bWVfcmVhZF9hbmFfbG9nKHN0cnVjdCBudm1lX2N0cmwg KmN0cmwpCiAJaW50IGVycm9yOwogCiAJbXV0ZXhfbG9jaygmY3RybC0+YW5hX2xvY2spOwotCWVy cm9yID0gbnZtZV9nZXRfbG9nKGN0cmwsIE5WTUVfTlNJRF9BTEwsIE5WTUVfTE9HX0FOQSwgMCwK KwllcnJvciA9IG52bWVfZ2V0X2xvZyhjdHJsLCBOVk1FX05TSURfQUxMLCBOVk1FX0xPR19BTkEs IDAsIE5WTUVfQ1NJX05WTSwKIAkJCWN0cmwtPmFuYV9sb2dfYnVmLCBjdHJsLT5hbmFfbG9nX3Np emUsIDApOwogCWlmIChlcnJvcikgewogCQlkZXZfd2FybihjdHJsLT5kZXZpY2UsICJGYWlsZWQg dG8gZ2V0IEFOQSBsb2c6ICVkXG4iLCBlcnJvcik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL252bWUv aG9zdC9udm1lLmggYi9kcml2ZXJzL252bWUvaG9zdC9udm1lLmgKaW5kZXggNGFhMzIxYjE2ZWFh Li5kZDI0YTk0YzQyZmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbnZtZS9ob3N0L252bWUuaAorKysg Yi9kcml2ZXJzL252bWUvaG9zdC9udm1lLmgKQEAgLTE5MSw2ICsxOTEsMTIgQEAgc3RydWN0IG52 bWVfZmF1bHRfaW5qZWN0IHsKICNlbmRpZgogfTsKIAorc3RydWN0IG52bWVfY2VsIHsKKwlzdHJ1 Y3QgbGlzdF9oZWFkCWVudHJ5OworCXN0cnVjdCBudm1lX2VmZmVjdHNfbG9nCWxvZzsKKwl1OAkJ CWNzaTsKK307CisKIHN0cnVjdCBudm1lX2N0cmwgewogCWJvb2wgY29tcF9zZWVuOwogCWVudW0g bnZtZV9jdHJsX3N0YXRlIHN0YXRlOwpAQCAtMjU3LDYgKzI2Myw3IEBAIHN0cnVjdCBudm1lX2N0 cmwgewogCXVuc2lnbmVkIGxvbmcgcXVpcmtzOwogCXN0cnVjdCBudm1lX2lkX3Bvd2VyX3N0YXRl IHBzZFszMl07CiAJc3RydWN0IG52bWVfZWZmZWN0c19sb2cgKmVmZmVjdHM7CisJc3RydWN0IGxp c3RfaGVhZCBjZWxzOwogCXN0cnVjdCB3b3JrX3N0cnVjdCBzY2FuX3dvcms7CiAJc3RydWN0IHdv cmtfc3RydWN0IGFzeW5jX2V2ZW50X3dvcms7CiAJc3RydWN0IGRlbGF5ZWRfd29yayBrYV93b3Jr OwpAQCAtMzU5LDYgKzM2Niw3IEBAIHN0cnVjdCBudm1lX25zX2hlYWQgewogCXN0cnVjdCBrcmVm CQlyZWY7CiAJYm9vbAkJCXNoYXJlZDsKIAlpbnQJCQlpbnN0YW5jZTsKKwlzdHJ1Y3QgbnZtZV9l ZmZlY3RzX2xvZyAqZWZmZWN0czsKICNpZmRlZiBDT05GSUdfTlZNRV9NVUxUSVBBVEgKIAlzdHJ1 Y3QgZ2VuZGlzawkJKmRpc2s7CiAJc3RydWN0IGJpb19saXN0CQlyZXF1ZXVlX2xpc3Q7CkBAIC01 NjEsNyArNTY5LDcgQEAgaW50IG52bWVfcmVzZXRfY3RybF9zeW5jKHN0cnVjdCBudm1lX2N0cmwg KmN0cmwpOwogaW50IG52bWVfdHJ5X3NjaGVkX3Jlc2V0KHN0cnVjdCBudm1lX2N0cmwgKmN0cmwp OwogaW50IG52bWVfZGVsZXRlX2N0cmwoc3RydWN0IG52bWVfY3RybCAqY3RybCk7CiAKLWludCBu dm1lX2dldF9sb2coc3RydWN0IG52bWVfY3RybCAqY3RybCwgdTMyIG5zaWQsIHU4IGxvZ19wYWdl LCB1OCBsc3AsCitpbnQgbnZtZV9nZXRfbG9nKHN0cnVjdCBudm1lX2N0cmwgKmN0cmwsIHUzMiBu c2lkLCB1OCBsb2dfcGFnZSwgdTggbHNwLCB1OCBjc2ksCiAJCXZvaWQgKmxvZywgc2l6ZV90IHNp emUsIHU2NCBvZmZzZXQpOwogCiBleHRlcm4gY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCAq bnZtZV9uc19pZF9hdHRyX2dyb3Vwc1tdOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9udm1l LmggYi9pbmNsdWRlL2xpbnV4L252bWUuaAppbmRleCA4MWZmZTUyNDc1MDUuLjk1Y2QwM2UyNDBh MSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9udm1lLmgKKysrIGIvaW5jbHVkZS9saW51eC9u dm1lLmgKQEAgLTExMDEsNyArMTEwMSw5IEBAIHN0cnVjdCBudm1lX2dldF9sb2dfcGFnZV9jb21t YW5kIHsKIAkJfTsKIAkJX19sZTY0IGxwbzsKIAl9OwotCV9fdTMyCQkJcnN2ZDE0WzJdOworCV9f dTgJCQlyc3ZkMTRbM107CisJX191OAkJCWNzaTsKKwlfX3UzMgkJCXJzdmQxNTsKIH07CiAKIHN0 cnVjdCBudm1lX2RpcmVjdGl2ZV9jbWQgewotLSAKMi4yNC4xCgoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXgtbnZtZSBtYWlsaW5nIGxpc3QKTGlu dXgtbnZtZUBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21h aWxtYW4vbGlzdGluZm8vbGludXgtbnZtZQo=