From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:44669) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1evSIX-0008EB-6e for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:35:50 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1evSIV-0005R1-J4 for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:35:49 -0400 Received: from mail-pl0-x241.google.com ([2607:f8b0:400e:c01::241]:38208) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1evSIV-0005Qd-BE for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:35:47 -0400 Received: by mail-pl0-x241.google.com with SMTP id m22-v6so9835858pls.5 for ; Mon, 12 Mar 2018 11:35:47 -0700 (PDT) From: Alexey Gerasimenko Date: Tue, 13 Mar 2018 04:34:04 +1000 Message-Id: <836d7504943af1390458dc2bc8341a654eee234a.1520867956.git.x1917x@gmail.com> In-Reply-To: References: In-Reply-To: References: Subject: [Qemu-devel] [RFC PATCH 19/30] xen/pt: avoid reading PCIe device type and cap version multiple times 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 xen_pt_config_init.c reads Device/Port Type and Capability version fields in many places. Two functions are used for this purpose: get_capability_version and get_device_type. These functions perform PCI conf space reading every time they're called. Another bad thing is that these functions know nothing about where PCI Expess Capability is located, so its offset must be provided explicitly in function arguments. Their typical usage is like this: uint8_t cap_ver = get_capability_version(s, real_offset - reg->offset); uint8_t dev_type = get_device_type(s, real_offset - reg->offset); To avoid this, the PCI Express Capability register now being read only once and stored in XenHostPCIDevice structure (pcie_flags field). The capabiliy offset parameter is no longer needed, simplifying functions usage. Also, get_device_type and get_capability_version were renamed to more descriptive get_pcie_device_type and get_pcie_capability_version. Signed-off-by: Alexey Gerasimenko --- hw/xen/xen-host-pci-device.c | 15 +++++++++++++++ hw/xen/xen-host-pci-device.h | 1 + hw/xen/xen_pt_config_init.c | 34 ++++++++++++++-------------------- 3 files changed, 30 insertions(+), 20 deletions(-) diff --git a/hw/xen/xen-host-pci-device.c b/hw/xen/xen-host-pci-device.c index 9d76b199af..11e9e26d31 100644 --- a/hw/xen/xen-host-pci-device.c +++ b/hw/xen/xen-host-pci-device.c @@ -402,6 +402,7 @@ void xen_host_pci_device_get(XenHostPCIDevice *d, uint16_t domain, { unsigned int v; Error *err = NULL; + int pcie_cap_pos; d->config_fd = -1; d->domain = domain; @@ -446,6 +447,20 @@ void xen_host_pci_device_get(XenHostPCIDevice *d, uint16_t domain, d->is_virtfn = xen_host_pci_dev_is_virtfn(d); d->has_pcie_ext_caps = xen_host_pci_dev_has_pcie_ext_caps(d); + /* read and store PCIe Capabilities field for later use */ + pcie_cap_pos = xen_host_pci_find_next_cap(d, 0, PCI_CAP_ID_EXP); + + if (pcie_cap_pos) { + if (xen_host_pci_get_word(d, pcie_cap_pos + PCI_EXP_FLAGS, + &d->pcie_flags)) { + error_setg(&err, "Unable to read from PCI Express capability " + "structure at 0x%x", pcie_cap_pos); + goto error; + } + } else { + d->pcie_flags = 0xFFFF; + } + return; error: diff --git a/hw/xen/xen-host-pci-device.h b/hw/xen/xen-host-pci-device.h index 37c5614a24..2884c4b4b9 100644 --- a/hw/xen/xen-host-pci-device.h +++ b/hw/xen/xen-host-pci-device.h @@ -27,6 +27,7 @@ typedef struct XenHostPCIDevice { uint16_t device_id; uint32_t class_code; int irq; + uint16_t pcie_flags; XenHostPCIIORegion io_regions[PCI_NUM_REGIONS - 1]; XenHostPCIIORegion rom; diff --git a/hw/xen/xen_pt_config_init.c b/hw/xen/xen_pt_config_init.c index a3ce33e78b..02e8c97f3c 100644 --- a/hw/xen/xen_pt_config_init.c +++ b/hw/xen/xen_pt_config_init.c @@ -828,24 +828,18 @@ static XenPTRegInfo xen_pt_emu_reg_vendor[] = { * PCI Express Capability */ -static inline uint8_t get_capability_version(XenPCIPassthroughState *s, - uint32_t offset) +static inline uint8_t get_pcie_capability_version(XenPCIPassthroughState *s) { - uint8_t flag; - if (xen_host_pci_get_byte(&s->real_device, offset + PCI_EXP_FLAGS, &flag)) { - return 0; - } - return flag & PCI_EXP_FLAGS_VERS; + assert(s->real_device.pcie_flags != 0xFFFF); + + return (uint8_t) (s->real_device.pcie_flags & PCI_EXP_FLAGS_VERS); } -static inline uint8_t get_device_type(XenPCIPassthroughState *s, - uint32_t offset) +static inline uint8_t get_pcie_device_type(XenPCIPassthroughState *s) { - uint8_t flag; - if (xen_host_pci_get_byte(&s->real_device, offset + PCI_EXP_FLAGS, &flag)) { - return 0; - } - return (flag & PCI_EXP_FLAGS_TYPE) >> 4; + assert(s->real_device.pcie_flags != 0xFFFF); + + return (uint8_t) ((s->real_device.pcie_flags & PCI_EXP_FLAGS_TYPE) >> 4); } /* initialize Link Control register */ @@ -853,8 +847,8 @@ static int xen_pt_linkctrl_reg_init(XenPCIPassthroughState *s, XenPTRegInfo *reg, uint32_t real_offset, uint32_t *data) { - uint8_t cap_ver = get_capability_version(s, real_offset - reg->offset); - uint8_t dev_type = get_device_type(s, real_offset - reg->offset); + uint8_t cap_ver = get_pcie_capability_version(s); + uint8_t dev_type = get_pcie_device_type(s); /* no need to initialize in case of Root Complex Integrated Endpoint * with cap_ver 1.x @@ -871,7 +865,7 @@ static int xen_pt_devctrl2_reg_init(XenPCIPassthroughState *s, XenPTRegInfo *reg, uint32_t real_offset, uint32_t *data) { - uint8_t cap_ver = get_capability_version(s, real_offset - reg->offset); + uint8_t cap_ver = get_pcie_capability_version(s); /* no need to initialize in case of cap_ver 1.x */ if (cap_ver == 1) { @@ -886,7 +880,7 @@ static int xen_pt_linkctrl2_reg_init(XenPCIPassthroughState *s, XenPTRegInfo *reg, uint32_t real_offset, uint32_t *data) { - uint8_t cap_ver = get_capability_version(s, real_offset - reg->offset); + uint8_t cap_ver = get_pcie_capability_version(s); uint32_t reg_field = 0; /* no need to initialize in case of cap_ver 1.x */ @@ -1586,8 +1580,8 @@ static int xen_pt_pcie_size_init(XenPCIPassthroughState *s, uint32_t base_offset, uint8_t *size) { PCIDevice *d = &s->dev; - uint8_t version = get_capability_version(s, base_offset); - uint8_t type = get_device_type(s, base_offset); + uint8_t version = get_pcie_capability_version(s); + uint8_t type = get_pcie_device_type(s); uint8_t pcie_size = 0; -- 2.11.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alexey Gerasimenko Subject: [RFC PATCH 19/30] xen/pt: avoid reading PCIe device type and cap version multiple times Date: Tue, 13 Mar 2018 04:34:04 +1000 Message-ID: <836d7504943af1390458dc2bc8341a654eee234a.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 1evSIW-00082O-4p for xen-devel@lists.xenproject.org; Mon, 12 Mar 2018 18:35:48 +0000 Received: by mail-pl0-x242.google.com with SMTP id 61-v6so9824970plf.3 for ; Mon, 12 Mar 2018 11:35:47 -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 eGVuX3B0X2NvbmZpZ19pbml0LmMgcmVhZHMgRGV2aWNlL1BvcnQgVHlwZSBhbmQgQ2FwYWJpbGl0 eSB2ZXJzaW9uIGZpZWxkcwppbiBtYW55IHBsYWNlcy4gVHdvIGZ1bmN0aW9ucyBhcmUgdXNlZCBm b3IgdGhpcyBwdXJwb3NlOgpnZXRfY2FwYWJpbGl0eV92ZXJzaW9uIGFuZCBnZXRfZGV2aWNlX3R5 cGUuIFRoZXNlIGZ1bmN0aW9ucyBwZXJmb3JtIFBDSQpjb25mIHNwYWNlIHJlYWRpbmcgZXZlcnkg dGltZSB0aGV5J3JlIGNhbGxlZC4gQW5vdGhlciBiYWQgdGhpbmcgaXMgdGhhdAp0aGVzZSBmdW5j dGlvbnMga25vdyBub3RoaW5nIGFib3V0IHdoZXJlIFBDSSBFeHBlc3MgQ2FwYWJpbGl0eSBpcyBs b2NhdGVkLApzbyBpdHMgb2Zmc2V0IG11c3QgYmUgcHJvdmlkZWQgZXhwbGljaXRseSBpbiBmdW5j dGlvbiBhcmd1bWVudHMuIFRoZWlyCnR5cGljYWwgdXNhZ2UgaXMgbGlrZSB0aGlzOgogICAgdWlu dDhfdCBjYXBfdmVyID0gZ2V0X2NhcGFiaWxpdHlfdmVyc2lvbihzLCByZWFsX29mZnNldCAtIHJl Zy0+b2Zmc2V0KTsKICAgIHVpbnQ4X3QgZGV2X3R5cGUgPSBnZXRfZGV2aWNlX3R5cGUocywgcmVh bF9vZmZzZXQgLSByZWctPm9mZnNldCk7CgpUbyBhdm9pZCB0aGlzLCB0aGUgUENJIEV4cHJlc3Mg Q2FwYWJpbGl0eSByZWdpc3RlciBub3cgYmVpbmcgcmVhZCBvbmx5Cm9uY2UgYW5kIHN0b3JlZCBp biAgWGVuSG9zdFBDSURldmljZSBzdHJ1Y3R1cmUgKHBjaWVfZmxhZ3MgZmllbGQpLiBUaGUKY2Fw YWJpbGl5IG9mZnNldCBwYXJhbWV0ZXIgaXMgbm8gbG9uZ2VyIG5lZWRlZCwgc2ltcGxpZnlpbmcg ZnVuY3Rpb25zCnVzYWdlLiBBbHNvLCBnZXRfZGV2aWNlX3R5cGUgYW5kIGdldF9jYXBhYmlsaXR5 X3ZlcnNpb24gd2VyZSByZW5hbWVkCnRvIG1vcmUgZGVzY3JpcHRpdmUgZ2V0X3BjaWVfZGV2aWNl X3R5cGUgYW5kIGdldF9wY2llX2NhcGFiaWxpdHlfdmVyc2lvbi4KClNpZ25lZC1vZmYtYnk6IEFs ZXhleSBHZXJhc2ltZW5rbyA8eDE5MTd4QGdtYWlsLmNvbT4KLS0tCiBody94ZW4veGVuLWhvc3Qt cGNpLWRldmljZS5jIHwgMTUgKysrKysrKysrKysrKysrCiBody94ZW4veGVuLWhvc3QtcGNpLWRl dmljZS5oIHwgIDEgKwogaHcveGVuL3hlbl9wdF9jb25maWdfaW5pdC5jICB8IDM0ICsrKysrKysr KysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0KIDMgZmlsZXMgY2hhbmdlZCwgMzAgaW5zZXJ0aW9u cygrKSwgMjAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvaHcveGVuL3hlbi1ob3N0LXBjaS1k ZXZpY2UuYyBiL2h3L3hlbi94ZW4taG9zdC1wY2ktZGV2aWNlLmMKaW5kZXggOWQ3NmIxOTlhZi4u MTFlOWUyNmQzMSAxMDA2NDQKLS0tIGEvaHcveGVuL3hlbi1ob3N0LXBjaS1kZXZpY2UuYworKysg Yi9ody94ZW4veGVuLWhvc3QtcGNpLWRldmljZS5jCkBAIC00MDIsNiArNDAyLDcgQEAgdm9pZCB4 ZW5faG9zdF9wY2lfZGV2aWNlX2dldChYZW5Ib3N0UENJRGV2aWNlICpkLCB1aW50MTZfdCBkb21h aW4sCiB7CiAgICAgdW5zaWduZWQgaW50IHY7CiAgICAgRXJyb3IgKmVyciA9IE5VTEw7CisgICAg aW50IHBjaWVfY2FwX3BvczsKIAogICAgIGQtPmNvbmZpZ19mZCA9IC0xOwogICAgIGQtPmRvbWFp biA9IGRvbWFpbjsKQEAgLTQ0Niw2ICs0NDcsMjAgQEAgdm9pZCB4ZW5faG9zdF9wY2lfZGV2aWNl X2dldChYZW5Ib3N0UENJRGV2aWNlICpkLCB1aW50MTZfdCBkb21haW4sCiAgICAgZC0+aXNfdmly dGZuICAgICAgICAgPSB4ZW5faG9zdF9wY2lfZGV2X2lzX3ZpcnRmbihkKTsKICAgICBkLT5oYXNf cGNpZV9leHRfY2FwcyA9IHhlbl9ob3N0X3BjaV9kZXZfaGFzX3BjaWVfZXh0X2NhcHMoZCk7CiAK KyAgICAvKiByZWFkIGFuZCBzdG9yZSBQQ0llIENhcGFiaWxpdGllcyBmaWVsZCBmb3IgbGF0ZXIg dXNlICovCisgICAgcGNpZV9jYXBfcG9zID0geGVuX2hvc3RfcGNpX2ZpbmRfbmV4dF9jYXAoZCwg MCwgUENJX0NBUF9JRF9FWFApOworCisgICAgaWYgKHBjaWVfY2FwX3BvcykgeworICAgICAgICBp ZiAoeGVuX2hvc3RfcGNpX2dldF93b3JkKGQsIHBjaWVfY2FwX3BvcyArIFBDSV9FWFBfRkxBR1Ms CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJmQtPnBjaWVfZmxhZ3MpKSB7Cisg ICAgICAgICAgICBlcnJvcl9zZXRnKCZlcnIsICJVbmFibGUgdG8gcmVhZCBmcm9tIFBDSSBFeHBy ZXNzIGNhcGFiaWxpdHkgIgorICAgICAgICAgICAgICAgICAgICAgICAic3RydWN0dXJlIGF0IDB4 JXgiLCBwY2llX2NhcF9wb3MpOworICAgICAgICAgICAgZ290byBlcnJvcjsKKyAgICAgICAgfQor ICAgIH0gZWxzZSB7CisgICAgICAgIGQtPnBjaWVfZmxhZ3MgPSAweEZGRkY7CisgICAgfQorCiAg ICAgcmV0dXJuOwogCiBlcnJvcjoKZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW4taG9zdC1wY2ktZGV2 aWNlLmggYi9ody94ZW4veGVuLWhvc3QtcGNpLWRldmljZS5oCmluZGV4IDM3YzU2MTRhMjQuLjI4 ODRjNGI0YjkgMTAwNjQ0Ci0tLSBhL2h3L3hlbi94ZW4taG9zdC1wY2ktZGV2aWNlLmgKKysrIGIv aHcveGVuL3hlbi1ob3N0LXBjaS1kZXZpY2UuaApAQCAtMjcsNiArMjcsNyBAQCB0eXBlZGVmIHN0 cnVjdCBYZW5Ib3N0UENJRGV2aWNlIHsKICAgICB1aW50MTZfdCBkZXZpY2VfaWQ7CiAgICAgdWlu dDMyX3QgY2xhc3NfY29kZTsKICAgICBpbnQgaXJxOworICAgIHVpbnQxNl90IHBjaWVfZmxhZ3M7 CiAKICAgICBYZW5Ib3N0UENJSU9SZWdpb24gaW9fcmVnaW9uc1tQQ0lfTlVNX1JFR0lPTlMgLSAx XTsKICAgICBYZW5Ib3N0UENJSU9SZWdpb24gcm9tOwpkaWZmIC0tZ2l0IGEvaHcveGVuL3hlbl9w dF9jb25maWdfaW5pdC5jIGIvaHcveGVuL3hlbl9wdF9jb25maWdfaW5pdC5jCmluZGV4IGEzY2Uz M2U3OGIuLjAyZThjOTdmM2MgMTAwNjQ0Ci0tLSBhL2h3L3hlbi94ZW5fcHRfY29uZmlnX2luaXQu YworKysgYi9ody94ZW4veGVuX3B0X2NvbmZpZ19pbml0LmMKQEAgLTgyOCwyNCArODI4LDE4IEBA IHN0YXRpYyBYZW5QVFJlZ0luZm8geGVuX3B0X2VtdV9yZWdfdmVuZG9yW10gPSB7CiAgKiBQQ0kg RXhwcmVzcyBDYXBhYmlsaXR5CiAgKi8KIAotc3RhdGljIGlubGluZSB1aW50OF90IGdldF9jYXBh YmlsaXR5X3ZlcnNpb24oWGVuUENJUGFzc3Rocm91Z2hTdGF0ZSAqcywKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVpbnQzMl90IG9mZnNldCkKK3N0YXRpYyBp bmxpbmUgdWludDhfdCBnZXRfcGNpZV9jYXBhYmlsaXR5X3ZlcnNpb24oWGVuUENJUGFzc3Rocm91 Z2hTdGF0ZSAqcykKIHsKLSAgICB1aW50OF90IGZsYWc7Ci0gICAgaWYgKHhlbl9ob3N0X3BjaV9n ZXRfYnl0ZSgmcy0+cmVhbF9kZXZpY2UsIG9mZnNldCArIFBDSV9FWFBfRkxBR1MsICZmbGFnKSkg ewotICAgICAgICByZXR1cm4gMDsKLSAgICB9Ci0gICAgcmV0dXJuIGZsYWcgJiBQQ0lfRVhQX0ZM QUdTX1ZFUlM7CisgICAgYXNzZXJ0KHMtPnJlYWxfZGV2aWNlLnBjaWVfZmxhZ3MgIT0gMHhGRkZG KTsKKworICAgIHJldHVybiAodWludDhfdCkgKHMtPnJlYWxfZGV2aWNlLnBjaWVfZmxhZ3MgJiBQ Q0lfRVhQX0ZMQUdTX1ZFUlMpOwogfQogCi1zdGF0aWMgaW5saW5lIHVpbnQ4X3QgZ2V0X2Rldmlj ZV90eXBlKFhlblBDSVBhc3N0aHJvdWdoU3RhdGUgKnMsCi0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHVpbnQzMl90IG9mZnNldCkKK3N0YXRpYyBpbmxpbmUgdWludDhfdCBn ZXRfcGNpZV9kZXZpY2VfdHlwZShYZW5QQ0lQYXNzdGhyb3VnaFN0YXRlICpzKQogewotICAgIHVp bnQ4X3QgZmxhZzsKLSAgICBpZiAoeGVuX2hvc3RfcGNpX2dldF9ieXRlKCZzLT5yZWFsX2Rldmlj ZSwgb2Zmc2V0ICsgUENJX0VYUF9GTEFHUywgJmZsYWcpKSB7Ci0gICAgICAgIHJldHVybiAwOwot ICAgIH0KLSAgICByZXR1cm4gKGZsYWcgJiBQQ0lfRVhQX0ZMQUdTX1RZUEUpID4+IDQ7CisgICAg YXNzZXJ0KHMtPnJlYWxfZGV2aWNlLnBjaWVfZmxhZ3MgIT0gMHhGRkZGKTsKKworICAgIHJldHVy biAodWludDhfdCkgKChzLT5yZWFsX2RldmljZS5wY2llX2ZsYWdzICYgUENJX0VYUF9GTEFHU19U WVBFKSA+PiA0KTsKIH0KIAogLyogaW5pdGlhbGl6ZSBMaW5rIENvbnRyb2wgcmVnaXN0ZXIgKi8K QEAgLTg1Myw4ICs4NDcsOCBAQCBzdGF0aWMgaW50IHhlbl9wdF9saW5rY3RybF9yZWdfaW5pdChY ZW5QQ0lQYXNzdGhyb3VnaFN0YXRlICpzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgWGVuUFRSZWdJbmZvICpyZWcsIHVpbnQzMl90IHJlYWxfb2Zmc2V0LAogICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgdWludDMyX3QgKmRhdGEpCiB7Ci0gICAgdWludDhf dCBjYXBfdmVyID0gZ2V0X2NhcGFiaWxpdHlfdmVyc2lvbihzLCByZWFsX29mZnNldCAtIHJlZy0+ b2Zmc2V0KTsKLSAgICB1aW50OF90IGRldl90eXBlID0gZ2V0X2RldmljZV90eXBlKHMsIHJlYWxf b2Zmc2V0IC0gcmVnLT5vZmZzZXQpOworICAgIHVpbnQ4X3QgY2FwX3ZlciAgPSBnZXRfcGNpZV9j YXBhYmlsaXR5X3ZlcnNpb24ocyk7CisgICAgdWludDhfdCBkZXZfdHlwZSA9IGdldF9wY2llX2Rl dmljZV90eXBlKHMpOwogCiAgICAgLyogbm8gbmVlZCB0byBpbml0aWFsaXplIGluIGNhc2Ugb2Yg Um9vdCBDb21wbGV4IEludGVncmF0ZWQgRW5kcG9pbnQKICAgICAgKiB3aXRoIGNhcF92ZXIgMS54 CkBAIC04NzEsNyArODY1LDcgQEAgc3RhdGljIGludCB4ZW5fcHRfZGV2Y3RybDJfcmVnX2luaXQo WGVuUENJUGFzc3Rocm91Z2hTdGF0ZSAqcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFhlblBUUmVnSW5mbyAqcmVnLCB1aW50MzJfdCByZWFsX29mZnNldCwKICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVpbnQzMl90ICpkYXRhKQogewotICAgIHVpbnQ4 X3QgY2FwX3ZlciA9IGdldF9jYXBhYmlsaXR5X3ZlcnNpb24ocywgcmVhbF9vZmZzZXQgLSByZWct Pm9mZnNldCk7CisgICAgdWludDhfdCBjYXBfdmVyID0gZ2V0X3BjaWVfY2FwYWJpbGl0eV92ZXJz aW9uKHMpOwogCiAgICAgLyogbm8gbmVlZCB0byBpbml0aWFsaXplIGluIGNhc2Ugb2YgY2FwX3Zl ciAxLnggKi8KICAgICBpZiAoY2FwX3ZlciA9PSAxKSB7CkBAIC04ODYsNyArODgwLDcgQEAgc3Rh dGljIGludCB4ZW5fcHRfbGlua2N0cmwyX3JlZ19pbml0KFhlblBDSVBhc3N0aHJvdWdoU3RhdGUg KnMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgWGVuUFRSZWdJbmZvICpy ZWcsIHVpbnQzMl90IHJlYWxfb2Zmc2V0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHVpbnQzMl90ICpkYXRhKQogewotICAgIHVpbnQ4X3QgY2FwX3ZlciA9IGdldF9jYXBh YmlsaXR5X3ZlcnNpb24ocywgcmVhbF9vZmZzZXQgLSByZWctPm9mZnNldCk7CisgICAgdWludDhf dCBjYXBfdmVyID0gZ2V0X3BjaWVfY2FwYWJpbGl0eV92ZXJzaW9uKHMpOwogICAgIHVpbnQzMl90 IHJlZ19maWVsZCA9IDA7CiAKICAgICAvKiBubyBuZWVkIHRvIGluaXRpYWxpemUgaW4gY2FzZSBv ZiBjYXBfdmVyIDEueCAqLwpAQCAtMTU4Niw4ICsxNTgwLDggQEAgc3RhdGljIGludCB4ZW5fcHRf cGNpZV9zaXplX2luaXQoWGVuUENJUGFzc3Rocm91Z2hTdGF0ZSAqcywKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHVpbnQzMl90IGJhc2Vfb2Zmc2V0LCB1aW50OF90ICpzaXplKQog ewogICAgIFBDSURldmljZSAqZCA9ICZzLT5kZXY7Ci0gICAgdWludDhfdCB2ZXJzaW9uID0gZ2V0 X2NhcGFiaWxpdHlfdmVyc2lvbihzLCBiYXNlX29mZnNldCk7Ci0gICAgdWludDhfdCB0eXBlID0g Z2V0X2RldmljZV90eXBlKHMsIGJhc2Vfb2Zmc2V0KTsKKyAgICB1aW50OF90IHZlcnNpb24gPSBn ZXRfcGNpZV9jYXBhYmlsaXR5X3ZlcnNpb24ocyk7CisgICAgdWludDhfdCB0eXBlID0gZ2V0X3Bj aWVfZGV2aWNlX3R5cGUocyk7CiAgICAgdWludDhfdCBwY2llX3NpemUgPSAwOwogCiAKLS0gCjIu MTEuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhl bi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCmh0dHBz Oi8vbGlzdHMueGVucHJvamVjdC5vcmcvbWFpbG1hbi9saXN0aW5mby94ZW4tZGV2ZWw=