From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 02411C282DD for ; Fri, 10 Jan 2020 19:49:54 +0000 (UTC) Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id BA80D205F4 for ; Fri, 10 Jan 2020 19:49:53 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org BA80D205F4 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=virtuozzo.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Received: from localhost ([::1]:51094 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iq0I4-0002pB-T9 for qemu-devel@archiver.kernel.org; Fri, 10 Jan 2020 14:49:52 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:44657) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iq0At-0001oY-0q for qemu-devel@nongnu.org; Fri, 10 Jan 2020 14:42:30 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1iq0Am-0004zt-T5 for qemu-devel@nongnu.org; Fri, 10 Jan 2020 14:42:26 -0500 Received: from relay.sw.ru ([185.231.240.75]:53978) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1iq0Am-0004mc-8K; Fri, 10 Jan 2020 14:42:20 -0500 Received: from vovaso.qa.sw.ru ([10.94.3.0] helo=kvm.qa.sw.ru) by relay.sw.ru with esmtp (Exim 4.92.3) (envelope-from ) id 1iq0AX-0008Ob-5N; Fri, 10 Jan 2020 22:42:05 +0300 From: Vladimir Sementsov-Ogievskiy To: qemu-devel@nongnu.org Subject: [PATCH v6 11/11] xen: introduce ERRP_AUTO_PROPAGATE Date: Fri, 10 Jan 2020 22:41:58 +0300 Message-Id: <20200110194158.14190-12-vsementsov@virtuozzo.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20200110194158.14190-1-vsementsov@virtuozzo.com> References: <20200110194158.14190-1-vsementsov@virtuozzo.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-detected-operating-system: by eggs.gnu.org: GNU/Linux 3.x [fuzzy] X-Received-From: 185.231.240.75 X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , Vladimir Sementsov-Ogievskiy , qemu-block@nongnu.org, Paul Durrant , Greg Kurz , Max Reitz , Stefano Stabellini , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org Errors-To: qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Sender: "Qemu-devel" If we want to add some info to errp (by error_prepend() or error_append_hint()), we must use the ERRP_AUTO_PROPAGATE macro. Otherwise, this info will not be added when errp == &error_fatal (the program will exit prior to the error_append_hint() or error_prepend() call). Fix such cases. If we want to check error after errp-function call, we need to introduce local_err and then propagate it to errp. Instead, use ERRP_AUTO_PROPAGATE macro, benefits are: 1. No need of explicit error_propagate call 2. No need of explicit local_err variable: use errp directly 3. ERRP_AUTO_PROPAGATE leaves errp as is if it's not NULL or &error_fatal, this means that we don't break error_abort (we'll abort on error_set, not on error_propagate) This commit is generated by command sed -n '/^X86 Xen CPUs$/,/^$/{s/^F: //p}' MAINTAINERS | \ xargs git ls-files | grep '\.[hc]$' | \ xargs spatch \ --sp-file scripts/coccinelle/auto-propagated-errp.cocci \ --macro-file scripts/cocci-macro-file.h \ --in-place --no-show-diff --max-width 80 Reported-by: Kevin Wolf Reported-by: Greg Kurz Signed-off-by: Vladimir Sementsov-Ogievskiy --- hw/block/dataplane/xen-block.c | 17 ++--- hw/block/xen-block.c | 125 ++++++++++++++------------------- hw/pci-host/xen_igd_pt.c | 7 +- hw/xen/xen-backend.c | 7 +- hw/xen/xen-bus.c | 100 ++++++++++++-------------- hw/xen/xen-host-pci-device.c | 27 ++++--- hw/xen/xen_pt.c | 25 +++---- hw/xen/xen_pt_config_init.c | 20 +++--- 8 files changed, 142 insertions(+), 186 deletions(-) diff --git a/hw/block/dataplane/xen-block.c b/hw/block/dataplane/xen-block.c index 3b9caeb2fa..c38e3c3d85 100644 --- a/hw/block/dataplane/xen-block.c +++ b/hw/block/dataplane/xen-block.c @@ -727,8 +727,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, unsigned int protocol, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenDevice *xendev = dataplane->xendev; - Error *local_err = NULL; unsigned int ring_size; unsigned int i; @@ -764,9 +764,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, } xen_device_set_max_grant_refs(xendev, dataplane->nr_ring_ref, - &local_err); - if (local_err) { - error_propagate(errp, local_err); + errp); + if (*errp) { goto stop; } @@ -774,9 +773,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, dataplane->ring_ref, dataplane->nr_ring_ref, PROT_READ | PROT_WRITE, - &local_err); - if (local_err) { - error_propagate(errp, local_err); + errp); + if (*errp) { goto stop; } @@ -809,9 +807,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, dataplane->event_channel = xen_device_bind_event_channel(xendev, dataplane->ctx, event_channel, xen_block_dataplane_event, dataplane, - &local_err); - if (local_err) { - error_propagate(errp, local_err); + errp); + if (*errp) { goto stop; } diff --git a/hw/block/xen-block.c b/hw/block/xen-block.c index 879fc310a4..70428f5a79 100644 --- a/hw/block/xen-block.c +++ b/hw/block/xen-block.c @@ -194,6 +194,7 @@ static const BlockDevOps xen_block_dev_ops = { static void xen_block_realize(XenDevice *xendev, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev); XenBlockDeviceClass *blockdev_class = XEN_BLOCK_DEVICE_GET_CLASS(xendev); @@ -201,7 +202,6 @@ static void xen_block_realize(XenDevice *xendev, Error **errp) XenBlockVdev *vdev = &blockdev->props.vdev; BlockConf *conf = &blockdev->props.conf; BlockBackend *blk = conf->blk; - Error *local_err = NULL; if (vdev->type == XEN_BLOCK_VDEV_TYPE_INVALID) { error_setg(errp, "vdev property not set"); @@ -211,9 +211,8 @@ static void xen_block_realize(XenDevice *xendev, Error **errp) trace_xen_block_realize(type, vdev->disk, vdev->partition); if (blockdev_class->realize) { - blockdev_class->realize(blockdev, &local_err); - if (local_err) { - error_propagate(errp, local_err); + blockdev_class->realize(blockdev, errp); + if (*errp) { return; } } @@ -283,8 +282,8 @@ static void xen_block_frontend_changed(XenDevice *xendev, enum xenbus_state frontend_state, Error **errp) { + ERRP_AUTO_PROPAGATE(); enum xenbus_state backend_state = xen_device_backend_get_state(xendev); - Error *local_err = NULL; switch (frontend_state) { case XenbusStateInitialised: @@ -293,15 +292,13 @@ static void xen_block_frontend_changed(XenDevice *xendev, break; } - xen_block_disconnect(xendev, &local_err); - if (local_err) { - error_propagate(errp, local_err); + xen_block_disconnect(xendev, errp); + if (*errp) { break; } - xen_block_connect(xendev, &local_err); - if (local_err) { - error_propagate(errp, local_err); + xen_block_connect(xendev, errp); + if (*errp) { break; } @@ -314,9 +311,8 @@ static void xen_block_frontend_changed(XenDevice *xendev, case XenbusStateClosed: case XenbusStateUnknown: - xen_block_disconnect(xendev, &local_err); - if (local_err) { - error_propagate(errp, local_err); + xen_block_disconnect(xendev, errp); + if (*errp) { break; } @@ -403,10 +399,10 @@ static int vbd_name_to_disk(const char *name, const char **endp, static void xen_block_set_vdev(Object *obj, Visitor *v, const char *name, void *opaque, Error **errp) { + ERRP_AUTO_PROPAGATE(); DeviceState *dev = DEVICE(obj); Property *prop = opaque; XenBlockVdev *vdev = qdev_get_prop_ptr(dev, prop); - Error *local_err = NULL; char *str, *p; const char *end; @@ -415,9 +411,8 @@ static void xen_block_set_vdev(Object *obj, Visitor *v, const char *name, return; } - visit_type_str(v, name, &str, &local_err); - if (local_err) { - error_propagate(errp, local_err); + visit_type_str(v, name, &str, errp); + if (*errp) { return; } @@ -671,9 +666,9 @@ static void xen_block_blockdev_del(const char *node_name, Error **errp) static char *xen_block_blockdev_add(const char *id, QDict *qdict, Error **errp) { + ERRP_AUTO_PROPAGATE(); const char *driver = qdict_get_try_str(qdict, "driver"); BlockdevOptions *options = NULL; - Error *local_err = NULL; char *node_name; Visitor *v; @@ -688,18 +683,16 @@ static char *xen_block_blockdev_add(const char *id, QDict *qdict, trace_xen_block_blockdev_add(node_name); v = qobject_input_visitor_new(QOBJECT(qdict)); - visit_type_BlockdevOptions(v, NULL, &options, &local_err); + visit_type_BlockdevOptions(v, NULL, &options, errp); visit_free(v); - if (local_err) { - error_propagate(errp, local_err); + if (*errp) { goto fail; } - qmp_blockdev_add(options, &local_err); + qmp_blockdev_add(options, errp); - if (local_err) { - error_propagate(errp, local_err); + if (*errp) { goto fail; } @@ -718,14 +711,12 @@ fail: static void xen_block_drive_destroy(XenBlockDrive *drive, Error **errp) { + ERRP_AUTO_PROPAGATE(); char *node_name = drive->node_name; if (node_name) { - Error *local_err = NULL; - - xen_block_blockdev_del(node_name, &local_err); - if (local_err) { - error_propagate(errp, local_err); + xen_block_blockdev_del(node_name, errp); + if (*errp) { return; } g_free(node_name); @@ -739,6 +730,7 @@ static XenBlockDrive *xen_block_drive_create(const char *id, const char *device_type, QDict *opts, Error **errp) { + ERRP_AUTO_PROPAGATE(); const char *params = qdict_get_try_str(opts, "params"); const char *mode = qdict_get_try_str(opts, "mode"); const char *direct_io_safe = qdict_get_try_str(opts, "direct-io-safe"); @@ -746,7 +738,6 @@ static XenBlockDrive *xen_block_drive_create(const char *id, char *driver = NULL; char *filename = NULL; XenBlockDrive *drive = NULL; - Error *local_err = NULL; QDict *file_layer; QDict *driver_layer; @@ -825,13 +816,12 @@ static XenBlockDrive *xen_block_drive_create(const char *id, g_assert(!drive->node_name); drive->node_name = xen_block_blockdev_add(drive->id, driver_layer, - &local_err); + errp); qobject_unref(driver_layer); done: - if (local_err) { - error_propagate(errp, local_err); + if (*errp) { xen_block_drive_destroy(drive, NULL); return NULL; } @@ -856,15 +846,13 @@ static void xen_block_iothread_destroy(XenBlockIOThread *iothread, static XenBlockIOThread *xen_block_iothread_create(const char *id, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenBlockIOThread *iothread = g_new(XenBlockIOThread, 1); - Error *local_err = NULL; iothread->id = g_strdup(id); - qmp_object_add(TYPE_IOTHREAD, id, false, NULL, &local_err); - if (local_err) { - error_propagate(errp, local_err); - + qmp_object_add(TYPE_IOTHREAD, id, false, NULL, errp); + if (*errp) { g_free(iothread->id); g_free(iothread); return NULL; @@ -876,6 +864,7 @@ static XenBlockIOThread *xen_block_iothread_create(const char *id, static void xen_block_device_create(XenBackendInstance *backend, QDict *opts, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenBus *xenbus = xen_backend_get_bus(backend); const char *name = xen_backend_get_name(backend); unsigned long number; @@ -883,7 +872,6 @@ static void xen_block_device_create(XenBackendInstance *backend, XenBlockDrive *drive = NULL; XenBlockIOThread *iothread = NULL; XenDevice *xendev = NULL; - Error *local_err = NULL; const char *type; XenBlockDevice *blockdev; @@ -915,52 +903,48 @@ static void xen_block_device_create(XenBackendInstance *backend, goto fail; } - drive = xen_block_drive_create(vdev, device_type, opts, &local_err); + drive = xen_block_drive_create(vdev, device_type, opts, errp); if (!drive) { - error_propagate_prepend(errp, local_err, "failed to create drive: "); + error_prepend(errp, "failed to create drive: "); goto fail; } - iothread = xen_block_iothread_create(vdev, &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, - "failed to create iothread: "); + iothread = xen_block_iothread_create(vdev, errp); + if (*errp) { + error_prepend(errp, "failed to create iothread: "); goto fail; } xendev = XEN_DEVICE(qdev_create(BUS(xenbus), type)); blockdev = XEN_BLOCK_DEVICE(xendev); - object_property_set_str(OBJECT(xendev), vdev, "vdev", &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, "failed to set 'vdev': "); + object_property_set_str(OBJECT(xendev), vdev, "vdev", errp); + if (*errp) { + error_prepend(errp, "failed to set 'vdev': "); goto fail; } object_property_set_str(OBJECT(xendev), xen_block_drive_get_node_name(drive), "drive", - &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, "failed to set 'drive': "); + errp); + if (*errp) { + error_prepend(errp, "failed to set 'drive': "); goto fail; } object_property_set_str(OBJECT(xendev), iothread->id, "iothread", - &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, - "failed to set 'iothread': "); + errp); + if (*errp) { + error_prepend(errp, "failed to set 'iothread': "); goto fail; } blockdev->iothread = iothread; blockdev->drive = drive; - object_property_set_bool(OBJECT(xendev), true, "realized", &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, - "realization of device %s failed: ", - type); + object_property_set_bool(OBJECT(xendev), true, "realized", errp); + if (*errp) { + error_prepend(errp, "realization of device %s failed: ", type); goto fail; } @@ -984,6 +968,7 @@ fail: static void xen_block_device_destroy(XenBackendInstance *backend, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenDevice *xendev = xen_backend_get_device(backend); XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev); XenBlockVdev *vdev = &blockdev->props.vdev; @@ -995,23 +980,17 @@ static void xen_block_device_destroy(XenBackendInstance *backend, object_unparent(OBJECT(xendev)); if (iothread) { - Error *local_err = NULL; - - xen_block_iothread_destroy(iothread, &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, - "failed to destroy iothread: "); + xen_block_iothread_destroy(iothread, errp); + if (*errp) { + error_prepend(errp, "failed to destroy iothread: "); return; } } if (drive) { - Error *local_err = NULL; - - xen_block_drive_destroy(drive, &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, - "failed to destroy drive: "); + xen_block_drive_destroy(drive, errp); + if (*errp) { + error_prepend(errp, "failed to destroy drive: "); } } } diff --git a/hw/pci-host/xen_igd_pt.c b/hw/pci-host/xen_igd_pt.c index efcc9347ff..29ade9ca25 100644 --- a/hw/pci-host/xen_igd_pt.c +++ b/hw/pci-host/xen_igd_pt.c @@ -79,17 +79,16 @@ static void host_pci_config_read(int pos, int len, uint32_t *val, Error **errp) static void igd_pt_i440fx_realize(PCIDevice *pci_dev, Error **errp) { + ERRP_AUTO_PROPAGATE(); uint32_t val = 0; size_t i; int pos, len; - Error *local_err = NULL; for (i = 0; i < ARRAY_SIZE(igd_host_bridge_infos); i++) { pos = igd_host_bridge_infos[i].offset; len = igd_host_bridge_infos[i].len; - host_pci_config_read(pos, len, &val, &local_err); - if (local_err) { - error_propagate(errp, local_err); + host_pci_config_read(pos, len, &val, errp); + if (*errp) { return; } pci_default_write_config(pci_dev, pos, val, len); diff --git a/hw/xen/xen-backend.c b/hw/xen/xen-backend.c index da065f81b7..1cc0694053 100644 --- a/hw/xen/xen-backend.c +++ b/hw/xen/xen-backend.c @@ -98,9 +98,9 @@ static void xen_backend_list_remove(XenBackendInstance *backend) void xen_backend_device_create(XenBus *xenbus, const char *type, const char *name, QDict *opts, Error **errp) { + ERRP_AUTO_PROPAGATE(); const XenBackendImpl *impl = xen_backend_table_lookup(type); XenBackendInstance *backend; - Error *local_error = NULL; if (!impl) { return; @@ -110,9 +110,8 @@ void xen_backend_device_create(XenBus *xenbus, const char *type, backend->xenbus = xenbus; backend->name = g_strdup(name); - impl->create(backend, opts, &local_error); - if (local_error) { - error_propagate(errp, local_error); + impl->create(backend, opts, errp); + if (*errp) { g_free(backend->name); g_free(backend); return; diff --git a/hw/xen/xen-bus.c b/hw/xen/xen-bus.c index c2ad22a42d..270ee31aa5 100644 --- a/hw/xen/xen-bus.c +++ b/hw/xen/xen-bus.c @@ -53,9 +53,9 @@ static char *xen_device_get_frontend_path(XenDevice *xendev) static void xen_device_unplug(XenDevice *xendev, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); const char *type = object_get_typename(OBJECT(xendev)); - Error *local_err = NULL; xs_transaction_t tid; trace_xen_device_unplug(type, xendev->name); @@ -69,14 +69,14 @@ again: } xs_node_printf(xenbus->xsh, tid, xendev->backend_path, "online", - &local_err, "%u", 0); - if (local_err) { + errp, "%u", 0); + if (*errp) { goto abort; } xs_node_printf(xenbus->xsh, tid, xendev->backend_path, "state", - &local_err, "%u", XenbusStateClosing); - if (local_err) { + errp, "%u", XenbusStateClosing); + if (*errp) { goto abort; } @@ -96,7 +96,6 @@ abort: * from ending the transaction. */ xs_transaction_end(xenbus->xsh, tid, true); - error_propagate(errp, local_err); } static void xen_bus_print_dev(Monitor *mon, DeviceState *dev, int indent) @@ -205,15 +204,13 @@ static XenWatch *watch_list_add(XenWatchList *watch_list, const char *node, const char *key, XenWatchHandler handler, void *opaque, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenWatch *watch = new_watch(node, key, handler, opaque); - Error *local_err = NULL; notifier_list_add(&watch_list->notifiers, &watch->notifier); - xs_node_watch(watch_list->xsh, node, key, watch->token, &local_err); - if (local_err) { - error_propagate(errp, local_err); - + xs_node_watch(watch_list->xsh, node, key, watch->token, errp); + if (*errp) { notifier_remove(&watch->notifier); free_watch(watch); @@ -255,11 +252,11 @@ static void xen_bus_backend_create(XenBus *xenbus, const char *type, const char *name, char *path, Error **errp) { + ERRP_AUTO_PROPAGATE(); xs_transaction_t tid; char **key; QDict *opts; unsigned int i, n; - Error *local_err = NULL; trace_xen_bus_backend_create(type, path); @@ -314,13 +311,11 @@ again: return; } - xen_backend_device_create(xenbus, type, name, opts, &local_err); + xen_backend_device_create(xenbus, type, name, opts, errp); qobject_unref(opts); - if (local_err) { - error_propagate_prepend(errp, local_err, - "failed to create '%s' device '%s': ", - type, name); + if (*errp) { + error_prepend(errp, "failed to create '%s' device '%s': ", type, name); } } @@ -451,9 +446,9 @@ static void xen_bus_unrealize(BusState *bus, Error **errp) static void xen_bus_realize(BusState *bus, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenBus *xenbus = XEN_BUS(bus); unsigned int domid; - Error *local_err = NULL; trace_xen_bus_realize(); @@ -476,10 +471,10 @@ static void xen_bus_realize(BusState *bus, Error **errp) xenbus->backend_watch = xen_bus_add_watch(xenbus, "", /* domain root node */ - "backend", xen_bus_backend_changed, &local_err); - if (local_err) { + "backend", xen_bus_backend_changed, errp); + if (*errp) { /* This need not be treated as a hard error so don't propagate */ - error_reportf_err(local_err, + error_reportf_err(*errp, "failed to set up enumeration watch: "); } @@ -692,9 +687,9 @@ static void xen_device_remove_watch(XenDevice *xendev, XenWatch *watch, static void xen_device_backend_create(XenDevice *xendev, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); struct xs_permissions perms[2]; - Error *local_err = NULL; xendev->backend_path = xen_device_get_backend_path(xendev); @@ -706,30 +701,27 @@ static void xen_device_backend_create(XenDevice *xendev, Error **errp) g_assert(xenbus->xsh); xs_node_create(xenbus->xsh, XBT_NULL, xendev->backend_path, perms, - ARRAY_SIZE(perms), &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, - "failed to create backend: "); + ARRAY_SIZE(perms), errp); + if (*errp) { + error_prepend(errp, "failed to create backend: "); return; } xendev->backend_state_watch = xen_device_add_watch(xendev, xendev->backend_path, "state", xen_device_backend_changed, - &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, - "failed to watch backend state: "); + errp); + if (*errp) { + error_prepend(errp, "failed to watch backend state: "); return; } xendev->backend_online_watch = xen_device_add_watch(xendev, xendev->backend_path, "online", xen_device_backend_changed, - &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, - "failed to watch backend online: "); + errp); + if (*errp) { + error_prepend(errp, "failed to watch backend online: "); return; } } @@ -866,9 +858,9 @@ static bool xen_device_frontend_exists(XenDevice *xendev) static void xen_device_frontend_create(XenDevice *xendev, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); struct xs_permissions perms[2]; - Error *local_err = NULL; xendev->frontend_path = xen_device_get_frontend_path(xendev); @@ -885,20 +877,18 @@ static void xen_device_frontend_create(XenDevice *xendev, Error **errp) g_assert(xenbus->xsh); xs_node_create(xenbus->xsh, XBT_NULL, xendev->frontend_path, perms, - ARRAY_SIZE(perms), &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, - "failed to create frontend: "); + ARRAY_SIZE(perms), errp); + if (*errp) { + error_prepend(errp, "failed to create frontend: "); return; } } xendev->frontend_state_watch = xen_device_add_watch(xendev, xendev->frontend_path, "state", - xen_device_frontend_changed, &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, - "failed to watch frontend state: "); + xen_device_frontend_changed, errp); + if (*errp) { + error_prepend(errp, "failed to watch frontend state: "); } } @@ -1228,11 +1218,11 @@ static void xen_device_exit(Notifier *n, void *data) static void xen_device_realize(DeviceState *dev, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenDevice *xendev = XEN_DEVICE(dev); XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev); XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); const char *type = object_get_typename(OBJECT(xendev)); - Error *local_err = NULL; if (xendev->frontend_id == DOMID_INVALID) { xendev->frontend_id = xen_domid; @@ -1248,10 +1238,9 @@ static void xen_device_realize(DeviceState *dev, Error **errp) goto unrealize; } - xendev->name = xendev_class->get_name(xendev, &local_err); - if (local_err) { - error_propagate_prepend(errp, local_err, - "failed to get device name: "); + xendev->name = xendev_class->get_name(xendev, errp); + if (*errp) { + error_prepend(errp, "failed to get device name: "); goto unrealize; } @@ -1274,22 +1263,19 @@ static void xen_device_realize(DeviceState *dev, Error **errp) xendev->feature_grant_copy = (xengnttab_grant_copy(xendev->xgth, 0, NULL) == 0); - xen_device_backend_create(xendev, &local_err); - if (local_err) { - error_propagate(errp, local_err); + xen_device_backend_create(xendev, errp); + if (*errp) { goto unrealize; } - xen_device_frontend_create(xendev, &local_err); - if (local_err) { - error_propagate(errp, local_err); + xen_device_frontend_create(xendev, errp); + if (*errp) { goto unrealize; } if (xendev_class->realize) { - xendev_class->realize(xendev, &local_err); - if (local_err) { - error_propagate(errp, local_err); + xendev_class->realize(xendev, errp); + if (*errp) { goto unrealize; } } diff --git a/hw/xen/xen-host-pci-device.c b/hw/xen/xen-host-pci-device.c index 1b44dcafaf..02379c341c 100644 --- a/hw/xen/xen-host-pci-device.c +++ b/hw/xen/xen-host-pci-device.c @@ -333,8 +333,8 @@ void xen_host_pci_device_get(XenHostPCIDevice *d, uint16_t domain, uint8_t bus, uint8_t dev, uint8_t func, Error **errp) { + ERRP_AUTO_PROPAGATE(); unsigned int v; - Error *err = NULL; d->config_fd = -1; d->domain = domain; @@ -342,36 +342,36 @@ void xen_host_pci_device_get(XenHostPCIDevice *d, uint16_t domain, d->dev = dev; d->func = func; - xen_host_pci_config_open(d, &err); - if (err) { + xen_host_pci_config_open(d, errp); + if (*errp) { goto error; } - xen_host_pci_get_resource(d, &err); - if (err) { + xen_host_pci_get_resource(d, errp); + if (*errp) { goto error; } - xen_host_pci_get_hex_value(d, "vendor", &v, &err); - if (err) { + xen_host_pci_get_hex_value(d, "vendor", &v, errp); + if (*errp) { goto error; } d->vendor_id = v; - xen_host_pci_get_hex_value(d, "device", &v, &err); - if (err) { + xen_host_pci_get_hex_value(d, "device", &v, errp); + if (*errp) { goto error; } d->device_id = v; - xen_host_pci_get_dec_value(d, "irq", &v, &err); - if (err) { + xen_host_pci_get_dec_value(d, "irq", &v, errp); + if (*errp) { goto error; } d->irq = v; - xen_host_pci_get_hex_value(d, "class", &v, &err); - if (err) { + xen_host_pci_get_hex_value(d, "class", &v, errp); + if (*errp) { goto error; } d->class_code = v; @@ -381,7 +381,6 @@ void xen_host_pci_device_get(XenHostPCIDevice *d, uint16_t domain, return; error: - error_propagate(errp, err); if (d->config_fd >= 0) { close(d->config_fd); diff --git a/hw/xen/xen_pt.c b/hw/xen/xen_pt.c index 9e767d4244..33b68dfcb8 100644 --- a/hw/xen/xen_pt.c +++ b/hw/xen/xen_pt.c @@ -767,12 +767,12 @@ static void xen_pt_destroy(PCIDevice *d) { static void xen_pt_realize(PCIDevice *d, Error **errp) { + ERRP_AUTO_PROPAGATE(); XenPCIPassthroughState *s = XEN_PT_DEVICE(d); int i, rc = 0; uint8_t machine_irq = 0, scratch; uint16_t cmd = 0; int pirq = XEN_PT_UNASSIGNED_PIRQ; - Error *err = NULL; /* register real device */ XEN_PT_LOG(d, "Assigning real physical device %02x:%02x.%d" @@ -783,10 +783,9 @@ static void xen_pt_realize(PCIDevice *d, Error **errp) xen_host_pci_device_get(&s->real_device, s->hostaddr.domain, s->hostaddr.bus, s->hostaddr.slot, s->hostaddr.function, - &err); - if (err) { - error_append_hint(&err, "Failed to \"open\" the real pci device"); - error_propagate(errp, err); + errp); + if (*errp) { + error_append_hint(errp, "Failed to \"open\" the real pci device"); return; } @@ -813,11 +812,10 @@ static void xen_pt_realize(PCIDevice *d, Error **errp) return; } - xen_pt_setup_vga(s, &s->real_device, &err); - if (err) { - error_append_hint(&err, "Setup VGA BIOS of passthrough" - " GFX failed"); - error_propagate(errp, err); + xen_pt_setup_vga(s, &s->real_device, errp); + if (*errp) { + error_append_hint(errp, "Setup VGA BIOS of passthrough" + " GFX failed"); xen_host_pci_device_put(&s->real_device); return; } @@ -830,10 +828,9 @@ static void xen_pt_realize(PCIDevice *d, Error **errp) xen_pt_register_regions(s, &cmd); /* reinitialize each config register to be emulated */ - xen_pt_config_init(s, &err); - if (err) { - error_append_hint(&err, "PCI Config space initialisation failed"); - error_propagate(errp, err); + xen_pt_config_init(s, errp); + if (*errp) { + error_append_hint(errp, "PCI Config space initialisation failed"); rc = -1; goto err_out; } diff --git a/hw/xen/xen_pt_config_init.c b/hw/xen/xen_pt_config_init.c index 31ec5add1d..af3fbd1bfb 100644 --- a/hw/xen/xen_pt_config_init.c +++ b/hw/xen/xen_pt_config_init.c @@ -2008,8 +2008,8 @@ static void xen_pt_config_reg_init(XenPCIPassthroughState *s, void xen_pt_config_init(XenPCIPassthroughState *s, Error **errp) { + ERRP_AUTO_PROPAGATE(); int i, rc; - Error *err = NULL; QLIST_INIT(&s->reg_grps); @@ -2052,10 +2052,9 @@ void xen_pt_config_init(XenPCIPassthroughState *s, Error **errp) reg_grp_offset, ®_grp_entry->size); if (rc < 0) { - error_setg(&err, "Failed to initialize %d/%zu, type = 0x%x," + error_setg(errp, "Failed to initialize %d/%zu, type = 0x%x," " rc: %d", i, ARRAY_SIZE(xen_pt_emu_reg_grps), xen_pt_emu_reg_grps[i].grp_type, rc); - error_propagate(errp, err); xen_pt_config_delete(s); return; } @@ -2068,13 +2067,14 @@ void xen_pt_config_init(XenPCIPassthroughState *s, Error **errp) /* initialize capability register */ for (j = 0; regs->size != 0; j++, regs++) { - xen_pt_config_reg_init(s, reg_grp_entry, regs, &err); - if (err) { - error_append_hint(&err, "Failed to init register %d" - " offsets 0x%x in grp_type = 0x%x (%d/%zu)", j, - regs->offset, xen_pt_emu_reg_grps[i].grp_type, - i, ARRAY_SIZE(xen_pt_emu_reg_grps)); - error_propagate(errp, err); + xen_pt_config_reg_init(s, reg_grp_entry, regs, errp); + if (*errp) { + error_append_hint(errp, "Failed to init register %d" + " offsets 0x%x in grp_type = 0x%x (%d/%zu)", + j, + regs->offset, + xen_pt_emu_reg_grps[i].grp_type, + i, ARRAY_SIZE(xen_pt_emu_reg_grps)); xen_pt_config_delete(s); return; } -- 2.21.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 64949C33CA5 for ; Fri, 10 Jan 2020 19:43:14 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 299CD20848 for ; Fri, 10 Jan 2020 19:43:14 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 299CD20848 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=virtuozzo.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iq0BO-0003sY-TB; Fri, 10 Jan 2020 19:42:58 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iq0BN-0003sF-O1 for xen-devel@lists.xenproject.org; Fri, 10 Jan 2020 19:42:57 +0000 X-Inumbo-ID: 58c9e574-33e1-11ea-a2eb-bc764e2007e4 Received: from relay.sw.ru (unknown [185.231.240.75]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 58c9e574-33e1-11ea-a2eb-bc764e2007e4; Fri, 10 Jan 2020 19:42:34 +0000 (UTC) Received: from vovaso.qa.sw.ru ([10.94.3.0] helo=kvm.qa.sw.ru) by relay.sw.ru with esmtp (Exim 4.92.3) (envelope-from ) id 1iq0AX-0008Ob-5N; Fri, 10 Jan 2020 22:42:05 +0300 From: Vladimir Sementsov-Ogievskiy To: qemu-devel@nongnu.org Date: Fri, 10 Jan 2020 22:41:58 +0300 Message-Id: <20200110194158.14190-12-vsementsov@virtuozzo.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20200110194158.14190-1-vsementsov@virtuozzo.com> References: <20200110194158.14190-1-vsementsov@virtuozzo.com> MIME-Version: 1.0 Subject: [Xen-devel] [PATCH v6 11/11] xen: introduce ERRP_AUTO_PROPAGATE X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Kevin Wolf , Vladimir Sementsov-Ogievskiy , qemu-block@nongnu.org, Paul Durrant , Greg Kurz , Max Reitz , Stefano Stabellini , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" SWYgd2Ugd2FudCB0byBhZGQgc29tZSBpbmZvIHRvIGVycnAgKGJ5IGVycm9yX3ByZXBlbmQoKSBv cgplcnJvcl9hcHBlbmRfaGludCgpKSwgd2UgbXVzdCB1c2UgdGhlIEVSUlBfQVVUT19QUk9QQUdB VEUgbWFjcm8uCk90aGVyd2lzZSwgdGhpcyBpbmZvIHdpbGwgbm90IGJlIGFkZGVkIHdoZW4gZXJy cCA9PSAmZXJyb3JfZmF0YWwKKHRoZSBwcm9ncmFtIHdpbGwgZXhpdCBwcmlvciB0byB0aGUgZXJy b3JfYXBwZW5kX2hpbnQoKSBvcgplcnJvcl9wcmVwZW5kKCkgY2FsbCkuICBGaXggc3VjaCBjYXNl cy4KCklmIHdlIHdhbnQgdG8gY2hlY2sgZXJyb3IgYWZ0ZXIgZXJycC1mdW5jdGlvbiBjYWxsLCB3 ZSBuZWVkIHRvCmludHJvZHVjZSBsb2NhbF9lcnIgYW5kIHRoZW4gcHJvcGFnYXRlIGl0IHRvIGVy cnAuIEluc3RlYWQsIHVzZQpFUlJQX0FVVE9fUFJPUEFHQVRFIG1hY3JvLCBiZW5lZml0cyBhcmU6 CjEuIE5vIG5lZWQgb2YgZXhwbGljaXQgZXJyb3JfcHJvcGFnYXRlIGNhbGwKMi4gTm8gbmVlZCBv ZiBleHBsaWNpdCBsb2NhbF9lcnIgdmFyaWFibGU6IHVzZSBlcnJwIGRpcmVjdGx5CjMuIEVSUlBf QVVUT19QUk9QQUdBVEUgbGVhdmVzIGVycnAgYXMgaXMgaWYgaXQncyBub3QgTlVMTCBvcgogICAm ZXJyb3JfZmF0YWwsIHRoaXMgbWVhbnMgdGhhdCB3ZSBkb24ndCBicmVhayBlcnJvcl9hYm9ydAog ICAod2UnbGwgYWJvcnQgb24gZXJyb3Jfc2V0LCBub3Qgb24gZXJyb3JfcHJvcGFnYXRlKQoKVGhp cyBjb21taXQgaXMgZ2VuZXJhdGVkIGJ5IGNvbW1hbmQKCiAgICBzZWQgLW4gJy9eWDg2IFhlbiBD UFVzJC8sL14kL3tzL15GOiAvL3B9JyBNQUlOVEFJTkVSUyB8IFwKICAgIHhhcmdzIGdpdCBscy1m aWxlcyB8IGdyZXAgJ1wuW2hjXSQnIHwgXAogICAgeGFyZ3Mgc3BhdGNoIFwKICAgICAgICAtLXNw LWZpbGUgc2NyaXB0cy9jb2NjaW5lbGxlL2F1dG8tcHJvcGFnYXRlZC1lcnJwLmNvY2NpIFwKICAg ICAgICAtLW1hY3JvLWZpbGUgc2NyaXB0cy9jb2NjaS1tYWNyby1maWxlLmggXAogICAgICAgIC0t aW4tcGxhY2UgLS1uby1zaG93LWRpZmYgLS1tYXgtd2lkdGggODAKClJlcG9ydGVkLWJ5OiBLZXZp biBXb2xmIDxrd29sZkByZWRoYXQuY29tPgpSZXBvcnRlZC1ieTogR3JlZyBLdXJ6IDxncm91Z0Br YW9kLm9yZz4KU2lnbmVkLW9mZi1ieTogVmxhZGltaXIgU2VtZW50c292LU9naWV2c2tpeSA8dnNl bWVudHNvdkB2aXJ0dW96em8uY29tPgotLS0KIGh3L2Jsb2NrL2RhdGFwbGFuZS94ZW4tYmxvY2su YyB8ICAxNyArKy0tLQogaHcvYmxvY2sveGVuLWJsb2NrLmMgICAgICAgICAgIHwgMTI1ICsrKysr KysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLQogaHcvcGNpLWhvc3QveGVuX2lnZF9wdC5jICAg ICAgIHwgICA3ICstCiBody94ZW4veGVuLWJhY2tlbmQuYyAgICAgICAgICAgfCAgIDcgKy0KIGh3 L3hlbi94ZW4tYnVzLmMgICAgICAgICAgICAgICB8IDEwMCArKysrKysrKysrKystLS0tLS0tLS0t LS0tLQogaHcveGVuL3hlbi1ob3N0LXBjaS1kZXZpY2UuYyAgIHwgIDI3ICsrKystLS0KIGh3L3hl bi94ZW5fcHQuYyAgICAgICAgICAgICAgICB8ICAyNSArKystLS0tCiBody94ZW4veGVuX3B0X2Nv bmZpZ19pbml0LmMgICAgfCAgMjAgKysrLS0tCiA4IGZpbGVzIGNoYW5nZWQsIDE0MiBpbnNlcnRp b25zKCspLCAxODYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvaHcvYmxvY2svZGF0YXBsYW5l L3hlbi1ibG9jay5jIGIvaHcvYmxvY2svZGF0YXBsYW5lL3hlbi1ibG9jay5jCmluZGV4IDNiOWNh ZWIyZmEuLmMzOGUzYzNkODUgMTAwNjQ0Ci0tLSBhL2h3L2Jsb2NrL2RhdGFwbGFuZS94ZW4tYmxv Y2suYworKysgYi9ody9ibG9jay9kYXRhcGxhbmUveGVuLWJsb2NrLmMKQEAgLTcyNyw4ICs3Mjcs OCBAQCB2b2lkIHhlbl9ibG9ja19kYXRhcGxhbmVfc3RhcnQoWGVuQmxvY2tEYXRhUGxhbmUgKmRh dGFwbGFuZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBpbnQgcHJv dG9jb2wsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRXJyb3IgKiplcnJwKQogewor ICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKICAgICBYZW5EZXZpY2UgKnhlbmRldiA9IGRhdGFw bGFuZS0+eGVuZGV2OwotICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwogICAgIHVuc2lnbmVk IGludCByaW5nX3NpemU7CiAgICAgdW5zaWduZWQgaW50IGk7CiAKQEAgLTc2NCw5ICs3NjQsOCBA QCB2b2lkIHhlbl9ibG9ja19kYXRhcGxhbmVfc3RhcnQoWGVuQmxvY2tEYXRhUGxhbmUgKmRhdGFw bGFuZSwKICAgICB9CiAKICAgICB4ZW5fZGV2aWNlX3NldF9tYXhfZ3JhbnRfcmVmcyh4ZW5kZXYs IGRhdGFwbGFuZS0+bnJfcmluZ19yZWYsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgJmxvY2FsX2Vycik7Ci0gICAgaWYgKGxvY2FsX2VycikgewotICAgICAgICBlcnJvcl9wcm9w YWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBlcnJwKTsKKyAgICBpZiAoKmVycnApIHsKICAgICAgICAgZ290byBzdG9wOwogICAgIH0KIApA QCAtNzc0LDkgKzc3Myw4IEBAIHZvaWQgeGVuX2Jsb2NrX2RhdGFwbGFuZV9zdGFydChYZW5CbG9j a0RhdGFQbGFuZSAqZGF0YXBsYW5lLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGRhdGFwbGFuZS0+cmluZ19yZWYsCiAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgZGF0YXBsYW5lLT5ucl9yaW5nX3JlZiwKICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQUk9UX1JFQUQgfCBQUk9UX1dS SVRFLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZsb2Nh bF9lcnIpOwotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVy cnAsIGxvY2FsX2Vycik7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgZXJycCk7CisgICAgaWYgKCplcnJwKSB7CiAgICAgICAgIGdvdG8gc3RvcDsKICAgICB9 CiAKQEAgLTgwOSw5ICs4MDcsOCBAQCB2b2lkIHhlbl9ibG9ja19kYXRhcGxhbmVfc3RhcnQoWGVu QmxvY2tEYXRhUGxhbmUgKmRhdGFwbGFuZSwKICAgICBkYXRhcGxhbmUtPmV2ZW50X2NoYW5uZWwg PQogICAgICAgICB4ZW5fZGV2aWNlX2JpbmRfZXZlbnRfY2hhbm5lbCh4ZW5kZXYsIGRhdGFwbGFu ZS0+Y3R4LCBldmVudF9jaGFubmVsLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB4ZW5fYmxvY2tfZGF0YXBsYW5lX2V2ZW50LCBkYXRhcGxhbmUsCi0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICZsb2NhbF9lcnIpOwotICAgIGlmIChsb2NhbF9lcnIp IHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7CisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVycnApOworICAgIGlmICgqZXJycCkgewogICAg ICAgICBnb3RvIHN0b3A7CiAgICAgfQogCmRpZmYgLS1naXQgYS9ody9ibG9jay94ZW4tYmxvY2su YyBiL2h3L2Jsb2NrL3hlbi1ibG9jay5jCmluZGV4IDg3OWZjMzEwYTQuLjcwNDI4ZjVhNzkgMTAw NjQ0Ci0tLSBhL2h3L2Jsb2NrL3hlbi1ibG9jay5jCisrKyBiL2h3L2Jsb2NrL3hlbi1ibG9jay5j CkBAIC0xOTQsNiArMTk0LDcgQEAgc3RhdGljIGNvbnN0IEJsb2NrRGV2T3BzIHhlbl9ibG9ja19k ZXZfb3BzID0gewogCiBzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfcmVhbGl6ZShYZW5EZXZpY2UgKnhl bmRldiwgRXJyb3IgKiplcnJwKQogeworICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKICAgICBY ZW5CbG9ja0RldmljZSAqYmxvY2tkZXYgPSBYRU5fQkxPQ0tfREVWSUNFKHhlbmRldik7CiAgICAg WGVuQmxvY2tEZXZpY2VDbGFzcyAqYmxvY2tkZXZfY2xhc3MgPQogICAgICAgICBYRU5fQkxPQ0tf REVWSUNFX0dFVF9DTEFTUyh4ZW5kZXYpOwpAQCAtMjAxLDcgKzIwMiw2IEBAIHN0YXRpYyB2b2lk IHhlbl9ibG9ja19yZWFsaXplKFhlbkRldmljZSAqeGVuZGV2LCBFcnJvciAqKmVycnApCiAgICAg WGVuQmxvY2tWZGV2ICp2ZGV2ID0gJmJsb2NrZGV2LT5wcm9wcy52ZGV2OwogICAgIEJsb2NrQ29u ZiAqY29uZiA9ICZibG9ja2Rldi0+cHJvcHMuY29uZjsKICAgICBCbG9ja0JhY2tlbmQgKmJsayA9 IGNvbmYtPmJsazsKLSAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKIAogICAgIGlmICh2ZGV2 LT50eXBlID09IFhFTl9CTE9DS19WREVWX1RZUEVfSU5WQUxJRCkgewogICAgICAgICBlcnJvcl9z ZXRnKGVycnAsICJ2ZGV2IHByb3BlcnR5IG5vdCBzZXQiKTsKQEAgLTIxMSw5ICsyMTEsOCBAQCBz dGF0aWMgdm9pZCB4ZW5fYmxvY2tfcmVhbGl6ZShYZW5EZXZpY2UgKnhlbmRldiwgRXJyb3IgKipl cnJwKQogICAgIHRyYWNlX3hlbl9ibG9ja19yZWFsaXplKHR5cGUsIHZkZXYtPmRpc2ssIHZkZXYt PnBhcnRpdGlvbik7CiAKICAgICBpZiAoYmxvY2tkZXZfY2xhc3MtPnJlYWxpemUpIHsKLSAgICAg ICAgYmxvY2tkZXZfY2xhc3MtPnJlYWxpemUoYmxvY2tkZXYsICZsb2NhbF9lcnIpOwotICAgICAg ICBpZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9j YWxfZXJyKTsKKyAgICAgICAgYmxvY2tkZXZfY2xhc3MtPnJlYWxpemUoYmxvY2tkZXYsIGVycnAp OworICAgICAgICBpZiAoKmVycnApIHsKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQog ICAgIH0KQEAgLTI4Myw4ICsyODIsOCBAQCBzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfZnJvbnRlbmRf Y2hhbmdlZChYZW5EZXZpY2UgKnhlbmRldiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGVudW0geGVuYnVzX3N0YXRlIGZyb250ZW5kX3N0YXRlLAogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgRXJyb3IgKiplcnJwKQogeworICAgIEVSUlBfQVVU T19QUk9QQUdBVEUoKTsKICAgICBlbnVtIHhlbmJ1c19zdGF0ZSBiYWNrZW5kX3N0YXRlID0geGVu X2RldmljZV9iYWNrZW5kX2dldF9zdGF0ZSh4ZW5kZXYpOwotICAgIEVycm9yICpsb2NhbF9lcnIg PSBOVUxMOwogCiAgICAgc3dpdGNoIChmcm9udGVuZF9zdGF0ZSkgewogICAgIGNhc2UgWGVuYnVz U3RhdGVJbml0aWFsaXNlZDoKQEAgLTI5MywxNSArMjkyLDEzIEBAIHN0YXRpYyB2b2lkIHhlbl9i bG9ja19mcm9udGVuZF9jaGFuZ2VkKFhlbkRldmljZSAqeGVuZGV2LAogICAgICAgICAgICAgYnJl YWs7CiAgICAgICAgIH0KIAotICAgICAgICB4ZW5fYmxvY2tfZGlzY29ubmVjdCh4ZW5kZXYsICZs b2NhbF9lcnIpOwotICAgICAgICBpZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgICAgICBlcnJvcl9w cm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKKyAgICAgICAgeGVuX2Jsb2NrX2Rpc2Nvbm5lY3Qo eGVuZGV2LCBlcnJwKTsKKyAgICAgICAgaWYgKCplcnJwKSB7CiAgICAgICAgICAgICBicmVhazsK ICAgICAgICAgfQogCi0gICAgICAgIHhlbl9ibG9ja19jb25uZWN0KHhlbmRldiwgJmxvY2FsX2Vy cik7Ci0gICAgICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgICAgIGVycm9yX3Byb3BhZ2F0 ZShlcnJwLCBsb2NhbF9lcnIpOworICAgICAgICB4ZW5fYmxvY2tfY29ubmVjdCh4ZW5kZXYsIGVy cnApOworICAgICAgICBpZiAoKmVycnApIHsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9 CiAKQEAgLTMxNCw5ICszMTEsOCBAQCBzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfZnJvbnRlbmRfY2hh bmdlZChYZW5EZXZpY2UgKnhlbmRldiwKIAogICAgIGNhc2UgWGVuYnVzU3RhdGVDbG9zZWQ6CiAg ICAgY2FzZSBYZW5idXNTdGF0ZVVua25vd246Ci0gICAgICAgIHhlbl9ibG9ja19kaXNjb25uZWN0 KHhlbmRldiwgJmxvY2FsX2Vycik7Ci0gICAgICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAg ICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOworICAgICAgICB4ZW5fYmxvY2tf ZGlzY29ubmVjdCh4ZW5kZXYsIGVycnApOworICAgICAgICBpZiAoKmVycnApIHsKICAgICAgICAg ICAgIGJyZWFrOwogICAgICAgICB9CiAKQEAgLTQwMywxMCArMzk5LDEwIEBAIHN0YXRpYyBpbnQg dmJkX25hbWVfdG9fZGlzayhjb25zdCBjaGFyICpuYW1lLCBjb25zdCBjaGFyICoqZW5kcCwKIHN0 YXRpYyB2b2lkIHhlbl9ibG9ja19zZXRfdmRldihPYmplY3QgKm9iaiwgVmlzaXRvciAqdiwgY29u c3QgY2hhciAqbmFtZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2b2lkICpvcGFx dWUsIEVycm9yICoqZXJycCkKIHsKKyAgICBFUlJQX0FVVE9fUFJPUEFHQVRFKCk7CiAgICAgRGV2 aWNlU3RhdGUgKmRldiA9IERFVklDRShvYmopOwogICAgIFByb3BlcnR5ICpwcm9wID0gb3BhcXVl OwogICAgIFhlbkJsb2NrVmRldiAqdmRldiA9IHFkZXZfZ2V0X3Byb3BfcHRyKGRldiwgcHJvcCk7 Ci0gICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7CiAgICAgY2hhciAqc3RyLCAqcDsKICAgICBj b25zdCBjaGFyICplbmQ7CiAKQEAgLTQxNSw5ICs0MTEsOCBAQCBzdGF0aWMgdm9pZCB4ZW5fYmxv Y2tfc2V0X3ZkZXYoT2JqZWN0ICpvYmosIFZpc2l0b3IgKnYsIGNvbnN0IGNoYXIgKm5hbWUsCiAg ICAgICAgIHJldHVybjsKICAgICB9CiAKLSAgICB2aXNpdF90eXBlX3N0cih2LCBuYW1lLCAmc3Ry LCAmbG9jYWxfZXJyKTsKLSAgICBpZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgIGVycm9yX3Byb3Bh Z2F0ZShlcnJwLCBsb2NhbF9lcnIpOworICAgIHZpc2l0X3R5cGVfc3RyKHYsIG5hbWUsICZzdHIs IGVycnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC02 NzEsOSArNjY2LDkgQEAgc3RhdGljIHZvaWQgeGVuX2Jsb2NrX2Jsb2NrZGV2X2RlbChjb25zdCBj aGFyICpub2RlX25hbWUsIEVycm9yICoqZXJycCkKIHN0YXRpYyBjaGFyICp4ZW5fYmxvY2tfYmxv Y2tkZXZfYWRkKGNvbnN0IGNoYXIgKmlkLCBRRGljdCAqcWRpY3QsCiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBFcnJvciAqKmVycnApCiB7CisgICAgRVJSUF9BVVRPX1BST1BB R0FURSgpOwogICAgIGNvbnN0IGNoYXIgKmRyaXZlciA9IHFkaWN0X2dldF90cnlfc3RyKHFkaWN0 LCAiZHJpdmVyIik7CiAgICAgQmxvY2tkZXZPcHRpb25zICpvcHRpb25zID0gTlVMTDsKLSAgICBF cnJvciAqbG9jYWxfZXJyID0gTlVMTDsKICAgICBjaGFyICpub2RlX25hbWU7CiAgICAgVmlzaXRv ciAqdjsKIApAQCAtNjg4LDE4ICs2ODMsMTYgQEAgc3RhdGljIGNoYXIgKnhlbl9ibG9ja19ibG9j a2Rldl9hZGQoY29uc3QgY2hhciAqaWQsIFFEaWN0ICpxZGljdCwKICAgICB0cmFjZV94ZW5fYmxv Y2tfYmxvY2tkZXZfYWRkKG5vZGVfbmFtZSk7CiAKICAgICB2ID0gcW9iamVjdF9pbnB1dF92aXNp dG9yX25ldyhRT0JKRUNUKHFkaWN0KSk7Ci0gICAgdmlzaXRfdHlwZV9CbG9ja2Rldk9wdGlvbnMo diwgTlVMTCwgJm9wdGlvbnMsICZsb2NhbF9lcnIpOworICAgIHZpc2l0X3R5cGVfQmxvY2tkZXZP cHRpb25zKHYsIE5VTEwsICZvcHRpb25zLCBlcnJwKTsKICAgICB2aXNpdF9mcmVlKHYpOwogCi0g ICAgaWYgKGxvY2FsX2VycikgewotICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxf ZXJyKTsKKyAgICBpZiAoKmVycnApIHsKICAgICAgICAgZ290byBmYWlsOwogICAgIH0KIAotICAg IHFtcF9ibG9ja2Rldl9hZGQob3B0aW9ucywgJmxvY2FsX2Vycik7CisgICAgcW1wX2Jsb2NrZGV2 X2FkZChvcHRpb25zLCBlcnJwKTsKIAotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJy b3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7CisgICAgaWYgKCplcnJwKSB7CiAgICAgICAg IGdvdG8gZmFpbDsKICAgICB9CiAKQEAgLTcxOCwxNCArNzExLDEyIEBAIGZhaWw6CiAKIHN0YXRp YyB2b2lkIHhlbl9ibG9ja19kcml2ZV9kZXN0cm95KFhlbkJsb2NrRHJpdmUgKmRyaXZlLCBFcnJv ciAqKmVycnApCiB7CisgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIGNoYXIgKm5vZGVf bmFtZSA9IGRyaXZlLT5ub2RlX25hbWU7CiAKICAgICBpZiAobm9kZV9uYW1lKSB7Ci0gICAgICAg IEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwotCi0gICAgICAgIHhlbl9ibG9ja19ibG9ja2Rldl9k ZWwobm9kZV9uYW1lLCAmbG9jYWxfZXJyKTsKLSAgICAgICAgaWYgKGxvY2FsX2VycikgewotICAg ICAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7CisgICAgICAgIHhlbl9i bG9ja19ibG9ja2Rldl9kZWwobm9kZV9uYW1lLCBlcnJwKTsKKyAgICAgICAgaWYgKCplcnJwKSB7 CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KICAgICAgICAgZ19mcmVlKG5vZGVfbmFt ZSk7CkBAIC03MzksNiArNzMwLDcgQEAgc3RhdGljIFhlbkJsb2NrRHJpdmUgKnhlbl9ibG9ja19k cml2ZV9jcmVhdGUoY29uc3QgY2hhciAqaWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICpkZXZpY2VfdHlwZSwKICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFFEaWN0ICpvcHRzLCBFcnJvciAqKmVycnAp CiB7CisgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIGNvbnN0IGNoYXIgKnBhcmFtcyA9 IHFkaWN0X2dldF90cnlfc3RyKG9wdHMsICJwYXJhbXMiKTsKICAgICBjb25zdCBjaGFyICptb2Rl ID0gcWRpY3RfZ2V0X3RyeV9zdHIob3B0cywgIm1vZGUiKTsKICAgICBjb25zdCBjaGFyICpkaXJl Y3RfaW9fc2FmZSA9IHFkaWN0X2dldF90cnlfc3RyKG9wdHMsICJkaXJlY3QtaW8tc2FmZSIpOwpA QCAtNzQ2LDcgKzczOCw2IEBAIHN0YXRpYyBYZW5CbG9ja0RyaXZlICp4ZW5fYmxvY2tfZHJpdmVf Y3JlYXRlKGNvbnN0IGNoYXIgKmlkLAogICAgIGNoYXIgKmRyaXZlciA9IE5VTEw7CiAgICAgY2hh ciAqZmlsZW5hbWUgPSBOVUxMOwogICAgIFhlbkJsb2NrRHJpdmUgKmRyaXZlID0gTlVMTDsKLSAg ICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKICAgICBRRGljdCAqZmlsZV9sYXllcjsKICAgICBR RGljdCAqZHJpdmVyX2xheWVyOwogCkBAIC04MjUsMTMgKzgxNiwxMiBAQCBzdGF0aWMgWGVuQmxv Y2tEcml2ZSAqeGVuX2Jsb2NrX2RyaXZlX2NyZWF0ZShjb25zdCBjaGFyICppZCwKIAogICAgIGdf YXNzZXJ0KCFkcml2ZS0+bm9kZV9uYW1lKTsKICAgICBkcml2ZS0+bm9kZV9uYW1lID0geGVuX2Js b2NrX2Jsb2NrZGV2X2FkZChkcml2ZS0+aWQsIGRyaXZlcl9sYXllciwKLSAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmbG9jYWxfZXJyKTsKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlcnJwKTsKIAogICAgIHFvYmplY3Rf dW5yZWYoZHJpdmVyX2xheWVyKTsKIAogZG9uZToKLSAgICBpZiAobG9jYWxfZXJyKSB7Ci0gICAg ICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOworICAgIGlmICgqZXJycCkgewog ICAgICAgICB4ZW5fYmxvY2tfZHJpdmVfZGVzdHJveShkcml2ZSwgTlVMTCk7CiAgICAgICAgIHJl dHVybiBOVUxMOwogICAgIH0KQEAgLTg1NiwxNSArODQ2LDEzIEBAIHN0YXRpYyB2b2lkIHhlbl9i bG9ja19pb3RocmVhZF9kZXN0cm95KFhlbkJsb2NrSU9UaHJlYWQgKmlvdGhyZWFkLAogc3RhdGlj IFhlbkJsb2NrSU9UaHJlYWQgKnhlbl9ibG9ja19pb3RocmVhZF9jcmVhdGUoY29uc3QgY2hhciAq aWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBF cnJvciAqKmVycnApCiB7CisgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIFhlbkJsb2Nr SU9UaHJlYWQgKmlvdGhyZWFkID0gZ19uZXcoWGVuQmxvY2tJT1RocmVhZCwgMSk7Ci0gICAgRXJy b3IgKmxvY2FsX2VyciA9IE5VTEw7CiAKICAgICBpb3RocmVhZC0+aWQgPSBnX3N0cmR1cChpZCk7 CiAKLSAgICBxbXBfb2JqZWN0X2FkZChUWVBFX0lPVEhSRUFELCBpZCwgZmFsc2UsIE5VTEwsICZs b2NhbF9lcnIpOwotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRl KGVycnAsIGxvY2FsX2Vycik7Ci0KKyAgICBxbXBfb2JqZWN0X2FkZChUWVBFX0lPVEhSRUFELCBp ZCwgZmFsc2UsIE5VTEwsIGVycnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICBnX2ZyZWUo aW90aHJlYWQtPmlkKTsKICAgICAgICAgZ19mcmVlKGlvdGhyZWFkKTsKICAgICAgICAgcmV0dXJu IE5VTEw7CkBAIC04NzYsNiArODY0LDcgQEAgc3RhdGljIFhlbkJsb2NrSU9UaHJlYWQgKnhlbl9i bG9ja19pb3RocmVhZF9jcmVhdGUoY29uc3QgY2hhciAqaWQsCiBzdGF0aWMgdm9pZCB4ZW5fYmxv Y2tfZGV2aWNlX2NyZWF0ZShYZW5CYWNrZW5kSW5zdGFuY2UgKmJhY2tlbmQsCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBRRGljdCAqb3B0cywgRXJyb3IgKiplcnJwKQogewor ICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKICAgICBYZW5CdXMgKnhlbmJ1cyA9IHhlbl9iYWNr ZW5kX2dldF9idXMoYmFja2VuZCk7CiAgICAgY29uc3QgY2hhciAqbmFtZSA9IHhlbl9iYWNrZW5k X2dldF9uYW1lKGJhY2tlbmQpOwogICAgIHVuc2lnbmVkIGxvbmcgbnVtYmVyOwpAQCAtODgzLDcg Kzg3Miw2IEBAIHN0YXRpYyB2b2lkIHhlbl9ibG9ja19kZXZpY2VfY3JlYXRlKFhlbkJhY2tlbmRJ bnN0YW5jZSAqYmFja2VuZCwKICAgICBYZW5CbG9ja0RyaXZlICpkcml2ZSA9IE5VTEw7CiAgICAg WGVuQmxvY2tJT1RocmVhZCAqaW90aHJlYWQgPSBOVUxMOwogICAgIFhlbkRldmljZSAqeGVuZGV2 ID0gTlVMTDsKLSAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKICAgICBjb25zdCBjaGFyICp0 eXBlOwogICAgIFhlbkJsb2NrRGV2aWNlICpibG9ja2RldjsKIApAQCAtOTE1LDUyICs5MDMsNDgg QEAgc3RhdGljIHZvaWQgeGVuX2Jsb2NrX2RldmljZV9jcmVhdGUoWGVuQmFja2VuZEluc3RhbmNl ICpiYWNrZW5kLAogICAgICAgICBnb3RvIGZhaWw7CiAgICAgfQogCi0gICAgZHJpdmUgPSB4ZW5f YmxvY2tfZHJpdmVfY3JlYXRlKHZkZXYsIGRldmljZV90eXBlLCBvcHRzLCAmbG9jYWxfZXJyKTsK KyAgICBkcml2ZSA9IHhlbl9ibG9ja19kcml2ZV9jcmVhdGUodmRldiwgZGV2aWNlX3R5cGUsIG9w dHMsIGVycnApOwogICAgIGlmICghZHJpdmUpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlX3By ZXBlbmQoZXJycCwgbG9jYWxfZXJyLCAiZmFpbGVkIHRvIGNyZWF0ZSBkcml2ZTogIik7CisgICAg ICAgIGVycm9yX3ByZXBlbmQoZXJycCwgImZhaWxlZCB0byBjcmVhdGUgZHJpdmU6ICIpOwogICAg ICAgICBnb3RvIGZhaWw7CiAgICAgfQogCi0gICAgaW90aHJlYWQgPSB4ZW5fYmxvY2tfaW90aHJl YWRfY3JlYXRlKHZkZXYsICZsb2NhbF9lcnIpOwotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAg ICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxfZXJyLAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAiZmFpbGVkIHRvIGNyZWF0ZSBpb3RocmVhZDogIik7CisgICAg aW90aHJlYWQgPSB4ZW5fYmxvY2tfaW90aHJlYWRfY3JlYXRlKHZkZXYsIGVycnApOworICAgIGlm ICgqZXJycCkgeworICAgICAgICBlcnJvcl9wcmVwZW5kKGVycnAsICJmYWlsZWQgdG8gY3JlYXRl IGlvdGhyZWFkOiAiKTsKICAgICAgICAgZ290byBmYWlsOwogICAgIH0KIAogICAgIHhlbmRldiA9 IFhFTl9ERVZJQ0UocWRldl9jcmVhdGUoQlVTKHhlbmJ1cyksIHR5cGUpKTsKICAgICBibG9ja2Rl diA9IFhFTl9CTE9DS19ERVZJQ0UoeGVuZGV2KTsKIAotICAgIG9iamVjdF9wcm9wZXJ0eV9zZXRf c3RyKE9CSkVDVCh4ZW5kZXYpLCB2ZGV2LCAidmRldiIsICZsb2NhbF9lcnIpOwotICAgIGlmIChs b2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxf ZXJyLCAiZmFpbGVkIHRvIHNldCAndmRldic6ICIpOworICAgIG9iamVjdF9wcm9wZXJ0eV9zZXRf c3RyKE9CSkVDVCh4ZW5kZXYpLCB2ZGV2LCAidmRldiIsIGVycnApOworICAgIGlmICgqZXJycCkg eworICAgICAgICBlcnJvcl9wcmVwZW5kKGVycnAsICJmYWlsZWQgdG8gc2V0ICd2ZGV2JzogIik7 CiAgICAgICAgIGdvdG8gZmFpbDsKICAgICB9CiAKICAgICBvYmplY3RfcHJvcGVydHlfc2V0X3N0 cihPQkpFQ1QoeGVuZGV2KSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5fYmxvY2tf ZHJpdmVfZ2V0X25vZGVfbmFtZShkcml2ZSksICJkcml2ZSIsCi0gICAgICAgICAgICAgICAgICAg ICAgICAgICAgJmxvY2FsX2Vycik7Ci0gICAgaWYgKGxvY2FsX2VycikgewotICAgICAgICBlcnJv cl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCBsb2NhbF9lcnIsICJmYWlsZWQgdG8gc2V0ICdkcml2 ZSc6ICIpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVycnApOworICAgIGlmICgqZXJy cCkgeworICAgICAgICBlcnJvcl9wcmVwZW5kKGVycnAsICJmYWlsZWQgdG8gc2V0ICdkcml2ZSc6 ICIpOwogICAgICAgICBnb3RvIGZhaWw7CiAgICAgfQogCiAgICAgb2JqZWN0X3Byb3BlcnR5X3Nl dF9zdHIoT0JKRUNUKHhlbmRldiksIGlvdGhyZWFkLT5pZCwgImlvdGhyZWFkIiwKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAmbG9jYWxfZXJyKTsKLSAgICBpZiAobG9jYWxfZXJyKSB7Ci0g ICAgICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgImZhaWxlZCB0byBzZXQgJ2lvdGhyZWFkJzogIik7Cisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgZXJycCk7CisgICAgaWYgKCplcnJwKSB7CisgICAg ICAgIGVycm9yX3ByZXBlbmQoZXJycCwgImZhaWxlZCB0byBzZXQgJ2lvdGhyZWFkJzogIik7CiAg ICAgICAgIGdvdG8gZmFpbDsKICAgICB9CiAKICAgICBibG9ja2Rldi0+aW90aHJlYWQgPSBpb3Ro cmVhZDsKICAgICBibG9ja2Rldi0+ZHJpdmUgPSBkcml2ZTsKIAotICAgIG9iamVjdF9wcm9wZXJ0 eV9zZXRfYm9vbChPQkpFQ1QoeGVuZGV2KSwgdHJ1ZSwgInJlYWxpemVkIiwgJmxvY2FsX2Vycik7 Ci0gICAgaWYgKGxvY2FsX2VycikgewotICAgICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChl cnJwLCBsb2NhbF9lcnIsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJyZWFsaXph dGlvbiBvZiBkZXZpY2UgJXMgZmFpbGVkOiAiLAotICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB0eXBlKTsKKyAgICBvYmplY3RfcHJvcGVydHlfc2V0X2Jvb2woT0JKRUNUKHhlbmRldiks IHRydWUsICJyZWFsaXplZCIsIGVycnApOworICAgIGlmICgqZXJycCkgeworICAgICAgICBlcnJv cl9wcmVwZW5kKGVycnAsICJyZWFsaXphdGlvbiBvZiBkZXZpY2UgJXMgZmFpbGVkOiAiLCB0eXBl KTsKICAgICAgICAgZ290byBmYWlsOwogICAgIH0KIApAQCAtOTg0LDYgKzk2OCw3IEBAIGZhaWw6 CiBzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfZGV2aWNlX2Rlc3Ryb3koWGVuQmFja2VuZEluc3RhbmNl ICpiYWNrZW5kLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEVycm9yICoq ZXJycCkKIHsKKyAgICBFUlJQX0FVVE9fUFJPUEFHQVRFKCk7CiAgICAgWGVuRGV2aWNlICp4ZW5k ZXYgPSB4ZW5fYmFja2VuZF9nZXRfZGV2aWNlKGJhY2tlbmQpOwogICAgIFhlbkJsb2NrRGV2aWNl ICpibG9ja2RldiA9IFhFTl9CTE9DS19ERVZJQ0UoeGVuZGV2KTsKICAgICBYZW5CbG9ja1ZkZXYg KnZkZXYgPSAmYmxvY2tkZXYtPnByb3BzLnZkZXY7CkBAIC05OTUsMjMgKzk4MCwxNyBAQCBzdGF0 aWMgdm9pZCB4ZW5fYmxvY2tfZGV2aWNlX2Rlc3Ryb3koWGVuQmFja2VuZEluc3RhbmNlICpiYWNr ZW5kLAogICAgIG9iamVjdF91bnBhcmVudChPQkpFQ1QoeGVuZGV2KSk7CiAKICAgICBpZiAoaW90 aHJlYWQpIHsKLSAgICAgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7Ci0KLSAgICAgICAgeGVu X2Jsb2NrX2lvdGhyZWFkX2Rlc3Ryb3koaW90aHJlYWQsICZsb2NhbF9lcnIpOwotICAgICAgICBp ZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChlcnJw LCBsb2NhbF9lcnIsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJmYWlsZWQgdG8g ZGVzdHJveSBpb3RocmVhZDogIik7CisgICAgICAgIHhlbl9ibG9ja19pb3RocmVhZF9kZXN0cm95 KGlvdGhyZWFkLCBlcnJwKTsKKyAgICAgICAgaWYgKCplcnJwKSB7CisgICAgICAgICAgICBlcnJv cl9wcmVwZW5kKGVycnAsICJmYWlsZWQgdG8gZGVzdHJveSBpb3RocmVhZDogIik7CiAgICAgICAg ICAgICByZXR1cm47CiAgICAgICAgIH0KICAgICB9CiAKICAgICBpZiAoZHJpdmUpIHsKLSAgICAg ICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7Ci0KLSAgICAgICAgeGVuX2Jsb2NrX2RyaXZlX2Rl c3Ryb3koZHJpdmUsICZsb2NhbF9lcnIpOwotICAgICAgICBpZiAobG9jYWxfZXJyKSB7Ci0gICAg ICAgICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCBsb2NhbF9lcnIsCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICJmYWlsZWQgdG8gZGVzdHJveSBkcml2ZTogIik7Cisg ICAgICAgIHhlbl9ibG9ja19kcml2ZV9kZXN0cm95KGRyaXZlLCBlcnJwKTsKKyAgICAgICAgaWYg KCplcnJwKSB7CisgICAgICAgICAgICBlcnJvcl9wcmVwZW5kKGVycnAsICJmYWlsZWQgdG8gZGVz dHJveSBkcml2ZTogIik7CiAgICAgICAgIH0KICAgICB9CiB9CmRpZmYgLS1naXQgYS9ody9wY2kt aG9zdC94ZW5faWdkX3B0LmMgYi9ody9wY2ktaG9zdC94ZW5faWdkX3B0LmMKaW5kZXggZWZjYzkz NDdmZi4uMjlhZGU5Y2EyNSAxMDA2NDQKLS0tIGEvaHcvcGNpLWhvc3QveGVuX2lnZF9wdC5jCisr KyBiL2h3L3BjaS1ob3N0L3hlbl9pZ2RfcHQuYwpAQCAtNzksMTcgKzc5LDE2IEBAIHN0YXRpYyB2 b2lkIGhvc3RfcGNpX2NvbmZpZ19yZWFkKGludCBwb3MsIGludCBsZW4sIHVpbnQzMl90ICp2YWws IEVycm9yICoqZXJycCkKIAogc3RhdGljIHZvaWQgaWdkX3B0X2k0NDBmeF9yZWFsaXplKFBDSURl dmljZSAqcGNpX2RldiwgRXJyb3IgKiplcnJwKQogeworICAgIEVSUlBfQVVUT19QUk9QQUdBVEUo KTsKICAgICB1aW50MzJfdCB2YWwgPSAwOwogICAgIHNpemVfdCBpOwogICAgIGludCBwb3MsIGxl bjsKLSAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKIAogICAgIGZvciAoaSA9IDA7IGkgPCBB UlJBWV9TSVpFKGlnZF9ob3N0X2JyaWRnZV9pbmZvcyk7IGkrKykgewogICAgICAgICBwb3MgPSBp Z2RfaG9zdF9icmlkZ2VfaW5mb3NbaV0ub2Zmc2V0OwogICAgICAgICBsZW4gPSBpZ2RfaG9zdF9i cmlkZ2VfaW5mb3NbaV0ubGVuOwotICAgICAgICBob3N0X3BjaV9jb25maWdfcmVhZChwb3MsIGxl biwgJnZhbCwgJmxvY2FsX2Vycik7Ci0gICAgICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAg ICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIpOworICAgICAgICBob3N0X3BjaV9j b25maWdfcmVhZChwb3MsIGxlbiwgJnZhbCwgZXJycCk7CisgICAgICAgIGlmICgqZXJycCkgewog ICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CiAgICAgICAgIHBjaV9kZWZhdWx0X3dyaXRl X2NvbmZpZyhwY2lfZGV2LCBwb3MsIHZhbCwgbGVuKTsKZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW4t YmFja2VuZC5jIGIvaHcveGVuL3hlbi1iYWNrZW5kLmMKaW5kZXggZGEwNjVmODFiNy4uMWNjMDY5 NDA1MyAxMDA2NDQKLS0tIGEvaHcveGVuL3hlbi1iYWNrZW5kLmMKKysrIGIvaHcveGVuL3hlbi1i YWNrZW5kLmMKQEAgLTk4LDkgKzk4LDkgQEAgc3RhdGljIHZvaWQgeGVuX2JhY2tlbmRfbGlzdF9y ZW1vdmUoWGVuQmFja2VuZEluc3RhbmNlICpiYWNrZW5kKQogdm9pZCB4ZW5fYmFja2VuZF9kZXZp Y2VfY3JlYXRlKFhlbkJ1cyAqeGVuYnVzLCBjb25zdCBjaGFyICp0eXBlLAogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKm5hbWUsIFFEaWN0ICpvcHRzLCBFcnJvciAq KmVycnApCiB7CisgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIGNvbnN0IFhlbkJhY2tl bmRJbXBsICppbXBsID0geGVuX2JhY2tlbmRfdGFibGVfbG9va3VwKHR5cGUpOwogICAgIFhlbkJh Y2tlbmRJbnN0YW5jZSAqYmFja2VuZDsKLSAgICBFcnJvciAqbG9jYWxfZXJyb3IgPSBOVUxMOwog CiAgICAgaWYgKCFpbXBsKSB7CiAgICAgICAgIHJldHVybjsKQEAgLTExMCw5ICsxMTAsOCBAQCB2 b2lkIHhlbl9iYWNrZW5kX2RldmljZV9jcmVhdGUoWGVuQnVzICp4ZW5idXMsIGNvbnN0IGNoYXIg KnR5cGUsCiAgICAgYmFja2VuZC0+eGVuYnVzID0geGVuYnVzOwogICAgIGJhY2tlbmQtPm5hbWUg PSBnX3N0cmR1cChuYW1lKTsKIAotICAgIGltcGwtPmNyZWF0ZShiYWNrZW5kLCBvcHRzLCAmbG9j YWxfZXJyb3IpOwotICAgIGlmIChsb2NhbF9lcnJvcikgewotICAgICAgICBlcnJvcl9wcm9wYWdh dGUoZXJycCwgbG9jYWxfZXJyb3IpOworICAgIGltcGwtPmNyZWF0ZShiYWNrZW5kLCBvcHRzLCBl cnJwKTsKKyAgICBpZiAoKmVycnApIHsKICAgICAgICAgZ19mcmVlKGJhY2tlbmQtPm5hbWUpOwog ICAgICAgICBnX2ZyZWUoYmFja2VuZCk7CiAgICAgICAgIHJldHVybjsKZGlmZiAtLWdpdCBhL2h3 L3hlbi94ZW4tYnVzLmMgYi9ody94ZW4veGVuLWJ1cy5jCmluZGV4IGMyYWQyMmE0MmQuLjI3MGVl MzFhYTUgMTAwNjQ0Ci0tLSBhL2h3L3hlbi94ZW4tYnVzLmMKKysrIGIvaHcveGVuL3hlbi1idXMu YwpAQCAtNTMsOSArNTMsOSBAQCBzdGF0aWMgY2hhciAqeGVuX2RldmljZV9nZXRfZnJvbnRlbmRf cGF0aChYZW5EZXZpY2UgKnhlbmRldikKIAogc3RhdGljIHZvaWQgeGVuX2RldmljZV91bnBsdWco WGVuRGV2aWNlICp4ZW5kZXYsIEVycm9yICoqZXJycCkKIHsKKyAgICBFUlJQX0FVVE9fUFJPUEFH QVRFKCk7CiAgICAgWGVuQnVzICp4ZW5idXMgPSBYRU5fQlVTKHFkZXZfZ2V0X3BhcmVudF9idXMo REVWSUNFKHhlbmRldikpKTsKICAgICBjb25zdCBjaGFyICp0eXBlID0gb2JqZWN0X2dldF90eXBl bmFtZShPQkpFQ1QoeGVuZGV2KSk7Ci0gICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7CiAgICAg eHNfdHJhbnNhY3Rpb25fdCB0aWQ7CiAKICAgICB0cmFjZV94ZW5fZGV2aWNlX3VucGx1Zyh0eXBl LCB4ZW5kZXYtPm5hbWUpOwpAQCAtNjksMTQgKzY5LDE0IEBAIGFnYWluOgogICAgIH0KIAogICAg IHhzX25vZGVfcHJpbnRmKHhlbmJ1cy0+eHNoLCB0aWQsIHhlbmRldi0+YmFja2VuZF9wYXRoLCAi b25saW5lIiwKLSAgICAgICAgICAgICAgICAgICAmbG9jYWxfZXJyLCAiJXUiLCAwKTsKLSAgICBp ZiAobG9jYWxfZXJyKSB7CisgICAgICAgICAgICAgICAgICAgZXJycCwgIiV1IiwgMCk7CisgICAg aWYgKCplcnJwKSB7CiAgICAgICAgIGdvdG8gYWJvcnQ7CiAgICAgfQogCiAgICAgeHNfbm9kZV9w cmludGYoeGVuYnVzLT54c2gsIHRpZCwgeGVuZGV2LT5iYWNrZW5kX3BhdGgsICJzdGF0ZSIsCi0g ICAgICAgICAgICAgICAgICAgJmxvY2FsX2VyciwgIiV1IiwgWGVuYnVzU3RhdGVDbG9zaW5nKTsK LSAgICBpZiAobG9jYWxfZXJyKSB7CisgICAgICAgICAgICAgICAgICAgZXJycCwgIiV1IiwgWGVu YnVzU3RhdGVDbG9zaW5nKTsKKyAgICBpZiAoKmVycnApIHsKICAgICAgICAgZ290byBhYm9ydDsK ICAgICB9CiAKQEAgLTk2LDcgKzk2LDYgQEAgYWJvcnQ6CiAgICAgICogZnJvbSBlbmRpbmcgdGhl IHRyYW5zYWN0aW9uLgogICAgICAqLwogICAgIHhzX3RyYW5zYWN0aW9uX2VuZCh4ZW5idXMtPnhz aCwgdGlkLCB0cnVlKTsKLSAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKIH0K IAogc3RhdGljIHZvaWQgeGVuX2J1c19wcmludF9kZXYoTW9uaXRvciAqbW9uLCBEZXZpY2VTdGF0 ZSAqZGV2LCBpbnQgaW5kZW50KQpAQCAtMjA1LDE1ICsyMDQsMTMgQEAgc3RhdGljIFhlbldhdGNo ICp3YXRjaF9saXN0X2FkZChYZW5XYXRjaExpc3QgKndhdGNoX2xpc3QsIGNvbnN0IGNoYXIgKm5v ZGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKmtleSwgWGVu V2F0Y2hIYW5kbGVyIGhhbmRsZXIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZv aWQgKm9wYXF1ZSwgRXJyb3IgKiplcnJwKQogeworICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsK ICAgICBYZW5XYXRjaCAqd2F0Y2ggPSBuZXdfd2F0Y2gobm9kZSwga2V5LCBoYW5kbGVyLCBvcGFx dWUpOwotICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwogCiAgICAgbm90aWZpZXJfbGlzdF9h ZGQoJndhdGNoX2xpc3QtPm5vdGlmaWVycywgJndhdGNoLT5ub3RpZmllcik7CiAKLSAgICB4c19u b2RlX3dhdGNoKHdhdGNoX2xpc3QtPnhzaCwgbm9kZSwga2V5LCB3YXRjaC0+dG9rZW4sICZsb2Nh bF9lcnIpOwotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVy cnAsIGxvY2FsX2Vycik7Ci0KKyAgICB4c19ub2RlX3dhdGNoKHdhdGNoX2xpc3QtPnhzaCwgbm9k ZSwga2V5LCB3YXRjaC0+dG9rZW4sIGVycnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICBu b3RpZmllcl9yZW1vdmUoJndhdGNoLT5ub3RpZmllcik7CiAgICAgICAgIGZyZWVfd2F0Y2god2F0 Y2gpOwogCkBAIC0yNTUsMTEgKzI1MiwxMSBAQCBzdGF0aWMgdm9pZCB4ZW5fYnVzX2JhY2tlbmRf Y3JlYXRlKFhlbkJ1cyAqeGVuYnVzLCBjb25zdCBjaGFyICp0eXBlLAogICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICpuYW1lLCBjaGFyICpwYXRoLAogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBFcnJvciAqKmVycnApCiB7CisgICAgRVJSUF9B VVRPX1BST1BBR0FURSgpOwogICAgIHhzX3RyYW5zYWN0aW9uX3QgdGlkOwogICAgIGNoYXIgKipr ZXk7CiAgICAgUURpY3QgKm9wdHM7CiAgICAgdW5zaWduZWQgaW50IGksIG47Ci0gICAgRXJyb3Ig KmxvY2FsX2VyciA9IE5VTEw7CiAKICAgICB0cmFjZV94ZW5fYnVzX2JhY2tlbmRfY3JlYXRlKHR5 cGUsIHBhdGgpOwogCkBAIC0zMTQsMTMgKzMxMSwxMSBAQCBhZ2FpbjoKICAgICAgICAgcmV0dXJu OwogICAgIH0KIAotICAgIHhlbl9iYWNrZW5kX2RldmljZV9jcmVhdGUoeGVuYnVzLCB0eXBlLCBu YW1lLCBvcHRzLCAmbG9jYWxfZXJyKTsKKyAgICB4ZW5fYmFja2VuZF9kZXZpY2VfY3JlYXRlKHhl bmJ1cywgdHlwZSwgbmFtZSwgb3B0cywgZXJycCk7CiAgICAgcW9iamVjdF91bnJlZihvcHRzKTsK IAotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQo ZXJycCwgbG9jYWxfZXJyLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiZmFpbGVk IHRvIGNyZWF0ZSAnJXMnIGRldmljZSAnJXMnOiAiLAotICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB0eXBlLCBuYW1lKTsKKyAgICBpZiAoKmVycnApIHsKKyAgICAgICAgZXJyb3JfcHJl cGVuZChlcnJwLCAiZmFpbGVkIHRvIGNyZWF0ZSAnJXMnIGRldmljZSAnJXMnOiAiLCB0eXBlLCBu YW1lKTsKICAgICB9CiB9CiAKQEAgLTQ1MSw5ICs0NDYsOSBAQCBzdGF0aWMgdm9pZCB4ZW5fYnVz X3VucmVhbGl6ZShCdXNTdGF0ZSAqYnVzLCBFcnJvciAqKmVycnApCiAKIHN0YXRpYyB2b2lkIHhl bl9idXNfcmVhbGl6ZShCdXNTdGF0ZSAqYnVzLCBFcnJvciAqKmVycnApCiB7CisgICAgRVJSUF9B VVRPX1BST1BBR0FURSgpOwogICAgIFhlbkJ1cyAqeGVuYnVzID0gWEVOX0JVUyhidXMpOwogICAg IHVuc2lnbmVkIGludCBkb21pZDsKLSAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKIAogICAg IHRyYWNlX3hlbl9idXNfcmVhbGl6ZSgpOwogCkBAIC00NzYsMTAgKzQ3MSwxMCBAQCBzdGF0aWMg dm9pZCB4ZW5fYnVzX3JlYWxpemUoQnVzU3RhdGUgKmJ1cywgRXJyb3IgKiplcnJwKQogCiAgICAg eGVuYnVzLT5iYWNrZW5kX3dhdGNoID0KICAgICAgICAgeGVuX2J1c19hZGRfd2F0Y2goeGVuYnVz LCAiIiwgLyogZG9tYWluIHJvb3Qgbm9kZSAqLwotICAgICAgICAgICAgICAgICAgICAgICAgICAi YmFja2VuZCIsIHhlbl9idXNfYmFja2VuZF9jaGFuZ2VkLCAmbG9jYWxfZXJyKTsKLSAgICBpZiAo bG9jYWxfZXJyKSB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICJiYWNrZW5kIiwgeGVuX2J1 c19iYWNrZW5kX2NoYW5nZWQsIGVycnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICAvKiBU aGlzIG5lZWQgbm90IGJlIHRyZWF0ZWQgYXMgYSBoYXJkIGVycm9yIHNvIGRvbid0IHByb3BhZ2F0 ZSAqLwotICAgICAgICBlcnJvcl9yZXBvcnRmX2Vycihsb2NhbF9lcnIsCisgICAgICAgIGVycm9y X3JlcG9ydGZfZXJyKCplcnJwLAogICAgICAgICAgICAgICAgICAgICAgICAgICAiZmFpbGVkIHRv IHNldCB1cCBlbnVtZXJhdGlvbiB3YXRjaDogIik7CiAgICAgfQogCkBAIC02OTIsOSArNjg3LDkg QEAgc3RhdGljIHZvaWQgeGVuX2RldmljZV9yZW1vdmVfd2F0Y2goWGVuRGV2aWNlICp4ZW5kZXYs IFhlbldhdGNoICp3YXRjaCwKIAogc3RhdGljIHZvaWQgeGVuX2RldmljZV9iYWNrZW5kX2NyZWF0 ZShYZW5EZXZpY2UgKnhlbmRldiwgRXJyb3IgKiplcnJwKQogeworICAgIEVSUlBfQVVUT19QUk9Q QUdBVEUoKTsKICAgICBYZW5CdXMgKnhlbmJ1cyA9IFhFTl9CVVMocWRldl9nZXRfcGFyZW50X2J1 cyhERVZJQ0UoeGVuZGV2KSkpOwogICAgIHN0cnVjdCB4c19wZXJtaXNzaW9ucyBwZXJtc1syXTsK LSAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKIAogICAgIHhlbmRldi0+YmFja2VuZF9wYXRo ID0geGVuX2RldmljZV9nZXRfYmFja2VuZF9wYXRoKHhlbmRldik7CiAKQEAgLTcwNiwzMCArNzAx LDI3IEBAIHN0YXRpYyB2b2lkIHhlbl9kZXZpY2VfYmFja2VuZF9jcmVhdGUoWGVuRGV2aWNlICp4 ZW5kZXYsIEVycm9yICoqZXJycCkKICAgICBnX2Fzc2VydCh4ZW5idXMtPnhzaCk7CiAKICAgICB4 c19ub2RlX2NyZWF0ZSh4ZW5idXMtPnhzaCwgWEJUX05VTEwsIHhlbmRldi0+YmFja2VuZF9wYXRo LCBwZXJtcywKLSAgICAgICAgICAgICAgICAgICBBUlJBWV9TSVpFKHBlcm1zKSwgJmxvY2FsX2Vy cik7Ci0gICAgaWYgKGxvY2FsX2VycikgewotICAgICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVu ZChlcnJwLCBsb2NhbF9lcnIsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJmYWls ZWQgdG8gY3JlYXRlIGJhY2tlbmQ6ICIpOworICAgICAgICAgICAgICAgICAgIEFSUkFZX1NJWkUo cGVybXMpLCBlcnJwKTsKKyAgICBpZiAoKmVycnApIHsKKyAgICAgICAgZXJyb3JfcHJlcGVuZChl cnJwLCAiZmFpbGVkIHRvIGNyZWF0ZSBiYWNrZW5kOiAiKTsKICAgICAgICAgcmV0dXJuOwogICAg IH0KIAogICAgIHhlbmRldi0+YmFja2VuZF9zdGF0ZV93YXRjaCA9CiAgICAgICAgIHhlbl9kZXZp Y2VfYWRkX3dhdGNoKHhlbmRldiwgeGVuZGV2LT5iYWNrZW5kX3BhdGgsCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICJzdGF0ZSIsIHhlbl9kZXZpY2VfYmFja2VuZF9jaGFuZ2VkLAotICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAmbG9jYWxfZXJyKTsKLSAgICBpZiAobG9jYWxfZXJy KSB7Ci0gICAgICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImZhaWxlZCB0byB3YXRjaCBiYWNrZW5kIHN0 YXRlOiAiKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZXJycCk7CisgICAgaWYgKCpl cnJwKSB7CisgICAgICAgIGVycm9yX3ByZXBlbmQoZXJycCwgImZhaWxlZCB0byB3YXRjaCBiYWNr ZW5kIHN0YXRlOiAiKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAogICAgIHhlbmRldi0+YmFj a2VuZF9vbmxpbmVfd2F0Y2ggPQogICAgICAgICB4ZW5fZGV2aWNlX2FkZF93YXRjaCh4ZW5kZXYs IHhlbmRldi0+YmFja2VuZF9wYXRoLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAib25s aW5lIiwgeGVuX2RldmljZV9iYWNrZW5kX2NoYW5nZWQsCi0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICZsb2NhbF9lcnIpOwotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3Jf cHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxfZXJyLAotICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAiZmFpbGVkIHRvIHdhdGNoIGJhY2tlbmQgb25saW5lOiAiKTsKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZXJycCk7CisgICAgaWYgKCplcnJwKSB7CisgICAgICAgIGVy cm9yX3ByZXBlbmQoZXJycCwgImZhaWxlZCB0byB3YXRjaCBiYWNrZW5kIG9ubGluZTogIik7CiAg ICAgICAgIHJldHVybjsKICAgICB9CiB9CkBAIC04NjYsOSArODU4LDkgQEAgc3RhdGljIGJvb2wg eGVuX2RldmljZV9mcm9udGVuZF9leGlzdHMoWGVuRGV2aWNlICp4ZW5kZXYpCiAKIHN0YXRpYyB2 b2lkIHhlbl9kZXZpY2VfZnJvbnRlbmRfY3JlYXRlKFhlbkRldmljZSAqeGVuZGV2LCBFcnJvciAq KmVycnApCiB7CisgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIFhlbkJ1cyAqeGVuYnVz ID0gWEVOX0JVUyhxZGV2X2dldF9wYXJlbnRfYnVzKERFVklDRSh4ZW5kZXYpKSk7CiAgICAgc3Ry dWN0IHhzX3Blcm1pc3Npb25zIHBlcm1zWzJdOwotICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxM OwogCiAgICAgeGVuZGV2LT5mcm9udGVuZF9wYXRoID0geGVuX2RldmljZV9nZXRfZnJvbnRlbmRf cGF0aCh4ZW5kZXYpOwogCkBAIC04ODUsMjAgKzg3NywxOCBAQCBzdGF0aWMgdm9pZCB4ZW5fZGV2 aWNlX2Zyb250ZW5kX2NyZWF0ZShYZW5EZXZpY2UgKnhlbmRldiwgRXJyb3IgKiplcnJwKQogICAg ICAgICBnX2Fzc2VydCh4ZW5idXMtPnhzaCk7CiAKICAgICAgICAgeHNfbm9kZV9jcmVhdGUoeGVu YnVzLT54c2gsIFhCVF9OVUxMLCB4ZW5kZXYtPmZyb250ZW5kX3BhdGgsIHBlcm1zLAotICAgICAg ICAgICAgICAgICAgICAgICBBUlJBWV9TSVpFKHBlcm1zKSwgJmxvY2FsX2Vycik7Ci0gICAgICAg IGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVy cnAsIGxvY2FsX2VyciwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJmYWls ZWQgdG8gY3JlYXRlIGZyb250ZW5kOiAiKTsKKyAgICAgICAgICAgICAgICAgICAgICAgQVJSQVlf U0laRShwZXJtcyksIGVycnApOworICAgICAgICBpZiAoKmVycnApIHsKKyAgICAgICAgICAgIGVy cm9yX3ByZXBlbmQoZXJycCwgImZhaWxlZCB0byBjcmVhdGUgZnJvbnRlbmQ6ICIpOwogICAgICAg ICAgICAgcmV0dXJuOwogICAgICAgICB9CiAgICAgfQogCiAgICAgeGVuZGV2LT5mcm9udGVuZF9z dGF0ZV93YXRjaCA9CiAgICAgICAgIHhlbl9kZXZpY2VfYWRkX3dhdGNoKHhlbmRldiwgeGVuZGV2 LT5mcm9udGVuZF9wYXRoLCAic3RhdGUiLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4 ZW5fZGV2aWNlX2Zyb250ZW5kX2NoYW5nZWQsICZsb2NhbF9lcnIpOwotICAgIGlmIChsb2NhbF9l cnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxfZXJyLAot ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiZmFpbGVkIHRvIHdhdGNoIGZyb250ZW5k IHN0YXRlOiAiKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeGVuX2RldmljZV9mcm9u dGVuZF9jaGFuZ2VkLCBlcnJwKTsKKyAgICBpZiAoKmVycnApIHsKKyAgICAgICAgZXJyb3JfcHJl cGVuZChlcnJwLCAiZmFpbGVkIHRvIHdhdGNoIGZyb250ZW5kIHN0YXRlOiAiKTsKICAgICB9CiB9 CiAKQEAgLTEyMjgsMTEgKzEyMTgsMTEgQEAgc3RhdGljIHZvaWQgeGVuX2RldmljZV9leGl0KE5v dGlmaWVyICpuLCB2b2lkICpkYXRhKQogCiBzdGF0aWMgdm9pZCB4ZW5fZGV2aWNlX3JlYWxpemUo RGV2aWNlU3RhdGUgKmRldiwgRXJyb3IgKiplcnJwKQogeworICAgIEVSUlBfQVVUT19QUk9QQUdB VEUoKTsKICAgICBYZW5EZXZpY2UgKnhlbmRldiA9IFhFTl9ERVZJQ0UoZGV2KTsKICAgICBYZW5E ZXZpY2VDbGFzcyAqeGVuZGV2X2NsYXNzID0gWEVOX0RFVklDRV9HRVRfQ0xBU1MoeGVuZGV2KTsK ICAgICBYZW5CdXMgKnhlbmJ1cyA9IFhFTl9CVVMocWRldl9nZXRfcGFyZW50X2J1cyhERVZJQ0Uo eGVuZGV2KSkpOwogICAgIGNvbnN0IGNoYXIgKnR5cGUgPSBvYmplY3RfZ2V0X3R5cGVuYW1lKE9C SkVDVCh4ZW5kZXYpKTsKLSAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKIAogICAgIGlmICh4 ZW5kZXYtPmZyb250ZW5kX2lkID09IERPTUlEX0lOVkFMSUQpIHsKICAgICAgICAgeGVuZGV2LT5m cm9udGVuZF9pZCA9IHhlbl9kb21pZDsKQEAgLTEyNDgsMTAgKzEyMzgsOSBAQCBzdGF0aWMgdm9p ZCB4ZW5fZGV2aWNlX3JlYWxpemUoRGV2aWNlU3RhdGUgKmRldiwgRXJyb3IgKiplcnJwKQogICAg ICAgICBnb3RvIHVucmVhbGl6ZTsKICAgICB9CiAKLSAgICB4ZW5kZXYtPm5hbWUgPSB4ZW5kZXZf Y2xhc3MtPmdldF9uYW1lKHhlbmRldiwgJmxvY2FsX2Vycik7Ci0gICAgaWYgKGxvY2FsX2Vycikg ewotICAgICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCBsb2NhbF9lcnIsCi0gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICJmYWlsZWQgdG8gZ2V0IGRldmljZSBuYW1lOiAi KTsKKyAgICB4ZW5kZXYtPm5hbWUgPSB4ZW5kZXZfY2xhc3MtPmdldF9uYW1lKHhlbmRldiwgZXJy cCk7CisgICAgaWYgKCplcnJwKSB7CisgICAgICAgIGVycm9yX3ByZXBlbmQoZXJycCwgImZhaWxl ZCB0byBnZXQgZGV2aWNlIG5hbWU6ICIpOwogICAgICAgICBnb3RvIHVucmVhbGl6ZTsKICAgICB9 CiAKQEAgLTEyNzQsMjIgKzEyNjMsMTkgQEAgc3RhdGljIHZvaWQgeGVuX2RldmljZV9yZWFsaXpl KERldmljZVN0YXRlICpkZXYsIEVycm9yICoqZXJycCkKICAgICB4ZW5kZXYtPmZlYXR1cmVfZ3Jh bnRfY29weSA9CiAgICAgICAgICh4ZW5nbnR0YWJfZ3JhbnRfY29weSh4ZW5kZXYtPnhndGgsIDAs IE5VTEwpID09IDApOwogCi0gICAgeGVuX2RldmljZV9iYWNrZW5kX2NyZWF0ZSh4ZW5kZXYsICZs b2NhbF9lcnIpOwotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRl KGVycnAsIGxvY2FsX2Vycik7CisgICAgeGVuX2RldmljZV9iYWNrZW5kX2NyZWF0ZSh4ZW5kZXYs IGVycnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICBnb3RvIHVucmVhbGl6ZTsKICAgICB9 CiAKLSAgICB4ZW5fZGV2aWNlX2Zyb250ZW5kX2NyZWF0ZSh4ZW5kZXYsICZsb2NhbF9lcnIpOwot ICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2Fs X2Vycik7CisgICAgeGVuX2RldmljZV9mcm9udGVuZF9jcmVhdGUoeGVuZGV2LCBlcnJwKTsKKyAg ICBpZiAoKmVycnApIHsKICAgICAgICAgZ290byB1bnJlYWxpemU7CiAgICAgfQogCiAgICAgaWYg KHhlbmRldl9jbGFzcy0+cmVhbGl6ZSkgewotICAgICAgICB4ZW5kZXZfY2xhc3MtPnJlYWxpemUo eGVuZGV2LCAmbG9jYWxfZXJyKTsKLSAgICAgICAgaWYgKGxvY2FsX2VycikgewotICAgICAgICAg ICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7CisgICAgICAgIHhlbmRldl9jbGFz cy0+cmVhbGl6ZSh4ZW5kZXYsIGVycnApOworICAgICAgICBpZiAoKmVycnApIHsKICAgICAgICAg ICAgIGdvdG8gdW5yZWFsaXplOwogICAgICAgICB9CiAgICAgfQpkaWZmIC0tZ2l0IGEvaHcveGVu L3hlbi1ob3N0LXBjaS1kZXZpY2UuYyBiL2h3L3hlbi94ZW4taG9zdC1wY2ktZGV2aWNlLmMKaW5k ZXggMWI0NGRjYWZhZi4uMDIzNzljMzQxYyAxMDA2NDQKLS0tIGEvaHcveGVuL3hlbi1ob3N0LXBj aS1kZXZpY2UuYworKysgYi9ody94ZW4veGVuLWhvc3QtcGNpLWRldmljZS5jCkBAIC0zMzMsOCAr MzMzLDggQEAgdm9pZCB4ZW5faG9zdF9wY2lfZGV2aWNlX2dldChYZW5Ib3N0UENJRGV2aWNlICpk LCB1aW50MTZfdCBkb21haW4sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVpbnQ4X3Qg YnVzLCB1aW50OF90IGRldiwgdWludDhfdCBmdW5jLAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBFcnJvciAqKmVycnApCiB7CisgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIHVu c2lnbmVkIGludCB2OwotICAgIEVycm9yICplcnIgPSBOVUxMOwogCiAgICAgZC0+Y29uZmlnX2Zk ID0gLTE7CiAgICAgZC0+ZG9tYWluID0gZG9tYWluOwpAQCAtMzQyLDM2ICszNDIsMzYgQEAgdm9p ZCB4ZW5faG9zdF9wY2lfZGV2aWNlX2dldChYZW5Ib3N0UENJRGV2aWNlICpkLCB1aW50MTZfdCBk b21haW4sCiAgICAgZC0+ZGV2ID0gZGV2OwogICAgIGQtPmZ1bmMgPSBmdW5jOwogCi0gICAgeGVu X2hvc3RfcGNpX2NvbmZpZ19vcGVuKGQsICZlcnIpOwotICAgIGlmIChlcnIpIHsKKyAgICB4ZW5f aG9zdF9wY2lfY29uZmlnX29wZW4oZCwgZXJycCk7CisgICAgaWYgKCplcnJwKSB7CiAgICAgICAg IGdvdG8gZXJyb3I7CiAgICAgfQogCi0gICAgeGVuX2hvc3RfcGNpX2dldF9yZXNvdXJjZShkLCAm ZXJyKTsKLSAgICBpZiAoZXJyKSB7CisgICAgeGVuX2hvc3RfcGNpX2dldF9yZXNvdXJjZShkLCBl cnJwKTsKKyAgICBpZiAoKmVycnApIHsKICAgICAgICAgZ290byBlcnJvcjsKICAgICB9CiAKLSAg ICB4ZW5faG9zdF9wY2lfZ2V0X2hleF92YWx1ZShkLCAidmVuZG9yIiwgJnYsICZlcnIpOwotICAg IGlmIChlcnIpIHsKKyAgICB4ZW5faG9zdF9wY2lfZ2V0X2hleF92YWx1ZShkLCAidmVuZG9yIiwg JnYsIGVycnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICBnb3RvIGVycm9yOwogICAgIH0K ICAgICBkLT52ZW5kb3JfaWQgPSB2OwogCi0gICAgeGVuX2hvc3RfcGNpX2dldF9oZXhfdmFsdWUo ZCwgImRldmljZSIsICZ2LCAmZXJyKTsKLSAgICBpZiAoZXJyKSB7CisgICAgeGVuX2hvc3RfcGNp X2dldF9oZXhfdmFsdWUoZCwgImRldmljZSIsICZ2LCBlcnJwKTsKKyAgICBpZiAoKmVycnApIHsK ICAgICAgICAgZ290byBlcnJvcjsKICAgICB9CiAgICAgZC0+ZGV2aWNlX2lkID0gdjsKIAotICAg IHhlbl9ob3N0X3BjaV9nZXRfZGVjX3ZhbHVlKGQsICJpcnEiLCAmdiwgJmVycik7Ci0gICAgaWYg KGVycikgeworICAgIHhlbl9ob3N0X3BjaV9nZXRfZGVjX3ZhbHVlKGQsICJpcnEiLCAmdiwgZXJy cCk7CisgICAgaWYgKCplcnJwKSB7CiAgICAgICAgIGdvdG8gZXJyb3I7CiAgICAgfQogICAgIGQt PmlycSA9IHY7CiAKLSAgICB4ZW5faG9zdF9wY2lfZ2V0X2hleF92YWx1ZShkLCAiY2xhc3MiLCAm diwgJmVycik7Ci0gICAgaWYgKGVycikgeworICAgIHhlbl9ob3N0X3BjaV9nZXRfaGV4X3ZhbHVl KGQsICJjbGFzcyIsICZ2LCBlcnJwKTsKKyAgICBpZiAoKmVycnApIHsKICAgICAgICAgZ290byBl cnJvcjsKICAgICB9CiAgICAgZC0+Y2xhc3NfY29kZSA9IHY7CkBAIC0zODEsNyArMzgxLDYgQEAg dm9pZCB4ZW5faG9zdF9wY2lfZGV2aWNlX2dldChYZW5Ib3N0UENJRGV2aWNlICpkLCB1aW50MTZf dCBkb21haW4sCiAgICAgcmV0dXJuOwogCiBlcnJvcjoKLSAgICBlcnJvcl9wcm9wYWdhdGUoZXJy cCwgZXJyKTsKIAogICAgIGlmIChkLT5jb25maWdfZmQgPj0gMCkgewogICAgICAgICBjbG9zZShk LT5jb25maWdfZmQpOwpkaWZmIC0tZ2l0IGEvaHcveGVuL3hlbl9wdC5jIGIvaHcveGVuL3hlbl9w dC5jCmluZGV4IDllNzY3ZDQyNDQuLjMzYjY4ZGZjYjggMTAwNjQ0Ci0tLSBhL2h3L3hlbi94ZW5f cHQuYworKysgYi9ody94ZW4veGVuX3B0LmMKQEAgLTc2NywxMiArNzY3LDEyIEBAIHN0YXRpYyB2 b2lkIHhlbl9wdF9kZXN0cm95KFBDSURldmljZSAqZCkgewogCiBzdGF0aWMgdm9pZCB4ZW5fcHRf cmVhbGl6ZShQQ0lEZXZpY2UgKmQsIEVycm9yICoqZXJycCkKIHsKKyAgICBFUlJQX0FVVE9fUFJP UEFHQVRFKCk7CiAgICAgWGVuUENJUGFzc3Rocm91Z2hTdGF0ZSAqcyA9IFhFTl9QVF9ERVZJQ0Uo ZCk7CiAgICAgaW50IGksIHJjID0gMDsKICAgICB1aW50OF90IG1hY2hpbmVfaXJxID0gMCwgc2Ny YXRjaDsKICAgICB1aW50MTZfdCBjbWQgPSAwOwogICAgIGludCBwaXJxID0gWEVOX1BUX1VOQVNT SUdORURfUElSUTsKLSAgICBFcnJvciAqZXJyID0gTlVMTDsKIAogICAgIC8qIHJlZ2lzdGVyIHJl YWwgZGV2aWNlICovCiAgICAgWEVOX1BUX0xPRyhkLCAiQXNzaWduaW5nIHJlYWwgcGh5c2ljYWwg ZGV2aWNlICUwMng6JTAyeC4lZCIKQEAgLTc4MywxMCArNzgzLDkgQEAgc3RhdGljIHZvaWQgeGVu X3B0X3JlYWxpemUoUENJRGV2aWNlICpkLCBFcnJvciAqKmVycnApCiAgICAgeGVuX2hvc3RfcGNp X2RldmljZV9nZXQoJnMtPnJlYWxfZGV2aWNlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAg IHMtPmhvc3RhZGRyLmRvbWFpbiwgcy0+aG9zdGFkZHIuYnVzLAogICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHMtPmhvc3RhZGRyLnNsb3QsIHMtPmhvc3RhZGRyLmZ1bmN0aW9uLAotICAgICAg ICAgICAgICAgICAgICAgICAgICAgICZlcnIpOwotICAgIGlmIChlcnIpIHsKLSAgICAgICAgZXJy b3JfYXBwZW5kX2hpbnQoJmVyciwgIkZhaWxlZCB0byBcIm9wZW5cIiB0aGUgcmVhbCBwY2kgZGV2 aWNlIik7Ci0gICAgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBlcnIpOworICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGVycnApOworICAgIGlmICgqZXJycCkgeworICAgICAgICBlcnJvcl9h cHBlbmRfaGludChlcnJwLCAiRmFpbGVkIHRvIFwib3BlblwiIHRoZSByZWFsIHBjaSBkZXZpY2Ui KTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIApAQCAtODEzLDExICs4MTIsMTAgQEAgc3RhdGlj IHZvaWQgeGVuX3B0X3JlYWxpemUoUENJRGV2aWNlICpkLCBFcnJvciAqKmVycnApCiAgICAgICAg ICAgICByZXR1cm47CiAgICAgICAgIH0KIAotICAgICAgICB4ZW5fcHRfc2V0dXBfdmdhKHMsICZz LT5yZWFsX2RldmljZSwgJmVycik7Ci0gICAgICAgIGlmIChlcnIpIHsKLSAgICAgICAgICAgIGVy cm9yX2FwcGVuZF9oaW50KCZlcnIsICJTZXR1cCBWR0EgQklPUyBvZiBwYXNzdGhyb3VnaCIKLSAg ICAgICAgICAgICAgICAgICAgIiBHRlggZmFpbGVkIik7Ci0gICAgICAgICAgICBlcnJvcl9wcm9w YWdhdGUoZXJycCwgZXJyKTsKKyAgICAgICAgeGVuX3B0X3NldHVwX3ZnYShzLCAmcy0+cmVhbF9k ZXZpY2UsIGVycnApOworICAgICAgICBpZiAoKmVycnApIHsKKyAgICAgICAgICAgIGVycm9yX2Fw cGVuZF9oaW50KGVycnAsICJTZXR1cCBWR0EgQklPUyBvZiBwYXNzdGhyb3VnaCIKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICIgR0ZYIGZhaWxlZCIpOwogICAgICAgICAgICAgeGVuX2hv c3RfcGNpX2RldmljZV9wdXQoJnMtPnJlYWxfZGV2aWNlKTsKICAgICAgICAgICAgIHJldHVybjsK ICAgICAgICAgfQpAQCAtODMwLDEwICs4MjgsOSBAQCBzdGF0aWMgdm9pZCB4ZW5fcHRfcmVhbGl6 ZShQQ0lEZXZpY2UgKmQsIEVycm9yICoqZXJycCkKICAgICB4ZW5fcHRfcmVnaXN0ZXJfcmVnaW9u cyhzLCAmY21kKTsKIAogICAgIC8qIHJlaW5pdGlhbGl6ZSBlYWNoIGNvbmZpZyByZWdpc3RlciB0 byBiZSBlbXVsYXRlZCAqLwotICAgIHhlbl9wdF9jb25maWdfaW5pdChzLCAmZXJyKTsKLSAgICBp ZiAoZXJyKSB7Ci0gICAgICAgIGVycm9yX2FwcGVuZF9oaW50KCZlcnIsICJQQ0kgQ29uZmlnIHNw YWNlIGluaXRpYWxpc2F0aW9uIGZhaWxlZCIpOwotICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJy cCwgZXJyKTsKKyAgICB4ZW5fcHRfY29uZmlnX2luaXQocywgZXJycCk7CisgICAgaWYgKCplcnJw KSB7CisgICAgICAgIGVycm9yX2FwcGVuZF9oaW50KGVycnAsICJQQ0kgQ29uZmlnIHNwYWNlIGlu aXRpYWxpc2F0aW9uIGZhaWxlZCIpOwogICAgICAgICByYyA9IC0xOwogICAgICAgICBnb3RvIGVy cl9vdXQ7CiAgICAgfQpkaWZmIC0tZ2l0IGEvaHcveGVuL3hlbl9wdF9jb25maWdfaW5pdC5jIGIv aHcveGVuL3hlbl9wdF9jb25maWdfaW5pdC5jCmluZGV4IDMxZWM1YWRkMWQuLmFmM2ZiZDFiZmIg MTAwNjQ0Ci0tLSBhL2h3L3hlbi94ZW5fcHRfY29uZmlnX2luaXQuYworKysgYi9ody94ZW4veGVu X3B0X2NvbmZpZ19pbml0LmMKQEAgLTIwMDgsOCArMjAwOCw4IEBAIHN0YXRpYyB2b2lkIHhlbl9w dF9jb25maWdfcmVnX2luaXQoWGVuUENJUGFzc3Rocm91Z2hTdGF0ZSAqcywKIAogdm9pZCB4ZW5f cHRfY29uZmlnX2luaXQoWGVuUENJUGFzc3Rocm91Z2hTdGF0ZSAqcywgRXJyb3IgKiplcnJwKQog eworICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKICAgICBpbnQgaSwgcmM7Ci0gICAgRXJyb3Ig KmVyciA9IE5VTEw7CiAKICAgICBRTElTVF9JTklUKCZzLT5yZWdfZ3Jwcyk7CiAKQEAgLTIwNTIs MTAgKzIwNTIsOSBAQCB2b2lkIHhlbl9wdF9jb25maWdfaW5pdChYZW5QQ0lQYXNzdGhyb3VnaFN0 YXRlICpzLCBFcnJvciAqKmVycnApCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHJlZ19ncnBfb2Zmc2V0LAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAmcmVnX2dycF9lbnRyeS0+c2l6ZSk7CiAgICAgICAg ICAgICBpZiAocmMgPCAwKSB7Ci0gICAgICAgICAgICAgICAgZXJyb3Jfc2V0ZygmZXJyLCAiRmFp bGVkIHRvIGluaXRpYWxpemUgJWQvJXp1LCB0eXBlID0gMHgleCwiCisgICAgICAgICAgICAgICAg ZXJyb3Jfc2V0ZyhlcnJwLCAiRmFpbGVkIHRvIGluaXRpYWxpemUgJWQvJXp1LCB0eXBlID0gMHgl eCwiCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAiIHJjOiAlZCIsIGksIEFSUkFZX1NJWkUo eGVuX3B0X2VtdV9yZWdfZ3JwcyksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5fcHRf ZW11X3JlZ19ncnBzW2ldLmdycF90eXBlLCByYyk7Ci0gICAgICAgICAgICAgICAgZXJyb3JfcHJv cGFnYXRlKGVycnAsIGVycik7CiAgICAgICAgICAgICAgICAgeGVuX3B0X2NvbmZpZ19kZWxldGUo cyk7CiAgICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgICAgfQpAQCAtMjA2OCwxMyAr MjA2NywxNCBAQCB2b2lkIHhlbl9wdF9jb25maWdfaW5pdChYZW5QQ0lQYXNzdGhyb3VnaFN0YXRl ICpzLCBFcnJvciAqKmVycnApCiAKICAgICAgICAgICAgICAgICAvKiBpbml0aWFsaXplIGNhcGFi aWxpdHkgcmVnaXN0ZXIgKi8KICAgICAgICAgICAgICAgICBmb3IgKGogPSAwOyByZWdzLT5zaXpl ICE9IDA7IGorKywgcmVncysrKSB7Ci0gICAgICAgICAgICAgICAgICAgIHhlbl9wdF9jb25maWdf cmVnX2luaXQocywgcmVnX2dycF9lbnRyeSwgcmVncywgJmVycik7Ci0gICAgICAgICAgICAgICAg ICAgIGlmIChlcnIpIHsKLSAgICAgICAgICAgICAgICAgICAgICAgIGVycm9yX2FwcGVuZF9oaW50 KCZlcnIsICJGYWlsZWQgdG8gaW5pdCByZWdpc3RlciAlZCIKLSAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIiBvZmZzZXRzIDB4JXggaW4gZ3JwX3R5cGUgPSAweCV4ICglZC8lenUpIiwg aiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVncy0+b2Zmc2V0LCB4ZW5fcHRf ZW11X3JlZ19ncnBzW2ldLmdycF90eXBlLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBpLCBBUlJBWV9TSVpFKHhlbl9wdF9lbXVfcmVnX2dycHMpKTsKLSAgICAgICAgICAgICAgICAg ICAgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBlcnIpOworICAgICAgICAgICAgICAgICAgICB4 ZW5fcHRfY29uZmlnX3JlZ19pbml0KHMsIHJlZ19ncnBfZW50cnksIHJlZ3MsIGVycnApOworICAg ICAgICAgICAgICAgICAgICBpZiAoKmVycnApIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIGVy cm9yX2FwcGVuZF9oaW50KGVycnAsICJGYWlsZWQgdG8gaW5pdCByZWdpc3RlciAlZCIKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICIgb2Zmc2V0cyAweCV4IGluIGdy cF90eXBlID0gMHgleCAoJWQvJXp1KSIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBqLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg cmVncy0+b2Zmc2V0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg eGVuX3B0X2VtdV9yZWdfZ3Jwc1tpXS5ncnBfdHlwZSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGksIEFSUkFZX1NJWkUoeGVuX3B0X2VtdV9yZWdfZ3JwcykpOwog ICAgICAgICAgICAgICAgICAgICAgICAgeGVuX3B0X2NvbmZpZ19kZWxldGUocyk7CiAgICAgICAg ICAgICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgICAgICAgICAgICAgIH0KLS0gCjIuMjEu MAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1k ZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCmh0dHBzOi8v bGlzdHMueGVucHJvamVjdC5vcmcvbWFpbG1hbi9saXN0aW5mby94ZW4tZGV2ZWw=