From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:54818) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1brJTA-0001uR-FI for qemu-devel@nongnu.org; Tue, 04 Oct 2016 02:44:58 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1brJT1-0005pt-1o for qemu-devel@nongnu.org; Tue, 04 Oct 2016 02:44:51 -0400 Received: from mail-wm0-x243.google.com ([2a00:1450:400c:c09::243]:36493) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1brJT0-0005p6-Dq for qemu-devel@nongnu.org; Tue, 04 Oct 2016 02:44:42 -0400 Received: by mail-wm0-x243.google.com with SMTP id b184so18028632wma.3 for ; Mon, 03 Oct 2016 23:44:42 -0700 (PDT) From: Emil Condrea Date: Tue, 4 Oct 2016 09:43:38 +0300 Message-Id: <1475563424-6604-10-git-send-email-emilcondrea@gmail.com> In-Reply-To: <1475563424-6604-1-git-send-email-emilcondrea@gmail.com> References: <1475563424-6604-1-git-send-email-emilcondrea@gmail.com> Subject: [Qemu-devel] [PATCH 09/15] xen: Rename xen_be_printf to xen_pv_printf List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: xuquan8@huawei.com, anthony.perard@citrix.com, wei.liu2@citrix.com, stefanb@linux.vnet.ibm.com, sstabellini@kernel.org, xen-devel@lists.xen.org, dgdegra@tycho.nsa.gov, eblake@redhat.com, Emil Condrea Prepare xen_be_printf to be used by both backend and frontends: * xen_be_printf -> xen_pv_printf Signed-off-by: Emil Condrea --- hw/block/xen_disk.c | 58 +++++++++++++++++++++++----------------------- hw/char/xen_console.c | 10 ++++---- hw/display/xenfb.c | 42 ++++++++++++++++----------------- hw/net/xen_nic.c | 22 +++++++++--------- hw/usb/xen-usb.c | 38 +++++++++++++++--------------- hw/xen/xen_backend.c | 40 ++++++++++++++++---------------- hw/xen/xen_devconfig.c | 4 ++-- hw/xen/xen_frontend.c | 6 ++--- hw/xen/xen_pvdev.c | 10 ++++---- include/hw/xen/xen_pvdev.h | 2 +- xen-common.c | 4 ++-- 11 files changed, 118 insertions(+), 118 deletions(-) diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c index 0b2db3b..425efba 100644 --- a/hw/block/xen_disk.c +++ b/hw/block/xen_disk.c @@ -168,12 +168,12 @@ static void destroy_grant(gpointer pgnt) xengnttab_handle *gnt = grant->blkdev->xendev.gnttabdev; if (xengnttab_unmap(gnt, grant->page, 1) != 0) { - xen_be_printf(&grant->blkdev->xendev, 0, + xen_pv_printf(&grant->blkdev->xendev, 0, "xengnttab_unmap failed: %s\n", strerror(errno)); } grant->blkdev->persistent_gnt_count--; - xen_be_printf(&grant->blkdev->xendev, 3, + xen_pv_printf(&grant->blkdev->xendev, 3, "unmapped grant %p\n", grant->page); g_free(grant); } @@ -185,11 +185,11 @@ static void remove_persistent_region(gpointer data, gpointer dev) xengnttab_handle *gnt = blkdev->xendev.gnttabdev; if (xengnttab_unmap(gnt, region->addr, region->num) != 0) { - xen_be_printf(&blkdev->xendev, 0, + xen_pv_printf(&blkdev->xendev, 0, "xengnttab_unmap region %p failed: %s\n", region->addr, strerror(errno)); } - xen_be_printf(&blkdev->xendev, 3, + xen_pv_printf(&blkdev->xendev, 3, "unmapped grant region %p with %d pages\n", region->addr, region->num); g_free(region); @@ -256,7 +256,7 @@ static int ioreq_parse(struct ioreq *ioreq) size_t len; int i; - xen_be_printf(&blkdev->xendev, 3, + xen_pv_printf(&blkdev->xendev, 3, "op %d, nr %d, handle %d, id %" PRId64 ", sector %" PRId64 "\n", ioreq->req.operation, ioreq->req.nr_segments, ioreq->req.handle, ioreq->req.id, ioreq->req.sector_number); @@ -276,28 +276,28 @@ static int ioreq_parse(struct ioreq *ioreq) case BLKIF_OP_DISCARD: return 0; default: - xen_be_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n", + xen_pv_printf(&blkdev->xendev, 0, "error: unknown operation (%d)\n", ioreq->req.operation); goto err; }; if (ioreq->req.operation != BLKIF_OP_READ && blkdev->mode[0] != 'w') { - xen_be_printf(&blkdev->xendev, 0, "error: write req for ro device\n"); + xen_pv_printf(&blkdev->xendev, 0, "error: write req for ro device\n"); goto err; } ioreq->start = ioreq->req.sector_number * blkdev->file_blk; for (i = 0; i < ioreq->req.nr_segments; i++) { if (i == BLKIF_MAX_SEGMENTS_PER_REQUEST) { - xen_be_printf(&blkdev->xendev, 0, "error: nr_segments too big\n"); + xen_pv_printf(&blkdev->xendev, 0, "error: nr_segments too big\n"); goto err; } if (ioreq->req.seg[i].first_sect > ioreq->req.seg[i].last_sect) { - xen_be_printf(&blkdev->xendev, 0, "error: first > last sector\n"); + xen_pv_printf(&blkdev->xendev, 0, "error: first > last sector\n"); goto err; } if (ioreq->req.seg[i].last_sect * BLOCK_SIZE >= XC_PAGE_SIZE) { - xen_be_printf(&blkdev->xendev, 0, "error: page crossing\n"); + xen_pv_printf(&blkdev->xendev, 0, "error: page crossing\n"); goto err; } @@ -309,7 +309,7 @@ static int ioreq_parse(struct ioreq *ioreq) qemu_iovec_add(&ioreq->v, (void*)mem, len); } if (ioreq->start + ioreq->v.size > blkdev->file_size) { - xen_be_printf(&blkdev->xendev, 0, "error: access beyond end of file\n"); + xen_pv_printf(&blkdev->xendev, 0, "error: access beyond end of file\n"); goto err; } return 0; @@ -332,7 +332,7 @@ static void ioreq_unmap(struct ioreq *ioreq) return; } if (xengnttab_unmap(gnt, ioreq->pages, ioreq->num_unmap) != 0) { - xen_be_printf(&ioreq->blkdev->xendev, 0, + xen_pv_printf(&ioreq->blkdev->xendev, 0, "xengnttab_unmap failed: %s\n", strerror(errno)); } @@ -344,7 +344,7 @@ static void ioreq_unmap(struct ioreq *ioreq) continue; } if (xengnttab_unmap(gnt, ioreq->page[i], 1) != 0) { - xen_be_printf(&ioreq->blkdev->xendev, 0, + xen_pv_printf(&ioreq->blkdev->xendev, 0, "xengnttab_unmap failed: %s\n", strerror(errno)); } @@ -382,7 +382,7 @@ static int ioreq_map(struct ioreq *ioreq) if (grant != NULL) { page[i] = grant->page; - xen_be_printf(&ioreq->blkdev->xendev, 3, + xen_pv_printf(&ioreq->blkdev->xendev, 3, "using persistent-grant %" PRIu32 "\n", ioreq->refs[i]); } else { @@ -411,7 +411,7 @@ static int ioreq_map(struct ioreq *ioreq) ioreq->pages = xengnttab_map_grant_refs (gnt, new_maps, domids, refs, ioreq->prot); if (ioreq->pages == NULL) { - xen_be_printf(&ioreq->blkdev->xendev, 0, + 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; @@ -427,7 +427,7 @@ static int ioreq_map(struct ioreq *ioreq) ioreq->page[i] = xengnttab_map_grant_ref (gnt, domids[i], refs[i], ioreq->prot); if (ioreq->page[i] == NULL) { - xen_be_printf(&ioreq->blkdev->xendev, 0, + 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; @@ -475,7 +475,7 @@ static int ioreq_map(struct ioreq *ioreq) grant->page = ioreq->page[new_maps]; } grant->blkdev = ioreq->blkdev; - xen_be_printf(&ioreq->blkdev->xendev, 3, + 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, @@ -558,7 +558,7 @@ static int ioreq_grant_copy(struct ioreq *ioreq) rc = xengnttab_grant_copy(gnt, count, segs); if (rc) { - xen_be_printf(&ioreq->blkdev->xendev, 0, + xen_pv_printf(&ioreq->blkdev->xendev, 0, "failed to copy data %d\n", rc); ioreq->aio_errors++; return -1; @@ -566,7 +566,7 @@ static int ioreq_grant_copy(struct ioreq *ioreq) for (i = 0; i < count; i++) { if (segs[i].status != GNTST_okay) { - xen_be_printf(&ioreq->blkdev->xendev, 3, + xen_pv_printf(&ioreq->blkdev->xendev, 3, "failed to copy data %d for gref %d, domid %d\n", segs[i].status, ioreq->refs[i], ioreq->domids[i]); ioreq->aio_errors++; @@ -600,7 +600,7 @@ static void qemu_aio_complete(void *opaque, int ret) struct ioreq *ioreq = opaque; if (ret != 0) { - xen_be_printf(&ioreq->blkdev->xendev, 0, "%s I/O error\n", + xen_pv_printf(&ioreq->blkdev->xendev, 0, "%s I/O error\n", ioreq->req.operation == BLKIF_OP_READ ? "read" : "write"); ioreq->aio_errors++; } @@ -911,7 +911,7 @@ static void blk_alloc(struct XenDevice *xendev) } if (xengnttab_set_max_grants(xendev->gnttabdev, MAX_GRANTS(max_requests, BLKIF_MAX_SEGMENTS_PER_REQUEST)) < 0) { - xen_be_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", + xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", strerror(errno)); } } @@ -1057,11 +1057,11 @@ static int blk_connect(struct XenDevice *xendev) } /* setup via xenbus -> create new block driver instance */ - xen_be_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n"); + xen_pv_printf(&blkdev->xendev, 2, "create new bdrv (xenbus setup)\n"); blkdev->blk = blk_new_open(blkdev->filename, NULL, options, qflags, &local_err); if (!blkdev->blk) { - xen_be_printf(&blkdev->xendev, 0, "error: %s\n", + xen_pv_printf(&blkdev->xendev, 0, "error: %s\n", error_get_pretty(local_err)); error_free(local_err); return -1; @@ -1069,11 +1069,11 @@ static int blk_connect(struct XenDevice *xendev) blk_set_enable_write_cache(blkdev->blk, !writethrough); } else { /* setup via qemu cmdline -> already setup for us */ - xen_be_printf(&blkdev->xendev, 2, + xen_pv_printf(&blkdev->xendev, 2, "get configured bdrv (cmdline setup)\n"); blkdev->blk = blk_by_legacy_dinfo(blkdev->dinfo); if (blk_is_read_only(blkdev->blk) && !readonly) { - xen_be_printf(&blkdev->xendev, 0, "Unexpected read-only drive"); + xen_pv_printf(&blkdev->xendev, 0, "Unexpected read-only drive"); blkdev->blk = NULL; return -1; } @@ -1086,13 +1086,13 @@ static int blk_connect(struct XenDevice *xendev) if (blkdev->file_size < 0) { BlockDriverState *bs = blk_bs(blkdev->blk); const char *drv_name = bs ? bdrv_get_format_name(bs) : NULL; - xen_be_printf(&blkdev->xendev, 1, "blk_getlength: %d (%s) | drv %s\n", + xen_pv_printf(&blkdev->xendev, 1, "blk_getlength: %d (%s) | drv %s\n", (int)blkdev->file_size, strerror(-blkdev->file_size), drv_name ?: "-"); blkdev->file_size = 0; } - xen_be_printf(xendev, 1, "type \"%s\", fileproto \"%s\", filename \"%s\"," + xen_pv_printf(xendev, 1, "type \"%s\", fileproto \"%s\", filename \"%s\"," " size %" PRId64 " (%" PRId64 " MB)\n", blkdev->type, blkdev->fileproto, blkdev->filename, blkdev->file_size, blkdev->file_size >> 20); @@ -1176,10 +1176,10 @@ static int blk_connect(struct XenDevice *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", + xen_pv_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, " + xen_pv_printf(&blkdev->xendev, 1, "ok: proto %s, ring-ref %d, " "remote port %d, local port %d\n", blkdev->xendev.protocol, blkdev->ring_ref, blkdev->xendev.remote_port, blkdev->xendev.local_port); diff --git a/hw/char/xen_console.c b/hw/char/xen_console.c index 399bb5d..b705a06 100644 --- a/hw/char/xen_console.c +++ b/hw/char/xen_console.c @@ -156,14 +156,14 @@ static void xencons_send(struct XenConsole *con) if (len < 1) { if (!con->backlog) { con->backlog = 1; - xen_be_printf(&con->xendev, 1, + xen_pv_printf(&con->xendev, 1, "backlog piling up, nobody listening?\n"); } } else { buffer_advance(&con->buffer, len); if (con->backlog && len == size) { con->backlog = 0; - xen_be_printf(&con->xendev, 1, "backlog is gone\n"); + xen_pv_printf(&con->xendev, 1, "backlog is gone\n"); } } } @@ -188,7 +188,7 @@ static int con_init(struct XenDevice *xendev) type = xenstore_read_str(con->console, "type"); if (!type || strcmp(type, "ioemu") != 0) { - xen_be_printf(xendev, 1, "not for me (type=%s)\n", type); + xen_pv_printf(xendev, 1, "not for me (type=%s)\n", type); ret = -1; goto out; } @@ -241,14 +241,14 @@ static int con_initialise(struct XenDevice *xendev) qemu_chr_add_handlers(con->chr, xencons_can_receive, xencons_receive, NULL, con); } else { - xen_be_printf(xendev, 0, + xen_pv_printf(xendev, 0, "xen_console_init error chardev %s already used\n", con->chr->label); con->chr = NULL; } } - xen_be_printf(xendev, 1, + xen_pv_printf(xendev, 1, "ring mfn %d, remote port %d, local port %d, limit %zd\n", con->ring_ref, con->xendev.remote_port, diff --git a/hw/display/xenfb.c b/hw/display/xenfb.c index 9b10b35..55aca85 100644 --- a/hw/display/xenfb.c +++ b/hw/display/xenfb.c @@ -104,7 +104,7 @@ static int common_bind(struct common *c) return -1; xen_be_bind_evtchn(&c->xendev); - xen_be_printf(&c->xendev, 1, + xen_pv_printf(&c->xendev, 1, "ring mfn %"PRI_xen_pfn", remote-port %d, local-port %d\n", mfn, c->xendev.remote_port, c->xendev.local_port); @@ -347,7 +347,7 @@ static int input_initialise(struct XenDevice *xendev) int rc; if (!in->c.con) { - xen_be_printf(xendev, 1, "ds not set (yet)\n"); + xen_pv_printf(xendev, 1, "ds not set (yet)\n"); return -1; } @@ -512,44 +512,44 @@ static int xenfb_configure_fb(struct XenFB *xenfb, size_t fb_len_lim, int max_width, max_height; if (fb_len_lim > fb_len_max) { - xen_be_printf(&xenfb->c.xendev, 0, + xen_pv_printf(&xenfb->c.xendev, 0, "fb size limit %zu exceeds %zu, corrected\n", fb_len_lim, fb_len_max); fb_len_lim = fb_len_max; } if (fb_len_lim && fb_len > fb_len_lim) { - xen_be_printf(&xenfb->c.xendev, 0, + xen_pv_printf(&xenfb->c.xendev, 0, "frontend fb size %zu limited to %zu\n", fb_len, fb_len_lim); fb_len = fb_len_lim; } if (depth != 8 && depth != 16 && depth != 24 && depth != 32) { - xen_be_printf(&xenfb->c.xendev, 0, + xen_pv_printf(&xenfb->c.xendev, 0, "can't handle frontend fb depth %d\n", depth); return -1; } if (row_stride <= 0 || row_stride > fb_len) { - xen_be_printf(&xenfb->c.xendev, 0, "invalid frontend stride %d\n", + xen_pv_printf(&xenfb->c.xendev, 0, "invalid frontend stride %d\n", row_stride); return -1; } max_width = row_stride / (depth / 8); if (width < 0 || width > max_width) { - xen_be_printf(&xenfb->c.xendev, 0, + xen_pv_printf(&xenfb->c.xendev, 0, "invalid frontend width %d limited to %d\n", width, max_width); width = max_width; } if (offset < 0 || offset >= fb_len) { - xen_be_printf(&xenfb->c.xendev, 0, + xen_pv_printf(&xenfb->c.xendev, 0, "invalid frontend offset %d (max %zu)\n", offset, fb_len - 1); return -1; } max_height = (fb_len - offset) / row_stride; if (height < 0 || height > max_height) { - xen_be_printf(&xenfb->c.xendev, 0, + xen_pv_printf(&xenfb->c.xendev, 0, "invalid frontend height %d limited to %d\n", height, max_height); height = max_height; @@ -562,7 +562,7 @@ static int xenfb_configure_fb(struct XenFB *xenfb, size_t fb_len_lim, xenfb->offset = offset; xenfb->up_fullscreen = 1; xenfb->do_resize = 1; - xen_be_printf(&xenfb->c.xendev, 1, + xen_pv_printf(&xenfb->c.xendev, 1, "framebuffer %dx%dx%d offset %d stride %d\n", width, height, depth, offset, row_stride); return 0; @@ -641,7 +641,7 @@ static void xenfb_guest_copy(struct XenFB *xenfb, int x, int y, int w, int h) } } if (oops) /* should not happen */ - xen_be_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n", + xen_pv_printf(&xenfb->c.xendev, 0, "%s: oops: convert %d -> %d bpp?\n", __FUNCTION__, xenfb->depth, bpp); dpy_gfx_update(xenfb->c.con, x, y, w, h); @@ -731,7 +731,7 @@ static void xenfb_update(void *opaque) break; } dpy_gfx_replace_surface(xenfb->c.con, surface); - xen_be_printf(&xenfb->c.xendev, 1, + xen_pv_printf(&xenfb->c.xendev, 1, "update: resizing: %dx%d @ %d bpp%s\n", xenfb->width, xenfb->height, xenfb->depth, is_buffer_shared(surface) ? " (shared)" : ""); @@ -740,10 +740,10 @@ static void xenfb_update(void *opaque) /* run queued updates */ if (xenfb->up_fullscreen) { - xen_be_printf(&xenfb->c.xendev, 3, "update: fullscreen\n"); + xen_pv_printf(&xenfb->c.xendev, 3, "update: fullscreen\n"); xenfb_guest_copy(xenfb, 0, 0, xenfb->width, xenfb->height); } else if (xenfb->up_count) { - xen_be_printf(&xenfb->c.xendev, 3, "update: %d rects\n", + xen_pv_printf(&xenfb->c.xendev, 3, "update: %d rects\n", xenfb->up_count); for (i = 0; i < xenfb->up_count; i++) xenfb_guest_copy(xenfb, @@ -752,7 +752,7 @@ static void xenfb_update(void *opaque) xenfb->up_rects[i].w, xenfb->up_rects[i].h); } else { - xen_be_printf(&xenfb->c.xendev, 3, "update: nothing\n"); + xen_pv_printf(&xenfb->c.xendev, 3, "update: nothing\n"); } xenfb->up_count = 0; xenfb->up_fullscreen = 0; @@ -806,14 +806,14 @@ static void xenfb_handle_events(struct XenFB *xenfb) w = MIN(event->update.width, xenfb->width - x); h = MIN(event->update.height, xenfb->height - y); if (w < 0 || h < 0) { - xen_be_printf(&xenfb->c.xendev, 1, "bogus update ignored\n"); + xen_pv_printf(&xenfb->c.xendev, 1, "bogus update ignored\n"); break; } if (x != event->update.x || y != event->update.y || w != event->update.width || h != event->update.height) { - xen_be_printf(&xenfb->c.xendev, 1, "bogus update clipped\n"); + xen_pv_printf(&xenfb->c.xendev, 1, "bogus update clipped\n"); } if (w == xenfb->width && h > xenfb->height / 2) { /* scroll detector: updated more than 50% of the lines, @@ -895,7 +895,7 @@ static int fb_initialise(struct XenDevice *xendev) if (fb->feature_update) xenstore_write_be_int(xendev, "request-update", 1); - xen_be_printf(xendev, 1, "feature-update=%d, videoram=%d\n", + xen_pv_printf(xendev, 1, "feature-update=%d, videoram=%d\n", fb->feature_update, videoram); return 0; } @@ -914,7 +914,7 @@ static void fb_disconnect(struct XenDevice *xendev) PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0); if (fb->pixels == MAP_FAILED) { - xen_be_printf(xendev, 0, + xen_pv_printf(xendev, 0, "Couldn't replace the framebuffer with anonymous memory errno=%d\n", errno); } @@ -935,7 +935,7 @@ static void fb_frontend_changed(struct XenDevice *xendev, const char *node) if (fb->bug_trigger == 0 && strcmp(node, "state") == 0 && xendev->fe_state == XenbusStateConnected && xendev->be_state == XenbusStateConnected) { - xen_be_printf(xendev, 2, "re-trigger connected (frontend bug)\n"); + xen_pv_printf(xendev, 2, "re-trigger connected (frontend bug)\n"); xen_be_set_state(xendev, XenbusStateConnected); fb->bug_trigger = 1; /* only once */ } @@ -996,7 +996,7 @@ wait_more: usleep(10000); goto wait_more; } - xen_be_printf(NULL, 1, "displaystate setup failed\n"); + xen_pv_printf(NULL, 1, "displaystate setup failed\n"); return; } diff --git a/hw/net/xen_nic.c b/hw/net/xen_nic.c index 8db3448..7418a7b 100644 --- a/hw/net/xen_nic.c +++ b/hw/net/xen_nic.c @@ -129,31 +129,31 @@ static void net_tx_packets(struct XenNetDev *netdev) /* should not happen in theory, we don't announce the * * feature-{sg,gso,whatelse} flags in xenstore (yet?) */ if (txreq.flags & NETTXF_extra_info) { - xen_be_printf(&netdev->xendev, 0, "FIXME: extra info flag\n"); + xen_pv_printf(&netdev->xendev, 0, "FIXME: extra info flag\n"); net_tx_error(netdev, &txreq, rc); continue; } if (txreq.flags & NETTXF_more_data) { - xen_be_printf(&netdev->xendev, 0, "FIXME: more data flag\n"); + xen_pv_printf(&netdev->xendev, 0, "FIXME: more data flag\n"); net_tx_error(netdev, &txreq, rc); continue; } #endif if (txreq.size < 14) { - xen_be_printf(&netdev->xendev, 0, "bad packet size: %d\n", + xen_pv_printf(&netdev->xendev, 0, "bad packet size: %d\n", txreq.size); net_tx_error(netdev, &txreq, rc); continue; } if ((txreq.offset + txreq.size) > XC_PAGE_SIZE) { - xen_be_printf(&netdev->xendev, 0, "error: page crossing\n"); + xen_pv_printf(&netdev->xendev, 0, "error: page crossing\n"); net_tx_error(netdev, &txreq, rc); continue; } - xen_be_printf(&netdev->xendev, 3, + xen_pv_printf(&netdev->xendev, 3, "tx packet ref %d, off %d, len %d, flags 0x%x%s%s%s%s\n", txreq.gref, txreq.offset, txreq.size, txreq.flags, (txreq.flags & NETTXF_csum_blank) ? " csum_blank" : "", @@ -165,7 +165,7 @@ static void net_tx_packets(struct XenNetDev *netdev) netdev->xendev.dom, txreq.gref, PROT_READ); if (page == NULL) { - xen_be_printf(&netdev->xendev, 0, + xen_pv_printf(&netdev->xendev, 0, "error: tx gref dereference failed (%d)\n", txreq.gref); net_tx_error(netdev, &txreq, rc); @@ -215,7 +215,7 @@ static void net_rx_response(struct XenNetDev *netdev, resp->status = (int16_t)st; } - xen_be_printf(&netdev->xendev, 3, + xen_pv_printf(&netdev->xendev, 3, "rx response: idx %d, status %d, flags 0x%x\n", i, resp->status, resp->flags); @@ -247,7 +247,7 @@ static ssize_t net_rx_packet(NetClientState *nc, const uint8_t *buf, size_t size return 0; } if (size > XC_PAGE_SIZE - NET_IP_ALIGN) { - xen_be_printf(&netdev->xendev, 0, "packet too big (%lu > %ld)", + xen_pv_printf(&netdev->xendev, 0, "packet too big (%lu > %ld)", (unsigned long)size, XC_PAGE_SIZE - NET_IP_ALIGN); return -1; } @@ -259,7 +259,7 @@ static ssize_t net_rx_packet(NetClientState *nc, const uint8_t *buf, size_t size netdev->xendev.dom, rxreq.gref, PROT_WRITE); if (page == NULL) { - xen_be_printf(&netdev->xendev, 0, + xen_pv_printf(&netdev->xendev, 0, "error: rx gref dereference failed (%d)\n", rxreq.gref); net_rx_response(netdev, &rxreq, NETIF_RSP_ERROR, 0, 0, 0); @@ -334,7 +334,7 @@ static int net_connect(struct XenDevice *xendev) rx_copy = 0; } if (rx_copy == 0) { - xen_be_printf(&netdev->xendev, 0, + xen_pv_printf(&netdev->xendev, 0, "frontend doesn't support rx-copy.\n"); return -1; } @@ -360,7 +360,7 @@ static int net_connect(struct XenDevice *xendev) xen_be_bind_evtchn(&netdev->xendev); - xen_be_printf(&netdev->xendev, 1, "ok: tx-ring-ref %d, rx-ring-ref %d, " + xen_pv_printf(&netdev->xendev, 1, "ok: tx-ring-ref %d, rx-ring-ref %d, " "remote port %d, local port %d\n", netdev->tx_ring_ref, netdev->rx_ring_ref, netdev->xendev.remote_port, netdev->xendev.local_port); diff --git a/hw/usb/xen-usb.c b/hw/usb/xen-usb.c index 10773f2..a245355 100644 --- a/hw/usb/xen-usb.c +++ b/hw/usb/xen-usb.c @@ -48,7 +48,7 @@ struct timeval tv; \ \ gettimeofday(&tv, NULL); \ - xen_be_printf(xendev, lvl, "%8ld.%06ld xen-usb(%s):" fmt, \ + xen_pv_printf(xendev, lvl, "%8ld.%06ld xen-usb(%s):" fmt, \ tv.tv_sec, tv.tv_usec, __func__, ##args); \ } #define TR_BUS(xendev, fmt, args...) TR(xendev, 2, fmt, ##args) @@ -154,7 +154,7 @@ static int usbback_gnttab_map(struct usbback_req *usbback_req) } if (nr_segs > USBIF_MAX_SEGMENTS_PER_REQUEST) { - xen_be_printf(xendev, 0, "bad number of segments in request (%d)\n", + xen_pv_printf(xendev, 0, "bad number of segments in request (%d)\n", nr_segs); return -EINVAL; } @@ -162,7 +162,7 @@ static int usbback_gnttab_map(struct usbback_req *usbback_req) for (i = 0; i < nr_segs; i++) { if ((unsigned)usbback_req->req.seg[i].offset + (unsigned)usbback_req->req.seg[i].length > PAGE_SIZE) { - xen_be_printf(xendev, 0, "segment crosses page boundary\n"); + xen_pv_printf(xendev, 0, "segment crosses page boundary\n"); return -EINVAL; } } @@ -200,7 +200,7 @@ static int usbback_gnttab_map(struct usbback_req *usbback_req) */ if (!usbback_req->nr_extra_segs) { - xen_be_printf(xendev, 0, "iso request without descriptor segments\n"); + xen_pv_printf(xendev, 0, "iso request without descriptor segments\n"); return -EINVAL; } @@ -552,14 +552,14 @@ static void usbback_dispatch(struct usbback_req *usbback_req) ret = usbback_init_packet(usbback_req); if (ret) { - xen_be_printf(&usbif->xendev, 0, "invalid request\n"); + xen_pv_printf(&usbif->xendev, 0, "invalid request\n"); ret = -ESHUTDOWN; goto fail_free_urb; } ret = usbback_gnttab_map(usbback_req); if (ret) { - xen_be_printf(&usbif->xendev, 0, "invalid buffer, ret=%d\n", ret); + xen_pv_printf(&usbif->xendev, 0, "invalid buffer, ret=%d\n", ret); ret = -ESHUTDOWN; goto fail_free_urb; } @@ -647,7 +647,7 @@ static void usbback_bh(void *opaque) if (RING_REQUEST_PROD_OVERFLOW(urb_ring, rp)) { rc = urb_ring->rsp_prod_pvt; - xen_be_printf(&usbif->xendev, 0, "domU provided bogus ring requests " + xen_pv_printf(&usbif->xendev, 0, "domU provided bogus ring requests " "(%#x - %#x = %u). Halting ring processing.\n", rp, rc, rp - rc); usbif->ring_error = true; @@ -745,7 +745,7 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port, portname = strchr(busid, '-'); if (!portname) { - xen_be_printf(&usbif->xendev, 0, "device %s illegal specification\n", + xen_pv_printf(&usbif->xendev, 0, "device %s illegal specification\n", busid); return; } @@ -784,7 +784,7 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port, break; } if (speed == USBIF_SPEED_NONE) { - xen_be_printf(&usbif->xendev, 0, "device %s wrong speed\n", busid); + xen_pv_printf(&usbif->xendev, 0, "device %s wrong speed\n", busid); object_unparent(OBJECT(usbif->ports[port - 1].dev)); usbif->ports[port - 1].dev = NULL; return; @@ -801,7 +801,7 @@ static void usbback_portid_add(struct usbback_info *usbif, unsigned port, err: QDECREF(qdict); snprintf(p->path, sizeof(p->path), "%d", 99); - xen_be_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid); + xen_pv_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid); } static void usbback_process_port(struct usbback_info *usbif, unsigned port) @@ -812,7 +812,7 @@ static void usbback_process_port(struct usbback_info *usbif, unsigned port) snprintf(node, sizeof(node), "port/%d", port); busid = xenstore_read_be_str(&usbif->xendev, node); if (busid == NULL) { - xen_be_printf(&usbif->xendev, 0, "xenstore_read %s failed\n", node); + xen_pv_printf(&usbif->xendev, 0, "xenstore_read %s failed\n", node); return; } @@ -869,15 +869,15 @@ static int usbback_connect(struct XenDevice *xendev) usbif = container_of(xendev, struct usbback_info, xendev); if (xenstore_read_fe_int(xendev, "urb-ring-ref", &urb_ring_ref)) { - xen_be_printf(xendev, 0, "error reading urb-ring-ref\n"); + xen_pv_printf(xendev, 0, "error reading urb-ring-ref\n"); return -1; } if (xenstore_read_fe_int(xendev, "conn-ring-ref", &conn_ring_ref)) { - xen_be_printf(xendev, 0, "error reading conn-ring-ref\n"); + xen_pv_printf(xendev, 0, "error reading conn-ring-ref\n"); return -1; } if (xenstore_read_fe_int(xendev, "event-channel", &xendev->remote_port)) { - xen_be_printf(xendev, 0, "error reading event-channel\n"); + xen_pv_printf(xendev, 0, "error reading event-channel\n"); return -1; } @@ -888,7 +888,7 @@ static int usbback_connect(struct XenDevice *xendev) conn_ring_ref, PROT_READ | PROT_WRITE); if (!usbif->urb_sring || !usbif->conn_sring) { - xen_be_printf(xendev, 0, "error mapping rings\n"); + xen_pv_printf(xendev, 0, "error mapping rings\n"); usbback_disconnect(xendev); return -1; } @@ -900,7 +900,7 @@ static int usbback_connect(struct XenDevice *xendev) xen_be_bind_evtchn(xendev); - xen_be_printf(xendev, 1, "urb-ring-ref %d, conn-ring-ref %d, " + xen_pv_printf(xendev, 1, "urb-ring-ref %d, conn-ring-ref %d, " "remote port %d, local port %d\n", urb_ring_ref, conn_ring_ref, xendev->remote_port, xendev->local_port); @@ -936,12 +936,12 @@ static int usbback_init(struct XenDevice *xendev) if (xenstore_read_be_int(xendev, "num-ports", &usbif->num_ports) || usbif->num_ports < 1 || usbif->num_ports > USBBACK_MAXPORTS) { - xen_be_printf(xendev, 0, "num-ports not readable or out of bounds\n"); + xen_pv_printf(xendev, 0, "num-ports not readable or out of bounds\n"); return -1; } if (xenstore_read_be_int(xendev, "usb-ver", &usbif->usb_ver) || (usbif->usb_ver != USB_VER_USB11 && usbif->usb_ver != USB_VER_USB20)) { - xen_be_printf(xendev, 0, "usb-ver not readable or out of bounds\n"); + xen_pv_printf(xendev, 0, "usb-ver not readable or out of bounds\n"); return -1; } @@ -1029,7 +1029,7 @@ static void usbback_alloc(struct XenDevice *xendev) /* max_grants: for each request and for the rings (request and connect). */ max_grants = USBIF_MAX_SEGMENTS_PER_REQUEST * USB_URB_RING_SIZE + 2; if (xengnttab_set_max_grants(xendev->gnttabdev, max_grants) < 0) { - xen_be_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", + xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", strerror(errno)); } } diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c index 3518aac..97869cf 100644 --- a/hw/xen/xen_backend.c +++ b/hw/xen/xen_backend.c @@ -85,7 +85,7 @@ int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state) if (rc < 0) { return rc; } - xen_be_printf(xendev, 1, "backend state: %s -> %s\n", + xen_pv_printf(xendev, 1, "backend state: %s -> %s\n", xenbus_strstate(xendev->be_state), xenbus_strstate(state)); xendev->be_state = state; return 0; @@ -121,7 +121,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev, xendev->evtchndev = xenevtchn_open(NULL, 0); if (xendev->evtchndev == NULL) { - xen_be_printf(NULL, 0, "can't open evtchn device\n"); + xen_pv_printf(NULL, 0, "can't open evtchn device\n"); g_free(xendev); return NULL; } @@ -130,7 +130,7 @@ static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev, if (ops->flags & DEVOPS_FLAG_NEED_GNTDEV) { xendev->gnttabdev = xengnttab_open(NULL, 0); if (xendev->gnttabdev == NULL) { - xen_be_printf(NULL, 0, "can't open gnttab device\n"); + xen_pv_printf(NULL, 0, "can't open gnttab device\n"); xenevtchn_close(xendev->evtchndev); g_free(xendev); return NULL; @@ -163,7 +163,7 @@ static void xen_be_backend_changed(struct XenDevice *xendev, const char *node) } if (node) { - xen_be_printf(xendev, 2, "backend update: %s\n", node); + xen_pv_printf(xendev, 2, "backend update: %s\n", node); if (xendev->ops->backend_changed) { xendev->ops->backend_changed(xendev, node); } @@ -187,26 +187,26 @@ static int xen_be_try_setup(struct XenDevice *xendev) int be_state; if (xenstore_read_be_int(xendev, "state", &be_state) == -1) { - xen_be_printf(xendev, 0, "reading backend state failed\n"); + xen_pv_printf(xendev, 0, "reading backend state failed\n"); return -1; } if (be_state != XenbusStateInitialising) { - xen_be_printf(xendev, 0, "initial backend state is wrong (%s)\n", + xen_pv_printf(xendev, 0, "initial backend state is wrong (%s)\n", xenbus_strstate(be_state)); return -1; } xendev->fe = xenstore_read_be_str(xendev, "frontend"); if (xendev->fe == NULL) { - xen_be_printf(xendev, 0, "reading frontend path failed\n"); + xen_pv_printf(xendev, 0, "reading frontend path failed\n"); return -1; } /* setup frontend watch */ snprintf(token, sizeof(token), "fe:%p", xendev); if (!xs_watch(xenstore, xendev->fe, token)) { - xen_be_printf(xendev, 0, "watching frontend path (%s) failed\n", + xen_pv_printf(xendev, 0, "watching frontend path (%s) failed\n", xendev->fe); return -1; } @@ -230,7 +230,7 @@ static int xen_be_try_init(struct XenDevice *xendev) int rc = 0; if (!xendev->online) { - xen_be_printf(xendev, 1, "not online\n"); + xen_pv_printf(xendev, 1, "not online\n"); return -1; } @@ -238,7 +238,7 @@ static int xen_be_try_init(struct XenDevice *xendev) rc = xendev->ops->init(xendev); } if (rc != 0) { - xen_be_printf(xendev, 1, "init() failed\n"); + xen_pv_printf(xendev, 1, "init() failed\n"); return rc; } @@ -261,9 +261,9 @@ static int xen_be_try_initialise(struct XenDevice *xendev) if (xendev->fe_state != XenbusStateInitialised && xendev->fe_state != XenbusStateConnected) { if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) { - xen_be_printf(xendev, 2, "frontend not ready, ignoring\n"); + xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n"); } else { - xen_be_printf(xendev, 2, "frontend not ready (yet)\n"); + xen_pv_printf(xendev, 2, "frontend not ready (yet)\n"); return -1; } } @@ -272,7 +272,7 @@ static int xen_be_try_initialise(struct XenDevice *xendev) rc = xendev->ops->initialise(xendev); } if (rc != 0) { - xen_be_printf(xendev, 0, "initialise() failed\n"); + xen_pv_printf(xendev, 0, "initialise() failed\n"); return rc; } @@ -293,9 +293,9 @@ static void xen_be_try_connected(struct XenDevice *xendev) if (xendev->fe_state != XenbusStateConnected) { if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) { - xen_be_printf(xendev, 2, "frontend not ready, ignoring\n"); + xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n"); } else { - xen_be_printf(xendev, 2, "frontend not ready (yet)\n"); + xen_pv_printf(xendev, 2, "frontend not ready (yet)\n"); return; } } @@ -329,7 +329,7 @@ static int xen_be_try_reset(struct XenDevice *xendev) return -1; } - xen_be_printf(xendev, 1, "device reset (for re-connect)\n"); + xen_pv_printf(xendev, 1, "device reset (for re-connect)\n"); xen_be_set_state(xendev, XenbusStateInitialising); return 0; } @@ -390,7 +390,7 @@ static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops) snprintf(token, sizeof(token), "be:%p:%d:%p", type, dom, ops); snprintf(path, sizeof(path), "backend/%s/%d", type, dom); if (!xs_watch(xenstore, path, token)) { - xen_be_printf(NULL, 0, "xen be: watching backend path (%s) failed\n", + xen_pv_printf(NULL, 0, "xen be: watching backend path (%s) failed\n", path); return -1; } @@ -451,7 +451,7 @@ int xen_be_init(void) { xenstore = xs_daemon_open(); if (!xenstore) { - xen_be_printf(NULL, 0, "can't connect to xenstored\n"); + xen_pv_printf(NULL, 0, "can't connect to xenstored\n"); return -1; } @@ -512,10 +512,10 @@ int xen_be_bind_evtchn(struct XenDevice *xendev) xendev->local_port = xenevtchn_bind_interdomain (xendev->evtchndev, xendev->dom, xendev->remote_port); if (xendev->local_port == -1) { - xen_be_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n"); + xen_pv_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n"); return -1; } - xen_be_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port); + xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port); qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev), xen_be_evtchn_event, NULL, xendev); return 0; diff --git a/hw/xen/xen_devconfig.c b/hw/xen/xen_devconfig.c index b7d290d..a80e78c 100644 --- a/hw/xen/xen_devconfig.c +++ b/hw/xen/xen_devconfig.c @@ -55,7 +55,7 @@ int xen_config_dev_blk(DriveInfo *disk) const char *filename = qemu_opt_get(disk->opts, "file"); snprintf(device_name, sizeof(device_name), "xvd%c", 'a' + disk->unit); - xen_be_printf(NULL, 1, "config disk %d [%s]: %s\n", + xen_pv_printf(NULL, 1, "config disk %d [%s]: %s\n", disk->unit, device_name, filename); xen_config_dev_dirs("vbd", "qdisk", vdev, fe, be, sizeof(fe)); @@ -83,7 +83,7 @@ int xen_config_dev_nic(NICInfo *nic) snprintf(mac, sizeof(mac), "%02x:%02x:%02x:%02x:%02x:%02x", nic->macaddr.a[0], nic->macaddr.a[1], nic->macaddr.a[2], nic->macaddr.a[3], nic->macaddr.a[4], nic->macaddr.a[5]); - xen_be_printf(NULL, 1, "config nic %d: mac=\"%s\"\n", vlan_id, mac); + xen_pv_printf(NULL, 1, "config nic %d: mac=\"%s\"\n", vlan_id, mac); xen_config_dev_dirs("vif", "qnic", vlan_id, fe, be, sizeof(fe)); /* frontend */ diff --git a/hw/xen/xen_frontend.c b/hw/xen/xen_frontend.c index d42e57b..1407f5f 100644 --- a/hw/xen/xen_frontend.c +++ b/hw/xen/xen_frontend.c @@ -48,7 +48,7 @@ void xen_be_frontend_changed(struct XenDevice *xendev, const char *node) fe_state = XenbusStateUnknown; } if (xendev->fe_state != fe_state) { - xen_be_printf(xendev, 1, "frontend state: %s -> %s\n", + xen_pv_printf(xendev, 1, "frontend state: %s -> %s\n", xenbus_strstate(xendev->fe_state), xenbus_strstate(fe_state)); } @@ -58,13 +58,13 @@ void xen_be_frontend_changed(struct XenDevice *xendev, const char *node) g_free(xendev->protocol); xendev->protocol = xenstore_read_fe_str(xendev, "protocol"); if (xendev->protocol) { - xen_be_printf(xendev, 1, "frontend protocol: %s\n", + xen_pv_printf(xendev, 1, "frontend protocol: %s\n", xendev->protocol); } } if (node) { - xen_be_printf(xendev, 2, "frontend update: %s\n", node); + xen_pv_printf(xendev, 2, "frontend update: %s\n", node); if (xendev->ops->frontend_changed) { xendev->ops->frontend_changed(xendev, node); } diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c index 6c92624..15bf95c 100644 --- a/hw/xen/xen_pvdev.c +++ b/hw/xen/xen_pvdev.c @@ -69,13 +69,13 @@ int xenstore_mkdir(char *path, int p) }; if (!xs_mkdir(xenstore, 0, path)) { - xen_be_printf(NULL, 0, "xs_mkdir %s: failed\n", path); + xen_pv_printf(NULL, 0, "xs_mkdir %s: failed\n", path); return -1; } xenstore_cleanup_dir(g_strdup(path)); if (!xs_set_permissions(xenstore, 0, path, perms, 2)) { - xen_be_printf(NULL, 0, "xs_set_permissions %s: failed\n", path); + xen_pv_printf(NULL, 0, "xs_set_permissions %s: failed\n", path); return -1; } return 0; @@ -195,7 +195,7 @@ const char *xenbus_strstate(enum xenbus_state state) * 2 == noisy debug messages (logfile only). * 3 == will flood your log (logfile only). */ -void xen_be_printf(struct XenDevice *xendev, int msg_level, +void xen_pv_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...) { va_list args; @@ -235,7 +235,7 @@ void xen_be_evtchn_event(void *opaque) port = xenevtchn_pending(xendev->evtchndev); if (port != xendev->local_port) { - xen_be_printf(xendev, 0, + xen_pv_printf(xendev, 0, "xenevtchn_pending returned %d (expected %d)\n", port, xendev->local_port); return; @@ -254,7 +254,7 @@ void xen_be_unbind_evtchn(struct XenDevice *xendev) } qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev), NULL, NULL, NULL); xenevtchn_unbind(xendev->evtchndev, xendev->local_port); - xen_be_printf(xendev, 2, "unbind evtchn port %d\n", xendev->local_port); + xen_pv_printf(xendev, 2, "unbind evtchn port %d\n", xendev->local_port); xendev->local_port = -1; } diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h index 337457e..cf26ce5 100644 --- a/include/hw/xen/xen_pvdev.h +++ b/include/hw/xen/xen_pvdev.h @@ -72,7 +72,7 @@ struct XenDevice *xen_be_find_xendev(const char *type, int dom, int dev); void xen_be_unbind_evtchn(struct XenDevice *xendev); int xen_be_send_notify(struct XenDevice *xendev); -void xen_be_printf(struct XenDevice *xendev, int msg_level, +void xen_pv_printf(struct XenDevice *xendev, int msg_level, const char *fmt, ...) GCC_FMT_ATTR(3, 4); #endif /* QEMU_HW_XEN_PVDEV_H */ diff --git a/xen-common.c b/xen-common.c index e641ad1..9099760 100644 --- a/xen-common.c +++ b/xen-common.c @@ -116,12 +116,12 @@ static int xen_init(MachineState *ms) { xen_xc = xc_interface_open(0, 0, 0); if (xen_xc == NULL) { - xen_be_printf(NULL, 0, "can't open xen interface\n"); + xen_pv_printf(NULL, 0, "can't open xen interface\n"); return -1; } xen_fmem = xenforeignmemory_open(0, 0); if (xen_fmem == NULL) { - xen_be_printf(NULL, 0, "can't open xen fmem interface\n"); + xen_pv_printf(NULL, 0, "can't open xen fmem interface\n"); xc_interface_close(xen_xc); return -1; } -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Emil Condrea Subject: [PATCH 09/15] xen: Rename xen_be_printf to xen_pv_printf Date: Tue, 4 Oct 2016 09:43:38 +0300 Message-ID: <1475563424-6604-10-git-send-email-emilcondrea@gmail.com> References: <1475563424-6604-1-git-send-email-emilcondrea@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1475563424-6604-1-git-send-email-emilcondrea@gmail.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: qemu-devel@nongnu.org Cc: xuquan8@huawei.com, sstabellini@kernel.org, wei.liu2@citrix.com, stefanb@linux.vnet.ibm.com, xen-devel@lists.xen.org, anthony.perard@citrix.com, dgdegra@tycho.nsa.gov, eblake@redhat.com, Emil Condrea List-Id: xen-devel@lists.xenproject.org UHJlcGFyZSB4ZW5fYmVfcHJpbnRmIHRvIGJlIHVzZWQgYnkgYm90aCBiYWNrZW5kIGFuZCBmcm9u dGVuZHM6CiAqIHhlbl9iZV9wcmludGYgLT4geGVuX3B2X3ByaW50ZgoKU2lnbmVkLW9mZi1ieTog RW1pbCBDb25kcmVhIDxlbWlsY29uZHJlYUBnbWFpbC5jb20+Ci0tLQogaHcvYmxvY2sveGVuX2Rp c2suYyAgICAgICAgfCA1OCArKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tCiBody9jaGFyL3hlbl9jb25zb2xlLmMgICAgICB8IDEwICsrKystLS0tCiBody9kaXNw bGF5L3hlbmZiLmMgICAgICAgICB8IDQyICsrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0t LQogaHcvbmV0L3hlbl9uaWMuYyAgICAgICAgICAgfCAyMiArKysrKysrKystLS0tLS0tLS0KIGh3 L3VzYi94ZW4tdXNiLmMgICAgICAgICAgIHwgMzggKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0t LS0tCiBody94ZW4veGVuX2JhY2tlbmQuYyAgICAgICB8IDQwICsrKysrKysrKysrKysrKystLS0t LS0tLS0tLS0tLS0tCiBody94ZW4veGVuX2RldmNvbmZpZy5jICAgICB8ICA0ICsrLS0KIGh3L3hl bi94ZW5fZnJvbnRlbmQuYyAgICAgIHwgIDYgKystLS0KIGh3L3hlbi94ZW5fcHZkZXYuYyAgICAg ICAgIHwgMTAgKysrKy0tLS0KIGluY2x1ZGUvaHcveGVuL3hlbl9wdmRldi5oIHwgIDIgKy0KIHhl bi1jb21tb24uYyAgICAgICAgICAgICAgIHwgIDQgKystLQogMTEgZmlsZXMgY2hhbmdlZCwgMTE4 IGluc2VydGlvbnMoKyksIDExOCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9ody9ibG9jay94 ZW5fZGlzay5jIGIvaHcvYmxvY2sveGVuX2Rpc2suYwppbmRleCAwYjJkYjNiLi40MjVlZmJhIDEw MDY0NAotLS0gYS9ody9ibG9jay94ZW5fZGlzay5jCisrKyBiL2h3L2Jsb2NrL3hlbl9kaXNrLmMK QEAgLTE2OCwxMiArMTY4LDEyIEBAIHN0YXRpYyB2b2lkIGRlc3Ryb3lfZ3JhbnQoZ3BvaW50ZXIg cGdudCkKICAgICB4ZW5nbnR0YWJfaGFuZGxlICpnbnQgPSBncmFudC0+YmxrZGV2LT54ZW5kZXYu Z250dGFiZGV2OwogCiAgICAgaWYgKHhlbmdudHRhYl91bm1hcChnbnQsIGdyYW50LT5wYWdlLCAx KSAhPSAwKSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoJmdyYW50LT5ibGtkZXYtPnhlbmRldiwg MCwKKyAgICAgICAgeGVuX3B2X3ByaW50ZigmZ3JhbnQtPmJsa2Rldi0+eGVuZGV2LCAwLAogICAg ICAgICAgICAgICAgICAgICAgICJ4ZW5nbnR0YWJfdW5tYXAgZmFpbGVkOiAlc1xuIiwKICAgICAg ICAgICAgICAgICAgICAgICBzdHJlcnJvcihlcnJubykpOwogICAgIH0KICAgICBncmFudC0+Ymxr ZGV2LT5wZXJzaXN0ZW50X2dudF9jb3VudC0tOwotICAgIHhlbl9iZV9wcmludGYoJmdyYW50LT5i bGtkZXYtPnhlbmRldiwgMywKKyAgICB4ZW5fcHZfcHJpbnRmKCZncmFudC0+YmxrZGV2LT54ZW5k ZXYsIDMsCiAgICAgICAgICAgICAgICAgICAidW5tYXBwZWQgZ3JhbnQgJXBcbiIsIGdyYW50LT5w YWdlKTsKICAgICBnX2ZyZWUoZ3JhbnQpOwogfQpAQCAtMTg1LDExICsxODUsMTEgQEAgc3RhdGlj IHZvaWQgcmVtb3ZlX3BlcnNpc3RlbnRfcmVnaW9uKGdwb2ludGVyIGRhdGEsIGdwb2ludGVyIGRl dikKICAgICB4ZW5nbnR0YWJfaGFuZGxlICpnbnQgPSBibGtkZXYtPnhlbmRldi5nbnR0YWJkZXY7 CiAKICAgICBpZiAoeGVuZ250dGFiX3VubWFwKGdudCwgcmVnaW9uLT5hZGRyLCByZWdpb24tPm51 bSkgIT0gMCkgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKCZibGtkZXYtPnhlbmRldiwgMCwKKyAg ICAgICAgeGVuX3B2X3ByaW50ZigmYmxrZGV2LT54ZW5kZXYsIDAsCiAgICAgICAgICAgICAgICAg ICAgICAgInhlbmdudHRhYl91bm1hcCByZWdpb24gJXAgZmFpbGVkOiAlc1xuIiwKICAgICAgICAg ICAgICAgICAgICAgICByZWdpb24tPmFkZHIsIHN0cmVycm9yKGVycm5vKSk7CiAgICAgfQotICAg IHhlbl9iZV9wcmludGYoJmJsa2Rldi0+eGVuZGV2LCAzLAorICAgIHhlbl9wdl9wcmludGYoJmJs a2Rldi0+eGVuZGV2LCAzLAogICAgICAgICAgICAgICAgICAgInVubWFwcGVkIGdyYW50IHJlZ2lv biAlcCB3aXRoICVkIHBhZ2VzXG4iLAogICAgICAgICAgICAgICAgICAgcmVnaW9uLT5hZGRyLCBy ZWdpb24tPm51bSk7CiAgICAgZ19mcmVlKHJlZ2lvbik7CkBAIC0yNTYsNyArMjU2LDcgQEAgc3Rh dGljIGludCBpb3JlcV9wYXJzZShzdHJ1Y3QgaW9yZXEgKmlvcmVxKQogICAgIHNpemVfdCBsZW47 CiAgICAgaW50IGk7CiAKLSAgICB4ZW5fYmVfcHJpbnRmKCZibGtkZXYtPnhlbmRldiwgMywKKyAg ICB4ZW5fcHZfcHJpbnRmKCZibGtkZXYtPnhlbmRldiwgMywKICAgICAgICAgICAgICAgICAgICJv cCAlZCwgbnIgJWQsIGhhbmRsZSAlZCwgaWQgJSIgUFJJZDY0ICIsIHNlY3RvciAlIiBQUklkNjQg IlxuIiwKICAgICAgICAgICAgICAgICAgIGlvcmVxLT5yZXEub3BlcmF0aW9uLCBpb3JlcS0+cmVx Lm5yX3NlZ21lbnRzLAogICAgICAgICAgICAgICAgICAgaW9yZXEtPnJlcS5oYW5kbGUsIGlvcmVx LT5yZXEuaWQsIGlvcmVxLT5yZXEuc2VjdG9yX251bWJlcik7CkBAIC0yNzYsMjggKzI3NiwyOCBA QCBzdGF0aWMgaW50IGlvcmVxX3BhcnNlKHN0cnVjdCBpb3JlcSAqaW9yZXEpCiAgICAgY2FzZSBC TEtJRl9PUF9ESVNDQVJEOgogICAgICAgICByZXR1cm4gMDsKICAgICBkZWZhdWx0OgotICAgICAg ICB4ZW5fYmVfcHJpbnRmKCZibGtkZXYtPnhlbmRldiwgMCwgImVycm9yOiB1bmtub3duIG9wZXJh dGlvbiAoJWQpXG4iLAorICAgICAgICB4ZW5fcHZfcHJpbnRmKCZibGtkZXYtPnhlbmRldiwgMCwg ImVycm9yOiB1bmtub3duIG9wZXJhdGlvbiAoJWQpXG4iLAogICAgICAgICAgICAgICAgICAgICAg IGlvcmVxLT5yZXEub3BlcmF0aW9uKTsKICAgICAgICAgZ290byBlcnI7CiAgICAgfTsKIAogICAg IGlmIChpb3JlcS0+cmVxLm9wZXJhdGlvbiAhPSBCTEtJRl9PUF9SRUFEICYmIGJsa2Rldi0+bW9k ZVswXSAhPSAndycpIHsKLSAgICAgICAgeGVuX2JlX3ByaW50ZigmYmxrZGV2LT54ZW5kZXYsIDAs ICJlcnJvcjogd3JpdGUgcmVxIGZvciBybyBkZXZpY2VcbiIpOworICAgICAgICB4ZW5fcHZfcHJp bnRmKCZibGtkZXYtPnhlbmRldiwgMCwgImVycm9yOiB3cml0ZSByZXEgZm9yIHJvIGRldmljZVxu Iik7CiAgICAgICAgIGdvdG8gZXJyOwogICAgIH0KIAogICAgIGlvcmVxLT5zdGFydCA9IGlvcmVx LT5yZXEuc2VjdG9yX251bWJlciAqIGJsa2Rldi0+ZmlsZV9ibGs7CiAgICAgZm9yIChpID0gMDsg aSA8IGlvcmVxLT5yZXEubnJfc2VnbWVudHM7IGkrKykgewogICAgICAgICBpZiAoaSA9PSBCTEtJ Rl9NQVhfU0VHTUVOVFNfUEVSX1JFUVVFU1QpIHsKLSAgICAgICAgICAgIHhlbl9iZV9wcmludGYo JmJsa2Rldi0+eGVuZGV2LCAwLCAiZXJyb3I6IG5yX3NlZ21lbnRzIHRvbyBiaWdcbiIpOworICAg ICAgICAgICAgeGVuX3B2X3ByaW50ZigmYmxrZGV2LT54ZW5kZXYsIDAsICJlcnJvcjogbnJfc2Vn bWVudHMgdG9vIGJpZ1xuIik7CiAgICAgICAgICAgICBnb3RvIGVycjsKICAgICAgICAgfQogICAg ICAgICBpZiAoaW9yZXEtPnJlcS5zZWdbaV0uZmlyc3Rfc2VjdCA+IGlvcmVxLT5yZXEuc2VnW2ld Lmxhc3Rfc2VjdCkgewotICAgICAgICAgICAgeGVuX2JlX3ByaW50ZigmYmxrZGV2LT54ZW5kZXYs IDAsICJlcnJvcjogZmlyc3QgPiBsYXN0IHNlY3RvclxuIik7CisgICAgICAgICAgICB4ZW5fcHZf cHJpbnRmKCZibGtkZXYtPnhlbmRldiwgMCwgImVycm9yOiBmaXJzdCA+IGxhc3Qgc2VjdG9yXG4i KTsKICAgICAgICAgICAgIGdvdG8gZXJyOwogICAgICAgICB9CiAgICAgICAgIGlmIChpb3JlcS0+ cmVxLnNlZ1tpXS5sYXN0X3NlY3QgKiBCTE9DS19TSVpFID49IFhDX1BBR0VfU0laRSkgewotICAg ICAgICAgICAgeGVuX2JlX3ByaW50ZigmYmxrZGV2LT54ZW5kZXYsIDAsICJlcnJvcjogcGFnZSBj cm9zc2luZ1xuIik7CisgICAgICAgICAgICB4ZW5fcHZfcHJpbnRmKCZibGtkZXYtPnhlbmRldiwg MCwgImVycm9yOiBwYWdlIGNyb3NzaW5nXG4iKTsKICAgICAgICAgICAgIGdvdG8gZXJyOwogICAg ICAgICB9CiAKQEAgLTMwOSw3ICszMDksNyBAQCBzdGF0aWMgaW50IGlvcmVxX3BhcnNlKHN0cnVj dCBpb3JlcSAqaW9yZXEpCiAgICAgICAgIHFlbXVfaW92ZWNfYWRkKCZpb3JlcS0+diwgKHZvaWQq KW1lbSwgbGVuKTsKICAgICB9CiAgICAgaWYgKGlvcmVxLT5zdGFydCArIGlvcmVxLT52LnNpemUg PiBibGtkZXYtPmZpbGVfc2l6ZSkgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKCZibGtkZXYtPnhl bmRldiwgMCwgImVycm9yOiBhY2Nlc3MgYmV5b25kIGVuZCBvZiBmaWxlXG4iKTsKKyAgICAgICAg eGVuX3B2X3ByaW50ZigmYmxrZGV2LT54ZW5kZXYsIDAsICJlcnJvcjogYWNjZXNzIGJleW9uZCBl bmQgb2YgZmlsZVxuIik7CiAgICAgICAgIGdvdG8gZXJyOwogICAgIH0KICAgICByZXR1cm4gMDsK QEAgLTMzMiw3ICszMzIsNyBAQCBzdGF0aWMgdm9pZCBpb3JlcV91bm1hcChzdHJ1Y3QgaW9yZXEg KmlvcmVxKQogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CiAgICAgICAgIGlmICh4ZW5n bnR0YWJfdW5tYXAoZ250LCBpb3JlcS0+cGFnZXMsIGlvcmVxLT5udW1fdW5tYXApICE9IDApIHsK LSAgICAgICAgICAgIHhlbl9iZV9wcmludGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMCwKKyAg ICAgICAgICAgIHhlbl9wdl9wcmludGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMCwKICAgICAg ICAgICAgICAgICAgICAgICAgICAgInhlbmdudHRhYl91bm1hcCBmYWlsZWQ6ICVzXG4iLAogICAg ICAgICAgICAgICAgICAgICAgICAgICBzdHJlcnJvcihlcnJubykpOwogICAgICAgICB9CkBAIC0z NDQsNyArMzQ0LDcgQEAgc3RhdGljIHZvaWQgaW9yZXFfdW5tYXAoc3RydWN0IGlvcmVxICppb3Jl cSkKICAgICAgICAgICAgICAgICBjb250aW51ZTsKICAgICAgICAgICAgIH0KICAgICAgICAgICAg IGlmICh4ZW5nbnR0YWJfdW5tYXAoZ250LCBpb3JlcS0+cGFnZVtpXSwgMSkgIT0gMCkgewotICAg ICAgICAgICAgICAgIHhlbl9iZV9wcmludGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMCwKKyAg ICAgICAgICAgICAgICB4ZW5fcHZfcHJpbnRmKCZpb3JlcS0+YmxrZGV2LT54ZW5kZXYsIDAsCiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAieGVuZ250dGFiX3VubWFwIGZhaWxlZDogJXNc biIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJlcnJvcihlcnJubykpOwogICAg ICAgICAgICAgfQpAQCAtMzgyLDcgKzM4Miw3IEBAIHN0YXRpYyBpbnQgaW9yZXFfbWFwKHN0cnVj dCBpb3JlcSAqaW9yZXEpCiAKICAgICAgICAgICAgIGlmIChncmFudCAhPSBOVUxMKSB7CiAgICAg ICAgICAgICAgICAgcGFnZVtpXSA9IGdyYW50LT5wYWdlOwotICAgICAgICAgICAgICAgIHhlbl9i ZV9wcmludGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMywKKyAgICAgICAgICAgICAgICB4ZW5f cHZfcHJpbnRmKCZpb3JlcS0+YmxrZGV2LT54ZW5kZXYsIDMsCiAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAidXNpbmcgcGVyc2lzdGVudC1ncmFudCAlIiBQUkl1MzIgIlxuIiwKICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGlvcmVxLT5yZWZzW2ldKTsKICAgICAgICAgICAgIH0g ZWxzZSB7CkBAIC00MTEsNyArNDExLDcgQEAgc3RhdGljIGludCBpb3JlcV9tYXAoc3RydWN0IGlv cmVxICppb3JlcSkKICAgICAgICAgaW9yZXEtPnBhZ2VzID0geGVuZ250dGFiX21hcF9ncmFudF9y ZWZzCiAgICAgICAgICAgICAoZ250LCBuZXdfbWFwcywgZG9taWRzLCByZWZzLCBpb3JlcS0+cHJv dCk7CiAgICAgICAgIGlmIChpb3JlcS0+cGFnZXMgPT0gTlVMTCkgewotICAgICAgICAgICAgeGVu X2JlX3ByaW50ZigmaW9yZXEtPmJsa2Rldi0+eGVuZGV2LCAwLAorICAgICAgICAgICAgeGVuX3B2 X3ByaW50ZigmaW9yZXEtPmJsa2Rldi0+eGVuZGV2LCAwLAogICAgICAgICAgICAgICAgICAgICAg ICAgICAiY2FuJ3QgbWFwICVkIGdyYW50IHJlZnMgKCVzLCAlZCBtYXBzKVxuIiwKICAgICAgICAg ICAgICAgICAgICAgICAgICAgbmV3X21hcHMsIHN0cmVycm9yKGVycm5vKSwgaW9yZXEtPmJsa2Rl di0+Y250X21hcCk7CiAgICAgICAgICAgICByZXR1cm4gLTE7CkBAIC00MjcsNyArNDI3LDcgQEAg c3RhdGljIGludCBpb3JlcV9tYXAoc3RydWN0IGlvcmVxICppb3JlcSkKICAgICAgICAgICAgIGlv cmVxLT5wYWdlW2ldID0geGVuZ250dGFiX21hcF9ncmFudF9yZWYKICAgICAgICAgICAgICAgICAo Z250LCBkb21pZHNbaV0sIHJlZnNbaV0sIGlvcmVxLT5wcm90KTsKICAgICAgICAgICAgIGlmIChp b3JlcS0+cGFnZVtpXSA9PSBOVUxMKSB7Ci0gICAgICAgICAgICAgICAgeGVuX2JlX3ByaW50Zigm aW9yZXEtPmJsa2Rldi0+eGVuZGV2LCAwLAorICAgICAgICAgICAgICAgIHhlbl9wdl9wcmludGYo JmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICJjYW4ndCBtYXAgZ3JhbnQgcmVmICVkICglcywgJWQgbWFwcylcbiIsCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICByZWZzW2ldLCBzdHJlcnJvcihlcnJubyksIGlvcmVxLT5ibGtkZXYt PmNudF9tYXApOwogICAgICAgICAgICAgICAgIGlvcmVxLT5tYXBwZWQgPSAxOwpAQCAtNDc1LDcg KzQ3NSw3IEBAIHN0YXRpYyBpbnQgaW9yZXFfbWFwKHN0cnVjdCBpb3JlcSAqaW9yZXEpCiAgICAg ICAgICAgICAgICAgZ3JhbnQtPnBhZ2UgPSBpb3JlcS0+cGFnZVtuZXdfbWFwc107CiAgICAgICAg ICAgICB9CiAgICAgICAgICAgICBncmFudC0+YmxrZGV2ID0gaW9yZXEtPmJsa2RldjsKLSAgICAg ICAgICAgIHhlbl9iZV9wcmludGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMywKKyAgICAgICAg ICAgIHhlbl9wdl9wcmludGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMywKICAgICAgICAgICAg ICAgICAgICAgICAgICAgImFkZGluZyBncmFudCAlIiBQUkl1MzIgIiBwYWdlOiAlcFxuIiwKICAg ICAgICAgICAgICAgICAgICAgICAgICAgcmVmc1tuZXdfbWFwc10sIGdyYW50LT5wYWdlKTsKICAg ICAgICAgICAgIGdfdHJlZV9pbnNlcnQoaW9yZXEtPmJsa2Rldi0+cGVyc2lzdGVudF9nbnRzLApA QCAtNTU4LDcgKzU1OCw3IEBAIHN0YXRpYyBpbnQgaW9yZXFfZ3JhbnRfY29weShzdHJ1Y3QgaW9y ZXEgKmlvcmVxKQogICAgIHJjID0geGVuZ250dGFiX2dyYW50X2NvcHkoZ250LCBjb3VudCwgc2Vn cyk7CiAKICAgICBpZiAocmMpIHsKLSAgICAgICAgeGVuX2JlX3ByaW50ZigmaW9yZXEtPmJsa2Rl di0+eGVuZGV2LCAwLAorICAgICAgICB4ZW5fcHZfcHJpbnRmKCZpb3JlcS0+YmxrZGV2LT54ZW5k ZXYsIDAsCiAgICAgICAgICAgICAgICAgICAgICAgImZhaWxlZCB0byBjb3B5IGRhdGEgJWRcbiIs IHJjKTsKICAgICAgICAgaW9yZXEtPmFpb19lcnJvcnMrKzsKICAgICAgICAgcmV0dXJuIC0xOwpA QCAtNTY2LDcgKzU2Niw3IEBAIHN0YXRpYyBpbnQgaW9yZXFfZ3JhbnRfY29weShzdHJ1Y3QgaW9y ZXEgKmlvcmVxKQogCiAgICAgZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKICAgICAgICAg aWYgKHNlZ3NbaV0uc3RhdHVzICE9IEdOVFNUX29rYXkpIHsKLSAgICAgICAgICAgIHhlbl9iZV9w cmludGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMywKKyAgICAgICAgICAgIHhlbl9wdl9wcmlu dGYoJmlvcmVxLT5ibGtkZXYtPnhlbmRldiwgMywKICAgICAgICAgICAgICAgICAgICAgICAgICAg ImZhaWxlZCB0byBjb3B5IGRhdGEgJWQgZm9yIGdyZWYgJWQsIGRvbWlkICVkXG4iLAogICAgICAg ICAgICAgICAgICAgICAgICAgICBzZWdzW2ldLnN0YXR1cywgaW9yZXEtPnJlZnNbaV0sIGlvcmVx LT5kb21pZHNbaV0pOwogICAgICAgICAgICAgaW9yZXEtPmFpb19lcnJvcnMrKzsKQEAgLTYwMCw3 ICs2MDAsNyBAQCBzdGF0aWMgdm9pZCBxZW11X2Fpb19jb21wbGV0ZSh2b2lkICpvcGFxdWUsIGlu dCByZXQpCiAgICAgc3RydWN0IGlvcmVxICppb3JlcSA9IG9wYXF1ZTsKIAogICAgIGlmIChyZXQg IT0gMCkgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKCZpb3JlcS0+YmxrZGV2LT54ZW5kZXYsIDAs ICIlcyBJL08gZXJyb3JcbiIsCisgICAgICAgIHhlbl9wdl9wcmludGYoJmlvcmVxLT5ibGtkZXYt PnhlbmRldiwgMCwgIiVzIEkvTyBlcnJvclxuIiwKICAgICAgICAgICAgICAgICAgICAgICBpb3Jl cS0+cmVxLm9wZXJhdGlvbiA9PSBCTEtJRl9PUF9SRUFEID8gInJlYWQiIDogIndyaXRlIik7CiAg ICAgICAgIGlvcmVxLT5haW9fZXJyb3JzKys7CiAgICAgfQpAQCAtOTExLDcgKzkxMSw3IEBAIHN0 YXRpYyB2b2lkIGJsa19hbGxvYyhzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCiAgICAgfQogICAg IGlmICh4ZW5nbnR0YWJfc2V0X21heF9ncmFudHMoeGVuZGV2LT5nbnR0YWJkZXYsCiAgICAgICAg ICAgICBNQVhfR1JBTlRTKG1heF9yZXF1ZXN0cywgQkxLSUZfTUFYX1NFR01FTlRTX1BFUl9SRVFV RVNUKSkgPCAwKSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoeGVuZGV2LCAwLCAieGVuZ250dGFi X3NldF9tYXhfZ3JhbnRzIGZhaWxlZDogJXNcbiIsCisgICAgICAgIHhlbl9wdl9wcmludGYoeGVu ZGV2LCAwLCAieGVuZ250dGFiX3NldF9tYXhfZ3JhbnRzIGZhaWxlZDogJXNcbiIsCiAgICAgICAg ICAgICAgICAgICAgICAgc3RyZXJyb3IoZXJybm8pKTsKICAgICB9CiB9CkBAIC0xMDU3LDExICsx MDU3LDExIEBAIHN0YXRpYyBpbnQgYmxrX2Nvbm5lY3Qoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2 KQogICAgICAgICB9CiAKICAgICAgICAgLyogc2V0dXAgdmlhIHhlbmJ1cyAtPiBjcmVhdGUgbmV3 IGJsb2NrIGRyaXZlciBpbnN0YW5jZSAqLwotICAgICAgICB4ZW5fYmVfcHJpbnRmKCZibGtkZXYt PnhlbmRldiwgMiwgImNyZWF0ZSBuZXcgYmRydiAoeGVuYnVzIHNldHVwKVxuIik7CisgICAgICAg IHhlbl9wdl9wcmludGYoJmJsa2Rldi0+eGVuZGV2LCAyLCAiY3JlYXRlIG5ldyBiZHJ2ICh4ZW5i dXMgc2V0dXApXG4iKTsKICAgICAgICAgYmxrZGV2LT5ibGsgPSBibGtfbmV3X29wZW4oYmxrZGV2 LT5maWxlbmFtZSwgTlVMTCwgb3B0aW9ucywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgcWZsYWdzLCAmbG9jYWxfZXJyKTsKICAgICAgICAgaWYgKCFibGtkZXYtPmJsaykgewot ICAgICAgICAgICAgeGVuX2JlX3ByaW50ZigmYmxrZGV2LT54ZW5kZXYsIDAsICJlcnJvcjogJXNc biIsCisgICAgICAgICAgICB4ZW5fcHZfcHJpbnRmKCZibGtkZXYtPnhlbmRldiwgMCwgImVycm9y OiAlc1xuIiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgZXJyb3JfZ2V0X3ByZXR0eShsb2Nh bF9lcnIpKTsKICAgICAgICAgICAgIGVycm9yX2ZyZWUobG9jYWxfZXJyKTsKICAgICAgICAgICAg IHJldHVybiAtMTsKQEAgLTEwNjksMTEgKzEwNjksMTEgQEAgc3RhdGljIGludCBibGtfY29ubmVj dChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCiAgICAgICAgIGJsa19zZXRfZW5hYmxlX3dyaXRl X2NhY2hlKGJsa2Rldi0+YmxrLCAhd3JpdGV0aHJvdWdoKTsKICAgICB9IGVsc2UgewogICAgICAg ICAvKiBzZXR1cCB2aWEgcWVtdSBjbWRsaW5lIC0+IGFscmVhZHkgc2V0dXAgZm9yIHVzICovCi0g ICAgICAgIHhlbl9iZV9wcmludGYoJmJsa2Rldi0+eGVuZGV2LCAyLAorICAgICAgICB4ZW5fcHZf cHJpbnRmKCZibGtkZXYtPnhlbmRldiwgMiwKICAgICAgICAgICAgICAgICAgICAgICJnZXQgY29u ZmlndXJlZCBiZHJ2IChjbWRsaW5lIHNldHVwKVxuIik7CiAgICAgICAgIGJsa2Rldi0+YmxrID0g YmxrX2J5X2xlZ2FjeV9kaW5mbyhibGtkZXYtPmRpbmZvKTsKICAgICAgICAgaWYgKGJsa19pc19y ZWFkX29ubHkoYmxrZGV2LT5ibGspICYmICFyZWFkb25seSkgewotICAgICAgICAgICAgeGVuX2Jl X3ByaW50ZigmYmxrZGV2LT54ZW5kZXYsIDAsICJVbmV4cGVjdGVkIHJlYWQtb25seSBkcml2ZSIp OworICAgICAgICAgICAgeGVuX3B2X3ByaW50ZigmYmxrZGV2LT54ZW5kZXYsIDAsICJVbmV4cGVj dGVkIHJlYWQtb25seSBkcml2ZSIpOwogICAgICAgICAgICAgYmxrZGV2LT5ibGsgPSBOVUxMOwog ICAgICAgICAgICAgcmV0dXJuIC0xOwogICAgICAgICB9CkBAIC0xMDg2LDEzICsxMDg2LDEzIEBA IHN0YXRpYyBpbnQgYmxrX2Nvbm5lY3Qoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAgIGlm IChibGtkZXYtPmZpbGVfc2l6ZSA8IDApIHsKICAgICAgICAgQmxvY2tEcml2ZXJTdGF0ZSAqYnMg PSBibGtfYnMoYmxrZGV2LT5ibGspOwogICAgICAgICBjb25zdCBjaGFyICpkcnZfbmFtZSA9IGJz ID8gYmRydl9nZXRfZm9ybWF0X25hbWUoYnMpIDogTlVMTDsKLSAgICAgICAgeGVuX2JlX3ByaW50 ZigmYmxrZGV2LT54ZW5kZXYsIDEsICJibGtfZ2V0bGVuZ3RoOiAlZCAoJXMpIHwgZHJ2ICVzXG4i LAorICAgICAgICB4ZW5fcHZfcHJpbnRmKCZibGtkZXYtPnhlbmRldiwgMSwgImJsa19nZXRsZW5n dGg6ICVkICglcykgfCBkcnYgJXNcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgKGludClibGtk ZXYtPmZpbGVfc2l6ZSwgc3RyZXJyb3IoLWJsa2Rldi0+ZmlsZV9zaXplKSwKICAgICAgICAgICAg ICAgICAgICAgICBkcnZfbmFtZSA/OiAiLSIpOwogICAgICAgICBibGtkZXYtPmZpbGVfc2l6ZSA9 IDA7CiAgICAgfQogCi0gICAgeGVuX2JlX3ByaW50Zih4ZW5kZXYsIDEsICJ0eXBlIFwiJXNcIiwg ZmlsZXByb3RvIFwiJXNcIiwgZmlsZW5hbWUgXCIlc1wiLCIKKyAgICB4ZW5fcHZfcHJpbnRmKHhl bmRldiwgMSwgInR5cGUgXCIlc1wiLCBmaWxlcHJvdG8gXCIlc1wiLCBmaWxlbmFtZSBcIiVzXCIs IgogICAgICAgICAgICAgICAgICAgIiBzaXplICUiIFBSSWQ2NCAiICglIiBQUklkNjQgIiBNQilc biIsCiAgICAgICAgICAgICAgICAgICBibGtkZXYtPnR5cGUsIGJsa2Rldi0+ZmlsZXByb3RvLCBi bGtkZXYtPmZpbGVuYW1lLAogICAgICAgICAgICAgICAgICAgYmxrZGV2LT5maWxlX3NpemUsIGJs a2Rldi0+ZmlsZV9zaXplID4+IDIwKTsKQEAgLTExNzYsMTAgKzExNzYsMTAgQEAgc3RhdGljIGlu dCBibGtfY29ubmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCiAgICAgYmxrZGV2LT5mZWF0 dXJlX2dyYW50X2NvcHkgPQogICAgICAgICAgICAgICAgICh4ZW5nbnR0YWJfZ3JhbnRfY29weShi bGtkZXYtPnhlbmRldi5nbnR0YWJkZXYsIDAsIE5VTEwpID09IDApOwogCi0gICAgeGVuX2JlX3By aW50ZigmYmxrZGV2LT54ZW5kZXYsIDMsICJncmFudCBjb3B5IG9wZXJhdGlvbiAlc1xuIiwKKyAg ICB4ZW5fcHZfcHJpbnRmKCZibGtkZXYtPnhlbmRldiwgMywgImdyYW50IGNvcHkgb3BlcmF0aW9u ICVzXG4iLAogICAgICAgICAgICAgICAgICAgYmxrZGV2LT5mZWF0dXJlX2dyYW50X2NvcHkgPyAi ZW5hYmxlZCIgOiAiZGlzYWJsZWQiKTsKIAotICAgIHhlbl9iZV9wcmludGYoJmJsa2Rldi0+eGVu ZGV2LCAxLCAib2s6IHByb3RvICVzLCByaW5nLXJlZiAlZCwgIgorICAgIHhlbl9wdl9wcmludGYo JmJsa2Rldi0+eGVuZGV2LCAxLCAib2s6IHByb3RvICVzLCByaW5nLXJlZiAlZCwgIgogICAgICAg ICAgICAgICAgICAgInJlbW90ZSBwb3J0ICVkLCBsb2NhbCBwb3J0ICVkXG4iLAogICAgICAgICAg ICAgICAgICAgYmxrZGV2LT54ZW5kZXYucHJvdG9jb2wsIGJsa2Rldi0+cmluZ19yZWYsCiAgICAg ICAgICAgICAgICAgICBibGtkZXYtPnhlbmRldi5yZW1vdGVfcG9ydCwgYmxrZGV2LT54ZW5kZXYu bG9jYWxfcG9ydCk7CmRpZmYgLS1naXQgYS9ody9jaGFyL3hlbl9jb25zb2xlLmMgYi9ody9jaGFy L3hlbl9jb25zb2xlLmMKaW5kZXggMzk5YmI1ZC4uYjcwNWEwNiAxMDA2NDQKLS0tIGEvaHcvY2hh ci94ZW5fY29uc29sZS5jCisrKyBiL2h3L2NoYXIveGVuX2NvbnNvbGUuYwpAQCAtMTU2LDE0ICsx NTYsMTQgQEAgc3RhdGljIHZvaWQgeGVuY29uc19zZW5kKHN0cnVjdCBYZW5Db25zb2xlICpjb24p CiAgICAgaWYgKGxlbiA8IDEpIHsKICAgICAgICAgaWYgKCFjb24tPmJhY2tsb2cpIHsKICAgICAg ICAgICAgIGNvbi0+YmFja2xvZyA9IDE7Ci0gICAgICAgICAgICB4ZW5fYmVfcHJpbnRmKCZjb24t PnhlbmRldiwgMSwKKyAgICAgICAgICAgIHhlbl9wdl9wcmludGYoJmNvbi0+eGVuZGV2LCAxLAog ICAgICAgICAgICAgICAgICAgICAgICAgICJiYWNrbG9nIHBpbGluZyB1cCwgbm9ib2R5IGxpc3Rl bmluZz9cbiIpOwogICAgICAgICB9CiAgICAgfSBlbHNlIHsKICAgICAgICAgYnVmZmVyX2FkdmFu Y2UoJmNvbi0+YnVmZmVyLCBsZW4pOwogICAgICAgICBpZiAoY29uLT5iYWNrbG9nICYmIGxlbiA9 PSBzaXplKSB7CiAgICAgICAgICAgICBjb24tPmJhY2tsb2cgPSAwOwotICAgICAgICAgICAgeGVu X2JlX3ByaW50ZigmY29uLT54ZW5kZXYsIDEsICJiYWNrbG9nIGlzIGdvbmVcbiIpOworICAgICAg ICAgICAgeGVuX3B2X3ByaW50ZigmY29uLT54ZW5kZXYsIDEsICJiYWNrbG9nIGlzIGdvbmVcbiIp OwogICAgICAgICB9CiAgICAgfQogfQpAQCAtMTg4LDcgKzE4OCw3IEBAIHN0YXRpYyBpbnQgY29u X2luaXQoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogCiAgICAgdHlwZSA9IHhlbnN0b3JlX3Jl YWRfc3RyKGNvbi0+Y29uc29sZSwgInR5cGUiKTsKICAgICBpZiAoIXR5cGUgfHwgc3RyY21wKHR5 cGUsICJpb2VtdSIpICE9IDApIHsKLSAgICAgICAgeGVuX2JlX3ByaW50Zih4ZW5kZXYsIDEsICJu b3QgZm9yIG1lICh0eXBlPSVzKVxuIiwgdHlwZSk7CisgICAgICAgIHhlbl9wdl9wcmludGYoeGVu ZGV2LCAxLCAibm90IGZvciBtZSAodHlwZT0lcylcbiIsIHR5cGUpOwogICAgICAgICByZXQgPSAt MTsKICAgICAgICAgZ290byBvdXQ7CiAgICAgfQpAQCAtMjQxLDE0ICsyNDEsMTQgQEAgc3RhdGlj IGludCBjb25faW5pdGlhbGlzZShzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCiAgICAgICAgICAg ICBxZW11X2Nocl9hZGRfaGFuZGxlcnMoY29uLT5jaHIsIHhlbmNvbnNfY2FuX3JlY2VpdmUsCiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeGVuY29uc19yZWNlaXZlLCBOVUxMLCBj b24pOwogICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAgeGVuX2JlX3ByaW50Zih4ZW5kZXYs IDAsCisgICAgICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMCwKICAgICAgICAgICAgICAg ICAgICAgICAgICAgInhlbl9jb25zb2xlX2luaXQgZXJyb3IgY2hhcmRldiAlcyBhbHJlYWR5IHVz ZWRcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbi0+Y2hyLT5sYWJlbCk7CiAgICAg ICAgICAgICBjb24tPmNociA9IE5VTEw7CiAgICAgICAgIH0KICAgICB9CiAKLSAgICB4ZW5fYmVf cHJpbnRmKHhlbmRldiwgMSwKKyAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMSwKICAgICAgICAg ICAgICAgICAgInJpbmcgbWZuICVkLCByZW1vdGUgcG9ydCAlZCwgbG9jYWwgcG9ydCAlZCwgbGlt aXQgJXpkXG4iLAogCQkgIGNvbi0+cmluZ19yZWYsCiAJCSAgY29uLT54ZW5kZXYucmVtb3RlX3Bv cnQsCmRpZmYgLS1naXQgYS9ody9kaXNwbGF5L3hlbmZiLmMgYi9ody9kaXNwbGF5L3hlbmZiLmMK aW5kZXggOWIxMGIzNS4uNTVhY2E4NSAxMDA2NDQKLS0tIGEvaHcvZGlzcGxheS94ZW5mYi5jCisr KyBiL2h3L2Rpc3BsYXkveGVuZmIuYwpAQCAtMTA0LDcgKzEwNCw3IEBAIHN0YXRpYyBpbnQgY29t bW9uX2JpbmQoc3RydWN0IGNvbW1vbiAqYykKICAgICAgICAgcmV0dXJuIC0xOwogCiAgICAgeGVu X2JlX2JpbmRfZXZ0Y2huKCZjLT54ZW5kZXYpOwotICAgIHhlbl9iZV9wcmludGYoJmMtPnhlbmRl diwgMSwKKyAgICB4ZW5fcHZfcHJpbnRmKCZjLT54ZW5kZXYsIDEsCiAgICAgICAgICAgICAgICAg ICJyaW5nIG1mbiAlIlBSSV94ZW5fcGZuIiwgcmVtb3RlLXBvcnQgJWQsIGxvY2FsLXBvcnQgJWRc biIsCiAgICAgICAgICAgICAgICAgICBtZm4sIGMtPnhlbmRldi5yZW1vdGVfcG9ydCwgYy0+eGVu ZGV2LmxvY2FsX3BvcnQpOwogCkBAIC0zNDcsNyArMzQ3LDcgQEAgc3RhdGljIGludCBpbnB1dF9p bml0aWFsaXNlKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKICAgICBpbnQgcmM7CiAKICAgICBp ZiAoIWluLT5jLmNvbikgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKHhlbmRldiwgMSwgImRzIG5v dCBzZXQgKHlldClcbiIpOworICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMSwgImRzIG5v dCBzZXQgKHlldClcbiIpOwogICAgICAgICByZXR1cm4gLTE7CiAgICAgfQogCkBAIC01MTIsNDQg KzUxMiw0NCBAQCBzdGF0aWMgaW50IHhlbmZiX2NvbmZpZ3VyZV9mYihzdHJ1Y3QgWGVuRkIgKnhl bmZiLCBzaXplX3QgZmJfbGVuX2xpbSwKICAgICBpbnQgbWF4X3dpZHRoLCBtYXhfaGVpZ2h0Owog CiAgICAgaWYgKGZiX2xlbl9saW0gPiBmYl9sZW5fbWF4KSB7Ci0gICAgICAgIHhlbl9iZV9wcmlu dGYoJnhlbmZiLT5jLnhlbmRldiwgMCwKKyAgICAgICAgeGVuX3B2X3ByaW50ZigmeGVuZmItPmMu eGVuZGV2LCAwLAogICAgICAgICAgICAgICAgICAgICAgImZiIHNpemUgbGltaXQgJXp1IGV4Y2Vl ZHMgJXp1LCBjb3JyZWN0ZWRcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgZmJfbGVuX2xpbSwg ZmJfbGVuX21heCk7CiAgICAgICAgIGZiX2xlbl9saW0gPSBmYl9sZW5fbWF4OwogICAgIH0KICAg ICBpZiAoZmJfbGVuX2xpbSAmJiBmYl9sZW4gPiBmYl9sZW5fbGltKSB7Ci0gICAgICAgIHhlbl9i ZV9wcmludGYoJnhlbmZiLT5jLnhlbmRldiwgMCwKKyAgICAgICAgeGVuX3B2X3ByaW50ZigmeGVu ZmItPmMueGVuZGV2LCAwLAogICAgICAgICAgICAgICAgICAgICAgImZyb250ZW5kIGZiIHNpemUg JXp1IGxpbWl0ZWQgdG8gJXp1XG4iLAogICAgICAgICAgICAgICAgICAgICAgIGZiX2xlbiwgZmJf bGVuX2xpbSk7CiAgICAgICAgIGZiX2xlbiA9IGZiX2xlbl9saW07CiAgICAgfQogICAgIGlmIChk ZXB0aCAhPSA4ICYmIGRlcHRoICE9IDE2ICYmIGRlcHRoICE9IDI0ICYmIGRlcHRoICE9IDMyKSB7 Ci0gICAgICAgIHhlbl9iZV9wcmludGYoJnhlbmZiLT5jLnhlbmRldiwgMCwKKyAgICAgICAgeGVu X3B2X3ByaW50ZigmeGVuZmItPmMueGVuZGV2LCAwLAogICAgICAgICAgICAgICAgICAgICAgImNh bid0IGhhbmRsZSBmcm9udGVuZCBmYiBkZXB0aCAlZFxuIiwKICAgICAgICAgICAgICAgICAgICAg ICBkZXB0aCk7CiAgICAgICAgIHJldHVybiAtMTsKICAgICB9CiAgICAgaWYgKHJvd19zdHJpZGUg PD0gMCB8fCByb3dfc3RyaWRlID4gZmJfbGVuKSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoJnhl bmZiLT5jLnhlbmRldiwgMCwgImludmFsaWQgZnJvbnRlbmQgc3RyaWRlICVkXG4iLAorICAgICAg ICB4ZW5fcHZfcHJpbnRmKCZ4ZW5mYi0+Yy54ZW5kZXYsIDAsICJpbnZhbGlkIGZyb250ZW5kIHN0 cmlkZSAlZFxuIiwKICAgICAgICAgICAgICAgICAgICAgICByb3dfc3RyaWRlKTsKICAgICAgICAg cmV0dXJuIC0xOwogICAgIH0KICAgICBtYXhfd2lkdGggPSByb3dfc3RyaWRlIC8gKGRlcHRoIC8g OCk7CiAgICAgaWYgKHdpZHRoIDwgMCB8fCB3aWR0aCA+IG1heF93aWR0aCkgewotICAgICAgICB4 ZW5fYmVfcHJpbnRmKCZ4ZW5mYi0+Yy54ZW5kZXYsIDAsCisgICAgICAgIHhlbl9wdl9wcmludGYo JnhlbmZiLT5jLnhlbmRldiwgMCwKICAgICAgICAgICAgICAgICAgICAgICJpbnZhbGlkIGZyb250 ZW5kIHdpZHRoICVkIGxpbWl0ZWQgdG8gJWRcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgd2lk dGgsIG1heF93aWR0aCk7CiAgICAgICAgIHdpZHRoID0gbWF4X3dpZHRoOwogICAgIH0KICAgICBp ZiAob2Zmc2V0IDwgMCB8fCBvZmZzZXQgPj0gZmJfbGVuKSB7Ci0gICAgICAgIHhlbl9iZV9wcmlu dGYoJnhlbmZiLT5jLnhlbmRldiwgMCwKKyAgICAgICAgeGVuX3B2X3ByaW50ZigmeGVuZmItPmMu eGVuZGV2LCAwLAogICAgICAgICAgICAgICAgICAgICAgImludmFsaWQgZnJvbnRlbmQgb2Zmc2V0 ICVkIChtYXggJXp1KVxuIiwKICAgICAgICAgICAgICAgICAgICAgICBvZmZzZXQsIGZiX2xlbiAt IDEpOwogICAgICAgICByZXR1cm4gLTE7CiAgICAgfQogICAgIG1heF9oZWlnaHQgPSAoZmJfbGVu IC0gb2Zmc2V0KSAvIHJvd19zdHJpZGU7CiAgICAgaWYgKGhlaWdodCA8IDAgfHwgaGVpZ2h0ID4g bWF4X2hlaWdodCkgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKCZ4ZW5mYi0+Yy54ZW5kZXYsIDAs CisgICAgICAgIHhlbl9wdl9wcmludGYoJnhlbmZiLT5jLnhlbmRldiwgMCwKICAgICAgICAgICAg ICAgICAgICAgICJpbnZhbGlkIGZyb250ZW5kIGhlaWdodCAlZCBsaW1pdGVkIHRvICVkXG4iLAog ICAgICAgICAgICAgICAgICAgICAgIGhlaWdodCwgbWF4X2hlaWdodCk7CiAgICAgICAgIGhlaWdo dCA9IG1heF9oZWlnaHQ7CkBAIC01NjIsNyArNTYyLDcgQEAgc3RhdGljIGludCB4ZW5mYl9jb25m aWd1cmVfZmIoc3RydWN0IFhlbkZCICp4ZW5mYiwgc2l6ZV90IGZiX2xlbl9saW0sCiAgICAgeGVu ZmItPm9mZnNldCA9IG9mZnNldDsKICAgICB4ZW5mYi0+dXBfZnVsbHNjcmVlbiA9IDE7CiAgICAg eGVuZmItPmRvX3Jlc2l6ZSA9IDE7Ci0gICAgeGVuX2JlX3ByaW50ZigmeGVuZmItPmMueGVuZGV2 LCAxLAorICAgIHhlbl9wdl9wcmludGYoJnhlbmZiLT5jLnhlbmRldiwgMSwKICAgICAgICAgICAg ICAgICAgImZyYW1lYnVmZmVyICVkeCVkeCVkIG9mZnNldCAlZCBzdHJpZGUgJWRcbiIsCiAgICAg ICAgICAgICAgICAgICB3aWR0aCwgaGVpZ2h0LCBkZXB0aCwgb2Zmc2V0LCByb3dfc3RyaWRlKTsK ICAgICByZXR1cm4gMDsKQEAgLTY0MSw3ICs2NDEsNyBAQCBzdGF0aWMgdm9pZCB4ZW5mYl9ndWVz dF9jb3B5KHN0cnVjdCBYZW5GQiAqeGVuZmIsIGludCB4LCBpbnQgeSwgaW50IHcsIGludCBoKQog CX0KICAgICB9CiAgICAgaWYgKG9vcHMpIC8qIHNob3VsZCBub3QgaGFwcGVuICovCi0gICAgICAg IHhlbl9iZV9wcmludGYoJnhlbmZiLT5jLnhlbmRldiwgMCwgIiVzOiBvb3BzOiBjb252ZXJ0ICVk IC0+ICVkIGJwcD9cbiIsCisgICAgICAgIHhlbl9wdl9wcmludGYoJnhlbmZiLT5jLnhlbmRldiwg MCwgIiVzOiBvb3BzOiBjb252ZXJ0ICVkIC0+ICVkIGJwcD9cbiIsCiAgICAgICAgICAgICAgICAg ICAgICAgX19GVU5DVElPTl9fLCB4ZW5mYi0+ZGVwdGgsIGJwcCk7CiAKICAgICBkcHlfZ2Z4X3Vw ZGF0ZSh4ZW5mYi0+Yy5jb24sIHgsIHksIHcsIGgpOwpAQCAtNzMxLDcgKzczMSw3IEBAIHN0YXRp YyB2b2lkIHhlbmZiX3VwZGF0ZSh2b2lkICpvcGFxdWUpCiAgICAgICAgICAgICBicmVhazsKICAg ICAgICAgfQogICAgICAgICBkcHlfZ2Z4X3JlcGxhY2Vfc3VyZmFjZSh4ZW5mYi0+Yy5jb24sIHN1 cmZhY2UpOwotICAgICAgICB4ZW5fYmVfcHJpbnRmKCZ4ZW5mYi0+Yy54ZW5kZXYsIDEsCisgICAg ICAgIHhlbl9wdl9wcmludGYoJnhlbmZiLT5jLnhlbmRldiwgMSwKICAgICAgICAgICAgICAgICAg ICAgICJ1cGRhdGU6IHJlc2l6aW5nOiAlZHglZCBAICVkIGJwcCVzXG4iLAogICAgICAgICAgICAg ICAgICAgICAgIHhlbmZiLT53aWR0aCwgeGVuZmItPmhlaWdodCwgeGVuZmItPmRlcHRoLAogICAg ICAgICAgICAgICAgICAgICAgIGlzX2J1ZmZlcl9zaGFyZWQoc3VyZmFjZSkgPyAiIChzaGFyZWQp IiA6ICIiKTsKQEAgLTc0MCwxMCArNzQwLDEwIEBAIHN0YXRpYyB2b2lkIHhlbmZiX3VwZGF0ZSh2 b2lkICpvcGFxdWUpCiAKICAgICAvKiBydW4gcXVldWVkIHVwZGF0ZXMgKi8KICAgICBpZiAoeGVu ZmItPnVwX2Z1bGxzY3JlZW4pIHsKLSAgICAgICAgeGVuX2JlX3ByaW50ZigmeGVuZmItPmMueGVu ZGV2LCAzLCAidXBkYXRlOiBmdWxsc2NyZWVuXG4iKTsKKyAgICAgICAgeGVuX3B2X3ByaW50Zigm eGVuZmItPmMueGVuZGV2LCAzLCAidXBkYXRlOiBmdWxsc2NyZWVuXG4iKTsKICAgICAgICAgeGVu ZmJfZ3Vlc3RfY29weSh4ZW5mYiwgMCwgMCwgeGVuZmItPndpZHRoLCB4ZW5mYi0+aGVpZ2h0KTsK ICAgICB9IGVsc2UgaWYgKHhlbmZiLT51cF9jb3VudCkgewotICAgICAgICB4ZW5fYmVfcHJpbnRm KCZ4ZW5mYi0+Yy54ZW5kZXYsIDMsICJ1cGRhdGU6ICVkIHJlY3RzXG4iLAorICAgICAgICB4ZW5f cHZfcHJpbnRmKCZ4ZW5mYi0+Yy54ZW5kZXYsIDMsICJ1cGRhdGU6ICVkIHJlY3RzXG4iLAogICAg ICAgICAgICAgICAgICAgICAgIHhlbmZiLT51cF9jb3VudCk7CiAgICAgICAgIGZvciAoaSA9IDA7 IGkgPCB4ZW5mYi0+dXBfY291bnQ7IGkrKykKICAgICAgICAgICAgIHhlbmZiX2d1ZXN0X2NvcHko eGVuZmIsCkBAIC03NTIsNyArNzUyLDcgQEAgc3RhdGljIHZvaWQgeGVuZmJfdXBkYXRlKHZvaWQg Km9wYXF1ZSkKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeGVuZmItPnVwX3JlY3RzW2ld LncsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhlbmZiLT51cF9yZWN0c1tpXS5oKTsK ICAgICB9IGVsc2UgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKCZ4ZW5mYi0+Yy54ZW5kZXYsIDMs ICJ1cGRhdGU6IG5vdGhpbmdcbiIpOworICAgICAgICB4ZW5fcHZfcHJpbnRmKCZ4ZW5mYi0+Yy54 ZW5kZXYsIDMsICJ1cGRhdGU6IG5vdGhpbmdcbiIpOwogICAgIH0KICAgICB4ZW5mYi0+dXBfY291 bnQgPSAwOwogICAgIHhlbmZiLT51cF9mdWxsc2NyZWVuID0gMDsKQEAgLTgwNiwxNCArODA2LDE0 IEBAIHN0YXRpYyB2b2lkIHhlbmZiX2hhbmRsZV9ldmVudHMoc3RydWN0IFhlbkZCICp4ZW5mYikK IAkgICAgdyA9IE1JTihldmVudC0+dXBkYXRlLndpZHRoLCB4ZW5mYi0+d2lkdGggLSB4KTsKIAkg ICAgaCA9IE1JTihldmVudC0+dXBkYXRlLmhlaWdodCwgeGVuZmItPmhlaWdodCAtIHkpOwogCSAg ICBpZiAodyA8IDAgfHwgaCA8IDApIHsKLSAgICAgICAgICAgICAgICB4ZW5fYmVfcHJpbnRmKCZ4 ZW5mYi0+Yy54ZW5kZXYsIDEsICJib2d1cyB1cGRhdGUgaWdub3JlZFxuIik7CisgICAgICAgICAg ICAgICAgeGVuX3B2X3ByaW50ZigmeGVuZmItPmMueGVuZGV2LCAxLCAiYm9ndXMgdXBkYXRlIGln bm9yZWRcbiIpOwogCQlicmVhazsKIAkgICAgfQogCSAgICBpZiAoeCAhPSBldmVudC0+dXBkYXRl LnggfHwKICAgICAgICAgICAgICAgICB5ICE9IGV2ZW50LT51cGRhdGUueSB8fAogCQl3ICE9IGV2 ZW50LT51cGRhdGUud2lkdGggfHwKIAkJaCAhPSBldmVudC0+dXBkYXRlLmhlaWdodCkgewotICAg ICAgICAgICAgICAgIHhlbl9iZV9wcmludGYoJnhlbmZiLT5jLnhlbmRldiwgMSwgImJvZ3VzIHVw ZGF0ZSBjbGlwcGVkXG4iKTsKKyAgICAgICAgICAgICAgICB4ZW5fcHZfcHJpbnRmKCZ4ZW5mYi0+ Yy54ZW5kZXYsIDEsICJib2d1cyB1cGRhdGUgY2xpcHBlZFxuIik7CiAJICAgIH0KIAkgICAgaWYg KHcgPT0geGVuZmItPndpZHRoICYmIGggPiB4ZW5mYi0+aGVpZ2h0IC8gMikgewogCQkvKiBzY3Jv bGwgZGV0ZWN0b3I6IHVwZGF0ZWQgbW9yZSB0aGFuIDUwJSBvZiB0aGUgbGluZXMsCkBAIC04OTUs NyArODk1LDcgQEAgc3RhdGljIGludCBmYl9pbml0aWFsaXNlKHN0cnVjdCBYZW5EZXZpY2UgKnhl bmRldikKICAgICBpZiAoZmItPmZlYXR1cmVfdXBkYXRlKQogCXhlbnN0b3JlX3dyaXRlX2JlX2lu dCh4ZW5kZXYsICJyZXF1ZXN0LXVwZGF0ZSIsIDEpOwogCi0gICAgeGVuX2JlX3ByaW50Zih4ZW5k ZXYsIDEsICJmZWF0dXJlLXVwZGF0ZT0lZCwgdmlkZW9yYW09JWRcbiIsCisgICAgeGVuX3B2X3By aW50Zih4ZW5kZXYsIDEsICJmZWF0dXJlLXVwZGF0ZT0lZCwgdmlkZW9yYW09JWRcbiIsCiAJCSAg ZmItPmZlYXR1cmVfdXBkYXRlLCB2aWRlb3JhbSk7CiAgICAgcmV0dXJuIDA7CiB9CkBAIC05MTQs NyArOTE0LDcgQEAgc3RhdGljIHZvaWQgZmJfZGlzY29ubmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4 ZW5kZXYpCiAgICAgICAgICAgICAgICAgICAgICAgUFJPVF9SRUFEIHwgUFJPVF9XUklURSwgTUFQ X1NIQVJFRCB8IE1BUF9BTk9OLAogICAgICAgICAgICAgICAgICAgICAgIC0xLCAwKTsKICAgICBp ZiAoZmItPnBpeGVscyA9PSBNQVBfRkFJTEVEKSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoeGVu ZGV2LCAwLAorICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMCwKICAgICAgICAgICAgICAg ICAiQ291bGRuJ3QgcmVwbGFjZSB0aGUgZnJhbWVidWZmZXIgd2l0aCBhbm9ueW1vdXMgbWVtb3J5 IGVycm5vPSVkXG4iLAogICAgICAgICAgICAgICAgIGVycm5vKTsKICAgICB9CkBAIC05MzUsNyAr OTM1LDcgQEAgc3RhdGljIHZvaWQgZmJfZnJvbnRlbmRfY2hhbmdlZChzdHJ1Y3QgWGVuRGV2aWNl ICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUpCiAgICAgaWYgKGZiLT5idWdfdHJpZ2dlciA9PSAw ICYmIHN0cmNtcChub2RlLCAic3RhdGUiKSA9PSAwICYmCiAgICAgICAgIHhlbmRldi0+ZmVfc3Rh dGUgPT0gWGVuYnVzU3RhdGVDb25uZWN0ZWQgJiYKICAgICAgICAgeGVuZGV2LT5iZV9zdGF0ZSA9 PSBYZW5idXNTdGF0ZUNvbm5lY3RlZCkgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKHhlbmRldiwg MiwgInJlLXRyaWdnZXIgY29ubmVjdGVkIChmcm9udGVuZCBidWcpXG4iKTsKKyAgICAgICAgeGVu X3B2X3ByaW50Zih4ZW5kZXYsIDIsICJyZS10cmlnZ2VyIGNvbm5lY3RlZCAoZnJvbnRlbmQgYnVn KVxuIik7CiAgICAgICAgIHhlbl9iZV9zZXRfc3RhdGUoeGVuZGV2LCBYZW5idXNTdGF0ZUNvbm5l Y3RlZCk7CiAgICAgICAgIGZiLT5idWdfdHJpZ2dlciA9IDE7IC8qIG9ubHkgb25jZSAqLwogICAg IH0KQEAgLTk5Niw3ICs5OTYsNyBAQCB3YWl0X21vcmU6CiAgICAgICAgICAgICB1c2xlZXAoMTAw MDApOwogICAgICAgICAgICAgZ290byB3YWl0X21vcmU7CiAgICAgICAgIH0KLSAgICAgICAgeGVu X2JlX3ByaW50ZihOVUxMLCAxLCAiZGlzcGxheXN0YXRlIHNldHVwIGZhaWxlZFxuIik7CisgICAg ICAgIHhlbl9wdl9wcmludGYoTlVMTCwgMSwgImRpc3BsYXlzdGF0ZSBzZXR1cCBmYWlsZWRcbiIp OwogICAgICAgICByZXR1cm47CiAgICAgfQogCmRpZmYgLS1naXQgYS9ody9uZXQveGVuX25pYy5j IGIvaHcvbmV0L3hlbl9uaWMuYwppbmRleCA4ZGIzNDQ4Li43NDE4YTdiIDEwMDY0NAotLS0gYS9o dy9uZXQveGVuX25pYy5jCisrKyBiL2h3L25ldC94ZW5fbmljLmMKQEAgLTEyOSwzMSArMTI5LDMx IEBAIHN0YXRpYyB2b2lkIG5ldF90eF9wYWNrZXRzKHN0cnVjdCBYZW5OZXREZXYgKm5ldGRldikK ICAgICAgICAgICAgIC8qIHNob3VsZCBub3QgaGFwcGVuIGluIHRoZW9yeSwgd2UgZG9uJ3QgYW5u b3VuY2UgdGhlICoKICAgICAgICAgICAgICAqIGZlYXR1cmUte3NnLGdzbyx3aGF0ZWxzZX0gZmxh Z3MgaW4geGVuc3RvcmUgKHlldD8pICovCiAgICAgICAgICAgICBpZiAodHhyZXEuZmxhZ3MgJiBO RVRUWEZfZXh0cmFfaW5mbykgewotICAgICAgICAgICAgICAgIHhlbl9iZV9wcmludGYoJm5ldGRl di0+eGVuZGV2LCAwLCAiRklYTUU6IGV4dHJhIGluZm8gZmxhZ1xuIik7CisgICAgICAgICAgICAg ICAgeGVuX3B2X3ByaW50ZigmbmV0ZGV2LT54ZW5kZXYsIDAsICJGSVhNRTogZXh0cmEgaW5mbyBm bGFnXG4iKTsKICAgICAgICAgICAgICAgICBuZXRfdHhfZXJyb3IobmV0ZGV2LCAmdHhyZXEsIHJj KTsKICAgICAgICAgICAgICAgICBjb250aW51ZTsKICAgICAgICAgICAgIH0KICAgICAgICAgICAg IGlmICh0eHJlcS5mbGFncyAmIE5FVFRYRl9tb3JlX2RhdGEpIHsKLSAgICAgICAgICAgICAgICB4 ZW5fYmVfcHJpbnRmKCZuZXRkZXYtPnhlbmRldiwgMCwgIkZJWE1FOiBtb3JlIGRhdGEgZmxhZ1xu Iik7CisgICAgICAgICAgICAgICAgeGVuX3B2X3ByaW50ZigmbmV0ZGV2LT54ZW5kZXYsIDAsICJG SVhNRTogbW9yZSBkYXRhIGZsYWdcbiIpOwogICAgICAgICAgICAgICAgIG5ldF90eF9lcnJvcihu ZXRkZXYsICZ0eHJlcSwgcmMpOwogICAgICAgICAgICAgICAgIGNvbnRpbnVlOwogICAgICAgICAg ICAgfQogI2VuZGlmCiAKICAgICAgICAgICAgIGlmICh0eHJlcS5zaXplIDwgMTQpIHsKLSAgICAg ICAgICAgICAgICB4ZW5fYmVfcHJpbnRmKCZuZXRkZXYtPnhlbmRldiwgMCwgImJhZCBwYWNrZXQg c2l6ZTogJWRcbiIsCisgICAgICAgICAgICAgICAgeGVuX3B2X3ByaW50ZigmbmV0ZGV2LT54ZW5k ZXYsIDAsICJiYWQgcGFja2V0IHNpemU6ICVkXG4iLAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgdHhyZXEuc2l6ZSk7CiAgICAgICAgICAgICAgICAgbmV0X3R4X2Vycm9yKG5ldGRldiwg JnR4cmVxLCByYyk7CiAgICAgICAgICAgICAgICAgY29udGludWU7CiAgICAgICAgICAgICB9CiAK ICAgICAgICAgICAgIGlmICgodHhyZXEub2Zmc2V0ICsgdHhyZXEuc2l6ZSkgPiBYQ19QQUdFX1NJ WkUpIHsKLSAgICAgICAgICAgICAgICB4ZW5fYmVfcHJpbnRmKCZuZXRkZXYtPnhlbmRldiwgMCwg ImVycm9yOiBwYWdlIGNyb3NzaW5nXG4iKTsKKyAgICAgICAgICAgICAgICB4ZW5fcHZfcHJpbnRm KCZuZXRkZXYtPnhlbmRldiwgMCwgImVycm9yOiBwYWdlIGNyb3NzaW5nXG4iKTsKICAgICAgICAg ICAgICAgICBuZXRfdHhfZXJyb3IobmV0ZGV2LCAmdHhyZXEsIHJjKTsKICAgICAgICAgICAgICAg ICBjb250aW51ZTsKICAgICAgICAgICAgIH0KIAotICAgICAgICAgICAgeGVuX2JlX3ByaW50Zigm bmV0ZGV2LT54ZW5kZXYsIDMsCisgICAgICAgICAgICB4ZW5fcHZfcHJpbnRmKCZuZXRkZXYtPnhl bmRldiwgMywKICAgICAgICAgICAgICAgICAgICAgICAgICAidHggcGFja2V0IHJlZiAlZCwgb2Zm ICVkLCBsZW4gJWQsIGZsYWdzIDB4JXglcyVzJXMlc1xuIiwKICAgICAgICAgICAgICAgICAgICAg ICAgICAgdHhyZXEuZ3JlZiwgdHhyZXEub2Zmc2V0LCB0eHJlcS5zaXplLCB0eHJlcS5mbGFncywK ICAgICAgICAgICAgICAgICAgICAgICAgICAgKHR4cmVxLmZsYWdzICYgTkVUVFhGX2NzdW1fYmxh bmspICAgICA/ICIgY3N1bV9ibGFuayIgICAgIDogIiIsCkBAIC0xNjUsNyArMTY1LDcgQEAgc3Rh dGljIHZvaWQgbmV0X3R4X3BhY2tldHMoc3RydWN0IFhlbk5ldERldiAqbmV0ZGV2KQogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5ldGRldi0+eGVuZGV2LmRvbSwK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0eHJlcS5ncmVmLCBQ Uk9UX1JFQUQpOwogICAgICAgICAgICAgaWYgKHBhZ2UgPT0gTlVMTCkgewotICAgICAgICAgICAg ICAgIHhlbl9iZV9wcmludGYoJm5ldGRldi0+eGVuZGV2LCAwLAorICAgICAgICAgICAgICAgIHhl bl9wdl9wcmludGYoJm5ldGRldi0+eGVuZGV2LCAwLAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAiZXJyb3I6IHR4IGdyZWYgZGVyZWZlcmVuY2UgZmFpbGVkICglZClcbiIsCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHR4cmVxLmdyZWYpOwogICAgICAgICAgICAgICAgIG5ldF90 eF9lcnJvcihuZXRkZXYsICZ0eHJlcSwgcmMpOwpAQCAtMjE1LDcgKzIxNSw3IEBAIHN0YXRpYyB2 b2lkIG5ldF9yeF9yZXNwb25zZShzdHJ1Y3QgWGVuTmV0RGV2ICpuZXRkZXYsCiAgICAgICAgIHJl c3AtPnN0YXR1cyA9IChpbnQxNl90KXN0OwogICAgIH0KIAotICAgIHhlbl9iZV9wcmludGYoJm5l dGRldi0+eGVuZGV2LCAzLAorICAgIHhlbl9wdl9wcmludGYoJm5ldGRldi0+eGVuZGV2LCAzLAog ICAgICAgICAgICAgICAgICAicnggcmVzcG9uc2U6IGlkeCAlZCwgc3RhdHVzICVkLCBmbGFncyAw eCV4XG4iLAogICAgICAgICAgICAgICAgICAgaSwgcmVzcC0+c3RhdHVzLCByZXNwLT5mbGFncyk7 CiAKQEAgLTI0Nyw3ICsyNDcsNyBAQCBzdGF0aWMgc3NpemVfdCBuZXRfcnhfcGFja2V0KE5ldENs aWVudFN0YXRlICpuYywgY29uc3QgdWludDhfdCAqYnVmLCBzaXplX3Qgc2l6ZQogICAgICAgICBy ZXR1cm4gMDsKICAgICB9CiAgICAgaWYgKHNpemUgPiBYQ19QQUdFX1NJWkUgLSBORVRfSVBfQUxJ R04pIHsKLSAgICAgICAgeGVuX2JlX3ByaW50ZigmbmV0ZGV2LT54ZW5kZXYsIDAsICJwYWNrZXQg dG9vIGJpZyAoJWx1ID4gJWxkKSIsCisgICAgICAgIHhlbl9wdl9wcmludGYoJm5ldGRldi0+eGVu ZGV2LCAwLCAicGFja2V0IHRvbyBiaWcgKCVsdSA+ICVsZCkiLAogICAgICAgICAgICAgICAgICAg ICAgICh1bnNpZ25lZCBsb25nKXNpemUsIFhDX1BBR0VfU0laRSAtIE5FVF9JUF9BTElHTik7CiAg ICAgICAgIHJldHVybiAtMTsKICAgICB9CkBAIC0yNTksNyArMjU5LDcgQEAgc3RhdGljIHNzaXpl X3QgbmV0X3J4X3BhY2tldChOZXRDbGllbnRTdGF0ZSAqbmMsIGNvbnN0IHVpbnQ4X3QgKmJ1Ziwg c2l6ZV90IHNpemUKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbmV0ZGV2LT54 ZW5kZXYuZG9tLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByeHJlcS5ncmVm LCBQUk9UX1dSSVRFKTsKICAgICBpZiAocGFnZSA9PSBOVUxMKSB7Ci0gICAgICAgIHhlbl9iZV9w cmludGYoJm5ldGRldi0+eGVuZGV2LCAwLAorICAgICAgICB4ZW5fcHZfcHJpbnRmKCZuZXRkZXYt PnhlbmRldiwgMCwKICAgICAgICAgICAgICAgICAgICAgICJlcnJvcjogcnggZ3JlZiBkZXJlZmVy ZW5jZSBmYWlsZWQgKCVkKVxuIiwKICAgICAgICAgICAgICAgICAgICAgICByeHJlcS5ncmVmKTsK ICAgICAgICAgbmV0X3J4X3Jlc3BvbnNlKG5ldGRldiwgJnJ4cmVxLCBORVRJRl9SU1BfRVJST1Is IDAsIDAsIDApOwpAQCAtMzM0LDcgKzMzNCw3IEBAIHN0YXRpYyBpbnQgbmV0X2Nvbm5lY3Qoc3Ry dWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAgICAgICByeF9jb3B5ID0gMDsKICAgICB9CiAgICAg aWYgKHJ4X2NvcHkgPT0gMCkgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKCZuZXRkZXYtPnhlbmRl diwgMCwKKyAgICAgICAgeGVuX3B2X3ByaW50ZigmbmV0ZGV2LT54ZW5kZXYsIDAsCiAgICAgICAg ICAgICAgICAgICAgICAiZnJvbnRlbmQgZG9lc24ndCBzdXBwb3J0IHJ4LWNvcHkuXG4iKTsKICAg ICAgICAgcmV0dXJuIC0xOwogICAgIH0KQEAgLTM2MCw3ICszNjAsNyBAQCBzdGF0aWMgaW50IG5l dF9jb25uZWN0KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKIAogICAgIHhlbl9iZV9iaW5kX2V2 dGNobigmbmV0ZGV2LT54ZW5kZXYpOwogCi0gICAgeGVuX2JlX3ByaW50ZigmbmV0ZGV2LT54ZW5k ZXYsIDEsICJvazogdHgtcmluZy1yZWYgJWQsIHJ4LXJpbmctcmVmICVkLCAiCisgICAgeGVuX3B2 X3ByaW50ZigmbmV0ZGV2LT54ZW5kZXYsIDEsICJvazogdHgtcmluZy1yZWYgJWQsIHJ4LXJpbmct cmVmICVkLCAiCiAgICAgICAgICAgICAgICAgICAicmVtb3RlIHBvcnQgJWQsIGxvY2FsIHBvcnQg JWRcbiIsCiAgICAgICAgICAgICAgICAgICBuZXRkZXYtPnR4X3JpbmdfcmVmLCBuZXRkZXYtPnJ4 X3JpbmdfcmVmLAogICAgICAgICAgICAgICAgICAgbmV0ZGV2LT54ZW5kZXYucmVtb3RlX3BvcnQs IG5ldGRldi0+eGVuZGV2LmxvY2FsX3BvcnQpOwpkaWZmIC0tZ2l0IGEvaHcvdXNiL3hlbi11c2Iu YyBiL2h3L3VzYi94ZW4tdXNiLmMKaW5kZXggMTA3NzNmMi4uYTI0NTM1NSAxMDA2NDQKLS0tIGEv aHcvdXNiL3hlbi11c2IuYworKysgYi9ody91c2IveGVuLXVzYi5jCkBAIC00OCw3ICs0OCw3IEBA CiAgICAgICAgIHN0cnVjdCB0aW1ldmFsIHR2OyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIFwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgXAogICAgICAgICBnZXR0aW1lb2ZkYXkoJnR2LCBO VUxMKTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCi0gICAgICAgIHhlbl9i ZV9wcmludGYoeGVuZGV2LCBsdmwsICIlOGxkLiUwNmxkIHhlbi11c2IoJXMpOiIgZm10LCAgIFwK KyAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIGx2bCwgIiU4bGQuJTA2bGQgeGVuLXVzYigl cyk6IiBmbXQsICAgXAogICAgICAgICAgICAgICAgICAgICAgIHR2LnR2X3NlYywgdHYudHZfdXNl YywgX19mdW5jX18sICMjYXJncyk7ICAgICBcCiAgICAgfQogI2RlZmluZSBUUl9CVVMoeGVuZGV2 LCBmbXQsIGFyZ3MuLi4pIFRSKHhlbmRldiwgMiwgZm10LCAjI2FyZ3MpCkBAIC0xNTQsNyArMTU0 LDcgQEAgc3RhdGljIGludCB1c2JiYWNrX2dudHRhYl9tYXAoc3RydWN0IHVzYmJhY2tfcmVxICp1 c2JiYWNrX3JlcSkKICAgICB9CiAKICAgICBpZiAobnJfc2VncyA+IFVTQklGX01BWF9TRUdNRU5U U19QRVJfUkVRVUVTVCkgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKHhlbmRldiwgMCwgImJhZCBu dW1iZXIgb2Ygc2VnbWVudHMgaW4gcmVxdWVzdCAoJWQpXG4iLAorICAgICAgICB4ZW5fcHZfcHJp bnRmKHhlbmRldiwgMCwgImJhZCBudW1iZXIgb2Ygc2VnbWVudHMgaW4gcmVxdWVzdCAoJWQpXG4i LAogICAgICAgICAgICAgICAgICAgICAgIG5yX3NlZ3MpOwogICAgICAgICByZXR1cm4gLUVJTlZB TDsKICAgICB9CkBAIC0xNjIsNyArMTYyLDcgQEAgc3RhdGljIGludCB1c2JiYWNrX2dudHRhYl9t YXAoc3RydWN0IHVzYmJhY2tfcmVxICp1c2JiYWNrX3JlcSkKICAgICBmb3IgKGkgPSAwOyBpIDwg bnJfc2VnczsgaSsrKSB7CiAgICAgICAgIGlmICgodW5zaWduZWQpdXNiYmFja19yZXEtPnJlcS5z ZWdbaV0ub2Zmc2V0ICsKICAgICAgICAgICAgICh1bnNpZ25lZCl1c2JiYWNrX3JlcS0+cmVxLnNl Z1tpXS5sZW5ndGggPiBQQUdFX1NJWkUpIHsKLSAgICAgICAgICAgIHhlbl9iZV9wcmludGYoeGVu ZGV2LCAwLCAic2VnbWVudCBjcm9zc2VzIHBhZ2UgYm91bmRhcnlcbiIpOworICAgICAgICAgICAg eGVuX3B2X3ByaW50Zih4ZW5kZXYsIDAsICJzZWdtZW50IGNyb3NzZXMgcGFnZSBib3VuZGFyeVxu Iik7CiAgICAgICAgICAgICByZXR1cm4gLUVJTlZBTDsKICAgICAgICAgfQogICAgIH0KQEAgLTIw MCw3ICsyMDAsNyBAQCBzdGF0aWMgaW50IHVzYmJhY2tfZ250dGFiX21hcChzdHJ1Y3QgdXNiYmFj a19yZXEgKnVzYmJhY2tfcmVxKQogICAgICAqLwogCiAgICAgaWYgKCF1c2JiYWNrX3JlcS0+bnJf ZXh0cmFfc2VncykgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKHhlbmRldiwgMCwgImlzbyByZXF1 ZXN0IHdpdGhvdXQgZGVzY3JpcHRvciBzZWdtZW50c1xuIik7CisgICAgICAgIHhlbl9wdl9wcmlu dGYoeGVuZGV2LCAwLCAiaXNvIHJlcXVlc3Qgd2l0aG91dCBkZXNjcmlwdG9yIHNlZ21lbnRzXG4i KTsKICAgICAgICAgcmV0dXJuIC1FSU5WQUw7CiAgICAgfQogCkBAIC01NTIsMTQgKzU1MiwxNCBA QCBzdGF0aWMgdm9pZCB1c2JiYWNrX2Rpc3BhdGNoKHN0cnVjdCB1c2JiYWNrX3JlcSAqdXNiYmFj a19yZXEpCiAKICAgICByZXQgPSB1c2JiYWNrX2luaXRfcGFja2V0KHVzYmJhY2tfcmVxKTsKICAg ICBpZiAocmV0KSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoJnVzYmlmLT54ZW5kZXYsIDAsICJp bnZhbGlkIHJlcXVlc3RcbiIpOworICAgICAgICB4ZW5fcHZfcHJpbnRmKCZ1c2JpZi0+eGVuZGV2 LCAwLCAiaW52YWxpZCByZXF1ZXN0XG4iKTsKICAgICAgICAgcmV0ID0gLUVTSFVURE9XTjsKICAg ICAgICAgZ290byBmYWlsX2ZyZWVfdXJiOwogICAgIH0KIAogICAgIHJldCA9IHVzYmJhY2tfZ250 dGFiX21hcCh1c2JiYWNrX3JlcSk7CiAgICAgaWYgKHJldCkgewotICAgICAgICB4ZW5fYmVfcHJp bnRmKCZ1c2JpZi0+eGVuZGV2LCAwLCAiaW52YWxpZCBidWZmZXIsIHJldD0lZFxuIiwgcmV0KTsK KyAgICAgICAgeGVuX3B2X3ByaW50ZigmdXNiaWYtPnhlbmRldiwgMCwgImludmFsaWQgYnVmZmVy LCByZXQ9JWRcbiIsIHJldCk7CiAgICAgICAgIHJldCA9IC1FU0hVVERPV047CiAgICAgICAgIGdv dG8gZmFpbF9mcmVlX3VyYjsKICAgICB9CkBAIC02NDcsNyArNjQ3LDcgQEAgc3RhdGljIHZvaWQg dXNiYmFja19iaCh2b2lkICpvcGFxdWUpCiAKICAgICBpZiAoUklOR19SRVFVRVNUX1BST0RfT1ZF UkZMT1codXJiX3JpbmcsIHJwKSkgewogICAgICAgICByYyA9IHVyYl9yaW5nLT5yc3BfcHJvZF9w dnQ7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoJnVzYmlmLT54ZW5kZXYsIDAsICJkb21VIHByb3Zp ZGVkIGJvZ3VzIHJpbmcgcmVxdWVzdHMgIgorICAgICAgICB4ZW5fcHZfcHJpbnRmKCZ1c2JpZi0+ eGVuZGV2LCAwLCAiZG9tVSBwcm92aWRlZCBib2d1cyByaW5nIHJlcXVlc3RzICIKICAgICAgICAg ICAgICAgICAgICAgICAiKCUjeCAtICUjeCA9ICV1KS4gSGFsdGluZyByaW5nIHByb2Nlc3Npbmcu XG4iLAogICAgICAgICAgICAgICAgICAgICAgIHJwLCByYywgcnAgLSByYyk7CiAgICAgICAgIHVz YmlmLT5yaW5nX2Vycm9yID0gdHJ1ZTsKQEAgLTc0NSw3ICs3NDUsNyBAQCBzdGF0aWMgdm9pZCB1 c2JiYWNrX3BvcnRpZF9hZGQoc3RydWN0IHVzYmJhY2tfaW5mbyAqdXNiaWYsIHVuc2lnbmVkIHBv cnQsCiAKICAgICBwb3J0bmFtZSA9IHN0cmNocihidXNpZCwgJy0nKTsKICAgICBpZiAoIXBvcnRu YW1lKSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoJnVzYmlmLT54ZW5kZXYsIDAsICJkZXZpY2Ug JXMgaWxsZWdhbCBzcGVjaWZpY2F0aW9uXG4iLAorICAgICAgICB4ZW5fcHZfcHJpbnRmKCZ1c2Jp Zi0+eGVuZGV2LCAwLCAiZGV2aWNlICVzIGlsbGVnYWwgc3BlY2lmaWNhdGlvblxuIiwKICAgICAg ICAgICAgICAgICAgICAgICBidXNpZCk7CiAgICAgICAgIHJldHVybjsKICAgICB9CkBAIC03ODQs NyArNzg0LDcgQEAgc3RhdGljIHZvaWQgdXNiYmFja19wb3J0aWRfYWRkKHN0cnVjdCB1c2JiYWNr X2luZm8gKnVzYmlmLCB1bnNpZ25lZCBwb3J0LAogICAgICAgICBicmVhazsKICAgICB9CiAgICAg aWYgKHNwZWVkID09IFVTQklGX1NQRUVEX05PTkUpIHsKLSAgICAgICAgeGVuX2JlX3ByaW50Zigm dXNiaWYtPnhlbmRldiwgMCwgImRldmljZSAlcyB3cm9uZyBzcGVlZFxuIiwgYnVzaWQpOworICAg ICAgICB4ZW5fcHZfcHJpbnRmKCZ1c2JpZi0+eGVuZGV2LCAwLCAiZGV2aWNlICVzIHdyb25nIHNw ZWVkXG4iLCBidXNpZCk7CiAgICAgICAgIG9iamVjdF91bnBhcmVudChPQkpFQ1QodXNiaWYtPnBv cnRzW3BvcnQgLSAxXS5kZXYpKTsKICAgICAgICAgdXNiaWYtPnBvcnRzW3BvcnQgLSAxXS5kZXYg PSBOVUxMOwogICAgICAgICByZXR1cm47CkBAIC04MDEsNyArODAxLDcgQEAgc3RhdGljIHZvaWQg dXNiYmFja19wb3J0aWRfYWRkKHN0cnVjdCB1c2JiYWNrX2luZm8gKnVzYmlmLCB1bnNpZ25lZCBw b3J0LAogZXJyOgogICAgIFFERUNSRUYocWRpY3QpOwogICAgIHNucHJpbnRmKHAtPnBhdGgsIHNp emVvZihwLT5wYXRoKSwgIiVkIiwgOTkpOwotICAgIHhlbl9iZV9wcmludGYoJnVzYmlmLT54ZW5k ZXYsIDAsICJkZXZpY2UgJXMgY291bGQgbm90IGJlIG9wZW5lZFxuIiwgYnVzaWQpOworICAgIHhl bl9wdl9wcmludGYoJnVzYmlmLT54ZW5kZXYsIDAsICJkZXZpY2UgJXMgY291bGQgbm90IGJlIG9w ZW5lZFxuIiwgYnVzaWQpOwogfQogCiBzdGF0aWMgdm9pZCB1c2JiYWNrX3Byb2Nlc3NfcG9ydChz dHJ1Y3QgdXNiYmFja19pbmZvICp1c2JpZiwgdW5zaWduZWQgcG9ydCkKQEAgLTgxMiw3ICs4MTIs NyBAQCBzdGF0aWMgdm9pZCB1c2JiYWNrX3Byb2Nlc3NfcG9ydChzdHJ1Y3QgdXNiYmFja19pbmZv ICp1c2JpZiwgdW5zaWduZWQgcG9ydCkKICAgICBzbnByaW50Zihub2RlLCBzaXplb2Yobm9kZSks ICJwb3J0LyVkIiwgcG9ydCk7CiAgICAgYnVzaWQgPSB4ZW5zdG9yZV9yZWFkX2JlX3N0cigmdXNi aWYtPnhlbmRldiwgbm9kZSk7CiAgICAgaWYgKGJ1c2lkID09IE5VTEwpIHsKLSAgICAgICAgeGVu X2JlX3ByaW50ZigmdXNiaWYtPnhlbmRldiwgMCwgInhlbnN0b3JlX3JlYWQgJXMgZmFpbGVkXG4i LCBub2RlKTsKKyAgICAgICAgeGVuX3B2X3ByaW50ZigmdXNiaWYtPnhlbmRldiwgMCwgInhlbnN0 b3JlX3JlYWQgJXMgZmFpbGVkXG4iLCBub2RlKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIApA QCAtODY5LDE1ICs4NjksMTUgQEAgc3RhdGljIGludCB1c2JiYWNrX2Nvbm5lY3Qoc3RydWN0IFhl bkRldmljZSAqeGVuZGV2KQogICAgIHVzYmlmID0gY29udGFpbmVyX29mKHhlbmRldiwgc3RydWN0 IHVzYmJhY2tfaW5mbywgeGVuZGV2KTsKIAogICAgIGlmICh4ZW5zdG9yZV9yZWFkX2ZlX2ludCh4 ZW5kZXYsICJ1cmItcmluZy1yZWYiLCAmdXJiX3JpbmdfcmVmKSkgewotICAgICAgICB4ZW5fYmVf cHJpbnRmKHhlbmRldiwgMCwgImVycm9yIHJlYWRpbmcgdXJiLXJpbmctcmVmXG4iKTsKKyAgICAg ICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDAsICJlcnJvciByZWFkaW5nIHVyYi1yaW5nLXJlZlxu Iik7CiAgICAgICAgIHJldHVybiAtMTsKICAgICB9CiAgICAgaWYgKHhlbnN0b3JlX3JlYWRfZmVf aW50KHhlbmRldiwgImNvbm4tcmluZy1yZWYiLCAmY29ubl9yaW5nX3JlZikpIHsKLSAgICAgICAg eGVuX2JlX3ByaW50Zih4ZW5kZXYsIDAsICJlcnJvciByZWFkaW5nIGNvbm4tcmluZy1yZWZcbiIp OworICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMCwgImVycm9yIHJlYWRpbmcgY29ubi1y aW5nLXJlZlxuIik7CiAgICAgICAgIHJldHVybiAtMTsKICAgICB9CiAgICAgaWYgKHhlbnN0b3Jl X3JlYWRfZmVfaW50KHhlbmRldiwgImV2ZW50LWNoYW5uZWwiLCAmeGVuZGV2LT5yZW1vdGVfcG9y dCkpIHsKLSAgICAgICAgeGVuX2JlX3ByaW50Zih4ZW5kZXYsIDAsICJlcnJvciByZWFkaW5nIGV2 ZW50LWNoYW5uZWxcbiIpOworICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMCwgImVycm9y IHJlYWRpbmcgZXZlbnQtY2hhbm5lbFxuIik7CiAgICAgICAgIHJldHVybiAtMTsKICAgICB9CiAK QEAgLTg4OCw3ICs4ODgsNyBAQCBzdGF0aWMgaW50IHVzYmJhY2tfY29ubmVjdChzdHJ1Y3QgWGVu RGV2aWNlICp4ZW5kZXYpCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBjb25uX3JpbmdfcmVmLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgUFJPVF9SRUFEIHwgUFJPVF9XUklURSk7CiAgICAgaWYgKCF1c2JpZi0+ dXJiX3NyaW5nIHx8ICF1c2JpZi0+Y29ubl9zcmluZykgewotICAgICAgICB4ZW5fYmVfcHJpbnRm KHhlbmRldiwgMCwgImVycm9yIG1hcHBpbmcgcmluZ3NcbiIpOworICAgICAgICB4ZW5fcHZfcHJp bnRmKHhlbmRldiwgMCwgImVycm9yIG1hcHBpbmcgcmluZ3NcbiIpOwogICAgICAgICB1c2JiYWNr X2Rpc2Nvbm5lY3QoeGVuZGV2KTsKICAgICAgICAgcmV0dXJuIC0xOwogICAgIH0KQEAgLTkwMCw3 ICs5MDAsNyBAQCBzdGF0aWMgaW50IHVzYmJhY2tfY29ubmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4 ZW5kZXYpCiAKICAgICB4ZW5fYmVfYmluZF9ldnRjaG4oeGVuZGV2KTsKIAotICAgIHhlbl9iZV9w cmludGYoeGVuZGV2LCAxLCAidXJiLXJpbmctcmVmICVkLCBjb25uLXJpbmctcmVmICVkLCAiCisg ICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDEsICJ1cmItcmluZy1yZWYgJWQsIGNvbm4tcmluZy1y ZWYgJWQsICIKICAgICAgICAgICAgICAgICAgICJyZW1vdGUgcG9ydCAlZCwgbG9jYWwgcG9ydCAl ZFxuIiwgdXJiX3JpbmdfcmVmLAogICAgICAgICAgICAgICAgICAgY29ubl9yaW5nX3JlZiwgeGVu ZGV2LT5yZW1vdGVfcG9ydCwgeGVuZGV2LT5sb2NhbF9wb3J0KTsKIApAQCAtOTM2LDEyICs5MzYs MTIgQEAgc3RhdGljIGludCB1c2JiYWNrX2luaXQoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQog CiAgICAgaWYgKHhlbnN0b3JlX3JlYWRfYmVfaW50KHhlbmRldiwgIm51bS1wb3J0cyIsICZ1c2Jp Zi0+bnVtX3BvcnRzKSB8fAogICAgICAgICB1c2JpZi0+bnVtX3BvcnRzIDwgMSB8fCB1c2JpZi0+ bnVtX3BvcnRzID4gVVNCQkFDS19NQVhQT1JUUykgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKHhl bmRldiwgMCwgIm51bS1wb3J0cyBub3QgcmVhZGFibGUgb3Igb3V0IG9mIGJvdW5kc1xuIik7Cisg ICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAwLCAibnVtLXBvcnRzIG5vdCByZWFkYWJsZSBv ciBvdXQgb2YgYm91bmRzXG4iKTsKICAgICAgICAgcmV0dXJuIC0xOwogICAgIH0KICAgICBpZiAo eGVuc3RvcmVfcmVhZF9iZV9pbnQoeGVuZGV2LCAidXNiLXZlciIsICZ1c2JpZi0+dXNiX3Zlcikg fHwKICAgICAgICAgKHVzYmlmLT51c2JfdmVyICE9IFVTQl9WRVJfVVNCMTEgJiYgdXNiaWYtPnVz Yl92ZXIgIT0gVVNCX1ZFUl9VU0IyMCkpIHsKLSAgICAgICAgeGVuX2JlX3ByaW50Zih4ZW5kZXYs IDAsICJ1c2ItdmVyIG5vdCByZWFkYWJsZSBvciBvdXQgb2YgYm91bmRzXG4iKTsKKyAgICAgICAg eGVuX3B2X3ByaW50Zih4ZW5kZXYsIDAsICJ1c2ItdmVyIG5vdCByZWFkYWJsZSBvciBvdXQgb2Yg Ym91bmRzXG4iKTsKICAgICAgICAgcmV0dXJuIC0xOwogICAgIH0KIApAQCAtMTAyOSw3ICsxMDI5 LDcgQEAgc3RhdGljIHZvaWQgdXNiYmFja19hbGxvYyhzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYp CiAgICAgLyogbWF4X2dyYW50czogZm9yIGVhY2ggcmVxdWVzdCBhbmQgZm9yIHRoZSByaW5ncyAo cmVxdWVzdCBhbmQgY29ubmVjdCkuICovCiAgICAgbWF4X2dyYW50cyA9IFVTQklGX01BWF9TRUdN RU5UU19QRVJfUkVRVUVTVCAqIFVTQl9VUkJfUklOR19TSVpFICsgMjsKICAgICBpZiAoeGVuZ250 dGFiX3NldF9tYXhfZ3JhbnRzKHhlbmRldi0+Z250dGFiZGV2LCBtYXhfZ3JhbnRzKSA8IDApIHsK LSAgICAgICAgeGVuX2JlX3ByaW50Zih4ZW5kZXYsIDAsICJ4ZW5nbnR0YWJfc2V0X21heF9ncmFu dHMgZmFpbGVkOiAlc1xuIiwKKyAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDAsICJ4ZW5n bnR0YWJfc2V0X21heF9ncmFudHMgZmFpbGVkOiAlc1xuIiwKICAgICAgICAgICAgICAgICAgICAg ICBzdHJlcnJvcihlcnJubykpOwogICAgIH0KIH0KZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW5fYmFj a2VuZC5jIGIvaHcveGVuL3hlbl9iYWNrZW5kLmMKaW5kZXggMzUxOGFhYy4uOTc4NjljZiAxMDA2 NDQKLS0tIGEvaHcveGVuL3hlbl9iYWNrZW5kLmMKKysrIGIvaHcveGVuL3hlbl9iYWNrZW5kLmMK QEAgLTg1LDcgKzg1LDcgQEAgaW50IHhlbl9iZV9zZXRfc3RhdGUoc3RydWN0IFhlbkRldmljZSAq eGVuZGV2LCBlbnVtIHhlbmJ1c19zdGF0ZSBzdGF0ZSkKICAgICBpZiAocmMgPCAwKSB7CiAgICAg ICAgIHJldHVybiByYzsKICAgICB9Ci0gICAgeGVuX2JlX3ByaW50Zih4ZW5kZXYsIDEsICJiYWNr ZW5kIHN0YXRlOiAlcyAtPiAlc1xuIiwKKyAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMSwgImJh Y2tlbmQgc3RhdGU6ICVzIC0+ICVzXG4iLAogICAgICAgICAgICAgICAgICAgeGVuYnVzX3N0cnN0 YXRlKHhlbmRldi0+YmVfc3RhdGUpLCB4ZW5idXNfc3Ryc3RhdGUoc3RhdGUpKTsKICAgICB4ZW5k ZXYtPmJlX3N0YXRlID0gc3RhdGU7CiAgICAgcmV0dXJuIDA7CkBAIC0xMjEsNyArMTIxLDcgQEAg c3RhdGljIHN0cnVjdCBYZW5EZXZpY2UgKnhlbl9iZV9nZXRfeGVuZGV2KGNvbnN0IGNoYXIgKnR5 cGUsIGludCBkb20sIGludCBkZXYsCiAKICAgICB4ZW5kZXYtPmV2dGNobmRldiA9IHhlbmV2dGNo bl9vcGVuKE5VTEwsIDApOwogICAgIGlmICh4ZW5kZXYtPmV2dGNobmRldiA9PSBOVUxMKSB7Ci0g ICAgICAgIHhlbl9iZV9wcmludGYoTlVMTCwgMCwgImNhbid0IG9wZW4gZXZ0Y2huIGRldmljZVxu Iik7CisgICAgICAgIHhlbl9wdl9wcmludGYoTlVMTCwgMCwgImNhbid0IG9wZW4gZXZ0Y2huIGRl dmljZVxuIik7CiAgICAgICAgIGdfZnJlZSh4ZW5kZXYpOwogICAgICAgICByZXR1cm4gTlVMTDsK ICAgICB9CkBAIC0xMzAsNyArMTMwLDcgQEAgc3RhdGljIHN0cnVjdCBYZW5EZXZpY2UgKnhlbl9i ZV9nZXRfeGVuZGV2KGNvbnN0IGNoYXIgKnR5cGUsIGludCBkb20sIGludCBkZXYsCiAgICAgaWYg KG9wcy0+ZmxhZ3MgJiBERVZPUFNfRkxBR19ORUVEX0dOVERFVikgewogICAgICAgICB4ZW5kZXYt PmdudHRhYmRldiA9IHhlbmdudHRhYl9vcGVuKE5VTEwsIDApOwogICAgICAgICBpZiAoeGVuZGV2 LT5nbnR0YWJkZXYgPT0gTlVMTCkgewotICAgICAgICAgICAgeGVuX2JlX3ByaW50ZihOVUxMLCAw LCAiY2FuJ3Qgb3BlbiBnbnR0YWIgZGV2aWNlXG4iKTsKKyAgICAgICAgICAgIHhlbl9wdl9wcmlu dGYoTlVMTCwgMCwgImNhbid0IG9wZW4gZ250dGFiIGRldmljZVxuIik7CiAgICAgICAgICAgICB4 ZW5ldnRjaG5fY2xvc2UoeGVuZGV2LT5ldnRjaG5kZXYpOwogICAgICAgICAgICAgZ19mcmVlKHhl bmRldik7CiAgICAgICAgICAgICByZXR1cm4gTlVMTDsKQEAgLTE2Myw3ICsxNjMsNyBAQCBzdGF0 aWMgdm9pZCB4ZW5fYmVfYmFja2VuZF9jaGFuZ2VkKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwg Y29uc3QgY2hhciAqbm9kZSkKICAgICB9CiAKICAgICBpZiAobm9kZSkgewotICAgICAgICB4ZW5f YmVfcHJpbnRmKHhlbmRldiwgMiwgImJhY2tlbmQgdXBkYXRlOiAlc1xuIiwgbm9kZSk7CisgICAg ICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAyLCAiYmFja2VuZCB1cGRhdGU6ICVzXG4iLCBub2Rl KTsKICAgICAgICAgaWYgKHhlbmRldi0+b3BzLT5iYWNrZW5kX2NoYW5nZWQpIHsKICAgICAgICAg ICAgIHhlbmRldi0+b3BzLT5iYWNrZW5kX2NoYW5nZWQoeGVuZGV2LCBub2RlKTsKICAgICAgICAg fQpAQCAtMTg3LDI2ICsxODcsMjYgQEAgc3RhdGljIGludCB4ZW5fYmVfdHJ5X3NldHVwKHN0cnVj dCBYZW5EZXZpY2UgKnhlbmRldikKICAgICBpbnQgYmVfc3RhdGU7CiAKICAgICBpZiAoeGVuc3Rv cmVfcmVhZF9iZV9pbnQoeGVuZGV2LCAic3RhdGUiLCAmYmVfc3RhdGUpID09IC0xKSB7Ci0gICAg ICAgIHhlbl9iZV9wcmludGYoeGVuZGV2LCAwLCAicmVhZGluZyBiYWNrZW5kIHN0YXRlIGZhaWxl ZFxuIik7CisgICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAwLCAicmVhZGluZyBiYWNrZW5k IHN0YXRlIGZhaWxlZFxuIik7CiAgICAgICAgIHJldHVybiAtMTsKICAgICB9CiAKICAgICBpZiAo YmVfc3RhdGUgIT0gWGVuYnVzU3RhdGVJbml0aWFsaXNpbmcpIHsKLSAgICAgICAgeGVuX2JlX3By aW50Zih4ZW5kZXYsIDAsICJpbml0aWFsIGJhY2tlbmQgc3RhdGUgaXMgd3JvbmcgKCVzKVxuIiwK KyAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDAsICJpbml0aWFsIGJhY2tlbmQgc3RhdGUg aXMgd3JvbmcgKCVzKVxuIiwKICAgICAgICAgICAgICAgICAgICAgICB4ZW5idXNfc3Ryc3RhdGUo YmVfc3RhdGUpKTsKICAgICAgICAgcmV0dXJuIC0xOwogICAgIH0KIAogICAgIHhlbmRldi0+ZmUg PSB4ZW5zdG9yZV9yZWFkX2JlX3N0cih4ZW5kZXYsICJmcm9udGVuZCIpOwogICAgIGlmICh4ZW5k ZXYtPmZlID09IE5VTEwpIHsKLSAgICAgICAgeGVuX2JlX3ByaW50Zih4ZW5kZXYsIDAsICJyZWFk aW5nIGZyb250ZW5kIHBhdGggZmFpbGVkXG4iKTsKKyAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5k ZXYsIDAsICJyZWFkaW5nIGZyb250ZW5kIHBhdGggZmFpbGVkXG4iKTsKICAgICAgICAgcmV0dXJu IC0xOwogICAgIH0KIAogICAgIC8qIHNldHVwIGZyb250ZW5kIHdhdGNoICovCiAgICAgc25wcmlu dGYodG9rZW4sIHNpemVvZih0b2tlbiksICJmZTolcCIsIHhlbmRldik7CiAgICAgaWYgKCF4c193 YXRjaCh4ZW5zdG9yZSwgeGVuZGV2LT5mZSwgdG9rZW4pKSB7Ci0gICAgICAgIHhlbl9iZV9wcmlu dGYoeGVuZGV2LCAwLCAid2F0Y2hpbmcgZnJvbnRlbmQgcGF0aCAoJXMpIGZhaWxlZFxuIiwKKyAg ICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDAsICJ3YXRjaGluZyBmcm9udGVuZCBwYXRoICgl cykgZmFpbGVkXG4iLAogICAgICAgICAgICAgICAgICAgICAgIHhlbmRldi0+ZmUpOwogICAgICAg ICByZXR1cm4gLTE7CiAgICAgfQpAQCAtMjMwLDcgKzIzMCw3IEBAIHN0YXRpYyBpbnQgeGVuX2Jl X3RyeV9pbml0KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKICAgICBpbnQgcmMgPSAwOwogCiAg ICAgaWYgKCF4ZW5kZXYtPm9ubGluZSkgewotICAgICAgICB4ZW5fYmVfcHJpbnRmKHhlbmRldiwg MSwgIm5vdCBvbmxpbmVcbiIpOworICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMSwgIm5v dCBvbmxpbmVcbiIpOwogICAgICAgICByZXR1cm4gLTE7CiAgICAgfQogCkBAIC0yMzgsNyArMjM4 LDcgQEAgc3RhdGljIGludCB4ZW5fYmVfdHJ5X2luaXQoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2 KQogICAgICAgICByYyA9IHhlbmRldi0+b3BzLT5pbml0KHhlbmRldik7CiAgICAgfQogICAgIGlm IChyYyAhPSAwKSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoeGVuZGV2LCAxLCAiaW5pdCgpIGZh aWxlZFxuIik7CisgICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAxLCAiaW5pdCgpIGZhaWxl ZFxuIik7CiAgICAgICAgIHJldHVybiByYzsKICAgICB9CiAKQEAgLTI2MSw5ICsyNjEsOSBAQCBz dGF0aWMgaW50IHhlbl9iZV90cnlfaW5pdGlhbGlzZShzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYp CiAgICAgaWYgKHhlbmRldi0+ZmVfc3RhdGUgIT0gWGVuYnVzU3RhdGVJbml0aWFsaXNlZCAgJiYK ICAgICAgICAgeGVuZGV2LT5mZV9zdGF0ZSAhPSBYZW5idXNTdGF0ZUNvbm5lY3RlZCkgewogICAg ICAgICBpZiAoeGVuZGV2LT5vcHMtPmZsYWdzICYgREVWT1BTX0ZMQUdfSUdOT1JFX1NUQVRFKSB7 Ci0gICAgICAgICAgICB4ZW5fYmVfcHJpbnRmKHhlbmRldiwgMiwgImZyb250ZW5kIG5vdCByZWFk eSwgaWdub3JpbmdcbiIpOworICAgICAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDIsICJm cm9udGVuZCBub3QgcmVhZHksIGlnbm9yaW5nXG4iKTsKICAgICAgICAgfSBlbHNlIHsKLSAgICAg ICAgICAgIHhlbl9iZV9wcmludGYoeGVuZGV2LCAyLCAiZnJvbnRlbmQgbm90IHJlYWR5ICh5ZXQp XG4iKTsKKyAgICAgICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAyLCAiZnJvbnRlbmQgbm90 IHJlYWR5ICh5ZXQpXG4iKTsKICAgICAgICAgICAgIHJldHVybiAtMTsKICAgICAgICAgfQogICAg IH0KQEAgLTI3Miw3ICsyNzIsNyBAQCBzdGF0aWMgaW50IHhlbl9iZV90cnlfaW5pdGlhbGlzZShz dHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCiAgICAgICAgIHJjID0geGVuZGV2LT5vcHMtPmluaXRp YWxpc2UoeGVuZGV2KTsKICAgICB9CiAgICAgaWYgKHJjICE9IDApIHsKLSAgICAgICAgeGVuX2Jl X3ByaW50Zih4ZW5kZXYsIDAsICJpbml0aWFsaXNlKCkgZmFpbGVkXG4iKTsKKyAgICAgICAgeGVu X3B2X3ByaW50Zih4ZW5kZXYsIDAsICJpbml0aWFsaXNlKCkgZmFpbGVkXG4iKTsKICAgICAgICAg cmV0dXJuIHJjOwogICAgIH0KIApAQCAtMjkzLDkgKzI5Myw5IEBAIHN0YXRpYyB2b2lkIHhlbl9i ZV90cnlfY29ubmVjdGVkKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKIAogICAgIGlmICh4ZW5k ZXYtPmZlX3N0YXRlICE9IFhlbmJ1c1N0YXRlQ29ubmVjdGVkKSB7CiAgICAgICAgIGlmICh4ZW5k ZXYtPm9wcy0+ZmxhZ3MgJiBERVZPUFNfRkxBR19JR05PUkVfU1RBVEUpIHsKLSAgICAgICAgICAg IHhlbl9iZV9wcmludGYoeGVuZGV2LCAyLCAiZnJvbnRlbmQgbm90IHJlYWR5LCBpZ25vcmluZ1xu Iik7CisgICAgICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMiwgImZyb250ZW5kIG5vdCBy ZWFkeSwgaWdub3JpbmdcbiIpOwogICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAgeGVuX2Jl X3ByaW50Zih4ZW5kZXYsIDIsICJmcm9udGVuZCBub3QgcmVhZHkgKHlldClcbiIpOworICAgICAg ICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDIsICJmcm9udGVuZCBub3QgcmVhZHkgKHlldClc biIpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CiAgICAgfQpAQCAtMzI5LDcgKzMy OSw3IEBAIHN0YXRpYyBpbnQgeGVuX2JlX3RyeV9yZXNldChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5k ZXYpCiAgICAgICAgIHJldHVybiAtMTsKICAgICB9CiAKLSAgICB4ZW5fYmVfcHJpbnRmKHhlbmRl diwgMSwgImRldmljZSByZXNldCAoZm9yIHJlLWNvbm5lY3QpXG4iKTsKKyAgICB4ZW5fcHZfcHJp bnRmKHhlbmRldiwgMSwgImRldmljZSByZXNldCAoZm9yIHJlLWNvbm5lY3QpXG4iKTsKICAgICB4 ZW5fYmVfc2V0X3N0YXRlKHhlbmRldiwgWGVuYnVzU3RhdGVJbml0aWFsaXNpbmcpOwogICAgIHJl dHVybiAwOwogfQpAQCAtMzkwLDcgKzM5MCw3IEBAIHN0YXRpYyBpbnQgeGVuc3RvcmVfc2Nhbihj b25zdCBjaGFyICp0eXBlLCBpbnQgZG9tLCBzdHJ1Y3QgWGVuRGV2T3BzICpvcHMpCiAgICAgc25w cmludGYodG9rZW4sIHNpemVvZih0b2tlbiksICJiZTolcDolZDolcCIsIHR5cGUsIGRvbSwgb3Bz KTsKICAgICBzbnByaW50ZihwYXRoLCBzaXplb2YocGF0aCksICJiYWNrZW5kLyVzLyVkIiwgdHlw ZSwgZG9tKTsKICAgICBpZiAoIXhzX3dhdGNoKHhlbnN0b3JlLCBwYXRoLCB0b2tlbikpIHsKLSAg ICAgICAgeGVuX2JlX3ByaW50ZihOVUxMLCAwLCAieGVuIGJlOiB3YXRjaGluZyBiYWNrZW5kIHBh dGggKCVzKSBmYWlsZWRcbiIsCisgICAgICAgIHhlbl9wdl9wcmludGYoTlVMTCwgMCwgInhlbiBi ZTogd2F0Y2hpbmcgYmFja2VuZCBwYXRoICglcykgZmFpbGVkXG4iLAogICAgICAgICAgICAgICAg ICAgICAgIHBhdGgpOwogICAgICAgICByZXR1cm4gLTE7CiAgICAgfQpAQCAtNDUxLDcgKzQ1MSw3 IEBAIGludCB4ZW5fYmVfaW5pdCh2b2lkKQogewogICAgIHhlbnN0b3JlID0geHNfZGFlbW9uX29w ZW4oKTsKICAgICBpZiAoIXhlbnN0b3JlKSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoTlVMTCwg MCwgImNhbid0IGNvbm5lY3QgdG8geGVuc3RvcmVkXG4iKTsKKyAgICAgICAgeGVuX3B2X3ByaW50 ZihOVUxMLCAwLCAiY2FuJ3QgY29ubmVjdCB0byB4ZW5zdG9yZWRcbiIpOwogICAgICAgICByZXR1 cm4gLTE7CiAgICAgfQogCkBAIC01MTIsMTAgKzUxMiwxMCBAQCBpbnQgeGVuX2JlX2JpbmRfZXZ0 Y2huKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKICAgICB4ZW5kZXYtPmxvY2FsX3BvcnQgPSB4 ZW5ldnRjaG5fYmluZF9pbnRlcmRvbWFpbgogICAgICAgICAoeGVuZGV2LT5ldnRjaG5kZXYsIHhl bmRldi0+ZG9tLCB4ZW5kZXYtPnJlbW90ZV9wb3J0KTsKICAgICBpZiAoeGVuZGV2LT5sb2NhbF9w b3J0ID09IC0xKSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoeGVuZGV2LCAwLCAieGVuZXZ0Y2hu X2JpbmRfaW50ZXJkb21haW4gZmFpbGVkXG4iKTsKKyAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5k ZXYsIDAsICJ4ZW5ldnRjaG5fYmluZF9pbnRlcmRvbWFpbiBmYWlsZWRcbiIpOwogICAgICAgICBy ZXR1cm4gLTE7CiAgICAgfQotICAgIHhlbl9iZV9wcmludGYoeGVuZGV2LCAyLCAiYmluZCBldnRj aG4gcG9ydCAlZFxuIiwgeGVuZGV2LT5sb2NhbF9wb3J0KTsKKyAgICB4ZW5fcHZfcHJpbnRmKHhl bmRldiwgMiwgImJpbmQgZXZ0Y2huIHBvcnQgJWRcbiIsIHhlbmRldi0+bG9jYWxfcG9ydCk7CiAg ICAgcWVtdV9zZXRfZmRfaGFuZGxlcih4ZW5ldnRjaG5fZmQoeGVuZGV2LT5ldnRjaG5kZXYpLAog ICAgICAgICAgICAgICAgICAgICAgICAgeGVuX2JlX2V2dGNobl9ldmVudCwgTlVMTCwgeGVuZGV2 KTsKICAgICByZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW5fZGV2Y29uZmlnLmMgYi9o dy94ZW4veGVuX2RldmNvbmZpZy5jCmluZGV4IGI3ZDI5MGQuLmE4MGU3OGMgMTAwNjQ0Ci0tLSBh L2h3L3hlbi94ZW5fZGV2Y29uZmlnLmMKKysrIGIvaHcveGVuL3hlbl9kZXZjb25maWcuYwpAQCAt NTUsNyArNTUsNyBAQCBpbnQgeGVuX2NvbmZpZ19kZXZfYmxrKERyaXZlSW5mbyAqZGlzaykKICAg ICBjb25zdCBjaGFyICpmaWxlbmFtZSA9IHFlbXVfb3B0X2dldChkaXNrLT5vcHRzLCAiZmlsZSIp OwogCiAgICAgc25wcmludGYoZGV2aWNlX25hbWUsIHNpemVvZihkZXZpY2VfbmFtZSksICJ4dmQl YyIsICdhJyArIGRpc2stPnVuaXQpOwotICAgIHhlbl9iZV9wcmludGYoTlVMTCwgMSwgImNvbmZp ZyBkaXNrICVkIFslc106ICVzXG4iLAorICAgIHhlbl9wdl9wcmludGYoTlVMTCwgMSwgImNvbmZp ZyBkaXNrICVkIFslc106ICVzXG4iLAogICAgICAgICAgICAgICAgICAgZGlzay0+dW5pdCwgZGV2 aWNlX25hbWUsIGZpbGVuYW1lKTsKICAgICB4ZW5fY29uZmlnX2Rldl9kaXJzKCJ2YmQiLCAicWRp c2siLCB2ZGV2LCBmZSwgYmUsIHNpemVvZihmZSkpOwogCkBAIC04Myw3ICs4Myw3IEBAIGludCB4 ZW5fY29uZmlnX2Rldl9uaWMoTklDSW5mbyAqbmljKQogICAgIHNucHJpbnRmKG1hYywgc2l6ZW9m KG1hYyksICIlMDJ4OiUwMng6JTAyeDolMDJ4OiUwMng6JTAyeCIsCiAgICAgICAgICAgICAgbmlj LT5tYWNhZGRyLmFbMF0sIG5pYy0+bWFjYWRkci5hWzFdLCBuaWMtPm1hY2FkZHIuYVsyXSwKICAg ICAgICAgICAgICBuaWMtPm1hY2FkZHIuYVszXSwgbmljLT5tYWNhZGRyLmFbNF0sIG5pYy0+bWFj YWRkci5hWzVdKTsKLSAgICB4ZW5fYmVfcHJpbnRmKE5VTEwsIDEsICJjb25maWcgbmljICVkOiBt YWM9XCIlc1wiXG4iLCB2bGFuX2lkLCBtYWMpOworICAgIHhlbl9wdl9wcmludGYoTlVMTCwgMSwg ImNvbmZpZyBuaWMgJWQ6IG1hYz1cIiVzXCJcbiIsIHZsYW5faWQsIG1hYyk7CiAgICAgeGVuX2Nv bmZpZ19kZXZfZGlycygidmlmIiwgInFuaWMiLCB2bGFuX2lkLCBmZSwgYmUsIHNpemVvZihmZSkp OwogCiAgICAgLyogZnJvbnRlbmQgKi8KZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW5fZnJvbnRlbmQu YyBiL2h3L3hlbi94ZW5fZnJvbnRlbmQuYwppbmRleCBkNDJlNTdiLi4xNDA3ZjVmIDEwMDY0NAot LS0gYS9ody94ZW4veGVuX2Zyb250ZW5kLmMKKysrIGIvaHcveGVuL3hlbl9mcm9udGVuZC5jCkBA IC00OCw3ICs0OCw3IEBAIHZvaWQgeGVuX2JlX2Zyb250ZW5kX2NoYW5nZWQoc3RydWN0IFhlbkRl dmljZSAqeGVuZGV2LCBjb25zdCBjaGFyICpub2RlKQogICAgICAgICAgICAgZmVfc3RhdGUgPSBY ZW5idXNTdGF0ZVVua25vd247CiAgICAgICAgIH0KICAgICAgICAgaWYgKHhlbmRldi0+ZmVfc3Rh dGUgIT0gZmVfc3RhdGUpIHsKLSAgICAgICAgICAgIHhlbl9iZV9wcmludGYoeGVuZGV2LCAxLCAi ZnJvbnRlbmQgc3RhdGU6ICVzIC0+ICVzXG4iLAorICAgICAgICAgICAgeGVuX3B2X3ByaW50Zih4 ZW5kZXYsIDEsICJmcm9udGVuZCBzdGF0ZTogJXMgLT4gJXNcbiIsCiAgICAgICAgICAgICAgICAg ICAgICAgICAgIHhlbmJ1c19zdHJzdGF0ZSh4ZW5kZXYtPmZlX3N0YXRlKSwKICAgICAgICAgICAg ICAgICAgICAgICAgICAgeGVuYnVzX3N0cnN0YXRlKGZlX3N0YXRlKSk7CiAgICAgICAgIH0KQEAg LTU4LDEzICs1OCwxMyBAQCB2b2lkIHhlbl9iZV9mcm9udGVuZF9jaGFuZ2VkKHN0cnVjdCBYZW5E ZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAqbm9kZSkKICAgICAgICAgZ19mcmVlKHhlbmRldi0+ cHJvdG9jb2wpOwogICAgICAgICB4ZW5kZXYtPnByb3RvY29sID0geGVuc3RvcmVfcmVhZF9mZV9z dHIoeGVuZGV2LCAicHJvdG9jb2wiKTsKICAgICAgICAgaWYgKHhlbmRldi0+cHJvdG9jb2wpIHsK LSAgICAgICAgICAgIHhlbl9iZV9wcmludGYoeGVuZGV2LCAxLCAiZnJvbnRlbmQgcHJvdG9jb2w6 ICVzXG4iLAorICAgICAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDEsICJmcm9udGVuZCBw cm90b2NvbDogJXNcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB4ZW5kZXYtPnByb3RvY29sKTsKICAgICAgICAgfQogICAgIH0KIAogICAgIGlmIChu b2RlKSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoeGVuZGV2LCAyLCAiZnJvbnRlbmQgdXBkYXRl OiAlc1xuIiwgbm9kZSk7CisgICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAyLCAiZnJvbnRl bmQgdXBkYXRlOiAlc1xuIiwgbm9kZSk7CiAgICAgICAgIGlmICh4ZW5kZXYtPm9wcy0+ZnJvbnRl bmRfY2hhbmdlZCkgewogICAgICAgICAgICAgeGVuZGV2LT5vcHMtPmZyb250ZW5kX2NoYW5nZWQo eGVuZGV2LCBub2RlKTsKICAgICAgICAgfQpkaWZmIC0tZ2l0IGEvaHcveGVuL3hlbl9wdmRldi5j IGIvaHcveGVuL3hlbl9wdmRldi5jCmluZGV4IDZjOTI2MjQuLjE1YmY5NWMgMTAwNjQ0Ci0tLSBh L2h3L3hlbi94ZW5fcHZkZXYuYworKysgYi9ody94ZW4veGVuX3B2ZGV2LmMKQEAgLTY5LDEzICs2 OSwxMyBAQCBpbnQgeGVuc3RvcmVfbWtkaXIoY2hhciAqcGF0aCwgaW50IHApCiAgICAgfTsKIAog ICAgIGlmICgheHNfbWtkaXIoeGVuc3RvcmUsIDAsIHBhdGgpKSB7Ci0gICAgICAgIHhlbl9iZV9w cmludGYoTlVMTCwgMCwgInhzX21rZGlyICVzOiBmYWlsZWRcbiIsIHBhdGgpOworICAgICAgICB4 ZW5fcHZfcHJpbnRmKE5VTEwsIDAsICJ4c19ta2RpciAlczogZmFpbGVkXG4iLCBwYXRoKTsKICAg ICAgICAgcmV0dXJuIC0xOwogICAgIH0KICAgICB4ZW5zdG9yZV9jbGVhbnVwX2RpcihnX3N0cmR1 cChwYXRoKSk7CiAKICAgICBpZiAoIXhzX3NldF9wZXJtaXNzaW9ucyh4ZW5zdG9yZSwgMCwgcGF0 aCwgcGVybXMsIDIpKSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoTlVMTCwgMCwgInhzX3NldF9w ZXJtaXNzaW9ucyAlczogZmFpbGVkXG4iLCBwYXRoKTsKKyAgICAgICAgeGVuX3B2X3ByaW50ZihO VUxMLCAwLCAieHNfc2V0X3Blcm1pc3Npb25zICVzOiBmYWlsZWRcbiIsIHBhdGgpOwogICAgICAg ICByZXR1cm4gLTE7CiAgICAgfQogICAgIHJldHVybiAwOwpAQCAtMTk1LDcgKzE5NSw3IEBAIGNv bnN0IGNoYXIgKnhlbmJ1c19zdHJzdGF0ZShlbnVtIHhlbmJ1c19zdGF0ZSBzdGF0ZSkKICAqICAy ID09IG5vaXN5IGRlYnVnIG1lc3NhZ2VzIChsb2dmaWxlIG9ubHkpLgogICogIDMgPT0gd2lsbCBm bG9vZCB5b3VyIGxvZyAobG9nZmlsZSBvbmx5KS4KICAqLwotdm9pZCB4ZW5fYmVfcHJpbnRmKHN0 cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgaW50IG1zZ19sZXZlbCwKK3ZvaWQgeGVuX3B2X3ByaW50 ZihzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIGludCBtc2dfbGV2ZWwsCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqZm10LCAuLi4pCiB7CiAgICAg dmFfbGlzdCBhcmdzOwpAQCAtMjM1LDcgKzIzNSw3IEBAIHZvaWQgeGVuX2JlX2V2dGNobl9ldmVu dCh2b2lkICpvcGFxdWUpCiAKICAgICBwb3J0ID0geGVuZXZ0Y2huX3BlbmRpbmcoeGVuZGV2LT5l dnRjaG5kZXYpOwogICAgIGlmIChwb3J0ICE9IHhlbmRldi0+bG9jYWxfcG9ydCkgewotICAgICAg ICB4ZW5fYmVfcHJpbnRmKHhlbmRldiwgMCwKKyAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYs IDAsCiAgICAgICAgICAgICAgICAgICAgICAgInhlbmV2dGNobl9wZW5kaW5nIHJldHVybmVkICVk IChleHBlY3RlZCAlZClcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgcG9ydCwgeGVuZGV2LT5s b2NhbF9wb3J0KTsKICAgICAgICAgcmV0dXJuOwpAQCAtMjU0LDcgKzI1NCw3IEBAIHZvaWQgeGVu X2JlX3VuYmluZF9ldnRjaG4oc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAgIH0KICAgICBx ZW11X3NldF9mZF9oYW5kbGVyKHhlbmV2dGNobl9mZCh4ZW5kZXYtPmV2dGNobmRldiksIE5VTEws IE5VTEwsIE5VTEwpOwogICAgIHhlbmV2dGNobl91bmJpbmQoeGVuZGV2LT5ldnRjaG5kZXYsIHhl bmRldi0+bG9jYWxfcG9ydCk7Ci0gICAgeGVuX2JlX3ByaW50Zih4ZW5kZXYsIDIsICJ1bmJpbmQg ZXZ0Y2huIHBvcnQgJWRcbiIsIHhlbmRldi0+bG9jYWxfcG9ydCk7CisgICAgeGVuX3B2X3ByaW50 Zih4ZW5kZXYsIDIsICJ1bmJpbmQgZXZ0Y2huIHBvcnQgJWRcbiIsIHhlbmRldi0+bG9jYWxfcG9y dCk7CiAgICAgeGVuZGV2LT5sb2NhbF9wb3J0ID0gLTE7CiB9CiAKZGlmZiAtLWdpdCBhL2luY2x1 ZGUvaHcveGVuL3hlbl9wdmRldi5oIGIvaW5jbHVkZS9ody94ZW4veGVuX3B2ZGV2LmgKaW5kZXgg MzM3NDU3ZS4uY2YyNmNlNSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9ody94ZW4veGVuX3B2ZGV2LmgK KysrIGIvaW5jbHVkZS9ody94ZW4veGVuX3B2ZGV2LmgKQEAgLTcyLDcgKzcyLDcgQEAgc3RydWN0 IFhlbkRldmljZSAqeGVuX2JlX2ZpbmRfeGVuZGV2KGNvbnN0IGNoYXIgKnR5cGUsIGludCBkb20s IGludCBkZXYpOwogdm9pZCB4ZW5fYmVfdW5iaW5kX2V2dGNobihzdHJ1Y3QgWGVuRGV2aWNlICp4 ZW5kZXYpOwogaW50IHhlbl9iZV9zZW5kX25vdGlmeShzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYp OwogCi12b2lkIHhlbl9iZV9wcmludGYoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LCBpbnQgbXNn X2xldmVsLAordm9pZCB4ZW5fcHZfcHJpbnRmKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgaW50 IG1zZ19sZXZlbCwKICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICpmbXQsIC4uLikgIEdDQ19G TVRfQVRUUigzLCA0KTsKIAogI2VuZGlmIC8qIFFFTVVfSFdfWEVOX1BWREVWX0ggKi8KZGlmZiAt LWdpdCBhL3hlbi1jb21tb24uYyBiL3hlbi1jb21tb24uYwppbmRleCBlNjQxYWQxLi45MDk5NzYw IDEwMDY0NAotLS0gYS94ZW4tY29tbW9uLmMKKysrIGIveGVuLWNvbW1vbi5jCkBAIC0xMTYsMTIg KzExNiwxMiBAQCBzdGF0aWMgaW50IHhlbl9pbml0KE1hY2hpbmVTdGF0ZSAqbXMpCiB7CiAgICAg eGVuX3hjID0geGNfaW50ZXJmYWNlX29wZW4oMCwgMCwgMCk7CiAgICAgaWYgKHhlbl94YyA9PSBO VUxMKSB7Ci0gICAgICAgIHhlbl9iZV9wcmludGYoTlVMTCwgMCwgImNhbid0IG9wZW4geGVuIGlu dGVyZmFjZVxuIik7CisgICAgICAgIHhlbl9wdl9wcmludGYoTlVMTCwgMCwgImNhbid0IG9wZW4g eGVuIGludGVyZmFjZVxuIik7CiAgICAgICAgIHJldHVybiAtMTsKICAgICB9CiAgICAgeGVuX2Zt ZW0gPSB4ZW5mb3JlaWdubWVtb3J5X29wZW4oMCwgMCk7CiAgICAgaWYgKHhlbl9mbWVtID09IE5V TEwpIHsKLSAgICAgICAgeGVuX2JlX3ByaW50ZihOVUxMLCAwLCAiY2FuJ3Qgb3BlbiB4ZW4gZm1l bSBpbnRlcmZhY2VcbiIpOworICAgICAgICB4ZW5fcHZfcHJpbnRmKE5VTEwsIDAsICJjYW4ndCBv cGVuIHhlbiBmbWVtIGludGVyZmFjZVxuIik7CiAgICAgICAgIHhjX2ludGVyZmFjZV9jbG9zZSh4 ZW5feGMpOwogICAgICAgICByZXR1cm4gLTE7CiAgICAgfQotLSAKMS45LjEKCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBs aXN0Clhlbi1kZXZlbEBsaXN0cy54ZW4ub3JnCmh0dHBzOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2 ZWwK