From mboxrd@z Thu Jan 1 00:00:00 1970 From: Martijn Coenen Subject: [PATCH 2/6] module: add support for symbol namespaces. Date: Mon, 16 Jul 2018 14:21:21 +0200 Message-ID: <20180716122125.175792-3-maco@android.com> References: <20180716122125.175792-1-maco@android.com> Return-path: In-Reply-To: <20180716122125.175792-1-maco@android.com> Sender: linux-kernel-owner@vger.kernel.org To: linux-kernel@vger.kernel.org Cc: Martijn Coenen , 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 , Jessica Yu , 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 List-Id: linux-arch.vger.kernel.org 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); + } + 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-ed1-f68.google.com ([209.85.208.68]:39255 "EHLO mail-ed1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730840AbeGPMst (ORCPT ); Mon, 16 Jul 2018 08:48:49 -0400 Received: by mail-ed1-f68.google.com with SMTP id w14-v6so29805395eds.6 for ; Mon, 16 Jul 2018 05:21:36 -0700 (PDT) From: Martijn Coenen Subject: [PATCH 2/6] module: add support for symbol namespaces. Date: Mon, 16 Jul 2018 14:21:21 +0200 Message-ID: <20180716122125.175792-3-maco@android.com> In-Reply-To: <20180716122125.175792-1-maco@android.com> References: <20180716122125.175792-1-maco@android.com> Sender: linux-arch-owner@vger.kernel.org List-ID: To: linux-kernel@vger.kernel.org Cc: Martijn Coenen , 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 , Jessica Yu , 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: <20180716122121.xllMoAeUyRiCX_DGNhaCqamiY_w9h3vlFyUvD9VU8qs@z> 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); + } + 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: Martijn Coenen Message-Id: <20180716122125.175792-3-maco@android.com> Date: Mon, 16 Jul 2018 14:21:21 +0200 To: linux-kernel@vger.kernel.org Cc: Martijn Coenen , 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 , Jessica Yu , 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: VGhlIEVYUE9SVF9TWU1CT0xfTlMoKSBhbmQgRVhQT1JUX1NZTUJPTF9OU19HUEwoKSBtYWNyb3Mg Y2FuIGJlIHVzZWQgdG8KZXhwb3J0IGEgc3ltYm9sIHRvIGEgc3BlY2lmaWMgbmFtZXNwYWNlLiAg VGhlcmUgYXJlIG5vIF9HUExfRlVUVVJFIGFuZApfVU5VU0VEIHZhcmlhbnRzIGJlY2F1c2UgdGhl c2UgYXJlIGN1cnJlbnRseSB1bnVzZWQsIGFuZCBJJ20gbm90IHN1cmUKdGhleSBhcmUgbmVjZXNz YXJ5LgoKSSBkaWRuJ3QgYWRkIEVYUE9SVF9TWU1CT0xfTlMoKSBmb3IgQVNNIGV4cG9ydHM7IHRo aXMgcGF0Y2ggc2V0cyB0aGUKbmFtZXNwYWNlIG9mIEFTTSBleHBvcnRzIHRvIE5VTEwgYnkgZGVm YXVsdC4gSWYgdGhlcmUncyBhIG5lZWQsIHRoaXMKc2hvdWxkIGJlIHByZXR0eSBlYXN5IHRvIGFk ZC4KCkEgbW9kdWxlIHRoYXQgd2FudHMgdG8gdXNlIGEgc3ltYm9sIGV4cG9ydGVkIHRvIGEgbmFt ZXNwYWNlIG11c3QgYWRkIGEKTU9EVUxFX0lNUE9SVF9OUygpIHN0YXRlbWVudCB0byB0aGVpciBt b2R1bGUgY29kZTsgb3RoZXJ3aXNlLCBtb2Rwb3N0CndpbGwgY29tcGxhaW4gd2hlbiBidWlsZGlu ZyB0aGUgbW9kdWxlLCBhbmQgdGhlIGtlcm5lbCBtb2R1bGUgbG9hZGVyCndpbGwgd2FybiB3aGVu IGxvYWRpbmcgdGhlIG1vZHVsZS4KClRoZSBFTEYgc3ltYm9scyBhcmUgcmVuYW1lZCB0byBpbmNs dWRlIHRoZSBuYW1lc3BhY2Ugd2l0aCBhbiBhc20gbGFiZWw7CmZvciBleGFtcGxlLCBzeW1ib2wg J3VzYl9zdG9yX3N1c3BlbmQnIGluIG5hbWVzcGFjZSBVU0JfU1RPUkFHRSBiZWNvbWVzCid1c2Jf c3Rvcl9zdXNwZW5kLlVTQl9TVE9SQUdFJy4gIFRoaXMgYWxsb3dzIG1vZHBvc3QgdG8gZG8gbmFt ZXNwYWNlCmNoZWNraW5nLCB3aXRob3V0IGhhdmluZyB0byBnbyB0aHJvdWdoIGFsbCB0aGUgZWZm b3J0IG9mIHBhcnNpbmcgRUxGIGFuZApyZWxvY3Rpb24gcmVjb3JkcyBqdXN0IHRvIGdldCB0byB0 aGUgc3RydWN0IGtlcm5lbF9zeW1ib2xzLgoKT24geDg2XzY0IEkgc2F3IG5vIGRpZmZlcmVuY2Ug aW4gYmluYXJ5IHNpemUgKGNvbXByZXNzaW9uKSwgYnV0IGF0CnJ1bnRpbWUgdGhpcyB3aWxsIHJl cXVpcmUgYSB3b3JkIG9mIG1lbW9yeSBwZXIgZXhwb3J0IHRvIGhvbGQgdGhlCm5hbWVzcGFjZS4g QW4gYWx0ZXJuYXRpdmUgY291bGQgYmUgdG8gc3RvcmUgbmFtZXNwYWNlZCBzeW1ib2xzIGluIHRo ZWlyCm93biBzZWN0aW9uIGFuZCB1c2UgYSBzZXBhcmF0ZSAnc3RydWN0IG5hbWVzcGFjZWRfa2Vy bmVsX3N5bWJvbCcgZm9yCnRoYXQgc2VjdGlvbiwgYXQgdGhlIGNvc3Qgb2YgbWFraW5nIHRoZSBt b2R1bGUgbG9hZGVyIG1vcmUgY29tcGxleC4KClNpZ25lZC1vZmYtYnk6IE1hcnRpam4gQ29lbmVu IDxtYWNvQGFuZHJvaWQuY29tPgotLS0KIGluY2x1ZGUvYXNtLWdlbmVyaWMvZXhwb3J0LmggfCAg MiArLQogaW5jbHVkZS9saW51eC9leHBvcnQuaCAgICAgICB8IDgzICsrKysrKysrKysrKysrKysr KysrKysrKysrKy0tLS0tLS0tLQogaW5jbHVkZS9saW51eC9tb2R1bGUuaCAgICAgICB8IDEzICsr KysrKwoga2VybmVsL21vZHVsZS5jICAgICAgICAgICAgICB8IDc5ICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysKIDQgZmlsZXMgY2hhbmdlZCwgMTU2IGluc2VydGlvbnMoKyksIDIx IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvZXhwb3J0Lmgg Yi9pbmNsdWRlL2FzbS1nZW5lcmljL2V4cG9ydC5oCmluZGV4IDY4ZWZiOTUwYTkxOC4uNGMzZDFh ZmI3MDJmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2FzbS1nZW5lcmljL2V4cG9ydC5oCisrKyBiL2lu Y2x1ZGUvYXNtLWdlbmVyaWMvZXhwb3J0LmgKQEAgLTI5LDcgKzI5LDcgQEAKIAkuc2VjdGlvbiBf X19rc3ltdGFiXHNlYytcbmFtZSwiYSIKIAkuYmFsaWduIEtTWU1fQUxJR04KIF9fa3N5bXRhYl9c bmFtZToKLQlfX3B1dCBcdmFsLCBfX2tzdHJ0YWJfXG5hbWUKKwlfX3B1dCBcdmFsLCBfX2tzdHJ0 YWJfXG5hbWUsIDAKIAkucHJldmlvdXMKIAkuc2VjdGlvbiBfX2tzeW10YWJfc3RyaW5ncywiYSIK IF9fa3N0cnRhYl9cbmFtZToKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZXhwb3J0LmggYi9p bmNsdWRlL2xpbnV4L2V4cG9ydC5oCmluZGV4IGFkNmI4ZTY5N2IyNy4uOWY2ZTcwZWViODVmIDEw MDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2V4cG9ydC5oCisrKyBiL2luY2x1ZGUvbGludXgvZXhw b3J0LmgKQEAgLTIyLDYgKzIyLDExIEBAIHN0cnVjdCBrZXJuZWxfc3ltYm9sCiB7CiAJdW5zaWdu ZWQgbG9uZyB2YWx1ZTsKIAljb25zdCBjaGFyICpuYW1lOworCWNvbnN0IGNoYXIgKm5hbWVzcGFj ZTsKK307CisKK3N0cnVjdCBuYW1lc3BhY2VfaW1wb3J0IHsKKwljb25zdCBjaGFyICpuYW1lc3Bh Y2U7CiB9OwogCiAjaWZkZWYgTU9EVUxFCkBAIC01NCwxOCArNTksMjggQEAgZXh0ZXJuIHN0cnVj dCBtb2R1bGUgX190aGlzX21vZHVsZTsKICNkZWZpbmUgX19DUkNfU1lNQk9MKHN5bSwgc2VjKQog I2VuZGlmCiAKKyNkZWZpbmUgTlNfU0VQQVJBVE9SICIuIgorCisjZGVmaW5lIE1PRFVMRV9JTVBP UlRfTlMobnMpCQkJCQkJXAorCXN0YXRpYyBjb25zdCBzdHJ1Y3QgbmFtZXNwYWNlX2ltcG9ydCBf X2tuc2ltcG9ydF8jI25zCQlcCisJYXNtKCJfX2tuc2ltcG9ydF8iICNucykJCQkJCQlcCisJX19h dHRyaWJ1dGVfXygoc2VjdGlvbigiX19rbnNpbXBvcnQiKSwgdXNlZCkpCQkJXAorCT0geyAjbnMg fQorCiAvKiBGb3IgZXZlcnkgZXhwb3J0ZWQgc3ltYm9sLCBwbGFjZSBhIHN0cnVjdCBpbiB0aGUg X19rc3ltdGFiIHNlY3Rpb24gKi8KLSNkZWZpbmUgX19fRVhQT1JUX1NZTUJPTChzeW0sIHNlYykJ CQkJCVwKKyNkZWZpbmUgX19fRVhQT1JUX1NZTUJPTChzeW0sIHNlYywgbnMsIG5zcG9zdCwgbnNw b3N0MikJCQlcCiAJZXh0ZXJuIHR5cGVvZihzeW0pIHN5bTsJCQkJCQlcCiAJX19DUkNfU1lNQk9M KHN5bSwgc2VjKQkJCQkJCVwKLQlzdGF0aWMgY29uc3QgY2hhciBfX2tzdHJ0YWJfIyNzeW1bXQkJ CQlcCisJc3RhdGljIGNvbnN0IGNoYXIgX19rc3RydGFiXyMjc3ltIyNuc3Bvc3RbXQkJCVwKIAlf X2F0dHJpYnV0ZV9fKChzZWN0aW9uKCJfX2tzeW10YWJfc3RyaW5ncyIpLCBhbGlnbmVkKDEpKSkJ XAogCT0gI3N5bTsJCQkJCQkJCVwKLQlzdGF0aWMgY29uc3Qgc3RydWN0IGtlcm5lbF9zeW1ib2wg X19rc3ltdGFiXyMjc3ltCQlcCisJc3RhdGljIGNvbnN0IHN0cnVjdCBrZXJuZWxfc3ltYm9sIF9f a3N5bXRhYl8jI3N5bSMjbnNwb3N0CVwKKwlhc20oIl9fa3N5bXRhYl8iICNzeW0gbnNwb3N0Mikg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAogCV9fdXNlZAkJCQkJCQkJXAotCV9f YXR0cmlidXRlX18oKHNlY3Rpb24oIl9fX2tzeW10YWIiIHNlYyAiKyIgI3N5bSksIHVzZWQpKQlc CisJX19hdHRyaWJ1dGVfXygoc2VjdGlvbigiX19fa3N5bXRhYiIgc2VjICIrIiAjc3ltICNuc3Bv c3QpKSkJXAorCV9fYXR0cmlidXRlX18oKHVzZWQpKQkJCQkJCVwKIAlfX2F0dHJpYnV0ZV9fKChh bGlnbmVkKHNpemVvZih2b2lkICopKSkpICAgICAgICAgICAgICAgICAgICAgICAgXAotCT0geyAo dW5zaWduZWQgbG9uZykmc3ltLCBfX2tzdHJ0YWJfIyNzeW0gfQorCT0geyAodW5zaWduZWQgbG9u Zykmc3ltLCBfX2tzdHJ0YWJfIyNzeW0jI25zcG9zdCwgbnMgfQogCiAjaWYgZGVmaW5lZChfX0tT WU1fREVQU19fKQogCkBAIC03Niw1MiArOTEsODAgQEAgZXh0ZXJuIHN0cnVjdCBtb2R1bGUgX190 aGlzX21vZHVsZTsKICAqIHN5c3RlbSBmaWx0ZXJzIG91dCBmcm9tIHRoZSBwcmVwcm9jZXNzb3Ig b3V0cHV0IChzZWUga3N5bV9kZXBfZmlsdGVyCiAgKiBpbiBzY3JpcHRzL0tidWlsZC5pbmNsdWRl KS4KICAqLwotI2RlZmluZSBfX0VYUE9SVF9TWU1CT0woc3ltLCBzZWMpCT09PSBfX0tTWU1fIyNz eW0gPT09CisjZGVmaW5lIF9fRVhQT1JUX1NZTUJPTChzeW0sIHNlYywgbnMsIG5zcG9zdCwgbnNw b3N0MikJPT09IF9fS1NZTV8jI3N5bSA9PT0KIAogI2VsaWYgZGVmaW5lZChDT05GSUdfVFJJTV9V TlVTRURfS1NZTVMpCiAKICNpbmNsdWRlIDxnZW5lcmF0ZWQvYXV0b2tzeW1zLmg+CiAKLSNkZWZp bmUgX19FWFBPUlRfU1lNQk9MKHN5bSwgc2VjKQkJCQlcCi0JX19jb25kX2V4cG9ydF9zeW0oc3lt LCBzZWMsIF9faXNfZGVmaW5lZChfX0tTWU1fIyNzeW0pKQotI2RlZmluZSBfX2NvbmRfZXhwb3J0 X3N5bShzeW0sIHNlYywgY29uZikJCQlcCi0JX19fY29uZF9leHBvcnRfc3ltKHN5bSwgc2VjLCBj b25mKQotI2RlZmluZSBfX19jb25kX2V4cG9ydF9zeW0oc3ltLCBzZWMsIGVuYWJsZWQpCQkJXAot CV9fY29uZF9leHBvcnRfc3ltXyMjZW5hYmxlZChzeW0sIHNlYykKLSNkZWZpbmUgX19jb25kX2V4 cG9ydF9zeW1fMShzeW0sIHNlYykgX19fRVhQT1JUX1NZTUJPTChzeW0sIHNlYykKLSNkZWZpbmUg X19jb25kX2V4cG9ydF9zeW1fMChzeW0sIHNlYykgLyogbm90aGluZyAqLworI2RlZmluZSBfX0VY UE9SVF9TWU1CT0woc3ltLCBzZWMsIG5zLCBuc3Bvc3QsIG5zcG9zdDIpCQkJXAorCV9fY29uZF9l eHBvcnRfc3ltKHN5bSwgc2VjLCBucywgbnNwb3N0LCBuc3Bvc3QyLAkJXAorCQkJICBfX2lzX2Rl ZmluZWQoX19LU1lNXyMjc3ltKSkKKyNkZWZpbmUgX19jb25kX2V4cG9ydF9zeW0oc3ltLCBzZWMs IG5zLCBuc3Bvc3QsIG5zcG9zdDIsIGNvbmYpCQlcCisJX19fY29uZF9leHBvcnRfc3ltKHN5bSwg c2VjLCBucywgbnNwb3N0LCBuc3Bvc3QyLCBjb25mKQorI2RlZmluZSBfX19jb25kX2V4cG9ydF9z eW0oc3ltLCBzZWMsIG5zLCBuc3Bvc3QsIG5zcG9zdDIsIGVuYWJsZWQpCVwKKwlfX2NvbmRfZXhw b3J0X3N5bV8jI2VuYWJsZWQoc3ltLCBzZWMsIG5zLCBuc3Bvc3QsIG5zcG9zdDIpCisjZGVmaW5l IF9fY29uZF9leHBvcnRfc3ltXzEoc3ltLCBzZWMsIG5zLCBuc3Bvc3QsIG5zcG9zdDIpCQlcCisJ X19fRVhQT1JUX1NZTUJPTChzeW0sIHNlYywgbnMsIG5zcG9zdCwgbnNwb3N0MikKKyNkZWZpbmUg X19jb25kX2V4cG9ydF9zeW1fMChzeW0sIHNlYywgbnMsIG5zcG9zdCwgbnNwb3N0MikgLyogbm90 aGluZyAqLwogCiAjZWxzZQogI2RlZmluZSBfX0VYUE9SVF9TWU1CT0wgX19fRVhQT1JUX1NZTUJP TAogI2VuZGlmCiAKICNkZWZpbmUgRVhQT1JUX1NZTUJPTChzeW0pCQkJCQlcCi0JX19FWFBPUlRf U1lNQk9MKHN5bSwgIiIpCisJX19FWFBPUlRfU1lNQk9MKHN5bSwgIiIsIE5VTEwsICwpCiAKICNk ZWZpbmUgRVhQT1JUX1NZTUJPTF9HUEwoc3ltKQkJCQkJXAotCV9fRVhQT1JUX1NZTUJPTChzeW0s ICJfZ3BsIikKKwlfX0VYUE9SVF9TWU1CT0woc3ltLCAiX2dwbCIsIE5VTEwsICwpCiAKICNkZWZp bmUgRVhQT1JUX1NZTUJPTF9HUExfRlVUVVJFKHN5bSkJCQkJXAotCV9fRVhQT1JUX1NZTUJPTChz eW0sICJfZ3BsX2Z1dHVyZSIpCisJX19FWFBPUlRfU1lNQk9MKHN5bSwgIl9ncGxfZnV0dXJlIiwg TlVMTCwgLCkKKworI2RlZmluZSBFWFBPUlRfU1lNQk9MX05TKHN5bSwgbnMpICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFwKKwlfX0VYUE9SVF9TWU1CT0woc3ltLCAiIiwgI25zLCBfXyMj bnMsIE5TX1NFUEFSQVRPUiAjbnMpCisKKyNkZWZpbmUgRVhQT1JUX1NZTUJPTF9OU19HUEwoc3lt LCBucykgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorCV9fRVhQT1JUX1NZTUJPTChz eW0sICJfZ3BsIiwgI25zLCBfXyMjbnMsIE5TX1NFUEFSQVRPUiAjbnMpCiAKICNpZmRlZiBDT05G SUdfVU5VU0VEX1NZTUJPTFMKLSNkZWZpbmUgRVhQT1JUX1VOVVNFRF9TWU1CT0woc3ltKSBfX0VY UE9SVF9TWU1CT0woc3ltLCAiX3VudXNlZCIpCi0jZGVmaW5lIEVYUE9SVF9VTlVTRURfU1lNQk9M X0dQTChzeW0pIF9fRVhQT1JUX1NZTUJPTChzeW0sICJfdW51c2VkX2dwbCIpCisjZGVmaW5lIEVY UE9SVF9VTlVTRURfU1lNQk9MKHN5bSkgX19FWFBPUlRfU1lNQk9MKHN5bSwgIl91bnVzZWQiLCAs ICwpCisjZGVmaW5lIEVYUE9SVF9VTlVTRURfU1lNQk9MX0dQTChzeW0pIF9fRVhQT1JUX1NZTUJP TChzeW0sICJfdW51c2VkX2dwbCIsICwgLCkKICNlbHNlCiAjZGVmaW5lIEVYUE9SVF9VTlVTRURf U1lNQk9MKHN5bSkKICNkZWZpbmUgRVhQT1JUX1VOVVNFRF9TWU1CT0xfR1BMKHN5bSkKICNlbmRp ZgogCi0jZW5kaWYJLyogX19HRU5LU1lNU19fICovCisjZW5kaWYJLyogX19LRVJORUxfXyAmJiAh X19HRU5LU1lNU19fICovCisKKyNpZiBkZWZpbmVkKF9fR0VOS1NZTVNfXykKKy8qCisgKiBXaGVu IHdlJ3JlIHJ1bm5pbmcgZ2Vua3N5bXMsIGlnbm9yZSB0aGUgbmFtZXNwYWNlIGFuZCBtYWtlIHRo ZSBfTlMKKyAqIHZhcmlhbnRzIGxvb2sgbGlrZSB0aGUgbm9ybWFsIG9uZXMuIFRoZXJlIGFyZSB0 d28gcmVhc29ucyBmb3IgdGhpczoKKyAqIDEpIEluIHRoZSBub3JtYWwgZGVmaW5pdGlvbiBvZiBF WFBPUlRfU1lNQk9MX05TLCB0aGUgJ25zJyBtYWNybworICogICAgYXJndW1lbnQgaXMgaXRzZWxm IG5vdCBleHBhbmRlZCBiZWNhdXNlIGl0J3MgYWx3YXlzIHRva2VuaXplZCBvcgorICogICAgY29u Y2F0ZW5hdGVkOyBidXQgd2hlbiBydW5uaW5nIGdlbmtzeW1zLCBhIGJsYW5rIGRlZmluaXRpb24g b2YgdGhlCisgKiAgICBtYWNybyBkb2VzIGFsbG93IHRoZSBhcmd1bWVudCB0byBiZSBleHBhbmRl ZDsgaWYgYSBuYW1lc3BhY2UKKyAqICAgIGhhcHBlbnMgdG8gY29sbGlkZSB3aXRoIGEgI2RlZmlu ZSwgdGhpcyBjYW4gY2F1c2UgaXNzdWVzLgorICogMikgVGhlcmUncyBubyBuZWVkIHRvIG1vZGlm eSBnZW5rc3ltcyB0byBkZWFsIHdpdGggdGhlIF9OUyB2YXJpYW50cworICovCisjZGVmaW5lIEVY UE9SVF9TWU1CT0xfTlMoc3ltLCBucykgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisJ RVhQT1JUX1NZTUJPTChzeW0pCisjZGVmaW5lIEVYUE9SVF9TWU1CT0xfTlNfR1BMKHN5bSwgbnMp ICAgICAgICAgICAgICAgICAgICAgICAgICBcCisJRVhQT1JUX1NZTUJPTF9HUEwoc3ltKQorI2Vu ZGlmCiAKICNlbHNlIC8qICFDT05GSUdfTU9EVUxFUy4uLiAqLwogCiAjZGVmaW5lIEVYUE9SVF9T WU1CT0woc3ltKQorI2RlZmluZSBFWFBPUlRfU1lNQk9MX05TKHN5bSwgbnMpCisjZGVmaW5lIEVY UE9SVF9TWU1CT0xfTlNfR1BMKHN5bSwgbnMpCiAjZGVmaW5lIEVYUE9SVF9TWU1CT0xfR1BMKHN5 bSkKICNkZWZpbmUgRVhQT1JUX1NZTUJPTF9HUExfRlVUVVJFKHN5bSkKICNkZWZpbmUgRVhQT1JU X1VOVVNFRF9TWU1CT0woc3ltKQogI2RlZmluZSBFWFBPUlRfVU5VU0VEX1NZTUJPTF9HUEwoc3lt KQogCisjZGVmaW5lIE1PRFVMRV9JTVBPUlRfTlMobnMpCiAjZW5kaWYgLyogQ09ORklHX01PRFVM RVMgKi8KICNlbmRpZiAvKiAhX19BU1NFTUJMWV9fICovCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUv bGludXgvbW9kdWxlLmggYi9pbmNsdWRlL2xpbnV4L21vZHVsZS5oCmluZGV4IGQ0NGRmOWIyYzEz MS4uYWZhYjRlOGZhMTg4IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L21vZHVsZS5oCisrKyBi L2luY2x1ZGUvbGludXgvbW9kdWxlLmgKQEAgLTI2OCw2ICsyNjgsMTIgQEAgdm9pZCAqX19zeW1i b2xfZ2V0KGNvbnN0IGNoYXIgKnN5bWJvbCk7CiB2b2lkICpfX3N5bWJvbF9nZXRfZ3BsKGNvbnN0 IGNoYXIgKnN5bWJvbCk7CiAjZGVmaW5lIHN5bWJvbF9nZXQoeCkgKCh0eXBlb2YoJngpKShfX3N5 bWJvbF9nZXQoVk1MSU5VWF9TWU1CT0xfU1RSKHgpKSkpCiAKKy8qIG5hbWVzcGFjZSBkZXBlbmRl bmNpZXMgb2YgdGhlIG1vZHVsZSAqLworc3RydWN0IG1vZHVsZV9uc19kZXAgeworCXN0cnVjdCBs aXN0X2hlYWQgbnNfZGVwOworCWNvbnN0IGNoYXIgKm5hbWVzcGFjZTsKK307CisKIC8qIG1vZHVs ZXMgdXNpbmcgb3RoZXIgbW9kdWxlczoga2RiIHdhbnRzIHRvIHNlZSB0aGlzLiAqLwogc3RydWN0 IG1vZHVsZV91c2UgewogCXN0cnVjdCBsaXN0X2hlYWQgc291cmNlX2xpc3Q7CkBAIC0zNTksNiAr MzY1LDEzIEBAIHN0cnVjdCBtb2R1bGUgewogCWNvbnN0IHN0cnVjdCBrZXJuZWxfc3ltYm9sICpn cGxfc3ltczsKIAljb25zdCBzMzIgKmdwbF9jcmNzOwogCisJLyogTmFtZXNwYWNlIGltcG9ydHMg Ki8KKwl1bnNpZ25lZCBpbnQgbnVtX25zX2ltcG9ydHM7CisJY29uc3Qgc3RydWN0IG5hbWVzcGFj ZV9pbXBvcnQgKm5zX2ltcG9ydHM7CisKKwkvKiBOYW1lc3BhY2UgZGVwZW5kZW5jaWVzICovCisJ c3RydWN0IGxpc3RfaGVhZCBuc19kZXBlbmRlbmNpZXM7CisKICNpZmRlZiBDT05GSUdfVU5VU0VE X1NZTUJPTFMKIAkvKiB1bnVzZWQgZXhwb3J0ZWQgc3ltYm9scy4gKi8KIAljb25zdCBzdHJ1Y3Qg a2VybmVsX3N5bWJvbCAqdW51c2VkX3N5bXM7CmRpZmYgLS1naXQgYS9rZXJuZWwvbW9kdWxlLmMg Yi9rZXJuZWwvbW9kdWxlLmMKaW5kZXggZjQ3NWYzMGVlZDhjLi42M2RlMGZlODQ5ZjkgMTAwNjQ0 Ci0tLSBhL2tlcm5lbC9tb2R1bGUuYworKysgYi9rZXJuZWwvbW9kdWxlLmMKQEAgLTExNjYsNiAr MTE2Niw1MSBAQCBzdGF0aWMgaW5saW5lIGludCBtb2R1bGVfdW5sb2FkX2luaXQoc3RydWN0IG1v ZHVsZSAqbW9kKQogfQogI2VuZGlmIC8qIENPTkZJR19NT0RVTEVfVU5MT0FEICovCiAKK3N0YXRp YyBib29sIG1vZHVsZV9oYXNfbnNfZGVwZW5kZW5jeShzdHJ1Y3QgbW9kdWxlICptb2QsIGNvbnN0 IGNoYXIgKm5zKQoreworCXN0cnVjdCBtb2R1bGVfbnNfZGVwICpuc19kZXA7CisKKwlsaXN0X2Zv cl9lYWNoX2VudHJ5KG5zX2RlcCwgJm1vZC0+bnNfZGVwZW5kZW5jaWVzLCBuc19kZXApIHsKKwkJ aWYgKHN0cmNtcChuc19kZXAtPm5hbWVzcGFjZSwgbnMpID09IDApCisJCQlyZXR1cm4gdHJ1ZTsK Kwl9CisKKwlyZXR1cm4gZmFsc2U7Cit9CisKK3N0YXRpYyBpbnQgYWRkX21vZHVsZV9uc19kZXBl bmRlbmN5KHN0cnVjdCBtb2R1bGUgKm1vZCwgY29uc3QgY2hhciAqbnMpCit7CisJc3RydWN0IG1v ZHVsZV9uc19kZXAgKm5zX2RlcDsKKworCWlmIChtb2R1bGVfaGFzX25zX2RlcGVuZGVuY3kobW9k LCBucykpCisJCXJldHVybiAwOworCisJbnNfZGVwID0ga21hbGxvYyhzaXplb2YoKm5zX2RlcCks IEdGUF9BVE9NSUMpOworCWlmICghbnNfZGVwKQorCQlyZXR1cm4gLUVOT01FTTsKKworCW5zX2Rl cC0+bmFtZXNwYWNlID0gbnM7CisKKwlsaXN0X2FkZCgmbnNfZGVwLT5uc19kZXAsICZtb2QtPm5z X2RlcGVuZGVuY2llcyk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGJvb2wgbW9kdWxlX2lt cG9ydHNfbnMoc3RydWN0IG1vZHVsZSAqbW9kLCBjb25zdCBjaGFyICpucykKK3sKKwlzaXplX3Qg aTsKKworCWlmICghbnMpCisJCXJldHVybiB0cnVlOworCisJZm9yIChpID0gMDsgaSA8IG1vZC0+ bnVtX25zX2ltcG9ydHM7ICsraSkgeworCQlpZiAoIXN0cmNtcChtb2QtPm5zX2ltcG9ydHNbaV0u bmFtZXNwYWNlLCBucykpCisJCQlyZXR1cm4gdHJ1ZTsKKwl9CisKKwlyZXR1cm4gZmFsc2U7Cit9 CisKIHN0YXRpYyBzaXplX3QgbW9kdWxlX2ZsYWdzX3RhaW50KHN0cnVjdCBtb2R1bGUgKm1vZCwg Y2hhciAqYnVmKQogewogCXNpemVfdCBsID0gMDsKQEAgLTE0MTUsNiArMTQ2MCwxOCBAQCBzdGF0 aWMgY29uc3Qgc3RydWN0IGtlcm5lbF9zeW1ib2wgKnJlc29sdmVfc3ltYm9sKHN0cnVjdCBtb2R1 bGUgKm1vZCwKIAkJZ290byBnZXRuYW1lOwogCX0KIAorCS8qCisJICogV2UgY2FuJ3QgeWV0IHZl cmlmeSB0aGF0IHRoZSBtb2R1bGUgYWN0dWFsbHkgaW1wb3J0cyB0aGlzCisJICogbmFtZXNwYWNl LCBiZWNhdXNlIHRoZSBpbXBvcnRzIHRoZW1zZWx2ZXMgYXJlIG9ubHkgYXZhaWxhYmxlCisJICog YWZ0ZXIgcHJvY2Vzc2luZyB0aGUgc3ltYm9sIHRhYmxlIGFuZCBkb2luZyByZWxvY2F0aW9uOyBz bworCSAqIGluc3RlYWQganVzdCByZWNvcmQgdGhlIGRlcGVuZGVuY3kgYW5kIGNoZWNrIGxhdGVy LgorCSAqLworCWlmIChzeW0tPm5hbWVzcGFjZSkgeworCQllcnIgPSBhZGRfbW9kdWxlX25zX2Rl cGVuZGVuY3kobW9kLCBzeW0tPm5hbWVzcGFjZSk7CisJCWlmIChlcnIpCisJCQlzeW0gPSBFUlJf UFRSKGVycik7CisJfQorCiBnZXRuYW1lOgogCS8qIFdlIG11c3QgbWFrZSBjb3B5IHVuZGVyIHRo ZSBsb2NrIGlmIHdlIGZhaWxlZCB0byBnZXQgcmVmLiAqLwogCXN0cm5jcHkob3duZXJuYW1lLCBt b2R1bGVfbmFtZShvd25lciksIE1PRFVMRV9OQU1FX0xFTik7CkBAIC0zMDYxLDYgKzMxMTgsMTEg QEAgc3RhdGljIGludCBmaW5kX21vZHVsZV9zZWN0aW9ucyhzdHJ1Y3QgbW9kdWxlICptb2QsIHN0 cnVjdCBsb2FkX2luZm8gKmluZm8pCiAJCQkJICAgICBzaXplb2YoKm1vZC0+Z3BsX3N5bXMpLAog CQkJCSAgICAgJm1vZC0+bnVtX2dwbF9zeW1zKTsKIAltb2QtPmdwbF9jcmNzID0gc2VjdGlvbl9h ZGRyKGluZm8sICJfX2tjcmN0YWJfZ3BsIik7CisKKwltb2QtPm5zX2ltcG9ydHMgPSBzZWN0aW9u X29ianMoaW5mbywgIl9fa25zaW1wb3J0IiwKKwkJCQkgICAgICAgc2l6ZW9mKCptb2QtPm5zX2lt cG9ydHMpLAorCQkJCSAgICAgICAmbW9kLT5udW1fbnNfaW1wb3J0cyk7CisKIAltb2QtPmdwbF9m dXR1cmVfc3ltcyA9IHNlY3Rpb25fb2JqcyhpbmZvLAogCQkJCQkgICAgIl9fa3N5bXRhYl9ncGxf ZnV0dXJlIiwKIAkJCQkJICAgIHNpemVvZigqbW9kLT5ncGxfZnV0dXJlX3N5bXMpLApAQCAtMzM4 MSw2ICszNDQzLDE5IEBAIHN0YXRpYyBpbnQgcG9zdF9yZWxvY2F0aW9uKHN0cnVjdCBtb2R1bGUg Km1vZCwgY29uc3Qgc3RydWN0IGxvYWRfaW5mbyAqaW5mbykKIAlyZXR1cm4gbW9kdWxlX2ZpbmFs aXplKGluZm8tPmhkciwgaW5mby0+c2VjaGRycywgbW9kKTsKIH0KIAorc3RhdGljIHZvaWQgdmVy aWZ5X25hbWVzcGFjZV9kZXBlbmRlbmNpZXMoc3RydWN0IG1vZHVsZSAqbW9kKQoreworCXN0cnVj dCBtb2R1bGVfbnNfZGVwICpuc19kZXA7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KG5zX2RlcCwg Jm1vZC0+bnNfZGVwZW5kZW5jaWVzLCBuc19kZXApIHsKKwkJaWYgKCFtb2R1bGVfaW1wb3J0c19u cyhtb2QsIG5zX2RlcC0+bmFtZXNwYWNlKSkgeworCQkJcHJfd2FybigiJXM6IG1vZHVsZSB1c2Vz IHN5bWJvbHMgZnJvbSBuYW1lc3BhY2UgJXMsIgorCQkJCSIgYnV0IGRvZXMgbm90IGltcG9ydCBp dC5cbiIsCisJCQkJbW9kLT5uYW1lLCBuc19kZXAtPm5hbWVzcGFjZSk7CisJCX0KKwl9Cit9CisK IC8qIElzIHRoaXMgbW9kdWxlIG9mIHRoaXMgbmFtZSBkb25lIGxvYWRpbmc/ICBObyBsb2NrcyBo ZWxkLiAqLwogc3RhdGljIGJvb2wgZmluaXNoZWRfbG9hZGluZyhjb25zdCBjaGFyICpuYW1lKQog ewpAQCAtMzY4Miw2ICszNzU3LDggQEAgc3RhdGljIGludCBsb2FkX21vZHVsZShzdHJ1Y3QgbG9h ZF9pbmZvICppbmZvLCBjb25zdCBjaGFyIF9fdXNlciAqdWFyZ3MsCiAJaWYgKGVycikKIAkJZ290 byBmcmVlX21vZHVsZTsKIAorCUlOSVRfTElTVF9IRUFEKCZtb2QtPm5zX2RlcGVuZGVuY2llcyk7 CisKICNpZmRlZiBDT05GSUdfTU9EVUxFX1NJRwogCW1vZC0+c2lnX29rID0gaW5mby0+c2lnX29r OwogCWlmICghbW9kLT5zaWdfb2spIHsKQEAgLTM3MzAsNiArMzgwNyw4IEBAIHN0YXRpYyBpbnQg bG9hZF9tb2R1bGUoc3RydWN0IGxvYWRfaW5mbyAqaW5mbywgY29uc3QgY2hhciBfX3VzZXIgKnVh cmdzLAogCWlmIChlcnIgPCAwKQogCQlnb3RvIGZyZWVfbW9kaW5mbzsKIAorCXZlcmlmeV9uYW1l c3BhY2VfZGVwZW5kZW5jaWVzKG1vZCk7CisKIAlmbHVzaF9tb2R1bGVfaWNhY2hlKG1vZCk7CiAK IAkvKiBOb3cgY29weSBpbiBhcmdzICovCg==