From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([209.51.188.92]:57997) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1ghb58-0005zL-5c for qemu-devel@nongnu.org; Thu, 10 Jan 2019 09:13:16 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1ghars-0002aZ-JB for qemu-devel@nongnu.org; Thu, 10 Jan 2019 08:59:34 -0500 Received: from smtp03.citrix.com ([162.221.156.55]:12075) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1gharp-0002Xf-Hi for qemu-devel@nongnu.org; Thu, 10 Jan 2019 08:59:30 -0500 From: Anthony PERARD Date: Thu, 10 Jan 2019 13:49:09 +0000 Message-ID: <20190110134917.16425-18-anthony.perard@citrix.com> In-Reply-To: <20190110134917.16425-1-anthony.perard@citrix.com> References: <20190110134917.16425-1-anthony.perard@citrix.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain Subject: [Qemu-devel] [PULL 17/25] xen: add a mechanism to automatically create XenDevice-s... List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: xen-devel@lists.xenproject.org, Paul Durrant , Anthony PERARD From: Paul Durrant ...that maintains compatibility with existing Xen toolstacks. Xen toolstacks instantiate PV backends by simply writing information into xenstore and expecting a backend implementation to be watching for this. This patch adds a new 'xen-backend' module to allow individual XenDevice implementations to register create and destroy functions. The creator will be called when a tool-stack instantiates a new backend in this way, and the destructor will then be called after the resulting XenDevice object is unrealized. To support this it is also necessary to add new watchers into the XenBus implementation to handle enumeration of new backends and also destruction of XenDevice-s when the toolstack sets the backend 'online' key to 0. NOTE: This patch only adds the framework. A subsequent patch will add a creator function for xen-block devices. Signed-off-by: Paul Durrant Reviewed-by: Anthony Perard Signed-off-by: Anthony PERARD --- hw/xen/Makefile.objs | 2 +- hw/xen/trace-events | 3 + hw/xen/xen-backend.c | 165 +++++++++++++++++++++++++++++++++++ hw/xen/xen-bus.c | 164 +++++++++++++++++++++++++++++++++- include/hw/xen/xen-backend.h | 39 +++++++++ include/hw/xen/xen-bus.h | 1 + include/qemu/module.h | 3 + 7 files changed, 375 insertions(+), 2 deletions(-) create mode 100644 hw/xen/xen-backend.c create mode 100644 include/hw/xen/xen-backend.h diff --git a/hw/xen/Makefile.objs b/hw/xen/Makefile.objs index 77c0868190..84df60a928 100644 --- a/hw/xen/Makefile.objs +++ b/hw/xen/Makefile.objs @@ -1,5 +1,5 @@ # xen backend driver support -common-obj-$(CONFIG_XEN) += xen-legacy-backend.o xen_devconfig.o xen_pvdev.o xen-common.o xen-bus.o xen-bus-helper.o +common-obj-$(CONFIG_XEN) += xen-legacy-backend.o xen_devconfig.o xen_pvdev.o xen-common.o xen-bus.o xen-bus-helper.o xen-backend.o obj-$(CONFIG_XEN_PCI_PASSTHROUGH) += xen-host-pci-device.o obj-$(CONFIG_XEN_PCI_PASSTHROUGH) += xen_pt.o xen_pt_config_init.o xen_pt_graphics.o xen_pt_msi.o diff --git a/hw/xen/trace-events b/hw/xen/trace-events index d4651bdb30..f6944624b2 100644 --- a/hw/xen/trace-events +++ b/hw/xen/trace-events @@ -16,6 +16,9 @@ xen_domid_restrict(int err) "err: %u" # include/hw/xen/xen-bus.c xen_bus_realize(void) "" xen_bus_unrealize(void) "" +xen_bus_enumerate(void) "" +xen_bus_type_enumerate(const char *type) "type: %s" +xen_bus_backend_create(const char *type, const char *path) "type: %s path: %s" xen_bus_add_watch(const char *node, const char *key, char *token) "node: %s key: %s token: %s" xen_bus_remove_watch(const char *node, const char *key, char *token) "node: %s key: %s token: %s" xen_bus_watch(const char *token) "token: %s" diff --git a/hw/xen/xen-backend.c b/hw/xen/xen-backend.c new file mode 100644 index 0000000000..da065f81b7 --- /dev/null +++ b/hw/xen/xen-backend.c @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2018 Citrix Systems Inc. + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#include "qemu/osdep.h" +#include "qemu/error-report.h" +#include "qapi/error.h" +#include "hw/xen/xen-backend.h" +#include "hw/xen/xen-bus.h" + +typedef struct XenBackendImpl { + const char *type; + XenBackendDeviceCreate create; + XenBackendDeviceDestroy destroy; +} XenBackendImpl; + +struct XenBackendInstance { + QLIST_ENTRY(XenBackendInstance) entry; + const XenBackendImpl *impl; + XenBus *xenbus; + char *name; + XenDevice *xendev; +}; + +static GHashTable *xen_backend_table_get(void) +{ + static GHashTable *table; + + if (table == NULL) { + table = g_hash_table_new(g_str_hash, g_str_equal); + } + + return table; +} + +static void xen_backend_table_add(XenBackendImpl *impl) +{ + g_hash_table_insert(xen_backend_table_get(), (void *)impl->type, impl); +} + +static const XenBackendImpl *xen_backend_table_lookup(const char *type) +{ + return g_hash_table_lookup(xen_backend_table_get(), type); +} + +void xen_backend_register(const XenBackendInfo *info) +{ + XenBackendImpl *impl = g_new0(XenBackendImpl, 1); + + g_assert(info->type); + + if (xen_backend_table_lookup(info->type)) { + error_report("attempt to register duplicate Xen backend type '%s'", + info->type); + abort(); + } + + if (!info->create) { + error_report("backend type '%s' has no creator", info->type); + abort(); + } + + impl->type = info->type; + impl->create = info->create; + impl->destroy = info->destroy; + + xen_backend_table_add(impl); +} + +static QLIST_HEAD(, XenBackendInstance) backend_list; + +static void xen_backend_list_add(XenBackendInstance *backend) +{ + QLIST_INSERT_HEAD(&backend_list, backend, entry); +} + +static XenBackendInstance *xen_backend_list_find(XenDevice *xendev) +{ + XenBackendInstance *backend; + + QLIST_FOREACH(backend, &backend_list, entry) { + if (backend->xendev == xendev) { + return backend; + } + } + + return NULL; +} + +static void xen_backend_list_remove(XenBackendInstance *backend) +{ + QLIST_REMOVE(backend, entry); +} + +void xen_backend_device_create(XenBus *xenbus, const char *type, + const char *name, QDict *opts, Error **errp) +{ + const XenBackendImpl *impl = xen_backend_table_lookup(type); + XenBackendInstance *backend; + Error *local_error = NULL; + + if (!impl) { + return; + } + + backend = g_new0(XenBackendInstance, 1); + backend->xenbus = xenbus; + backend->name = g_strdup(name); + + impl->create(backend, opts, &local_error); + if (local_error) { + error_propagate(errp, local_error); + g_free(backend->name); + g_free(backend); + return; + } + + backend->impl = impl; + xen_backend_list_add(backend); +} + +XenBus *xen_backend_get_bus(XenBackendInstance *backend) +{ + return backend->xenbus; +} + +const char *xen_backend_get_name(XenBackendInstance *backend) +{ + return backend->name; +} + +void xen_backend_set_device(XenBackendInstance *backend, + XenDevice *xendev) +{ + g_assert(!backend->xendev); + backend->xendev = xendev; +} + +XenDevice *xen_backend_get_device(XenBackendInstance *backend) +{ + return backend->xendev; +} + + +bool xen_backend_try_device_destroy(XenDevice *xendev, Error **errp) +{ + XenBackendInstance *backend = xen_backend_list_find(xendev); + const XenBackendImpl *impl; + + if (!backend) { + return false; + } + + impl = backend->impl; + impl->destroy(backend, errp); + + xen_backend_list_remove(backend); + g_free(backend->name); + g_free(backend); + + return true; +} diff --git a/hw/xen/xen-bus.c b/hw/xen/xen-bus.c index a22aa49921..f90bcf2342 100644 --- a/hw/xen/xen-bus.c +++ b/hw/xen/xen-bus.c @@ -11,10 +11,12 @@ #include "hw/hw.h" #include "hw/sysbus.h" #include "hw/xen/xen.h" +#include "hw/xen/xen-backend.h" #include "hw/xen/xen-bus.h" #include "hw/xen/xen-bus-helper.h" #include "monitor/monitor.h" #include "qapi/error.h" +#include "qapi/qmp/qdict.h" #include "sysemu/sysemu.h" #include "trace.h" @@ -190,12 +192,151 @@ static void xen_bus_remove_watch(XenBus *xenbus, XenWatch *watch, free_watch(watch); } +static void xen_bus_backend_create(XenBus *xenbus, const char *type, + const char *name, char *path, + Error **errp) +{ + xs_transaction_t tid; + char **key; + QDict *opts; + unsigned int i, n; + Error *local_err = NULL; + + trace_xen_bus_backend_create(type, path); + +again: + tid = xs_transaction_start(xenbus->xsh); + if (tid == XBT_NULL) { + error_setg(errp, "failed xs_transaction_start"); + return; + } + + key = xs_directory(xenbus->xsh, tid, path, &n); + if (!key) { + if (!xs_transaction_end(xenbus->xsh, tid, true)) { + error_setg_errno(errp, errno, "failed xs_transaction_end"); + } + return; + } + + opts = qdict_new(); + for (i = 0; i < n; i++) { + char *val; + + /* + * Assume anything found in the xenstore backend area, other than + * the keys created for a generic XenDevice, are parameters + * to be used to configure the backend. + */ + if (!strcmp(key[i], "state") || + !strcmp(key[i], "online") || + !strcmp(key[i], "frontend") || + !strcmp(key[i], "frontend-id") || + !strcmp(key[i], "hotplug-status")) + continue; + + if (xs_node_scanf(xenbus->xsh, tid, path, key[i], NULL, "%ms", + &val) == 1) { + qdict_put_str(opts, key[i], val); + free(val); + } + } + + free(key); + + if (!xs_transaction_end(xenbus->xsh, tid, false)) { + qobject_unref(opts); + + if (errno == EAGAIN) { + goto again; + } + + error_setg_errno(errp, errno, "failed xs_transaction_end"); + return; + } + + xen_backend_device_create(xenbus, type, name, opts, &local_err); + qobject_unref(opts); + + if (local_err) { + error_propagate_prepend(errp, local_err, + "failed to create '%s' device '%s': ", + type, name); + } +} + +static void xen_bus_type_enumerate(XenBus *xenbus, const char *type) +{ + char *domain_path = g_strdup_printf("backend/%s/%u", type, xen_domid); + char **backend; + unsigned int i, n; + + trace_xen_bus_type_enumerate(type); + + backend = xs_directory(xenbus->xsh, XBT_NULL, domain_path, &n); + if (!backend) { + goto out; + } + + for (i = 0; i < n; i++) { + char *backend_path = g_strdup_printf("%s/%s", domain_path, + backend[i]); + enum xenbus_state backend_state; + + if (xs_node_scanf(xenbus->xsh, XBT_NULL, backend_path, "state", + NULL, "%u", &backend_state) != 1) + backend_state = XenbusStateUnknown; + + if (backend_state == XenbusStateInitialising) { + Error *local_err = NULL; + + xen_bus_backend_create(xenbus, type, backend[i], backend_path, + &local_err); + if (local_err) { + error_report_err(local_err); + } + } + + g_free(backend_path); + } + + free(backend); + +out: + g_free(domain_path); +} + +static void xen_bus_enumerate(void *opaque) +{ + XenBus *xenbus = opaque; + char **type; + unsigned int i, n; + + trace_xen_bus_enumerate(); + + type = xs_directory(xenbus->xsh, XBT_NULL, "backend", &n); + if (!type) { + return; + } + + for (i = 0; i < n; i++) { + xen_bus_type_enumerate(xenbus, type[i]); + } + + free(type); +} + static void xen_bus_unrealize(BusState *bus, Error **errp) { XenBus *xenbus = XEN_BUS(bus); trace_xen_bus_unrealize(); + if (xenbus->backend_watch) { + xen_bus_remove_watch(xenbus, xenbus->backend_watch, NULL); + xenbus->backend_watch = NULL; + } + if (!xenbus->xsh) { return; } @@ -231,6 +372,7 @@ static void xen_bus_realize(BusState *bus, Error **errp) { XenBus *xenbus = XEN_BUS(bus); unsigned int domid; + Error *local_err = NULL; trace_xen_bus_realize(); @@ -250,6 +392,18 @@ static void xen_bus_realize(BusState *bus, Error **errp) notifier_list_init(&xenbus->watch_notifiers); qemu_set_fd_handler(xs_fileno(xenbus->xsh), xen_bus_watch, NULL, xenbus); + + module_call_init(MODULE_INIT_XEN_BACKEND); + + xenbus->backend_watch = + xen_bus_add_watch(xenbus, "", /* domain root node */ + "backend", xen_bus_enumerate, xenbus, &local_err); + if (local_err) { + /* This need not be treated as a hard error so don't propagate */ + error_reportf_err(local_err, + "failed to set up enumeration watch: "); + } + return; fail: @@ -407,7 +561,15 @@ static void xen_device_backend_changed(void *opaque) xendev->backend_state == XenbusStateInitialising || xendev->backend_state == XenbusStateInitWait || xendev->backend_state == XenbusStateUnknown)) { - object_unparent(OBJECT(xendev)); + Error *local_err = NULL; + + if (!xen_backend_try_device_destroy(xendev, &local_err)) { + object_unparent(OBJECT(xendev)); + } + + if (local_err) { + error_report_err(local_err); + } } } diff --git a/include/hw/xen/xen-backend.h b/include/hw/xen/xen-backend.h new file mode 100644 index 0000000000..010d712638 --- /dev/null +++ b/include/hw/xen/xen-backend.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2018 Citrix Systems Inc. + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#ifndef HW_XEN_BACKEND_H +#define HW_XEN_BACKEND_H + +#include "hw/xen/xen-bus.h" + +typedef struct XenBackendInstance XenBackendInstance; + +typedef void (*XenBackendDeviceCreate)(XenBackendInstance *backend, + QDict *opts, Error **errp); +typedef void (*XenBackendDeviceDestroy)(XenBackendInstance *backend, + Error **errp); + +typedef struct XenBackendInfo { + const char *type; + XenBackendDeviceCreate create; + XenBackendDeviceDestroy destroy; +} XenBackendInfo; + +XenBus *xen_backend_get_bus(XenBackendInstance *backend); +const char *xen_backend_get_name(XenBackendInstance *backend); + +void xen_backend_set_device(XenBackendInstance *backend, + XenDevice *xendevice); +XenDevice *xen_backend_get_device(XenBackendInstance *backend); + +void xen_backend_register(const XenBackendInfo *info); + +void xen_backend_device_create(XenBus *xenbus, const char *type, + const char *name, QDict *opts, Error **errp); +bool xen_backend_try_device_destroy(XenDevice *xendev, Error **errp); + +#endif /* HW_XEN_BACKEND_H */ diff --git a/include/hw/xen/xen-bus.h b/include/hw/xen/xen-bus.h index 0834cb3a7e..e55a5de5f1 100644 --- a/include/hw/xen/xen-bus.h +++ b/include/hw/xen/xen-bus.h @@ -65,6 +65,7 @@ typedef struct XenBus { domid_t backend_id; struct xs_handle *xsh; NotifierList watch_notifiers; + XenWatch *backend_watch; } XenBus; typedef struct XenBusClass { diff --git a/include/qemu/module.h b/include/qemu/module.h index 54300ab6e5..55dd2beea8 100644 --- a/include/qemu/module.h +++ b/include/qemu/module.h @@ -44,6 +44,7 @@ typedef enum { MODULE_INIT_OPTS, MODULE_INIT_QOM, MODULE_INIT_TRACE, + MODULE_INIT_XEN_BACKEND, MODULE_INIT_MAX } module_init_type; @@ -51,6 +52,8 @@ typedef enum { #define opts_init(function) module_init(function, MODULE_INIT_OPTS) #define type_init(function) module_init(function, MODULE_INIT_QOM) #define trace_init(function) module_init(function, MODULE_INIT_TRACE) +#define xen_backend_init(function) module_init(function, \ + MODULE_INIT_XEN_BACKEND) #define block_module_load_one(lib) module_load_one("block-", lib) #define ui_module_load_one(lib) module_load_one("ui-", lib) -- Anthony PERARD From mboxrd@z Thu Jan 1 00:00:00 1970 From: Anthony PERARD Subject: [PULL 17/25] xen: add a mechanism to automatically create XenDevice-s... Date: Thu, 10 Jan 2019 13:49:09 +0000 Message-ID: <20190110134917.16425-18-anthony.perard@citrix.com> References: <20190110134917.16425-1-anthony.perard@citrix.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1gharm-0001Ew-HM for xen-devel@lists.xenproject.org; Thu, 10 Jan 2019 13:59:26 +0000 In-Reply-To: <20190110134917.16425-1-anthony.perard@citrix.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: qemu-devel@nongnu.org Cc: Anthony PERARD , xen-devel@lists.xenproject.org, Paul Durrant List-Id: xen-devel@lists.xenproject.org RnJvbTogUGF1bCBEdXJyYW50IDxwYXVsLmR1cnJhbnRAY2l0cml4LmNvbT4KCi4uLnRoYXQgbWFp bnRhaW5zIGNvbXBhdGliaWxpdHkgd2l0aCBleGlzdGluZyBYZW4gdG9vbHN0YWNrcy4KClhlbiB0 b29sc3RhY2tzIGluc3RhbnRpYXRlIFBWIGJhY2tlbmRzIGJ5IHNpbXBseSB3cml0aW5nIGluZm9y bWF0aW9uIGludG8KeGVuc3RvcmUgYW5kIGV4cGVjdGluZyBhIGJhY2tlbmQgaW1wbGVtZW50YXRp b24gdG8gYmUgd2F0Y2hpbmcgZm9yIHRoaXMuCgpUaGlzIHBhdGNoIGFkZHMgYSBuZXcgJ3hlbi1i YWNrZW5kJyBtb2R1bGUgdG8gYWxsb3cgaW5kaXZpZHVhbCBYZW5EZXZpY2UKaW1wbGVtZW50YXRp b25zIHRvIHJlZ2lzdGVyIGNyZWF0ZSBhbmQgZGVzdHJveSBmdW5jdGlvbnMuIFRoZSBjcmVhdG9y CndpbGwgYmUgY2FsbGVkIHdoZW4gYSB0b29sLXN0YWNrIGluc3RhbnRpYXRlcyBhIG5ldyBiYWNr ZW5kIGluIHRoaXMgd2F5LAphbmQgdGhlIGRlc3RydWN0b3Igd2lsbCB0aGVuIGJlIGNhbGxlZCBh ZnRlciB0aGUgcmVzdWx0aW5nIFhlbkRldmljZQpvYmplY3QgaXMgdW5yZWFsaXplZC4KClRvIHN1 cHBvcnQgdGhpcyBpdCBpcyBhbHNvIG5lY2Vzc2FyeSB0byBhZGQgbmV3IHdhdGNoZXJzIGludG8g dGhlIFhlbkJ1cwppbXBsZW1lbnRhdGlvbiB0byBoYW5kbGUgZW51bWVyYXRpb24gb2YgbmV3IGJh Y2tlbmRzIGFuZCBhbHNvIGRlc3RydWN0aW9uCm9mIFhlbkRldmljZS1zIHdoZW4gdGhlIHRvb2xz dGFjayBzZXRzIHRoZSBiYWNrZW5kICdvbmxpbmUnIGtleSB0byAwLgoKTk9URTogVGhpcyBwYXRj aCBvbmx5IGFkZHMgdGhlIGZyYW1ld29yay4gQSBzdWJzZXF1ZW50IHBhdGNoIHdpbGwgYWRkIGEK ICAgICAgY3JlYXRvciBmdW5jdGlvbiBmb3IgeGVuLWJsb2NrIGRldmljZXMuCgpTaWduZWQtb2Zm LWJ5OiBQYXVsIER1cnJhbnQgPHBhdWwuZHVycmFudEBjaXRyaXguY29tPgpSZXZpZXdlZC1ieTog QW50aG9ueSBQZXJhcmQgPGFudGhvbnkucGVyYXJkQGNpdHJpeC5jb20+ClNpZ25lZC1vZmYtYnk6 IEFudGhvbnkgUEVSQVJEIDxhbnRob255LnBlcmFyZEBjaXRyaXguY29tPgotLS0KIGh3L3hlbi9N YWtlZmlsZS5vYmpzICAgICAgICAgfCAgIDIgKy0KIGh3L3hlbi90cmFjZS1ldmVudHMgICAgICAg ICAgfCAgIDMgKwogaHcveGVuL3hlbi1iYWNrZW5kLmMgICAgICAgICB8IDE2NSArKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKwogaHcveGVuL3hlbi1idXMuYyAgICAgICAgICAgICB8 IDE2NCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCiBpbmNsdWRlL2h3L3hlbi94 ZW4tYmFja2VuZC5oIHwgIDM5ICsrKysrKysrKwogaW5jbHVkZS9ody94ZW4veGVuLWJ1cy5oICAg ICB8ICAgMSArCiBpbmNsdWRlL3FlbXUvbW9kdWxlLmggICAgICAgIHwgICAzICsKIDcgZmlsZXMg Y2hhbmdlZCwgMzc1IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAx MDA2NDQgaHcveGVuL3hlbi1iYWNrZW5kLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2h3 L3hlbi94ZW4tYmFja2VuZC5oCgpkaWZmIC0tZ2l0IGEvaHcveGVuL01ha2VmaWxlLm9ianMgYi9o dy94ZW4vTWFrZWZpbGUub2JqcwppbmRleCA3N2MwODY4MTkwLi44NGRmNjBhOTI4IDEwMDY0NAot LS0gYS9ody94ZW4vTWFrZWZpbGUub2JqcworKysgYi9ody94ZW4vTWFrZWZpbGUub2JqcwpAQCAt MSw1ICsxLDUgQEAKICMgeGVuIGJhY2tlbmQgZHJpdmVyIHN1cHBvcnQKLWNvbW1vbi1vYmotJChD T05GSUdfWEVOKSArPSB4ZW4tbGVnYWN5LWJhY2tlbmQubyB4ZW5fZGV2Y29uZmlnLm8geGVuX3B2 ZGV2Lm8geGVuLWNvbW1vbi5vIHhlbi1idXMubyB4ZW4tYnVzLWhlbHBlci5vCitjb21tb24tb2Jq LSQoQ09ORklHX1hFTikgKz0geGVuLWxlZ2FjeS1iYWNrZW5kLm8geGVuX2RldmNvbmZpZy5vIHhl bl9wdmRldi5vIHhlbi1jb21tb24ubyB4ZW4tYnVzLm8geGVuLWJ1cy1oZWxwZXIubyB4ZW4tYmFj a2VuZC5vCiAKIG9iai0kKENPTkZJR19YRU5fUENJX1BBU1NUSFJPVUdIKSArPSB4ZW4taG9zdC1w Y2ktZGV2aWNlLm8KIG9iai0kKENPTkZJR19YRU5fUENJX1BBU1NUSFJPVUdIKSArPSB4ZW5fcHQu byB4ZW5fcHRfY29uZmlnX2luaXQubyB4ZW5fcHRfZ3JhcGhpY3MubyB4ZW5fcHRfbXNpLm8KZGlm ZiAtLWdpdCBhL2h3L3hlbi90cmFjZS1ldmVudHMgYi9ody94ZW4vdHJhY2UtZXZlbnRzCmluZGV4 IGQ0NjUxYmRiMzAuLmY2OTQ0NjI0YjIgMTAwNjQ0Ci0tLSBhL2h3L3hlbi90cmFjZS1ldmVudHMK KysrIGIvaHcveGVuL3RyYWNlLWV2ZW50cwpAQCAtMTYsNiArMTYsOSBAQCB4ZW5fZG9taWRfcmVz dHJpY3QoaW50IGVycikgImVycjogJXUiCiAjIGluY2x1ZGUvaHcveGVuL3hlbi1idXMuYwogeGVu X2J1c19yZWFsaXplKHZvaWQpICIiCiB4ZW5fYnVzX3VucmVhbGl6ZSh2b2lkKSAiIgoreGVuX2J1 c19lbnVtZXJhdGUodm9pZCkgIiIKK3hlbl9idXNfdHlwZV9lbnVtZXJhdGUoY29uc3QgY2hhciAq dHlwZSkgInR5cGU6ICVzIgoreGVuX2J1c19iYWNrZW5kX2NyZWF0ZShjb25zdCBjaGFyICp0eXBl LCBjb25zdCBjaGFyICpwYXRoKSAidHlwZTogJXMgcGF0aDogJXMiCiB4ZW5fYnVzX2FkZF93YXRj aChjb25zdCBjaGFyICpub2RlLCBjb25zdCBjaGFyICprZXksIGNoYXIgKnRva2VuKSAibm9kZTog JXMga2V5OiAlcyB0b2tlbjogJXMiCiB4ZW5fYnVzX3JlbW92ZV93YXRjaChjb25zdCBjaGFyICpu b2RlLCBjb25zdCBjaGFyICprZXksIGNoYXIgKnRva2VuKSAibm9kZTogJXMga2V5OiAlcyB0b2tl bjogJXMiCiB4ZW5fYnVzX3dhdGNoKGNvbnN0IGNoYXIgKnRva2VuKSAidG9rZW46ICVzIgpkaWZm IC0tZ2l0IGEvaHcveGVuL3hlbi1iYWNrZW5kLmMgYi9ody94ZW4veGVuLWJhY2tlbmQuYwpuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwLi5kYTA2NWY4MWI3Ci0tLSAvZGV2L251 bGwKKysrIGIvaHcveGVuL3hlbi1iYWNrZW5kLmMKQEAgLTAsMCArMSwxNjUgQEAKKy8qCisgKiBD b3B5cmlnaHQgKGMpIDIwMTggIENpdHJpeCBTeXN0ZW1zIEluYy4KKyAqCisgKiBUaGlzIHdvcmsg aXMgbGljZW5zZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR1BMLCB2ZXJzaW9uIDIgb3Ig bGF0ZXIuCisgKiBTZWUgdGhlIENPUFlJTkcgZmlsZSBpbiB0aGUgdG9wLWxldmVsIGRpcmVjdG9y eS4KKyAqLworCisjaW5jbHVkZSAicWVtdS9vc2RlcC5oIgorI2luY2x1ZGUgInFlbXUvZXJyb3It cmVwb3J0LmgiCisjaW5jbHVkZSAicWFwaS9lcnJvci5oIgorI2luY2x1ZGUgImh3L3hlbi94ZW4t YmFja2VuZC5oIgorI2luY2x1ZGUgImh3L3hlbi94ZW4tYnVzLmgiCisKK3R5cGVkZWYgc3RydWN0 IFhlbkJhY2tlbmRJbXBsIHsKKyAgICBjb25zdCBjaGFyICp0eXBlOworICAgIFhlbkJhY2tlbmRE ZXZpY2VDcmVhdGUgY3JlYXRlOworICAgIFhlbkJhY2tlbmREZXZpY2VEZXN0cm95IGRlc3Ryb3k7 Cit9IFhlbkJhY2tlbmRJbXBsOworCitzdHJ1Y3QgWGVuQmFja2VuZEluc3RhbmNlIHsKKyAgICBR TElTVF9FTlRSWShYZW5CYWNrZW5kSW5zdGFuY2UpIGVudHJ5OworICAgIGNvbnN0IFhlbkJhY2tl bmRJbXBsICppbXBsOworICAgIFhlbkJ1cyAqeGVuYnVzOworICAgIGNoYXIgKm5hbWU7CisgICAg WGVuRGV2aWNlICp4ZW5kZXY7Cit9OworCitzdGF0aWMgR0hhc2hUYWJsZSAqeGVuX2JhY2tlbmRf dGFibGVfZ2V0KHZvaWQpCit7CisgICAgc3RhdGljIEdIYXNoVGFibGUgKnRhYmxlOworCisgICAg aWYgKHRhYmxlID09IE5VTEwpIHsKKyAgICAgICAgdGFibGUgPSBnX2hhc2hfdGFibGVfbmV3KGdf c3RyX2hhc2gsIGdfc3RyX2VxdWFsKTsKKyAgICB9CisKKyAgICByZXR1cm4gdGFibGU7Cit9CisK K3N0YXRpYyB2b2lkIHhlbl9iYWNrZW5kX3RhYmxlX2FkZChYZW5CYWNrZW5kSW1wbCAqaW1wbCkK K3sKKyAgICBnX2hhc2hfdGFibGVfaW5zZXJ0KHhlbl9iYWNrZW5kX3RhYmxlX2dldCgpLCAodm9p ZCAqKWltcGwtPnR5cGUsIGltcGwpOworfQorCitzdGF0aWMgY29uc3QgWGVuQmFja2VuZEltcGwg Knhlbl9iYWNrZW5kX3RhYmxlX2xvb2t1cChjb25zdCBjaGFyICp0eXBlKQoreworICAgIHJldHVy biBnX2hhc2hfdGFibGVfbG9va3VwKHhlbl9iYWNrZW5kX3RhYmxlX2dldCgpLCB0eXBlKTsKK30K Kwordm9pZCB4ZW5fYmFja2VuZF9yZWdpc3Rlcihjb25zdCBYZW5CYWNrZW5kSW5mbyAqaW5mbykK K3sKKyAgICBYZW5CYWNrZW5kSW1wbCAqaW1wbCA9IGdfbmV3MChYZW5CYWNrZW5kSW1wbCwgMSk7 CisKKyAgICBnX2Fzc2VydChpbmZvLT50eXBlKTsKKworICAgIGlmICh4ZW5fYmFja2VuZF90YWJs ZV9sb29rdXAoaW5mby0+dHlwZSkpIHsKKyAgICAgICAgZXJyb3JfcmVwb3J0KCJhdHRlbXB0IHRv IHJlZ2lzdGVyIGR1cGxpY2F0ZSBYZW4gYmFja2VuZCB0eXBlICclcyciLAorICAgICAgICAgICAg ICAgICAgICAgaW5mby0+dHlwZSk7CisgICAgICAgIGFib3J0KCk7CisgICAgfQorCisgICAgaWYg KCFpbmZvLT5jcmVhdGUpIHsKKyAgICAgICAgZXJyb3JfcmVwb3J0KCJiYWNrZW5kIHR5cGUgJyVz JyBoYXMgbm8gY3JlYXRvciIsIGluZm8tPnR5cGUpOworICAgICAgICBhYm9ydCgpOworICAgIH0K KworICAgIGltcGwtPnR5cGUgPSBpbmZvLT50eXBlOworICAgIGltcGwtPmNyZWF0ZSA9IGluZm8t PmNyZWF0ZTsKKyAgICBpbXBsLT5kZXN0cm95ID0gaW5mby0+ZGVzdHJveTsKKworICAgIHhlbl9i YWNrZW5kX3RhYmxlX2FkZChpbXBsKTsKK30KKworc3RhdGljIFFMSVNUX0hFQUQoLCBYZW5CYWNr ZW5kSW5zdGFuY2UpIGJhY2tlbmRfbGlzdDsKKworc3RhdGljIHZvaWQgeGVuX2JhY2tlbmRfbGlz dF9hZGQoWGVuQmFja2VuZEluc3RhbmNlICpiYWNrZW5kKQoreworICAgIFFMSVNUX0lOU0VSVF9I RUFEKCZiYWNrZW5kX2xpc3QsIGJhY2tlbmQsIGVudHJ5KTsKK30KKworc3RhdGljIFhlbkJhY2tl bmRJbnN0YW5jZSAqeGVuX2JhY2tlbmRfbGlzdF9maW5kKFhlbkRldmljZSAqeGVuZGV2KQorewor ICAgIFhlbkJhY2tlbmRJbnN0YW5jZSAqYmFja2VuZDsKKworICAgIFFMSVNUX0ZPUkVBQ0goYmFj a2VuZCwgJmJhY2tlbmRfbGlzdCwgZW50cnkpIHsKKyAgICAgICAgaWYgKGJhY2tlbmQtPnhlbmRl diA9PSB4ZW5kZXYpIHsKKyAgICAgICAgICAgIHJldHVybiBiYWNrZW5kOworICAgICAgICB9Cisg ICAgfQorCisgICAgcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkIHhlbl9iYWNrZW5kX2xp c3RfcmVtb3ZlKFhlbkJhY2tlbmRJbnN0YW5jZSAqYmFja2VuZCkKK3sKKyAgICBRTElTVF9SRU1P VkUoYmFja2VuZCwgZW50cnkpOworfQorCit2b2lkIHhlbl9iYWNrZW5kX2RldmljZV9jcmVhdGUo WGVuQnVzICp4ZW5idXMsIGNvbnN0IGNoYXIgKnR5cGUsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgY29uc3QgY2hhciAqbmFtZSwgUURpY3QgKm9wdHMsIEVycm9yICoqZXJycCkKK3sK KyAgICBjb25zdCBYZW5CYWNrZW5kSW1wbCAqaW1wbCA9IHhlbl9iYWNrZW5kX3RhYmxlX2xvb2t1 cCh0eXBlKTsKKyAgICBYZW5CYWNrZW5kSW5zdGFuY2UgKmJhY2tlbmQ7CisgICAgRXJyb3IgKmxv Y2FsX2Vycm9yID0gTlVMTDsKKworICAgIGlmICghaW1wbCkgeworICAgICAgICByZXR1cm47Cisg ICAgfQorCisgICAgYmFja2VuZCA9IGdfbmV3MChYZW5CYWNrZW5kSW5zdGFuY2UsIDEpOworICAg IGJhY2tlbmQtPnhlbmJ1cyA9IHhlbmJ1czsKKyAgICBiYWNrZW5kLT5uYW1lID0gZ19zdHJkdXAo bmFtZSk7CisKKyAgICBpbXBsLT5jcmVhdGUoYmFja2VuZCwgb3B0cywgJmxvY2FsX2Vycm9yKTsK KyAgICBpZiAobG9jYWxfZXJyb3IpIHsKKyAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxv Y2FsX2Vycm9yKTsKKyAgICAgICAgZ19mcmVlKGJhY2tlbmQtPm5hbWUpOworICAgICAgICBnX2Zy ZWUoYmFja2VuZCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBiYWNrZW5kLT5pbXBs ID0gaW1wbDsKKyAgICB4ZW5fYmFja2VuZF9saXN0X2FkZChiYWNrZW5kKTsKK30KKworWGVuQnVz ICp4ZW5fYmFja2VuZF9nZXRfYnVzKFhlbkJhY2tlbmRJbnN0YW5jZSAqYmFja2VuZCkKK3sKKyAg ICByZXR1cm4gYmFja2VuZC0+eGVuYnVzOworfQorCitjb25zdCBjaGFyICp4ZW5fYmFja2VuZF9n ZXRfbmFtZShYZW5CYWNrZW5kSW5zdGFuY2UgKmJhY2tlbmQpCit7CisgICAgcmV0dXJuIGJhY2tl bmQtPm5hbWU7Cit9CisKK3ZvaWQgeGVuX2JhY2tlbmRfc2V0X2RldmljZShYZW5CYWNrZW5kSW5z dGFuY2UgKmJhY2tlbmQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgWGVuRGV2aWNlICp4 ZW5kZXYpCit7CisgICAgZ19hc3NlcnQoIWJhY2tlbmQtPnhlbmRldik7CisgICAgYmFja2VuZC0+ eGVuZGV2ID0geGVuZGV2OworfQorCitYZW5EZXZpY2UgKnhlbl9iYWNrZW5kX2dldF9kZXZpY2Uo WGVuQmFja2VuZEluc3RhbmNlICpiYWNrZW5kKQoreworICAgIHJldHVybiBiYWNrZW5kLT54ZW5k ZXY7Cit9CisKKworYm9vbCB4ZW5fYmFja2VuZF90cnlfZGV2aWNlX2Rlc3Ryb3koWGVuRGV2aWNl ICp4ZW5kZXYsIEVycm9yICoqZXJycCkKK3sKKyAgICBYZW5CYWNrZW5kSW5zdGFuY2UgKmJhY2tl bmQgPSB4ZW5fYmFja2VuZF9saXN0X2ZpbmQoeGVuZGV2KTsKKyAgICBjb25zdCBYZW5CYWNrZW5k SW1wbCAqaW1wbDsKKworICAgIGlmICghYmFja2VuZCkgeworICAgICAgICByZXR1cm4gZmFsc2U7 CisgICAgfQorCisgICAgaW1wbCA9IGJhY2tlbmQtPmltcGw7CisgICAgaW1wbC0+ZGVzdHJveShi YWNrZW5kLCBlcnJwKTsKKworICAgIHhlbl9iYWNrZW5kX2xpc3RfcmVtb3ZlKGJhY2tlbmQpOwor ICAgIGdfZnJlZShiYWNrZW5kLT5uYW1lKTsKKyAgICBnX2ZyZWUoYmFja2VuZCk7CisKKyAgICBy ZXR1cm4gdHJ1ZTsKK30KZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW4tYnVzLmMgYi9ody94ZW4veGVu LWJ1cy5jCmluZGV4IGEyMmFhNDk5MjEuLmY5MGJjZjIzNDIgMTAwNjQ0Ci0tLSBhL2h3L3hlbi94 ZW4tYnVzLmMKKysrIGIvaHcveGVuL3hlbi1idXMuYwpAQCAtMTEsMTAgKzExLDEyIEBACiAjaW5j bHVkZSAiaHcvaHcuaCIKICNpbmNsdWRlICJody9zeXNidXMuaCIKICNpbmNsdWRlICJody94ZW4v eGVuLmgiCisjaW5jbHVkZSAiaHcveGVuL3hlbi1iYWNrZW5kLmgiCiAjaW5jbHVkZSAiaHcveGVu L3hlbi1idXMuaCIKICNpbmNsdWRlICJody94ZW4veGVuLWJ1cy1oZWxwZXIuaCIKICNpbmNsdWRl ICJtb25pdG9yL21vbml0b3IuaCIKICNpbmNsdWRlICJxYXBpL2Vycm9yLmgiCisjaW5jbHVkZSAi cWFwaS9xbXAvcWRpY3QuaCIKICNpbmNsdWRlICJzeXNlbXUvc3lzZW11LmgiCiAjaW5jbHVkZSAi dHJhY2UuaCIKIApAQCAtMTkwLDEyICsxOTIsMTUxIEBAIHN0YXRpYyB2b2lkIHhlbl9idXNfcmVt b3ZlX3dhdGNoKFhlbkJ1cyAqeGVuYnVzLCBYZW5XYXRjaCAqd2F0Y2gsCiAgICAgZnJlZV93YXRj aCh3YXRjaCk7CiB9CiAKK3N0YXRpYyB2b2lkIHhlbl9idXNfYmFja2VuZF9jcmVhdGUoWGVuQnVz ICp4ZW5idXMsIGNvbnN0IGNoYXIgKnR5cGUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGNvbnN0IGNoYXIgKm5hbWUsIGNoYXIgKnBhdGgsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIEVycm9yICoqZXJycCkKK3sKKyAgICB4c190cmFuc2FjdGlvbl90IHRp ZDsKKyAgICBjaGFyICoqa2V5OworICAgIFFEaWN0ICpvcHRzOworICAgIHVuc2lnbmVkIGludCBp LCBuOworICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOworCisgICAgdHJhY2VfeGVuX2J1c19i YWNrZW5kX2NyZWF0ZSh0eXBlLCBwYXRoKTsKKworYWdhaW46CisgICAgdGlkID0geHNfdHJhbnNh Y3Rpb25fc3RhcnQoeGVuYnVzLT54c2gpOworICAgIGlmICh0aWQgPT0gWEJUX05VTEwpIHsKKyAg ICAgICAgZXJyb3Jfc2V0ZyhlcnJwLCAiZmFpbGVkIHhzX3RyYW5zYWN0aW9uX3N0YXJ0Iik7Cisg ICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBrZXkgPSB4c19kaXJlY3RvcnkoeGVuYnVzLT54 c2gsIHRpZCwgcGF0aCwgJm4pOworICAgIGlmICgha2V5KSB7CisgICAgICAgIGlmICgheHNfdHJh bnNhY3Rpb25fZW5kKHhlbmJ1cy0+eHNoLCB0aWQsIHRydWUpKSB7CisgICAgICAgICAgICBlcnJv cl9zZXRnX2Vycm5vKGVycnAsIGVycm5vLCAiZmFpbGVkIHhzX3RyYW5zYWN0aW9uX2VuZCIpOwor ICAgICAgICB9CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBvcHRzID0gcWRpY3RfbmV3 KCk7CisgICAgZm9yIChpID0gMDsgaSA8IG47IGkrKykgeworICAgICAgICBjaGFyICp2YWw7CisK KyAgICAgICAgLyoKKyAgICAgICAgICogQXNzdW1lIGFueXRoaW5nIGZvdW5kIGluIHRoZSB4ZW5z dG9yZSBiYWNrZW5kIGFyZWEsIG90aGVyIHRoYW4KKyAgICAgICAgICogdGhlIGtleXMgY3JlYXRl ZCBmb3IgYSBnZW5lcmljIFhlbkRldmljZSwgYXJlIHBhcmFtZXRlcnMKKyAgICAgICAgICogdG8g YmUgdXNlZCB0byBjb25maWd1cmUgdGhlIGJhY2tlbmQuCisgICAgICAgICAqLworICAgICAgICBp ZiAoIXN0cmNtcChrZXlbaV0sICJzdGF0ZSIpIHx8CisgICAgICAgICAgICAhc3RyY21wKGtleVtp XSwgIm9ubGluZSIpIHx8CisgICAgICAgICAgICAhc3RyY21wKGtleVtpXSwgImZyb250ZW5kIikg fHwKKyAgICAgICAgICAgICFzdHJjbXAoa2V5W2ldLCAiZnJvbnRlbmQtaWQiKSB8fAorICAgICAg ICAgICAgIXN0cmNtcChrZXlbaV0sICJob3RwbHVnLXN0YXR1cyIpKQorICAgICAgICAgICAgY29u dGludWU7CisKKyAgICAgICAgaWYgKHhzX25vZGVfc2NhbmYoeGVuYnVzLT54c2gsIHRpZCwgcGF0 aCwga2V5W2ldLCBOVUxMLCAiJW1zIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgJnZhbCkg PT0gMSkgeworICAgICAgICAgICAgcWRpY3RfcHV0X3N0cihvcHRzLCBrZXlbaV0sIHZhbCk7Cisg ICAgICAgICAgICBmcmVlKHZhbCk7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBmcmVlKGtleSk7 CisKKyAgICBpZiAoIXhzX3RyYW5zYWN0aW9uX2VuZCh4ZW5idXMtPnhzaCwgdGlkLCBmYWxzZSkp IHsKKyAgICAgICAgcW9iamVjdF91bnJlZihvcHRzKTsKKworICAgICAgICBpZiAoZXJybm8gPT0g RUFHQUlOKSB7CisgICAgICAgICAgICBnb3RvIGFnYWluOworICAgICAgICB9CisKKyAgICAgICAg ZXJyb3Jfc2V0Z19lcnJubyhlcnJwLCBlcnJubywgImZhaWxlZCB4c190cmFuc2FjdGlvbl9lbmQi KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHhlbl9iYWNrZW5kX2RldmljZV9jcmVh dGUoeGVuYnVzLCB0eXBlLCBuYW1lLCBvcHRzLCAmbG9jYWxfZXJyKTsKKyAgICBxb2JqZWN0X3Vu cmVmKG9wdHMpOworCisgICAgaWYgKGxvY2FsX2VycikgeworICAgICAgICBlcnJvcl9wcm9wYWdh dGVfcHJlcGVuZChlcnJwLCBsb2NhbF9lcnIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICJmYWlsZWQgdG8gY3JlYXRlICclcycgZGV2aWNlICclcyc6ICIsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHR5cGUsIG5hbWUpOworICAgIH0KK30KKworc3RhdGljIHZvaWQg eGVuX2J1c190eXBlX2VudW1lcmF0ZShYZW5CdXMgKnhlbmJ1cywgY29uc3QgY2hhciAqdHlwZSkK K3sKKyAgICBjaGFyICpkb21haW5fcGF0aCA9IGdfc3RyZHVwX3ByaW50ZigiYmFja2VuZC8lcy8l dSIsIHR5cGUsIHhlbl9kb21pZCk7CisgICAgY2hhciAqKmJhY2tlbmQ7CisgICAgdW5zaWduZWQg aW50IGksIG47CisKKyAgICB0cmFjZV94ZW5fYnVzX3R5cGVfZW51bWVyYXRlKHR5cGUpOworCisg ICAgYmFja2VuZCA9IHhzX2RpcmVjdG9yeSh4ZW5idXMtPnhzaCwgWEJUX05VTEwsIGRvbWFpbl9w YXRoLCAmbik7CisgICAgaWYgKCFiYWNrZW5kKSB7CisgICAgICAgIGdvdG8gb3V0OworICAgIH0K KworICAgIGZvciAoaSA9IDA7IGkgPCBuOyBpKyspIHsKKyAgICAgICAgY2hhciAqYmFja2VuZF9w YXRoID0gZ19zdHJkdXBfcHJpbnRmKCIlcy8lcyIsIGRvbWFpbl9wYXRoLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYmFja2VuZFtpXSk7CisgICAgICAgIGVu dW0geGVuYnVzX3N0YXRlIGJhY2tlbmRfc3RhdGU7CisKKyAgICAgICAgaWYgKHhzX25vZGVfc2Nh bmYoeGVuYnVzLT54c2gsIFhCVF9OVUxMLCBiYWNrZW5kX3BhdGgsICJzdGF0ZSIsCisgICAgICAg ICAgICAgICAgICAgICAgICAgIE5VTEwsICIldSIsICZiYWNrZW5kX3N0YXRlKSAhPSAxKQorICAg ICAgICAgICAgYmFja2VuZF9zdGF0ZSA9IFhlbmJ1c1N0YXRlVW5rbm93bjsKKworICAgICAgICBp ZiAoYmFja2VuZF9zdGF0ZSA9PSBYZW5idXNTdGF0ZUluaXRpYWxpc2luZykgeworICAgICAgICAg ICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7CisKKyAgICAgICAgICAgIHhlbl9idXNfYmFja2Vu ZF9jcmVhdGUoeGVuYnVzLCB0eXBlLCBiYWNrZW5kW2ldLCBiYWNrZW5kX3BhdGgsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICZsb2NhbF9lcnIpOworICAgICAgICAgICAgaWYg KGxvY2FsX2VycikgeworICAgICAgICAgICAgICAgIGVycm9yX3JlcG9ydF9lcnIobG9jYWxfZXJy KTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorCisgICAgICAgIGdfZnJlZShiYWNrZW5kX3Bh dGgpOworICAgIH0KKworICAgIGZyZWUoYmFja2VuZCk7CisKK291dDoKKyAgICBnX2ZyZWUoZG9t YWluX3BhdGgpOworfQorCitzdGF0aWMgdm9pZCB4ZW5fYnVzX2VudW1lcmF0ZSh2b2lkICpvcGFx dWUpCit7CisgICAgWGVuQnVzICp4ZW5idXMgPSBvcGFxdWU7CisgICAgY2hhciAqKnR5cGU7Cisg ICAgdW5zaWduZWQgaW50IGksIG47CisKKyAgICB0cmFjZV94ZW5fYnVzX2VudW1lcmF0ZSgpOwor CisgICAgdHlwZSA9IHhzX2RpcmVjdG9yeSh4ZW5idXMtPnhzaCwgWEJUX05VTEwsICJiYWNrZW5k IiwgJm4pOworICAgIGlmICghdHlwZSkgeworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAg Zm9yIChpID0gMDsgaSA8IG47IGkrKykgeworICAgICAgICB4ZW5fYnVzX3R5cGVfZW51bWVyYXRl KHhlbmJ1cywgdHlwZVtpXSk7CisgICAgfQorCisgICAgZnJlZSh0eXBlKTsKK30KKwogc3RhdGlj IHZvaWQgeGVuX2J1c191bnJlYWxpemUoQnVzU3RhdGUgKmJ1cywgRXJyb3IgKiplcnJwKQogewog ICAgIFhlbkJ1cyAqeGVuYnVzID0gWEVOX0JVUyhidXMpOwogCiAgICAgdHJhY2VfeGVuX2J1c191 bnJlYWxpemUoKTsKIAorICAgIGlmICh4ZW5idXMtPmJhY2tlbmRfd2F0Y2gpIHsKKyAgICAgICAg eGVuX2J1c19yZW1vdmVfd2F0Y2goeGVuYnVzLCB4ZW5idXMtPmJhY2tlbmRfd2F0Y2gsIE5VTEwp OworICAgICAgICB4ZW5idXMtPmJhY2tlbmRfd2F0Y2ggPSBOVUxMOworICAgIH0KKwogICAgIGlm ICgheGVuYnVzLT54c2gpIHsKICAgICAgICAgcmV0dXJuOwogICAgIH0KQEAgLTIzMSw2ICszNzIs NyBAQCBzdGF0aWMgdm9pZCB4ZW5fYnVzX3JlYWxpemUoQnVzU3RhdGUgKmJ1cywgRXJyb3IgKipl cnJwKQogewogICAgIFhlbkJ1cyAqeGVuYnVzID0gWEVOX0JVUyhidXMpOwogICAgIHVuc2lnbmVk IGludCBkb21pZDsKKyAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKIAogICAgIHRyYWNlX3hl bl9idXNfcmVhbGl6ZSgpOwogCkBAIC0yNTAsNiArMzkyLDE4IEBAIHN0YXRpYyB2b2lkIHhlbl9i dXNfcmVhbGl6ZShCdXNTdGF0ZSAqYnVzLCBFcnJvciAqKmVycnApCiAgICAgbm90aWZpZXJfbGlz dF9pbml0KCZ4ZW5idXMtPndhdGNoX25vdGlmaWVycyk7CiAgICAgcWVtdV9zZXRfZmRfaGFuZGxl cih4c19maWxlbm8oeGVuYnVzLT54c2gpLCB4ZW5fYnVzX3dhdGNoLCBOVUxMLAogICAgICAgICAg ICAgICAgICAgICAgICAgeGVuYnVzKTsKKworICAgIG1vZHVsZV9jYWxsX2luaXQoTU9EVUxFX0lO SVRfWEVOX0JBQ0tFTkQpOworCisgICAgeGVuYnVzLT5iYWNrZW5kX3dhdGNoID0KKyAgICAgICAg eGVuX2J1c19hZGRfd2F0Y2goeGVuYnVzLCAiIiwgLyogZG9tYWluIHJvb3Qgbm9kZSAqLworICAg ICAgICAgICAgICAgICAgICAgICAgICAiYmFja2VuZCIsIHhlbl9idXNfZW51bWVyYXRlLCB4ZW5i dXMsICZsb2NhbF9lcnIpOworICAgIGlmIChsb2NhbF9lcnIpIHsKKyAgICAgICAgLyogVGhpcyBu ZWVkIG5vdCBiZSB0cmVhdGVkIGFzIGEgaGFyZCBlcnJvciBzbyBkb24ndCBwcm9wYWdhdGUgKi8K KyAgICAgICAgZXJyb3JfcmVwb3J0Zl9lcnIobG9jYWxfZXJyLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAiZmFpbGVkIHRvIHNldCB1cCBlbnVtZXJhdGlvbiB3YXRjaDogIik7CisgICAgfQor CiAgICAgcmV0dXJuOwogCiBmYWlsOgpAQCAtNDA3LDcgKzU2MSwxNSBAQCBzdGF0aWMgdm9pZCB4 ZW5fZGV2aWNlX2JhY2tlbmRfY2hhbmdlZCh2b2lkICpvcGFxdWUpCiAgICAgICAgICAgICAgICAg eGVuZGV2LT5iYWNrZW5kX3N0YXRlID09IFhlbmJ1c1N0YXRlSW5pdGlhbGlzaW5nIHx8CiAgICAg ICAgICAgICAgICAgeGVuZGV2LT5iYWNrZW5kX3N0YXRlID09IFhlbmJ1c1N0YXRlSW5pdFdhaXQg fHwKICAgICAgICAgICAgICAgICB4ZW5kZXYtPmJhY2tlbmRfc3RhdGUgPT0gWGVuYnVzU3RhdGVV bmtub3duKSkgewotICAgICAgICBvYmplY3RfdW5wYXJlbnQoT0JKRUNUKHhlbmRldikpOworICAg ICAgICBFcnJvciAqbG9jYWxfZXJyID0gTlVMTDsKKworICAgICAgICBpZiAoIXhlbl9iYWNrZW5k X3RyeV9kZXZpY2VfZGVzdHJveSh4ZW5kZXYsICZsb2NhbF9lcnIpKSB7CisgICAgICAgICAgICBv YmplY3RfdW5wYXJlbnQoT0JKRUNUKHhlbmRldikpOworICAgICAgICB9CisKKyAgICAgICAgaWYg KGxvY2FsX2VycikgeworICAgICAgICAgICAgZXJyb3JfcmVwb3J0X2Vycihsb2NhbF9lcnIpOwor ICAgICAgICB9CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2h3L3hlbi94ZW4tYmFj a2VuZC5oIGIvaW5jbHVkZS9ody94ZW4veGVuLWJhY2tlbmQuaApuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwLi4wMTBkNzEyNjM4Ci0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVk ZS9ody94ZW4veGVuLWJhY2tlbmQuaApAQCAtMCwwICsxLDM5IEBACisvKgorICogQ29weXJpZ2h0 IChjKSAyMDE4ICBDaXRyaXggU3lzdGVtcyBJbmMuCisgKgorICogVGhpcyB3b3JrIGlzIGxpY2Vu c2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdQTCwgdmVyc2lvbiAyIG9yIGxhdGVyLgor ICogU2VlIHRoZSBDT1BZSU5HIGZpbGUgaW4gdGhlIHRvcC1sZXZlbCBkaXJlY3RvcnkuCisgKi8K KworI2lmbmRlZiBIV19YRU5fQkFDS0VORF9ICisjZGVmaW5lIEhXX1hFTl9CQUNLRU5EX0gKKwor I2luY2x1ZGUgImh3L3hlbi94ZW4tYnVzLmgiCisKK3R5cGVkZWYgc3RydWN0IFhlbkJhY2tlbmRJ bnN0YW5jZSBYZW5CYWNrZW5kSW5zdGFuY2U7CisKK3R5cGVkZWYgdm9pZCAoKlhlbkJhY2tlbmRE ZXZpY2VDcmVhdGUpKFhlbkJhY2tlbmRJbnN0YW5jZSAqYmFja2VuZCwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIFFEaWN0ICpvcHRzLCBFcnJvciAqKmVycnApOwordHlw ZWRlZiB2b2lkICgqWGVuQmFja2VuZERldmljZURlc3Ryb3kpKFhlbkJhY2tlbmRJbnN0YW5jZSAq YmFja2VuZCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBFcnJvciAq KmVycnApOworCit0eXBlZGVmIHN0cnVjdCBYZW5CYWNrZW5kSW5mbyB7CisgICAgY29uc3QgY2hh ciAqdHlwZTsKKyAgICBYZW5CYWNrZW5kRGV2aWNlQ3JlYXRlIGNyZWF0ZTsKKyAgICBYZW5CYWNr ZW5kRGV2aWNlRGVzdHJveSBkZXN0cm95OworfSBYZW5CYWNrZW5kSW5mbzsKKworWGVuQnVzICp4 ZW5fYmFja2VuZF9nZXRfYnVzKFhlbkJhY2tlbmRJbnN0YW5jZSAqYmFja2VuZCk7Citjb25zdCBj aGFyICp4ZW5fYmFja2VuZF9nZXRfbmFtZShYZW5CYWNrZW5kSW5zdGFuY2UgKmJhY2tlbmQpOwor Cit2b2lkIHhlbl9iYWNrZW5kX3NldF9kZXZpY2UoWGVuQmFja2VuZEluc3RhbmNlICpiYWNrZW5k LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIFhlbkRldmljZSAqeGVuZGV2aWNlKTsKK1hl bkRldmljZSAqeGVuX2JhY2tlbmRfZ2V0X2RldmljZShYZW5CYWNrZW5kSW5zdGFuY2UgKmJhY2tl bmQpOworCit2b2lkIHhlbl9iYWNrZW5kX3JlZ2lzdGVyKGNvbnN0IFhlbkJhY2tlbmRJbmZvICpp bmZvKTsKKwordm9pZCB4ZW5fYmFja2VuZF9kZXZpY2VfY3JlYXRlKFhlbkJ1cyAqeGVuYnVzLCBj b25zdCBjaGFyICp0eXBlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNo YXIgKm5hbWUsIFFEaWN0ICpvcHRzLCBFcnJvciAqKmVycnApOworYm9vbCB4ZW5fYmFja2VuZF90 cnlfZGV2aWNlX2Rlc3Ryb3koWGVuRGV2aWNlICp4ZW5kZXYsIEVycm9yICoqZXJycCk7CisKKyNl bmRpZiAvKiBIV19YRU5fQkFDS0VORF9IICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2h3L3hlbi94 ZW4tYnVzLmggYi9pbmNsdWRlL2h3L3hlbi94ZW4tYnVzLmgKaW5kZXggMDgzNGNiM2E3ZS4uZTU1 YTVkZTVmMSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9ody94ZW4veGVuLWJ1cy5oCisrKyBiL2luY2x1 ZGUvaHcveGVuL3hlbi1idXMuaApAQCAtNjUsNiArNjUsNyBAQCB0eXBlZGVmIHN0cnVjdCBYZW5C dXMgewogICAgIGRvbWlkX3QgYmFja2VuZF9pZDsKICAgICBzdHJ1Y3QgeHNfaGFuZGxlICp4c2g7 CiAgICAgTm90aWZpZXJMaXN0IHdhdGNoX25vdGlmaWVyczsKKyAgICBYZW5XYXRjaCAqYmFja2Vu ZF93YXRjaDsKIH0gWGVuQnVzOwogCiB0eXBlZGVmIHN0cnVjdCBYZW5CdXNDbGFzcyB7CmRpZmYg LS1naXQgYS9pbmNsdWRlL3FlbXUvbW9kdWxlLmggYi9pbmNsdWRlL3FlbXUvbW9kdWxlLmgKaW5k ZXggNTQzMDBhYjZlNS4uNTVkZDJiZWVhOCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9xZW11L21vZHVs ZS5oCisrKyBiL2luY2x1ZGUvcWVtdS9tb2R1bGUuaApAQCAtNDQsNiArNDQsNyBAQCB0eXBlZGVm IGVudW0gewogICAgIE1PRFVMRV9JTklUX09QVFMsCiAgICAgTU9EVUxFX0lOSVRfUU9NLAogICAg IE1PRFVMRV9JTklUX1RSQUNFLAorICAgIE1PRFVMRV9JTklUX1hFTl9CQUNLRU5ELAogICAgIE1P RFVMRV9JTklUX01BWAogfSBtb2R1bGVfaW5pdF90eXBlOwogCkBAIC01MSw2ICs1Miw4IEBAIHR5 cGVkZWYgZW51bSB7CiAjZGVmaW5lIG9wdHNfaW5pdChmdW5jdGlvbikgbW9kdWxlX2luaXQoZnVu Y3Rpb24sIE1PRFVMRV9JTklUX09QVFMpCiAjZGVmaW5lIHR5cGVfaW5pdChmdW5jdGlvbikgbW9k dWxlX2luaXQoZnVuY3Rpb24sIE1PRFVMRV9JTklUX1FPTSkKICNkZWZpbmUgdHJhY2VfaW5pdChm dW5jdGlvbikgbW9kdWxlX2luaXQoZnVuY3Rpb24sIE1PRFVMRV9JTklUX1RSQUNFKQorI2RlZmlu ZSB4ZW5fYmFja2VuZF9pbml0KGZ1bmN0aW9uKSBtb2R1bGVfaW5pdChmdW5jdGlvbiwgXAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBNT0RVTEVfSU5JVF9Y RU5fQkFDS0VORCkKIAogI2RlZmluZSBibG9ja19tb2R1bGVfbG9hZF9vbmUobGliKSBtb2R1bGVf bG9hZF9vbmUoImJsb2NrLSIsIGxpYikKICNkZWZpbmUgdWlfbW9kdWxlX2xvYWRfb25lKGxpYikg bW9kdWxlX2xvYWRfb25lKCJ1aS0iLCBsaWIpCi0tIApBbnRob255IFBFUkFSRAoKCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5n IGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCmh0dHBzOi8vbGlzdHMueGVucHJv amVjdC5vcmcvbWFpbG1hbi9saXN0aW5mby94ZW4tZGV2ZWw=