From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jessica Yu Subject: Re: [PATCH 2/6] module: add support for symbol namespaces. Date: Wed, 25 Jul 2018 17:55:07 +0200 Message-ID: <20180725155507.umb5oatduquxwlmt@linux-8ccs> References: <20180716122125.175792-1-maco@android.com> <20180716122125.175792-3-maco@android.com> Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii; format=flowed Return-path: Content-Disposition: inline In-Reply-To: Sender: linux-kernel-owner@vger.kernel.org To: Martijn Coenen Cc: LKML , Masahiro Yamada , Michal Marek , Geert Uytterhoeven , Thomas Gleixner , Ingo Molnar , "H. Peter Anvin" , the arch/x86 maintainers , Alan Stern , Greg Kroah-Hartman , Oliver Neukum , Arnd Bergmann , Stephen Boyd , Philippe Ombredanne , Kate Stewart , Sam Ravnborg , linux-kbuild@vger.kernel.org, linux-m68k , USB list USB List-Id: linux-arch.vger.kernel.org +++ Martijn Coenen [24/07/18 09:56 +0200]: >I did find an issue with my approach: > >On Mon, Jul 16, 2018 at 2:21 PM, Martijn Coenen wrote: >> The ELF symbols are renamed to include the namespace with an asm label; >> for example, symbol 'usb_stor_suspend' in namespace USB_STORAGE becomes >> 'usb_stor_suspend.USB_STORAGE'. This allows modpost to do namespace >> checking, without having to go through all the effort of parsing ELF and >> reloction records just to get to the struct kernel_symbols. > >depmod doesn't like this: if namespaced symbols are built-in to the >kernel, they will appear as 'symbol.NS' in the symbol table, whereas >modules using those symbols just depend on 'symbol'. This will cause >depmod to warn about unknown symbols. I didn't find this previously >because all the exports/imports I tested were done from modules >themselves. > >One way to deal with it is to change depmod, but it looks like it >hasn't been changed in ages, and it would also introduce a dependency >on userspaces to update it to avoid these warnings. So, we'd have to >encode the symbol namespace information in another way for modpost to >use. I could just write a separate post-processing tool (much like >genksyms), or perhaps encode the information in a discardable section. >Any other suggestions welcome. This seems to be because depmod uses System.map as a source for kernel symbols and scans for only the ones prefixed with "__ksymtab" to find the exported ones - and those happen to use the '.' to mark the namespace it belongs to. It strips that prefix and uses the remainder as the actual symbol name. To fix that it'd have to strip the namespace suffix in the symbol name as well. Just scanning the depmod source code, it seems really trivial to just have depmod accommodate the new symbol name format. Adding Lucas (kmod maintainer) to CC. Thanks, Jessica > >> >> On x86_64 I saw no difference in binary size (compression), but at >> runtime this will require a word of memory per export to hold the >> namespace. An alternative could be to store namespaced symbols in their >> own section and use a separate 'struct namespaced_kernel_symbol' for >> that section, at the cost of making the module loader more complex. >> >> Signed-off-by: Martijn Coenen >> --- >> include/asm-generic/export.h | 2 +- >> include/linux/export.h | 83 +++++++++++++++++++++++++++--------- >> include/linux/module.h | 13 ++++++ >> kernel/module.c | 79 ++++++++++++++++++++++++++++++++++ >> 4 files changed, 156 insertions(+), 21 deletions(-) >> >> diff --git a/include/asm-generic/export.h b/include/asm-generic/export.h >> index 68efb950a918..4c3d1afb702f 100644 >> --- a/include/asm-generic/export.h >> +++ b/include/asm-generic/export.h >> @@ -29,7 +29,7 @@ >> .section ___ksymtab\sec+\name,"a" >> .balign KSYM_ALIGN >> __ksymtab_\name: >> - __put \val, __kstrtab_\name >> + __put \val, __kstrtab_\name, 0 >> .previous >> .section __ksymtab_strings,"a" >> __kstrtab_\name: >> diff --git a/include/linux/export.h b/include/linux/export.h >> index ad6b8e697b27..9f6e70eeb85f 100644 >> --- a/include/linux/export.h >> +++ b/include/linux/export.h >> @@ -22,6 +22,11 @@ struct kernel_symbol >> { >> unsigned long value; >> const char *name; >> + const char *namespace; >> +}; >> + >> +struct namespace_import { >> + const char *namespace; >> }; >> >> #ifdef MODULE >> @@ -54,18 +59,28 @@ extern struct module __this_module; >> #define __CRC_SYMBOL(sym, sec) >> #endif >> >> +#define NS_SEPARATOR "." >> + >> +#define MODULE_IMPORT_NS(ns) \ >> + static const struct namespace_import __knsimport_##ns \ >> + asm("__knsimport_" #ns) \ >> + __attribute__((section("__knsimport"), used)) \ >> + = { #ns } >> + >> /* For every exported symbol, place a struct in the __ksymtab section */ >> -#define ___EXPORT_SYMBOL(sym, sec) \ >> +#define ___EXPORT_SYMBOL(sym, sec, ns, nspost, nspost2) \ >> extern typeof(sym) sym; \ >> __CRC_SYMBOL(sym, sec) \ >> - static const char __kstrtab_##sym[] \ >> + static const char __kstrtab_##sym##nspost[] \ >> __attribute__((section("__ksymtab_strings"), aligned(1))) \ >> = #sym; \ >> - static const struct kernel_symbol __ksymtab_##sym \ >> + static const struct kernel_symbol __ksymtab_##sym##nspost \ >> + asm("__ksymtab_" #sym nspost2) \ >> __used \ >> - __attribute__((section("___ksymtab" sec "+" #sym), used)) \ >> + __attribute__((section("___ksymtab" sec "+" #sym #nspost))) \ >> + __attribute__((used)) \ >> __attribute__((aligned(sizeof(void *)))) \ >> - = { (unsigned long)&sym, __kstrtab_##sym } >> + = { (unsigned long)&sym, __kstrtab_##sym##nspost, ns } >> >> #if defined(__KSYM_DEPS__) >> >> @@ -76,52 +91,80 @@ extern struct module __this_module; >> * system filters out from the preprocessor output (see ksym_dep_filter >> * in scripts/Kbuild.include). >> */ >> -#define __EXPORT_SYMBOL(sym, sec) === __KSYM_##sym === >> +#define __EXPORT_SYMBOL(sym, sec, ns, nspost, nspost2) === __KSYM_##sym === >> >> #elif defined(CONFIG_TRIM_UNUSED_KSYMS) >> >> #include >> >> -#define __EXPORT_SYMBOL(sym, sec) \ >> - __cond_export_sym(sym, sec, __is_defined(__KSYM_##sym)) >> -#define __cond_export_sym(sym, sec, conf) \ >> - ___cond_export_sym(sym, sec, conf) >> -#define ___cond_export_sym(sym, sec, enabled) \ >> - __cond_export_sym_##enabled(sym, sec) >> -#define __cond_export_sym_1(sym, sec) ___EXPORT_SYMBOL(sym, sec) >> -#define __cond_export_sym_0(sym, sec) /* nothing */ >> +#define __EXPORT_SYMBOL(sym, sec, ns, nspost, nspost2) \ >> + __cond_export_sym(sym, sec, ns, nspost, nspost2, \ >> + __is_defined(__KSYM_##sym)) >> +#define __cond_export_sym(sym, sec, ns, nspost, nspost2, conf) \ >> + ___cond_export_sym(sym, sec, ns, nspost, nspost2, conf) >> +#define ___cond_export_sym(sym, sec, ns, nspost, nspost2, enabled) \ >> + __cond_export_sym_##enabled(sym, sec, ns, nspost, nspost2) >> +#define __cond_export_sym_1(sym, sec, ns, nspost, nspost2) \ >> + ___EXPORT_SYMBOL(sym, sec, ns, nspost, nspost2) >> +#define __cond_export_sym_0(sym, sec, ns, nspost, nspost2) /* nothing */ >> >> #else >> #define __EXPORT_SYMBOL ___EXPORT_SYMBOL >> #endif >> >> #define EXPORT_SYMBOL(sym) \ >> - __EXPORT_SYMBOL(sym, "") >> + __EXPORT_SYMBOL(sym, "", NULL, ,) >> >> #define EXPORT_SYMBOL_GPL(sym) \ >> - __EXPORT_SYMBOL(sym, "_gpl") >> + __EXPORT_SYMBOL(sym, "_gpl", NULL, ,) >> >> #define EXPORT_SYMBOL_GPL_FUTURE(sym) \ >> - __EXPORT_SYMBOL(sym, "_gpl_future") >> + __EXPORT_SYMBOL(sym, "_gpl_future", NULL, ,) >> + >> +#define EXPORT_SYMBOL_NS(sym, ns) \ >> + __EXPORT_SYMBOL(sym, "", #ns, __##ns, NS_SEPARATOR #ns) >> + >> +#define EXPORT_SYMBOL_NS_GPL(sym, ns) \ >> + __EXPORT_SYMBOL(sym, "_gpl", #ns, __##ns, NS_SEPARATOR #ns) >> >> #ifdef CONFIG_UNUSED_SYMBOLS >> -#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused") >> -#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl") >> +#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused", , ,) >> +#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl", , ,) >> #else >> #define EXPORT_UNUSED_SYMBOL(sym) >> #define EXPORT_UNUSED_SYMBOL_GPL(sym) >> #endif >> >> -#endif /* __GENKSYMS__ */ >> +#endif /* __KERNEL__ && !__GENKSYMS__ */ >> + >> +#if defined(__GENKSYMS__) >> +/* >> + * When we're running genksyms, ignore the namespace and make the _NS >> + * variants look like the normal ones. There are two reasons for this: >> + * 1) In the normal definition of EXPORT_SYMBOL_NS, the 'ns' macro >> + * argument is itself not expanded because it's always tokenized or >> + * concatenated; but when running genksyms, a blank definition of the >> + * macro does allow the argument to be expanded; if a namespace >> + * happens to collide with a #define, this can cause issues. >> + * 2) There's no need to modify genksyms to deal with the _NS variants >> + */ >> +#define EXPORT_SYMBOL_NS(sym, ns) \ >> + EXPORT_SYMBOL(sym) >> +#define EXPORT_SYMBOL_NS_GPL(sym, ns) \ >> + EXPORT_SYMBOL_GPL(sym) >> +#endif >> >> #else /* !CONFIG_MODULES... */ >> >> #define EXPORT_SYMBOL(sym) >> +#define EXPORT_SYMBOL_NS(sym, ns) >> +#define EXPORT_SYMBOL_NS_GPL(sym, ns) >> #define EXPORT_SYMBOL_GPL(sym) >> #define EXPORT_SYMBOL_GPL_FUTURE(sym) >> #define EXPORT_UNUSED_SYMBOL(sym) >> #define EXPORT_UNUSED_SYMBOL_GPL(sym) >> >> +#define MODULE_IMPORT_NS(ns) >> #endif /* CONFIG_MODULES */ >> #endif /* !__ASSEMBLY__ */ >> >> diff --git a/include/linux/module.h b/include/linux/module.h >> index d44df9b2c131..afab4e8fa188 100644 >> --- a/include/linux/module.h >> +++ b/include/linux/module.h >> @@ -268,6 +268,12 @@ void *__symbol_get(const char *symbol); >> void *__symbol_get_gpl(const char *symbol); >> #define symbol_get(x) ((typeof(&x))(__symbol_get(VMLINUX_SYMBOL_STR(x)))) >> >> +/* namespace dependencies of the module */ >> +struct module_ns_dep { >> + struct list_head ns_dep; >> + const char *namespace; >> +}; >> + >> /* modules using other modules: kdb wants to see this. */ >> struct module_use { >> struct list_head source_list; >> @@ -359,6 +365,13 @@ struct module { >> const struct kernel_symbol *gpl_syms; >> const s32 *gpl_crcs; >> >> + /* Namespace imports */ >> + unsigned int num_ns_imports; >> + const struct namespace_import *ns_imports; >> + >> + /* Namespace dependencies */ >> + struct list_head ns_dependencies; >> + >> #ifdef CONFIG_UNUSED_SYMBOLS >> /* unused exported symbols. */ >> const struct kernel_symbol *unused_syms; >> diff --git a/kernel/module.c b/kernel/module.c >> index f475f30eed8c..63de0fe849f9 100644 >> --- a/kernel/module.c >> +++ b/kernel/module.c >> @@ -1166,6 +1166,51 @@ static inline int module_unload_init(struct module *mod) >> } >> #endif /* CONFIG_MODULE_UNLOAD */ >> >> +static bool module_has_ns_dependency(struct module *mod, const char *ns) >> +{ >> + struct module_ns_dep *ns_dep; >> + >> + list_for_each_entry(ns_dep, &mod->ns_dependencies, ns_dep) { >> + if (strcmp(ns_dep->namespace, ns) == 0) >> + return true; >> + } >> + >> + return false; >> +} >> + >> +static int add_module_ns_dependency(struct module *mod, const char *ns) >> +{ >> + struct module_ns_dep *ns_dep; >> + >> + if (module_has_ns_dependency(mod, ns)) >> + return 0; >> + >> + ns_dep = kmalloc(sizeof(*ns_dep), GFP_ATOMIC); >> + if (!ns_dep) >> + return -ENOMEM; >> + >> + ns_dep->namespace = ns; >> + >> + list_add(&ns_dep->ns_dep, &mod->ns_dependencies); >> + >> + return 0; >> +} >> + >> +static bool module_imports_ns(struct module *mod, const char *ns) >> +{ >> + size_t i; >> + >> + if (!ns) >> + return true; >> + >> + for (i = 0; i < mod->num_ns_imports; ++i) { >> + if (!strcmp(mod->ns_imports[i].namespace, ns)) >> + return true; >> + } >> + >> + return false; >> +} >> + >> static size_t module_flags_taint(struct module *mod, char *buf) >> { >> size_t l = 0; >> @@ -1415,6 +1460,18 @@ static const struct kernel_symbol *resolve_symbol(struct module *mod, >> goto getname; >> } >> >> + /* >> + * We can't yet verify that the module actually imports this >> + * namespace, because the imports themselves are only available >> + * after processing the symbol table and doing relocation; so >> + * instead just record the dependency and check later. >> + */ >> + if (sym->namespace) { >> + err = add_module_ns_dependency(mod, sym->namespace); >> + if (err) >> + sym = ERR_PTR(err); >> + } >> + >> getname: >> /* We must make copy under the lock if we failed to get ref. */ >> strncpy(ownername, module_name(owner), MODULE_NAME_LEN); >> @@ -3061,6 +3118,11 @@ static int find_module_sections(struct module *mod, struct load_info *info) >> sizeof(*mod->gpl_syms), >> &mod->num_gpl_syms); >> mod->gpl_crcs = section_addr(info, "__kcrctab_gpl"); >> + >> + mod->ns_imports = section_objs(info, "__knsimport", >> + sizeof(*mod->ns_imports), >> + &mod->num_ns_imports); >> + >> mod->gpl_future_syms = section_objs(info, >> "__ksymtab_gpl_future", >> sizeof(*mod->gpl_future_syms), >> @@ -3381,6 +3443,19 @@ static int post_relocation(struct module *mod, const struct load_info *info) >> return module_finalize(info->hdr, info->sechdrs, mod); >> } >> >> +static void verify_namespace_dependencies(struct module *mod) >> +{ >> + struct module_ns_dep *ns_dep; >> + >> + list_for_each_entry(ns_dep, &mod->ns_dependencies, ns_dep) { >> + if (!module_imports_ns(mod, ns_dep->namespace)) { >> + pr_warn("%s: module uses symbols from namespace %s," >> + " but does not import it.\n", >> + mod->name, ns_dep->namespace); >> + } >> + } >> +} >> + >> /* Is this module of this name done loading? No locks held. */ >> static bool finished_loading(const char *name) >> { >> @@ -3682,6 +3757,8 @@ static int load_module(struct load_info *info, const char __user *uargs, >> if (err) >> goto free_module; >> >> + INIT_LIST_HEAD(&mod->ns_dependencies); >> + >> #ifdef CONFIG_MODULE_SIG >> mod->sig_ok = info->sig_ok; >> if (!mod->sig_ok) { >> @@ -3730,6 +3807,8 @@ static int load_module(struct load_info *info, const char __user *uargs, >> if (err < 0) >> goto free_modinfo; >> >> + verify_namespace_dependencies(mod); >> + >> flush_module_icache(mod); >> >> /* Now copy in args */ >> -- >> 2.18.0.203.gfac676dfb9-goog >> From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.kernel.org ([198.145.29.99]:43566 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728568AbeGYRHb (ORCPT ); Wed, 25 Jul 2018 13:07:31 -0400 Date: Wed, 25 Jul 2018 17:55:07 +0200 From: Jessica Yu Subject: Re: [PATCH 2/6] module: add support for symbol namespaces. Message-ID: <20180725155507.umb5oatduquxwlmt@linux-8ccs> References: <20180716122125.175792-1-maco@android.com> <20180716122125.175792-3-maco@android.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii; format=flowed Content-Disposition: inline In-Reply-To: Sender: linux-arch-owner@vger.kernel.org List-ID: To: Martijn Coenen Cc: LKML , Masahiro Yamada , Michal Marek , Geert Uytterhoeven , Thomas Gleixner , Ingo Molnar , "H. Peter Anvin" , the arch/x86 maintainers , Alan Stern , Greg Kroah-Hartman , Oliver Neukum , Arnd Bergmann , Stephen Boyd , Philippe Ombredanne , Kate Stewart , Sam Ravnborg , linux-kbuild@vger.kernel.org, linux-m68k , USB list , USB Storage list , linux-scsi@vger.kernel.org, Linux-Arch , Martijn Coenen , Sandeep Patil , Iliyan Malchev , Joel Fernandes , Lucas De Marchi Message-ID: <20180725155507.ktPeamG1TleSlMS6l0YAuRPMjtM1v32qOPWpy05kAZ0@z> +++ Martijn Coenen [24/07/18 09:56 +0200]: >I did find an issue with my approach: > >On Mon, Jul 16, 2018 at 2:21 PM, Martijn Coenen wrote: >> The ELF symbols are renamed to include the namespace with an asm label; >> for example, symbol 'usb_stor_suspend' in namespace USB_STORAGE becomes >> 'usb_stor_suspend.USB_STORAGE'. This allows modpost to do namespace >> checking, without having to go through all the effort of parsing ELF and >> reloction records just to get to the struct kernel_symbols. > >depmod doesn't like this: if namespaced symbols are built-in to the >kernel, they will appear as 'symbol.NS' in the symbol table, whereas >modules using those symbols just depend on 'symbol'. This will cause >depmod to warn about unknown symbols. I didn't find this previously >because all the exports/imports I tested were done from modules >themselves. > >One way to deal with it is to change depmod, but it looks like it >hasn't been changed in ages, and it would also introduce a dependency >on userspaces to update it to avoid these warnings. So, we'd have to >encode the symbol namespace information in another way for modpost to >use. I could just write a separate post-processing tool (much like >genksyms), or perhaps encode the information in a discardable section. >Any other suggestions welcome. This seems to be because depmod uses System.map as a source for kernel symbols and scans for only the ones prefixed with "__ksymtab" to find the exported ones - and those happen to use the '.' to mark the namespace it belongs to. It strips that prefix and uses the remainder as the actual symbol name. To fix that it'd have to strip the namespace suffix in the symbol name as well. Just scanning the depmod source code, it seems really trivial to just have depmod accommodate the new symbol name format. Adding Lucas (kmod maintainer) to CC. Thanks, Jessica > >> >> On x86_64 I saw no difference in binary size (compression), but at >> runtime this will require a word of memory per export to hold the >> namespace. An alternative could be to store namespaced symbols in their >> own section and use a separate 'struct namespaced_kernel_symbol' for >> that section, at the cost of making the module loader more complex. >> >> Signed-off-by: Martijn Coenen >> --- >> include/asm-generic/export.h | 2 +- >> include/linux/export.h | 83 +++++++++++++++++++++++++++--------- >> include/linux/module.h | 13 ++++++ >> kernel/module.c | 79 ++++++++++++++++++++++++++++++++++ >> 4 files changed, 156 insertions(+), 21 deletions(-) >> >> diff --git a/include/asm-generic/export.h b/include/asm-generic/export.h >> index 68efb950a918..4c3d1afb702f 100644 >> --- a/include/asm-generic/export.h >> +++ b/include/asm-generic/export.h >> @@ -29,7 +29,7 @@ >> .section ___ksymtab\sec+\name,"a" >> .balign KSYM_ALIGN >> __ksymtab_\name: >> - __put \val, __kstrtab_\name >> + __put \val, __kstrtab_\name, 0 >> .previous >> .section __ksymtab_strings,"a" >> __kstrtab_\name: >> diff --git a/include/linux/export.h b/include/linux/export.h >> index ad6b8e697b27..9f6e70eeb85f 100644 >> --- a/include/linux/export.h >> +++ b/include/linux/export.h >> @@ -22,6 +22,11 @@ struct kernel_symbol >> { >> unsigned long value; >> const char *name; >> + const char *namespace; >> +}; >> + >> +struct namespace_import { >> + const char *namespace; >> }; >> >> #ifdef MODULE >> @@ -54,18 +59,28 @@ extern struct module __this_module; >> #define __CRC_SYMBOL(sym, sec) >> #endif >> >> +#define NS_SEPARATOR "." >> + >> +#define MODULE_IMPORT_NS(ns) \ >> + static const struct namespace_import __knsimport_##ns \ >> + asm("__knsimport_" #ns) \ >> + __attribute__((section("__knsimport"), used)) \ >> + = { #ns } >> + >> /* For every exported symbol, place a struct in the __ksymtab section */ >> -#define ___EXPORT_SYMBOL(sym, sec) \ >> +#define ___EXPORT_SYMBOL(sym, sec, ns, nspost, nspost2) \ >> extern typeof(sym) sym; \ >> __CRC_SYMBOL(sym, sec) \ >> - static const char __kstrtab_##sym[] \ >> + static const char __kstrtab_##sym##nspost[] \ >> __attribute__((section("__ksymtab_strings"), aligned(1))) \ >> = #sym; \ >> - static const struct kernel_symbol __ksymtab_##sym \ >> + static const struct kernel_symbol __ksymtab_##sym##nspost \ >> + asm("__ksymtab_" #sym nspost2) \ >> __used \ >> - __attribute__((section("___ksymtab" sec "+" #sym), used)) \ >> + __attribute__((section("___ksymtab" sec "+" #sym #nspost))) \ >> + __attribute__((used)) \ >> __attribute__((aligned(sizeof(void *)))) \ >> - = { (unsigned long)&sym, __kstrtab_##sym } >> + = { (unsigned long)&sym, __kstrtab_##sym##nspost, ns } >> >> #if defined(__KSYM_DEPS__) >> >> @@ -76,52 +91,80 @@ extern struct module __this_module; >> * system filters out from the preprocessor output (see ksym_dep_filter >> * in scripts/Kbuild.include). >> */ >> -#define __EXPORT_SYMBOL(sym, sec) === __KSYM_##sym === >> +#define __EXPORT_SYMBOL(sym, sec, ns, nspost, nspost2) === __KSYM_##sym === >> >> #elif defined(CONFIG_TRIM_UNUSED_KSYMS) >> >> #include >> >> -#define __EXPORT_SYMBOL(sym, sec) \ >> - __cond_export_sym(sym, sec, __is_defined(__KSYM_##sym)) >> -#define __cond_export_sym(sym, sec, conf) \ >> - ___cond_export_sym(sym, sec, conf) >> -#define ___cond_export_sym(sym, sec, enabled) \ >> - __cond_export_sym_##enabled(sym, sec) >> -#define __cond_export_sym_1(sym, sec) ___EXPORT_SYMBOL(sym, sec) >> -#define __cond_export_sym_0(sym, sec) /* nothing */ >> +#define __EXPORT_SYMBOL(sym, sec, ns, nspost, nspost2) \ >> + __cond_export_sym(sym, sec, ns, nspost, nspost2, \ >> + __is_defined(__KSYM_##sym)) >> +#define __cond_export_sym(sym, sec, ns, nspost, nspost2, conf) \ >> + ___cond_export_sym(sym, sec, ns, nspost, nspost2, conf) >> +#define ___cond_export_sym(sym, sec, ns, nspost, nspost2, enabled) \ >> + __cond_export_sym_##enabled(sym, sec, ns, nspost, nspost2) >> +#define __cond_export_sym_1(sym, sec, ns, nspost, nspost2) \ >> + ___EXPORT_SYMBOL(sym, sec, ns, nspost, nspost2) >> +#define __cond_export_sym_0(sym, sec, ns, nspost, nspost2) /* nothing */ >> >> #else >> #define __EXPORT_SYMBOL ___EXPORT_SYMBOL >> #endif >> >> #define EXPORT_SYMBOL(sym) \ >> - __EXPORT_SYMBOL(sym, "") >> + __EXPORT_SYMBOL(sym, "", NULL, ,) >> >> #define EXPORT_SYMBOL_GPL(sym) \ >> - __EXPORT_SYMBOL(sym, "_gpl") >> + __EXPORT_SYMBOL(sym, "_gpl", NULL, ,) >> >> #define EXPORT_SYMBOL_GPL_FUTURE(sym) \ >> - __EXPORT_SYMBOL(sym, "_gpl_future") >> + __EXPORT_SYMBOL(sym, "_gpl_future", NULL, ,) >> + >> +#define EXPORT_SYMBOL_NS(sym, ns) \ >> + __EXPORT_SYMBOL(sym, "", #ns, __##ns, NS_SEPARATOR #ns) >> + >> +#define EXPORT_SYMBOL_NS_GPL(sym, ns) \ >> + __EXPORT_SYMBOL(sym, "_gpl", #ns, __##ns, NS_SEPARATOR #ns) >> >> #ifdef CONFIG_UNUSED_SYMBOLS >> -#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused") >> -#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl") >> +#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused", , ,) >> +#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl", , ,) >> #else >> #define EXPORT_UNUSED_SYMBOL(sym) >> #define EXPORT_UNUSED_SYMBOL_GPL(sym) >> #endif >> >> -#endif /* __GENKSYMS__ */ >> +#endif /* __KERNEL__ && !__GENKSYMS__ */ >> + >> +#if defined(__GENKSYMS__) >> +/* >> + * When we're running genksyms, ignore the namespace and make the _NS >> + * variants look like the normal ones. There are two reasons for this: >> + * 1) In the normal definition of EXPORT_SYMBOL_NS, the 'ns' macro >> + * argument is itself not expanded because it's always tokenized or >> + * concatenated; but when running genksyms, a blank definition of the >> + * macro does allow the argument to be expanded; if a namespace >> + * happens to collide with a #define, this can cause issues. >> + * 2) There's no need to modify genksyms to deal with the _NS variants >> + */ >> +#define EXPORT_SYMBOL_NS(sym, ns) \ >> + EXPORT_SYMBOL(sym) >> +#define EXPORT_SYMBOL_NS_GPL(sym, ns) \ >> + EXPORT_SYMBOL_GPL(sym) >> +#endif >> >> #else /* !CONFIG_MODULES... */ >> >> #define EXPORT_SYMBOL(sym) >> +#define EXPORT_SYMBOL_NS(sym, ns) >> +#define EXPORT_SYMBOL_NS_GPL(sym, ns) >> #define EXPORT_SYMBOL_GPL(sym) >> #define EXPORT_SYMBOL_GPL_FUTURE(sym) >> #define EXPORT_UNUSED_SYMBOL(sym) >> #define EXPORT_UNUSED_SYMBOL_GPL(sym) >> >> +#define MODULE_IMPORT_NS(ns) >> #endif /* CONFIG_MODULES */ >> #endif /* !__ASSEMBLY__ */ >> >> diff --git a/include/linux/module.h b/include/linux/module.h >> index d44df9b2c131..afab4e8fa188 100644 >> --- a/include/linux/module.h >> +++ b/include/linux/module.h >> @@ -268,6 +268,12 @@ void *__symbol_get(const char *symbol); >> void *__symbol_get_gpl(const char *symbol); >> #define symbol_get(x) ((typeof(&x))(__symbol_get(VMLINUX_SYMBOL_STR(x)))) >> >> +/* namespace dependencies of the module */ >> +struct module_ns_dep { >> + struct list_head ns_dep; >> + const char *namespace; >> +}; >> + >> /* modules using other modules: kdb wants to see this. */ >> struct module_use { >> struct list_head source_list; >> @@ -359,6 +365,13 @@ struct module { >> const struct kernel_symbol *gpl_syms; >> const s32 *gpl_crcs; >> >> + /* Namespace imports */ >> + unsigned int num_ns_imports; >> + const struct namespace_import *ns_imports; >> + >> + /* Namespace dependencies */ >> + struct list_head ns_dependencies; >> + >> #ifdef CONFIG_UNUSED_SYMBOLS >> /* unused exported symbols. */ >> const struct kernel_symbol *unused_syms; >> diff --git a/kernel/module.c b/kernel/module.c >> index f475f30eed8c..63de0fe849f9 100644 >> --- a/kernel/module.c >> +++ b/kernel/module.c >> @@ -1166,6 +1166,51 @@ static inline int module_unload_init(struct module *mod) >> } >> #endif /* CONFIG_MODULE_UNLOAD */ >> >> +static bool module_has_ns_dependency(struct module *mod, const char *ns) >> +{ >> + struct module_ns_dep *ns_dep; >> + >> + list_for_each_entry(ns_dep, &mod->ns_dependencies, ns_dep) { >> + if (strcmp(ns_dep->namespace, ns) == 0) >> + return true; >> + } >> + >> + return false; >> +} >> + >> +static int add_module_ns_dependency(struct module *mod, const char *ns) >> +{ >> + struct module_ns_dep *ns_dep; >> + >> + if (module_has_ns_dependency(mod, ns)) >> + return 0; >> + >> + ns_dep = kmalloc(sizeof(*ns_dep), GFP_ATOMIC); >> + if (!ns_dep) >> + return -ENOMEM; >> + >> + ns_dep->namespace = ns; >> + >> + list_add(&ns_dep->ns_dep, &mod->ns_dependencies); >> + >> + return 0; >> +} >> + >> +static bool module_imports_ns(struct module *mod, const char *ns) >> +{ >> + size_t i; >> + >> + if (!ns) >> + return true; >> + >> + for (i = 0; i < mod->num_ns_imports; ++i) { >> + if (!strcmp(mod->ns_imports[i].namespace, ns)) >> + return true; >> + } >> + >> + return false; >> +} >> + >> static size_t module_flags_taint(struct module *mod, char *buf) >> { >> size_t l = 0; >> @@ -1415,6 +1460,18 @@ static const struct kernel_symbol *resolve_symbol(struct module *mod, >> goto getname; >> } >> >> + /* >> + * We can't yet verify that the module actually imports this >> + * namespace, because the imports themselves are only available >> + * after processing the symbol table and doing relocation; so >> + * instead just record the dependency and check later. >> + */ >> + if (sym->namespace) { >> + err = add_module_ns_dependency(mod, sym->namespace); >> + if (err) >> + sym = ERR_PTR(err); >> + } >> + >> getname: >> /* We must make copy under the lock if we failed to get ref. */ >> strncpy(ownername, module_name(owner), MODULE_NAME_LEN); >> @@ -3061,6 +3118,11 @@ static int find_module_sections(struct module *mod, struct load_info *info) >> sizeof(*mod->gpl_syms), >> &mod->num_gpl_syms); >> mod->gpl_crcs = section_addr(info, "__kcrctab_gpl"); >> + >> + mod->ns_imports = section_objs(info, "__knsimport", >> + sizeof(*mod->ns_imports), >> + &mod->num_ns_imports); >> + >> mod->gpl_future_syms = section_objs(info, >> "__ksymtab_gpl_future", >> sizeof(*mod->gpl_future_syms), >> @@ -3381,6 +3443,19 @@ static int post_relocation(struct module *mod, const struct load_info *info) >> return module_finalize(info->hdr, info->sechdrs, mod); >> } >> >> +static void verify_namespace_dependencies(struct module *mod) >> +{ >> + struct module_ns_dep *ns_dep; >> + >> + list_for_each_entry(ns_dep, &mod->ns_dependencies, ns_dep) { >> + if (!module_imports_ns(mod, ns_dep->namespace)) { >> + pr_warn("%s: module uses symbols from namespace %s," >> + " but does not import it.\n", >> + mod->name, ns_dep->namespace); >> + } >> + } >> +} >> + >> /* Is this module of this name done loading? No locks held. */ >> static bool finished_loading(const char *name) >> { >> @@ -3682,6 +3757,8 @@ static int load_module(struct load_info *info, const char __user *uargs, >> if (err) >> goto free_module; >> >> + INIT_LIST_HEAD(&mod->ns_dependencies); >> + >> #ifdef CONFIG_MODULE_SIG >> mod->sig_ok = info->sig_ok; >> if (!mod->sig_ok) { >> @@ -3730,6 +3807,8 @@ static int load_module(struct load_info *info, const char __user *uargs, >> if (err < 0) >> goto free_modinfo; >> >> + verify_namespace_dependencies(mod); >> + >> flush_module_icache(mod); >> >> /* Now copy in args */ >> -- >> 2.18.0.203.gfac676dfb9-goog >> From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [2/6] module: add support for symbol namespaces. From: Jessica Yu Message-Id: <20180725155507.umb5oatduquxwlmt@linux-8ccs> Date: Wed, 25 Jul 2018 17:55:07 +0200 To: Martijn Coenen Cc: LKML , Masahiro Yamada , Michal Marek , Geert Uytterhoeven , Thomas Gleixner , Ingo Molnar , "H. Peter Anvin" , the arch/x86 maintainers , Alan Stern , Greg Kroah-Hartman , Oliver Neukum , Arnd Bergmann , Stephen Boyd , Philippe Ombredanne , Kate Stewart , Sam Ravnborg , linux-kbuild@vger.kernel.org, linux-m68k , USB list , USB Storage list , linux-scsi@vger.kernel.org, Linux-Arch , Martijn Coenen , Sandeep Patil , Iliyan Malchev , Joel Fernandes , Lucas De Marchi List-ID: KysrIE1hcnRpam4gQ29lbmVuIFsyNC8wNy8xOCAwOTo1NiArMDIwMF06Cj5JIGRpZCBmaW5kIGFu IGlzc3VlIHdpdGggbXkgYXBwcm9hY2g6Cj4KPk9uIE1vbiwgSnVsIDE2LCAyMDE4IGF0IDI6MjEg UE0sIE1hcnRpam4gQ29lbmVuIDxtYWNvQGFuZHJvaWQuY29tPiB3cm90ZToKPj4gVGhlIEVMRiBz eW1ib2xzIGFyZSByZW5hbWVkIHRvIGluY2x1ZGUgdGhlIG5hbWVzcGFjZSB3aXRoIGFuIGFzbSBs YWJlbDsKPj4gZm9yIGV4YW1wbGUsIHN5bWJvbCAndXNiX3N0b3Jfc3VzcGVuZCcgaW4gbmFtZXNw YWNlIFVTQl9TVE9SQUdFIGJlY29tZXMKPj4gJ3VzYl9zdG9yX3N1c3BlbmQuVVNCX1NUT1JBR0Un LiAgVGhpcyBhbGxvd3MgbW9kcG9zdCB0byBkbyBuYW1lc3BhY2UKPj4gY2hlY2tpbmcsIHdpdGhv dXQgaGF2aW5nIHRvIGdvIHRocm91Z2ggYWxsIHRoZSBlZmZvcnQgb2YgcGFyc2luZyBFTEYgYW5k Cj4+IHJlbG9jdGlvbiByZWNvcmRzIGp1c3QgdG8gZ2V0IHRvIHRoZSBzdHJ1Y3Qga2VybmVsX3N5 bWJvbHMuCj4KPmRlcG1vZCBkb2Vzbid0IGxpa2UgdGhpczogaWYgbmFtZXNwYWNlZCBzeW1ib2xz IGFyZSBidWlsdC1pbiB0byB0aGUKPmtlcm5lbCwgdGhleSB3aWxsIGFwcGVhciBhcyAnc3ltYm9s Lk5TJyBpbiB0aGUgc3ltYm9sIHRhYmxlLCB3aGVyZWFzCj5tb2R1bGVzIHVzaW5nIHRob3NlIHN5 bWJvbHMganVzdCBkZXBlbmQgb24gJ3N5bWJvbCcuIFRoaXMgd2lsbCBjYXVzZQo+ZGVwbW9kIHRv IHdhcm4gYWJvdXQgdW5rbm93biBzeW1ib2xzLiBJIGRpZG4ndCBmaW5kIHRoaXMgcHJldmlvdXNs eQo+YmVjYXVzZSBhbGwgdGhlIGV4cG9ydHMvaW1wb3J0cyBJIHRlc3RlZCB3ZXJlIGRvbmUgZnJv bSBtb2R1bGVzCj50aGVtc2VsdmVzLgo+Cj5PbmUgd2F5IHRvIGRlYWwgd2l0aCBpdCBpcyB0byBj aGFuZ2UgZGVwbW9kLCBidXQgaXQgbG9va3MgbGlrZSBpdAo+aGFzbid0IGJlZW4gY2hhbmdlZCBp biBhZ2VzLCBhbmQgaXQgd291bGQgYWxzbyBpbnRyb2R1Y2UgYSBkZXBlbmRlbmN5Cj5vbiB1c2Vy c3BhY2VzIHRvIHVwZGF0ZSBpdCB0byBhdm9pZCB0aGVzZSB3YXJuaW5ncy4gU28sIHdlJ2QgaGF2 ZSB0bwo+ZW5jb2RlIHRoZSBzeW1ib2wgbmFtZXNwYWNlIGluZm9ybWF0aW9uIGluIGFub3RoZXIg d2F5IGZvciBtb2Rwb3N0IHRvCj51c2UuIEkgY291bGQganVzdCB3cml0ZSBhIHNlcGFyYXRlIHBv c3QtcHJvY2Vzc2luZyB0b29sIChtdWNoIGxpa2UKPmdlbmtzeW1zKSwgb3IgcGVyaGFwcyBlbmNv ZGUgdGhlIGluZm9ybWF0aW9uIGluIGEgZGlzY2FyZGFibGUgc2VjdGlvbi4KPkFueSBvdGhlciBz dWdnZXN0aW9ucyB3ZWxjb21lLgoKVGhpcyBzZWVtcyB0byBiZSBiZWNhdXNlIGRlcG1vZCB1c2Vz IFN5c3RlbS5tYXAgYXMgYSBzb3VyY2UgZm9yIGtlcm5lbApzeW1ib2xzIGFuZCBzY2FucyBmb3Ig b25seSB0aGUgb25lcyBwcmVmaXhlZCB3aXRoICJfX2tzeW10YWIiIHRvIGZpbmQKdGhlIGV4cG9y dGVkIG9uZXMgLSBhbmQgdGhvc2UgaGFwcGVuIHRvIHVzZSB0aGUgJy4nIHRvIG1hcmsgdGhlCm5h bWVzcGFjZSBpdCBiZWxvbmdzIHRvLiBJdCBzdHJpcHMgdGhhdCBwcmVmaXggYW5kIHVzZXMgdGhl IHJlbWFpbmRlcgphcyB0aGUgYWN0dWFsIHN5bWJvbCBuYW1lLiBUbyBmaXggdGhhdCBpdCdkIGhh dmUgdG8gc3RyaXAgdGhlCm5hbWVzcGFjZSBzdWZmaXggaW4gdGhlIHN5bWJvbCBuYW1lIGFzIHdl bGwuCgpKdXN0IHNjYW5uaW5nIHRoZSBkZXBtb2Qgc291cmNlIGNvZGUsIGl0IHNlZW1zIHJlYWxs eSB0cml2aWFsIHRvIGp1c3QKaGF2ZSBkZXBtb2QgYWNjb21tb2RhdGUgdGhlIG5ldyBzeW1ib2wg bmFtZSBmb3JtYXQuIEFkZGluZyBMdWNhcyAoa21vZAptYWludGFpbmVyKSB0byBDQy4KClRoYW5r cywKCkplc3NpY2EKCj4KPj4KPj4gT24geDg2XzY0IEkgc2F3IG5vIGRpZmZlcmVuY2UgaW4gYmlu YXJ5IHNpemUgKGNvbXByZXNzaW9uKSwgYnV0IGF0Cj4+IHJ1bnRpbWUgdGhpcyB3aWxsIHJlcXVp cmUgYSB3b3JkIG9mIG1lbW9yeSBwZXIgZXhwb3J0IHRvIGhvbGQgdGhlCj4+IG5hbWVzcGFjZS4g QW4gYWx0ZXJuYXRpdmUgY291bGQgYmUgdG8gc3RvcmUgbmFtZXNwYWNlZCBzeW1ib2xzIGluIHRo ZWlyCj4+IG93biBzZWN0aW9uIGFuZCB1c2UgYSBzZXBhcmF0ZSAnc3RydWN0IG5hbWVzcGFjZWRf a2VybmVsX3N5bWJvbCcgZm9yCj4+IHRoYXQgc2VjdGlvbiwgYXQgdGhlIGNvc3Qgb2YgbWFraW5n IHRoZSBtb2R1bGUgbG9hZGVyIG1vcmUgY29tcGxleC4KPj4KPj4gU2lnbmVkLW9mZi1ieTogTWFy dGlqbiBDb2VuZW4gPG1hY29AYW5kcm9pZC5jb20+Cj4+IC0tLQo+PiAgaW5jbHVkZS9hc20tZ2Vu ZXJpYy9leHBvcnQuaCB8ICAyICstCj4+ICBpbmNsdWRlL2xpbnV4L2V4cG9ydC5oICAgICAgIHwg ODMgKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tCj4+ICBpbmNsdWRlL2xpbnV4 L21vZHVsZS5oICAgICAgIHwgMTMgKysrKysrCj4+ICBrZXJuZWwvbW9kdWxlLmMgICAgICAgICAg ICAgIHwgNzkgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+PiAgNCBmaWxlcyBj aGFuZ2VkLCAxNTYgaW5zZXJ0aW9ucygrKSwgMjEgZGVsZXRpb25zKC0pCj4+Cj4+IGRpZmYgLS1n aXQgYS9pbmNsdWRlL2FzbS1nZW5lcmljL2V4cG9ydC5oIGIvaW5jbHVkZS9hc20tZ2VuZXJpYy9l eHBvcnQuaAo+PiBpbmRleCA2OGVmYjk1MGE5MTguLjRjM2QxYWZiNzAyZiAxMDA2NDQKPj4gLS0t IGEvaW5jbHVkZS9hc20tZ2VuZXJpYy9leHBvcnQuaAo+PiArKysgYi9pbmNsdWRlL2FzbS1nZW5l cmljL2V4cG9ydC5oCj4+IEBAIC0yOSw3ICsyOSw3IEBACj4+ICAgICAgICAgLnNlY3Rpb24gX19f a3N5bXRhYlxzZWMrXG5hbWUsImEiCj4+ICAgICAgICAgLmJhbGlnbiBLU1lNX0FMSUdOCj4+ICBf X2tzeW10YWJfXG5hbWU6Cj4+IC0gICAgICAgX19wdXQgXHZhbCwgX19rc3RydGFiX1xuYW1lCj4+ ICsgICAgICAgX19wdXQgXHZhbCwgX19rc3RydGFiX1xuYW1lLCAwCj4+ICAgICAgICAgLnByZXZp b3VzCj4+ICAgICAgICAgLnNlY3Rpb24gX19rc3ltdGFiX3N0cmluZ3MsImEiCj4+ICBfX2tzdHJ0 YWJfXG5hbWU6Cj4+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2V4cG9ydC5oIGIvaW5jbHVk ZS9saW51eC9leHBvcnQuaAo+PiBpbmRleCBhZDZiOGU2OTdiMjcuLjlmNmU3MGVlYjg1ZiAxMDA2 NDQKPj4gLS0tIGEvaW5jbHVkZS9saW51eC9leHBvcnQuaAo+PiArKysgYi9pbmNsdWRlL2xpbnV4 L2V4cG9ydC5oCj4+IEBAIC0yMiw2ICsyMiwxMSBAQCBzdHJ1Y3Qga2VybmVsX3N5bWJvbAo+PiAg ewo+PiAgICAgICAgIHVuc2lnbmVkIGxvbmcgdmFsdWU7Cj4+ICAgICAgICAgY29uc3QgY2hhciAq bmFtZTsKPj4gKyAgICAgICBjb25zdCBjaGFyICpuYW1lc3BhY2U7Cj4+ICt9Owo+PiArCj4+ICtz dHJ1Y3QgbmFtZXNwYWNlX2ltcG9ydCB7Cj4+ICsgICAgICAgY29uc3QgY2hhciAqbmFtZXNwYWNl Owo+PiAgfTsKPj4KPj4gICNpZmRlZiBNT0RVTEUKPj4gQEAgLTU0LDE4ICs1OSwyOCBAQCBleHRl cm4gc3RydWN0IG1vZHVsZSBfX3RoaXNfbW9kdWxlOwo+PiAgI2RlZmluZSBfX0NSQ19TWU1CT0wo c3ltLCBzZWMpCj4+ICAjZW5kaWYKPj4KPj4gKyNkZWZpbmUgTlNfU0VQQVJBVE9SICIuIgo+PiAr Cj4+ICsjZGVmaW5lIE1PRFVMRV9JTVBPUlRfTlMobnMpICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFwKPj4gKyAgICAgICBzdGF0aWMgY29uc3Qgc3RydWN0IG5hbWVz cGFjZV9pbXBvcnQgX19rbnNpbXBvcnRfIyNucyAgICAgICAgICAgXAo+PiArICAgICAgIGFzbSgi X19rbnNpbXBvcnRfIiAjbnMpICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBcCj4+ICsgICAgICAgX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX19rbnNpbXBvcnQiKSwgdXNl ZCkpICAgICAgICAgICAgICAgICAgIFwKPj4gKyAgICAgICA9IHsgI25zIH0KPj4gKwo+PiAgLyog Rm9yIGV2ZXJ5IGV4cG9ydGVkIHN5bWJvbCwgcGxhY2UgYSBzdHJ1Y3QgaW4gdGhlIF9fa3N5bXRh YiBzZWN0aW9uICovCj4+IC0jZGVmaW5lIF9fX0VYUE9SVF9TWU1CT0woc3ltLCBzZWMpICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKPj4gKyNkZWZpbmUgX19fRVhQT1JUX1NZ TUJPTChzeW0sIHNlYywgbnMsIG5zcG9zdCwgbnNwb3N0MikgICAgICAgICAgICAgICAgICAgICAg ICBcCj4+ICAgICAgICAgZXh0ZXJuIHR5cGVvZihzeW0pIHN5bTsgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIFwKPj4gICAgICAgICBfX0NSQ19TWU1CT0woc3ltLCBzZWMp ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAo+PiAtICAgICAgIHN0 YXRpYyBjb25zdCBjaGFyIF9fa3N0cnRhYl8jI3N5bVtdICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBcCj4+ICsgICAgICAgc3RhdGljIGNvbnN0IGNoYXIgX19rc3RydGFiXyMjc3ltIyNuc3Bv c3RbXSAgICAgICAgICAgICAgICAgICAgIFwKPj4gICAgICAgICBfX2F0dHJpYnV0ZV9fKChzZWN0 aW9uKCJfX2tzeW10YWJfc3RyaW5ncyIpLCBhbGlnbmVkKDEpKSkgICAgICAgXAo+PiAgICAgICAg ID0gI3N5bTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBcCj4+IC0gICAgICAgc3RhdGljIGNvbnN0IHN0cnVjdCBrZXJuZWxfc3ltYm9sIF9f a3N5bXRhYl8jI3N5bSAgICAgICAgICAgICAgIFwKPj4gKyAgICAgICBzdGF0aWMgY29uc3Qgc3Ry dWN0IGtlcm5lbF9zeW1ib2wgX19rc3ltdGFiXyMjc3ltIyNuc3Bvc3QgICAgICAgXAo+PiArICAg ICAgIGFzbSgiX19rc3ltdGFiXyIgI3N5bSBuc3Bvc3QyKSAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBcCj4+ICAgICAgICAgX191c2VkICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKPj4gLSAgICAgICBfX2F0dHJpYnV0ZV9f KChzZWN0aW9uKCJfX19rc3ltdGFiIiBzZWMgIisiICNzeW0pLCB1c2VkKSkgICAgICAgXAo+PiAr ICAgICAgIF9fYXR0cmlidXRlX18oKHNlY3Rpb24oIl9fX2tzeW10YWIiIHNlYyAiKyIgI3N5bSAj bnNwb3N0KSkpICAgICBcCj4+ICsgICAgICAgX19hdHRyaWJ1dGVfXygodXNlZCkpICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKPj4gICAgICAgICBfX2F0dHJpYnV0 ZV9fKChhbGlnbmVkKHNpemVvZih2b2lkICopKSkpICAgICAgICAgICAgICAgICAgICAgICAgXAo+ PiAtICAgICAgID0geyAodW5zaWduZWQgbG9uZykmc3ltLCBfX2tzdHJ0YWJfIyNzeW0gfQo+PiAr ICAgICAgID0geyAodW5zaWduZWQgbG9uZykmc3ltLCBfX2tzdHJ0YWJfIyNzeW0jI25zcG9zdCwg bnMgfQo+Pgo+PiAgI2lmIGRlZmluZWQoX19LU1lNX0RFUFNfXykKPj4KPj4gQEAgLTc2LDUyICs5 MSw4MCBAQCBleHRlcm4gc3RydWN0IG1vZHVsZSBfX3RoaXNfbW9kdWxlOwo+PiAgICogc3lzdGVt IGZpbHRlcnMgb3V0IGZyb20gdGhlIHByZXByb2Nlc3NvciBvdXRwdXQgKHNlZSBrc3ltX2RlcF9m aWx0ZXIKPj4gICAqIGluIHNjcmlwdHMvS2J1aWxkLmluY2x1ZGUpLgo+PiAgICovCj4+IC0jZGVm aW5lIF9fRVhQT1JUX1NZTUJPTChzeW0sIHNlYykgICAgICA9PT0gX19LU1lNXyMjc3ltID09PQo+ PiArI2RlZmluZSBfX0VYUE9SVF9TWU1CT0woc3ltLCBzZWMsIG5zLCBuc3Bvc3QsIG5zcG9zdDIp ID09PSBfX0tTWU1fIyNzeW0gPT09Cj4+Cj4+ICAjZWxpZiBkZWZpbmVkKENPTkZJR19UUklNX1VO VVNFRF9LU1lNUykKPj4KPj4gICNpbmNsdWRlIDxnZW5lcmF0ZWQvYXV0b2tzeW1zLmg+Cj4+Cj4+ IC0jZGVmaW5lIF9fRVhQT1JUX1NZTUJPTChzeW0sIHNlYykgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBcCj4+IC0gICAgICAgX19jb25kX2V4cG9ydF9zeW0oc3ltLCBzZWMsIF9faXNfZGVm aW5lZChfX0tTWU1fIyNzeW0pKQo+PiAtI2RlZmluZSBfX2NvbmRfZXhwb3J0X3N5bShzeW0sIHNl YywgY29uZikgICAgICAgICAgICAgICAgICAgICAgXAo+PiAtICAgICAgIF9fX2NvbmRfZXhwb3J0 X3N5bShzeW0sIHNlYywgY29uZikKPj4gLSNkZWZpbmUgX19fY29uZF9leHBvcnRfc3ltKHN5bSwg c2VjLCBlbmFibGVkKSAgICAgICAgICAgICAgICAgIFwKPj4gLSAgICAgICBfX2NvbmRfZXhwb3J0 X3N5bV8jI2VuYWJsZWQoc3ltLCBzZWMpCj4+IC0jZGVmaW5lIF9fY29uZF9leHBvcnRfc3ltXzEo c3ltLCBzZWMpIF9fX0VYUE9SVF9TWU1CT0woc3ltLCBzZWMpCj4+IC0jZGVmaW5lIF9fY29uZF9l eHBvcnRfc3ltXzAoc3ltLCBzZWMpIC8qIG5vdGhpbmcgKi8KPj4gKyNkZWZpbmUgX19FWFBPUlRf U1lNQk9MKHN5bSwgc2VjLCBucywgbnNwb3N0LCBuc3Bvc3QyKSAgICAgICAgICAgICAgICAgXAo+ PiArICAgICAgIF9fY29uZF9leHBvcnRfc3ltKHN5bSwgc2VjLCBucywgbnNwb3N0LCBuc3Bvc3Qy LCAgICAgICAgICAgICAgICBcCj4+ICsgICAgICAgICAgICAgICAgICAgICAgICAgX19pc19kZWZp bmVkKF9fS1NZTV8jI3N5bSkpCj4+ICsjZGVmaW5lIF9fY29uZF9leHBvcnRfc3ltKHN5bSwgc2Vj LCBucywgbnNwb3N0LCBuc3Bvc3QyLCBjb25mKSAgICAgICAgIFwKPj4gKyAgICAgICBfX19jb25k X2V4cG9ydF9zeW0oc3ltLCBzZWMsIG5zLCBuc3Bvc3QsIG5zcG9zdDIsIGNvbmYpCj4+ICsjZGVm aW5lIF9fX2NvbmRfZXhwb3J0X3N5bShzeW0sIHNlYywgbnMsIG5zcG9zdCwgbnNwb3N0MiwgZW5h YmxlZCkgICAgIFwKPj4gKyAgICAgICBfX2NvbmRfZXhwb3J0X3N5bV8jI2VuYWJsZWQoc3ltLCBz ZWMsIG5zLCBuc3Bvc3QsIG5zcG9zdDIpCj4+ICsjZGVmaW5lIF9fY29uZF9leHBvcnRfc3ltXzEo c3ltLCBzZWMsIG5zLCBuc3Bvc3QsIG5zcG9zdDIpICAgICAgICAgICAgIFwKPj4gKyAgICAgICBf X19FWFBPUlRfU1lNQk9MKHN5bSwgc2VjLCBucywgbnNwb3N0LCBuc3Bvc3QyKQo+PiArI2RlZmlu ZSBfX2NvbmRfZXhwb3J0X3N5bV8wKHN5bSwgc2VjLCBucywgbnNwb3N0LCBuc3Bvc3QyKSAvKiBu b3RoaW5nICovCj4+Cj4+ICAjZWxzZQo+PiAgI2RlZmluZSBfX0VYUE9SVF9TWU1CT0wgX19fRVhQ T1JUX1NZTUJPTAo+PiAgI2VuZGlmCj4+Cj4+ICAjZGVmaW5lIEVYUE9SVF9TWU1CT0woc3ltKSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCj4+IC0gICAgICAgX19FWFBPUlRf U1lNQk9MKHN5bSwgIiIpCj4+ICsgICAgICAgX19FWFBPUlRfU1lNQk9MKHN5bSwgIiIsIE5VTEws ICwpCj4+Cj4+ICAjZGVmaW5lIEVYUE9SVF9TWU1CT0xfR1BMKHN5bSkgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBcCj4+IC0gICAgICAgX19FWFBPUlRfU1lNQk9MKHN5bSwgIl9ncGwi KQo+PiArICAgICAgIF9fRVhQT1JUX1NZTUJPTChzeW0sICJfZ3BsIiwgTlVMTCwgLCkKPj4KPj4g ICNkZWZpbmUgRVhQT1JUX1NZTUJPTF9HUExfRlVUVVJFKHN5bSkgICAgICAgICAgICAgICAgICAg ICAgICAgIFwKPj4gLSAgICAgICBfX0VYUE9SVF9TWU1CT0woc3ltLCAiX2dwbF9mdXR1cmUiKQo+ PiArICAgICAgIF9fRVhQT1JUX1NZTUJPTChzeW0sICJfZ3BsX2Z1dHVyZSIsIE5VTEwsICwpCj4+ ICsKPj4gKyNkZWZpbmUgRVhQT1JUX1NZTUJPTF9OUyhzeW0sIG5zKSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBcCj4+ICsgICAgICAgX19FWFBPUlRfU1lNQk9MKHN5bSwgIiIsICNucywg X18jI25zLCBOU19TRVBBUkFUT1IgI25zKQo+PiArCj4+ICsjZGVmaW5lIEVYUE9SVF9TWU1CT0xf TlNfR1BMKHN5bSwgbnMpICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKPj4gKyAgICAg ICBfX0VYUE9SVF9TWU1CT0woc3ltLCAiX2dwbCIsICNucywgX18jI25zLCBOU19TRVBBUkFUT1Ig I25zKQo+Pgo+PiAgI2lmZGVmIENPTkZJR19VTlVTRURfU1lNQk9MUwo+PiAtI2RlZmluZSBFWFBP UlRfVU5VU0VEX1NZTUJPTChzeW0pIF9fRVhQT1JUX1NZTUJPTChzeW0sICJfdW51c2VkIikKPj4g LSNkZWZpbmUgRVhQT1JUX1VOVVNFRF9TWU1CT0xfR1BMKHN5bSkgX19FWFBPUlRfU1lNQk9MKHN5 bSwgIl91bnVzZWRfZ3BsIikKPj4gKyNkZWZpbmUgRVhQT1JUX1VOVVNFRF9TWU1CT0woc3ltKSBf X0VYUE9SVF9TWU1CT0woc3ltLCAiX3VudXNlZCIsICwgLCkKPj4gKyNkZWZpbmUgRVhQT1JUX1VO VVNFRF9TWU1CT0xfR1BMKHN5bSkgX19FWFBPUlRfU1lNQk9MKHN5bSwgIl91bnVzZWRfZ3BsIiwg LCAsKQo+PiAgI2Vsc2UKPj4gICNkZWZpbmUgRVhQT1JUX1VOVVNFRF9TWU1CT0woc3ltKQo+PiAg I2RlZmluZSBFWFBPUlRfVU5VU0VEX1NZTUJPTF9HUEwoc3ltKQo+PiAgI2VuZGlmCj4+Cj4+IC0j ZW5kaWYgLyogX19HRU5LU1lNU19fICovCj4+ICsjZW5kaWYgLyogX19LRVJORUxfXyAmJiAhX19H RU5LU1lNU19fICovCj4+ICsKPj4gKyNpZiBkZWZpbmVkKF9fR0VOS1NZTVNfXykKPj4gKy8qCj4+ ICsgKiBXaGVuIHdlJ3JlIHJ1bm5pbmcgZ2Vua3N5bXMsIGlnbm9yZSB0aGUgbmFtZXNwYWNlIGFu ZCBtYWtlIHRoZSBfTlMKPj4gKyAqIHZhcmlhbnRzIGxvb2sgbGlrZSB0aGUgbm9ybWFsIG9uZXMu IFRoZXJlIGFyZSB0d28gcmVhc29ucyBmb3IgdGhpczoKPj4gKyAqIDEpIEluIHRoZSBub3JtYWwg ZGVmaW5pdGlvbiBvZiBFWFBPUlRfU1lNQk9MX05TLCB0aGUgJ25zJyBtYWNybwo+PiArICogICAg YXJndW1lbnQgaXMgaXRzZWxmIG5vdCBleHBhbmRlZCBiZWNhdXNlIGl0J3MgYWx3YXlzIHRva2Vu aXplZCBvcgo+PiArICogICAgY29uY2F0ZW5hdGVkOyBidXQgd2hlbiBydW5uaW5nIGdlbmtzeW1z LCBhIGJsYW5rIGRlZmluaXRpb24gb2YgdGhlCj4+ICsgKiAgICBtYWNybyBkb2VzIGFsbG93IHRo ZSBhcmd1bWVudCB0byBiZSBleHBhbmRlZDsgaWYgYSBuYW1lc3BhY2UKPj4gKyAqICAgIGhhcHBl bnMgdG8gY29sbGlkZSB3aXRoIGEgI2RlZmluZSwgdGhpcyBjYW4gY2F1c2UgaXNzdWVzLgo+PiAr ICogMikgVGhlcmUncyBubyBuZWVkIHRvIG1vZGlmeSBnZW5rc3ltcyB0byBkZWFsIHdpdGggdGhl IF9OUyB2YXJpYW50cwo+PiArICovCj4+ICsjZGVmaW5lIEVYUE9SVF9TWU1CT0xfTlMoc3ltLCBu cykgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCj4+ICsgICAgICAgRVhQT1JUX1NZTUJP TChzeW0pCj4+ICsjZGVmaW5lIEVYUE9SVF9TWU1CT0xfTlNfR1BMKHN5bSwgbnMpICAgICAgICAg ICAgICAgICAgICAgICAgICBcCj4+ICsgICAgICAgRVhQT1JUX1NZTUJPTF9HUEwoc3ltKQo+PiAr I2VuZGlmCj4+Cj4+ICAjZWxzZSAvKiAhQ09ORklHX01PRFVMRVMuLi4gKi8KPj4KPj4gICNkZWZp bmUgRVhQT1JUX1NZTUJPTChzeW0pCj4+ICsjZGVmaW5lIEVYUE9SVF9TWU1CT0xfTlMoc3ltLCBu cykKPj4gKyNkZWZpbmUgRVhQT1JUX1NZTUJPTF9OU19HUEwoc3ltLCBucykKPj4gICNkZWZpbmUg RVhQT1JUX1NZTUJPTF9HUEwoc3ltKQo+PiAgI2RlZmluZSBFWFBPUlRfU1lNQk9MX0dQTF9GVVRV UkUoc3ltKQo+PiAgI2RlZmluZSBFWFBPUlRfVU5VU0VEX1NZTUJPTChzeW0pCj4+ICAjZGVmaW5l IEVYUE9SVF9VTlVTRURfU1lNQk9MX0dQTChzeW0pCj4+Cj4+ICsjZGVmaW5lIE1PRFVMRV9JTVBP UlRfTlMobnMpCj4+ICAjZW5kaWYgLyogQ09ORklHX01PRFVMRVMgKi8KPj4gICNlbmRpZiAvKiAh X19BU1NFTUJMWV9fICovCj4+Cj4+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21vZHVsZS5o IGIvaW5jbHVkZS9saW51eC9tb2R1bGUuaAo+PiBpbmRleCBkNDRkZjliMmMxMzEuLmFmYWI0ZThm YTE4OCAxMDA2NDQKPj4gLS0tIGEvaW5jbHVkZS9saW51eC9tb2R1bGUuaAo+PiArKysgYi9pbmNs dWRlL2xpbnV4L21vZHVsZS5oCj4+IEBAIC0yNjgsNiArMjY4LDEyIEBAIHZvaWQgKl9fc3ltYm9s X2dldChjb25zdCBjaGFyICpzeW1ib2wpOwo+PiAgdm9pZCAqX19zeW1ib2xfZ2V0X2dwbChjb25z dCBjaGFyICpzeW1ib2wpOwo+PiAgI2RlZmluZSBzeW1ib2xfZ2V0KHgpICgodHlwZW9mKCZ4KSko X19zeW1ib2xfZ2V0KFZNTElOVVhfU1lNQk9MX1NUUih4KSkpKQo+Pgo+PiArLyogbmFtZXNwYWNl IGRlcGVuZGVuY2llcyBvZiB0aGUgbW9kdWxlICovCj4+ICtzdHJ1Y3QgbW9kdWxlX25zX2RlcCB7 Cj4+ICsgICAgICAgc3RydWN0IGxpc3RfaGVhZCBuc19kZXA7Cj4+ICsgICAgICAgY29uc3QgY2hh ciAqbmFtZXNwYWNlOwo+PiArfTsKPj4gKwo+PiAgLyogbW9kdWxlcyB1c2luZyBvdGhlciBtb2R1 bGVzOiBrZGIgd2FudHMgdG8gc2VlIHRoaXMuICovCj4+ICBzdHJ1Y3QgbW9kdWxlX3VzZSB7Cj4+ ICAgICAgICAgc3RydWN0IGxpc3RfaGVhZCBzb3VyY2VfbGlzdDsKPj4gQEAgLTM1OSw2ICszNjUs MTMgQEAgc3RydWN0IG1vZHVsZSB7Cj4+ICAgICAgICAgY29uc3Qgc3RydWN0IGtlcm5lbF9zeW1i b2wgKmdwbF9zeW1zOwo+PiAgICAgICAgIGNvbnN0IHMzMiAqZ3BsX2NyY3M7Cj4+Cj4+ICsgICAg ICAgLyogTmFtZXNwYWNlIGltcG9ydHMgKi8KPj4gKyAgICAgICB1bnNpZ25lZCBpbnQgbnVtX25z X2ltcG9ydHM7Cj4+ICsgICAgICAgY29uc3Qgc3RydWN0IG5hbWVzcGFjZV9pbXBvcnQgKm5zX2lt cG9ydHM7Cj4+ICsKPj4gKyAgICAgICAvKiBOYW1lc3BhY2UgZGVwZW5kZW5jaWVzICovCj4+ICsg ICAgICAgc3RydWN0IGxpc3RfaGVhZCBuc19kZXBlbmRlbmNpZXM7Cj4+ICsKPj4gICNpZmRlZiBD T05GSUdfVU5VU0VEX1NZTUJPTFMKPj4gICAgICAgICAvKiB1bnVzZWQgZXhwb3J0ZWQgc3ltYm9s cy4gKi8KPj4gICAgICAgICBjb25zdCBzdHJ1Y3Qga2VybmVsX3N5bWJvbCAqdW51c2VkX3N5bXM7 Cj4+IGRpZmYgLS1naXQgYS9rZXJuZWwvbW9kdWxlLmMgYi9rZXJuZWwvbW9kdWxlLmMKPj4gaW5k ZXggZjQ3NWYzMGVlZDhjLi42M2RlMGZlODQ5ZjkgMTAwNjQ0Cj4+IC0tLSBhL2tlcm5lbC9tb2R1 bGUuYwo+PiArKysgYi9rZXJuZWwvbW9kdWxlLmMKPj4gQEAgLTExNjYsNiArMTE2Niw1MSBAQCBz dGF0aWMgaW5saW5lIGludCBtb2R1bGVfdW5sb2FkX2luaXQoc3RydWN0IG1vZHVsZSAqbW9kKQo+ PiAgfQo+PiAgI2VuZGlmIC8qIENPTkZJR19NT0RVTEVfVU5MT0FEICovCj4+Cj4+ICtzdGF0aWMg Ym9vbCBtb2R1bGVfaGFzX25zX2RlcGVuZGVuY3koc3RydWN0IG1vZHVsZSAqbW9kLCBjb25zdCBj aGFyICpucykKPj4gK3sKPj4gKyAgICAgICBzdHJ1Y3QgbW9kdWxlX25zX2RlcCAqbnNfZGVwOwo+ PiArCj4+ICsgICAgICAgbGlzdF9mb3JfZWFjaF9lbnRyeShuc19kZXAsICZtb2QtPm5zX2RlcGVu ZGVuY2llcywgbnNfZGVwKSB7Cj4+ICsgICAgICAgICAgICAgICBpZiAoc3RyY21wKG5zX2RlcC0+ bmFtZXNwYWNlLCBucykgPT0gMCkKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRy dWU7Cj4+ICsgICAgICAgfQo+PiArCj4+ICsgICAgICAgcmV0dXJuIGZhbHNlOwo+PiArfQo+PiAr Cj4+ICtzdGF0aWMgaW50IGFkZF9tb2R1bGVfbnNfZGVwZW5kZW5jeShzdHJ1Y3QgbW9kdWxlICpt b2QsIGNvbnN0IGNoYXIgKm5zKQo+PiArewo+PiArICAgICAgIHN0cnVjdCBtb2R1bGVfbnNfZGVw ICpuc19kZXA7Cj4+ICsKPj4gKyAgICAgICBpZiAobW9kdWxlX2hhc19uc19kZXBlbmRlbmN5KG1v ZCwgbnMpKQo+PiArICAgICAgICAgICAgICAgcmV0dXJuIDA7Cj4+ICsKPj4gKyAgICAgICBuc19k ZXAgPSBrbWFsbG9jKHNpemVvZigqbnNfZGVwKSwgR0ZQX0FUT01JQyk7Cj4+ICsgICAgICAgaWYg KCFuc19kZXApCj4+ICsgICAgICAgICAgICAgICByZXR1cm4gLUVOT01FTTsKPj4gKwo+PiArICAg ICAgIG5zX2RlcC0+bmFtZXNwYWNlID0gbnM7Cj4+ICsKPj4gKyAgICAgICBsaXN0X2FkZCgmbnNf ZGVwLT5uc19kZXAsICZtb2QtPm5zX2RlcGVuZGVuY2llcyk7Cj4+ICsKPj4gKyAgICAgICByZXR1 cm4gMDsKPj4gK30KPj4gKwo+PiArc3RhdGljIGJvb2wgbW9kdWxlX2ltcG9ydHNfbnMoc3RydWN0 IG1vZHVsZSAqbW9kLCBjb25zdCBjaGFyICpucykKPj4gK3sKPj4gKyAgICAgICBzaXplX3QgaTsK Pj4gKwo+PiArICAgICAgIGlmICghbnMpCj4+ICsgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsK Pj4gKwo+PiArICAgICAgIGZvciAoaSA9IDA7IGkgPCBtb2QtPm51bV9uc19pbXBvcnRzOyArK2kp IHsKPj4gKyAgICAgICAgICAgICAgIGlmICghc3RyY21wKG1vZC0+bnNfaW1wb3J0c1tpXS5uYW1l c3BhY2UsIG5zKSkKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHRydWU7Cj4+ICsg ICAgICAgfQo+PiArCj4+ICsgICAgICAgcmV0dXJuIGZhbHNlOwo+PiArfQo+PiArCj4+ICBzdGF0 aWMgc2l6ZV90IG1vZHVsZV9mbGFnc190YWludChzdHJ1Y3QgbW9kdWxlICptb2QsIGNoYXIgKmJ1 ZikKPj4gIHsKPj4gICAgICAgICBzaXplX3QgbCA9IDA7Cj4+IEBAIC0xNDE1LDYgKzE0NjAsMTgg QEAgc3RhdGljIGNvbnN0IHN0cnVjdCBrZXJuZWxfc3ltYm9sICpyZXNvbHZlX3N5bWJvbChzdHJ1 Y3QgbW9kdWxlICptb2QsCj4+ICAgICAgICAgICAgICAgICBnb3RvIGdldG5hbWU7Cj4+ICAgICAg ICAgfQo+Pgo+PiArICAgICAgIC8qCj4+ICsgICAgICAgICogV2UgY2FuJ3QgeWV0IHZlcmlmeSB0 aGF0IHRoZSBtb2R1bGUgYWN0dWFsbHkgaW1wb3J0cyB0aGlzCj4+ICsgICAgICAgICogbmFtZXNw YWNlLCBiZWNhdXNlIHRoZSBpbXBvcnRzIHRoZW1zZWx2ZXMgYXJlIG9ubHkgYXZhaWxhYmxlCj4+ ICsgICAgICAgICogYWZ0ZXIgcHJvY2Vzc2luZyB0aGUgc3ltYm9sIHRhYmxlIGFuZCBkb2luZyBy ZWxvY2F0aW9uOyBzbwo+PiArICAgICAgICAqIGluc3RlYWQganVzdCByZWNvcmQgdGhlIGRlcGVu ZGVuY3kgYW5kIGNoZWNrIGxhdGVyLgo+PiArICAgICAgICAqLwo+PiArICAgICAgIGlmIChzeW0t Pm5hbWVzcGFjZSkgewo+PiArICAgICAgICAgICAgICAgZXJyID0gYWRkX21vZHVsZV9uc19kZXBl bmRlbmN5KG1vZCwgc3ltLT5uYW1lc3BhY2UpOwo+PiArICAgICAgICAgICAgICAgaWYgKGVycikK Pj4gKyAgICAgICAgICAgICAgICAgICAgICAgc3ltID0gRVJSX1BUUihlcnIpOwo+PiArICAgICAg IH0KPj4gKwo+PiAgZ2V0bmFtZToKPj4gICAgICAgICAvKiBXZSBtdXN0IG1ha2UgY29weSB1bmRl ciB0aGUgbG9jayBpZiB3ZSBmYWlsZWQgdG8gZ2V0IHJlZi4gKi8KPj4gICAgICAgICBzdHJuY3B5 KG93bmVybmFtZSwgbW9kdWxlX25hbWUob3duZXIpLCBNT0RVTEVfTkFNRV9MRU4pOwo+PiBAQCAt MzA2MSw2ICszMTE4LDExIEBAIHN0YXRpYyBpbnQgZmluZF9tb2R1bGVfc2VjdGlvbnMoc3RydWN0 IG1vZHVsZSAqbW9kLCBzdHJ1Y3QgbG9hZF9pbmZvICppbmZvKQo+PiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgc2l6ZW9mKCptb2QtPmdwbF9zeW1zKSwKPj4gICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICZtb2QtPm51bV9ncGxfc3ltcyk7Cj4+ICAgICAg ICAgbW9kLT5ncGxfY3JjcyA9IHNlY3Rpb25fYWRkcihpbmZvLCAiX19rY3JjdGFiX2dwbCIpOwo+ PiArCj4+ICsgICAgICAgbW9kLT5uc19pbXBvcnRzID0gc2VjdGlvbl9vYmpzKGluZm8sICJfX2tu c2ltcG9ydCIsCj4+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNpemVv ZigqbW9kLT5uc19pbXBvcnRzKSwKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgJm1vZC0+bnVtX25zX2ltcG9ydHMpOwo+PiArCj4+ICAgICAgICAgbW9kLT5ncGxfZnV0 dXJlX3N5bXMgPSBzZWN0aW9uX29ianMoaW5mbywKPj4gICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAiX19rc3ltdGFiX2dwbF9mdXR1cmUiLAo+PiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNpemVvZigqbW9kLT5ncGxfZnV0dXJl X3N5bXMpLAo+PiBAQCAtMzM4MSw2ICszNDQzLDE5IEBAIHN0YXRpYyBpbnQgcG9zdF9yZWxvY2F0 aW9uKHN0cnVjdCBtb2R1bGUgKm1vZCwgY29uc3Qgc3RydWN0IGxvYWRfaW5mbyAqaW5mbykKPj4g ICAgICAgICByZXR1cm4gbW9kdWxlX2ZpbmFsaXplKGluZm8tPmhkciwgaW5mby0+c2VjaGRycywg bW9kKTsKPj4gIH0KPj4KPj4gK3N0YXRpYyB2b2lkIHZlcmlmeV9uYW1lc3BhY2VfZGVwZW5kZW5j aWVzKHN0cnVjdCBtb2R1bGUgKm1vZCkKPj4gK3sKPj4gKyAgICAgICBzdHJ1Y3QgbW9kdWxlX25z X2RlcCAqbnNfZGVwOwo+PiArCj4+ICsgICAgICAgbGlzdF9mb3JfZWFjaF9lbnRyeShuc19kZXAs ICZtb2QtPm5zX2RlcGVuZGVuY2llcywgbnNfZGVwKSB7Cj4+ICsgICAgICAgICAgICAgICBpZiAo IW1vZHVsZV9pbXBvcnRzX25zKG1vZCwgbnNfZGVwLT5uYW1lc3BhY2UpKSB7Cj4+ICsgICAgICAg ICAgICAgICAgICAgICAgIHByX3dhcm4oIiVzOiBtb2R1bGUgdXNlcyBzeW1ib2xzIGZyb20gbmFt ZXNwYWNlICVzLCIKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiIGJ1dCBkb2Vz IG5vdCBpbXBvcnQgaXQuXG4iLAo+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1v ZC0+bmFtZSwgbnNfZGVwLT5uYW1lc3BhY2UpOwo+PiArICAgICAgICAgICAgICAgfQo+PiArICAg ICAgIH0KPj4gK30KPj4gKwo+PiAgLyogSXMgdGhpcyBtb2R1bGUgb2YgdGhpcyBuYW1lIGRvbmUg bG9hZGluZz8gIE5vIGxvY2tzIGhlbGQuICovCj4+ICBzdGF0aWMgYm9vbCBmaW5pc2hlZF9sb2Fk aW5nKGNvbnN0IGNoYXIgKm5hbWUpCj4+ICB7Cj4+IEBAIC0zNjgyLDYgKzM3NTcsOCBAQCBzdGF0 aWMgaW50IGxvYWRfbW9kdWxlKHN0cnVjdCBsb2FkX2luZm8gKmluZm8sIGNvbnN0IGNoYXIgX191 c2VyICp1YXJncywKPj4gICAgICAgICBpZiAoZXJyKQo+PiAgICAgICAgICAgICAgICAgZ290byBm cmVlX21vZHVsZTsKPj4KPj4gKyAgICAgICBJTklUX0xJU1RfSEVBRCgmbW9kLT5uc19kZXBlbmRl bmNpZXMpOwo+PiArCj4+ICAjaWZkZWYgQ09ORklHX01PRFVMRV9TSUcKPj4gICAgICAgICBtb2Qt PnNpZ19vayA9IGluZm8tPnNpZ19vazsKPj4gICAgICAgICBpZiAoIW1vZC0+c2lnX29rKSB7Cj4+ IEBAIC0zNzMwLDYgKzM4MDcsOCBAQCBzdGF0aWMgaW50IGxvYWRfbW9kdWxlKHN0cnVjdCBsb2Fk X2luZm8gKmluZm8sIGNvbnN0IGNoYXIgX191c2VyICp1YXJncywKPj4gICAgICAgICBpZiAoZXJy IDwgMCkKPj4gICAgICAgICAgICAgICAgIGdvdG8gZnJlZV9tb2RpbmZvOwo+Pgo+PiArICAgICAg IHZlcmlmeV9uYW1lc3BhY2VfZGVwZW5kZW5jaWVzKG1vZCk7Cj4+ICsKPj4gICAgICAgICBmbHVz aF9tb2R1bGVfaWNhY2hlKG1vZCk7Cj4+Cj4+ICAgICAgICAgLyogTm93IGNvcHkgaW4gYXJncyAq Lwo+PiAtLQo+PiAyLjE4LjAuMjAzLmdmYWM2NzZkZmI5LWdvb2cKPj4KLS0tClRvIHVuc3Vic2Ny aWJlIGZyb20gdGhpcyBsaXN0OiBzZW5kIHRoZSBsaW5lICJ1bnN1YnNjcmliZSBsaW51eC11c2Ii IGluCnRoZSBib2R5IG9mIGEgbWVzc2FnZSB0byBtYWpvcmRvbW9Admdlci5rZXJuZWwub3JnCk1v cmUgbWFqb3Jkb21vIGluZm8gYXQgIGh0dHA6Ly92Z2VyLmtlcm5lbC5vcmcvbWFqb3Jkb21vLWlu Zm8uaHRtbAo=