From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:41673) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1fKqaO-0000fI-UI for qemu-devel@nongnu.org; Mon, 21 May 2018 15:35:15 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1fKqaN-0003GG-Bs for qemu-devel@nongnu.org; Mon, 21 May 2018 15:35:12 -0400 Received: from mail.kernel.org ([198.145.29.99]:60310) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1fKqaN-0003ET-4D for qemu-devel@nongnu.org; Mon, 21 May 2018 15:35:11 -0400 From: Stefano Stabellini Date: Mon, 21 May 2018 12:34:57 -0700 Message-Id: <1526931304-7289-8-git-send-email-sstabellini@kernel.org> In-Reply-To: References: Subject: [Qemu-devel] [PULL 08/15] xen_backend: add grant table helpers List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: peter.maydell@linaro.org, stefanha@gmail.com Cc: sstabellini@kernel.org, stefanha@redhat.com, anthony.perard@citrix.com, xen-devel@lists.xenproject.org, qemu-devel@nongnu.org, Paul Durrant From: Paul Durrant This patch adds grant table helper functions to the xen_backend code to localize error reporting and use of xen_domid. The patch also defers the call to xengnttab_open() until just before the initialise method in XenDevOps is invoked. This method is responsible for mapping the shared ring. No prior method requires access to the grant table. Signed-off-by: Paul Durrant Acked-by: Anthony PERARD Signed-off-by: Stefano Stabellini --- hw/xen/xen_backend.c | 123 ++++++++++++++++++++++++++++++++++++++----- include/hw/xen/xen_backend.h | 33 ++++++++++++ 2 files changed, 144 insertions(+), 12 deletions(-) diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c index 7445b50..50412d6 100644 --- a/hw/xen/xen_backend.c +++ b/hw/xen/xen_backend.c @@ -106,6 +106,103 @@ int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state) return 0; } +void xen_be_set_max_grant_refs(struct XenDevice *xendev, + unsigned int nr_refs) +{ + assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); + + if (xengnttab_set_max_grants(xendev->gnttabdev, nr_refs)) { + xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", + strerror(errno)); + } +} + +void *xen_be_map_grant_refs(struct XenDevice *xendev, uint32_t *refs, + unsigned int nr_refs, int prot) +{ + void *ptr; + + assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); + + ptr = xengnttab_map_domain_grant_refs(xendev->gnttabdev, nr_refs, + xen_domid, refs, prot); + if (!ptr) { + xen_pv_printf(xendev, 0, + "xengnttab_map_domain_grant_refs failed: %s\n", + strerror(errno)); + } + + return ptr; +} + +void xen_be_unmap_grant_refs(struct XenDevice *xendev, void *ptr, + unsigned int nr_refs) +{ + assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); + + if (xengnttab_unmap(xendev->gnttabdev, ptr, nr_refs)) { + xen_pv_printf(xendev, 0, "xengnttab_unmap failed: %s\n", + strerror(errno)); + } +} + +int xen_be_copy_grant_refs(struct XenDevice *xendev, + bool to_domain, + XenGrantCopySegment segs[], + unsigned int nr_segs) +{ + xengnttab_grant_copy_segment_t *xengnttab_segs; + unsigned int i; + int rc; + + assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); + + xengnttab_segs = g_new0(xengnttab_grant_copy_segment_t, nr_segs); + + for (i = 0; i < nr_segs; i++) { + XenGrantCopySegment *seg = &segs[i]; + xengnttab_grant_copy_segment_t *xengnttab_seg = &xengnttab_segs[i]; + + if (to_domain) { + xengnttab_seg->flags = GNTCOPY_dest_gref; + xengnttab_seg->dest.foreign.domid = xen_domid; + xengnttab_seg->dest.foreign.ref = seg->dest.foreign.ref; + xengnttab_seg->dest.foreign.offset = seg->dest.foreign.offset; + xengnttab_seg->source.virt = seg->source.virt; + } else { + xengnttab_seg->flags = GNTCOPY_source_gref; + xengnttab_seg->source.foreign.domid = xen_domid; + xengnttab_seg->source.foreign.ref = seg->source.foreign.ref; + xengnttab_seg->source.foreign.offset = + seg->source.foreign.offset; + xengnttab_seg->dest.virt = seg->dest.virt; + } + + xengnttab_seg->len = seg->len; + } + + rc = xengnttab_grant_copy(xendev->gnttabdev, nr_segs, xengnttab_segs); + + if (rc) { + xen_pv_printf(xendev, 0, "xengnttab_copy failed: %s\n", + strerror(errno)); + } + + for (i = 0; i < nr_segs; i++) { + xengnttab_grant_copy_segment_t *xengnttab_seg = + &xengnttab_segs[i]; + + if (xengnttab_seg->status != GNTST_okay) { + xen_pv_printf(xendev, 0, "segment[%u] status: %d\n", i, + xengnttab_seg->status); + rc = -1; + } + } + + g_free(xengnttab_segs); + return rc; +} + /* * get xen backend device, allocate a new one if it doesn't exist. */ @@ -149,18 +246,6 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev, } qemu_set_cloexec(xenevtchn_fd(xendev->evtchndev)); - if (ops->flags & DEVOPS_FLAG_NEED_GNTDEV) { - xendev->gnttabdev = xengnttab_open(NULL, 0); - if (xendev->gnttabdev == NULL) { - xen_pv_printf(NULL, 0, "can't open gnttab device\n"); - xenevtchn_close(xendev->evtchndev); - qdev_unplug(DEVICE(xendev), NULL); - return NULL; - } - } else { - xendev->gnttabdev = NULL; - } - xen_pv_insert_xendev(xendev); if (xendev->ops->alloc) { @@ -322,6 +407,16 @@ static int xen_be_try_initialise(struct XenDevice *xendev) } } + if (xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV) { + xendev->gnttabdev = xengnttab_open(NULL, 0); + if (xendev->gnttabdev == NULL) { + xen_pv_printf(NULL, 0, "can't open gnttab device\n"); + return -1; + } + } else { + xendev->gnttabdev = NULL; + } + if (xendev->ops->initialise) { rc = xendev->ops->initialise(xendev); } @@ -369,6 +464,10 @@ static void xen_be_disconnect(struct XenDevice *xendev, enum xenbus_state state) xendev->ops->disconnect) { xendev->ops->disconnect(xendev); } + if (xendev->gnttabdev) { + xengnttab_close(xendev->gnttabdev); + xendev->gnttabdev = NULL; + } if (xendev->be_state != state) { xen_be_set_state(xendev, state); } diff --git a/include/hw/xen/xen_backend.h b/include/hw/xen/xen_backend.h index 3a27692..29bf1c3 100644 --- a/include/hw/xen/xen_backend.h +++ b/include/hw/xen/xen_backend.h @@ -42,6 +42,39 @@ void xen_be_register_common(void); int xen_be_register(const char *type, struct XenDevOps *ops); int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state); int xen_be_bind_evtchn(struct XenDevice *xendev); +void xen_be_set_max_grant_refs(struct XenDevice *xendev, + unsigned int nr_refs); +void *xen_be_map_grant_refs(struct XenDevice *xendev, uint32_t *refs, + unsigned int nr_refs, int prot); +void xen_be_unmap_grant_refs(struct XenDevice *xendev, void *ptr, + unsigned int nr_refs); + +typedef struct XenGrantCopySegment { + union { + void *virt; + struct { + uint32_t ref; + off_t offset; + } foreign; + } source, dest; + size_t len; +} XenGrantCopySegment; + +int xen_be_copy_grant_refs(struct XenDevice *xendev, + bool to_domain, XenGrantCopySegment segs[], + unsigned int nr_segs); + +static inline void *xen_be_map_grant_ref(struct XenDevice *xendev, + uint32_t ref, int prot) +{ + return xen_be_map_grant_refs(xendev, &ref, 1, prot); +} + +static inline void xen_be_unmap_grant_ref(struct XenDevice *xendev, + void *ptr) +{ + return xen_be_unmap_grant_refs(xendev, ptr, 1); +} /* actual backend drivers */ extern struct XenDevOps xen_console_ops; /* xen_console.c */ -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Stefano Stabellini Subject: [PULL 08/15] xen_backend: add grant table helpers Date: Mon, 21 May 2018 12:34:57 -0700 Message-ID: <1526931304-7289-8-git-send-email-sstabellini@kernel.org> 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.89) (envelope-from ) id 1fKqaO-0000Ts-Il for xen-devel@lists.xenproject.org; Mon, 21 May 2018 19:35:12 +0000 In-Reply-To: List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: peter.maydell@linaro.org, stefanha@gmail.com Cc: sstabellini@kernel.org, qemu-devel@nongnu.org, Paul Durrant , stefanha@redhat.com, anthony.perard@citrix.com, xen-devel@lists.xenproject.org List-Id: xen-devel@lists.xenproject.org RnJvbTogUGF1bCBEdXJyYW50IDxwYXVsLmR1cnJhbnRAY2l0cml4LmNvbT4KClRoaXMgcGF0Y2gg YWRkcyBncmFudCB0YWJsZSBoZWxwZXIgZnVuY3Rpb25zIHRvIHRoZSB4ZW5fYmFja2VuZCBjb2Rl IHRvCmxvY2FsaXplIGVycm9yIHJlcG9ydGluZyBhbmQgdXNlIG9mIHhlbl9kb21pZC4KClRoZSBw YXRjaCBhbHNvIGRlZmVycyB0aGUgY2FsbCB0byB4ZW5nbnR0YWJfb3BlbigpIHVudGlsIGp1c3Qg YmVmb3JlIHRoZQppbml0aWFsaXNlIG1ldGhvZCBpbiBYZW5EZXZPcHMgaXMgaW52b2tlZC4gVGhp cyBtZXRob2QgaXMgcmVzcG9uc2libGUgZm9yCm1hcHBpbmcgdGhlIHNoYXJlZCByaW5nLiBObyBw cmlvciBtZXRob2QgcmVxdWlyZXMgYWNjZXNzIHRvIHRoZSBncmFudCB0YWJsZS4KClNpZ25lZC1v ZmYtYnk6IFBhdWwgRHVycmFudCA8cGF1bC5kdXJyYW50QGNpdHJpeC5jb20+CkFja2VkLWJ5OiBB bnRob255IFBFUkFSRCA8YW50aG9ueS5wZXJhcmRAY2l0cml4LmNvbT4KU2lnbmVkLW9mZi1ieTog U3RlZmFubyBTdGFiZWxsaW5pIDxzc3RhYmVsbGluaUBrZXJuZWwub3JnPgotLS0KIGh3L3hlbi94 ZW5fYmFja2VuZC5jICAgICAgICAgfCAxMjMgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKystLS0tLQogaW5jbHVkZS9ody94ZW4veGVuX2JhY2tlbmQuaCB8ICAzMyArKysrKysr KysrKysKIDIgZmlsZXMgY2hhbmdlZCwgMTQ0IGluc2VydGlvbnMoKyksIDEyIGRlbGV0aW9ucygt KQoKZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW5fYmFja2VuZC5jIGIvaHcveGVuL3hlbl9iYWNrZW5k LmMKaW5kZXggNzQ0NWI1MC4uNTA0MTJkNiAxMDA2NDQKLS0tIGEvaHcveGVuL3hlbl9iYWNrZW5k LmMKKysrIGIvaHcveGVuL3hlbl9iYWNrZW5kLmMKQEAgLTEwNiw2ICsxMDYsMTAzIEBAIGludCB4 ZW5fYmVfc2V0X3N0YXRlKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgZW51bSB4ZW5idXNfc3Rh dGUgc3RhdGUpCiAgICAgcmV0dXJuIDA7CiB9CiAKK3ZvaWQgeGVuX2JlX3NldF9tYXhfZ3JhbnRf cmVmcyhzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgdW5zaWduZWQgaW50IG5yX3JlZnMpCit7CisgICAgYXNzZXJ0KHhlbmRldi0+b3BzLT5m bGFncyAmIERFVk9QU19GTEFHX05FRURfR05UREVWKTsKKworICAgIGlmICh4ZW5nbnR0YWJfc2V0 X21heF9ncmFudHMoeGVuZGV2LT5nbnR0YWJkZXYsIG5yX3JlZnMpKSB7CisgICAgICAgIHhlbl9w dl9wcmludGYoeGVuZGV2LCAwLCAieGVuZ250dGFiX3NldF9tYXhfZ3JhbnRzIGZhaWxlZDogJXNc biIsCisgICAgICAgICAgICAgICAgICAgICAgc3RyZXJyb3IoZXJybm8pKTsKKyAgICB9Cit9CisK K3ZvaWQgKnhlbl9iZV9tYXBfZ3JhbnRfcmVmcyhzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIHVp bnQzMl90ICpyZWZzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBu cl9yZWZzLCBpbnQgcHJvdCkKK3sKKyAgICB2b2lkICpwdHI7CisKKyAgICBhc3NlcnQoeGVuZGV2 LT5vcHMtPmZsYWdzICYgREVWT1BTX0ZMQUdfTkVFRF9HTlRERVYpOworCisgICAgcHRyID0geGVu Z250dGFiX21hcF9kb21haW5fZ3JhbnRfcmVmcyh4ZW5kZXYtPmdudHRhYmRldiwgbnJfcmVmcywK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhlbl9kb21pZCwgcmVm cywgcHJvdCk7CisgICAgaWYgKCFwdHIpIHsKKyAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYs IDAsCisgICAgICAgICAgICAgICAgICAgICAgInhlbmdudHRhYl9tYXBfZG9tYWluX2dyYW50X3Jl ZnMgZmFpbGVkOiAlc1xuIiwKKyAgICAgICAgICAgICAgICAgICAgICBzdHJlcnJvcihlcnJubykp OworICAgIH0KKworICAgIHJldHVybiBwdHI7Cit9CisKK3ZvaWQgeGVuX2JlX3VubWFwX2dyYW50 X3JlZnMoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LCB2b2lkICpwdHIsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBucl9yZWZzKQoreworICAgIGFzc2VydCh4ZW5k ZXYtPm9wcy0+ZmxhZ3MgJiBERVZPUFNfRkxBR19ORUVEX0dOVERFVik7CisKKyAgICBpZiAoeGVu Z250dGFiX3VubWFwKHhlbmRldi0+Z250dGFiZGV2LCBwdHIsIG5yX3JlZnMpKSB7CisgICAgICAg IHhlbl9wdl9wcmludGYoeGVuZGV2LCAwLCAieGVuZ250dGFiX3VubWFwIGZhaWxlZDogJXNcbiIs CisgICAgICAgICAgICAgICAgICAgICAgc3RyZXJyb3IoZXJybm8pKTsKKyAgICB9Cit9CisKK2lu dCB4ZW5fYmVfY29weV9ncmFudF9yZWZzKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgIGJvb2wgdG9fZG9tYWluLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgWGVuR3JhbnRDb3B5U2VnbWVudCBzZWdzW10sCisgICAgICAgICAgICAgICAgICAg ICAgICAgICB1bnNpZ25lZCBpbnQgbnJfc2VncykKK3sKKyAgICB4ZW5nbnR0YWJfZ3JhbnRfY29w eV9zZWdtZW50X3QgKnhlbmdudHRhYl9zZWdzOworICAgIHVuc2lnbmVkIGludCBpOworICAgIGlu dCByYzsKKworICAgIGFzc2VydCh4ZW5kZXYtPm9wcy0+ZmxhZ3MgJiBERVZPUFNfRkxBR19ORUVE X0dOVERFVik7CisKKyAgICB4ZW5nbnR0YWJfc2VncyA9IGdfbmV3MCh4ZW5nbnR0YWJfZ3JhbnRf Y29weV9zZWdtZW50X3QsIG5yX3NlZ3MpOworCisgICAgZm9yIChpID0gMDsgaSA8IG5yX3NlZ3M7 IGkrKykgeworICAgICAgICBYZW5HcmFudENvcHlTZWdtZW50ICpzZWcgPSAmc2Vnc1tpXTsKKyAg ICAgICAgeGVuZ250dGFiX2dyYW50X2NvcHlfc2VnbWVudF90ICp4ZW5nbnR0YWJfc2VnID0gJnhl bmdudHRhYl9zZWdzW2ldOworCisgICAgICAgIGlmICh0b19kb21haW4pIHsKKyAgICAgICAgICAg IHhlbmdudHRhYl9zZWctPmZsYWdzID0gR05UQ09QWV9kZXN0X2dyZWY7CisgICAgICAgICAgICB4 ZW5nbnR0YWJfc2VnLT5kZXN0LmZvcmVpZ24uZG9taWQgPSB4ZW5fZG9taWQ7CisgICAgICAgICAg ICB4ZW5nbnR0YWJfc2VnLT5kZXN0LmZvcmVpZ24ucmVmID0gc2VnLT5kZXN0LmZvcmVpZ24ucmVm OworICAgICAgICAgICAgeGVuZ250dGFiX3NlZy0+ZGVzdC5mb3JlaWduLm9mZnNldCA9IHNlZy0+ ZGVzdC5mb3JlaWduLm9mZnNldDsKKyAgICAgICAgICAgIHhlbmdudHRhYl9zZWctPnNvdXJjZS52 aXJ0ID0gc2VnLT5zb3VyY2UudmlydDsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIHhl bmdudHRhYl9zZWctPmZsYWdzID0gR05UQ09QWV9zb3VyY2VfZ3JlZjsKKyAgICAgICAgICAgIHhl bmdudHRhYl9zZWctPnNvdXJjZS5mb3JlaWduLmRvbWlkID0geGVuX2RvbWlkOworICAgICAgICAg ICAgeGVuZ250dGFiX3NlZy0+c291cmNlLmZvcmVpZ24ucmVmID0gc2VnLT5zb3VyY2UuZm9yZWln bi5yZWY7CisgICAgICAgICAgICB4ZW5nbnR0YWJfc2VnLT5zb3VyY2UuZm9yZWlnbi5vZmZzZXQg PQorICAgICAgICAgICAgICAgIHNlZy0+c291cmNlLmZvcmVpZ24ub2Zmc2V0OworICAgICAgICAg ICAgeGVuZ250dGFiX3NlZy0+ZGVzdC52aXJ0ID0gc2VnLT5kZXN0LnZpcnQ7CisgICAgICAgIH0K KworICAgICAgICB4ZW5nbnR0YWJfc2VnLT5sZW4gPSBzZWctPmxlbjsKKyAgICB9CisKKyAgICBy YyA9IHhlbmdudHRhYl9ncmFudF9jb3B5KHhlbmRldi0+Z250dGFiZGV2LCBucl9zZWdzLCB4ZW5n bnR0YWJfc2Vncyk7CisKKyAgICBpZiAocmMpIHsKKyAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5k ZXYsIDAsICJ4ZW5nbnR0YWJfY29weSBmYWlsZWQ6ICVzXG4iLAorICAgICAgICAgICAgICAgICAg ICAgIHN0cmVycm9yKGVycm5vKSk7CisgICAgfQorCisgICAgZm9yIChpID0gMDsgaSA8IG5yX3Nl Z3M7IGkrKykgeworICAgICAgICB4ZW5nbnR0YWJfZ3JhbnRfY29weV9zZWdtZW50X3QgKnhlbmdu dHRhYl9zZWcgPQorICAgICAgICAgICAgJnhlbmdudHRhYl9zZWdzW2ldOworCisgICAgICAgIGlm ICh4ZW5nbnR0YWJfc2VnLT5zdGF0dXMgIT0gR05UU1Rfb2theSkgeworICAgICAgICAgICAgeGVu X3B2X3ByaW50Zih4ZW5kZXYsIDAsICJzZWdtZW50WyV1XSBzdGF0dXM6ICVkXG4iLCBpLAorICAg ICAgICAgICAgICAgICAgICAgICAgICB4ZW5nbnR0YWJfc2VnLT5zdGF0dXMpOworICAgICAgICAg ICAgcmMgPSAtMTsKKyAgICAgICAgfQorICAgIH0KKworICAgIGdfZnJlZSh4ZW5nbnR0YWJfc2Vn cyk7CisgICAgcmV0dXJuIHJjOworfQorCiAvKgogICogZ2V0IHhlbiBiYWNrZW5kIGRldmljZSwg YWxsb2NhdGUgYSBuZXcgb25lIGlmIGl0IGRvZXNuJ3QgZXhpc3QuCiAgKi8KQEAgLTE0OSwxOCAr MjQ2LDYgQEAgc3RhdGljIHN0cnVjdCBYZW5EZXZpY2UgKnhlbl9iZV9nZXRfeGVuZGV2KGNvbnN0 IGNoYXIgKnR5cGUsIGludCBkb20sIGludCBkZXYsCiAgICAgfQogICAgIHFlbXVfc2V0X2Nsb2V4 ZWMoeGVuZXZ0Y2huX2ZkKHhlbmRldi0+ZXZ0Y2huZGV2KSk7CiAKLSAgICBpZiAob3BzLT5mbGFn cyAmIERFVk9QU19GTEFHX05FRURfR05UREVWKSB7Ci0gICAgICAgIHhlbmRldi0+Z250dGFiZGV2 ID0geGVuZ250dGFiX29wZW4oTlVMTCwgMCk7Ci0gICAgICAgIGlmICh4ZW5kZXYtPmdudHRhYmRl diA9PSBOVUxMKSB7Ci0gICAgICAgICAgICB4ZW5fcHZfcHJpbnRmKE5VTEwsIDAsICJjYW4ndCBv cGVuIGdudHRhYiBkZXZpY2VcbiIpOwotICAgICAgICAgICAgeGVuZXZ0Y2huX2Nsb3NlKHhlbmRl di0+ZXZ0Y2huZGV2KTsKLSAgICAgICAgICAgIHFkZXZfdW5wbHVnKERFVklDRSh4ZW5kZXYpLCBO VUxMKTsKLSAgICAgICAgICAgIHJldHVybiBOVUxMOwotICAgICAgICB9Ci0gICAgfSBlbHNlIHsK LSAgICAgICAgeGVuZGV2LT5nbnR0YWJkZXYgPSBOVUxMOwotICAgIH0KLQogICAgIHhlbl9wdl9p bnNlcnRfeGVuZGV2KHhlbmRldik7CiAKICAgICBpZiAoeGVuZGV2LT5vcHMtPmFsbG9jKSB7CkBA IC0zMjIsNiArNDA3LDE2IEBAIHN0YXRpYyBpbnQgeGVuX2JlX3RyeV9pbml0aWFsaXNlKHN0cnVj dCBYZW5EZXZpY2UgKnhlbmRldikKICAgICAgICAgfQogICAgIH0KIAorICAgIGlmICh4ZW5kZXYt Pm9wcy0+ZmxhZ3MgJiBERVZPUFNfRkxBR19ORUVEX0dOVERFVikgeworICAgICAgICB4ZW5kZXYt PmdudHRhYmRldiA9IHhlbmdudHRhYl9vcGVuKE5VTEwsIDApOworICAgICAgICBpZiAoeGVuZGV2 LT5nbnR0YWJkZXYgPT0gTlVMTCkgeworICAgICAgICAgICAgeGVuX3B2X3ByaW50ZihOVUxMLCAw LCAiY2FuJ3Qgb3BlbiBnbnR0YWIgZGV2aWNlXG4iKTsKKyAgICAgICAgICAgIHJldHVybiAtMTsK KyAgICAgICAgfQorICAgIH0gZWxzZSB7CisgICAgICAgIHhlbmRldi0+Z250dGFiZGV2ID0gTlVM TDsKKyAgICB9CisKICAgICBpZiAoeGVuZGV2LT5vcHMtPmluaXRpYWxpc2UpIHsKICAgICAgICAg cmMgPSB4ZW5kZXYtPm9wcy0+aW5pdGlhbGlzZSh4ZW5kZXYpOwogICAgIH0KQEAgLTM2OSw2ICs0 NjQsMTAgQEAgc3RhdGljIHZvaWQgeGVuX2JlX2Rpc2Nvbm5lY3Qoc3RydWN0IFhlbkRldmljZSAq eGVuZGV2LCBlbnVtIHhlbmJ1c19zdGF0ZSBzdGF0ZSkKICAgICAgICAgeGVuZGV2LT5vcHMtPmRp c2Nvbm5lY3QpIHsKICAgICAgICAgeGVuZGV2LT5vcHMtPmRpc2Nvbm5lY3QoeGVuZGV2KTsKICAg ICB9CisgICAgaWYgKHhlbmRldi0+Z250dGFiZGV2KSB7CisgICAgICAgIHhlbmdudHRhYl9jbG9z ZSh4ZW5kZXYtPmdudHRhYmRldik7CisgICAgICAgIHhlbmRldi0+Z250dGFiZGV2ID0gTlVMTDsK KyAgICB9CiAgICAgaWYgKHhlbmRldi0+YmVfc3RhdGUgIT0gc3RhdGUpIHsKICAgICAgICAgeGVu X2JlX3NldF9zdGF0ZSh4ZW5kZXYsIHN0YXRlKTsKICAgICB9CmRpZmYgLS1naXQgYS9pbmNsdWRl L2h3L3hlbi94ZW5fYmFja2VuZC5oIGIvaW5jbHVkZS9ody94ZW4veGVuX2JhY2tlbmQuaAppbmRl eCAzYTI3NjkyLi4yOWJmMWMzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2h3L3hlbi94ZW5fYmFja2Vu ZC5oCisrKyBiL2luY2x1ZGUvaHcveGVuL3hlbl9iYWNrZW5kLmgKQEAgLTQyLDYgKzQyLDM5IEBA IHZvaWQgeGVuX2JlX3JlZ2lzdGVyX2NvbW1vbih2b2lkKTsKIGludCB4ZW5fYmVfcmVnaXN0ZXIo Y29uc3QgY2hhciAqdHlwZSwgc3RydWN0IFhlbkRldk9wcyAqb3BzKTsKIGludCB4ZW5fYmVfc2V0 X3N0YXRlKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgZW51bSB4ZW5idXNfc3RhdGUgc3RhdGUp OwogaW50IHhlbl9iZV9iaW5kX2V2dGNobihzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpOwordm9p ZCB4ZW5fYmVfc2V0X21heF9ncmFudF9yZWZzKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBpbnQgbnJfcmVmcyk7Cit2b2lk ICp4ZW5fYmVfbWFwX2dyYW50X3JlZnMoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LCB1aW50MzJf dCAqcmVmcywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBpbnQgbnJfcmVm cywgaW50IHByb3QpOwordm9pZCB4ZW5fYmVfdW5tYXBfZ3JhbnRfcmVmcyhzdHJ1Y3QgWGVuRGV2 aWNlICp4ZW5kZXYsIHZvaWQgKnB0ciwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdW5z aWduZWQgaW50IG5yX3JlZnMpOworCit0eXBlZGVmIHN0cnVjdCBYZW5HcmFudENvcHlTZWdtZW50 IHsKKyAgICB1bmlvbiB7CisgICAgICAgIHZvaWQgKnZpcnQ7CisgICAgICAgIHN0cnVjdCB7Cisg ICAgICAgICAgICB1aW50MzJfdCByZWY7CisgICAgICAgICAgICBvZmZfdCBvZmZzZXQ7CisgICAg ICAgIH0gZm9yZWlnbjsKKyAgICB9IHNvdXJjZSwgZGVzdDsKKyAgICBzaXplX3QgbGVuOworfSBY ZW5HcmFudENvcHlTZWdtZW50OworCitpbnQgeGVuX2JlX2NvcHlfZ3JhbnRfcmVmcyhzdHJ1Y3Qg WGVuRGV2aWNlICp4ZW5kZXYsCisgICAgICAgICAgICAgICAgICAgICAgICAgICBib29sIHRvX2Rv bWFpbiwgWGVuR3JhbnRDb3B5U2VnbWVudCBzZWdzW10sCisgICAgICAgICAgICAgICAgICAgICAg ICAgICB1bnNpZ25lZCBpbnQgbnJfc2Vncyk7CisKK3N0YXRpYyBpbmxpbmUgdm9pZCAqeGVuX2Jl X21hcF9ncmFudF9yZWYoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB1aW50MzJfdCByZWYsIGludCBwcm90KQoreworICAg IHJldHVybiB4ZW5fYmVfbWFwX2dyYW50X3JlZnMoeGVuZGV2LCAmcmVmLCAxLCBwcm90KTsKK30K Kworc3RhdGljIGlubGluZSB2b2lkIHhlbl9iZV91bm1hcF9ncmFudF9yZWYoc3RydWN0IFhlbkRl dmljZSAqeGVuZGV2LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg dm9pZCAqcHRyKQoreworICAgIHJldHVybiB4ZW5fYmVfdW5tYXBfZ3JhbnRfcmVmcyh4ZW5kZXYs IHB0ciwgMSk7Cit9CiAKIC8qIGFjdHVhbCBiYWNrZW5kIGRyaXZlcnMgKi8KIGV4dGVybiBzdHJ1 Y3QgWGVuRGV2T3BzIHhlbl9jb25zb2xlX29wczsgICAgICAvKiB4ZW5fY29uc29sZS5jICAgICAq LwotLSAKMS45LjEKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9y ZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qub3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs