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: Thu, 19 Jul 2018 18:32:08 +0200 Message-ID: <20180719163208.5xvrafugpcbhh7kj@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: <20180716122125.175792-3-maco@android.com> Sender: linux-kernel-owner@vger.kernel.org To: Martijn Coenen Cc: linux-kernel@vger.kernel.org, Masahiro Yamada , Michal Marek , Geert Uytterhoeven , Thomas Gleixner , Ingo Molnar , "H. Peter Anvin" , x86@kernel.org, Alan Stern , Greg Kroah-Hartman , Oliver Neukum , Arnd Bergmann , Stephen Boyd , Philippe Ombredanne , Kate Stewart , Sam Ravnborg , linux-kbuild@vger.kernel.org, linux-m68k@lists.linux-m68k.org, linux-usb@vger.kernel.org, usb-storage@lists.one-eyed-alien.net, linux-scsi@vger.kernel.org, linux-arc List-Id: linux-arch.vger.kernel.org +++ Martijn Coenen [16/07/18 14:21 +0200]: >The EXPORT_SYMBOL_NS() and EXPORT_SYMBOL_NS_GPL() macros can be used to >export a symbol to a specific namespace. There are no _GPL_FUTURE and >_UNUSED variants because these are currently unused, and I'm not sure >they are necessary. > >I didn't add EXPORT_SYMBOL_NS() for ASM exports; this patch sets the >namespace of ASM exports to NULL by default. If there's a need, this >should be pretty easy to add. > >A module that wants to use a symbol exported to a namespace must add a >MODULE_IMPORT_NS() statement to their module code; otherwise, modpost >will complain when building the module, and the kernel module loader >will warn when loading the module. > >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. > >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); >+ } >+ First, thanks a lot for the patchset. This is definitely something that will help distros as well to declutter the exported symbol space and provide a more cleanly defined kernel interface. Hm, I'm wondering if we could avoid all this extra module-ns-dependency checking work if we just put the import stuff as a modinfo tag, like have MODULE_IMPORT_NS() insert an "import:" tag like we already do for module parameters, author, license, aliases, etc. Then we'd have that information pretty much from the start of load_module() and we don't need to wait for relocations to be applied to __knsimport. Then you could do the namespace checking right at resolve_symbol() instead of going through the extra step of building a dependency list to be verified later. Also, this would get rid of the extra __knsimport section, the extra ns_dependencies field in struct module, and all those helper functions that manage it. In addition, having the modinfo tag may potentially help with debugging as we have the namespace imports clearly listed if we don't have the source code for a module. We'd probably need to modify get_modinfo() to handle multiple import: tags though. Luis [1] had written some code a while ago to handle multiple (of the same) modinfo tags. Thoughts on this? Thanks, Jessica [1] https://lkml.kernel.org/r/20171130023605.29568-3-mcgrof@kernel.org > 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]:46606 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731983AbeGSRQN (ORCPT ); Thu, 19 Jul 2018 13:16:13 -0400 Date: Thu, 19 Jul 2018 18:32:08 +0200 From: Jessica Yu Subject: Re: [PATCH 2/6] module: add support for symbol namespaces. Message-ID: <20180719163208.5xvrafugpcbhh7kj@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: <20180716122125.175792-3-maco@android.com> Sender: linux-arch-owner@vger.kernel.org List-ID: To: Martijn Coenen Cc: linux-kernel@vger.kernel.org, Masahiro Yamada , Michal Marek , Geert Uytterhoeven , Thomas Gleixner , Ingo Molnar , "H. Peter Anvin" , x86@kernel.org, Alan Stern , Greg Kroah-Hartman , Oliver Neukum , Arnd Bergmann , Stephen Boyd , Philippe Ombredanne , Kate Stewart , Sam Ravnborg , linux-kbuild@vger.kernel.org, linux-m68k@lists.linux-m68k.org, linux-usb@vger.kernel.org, usb-storage@lists.one-eyed-alien.net, linux-scsi@vger.kernel.org, linux-arch@vger.kernel.org, maco@google.com, sspatil@google.com, malchev@google.com, joelaf@google.com Message-ID: <20180719163208._-RMhZd_kHMh8ltJ_8FURmBHs8qhTgOuoQVjPpT6w0k@z> +++ Martijn Coenen [16/07/18 14:21 +0200]: >The EXPORT_SYMBOL_NS() and EXPORT_SYMBOL_NS_GPL() macros can be used to >export a symbol to a specific namespace. There are no _GPL_FUTURE and >_UNUSED variants because these are currently unused, and I'm not sure >they are necessary. > >I didn't add EXPORT_SYMBOL_NS() for ASM exports; this patch sets the >namespace of ASM exports to NULL by default. If there's a need, this >should be pretty easy to add. > >A module that wants to use a symbol exported to a namespace must add a >MODULE_IMPORT_NS() statement to their module code; otherwise, modpost >will complain when building the module, and the kernel module loader >will warn when loading the module. > >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. > >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); >+ } >+ First, thanks a lot for the patchset. This is definitely something that will help distros as well to declutter the exported symbol space and provide a more cleanly defined kernel interface. Hm, I'm wondering if we could avoid all this extra module-ns-dependency checking work if we just put the import stuff as a modinfo tag, like have MODULE_IMPORT_NS() insert an "import:" tag like we already do for module parameters, author, license, aliases, etc. Then we'd have that information pretty much from the start of load_module() and we don't need to wait for relocations to be applied to __knsimport. Then you could do the namespace checking right at resolve_symbol() instead of going through the extra step of building a dependency list to be verified later. Also, this would get rid of the extra __knsimport section, the extra ns_dependencies field in struct module, and all those helper functions that manage it. In addition, having the modinfo tag may potentially help with debugging as we have the namespace imports clearly listed if we don't have the source code for a module. We'd probably need to modify get_modinfo() to handle multiple import: tags though. Luis [1] had written some code a while ago to handle multiple (of the same) modinfo tags. Thoughts on this? Thanks, Jessica [1] https://lkml.kernel.org/r/20171130023605.29568-3-mcgrof@kernel.org > 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: <20180719163208.5xvrafugpcbhh7kj@linux-8ccs> Date: Thu, 19 Jul 2018 18:32:08 +0200 To: Martijn Coenen Cc: linux-kernel@vger.kernel.org, Masahiro Yamada , Michal Marek , Geert Uytterhoeven , Thomas Gleixner , Ingo Molnar , "H. Peter Anvin" , x86@kernel.org, Alan Stern , Greg Kroah-Hartman , Oliver Neukum , Arnd Bergmann , Stephen Boyd , Philippe Ombredanne , Kate Stewart , Sam Ravnborg , linux-kbuild@vger.kernel.org, linux-m68k@lists.linux-m68k.org, linux-usb@vger.kernel.org, usb-storage@lists.one-eyed-alien.net, linux-scsi@vger.kernel.org, linux-arch@vger.kernel.org, maco@google.com, sspatil@google.com, malchev@google.com, joelaf@google.com List-ID: KysrIE1hcnRpam4gQ29lbmVuIFsxNi8wNy8xOCAxNDoyMSArMDIwMF06Cj5UaGUgRVhQT1JUX1NZ TUJPTF9OUygpIGFuZCBFWFBPUlRfU1lNQk9MX05TX0dQTCgpIG1hY3JvcyBjYW4gYmUgdXNlZCB0 bwo+ZXhwb3J0IGEgc3ltYm9sIHRvIGEgc3BlY2lmaWMgbmFtZXNwYWNlLiAgVGhlcmUgYXJlIG5v IF9HUExfRlVUVVJFIGFuZAo+X1VOVVNFRCB2YXJpYW50cyBiZWNhdXNlIHRoZXNlIGFyZSBjdXJy ZW50bHkgdW51c2VkLCBhbmQgSSdtIG5vdCBzdXJlCj50aGV5IGFyZSBuZWNlc3NhcnkuCj4KPkkg ZGlkbid0IGFkZCBFWFBPUlRfU1lNQk9MX05TKCkgZm9yIEFTTSBleHBvcnRzOyB0aGlzIHBhdGNo IHNldHMgdGhlCj5uYW1lc3BhY2Ugb2YgQVNNIGV4cG9ydHMgdG8gTlVMTCBieSBkZWZhdWx0LiBJ ZiB0aGVyZSdzIGEgbmVlZCwgdGhpcwo+c2hvdWxkIGJlIHByZXR0eSBlYXN5IHRvIGFkZC4KPgo+ QSBtb2R1bGUgdGhhdCB3YW50cyB0byB1c2UgYSBzeW1ib2wgZXhwb3J0ZWQgdG8gYSBuYW1lc3Bh Y2UgbXVzdCBhZGQgYQo+TU9EVUxFX0lNUE9SVF9OUygpIHN0YXRlbWVudCB0byB0aGVpciBtb2R1 bGUgY29kZTsgb3RoZXJ3aXNlLCBtb2Rwb3N0Cj53aWxsIGNvbXBsYWluIHdoZW4gYnVpbGRpbmcg dGhlIG1vZHVsZSwgYW5kIHRoZSBrZXJuZWwgbW9kdWxlIGxvYWRlcgo+d2lsbCB3YXJuIHdoZW4g bG9hZGluZyB0aGUgbW9kdWxlLgo+Cj5UaGUgRUxGIHN5bWJvbHMgYXJlIHJlbmFtZWQgdG8gaW5j bHVkZSB0aGUgbmFtZXNwYWNlIHdpdGggYW4gYXNtIGxhYmVsOwo+Zm9yIGV4YW1wbGUsIHN5bWJv bCAndXNiX3N0b3Jfc3VzcGVuZCcgaW4gbmFtZXNwYWNlIFVTQl9TVE9SQUdFIGJlY29tZXMKPid1 c2Jfc3Rvcl9zdXNwZW5kLlVTQl9TVE9SQUdFJy4gIFRoaXMgYWxsb3dzIG1vZHBvc3QgdG8gZG8g bmFtZXNwYWNlCj5jaGVja2luZywgd2l0aG91dCBoYXZpbmcgdG8gZ28gdGhyb3VnaCBhbGwgdGhl IGVmZm9ydCBvZiBwYXJzaW5nIEVMRiBhbmQKPnJlbG9jdGlvbiByZWNvcmRzIGp1c3QgdG8gZ2V0 IHRvIHRoZSBzdHJ1Y3Qga2VybmVsX3N5bWJvbHMuCj4KPk9uIHg4Nl82NCBJIHNhdyBubyBkaWZm ZXJlbmNlIGluIGJpbmFyeSBzaXplIChjb21wcmVzc2lvbiksIGJ1dCBhdAo+cnVudGltZSB0aGlz IHdpbGwgcmVxdWlyZSBhIHdvcmQgb2YgbWVtb3J5IHBlciBleHBvcnQgdG8gaG9sZCB0aGUKPm5h bWVzcGFjZS4gQW4gYWx0ZXJuYXRpdmUgY291bGQgYmUgdG8gc3RvcmUgbmFtZXNwYWNlZCBzeW1i b2xzIGluIHRoZWlyCj5vd24gc2VjdGlvbiBhbmQgdXNlIGEgc2VwYXJhdGUgJ3N0cnVjdCBuYW1l c3BhY2VkX2tlcm5lbF9zeW1ib2wnIGZvcgo+dGhhdCBzZWN0aW9uLCBhdCB0aGUgY29zdCBvZiBt YWtpbmcgdGhlIG1vZHVsZSBsb2FkZXIgbW9yZSBjb21wbGV4Lgo+Cj5TaWduZWQtb2ZmLWJ5OiBN YXJ0aWpuIENvZW5lbiA8bWFjb0BhbmRyb2lkLmNvbT4KPi0tLQo+IGluY2x1ZGUvYXNtLWdlbmVy aWMvZXhwb3J0LmggfCAgMiArLQo+IGluY2x1ZGUvbGludXgvZXhwb3J0LmggICAgICAgfCA4MyAr KysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0KPiBpbmNsdWRlL2xpbnV4L21vZHVs ZS5oICAgICAgIHwgMTMgKysrKysrCj4ga2VybmVsL21vZHVsZS5jICAgICAgICAgICAgICB8IDc5 ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiA0IGZpbGVzIGNoYW5nZWQsIDE1 NiBpbnNlcnRpb25zKCspLCAyMSBkZWxldGlvbnMoLSkKPgo+ZGlmZiAtLWdpdCBhL2luY2x1ZGUv YXNtLWdlbmVyaWMvZXhwb3J0LmggYi9pbmNsdWRlL2FzbS1nZW5lcmljL2V4cG9ydC5oCj5pbmRl eCA2OGVmYjk1MGE5MTguLjRjM2QxYWZiNzAyZiAxMDA2NDQKPi0tLSBhL2luY2x1ZGUvYXNtLWdl bmVyaWMvZXhwb3J0LmgKPisrKyBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvZXhwb3J0LmgKPkBAIC0y OSw3ICsyOSw3IEBACj4gCS5zZWN0aW9uIF9fX2tzeW10YWJcc2VjK1xuYW1lLCJhIgo+IAkuYmFs aWduIEtTWU1fQUxJR04KPiBfX2tzeW10YWJfXG5hbWU6Cj4tCV9fcHV0IFx2YWwsIF9fa3N0cnRh Yl9cbmFtZQo+KwlfX3B1dCBcdmFsLCBfX2tzdHJ0YWJfXG5hbWUsIDAKPiAJLnByZXZpb3VzCj4g CS5zZWN0aW9uIF9fa3N5bXRhYl9zdHJpbmdzLCJhIgo+IF9fa3N0cnRhYl9cbmFtZToKPmRpZmYg LS1naXQgYS9pbmNsdWRlL2xpbnV4L2V4cG9ydC5oIGIvaW5jbHVkZS9saW51eC9leHBvcnQuaAo+ aW5kZXggYWQ2YjhlNjk3YjI3Li45ZjZlNzBlZWI4NWYgMTAwNjQ0Cj4tLS0gYS9pbmNsdWRlL2xp bnV4L2V4cG9ydC5oCj4rKysgYi9pbmNsdWRlL2xpbnV4L2V4cG9ydC5oCj5AQCAtMjIsNiArMjIs MTEgQEAgc3RydWN0IGtlcm5lbF9zeW1ib2wKPiB7Cj4gCXVuc2lnbmVkIGxvbmcgdmFsdWU7Cj4g CWNvbnN0IGNoYXIgKm5hbWU7Cj4rCWNvbnN0IGNoYXIgKm5hbWVzcGFjZTsKPit9Owo+Kwo+K3N0 cnVjdCBuYW1lc3BhY2VfaW1wb3J0IHsKPisJY29uc3QgY2hhciAqbmFtZXNwYWNlOwo+IH07Cj4K PiAjaWZkZWYgTU9EVUxFCj5AQCAtNTQsMTggKzU5LDI4IEBAIGV4dGVybiBzdHJ1Y3QgbW9kdWxl IF9fdGhpc19tb2R1bGU7Cj4gI2RlZmluZSBfX0NSQ19TWU1CT0woc3ltLCBzZWMpCj4gI2VuZGlm Cj4KPisjZGVmaW5lIE5TX1NFUEFSQVRPUiAiLiIKPisKPisjZGVmaW5lIE1PRFVMRV9JTVBPUlRf TlMobnMpCQkJCQkJXAo+KwlzdGF0aWMgY29uc3Qgc3RydWN0IG5hbWVzcGFjZV9pbXBvcnQgX19r bnNpbXBvcnRfIyNucwkJXAo+Kwlhc20oIl9fa25zaW1wb3J0XyIgI25zKQkJCQkJCVwKPisJX19h dHRyaWJ1dGVfXygoc2VjdGlvbigiX19rbnNpbXBvcnQiKSwgdXNlZCkpCQkJXAo+Kwk9IHsgI25z IH0KPisKPiAvKiBGb3IgZXZlcnkgZXhwb3J0ZWQgc3ltYm9sLCBwbGFjZSBhIHN0cnVjdCBpbiB0 aGUgX19rc3ltdGFiIHNlY3Rpb24gKi8KPi0jZGVmaW5lIF9fX0VYUE9SVF9TWU1CT0woc3ltLCBz ZWMpCQkJCQlcCj4rI2RlZmluZSBfX19FWFBPUlRfU1lNQk9MKHN5bSwgc2VjLCBucywgbnNwb3N0 LCBuc3Bvc3QyKQkJCVwKPiAJZXh0ZXJuIHR5cGVvZihzeW0pIHN5bTsJCQkJCQlcCj4gCV9fQ1JD X1NZTUJPTChzeW0sIHNlYykJCQkJCQlcCj4tCXN0YXRpYyBjb25zdCBjaGFyIF9fa3N0cnRhYl8j I3N5bVtdCQkJCVwKPisJc3RhdGljIGNvbnN0IGNoYXIgX19rc3RydGFiXyMjc3ltIyNuc3Bvc3Rb XQkJCVwKPiAJX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX19rc3ltdGFiX3N0cmluZ3MiKSwgYWxp Z25lZCgxKSkpCVwKPiAJPSAjc3ltOwkJCQkJCQkJXAo+LQlzdGF0aWMgY29uc3Qgc3RydWN0IGtl cm5lbF9zeW1ib2wgX19rc3ltdGFiXyMjc3ltCQlcCj4rCXN0YXRpYyBjb25zdCBzdHJ1Y3Qga2Vy bmVsX3N5bWJvbCBfX2tzeW10YWJfIyNzeW0jI25zcG9zdAlcCj4rCWFzbSgiX19rc3ltdGFiXyIg I3N5bSBuc3Bvc3QyKSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCj4gCV9fdXNl ZAkJCQkJCQkJXAo+LQlfX2F0dHJpYnV0ZV9fKChzZWN0aW9uKCJfX19rc3ltdGFiIiBzZWMgIisi ICNzeW0pLCB1c2VkKSkJXAo+KwlfX2F0dHJpYnV0ZV9fKChzZWN0aW9uKCJfX19rc3ltdGFiIiBz ZWMgIisiICNzeW0gI25zcG9zdCkpKQlcCj4rCV9fYXR0cmlidXRlX18oKHVzZWQpKQkJCQkJCVwK PiAJX19hdHRyaWJ1dGVfXygoYWxpZ25lZChzaXplb2Yodm9pZCAqKSkpKSAgICAgICAgICAgICAg ICAgICAgICAgIFwKPi0JPSB7ICh1bnNpZ25lZCBsb25nKSZzeW0sIF9fa3N0cnRhYl8jI3N5bSB9 Cj4rCT0geyAodW5zaWduZWQgbG9uZykmc3ltLCBfX2tzdHJ0YWJfIyNzeW0jI25zcG9zdCwgbnMg fQo+Cj4gI2lmIGRlZmluZWQoX19LU1lNX0RFUFNfXykKPgo+QEAgLTc2LDUyICs5MSw4MCBAQCBl eHRlcm4gc3RydWN0IG1vZHVsZSBfX3RoaXNfbW9kdWxlOwo+ICAqIHN5c3RlbSBmaWx0ZXJzIG91 dCBmcm9tIHRoZSBwcmVwcm9jZXNzb3Igb3V0cHV0IChzZWUga3N5bV9kZXBfZmlsdGVyCj4gICog aW4gc2NyaXB0cy9LYnVpbGQuaW5jbHVkZSkuCj4gICovCj4tI2RlZmluZSBfX0VYUE9SVF9TWU1C T0woc3ltLCBzZWMpCT09PSBfX0tTWU1fIyNzeW0gPT09Cj4rI2RlZmluZSBfX0VYUE9SVF9TWU1C T0woc3ltLCBzZWMsIG5zLCBuc3Bvc3QsIG5zcG9zdDIpCT09PSBfX0tTWU1fIyNzeW0gPT09Cj4K PiAjZWxpZiBkZWZpbmVkKENPTkZJR19UUklNX1VOVVNFRF9LU1lNUykKPgo+ICNpbmNsdWRlIDxn ZW5lcmF0ZWQvYXV0b2tzeW1zLmg+Cj4KPi0jZGVmaW5lIF9fRVhQT1JUX1NZTUJPTChzeW0sIHNl YykJCQkJXAo+LQlfX2NvbmRfZXhwb3J0X3N5bShzeW0sIHNlYywgX19pc19kZWZpbmVkKF9fS1NZ TV8jI3N5bSkpCj4tI2RlZmluZSBfX2NvbmRfZXhwb3J0X3N5bShzeW0sIHNlYywgY29uZikJCQlc Cj4tCV9fX2NvbmRfZXhwb3J0X3N5bShzeW0sIHNlYywgY29uZikKPi0jZGVmaW5lIF9fX2NvbmRf ZXhwb3J0X3N5bShzeW0sIHNlYywgZW5hYmxlZCkJCQlcCj4tCV9fY29uZF9leHBvcnRfc3ltXyMj ZW5hYmxlZChzeW0sIHNlYykKPi0jZGVmaW5lIF9fY29uZF9leHBvcnRfc3ltXzEoc3ltLCBzZWMp IF9fX0VYUE9SVF9TWU1CT0woc3ltLCBzZWMpCj4tI2RlZmluZSBfX2NvbmRfZXhwb3J0X3N5bV8w KHN5bSwgc2VjKSAvKiBub3RoaW5nICovCj4rI2RlZmluZSBfX0VYUE9SVF9TWU1CT0woc3ltLCBz ZWMsIG5zLCBuc3Bvc3QsIG5zcG9zdDIpCQkJXAo+KwlfX2NvbmRfZXhwb3J0X3N5bShzeW0sIHNl YywgbnMsIG5zcG9zdCwgbnNwb3N0MiwJCVwKPisJCQkgIF9faXNfZGVmaW5lZChfX0tTWU1fIyNz eW0pKQo+KyNkZWZpbmUgX19jb25kX2V4cG9ydF9zeW0oc3ltLCBzZWMsIG5zLCBuc3Bvc3QsIG5z cG9zdDIsIGNvbmYpCQlcCj4rCV9fX2NvbmRfZXhwb3J0X3N5bShzeW0sIHNlYywgbnMsIG5zcG9z dCwgbnNwb3N0MiwgY29uZikKPisjZGVmaW5lIF9fX2NvbmRfZXhwb3J0X3N5bShzeW0sIHNlYywg bnMsIG5zcG9zdCwgbnNwb3N0MiwgZW5hYmxlZCkJXAo+KwlfX2NvbmRfZXhwb3J0X3N5bV8jI2Vu YWJsZWQoc3ltLCBzZWMsIG5zLCBuc3Bvc3QsIG5zcG9zdDIpCj4rI2RlZmluZSBfX2NvbmRfZXhw b3J0X3N5bV8xKHN5bSwgc2VjLCBucywgbnNwb3N0LCBuc3Bvc3QyKQkJXAo+KwlfX19FWFBPUlRf U1lNQk9MKHN5bSwgc2VjLCBucywgbnNwb3N0LCBuc3Bvc3QyKQo+KyNkZWZpbmUgX19jb25kX2V4 cG9ydF9zeW1fMChzeW0sIHNlYywgbnMsIG5zcG9zdCwgbnNwb3N0MikgLyogbm90aGluZyAqLwo+ Cj4gI2Vsc2UKPiAjZGVmaW5lIF9fRVhQT1JUX1NZTUJPTCBfX19FWFBPUlRfU1lNQk9MCj4gI2Vu ZGlmCj4KPiAjZGVmaW5lIEVYUE9SVF9TWU1CT0woc3ltKQkJCQkJXAo+LQlfX0VYUE9SVF9TWU1C T0woc3ltLCAiIikKPisJX19FWFBPUlRfU1lNQk9MKHN5bSwgIiIsIE5VTEwsICwpCj4KPiAjZGVm aW5lIEVYUE9SVF9TWU1CT0xfR1BMKHN5bSkJCQkJCVwKPi0JX19FWFBPUlRfU1lNQk9MKHN5bSwg Il9ncGwiKQo+KwlfX0VYUE9SVF9TWU1CT0woc3ltLCAiX2dwbCIsIE5VTEwsICwpCj4KPiAjZGVm aW5lIEVYUE9SVF9TWU1CT0xfR1BMX0ZVVFVSRShzeW0pCQkJCVwKPi0JX19FWFBPUlRfU1lNQk9M KHN5bSwgIl9ncGxfZnV0dXJlIikKPisJX19FWFBPUlRfU1lNQk9MKHN5bSwgIl9ncGxfZnV0dXJl IiwgTlVMTCwgLCkKPisKPisjZGVmaW5lIEVYUE9SVF9TWU1CT0xfTlMoc3ltLCBucykgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgXAo+KwlfX0VYUE9SVF9TWU1CT0woc3ltLCAiIiwgI25z LCBfXyMjbnMsIE5TX1NFUEFSQVRPUiAjbnMpCj4rCj4rI2RlZmluZSBFWFBPUlRfU1lNQk9MX05T X0dQTChzeW0sIG5zKSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCj4rCV9fRVhQT1JU X1NZTUJPTChzeW0sICJfZ3BsIiwgI25zLCBfXyMjbnMsIE5TX1NFUEFSQVRPUiAjbnMpCj4KPiAj aWZkZWYgQ09ORklHX1VOVVNFRF9TWU1CT0xTCj4tI2RlZmluZSBFWFBPUlRfVU5VU0VEX1NZTUJP TChzeW0pIF9fRVhQT1JUX1NZTUJPTChzeW0sICJfdW51c2VkIikKPi0jZGVmaW5lIEVYUE9SVF9V TlVTRURfU1lNQk9MX0dQTChzeW0pIF9fRVhQT1JUX1NZTUJPTChzeW0sICJfdW51c2VkX2dwbCIp Cj4rI2RlZmluZSBFWFBPUlRfVU5VU0VEX1NZTUJPTChzeW0pIF9fRVhQT1JUX1NZTUJPTChzeW0s ICJfdW51c2VkIiwgLCAsKQo+KyNkZWZpbmUgRVhQT1JUX1VOVVNFRF9TWU1CT0xfR1BMKHN5bSkg X19FWFBPUlRfU1lNQk9MKHN5bSwgIl91bnVzZWRfZ3BsIiwgLCAsKQo+ICNlbHNlCj4gI2RlZmlu ZSBFWFBPUlRfVU5VU0VEX1NZTUJPTChzeW0pCj4gI2RlZmluZSBFWFBPUlRfVU5VU0VEX1NZTUJP TF9HUEwoc3ltKQo+ICNlbmRpZgo+Cj4tI2VuZGlmCS8qIF9fR0VOS1NZTVNfXyAqLwo+KyNlbmRp ZgkvKiBfX0tFUk5FTF9fICYmICFfX0dFTktTWU1TX18gKi8KPisKPisjaWYgZGVmaW5lZChfX0dF TktTWU1TX18pCj4rLyoKPisgKiBXaGVuIHdlJ3JlIHJ1bm5pbmcgZ2Vua3N5bXMsIGlnbm9yZSB0 aGUgbmFtZXNwYWNlIGFuZCBtYWtlIHRoZSBfTlMKPisgKiB2YXJpYW50cyBsb29rIGxpa2UgdGhl IG5vcm1hbCBvbmVzLiBUaGVyZSBhcmUgdHdvIHJlYXNvbnMgZm9yIHRoaXM6Cj4rICogMSkgSW4g dGhlIG5vcm1hbCBkZWZpbml0aW9uIG9mIEVYUE9SVF9TWU1CT0xfTlMsIHRoZSAnbnMnIG1hY3Jv Cj4rICogICAgYXJndW1lbnQgaXMgaXRzZWxmIG5vdCBleHBhbmRlZCBiZWNhdXNlIGl0J3MgYWx3 YXlzIHRva2VuaXplZCBvcgo+KyAqICAgIGNvbmNhdGVuYXRlZDsgYnV0IHdoZW4gcnVubmluZyBn ZW5rc3ltcywgYSBibGFuayBkZWZpbml0aW9uIG9mIHRoZQo+KyAqICAgIG1hY3JvIGRvZXMgYWxs b3cgdGhlIGFyZ3VtZW50IHRvIGJlIGV4cGFuZGVkOyBpZiBhIG5hbWVzcGFjZQo+KyAqICAgIGhh cHBlbnMgdG8gY29sbGlkZSB3aXRoIGEgI2RlZmluZSwgdGhpcyBjYW4gY2F1c2UgaXNzdWVzLgo+ KyAqIDIpIFRoZXJlJ3Mgbm8gbmVlZCB0byBtb2RpZnkgZ2Vua3N5bXMgdG8gZGVhbCB3aXRoIHRo ZSBfTlMgdmFyaWFudHMKPisgKi8KPisjZGVmaW5lIEVYUE9SVF9TWU1CT0xfTlMoc3ltLCBucykg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCj4rCUVYUE9SVF9TWU1CT0woc3ltKQo+KyNk ZWZpbmUgRVhQT1JUX1NZTUJPTF9OU19HUEwoc3ltLCBucykgICAgICAgICAgICAgICAgICAgICAg ICAgIFwKPisJRVhQT1JUX1NZTUJPTF9HUEwoc3ltKQo+KyNlbmRpZgo+Cj4gI2Vsc2UgLyogIUNP TkZJR19NT0RVTEVTLi4uICovCj4KPiAjZGVmaW5lIEVYUE9SVF9TWU1CT0woc3ltKQo+KyNkZWZp bmUgRVhQT1JUX1NZTUJPTF9OUyhzeW0sIG5zKQo+KyNkZWZpbmUgRVhQT1JUX1NZTUJPTF9OU19H UEwoc3ltLCBucykKPiAjZGVmaW5lIEVYUE9SVF9TWU1CT0xfR1BMKHN5bSkKPiAjZGVmaW5lIEVY UE9SVF9TWU1CT0xfR1BMX0ZVVFVSRShzeW0pCj4gI2RlZmluZSBFWFBPUlRfVU5VU0VEX1NZTUJP TChzeW0pCj4gI2RlZmluZSBFWFBPUlRfVU5VU0VEX1NZTUJPTF9HUEwoc3ltKQo+Cj4rI2RlZmlu ZSBNT0RVTEVfSU1QT1JUX05TKG5zKQo+ICNlbmRpZiAvKiBDT05GSUdfTU9EVUxFUyAqLwo+ICNl bmRpZiAvKiAhX19BU1NFTUJMWV9fICovCj4KPmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21v ZHVsZS5oIGIvaW5jbHVkZS9saW51eC9tb2R1bGUuaAo+aW5kZXggZDQ0ZGY5YjJjMTMxLi5hZmFi NGU4ZmExODggMTAwNjQ0Cj4tLS0gYS9pbmNsdWRlL2xpbnV4L21vZHVsZS5oCj4rKysgYi9pbmNs dWRlL2xpbnV4L21vZHVsZS5oCj5AQCAtMjY4LDYgKzI2OCwxMiBAQCB2b2lkICpfX3N5bWJvbF9n ZXQoY29uc3QgY2hhciAqc3ltYm9sKTsKPiB2b2lkICpfX3N5bWJvbF9nZXRfZ3BsKGNvbnN0IGNo YXIgKnN5bWJvbCk7Cj4gI2RlZmluZSBzeW1ib2xfZ2V0KHgpICgodHlwZW9mKCZ4KSkoX19zeW1i b2xfZ2V0KFZNTElOVVhfU1lNQk9MX1NUUih4KSkpKQo+Cj4rLyogbmFtZXNwYWNlIGRlcGVuZGVu Y2llcyBvZiB0aGUgbW9kdWxlICovCj4rc3RydWN0IG1vZHVsZV9uc19kZXAgewo+KwlzdHJ1Y3Qg bGlzdF9oZWFkIG5zX2RlcDsKPisJY29uc3QgY2hhciAqbmFtZXNwYWNlOwo+K307Cj4rCj4gLyog bW9kdWxlcyB1c2luZyBvdGhlciBtb2R1bGVzOiBrZGIgd2FudHMgdG8gc2VlIHRoaXMuICovCj4g c3RydWN0IG1vZHVsZV91c2Ugewo+IAlzdHJ1Y3QgbGlzdF9oZWFkIHNvdXJjZV9saXN0Owo+QEAg LTM1OSw2ICszNjUsMTMgQEAgc3RydWN0IG1vZHVsZSB7Cj4gCWNvbnN0IHN0cnVjdCBrZXJuZWxf c3ltYm9sICpncGxfc3ltczsKPiAJY29uc3QgczMyICpncGxfY3JjczsKPgo+KwkvKiBOYW1lc3Bh Y2UgaW1wb3J0cyAqLwo+Kwl1bnNpZ25lZCBpbnQgbnVtX25zX2ltcG9ydHM7Cj4rCWNvbnN0IHN0 cnVjdCBuYW1lc3BhY2VfaW1wb3J0ICpuc19pbXBvcnRzOwo+Kwo+KwkvKiBOYW1lc3BhY2UgZGVw ZW5kZW5jaWVzICovCj4rCXN0cnVjdCBsaXN0X2hlYWQgbnNfZGVwZW5kZW5jaWVzOwo+Kwo+ICNp ZmRlZiBDT05GSUdfVU5VU0VEX1NZTUJPTFMKPiAJLyogdW51c2VkIGV4cG9ydGVkIHN5bWJvbHMu ICovCj4gCWNvbnN0IHN0cnVjdCBrZXJuZWxfc3ltYm9sICp1bnVzZWRfc3ltczsKPmRpZmYgLS1n aXQgYS9rZXJuZWwvbW9kdWxlLmMgYi9rZXJuZWwvbW9kdWxlLmMKPmluZGV4IGY0NzVmMzBlZWQ4 Yy4uNjNkZTBmZTg0OWY5IDEwMDY0NAo+LS0tIGEva2VybmVsL21vZHVsZS5jCj4rKysgYi9rZXJu ZWwvbW9kdWxlLmMKPkBAIC0xMTY2LDYgKzExNjYsNTEgQEAgc3RhdGljIGlubGluZSBpbnQgbW9k dWxlX3VubG9hZF9pbml0KHN0cnVjdCBtb2R1bGUgKm1vZCkKPiB9Cj4gI2VuZGlmIC8qIENPTkZJ R19NT0RVTEVfVU5MT0FEICovCj4KPitzdGF0aWMgYm9vbCBtb2R1bGVfaGFzX25zX2RlcGVuZGVu Y3koc3RydWN0IG1vZHVsZSAqbW9kLCBjb25zdCBjaGFyICpucykKPit7Cj4rCXN0cnVjdCBtb2R1 bGVfbnNfZGVwICpuc19kZXA7Cj4rCj4rCWxpc3RfZm9yX2VhY2hfZW50cnkobnNfZGVwLCAmbW9k LT5uc19kZXBlbmRlbmNpZXMsIG5zX2RlcCkgewo+KwkJaWYgKHN0cmNtcChuc19kZXAtPm5hbWVz cGFjZSwgbnMpID09IDApCj4rCQkJcmV0dXJuIHRydWU7Cj4rCX0KPisKPisJcmV0dXJuIGZhbHNl Owo+K30KPisKPitzdGF0aWMgaW50IGFkZF9tb2R1bGVfbnNfZGVwZW5kZW5jeShzdHJ1Y3QgbW9k dWxlICptb2QsIGNvbnN0IGNoYXIgKm5zKQo+K3sKPisJc3RydWN0IG1vZHVsZV9uc19kZXAgKm5z X2RlcDsKPisKPisJaWYgKG1vZHVsZV9oYXNfbnNfZGVwZW5kZW5jeShtb2QsIG5zKSkKPisJCXJl dHVybiAwOwo+Kwo+Kwluc19kZXAgPSBrbWFsbG9jKHNpemVvZigqbnNfZGVwKSwgR0ZQX0FUT01J Qyk7Cj4rCWlmICghbnNfZGVwKQo+KwkJcmV0dXJuIC1FTk9NRU07Cj4rCj4rCW5zX2RlcC0+bmFt ZXNwYWNlID0gbnM7Cj4rCj4rCWxpc3RfYWRkKCZuc19kZXAtPm5zX2RlcCwgJm1vZC0+bnNfZGVw ZW5kZW5jaWVzKTsKPisKPisJcmV0dXJuIDA7Cj4rfQo+Kwo+K3N0YXRpYyBib29sIG1vZHVsZV9p bXBvcnRzX25zKHN0cnVjdCBtb2R1bGUgKm1vZCwgY29uc3QgY2hhciAqbnMpCj4rewo+KwlzaXpl X3QgaTsKPisKPisJaWYgKCFucykKPisJCXJldHVybiB0cnVlOwo+Kwo+Kwlmb3IgKGkgPSAwOyBp IDwgbW9kLT5udW1fbnNfaW1wb3J0czsgKytpKSB7Cj4rCQlpZiAoIXN0cmNtcChtb2QtPm5zX2lt cG9ydHNbaV0ubmFtZXNwYWNlLCBucykpCj4rCQkJcmV0dXJuIHRydWU7Cj4rCX0KPisKPisJcmV0 dXJuIGZhbHNlOwo+K30KPisKPiBzdGF0aWMgc2l6ZV90IG1vZHVsZV9mbGFnc190YWludChzdHJ1 Y3QgbW9kdWxlICptb2QsIGNoYXIgKmJ1ZikKPiB7Cj4gCXNpemVfdCBsID0gMDsKPkBAIC0xNDE1 LDYgKzE0NjAsMTggQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBrZXJuZWxfc3ltYm9sICpyZXNvbHZl X3N5bWJvbChzdHJ1Y3QgbW9kdWxlICptb2QsCj4gCQlnb3RvIGdldG5hbWU7Cj4gCX0KPgo+Kwkv Kgo+KwkgKiBXZSBjYW4ndCB5ZXQgdmVyaWZ5IHRoYXQgdGhlIG1vZHVsZSBhY3R1YWxseSBpbXBv cnRzIHRoaXMKPisJICogbmFtZXNwYWNlLCBiZWNhdXNlIHRoZSBpbXBvcnRzIHRoZW1zZWx2ZXMg YXJlIG9ubHkgYXZhaWxhYmxlCj4rCSAqIGFmdGVyIHByb2Nlc3NpbmcgdGhlIHN5bWJvbCB0YWJs ZSBhbmQgZG9pbmcgcmVsb2NhdGlvbjsgc28KPisJICogaW5zdGVhZCBqdXN0IHJlY29yZCB0aGUg ZGVwZW5kZW5jeSBhbmQgY2hlY2sgbGF0ZXIuCj4rCSAqLwo+KwlpZiAoc3ltLT5uYW1lc3BhY2Up IHsKPisJCWVyciA9IGFkZF9tb2R1bGVfbnNfZGVwZW5kZW5jeShtb2QsIHN5bS0+bmFtZXNwYWNl KTsKPisJCWlmIChlcnIpCj4rCQkJc3ltID0gRVJSX1BUUihlcnIpOwo+Kwl9Cj4rCgpGaXJzdCwg dGhhbmtzIGEgbG90IGZvciB0aGUgcGF0Y2hzZXQuIFRoaXMgaXMgZGVmaW5pdGVseSBzb21ldGhp bmcgdGhhdAp3aWxsIGhlbHAgZGlzdHJvcyBhcyB3ZWxsIHRvIGRlY2x1dHRlciB0aGUgZXhwb3J0 ZWQgc3ltYm9sIHNwYWNlIGFuZApwcm92aWRlIGEgbW9yZSBjbGVhbmx5IGRlZmluZWQga2VybmVs IGludGVyZmFjZS4KCkhtLCBJJ20gd29uZGVyaW5nIGlmIHdlIGNvdWxkIGF2b2lkIGFsbCB0aGlz IGV4dHJhIG1vZHVsZS1ucy1kZXBlbmRlbmN5CmNoZWNraW5nIHdvcmsgaWYgd2UganVzdCBwdXQg dGhlIGltcG9ydCBzdHVmZiBhcyBhIG1vZGluZm8gdGFnLCBsaWtlCmhhdmUgTU9EVUxFX0lNUE9S VF9OUygpIGluc2VydCBhbiAiaW1wb3J0OiIgdGFnIGxpa2Ugd2UgYWxyZWFkeSBkbyBmb3IKbW9k dWxlIHBhcmFtZXRlcnMsIGF1dGhvciwgbGljZW5zZSwgYWxpYXNlcywgZXRjLiBUaGVuIHdlJ2Qg aGF2ZSB0aGF0CmluZm9ybWF0aW9uIHByZXR0eSBtdWNoIGZyb20gdGhlIHN0YXJ0IG9mIGxvYWRf bW9kdWxlKCkgYW5kIHdlIGRvbid0Cm5lZWQgdG8gd2FpdCBmb3IgcmVsb2NhdGlvbnMgdG8gYmUg YXBwbGllZCB0byBfX2tuc2ltcG9ydC4gVGhlbiB5b3UKY291bGQgZG8gdGhlIG5hbWVzcGFjZSBj aGVja2luZyByaWdodCBhdCByZXNvbHZlX3N5bWJvbCgpIGluc3RlYWQgb2YKZ29pbmcgdGhyb3Vn aCB0aGUgZXh0cmEgc3RlcCBvZiBidWlsZGluZyBhIGRlcGVuZGVuY3kgbGlzdCB0byBiZQp2ZXJp ZmllZCBsYXRlci4KCkFsc28sIHRoaXMgd291bGQgZ2V0IHJpZCBvZiB0aGUgZXh0cmEgX19rbnNp bXBvcnQgc2VjdGlvbiwgdGhlIGV4dHJhCm5zX2RlcGVuZGVuY2llcyBmaWVsZCBpbiBzdHJ1Y3Qg bW9kdWxlLCBhbmQgYWxsIHRob3NlIGhlbHBlciBmdW5jdGlvbnMgdGhhdAptYW5hZ2UgaXQuIElu IGFkZGl0aW9uLCBoYXZpbmcgdGhlIG1vZGluZm8gdGFnIG1heSBwb3RlbnRpYWxseSBoZWxwIHdp dGgKZGVidWdnaW5nIGFzIHdlIGhhdmUgdGhlIG5hbWVzcGFjZSBpbXBvcnRzIGNsZWFybHkgbGlz dGVkIGlmIHdlIGRvbid0IGhhdmUKdGhlIHNvdXJjZSBjb2RlIGZvciBhIG1vZHVsZS4gV2UnZCBw cm9iYWJseSBuZWVkIHRvIG1vZGlmeSBnZXRfbW9kaW5mbygpIHRvCmhhbmRsZSBtdWx0aXBsZSBp bXBvcnQ6IHRhZ3MgdGhvdWdoLiBMdWlzIFsxXSBoYWQgd3JpdHRlbiBzb21lIGNvZGUgYSB3aGls ZQphZ28gdG8gaGFuZGxlIG11bHRpcGxlIChvZiB0aGUgc2FtZSkgbW9kaW5mbyB0YWdzLgoKVGhv dWdodHMgb24gdGhpcz8KClRoYW5rcywKCkplc3NpY2EKClsxXSBodHRwczovL2xrbWwua2VybmVs Lm9yZy9yLzIwMTcxMTMwMDIzNjA1LjI5NTY4LTMtbWNncm9mQGtlcm5lbC5vcmcKCj4gZ2V0bmFt ZToKPiAJLyogV2UgbXVzdCBtYWtlIGNvcHkgdW5kZXIgdGhlIGxvY2sgaWYgd2UgZmFpbGVkIHRv IGdldCByZWYuICovCj4gCXN0cm5jcHkob3duZXJuYW1lLCBtb2R1bGVfbmFtZShvd25lciksIE1P RFVMRV9OQU1FX0xFTik7Cj5AQCAtMzA2MSw2ICszMTE4LDExIEBAIHN0YXRpYyBpbnQgZmluZF9t b2R1bGVfc2VjdGlvbnMoc3RydWN0IG1vZHVsZSAqbW9kLCBzdHJ1Y3QgbG9hZF9pbmZvICppbmZv KQo+IAkJCQkgICAgIHNpemVvZigqbW9kLT5ncGxfc3ltcyksCj4gCQkJCSAgICAgJm1vZC0+bnVt X2dwbF9zeW1zKTsKPiAJbW9kLT5ncGxfY3JjcyA9IHNlY3Rpb25fYWRkcihpbmZvLCAiX19rY3Jj dGFiX2dwbCIpOwo+Kwo+Kwltb2QtPm5zX2ltcG9ydHMgPSBzZWN0aW9uX29ianMoaW5mbywgIl9f a25zaW1wb3J0IiwKPisJCQkJICAgICAgIHNpemVvZigqbW9kLT5uc19pbXBvcnRzKSwKPisJCQkJ ICAgICAgICZtb2QtPm51bV9uc19pbXBvcnRzKTsKPisKPiAJbW9kLT5ncGxfZnV0dXJlX3N5bXMg PSBzZWN0aW9uX29ianMoaW5mbywKPiAJCQkJCSAgICAiX19rc3ltdGFiX2dwbF9mdXR1cmUiLAo+ IAkJCQkJICAgIHNpemVvZigqbW9kLT5ncGxfZnV0dXJlX3N5bXMpLAo+QEAgLTMzODEsNiArMzQ0 MywxOSBAQCBzdGF0aWMgaW50IHBvc3RfcmVsb2NhdGlvbihzdHJ1Y3QgbW9kdWxlICptb2QsIGNv bnN0IHN0cnVjdCBsb2FkX2luZm8gKmluZm8pCj4gCXJldHVybiBtb2R1bGVfZmluYWxpemUoaW5m by0+aGRyLCBpbmZvLT5zZWNoZHJzLCBtb2QpOwo+IH0KPgo+K3N0YXRpYyB2b2lkIHZlcmlmeV9u YW1lc3BhY2VfZGVwZW5kZW5jaWVzKHN0cnVjdCBtb2R1bGUgKm1vZCkKPit7Cj4rCXN0cnVjdCBt b2R1bGVfbnNfZGVwICpuc19kZXA7Cj4rCj4rCWxpc3RfZm9yX2VhY2hfZW50cnkobnNfZGVwLCAm bW9kLT5uc19kZXBlbmRlbmNpZXMsIG5zX2RlcCkgewo+KwkJaWYgKCFtb2R1bGVfaW1wb3J0c19u cyhtb2QsIG5zX2RlcC0+bmFtZXNwYWNlKSkgewo+KwkJCXByX3dhcm4oIiVzOiBtb2R1bGUgdXNl cyBzeW1ib2xzIGZyb20gbmFtZXNwYWNlICVzLCIKPisJCQkJIiBidXQgZG9lcyBub3QgaW1wb3J0 IGl0LlxuIiwKPisJCQkJbW9kLT5uYW1lLCBuc19kZXAtPm5hbWVzcGFjZSk7Cj4rCQl9Cj4rCX0K Pit9Cj4rCj4gLyogSXMgdGhpcyBtb2R1bGUgb2YgdGhpcyBuYW1lIGRvbmUgbG9hZGluZz8gIE5v IGxvY2tzIGhlbGQuICovCj4gc3RhdGljIGJvb2wgZmluaXNoZWRfbG9hZGluZyhjb25zdCBjaGFy ICpuYW1lKQo+IHsKPkBAIC0zNjgyLDYgKzM3NTcsOCBAQCBzdGF0aWMgaW50IGxvYWRfbW9kdWxl KHN0cnVjdCBsb2FkX2luZm8gKmluZm8sIGNvbnN0IGNoYXIgX191c2VyICp1YXJncywKPiAJaWYg KGVycikKPiAJCWdvdG8gZnJlZV9tb2R1bGU7Cj4KPisJSU5JVF9MSVNUX0hFQUQoJm1vZC0+bnNf ZGVwZW5kZW5jaWVzKTsKPisKPiAjaWZkZWYgQ09ORklHX01PRFVMRV9TSUcKPiAJbW9kLT5zaWdf b2sgPSBpbmZvLT5zaWdfb2s7Cj4gCWlmICghbW9kLT5zaWdfb2spIHsKPkBAIC0zNzMwLDYgKzM4 MDcsOCBAQCBzdGF0aWMgaW50IGxvYWRfbW9kdWxlKHN0cnVjdCBsb2FkX2luZm8gKmluZm8sIGNv bnN0IGNoYXIgX191c2VyICp1YXJncywKPiAJaWYgKGVyciA8IDApCj4gCQlnb3RvIGZyZWVfbW9k aW5mbzsKPgo+Kwl2ZXJpZnlfbmFtZXNwYWNlX2RlcGVuZGVuY2llcyhtb2QpOwo+Kwo+IAlmbHVz aF9tb2R1bGVfaWNhY2hlKG1vZCk7Cj4KPiAJLyogTm93IGNvcHkgaW4gYXJncyAqLwo+LS0gCj4y LjE4LjAuMjAzLmdmYWM2NzZkZmI5LWdvb2cKPgotLS0KVG8gdW5zdWJzY3JpYmUgZnJvbSB0aGlz IGxpc3Q6IHNlbmQgdGhlIGxpbmUgInVuc3Vic2NyaWJlIGxpbnV4LXVzYiIgaW4KdGhlIGJvZHkg b2YgYSBtZXNzYWdlIHRvIG1ham9yZG9tb0B2Z2VyLmtlcm5lbC5vcmcKTW9yZSBtYWpvcmRvbW8g aW5mbyBhdCAgaHR0cDovL3ZnZXIua2VybmVsLm9yZy9tYWpvcmRvbW8taW5mby5odG1sCg==