From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:36184) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1fECjF-0001Sl-8X for qemu-devel@nongnu.org; Thu, 03 May 2018 07:48:54 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1fECjA-00038N-SG for qemu-devel@nongnu.org; Thu, 03 May 2018 07:48:53 -0400 Received: from mx3-rdu2.redhat.com ([66.187.233.73]:58760 helo=mx1.redhat.com) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1fECjA-00037j-IF for qemu-devel@nongnu.org; Thu, 03 May 2018 07:48:48 -0400 References: <1525346320-24553-1-git-send-email-paul.durrant@citrix.com> From: Paolo Bonzini Message-ID: <1b7ac8b6-df19-c6e2-bc6d-587c60e20207@redhat.com> Date: Thu, 3 May 2018 13:48:43 +0200 MIME-Version: 1.0 In-Reply-To: <1525346320-24553-1-git-send-email-paul.durrant@citrix.com> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 7bit Subject: Re: [Qemu-devel] [PATCH] xen-hvm: stop faking I/O to access PCI config space List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Paul Durrant , xen-devel@lists.xenproject.org, qemu-devel@nongnu.org Cc: Stefano Stabellini , Anthony Perard , "Michael S. Tsirkin" , Marcel Apfelbaum , Richard Henderson , Eduardo Habkost On 03/05/2018 13:18, Paul Durrant wrote: > This patch removes the current hackery where IOREQ_TYPE_PCI_CONFIG > reqyests are handled by faking PIO to 0xcf8 and 0xcfc and replaces it > with direct calls to pci_host_config_read/write_common(). > Doing so necessitates mapping BDFs to PCIDevices but maintaining a simple > QLIST in xen_device_realize/unrealize() will suffice. No objection! Thanks, Paolo > NOTE: whilst config space accesses are currently limited to > PCI_CONFIG_SPACE_SIZE, this patch paves the way to increasing the > limit to PCIE_CONFIG_SPACE_SIZE when Xen gains the ability to > emulate MCFG table accesses. > > Signed-off-by: Paul Durrant > -- > Cc: Stefano Stabellini > Cc: Anthony Perard > Cc: "Michael S. Tsirkin" > Cc: Marcel Apfelbaum > Cc: Paolo Bonzini > Cc: Richard Henderson > Cc: Eduardo Habkost > --- > hw/i386/xen/trace-events | 2 + > hw/i386/xen/xen-hvm.c | 101 +++++++++++++++++++++++++++++++++++++---------- > 2 files changed, 83 insertions(+), 20 deletions(-) > > diff --git a/hw/i386/xen/trace-events b/hw/i386/xen/trace-events > index 8dab7bc..f576f1b 100644 > --- a/hw/i386/xen/trace-events > +++ b/hw/i386/xen/trace-events > @@ -15,6 +15,8 @@ cpu_ioreq_pio(void *req, uint32_t dir, uint32_t df, uint32_t data_is_ptr, uint64 > cpu_ioreq_pio_read_reg(void *req, uint64_t data, uint64_t addr, uint32_t size) "I/O=%p pio read reg data=0x%"PRIx64" port=0x%"PRIx64" size=%d" > cpu_ioreq_pio_write_reg(void *req, uint64_t data, uint64_t addr, uint32_t size) "I/O=%p pio write reg data=0x%"PRIx64" port=0x%"PRIx64" size=%d" > cpu_ioreq_move(void *req, uint32_t dir, uint32_t df, uint32_t data_is_ptr, uint64_t addr, uint64_t data, uint32_t count, uint32_t size) "I/O=%p copy dir=%d df=%d ptr=%d port=0x%"PRIx64" data=0x%"PRIx64" count=%d size=%d" > +cpu_ioreq_config_read(void *req, uint32_t sbdf, uint32_t reg, uint32_t size, uint32_t data) "I/O=%p sbdf=0x%x reg=%u size=%u data=0x%x" > +cpu_ioreq_config_write(void *req, uint32_t sbdf, uint32_t reg, uint32_t size, uint32_t data) "I/O=%p sbdf=0x%x reg=%u size=%u data=0x%x" > > # xen-mapcache.c > xen_map_cache(uint64_t phys_addr) "want 0x%"PRIx64 > diff --git a/hw/i386/xen/xen-hvm.c b/hw/i386/xen/xen-hvm.c > index caa563b..c139d29 100644 > --- a/hw/i386/xen/xen-hvm.c > +++ b/hw/i386/xen/xen-hvm.c > @@ -12,6 +12,7 @@ > > #include "cpu.h" > #include "hw/pci/pci.h" > +#include "hw/pci/pci_host.h" > #include "hw/i386/pc.h" > #include "hw/i386/apic-msidef.h" > #include "hw/xen/xen_common.h" > @@ -86,6 +87,12 @@ typedef struct XenPhysmap { > QLIST_ENTRY(XenPhysmap) list; > } XenPhysmap; > > +typedef struct XenPciDevice { > + PCIDevice *pci_dev; > + uint32_t sbdf; > + QLIST_ENTRY(XenPciDevice) entry; > +} XenPciDevice; > + > typedef struct XenIOState { > ioservid_t ioservid; > shared_iopage_t *shared_page; > @@ -105,6 +112,7 @@ typedef struct XenIOState { > struct xs_handle *xenstore; > MemoryListener memory_listener; > MemoryListener io_listener; > + QLIST_HEAD(, XenPciDevice) dev_list; > DeviceListener device_listener; > QLIST_HEAD(, XenPhysmap) physmap; > hwaddr free_phys_offset; > @@ -569,6 +577,12 @@ static void xen_device_realize(DeviceListener *listener, > > if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) { > PCIDevice *pci_dev = PCI_DEVICE(dev); > + XenPciDevice *xendev = g_new(XenPciDevice, 1); > + > + xendev->pci_dev = pci_dev; > + xendev->sbdf = PCI_BUILD_BDF(pci_dev_bus_num(pci_dev), > + pci_dev->devfn); > + QLIST_INSERT_HEAD(&state->dev_list, xendev, entry); > > xen_map_pcidev(xen_domid, state->ioservid, pci_dev); > } > @@ -581,8 +595,17 @@ static void xen_device_unrealize(DeviceListener *listener, > > if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) { > PCIDevice *pci_dev = PCI_DEVICE(dev); > + XenPciDevice *xendev, *next; > > xen_unmap_pcidev(xen_domid, state->ioservid, pci_dev); > + > + QLIST_FOREACH_SAFE(xendev, &state->dev_list, entry, next) { > + if (xendev->pci_dev == pci_dev) { > + QLIST_REMOVE(xendev, entry); > + g_free(xendev); > + break; > + } > + } > } > } > > @@ -903,6 +926,61 @@ static void cpu_ioreq_move(ioreq_t *req) > } > } > > +static void cpu_ioreq_config(XenIOState *state, ioreq_t *req) > +{ > + uint32_t sbdf = req->addr >> 32; > + uint32_t reg = req->addr; > + XenPciDevice *xendev; > + > + if (req->size > sizeof(uint32_t)) { > + hw_error("PCI config access: bad size (%u)", req->size); > + } > + > + QLIST_FOREACH(xendev, &state->dev_list, entry) { > + unsigned int i; > + > + if (xendev->sbdf != sbdf) { > + continue; > + } > + > + if (req->dir == IOREQ_READ) { > + if (!req->data_is_ptr) { > + req->data = pci_host_config_read_common( > + xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE, > + req->size); > + trace_cpu_ioreq_config_read(req, sbdf, reg, req->size, > + req->data); > + } else { > + for (i = 0; i < req->count; i++) { > + uint32_t tmp; > + > + tmp = pci_host_config_read_common( > + xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE, > + req->size); > + write_phys_req_item(req->data, req, i, &tmp); > + } > + } > + } else if (req->dir == IOREQ_WRITE) { > + if (!req->data_is_ptr) { > + trace_cpu_ioreq_config_write(req, sbdf, reg, req->size, > + req->data); > + pci_host_config_write_common( > + xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE, req->data, > + req->size); > + } else { > + for (i = 0; i < req->count; i++) { > + uint32_t tmp = 0; > + > + read_phys_req_item(req->data, req, i, &tmp); > + pci_host_config_write_common( > + xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE, tmp, > + req->size); > + } > + } > + } > + } > +} > + > static void regs_to_cpu(vmware_regs_t *vmport_regs, ioreq_t *req) > { > X86CPU *cpu; > @@ -975,27 +1053,9 @@ static void handle_ioreq(XenIOState *state, ioreq_t *req) > case IOREQ_TYPE_INVALIDATE: > xen_invalidate_map_cache(); > break; > - case IOREQ_TYPE_PCI_CONFIG: { > - uint32_t sbdf = req->addr >> 32; > - uint32_t val; > - > - /* Fake a write to port 0xCF8 so that > - * the config space access will target the > - * correct device model. > - */ > - val = (1u << 31) | > - ((req->addr & 0x0f00) << 16) | > - ((sbdf & 0xffff) << 8) | > - (req->addr & 0xfc); > - do_outp(0xcf8, 4, val); > - > - /* Now issue the config space access via > - * port 0xCFC > - */ > - req->addr = 0xcfc | (req->addr & 0x03); > - cpu_ioreq_pio(req); > + case IOREQ_TYPE_PCI_CONFIG: > + cpu_ioreq_config(state, req); > break; > - } > default: > hw_error("Invalid ioreq type 0x%x\n", req->type); > } > @@ -1366,6 +1426,7 @@ void xen_hvm_init(PCMachineState *pcms, MemoryRegion **ram_memory) > memory_listener_register(&state->io_listener, &address_space_io); > > state->device_listener = xen_device_listener; > + QLIST_INIT(&state->dev_list); > device_listener_register(&state->device_listener); > > /* Initialize backend core & drivers */ > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Paolo Bonzini Subject: Re: [PATCH] xen-hvm: stop faking I/O to access PCI config space Date: Thu, 3 May 2018 13:48:43 +0200 Message-ID: <1b7ac8b6-df19-c6e2-bc6d-587c60e20207@redhat.com> References: <1525346320-24553-1-git-send-email-paul.durrant@citrix.com> 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.89) (envelope-from ) id 1fECjC-0006Qm-7i for xen-devel@lists.xenproject.org; Thu, 03 May 2018 11:48:50 +0000 In-Reply-To: <1525346320-24553-1-git-send-email-paul.durrant@citrix.com> Content-Language: en-US List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: Paul Durrant , xen-devel@lists.xenproject.org, qemu-devel@nongnu.org Cc: Stefano Stabellini , Eduardo Habkost , "Michael S. Tsirkin" , Marcel Apfelbaum , Anthony Perard , Richard Henderson List-Id: xen-devel@lists.xenproject.org T24gMDMvMDUvMjAxOCAxMzoxOCwgUGF1bCBEdXJyYW50IHdyb3RlOgo+IFRoaXMgcGF0Y2ggcmVt b3ZlcyB0aGUgY3VycmVudCBoYWNrZXJ5IHdoZXJlIElPUkVRX1RZUEVfUENJX0NPTkZJRwo+IHJl cXllc3RzIGFyZSBoYW5kbGVkIGJ5IGZha2luZyBQSU8gdG8gMHhjZjggYW5kIDB4Y2ZjIGFuZCBy ZXBsYWNlcyBpdAo+IHdpdGggZGlyZWN0IGNhbGxzIHRvIHBjaV9ob3N0X2NvbmZpZ19yZWFkL3dy aXRlX2NvbW1vbigpLgo+IERvaW5nIHNvIG5lY2Vzc2l0YXRlcyBtYXBwaW5nIEJERnMgdG8gUENJ RGV2aWNlcyBidXQgbWFpbnRhaW5pbmcgYSBzaW1wbGUKPiBRTElTVCBpbiB4ZW5fZGV2aWNlX3Jl YWxpemUvdW5yZWFsaXplKCkgd2lsbCBzdWZmaWNlLgoKTm8gb2JqZWN0aW9uIQoKVGhhbmtzLAoK UGFvbG8KCj4gTk9URTogd2hpbHN0IGNvbmZpZyBzcGFjZSBhY2Nlc3NlcyBhcmUgY3VycmVudGx5 IGxpbWl0ZWQgdG8KPiAgICAgICBQQ0lfQ09ORklHX1NQQUNFX1NJWkUsIHRoaXMgcGF0Y2ggcGF2 ZXMgdGhlIHdheSB0byBpbmNyZWFzaW5nIHRoZQo+ICAgICAgIGxpbWl0IHRvIFBDSUVfQ09ORklH X1NQQUNFX1NJWkUgd2hlbiBYZW4gZ2FpbnMgdGhlIGFiaWxpdHkgdG8KPiAgICAgICBlbXVsYXRl IE1DRkcgdGFibGUgYWNjZXNzZXMuCj4gCj4gU2lnbmVkLW9mZi1ieTogUGF1bCBEdXJyYW50IDxw YXVsLmR1cnJhbnRAY2l0cml4LmNvbT4KPiAtLQo+IENjOiBTdGVmYW5vIFN0YWJlbGxpbmkgPHNz dGFiZWxsaW5pQGtlcm5lbC5vcmc+Cj4gQ2M6IEFudGhvbnkgUGVyYXJkIDxhbnRob255LnBlcmFy ZEBjaXRyaXguY29tPgo+IENjOiAiTWljaGFlbCBTLiBUc2lya2luIiA8bXN0QHJlZGhhdC5jb20+ Cj4gQ2M6IE1hcmNlbCBBcGZlbGJhdW0gPG1hcmNlbEByZWRoYXQuY29tPgo+IENjOiBQYW9sbyBC b256aW5pIDxwYm9uemluaUByZWRoYXQuY29tPgo+IENjOiBSaWNoYXJkIEhlbmRlcnNvbiA8cnRo QHR3aWRkbGUubmV0Pgo+IENjOiBFZHVhcmRvIEhhYmtvc3QgPGVoYWJrb3N0QHJlZGhhdC5jb20+ Cj4gLS0tCj4gIGh3L2kzODYveGVuL3RyYWNlLWV2ZW50cyB8ICAgMiArCj4gIGh3L2kzODYveGVu L3hlbi1odm0uYyAgICB8IDEwMSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr LS0tLS0tLS0tLQo+ICAyIGZpbGVzIGNoYW5nZWQsIDgzIGluc2VydGlvbnMoKyksIDIwIGRlbGV0 aW9ucygtKQo+IAo+IGRpZmYgLS1naXQgYS9ody9pMzg2L3hlbi90cmFjZS1ldmVudHMgYi9ody9p Mzg2L3hlbi90cmFjZS1ldmVudHMKPiBpbmRleCA4ZGFiN2JjLi5mNTc2ZjFiIDEwMDY0NAo+IC0t LSBhL2h3L2kzODYveGVuL3RyYWNlLWV2ZW50cwo+ICsrKyBiL2h3L2kzODYveGVuL3RyYWNlLWV2 ZW50cwo+IEBAIC0xNSw2ICsxNSw4IEBAIGNwdV9pb3JlcV9waW8odm9pZCAqcmVxLCB1aW50MzJf dCBkaXIsIHVpbnQzMl90IGRmLCB1aW50MzJfdCBkYXRhX2lzX3B0ciwgdWludDY0Cj4gIGNwdV9p b3JlcV9waW9fcmVhZF9yZWcodm9pZCAqcmVxLCB1aW50NjRfdCBkYXRhLCB1aW50NjRfdCBhZGRy LCB1aW50MzJfdCBzaXplKSAiSS9PPSVwIHBpbyByZWFkIHJlZyBkYXRhPTB4JSJQUkl4NjQiIHBv cnQ9MHglIlBSSXg2NCIgc2l6ZT0lZCIKPiAgY3B1X2lvcmVxX3Bpb193cml0ZV9yZWcodm9pZCAq cmVxLCB1aW50NjRfdCBkYXRhLCB1aW50NjRfdCBhZGRyLCB1aW50MzJfdCBzaXplKSAiSS9PPSVw IHBpbyB3cml0ZSByZWcgZGF0YT0weCUiUFJJeDY0IiBwb3J0PTB4JSJQUkl4NjQiIHNpemU9JWQi Cj4gIGNwdV9pb3JlcV9tb3ZlKHZvaWQgKnJlcSwgdWludDMyX3QgZGlyLCB1aW50MzJfdCBkZiwg dWludDMyX3QgZGF0YV9pc19wdHIsIHVpbnQ2NF90IGFkZHIsIHVpbnQ2NF90IGRhdGEsIHVpbnQz Ml90IGNvdW50LCB1aW50MzJfdCBzaXplKSAiSS9PPSVwIGNvcHkgZGlyPSVkIGRmPSVkIHB0cj0l ZCBwb3J0PTB4JSJQUkl4NjQiIGRhdGE9MHglIlBSSXg2NCIgY291bnQ9JWQgc2l6ZT0lZCIKPiAr Y3B1X2lvcmVxX2NvbmZpZ19yZWFkKHZvaWQgKnJlcSwgdWludDMyX3Qgc2JkZiwgdWludDMyX3Qg cmVnLCB1aW50MzJfdCBzaXplLCB1aW50MzJfdCBkYXRhKSAiSS9PPSVwIHNiZGY9MHgleCByZWc9 JXUgc2l6ZT0ldSBkYXRhPTB4JXgiCj4gK2NwdV9pb3JlcV9jb25maWdfd3JpdGUodm9pZCAqcmVx LCB1aW50MzJfdCBzYmRmLCB1aW50MzJfdCByZWcsIHVpbnQzMl90IHNpemUsIHVpbnQzMl90IGRh dGEpICJJL089JXAgc2JkZj0weCV4IHJlZz0ldSBzaXplPSV1IGRhdGE9MHgleCIKPiAgCj4gICMg eGVuLW1hcGNhY2hlLmMKPiAgeGVuX21hcF9jYWNoZSh1aW50NjRfdCBwaHlzX2FkZHIpICJ3YW50 IDB4JSJQUkl4NjQKPiBkaWZmIC0tZ2l0IGEvaHcvaTM4Ni94ZW4veGVuLWh2bS5jIGIvaHcvaTM4 Ni94ZW4veGVuLWh2bS5jCj4gaW5kZXggY2FhNTYzYi4uYzEzOWQyOSAxMDA2NDQKPiAtLS0gYS9o dy9pMzg2L3hlbi94ZW4taHZtLmMKPiArKysgYi9ody9pMzg2L3hlbi94ZW4taHZtLmMKPiBAQCAt MTIsNiArMTIsNyBAQAo+ICAKPiAgI2luY2x1ZGUgImNwdS5oIgo+ICAjaW5jbHVkZSAiaHcvcGNp L3BjaS5oIgo+ICsjaW5jbHVkZSAiaHcvcGNpL3BjaV9ob3N0LmgiCj4gICNpbmNsdWRlICJody9p Mzg2L3BjLmgiCj4gICNpbmNsdWRlICJody9pMzg2L2FwaWMtbXNpZGVmLmgiCj4gICNpbmNsdWRl ICJody94ZW4veGVuX2NvbW1vbi5oIgo+IEBAIC04Niw2ICs4NywxMiBAQCB0eXBlZGVmIHN0cnVj dCBYZW5QaHlzbWFwIHsKPiAgICAgIFFMSVNUX0VOVFJZKFhlblBoeXNtYXApIGxpc3Q7Cj4gIH0g WGVuUGh5c21hcDsKPiAgCj4gK3R5cGVkZWYgc3RydWN0IFhlblBjaURldmljZSB7Cj4gKyAgICBQ Q0lEZXZpY2UgKnBjaV9kZXY7Cj4gKyAgICB1aW50MzJfdCBzYmRmOwo+ICsgICAgUUxJU1RfRU5U UlkoWGVuUGNpRGV2aWNlKSBlbnRyeTsKPiArfSBYZW5QY2lEZXZpY2U7Cj4gKwo+ICB0eXBlZGVm IHN0cnVjdCBYZW5JT1N0YXRlIHsKPiAgICAgIGlvc2VydmlkX3QgaW9zZXJ2aWQ7Cj4gICAgICBz aGFyZWRfaW9wYWdlX3QgKnNoYXJlZF9wYWdlOwo+IEBAIC0xMDUsNiArMTEyLDcgQEAgdHlwZWRl ZiBzdHJ1Y3QgWGVuSU9TdGF0ZSB7Cj4gICAgICBzdHJ1Y3QgeHNfaGFuZGxlICp4ZW5zdG9yZTsK PiAgICAgIE1lbW9yeUxpc3RlbmVyIG1lbW9yeV9saXN0ZW5lcjsKPiAgICAgIE1lbW9yeUxpc3Rl bmVyIGlvX2xpc3RlbmVyOwo+ICsgICAgUUxJU1RfSEVBRCgsIFhlblBjaURldmljZSkgZGV2X2xp c3Q7Cj4gICAgICBEZXZpY2VMaXN0ZW5lciBkZXZpY2VfbGlzdGVuZXI7Cj4gICAgICBRTElTVF9I RUFEKCwgWGVuUGh5c21hcCkgcGh5c21hcDsKPiAgICAgIGh3YWRkciBmcmVlX3BoeXNfb2Zmc2V0 Owo+IEBAIC01NjksNiArNTc3LDEyIEBAIHN0YXRpYyB2b2lkIHhlbl9kZXZpY2VfcmVhbGl6ZShE ZXZpY2VMaXN0ZW5lciAqbGlzdGVuZXIsCj4gIAo+ICAgICAgaWYgKG9iamVjdF9keW5hbWljX2Nh c3QoT0JKRUNUKGRldiksIFRZUEVfUENJX0RFVklDRSkpIHsKPiAgICAgICAgICBQQ0lEZXZpY2Ug KnBjaV9kZXYgPSBQQ0lfREVWSUNFKGRldik7Cj4gKyAgICAgICAgWGVuUGNpRGV2aWNlICp4ZW5k ZXYgPSBnX25ldyhYZW5QY2lEZXZpY2UsIDEpOwo+ICsKPiArICAgICAgICB4ZW5kZXYtPnBjaV9k ZXYgPSBwY2lfZGV2Owo+ICsgICAgICAgIHhlbmRldi0+c2JkZiA9IFBDSV9CVUlMRF9CREYocGNp X2Rldl9idXNfbnVtKHBjaV9kZXYpLAo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgcGNpX2Rldi0+ZGV2Zm4pOwo+ICsgICAgICAgIFFMSVNUX0lOU0VSVF9IRUFEKCZzdGF0 ZS0+ZGV2X2xpc3QsIHhlbmRldiwgZW50cnkpOwo+ICAKPiAgICAgICAgICB4ZW5fbWFwX3BjaWRl dih4ZW5fZG9taWQsIHN0YXRlLT5pb3NlcnZpZCwgcGNpX2Rldik7Cj4gICAgICB9Cj4gQEAgLTU4 MSw4ICs1OTUsMTcgQEAgc3RhdGljIHZvaWQgeGVuX2RldmljZV91bnJlYWxpemUoRGV2aWNlTGlz dGVuZXIgKmxpc3RlbmVyLAo+ICAKPiAgICAgIGlmIChvYmplY3RfZHluYW1pY19jYXN0KE9CSkVD VChkZXYpLCBUWVBFX1BDSV9ERVZJQ0UpKSB7Cj4gICAgICAgICAgUENJRGV2aWNlICpwY2lfZGV2 ID0gUENJX0RFVklDRShkZXYpOwo+ICsgICAgICAgIFhlblBjaURldmljZSAqeGVuZGV2LCAqbmV4 dDsKPiAgCj4gICAgICAgICAgeGVuX3VubWFwX3BjaWRldih4ZW5fZG9taWQsIHN0YXRlLT5pb3Nl cnZpZCwgcGNpX2Rldik7Cj4gKwo+ICsgICAgICAgIFFMSVNUX0ZPUkVBQ0hfU0FGRSh4ZW5kZXYs ICZzdGF0ZS0+ZGV2X2xpc3QsIGVudHJ5LCBuZXh0KSB7Cj4gKyAgICAgICAgICAgIGlmICh4ZW5k ZXYtPnBjaV9kZXYgPT0gcGNpX2Rldikgewo+ICsgICAgICAgICAgICAgICAgUUxJU1RfUkVNT1ZF KHhlbmRldiwgZW50cnkpOwo+ICsgICAgICAgICAgICAgICAgZ19mcmVlKHhlbmRldik7Cj4gKyAg ICAgICAgICAgICAgICBicmVhazsKPiArICAgICAgICAgICAgfQo+ICsgICAgICAgIH0KPiAgICAg IH0KPiAgfQo+ICAKPiBAQCAtOTAzLDYgKzkyNiw2MSBAQCBzdGF0aWMgdm9pZCBjcHVfaW9yZXFf bW92ZShpb3JlcV90ICpyZXEpCj4gICAgICB9Cj4gIH0KPiAgCj4gK3N0YXRpYyB2b2lkIGNwdV9p b3JlcV9jb25maWcoWGVuSU9TdGF0ZSAqc3RhdGUsIGlvcmVxX3QgKnJlcSkKPiArewo+ICsgICAg dWludDMyX3Qgc2JkZiA9IHJlcS0+YWRkciA+PiAzMjsKPiArICAgIHVpbnQzMl90IHJlZyA9IHJl cS0+YWRkcjsKPiArICAgIFhlblBjaURldmljZSAqeGVuZGV2Owo+ICsKPiArICAgIGlmIChyZXEt PnNpemUgPiBzaXplb2YodWludDMyX3QpKSB7Cj4gKyAgICAgICAgaHdfZXJyb3IoIlBDSSBjb25m aWcgYWNjZXNzOiBiYWQgc2l6ZSAoJXUpIiwgcmVxLT5zaXplKTsKPiArICAgIH0KPiArCj4gKyAg ICBRTElTVF9GT1JFQUNIKHhlbmRldiwgJnN0YXRlLT5kZXZfbGlzdCwgZW50cnkpIHsKPiArICAg ICAgICB1bnNpZ25lZCBpbnQgaTsKPiArCj4gKyAgICAgICAgaWYgKHhlbmRldi0+c2JkZiAhPSBz YmRmKSB7Cj4gKyAgICAgICAgICAgIGNvbnRpbnVlOwo+ICsgICAgICAgIH0KPiArCj4gKyAgICAg ICAgaWYgKHJlcS0+ZGlyID09IElPUkVRX1JFQUQpIHsKPiArICAgICAgICAgICAgaWYgKCFyZXEt PmRhdGFfaXNfcHRyKSB7Cj4gKyAgICAgICAgICAgICAgICByZXEtPmRhdGEgPSBwY2lfaG9zdF9j b25maWdfcmVhZF9jb21tb24oCj4gKyAgICAgICAgICAgICAgICAgICAgeGVuZGV2LT5wY2lfZGV2 LCByZWcsIFBDSV9DT05GSUdfU1BBQ0VfU0laRSwKPiArICAgICAgICAgICAgICAgICAgICByZXEt PnNpemUpOwo+ICsgICAgICAgICAgICAgICAgdHJhY2VfY3B1X2lvcmVxX2NvbmZpZ19yZWFkKHJl cSwgc2JkZiwgcmVnLCByZXEtPnNpemUsCj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgcmVxLT5kYXRhKTsKPiArICAgICAgICAgICAgfSBlbHNlIHsKPiArICAg ICAgICAgICAgICAgIGZvciAoaSA9IDA7IGkgPCByZXEtPmNvdW50OyBpKyspIHsKPiArICAgICAg ICAgICAgICAgICAgICB1aW50MzJfdCB0bXA7Cj4gKwo+ICsgICAgICAgICAgICAgICAgICAgIHRt cCA9IHBjaV9ob3N0X2NvbmZpZ19yZWFkX2NvbW1vbigKPiArICAgICAgICAgICAgICAgICAgICAg ICAgeGVuZGV2LT5wY2lfZGV2LCByZWcsIFBDSV9DT05GSUdfU1BBQ0VfU0laRSwKPiArICAgICAg ICAgICAgICAgICAgICAgICAgcmVxLT5zaXplKTsKPiArICAgICAgICAgICAgICAgICAgICB3cml0 ZV9waHlzX3JlcV9pdGVtKHJlcS0+ZGF0YSwgcmVxLCBpLCAmdG1wKTsKPiArICAgICAgICAgICAg ICAgIH0KPiArICAgICAgICAgICAgfQo+ICsgICAgICAgIH0gZWxzZSBpZiAocmVxLT5kaXIgPT0g SU9SRVFfV1JJVEUpIHsKPiArICAgICAgICAgICAgaWYgKCFyZXEtPmRhdGFfaXNfcHRyKSB7Cj4g KyAgICAgICAgICAgICAgICB0cmFjZV9jcHVfaW9yZXFfY29uZmlnX3dyaXRlKHJlcSwgc2JkZiwg cmVnLCByZXEtPnNpemUsCj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHJlcS0+ZGF0YSk7Cj4gKyAgICAgICAgICAgICAgICBwY2lfaG9zdF9jb25maWdfd3Jp dGVfY29tbW9uKAo+ICsgICAgICAgICAgICAgICAgICAgIHhlbmRldi0+cGNpX2RldiwgcmVnLCBQ Q0lfQ09ORklHX1NQQUNFX1NJWkUsIHJlcS0+ZGF0YSwKPiArICAgICAgICAgICAgICAgICAgICBy ZXEtPnNpemUpOwo+ICsgICAgICAgICAgICB9IGVsc2Ugewo+ICsgICAgICAgICAgICAgICAgZm9y IChpID0gMDsgaSA8IHJlcS0+Y291bnQ7IGkrKykgewo+ICsgICAgICAgICAgICAgICAgICAgIHVp bnQzMl90IHRtcCA9IDA7Cj4gKwo+ICsgICAgICAgICAgICAgICAgICAgIHJlYWRfcGh5c19yZXFf aXRlbShyZXEtPmRhdGEsIHJlcSwgaSwgJnRtcCk7Cj4gKyAgICAgICAgICAgICAgICAgICAgcGNp X2hvc3RfY29uZmlnX3dyaXRlX2NvbW1vbigKPiArICAgICAgICAgICAgICAgICAgICAgICAgeGVu ZGV2LT5wY2lfZGV2LCByZWcsIFBDSV9DT05GSUdfU1BBQ0VfU0laRSwgdG1wLAo+ICsgICAgICAg ICAgICAgICAgICAgICAgICByZXEtPnNpemUpOwo+ICsgICAgICAgICAgICAgICAgfQo+ICsgICAg ICAgICAgICB9Cj4gKyAgICAgICAgfQo+ICsgICAgfQo+ICt9Cj4gKwo+ICBzdGF0aWMgdm9pZCBy ZWdzX3RvX2NwdSh2bXdhcmVfcmVnc190ICp2bXBvcnRfcmVncywgaW9yZXFfdCAqcmVxKQo+ICB7 Cj4gICAgICBYODZDUFUgKmNwdTsKPiBAQCAtOTc1LDI3ICsxMDUzLDkgQEAgc3RhdGljIHZvaWQg aGFuZGxlX2lvcmVxKFhlbklPU3RhdGUgKnN0YXRlLCBpb3JlcV90ICpyZXEpCj4gICAgICAgICAg Y2FzZSBJT1JFUV9UWVBFX0lOVkFMSURBVEU6Cj4gICAgICAgICAgICAgIHhlbl9pbnZhbGlkYXRl X21hcF9jYWNoZSgpOwo+ICAgICAgICAgICAgICBicmVhazsKPiAtICAgICAgICBjYXNlIElPUkVR X1RZUEVfUENJX0NPTkZJRzogewo+IC0gICAgICAgICAgICB1aW50MzJfdCBzYmRmID0gcmVxLT5h ZGRyID4+IDMyOwo+IC0gICAgICAgICAgICB1aW50MzJfdCB2YWw7Cj4gLQo+IC0gICAgICAgICAg ICAvKiBGYWtlIGEgd3JpdGUgdG8gcG9ydCAweENGOCBzbyB0aGF0Cj4gLSAgICAgICAgICAgICAq IHRoZSBjb25maWcgc3BhY2UgYWNjZXNzIHdpbGwgdGFyZ2V0IHRoZQo+IC0gICAgICAgICAgICAg KiBjb3JyZWN0IGRldmljZSBtb2RlbC4KPiAtICAgICAgICAgICAgICovCj4gLSAgICAgICAgICAg IHZhbCA9ICgxdSA8PCAzMSkgfAo+IC0gICAgICAgICAgICAgICAgICAoKHJlcS0+YWRkciAmIDB4 MGYwMCkgPDwgMTYpIHwKPiAtICAgICAgICAgICAgICAgICAgKChzYmRmICYgMHhmZmZmKSA8PCA4 KSB8Cj4gLSAgICAgICAgICAgICAgICAgIChyZXEtPmFkZHIgJiAweGZjKTsKPiAtICAgICAgICAg ICAgZG9fb3V0cCgweGNmOCwgNCwgdmFsKTsKPiAtCj4gLSAgICAgICAgICAgIC8qIE5vdyBpc3N1 ZSB0aGUgY29uZmlnIHNwYWNlIGFjY2VzcyB2aWEKPiAtICAgICAgICAgICAgICogcG9ydCAweENG Qwo+IC0gICAgICAgICAgICAgKi8KPiAtICAgICAgICAgICAgcmVxLT5hZGRyID0gMHhjZmMgfCAo cmVxLT5hZGRyICYgMHgwMyk7Cj4gLSAgICAgICAgICAgIGNwdV9pb3JlcV9waW8ocmVxKTsKPiAr ICAgICAgICBjYXNlIElPUkVRX1RZUEVfUENJX0NPTkZJRzoKPiArICAgICAgICAgICAgY3B1X2lv cmVxX2NvbmZpZyhzdGF0ZSwgcmVxKTsKPiAgICAgICAgICAgICAgYnJlYWs7Cj4gLSAgICAgICAg fQo+ICAgICAgICAgIGRlZmF1bHQ6Cj4gICAgICAgICAgICAgIGh3X2Vycm9yKCJJbnZhbGlkIGlv cmVxIHR5cGUgMHgleFxuIiwgcmVxLT50eXBlKTsKPiAgICAgIH0KPiBAQCAtMTM2Niw2ICsxNDI2 LDcgQEAgdm9pZCB4ZW5faHZtX2luaXQoUENNYWNoaW5lU3RhdGUgKnBjbXMsIE1lbW9yeVJlZ2lv biAqKnJhbV9tZW1vcnkpCj4gICAgICBtZW1vcnlfbGlzdGVuZXJfcmVnaXN0ZXIoJnN0YXRlLT5p b19saXN0ZW5lciwgJmFkZHJlc3Nfc3BhY2VfaW8pOwo+ICAKPiAgICAgIHN0YXRlLT5kZXZpY2Vf bGlzdGVuZXIgPSB4ZW5fZGV2aWNlX2xpc3RlbmVyOwo+ICsgICAgUUxJU1RfSU5JVCgmc3RhdGUt PmRldl9saXN0KTsKPiAgICAgIGRldmljZV9saXN0ZW5lcl9yZWdpc3Rlcigmc3RhdGUtPmRldmlj ZV9saXN0ZW5lcik7Cj4gIAo+ICAgICAgLyogSW5pdGlhbGl6ZSBiYWNrZW5kIGNvcmUgJiBkcml2 ZXJzICovCj4gCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcK aHR0cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hlbi1kZXZlbA==