From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:44784) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1evSIp-000050-Io for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:36:08 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1evSIo-0005cg-Jo for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:36:07 -0400 Received: from mail-pl0-x242.google.com ([2607:f8b0:400e:c01::242]:33700) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1evSIo-0005c9-Ak for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:36:06 -0400 Received: by mail-pl0-x242.google.com with SMTP id c11-v6so9833118plo.0 for ; Mon, 12 Mar 2018 11:36:06 -0700 (PDT) From: Alexey Gerasimenko Date: Tue, 13 Mar 2018 04:34:09 +1000 Message-Id: <2bb9523a189c03a8a4da12af11cbc07f597dff57.1520867956.git.x1917x@gmail.com> In-Reply-To: References: In-Reply-To: References: Subject: [Qemu-devel] [RFC PATCH 24/30] xen/pt: allow to hide PCIe Extended Capabilities List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: xen-devel@lists.xenproject.org Cc: Alexey Gerasimenko , qemu-devel@nongnu.org, Stefano Stabellini , Anthony Perard We need to hide some unwanted PCI/PCIe capabilities for passed through devices. Normally we do this by marking the capability register group as XEN_PT_GRP_TYPE_HARDWIRED which exclude this capability from the capability list and returns zeroes on attempts to read capability body. Skipping the capability in the linked list of capabilities can be done by changing Next Capability register to skip one or many unwanted capabilities. One difference between PCI and PCIe Extended capabilities is that we don't have the list head field anymore. PCIe Extended capabilities always start at offset 0x100 if they're present. Unfortunately, there are typically only few PCIe extended capabilities present which means there is a chance that some capability we want to hide will reside at offset 0x100 in PCIe config space. The simplest way to hide such capabilities from guest OS or drivers is faking their capability ID value. This patch adds the Capability ID register handler which checks - if the capability to which this register belong starts at offset 0x100 in PCIe config space - if this capability is marked as XEN_PT_GRP_TYPE_HARDWIRED If it is the case, then a fake Capability ID value is returned. Signed-off-by: Alexey Gerasimenko --- hw/xen/xen_pt.c | 11 +++++++- hw/xen/xen_pt.h | 5 ++++ hw/xen/xen_pt_config_init.c | 62 ++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 76 insertions(+), 2 deletions(-) diff --git a/hw/xen/xen_pt.c b/hw/xen/xen_pt.c index bf098c26b3..e6a18afa83 100644 --- a/hw/xen/xen_pt.c +++ b/hw/xen/xen_pt.c @@ -154,7 +154,16 @@ static uint32_t xen_pt_pci_read_config(PCIDevice *d, uint32_t addr, int len) reg_grp_entry = xen_pt_find_reg_grp(s, addr); if (reg_grp_entry) { /* check 0-Hardwired register group */ - if (reg_grp_entry->reg_grp->grp_type == XEN_PT_GRP_TYPE_HARDWIRED) { + if (reg_grp_entry->reg_grp->grp_type == XEN_PT_GRP_TYPE_HARDWIRED && + /* + * For PCIe Extended Capabilities we need to emulate + * CapabilityID and NextCapability/Version registers for a + * hardwired reg group located at the offset 0x100 in PCIe + * config space. This allows us to hide the first extended + * capability as well. + */ + !(reg_grp_entry->base_offset == PCI_CONFIG_SPACE_SIZE && + ranges_overlap(addr, len, 0x100, 4))) { /* no need to emulate, just return 0 */ val = 0; goto exit; diff --git a/hw/xen/xen_pt.h b/hw/xen/xen_pt.h index 5531347ab2..ac45261679 100644 --- a/hw/xen/xen_pt.h +++ b/hw/xen/xen_pt.h @@ -78,6 +78,11 @@ typedef int (*xen_pt_conf_byte_read) #define XEN_PCI_INTEL_OPREGION 0xfc +#define XEN_PCIE_CAP_ID 0 +#define XEN_PCIE_CAP_LIST_NEXT 2 + +#define XEN_PCIE_FAKE_CAP_ID_BASE 0xFE00 + typedef enum { XEN_PT_GRP_TYPE_HARDWIRED = 0, /* 0 Hardwired reg group */ XEN_PT_GRP_TYPE_EMU, /* emul reg group */ diff --git a/hw/xen/xen_pt_config_init.c b/hw/xen/xen_pt_config_init.c index 0ce2a033f9..10f3b67d35 100644 --- a/hw/xen/xen_pt_config_init.c +++ b/hw/xen/xen_pt_config_init.c @@ -31,6 +31,10 @@ static int xen_pt_ext_cap_ptr_reg_init(XenPCIPassthroughState *s, XenPTRegInfo *reg, uint32_t real_offset, uint32_t *data); +static int xen_pt_ext_cap_capid_reg_init(XenPCIPassthroughState *s, + XenPTRegInfo *reg, + uint32_t real_offset, + uint32_t *data); /* helper */ @@ -1630,6 +1634,56 @@ static XenPTRegInfo xen_pt_emu_reg_igd_opregion[] = { }, }; + +/**************************** + * Emulated registers for + * PCIe Extended Capabilities + */ + +static uint16_t fake_cap_id = XEN_PCIE_FAKE_CAP_ID_BASE; + +/* PCIe Extended Capability ID reg */ +static int xen_pt_ext_cap_capid_reg_init(XenPCIPassthroughState *s, + XenPTRegInfo *reg, + uint32_t real_offset, + uint32_t *data) +{ + uint16_t reg_field; + int rc; + XenPTRegGroup *reg_grp_entry = NULL; + + /* use real device register's value as initial value */ + rc = xen_host_pci_get_word(&s->real_device, real_offset, ®_field); + if (rc) { + return rc; + } + + reg_grp_entry = xen_pt_find_reg_grp(s, real_offset); + + if (reg_grp_entry) { + if (reg_grp_entry->reg_grp->grp_type == XEN_PT_GRP_TYPE_HARDWIRED && + reg_grp_entry->base_offset == PCI_CONFIG_SPACE_SIZE) { + /* + * This is the situation when we were asked to hide (aka + * "hardwire to 0") some PCIe ext capability, but it was located + * at offset 0x100 in PCIe config space. In this case we can't + * simply exclude it from the linked list of capabilities + * (as it is the first entry in the list), so we must fake its + * Capability ID in PCIe Extended Capability header, leaving + * the Next Ptr field intact while returning zeroes on attempts + * to read capability body (writes are ignored). + */ + reg_field = fake_cap_id; + /* increment the value in order to have unique Capability IDs */ + fake_cap_id++; + } + } + + *data = reg_field; + return 0; +} + + /**************************** * Capabilities */ @@ -2173,7 +2227,13 @@ void xen_pt_config_init(XenPCIPassthroughState *s, Error **errp) } } - if (xen_pt_emu_reg_grps[i].grp_type == XEN_PT_GRP_TYPE_EMU) { + if (xen_pt_emu_reg_grps[i].grp_type == XEN_PT_GRP_TYPE_EMU || + /* + * We need to always emulate the PCIe Extended Capability + * header for a hidden capability which starts at offset 0x100 + */ + (xen_pt_emu_reg_grps[i].grp_type == XEN_PT_GRP_TYPE_HARDWIRED && + reg_grp_offset == 0x100)) { if (xen_pt_emu_reg_grps[i].emu_regs) { int j = 0; XenPTRegInfo *regs = xen_pt_emu_reg_grps[i].emu_regs; -- 2.11.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alexey Gerasimenko Subject: [RFC PATCH 24/30] xen/pt: allow to hide PCIe Extended Capabilities Date: Tue, 13 Mar 2018 04:34:09 +1000 Message-ID: <2bb9523a189c03a8a4da12af11cbc07f597dff57.1520867956.git.x1917x@gmail.com> References: Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from us1-rack-dfw2.inumbo.com ([104.130.134.6]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1evSIp-0008Qp-Fy for xen-devel@lists.xenproject.org; Mon, 12 Mar 2018 18:36:07 +0000 Received: by mail-pl0-x243.google.com with SMTP id 61-v6so9825509plf.3 for ; Mon, 12 Mar 2018 11:36:06 -0700 (PDT) In-Reply-To: In-Reply-To: References: List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: xen-devel@lists.xenproject.org Cc: Anthony Perard , Stefano Stabellini , Alexey Gerasimenko , qemu-devel@nongnu.org List-Id: xen-devel@lists.xenproject.org V2UgbmVlZCB0byBoaWRlIHNvbWUgdW53YW50ZWQgUENJL1BDSWUgY2FwYWJpbGl0aWVzIGZvciBw YXNzZWQgdGhyb3VnaApkZXZpY2VzLgpOb3JtYWxseSB3ZSBkbyB0aGlzIGJ5IG1hcmtpbmcgdGhl IGNhcGFiaWxpdHkgcmVnaXN0ZXIgZ3JvdXAKYXMgWEVOX1BUX0dSUF9UWVBFX0hBUkRXSVJFRCB3 aGljaCBleGNsdWRlIHRoaXMgY2FwYWJpbGl0eSBmcm9tIHRoZQpjYXBhYmlsaXR5IGxpc3QgYW5k IHJldHVybnMgemVyb2VzIG9uIGF0dGVtcHRzIHRvIHJlYWQgY2FwYWJpbGl0eSBib2R5LgpTa2lw cGluZyB0aGUgY2FwYWJpbGl0eSBpbiB0aGUgbGlua2VkIGxpc3Qgb2YgY2FwYWJpbGl0aWVzIGNh biBiZSBkb25lCmJ5IGNoYW5naW5nIE5leHQgQ2FwYWJpbGl0eSByZWdpc3RlciB0byBza2lwIG9u ZSBvciBtYW55IHVud2FudGVkCmNhcGFiaWxpdGllcy4KCk9uZSBkaWZmZXJlbmNlIGJldHdlZW4g UENJIGFuZCBQQ0llIEV4dGVuZGVkIGNhcGFiaWxpdGllcyBpcyB0aGF0IHdlIGRvbid0CmhhdmUg dGhlIGxpc3QgaGVhZCBmaWVsZCBhbnltb3JlLiBQQ0llIEV4dGVuZGVkIGNhcGFiaWxpdGllcyBh bHdheXMgc3RhcnQKYXQgb2Zmc2V0IDB4MTAwIGlmIHRoZXkncmUgcHJlc2VudC4gVW5mb3J0dW5h dGVseSwgdGhlcmUgYXJlIHR5cGljYWxseQpvbmx5IGZldyBQQ0llIGV4dGVuZGVkIGNhcGFiaWxp dGllcyBwcmVzZW50IHdoaWNoIG1lYW5zIHRoZXJlIGlzIGEgY2hhbmNlCnRoYXQgc29tZSBjYXBh YmlsaXR5IHdlIHdhbnQgdG8gaGlkZSB3aWxsIHJlc2lkZSBhdCBvZmZzZXQgMHgxMDAgaW4gUENJ ZQpjb25maWcgc3BhY2UuCgpUaGUgc2ltcGxlc3Qgd2F5IHRvIGhpZGUgc3VjaCBjYXBhYmlsaXRp ZXMgZnJvbSBndWVzdCBPUyBvciBkcml2ZXJzCmlzIGZha2luZyB0aGVpciBjYXBhYmlsaXR5IElE IHZhbHVlLgoKVGhpcyBwYXRjaCBhZGRzIHRoZSBDYXBhYmlsaXR5IElEIHJlZ2lzdGVyIGhhbmRs ZXIgd2hpY2ggY2hlY2tzCi0gaWYgdGhlIGNhcGFiaWxpdHkgdG8gd2hpY2ggdGhpcyByZWdpc3Rl ciBiZWxvbmcgc3RhcnRzIGF0IG9mZnNldCAweDEwMAogIGluIFBDSWUgY29uZmlnIHNwYWNlCi0g aWYgdGhpcyBjYXBhYmlsaXR5IGlzIG1hcmtlZCBhcyBYRU5fUFRfR1JQX1RZUEVfSEFSRFdJUkVE CgpJZiBpdCBpcyB0aGUgY2FzZSwgdGhlbiBhIGZha2UgQ2FwYWJpbGl0eSBJRCB2YWx1ZSBpcyBy ZXR1cm5lZC4KClNpZ25lZC1vZmYtYnk6IEFsZXhleSBHZXJhc2ltZW5rbyA8eDE5MTd4QGdtYWls LmNvbT4KLS0tCiBody94ZW4veGVuX3B0LmMgICAgICAgICAgICAgfCAxMSArKysrKysrLQogaHcv eGVuL3hlbl9wdC5oICAgICAgICAgICAgIHwgIDUgKysrKwogaHcveGVuL3hlbl9wdF9jb25maWdf aW5pdC5jIHwgNjIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKyst CiAzIGZpbGVzIGNoYW5nZWQsIDc2IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCgpkaWZm IC0tZ2l0IGEvaHcveGVuL3hlbl9wdC5jIGIvaHcveGVuL3hlbl9wdC5jCmluZGV4IGJmMDk4YzI2 YjMuLmU2YTE4YWZhODMgMTAwNjQ0Ci0tLSBhL2h3L3hlbi94ZW5fcHQuYworKysgYi9ody94ZW4v eGVuX3B0LmMKQEAgLTE1NCw3ICsxNTQsMTYgQEAgc3RhdGljIHVpbnQzMl90IHhlbl9wdF9wY2lf cmVhZF9jb25maWcoUENJRGV2aWNlICpkLCB1aW50MzJfdCBhZGRyLCBpbnQgbGVuKQogICAgIHJl Z19ncnBfZW50cnkgPSB4ZW5fcHRfZmluZF9yZWdfZ3JwKHMsIGFkZHIpOwogICAgIGlmIChyZWdf Z3JwX2VudHJ5KSB7CiAgICAgICAgIC8qIGNoZWNrIDAtSGFyZHdpcmVkIHJlZ2lzdGVyIGdyb3Vw ICovCi0gICAgICAgIGlmIChyZWdfZ3JwX2VudHJ5LT5yZWdfZ3JwLT5ncnBfdHlwZSA9PSBYRU5f UFRfR1JQX1RZUEVfSEFSRFdJUkVEKSB7CisgICAgICAgIGlmIChyZWdfZ3JwX2VudHJ5LT5yZWdf Z3JwLT5ncnBfdHlwZSA9PSBYRU5fUFRfR1JQX1RZUEVfSEFSRFdJUkVEICYmCisgICAgICAgICAg ICAvKgorICAgICAgICAgICAgICogRm9yIFBDSWUgRXh0ZW5kZWQgQ2FwYWJpbGl0aWVzIHdlIG5l ZWQgdG8gZW11bGF0ZQorICAgICAgICAgICAgICogQ2FwYWJpbGl0eUlEIGFuZCBOZXh0Q2FwYWJp bGl0eS9WZXJzaW9uIHJlZ2lzdGVycyBmb3IgYQorICAgICAgICAgICAgICogaGFyZHdpcmVkIHJl ZyBncm91cCBsb2NhdGVkIGF0IHRoZSBvZmZzZXQgMHgxMDAgaW4gUENJZQorICAgICAgICAgICAg ICogY29uZmlnIHNwYWNlLiBUaGlzIGFsbG93cyB1cyB0byBoaWRlIHRoZSBmaXJzdCBleHRlbmRl ZAorICAgICAgICAgICAgICogY2FwYWJpbGl0eSBhcyB3ZWxsLgorICAgICAgICAgICAgICovCisg ICAgICAgICAgICAhKHJlZ19ncnBfZW50cnktPmJhc2Vfb2Zmc2V0ID09IFBDSV9DT05GSUdfU1BB Q0VfU0laRSAmJgorICAgICAgICAgICAgcmFuZ2VzX292ZXJsYXAoYWRkciwgbGVuLCAweDEwMCwg NCkpKSB7CiAgICAgICAgICAgICAvKiBubyBuZWVkIHRvIGVtdWxhdGUsIGp1c3QgcmV0dXJuIDAg Ki8KICAgICAgICAgICAgIHZhbCA9IDA7CiAgICAgICAgICAgICBnb3RvIGV4aXQ7CmRpZmYgLS1n aXQgYS9ody94ZW4veGVuX3B0LmggYi9ody94ZW4veGVuX3B0LmgKaW5kZXggNTUzMTM0N2FiMi4u YWM0NTI2MTY3OSAxMDA2NDQKLS0tIGEvaHcveGVuL3hlbl9wdC5oCisrKyBiL2h3L3hlbi94ZW5f cHQuaApAQCAtNzgsNiArNzgsMTEgQEAgdHlwZWRlZiBpbnQgKCp4ZW5fcHRfY29uZl9ieXRlX3Jl YWQpCiAKICNkZWZpbmUgWEVOX1BDSV9JTlRFTF9PUFJFR0lPTiAweGZjCiAKKyNkZWZpbmUgWEVO X1BDSUVfQ0FQX0lEICAgICAgICAgICAgIDAKKyNkZWZpbmUgWEVOX1BDSUVfQ0FQX0xJU1RfTkVY VCAgICAgIDIKKworI2RlZmluZSBYRU5fUENJRV9GQUtFX0NBUF9JRF9CQVNFICAgMHhGRTAwCisK IHR5cGVkZWYgZW51bSB7CiAgICAgWEVOX1BUX0dSUF9UWVBFX0hBUkRXSVJFRCA9IDAsICAvKiAw IEhhcmR3aXJlZCByZWcgZ3JvdXAgKi8KICAgICBYRU5fUFRfR1JQX1RZUEVfRU1VLCAgICAgICAg ICAgIC8qIGVtdWwgcmVnIGdyb3VwICovCmRpZmYgLS1naXQgYS9ody94ZW4veGVuX3B0X2NvbmZp Z19pbml0LmMgYi9ody94ZW4veGVuX3B0X2NvbmZpZ19pbml0LmMKaW5kZXggMGNlMmEwMzNmOS4u MTBmM2I2N2QzNSAxMDA2NDQKLS0tIGEvaHcveGVuL3hlbl9wdF9jb25maWdfaW5pdC5jCisrKyBi L2h3L3hlbi94ZW5fcHRfY29uZmlnX2luaXQuYwpAQCAtMzEsNiArMzEsMTAgQEAgc3RhdGljIGlu dCB4ZW5fcHRfZXh0X2NhcF9wdHJfcmVnX2luaXQoWGVuUENJUGFzc3Rocm91Z2hTdGF0ZSAqcywK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFhlblBUUmVnSW5mbyAqcmVn LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdWludDMyX3QgcmVhbF9v ZmZzZXQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1aW50MzJfdCAq ZGF0YSk7CitzdGF0aWMgaW50IHhlbl9wdF9leHRfY2FwX2NhcGlkX3JlZ19pbml0KFhlblBDSVBh c3N0aHJvdWdoU3RhdGUgKnMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFhlblBUUmVnSW5mbyAqcmVnLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB1aW50MzJfdCByZWFsX29mZnNldCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgdWludDMyX3QgKmRhdGEpOwogCiAvKiBoZWxwZXIgKi8KIApAQCAtMTYz MCw2ICsxNjM0LDU2IEBAIHN0YXRpYyBYZW5QVFJlZ0luZm8geGVuX3B0X2VtdV9yZWdfaWdkX29w cmVnaW9uW10gPSB7CiAgICAgfSwKIH07CiAKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioq KioKKyAqIEVtdWxhdGVkIHJlZ2lzdGVycyBmb3IKKyAqIFBDSWUgRXh0ZW5kZWQgQ2FwYWJpbGl0 aWVzCisgKi8KKworc3RhdGljIHVpbnQxNl90IGZha2VfY2FwX2lkID0gWEVOX1BDSUVfRkFLRV9D QVBfSURfQkFTRTsKKworLyogUENJZSBFeHRlbmRlZCBDYXBhYmlsaXR5IElEIHJlZyAqLworc3Rh dGljIGludCB4ZW5fcHRfZXh0X2NhcF9jYXBpZF9yZWdfaW5pdChYZW5QQ0lQYXNzdGhyb3VnaFN0 YXRlICpzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBYZW5QVFJl Z0luZm8gKnJlZywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdWlu dDMyX3QgcmVhbF9vZmZzZXQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHVpbnQzMl90ICpkYXRhKQoreworICAgIHVpbnQxNl90IHJlZ19maWVsZDsKKyAgICBpbnQg cmM7CisgICAgWGVuUFRSZWdHcm91cCAqcmVnX2dycF9lbnRyeSA9IE5VTEw7CisKKyAgICAvKiB1 c2UgcmVhbCBkZXZpY2UgcmVnaXN0ZXIncyB2YWx1ZSBhcyBpbml0aWFsIHZhbHVlICovCisgICAg cmMgPSB4ZW5faG9zdF9wY2lfZ2V0X3dvcmQoJnMtPnJlYWxfZGV2aWNlLCByZWFsX29mZnNldCwg JnJlZ19maWVsZCk7CisgICAgaWYgKHJjKSB7CisgICAgICAgIHJldHVybiByYzsKKyAgICB9CisK KyAgICByZWdfZ3JwX2VudHJ5ID0geGVuX3B0X2ZpbmRfcmVnX2dycChzLCByZWFsX29mZnNldCk7 CisKKyAgICBpZiAocmVnX2dycF9lbnRyeSkgeworICAgICAgICBpZiAocmVnX2dycF9lbnRyeS0+ cmVnX2dycC0+Z3JwX3R5cGUgPT0gWEVOX1BUX0dSUF9UWVBFX0hBUkRXSVJFRCAmJgorICAgICAg ICAgICAgcmVnX2dycF9lbnRyeS0+YmFzZV9vZmZzZXQgPT0gUENJX0NPTkZJR19TUEFDRV9TSVpF KSB7CisgICAgICAgICAgICAvKgorICAgICAgICAgICAgICogVGhpcyBpcyB0aGUgc2l0dWF0aW9u IHdoZW4gd2Ugd2VyZSBhc2tlZCB0byBoaWRlIChha2EKKyAgICAgICAgICAgICAqICJoYXJkd2ly ZSB0byAwIikgc29tZSBQQ0llIGV4dCBjYXBhYmlsaXR5LCBidXQgaXQgd2FzIGxvY2F0ZWQKKyAg ICAgICAgICAgICAqIGF0IG9mZnNldCAweDEwMCBpbiBQQ0llIGNvbmZpZyBzcGFjZS4gSW4gdGhp cyBjYXNlIHdlIGNhbid0CisgICAgICAgICAgICAgKiBzaW1wbHkgZXhjbHVkZSBpdCBmcm9tIHRo ZSBsaW5rZWQgbGlzdCBvZiBjYXBhYmlsaXRpZXMKKyAgICAgICAgICAgICAqIChhcyBpdCBpcyB0 aGUgZmlyc3QgZW50cnkgaW4gdGhlIGxpc3QpLCBzbyB3ZSBtdXN0IGZha2UgaXRzCisgICAgICAg ICAgICAgKiBDYXBhYmlsaXR5IElEIGluIFBDSWUgRXh0ZW5kZWQgQ2FwYWJpbGl0eSBoZWFkZXIs IGxlYXZpbmcKKyAgICAgICAgICAgICAqIHRoZSBOZXh0IFB0ciBmaWVsZCBpbnRhY3Qgd2hpbGUg cmV0dXJuaW5nIHplcm9lcyBvbiBhdHRlbXB0cworICAgICAgICAgICAgICogdG8gcmVhZCBjYXBh YmlsaXR5IGJvZHkgKHdyaXRlcyBhcmUgaWdub3JlZCkuCisgICAgICAgICAgICAgKi8KKyAgICAg ICAgICAgIHJlZ19maWVsZCA9IGZha2VfY2FwX2lkOworICAgICAgICAgICAgLyogaW5jcmVtZW50 IHRoZSB2YWx1ZSBpbiBvcmRlciB0byBoYXZlIHVuaXF1ZSBDYXBhYmlsaXR5IElEcyAqLworICAg ICAgICAgICAgZmFrZV9jYXBfaWQrKzsKKyAgICAgICAgfQorICAgIH0KKworICAgICpkYXRhID0g cmVnX2ZpZWxkOworICAgIHJldHVybiAwOworfQorCisKIC8qKioqKioqKioqKioqKioqKioqKioq KioqKioqCiAgKiBDYXBhYmlsaXRpZXMKICAqLwpAQCAtMjE3Myw3ICsyMjI3LDEzIEBAIHZvaWQg eGVuX3B0X2NvbmZpZ19pbml0KFhlblBDSVBhc3N0aHJvdWdoU3RhdGUgKnMsIEVycm9yICoqZXJy cCkKICAgICAgICAgICAgIH0KICAgICAgICAgfQogCi0gICAgICAgIGlmICh4ZW5fcHRfZW11X3Jl Z19ncnBzW2ldLmdycF90eXBlID09IFhFTl9QVF9HUlBfVFlQRV9FTVUpIHsKKyAgICAgICAgaWYg KHhlbl9wdF9lbXVfcmVnX2dycHNbaV0uZ3JwX3R5cGUgPT0gWEVOX1BUX0dSUF9UWVBFX0VNVSB8 fAorICAgICAgICAgICAgLyoKKyAgICAgICAgICAgICAqIFdlIG5lZWQgdG8gYWx3YXlzIGVtdWxh dGUgdGhlIFBDSWUgRXh0ZW5kZWQgQ2FwYWJpbGl0eQorICAgICAgICAgICAgICogaGVhZGVyIGZv ciBhIGhpZGRlbiBjYXBhYmlsaXR5IHdoaWNoIHN0YXJ0cyBhdCBvZmZzZXQgMHgxMDAKKyAgICAg ICAgICAgICAqLworICAgICAgICAgICAgKHhlbl9wdF9lbXVfcmVnX2dycHNbaV0uZ3JwX3R5cGUg PT0gWEVOX1BUX0dSUF9UWVBFX0hBUkRXSVJFRCAmJgorICAgICAgICAgICAgcmVnX2dycF9vZmZz ZXQgPT0gMHgxMDApKSB7CiAgICAgICAgICAgICBpZiAoeGVuX3B0X2VtdV9yZWdfZ3Jwc1tpXS5l bXVfcmVncykgewogICAgICAgICAgICAgICAgIGludCBqID0gMDsKICAgICAgICAgICAgICAgICBY ZW5QVFJlZ0luZm8gKnJlZ3MgPSB4ZW5fcHRfZW11X3JlZ19ncnBzW2ldLmVtdV9yZWdzOwotLSAK Mi4xMS4wCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K WGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKaHR0 cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hlbi1kZXZlbA==