From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1758107AbdAFPHV (ORCPT ); Fri, 6 Jan 2017 10:07:21 -0500 Received: from mx2.suse.de ([195.135.220.15]:53711 "EHLO mx2.suse.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1757602AbdAFPHL (ORCPT ); Fri, 6 Jan 2017 10:07:11 -0500 From: Juergen Gross To: linux-kernel@vger.kernel.org, xen-devel@lists.xenproject.org Cc: boris.ostrovsky@oracle.com, Juergen Gross Subject: [PATCH 1/3] xen: clean up xenbus internal headers Date: Fri, 6 Jan 2017 16:05:42 +0100 Message-Id: <20170106150544.10836-2-jgross@suse.com> X-Mailer: git-send-email 2.10.2 In-Reply-To: <20170106150544.10836-1-jgross@suse.com> References: <20170106150544.10836-1-jgross@suse.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The xenbus driver has an awful mixture of internal and global visible headers: some of the internal used only stuff is defined in the global header include/xen/xenbus.h while some stuff defined in internal headers is used by other drivers, too. Clean this up by moving the external used symbols to include/xen/xenbus.h and the symbols used internal only to a new header drivers/xen/xenbus/xenbus.h Signed-off-by: Juergen Gross --- drivers/xen/xenbus/{xenbus_probe.h => xenbus.h} | 64 ++++++++++++++----------- drivers/xen/xenbus/xenbus_client.c | 2 +- drivers/xen/xenbus/xenbus_comms.c | 2 +- drivers/xen/xenbus/xenbus_comms.h | 51 -------------------- drivers/xen/xenbus/xenbus_dev_backend.c | 2 +- drivers/xen/xenbus/xenbus_dev_frontend.c | 4 +- drivers/xen/xenbus/xenbus_probe.c | 3 +- drivers/xen/xenbus/xenbus_probe_backend.c | 3 +- drivers/xen/xenbus/xenbus_probe_frontend.c | 3 +- drivers/xen/xenbus/xenbus_xs.c | 3 +- drivers/xen/xenfs/super.c | 2 +- drivers/xen/xenfs/xenstored.c | 2 +- include/xen/xenbus.h | 12 ++--- 13 files changed, 52 insertions(+), 101 deletions(-) rename drivers/xen/xenbus/{xenbus_probe.h => xenbus.h} (58%) delete mode 100644 drivers/xen/xenbus/xenbus_comms.h diff --git a/drivers/xen/xenbus/xenbus_probe.h b/drivers/xen/xenbus/xenbus.h similarity index 58% rename from drivers/xen/xenbus/xenbus_probe.h rename to drivers/xen/xenbus/xenbus.h index c9ec7ca..6a80c1e 100644 --- a/drivers/xen/xenbus/xenbus_probe.h +++ b/drivers/xen/xenbus/xenbus.h @@ -1,10 +1,7 @@ -/****************************************************************************** - * xenbus_probe.h - * - * Talks to Xen Store to figure out what devices we have. +/* + * Private include for xenbus communications. * * Copyright (C) 2005 Rusty Russell, IBM Corporation - * Copyright (C) 2005 XenSource Ltd. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License version 2 @@ -31,8 +28,8 @@ * IN THE SOFTWARE. */ -#ifndef _XENBUS_PROBE_H -#define _XENBUS_PROBE_H +#ifndef _XENBUS_XENBUS_H +#define _XENBUS_XENBUS_H #define XEN_BUS_ID_SIZE 20 @@ -54,35 +51,46 @@ enum xenstore_init { XS_LOCAL, }; +extern enum xenstore_init xen_store_domain_type; extern const struct attribute_group *xenbus_dev_groups[]; -extern int xenbus_match(struct device *_dev, struct device_driver *_drv); -extern int xenbus_dev_probe(struct device *_dev); -extern int xenbus_dev_remove(struct device *_dev); -extern int xenbus_register_driver_common(struct xenbus_driver *drv, - struct xen_bus_type *bus, - struct module *owner, - const char *mod_name); -extern int xenbus_probe_node(struct xen_bus_type *bus, - const char *type, - const char *nodename); -extern int xenbus_probe_devices(struct xen_bus_type *bus); +int xs_init(void); +int xb_init_comms(void); +void xb_deinit_comms(void); +int xb_write(const void *data, unsigned int len); +int xb_read(void *data, unsigned int len); +int xb_data_to_read(void); +int xb_wait_for_data_to_read(void); -extern void xenbus_dev_changed(const char *node, struct xen_bus_type *bus); +int xenbus_match(struct device *_dev, struct device_driver *_drv); +int xenbus_dev_probe(struct device *_dev); +int xenbus_dev_remove(struct device *_dev); +int xenbus_register_driver_common(struct xenbus_driver *drv, + struct xen_bus_type *bus, + struct module *owner, + const char *mod_name); +int xenbus_probe_node(struct xen_bus_type *bus, + const char *type, + const char *nodename); +int xenbus_probe_devices(struct xen_bus_type *bus); -extern void xenbus_dev_shutdown(struct device *_dev); +void xenbus_dev_changed(const char *node, struct xen_bus_type *bus); -extern int xenbus_dev_suspend(struct device *dev); -extern int xenbus_dev_resume(struct device *dev); -extern int xenbus_dev_cancel(struct device *dev); +void xenbus_dev_shutdown(struct device *_dev); -extern void xenbus_otherend_changed(struct xenbus_watch *watch, - const char **vec, unsigned int len, - int ignore_on_shutdown); +int xenbus_dev_suspend(struct device *dev); +int xenbus_dev_resume(struct device *dev); +int xenbus_dev_cancel(struct device *dev); -extern int xenbus_read_otherend_details(struct xenbus_device *xendev, - char *id_node, char *path_node); +void xenbus_otherend_changed(struct xenbus_watch *watch, + const char **vec, unsigned int len, + int ignore_on_shutdown); + +int xenbus_read_otherend_details(struct xenbus_device *xendev, + char *id_node, char *path_node); void xenbus_ring_ops_init(void); +void *xenbus_dev_request_and_reply(struct xsd_sockmsg *msg); + #endif diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c index 056da6e..23edf53 100644 --- a/drivers/xen/xenbus/xenbus_client.c +++ b/drivers/xen/xenbus/xenbus_client.c @@ -47,7 +47,7 @@ #include #include -#include "xenbus_probe.h" +#include "xenbus.h" #define XENBUS_PAGES(_grants) (DIV_ROUND_UP(_grants, XEN_PFN_PER_PAGE)) diff --git a/drivers/xen/xenbus/xenbus_comms.c b/drivers/xen/xenbus/xenbus_comms.c index ecdecce..c21ec02 100644 --- a/drivers/xen/xenbus/xenbus_comms.c +++ b/drivers/xen/xenbus/xenbus_comms.c @@ -40,7 +40,7 @@ #include #include #include -#include "xenbus_comms.h" +#include "xenbus.h" static int xenbus_irq; diff --git a/drivers/xen/xenbus/xenbus_comms.h b/drivers/xen/xenbus/xenbus_comms.h deleted file mode 100644 index 867a2e4..0000000 --- a/drivers/xen/xenbus/xenbus_comms.h +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Private include for xenbus communications. - * - * Copyright (C) 2005 Rusty Russell, IBM Corporation - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License version 2 - * as published by the Free Software Foundation; or, when distributed - * separately from the Linux kernel or incorporated into other - * software packages, subject to the following license: - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this source file (the "Software"), to deal in the Software without - * restriction, including without limitation the rights to use, copy, modify, - * merge, publish, distribute, sublicense, and/or sell copies of the Software, - * and to permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - * IN THE SOFTWARE. - */ - -#ifndef _XENBUS_COMMS_H -#define _XENBUS_COMMS_H - -#include - -int xs_init(void); -int xb_init_comms(void); -void xb_deinit_comms(void); - -/* Low level routines. */ -int xb_write(const void *data, unsigned len); -int xb_read(void *data, unsigned len); -int xb_data_to_read(void); -int xb_wait_for_data_to_read(void); -extern struct xenstore_domain_interface *xen_store_interface; -extern int xen_store_evtchn; -extern enum xenstore_init xen_store_domain_type; - -extern const struct file_operations xen_xenbus_fops; - -#endif /* _XENBUS_COMMS_H */ diff --git a/drivers/xen/xenbus/xenbus_dev_backend.c b/drivers/xen/xenbus/xenbus_dev_backend.c index 4a41ac9..1126701 100644 --- a/drivers/xen/xenbus/xenbus_dev_backend.c +++ b/drivers/xen/xenbus/xenbus_dev_backend.c @@ -16,7 +16,7 @@ #include #include -#include "xenbus_comms.h" +#include "xenbus.h" static int xenbus_backend_open(struct inode *inode, struct file *filp) { diff --git a/drivers/xen/xenbus/xenbus_dev_frontend.c b/drivers/xen/xenbus/xenbus_dev_frontend.c index 79130b3..e2bc9b3 100644 --- a/drivers/xen/xenbus/xenbus_dev_frontend.c +++ b/drivers/xen/xenbus/xenbus_dev_frontend.c @@ -57,12 +57,12 @@ #include #include -#include "xenbus_comms.h" - #include #include #include +#include "xenbus.h" + /* * An element of a list of outstanding transactions, for which we're * still waiting a reply. diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c index 4bdf654..6baffbb 100644 --- a/drivers/xen/xenbus/xenbus_probe.c +++ b/drivers/xen/xenbus/xenbus_probe.c @@ -62,8 +62,7 @@ #include -#include "xenbus_comms.h" -#include "xenbus_probe.h" +#include "xenbus.h" int xen_store_evtchn; diff --git a/drivers/xen/xenbus/xenbus_probe_backend.c b/drivers/xen/xenbus/xenbus_probe_backend.c index 37929df..f46b4dc 100644 --- a/drivers/xen/xenbus/xenbus_probe_backend.c +++ b/drivers/xen/xenbus/xenbus_probe_backend.c @@ -53,8 +53,7 @@ #include #include -#include "xenbus_comms.h" -#include "xenbus_probe.h" +#include "xenbus.h" /* backend/// => -- */ static int backend_bus_id(char bus_id[XEN_BUS_ID_SIZE], const char *nodename) diff --git a/drivers/xen/xenbus/xenbus_probe_frontend.c b/drivers/xen/xenbus/xenbus_probe_frontend.c index 6d40a97..d7b77a6 100644 --- a/drivers/xen/xenbus/xenbus_probe_frontend.c +++ b/drivers/xen/xenbus/xenbus_probe_frontend.c @@ -27,8 +27,7 @@ #include -#include "xenbus_comms.h" -#include "xenbus_probe.h" +#include "xenbus.h" diff --git a/drivers/xen/xenbus/xenbus_xs.c b/drivers/xen/xenbus/xenbus_xs.c index 6afb993..4c49d87 100644 --- a/drivers/xen/xenbus/xenbus_xs.c +++ b/drivers/xen/xenbus/xenbus_xs.c @@ -48,8 +48,7 @@ #include #include #include -#include "xenbus_comms.h" -#include "xenbus_probe.h" +#include "xenbus.h" struct xs_stored_msg { struct list_head list; diff --git a/drivers/xen/xenfs/super.c b/drivers/xen/xenfs/super.c index 8559a71..328c398 100644 --- a/drivers/xen/xenfs/super.c +++ b/drivers/xen/xenfs/super.c @@ -16,10 +16,10 @@ #include #include +#include #include "xenfs.h" #include "../privcmd.h" -#include "../xenbus/xenbus_comms.h" #include diff --git a/drivers/xen/xenfs/xenstored.c b/drivers/xen/xenfs/xenstored.c index fef20db..82fd2a3 100644 --- a/drivers/xen/xenfs/xenstored.c +++ b/drivers/xen/xenfs/xenstored.c @@ -4,9 +4,9 @@ #include #include +#include #include "xenfs.h" -#include "../xenbus/xenbus_comms.h" static ssize_t xsd_read(struct file *file, char __user *buf, size_t size, loff_t *off) diff --git a/include/xen/xenbus.h b/include/xen/xenbus.h index 271ba62..98f73a2 100644 --- a/include/xen/xenbus.h +++ b/include/xen/xenbus.h @@ -38,6 +38,7 @@ #include #include #include +#include #include #include #include @@ -175,16 +176,9 @@ void xs_suspend(void); void xs_resume(void); void xs_suspend_cancel(void); -/* Used by xenbus_dev to borrow kernel's store connection. */ -void *xenbus_dev_request_and_reply(struct xsd_sockmsg *msg); - struct work_struct; -/* Prepare for domain suspend: then resume or cancel the suspend. */ -void xenbus_suspend(void); -void xenbus_resume(void); void xenbus_probe(struct work_struct *); -void xenbus_suspend_cancel(void); #define XENBUS_IS_ERR_READ(str) ({ \ if (!IS_ERR(str) && strlen(str) == 0) { \ @@ -235,4 +229,8 @@ const char *xenbus_strstate(enum xenbus_state state); int xenbus_dev_is_online(struct xenbus_device *dev); int xenbus_frontend_closed(struct xenbus_device *dev); +extern const struct file_operations xen_xenbus_fops; +extern struct xenstore_domain_interface *xen_store_interface; +extern int xen_store_evtchn; + #endif /* _XEN_XENBUS_H */ -- 2.10.2 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Juergen Gross Subject: [PATCH 1/3] xen: clean up xenbus internal headers Date: Fri, 6 Jan 2017 16:05:42 +0100 Message-ID: <20170106150544.10836-2-jgross@suse.com> References: <20170106150544.10836-1-jgross@suse.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta6.messagelabs.com ([193.109.254.103]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1cPW5k-0002uY-H2 for xen-devel@lists.xenproject.org; Fri, 06 Jan 2017 15:06:04 +0000 In-Reply-To: <20170106150544.10836-1-jgross@suse.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: linux-kernel@vger.kernel.org, xen-devel@lists.xenproject.org Cc: Juergen Gross , boris.ostrovsky@oracle.com List-Id: xen-devel@lists.xenproject.org VGhlIHhlbmJ1cyBkcml2ZXIgaGFzIGFuIGF3ZnVsIG1peHR1cmUgb2YgaW50ZXJuYWwgYW5kIGds b2JhbCB2aXNpYmxlCmhlYWRlcnM6IHNvbWUgb2YgdGhlIGludGVybmFsIHVzZWQgb25seSBzdHVm ZiBpcyBkZWZpbmVkIGluIHRoZQpnbG9iYWwgaGVhZGVyIGluY2x1ZGUveGVuL3hlbmJ1cy5oIHdo aWxlIHNvbWUgc3R1ZmYgZGVmaW5lZCBpbiBpbnRlcm5hbApoZWFkZXJzIGlzIHVzZWQgYnkgb3Ro ZXIgZHJpdmVycywgdG9vLgoKQ2xlYW4gdGhpcyB1cCBieSBtb3ZpbmcgdGhlIGV4dGVybmFsIHVz ZWQgc3ltYm9scyB0bwppbmNsdWRlL3hlbi94ZW5idXMuaCBhbmQgdGhlIHN5bWJvbHMgdXNlZCBp bnRlcm5hbCBvbmx5IHRvIGEgbmV3CmhlYWRlciBkcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzLmgK ClNpZ25lZC1vZmYtYnk6IEp1ZXJnZW4gR3Jvc3MgPGpncm9zc0BzdXNlLmNvbT4KLS0tCiBkcml2 ZXJzL3hlbi94ZW5idXMve3hlbmJ1c19wcm9iZS5oID0+IHhlbmJ1cy5ofSB8IDY0ICsrKysrKysr KysrKysrLS0tLS0tLS0tLS0KIGRyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfY2xpZW50LmMgICAg ICAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfY29tbXMuYyAgICAg ICAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfY29tbXMuaCAgICAg ICAgICAgICAgIHwgNTEgLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMveGVuL3hlbmJ1cy94 ZW5idXNfZGV2X2JhY2tlbmQuYyAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMveGVuL3hlbmJ1cy94 ZW5idXNfZGV2X2Zyb250ZW5kLmMgICAgICAgIHwgIDQgKy0KIGRyaXZlcnMveGVuL3hlbmJ1cy94 ZW5idXNfcHJvYmUuYyAgICAgICAgICAgICAgIHwgIDMgKy0KIGRyaXZlcnMveGVuL3hlbmJ1cy94 ZW5idXNfcHJvYmVfYmFja2VuZC5jICAgICAgIHwgIDMgKy0KIGRyaXZlcnMveGVuL3hlbmJ1cy94 ZW5idXNfcHJvYmVfZnJvbnRlbmQuYyAgICAgIHwgIDMgKy0KIGRyaXZlcnMveGVuL3hlbmJ1cy94 ZW5idXNfeHMuYyAgICAgICAgICAgICAgICAgIHwgIDMgKy0KIGRyaXZlcnMveGVuL3hlbmZzL3N1 cGVyLmMgICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMveGVuL3hlbmZzL3hl bnN0b3JlZC5jICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KIGluY2x1ZGUveGVuL3hlbmJ1cy5o ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMTIgKystLS0KIDEzIGZpbGVzIGNoYW5nZWQs IDUyIGluc2VydGlvbnMoKyksIDEwMSBkZWxldGlvbnMoLSkKIHJlbmFtZSBkcml2ZXJzL3hlbi94 ZW5idXMve3hlbmJ1c19wcm9iZS5oID0+IHhlbmJ1cy5ofSAoNTglKQogZGVsZXRlIG1vZGUgMTAw NjQ0IGRyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfY29tbXMuaAoKZGlmZiAtLWdpdCBhL2RyaXZl cnMveGVuL3hlbmJ1cy94ZW5idXNfcHJvYmUuaCBiL2RyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXMu aApzaW1pbGFyaXR5IGluZGV4IDU4JQpyZW5hbWUgZnJvbSBkcml2ZXJzL3hlbi94ZW5idXMveGVu YnVzX3Byb2JlLmgKcmVuYW1lIHRvIGRyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXMuaAppbmRleCBj OWVjN2NhLi42YTgwYzFlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX3By b2JlLmgKKysrIGIvZHJpdmVycy94ZW4veGVuYnVzL3hlbmJ1cy5oCkBAIC0xLDEwICsxLDcgQEAK LS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioKLSAqIHhlbmJ1c19wcm9iZS5oCi0gKgotICogVGFsa3Mg dG8gWGVuIFN0b3JlIHRvIGZpZ3VyZSBvdXQgd2hhdCBkZXZpY2VzIHdlIGhhdmUuCisvKgorICog UHJpdmF0ZSBpbmNsdWRlIGZvciB4ZW5idXMgY29tbXVuaWNhdGlvbnMuCiAgKgogICogQ29weXJp Z2h0IChDKSAyMDA1IFJ1c3R5IFJ1c3NlbGwsIElCTSBDb3Jwb3JhdGlvbgotICogQ29weXJpZ2h0 IChDKSAyMDA1IFhlblNvdXJjZSBMdGQuCiAgKgogICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29m dHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgogICogbW9kaWZ5IGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyCkBA IC0zMSw4ICsyOCw4IEBACiAgKiBJTiBUSEUgU09GVFdBUkUuCiAgKi8KIAotI2lmbmRlZiBfWEVO QlVTX1BST0JFX0gKLSNkZWZpbmUgX1hFTkJVU19QUk9CRV9ICisjaWZuZGVmIF9YRU5CVVNfWEVO QlVTX0gKKyNkZWZpbmUgX1hFTkJVU19YRU5CVVNfSAogCiAjZGVmaW5lIFhFTl9CVVNfSURfU0la RQkJCTIwCiAKQEAgLTU0LDM1ICs1MSw0NiBAQCBlbnVtIHhlbnN0b3JlX2luaXQgewogCVhTX0xP Q0FMLAogfTsKIAorZXh0ZXJuIGVudW0geGVuc3RvcmVfaW5pdCB4ZW5fc3RvcmVfZG9tYWluX3R5 cGU7CiBleHRlcm4gY29uc3Qgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCAqeGVuYnVzX2Rldl9ncm91 cHNbXTsKIAotZXh0ZXJuIGludCB4ZW5idXNfbWF0Y2goc3RydWN0IGRldmljZSAqX2Rldiwgc3Ry dWN0IGRldmljZV9kcml2ZXIgKl9kcnYpOwotZXh0ZXJuIGludCB4ZW5idXNfZGV2X3Byb2JlKHN0 cnVjdCBkZXZpY2UgKl9kZXYpOwotZXh0ZXJuIGludCB4ZW5idXNfZGV2X3JlbW92ZShzdHJ1Y3Qg ZGV2aWNlICpfZGV2KTsKLWV4dGVybiBpbnQgeGVuYnVzX3JlZ2lzdGVyX2RyaXZlcl9jb21tb24o c3RydWN0IHhlbmJ1c19kcml2ZXIgKmRydiwKLQkJCQkJIHN0cnVjdCB4ZW5fYnVzX3R5cGUgKmJ1 cywKLQkJCQkJIHN0cnVjdCBtb2R1bGUgKm93bmVyLAotCQkJCQkgY29uc3QgY2hhciAqbW9kX25h bWUpOwotZXh0ZXJuIGludCB4ZW5idXNfcHJvYmVfbm9kZShzdHJ1Y3QgeGVuX2J1c190eXBlICpi dXMsCi0JCQkgICAgIGNvbnN0IGNoYXIgKnR5cGUsCi0JCQkgICAgIGNvbnN0IGNoYXIgKm5vZGVu YW1lKTsKLWV4dGVybiBpbnQgeGVuYnVzX3Byb2JlX2RldmljZXMoc3RydWN0IHhlbl9idXNfdHlw ZSAqYnVzKTsKK2ludCB4c19pbml0KHZvaWQpOworaW50IHhiX2luaXRfY29tbXModm9pZCk7Cit2 b2lkIHhiX2RlaW5pdF9jb21tcyh2b2lkKTsKK2ludCB4Yl93cml0ZShjb25zdCB2b2lkICpkYXRh LCB1bnNpZ25lZCBpbnQgbGVuKTsKK2ludCB4Yl9yZWFkKHZvaWQgKmRhdGEsIHVuc2lnbmVkIGlu dCBsZW4pOworaW50IHhiX2RhdGFfdG9fcmVhZCh2b2lkKTsKK2ludCB4Yl93YWl0X2Zvcl9kYXRh X3RvX3JlYWQodm9pZCk7CiAKLWV4dGVybiB2b2lkIHhlbmJ1c19kZXZfY2hhbmdlZChjb25zdCBj aGFyICpub2RlLCBzdHJ1Y3QgeGVuX2J1c190eXBlICpidXMpOworaW50IHhlbmJ1c19tYXRjaChz dHJ1Y3QgZGV2aWNlICpfZGV2LCBzdHJ1Y3QgZGV2aWNlX2RyaXZlciAqX2Rydik7CitpbnQgeGVu YnVzX2Rldl9wcm9iZShzdHJ1Y3QgZGV2aWNlICpfZGV2KTsKK2ludCB4ZW5idXNfZGV2X3JlbW92 ZShzdHJ1Y3QgZGV2aWNlICpfZGV2KTsKK2ludCB4ZW5idXNfcmVnaXN0ZXJfZHJpdmVyX2NvbW1v bihzdHJ1Y3QgeGVuYnVzX2RyaXZlciAqZHJ2LAorCQkJCSAgc3RydWN0IHhlbl9idXNfdHlwZSAq YnVzLAorCQkJCSAgc3RydWN0IG1vZHVsZSAqb3duZXIsCisJCQkJICBjb25zdCBjaGFyICptb2Rf bmFtZSk7CitpbnQgeGVuYnVzX3Byb2JlX25vZGUoc3RydWN0IHhlbl9idXNfdHlwZSAqYnVzLAor CQkgICAgICBjb25zdCBjaGFyICp0eXBlLAorCQkgICAgICBjb25zdCBjaGFyICpub2RlbmFtZSk7 CitpbnQgeGVuYnVzX3Byb2JlX2RldmljZXMoc3RydWN0IHhlbl9idXNfdHlwZSAqYnVzKTsKIAot ZXh0ZXJuIHZvaWQgeGVuYnVzX2Rldl9zaHV0ZG93bihzdHJ1Y3QgZGV2aWNlICpfZGV2KTsKK3Zv aWQgeGVuYnVzX2Rldl9jaGFuZ2VkKGNvbnN0IGNoYXIgKm5vZGUsIHN0cnVjdCB4ZW5fYnVzX3R5 cGUgKmJ1cyk7CiAKLWV4dGVybiBpbnQgeGVuYnVzX2Rldl9zdXNwZW5kKHN0cnVjdCBkZXZpY2Ug KmRldik7Ci1leHRlcm4gaW50IHhlbmJ1c19kZXZfcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldik7 Ci1leHRlcm4gaW50IHhlbmJ1c19kZXZfY2FuY2VsKHN0cnVjdCBkZXZpY2UgKmRldik7Cit2b2lk IHhlbmJ1c19kZXZfc2h1dGRvd24oc3RydWN0IGRldmljZSAqX2Rldik7CiAKLWV4dGVybiB2b2lk IHhlbmJ1c19vdGhlcmVuZF9jaGFuZ2VkKHN0cnVjdCB4ZW5idXNfd2F0Y2ggKndhdGNoLAotCQkJ CSAgICBjb25zdCBjaGFyICoqdmVjLCB1bnNpZ25lZCBpbnQgbGVuLAotCQkJCSAgICBpbnQgaWdu b3JlX29uX3NodXRkb3duKTsKK2ludCB4ZW5idXNfZGV2X3N1c3BlbmQoc3RydWN0IGRldmljZSAq ZGV2KTsKK2ludCB4ZW5idXNfZGV2X3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpOworaW50IHhl bmJ1c19kZXZfY2FuY2VsKHN0cnVjdCBkZXZpY2UgKmRldik7CiAKLWV4dGVybiBpbnQgeGVuYnVz X3JlYWRfb3RoZXJlbmRfZGV0YWlscyhzdHJ1Y3QgeGVuYnVzX2RldmljZSAqeGVuZGV2LAotCQkJ CQljaGFyICppZF9ub2RlLCBjaGFyICpwYXRoX25vZGUpOwordm9pZCB4ZW5idXNfb3RoZXJlbmRf Y2hhbmdlZChzdHJ1Y3QgeGVuYnVzX3dhdGNoICp3YXRjaCwKKwkJCSAgICAgY29uc3QgY2hhciAq KnZlYywgdW5zaWduZWQgaW50IGxlbiwKKwkJCSAgICAgaW50IGlnbm9yZV9vbl9zaHV0ZG93bik7 CisKK2ludCB4ZW5idXNfcmVhZF9vdGhlcmVuZF9kZXRhaWxzKHN0cnVjdCB4ZW5idXNfZGV2aWNl ICp4ZW5kZXYsCisJCQkJIGNoYXIgKmlkX25vZGUsIGNoYXIgKnBhdGhfbm9kZSk7CiAKIHZvaWQg eGVuYnVzX3Jpbmdfb3BzX2luaXQodm9pZCk7CiAKK3ZvaWQgKnhlbmJ1c19kZXZfcmVxdWVzdF9h bmRfcmVwbHkoc3RydWN0IHhzZF9zb2NrbXNnICptc2cpOworCiAjZW5kaWYKZGlmZiAtLWdpdCBh L2RyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfY2xpZW50LmMgYi9kcml2ZXJzL3hlbi94ZW5idXMv eGVuYnVzX2NsaWVudC5jCmluZGV4IDA1NmRhNmUuLjIzZWRmNTMgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMveGVuL3hlbmJ1cy94ZW5idXNfY2xpZW50LmMKKysrIGIvZHJpdmVycy94ZW4veGVuYnVzL3hl bmJ1c19jbGllbnQuYwpAQCAtNDcsNyArNDcsNyBAQAogI2luY2x1ZGUgPHhlbi94ZW4uaD4KICNp bmNsdWRlIDx4ZW4vZmVhdHVyZXMuaD4KIAotI2luY2x1ZGUgInhlbmJ1c19wcm9iZS5oIgorI2lu Y2x1ZGUgInhlbmJ1cy5oIgogCiAjZGVmaW5lIFhFTkJVU19QQUdFUyhfZ3JhbnRzKQkoRElWX1JP VU5EX1VQKF9ncmFudHMsIFhFTl9QRk5fUEVSX1BBR0UpKQogCmRpZmYgLS1naXQgYS9kcml2ZXJz L3hlbi94ZW5idXMveGVuYnVzX2NvbW1zLmMgYi9kcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX2Nv bW1zLmMKaW5kZXggZWNkZWNjZS4uYzIxZWMwMiAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4veGVu YnVzL3hlbmJ1c19jb21tcy5jCisrKyBiL2RyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfY29tbXMu YwpAQCAtNDAsNyArNDAsNyBAQAogI2luY2x1ZGUgPGFzbS94ZW4vaHlwZXJ2aXNvci5oPgogI2lu Y2x1ZGUgPHhlbi9ldmVudHMuaD4KICNpbmNsdWRlIDx4ZW4vcGFnZS5oPgotI2luY2x1ZGUgInhl bmJ1c19jb21tcy5oIgorI2luY2x1ZGUgInhlbmJ1cy5oIgogCiBzdGF0aWMgaW50IHhlbmJ1c19p cnE7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfY29tbXMuaCBiL2Ry aXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfY29tbXMuaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggODY3YTJlNC4uMDAwMDAwMAotLS0gYS9kcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX2Nv bW1zLmgKKysrIC9kZXYvbnVsbApAQCAtMSw1MSArMCwwIEBACi0vKgotICogUHJpdmF0ZSBpbmNs dWRlIGZvciB4ZW5idXMgY29tbXVuaWNhdGlvbnMuCi0gKgotICogQ29weXJpZ2h0IChDKSAyMDA1 IFJ1c3R5IFJ1c3NlbGwsIElCTSBDb3Jwb3JhdGlvbgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBm cmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKLSAqIG1vZGlmeSBp dCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNp b24gMgotICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IG9y LCB3aGVuIGRpc3RyaWJ1dGVkCi0gKiBzZXBhcmF0ZWx5IGZyb20gdGhlIExpbnV4IGtlcm5lbCBv ciBpbmNvcnBvcmF0ZWQgaW50byBvdGhlcgotICogc29mdHdhcmUgcGFja2FnZXMsIHN1YmplY3Qg dG8gdGhlIGZvbGxvd2luZyBsaWNlbnNlOgotICoKLSAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdy YW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhIGNvcHkKLSAq IG9mIHRoaXMgc291cmNlIGZpbGUgKHRoZSAiU29mdHdhcmUiKSwgdG8gZGVhbCBpbiB0aGUgU29m dHdhcmUgd2l0aG91dAotICogcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRp b24gdGhlIHJpZ2h0cyB0byB1c2UsIGNvcHksIG1vZGlmeSwKLSAqIG1lcmdlLCBwdWJsaXNoLCBk aXN0cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJl LAotICogYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzIGZ1cm5p c2hlZCB0byBkbyBzbywgc3ViamVjdCB0bwotICogdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgot ICoKLSAqIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90 aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluCi0gKiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBv cnRpb25zIG9mIHRoZSBTb2Z0d2FyZS4KLSAqCi0gKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQg IkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgotICogSU1Q TElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJD SEFOVEFCSUxJVFksCi0gKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9O SU5GUklOR0VNRU5ULiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUKLSAqIEFVVEhPUlMgT1IgQ09QWVJJ R0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVIKLSAq IExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RI RVJXSVNFLCBBUklTSU5HCi0gKiBGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRI RSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SIE9USEVSIERFQUxJTkdTCi0gKiBJTiBUSEUgU09GVFdB UkUuCi0gKi8KLQotI2lmbmRlZiBfWEVOQlVTX0NPTU1TX0gKLSNkZWZpbmUgX1hFTkJVU19DT01N U19ICi0KLSNpbmNsdWRlIDxsaW51eC9mcy5oPgotCi1pbnQgeHNfaW5pdCh2b2lkKTsKLWludCB4 Yl9pbml0X2NvbW1zKHZvaWQpOwotdm9pZCB4Yl9kZWluaXRfY29tbXModm9pZCk7Ci0KLS8qIExv dyBsZXZlbCByb3V0aW5lcy4gKi8KLWludCB4Yl93cml0ZShjb25zdCB2b2lkICpkYXRhLCB1bnNp Z25lZCBsZW4pOwotaW50IHhiX3JlYWQodm9pZCAqZGF0YSwgdW5zaWduZWQgbGVuKTsKLWludCB4 Yl9kYXRhX3RvX3JlYWQodm9pZCk7Ci1pbnQgeGJfd2FpdF9mb3JfZGF0YV90b19yZWFkKHZvaWQp OwotZXh0ZXJuIHN0cnVjdCB4ZW5zdG9yZV9kb21haW5faW50ZXJmYWNlICp4ZW5fc3RvcmVfaW50 ZXJmYWNlOwotZXh0ZXJuIGludCB4ZW5fc3RvcmVfZXZ0Y2huOwotZXh0ZXJuIGVudW0geGVuc3Rv cmVfaW5pdCB4ZW5fc3RvcmVfZG9tYWluX3R5cGU7Ci0KLWV4dGVybiBjb25zdCBzdHJ1Y3QgZmls ZV9vcGVyYXRpb25zIHhlbl94ZW5idXNfZm9wczsKLQotI2VuZGlmIC8qIF9YRU5CVVNfQ09NTVNf SCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4veGVuYnVzL3hlbmJ1c19kZXZfYmFja2VuZC5j IGIvZHJpdmVycy94ZW4veGVuYnVzL3hlbmJ1c19kZXZfYmFja2VuZC5jCmluZGV4IDRhNDFhYzku LjExMjY3MDEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfZGV2X2JhY2tl bmQuYworKysgYi9kcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX2Rldl9iYWNrZW5kLmMKQEAgLTE2 LDcgKzE2LDcgQEAKICNpbmNsdWRlIDx4ZW4vZXZlbnRzLmg+CiAjaW5jbHVkZSA8YXNtL3hlbi9o eXBlcnZpc29yLmg+CiAKLSNpbmNsdWRlICJ4ZW5idXNfY29tbXMuaCIKKyNpbmNsdWRlICJ4ZW5i dXMuaCIKIAogc3RhdGljIGludCB4ZW5idXNfYmFja2VuZF9vcGVuKHN0cnVjdCBpbm9kZSAqaW5v ZGUsIHN0cnVjdCBmaWxlICpmaWxwKQogewpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4veGVuYnVz L3hlbmJ1c19kZXZfZnJvbnRlbmQuYyBiL2RyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfZGV2X2Zy b250ZW5kLmMKaW5kZXggNzkxMzBiMy4uZTJiYzliMyAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4v eGVuYnVzL3hlbmJ1c19kZXZfZnJvbnRlbmQuYworKysgYi9kcml2ZXJzL3hlbi94ZW5idXMveGVu YnVzX2Rldl9mcm9udGVuZC5jCkBAIC01NywxMiArNTcsMTIgQEAKICNpbmNsdWRlIDxsaW51eC9t aXNjZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogCi0jaW5jbHVkZSAieGVuYnVz X2NvbW1zLmgiCi0KICNpbmNsdWRlIDx4ZW4veGVuYnVzLmg+CiAjaW5jbHVkZSA8eGVuL3hlbi5o PgogI2luY2x1ZGUgPGFzbS94ZW4vaHlwZXJ2aXNvci5oPgogCisjaW5jbHVkZSAieGVuYnVzLmgi CisKIC8qCiAgKiBBbiBlbGVtZW50IG9mIGEgbGlzdCBvZiBvdXRzdGFuZGluZyB0cmFuc2FjdGlv bnMsIGZvciB3aGljaCB3ZSdyZQogICogc3RpbGwgd2FpdGluZyBhIHJlcGx5LgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy94ZW4veGVuYnVzL3hlbmJ1c19wcm9iZS5jIGIvZHJpdmVycy94ZW4veGVuYnVz L3hlbmJ1c19wcm9iZS5jCmluZGV4IDRiZGY2NTQuLjZiYWZmYmIgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMveGVuL3hlbmJ1cy94ZW5idXNfcHJvYmUuYworKysgYi9kcml2ZXJzL3hlbi94ZW5idXMveGVu YnVzX3Byb2JlLmMKQEAgLTYyLDggKzYyLDcgQEAKIAogI2luY2x1ZGUgPHhlbi9odm0uaD4KIAot I2luY2x1ZGUgInhlbmJ1c19jb21tcy5oIgotI2luY2x1ZGUgInhlbmJ1c19wcm9iZS5oIgorI2lu Y2x1ZGUgInhlbmJ1cy5oIgogCiAKIGludCB4ZW5fc3RvcmVfZXZ0Y2huOwpkaWZmIC0tZ2l0IGEv ZHJpdmVycy94ZW4veGVuYnVzL3hlbmJ1c19wcm9iZV9iYWNrZW5kLmMgYi9kcml2ZXJzL3hlbi94 ZW5idXMveGVuYnVzX3Byb2JlX2JhY2tlbmQuYwppbmRleCAzNzkyOWRmLi5mNDZiNGRjIDEwMDY0 NAotLS0gYS9kcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX3Byb2JlX2JhY2tlbmQuYworKysgYi9k cml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX3Byb2JlX2JhY2tlbmQuYwpAQCAtNTMsOCArNTMsNyBA QAogI2luY2x1ZGUgPHhlbi94ZW5idXMuaD4KICNpbmNsdWRlIDx4ZW4vZmVhdHVyZXMuaD4KIAot I2luY2x1ZGUgInhlbmJ1c19jb21tcy5oIgotI2luY2x1ZGUgInhlbmJ1c19wcm9iZS5oIgorI2lu Y2x1ZGUgInhlbmJ1cy5oIgogCiAvKiBiYWNrZW5kLzx0eXBlPi88ZmUtdXVpZD4vPGlkPiA9PiA8 dHlwZT4tPGZlLWRvbWlkPi08aWQ+ICovCiBzdGF0aWMgaW50IGJhY2tlbmRfYnVzX2lkKGNoYXIg YnVzX2lkW1hFTl9CVVNfSURfU0laRV0sIGNvbnN0IGNoYXIgKm5vZGVuYW1lKQpkaWZmIC0tZ2l0 IGEvZHJpdmVycy94ZW4veGVuYnVzL3hlbmJ1c19wcm9iZV9mcm9udGVuZC5jIGIvZHJpdmVycy94 ZW4veGVuYnVzL3hlbmJ1c19wcm9iZV9mcm9udGVuZC5jCmluZGV4IDZkNDBhOTcuLmQ3Yjc3YTYg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfcHJvYmVfZnJvbnRlbmQuYwor KysgYi9kcml2ZXJzL3hlbi94ZW5idXMveGVuYnVzX3Byb2JlX2Zyb250ZW5kLmMKQEAgLTI3LDgg KzI3LDcgQEAKIAogI2luY2x1ZGUgPHhlbi9wbGF0Zm9ybV9wY2kuaD4KIAotI2luY2x1ZGUgInhl bmJ1c19jb21tcy5oIgotI2luY2x1ZGUgInhlbmJ1c19wcm9iZS5oIgorI2luY2x1ZGUgInhlbmJ1 cy5oIgogCiAKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4veGVuYnVzL3hlbmJ1c194cy5jIGIv ZHJpdmVycy94ZW4veGVuYnVzL3hlbmJ1c194cy5jCmluZGV4IDZhZmI5OTMuLjRjNDlkODcgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMveGVuL3hlbmJ1cy94ZW5idXNfeHMuYworKysgYi9kcml2ZXJzL3hl bi94ZW5idXMveGVuYnVzX3hzLmMKQEAgLTQ4LDggKzQ4LDcgQEAKICNpbmNsdWRlIDxhc20veGVu L2h5cGVydmlzb3IuaD4KICNpbmNsdWRlIDx4ZW4veGVuYnVzLmg+CiAjaW5jbHVkZSA8eGVuL3hl bi5oPgotI2luY2x1ZGUgInhlbmJ1c19jb21tcy5oIgotI2luY2x1ZGUgInhlbmJ1c19wcm9iZS5o IgorI2luY2x1ZGUgInhlbmJ1cy5oIgogCiBzdHJ1Y3QgeHNfc3RvcmVkX21zZyB7CiAJc3RydWN0 IGxpc3RfaGVhZCBsaXN0OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4veGVuZnMvc3VwZXIuYyBi L2RyaXZlcnMveGVuL3hlbmZzL3N1cGVyLmMKaW5kZXggODU1OWE3MS4uMzI4YzM5OCAxMDA2NDQK LS0tIGEvZHJpdmVycy94ZW4veGVuZnMvc3VwZXIuYworKysgYi9kcml2ZXJzL3hlbi94ZW5mcy9z dXBlci5jCkBAIC0xNiwxMCArMTYsMTAgQEAKICNpbmNsdWRlIDxsaW51eC9tYWdpYy5oPgogCiAj aW5jbHVkZSA8eGVuL3hlbi5oPgorI2luY2x1ZGUgPHhlbi94ZW5idXMuaD4KIAogI2luY2x1ZGUg InhlbmZzLmgiCiAjaW5jbHVkZSAiLi4vcHJpdmNtZC5oIgotI2luY2x1ZGUgIi4uL3hlbmJ1cy94 ZW5idXNfY29tbXMuaCIKIAogI2luY2x1ZGUgPGFzbS94ZW4vaHlwZXJ2aXNvci5oPgogCmRpZmYg LS1naXQgYS9kcml2ZXJzL3hlbi94ZW5mcy94ZW5zdG9yZWQuYyBiL2RyaXZlcnMveGVuL3hlbmZz L3hlbnN0b3JlZC5jCmluZGV4IGZlZjIwZGIuLjgyZmQyYTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv eGVuL3hlbmZzL3hlbnN0b3JlZC5jCisrKyBiL2RyaXZlcnMveGVuL3hlbmZzL3hlbnN0b3JlZC5j CkBAIC00LDkgKzQsOSBAQAogI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CiAKICNpbmNsdWRlIDx4ZW4v cGFnZS5oPgorI2luY2x1ZGUgPHhlbi94ZW5idXMuaD4KIAogI2luY2x1ZGUgInhlbmZzLmgiCi0j aW5jbHVkZSAiLi4veGVuYnVzL3hlbmJ1c19jb21tcy5oIgogCiBzdGF0aWMgc3NpemVfdCB4c2Rf cmVhZChzdHJ1Y3QgZmlsZSAqZmlsZSwgY2hhciBfX3VzZXIgKmJ1ZiwKIAkJCSAgICBzaXplX3Qg c2l6ZSwgbG9mZl90ICpvZmYpCmRpZmYgLS1naXQgYS9pbmNsdWRlL3hlbi94ZW5idXMuaCBiL2lu Y2x1ZGUveGVuL3hlbmJ1cy5oCmluZGV4IDI3MWJhNjIuLjk4ZjczYTIgMTAwNjQ0Ci0tLSBhL2lu Y2x1ZGUveGVuL3hlbmJ1cy5oCisrKyBiL2luY2x1ZGUveGVuL3hlbmJ1cy5oCkBAIC0zOCw2ICsz OCw3IEBACiAjaW5jbHVkZSA8bGludXgvbm90aWZpZXIuaD4KICNpbmNsdWRlIDxsaW51eC9tdXRl eC5oPgogI2luY2x1ZGUgPGxpbnV4L2V4cG9ydC5oPgorI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CiAj aW5jbHVkZSA8bGludXgvY29tcGxldGlvbi5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNp bmNsdWRlIDxsaW51eC9zbGFiLmg+CkBAIC0xNzUsMTYgKzE3Niw5IEBAIHZvaWQgeHNfc3VzcGVu ZCh2b2lkKTsKIHZvaWQgeHNfcmVzdW1lKHZvaWQpOwogdm9pZCB4c19zdXNwZW5kX2NhbmNlbCh2 b2lkKTsKIAotLyogVXNlZCBieSB4ZW5idXNfZGV2IHRvIGJvcnJvdyBrZXJuZWwncyBzdG9yZSBj b25uZWN0aW9uLiAqLwotdm9pZCAqeGVuYnVzX2Rldl9yZXF1ZXN0X2FuZF9yZXBseShzdHJ1Y3Qg eHNkX3NvY2ttc2cgKm1zZyk7Ci0KIHN0cnVjdCB3b3JrX3N0cnVjdDsKIAotLyogUHJlcGFyZSBm b3IgZG9tYWluIHN1c3BlbmQ6IHRoZW4gcmVzdW1lIG9yIGNhbmNlbCB0aGUgc3VzcGVuZC4gKi8K LXZvaWQgeGVuYnVzX3N1c3BlbmQodm9pZCk7Ci12b2lkIHhlbmJ1c19yZXN1bWUodm9pZCk7CiB2 b2lkIHhlbmJ1c19wcm9iZShzdHJ1Y3Qgd29ya19zdHJ1Y3QgKik7Ci12b2lkIHhlbmJ1c19zdXNw ZW5kX2NhbmNlbCh2b2lkKTsKIAogI2RlZmluZSBYRU5CVVNfSVNfRVJSX1JFQUQoc3RyKSAoewkJ CVwKIAlpZiAoIUlTX0VSUihzdHIpICYmIHN0cmxlbihzdHIpID09IDApIHsJCVwKQEAgLTIzNSw0 ICsyMjksOCBAQCBjb25zdCBjaGFyICp4ZW5idXNfc3Ryc3RhdGUoZW51bSB4ZW5idXNfc3RhdGUg c3RhdGUpOwogaW50IHhlbmJ1c19kZXZfaXNfb25saW5lKHN0cnVjdCB4ZW5idXNfZGV2aWNlICpk ZXYpOwogaW50IHhlbmJ1c19mcm9udGVuZF9jbG9zZWQoc3RydWN0IHhlbmJ1c19kZXZpY2UgKmRl dik7CiAKK2V4dGVybiBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIHhlbl94ZW5idXNfZm9w czsKK2V4dGVybiBzdHJ1Y3QgeGVuc3RvcmVfZG9tYWluX2ludGVyZmFjZSAqeGVuX3N0b3JlX2lu dGVyZmFjZTsKK2V4dGVybiBpbnQgeGVuX3N0b3JlX2V2dGNobjsKKwogI2VuZGlmIC8qIF9YRU5f WEVOQlVTX0ggKi8KLS0gCjIuMTAuMgoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhl bi5vcmcKaHR0cHM6Ly9saXN0cy54ZW4ub3JnL3hlbi1kZXZlbAo=