From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.5 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,USER_AGENT_MUTT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0A20DC43381 for ; Thu, 21 Mar 2019 22:13:43 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C3CD1218A5 for ; Thu, 21 Mar 2019 22:13:42 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727194AbfCUWNl (ORCPT ); Thu, 21 Mar 2019 18:13:41 -0400 Received: from mga05.intel.com ([192.55.52.43]:21560 "EHLO mga05.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726374AbfCUWNl (ORCPT ); Thu, 21 Mar 2019 18:13:41 -0400 X-Amp-Result: UNKNOWN X-Amp-Original-Verdict: FILE UNKNOWN X-Amp-File-Uploaded: False Received: from orsmga005.jf.intel.com ([10.7.209.41]) by fmsmga105.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 21 Mar 2019 15:13:40 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.60,254,1549958400"; d="scan'208";a="309277290" Received: from agluck-desk.sc.intel.com (HELO agluck-desk) ([10.3.52.160]) by orsmga005.jf.intel.com with ESMTP; 21 Mar 2019 15:13:39 -0700 Date: Thu, 21 Mar 2019 15:13:39 -0700 From: "Luck, Tony" To: Arnd Bergmann Cc: Borislav Petkov , Mauro Carvalho Chehab , James Morse , Qiuxu Zhuo , linux-edac@vger.kernel.org, Linux Kernel Mailing List Subject: [PATCH] EDAC, {skx|i10nm}_edac: Fix randconfig build error Message-ID: <20190321221339.GA32323@agluck-desk> References: <20190314110413.GA32277@zn.tnic> <20190314215952.GA303@agluck-desk> <20190315094341.GA12523@zn.tnic> <20190315155718.GA17775@agluck-desk> <20190315173720.GC12523@zn.tnic> <20190315174956.GA20831@agluck-desk> <20190315180206.GD12523@zn.tnic> <20190315181108.GA21111@agluck-desk> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Qiuxu Zhuo Kbuild failed on the kernel configurations below: CONFIG_ACPI_NFIT=y CONFIG_EDAC_DEBUG=y CONFIG_EDAC_SKX=m CONFIG_EDAC_I10NM=y or CONFIG_ACPI_NFIT=y CONFIG_EDAC_DEBUG=y CONFIG_EDAC_SKX=y CONFIG_EDAC_I10NM=m Failed log: ... CC [M] drivers/edac/skx_common.o ... .../skx_common.o:.../skx_common.c:672: undefined reference to `__this_module' That is because if one of the two drivers {skx|i10nm}_edac is built-in and the other one is built as a module, the shared file skx_common.c is built to an object in module style by kbuild. Therefore, when linking for vmlinux, the '__this_module' symbol used in debugfs isn't defined. Fix it by moving all debugfs code from skx_common.c to {skx|i10nm}_base.c respectively. Thus, skx_common.c is a module independent file which doesn't refer to '__this_module' symbol anymore. Fixes: d4dc89d069aa ("EDAC, i10nm: Add a driver for Intel 10nm server processors") Reported-by: Arnd Bergmann Signed-off-by: Qiuxu Zhuo Signed-off-by: Tony Luck --- Arnd: I couldn't get your Kconfig trick (to disallow mixing module with builtin) working. Qiuxu made this better cleanup of the skx_common.c file that moves out all of the debugfs bits, and adds a comment to the top of the file warning future developers of the mixed mode issue. drivers/edac/i10nm_base.c | 52 +++++++++++++++++++++++++++++++++++++-- drivers/edac/skx_base.c | 50 ++++++++++++++++++++++++++++++++++++- drivers/edac/skx_common.c | 51 +++++--------------------------------- drivers/edac/skx_common.h | 8 ------ 4 files changed, 105 insertions(+), 56 deletions(-) diff --git a/drivers/edac/i10nm_base.c b/drivers/edac/i10nm_base.c index c334fb7c63df..6f06aec4877c 100644 --- a/drivers/edac/i10nm_base.c +++ b/drivers/edac/i10nm_base.c @@ -181,6 +181,54 @@ static struct notifier_block i10nm_mce_dec = { .priority = MCE_PRIO_EDAC, }; +#ifdef CONFIG_EDAC_DEBUG +/* + * Debug feature. + * Exercise the address decode logic by writing an address to + * /sys/kernel/debug/edac/i10nm_test/addr. + */ +static struct dentry *i10nm_test; + +static int debugfs_u64_set(void *data, u64 val) +{ + struct mce m; + + pr_warn_once("Fake error to 0x%llx injected via debugfs\n", val); + + memset(&m, 0, sizeof(m)); + /* ADDRV + MemRd + Unknown channel */ + m.status = MCI_STATUS_ADDRV + 0x90; + /* One corrected error */ + m.status |= BIT_ULL(MCI_STATUS_CEC_SHIFT); + m.addr = val; + skx_mce_check_error(NULL, 0, &m); + + return 0; +} +DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n"); + +static void setup_i10nm_debug(void) +{ + i10nm_test = edac_debugfs_create_dir("i10nm_test"); + if (!i10nm_test) + return; + + if (!edac_debugfs_create_file("addr", 0200, i10nm_test, + NULL, &fops_u64_wo)) { + debugfs_remove(i10nm_test); + i10nm_test = NULL; + } +} + +static void teardown_i10nm_debug(void) +{ + debugfs_remove_recursive(i10nm_test); +} +#else +static inline void setup_i10nm_debug(void) {} +static inline void teardown_i10nm_debug(void) {} +#endif /*CONFIG_EDAC_DEBUG*/ + static int __init i10nm_init(void) { u8 mc = 0, src_id = 0, node_id = 0; @@ -249,7 +297,7 @@ static int __init i10nm_init(void) opstate_init(); mce_register_decode_chain(&i10nm_mce_dec); - setup_skx_debug("i10nm_test"); + setup_i10nm_debug(); i10nm_printk(KERN_INFO, "%s\n", I10NM_REVISION); @@ -262,7 +310,7 @@ static int __init i10nm_init(void) static void __exit i10nm_exit(void) { edac_dbg(2, "\n"); - teardown_skx_debug(); + teardown_i10nm_debug(); mce_unregister_decode_chain(&i10nm_mce_dec); skx_adxl_put(); skx_remove(); diff --git a/drivers/edac/skx_base.c b/drivers/edac/skx_base.c index adae4c848ca1..a5c8fa3a249a 100644 --- a/drivers/edac/skx_base.c +++ b/drivers/edac/skx_base.c @@ -540,6 +540,54 @@ static struct notifier_block skx_mce_dec = { .priority = MCE_PRIO_EDAC, }; +#ifdef CONFIG_EDAC_DEBUG +/* + * Debug feature. + * Exercise the address decode logic by writing an address to + * /sys/kernel/debug/edac/skx_test/addr. + */ +static struct dentry *skx_test; + +static int debugfs_u64_set(void *data, u64 val) +{ + struct mce m; + + pr_warn_once("Fake error to 0x%llx injected via debugfs\n", val); + + memset(&m, 0, sizeof(m)); + /* ADDRV + MemRd + Unknown channel */ + m.status = MCI_STATUS_ADDRV + 0x90; + /* One corrected error */ + m.status |= BIT_ULL(MCI_STATUS_CEC_SHIFT); + m.addr = val; + skx_mce_check_error(NULL, 0, &m); + + return 0; +} +DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n"); + +static void setup_skx_debug(void) +{ + skx_test = edac_debugfs_create_dir("skx_test"); + if (!skx_test) + return; + + if (!edac_debugfs_create_file("addr", 0200, skx_test, + NULL, &fops_u64_wo)) { + debugfs_remove(skx_test); + skx_test = NULL; + } +} + +static void teardown_skx_debug(void) +{ + debugfs_remove_recursive(skx_test); +} +#else +static inline void setup_skx_debug(void) {} +static inline void teardown_skx_debug(void) {} +#endif /*CONFIG_EDAC_DEBUG*/ + /* * skx_init: * make sure we are running on the correct cpu model @@ -619,7 +667,7 @@ static int __init skx_init(void) /* Ensure that the OPSTATE is set correctly for POLL or NMI */ opstate_init(); - setup_skx_debug("skx_test"); + setup_skx_debug(); mce_register_decode_chain(&skx_mce_dec); diff --git a/drivers/edac/skx_common.c b/drivers/edac/skx_common.c index 0e96e7b5b0a7..6b11d6f4ae07 100644 --- a/drivers/edac/skx_common.c +++ b/drivers/edac/skx_common.c @@ -3,6 +3,12 @@ * Common codes for both the skx_edac driver and Intel 10nm server EDAC driver. * Originally split out from the skx_edac driver. * + * This file is used for both {skx|i10nm}_edac drivers. If one of them is + * built-in and the other one is built as a module, this file is built to + * an object in module style by kbuid. Therefore, to avoid linking errors + * from undefined module symbols, please don't add any functionality which + * would involve modules (e.g., debugfs code) to this file. + * * Copyright (c) 2018, Intel Corporation. */ @@ -644,48 +650,3 @@ void skx_remove(void) kfree(d); } } - -#ifdef CONFIG_EDAC_DEBUG -/* - * Debug feature. - * Exercise the address decode logic by writing an address to - * /sys/kernel/debug/edac/dirname/addr. - */ -static struct dentry *skx_test; - -static int debugfs_u64_set(void *data, u64 val) -{ - struct mce m; - - pr_warn_once("Fake error to 0x%llx injected via debugfs\n", val); - - memset(&m, 0, sizeof(m)); - /* ADDRV + MemRd + Unknown channel */ - m.status = MCI_STATUS_ADDRV + 0x90; - /* One corrected error */ - m.status |= BIT_ULL(MCI_STATUS_CEC_SHIFT); - m.addr = val; - skx_mce_check_error(NULL, 0, &m); - - return 0; -} -DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n"); - -void setup_skx_debug(const char *dirname) -{ - skx_test = edac_debugfs_create_dir(dirname); - if (!skx_test) - return; - - if (!edac_debugfs_create_file("addr", 0200, skx_test, - NULL, &fops_u64_wo)) { - debugfs_remove(skx_test); - skx_test = NULL; - } -} - -void teardown_skx_debug(void) -{ - debugfs_remove_recursive(skx_test); -} -#endif /*CONFIG_EDAC_DEBUG*/ diff --git a/drivers/edac/skx_common.h b/drivers/edac/skx_common.h index d25374e34d4f..d18fa98669af 100644 --- a/drivers/edac/skx_common.h +++ b/drivers/edac/skx_common.h @@ -141,12 +141,4 @@ int skx_mce_check_error(struct notifier_block *nb, unsigned long val, void skx_remove(void); -#ifdef CONFIG_EDAC_DEBUG -void setup_skx_debug(const char *dirname); -void teardown_skx_debug(void); -#else -static inline void setup_skx_debug(const char *dirname) {} -static inline void teardown_skx_debug(void) {} -#endif /*CONFIG_EDAC_DEBUG*/ - #endif /* _SKX_COMM_EDAC_H */ -- 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: EDAC, {skx|i10nm}_edac: Fix randconfig build error From: "Luck, Tony" Message-Id: <20190321221339.GA32323@agluck-desk> Date: Thu, 21 Mar 2019 15:13:39 -0700 To: Arnd Bergmann Cc: Borislav Petkov , Mauro Carvalho Chehab , James Morse , Qiuxu Zhuo , linux-edac@vger.kernel.org, Linux Kernel Mailing List List-ID: RnJvbTogUWl1eHUgWmh1byA8cWl1eHUuemh1b0BpbnRlbC5jb20+CgpLYnVpbGQgZmFpbGVkIG9u IHRoZSBrZXJuZWwgY29uZmlndXJhdGlvbnMgYmVsb3c6CgogIENPTkZJR19BQ1BJX05GSVQ9eQog IENPTkZJR19FREFDX0RFQlVHPXkKICBDT05GSUdfRURBQ19TS1g9bQogIENPTkZJR19FREFDX0kx ME5NPXkKICAgICAgICAgb3IKICBDT05GSUdfQUNQSV9ORklUPXkKICBDT05GSUdfRURBQ19ERUJV Rz15CiAgQ09ORklHX0VEQUNfU0tYPXkKICBDT05GSUdfRURBQ19JMTBOTT1tCgpGYWlsZWQgbG9n OgogIC4uLgogIENDIFtNXSAgZHJpdmVycy9lZGFjL3NreF9jb21tb24ubwogIC4uLgogIC4uLi9z a3hfY29tbW9uLm86Li4uL3NreF9jb21tb24uYzo2NzI6IHVuZGVmaW5lZCByZWZlcmVuY2UgdG8g YF9fdGhpc19tb2R1bGUnCgpUaGF0IGlzIGJlY2F1c2UgaWYgb25lIG9mIHRoZSB0d28gZHJpdmVy cyB7c2t4fGkxMG5tfV9lZGFjIGlzIGJ1aWx0LWluCmFuZCB0aGUgb3RoZXIgb25lIGlzIGJ1aWx0 IGFzIGEgbW9kdWxlLCB0aGUgc2hhcmVkIGZpbGUgc2t4X2NvbW1vbi5jIGlzCmJ1aWx0IHRvIGFu IG9iamVjdCBpbiBtb2R1bGUgc3R5bGUgYnkga2J1aWxkLiBUaGVyZWZvcmUsIHdoZW4gbGlua2lu ZyBmb3IKdm1saW51eCwgdGhlICdfX3RoaXNfbW9kdWxlJyBzeW1ib2wgdXNlZCBpbiBkZWJ1Z2Zz IGlzbid0IGRlZmluZWQuCgpGaXggaXQgYnkgbW92aW5nIGFsbCBkZWJ1Z2ZzIGNvZGUgZnJvbSBz a3hfY29tbW9uLmMgdG8ge3NreHxpMTBubX1fYmFzZS5jCnJlc3BlY3RpdmVseS4gVGh1cywgc2t4 X2NvbW1vbi5jIGlzIGEgbW9kdWxlIGluZGVwZW5kZW50IGZpbGUgd2hpY2ggZG9lc24ndApyZWZl ciB0byAnX190aGlzX21vZHVsZScgc3ltYm9sIGFueW1vcmUuCgpGaXhlczogZDRkYzg5ZDA2OWFh ICgiRURBQywgaTEwbm06IEFkZCBhIGRyaXZlciBmb3IgSW50ZWwgMTBubSBzZXJ2ZXIgcHJvY2Vz c29ycyIpClJlcG9ydGVkLWJ5OiBBcm5kIEJlcmdtYW5uIDxhcm5kQGFybmRiLmRlPgpTaWduZWQt b2ZmLWJ5OiBRaXV4dSBaaHVvIDxxaXV4dS56aHVvQGludGVsLmNvbT4KU2lnbmVkLW9mZi1ieTog VG9ueSBMdWNrIDx0b255Lmx1Y2tAaW50ZWwuY29tPgotLS0KCkFybmQ6IEkgY291bGRuJ3QgZ2V0 IHlvdXIgS2NvbmZpZyB0cmljayAodG8gZGlzYWxsb3cgbWl4aW5nIG1vZHVsZSB3aXRoCmJ1aWx0 aW4pIHdvcmtpbmcuICBRaXV4dSBtYWRlIHRoaXMgYmV0dGVyIGNsZWFudXAgb2YgdGhlIHNreF9j b21tb24uYyBmaWxlIHRoYXQKbW92ZXMgb3V0IGFsbCBvZiB0aGUgZGVidWdmcyBiaXRzLCBhbmQg YWRkcyBhIGNvbW1lbnQgdG8gdGhlIHRvcCBvZiB0aGUKZmlsZSB3YXJuaW5nIGZ1dHVyZSBkZXZl bG9wZXJzIG9mIHRoZSBtaXhlZCBtb2RlIGlzc3VlLgoKIGRyaXZlcnMvZWRhYy9pMTBubV9iYXNl LmMgfCA1MiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0KIGRyaXZlcnMv ZWRhYy9za3hfYmFzZS5jICAgfCA1MCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KystCiBkcml2ZXJzL2VkYWMvc2t4X2NvbW1vbi5jIHwgNTEgKysrKystLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvZWRhYy9za3hfY29tbW9uLmggfCAgOCAtLS0tLS0K IDQgZmlsZXMgY2hhbmdlZCwgMTA1IGluc2VydGlvbnMoKyksIDU2IGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9pMTBubV9iYXNlLmMgYi9kcml2ZXJzL2VkYWMvaTEwbm1f YmFzZS5jCmluZGV4IGMzMzRmYjdjNjNkZi4uNmYwNmFlYzQ4NzdjIDEwMDY0NAotLS0gYS9kcml2 ZXJzL2VkYWMvaTEwbm1fYmFzZS5jCisrKyBiL2RyaXZlcnMvZWRhYy9pMTBubV9iYXNlLmMKQEAg LTE4MSw2ICsxODEsNTQgQEAgc3RhdGljIHN0cnVjdCBub3RpZmllcl9ibG9jayBpMTBubV9tY2Vf ZGVjID0gewogCS5wcmlvcml0eQk9IE1DRV9QUklPX0VEQUMsCiB9OwogCisjaWZkZWYgQ09ORklH X0VEQUNfREVCVUcKKy8qCisgKiBEZWJ1ZyBmZWF0dXJlLgorICogRXhlcmNpc2UgdGhlIGFkZHJl c3MgZGVjb2RlIGxvZ2ljIGJ5IHdyaXRpbmcgYW4gYWRkcmVzcyB0bworICogL3N5cy9rZXJuZWwv ZGVidWcvZWRhYy9pMTBubV90ZXN0L2FkZHIuCisgKi8KK3N0YXRpYyBzdHJ1Y3QgZGVudHJ5ICpp MTBubV90ZXN0OworCitzdGF0aWMgaW50IGRlYnVnZnNfdTY0X3NldCh2b2lkICpkYXRhLCB1NjQg dmFsKQoreworCXN0cnVjdCBtY2UgbTsKKworCXByX3dhcm5fb25jZSgiRmFrZSBlcnJvciB0byAw eCVsbHggaW5qZWN0ZWQgdmlhIGRlYnVnZnNcbiIsIHZhbCk7CisKKwltZW1zZXQoJm0sIDAsIHNp emVvZihtKSk7CisJLyogQUREUlYgKyBNZW1SZCArIFVua25vd24gY2hhbm5lbCAqLworCW0uc3Rh dHVzID0gTUNJX1NUQVRVU19BRERSViArIDB4OTA7CisJLyogT25lIGNvcnJlY3RlZCBlcnJvciAq LworCW0uc3RhdHVzIHw9IEJJVF9VTEwoTUNJX1NUQVRVU19DRUNfU0hJRlQpOworCW0uYWRkciA9 IHZhbDsKKwlza3hfbWNlX2NoZWNrX2Vycm9yKE5VTEwsIDAsICZtKTsKKworCXJldHVybiAwOwor fQorREVGSU5FX1NJTVBMRV9BVFRSSUJVVEUoZm9wc191NjRfd28sIE5VTEwsIGRlYnVnZnNfdTY0 X3NldCwgIiVsbHVcbiIpOworCitzdGF0aWMgdm9pZCBzZXR1cF9pMTBubV9kZWJ1Zyh2b2lkKQor eworCWkxMG5tX3Rlc3QgPSBlZGFjX2RlYnVnZnNfY3JlYXRlX2RpcigiaTEwbm1fdGVzdCIpOwor CWlmICghaTEwbm1fdGVzdCkKKwkJcmV0dXJuOworCisJaWYgKCFlZGFjX2RlYnVnZnNfY3JlYXRl X2ZpbGUoImFkZHIiLCAwMjAwLCBpMTBubV90ZXN0LAorCQkJCSAgICAgIE5VTEwsICZmb3BzX3U2 NF93bykpIHsKKwkJZGVidWdmc19yZW1vdmUoaTEwbm1fdGVzdCk7CisJCWkxMG5tX3Rlc3QgPSBO VUxMOworCX0KK30KKworc3RhdGljIHZvaWQgdGVhcmRvd25faTEwbm1fZGVidWcodm9pZCkKK3sK KwlkZWJ1Z2ZzX3JlbW92ZV9yZWN1cnNpdmUoaTEwbm1fdGVzdCk7Cit9CisjZWxzZQorc3RhdGlj IGlubGluZSB2b2lkIHNldHVwX2kxMG5tX2RlYnVnKHZvaWQpIHt9CitzdGF0aWMgaW5saW5lIHZv aWQgdGVhcmRvd25faTEwbm1fZGVidWcodm9pZCkge30KKyNlbmRpZiAvKkNPTkZJR19FREFDX0RF QlVHKi8KKwogc3RhdGljIGludCBfX2luaXQgaTEwbm1faW5pdCh2b2lkKQogewogCXU4IG1jID0g MCwgc3JjX2lkID0gMCwgbm9kZV9pZCA9IDA7CkBAIC0yNDksNyArMjk3LDcgQEAgc3RhdGljIGlu dCBfX2luaXQgaTEwbm1faW5pdCh2b2lkKQogCiAJb3BzdGF0ZV9pbml0KCk7CiAJbWNlX3JlZ2lz dGVyX2RlY29kZV9jaGFpbigmaTEwbm1fbWNlX2RlYyk7Ci0Jc2V0dXBfc2t4X2RlYnVnKCJpMTBu bV90ZXN0Iik7CisJc2V0dXBfaTEwbm1fZGVidWcoKTsKIAogCWkxMG5tX3ByaW50ayhLRVJOX0lO Rk8sICIlc1xuIiwgSTEwTk1fUkVWSVNJT04pOwogCkBAIC0yNjIsNyArMzEwLDcgQEAgc3RhdGlj IGludCBfX2luaXQgaTEwbm1faW5pdCh2b2lkKQogc3RhdGljIHZvaWQgX19leGl0IGkxMG5tX2V4 aXQodm9pZCkKIHsKIAllZGFjX2RiZygyLCAiXG4iKTsKLQl0ZWFyZG93bl9za3hfZGVidWcoKTsK Kwl0ZWFyZG93bl9pMTBubV9kZWJ1ZygpOwogCW1jZV91bnJlZ2lzdGVyX2RlY29kZV9jaGFpbigm aTEwbm1fbWNlX2RlYyk7CiAJc2t4X2FkeGxfcHV0KCk7CiAJc2t4X3JlbW92ZSgpOwpkaWZmIC0t Z2l0IGEvZHJpdmVycy9lZGFjL3NreF9iYXNlLmMgYi9kcml2ZXJzL2VkYWMvc2t4X2Jhc2UuYwpp bmRleCBhZGFlNGM4NDhjYTEuLmE1YzhmYTNhMjQ5YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9lZGFj L3NreF9iYXNlLmMKKysrIGIvZHJpdmVycy9lZGFjL3NreF9iYXNlLmMKQEAgLTU0MCw2ICs1NDAs NTQgQEAgc3RhdGljIHN0cnVjdCBub3RpZmllcl9ibG9jayBza3hfbWNlX2RlYyA9IHsKIAkucHJp b3JpdHkJPSBNQ0VfUFJJT19FREFDLAogfTsKIAorI2lmZGVmIENPTkZJR19FREFDX0RFQlVHCisv KgorICogRGVidWcgZmVhdHVyZS4KKyAqIEV4ZXJjaXNlIHRoZSBhZGRyZXNzIGRlY29kZSBsb2dp YyBieSB3cml0aW5nIGFuIGFkZHJlc3MgdG8KKyAqIC9zeXMva2VybmVsL2RlYnVnL2VkYWMvc2t4 X3Rlc3QvYWRkci4KKyAqLworc3RhdGljIHN0cnVjdCBkZW50cnkgKnNreF90ZXN0OworCitzdGF0 aWMgaW50IGRlYnVnZnNfdTY0X3NldCh2b2lkICpkYXRhLCB1NjQgdmFsKQoreworCXN0cnVjdCBt Y2UgbTsKKworCXByX3dhcm5fb25jZSgiRmFrZSBlcnJvciB0byAweCVsbHggaW5qZWN0ZWQgdmlh IGRlYnVnZnNcbiIsIHZhbCk7CisKKwltZW1zZXQoJm0sIDAsIHNpemVvZihtKSk7CisJLyogQURE UlYgKyBNZW1SZCArIFVua25vd24gY2hhbm5lbCAqLworCW0uc3RhdHVzID0gTUNJX1NUQVRVU19B RERSViArIDB4OTA7CisJLyogT25lIGNvcnJlY3RlZCBlcnJvciAqLworCW0uc3RhdHVzIHw9IEJJ VF9VTEwoTUNJX1NUQVRVU19DRUNfU0hJRlQpOworCW0uYWRkciA9IHZhbDsKKwlza3hfbWNlX2No ZWNrX2Vycm9yKE5VTEwsIDAsICZtKTsKKworCXJldHVybiAwOworfQorREVGSU5FX1NJTVBMRV9B VFRSSUJVVEUoZm9wc191NjRfd28sIE5VTEwsIGRlYnVnZnNfdTY0X3NldCwgIiVsbHVcbiIpOwor CitzdGF0aWMgdm9pZCBzZXR1cF9za3hfZGVidWcodm9pZCkKK3sKKwlza3hfdGVzdCA9IGVkYWNf ZGVidWdmc19jcmVhdGVfZGlyKCJza3hfdGVzdCIpOworCWlmICghc2t4X3Rlc3QpCisJCXJldHVy bjsKKworCWlmICghZWRhY19kZWJ1Z2ZzX2NyZWF0ZV9maWxlKCJhZGRyIiwgMDIwMCwgc2t4X3Rl c3QsCisJCQkJICAgICAgTlVMTCwgJmZvcHNfdTY0X3dvKSkgeworCQlkZWJ1Z2ZzX3JlbW92ZShz a3hfdGVzdCk7CisJCXNreF90ZXN0ID0gTlVMTDsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIHRlYXJk b3duX3NreF9kZWJ1Zyh2b2lkKQoreworCWRlYnVnZnNfcmVtb3ZlX3JlY3Vyc2l2ZShza3hfdGVz dCk7Cit9CisjZWxzZQorc3RhdGljIGlubGluZSB2b2lkIHNldHVwX3NreF9kZWJ1Zyh2b2lkKSB7 fQorc3RhdGljIGlubGluZSB2b2lkIHRlYXJkb3duX3NreF9kZWJ1Zyh2b2lkKSB7fQorI2VuZGlm IC8qQ09ORklHX0VEQUNfREVCVUcqLworCiAvKgogICogc2t4X2luaXQ6CiAgKgltYWtlIHN1cmUg d2UgYXJlIHJ1bm5pbmcgb24gdGhlIGNvcnJlY3QgY3B1IG1vZGVsCkBAIC02MTksNyArNjY3LDcg QEAgc3RhdGljIGludCBfX2luaXQgc2t4X2luaXQodm9pZCkKIAkvKiBFbnN1cmUgdGhhdCB0aGUg T1BTVEFURSBpcyBzZXQgY29ycmVjdGx5IGZvciBQT0xMIG9yIE5NSSAqLwogCW9wc3RhdGVfaW5p dCgpOwogCi0Jc2V0dXBfc2t4X2RlYnVnKCJza3hfdGVzdCIpOworCXNldHVwX3NreF9kZWJ1Zygp OwogCiAJbWNlX3JlZ2lzdGVyX2RlY29kZV9jaGFpbigmc2t4X21jZV9kZWMpOwogCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2VkYWMvc2t4X2NvbW1vbi5jIGIvZHJpdmVycy9lZGFjL3NreF9jb21tb24u YwppbmRleCAwZTk2ZTdiNWIwYTcuLjZiMTFkNmY0YWUwNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9l ZGFjL3NreF9jb21tb24uYworKysgYi9kcml2ZXJzL2VkYWMvc2t4X2NvbW1vbi5jCkBAIC0zLDYg KzMsMTIgQEAKICAqIENvbW1vbiBjb2RlcyBmb3IgYm90aCB0aGUgc2t4X2VkYWMgZHJpdmVyIGFu ZCBJbnRlbCAxMG5tIHNlcnZlciBFREFDIGRyaXZlci4KICAqIE9yaWdpbmFsbHkgc3BsaXQgb3V0 IGZyb20gdGhlIHNreF9lZGFjIGRyaXZlci4KICAqCisgKiBUaGlzIGZpbGUgaXMgdXNlZCBmb3Ig Ym90aCB7c2t4fGkxMG5tfV9lZGFjIGRyaXZlcnMuIElmIG9uZSBvZiB0aGVtIGlzCisgKiBidWls dC1pbiBhbmQgdGhlIG90aGVyIG9uZSBpcyBidWlsdCBhcyBhIG1vZHVsZSwgdGhpcyBmaWxlIGlz IGJ1aWx0IHRvCisgKiBhbiBvYmplY3QgaW4gbW9kdWxlIHN0eWxlIGJ5IGtidWlkLiBUaGVyZWZv cmUsIHRvIGF2b2lkIGxpbmtpbmcgZXJyb3JzCisgKiBmcm9tIHVuZGVmaW5lZCBtb2R1bGUgc3lt Ym9scywgcGxlYXNlIGRvbid0IGFkZCBhbnkgZnVuY3Rpb25hbGl0eSB3aGljaAorICogd291bGQg aW52b2x2ZSBtb2R1bGVzIChlLmcuLCBkZWJ1Z2ZzIGNvZGUpIHRvIHRoaXMgZmlsZS4KKyAqCiAg KiBDb3B5cmlnaHQgKGMpIDIwMTgsIEludGVsIENvcnBvcmF0aW9uLgogICovCiAKQEAgLTY0NCw0 OCArNjUwLDMgQEAgdm9pZCBza3hfcmVtb3ZlKHZvaWQpCiAJCWtmcmVlKGQpOwogCX0KIH0KLQot I2lmZGVmIENPTkZJR19FREFDX0RFQlVHCi0vKgotICogRGVidWcgZmVhdHVyZS4KLSAqIEV4ZXJj aXNlIHRoZSBhZGRyZXNzIGRlY29kZSBsb2dpYyBieSB3cml0aW5nIGFuIGFkZHJlc3MgdG8KLSAq IC9zeXMva2VybmVsL2RlYnVnL2VkYWMvZGlybmFtZS9hZGRyLgotICovCi1zdGF0aWMgc3RydWN0 IGRlbnRyeSAqc2t4X3Rlc3Q7Ci0KLXN0YXRpYyBpbnQgZGVidWdmc191NjRfc2V0KHZvaWQgKmRh dGEsIHU2NCB2YWwpCi17Ci0Jc3RydWN0IG1jZSBtOwotCi0JcHJfd2Fybl9vbmNlKCJGYWtlIGVy cm9yIHRvIDB4JWxseCBpbmplY3RlZCB2aWEgZGVidWdmc1xuIiwgdmFsKTsKLQotCW1lbXNldCgm bSwgMCwgc2l6ZW9mKG0pKTsKLQkvKiBBRERSViArIE1lbVJkICsgVW5rbm93biBjaGFubmVsICov Ci0JbS5zdGF0dXMgPSBNQ0lfU1RBVFVTX0FERFJWICsgMHg5MDsKLQkvKiBPbmUgY29ycmVjdGVk IGVycm9yICovCi0JbS5zdGF0dXMgfD0gQklUX1VMTChNQ0lfU1RBVFVTX0NFQ19TSElGVCk7Ci0J bS5hZGRyID0gdmFsOwotCXNreF9tY2VfY2hlY2tfZXJyb3IoTlVMTCwgMCwgJm0pOwotCi0JcmV0 dXJuIDA7Ci19Ci1ERUZJTkVfU0lNUExFX0FUVFJJQlVURShmb3BzX3U2NF93bywgTlVMTCwgZGVi dWdmc191NjRfc2V0LCAiJWxsdVxuIik7Ci0KLXZvaWQgc2V0dXBfc2t4X2RlYnVnKGNvbnN0IGNo YXIgKmRpcm5hbWUpCi17Ci0Jc2t4X3Rlc3QgPSBlZGFjX2RlYnVnZnNfY3JlYXRlX2RpcihkaXJu YW1lKTsKLQlpZiAoIXNreF90ZXN0KQotCQlyZXR1cm47Ci0KLQlpZiAoIWVkYWNfZGVidWdmc19j cmVhdGVfZmlsZSgiYWRkciIsIDAyMDAsIHNreF90ZXN0LAotCQkJCSAgICAgIE5VTEwsICZmb3Bz X3U2NF93bykpIHsKLQkJZGVidWdmc19yZW1vdmUoc2t4X3Rlc3QpOwotCQlza3hfdGVzdCA9IE5V TEw7Ci0JfQotfQotCi12b2lkIHRlYXJkb3duX3NreF9kZWJ1Zyh2b2lkKQotewotCWRlYnVnZnNf cmVtb3ZlX3JlY3Vyc2l2ZShza3hfdGVzdCk7Ci19Ci0jZW5kaWYgLypDT05GSUdfRURBQ19ERUJV RyovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2VkYWMvc2t4X2NvbW1vbi5oIGIvZHJpdmVycy9lZGFj L3NreF9jb21tb24uaAppbmRleCBkMjUzNzRlMzRkNGYuLmQxOGZhOTg2NjlhZiAxMDA2NDQKLS0t IGEvZHJpdmVycy9lZGFjL3NreF9jb21tb24uaAorKysgYi9kcml2ZXJzL2VkYWMvc2t4X2NvbW1v bi5oCkBAIC0xNDEsMTIgKzE0MSw0IEBAIGludCBza3hfbWNlX2NoZWNrX2Vycm9yKHN0cnVjdCBu b3RpZmllcl9ibG9jayAqbmIsIHVuc2lnbmVkIGxvbmcgdmFsLAogCiB2b2lkIHNreF9yZW1vdmUo dm9pZCk7CiAKLSNpZmRlZiBDT05GSUdfRURBQ19ERUJVRwotdm9pZCBzZXR1cF9za3hfZGVidWco Y29uc3QgY2hhciAqZGlybmFtZSk7Ci12b2lkIHRlYXJkb3duX3NreF9kZWJ1Zyh2b2lkKTsKLSNl bHNlCi1zdGF0aWMgaW5saW5lIHZvaWQgc2V0dXBfc2t4X2RlYnVnKGNvbnN0IGNoYXIgKmRpcm5h bWUpIHt9Ci1zdGF0aWMgaW5saW5lIHZvaWQgdGVhcmRvd25fc2t4X2RlYnVnKHZvaWQpIHt9Ci0j ZW5kaWYgLypDT05GSUdfRURBQ19ERUJVRyovCi0KICNlbmRpZiAvKiBfU0tYX0NPTU1fRURBQ19I ICovCg==