Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752000AbbBUUA5 (ORCPT ); Sat, 21 Feb 2015 15:00:57 -0500 Received: from mail-ig0-f180.google.com ([209.85.213.180]:63110 "EHLO mail-ig0-f180.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751707AbbBUUAz (ORCPT ); Sat, 21 Feb 2015 15:00:55 -0500 MIME-Version: 1.0 In-Reply-To: <20150221024738.GA2899@dhcp-17-102.nay.redhat.com> References: <1423015400-12629-1-git-send-email-yinghai@kernel.org> <20150211061148.GA4448@dhcp-17-102.nay.redhat.com> <20150218112956.GA1965@dhcp-17-102.nay.redhat.com> <20150220021306.GA2621@dhcp-17-102.nay.redhat.com> <20150220092859.GA1572@dhcp-17-102.nay.redhat.com> <20150221024738.GA2899@dhcp-17-102.nay.redhat.com> Date: Sat, 21 Feb 2015 12:00:54 -0800 X-Google-Sender-Auth: rJPXCcPaRi8KrH3fyOCouOe6Q2U Message-ID: Subject: Re: [PATCH] x86, boot: Allow 64bit EFI kernel to be loaded above 4G From: Yinghai Lu To: Baoquan He Cc: "H. Peter Anvin" , Linux Kernel Mailing List Content-Type: multipart/mixed; boundary=001a1140d4b86fe93a050f9ea012 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 22031 Lines: 485 --001a1140d4b86fe93a050f9ea012 Content-Type: text/plain; charset=UTF-8 On Fri, Feb 20, 2015 at 6:49 PM, Baoquan He wrote: > On 02/20/15 at 03:53pm, Yinghai Lu wrote: > At the beginning I did it just as you said, add IDT table and $PF > handler. Get page fault address and built ident mapping around it when > reload kernel above 4G. In this case 3 more pages are enough if kernel > is put to another 512G and cross the boundary of 512G. > kernel_ident_mapping_init code can be borrowed and need be adjusted a > little bit. This works as expected, but a GPF reported and reboot to > BIOS. That's why I made a simple debug patch as I pasted before to > filter unnecessary interference. Please use attached one to instead of the #PF handler in boot stage. It works when hard-code to move output above 4G. From: Yinghai Lu Subject: [PATCH] x86, boot: Enable ident_mapping for kasl above 4G for 64bit split kernel_ident_mapping_init() and call that in boot::misc.c stage. it will cover new range kernel space that is above 4G. Signed-off-by: Yinghai Lu --- arch/x86/boot/compressed/misc.c | 10 ++++ arch/x86/boot/compressed/misc_pgt.c | 61 +++++++++++++++++++++++++++++ arch/x86/include/asm/page.h | 5 ++ arch/x86/mm/ident_map.c | 74 ++++++++++++++++++++++++++++++++++++ arch/x86/mm/init_64.c | 74 ------------------------------------ 5 files changed, 151 insertions(+), 73 deletions(-) Index: linux-2.6/arch/x86/boot/compressed/misc.c =================================================================== --- linux-2.6.orig/arch/x86/boot/compressed/misc.c +++ linux-2.6/arch/x86/boot/compressed/misc.c @@ -9,6 +9,11 @@ * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996 */ +#ifdef CONFIG_X86_64 +#define __pa(x) ((unsigned long)(x)) +#define __va(x) ((void *)((unsigned long)(x))) +#endif + #include "misc.h" #include "../string.h" @@ -366,6 +371,8 @@ static void parse_elf(void *output) free(phdrs); } +#include "misc_pgt.c" + asmlinkage __visible void *decompress_kernel(void *rmode, memptr heap, unsigned char *input_data, unsigned long input_len, @@ -421,6 +428,9 @@ asmlinkage __visible void *decompress_ke error("Wrong destination address"); #endif + if (output != output_orig) + fill_linux64_pagetable((unsigned long)output, output_len); + debug_putstr("\nDecompressing Linux... "); decompress(input_data, input_len, NULL, NULL, output, NULL, error); parse_elf(output); Index: linux-2.6/arch/x86/include/asm/page.h =================================================================== --- linux-2.6.orig/arch/x86/include/asm/page.h +++ linux-2.6/arch/x86/include/asm/page.h @@ -37,7 +37,10 @@ static inline void copy_user_page(void * alloc_page_vma(GFP_HIGHUSER | __GFP_ZERO | movableflags, vma, vaddr) #define __HAVE_ARCH_ALLOC_ZEROED_USER_HIGHPAGE +#ifndef __pa #define __pa(x) __phys_addr((unsigned long)(x)) +#endif + #define __pa_nodebug(x) __phys_addr_nodebug((unsigned long)(x)) /* __pa_symbol should be used for C visible symbols. This seems to be the official gcc blessed way to do such arithmetic. */ @@ -51,7 +54,9 @@ static inline void copy_user_page(void * #define __pa_symbol(x) \ __phys_addr_symbol(__phys_reloc_hide((unsigned long)(x))) +#ifndef __va #define __va(x) ((void *)((unsigned long)(x)+PAGE_OFFSET)) +#endif #define __boot_va(x) __va(x) #define __boot_pa(x) __pa(x) Index: linux-2.6/arch/x86/boot/compressed/misc_pgt.c =================================================================== --- /dev/null +++ linux-2.6/arch/x86/boot/compressed/misc_pgt.c @@ -0,0 +1,61 @@ + +#ifdef CONFIG_X86_64 +#include +#include + +#include "../../mm/ident_map.h" + +struct alloc_pgt_data { + unsigned char *pgt_buf; + unsigned long pgt_buf_size; + unsigned long pgt_buf_offset; +}; + +static void *alloc_pgt_page(void *context) +{ + struct alloc_pgt_data *d = (struct alloc_pgt_data *)context; + unsigned char *p = (unsigned char *)d->pgt_buf; + + if (d->pgt_buf_offset >= d->pgt_buf_size) { + debug_putstr("out of pgt_buf in misc.c\n"); + return NULL; + } + + p += d->pgt_buf_offset; + d->pgt_buf_offset += 4096; + memset(p, 0, 4096); + + return p; +} + +#define PGT_BUF_SIZE (4096*4) + +unsigned long __force_order; +static unsigned char pgt_buf[PGT_BUF_SIZE] __aligned(4096); + +static void fill_linux64_pagetable(unsigned long start, unsigned long size) +{ + struct alloc_pgt_data data = { + .pgt_buf = (unsigned char *) pgt_buf, + .pgt_buf_size = sizeof(pgt_buf), + .pgt_buf_offset = 0, + }; + struct x86_mapping_info mapping_info = { + .alloc_pgt_page = alloc_pgt_page, + .context = &data, + .pmd_flag = __PAGE_KERNEL_LARGE_EXEC, + }; + unsigned long end = start + size; + pgd_t *level4p = (pgd_t *)read_cr3(); + + /* align boundary to 2M */ + start = (start >> 21) << 21; + end = ((end + (1<<21) - 1) >> 21) << 21; + if (start >= (1UL<<32)) + kernel_ident_mapping_init(&mapping_info, level4p, start, end); +} +#else +static void fill_linux64_pagetable(unsigned long start, unsigned long size) +{ +} +#endif Index: linux-2.6/arch/x86/mm/ident_map.c =================================================================== --- /dev/null +++ linux-2.6/arch/x86/mm/ident_map.c @@ -0,0 +1,74 @@ + +static void ident_pmd_init(unsigned long pmd_flag, pmd_t *pmd_page, + unsigned long addr, unsigned long end) +{ + addr &= PMD_MASK; + for (; addr < end; addr += PMD_SIZE) { + pmd_t *pmd = pmd_page + pmd_index(addr); + + if (!pmd_present(*pmd)) + set_pmd(pmd, __pmd(addr | pmd_flag)); + } +} +static int ident_pud_init(struct x86_mapping_info *info, pud_t *pud_page, + unsigned long addr, unsigned long end) +{ + unsigned long next; + + for (; addr < end; addr = next) { + pud_t *pud = pud_page + pud_index(addr); + pmd_t *pmd; + + next = (addr & PUD_MASK) + PUD_SIZE; + if (next > end) + next = end; + + if (pud_present(*pud)) { + pmd = pmd_offset(pud, 0); + ident_pmd_init(info->pmd_flag, pmd, addr, next); + continue; + } + pmd = (pmd_t *)info->alloc_pgt_page(info->context); + if (!pmd) + return -ENOMEM; + ident_pmd_init(info->pmd_flag, pmd, addr, next); + set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE)); + } + + return 0; +} + +int kernel_ident_mapping_init(struct x86_mapping_info *info, pgd_t *pgd_page, + unsigned long addr, unsigned long end) +{ + unsigned long next; + int result; + int off = info->kernel_mapping ? pgd_index(__PAGE_OFFSET) : 0; + + for (; addr < end; addr = next) { + pgd_t *pgd = pgd_page + pgd_index(addr) + off; + pud_t *pud; + + next = (addr & PGDIR_MASK) + PGDIR_SIZE; + if (next > end) + next = end; + + if (pgd_present(*pgd)) { + pud = pud_offset(pgd, 0); + result = ident_pud_init(info, pud, addr, next); + if (result) + return result; + continue; + } + + pud = (pud_t *)info->alloc_pgt_page(info->context); + if (!pud) + return -ENOMEM; + result = ident_pud_init(info, pud, addr, next); + if (result) + return result; + set_pgd(pgd, __pgd(__pa(pud) | _KERNPG_TABLE)); + } + + return 0; +} Index: linux-2.6/arch/x86/mm/init_64.c =================================================================== --- linux-2.6.orig/arch/x86/mm/init_64.c +++ linux-2.6/arch/x86/mm/init_64.c @@ -56,79 +56,7 @@ #include "mm_internal.h" -static void ident_pmd_init(unsigned long pmd_flag, pmd_t *pmd_page, - unsigned long addr, unsigned long end) -{ - addr &= PMD_MASK; - for (; addr < end; addr += PMD_SIZE) { - pmd_t *pmd = pmd_page + pmd_index(addr); - - if (!pmd_present(*pmd)) - set_pmd(pmd, __pmd(addr | pmd_flag)); - } -} -static int ident_pud_init(struct x86_mapping_info *info, pud_t *pud_page, - unsigned long addr, unsigned long end) -{ - unsigned long next; - - for (; addr < end; addr = next) { - pud_t *pud = pud_page + pud_index(addr); - pmd_t *pmd; - - next = (addr & PUD_MASK) + PUD_SIZE; - if (next > end) - next = end; - - if (pud_present(*pud)) { - pmd = pmd_offset(pud, 0); - ident_pmd_init(info->pmd_flag, pmd, addr, next); - continue; - } - pmd = (pmd_t *)info->alloc_pgt_page(info->context); - if (!pmd) - return -ENOMEM; - ident_pmd_init(info->pmd_flag, pmd, addr, next); - set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE)); - } - - return 0; -} - -int kernel_ident_mapping_init(struct x86_mapping_info *info, pgd_t *pgd_page, - unsigned long addr, unsigned long end) -{ - unsigned long next; - int result; - int off = info->kernel_mapping ? pgd_index(__PAGE_OFFSET) : 0; - - for (; addr < end; addr = next) { - pgd_t *pgd = pgd_page + pgd_index(addr) + off; - pud_t *pud; - - next = (addr & PGDIR_MASK) + PGDIR_SIZE; - if (next > end) - next = end; - - if (pgd_present(*pgd)) { - pud = pud_offset(pgd, 0); - result = ident_pud_init(info, pud, addr, next); - if (result) - return result; - continue; - } - - pud = (pud_t *)info->alloc_pgt_page(info->context); - if (!pud) - return -ENOMEM; - result = ident_pud_init(info, pud, addr, next); - if (result) - return result; - set_pgd(pgd, __pgd(__pa(pud) | _KERNPG_TABLE)); - } - - return 0; -} +#include "ident_map.c" static int __init parse_direct_gbpages_off(char *arg) { --001a1140d4b86fe93a050f9ea012 Content-Type: text/x-patch; charset=US-ASCII; name="misc_fill_pgt.patch" Content-Disposition: attachment; filename="misc_fill_pgt.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_i6ffik4y0 RnJvbTogWWluZ2hhaSBMdSA8eWluZ2hhaUBrZXJuZWwub3JnPgpTdWJqZWN0OiBbUEFUQ0hdIHg4 NiwgYm9vdDogRW5hYmxlIGlkZW50X21hcHBpbmcgZm9yIGthc2wgYWJvdmUgNEcgZm9yIDY0Yml0 CgpzcGxpdCBrZXJuZWxfaWRlbnRfbWFwcGluZ19pbml0KCkgYW5kIGNhbGwgdGhhdCBpbiBib290 OjptaXNjLmMgc3RhZ2UuCml0IHdpbGwgY292ZXIgbmV3IHJhbmdlIGtlcm5lbCBzcGFjZSB0aGF0 IGlzIGFib3ZlIDRHLgoKU2lnbmVkLW9mZi1ieTogWWluZ2hhaSBMdSA8eWluZ2hhaUBrZXJuZWwu b3JnPgoKLS0tCiBhcmNoL3g4Ni9ib290L2NvbXByZXNzZWQvbWlzYy5jICAgICB8ICAgMTAgKysr KwogYXJjaC94ODYvYm9vdC9jb21wcmVzc2VkL21pc2NfcGd0LmMgfCAgIDYxICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrCiBhcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYWdlLmggICAgICAgICB8 ICAgIDUgKysKIGFyY2gveDg2L21tL2lkZW50X21hcC5jICAgICAgICAgICAgIHwgICA3NCArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGFyY2gveDg2L21tL2luaXRfNjQuYyAg ICAgICAgICAgICAgIHwgICA3NCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0K IDUgZmlsZXMgY2hhbmdlZCwgMTUxIGluc2VydGlvbnMoKyksIDczIGRlbGV0aW9ucygtKQoKSW5k ZXg6IGxpbnV4LTIuNi9hcmNoL3g4Ni9ib290L2NvbXByZXNzZWQvbWlzYy5jCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIGxpbnV4LTIuNi5vcmlnL2FyY2gveDg2L2Jvb3QvY29tcHJlc3NlZC9taXNjLmMKKysrIGxp bnV4LTIuNi9hcmNoL3g4Ni9ib290L2NvbXByZXNzZWQvbWlzYy5jCkBAIC05LDYgKzksMTEgQEAK ICAqIEhpZ2ggbG9hZGVkIHN0dWZmIGJ5IEhhbnMgTGVybWVuICYgV2VybmVyIEFsbWVzYmVyZ2Vy LCBGZWIuIDE5OTYKICAqLwogCisjaWZkZWYgQ09ORklHX1g4Nl82NAorI2RlZmluZSBfX3BhKHgp ICAoKHVuc2lnbmVkIGxvbmcpKHgpKQorI2RlZmluZSBfX3ZhKHgpICAoKHZvaWQgKikoKHVuc2ln bmVkIGxvbmcpKHgpKSkKKyNlbmRpZgorCiAjaW5jbHVkZSAibWlzYy5oIgogI2luY2x1ZGUgIi4u L3N0cmluZy5oIgogCkBAIC0zNjYsNiArMzcxLDggQEAgc3RhdGljIHZvaWQgcGFyc2VfZWxmKHZv aWQgKm91dHB1dCkKIAlmcmVlKHBoZHJzKTsKIH0KIAorI2luY2x1ZGUgIm1pc2NfcGd0LmMiCisK IGFzbWxpbmthZ2UgX192aXNpYmxlIHZvaWQgKmRlY29tcHJlc3Nfa2VybmVsKHZvaWQgKnJtb2Rl LCBtZW1wdHIgaGVhcCwKIAkJCQkgIHVuc2lnbmVkIGNoYXIgKmlucHV0X2RhdGEsCiAJCQkJICB1 bnNpZ25lZCBsb25nIGlucHV0X2xlbiwKQEAgLTQyMSw2ICs0MjgsOSBAQCBhc21saW5rYWdlIF9f dmlzaWJsZSB2b2lkICpkZWNvbXByZXNzX2tlCiAJCWVycm9yKCJXcm9uZyBkZXN0aW5hdGlvbiBh ZGRyZXNzIik7CiAjZW5kaWYKIAorCWlmIChvdXRwdXQgIT0gb3V0cHV0X29yaWcpCisJCWZpbGxf bGludXg2NF9wYWdldGFibGUoKHVuc2lnbmVkIGxvbmcpb3V0cHV0LCBvdXRwdXRfbGVuKTsKKwog CWRlYnVnX3B1dHN0cigiXG5EZWNvbXByZXNzaW5nIExpbnV4Li4uICIpOwogCWRlY29tcHJlc3Mo aW5wdXRfZGF0YSwgaW5wdXRfbGVuLCBOVUxMLCBOVUxMLCBvdXRwdXQsIE5VTEwsIGVycm9yKTsK IAlwYXJzZV9lbGYob3V0cHV0KTsKSW5kZXg6IGxpbnV4LTIuNi9hcmNoL3g4Ni9pbmNsdWRlL2Fz bS9wYWdlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gbGludXgtMi42Lm9yaWcvYXJjaC94ODYvaW5jbHVkZS9h c20vcGFnZS5oCisrKyBsaW51eC0yLjYvYXJjaC94ODYvaW5jbHVkZS9hc20vcGFnZS5oCkBAIC0z Nyw3ICszNywxMCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgY29weV91c2VyX3BhZ2Uodm9pZCAqCiAJ YWxsb2NfcGFnZV92bWEoR0ZQX0hJR0hVU0VSIHwgX19HRlBfWkVSTyB8IG1vdmFibGVmbGFncywg dm1hLCB2YWRkcikKICNkZWZpbmUgX19IQVZFX0FSQ0hfQUxMT0NfWkVST0VEX1VTRVJfSElHSFBB R0UKIAorI2lmbmRlZiBfX3BhCiAjZGVmaW5lIF9fcGEoeCkJCV9fcGh5c19hZGRyKCh1bnNpZ25l ZCBsb25nKSh4KSkKKyNlbmRpZgorCiAjZGVmaW5lIF9fcGFfbm9kZWJ1Zyh4KQlfX3BoeXNfYWRk cl9ub2RlYnVnKCh1bnNpZ25lZCBsb25nKSh4KSkKIC8qIF9fcGFfc3ltYm9sIHNob3VsZCBiZSB1 c2VkIGZvciBDIHZpc2libGUgc3ltYm9scy4KICAgIFRoaXMgc2VlbXMgdG8gYmUgdGhlIG9mZmlj aWFsIGdjYyBibGVzc2VkIHdheSB0byBkbyBzdWNoIGFyaXRobWV0aWMuICovCkBAIC01MSw3ICs1 NCw5IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBjb3B5X3VzZXJfcGFnZSh2b2lkICoKICNkZWZpbmUg X19wYV9zeW1ib2woeCkgXAogCV9fcGh5c19hZGRyX3N5bWJvbChfX3BoeXNfcmVsb2NfaGlkZSgo dW5zaWduZWQgbG9uZykoeCkpKQogCisjaWZuZGVmIF9fdmEKICNkZWZpbmUgX192YSh4KQkJCSgo dm9pZCAqKSgodW5zaWduZWQgbG9uZykoeCkrUEFHRV9PRkZTRVQpKQorI2VuZGlmCiAKICNkZWZp bmUgX19ib290X3ZhKHgpCQlfX3ZhKHgpCiAjZGVmaW5lIF9fYm9vdF9wYSh4KQkJX19wYSh4KQpJ bmRleDogbGludXgtMi42L2FyY2gveDg2L2Jvb3QvY29tcHJlc3NlZC9taXNjX3BndC5jCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIC9kZXYvbnVsbAorKysgbGludXgtMi42L2FyY2gveDg2L2Jvb3QvY29tcHJlc3Nl ZC9taXNjX3BndC5jCkBAIC0wLDAgKzEsNjEgQEAKKworI2lmZGVmIENPTkZJR19YODZfNjQKKyNp bmNsdWRlIDxhc20vaW5pdC5oPgorI2luY2x1ZGUgPGFzbS9wZ3RhYmxlLmg+CisKKyNpbmNsdWRl ICIuLi8uLi9tbS9pZGVudF9tYXAuaCIKKworc3RydWN0IGFsbG9jX3BndF9kYXRhIHsKKwl1bnNp Z25lZCBjaGFyICpwZ3RfYnVmOworCXVuc2lnbmVkIGxvbmcgcGd0X2J1Zl9zaXplOworCXVuc2ln bmVkIGxvbmcgcGd0X2J1Zl9vZmZzZXQ7Cit9OworCitzdGF0aWMgdm9pZCAqYWxsb2NfcGd0X3Bh Z2Uodm9pZCAqY29udGV4dCkKK3sKKwlzdHJ1Y3QgYWxsb2NfcGd0X2RhdGEgKmQgPSAoc3RydWN0 IGFsbG9jX3BndF9kYXRhICopY29udGV4dDsKKwl1bnNpZ25lZCBjaGFyICpwID0gKHVuc2lnbmVk IGNoYXIgKilkLT5wZ3RfYnVmOworCisJaWYgKGQtPnBndF9idWZfb2Zmc2V0ID49IGQtPnBndF9i dWZfc2l6ZSkgeworCQlkZWJ1Z19wdXRzdHIoIm91dCBvZiBwZ3RfYnVmIGluIG1pc2MuY1xuIik7 CisJCXJldHVybiBOVUxMOworCX0KKworCXAgKz0gZC0+cGd0X2J1Zl9vZmZzZXQ7CisJZC0+cGd0 X2J1Zl9vZmZzZXQgKz0gNDA5NjsKKwltZW1zZXQocCwgMCwgNDA5Nik7CisKKwlyZXR1cm4gcDsK K30KKworI2RlZmluZSBQR1RfQlVGX1NJWkUgKDQwOTYqNCkKKwordW5zaWduZWQgbG9uZyBfX2Zv cmNlX29yZGVyOworc3RhdGljIHVuc2lnbmVkIGNoYXIgcGd0X2J1ZltQR1RfQlVGX1NJWkVdIF9f YWxpZ25lZCg0MDk2KTsKKworc3RhdGljIHZvaWQgZmlsbF9saW51eDY0X3BhZ2V0YWJsZSh1bnNp Z25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIHNpemUpCit7CisJc3RydWN0IGFsbG9jX3Bn dF9kYXRhIGRhdGEgPSB7CisJCS5wZ3RfYnVmID0gKHVuc2lnbmVkIGNoYXIgKikgcGd0X2J1ZiwK KwkJLnBndF9idWZfc2l6ZSA9IHNpemVvZihwZ3RfYnVmKSwKKwkJLnBndF9idWZfb2Zmc2V0ID0g MCwKKwl9OworCXN0cnVjdCB4ODZfbWFwcGluZ19pbmZvIG1hcHBpbmdfaW5mbyA9IHsKKwkJLmFs bG9jX3BndF9wYWdlID0gYWxsb2NfcGd0X3BhZ2UsCisJCS5jb250ZXh0ID0gJmRhdGEsCisJCS5w bWRfZmxhZyA9IF9fUEFHRV9LRVJORUxfTEFSR0VfRVhFQywKKwl9OworCXVuc2lnbmVkIGxvbmcg ZW5kID0gc3RhcnQgKyBzaXplOworCXBnZF90ICpsZXZlbDRwID0gKHBnZF90ICopcmVhZF9jcjMo KTsKKworCS8qIGFsaWduIGJvdW5kYXJ5IHRvIDJNICovCisJc3RhcnQgPSAoc3RhcnQgPj4gMjEp IDw8IDIxOworCWVuZCA9ICgoZW5kICsgKDE8PDIxKSAtIDEpID4+IDIxKSA8PCAyMTsKKwlpZiAo c3RhcnQgPj0gKDFVTDw8MzIpKQorCQlrZXJuZWxfaWRlbnRfbWFwcGluZ19pbml0KCZtYXBwaW5n X2luZm8sIGxldmVsNHAsIHN0YXJ0LCBlbmQpOworfQorI2Vsc2UKK3N0YXRpYyB2b2lkIGZpbGxf bGludXg2NF9wYWdldGFibGUodW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBzaXpl KQoreworfQorI2VuZGlmCkluZGV4OiBsaW51eC0yLjYvYXJjaC94ODYvbW0vaWRlbnRfbWFwLmMK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gL2Rldi9udWxsCisrKyBsaW51eC0yLjYvYXJjaC94ODYvbW0vaWRlbnRf bWFwLmMKQEAgLTAsMCArMSw3NCBAQAorCitzdGF0aWMgdm9pZCBpZGVudF9wbWRfaW5pdCh1bnNp Z25lZCBsb25nIHBtZF9mbGFnLCBwbWRfdCAqcG1kX3BhZ2UsCisJCQkgICB1bnNpZ25lZCBsb25n IGFkZHIsIHVuc2lnbmVkIGxvbmcgZW5kKQoreworCWFkZHIgJj0gUE1EX01BU0s7CisJZm9yICg7 IGFkZHIgPCBlbmQ7IGFkZHIgKz0gUE1EX1NJWkUpIHsKKwkJcG1kX3QgKnBtZCA9IHBtZF9wYWdl ICsgcG1kX2luZGV4KGFkZHIpOworCisJCWlmICghcG1kX3ByZXNlbnQoKnBtZCkpCisJCQlzZXRf cG1kKHBtZCwgX19wbWQoYWRkciB8IHBtZF9mbGFnKSk7CisJfQorfQorc3RhdGljIGludCBpZGVu dF9wdWRfaW5pdChzdHJ1Y3QgeDg2X21hcHBpbmdfaW5mbyAqaW5mbywgcHVkX3QgKnB1ZF9wYWdl LAorCQkJICB1bnNpZ25lZCBsb25nIGFkZHIsIHVuc2lnbmVkIGxvbmcgZW5kKQoreworCXVuc2ln bmVkIGxvbmcgbmV4dDsKKworCWZvciAoOyBhZGRyIDwgZW5kOyBhZGRyID0gbmV4dCkgeworCQlw dWRfdCAqcHVkID0gcHVkX3BhZ2UgKyBwdWRfaW5kZXgoYWRkcik7CisJCXBtZF90ICpwbWQ7CisK KwkJbmV4dCA9IChhZGRyICYgUFVEX01BU0spICsgUFVEX1NJWkU7CisJCWlmIChuZXh0ID4gZW5k KQorCQkJbmV4dCA9IGVuZDsKKworCQlpZiAocHVkX3ByZXNlbnQoKnB1ZCkpIHsKKwkJCXBtZCA9 IHBtZF9vZmZzZXQocHVkLCAwKTsKKwkJCWlkZW50X3BtZF9pbml0KGluZm8tPnBtZF9mbGFnLCBw bWQsIGFkZHIsIG5leHQpOworCQkJY29udGludWU7CisJCX0KKwkJcG1kID0gKHBtZF90ICopaW5m by0+YWxsb2NfcGd0X3BhZ2UoaW5mby0+Y29udGV4dCk7CisJCWlmICghcG1kKQorCQkJcmV0dXJu IC1FTk9NRU07CisJCWlkZW50X3BtZF9pbml0KGluZm8tPnBtZF9mbGFnLCBwbWQsIGFkZHIsIG5l eHQpOworCQlzZXRfcHVkKHB1ZCwgX19wdWQoX19wYShwbWQpIHwgX0tFUk5QR19UQUJMRSkpOwor CX0KKworCXJldHVybiAwOworfQorCitpbnQga2VybmVsX2lkZW50X21hcHBpbmdfaW5pdChzdHJ1 Y3QgeDg2X21hcHBpbmdfaW5mbyAqaW5mbywgcGdkX3QgKnBnZF9wYWdlLAorCQkJICAgICAgdW5z aWduZWQgbG9uZyBhZGRyLCB1bnNpZ25lZCBsb25nIGVuZCkKK3sKKwl1bnNpZ25lZCBsb25nIG5l eHQ7CisJaW50IHJlc3VsdDsKKwlpbnQgb2ZmID0gaW5mby0+a2VybmVsX21hcHBpbmcgPyBwZ2Rf aW5kZXgoX19QQUdFX09GRlNFVCkgOiAwOworCisJZm9yICg7IGFkZHIgPCBlbmQ7IGFkZHIgPSBu ZXh0KSB7CisJCXBnZF90ICpwZ2QgPSBwZ2RfcGFnZSArIHBnZF9pbmRleChhZGRyKSArIG9mZjsK KwkJcHVkX3QgKnB1ZDsKKworCQluZXh0ID0gKGFkZHIgJiBQR0RJUl9NQVNLKSArIFBHRElSX1NJ WkU7CisJCWlmIChuZXh0ID4gZW5kKQorCQkJbmV4dCA9IGVuZDsKKworCQlpZiAocGdkX3ByZXNl bnQoKnBnZCkpIHsKKwkJCXB1ZCA9IHB1ZF9vZmZzZXQocGdkLCAwKTsKKwkJCXJlc3VsdCA9IGlk ZW50X3B1ZF9pbml0KGluZm8sIHB1ZCwgYWRkciwgbmV4dCk7CisJCQlpZiAocmVzdWx0KQorCQkJ CXJldHVybiByZXN1bHQ7CisJCQljb250aW51ZTsKKwkJfQorCisJCXB1ZCA9IChwdWRfdCAqKWlu Zm8tPmFsbG9jX3BndF9wYWdlKGluZm8tPmNvbnRleHQpOworCQlpZiAoIXB1ZCkKKwkJCXJldHVy biAtRU5PTUVNOworCQlyZXN1bHQgPSBpZGVudF9wdWRfaW5pdChpbmZvLCBwdWQsIGFkZHIsIG5l eHQpOworCQlpZiAocmVzdWx0KQorCQkJcmV0dXJuIHJlc3VsdDsKKwkJc2V0X3BnZChwZ2QsIF9f cGdkKF9fcGEocHVkKSB8IF9LRVJOUEdfVEFCTEUpKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KSW5k ZXg6IGxpbnV4LTIuNi9hcmNoL3g4Ni9tbS9pbml0XzY0LmMKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gbGludXgt Mi42Lm9yaWcvYXJjaC94ODYvbW0vaW5pdF82NC5jCisrKyBsaW51eC0yLjYvYXJjaC94ODYvbW0v aW5pdF82NC5jCkBAIC01Niw3OSArNTYsNyBAQAogCiAjaW5jbHVkZSAibW1faW50ZXJuYWwuaCIK IAotc3RhdGljIHZvaWQgaWRlbnRfcG1kX2luaXQodW5zaWduZWQgbG9uZyBwbWRfZmxhZywgcG1k X3QgKnBtZF9wYWdlLAotCQkJICAgdW5zaWduZWQgbG9uZyBhZGRyLCB1bnNpZ25lZCBsb25nIGVu ZCkKLXsKLQlhZGRyICY9IFBNRF9NQVNLOwotCWZvciAoOyBhZGRyIDwgZW5kOyBhZGRyICs9IFBN RF9TSVpFKSB7Ci0JCXBtZF90ICpwbWQgPSBwbWRfcGFnZSArIHBtZF9pbmRleChhZGRyKTsKLQot CQlpZiAoIXBtZF9wcmVzZW50KCpwbWQpKQotCQkJc2V0X3BtZChwbWQsIF9fcG1kKGFkZHIgfCBw bWRfZmxhZykpOwotCX0KLX0KLXN0YXRpYyBpbnQgaWRlbnRfcHVkX2luaXQoc3RydWN0IHg4Nl9t YXBwaW5nX2luZm8gKmluZm8sIHB1ZF90ICpwdWRfcGFnZSwKLQkJCSAgdW5zaWduZWQgbG9uZyBh ZGRyLCB1bnNpZ25lZCBsb25nIGVuZCkKLXsKLQl1bnNpZ25lZCBsb25nIG5leHQ7Ci0KLQlmb3Ig KDsgYWRkciA8IGVuZDsgYWRkciA9IG5leHQpIHsKLQkJcHVkX3QgKnB1ZCA9IHB1ZF9wYWdlICsg cHVkX2luZGV4KGFkZHIpOwotCQlwbWRfdCAqcG1kOwotCi0JCW5leHQgPSAoYWRkciAmIFBVRF9N QVNLKSArIFBVRF9TSVpFOwotCQlpZiAobmV4dCA+IGVuZCkKLQkJCW5leHQgPSBlbmQ7Ci0KLQkJ aWYgKHB1ZF9wcmVzZW50KCpwdWQpKSB7Ci0JCQlwbWQgPSBwbWRfb2Zmc2V0KHB1ZCwgMCk7Ci0J CQlpZGVudF9wbWRfaW5pdChpbmZvLT5wbWRfZmxhZywgcG1kLCBhZGRyLCBuZXh0KTsKLQkJCWNv bnRpbnVlOwotCQl9Ci0JCXBtZCA9IChwbWRfdCAqKWluZm8tPmFsbG9jX3BndF9wYWdlKGluZm8t PmNvbnRleHQpOwotCQlpZiAoIXBtZCkKLQkJCXJldHVybiAtRU5PTUVNOwotCQlpZGVudF9wbWRf aW5pdChpbmZvLT5wbWRfZmxhZywgcG1kLCBhZGRyLCBuZXh0KTsKLQkJc2V0X3B1ZChwdWQsIF9f cHVkKF9fcGEocG1kKSB8IF9LRVJOUEdfVEFCTEUpKTsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQot aW50IGtlcm5lbF9pZGVudF9tYXBwaW5nX2luaXQoc3RydWN0IHg4Nl9tYXBwaW5nX2luZm8gKmlu Zm8sIHBnZF90ICpwZ2RfcGFnZSwKLQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWdu ZWQgbG9uZyBlbmQpCi17Ci0JdW5zaWduZWQgbG9uZyBuZXh0OwotCWludCByZXN1bHQ7Ci0JaW50 IG9mZiA9IGluZm8tPmtlcm5lbF9tYXBwaW5nID8gcGdkX2luZGV4KF9fUEFHRV9PRkZTRVQpIDog MDsKLQotCWZvciAoOyBhZGRyIDwgZW5kOyBhZGRyID0gbmV4dCkgewotCQlwZ2RfdCAqcGdkID0g cGdkX3BhZ2UgKyBwZ2RfaW5kZXgoYWRkcikgKyBvZmY7Ci0JCXB1ZF90ICpwdWQ7Ci0KLQkJbmV4 dCA9IChhZGRyICYgUEdESVJfTUFTSykgKyBQR0RJUl9TSVpFOwotCQlpZiAobmV4dCA+IGVuZCkK LQkJCW5leHQgPSBlbmQ7Ci0KLQkJaWYgKHBnZF9wcmVzZW50KCpwZ2QpKSB7Ci0JCQlwdWQgPSBw dWRfb2Zmc2V0KHBnZCwgMCk7Ci0JCQlyZXN1bHQgPSBpZGVudF9wdWRfaW5pdChpbmZvLCBwdWQs IGFkZHIsIG5leHQpOwotCQkJaWYgKHJlc3VsdCkKLQkJCQlyZXR1cm4gcmVzdWx0OwotCQkJY29u dGludWU7Ci0JCX0KLQotCQlwdWQgPSAocHVkX3QgKilpbmZvLT5hbGxvY19wZ3RfcGFnZShpbmZv LT5jb250ZXh0KTsKLQkJaWYgKCFwdWQpCi0JCQlyZXR1cm4gLUVOT01FTTsKLQkJcmVzdWx0ID0g aWRlbnRfcHVkX2luaXQoaW5mbywgcHVkLCBhZGRyLCBuZXh0KTsKLQkJaWYgKHJlc3VsdCkKLQkJ CXJldHVybiByZXN1bHQ7Ci0JCXNldF9wZ2QocGdkLCBfX3BnZChfX3BhKHB1ZCkgfCBfS0VSTlBH X1RBQkxFKSk7Ci0JfQotCi0JcmV0dXJuIDA7Ci19CisjaW5jbHVkZSAiaWRlbnRfbWFwLmMiCiAK IHN0YXRpYyBpbnQgX19pbml0IHBhcnNlX2RpcmVjdF9nYnBhZ2VzX29mZihjaGFyICphcmcpCiB7 Cg== --001a1140d4b86fe93a050f9ea012-- -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/