From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Garnier Date: Wed, 4 Oct 2017 14:19:59 -0700 Message-Id: <20171004212003.28296-24-thgarnie@google.com> In-Reply-To: <20171004212003.28296-1-thgarnie@google.com> References: <20171004212003.28296-1-thgarnie@google.com> Subject: [kernel-hardening] [RFC v3 23/27] x86/modules: Adapt module loading for PIE support To: Herbert Xu , "David S . Miller" , Thomas Gleixner , Ingo Molnar , "H . Peter Anvin" , Peter Zijlstra , Josh Poimboeuf , Thomas Garnier , Arnd Bergmann , Kees Cook , Matthias Kaehlcke , Tom Lendacky , Andy Lutomirski , "Kirill A . Shutemov" , Borislav Petkov , "Rafael J . Wysocki" , Len Brown , Pavel Machek , Juergen Gross , Chris Wright , Alok Kataria , Rusty Russell , Tejun Heo , Christoph Lameter , Boris Ostrovsky , Alexey Dobriyan , Andrew Morton , Paul Gortmaker , Chris Metcalf , "Paul E . McKenney" , Nicolas Pitre , Borislav Petkov , "Luis R . Rodriguez" , Greg Kroah-Hartman , Christopher Li , Steven Rostedt , Jason Baron , Dou Liyang , "Rafael J . Wysocki" , Mika Westerberg , Lukas Wunner , Masahiro Yamada , Alexei Starovoitov , Daniel Borkmann , Markus Trippelsdorf , Paolo Bonzini , =?UTF-8?q?Radim=20Kr=C4=8Dm=C3=A1=C5=99?= , Joerg Roedel , Rik van Riel , David Howells , Ard Biesheuvel , Waiman Long , Kyle Huey , Andrey Ryabinin , Jonathan Corbet , Matthew Wilcox , Michal Hocko , Peter Foley , Paul Bolle , Jiri Kosina , Rob Landley , "H . J . Lu" , Baoquan He , =?UTF-8?q?Jan=20H=20=2E=20Sch=C3=B6nherr?= , Daniel Micay Cc: x86@kernel.org, linux-crypto@vger.kernel.org, linux-kernel@vger.kernel.org, linux-pm@vger.kernel.org, virtualization@lists.linux-foundation.org, xen-devel@lists.xenproject.org, linux-arch@vger.kernel.org, linux-sparse@vger.kernel.org, kvm@vger.kernel.org, linux-doc@vger.kernel.org, kernel-hardening@lists.openwall.com List-ID: Adapt module loading to support PIE relocations. Generate dynamic GOT if a symbol requires it but no entry exist in the kernel GOT. Position Independent Executable (PIE) support will allow to extended the KASLR randomization range below the -2G memory limit. Signed-off-by: Thomas Garnier --- arch/x86/Makefile | 4 + arch/x86/include/asm/module.h | 14 +++ arch/x86/kernel/module.c | 204 ++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 217 insertions(+), 5 deletions(-) diff --git a/arch/x86/Makefile b/arch/x86/Makefile index 4cb4f0495ddc..42774185a58a 100644 --- a/arch/x86/Makefile +++ b/arch/x86/Makefile @@ -143,7 +143,11 @@ else KBUILD_CFLAGS += $(cflags-y) KBUILD_CFLAGS += -mno-red-zone +ifdef CONFIG_X86_PIE + KBUILD_LDFLAGS_MODULE += -T $(srctree)/arch/x86/kernel/module.lds +else KBUILD_CFLAGS += -mcmodel=kernel +endif # -funit-at-a-time shrinks the kernel .text considerably # unfortunately it makes reading oopses harder. diff --git a/arch/x86/include/asm/module.h b/arch/x86/include/asm/module.h index 9eb7c718aaf8..8e0bd52bbadf 100644 --- a/arch/x86/include/asm/module.h +++ b/arch/x86/include/asm/module.h @@ -4,12 +4,23 @@ #include #include +#ifdef CONFIG_X86_PIE +struct mod_got_sec { + struct elf64_shdr *got; + int got_num_entries; + int got_max_entries; +}; +#endif + struct mod_arch_specific { #ifdef CONFIG_ORC_UNWINDER unsigned int num_orcs; int *orc_unwind_ip; struct orc_entry *orc_unwind; #endif +#ifdef CONFIG_X86_PIE + struct mod_got_sec core; +#endif }; #ifdef CONFIG_X86_64 @@ -70,4 +81,7 @@ struct mod_arch_specific { # define MODULE_ARCH_VERMAGIC MODULE_PROC_FAMILY #endif + +u64 module_find_got_entry(struct module *mod, u64 addr); + #endif /* _ASM_X86_MODULE_H */ diff --git a/arch/x86/kernel/module.c b/arch/x86/kernel/module.c index 62e7d70aadd5..3b9b43a9d63b 100644 --- a/arch/x86/kernel/module.c +++ b/arch/x86/kernel/module.c @@ -30,6 +30,7 @@ #include #include #include +#include #include #include @@ -77,6 +78,195 @@ static unsigned long int get_module_load_offset(void) } #endif +#ifdef CONFIG_X86_PIE +static u64 find_got_kernel_entry(Elf64_Sym *sym, const Elf64_Rela *rela) +{ + u64 *pos; + + for (pos = (u64*)__start_got; pos < (u64*)__end_got; pos++) { + if (*pos == sym->st_value) + return (u64)pos + rela->r_addend; + } + + return 0; +} + +/* Search the GOT entry for a specific address and a module (optional) */ +u64 module_find_got_entry(struct module *mod, u64 addr) +{ + int i; + u64 *pos; + + for (pos = (u64*)__start_got; pos < (u64*)__end_got; pos++) { + if (*pos == addr) + return (u64)pos; + } + + if (!mod) + return 0; + + pos = (u64*)mod->arch.core.got->sh_addr; + for (i = 0; i < mod->arch.core.got_num_entries; i++) { + if (pos[i] == addr) + return (u64)&pos[i]; + } + return 0; +} + +static u64 module_emit_got_entry(struct module *mod, void *loc, + const Elf64_Rela *rela, Elf64_Sym *sym) +{ + struct mod_got_sec *gotsec = &mod->arch.core; + u64 *got = (u64*)gotsec->got->sh_addr; + int i = gotsec->got_num_entries; + u64 ret; + + /* Check if we can use the kernel GOT */ + ret = find_got_kernel_entry(sym, rela); + if (ret) + return ret; + + got[i] = sym->st_value; + + /* + * Check if the entry we just created is a duplicate. Given that the + * relocations are sorted, this will be the last entry we allocated. + * (if one exists). + */ + if (i > 0 && got[i] == got[i - 2]) { + ret = (u64)&got[i - 1]; + } else { + gotsec->got_num_entries++; + BUG_ON(gotsec->got_num_entries > gotsec->got_max_entries); + ret = (u64)&got[i]; + } + + return ret + rela->r_addend; +} + +#define cmp_3way(a,b) ((a) < (b) ? -1 : (a) > (b)) + +static int cmp_rela(const void *a, const void *b) +{ + const Elf64_Rela *x = a, *y = b; + int i; + + /* sort by type, symbol index and addend */ + i = cmp_3way(ELF64_R_TYPE(x->r_info), ELF64_R_TYPE(y->r_info)); + if (i == 0) + i = cmp_3way(ELF64_R_SYM(x->r_info), ELF64_R_SYM(y->r_info)); + if (i == 0) + i = cmp_3way(x->r_addend, y->r_addend); + return i; +} + +static bool duplicate_rel(const Elf64_Rela *rela, int num) +{ + /* + * Entries are sorted by type, symbol index and addend. That means + * that, if a duplicate entry exists, it must be in the preceding + * slot. + */ + return num > 0 && cmp_rela(rela + num, rela + num - 1) == 0; +} + +static unsigned int count_gots(Elf64_Sym *syms, Elf64_Rela *rela, int num) +{ + unsigned int ret = 0; + Elf64_Sym *s; + int i; + + for (i = 0; i < num; i++) { + switch (ELF64_R_TYPE(rela[i].r_info)) { + case R_X86_64_GOTPCREL: + s = syms + ELF64_R_SYM(rela[i].r_info); + + /* + * Use the kernel GOT when possible, else reserve a + * custom one for this module. + */ + if (!duplicate_rel(rela, i) && + !find_got_kernel_entry(s, rela + i)) + ret++; + break; + } + } + return ret; +} + +/* + * Generate GOT entries for GOTPCREL relocations that do not exists in the + * kernel GOT. Based on arm64 module-plts implementation. + */ +int module_frob_arch_sections(Elf_Ehdr *ehdr, Elf_Shdr *sechdrs, + char *secstrings, struct module *mod) +{ + unsigned long gots = 0; + Elf_Shdr *symtab = NULL; + Elf64_Sym *syms = NULL; + char *strings, *name; + int i; + + /* + * Find the empty .got section so we can expand it to store the PLT + * entries. Record the symtab address as well. + */ + for (i = 0; i < ehdr->e_shnum; i++) { + if (!strcmp(secstrings + sechdrs[i].sh_name, ".got")) { + mod->arch.core.got = sechdrs + i; + } else if (sechdrs[i].sh_type == SHT_SYMTAB) { + symtab = sechdrs + i; + syms = (Elf64_Sym *)symtab->sh_addr; + } + } + + if (!mod->arch.core.got) { + pr_err("%s: module GOT section missing\n", mod->name); + return -ENOEXEC; + } + if (!syms) { + pr_err("%s: module symtab section missing\n", mod->name); + return -ENOEXEC; + } + + for (i = 0; i < ehdr->e_shnum; i++) { + Elf64_Rela *rels = (void *)ehdr + sechdrs[i].sh_offset; + int numrels = sechdrs[i].sh_size / sizeof(Elf64_Rela); + + if (sechdrs[i].sh_type != SHT_RELA) + continue; + + /* sort by type, symbol index and addend */ + sort(rels, numrels, sizeof(Elf64_Rela), cmp_rela, NULL); + + gots += count_gots(syms, rels, numrels); + } + + mod->arch.core.got->sh_type = SHT_NOBITS; + mod->arch.core.got->sh_flags = SHF_ALLOC; + mod->arch.core.got->sh_addralign = L1_CACHE_BYTES; + mod->arch.core.got->sh_size = (gots + 1) * sizeof(u64); + mod->arch.core.got_num_entries = 0; + mod->arch.core.got_max_entries = gots; + + /* + * If a _GLOBAL_OFFSET_TABLE_ symbol exists, make it absolute for + * modules to correctly reference it. Similar to s390 implementation. + */ + strings = (void *) ehdr + sechdrs[symtab->sh_link].sh_offset; + for (i = 0; i < symtab->sh_size/sizeof(Elf_Sym); i++) { + if (syms[i].st_shndx != SHN_UNDEF) + continue; + name = strings + syms[i].st_name; + if (!strcmp(name, "_GLOBAL_OFFSET_TABLE_")) { + syms[i].st_shndx = SHN_ABS; + break; + } + } + return 0; +} +#endif + void *module_alloc(unsigned long size) { void *p; @@ -184,13 +374,18 @@ int apply_relocate_add(Elf64_Shdr *sechdrs, if ((s64)val != *(s32 *)loc) goto overflow; break; +#ifdef CONFIG_X86_PIE + case R_X86_64_GOTPCREL: + val = module_emit_got_entry(me, loc, rel + i, sym); + /* fallthrough */ +#endif + case R_X86_64_PLT32: case R_X86_64_PC32: val -= (u64)loc; *(u32 *)loc = val; -#if 0 - if ((s64)val != *(s32 *)loc) + if (IS_ENABLED(CONFIG_X86_PIE) && + (s64)val != *(s32 *)loc) goto overflow; -#endif break; default: pr_err("%s: Unknown rela relocation: %llu\n", @@ -203,8 +398,7 @@ int apply_relocate_add(Elf64_Shdr *sechdrs, overflow: pr_err("overflow in relocation type %d val %Lx\n", (int)ELF64_R_TYPE(rel[i].r_info), val); - pr_err("`%s' likely not compiled with -mcmodel=kernel\n", - me->name); + pr_err("`%s' likely too far from the kernel\n", me->name); return -ENOEXEC; } #endif -- 2.14.2.920.gcf0c67979c-goog From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Garnier Subject: [RFC v3 23/27] x86/modules: Adapt module loading for PIE support Date: Wed, 4 Oct 2017 14:19:59 -0700 Message-ID: <20171004212003.28296-24-thgarnie@google.com> References: <20171004212003.28296-1-thgarnie@google.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20171004212003.28296-1-thgarnie@google.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: Herbert Xu , "David S . Miller" , Thomas Gleixner , Ingo Molnar , "H . Peter Anvin" , Peter Zijlstra , Josh Poimboeuf , Thomas Garnier , Arnd Bergmann , Kees Cook , Matthias Kaehlcke , Tom Lendacky , Andy Lutomirski , "Kirill A . Shutemov" , Borislav Petkov , "Rafael J . Wysocki" , Len Brown , Pavel Machek , Juergen Gross , Chris Wright , Alok Kataria , Rusty Russell , Tejun Heo , Christoph Lameter Bor Cc: linux-arch@vger.kernel.org, kvm@vger.kernel.org, linux-pm@vger.kernel.org, x86@kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, linux-sparse@vger.kernel.org, linux-crypto@vger.kernel.org, kernel-hardening@lists.openwall.com, xen-devel@lists.xenproject.org List-Id: linux-arch.vger.kernel.org QWRhcHQgbW9kdWxlIGxvYWRpbmcgdG8gc3VwcG9ydCBQSUUgcmVsb2NhdGlvbnMuIEdlbmVyYXRl IGR5bmFtaWMgR09UIGlmCmEgc3ltYm9sIHJlcXVpcmVzIGl0IGJ1dCBubyBlbnRyeSBleGlzdCBp biB0aGUga2VybmVsIEdPVC4KClBvc2l0aW9uIEluZGVwZW5kZW50IEV4ZWN1dGFibGUgKFBJRSkg c3VwcG9ydCB3aWxsIGFsbG93IHRvIGV4dGVuZGVkIHRoZQpLQVNMUiByYW5kb21pemF0aW9uIHJh bmdlIGJlbG93IHRoZSAtMkcgbWVtb3J5IGxpbWl0LgoKU2lnbmVkLW9mZi1ieTogVGhvbWFzIEdh cm5pZXIgPHRoZ2FybmllQGdvb2dsZS5jb20+Ci0tLQogYXJjaC94ODYvTWFrZWZpbGUgICAgICAg ICAgICAgfCAgIDQgKwogYXJjaC94ODYvaW5jbHVkZS9hc20vbW9kdWxlLmggfCAgMTQgKysrCiBh cmNoL3g4Ni9rZXJuZWwvbW9kdWxlLmMgICAgICB8IDIwNCArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrLS0KIDMgZmlsZXMgY2hhbmdlZCwgMjE3IGluc2VydGlvbnMoKyks IDUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvTWFrZWZpbGUgYi9hcmNoL3g4 Ni9NYWtlZmlsZQppbmRleCA0Y2I0ZjA0OTVkZGMuLjQyNzc0MTg1YTU4YSAxMDA2NDQKLS0tIGEv YXJjaC94ODYvTWFrZWZpbGUKKysrIGIvYXJjaC94ODYvTWFrZWZpbGUKQEAgLTE0Myw3ICsxNDMs MTEgQEAgZWxzZQogICAgICAgICBLQlVJTERfQ0ZMQUdTICs9ICQoY2ZsYWdzLXkpCiAKICAgICAg ICAgS0JVSUxEX0NGTEFHUyArPSAtbW5vLXJlZC16b25lCitpZmRlZiBDT05GSUdfWDg2X1BJRQor ICAgICAgICBLQlVJTERfTERGTEFHU19NT0RVTEUgKz0gLVQgJChzcmN0cmVlKS9hcmNoL3g4Ni9r ZXJuZWwvbW9kdWxlLmxkcworZWxzZQogICAgICAgICBLQlVJTERfQ0ZMQUdTICs9IC1tY21vZGVs PWtlcm5lbAorZW5kaWYKIAogICAgICAgICAjIC1mdW5pdC1hdC1hLXRpbWUgc2hyaW5rcyB0aGUg a2VybmVsIC50ZXh0IGNvbnNpZGVyYWJseQogICAgICAgICAjIHVuZm9ydHVuYXRlbHkgaXQgbWFr ZXMgcmVhZGluZyBvb3BzZXMgaGFyZGVyLgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9h c20vbW9kdWxlLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9tb2R1bGUuaAppbmRleCA5ZWI3Yzcx OGFhZjguLjhlMGJkNTJiYmFkZiAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vbW9k dWxlLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vbW9kdWxlLmgKQEAgLTQsMTIgKzQsMjMg QEAKICNpbmNsdWRlIDxhc20tZ2VuZXJpYy9tb2R1bGUuaD4KICNpbmNsdWRlIDxhc20vb3JjX3R5 cGVzLmg+CiAKKyNpZmRlZiBDT05GSUdfWDg2X1BJRQorc3RydWN0IG1vZF9nb3Rfc2VjIHsKKwlz dHJ1Y3QgZWxmNjRfc2hkcgkqZ290OworCWludAkJCWdvdF9udW1fZW50cmllczsKKwlpbnQJCQln b3RfbWF4X2VudHJpZXM7Cit9OworI2VuZGlmCisKIHN0cnVjdCBtb2RfYXJjaF9zcGVjaWZpYyB7 CiAjaWZkZWYgQ09ORklHX09SQ19VTldJTkRFUgogCXVuc2lnbmVkIGludCBudW1fb3JjczsKIAlp bnQgKm9yY191bndpbmRfaXA7CiAJc3RydWN0IG9yY19lbnRyeSAqb3JjX3Vud2luZDsKICNlbmRp ZgorI2lmZGVmIENPTkZJR19YODZfUElFCisJc3RydWN0IG1vZF9nb3Rfc2VjCWNvcmU7CisjZW5k aWYKIH07CiAKICNpZmRlZiBDT05GSUdfWDg2XzY0CkBAIC03MCw0ICs4MSw3IEBAIHN0cnVjdCBt b2RfYXJjaF9zcGVjaWZpYyB7CiAjIGRlZmluZSBNT0RVTEVfQVJDSF9WRVJNQUdJQyBNT0RVTEVf UFJPQ19GQU1JTFkKICNlbmRpZgogCisKK3U2NCBtb2R1bGVfZmluZF9nb3RfZW50cnkoc3RydWN0 IG1vZHVsZSAqbW9kLCB1NjQgYWRkcik7CisKICNlbmRpZiAvKiBfQVNNX1g4Nl9NT0RVTEVfSCAq LwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL21vZHVsZS5jIGIvYXJjaC94ODYva2VybmVs L21vZHVsZS5jCmluZGV4IDYyZTdkNzBhYWRkNS4uM2I5YjQzYTlkNjNiIDEwMDY0NAotLS0gYS9h cmNoL3g4Ni9rZXJuZWwvbW9kdWxlLmMKKysrIGIvYXJjaC94ODYva2VybmVsL21vZHVsZS5jCkBA IC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSA8bGludXgvZ2ZwLmg+CiAjaW5jbHVkZSA8bGludXgv anVtcF9sYWJlbC5oPgogI2luY2x1ZGUgPGxpbnV4L3JhbmRvbS5oPgorI2luY2x1ZGUgPGxpbnV4 L3NvcnQuaD4KIAogI2luY2x1ZGUgPGFzbS90ZXh0LXBhdGNoaW5nLmg+CiAjaW5jbHVkZSA8YXNt L3BhZ2UuaD4KQEAgLTc3LDYgKzc4LDE5NSBAQCBzdGF0aWMgdW5zaWduZWQgbG9uZyBpbnQgZ2V0 X21vZHVsZV9sb2FkX29mZnNldCh2b2lkKQogfQogI2VuZGlmCiAKKyNpZmRlZiBDT05GSUdfWDg2 X1BJRQorc3RhdGljIHU2NCBmaW5kX2dvdF9rZXJuZWxfZW50cnkoRWxmNjRfU3ltICpzeW0sIGNv bnN0IEVsZjY0X1JlbGEgKnJlbGEpCit7CisJdTY0ICpwb3M7CisKKwlmb3IgKHBvcyA9ICh1NjQq KV9fc3RhcnRfZ290OyBwb3MgPCAodTY0KilfX2VuZF9nb3Q7IHBvcysrKSB7CisJCWlmICgqcG9z ID09IHN5bS0+c3RfdmFsdWUpCisJCQlyZXR1cm4gKHU2NClwb3MgKyByZWxhLT5yX2FkZGVuZDsK Kwl9CisKKwlyZXR1cm4gMDsKK30KKworLyogU2VhcmNoIHRoZSBHT1QgZW50cnkgZm9yIGEgc3Bl Y2lmaWMgYWRkcmVzcyBhbmQgYSBtb2R1bGUgKG9wdGlvbmFsKSAqLwordTY0IG1vZHVsZV9maW5k X2dvdF9lbnRyeShzdHJ1Y3QgbW9kdWxlICptb2QsIHU2NCBhZGRyKQoreworCWludCBpOworCXU2 NCAqcG9zOworCisJZm9yIChwb3MgPSAodTY0KilfX3N0YXJ0X2dvdDsgcG9zIDwgKHU2NCopX19l bmRfZ290OyBwb3MrKykgeworCQlpZiAoKnBvcyA9PSBhZGRyKQorCQkJcmV0dXJuICh1NjQpcG9z OworCX0KKworCWlmICghbW9kKQorCQlyZXR1cm4gMDsKKworCXBvcyA9ICh1NjQqKW1vZC0+YXJj aC5jb3JlLmdvdC0+c2hfYWRkcjsKKwlmb3IgKGkgPSAwOyBpIDwgbW9kLT5hcmNoLmNvcmUuZ290 X251bV9lbnRyaWVzOyBpKyspIHsKKwkJaWYgKHBvc1tpXSA9PSBhZGRyKQorCQkJcmV0dXJuICh1 NjQpJnBvc1tpXTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB1NjQgbW9kdWxlX2VtaXRf Z290X2VudHJ5KHN0cnVjdCBtb2R1bGUgKm1vZCwgdm9pZCAqbG9jLAorCQkJCSBjb25zdCBFbGY2 NF9SZWxhICpyZWxhLCBFbGY2NF9TeW0gKnN5bSkKK3sKKwlzdHJ1Y3QgbW9kX2dvdF9zZWMgKmdv dHNlYyA9ICZtb2QtPmFyY2guY29yZTsKKwl1NjQgKmdvdCA9ICh1NjQqKWdvdHNlYy0+Z290LT5z aF9hZGRyOworCWludCBpID0gZ290c2VjLT5nb3RfbnVtX2VudHJpZXM7CisJdTY0IHJldDsKKwor CS8qIENoZWNrIGlmIHdlIGNhbiB1c2UgdGhlIGtlcm5lbCBHT1QgKi8KKwlyZXQgPSBmaW5kX2dv dF9rZXJuZWxfZW50cnkoc3ltLCByZWxhKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJ Z290W2ldID0gc3ltLT5zdF92YWx1ZTsKKworCS8qCisJICogQ2hlY2sgaWYgdGhlIGVudHJ5IHdl IGp1c3QgY3JlYXRlZCBpcyBhIGR1cGxpY2F0ZS4gR2l2ZW4gdGhhdCB0aGUKKwkgKiByZWxvY2F0 aW9ucyBhcmUgc29ydGVkLCB0aGlzIHdpbGwgYmUgdGhlIGxhc3QgZW50cnkgd2UgYWxsb2NhdGVk LgorCSAqIChpZiBvbmUgZXhpc3RzKS4KKwkgKi8KKwlpZiAoaSA+IDAgJiYgZ290W2ldID09IGdv dFtpIC0gMl0pIHsKKwkJcmV0ID0gKHU2NCkmZ290W2kgLSAxXTsKKwl9IGVsc2UgeworCQlnb3Rz ZWMtPmdvdF9udW1fZW50cmllcysrOworCQlCVUdfT04oZ290c2VjLT5nb3RfbnVtX2VudHJpZXMg PiBnb3RzZWMtPmdvdF9tYXhfZW50cmllcyk7CisJCXJldCA9ICh1NjQpJmdvdFtpXTsKKwl9CisK KwlyZXR1cm4gcmV0ICsgcmVsYS0+cl9hZGRlbmQ7Cit9CisKKyNkZWZpbmUgY21wXzN3YXkoYSxi KQkoKGEpIDwgKGIpID8gLTEgOiAoYSkgPiAoYikpCisKK3N0YXRpYyBpbnQgY21wX3JlbGEoY29u c3Qgdm9pZCAqYSwgY29uc3Qgdm9pZCAqYikKK3sKKwljb25zdCBFbGY2NF9SZWxhICp4ID0gYSwg KnkgPSBiOworCWludCBpOworCisJLyogc29ydCBieSB0eXBlLCBzeW1ib2wgaW5kZXggYW5kIGFk ZGVuZCAqLworCWkgPSBjbXBfM3dheShFTEY2NF9SX1RZUEUoeC0+cl9pbmZvKSwgRUxGNjRfUl9U WVBFKHktPnJfaW5mbykpOworCWlmIChpID09IDApCisJCWkgPSBjbXBfM3dheShFTEY2NF9SX1NZ TSh4LT5yX2luZm8pLCBFTEY2NF9SX1NZTSh5LT5yX2luZm8pKTsKKwlpZiAoaSA9PSAwKQorCQlp ID0gY21wXzN3YXkoeC0+cl9hZGRlbmQsIHktPnJfYWRkZW5kKTsKKwlyZXR1cm4gaTsKK30KKwor c3RhdGljIGJvb2wgZHVwbGljYXRlX3JlbChjb25zdCBFbGY2NF9SZWxhICpyZWxhLCBpbnQgbnVt KQoreworCS8qCisJICogRW50cmllcyBhcmUgc29ydGVkIGJ5IHR5cGUsIHN5bWJvbCBpbmRleCBh bmQgYWRkZW5kLiBUaGF0IG1lYW5zCisJICogdGhhdCwgaWYgYSBkdXBsaWNhdGUgZW50cnkgZXhp c3RzLCBpdCBtdXN0IGJlIGluIHRoZSBwcmVjZWRpbmcKKwkgKiBzbG90LgorCSAqLworCXJldHVy biBudW0gPiAwICYmIGNtcF9yZWxhKHJlbGEgKyBudW0sIHJlbGEgKyBudW0gLSAxKSA9PSAwOwor fQorCitzdGF0aWMgdW5zaWduZWQgaW50IGNvdW50X2dvdHMoRWxmNjRfU3ltICpzeW1zLCBFbGY2 NF9SZWxhICpyZWxhLCBpbnQgbnVtKQoreworCXVuc2lnbmVkIGludCByZXQgPSAwOworCUVsZjY0 X1N5bSAqczsKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykgeworCQlzd2l0 Y2ggKEVMRjY0X1JfVFlQRShyZWxhW2ldLnJfaW5mbykpIHsKKwkJY2FzZSBSX1g4Nl82NF9HT1RQ Q1JFTDoKKwkJCXMgPSBzeW1zICsgRUxGNjRfUl9TWU0ocmVsYVtpXS5yX2luZm8pOworCisJCQkv KgorCQkJICogVXNlIHRoZSBrZXJuZWwgR09UIHdoZW4gcG9zc2libGUsIGVsc2UgcmVzZXJ2ZSBh CisJCQkgKiBjdXN0b20gb25lIGZvciB0aGlzIG1vZHVsZS4KKwkJCSAqLworCQkJaWYgKCFkdXBs aWNhdGVfcmVsKHJlbGEsIGkpICYmCisJCQkgICAgIWZpbmRfZ290X2tlcm5lbF9lbnRyeShzLCBy ZWxhICsgaSkpCisJCQkJcmV0Kys7CisJCQlicmVhazsKKwkJfQorCX0KKwlyZXR1cm4gcmV0Owor fQorCisvKgorICogR2VuZXJhdGUgR09UIGVudHJpZXMgZm9yIEdPVFBDUkVMIHJlbG9jYXRpb25z IHRoYXQgZG8gbm90IGV4aXN0cyBpbiB0aGUKKyAqIGtlcm5lbCBHT1QuIEJhc2VkIG9uIGFybTY0 IG1vZHVsZS1wbHRzIGltcGxlbWVudGF0aW9uLgorICovCitpbnQgbW9kdWxlX2Zyb2JfYXJjaF9z ZWN0aW9ucyhFbGZfRWhkciAqZWhkciwgRWxmX1NoZHIgKnNlY2hkcnMsCisJCQkgICAgICBjaGFy ICpzZWNzdHJpbmdzLCBzdHJ1Y3QgbW9kdWxlICptb2QpCit7CisJdW5zaWduZWQgbG9uZyBnb3Rz ID0gMDsKKwlFbGZfU2hkciAqc3ltdGFiID0gTlVMTDsKKwlFbGY2NF9TeW0gKnN5bXMgPSBOVUxM OworCWNoYXIgKnN0cmluZ3MsICpuYW1lOworCWludCBpOworCisJLyoKKwkgKiBGaW5kIHRoZSBl bXB0eSAuZ290IHNlY3Rpb24gc28gd2UgY2FuIGV4cGFuZCBpdCB0byBzdG9yZSB0aGUgUExUCisJ ICogZW50cmllcy4gUmVjb3JkIHRoZSBzeW10YWIgYWRkcmVzcyBhcyB3ZWxsLgorCSAqLworCWZv ciAoaSA9IDA7IGkgPCBlaGRyLT5lX3NobnVtOyBpKyspIHsKKwkJaWYgKCFzdHJjbXAoc2Vjc3Ry aW5ncyArIHNlY2hkcnNbaV0uc2hfbmFtZSwgIi5nb3QiKSkgeworCQkJbW9kLT5hcmNoLmNvcmUu Z290ID0gc2VjaGRycyArIGk7CisJCX0gZWxzZSBpZiAoc2VjaGRyc1tpXS5zaF90eXBlID09IFNI VF9TWU1UQUIpIHsKKwkJCXN5bXRhYiA9IHNlY2hkcnMgKyBpOworCQkJc3ltcyA9IChFbGY2NF9T eW0gKilzeW10YWItPnNoX2FkZHI7CisJCX0KKwl9CisKKwlpZiAoIW1vZC0+YXJjaC5jb3JlLmdv dCkgeworCQlwcl9lcnIoIiVzOiBtb2R1bGUgR09UIHNlY3Rpb24gbWlzc2luZ1xuIiwgbW9kLT5u YW1lKTsKKwkJcmV0dXJuIC1FTk9FWEVDOworCX0KKwlpZiAoIXN5bXMpIHsKKwkJcHJfZXJyKCIl czogbW9kdWxlIHN5bXRhYiBzZWN0aW9uIG1pc3NpbmdcbiIsIG1vZC0+bmFtZSk7CisJCXJldHVy biAtRU5PRVhFQzsKKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwgZWhkci0+ZV9zaG51bTsgaSsrKSB7 CisJCUVsZjY0X1JlbGEgKnJlbHMgPSAodm9pZCAqKWVoZHIgKyBzZWNoZHJzW2ldLnNoX29mZnNl dDsKKwkJaW50IG51bXJlbHMgPSBzZWNoZHJzW2ldLnNoX3NpemUgLyBzaXplb2YoRWxmNjRfUmVs YSk7CisKKwkJaWYgKHNlY2hkcnNbaV0uc2hfdHlwZSAhPSBTSFRfUkVMQSkKKwkJCWNvbnRpbnVl OworCisJCS8qIHNvcnQgYnkgdHlwZSwgc3ltYm9sIGluZGV4IGFuZCBhZGRlbmQgKi8KKwkJc29y dChyZWxzLCBudW1yZWxzLCBzaXplb2YoRWxmNjRfUmVsYSksIGNtcF9yZWxhLCBOVUxMKTsKKwor CQlnb3RzICs9IGNvdW50X2dvdHMoc3ltcywgcmVscywgbnVtcmVscyk7CisJfQorCisJbW9kLT5h cmNoLmNvcmUuZ290LT5zaF90eXBlID0gU0hUX05PQklUUzsKKwltb2QtPmFyY2guY29yZS5nb3Qt PnNoX2ZsYWdzID0gU0hGX0FMTE9DOworCW1vZC0+YXJjaC5jb3JlLmdvdC0+c2hfYWRkcmFsaWdu ID0gTDFfQ0FDSEVfQllURVM7CisJbW9kLT5hcmNoLmNvcmUuZ290LT5zaF9zaXplID0gKGdvdHMg KyAxKSAqIHNpemVvZih1NjQpOworCW1vZC0+YXJjaC5jb3JlLmdvdF9udW1fZW50cmllcyA9IDA7 CisJbW9kLT5hcmNoLmNvcmUuZ290X21heF9lbnRyaWVzID0gZ290czsKKworCS8qCisJICogSWYg YSBfR0xPQkFMX09GRlNFVF9UQUJMRV8gc3ltYm9sIGV4aXN0cywgbWFrZSBpdCBhYnNvbHV0ZSBm b3IKKwkgKiBtb2R1bGVzIHRvIGNvcnJlY3RseSByZWZlcmVuY2UgaXQuIFNpbWlsYXIgdG8gczM5 MCBpbXBsZW1lbnRhdGlvbi4KKwkgKi8KKwlzdHJpbmdzID0gKHZvaWQgKikgZWhkciArIHNlY2hk cnNbc3ltdGFiLT5zaF9saW5rXS5zaF9vZmZzZXQ7CisJZm9yIChpID0gMDsgaSA8IHN5bXRhYi0+ c2hfc2l6ZS9zaXplb2YoRWxmX1N5bSk7IGkrKykgeworCQlpZiAoc3ltc1tpXS5zdF9zaG5keCAh PSBTSE5fVU5ERUYpCisJCQljb250aW51ZTsKKwkJbmFtZSA9IHN0cmluZ3MgKyBzeW1zW2ldLnN0 X25hbWU7CisJCWlmICghc3RyY21wKG5hbWUsICJfR0xPQkFMX09GRlNFVF9UQUJMRV8iKSkgewor CQkJc3ltc1tpXS5zdF9zaG5keCA9IFNITl9BQlM7CisJCQlicmVhazsKKwkJfQorCX0KKwlyZXR1 cm4gMDsKK30KKyNlbmRpZgorCiB2b2lkICptb2R1bGVfYWxsb2ModW5zaWduZWQgbG9uZyBzaXpl KQogewogCXZvaWQgKnA7CkBAIC0xODQsMTMgKzM3NCwxOCBAQCBpbnQgYXBwbHlfcmVsb2NhdGVf YWRkKEVsZjY0X1NoZHIgKnNlY2hkcnMsCiAJCQlpZiAoKHM2NCl2YWwgIT0gKihzMzIgKilsb2Mp CiAJCQkJZ290byBvdmVyZmxvdzsKIAkJCWJyZWFrOworI2lmZGVmIENPTkZJR19YODZfUElFCisJ CWNhc2UgUl9YODZfNjRfR09UUENSRUw6CisJCQl2YWwgPSBtb2R1bGVfZW1pdF9nb3RfZW50cnko bWUsIGxvYywgcmVsICsgaSwgc3ltKTsKKwkJCS8qIGZhbGx0aHJvdWdoICovCisjZW5kaWYKKwkJ Y2FzZSBSX1g4Nl82NF9QTFQzMjoKIAkJY2FzZSBSX1g4Nl82NF9QQzMyOgogCQkJdmFsIC09ICh1 NjQpbG9jOwogCQkJKih1MzIgKilsb2MgPSB2YWw7Ci0jaWYgMAotCQkJaWYgKChzNjQpdmFsICE9 ICooczMyICopbG9jKQorCQkJaWYgKElTX0VOQUJMRUQoQ09ORklHX1g4Nl9QSUUpICYmCisJCQkg ICAgKHM2NCl2YWwgIT0gKihzMzIgKilsb2MpCiAJCQkJZ290byBvdmVyZmxvdzsKLSNlbmRpZgog CQkJYnJlYWs7CiAJCWRlZmF1bHQ6CiAJCQlwcl9lcnIoIiVzOiBVbmtub3duIHJlbGEgcmVsb2Nh dGlvbjogJWxsdVxuIiwKQEAgLTIwMyw4ICszOTgsNyBAQCBpbnQgYXBwbHlfcmVsb2NhdGVfYWRk KEVsZjY0X1NoZHIgKnNlY2hkcnMsCiBvdmVyZmxvdzoKIAlwcl9lcnIoIm92ZXJmbG93IGluIHJl bG9jYXRpb24gdHlwZSAlZCB2YWwgJUx4XG4iLAogCSAgICAgICAoaW50KUVMRjY0X1JfVFlQRShy ZWxbaV0ucl9pbmZvKSwgdmFsKTsKLQlwcl9lcnIoImAlcycgbGlrZWx5IG5vdCBjb21waWxlZCB3 aXRoIC1tY21vZGVsPWtlcm5lbFxuIiwKLQkgICAgICAgbWUtPm5hbWUpOworCXByX2VycigiYCVz JyBsaWtlbHkgdG9vIGZhciBmcm9tIHRoZSBrZXJuZWxcbiIsIG1lLT5uYW1lKTsKIAlyZXR1cm4g LUVOT0VYRUM7CiB9CiAjZW5kaWYKLS0gCjIuMTQuMi45MjAuZ2NmMGM2Nzk3OWMtZ29vZwoKCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBt YWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cHM6Ly9saXN0cy54ZW4ub3Jn L3hlbi1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Garnier Subject: [RFC v3 23/27] x86/modules: Adapt module loading for PIE support Date: Wed, 4 Oct 2017 14:19:59 -0700 Message-ID: <20171004212003.28296-24-thgarnie@google.com> References: <20171004212003.28296-1-thgarnie@google.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Cc: linux-arch@vger.kernel.org, kvm@vger.kernel.org, linux-pm@vger.kernel.org, x86@kernel.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, linux-sparse@vger.kernel.org, linux-crypto@vger.kernel.org, kernel-hardening@lists.openwall.com, xen-devel@lists.xenproject.org To: Herbert Xu , "David S . Miller" , Thomas Gleixner , Ingo Molnar , "H . Peter Anvin" , Peter Zijlstra , Josh Poimboeuf , Thomas Garnier , Arnd Bergmann , Kees Cook , Matthias Kaehlcke , Tom Lendacky , Andy Lutomirski , "Kirill A . Shutemov" , Borislav Petkov , "Rafael J . Wysocki" , Len Brown , Pavel Machek , Juergen Gross , Chris Wright , Alok Kataria , Rusty Russell , Tejun Heo , Christoph Lameter , Bor Return-path: In-Reply-To: <20171004212003.28296-1-thgarnie@google.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" List-Id: linux-crypto.vger.kernel.org QWRhcHQgbW9kdWxlIGxvYWRpbmcgdG8gc3VwcG9ydCBQSUUgcmVsb2NhdGlvbnMuIEdlbmVyYXRl IGR5bmFtaWMgR09UIGlmCmEgc3ltYm9sIHJlcXVpcmVzIGl0IGJ1dCBubyBlbnRyeSBleGlzdCBp biB0aGUga2VybmVsIEdPVC4KClBvc2l0aW9uIEluZGVwZW5kZW50IEV4ZWN1dGFibGUgKFBJRSkg c3VwcG9ydCB3aWxsIGFsbG93IHRvIGV4dGVuZGVkIHRoZQpLQVNMUiByYW5kb21pemF0aW9uIHJh bmdlIGJlbG93IHRoZSAtMkcgbWVtb3J5IGxpbWl0LgoKU2lnbmVkLW9mZi1ieTogVGhvbWFzIEdh cm5pZXIgPHRoZ2FybmllQGdvb2dsZS5jb20+Ci0tLQogYXJjaC94ODYvTWFrZWZpbGUgICAgICAg ICAgICAgfCAgIDQgKwogYXJjaC94ODYvaW5jbHVkZS9hc20vbW9kdWxlLmggfCAgMTQgKysrCiBh cmNoL3g4Ni9rZXJuZWwvbW9kdWxlLmMgICAgICB8IDIwNCArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrLS0KIDMgZmlsZXMgY2hhbmdlZCwgMjE3IGluc2VydGlvbnMoKyks IDUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvTWFrZWZpbGUgYi9hcmNoL3g4 Ni9NYWtlZmlsZQppbmRleCA0Y2I0ZjA0OTVkZGMuLjQyNzc0MTg1YTU4YSAxMDA2NDQKLS0tIGEv YXJjaC94ODYvTWFrZWZpbGUKKysrIGIvYXJjaC94ODYvTWFrZWZpbGUKQEAgLTE0Myw3ICsxNDMs MTEgQEAgZWxzZQogICAgICAgICBLQlVJTERfQ0ZMQUdTICs9ICQoY2ZsYWdzLXkpCiAKICAgICAg ICAgS0JVSUxEX0NGTEFHUyArPSAtbW5vLXJlZC16b25lCitpZmRlZiBDT05GSUdfWDg2X1BJRQor ICAgICAgICBLQlVJTERfTERGTEFHU19NT0RVTEUgKz0gLVQgJChzcmN0cmVlKS9hcmNoL3g4Ni9r ZXJuZWwvbW9kdWxlLmxkcworZWxzZQogICAgICAgICBLQlVJTERfQ0ZMQUdTICs9IC1tY21vZGVs PWtlcm5lbAorZW5kaWYKIAogICAgICAgICAjIC1mdW5pdC1hdC1hLXRpbWUgc2hyaW5rcyB0aGUg a2VybmVsIC50ZXh0IGNvbnNpZGVyYWJseQogICAgICAgICAjIHVuZm9ydHVuYXRlbHkgaXQgbWFr ZXMgcmVhZGluZyBvb3BzZXMgaGFyZGVyLgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS9h c20vbW9kdWxlLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9tb2R1bGUuaAppbmRleCA5ZWI3Yzcx OGFhZjguLjhlMGJkNTJiYmFkZiAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vbW9k dWxlLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vbW9kdWxlLmgKQEAgLTQsMTIgKzQsMjMg QEAKICNpbmNsdWRlIDxhc20tZ2VuZXJpYy9tb2R1bGUuaD4KICNpbmNsdWRlIDxhc20vb3JjX3R5 cGVzLmg+CiAKKyNpZmRlZiBDT05GSUdfWDg2X1BJRQorc3RydWN0IG1vZF9nb3Rfc2VjIHsKKwlz dHJ1Y3QgZWxmNjRfc2hkcgkqZ290OworCWludAkJCWdvdF9udW1fZW50cmllczsKKwlpbnQJCQln b3RfbWF4X2VudHJpZXM7Cit9OworI2VuZGlmCisKIHN0cnVjdCBtb2RfYXJjaF9zcGVjaWZpYyB7 CiAjaWZkZWYgQ09ORklHX09SQ19VTldJTkRFUgogCXVuc2lnbmVkIGludCBudW1fb3JjczsKIAlp bnQgKm9yY191bndpbmRfaXA7CiAJc3RydWN0IG9yY19lbnRyeSAqb3JjX3Vud2luZDsKICNlbmRp ZgorI2lmZGVmIENPTkZJR19YODZfUElFCisJc3RydWN0IG1vZF9nb3Rfc2VjCWNvcmU7CisjZW5k aWYKIH07CiAKICNpZmRlZiBDT05GSUdfWDg2XzY0CkBAIC03MCw0ICs4MSw3IEBAIHN0cnVjdCBt b2RfYXJjaF9zcGVjaWZpYyB7CiAjIGRlZmluZSBNT0RVTEVfQVJDSF9WRVJNQUdJQyBNT0RVTEVf UFJPQ19GQU1JTFkKICNlbmRpZgogCisKK3U2NCBtb2R1bGVfZmluZF9nb3RfZW50cnkoc3RydWN0 IG1vZHVsZSAqbW9kLCB1NjQgYWRkcik7CisKICNlbmRpZiAvKiBfQVNNX1g4Nl9NT0RVTEVfSCAq LwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL21vZHVsZS5jIGIvYXJjaC94ODYva2VybmVs L21vZHVsZS5jCmluZGV4IDYyZTdkNzBhYWRkNS4uM2I5YjQzYTlkNjNiIDEwMDY0NAotLS0gYS9h cmNoL3g4Ni9rZXJuZWwvbW9kdWxlLmMKKysrIGIvYXJjaC94ODYva2VybmVsL21vZHVsZS5jCkBA IC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSA8bGludXgvZ2ZwLmg+CiAjaW5jbHVkZSA8bGludXgv anVtcF9sYWJlbC5oPgogI2luY2x1ZGUgPGxpbnV4L3JhbmRvbS5oPgorI2luY2x1ZGUgPGxpbnV4 L3NvcnQuaD4KIAogI2luY2x1ZGUgPGFzbS90ZXh0LXBhdGNoaW5nLmg+CiAjaW5jbHVkZSA8YXNt L3BhZ2UuaD4KQEAgLTc3LDYgKzc4LDE5NSBAQCBzdGF0aWMgdW5zaWduZWQgbG9uZyBpbnQgZ2V0 X21vZHVsZV9sb2FkX29mZnNldCh2b2lkKQogfQogI2VuZGlmCiAKKyNpZmRlZiBDT05GSUdfWDg2 X1BJRQorc3RhdGljIHU2NCBmaW5kX2dvdF9rZXJuZWxfZW50cnkoRWxmNjRfU3ltICpzeW0sIGNv bnN0IEVsZjY0X1JlbGEgKnJlbGEpCit7CisJdTY0ICpwb3M7CisKKwlmb3IgKHBvcyA9ICh1NjQq KV9fc3RhcnRfZ290OyBwb3MgPCAodTY0KilfX2VuZF9nb3Q7IHBvcysrKSB7CisJCWlmICgqcG9z ID09IHN5bS0+c3RfdmFsdWUpCisJCQlyZXR1cm4gKHU2NClwb3MgKyByZWxhLT5yX2FkZGVuZDsK Kwl9CisKKwlyZXR1cm4gMDsKK30KKworLyogU2VhcmNoIHRoZSBHT1QgZW50cnkgZm9yIGEgc3Bl Y2lmaWMgYWRkcmVzcyBhbmQgYSBtb2R1bGUgKG9wdGlvbmFsKSAqLwordTY0IG1vZHVsZV9maW5k X2dvdF9lbnRyeShzdHJ1Y3QgbW9kdWxlICptb2QsIHU2NCBhZGRyKQoreworCWludCBpOworCXU2 NCAqcG9zOworCisJZm9yIChwb3MgPSAodTY0KilfX3N0YXJ0X2dvdDsgcG9zIDwgKHU2NCopX19l bmRfZ290OyBwb3MrKykgeworCQlpZiAoKnBvcyA9PSBhZGRyKQorCQkJcmV0dXJuICh1NjQpcG9z OworCX0KKworCWlmICghbW9kKQorCQlyZXR1cm4gMDsKKworCXBvcyA9ICh1NjQqKW1vZC0+YXJj aC5jb3JlLmdvdC0+c2hfYWRkcjsKKwlmb3IgKGkgPSAwOyBpIDwgbW9kLT5hcmNoLmNvcmUuZ290 X251bV9lbnRyaWVzOyBpKyspIHsKKwkJaWYgKHBvc1tpXSA9PSBhZGRyKQorCQkJcmV0dXJuICh1 NjQpJnBvc1tpXTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB1NjQgbW9kdWxlX2VtaXRf Z290X2VudHJ5KHN0cnVjdCBtb2R1bGUgKm1vZCwgdm9pZCAqbG9jLAorCQkJCSBjb25zdCBFbGY2 NF9SZWxhICpyZWxhLCBFbGY2NF9TeW0gKnN5bSkKK3sKKwlzdHJ1Y3QgbW9kX2dvdF9zZWMgKmdv dHNlYyA9ICZtb2QtPmFyY2guY29yZTsKKwl1NjQgKmdvdCA9ICh1NjQqKWdvdHNlYy0+Z290LT5z aF9hZGRyOworCWludCBpID0gZ290c2VjLT5nb3RfbnVtX2VudHJpZXM7CisJdTY0IHJldDsKKwor CS8qIENoZWNrIGlmIHdlIGNhbiB1c2UgdGhlIGtlcm5lbCBHT1QgKi8KKwlyZXQgPSBmaW5kX2dv dF9rZXJuZWxfZW50cnkoc3ltLCByZWxhKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJ Z290W2ldID0gc3ltLT5zdF92YWx1ZTsKKworCS8qCisJICogQ2hlY2sgaWYgdGhlIGVudHJ5IHdl IGp1c3QgY3JlYXRlZCBpcyBhIGR1cGxpY2F0ZS4gR2l2ZW4gdGhhdCB0aGUKKwkgKiByZWxvY2F0 aW9ucyBhcmUgc29ydGVkLCB0aGlzIHdpbGwgYmUgdGhlIGxhc3QgZW50cnkgd2UgYWxsb2NhdGVk LgorCSAqIChpZiBvbmUgZXhpc3RzKS4KKwkgKi8KKwlpZiAoaSA+IDAgJiYgZ290W2ldID09IGdv dFtpIC0gMl0pIHsKKwkJcmV0ID0gKHU2NCkmZ290W2kgLSAxXTsKKwl9IGVsc2UgeworCQlnb3Rz ZWMtPmdvdF9udW1fZW50cmllcysrOworCQlCVUdfT04oZ290c2VjLT5nb3RfbnVtX2VudHJpZXMg PiBnb3RzZWMtPmdvdF9tYXhfZW50cmllcyk7CisJCXJldCA9ICh1NjQpJmdvdFtpXTsKKwl9CisK KwlyZXR1cm4gcmV0ICsgcmVsYS0+cl9hZGRlbmQ7Cit9CisKKyNkZWZpbmUgY21wXzN3YXkoYSxi KQkoKGEpIDwgKGIpID8gLTEgOiAoYSkgPiAoYikpCisKK3N0YXRpYyBpbnQgY21wX3JlbGEoY29u c3Qgdm9pZCAqYSwgY29uc3Qgdm9pZCAqYikKK3sKKwljb25zdCBFbGY2NF9SZWxhICp4ID0gYSwg KnkgPSBiOworCWludCBpOworCisJLyogc29ydCBieSB0eXBlLCBzeW1ib2wgaW5kZXggYW5kIGFk ZGVuZCAqLworCWkgPSBjbXBfM3dheShFTEY2NF9SX1RZUEUoeC0+cl9pbmZvKSwgRUxGNjRfUl9U WVBFKHktPnJfaW5mbykpOworCWlmIChpID09IDApCisJCWkgPSBjbXBfM3dheShFTEY2NF9SX1NZ TSh4LT5yX2luZm8pLCBFTEY2NF9SX1NZTSh5LT5yX2luZm8pKTsKKwlpZiAoaSA9PSAwKQorCQlp ID0gY21wXzN3YXkoeC0+cl9hZGRlbmQsIHktPnJfYWRkZW5kKTsKKwlyZXR1cm4gaTsKK30KKwor c3RhdGljIGJvb2wgZHVwbGljYXRlX3JlbChjb25zdCBFbGY2NF9SZWxhICpyZWxhLCBpbnQgbnVt KQoreworCS8qCisJICogRW50cmllcyBhcmUgc29ydGVkIGJ5IHR5cGUsIHN5bWJvbCBpbmRleCBh bmQgYWRkZW5kLiBUaGF0IG1lYW5zCisJICogdGhhdCwgaWYgYSBkdXBsaWNhdGUgZW50cnkgZXhp c3RzLCBpdCBtdXN0IGJlIGluIHRoZSBwcmVjZWRpbmcKKwkgKiBzbG90LgorCSAqLworCXJldHVy biBudW0gPiAwICYmIGNtcF9yZWxhKHJlbGEgKyBudW0sIHJlbGEgKyBudW0gLSAxKSA9PSAwOwor fQorCitzdGF0aWMgdW5zaWduZWQgaW50IGNvdW50X2dvdHMoRWxmNjRfU3ltICpzeW1zLCBFbGY2 NF9SZWxhICpyZWxhLCBpbnQgbnVtKQoreworCXVuc2lnbmVkIGludCByZXQgPSAwOworCUVsZjY0 X1N5bSAqczsKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBudW07IGkrKykgeworCQlzd2l0 Y2ggKEVMRjY0X1JfVFlQRShyZWxhW2ldLnJfaW5mbykpIHsKKwkJY2FzZSBSX1g4Nl82NF9HT1RQ Q1JFTDoKKwkJCXMgPSBzeW1zICsgRUxGNjRfUl9TWU0ocmVsYVtpXS5yX2luZm8pOworCisJCQkv KgorCQkJICogVXNlIHRoZSBrZXJuZWwgR09UIHdoZW4gcG9zc2libGUsIGVsc2UgcmVzZXJ2ZSBh CisJCQkgKiBjdXN0b20gb25lIGZvciB0aGlzIG1vZHVsZS4KKwkJCSAqLworCQkJaWYgKCFkdXBs aWNhdGVfcmVsKHJlbGEsIGkpICYmCisJCQkgICAgIWZpbmRfZ290X2tlcm5lbF9lbnRyeShzLCBy ZWxhICsgaSkpCisJCQkJcmV0Kys7CisJCQlicmVhazsKKwkJfQorCX0KKwlyZXR1cm4gcmV0Owor fQorCisvKgorICogR2VuZXJhdGUgR09UIGVudHJpZXMgZm9yIEdPVFBDUkVMIHJlbG9jYXRpb25z IHRoYXQgZG8gbm90IGV4aXN0cyBpbiB0aGUKKyAqIGtlcm5lbCBHT1QuIEJhc2VkIG9uIGFybTY0 IG1vZHVsZS1wbHRzIGltcGxlbWVudGF0aW9uLgorICovCitpbnQgbW9kdWxlX2Zyb2JfYXJjaF9z ZWN0aW9ucyhFbGZfRWhkciAqZWhkciwgRWxmX1NoZHIgKnNlY2hkcnMsCisJCQkgICAgICBjaGFy ICpzZWNzdHJpbmdzLCBzdHJ1Y3QgbW9kdWxlICptb2QpCit7CisJdW5zaWduZWQgbG9uZyBnb3Rz ID0gMDsKKwlFbGZfU2hkciAqc3ltdGFiID0gTlVMTDsKKwlFbGY2NF9TeW0gKnN5bXMgPSBOVUxM OworCWNoYXIgKnN0cmluZ3MsICpuYW1lOworCWludCBpOworCisJLyoKKwkgKiBGaW5kIHRoZSBl bXB0eSAuZ290IHNlY3Rpb24gc28gd2UgY2FuIGV4cGFuZCBpdCB0byBzdG9yZSB0aGUgUExUCisJ ICogZW50cmllcy4gUmVjb3JkIHRoZSBzeW10YWIgYWRkcmVzcyBhcyB3ZWxsLgorCSAqLworCWZv ciAoaSA9IDA7IGkgPCBlaGRyLT5lX3NobnVtOyBpKyspIHsKKwkJaWYgKCFzdHJjbXAoc2Vjc3Ry aW5ncyArIHNlY2hkcnNbaV0uc2hfbmFtZSwgIi5nb3QiKSkgeworCQkJbW9kLT5hcmNoLmNvcmUu Z290ID0gc2VjaGRycyArIGk7CisJCX0gZWxzZSBpZiAoc2VjaGRyc1tpXS5zaF90eXBlID09IFNI VF9TWU1UQUIpIHsKKwkJCXN5bXRhYiA9IHNlY2hkcnMgKyBpOworCQkJc3ltcyA9IChFbGY2NF9T eW0gKilzeW10YWItPnNoX2FkZHI7CisJCX0KKwl9CisKKwlpZiAoIW1vZC0+YXJjaC5jb3JlLmdv dCkgeworCQlwcl9lcnIoIiVzOiBtb2R1bGUgR09UIHNlY3Rpb24gbWlzc2luZ1xuIiwgbW9kLT5u YW1lKTsKKwkJcmV0dXJuIC1FTk9FWEVDOworCX0KKwlpZiAoIXN5bXMpIHsKKwkJcHJfZXJyKCIl czogbW9kdWxlIHN5bXRhYiBzZWN0aW9uIG1pc3NpbmdcbiIsIG1vZC0+bmFtZSk7CisJCXJldHVy biAtRU5PRVhFQzsKKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwgZWhkci0+ZV9zaG51bTsgaSsrKSB7 CisJCUVsZjY0X1JlbGEgKnJlbHMgPSAodm9pZCAqKWVoZHIgKyBzZWNoZHJzW2ldLnNoX29mZnNl dDsKKwkJaW50IG51bXJlbHMgPSBzZWNoZHJzW2ldLnNoX3NpemUgLyBzaXplb2YoRWxmNjRfUmVs YSk7CisKKwkJaWYgKHNlY2hkcnNbaV0uc2hfdHlwZSAhPSBTSFRfUkVMQSkKKwkJCWNvbnRpbnVl OworCisJCS8qIHNvcnQgYnkgdHlwZSwgc3ltYm9sIGluZGV4IGFuZCBhZGRlbmQgKi8KKwkJc29y dChyZWxzLCBudW1yZWxzLCBzaXplb2YoRWxmNjRfUmVsYSksIGNtcF9yZWxhLCBOVUxMKTsKKwor CQlnb3RzICs9IGNvdW50X2dvdHMoc3ltcywgcmVscywgbnVtcmVscyk7CisJfQorCisJbW9kLT5h cmNoLmNvcmUuZ290LT5zaF90eXBlID0gU0hUX05PQklUUzsKKwltb2QtPmFyY2guY29yZS5nb3Qt PnNoX2ZsYWdzID0gU0hGX0FMTE9DOworCW1vZC0+YXJjaC5jb3JlLmdvdC0+c2hfYWRkcmFsaWdu ID0gTDFfQ0FDSEVfQllURVM7CisJbW9kLT5hcmNoLmNvcmUuZ290LT5zaF9zaXplID0gKGdvdHMg KyAxKSAqIHNpemVvZih1NjQpOworCW1vZC0+YXJjaC5jb3JlLmdvdF9udW1fZW50cmllcyA9IDA7 CisJbW9kLT5hcmNoLmNvcmUuZ290X21heF9lbnRyaWVzID0gZ290czsKKworCS8qCisJICogSWYg YSBfR0xPQkFMX09GRlNFVF9UQUJMRV8gc3ltYm9sIGV4aXN0cywgbWFrZSBpdCBhYnNvbHV0ZSBm b3IKKwkgKiBtb2R1bGVzIHRvIGNvcnJlY3RseSByZWZlcmVuY2UgaXQuIFNpbWlsYXIgdG8gczM5 MCBpbXBsZW1lbnRhdGlvbi4KKwkgKi8KKwlzdHJpbmdzID0gKHZvaWQgKikgZWhkciArIHNlY2hk cnNbc3ltdGFiLT5zaF9saW5rXS5zaF9vZmZzZXQ7CisJZm9yIChpID0gMDsgaSA8IHN5bXRhYi0+ c2hfc2l6ZS9zaXplb2YoRWxmX1N5bSk7IGkrKykgeworCQlpZiAoc3ltc1tpXS5zdF9zaG5keCAh PSBTSE5fVU5ERUYpCisJCQljb250aW51ZTsKKwkJbmFtZSA9IHN0cmluZ3MgKyBzeW1zW2ldLnN0 X25hbWU7CisJCWlmICghc3RyY21wKG5hbWUsICJfR0xPQkFMX09GRlNFVF9UQUJMRV8iKSkgewor CQkJc3ltc1tpXS5zdF9zaG5keCA9IFNITl9BQlM7CisJCQlicmVhazsKKwkJfQorCX0KKwlyZXR1 cm4gMDsKK30KKyNlbmRpZgorCiB2b2lkICptb2R1bGVfYWxsb2ModW5zaWduZWQgbG9uZyBzaXpl KQogewogCXZvaWQgKnA7CkBAIC0xODQsMTMgKzM3NCwxOCBAQCBpbnQgYXBwbHlfcmVsb2NhdGVf YWRkKEVsZjY0X1NoZHIgKnNlY2hkcnMsCiAJCQlpZiAoKHM2NCl2YWwgIT0gKihzMzIgKilsb2Mp CiAJCQkJZ290byBvdmVyZmxvdzsKIAkJCWJyZWFrOworI2lmZGVmIENPTkZJR19YODZfUElFCisJ CWNhc2UgUl9YODZfNjRfR09UUENSRUw6CisJCQl2YWwgPSBtb2R1bGVfZW1pdF9nb3RfZW50cnko bWUsIGxvYywgcmVsICsgaSwgc3ltKTsKKwkJCS8qIGZhbGx0aHJvdWdoICovCisjZW5kaWYKKwkJ Y2FzZSBSX1g4Nl82NF9QTFQzMjoKIAkJY2FzZSBSX1g4Nl82NF9QQzMyOgogCQkJdmFsIC09ICh1 NjQpbG9jOwogCQkJKih1MzIgKilsb2MgPSB2YWw7Ci0jaWYgMAotCQkJaWYgKChzNjQpdmFsICE9 ICooczMyICopbG9jKQorCQkJaWYgKElTX0VOQUJMRUQoQ09ORklHX1g4Nl9QSUUpICYmCisJCQkg ICAgKHM2NCl2YWwgIT0gKihzMzIgKilsb2MpCiAJCQkJZ290byBvdmVyZmxvdzsKLSNlbmRpZgog CQkJYnJlYWs7CiAJCWRlZmF1bHQ6CiAJCQlwcl9lcnIoIiVzOiBVbmtub3duIHJlbGEgcmVsb2Nh dGlvbjogJWxsdVxuIiwKQEAgLTIwMyw4ICszOTgsNyBAQCBpbnQgYXBwbHlfcmVsb2NhdGVfYWRk KEVsZjY0X1NoZHIgKnNlY2hkcnMsCiBvdmVyZmxvdzoKIAlwcl9lcnIoIm92ZXJmbG93IGluIHJl bG9jYXRpb24gdHlwZSAlZCB2YWwgJUx4XG4iLAogCSAgICAgICAoaW50KUVMRjY0X1JfVFlQRShy ZWxbaV0ucl9pbmZvKSwgdmFsKTsKLQlwcl9lcnIoImAlcycgbGlrZWx5IG5vdCBjb21waWxlZCB3 aXRoIC1tY21vZGVsPWtlcm5lbFxuIiwKLQkgICAgICAgbWUtPm5hbWUpOworCXByX2VycigiYCVz JyBsaWtlbHkgdG9vIGZhciBmcm9tIHRoZSBrZXJuZWxcbiIsIG1lLT5uYW1lKTsKIAlyZXR1cm4g LUVOT0VYRUM7CiB9CiAjZW5kaWYKLS0gCjIuMTQuMi45MjAuZ2NmMGM2Nzk3OWMtZ29vZwoKCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBt YWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cHM6Ly9saXN0cy54ZW4ub3Jn L3hlbi1kZXZlbAo=