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 21DC4C3F2CD for ; Fri, 6 Mar 2020 05:22:28 +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 D5D532072D for ; Fri, 6 Mar 2020 05:22:27 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D5D532072D 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]:59674 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jA5RL-0001sK-3j for qemu-devel@archiver.kernel.org; Fri, 06 Mar 2020 00:22:27 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:52006) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1jA5L1-0008ON-UV for qemu-devel@nongnu.org; Fri, 06 Mar 2020 00:15:59 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1jA5Ky-0000pQ-9o for qemu-devel@nongnu.org; Fri, 06 Mar 2020 00:15:55 -0500 Received: from relay.sw.ru ([185.231.240.75]:34034) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1jA5Kx-0000iJ-Sd; Fri, 06 Mar 2020 00:15:52 -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 1jA5Ko-0001tg-6u; Fri, 06 Mar 2020 08:15:42 +0300 From: Vladimir Sementsov-Ogievskiy To: qemu-devel@nongnu.org Subject: [PATCH v8 10/10] xen: introduce ERRP_AUTO_PROPAGATE Date: Fri, 6 Mar 2020 08:15:36 +0300 Message-Id: <20200306051536.27803-11-vsementsov@virtuozzo.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20200306051536.27803-1-vsementsov@virtuozzo.com> References: <20200306051536.27803-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 , vsementsov@virtuozzo.com, qemu-block@nongnu.org, Paul Durrant , armbru@redhat.com, Greg Kurz , Stefano Stabellini , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz 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 | 92 ++++++++++-------------- 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, 138 insertions(+), 182 deletions(-) diff --git a/hw/block/dataplane/xen-block.c b/hw/block/dataplane/xen-block.c index 288a87a814..3a8469fe87 100644 --- a/hw/block/dataplane/xen-block.c +++ b/hw/block/dataplane/xen-block.c @@ -739,8 +739,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; @@ -776,9 +776,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; } @@ -786,9 +785,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; } @@ -821,9 +819,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, dataplane->event_channel = xen_device_bind_event_channel(xendev, 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 686bbc3f0d..717a80d5b5 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 18237b34ea..97259c964b 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); } } @@ -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: "); } } @@ -1247,11 +1237,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; @@ -1267,10 +1257,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; } @@ -1293,22 +1282,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 b91082cb8b..f57b81588e 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 02CBDC3F2D9 for ; Fri, 6 Mar 2020 05:16:42 +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 BFB5B20848 for ; Fri, 6 Mar 2020 05:16:41 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org BFB5B20848 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 1jA5LG-0005Tn-BY; Fri, 06 Mar 2020 05:16:10 +0000 Received: from us1-rack-iad1.inumbo.com ([172.99.69.81]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1jA5LF-0005TU-Rm for xen-devel@lists.xenproject.org; Fri, 06 Mar 2020 05:16:09 +0000 X-Inumbo-ID: 94065dc6-5f69-11ea-b74d-bc764e2007e4 Received: from relay.sw.ru (unknown [185.231.240.75]) by us1-rack-iad1.inumbo.com (Halon) with ESMTPS id 94065dc6-5f69-11ea-b74d-bc764e2007e4; Fri, 06 Mar 2020 05:16:05 +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 1jA5Ko-0001tg-6u; Fri, 06 Mar 2020 08:15:42 +0300 From: Vladimir Sementsov-Ogievskiy To: qemu-devel@nongnu.org Date: Fri, 6 Mar 2020 08:15:36 +0300 Message-Id: <20200306051536.27803-11-vsementsov@virtuozzo.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20200306051536.27803-1-vsementsov@virtuozzo.com> References: <20200306051536.27803-1-vsementsov@virtuozzo.com> MIME-Version: 1.0 Subject: [Xen-devel] [PATCH v8 10/10] 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 , vsementsov@virtuozzo.com, qemu-block@nongnu.org, Paul Durrant , armbru@redhat.com, Greg Kurz , Stefano Stabellini , Stefan Hajnoczi , Anthony Perard , xen-devel@lists.xenproject.org, Max Reitz 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 L3hlbi94ZW4tYnVzLmMgICAgICAgICAgICAgICB8ICA5MiArKysrKysrKysrLS0tLS0tLS0tLS0t LS0KIGh3L3hlbi94ZW4taG9zdC1wY2ktZGV2aWNlLmMgICB8ICAyNyArKysrLS0tCiBody94ZW4v eGVuX3B0LmMgICAgICAgICAgICAgICAgfCAgMjUgKysrLS0tLQogaHcveGVuL3hlbl9wdF9jb25m aWdfaW5pdC5jICAgIHwgIDIwICsrKy0tLQogOCBmaWxlcyBjaGFuZ2VkLCAxMzggaW5zZXJ0aW9u cygrKSwgMTgyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2h3L2Jsb2NrL2RhdGFwbGFuZS94 ZW4tYmxvY2suYyBiL2h3L2Jsb2NrL2RhdGFwbGFuZS94ZW4tYmxvY2suYwppbmRleCAyODhhODdh ODE0Li4zYTg0NjlmZTg3IDEwMDY0NAotLS0gYS9ody9ibG9jay9kYXRhcGxhbmUveGVuLWJsb2Nr LmMKKysrIGIvaHcvYmxvY2svZGF0YXBsYW5lL3hlbi1ibG9jay5jCkBAIC03MzksOCArNzM5LDgg QEAgdm9pZCB4ZW5fYmxvY2tfZGF0YXBsYW5lX3N0YXJ0KFhlbkJsb2NrRGF0YVBsYW5lICpkYXRh cGxhbmUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdW5zaWduZWQgaW50IHByb3Rv Y29sLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEVycm9yICoqZXJycCkKIHsKKyAg ICBFUlJQX0FVVE9fUFJPUEFHQVRFKCk7CiAgICAgWGVuRGV2aWNlICp4ZW5kZXYgPSBkYXRhcGxh bmUtPnhlbmRldjsKLSAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKICAgICB1bnNpZ25lZCBp bnQgcmluZ19zaXplOwogICAgIHVuc2lnbmVkIGludCBpOwogCkBAIC03NzYsOSArNzc2LDggQEAg dm9pZCB4ZW5fYmxvY2tfZGF0YXBsYW5lX3N0YXJ0KFhlbkJsb2NrRGF0YVBsYW5lICpkYXRhcGxh bmUsCiAgICAgfQogCiAgICAgeGVuX2RldmljZV9zZXRfbWF4X2dyYW50X3JlZnMoeGVuZGV2LCBk YXRhcGxhbmUtPm5yX3JpbmdfcmVmLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICZsb2NhbF9lcnIpOwotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFn YXRlKGVycnAsIGxvY2FsX2Vycik7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ZXJycCk7CisgICAgaWYgKCplcnJwKSB7CiAgICAgICAgIGdvdG8gc3RvcDsKICAgICB9CiAKQEAg LTc4Niw5ICs3ODUsOCBAQCB2b2lkIHhlbl9ibG9ja19kYXRhcGxhbmVfc3RhcnQoWGVuQmxvY2tE YXRhUGxhbmUgKmRhdGFwbGFuZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBkYXRhcGxhbmUtPnJpbmdfcmVmLAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGRhdGFwbGFuZS0+bnJfcmluZ19yZWYsCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUFJPVF9SRUFEIHwgUFJPVF9XUklU RSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmbG9jYWxf ZXJyKTsKLSAgICBpZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJw LCBsb2NhbF9lcnIpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGVycnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICBnb3RvIHN0b3A7CiAgICAgfQog CkBAIC04MjEsOSArODE5LDggQEAgdm9pZCB4ZW5fYmxvY2tfZGF0YXBsYW5lX3N0YXJ0KFhlbkJs b2NrRGF0YVBsYW5lICpkYXRhcGxhbmUsCiAgICAgZGF0YXBsYW5lLT5ldmVudF9jaGFubmVsID0K ICAgICAgICAgeGVuX2RldmljZV9iaW5kX2V2ZW50X2NoYW5uZWwoeGVuZGV2LCBldmVudF9jaGFu bmVsLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5fYmxvY2tfZGF0 YXBsYW5lX2V2ZW50LCBkYXRhcGxhbmUsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICZsb2NhbF9lcnIpOwotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3Jf cHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGVycnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICBnb3RvIHN0b3A7CiAg ICAgfQogCmRpZmYgLS1naXQgYS9ody9ibG9jay94ZW4tYmxvY2suYyBiL2h3L2Jsb2NrL3hlbi1i bG9jay5jCmluZGV4IDY4NmJiYzNmMGQuLjcxN2E4MGQ1YjUgMTAwNjQ0Ci0tLSBhL2h3L2Jsb2Nr L3hlbi1ibG9jay5jCisrKyBiL2h3L2Jsb2NrL3hlbi1ibG9jay5jCkBAIC0xOTQsNiArMTk0LDcg QEAgc3RhdGljIGNvbnN0IEJsb2NrRGV2T3BzIHhlbl9ibG9ja19kZXZfb3BzID0gewogCiBzdGF0 aWMgdm9pZCB4ZW5fYmxvY2tfcmVhbGl6ZShYZW5EZXZpY2UgKnhlbmRldiwgRXJyb3IgKiplcnJw KQogeworICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKICAgICBYZW5CbG9ja0RldmljZSAqYmxv Y2tkZXYgPSBYRU5fQkxPQ0tfREVWSUNFKHhlbmRldik7CiAgICAgWGVuQmxvY2tEZXZpY2VDbGFz cyAqYmxvY2tkZXZfY2xhc3MgPQogICAgICAgICBYRU5fQkxPQ0tfREVWSUNFX0dFVF9DTEFTUyh4 ZW5kZXYpOwpAQCAtMjAxLDcgKzIwMiw2IEBAIHN0YXRpYyB2b2lkIHhlbl9ibG9ja19yZWFsaXpl KFhlbkRldmljZSAqeGVuZGV2LCBFcnJvciAqKmVycnApCiAgICAgWGVuQmxvY2tWZGV2ICp2ZGV2 ID0gJmJsb2NrZGV2LT5wcm9wcy52ZGV2OwogICAgIEJsb2NrQ29uZiAqY29uZiA9ICZibG9ja2Rl di0+cHJvcHMuY29uZjsKICAgICBCbG9ja0JhY2tlbmQgKmJsayA9IGNvbmYtPmJsazsKLSAgICBF cnJvciAqbG9jYWxfZXJyID0gTlVMTDsKIAogICAgIGlmICh2ZGV2LT50eXBlID09IFhFTl9CTE9D S19WREVWX1RZUEVfSU5WQUxJRCkgewogICAgICAgICBlcnJvcl9zZXRnKGVycnAsICJ2ZGV2IHBy b3BlcnR5IG5vdCBzZXQiKTsKQEAgLTIxMSw5ICsyMTEsOCBAQCBzdGF0aWMgdm9pZCB4ZW5fYmxv Y2tfcmVhbGl6ZShYZW5EZXZpY2UgKnhlbmRldiwgRXJyb3IgKiplcnJwKQogICAgIHRyYWNlX3hl bl9ibG9ja19yZWFsaXplKHR5cGUsIHZkZXYtPmRpc2ssIHZkZXYtPnBhcnRpdGlvbik7CiAKICAg ICBpZiAoYmxvY2tkZXZfY2xhc3MtPnJlYWxpemUpIHsKLSAgICAgICAgYmxvY2tkZXZfY2xhc3Mt PnJlYWxpemUoYmxvY2tkZXYsICZsb2NhbF9lcnIpOwotICAgICAgICBpZiAobG9jYWxfZXJyKSB7 Ci0gICAgICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKKyAgICAgICAg YmxvY2tkZXZfY2xhc3MtPnJlYWxpemUoYmxvY2tkZXYsIGVycnApOworICAgICAgICBpZiAoKmVy cnApIHsKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQogICAgIH0KQEAgLTI4Myw4ICsy ODIsOCBAQCBzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfZnJvbnRlbmRfY2hhbmdlZChYZW5EZXZpY2Ug KnhlbmRldiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVudW0geGVu YnVzX3N0YXRlIGZyb250ZW5kX3N0YXRlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgRXJyb3IgKiplcnJwKQogeworICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKICAg ICBlbnVtIHhlbmJ1c19zdGF0ZSBiYWNrZW5kX3N0YXRlID0geGVuX2RldmljZV9iYWNrZW5kX2dl dF9zdGF0ZSh4ZW5kZXYpOwotICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwogCiAgICAgc3dp dGNoIChmcm9udGVuZF9zdGF0ZSkgewogICAgIGNhc2UgWGVuYnVzU3RhdGVJbml0aWFsaXNlZDoK QEAgLTI5MywxNSArMjkyLDEzIEBAIHN0YXRpYyB2b2lkIHhlbl9ibG9ja19mcm9udGVuZF9jaGFu Z2VkKFhlbkRldmljZSAqeGVuZGV2LAogICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgIH0KIAot ICAgICAgICB4ZW5fYmxvY2tfZGlzY29ubmVjdCh4ZW5kZXYsICZsb2NhbF9lcnIpOwotICAgICAg ICBpZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9j YWxfZXJyKTsKKyAgICAgICAgeGVuX2Jsb2NrX2Rpc2Nvbm5lY3QoeGVuZGV2LCBlcnJwKTsKKyAg ICAgICAgaWYgKCplcnJwKSB7CiAgICAgICAgICAgICBicmVhazsKICAgICAgICAgfQogCi0gICAg ICAgIHhlbl9ibG9ja19jb25uZWN0KHhlbmRldiwgJmxvY2FsX2Vycik7Ci0gICAgICAgIGlmIChs b2NhbF9lcnIpIHsKLSAgICAgICAgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9lcnIp OworICAgICAgICB4ZW5fYmxvY2tfY29ubmVjdCh4ZW5kZXYsIGVycnApOworICAgICAgICBpZiAo KmVycnApIHsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICB9CiAKQEAgLTMxNCw5ICszMTEs OCBAQCBzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfZnJvbnRlbmRfY2hhbmdlZChYZW5EZXZpY2UgKnhl bmRldiwKIAogICAgIGNhc2UgWGVuYnVzU3RhdGVDbG9zZWQ6CiAgICAgY2FzZSBYZW5idXNTdGF0 ZVVua25vd246Ci0gICAgICAgIHhlbl9ibG9ja19kaXNjb25uZWN0KHhlbmRldiwgJmxvY2FsX2Vy cik7Ci0gICAgICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgICAgIGVycm9yX3Byb3BhZ2F0 ZShlcnJwLCBsb2NhbF9lcnIpOworICAgICAgICB4ZW5fYmxvY2tfZGlzY29ubmVjdCh4ZW5kZXYs IGVycnApOworICAgICAgICBpZiAoKmVycnApIHsKICAgICAgICAgICAgIGJyZWFrOwogICAgICAg ICB9CiAKQEAgLTQwMywxMCArMzk5LDEwIEBAIHN0YXRpYyBpbnQgdmJkX25hbWVfdG9fZGlzayhj b25zdCBjaGFyICpuYW1lLCBjb25zdCBjaGFyICoqZW5kcCwKIHN0YXRpYyB2b2lkIHhlbl9ibG9j a19zZXRfdmRldihPYmplY3QgKm9iaiwgVmlzaXRvciAqdiwgY29uc3QgY2hhciAqbmFtZSwKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2b2lkICpvcGFxdWUsIEVycm9yICoqZXJycCkK IHsKKyAgICBFUlJQX0FVVE9fUFJPUEFHQVRFKCk7CiAgICAgRGV2aWNlU3RhdGUgKmRldiA9IERF VklDRShvYmopOwogICAgIFByb3BlcnR5ICpwcm9wID0gb3BhcXVlOwogICAgIFhlbkJsb2NrVmRl diAqdmRldiA9IHFkZXZfZ2V0X3Byb3BfcHRyKGRldiwgcHJvcCk7Ci0gICAgRXJyb3IgKmxvY2Fs X2VyciA9IE5VTEw7CiAgICAgY2hhciAqc3RyLCAqcDsKICAgICBjb25zdCBjaGFyICplbmQ7CiAK QEAgLTQxNSw5ICs0MTEsOCBAQCBzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfc2V0X3ZkZXYoT2JqZWN0 ICpvYmosIFZpc2l0b3IgKnYsIGNvbnN0IGNoYXIgKm5hbWUsCiAgICAgICAgIHJldHVybjsKICAg ICB9CiAKLSAgICB2aXNpdF90eXBlX3N0cih2LCBuYW1lLCAmc3RyLCAmbG9jYWxfZXJyKTsKLSAg ICBpZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBsb2NhbF9l cnIpOworICAgIHZpc2l0X3R5cGVfc3RyKHYsIG5hbWUsICZzdHIsIGVycnApOworICAgIGlmICgq ZXJycCkgewogICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC02NzEsOSArNjY2LDkgQEAgc3Rh dGljIHZvaWQgeGVuX2Jsb2NrX2Jsb2NrZGV2X2RlbChjb25zdCBjaGFyICpub2RlX25hbWUsIEVy cm9yICoqZXJycCkKIHN0YXRpYyBjaGFyICp4ZW5fYmxvY2tfYmxvY2tkZXZfYWRkKGNvbnN0IGNo YXIgKmlkLCBRRGljdCAqcWRpY3QsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBFcnJvciAqKmVycnApCiB7CisgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIGNvbnN0 IGNoYXIgKmRyaXZlciA9IHFkaWN0X2dldF90cnlfc3RyKHFkaWN0LCAiZHJpdmVyIik7CiAgICAg QmxvY2tkZXZPcHRpb25zICpvcHRpb25zID0gTlVMTDsKLSAgICBFcnJvciAqbG9jYWxfZXJyID0g TlVMTDsKICAgICBjaGFyICpub2RlX25hbWU7CiAgICAgVmlzaXRvciAqdjsKIApAQCAtNjg4LDE4 ICs2ODMsMTYgQEAgc3RhdGljIGNoYXIgKnhlbl9ibG9ja19ibG9ja2Rldl9hZGQoY29uc3QgY2hh ciAqaWQsIFFEaWN0ICpxZGljdCwKICAgICB0cmFjZV94ZW5fYmxvY2tfYmxvY2tkZXZfYWRkKG5v ZGVfbmFtZSk7CiAKICAgICB2ID0gcW9iamVjdF9pbnB1dF92aXNpdG9yX25ldyhRT0JKRUNUKHFk aWN0KSk7Ci0gICAgdmlzaXRfdHlwZV9CbG9ja2Rldk9wdGlvbnModiwgTlVMTCwgJm9wdGlvbnMs ICZsb2NhbF9lcnIpOworICAgIHZpc2l0X3R5cGVfQmxvY2tkZXZPcHRpb25zKHYsIE5VTEwsICZv cHRpb25zLCBlcnJwKTsKICAgICB2aXNpdF9mcmVlKHYpOwogCi0gICAgaWYgKGxvY2FsX2Vycikg ewotICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKKyAgICBpZiAoKmVy cnApIHsKICAgICAgICAgZ290byBmYWlsOwogICAgIH0KIAotICAgIHFtcF9ibG9ja2Rldl9hZGQo b3B0aW9ucywgJmxvY2FsX2Vycik7CisgICAgcW1wX2Jsb2NrZGV2X2FkZChvcHRpb25zLCBlcnJw KTsKIAotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAs IGxvY2FsX2Vycik7CisgICAgaWYgKCplcnJwKSB7CiAgICAgICAgIGdvdG8gZmFpbDsKICAgICB9 CiAKQEAgLTcxOCwxNCArNzExLDEyIEBAIGZhaWw6CiAKIHN0YXRpYyB2b2lkIHhlbl9ibG9ja19k cml2ZV9kZXN0cm95KFhlbkJsb2NrRHJpdmUgKmRyaXZlLCBFcnJvciAqKmVycnApCiB7CisgICAg RVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIGNoYXIgKm5vZGVfbmFtZSA9IGRyaXZlLT5ub2Rl X25hbWU7CiAKICAgICBpZiAobm9kZV9uYW1lKSB7Ci0gICAgICAgIEVycm9yICpsb2NhbF9lcnIg PSBOVUxMOwotCi0gICAgICAgIHhlbl9ibG9ja19ibG9ja2Rldl9kZWwobm9kZV9uYW1lLCAmbG9j YWxfZXJyKTsKLSAgICAgICAgaWYgKGxvY2FsX2VycikgewotICAgICAgICAgICAgZXJyb3JfcHJv cGFnYXRlKGVycnAsIGxvY2FsX2Vycik7CisgICAgICAgIHhlbl9ibG9ja19ibG9ja2Rldl9kZWwo bm9kZV9uYW1lLCBlcnJwKTsKKyAgICAgICAgaWYgKCplcnJwKSB7CiAgICAgICAgICAgICByZXR1 cm47CiAgICAgICAgIH0KICAgICAgICAgZ19mcmVlKG5vZGVfbmFtZSk7CkBAIC03MzksNiArNzMw LDcgQEAgc3RhdGljIFhlbkJsb2NrRHJpdmUgKnhlbl9ibG9ja19kcml2ZV9jcmVhdGUoY29uc3Qg Y2hhciAqaWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBj b25zdCBjaGFyICpkZXZpY2VfdHlwZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIFFEaWN0ICpvcHRzLCBFcnJvciAqKmVycnApCiB7CisgICAgRVJSUF9BVVRP X1BST1BBR0FURSgpOwogICAgIGNvbnN0IGNoYXIgKnBhcmFtcyA9IHFkaWN0X2dldF90cnlfc3Ry KG9wdHMsICJwYXJhbXMiKTsKICAgICBjb25zdCBjaGFyICptb2RlID0gcWRpY3RfZ2V0X3RyeV9z dHIob3B0cywgIm1vZGUiKTsKICAgICBjb25zdCBjaGFyICpkaXJlY3RfaW9fc2FmZSA9IHFkaWN0 X2dldF90cnlfc3RyKG9wdHMsICJkaXJlY3QtaW8tc2FmZSIpOwpAQCAtNzQ2LDcgKzczOCw2IEBA IHN0YXRpYyBYZW5CbG9ja0RyaXZlICp4ZW5fYmxvY2tfZHJpdmVfY3JlYXRlKGNvbnN0IGNoYXIg KmlkLAogICAgIGNoYXIgKmRyaXZlciA9IE5VTEw7CiAgICAgY2hhciAqZmlsZW5hbWUgPSBOVUxM OwogICAgIFhlbkJsb2NrRHJpdmUgKmRyaXZlID0gTlVMTDsKLSAgICBFcnJvciAqbG9jYWxfZXJy ID0gTlVMTDsKICAgICBRRGljdCAqZmlsZV9sYXllcjsKICAgICBRRGljdCAqZHJpdmVyX2xheWVy OwogCkBAIC04MjUsMTMgKzgxNiwxMiBAQCBzdGF0aWMgWGVuQmxvY2tEcml2ZSAqeGVuX2Jsb2Nr X2RyaXZlX2NyZWF0ZShjb25zdCBjaGFyICppZCwKIAogICAgIGdfYXNzZXJ0KCFkcml2ZS0+bm9k ZV9uYW1lKTsKICAgICBkcml2ZS0+bm9kZV9uYW1lID0geGVuX2Jsb2NrX2Jsb2NrZGV2X2FkZChk cml2ZS0+aWQsIGRyaXZlcl9sYXllciwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAmbG9jYWxfZXJyKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBlcnJwKTsKIAogICAgIHFvYmplY3RfdW5yZWYoZHJpdmVyX2xheWVy KTsKIAogZG9uZToKLSAgICBpZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgIGVycm9yX3Byb3BhZ2F0 ZShlcnJwLCBsb2NhbF9lcnIpOworICAgIGlmICgqZXJycCkgewogICAgICAgICB4ZW5fYmxvY2tf ZHJpdmVfZGVzdHJveShkcml2ZSwgTlVMTCk7CiAgICAgICAgIHJldHVybiBOVUxMOwogICAgIH0K QEAgLTg1NiwxNSArODQ2LDEzIEBAIHN0YXRpYyB2b2lkIHhlbl9ibG9ja19pb3RocmVhZF9kZXN0 cm95KFhlbkJsb2NrSU9UaHJlYWQgKmlvdGhyZWFkLAogc3RhdGljIFhlbkJsb2NrSU9UaHJlYWQg Knhlbl9ibG9ja19pb3RocmVhZF9jcmVhdGUoY29uc3QgY2hhciAqaWQsCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBFcnJvciAqKmVycnApCiB7Cisg ICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIFhlbkJsb2NrSU9UaHJlYWQgKmlvdGhyZWFk ID0gZ19uZXcoWGVuQmxvY2tJT1RocmVhZCwgMSk7Ci0gICAgRXJyb3IgKmxvY2FsX2VyciA9IE5V TEw7CiAKICAgICBpb3RocmVhZC0+aWQgPSBnX3N0cmR1cChpZCk7CiAKLSAgICBxbXBfb2JqZWN0 X2FkZChUWVBFX0lPVEhSRUFELCBpZCwgZmFsc2UsIE5VTEwsICZsb2NhbF9lcnIpOwotICAgIGlm IChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7 Ci0KKyAgICBxbXBfb2JqZWN0X2FkZChUWVBFX0lPVEhSRUFELCBpZCwgZmFsc2UsIE5VTEwsIGVy cnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICBnX2ZyZWUoaW90aHJlYWQtPmlkKTsKICAg ICAgICAgZ19mcmVlKGlvdGhyZWFkKTsKICAgICAgICAgcmV0dXJuIE5VTEw7CkBAIC04NzYsNiAr ODY0LDcgQEAgc3RhdGljIFhlbkJsb2NrSU9UaHJlYWQgKnhlbl9ibG9ja19pb3RocmVhZF9jcmVh dGUoY29uc3QgY2hhciAqaWQsCiBzdGF0aWMgdm9pZCB4ZW5fYmxvY2tfZGV2aWNlX2NyZWF0ZShY ZW5CYWNrZW5kSW5zdGFuY2UgKmJhY2tlbmQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBRRGljdCAqb3B0cywgRXJyb3IgKiplcnJwKQogeworICAgIEVSUlBfQVVUT19QUk9Q QUdBVEUoKTsKICAgICBYZW5CdXMgKnhlbmJ1cyA9IHhlbl9iYWNrZW5kX2dldF9idXMoYmFja2Vu ZCk7CiAgICAgY29uc3QgY2hhciAqbmFtZSA9IHhlbl9iYWNrZW5kX2dldF9uYW1lKGJhY2tlbmQp OwogICAgIHVuc2lnbmVkIGxvbmcgbnVtYmVyOwpAQCAtODgzLDcgKzg3Miw2IEBAIHN0YXRpYyB2 b2lkIHhlbl9ibG9ja19kZXZpY2VfY3JlYXRlKFhlbkJhY2tlbmRJbnN0YW5jZSAqYmFja2VuZCwK ICAgICBYZW5CbG9ja0RyaXZlICpkcml2ZSA9IE5VTEw7CiAgICAgWGVuQmxvY2tJT1RocmVhZCAq aW90aHJlYWQgPSBOVUxMOwogICAgIFhlbkRldmljZSAqeGVuZGV2ID0gTlVMTDsKLSAgICBFcnJv ciAqbG9jYWxfZXJyID0gTlVMTDsKICAgICBjb25zdCBjaGFyICp0eXBlOwogICAgIFhlbkJsb2Nr RGV2aWNlICpibG9ja2RldjsKIApAQCAtOTE1LDUyICs5MDMsNDggQEAgc3RhdGljIHZvaWQgeGVu X2Jsb2NrX2RldmljZV9jcmVhdGUoWGVuQmFja2VuZEluc3RhbmNlICpiYWNrZW5kLAogICAgICAg ICBnb3RvIGZhaWw7CiAgICAgfQogCi0gICAgZHJpdmUgPSB4ZW5fYmxvY2tfZHJpdmVfY3JlYXRl KHZkZXYsIGRldmljZV90eXBlLCBvcHRzLCAmbG9jYWxfZXJyKTsKKyAgICBkcml2ZSA9IHhlbl9i bG9ja19kcml2ZV9jcmVhdGUodmRldiwgZGV2aWNlX3R5cGUsIG9wdHMsIGVycnApOwogICAgIGlm ICghZHJpdmUpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxf ZXJyLCAiZmFpbGVkIHRvIGNyZWF0ZSBkcml2ZTogIik7CisgICAgICAgIGVycm9yX3ByZXBlbmQo ZXJycCwgImZhaWxlZCB0byBjcmVhdGUgZHJpdmU6ICIpOwogICAgICAgICBnb3RvIGZhaWw7CiAg ICAgfQogCi0gICAgaW90aHJlYWQgPSB4ZW5fYmxvY2tfaW90aHJlYWRfY3JlYXRlKHZkZXYsICZs b2NhbF9lcnIpOwotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRl X3ByZXBlbmQoZXJycCwgbG9jYWxfZXJyLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAiZmFpbGVkIHRvIGNyZWF0ZSBpb3RocmVhZDogIik7CisgICAgaW90aHJlYWQgPSB4ZW5fYmxv Y2tfaW90aHJlYWRfY3JlYXRlKHZkZXYsIGVycnApOworICAgIGlmICgqZXJycCkgeworICAgICAg ICBlcnJvcl9wcmVwZW5kKGVycnAsICJmYWlsZWQgdG8gY3JlYXRlIGlvdGhyZWFkOiAiKTsKICAg ICAgICAgZ290byBmYWlsOwogICAgIH0KIAogICAgIHhlbmRldiA9IFhFTl9ERVZJQ0UocWRldl9j cmVhdGUoQlVTKHhlbmJ1cyksIHR5cGUpKTsKICAgICBibG9ja2RldiA9IFhFTl9CTE9DS19ERVZJ Q0UoeGVuZGV2KTsKIAotICAgIG9iamVjdF9wcm9wZXJ0eV9zZXRfc3RyKE9CSkVDVCh4ZW5kZXYp LCB2ZGV2LCAidmRldiIsICZsb2NhbF9lcnIpOwotICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAg ICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxfZXJyLCAiZmFpbGVkIHRvIHNl dCAndmRldic6ICIpOworICAgIG9iamVjdF9wcm9wZXJ0eV9zZXRfc3RyKE9CSkVDVCh4ZW5kZXYp LCB2ZGV2LCAidmRldiIsIGVycnApOworICAgIGlmICgqZXJycCkgeworICAgICAgICBlcnJvcl9w cmVwZW5kKGVycnAsICJmYWlsZWQgdG8gc2V0ICd2ZGV2JzogIik7CiAgICAgICAgIGdvdG8gZmFp bDsKICAgICB9CiAKICAgICBvYmplY3RfcHJvcGVydHlfc2V0X3N0cihPQkpFQ1QoeGVuZGV2KSwK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5fYmxvY2tfZHJpdmVfZ2V0X25vZGVfbmFt ZShkcml2ZSksICJkcml2ZSIsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgJmxvY2FsX2Vy cik7Ci0gICAgaWYgKGxvY2FsX2VycikgewotICAgICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVu ZChlcnJwLCBsb2NhbF9lcnIsICJmYWlsZWQgdG8gc2V0ICdkcml2ZSc6ICIpOworICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGVycnApOworICAgIGlmICgqZXJycCkgeworICAgICAgICBlcnJv cl9wcmVwZW5kKGVycnAsICJmYWlsZWQgdG8gc2V0ICdkcml2ZSc6ICIpOwogICAgICAgICBnb3Rv IGZhaWw7CiAgICAgfQogCiAgICAgb2JqZWN0X3Byb3BlcnR5X3NldF9zdHIoT0JKRUNUKHhlbmRl diksIGlvdGhyZWFkLT5pZCwgImlvdGhyZWFkIiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAg ICAmbG9jYWxfZXJyKTsKLSAgICBpZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgIGVycm9yX3Byb3Bh Z2F0ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwKLSAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgImZhaWxlZCB0byBzZXQgJ2lvdGhyZWFkJzogIik7CisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgZXJycCk7CisgICAgaWYgKCplcnJwKSB7CisgICAgICAgIGVycm9yX3ByZXBlbmQo ZXJycCwgImZhaWxlZCB0byBzZXQgJ2lvdGhyZWFkJzogIik7CiAgICAgICAgIGdvdG8gZmFpbDsK ICAgICB9CiAKICAgICBibG9ja2Rldi0+aW90aHJlYWQgPSBpb3RocmVhZDsKICAgICBibG9ja2Rl di0+ZHJpdmUgPSBkcml2ZTsKIAotICAgIG9iamVjdF9wcm9wZXJ0eV9zZXRfYm9vbChPQkpFQ1Qo eGVuZGV2KSwgdHJ1ZSwgInJlYWxpemVkIiwgJmxvY2FsX2Vycik7Ci0gICAgaWYgKGxvY2FsX2Vy cikgewotICAgICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCBsb2NhbF9lcnIsCi0g ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJyZWFsaXphdGlvbiBvZiBkZXZpY2UgJXMg ZmFpbGVkOiAiLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0eXBlKTsKKyAgICBv YmplY3RfcHJvcGVydHlfc2V0X2Jvb2woT0JKRUNUKHhlbmRldiksIHRydWUsICJyZWFsaXplZCIs IGVycnApOworICAgIGlmICgqZXJycCkgeworICAgICAgICBlcnJvcl9wcmVwZW5kKGVycnAsICJy ZWFsaXphdGlvbiBvZiBkZXZpY2UgJXMgZmFpbGVkOiAiLCB0eXBlKTsKICAgICAgICAgZ290byBm YWlsOwogICAgIH0KIApAQCAtOTg0LDYgKzk2OCw3IEBAIGZhaWw6CiBzdGF0aWMgdm9pZCB4ZW5f YmxvY2tfZGV2aWNlX2Rlc3Ryb3koWGVuQmFja2VuZEluc3RhbmNlICpiYWNrZW5kLAogICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEVycm9yICoqZXJycCkKIHsKKyAgICBFUlJQ X0FVVE9fUFJPUEFHQVRFKCk7CiAgICAgWGVuRGV2aWNlICp4ZW5kZXYgPSB4ZW5fYmFja2VuZF9n ZXRfZGV2aWNlKGJhY2tlbmQpOwogICAgIFhlbkJsb2NrRGV2aWNlICpibG9ja2RldiA9IFhFTl9C TE9DS19ERVZJQ0UoeGVuZGV2KTsKICAgICBYZW5CbG9ja1ZkZXYgKnZkZXYgPSAmYmxvY2tkZXYt PnByb3BzLnZkZXY7CkBAIC05OTUsMjMgKzk4MCwxNyBAQCBzdGF0aWMgdm9pZCB4ZW5fYmxvY2tf ZGV2aWNlX2Rlc3Ryb3koWGVuQmFja2VuZEluc3RhbmNlICpiYWNrZW5kLAogICAgIG9iamVjdF91 bnBhcmVudChPQkpFQ1QoeGVuZGV2KSk7CiAKICAgICBpZiAoaW90aHJlYWQpIHsKLSAgICAgICAg RXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7Ci0KLSAgICAgICAgeGVuX2Jsb2NrX2lvdGhyZWFkX2Rl c3Ryb3koaW90aHJlYWQsICZsb2NhbF9lcnIpOwotICAgICAgICBpZiAobG9jYWxfZXJyKSB7Ci0g ICAgICAgICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCBsb2NhbF9lcnIsCi0gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICJmYWlsZWQgdG8gZGVzdHJveSBpb3RocmVhZDog Iik7CisgICAgICAgIHhlbl9ibG9ja19pb3RocmVhZF9kZXN0cm95KGlvdGhyZWFkLCBlcnJwKTsK KyAgICAgICAgaWYgKCplcnJwKSB7CisgICAgICAgICAgICBlcnJvcl9wcmVwZW5kKGVycnAsICJm YWlsZWQgdG8gZGVzdHJveSBpb3RocmVhZDogIik7CiAgICAgICAgICAgICByZXR1cm47CiAgICAg ICAgIH0KICAgICB9CiAKICAgICBpZiAoZHJpdmUpIHsKLSAgICAgICAgRXJyb3IgKmxvY2FsX2Vy ciA9IE5VTEw7Ci0KLSAgICAgICAgeGVuX2Jsb2NrX2RyaXZlX2Rlc3Ryb3koZHJpdmUsICZsb2Nh bF9lcnIpOwotICAgICAgICBpZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgICAgICBlcnJvcl9wcm9w YWdhdGVfcHJlcGVuZChlcnJwLCBsb2NhbF9lcnIsCi0gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICJmYWlsZWQgdG8gZGVzdHJveSBkcml2ZTogIik7CisgICAgICAgIHhlbl9ibG9ja19k cml2ZV9kZXN0cm95KGRyaXZlLCBlcnJwKTsKKyAgICAgICAgaWYgKCplcnJwKSB7CisgICAgICAg ICAgICBlcnJvcl9wcmVwZW5kKGVycnAsICJmYWlsZWQgdG8gZGVzdHJveSBkcml2ZTogIik7CiAg ICAgICAgIH0KICAgICB9CiB9CmRpZmYgLS1naXQgYS9ody9wY2ktaG9zdC94ZW5faWdkX3B0LmMg Yi9ody9wY2ktaG9zdC94ZW5faWdkX3B0LmMKaW5kZXggZWZjYzkzNDdmZi4uMjlhZGU5Y2EyNSAx MDA2NDQKLS0tIGEvaHcvcGNpLWhvc3QveGVuX2lnZF9wdC5jCisrKyBiL2h3L3BjaS1ob3N0L3hl bl9pZ2RfcHQuYwpAQCAtNzksMTcgKzc5LDE2IEBAIHN0YXRpYyB2b2lkIGhvc3RfcGNpX2NvbmZp Z19yZWFkKGludCBwb3MsIGludCBsZW4sIHVpbnQzMl90ICp2YWwsIEVycm9yICoqZXJycCkKIAog c3RhdGljIHZvaWQgaWdkX3B0X2k0NDBmeF9yZWFsaXplKFBDSURldmljZSAqcGNpX2RldiwgRXJy b3IgKiplcnJwKQogeworICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKICAgICB1aW50MzJfdCB2 YWwgPSAwOwogICAgIHNpemVfdCBpOwogICAgIGludCBwb3MsIGxlbjsKLSAgICBFcnJvciAqbG9j YWxfZXJyID0gTlVMTDsKIAogICAgIGZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGlnZF9ob3N0 X2JyaWRnZV9pbmZvcyk7IGkrKykgewogICAgICAgICBwb3MgPSBpZ2RfaG9zdF9icmlkZ2VfaW5m b3NbaV0ub2Zmc2V0OwogICAgICAgICBsZW4gPSBpZ2RfaG9zdF9icmlkZ2VfaW5mb3NbaV0ubGVu OwotICAgICAgICBob3N0X3BjaV9jb25maWdfcmVhZChwb3MsIGxlbiwgJnZhbCwgJmxvY2FsX2Vy cik7Ci0gICAgICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgICAgIGVycm9yX3Byb3BhZ2F0 ZShlcnJwLCBsb2NhbF9lcnIpOworICAgICAgICBob3N0X3BjaV9jb25maWdfcmVhZChwb3MsIGxl biwgJnZhbCwgZXJycCk7CisgICAgICAgIGlmICgqZXJycCkgewogICAgICAgICAgICAgcmV0dXJu OwogICAgICAgICB9CiAgICAgICAgIHBjaV9kZWZhdWx0X3dyaXRlX2NvbmZpZyhwY2lfZGV2LCBw b3MsIHZhbCwgbGVuKTsKZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW4tYmFja2VuZC5jIGIvaHcveGVu L3hlbi1iYWNrZW5kLmMKaW5kZXggZGEwNjVmODFiNy4uMWNjMDY5NDA1MyAxMDA2NDQKLS0tIGEv aHcveGVuL3hlbi1iYWNrZW5kLmMKKysrIGIvaHcveGVuL3hlbi1iYWNrZW5kLmMKQEAgLTk4LDkg Kzk4LDkgQEAgc3RhdGljIHZvaWQgeGVuX2JhY2tlbmRfbGlzdF9yZW1vdmUoWGVuQmFja2VuZElu c3RhbmNlICpiYWNrZW5kKQogdm9pZCB4ZW5fYmFja2VuZF9kZXZpY2VfY3JlYXRlKFhlbkJ1cyAq eGVuYnVzLCBjb25zdCBjaGFyICp0eXBlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGNvbnN0IGNoYXIgKm5hbWUsIFFEaWN0ICpvcHRzLCBFcnJvciAqKmVycnApCiB7CisgICAgRVJS UF9BVVRPX1BST1BBR0FURSgpOwogICAgIGNvbnN0IFhlbkJhY2tlbmRJbXBsICppbXBsID0geGVu X2JhY2tlbmRfdGFibGVfbG9va3VwKHR5cGUpOwogICAgIFhlbkJhY2tlbmRJbnN0YW5jZSAqYmFj a2VuZDsKLSAgICBFcnJvciAqbG9jYWxfZXJyb3IgPSBOVUxMOwogCiAgICAgaWYgKCFpbXBsKSB7 CiAgICAgICAgIHJldHVybjsKQEAgLTExMCw5ICsxMTAsOCBAQCB2b2lkIHhlbl9iYWNrZW5kX2Rl dmljZV9jcmVhdGUoWGVuQnVzICp4ZW5idXMsIGNvbnN0IGNoYXIgKnR5cGUsCiAgICAgYmFja2Vu ZC0+eGVuYnVzID0geGVuYnVzOwogICAgIGJhY2tlbmQtPm5hbWUgPSBnX3N0cmR1cChuYW1lKTsK IAotICAgIGltcGwtPmNyZWF0ZShiYWNrZW5kLCBvcHRzLCAmbG9jYWxfZXJyb3IpOwotICAgIGlm IChsb2NhbF9lcnJvcikgewotICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJy b3IpOworICAgIGltcGwtPmNyZWF0ZShiYWNrZW5kLCBvcHRzLCBlcnJwKTsKKyAgICBpZiAoKmVy cnApIHsKICAgICAgICAgZ19mcmVlKGJhY2tlbmQtPm5hbWUpOwogICAgICAgICBnX2ZyZWUoYmFj a2VuZCk7CiAgICAgICAgIHJldHVybjsKZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW4tYnVzLmMgYi9o dy94ZW4veGVuLWJ1cy5jCmluZGV4IDE4MjM3YjM0ZWEuLjk3MjU5Yzk2NGIgMTAwNjQ0Ci0tLSBh L2h3L3hlbi94ZW4tYnVzLmMKKysrIGIvaHcveGVuL3hlbi1idXMuYwpAQCAtNTMsOSArNTMsOSBA QCBzdGF0aWMgY2hhciAqeGVuX2RldmljZV9nZXRfZnJvbnRlbmRfcGF0aChYZW5EZXZpY2UgKnhl bmRldikKIAogc3RhdGljIHZvaWQgeGVuX2RldmljZV91bnBsdWcoWGVuRGV2aWNlICp4ZW5kZXYs IEVycm9yICoqZXJycCkKIHsKKyAgICBFUlJQX0FVVE9fUFJPUEFHQVRFKCk7CiAgICAgWGVuQnVz ICp4ZW5idXMgPSBYRU5fQlVTKHFkZXZfZ2V0X3BhcmVudF9idXMoREVWSUNFKHhlbmRldikpKTsK ICAgICBjb25zdCBjaGFyICp0eXBlID0gb2JqZWN0X2dldF90eXBlbmFtZShPQkpFQ1QoeGVuZGV2 KSk7Ci0gICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7CiAgICAgeHNfdHJhbnNhY3Rpb25fdCB0 aWQ7CiAKICAgICB0cmFjZV94ZW5fZGV2aWNlX3VucGx1Zyh0eXBlLCB4ZW5kZXYtPm5hbWUpOwpA QCAtNjksMTQgKzY5LDE0IEBAIGFnYWluOgogICAgIH0KIAogICAgIHhzX25vZGVfcHJpbnRmKHhl bmJ1cy0+eHNoLCB0aWQsIHhlbmRldi0+YmFja2VuZF9wYXRoLCAib25saW5lIiwKLSAgICAgICAg ICAgICAgICAgICAmbG9jYWxfZXJyLCAiJXUiLCAwKTsKLSAgICBpZiAobG9jYWxfZXJyKSB7Cisg ICAgICAgICAgICAgICAgICAgZXJycCwgIiV1IiwgMCk7CisgICAgaWYgKCplcnJwKSB7CiAgICAg ICAgIGdvdG8gYWJvcnQ7CiAgICAgfQogCiAgICAgeHNfbm9kZV9wcmludGYoeGVuYnVzLT54c2gs IHRpZCwgeGVuZGV2LT5iYWNrZW5kX3BhdGgsICJzdGF0ZSIsCi0gICAgICAgICAgICAgICAgICAg JmxvY2FsX2VyciwgIiV1IiwgWGVuYnVzU3RhdGVDbG9zaW5nKTsKLSAgICBpZiAobG9jYWxfZXJy KSB7CisgICAgICAgICAgICAgICAgICAgZXJycCwgIiV1IiwgWGVuYnVzU3RhdGVDbG9zaW5nKTsK KyAgICBpZiAoKmVycnApIHsKICAgICAgICAgZ290byBhYm9ydDsKICAgICB9CiAKQEAgLTk2LDcg Kzk2LDYgQEAgYWJvcnQ6CiAgICAgICogZnJvbSBlbmRpbmcgdGhlIHRyYW5zYWN0aW9uLgogICAg ICAqLwogICAgIHhzX3RyYW5zYWN0aW9uX2VuZCh4ZW5idXMtPnhzaCwgdGlkLCB0cnVlKTsKLSAg ICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKIH0KIAogc3RhdGljIHZvaWQgeGVu X2J1c19wcmludF9kZXYoTW9uaXRvciAqbW9uLCBEZXZpY2VTdGF0ZSAqZGV2LCBpbnQgaW5kZW50 KQpAQCAtMjA1LDE1ICsyMDQsMTMgQEAgc3RhdGljIFhlbldhdGNoICp3YXRjaF9saXN0X2FkZChY ZW5XYXRjaExpc3QgKndhdGNoX2xpc3QsIGNvbnN0IGNoYXIgKm5vZGUsCiAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKmtleSwgWGVuV2F0Y2hIYW5kbGVyIGhhbmRs ZXIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZvaWQgKm9wYXF1ZSwgRXJyb3Ig KiplcnJwKQogeworICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKICAgICBYZW5XYXRjaCAqd2F0 Y2ggPSBuZXdfd2F0Y2gobm9kZSwga2V5LCBoYW5kbGVyLCBvcGFxdWUpOwotICAgIEVycm9yICps b2NhbF9lcnIgPSBOVUxMOwogCiAgICAgbm90aWZpZXJfbGlzdF9hZGQoJndhdGNoX2xpc3QtPm5v dGlmaWVycywgJndhdGNoLT5ub3RpZmllcik7CiAKLSAgICB4c19ub2RlX3dhdGNoKHdhdGNoX2xp c3QtPnhzaCwgbm9kZSwga2V5LCB3YXRjaC0+dG9rZW4sICZsb2NhbF9lcnIpOwotICAgIGlmIChs b2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vycik7Ci0K KyAgICB4c19ub2RlX3dhdGNoKHdhdGNoX2xpc3QtPnhzaCwgbm9kZSwga2V5LCB3YXRjaC0+dG9r ZW4sIGVycnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICBub3RpZmllcl9yZW1vdmUoJndh dGNoLT5ub3RpZmllcik7CiAgICAgICAgIGZyZWVfd2F0Y2god2F0Y2gpOwogCkBAIC0yNTUsMTEg KzI1MiwxMSBAQCBzdGF0aWMgdm9pZCB4ZW5fYnVzX2JhY2tlbmRfY3JlYXRlKFhlbkJ1cyAqeGVu YnVzLCBjb25zdCBjaGFyICp0eXBlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBjb25zdCBjaGFyICpuYW1lLCBjaGFyICpwYXRoLAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBFcnJvciAqKmVycnApCiB7CisgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwog ICAgIHhzX3RyYW5zYWN0aW9uX3QgdGlkOwogICAgIGNoYXIgKiprZXk7CiAgICAgUURpY3QgKm9w dHM7CiAgICAgdW5zaWduZWQgaW50IGksIG47Ci0gICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7 CiAKICAgICB0cmFjZV94ZW5fYnVzX2JhY2tlbmRfY3JlYXRlKHR5cGUsIHBhdGgpOwogCkBAIC0z MTQsMTMgKzMxMSwxMSBAQCBhZ2FpbjoKICAgICAgICAgcmV0dXJuOwogICAgIH0KIAotICAgIHhl bl9iYWNrZW5kX2RldmljZV9jcmVhdGUoeGVuYnVzLCB0eXBlLCBuYW1lLCBvcHRzLCAmbG9jYWxf ZXJyKTsKKyAgICB4ZW5fYmFja2VuZF9kZXZpY2VfY3JlYXRlKHhlbmJ1cywgdHlwZSwgbmFtZSwg b3B0cywgZXJycCk7CiAgICAgcW9iamVjdF91bnJlZihvcHRzKTsKIAotICAgIGlmIChsb2NhbF9l cnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxfZXJyLAot ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiZmFpbGVkIHRvIGNyZWF0ZSAnJXMnIGRl dmljZSAnJXMnOiAiLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0eXBlLCBuYW1l KTsKKyAgICBpZiAoKmVycnApIHsKKyAgICAgICAgZXJyb3JfcHJlcGVuZChlcnJwLCAiZmFpbGVk IHRvIGNyZWF0ZSAnJXMnIGRldmljZSAnJXMnOiAiLCB0eXBlLCBuYW1lKTsKICAgICB9CiB9CiAK QEAgLTY5Miw5ICs2ODcsOSBAQCBzdGF0aWMgdm9pZCB4ZW5fZGV2aWNlX3JlbW92ZV93YXRjaChY ZW5EZXZpY2UgKnhlbmRldiwgWGVuV2F0Y2ggKndhdGNoLAogCiBzdGF0aWMgdm9pZCB4ZW5fZGV2 aWNlX2JhY2tlbmRfY3JlYXRlKFhlbkRldmljZSAqeGVuZGV2LCBFcnJvciAqKmVycnApCiB7Cisg ICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIFhlbkJ1cyAqeGVuYnVzID0gWEVOX0JVUyhx ZGV2X2dldF9wYXJlbnRfYnVzKERFVklDRSh4ZW5kZXYpKSk7CiAgICAgc3RydWN0IHhzX3Blcm1p c3Npb25zIHBlcm1zWzJdOwotICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOwogCiAgICAgeGVu ZGV2LT5iYWNrZW5kX3BhdGggPSB4ZW5fZGV2aWNlX2dldF9iYWNrZW5kX3BhdGgoeGVuZGV2KTsK IApAQCAtNzA2LDMwICs3MDEsMjcgQEAgc3RhdGljIHZvaWQgeGVuX2RldmljZV9iYWNrZW5kX2Ny ZWF0ZShYZW5EZXZpY2UgKnhlbmRldiwgRXJyb3IgKiplcnJwKQogICAgIGdfYXNzZXJ0KHhlbmJ1 cy0+eHNoKTsKIAogICAgIHhzX25vZGVfY3JlYXRlKHhlbmJ1cy0+eHNoLCBYQlRfTlVMTCwgeGVu ZGV2LT5iYWNrZW5kX3BhdGgsIHBlcm1zLAotICAgICAgICAgICAgICAgICAgIEFSUkFZX1NJWkUo cGVybXMpLCAmbG9jYWxfZXJyKTsKLSAgICBpZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgIGVycm9y X3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAsIGxvY2FsX2VyciwKLSAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgImZhaWxlZCB0byBjcmVhdGUgYmFja2VuZDogIik7CisgICAgICAgICAgICAg ICAgICAgQVJSQVlfU0laRShwZXJtcyksIGVycnApOworICAgIGlmICgqZXJycCkgeworICAgICAg ICBlcnJvcl9wcmVwZW5kKGVycnAsICJmYWlsZWQgdG8gY3JlYXRlIGJhY2tlbmQ6ICIpOwogICAg ICAgICByZXR1cm47CiAgICAgfQogCiAgICAgeGVuZGV2LT5iYWNrZW5kX3N0YXRlX3dhdGNoID0K ICAgICAgICAgeGVuX2RldmljZV9hZGRfd2F0Y2goeGVuZGV2LCB4ZW5kZXYtPmJhY2tlbmRfcGF0 aCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgInN0YXRlIiwgeGVuX2RldmljZV9iYWNr ZW5kX2NoYW5nZWQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICZsb2NhbF9lcnIpOwot ICAgIGlmIChsb2NhbF9lcnIpIHsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJy cCwgbG9jYWxfZXJyLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiZmFpbGVkIHRv IHdhdGNoIGJhY2tlbmQgc3RhdGU6ICIpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICBl cnJwKTsKKyAgICBpZiAoKmVycnApIHsKKyAgICAgICAgZXJyb3JfcHJlcGVuZChlcnJwLCAiZmFp bGVkIHRvIHdhdGNoIGJhY2tlbmQgc3RhdGU6ICIpOwogICAgICAgICByZXR1cm47CiAgICAgfQog CiAgICAgeGVuZGV2LT5iYWNrZW5kX29ubGluZV93YXRjaCA9CiAgICAgICAgIHhlbl9kZXZpY2Vf YWRkX3dhdGNoKHhlbmRldiwgeGVuZGV2LT5iYWNrZW5kX3BhdGgsCiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICJvbmxpbmUiLCB4ZW5fZGV2aWNlX2JhY2tlbmRfY2hhbmdlZCwKLSAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgJmxvY2FsX2Vycik7Ci0gICAgaWYgKGxvY2FsX2Vycikg ewotICAgICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChlcnJwLCBsb2NhbF9lcnIsCi0gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICJmYWlsZWQgdG8gd2F0Y2ggYmFja2VuZCBvbmxp bmU6ICIpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlcnJwKTsKKyAgICBpZiAoKmVy cnApIHsKKyAgICAgICAgZXJyb3JfcHJlcGVuZChlcnJwLCAiZmFpbGVkIHRvIHdhdGNoIGJhY2tl bmQgb25saW5lOiAiKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KIH0KQEAgLTg2Niw5ICs4NTgs OSBAQCBzdGF0aWMgYm9vbCB4ZW5fZGV2aWNlX2Zyb250ZW5kX2V4aXN0cyhYZW5EZXZpY2UgKnhl bmRldikKIAogc3RhdGljIHZvaWQgeGVuX2RldmljZV9mcm9udGVuZF9jcmVhdGUoWGVuRGV2aWNl ICp4ZW5kZXYsIEVycm9yICoqZXJycCkKIHsKKyAgICBFUlJQX0FVVE9fUFJPUEFHQVRFKCk7CiAg ICAgWGVuQnVzICp4ZW5idXMgPSBYRU5fQlVTKHFkZXZfZ2V0X3BhcmVudF9idXMoREVWSUNFKHhl bmRldikpKTsKICAgICBzdHJ1Y3QgeHNfcGVybWlzc2lvbnMgcGVybXNbMl07Ci0gICAgRXJyb3Ig KmxvY2FsX2VyciA9IE5VTEw7CiAKICAgICB4ZW5kZXYtPmZyb250ZW5kX3BhdGggPSB4ZW5fZGV2 aWNlX2dldF9mcm9udGVuZF9wYXRoKHhlbmRldik7CiAKQEAgLTg4NSwyMCArODc3LDE4IEBAIHN0 YXRpYyB2b2lkIHhlbl9kZXZpY2VfZnJvbnRlbmRfY3JlYXRlKFhlbkRldmljZSAqeGVuZGV2LCBF cnJvciAqKmVycnApCiAgICAgICAgIGdfYXNzZXJ0KHhlbmJ1cy0+eHNoKTsKIAogICAgICAgICB4 c19ub2RlX2NyZWF0ZSh4ZW5idXMtPnhzaCwgWEJUX05VTEwsIHhlbmRldi0+ZnJvbnRlbmRfcGF0 aCwgcGVybXMsCi0gICAgICAgICAgICAgICAgICAgICAgIEFSUkFZX1NJWkUocGVybXMpLCAmbG9j YWxfZXJyKTsKLSAgICAgICAgaWYgKGxvY2FsX2VycikgewotICAgICAgICAgICAgZXJyb3JfcHJv cGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxfZXJyLAotICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgImZhaWxlZCB0byBjcmVhdGUgZnJvbnRlbmQ6ICIpOworICAgICAgICAgICAg ICAgICAgICAgICBBUlJBWV9TSVpFKHBlcm1zKSwgZXJycCk7CisgICAgICAgIGlmICgqZXJycCkg eworICAgICAgICAgICAgZXJyb3JfcHJlcGVuZChlcnJwLCAiZmFpbGVkIHRvIGNyZWF0ZSBmcm9u dGVuZDogIik7CiAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgIH0KICAgICB9CiAKICAgICB4 ZW5kZXYtPmZyb250ZW5kX3N0YXRlX3dhdGNoID0KICAgICAgICAgeGVuX2RldmljZV9hZGRfd2F0 Y2goeGVuZGV2LCB4ZW5kZXYtPmZyb250ZW5kX3BhdGgsICJzdGF0ZSIsCi0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHhlbl9kZXZpY2VfZnJvbnRlbmRfY2hhbmdlZCwgJmxvY2FsX2Vycik7 Ci0gICAgaWYgKGxvY2FsX2VycikgewotICAgICAgICBlcnJvcl9wcm9wYWdhdGVfcHJlcGVuZChl cnJwLCBsb2NhbF9lcnIsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJmYWlsZWQg dG8gd2F0Y2ggZnJvbnRlbmQgc3RhdGU6ICIpOworICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB4ZW5fZGV2aWNlX2Zyb250ZW5kX2NoYW5nZWQsIGVycnApOworICAgIGlmICgqZXJycCkgewor ICAgICAgICBlcnJvcl9wcmVwZW5kKGVycnAsICJmYWlsZWQgdG8gd2F0Y2ggZnJvbnRlbmQgc3Rh dGU6ICIpOwogICAgIH0KIH0KIApAQCAtMTI0NywxMSArMTIzNywxMSBAQCBzdGF0aWMgdm9pZCB4 ZW5fZGV2aWNlX2V4aXQoTm90aWZpZXIgKm4sIHZvaWQgKmRhdGEpCiAKIHN0YXRpYyB2b2lkIHhl bl9kZXZpY2VfcmVhbGl6ZShEZXZpY2VTdGF0ZSAqZGV2LCBFcnJvciAqKmVycnApCiB7CisgICAg RVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIFhlbkRldmljZSAqeGVuZGV2ID0gWEVOX0RFVklD RShkZXYpOwogICAgIFhlbkRldmljZUNsYXNzICp4ZW5kZXZfY2xhc3MgPSBYRU5fREVWSUNFX0dF VF9DTEFTUyh4ZW5kZXYpOwogICAgIFhlbkJ1cyAqeGVuYnVzID0gWEVOX0JVUyhxZGV2X2dldF9w YXJlbnRfYnVzKERFVklDRSh4ZW5kZXYpKSk7CiAgICAgY29uc3QgY2hhciAqdHlwZSA9IG9iamVj dF9nZXRfdHlwZW5hbWUoT0JKRUNUKHhlbmRldikpOwotICAgIEVycm9yICpsb2NhbF9lcnIgPSBO VUxMOwogCiAgICAgaWYgKHhlbmRldi0+ZnJvbnRlbmRfaWQgPT0gRE9NSURfSU5WQUxJRCkgewog ICAgICAgICB4ZW5kZXYtPmZyb250ZW5kX2lkID0geGVuX2RvbWlkOwpAQCAtMTI2NywxMCArMTI1 Nyw5IEBAIHN0YXRpYyB2b2lkIHhlbl9kZXZpY2VfcmVhbGl6ZShEZXZpY2VTdGF0ZSAqZGV2LCBF cnJvciAqKmVycnApCiAgICAgICAgIGdvdG8gdW5yZWFsaXplOwogICAgIH0KIAotICAgIHhlbmRl di0+bmFtZSA9IHhlbmRldl9jbGFzcy0+Z2V0X25hbWUoeGVuZGV2LCAmbG9jYWxfZXJyKTsKLSAg ICBpZiAobG9jYWxfZXJyKSB7Ci0gICAgICAgIGVycm9yX3Byb3BhZ2F0ZV9wcmVwZW5kKGVycnAs IGxvY2FsX2VyciwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImZhaWxlZCB0byBn ZXQgZGV2aWNlIG5hbWU6ICIpOworICAgIHhlbmRldi0+bmFtZSA9IHhlbmRldl9jbGFzcy0+Z2V0 X25hbWUoeGVuZGV2LCBlcnJwKTsKKyAgICBpZiAoKmVycnApIHsKKyAgICAgICAgZXJyb3JfcHJl cGVuZChlcnJwLCAiZmFpbGVkIHRvIGdldCBkZXZpY2UgbmFtZTogIik7CiAgICAgICAgIGdvdG8g dW5yZWFsaXplOwogICAgIH0KIApAQCAtMTI5MywyMiArMTI4MiwxOSBAQCBzdGF0aWMgdm9pZCB4 ZW5fZGV2aWNlX3JlYWxpemUoRGV2aWNlU3RhdGUgKmRldiwgRXJyb3IgKiplcnJwKQogICAgIHhl bmRldi0+ZmVhdHVyZV9ncmFudF9jb3B5ID0KICAgICAgICAgKHhlbmdudHRhYl9ncmFudF9jb3B5 KHhlbmRldi0+eGd0aCwgMCwgTlVMTCkgPT0gMCk7CiAKLSAgICB4ZW5fZGV2aWNlX2JhY2tlbmRf Y3JlYXRlKHhlbmRldiwgJmxvY2FsX2Vycik7Ci0gICAgaWYgKGxvY2FsX2VycikgewotICAgICAg ICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKKyAgICB4ZW5fZGV2aWNlX2JhY2tl bmRfY3JlYXRlKHhlbmRldiwgZXJycCk7CisgICAgaWYgKCplcnJwKSB7CiAgICAgICAgIGdvdG8g dW5yZWFsaXplOwogICAgIH0KIAotICAgIHhlbl9kZXZpY2VfZnJvbnRlbmRfY3JlYXRlKHhlbmRl diwgJmxvY2FsX2Vycik7Ci0gICAgaWYgKGxvY2FsX2VycikgewotICAgICAgICBlcnJvcl9wcm9w YWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKKyAgICB4ZW5fZGV2aWNlX2Zyb250ZW5kX2NyZWF0ZSh4 ZW5kZXYsIGVycnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICBnb3RvIHVucmVhbGl6ZTsK ICAgICB9CiAKICAgICBpZiAoeGVuZGV2X2NsYXNzLT5yZWFsaXplKSB7Ci0gICAgICAgIHhlbmRl dl9jbGFzcy0+cmVhbGl6ZSh4ZW5kZXYsICZsb2NhbF9lcnIpOwotICAgICAgICBpZiAobG9jYWxf ZXJyKSB7Ci0gICAgICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKKyAg ICAgICAgeGVuZGV2X2NsYXNzLT5yZWFsaXplKHhlbmRldiwgZXJycCk7CisgICAgICAgIGlmICgq ZXJycCkgewogICAgICAgICAgICAgZ290byB1bnJlYWxpemU7CiAgICAgICAgIH0KICAgICB9CmRp ZmYgLS1naXQgYS9ody94ZW4veGVuLWhvc3QtcGNpLWRldmljZS5jIGIvaHcveGVuL3hlbi1ob3N0 LXBjaS1kZXZpY2UuYwppbmRleCAxYjQ0ZGNhZmFmLi4wMjM3OWMzNDFjIDEwMDY0NAotLS0gYS9o dy94ZW4veGVuLWhvc3QtcGNpLWRldmljZS5jCisrKyBiL2h3L3hlbi94ZW4taG9zdC1wY2ktZGV2 aWNlLmMKQEAgLTMzMyw4ICszMzMsOCBAQCB2b2lkIHhlbl9ob3N0X3BjaV9kZXZpY2VfZ2V0KFhl bkhvc3RQQ0lEZXZpY2UgKmQsIHVpbnQxNl90IGRvbWFpbiwKICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgdWludDhfdCBidXMsIHVpbnQ4X3QgZGV2LCB1aW50OF90IGZ1bmMsCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIEVycm9yICoqZXJycCkKIHsKKyAgICBFUlJQX0FVVE9fUFJP UEFHQVRFKCk7CiAgICAgdW5zaWduZWQgaW50IHY7Ci0gICAgRXJyb3IgKmVyciA9IE5VTEw7CiAK ICAgICBkLT5jb25maWdfZmQgPSAtMTsKICAgICBkLT5kb21haW4gPSBkb21haW47CkBAIC0zNDIs MzYgKzM0MiwzNiBAQCB2b2lkIHhlbl9ob3N0X3BjaV9kZXZpY2VfZ2V0KFhlbkhvc3RQQ0lEZXZp Y2UgKmQsIHVpbnQxNl90IGRvbWFpbiwKICAgICBkLT5kZXYgPSBkZXY7CiAgICAgZC0+ZnVuYyA9 IGZ1bmM7CiAKLSAgICB4ZW5faG9zdF9wY2lfY29uZmlnX29wZW4oZCwgJmVycik7Ci0gICAgaWYg KGVycikgeworICAgIHhlbl9ob3N0X3BjaV9jb25maWdfb3BlbihkLCBlcnJwKTsKKyAgICBpZiAo KmVycnApIHsKICAgICAgICAgZ290byBlcnJvcjsKICAgICB9CiAKLSAgICB4ZW5faG9zdF9wY2lf Z2V0X3Jlc291cmNlKGQsICZlcnIpOwotICAgIGlmIChlcnIpIHsKKyAgICB4ZW5faG9zdF9wY2lf Z2V0X3Jlc291cmNlKGQsIGVycnApOworICAgIGlmICgqZXJycCkgewogICAgICAgICBnb3RvIGVy cm9yOwogICAgIH0KIAotICAgIHhlbl9ob3N0X3BjaV9nZXRfaGV4X3ZhbHVlKGQsICJ2ZW5kb3Ii LCAmdiwgJmVycik7Ci0gICAgaWYgKGVycikgeworICAgIHhlbl9ob3N0X3BjaV9nZXRfaGV4X3Zh bHVlKGQsICJ2ZW5kb3IiLCAmdiwgZXJycCk7CisgICAgaWYgKCplcnJwKSB7CiAgICAgICAgIGdv dG8gZXJyb3I7CiAgICAgfQogICAgIGQtPnZlbmRvcl9pZCA9IHY7CiAKLSAgICB4ZW5faG9zdF9w Y2lfZ2V0X2hleF92YWx1ZShkLCAiZGV2aWNlIiwgJnYsICZlcnIpOwotICAgIGlmIChlcnIpIHsK KyAgICB4ZW5faG9zdF9wY2lfZ2V0X2hleF92YWx1ZShkLCAiZGV2aWNlIiwgJnYsIGVycnApOwor ICAgIGlmICgqZXJycCkgewogICAgICAgICBnb3RvIGVycm9yOwogICAgIH0KICAgICBkLT5kZXZp Y2VfaWQgPSB2OwogCi0gICAgeGVuX2hvc3RfcGNpX2dldF9kZWNfdmFsdWUoZCwgImlycSIsICZ2 LCAmZXJyKTsKLSAgICBpZiAoZXJyKSB7CisgICAgeGVuX2hvc3RfcGNpX2dldF9kZWNfdmFsdWUo ZCwgImlycSIsICZ2LCBlcnJwKTsKKyAgICBpZiAoKmVycnApIHsKICAgICAgICAgZ290byBlcnJv cjsKICAgICB9CiAgICAgZC0+aXJxID0gdjsKIAotICAgIHhlbl9ob3N0X3BjaV9nZXRfaGV4X3Zh bHVlKGQsICJjbGFzcyIsICZ2LCAmZXJyKTsKLSAgICBpZiAoZXJyKSB7CisgICAgeGVuX2hvc3Rf cGNpX2dldF9oZXhfdmFsdWUoZCwgImNsYXNzIiwgJnYsIGVycnApOworICAgIGlmICgqZXJycCkg ewogICAgICAgICBnb3RvIGVycm9yOwogICAgIH0KICAgICBkLT5jbGFzc19jb2RlID0gdjsKQEAg LTM4MSw3ICszODEsNiBAQCB2b2lkIHhlbl9ob3N0X3BjaV9kZXZpY2VfZ2V0KFhlbkhvc3RQQ0lE ZXZpY2UgKmQsIHVpbnQxNl90IGRvbWFpbiwKICAgICByZXR1cm47CiAKIGVycm9yOgotICAgIGVy cm9yX3Byb3BhZ2F0ZShlcnJwLCBlcnIpOwogCiAgICAgaWYgKGQtPmNvbmZpZ19mZCA+PSAwKSB7 CiAgICAgICAgIGNsb3NlKGQtPmNvbmZpZ19mZCk7CmRpZmYgLS1naXQgYS9ody94ZW4veGVuX3B0 LmMgYi9ody94ZW4veGVuX3B0LmMKaW5kZXggYjkxMDgyY2I4Yi4uZjU3YjgxNTg4ZSAxMDA2NDQK LS0tIGEvaHcveGVuL3hlbl9wdC5jCisrKyBiL2h3L3hlbi94ZW5fcHQuYwpAQCAtNzY3LDEyICs3 NjcsMTIgQEAgc3RhdGljIHZvaWQgeGVuX3B0X2Rlc3Ryb3koUENJRGV2aWNlICpkKSB7CiAKIHN0 YXRpYyB2b2lkIHhlbl9wdF9yZWFsaXplKFBDSURldmljZSAqZCwgRXJyb3IgKiplcnJwKQogewor ICAgIEVSUlBfQVVUT19QUk9QQUdBVEUoKTsKICAgICBYZW5QQ0lQYXNzdGhyb3VnaFN0YXRlICpz ID0gWEVOX1BUX0RFVklDRShkKTsKICAgICBpbnQgaSwgcmMgPSAwOwogICAgIHVpbnQ4X3QgbWFj aGluZV9pcnEgPSAwLCBzY3JhdGNoOwogICAgIHVpbnQxNl90IGNtZCA9IDA7CiAgICAgaW50IHBp cnEgPSBYRU5fUFRfVU5BU1NJR05FRF9QSVJROwotICAgIEVycm9yICplcnIgPSBOVUxMOwogCiAg ICAgLyogcmVnaXN0ZXIgcmVhbCBkZXZpY2UgKi8KICAgICBYRU5fUFRfTE9HKGQsICJBc3NpZ25p bmcgcmVhbCBwaHlzaWNhbCBkZXZpY2UgJTAyeDolMDJ4LiVkIgpAQCAtNzgzLDEwICs3ODMsOSBA QCBzdGF0aWMgdm9pZCB4ZW5fcHRfcmVhbGl6ZShQQ0lEZXZpY2UgKmQsIEVycm9yICoqZXJycCkK ICAgICB4ZW5faG9zdF9wY2lfZGV2aWNlX2dldCgmcy0+cmVhbF9kZXZpY2UsCiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcy0+aG9zdGFkZHIuZG9tYWluLCBzLT5ob3N0YWRkci5idXMsCiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgcy0+aG9zdGFkZHIuc2xvdCwgcy0+aG9zdGFkZHIu ZnVuY3Rpb24sCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgJmVycik7Ci0gICAgaWYgKGVy cikgewotICAgICAgICBlcnJvcl9hcHBlbmRfaGludCgmZXJyLCAiRmFpbGVkIHRvIFwib3Blblwi IHRoZSByZWFsIHBjaSBkZXZpY2UiKTsKLSAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGVy cik7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgZXJycCk7CisgICAgaWYgKCplcnJwKSB7 CisgICAgICAgIGVycm9yX2FwcGVuZF9oaW50KGVycnAsICJGYWlsZWQgdG8gXCJvcGVuXCIgdGhl IHJlYWwgcGNpIGRldmljZSIpOwogICAgICAgICByZXR1cm47CiAgICAgfQogCkBAIC04MTMsMTEg KzgxMiwxMCBAQCBzdGF0aWMgdm9pZCB4ZW5fcHRfcmVhbGl6ZShQQ0lEZXZpY2UgKmQsIEVycm9y ICoqZXJycCkKICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgfQogCi0gICAgICAgIHhlbl9w dF9zZXR1cF92Z2EocywgJnMtPnJlYWxfZGV2aWNlLCAmZXJyKTsKLSAgICAgICAgaWYgKGVycikg ewotICAgICAgICAgICAgZXJyb3JfYXBwZW5kX2hpbnQoJmVyciwgIlNldHVwIFZHQSBCSU9TIG9m IHBhc3N0aHJvdWdoIgotICAgICAgICAgICAgICAgICAgICAiIEdGWCBmYWlsZWQiKTsKLSAgICAg ICAgICAgIGVycm9yX3Byb3BhZ2F0ZShlcnJwLCBlcnIpOworICAgICAgICB4ZW5fcHRfc2V0dXBf dmdhKHMsICZzLT5yZWFsX2RldmljZSwgZXJycCk7CisgICAgICAgIGlmICgqZXJycCkgeworICAg ICAgICAgICAgZXJyb3JfYXBwZW5kX2hpbnQoZXJycCwgIlNldHVwIFZHQSBCSU9TIG9mIHBhc3N0 aHJvdWdoIgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIiBHRlggZmFpbGVkIik7CiAg ICAgICAgICAgICB4ZW5faG9zdF9wY2lfZGV2aWNlX3B1dCgmcy0+cmVhbF9kZXZpY2UpOwogICAg ICAgICAgICAgcmV0dXJuOwogICAgICAgICB9CkBAIC04MzAsMTAgKzgyOCw5IEBAIHN0YXRpYyB2 b2lkIHhlbl9wdF9yZWFsaXplKFBDSURldmljZSAqZCwgRXJyb3IgKiplcnJwKQogICAgIHhlbl9w dF9yZWdpc3Rlcl9yZWdpb25zKHMsICZjbWQpOwogCiAgICAgLyogcmVpbml0aWFsaXplIGVhY2gg Y29uZmlnIHJlZ2lzdGVyIHRvIGJlIGVtdWxhdGVkICovCi0gICAgeGVuX3B0X2NvbmZpZ19pbml0 KHMsICZlcnIpOwotICAgIGlmIChlcnIpIHsKLSAgICAgICAgZXJyb3JfYXBwZW5kX2hpbnQoJmVy ciwgIlBDSSBDb25maWcgc3BhY2UgaW5pdGlhbGlzYXRpb24gZmFpbGVkIik7Ci0gICAgICAgIGVy cm9yX3Byb3BhZ2F0ZShlcnJwLCBlcnIpOworICAgIHhlbl9wdF9jb25maWdfaW5pdChzLCBlcnJw KTsKKyAgICBpZiAoKmVycnApIHsKKyAgICAgICAgZXJyb3JfYXBwZW5kX2hpbnQoZXJycCwgIlBD SSBDb25maWcgc3BhY2UgaW5pdGlhbGlzYXRpb24gZmFpbGVkIik7CiAgICAgICAgIHJjID0gLTE7 CiAgICAgICAgIGdvdG8gZXJyX291dDsKICAgICB9CmRpZmYgLS1naXQgYS9ody94ZW4veGVuX3B0 X2NvbmZpZ19pbml0LmMgYi9ody94ZW4veGVuX3B0X2NvbmZpZ19pbml0LmMKaW5kZXggMzFlYzVh ZGQxZC4uYWYzZmJkMWJmYiAxMDA2NDQKLS0tIGEvaHcveGVuL3hlbl9wdF9jb25maWdfaW5pdC5j CisrKyBiL2h3L3hlbi94ZW5fcHRfY29uZmlnX2luaXQuYwpAQCAtMjAwOCw4ICsyMDA4LDggQEAg c3RhdGljIHZvaWQgeGVuX3B0X2NvbmZpZ19yZWdfaW5pdChYZW5QQ0lQYXNzdGhyb3VnaFN0YXRl ICpzLAogCiB2b2lkIHhlbl9wdF9jb25maWdfaW5pdChYZW5QQ0lQYXNzdGhyb3VnaFN0YXRlICpz LCBFcnJvciAqKmVycnApCiB7CisgICAgRVJSUF9BVVRPX1BST1BBR0FURSgpOwogICAgIGludCBp LCByYzsKLSAgICBFcnJvciAqZXJyID0gTlVMTDsKIAogICAgIFFMSVNUX0lOSVQoJnMtPnJlZ19n cnBzKTsKIApAQCAtMjA1MiwxMCArMjA1Miw5IEBAIHZvaWQgeGVuX3B0X2NvbmZpZ19pbml0KFhl blBDSVBhc3N0aHJvdWdoU3RhdGUgKnMsIEVycm9yICoqZXJycCkKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVnX2dycF9vZmZzZXQsCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZyZWdfZ3JwX2VudHJ5 LT5zaXplKTsKICAgICAgICAgICAgIGlmIChyYyA8IDApIHsKLSAgICAgICAgICAgICAgICBlcnJv cl9zZXRnKCZlcnIsICJGYWlsZWQgdG8gaW5pdGlhbGl6ZSAlZC8lenUsIHR5cGUgPSAweCV4LCIK KyAgICAgICAgICAgICAgICBlcnJvcl9zZXRnKGVycnAsICJGYWlsZWQgdG8gaW5pdGlhbGl6ZSAl ZC8lenUsIHR5cGUgPSAweCV4LCIKICAgICAgICAgICAgICAgICAgICAgICAgICAgICIgcmM6ICVk IiwgaSwgQVJSQVlfU0laRSh4ZW5fcHRfZW11X3JlZ19ncnBzKSwKICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHhlbl9wdF9lbXVfcmVnX2dycHNbaV0uZ3JwX3R5cGUsIHJjKTsKLSAgICAgICAg ICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgZXJyKTsKICAgICAgICAgICAgICAgICB4ZW5f cHRfY29uZmlnX2RlbGV0ZShzKTsKICAgICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgICAg ICB9CkBAIC0yMDY4LDEzICsyMDY3LDE0IEBAIHZvaWQgeGVuX3B0X2NvbmZpZ19pbml0KFhlblBD SVBhc3N0aHJvdWdoU3RhdGUgKnMsIEVycm9yICoqZXJycCkKIAogICAgICAgICAgICAgICAgIC8q IGluaXRpYWxpemUgY2FwYWJpbGl0eSByZWdpc3RlciAqLwogICAgICAgICAgICAgICAgIGZvciAo aiA9IDA7IHJlZ3MtPnNpemUgIT0gMDsgaisrLCByZWdzKyspIHsKLSAgICAgICAgICAgICAgICAg ICAgeGVuX3B0X2NvbmZpZ19yZWdfaW5pdChzLCByZWdfZ3JwX2VudHJ5LCByZWdzLCAmZXJyKTsK LSAgICAgICAgICAgICAgICAgICAgaWYgKGVycikgewotICAgICAgICAgICAgICAgICAgICAgICAg ZXJyb3JfYXBwZW5kX2hpbnQoJmVyciwgIkZhaWxlZCB0byBpbml0IHJlZ2lzdGVyICVkIgotICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiIG9mZnNldHMgMHgleCBpbiBncnBfdHlwZSA9 IDB4JXggKCVkLyV6dSkiLCBqLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWdz LT5vZmZzZXQsIHhlbl9wdF9lbXVfcmVnX2dycHNbaV0uZ3JwX3R5cGUsCi0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIGksIEFSUkFZX1NJWkUoeGVuX3B0X2VtdV9yZWdfZ3JwcykpOwot ICAgICAgICAgICAgICAgICAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGVycik7CisgICAg ICAgICAgICAgICAgICAgIHhlbl9wdF9jb25maWdfcmVnX2luaXQocywgcmVnX2dycF9lbnRyeSwg cmVncywgZXJycCk7CisgICAgICAgICAgICAgICAgICAgIGlmICgqZXJycCkgeworICAgICAgICAg ICAgICAgICAgICAgICAgZXJyb3JfYXBwZW5kX2hpbnQoZXJycCwgIkZhaWxlZCB0byBpbml0IHJl Z2lzdGVyICVkIgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIiBv ZmZzZXRzIDB4JXggaW4gZ3JwX3R5cGUgPSAweCV4ICglZC8lenUpIiwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGosCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICByZWdzLT5vZmZzZXQsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB4ZW5fcHRfZW11X3JlZ19ncnBzW2ldLmdycF90eXBlLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaSwgQVJSQVlfU0laRSh4ZW5fcHRf ZW11X3JlZ19ncnBzKSk7CiAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5fcHRfY29uZmlnX2Rl bGV0ZShzKTsKICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybjsKICAgICAgICAgICAgICAg ICAgICAgfQotLSAKMi4yMS4wCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJv amVjdC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hl bi1kZXZlbA==