From mboxrd@z Thu Jan 1 00:00:00 1970 From: Martijn Coenen Subject: [PATCH 3/6] modpost: add support for checking symbol namespaces. Date: Mon, 16 Jul 2018 14:21:22 +0200 Message-ID: <20180716122125.175792-4-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 Emits a warning whenever a module refers to an exported symbol without explicitly importing the namespace that it is defined in. Example: WARNING: module ums-usbat uses symbol usb_stor_resume from namespace USB_STORAGE_NS, but does not import it. Signed-off-by: Martijn Coenen --- scripts/mod/modpost.c | 70 +++++++++++++++++++++++++++++++++++++++---- scripts/mod/modpost.h | 7 +++++ 2 files changed, 72 insertions(+), 5 deletions(-) diff --git a/scripts/mod/modpost.c b/scripts/mod/modpost.c index 1663fb19343a..a56a8461a96a 100644 --- a/scripts/mod/modpost.c +++ b/scripts/mod/modpost.c @@ -165,6 +165,7 @@ struct symbol { struct module *module; unsigned int crc; int crc_valid; + const char *ns; /* namespace */ unsigned int weak:1; unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */ unsigned int kernel:1; /* 1 if symbol is from kernel @@ -234,6 +235,35 @@ static struct symbol *find_symbol(const char *name) return NULL; } +static bool contains_namespace(struct namespace_list *list, const char *ns) +{ + struct namespace_list *ns_entry; + + for (ns_entry = list; ns_entry != NULL; ns_entry = ns_entry->next) { + if (strcmp(ns_entry->namespace, ns) == 0) + return true; + } + + return false; +} + +static void add_namespace(struct namespace_list **list, const char *ns) +{ + struct namespace_list *ns_entry; + + if (!contains_namespace(*list, ns)) { + ns_entry = NOFAIL(malloc(sizeof(struct namespace_list))); + strcpy(ns_entry->namespace, ns); + ns_entry->next = *list; + *list = ns_entry; + } +} + +static bool module_imports_namespace(struct module *module, const char *ns) +{ + return contains_namespace(module->imported_namespaces, ns); +} + static const struct { const char *str; enum export export; @@ -313,21 +343,40 @@ static enum export export_from_sec(struct elf_info *elf, unsigned int sec) return export_unknown; } +static const char *sym_extract_ns(const char **symname) +{ + size_t n; + + n = strcspn(*symname, "."); + if (n < strlen(*symname) - 1) { + char *dupsymname = NOFAIL(strdup(*symname)); + + dupsymname[n] = '\0'; + *symname = dupsymname; + return dupsymname + n + 1; + } else { + return NULL; + } +} + /** * Add an exported symbol - it may have already been added without a * CRC, in this case just update the CRC **/ -static struct symbol *sym_add_exported(const char *name, struct module *mod, - enum export export) +static struct symbol *sym_add_exported(const char *name, + struct module *mod, enum export export) { - struct symbol *s = find_symbol(name); + const char *extract_name = name; + const char *ns = sym_extract_ns(&extract_name); + struct symbol *s = find_symbol(extract_name); if (!s) { - s = new_symbol(name, mod, export); + s = new_symbol(extract_name, mod, export); + s->ns = ns; } else { if (!s->preloaded) { warn("%s: '%s' exported twice. Previous export " - "was in %s%s\n", mod->name, name, + "was in %s%s\n", mod->name, extract_name, s->module->name, is_vmlinux(s->module->name) ?"":".ko"); } else { @@ -697,6 +746,10 @@ static void handle_modversions(struct module *mod, struct elf_info *info, } if (strcmp(symname, "init_module") == 0) mod->has_init = 1; + if (strstarts(symname, "__knsimport_")) { + const char *name = symname + strlen("__knsimport_"); + add_namespace(&mod->imported_namespaces, name); + } if (strcmp(symname, "cleanup_module") == 0) mod->has_cleanup = 1; break; @@ -2097,6 +2150,13 @@ static void check_exports(struct module *mod) basename++; else basename = mod->name; + + if (exp->ns && !module_imports_namespace(mod, exp->ns)) { + warn("module %s uses symbol %s from namespace %s, " + "but does not import it.\n", + basename, exp->name, exp->ns); + } + if (!mod->gpl_compatible) check_for_gpl_usage(exp->export, basename, exp->name); check_for_unused(exp->export, basename, exp->name); diff --git a/scripts/mod/modpost.h b/scripts/mod/modpost.h index 8453d6ac2f77..9626bf3e7424 100644 --- a/scripts/mod/modpost.h +++ b/scripts/mod/modpost.h @@ -109,6 +109,11 @@ buf_printf(struct buffer *buf, const char *fmt, ...); void buf_write(struct buffer *buf, const char *s, int len); +struct namespace_list { + struct namespace_list *next; + char namespace[0]; +}; + struct module { struct module *next; const char *name; @@ -121,6 +126,8 @@ struct module { struct buffer dev_table_buf; char srcversion[25]; int is_dot_o; + // Actual imported namespaces + struct namespace_list *imported_namespaces; }; struct elf_info { -- 2.18.0.203.gfac676dfb9-goog From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-ed1-f51.google.com ([209.85.208.51]:40438 "EHLO mail-ed1-f51.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729827AbeGPMst (ORCPT ); Mon, 16 Jul 2018 08:48:49 -0400 Received: by mail-ed1-f51.google.com with SMTP id e19-v6so29791600edq.7 for ; Mon, 16 Jul 2018 05:21:37 -0700 (PDT) From: Martijn Coenen Subject: [PATCH 3/6] modpost: add support for checking symbol namespaces. Date: Mon, 16 Jul 2018 14:21:22 +0200 Message-ID: <20180716122125.175792-4-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: <20180716122122.Hqa_dr3Os41Sk0vSSMY7fbamk9sMOrBp-3ira5Ga-1k@z> Emits a warning whenever a module refers to an exported symbol without explicitly importing the namespace that it is defined in. Example: WARNING: module ums-usbat uses symbol usb_stor_resume from namespace USB_STORAGE_NS, but does not import it. Signed-off-by: Martijn Coenen --- scripts/mod/modpost.c | 70 +++++++++++++++++++++++++++++++++++++++---- scripts/mod/modpost.h | 7 +++++ 2 files changed, 72 insertions(+), 5 deletions(-) diff --git a/scripts/mod/modpost.c b/scripts/mod/modpost.c index 1663fb19343a..a56a8461a96a 100644 --- a/scripts/mod/modpost.c +++ b/scripts/mod/modpost.c @@ -165,6 +165,7 @@ struct symbol { struct module *module; unsigned int crc; int crc_valid; + const char *ns; /* namespace */ unsigned int weak:1; unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */ unsigned int kernel:1; /* 1 if symbol is from kernel @@ -234,6 +235,35 @@ static struct symbol *find_symbol(const char *name) return NULL; } +static bool contains_namespace(struct namespace_list *list, const char *ns) +{ + struct namespace_list *ns_entry; + + for (ns_entry = list; ns_entry != NULL; ns_entry = ns_entry->next) { + if (strcmp(ns_entry->namespace, ns) == 0) + return true; + } + + return false; +} + +static void add_namespace(struct namespace_list **list, const char *ns) +{ + struct namespace_list *ns_entry; + + if (!contains_namespace(*list, ns)) { + ns_entry = NOFAIL(malloc(sizeof(struct namespace_list))); + strcpy(ns_entry->namespace, ns); + ns_entry->next = *list; + *list = ns_entry; + } +} + +static bool module_imports_namespace(struct module *module, const char *ns) +{ + return contains_namespace(module->imported_namespaces, ns); +} + static const struct { const char *str; enum export export; @@ -313,21 +343,40 @@ static enum export export_from_sec(struct elf_info *elf, unsigned int sec) return export_unknown; } +static const char *sym_extract_ns(const char **symname) +{ + size_t n; + + n = strcspn(*symname, "."); + if (n < strlen(*symname) - 1) { + char *dupsymname = NOFAIL(strdup(*symname)); + + dupsymname[n] = '\0'; + *symname = dupsymname; + return dupsymname + n + 1; + } else { + return NULL; + } +} + /** * Add an exported symbol - it may have already been added without a * CRC, in this case just update the CRC **/ -static struct symbol *sym_add_exported(const char *name, struct module *mod, - enum export export) +static struct symbol *sym_add_exported(const char *name, + struct module *mod, enum export export) { - struct symbol *s = find_symbol(name); + const char *extract_name = name; + const char *ns = sym_extract_ns(&extract_name); + struct symbol *s = find_symbol(extract_name); if (!s) { - s = new_symbol(name, mod, export); + s = new_symbol(extract_name, mod, export); + s->ns = ns; } else { if (!s->preloaded) { warn("%s: '%s' exported twice. Previous export " - "was in %s%s\n", mod->name, name, + "was in %s%s\n", mod->name, extract_name, s->module->name, is_vmlinux(s->module->name) ?"":".ko"); } else { @@ -697,6 +746,10 @@ static void handle_modversions(struct module *mod, struct elf_info *info, } if (strcmp(symname, "init_module") == 0) mod->has_init = 1; + if (strstarts(symname, "__knsimport_")) { + const char *name = symname + strlen("__knsimport_"); + add_namespace(&mod->imported_namespaces, name); + } if (strcmp(symname, "cleanup_module") == 0) mod->has_cleanup = 1; break; @@ -2097,6 +2150,13 @@ static void check_exports(struct module *mod) basename++; else basename = mod->name; + + if (exp->ns && !module_imports_namespace(mod, exp->ns)) { + warn("module %s uses symbol %s from namespace %s, " + "but does not import it.\n", + basename, exp->name, exp->ns); + } + if (!mod->gpl_compatible) check_for_gpl_usage(exp->export, basename, exp->name); check_for_unused(exp->export, basename, exp->name); diff --git a/scripts/mod/modpost.h b/scripts/mod/modpost.h index 8453d6ac2f77..9626bf3e7424 100644 --- a/scripts/mod/modpost.h +++ b/scripts/mod/modpost.h @@ -109,6 +109,11 @@ buf_printf(struct buffer *buf, const char *fmt, ...); void buf_write(struct buffer *buf, const char *s, int len); +struct namespace_list { + struct namespace_list *next; + char namespace[0]; +}; + struct module { struct module *next; const char *name; @@ -121,6 +126,8 @@ struct module { struct buffer dev_table_buf; char srcversion[25]; int is_dot_o; + // Actual imported namespaces + struct namespace_list *imported_namespaces; }; struct elf_info { -- 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: [3/6] modpost: add support for checking symbol namespaces. From: Martijn Coenen Message-Id: <20180716122125.175792-4-maco@android.com> Date: Mon, 16 Jul 2018 14:21:22 +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: RW1pdHMgYSB3YXJuaW5nIHdoZW5ldmVyIGEgbW9kdWxlIHJlZmVycyB0byBhbiBleHBvcnRlZCBz eW1ib2wgd2l0aG91dApleHBsaWNpdGx5IGltcG9ydGluZyB0aGUgbmFtZXNwYWNlIHRoYXQgaXQg aXMgZGVmaW5lZCBpbi4KCkV4YW1wbGU6CgpXQVJOSU5HOiBtb2R1bGUgdW1zLXVzYmF0IHVzZXMg c3ltYm9sIHVzYl9zdG9yX3Jlc3VtZSBmcm9tIG5hbWVzcGFjZQpVU0JfU1RPUkFHRV9OUywgYnV0 IGRvZXMgbm90IGltcG9ydCBpdC4KClNpZ25lZC1vZmYtYnk6IE1hcnRpam4gQ29lbmVuIDxtYWNv QGFuZHJvaWQuY29tPgotLS0KIHNjcmlwdHMvbW9kL21vZHBvc3QuYyB8IDcwICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0KIHNjcmlwdHMvbW9kL21vZHBvc3QuaCB8 ICA3ICsrKysrCiAyIGZpbGVzIGNoYW5nZWQsIDcyIGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25z KC0pCgpkaWZmIC0tZ2l0IGEvc2NyaXB0cy9tb2QvbW9kcG9zdC5jIGIvc2NyaXB0cy9tb2QvbW9k cG9zdC5jCmluZGV4IDE2NjNmYjE5MzQzYS4uYTU2YTg0NjFhOTZhIDEwMDY0NAotLS0gYS9zY3Jp cHRzL21vZC9tb2Rwb3N0LmMKKysrIGIvc2NyaXB0cy9tb2QvbW9kcG9zdC5jCkBAIC0xNjUsNiAr MTY1LDcgQEAgc3RydWN0IHN5bWJvbCB7CiAJc3RydWN0IG1vZHVsZSAqbW9kdWxlOwogCXVuc2ln bmVkIGludCBjcmM7CiAJaW50IGNyY192YWxpZDsKKwljb25zdCBjaGFyICpuczsgLyogbmFtZXNw YWNlICovCiAJdW5zaWduZWQgaW50IHdlYWs6MTsKIAl1bnNpZ25lZCBpbnQgdm1saW51eDoxOyAg ICAvKiAxIGlmIHN5bWJvbCBpcyBkZWZpbmVkIGluIHZtbGludXggKi8KIAl1bnNpZ25lZCBpbnQg a2VybmVsOjE7ICAgICAvKiAxIGlmIHN5bWJvbCBpcyBmcm9tIGtlcm5lbApAQCAtMjM0LDYgKzIz NSwzNSBAQCBzdGF0aWMgc3RydWN0IHN5bWJvbCAqZmluZF9zeW1ib2woY29uc3QgY2hhciAqbmFt ZSkKIAlyZXR1cm4gTlVMTDsKIH0KIAorc3RhdGljIGJvb2wgY29udGFpbnNfbmFtZXNwYWNlKHN0 cnVjdCBuYW1lc3BhY2VfbGlzdCAqbGlzdCwgY29uc3QgY2hhciAqbnMpCit7CisJc3RydWN0IG5h bWVzcGFjZV9saXN0ICpuc19lbnRyeTsKKworCWZvciAobnNfZW50cnkgPSBsaXN0OyBuc19lbnRy eSAhPSBOVUxMOyBuc19lbnRyeSA9IG5zX2VudHJ5LT5uZXh0KSB7CisJCWlmIChzdHJjbXAobnNf ZW50cnktPm5hbWVzcGFjZSwgbnMpID09IDApCisJCQlyZXR1cm4gdHJ1ZTsKKwl9CisKKwlyZXR1 cm4gZmFsc2U7Cit9CisKK3N0YXRpYyB2b2lkIGFkZF9uYW1lc3BhY2Uoc3RydWN0IG5hbWVzcGFj ZV9saXN0ICoqbGlzdCwgY29uc3QgY2hhciAqbnMpCit7CisJc3RydWN0IG5hbWVzcGFjZV9saXN0 ICpuc19lbnRyeTsKKworCWlmICghY29udGFpbnNfbmFtZXNwYWNlKCpsaXN0LCBucykpIHsKKwkJ bnNfZW50cnkgPSBOT0ZBSUwobWFsbG9jKHNpemVvZihzdHJ1Y3QgbmFtZXNwYWNlX2xpc3QpKSk7 CisJCXN0cmNweShuc19lbnRyeS0+bmFtZXNwYWNlLCBucyk7CisJCW5zX2VudHJ5LT5uZXh0ID0g Kmxpc3Q7CisJCSpsaXN0ID0gbnNfZW50cnk7CisJfQorfQorCitzdGF0aWMgYm9vbCBtb2R1bGVf aW1wb3J0c19uYW1lc3BhY2Uoc3RydWN0IG1vZHVsZSAqbW9kdWxlLCBjb25zdCBjaGFyICpucykK K3sKKwlyZXR1cm4gY29udGFpbnNfbmFtZXNwYWNlKG1vZHVsZS0+aW1wb3J0ZWRfbmFtZXNwYWNl cywgbnMpOworfQorCiBzdGF0aWMgY29uc3Qgc3RydWN0IHsKIAljb25zdCBjaGFyICpzdHI7CiAJ ZW51bSBleHBvcnQgZXhwb3J0OwpAQCAtMzEzLDIxICszNDMsNDAgQEAgc3RhdGljIGVudW0gZXhw b3J0IGV4cG9ydF9mcm9tX3NlYyhzdHJ1Y3QgZWxmX2luZm8gKmVsZiwgdW5zaWduZWQgaW50IHNl YykKIAkJcmV0dXJuIGV4cG9ydF91bmtub3duOwogfQogCitzdGF0aWMgY29uc3QgY2hhciAqc3lt X2V4dHJhY3RfbnMoY29uc3QgY2hhciAqKnN5bW5hbWUpCit7CisJc2l6ZV90IG47CisKKwluID0g c3RyY3Nwbigqc3ltbmFtZSwgIi4iKTsKKwlpZiAobiA8IHN0cmxlbigqc3ltbmFtZSkgLSAxKSB7 CisJCWNoYXIgKmR1cHN5bW5hbWUgPSBOT0ZBSUwoc3RyZHVwKCpzeW1uYW1lKSk7CisKKwkJZHVw c3ltbmFtZVtuXSA9ICdcMCc7CisJCSpzeW1uYW1lID0gZHVwc3ltbmFtZTsKKwkJcmV0dXJuIGR1 cHN5bW5hbWUgKyBuICsgMTsKKwl9IGVsc2UgeworCQlyZXR1cm4gTlVMTDsKKwl9Cit9CisKIC8q KgogICogQWRkIGFuIGV4cG9ydGVkIHN5bWJvbCAtIGl0IG1heSBoYXZlIGFscmVhZHkgYmVlbiBh ZGRlZCB3aXRob3V0IGEKICAqIENSQywgaW4gdGhpcyBjYXNlIGp1c3QgdXBkYXRlIHRoZSBDUkMK ICAqKi8KLXN0YXRpYyBzdHJ1Y3Qgc3ltYm9sICpzeW1fYWRkX2V4cG9ydGVkKGNvbnN0IGNoYXIg Km5hbWUsIHN0cnVjdCBtb2R1bGUgKm1vZCwKLQkJCQkgICAgICAgZW51bSBleHBvcnQgZXhwb3J0 KQorc3RhdGljIHN0cnVjdCBzeW1ib2wgKnN5bV9hZGRfZXhwb3J0ZWQoY29uc3QgY2hhciAqbmFt ZSwKKwkJCQkgICAgICAgc3RydWN0IG1vZHVsZSAqbW9kLCBlbnVtIGV4cG9ydCBleHBvcnQpCiB7 Ci0Jc3RydWN0IHN5bWJvbCAqcyA9IGZpbmRfc3ltYm9sKG5hbWUpOworCWNvbnN0IGNoYXIgKmV4 dHJhY3RfbmFtZSA9IG5hbWU7CisJY29uc3QgY2hhciAqbnMgPSBzeW1fZXh0cmFjdF9ucygmZXh0 cmFjdF9uYW1lKTsKKwlzdHJ1Y3Qgc3ltYm9sICpzID0gZmluZF9zeW1ib2woZXh0cmFjdF9uYW1l KTsKIAogCWlmICghcykgewotCQlzID0gbmV3X3N5bWJvbChuYW1lLCBtb2QsIGV4cG9ydCk7CisJ CXMgPSBuZXdfc3ltYm9sKGV4dHJhY3RfbmFtZSwgbW9kLCBleHBvcnQpOworCQlzLT5ucyA9IG5z OwogCX0gZWxzZSB7CiAJCWlmICghcy0+cHJlbG9hZGVkKSB7CiAJCQl3YXJuKCIlczogJyVzJyBl eHBvcnRlZCB0d2ljZS4gUHJldmlvdXMgZXhwb3J0ICIKLQkJCSAgICAgIndhcyBpbiAlcyVzXG4i LCBtb2QtPm5hbWUsIG5hbWUsCisJCQkgICAgICJ3YXMgaW4gJXMlc1xuIiwgbW9kLT5uYW1lLCBl eHRyYWN0X25hbWUsCiAJCQkgICAgIHMtPm1vZHVsZS0+bmFtZSwKIAkJCSAgICAgaXNfdm1saW51 eChzLT5tb2R1bGUtPm5hbWUpID8iIjoiLmtvIik7CiAJCX0gZWxzZSB7CkBAIC02OTcsNiArNzQ2 LDEwIEBAIHN0YXRpYyB2b2lkIGhhbmRsZV9tb2R2ZXJzaW9ucyhzdHJ1Y3QgbW9kdWxlICptb2Qs IHN0cnVjdCBlbGZfaW5mbyAqaW5mbywKIAkJfQogCQlpZiAoc3RyY21wKHN5bW5hbWUsICJpbml0 X21vZHVsZSIpID09IDApCiAJCQltb2QtPmhhc19pbml0ID0gMTsKKwkJaWYgKHN0cnN0YXJ0cyhz eW1uYW1lLCAiX19rbnNpbXBvcnRfIikpIHsKKwkJCWNvbnN0IGNoYXIgKm5hbWUgPSBzeW1uYW1l ICsgc3RybGVuKCJfX2tuc2ltcG9ydF8iKTsKKwkJCWFkZF9uYW1lc3BhY2UoJm1vZC0+aW1wb3J0 ZWRfbmFtZXNwYWNlcywgbmFtZSk7CisJCX0KIAkJaWYgKHN0cmNtcChzeW1uYW1lLCAiY2xlYW51 cF9tb2R1bGUiKSA9PSAwKQogCQkJbW9kLT5oYXNfY2xlYW51cCA9IDE7CiAJCWJyZWFrOwpAQCAt MjA5Nyw2ICsyMTUwLDEzIEBAIHN0YXRpYyB2b2lkIGNoZWNrX2V4cG9ydHMoc3RydWN0IG1vZHVs ZSAqbW9kKQogCQkJYmFzZW5hbWUrKzsKIAkJZWxzZQogCQkJYmFzZW5hbWUgPSBtb2QtPm5hbWU7 CisKKwkJaWYgKGV4cC0+bnMgJiYgIW1vZHVsZV9pbXBvcnRzX25hbWVzcGFjZShtb2QsIGV4cC0+ bnMpKSB7CisJCQl3YXJuKCJtb2R1bGUgJXMgdXNlcyBzeW1ib2wgJXMgZnJvbSBuYW1lc3BhY2Ug JXMsICIKKwkJCSAgICAgImJ1dCBkb2VzIG5vdCBpbXBvcnQgaXQuXG4iLAorCQkJICAgICBiYXNl bmFtZSwgZXhwLT5uYW1lLCBleHAtPm5zKTsKKwkJfQorCiAJCWlmICghbW9kLT5ncGxfY29tcGF0 aWJsZSkKIAkJCWNoZWNrX2Zvcl9ncGxfdXNhZ2UoZXhwLT5leHBvcnQsIGJhc2VuYW1lLCBleHAt Pm5hbWUpOwogCQljaGVja19mb3JfdW51c2VkKGV4cC0+ZXhwb3J0LCBiYXNlbmFtZSwgZXhwLT5u YW1lKTsKZGlmZiAtLWdpdCBhL3NjcmlwdHMvbW9kL21vZHBvc3QuaCBiL3NjcmlwdHMvbW9kL21v ZHBvc3QuaAppbmRleCA4NDUzZDZhYzJmNzcuLjk2MjZiZjNlNzQyNCAxMDA2NDQKLS0tIGEvc2Ny aXB0cy9tb2QvbW9kcG9zdC5oCisrKyBiL3NjcmlwdHMvbW9kL21vZHBvc3QuaApAQCAtMTA5LDYg KzEwOSwxMSBAQCBidWZfcHJpbnRmKHN0cnVjdCBidWZmZXIgKmJ1ZiwgY29uc3QgY2hhciAqZm10 LCAuLi4pOwogdm9pZAogYnVmX3dyaXRlKHN0cnVjdCBidWZmZXIgKmJ1ZiwgY29uc3QgY2hhciAq cywgaW50IGxlbik7CiAKK3N0cnVjdCBuYW1lc3BhY2VfbGlzdCB7CisJc3RydWN0IG5hbWVzcGFj ZV9saXN0ICpuZXh0OworCWNoYXIgbmFtZXNwYWNlWzBdOworfTsKKwogc3RydWN0IG1vZHVsZSB7 CiAJc3RydWN0IG1vZHVsZSAqbmV4dDsKIAljb25zdCBjaGFyICpuYW1lOwpAQCAtMTIxLDYgKzEy Niw4IEBAIHN0cnVjdCBtb2R1bGUgewogCXN0cnVjdCBidWZmZXIgZGV2X3RhYmxlX2J1ZjsKIAlj aGFyCSAgICAgc3JjdmVyc2lvblsyNV07CiAJaW50IGlzX2RvdF9vOworCS8vIEFjdHVhbCBpbXBv cnRlZCBuYW1lc3BhY2VzCisJc3RydWN0IG5hbWVzcGFjZV9saXN0ICppbXBvcnRlZF9uYW1lc3Bh Y2VzOwogfTsKIAogc3RydWN0IGVsZl9pbmZvIHsK