From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:37801) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bWiSn-0004bt-Ts for qemu-devel@nongnu.org; Mon, 08 Aug 2016 07:11:23 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1bWiSi-0007ik-Re for qemu-devel@nongnu.org; Mon, 08 Aug 2016 07:11:20 -0400 Received: from smtp02.citrix.com ([66.165.176.63]:3317) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bWiSi-0007iV-KB for qemu-devel@nongnu.org; Mon, 08 Aug 2016 07:11:16 -0400 Date: Mon, 8 Aug 2016 13:11:11 +0200 From: Roger Pau =?iso-8859-1?Q?Monn=E9?= Message-ID: <20160808111103.psksqgqjs4rcxqjd@mac> References: <1470146790-6168-1-git-send-email-paulinaszubarczyk@gmail.com> <1470146790-6168-3-git-send-email-paulinaszubarczyk@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Disposition: inline In-Reply-To: <1470146790-6168-3-git-send-email-paulinaszubarczyk@gmail.com> Subject: Re: [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: Paulina Szubarczyk Cc: xen-devel@lists.xenproject.org, wei.liu2@citrix.com, ian.jackson@eu.citrix.com, david.vrabel@citrix.com, sstabellini@kernel.org, anthony.perard@citrix.com, qemu-devel@nongnu.org On Tue, Aug 02, 2016 at 04:06:30PM +0200, Paulina Szubarczyk wrote: > 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 Thanks, this is looking good, just a couple of minor comments below. > --- > 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); I don't think you need to check xengnttab_map_grant_ref, just xengnttab_grant_copy should be enough? Since xengnttab_grant_copy was added later you can assume xengnttab_map_grant_ref will be there. > + 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 < +/* > + * If we have stable libs the we don't want the libxc compat > + * layers, regardless of what CFLAGS we may have been given. > */ > #undef XC_WANT_COMPAT_EVTCHN_API > #undef XC_WANT_COMPAT_GNTTAB_API > diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c > index 3b8ad33..2dd1464 100644 > --- a/hw/block/xen_disk.c > +++ b/hw/block/xen_disk.c > @@ -119,6 +119,9 @@ struct XenBlkDev { > unsigned int persistent_gnt_count; > unsigned int max_grants; > > + /* Grant copy */ > + gboolean feature_grant_copy; > + > /* qemu block driver */ > DriveInfo *dinfo; > BlockBackend *blk; > @@ -489,6 +492,95 @@ static int ioreq_map(struct ioreq *ioreq) > return 0; > } > > +static void free_buffers(struct ioreq *ioreq) > +{ > + int i; > + > + for (i = 0; i < ioreq->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; Why do you need to initialize count to 0 here? A couple of lines below you inconditionally set it to ioreq->v.niov. > + 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; > + } Do you really need both r and rc here? I think you could just have rc and use it below also. > + 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) Roger. From mboxrd@z Thu Jan 1 00:00:00 1970 From: Roger Pau =?iso-8859-1?Q?Monn=E9?= Subject: Re: [PATCH v4 2/2] qdisk - hw/block/xen_disk: grant copy implementation Date: Mon, 8 Aug 2016 13:11:11 +0200 Message-ID: <20160808111103.psksqgqjs4rcxqjd@mac> References: <1470146790-6168-1-git-send-email-paulinaszubarczyk@gmail.com> <1470146790-6168-3-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.bemta6.messagelabs.com ([85.158.143.247]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1bWiSp-000806-4Y for xen-devel@lists.xenproject.org; Mon, 08 Aug 2016 11:11:23 +0000 Content-Disposition: inline In-Reply-To: <1470146790-6168-3-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: Paulina Szubarczyk Cc: sstabellini@kernel.org, wei.liu2@citrix.com, ian.jackson@eu.citrix.com, qemu-devel@nongnu.org, david.vrabel@citrix.com, anthony.perard@citrix.com, xen-devel@lists.xenproject.org List-Id: xen-devel@lists.xenproject.org T24gVHVlLCBBdWcgMDIsIDIwMTYgYXQgMDQ6MDY6MzBQTSArMDIwMCwgUGF1bGluYSBTenViYXJj enlrIHdyb3RlOgo+IENvcHkgZGF0YSBvcGVyYXRlZCBvbiBkdXJpbmcgcmVxdWVzdCBmcm9tL3Rv IGxvY2FsIGJ1ZmZlcnMgdG8vZnJvbQo+IHRoZSBncmFudCByZWZlcmVuY2VzLgo+IAo+IEJlZm9y ZSBncmFudCBjb3B5IG9wZXJhdGlvbiBsb2NhbCBidWZmZXJzIG11c3QgYmUgYWxsb2NhdGVkIHdo YXQgaXMKPiBkb25lIGJ5IGNhbGxpbmcgaW9yZXFfaW5pdF9jb3B5X2J1ZmZlcnMuIEZvciB0aGUg J3JlYWQnIG9wZXJhdGlvbiwKPiBmaXJzdCwgdGhlIHFlbXUgZGV2aWNlIGludm9rZXMgdGhlIHJl YWQgb3BlcmF0aW9uIG9uIGxvY2FsIGJ1ZmZlcnMKPiBhbmQgb24gdGhlIGNvbXBsZXRpb24gZ3Jh bnQgY29weSBpcyBjYWxsZWQgYW5kIGJ1ZmZlcnMgYXJlIGZyZWVkLgo+IEZvciB0aGUgJ3dyaXRl JyBvcGVyYXRpb24gZ3JhbnQgY29weSBpcyBwZXJmb3JtZWQgYmVmb3JlIGludm9raW5nCj4gd3Jp dGUgYnkgcWVtdSBkZXZpY2UuCj4gCj4gQSBuZXcgdmFsdWUgJ2ZlYXR1cmVfZ3JhbnRfY29weScg aXMgYWRkZWQgdG8gcmVjb2duaXplIHdoZW4gdGhlCj4gZ3JhbnQgY29weSBvcGVyYXRpb24gaXMg c3VwcG9ydGVkIGJ5IGEgZ3Vlc3QuCj4gCj4gU2lnbmVkLW9mZi1ieTogUGF1bGluYSBTenViYXJj enlrIDxwYXVsaW5hc3p1YmFyY3p5a0BnbWFpbC5jb20+CgpUaGFua3MsIHRoaXMgaXMgbG9va2lu ZyBnb29kLCBqdXN0IGEgY291cGxlIG9mIG1pbm9yIGNvbW1lbnRzIGJlbG93LgoKPiAtLS0KPiBD aGFuZ2VzIHNpbmNlIHYzOgo+IC0gcWVtdV9tZW1hbGlnbi9xZW11X2ZyZWUgaXMgdXNlZCBpbnN0 ZWFkIGZ1bmN0aW9uIGFsbG9jYXRpbmcKPiAgIG1lbW9yeSBmcm9tIHhjLgo+IC0gcmVtb3ZlZCB0 aGUgZ2V0X2J1ZmZlciBmdW5jdGlvbiBpbnN0ZWFkIHRoZXJlIGlzIGEgZGlyZWN0IGNhbGwKPiAg IHRvIHFlbXVfbWVtYWxpZ24uCj4gLSBtb3ZlZCBpb3JlcV9jb3B5IGZvciB3cml0ZSBvcGVyYXRp b24gdG8gaW9yZXFfcnVuaW9fcWVtdV9haW8uCj4gLSBhZGRlZCBzdHJ1Y3QgeGVuZ250dGFiX2dy YW50X2NvcHlfc2VnbWVudF90IGFuZCBzdHViIGluCj4gICB4ZW5fY29tbW9uLmggZm9yIHZlcnNp b24gb2YgeGVuIGVhcmxpZXIgdGhlbiA0ODAuCj4gLSBhZGRlZCBjaGVja2luZyBmb3IgdmVyc2lv biA0ODAgdG8gY29uZmlndXJlLiBUaGUgdGVzdCByZXBlYXRzCj4gICBhbGwgdGhlIG9wZXJhdGlv biB0aGF0IGFyZSByZXF1aXJlZCBmb3IgdmVyc2lvbiA8IDQ4MCBhbmQKPiAgIGNoZWNrcyBpZiB4 ZW5nbnR0YWJfZ3JhbnRfY29weSgpIGlzIGltcGxlbWVudGVkLgo+IAo+ICogSSBkaWQgbm90IGNo YW5nZSB0aGUgd2F5IG9mIHRlc3RpbmcgaWYgZ3JhbnRfY29weSBvcGVyYXRpb24gaXMKPiAgIGlt cGxlbWVudGVkLiBBcyBmYXIgYXMgSSB1bmRlcnN0YW5kIGlmIHRoZSBjb2RlIGZyb20KPiAgIGdu dHRhYl91bmltcC5jIGlzIHVzZWQgdGhlbiB0aGUgZ250dGFiIGRldmljZSBpcyB1bmF2YWlsYWJs ZQo+ICAgYW5kIHRoZSBoYW5kbGVyIHRvIGdudGRldiB3b3VsZCBiZSBpbnZhbGlkLiBCdXQgaWYg dGhlIGhhbmRsZXIKPiAgIGlzIHZhbGlkIHRoZW4gdGhlIGlvY3RsIHNob3VsZCByZXR1cm4gb3Bl cmF0aW9uIHVuaW1wbGVtZW50ZWQKPiAgIGlmIHRoZSBnbnRkZXYgZG9lcyBub3QgaW1wbGVtZW50 IHRoZSBvcGVyYXRpb24uCj4gLS0tCj4gIGNvbmZpZ3VyZSAgICAgICAgICAgICAgICAgICB8ICA1 NiArKysrKysrKysrKysrKysrKwo+ICBody9ibG9jay94ZW5fZGlzay5jICAgICAgICAgfCAxNDIg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0KPiAgaW5jbHVkZS9o dy94ZW4veGVuX2NvbW1vbi5oIHwgIDI1ICsrKysrKysrCj4gIDMgZmlsZXMgY2hhbmdlZCwgMjE4 IGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2NvbmZpZ3Vy ZSBiL2NvbmZpZ3VyZQo+IGluZGV4IGY1N2ZjYzYuLmI1YmY3ZDQgMTAwNzU1Cj4gLS0tIGEvY29u ZmlndXJlCj4gKysrIGIvY29uZmlndXJlCj4gQEAgLTE5NTYsNiArMTk1Niw2MiBAQCBFT0YKPiAg LyoKPiAgICogSWYgd2UgaGF2ZSBzdGFibGUgbGlicyB0aGUgd2UgZG9uJ3Qgd2FudCB0aGUgbGli eGMgY29tcGF0Cj4gICAqIGxheWVycywgcmVnYXJkbGVzcyBvZiB3aGF0IENGTEFHUyB3ZSBtYXkg aGF2ZSBiZWVuIGdpdmVuLgo+ICsgKgo+ICsgKiBBbHNvLCBjaGVjayBpZiB4ZW5nbnR0YWJfZ3Jh bnRfY29weV9zZWdtZW50X3QgaXMgZGVmaW5lZCBhbmQKPiArICogZ3JhbnQgY29weSBvcGVyYXRp b24gaXMgaW1wbGVtZW50ZWQuCj4gKyAqLwo+ICsjdW5kZWYgWENfV0FOVF9DT01QQVRfRVZUQ0hO X0FQSQo+ICsjdW5kZWYgWENfV0FOVF9DT01QQVRfR05UVEFCX0FQSQo+ICsjdW5kZWYgWENfV0FO VF9DT01QQVRfTUFQX0ZPUkVJR05fQVBJCj4gKyNpbmNsdWRlIDx4ZW5jdHJsLmg+Cj4gKyNpbmNs dWRlIDx4ZW5zdG9yZS5oPgo+ICsjaW5jbHVkZSA8eGVuZXZ0Y2huLmg+Cj4gKyNpbmNsdWRlIDx4 ZW5nbnR0YWIuaD4KPiArI2luY2x1ZGUgPHhlbmZvcmVpZ25tZW1vcnkuaD4KPiArI2luY2x1ZGUg PHN0ZGludC5oPgo+ICsjaW5jbHVkZSA8eGVuL2h2bS9odm1faW5mb190YWJsZS5oPgo+ICsjaWYg IWRlZmluZWQoSFZNX01BWF9WQ1BVUykKPiArIyBlcnJvciBIVk1fTUFYX1ZDUFVTIG5vdCBkZWZp bmVkCj4gKyNlbmRpZgo+ICtpbnQgbWFpbih2b2lkKSB7Cj4gKyAgeGNfaW50ZXJmYWNlICp4YyA9 IE5VTEw7Cj4gKyAgeGVuZm9yZWlnbm1lbW9yeV9oYW5kbGUgKnhmbWVtOwo+ICsgIHhlbmV2dGNo bl9oYW5kbGUgKnhlOwo+ICsgIHhlbmdudHRhYl9oYW5kbGUgKnhnOwo+ICsgIHhlbl9kb21haW5f aGFuZGxlX3QgaGFuZGxlOwo+ICsgIHhlbmdudHRhYl9ncmFudF9jb3B5X3NlZ21lbnRfdCogc2Vn ID0gTlVMTDsKPiArCj4gKyAgeHNfZGFlbW9uX29wZW4oKTsKPiArCj4gKyAgeGMgPSB4Y19pbnRl cmZhY2Vfb3BlbigwLCAwLCAwKTsKPiArICB4Y19odm1fc2V0X21lbV90eXBlKDAsIDAsIEhWTU1F TV9yYW1fcm8sIDAsIDApOwo+ICsgIHhjX2RvbWFpbl9hZGRfdG9fcGh5c21hcCgwLCAwLCBYRU5N QVBTUEFDRV9nbWZuLCAwLCAwKTsKPiArICB4Y19odm1faW5qZWN0X21zaSh4YywgMCwgMHhmMDAw MDAwMCwgMHgwMDAwMDAwMCk7Cj4gKyAgeGNfaHZtX2NyZWF0ZV9pb3JlcV9zZXJ2ZXIoeGMsIDAs IEhWTV9JT1JFUVNSVl9CVUZJT1JFUV9BVE9NSUMsIE5VTEwpOwo+ICsgIHhjX2RvbWFpbl9jcmVh dGUoeGMsIDAsIGhhbmRsZSwgMCwgTlVMTCwgTlVMTCk7Cj4gKwo+ICsgIHhmbWVtID0geGVuZm9y ZWlnbm1lbW9yeV9vcGVuKDAsIDApOwo+ICsgIHhlbmZvcmVpZ25tZW1vcnlfbWFwKHhmbWVtLCAw LCAwLCAwLCAwLCAwKTsKPiArCj4gKyAgeGUgPSB4ZW5ldnRjaG5fb3BlbigwLCAwKTsKPiArICB4 ZW5ldnRjaG5fZmQoeGUpOwo+ICsKPiArICB4ZyA9IHhlbmdudHRhYl9vcGVuKDAsIDApOwo+ICsg IHhlbmdudHRhYl9tYXBfZ3JhbnRfcmVmKHhnLCAwLCAwLCAwKTsKCkkgZG9uJ3QgdGhpbmsgeW91 IG5lZWQgdG8gY2hlY2sgeGVuZ250dGFiX21hcF9ncmFudF9yZWYsIGp1c3QgCnhlbmdudHRhYl9n cmFudF9jb3B5IHNob3VsZCBiZSBlbm91Z2g/IFNpbmNlIHhlbmdudHRhYl9ncmFudF9jb3B5IHdh cyBhZGRlZCAKbGF0ZXIgeW91IGNhbiBhc3N1bWUgeGVuZ250dGFiX21hcF9ncmFudF9yZWYgd2ls bCBiZSB0aGVyZS4KCj4gKyAgeGVuZ250dGFiX2dyYW50X2NvcHkoeGcsIDAsIHNlZyk7Cj4gKwo+ ICsgIHJldHVybiAwOwo+ICt9Cj4gK0VPRgo+ICsgICAgICBjb21waWxlX3Byb2cgIiIgIiR4ZW5f bGlicyAkeGVuX3N0YWJsZV9saWJzIgo+ICsgICAgdGhlbgo+ICsgICAgeGVuX2N0cmxfdmVyc2lv bj00ODAKPiArICAgIHhlbj15ZXMKPiArICBlbGlmCj4gKyAgICAgIGNhdCA+ICRUTVBDIDw8RU9G ICYmCj4gKy8qCj4gKyAqIElmIHdlIGhhdmUgc3RhYmxlIGxpYnMgdGhlIHdlIGRvbid0IHdhbnQg dGhlIGxpYnhjIGNvbXBhdAo+ICsgKiBsYXllcnMsIHJlZ2FyZGxlc3Mgb2Ygd2hhdCBDRkxBR1Mg d2UgbWF5IGhhdmUgYmVlbiBnaXZlbi4KPiAgICovCj4gICN1bmRlZiBYQ19XQU5UX0NPTVBBVF9F VlRDSE5fQVBJCj4gICN1bmRlZiBYQ19XQU5UX0NPTVBBVF9HTlRUQUJfQVBJCj4gZGlmZiAtLWdp dCBhL2h3L2Jsb2NrL3hlbl9kaXNrLmMgYi9ody9ibG9jay94ZW5fZGlzay5jCj4gaW5kZXggM2I4 YWQzMy4uMmRkMTQ2NCAxMDA2NDQKPiAtLS0gYS9ody9ibG9jay94ZW5fZGlzay5jCj4gKysrIGIv aHcvYmxvY2sveGVuX2Rpc2suYwo+IEBAIC0xMTksNiArMTE5LDkgQEAgc3RydWN0IFhlbkJsa0Rl diB7Cj4gICAgICB1bnNpZ25lZCBpbnQgICAgICAgIHBlcnNpc3RlbnRfZ250X2NvdW50Owo+ICAg ICAgdW5zaWduZWQgaW50ICAgICAgICBtYXhfZ3JhbnRzOwo+ICAKPiArICAgIC8qIEdyYW50IGNv cHkgKi8KPiArICAgIGdib29sZWFuICAgICAgICAgICAgZmVhdHVyZV9ncmFudF9jb3B5Owo+ICsK PiAgICAgIC8qIHFlbXUgYmxvY2sgZHJpdmVyICovCj4gICAgICBEcml2ZUluZm8gICAgICAgICAg ICpkaW5mbzsKPiAgICAgIEJsb2NrQmFja2VuZCAgICAgICAgKmJsazsKPiBAQCAtNDg5LDYgKzQ5 Miw5NSBAQCBzdGF0aWMgaW50IGlvcmVxX21hcChzdHJ1Y3QgaW9yZXEgKmlvcmVxKQo+ICAgICAg cmV0dXJuIDA7Cj4gIH0KPiAgCj4gK3N0YXRpYyB2b2lkIGZyZWVfYnVmZmVycyhzdHJ1Y3QgaW9y ZXEgKmlvcmVxKQo+ICt7Cj4gKyAgICBpbnQgaTsKPiArCj4gKyAgICBmb3IgKGkgPSAwOyBpIDwg aW9yZXEtPnYubmlvdjsgaSsrKSB7Cj4gKyAgICAgICAgaW9yZXEtPnBhZ2VbaV0gPSBOVUxMOwo+ ICsgICAgfQo+ICsKPiArICAgIHFlbXVfdmZyZWUoaW9yZXEtPnBhZ2VzKTsKPiArfQo+ICsKPiAr c3RhdGljIGludCBpb3JlcV9pbml0X2NvcHlfYnVmZmVycyhzdHJ1Y3QgaW9yZXEgKmlvcmVxKQo+ ICt7Cj4gKyAgICBpbnQgaTsKPiArCj4gKyAgICBpZiAoaW9yZXEtPnYubmlvdiA9PSAwKSB7Cj4g KyAgICAgICAgcmV0dXJuIDA7Cj4gKyAgICB9Cj4gKwo+ICsgICAgaW9yZXEtPnBhZ2VzID0gcWVt dV9tZW1hbGlnbihYQ19QQUdFX1NJWkUsIGlvcmVxLT52Lm5pb3YgKiBYQ19QQUdFX1NJWkUpOwo+ ICsgICAgaWYgKCFpb3JlcS0+cGFnZXMpIHsKPiArICAgICAgICByZXR1cm4gLTE7Cj4gKyAgICB9 Cj4gKwo+ICsgICAgZm9yIChpID0gMDsgaSA8IGlvcmVxLT52Lm5pb3Y7IGkrKykgewo+ICsgICAg ICAgIGlvcmVxLT5wYWdlW2ldID0gaW9yZXEtPnBhZ2VzICsgaSAqIFhDX1BBR0VfU0laRTsKPiAr ICAgICAgICBpb3JlcS0+di5pb3ZbaV0uaW92X2Jhc2UgPSBpb3JlcS0+cGFnZVtpXTsKPiArICAg IH0KPiArCj4gKyAgICByZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCBpb3JlcV9jb3B5 KHN0cnVjdCBpb3JlcSAqaW9yZXEpCj4gK3sKPiArICAgIHhlbmdudHRhYl9oYW5kbGUgKmdudCA9 IGlvcmVxLT5ibGtkZXYtPnhlbmRldi5nbnR0YWJkZXY7Cj4gKyAgICB4ZW5nbnR0YWJfZ3JhbnRf Y29weV9zZWdtZW50X3Qgc2Vnc1tCTEtJRl9NQVhfU0VHTUVOVFNfUEVSX1JFUVVFU1RdOwo+ICsg ICAgaW50IGksIGNvdW50ID0gMCwgciwgcmM7CgpXaHkgZG8geW91IG5lZWQgdG8gaW5pdGlhbGl6 ZSBjb3VudCB0byAwIGhlcmU/IEEgY291cGxlIG9mIGxpbmVzIGJlbG93IHlvdSAKaW5jb25kaXRp b25hbGx5IHNldCBpdCB0byBpb3JlcS0+di5uaW92LgoKPiArICAgIGludDY0X3QgZmlsZV9ibGsg PSBpb3JlcS0+YmxrZGV2LT5maWxlX2JsazsKPiArCj4gKyAgICBpZiAoaW9yZXEtPnYubmlvdiA9 PSAwKSB7Cj4gKyAgICAgICAgcmV0dXJuIDA7Cj4gKyAgICB9Cj4gKwo+ICsgICAgY291bnQgPSBp b3JlcS0+di5uaW92Owo+ICsKPiArICAgIGZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKSB7Cj4g Kwo+ICsgICAgICAgIGlmIChpb3JlcS0+cmVxLm9wZXJhdGlvbiA9PSBCTEtJRl9PUF9SRUFEKSB7 Cj4gKyAgICAgICAgICAgIHNlZ3NbaV0uZmxhZ3MgPSBHTlRDT1BZX2Rlc3RfZ3JlZjsKPiArICAg ICAgICAgICAgc2Vnc1tpXS5kZXN0LmZvcmVpZ24ucmVmID0gaW9yZXEtPnJlZnNbaV07Cj4gKyAg ICAgICAgICAgIHNlZ3NbaV0uZGVzdC5mb3JlaWduLmRvbWlkID0gaW9yZXEtPmRvbWlkc1tpXTsK PiArICAgICAgICAgICAgc2Vnc1tpXS5kZXN0LmZvcmVpZ24ub2Zmc2V0ID0gaW9yZXEtPnJlcS5z ZWdbaV0uZmlyc3Rfc2VjdCAqIGZpbGVfYmxrOwo+ICsgICAgICAgICAgICBzZWdzW2ldLnNvdXJj ZS52aXJ0ID0gaW9yZXEtPnYuaW92W2ldLmlvdl9iYXNlOwo+ICsgICAgICAgIH0gZWxzZSB7Cj4g KyAgICAgICAgICAgIHNlZ3NbaV0uZmxhZ3MgPSBHTlRDT1BZX3NvdXJjZV9ncmVmOwo+ICsgICAg ICAgICAgICBzZWdzW2ldLnNvdXJjZS5mb3JlaWduLnJlZiA9IGlvcmVxLT5yZWZzW2ldOwo+ICsg ICAgICAgICAgICBzZWdzW2ldLnNvdXJjZS5mb3JlaWduLmRvbWlkID0gaW9yZXEtPmRvbWlkc1tp XTsKPiArICAgICAgICAgICAgc2Vnc1tpXS5zb3VyY2UuZm9yZWlnbi5vZmZzZXQgPSBpb3JlcS0+ cmVxLnNlZ1tpXS5maXJzdF9zZWN0ICogZmlsZV9ibGs7Cj4gKyAgICAgICAgICAgIHNlZ3NbaV0u ZGVzdC52aXJ0ID0gaW9yZXEtPnYuaW92W2ldLmlvdl9iYXNlOwo+ICsgICAgICAgIH0KPiArICAg ICAgICBzZWdzW2ldLmxlbiA9IChpb3JlcS0+cmVxLnNlZ1tpXS5sYXN0X3NlY3QKPiArICAgICAg ICAgICAgICAgICAgICAgICAtIGlvcmVxLT5yZXEuc2VnW2ldLmZpcnN0X3NlY3QgKyAxKSAqIGZp bGVfYmxrOwo+ICsKPiArICAgIH0KPiArCj4gKyAgICByYyA9IHhlbmdudHRhYl9ncmFudF9jb3B5 KGdudCwgY291bnQsIHNlZ3MpOwo+ICsKPiArICAgIGlmIChyYykgewo+ICsgICAgICAgIHhlbl9i ZV9wcmludGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMCwKPiArICAgICAgICAgICAgICAgICAg ICAgICJmYWlsZWQgdG8gY29weSBkYXRhICVkXG4iLCByYyk7Cj4gKyAgICAgICAgaW9yZXEtPmFp b19lcnJvcnMrKzsKPiArICAgICAgICByZXR1cm4gLTE7Cj4gKyAgICB9IGVsc2Ugewo+ICsgICAg ICAgIHIgPSAwOwo+ICsgICAgfQoKRG8geW91IHJlYWxseSBuZWVkIGJvdGggciBhbmQgcmMgaGVy ZT8gSSB0aGluayB5b3UgY291bGQganVzdCBoYXZlIHJjIGFuZCAKdXNlIGl0IGJlbG93IGFsc28u Cgo+ICsgICAgZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKPiArICAgICAgICBpZiAoc2Vn c1tpXS5zdGF0dXMgIT0gR05UU1Rfb2theSkgewo+ICsgICAgICAgICAgICB4ZW5fYmVfcHJpbnRm KCZpb3JlcS0+YmxrZGV2LT54ZW5kZXYsIDMsCj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAg ImZhaWxlZCB0byBjb3B5IGRhdGEgJWQgZm9yIGdyZWYgJWQsIGRvbWlkICVkXG4iLCByYywKPiAr ICAgICAgICAgICAgICAgICAgICAgICAgICBpb3JlcS0+cmVmc1tpXSwgaW9yZXEtPmRvbWlkc1tp XSk7Cj4gKyAgICAgICAgICAgIGlvcmVxLT5haW9fZXJyb3JzKys7Cj4gKyAgICAgICAgICAgIHIg PSAtMTsKPiArICAgICAgICB9Cj4gKyAgICB9Cj4gKwo+ICsgICAgcmV0dXJuIHI7Cj4gK30KPiAr Cj4gIHN0YXRpYyBpbnQgaW9yZXFfcnVuaW9fcWVtdV9haW8oc3RydWN0IGlvcmVxICppb3JlcSk7 Cj4gIAo+ICBzdGF0aWMgdm9pZCBxZW11X2Fpb19jb21wbGV0ZSh2b2lkICpvcGFxdWUsIGludCBy ZXQpCgpSb2dlci4KCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cHM6 Ly9saXN0cy54ZW4ub3JnL3hlbi1kZXZlbAo=