From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:50562) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1fEbBq-00053F-ET for qemu-devel@nongnu.org; Fri, 04 May 2018 09:56:07 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1fEbBo-0003aR-Cb for qemu-devel@nongnu.org; Fri, 04 May 2018 09:56:02 -0400 From: Paul Durrant Date: Fri, 4 May 2018 14:55:31 +0100 Message-ID: <1525442134-20488-6-git-send-email-paul.durrant@citrix.com> In-Reply-To: <1525442134-20488-1-git-send-email-paul.durrant@citrix.com> References: <1525442134-20488-1-git-send-email-paul.durrant@citrix.com> MIME-Version: 1.0 Content-Type: text/plain Subject: [Qemu-devel] [PATCH v2 5/8] xen_disk: remove use of grant map/unmap List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: xen-devel@lists.xenproject.org, qemu-block@nongnu.org, qemu-devel@nongnu.org Cc: Paul Durrant , Stefano Stabellini , Anthony Perard , Kevin Wolf , Max Reitz Now that the (native or emulated) xen_be_copy_grant_refs() helper is always available, the xen_disk code can be significantly simplified by removing direct use of grant map and unmap operations. Signed-off-by: Paul Durrant --- Cc: Stefano Stabellini Cc: Anthony Perard Cc: Kevin Wolf Cc: Max Reitz v2: - Squashed in separate patche removing persistent grant use - Re-based --- hw/block/xen_disk.c | 370 ++++------------------------------------------------ 1 file changed, 25 insertions(+), 345 deletions(-) diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c index 66ed2b7..28be8b6 100644 --- a/hw/block/xen_disk.c +++ b/hw/block/xen_disk.c @@ -36,27 +36,9 @@ /* ------------------------------------------------------------- */ -static int batch_maps = 0; - -/* ------------------------------------------------------------- */ - #define BLOCK_SIZE 512 #define IOCB_COUNT (BLKIF_MAX_SEGMENTS_PER_REQUEST + 2) -struct PersistentGrant { - void *page; - struct XenBlkDev *blkdev; -}; - -typedef struct PersistentGrant PersistentGrant; - -struct PersistentRegion { - void *addr; - int num; -}; - -typedef struct PersistentRegion PersistentRegion; - struct ioreq { blkif_request_t req; int16_t status; @@ -65,14 +47,11 @@ struct ioreq { off_t start; QEMUIOVector v; int presync; - uint8_t mapped; /* grant mapping */ uint32_t refs[BLKIF_MAX_SEGMENTS_PER_REQUEST]; - int prot; void *page[BLKIF_MAX_SEGMENTS_PER_REQUEST]; void *pages; - int num_unmap; /* aio status */ int aio_inflight; @@ -103,7 +82,6 @@ struct XenBlkDev { int protocol; blkif_back_rings_t rings; int more_work; - int cnt_map; /* request lists */ QLIST_HEAD(inflight_head, ioreq) inflight; @@ -114,13 +92,7 @@ struct XenBlkDev { int requests_finished; unsigned int max_requests; - /* Persistent grants extension */ gboolean feature_discard; - gboolean feature_persistent; - GTree *persistent_gnts; - GSList *persistent_regions; - unsigned int persistent_gnt_count; - unsigned int max_grants; /* qemu block driver */ DriveInfo *dinfo; @@ -139,10 +111,8 @@ static void ioreq_reset(struct ioreq *ioreq) ioreq->status = 0; ioreq->start = 0; ioreq->presync = 0; - ioreq->mapped = 0; memset(ioreq->refs, 0, sizeof(ioreq->refs)); - ioreq->prot = 0; memset(ioreq->page, 0, sizeof(ioreq->page)); ioreq->pages = NULL; @@ -156,37 +126,6 @@ static void ioreq_reset(struct ioreq *ioreq) qemu_iovec_reset(&ioreq->v); } -static gint int_cmp(gconstpointer a, gconstpointer b, gpointer user_data) -{ - uint ua = GPOINTER_TO_UINT(a); - uint ub = GPOINTER_TO_UINT(b); - return (ua > ub) - (ua < ub); -} - -static void destroy_grant(gpointer pgnt) -{ - PersistentGrant *grant = pgnt; - struct XenBlkDev *blkdev = grant->blkdev; - struct XenDevice *xendev = &blkdev->xendev; - - xen_be_unmap_grant_ref(xendev, grant->page); - grant->blkdev->persistent_gnt_count--; - xen_pv_printf(xendev, 3, "unmapped grant %p\n", grant->page); - g_free(grant); -} - -static void remove_persistent_region(gpointer data, gpointer dev) -{ - PersistentRegion *region = data; - struct XenBlkDev *blkdev = dev; - struct XenDevice *xendev = &blkdev->xendev; - - xen_be_unmap_grant_refs(xendev, region->addr, region->num); - xen_pv_printf(xendev, 3, "unmapped grant region %p with %d pages\n", - region->addr, region->num); - g_free(region); -} - static struct ioreq *ioreq_start(struct XenBlkDev *blkdev) { struct ioreq *ioreq = NULL; @@ -254,7 +193,6 @@ static int ioreq_parse(struct ioreq *ioreq) ioreq->req.handle, ioreq->req.id, ioreq->req.sector_number); switch (ioreq->req.operation) { case BLKIF_OP_READ: - ioreq->prot = PROT_WRITE; /* to memory */ break; case BLKIF_OP_FLUSH_DISKCACHE: ioreq->presync = 1; @@ -263,7 +201,6 @@ static int ioreq_parse(struct ioreq *ioreq) } /* fall through */ case BLKIF_OP_WRITE: - ioreq->prot = PROT_READ; /* from memory */ break; case BLKIF_OP_DISCARD: return 0; @@ -310,173 +247,6 @@ err: return -1; } -static void ioreq_unmap(struct ioreq *ioreq) -{ - struct XenBlkDev *blkdev = ioreq->blkdev; - struct XenDevice *xendev = &blkdev->xendev; - int i; - - if (ioreq->num_unmap == 0 || ioreq->mapped == 0) { - return; - } - if (batch_maps) { - if (!ioreq->pages) { - return; - } - xen_be_unmap_grant_refs(xendev, ioreq->pages, ioreq->num_unmap); - ioreq->blkdev->cnt_map -= ioreq->num_unmap; - ioreq->pages = NULL; - } else { - for (i = 0; i < ioreq->num_unmap; i++) { - if (!ioreq->page[i]) { - continue; - } - xen_be_unmap_grant_ref(xendev, ioreq->page[i]); - ioreq->blkdev->cnt_map--; - ioreq->page[i] = NULL; - } - } - ioreq->mapped = 0; -} - -static int ioreq_map(struct ioreq *ioreq) -{ - struct XenBlkDev *blkdev = ioreq->blkdev; - struct XenDevice *xendev = &blkdev->xendev; - uint32_t refs[BLKIF_MAX_SEGMENTS_PER_REQUEST]; - void *page[BLKIF_MAX_SEGMENTS_PER_REQUEST]; - int i, j, new_maps = 0; - PersistentGrant *grant; - PersistentRegion *region; - /* refs variable will contain the information necessary - * to map the grants that are needed to fulfill this request. - * - * After mapping the needed grants, the page array will contain the - * memory address of each granted page in the order specified in ioreq - * (disregarding if it's a persistent grant or not). - */ - - if (ioreq->v.niov == 0 || ioreq->mapped == 1) { - return 0; - } - if (ioreq->blkdev->feature_persistent) { - for (i = 0; i < ioreq->v.niov; i++) { - grant = g_tree_lookup(ioreq->blkdev->persistent_gnts, - GUINT_TO_POINTER(ioreq->refs[i])); - - if (grant != NULL) { - page[i] = grant->page; - xen_pv_printf(&ioreq->blkdev->xendev, 3, - "using persistent-grant %" PRIu32 "\n", - ioreq->refs[i]); - } else { - /* Add the grant to the list of grants that - * should be mapped - */ - refs[new_maps] = ioreq->refs[i]; - page[i] = NULL; - new_maps++; - } - } - /* Set the protection to RW, since grants may be reused later - * with a different protection than the one needed for this request - */ - ioreq->prot = PROT_WRITE | PROT_READ; - } else { - /* All grants in the request should be mapped */ - memcpy(refs, ioreq->refs, sizeof(refs)); - memset(page, 0, sizeof(page)); - new_maps = ioreq->v.niov; - } - - if (batch_maps && new_maps) { - ioreq->pages = xen_be_map_grant_refs(xendev, refs, new_maps, - ioreq->prot); - if (ioreq->pages == NULL) { - xen_pv_printf(&ioreq->blkdev->xendev, 0, - "can't map %d grant refs (%s, %d maps)\n", - new_maps, strerror(errno), ioreq->blkdev->cnt_map); - return -1; - } - for (i = 0, j = 0; i < ioreq->v.niov; i++) { - if (page[i] == NULL) { - page[i] = ioreq->pages + (j++) * XC_PAGE_SIZE; - } - } - ioreq->blkdev->cnt_map += new_maps; - } else if (new_maps) { - for (i = 0; i < new_maps; i++) { - ioreq->page[i] = xen_be_map_grant_ref(xendev, refs[i], - ioreq->prot); - if (ioreq->page[i] == NULL) { - xen_pv_printf(&ioreq->blkdev->xendev, 0, - "can't map grant ref %d (%s, %d maps)\n", - refs[i], strerror(errno), ioreq->blkdev->cnt_map); - ioreq->mapped = 1; - ioreq_unmap(ioreq); - return -1; - } - ioreq->blkdev->cnt_map++; - } - for (i = 0, j = 0; i < ioreq->v.niov; i++) { - if (page[i] == NULL) { - page[i] = ioreq->page[j++]; - } - } - } - if (ioreq->blkdev->feature_persistent && new_maps != 0 && - (!batch_maps || (ioreq->blkdev->persistent_gnt_count + new_maps <= - ioreq->blkdev->max_grants))) { - /* - * If we are using persistent grants and batch mappings only - * add the new maps to the list of persistent grants if the whole - * area can be persistently mapped. - */ - if (batch_maps) { - region = g_malloc0(sizeof(*region)); - region->addr = ioreq->pages; - region->num = new_maps; - ioreq->blkdev->persistent_regions = g_slist_append( - ioreq->blkdev->persistent_regions, - region); - } - while ((ioreq->blkdev->persistent_gnt_count < ioreq->blkdev->max_grants) - && new_maps) { - /* Go through the list of newly mapped grants and add as many - * as possible to the list of persistently mapped grants. - * - * Since we start at the end of ioreq->page(s), we only need - * to decrease new_maps to prevent this granted pages from - * being unmapped in ioreq_unmap. - */ - grant = g_malloc0(sizeof(*grant)); - new_maps--; - if (batch_maps) { - grant->page = ioreq->pages + (new_maps) * XC_PAGE_SIZE; - } else { - grant->page = ioreq->page[new_maps]; - } - grant->blkdev = ioreq->blkdev; - xen_pv_printf(&ioreq->blkdev->xendev, 3, - "adding grant %" PRIu32 " page: %p\n", - refs[new_maps], grant->page); - g_tree_insert(ioreq->blkdev->persistent_gnts, - GUINT_TO_POINTER(refs[new_maps]), - grant); - ioreq->blkdev->persistent_gnt_count++; - } - assert(!batch_maps || new_maps == 0); - } - for (i = 0; i < ioreq->v.niov; i++) { - ioreq->v.iov[i].iov_base += (uintptr_t)page[i]; - } - ioreq->mapped = 1; - ioreq->num_unmap = new_maps; - return 0; -} - -#if CONFIG_XEN_CTRL_INTERFACE_VERSION >= 40800 - static void ioreq_free_copy_buffers(struct ioreq *ioreq) { int i; @@ -546,22 +316,6 @@ static int ioreq_grant_copy(struct ioreq *ioreq) return rc; } -#else -static void ioreq_free_copy_buffers(struct ioreq *ioreq) -{ - abort(); -} - -static int ioreq_init_copy_buffers(struct ioreq *ioreq) -{ - abort(); -} - -static int ioreq_grant_copy(struct ioreq *ioreq) -{ - abort(); -} -#endif static int ioreq_runio_qemu_aio(struct ioreq *ioreq); @@ -588,32 +342,28 @@ static void qemu_aio_complete(void *opaque, int ret) goto done; } - if (xen_feature_grant_copy) { - switch (ioreq->req.operation) { - case BLKIF_OP_READ: - /* in case of failure ioreq->aio_errors is increased */ - if (ret == 0) { - ioreq_grant_copy(ioreq); - } - ioreq_free_copy_buffers(ioreq); - break; - case BLKIF_OP_WRITE: - case BLKIF_OP_FLUSH_DISKCACHE: - if (!ioreq->req.nr_segments) { - break; - } - ioreq_free_copy_buffers(ioreq); - break; - default: + switch (ioreq->req.operation) { + case BLKIF_OP_READ: + /* in case of failure ioreq->aio_errors is increased */ + if (ret == 0) { + ioreq_grant_copy(ioreq); + } + ioreq_free_copy_buffers(ioreq); + break; + case BLKIF_OP_WRITE: + case BLKIF_OP_FLUSH_DISKCACHE: + if (!ioreq->req.nr_segments) { break; } + ioreq_free_copy_buffers(ioreq); + break; + default: + break; } ioreq->status = ioreq->aio_errors ? BLKIF_RSP_ERROR : BLKIF_RSP_OKAY; - if (!xen_feature_grant_copy) { - ioreq_unmap(ioreq); - } ioreq_finish(ioreq); + switch (ioreq->req.operation) { case BLKIF_OP_WRITE: case BLKIF_OP_FLUSH_DISKCACHE: @@ -673,18 +423,13 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) { struct XenBlkDev *blkdev = ioreq->blkdev; - if (xen_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) && - ioreq_grant_copy(ioreq)) { - ioreq_free_copy_buffers(ioreq); - goto err; - } - } else { - if (ioreq->req.nr_segments && ioreq_map(ioreq)) { - goto err; - } + ioreq_init_copy_buffers(ioreq); + if (ioreq->req.nr_segments && + (ioreq->req.operation == BLKIF_OP_WRITE || + ioreq->req.operation == BLKIF_OP_FLUSH_DISKCACHE) && + ioreq_grant_copy(ioreq)) { + ioreq_free_copy_buffers(ioreq); + goto err; } ioreq->aio_inflight++; @@ -725,9 +470,6 @@ static int ioreq_runio_qemu_aio(struct ioreq *ioreq) } default: /* unknown operation (shouldn't happen -- parse catches this) */ - if (!xen_feature_grant_copy) { - ioreq_unmap(ioreq); - } goto err; } @@ -913,10 +655,6 @@ static void blk_alloc(struct XenDevice *xendev) blkdev->ctx = iothread_get_aio_context(blkdev->iothread); blkdev->bh = aio_bh_new(blkdev->ctx, blk_bh, blkdev); - - if (xen_mode != XEN_EMULATE) { - batch_maps = 1; - } } static void blk_parse_discard(struct XenBlkDev *blkdev) @@ -999,15 +737,10 @@ static int blk_init(struct XenDevice *xendev) blkdev->file_blk = BLOCK_SIZE; - xen_pv_printf(&blkdev->xendev, 3, "grant copy operation %s\n", - xen_feature_grant_copy ? "enabled" : "disabled"); - /* fill info * blk_connect supplies sector-size and sectors */ xenstore_write_be_int(&blkdev->xendev, "feature-flush-cache", 1); - xenstore_write_be_int(&blkdev->xendev, "feature-persistent", - !xen_feature_grant_copy); xenstore_write_be_int(&blkdev->xendev, "info", info); xenstore_write_be_int(&blkdev->xendev, "max-ring-page-order", @@ -1034,19 +767,10 @@ out_error: return -1; } -/* - * We need to account for the grant allocations requiring contiguous - * chunks; the worst case number would be - * max_req * max_seg + (max_req - 1) * (max_seg - 1) + 1, - * but in order to keep things simple just use - * 2 * max_req * max_seg. - */ -#define MAX_GRANTS(max_req, max_seg) (2 * (max_req) * (max_seg)) - static int blk_connect(struct XenDevice *xendev) { struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); - int pers, index, qflags; + int index, qflags; bool readonly = true; bool writethrough = true; int order, ring_ref; @@ -1168,11 +892,6 @@ static int blk_connect(struct XenDevice *xendev) &blkdev->xendev.remote_port) == -1) { return -1; } - if (xenstore_read_fe_int(&blkdev->xendev, "feature-persistent", &pers)) { - blkdev->feature_persistent = FALSE; - } else { - blkdev->feature_persistent = !!pers; - } if (!blkdev->xendev.protocol) { blkdev->protocol = BLKIF_PROTOCOL_NATIVE; @@ -1207,11 +926,8 @@ static int blk_connect(struct XenDevice *xendev) return -1; } - /* Calculate the maximum number of grants needed by ioreqs */ - max_grants = MAX_GRANTS(blkdev->max_requests, - BLKIF_MAX_SEGMENTS_PER_REQUEST); /* Add on the number needed for the ring pages */ - max_grants += blkdev->nr_ring_ref; + max_grants = blkdev->nr_ring_ref; xen_be_set_max_grant_refs(xendev, max_grants); @@ -1222,8 +938,6 @@ static int blk_connect(struct XenDevice *xendev) return -1; } - blkdev->cnt_map++; - switch (blkdev->protocol) { case BLKIF_PROTOCOL_NATIVE: { @@ -1247,19 +961,6 @@ static int blk_connect(struct XenDevice *xendev) } } - if (blkdev->feature_persistent) { - /* Init persistent grants */ - blkdev->max_grants = blkdev->max_requests * - BLKIF_MAX_SEGMENTS_PER_REQUEST; - blkdev->persistent_gnts = g_tree_new_full((GCompareDataFunc)int_cmp, - NULL, NULL, - batch_maps ? - (GDestroyNotify)g_free : - (GDestroyNotify)destroy_grant); - blkdev->persistent_regions = NULL; - blkdev->persistent_gnt_count = 0; - } - blk_set_aio_context(blkdev->blk, blkdev->ctx); xen_be_bind_evtchn(&blkdev->xendev); @@ -1292,29 +993,8 @@ static void blk_disconnect(struct XenDevice *xendev) if (blkdev->sring) { xen_be_unmap_grant_refs(xendev, blkdev->sring, blkdev->nr_ring_ref); - blkdev->cnt_map--; blkdev->sring = NULL; } - - /* - * Unmap persistent grants before switching to the closed state - * so the frontend can free them. - * - * In the !batch_maps case g_tree_destroy will take care of unmapping - * the grant, but in the batch_maps case we need to iterate over every - * region in persistent_regions and unmap it. - */ - if (blkdev->feature_persistent) { - g_tree_destroy(blkdev->persistent_gnts); - assert(batch_maps || blkdev->persistent_gnt_count == 0); - if (batch_maps) { - blkdev->persistent_gnt_count = 0; - g_slist_foreach(blkdev->persistent_regions, - (GFunc)remove_persistent_region, blkdev); - g_slist_free(blkdev->persistent_regions); - } - blkdev->feature_persistent = false; - } } static int blk_free(struct XenDevice *xendev) -- 2.1.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Paul Durrant Subject: [PATCH v2 5/8] xen_disk: remove use of grant map/unmap Date: Fri, 4 May 2018 14:55:31 +0100 Message-ID: <1525442134-20488-6-git-send-email-paul.durrant@citrix.com> References: <1525442134-20488-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 all-amaz-eas1.inumbo.com ([34.197.232.57]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1fEbBk-0006xd-AS for xen-devel@lists.xenproject.org; Fri, 04 May 2018 13:55:56 +0000 In-Reply-To: <1525442134-20488-1-git-send-email-paul.durrant@citrix.com> 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, qemu-block@nongnu.org, qemu-devel@nongnu.org Cc: Anthony Perard , Kevin Wolf , Paul Durrant , Stefano Stabellini , Max Reitz List-Id: xen-devel@lists.xenproject.org Tm93IHRoYXQgdGhlIChuYXRpdmUgb3IgZW11bGF0ZWQpIHhlbl9iZV9jb3B5X2dyYW50X3JlZnMo KSBoZWxwZXIgaXMKYWx3YXlzIGF2YWlsYWJsZSwgdGhlIHhlbl9kaXNrIGNvZGUgY2FuIGJlIHNp Z25pZmljYW50bHkgc2ltcGxpZmllZCBieQpyZW1vdmluZyBkaXJlY3QgdXNlIG9mIGdyYW50IG1h cCBhbmQgdW5tYXAgb3BlcmF0aW9ucy4KClNpZ25lZC1vZmYtYnk6IFBhdWwgRHVycmFudCA8cGF1 bC5kdXJyYW50QGNpdHJpeC5jb20+Ci0tLQpDYzogU3RlZmFubyBTdGFiZWxsaW5pIDxzc3RhYmVs bGluaUBrZXJuZWwub3JnPgpDYzogQW50aG9ueSBQZXJhcmQgPGFudGhvbnkucGVyYXJkQGNpdHJp eC5jb20+CkNjOiBLZXZpbiBXb2xmIDxrd29sZkByZWRoYXQuY29tPgpDYzogTWF4IFJlaXR6IDxt cmVpdHpAcmVkaGF0LmNvbT4KCnYyOgogLSBTcXVhc2hlZCBpbiBzZXBhcmF0ZSBwYXRjaGUgcmVt b3ZpbmcgcGVyc2lzdGVudCBncmFudCB1c2UKIC0gUmUtYmFzZWQKLS0tCiBody9ibG9jay94ZW5f ZGlzay5jIHwgMzcwICsrKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAyNSBpbnNlcnRpb25zKCspLCAzNDUgZGVsZXRpb25z KC0pCgpkaWZmIC0tZ2l0IGEvaHcvYmxvY2sveGVuX2Rpc2suYyBiL2h3L2Jsb2NrL3hlbl9kaXNr LmMKaW5kZXggNjZlZDJiNy4uMjhiZThiNiAxMDA2NDQKLS0tIGEvaHcvYmxvY2sveGVuX2Rpc2su YworKysgYi9ody9ibG9jay94ZW5fZGlzay5jCkBAIC0zNiwyNyArMzYsOSBAQAogCiAvKiAtLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t ICovCiAKLXN0YXRpYyBpbnQgYmF0Y2hfbWFwcyAgID0gMDsKLQotLyogLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwotCiAjZGVm aW5lIEJMT0NLX1NJWkUgIDUxMgogI2RlZmluZSBJT0NCX0NPVU5UICAoQkxLSUZfTUFYX1NFR01F TlRTX1BFUl9SRVFVRVNUICsgMikKIAotc3RydWN0IFBlcnNpc3RlbnRHcmFudCB7Ci0gICAgdm9p ZCAqcGFnZTsKLSAgICBzdHJ1Y3QgWGVuQmxrRGV2ICpibGtkZXY7Ci19OwotCi10eXBlZGVmIHN0 cnVjdCBQZXJzaXN0ZW50R3JhbnQgUGVyc2lzdGVudEdyYW50OwotCi1zdHJ1Y3QgUGVyc2lzdGVu dFJlZ2lvbiB7Ci0gICAgdm9pZCAqYWRkcjsKLSAgICBpbnQgbnVtOwotfTsKLQotdHlwZWRlZiBz dHJ1Y3QgUGVyc2lzdGVudFJlZ2lvbiBQZXJzaXN0ZW50UmVnaW9uOwotCiBzdHJ1Y3QgaW9yZXEg ewogICAgIGJsa2lmX3JlcXVlc3RfdCAgICAgcmVxOwogICAgIGludDE2X3QgICAgICAgICAgICAg c3RhdHVzOwpAQCAtNjUsMTQgKzQ3LDExIEBAIHN0cnVjdCBpb3JlcSB7CiAgICAgb2ZmX3QgICAg ICAgICAgICAgICBzdGFydDsKICAgICBRRU1VSU9WZWN0b3IgICAgICAgIHY7CiAgICAgaW50ICAg ICAgICAgICAgICAgICBwcmVzeW5jOwotICAgIHVpbnQ4X3QgICAgICAgICAgICAgbWFwcGVkOwog CiAgICAgLyogZ3JhbnQgbWFwcGluZyAqLwogICAgIHVpbnQzMl90ICAgICAgICAgICAgcmVmc1tC TEtJRl9NQVhfU0VHTUVOVFNfUEVSX1JFUVVFU1RdOwotICAgIGludCAgICAgICAgICAgICAgICAg cHJvdDsKICAgICB2b2lkICAgICAgICAgICAgICAgICpwYWdlW0JMS0lGX01BWF9TRUdNRU5UU19Q RVJfUkVRVUVTVF07CiAgICAgdm9pZCAgICAgICAgICAgICAgICAqcGFnZXM7Ci0gICAgaW50ICAg ICAgICAgICAgICAgICBudW1fdW5tYXA7CiAKICAgICAvKiBhaW8gc3RhdHVzICovCiAgICAgaW50 ICAgICAgICAgICAgICAgICBhaW9faW5mbGlnaHQ7CkBAIC0xMDMsNyArODIsNiBAQCBzdHJ1Y3Qg WGVuQmxrRGV2IHsKICAgICBpbnQgICAgICAgICAgICAgICAgIHByb3RvY29sOwogICAgIGJsa2lm X2JhY2tfcmluZ3NfdCAgcmluZ3M7CiAgICAgaW50ICAgICAgICAgICAgICAgICBtb3JlX3dvcms7 Ci0gICAgaW50ICAgICAgICAgICAgICAgICBjbnRfbWFwOwogCiAgICAgLyogcmVxdWVzdCBsaXN0 cyAqLwogICAgIFFMSVNUX0hFQUQoaW5mbGlnaHRfaGVhZCwgaW9yZXEpIGluZmxpZ2h0OwpAQCAt MTE0LDEzICs5Miw3IEBAIHN0cnVjdCBYZW5CbGtEZXYgewogICAgIGludCAgICAgICAgICAgICAg ICAgcmVxdWVzdHNfZmluaXNoZWQ7CiAgICAgdW5zaWduZWQgaW50ICAgICAgICBtYXhfcmVxdWVz dHM7CiAKLSAgICAvKiBQZXJzaXN0ZW50IGdyYW50cyBleHRlbnNpb24gKi8KICAgICBnYm9vbGVh biAgICAgICAgICAgIGZlYXR1cmVfZGlzY2FyZDsKLSAgICBnYm9vbGVhbiAgICAgICAgICAgIGZl YXR1cmVfcGVyc2lzdGVudDsKLSAgICBHVHJlZSAgICAgICAgICAgICAgICpwZXJzaXN0ZW50X2du dHM7Ci0gICAgR1NMaXN0ICAgICAgICAgICAgICAqcGVyc2lzdGVudF9yZWdpb25zOwotICAgIHVu c2lnbmVkIGludCAgICAgICAgcGVyc2lzdGVudF9nbnRfY291bnQ7Ci0gICAgdW5zaWduZWQgaW50 ICAgICAgICBtYXhfZ3JhbnRzOwogCiAgICAgLyogcWVtdSBibG9jayBkcml2ZXIgKi8KICAgICBE cml2ZUluZm8gICAgICAgICAgICpkaW5mbzsKQEAgLTEzOSwxMCArMTExLDggQEAgc3RhdGljIHZv aWQgaW9yZXFfcmVzZXQoc3RydWN0IGlvcmVxICppb3JlcSkKICAgICBpb3JlcS0+c3RhdHVzID0g MDsKICAgICBpb3JlcS0+c3RhcnQgPSAwOwogICAgIGlvcmVxLT5wcmVzeW5jID0gMDsKLSAgICBp b3JlcS0+bWFwcGVkID0gMDsKIAogICAgIG1lbXNldChpb3JlcS0+cmVmcywgMCwgc2l6ZW9mKGlv cmVxLT5yZWZzKSk7Ci0gICAgaW9yZXEtPnByb3QgPSAwOwogICAgIG1lbXNldChpb3JlcS0+cGFn ZSwgMCwgc2l6ZW9mKGlvcmVxLT5wYWdlKSk7CiAgICAgaW9yZXEtPnBhZ2VzID0gTlVMTDsKIApA QCAtMTU2LDM3ICsxMjYsNiBAQCBzdGF0aWMgdm9pZCBpb3JlcV9yZXNldChzdHJ1Y3QgaW9yZXEg KmlvcmVxKQogICAgIHFlbXVfaW92ZWNfcmVzZXQoJmlvcmVxLT52KTsKIH0KIAotc3RhdGljIGdp bnQgaW50X2NtcChnY29uc3Rwb2ludGVyIGEsIGdjb25zdHBvaW50ZXIgYiwgZ3BvaW50ZXIgdXNl cl9kYXRhKQotewotICAgIHVpbnQgdWEgPSBHUE9JTlRFUl9UT19VSU5UKGEpOwotICAgIHVpbnQg dWIgPSBHUE9JTlRFUl9UT19VSU5UKGIpOwotICAgIHJldHVybiAodWEgPiB1YikgLSAodWEgPCB1 Yik7Ci19Ci0KLXN0YXRpYyB2b2lkIGRlc3Ryb3lfZ3JhbnQoZ3BvaW50ZXIgcGdudCkKLXsKLSAg ICBQZXJzaXN0ZW50R3JhbnQgKmdyYW50ID0gcGdudDsKLSAgICBzdHJ1Y3QgWGVuQmxrRGV2ICpi bGtkZXYgPSBncmFudC0+YmxrZGV2OwotICAgIHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiA9ICZi bGtkZXYtPnhlbmRldjsKLQotICAgIHhlbl9iZV91bm1hcF9ncmFudF9yZWYoeGVuZGV2LCBncmFu dC0+cGFnZSk7Ci0gICAgZ3JhbnQtPmJsa2Rldi0+cGVyc2lzdGVudF9nbnRfY291bnQtLTsKLSAg ICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMywgInVubWFwcGVkIGdyYW50ICVwXG4iLCBncmFudC0+ cGFnZSk7Ci0gICAgZ19mcmVlKGdyYW50KTsKLX0KLQotc3RhdGljIHZvaWQgcmVtb3ZlX3BlcnNp c3RlbnRfcmVnaW9uKGdwb2ludGVyIGRhdGEsIGdwb2ludGVyIGRldikKLXsKLSAgICBQZXJzaXN0 ZW50UmVnaW9uICpyZWdpb24gPSBkYXRhOwotICAgIHN0cnVjdCBYZW5CbGtEZXYgKmJsa2RldiA9 IGRldjsKLSAgICBzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYgPSAmYmxrZGV2LT54ZW5kZXY7Ci0K LSAgICB4ZW5fYmVfdW5tYXBfZ3JhbnRfcmVmcyh4ZW5kZXYsIHJlZ2lvbi0+YWRkciwgcmVnaW9u LT5udW0pOwotICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAzLCAidW5tYXBwZWQgZ3JhbnQgcmVn aW9uICVwIHdpdGggJWQgcGFnZXNcbiIsCi0gICAgICAgICAgICAgICAgICByZWdpb24tPmFkZHIs IHJlZ2lvbi0+bnVtKTsKLSAgICBnX2ZyZWUocmVnaW9uKTsKLX0KLQogc3RhdGljIHN0cnVjdCBp b3JlcSAqaW9yZXFfc3RhcnQoc3RydWN0IFhlbkJsa0RldiAqYmxrZGV2KQogewogICAgIHN0cnVj dCBpb3JlcSAqaW9yZXEgPSBOVUxMOwpAQCAtMjU0LDcgKzE5Myw2IEBAIHN0YXRpYyBpbnQgaW9y ZXFfcGFyc2Uoc3RydWN0IGlvcmVxICppb3JlcSkKICAgICAgICAgICAgICAgICAgIGlvcmVxLT5y ZXEuaGFuZGxlLCBpb3JlcS0+cmVxLmlkLCBpb3JlcS0+cmVxLnNlY3Rvcl9udW1iZXIpOwogICAg IHN3aXRjaCAoaW9yZXEtPnJlcS5vcGVyYXRpb24pIHsKICAgICBjYXNlIEJMS0lGX09QX1JFQUQ6 Ci0gICAgICAgIGlvcmVxLT5wcm90ID0gUFJPVF9XUklURTsgLyogdG8gbWVtb3J5ICovCiAgICAg ICAgIGJyZWFrOwogICAgIGNhc2UgQkxLSUZfT1BfRkxVU0hfRElTS0NBQ0hFOgogICAgICAgICBp b3JlcS0+cHJlc3luYyA9IDE7CkBAIC0yNjMsNyArMjAxLDYgQEAgc3RhdGljIGludCBpb3JlcV9w YXJzZShzdHJ1Y3QgaW9yZXEgKmlvcmVxKQogICAgICAgICB9CiAgICAgICAgIC8qIGZhbGwgdGhy b3VnaCAqLwogICAgIGNhc2UgQkxLSUZfT1BfV1JJVEU6Ci0gICAgICAgIGlvcmVxLT5wcm90ID0g UFJPVF9SRUFEOyAvKiBmcm9tIG1lbW9yeSAqLwogICAgICAgICBicmVhazsKICAgICBjYXNlIEJM S0lGX09QX0RJU0NBUkQ6CiAgICAgICAgIHJldHVybiAwOwpAQCAtMzEwLDE3MyArMjQ3LDYgQEAg ZXJyOgogICAgIHJldHVybiAtMTsKIH0KIAotc3RhdGljIHZvaWQgaW9yZXFfdW5tYXAoc3RydWN0 IGlvcmVxICppb3JlcSkKLXsKLSAgICBzdHJ1Y3QgWGVuQmxrRGV2ICpibGtkZXYgPSBpb3JlcS0+ YmxrZGV2OwotICAgIHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiA9ICZibGtkZXYtPnhlbmRldjsK LSAgICBpbnQgaTsKLQotICAgIGlmIChpb3JlcS0+bnVtX3VubWFwID09IDAgfHwgaW9yZXEtPm1h cHBlZCA9PSAwKSB7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0gICAgaWYgKGJhdGNoX21hcHMp IHsKLSAgICAgICAgaWYgKCFpb3JlcS0+cGFnZXMpIHsKLSAgICAgICAgICAgIHJldHVybjsKLSAg ICAgICAgfQotICAgICAgICB4ZW5fYmVfdW5tYXBfZ3JhbnRfcmVmcyh4ZW5kZXYsIGlvcmVxLT5w YWdlcywgaW9yZXEtPm51bV91bm1hcCk7Ci0gICAgICAgIGlvcmVxLT5ibGtkZXYtPmNudF9tYXAg LT0gaW9yZXEtPm51bV91bm1hcDsKLSAgICAgICAgaW9yZXEtPnBhZ2VzID0gTlVMTDsKLSAgICB9 IGVsc2UgewotICAgICAgICBmb3IgKGkgPSAwOyBpIDwgaW9yZXEtPm51bV91bm1hcDsgaSsrKSB7 Ci0gICAgICAgICAgICBpZiAoIWlvcmVxLT5wYWdlW2ldKSB7Ci0gICAgICAgICAgICAgICAgY29u dGludWU7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICB4ZW5fYmVfdW5tYXBfZ3JhbnRfcmVm KHhlbmRldiwgaW9yZXEtPnBhZ2VbaV0pOwotICAgICAgICAgICAgaW9yZXEtPmJsa2Rldi0+Y250 X21hcC0tOwotICAgICAgICAgICAgaW9yZXEtPnBhZ2VbaV0gPSBOVUxMOwotICAgICAgICB9Ci0g ICAgfQotICAgIGlvcmVxLT5tYXBwZWQgPSAwOwotfQotCi1zdGF0aWMgaW50IGlvcmVxX21hcChz dHJ1Y3QgaW9yZXEgKmlvcmVxKQotewotICAgIHN0cnVjdCBYZW5CbGtEZXYgKmJsa2RldiA9IGlv cmVxLT5ibGtkZXY7Ci0gICAgc3RydWN0IFhlbkRldmljZSAqeGVuZGV2ID0gJmJsa2Rldi0+eGVu ZGV2OwotICAgIHVpbnQzMl90IHJlZnNbQkxLSUZfTUFYX1NFR01FTlRTX1BFUl9SRVFVRVNUXTsK LSAgICB2b2lkICpwYWdlW0JMS0lGX01BWF9TRUdNRU5UU19QRVJfUkVRVUVTVF07Ci0gICAgaW50 IGksIGosIG5ld19tYXBzID0gMDsKLSAgICBQZXJzaXN0ZW50R3JhbnQgKmdyYW50OwotICAgIFBl cnNpc3RlbnRSZWdpb24gKnJlZ2lvbjsKLSAgICAvKiByZWZzIHZhcmlhYmxlIHdpbGwgY29udGFp biB0aGUgaW5mb3JtYXRpb24gbmVjZXNzYXJ5Ci0gICAgICogdG8gbWFwIHRoZSBncmFudHMgdGhh dCBhcmUgbmVlZGVkIHRvIGZ1bGZpbGwgdGhpcyByZXF1ZXN0LgotICAgICAqCi0gICAgICogQWZ0 ZXIgbWFwcGluZyB0aGUgbmVlZGVkIGdyYW50cywgdGhlIHBhZ2UgYXJyYXkgd2lsbCBjb250YWlu IHRoZQotICAgICAqIG1lbW9yeSBhZGRyZXNzIG9mIGVhY2ggZ3JhbnRlZCBwYWdlIGluIHRoZSBv cmRlciBzcGVjaWZpZWQgaW4gaW9yZXEKLSAgICAgKiAoZGlzcmVnYXJkaW5nIGlmIGl0J3MgYSBw ZXJzaXN0ZW50IGdyYW50IG9yIG5vdCkuCi0gICAgICovCi0KLSAgICBpZiAoaW9yZXEtPnYubmlv diA9PSAwIHx8IGlvcmVxLT5tYXBwZWQgPT0gMSkgewotICAgICAgICByZXR1cm4gMDsKLSAgICB9 Ci0gICAgaWYgKGlvcmVxLT5ibGtkZXYtPmZlYXR1cmVfcGVyc2lzdGVudCkgewotICAgICAgICBm b3IgKGkgPSAwOyBpIDwgaW9yZXEtPnYubmlvdjsgaSsrKSB7Ci0gICAgICAgICAgICBncmFudCA9 IGdfdHJlZV9sb29rdXAoaW9yZXEtPmJsa2Rldi0+cGVyc2lzdGVudF9nbnRzLAotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgR1VJTlRfVE9fUE9JTlRFUihpb3JlcS0+cmVmc1tp XSkpOwotCi0gICAgICAgICAgICBpZiAoZ3JhbnQgIT0gTlVMTCkgewotICAgICAgICAgICAgICAg IHBhZ2VbaV0gPSBncmFudC0+cGFnZTsKLSAgICAgICAgICAgICAgICB4ZW5fcHZfcHJpbnRmKCZp b3JlcS0+YmxrZGV2LT54ZW5kZXYsIDMsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAi dXNpbmcgcGVyc2lzdGVudC1ncmFudCAlIiBQUkl1MzIgIlxuIiwKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGlvcmVxLT5yZWZzW2ldKTsKLSAgICAgICAgICAgIH0gZWxzZSB7Ci0gICAg ICAgICAgICAgICAgICAgIC8qIEFkZCB0aGUgZ3JhbnQgdG8gdGhlIGxpc3Qgb2YgZ3JhbnRzIHRo YXQKLSAgICAgICAgICAgICAgICAgICAgICogc2hvdWxkIGJlIG1hcHBlZAotICAgICAgICAgICAg ICAgICAgICAgKi8KLSAgICAgICAgICAgICAgICAgICAgcmVmc1tuZXdfbWFwc10gPSBpb3JlcS0+ cmVmc1tpXTsKLSAgICAgICAgICAgICAgICAgICAgcGFnZVtpXSA9IE5VTEw7Ci0gICAgICAgICAg ICAgICAgICAgIG5ld19tYXBzKys7Ci0gICAgICAgICAgICB9Ci0gICAgICAgIH0KLSAgICAgICAg LyogU2V0IHRoZSBwcm90ZWN0aW9uIHRvIFJXLCBzaW5jZSBncmFudHMgbWF5IGJlIHJldXNlZCBs YXRlcgotICAgICAgICAgKiB3aXRoIGEgZGlmZmVyZW50IHByb3RlY3Rpb24gdGhhbiB0aGUgb25l IG5lZWRlZCBmb3IgdGhpcyByZXF1ZXN0Ci0gICAgICAgICAqLwotICAgICAgICBpb3JlcS0+cHJv dCA9IFBST1RfV1JJVEUgfCBQUk9UX1JFQUQ7Ci0gICAgfSBlbHNlIHsKLSAgICAgICAgLyogQWxs IGdyYW50cyBpbiB0aGUgcmVxdWVzdCBzaG91bGQgYmUgbWFwcGVkICovCi0gICAgICAgIG1lbWNw eShyZWZzLCBpb3JlcS0+cmVmcywgc2l6ZW9mKHJlZnMpKTsKLSAgICAgICAgbWVtc2V0KHBhZ2Us IDAsIHNpemVvZihwYWdlKSk7Ci0gICAgICAgIG5ld19tYXBzID0gaW9yZXEtPnYubmlvdjsKLSAg ICB9Ci0KLSAgICBpZiAoYmF0Y2hfbWFwcyAmJiBuZXdfbWFwcykgewotICAgICAgICBpb3JlcS0+ cGFnZXMgPSB4ZW5fYmVfbWFwX2dyYW50X3JlZnMoeGVuZGV2LCByZWZzLCBuZXdfbWFwcywKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlvcmVxLT5wcm90KTsK LSAgICAgICAgaWYgKGlvcmVxLT5wYWdlcyA9PSBOVUxMKSB7Ci0gICAgICAgICAgICB4ZW5fcHZf cHJpbnRmKCZpb3JlcS0+YmxrZGV2LT54ZW5kZXYsIDAsCi0gICAgICAgICAgICAgICAgICAgICAg ICAgICJjYW4ndCBtYXAgJWQgZ3JhbnQgcmVmcyAoJXMsICVkIG1hcHMpXG4iLAotICAgICAgICAg ICAgICAgICAgICAgICAgICBuZXdfbWFwcywgc3RyZXJyb3IoZXJybm8pLCBpb3JlcS0+YmxrZGV2 LT5jbnRfbWFwKTsKLSAgICAgICAgICAgIHJldHVybiAtMTsKLSAgICAgICAgfQotICAgICAgICBm b3IgKGkgPSAwLCBqID0gMDsgaSA8IGlvcmVxLT52Lm5pb3Y7IGkrKykgewotICAgICAgICAgICAg aWYgKHBhZ2VbaV0gPT0gTlVMTCkgewotICAgICAgICAgICAgICAgIHBhZ2VbaV0gPSBpb3JlcS0+ cGFnZXMgKyAoaisrKSAqIFhDX1BBR0VfU0laRTsKLSAgICAgICAgICAgIH0KLSAgICAgICAgfQot ICAgICAgICBpb3JlcS0+YmxrZGV2LT5jbnRfbWFwICs9IG5ld19tYXBzOwotICAgIH0gZWxzZSBp ZiAobmV3X21hcHMpICB7Ci0gICAgICAgIGZvciAoaSA9IDA7IGkgPCBuZXdfbWFwczsgaSsrKSB7 Ci0gICAgICAgICAgICBpb3JlcS0+cGFnZVtpXSA9IHhlbl9iZV9tYXBfZ3JhbnRfcmVmKHhlbmRl diwgcmVmc1tpXSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgaW9yZXEtPnByb3QpOwotICAgICAgICAgICAgaWYgKGlvcmVxLT5wYWdlW2ldID09IE5V TEwpIHsKLSAgICAgICAgICAgICAgICB4ZW5fcHZfcHJpbnRmKCZpb3JlcS0+YmxrZGV2LT54ZW5k ZXYsIDAsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiY2FuJ3QgbWFwIGdyYW50IHJl ZiAlZCAoJXMsICVkIG1hcHMpXG4iLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVm c1tpXSwgc3RyZXJyb3IoZXJybm8pLCBpb3JlcS0+YmxrZGV2LT5jbnRfbWFwKTsKLSAgICAgICAg ICAgICAgICBpb3JlcS0+bWFwcGVkID0gMTsKLSAgICAgICAgICAgICAgICBpb3JlcV91bm1hcChp b3JlcSk7Ci0gICAgICAgICAgICAgICAgcmV0dXJuIC0xOwotICAgICAgICAgICAgfQotICAgICAg ICAgICAgaW9yZXEtPmJsa2Rldi0+Y250X21hcCsrOwotICAgICAgICB9Ci0gICAgICAgIGZvciAo aSA9IDAsIGogPSAwOyBpIDwgaW9yZXEtPnYubmlvdjsgaSsrKSB7Ci0gICAgICAgICAgICBpZiAo cGFnZVtpXSA9PSBOVUxMKSB7Ci0gICAgICAgICAgICAgICAgcGFnZVtpXSA9IGlvcmVxLT5wYWdl W2orK107Ci0gICAgICAgICAgICB9Ci0gICAgICAgIH0KLSAgICB9Ci0gICAgaWYgKGlvcmVxLT5i bGtkZXYtPmZlYXR1cmVfcGVyc2lzdGVudCAmJiBuZXdfbWFwcyAhPSAwICYmCi0gICAgICAgICgh YmF0Y2hfbWFwcyB8fCAoaW9yZXEtPmJsa2Rldi0+cGVyc2lzdGVudF9nbnRfY291bnQgKyBuZXdf bWFwcyA8PQotICAgICAgICBpb3JlcS0+YmxrZGV2LT5tYXhfZ3JhbnRzKSkpIHsKLSAgICAgICAg LyoKLSAgICAgICAgICogSWYgd2UgYXJlIHVzaW5nIHBlcnNpc3RlbnQgZ3JhbnRzIGFuZCBiYXRj aCBtYXBwaW5ncyBvbmx5Ci0gICAgICAgICAqIGFkZCB0aGUgbmV3IG1hcHMgdG8gdGhlIGxpc3Qg b2YgcGVyc2lzdGVudCBncmFudHMgaWYgdGhlIHdob2xlCi0gICAgICAgICAqIGFyZWEgY2FuIGJl IHBlcnNpc3RlbnRseSBtYXBwZWQuCi0gICAgICAgICAqLwotICAgICAgICBpZiAoYmF0Y2hfbWFw cykgewotICAgICAgICAgICAgcmVnaW9uID0gZ19tYWxsb2MwKHNpemVvZigqcmVnaW9uKSk7Ci0g ICAgICAgICAgICByZWdpb24tPmFkZHIgPSBpb3JlcS0+cGFnZXM7Ci0gICAgICAgICAgICByZWdp b24tPm51bSA9IG5ld19tYXBzOwotICAgICAgICAgICAgaW9yZXEtPmJsa2Rldi0+cGVyc2lzdGVu dF9yZWdpb25zID0gZ19zbGlzdF9hcHBlbmQoCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGlvcmVxLT5ibGtkZXYtPnBlcnNpc3RlbnRfcmVnaW9ucywKLSAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVnaW9uKTsKLSAgICAgICAg fQotICAgICAgICB3aGlsZSAoKGlvcmVxLT5ibGtkZXYtPnBlcnNpc3RlbnRfZ250X2NvdW50IDwg aW9yZXEtPmJsa2Rldi0+bWF4X2dyYW50cykKLSAgICAgICAgICAgICAgJiYgbmV3X21hcHMpIHsK LSAgICAgICAgICAgIC8qIEdvIHRocm91Z2ggdGhlIGxpc3Qgb2YgbmV3bHkgbWFwcGVkIGdyYW50 cyBhbmQgYWRkIGFzIG1hbnkKLSAgICAgICAgICAgICAqIGFzIHBvc3NpYmxlIHRvIHRoZSBsaXN0 IG9mIHBlcnNpc3RlbnRseSBtYXBwZWQgZ3JhbnRzLgotICAgICAgICAgICAgICoKLSAgICAgICAg ICAgICAqIFNpbmNlIHdlIHN0YXJ0IGF0IHRoZSBlbmQgb2YgaW9yZXEtPnBhZ2UocyksIHdlIG9u bHkgbmVlZAotICAgICAgICAgICAgICogdG8gZGVjcmVhc2UgbmV3X21hcHMgdG8gcHJldmVudCB0 aGlzIGdyYW50ZWQgcGFnZXMgZnJvbQotICAgICAgICAgICAgICogYmVpbmcgdW5tYXBwZWQgaW4g aW9yZXFfdW5tYXAuCi0gICAgICAgICAgICAgKi8KLSAgICAgICAgICAgIGdyYW50ID0gZ19tYWxs b2MwKHNpemVvZigqZ3JhbnQpKTsKLSAgICAgICAgICAgIG5ld19tYXBzLS07Ci0gICAgICAgICAg ICBpZiAoYmF0Y2hfbWFwcykgewotICAgICAgICAgICAgICAgIGdyYW50LT5wYWdlID0gaW9yZXEt PnBhZ2VzICsgKG5ld19tYXBzKSAqIFhDX1BBR0VfU0laRTsKLSAgICAgICAgICAgIH0gZWxzZSB7 Ci0gICAgICAgICAgICAgICAgZ3JhbnQtPnBhZ2UgPSBpb3JlcS0+cGFnZVtuZXdfbWFwc107Ci0g ICAgICAgICAgICB9Ci0gICAgICAgICAgICBncmFudC0+YmxrZGV2ID0gaW9yZXEtPmJsa2RldjsK LSAgICAgICAgICAgIHhlbl9wdl9wcmludGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMywKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgImFkZGluZyBncmFudCAlIiBQUkl1MzIgIiBwYWdlOiAl cFxuIiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgcmVmc1tuZXdfbWFwc10sIGdyYW50LT5w YWdlKTsKLSAgICAgICAgICAgIGdfdHJlZV9pbnNlcnQoaW9yZXEtPmJsa2Rldi0+cGVyc2lzdGVu dF9nbnRzLAotICAgICAgICAgICAgICAgICAgICAgICAgICBHVUlOVF9UT19QT0lOVEVSKHJlZnNb bmV3X21hcHNdKSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgZ3JhbnQpOwotICAgICAgICAg ICAgaW9yZXEtPmJsa2Rldi0+cGVyc2lzdGVudF9nbnRfY291bnQrKzsKLSAgICAgICAgfQotICAg ICAgICBhc3NlcnQoIWJhdGNoX21hcHMgfHwgbmV3X21hcHMgPT0gMCk7Ci0gICAgfQotICAgIGZv ciAoaSA9IDA7IGkgPCBpb3JlcS0+di5uaW92OyBpKyspIHsKLSAgICAgICAgaW9yZXEtPnYuaW92 W2ldLmlvdl9iYXNlICs9ICh1aW50cHRyX3QpcGFnZVtpXTsKLSAgICB9Ci0gICAgaW9yZXEtPm1h cHBlZCA9IDE7Ci0gICAgaW9yZXEtPm51bV91bm1hcCA9IG5ld19tYXBzOwotICAgIHJldHVybiAw OwotfQotCi0jaWYgQ09ORklHX1hFTl9DVFJMX0lOVEVSRkFDRV9WRVJTSU9OID49IDQwODAwCi0K IHN0YXRpYyB2b2lkIGlvcmVxX2ZyZWVfY29weV9idWZmZXJzKHN0cnVjdCBpb3JlcSAqaW9yZXEp CiB7CiAgICAgaW50IGk7CkBAIC01NDYsMjIgKzMxNiw2IEBAIHN0YXRpYyBpbnQgaW9yZXFfZ3Jh bnRfY29weShzdHJ1Y3QgaW9yZXEgKmlvcmVxKQogCiAgICAgcmV0dXJuIHJjOwogfQotI2Vsc2UK LXN0YXRpYyB2b2lkIGlvcmVxX2ZyZWVfY29weV9idWZmZXJzKHN0cnVjdCBpb3JlcSAqaW9yZXEp Ci17Ci0gICAgYWJvcnQoKTsKLX0KLQotc3RhdGljIGludCBpb3JlcV9pbml0X2NvcHlfYnVmZmVy cyhzdHJ1Y3QgaW9yZXEgKmlvcmVxKQotewotICAgIGFib3J0KCk7Ci19Ci0KLXN0YXRpYyBpbnQg aW9yZXFfZ3JhbnRfY29weShzdHJ1Y3QgaW9yZXEgKmlvcmVxKQotewotICAgIGFib3J0KCk7Ci19 Ci0jZW5kaWYKIAogc3RhdGljIGludCBpb3JlcV9ydW5pb19xZW11X2FpbyhzdHJ1Y3QgaW9yZXEg KmlvcmVxKTsKIApAQCAtNTg4LDMyICszNDIsMjggQEAgc3RhdGljIHZvaWQgcWVtdV9haW9fY29t cGxldGUodm9pZCAqb3BhcXVlLCBpbnQgcmV0KQogICAgICAgICBnb3RvIGRvbmU7CiAgICAgfQog Ci0gICAgaWYgKHhlbl9mZWF0dXJlX2dyYW50X2NvcHkpIHsKLSAgICAgICAgc3dpdGNoIChpb3Jl cS0+cmVxLm9wZXJhdGlvbikgewotICAgICAgICBjYXNlIEJMS0lGX09QX1JFQUQ6Ci0gICAgICAg ICAgICAvKiBpbiBjYXNlIG9mIGZhaWx1cmUgaW9yZXEtPmFpb19lcnJvcnMgaXMgaW5jcmVhc2Vk ICovCi0gICAgICAgICAgICBpZiAocmV0ID09IDApIHsKLSAgICAgICAgICAgICAgICBpb3JlcV9n cmFudF9jb3B5KGlvcmVxKTsKLSAgICAgICAgICAgIH0KLSAgICAgICAgICAgIGlvcmVxX2ZyZWVf Y29weV9idWZmZXJzKGlvcmVxKTsKLSAgICAgICAgICAgIGJyZWFrOwotICAgICAgICBjYXNlIEJM S0lGX09QX1dSSVRFOgotICAgICAgICBjYXNlIEJMS0lGX09QX0ZMVVNIX0RJU0tDQUNIRToKLSAg ICAgICAgICAgIGlmICghaW9yZXEtPnJlcS5ucl9zZWdtZW50cykgewotICAgICAgICAgICAgICAg IGJyZWFrOwotICAgICAgICAgICAgfQotICAgICAgICAgICAgaW9yZXFfZnJlZV9jb3B5X2J1ZmZl cnMoaW9yZXEpOwotICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgIGRlZmF1bHQ6CisgICAgc3dp dGNoIChpb3JlcS0+cmVxLm9wZXJhdGlvbikgeworICAgIGNhc2UgQkxLSUZfT1BfUkVBRDoKKyAg ICAgICAgLyogaW4gY2FzZSBvZiBmYWlsdXJlIGlvcmVxLT5haW9fZXJyb3JzIGlzIGluY3JlYXNl ZCAqLworICAgICAgICBpZiAocmV0ID09IDApIHsKKyAgICAgICAgICAgIGlvcmVxX2dyYW50X2Nv cHkoaW9yZXEpOworICAgICAgICB9CisgICAgICAgIGlvcmVxX2ZyZWVfY29weV9idWZmZXJzKGlv cmVxKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBCTEtJRl9PUF9XUklURToKKyAgICBjYXNl IEJMS0lGX09QX0ZMVVNIX0RJU0tDQUNIRToKKyAgICAgICAgaWYgKCFpb3JlcS0+cmVxLm5yX3Nl Z21lbnRzKSB7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQorICAgICAgICBpb3JlcV9m cmVlX2NvcHlfYnVmZmVycyhpb3JlcSk7CisgICAgICAgIGJyZWFrOworICAgIGRlZmF1bHQ6Cisg ICAgICAgIGJyZWFrOwogICAgIH0KIAogICAgIGlvcmVxLT5zdGF0dXMgPSBpb3JlcS0+YWlvX2Vy cm9ycyA/IEJMS0lGX1JTUF9FUlJPUiA6IEJMS0lGX1JTUF9PS0FZOwotICAgIGlmICgheGVuX2Zl YXR1cmVfZ3JhbnRfY29weSkgewotICAgICAgICBpb3JlcV91bm1hcChpb3JlcSk7Ci0gICAgfQog ICAgIGlvcmVxX2ZpbmlzaChpb3JlcSk7CisKICAgICBzd2l0Y2ggKGlvcmVxLT5yZXEub3BlcmF0 aW9uKSB7CiAgICAgY2FzZSBCTEtJRl9PUF9XUklURToKICAgICBjYXNlIEJMS0lGX09QX0ZMVVNI X0RJU0tDQUNIRToKQEAgLTY3MywxOCArNDIzLDEzIEBAIHN0YXRpYyBpbnQgaW9yZXFfcnVuaW9f cWVtdV9haW8oc3RydWN0IGlvcmVxICppb3JlcSkKIHsKICAgICBzdHJ1Y3QgWGVuQmxrRGV2ICpi bGtkZXYgPSBpb3JlcS0+YmxrZGV2OwogCi0gICAgaWYgKHhlbl9mZWF0dXJlX2dyYW50X2NvcHkp IHsKLSAgICAgICAgaW9yZXFfaW5pdF9jb3B5X2J1ZmZlcnMoaW9yZXEpOwotICAgICAgICBpZiAo aW9yZXEtPnJlcS5ucl9zZWdtZW50cyAmJiAoaW9yZXEtPnJlcS5vcGVyYXRpb24gPT0gQkxLSUZf T1BfV1JJVEUgfHwKLSAgICAgICAgICAgIGlvcmVxLT5yZXEub3BlcmF0aW9uID09IEJMS0lGX09Q X0ZMVVNIX0RJU0tDQUNIRSkgJiYKLSAgICAgICAgICAgIGlvcmVxX2dyYW50X2NvcHkoaW9yZXEp KSB7Ci0gICAgICAgICAgICAgICAgaW9yZXFfZnJlZV9jb3B5X2J1ZmZlcnMoaW9yZXEpOwotICAg ICAgICAgICAgICAgIGdvdG8gZXJyOwotICAgICAgICB9Ci0gICAgfSBlbHNlIHsKLSAgICAgICAg aWYgKGlvcmVxLT5yZXEubnJfc2VnbWVudHMgJiYgaW9yZXFfbWFwKGlvcmVxKSkgewotICAgICAg ICAgICAgZ290byBlcnI7Ci0gICAgICAgIH0KKyAgICBpb3JlcV9pbml0X2NvcHlfYnVmZmVycyhp b3JlcSk7CisgICAgaWYgKGlvcmVxLT5yZXEubnJfc2VnbWVudHMgJiYKKyAgICAgICAgKGlvcmVx LT5yZXEub3BlcmF0aW9uID09IEJMS0lGX09QX1dSSVRFIHx8CisgICAgICAgICBpb3JlcS0+cmVx Lm9wZXJhdGlvbiA9PSBCTEtJRl9PUF9GTFVTSF9ESVNLQ0FDSEUpICYmCisgICAgICAgIGlvcmVx X2dyYW50X2NvcHkoaW9yZXEpKSB7CisgICAgICAgIGlvcmVxX2ZyZWVfY29weV9idWZmZXJzKGlv cmVxKTsKKyAgICAgICAgZ290byBlcnI7CiAgICAgfQogCiAgICAgaW9yZXEtPmFpb19pbmZsaWdo dCsrOwpAQCAtNzI1LDkgKzQ3MCw2IEBAIHN0YXRpYyBpbnQgaW9yZXFfcnVuaW9fcWVtdV9haW8o c3RydWN0IGlvcmVxICppb3JlcSkKICAgICB9CiAgICAgZGVmYXVsdDoKICAgICAgICAgLyogdW5r bm93biBvcGVyYXRpb24gKHNob3VsZG4ndCBoYXBwZW4gLS0gcGFyc2UgY2F0Y2hlcyB0aGlzKSAq LwotICAgICAgICBpZiAoIXhlbl9mZWF0dXJlX2dyYW50X2NvcHkpIHsKLSAgICAgICAgICAgIGlv cmVxX3VubWFwKGlvcmVxKTsKLSAgICAgICAgfQogICAgICAgICBnb3RvIGVycjsKICAgICB9CiAK QEAgLTkxMywxMCArNjU1LDYgQEAgc3RhdGljIHZvaWQgYmxrX2FsbG9jKHN0cnVjdCBYZW5EZXZp Y2UgKnhlbmRldikKIAogICAgIGJsa2Rldi0+Y3R4ID0gaW90aHJlYWRfZ2V0X2Fpb19jb250ZXh0 KGJsa2Rldi0+aW90aHJlYWQpOwogICAgIGJsa2Rldi0+YmggPSBhaW9fYmhfbmV3KGJsa2Rldi0+ Y3R4LCBibGtfYmgsIGJsa2Rldik7Ci0KLSAgICBpZiAoeGVuX21vZGUgIT0gWEVOX0VNVUxBVEUp IHsKLSAgICAgICAgYmF0Y2hfbWFwcyA9IDE7Ci0gICAgfQogfQogCiBzdGF0aWMgdm9pZCBibGtf cGFyc2VfZGlzY2FyZChzdHJ1Y3QgWGVuQmxrRGV2ICpibGtkZXYpCkBAIC05OTksMTUgKzczNywx MCBAQCBzdGF0aWMgaW50IGJsa19pbml0KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKIAogICAg IGJsa2Rldi0+ZmlsZV9ibGsgID0gQkxPQ0tfU0laRTsKIAotICAgIHhlbl9wdl9wcmludGYoJmJs a2Rldi0+eGVuZGV2LCAzLCAiZ3JhbnQgY29weSBvcGVyYXRpb24gJXNcbiIsCi0gICAgICAgICAg ICAgICAgICB4ZW5fZmVhdHVyZV9ncmFudF9jb3B5ID8gImVuYWJsZWQiIDogImRpc2FibGVkIik7 Ci0KICAgICAvKiBmaWxsIGluZm8KICAgICAgKiBibGtfY29ubmVjdCBzdXBwbGllcyBzZWN0b3It c2l6ZSBhbmQgc2VjdG9ycwogICAgICAqLwogICAgIHhlbnN0b3JlX3dyaXRlX2JlX2ludCgmYmxr ZGV2LT54ZW5kZXYsICJmZWF0dXJlLWZsdXNoLWNhY2hlIiwgMSk7Ci0gICAgeGVuc3RvcmVfd3Jp dGVfYmVfaW50KCZibGtkZXYtPnhlbmRldiwgImZlYXR1cmUtcGVyc2lzdGVudCIsCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICF4ZW5fZmVhdHVyZV9ncmFudF9jb3B5KTsKICAgICB4ZW5zdG9y ZV93cml0ZV9iZV9pbnQoJmJsa2Rldi0+eGVuZGV2LCAiaW5mbyIsIGluZm8pOwogCiAgICAgeGVu c3RvcmVfd3JpdGVfYmVfaW50KCZibGtkZXYtPnhlbmRldiwgIm1heC1yaW5nLXBhZ2Utb3JkZXIi LApAQCAtMTAzNCwxOSArNzY3LDEwIEBAIG91dF9lcnJvcjoKICAgICByZXR1cm4gLTE7CiB9CiAK LS8qCi0gKiBXZSBuZWVkIHRvIGFjY291bnQgZm9yIHRoZSBncmFudCBhbGxvY2F0aW9ucyByZXF1 aXJpbmcgY29udGlndW91cwotICogY2h1bmtzOyB0aGUgd29yc3QgY2FzZSBudW1iZXIgd291bGQg YmUKLSAqICAgICBtYXhfcmVxICogbWF4X3NlZyArIChtYXhfcmVxIC0gMSkgKiAobWF4X3NlZyAt IDEpICsgMSwKLSAqIGJ1dCBpbiBvcmRlciB0byBrZWVwIHRoaW5ncyBzaW1wbGUganVzdCB1c2UK LSAqICAgICAyICogbWF4X3JlcSAqIG1heF9zZWcuCi0gKi8KLSNkZWZpbmUgTUFYX0dSQU5UUyht YXhfcmVxLCBtYXhfc2VnKSAoMiAqIChtYXhfcmVxKSAqIChtYXhfc2VnKSkKLQogc3RhdGljIGlu dCBibGtfY29ubmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCiB7CiAgICAgc3RydWN0IFhl bkJsa0RldiAqYmxrZGV2ID0gY29udGFpbmVyX29mKHhlbmRldiwgc3RydWN0IFhlbkJsa0Rldiwg eGVuZGV2KTsKLSAgICBpbnQgcGVycywgaW5kZXgsIHFmbGFnczsKKyAgICBpbnQgaW5kZXgsIHFm bGFnczsKICAgICBib29sIHJlYWRvbmx5ID0gdHJ1ZTsKICAgICBib29sIHdyaXRldGhyb3VnaCA9 IHRydWU7CiAgICAgaW50IG9yZGVyLCByaW5nX3JlZjsKQEAgLTExNjgsMTEgKzg5Miw2IEBAIHN0 YXRpYyBpbnQgYmxrX2Nvbm5lY3Qoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAmYmxrZGV2LT54ZW5kZXYucmVtb3RlX3BvcnQpID09IC0xKSB7 CiAgICAgICAgIHJldHVybiAtMTsKICAgICB9Ci0gICAgaWYgKHhlbnN0b3JlX3JlYWRfZmVfaW50 KCZibGtkZXYtPnhlbmRldiwgImZlYXR1cmUtcGVyc2lzdGVudCIsICZwZXJzKSkgewotICAgICAg ICBibGtkZXYtPmZlYXR1cmVfcGVyc2lzdGVudCA9IEZBTFNFOwotICAgIH0gZWxzZSB7Ci0gICAg ICAgIGJsa2Rldi0+ZmVhdHVyZV9wZXJzaXN0ZW50ID0gISFwZXJzOwotICAgIH0KIAogICAgIGlm ICghYmxrZGV2LT54ZW5kZXYucHJvdG9jb2wpIHsKICAgICAgICAgYmxrZGV2LT5wcm90b2NvbCA9 IEJMS0lGX1BST1RPQ09MX05BVElWRTsKQEAgLTEyMDcsMTEgKzkyNiw4IEBAIHN0YXRpYyBpbnQg YmxrX2Nvbm5lY3Qoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAgICAgICByZXR1cm4gLTE7 CiAgICAgfQogCi0gICAgLyogQ2FsY3VsYXRlIHRoZSBtYXhpbXVtIG51bWJlciBvZiBncmFudHMg bmVlZGVkIGJ5IGlvcmVxcyAqLwotICAgIG1heF9ncmFudHMgPSBNQVhfR1JBTlRTKGJsa2Rldi0+ bWF4X3JlcXVlc3RzLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgIEJMS0lGX01BWF9TRUdN RU5UU19QRVJfUkVRVUVTVCk7CiAgICAgLyogQWRkIG9uIHRoZSBudW1iZXIgbmVlZGVkIGZvciB0 aGUgcmluZyBwYWdlcyAqLwotICAgIG1heF9ncmFudHMgKz0gYmxrZGV2LT5ucl9yaW5nX3JlZjsK KyAgICBtYXhfZ3JhbnRzID0gYmxrZGV2LT5ucl9yaW5nX3JlZjsKIAogICAgIHhlbl9iZV9zZXRf bWF4X2dyYW50X3JlZnMoeGVuZGV2LCBtYXhfZ3JhbnRzKTsKIApAQCAtMTIyMiw4ICs5MzgsNiBA QCBzdGF0aWMgaW50IGJsa19jb25uZWN0KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKICAgICAg ICAgcmV0dXJuIC0xOwogICAgIH0KIAotICAgIGJsa2Rldi0+Y250X21hcCsrOwotCiAgICAgc3dp dGNoIChibGtkZXYtPnByb3RvY29sKSB7CiAgICAgY2FzZSBCTEtJRl9QUk9UT0NPTF9OQVRJVkU6 CiAgICAgewpAQCAtMTI0NywxOSArOTYxLDYgQEAgc3RhdGljIGludCBibGtfY29ubmVjdChzdHJ1 Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCiAgICAgfQogICAgIH0KIAotICAgIGlmIChibGtkZXYtPmZl YXR1cmVfcGVyc2lzdGVudCkgewotICAgICAgICAvKiBJbml0IHBlcnNpc3RlbnQgZ3JhbnRzICov Ci0gICAgICAgIGJsa2Rldi0+bWF4X2dyYW50cyA9IGJsa2Rldi0+bWF4X3JlcXVlc3RzICoKLSAg ICAgICAgICAgIEJMS0lGX01BWF9TRUdNRU5UU19QRVJfUkVRVUVTVDsKLSAgICAgICAgYmxrZGV2 LT5wZXJzaXN0ZW50X2dudHMgPSBnX3RyZWVfbmV3X2Z1bGwoKEdDb21wYXJlRGF0YUZ1bmMpaW50 X2NtcCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEws IE5VTEwsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBiYXRj aF9tYXBzID8KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChH RGVzdHJveU5vdGlmeSlnX2ZyZWUgOgotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgKEdEZXN0cm95Tm90aWZ5KWRlc3Ryb3lfZ3JhbnQpOwotICAgICAgICBibGtk ZXYtPnBlcnNpc3RlbnRfcmVnaW9ucyA9IE5VTEw7Ci0gICAgICAgIGJsa2Rldi0+cGVyc2lzdGVu dF9nbnRfY291bnQgPSAwOwotICAgIH0KLQogICAgIGJsa19zZXRfYWlvX2NvbnRleHQoYmxrZGV2 LT5ibGssIGJsa2Rldi0+Y3R4KTsKIAogICAgIHhlbl9iZV9iaW5kX2V2dGNobigmYmxrZGV2LT54 ZW5kZXYpOwpAQCAtMTI5MiwyOSArOTkzLDggQEAgc3RhdGljIHZvaWQgYmxrX2Rpc2Nvbm5lY3Qo c3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAgIGlmIChibGtkZXYtPnNyaW5nKSB7CiAgICAg ICAgIHhlbl9iZV91bm1hcF9ncmFudF9yZWZzKHhlbmRldiwgYmxrZGV2LT5zcmluZywKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgYmxrZGV2LT5ucl9yaW5nX3JlZik7Ci0gICAgICAg IGJsa2Rldi0+Y250X21hcC0tOwogICAgICAgICBibGtkZXYtPnNyaW5nID0gTlVMTDsKICAgICB9 Ci0KLSAgICAvKgotICAgICAqIFVubWFwIHBlcnNpc3RlbnQgZ3JhbnRzIGJlZm9yZSBzd2l0Y2hp bmcgdG8gdGhlIGNsb3NlZCBzdGF0ZQotICAgICAqIHNvIHRoZSBmcm9udGVuZCBjYW4gZnJlZSB0 aGVtLgotICAgICAqCi0gICAgICogSW4gdGhlICFiYXRjaF9tYXBzIGNhc2UgZ190cmVlX2Rlc3Ry b3kgd2lsbCB0YWtlIGNhcmUgb2YgdW5tYXBwaW5nCi0gICAgICogdGhlIGdyYW50LCBidXQgaW4g dGhlIGJhdGNoX21hcHMgY2FzZSB3ZSBuZWVkIHRvIGl0ZXJhdGUgb3ZlciBldmVyeQotICAgICAq IHJlZ2lvbiBpbiBwZXJzaXN0ZW50X3JlZ2lvbnMgYW5kIHVubWFwIGl0LgotICAgICAqLwotICAg IGlmIChibGtkZXYtPmZlYXR1cmVfcGVyc2lzdGVudCkgewotICAgICAgICBnX3RyZWVfZGVzdHJv eShibGtkZXYtPnBlcnNpc3RlbnRfZ250cyk7Ci0gICAgICAgIGFzc2VydChiYXRjaF9tYXBzIHx8 IGJsa2Rldi0+cGVyc2lzdGVudF9nbnRfY291bnQgPT0gMCk7Ci0gICAgICAgIGlmIChiYXRjaF9t YXBzKSB7Ci0gICAgICAgICAgICBibGtkZXYtPnBlcnNpc3RlbnRfZ250X2NvdW50ID0gMDsKLSAg ICAgICAgICAgIGdfc2xpc3RfZm9yZWFjaChibGtkZXYtPnBlcnNpc3RlbnRfcmVnaW9ucywKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAoR0Z1bmMpcmVtb3ZlX3BlcnNpc3RlbnRfcmVnaW9u LCBibGtkZXYpOwotICAgICAgICAgICAgZ19zbGlzdF9mcmVlKGJsa2Rldi0+cGVyc2lzdGVudF9y ZWdpb25zKTsKLSAgICAgICAgfQotICAgICAgICBibGtkZXYtPmZlYXR1cmVfcGVyc2lzdGVudCA9 IGZhbHNlOwotICAgIH0KIH0KIAogc3RhdGljIGludCBibGtfZnJlZShzdHJ1Y3QgWGVuRGV2aWNl ICp4ZW5kZXYpCi0tIAoyLjEuNAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbnBy b2plY3Qub3JnCmh0dHBzOi8vbGlzdHMueGVucHJvamVjdC5vcmcvbWFpbG1hbi9saXN0aW5mby94 ZW4tZGV2ZWw=