From mboxrd@z Thu Jan 1 00:00:00 1970 From: mcgrof@kernel.org Date: Fri, 19 Aug 2016 21:32:56 +0000 Subject: [PATCH v4 07/16] tables.h: add linker table support Message-Id: <1471642385-5629-8-git-send-email-mcgrof@kernel.org> List-Id: References: <1471642385-5629-1-git-send-email-mcgrof@kernel.org> In-Reply-To: <1471642385-5629-1-git-send-email-mcgrof@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: hpa@zytor.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, linux@arm.linux.org.uk, mhiramat@kernel.org, masami.hiramatsu.pt@hitachi.com, jbaron@akamai.com, heiko.carstens@de.ibm.com, ananth@linux.vnet.ibm.com, anil.s.keshavamurthy@intel.com, davem@davemloft.net, realmz6@gmail.com Cc: gnomes@lxorguk.ukuu.org.uk, linux-ia64@vger.kernel.org, jkosina@suse.cz, benh@kernel.crashing.org, ming.lei@canonical.com, linux@rasmusvillemoes.dk, platform-driver-x86@vger.kernel.org, James.Bottomley@HansenPartnership.com, paul.gortmaker@windriver.com, paulus@samba.org, sparclinux@vger.kernel.org, mchehab@osg.samsung.com, linux-arch@vger.kernel.org, markus.heiser@darmarit.de, xen-devel@lists.xensource.com, msalter@redhat.com, linux-sh@vger.kernel.org, mpe@ellerman.id.au, x86@kernel.org, fontana@sharpeleven.org, linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, dvhart@infradead.org, dwmw2@infradead.org, linux-xtensa@linux-xtensa.org, pali.rohar@gmail.com, keescook@chromium.org, arnd@arndb.de, jani.nikula@intel.com, will.deacon@arm.com, rusty@rustcorp.com.au, rostedt@goodmis.org, acme@redhat.com, ak@linux.intel.com, andriy.shevchenko@linux.intel.com, mcb30@ip From: "Luis R. Rodriguez" A linker table is a data structure that is stitched together from items in multiple object files. Linux has historically implicitly used linker tables for ages, however they were all built in an adhoc manner which requires linker script modifications, per architecture. This adds a general linker table solution so that a new linker table can be implemented by changing C code only. The Linux linker table was inspired by Michael Brown's iPXE's linker table solution, it has been been completely re-written and adapted for integration and use on Linux. The same philosophy is borrowed, extended and further simplified: Linker tables enable an extremely light weight linker build time solution for feature ordering and selection, this can help to both simplify init sequences in a generic fashion and helps avoiding code bit-rotting when desirable. Further changes will be added later which will make more evident how code bit rot can be avoided using linker tables. v4: o Split out kbuild additions to help with code bit rot into its own patch o tons of documentation love o fix arch/x86/tools/relocs.c typo - which caused compilation issues on old toolchains o add c6x toolchain work around as discussed with Mark Salter o sprinkle a few more needed VMLINUX_SYMBOL() - fixes compilation on blackfin o suggested name changes by boris: - %s/SECTION_TYPE_RANGES/rng/g - %s/SECTION_TYPE/SECTION_CORE/g - %s/section_type_asmtype/section_core_type/g - %s/section_type/section_core/g - %s/section_rng/set_section_rng/g - Drop DECLARE_SECTION_TBL() -- this is an asm equivalent DEFINE_LINKTABLE() -- this however is not used yet, and it requires a bit more work to match the C code definitions. o drop tools/include/linux/sections.h in favor of the more popular open coding the names for tools o expand documentation to include module support o add maintaners o Use generic-y o move .text.tbl before unlikely to match the other sections v3: o addressed initial modular support test cases o added generic asm macros so linker tables can be used in asm code / C asm calls o section ranges are now split up into their own set of files o use asm/sections.h instead of linux/sections.h for the linker script o add a sections.h file for each architecture that was missing one, this is needed now as we'll be relying on sections.h for custom section types in code rather than custom architecture specific linker script hacks. o full rewrite at this point, decided to pick copyleft-next license for this work v2: o modified completely to match feedback by community, made equivalent modifications to userspace solution. This is pretty much a complete rewrite of how we present and use linker tables. By using standard sections we no longer have to make custom linker script extensions for each new linker table solution, you just pick a linker table type by section type. o extend documention considerably, including use of kdoc o drop ICC hacks per popular request to ignore such issues for now o use sections.h - this lets us streamline a clean use case of well documented sections. To help further with this make use of SECTION_TBL() to allow use of these in code and SECTION_TBL_ALL() on linker scripts, as well as SECTION_TBL_ALL_STR() on relocs.c when needed. Cc: Michael Brown Signed-off-by: Luis R. Rodriguez --- Documentation/sections/index.rst | 1 + Documentation/sections/linker-tables.rst | 187 ++++++++++ MAINTAINERS | 12 + arch/alpha/include/asm/Kbuild | 1 + arch/arc/include/asm/Kbuild | 1 + arch/arm/include/asm/Kbuild | 1 + arch/arm64/include/asm/Kbuild | 1 + arch/avr32/include/asm/Kbuild | 1 + arch/blackfin/include/asm/Kbuild | 1 + arch/c6x/include/asm/tables.h | 26 ++ arch/cris/include/asm/Kbuild | 1 + arch/frv/include/asm/Kbuild | 1 + arch/h8300/include/asm/Kbuild | 1 + arch/hexagon/include/asm/Kbuild | 1 + arch/ia64/include/asm/Kbuild | 1 + arch/m32r/include/asm/Kbuild | 1 + arch/m68k/include/asm/Kbuild | 1 + arch/metag/include/asm/Kbuild | 1 + arch/microblaze/include/asm/Kbuild | 1 + arch/mips/include/asm/Kbuild | 1 + arch/mn10300/include/asm/Kbuild | 1 + arch/nios2/include/asm/Kbuild | 1 + arch/openrisc/include/asm/Kbuild | 1 + arch/parisc/include/asm/Kbuild | 1 + arch/powerpc/include/asm/Kbuild | 1 + arch/s390/include/asm/Kbuild | 1 + arch/score/include/asm/Kbuild | 1 + arch/sh/include/asm/Kbuild | 1 + arch/sparc/include/asm/Kbuild | 1 + arch/tile/include/asm/Kbuild | 1 + arch/um/include/asm/Kbuild | 1 + arch/unicore32/include/asm/Kbuild | 1 + arch/x86/include/asm/Kbuild | 1 + arch/x86/tools/relocs.c | 2 + arch/xtensa/include/asm/Kbuild | 1 + include/asm-generic/ranges.h | 14 + include/asm-generic/tables.h | 50 +++ include/asm-generic/vmlinux.lds.h | 6 + include/linux/tables.h | 567 +++++++++++++++++++++++++++++++ scripts/Makefile.clean | 2 + 40 files changed, 897 insertions(+) create mode 100644 Documentation/sections/linker-tables.rst create mode 100644 arch/c6x/include/asm/tables.h create mode 100644 include/asm-generic/tables.h create mode 100644 include/linux/tables.h diff --git a/Documentation/sections/index.rst b/Documentation/sections/index.rst index 6dd93ddd5dbe..4514c5738b33 100644 --- a/Documentation/sections/index.rst +++ b/Documentation/sections/index.rst @@ -10,3 +10,4 @@ used throughout the kernel to help declare and define them. section-core ranges + linker-tables diff --git a/Documentation/sections/linker-tables.rst b/Documentation/sections/linker-tables.rst new file mode 100644 index 000000000000..df11c632dca7 --- /dev/null +++ b/Documentation/sections/linker-tables.rst @@ -0,0 +1,187 @@ +=========+Linux linker tables +=========+ +This documents Linux linker tables, it explains what they are, where they +came from, how they work, the benefits of using them and more importantly +how you can use them. + +About Linker tables +=========+.. kernel-doc:: include/linux/tables.h + :doc: Introduction + +Linker table provenance +--------------------------------------------- + +.. kernel-doc:: include/linux/tables.h + :doc: Linker table provenance + +Benefits of using Linker tables +===============+ +Avoids modifying architecture linker scripts +---------------------------------------------- +.. kernel-doc:: include/linux/tables.h + :doc: Avoids modifying architecture linker scripts + +How linker tables simplify initialization code +---------------------------------------------- +.. kernel-doc:: include/linux/tables.h + :doc: How linker tables simplify initialization code + +Using linker tables in Linux +============== + +Linker table module support +--------------------------- + +.. kernel-doc:: include/linux/tables.h + :doc: Linker table module support + +Linker table helpers +========== + +.. kernel-doc:: include/linux/tables.h + :doc: Linker table helpers + +LINKTABLE_ADDR_WITHIN +--------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_ADDR_WITHIN + +Constructing linker tables +============= + +.. kernel-doc:: include/linux/tables.h + :doc: Constructing linker tables + +Weak linker tables constructors +------------------------------- + +.. kernel-doc:: include/linux/tables.h + :doc: Weak linker tables constructors + +LINKTABLE_WEAK +-------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_WEAK + +LINKTABLE_TEXT_WEAK +------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_TEXT_WEAK + +LINKTABLE_RO_WEAK +----------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_RO_WEAK + +LINKTABLE_INIT_WEAK +------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_INIT_WEAK + +LINKTABLE_INIT_DATA_WEAK +------------------------ +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_INIT_DATA_WEAK + +Regular linker linker table constructors +---------------------------------------- + +.. kernel-doc:: include/linux/tables.h + :doc: Regular linker linker table constructors + +LINKTABLE +--------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE + +LINKTABLE_TEXT +-------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_TEXT + +LINKTABLE_RO +------------ +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_RO + +LINKTABLE_INIT +-------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_INIT + +LINKTABLE_INIT_DATA +------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_INIT_DATA + +Declaring Linker tables +===========+ +.. kernel-doc:: include/linux/tables.h + :doc: Declaring Linker tables + +DECLARE_LINKTABLE +---------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DECLARE_LINKTABLE + +DECLARE_LINKTABLE_RO +-------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DECLARE_LINKTABLE_RO + +Defining Linker tables +=========== + +.. kernel-doc:: include/linux/tables.h + :doc: Defining Linker tables + +DEFINE_LINKTABLE +---------------- +.. kernel-doc:: include/linux/tables.h + :functions: DEFINE_LINKTABLE + +DEFINE_LINKTABLE_TEXT +--------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DEFINE_LINKTABLE_TEXT + +DEFINE_LINKTABLE_RO +------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DEFINE_LINKTABLE_RO + +DEFINE_LINKTABLE_INIT +--------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DEFINE_LINKTABLE_INIT + +DEFINE_LINKTABLE_INIT_DATA +-------------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DEFINE_LINKTABLE_INIT_DATA + +Iterating over Linker tables +============== + +.. kernel-doc:: include/linux/tables.h + :doc: Iterating over Linker tables + +LINKTABLE_FOR_EACH +------------------ +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_FOR_EACH + +LINKTABLE_RUN_ALL +----------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_RUN_ALL + +LINKTABLE_RUN_ERR +----------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_RUN_ERR diff --git a/MAINTAINERS b/MAINTAINERS index 1a217751aa8a..e3569ed12c86 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -5200,6 +5200,18 @@ S: Maintained F: include/asm-generic/ F: include/uapi/asm-generic/ +GENERIC LINKER TABLES +M: "Luis R. Rodriguez" +M: "H. Peter Anvin" +L: linux-arch@vger.kernel.org +L: linux-kernel@vger.kernel.org +T: git git://git.kernel.org/pub/scm/linux/kernel/git/mcgrof/linux.git sections +T: git git://git.kernel.org/pub/scm/linux/kernel/git/mcgrof/linux-next.git sections +S: Supported +F: include/asm-generic/tables.h +F: include/linux/tables.h +F: Documentation/sections/linker-tables.rst + GENERIC PHY FRAMEWORK M: Kishon Vijay Abraham I L: linux-kernel@vger.kernel.org diff --git a/arch/alpha/include/asm/Kbuild b/arch/alpha/include/asm/Kbuild index e44c896b91c4..f3bdc31d3c97 100644 --- a/arch/alpha/include/asm/Kbuild +++ b/arch/alpha/include/asm/Kbuild @@ -12,3 +12,4 @@ generic-y += sections.h generic-y += trace_clock.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/arc/include/asm/Kbuild b/arch/arc/include/asm/Kbuild index e5295413fdf8..70f252472cb9 100644 --- a/arch/arc/include/asm/Kbuild +++ b/arch/arc/include/asm/Kbuild @@ -52,3 +52,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/arm/include/asm/Kbuild b/arch/arm/include/asm/Kbuild index 8e52300e1eed..d13700f573d0 100644 --- a/arch/arm/include/asm/Kbuild +++ b/arch/arm/include/asm/Kbuild @@ -41,3 +41,4 @@ generic-y += trace_clock.h generic-y += unaligned.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/arm64/include/asm/Kbuild b/arch/arm64/include/asm/Kbuild index 5ff184574976..a1991517aad6 100644 --- a/arch/arm64/include/asm/Kbuild +++ b/arch/arm64/include/asm/Kbuild @@ -54,3 +54,4 @@ generic-y += vga.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/avr32/include/asm/Kbuild b/arch/avr32/include/asm/Kbuild index edc176348d7c..a6cd145515ae 100644 --- a/arch/avr32/include/asm/Kbuild +++ b/arch/avr32/include/asm/Kbuild @@ -24,3 +24,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/blackfin/include/asm/Kbuild b/arch/blackfin/include/asm/Kbuild index 35b7752e65c0..b71893b1cd53 100644 --- a/arch/blackfin/include/asm/Kbuild +++ b/arch/blackfin/include/asm/Kbuild @@ -50,3 +50,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/c6x/include/asm/tables.h b/arch/c6x/include/asm/tables.h new file mode 100644 index 000000000000..09a9e31c573a --- /dev/null +++ b/arch/c6x/include/asm/tables.h @@ -0,0 +1,26 @@ +#ifndef _ASM_C6X_ASM_TABLES_H +#define _ASM_C6X_ASM_TABLES_H +/* + * Copyright (C) 2016 Luis R. Rodriguez + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of copyleft-next (version 0.3.1 or later) as published + * at http://copyleft-next.org/. + */ + +/* + * The c6x toolchain has a bug present even on gcc-6 when non-weak attributes + * are used and sends them to .rodata even though const data with weak + * attributes are put in .const, this forces the linker to believe the address + * is relative relative to the a base + offset and you end up with SB-relative + * reloc error upon linking. Work around this by by forcing both start and + * ending const RO waek linker table entry to be .const to fix this for now. + * + * [0] https://lkml.kernel.org/r/1470798247.3551.94.camel@redhat.com + */ + +#define SECTION_TBL_RO .const + +#include + +#endif /* _ASM_C6X_ASM_TABLES_H */ diff --git a/arch/cris/include/asm/Kbuild b/arch/cris/include/asm/Kbuild index fb8bb4112773..7062c1be7913 100644 --- a/arch/cris/include/asm/Kbuild +++ b/arch/cris/include/asm/Kbuild @@ -47,3 +47,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/frv/include/asm/Kbuild b/arch/frv/include/asm/Kbuild index 5191fec655d7..4a59cbda5091 100644 --- a/arch/frv/include/asm/Kbuild +++ b/arch/frv/include/asm/Kbuild @@ -10,3 +10,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/h8300/include/asm/Kbuild b/arch/h8300/include/asm/Kbuild index 7929a992566c..d79968d93c12 100644 --- a/arch/h8300/include/asm/Kbuild +++ b/arch/h8300/include/asm/Kbuild @@ -77,3 +77,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/hexagon/include/asm/Kbuild b/arch/hexagon/include/asm/Kbuild index af17ee334788..d59ac1c1858b 100644 --- a/arch/hexagon/include/asm/Kbuild +++ b/arch/hexagon/include/asm/Kbuild @@ -62,3 +62,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/ia64/include/asm/Kbuild b/arch/ia64/include/asm/Kbuild index d8f226b35a0a..76540f143473 100644 --- a/arch/ia64/include/asm/Kbuild +++ b/arch/ia64/include/asm/Kbuild @@ -11,3 +11,4 @@ generic-y += vtime.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/m32r/include/asm/Kbuild b/arch/m32r/include/asm/Kbuild index 1c6504d29312..24088f3c733c 100644 --- a/arch/m32r/include/asm/Kbuild +++ b/arch/m32r/include/asm/Kbuild @@ -13,3 +13,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/m68k/include/asm/Kbuild b/arch/m68k/include/asm/Kbuild index d465f51c2088..65c0df17f70e 100644 --- a/arch/m68k/include/asm/Kbuild +++ b/arch/m68k/include/asm/Kbuild @@ -37,3 +37,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/metag/include/asm/Kbuild b/arch/metag/include/asm/Kbuild index c869b1ebd583..2538224899fd 100644 --- a/arch/metag/include/asm/Kbuild +++ b/arch/metag/include/asm/Kbuild @@ -58,3 +58,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/microblaze/include/asm/Kbuild b/arch/microblaze/include/asm/Kbuild index 63c083a1f8da..01afb1b420f5 100644 --- a/arch/microblaze/include/asm/Kbuild +++ b/arch/microblaze/include/asm/Kbuild @@ -13,3 +13,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/mips/include/asm/Kbuild b/arch/mips/include/asm/Kbuild index ed225600c8a4..07009c0863f6 100644 --- a/arch/mips/include/asm/Kbuild +++ b/arch/mips/include/asm/Kbuild @@ -22,3 +22,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/mn10300/include/asm/Kbuild b/arch/mn10300/include/asm/Kbuild index 656af7b69940..6c8d12f3fe44 100644 --- a/arch/mn10300/include/asm/Kbuild +++ b/arch/mn10300/include/asm/Kbuild @@ -12,3 +12,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/nios2/include/asm/Kbuild b/arch/nios2/include/asm/Kbuild index c55880659d67..ee6220dac1e8 100644 --- a/arch/nios2/include/asm/Kbuild +++ b/arch/nios2/include/asm/Kbuild @@ -65,3 +65,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/openrisc/include/asm/Kbuild b/arch/openrisc/include/asm/Kbuild index 7d6a704b808c..ceafe458e295 100644 --- a/arch/openrisc/include/asm/Kbuild +++ b/arch/openrisc/include/asm/Kbuild @@ -73,3 +73,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/parisc/include/asm/Kbuild b/arch/parisc/include/asm/Kbuild index 1a263a7158e2..99211477bfb2 100644 --- a/arch/parisc/include/asm/Kbuild +++ b/arch/parisc/include/asm/Kbuild @@ -31,3 +31,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/powerpc/include/asm/Kbuild b/arch/powerpc/include/asm/Kbuild index 065c6e84fb67..bbd54aa1571e 100644 --- a/arch/powerpc/include/asm/Kbuild +++ b/arch/powerpc/include/asm/Kbuild @@ -9,3 +9,4 @@ generic-y += rwsem.h generic-y += vtime.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/s390/include/asm/Kbuild b/arch/s390/include/asm/Kbuild index 3e8b95927cb5..92c2250a1521 100644 --- a/arch/s390/include/asm/Kbuild +++ b/arch/s390/include/asm/Kbuild @@ -10,3 +10,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/score/include/asm/Kbuild b/arch/score/include/asm/Kbuild index f0cdb2cbca4d..16ea15a3e432 100644 --- a/arch/score/include/asm/Kbuild +++ b/arch/score/include/asm/Kbuild @@ -16,3 +16,4 @@ generic-y += serial.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/sh/include/asm/Kbuild b/arch/sh/include/asm/Kbuild index c9bb7932a3d1..d0ea768d15ae 100644 --- a/arch/sh/include/asm/Kbuild +++ b/arch/sh/include/asm/Kbuild @@ -41,3 +41,4 @@ generic-y += ucontext.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/sparc/include/asm/Kbuild b/arch/sparc/include/asm/Kbuild index 79664d10e63b..0e7663749c97 100644 --- a/arch/sparc/include/asm/Kbuild +++ b/arch/sparc/include/asm/Kbuild @@ -24,3 +24,4 @@ generic-y += types.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/tile/include/asm/Kbuild b/arch/tile/include/asm/Kbuild index 951fa4be571d..8f3e38c981cd 100644 --- a/arch/tile/include/asm/Kbuild +++ b/arch/tile/include/asm/Kbuild @@ -43,3 +43,4 @@ generic-y += types.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/um/include/asm/Kbuild b/arch/um/include/asm/Kbuild index 99be54949b99..eea5dd842992 100644 --- a/arch/um/include/asm/Kbuild +++ b/arch/um/include/asm/Kbuild @@ -29,3 +29,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/unicore32/include/asm/Kbuild b/arch/unicore32/include/asm/Kbuild index 6c35905fe371..5c31eafbf1fd 100644 --- a/arch/unicore32/include/asm/Kbuild +++ b/arch/unicore32/include/asm/Kbuild @@ -65,3 +65,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/x86/include/asm/Kbuild b/arch/x86/include/asm/Kbuild index f790756fdb48..cd0fa76b32a3 100644 --- a/arch/x86/include/asm/Kbuild +++ b/arch/x86/include/asm/Kbuild @@ -18,3 +18,4 @@ generic-y += mcs_spinlock.h generic-y += mm-arch-hooks.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/x86/tools/relocs.c b/arch/x86/tools/relocs.c index c215db049920..45733a182ac2 100644 --- a/arch/x86/tools/relocs.c +++ b/arch/x86/tools/relocs.c @@ -69,7 +69,9 @@ static const char * const sym_regex_kernel[S_NSYMTYPES] = { "__initramfs_start|" "(jiffies|jiffies_64)|" ".rodata.rng.*|" + ".rodata.tbl.*|" ".init.text.rng.*|" + ".init.text.tbl.*|" #if ELF_BITS = 64 "__per_cpu_load|" "init_per_cpu__.*|" diff --git a/arch/xtensa/include/asm/Kbuild b/arch/xtensa/include/asm/Kbuild index 221b6b652500..ae48f8fd9212 100644 --- a/arch/xtensa/include/asm/Kbuild +++ b/arch/xtensa/include/asm/Kbuild @@ -33,3 +33,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/include/asm-generic/ranges.h b/include/asm-generic/ranges.h index 74cd941aa2f8..8cf21a1497c6 100644 --- a/include/asm-generic/ranges.h +++ b/include/asm-generic/ranges.h @@ -86,4 +86,18 @@ #endif /* __ASSEMBLY__ */ +#ifdef __ASSEMBLER__ + +#ifndef DEFINE_SECTION_RANGE +#define DEFINE_SECTION_RANGE(section, name) \ + push_section_rng_level(section, name,,) ; \ + .globl name ; \ +name: ; \ + .popsection \ + \ + push_section_rng_level(section, name, ~,) ; \ + .popsection +#endif +#endif /* __ASSEMBLER__ */ + #endif /* _ASM_GENERIC_RANGES_H_ */ diff --git a/include/asm-generic/tables.h b/include/asm-generic/tables.h new file mode 100644 index 000000000000..43cd03a83bd2 --- /dev/null +++ b/include/asm-generic/tables.h @@ -0,0 +1,50 @@ +#ifndef _ASM_GENERIC_TABLES_H_ +#define _ASM_GENERIC_TABLES_H_ +/* + * Linux linker tables + * + * Copyright (C) 2016 Luis R. Rodriguez + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of copyleft-next (version 0.3.1 or later) as published + * at http://copyleft-next.org/. + */ +#include + +#define SECTION_TBL(section, name, level) \ + SECTION_CORE(section, tbl, name, level) + +#define SECTION_TBL_ALL(section) \ + SECTION_CORE_ALL(section,tbl) + +/* Some toolchains are buggy, let them override */ +#ifndef SECTION_TBL_RO +# define SECTION_TBL_RO SECTION_RODATA +#endif + +#ifndef set_section_tbl +# define set_section_tbl(section, name, level, flags) \ + set_section_core(section, tbl, name, level, flags) +#endif + +#ifndef set_section_tbl_any +# define set_section_tbl_any(section, name, flags) \ + set_section_core(section, tbl, name, SECTION_ORDER_ANY, flags) +#endif + +#ifndef set_section_tbl_type +# define set_section_tbl_type(section, name, level, flags, type) \ + set_section_core_type(section, tbl, name, level, flags, type) +#endif + +#ifndef push_section_tbl +# define push_section_tbl(section, name, level, flags) \ + push_section_core(section, tbl, name, level, flags) +#endif + +#ifndef push_section_tbl_any +# define push_section_tbl_any(section, name, flags) \ + push_section_core(section, tbl, name, SECTION_ORDER_ANY, flags) +#endif + +#endif /* _ASM_GENERIC_TABLES_H_ */ diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index ad843555e6a4..4b6a3d820883 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -57,6 +57,7 @@ #include #include #include +#include /* Align . to a 8 byte boundary equals to maximum function alignment. */ #define ALIGN_FUNCTION() . = ALIGN(8) @@ -202,6 +203,7 @@ #define DATA_DATA \ *(SECTION_DATA) \ *(SORT(SECTION_RNG_ALL(SECTION_DATA))) \ + *(SORT(SECTION_TBL_ALL(SECTION_DATA))) \ *(SECTION_REF_DATA) \ *(.data..shared_aligned) /* percpu related */ \ MEM_KEEP(init.data) \ @@ -269,6 +271,7 @@ VMLINUX_SYMBOL(__start_rodata) = .; \ *(SECTION_RODATA) \ *(SORT(SECTION_RNG_ALL(SECTION_RODATA))) \ + *(SORT(SECTION_TBL_ALL(SECTION_RODATA))) \ *(SECTION_ALL(SECTION_RODATA)) \ RO_AFTER_INIT_DATA /* Read only after init */ \ *(__vermagic) /* Kernel version magic */ \ @@ -439,6 +442,7 @@ ALIGN_FUNCTION(); \ *(.text.hot SECTION_TEXT) \ *(SORT(SECTION_RNG_ALL(SECTION_TEXT))) \ + *(SORT(SECTION_TBL_ALL(SECTION_TEXT))) \ *(.text.fixup .text.unlikely) \ *(SECTION_REF) \ MEM_KEEP(init.text) \ @@ -536,6 +540,7 @@ #define INIT_DATA \ *(SECTION_INIT_DATA) \ *(SORT(SECTION_RNG_ALL(SECTION_INIT_DATA))) \ + *(SORT(SECTION_TBL_ALL(SECTION_INIT_DATA))) \ MEM_DISCARD(init.data) \ KERNEL_CTORS() \ MCOUNT_REC() \ @@ -559,6 +564,7 @@ #define INIT_TEXT \ *(SECTION_INIT) \ *(SORT(SECTION_RNG_ALL(SECTION_INIT))) \ + *(SORT(SECTION_TBL_ALL(SECTION_INIT))) \ *(.text.startup) \ MEM_DISCARD(init.text) diff --git a/include/linux/tables.h b/include/linux/tables.h new file mode 100644 index 000000000000..423827eafb52 --- /dev/null +++ b/include/linux/tables.h @@ -0,0 +1,567 @@ +#ifndef _LINUX_LINKER_TABLES_H +#define _LINUX_LINKER_TABLES_H +/* + * Linux linker tables + * + * Copyright (C) 2016 Luis R. Rodriguez + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of copyleft-next (version 0.3.1 or later) as published + * at http://copyleft-next.org/. + */ +#include +#include +#include + +#ifndef __ASSEMBLY__ + +/** + * DOC: Introduction + * + * A linker table is a data structure that is stitched together from items in + * multiple object files for the purpose of selective placement into standard + * or architecture specific ELF sections. What section is used is utility + * specific. Linux has historically implicitly used linker tables, however they + * were all built in an adhoc manner which requires linker script modifications + * per architecture. The linker table API provides a general facility so that + * data structures can be stitched together and placed into Linux ELF sections + * by only changing C or asm code in an architecture agnostic form. + * + * Linker tables help you group together related data and code in an efficient + * way. Linker tables can be used to help simplify init sequences, they + * enable linker build time selective sorting (disabled options get ignored), + * and can optionally also be used to help you avoid code bit-rot due to + * overuse of #ifdef. + */ + +/** + * DOC: Linker table provenance + * + * The Linux implementation of linker tables was inspired by the iPXE linker + * table's solution (iPXE commit 67a10ef000cb7 "[contrib] Add rom-o-matic to + * contrib "[0]). To see how this code evolved refer to the out of tree + * userspace linker-table tree [1]. + * + * Contrary to iPXE's solution which strives to force compilation of + * everything using linker tables, Linux's solution allows for developers to be + * selective over where one wishes to force compilation, this then is just an + * optional feature for the Linux linker table solution. The main advantages + * of using linker-tables then are: + * + * - Avoiding modifying architecture linker scripts + * - Simplifying initialization code + * - Avoiding the code bit-rot problem + * + * [0] git://git.ipxe.org/ipxe.git + * + * [1] https://git.kernel.org/cgit/linux/kernel/git/mcgrof/linker-tables.git/ + */ + +/** + * DOC: Avoids modifying architecture linker scripts + * + * Linker tables enable you to avoid modifying architecture linker scripts + * since it has its has extended each core Linux section with a respective + * linker table entry in `include/asm-generic/vmlinux.lds.h`. When you add new + * linker table entry you aggregate them `into` the existing linker table core + * section. + */ + +/** + * DOC: How linker tables simplify initialization code + * + * Traditionally, we would implement features in C code as follows: + * + * foo_init(); + * + * You'd then have a foo.h which would have:: + * + * #ifndef CONFIG_FOO + * static inline void foo_init(void) { } + * #endif + * + * With linker tables this is no longer necessary as your init routines would + * be implicit, you'd instead call: + * + * call_init_fns(); + * + * call_init_fns() would call all functions present in your init table and if + * and only if foo.o gets linked in, then its initialisation function will be + * called. + * + * The linker script takes care of assembling the tables for us. All of our + * table sections have names of the format `SECTION_NAME.tbl.NAME.N`. Here + * `SECTION_NAME` is one of the standard sections in:: + * + * include/asm-generic/section-core.h + * + * and `NAME` designates the specific use case for the linker table, the table. + * `N` is a digit used to help sort entries in the section. `N=` (empty string) + * is reserved for the symbol indicating `table start`, and `N=~` is reserved + * for the symbol indicating `table end`. In order for the call_init_fns() to + * work behind the scenes the custom linker script would need to define the + * beginning of the table, the end of the table, and in between it should use + * ``SORT()`` to give order to the section. Typically this would require custom + * linker script modifications however since linker table are already defined + * in ``include/asm-generic/vmlinux.lds.h`` as documented above each new linker + * table definition added in C code folds into the respective core Linux + * section linker table. + * + * This is also done to support all architectures. All that is needed then is + * to ensure a respective common linker table entry is added to the shared + * ``include/asm-generic/vmlinux.lds.h``. There should be a respective:: + * + * *(SORT(SECTION_TBL_ALL(SECTION_NAME))) + * + * entry for each type of supported section there. If your `SECTION_NAME` + * is not yet supported, consider adding support for it. + * + * Linker tables support ordering entries, it does this using a digit which + * is eventually added as a postfix to a section entry name, we refer to this + * as the linker table ``order-level``. If order is not important to your + * linker table entry you can use the special ``SECTION_ORDER_ANY``. After + * ``order-level``, the next contributing factor to order is the order of the + * code in the C file, and the order of the objects in the Makefile. Using an + * ``order-level`` then should not really be needed in most cases, its use + * however enables to compartamentalize code into tables where ordering through + * C file or through the Makefile would otherwise be very difficult or if one + * wanted to enable very specific initialization semantics. + * + * As an example, suppose that we want to create a "frobnicator" + * feature framework, and allow for several independent modules to + * provide frobnicating services. Then we would create a frob.h + * header file containing e.g.:: + * + * struct frobnicator { + * const char *name; + * void (*frob) (void); + * }; + * + * DECLARE_LINKTABLE(struct frobnicator, frobnicator_fns); + * + * Any module providing frobnicating services would look something + * like:: + * + * #include "frob.h" + * + * static void my_frob(void) { + * ... Do my frobnicating + * } + * + * LINKTABLE_INIT_DATA(frobnicator_fns, all) my_frobnicator = { + * .name = "my_frob", + * .frob = my_frob, + * }; + * + * The central frobnicator code, say in frob.c, would use the frobnicating + * modules as follows:: + * + * #include "frob.h" + * + * void frob_all(void) { + * struct frobnicator *f; + * + * LINKTABLE_FOR_EACH(f, frobnicator_fns) { + * pr_info("Calling frobnicator %s\n", frob->name); + * f->frob(); + * } + * } + */ + +/** + * DOC: Linker table module support + * + * Modules can use linker tables, however the linker table definition + * must be built-in to the kernel. That is, the code that implements + * ``DEFINE_LINKTABLE*()`` must be built-in, and modular code cannot add + * more items in to the table, unless ``kernel/module.c`` find_module_sections() + * and module-common.lds.S are updated accordingly with a respective + * module notifier to account for updates. This restriction may be enhanced + * in the future. + */ + +/** + * DOC: Linker table helpers + * + * These are helpers for linker tables. + */ + +/** + * LINKTABLE_ADDR_WITHIN - returns true if address is in range + * + * @tbl: linker table + * @addr: address to query for + * + * Returns true if the address is part of the linker table. + */ +#define LINKTABLE_ADDR_WITHIN(tbl, addr) \ + (addr >= (unsigned long) LINUX_SECTION_START(tbl) && \ + addr < (unsigned long) LINUX_SECTION_END(tbl)) + +/** + * DOC: Constructing linker tables + * + * Linker tables constructors are used to build an entry into a linker table. + * Linker table constructors exist for each type of supported section. + * + * You have weak and regular type of link table entry constructors. + */ + +/** + * DOC: Weak linker tables constructors + * + * The weak attribute is desirable if you want an entry you can replace at + * link time. A very special use case for linker tables is the first entry. + * A weak attribute is used for the first entry to ensure that this entry's + * address matches the end address of the table when the linker table is + * emtpy, but will also point to the first real entry of the table once not + * empty. When the first entry is linked in, it takes place of the first entry. + */ + +/** + * LINKTABLE_WEAK - Constructs a weak linker table entry for data + * + * @name: linker table name + * @level: order level + * + * Constructs a weak linker table for data. + */ +#define LINKTABLE_WEAK(name, level) \ + __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_DATA, \ + name, level)))) + +/** + * LINKTABLE_TEXT_WEAK - Constructs a weak linker table entry for execution + * + * @name: linker table name + * @level: order level + * + * Constructs a weak linker table for code execution. These will be + * read-only. + */ +#define LINKTABLE_TEXT_WEAK(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_TEXT, \ + name, level)))) + +/** + * LINKTABLE_RO_WEAK - Constructs a weak read-only linker table entry + * + * @name: linker table name + * @level: order level + * + * Constructs a weak linker table which only requires read-only access. + */ +#define LINKTABLE_RO_WEAK(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_TBL_RO, \ + name, level)))) + +/** + * LINKTABLE_INIT_WEAK - Constructs a weak linker table entry for init code + * + * @name: linker table name + * @level: order level + * + * Constructs a weak linker table for execution. use at init. + */ +#define LINKTABLE_INIT_WEAK(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_INIT, \ + name, level)))) + +/** + * LINKTABLE_INIT_DATA_WEAK - Constructs a weak linker table entry for initdata + * + * @name: linker table name + * @level: order level + * + * Constructs a weak linker table for data during init. + */ +#define LINKTABLE_INIT_DATA_WEAK(name, level) \ + __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_INIT_DATA, \ + name, level)))) + +/** + * DOC: Regular linker linker table constructors + * + * Regular constructors are expected to be used for valid linker table entries. + * Valid uses of weak entries other than the beginning and is currently + * untested but should in theory work. + */ + +/** + * LINKTABLE - Declares a data linker table entry + * + * @name: linker table name + * @level: order level + * + * Declares a data linker table entry. These are read-write. + */ +#define LINKTABLE(name, level) \ + __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_DATA, \ + name, level)))) + +/** + * LINKTABLE_TEXT - Declares a linker table entry for execution + * + * @name: linker table name + * @level: order level + * + * Declares a linker table to be used for execution. + */ +#define LINKTABLE_TEXT(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_TEXT, \ + name, level)))) + +/** + * LINKTABLE_RO - Declares a read-only linker table entry. + * + * @name: linker table name + * @level: order level + * + * Declares a linker table which only requires read-only access. Contrary + * to LINKTABLE_RO_WEAK() which uses SECTION_RODATA this helper uses the + * section SECTION_TBL_RO here due to possible toolchains bug on some + * architectures, for instance the c6x architicture stuffs non-weak data + * into different sections other than the one intended. + */ +#define LINKTABLE_RO(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_TBL_RO, \ + name, level)))) + +/** + * LINKTABLE_INIT - Declares a linker table entry to be used on init. + * + * @name: linker table name + * @level: order level + * + * Declares a linker table entry for execution use during init. + */ +#define LINKTABLE_INIT(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + __aligned__(LINUX_SECTION_ALIGN_FUNC), \ + section(SECTION_TBL(SECTION_INIT, \ + name, level)))) + +/** + * LINKTABLE_INIT_DATA - Declares a linker table entry to be used on init data. + * + * @name: linker table name + * @level: order level + * + * Declares a linker table entry for data during init. + */ +#define LINKTABLE_INIT_DATA(name, level) \ + __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_INIT_DATA, \ + name, level)))) + +/** + * DOC: Declaring Linker tables + * + * Declarers are used to help code access the linker tables. Typically + * header files for subsystems would declare the linker tables to enable + * easy access to add new entries, and to iterate over the list of table. + * There are only two declarers needed given that the section association + * is done by the definition of the linker table using ``DEFINE_LINKTABLE*()`` + * helpers. + */ + + +/** + * DECLARE_LINKTABLE - Declares a data linker table entry + * + * @type: data type + * @name: table name + * + * Declares a data linker table entry. + */ +#define DECLARE_LINKTABLE(type, name) \ + DECLARE_LINUX_SECTION(type, name) + +/** + * DECLARE_LINKTABLE_RO - Declares a read-only linker table entry + * + * @type: data type + * @name: table name + * + * Declares a read-only linker table entry. + */ +#define DECLARE_LINKTABLE_RO(type, name) \ + DECLARE_LINUX_SECTION_RO(type, name) + +/** + * DOC: Defining Linker tables + * + * Linker tables are defined in the code that takes ownership over + * the linker table. This is typically done in the same code that is in + * charge of iterating over the linker table as well. + */ + +/** + * DEFINE_LINKTABLE - Defines a linker table for data + * + * @type: data type + * @name: table name + * + * Defines a linker table which used for data. + */ +#define DEFINE_LINKTABLE(type, name) \ + DECLARE_LINKTABLE(type, name); \ + LINKTABLE_WEAK(name,) VMLINUX_SYMBOL(name)[0] = {}; \ + LINKTABLE(name, ~) VMLINUX_SYMBOL(name##__end)[0] = {} + +/** + * DEFINE_LINKTABLE_TEXT - Declares linker table entry for exectuion + * + * @type: data type + * @name: table name + * + * Declares a linker table entry for execution. + */ +#define DEFINE_LINKTABLE_TEXT(type, name) \ + DECLARE_LINKTABLE_RO(type, name); \ + LINKTABLE_TEXT_WEAK(name,) VMLINUX_SYMBOL(name)[0] = {}; \ + LINKTABLE_TEXT(name, ~) VMLINUX_SYMBOL(name##__end)[0] = {} + +/** + * DEFINE_LINKTABLE_RO - Defines a read-only linker table + * + * @type: data type + * @name: table name + * + * Defines a linker table which we know only requires read-only access. + */ +#define DEFINE_LINKTABLE_RO(type, name) \ + DECLARE_LINKTABLE_RO(type, name); \ + LINKTABLE_RO_WEAK(name,) VMLINUX_SYMBOL(name)[0] = {}; \ + LINKTABLE_RO(name, ~) VMLINUX_SYMBOL(name##__end)[0] = {} + +/** + * DEFINE_LINKTABLE_INIT - Defines an init time linker table for execution + * + * @type: data type + * @name: table name + * + * Defines a linker table. If you are adding a new type you should + * enable ``CONFIG_DEBUG_SECTION_MISMATCH`` and ensure routines that make + * use of the linker tables get a respective __ref tag. + */ +#define DEFINE_LINKTABLE_INIT(type, name) \ + DECLARE_LINKTABLE(type, name); \ + LINKTABLE_INIT_WEAK(name,) VMLINUX_SYMBOL(name)[0] = {}; \ + LINKTABLE_INIT(name, ~) VMLINUX_SYMBOL(name##__end)[0] = {} + +/** + * DEFINE_LINKTABLE_INIT_DATA - Defines an init time linker table for data + * + * @type: data type + * @name: table name + * + * Defines a linker table for init data. If you are adding a new type you + * should enable ``CONFIG_DEBUG_SECTION_MISMATCH`` and ensure routines that + * make use of the linker tables get a respective __ref tag. + */ +#define DEFINE_LINKTABLE_INIT_DATA(type, name) \ + DECLARE_LINKTABLE(type, name); \ + LINKTABLE_INIT_DATA_WEAK(name,) VMLINUX_SYMBOL(name)[0] = {}; \ + LINKTABLE_INIT_DATA(name, ~) VMLINUX_SYMBOL(name##__end)[0] = {} + +/** + * DOC: Iterating over Linker tables + * + * To make use of the linker tables you want to be able to iterate over + * them. This section documents the different iterators available. + */ + +/** + * LINKTABLE_FOR_EACH - iterate through all entries within a linker table + * + * @pointer: entry pointer + * @tbl: linker table + * + * Example usage:: + * + * struct frobnicator *frob; + * + * LINKTABLE_FOR_EACH(frob, frobnicator_fns) { + * ... + * } + */ + +#define LINKTABLE_FOR_EACH(pointer, tbl) \ + for (pointer = LINUX_SECTION_START(tbl); \ + pointer < LINUX_SECTION_END(tbl); \ + pointer++) + +/** + * LINKTABLE_RUN_ALL - iterate and run through all entries on a linker table + * + * @tbl: linker table + * @func: structure name for the function name we want to call. + * @args...: arguments to pass to func + * + * Example usage:: + * + * LINKTABLE_RUN_ALL(frobnicator_fns, some_run,); + */ +#define LINKTABLE_RUN_ALL(tbl, func, args...) \ +do { \ + size_t i; \ + for (i = 0; i < LINUX_SECTION_SIZE(tbl); i++) \ + (VMLINUX_SYMBOL(tbl)[i]).func (args); \ +} while (0) + +/** + * LINKTABLE_RUN_ERR - run each linker table entry func and return error if any + * + * @tbl: linker table + * @func: structure name for the function name we want to call. + * @args...: arguments to pass to func + * + * Example usage:: + * + * unsigned int err = LINKTABLE_RUN_ERR(frobnicator_fns, some_run,); + */ +#define LINKTABLE_RUN_ERR(tbl, func, args...) \ +({ \ + size_t i; \ + int err = 0; \ + for (i = 0; !err && i < LINUX_SECTION_SIZE(tbl); i++) \ + err = (VMLINUX_SYMBOL(tbl)[i]).func (args); \ + err; \ +}) + +#endif /* __ASSEMBLY__ */ + +#endif /* _LINUX_LINKER_TABLES_H */ diff --git a/scripts/Makefile.clean b/scripts/Makefile.clean index 50616ea25131..2b54546237d6 100644 --- a/scripts/Makefile.clean +++ b/scripts/Makefile.clean @@ -36,6 +36,8 @@ subdir-ymn := $(addprefix $(obj)/,$(subdir-ymn)) # directory __clean-files := $(extra-y) $(extra-m) $(extra-) \ + $(force-obj-y) $(force-obj-m) $(force-obj-) \ + $(force-lib-y) $(force-lib-m) $(force-lib-) \ $(always) $(targets) $(clean-files) \ $(host-progs) \ $(hostprogs-y) $(hostprogs-m) $(hostprogs-) \ -- 2.9.2 From mboxrd@z Thu Jan 1 00:00:00 1970 From: mcgrof@kernel.org Subject: [PATCH v4 07/16] tables.h: add linker table support Date: Fri, 19 Aug 2016 14:32:56 -0700 Message-ID: <1471642385-5629-8-git-send-email-mcgrof@kernel.org> References: <1471642385-5629-1-git-send-email-mcgrof@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1471642385-5629-1-git-send-email-mcgrof@kernel.org> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: hpa@zytor.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, linux@arm.linux.org.uk, mhiramat@kernel.org, masami.hiramatsu.pt@hitachi.com, jbaron@akamai.com, heiko.carstens@de.ibm.com, ananth@linux.vnet.ibm.com, anil.s.keshavamurthy@intel.com, davem@davemloft.net, realmz6@gmail.com Cc: gnomes@lxorguk.ukuu.org.uk, linux-ia64@vger.kernel.org, jkosina@suse.cz, benh@kernel.crashing.org, ming.lei@canonical.com, linux@rasmusvillemoes.dk, platform-driver-x86@vger.kernel.org, James.Bottomley@HansenPartnership.com, paul.gortmaker@windriver.com, paulus@samba.org, sparclinux@vger.kernel.org, mchehab@osg.samsung.com, linux-arch@vger.kernel.org, markus.heiser@darmarit.de, xen-devel@lists.xensource.com, msalter@redhat.com, linux-sh@vger.kernel.org, mpe@ellerman.id.au, x86@kernel.org, fontana@sharpeleven.org, linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, dvhart@infradead.org, dwmw2@infradead.org, linux-xtensa@linux-xtensa.org, pali.rohar@gmail.com, keescook@chromium.org, arnd@arndb.de, jani.nikula@intel.com, will.deacon@arm.com, rusty@rustcorp.com.au, rostedt@goodmis.org, acme@redhat.com, ak@linux.intel.com, andriy.shevchenko@linux.intel.com, mcb30@ip List-Id: platform-driver-x86.vger.kernel.org RnJvbTogIkx1aXMgUi4gUm9kcmlndWV6IiA8bWNncm9mQGtlcm5lbC5vcmc+CgpBIGxpbmtlciB0 YWJsZSBpcyBhIGRhdGEgc3RydWN0dXJlIHRoYXQgaXMgc3RpdGNoZWQgdG9nZXRoZXIgZnJvbSBp dGVtcwppbiBtdWx0aXBsZSBvYmplY3QgZmlsZXMuIExpbnV4IGhhcyBoaXN0b3JpY2FsbHkgaW1w bGljaXRseSB1c2VkIGxpbmtlcgp0YWJsZXMgZm9yIGFnZXMsIGhvd2V2ZXIgdGhleSB3ZXJlIGFs bCBidWlsdCBpbiBhbiBhZGhvYyBtYW5uZXIgd2hpY2gKcmVxdWlyZXMgbGlua2VyIHNjcmlwdCBt b2RpZmljYXRpb25zLCBwZXIgYXJjaGl0ZWN0dXJlLiBUaGlzIGFkZHMgYQpnZW5lcmFsIGxpbmtl ciB0YWJsZSBzb2x1dGlvbiBzbyB0aGF0IGEgbmV3IGxpbmtlciB0YWJsZSBjYW4gYmUKaW1wbGVt ZW50ZWQgYnkgY2hhbmdpbmcgQyBjb2RlIG9ubHkuIFRoZSBMaW51eCBsaW5rZXIgdGFibGUgd2Fz Cmluc3BpcmVkIGJ5IE1pY2hhZWwgQnJvd24ncyBpUFhFJ3MgbGlua2VyIHRhYmxlIHNvbHV0aW9u LCBpdCBoYXMgYmVlbgpiZWVuIGNvbXBsZXRlbHkgcmUtd3JpdHRlbiBhbmQgYWRhcHRlZCBmb3Ig aW50ZWdyYXRpb24gYW5kIHVzZSBvbiBMaW51eC4KClRoZSBzYW1lIHBoaWxvc29waHkgaXMgYm9y cm93ZWQsIGV4dGVuZGVkIGFuZCBmdXJ0aGVyIHNpbXBsaWZpZWQ6CgpMaW5rZXIgdGFibGVzIGVu YWJsZSBhbiBleHRyZW1lbHkgbGlnaHQgd2VpZ2h0IGxpbmtlciBidWlsZCB0aW1lCnNvbHV0aW9u IGZvciBmZWF0dXJlIG9yZGVyaW5nIGFuZCBzZWxlY3Rpb24sIHRoaXMgY2FuIGhlbHAgdG8gYm90 aApzaW1wbGlmeSBpbml0IHNlcXVlbmNlcyBpbiBhIGdlbmVyaWMgZmFzaGlvbiBhbmQgaGVscHMg YXZvaWRpbmcgY29kZQpiaXQtcm90dGluZyB3aGVuIGRlc2lyYWJsZS4gRnVydGhlciBjaGFuZ2Vz IHdpbGwgYmUgYWRkZWQgbGF0ZXIKd2hpY2ggd2lsbCBtYWtlIG1vcmUgZXZpZGVudCBob3cgY29k ZSBiaXQgcm90IGNhbiBiZSBhdm9pZGVkIHVzaW5nCmxpbmtlciB0YWJsZXMuCgp2NDoKCm8gU3Bs aXQgb3V0IGtidWlsZCBhZGRpdGlvbnMgdG8gaGVscCB3aXRoIGNvZGUgYml0IHJvdCBpbnRvCiAg aXRzIG93biBwYXRjaApvIHRvbnMgb2YgZG9jdW1lbnRhdGlvbiBsb3ZlCm8gZml4IGFyY2gveDg2 L3Rvb2xzL3JlbG9jcy5jIHR5cG8gLSB3aGljaCBjYXVzZWQgY29tcGlsYXRpb24gaXNzdWVzCiAg b24gb2xkIHRvb2xjaGFpbnMKbyBhZGQgYzZ4IHRvb2xjaGFpbiB3b3JrIGFyb3VuZCBhcyBkaXNj dXNzZWQgd2l0aCBNYXJrIFNhbHRlcgpvIHNwcmlua2xlIGEgZmV3IG1vcmUgbmVlZGVkIFZNTElO VVhfU1lNQk9MKCkgLSBmaXhlcwogIGNvbXBpbGF0aW9uIG9uIGJsYWNrZmluCm8gc3VnZ2VzdGVk IG5hbWUgY2hhbmdlcyBieSBib3JpczoKLSAlcy9TRUNUSU9OX1RZUEVfUkFOR0VTL3JuZy9nCi0g JXMvU0VDVElPTl9UWVBFL1NFQ1RJT05fQ09SRS9nCi0gJXMvc2VjdGlvbl90eXBlX2FzbXR5cGUv c2VjdGlvbl9jb3JlX3R5cGUvZwotICVzL3NlY3Rpb25fdHlwZS9zZWN0aW9uX2NvcmUvZwotICVz L3NlY3Rpb25fcm5nL3NldF9zZWN0aW9uX3JuZy9nCi0gRHJvcCBERUNMQVJFX1NFQ1RJT05fVEJM KCkgLS0gdGhpcyBpcyBhbiBhc20gZXF1aXZhbGVudAogIERFRklORV9MSU5LVEFCTEUoKSAtLSB0 aGlzIGhvd2V2ZXIgaXMgbm90IHVzZWQgeWV0LCBhbmQgaXQgcmVxdWlyZXMKICBhIGJpdCBtb3Jl IHdvcmsgdG8gbWF0Y2ggdGhlIEMgY29kZSBkZWZpbml0aW9ucy4KbyBkcm9wIHRvb2xzL2luY2x1 ZGUvbGludXgvc2VjdGlvbnMuaCBpbiBmYXZvciBvZiB0aGUgbW9yZSBwb3B1bGFyIG9wZW4KICBj b2RpbmcgdGhlIG5hbWVzIGZvciB0b29scwpvIGV4cGFuZCBkb2N1bWVudGF0aW9uIHRvIGluY2x1 ZGUgbW9kdWxlIHN1cHBvcnQKbyBhZGQgbWFpbnRhbmVycwpvIFVzZSBnZW5lcmljLXkKbyBtb3Zl IC50ZXh0LnRibCBiZWZvcmUgdW5saWtlbHkgdG8gbWF0Y2ggdGhlIG90aGVyIHNlY3Rpb25zCgp2 MzoKCm8gYWRkcmVzc2VkIGluaXRpYWwgbW9kdWxhciBzdXBwb3J0IHRlc3QgY2FzZXMKbyBhZGRl ZCBnZW5lcmljIGFzbSBtYWNyb3Mgc28gbGlua2VyIHRhYmxlcyBjYW4gYmUgdXNlZCBpbgogIGFz bSBjb2RlIC8gQyBhc20gY2FsbHMKbyBzZWN0aW9uIHJhbmdlcyBhcmUgbm93IHNwbGl0IHVwIGlu dG8gdGhlaXIgb3duIHNldCBvZiBmaWxlcwpvIHVzZSBhc20vc2VjdGlvbnMuaCBpbnN0ZWFkIG9m IGxpbnV4L3NlY3Rpb25zLmggZm9yIHRoZSBsaW5rZXIKICBzY3JpcHQKbyBhZGQgYSBzZWN0aW9u cy5oIGZpbGUgZm9yIGVhY2ggYXJjaGl0ZWN0dXJlIHRoYXQgd2FzIG1pc3Npbmcgb25lLAogIHRo aXMgaXMgbmVlZGVkIG5vdyBhcyB3ZSdsbCBiZSByZWx5aW5nIG9uIHNlY3Rpb25zLmggZm9yIGN1 c3RvbQogIHNlY3Rpb24gdHlwZXMgaW4gY29kZSByYXRoZXIgdGhhbiBjdXN0b20gYXJjaGl0ZWN0 dXJlIHNwZWNpZmljCiAgbGlua2VyIHNjcmlwdCBoYWNrcy4KbyBmdWxsIHJld3JpdGUgYXQgdGhp cyBwb2ludCwgZGVjaWRlZCB0byBwaWNrIGNvcHlsZWZ0LW5leHQgbGljZW5zZQogIGZvciB0aGlz IHdvcmsKCnYyOgoKbyBtb2RpZmllZCBjb21wbGV0ZWx5IHRvIG1hdGNoIGZlZWRiYWNrIGJ5IGNv bW11bml0eSwgbWFkZSBlcXVpdmFsZW50CiAgbW9kaWZpY2F0aW9ucyB0byB1c2Vyc3BhY2Ugc29s dXRpb24uIFRoaXMgaXMgcHJldHR5IG11Y2ggYSBjb21wbGV0ZQogIHJld3JpdGUgb2YgaG93IHdl IHByZXNlbnQgYW5kIHVzZSBsaW5rZXIgdGFibGVzLiBCeSB1c2luZyBzdGFuZGFyZAogIHNlY3Rp b25zIHdlIG5vIGxvbmdlciBoYXZlIHRvIG1ha2UgY3VzdG9tIGxpbmtlciBzY3JpcHQgZXh0ZW5z aW9ucwogIGZvciBlYWNoIG5ldyBsaW5rZXIgdGFibGUgc29sdXRpb24sIHlvdSBqdXN0IHBpY2sg YSBsaW5rZXIgdGFibGUKICB0eXBlIGJ5IHNlY3Rpb24gdHlwZS4KbyBleHRlbmQgZG9jdW1lbnRp b24gY29uc2lkZXJhYmx5LCBpbmNsdWRpbmcgdXNlIG9mIGtkb2MKbyBkcm9wIElDQyBoYWNrcyBw ZXIgcG9wdWxhciByZXF1ZXN0IHRvIGlnbm9yZSBzdWNoIGlzc3VlcyBmb3Igbm93Cm8gdXNlIHNl Y3Rpb25zLmggLSB0aGlzIGxldHMgdXMgc3RyZWFtbGluZSBhIGNsZWFuIHVzZSBjYXNlIG9mCiAg d2VsbCBkb2N1bWVudGVkIHNlY3Rpb25zLiBUbyBoZWxwIGZ1cnRoZXIgd2l0aCB0aGlzIG1ha2Ug dXNlIG9mCiAgU0VDVElPTl9UQkwoKSB0byBhbGxvdyB1c2Ugb2YgdGhlc2UgaW4gY29kZSBhbmQg U0VDVElPTl9UQkxfQUxMKCkKICBvbiBsaW5rZXIgc2NyaXB0cywgYXMgd2VsbCBhcyBTRUNUSU9O X1RCTF9BTExfU1RSKCkgb24gcmVsb2NzLmMKICB3aGVuIG5lZWRlZC4KCkNjOiBNaWNoYWVsIEJy b3duIDxtY2IzMEBpcHhlLm9yZz4KU2lnbmVkLW9mZi1ieTogTHVpcyBSLiBSb2RyaWd1ZXogPG1j Z3JvZkBrZXJuZWwub3JnPgotLS0KIERvY3VtZW50YXRpb24vc2VjdGlvbnMvaW5kZXgucnN0ICAg ICAgICAgfCAgIDEgKwogRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9saW5rZXItdGFibGVzLnJzdCB8 IDE4NyArKysrKysrKysrCiBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHwgIDEyICsKIGFyY2gvYWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgfCAgIDEg KwogYXJjaC9hcmMvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgICB8ICAgMSArCiBhcmNo L2FybS9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvYXJtNjQv aW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9hdnIzMi9pbmNsdWRl L2FzbS9LYnVpbGQgICAgICAgICAgICB8ICAgMSArCiBhcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNt L0tidWlsZCAgICAgICAgIHwgICAxICsKIGFyY2gvYzZ4L2luY2x1ZGUvYXNtL3RhYmxlcy5oICAg ICAgICAgICAgfCAgMjYgKysKIGFyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAg ICAgfCAgIDEgKwogYXJjaC9mcnYvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgICB8ICAg MSArCiBhcmNoL2g4MzAwL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgIHwgICAxICsKIGFy Y2gvaGV4YWdvbi9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgfCAgIDEgKwogYXJjaC9pYTY0 L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICB8ICAgMSArCiBhcmNoL20zMnIvaW5jbHVk ZS9hc20vS2J1aWxkICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvbTY4ay9pbmNsdWRlL2FzbS9L YnVpbGQgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9tZXRhZy9pbmNsdWRlL2FzbS9LYnVpbGQg ICAgICAgICAgICB8ICAgMSArCiBhcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vS2J1aWxkICAg ICAgIHwgICAxICsKIGFyY2gvbWlwcy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgfCAg IDEgKwogYXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICB8ICAgMSArCiBh cmNoL25pb3MyL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgIHwgICAxICsKIGFyY2gvb3Bl bnJpc2MvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgfCAgIDEgKwogYXJjaC9wYXJpc2MvaW5j bHVkZS9hc20vS2J1aWxkICAgICAgICAgICB8ICAgMSArCiBhcmNoL3Bvd2VycGMvaW5jbHVkZS9h c20vS2J1aWxkICAgICAgICAgIHwgICAxICsKIGFyY2gvczM5MC9pbmNsdWRlL2FzbS9LYnVpbGQg ICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9zY29yZS9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAg ICAgICB8ICAgMSArCiBhcmNoL3NoL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICAgIHwg ICAxICsKIGFyY2gvc3BhcmMvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgfCAgIDEgKwog YXJjaC90aWxlL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICB8ICAgMSArCiBhcmNoL3Vt L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvdW5pY29yZTMy L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgfCAgIDEgKwogYXJjaC94ODYvaW5jbHVkZS9hc20v S2J1aWxkICAgICAgICAgICAgICB8ICAgMSArCiBhcmNoL3g4Ni90b29scy9yZWxvY3MuYyAgICAg ICAgICAgICAgICAgIHwgICAyICsKIGFyY2gveHRlbnNhL2luY2x1ZGUvYXNtL0tidWlsZCAgICAg ICAgICAgfCAgIDEgKwogaW5jbHVkZS9hc20tZ2VuZXJpYy9yYW5nZXMuaCAgICAgICAgICAgICB8 ICAxNCArCiBpbmNsdWRlL2FzbS1nZW5lcmljL3RhYmxlcy5oICAgICAgICAgICAgIHwgIDUwICsr KwogaW5jbHVkZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oICAgICAgICB8ICAgNiArCiBpbmNs dWRlL2xpbnV4L3RhYmxlcy5oICAgICAgICAgICAgICAgICAgIHwgNTY3ICsrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysKIHNjcmlwdHMvTWFrZWZpbGUuY2xlYW4gICAgICAgICAgICAgICAg ICAgfCAgIDIgKwogNDAgZmlsZXMgY2hhbmdlZCwgODk3IGluc2VydGlvbnMoKykKIGNyZWF0ZSBt b2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL3NlY3Rpb25zL2xpbmtlci10YWJsZXMucnN0CiBjcmVh dGUgbW9kZSAxMDA2NDQgYXJjaC9jNngvaW5jbHVkZS9hc20vdGFibGVzLmgKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBpbmNsdWRlL2FzbS1nZW5lcmljL3RhYmxlcy5oCiBjcmVhdGUgbW9kZSAxMDA2NDQg aW5jbHVkZS9saW51eC90YWJsZXMuaAoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2VjdGlv bnMvaW5kZXgucnN0IGIvRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9pbmRleC5yc3QKaW5kZXggNmRk OTNkZGQ1ZGJlLi40NTE0YzU3MzhiMzMgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vc2VjdGlv bnMvaW5kZXgucnN0CisrKyBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvaW5kZXgucnN0CkBAIC0x MCwzICsxMCw0IEBAIHVzZWQgdGhyb3VnaG91dCB0aGUga2VybmVsIHRvIGhlbHAgZGVjbGFyZSBh bmQgZGVmaW5lIHRoZW0uCiAKICAgIHNlY3Rpb24tY29yZQogICAgcmFuZ2VzCisgICBsaW5rZXIt dGFibGVzCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3NlY3Rpb25zL2xpbmtlci10YWJsZXMu cnN0IGIvRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9saW5rZXItdGFibGVzLnJzdApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmRmMTFjNjMyZGNhNwotLS0gL2Rldi9udWxs CisrKyBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvbGlua2VyLXRhYmxlcy5yc3QKQEAgLTAsMCAr MSwxODcgQEAKKz09PT09PT09PT09PT09PT09PT0KK0xpbnV4IGxpbmtlciB0YWJsZXMKKz09PT09 PT09PT09PT09PT09PT0KKworVGhpcyBkb2N1bWVudHMgTGludXggbGlua2VyIHRhYmxlcywgaXQg ZXhwbGFpbnMgd2hhdCB0aGV5IGFyZSwgd2hlcmUgdGhleQorY2FtZSBmcm9tLCBob3cgdGhleSB3 b3JrLCB0aGUgYmVuZWZpdHMgb2YgdXNpbmcgdGhlbSBhbmQgbW9yZSBpbXBvcnRhbnRseQoraG93 IHlvdSBjYW4gdXNlIHRoZW0uCisKK0Fib3V0IExpbmtlciB0YWJsZXMKKz09PT09PT09PT09PT09 PT09PT0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZG9jOiBJ bnRyb2R1Y3Rpb24KKworTGlua2VyIHRhYmxlIHByb3ZlbmFuY2UKKy0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9s aW51eC90YWJsZXMuaAorICAgOmRvYzogTGlua2VyIHRhYmxlIHByb3ZlbmFuY2UKKworQmVuZWZp dHMgb2YgdXNpbmcgTGlua2VyIHRhYmxlcworPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQorCitBdm9pZHMgbW9kaWZ5aW5nIGFyY2hpdGVjdHVyZSBsaW5rZXIgc2NyaXB0cworLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6 IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpkb2M6IEF2b2lkcyBtb2RpZnlpbmcgYXJjaGl0 ZWN0dXJlIGxpbmtlciBzY3JpcHRzCisKK0hvdyBsaW5rZXIgdGFibGVzIHNpbXBsaWZ5IGluaXRp YWxpemF0aW9uIGNvZGUKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZG9jOiBI b3cgbGlua2VyIHRhYmxlcyBzaW1wbGlmeSBpbml0aWFsaXphdGlvbiBjb2RlCisKK1VzaW5nIGxp bmtlciB0YWJsZXMgaW4gTGludXgKKz09PT09PT09PT09PT09PT09PT09PT09PT09PT0KKworTGlu a2VyIHRhYmxlIG1vZHVsZSBzdXBwb3J0CistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKwor Li4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpkb2M6IExpbmtlciB0 YWJsZSBtb2R1bGUgc3VwcG9ydAorCitMaW5rZXIgdGFibGUgaGVscGVycworPT09PT09PT09PT09 PT09PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpk b2M6IExpbmtlciB0YWJsZSBoZWxwZXJzCisKK0xJTktUQUJMRV9BRERSX1dJVEhJTgorLS0tLS0t LS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAor ICAgOmZ1bmN0aW9uczogTElOS1RBQkxFX0FERFJfV0lUSElOCisKK0NvbnN0cnVjdGluZyBsaW5r ZXIgdGFibGVzCis9PT09PT09PT09PT09PT09PT09PT09PT09PQorCisuLiBrZXJuZWwtZG9jOjog aW5jbHVkZS9saW51eC90YWJsZXMuaAorICAgOmRvYzogQ29uc3RydWN0aW5nIGxpbmtlciB0YWJs ZXMKKworV2VhayBsaW5rZXIgdGFibGVzIGNvbnN0cnVjdG9ycworLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLQorCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAor ICAgOmRvYzogV2VhayBsaW5rZXIgdGFibGVzIGNvbnN0cnVjdG9ycworCitMSU5LVEFCTEVfV0VB SworLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5o CisgICA6ZnVuY3Rpb25zOiBMSU5LVEFCTEVfV0VBSworCitMSU5LVEFCTEVfVEVYVF9XRUFLCist LS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMu aAorICAgOmZ1bmN0aW9uczogTElOS1RBQkxFX1RFWFRfV0VBSworCitMSU5LVEFCTEVfUk9fV0VB SworLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxl cy5oCisgICA6ZnVuY3Rpb25zOiBMSU5LVEFCTEVfUk9fV0VBSworCitMSU5LVEFCTEVfSU5JVF9X RUFLCistLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90 YWJsZXMuaAorICAgOmZ1bmN0aW9uczogTElOS1RBQkxFX0lOSVRfV0VBSworCitMSU5LVEFCTEVf SU5JVF9EQVRBX1dFQUsKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6 IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpmdW5jdGlvbnM6IExJTktUQUJMRV9JTklUX0RB VEFfV0VBSworCitSZWd1bGFyIGxpbmtlciBsaW5rZXIgdGFibGUgY29uc3RydWN0b3JzCistLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKKy4uIGtlcm5lbC1kb2M6OiBp bmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZG9jOiBSZWd1bGFyIGxpbmtlciBsaW5rZXIgdGFi bGUgY29uc3RydWN0b3JzCisKK0xJTktUQUJMRQorLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjog aW5jbHVkZS9saW51eC90YWJsZXMuaAorICAgOmZ1bmN0aW9uczogTElOS1RBQkxFCisKK0xJTktU QUJMRV9URVhUCistLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgv dGFibGVzLmgKKyAgIDpmdW5jdGlvbnM6IExJTktUQUJMRV9URVhUCisKK0xJTktUQUJMRV9STwor LS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAg OmZ1bmN0aW9uczogTElOS1RBQkxFX1JPCisKK0xJTktUQUJMRV9JTklUCistLS0tLS0tLS0tLS0t LQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpmdW5jdGlvbnM6 IExJTktUQUJMRV9JTklUCisKK0xJTktUQUJMRV9JTklUX0RBVEEKKy0tLS0tLS0tLS0tLS0tLS0t LS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZnVuY3Rpb25z OiBMSU5LVEFCTEVfSU5JVF9EQVRBCisKK0RlY2xhcmluZyBMaW5rZXIgdGFibGVzCis9PT09PT09 PT09PT09PT09PT09PT09PQorCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMu aAorICAgOmRvYzogRGVjbGFyaW5nIExpbmtlciB0YWJsZXMKKworREVDTEFSRV9MSU5LVEFCTEUK Ky0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3Rh Ymxlcy5oCisgICA6ZnVuY3Rpb25zOiBERUNMQVJFX0xJTktUQUJMRQorCitERUNMQVJFX0xJTktU QUJMRV9STworLS0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xp bnV4L3RhYmxlcy5oCisgICA6ZnVuY3Rpb25zOiBERUNMQVJFX0xJTktUQUJMRV9STworCitEZWZp bmluZyBMaW5rZXIgdGFibGVzCis9PT09PT09PT09PT09PT09PT09PT09CisKKy4uIGtlcm5lbC1k b2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZG9jOiBEZWZpbmluZyBMaW5rZXIgdGFi bGVzCisKK0RFRklORV9MSU5LVEFCTEUKKy0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6 OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZnVuY3Rpb25zOiBERUZJTkVfTElOS1RBQkxF CisKK0RFRklORV9MSU5LVEFCTEVfVEVYVAorLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJu ZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAgOmZ1bmN0aW9uczogREVGSU5FX0xJ TktUQUJMRV9URVhUCisKK0RFRklORV9MSU5LVEFCTEVfUk8KKy0tLS0tLS0tLS0tLS0tLS0tLS0K Ky4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZnVuY3Rpb25zOiBE RUZJTkVfTElOS1RBQkxFX1JPCisKK0RFRklORV9MSU5LVEFCTEVfSU5JVAorLS0tLS0tLS0tLS0t LS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAgOmZ1 bmN0aW9uczogREVGSU5FX0xJTktUQUJMRV9JTklUCisKK0RFRklORV9MSU5LVEFCTEVfSU5JVF9E QVRBCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUv bGludXgvdGFibGVzLmgKKyAgIDpmdW5jdGlvbnM6IERFRklORV9MSU5LVEFCTEVfSU5JVF9EQVRB CisKK0l0ZXJhdGluZyBvdmVyIExpbmtlciB0YWJsZXMKKz09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpkb2M6 IEl0ZXJhdGluZyBvdmVyIExpbmtlciB0YWJsZXMKKworTElOS1RBQkxFX0ZPUl9FQUNICistLS0t LS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisg ICA6ZnVuY3Rpb25zOiBMSU5LVEFCTEVfRk9SX0VBQ0gKKworTElOS1RBQkxFX1JVTl9BTEwKKy0t LS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAor ICAgOmZ1bmN0aW9uczogTElOS1RBQkxFX1JVTl9BTEwKKworTElOS1RBQkxFX1JVTl9FUlIKKy0t LS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAor ICAgOmZ1bmN0aW9uczogTElOS1RBQkxFX1JVTl9FUlIKZGlmZiAtLWdpdCBhL01BSU5UQUlORVJT IGIvTUFJTlRBSU5FUlMKaW5kZXggMWEyMTc3NTFhYThhLi5lMzU2OWVkMTJjODYgMTAwNjQ0Ci0t LSBhL01BSU5UQUlORVJTCisrKyBiL01BSU5UQUlORVJTCkBAIC01MjAwLDYgKzUyMDAsMTggQEAg UzoJTWFpbnRhaW5lZAogRjoJaW5jbHVkZS9hc20tZ2VuZXJpYy8KIEY6CWluY2x1ZGUvdWFwaS9h c20tZ2VuZXJpYy8KIAorR0VORVJJQyBMSU5LRVIgVEFCTEVTCitNOgkiTHVpcyBSLiBSb2RyaWd1 ZXoiIDxtY2dyb2ZAa2VybmVsLm9yZz4KK006CSJILiBQZXRlciBBbnZpbiIgPGhwYUB6eXRvci5j b20+CitMOglsaW51eC1hcmNoQHZnZXIua2VybmVsLm9yZworTDoJbGludXgta2VybmVsQHZnZXIu a2VybmVsLm9yZworVDoJZ2l0IGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2Vy bmVsL2dpdC9tY2dyb2YvbGludXguZ2l0IHNlY3Rpb25zCitUOglnaXQgZ2l0Oi8vZ2l0Lmtlcm5l bC5vcmcvcHViL3NjbS9saW51eC9rZXJuZWwvZ2l0L21jZ3JvZi9saW51eC1uZXh0LmdpdCBzZWN0 aW9ucworUzoJU3VwcG9ydGVkCitGOglpbmNsdWRlL2FzbS1nZW5lcmljL3RhYmxlcy5oCitGOglp bmNsdWRlL2xpbnV4L3RhYmxlcy5oCitGOglEb2N1bWVudGF0aW9uL3NlY3Rpb25zL2xpbmtlci10 YWJsZXMucnN0CisKIEdFTkVSSUMgUEhZIEZSQU1FV09SSwogTToJS2lzaG9uIFZpamF5IEFicmFo YW0gSSA8a2lzaG9uQHRpLmNvbT4KIEw6CWxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKZGlm ZiAtLWdpdCBhL2FyY2gvYWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9hbHBoYS9pbmNs dWRlL2FzbS9LYnVpbGQKaW5kZXggZTQ0Yzg5NmI5MWM0Li5mM2JkYzMxZDNjOTcgMTAwNjQ0Ci0t LSBhL2FyY2gvYWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvYWxwaGEvaW5jbHVk ZS9hc20vS2J1aWxkCkBAIC0xMiwzICsxMiw0IEBAIGdlbmVyaWMteSArPSBzZWN0aW9ucy5oCiBn ZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBn ZW5lcmljLXkgKz0gcmFuZ2VzLmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEv YXJjaC9hcmMvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9hcmMvaW5jbHVkZS9hc20vS2J1aWxk CmluZGV4IGU1Mjk1NDEzZmRmOC4uNzBmMjUyNDcyY2I5IDEwMDY0NAotLS0gYS9hcmNoL2FyYy9p bmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9hcmMvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC01 MiwzICs1Miw0IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0g eG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5o CitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNt L0tidWlsZCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCA4ZTUyMzAwZTFlZWQu LmQxMzcwMGY1NzNkMCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vaW5jbHVkZS9hc20vS2J1aWxkCisr KyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNDEsMyArNDEsNCBAQCBnZW5lcmlj LXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHVuYWxpZ25lZC5oCiBnZW5lcmljLXkg Kz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAorZ2VuZXJpYy15ICs9IHRh Ymxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gv YXJtNjQvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDVmZjE4NDU3NDk3Ni4uYTE5OTE1MTdhYWQ2 IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2Fy bTY0L2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNTQsMyArNTQsNCBAQCBnZW5lcmljLXkgKz0gdmdh LmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5l cmljLXkgKz0gcmFuZ2VzLmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJj aC9hdnIzMi9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2F2cjMyL2luY2x1ZGUvYXNtL0tidWls ZAppbmRleCBlZGMxNzYzNDhkN2MuLmE2Y2QxNDU1MTVhZSAxMDA2NDQKLS0tIGEvYXJjaC9hdnIz Mi9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9hdnIzMi9pbmNsdWRlL2FzbS9LYnVpbGQK QEAgLTI0LDMgKzI0LDQgQEAgZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMt eSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFu Z2VzLmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9p bmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL0tidWlsZAppbmRl eCAzNWI3NzUyZTY1YzAuLmI3MTg5M2IxY2Q1MyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9p bmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9LYnVpbGQK QEAgLTUwLDMgKzUwLDQgQEAgZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMt eSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFu Z2VzLmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9jNngvaW5jbHVk ZS9hc20vdGFibGVzLmggYi9hcmNoL2M2eC9pbmNsdWRlL2FzbS90YWJsZXMuaApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjA5YTllMzFjNTczYQotLS0gL2Rldi9udWxs CisrKyBiL2FyY2gvYzZ4L2luY2x1ZGUvYXNtL3RhYmxlcy5oCkBAIC0wLDAgKzEsMjYgQEAKKyNp Zm5kZWYgX0FTTV9DNlhfQVNNX1RBQkxFU19ICisjZGVmaW5lIF9BU01fQzZYX0FTTV9UQUJMRVNf SAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBMdWlzIFIuIFJvZHJpZ3VleiA8bWNncm9mQGtl cm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4g cmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiBj b3B5bGVmdC1uZXh0ICh2ZXJzaW9uIDAuMy4xIG9yIGxhdGVyKSBhcyBwdWJsaXNoZWQKKyAqIGF0 IGh0dHA6Ly9jb3B5bGVmdC1uZXh0Lm9yZy8uCisgKi8KKworLyoKKyAqIFRoZSBjNnggdG9vbGNo YWluIGhhcyBhIGJ1ZyBwcmVzZW50IGV2ZW4gb24gZ2NjLTYgd2hlbiBub24td2VhayBhdHRyaWJ1 dGVzCisgKiBhcmUgdXNlZCBhbmQgc2VuZHMgdGhlbSB0byAucm9kYXRhIGV2ZW4gdGhvdWdoIGNv bnN0IGRhdGEgd2l0aCB3ZWFrCisgKiBhdHRyaWJ1dGVzIGFyZSBwdXQgaW4gLmNvbnN0LCB0aGlz IGZvcmNlcyB0aGUgbGlua2VyIHRvIGJlbGlldmUgdGhlIGFkZHJlc3MKKyAqIGlzIHJlbGF0aXZl IHJlbGF0aXZlIHRvIHRoZSBhIGJhc2UgKyBvZmZzZXQgYW5kIHlvdSBlbmQgdXAgd2l0aCBTQi1y ZWxhdGl2ZQorICogcmVsb2MgZXJyb3IgdXBvbiBsaW5raW5nLiBXb3JrIGFyb3VuZCB0aGlzIGJ5 IGJ5IGZvcmNpbmcgYm90aCBzdGFydCBhbmQKKyAqIGVuZGluZyBjb25zdCBSTyB3YWVrIGxpbmtl ciB0YWJsZSBlbnRyeSB0byBiZSAuY29uc3QgdG8gZml4IHRoaXMgZm9yIG5vdy4KKyAqCisgKiBb MF0gaHR0cHM6Ly9sa21sLmtlcm5lbC5vcmcvci8xNDcwNzk4MjQ3LjM1NTEuOTQuY2FtZWxAcmVk aGF0LmNvbQorICovCisKKyNkZWZpbmUgU0VDVElPTl9UQkxfUk8JCS5jb25zdAorCisjaW5jbHVk ZSA8YXNtLWdlbmVyaWMvdGFibGVzLmg+CisKKyNlbmRpZiAvKiBfQVNNX0M2WF9BU01fVEFCTEVT X0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2Ny aXMvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGZiOGJiNDExMjc3My4uNzA2MmMxYmU3OTEzIDEw MDY0NAotLS0gYS9hcmNoL2NyaXMvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvY3Jpcy9p bmNsdWRlL2FzbS9LYnVpbGQKQEAgLTQ3LDMgKzQ3LDQgQEAgZ2VuZXJpYy15ICs9IHdvcmQtYXQt YS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5o CiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0 IGEvYXJjaC9mcnYvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9mcnYvaW5jbHVkZS9hc20vS2J1 aWxkCmluZGV4IDUxOTFmZWM2NTVkNy4uNGE1OWNiZGE1MDkxIDEwMDY0NAotLS0gYS9hcmNoL2Zy di9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9mcnYvaW5jbHVkZS9hc20vS2J1aWxkCkBA IC0xMCwzICsxMCw0IEBAIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0g d29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkg Kz0gcmFuZ2VzLmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9oODMw MC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2g4MzAwL2luY2x1ZGUvYXNtL0tidWlsZAppbmRl eCA3OTI5YTk5MjU2NmMuLmQ3OTk2OGQ5M2MxMiAxMDA2NDQKLS0tIGEvYXJjaC9oODMwMC9pbmNs dWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9oODMwMC9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTc3 LDMgKzc3LDQgQEAgZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4 b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgK K2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9oZXhhZ29uL2luY2x1ZGUv YXNtL0tidWlsZCBiL2FyY2gvaGV4YWdvbi9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggYWYxN2Vl MzM0Nzg4Li5kNTlhYzFjMTg1OGIgMTAwNjQ0Ci0tLSBhL2FyY2gvaGV4YWdvbi9pbmNsdWRlL2Fz bS9LYnVpbGQKKysrIGIvYXJjaC9oZXhhZ29uL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNjIsMyAr NjIsNCBAQCBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5o CiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAorZ2Vu ZXJpYy15ICs9IHRhYmxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL2lhNjQvaW5jbHVkZS9hc20vS2J1 aWxkIGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBkOGYyMjZiMzVhMGEuLjc2 NTQwZjE0MzQ3MyAxMDA2NDQKLS0tIGEvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL0tidWlsZAorKysg Yi9hcmNoL2lhNjQvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0xMSwzICsxMSw0IEBAIGdlbmVyaWMt eSArPSB2dGltZS5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9 IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgKK2dlbmVyaWMteSArPSB0YWJs ZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvbTMy ci9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggMWM2NTA0ZDI5MzEyLi4yNDA4OGYzYzczM2MgMTAw NjQ0Ci0tLSBhL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9tMzJyL2lu Y2x1ZGUvYXNtL0tidWlsZApAQCAtMTMsMyArMTMsNCBAQCBnZW5lcmljLXkgKz0gdHJhY2VfY2xv Y2suaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9u LWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlm ZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL202OGsvaW5jbHVk ZS9hc20vS2J1aWxkCmluZGV4IGQ0NjVmNTFjMjA4OC4uNjVjMGRmMTdmNzBlIDEwMDY0NAotLS0g YS9hcmNoL202OGsvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2Fz bS9LYnVpbGQKQEAgLTM3LDMgKzM3LDQgQEAgZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgK IGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmlj LXkgKz0gcmFuZ2VzLmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9t ZXRhZy9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL21ldGFnL2luY2x1ZGUvYXNtL0tidWlsZApp bmRleCBjODY5YjFlYmQ1ODMuLjI1MzgyMjQ4OTlmZCAxMDA2NDQKLS0tIGEvYXJjaC9tZXRhZy9p bmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9tZXRhZy9pbmNsdWRlL2FzbS9LYnVpbGQKQEAg LTU4LDMgKzU4LDQgQEAgZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSAr PSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2Vz LmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9taWNyb2JsYXplL2lu Y2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9LYnVpbGQKaW5k ZXggNjNjMDgzYTFmOGRhLi4wMWFmYjFiNDIwZjUgMTAwNjQ0Ci0tLSBhL2FyY2gvbWljcm9ibGF6 ZS9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL0ti dWlsZApAQCAtMTMsMyArMTMsNCBAQCBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJp Yy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2Vu ZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2Fy Y2gvbWlwcy9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vS2J1aWxk CmluZGV4IGVkMjI1NjAwYzhhNC4uMDcwMDljMDg2M2Y2IDEwMDY0NAotLS0gYS9hcmNoL21pcHMv aW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9LYnVpbGQKQEAg LTIyLDMgKzIyLDQgQEAgZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSAr PSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2Vz LmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9tbjEwMzAwL2luY2x1 ZGUvYXNtL0tidWlsZCBiL2FyY2gvbW4xMDMwMC9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggNjU2 YWY3YjY5OTQwLi42YzhkMTJmM2ZlNDQgMTAwNjQ0Ci0tLSBhL2FyY2gvbW4xMDMwMC9pbmNsdWRl L2FzbS9LYnVpbGQKKysrIGIvYXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMTIs MyArMTIsNCBAQCBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHdvcmQt YXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJh bmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvbmlvczIvaW5j bHVkZS9hc20vS2J1aWxkIGIvYXJjaC9uaW9zMi9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggYzU1 ODgwNjU5ZDY3Li5lZTYyMjBkYWMxZTggMTAwNjQ0Ci0tLSBhL2FyY2gvbmlvczIvaW5jbHVkZS9h c20vS2J1aWxkCisrKyBiL2FyY2gvbmlvczIvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC02NSwzICs2 NSw0IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgK IGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5l cmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvb3BlbnJpc2MvaW5jbHVkZS9hc20v S2J1aWxkIGIvYXJjaC9vcGVucmlzYy9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggN2Q2YTcwNGI4 MDhjLi5jZWFmZTQ1OGUyOTUgMTAwNjQ0Ci0tLSBhL2FyY2gvb3BlbnJpc2MvaW5jbHVkZS9hc20v S2J1aWxkCisrKyBiL2FyY2gvb3BlbnJpc2MvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC03MywzICs3 Myw0IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgK IGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5l cmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL0ti dWlsZCBiL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCAxYTI2M2E3MTU4ZTIu Ljk5MjExNDc3YmZiMiAxMDA2NDQKLS0tIGEvYXJjaC9wYXJpc2MvaW5jbHVkZS9hc20vS2J1aWxk CisrKyBiL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMzEsMyArMzEsNCBAQCBn ZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCiBnZW5lcmlj LXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAorZ2VuZXJpYy15ICs9 IHRhYmxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vS2J1aWxkIGIv YXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCAwNjVjNmU4NGZiNjcuLmJiZDU0 YWExNTcxZSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL0tidWlsZAorKysg Yi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC05LDMgKzksNCBAQCBnZW5lcmlj LXkgKz0gcndzZW0uaAogZ2VuZXJpYy15ICs9IHZ0aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9u LWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlm ZiAtLWdpdCBhL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3MzOTAvaW5jbHVk ZS9hc20vS2J1aWxkCmluZGV4IDNlOGI5NTkyN2NiNS4uOTJjMjI1MGExNTIxIDEwMDY0NAotLS0g YS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvczM5MC9pbmNsdWRlL2Fz bS9LYnVpbGQKQEAgLTEwLDMgKzEwLDQgQEAgZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdl bmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgK IGdlbmVyaWMteSArPSByYW5nZXMuaAorZ2VuZXJpYy15ICs9IHRhYmxlcy5oCmRpZmYgLS1naXQg YS9hcmNoL3Njb3JlL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvc2NvcmUvaW5jbHVkZS9hc20v S2J1aWxkCmluZGV4IGYwY2RiMmNiY2E0ZC4uMTZlYTE1YTNlNDMyIDEwMDY0NAotLS0gYS9hcmNo L3Njb3JlL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3Njb3JlL2luY2x1ZGUvYXNtL0ti dWlsZApAQCAtMTYsMyArMTYsNCBAQCBnZW5lcmljLXkgKz0gc2VyaWFsLmgKIGdlbmVyaWMteSAr PSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMt eSArPSByYW5nZXMuaAorZ2VuZXJpYy15ICs9IHRhYmxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3No L2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvc2gvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGM5 YmI3OTMyYTNkMS4uZDBlYTc2OGQxNWFlIDEwMDY0NAotLS0gYS9hcmNoL3NoL2luY2x1ZGUvYXNt L0tidWlsZAorKysgYi9hcmNoL3NoL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNDEsMyArNDEsNCBA QCBnZW5lcmljLXkgKz0gdWNvbnRleHQuaAogZ2VuZXJpYy15ICs9IHhvci5oCiBnZW5lcmljLXkg Kz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAorZ2VuZXJpYy15ICs9IHRh Ymxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gv c3BhcmMvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDc5NjY0ZDEwZTYzYi4uMGU3NjYzNzQ5Yzk3 IDEwMDY0NAotLS0gYS9hcmNoL3NwYXJjL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3Nw YXJjL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMjQsMyArMjQsNCBAQCBnZW5lcmljLXkgKz0gdHlw ZXMuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9u LWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlm ZiAtLWdpdCBhL2FyY2gvdGlsZS9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3RpbGUvaW5jbHVk ZS9hc20vS2J1aWxkCmluZGV4IDk1MWZhNGJlNTcxZC4uOGYzZTM4Yzk4MWNkIDEwMDY0NAotLS0g YS9hcmNoL3RpbGUvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvdGlsZS9pbmNsdWRlL2Fz bS9LYnVpbGQKQEAgLTQzLDMgKzQzLDQgQEAgZ2VuZXJpYy15ICs9IHR5cGVzLmgKIGdlbmVyaWMt eSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFu Z2VzLmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC91bS9pbmNsdWRl L2FzbS9LYnVpbGQgYi9hcmNoL3VtL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCA5OWJlNTQ5NDli OTkuLmVlYTVkZDg0Mjk5MiAxMDA2NDQKLS0tIGEvYXJjaC91bS9pbmNsdWRlL2FzbS9LYnVpbGQK KysrIGIvYXJjaC91bS9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTI5LDMgKzI5LDQgQEAgZ2VuZXJp Yy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9 IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgKK2dlbmVyaWMteSArPSB0YWJs ZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC91bmljb3JlMzIvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJj aC91bmljb3JlMzIvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDZjMzU5MDVmZTM3MS4uNWMzMWVh ZmJmMWZkIDEwMDY0NAotLS0gYS9hcmNoL3VuaWNvcmUzMi9pbmNsdWRlL2FzbS9LYnVpbGQKKysr IGIvYXJjaC91bmljb3JlMzIvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC02NSwzICs2NSw0IEBAIGdl bmVyaWMteSArPSB2Z2EuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMt eSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgK ZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gveDg2L2luY2x1 ZGUvYXNtL0tidWlsZAppbmRleCBmNzkwNzU2ZmRiNDguLmNkMGZhNzZiMzJhMyAxMDA2NDQKLS0t IGEvYXJjaC94ODYvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNt L0tidWlsZApAQCAtMTgsMyArMTgsNCBAQCBnZW5lcmljLXkgKz0gbWNzX3NwaW5sb2NrLmgKIGdl bmVyaWMteSArPSBtbS1hcmNoLWhvb2tzLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAog Z2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBh L2FyY2gveDg2L3Rvb2xzL3JlbG9jcy5jIGIvYXJjaC94ODYvdG9vbHMvcmVsb2NzLmMKaW5kZXgg YzIxNWRiMDQ5OTIwLi40NTczM2ExODJhYzIgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L3Rvb2xzL3Jl bG9jcy5jCisrKyBiL2FyY2gveDg2L3Rvb2xzL3JlbG9jcy5jCkBAIC02OSw3ICs2OSw5IEBAIHN0 YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3ltX3JlZ2V4X2tlcm5lbFtTX05TWU1UWVBFU10gPSB7 CiAJIl9faW5pdHJhbWZzX3N0YXJ0fCIKIAkiKGppZmZpZXN8amlmZmllc182NCl8IgogCSIucm9k YXRhLnJuZy4qfCIKKwkiLnJvZGF0YS50YmwuKnwiCiAJIi5pbml0LnRleHQucm5nLip8IgorCSIu aW5pdC50ZXh0LnRibC4qfCIKICNpZiBFTEZfQklUUyA9PSA2NAogCSJfX3Blcl9jcHVfbG9hZHwi CiAJImluaXRfcGVyX2NwdV9fLip8IgpkaWZmIC0tZ2l0IGEvYXJjaC94dGVuc2EvaW5jbHVkZS9h c20vS2J1aWxkIGIvYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDIyMWI2YjY1 MjUwMC4uYWU0OGY4ZmQ5MjEyIDEwMDY0NAotLS0gYS9hcmNoL3h0ZW5zYS9pbmNsdWRlL2FzbS9L YnVpbGQKKysrIGIvYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0zMywzICszMyw0 IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdl bmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmlj LXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvcmFuZ2VzLmgg Yi9pbmNsdWRlL2FzbS1nZW5lcmljL3Jhbmdlcy5oCmluZGV4IDc0Y2Q5NDFhYTJmOC4uOGNmMjFh MTQ5N2M2IDEwMDY0NAotLS0gYS9pbmNsdWRlL2FzbS1nZW5lcmljL3Jhbmdlcy5oCisrKyBiL2lu Y2x1ZGUvYXNtLWdlbmVyaWMvcmFuZ2VzLmgKQEAgLTg2LDQgKzg2LDE4IEBACiAKICNlbmRpZiAv KiBfX0FTU0VNQkxZX18gKi8KIAorI2lmZGVmIF9fQVNTRU1CTEVSX18KKworI2lmbmRlZiBERUZJ TkVfU0VDVElPTl9SQU5HRQorI2RlZmluZSBERUZJTkVfU0VDVElPTl9SQU5HRShzZWN0aW9uLCBu YW1lKQkJCQlcCisgIHB1c2hfc2VjdGlvbl9ybmdfbGV2ZWwoc2VjdGlvbiwgbmFtZSwsKSA7CQkJ CQlcCisgIC5nbG9ibCBuYW1lIDsJCQkJCQkJCVwKK25hbWU6IDsJCQkJCQkJCQlcCisgIC5wb3Bz ZWN0aW9uCQkJCQkJCQlcCisJCQkJCQkJCQlcCisgIHB1c2hfc2VjdGlvbl9ybmdfbGV2ZWwoc2Vj dGlvbiwgbmFtZSwgfiwpIDsJCQkJCVwKKyAgLnBvcHNlY3Rpb24KKyNlbmRpZgorI2VuZGlmIC8q IF9fQVNTRU1CTEVSX18gKi8KKwogI2VuZGlmIC8qIF9BU01fR0VORVJJQ19SQU5HRVNfSF8gKi8K ZGlmZiAtLWdpdCBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvdGFibGVzLmggYi9pbmNsdWRlL2FzbS1n ZW5lcmljL3RhYmxlcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4u NDNjZDAzYTgzYmQyCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9hc20tZ2VuZXJpYy90YWJs ZXMuaApAQCAtMCwwICsxLDUwIEBACisjaWZuZGVmIF9BU01fR0VORVJJQ19UQUJMRVNfSF8KKyNk ZWZpbmUgX0FTTV9HRU5FUklDX1RBQkxFU19IXworLyoKKyAqIExpbnV4IGxpbmtlciB0YWJsZXMK KyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYgTHVpcyBSLiBSb2RyaWd1ZXogPG1jZ3JvZkBrZXJu ZWwub3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJl ZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgY29w eWxlZnQtbmV4dCAodmVyc2lvbiAwLjMuMSBvciBsYXRlcikgYXMgcHVibGlzaGVkCisgKiBhdCBo dHRwOi8vY29weWxlZnQtbmV4dC5vcmcvLgorICovCisjaW5jbHVkZSA8YXNtL3NlY3Rpb24tY29y ZS5oPgorCisjZGVmaW5lIFNFQ1RJT05fVEJMKHNlY3Rpb24sIG5hbWUsIGxldmVsKQkJCQlcCisJ U0VDVElPTl9DT1JFKHNlY3Rpb24sIHRibCwgbmFtZSwgbGV2ZWwpCisKKyNkZWZpbmUgU0VDVElP Tl9UQkxfQUxMKHNlY3Rpb24pCQkJCQlcCisJU0VDVElPTl9DT1JFX0FMTChzZWN0aW9uLHRibCkK KworLyogU29tZSB0b29sY2hhaW5zIGFyZSBidWdneSwgbGV0IHRoZW0gb3ZlcnJpZGUgKi8KKyNp Zm5kZWYgU0VDVElPTl9UQkxfUk8KKyMgZGVmaW5lIFNFQ1RJT05fVEJMX1JPCVNFQ1RJT05fUk9E QVRBCisjZW5kaWYKKworI2lmbmRlZiBzZXRfc2VjdGlvbl90YmwKKyMgZGVmaW5lIHNldF9zZWN0 aW9uX3RibChzZWN0aW9uLCBuYW1lLCBsZXZlbCwgZmxhZ3MpCQkJXAorCSBzZXRfc2VjdGlvbl9j b3JlKHNlY3Rpb24sIHRibCwgbmFtZSwgbGV2ZWwsIGZsYWdzKQorI2VuZGlmCisKKyNpZm5kZWYg c2V0X3NlY3Rpb25fdGJsX2FueQorIyBkZWZpbmUgc2V0X3NlY3Rpb25fdGJsX2FueShzZWN0aW9u LCBuYW1lLCBmbGFncykJCQkJXAorCSBzZXRfc2VjdGlvbl9jb3JlKHNlY3Rpb24sIHRibCwgbmFt ZSwgU0VDVElPTl9PUkRFUl9BTlksIGZsYWdzKQorI2VuZGlmCisKKyNpZm5kZWYgc2V0X3NlY3Rp b25fdGJsX3R5cGUKKyMgZGVmaW5lIHNldF9zZWN0aW9uX3RibF90eXBlKHNlY3Rpb24sIG5hbWUs IGxldmVsLCBmbGFncywgdHlwZSkJCVwKKwkgc2V0X3NlY3Rpb25fY29yZV90eXBlKHNlY3Rpb24s IHRibCwgbmFtZSwgbGV2ZWwsIGZsYWdzLCB0eXBlKQorI2VuZGlmCisKKyNpZm5kZWYgcHVzaF9z ZWN0aW9uX3RibAorIyBkZWZpbmUgcHVzaF9zZWN0aW9uX3RibChzZWN0aW9uLCBuYW1lLCBsZXZl bCwgZmxhZ3MpCQkJXAorCSBwdXNoX3NlY3Rpb25fY29yZShzZWN0aW9uLCB0YmwsIG5hbWUsIGxl dmVsLCBmbGFncykKKyNlbmRpZgorCisjaWZuZGVmIHB1c2hfc2VjdGlvbl90YmxfYW55CisjIGRl ZmluZSBwdXNoX3NlY3Rpb25fdGJsX2FueShzZWN0aW9uLCBuYW1lLCBmbGFncykJCQlcCisJIHB1 c2hfc2VjdGlvbl9jb3JlKHNlY3Rpb24sIHRibCwgbmFtZSwgU0VDVElPTl9PUkRFUl9BTlksIGZs YWdzKQorI2VuZGlmCisKKyNlbmRpZiAvKiBfQVNNX0dFTkVSSUNfVEFCTEVTX0hfICovCmRpZmYg LS1naXQgYS9pbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmggYi9pbmNsdWRlL2FzbS1n ZW5lcmljL3ZtbGludXgubGRzLmgKaW5kZXggYWQ4NDM1NTVlNmE0Li40YjZhM2Q4MjA4ODMgMTAw NjQ0Ci0tLSBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5sZHMuaAorKysgYi9pbmNsdWRl L2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmgKQEAgLTU3LDYgKzU3LDcgQEAKICNpbmNsdWRlIDxs aW51eC9leHBvcnQuaD4KICNpbmNsdWRlIDxhc20vc2VjdGlvbi1jb3JlLmg+CiAjaW5jbHVkZSA8 YXNtL3Jhbmdlcy5oPgorI2luY2x1ZGUgPGFzbS90YWJsZXMuaD4KIAogLyogQWxpZ24gLiB0byBh IDggYnl0ZSBib3VuZGFyeSBlcXVhbHMgdG8gbWF4aW11bSBmdW5jdGlvbiBhbGlnbm1lbnQuICov CiAjZGVmaW5lIEFMSUdOX0ZVTkNUSU9OKCkgIC4gPSBBTElHTig4KQpAQCAtMjAyLDYgKzIwMyw3 IEBACiAjZGVmaW5lIERBVEFfREFUQQkJCQkJCQlcCiAJKihTRUNUSU9OX0RBVEEpCQkJCQkJCVwK IAkqKFNPUlQoU0VDVElPTl9STkdfQUxMKFNFQ1RJT05fREFUQSkpKQkJCQlcCisJKihTT1JUKFNF Q1RJT05fVEJMX0FMTChTRUNUSU9OX0RBVEEpKSkJCQkJXAogCSooU0VDVElPTl9SRUZfREFUQSkJ CQkJCQlcCiAJKiguZGF0YS4uc2hhcmVkX2FsaWduZWQpIC8qIHBlcmNwdSByZWxhdGVkICovCQkJ XAogCU1FTV9LRUVQKGluaXQuZGF0YSkJCQkJCQlcCkBAIC0yNjksNiArMjcxLDcgQEAKIAkJVk1M SU5VWF9TWU1CT0woX19zdGFydF9yb2RhdGEpID0gLjsJCQlcCiAJCSooU0VDVElPTl9ST0RBVEEp CQkJCQlcCiAJCSooU09SVChTRUNUSU9OX1JOR19BTEwoU0VDVElPTl9ST0RBVEEpKSkJCVwKKwkJ KihTT1JUKFNFQ1RJT05fVEJMX0FMTChTRUNUSU9OX1JPREFUQSkpKQkJXAogCQkqKFNFQ1RJT05f QUxMKFNFQ1RJT05fUk9EQVRBKSkJCQkJXAogCQlST19BRlRFUl9JTklUX0RBVEEJLyogUmVhZCBv bmx5IGFmdGVyIGluaXQgKi8JXAogCQkqKF9fdmVybWFnaWMpCQkvKiBLZXJuZWwgdmVyc2lvbiBt YWdpYyAqLwlcCkBAIC00MzksNiArNDQyLDcgQEAKIAkJQUxJR05fRlVOQ1RJT04oKTsJCQkJCVwK IAkJKigudGV4dC5ob3QgU0VDVElPTl9URVhUKQkJCQlcCiAJCSooU09SVChTRUNUSU9OX1JOR19B TEwoU0VDVElPTl9URVhUKSkpCQkJXAorCQkqKFNPUlQoU0VDVElPTl9UQkxfQUxMKFNFQ1RJT05f VEVYVCkpKQkJCVwKIAkJKigudGV4dC5maXh1cCAudGV4dC51bmxpa2VseSkJCQkJXAogCQkqKFNF Q1RJT05fUkVGKQkJCQkJCVwKIAlNRU1fS0VFUChpbml0LnRleHQpCQkJCQkJXApAQCAtNTM2LDYg KzU0MCw3IEBACiAjZGVmaW5lIElOSVRfREFUQQkJCQkJCQlcCiAJKihTRUNUSU9OX0lOSVRfREFU QSkJCQkJCQlcCiAJKihTT1JUKFNFQ1RJT05fUk5HX0FMTChTRUNUSU9OX0lOSVRfREFUQSkpKQkJ CVwKKwkqKFNPUlQoU0VDVElPTl9UQkxfQUxMKFNFQ1RJT05fSU5JVF9EQVRBKSkpCQkJXAogCU1F TV9ESVNDQVJEKGluaXQuZGF0YSkJCQkJCQlcCiAJS0VSTkVMX0NUT1JTKCkJCQkJCQkJXAogCU1D T1VOVF9SRUMoKQkJCQkJCQlcCkBAIC01NTksNiArNTY0LDcgQEAKICNkZWZpbmUgSU5JVF9URVhU CQkJCQkJCVwKIAkqKFNFQ1RJT05fSU5JVCkJCQkJCQkJXAogCSooU09SVChTRUNUSU9OX1JOR19B TEwoU0VDVElPTl9JTklUKSkpCQkJCVwKKwkqKFNPUlQoU0VDVElPTl9UQkxfQUxMKFNFQ1RJT05f SU5JVCkpKQkJCQlcCiAJKigudGV4dC5zdGFydHVwKQkJCQkJCVwKIAlNRU1fRElTQ0FSRChpbml0 LnRleHQpCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdGFibGVzLmggYi9pbmNsdWRlL2xp bnV4L3RhYmxlcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNDIz ODI3ZWFmYjUyCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9saW51eC90YWJsZXMuaApAQCAt MCwwICsxLDU2NyBAQAorI2lmbmRlZiBfTElOVVhfTElOS0VSX1RBQkxFU19ICisjZGVmaW5lIF9M SU5VWF9MSU5LRVJfVEFCTEVTX0gKKy8qCisgKiBMaW51eCBsaW5rZXIgdGFibGVzCisgKgorICog Q29weXJpZ2h0IChDKSAyMDE2IEx1aXMgUi4gUm9kcmlndWV6IDxtY2dyb2ZAa2VybmVsLm9yZz4K KyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIGNvcHlsZWZ0LW5l eHQgKHZlcnNpb24gMC4zLjEgb3IgbGF0ZXIpIGFzIHB1Ymxpc2hlZAorICogYXQgaHR0cDovL2Nv cHlsZWZ0LW5leHQub3JnLy4KKyAqLworI2luY2x1ZGUgPGxpbnV4L2V4cG9ydC5oPgorI2luY2x1 ZGUgPGxpbnV4L3NlY3Rpb25zLmg+CisjaW5jbHVkZSA8YXNtL3RhYmxlcy5oPgorCisjaWZuZGVm IF9fQVNTRU1CTFlfXworCisvKioKKyAqIERPQzogSW50cm9kdWN0aW9uCisgKgorICogQSBsaW5r ZXIgdGFibGUgaXMgYSBkYXRhIHN0cnVjdHVyZSB0aGF0IGlzIHN0aXRjaGVkIHRvZ2V0aGVyIGZy b20gaXRlbXMgaW4KKyAqIG11bHRpcGxlIG9iamVjdCBmaWxlcyBmb3IgdGhlIHB1cnBvc2Ugb2Yg c2VsZWN0aXZlIHBsYWNlbWVudCBpbnRvIHN0YW5kYXJkCisgKiBvciBhcmNoaXRlY3R1cmUgc3Bl Y2lmaWMgRUxGIHNlY3Rpb25zLiBXaGF0IHNlY3Rpb24gaXMgdXNlZCBpcyB1dGlsaXR5CisgKiBz cGVjaWZpYy4gTGludXggaGFzIGhpc3RvcmljYWxseSBpbXBsaWNpdGx5IHVzZWQgbGlua2VyIHRh YmxlcywgaG93ZXZlciB0aGV5CisgKiB3ZXJlIGFsbCBidWlsdCBpbiBhbiBhZGhvYyBtYW5uZXIg d2hpY2ggcmVxdWlyZXMgbGlua2VyIHNjcmlwdCBtb2RpZmljYXRpb25zCisgKiBwZXIgYXJjaGl0 ZWN0dXJlLiBUaGUgbGlua2VyIHRhYmxlIEFQSSBwcm92aWRlcyBhIGdlbmVyYWwgZmFjaWxpdHkg c28gdGhhdAorICogZGF0YSBzdHJ1Y3R1cmVzIGNhbiBiZSBzdGl0Y2hlZCB0b2dldGhlciBhbmQg cGxhY2VkIGludG8gTGludXggRUxGIHNlY3Rpb25zCisgKiBieSBvbmx5IGNoYW5naW5nIEMgb3Ig YXNtIGNvZGUgaW4gYW4gYXJjaGl0ZWN0dXJlIGFnbm9zdGljIGZvcm0uCisgKgorICogTGlua2Vy IHRhYmxlcyBoZWxwIHlvdSBncm91cCB0b2dldGhlciByZWxhdGVkIGRhdGEgYW5kIGNvZGUgaW4g YW4gZWZmaWNpZW50CisgKiB3YXkuIExpbmtlciB0YWJsZXMgY2FuIGJlIHVzZWQgdG8gaGVscCBz aW1wbGlmeSBpbml0IHNlcXVlbmNlcywgdGhleQorICogZW5hYmxlIGxpbmtlciBidWlsZCB0aW1l IHNlbGVjdGl2ZSBzb3J0aW5nIChkaXNhYmxlZCBvcHRpb25zIGdldCBpZ25vcmVkKSwKKyAqIGFu ZCBjYW4gb3B0aW9uYWxseSBhbHNvIGJlIHVzZWQgdG8gaGVscCB5b3UgYXZvaWQgY29kZSBiaXQt cm90IGR1ZSB0bworICogb3ZlcnVzZSBvZiAjaWZkZWYuCisgKi8KKworLyoqCisgKiBET0M6IExp bmtlciB0YWJsZSBwcm92ZW5hbmNlCisgKgorICogVGhlIExpbnV4IGltcGxlbWVudGF0aW9uIG9m IGxpbmtlciB0YWJsZXMgd2FzIGluc3BpcmVkIGJ5IHRoZSBpUFhFIGxpbmtlcgorICogdGFibGUn cyBzb2x1dGlvbiAoaVBYRSBjb21taXQgNjdhMTBlZjAwMGNiNyAiW2NvbnRyaWJdIEFkZCByb20t by1tYXRpYyB0bworICogY29udHJpYiAiWzBdKS4gIFRvIHNlZSBob3cgdGhpcyBjb2RlIGV2b2x2 ZWQgcmVmZXIgdG8gdGhlIG91dCBvZiB0cmVlCisgKiB1c2Vyc3BhY2UgbGlua2VyLXRhYmxlIHRy ZWUgWzFdLgorICoKKyAqIENvbnRyYXJ5IHRvIGlQWEUncyBzb2x1dGlvbiB3aGljaCBzdHJpdmVz IHRvIGZvcmNlIGNvbXBpbGF0aW9uIG9mCisgKiBldmVyeXRoaW5nIHVzaW5nIGxpbmtlciB0YWJs ZXMsIExpbnV4J3Mgc29sdXRpb24gYWxsb3dzIGZvciBkZXZlbG9wZXJzIHRvIGJlCisgKiBzZWxl Y3RpdmUgb3ZlciB3aGVyZSBvbmUgd2lzaGVzIHRvIGZvcmNlIGNvbXBpbGF0aW9uLCB0aGlzIHRo ZW4gaXMganVzdCBhbgorICogb3B0aW9uYWwgZmVhdHVyZSBmb3IgdGhlIExpbnV4IGxpbmtlciB0 YWJsZSBzb2x1dGlvbi4gVGhlIG1haW4gYWR2YW50YWdlcworICogb2YgdXNpbmcgbGlua2VyLXRh YmxlcyB0aGVuIGFyZToKKyAqCisgKiAgLSBBdm9pZGluZyBtb2RpZnlpbmcgYXJjaGl0ZWN0dXJl IGxpbmtlciBzY3JpcHRzCisgKiAgLSBTaW1wbGlmeWluZyBpbml0aWFsaXphdGlvbiBjb2RlCisg KiAgLSBBdm9pZGluZyB0aGUgY29kZSBiaXQtcm90IHByb2JsZW0KKyAqCisgKiBbMF0gZ2l0Oi8v Z2l0LmlweGUub3JnL2lweGUuZ2l0CisgKgorICogWzFdIGh0dHBzOi8vZ2l0Lmtlcm5lbC5vcmcv Y2dpdC9saW51eC9rZXJuZWwvZ2l0L21jZ3JvZi9saW5rZXItdGFibGVzLmdpdC8KKyAqLworCisv KioKKyAqIERPQzogQXZvaWRzIG1vZGlmeWluZyBhcmNoaXRlY3R1cmUgbGlua2VyIHNjcmlwdHMK KyAqCisgKiBMaW5rZXIgdGFibGVzIGVuYWJsZSB5b3UgdG8gYXZvaWQgbW9kaWZ5aW5nIGFyY2hp dGVjdHVyZSBsaW5rZXIgc2NyaXB0cworICogc2luY2UgaXQgaGFzIGl0cyBoYXMgZXh0ZW5kZWQg ZWFjaCBjb3JlIExpbnV4IHNlY3Rpb24gd2l0aCBhIHJlc3BlY3RpdmUKKyAqIGxpbmtlciB0YWJs ZSBlbnRyeSBpbiBgaW5jbHVkZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oYC4gV2hlbiB5b3Ug YWRkIG5ldworICogbGlua2VyIHRhYmxlIGVudHJ5IHlvdSBhZ2dyZWdhdGUgdGhlbSBgaW50b2Ag dGhlIGV4aXN0aW5nIGxpbmtlciB0YWJsZSBjb3JlCisgKiBzZWN0aW9uLgorICovCisKKy8qKgor ICogRE9DOiBIb3cgbGlua2VyIHRhYmxlcyBzaW1wbGlmeSBpbml0aWFsaXphdGlvbiBjb2RlCisg KgorICogVHJhZGl0aW9uYWxseSwgd2Ugd291bGQgaW1wbGVtZW50IGZlYXR1cmVzIGluIEMgY29k ZSBhcyBmb2xsb3dzOgorICoKKyAqICBmb29faW5pdCgpOworICoKKyAqIFlvdSdkIHRoZW4gaGF2 ZSBhIGZvby5oIHdoaWNoIHdvdWxkIGhhdmU6OgorICoKKyAqICAjaWZuZGVmIENPTkZJR19GT08K KyAqICBzdGF0aWMgaW5saW5lIHZvaWQgZm9vX2luaXQodm9pZCkgeyB9CisgKiAgI2VuZGlmCisg KgorICogV2l0aCBsaW5rZXIgdGFibGVzIHRoaXMgaXMgbm8gbG9uZ2VyIG5lY2Vzc2FyeSBhcyB5 b3VyIGluaXQgcm91dGluZXMgd291bGQKKyAqIGJlIGltcGxpY2l0LCB5b3UnZCBpbnN0ZWFkIGNh bGw6CisgKgorICogIGNhbGxfaW5pdF9mbnMoKTsKKyAqCisgKiBjYWxsX2luaXRfZm5zKCkgd291 bGQgY2FsbCBhbGwgZnVuY3Rpb25zIHByZXNlbnQgaW4geW91ciBpbml0IHRhYmxlIGFuZCBpZgor ICogYW5kIG9ubHkgaWYgZm9vLm8gZ2V0cyBsaW5rZWQgaW4sIHRoZW4gaXRzIGluaXRpYWxpc2F0 aW9uIGZ1bmN0aW9uIHdpbGwgYmUKKyAqIGNhbGxlZC4KKyAqCisgKiBUaGUgbGlua2VyIHNjcmlw dCB0YWtlcyBjYXJlIG9mIGFzc2VtYmxpbmcgdGhlIHRhYmxlcyBmb3IgdXMuIEFsbCBvZiBvdXIK KyAqIHRhYmxlIHNlY3Rpb25zIGhhdmUgbmFtZXMgb2YgdGhlIGZvcm1hdCBgU0VDVElPTl9OQU1F LnRibC5OQU1FLk5gLiBIZXJlCisgKiBgU0VDVElPTl9OQU1FYCBpcyBvbmUgb2YgdGhlIHN0YW5k YXJkIHNlY3Rpb25zIGluOjoKKyAqCisgKiAgIGluY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1j b3JlLmgKKyAqCisgKiBhbmQgYE5BTUVgIGRlc2lnbmF0ZXMgdGhlIHNwZWNpZmljIHVzZSBjYXNl IGZvciB0aGUgbGlua2VyIHRhYmxlLCB0aGUgdGFibGUuCisgKiBgTmAgaXMgYSBkaWdpdCB1c2Vk IHRvIGhlbHAgc29ydCBlbnRyaWVzIGluIHRoZSBzZWN0aW9uLiBgTj1gIChlbXB0eSBzdHJpbmcp CisgKiBpcyByZXNlcnZlZCBmb3IgdGhlIHN5bWJvbCBpbmRpY2F0aW5nIGB0YWJsZSBzdGFydGAs IGFuZCBgTj1+YCBpcyByZXNlcnZlZAorICogZm9yIHRoZSBzeW1ib2wgaW5kaWNhdGluZyBgdGFi bGUgZW5kYC4gSW4gb3JkZXIgZm9yIHRoZSBjYWxsX2luaXRfZm5zKCkgdG8KKyAqIHdvcmsgYmVo aW5kIHRoZSBzY2VuZXMgdGhlIGN1c3RvbSBsaW5rZXIgc2NyaXB0IHdvdWxkIG5lZWQgdG8gZGVm aW5lIHRoZQorICogYmVnaW5uaW5nIG9mIHRoZSB0YWJsZSwgdGhlIGVuZCBvZiB0aGUgdGFibGUs IGFuZCBpbiBiZXR3ZWVuIGl0IHNob3VsZCB1c2UKKyAqIGBgU09SVCgpYGAgdG8gZ2l2ZSBvcmRl ciB0byB0aGUgc2VjdGlvbi4gVHlwaWNhbGx5IHRoaXMgd291bGQgcmVxdWlyZSBjdXN0b20KKyAq IGxpbmtlciBzY3JpcHQgbW9kaWZpY2F0aW9ucyBob3dldmVyIHNpbmNlIGxpbmtlciB0YWJsZSBh cmUgYWxyZWFkeSBkZWZpbmVkCisgKiBpbiBgYGluY2x1ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5s ZHMuaGBgIGFzIGRvY3VtZW50ZWQgYWJvdmUgZWFjaCBuZXcgbGlua2VyCisgKiB0YWJsZSBkZWZp bml0aW9uIGFkZGVkIGluIEMgY29kZSBmb2xkcyBpbnRvIHRoZSByZXNwZWN0aXZlIGNvcmUgTGlu dXgKKyAqIHNlY3Rpb24gbGlua2VyIHRhYmxlLgorICoKKyAqIFRoaXMgaXMgYWxzbyBkb25lIHRv IHN1cHBvcnQgYWxsIGFyY2hpdGVjdHVyZXMuICBBbGwgdGhhdCBpcyBuZWVkZWQgdGhlbiBpcwor ICogdG8gZW5zdXJlIGEgcmVzcGVjdGl2ZSBjb21tb24gbGlua2VyIHRhYmxlIGVudHJ5IGlzIGFk ZGVkIHRvIHRoZSBzaGFyZWQKKyAqIGBgaW5jbHVkZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5o YGAuICBUaGVyZSBzaG91bGQgYmUgYSByZXNwZWN0aXZlOjoKKyAqCisgKiAgKihTT1JUKFNFQ1RJ T05fVEJMX0FMTChTRUNUSU9OX05BTUUpKSkKKyAqCisgKiBlbnRyeSBmb3IgZWFjaCB0eXBlIG9m IHN1cHBvcnRlZCBzZWN0aW9uIHRoZXJlLiBJZiB5b3VyIGBTRUNUSU9OX05BTUVgCisgKiBpcyBu b3QgeWV0IHN1cHBvcnRlZCwgY29uc2lkZXIgYWRkaW5nIHN1cHBvcnQgZm9yIGl0LgorICoKKyAq IExpbmtlciB0YWJsZXMgc3VwcG9ydCBvcmRlcmluZyBlbnRyaWVzLCBpdCBkb2VzIHRoaXMgdXNp bmcgYSBkaWdpdCB3aGljaAorICogaXMgZXZlbnR1YWxseSBhZGRlZCBhcyBhIHBvc3RmaXggdG8g YSBzZWN0aW9uIGVudHJ5IG5hbWUsIHdlIHJlZmVyIHRvIHRoaXMKKyAqIGFzIHRoZSBsaW5rZXIg dGFibGUgYGBvcmRlci1sZXZlbGBgLiBJZiBvcmRlciBpcyBub3QgaW1wb3J0YW50IHRvIHlvdXIK KyAqIGxpbmtlciB0YWJsZSBlbnRyeSB5b3UgY2FuIHVzZSB0aGUgc3BlY2lhbCBgYFNFQ1RJT05f T1JERVJfQU5ZYGAuIEFmdGVyCisgKiBgYG9yZGVyLWxldmVsYGAsIHRoZSBuZXh0IGNvbnRyaWJ1 dGluZyBmYWN0b3IgdG8gb3JkZXIgaXMgdGhlIG9yZGVyIG9mIHRoZQorICogY29kZSBpbiB0aGUg QyBmaWxlLCBhbmQgdGhlIG9yZGVyIG9mIHRoZSBvYmplY3RzIGluIHRoZSBNYWtlZmlsZS4gVXNp bmcgYW4KKyAqIGBgb3JkZXItbGV2ZWxgYCB0aGVuIHNob3VsZCBub3QgcmVhbGx5IGJlIG5lZWRl ZCBpbiBtb3N0IGNhc2VzLCBpdHMgdXNlCisgKiBob3dldmVyIGVuYWJsZXMgdG8gY29tcGFydGFt ZW50YWxpemUgY29kZSBpbnRvIHRhYmxlcyB3aGVyZSBvcmRlcmluZyB0aHJvdWdoCisgKiBDIGZp bGUgb3IgdGhyb3VnaCB0aGUgTWFrZWZpbGUgd291bGQgb3RoZXJ3aXNlIGJlIHZlcnkgZGlmZmlj dWx0IG9yIGlmIG9uZQorICogd2FudGVkIHRvIGVuYWJsZSB2ZXJ5IHNwZWNpZmljIGluaXRpYWxp emF0aW9uIHNlbWFudGljcy4KKyAqCisgKiBBcyBhbiBleGFtcGxlLCBzdXBwb3NlIHRoYXQgd2Ug d2FudCB0byBjcmVhdGUgYSAiZnJvYm5pY2F0b3IiCisgKiBmZWF0dXJlIGZyYW1ld29yaywgYW5k IGFsbG93IGZvciBzZXZlcmFsIGluZGVwZW5kZW50IG1vZHVsZXMgdG8KKyAqIHByb3ZpZGUgZnJv Ym5pY2F0aW5nIHNlcnZpY2VzLiBUaGVuIHdlIHdvdWxkIGNyZWF0ZSBhIGZyb2IuaAorICogaGVh ZGVyIGZpbGUgY29udGFpbmluZyBlLmcuOjoKKyAqCisgKglzdHJ1Y3QgZnJvYm5pY2F0b3Igewor ICoJCWNvbnN0IGNoYXIgKm5hbWU7CisgKgkJdm9pZCAoKmZyb2IpICh2b2lkKTsKKyAqCX07Cisg KgorICoJREVDTEFSRV9MSU5LVEFCTEUoc3RydWN0IGZyb2JuaWNhdG9yLCBmcm9ibmljYXRvcl9m bnMpOworICoKKyAqIEFueSBtb2R1bGUgcHJvdmlkaW5nIGZyb2JuaWNhdGluZyBzZXJ2aWNlcyB3 b3VsZCBsb29rIHNvbWV0aGluZworICogbGlrZTo6CisgKgorICoJI2luY2x1ZGUgImZyb2IuaCIK KyAqCisgKglzdGF0aWMgdm9pZCBteV9mcm9iKHZvaWQpIHsKKyAqCQkuLi4gRG8gbXkgZnJvYm5p Y2F0aW5nCisgKgl9CisgKgorICoJTElOS1RBQkxFX0lOSVRfREFUQShmcm9ibmljYXRvcl9mbnMs IGFsbCkgbXlfZnJvYm5pY2F0b3IgPSB7CisgKgkJLm5hbWUgPSAibXlfZnJvYiIsCisgKgkJLmZy b2IgPSBteV9mcm9iLAorICoJfTsKKyAqCisgKiBUaGUgY2VudHJhbCBmcm9ibmljYXRvciBjb2Rl LCBzYXkgaW4gZnJvYi5jLCB3b3VsZCB1c2UgdGhlIGZyb2JuaWNhdGluZworICogbW9kdWxlcyBh cyBmb2xsb3dzOjoKKyAqCisgKgkjaW5jbHVkZSAiZnJvYi5oIgorICoKKyAqCXZvaWQgZnJvYl9h bGwodm9pZCkgeworICoJCXN0cnVjdCBmcm9ibmljYXRvciAqZjsKKyAqCisgKgkJTElOS1RBQkxF X0ZPUl9FQUNIKGYsIGZyb2JuaWNhdG9yX2ZucykgeworICoJCQlwcl9pbmZvKCJDYWxsaW5nIGZy b2JuaWNhdG9yICVzXG4iLCBmcm9iLT5uYW1lKTsKKyAqCQkJZi0+ZnJvYigpOworICoJCX0KKyAq CX0KKyAqLworCisvKioKKyAqIERPQzogTGlua2VyIHRhYmxlIG1vZHVsZSBzdXBwb3J0CisgKgor ICogTW9kdWxlcyBjYW4gdXNlIGxpbmtlciB0YWJsZXMsIGhvd2V2ZXIgdGhlIGxpbmtlciB0YWJs ZSBkZWZpbml0aW9uCisgKiBtdXN0IGJlIGJ1aWx0LWluIHRvIHRoZSBrZXJuZWwuIFRoYXQgaXMs IHRoZSBjb2RlIHRoYXQgaW1wbGVtZW50cworICogYGBERUZJTkVfTElOS1RBQkxFKigpYGAgbXVz dCBiZSBidWlsdC1pbiwgYW5kIG1vZHVsYXIgY29kZSBjYW5ub3QgYWRkCisgKiBtb3JlIGl0ZW1z IGluIHRvIHRoZSB0YWJsZSwgdW5sZXNzIGBga2VybmVsL21vZHVsZS5jYGAgZmluZF9tb2R1bGVf c2VjdGlvbnMoKQorICogYW5kIG1vZHVsZS1jb21tb24ubGRzLlMgYXJlIHVwZGF0ZWQgYWNjb3Jk aW5nbHkgd2l0aCBhIHJlc3BlY3RpdmUKKyAqIG1vZHVsZSBub3RpZmllciB0byBhY2NvdW50IGZv ciB1cGRhdGVzLiBUaGlzIHJlc3RyaWN0aW9uIG1heSBiZSBlbmhhbmNlZAorICogaW4gdGhlIGZ1 dHVyZS4KKyAqLworCisvKioKKyAqIERPQzogTGlua2VyIHRhYmxlIGhlbHBlcnMKKyAqCisgKiBU aGVzZSBhcmUgaGVscGVycyBmb3IgbGlua2VyIHRhYmxlcy4KKyAqLworCisvKioKKyAqIExJTktU QUJMRV9BRERSX1dJVEhJTiAtIHJldHVybnMgdHJ1ZSBpZiBhZGRyZXNzIGlzIGluIHJhbmdlCisg KgorICogQHRibDogbGlua2VyIHRhYmxlCisgKiBAYWRkcjogYWRkcmVzcyB0byBxdWVyeSBmb3IK KyAqCisgKiBSZXR1cm5zIHRydWUgaWYgdGhlIGFkZHJlc3MgaXMgcGFydCBvZiB0aGUgbGlua2Vy IHRhYmxlLgorICovCisjZGVmaW5lIExJTktUQUJMRV9BRERSX1dJVEhJTih0YmwsIGFkZHIpCQkJ CVwKKwkgKGFkZHIgPj0gKHVuc2lnbmVkIGxvbmcpIExJTlVYX1NFQ1RJT05fU1RBUlQodGJsKSAm JgkJXAorICAgICAgICAgIGFkZHIgPCAodW5zaWduZWQgbG9uZykgTElOVVhfU0VDVElPTl9FTkQo dGJsKSkKKworLyoqCisgKiBET0M6IENvbnN0cnVjdGluZyBsaW5rZXIgdGFibGVzCisgKgorICog TGlua2VyIHRhYmxlcyBjb25zdHJ1Y3RvcnMgYXJlIHVzZWQgdG8gYnVpbGQgYW4gZW50cnkgaW50 byBhIGxpbmtlciB0YWJsZS4KKyAqIExpbmtlciB0YWJsZSBjb25zdHJ1Y3RvcnMgZXhpc3QgZm9y IGVhY2ggdHlwZSBvZiBzdXBwb3J0ZWQgc2VjdGlvbi4KKyAqCisgKiBZb3UgaGF2ZSB3ZWFrIGFu ZCByZWd1bGFyIHR5cGUgb2YgbGluayB0YWJsZSBlbnRyeSBjb25zdHJ1Y3RvcnMuCisgKi8KKwor LyoqCisgKiBET0M6IFdlYWsgbGlua2VyIHRhYmxlcyBjb25zdHJ1Y3RvcnMKKyAqCisgKiBUaGUg d2VhayBhdHRyaWJ1dGUgaXMgZGVzaXJhYmxlIGlmIHlvdSB3YW50IGFuIGVudHJ5IHlvdSBjYW4g cmVwbGFjZSBhdAorICogbGluayB0aW1lLiBBIHZlcnkgc3BlY2lhbCB1c2UgY2FzZSBmb3IgbGlu a2VyIHRhYmxlcyBpcyB0aGUgZmlyc3QgZW50cnkuCisgKiBBIHdlYWsgYXR0cmlidXRlIGlzIHVz ZWQgZm9yIHRoZSBmaXJzdCBlbnRyeSB0byBlbnN1cmUgdGhhdCB0aGlzIGVudHJ5J3MKKyAqIGFk ZHJlc3MgbWF0Y2hlcyB0aGUgZW5kIGFkZHJlc3Mgb2YgdGhlIHRhYmxlIHdoZW4gdGhlIGxpbmtl ciB0YWJsZSBpcworICogZW10cHksIGJ1dCB3aWxsIGFsc28gcG9pbnQgdG8gdGhlIGZpcnN0IHJl YWwgZW50cnkgb2YgdGhlIHRhYmxlIG9uY2Ugbm90CisgKiBlbXB0eS4gV2hlbiB0aGUgZmlyc3Qg ZW50cnkgaXMgbGlua2VkIGluLCBpdCB0YWtlcyBwbGFjZSBvZiB0aGUgZmlyc3QgZW50cnkuCisg Ki8KKworLyoqCisgKiBMSU5LVEFCTEVfV0VBSyAtIENvbnN0cnVjdHMgYSB3ZWFrIGxpbmtlciB0 YWJsZSBlbnRyeSBmb3IgZGF0YQorICoKKyAqIEBuYW1lOiBsaW5rZXIgdGFibGUgbmFtZQorICog QGxldmVsOiBvcmRlciBsZXZlbAorICoKKyAqIENvbnN0cnVjdHMgYSB3ZWFrIGxpbmtlciB0YWJs ZSBmb3IgZGF0YS4KKyAqLworI2RlZmluZSBMSU5LVEFCTEVfV0VBSyhuYW1lLCBsZXZlbCkJCQkJ CVwKKwkgICAgICBfX3R5cGVvZl9fKFZNTElOVVhfU1lNQk9MKG5hbWUpWzBdKQkJCVwKKwkgICAg ICBfX2F0dHJpYnV0ZV9fKCh1c2VkLAkJCQkJXAorCQkJICAgICB3ZWFrLAkJCQkJXAorCQkJICAg ICBfX2FsaWduZWRfXyhMSU5VWF9TRUNUSU9OX0FMSUdOTUVOVChuYW1lKSksXAorCQkJICAgICBz ZWN0aW9uKFNFQ1RJT05fVEJMKFNFQ1RJT05fREFUQSwJCVwKKwkJCQkgICAgIG5hbWUsIGxldmVs KSkpKQorCisvKioKKyAqIExJTktUQUJMRV9URVhUX1dFQUsgLSBDb25zdHJ1Y3RzIGEgd2VhayBs aW5rZXIgdGFibGUgZW50cnkgZm9yIGV4ZWN1dGlvbgorICoKKyAqIEBuYW1lOiBsaW5rZXIgdGFi bGUgbmFtZQorICogQGxldmVsOiBvcmRlciBsZXZlbAorICoKKyAqIENvbnN0cnVjdHMgYSB3ZWFr IGxpbmtlciB0YWJsZSBmb3IgY29kZSBleGVjdXRpb24uIFRoZXNlIHdpbGwgYmUKKyAqIHJlYWQt b25seS4KKyAqLworI2RlZmluZSBMSU5LVEFCTEVfVEVYVF9XRUFLKG5hbWUsIGxldmVsKQkJCQlc CisJY29uc3QgX190eXBlb2ZfXyhWTUxJTlVYX1NZTUJPTChuYW1lKVswXSkJCQlcCisJICAgICAg X19hdHRyaWJ1dGVfXygodXNlZCwJCQkJCVwKKwkJCSAgICAgd2VhaywJCQkJCVwKKwkJCSAgICAg X19hbGlnbmVkX18oTElOVVhfU0VDVElPTl9BTElHTk1FTlQobmFtZSkpLFwKKwkJCSAgICAgc2Vj dGlvbihTRUNUSU9OX1RCTChTRUNUSU9OX1RFWFQsCQlcCisJCQkJICAgICBuYW1lLCBsZXZlbCkp KSkKKworLyoqCisgKiBMSU5LVEFCTEVfUk9fV0VBSyAtIENvbnN0cnVjdHMgYSB3ZWFrIHJlYWQt b25seSBsaW5rZXIgdGFibGUgZW50cnkKKyAqCisgKiBAbmFtZTogbGlua2VyIHRhYmxlIG5hbWUK KyAqIEBsZXZlbDogb3JkZXIgbGV2ZWwKKyAqCisgKiBDb25zdHJ1Y3RzIGEgd2VhayBsaW5rZXIg dGFibGUgd2hpY2ggb25seSByZXF1aXJlcyByZWFkLW9ubHkgYWNjZXNzLgorICovCisjZGVmaW5l IExJTktUQUJMRV9ST19XRUFLKG5hbWUsIGxldmVsKQkJCQkJXAorCWNvbnN0IF9fdHlwZW9mX18o Vk1MSU5VWF9TWU1CT0wobmFtZSlbMF0pCQkJXAorCSAgICAgIF9fYXR0cmlidXRlX18oKHVzZWQs CQkJCQlcCisJCQkgICAgIHdlYWssCQkJCQlcCisJCQkgICAgIF9fYWxpZ25lZF9fKExJTlVYX1NF Q1RJT05fQUxJR05NRU5UKG5hbWUpKSxcCisJCQkgICAgIHNlY3Rpb24oU0VDVElPTl9UQkwoU0VD VElPTl9UQkxfUk8sCVwKKwkJCQkJCSBuYW1lLCBsZXZlbCkpKSkKKworLyoqCisgKiBMSU5LVEFC TEVfSU5JVF9XRUFLIC0gQ29uc3RydWN0cyBhIHdlYWsgbGlua2VyIHRhYmxlIGVudHJ5IGZvciBp bml0IGNvZGUKKyAqCisgKiBAbmFtZTogbGlua2VyIHRhYmxlIG5hbWUKKyAqIEBsZXZlbDogb3Jk ZXIgbGV2ZWwKKyAqCisgKiBDb25zdHJ1Y3RzIGEgd2VhayBsaW5rZXIgdGFibGUgZm9yIGV4ZWN1 dGlvbi4gdXNlIGF0IGluaXQuCisgKi8KKyNkZWZpbmUgTElOS1RBQkxFX0lOSVRfV0VBSyhuYW1l LCBsZXZlbCkJCQkJXAorCWNvbnN0IF9fdHlwZW9mX18oVk1MSU5VWF9TWU1CT0wobmFtZSlbMF0p CQkJXAorCSAgICAgIF9fYXR0cmlidXRlX18oKHVzZWQsCQkJCQlcCisJCQkgICAgIHdlYWssCQkJ CQlcCisJCQkgICAgIF9fYWxpZ25lZF9fKExJTlVYX1NFQ1RJT05fQUxJR05NRU5UKG5hbWUpKSxc CisJCQkgICAgIHNlY3Rpb24oU0VDVElPTl9UQkwoU0VDVElPTl9JTklULAkJXAorCQkJCQkJIG5h bWUsIGxldmVsKSkpKQorCisvKioKKyAqIExJTktUQUJMRV9JTklUX0RBVEFfV0VBSyAtIENvbnN0 cnVjdHMgYSB3ZWFrIGxpbmtlciB0YWJsZSBlbnRyeSBmb3IgaW5pdGRhdGEKKyAqCisgKiBAbmFt ZTogbGlua2VyIHRhYmxlIG5hbWUKKyAqIEBsZXZlbDogb3JkZXIgbGV2ZWwKKyAqCisgKiBDb25z dHJ1Y3RzIGEgd2VhayBsaW5rZXIgdGFibGUgZm9yIGRhdGEgZHVyaW5nIGluaXQuCisgKi8KKyNk ZWZpbmUgTElOS1RBQkxFX0lOSVRfREFUQV9XRUFLKG5hbWUsIGxldmVsKQkJCQlcCisJICAgICAg X190eXBlb2ZfXyhWTUxJTlVYX1NZTUJPTChuYW1lKVswXSkJCQlcCisJICAgICAgX19hdHRyaWJ1 dGVfXygodXNlZCwJCQkJCVwKKwkJCSAgICAgd2VhaywJCQkJCVwKKwkJCSAgICAgX19hbGlnbmVk X18oTElOVVhfU0VDVElPTl9BTElHTk1FTlQobmFtZSkpLFwKKwkJCSAgICAgc2VjdGlvbihTRUNU SU9OX1RCTChTRUNUSU9OX0lOSVRfREFUQSwJXAorCQkJCQkJIG5hbWUsIGxldmVsKSkpKQorCisv KioKKyAqIERPQzogUmVndWxhciBsaW5rZXIgbGlua2VyIHRhYmxlIGNvbnN0cnVjdG9ycworICoK KyAqIFJlZ3VsYXIgY29uc3RydWN0b3JzIGFyZSBleHBlY3RlZCB0byBiZSB1c2VkIGZvciB2YWxp ZCBsaW5rZXIgdGFibGUgZW50cmllcy4KKyAqIFZhbGlkIHVzZXMgb2Ygd2VhayBlbnRyaWVzIG90 aGVyIHRoYW4gdGhlIGJlZ2lubmluZyBhbmQgaXMgY3VycmVudGx5CisgKiB1bnRlc3RlZCBidXQg c2hvdWxkIGluIHRoZW9yeSB3b3JrLgorICovCisKKy8qKgorICogTElOS1RBQkxFIC0gRGVjbGFy ZXMgYSBkYXRhIGxpbmtlciB0YWJsZSBlbnRyeQorICoKKyAqIEBuYW1lOiBsaW5rZXIgdGFibGUg bmFtZQorICogQGxldmVsOiBvcmRlciBsZXZlbAorICoKKyAqIERlY2xhcmVzIGEgZGF0YSBsaW5r ZXIgdGFibGUgZW50cnkuIFRoZXNlIGFyZSByZWFkLXdyaXRlLgorICovCisjZGVmaW5lIExJTktU QUJMRShuYW1lLCBsZXZlbCkJCQkJCQlcCisJICAgICAgX190eXBlb2ZfXyhWTUxJTlVYX1NZTUJP TChuYW1lKVswXSkJCQlcCisJICAgICAgX19hdHRyaWJ1dGVfXygodXNlZCwJCQkJCVwKKwkJCSAg ICAgX19hbGlnbmVkX18oTElOVVhfU0VDVElPTl9BTElHTk1FTlQobmFtZSkpLFwKKwkJCSAgICAg c2VjdGlvbihTRUNUSU9OX1RCTChTRUNUSU9OX0RBVEEsCQlcCisJCQkJCQkgbmFtZSwgbGV2ZWwp KSkpCisKKy8qKgorICogTElOS1RBQkxFX1RFWFQgLSBEZWNsYXJlcyBhIGxpbmtlciB0YWJsZSBl bnRyeSBmb3IgZXhlY3V0aW9uCisgKgorICogQG5hbWU6IGxpbmtlciB0YWJsZSBuYW1lCisgKiBA bGV2ZWw6IG9yZGVyIGxldmVsCisgKgorICogRGVjbGFyZXMgYSBsaW5rZXIgdGFibGUgdG8gYmUg dXNlZCBmb3IgZXhlY3V0aW9uLgorICovCisjZGVmaW5lIExJTktUQUJMRV9URVhUKG5hbWUsIGxl dmVsKQkJCQkJXAorCWNvbnN0IF9fdHlwZW9mX18oVk1MSU5VWF9TWU1CT0wobmFtZSlbMF0pCQkJ XAorCSAgICAgIF9fYXR0cmlidXRlX18oKHVzZWQsCQkJCQlcCisJCQkgICAgIF9fYWxpZ25lZF9f KExJTlVYX1NFQ1RJT05fQUxJR05NRU5UKG5hbWUpKSxcCisJCQkgICAgIHNlY3Rpb24oU0VDVElP Tl9UQkwoU0VDVElPTl9URVhULAkJXAorCQkJCQkJIG5hbWUsIGxldmVsKSkpKQorCisvKioKKyAq IExJTktUQUJMRV9STyAtIERlY2xhcmVzIGEgcmVhZC1vbmx5IGxpbmtlciB0YWJsZSBlbnRyeS4K KyAqCisgKiBAbmFtZTogbGlua2VyIHRhYmxlIG5hbWUKKyAqIEBsZXZlbDogb3JkZXIgbGV2ZWwK KyAqCisgKiBEZWNsYXJlcyBhIGxpbmtlciB0YWJsZSB3aGljaCBvbmx5IHJlcXVpcmVzIHJlYWQt b25seSBhY2Nlc3MuIENvbnRyYXJ5CisgKiB0byBMSU5LVEFCTEVfUk9fV0VBSygpIHdoaWNoIHVz ZXMgU0VDVElPTl9ST0RBVEEgdGhpcyBoZWxwZXIgdXNlcyB0aGUKKyAqIHNlY3Rpb24gU0VDVElP Tl9UQkxfUk8gaGVyZSBkdWUgdG8gcG9zc2libGUgdG9vbGNoYWlucyBidWcgb24gc29tZQorICog YXJjaGl0ZWN0dXJlcywgZm9yIGluc3RhbmNlIHRoZSBjNnggYXJjaGl0aWN0dXJlIHN0dWZmcyBu b24td2VhayBkYXRhCisgKiBpbnRvIGRpZmZlcmVudCBzZWN0aW9ucyBvdGhlciB0aGFuIHRoZSBv bmUgaW50ZW5kZWQuCisgKi8KKyNkZWZpbmUgTElOS1RBQkxFX1JPKG5hbWUsIGxldmVsKQkJCQkJ XAorCWNvbnN0IF9fdHlwZW9mX18oVk1MSU5VWF9TWU1CT0wobmFtZSlbMF0pCQkJXAorCSAgICAg IF9fYXR0cmlidXRlX18oKHVzZWQsCQkJCQlcCisJCQkgICAgIF9fYWxpZ25lZF9fKExJTlVYX1NF Q1RJT05fQUxJR05NRU5UKG5hbWUpKSxcCisJCQkgICAgIHNlY3Rpb24oU0VDVElPTl9UQkwoU0VD VElPTl9UQkxfUk8sCVwKKwkJCQkJCSBuYW1lLCBsZXZlbCkpKSkKKworLyoqCisgKiBMSU5LVEFC TEVfSU5JVCAtIERlY2xhcmVzIGEgbGlua2VyIHRhYmxlIGVudHJ5IHRvIGJlIHVzZWQgb24gaW5p dC4KKyAqCisgKiBAbmFtZTogbGlua2VyIHRhYmxlIG5hbWUKKyAqIEBsZXZlbDogb3JkZXIgbGV2 ZWwKKyAqCisgKiBEZWNsYXJlcyBhIGxpbmtlciB0YWJsZSBlbnRyeSBmb3IgZXhlY3V0aW9uIHVz ZSBkdXJpbmcgaW5pdC4KKyAqLworI2RlZmluZSBMSU5LVEFCTEVfSU5JVChuYW1lLCBsZXZlbCkJ CQkJCVwKKwljb25zdCBfX3R5cGVvZl9fKFZNTElOVVhfU1lNQk9MKG5hbWUpWzBdKQkJCVwKKwkg ICAgICBfX2F0dHJpYnV0ZV9fKCh1c2VkLAkJCQkJXAorCQkJICAgICBfX2FsaWduZWRfXyhMSU5V WF9TRUNUSU9OX0FMSUdOX0ZVTkMpLAlcCisJCQkgICAgIHNlY3Rpb24oU0VDVElPTl9UQkwoU0VD VElPTl9JTklULAkJXAorCQkJCQkJIG5hbWUsIGxldmVsKSkpKQorCisvKioKKyAqIExJTktUQUJM RV9JTklUX0RBVEEgLSBEZWNsYXJlcyBhIGxpbmtlciB0YWJsZSBlbnRyeSB0byBiZSB1c2VkIG9u IGluaXQgZGF0YS4KKyAqCisgKiBAbmFtZTogbGlua2VyIHRhYmxlIG5hbWUKKyAqIEBsZXZlbDog b3JkZXIgbGV2ZWwKKyAqCisgKiBEZWNsYXJlcyBhIGxpbmtlciB0YWJsZSBlbnRyeSBmb3IgZGF0 YSBkdXJpbmcgaW5pdC4KKyAqLworI2RlZmluZSBMSU5LVEFCTEVfSU5JVF9EQVRBKG5hbWUsIGxl dmVsKQkJCQlcCisJICAgICAgX190eXBlb2ZfXyhWTUxJTlVYX1NZTUJPTChuYW1lKVswXSkJCQlc CisJICAgICAgX19hdHRyaWJ1dGVfXygodXNlZCwJCQkJCVwKKwkJCSAgICAgX19hbGlnbmVkX18o TElOVVhfU0VDVElPTl9BTElHTk1FTlQobmFtZSkpLFwKKwkJCSAgICAgc2VjdGlvbihTRUNUSU9O X1RCTChTRUNUSU9OX0lOSVRfREFUQSwJXAorCQkJCQkJIG5hbWUsIGxldmVsKSkpKQorCisvKioK KyAqIERPQzogRGVjbGFyaW5nIExpbmtlciB0YWJsZXMKKyAqCisgKiBEZWNsYXJlcnMgYXJlIHVz ZWQgdG8gaGVscCBjb2RlIGFjY2VzcyB0aGUgbGlua2VyIHRhYmxlcy4gVHlwaWNhbGx5CisgKiBo ZWFkZXIgZmlsZXMgZm9yIHN1YnN5c3RlbXMgd291bGQgZGVjbGFyZSB0aGUgbGlua2VyIHRhYmxl cyB0byBlbmFibGUKKyAqIGVhc3kgYWNjZXNzIHRvIGFkZCBuZXcgZW50cmllcywgYW5kIHRvIGl0 ZXJhdGUgb3ZlciB0aGUgbGlzdCBvZiB0YWJsZS4KKyAqIFRoZXJlIGFyZSBvbmx5IHR3byBkZWNs YXJlcnMgbmVlZGVkIGdpdmVuIHRoYXQgdGhlIHNlY3Rpb24gYXNzb2NpYXRpb24KKyAqIGlzIGRv bmUgYnkgdGhlIGRlZmluaXRpb24gb2YgdGhlIGxpbmtlciB0YWJsZSB1c2luZyBgYERFRklORV9M SU5LVEFCTEUqKClgYAorICogaGVscGVycy4KKyAqLworCisKKy8qKgorICogREVDTEFSRV9MSU5L VEFCTEUgLSBEZWNsYXJlcyBhIGRhdGEgbGlua2VyIHRhYmxlIGVudHJ5CisgKgorICogQHR5cGU6 IGRhdGEgdHlwZQorICogQG5hbWU6IHRhYmxlIG5hbWUKKyAqCisgKiBEZWNsYXJlcyBhIGRhdGEg bGlua2VyIHRhYmxlIGVudHJ5LgorICovCisjZGVmaW5lIERFQ0xBUkVfTElOS1RBQkxFKHR5cGUs IG5hbWUpCQkJCQlcCisJREVDTEFSRV9MSU5VWF9TRUNUSU9OKHR5cGUsIG5hbWUpCisKKy8qKgor ICogREVDTEFSRV9MSU5LVEFCTEVfUk8gLSBEZWNsYXJlcyBhIHJlYWQtb25seSBsaW5rZXIgdGFi bGUgZW50cnkKKyAqCisgKiBAdHlwZTogZGF0YSB0eXBlCisgKiBAbmFtZTogdGFibGUgbmFtZQor ICoKKyAqIERlY2xhcmVzIGEgcmVhZC1vbmx5IGxpbmtlciB0YWJsZSBlbnRyeS4KKyAqLworI2Rl ZmluZSBERUNMQVJFX0xJTktUQUJMRV9STyh0eXBlLCBuYW1lKQkJCQlcCisJREVDTEFSRV9MSU5V WF9TRUNUSU9OX1JPKHR5cGUsIG5hbWUpCisKKy8qKgorICogRE9DOiBEZWZpbmluZyBMaW5rZXIg dGFibGVzCisgKgorICogTGlua2VyIHRhYmxlcyBhcmUgZGVmaW5lZCBpbiB0aGUgY29kZSB0aGF0 IHRha2VzIG93bmVyc2hpcCBvdmVyCisgKiB0aGUgbGlua2VyIHRhYmxlLiBUaGlzIGlzIHR5cGlj YWxseSBkb25lIGluIHRoZSBzYW1lIGNvZGUgdGhhdCBpcyBpbgorICogY2hhcmdlIG9mIGl0ZXJh dGluZyBvdmVyIHRoZSBsaW5rZXIgdGFibGUgYXMgd2VsbC4KKyAqLworCisvKioKKyAqIERFRklO RV9MSU5LVEFCTEUgLSBEZWZpbmVzIGEgbGlua2VyIHRhYmxlIGZvciBkYXRhCisgKgorICogQHR5 cGU6IGRhdGEgdHlwZQorICogQG5hbWU6IHRhYmxlIG5hbWUKKyAqCisgKiBEZWZpbmVzIGEgbGlu a2VyIHRhYmxlIHdoaWNoIHVzZWQgZm9yIGRhdGEuCisgKi8KKyNkZWZpbmUgREVGSU5FX0xJTktU QUJMRSh0eXBlLCBuYW1lKQkJCQkJXAorCURFQ0xBUkVfTElOS1RBQkxFKHR5cGUsIG5hbWUpOwkJ CQkJXAorCUxJTktUQUJMRV9XRUFLKG5hbWUsKSBWTUxJTlVYX1NZTUJPTChuYW1lKVswXSA9IHt9 OwkJXAorCUxJTktUQUJMRShuYW1lLCB+KSBWTUxJTlVYX1NZTUJPTChuYW1lIyNfX2VuZClbMF0g PSB7fQorCisvKioKKyAqIERFRklORV9MSU5LVEFCTEVfVEVYVCAtIERlY2xhcmVzIGxpbmtlciB0 YWJsZSBlbnRyeSBmb3IgZXhlY3R1aW9uCisgKgorICogQHR5cGU6IGRhdGEgdHlwZQorICogQG5h bWU6IHRhYmxlIG5hbWUKKyAqCisgKiBEZWNsYXJlcyBhIGxpbmtlciB0YWJsZSBlbnRyeSBmb3Ig ZXhlY3V0aW9uLgorICovCisjZGVmaW5lIERFRklORV9MSU5LVEFCTEVfVEVYVCh0eXBlLCBuYW1l KQkJCQlcCisJREVDTEFSRV9MSU5LVEFCTEVfUk8odHlwZSwgbmFtZSk7CQkJCVwKKwlMSU5LVEFC TEVfVEVYVF9XRUFLKG5hbWUsKSBWTUxJTlVYX1NZTUJPTChuYW1lKVswXSA9IHt9OwlcCisJTElO S1RBQkxFX1RFWFQobmFtZSwgfikgVk1MSU5VWF9TWU1CT0wobmFtZSMjX19lbmQpWzBdID0ge30K KworLyoqCisgKiBERUZJTkVfTElOS1RBQkxFX1JPIC0gRGVmaW5lcyBhIHJlYWQtb25seSBsaW5r ZXIgdGFibGUKKyAqCisgKiBAdHlwZTogZGF0YSB0eXBlCisgKiBAbmFtZTogdGFibGUgbmFtZQor ICoKKyAqIERlZmluZXMgYSBsaW5rZXIgdGFibGUgd2hpY2ggd2Uga25vdyBvbmx5IHJlcXVpcmVz IHJlYWQtb25seSBhY2Nlc3MuCisgKi8KKyNkZWZpbmUgREVGSU5FX0xJTktUQUJMRV9STyh0eXBl LCBuYW1lKQkJCQkJXAorCURFQ0xBUkVfTElOS1RBQkxFX1JPKHR5cGUsIG5hbWUpOwkJCQlcCisJ TElOS1RBQkxFX1JPX1dFQUsobmFtZSwpIFZNTElOVVhfU1lNQk9MKG5hbWUpWzBdID0ge307CQlc CisJTElOS1RBQkxFX1JPKG5hbWUsIH4pIFZNTElOVVhfU1lNQk9MKG5hbWUjI19fZW5kKVswXSA9 IHt9CisKKy8qKgorICogREVGSU5FX0xJTktUQUJMRV9JTklUIC0gRGVmaW5lcyBhbiBpbml0IHRp bWUgbGlua2VyIHRhYmxlIGZvciBleGVjdXRpb24KKyAqCisgKiBAdHlwZTogZGF0YSB0eXBlCisg KiBAbmFtZTogdGFibGUgbmFtZQorICoKKyAqIERlZmluZXMgYSBsaW5rZXIgdGFibGUuIElmIHlv dSBhcmUgYWRkaW5nIGEgbmV3IHR5cGUgeW91IHNob3VsZAorICogZW5hYmxlIGBgQ09ORklHX0RF QlVHX1NFQ1RJT05fTUlTTUFUQ0hgYCBhbmQgZW5zdXJlIHJvdXRpbmVzIHRoYXQgbWFrZQorICog dXNlIG9mIHRoZSBsaW5rZXIgdGFibGVzIGdldCBhIHJlc3BlY3RpdmUgX19yZWYgdGFnLgorICov CisjZGVmaW5lIERFRklORV9MSU5LVEFCTEVfSU5JVCh0eXBlLCBuYW1lKQkJCQlcCisJREVDTEFS RV9MSU5LVEFCTEUodHlwZSwgbmFtZSk7CQkJCQlcCisJTElOS1RBQkxFX0lOSVRfV0VBSyhuYW1l LCkgVk1MSU5VWF9TWU1CT0wobmFtZSlbMF0gPSB7fTsJXAorCUxJTktUQUJMRV9JTklUKG5hbWUs IH4pIFZNTElOVVhfU1lNQk9MKG5hbWUjI19fZW5kKVswXSA9IHt9CisKKy8qKgorICogREVGSU5F X0xJTktUQUJMRV9JTklUX0RBVEEgLSBEZWZpbmVzIGFuIGluaXQgdGltZSBsaW5rZXIgdGFibGUg Zm9yIGRhdGEKKyAqCisgKiBAdHlwZTogZGF0YSB0eXBlCisgKiBAbmFtZTogdGFibGUgbmFtZQor ICoKKyAqIERlZmluZXMgYSBsaW5rZXIgdGFibGUgZm9yIGluaXQgZGF0YS4gSWYgeW91IGFyZSBh ZGRpbmcgYSBuZXcgdHlwZSB5b3UKKyAqIHNob3VsZCBlbmFibGUgYGBDT05GSUdfREVCVUdfU0VD VElPTl9NSVNNQVRDSGBgIGFuZCBlbnN1cmUgcm91dGluZXMgdGhhdAorICogbWFrZSB1c2Ugb2Yg dGhlIGxpbmtlciB0YWJsZXMgZ2V0IGEgcmVzcGVjdGl2ZSBfX3JlZiB0YWcuCisgKi8KKyNkZWZp bmUgREVGSU5FX0xJTktUQUJMRV9JTklUX0RBVEEodHlwZSwgbmFtZSkJCQkJXAorCURFQ0xBUkVf TElOS1RBQkxFKHR5cGUsIG5hbWUpOwkJCQkJXAorCUxJTktUQUJMRV9JTklUX0RBVEFfV0VBSyhu YW1lLCkgVk1MSU5VWF9TWU1CT0wobmFtZSlbMF0gPSB7fTsJXAorCUxJTktUQUJMRV9JTklUX0RB VEEobmFtZSwgfikgVk1MSU5VWF9TWU1CT0wobmFtZSMjX19lbmQpWzBdID0ge30KKworLyoqCisg KiBET0M6IEl0ZXJhdGluZyBvdmVyIExpbmtlciB0YWJsZXMKKyAqCisgKiBUbyBtYWtlIHVzZSBv ZiB0aGUgbGlua2VyIHRhYmxlcyB5b3Ugd2FudCB0byBiZSBhYmxlIHRvIGl0ZXJhdGUgb3Zlcgor ICogdGhlbS4gVGhpcyBzZWN0aW9uIGRvY3VtZW50cyB0aGUgZGlmZmVyZW50IGl0ZXJhdG9ycyBh dmFpbGFibGUuCisgKi8KKworLyoqCisgKiBMSU5LVEFCTEVfRk9SX0VBQ0ggLSBpdGVyYXRlIHRo cm91Z2ggYWxsIGVudHJpZXMgd2l0aGluIGEgbGlua2VyIHRhYmxlCisgKgorICogQHBvaW50ZXI6 IGVudHJ5IHBvaW50ZXIKKyAqIEB0Ymw6IGxpbmtlciB0YWJsZQorICoKKyAqIEV4YW1wbGUgdXNh Z2U6OgorICoKKyAqICAgc3RydWN0IGZyb2JuaWNhdG9yICpmcm9iOworICoKKyAqICAgTElOS1RB QkxFX0ZPUl9FQUNIKGZyb2IsIGZyb2JuaWNhdG9yX2ZucykgeworICogICAgIC4uLgorICogICB9 CisgKi8KKworI2RlZmluZSBMSU5LVEFCTEVfRk9SX0VBQ0gocG9pbnRlciwgdGJsKQkJCQlcCisJ Zm9yIChwb2ludGVyID0gTElOVVhfU0VDVElPTl9TVEFSVCh0YmwpOwkJCVwKKwkgICAgIHBvaW50 ZXIgPCBMSU5VWF9TRUNUSU9OX0VORCh0YmwpOwkJCQlcCisJICAgICBwb2ludGVyKyspCisKKy8q KgorICogTElOS1RBQkxFX1JVTl9BTEwgLSBpdGVyYXRlIGFuZCBydW4gdGhyb3VnaCBhbGwgZW50 cmllcyBvbiBhIGxpbmtlciB0YWJsZQorICoKKyAqIEB0Ymw6IGxpbmtlciB0YWJsZQorICogQGZ1 bmM6IHN0cnVjdHVyZSBuYW1lIGZvciB0aGUgZnVuY3Rpb24gbmFtZSB3ZSB3YW50IHRvIGNhbGwu CisgKiBAYXJncy4uLjogYXJndW1lbnRzIHRvIHBhc3MgdG8gZnVuYworICoKKyAqIEV4YW1wbGUg dXNhZ2U6OgorICoKKyAqICAgTElOS1RBQkxFX1JVTl9BTEwoZnJvYm5pY2F0b3JfZm5zLCBzb21l X3J1biwpOworICovCisjZGVmaW5lIExJTktUQUJMRV9SVU5fQUxMKHRibCwgZnVuYywgYXJncy4u LikJCQkJXAorZG8gewkJCQkJCQkJCVwKKwlzaXplX3QgaTsJCQkJCQkJXAorCWZvciAoaSA9IDA7 IGkgPCBMSU5VWF9TRUNUSU9OX1NJWkUodGJsKTsgaSsrKQkJCVwKKwkJKFZNTElOVVhfU1lNQk9M KHRibClbaV0pLmZ1bmMgKGFyZ3MpOwkJCVwKK30gd2hpbGUgKDApCisKKy8qKgorICogTElOS1RB QkxFX1JVTl9FUlIgLSBydW4gZWFjaCBsaW5rZXIgdGFibGUgZW50cnkgZnVuYyBhbmQgcmV0dXJu IGVycm9yIGlmIGFueQorICoKKyAqIEB0Ymw6IGxpbmtlciB0YWJsZQorICogQGZ1bmM6IHN0cnVj dHVyZSBuYW1lIGZvciB0aGUgZnVuY3Rpb24gbmFtZSB3ZSB3YW50IHRvIGNhbGwuCisgKiBAYXJn cy4uLjogYXJndW1lbnRzIHRvIHBhc3MgdG8gZnVuYworICoKKyAqIEV4YW1wbGUgdXNhZ2U6Ogor ICoKKyAqICAgdW5zaWduZWQgaW50IGVyciA9IExJTktUQUJMRV9SVU5fRVJSKGZyb2JuaWNhdG9y X2Zucywgc29tZV9ydW4sKTsKKyAqLworI2RlZmluZSBMSU5LVEFCTEVfUlVOX0VSUih0YmwsIGZ1 bmMsIGFyZ3MuLi4pCQkJCVwKKyh7CQkJCQkJCQkJXAorCXNpemVfdCBpOwkJCQkJCQlcCisJaW50 IGVyciA9IDA7CQkJCQkJCVwKKwlmb3IgKGkgPSAwOyAhZXJyICYmIGkgPCBMSU5VWF9TRUNUSU9O X1NJWkUodGJsKTsgaSsrKQkJXAorCQllcnIgPSAoVk1MSU5VWF9TWU1CT0wodGJsKVtpXSkuZnVu YyAoYXJncyk7CQlcCisJCWVycjsgXAorfSkKKworI2VuZGlmIC8qIF9fQVNTRU1CTFlfXyAqLwor CisjZW5kaWYgLyogX0xJTlVYX0xJTktFUl9UQUJMRVNfSCAqLwpkaWZmIC0tZ2l0IGEvc2NyaXB0 cy9NYWtlZmlsZS5jbGVhbiBiL3NjcmlwdHMvTWFrZWZpbGUuY2xlYW4KaW5kZXggNTA2MTZlYTI1 MTMxLi4yYjU0NTQ2MjM3ZDYgMTAwNjQ0Ci0tLSBhL3NjcmlwdHMvTWFrZWZpbGUuY2xlYW4KKysr IGIvc2NyaXB0cy9NYWtlZmlsZS5jbGVhbgpAQCAtMzYsNiArMzYsOCBAQCBzdWJkaXIteW1uCTo9 ICQoYWRkcHJlZml4ICQob2JqKS8sJChzdWJkaXIteW1uKSkKICMgZGlyZWN0b3J5CiAKIF9fY2xl YW4tZmlsZXMJOj0gJChleHRyYS15KSAkKGV4dHJhLW0pICQoZXh0cmEtKSAgICAgICBcCisJCSAg ICQoZm9yY2Utb2JqLXkpICQoZm9yY2Utb2JqLW0pICQoZm9yY2Utb2JqLSkgICAgICAgXAorCQkg ICAkKGZvcmNlLWxpYi15KSAkKGZvcmNlLWxpYi1tKSAkKGZvcmNlLWxpYi0pICAgICAgIFwKIAkJ ICAgJChhbHdheXMpICQodGFyZ2V0cykgJChjbGVhbi1maWxlcykgICBcCiAJCSAgICQoaG9zdC1w cm9ncykgICAgICAgICAgICAgICAgICAgICAgICAgXAogCQkgICAkKGhvc3Rwcm9ncy15KSAkKGhv c3Rwcm9ncy1tKSAkKGhvc3Rwcm9ncy0pIFwKLS0gCjIuOS4yCgoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4t ZGV2ZWxAbGlzdHMueGVuLm9yZwpodHRwczovL2xpc3RzLnhlbi5vcmcveGVuLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.kernel.org ([198.145.29.136]:38330 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754947AbcHSVey (ORCPT ); Fri, 19 Aug 2016 17:34:54 -0400 From: mcgrof@kernel.org Subject: [PATCH v4 07/16] tables.h: add linker table support Date: Fri, 19 Aug 2016 14:32:56 -0700 Message-Id: <1471642385-5629-8-git-send-email-mcgrof@kernel.org> In-Reply-To: <1471642385-5629-1-git-send-email-mcgrof@kernel.org> References: <1471642385-5629-1-git-send-email-mcgrof@kernel.org> Sender: linux-kbuild-owner@vger.kernel.org List-ID: To: hpa@zytor.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, linux@arm.linux.org.uk, mhiramat@kernel.org, masami.hiramatsu.pt@hitachi.com, jbaron@akamai.com, heiko.carstens@de.ibm.com, ananth@linux.vnet.ibm.com, anil.s.keshavamurthy@intel.com, davem@davemloft.net, realmz6@gmail.com Cc: x86@kernel.org, luto@amacapital.net, keescook@chromium.org, torvalds@linux-foundation.org, gregkh@linuxfoundation.org, rusty@rustcorp.com.au, gnomes@lxorguk.ukuu.org.uk, alan@linux.intel.com, dwmw2@infradead.org, arnd@arndb.de, ming.lei@canonical.com, linux-arch@vger.kernel.org, benh@kernel.crashing.org, ananth@in.ibm.com, pebolle@tiscali.nl, fontana@sharpeleven.org, david.vrabel@citrix.com, konrad.wilk@oracle.com, mcb30@ipxe.org, jgross@suse.com, andrew.cooper3@citrix.com, andriy.shevchenko@linux.intel.com, paul.gortmaker@windriver.com, xen-devel@lists.xensource.com, ak@linux.intel.com, pali.rohar@gmail.com, dvhart@infradead.org, platform-driver-x86@vger.kernel.org, mmarek@suse.com, linux@rasmusvillemoes.dk, jkosina@suse.cz, korea.drzix@gmail.com, linux-kbuild@vger.kernel.org, tony.luck@intel.com, akpm@linux-foundation.org, linux-ia64@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sh@vger.kernel.org, sparclinux@vger.kernel.org, catalin.marinas@arm.com, will.deacon@arm.com, rostedt@goodmis.org, jani.nikula@intel.com, mchehab@osg.samsung.com, markus.heiser@darmarit.de, acme@redhat.com, jolsa@kernel.org, msalter@redhat.com, chris@zankel.net, jcmvbkbc@gmail.com, linux-xtensa@linux-xtensa.org, paulus@samba.org, mpe@ellerman.id.au, James.Bottomley@HansenPartnership.com, "Luis R. Rodriguez" From: "Luis R. Rodriguez" A linker table is a data structure that is stitched together from items in multiple object files. Linux has historically implicitly used linker tables for ages, however they were all built in an adhoc manner which requires linker script modifications, per architecture. This adds a general linker table solution so that a new linker table can be implemented by changing C code only. The Linux linker table was inspired by Michael Brown's iPXE's linker table solution, it has been been completely re-written and adapted for integration and use on Linux. The same philosophy is borrowed, extended and further simplified: Linker tables enable an extremely light weight linker build time solution for feature ordering and selection, this can help to both simplify init sequences in a generic fashion and helps avoiding code bit-rotting when desirable. Further changes will be added later which will make more evident how code bit rot can be avoided using linker tables. v4: o Split out kbuild additions to help with code bit rot into its own patch o tons of documentation love o fix arch/x86/tools/relocs.c typo - which caused compilation issues on old toolchains o add c6x toolchain work around as discussed with Mark Salter o sprinkle a few more needed VMLINUX_SYMBOL() - fixes compilation on blackfin o suggested name changes by boris: - %s/SECTION_TYPE_RANGES/rng/g - %s/SECTION_TYPE/SECTION_CORE/g - %s/section_type_asmtype/section_core_type/g - %s/section_type/section_core/g - %s/section_rng/set_section_rng/g - Drop DECLARE_SECTION_TBL() -- this is an asm equivalent DEFINE_LINKTABLE() -- this however is not used yet, and it requires a bit more work to match the C code definitions. o drop tools/include/linux/sections.h in favor of the more popular open coding the names for tools o expand documentation to include module support o add maintaners o Use generic-y o move .text.tbl before unlikely to match the other sections v3: o addressed initial modular support test cases o added generic asm macros so linker tables can be used in asm code / C asm calls o section ranges are now split up into their own set of files o use asm/sections.h instead of linux/sections.h for the linker script o add a sections.h file for each architecture that was missing one, this is needed now as we'll be relying on sections.h for custom section types in code rather than custom architecture specific linker script hacks. o full rewrite at this point, decided to pick copyleft-next license for this work v2: o modified completely to match feedback by community, made equivalent modifications to userspace solution. This is pretty much a complete rewrite of how we present and use linker tables. By using standard sections we no longer have to make custom linker script extensions for each new linker table solution, you just pick a linker table type by section type. o extend documention considerably, including use of kdoc o drop ICC hacks per popular request to ignore such issues for now o use sections.h - this lets us streamline a clean use case of well documented sections. To help further with this make use of SECTION_TBL() to allow use of these in code and SECTION_TBL_ALL() on linker scripts, as well as SECTION_TBL_ALL_STR() on relocs.c when needed. Cc: Michael Brown Signed-off-by: Luis R. Rodriguez --- Documentation/sections/index.rst | 1 + Documentation/sections/linker-tables.rst | 187 ++++++++++ MAINTAINERS | 12 + arch/alpha/include/asm/Kbuild | 1 + arch/arc/include/asm/Kbuild | 1 + arch/arm/include/asm/Kbuild | 1 + arch/arm64/include/asm/Kbuild | 1 + arch/avr32/include/asm/Kbuild | 1 + arch/blackfin/include/asm/Kbuild | 1 + arch/c6x/include/asm/tables.h | 26 ++ arch/cris/include/asm/Kbuild | 1 + arch/frv/include/asm/Kbuild | 1 + arch/h8300/include/asm/Kbuild | 1 + arch/hexagon/include/asm/Kbuild | 1 + arch/ia64/include/asm/Kbuild | 1 + arch/m32r/include/asm/Kbuild | 1 + arch/m68k/include/asm/Kbuild | 1 + arch/metag/include/asm/Kbuild | 1 + arch/microblaze/include/asm/Kbuild | 1 + arch/mips/include/asm/Kbuild | 1 + arch/mn10300/include/asm/Kbuild | 1 + arch/nios2/include/asm/Kbuild | 1 + arch/openrisc/include/asm/Kbuild | 1 + arch/parisc/include/asm/Kbuild | 1 + arch/powerpc/include/asm/Kbuild | 1 + arch/s390/include/asm/Kbuild | 1 + arch/score/include/asm/Kbuild | 1 + arch/sh/include/asm/Kbuild | 1 + arch/sparc/include/asm/Kbuild | 1 + arch/tile/include/asm/Kbuild | 1 + arch/um/include/asm/Kbuild | 1 + arch/unicore32/include/asm/Kbuild | 1 + arch/x86/include/asm/Kbuild | 1 + arch/x86/tools/relocs.c | 2 + arch/xtensa/include/asm/Kbuild | 1 + include/asm-generic/ranges.h | 14 + include/asm-generic/tables.h | 50 +++ include/asm-generic/vmlinux.lds.h | 6 + include/linux/tables.h | 567 +++++++++++++++++++++++++++++++ scripts/Makefile.clean | 2 + 40 files changed, 897 insertions(+) create mode 100644 Documentation/sections/linker-tables.rst create mode 100644 arch/c6x/include/asm/tables.h create mode 100644 include/asm-generic/tables.h create mode 100644 include/linux/tables.h diff --git a/Documentation/sections/index.rst b/Documentation/sections/index.rst index 6dd93ddd5dbe..4514c5738b33 100644 --- a/Documentation/sections/index.rst +++ b/Documentation/sections/index.rst @@ -10,3 +10,4 @@ used throughout the kernel to help declare and define them. section-core ranges + linker-tables diff --git a/Documentation/sections/linker-tables.rst b/Documentation/sections/linker-tables.rst new file mode 100644 index 000000000000..df11c632dca7 --- /dev/null +++ b/Documentation/sections/linker-tables.rst @@ -0,0 +1,187 @@ +=================== +Linux linker tables +=================== + +This documents Linux linker tables, it explains what they are, where they +came from, how they work, the benefits of using them and more importantly +how you can use them. + +About Linker tables +=================== +.. kernel-doc:: include/linux/tables.h + :doc: Introduction + +Linker table provenance +--------------------------------------------- + +.. kernel-doc:: include/linux/tables.h + :doc: Linker table provenance + +Benefits of using Linker tables +=============================== + +Avoids modifying architecture linker scripts +---------------------------------------------- +.. kernel-doc:: include/linux/tables.h + :doc: Avoids modifying architecture linker scripts + +How linker tables simplify initialization code +---------------------------------------------- +.. kernel-doc:: include/linux/tables.h + :doc: How linker tables simplify initialization code + +Using linker tables in Linux +============================ + +Linker table module support +--------------------------- + +.. kernel-doc:: include/linux/tables.h + :doc: Linker table module support + +Linker table helpers +==================== + +.. kernel-doc:: include/linux/tables.h + :doc: Linker table helpers + +LINKTABLE_ADDR_WITHIN +--------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_ADDR_WITHIN + +Constructing linker tables +========================== + +.. kernel-doc:: include/linux/tables.h + :doc: Constructing linker tables + +Weak linker tables constructors +------------------------------- + +.. kernel-doc:: include/linux/tables.h + :doc: Weak linker tables constructors + +LINKTABLE_WEAK +-------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_WEAK + +LINKTABLE_TEXT_WEAK +------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_TEXT_WEAK + +LINKTABLE_RO_WEAK +----------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_RO_WEAK + +LINKTABLE_INIT_WEAK +------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_INIT_WEAK + +LINKTABLE_INIT_DATA_WEAK +------------------------ +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_INIT_DATA_WEAK + +Regular linker linker table constructors +---------------------------------------- + +.. kernel-doc:: include/linux/tables.h + :doc: Regular linker linker table constructors + +LINKTABLE +--------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE + +LINKTABLE_TEXT +-------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_TEXT + +LINKTABLE_RO +------------ +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_RO + +LINKTABLE_INIT +-------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_INIT + +LINKTABLE_INIT_DATA +------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_INIT_DATA + +Declaring Linker tables +======================= + +.. kernel-doc:: include/linux/tables.h + :doc: Declaring Linker tables + +DECLARE_LINKTABLE +---------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DECLARE_LINKTABLE + +DECLARE_LINKTABLE_RO +-------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DECLARE_LINKTABLE_RO + +Defining Linker tables +====================== + +.. kernel-doc:: include/linux/tables.h + :doc: Defining Linker tables + +DEFINE_LINKTABLE +---------------- +.. kernel-doc:: include/linux/tables.h + :functions: DEFINE_LINKTABLE + +DEFINE_LINKTABLE_TEXT +--------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DEFINE_LINKTABLE_TEXT + +DEFINE_LINKTABLE_RO +------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DEFINE_LINKTABLE_RO + +DEFINE_LINKTABLE_INIT +--------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DEFINE_LINKTABLE_INIT + +DEFINE_LINKTABLE_INIT_DATA +-------------------------- +.. kernel-doc:: include/linux/tables.h + :functions: DEFINE_LINKTABLE_INIT_DATA + +Iterating over Linker tables +============================ + +.. kernel-doc:: include/linux/tables.h + :doc: Iterating over Linker tables + +LINKTABLE_FOR_EACH +------------------ +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_FOR_EACH + +LINKTABLE_RUN_ALL +----------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_RUN_ALL + +LINKTABLE_RUN_ERR +----------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_RUN_ERR diff --git a/MAINTAINERS b/MAINTAINERS index 1a217751aa8a..e3569ed12c86 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -5200,6 +5200,18 @@ S: Maintained F: include/asm-generic/ F: include/uapi/asm-generic/ +GENERIC LINKER TABLES +M: "Luis R. Rodriguez" +M: "H. Peter Anvin" +L: linux-arch@vger.kernel.org +L: linux-kernel@vger.kernel.org +T: git git://git.kernel.org/pub/scm/linux/kernel/git/mcgrof/linux.git sections +T: git git://git.kernel.org/pub/scm/linux/kernel/git/mcgrof/linux-next.git sections +S: Supported +F: include/asm-generic/tables.h +F: include/linux/tables.h +F: Documentation/sections/linker-tables.rst + GENERIC PHY FRAMEWORK M: Kishon Vijay Abraham I L: linux-kernel@vger.kernel.org diff --git a/arch/alpha/include/asm/Kbuild b/arch/alpha/include/asm/Kbuild index e44c896b91c4..f3bdc31d3c97 100644 --- a/arch/alpha/include/asm/Kbuild +++ b/arch/alpha/include/asm/Kbuild @@ -12,3 +12,4 @@ generic-y += sections.h generic-y += trace_clock.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/arc/include/asm/Kbuild b/arch/arc/include/asm/Kbuild index e5295413fdf8..70f252472cb9 100644 --- a/arch/arc/include/asm/Kbuild +++ b/arch/arc/include/asm/Kbuild @@ -52,3 +52,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/arm/include/asm/Kbuild b/arch/arm/include/asm/Kbuild index 8e52300e1eed..d13700f573d0 100644 --- a/arch/arm/include/asm/Kbuild +++ b/arch/arm/include/asm/Kbuild @@ -41,3 +41,4 @@ generic-y += trace_clock.h generic-y += unaligned.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/arm64/include/asm/Kbuild b/arch/arm64/include/asm/Kbuild index 5ff184574976..a1991517aad6 100644 --- a/arch/arm64/include/asm/Kbuild +++ b/arch/arm64/include/asm/Kbuild @@ -54,3 +54,4 @@ generic-y += vga.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/avr32/include/asm/Kbuild b/arch/avr32/include/asm/Kbuild index edc176348d7c..a6cd145515ae 100644 --- a/arch/avr32/include/asm/Kbuild +++ b/arch/avr32/include/asm/Kbuild @@ -24,3 +24,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/blackfin/include/asm/Kbuild b/arch/blackfin/include/asm/Kbuild index 35b7752e65c0..b71893b1cd53 100644 --- a/arch/blackfin/include/asm/Kbuild +++ b/arch/blackfin/include/asm/Kbuild @@ -50,3 +50,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/c6x/include/asm/tables.h b/arch/c6x/include/asm/tables.h new file mode 100644 index 000000000000..09a9e31c573a --- /dev/null +++ b/arch/c6x/include/asm/tables.h @@ -0,0 +1,26 @@ +#ifndef _ASM_C6X_ASM_TABLES_H +#define _ASM_C6X_ASM_TABLES_H +/* + * Copyright (C) 2016 Luis R. Rodriguez + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of copyleft-next (version 0.3.1 or later) as published + * at http://copyleft-next.org/. + */ + +/* + * The c6x toolchain has a bug present even on gcc-6 when non-weak attributes + * are used and sends them to .rodata even though const data with weak + * attributes are put in .const, this forces the linker to believe the address + * is relative relative to the a base + offset and you end up with SB-relative + * reloc error upon linking. Work around this by by forcing both start and + * ending const RO waek linker table entry to be .const to fix this for now. + * + * [0] https://lkml.kernel.org/r/1470798247.3551.94.camel@redhat.com + */ + +#define SECTION_TBL_RO .const + +#include + +#endif /* _ASM_C6X_ASM_TABLES_H */ diff --git a/arch/cris/include/asm/Kbuild b/arch/cris/include/asm/Kbuild index fb8bb4112773..7062c1be7913 100644 --- a/arch/cris/include/asm/Kbuild +++ b/arch/cris/include/asm/Kbuild @@ -47,3 +47,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/frv/include/asm/Kbuild b/arch/frv/include/asm/Kbuild index 5191fec655d7..4a59cbda5091 100644 --- a/arch/frv/include/asm/Kbuild +++ b/arch/frv/include/asm/Kbuild @@ -10,3 +10,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/h8300/include/asm/Kbuild b/arch/h8300/include/asm/Kbuild index 7929a992566c..d79968d93c12 100644 --- a/arch/h8300/include/asm/Kbuild +++ b/arch/h8300/include/asm/Kbuild @@ -77,3 +77,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/hexagon/include/asm/Kbuild b/arch/hexagon/include/asm/Kbuild index af17ee334788..d59ac1c1858b 100644 --- a/arch/hexagon/include/asm/Kbuild +++ b/arch/hexagon/include/asm/Kbuild @@ -62,3 +62,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/ia64/include/asm/Kbuild b/arch/ia64/include/asm/Kbuild index d8f226b35a0a..76540f143473 100644 --- a/arch/ia64/include/asm/Kbuild +++ b/arch/ia64/include/asm/Kbuild @@ -11,3 +11,4 @@ generic-y += vtime.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/m32r/include/asm/Kbuild b/arch/m32r/include/asm/Kbuild index 1c6504d29312..24088f3c733c 100644 --- a/arch/m32r/include/asm/Kbuild +++ b/arch/m32r/include/asm/Kbuild @@ -13,3 +13,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/m68k/include/asm/Kbuild b/arch/m68k/include/asm/Kbuild index d465f51c2088..65c0df17f70e 100644 --- a/arch/m68k/include/asm/Kbuild +++ b/arch/m68k/include/asm/Kbuild @@ -37,3 +37,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/metag/include/asm/Kbuild b/arch/metag/include/asm/Kbuild index c869b1ebd583..2538224899fd 100644 --- a/arch/metag/include/asm/Kbuild +++ b/arch/metag/include/asm/Kbuild @@ -58,3 +58,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/microblaze/include/asm/Kbuild b/arch/microblaze/include/asm/Kbuild index 63c083a1f8da..01afb1b420f5 100644 --- a/arch/microblaze/include/asm/Kbuild +++ b/arch/microblaze/include/asm/Kbuild @@ -13,3 +13,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/mips/include/asm/Kbuild b/arch/mips/include/asm/Kbuild index ed225600c8a4..07009c0863f6 100644 --- a/arch/mips/include/asm/Kbuild +++ b/arch/mips/include/asm/Kbuild @@ -22,3 +22,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/mn10300/include/asm/Kbuild b/arch/mn10300/include/asm/Kbuild index 656af7b69940..6c8d12f3fe44 100644 --- a/arch/mn10300/include/asm/Kbuild +++ b/arch/mn10300/include/asm/Kbuild @@ -12,3 +12,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/nios2/include/asm/Kbuild b/arch/nios2/include/asm/Kbuild index c55880659d67..ee6220dac1e8 100644 --- a/arch/nios2/include/asm/Kbuild +++ b/arch/nios2/include/asm/Kbuild @@ -65,3 +65,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/openrisc/include/asm/Kbuild b/arch/openrisc/include/asm/Kbuild index 7d6a704b808c..ceafe458e295 100644 --- a/arch/openrisc/include/asm/Kbuild +++ b/arch/openrisc/include/asm/Kbuild @@ -73,3 +73,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/parisc/include/asm/Kbuild b/arch/parisc/include/asm/Kbuild index 1a263a7158e2..99211477bfb2 100644 --- a/arch/parisc/include/asm/Kbuild +++ b/arch/parisc/include/asm/Kbuild @@ -31,3 +31,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/powerpc/include/asm/Kbuild b/arch/powerpc/include/asm/Kbuild index 065c6e84fb67..bbd54aa1571e 100644 --- a/arch/powerpc/include/asm/Kbuild +++ b/arch/powerpc/include/asm/Kbuild @@ -9,3 +9,4 @@ generic-y += rwsem.h generic-y += vtime.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/s390/include/asm/Kbuild b/arch/s390/include/asm/Kbuild index 3e8b95927cb5..92c2250a1521 100644 --- a/arch/s390/include/asm/Kbuild +++ b/arch/s390/include/asm/Kbuild @@ -10,3 +10,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/score/include/asm/Kbuild b/arch/score/include/asm/Kbuild index f0cdb2cbca4d..16ea15a3e432 100644 --- a/arch/score/include/asm/Kbuild +++ b/arch/score/include/asm/Kbuild @@ -16,3 +16,4 @@ generic-y += serial.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/sh/include/asm/Kbuild b/arch/sh/include/asm/Kbuild index c9bb7932a3d1..d0ea768d15ae 100644 --- a/arch/sh/include/asm/Kbuild +++ b/arch/sh/include/asm/Kbuild @@ -41,3 +41,4 @@ generic-y += ucontext.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/sparc/include/asm/Kbuild b/arch/sparc/include/asm/Kbuild index 79664d10e63b..0e7663749c97 100644 --- a/arch/sparc/include/asm/Kbuild +++ b/arch/sparc/include/asm/Kbuild @@ -24,3 +24,4 @@ generic-y += types.h generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/tile/include/asm/Kbuild b/arch/tile/include/asm/Kbuild index 951fa4be571d..8f3e38c981cd 100644 --- a/arch/tile/include/asm/Kbuild +++ b/arch/tile/include/asm/Kbuild @@ -43,3 +43,4 @@ generic-y += types.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/um/include/asm/Kbuild b/arch/um/include/asm/Kbuild index 99be54949b99..eea5dd842992 100644 --- a/arch/um/include/asm/Kbuild +++ b/arch/um/include/asm/Kbuild @@ -29,3 +29,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/unicore32/include/asm/Kbuild b/arch/unicore32/include/asm/Kbuild index 6c35905fe371..5c31eafbf1fd 100644 --- a/arch/unicore32/include/asm/Kbuild +++ b/arch/unicore32/include/asm/Kbuild @@ -65,3 +65,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/x86/include/asm/Kbuild b/arch/x86/include/asm/Kbuild index f790756fdb48..cd0fa76b32a3 100644 --- a/arch/x86/include/asm/Kbuild +++ b/arch/x86/include/asm/Kbuild @@ -18,3 +18,4 @@ generic-y += mcs_spinlock.h generic-y += mm-arch-hooks.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/arch/x86/tools/relocs.c b/arch/x86/tools/relocs.c index c215db049920..45733a182ac2 100644 --- a/arch/x86/tools/relocs.c +++ b/arch/x86/tools/relocs.c @@ -69,7 +69,9 @@ static const char * const sym_regex_kernel[S_NSYMTYPES] = { "__initramfs_start|" "(jiffies|jiffies_64)|" ".rodata.rng.*|" + ".rodata.tbl.*|" ".init.text.rng.*|" + ".init.text.tbl.*|" #if ELF_BITS == 64 "__per_cpu_load|" "init_per_cpu__.*|" diff --git a/arch/xtensa/include/asm/Kbuild b/arch/xtensa/include/asm/Kbuild index 221b6b652500..ae48f8fd9212 100644 --- a/arch/xtensa/include/asm/Kbuild +++ b/arch/xtensa/include/asm/Kbuild @@ -33,3 +33,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += tables.h diff --git a/include/asm-generic/ranges.h b/include/asm-generic/ranges.h index 74cd941aa2f8..8cf21a1497c6 100644 --- a/include/asm-generic/ranges.h +++ b/include/asm-generic/ranges.h @@ -86,4 +86,18 @@ #endif /* __ASSEMBLY__ */ +#ifdef __ASSEMBLER__ + +#ifndef DEFINE_SECTION_RANGE +#define DEFINE_SECTION_RANGE(section, name) \ + push_section_rng_level(section, name,,) ; \ + .globl name ; \ +name: ; \ + .popsection \ + \ + push_section_rng_level(section, name, ~,) ; \ + .popsection +#endif +#endif /* __ASSEMBLER__ */ + #endif /* _ASM_GENERIC_RANGES_H_ */ diff --git a/include/asm-generic/tables.h b/include/asm-generic/tables.h new file mode 100644 index 000000000000..43cd03a83bd2 --- /dev/null +++ b/include/asm-generic/tables.h @@ -0,0 +1,50 @@ +#ifndef _ASM_GENERIC_TABLES_H_ +#define _ASM_GENERIC_TABLES_H_ +/* + * Linux linker tables + * + * Copyright (C) 2016 Luis R. Rodriguez + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of copyleft-next (version 0.3.1 or later) as published + * at http://copyleft-next.org/. + */ +#include + +#define SECTION_TBL(section, name, level) \ + SECTION_CORE(section, tbl, name, level) + +#define SECTION_TBL_ALL(section) \ + SECTION_CORE_ALL(section,tbl) + +/* Some toolchains are buggy, let them override */ +#ifndef SECTION_TBL_RO +# define SECTION_TBL_RO SECTION_RODATA +#endif + +#ifndef set_section_tbl +# define set_section_tbl(section, name, level, flags) \ + set_section_core(section, tbl, name, level, flags) +#endif + +#ifndef set_section_tbl_any +# define set_section_tbl_any(section, name, flags) \ + set_section_core(section, tbl, name, SECTION_ORDER_ANY, flags) +#endif + +#ifndef set_section_tbl_type +# define set_section_tbl_type(section, name, level, flags, type) \ + set_section_core_type(section, tbl, name, level, flags, type) +#endif + +#ifndef push_section_tbl +# define push_section_tbl(section, name, level, flags) \ + push_section_core(section, tbl, name, level, flags) +#endif + +#ifndef push_section_tbl_any +# define push_section_tbl_any(section, name, flags) \ + push_section_core(section, tbl, name, SECTION_ORDER_ANY, flags) +#endif + +#endif /* _ASM_GENERIC_TABLES_H_ */ diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index ad843555e6a4..4b6a3d820883 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -57,6 +57,7 @@ #include #include #include +#include /* Align . to a 8 byte boundary equals to maximum function alignment. */ #define ALIGN_FUNCTION() . = ALIGN(8) @@ -202,6 +203,7 @@ #define DATA_DATA \ *(SECTION_DATA) \ *(SORT(SECTION_RNG_ALL(SECTION_DATA))) \ + *(SORT(SECTION_TBL_ALL(SECTION_DATA))) \ *(SECTION_REF_DATA) \ *(.data..shared_aligned) /* percpu related */ \ MEM_KEEP(init.data) \ @@ -269,6 +271,7 @@ VMLINUX_SYMBOL(__start_rodata) = .; \ *(SECTION_RODATA) \ *(SORT(SECTION_RNG_ALL(SECTION_RODATA))) \ + *(SORT(SECTION_TBL_ALL(SECTION_RODATA))) \ *(SECTION_ALL(SECTION_RODATA)) \ RO_AFTER_INIT_DATA /* Read only after init */ \ *(__vermagic) /* Kernel version magic */ \ @@ -439,6 +442,7 @@ ALIGN_FUNCTION(); \ *(.text.hot SECTION_TEXT) \ *(SORT(SECTION_RNG_ALL(SECTION_TEXT))) \ + *(SORT(SECTION_TBL_ALL(SECTION_TEXT))) \ *(.text.fixup .text.unlikely) \ *(SECTION_REF) \ MEM_KEEP(init.text) \ @@ -536,6 +540,7 @@ #define INIT_DATA \ *(SECTION_INIT_DATA) \ *(SORT(SECTION_RNG_ALL(SECTION_INIT_DATA))) \ + *(SORT(SECTION_TBL_ALL(SECTION_INIT_DATA))) \ MEM_DISCARD(init.data) \ KERNEL_CTORS() \ MCOUNT_REC() \ @@ -559,6 +564,7 @@ #define INIT_TEXT \ *(SECTION_INIT) \ *(SORT(SECTION_RNG_ALL(SECTION_INIT))) \ + *(SORT(SECTION_TBL_ALL(SECTION_INIT))) \ *(.text.startup) \ MEM_DISCARD(init.text) diff --git a/include/linux/tables.h b/include/linux/tables.h new file mode 100644 index 000000000000..423827eafb52 --- /dev/null +++ b/include/linux/tables.h @@ -0,0 +1,567 @@ +#ifndef _LINUX_LINKER_TABLES_H +#define _LINUX_LINKER_TABLES_H +/* + * Linux linker tables + * + * Copyright (C) 2016 Luis R. Rodriguez + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of copyleft-next (version 0.3.1 or later) as published + * at http://copyleft-next.org/. + */ +#include +#include +#include + +#ifndef __ASSEMBLY__ + +/** + * DOC: Introduction + * + * A linker table is a data structure that is stitched together from items in + * multiple object files for the purpose of selective placement into standard + * or architecture specific ELF sections. What section is used is utility + * specific. Linux has historically implicitly used linker tables, however they + * were all built in an adhoc manner which requires linker script modifications + * per architecture. The linker table API provides a general facility so that + * data structures can be stitched together and placed into Linux ELF sections + * by only changing C or asm code in an architecture agnostic form. + * + * Linker tables help you group together related data and code in an efficient + * way. Linker tables can be used to help simplify init sequences, they + * enable linker build time selective sorting (disabled options get ignored), + * and can optionally also be used to help you avoid code bit-rot due to + * overuse of #ifdef. + */ + +/** + * DOC: Linker table provenance + * + * The Linux implementation of linker tables was inspired by the iPXE linker + * table's solution (iPXE commit 67a10ef000cb7 "[contrib] Add rom-o-matic to + * contrib "[0]). To see how this code evolved refer to the out of tree + * userspace linker-table tree [1]. + * + * Contrary to iPXE's solution which strives to force compilation of + * everything using linker tables, Linux's solution allows for developers to be + * selective over where one wishes to force compilation, this then is just an + * optional feature for the Linux linker table solution. The main advantages + * of using linker-tables then are: + * + * - Avoiding modifying architecture linker scripts + * - Simplifying initialization code + * - Avoiding the code bit-rot problem + * + * [0] git://git.ipxe.org/ipxe.git + * + * [1] https://git.kernel.org/cgit/linux/kernel/git/mcgrof/linker-tables.git/ + */ + +/** + * DOC: Avoids modifying architecture linker scripts + * + * Linker tables enable you to avoid modifying architecture linker scripts + * since it has its has extended each core Linux section with a respective + * linker table entry in `include/asm-generic/vmlinux.lds.h`. When you add new + * linker table entry you aggregate them `into` the existing linker table core + * section. + */ + +/** + * DOC: How linker tables simplify initialization code + * + * Traditionally, we would implement features in C code as follows: + * + * foo_init(); + * + * You'd then have a foo.h which would have:: + * + * #ifndef CONFIG_FOO + * static inline void foo_init(void) { } + * #endif + * + * With linker tables this is no longer necessary as your init routines would + * be implicit, you'd instead call: + * + * call_init_fns(); + * + * call_init_fns() would call all functions present in your init table and if + * and only if foo.o gets linked in, then its initialisation function will be + * called. + * + * The linker script takes care of assembling the tables for us. All of our + * table sections have names of the format `SECTION_NAME.tbl.NAME.N`. Here + * `SECTION_NAME` is one of the standard sections in:: + * + * include/asm-generic/section-core.h + * + * and `NAME` designates the specific use case for the linker table, the table. + * `N` is a digit used to help sort entries in the section. `N=` (empty string) + * is reserved for the symbol indicating `table start`, and `N=~` is reserved + * for the symbol indicating `table end`. In order for the call_init_fns() to + * work behind the scenes the custom linker script would need to define the + * beginning of the table, the end of the table, and in between it should use + * ``SORT()`` to give order to the section. Typically this would require custom + * linker script modifications however since linker table are already defined + * in ``include/asm-generic/vmlinux.lds.h`` as documented above each new linker + * table definition added in C code folds into the respective core Linux + * section linker table. + * + * This is also done to support all architectures. All that is needed then is + * to ensure a respective common linker table entry is added to the shared + * ``include/asm-generic/vmlinux.lds.h``. There should be a respective:: + * + * *(SORT(SECTION_TBL_ALL(SECTION_NAME))) + * + * entry for each type of supported section there. If your `SECTION_NAME` + * is not yet supported, consider adding support for it. + * + * Linker tables support ordering entries, it does this using a digit which + * is eventually added as a postfix to a section entry name, we refer to this + * as the linker table ``order-level``. If order is not important to your + * linker table entry you can use the special ``SECTION_ORDER_ANY``. After + * ``order-level``, the next contributing factor to order is the order of the + * code in the C file, and the order of the objects in the Makefile. Using an + * ``order-level`` then should not really be needed in most cases, its use + * however enables to compartamentalize code into tables where ordering through + * C file or through the Makefile would otherwise be very difficult or if one + * wanted to enable very specific initialization semantics. + * + * As an example, suppose that we want to create a "frobnicator" + * feature framework, and allow for several independent modules to + * provide frobnicating services. Then we would create a frob.h + * header file containing e.g.:: + * + * struct frobnicator { + * const char *name; + * void (*frob) (void); + * }; + * + * DECLARE_LINKTABLE(struct frobnicator, frobnicator_fns); + * + * Any module providing frobnicating services would look something + * like:: + * + * #include "frob.h" + * + * static void my_frob(void) { + * ... Do my frobnicating + * } + * + * LINKTABLE_INIT_DATA(frobnicator_fns, all) my_frobnicator = { + * .name = "my_frob", + * .frob = my_frob, + * }; + * + * The central frobnicator code, say in frob.c, would use the frobnicating + * modules as follows:: + * + * #include "frob.h" + * + * void frob_all(void) { + * struct frobnicator *f; + * + * LINKTABLE_FOR_EACH(f, frobnicator_fns) { + * pr_info("Calling frobnicator %s\n", frob->name); + * f->frob(); + * } + * } + */ + +/** + * DOC: Linker table module support + * + * Modules can use linker tables, however the linker table definition + * must be built-in to the kernel. That is, the code that implements + * ``DEFINE_LINKTABLE*()`` must be built-in, and modular code cannot add + * more items in to the table, unless ``kernel/module.c`` find_module_sections() + * and module-common.lds.S are updated accordingly with a respective + * module notifier to account for updates. This restriction may be enhanced + * in the future. + */ + +/** + * DOC: Linker table helpers + * + * These are helpers for linker tables. + */ + +/** + * LINKTABLE_ADDR_WITHIN - returns true if address is in range + * + * @tbl: linker table + * @addr: address to query for + * + * Returns true if the address is part of the linker table. + */ +#define LINKTABLE_ADDR_WITHIN(tbl, addr) \ + (addr >= (unsigned long) LINUX_SECTION_START(tbl) && \ + addr < (unsigned long) LINUX_SECTION_END(tbl)) + +/** + * DOC: Constructing linker tables + * + * Linker tables constructors are used to build an entry into a linker table. + * Linker table constructors exist for each type of supported section. + * + * You have weak and regular type of link table entry constructors. + */ + +/** + * DOC: Weak linker tables constructors + * + * The weak attribute is desirable if you want an entry you can replace at + * link time. A very special use case for linker tables is the first entry. + * A weak attribute is used for the first entry to ensure that this entry's + * address matches the end address of the table when the linker table is + * emtpy, but will also point to the first real entry of the table once not + * empty. When the first entry is linked in, it takes place of the first entry. + */ + +/** + * LINKTABLE_WEAK - Constructs a weak linker table entry for data + * + * @name: linker table name + * @level: order level + * + * Constructs a weak linker table for data. + */ +#define LINKTABLE_WEAK(name, level) \ + __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_DATA, \ + name, level)))) + +/** + * LINKTABLE_TEXT_WEAK - Constructs a weak linker table entry for execution + * + * @name: linker table name + * @level: order level + * + * Constructs a weak linker table for code execution. These will be + * read-only. + */ +#define LINKTABLE_TEXT_WEAK(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_TEXT, \ + name, level)))) + +/** + * LINKTABLE_RO_WEAK - Constructs a weak read-only linker table entry + * + * @name: linker table name + * @level: order level + * + * Constructs a weak linker table which only requires read-only access. + */ +#define LINKTABLE_RO_WEAK(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_TBL_RO, \ + name, level)))) + +/** + * LINKTABLE_INIT_WEAK - Constructs a weak linker table entry for init code + * + * @name: linker table name + * @level: order level + * + * Constructs a weak linker table for execution. use at init. + */ +#define LINKTABLE_INIT_WEAK(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_INIT, \ + name, level)))) + +/** + * LINKTABLE_INIT_DATA_WEAK - Constructs a weak linker table entry for initdata + * + * @name: linker table name + * @level: order level + * + * Constructs a weak linker table for data during init. + */ +#define LINKTABLE_INIT_DATA_WEAK(name, level) \ + __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_INIT_DATA, \ + name, level)))) + +/** + * DOC: Regular linker linker table constructors + * + * Regular constructors are expected to be used for valid linker table entries. + * Valid uses of weak entries other than the beginning and is currently + * untested but should in theory work. + */ + +/** + * LINKTABLE - Declares a data linker table entry + * + * @name: linker table name + * @level: order level + * + * Declares a data linker table entry. These are read-write. + */ +#define LINKTABLE(name, level) \ + __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_DATA, \ + name, level)))) + +/** + * LINKTABLE_TEXT - Declares a linker table entry for execution + * + * @name: linker table name + * @level: order level + * + * Declares a linker table to be used for execution. + */ +#define LINKTABLE_TEXT(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_TEXT, \ + name, level)))) + +/** + * LINKTABLE_RO - Declares a read-only linker table entry. + * + * @name: linker table name + * @level: order level + * + * Declares a linker table which only requires read-only access. Contrary + * to LINKTABLE_RO_WEAK() which uses SECTION_RODATA this helper uses the + * section SECTION_TBL_RO here due to possible toolchains bug on some + * architectures, for instance the c6x architicture stuffs non-weak data + * into different sections other than the one intended. + */ +#define LINKTABLE_RO(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_TBL_RO, \ + name, level)))) + +/** + * LINKTABLE_INIT - Declares a linker table entry to be used on init. + * + * @name: linker table name + * @level: order level + * + * Declares a linker table entry for execution use during init. + */ +#define LINKTABLE_INIT(name, level) \ + const __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + __aligned__(LINUX_SECTION_ALIGN_FUNC), \ + section(SECTION_TBL(SECTION_INIT, \ + name, level)))) + +/** + * LINKTABLE_INIT_DATA - Declares a linker table entry to be used on init data. + * + * @name: linker table name + * @level: order level + * + * Declares a linker table entry for data during init. + */ +#define LINKTABLE_INIT_DATA(name, level) \ + __typeof__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_TBL(SECTION_INIT_DATA, \ + name, level)))) + +/** + * DOC: Declaring Linker tables + * + * Declarers are used to help code access the linker tables. Typically + * header files for subsystems would declare the linker tables to enable + * easy access to add new entries, and to iterate over the list of table. + * There are only two declarers needed given that the section association + * is done by the definition of the linker table using ``DEFINE_LINKTABLE*()`` + * helpers. + */ + + +/** + * DECLARE_LINKTABLE - Declares a data linker table entry + * + * @type: data type + * @name: table name + * + * Declares a data linker table entry. + */ +#define DECLARE_LINKTABLE(type, name) \ + DECLARE_LINUX_SECTION(type, name) + +/** + * DECLARE_LINKTABLE_RO - Declares a read-only linker table entry + * + * @type: data type + * @name: table name + * + * Declares a read-only linker table entry. + */ +#define DECLARE_LINKTABLE_RO(type, name) \ + DECLARE_LINUX_SECTION_RO(type, name) + +/** + * DOC: Defining Linker tables + * + * Linker tables are defined in the code that takes ownership over + * the linker table. This is typically done in the same code that is in + * charge of iterating over the linker table as well. + */ + +/** + * DEFINE_LINKTABLE - Defines a linker table for data + * + * @type: data type + * @name: table name + * + * Defines a linker table which used for data. + */ +#define DEFINE_LINKTABLE(type, name) \ + DECLARE_LINKTABLE(type, name); \ + LINKTABLE_WEAK(name,) VMLINUX_SYMBOL(name)[0] = {}; \ + LINKTABLE(name, ~) VMLINUX_SYMBOL(name##__end)[0] = {} + +/** + * DEFINE_LINKTABLE_TEXT - Declares linker table entry for exectuion + * + * @type: data type + * @name: table name + * + * Declares a linker table entry for execution. + */ +#define DEFINE_LINKTABLE_TEXT(type, name) \ + DECLARE_LINKTABLE_RO(type, name); \ + LINKTABLE_TEXT_WEAK(name,) VMLINUX_SYMBOL(name)[0] = {}; \ + LINKTABLE_TEXT(name, ~) VMLINUX_SYMBOL(name##__end)[0] = {} + +/** + * DEFINE_LINKTABLE_RO - Defines a read-only linker table + * + * @type: data type + * @name: table name + * + * Defines a linker table which we know only requires read-only access. + */ +#define DEFINE_LINKTABLE_RO(type, name) \ + DECLARE_LINKTABLE_RO(type, name); \ + LINKTABLE_RO_WEAK(name,) VMLINUX_SYMBOL(name)[0] = {}; \ + LINKTABLE_RO(name, ~) VMLINUX_SYMBOL(name##__end)[0] = {} + +/** + * DEFINE_LINKTABLE_INIT - Defines an init time linker table for execution + * + * @type: data type + * @name: table name + * + * Defines a linker table. If you are adding a new type you should + * enable ``CONFIG_DEBUG_SECTION_MISMATCH`` and ensure routines that make + * use of the linker tables get a respective __ref tag. + */ +#define DEFINE_LINKTABLE_INIT(type, name) \ + DECLARE_LINKTABLE(type, name); \ + LINKTABLE_INIT_WEAK(name,) VMLINUX_SYMBOL(name)[0] = {}; \ + LINKTABLE_INIT(name, ~) VMLINUX_SYMBOL(name##__end)[0] = {} + +/** + * DEFINE_LINKTABLE_INIT_DATA - Defines an init time linker table for data + * + * @type: data type + * @name: table name + * + * Defines a linker table for init data. If you are adding a new type you + * should enable ``CONFIG_DEBUG_SECTION_MISMATCH`` and ensure routines that + * make use of the linker tables get a respective __ref tag. + */ +#define DEFINE_LINKTABLE_INIT_DATA(type, name) \ + DECLARE_LINKTABLE(type, name); \ + LINKTABLE_INIT_DATA_WEAK(name,) VMLINUX_SYMBOL(name)[0] = {}; \ + LINKTABLE_INIT_DATA(name, ~) VMLINUX_SYMBOL(name##__end)[0] = {} + +/** + * DOC: Iterating over Linker tables + * + * To make use of the linker tables you want to be able to iterate over + * them. This section documents the different iterators available. + */ + +/** + * LINKTABLE_FOR_EACH - iterate through all entries within a linker table + * + * @pointer: entry pointer + * @tbl: linker table + * + * Example usage:: + * + * struct frobnicator *frob; + * + * LINKTABLE_FOR_EACH(frob, frobnicator_fns) { + * ... + * } + */ + +#define LINKTABLE_FOR_EACH(pointer, tbl) \ + for (pointer = LINUX_SECTION_START(tbl); \ + pointer < LINUX_SECTION_END(tbl); \ + pointer++) + +/** + * LINKTABLE_RUN_ALL - iterate and run through all entries on a linker table + * + * @tbl: linker table + * @func: structure name for the function name we want to call. + * @args...: arguments to pass to func + * + * Example usage:: + * + * LINKTABLE_RUN_ALL(frobnicator_fns, some_run,); + */ +#define LINKTABLE_RUN_ALL(tbl, func, args...) \ +do { \ + size_t i; \ + for (i = 0; i < LINUX_SECTION_SIZE(tbl); i++) \ + (VMLINUX_SYMBOL(tbl)[i]).func (args); \ +} while (0) + +/** + * LINKTABLE_RUN_ERR - run each linker table entry func and return error if any + * + * @tbl: linker table + * @func: structure name for the function name we want to call. + * @args...: arguments to pass to func + * + * Example usage:: + * + * unsigned int err = LINKTABLE_RUN_ERR(frobnicator_fns, some_run,); + */ +#define LINKTABLE_RUN_ERR(tbl, func, args...) \ +({ \ + size_t i; \ + int err = 0; \ + for (i = 0; !err && i < LINUX_SECTION_SIZE(tbl); i++) \ + err = (VMLINUX_SYMBOL(tbl)[i]).func (args); \ + err; \ +}) + +#endif /* __ASSEMBLY__ */ + +#endif /* _LINUX_LINKER_TABLES_H */ diff --git a/scripts/Makefile.clean b/scripts/Makefile.clean index 50616ea25131..2b54546237d6 100644 --- a/scripts/Makefile.clean +++ b/scripts/Makefile.clean @@ -36,6 +36,8 @@ subdir-ymn := $(addprefix $(obj)/,$(subdir-ymn)) # directory __clean-files := $(extra-y) $(extra-m) $(extra-) \ + $(force-obj-y) $(force-obj-m) $(force-obj-) \ + $(force-lib-y) $(force-lib-m) $(force-lib-) \ $(always) $(targets) $(clean-files) \ $(host-progs) \ $(hostprogs-y) $(hostprogs-m) $(hostprogs-) \ -- 2.9.2