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.6 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED,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 DE07EC43381 for ; Fri, 22 Mar 2019 22:59:45 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 9ACA720685 for ; Fri, 22 Mar 2019 22:59:45 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=alien8.de header.i=@alien8.de header.b="DKQUvxjY" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728346AbfCVW7o (ORCPT ); Fri, 22 Mar 2019 18:59:44 -0400 Received: from mail.skyhub.de ([5.9.137.197]:60586 "EHLO mail.skyhub.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727846AbfCVW7n (ORCPT ); Fri, 22 Mar 2019 18:59:43 -0400 Received: from zn.tnic (p200300EC2F098000329C23FFFEA6A903.dip0.t-ipconnect.de [IPv6:2003:ec:2f09:8000:329c:23ff:fea6:a903]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.skyhub.de (SuperMail on ZX Spectrum 128k) with ESMTPSA id D59B61EC0AB1; Fri, 22 Mar 2019 23:59:40 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=alien8.de; s=dkim; t=1553295581; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:in-reply-to:in-reply-to: references:references; bh=ODJgH8cK0dRVnTkySycVgcmFCa334CVgP66cVUl9IPo=; b=DKQUvxjYsO8QGJTNQaJj+5oCdApFPI2KR4LeDW96x7zNOnGq1LCWiZNae2DF6ldVqWhzE/ 70krGqQ9nUs5jW4LeHN7iZEk9alRFlZvXNUOgGqzSWUtklwjGlhLfO5KTLrMkoXYVbzojk lhPLYUnHhHsl0TCNUMDqEuw410gnjRY= Date: Fri, 22 Mar 2019 23:59:44 +0100 From: Borislav Petkov To: "Luck, Tony" Cc: Arnd Bergmann , Mauro Carvalho Chehab , James Morse , Qiuxu Zhuo , linux-edac@vger.kernel.org, Linux Kernel Mailing List Subject: Re: [PATCH] EDAC, {skx|i10nm}_edac: Fix randconfig build error Message-ID: <20190322225928.GR12472@zn.tnic> 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> <20190321221339.GA32323@agluck-desk> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline In-Reply-To: <20190321221339.GA32323@agluck-desk> 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 On Thu, Mar 21, 2019 at 03:13:39PM -0700, Luck, Tony wrote: > > From: Qiuxu Zhuo > > Kbuild failed on the kernel configurations below: ... I've massaged this into the below and running randconfigs now: --- From: Qiuxu Zhuo Date: Thu, 21 Mar 2019 15:13:39 -0700 Subject: [PATCH] EDAC, skx, i10nm: Make skx_common.c a pure library The following Kconfig constellations fail randconfig builds: 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 with: ... 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_edac or i10nm_edac - is built-in and the other one is a module, the shared file skx_common.c gets linked into a module object by kbuild. Therefore, when linking that same file into vmlinux, the '__this_module' symbol used in debugfs isn't defined, leading to the above error. Fix it by moving all debugfs code from skx_common.c to both skx_base.c and i10nm_base.c respectively. Thus, skx_common.c doesn't refer to '__this_module' symbol anymore. Clarify its purpose at the top of the file for future reference, while at it. [ bp: Make text more readable. ] 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 Signed-off-by: Borislav Petkov Cc: James Morse Cc: Mauro Carvalho Chehab Cc: linux-edac Link: https://lkml.kernel.org/r/20190321221339.GA32323@agluck-desk --- drivers/edac/i10nm_base.c | 52 +++++++++++++++++++++++++++++++++-- drivers/edac/skx_base.c | 50 +++++++++++++++++++++++++++++++++- drivers/edac/skx_common.c | 57 +++++++-------------------------------- drivers/edac/skx_common.h | 8 ------ 4 files changed, 109 insertions(+), 58 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..b0dddcfa9baa 100644 --- a/drivers/edac/skx_common.c +++ b/drivers/edac/skx_common.c @@ -1,7 +1,15 @@ // SPDX-License-Identifier: GPL-2.0 /* - * Common codes for both the skx_edac driver and Intel 10nm server EDAC driver. - * Originally split out from the skx_edac driver. + * + * Shared code by both skx_edac and i10nm_edac. Originally split out + * from the skx_edac driver. + * + * This file is linked into both skx_edac and i10nm_edac drivers. In + * order to avoid link errors, this file must be like a pure library + * without including symbols and defines which would otherwise conflict, + * when linked once into a module and into a built-in object, at the + * same time. For example, __this_module symbol references when that + * file is being linked into a built-in object. * * Copyright (c) 2018, Intel Corporation. */ @@ -644,48 +652,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.21.0 -- Regards/Gruss, Boris. Good mailing practices for 400: avoid top-posting and trim the reply. 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: Borislav Petkov Message-Id: <20190322225928.GR12472@zn.tnic> Date: Fri, 22 Mar 2019 23:59:44 +0100 To: "Luck, Tony" Cc: Arnd Bergmann , Mauro Carvalho Chehab , James Morse , Qiuxu Zhuo , linux-edac@vger.kernel.org, Linux Kernel Mailing List List-ID: T24gVGh1LCBNYXIgMjEsIDIwMTkgYXQgMDM6MTM6MzlQTSAtMDcwMCwgTHVjaywgVG9ueSB3cm90 ZToKPiAKPiBGcm9tOiBRaXV4dSBaaHVvIDxxaXV4dS56aHVvQGludGVsLmNvbT4KPiAKPiBLYnVp bGQgZmFpbGVkIG9uIHRoZSBrZXJuZWwgY29uZmlndXJhdGlvbnMgYmVsb3c6CgouLi4KCkkndmUg bWFzc2FnZWQgdGhpcyBpbnRvIHRoZSBiZWxvdyBhbmQgcnVubmluZyByYW5kY29uZmlncyBub3c6 Ci0tLQpGcm9tOiBRaXV4dSBaaHVvIDxxaXV4dS56aHVvQGludGVsLmNvbT4KRGF0ZTogVGh1LCAy MSBNYXIgMjAxOSAxNToxMzozOSAtMDcwMApTdWJqZWN0OiBbUEFUQ0hdIEVEQUMsIHNreCwgaTEw bm06IE1ha2Ugc2t4X2NvbW1vbi5jIGEgcHVyZSBsaWJyYXJ5CgpUaGUgZm9sbG93aW5nIEtjb25m aWcgY29uc3RlbGxhdGlvbnMgZmFpbCByYW5kY29uZmlnIGJ1aWxkczoKCiAgQ09ORklHX0FDUElf TkZJVD15CiAgQ09ORklHX0VEQUNfREVCVUc9eQogIENPTkZJR19FREFDX1NLWD1tCiAgQ09ORklH X0VEQUNfSTEwTk09eQoKb3IKCiAgQ09ORklHX0FDUElfTkZJVD15CiAgQ09ORklHX0VEQUNfREVC VUc9eQogIENPTkZJR19FREFDX1NLWD15CiAgQ09ORklHX0VEQUNfSTEwTk09bQoKd2l0aDoKICAu Li4KICBDQyBbTV0gIGRyaXZlcnMvZWRhYy9za3hfY29tbW9uLm8KICAuLi4KICAuLi4vc2t4X2Nv bW1vbi5vOi4uLi9za3hfY29tbW9uLmM6NjcyOiB1bmRlZmluZWQgcmVmZXJlbmNlIHRvIGBfX3Ro aXNfbW9kdWxlJwoKVGhhdCBpcyBiZWNhdXNlIGlmIG9uZSBvZiB0aGUgdHdvIGRyaXZlcnMgLSBz a3hfZWRhYyBvciBpMTBubV9lZGFjIC0gaXMKYnVpbHQtaW4gYW5kIHRoZSBvdGhlciBvbmUgaXMg YSBtb2R1bGUsIHRoZSBzaGFyZWQgZmlsZSBza3hfY29tbW9uLmMKZ2V0cyBsaW5rZWQgaW50byBh IG1vZHVsZSBvYmplY3QgYnkga2J1aWxkLiBUaGVyZWZvcmUsIHdoZW4gbGlua2luZyB0aGF0CnNh bWUgZmlsZSBpbnRvIHZtbGludXgsIHRoZSAnX190aGlzX21vZHVsZScgc3ltYm9sIHVzZWQgaW4g ZGVidWdmcyBpc24ndApkZWZpbmVkLCBsZWFkaW5nIHRvIHRoZSBhYm92ZSBlcnJvci4KCkZpeCBp dCBieSBtb3ZpbmcgYWxsIGRlYnVnZnMgY29kZSBmcm9tIHNreF9jb21tb24uYyB0byBib3RoIHNr eF9iYXNlLmMKYW5kIGkxMG5tX2Jhc2UuYyByZXNwZWN0aXZlbHkuIFRodXMsIHNreF9jb21tb24u YyBkb2Vzbid0IHJlZmVyIHRvCidfX3RoaXNfbW9kdWxlJyBzeW1ib2wgYW55bW9yZS4KCkNsYXJp ZnkgaXRzIHB1cnBvc2UgYXQgdGhlIHRvcCBvZiB0aGUgZmlsZSBmb3IgZnV0dXJlIHJlZmVyZW5j ZSwgd2hpbGUKYXQgaXQuCgogWyBicDogTWFrZSB0ZXh0IG1vcmUgcmVhZGFibGUuIF0KCkZpeGVz OiBkNGRjODlkMDY5YWEgKCJFREFDLCBpMTBubTogQWRkIGEgZHJpdmVyIGZvciBJbnRlbCAxMG5t IHNlcnZlciBwcm9jZXNzb3JzIikKUmVwb3J0ZWQtYnk6IEFybmQgQmVyZ21hbm4gPGFybmRAYXJu ZGIuZGU+ClNpZ25lZC1vZmYtYnk6IFFpdXh1IFpodW8gPHFpdXh1LnpodW9AaW50ZWwuY29tPgpT aWduZWQtb2ZmLWJ5OiBUb255IEx1Y2sgPHRvbnkubHVja0BpbnRlbC5jb20+ClNpZ25lZC1vZmYt Ynk6IEJvcmlzbGF2IFBldGtvdiA8YnBAc3VzZS5kZT4KQ2M6IEphbWVzIE1vcnNlIDxqYW1lcy5t b3JzZUBhcm0uY29tPgpDYzogTWF1cm8gQ2FydmFsaG8gQ2hlaGFiIDxtY2hlaGFiQGtlcm5lbC5v cmc+CkNjOiBsaW51eC1lZGFjIDxsaW51eC1lZGFjQHZnZXIua2VybmVsLm9yZz4KTGluazogaHR0 cHM6Ly9sa21sLmtlcm5lbC5vcmcvci8yMDE5MDMyMTIyMTMzOS5HQTMyMzIzQGFnbHVjay1kZXNr Ci0tLQogZHJpdmVycy9lZGFjL2kxMG5tX2Jhc2UuYyB8IDUyICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKy0tCiBkcml2ZXJzL2VkYWMvc2t4X2Jhc2UuYyAgIHwgNTAgKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrLQogZHJpdmVycy9lZGFjL3NreF9jb21tb24uYyB8IDU3 ICsrKysrKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9lZGFjL3Nr eF9jb21tb24uaCB8ICA4IC0tLS0tLQogNCBmaWxlcyBjaGFuZ2VkLCAxMDkgaW5zZXJ0aW9ucygr KSwgNTggZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL2kxMG5tX2Jhc2Uu YyBiL2RyaXZlcnMvZWRhYy9pMTBubV9iYXNlLmMKaW5kZXggYzMzNGZiN2M2M2RmLi42ZjA2YWVj NDg3N2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9pMTBubV9iYXNlLmMKKysrIGIvZHJpdmVy cy9lZGFjL2kxMG5tX2Jhc2UuYwpAQCAtMTgxLDYgKzE4MSw1NCBAQCBzdGF0aWMgc3RydWN0IG5v dGlmaWVyX2Jsb2NrIGkxMG5tX21jZV9kZWMgPSB7CiAJLnByaW9yaXR5CT0gTUNFX1BSSU9fRURB QywKIH07CiAKKyNpZmRlZiBDT05GSUdfRURBQ19ERUJVRworLyoKKyAqIERlYnVnIGZlYXR1cmUu CisgKiBFeGVyY2lzZSB0aGUgYWRkcmVzcyBkZWNvZGUgbG9naWMgYnkgd3JpdGluZyBhbiBhZGRy ZXNzIHRvCisgKiAvc3lzL2tlcm5lbC9kZWJ1Zy9lZGFjL2kxMG5tX3Rlc3QvYWRkci4KKyAqLwor c3RhdGljIHN0cnVjdCBkZW50cnkgKmkxMG5tX3Rlc3Q7CisKK3N0YXRpYyBpbnQgZGVidWdmc191 NjRfc2V0KHZvaWQgKmRhdGEsIHU2NCB2YWwpCit7CisJc3RydWN0IG1jZSBtOworCisJcHJfd2Fy bl9vbmNlKCJGYWtlIGVycm9yIHRvIDB4JWxseCBpbmplY3RlZCB2aWEgZGVidWdmc1xuIiwgdmFs KTsKKworCW1lbXNldCgmbSwgMCwgc2l6ZW9mKG0pKTsKKwkvKiBBRERSViArIE1lbVJkICsgVW5r bm93biBjaGFubmVsICovCisJbS5zdGF0dXMgPSBNQ0lfU1RBVFVTX0FERFJWICsgMHg5MDsKKwkv KiBPbmUgY29ycmVjdGVkIGVycm9yICovCisJbS5zdGF0dXMgfD0gQklUX1VMTChNQ0lfU1RBVFVT X0NFQ19TSElGVCk7CisJbS5hZGRyID0gdmFsOworCXNreF9tY2VfY2hlY2tfZXJyb3IoTlVMTCwg MCwgJm0pOworCisJcmV0dXJuIDA7Cit9CitERUZJTkVfU0lNUExFX0FUVFJJQlVURShmb3BzX3U2 NF93bywgTlVMTCwgZGVidWdmc191NjRfc2V0LCAiJWxsdVxuIik7CisKK3N0YXRpYyB2b2lkIHNl dHVwX2kxMG5tX2RlYnVnKHZvaWQpCit7CisJaTEwbm1fdGVzdCA9IGVkYWNfZGVidWdmc19jcmVh dGVfZGlyKCJpMTBubV90ZXN0Iik7CisJaWYgKCFpMTBubV90ZXN0KQorCQlyZXR1cm47CisKKwlp ZiAoIWVkYWNfZGVidWdmc19jcmVhdGVfZmlsZSgiYWRkciIsIDAyMDAsIGkxMG5tX3Rlc3QsCisJ CQkJICAgICAgTlVMTCwgJmZvcHNfdTY0X3dvKSkgeworCQlkZWJ1Z2ZzX3JlbW92ZShpMTBubV90 ZXN0KTsKKwkJaTEwbm1fdGVzdCA9IE5VTEw7CisJfQorfQorCitzdGF0aWMgdm9pZCB0ZWFyZG93 bl9pMTBubV9kZWJ1Zyh2b2lkKQoreworCWRlYnVnZnNfcmVtb3ZlX3JlY3Vyc2l2ZShpMTBubV90 ZXN0KTsKK30KKyNlbHNlCitzdGF0aWMgaW5saW5lIHZvaWQgc2V0dXBfaTEwbm1fZGVidWcodm9p ZCkge30KK3N0YXRpYyBpbmxpbmUgdm9pZCB0ZWFyZG93bl9pMTBubV9kZWJ1Zyh2b2lkKSB7fQor I2VuZGlmIC8qQ09ORklHX0VEQUNfREVCVUcqLworCiBzdGF0aWMgaW50IF9faW5pdCBpMTBubV9p bml0KHZvaWQpCiB7CiAJdTggbWMgPSAwLCBzcmNfaWQgPSAwLCBub2RlX2lkID0gMDsKQEAgLTI0 OSw3ICsyOTcsNyBAQCBzdGF0aWMgaW50IF9faW5pdCBpMTBubV9pbml0KHZvaWQpCiAKIAlvcHN0 YXRlX2luaXQoKTsKIAltY2VfcmVnaXN0ZXJfZGVjb2RlX2NoYWluKCZpMTBubV9tY2VfZGVjKTsK LQlzZXR1cF9za3hfZGVidWcoImkxMG5tX3Rlc3QiKTsKKwlzZXR1cF9pMTBubV9kZWJ1ZygpOwog CiAJaTEwbm1fcHJpbnRrKEtFUk5fSU5GTywgIiVzXG4iLCBJMTBOTV9SRVZJU0lPTik7CiAKQEAg LTI2Miw3ICszMTAsNyBAQCBzdGF0aWMgaW50IF9faW5pdCBpMTBubV9pbml0KHZvaWQpCiBzdGF0 aWMgdm9pZCBfX2V4aXQgaTEwbm1fZXhpdCh2b2lkKQogewogCWVkYWNfZGJnKDIsICJcbiIpOwot CXRlYXJkb3duX3NreF9kZWJ1ZygpOworCXRlYXJkb3duX2kxMG5tX2RlYnVnKCk7CiAJbWNlX3Vu cmVnaXN0ZXJfZGVjb2RlX2NoYWluKCZpMTBubV9tY2VfZGVjKTsKIAlza3hfYWR4bF9wdXQoKTsK IAlza3hfcmVtb3ZlKCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2VkYWMvc2t4X2Jhc2UuYyBiL2Ry aXZlcnMvZWRhYy9za3hfYmFzZS5jCmluZGV4IGFkYWU0Yzg0OGNhMS4uYTVjOGZhM2EyNDlhIDEw MDY0NAotLS0gYS9kcml2ZXJzL2VkYWMvc2t4X2Jhc2UuYworKysgYi9kcml2ZXJzL2VkYWMvc2t4 X2Jhc2UuYwpAQCAtNTQwLDYgKzU0MCw1NCBAQCBzdGF0aWMgc3RydWN0IG5vdGlmaWVyX2Jsb2Nr IHNreF9tY2VfZGVjID0gewogCS5wcmlvcml0eQk9IE1DRV9QUklPX0VEQUMsCiB9OwogCisjaWZk ZWYgQ09ORklHX0VEQUNfREVCVUcKKy8qCisgKiBEZWJ1ZyBmZWF0dXJlLgorICogRXhlcmNpc2Ug dGhlIGFkZHJlc3MgZGVjb2RlIGxvZ2ljIGJ5IHdyaXRpbmcgYW4gYWRkcmVzcyB0bworICogL3N5 cy9rZXJuZWwvZGVidWcvZWRhYy9za3hfdGVzdC9hZGRyLgorICovCitzdGF0aWMgc3RydWN0IGRl bnRyeSAqc2t4X3Rlc3Q7CisKK3N0YXRpYyBpbnQgZGVidWdmc191NjRfc2V0KHZvaWQgKmRhdGEs IHU2NCB2YWwpCit7CisJc3RydWN0IG1jZSBtOworCisJcHJfd2Fybl9vbmNlKCJGYWtlIGVycm9y IHRvIDB4JWxseCBpbmplY3RlZCB2aWEgZGVidWdmc1xuIiwgdmFsKTsKKworCW1lbXNldCgmbSwg MCwgc2l6ZW9mKG0pKTsKKwkvKiBBRERSViArIE1lbVJkICsgVW5rbm93biBjaGFubmVsICovCisJ bS5zdGF0dXMgPSBNQ0lfU1RBVFVTX0FERFJWICsgMHg5MDsKKwkvKiBPbmUgY29ycmVjdGVkIGVy cm9yICovCisJbS5zdGF0dXMgfD0gQklUX1VMTChNQ0lfU1RBVFVTX0NFQ19TSElGVCk7CisJbS5h ZGRyID0gdmFsOworCXNreF9tY2VfY2hlY2tfZXJyb3IoTlVMTCwgMCwgJm0pOworCisJcmV0dXJu IDA7Cit9CitERUZJTkVfU0lNUExFX0FUVFJJQlVURShmb3BzX3U2NF93bywgTlVMTCwgZGVidWdm c191NjRfc2V0LCAiJWxsdVxuIik7CisKK3N0YXRpYyB2b2lkIHNldHVwX3NreF9kZWJ1Zyh2b2lk KQoreworCXNreF90ZXN0ID0gZWRhY19kZWJ1Z2ZzX2NyZWF0ZV9kaXIoInNreF90ZXN0Iik7CisJ aWYgKCFza3hfdGVzdCkKKwkJcmV0dXJuOworCisJaWYgKCFlZGFjX2RlYnVnZnNfY3JlYXRlX2Zp bGUoImFkZHIiLCAwMjAwLCBza3hfdGVzdCwKKwkJCQkgICAgICBOVUxMLCAmZm9wc191NjRfd28p KSB7CisJCWRlYnVnZnNfcmVtb3ZlKHNreF90ZXN0KTsKKwkJc2t4X3Rlc3QgPSBOVUxMOworCX0K K30KKworc3RhdGljIHZvaWQgdGVhcmRvd25fc2t4X2RlYnVnKHZvaWQpCit7CisJZGVidWdmc19y ZW1vdmVfcmVjdXJzaXZlKHNreF90ZXN0KTsKK30KKyNlbHNlCitzdGF0aWMgaW5saW5lIHZvaWQg c2V0dXBfc2t4X2RlYnVnKHZvaWQpIHt9CitzdGF0aWMgaW5saW5lIHZvaWQgdGVhcmRvd25fc2t4 X2RlYnVnKHZvaWQpIHt9CisjZW5kaWYgLypDT05GSUdfRURBQ19ERUJVRyovCisKIC8qCiAgKiBz a3hfaW5pdDoKICAqCW1ha2Ugc3VyZSB3ZSBhcmUgcnVubmluZyBvbiB0aGUgY29ycmVjdCBjcHUg bW9kZWwKQEAgLTYxOSw3ICs2NjcsNyBAQCBzdGF0aWMgaW50IF9faW5pdCBza3hfaW5pdCh2b2lk KQogCS8qIEVuc3VyZSB0aGF0IHRoZSBPUFNUQVRFIGlzIHNldCBjb3JyZWN0bHkgZm9yIFBPTEwg b3IgTk1JICovCiAJb3BzdGF0ZV9pbml0KCk7CiAKLQlzZXR1cF9za3hfZGVidWcoInNreF90ZXN0 Iik7CisJc2V0dXBfc2t4X2RlYnVnKCk7CiAKIAltY2VfcmVnaXN0ZXJfZGVjb2RlX2NoYWluKCZz a3hfbWNlX2RlYyk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9za3hfY29tbW9uLmMgYi9k cml2ZXJzL2VkYWMvc2t4X2NvbW1vbi5jCmluZGV4IDBlOTZlN2I1YjBhNy4uYjBkZGRjZmE5YmFh IDEwMDY0NAotLS0gYS9kcml2ZXJzL2VkYWMvc2t4X2NvbW1vbi5jCisrKyBiL2RyaXZlcnMvZWRh Yy9za3hfY29tbW9uLmMKQEAgLTEsNyArMSwxNSBAQAogLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZp ZXI6IEdQTC0yLjAKIC8qCi0gKiBDb21tb24gY29kZXMgZm9yIGJvdGggdGhlIHNreF9lZGFjIGRy aXZlciBhbmQgSW50ZWwgMTBubSBzZXJ2ZXIgRURBQyBkcml2ZXIuCi0gKiBPcmlnaW5hbGx5IHNw bGl0IG91dCBmcm9tIHRoZSBza3hfZWRhYyBkcml2ZXIuCisgKgorICogU2hhcmVkIGNvZGUgYnkg Ym90aCBza3hfZWRhYyBhbmQgaTEwbm1fZWRhYy4gT3JpZ2luYWxseSBzcGxpdCBvdXQKKyAqIGZy b20gdGhlIHNreF9lZGFjIGRyaXZlci4KKyAqCisgKiBUaGlzIGZpbGUgaXMgbGlua2VkIGludG8g Ym90aCBza3hfZWRhYyBhbmQgaTEwbm1fZWRhYyBkcml2ZXJzLiBJbgorICogb3JkZXIgdG8gYXZv aWQgbGluayBlcnJvcnMsIHRoaXMgZmlsZSBtdXN0IGJlIGxpa2UgYSBwdXJlIGxpYnJhcnkKKyAq IHdpdGhvdXQgaW5jbHVkaW5nIHN5bWJvbHMgYW5kIGRlZmluZXMgd2hpY2ggd291bGQgb3RoZXJ3 aXNlIGNvbmZsaWN0LAorICogd2hlbiBsaW5rZWQgb25jZSBpbnRvIGEgbW9kdWxlIGFuZCBpbnRv IGEgYnVpbHQtaW4gb2JqZWN0LCBhdCB0aGUKKyAqIHNhbWUgdGltZS4gRm9yIGV4YW1wbGUsIF9f dGhpc19tb2R1bGUgc3ltYm9sIHJlZmVyZW5jZXMgd2hlbiB0aGF0CisgKiBmaWxlIGlzIGJlaW5n IGxpbmtlZCBpbnRvIGEgYnVpbHQtaW4gb2JqZWN0LgogICoKICAqIENvcHlyaWdodCAoYykgMjAx OCwgSW50ZWwgQ29ycG9yYXRpb24uCiAgKi8KQEAgLTY0NCw0OCArNjUyLDMgQEAgdm9pZCBza3hf cmVtb3ZlKHZvaWQpCiAJCWtmcmVlKGQpOwogCX0KIH0KLQotI2lmZGVmIENPTkZJR19FREFDX0RF QlVHCi0vKgotICogRGVidWcgZmVhdHVyZS4KLSAqIEV4ZXJjaXNlIHRoZSBhZGRyZXNzIGRlY29k ZSBsb2dpYyBieSB3cml0aW5nIGFuIGFkZHJlc3MgdG8KLSAqIC9zeXMva2VybmVsL2RlYnVnL2Vk YWMvZGlybmFtZS9hZGRyLgotICovCi1zdGF0aWMgc3RydWN0IGRlbnRyeSAqc2t4X3Rlc3Q7Ci0K LXN0YXRpYyBpbnQgZGVidWdmc191NjRfc2V0KHZvaWQgKmRhdGEsIHU2NCB2YWwpCi17Ci0Jc3Ry dWN0IG1jZSBtOwotCi0JcHJfd2Fybl9vbmNlKCJGYWtlIGVycm9yIHRvIDB4JWxseCBpbmplY3Rl ZCB2aWEgZGVidWdmc1xuIiwgdmFsKTsKLQotCW1lbXNldCgmbSwgMCwgc2l6ZW9mKG0pKTsKLQkv KiBBRERSViArIE1lbVJkICsgVW5rbm93biBjaGFubmVsICovCi0JbS5zdGF0dXMgPSBNQ0lfU1RB VFVTX0FERFJWICsgMHg5MDsKLQkvKiBPbmUgY29ycmVjdGVkIGVycm9yICovCi0JbS5zdGF0dXMg fD0gQklUX1VMTChNQ0lfU1RBVFVTX0NFQ19TSElGVCk7Ci0JbS5hZGRyID0gdmFsOwotCXNreF9t Y2VfY2hlY2tfZXJyb3IoTlVMTCwgMCwgJm0pOwotCi0JcmV0dXJuIDA7Ci19Ci1ERUZJTkVfU0lN UExFX0FUVFJJQlVURShmb3BzX3U2NF93bywgTlVMTCwgZGVidWdmc191NjRfc2V0LCAiJWxsdVxu Iik7Ci0KLXZvaWQgc2V0dXBfc2t4X2RlYnVnKGNvbnN0IGNoYXIgKmRpcm5hbWUpCi17Ci0Jc2t4 X3Rlc3QgPSBlZGFjX2RlYnVnZnNfY3JlYXRlX2RpcihkaXJuYW1lKTsKLQlpZiAoIXNreF90ZXN0 KQotCQlyZXR1cm47Ci0KLQlpZiAoIWVkYWNfZGVidWdmc19jcmVhdGVfZmlsZSgiYWRkciIsIDAy MDAsIHNreF90ZXN0LAotCQkJCSAgICAgIE5VTEwsICZmb3BzX3U2NF93bykpIHsKLQkJZGVidWdm c19yZW1vdmUoc2t4X3Rlc3QpOwotCQlza3hfdGVzdCA9IE5VTEw7Ci0JfQotfQotCi12b2lkIHRl YXJkb3duX3NreF9kZWJ1Zyh2b2lkKQotewotCWRlYnVnZnNfcmVtb3ZlX3JlY3Vyc2l2ZShza3hf dGVzdCk7Ci19Ci0jZW5kaWYgLypDT05GSUdfRURBQ19ERUJVRyovCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2VkYWMvc2t4X2NvbW1vbi5oIGIvZHJpdmVycy9lZGFjL3NreF9jb21tb24uaAppbmRleCBk MjUzNzRlMzRkNGYuLmQxOGZhOTg2NjlhZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9lZGFjL3NreF9j b21tb24uaAorKysgYi9kcml2ZXJzL2VkYWMvc2t4X2NvbW1vbi5oCkBAIC0xNDEsMTIgKzE0MSw0 IEBAIGludCBza3hfbWNlX2NoZWNrX2Vycm9yKHN0cnVjdCBub3RpZmllcl9ibG9jayAqbmIsIHVu c2lnbmVkIGxvbmcgdmFsLAogCiB2b2lkIHNreF9yZW1vdmUodm9pZCk7CiAKLSNpZmRlZiBDT05G SUdfRURBQ19ERUJVRwotdm9pZCBzZXR1cF9za3hfZGVidWcoY29uc3QgY2hhciAqZGlybmFtZSk7 Ci12b2lkIHRlYXJkb3duX3NreF9kZWJ1Zyh2b2lkKTsKLSNlbHNlCi1zdGF0aWMgaW5saW5lIHZv aWQgc2V0dXBfc2t4X2RlYnVnKGNvbnN0IGNoYXIgKmRpcm5hbWUpIHt9Ci1zdGF0aWMgaW5saW5l IHZvaWQgdGVhcmRvd25fc2t4X2RlYnVnKHZvaWQpIHt9Ci0jZW5kaWYgLypDT05GSUdfRURBQ19E RUJVRyovCi0KICNlbmRpZiAvKiBfU0tYX0NPTU1fRURBQ19IICovCg==