From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Luis R. Rodriguez" Date: Mon, 09 Jan 2017 14:58:22 +0000 Subject: [PATCH v6 04/14] tables.h: add linker table support Message-Id: <20170109145833.11502-5-mcgrof@kernel.org> List-Id: References: <20161222023811.21246-1-mcgrof@kernel.org> <20170109145833.11502-1-mcgrof@kernel.org> In-Reply-To: <20170109145833.11502-1-mcgrof@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: hpa@zytor.com, acme@redhat.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, npiggin@gmail.com, 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, dalias@libc.org, linux@arm.linux.org.uk 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, wangnan0@huawei.com, 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, joro@8bytes.org, x86@kernel.org, fontana@sharpeleven.org, dsahern@gmail.com, linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, dvhart@infradead.org, dwmw2@infradead.org, linux@roeck-us.net, 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 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. v6: o rename tables macro as requested by Andy Shevchenko v5: o Use ..tbl.* instead of .tbl.* as suggested by Nicholas Piggin. This is the typical way to avoid clashes with compiler generated sections. o Replace section macros with section names o Dropped SECTION_RNG_ALL() o Fix documentation typos o To make this easier to read, as per Nicholas Piggin, add our own LINKTABLE_START(), LINKTABLE_END(). After reviewing the changes affected by this it seemed clearer and better then to also use our own specific LINKTABLE_SIZE(), LINKTABLE_EMPTY() and LINKTABLE_ALIGNMENT() as well. o Clarifies SECTION_TBL_RO needs to be kept since some toolchains are buggy, and so we also add SECTION_TBL_RO_STR. o We were using LINUX_SECTION_START() and LINUX_SECTION_END() in some places but in some other places VMLINUX_SYMBOL(name), VMLINUX_SYMBOL(name##__end). Since we are adding LINKTABLE_START() and LINKTABLE_END() just use those consistently. o Fix DEFINE_LINKTABLE_INIT() by making it use DECLARE_LINKTABLE_RO() which forces const. o Fix powerpc .text use: it does not use TEXT_TEXT so we must add our *(SORT(.text.tbl.*)) to its linker script manually. 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 | 212 +++++++++++ MAINTAINERS | 10 + 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/powerpc/kernel/vmlinux.lds.S | 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/tables.h | 48 +++ include/asm-generic/vmlinux.lds.h | 6 + include/linux/tables.h | 612 +++++++++++++++++++++++++++++++ 39 files changed, 948 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 4a1df389fa91..7c7c1adf955c 100644 --- a/Documentation/sections/index.rst +++ b/Documentation/sections/index.rst @@ -16,3 +16,4 @@ common a set of Linux helpers for ELF sections are also documented. background 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..780a292d2d00 --- /dev/null +++ b/Documentation/sections/linker-tables.rst @@ -0,0 +1,212 @@ +=========+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_START +--------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_START + +LINKTABLE_END +------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_END + +LINKTABLE_SIZE +-------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_SIZE + +LINKTABLE_EMPTY +--------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_EMPTY + +LINKTABLE_ADDR_WITHIN +--------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_ADDR_WITHIN + +LINKTABLE_ALIGNMENT +------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_ALIGNMENT + +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 c96ca032c276..bbf519da3a78 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -5407,6 +5407,16 @@ 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 +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 a374b7f83888..ccfa69ce2608 100644 --- a/arch/arc/include/asm/Kbuild +++ b/arch/arc/include/asm/Kbuild @@ -53,3 +53,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 0d47f98ccbc0..b70d4b78d577 100644 --- a/arch/arm/include/asm/Kbuild +++ b/arch/arm/include/asm/Kbuild @@ -43,3 +43,4 @@ generated-y += mach-types.h generated-y += unistd-nr.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 e9939cbd9067..0c1e781ab10b 100644 --- a/arch/arm64/include/asm/Kbuild +++ b/arch/arm64/include/asm/Kbuild @@ -47,3 +47,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 3428415b1996..9115b215fc7e 100644 --- a/arch/blackfin/include/asm/Kbuild +++ b/arch/blackfin/include/asm/Kbuild @@ -49,3 +49,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..90a0d3df35c8 --- /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 weak 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 006e2863ad37..c28bcdecc764 100644 --- a/arch/m68k/include/asm/Kbuild +++ b/arch/m68k/include/asm/Kbuild @@ -36,3 +36,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 4a8471434a3e..c836f7e2a5e7 100644 --- a/arch/metag/include/asm/Kbuild +++ b/arch/metag/include/asm/Kbuild @@ -57,3 +57,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 e844d6058248..db9dff9c1535 100644 --- a/arch/mips/include/asm/Kbuild +++ b/arch/mips/include/asm/Kbuild @@ -23,3 +23,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 f11d1249738f..aaae8a9f6099 100644 --- a/arch/parisc/include/asm/Kbuild +++ b/arch/parisc/include/asm/Kbuild @@ -30,3 +30,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 60d8349241a7..7c06627a0a0d 100644 --- a/arch/powerpc/include/asm/Kbuild +++ b/arch/powerpc/include/asm/Kbuild @@ -10,3 +10,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/powerpc/kernel/vmlinux.lds.S b/arch/powerpc/kernel/vmlinux.lds.S index fcfc9d102348..8cd940c72895 100644 --- a/arch/powerpc/kernel/vmlinux.lds.S +++ b/arch/powerpc/kernel/vmlinux.lds.S @@ -108,6 +108,7 @@ SECTIONS /* careful! __ftr_alt_* sections need to be close to .text */ *(.text .fixup __ftr_alt_* .ref.text) *(SORT(.text.rng.*)) + *(SORT(.text..tbl.*)) SCHED_TEXT CPUIDLE_TEXT LOCK_TEXT diff --git a/arch/s390/include/asm/Kbuild b/arch/s390/include/asm/Kbuild index c1b85a361e5d..96dd69931427 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 28280887ac79..23a2216f4146 100644 --- a/arch/sparc/include/asm/Kbuild +++ b/arch/sparc/include/asm/Kbuild @@ -23,3 +23,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 33f7069763ae..a599f6f4ee0a 100644 --- a/arch/tile/include/asm/Kbuild +++ b/arch/tile/include/asm/Kbuild @@ -42,3 +42,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 b952dcb3e216..d2867aa09e23 100644 --- a/arch/um/include/asm/Kbuild +++ b/arch/um/include/asm/Kbuild @@ -28,3 +28,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 93abbfdab543..6671a1f08ead 100644 --- a/arch/unicore32/include/asm/Kbuild +++ b/arch/unicore32/include/asm/Kbuild @@ -62,3 +62,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 f672f2fc181d..4cb511f1067c 100644 --- a/arch/x86/include/asm/Kbuild +++ b/arch/x86/include/asm/Kbuild @@ -14,3 +14,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 f96fa2ddf7c9..484a24c309fb 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 2b7fe48c0225..7b41f32a2ba0 100644 --- a/arch/xtensa/include/asm/Kbuild +++ b/arch/xtensa/include/asm/Kbuild @@ -34,3 +34,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/tables.h b/include/asm-generic/tables.h new file mode 100644 index 000000000000..16ef40d145fb --- /dev/null +++ b/include/asm-generic/tables.h @@ -0,0 +1,48 @@ +#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..tbl.name.level + +/* Some toolchains are buggy, let them override */ +#ifndef SECTION_TBL_RO +# define SECTION_TBL_RO .rodata +#endif + +#define SECTION_TBL_RO_STR __stringify(SECTION_TBL_RO) + +#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, 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, 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 71bfd3b3c719..ce1e9a310ada 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) @@ -207,6 +208,7 @@ #define DATA_DATA \ *(.data .data.[0-9a-zA-Z_]*) \ *(SORT(.data..rng.*)) \ + *(SORT(.data..tbl.*)) \ *(.ref.data) \ *(.data..shared_aligned) /* percpu related */ \ MEM_KEEP(init.data) \ @@ -277,6 +279,7 @@ VMLINUX_SYMBOL(__start_rodata) = .; \ *(.rodata) \ *(SORT(.rodata..rng.*)) \ + *(SORT(.rodata..tbl.*)) \ *(.rodata.*) \ RO_AFTER_INIT_DATA /* Read only after init */ \ KEEP(*(__vermagic)) /* Kernel version magic */ \ @@ -452,6 +455,7 @@ ALIGN_FUNCTION(); \ *(.text.hot .text) \ *(SORT(.text..rng.*)) \ + *(SORT(.text..tbl.*)) \ *(.text.fixup .text.unlikely) \ *(.ref.text) \ MEM_KEEP(init.text) \ @@ -556,6 +560,7 @@ KEEP(*(SORT(___kentry+*))) \ *(.init.data) \ *(SORT(.init.data..rng.*)) \ + *(SORT(.init.data..tbl.*)) \ MEM_DISCARD(init.data) \ KERNEL_CTORS() \ MCOUNT_REC() \ @@ -580,6 +585,7 @@ #define INIT_TEXT \ *(.init.text) \ *(SORT(.init.text..rng.*)) \ + *(SORT(.init.text..tbl.*)) \ *(.text.startup) \ MEM_DISCARD(init.text) diff --git a/include/linux/tables.h b/include/linux/tables.h new file mode 100644 index 000000000000..1a1838d51951 --- /dev/null +++ b/include/linux/tables.h @@ -0,0 +1,612 @@ +#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(.foo..tbl.*)) + * + * 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_START - get address of start of linker table + * + * @name: name of the linker table + * + * This gives you the start address of the linker table. + * This should give you the address of the first entry. + * + */ +#define LINKTABLE_START(name) LINUX_SECTION_START(name) + +/** + * LINKTABLE_END - get address of end of the linker table + * + * @name: name of the linker table + * + * This gives you the end address of the linker table. + * This will match the start address if the linker table + * is empty. + */ +#define LINKTABLE_END(name) LINUX_SECTION_END(name) + +/** + * LINKTABLE_SIZE - get number of entries in the linker table + * + * @name: name of the linker table + * + * This gives you the number of entries in the linker table. + * Example usage: + * + * unsigned int num_frobs = LINKTABLE_SIZE(frobnicator_fns); + */ +#define LINKTABLE_SIZE(name) \ + ((LINKTABLE_END(name)) - (LINKTABLE_START(name))) + +/** + * LINKTABLE_EMPTY - check if linker table has no entries + * + * @name: name of linker table + * + * Returns true if the linker table is emtpy. + * + * bool is_empty = LINKTABLE_EMPTY(frobnicator_fns); + */ +#define LINKTABLE_EMPTY(name) (LINKTABLE_SIZE(name) = 0) + +/** + * LINKTABLE_ADDR_WITHIN - returns true if address is in the linker table + * + * @name: name of the linker table + * @addr: address to query for + * + * Returns true if the address is part of the linker table. + */ +#define LINKTABLE_ADDR_WITHIN(name, addr) \ + (addr >= (unsigned long) LINKTABLE_START(name) && \ + addr < (unsigned long) LINKTABLE_END(name)) + +/** + * LINKTABLE_ALIGNMENT - get the alignment of the linker table + * + * @name: name of linker table + * + * Gives you the alignment for the linker table. + */ +#define LINKTABLE_ALIGNMENT(name) LINUX_SECTION_ALIGNMENT(name) + +/** + * 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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".data..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".text..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(SECTION_TBL_RO_STR "..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".init.text..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".init.data..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".data..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".text..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(SECTION_TBL_RO_STR "..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".init.text..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".init.data..tbl." #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,) LINKTABLE_START(name)[0] = {}; \ + LINKTABLE(name, ~) LINKTABLE_END(name)[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,) LINKTABLE_START(name)[0] = {}; \ + LINKTABLE_TEXT(name, ~) LINKTABLE_END(name)[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,) LINKTABLE_START(name)[0] = {}; \ + LINKTABLE_RO(name, ~) LINKTABLE_END(name)[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_RO(type, name); \ + LINKTABLE_INIT_WEAK(name,) LINKTABLE_START(name)[0] = {}; \ + LINKTABLE_INIT(name, ~) LINKTABLE_END(name)[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,) LINKTABLE_START(name)[0] = {}; \ + LINKTABLE_INIT_DATA(name, ~) LINKTABLE_END(name)[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 = LINKTABLE_START(tbl); \ + pointer < LINKTABLE_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 < LINKTABLE_SIZE(tbl); i++) \ + (LINKTABLE_START(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 < LINKTABLE_SIZE(tbl); i++) \ + err = (LINKTABLE_START(tbl)[i]).func (args); \ + err; \ +}) + +#endif /* __ASSEMBLY__ */ + +#endif /* _LINUX_LINKER_TABLES_H */ -- 2.11.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Luis R. Rodriguez" Subject: [PATCH v6 04/14] tables.h: add linker table support Date: Mon, 9 Jan 2017 06:58:22 -0800 Message-ID: <20170109145833.11502-5-mcgrof@kernel.org> References: <20161222023811.21246-1-mcgrof@kernel.org> <20170109145833.11502-1-mcgrof@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170109145833.11502-1-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, acme@redhat.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, npiggin@gmail.com, 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, dalias@libc.org, linux@arm.linux.org.uk 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, wangnan0@huawei.com, 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, joro@8bytes.org, x86@kernel.org, fontana@sharpeleven.org, dsahern@gmail.com, linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, dvhart@infradead.org, dwmw2@infradead.org, linux@roeck-us.net, 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, ak@ List-Id: platform-driver-x86.vger.kernel.org QSBsaW5rZXIgdGFibGUgaXMgYSBkYXRhIHN0cnVjdHVyZSB0aGF0IGlzIHN0aXRjaGVkIHRvZ2V0 aGVyIGZyb20gaXRlbXMKaW4gbXVsdGlwbGUgb2JqZWN0IGZpbGVzLiBMaW51eCBoYXMgaGlzdG9y aWNhbGx5IGltcGxpY2l0bHkgdXNlZCBsaW5rZXIKdGFibGVzIGZvciBhZ2VzLCBob3dldmVyIHRo ZXkgd2VyZSBhbGwgYnVpbHQgaW4gYW4gYWRob2MgbWFubmVyIHdoaWNoCnJlcXVpcmVzIGxpbmtl ciBzY3JpcHQgbW9kaWZpY2F0aW9ucywgcGVyIGFyY2hpdGVjdHVyZS4gVGhpcyBhZGRzIGEKZ2Vu ZXJhbCBsaW5rZXIgdGFibGUgc29sdXRpb24gc28gdGhhdCBhIG5ldyBsaW5rZXIgdGFibGUgY2Fu IGJlCmltcGxlbWVudGVkIGJ5IGNoYW5naW5nIEMgY29kZSBvbmx5LiBUaGUgTGludXggbGlua2Vy IHRhYmxlIHdhcwppbnNwaXJlZCBieSBNaWNoYWVsIEJyb3duJ3MgaVBYRSdzIGxpbmtlciB0YWJs ZSBzb2x1dGlvbiwgaXQgaGFzIGJlZW4KYmVlbiBjb21wbGV0ZWx5IHJlLXdyaXR0ZW4gYW5kIGFk YXB0ZWQgZm9yIGludGVncmF0aW9uIGFuZCB1c2Ugb24gTGludXguCgpUaGUgc2FtZSBwaGlsb3Nv cGh5IGlzIGJvcnJvd2VkLCBleHRlbmRlZCBhbmQgZnVydGhlciBzaW1wbGlmaWVkOgoKTGlua2Vy IHRhYmxlcyBlbmFibGUgYW4gZXh0cmVtZWx5IGxpZ2h0IHdlaWdodCBsaW5rZXIgYnVpbGQgdGlt ZQpzb2x1dGlvbiBmb3IgZmVhdHVyZSBvcmRlcmluZyBhbmQgc2VsZWN0aW9uLCB0aGlzIGNhbiBo ZWxwIHRvIGJvdGgKc2ltcGxpZnkgaW5pdCBzZXF1ZW5jZXMgaW4gYSBnZW5lcmljIGZhc2hpb24g YW5kIGhlbHBzIGF2b2lkaW5nIGNvZGUKYml0LXJvdHRpbmcgd2hlbiBkZXNpcmFibGUuIEZ1cnRo ZXIgY2hhbmdlcyB3aWxsIGJlIGFkZGVkIGxhdGVyCndoaWNoIHdpbGwgbWFrZSBtb3JlIGV2aWRl bnQgaG93IGNvZGUgYml0IHJvdCBjYW4gYmUgYXZvaWRlZCB1c2luZwpsaW5rZXIgdGFibGVzLgoK djY6CgpvIHJlbmFtZSB0YWJsZXMgbWFjcm8gYXMgcmVxdWVzdGVkIGJ5IEFuZHkgU2hldmNoZW5r bwoKdjU6Cm8gVXNlIC4udGJsLiogaW5zdGVhZCBvZiAudGJsLiogYXMgc3VnZ2VzdGVkIGJ5IE5p Y2hvbGFzIFBpZ2dpbi4KICBUaGlzIGlzIHRoZSB0eXBpY2FsIHdheSB0byBhdm9pZCBjbGFzaGVz IHdpdGggY29tcGlsZXIgZ2VuZXJhdGVkCiAgc2VjdGlvbnMuCm8gUmVwbGFjZSBzZWN0aW9uIG1h Y3JvcyB3aXRoIHNlY3Rpb24gbmFtZXMKbyBEcm9wcGVkIFNFQ1RJT05fUk5HX0FMTCgpCm8gRml4 IGRvY3VtZW50YXRpb24gdHlwb3MKbyBUbyBtYWtlIHRoaXMgZWFzaWVyIHRvIHJlYWQsIGFzIHBl ciBOaWNob2xhcyBQaWdnaW4sIGFkZCBvdXIgb3duCiAgTElOS1RBQkxFX1NUQVJUKCksIExJTktU QUJMRV9FTkQoKS4gQWZ0ZXIgcmV2aWV3aW5nIHRoZSBjaGFuZ2VzCiAgYWZmZWN0ZWQgYnkgdGhp cyBpdCBzZWVtZWQgY2xlYXJlciBhbmQgYmV0dGVyIHRoZW4gdG8gYWxzbwogIHVzZSBvdXIgb3du IHNwZWNpZmljIExJTktUQUJMRV9TSVpFKCksIExJTktUQUJMRV9FTVBUWSgpIGFuZAogIExJTktU QUJMRV9BTElHTk1FTlQoKSBhcyB3ZWxsLgpvIENsYXJpZmllcyBTRUNUSU9OX1RCTF9STyBuZWVk cyB0byBiZSBrZXB0IHNpbmNlIHNvbWUgdG9vbGNoYWlucwogIGFyZSBidWdneSwgYW5kIHNvIHdl IGFsc28gYWRkIFNFQ1RJT05fVEJMX1JPX1NUUi4KbyBXZSB3ZXJlIHVzaW5nIExJTlVYX1NFQ1RJ T05fU1RBUlQoKSBhbmQgTElOVVhfU0VDVElPTl9FTkQoKSBpbiBzb21lIHBsYWNlcwogIGJ1dCBp biBzb21lIG90aGVyIHBsYWNlcyBWTUxJTlVYX1NZTUJPTChuYW1lKSwgVk1MSU5VWF9TWU1CT0wo bmFtZSMjX19lbmQpLgogIFNpbmNlIHdlIGFyZSBhZGRpbmcgTElOS1RBQkxFX1NUQVJUKCkgYW5k IExJTktUQUJMRV9FTkQoKSBqdXN0IHVzZSB0aG9zZQogIGNvbnNpc3RlbnRseS4KbyBGaXggREVG SU5FX0xJTktUQUJMRV9JTklUKCkgYnkgbWFraW5nIGl0IHVzZSBERUNMQVJFX0xJTktUQUJMRV9S TygpCiAgd2hpY2ggZm9yY2VzIGNvbnN0LgpvIEZpeCBwb3dlcnBjIC50ZXh0IHVzZTogaXQgZG9l cyBub3QgdXNlIFRFWFRfVEVYVCBzbyB3ZSBtdXN0CiAgYWRkIG91ciAqKFNPUlQoLnRleHQudGJs LiopKSB0byBpdHMgbGlua2VyIHNjcmlwdCBtYW51YWxseS4KCnY0OgoKbyBTcGxpdCBvdXQga2J1 aWxkIGFkZGl0aW9ucyB0byBoZWxwIHdpdGggY29kZSBiaXQgcm90IGludG8KICBpdHMgb3duIHBh dGNoCm8gdG9ucyBvZiBkb2N1bWVudGF0aW9uIGxvdmUKbyBmaXggYXJjaC94ODYvdG9vbHMvcmVs b2NzLmMgdHlwbyAtIHdoaWNoIGNhdXNlZCBjb21waWxhdGlvbiBpc3N1ZXMKICBvbiBvbGQgdG9v bGNoYWlucwpvIGFkZCBjNnggdG9vbGNoYWluIHdvcmsgYXJvdW5kIGFzIGRpc2N1c3NlZCB3aXRo IE1hcmsgU2FsdGVyCm8gc3ByaW5rbGUgYSBmZXcgbW9yZSBuZWVkZWQgVk1MSU5VWF9TWU1CT0wo KSAtIGZpeGVzCiAgY29tcGlsYXRpb24gb24gYmxhY2tmaW4KbyBzdWdnZXN0ZWQgbmFtZSBjaGFu Z2VzIGJ5IGJvcmlzOgotICVzL1NFQ1RJT05fVFlQRV9SQU5HRVMvcm5nL2cKLSAlcy9TRUNUSU9O X1RZUEUvU0VDVElPTl9DT1JFL2cKLSAlcy9zZWN0aW9uX3R5cGVfYXNtdHlwZS9zZWN0aW9uX2Nv cmVfdHlwZS9nCi0gJXMvc2VjdGlvbl90eXBlL3NlY3Rpb25fY29yZS9nCi0gJXMvc2VjdGlvbl9y bmcvc2V0X3NlY3Rpb25fcm5nL2cKLSBEcm9wIERFQ0xBUkVfU0VDVElPTl9UQkwoKSAtLSB0aGlz IGlzIGFuIGFzbSBlcXVpdmFsZW50CiAgREVGSU5FX0xJTktUQUJMRSgpIC0tIHRoaXMgaG93ZXZl ciBpcyBub3QgdXNlZCB5ZXQsIGFuZCBpdCByZXF1aXJlcwogIGEgYml0IG1vcmUgd29yayB0byBt YXRjaCB0aGUgQyBjb2RlIGRlZmluaXRpb25zLgpvIGRyb3AgdG9vbHMvaW5jbHVkZS9saW51eC9z ZWN0aW9ucy5oIGluIGZhdm9yIG9mIHRoZSBtb3JlIHBvcHVsYXIgb3BlbgogIGNvZGluZyB0aGUg bmFtZXMgZm9yIHRvb2xzCm8gZXhwYW5kIGRvY3VtZW50YXRpb24gdG8gaW5jbHVkZSBtb2R1bGUg c3VwcG9ydApvIGFkZCBtYWludGFuZXJzCm8gVXNlIGdlbmVyaWMteQpvIG1vdmUgLnRleHQudGJs IGJlZm9yZSB1bmxpa2VseSB0byBtYXRjaCB0aGUgb3RoZXIgc2VjdGlvbnMKCnYzOgoKbyBhZGRy ZXNzZWQgaW5pdGlhbCBtb2R1bGFyIHN1cHBvcnQgdGVzdCBjYXNlcwpvIGFkZGVkIGdlbmVyaWMg YXNtIG1hY3JvcyBzbyBsaW5rZXIgdGFibGVzIGNhbiBiZSB1c2VkIGluCiAgYXNtIGNvZGUgLyBD IGFzbSBjYWxscwpvIHNlY3Rpb24gcmFuZ2VzIGFyZSBub3cgc3BsaXQgdXAgaW50byB0aGVpciBv d24gc2V0IG9mIGZpbGVzCm8gdXNlIGFzbS9zZWN0aW9ucy5oIGluc3RlYWQgb2YgbGludXgvc2Vj dGlvbnMuaCBmb3IgdGhlIGxpbmtlcgogIHNjcmlwdApvIGFkZCBhIHNlY3Rpb25zLmggZmlsZSBm b3IgZWFjaCBhcmNoaXRlY3R1cmUgdGhhdCB3YXMgbWlzc2luZyBvbmUsCiAgdGhpcyBpcyBuZWVk ZWQgbm93IGFzIHdlJ2xsIGJlIHJlbHlpbmcgb24gc2VjdGlvbnMuaCBmb3IgY3VzdG9tCiAgc2Vj dGlvbiB0eXBlcyBpbiBjb2RlIHJhdGhlciB0aGFuIGN1c3RvbSBhcmNoaXRlY3R1cmUgc3BlY2lm aWMKICBsaW5rZXIgc2NyaXB0IGhhY2tzLgpvIGZ1bGwgcmV3cml0ZSBhdCB0aGlzIHBvaW50LCBk ZWNpZGVkIHRvIHBpY2sgY29weWxlZnQtbmV4dCBsaWNlbnNlCiAgZm9yIHRoaXMgd29yawoKdjI6 CgpvIG1vZGlmaWVkIGNvbXBsZXRlbHkgdG8gbWF0Y2ggZmVlZGJhY2sgYnkgY29tbXVuaXR5LCBt YWRlIGVxdWl2YWxlbnQKICBtb2RpZmljYXRpb25zIHRvIHVzZXJzcGFjZSBzb2x1dGlvbi4gVGhp cyBpcyBwcmV0dHkgbXVjaCBhIGNvbXBsZXRlCiAgcmV3cml0ZSBvZiBob3cgd2UgcHJlc2VudCBh bmQgdXNlIGxpbmtlciB0YWJsZXMuIEJ5IHVzaW5nIHN0YW5kYXJkCiAgc2VjdGlvbnMgd2Ugbm8g bG9uZ2VyIGhhdmUgdG8gbWFrZSBjdXN0b20gbGlua2VyIHNjcmlwdCBleHRlbnNpb25zCiAgZm9y IGVhY2ggbmV3IGxpbmtlciB0YWJsZSBzb2x1dGlvbiwgeW91IGp1c3QgcGljayBhIGxpbmtlciB0 YWJsZQogIHR5cGUgYnkgc2VjdGlvbiB0eXBlLgpvIGV4dGVuZCBkb2N1bWVudGlvbiBjb25zaWRl cmFibHksIGluY2x1ZGluZyB1c2Ugb2Yga2RvYwpvIGRyb3AgSUNDIGhhY2tzIHBlciBwb3B1bGFy IHJlcXVlc3QgdG8gaWdub3JlIHN1Y2ggaXNzdWVzIGZvciBub3cKbyB1c2Ugc2VjdGlvbnMuaCAt IHRoaXMgbGV0cyB1cyBzdHJlYW1saW5lIGEgY2xlYW4gdXNlIGNhc2Ugb2YKICB3ZWxsIGRvY3Vt ZW50ZWQgc2VjdGlvbnMuIFRvIGhlbHAgZnVydGhlciB3aXRoIHRoaXMgbWFrZSB1c2Ugb2YKICBT RUNUSU9OX1RCTCgpIHRvIGFsbG93IHVzZSBvZiB0aGVzZSBpbiBjb2RlIGFuZCBTRUNUSU9OX1RC TF9BTEwoKQogIG9uIGxpbmtlciBzY3JpcHRzLCBhcyB3ZWxsIGFzIFNFQ1RJT05fVEJMX0FMTF9T VFIoKSBvbiByZWxvY3MuYwogIHdoZW4gbmVlZGVkLgoKQ2M6IE1pY2hhZWwgQnJvd24gPG1jYjMw QGlweGUub3JnPgpTaWduZWQtb2ZmLWJ5OiBMdWlzIFIuIFJvZHJpZ3VleiA8bWNncm9mQGtlcm5l bC5vcmc+Ci0tLQogRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9pbmRleC5yc3QgICAgICAgICB8ICAg MSArCiBEb2N1bWVudGF0aW9uL3NlY3Rpb25zL2xpbmtlci10YWJsZXMucnN0IHwgMjEyICsrKysr KysrKysrCiBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDEwICsK IGFyY2gvYWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9h cmMvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgICB8ICAgMSArCiBhcmNoL2FybS9pbmNs dWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvYXJtNjQvaW5jbHVkZS9h c20vS2J1aWxkICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9hdnIzMi9pbmNsdWRlL2FzbS9LYnVp bGQgICAgICAgICAgICB8ICAgMSArCiBhcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL0tidWlsZCAg ICAgICAgIHwgICAxICsKIGFyY2gvYzZ4L2luY2x1ZGUvYXNtL3RhYmxlcy5oICAgICAgICAgICAg fCAgMjYgKysKIGFyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgfCAgIDEg KwogYXJjaC9mcnYvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgICB8ICAgMSArCiBhcmNo L2g4MzAwL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgIHwgICAxICsKIGFyY2gvaGV4YWdv bi9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgfCAgIDEgKwogYXJjaC9pYTY0L2luY2x1ZGUv YXNtL0tidWlsZCAgICAgICAgICAgICB8ICAgMSArCiBhcmNoL20zMnIvaW5jbHVkZS9hc20vS2J1 aWxkICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvbTY4ay9pbmNsdWRlL2FzbS9LYnVpbGQgICAg ICAgICAgICAgfCAgIDEgKwogYXJjaC9tZXRhZy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAg ICB8ICAgMSArCiBhcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgIHwgICAx ICsKIGFyY2gvbWlwcy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgfCAgIDEgKwogYXJj aC9tbjEwMzAwL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICB8ICAgMSArCiBhcmNoL25pb3My L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgIHwgICAxICsKIGFyY2gvb3BlbnJpc2MvaW5j bHVkZS9hc20vS2J1aWxkICAgICAgICAgfCAgIDEgKwogYXJjaC9wYXJpc2MvaW5jbHVkZS9hc20v S2J1aWxkICAgICAgICAgICB8ICAgMSArCiBhcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vS2J1aWxk ICAgICAgICAgIHwgICAxICsKIGFyY2gvcG93ZXJwYy9rZXJuZWwvdm1saW51eC5sZHMuUyAgICAg ICAgfCAgIDEgKwogYXJjaC9zMzkwL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICB8ICAg MSArCiBhcmNoL3Njb3JlL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgIHwgICAxICsKIGFy Y2gvc2gvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9zcGFy Yy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICB8ICAgMSArCiBhcmNoL3RpbGUvaW5jbHVk ZS9hc20vS2J1aWxkICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvdW0vaW5jbHVkZS9hc20vS2J1 aWxkICAgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC91bmljb3JlMzIvaW5jbHVkZS9hc20vS2J1 aWxkICAgICAgICB8ICAgMSArCiBhcmNoL3g4Ni9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAg ICAgIHwgICAxICsKIGFyY2gveDg2L3Rvb2xzL3JlbG9jcy5jICAgICAgICAgICAgICAgICAgfCAg IDIgKwogYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICB8ICAgMSArCiBp bmNsdWRlL2FzbS1nZW5lcmljL3RhYmxlcy5oICAgICAgICAgICAgIHwgIDQ4ICsrKwogaW5jbHVk ZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oICAgICAgICB8ICAgNiArCiBpbmNsdWRlL2xpbnV4 L3RhYmxlcy5oICAgICAgICAgICAgICAgICAgIHwgNjEyICsrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysKIDM5IGZpbGVzIGNoYW5nZWQsIDk0OCBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9k ZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9saW5rZXItdGFibGVzLnJzdAogY3JlYXRl IG1vZGUgMTAwNjQ0IGFyY2gvYzZ4L2luY2x1ZGUvYXNtL3RhYmxlcy5oCiBjcmVhdGUgbW9kZSAx MDA2NDQgaW5jbHVkZS9hc20tZ2VuZXJpYy90YWJsZXMuaAogY3JlYXRlIG1vZGUgMTAwNjQ0IGlu Y2x1ZGUvbGludXgvdGFibGVzLmgKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3NlY3Rpb25z L2luZGV4LnJzdCBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvaW5kZXgucnN0CmluZGV4IDRhMWRm Mzg5ZmE5MS4uN2M3YzFhZGY5NTVjIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3NlY3Rpb25z L2luZGV4LnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL3NlY3Rpb25zL2luZGV4LnJzdApAQCAtMTYs MyArMTYsNCBAQCBjb21tb24gYSBzZXQgb2YgTGludXggaGVscGVycyBmb3IgRUxGIHNlY3Rpb25z IGFyZSBhbHNvIGRvY3VtZW50ZWQuCiAgICBiYWNrZ3JvdW5kCiAgICBzZWN0aW9uLWNvcmUKICAg IHJhbmdlcworICAgbGlua2VyLXRhYmxlcwpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zZWN0 aW9ucy9saW5rZXItdGFibGVzLnJzdCBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvbGlua2VyLXRh Ymxlcy5yc3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi43ODBhMjky ZDJkMDAKLS0tIC9kZXYvbnVsbAorKysgYi9Eb2N1bWVudGF0aW9uL3NlY3Rpb25zL2xpbmtlci10 YWJsZXMucnN0CkBAIC0wLDAgKzEsMjEyIEBACis9PT09PT09PT09PT09PT09PT09CitMaW51eCBs aW5rZXIgdGFibGVzCis9PT09PT09PT09PT09PT09PT09CisKK1RoaXMgZG9jdW1lbnRzIExpbnV4 IGxpbmtlciB0YWJsZXMsIGl0IGV4cGxhaW5zIHdoYXQgdGhleSBhcmUsIHdoZXJlIHRoZXkKK2Nh bWUgZnJvbSwgaG93IHRoZXkgd29yaywgdGhlIGJlbmVmaXRzIG9mIHVzaW5nIHRoZW0gYW5kIG1v cmUgaW1wb3J0YW50bHkKK2hvdyB5b3UgY2FuIHVzZSB0aGVtLgorCitBYm91dCBMaW5rZXIgdGFi bGVzCis9PT09PT09PT09PT09PT09PT09CisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90 YWJsZXMuaAorICAgOmRvYzogSW50cm9kdWN0aW9uCisKK0xpbmtlciB0YWJsZSBwcm92ZW5hbmNl CistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworLi4ga2Vy bmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpkb2M6IExpbmtlciB0YWJsZSBw cm92ZW5hbmNlCisKK0JlbmVmaXRzIG9mIHVzaW5nIExpbmtlciB0YWJsZXMKKz09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KKworQXZvaWRzIG1vZGlmeWluZyBhcmNoaXRlY3R1cmUgbGlu a2VyIHNjcmlwdHMKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZG9jOiBBdm9p ZHMgbW9kaWZ5aW5nIGFyY2hpdGVjdHVyZSBsaW5rZXIgc2NyaXB0cworCitIb3cgbGlua2VyIHRh YmxlcyBzaW1wbGlmeSBpbml0aWFsaXphdGlvbiBjb2RlCistLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90 YWJsZXMuaAorICAgOmRvYzogSG93IGxpbmtlciB0YWJsZXMgc2ltcGxpZnkgaW5pdGlhbGl6YXRp b24gY29kZQorCitVc2luZyBsaW5rZXIgdGFibGVzIGluIExpbnV4Cis9PT09PT09PT09PT09PT09 PT09PT09PT09PT09CisKK0xpbmtlciB0YWJsZSBtb2R1bGUgc3VwcG9ydAorLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCisKKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5o CisgICA6ZG9jOiBMaW5rZXIgdGFibGUgbW9kdWxlIHN1cHBvcnQKKworTGlua2VyIHRhYmxlIGhl bHBlcnMKKz09PT09PT09PT09PT09PT09PT09CisKKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xp bnV4L3RhYmxlcy5oCisgICA6ZG9jOiBMaW5rZXIgdGFibGUgaGVscGVycworCitMSU5LVEFCTEVf U1RBUlQKKy0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFi bGVzLmgKKyAgIDpmdW5jdGlvbnM6IExJTktUQUJMRV9TVEFSVAorCitMSU5LVEFCTEVfRU5ECist LS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAg OmZ1bmN0aW9uczogTElOS1RBQkxFX0VORAorCitMSU5LVEFCTEVfU0laRQorLS0tLS0tLS0tLS0t LS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZnVuY3Rpb25z OiBMSU5LVEFCTEVfU0laRQorCitMSU5LVEFCTEVfRU1QVFkKKy0tLS0tLS0tLS0tLS0tLQorLi4g a2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpmdW5jdGlvbnM6IExJTktU QUJMRV9FTVBUWQorCitMSU5LVEFCTEVfQUREUl9XSVRISU4KKy0tLS0tLS0tLS0tLS0tLS0tLS0t LQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpmdW5jdGlvbnM6 IExJTktUQUJMRV9BRERSX1dJVEhJTgorCitMSU5LVEFCTEVfQUxJR05NRU5UCistLS0tLS0tLS0t LS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAgOmZ1 bmN0aW9uczogTElOS1RBQkxFX0FMSUdOTUVOVAorCitDb25zdHJ1Y3RpbmcgbGlua2VyIHRhYmxl cworPT09PT09PT09PT09PT09PT09PT09PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUv bGludXgvdGFibGVzLmgKKyAgIDpkb2M6IENvbnN0cnVjdGluZyBsaW5rZXIgdGFibGVzCisKK1dl YWsgbGlua2VyIHRhYmxlcyBjb25zdHJ1Y3RvcnMKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0KKworLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpkb2M6 IFdlYWsgbGlua2VyIHRhYmxlcyBjb25zdHJ1Y3RvcnMKKworTElOS1RBQkxFX1dFQUsKKy0tLS0t LS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAgOmZ1 bmN0aW9uczogTElOS1RBQkxFX1dFQUsKKworTElOS1RBQkxFX1RFWFRfV0VBSworLS0tLS0tLS0t LS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpm dW5jdGlvbnM6IExJTktUQUJMRV9URVhUX1dFQUsKKworTElOS1RBQkxFX1JPX1dFQUsKKy0tLS0t LS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAg OmZ1bmN0aW9uczogTElOS1RBQkxFX1JPX1dFQUsKKworTElOS1RBQkxFX0lOSVRfV0VBSworLS0t LS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgK KyAgIDpmdW5jdGlvbnM6IExJTktUQUJMRV9JTklUX1dFQUsKKworTElOS1RBQkxFX0lOSVRfREFU QV9XRUFLCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRl L2xpbnV4L3RhYmxlcy5oCisgICA6ZnVuY3Rpb25zOiBMSU5LVEFCTEVfSU5JVF9EQVRBX1dFQUsK KworUmVndWxhciBsaW5rZXIgbGlua2VyIHRhYmxlIGNvbnN0cnVjdG9ycworLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9s aW51eC90YWJsZXMuaAorICAgOmRvYzogUmVndWxhciBsaW5rZXIgbGlua2VyIHRhYmxlIGNvbnN0 cnVjdG9ycworCitMSU5LVEFCTEUKKy0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUv bGludXgvdGFibGVzLmgKKyAgIDpmdW5jdGlvbnM6IExJTktUQUJMRQorCitMSU5LVEFCTEVfVEVY VAorLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5o CisgICA6ZnVuY3Rpb25zOiBMSU5LVEFCTEVfVEVYVAorCitMSU5LVEFCTEVfUk8KKy0tLS0tLS0t LS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpmdW5jdGlv bnM6IExJTktUQUJMRV9STworCitMSU5LVEFCTEVfSU5JVAorLS0tLS0tLS0tLS0tLS0KKy4uIGtl cm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZnVuY3Rpb25zOiBMSU5LVEFC TEVfSU5JVAorCitMSU5LVEFCTEVfSU5JVF9EQVRBCistLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBr ZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAgOmZ1bmN0aW9uczogTElOS1RB QkxFX0lOSVRfREFUQQorCitEZWNsYXJpbmcgTGlua2VyIHRhYmxlcworPT09PT09PT09PT09PT09 PT09PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpk b2M6IERlY2xhcmluZyBMaW5rZXIgdGFibGVzCisKK0RFQ0xBUkVfTElOS1RBQkxFCistLS0tLS0t LS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAor ICAgOmZ1bmN0aW9uczogREVDTEFSRV9MSU5LVEFCTEUKKworREVDTEFSRV9MSU5LVEFCTEVfUk8K Ky0tLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJs ZXMuaAorICAgOmZ1bmN0aW9uczogREVDTEFSRV9MSU5LVEFCTEVfUk8KKworRGVmaW5pbmcgTGlu a2VyIHRhYmxlcworPT09PT09PT09PT09PT09PT09PT09PQorCisuLiBrZXJuZWwtZG9jOjogaW5j bHVkZS9saW51eC90YWJsZXMuaAorICAgOmRvYzogRGVmaW5pbmcgTGlua2VyIHRhYmxlcworCitE RUZJTkVfTElOS1RBQkxFCistLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVk ZS9saW51eC90YWJsZXMuaAorICAgOmZ1bmN0aW9uczogREVGSU5FX0xJTktUQUJMRQorCitERUZJ TkVfTElOS1RBQkxFX1RFWFQKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6 IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpmdW5jdGlvbnM6IERFRklORV9MSU5LVEFCTEVf VEVYVAorCitERUZJTkVfTElOS1RBQkxFX1JPCistLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJu ZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAgOmZ1bmN0aW9uczogREVGSU5FX0xJ TktUQUJMRV9STworCitERUZJTkVfTElOS1RBQkxFX0lOSVQKKy0tLS0tLS0tLS0tLS0tLS0tLS0t LQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpmdW5jdGlvbnM6 IERFRklORV9MSU5LVEFCTEVfSU5JVAorCitERUZJTkVfTElOS1RBQkxFX0lOSVRfREFUQQorLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3Rh Ymxlcy5oCisgICA6ZnVuY3Rpb25zOiBERUZJTkVfTElOS1RBQkxFX0lOSVRfREFUQQorCitJdGVy YXRpbmcgb3ZlciBMaW5rZXIgdGFibGVzCis9PT09PT09PT09PT09PT09PT09PT09PT09PT09CisK Ky4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3RhYmxlcy5oCisgICA6ZG9jOiBJdGVyYXRp bmcgb3ZlciBMaW5rZXIgdGFibGVzCisKK2xpbmt0YWJsZV9mb3JfZWFjaAorLS0tLS0tLS0tLS0t LS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC90YWJsZXMuaAorICAgOmZ1bmN0 aW9uczogbGlua3RhYmxlX2Zvcl9lYWNoCisKK2xpbmt0YWJsZV9ydW5fYWxsCistLS0tLS0tLS0t LS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpmdW5j dGlvbnM6IGxpbmt0YWJsZV9ydW5fYWxsCisKK2xpbmt0YWJsZV9ydW5fZXJyCistLS0tLS0tLS0t LS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvdGFibGVzLmgKKyAgIDpmdW5j dGlvbnM6IGxpbmt0YWJsZV9ydW5fZXJyCmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5U QUlORVJTCmluZGV4IGM5NmNhMDMyYzI3Ni4uYmJmNTE5ZGEzYTc4IDEwMDY0NAotLS0gYS9NQUlO VEFJTkVSUworKysgYi9NQUlOVEFJTkVSUwpAQCAtNTQwNyw2ICs1NDA3LDE2IEBAIFM6CU1haW50 YWluZWQKIEY6CWluY2x1ZGUvYXNtLWdlbmVyaWMvCiBGOglpbmNsdWRlL3VhcGkvYXNtLWdlbmVy aWMvCiAKK0dFTkVSSUMgTElOS0VSIFRBQkxFUworTToJIkx1aXMgUi4gUm9kcmlndWV6IiA8bWNn cm9mQGtlcm5lbC5vcmc+CitNOgkiSC4gUGV0ZXIgQW52aW4iIDxocGFAenl0b3IuY29tPgorTDoJ bGludXgtYXJjaEB2Z2VyLmtlcm5lbC5vcmcKK0w6CWxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5v cmcKK1M6CVN1cHBvcnRlZAorRjoJaW5jbHVkZS9hc20tZ2VuZXJpYy90YWJsZXMuaAorRjoJaW5j bHVkZS9saW51eC90YWJsZXMuaAorRjoJRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9saW5rZXItdGFi bGVzLnJzdAorCiBHRU5FUklDIFBIWSBGUkFNRVdPUksKIE06CUtpc2hvbiBWaWpheSBBYnJhaGFt IEkgPGtpc2hvbkB0aS5jb20+CiBMOglsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnCmRpZmYg LS1naXQgYS9hcmNoL2FscGhhL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvYWxwaGEvaW5jbHVk ZS9hc20vS2J1aWxkCmluZGV4IGU0NGM4OTZiOTFjNC4uZjNiZGMzMWQzYzk3IDEwMDY0NAotLS0g YS9hcmNoL2FscGhhL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2FscGhhL2luY2x1ZGUv YXNtL0tidWlsZApAQCAtMTIsMyArMTIsNCBAQCBnZW5lcmljLXkgKz0gc2VjdGlvbnMuaAogZ2Vu ZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2Vu ZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2Fy Y2gvYXJjL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvYXJjL2luY2x1ZGUvYXNtL0tidWlsZApp bmRleCBhMzc0YjdmODM4ODguLmNjZmE2OWNlMjYwOCAxMDA2NDQKLS0tIGEvYXJjaC9hcmMvaW5j bHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvYXJjL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNTMs MyArNTMsNCBAQCBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhv ci5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAor Z2VuZXJpYy15ICs9IHRhYmxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9L YnVpbGQgYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggMGQ0N2Y5OGNjYmMwLi5i NzBkNGI3OGQ1NzcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL0tidWlsZAorKysg Yi9hcmNoL2FybS9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTQzLDMgKzQzLDQgQEAgZ2VuZXJhdGVk LXkgKz0gbWFjaC10eXBlcy5oCiBnZW5lcmF0ZWQteSArPSB1bmlzdGQtbnIuaAogZ2VuZXJpYy15 ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgKK2dlbmVyaWMteSArPSB0 YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNo L2FybTY0L2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBlOTkzOWNiZDkwNjcuLjBjMWU3ODFhYjEw YiAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9h cm02NC9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTQ3LDMgKzQ3LDQgQEAgZ2VuZXJpYy15ICs9IHZn YS5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2Vu ZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2Fy Y2gvYXZyMzIvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9hdnIzMi9pbmNsdWRlL2FzbS9LYnVp bGQKaW5kZXggZWRjMTc2MzQ4ZDdjLi5hNmNkMTQ1NTE1YWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXZy MzIvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvYXZyMzIvaW5jbHVkZS9hc20vS2J1aWxk CkBAIC0yNCwzICsyNCw0IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmlj LXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJh bmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4v aW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9LYnVpbGQKaW5k ZXggMzQyODQxNWIxOTk2Li45MTE1YjIxNWZjN2UgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4v aW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vS2J1aWxk CkBAIC00OSwzICs0OSw0IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmlj LXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJh bmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvYzZ4L2luY2x1 ZGUvYXNtL3RhYmxlcy5oIGIvYXJjaC9jNngvaW5jbHVkZS9hc20vdGFibGVzLmgKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi45MGEwZDNkZjM1YzgKLS0tIC9kZXYvbnVs bAorKysgYi9hcmNoL2M2eC9pbmNsdWRlL2FzbS90YWJsZXMuaApAQCAtMCwwICsxLDI2IEBACisj aWZuZGVmIF9BU01fQzZYX0FTTV9UQUJMRVNfSAorI2RlZmluZSBfQVNNX0M2WF9BU01fVEFCTEVT X0gKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYgTHVpcyBSLiBSb2RyaWd1ZXogPG1jZ3JvZkBr ZXJuZWwub3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2Yg Y29weWxlZnQtbmV4dCAodmVyc2lvbiAwLjMuMSBvciBsYXRlcikgYXMgcHVibGlzaGVkCisgKiBh dCBodHRwOi8vY29weWxlZnQtbmV4dC5vcmcvLgorICovCisKKy8qCisgKiBUaGUgYzZ4IHRvb2xj aGFpbiBoYXMgYSBidWcgcHJlc2VudCBldmVuIG9uIGdjYy02IHdoZW4gbm9uLXdlYWsgYXR0cmli dXRlcworICogYXJlIHVzZWQgYW5kIHNlbmRzIHRoZW0gdG8gLnJvZGF0YSBldmVuIHRob3VnaCBj b25zdCBkYXRhIHdpdGggd2VhaworICogYXR0cmlidXRlcyBhcmUgcHV0IGluIC5jb25zdCwgdGhp cyBmb3JjZXMgdGhlIGxpbmtlciB0byBiZWxpZXZlIHRoZSBhZGRyZXNzCisgKiBpcyByZWxhdGl2 ZSByZWxhdGl2ZSB0byB0aGUgYSBiYXNlICsgb2Zmc2V0IGFuZCB5b3UgZW5kIHVwIHdpdGggU0It cmVsYXRpdmUKKyAqIHJlbG9jIGVycm9yIHVwb24gbGlua2luZy4gV29yayBhcm91bmQgdGhpcyBi eSBieSBmb3JjaW5nIGJvdGggc3RhcnQgYW5kCisgKiBlbmRpbmcgY29uc3QgUk8gd2VhayBsaW5r ZXIgdGFibGUgZW50cnkgdG8gYmUgLmNvbnN0IHRvIGZpeCB0aGlzIGZvciBub3cuCisgKgorICog WzBdIGh0dHBzOi8vbGttbC5rZXJuZWwub3JnL3IvMTQ3MDc5ODI0Ny4zNTUxLjk0LmNhbWVsQHJl ZGhhdC5jb20KKyAqLworCisjZGVmaW5lIFNFQ1RJT05fVEJMX1JPCQkuY29uc3QKKworI2luY2x1 ZGUgPGFzbS1nZW5lcmljL3RhYmxlcy5oPgorCisjZW5kaWYgLyogX0FTTV9DNlhfQVNNX1RBQkxF U19IICovCmRpZmYgLS1naXQgYS9hcmNoL2NyaXMvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9j cmlzL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBmYjhiYjQxMTI3NzMuLjcwNjJjMWJlNzkxMyAx MDA2NDQKLS0tIGEvYXJjaC9jcmlzL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2NyaXMv aW5jbHVkZS9hc20vS2J1aWxkCkBAIC00NywzICs0Nyw0IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0 LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUu aAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdp dCBhL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL0ti dWlsZAppbmRleCA1MTkxZmVjNjU1ZDcuLjRhNTljYmRhNTA5MSAxMDA2NDQKLS0tIGEvYXJjaC9m cnYvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL0tidWlsZApA QCAtMTAsMyArMTAsNCBAQCBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9 IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15 ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvaDgz MDAvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9oODMwMC9pbmNsdWRlL2FzbS9LYnVpbGQKaW5k ZXggNzkyOWE5OTI1NjZjLi5kNzk5NjhkOTNjMTIgMTAwNjQ0Ci0tLSBhL2FyY2gvaDgzMDAvaW5j bHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvaDgzMDAvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC03 NywzICs3Nyw0IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0g eG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5o CitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvaGV4YWdvbi9pbmNsdWRl L2FzbS9LYnVpbGQgYi9hcmNoL2hleGFnb24vaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGFmMTdl ZTMzNDc4OC4uZDU5YWMxYzE4NThiIDEwMDY0NAotLS0gYS9hcmNoL2hleGFnb24vaW5jbHVkZS9h c20vS2J1aWxkCisrKyBiL2FyY2gvaGV4YWdvbi9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTYyLDMg KzYyLDQgQEAgZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3Iu aAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgKK2dl bmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL0ti dWlsZCBiL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggZDhmMjI2YjM1YTBhLi43 NjU0MGYxNDM0NzMgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9LYnVpbGQKKysr IGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMTEsMyArMTEsNCBAQCBnZW5lcmlj LXkgKz0gdnRpbWUuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSAr PSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFi bGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL20z MnIvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDFjNjUwNGQyOTMxMi4uMjQwODhmM2M3MzNjIDEw MDY0NAotLS0gYS9hcmNoL20zMnIvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbTMyci9p bmNsdWRlL2FzbS9LYnVpbGQKQEAgLTEzLDMgKzEzLDQgQEAgZ2VuZXJpYy15ICs9IHRyYWNlX2Ns b2NrLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0gc2VjdGlv bi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAorZ2VuZXJpYy15ICs9IHRhYmxlcy5oCmRp ZmYgLS1naXQgYS9hcmNoL202OGsvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9tNjhrL2luY2x1 ZGUvYXNtL0tidWlsZAppbmRleCAwMDZlMjg2M2FkMzcuLmMyOGJjZGVjYzc2NCAxMDA2NDQKLS0t IGEvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL202OGsvaW5jbHVkZS9h c20vS2J1aWxkCkBAIC0zNiwzICszNiw0IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5o CiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJp Yy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gv bWV0YWcvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9tZXRhZy9pbmNsdWRlL2FzbS9LYnVpbGQK aW5kZXggNGE4NDcxNDM0YTNlLi5jODM2ZjdlMmE1ZTcgMTAwNjQ0Ci0tLSBhL2FyY2gvbWV0YWcv aW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbWV0YWcvaW5jbHVkZS9hc20vS2J1aWxkCkBA IC01NywzICs1Nyw0IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkg Kz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdl cy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvbWljcm9ibGF6ZS9p bmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vS2J1aWxkCmlu ZGV4IDYzYzA4M2ExZjhkYS4uMDFhZmIxYjQyMGY1IDEwMDY0NAotLS0gYS9hcmNoL21pY3JvYmxh emUvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9L YnVpbGQKQEAgLTEzLDMgKzEzLDQgQEAgZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdlbmVy aWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdl bmVyaWMteSArPSByYW5nZXMuaAorZ2VuZXJpYy15ICs9IHRhYmxlcy5oCmRpZmYgLS1naXQgYS9h cmNoL21pcHMvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL0tidWls ZAppbmRleCBlODQ0ZDYwNTgyNDguLmRiOWRmZjljMTUzNSAxMDA2NDQKLS0tIGEvYXJjaC9taXBz L2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vS2J1aWxkCkBA IC0yMywzICsyMyw0IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkg Kz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdl cy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvbW4xMDMwMC9pbmNs dWRlL2FzbS9LYnVpbGQgYi9hcmNoL21uMTAzMDAvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDY1 NmFmN2I2OTk0MC4uNmM4ZDEyZjNmZTQ0IDEwMDY0NAotLS0gYS9hcmNoL21uMTAzMDAvaW5jbHVk ZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbW4xMDMwMC9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTEy LDMgKzEyLDQgQEAgZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdlbmVyaWMteSArPSB3b3Jk LWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSBy YW5nZXMuaAorZ2VuZXJpYy15ICs9IHRhYmxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL25pb3MyL2lu Y2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvbmlvczIvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGM1 NTg4MDY1OWQ2Ny4uZWU2MjIwZGFjMWU4IDEwMDY0NAotLS0gYS9hcmNoL25pb3MyL2luY2x1ZGUv YXNtL0tidWlsZAorKysgYi9hcmNoL25pb3MyL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNjUsMyAr NjUsNCBAQCBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5o CiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAorZ2Vu ZXJpYy15ICs9IHRhYmxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL29wZW5yaXNjL2luY2x1ZGUvYXNt L0tidWlsZCBiL2FyY2gvb3BlbnJpc2MvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDdkNmE3MDRi ODA4Yy4uY2VhZmU0NThlMjk1IDEwMDY0NAotLS0gYS9hcmNoL29wZW5yaXNjL2luY2x1ZGUvYXNt L0tidWlsZAorKysgYi9hcmNoL29wZW5yaXNjL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNzMsMyAr NzMsNCBAQCBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5o CiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAorZ2Vu ZXJpYy15ICs9IHRhYmxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9L YnVpbGQgYi9hcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggZjExZDEyNDk3Mzhm Li5hYWFlOGE5ZjYwOTkgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL0tidWls ZAorKysgYi9hcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTMwLDMgKzMwLDQgQEAg Z2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJp Yy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgKK2dlbmVyaWMteSAr PSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL0tidWlsZCBi L2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggNjBkODM0OTI0MWE3Li43YzA2 NjI3YTBhMGQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9LYnVpbGQKKysr IGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMTAsMyArMTAsNCBAQCBnZW5l cmljLXkgKz0gcndzZW0uaAogZ2VuZXJpYy15ICs9IHZ0aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0 aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgK ZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvdm1saW51eC5sZHMuUyBiL2FyY2gvcG93 ZXJwYy9rZXJuZWwvdm1saW51eC5sZHMuUwppbmRleCBmY2ZjOWQxMDIzNDguLjhjZDk0MGM3Mjg5 NSAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2tlcm5lbC92bWxpbnV4Lmxkcy5TCisrKyBiL2Fy Y2gvcG93ZXJwYy9rZXJuZWwvdm1saW51eC5sZHMuUwpAQCAtMTA4LDYgKzEwOCw3IEBAIFNFQ1RJ T05TCiAJCS8qIGNhcmVmdWwhIF9fZnRyX2FsdF8qIHNlY3Rpb25zIG5lZWQgdG8gYmUgY2xvc2Ug dG8gLnRleHQgKi8KIAkJKigudGV4dCAuZml4dXAgX19mdHJfYWx0XyogLnJlZi50ZXh0KQogCQkq KFNPUlQoLnRleHQucm5nLiopKQorCQkqKFNPUlQoLnRleHQuLnRibC4qKSkKIAkJU0NIRURfVEVY VAogCQlDUFVJRExFX1RFWFQKIAkJTE9DS19URVhUCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvaW5j bHVkZS9hc20vS2J1aWxkIGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBjMWI4 NWEzNjFlNWQuLjk2ZGQ2OTkzMTQyNyAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNt L0tidWlsZAorKysgYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0xMCwzICsxMCw0 IEBAIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRp bWUuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgK K2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9zY29yZS9pbmNsdWRlL2Fz bS9LYnVpbGQgYi9hcmNoL3Njb3JlL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBmMGNkYjJjYmNh NGQuLjE2ZWExNWEzZTQzMiAxMDA2NDQKLS0tIGEvYXJjaC9zY29yZS9pbmNsdWRlL2FzbS9LYnVp bGQKKysrIGIvYXJjaC9zY29yZS9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTE2LDMgKzE2LDQgQEAg Z2VuZXJpYy15ICs9IHNlcmlhbC5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2Vu ZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgKK2dlbmVyaWMt eSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9zaC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9h cmNoL3NoL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBjOWJiNzkzMmEzZDEuLmQwZWE3NjhkMTVh ZSAxMDA2NDQKLS0tIGEvYXJjaC9zaC9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9zaC9p bmNsdWRlL2FzbS9LYnVpbGQKQEAgLTQxLDMgKzQxLDQgQEAgZ2VuZXJpYy15ICs9IHVjb250ZXh0 LmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5l cmljLXkgKz0gcmFuZ2VzLmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZmIC0tZ2l0IGEvYXJj aC9zcGFyYy9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3NwYXJjL2luY2x1ZGUvYXNtL0tidWls ZAppbmRleCAyODI4MDg4N2FjNzkuLjIzYTIyMTZmNDE0NiAxMDA2NDQKLS0tIGEvYXJjaC9zcGFy Yy9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9LYnVpbGQK QEAgLTIzLDMgKzIzLDQgQEAgZ2VuZXJpYy15ICs9IHR5cGVzLmgKIGdlbmVyaWMteSArPSB3b3Jk LWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSBy YW5nZXMuaAorZ2VuZXJpYy15ICs9IHRhYmxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3RpbGUvaW5j bHVkZS9hc20vS2J1aWxkIGIvYXJjaC90aWxlL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCAzM2Y3 MDY5NzYzYWUuLmE1OTlmNmY0ZWUwYSAxMDA2NDQKLS0tIGEvYXJjaC90aWxlL2luY2x1ZGUvYXNt L0tidWlsZAorKysgYi9hcmNoL3RpbGUvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC00MiwzICs0Miw0 IEBAIGdlbmVyaWMteSArPSB0eXBlcy5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSAr PSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFi bGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvdW0vaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC91bS9p bmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggYjk1MmRjYjNlMjE2Li5kMjg2N2FhMDllMjMgMTAwNjQ0 Ci0tLSBhL2FyY2gvdW0vaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvdW0vaW5jbHVkZS9h c20vS2J1aWxkCkBAIC0yOCwzICsyOCw0IEBAIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5o CiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJp Yy15ICs9IHJhbmdlcy5oCitnZW5lcmljLXkgKz0gdGFibGVzLmgKZGlmZiAtLWdpdCBhL2FyY2gv dW5pY29yZTMyL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvdW5pY29yZTMyL2luY2x1ZGUvYXNt L0tidWlsZAppbmRleCA5M2FiYmZkYWI1NDMuLjY2NzFhMWYwOGVhZCAxMDA2NDQKLS0tIGEvYXJj aC91bmljb3JlMzIvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvdW5pY29yZTMyL2luY2x1 ZGUvYXNtL0tidWlsZApAQCAtNjIsMyArNjIsNCBAQCBnZW5lcmljLXkgKz0gdmdhLmgKIGdlbmVy aWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSAr PSByYW5nZXMuaAorZ2VuZXJpYy15ICs9IHRhYmxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9p bmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggZjY3 MmYyZmMxODFkLi40Y2I1MTFmMTA2N2MgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNt L0tidWlsZAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTE0LDMgKzE0LDQg QEAgZ2VuZXJpYy15ICs9IG1jc19zcGlubG9jay5oCiBnZW5lcmljLXkgKz0gbW0tYXJjaC1ob29r cy5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAor Z2VuZXJpYy15ICs9IHRhYmxlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni90b29scy9yZWxvY3Mu YyBiL2FyY2gveDg2L3Rvb2xzL3JlbG9jcy5jCmluZGV4IGY5NmZhMmRkZjdjOS4uNDg0YTI0YzMw OWZiIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni90b29scy9yZWxvY3MuYworKysgYi9hcmNoL3g4Ni90 b29scy9yZWxvY3MuYwpAQCAtNjksNyArNjksOSBAQCBzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IHN5bV9yZWdleF9rZXJuZWxbU19OU1lNVFlQRVNdID0gewogCSJfX2luaXRyYW1mc19zdGFydHwi CiAJIihqaWZmaWVzfGppZmZpZXNfNjQpfCIKIAkiLnJvZGF0YS4ucm5nLip8IgorCSIucm9kYXRh Li50YmwuKnwiCiAJIi5pbml0LnRleHQuLnJuZy4qfCIKKwkiLmluaXQudGV4dC4udGJsLip8Igog I2lmIEVMRl9CSVRTID09IDY0CiAJIl9fcGVyX2NwdV9sb2FkfCIKIAkiaW5pdF9wZXJfY3B1X18u KnwiCmRpZmYgLS1naXQgYS9hcmNoL3h0ZW5zYS9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3h0 ZW5zYS9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggMmI3ZmU0OGMwMjI1Li43YjQxZjMyYTJiYTAg MTAwNjQ0Ci0tLSBhL2FyY2gveHRlbnNhL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3h0 ZW5zYS9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTM0LDMgKzM0LDQgQEAgZ2VuZXJpYy15ICs9IHdv cmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24t Y29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgKK2dlbmVyaWMteSArPSB0YWJsZXMuaApkaWZm IC0tZ2l0IGEvaW5jbHVkZS9hc20tZ2VuZXJpYy90YWJsZXMuaCBiL2luY2x1ZGUvYXNtLWdlbmVy aWMvdGFibGVzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xNmVm NDBkMTQ1ZmIKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL2FzbS1nZW5lcmljL3RhYmxlcy5o CkBAIC0wLDAgKzEsNDggQEAKKyNpZm5kZWYgX0FTTV9HRU5FUklDX1RBQkxFU19IXworI2RlZmlu ZSBfQVNNX0dFTkVSSUNfVEFCTEVTX0hfCisvKgorICogTGludXggbGlua2VyIHRhYmxlcworICoK KyAqIENvcHlyaWdodCAoQykgMjAxNiBMdWlzIFIuIFJvZHJpZ3VleiA8bWNncm9mQGtlcm5lbC5v cmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiBjb3B5bGVm dC1uZXh0ICh2ZXJzaW9uIDAuMy4xIG9yIGxhdGVyKSBhcyBwdWJsaXNoZWQKKyAqIGF0IGh0dHA6 Ly9jb3B5bGVmdC1uZXh0Lm9yZy8uCisgKi8KKyNpbmNsdWRlIDxhc20vc2VjdGlvbi1jb3JlLmg+ CisKKyNkZWZpbmUgU0VDVElPTl9UQkwoc2VjdGlvbiwgbmFtZSwgbGV2ZWwpCXNlY3Rpb24uLnRi bC5uYW1lLmxldmVsCisKKy8qIFNvbWUgdG9vbGNoYWlucyBhcmUgYnVnZ3ksIGxldCB0aGVtIG92 ZXJyaWRlICovCisjaWZuZGVmIFNFQ1RJT05fVEJMX1JPCisjIGRlZmluZSBTRUNUSU9OX1RCTF9S Twkucm9kYXRhCisjZW5kaWYKKworI2RlZmluZSBTRUNUSU9OX1RCTF9ST19TVFIgX19zdHJpbmdp ZnkoU0VDVElPTl9UQkxfUk8pCisKKyNpZm5kZWYgc2V0X3NlY3Rpb25fdGJsCisjIGRlZmluZSBz ZXRfc2VjdGlvbl90Ymwoc2VjdGlvbiwgbmFtZSwgbGV2ZWwsIGZsYWdzKQkJCVwKKwkgc2V0X3Nl Y3Rpb25fY29yZShzZWN0aW9uLCB0YmwsIG5hbWUsIGxldmVsLCBmbGFncykKKyNlbmRpZgorCisj aWZuZGVmIHNldF9zZWN0aW9uX3RibF9hbnkKKyMgZGVmaW5lIHNldF9zZWN0aW9uX3RibF9hbnko c2VjdGlvbiwgbmFtZSwgZmxhZ3MpCQkJCVwKKwkgc2V0X3NlY3Rpb25fY29yZShzZWN0aW9uLCB0 YmwsIG5hbWUsIGFueSwgZmxhZ3MpCisjZW5kaWYKKworI2lmbmRlZiBzZXRfc2VjdGlvbl90Ymxf dHlwZQorIyBkZWZpbmUgc2V0X3NlY3Rpb25fdGJsX3R5cGUoc2VjdGlvbiwgbmFtZSwgbGV2ZWws IGZsYWdzLCB0eXBlKQkJXAorCSBzZXRfc2VjdGlvbl9jb3JlX3R5cGUoc2VjdGlvbiwgdGJsLCBu YW1lLCBsZXZlbCwgZmxhZ3MsIHR5cGUpCisjZW5kaWYKKworI2lmbmRlZiBwdXNoX3NlY3Rpb25f dGJsCisjIGRlZmluZSBwdXNoX3NlY3Rpb25fdGJsKHNlY3Rpb24sIG5hbWUsIGxldmVsLCBmbGFn cykJCQlcCisJIHB1c2hfc2VjdGlvbl9jb3JlKHNlY3Rpb24sIHRibCwgbmFtZSwgbGV2ZWwsIGZs YWdzKQorI2VuZGlmCisKKyNpZm5kZWYgcHVzaF9zZWN0aW9uX3RibF9hbnkKKyMgZGVmaW5lIHB1 c2hfc2VjdGlvbl90YmxfYW55KHNlY3Rpb24sIG5hbWUsIGZsYWdzKQkJCVwKKwkgcHVzaF9zZWN0 aW9uX2NvcmUoc2VjdGlvbiwgdGJsLCBuYW1lLCBhbnksIGZsYWdzKQorI2VuZGlmCisKKyNlbmRp ZiAvKiBfQVNNX0dFTkVSSUNfVEFCTEVTX0hfICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2FzbS1n ZW5lcmljL3ZtbGludXgubGRzLmggYi9pbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmgK aW5kZXggNzFiZmQzYjNjNzE5Li5jZTFlOWEzMTBhZGEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYXNt LWdlbmVyaWMvdm1saW51eC5sZHMuaAorKysgYi9pbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgu bGRzLmgKQEAgLTU3LDYgKzU3LDcgQEAKICNpbmNsdWRlIDxsaW51eC9leHBvcnQuaD4KICNpbmNs dWRlIDxhc20vc2VjdGlvbi1jb3JlLmg+CiAjaW5jbHVkZSA8YXNtL3Jhbmdlcy5oPgorI2luY2x1 ZGUgPGFzbS90YWJsZXMuaD4KIAogLyogQWxpZ24gLiB0byBhIDggYnl0ZSBib3VuZGFyeSBlcXVh bHMgdG8gbWF4aW11bSBmdW5jdGlvbiBhbGlnbm1lbnQuICovCiAjZGVmaW5lIEFMSUdOX0ZVTkNU SU9OKCkgIC4gPSBBTElHTig4KQpAQCAtMjA3LDYgKzIwOCw3IEBACiAjZGVmaW5lIERBVEFfREFU QQkJCQkJCQlcCiAJKiguZGF0YSAuZGF0YS5bMC05YS16QS1aX10qKQkJCQkJXAogCSooU09SVCgu ZGF0YS4ucm5nLiopKQkJCQkJCVwKKwkqKFNPUlQoLmRhdGEuLnRibC4qKSkJCQkJCQlcCiAJKigu cmVmLmRhdGEpCQkJCQkJCVwKIAkqKC5kYXRhLi5zaGFyZWRfYWxpZ25lZCkgLyogcGVyY3B1IHJl bGF0ZWQgKi8JCQlcCiAJTUVNX0tFRVAoaW5pdC5kYXRhKQkJCQkJCVwKQEAgLTI3Nyw2ICsyNzks NyBAQAogCQlWTUxJTlVYX1NZTUJPTChfX3N0YXJ0X3JvZGF0YSkgPSAuOwkJCVwKIAkJKigucm9k YXRhKQkJCQkJCVwKIAkJKihTT1JUKC5yb2RhdGEuLnJuZy4qKSkJCQkJCVwKKwkJKihTT1JUKC5y b2RhdGEuLnRibC4qKSkJCQkJCVwKIAkJKigucm9kYXRhLiopCQkJCQkJXAogCQlST19BRlRFUl9J TklUX0RBVEEJLyogUmVhZCBvbmx5IGFmdGVyIGluaXQgKi8JXAogCQlLRUVQKCooX192ZXJtYWdp YykpCS8qIEtlcm5lbCB2ZXJzaW9uIG1hZ2ljICovCVwKQEAgLTQ1Miw2ICs0NTUsNyBAQAogCQlB TElHTl9GVU5DVElPTigpOwkJCQkJXAogCQkqKC50ZXh0LmhvdCAudGV4dCkJCQkJCVwKIAkJKihT T1JUKC50ZXh0Li5ybmcuKikpCQkJCQlcCisJCSooU09SVCgudGV4dC4udGJsLiopKQkJCQkJXAog CQkqKC50ZXh0LmZpeHVwIC50ZXh0LnVubGlrZWx5KQkJCQlcCiAJCSooLnJlZi50ZXh0KQkJCQkJ CVwKIAlNRU1fS0VFUChpbml0LnRleHQpCQkJCQkJXApAQCAtNTU2LDYgKzU2MCw3IEBACiAJS0VF UCgqKFNPUlQoX19fa2VudHJ5KyopKSkJCQkJCVwKIAkqKC5pbml0LmRhdGEpCQkJCQkJCVwKIAkq KFNPUlQoLmluaXQuZGF0YS4ucm5nLiopKQkJCQkJXAorCSooU09SVCguaW5pdC5kYXRhLi50Ymwu KikpCQkJCQlcCiAJTUVNX0RJU0NBUkQoaW5pdC5kYXRhKQkJCQkJCVwKIAlLRVJORUxfQ1RPUlMo KQkJCQkJCQlcCiAJTUNPVU5UX1JFQygpCQkJCQkJCVwKQEAgLTU4MCw2ICs1ODUsNyBAQAogI2Rl ZmluZSBJTklUX1RFWFQJCQkJCQkJXAogCSooLmluaXQudGV4dCkJCQkJCQkJXAogCSooU09SVCgu aW5pdC50ZXh0Li5ybmcuKikpCQkJCQlcCisJKihTT1JUKC5pbml0LnRleHQuLnRibC4qKSkJCQkJ CVwKIAkqKC50ZXh0LnN0YXJ0dXApCQkJCQkJXAogCU1FTV9ESVNDQVJEKGluaXQudGV4dCkKIApk aWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC90YWJsZXMuaCBiL2luY2x1ZGUvbGludXgvdGFibGVz LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4xYTE4MzhkNTE5NTEK LS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL2xpbnV4L3RhYmxlcy5oCkBAIC0wLDAgKzEsNjEy IEBACisjaWZuZGVmIF9MSU5VWF9MSU5LRVJfVEFCTEVTX0gKKyNkZWZpbmUgX0xJTlVYX0xJTktF Ul9UQUJMRVNfSAorLyoKKyAqIExpbnV4IGxpbmtlciB0YWJsZXMKKyAqCisgKiBDb3B5cmlnaHQg KEMpIDIwMTYgTHVpcyBSLiBSb2RyaWd1ZXogPG1jZ3JvZkBrZXJuZWwub3JnPgorICoKKyAqIFRo aXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQv b3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgY29weWxlZnQtbmV4dCAodmVyc2lv biAwLjMuMSBvciBsYXRlcikgYXMgcHVibGlzaGVkCisgKiBhdCBodHRwOi8vY29weWxlZnQtbmV4 dC5vcmcvLgorICovCisjaW5jbHVkZSA8bGludXgvZXhwb3J0Lmg+CisjaW5jbHVkZSA8bGludXgv c2VjdGlvbnMuaD4KKyNpbmNsdWRlIDxhc20vdGFibGVzLmg+CisKKyNpZm5kZWYgX19BU1NFTUJM WV9fCisKKy8qKgorICogRE9DOiBJbnRyb2R1Y3Rpb24KKyAqCisgKiBBIGxpbmtlciB0YWJsZSBp cyBhIGRhdGEgc3RydWN0dXJlIHRoYXQgaXMgc3RpdGNoZWQgdG9nZXRoZXIgZnJvbSBpdGVtcyBp bgorICogbXVsdGlwbGUgb2JqZWN0IGZpbGVzIGZvciB0aGUgcHVycG9zZSBvZiBzZWxlY3RpdmUg cGxhY2VtZW50IGludG8gc3RhbmRhcmQKKyAqIG9yIGFyY2hpdGVjdHVyZSBzcGVjaWZpYyBFTEYg c2VjdGlvbnMuIFdoYXQgc2VjdGlvbiBpcyB1c2VkIGlzIHV0aWxpdHkKKyAqIHNwZWNpZmljLiBM aW51eCBoYXMgaGlzdG9yaWNhbGx5IGltcGxpY2l0bHkgdXNlZCBsaW5rZXIgdGFibGVzLCBob3dl dmVyIHRoZXkKKyAqIHdlcmUgYWxsIGJ1aWx0IGluIGFuIGFkaG9jIG1hbm5lciB3aGljaCByZXF1 aXJlcyBsaW5rZXIgc2NyaXB0IG1vZGlmaWNhdGlvbnMKKyAqIHBlciBhcmNoaXRlY3R1cmUuIFRo ZSBsaW5rZXIgdGFibGUgQVBJIHByb3ZpZGVzIGEgZ2VuZXJhbCBmYWNpbGl0eSBzbyB0aGF0Cisg KiBkYXRhIHN0cnVjdHVyZXMgY2FuIGJlIHN0aXRjaGVkIHRvZ2V0aGVyIGFuZCBwbGFjZWQgaW50 byBMaW51eCBFTEYgc2VjdGlvbnMKKyAqIGJ5IG9ubHkgY2hhbmdpbmcgQyBvciBhc20gY29kZSBp biBhbiBhcmNoaXRlY3R1cmUgYWdub3N0aWMgZm9ybS4KKyAqCisgKiBMaW5rZXIgdGFibGVzIGhl bHAgeW91IGdyb3VwIHRvZ2V0aGVyIHJlbGF0ZWQgZGF0YSBhbmQgY29kZSBpbiBhbiBlZmZpY2ll bnQKKyAqIHdheS4gTGlua2VyIHRhYmxlcyBjYW4gYmUgdXNlZCB0byBoZWxwIHNpbXBsaWZ5IGlu aXQgc2VxdWVuY2VzLCB0aGV5CisgKiBlbmFibGUgbGlua2VyIGJ1aWxkIHRpbWUgc2VsZWN0aXZl IHNvcnRpbmcgKGRpc2FibGVkIG9wdGlvbnMgZ2V0IGlnbm9yZWQpLAorICogYW5kIGNhbiBvcHRp b25hbGx5IGFsc28gYmUgdXNlZCB0byBoZWxwIHlvdSBhdm9pZCBjb2RlIGJpdC1yb3QgZHVlIHRv CisgKiBvdmVydXNlIG9mICNpZmRlZi4KKyAqLworCisvKioKKyAqIERPQzogTGlua2VyIHRhYmxl IHByb3ZlbmFuY2UKKyAqCisgKiBUaGUgTGludXggaW1wbGVtZW50YXRpb24gb2YgbGlua2VyIHRh YmxlcyB3YXMgaW5zcGlyZWQgYnkgdGhlIGlQWEUgbGlua2VyCisgKiB0YWJsZSdzIHNvbHV0aW9u IChpUFhFIGNvbW1pdCA2N2ExMGVmMDAwY2I3ICJbY29udHJpYl0gQWRkIHJvbS1vLW1hdGljIHRv CisgKiBjb250cmliICJbMF0pLiAgVG8gc2VlIGhvdyB0aGlzIGNvZGUgZXZvbHZlZCByZWZlciB0 byB0aGUgb3V0IG9mIHRyZWUKKyAqIHVzZXJzcGFjZSBsaW5rZXItdGFibGUgdHJlZSBbMV0uCisg KgorICogQ29udHJhcnkgdG8gaVBYRSdzIHNvbHV0aW9uIHdoaWNoIHN0cml2ZXMgdG8gZm9yY2Ug Y29tcGlsYXRpb24gb2YKKyAqIGV2ZXJ5dGhpbmcgdXNpbmcgbGlua2VyIHRhYmxlcywgTGludXgn cyBzb2x1dGlvbiBhbGxvd3MgZm9yIGRldmVsb3BlcnMgdG8gYmUKKyAqIHNlbGVjdGl2ZSBvdmVy IHdoZXJlIG9uZSB3aXNoZXMgdG8gZm9yY2UgY29tcGlsYXRpb24sIHRoaXMgdGhlbiBpcyBqdXN0 IGFuCisgKiBvcHRpb25hbCBmZWF0dXJlIGZvciB0aGUgTGludXggbGlua2VyIHRhYmxlIHNvbHV0 aW9uLiBUaGUgbWFpbiBhZHZhbnRhZ2VzCisgKiBvZiB1c2luZyBsaW5rZXItdGFibGVzIHRoZW4g YXJlOgorICoKKyAqICAtIEF2b2lkaW5nIG1vZGlmeWluZyBhcmNoaXRlY3R1cmUgbGlua2VyIHNj cmlwdHMKKyAqICAtIFNpbXBsaWZ5aW5nIGluaXRpYWxpemF0aW9uIGNvZGUKKyAqICAtIEF2b2lk aW5nIHRoZSBjb2RlIGJpdC1yb3QgcHJvYmxlbQorICoKKyAqIFswXSBnaXQ6Ly9naXQuaXB4ZS5v cmcvaXB4ZS5naXQKKyAqCisgKiBbMV0gaHR0cHM6Ly9naXQua2VybmVsLm9yZy9jZ2l0L2xpbnV4 L2tlcm5lbC9naXQvbWNncm9mL2xpbmtlci10YWJsZXMuZ2l0LworICovCisKKy8qKgorICogRE9D OiBBdm9pZHMgbW9kaWZ5aW5nIGFyY2hpdGVjdHVyZSBsaW5rZXIgc2NyaXB0cworICoKKyAqIExp bmtlciB0YWJsZXMgZW5hYmxlIHlvdSB0byBhdm9pZCBtb2RpZnlpbmcgYXJjaGl0ZWN0dXJlIGxp bmtlciBzY3JpcHRzCisgKiBzaW5jZSBpdCBoYXMgaXRzIGhhcyBleHRlbmRlZCBlYWNoIGNvcmUg TGludXggc2VjdGlvbiB3aXRoIGEgcmVzcGVjdGl2ZQorICogbGlua2VyIHRhYmxlIGVudHJ5IGlu IGBpbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmhgLiBXaGVuIHlvdSBhZGQgbmV3Cisg KiBsaW5rZXIgdGFibGUgZW50cnkgeW91IGFnZ3JlZ2F0ZSB0aGVtIGBpbnRvYCB0aGUgZXhpc3Rp bmcgbGlua2VyIHRhYmxlIGNvcmUKKyAqIHNlY3Rpb24uCisgKi8KKworLyoqCisgKiBET0M6IEhv dyBsaW5rZXIgdGFibGVzIHNpbXBsaWZ5IGluaXRpYWxpemF0aW9uIGNvZGUKKyAqCisgKiBUcmFk aXRpb25hbGx5LCB3ZSB3b3VsZCBpbXBsZW1lbnQgZmVhdHVyZXMgaW4gQyBjb2RlIGFzIGZvbGxv d3M6CisgKgorICogIGZvb19pbml0KCk7CisgKgorICogWW91J2QgdGhlbiBoYXZlIGEgZm9vLmgg d2hpY2ggd291bGQgaGF2ZTo6CisgKgorICogICNpZm5kZWYgQ09ORklHX0ZPTworICogIHN0YXRp YyBpbmxpbmUgdm9pZCBmb29faW5pdCh2b2lkKSB7IH0KKyAqICAjZW5kaWYKKyAqCisgKiBXaXRo IGxpbmtlciB0YWJsZXMgdGhpcyBpcyBubyBsb25nZXIgbmVjZXNzYXJ5IGFzIHlvdXIgaW5pdCBy b3V0aW5lcyB3b3VsZAorICogYmUgaW1wbGljaXQsIHlvdSdkIGluc3RlYWQgY2FsbDoKKyAqCisg KiAgY2FsbF9pbml0X2ZucygpOworICoKKyAqIGNhbGxfaW5pdF9mbnMoKSB3b3VsZCBjYWxsIGFs bCBmdW5jdGlvbnMgcHJlc2VudCBpbiB5b3VyIGluaXQgdGFibGUgYW5kIGlmCisgKiBhbmQgb25s eSBpZiBmb28ubyBnZXRzIGxpbmtlZCBpbiwgdGhlbiBpdHMgaW5pdGlhbGlzYXRpb24gZnVuY3Rp b24gd2lsbCBiZQorICogY2FsbGVkLgorICoKKyAqIFRoZSBsaW5rZXIgc2NyaXB0IHRha2VzIGNh cmUgb2YgYXNzZW1ibGluZyB0aGUgdGFibGVzIGZvciB1cy4gQWxsIG9mIG91cgorICogdGFibGUg c2VjdGlvbnMgaGF2ZSBuYW1lcyBvZiB0aGUgZm9ybWF0IGBTRUNUSU9OX05BTUUuLnRibC5OQU1F Lk5gLiBIZXJlCisgKiBgU0VDVElPTl9OQU1FYCBpcyBvbmUgb2YgdGhlIHN0YW5kYXJkIHNlY3Rp b25zIGluOjoKKyAqCisgKiAgIGluY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAq CisgKiBhbmQgYE5BTUVgIGRlc2lnbmF0ZXMgdGhlIHNwZWNpZmljIHVzZSBjYXNlIGZvciB0aGUg bGlua2VyIHRhYmxlLCB0aGUgdGFibGUuCisgKiBgTmAgaXMgYSBkaWdpdCB1c2VkIHRvIGhlbHAg c29ydCBlbnRyaWVzIGluIHRoZSBzZWN0aW9uLiBgTj1gIChlbXB0eSBzdHJpbmcpCisgKiBpcyBy ZXNlcnZlZCBmb3IgdGhlIHN5bWJvbCBpbmRpY2F0aW5nIGB0YWJsZSBzdGFydGAsIGFuZCBgTj1+ YCBpcyByZXNlcnZlZAorICogZm9yIHRoZSBzeW1ib2wgaW5kaWNhdGluZyBgdGFibGUgZW5kYC4g SW4gb3JkZXIgZm9yIHRoZSBjYWxsX2luaXRfZm5zKCkgdG8KKyAqIHdvcmsgYmVoaW5kIHRoZSBz Y2VuZXMgdGhlIGN1c3RvbSBsaW5rZXIgc2NyaXB0IHdvdWxkIG5lZWQgdG8gZGVmaW5lIHRoZQor ICogYmVnaW5uaW5nIG9mIHRoZSB0YWJsZSwgdGhlIGVuZCBvZiB0aGUgdGFibGUsIGFuZCBpbiBi ZXR3ZWVuIGl0IHNob3VsZCB1c2UKKyAqIGBgU09SVCgpYGAgdG8gZ2l2ZSBvcmRlciB0byB0aGUg c2VjdGlvbi4gVHlwaWNhbGx5IHRoaXMgd291bGQgcmVxdWlyZSBjdXN0b20KKyAqIGxpbmtlciBz Y3JpcHQgbW9kaWZpY2F0aW9ucyBob3dldmVyIHNpbmNlIGxpbmtlciB0YWJsZSBhcmUgYWxyZWFk eSBkZWZpbmVkCisgKiBpbiBgYGluY2x1ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5sZHMuaGBgIGFz IGRvY3VtZW50ZWQgYWJvdmUgZWFjaCBuZXcgbGlua2VyCisgKiB0YWJsZSBkZWZpbml0aW9uIGFk ZGVkIGluIEMgY29kZSBmb2xkcyBpbnRvIHRoZSByZXNwZWN0aXZlIGNvcmUgTGludXgKKyAqIHNl Y3Rpb24gbGlua2VyIHRhYmxlLgorICoKKyAqIFRoaXMgaXMgYWxzbyBkb25lIHRvIHN1cHBvcnQg YWxsIGFyY2hpdGVjdHVyZXMuICBBbGwgdGhhdCBpcyBuZWVkZWQgdGhlbiBpcworICogdG8gZW5z dXJlIGEgcmVzcGVjdGl2ZSBjb21tb24gbGlua2VyIHRhYmxlIGVudHJ5IGlzIGFkZGVkIHRvIHRo ZSBzaGFyZWQKKyAqIGBgaW5jbHVkZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oYGAuICBUaGVy ZSBzaG91bGQgYmUgYSByZXNwZWN0aXZlOjoKKyAqCisgKiAgKihTT1JUKC5mb28uLnRibC4qKSkK KyAqCisgKiBlbnRyeSBmb3IgZWFjaCB0eXBlIG9mIHN1cHBvcnRlZCBzZWN0aW9uIHRoZXJlLiBJ ZiB5b3VyIGBTRUNUSU9OX05BTUVgCisgKiBpcyBub3QgeWV0IHN1cHBvcnRlZCwgY29uc2lkZXIg YWRkaW5nIHN1cHBvcnQgZm9yIGl0LgorICoKKyAqIExpbmtlciB0YWJsZXMgc3VwcG9ydCBvcmRl cmluZyBlbnRyaWVzLCBpdCBkb2VzIHRoaXMgdXNpbmcgYSBkaWdpdCB3aGljaAorICogaXMgZXZl bnR1YWxseSBhZGRlZCBhcyBhIHBvc3RmaXggdG8gYSBzZWN0aW9uIGVudHJ5IG5hbWUsIHdlIHJl ZmVyIHRvIHRoaXMKKyAqIGFzIHRoZSBsaW5rZXIgdGFibGUgYGBvcmRlci1sZXZlbGBgLiBJZiBv cmRlciBpcyBub3QgaW1wb3J0YW50IHRvIHlvdXIKKyAqIGxpbmtlciB0YWJsZSBlbnRyeSB5b3Ug Y2FuIHVzZSB0aGUgc3BlY2lhbCBgYFNFQ1RJT05fT1JERVJfQU5ZYGAuIEFmdGVyCisgKiBgYG9y ZGVyLWxldmVsYGAsIHRoZSBuZXh0IGNvbnRyaWJ1dGluZyBmYWN0b3IgdG8gb3JkZXIgaXMgdGhl IG9yZGVyIG9mIHRoZQorICogY29kZSBpbiB0aGUgQyBmaWxlLCBhbmQgdGhlIG9yZGVyIG9mIHRo ZSBvYmplY3RzIGluIHRoZSBNYWtlZmlsZS4gVXNpbmcgYW4KKyAqIGBgb3JkZXItbGV2ZWxgYCB0 aGVuIHNob3VsZCBub3QgcmVhbGx5IGJlIG5lZWRlZCBpbiBtb3N0IGNhc2VzLCBpdHMgdXNlCisg KiBob3dldmVyIGVuYWJsZXMgdG8gY29tcGFydGFtZW50YWxpemUgY29kZSBpbnRvIHRhYmxlcyB3 aGVyZSBvcmRlcmluZyB0aHJvdWdoCisgKiBDIGZpbGUgb3IgdGhyb3VnaCB0aGUgTWFrZWZpbGUg d291bGQgb3RoZXJ3aXNlIGJlIHZlcnkgZGlmZmljdWx0IG9yIGlmIG9uZQorICogd2FudGVkIHRv IGVuYWJsZSB2ZXJ5IHNwZWNpZmljIGluaXRpYWxpemF0aW9uIHNlbWFudGljcy4KKyAqCisgKiBB cyBhbiBleGFtcGxlLCBzdXBwb3NlIHRoYXQgd2Ugd2FudCB0byBjcmVhdGUgYSAiZnJvYm5pY2F0 b3IiCisgKiBmZWF0dXJlIGZyYW1ld29yaywgYW5kIGFsbG93IGZvciBzZXZlcmFsIGluZGVwZW5k ZW50IG1vZHVsZXMgdG8KKyAqIHByb3ZpZGUgZnJvYm5pY2F0aW5nIHNlcnZpY2VzLiBUaGVuIHdl IHdvdWxkIGNyZWF0ZSBhIGZyb2IuaAorICogaGVhZGVyIGZpbGUgY29udGFpbmluZyBlLmcuOjoK KyAqCisgKglzdHJ1Y3QgZnJvYm5pY2F0b3IgeworICoJCWNvbnN0IGNoYXIgKm5hbWU7CisgKgkJ dm9pZCAoKmZyb2IpICh2b2lkKTsKKyAqCX07CisgKgorICoJREVDTEFSRV9MSU5LVEFCTEUoc3Ry dWN0IGZyb2JuaWNhdG9yLCBmcm9ibmljYXRvcl9mbnMpOworICoKKyAqIEFueSBtb2R1bGUgcHJv dmlkaW5nIGZyb2JuaWNhdGluZyBzZXJ2aWNlcyB3b3VsZCBsb29rIHNvbWV0aGluZworICogbGlr ZTo6CisgKgorICoJI2luY2x1ZGUgImZyb2IuaCIKKyAqCisgKglzdGF0aWMgdm9pZCBteV9mcm9i KHZvaWQpIHsKKyAqCQkuLi4gRG8gbXkgZnJvYm5pY2F0aW5nCisgKgl9CisgKgorICoJTElOS1RB QkxFX0lOSVRfREFUQShmcm9ibmljYXRvcl9mbnMsIGFsbCkgbXlfZnJvYm5pY2F0b3IgPSB7Cisg KgkJLm5hbWUgPSAibXlfZnJvYiIsCisgKgkJLmZyb2IgPSBteV9mcm9iLAorICoJfTsKKyAqCisg KiBUaGUgY2VudHJhbCBmcm9ibmljYXRvciBjb2RlLCBzYXkgaW4gZnJvYi5jLCB3b3VsZCB1c2Ug dGhlIGZyb2JuaWNhdGluZworICogbW9kdWxlcyBhcyBmb2xsb3dzOjoKKyAqCisgKgkjaW5jbHVk ZSAiZnJvYi5oIgorICoKKyAqCXZvaWQgZnJvYl9hbGwodm9pZCkgeworICoJCXN0cnVjdCBmcm9i bmljYXRvciAqZjsKKyAqCisgKgkJbGlua3RhYmxlX2Zvcl9lYWNoKGYsIGZyb2JuaWNhdG9yX2Zu cykgeworICoJCQlwcl9pbmZvKCJDYWxsaW5nIGZyb2JuaWNhdG9yICVzXG4iLCBmcm9iLT5uYW1l KTsKKyAqCQkJZi0+ZnJvYigpOworICoJCX0KKyAqCX0KKyAqLworCisvKioKKyAqIERPQzogTGlu a2VyIHRhYmxlIG1vZHVsZSBzdXBwb3J0CisgKgorICogTW9kdWxlcyBjYW4gdXNlIGxpbmtlciB0 YWJsZXMsIGhvd2V2ZXIgdGhlIGxpbmtlciB0YWJsZSBkZWZpbml0aW9uCisgKiBtdXN0IGJlIGJ1 aWx0LWluIHRvIHRoZSBrZXJuZWwuIFRoYXQgaXMsIHRoZSBjb2RlIHRoYXQgaW1wbGVtZW50cwor ICogYGBERUZJTkVfTElOS1RBQkxFKigpYGAgbXVzdCBiZSBidWlsdC1pbiwgYW5kIG1vZHVsYXIg Y29kZSBjYW5ub3QgYWRkCisgKiBtb3JlIGl0ZW1zIGluIHRvIHRoZSB0YWJsZSwgdW5sZXNzIGBg a2VybmVsL21vZHVsZS5jYGAgZmluZF9tb2R1bGVfc2VjdGlvbnMoKQorICogYW5kIG1vZHVsZS1j b21tb24ubGRzLlMgYXJlIHVwZGF0ZWQgYWNjb3JkaW5nbHkgd2l0aCBhIHJlc3BlY3RpdmUKKyAq IG1vZHVsZSBub3RpZmllciB0byBhY2NvdW50IGZvciB1cGRhdGVzLiBUaGlzIHJlc3RyaWN0aW9u IG1heSBiZSBlbmhhbmNlZAorICogaW4gdGhlIGZ1dHVyZS4KKyAqLworCisvKioKKyAqIERPQzog TGlua2VyIHRhYmxlIGhlbHBlcnMKKyAqCisgKiBUaGVzZSBhcmUgaGVscGVycyBmb3IgbGlua2Vy IHRhYmxlcy4KKyAqLworCisvKioKKyAqIExJTktUQUJMRV9TVEFSVCAtIGdldCBhZGRyZXNzIG9m IHN0YXJ0IG9mIGxpbmtlciB0YWJsZQorICoKKyAqIEBuYW1lOiBuYW1lIG9mIHRoZSBsaW5rZXIg dGFibGUKKyAqCisgKiBUaGlzIGdpdmVzIHlvdSB0aGUgc3RhcnQgYWRkcmVzcyBvZiB0aGUgbGlu a2VyIHRhYmxlLgorICogVGhpcyBzaG91bGQgZ2l2ZSB5b3UgdGhlIGFkZHJlc3Mgb2YgdGhlIGZp cnN0IGVudHJ5LgorICoKKyAqLworI2RlZmluZSBMSU5LVEFCTEVfU1RBUlQobmFtZSkJTElOVVhf U0VDVElPTl9TVEFSVChuYW1lKQorCisvKioKKyAqIExJTktUQUJMRV9FTkQgLSBnZXQgYWRkcmVz cyBvZiBlbmQgb2YgdGhlIGxpbmtlciB0YWJsZQorICoKKyAqIEBuYW1lOiBuYW1lIG9mIHRoZSBs aW5rZXIgdGFibGUKKyAqCisgKiBUaGlzIGdpdmVzIHlvdSB0aGUgZW5kIGFkZHJlc3Mgb2YgdGhl IGxpbmtlciB0YWJsZS4KKyAqIFRoaXMgd2lsbCBtYXRjaCB0aGUgc3RhcnQgYWRkcmVzcyBpZiB0 aGUgbGlua2VyIHRhYmxlCisgKiBpcyBlbXB0eS4KKyAqLworI2RlZmluZSBMSU5LVEFCTEVfRU5E KG5hbWUpCUxJTlVYX1NFQ1RJT05fRU5EKG5hbWUpCisKKy8qKgorICogTElOS1RBQkxFX1NJWkUg LSBnZXQgbnVtYmVyIG9mIGVudHJpZXMgaW4gdGhlIGxpbmtlciB0YWJsZQorICoKKyAqIEBuYW1l OiBuYW1lIG9mIHRoZSBsaW5rZXIgdGFibGUKKyAqCisgKiBUaGlzIGdpdmVzIHlvdSB0aGUgbnVt YmVyIG9mIGVudHJpZXMgaW4gdGhlIGxpbmtlciB0YWJsZS4KKyAqIEV4YW1wbGUgdXNhZ2U6Cisg KgorICogICB1bnNpZ25lZCBpbnQgbnVtX2Zyb2JzID0gTElOS1RBQkxFX1NJWkUoZnJvYm5pY2F0 b3JfZm5zKTsKKyAqLworI2RlZmluZSBMSU5LVEFCTEVfU0laRShuYW1lKQkJCQkJXAorCSgoTElO S1RBQkxFX0VORChuYW1lKSkgLSAoTElOS1RBQkxFX1NUQVJUKG5hbWUpKSkKKworLyoqCisgKiBM SU5LVEFCTEVfRU1QVFkgLSBjaGVjayBpZiBsaW5rZXIgdGFibGUgaGFzIG5vIGVudHJpZXMKKyAq CisgKiBAbmFtZTogbmFtZSBvZiBsaW5rZXIgdGFibGUKKyAqCisgKiBSZXR1cm5zIHRydWUgaWYg dGhlIGxpbmtlciB0YWJsZSBpcyBlbXRweS4KKyAqCisgKiAgIGJvb2wgaXNfZW1wdHkgPSBMSU5L VEFCTEVfRU1QVFkoZnJvYm5pY2F0b3JfZm5zKTsKKyAqLworI2RlZmluZSBMSU5LVEFCTEVfRU1Q VFkobmFtZSkJKExJTktUQUJMRV9TSVpFKG5hbWUpID09IDApCisKKy8qKgorICogTElOS1RBQkxF X0FERFJfV0lUSElOIC0gcmV0dXJucyB0cnVlIGlmIGFkZHJlc3MgaXMgaW4gdGhlIGxpbmtlciB0 YWJsZQorICoKKyAqIEBuYW1lOiBuYW1lIG9mIHRoZSBsaW5rZXIgdGFibGUKKyAqIEBhZGRyOiBh ZGRyZXNzIHRvIHF1ZXJ5IGZvcgorICoKKyAqIFJldHVybnMgdHJ1ZSBpZiB0aGUgYWRkcmVzcyBp cyBwYXJ0IG9mIHRoZSBsaW5rZXIgdGFibGUuCisgKi8KKyNkZWZpbmUgTElOS1RBQkxFX0FERFJf V0lUSElOKG5hbWUsIGFkZHIpCQkJCVwKKwkgKGFkZHIgPj0gKHVuc2lnbmVkIGxvbmcpIExJTktU QUJMRV9TVEFSVChuYW1lKSAmJgkJXAorICAgICAgICAgIGFkZHIgPCAodW5zaWduZWQgbG9uZykg TElOS1RBQkxFX0VORChuYW1lKSkKKworLyoqCisgKiBMSU5LVEFCTEVfQUxJR05NRU5UIC0gZ2V0 IHRoZSBhbGlnbm1lbnQgb2YgdGhlIGxpbmtlciB0YWJsZQorICoKKyAqIEBuYW1lOiBuYW1lIG9m IGxpbmtlciB0YWJsZQorICoKKyAqIEdpdmVzIHlvdSB0aGUgYWxpZ25tZW50IGZvciB0aGUgbGlu a2VyIHRhYmxlLgorICovCisjZGVmaW5lIExJTktUQUJMRV9BTElHTk1FTlQobmFtZSkJTElOVVhf U0VDVElPTl9BTElHTk1FTlQobmFtZSkKKworLyoqCisgKiBET0M6IENvbnN0cnVjdGluZyBsaW5r ZXIgdGFibGVzCisgKgorICogTGlua2VyIHRhYmxlcyBjb25zdHJ1Y3RvcnMgYXJlIHVzZWQgdG8g YnVpbGQgYW4gZW50cnkgaW50byBhIGxpbmtlciB0YWJsZS4KKyAqIExpbmtlciB0YWJsZSBjb25z dHJ1Y3RvcnMgZXhpc3QgZm9yIGVhY2ggdHlwZSBvZiBzdXBwb3J0ZWQgc2VjdGlvbi4KKyAqCisg KiBZb3UgaGF2ZSB3ZWFrIGFuZCByZWd1bGFyIHR5cGUgb2YgbGluayB0YWJsZSBlbnRyeSBjb25z dHJ1Y3RvcnMuCisgKi8KKworLyoqCisgKiBET0M6IFdlYWsgbGlua2VyIHRhYmxlcyBjb25zdHJ1 Y3RvcnMKKyAqCisgKiBUaGUgd2VhayBhdHRyaWJ1dGUgaXMgZGVzaXJhYmxlIGlmIHlvdSB3YW50 IGFuIGVudHJ5IHlvdSBjYW4gcmVwbGFjZSBhdAorICogbGluayB0aW1lLiBBIHZlcnkgc3BlY2lh bCB1c2UgY2FzZSBmb3IgbGlua2VyIHRhYmxlcyBpcyB0aGUgZmlyc3QgZW50cnkuCisgKiBBIHdl YWsgYXR0cmlidXRlIGlzIHVzZWQgZm9yIHRoZSBmaXJzdCBlbnRyeSB0byBlbnN1cmUgdGhhdCB0 aGlzIGVudHJ5J3MKKyAqIGFkZHJlc3MgbWF0Y2hlcyB0aGUgZW5kIGFkZHJlc3Mgb2YgdGhlIHRh YmxlIHdoZW4gdGhlIGxpbmtlciB0YWJsZSBpcworICogZW10cHksIGJ1dCB3aWxsIGFsc28gcG9p bnQgdG8gdGhlIGZpcnN0IHJlYWwgZW50cnkgb2YgdGhlIHRhYmxlIG9uY2Ugbm90CisgKiBlbXB0 eS4gV2hlbiB0aGUgZmlyc3QgZW50cnkgaXMgbGlua2VkIGluLCBpdCB0YWtlcyBwbGFjZSBvZiB0 aGUgZmlyc3QgZW50cnkuCisgKi8KKworLyoqCisgKiBMSU5LVEFCTEVfV0VBSyAtIENvbnN0cnVj dHMgYSB3ZWFrIGxpbmtlciB0YWJsZSBlbnRyeSBmb3IgZGF0YQorICoKKyAqIEBuYW1lOiBsaW5r ZXIgdGFibGUgbmFtZQorICogQGxldmVsOiBvcmRlciBsZXZlbAorICoKKyAqIENvbnN0cnVjdHMg YSB3ZWFrIGxpbmtlciB0YWJsZSBmb3IgZGF0YS4KKyAqLworI2RlZmluZSBMSU5LVEFCTEVfV0VB SyhuYW1lLCBsZXZlbCkJCQkJCVwKKwkgICAgICBfX3R5cGVvZl9fKExJTktUQUJMRV9TVEFSVChu YW1lKVswXSkJCQlcCisJICAgICAgX19hdHRyaWJ1dGVfXygodXNlZCwJCQkJCVwKKwkJCSAgICAg d2VhaywJCQkJCVwKKwkJCSAgICAgX19hbGlnbmVkX18oTElOS1RBQkxFX0FMSUdOTUVOVChuYW1l KSksCVwKKwkJCSAgICAgc2VjdGlvbigiLmRhdGEuLnRibC4iICNuYW1lICIuIiAjbGV2ZWwpKSkK KworLyoqCisgKiBMSU5LVEFCTEVfVEVYVF9XRUFLIC0gQ29uc3RydWN0cyBhIHdlYWsgbGlua2Vy IHRhYmxlIGVudHJ5IGZvciBleGVjdXRpb24KKyAqCisgKiBAbmFtZTogbGlua2VyIHRhYmxlIG5h bWUKKyAqIEBsZXZlbDogb3JkZXIgbGV2ZWwKKyAqCisgKiBDb25zdHJ1Y3RzIGEgd2VhayBsaW5r ZXIgdGFibGUgZm9yIGNvZGUgZXhlY3V0aW9uLiBUaGVzZSB3aWxsIGJlCisgKiByZWFkLW9ubHku CisgKi8KKyNkZWZpbmUgTElOS1RBQkxFX1RFWFRfV0VBSyhuYW1lLCBsZXZlbCkJCQkJXAorCWNv bnN0IF9fdHlwZW9mX18oTElOS1RBQkxFX1NUQVJUKG5hbWUpWzBdKQkJCVwKKwkgICAgICBfX2F0 dHJpYnV0ZV9fKCh1c2VkLAkJCQkJXAorCQkJICAgICB3ZWFrLAkJCQkJXAorCQkJICAgICBfX2Fs aWduZWRfXyhMSU5LVEFCTEVfQUxJR05NRU5UKG5hbWUpKSwJXAorCQkJICAgICBzZWN0aW9uKCIu dGV4dC4udGJsLiIgI25hbWUgIi4iICNsZXZlbCkpKQorCisvKioKKyAqIExJTktUQUJMRV9ST19X RUFLIC0gQ29uc3RydWN0cyBhIHdlYWsgcmVhZC1vbmx5IGxpbmtlciB0YWJsZSBlbnRyeQorICoK KyAqIEBuYW1lOiBsaW5rZXIgdGFibGUgbmFtZQorICogQGxldmVsOiBvcmRlciBsZXZlbAorICoK KyAqIENvbnN0cnVjdHMgYSB3ZWFrIGxpbmtlciB0YWJsZSB3aGljaCBvbmx5IHJlcXVpcmVzIHJl YWQtb25seSBhY2Nlc3MuCisgKi8KKyNkZWZpbmUgTElOS1RBQkxFX1JPX1dFQUsobmFtZSwgbGV2 ZWwpCQkJCQlcCisJY29uc3QgX190eXBlb2ZfXyhMSU5LVEFCTEVfU1RBUlQobmFtZSlbMF0pCQkJ XAorCSAgICAgIF9fYXR0cmlidXRlX18oKHVzZWQsCQkJCQlcCisJCQkgICAgIHdlYWssCQkJCQlc CisJCQkgICAgIF9fYWxpZ25lZF9fKExJTktUQUJMRV9BTElHTk1FTlQobmFtZSkpLAlcCisJCQkg ICAgIHNlY3Rpb24oU0VDVElPTl9UQkxfUk9fU1RSICIuLnRibC4iICNuYW1lICIuIiAjbGV2ZWwp KSkKKworLyoqCisgKiBMSU5LVEFCTEVfSU5JVF9XRUFLIC0gQ29uc3RydWN0cyBhIHdlYWsgbGlu a2VyIHRhYmxlIGVudHJ5IGZvciBpbml0IGNvZGUKKyAqCisgKiBAbmFtZTogbGlua2VyIHRhYmxl IG5hbWUKKyAqIEBsZXZlbDogb3JkZXIgbGV2ZWwKKyAqCisgKiBDb25zdHJ1Y3RzIGEgd2VhayBs aW5rZXIgdGFibGUgZm9yIGV4ZWN1dGlvbi4gdXNlIGF0IGluaXQuCisgKi8KKyNkZWZpbmUgTElO S1RBQkxFX0lOSVRfV0VBSyhuYW1lLCBsZXZlbCkJCQkJXAorCWNvbnN0IF9fdHlwZW9mX18oTElO S1RBQkxFX1NUQVJUKG5hbWUpWzBdKQkJCVwKKwkgICAgICBfX2F0dHJpYnV0ZV9fKCh1c2VkLAkJ CQkJXAorCQkJICAgICB3ZWFrLAkJCQkJXAorCQkJICAgICBfX2FsaWduZWRfXyhMSU5LVEFCTEVf QUxJR05NRU5UKG5hbWUpKSwJXAorCQkJICAgICBzZWN0aW9uKCIuaW5pdC50ZXh0Li50YmwuIiAj bmFtZSAiLiIgI2xldmVsKSkpCisKKy8qKgorICogTElOS1RBQkxFX0lOSVRfREFUQV9XRUFLIC0g Q29uc3RydWN0cyBhIHdlYWsgbGlua2VyIHRhYmxlIGVudHJ5IGZvciBpbml0ZGF0YQorICoKKyAq IEBuYW1lOiBsaW5rZXIgdGFibGUgbmFtZQorICogQGxldmVsOiBvcmRlciBsZXZlbAorICoKKyAq IENvbnN0cnVjdHMgYSB3ZWFrIGxpbmtlciB0YWJsZSBmb3IgZGF0YSBkdXJpbmcgaW5pdC4KKyAq LworI2RlZmluZSBMSU5LVEFCTEVfSU5JVF9EQVRBX1dFQUsobmFtZSwgbGV2ZWwpCQkJCVwKKwkg ICAgICBfX3R5cGVvZl9fKExJTktUQUJMRV9TVEFSVChuYW1lKVswXSkJCQlcCisJICAgICAgX19h dHRyaWJ1dGVfXygodXNlZCwJCQkJCVwKKwkJCSAgICAgd2VhaywJCQkJCVwKKwkJCSAgICAgX19h bGlnbmVkX18oTElOS1RBQkxFX0FMSUdOTUVOVChuYW1lKSksCVwKKwkJCSAgICAgc2VjdGlvbigi LmluaXQuZGF0YS4udGJsLiIgI25hbWUgIi4iICNsZXZlbCkpKQorCisvKioKKyAqIERPQzogUmVn dWxhciBsaW5rZXIgbGlua2VyIHRhYmxlIGNvbnN0cnVjdG9ycworICoKKyAqIFJlZ3VsYXIgY29u c3RydWN0b3JzIGFyZSBleHBlY3RlZCB0byBiZSB1c2VkIGZvciB2YWxpZCBsaW5rZXIgdGFibGUg ZW50cmllcy4KKyAqIFZhbGlkIHVzZXMgb2Ygd2VhayBlbnRyaWVzIG90aGVyIHRoYW4gdGhlIGJl Z2lubmluZyBhbmQgaXMgY3VycmVudGx5CisgKiB1bnRlc3RlZCBidXQgc2hvdWxkIGluIHRoZW9y eSB3b3JrLgorICovCisKKy8qKgorICogTElOS1RBQkxFIC0gRGVjbGFyZXMgYSBkYXRhIGxpbmtl ciB0YWJsZSBlbnRyeQorICoKKyAqIEBuYW1lOiBsaW5rZXIgdGFibGUgbmFtZQorICogQGxldmVs OiBvcmRlciBsZXZlbAorICoKKyAqIERlY2xhcmVzIGEgZGF0YSBsaW5rZXIgdGFibGUgZW50cnku IFRoZXNlIGFyZSByZWFkLXdyaXRlLgorICovCisjZGVmaW5lIExJTktUQUJMRShuYW1lLCBsZXZl bCkJCQkJCQlcCisJICAgICAgX190eXBlb2ZfXyhMSU5LVEFCTEVfU1RBUlQobmFtZSlbMF0pCQkJ XAorCSAgICAgIF9fYXR0cmlidXRlX18oKHVzZWQsCQkJCQlcCisJCQkgICAgIF9fYWxpZ25lZF9f KExJTktUQUJMRV9BTElHTk1FTlQobmFtZSkpLAlcCisJCQkgICAgIHNlY3Rpb24oIi5kYXRhLi50 YmwuIiAjbmFtZSAiLiIgI2xldmVsKSkpCisKKy8qKgorICogTElOS1RBQkxFX1RFWFQgLSBEZWNs YXJlcyBhIGxpbmtlciB0YWJsZSBlbnRyeSBmb3IgZXhlY3V0aW9uCisgKgorICogQG5hbWU6IGxp bmtlciB0YWJsZSBuYW1lCisgKiBAbGV2ZWw6IG9yZGVyIGxldmVsCisgKgorICogRGVjbGFyZXMg YSBsaW5rZXIgdGFibGUgdG8gYmUgdXNlZCBmb3IgZXhlY3V0aW9uLgorICovCisjZGVmaW5lIExJ TktUQUJMRV9URVhUKG5hbWUsIGxldmVsKQkJCQkJXAorCWNvbnN0IF9fdHlwZW9mX18oTElOS1RB QkxFX1NUQVJUKG5hbWUpWzBdKQkJCVwKKwkgICAgICBfX2F0dHJpYnV0ZV9fKCh1c2VkLAkJCQkJ XAorCQkJICAgICBfX2FsaWduZWRfXyhMSU5LVEFCTEVfQUxJR05NRU5UKG5hbWUpKSwJXAorCQkJ ICAgICBzZWN0aW9uKCIudGV4dC4udGJsLiIgI25hbWUgIi4iICNsZXZlbCkpKQorCisvKioKKyAq IExJTktUQUJMRV9STyAtIERlY2xhcmVzIGEgcmVhZC1vbmx5IGxpbmtlciB0YWJsZSBlbnRyeS4K KyAqCisgKiBAbmFtZTogbGlua2VyIHRhYmxlIG5hbWUKKyAqIEBsZXZlbDogb3JkZXIgbGV2ZWwK KyAqCisgKiBEZWNsYXJlcyBhIGxpbmtlciB0YWJsZSB3aGljaCBvbmx5IHJlcXVpcmVzIHJlYWQt b25seSBhY2Nlc3MuIENvbnRyYXJ5CisgKiB0byBMSU5LVEFCTEVfUk9fV0VBSygpIHdoaWNoIHVz ZXMgU0VDVElPTl9ST0RBVEEgdGhpcyBoZWxwZXIgdXNlcyB0aGUKKyAqIHNlY3Rpb24gU0VDVElP Tl9UQkxfUk8gaGVyZSBkdWUgdG8gcG9zc2libGUgdG9vbGNoYWlucyBidWcgb24gc29tZQorICog YXJjaGl0ZWN0dXJlcywgZm9yIGluc3RhbmNlIHRoZSBjNnggYXJjaGl0aWN0dXJlIHN0dWZmcyBu b24td2VhayBkYXRhCisgKiBpbnRvIGRpZmZlcmVudCBzZWN0aW9ucyBvdGhlciB0aGFuIHRoZSBv bmUgaW50ZW5kZWQuCisgKi8KKyNkZWZpbmUgTElOS1RBQkxFX1JPKG5hbWUsIGxldmVsKQkJCQkJ XAorCWNvbnN0IF9fdHlwZW9mX18oTElOS1RBQkxFX1NUQVJUKG5hbWUpWzBdKQkJCVwKKwkgICAg ICBfX2F0dHJpYnV0ZV9fKCh1c2VkLAkJCQkJXAorCQkJICAgICBfX2FsaWduZWRfXyhMSU5LVEFC TEVfQUxJR05NRU5UKG5hbWUpKSwJXAorCQkJICAgICBzZWN0aW9uKFNFQ1RJT05fVEJMX1JPX1NU UiAiLi50YmwuIiAjbmFtZSAiLiIgI2xldmVsKSkpCisKKy8qKgorICogTElOS1RBQkxFX0lOSVQg LSBEZWNsYXJlcyBhIGxpbmtlciB0YWJsZSBlbnRyeSB0byBiZSB1c2VkIG9uIGluaXQuCisgKgor ICogQG5hbWU6IGxpbmtlciB0YWJsZSBuYW1lCisgKiBAbGV2ZWw6IG9yZGVyIGxldmVsCisgKgor ICogRGVjbGFyZXMgYSBsaW5rZXIgdGFibGUgZW50cnkgZm9yIGV4ZWN1dGlvbiB1c2UgZHVyaW5n IGluaXQuCisgKi8KKyNkZWZpbmUgTElOS1RBQkxFX0lOSVQobmFtZSwgbGV2ZWwpCQkJCQlcCisJ Y29uc3QgX190eXBlb2ZfXyhMSU5LVEFCTEVfU1RBUlQobmFtZSlbMF0pCQkJXAorCSAgICAgIF9f YXR0cmlidXRlX18oKHVzZWQsCQkJCQlcCisJCQkgICAgIF9fYWxpZ25lZF9fKExJTktUQUJMRV9B TElHTk1FTlQobmFtZSkpLAlcCisJCQkgICAgIHNlY3Rpb24oIi5pbml0LnRleHQuLnRibC4iICNu YW1lICIuIiAjbGV2ZWwpKSkKKworLyoqCisgKiBMSU5LVEFCTEVfSU5JVF9EQVRBIC0gRGVjbGFy ZXMgYSBsaW5rZXIgdGFibGUgZW50cnkgdG8gYmUgdXNlZCBvbiBpbml0IGRhdGEuCisgKgorICog QG5hbWU6IGxpbmtlciB0YWJsZSBuYW1lCisgKiBAbGV2ZWw6IG9yZGVyIGxldmVsCisgKgorICog RGVjbGFyZXMgYSBsaW5rZXIgdGFibGUgZW50cnkgZm9yIGRhdGEgZHVyaW5nIGluaXQuCisgKi8K KyNkZWZpbmUgTElOS1RBQkxFX0lOSVRfREFUQShuYW1lLCBsZXZlbCkJCQkJXAorCSAgICAgIF9f dHlwZW9mX18oTElOS1RBQkxFX1NUQVJUKG5hbWUpWzBdKQkJCVwKKwkgICAgICBfX2F0dHJpYnV0 ZV9fKCh1c2VkLAkJCQkJXAorCQkJICAgICBfX2FsaWduZWRfXyhMSU5LVEFCTEVfQUxJR05NRU5U KG5hbWUpKSwJXAorCQkJICAgICBzZWN0aW9uKCIuaW5pdC5kYXRhLi50YmwuIiAjbmFtZSAiLiIg I2xldmVsKSkpCisKKy8qKgorICogRE9DOiBEZWNsYXJpbmcgTGlua2VyIHRhYmxlcworICoKKyAq IERlY2xhcmVycyBhcmUgdXNlZCB0byBoZWxwIGNvZGUgYWNjZXNzIHRoZSBsaW5rZXIgdGFibGVz LiBUeXBpY2FsbHkKKyAqIGhlYWRlciBmaWxlcyBmb3Igc3Vic3lzdGVtcyB3b3VsZCBkZWNsYXJl IHRoZSBsaW5rZXIgdGFibGVzIHRvIGVuYWJsZQorICogZWFzeSBhY2Nlc3MgdG8gYWRkIG5ldyBl bnRyaWVzLCBhbmQgdG8gaXRlcmF0ZSBvdmVyIHRoZSBsaXN0IG9mIHRhYmxlLgorICogVGhlcmUg YXJlIG9ubHkgdHdvIGRlY2xhcmVycyBuZWVkZWQgZ2l2ZW4gdGhhdCB0aGUgc2VjdGlvbiBhc3Nv Y2lhdGlvbgorICogaXMgZG9uZSBieSB0aGUgZGVmaW5pdGlvbiBvZiB0aGUgbGlua2VyIHRhYmxl IHVzaW5nIGBgREVGSU5FX0xJTktUQUJMRSooKWBgCisgKiBoZWxwZXJzLgorICovCisKKworLyoq CisgKiBERUNMQVJFX0xJTktUQUJMRSAtIERlY2xhcmVzIGEgZGF0YSBsaW5rZXIgdGFibGUgZW50 cnkKKyAqCisgKiBAdHlwZTogZGF0YSB0eXBlCisgKiBAbmFtZTogdGFibGUgbmFtZQorICoKKyAq IERlY2xhcmVzIGEgZGF0YSBsaW5rZXIgdGFibGUgZW50cnkuCisgKi8KKyNkZWZpbmUgREVDTEFS RV9MSU5LVEFCTEUodHlwZSwgbmFtZSkJCQkJCVwKKwlERUNMQVJFX0xJTlVYX1NFQ1RJT04odHlw ZSwgbmFtZSkKKworLyoqCisgKiBERUNMQVJFX0xJTktUQUJMRV9STyAtIERlY2xhcmVzIGEgcmVh ZC1vbmx5IGxpbmtlciB0YWJsZSBlbnRyeQorICoKKyAqIEB0eXBlOiBkYXRhIHR5cGUKKyAqIEBu YW1lOiB0YWJsZSBuYW1lCisgKgorICogRGVjbGFyZXMgYSByZWFkLW9ubHkgbGlua2VyIHRhYmxl IGVudHJ5LgorICovCisjZGVmaW5lIERFQ0xBUkVfTElOS1RBQkxFX1JPKHR5cGUsIG5hbWUpCQkJ CVwKKwlERUNMQVJFX0xJTlVYX1NFQ1RJT05fUk8odHlwZSwgbmFtZSkKKworLyoqCisgKiBET0M6 IERlZmluaW5nIExpbmtlciB0YWJsZXMKKyAqCisgKiBMaW5rZXIgdGFibGVzIGFyZSBkZWZpbmVk IGluIHRoZSBjb2RlIHRoYXQgdGFrZXMgb3duZXJzaGlwIG92ZXIKKyAqIHRoZSBsaW5rZXIgdGFi bGUuIFRoaXMgaXMgdHlwaWNhbGx5IGRvbmUgaW4gdGhlIHNhbWUgY29kZSB0aGF0IGlzIGluCisg KiBjaGFyZ2Ugb2YgaXRlcmF0aW5nIG92ZXIgdGhlIGxpbmtlciB0YWJsZSBhcyB3ZWxsLgorICov CisKKy8qKgorICogREVGSU5FX0xJTktUQUJMRSAtIERlZmluZXMgYSBsaW5rZXIgdGFibGUgZm9y IGRhdGEKKyAqCisgKiBAdHlwZTogZGF0YSB0eXBlCisgKiBAbmFtZTogdGFibGUgbmFtZQorICoK KyAqIERlZmluZXMgYSBsaW5rZXIgdGFibGUgd2hpY2ggdXNlZCBmb3IgZGF0YS4KKyAqLworI2Rl ZmluZSBERUZJTkVfTElOS1RBQkxFKHR5cGUsIG5hbWUpCQkJCQlcCisJREVDTEFSRV9MSU5LVEFC TEUodHlwZSwgbmFtZSk7CQkJCQlcCisJTElOS1RBQkxFX1dFQUsobmFtZSwpIExJTktUQUJMRV9T VEFSVChuYW1lKVswXSA9IHt9OwkJXAorCUxJTktUQUJMRShuYW1lLCB+KSBMSU5LVEFCTEVfRU5E KG5hbWUpWzBdID0ge30KKworLyoqCisgKiBERUZJTkVfTElOS1RBQkxFX1RFWFQgLSBEZWNsYXJl cyBsaW5rZXIgdGFibGUgZW50cnkgZm9yIGV4ZWN0dWlvbgorICoKKyAqIEB0eXBlOiBkYXRhIHR5 cGUKKyAqIEBuYW1lOiB0YWJsZSBuYW1lCisgKgorICogRGVjbGFyZXMgYSBsaW5rZXIgdGFibGUg ZW50cnkgZm9yIGV4ZWN1dGlvbi4KKyAqLworI2RlZmluZSBERUZJTkVfTElOS1RBQkxFX1RFWFQo dHlwZSwgbmFtZSkJCQkJXAorCURFQ0xBUkVfTElOS1RBQkxFX1JPKHR5cGUsIG5hbWUpOwkJCQlc CisJTElOS1RBQkxFX1RFWFRfV0VBSyhuYW1lLCkgTElOS1RBQkxFX1NUQVJUKG5hbWUpWzBdID0g e307CVwKKwlMSU5LVEFCTEVfVEVYVChuYW1lLCB+KSBMSU5LVEFCTEVfRU5EKG5hbWUpWzBdID0g e30KKworLyoqCisgKiBERUZJTkVfTElOS1RBQkxFX1JPIC0gRGVmaW5lcyBhIHJlYWQtb25seSBs aW5rZXIgdGFibGUKKyAqCisgKiBAdHlwZTogZGF0YSB0eXBlCisgKiBAbmFtZTogdGFibGUgbmFt ZQorICoKKyAqIERlZmluZXMgYSBsaW5rZXIgdGFibGUgd2hpY2ggd2Uga25vdyBvbmx5IHJlcXVp cmVzIHJlYWQtb25seSBhY2Nlc3MuCisgKi8KKyNkZWZpbmUgREVGSU5FX0xJTktUQUJMRV9STyh0 eXBlLCBuYW1lKQkJCQkJXAorCURFQ0xBUkVfTElOS1RBQkxFX1JPKHR5cGUsIG5hbWUpOwkJCQlc CisJTElOS1RBQkxFX1JPX1dFQUsobmFtZSwpIExJTktUQUJMRV9TVEFSVChuYW1lKVswXSA9IHt9 OwkJXAorCUxJTktUQUJMRV9STyhuYW1lLCB+KSBMSU5LVEFCTEVfRU5EKG5hbWUpWzBdID0ge30K KworLyoqCisgKiBERUZJTkVfTElOS1RBQkxFX0lOSVQgLSBEZWZpbmVzIGFuIGluaXQgdGltZSBs aW5rZXIgdGFibGUgZm9yIGV4ZWN1dGlvbgorICoKKyAqIEB0eXBlOiBkYXRhIHR5cGUKKyAqIEBu YW1lOiB0YWJsZSBuYW1lCisgKgorICogRGVmaW5lcyBhIGxpbmtlciB0YWJsZS4gSWYgeW91IGFy ZSBhZGRpbmcgYSBuZXcgdHlwZSB5b3Ugc2hvdWxkCisgKiBlbmFibGUgYGBDT05GSUdfREVCVUdf U0VDVElPTl9NSVNNQVRDSGBgIGFuZCBlbnN1cmUgcm91dGluZXMgdGhhdCBtYWtlCisgKiB1c2Ug b2YgdGhlIGxpbmtlciB0YWJsZXMgZ2V0IGEgcmVzcGVjdGl2ZSBfX3JlZiB0YWcuCisgKi8KKyNk ZWZpbmUgREVGSU5FX0xJTktUQUJMRV9JTklUKHR5cGUsIG5hbWUpCQkJCVwKKwlERUNMQVJFX0xJ TktUQUJMRV9STyh0eXBlLCBuYW1lKTsJCQkJXAorCUxJTktUQUJMRV9JTklUX1dFQUsobmFtZSwp IExJTktUQUJMRV9TVEFSVChuYW1lKVswXSA9IHt9OwlcCisJTElOS1RBQkxFX0lOSVQobmFtZSwg fikgTElOS1RBQkxFX0VORChuYW1lKVswXSA9IHt9CisKKy8qKgorICogREVGSU5FX0xJTktUQUJM RV9JTklUX0RBVEEgLSBEZWZpbmVzIGFuIGluaXQgdGltZSBsaW5rZXIgdGFibGUgZm9yIGRhdGEK KyAqCisgKiBAdHlwZTogZGF0YSB0eXBlCisgKiBAbmFtZTogdGFibGUgbmFtZQorICoKKyAqIERl ZmluZXMgYSBsaW5rZXIgdGFibGUgZm9yIGluaXQgZGF0YS4gSWYgeW91IGFyZSBhZGRpbmcgYSBu ZXcgdHlwZSB5b3UKKyAqIHNob3VsZCBlbmFibGUgYGBDT05GSUdfREVCVUdfU0VDVElPTl9NSVNN QVRDSGBgIGFuZCBlbnN1cmUgcm91dGluZXMgdGhhdAorICogbWFrZSB1c2Ugb2YgdGhlIGxpbmtl ciB0YWJsZXMgZ2V0IGEgcmVzcGVjdGl2ZSBfX3JlZiB0YWcuCisgKi8KKyNkZWZpbmUgREVGSU5F X0xJTktUQUJMRV9JTklUX0RBVEEodHlwZSwgbmFtZSkJCQkJXAorCURFQ0xBUkVfTElOS1RBQkxF KHR5cGUsIG5hbWUpOwkJCQkJXAorCUxJTktUQUJMRV9JTklUX0RBVEFfV0VBSyhuYW1lLCkgTElO S1RBQkxFX1NUQVJUKG5hbWUpWzBdID0ge307CVwKKwlMSU5LVEFCTEVfSU5JVF9EQVRBKG5hbWUs IH4pIExJTktUQUJMRV9FTkQobmFtZSlbMF0gPSB7fQorCisvKioKKyAqIERPQzogSXRlcmF0aW5n IG92ZXIgTGlua2VyIHRhYmxlcworICoKKyAqIFRvIG1ha2UgdXNlIG9mIHRoZSBsaW5rZXIgdGFi bGVzIHlvdSB3YW50IHRvIGJlIGFibGUgdG8gaXRlcmF0ZSBvdmVyCisgKiB0aGVtLiBUaGlzIHNl Y3Rpb24gZG9jdW1lbnRzIHRoZSBkaWZmZXJlbnQgaXRlcmF0b3JzIGF2YWlsYWJsZS4KKyAqLwor CisvKioKKyAqIGxpbmt0YWJsZV9mb3JfZWFjaCAtIGl0ZXJhdGUgdGhyb3VnaCBhbGwgZW50cmll cyB3aXRoaW4gYSBsaW5rZXIgdGFibGUKKyAqCisgKiBAcG9pbnRlcjogZW50cnkgcG9pbnRlcgor ICogQHRibDogbGlua2VyIHRhYmxlCisgKgorICogRXhhbXBsZSB1c2FnZTo6CisgKgorICogICBz dHJ1Y3QgZnJvYm5pY2F0b3IgKmZyb2I7CisgKgorICogICBsaW5rdGFibGVfZm9yX2VhY2goZnJv YiwgZnJvYm5pY2F0b3JfZm5zKSB7CisgKiAgICAgLi4uCisgKiAgIH0KKyAqLworCisjZGVmaW5l IGxpbmt0YWJsZV9mb3JfZWFjaChwb2ludGVyLCB0YmwpCQkJCVwKKwlmb3IgKHBvaW50ZXIgPSBM SU5LVEFCTEVfU1RBUlQodGJsKTsJCQkJXAorCSAgICAgcG9pbnRlciA8IExJTktUQUJMRV9FTkQo dGJsKTsJCQkJXAorCSAgICAgcG9pbnRlcisrKQorCisvKioKKyAqIGxpbmt0YWJsZV9ydW5fYWxs IC0gaXRlcmF0ZSBhbmQgcnVuIHRocm91Z2ggYWxsIGVudHJpZXMgb24gYSBsaW5rZXIgdGFibGUK KyAqCisgKiBAdGJsOiBsaW5rZXIgdGFibGUKKyAqIEBmdW5jOiBzdHJ1Y3R1cmUgbmFtZSBmb3Ig dGhlIGZ1bmN0aW9uIG5hbWUgd2Ugd2FudCB0byBjYWxsLgorICogQGFyZ3MuLi46IGFyZ3VtZW50 cyB0byBwYXNzIHRvIGZ1bmMKKyAqCisgKiBFeGFtcGxlIHVzYWdlOjoKKyAqCisgKiAgIGxpbmt0 YWJsZV9ydW5fYWxsKGZyb2JuaWNhdG9yX2Zucywgc29tZV9ydW4sKTsKKyAqLworI2RlZmluZSBs aW5rdGFibGVfcnVuX2FsbCh0YmwsIGZ1bmMsIGFyZ3MuLi4pCQkJCVwKK2RvIHsJCQkJCQkJCQlc CisJc2l6ZV90IGk7CQkJCQkJCVwKKwlmb3IgKGkgPSAwOyBpIDwgTElOS1RBQkxFX1NJWkUodGJs KTsgaSsrKQkJCVwKKwkJKExJTktUQUJMRV9TVEFSVCh0YmwpW2ldKS5mdW5jIChhcmdzKTsJCQlc Cit9IHdoaWxlICgwKQorCisvKioKKyAqIGxpbmt0YWJsZV9ydW5fZXJyIC0gcnVuIGVhY2ggbGlu a2VyIHRhYmxlIGVudHJ5IGZ1bmMgYW5kIHJldHVybiBlcnJvciBpZiBhbnkKKyAqCisgKiBAdGJs OiBsaW5rZXIgdGFibGUKKyAqIEBmdW5jOiBzdHJ1Y3R1cmUgbmFtZSBmb3IgdGhlIGZ1bmN0aW9u IG5hbWUgd2Ugd2FudCB0byBjYWxsLgorICogQGFyZ3MuLi46IGFyZ3VtZW50cyB0byBwYXNzIHRv IGZ1bmMKKyAqCisgKiBFeGFtcGxlIHVzYWdlOjoKKyAqCisgKiAgIHVuc2lnbmVkIGludCBlcnIg PSBsaW5rdGFibGVfcnVuX2Vycihmcm9ibmljYXRvcl9mbnMsIHNvbWVfcnVuLCk7CisgKi8KKyNk ZWZpbmUgbGlua3RhYmxlX3J1bl9lcnIodGJsLCBmdW5jLCBhcmdzLi4uKQkJCQlcCisoewkJCQkJ CQkJCVwKKwlzaXplX3QgaTsJCQkJCQkJXAorCWludCBlcnIgPSAwOwkJCQkJCQlcCisJZm9yIChp ID0gMDsgIWVyciAmJiBpIDwgTElOS1RBQkxFX1NJWkUodGJsKTsgaSsrKQkJXAorCQllcnIgPSAo TElOS1RBQkxFX1NUQVJUKHRibClbaV0pLmZ1bmMgKGFyZ3MpOwkJXAorCWVycjsJCQkJCQkJCVwK K30pCisKKyNlbmRpZiAvKiBfX0FTU0VNQkxZX18gKi8KKworI2VuZGlmIC8qIF9MSU5VWF9MSU5L RVJfVEFCTEVTX0ggKi8KLS0gCjIuMTEuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3Rz Lnhlbi5vcmcKaHR0cHM6Ly9saXN0cy54ZW4ub3JnL3hlbi1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.kernel.org ([198.145.29.136]:52270 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S968087AbdAIO7K (ORCPT ); Mon, 9 Jan 2017 09:59:10 -0500 From: "Luis R. Rodriguez" Subject: [PATCH v6 04/14] tables.h: add linker table support Date: Mon, 9 Jan 2017 06:58:22 -0800 Message-Id: <20170109145833.11502-5-mcgrof@kernel.org> In-Reply-To: <20170109145833.11502-1-mcgrof@kernel.org> References: <20161222023811.21246-1-mcgrof@kernel.org> <20170109145833.11502-1-mcgrof@kernel.org> Sender: linux-kbuild-owner@vger.kernel.org List-ID: To: hpa@zytor.com, acme@redhat.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, npiggin@gmail.com, 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, dalias@libc.org, linux@arm.linux.org.uk Cc: x86@kernel.org, luto@amacapital.net, keescook@chromium.org, linux@roeck-us.net, 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, 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, jolsa@kernel.org, msalter@redhat.com, chris@zankel.net, jcmvbkbc@gmail.com, linux-xtensa@linux-xtensa.org, adrian.hunter@intel.com, dsahern@gmail.com, namhyung@kernel.org, wangnan0@huawei.com, dmitry.torokhov@gmail.com, joro@8bytes.org, paulus@samba.org, mpe@ellerman.id.au, James.Bottomley@HansenPartnership.com, "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. v6: o rename tables macro as requested by Andy Shevchenko v5: o Use ..tbl.* instead of .tbl.* as suggested by Nicholas Piggin. This is the typical way to avoid clashes with compiler generated sections. o Replace section macros with section names o Dropped SECTION_RNG_ALL() o Fix documentation typos o To make this easier to read, as per Nicholas Piggin, add our own LINKTABLE_START(), LINKTABLE_END(). After reviewing the changes affected by this it seemed clearer and better then to also use our own specific LINKTABLE_SIZE(), LINKTABLE_EMPTY() and LINKTABLE_ALIGNMENT() as well. o Clarifies SECTION_TBL_RO needs to be kept since some toolchains are buggy, and so we also add SECTION_TBL_RO_STR. o We were using LINUX_SECTION_START() and LINUX_SECTION_END() in some places but in some other places VMLINUX_SYMBOL(name), VMLINUX_SYMBOL(name##__end). Since we are adding LINKTABLE_START() and LINKTABLE_END() just use those consistently. o Fix DEFINE_LINKTABLE_INIT() by making it use DECLARE_LINKTABLE_RO() which forces const. o Fix powerpc .text use: it does not use TEXT_TEXT so we must add our *(SORT(.text.tbl.*)) to its linker script manually. 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 | 212 +++++++++++ MAINTAINERS | 10 + 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/powerpc/kernel/vmlinux.lds.S | 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/tables.h | 48 +++ include/asm-generic/vmlinux.lds.h | 6 + include/linux/tables.h | 612 +++++++++++++++++++++++++++++++ 39 files changed, 948 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 4a1df389fa91..7c7c1adf955c 100644 --- a/Documentation/sections/index.rst +++ b/Documentation/sections/index.rst @@ -16,3 +16,4 @@ common a set of Linux helpers for ELF sections are also documented. background 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..780a292d2d00 --- /dev/null +++ b/Documentation/sections/linker-tables.rst @@ -0,0 +1,212 @@ +=================== +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_START +--------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_START + +LINKTABLE_END +------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_END + +LINKTABLE_SIZE +-------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_SIZE + +LINKTABLE_EMPTY +--------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_EMPTY + +LINKTABLE_ADDR_WITHIN +--------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_ADDR_WITHIN + +LINKTABLE_ALIGNMENT +------------------- +.. kernel-doc:: include/linux/tables.h + :functions: LINKTABLE_ALIGNMENT + +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 c96ca032c276..bbf519da3a78 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -5407,6 +5407,16 @@ 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 +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 a374b7f83888..ccfa69ce2608 100644 --- a/arch/arc/include/asm/Kbuild +++ b/arch/arc/include/asm/Kbuild @@ -53,3 +53,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 0d47f98ccbc0..b70d4b78d577 100644 --- a/arch/arm/include/asm/Kbuild +++ b/arch/arm/include/asm/Kbuild @@ -43,3 +43,4 @@ generated-y += mach-types.h generated-y += unistd-nr.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 e9939cbd9067..0c1e781ab10b 100644 --- a/arch/arm64/include/asm/Kbuild +++ b/arch/arm64/include/asm/Kbuild @@ -47,3 +47,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 3428415b1996..9115b215fc7e 100644 --- a/arch/blackfin/include/asm/Kbuild +++ b/arch/blackfin/include/asm/Kbuild @@ -49,3 +49,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..90a0d3df35c8 --- /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 weak 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 006e2863ad37..c28bcdecc764 100644 --- a/arch/m68k/include/asm/Kbuild +++ b/arch/m68k/include/asm/Kbuild @@ -36,3 +36,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 4a8471434a3e..c836f7e2a5e7 100644 --- a/arch/metag/include/asm/Kbuild +++ b/arch/metag/include/asm/Kbuild @@ -57,3 +57,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 e844d6058248..db9dff9c1535 100644 --- a/arch/mips/include/asm/Kbuild +++ b/arch/mips/include/asm/Kbuild @@ -23,3 +23,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 f11d1249738f..aaae8a9f6099 100644 --- a/arch/parisc/include/asm/Kbuild +++ b/arch/parisc/include/asm/Kbuild @@ -30,3 +30,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 60d8349241a7..7c06627a0a0d 100644 --- a/arch/powerpc/include/asm/Kbuild +++ b/arch/powerpc/include/asm/Kbuild @@ -10,3 +10,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/powerpc/kernel/vmlinux.lds.S b/arch/powerpc/kernel/vmlinux.lds.S index fcfc9d102348..8cd940c72895 100644 --- a/arch/powerpc/kernel/vmlinux.lds.S +++ b/arch/powerpc/kernel/vmlinux.lds.S @@ -108,6 +108,7 @@ SECTIONS /* careful! __ftr_alt_* sections need to be close to .text */ *(.text .fixup __ftr_alt_* .ref.text) *(SORT(.text.rng.*)) + *(SORT(.text..tbl.*)) SCHED_TEXT CPUIDLE_TEXT LOCK_TEXT diff --git a/arch/s390/include/asm/Kbuild b/arch/s390/include/asm/Kbuild index c1b85a361e5d..96dd69931427 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 28280887ac79..23a2216f4146 100644 --- a/arch/sparc/include/asm/Kbuild +++ b/arch/sparc/include/asm/Kbuild @@ -23,3 +23,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 33f7069763ae..a599f6f4ee0a 100644 --- a/arch/tile/include/asm/Kbuild +++ b/arch/tile/include/asm/Kbuild @@ -42,3 +42,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 b952dcb3e216..d2867aa09e23 100644 --- a/arch/um/include/asm/Kbuild +++ b/arch/um/include/asm/Kbuild @@ -28,3 +28,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 93abbfdab543..6671a1f08ead 100644 --- a/arch/unicore32/include/asm/Kbuild +++ b/arch/unicore32/include/asm/Kbuild @@ -62,3 +62,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 f672f2fc181d..4cb511f1067c 100644 --- a/arch/x86/include/asm/Kbuild +++ b/arch/x86/include/asm/Kbuild @@ -14,3 +14,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 f96fa2ddf7c9..484a24c309fb 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 2b7fe48c0225..7b41f32a2ba0 100644 --- a/arch/xtensa/include/asm/Kbuild +++ b/arch/xtensa/include/asm/Kbuild @@ -34,3 +34,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/tables.h b/include/asm-generic/tables.h new file mode 100644 index 000000000000..16ef40d145fb --- /dev/null +++ b/include/asm-generic/tables.h @@ -0,0 +1,48 @@ +#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..tbl.name.level + +/* Some toolchains are buggy, let them override */ +#ifndef SECTION_TBL_RO +# define SECTION_TBL_RO .rodata +#endif + +#define SECTION_TBL_RO_STR __stringify(SECTION_TBL_RO) + +#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, 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, 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 71bfd3b3c719..ce1e9a310ada 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) @@ -207,6 +208,7 @@ #define DATA_DATA \ *(.data .data.[0-9a-zA-Z_]*) \ *(SORT(.data..rng.*)) \ + *(SORT(.data..tbl.*)) \ *(.ref.data) \ *(.data..shared_aligned) /* percpu related */ \ MEM_KEEP(init.data) \ @@ -277,6 +279,7 @@ VMLINUX_SYMBOL(__start_rodata) = .; \ *(.rodata) \ *(SORT(.rodata..rng.*)) \ + *(SORT(.rodata..tbl.*)) \ *(.rodata.*) \ RO_AFTER_INIT_DATA /* Read only after init */ \ KEEP(*(__vermagic)) /* Kernel version magic */ \ @@ -452,6 +455,7 @@ ALIGN_FUNCTION(); \ *(.text.hot .text) \ *(SORT(.text..rng.*)) \ + *(SORT(.text..tbl.*)) \ *(.text.fixup .text.unlikely) \ *(.ref.text) \ MEM_KEEP(init.text) \ @@ -556,6 +560,7 @@ KEEP(*(SORT(___kentry+*))) \ *(.init.data) \ *(SORT(.init.data..rng.*)) \ + *(SORT(.init.data..tbl.*)) \ MEM_DISCARD(init.data) \ KERNEL_CTORS() \ MCOUNT_REC() \ @@ -580,6 +585,7 @@ #define INIT_TEXT \ *(.init.text) \ *(SORT(.init.text..rng.*)) \ + *(SORT(.init.text..tbl.*)) \ *(.text.startup) \ MEM_DISCARD(init.text) diff --git a/include/linux/tables.h b/include/linux/tables.h new file mode 100644 index 000000000000..1a1838d51951 --- /dev/null +++ b/include/linux/tables.h @@ -0,0 +1,612 @@ +#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(.foo..tbl.*)) + * + * 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_START - get address of start of linker table + * + * @name: name of the linker table + * + * This gives you the start address of the linker table. + * This should give you the address of the first entry. + * + */ +#define LINKTABLE_START(name) LINUX_SECTION_START(name) + +/** + * LINKTABLE_END - get address of end of the linker table + * + * @name: name of the linker table + * + * This gives you the end address of the linker table. + * This will match the start address if the linker table + * is empty. + */ +#define LINKTABLE_END(name) LINUX_SECTION_END(name) + +/** + * LINKTABLE_SIZE - get number of entries in the linker table + * + * @name: name of the linker table + * + * This gives you the number of entries in the linker table. + * Example usage: + * + * unsigned int num_frobs = LINKTABLE_SIZE(frobnicator_fns); + */ +#define LINKTABLE_SIZE(name) \ + ((LINKTABLE_END(name)) - (LINKTABLE_START(name))) + +/** + * LINKTABLE_EMPTY - check if linker table has no entries + * + * @name: name of linker table + * + * Returns true if the linker table is emtpy. + * + * bool is_empty = LINKTABLE_EMPTY(frobnicator_fns); + */ +#define LINKTABLE_EMPTY(name) (LINKTABLE_SIZE(name) == 0) + +/** + * LINKTABLE_ADDR_WITHIN - returns true if address is in the linker table + * + * @name: name of the linker table + * @addr: address to query for + * + * Returns true if the address is part of the linker table. + */ +#define LINKTABLE_ADDR_WITHIN(name, addr) \ + (addr >= (unsigned long) LINKTABLE_START(name) && \ + addr < (unsigned long) LINKTABLE_END(name)) + +/** + * LINKTABLE_ALIGNMENT - get the alignment of the linker table + * + * @name: name of linker table + * + * Gives you the alignment for the linker table. + */ +#define LINKTABLE_ALIGNMENT(name) LINUX_SECTION_ALIGNMENT(name) + +/** + * 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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".data..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".text..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(SECTION_TBL_RO_STR "..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".init.text..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".init.data..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".data..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".text..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(SECTION_TBL_RO_STR "..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".init.text..tbl." #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__(LINKTABLE_START(name)[0]) \ + __attribute__((used, \ + __aligned__(LINKTABLE_ALIGNMENT(name)), \ + section(".init.data..tbl." #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,) LINKTABLE_START(name)[0] = {}; \ + LINKTABLE(name, ~) LINKTABLE_END(name)[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,) LINKTABLE_START(name)[0] = {}; \ + LINKTABLE_TEXT(name, ~) LINKTABLE_END(name)[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,) LINKTABLE_START(name)[0] = {}; \ + LINKTABLE_RO(name, ~) LINKTABLE_END(name)[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_RO(type, name); \ + LINKTABLE_INIT_WEAK(name,) LINKTABLE_START(name)[0] = {}; \ + LINKTABLE_INIT(name, ~) LINKTABLE_END(name)[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,) LINKTABLE_START(name)[0] = {}; \ + LINKTABLE_INIT_DATA(name, ~) LINKTABLE_END(name)[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 = LINKTABLE_START(tbl); \ + pointer < LINKTABLE_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 < LINKTABLE_SIZE(tbl); i++) \ + (LINKTABLE_START(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 < LINKTABLE_SIZE(tbl); i++) \ + err = (LINKTABLE_START(tbl)[i]).func (args); \ + err; \ +}) + +#endif /* __ASSEMBLY__ */ + +#endif /* _LINUX_LINKER_TABLES_H */ -- 2.11.0