From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:58978) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bMDE3-0006L6-4R for qemu-devel@nongnu.org; Sun, 10 Jul 2016 07:48:48 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1bMDE0-0001nZ-5u for qemu-devel@nongnu.org; Sun, 10 Jul 2016 07:48:42 -0400 Received: from mail-wm0-x241.google.com ([2a00:1450:400c:c09::241]:34340) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1bMDDz-0001nR-Ry for qemu-devel@nongnu.org; Sun, 10 Jul 2016 07:48:40 -0400 Received: by mail-wm0-x241.google.com with SMTP id w75so13127194wmd.1 for ; Sun, 10 Jul 2016 04:48:39 -0700 (PDT) From: Emil Condrea Date: Sun, 10 Jul 2016 14:47:47 +0300 Message-Id: <1468151270-12984-17-git-send-email-emilcondrea@gmail.com> In-Reply-To: <1468151270-12984-1-git-send-email-emilcondrea@gmail.com> References: <1468151270-12984-1-git-send-email-emilcondrea@gmail.com> Subject: [Qemu-devel] [PATCH 16/19] Qemu-Xen-vTPM: Register Xen stubdom vTPM frontend driver List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: xen-devel@lists.xen.org, quan.xu@intel.com, dgdegra@tycho.nsa.gov, stefano.stabellini@eu.citrix.com, wei.liu2@citrix.com, stefanb@linux.vnet.ibm.com, eblake@redhat.com, emilcondrea@gmail.com This driver transfers any request/repond between TPM xenstubdoms driver and Xen vTPM stubdom, and facilitates communications between Xen vTPM stubdom domain and vTPM xenstubdoms driver. It is a glue for the TPM xenstubdoms driver and Xen stubdom vTPM domain that provides the actual TPM functionality. (Xen) Xen backend driver should run before running this frontend, and initialize XenStore as the following for communication. [XenStore] for example: Domain 0: runs QEMU for guest A Domain 1: vtpmmgr Domain 2: vTPM for guest A Domain 3: HVM guest A [...] local = "" domain = "" 0 = "" frontend = "" vtpm = "" 2 = "" 0 = "" backend = "/local/domain/2/backend/vtpm/0/0" backend-id = "2" state = "*" handle = "0" domain = "Domain3's name" ring-ref = "*" event-channel = "*" feature-protocol-v2 = "1" backend = "" qdisk = "" [...] console = "" vif = "" [...] 2 = "" [...] backend = "" vtpm = "" 0 = "" 0 = "" frontend = "/local/domain/0/frontend/vtpm/2/0" frontend-id = "0" ('0', frontend is running in Domain-0) [...] 3 = "" [...] device = "" (frontend device, the backend is running in QEMU/.etc) vkbd = "" [...] vif = "" [...] .. (QEMU) xen_vtpmdev_ops is initialized with the following process: xen_hvm_init() [...] -->xen_fe_register("vtpm", ...) -->xenstore_fe_scan() -->xen_fe_try_init(ops) --> XenDevOps.init() -->xen_fe_get_xendev() --> XenDevOps.alloc() -->xen_fe_check() -->xen_fe_try_initialise() --> XenDevOps.initialise() -->xen_fe_try_connected() --> XenDevOps.connected() -->xs_watch() [...] Signed-off-by: Quan Xu Signed-off-by: Emil Condrea Reviewed-by: Stefan Berger --- Changed in v9: * instead of xen_frontend.c global variable xenstore_dev, use vtpm specific xenstore_vtpm_dev (since it will be needed just for tpm_xenstubdoms qemu driver) * added xen_vtpm_frontend.h * move vtpm_backend_changed -> xen_fe_backend_changed to xen_frontend.c * use libxengnttab, libxenevtchn stable API instead of xc_* calls: - xc_gntshr_share_pages -> xengntshr_share_pages - xc_gntshr_munmap -> xengntshr_unshare - xc_interface_close -> xengntshr_close - xc_evtchn_unmask -> xenevtchn_unmask --- hw/tpm/Makefile.objs | 1 + hw/tpm/xen_vtpm_frontend.c | 303 ++++++++++++++++++++++++++++++++++++++++++ hw/tpm/xen_vtpm_frontend.h | 10 ++ hw/xen/xen_frontend.c | 20 +++ include/hw/xen/xen_backend.h | 1 + include/hw/xen/xen_frontend.h | 1 + xen-hvm.c | 6 + 7 files changed, 342 insertions(+) create mode 100644 hw/tpm/xen_vtpm_frontend.c create mode 100644 hw/tpm/xen_vtpm_frontend.h diff --git a/hw/tpm/Makefile.objs b/hw/tpm/Makefile.objs index 64cecc3..b0a821c 100644 --- a/hw/tpm/Makefile.objs +++ b/hw/tpm/Makefile.objs @@ -1,2 +1,3 @@ common-obj-$(CONFIG_TPM_TIS) += tpm_tis.o common-obj-$(CONFIG_TPM_PASSTHROUGH) += tpm_passthrough.o tpm_util.o +common-obj-$(CONFIG_TPM_XENSTUBDOMS) += xen_vtpm_frontend.o diff --git a/hw/tpm/xen_vtpm_frontend.c b/hw/tpm/xen_vtpm_frontend.c new file mode 100644 index 0000000..cf3eb5e --- /dev/null +++ b/hw/tpm/xen_vtpm_frontend.c @@ -0,0 +1,303 @@ +/* + * Connect to Xen vTPM stubdom domain + * + * Copyright (c) 2015 Intel Corporation + * Authors: + * Quan Xu + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see + */ + +#include "qemu/osdep.h" + +#include "xen_vtpm_frontend.h" +#include "hw/xen/xen_frontend.h" +#include "hw/xen/xen_backend.h" + +int xenstore_vtpm_dev; +#ifndef XS_STUBDOM_VTPM_ENABLE +#define XS_STUBDOM_VTPM_ENABLE "1" +#endif + +#ifndef VTPM_PAGE_SIZE +#define VTPM_PAGE_SIZE 4096 +#endif + +enum tpmif_state { + /* No contents, vTPM idle, cancel complete */ + TPMIF_STATE_IDLE, + /* Request ready or vTPM working */ + TPMIF_STATE_SUBMIT, + /* Response ready or vTPM idle */ + TPMIF_STATE_FINISH, + /* Cancel requested or vTPM working */ + TPMIF_STATE_CANCEL, +}; + +static AioContext *vtpm_aio_ctx; + +enum status_bits { + VTPM_STATUS_RUNNING = 0x1, + VTPM_STATUS_IDLE = 0x2, + VTPM_STATUS_RESULT = 0x4, + VTPM_STATUS_CANCELED = 0x8, +}; + +struct tpmif_shared_page { + /* Request and response length in bytes */ + uint32_t length; + /* Enum tpmif_state */ + uint8_t state; + /* For the current request */ + uint8_t locality; + /* Should be zero */ + uint8_t pad; + /* Extra pages for long packets; may be zero */ + uint8_t nr_extra_pages; + /* + * Grant IDs, the length is actually nr_extra_pages. + * beyond the extra_pages entries is the actual request + * and response. + */ + uint32_t extra_pages[0]; +}; + +struct xen_vtpm_dev { + struct XenDevice xendev; /* must be first */ + struct tpmif_shared_page *shr; + xengntshr_handle *xen_xcs; + int ring_ref; + int bedomid; + QEMUBH *sr_bh; +}; + +static uint8_t vtpm_status(struct xen_vtpm_dev *vtpmdev) +{ + switch (vtpmdev->shr->state) { + case TPMIF_STATE_IDLE: + case TPMIF_STATE_FINISH: + return VTPM_STATUS_IDLE; + case TPMIF_STATE_SUBMIT: + case TPMIF_STATE_CANCEL: + return VTPM_STATUS_RUNNING; + default: + return 0; + } +} + +static bool vtpm_aio_wait(AioContext *ctx) +{ + return aio_poll(ctx, true); +} + +static void sr_bh_handler(void *opaque) +{ +} + +int vtpm_recv(struct XenDevice *xendev, uint8_t* buf, size_t *count) +{ + struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev, + xendev); + struct tpmif_shared_page *shr = vtpmdev->shr; + unsigned int offset; + size_t length = shr->length; + + if (shr->state == TPMIF_STATE_IDLE) { + return -ECANCELED; + } + + offset = sizeof(*shr) + sizeof(shr->extra_pages[0])*shr->nr_extra_pages; + if (offset > VTPM_PAGE_SIZE) { + return -EIO; + } + + if (offset + length > VTPM_PAGE_SIZE) { + length = VTPM_PAGE_SIZE - offset; + } + + memcpy(buf, offset + (uint8_t *)shr, length); + *count = length; + + return 0; +} + +int vtpm_send(struct XenDevice *xendev, uint8_t* buf, size_t count) +{ + struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev, + xendev); + struct tpmif_shared_page *shr = vtpmdev->shr; + unsigned int offset = sizeof(*shr) + + sizeof(shr->extra_pages[0])*shr->nr_extra_pages; + + if (offset > VTPM_PAGE_SIZE) { + return -EIO; + } + + if (offset + count > VTPM_PAGE_SIZE) { + return -ECANCELED; + } + + while (vtpm_status(vtpmdev) != VTPM_STATUS_IDLE) { + vtpm_aio_wait(vtpm_aio_ctx); + } + + memcpy(offset + (uint8_t *)shr, buf, count); + shr->length = count; + barrier(); + shr->state = TPMIF_STATE_SUBMIT; + xen_wmb(); + xen_pv_send_notify(&vtpmdev->xendev); + + while (vtpm_status(vtpmdev) != VTPM_STATUS_IDLE) { + vtpm_aio_wait(vtpm_aio_ctx); + } + + return count; +} + +static int vtpm_initialise(struct XenDevice *xendev) +{ + struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev, + xendev); + xs_transaction_t xbt = XBT_NULL; + unsigned int ring_ref; + + vtpmdev->xendev.fe = xenstore_read_be_str(&vtpmdev->xendev, "frontend"); + if (vtpmdev->xendev.fe == NULL) { + return -1; + } + + /* Get backend domid */ + if (xenstore_read_fe_int(&vtpmdev->xendev, "backend-id", + &vtpmdev->bedomid)) { + return -1; + } + + /* Alloc shared page */ + vtpmdev->shr = xengntshr_share_pages(vtpmdev->xen_xcs, vtpmdev->bedomid, 1, + &ring_ref, PROT_READ|PROT_WRITE); + vtpmdev->ring_ref = ring_ref; + if (vtpmdev->shr == NULL) { + return -1; + } + + /* Create event channel */ + if (xen_fe_alloc_unbound(&vtpmdev->xendev, 0, vtpmdev->bedomid)) { + xengntshr_unshare(vtpmdev->xen_xcs, vtpmdev->shr, 1); + return -1; + } + + xenevtchn_unmask(vtpmdev->xendev.evtchndev, + vtpmdev->xendev.local_port); + +again: + xbt = xs_transaction_start(xenstore); + if (xbt == XBT_NULL) { + goto abort_transaction; + } + + if (xenstore_write_int(vtpmdev->xendev.fe, "ring-ref", + vtpmdev->ring_ref)) { + goto abort_transaction; + } + + if (xenstore_write_int(vtpmdev->xendev.fe, "event-channel", + vtpmdev->xendev.local_port)) { + goto abort_transaction; + } + + /* Publish protocol v2 feature */ + if (xenstore_write_int(vtpmdev->xendev.fe, "feature-protocol-v2", 1)) { + goto abort_transaction; + } + + if (!xs_transaction_end(xenstore, xbt, 0)) { + if (errno == EAGAIN) { + goto again; + } + } + + return 0; + +abort_transaction: + xengntshr_unshare(vtpmdev->xen_xcs, vtpmdev->shr, 1); + xs_transaction_end(xenstore, xbt, 1); + return -1; +} + +static int vtpm_free(struct XenDevice *xendev) +{ + struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev, + xendev); + + aio_poll(vtpm_aio_ctx, false); + qemu_bh_delete(vtpmdev->sr_bh); + if (vtpmdev->shr) { + xengntshr_unshare(vtpmdev->xen_xcs, vtpmdev->shr, 1); + } + xengntshr_close(vtpmdev->xen_xcs); + return 0; +} + +static int vtpm_init(struct XenDevice *xendev) +{ + char path[XEN_BUFSIZE]; + char *value; + unsigned int stubdom_vtpm = 0; + + snprintf(path, sizeof(path), "/local/domain/%d/platform/acpi_stubdom_vtpm", + xen_domid); + value = xs_read(xenstore, 0, path, &stubdom_vtpm); + if (stubdom_vtpm <= 0 || strcmp(value, XS_STUBDOM_VTPM_ENABLE)) { + free(value); + return -1; + } + free(value); + return 0; +} + +static void vtpm_alloc(struct XenDevice *xendev) +{ + struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev, + xendev); + + vtpm_aio_ctx = aio_context_new(NULL); + if (vtpm_aio_ctx == NULL) { + return; + } + vtpmdev->sr_bh = aio_bh_new(vtpm_aio_ctx, sr_bh_handler, vtpmdev); + qemu_bh_schedule(vtpmdev->sr_bh); + vtpmdev->xen_xcs = xengntshr_open(0, 0); + xenstore_vtpm_dev = xendev->dev; +} + +static void vtpm_event(struct XenDevice *xendev) +{ + struct xen_vtpm_dev *vtpmdev = container_of(xendev, struct xen_vtpm_dev, + xendev); + + qemu_bh_schedule(vtpmdev->sr_bh); +} + +struct XenDevOps xen_vtpmdev_ops = { + .size = sizeof(struct xen_vtpm_dev), + .flags = DEVOPS_FLAG_IGNORE_STATE | + DEVOPS_FLAG_FE, + .event = vtpm_event, + .free = vtpm_free, + .init = vtpm_init, + .alloc = vtpm_alloc, + .initialise = vtpm_initialise, + .backend_changed = xen_fe_backend_changed, +}; \ No newline at end of file diff --git a/hw/tpm/xen_vtpm_frontend.h b/hw/tpm/xen_vtpm_frontend.h new file mode 100644 index 0000000..72f586b --- /dev/null +++ b/hw/tpm/xen_vtpm_frontend.h @@ -0,0 +1,10 @@ +#ifndef TPM_XEN_VTPM_FRONTEND_H +#define TPM_XEN_VTPM_FRONTEND_H 1 + +struct XenDevice; +extern int xenstore_vtpm_dev; +/* Xen vtpm */ +int vtpm_send(struct XenDevice *xendev, uint8_t* buf, size_t count); +int vtpm_recv(struct XenDevice *xendev, uint8_t* buf, size_t *count); + +#endif /* TPM_XEN_VTPM_FRONTEND_H */ diff --git a/hw/xen/xen_frontend.c b/hw/xen/xen_frontend.c index 7b305ce..f110411 100644 --- a/hw/xen/xen_frontend.c +++ b/hw/xen/xen_frontend.c @@ -75,6 +75,26 @@ void xen_fe_frontend_changed(struct XenDevice *xendev, const char *node) } } +void xen_fe_backend_changed(struct XenDevice *xendev, const char *node) +{ + int be_state; + + if (strcmp(node, "state") == 0) { + xenstore_read_be_int(xendev, node, &be_state); + switch (be_state) { + case XenbusStateConnected: + /* TODO */ + break; + case XenbusStateClosing: + case XenbusStateClosed: + xenbus_switch_state(xendev, XenbusStateClosing); + break; + default: + break; + } + } +} + void xenstore_update_fe(char *watch, struct XenDevice *xendev) { char *node; diff --git a/include/hw/xen/xen_backend.h b/include/hw/xen/xen_backend.h index 71dd158..4a8808e 100644 --- a/include/hw/xen/xen_backend.h +++ b/include/hw/xen/xen_backend.h @@ -35,6 +35,7 @@ extern struct XenDevOps xen_kbdmouse_ops; /* xen_framebuffer.c */ extern struct XenDevOps xen_framebuffer_ops; /* xen_framebuffer.c */ extern struct XenDevOps xen_blkdev_ops; /* xen_disk.c */ extern struct XenDevOps xen_netdev_ops; /* xen_nic.c */ +extern struct XenDevOps xen_vtpmdev_ops; /* xen_vtpm_frontend.c*/ #ifdef CONFIG_USB_LIBUSB extern struct XenDevOps xen_usb_ops; /* xen-usb.c */ #endif diff --git a/include/hw/xen/xen_frontend.h b/include/hw/xen/xen_frontend.h index 8fc0422..912f333 100644 --- a/include/hw/xen/xen_frontend.h +++ b/include/hw/xen/xen_frontend.h @@ -11,6 +11,7 @@ void xenstore_update_fe(char *watch, struct XenDevice *xendev); struct XenDevice *xen_fe_get_xendev(const char *type, int dom, int dev, char *backend, struct XenDevOps *ops); void xen_fe_frontend_changed(struct XenDevice *xendev, const char *node); +void xen_fe_backend_changed(struct XenDevice *xendev, const char *node); int xen_fe_register(const char *type, struct XenDevOps *ops); int xen_fe_alloc_unbound(struct XenDevice *xendev, int dom, int remote_dom); int xenbus_switch_state(struct XenDevice *xendev, enum xenbus_state xbus); diff --git a/xen-hvm.c b/xen-hvm.c index eb57792..ef3fc53 100644 --- a/xen-hvm.c +++ b/xen-hvm.c @@ -16,6 +16,7 @@ #include "hw/i386/apic-msidef.h" #include "hw/xen/xen_common.h" #include "hw/xen/xen_backend.h" +#include "hw/xen/xen_frontend.h" #include "qmp-commands.h" #include "sysemu/char.h" @@ -1318,6 +1319,11 @@ void xen_hvm_init(PCMachineState *pcms, MemoryRegion **ram_memory) error_report("xen backend core setup failed"); goto err; } + +#ifdef CONFIG_TPM_XENSTUBDOMS + xen_fe_register("vtpm", &xen_vtpmdev_ops); +#endif + xen_be_register("console", &xen_console_ops); xen_be_register("vkbd", &xen_kbdmouse_ops); xen_be_register("qdisk", &xen_blkdev_ops); -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Emil Condrea Subject: [PATCH 16/19] Qemu-Xen-vTPM: Register Xen stubdom vTPM frontend driver Date: Sun, 10 Jul 2016 14:47:47 +0300 Message-ID: <1468151270-12984-17-git-send-email-emilcondrea@gmail.com> References: <1468151270-12984-1-git-send-email-emilcondrea@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1468151270-12984-1-git-send-email-emilcondrea@gmail.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: qemu-devel@nongnu.org Cc: wei.liu2@citrix.com, stefanb@linux.vnet.ibm.com, stefano.stabellini@eu.citrix.com, xen-devel@lists.xen.org, quan.xu@intel.com, dgdegra@tycho.nsa.gov, eblake@redhat.com, emilcondrea@gmail.com List-Id: xen-devel@lists.xenproject.org VGhpcyBkcml2ZXIgdHJhbnNmZXJzIGFueSByZXF1ZXN0L3JlcG9uZCBiZXR3ZWVuIFRQTSB4ZW5z dHViZG9tcwpkcml2ZXIgYW5kIFhlbiB2VFBNIHN0dWJkb20sIGFuZCBmYWNpbGl0YXRlcyBjb21t dW5pY2F0aW9ucyBiZXR3ZWVuClhlbiB2VFBNIHN0dWJkb20gZG9tYWluIGFuZCB2VFBNIHhlbnN0 dWJkb21zIGRyaXZlci4gSXQgaXMgYSBnbHVlIGZvcgp0aGUgVFBNIHhlbnN0dWJkb21zIGRyaXZl ciBhbmQgWGVuIHN0dWJkb20gdlRQTSBkb21haW4gdGhhdCBwcm92aWRlcwp0aGUgYWN0dWFsIFRQ TSBmdW5jdGlvbmFsaXR5LgoKKFhlbikgWGVuIGJhY2tlbmQgZHJpdmVyIHNob3VsZCBydW4gYmVm b3JlIHJ1bm5pbmcgdGhpcyBmcm9udGVuZCwgYW5kCmluaXRpYWxpemUgWGVuU3RvcmUgYXMgdGhl IGZvbGxvd2luZyBmb3IgY29tbXVuaWNhdGlvbi4KCltYZW5TdG9yZV0KCmZvciBleGFtcGxlOgoK RG9tYWluIDA6IHJ1bnMgUUVNVSBmb3IgZ3Vlc3QgQQpEb21haW4gMTogdnRwbW1ncgpEb21haW4g MjogdlRQTSBmb3IgZ3Vlc3QgQQpEb21haW4gMzogSFZNIGd1ZXN0IEEKClsuLi5dCiBsb2NhbCA9 ICIiCiAgIGRvbWFpbiA9ICIiCiAgICAwID0gIiIKICAgICBmcm9udGVuZCA9ICIiCiAgICAgIHZ0 cG0gPSAiIgogICAgICAgMiA9ICIiCiAgICAgICAgMCA9ICIiCiAgICAgICAgIGJhY2tlbmQgPSAi L2xvY2FsL2RvbWFpbi8yL2JhY2tlbmQvdnRwbS8wLzAiCiAgICAgICAgIGJhY2tlbmQtaWQgPSAi MiIKICAgICAgICAgc3RhdGUgPSAiKiIKICAgICAgICAgaGFuZGxlID0gIjAiCiAgICAgICAgIGRv bWFpbiA9ICJEb21haW4zJ3MgbmFtZSIKICAgICAgICAgcmluZy1yZWYgPSAiKiIKICAgICAgICAg ZXZlbnQtY2hhbm5lbCA9ICIqIgogICAgICAgICBmZWF0dXJlLXByb3RvY29sLXYyID0gIjEiCiAg ICAgYmFja2VuZCA9ICIiCiAgICAgIHFkaXNrID0gIiIKICAgICAgIFsuLi5dCiAgICAgIGNvbnNv bGUgPSAiIgogICAgICB2aWYgPSAiIgogICAgICAgWy4uLl0KICAgIDIgPSAiIgogICAgIFsuLi5d CiAgICAgYmFja2VuZCA9ICIiCiAgICAgIHZ0cG0gPSAiIgogICAgICAgMCA9ICIiCiAgICAgICAg MCA9ICIiCiAgICAgICAgIGZyb250ZW5kID0gIi9sb2NhbC9kb21haW4vMC9mcm9udGVuZC92dHBt LzIvMCIKICAgICAgICAgZnJvbnRlbmQtaWQgPSAiMCIgKCcwJywgZnJvbnRlbmQgaXMgcnVubmlu ZyBpbiBEb21haW4tMCkKICAgICAgICAgWy4uLl0KICAgIDMgPSAiIgogICAgIFsuLi5dCiAgICAg ZGV2aWNlID0gIiIgKGZyb250ZW5kIGRldmljZSwgdGhlIGJhY2tlbmQgaXMgcnVubmluZyBpbiBR RU1VLy5ldGMpCiAgICAgIHZrYmQgPSAiIgogICAgICAgWy4uLl0KICAgICAgdmlmID0gIiIKICAg ICAgIFsuLi5dCgogLi4KCihRRU1VKSB4ZW5fdnRwbWRldl9vcHMgaXMgaW5pdGlhbGl6ZWQgd2l0 aCB0aGUgZm9sbG93aW5nIHByb2Nlc3M6CiAgeGVuX2h2bV9pbml0KCkKICAgIFsuLi5dCiAgICAt LT54ZW5fZmVfcmVnaXN0ZXIoInZ0cG0iLCAuLi4pCiAgICAgIC0tPnhlbnN0b3JlX2ZlX3NjYW4o KQogICAgICAgIC0tPnhlbl9mZV90cnlfaW5pdChvcHMpCiAgICAgICAgICAtLT4gWGVuRGV2T3Bz LmluaXQoKQogICAgICAgIC0tPnhlbl9mZV9nZXRfeGVuZGV2KCkKICAgICAgICAgIC0tPiBYZW5E ZXZPcHMuYWxsb2MoKQogICAgICAgIC0tPnhlbl9mZV9jaGVjaygpCiAgICAgICAgICAtLT54ZW5f ZmVfdHJ5X2luaXRpYWxpc2UoKQogICAgICAgICAgICAtLT4gWGVuRGV2T3BzLmluaXRpYWxpc2Uo KQogICAgICAgICAgLS0+eGVuX2ZlX3RyeV9jb25uZWN0ZWQoKQogICAgICAgICAgICAtLT4gWGVu RGV2T3BzLmNvbm5lY3RlZCgpCiAgICAgICAgLS0+eHNfd2F0Y2goKQogICAgWy4uLl0KClNpZ25l ZC1vZmYtYnk6IFF1YW4gWHUgPHF1YW4ueHVAaW50ZWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBFbWls IENvbmRyZWEgPGVtaWxjb25kcmVhQGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6IFN0ZWZhbiBCZXJn ZXIgPHN0ZWZhbmJAbGludXgudm5ldC5pYm0uY29tPgoKLS0tCkNoYW5nZWQgaW4gdjk6CiAqIGlu c3RlYWQgb2YgeGVuX2Zyb250ZW5kLmMgZ2xvYmFsIHZhcmlhYmxlIHhlbnN0b3JlX2RldiwgdXNl IHZ0cG0gc3BlY2lmaWMKeGVuc3RvcmVfdnRwbV9kZXYgKHNpbmNlIGl0IHdpbGwgYmUgbmVlZGVk IGp1c3QgZm9yIHRwbV94ZW5zdHViZG9tcyBxZW11IGRyaXZlcikKICogYWRkZWQgeGVuX3Z0cG1f ZnJvbnRlbmQuaAogKiBtb3ZlIHZ0cG1fYmFja2VuZF9jaGFuZ2VkIC0+IHhlbl9mZV9iYWNrZW5k X2NoYW5nZWQgdG8geGVuX2Zyb250ZW5kLmMKICogdXNlIGxpYnhlbmdudHRhYiwgbGlieGVuZXZ0 Y2huIHN0YWJsZSBBUEkgaW5zdGVhZCBvZiB4Y18qIGNhbGxzOgogICAgLSB4Y19nbnRzaHJfc2hh cmVfcGFnZXMgLT4geGVuZ250c2hyX3NoYXJlX3BhZ2VzCiAgICAtIHhjX2dudHNocl9tdW5tYXAg LT4geGVuZ250c2hyX3Vuc2hhcmUKICAgIC0geGNfaW50ZXJmYWNlX2Nsb3NlIC0+IHhlbmdudHNo cl9jbG9zZQogICAgLSB4Y19ldnRjaG5fdW5tYXNrIC0+IHhlbmV2dGNobl91bm1hc2sKLS0tCiBo dy90cG0vTWFrZWZpbGUub2JqcyAgICAgICAgICB8ICAgMSArCiBody90cG0veGVuX3Z0cG1fZnJv bnRlbmQuYyAgICB8IDMwMyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysKIGh3L3RwbS94ZW5fdnRwbV9mcm9udGVuZC5oICAgIHwgIDEwICsrCiBody94ZW4veGVuX2Zy b250ZW5kLmMgICAgICAgICB8ICAyMCArKysKIGluY2x1ZGUvaHcveGVuL3hlbl9iYWNrZW5kLmgg IHwgICAxICsKIGluY2x1ZGUvaHcveGVuL3hlbl9mcm9udGVuZC5oIHwgICAxICsKIHhlbi1odm0u YyAgICAgICAgICAgICAgICAgICAgIHwgICA2ICsKIDcgZmlsZXMgY2hhbmdlZCwgMzQyIGluc2Vy dGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBody90cG0veGVuX3Z0cG1fZnJvbnRlbmQuYwog Y3JlYXRlIG1vZGUgMTAwNjQ0IGh3L3RwbS94ZW5fdnRwbV9mcm9udGVuZC5oCgpkaWZmIC0tZ2l0 IGEvaHcvdHBtL01ha2VmaWxlLm9ianMgYi9ody90cG0vTWFrZWZpbGUub2JqcwppbmRleCA2NGNl Y2MzLi5iMGE4MjFjIDEwMDY0NAotLS0gYS9ody90cG0vTWFrZWZpbGUub2JqcworKysgYi9ody90 cG0vTWFrZWZpbGUub2JqcwpAQCAtMSwyICsxLDMgQEAKIGNvbW1vbi1vYmotJChDT05GSUdfVFBN X1RJUykgKz0gdHBtX3Rpcy5vCiBjb21tb24tb2JqLSQoQ09ORklHX1RQTV9QQVNTVEhST1VHSCkg Kz0gdHBtX3Bhc3N0aHJvdWdoLm8gdHBtX3V0aWwubworY29tbW9uLW9iai0kKENPTkZJR19UUE1f WEVOU1RVQkRPTVMpICs9IHhlbl92dHBtX2Zyb250ZW5kLm8KZGlmZiAtLWdpdCBhL2h3L3RwbS94 ZW5fdnRwbV9mcm9udGVuZC5jIGIvaHcvdHBtL3hlbl92dHBtX2Zyb250ZW5kLmMKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uY2YzZWI1ZQotLS0gL2Rldi9udWxsCisrKyBiL2h3 L3RwbS94ZW5fdnRwbV9mcm9udGVuZC5jCkBAIC0wLDAgKzEsMzAzIEBACisvKgorICogQ29ubmVj dCB0byBYZW4gdlRQTSBzdHViZG9tIGRvbWFpbgorICoKKyAqICBDb3B5cmlnaHQgKGMpIDIwMTUg SW50ZWwgQ29ycG9yYXRpb24KKyAqICBBdXRob3JzOgorICogICAgUXVhbiBYdSA8cXVhbi54dUBp bnRlbC5jb20+CisgKgorICogVGhpcyBsaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkg dGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgKiB2ZXJzaW9uIDIgb2YgdGhl IExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKgorICog VGhpcyBsaWJyYXJ5IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1 c2VmdWwsCisgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIExlc3NlciBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVk IGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICogTGljZW5zZSBhbG9u ZyB3aXRoIHRoaXMgbGlicmFyeTsgaWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNl bnNlcy8+CisgKi8KKworI2luY2x1ZGUgInFlbXUvb3NkZXAuaCIKKworI2luY2x1ZGUgInhlbl92 dHBtX2Zyb250ZW5kLmgiCisjaW5jbHVkZSAiaHcveGVuL3hlbl9mcm9udGVuZC5oIgorI2luY2x1 ZGUgImh3L3hlbi94ZW5fYmFja2VuZC5oIgorCitpbnQgeGVuc3RvcmVfdnRwbV9kZXY7CisjaWZu ZGVmIFhTX1NUVUJET01fVlRQTV9FTkFCTEUKKyNkZWZpbmUgWFNfU1RVQkRPTV9WVFBNX0VOQUJM RSAgICAiMSIKKyNlbmRpZgorCisjaWZuZGVmIFZUUE1fUEFHRV9TSVpFCisjZGVmaW5lIFZUUE1f UEFHRV9TSVpFICAgICAgNDA5NgorI2VuZGlmCisKK2VudW0gdHBtaWZfc3RhdGUgeworICAgIC8q IE5vIGNvbnRlbnRzLCB2VFBNIGlkbGUsIGNhbmNlbCBjb21wbGV0ZSAqLworICAgIFRQTUlGX1NU QVRFX0lETEUsCisgICAgLyogUmVxdWVzdCByZWFkeSBvciB2VFBNIHdvcmtpbmcgKi8KKyAgICBU UE1JRl9TVEFURV9TVUJNSVQsCisgICAgLyogUmVzcG9uc2UgcmVhZHkgb3IgdlRQTSBpZGxlICov CisgICAgVFBNSUZfU1RBVEVfRklOSVNILAorICAgIC8qIENhbmNlbCByZXF1ZXN0ZWQgb3IgdlRQ TSB3b3JraW5nICovCisgICAgVFBNSUZfU1RBVEVfQ0FOQ0VMLAorfTsKKworc3RhdGljIEFpb0Nv bnRleHQgKnZ0cG1fYWlvX2N0eDsKKworZW51bSBzdGF0dXNfYml0cyB7CisgICAgVlRQTV9TVEFU VVNfUlVOTklORyAgPSAweDEsCisgICAgVlRQTV9TVEFUVVNfSURMRSAgICAgPSAweDIsCisgICAg VlRQTV9TVEFUVVNfUkVTVUxUICAgPSAweDQsCisgICAgVlRQTV9TVEFUVVNfQ0FOQ0VMRUQgPSAw eDgsCit9OworCitzdHJ1Y3QgdHBtaWZfc2hhcmVkX3BhZ2UgeworICAgIC8qIFJlcXVlc3QgYW5k IHJlc3BvbnNlIGxlbmd0aCBpbiBieXRlcyAqLworICAgIHVpbnQzMl90IGxlbmd0aDsKKyAgICAv KiBFbnVtIHRwbWlmX3N0YXRlICovCisgICAgdWludDhfdCAgc3RhdGU7CisgICAgLyogRm9yIHRo ZSBjdXJyZW50IHJlcXVlc3QgKi8KKyAgICB1aW50OF90ICBsb2NhbGl0eTsKKyAgICAvKiBTaG91 bGQgYmUgemVybyAqLworICAgIHVpbnQ4X3QgIHBhZDsKKyAgICAvKiBFeHRyYSBwYWdlcyBmb3Ig bG9uZyBwYWNrZXRzOyBtYXkgYmUgemVybyAqLworICAgIHVpbnQ4X3QgIG5yX2V4dHJhX3BhZ2Vz OworICAgIC8qCisgICAgICogR3JhbnQgSURzLCB0aGUgbGVuZ3RoIGlzIGFjdHVhbGx5IG5yX2V4 dHJhX3BhZ2VzLgorICAgICAqIGJleW9uZCB0aGUgZXh0cmFfcGFnZXMgZW50cmllcyBpcyB0aGUg YWN0dWFsIHJlcXVlc3QKKyAgICAgKiBhbmQgcmVzcG9uc2UuCisgICAgICovCisgICAgdWludDMy X3QgZXh0cmFfcGFnZXNbMF07Cit9OworCitzdHJ1Y3QgeGVuX3Z0cG1fZGV2IHsKKyAgICBzdHJ1 Y3QgWGVuRGV2aWNlIHhlbmRldjsgIC8qIG11c3QgYmUgZmlyc3QgKi8KKyAgICBzdHJ1Y3QgICAg ICAgICAgIHRwbWlmX3NoYXJlZF9wYWdlICpzaHI7CisgICAgeGVuZ250c2hyX2hhbmRsZSAqeGVu X3hjczsKKyAgICBpbnQgICAgICAgICAgICAgIHJpbmdfcmVmOworICAgIGludCAgICAgICAgICAg ICAgYmVkb21pZDsKKyAgICBRRU1VQkggICAgICAgICAgICpzcl9iaDsKK307CisKK3N0YXRpYyB1 aW50OF90IHZ0cG1fc3RhdHVzKHN0cnVjdCB4ZW5fdnRwbV9kZXYgKnZ0cG1kZXYpCit7CisgICAg c3dpdGNoICh2dHBtZGV2LT5zaHItPnN0YXRlKSB7CisgICAgY2FzZSBUUE1JRl9TVEFURV9JRExF OgorICAgIGNhc2UgVFBNSUZfU1RBVEVfRklOSVNIOgorICAgICAgICByZXR1cm4gVlRQTV9TVEFU VVNfSURMRTsKKyAgICBjYXNlIFRQTUlGX1NUQVRFX1NVQk1JVDoKKyAgICBjYXNlIFRQTUlGX1NU QVRFX0NBTkNFTDoKKyAgICAgICAgcmV0dXJuIFZUUE1fU1RBVFVTX1JVTk5JTkc7CisgICAgZGVm YXVsdDoKKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQorfQorCitzdGF0aWMgYm9vbCB2dHBtX2Fp b193YWl0KEFpb0NvbnRleHQgKmN0eCkKK3sKKyAgICByZXR1cm4gYWlvX3BvbGwoY3R4LCB0cnVl KTsKK30KKworc3RhdGljIHZvaWQgc3JfYmhfaGFuZGxlcih2b2lkICpvcGFxdWUpCit7Cit9CisK K2ludCB2dHBtX3JlY3Yoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LCB1aW50OF90KiBidWYsIHNp emVfdCAqY291bnQpCit7CisgICAgc3RydWN0IHhlbl92dHBtX2RldiAqdnRwbWRldiA9IGNvbnRh aW5lcl9vZih4ZW5kZXYsIHN0cnVjdCB4ZW5fdnRwbV9kZXYsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5kZXYpOworICAgIHN0cnVjdCB0cG1pZl9z aGFyZWRfcGFnZSAqc2hyID0gdnRwbWRldi0+c2hyOworICAgIHVuc2lnbmVkIGludCBvZmZzZXQ7 CisgICAgc2l6ZV90IGxlbmd0aCA9IHNoci0+bGVuZ3RoOworCisgICAgaWYgKHNoci0+c3RhdGUg PT0gVFBNSUZfU1RBVEVfSURMRSkgeworICAgICAgICByZXR1cm4gLUVDQU5DRUxFRDsKKyAgICB9 CisKKyAgICBvZmZzZXQgPSBzaXplb2YoKnNocikgKyBzaXplb2Yoc2hyLT5leHRyYV9wYWdlc1sw XSkqc2hyLT5ucl9leHRyYV9wYWdlczsKKyAgICBpZiAob2Zmc2V0ID4gVlRQTV9QQUdFX1NJWkUp IHsKKyAgICAgICAgcmV0dXJuIC1FSU87CisgICAgfQorCisgICAgaWYgKG9mZnNldCArIGxlbmd0 aCA+IFZUUE1fUEFHRV9TSVpFKSB7CisgICAgICAgIGxlbmd0aCA9IFZUUE1fUEFHRV9TSVpFIC0g b2Zmc2V0OworICAgIH0KKworICAgIG1lbWNweShidWYsIG9mZnNldCArICh1aW50OF90ICopc2hy LCBsZW5ndGgpOworICAgICpjb3VudCA9IGxlbmd0aDsKKworICAgIHJldHVybiAwOworfQorCitp bnQgdnRwbV9zZW5kKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgdWludDhfdCogYnVmLCBzaXpl X3QgY291bnQpCit7CisgICAgc3RydWN0IHhlbl92dHBtX2RldiAqdnRwbWRldiA9IGNvbnRhaW5l cl9vZih4ZW5kZXYsIHN0cnVjdCB4ZW5fdnRwbV9kZXYsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5kZXYpOworICAgIHN0cnVjdCB0cG1pZl9zaGFy ZWRfcGFnZSAqc2hyID0gdnRwbWRldi0+c2hyOworICAgIHVuc2lnbmVkIGludCBvZmZzZXQgPSBz aXplb2YoKnNocikgKworICAgICAgICAgICAgICAgICAgICAgICAgICBzaXplb2Yoc2hyLT5leHRy YV9wYWdlc1swXSkqc2hyLT5ucl9leHRyYV9wYWdlczsKKworICAgIGlmIChvZmZzZXQgPiBWVFBN X1BBR0VfU0laRSkgeworICAgICAgICByZXR1cm4gLUVJTzsKKyAgICB9CisKKyAgICBpZiAob2Zm c2V0ICsgY291bnQgPiBWVFBNX1BBR0VfU0laRSkgeworICAgICAgICByZXR1cm4gLUVDQU5DRUxF RDsKKyAgICB9CisKKyAgICB3aGlsZSAodnRwbV9zdGF0dXModnRwbWRldikgIT0gVlRQTV9TVEFU VVNfSURMRSkgeworICAgICAgICB2dHBtX2Fpb193YWl0KHZ0cG1fYWlvX2N0eCk7CisgICAgfQor CisgICAgbWVtY3B5KG9mZnNldCArICh1aW50OF90ICopc2hyLCBidWYsIGNvdW50KTsKKyAgICBz aHItPmxlbmd0aCA9IGNvdW50OworICAgIGJhcnJpZXIoKTsKKyAgICBzaHItPnN0YXRlID0gVFBN SUZfU1RBVEVfU1VCTUlUOworICAgIHhlbl93bWIoKTsKKyAgICB4ZW5fcHZfc2VuZF9ub3RpZnko JnZ0cG1kZXYtPnhlbmRldik7CisKKyAgICB3aGlsZSAodnRwbV9zdGF0dXModnRwbWRldikgIT0g VlRQTV9TVEFUVVNfSURMRSkgeworICAgICAgICB2dHBtX2Fpb193YWl0KHZ0cG1fYWlvX2N0eCk7 CisgICAgfQorCisgICAgcmV0dXJuIGNvdW50OworfQorCitzdGF0aWMgaW50IHZ0cG1faW5pdGlh bGlzZShzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCit7CisgICAgc3RydWN0IHhlbl92dHBtX2Rl diAqdnRwbWRldiA9IGNvbnRhaW5lcl9vZih4ZW5kZXYsIHN0cnVjdCB4ZW5fdnRwbV9kZXYsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5kZXYpOwor ICAgIHhzX3RyYW5zYWN0aW9uX3QgeGJ0ID0gWEJUX05VTEw7CisgICAgdW5zaWduZWQgaW50IHJp bmdfcmVmOworCisgICAgdnRwbWRldi0+eGVuZGV2LmZlID0geGVuc3RvcmVfcmVhZF9iZV9zdHIo JnZ0cG1kZXYtPnhlbmRldiwgImZyb250ZW5kIik7CisgICAgaWYgKHZ0cG1kZXYtPnhlbmRldi5m ZSA9PSBOVUxMKSB7CisgICAgICAgIHJldHVybiAtMTsKKyAgICB9CisKKyAgICAvKiBHZXQgYmFj a2VuZCBkb21pZCAqLworICAgIGlmICh4ZW5zdG9yZV9yZWFkX2ZlX2ludCgmdnRwbWRldi0+eGVu ZGV2LCAiYmFja2VuZC1pZCIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZ2dHBtZGV2 LT5iZWRvbWlkKSkgeworICAgICAgICByZXR1cm4gLTE7CisgICAgfQorCisgICAgLyogQWxsb2Mg c2hhcmVkIHBhZ2UgKi8KKyAgICB2dHBtZGV2LT5zaHIgPSB4ZW5nbnRzaHJfc2hhcmVfcGFnZXMo dnRwbWRldi0+eGVuX3hjcywgdnRwbWRldi0+YmVkb21pZCwgMSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgJnJpbmdfcmVmLCBQUk9UX1JFQUR8UFJPVF9XUklURSk7 CisgICAgdnRwbWRldi0+cmluZ19yZWYgPSByaW5nX3JlZjsKKyAgICBpZiAodnRwbWRldi0+c2hy ID09IE5VTEwpIHsKKyAgICAgICAgcmV0dXJuIC0xOworICAgIH0KKworICAgIC8qIENyZWF0ZSBl dmVudCBjaGFubmVsICovCisgICAgaWYgKHhlbl9mZV9hbGxvY191bmJvdW5kKCZ2dHBtZGV2LT54 ZW5kZXYsIDAsIHZ0cG1kZXYtPmJlZG9taWQpKSB7CisgICAgICAgIHhlbmdudHNocl91bnNoYXJl KHZ0cG1kZXYtPnhlbl94Y3MsIHZ0cG1kZXYtPnNociwgMSk7CisgICAgICAgIHJldHVybiAtMTsK KyAgICB9CisKKyAgICB4ZW5ldnRjaG5fdW5tYXNrKHZ0cG1kZXYtPnhlbmRldi5ldnRjaG5kZXYs CisgICAgICAgICAgICAgICAgICAgICB2dHBtZGV2LT54ZW5kZXYubG9jYWxfcG9ydCk7CisKK2Fn YWluOgorICAgIHhidCA9IHhzX3RyYW5zYWN0aW9uX3N0YXJ0KHhlbnN0b3JlKTsKKyAgICBpZiAo eGJ0ID09IFhCVF9OVUxMKSB7CisgICAgICAgIGdvdG8gYWJvcnRfdHJhbnNhY3Rpb247CisgICAg fQorCisgICAgaWYgKHhlbnN0b3JlX3dyaXRlX2ludCh2dHBtZGV2LT54ZW5kZXYuZmUsICJyaW5n LXJlZiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICB2dHBtZGV2LT5yaW5nX3JlZikpIHsK KyAgICAgICAgZ290byBhYm9ydF90cmFuc2FjdGlvbjsKKyAgICB9CisKKyAgICBpZiAoeGVuc3Rv cmVfd3JpdGVfaW50KHZ0cG1kZXYtPnhlbmRldi5mZSwgImV2ZW50LWNoYW5uZWwiLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgdnRwbWRldi0+eGVuZGV2LmxvY2FsX3BvcnQpKSB7CisgICAg ICAgIGdvdG8gYWJvcnRfdHJhbnNhY3Rpb247CisgICAgfQorCisgICAgLyogUHVibGlzaCBwcm90 b2NvbCB2MiBmZWF0dXJlICovCisgICAgaWYgKHhlbnN0b3JlX3dyaXRlX2ludCh2dHBtZGV2LT54 ZW5kZXYuZmUsICJmZWF0dXJlLXByb3RvY29sLXYyIiwgMSkpIHsKKyAgICAgICAgZ290byBhYm9y dF90cmFuc2FjdGlvbjsKKyAgICB9CisKKyAgICBpZiAoIXhzX3RyYW5zYWN0aW9uX2VuZCh4ZW5z dG9yZSwgeGJ0LCAwKSkgeworICAgICAgICBpZiAoZXJybm8gPT0gRUFHQUlOKSB7CisgICAgICAg ICAgICBnb3RvIGFnYWluOworICAgICAgICB9CisgICAgfQorCisgICAgcmV0dXJuIDA7CisKK2Fi b3J0X3RyYW5zYWN0aW9uOgorICAgIHhlbmdudHNocl91bnNoYXJlKHZ0cG1kZXYtPnhlbl94Y3Ms IHZ0cG1kZXYtPnNociwgMSk7CisgICAgeHNfdHJhbnNhY3Rpb25fZW5kKHhlbnN0b3JlLCB4YnQs IDEpOworICAgIHJldHVybiAtMTsKK30KKworc3RhdGljIGludCB2dHBtX2ZyZWUoc3RydWN0IFhl bkRldmljZSAqeGVuZGV2KQoreworICAgIHN0cnVjdCB4ZW5fdnRwbV9kZXYgKnZ0cG1kZXYgPSBj b250YWluZXJfb2YoeGVuZGV2LCBzdHJ1Y3QgeGVuX3Z0cG1fZGV2LAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeGVuZGV2KTsKKworICAgIGFpb19wb2xs KHZ0cG1fYWlvX2N0eCwgZmFsc2UpOworICAgIHFlbXVfYmhfZGVsZXRlKHZ0cG1kZXYtPnNyX2Jo KTsKKyAgICBpZiAodnRwbWRldi0+c2hyKSB7CisgICAgICAgIHhlbmdudHNocl91bnNoYXJlKHZ0 cG1kZXYtPnhlbl94Y3MsIHZ0cG1kZXYtPnNociwgMSk7CisgICAgfQorICAgIHhlbmdudHNocl9j bG9zZSh2dHBtZGV2LT54ZW5feGNzKTsKKyAgICByZXR1cm4gMDsKK30KKworc3RhdGljIGludCB2 dHBtX2luaXQoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQoreworICAgIGNoYXIgcGF0aFtYRU5f QlVGU0laRV07CisgICAgY2hhciAqdmFsdWU7CisgICAgdW5zaWduZWQgaW50IHN0dWJkb21fdnRw bSA9IDA7CisKKyAgICBzbnByaW50ZihwYXRoLCBzaXplb2YocGF0aCksICIvbG9jYWwvZG9tYWlu LyVkL3BsYXRmb3JtL2FjcGlfc3R1YmRvbV92dHBtIiwKKyAgICAgICAgICAgICB4ZW5fZG9taWQp OworICAgIHZhbHVlID0geHNfcmVhZCh4ZW5zdG9yZSwgMCwgcGF0aCwgJnN0dWJkb21fdnRwbSk7 CisgICAgaWYgKHN0dWJkb21fdnRwbSA8PSAwIHx8IHN0cmNtcCh2YWx1ZSwgWFNfU1RVQkRPTV9W VFBNX0VOQUJMRSkpIHsKKyAgICAgICAgZnJlZSh2YWx1ZSk7CisgICAgICAgIHJldHVybiAtMTsK KyAgICB9CisgICAgZnJlZSh2YWx1ZSk7CisgICAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lk IHZ0cG1fYWxsb2Moc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQoreworICAgIHN0cnVjdCB4ZW5f dnRwbV9kZXYgKnZ0cG1kZXYgPSBjb250YWluZXJfb2YoeGVuZGV2LCBzdHJ1Y3QgeGVuX3Z0cG1f ZGV2LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeGVu ZGV2KTsKKworICAgIHZ0cG1fYWlvX2N0eCA9IGFpb19jb250ZXh0X25ldyhOVUxMKTsKKyAgICBp ZiAodnRwbV9haW9fY3R4ID09IE5VTEwpIHsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICB2 dHBtZGV2LT5zcl9iaCA9IGFpb19iaF9uZXcodnRwbV9haW9fY3R4LCBzcl9iaF9oYW5kbGVyLCB2 dHBtZGV2KTsKKyAgICBxZW11X2JoX3NjaGVkdWxlKHZ0cG1kZXYtPnNyX2JoKTsKKyAgICB2dHBt ZGV2LT54ZW5feGNzID0geGVuZ250c2hyX29wZW4oMCwgMCk7CisgICAgeGVuc3RvcmVfdnRwbV9k ZXYgPSB4ZW5kZXYtPmRldjsKK30KKworc3RhdGljIHZvaWQgdnRwbV9ldmVudChzdHJ1Y3QgWGVu RGV2aWNlICp4ZW5kZXYpCit7CisgICAgc3RydWN0IHhlbl92dHBtX2RldiAqdnRwbWRldiA9IGNv bnRhaW5lcl9vZih4ZW5kZXYsIHN0cnVjdCB4ZW5fdnRwbV9kZXYsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5kZXYpOworCisgICAgcWVtdV9iaF9z Y2hlZHVsZSh2dHBtZGV2LT5zcl9iaCk7Cit9CisKK3N0cnVjdCBYZW5EZXZPcHMgeGVuX3Z0cG1k ZXZfb3BzID0geworICAgIC5zaXplICAgICAgICAgICAgID0gc2l6ZW9mKHN0cnVjdCB4ZW5fdnRw bV9kZXYpLAorICAgIC5mbGFncyAgICAgICAgICAgID0gREVWT1BTX0ZMQUdfSUdOT1JFX1NUQVRF IHwKKyAgICAgICAgICAgICAgICAgICAgICAgIERFVk9QU19GTEFHX0ZFLAorICAgIC5ldmVudCAg ICAgICAgICAgID0gdnRwbV9ldmVudCwKKyAgICAuZnJlZSAgICAgICAgICAgICA9IHZ0cG1fZnJl ZSwKKyAgICAuaW5pdCAgICAgICAgICAgICA9IHZ0cG1faW5pdCwKKyAgICAuYWxsb2MgICAgICAg ICAgICA9IHZ0cG1fYWxsb2MsCisgICAgLmluaXRpYWxpc2UgICAgICAgPSB2dHBtX2luaXRpYWxp c2UsCisgICAgLmJhY2tlbmRfY2hhbmdlZCAgPSB4ZW5fZmVfYmFja2VuZF9jaGFuZ2VkLAorfTsK XCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9ody90cG0veGVuX3Z0cG1f ZnJvbnRlbmQuaCBiL2h3L3RwbS94ZW5fdnRwbV9mcm9udGVuZC5oCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLjcyZjU4NmIKLS0tIC9kZXYvbnVsbAorKysgYi9ody90cG0veGVu X3Z0cG1fZnJvbnRlbmQuaApAQCAtMCwwICsxLDEwIEBACisjaWZuZGVmIFRQTV9YRU5fVlRQTV9G Uk9OVEVORF9ICisjZGVmaW5lIFRQTV9YRU5fVlRQTV9GUk9OVEVORF9IIDEKKworc3RydWN0IFhl bkRldmljZTsKK2V4dGVybiBpbnQgeGVuc3RvcmVfdnRwbV9kZXY7CisvKiBYZW4gdnRwbSAqLwor aW50IHZ0cG1fc2VuZChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIHVpbnQ4X3QqIGJ1Ziwgc2l6 ZV90IGNvdW50KTsKK2ludCB2dHBtX3JlY3Yoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LCB1aW50 OF90KiBidWYsIHNpemVfdCAqY291bnQpOworCisjZW5kaWYgLyogVFBNX1hFTl9WVFBNX0ZST05U RU5EX0ggKi8KZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW5fZnJvbnRlbmQuYyBiL2h3L3hlbi94ZW5f ZnJvbnRlbmQuYwppbmRleCA3YjMwNWNlLi5mMTEwNDExIDEwMDY0NAotLS0gYS9ody94ZW4veGVu X2Zyb250ZW5kLmMKKysrIGIvaHcveGVuL3hlbl9mcm9udGVuZC5jCkBAIC03NSw2ICs3NSwyNiBA QCB2b2lkIHhlbl9mZV9mcm9udGVuZF9jaGFuZ2VkKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwg Y29uc3QgY2hhciAqbm9kZSkKICAgICB9CiB9CiAKK3ZvaWQgeGVuX2ZlX2JhY2tlbmRfY2hhbmdl ZChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUpCit7CisgICAgaW50 IGJlX3N0YXRlOworCisgICAgaWYgKHN0cmNtcChub2RlLCAic3RhdGUiKSA9PSAwKSB7CisgICAg ICAgIHhlbnN0b3JlX3JlYWRfYmVfaW50KHhlbmRldiwgbm9kZSwgJmJlX3N0YXRlKTsKKyAgICAg ICAgc3dpdGNoIChiZV9zdGF0ZSkgeworICAgICAgICBjYXNlIFhlbmJ1c1N0YXRlQ29ubmVjdGVk OgorICAgICAgICAgICAgLyogVE9ETyAqLworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNh c2UgWGVuYnVzU3RhdGVDbG9zaW5nOgorICAgICAgICBjYXNlIFhlbmJ1c1N0YXRlQ2xvc2VkOgor ICAgICAgICAgICAgeGVuYnVzX3N3aXRjaF9zdGF0ZSh4ZW5kZXYsIFhlbmJ1c1N0YXRlQ2xvc2lu Zyk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIGJy ZWFrOworICAgICAgICB9CisgICAgfQorfQorCiB2b2lkIHhlbnN0b3JlX3VwZGF0ZV9mZShjaGFy ICp3YXRjaCwgc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogewogICAgIGNoYXIgKm5vZGU7CmRp ZmYgLS1naXQgYS9pbmNsdWRlL2h3L3hlbi94ZW5fYmFja2VuZC5oIGIvaW5jbHVkZS9ody94ZW4v eGVuX2JhY2tlbmQuaAppbmRleCA3MWRkMTU4Li40YTg4MDhlIDEwMDY0NAotLS0gYS9pbmNsdWRl L2h3L3hlbi94ZW5fYmFja2VuZC5oCisrKyBiL2luY2x1ZGUvaHcveGVuL3hlbl9iYWNrZW5kLmgK QEAgLTM1LDYgKzM1LDcgQEAgZXh0ZXJuIHN0cnVjdCBYZW5EZXZPcHMgeGVuX2tiZG1vdXNlX29w czsgICAgIC8qIHhlbl9mcmFtZWJ1ZmZlci5jICovCiBleHRlcm4gc3RydWN0IFhlbkRldk9wcyB4 ZW5fZnJhbWVidWZmZXJfb3BzOyAgLyogeGVuX2ZyYW1lYnVmZmVyLmMgKi8KIGV4dGVybiBzdHJ1 Y3QgWGVuRGV2T3BzIHhlbl9ibGtkZXZfb3BzOyAgICAgICAvKiB4ZW5fZGlzay5jICAgICAgICAq LwogZXh0ZXJuIHN0cnVjdCBYZW5EZXZPcHMgeGVuX25ldGRldl9vcHM7ICAgICAgIC8qIHhlbl9u aWMuYyAgICAgICAgICovCitleHRlcm4gc3RydWN0IFhlbkRldk9wcyB4ZW5fdnRwbWRldl9vcHM7 ICAgICAgLyogeGVuX3Z0cG1fZnJvbnRlbmQuYyovCiAjaWZkZWYgQ09ORklHX1VTQl9MSUJVU0IK IGV4dGVybiBzdHJ1Y3QgWGVuRGV2T3BzIHhlbl91c2Jfb3BzOyAgICAgICAgICAvKiB4ZW4tdXNi LmMgICAgICAgICAqLwogI2VuZGlmCmRpZmYgLS1naXQgYS9pbmNsdWRlL2h3L3hlbi94ZW5fZnJv bnRlbmQuaCBiL2luY2x1ZGUvaHcveGVuL3hlbl9mcm9udGVuZC5oCmluZGV4IDhmYzA0MjIuLjkx MmYzMzMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvaHcveGVuL3hlbl9mcm9udGVuZC5oCisrKyBiL2lu Y2x1ZGUvaHcveGVuL3hlbl9mcm9udGVuZC5oCkBAIC0xMSw2ICsxMSw3IEBAIHZvaWQgeGVuc3Rv cmVfdXBkYXRlX2ZlKGNoYXIgKndhdGNoLCBzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpOwogc3Ry dWN0IFhlbkRldmljZSAqeGVuX2ZlX2dldF94ZW5kZXYoY29uc3QgY2hhciAqdHlwZSwgaW50IGRv bSwgaW50IGRldiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNoYXIgKmJh Y2tlbmQsIHN0cnVjdCBYZW5EZXZPcHMgKm9wcyk7CiB2b2lkIHhlbl9mZV9mcm9udGVuZF9jaGFu Z2VkKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAqbm9kZSk7Cit2b2lkIHhl bl9mZV9iYWNrZW5kX2NoYW5nZWQoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LCBjb25zdCBjaGFy ICpub2RlKTsKIGludCB4ZW5fZmVfcmVnaXN0ZXIoY29uc3QgY2hhciAqdHlwZSwgc3RydWN0IFhl bkRldk9wcyAqb3BzKTsKIGludCB4ZW5fZmVfYWxsb2NfdW5ib3VuZChzdHJ1Y3QgWGVuRGV2aWNl ICp4ZW5kZXYsIGludCBkb20sIGludCByZW1vdGVfZG9tKTsKIGludCB4ZW5idXNfc3dpdGNoX3N0 YXRlKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgZW51bSB4ZW5idXNfc3RhdGUgeGJ1cyk7CmRp ZmYgLS1naXQgYS94ZW4taHZtLmMgYi94ZW4taHZtLmMKaW5kZXggZWI1Nzc5Mi4uZWYzZmM1MyAx MDA2NDQKLS0tIGEveGVuLWh2bS5jCisrKyBiL3hlbi1odm0uYwpAQCAtMTYsNiArMTYsNyBAQAog I2luY2x1ZGUgImh3L2kzODYvYXBpYy1tc2lkZWYuaCIKICNpbmNsdWRlICJody94ZW4veGVuX2Nv bW1vbi5oIgogI2luY2x1ZGUgImh3L3hlbi94ZW5fYmFja2VuZC5oIgorI2luY2x1ZGUgImh3L3hl bi94ZW5fZnJvbnRlbmQuaCIKICNpbmNsdWRlICJxbXAtY29tbWFuZHMuaCIKIAogI2luY2x1ZGUg InN5c2VtdS9jaGFyLmgiCkBAIC0xMzE4LDYgKzEzMTksMTEgQEAgdm9pZCB4ZW5faHZtX2luaXQo UENNYWNoaW5lU3RhdGUgKnBjbXMsIE1lbW9yeVJlZ2lvbiAqKnJhbV9tZW1vcnkpCiAgICAgICAg IGVycm9yX3JlcG9ydCgieGVuIGJhY2tlbmQgY29yZSBzZXR1cCBmYWlsZWQiKTsKICAgICAgICAg Z290byBlcnI7CiAgICAgfQorCisjaWZkZWYgQ09ORklHX1RQTV9YRU5TVFVCRE9NUworICAgIHhl bl9mZV9yZWdpc3RlcigidnRwbSIsICZ4ZW5fdnRwbWRldl9vcHMpOworI2VuZGlmCisKICAgICB4 ZW5fYmVfcmVnaXN0ZXIoImNvbnNvbGUiLCAmeGVuX2NvbnNvbGVfb3BzKTsKICAgICB4ZW5fYmVf cmVnaXN0ZXIoInZrYmQiLCAmeGVuX2tiZG1vdXNlX29wcyk7CiAgICAgeGVuX2JlX3JlZ2lzdGVy KCJxZGlzayIsICZ4ZW5fYmxrZGV2X29wcyk7Ci0tIAoxLjkuMQoKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVu LWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cHM6Ly9saXN0cy54ZW4ub3JnL3hlbi1kZXZlbAo=