From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:35600) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bUaLW-0008Kg-6w for qemu-devel@nongnu.org; Tue, 02 Aug 2016 10:07:04 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1bUaLT-0005iz-9w for qemu-devel@nongnu.org; Tue, 02 Aug 2016 10:07:01 -0400 Received: from mail-lf0-x243.google.com ([2a00:1450:4010:c07::243]:34751) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bUaLS-0005iv-ST for qemu-devel@nongnu.org; Tue, 02 Aug 2016 10:06:59 -0400 Received: by mail-lf0-x243.google.com with SMTP id l69so10117553lfg.1 for ; Tue, 02 Aug 2016 07:06:58 -0700 (PDT) From: Paulina Szubarczyk Date: Tue, 2 Aug 2016 16:06:30 +0200 Message-Id: <1470146790-6168-3-git-send-email-paulinaszubarczyk@gmail.com> In-Reply-To: <1470146790-6168-1-git-send-email-paulinaszubarczyk@gmail.com> References: <1470146790-6168-1-git-send-email-paulinaszubarczyk@gmail.com> Subject: [Qemu-devel] [PATCH v4 2/2] qdisk - hw/block/xen_disk: grant copy implementation List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: xen-devel@lists.xenproject.org Cc: roger.pau@citrix.com, wei.liu2@citrix.com, ian.jackson@eu.citrix.com, david.vrabel@citrix.com, sstabellini@kernel.org, anthony.perard@citrix.com, qemu-devel@nongnu.org, Paulina Szubarczyk Copy data operated on during request from/to local buffers to/from the grant references. Before grant copy operation local buffers must be allocated what is done by calling ioreq_init_copy_buffers. For the 'read' operation, first, the qemu device invokes the read operation on local buffers and on the completion grant copy is called and buffers are freed. For the 'write' operation grant copy is performed before invoking write by qemu device. A new value 'feature_grant_copy' is added to recognize when the grant copy operation is supported by a guest. Signed-off-by: Paulina Szubarczyk --- Changes since v3: - qemu_memalign/qemu_free is used instead function allocating memory from xc. - removed the get_buffer function instead there is a direct call to qemu_memalign. - moved ioreq_copy for write operation to ioreq_runio_qemu_aio. - added struct xengnttab_grant_copy_segment_t and stub in xen_common.h for version of xen earlier then 480. - added checking for version 480 to configure. The test repeats all the operation that are required for version < 480 and checks if xengnttab_grant_copy() is implemented. * I did not change the way of testing if grant_copy operation is implemented. As far as I understand if the code from gnttab_unimp.c is used then the gnttab device is unavailable and the handler to gntdev would be invalid. But if the handler is valid then the ioctl should return operation unimplemented if the gntdev does not implement the operation. --- configure | 56 +++++++++++++++++ hw/block/xen_disk.c | 142 ++++++++++++++++++++++++++++++++++++++++++-- include/hw/xen/xen_common.h | 25 ++++++++ 3 files changed, 218 insertions(+), 5 deletions(-) diff --git a/configure b/configure index f57fcc6..b5bf7d4 100755 --- a/configure +++ b/configure @@ -1956,6 +1956,62 @@ EOF /* * If we have stable libs the we don't want the libxc compat * layers, regardless of what CFLAGS we may have been given. + * + * Also, check if xengnttab_grant_copy_segment_t is defined and + * grant copy operation is implemented. + */ +#undef XC_WANT_COMPAT_EVTCHN_API +#undef XC_WANT_COMPAT_GNTTAB_API +#undef XC_WANT_COMPAT_MAP_FOREIGN_API +#include +#include +#include +#include +#include +#include +#include +#if !defined(HVM_MAX_VCPUS) +# error HVM_MAX_VCPUS not defined +#endif +int main(void) { + xc_interface *xc = NULL; + xenforeignmemory_handle *xfmem; + xenevtchn_handle *xe; + xengnttab_handle *xg; + xen_domain_handle_t handle; + xengnttab_grant_copy_segment_t* seg = NULL; + + xs_daemon_open(); + + xc = xc_interface_open(0, 0, 0); + xc_hvm_set_mem_type(0, 0, HVMMEM_ram_ro, 0, 0); + xc_domain_add_to_physmap(0, 0, XENMAPSPACE_gmfn, 0, 0); + xc_hvm_inject_msi(xc, 0, 0xf0000000, 0x00000000); + xc_hvm_create_ioreq_server(xc, 0, HVM_IOREQSRV_BUFIOREQ_ATOMIC, NULL); + xc_domain_create(xc, 0, handle, 0, NULL, NULL); + + xfmem = xenforeignmemory_open(0, 0); + xenforeignmemory_map(xfmem, 0, 0, 0, 0, 0); + + xe = xenevtchn_open(0, 0); + xenevtchn_fd(xe); + + xg = xengnttab_open(0, 0); + xengnttab_map_grant_ref(xg, 0, 0, 0); + xengnttab_grant_copy(xg, 0, seg); + + return 0; +} +EOF + compile_prog "" "$xen_libs $xen_stable_libs" + then + xen_ctrl_version=480 + xen=yes + elif + cat > $TMPC <v.niov; i++) { + ioreq->page[i] = NULL; + } + + qemu_vfree(ioreq->pages); +} + +static int ioreq_init_copy_buffers(struct ioreq *ioreq) +{ + int i; + + if (ioreq->v.niov == 0) { + return 0; + } + + ioreq->pages = qemu_memalign(XC_PAGE_SIZE, ioreq->v.niov * XC_PAGE_SIZE); + if (!ioreq->pages) { + return -1; + } + + for (i = 0; i < ioreq->v.niov; i++) { + ioreq->page[i] = ioreq->pages + i * XC_PAGE_SIZE; + ioreq->v.iov[i].iov_base = ioreq->page[i]; + } + + return 0; +} + +static int ioreq_copy(struct ioreq *ioreq) +{ + xengnttab_handle *gnt = ioreq->blkdev->xendev.gnttabdev; + xengnttab_grant_copy_segment_t segs[BLKIF_MAX_SEGMENTS_PER_REQUEST]; + int i, count = 0, r, rc; + int64_t file_blk = ioreq->blkdev->file_blk; + + if (ioreq->v.niov == 0) { + return 0; + } + + count = ioreq->v.niov; + + for (i = 0; i < count; i++) { + + if (ioreq->req.operation == BLKIF_OP_READ) { + segs[i].flags = GNTCOPY_dest_gref; + segs[i].dest.foreign.ref = ioreq->refs[i]; + segs[i].dest.foreign.domid = ioreq->domids[i]; + segs[i].dest.foreign.offset = ioreq->req.seg[i].first_sect * file_blk; + segs[i].source.virt = ioreq->v.iov[i].iov_base; + } else { + segs[i].flags = GNTCOPY_source_gref; + segs[i].source.foreign.ref = ioreq->refs[i]; + segs[i].source.foreign.domid = ioreq->domids[i]; + segs[i].source.foreign.offset = ioreq->req.seg[i].first_sect * file_blk; + segs[i].dest.virt = ioreq->v.iov[i].iov_base; + } + segs[i].len = (ioreq->req.seg[i].last_sect + - ioreq->req.seg[i].first_sect + 1) * file_blk; + + } + + rc = xengnttab_grant_copy(gnt, count, segs); + + if (rc) { + xen_be_printf(&ioreq->blkdev->xendev, 0, + "failed to copy data %d\n", rc); + ioreq->aio_errors++; + return -1; + } else { + r = 0; + } + + for (i = 0; i < count; i++) { + if (segs[i].status != GNTST_okay) { + xen_be_printf(&ioreq->blkdev->xendev, 3, + "failed to copy data %d for gref %d, domid %d\n", rc, + ioreq->refs[i], ioreq->domids[i]); + ioreq->aio_errors++; + r = -1; + } + } + + return r; +} + static int ioreq_runio_qemu_aio(struct ioreq *ioreq); static void qemu_aio_complete(void *opaque, int ret) @@ -511,8 +603,29 @@ static void qemu_aio_complete(void *opaque, int ret) return; } + if (ioreq->blkdev->feature_grant_copy) { + switch (ioreq->req.operation) { + case BLKIF_OP_READ: + /* in case of failure ioreq->aio_errors is increased */ + ioreq_copy(ioreq); + free_buffers(ioreq); + break; + case BLKIF_OP_WRITE: + case BLKIF_OP_FLUSH_DISKCACHE: + if (!ioreq->req.nr_segments) { + break; + } + free_buffers(ioreq); + break; + default: + break; + } + } + ioreq->status = ioreq->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY; - ioreq_unmap(ioreq); + if (!ioreq->blkdev->feature_grant_copy) { + ioreq_unmap(ioreq); + } ioreq_finish(ioreq); switch (ioreq->req.operation) { case BLKIF_OP_WRITE: @@ -538,8 +651,20 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) { struct XenBlkDev *blkdev = ioreq->blkdev; - if (ioreq->req.nr_segments && ioreq_map(ioreq) == -1) { - goto err_no_map; + if (ioreq->blkdev->feature_grant_copy) { + ioreq_init_copy_buffers(ioreq); + if (ioreq->req.nr_segments && (ioreq->req.operation == BLKIF_OP_WRITE || + ioreq->req.operation == BLKIF_OP_FLUSH_DISKCACHE)) { + if (ioreq_copy(ioreq)) { + free_buffers(ioreq); + goto err; + } + } + + } else { + if (ioreq->req.nr_segments && ioreq_map(ioreq)) { + goto err; + } } ioreq->aio_inflight++; @@ -582,6 +707,9 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) } default: /* unknown operation (shouldn't happen -- parse catches this) */ + if (!ioreq->blkdev->feature_grant_copy) { + ioreq_unmap(ioreq); + } goto err; } @@ -590,8 +718,6 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) return 0; err: - ioreq_unmap(ioreq); -err_no_map: ioreq_finish(ioreq); ioreq->status = BLKIF_RSP_ERROR; return -1; @@ -1032,6 +1158,12 @@ static int blk_connect(struct XenDevice *xendev) xen_be_bind_evtchn(&blkdev->xendev); + blkdev->feature_grant_copy = + (xengnttab_grant_copy(blkdev->xendev.gnttabdev, 0, NULL) == 0); + + xen_be_printf(&blkdev->xendev, 3, "grant copy operation %s\n", + blkdev->feature_grant_copy ? "enabled" : "disabled"); + xen_be_printf(&blkdev->xendev, 1, "ok: proto %s, ring-ref %d, " "remote port %d, local port %d\n", blkdev->xendev.protocol, blkdev->ring_ref, diff --git a/include/hw/xen/xen_common.h b/include/hw/xen/xen_common.h index 640c31e..e80c61f 100644 --- a/include/hw/xen/xen_common.h +++ b/include/hw/xen/xen_common.h @@ -25,6 +25,31 @@ */ /* Xen 4.2 through 4.6 */ +#if CONFIG_XEN_CTRL_INTERFACE_VERSION < 480 + +struct xengnttab_grant_copy_segment { + union xengnttab_copy_ptr { + void *virt; + struct { + uint32_t ref; + uint16_t offset; + uint16_t domid; + } foreign; + } source, dest; + uint16_t len; + uint16_t flags; + int16_t status; +}; +typedef struct xengnttab_grant_copy_segment xengnttab_grant_copy_segment_t; + +static inline int xengnttab_grant_copy(xengnttab_handle *xgt, uint32_t count, + xengnttab_grant_copy_segment_t *segs) +{ + return -1; +} + +#endif + #if CONFIG_XEN_CTRL_INTERFACE_VERSION < 471 typedef xc_interface xenforeignmemory_handle; -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Paulina Szubarczyk Subject: [PATCH v4 2/2] qdisk - hw/block/xen_disk: grant copy implementation Date: Tue, 2 Aug 2016 16:06:30 +0200 Message-ID: <1470146790-6168-3-git-send-email-paulinaszubarczyk@gmail.com> References: <1470146790-6168-1-git-send-email-paulinaszubarczyk@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta14.messagelabs.com ([193.109.254.103]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1bUaLU-0001d8-Qk for xen-devel@lists.xenproject.org; Tue, 02 Aug 2016 14:07:01 +0000 Received: by mail-lf0-f66.google.com with SMTP id 33so10133830lfw.3 for ; Tue, 02 Aug 2016 07:06:58 -0700 (PDT) In-Reply-To: <1470146790-6168-1-git-send-email-paulinaszubarczyk@gmail.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: xen-devel@lists.xenproject.org Cc: sstabellini@kernel.org, wei.liu2@citrix.com, Paulina Szubarczyk , ian.jackson@eu.citrix.com, qemu-devel@nongnu.org, david.vrabel@citrix.com, anthony.perard@citrix.com, roger.pau@citrix.com List-Id: xen-devel@lists.xenproject.org Q29weSBkYXRhIG9wZXJhdGVkIG9uIGR1cmluZyByZXF1ZXN0IGZyb20vdG8gbG9jYWwgYnVmZmVy cyB0by9mcm9tCnRoZSBncmFudCByZWZlcmVuY2VzLgoKQmVmb3JlIGdyYW50IGNvcHkgb3BlcmF0 aW9uIGxvY2FsIGJ1ZmZlcnMgbXVzdCBiZSBhbGxvY2F0ZWQgd2hhdCBpcwpkb25lIGJ5IGNhbGxp bmcgaW9yZXFfaW5pdF9jb3B5X2J1ZmZlcnMuIEZvciB0aGUgJ3JlYWQnIG9wZXJhdGlvbiwKZmly c3QsIHRoZSBxZW11IGRldmljZSBpbnZva2VzIHRoZSByZWFkIG9wZXJhdGlvbiBvbiBsb2NhbCBi dWZmZXJzCmFuZCBvbiB0aGUgY29tcGxldGlvbiBncmFudCBjb3B5IGlzIGNhbGxlZCBhbmQgYnVm ZmVycyBhcmUgZnJlZWQuCkZvciB0aGUgJ3dyaXRlJyBvcGVyYXRpb24gZ3JhbnQgY29weSBpcyBw ZXJmb3JtZWQgYmVmb3JlIGludm9raW5nCndyaXRlIGJ5IHFlbXUgZGV2aWNlLgoKQSBuZXcgdmFs dWUgJ2ZlYXR1cmVfZ3JhbnRfY29weScgaXMgYWRkZWQgdG8gcmVjb2duaXplIHdoZW4gdGhlCmdy YW50IGNvcHkgb3BlcmF0aW9uIGlzIHN1cHBvcnRlZCBieSBhIGd1ZXN0LgoKU2lnbmVkLW9mZi1i eTogUGF1bGluYSBTenViYXJjenlrIDxwYXVsaW5hc3p1YmFyY3p5a0BnbWFpbC5jb20+Ci0tLQpD aGFuZ2VzIHNpbmNlIHYzOgotIHFlbXVfbWVtYWxpZ24vcWVtdV9mcmVlIGlzIHVzZWQgaW5zdGVh ZCBmdW5jdGlvbiBhbGxvY2F0aW5nCiAgbWVtb3J5IGZyb20geGMuCi0gcmVtb3ZlZCB0aGUgZ2V0 X2J1ZmZlciBmdW5jdGlvbiBpbnN0ZWFkIHRoZXJlIGlzIGEgZGlyZWN0IGNhbGwKICB0byBxZW11 X21lbWFsaWduLgotIG1vdmVkIGlvcmVxX2NvcHkgZm9yIHdyaXRlIG9wZXJhdGlvbiB0byBpb3Jl cV9ydW5pb19xZW11X2Fpby4KLSBhZGRlZCBzdHJ1Y3QgeGVuZ250dGFiX2dyYW50X2NvcHlfc2Vn bWVudF90IGFuZCBzdHViIGluCiAgeGVuX2NvbW1vbi5oIGZvciB2ZXJzaW9uIG9mIHhlbiBlYXJs aWVyIHRoZW4gNDgwLgotIGFkZGVkIGNoZWNraW5nIGZvciB2ZXJzaW9uIDQ4MCB0byBjb25maWd1 cmUuIFRoZSB0ZXN0IHJlcGVhdHMKICBhbGwgdGhlIG9wZXJhdGlvbiB0aGF0IGFyZSByZXF1aXJl ZCBmb3IgdmVyc2lvbiA8IDQ4MCBhbmQKICBjaGVja3MgaWYgeGVuZ250dGFiX2dyYW50X2NvcHko KSBpcyBpbXBsZW1lbnRlZC4KCiogSSBkaWQgbm90IGNoYW5nZSB0aGUgd2F5IG9mIHRlc3Rpbmcg aWYgZ3JhbnRfY29weSBvcGVyYXRpb24gaXMKICBpbXBsZW1lbnRlZC4gQXMgZmFyIGFzIEkgdW5k ZXJzdGFuZCBpZiB0aGUgY29kZSBmcm9tCiAgZ250dGFiX3VuaW1wLmMgaXMgdXNlZCB0aGVuIHRo ZSBnbnR0YWIgZGV2aWNlIGlzIHVuYXZhaWxhYmxlCiAgYW5kIHRoZSBoYW5kbGVyIHRvIGdudGRl diB3b3VsZCBiZSBpbnZhbGlkLiBCdXQgaWYgdGhlIGhhbmRsZXIKICBpcyB2YWxpZCB0aGVuIHRo ZSBpb2N0bCBzaG91bGQgcmV0dXJuIG9wZXJhdGlvbiB1bmltcGxlbWVudGVkCiAgaWYgdGhlIGdu dGRldiBkb2VzIG5vdCBpbXBsZW1lbnQgdGhlIG9wZXJhdGlvbi4KLS0tCiBjb25maWd1cmUgICAg ICAgICAgICAgICAgICAgfCAgNTYgKysrKysrKysrKysrKysrKysKIGh3L2Jsb2NrL3hlbl9kaXNr LmMgICAgICAgICB8IDE0MiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KystLQogaW5jbHVkZS9ody94ZW4veGVuX2NvbW1vbi5oIHwgIDI1ICsrKysrKysrCiAzIGZpbGVz IGNoYW5nZWQsIDIxOCBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L2NvbmZpZ3VyZSBiL2NvbmZpZ3VyZQppbmRleCBmNTdmY2M2Li5iNWJmN2Q0IDEwMDc1NQotLS0g YS9jb25maWd1cmUKKysrIGIvY29uZmlndXJlCkBAIC0xOTU2LDYgKzE5NTYsNjIgQEAgRU9GCiAv KgogICogSWYgd2UgaGF2ZSBzdGFibGUgbGlicyB0aGUgd2UgZG9uJ3Qgd2FudCB0aGUgbGlieGMg Y29tcGF0CiAgKiBsYXllcnMsIHJlZ2FyZGxlc3Mgb2Ygd2hhdCBDRkxBR1Mgd2UgbWF5IGhhdmUg YmVlbiBnaXZlbi4KKyAqCisgKiBBbHNvLCBjaGVjayBpZiB4ZW5nbnR0YWJfZ3JhbnRfY29weV9z ZWdtZW50X3QgaXMgZGVmaW5lZCBhbmQKKyAqIGdyYW50IGNvcHkgb3BlcmF0aW9uIGlzIGltcGxl bWVudGVkLgorICovCisjdW5kZWYgWENfV0FOVF9DT01QQVRfRVZUQ0hOX0FQSQorI3VuZGVmIFhD X1dBTlRfQ09NUEFUX0dOVFRBQl9BUEkKKyN1bmRlZiBYQ19XQU5UX0NPTVBBVF9NQVBfRk9SRUlH Tl9BUEkKKyNpbmNsdWRlIDx4ZW5jdHJsLmg+CisjaW5jbHVkZSA8eGVuc3RvcmUuaD4KKyNpbmNs dWRlIDx4ZW5ldnRjaG4uaD4KKyNpbmNsdWRlIDx4ZW5nbnR0YWIuaD4KKyNpbmNsdWRlIDx4ZW5m b3JlaWdubWVtb3J5Lmg+CisjaW5jbHVkZSA8c3RkaW50Lmg+CisjaW5jbHVkZSA8eGVuL2h2bS9o dm1faW5mb190YWJsZS5oPgorI2lmICFkZWZpbmVkKEhWTV9NQVhfVkNQVVMpCisjIGVycm9yIEhW TV9NQVhfVkNQVVMgbm90IGRlZmluZWQKKyNlbmRpZgoraW50IG1haW4odm9pZCkgeworICB4Y19p bnRlcmZhY2UgKnhjID0gTlVMTDsKKyAgeGVuZm9yZWlnbm1lbW9yeV9oYW5kbGUgKnhmbWVtOwor ICB4ZW5ldnRjaG5faGFuZGxlICp4ZTsKKyAgeGVuZ250dGFiX2hhbmRsZSAqeGc7CisgIHhlbl9k b21haW5faGFuZGxlX3QgaGFuZGxlOworICB4ZW5nbnR0YWJfZ3JhbnRfY29weV9zZWdtZW50X3Qq IHNlZyA9IE5VTEw7CisKKyAgeHNfZGFlbW9uX29wZW4oKTsKKworICB4YyA9IHhjX2ludGVyZmFj ZV9vcGVuKDAsIDAsIDApOworICB4Y19odm1fc2V0X21lbV90eXBlKDAsIDAsIEhWTU1FTV9yYW1f cm8sIDAsIDApOworICB4Y19kb21haW5fYWRkX3RvX3BoeXNtYXAoMCwgMCwgWEVOTUFQU1BBQ0Vf Z21mbiwgMCwgMCk7CisgIHhjX2h2bV9pbmplY3RfbXNpKHhjLCAwLCAweGYwMDAwMDAwLCAweDAw MDAwMDAwKTsKKyAgeGNfaHZtX2NyZWF0ZV9pb3JlcV9zZXJ2ZXIoeGMsIDAsIEhWTV9JT1JFUVNS Vl9CVUZJT1JFUV9BVE9NSUMsIE5VTEwpOworICB4Y19kb21haW5fY3JlYXRlKHhjLCAwLCBoYW5k bGUsIDAsIE5VTEwsIE5VTEwpOworCisgIHhmbWVtID0geGVuZm9yZWlnbm1lbW9yeV9vcGVuKDAs IDApOworICB4ZW5mb3JlaWdubWVtb3J5X21hcCh4Zm1lbSwgMCwgMCwgMCwgMCwgMCk7CisKKyAg eGUgPSB4ZW5ldnRjaG5fb3BlbigwLCAwKTsKKyAgeGVuZXZ0Y2huX2ZkKHhlKTsKKworICB4ZyA9 IHhlbmdudHRhYl9vcGVuKDAsIDApOworICB4ZW5nbnR0YWJfbWFwX2dyYW50X3JlZih4ZywgMCwg MCwgMCk7CisgIHhlbmdudHRhYl9ncmFudF9jb3B5KHhnLCAwLCBzZWcpOworCisgIHJldHVybiAw OworfQorRU9GCisgICAgICBjb21waWxlX3Byb2cgIiIgIiR4ZW5fbGlicyAkeGVuX3N0YWJsZV9s aWJzIgorICAgIHRoZW4KKyAgICB4ZW5fY3RybF92ZXJzaW9uPTQ4MAorICAgIHhlbj15ZXMKKyAg ZWxpZgorICAgICAgY2F0ID4gJFRNUEMgPDxFT0YgJiYKKy8qCisgKiBJZiB3ZSBoYXZlIHN0YWJs ZSBsaWJzIHRoZSB3ZSBkb24ndCB3YW50IHRoZSBsaWJ4YyBjb21wYXQKKyAqIGxheWVycywgcmVn YXJkbGVzcyBvZiB3aGF0IENGTEFHUyB3ZSBtYXkgaGF2ZSBiZWVuIGdpdmVuLgogICovCiAjdW5k ZWYgWENfV0FOVF9DT01QQVRfRVZUQ0hOX0FQSQogI3VuZGVmIFhDX1dBTlRfQ09NUEFUX0dOVFRB Ql9BUEkKZGlmZiAtLWdpdCBhL2h3L2Jsb2NrL3hlbl9kaXNrLmMgYi9ody9ibG9jay94ZW5fZGlz ay5jCmluZGV4IDNiOGFkMzMuLjJkZDE0NjQgMTAwNjQ0Ci0tLSBhL2h3L2Jsb2NrL3hlbl9kaXNr LmMKKysrIGIvaHcvYmxvY2sveGVuX2Rpc2suYwpAQCAtMTE5LDYgKzExOSw5IEBAIHN0cnVjdCBY ZW5CbGtEZXYgewogICAgIHVuc2lnbmVkIGludCAgICAgICAgcGVyc2lzdGVudF9nbnRfY291bnQ7 CiAgICAgdW5zaWduZWQgaW50ICAgICAgICBtYXhfZ3JhbnRzOwogCisgICAgLyogR3JhbnQgY29w eSAqLworICAgIGdib29sZWFuICAgICAgICAgICAgZmVhdHVyZV9ncmFudF9jb3B5OworCiAgICAg LyogcWVtdSBibG9jayBkcml2ZXIgKi8KICAgICBEcml2ZUluZm8gICAgICAgICAgICpkaW5mbzsK ICAgICBCbG9ja0JhY2tlbmQgICAgICAgICpibGs7CkBAIC00ODksNiArNDkyLDk1IEBAIHN0YXRp YyBpbnQgaW9yZXFfbWFwKHN0cnVjdCBpb3JlcSAqaW9yZXEpCiAgICAgcmV0dXJuIDA7CiB9CiAK K3N0YXRpYyB2b2lkIGZyZWVfYnVmZmVycyhzdHJ1Y3QgaW9yZXEgKmlvcmVxKQoreworICAgIGlu dCBpOworCisgICAgZm9yIChpID0gMDsgaSA8IGlvcmVxLT52Lm5pb3Y7IGkrKykgeworICAgICAg ICBpb3JlcS0+cGFnZVtpXSA9IE5VTEw7CisgICAgfQorCisgICAgcWVtdV92ZnJlZShpb3JlcS0+ cGFnZXMpOworfQorCitzdGF0aWMgaW50IGlvcmVxX2luaXRfY29weV9idWZmZXJzKHN0cnVjdCBp b3JlcSAqaW9yZXEpCit7CisgICAgaW50IGk7CisKKyAgICBpZiAoaW9yZXEtPnYubmlvdiA9PSAw KSB7CisgICAgICAgIHJldHVybiAwOworICAgIH0KKworICAgIGlvcmVxLT5wYWdlcyA9IHFlbXVf bWVtYWxpZ24oWENfUEFHRV9TSVpFLCBpb3JlcS0+di5uaW92ICogWENfUEFHRV9TSVpFKTsKKyAg ICBpZiAoIWlvcmVxLT5wYWdlcykgeworICAgICAgICByZXR1cm4gLTE7CisgICAgfQorCisgICAg Zm9yIChpID0gMDsgaSA8IGlvcmVxLT52Lm5pb3Y7IGkrKykgeworICAgICAgICBpb3JlcS0+cGFn ZVtpXSA9IGlvcmVxLT5wYWdlcyArIGkgKiBYQ19QQUdFX1NJWkU7CisgICAgICAgIGlvcmVxLT52 LmlvdltpXS5pb3ZfYmFzZSA9IGlvcmVxLT5wYWdlW2ldOworICAgIH0KKworICAgIHJldHVybiAw OworfQorCitzdGF0aWMgaW50IGlvcmVxX2NvcHkoc3RydWN0IGlvcmVxICppb3JlcSkKK3sKKyAg ICB4ZW5nbnR0YWJfaGFuZGxlICpnbnQgPSBpb3JlcS0+YmxrZGV2LT54ZW5kZXYuZ250dGFiZGV2 OworICAgIHhlbmdudHRhYl9ncmFudF9jb3B5X3NlZ21lbnRfdCBzZWdzW0JMS0lGX01BWF9TRUdN RU5UU19QRVJfUkVRVUVTVF07CisgICAgaW50IGksIGNvdW50ID0gMCwgciwgcmM7CisgICAgaW50 NjRfdCBmaWxlX2JsayA9IGlvcmVxLT5ibGtkZXYtPmZpbGVfYmxrOworCisgICAgaWYgKGlvcmVx LT52Lm5pb3YgPT0gMCkgeworICAgICAgICByZXR1cm4gMDsKKyAgICB9CisKKyAgICBjb3VudCA9 IGlvcmVxLT52Lm5pb3Y7CisKKyAgICBmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykgeworCisg ICAgICAgIGlmIChpb3JlcS0+cmVxLm9wZXJhdGlvbiA9PSBCTEtJRl9PUF9SRUFEKSB7CisgICAg ICAgICAgICBzZWdzW2ldLmZsYWdzID0gR05UQ09QWV9kZXN0X2dyZWY7CisgICAgICAgICAgICBz ZWdzW2ldLmRlc3QuZm9yZWlnbi5yZWYgPSBpb3JlcS0+cmVmc1tpXTsKKyAgICAgICAgICAgIHNl Z3NbaV0uZGVzdC5mb3JlaWduLmRvbWlkID0gaW9yZXEtPmRvbWlkc1tpXTsKKyAgICAgICAgICAg IHNlZ3NbaV0uZGVzdC5mb3JlaWduLm9mZnNldCA9IGlvcmVxLT5yZXEuc2VnW2ldLmZpcnN0X3Nl Y3QgKiBmaWxlX2JsazsKKyAgICAgICAgICAgIHNlZ3NbaV0uc291cmNlLnZpcnQgPSBpb3JlcS0+ di5pb3ZbaV0uaW92X2Jhc2U7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBzZWdzW2ld LmZsYWdzID0gR05UQ09QWV9zb3VyY2VfZ3JlZjsKKyAgICAgICAgICAgIHNlZ3NbaV0uc291cmNl LmZvcmVpZ24ucmVmID0gaW9yZXEtPnJlZnNbaV07CisgICAgICAgICAgICBzZWdzW2ldLnNvdXJj ZS5mb3JlaWduLmRvbWlkID0gaW9yZXEtPmRvbWlkc1tpXTsKKyAgICAgICAgICAgIHNlZ3NbaV0u c291cmNlLmZvcmVpZ24ub2Zmc2V0ID0gaW9yZXEtPnJlcS5zZWdbaV0uZmlyc3Rfc2VjdCAqIGZp bGVfYmxrOworICAgICAgICAgICAgc2Vnc1tpXS5kZXN0LnZpcnQgPSBpb3JlcS0+di5pb3ZbaV0u aW92X2Jhc2U7CisgICAgICAgIH0KKyAgICAgICAgc2Vnc1tpXS5sZW4gPSAoaW9yZXEtPnJlcS5z ZWdbaV0ubGFzdF9zZWN0CisgICAgICAgICAgICAgICAgICAgICAgIC0gaW9yZXEtPnJlcS5zZWdb aV0uZmlyc3Rfc2VjdCArIDEpICogZmlsZV9ibGs7CisKKyAgICB9CisKKyAgICByYyA9IHhlbmdu dHRhYl9ncmFudF9jb3B5KGdudCwgY291bnQsIHNlZ3MpOworCisgICAgaWYgKHJjKSB7CisgICAg ICAgIHhlbl9iZV9wcmludGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMCwKKyAgICAgICAgICAg ICAgICAgICAgICAiZmFpbGVkIHRvIGNvcHkgZGF0YSAlZFxuIiwgcmMpOworICAgICAgICBpb3Jl cS0+YWlvX2Vycm9ycysrOworICAgICAgICByZXR1cm4gLTE7CisgICAgfSBlbHNlIHsKKyAgICAg ICAgciA9IDA7CisgICAgfQorCisgICAgZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKKyAg ICAgICAgaWYgKHNlZ3NbaV0uc3RhdHVzICE9IEdOVFNUX29rYXkpIHsKKyAgICAgICAgICAgIHhl bl9iZV9wcmludGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMywKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgImZhaWxlZCB0byBjb3B5IGRhdGEgJWQgZm9yIGdyZWYgJWQsIGRvbWlkICVkXG4i LCByYywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgaW9yZXEtPnJlZnNbaV0sIGlvcmVxLT5k b21pZHNbaV0pOworICAgICAgICAgICAgaW9yZXEtPmFpb19lcnJvcnMrKzsKKyAgICAgICAgICAg IHIgPSAtMTsKKyAgICAgICAgfQorICAgIH0KKworICAgIHJldHVybiByOworfQorCiBzdGF0aWMg aW50IGlvcmVxX3J1bmlvX3FlbXVfYWlvKHN0cnVjdCBpb3JlcSAqaW9yZXEpOwogCiBzdGF0aWMg dm9pZCBxZW11X2Fpb19jb21wbGV0ZSh2b2lkICpvcGFxdWUsIGludCByZXQpCkBAIC01MTEsOCAr NjAzLDI5IEBAIHN0YXRpYyB2b2lkIHFlbXVfYWlvX2NvbXBsZXRlKHZvaWQgKm9wYXF1ZSwgaW50 IHJldCkKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAorICAgIGlmIChpb3JlcS0+YmxrZGV2LT5m ZWF0dXJlX2dyYW50X2NvcHkpIHsKKyAgICAgICAgc3dpdGNoIChpb3JlcS0+cmVxLm9wZXJhdGlv bikgeworICAgICAgICBjYXNlIEJMS0lGX09QX1JFQUQ6CisgICAgICAgICAgICAvKiBpbiBjYXNl IG9mIGZhaWx1cmUgaW9yZXEtPmFpb19lcnJvcnMgaXMgaW5jcmVhc2VkICovCisgICAgICAgICAg ICBpb3JlcV9jb3B5KGlvcmVxKTsKKyAgICAgICAgICAgIGZyZWVfYnVmZmVycyhpb3JlcSk7Cisg ICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBCTEtJRl9PUF9XUklURToKKyAgICAgICAg Y2FzZSBCTEtJRl9PUF9GTFVTSF9ESVNLQ0FDSEU6CisgICAgICAgICAgICBpZiAoIWlvcmVxLT5y ZXEubnJfc2VnbWVudHMpIHsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0K KyAgICAgICAgICAgIGZyZWVfYnVmZmVycyhpb3JlcSk7CisgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgfQorCiAg ICAgaW9yZXEtPnN0YXR1cyA9IGlvcmVxLT5haW9fZXJyb3JzID8gQkxLSUZfUlNQX0VSUk9SIDog QkxLSUZfUlNQX09LQVk7Ci0gICAgaW9yZXFfdW5tYXAoaW9yZXEpOworICAgIGlmICghaW9yZXEt PmJsa2Rldi0+ZmVhdHVyZV9ncmFudF9jb3B5KSB7CisgICAgICAgIGlvcmVxX3VubWFwKGlvcmVx KTsKKyAgICB9CiAgICAgaW9yZXFfZmluaXNoKGlvcmVxKTsKICAgICBzd2l0Y2ggKGlvcmVxLT5y ZXEub3BlcmF0aW9uKSB7CiAgICAgY2FzZSBCTEtJRl9PUF9XUklURToKQEAgLTUzOCw4ICs2NTEs MjAgQEAgc3RhdGljIGludCBpb3JlcV9ydW5pb19xZW11X2FpbyhzdHJ1Y3QgaW9yZXEgKmlvcmVx KQogewogICAgIHN0cnVjdCBYZW5CbGtEZXYgKmJsa2RldiA9IGlvcmVxLT5ibGtkZXY7CiAKLSAg ICBpZiAoaW9yZXEtPnJlcS5ucl9zZWdtZW50cyAmJiBpb3JlcV9tYXAoaW9yZXEpID09IC0xKSB7 Ci0gICAgICAgIGdvdG8gZXJyX25vX21hcDsKKyAgICBpZiAoaW9yZXEtPmJsa2Rldi0+ZmVhdHVy ZV9ncmFudF9jb3B5KSB7CisgICAgICAgIGlvcmVxX2luaXRfY29weV9idWZmZXJzKGlvcmVxKTsK KyAgICAgICAgaWYgKGlvcmVxLT5yZXEubnJfc2VnbWVudHMgJiYgKGlvcmVxLT5yZXEub3BlcmF0 aW9uID09IEJMS0lGX09QX1dSSVRFIHx8CisgICAgICAgICAgICBpb3JlcS0+cmVxLm9wZXJhdGlv biA9PSBCTEtJRl9PUF9GTFVTSF9ESVNLQ0FDSEUpKSB7CisgICAgICAgICAgICBpZiAoaW9yZXFf Y29weShpb3JlcSkpIHsKKyAgICAgICAgICAgICAgICBmcmVlX2J1ZmZlcnMoaW9yZXEpOworICAg ICAgICAgICAgICAgIGdvdG8gZXJyOworICAgICAgICAgICAgfQorICAgICAgICB9CisKKyAgICB9 IGVsc2UgeworICAgICAgICBpZiAoaW9yZXEtPnJlcS5ucl9zZWdtZW50cyAmJiBpb3JlcV9tYXAo aW9yZXEpKSB7CisgICAgICAgICAgICBnb3RvIGVycjsKKyAgICAgICAgfQogICAgIH0KIAogICAg IGlvcmVxLT5haW9faW5mbGlnaHQrKzsKQEAgLTU4Miw2ICs3MDcsOSBAQCBzdGF0aWMgaW50IGlv cmVxX3J1bmlvX3FlbXVfYWlvKHN0cnVjdCBpb3JlcSAqaW9yZXEpCiAgICAgfQogICAgIGRlZmF1 bHQ6CiAgICAgICAgIC8qIHVua25vd24gb3BlcmF0aW9uIChzaG91bGRuJ3QgaGFwcGVuIC0tIHBh cnNlIGNhdGNoZXMgdGhpcykgKi8KKyAgICAgICAgaWYgKCFpb3JlcS0+YmxrZGV2LT5mZWF0dXJl X2dyYW50X2NvcHkpIHsKKyAgICAgICAgICAgIGlvcmVxX3VubWFwKGlvcmVxKTsKKyAgICAgICAg fQogICAgICAgICBnb3RvIGVycjsKICAgICB9CiAKQEAgLTU5MCw4ICs3MTgsNiBAQCBzdGF0aWMg aW50IGlvcmVxX3J1bmlvX3FlbXVfYWlvKHN0cnVjdCBpb3JlcSAqaW9yZXEpCiAgICAgcmV0dXJu IDA7CiAKIGVycjoKLSAgICBpb3JlcV91bm1hcChpb3JlcSk7Ci1lcnJfbm9fbWFwOgogICAgIGlv cmVxX2ZpbmlzaChpb3JlcSk7CiAgICAgaW9yZXEtPnN0YXR1cyA9IEJMS0lGX1JTUF9FUlJPUjsK ICAgICByZXR1cm4gLTE7CkBAIC0xMDMyLDYgKzExNTgsMTIgQEAgc3RhdGljIGludCBibGtfY29u bmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCiAKICAgICB4ZW5fYmVfYmluZF9ldnRjaG4o JmJsa2Rldi0+eGVuZGV2KTsKIAorICAgIGJsa2Rldi0+ZmVhdHVyZV9ncmFudF9jb3B5ID0KKyAg ICAgICAgICAgICAgICAoeGVuZ250dGFiX2dyYW50X2NvcHkoYmxrZGV2LT54ZW5kZXYuZ250dGFi ZGV2LCAwLCBOVUxMKSA9PSAwKTsKKworICAgIHhlbl9iZV9wcmludGYoJmJsa2Rldi0+eGVuZGV2 LCAzLCAiZ3JhbnQgY29weSBvcGVyYXRpb24gJXNcbiIsCisgICAgICAgICAgICAgICAgICBibGtk ZXYtPmZlYXR1cmVfZ3JhbnRfY29weSA/ICJlbmFibGVkIiA6ICJkaXNhYmxlZCIpOworCiAgICAg eGVuX2JlX3ByaW50ZigmYmxrZGV2LT54ZW5kZXYsIDEsICJvazogcHJvdG8gJXMsIHJpbmctcmVm ICVkLCAiCiAgICAgICAgICAgICAgICAgICAicmVtb3RlIHBvcnQgJWQsIGxvY2FsIHBvcnQgJWRc biIsCiAgICAgICAgICAgICAgICAgICBibGtkZXYtPnhlbmRldi5wcm90b2NvbCwgYmxrZGV2LT5y aW5nX3JlZiwKZGlmZiAtLWdpdCBhL2luY2x1ZGUvaHcveGVuL3hlbl9jb21tb24uaCBiL2luY2x1 ZGUvaHcveGVuL3hlbl9jb21tb24uaAppbmRleCA2NDBjMzFlLi5lODBjNjFmIDEwMDY0NAotLS0g YS9pbmNsdWRlL2h3L3hlbi94ZW5fY29tbW9uLmgKKysrIGIvaW5jbHVkZS9ody94ZW4veGVuX2Nv bW1vbi5oCkBAIC0yNSw2ICsyNSwzMSBAQAogICovCiAKIC8qIFhlbiA0LjIgdGhyb3VnaCA0LjYg Ki8KKyNpZiBDT05GSUdfWEVOX0NUUkxfSU5URVJGQUNFX1ZFUlNJT04gPCA0ODAKKworc3RydWN0 IHhlbmdudHRhYl9ncmFudF9jb3B5X3NlZ21lbnQgeworICAgIHVuaW9uIHhlbmdudHRhYl9jb3B5 X3B0ciB7CisgICAgICAgIHZvaWQgKnZpcnQ7CisgICAgICAgIHN0cnVjdCB7CisgICAgICAgICAg ICB1aW50MzJfdCByZWY7CisgICAgICAgICAgICB1aW50MTZfdCBvZmZzZXQ7CisgICAgICAgICAg ICB1aW50MTZfdCBkb21pZDsKKyAgICAgICAgfSBmb3JlaWduOworICAgIH0gc291cmNlLCBkZXN0 OworICAgIHVpbnQxNl90IGxlbjsKKyAgICB1aW50MTZfdCBmbGFnczsKKyAgICBpbnQxNl90IHN0 YXR1czsKK307Cit0eXBlZGVmIHN0cnVjdCB4ZW5nbnR0YWJfZ3JhbnRfY29weV9zZWdtZW50IHhl bmdudHRhYl9ncmFudF9jb3B5X3NlZ21lbnRfdDsKKworc3RhdGljIGlubGluZSBpbnQgeGVuZ250 dGFiX2dyYW50X2NvcHkoeGVuZ250dGFiX2hhbmRsZSAqeGd0LCB1aW50MzJfdCBjb3VudCwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhlbmdudHRhYl9ncmFudF9jb3B5 X3NlZ21lbnRfdCAqc2VncykKK3sKKyAgICByZXR1cm4gLTE7Cit9CisKKyNlbmRpZgorCiAjaWYg Q09ORklHX1hFTl9DVFJMX0lOVEVSRkFDRV9WRVJTSU9OIDwgNDcxCiAKIHR5cGVkZWYgeGNfaW50 ZXJmYWNlIHhlbmZvcmVpZ25tZW1vcnlfaGFuZGxlOwotLSAKMS45LjEKCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0 Clhlbi1kZXZlbEBsaXN0cy54ZW4ub3JnCmh0dHBzOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK