From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S934705AbeEJILo (ORCPT ); Thu, 10 May 2018 04:11:44 -0400 Received: from mx2.suse.de ([195.135.220.15]:51760 "EHLO mx2.suse.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756792AbeEJIHH (ORCPT ); Thu, 10 May 2018 04:07:07 -0400 From: Jiri Slaby To: mingo@redhat.com Cc: linux-arch@vger.kernel.org, linux-kernel@vger.kernel.org, Jiri Slaby , "H. Peter Anvin" , Thomas Gleixner , x86@kernel.org, Matt Fleming , Ard Biesheuvel , linux-efi@vger.kernel.org, xen-devel@lists.xenproject.org Subject: [PATCH -resend 19/27] x86: assembly, make some functions local Date: Thu, 10 May 2018 10:06:36 +0200 Message-Id: <20180510080644.19752-20-jslaby@suse.cz> X-Mailer: git-send-email 2.16.3 In-Reply-To: <20180510080644.19752-1-jslaby@suse.cz> References: <20180510080644.19752-1-jslaby@suse.cz> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org There is a couple of assembly functions, which are invoked only locally in the file they are defined. In C, we mark them "static". In assembly, annotate them using SYM_{FUNC,CODE}_START_LOCAL (and switch their ENDPROC to SYM_{FUNC,CODE}_END too). Whether FUNC or CODE depends on ENDPROC/END for a particular function (C or non-C). Signed-off-by: Jiri Slaby Cc: "H. Peter Anvin" Cc: Thomas Gleixner Cc: Ingo Molnar Cc: x86@kernel.org Cc: Matt Fleming Cc: Ard Biesheuvel Cc: linux-efi@vger.kernel.org Cc: xen-devel@lists.xenproject.org --- arch/x86/boot/compressed/efi_thunk_64.S | 8 ++++---- arch/x86/entry/entry_64.S | 21 +++++++++++---------- arch/x86/lib/copy_page_64.S | 4 ++-- arch/x86/lib/memcpy_64.S | 12 ++++++------ arch/x86/lib/memset_64.S | 8 ++++---- arch/x86/platform/efi/efi_thunk_64.S | 12 ++++++------ arch/x86/xen/xen-pvh.S | 4 ++-- 7 files changed, 35 insertions(+), 34 deletions(-) diff --git a/arch/x86/boot/compressed/efi_thunk_64.S b/arch/x86/boot/compressed/efi_thunk_64.S index d66000d23921..31312070db22 100644 --- a/arch/x86/boot/compressed/efi_thunk_64.S +++ b/arch/x86/boot/compressed/efi_thunk_64.S @@ -99,12 +99,12 @@ ENTRY(efi64_thunk) ret ENDPROC(efi64_thunk) -ENTRY(efi_exit32) +SYM_FUNC_START_LOCAL(efi_exit32) movq func_rt_ptr(%rip), %rax push %rax mov %rdi, %rax ret -ENDPROC(efi_exit32) +SYM_FUNC_END(efi_exit32) .code32 /* @@ -112,7 +112,7 @@ ENDPROC(efi_exit32) * * The stack should represent the 32-bit calling convention. */ -ENTRY(efi_enter32) +SYM_FUNC_START_LOCAL(efi_enter32) movl $__KERNEL_DS, %eax movl %eax, %ds movl %eax, %es @@ -172,7 +172,7 @@ ENTRY(efi_enter32) btsl $X86_CR0_PG_BIT, %eax movl %eax, %cr0 lret -ENDPROC(efi_enter32) +SYM_FUNC_END(efi_enter32) .data .balign 8 diff --git a/arch/x86/entry/entry_64.S b/arch/x86/entry/entry_64.S index fda55310de2a..c6841c038170 100644 --- a/arch/x86/entry/entry_64.S +++ b/arch/x86/entry/entry_64.S @@ -1068,7 +1068,8 @@ idtentry hypervisor_callback xen_do_hypervisor_callback has_error_code=0 * existing activation in its critical region -- if so, we pop the current * activation and restart the handler using the previous one. */ -ENTRY(xen_do_hypervisor_callback) /* do_hypervisor_callback(struct *pt_regs) */ +/* do_hypervisor_callback(struct *pt_regs) */ +SYM_CODE_START_LOCAL(xen_do_hypervisor_callback) /* * Since we don't modify %rdi, evtchn_do_upall(struct *pt_regs) will @@ -1086,7 +1087,7 @@ ENTRY(xen_do_hypervisor_callback) /* do_hypervisor_callback(struct *pt_regs) */ call xen_maybe_preempt_hcall #endif jmp error_exit -END(xen_do_hypervisor_callback) +SYM_CODE_END(xen_do_hypervisor_callback) /* * Hypervisor uses this for application faults while it executes. @@ -1175,7 +1176,7 @@ idtentry machine_check do_mce has_error_code=0 paranoid=1 * Use slow, but surefire "are we in kernel?" check. * Return: ebx=0: need swapgs on exit, ebx=1: otherwise */ -ENTRY(paranoid_entry) +SYM_CODE_START_LOCAL(paranoid_entry) UNWIND_HINT_FUNC cld PUSH_AND_CLEAR_REGS save_ret=1 @@ -1192,7 +1193,7 @@ ENTRY(paranoid_entry) SAVE_AND_SWITCH_TO_KERNEL_CR3 scratch_reg=%rax save_reg=%r14 ret -END(paranoid_entry) +SYM_CODE_END(paranoid_entry) /* * "Paranoid" exit path from exception stack. This is invoked @@ -1206,7 +1207,7 @@ END(paranoid_entry) * * On entry, ebx is "no swapgs" flag (1: don't need swapgs, 0: need it) */ -ENTRY(paranoid_exit) +SYM_CODE_START_LOCAL(paranoid_exit) UNWIND_HINT_REGS DISABLE_INTERRUPTS(CLBR_ANY) TRACE_IRQS_OFF_DEBUG @@ -1221,13 +1222,13 @@ ENTRY(paranoid_exit) RESTORE_CR3 scratch_reg=%rbx save_reg=%r14 .Lparanoid_exit_restore: jmp restore_regs_and_return_to_kernel -END(paranoid_exit) +SYM_CODE_END(paranoid_exit) /* * Save all registers in pt_regs, and switch GS if needed. * Return: EBX=0: came from user mode; EBX=1: otherwise */ -ENTRY(error_entry) +SYM_CODE_START_LOCAL(error_entry) UNWIND_HINT_FUNC cld PUSH_AND_CLEAR_REGS save_ret=1 @@ -1314,7 +1315,7 @@ ENTRY(error_entry) mov %rax, %rsp decl %ebx jmp .Lerror_entry_from_usermode_after_swapgs -END(error_entry) +SYM_CODE_END(error_entry) /* @@ -1322,14 +1323,14 @@ END(error_entry) * 1: already in kernel mode, don't need SWAPGS * 0: user gsbase is loaded, we need SWAPGS and standard preparation for return to usermode */ -ENTRY(error_exit) +SYM_CODE_START_LOCAL(error_exit) UNWIND_HINT_REGS DISABLE_INTERRUPTS(CLBR_ANY) TRACE_IRQS_OFF testl %ebx, %ebx jnz retint_kernel jmp retint_user -END(error_exit) +SYM_CODE_END(error_exit) /* * Runs on exception stack. Xen PV does not go through this path at all, diff --git a/arch/x86/lib/copy_page_64.S b/arch/x86/lib/copy_page_64.S index fd2d09afa097..f505870bd93b 100644 --- a/arch/x86/lib/copy_page_64.S +++ b/arch/x86/lib/copy_page_64.S @@ -21,7 +21,7 @@ ENTRY(copy_page) ENDPROC(copy_page) EXPORT_SYMBOL(copy_page) -ENTRY(copy_page_regs) +SYM_FUNC_START_LOCAL(copy_page_regs) subq $2*8, %rsp movq %rbx, (%rsp) movq %r12, 1*8(%rsp) @@ -86,4 +86,4 @@ ENTRY(copy_page_regs) movq 1*8(%rsp), %r12 addq $2*8, %rsp ret -ENDPROC(copy_page_regs) +SYM_FUNC_END(copy_page_regs) diff --git a/arch/x86/lib/memcpy_64.S b/arch/x86/lib/memcpy_64.S index 4911b1c61aa8..728703c47d58 100644 --- a/arch/x86/lib/memcpy_64.S +++ b/arch/x86/lib/memcpy_64.S @@ -27,7 +27,7 @@ * rax original destination */ SYM_FUNC_START_ALIAS(__memcpy) -ENTRY(memcpy) +SYM_FUNC_START_LOCAL(memcpy) ALTERNATIVE_2 "jmp memcpy_orig", "", X86_FEATURE_REP_GOOD, \ "jmp memcpy_erms", X86_FEATURE_ERMS @@ -39,7 +39,7 @@ ENTRY(memcpy) movl %edx, %ecx rep movsb ret -ENDPROC(memcpy) +SYM_FUNC_END(memcpy) SYM_FUNC_END_ALIAS(__memcpy) EXPORT_SYMBOL(memcpy) EXPORT_SYMBOL(__memcpy) @@ -48,14 +48,14 @@ EXPORT_SYMBOL(__memcpy) * memcpy_erms() - enhanced fast string memcpy. This is faster and * simpler than memcpy. Use memcpy_erms when possible. */ -ENTRY(memcpy_erms) +SYM_FUNC_START_LOCAL(memcpy_erms) movq %rdi, %rax movq %rdx, %rcx rep movsb ret -ENDPROC(memcpy_erms) +SYM_FUNC_END(memcpy_erms) -ENTRY(memcpy_orig) +SYM_FUNC_START_LOCAL(memcpy_orig) movq %rdi, %rax cmpq $0x20, %rdx @@ -180,7 +180,7 @@ ENTRY(memcpy_orig) .Lend: retq -ENDPROC(memcpy_orig) +SYM_FUNC_END(memcpy_orig) #ifndef CONFIG_UML /* diff --git a/arch/x86/lib/memset_64.S b/arch/x86/lib/memset_64.S index 927ac44d34aa..564abf9ecedb 100644 --- a/arch/x86/lib/memset_64.S +++ b/arch/x86/lib/memset_64.S @@ -59,16 +59,16 @@ EXPORT_SYMBOL(__memset) * * rax original destination */ -ENTRY(memset_erms) +SYM_FUNC_START_LOCAL(memset_erms) movq %rdi,%r9 movb %sil,%al movq %rdx,%rcx rep stosb movq %r9,%rax ret -ENDPROC(memset_erms) +SYM_FUNC_END(memset_erms) -ENTRY(memset_orig) +SYM_FUNC_START_LOCAL(memset_orig) movq %rdi,%r10 /* expand byte value */ @@ -139,4 +139,4 @@ ENTRY(memset_orig) subq %r8,%rdx jmp .Lafter_bad_alignment .Lfinal: -ENDPROC(memset_orig) +SYM_FUNC_END(memset_orig) diff --git a/arch/x86/platform/efi/efi_thunk_64.S b/arch/x86/platform/efi/efi_thunk_64.S index 46c58b08739c..d677a7eb2d0a 100644 --- a/arch/x86/platform/efi/efi_thunk_64.S +++ b/arch/x86/platform/efi/efi_thunk_64.S @@ -67,7 +67,7 @@ ENDPROC(efi64_thunk) * * This function must be invoked with a 1:1 mapped stack. */ -ENTRY(__efi64_thunk) +SYM_FUNC_START_LOCAL(__efi64_thunk) movl %ds, %eax push %rax movl %es, %eax @@ -114,14 +114,14 @@ ENTRY(__efi64_thunk) or %rcx, %rax 1: ret -ENDPROC(__efi64_thunk) +SYM_FUNC_END(__efi64_thunk) -ENTRY(efi_exit32) +SYM_FUNC_START_LOCAL(efi_exit32) movq func_rt_ptr(%rip), %rax push %rax mov %rdi, %rax ret -ENDPROC(efi_exit32) +SYM_FUNC_END(efi_exit32) .code32 /* @@ -129,7 +129,7 @@ ENDPROC(efi_exit32) * * The stack should represent the 32-bit calling convention. */ -ENTRY(efi_enter32) +SYM_FUNC_START_LOCAL(efi_enter32) movl $__KERNEL_DS, %eax movl %eax, %ds movl %eax, %es @@ -145,7 +145,7 @@ ENTRY(efi_enter32) pushl %eax lret -ENDPROC(efi_enter32) +SYM_FUNC_END(efi_enter32) .data .balign 8 diff --git a/arch/x86/xen/xen-pvh.S b/arch/x86/xen/xen-pvh.S index 52b28793a625..a20a55cc5135 100644 --- a/arch/x86/xen/xen-pvh.S +++ b/arch/x86/xen/xen-pvh.S @@ -54,7 +54,7 @@ * charge of setting up it's own stack, GDT and IDT. */ -ENTRY(pvh_start_xen) +SYM_CODE_START_LOCAL(pvh_start_xen) cld lgdt (_pa(gdt)) @@ -133,7 +133,7 @@ ENTRY(pvh_start_xen) ljmp $__BOOT_CS, $_pa(startup_32) #endif -END(pvh_start_xen) +SYM_CODE_END(pvh_start_xen) .section ".init.data","aw" .balign 8 -- 2.16.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jiri Slaby Subject: [PATCH -resend 19/27] x86: assembly, make some functions local Date: Thu, 10 May 2018 10:06:36 +0200 Message-ID: <20180510080644.19752-20-jslaby@suse.cz> References: <20180510080644.19752-1-jslaby@suse.cz> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180510080644.19752-1-jslaby@suse.cz> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: mingo@redhat.com Cc: linux-arch@vger.kernel.org, linux-efi@vger.kernel.org, Ard Biesheuvel , Matt Fleming , x86@kernel.org, linux-kernel@vger.kernel.org, "H. Peter Anvin" , xen-devel@lists.xenproject.org, Thomas Gleixner , Jiri Slaby List-Id: linux-efi@vger.kernel.org VGhlcmUgaXMgYSBjb3VwbGUgb2YgYXNzZW1ibHkgZnVuY3Rpb25zLCB3aGljaCBhcmUgaW52b2tl ZCBvbmx5IGxvY2FsbHkKaW4gdGhlIGZpbGUgdGhleSBhcmUgZGVmaW5lZC4gSW4gQywgd2UgbWFy ayB0aGVtICJzdGF0aWMiLiBJbiBhc3NlbWJseSwKYW5ub3RhdGUgdGhlbSB1c2luZyBTWU1fe0ZV TkMsQ09ERX1fU1RBUlRfTE9DQUwgKGFuZCBzd2l0Y2ggdGhlaXIKRU5EUFJPQyB0byBTWU1fe0ZV TkMsQ09ERX1fRU5EIHRvbykuIFdoZXRoZXIgRlVOQyBvciBDT0RFIGRlcGVuZHMgb24KRU5EUFJP Qy9FTkQgZm9yIGEgcGFydGljdWxhciBmdW5jdGlvbiAoQyBvciBub24tQykuCgpTaWduZWQtb2Zm LWJ5OiBKaXJpIFNsYWJ5IDxqc2xhYnlAc3VzZS5jej4KQ2M6ICJILiBQZXRlciBBbnZpbiIgPGhw YUB6eXRvci5jb20+CkNjOiBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGludXRyb25peC5kZT4KQ2M6 IEluZ28gTW9sbmFyIDxtaW5nb0ByZWRoYXQuY29tPgpDYzogeDg2QGtlcm5lbC5vcmcKQ2M6IE1h dHQgRmxlbWluZyA8bWF0dEBjb2RlYmx1ZXByaW50LmNvLnVrPgpDYzogQXJkIEJpZXNoZXV2ZWwg PGFyZC5iaWVzaGV1dmVsQGxpbmFyby5vcmc+CkNjOiBsaW51eC1lZmlAdmdlci5rZXJuZWwub3Jn CkNjOiB4ZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKLS0tCiBhcmNoL3g4Ni9ib290L2Nv bXByZXNzZWQvZWZpX3RodW5rXzY0LlMgfCAgOCArKysrLS0tLQogYXJjaC94ODYvZW50cnkvZW50 cnlfNjQuUyAgICAgICAgICAgICAgIHwgMjEgKysrKysrKysrKystLS0tLS0tLS0tCiBhcmNoL3g4 Ni9saWIvY29weV9wYWdlXzY0LlMgICAgICAgICAgICAgfCAgNCArKy0tCiBhcmNoL3g4Ni9saWIv bWVtY3B5XzY0LlMgICAgICAgICAgICAgICAgfCAxMiArKysrKystLS0tLS0KIGFyY2gveDg2L2xp Yi9tZW1zZXRfNjQuUyAgICAgICAgICAgICAgICB8ICA4ICsrKystLS0tCiBhcmNoL3g4Ni9wbGF0 Zm9ybS9lZmkvZWZpX3RodW5rXzY0LlMgICAgfCAxMiArKysrKystLS0tLS0KIGFyY2gveDg2L3hl bi94ZW4tcHZoLlMgICAgICAgICAgICAgICAgICB8ICA0ICsrLS0KIDcgZmlsZXMgY2hhbmdlZCwg MzUgaW5zZXJ0aW9ucygrKSwgMzQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYv Ym9vdC9jb21wcmVzc2VkL2VmaV90aHVua182NC5TIGIvYXJjaC94ODYvYm9vdC9jb21wcmVzc2Vk L2VmaV90aHVua182NC5TCmluZGV4IGQ2NjAwMGQyMzkyMS4uMzEzMTIwNzBkYjIyIDEwMDY0NAot LS0gYS9hcmNoL3g4Ni9ib290L2NvbXByZXNzZWQvZWZpX3RodW5rXzY0LlMKKysrIGIvYXJjaC94 ODYvYm9vdC9jb21wcmVzc2VkL2VmaV90aHVua182NC5TCkBAIC05OSwxMiArOTksMTIgQEAgRU5U UlkoZWZpNjRfdGh1bmspCiAJcmV0CiBFTkRQUk9DKGVmaTY0X3RodW5rKQogCi1FTlRSWShlZmlf ZXhpdDMyKQorU1lNX0ZVTkNfU1RBUlRfTE9DQUwoZWZpX2V4aXQzMikKIAltb3ZxCWZ1bmNfcnRf cHRyKCVyaXApLCAlcmF4CiAJcHVzaAklcmF4CiAJbW92CSVyZGksICVyYXgKIAlyZXQKLUVORFBS T0MoZWZpX2V4aXQzMikKK1NZTV9GVU5DX0VORChlZmlfZXhpdDMyKQogCiAJLmNvZGUzMgogLyoK QEAgLTExMiw3ICsxMTIsNyBAQCBFTkRQUk9DKGVmaV9leGl0MzIpCiAgKgogICogVGhlIHN0YWNr IHNob3VsZCByZXByZXNlbnQgdGhlIDMyLWJpdCBjYWxsaW5nIGNvbnZlbnRpb24uCiAgKi8KLUVO VFJZKGVmaV9lbnRlcjMyKQorU1lNX0ZVTkNfU1RBUlRfTE9DQUwoZWZpX2VudGVyMzIpCiAJbW92 bAkkX19LRVJORUxfRFMsICVlYXgKIAltb3ZsCSVlYXgsICVkcwogCW1vdmwJJWVheCwgJWVzCkBA IC0xNzIsNyArMTcyLDcgQEAgRU5UUlkoZWZpX2VudGVyMzIpCiAJYnRzbAkkWDg2X0NSMF9QR19C SVQsICVlYXgKIAltb3ZsCSVlYXgsICVjcjAKIAlscmV0Ci1FTkRQUk9DKGVmaV9lbnRlcjMyKQor U1lNX0ZVTkNfRU5EKGVmaV9lbnRlcjMyKQogCiAJLmRhdGEKIAkuYmFsaWduCTgKZGlmZiAtLWdp dCBhL2FyY2gveDg2L2VudHJ5L2VudHJ5XzY0LlMgYi9hcmNoL3g4Ni9lbnRyeS9lbnRyeV82NC5T CmluZGV4IGZkYTU1MzEwZGUyYS4uYzY4NDFjMDM4MTcwIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9l bnRyeS9lbnRyeV82NC5TCisrKyBiL2FyY2gveDg2L2VudHJ5L2VudHJ5XzY0LlMKQEAgLTEwNjgs NyArMTA2OCw4IEBAIGlkdGVudHJ5IGh5cGVydmlzb3JfY2FsbGJhY2sgeGVuX2RvX2h5cGVydmlz b3JfY2FsbGJhY2sgaGFzX2Vycm9yX2NvZGU9MAogICogZXhpc3RpbmcgYWN0aXZhdGlvbiBpbiBp dHMgY3JpdGljYWwgcmVnaW9uIC0tIGlmIHNvLCB3ZSBwb3AgdGhlIGN1cnJlbnQKICAqIGFjdGl2 YXRpb24gYW5kIHJlc3RhcnQgdGhlIGhhbmRsZXIgdXNpbmcgdGhlIHByZXZpb3VzIG9uZS4KICAq LwotRU5UUlkoeGVuX2RvX2h5cGVydmlzb3JfY2FsbGJhY2spCQkvKiBkb19oeXBlcnZpc29yX2Nh bGxiYWNrKHN0cnVjdCAqcHRfcmVncykgKi8KKy8qIGRvX2h5cGVydmlzb3JfY2FsbGJhY2soc3Ry dWN0ICpwdF9yZWdzKSAqLworU1lNX0NPREVfU1RBUlRfTE9DQUwoeGVuX2RvX2h5cGVydmlzb3Jf Y2FsbGJhY2spCiAKIC8qCiAgKiBTaW5jZSB3ZSBkb24ndCBtb2RpZnkgJXJkaSwgZXZ0Y2huX2Rv X3VwYWxsKHN0cnVjdCAqcHRfcmVncykgd2lsbApAQCAtMTA4Niw3ICsxMDg3LDcgQEAgRU5UUlko eGVuX2RvX2h5cGVydmlzb3JfY2FsbGJhY2spCQkvKiBkb19oeXBlcnZpc29yX2NhbGxiYWNrKHN0 cnVjdCAqcHRfcmVncykgKi8KIAljYWxsCXhlbl9tYXliZV9wcmVlbXB0X2hjYWxsCiAjZW5kaWYK IAlqbXAJZXJyb3JfZXhpdAotRU5EKHhlbl9kb19oeXBlcnZpc29yX2NhbGxiYWNrKQorU1lNX0NP REVfRU5EKHhlbl9kb19oeXBlcnZpc29yX2NhbGxiYWNrKQogCiAvKgogICogSHlwZXJ2aXNvciB1 c2VzIHRoaXMgZm9yIGFwcGxpY2F0aW9uIGZhdWx0cyB3aGlsZSBpdCBleGVjdXRlcy4KQEAgLTEx NzUsNyArMTE3Niw3IEBAIGlkdGVudHJ5IG1hY2hpbmVfY2hlY2sJCWRvX21jZQkJCWhhc19lcnJv cl9jb2RlPTAJcGFyYW5vaWQ9MQogICogVXNlIHNsb3csIGJ1dCBzdXJlZmlyZSAiYXJlIHdlIGlu IGtlcm5lbD8iIGNoZWNrLgogICogUmV0dXJuOiBlYng9MDogbmVlZCBzd2FwZ3Mgb24gZXhpdCwg ZWJ4PTE6IG90aGVyd2lzZQogICovCi1FTlRSWShwYXJhbm9pZF9lbnRyeSkKK1NZTV9DT0RFX1NU QVJUX0xPQ0FMKHBhcmFub2lkX2VudHJ5KQogCVVOV0lORF9ISU5UX0ZVTkMKIAljbGQKIAlQVVNI X0FORF9DTEVBUl9SRUdTIHNhdmVfcmV0PTEKQEAgLTExOTIsNyArMTE5Myw3IEBAIEVOVFJZKHBh cmFub2lkX2VudHJ5KQogCVNBVkVfQU5EX1NXSVRDSF9UT19LRVJORUxfQ1IzIHNjcmF0Y2hfcmVn PSVyYXggc2F2ZV9yZWc9JXIxNAogCiAJcmV0Ci1FTkQocGFyYW5vaWRfZW50cnkpCitTWU1fQ09E RV9FTkQocGFyYW5vaWRfZW50cnkpCiAKIC8qCiAgKiAiUGFyYW5vaWQiIGV4aXQgcGF0aCBmcm9t IGV4Y2VwdGlvbiBzdGFjay4gIFRoaXMgaXMgaW52b2tlZApAQCAtMTIwNiw3ICsxMjA3LDcgQEAg RU5EKHBhcmFub2lkX2VudHJ5KQogICoKICAqIE9uIGVudHJ5LCBlYnggaXMgIm5vIHN3YXBncyIg ZmxhZyAoMTogZG9uJ3QgbmVlZCBzd2FwZ3MsIDA6IG5lZWQgaXQpCiAgKi8KLUVOVFJZKHBhcmFu b2lkX2V4aXQpCitTWU1fQ09ERV9TVEFSVF9MT0NBTChwYXJhbm9pZF9leGl0KQogCVVOV0lORF9I SU5UX1JFR1MKIAlESVNBQkxFX0lOVEVSUlVQVFMoQ0xCUl9BTlkpCiAJVFJBQ0VfSVJRU19PRkZf REVCVUcKQEAgLTEyMjEsMTMgKzEyMjIsMTMgQEAgRU5UUlkocGFyYW5vaWRfZXhpdCkKIAlSRVNU T1JFX0NSMwlzY3JhdGNoX3JlZz0lcmJ4IHNhdmVfcmVnPSVyMTQKIC5McGFyYW5vaWRfZXhpdF9y ZXN0b3JlOgogCWptcCByZXN0b3JlX3JlZ3NfYW5kX3JldHVybl90b19rZXJuZWwKLUVORChwYXJh bm9pZF9leGl0KQorU1lNX0NPREVfRU5EKHBhcmFub2lkX2V4aXQpCiAKIC8qCiAgKiBTYXZlIGFs bCByZWdpc3RlcnMgaW4gcHRfcmVncywgYW5kIHN3aXRjaCBHUyBpZiBuZWVkZWQuCiAgKiBSZXR1 cm46IEVCWD0wOiBjYW1lIGZyb20gdXNlciBtb2RlOyBFQlg9MTogb3RoZXJ3aXNlCiAgKi8KLUVO VFJZKGVycm9yX2VudHJ5KQorU1lNX0NPREVfU1RBUlRfTE9DQUwoZXJyb3JfZW50cnkpCiAJVU5X SU5EX0hJTlRfRlVOQwogCWNsZAogCVBVU0hfQU5EX0NMRUFSX1JFR1Mgc2F2ZV9yZXQ9MQpAQCAt MTMxNCw3ICsxMzE1LDcgQEAgRU5UUlkoZXJyb3JfZW50cnkpCiAJbW92CSVyYXgsICVyc3AKIAlk ZWNsCSVlYngKIAlqbXAJLkxlcnJvcl9lbnRyeV9mcm9tX3VzZXJtb2RlX2FmdGVyX3N3YXBncwot RU5EKGVycm9yX2VudHJ5KQorU1lNX0NPREVfRU5EKGVycm9yX2VudHJ5KQogCiAKIC8qCkBAIC0x MzIyLDE0ICsxMzIzLDE0IEBAIEVORChlcnJvcl9lbnRyeSkKICAqICAgMTogYWxyZWFkeSBpbiBr ZXJuZWwgbW9kZSwgZG9uJ3QgbmVlZCBTV0FQR1MKICAqICAgMDogdXNlciBnc2Jhc2UgaXMgbG9h ZGVkLCB3ZSBuZWVkIFNXQVBHUyBhbmQgc3RhbmRhcmQgcHJlcGFyYXRpb24gZm9yIHJldHVybiB0 byB1c2VybW9kZQogICovCi1FTlRSWShlcnJvcl9leGl0KQorU1lNX0NPREVfU1RBUlRfTE9DQUwo ZXJyb3JfZXhpdCkKIAlVTldJTkRfSElOVF9SRUdTCiAJRElTQUJMRV9JTlRFUlJVUFRTKENMQlJf QU5ZKQogCVRSQUNFX0lSUVNfT0ZGCiAJdGVzdGwJJWVieCwgJWVieAogCWpueglyZXRpbnRfa2Vy bmVsCiAJam1wCXJldGludF91c2VyCi1FTkQoZXJyb3JfZXhpdCkKK1NZTV9DT0RFX0VORChlcnJv cl9leGl0KQogCiAvKgogICogUnVucyBvbiBleGNlcHRpb24gc3RhY2suICBYZW4gUFYgZG9lcyBu b3QgZ28gdGhyb3VnaCB0aGlzIHBhdGggYXQgYWxsLApkaWZmIC0tZ2l0IGEvYXJjaC94ODYvbGli L2NvcHlfcGFnZV82NC5TIGIvYXJjaC94ODYvbGliL2NvcHlfcGFnZV82NC5TCmluZGV4IGZkMmQw OWFmYTA5Ny4uZjUwNTg3MGJkOTNiIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9saWIvY29weV9wYWdl XzY0LlMKKysrIGIvYXJjaC94ODYvbGliL2NvcHlfcGFnZV82NC5TCkBAIC0yMSw3ICsyMSw3IEBA IEVOVFJZKGNvcHlfcGFnZSkKIEVORFBST0MoY29weV9wYWdlKQogRVhQT1JUX1NZTUJPTChjb3B5 X3BhZ2UpCiAKLUVOVFJZKGNvcHlfcGFnZV9yZWdzKQorU1lNX0ZVTkNfU1RBUlRfTE9DQUwoY29w eV9wYWdlX3JlZ3MpCiAJc3VicQkkMio4LAklcnNwCiAJbW92cQklcmJ4LAkoJXJzcCkKIAltb3Zx CSVyMTIsCTEqOCglcnNwKQpAQCAtODYsNCArODYsNCBAQCBFTlRSWShjb3B5X3BhZ2VfcmVncykK IAltb3ZxCTEqOCglcnNwKSwgJXIxMgogCWFkZHEJJDIqOCwgJXJzcAogCXJldAotRU5EUFJPQyhj b3B5X3BhZ2VfcmVncykKK1NZTV9GVU5DX0VORChjb3B5X3BhZ2VfcmVncykKZGlmZiAtLWdpdCBh L2FyY2gveDg2L2xpYi9tZW1jcHlfNjQuUyBiL2FyY2gveDg2L2xpYi9tZW1jcHlfNjQuUwppbmRl eCA0OTExYjFjNjFhYTguLjcyODcwM2M0N2Q1OCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvbGliL21l bWNweV82NC5TCisrKyBiL2FyY2gveDg2L2xpYi9tZW1jcHlfNjQuUwpAQCAtMjcsNyArMjcsNyBA QAogICogcmF4IG9yaWdpbmFsIGRlc3RpbmF0aW9uCiAgKi8KIFNZTV9GVU5DX1NUQVJUX0FMSUFT KF9fbWVtY3B5KQotRU5UUlkobWVtY3B5KQorU1lNX0ZVTkNfU1RBUlRfTE9DQUwobWVtY3B5KQog CUFMVEVSTkFUSVZFXzIgImptcCBtZW1jcHlfb3JpZyIsICIiLCBYODZfRkVBVFVSRV9SRVBfR09P RCwgXAogCQkgICAgICAiam1wIG1lbWNweV9lcm1zIiwgWDg2X0ZFQVRVUkVfRVJNUwogCkBAIC0z OSw3ICszOSw3IEBAIEVOVFJZKG1lbWNweSkKIAltb3ZsICVlZHgsICVlY3gKIAlyZXAgbW92c2IK IAlyZXQKLUVORFBST0MobWVtY3B5KQorU1lNX0ZVTkNfRU5EKG1lbWNweSkKIFNZTV9GVU5DX0VO RF9BTElBUyhfX21lbWNweSkKIEVYUE9SVF9TWU1CT0wobWVtY3B5KQogRVhQT1JUX1NZTUJPTChf X21lbWNweSkKQEAgLTQ4LDE0ICs0OCwxNCBAQCBFWFBPUlRfU1lNQk9MKF9fbWVtY3B5KQogICog bWVtY3B5X2VybXMoKSAtIGVuaGFuY2VkIGZhc3Qgc3RyaW5nIG1lbWNweS4gVGhpcyBpcyBmYXN0 ZXIgYW5kCiAgKiBzaW1wbGVyIHRoYW4gbWVtY3B5LiBVc2UgbWVtY3B5X2VybXMgd2hlbiBwb3Nz aWJsZS4KICAqLwotRU5UUlkobWVtY3B5X2VybXMpCitTWU1fRlVOQ19TVEFSVF9MT0NBTChtZW1j cHlfZXJtcykKIAltb3ZxICVyZGksICVyYXgKIAltb3ZxICVyZHgsICVyY3gKIAlyZXAgbW92c2IK IAlyZXQKLUVORFBST0MobWVtY3B5X2VybXMpCitTWU1fRlVOQ19FTkQobWVtY3B5X2VybXMpCiAK LUVOVFJZKG1lbWNweV9vcmlnKQorU1lNX0ZVTkNfU1RBUlRfTE9DQUwobWVtY3B5X29yaWcpCiAJ bW92cSAlcmRpLCAlcmF4CiAKIAljbXBxICQweDIwLCAlcmR4CkBAIC0xODAsNyArMTgwLDcgQEAg RU5UUlkobWVtY3B5X29yaWcpCiAKIC5MZW5kOgogCXJldHEKLUVORFBST0MobWVtY3B5X29yaWcp CitTWU1fRlVOQ19FTkQobWVtY3B5X29yaWcpCiAKICNpZm5kZWYgQ09ORklHX1VNTAogLyoKZGlm ZiAtLWdpdCBhL2FyY2gveDg2L2xpYi9tZW1zZXRfNjQuUyBiL2FyY2gveDg2L2xpYi9tZW1zZXRf NjQuUwppbmRleCA5MjdhYzQ0ZDM0YWEuLjU2NGFiZjllY2VkYiAxMDA2NDQKLS0tIGEvYXJjaC94 ODYvbGliL21lbXNldF82NC5TCisrKyBiL2FyY2gveDg2L2xpYi9tZW1zZXRfNjQuUwpAQCAtNTks MTYgKzU5LDE2IEBAIEVYUE9SVF9TWU1CT0woX19tZW1zZXQpCiAgKgogICogcmF4ICAgb3JpZ2lu YWwgZGVzdGluYXRpb24KICAqLwotRU5UUlkobWVtc2V0X2VybXMpCitTWU1fRlVOQ19TVEFSVF9M T0NBTChtZW1zZXRfZXJtcykKIAltb3ZxICVyZGksJXI5CiAJbW92YiAlc2lsLCVhbAogCW1vdnEg JXJkeCwlcmN4CiAJcmVwIHN0b3NiCiAJbW92cSAlcjksJXJheAogCXJldAotRU5EUFJPQyhtZW1z ZXRfZXJtcykKK1NZTV9GVU5DX0VORChtZW1zZXRfZXJtcykKIAotRU5UUlkobWVtc2V0X29yaWcp CitTWU1fRlVOQ19TVEFSVF9MT0NBTChtZW1zZXRfb3JpZykKIAltb3ZxICVyZGksJXIxMAogCiAJ LyogZXhwYW5kIGJ5dGUgdmFsdWUgICovCkBAIC0xMzksNCArMTM5LDQgQEAgRU5UUlkobWVtc2V0 X29yaWcpCiAJc3VicSAlcjgsJXJkeAogCWptcCAuTGFmdGVyX2JhZF9hbGlnbm1lbnQKIC5MZmlu YWw6Ci1FTkRQUk9DKG1lbXNldF9vcmlnKQorU1lNX0ZVTkNfRU5EKG1lbXNldF9vcmlnKQpkaWZm IC0tZ2l0IGEvYXJjaC94ODYvcGxhdGZvcm0vZWZpL2VmaV90aHVua182NC5TIGIvYXJjaC94ODYv cGxhdGZvcm0vZWZpL2VmaV90aHVua182NC5TCmluZGV4IDQ2YzU4YjA4NzM5Yy4uZDY3N2E3ZWIy ZDBhIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9wbGF0Zm9ybS9lZmkvZWZpX3RodW5rXzY0LlMKKysr IGIvYXJjaC94ODYvcGxhdGZvcm0vZWZpL2VmaV90aHVua182NC5TCkBAIC02Nyw3ICs2Nyw3IEBA IEVORFBST0MoZWZpNjRfdGh1bmspCiAgKgogICogVGhpcyBmdW5jdGlvbiBtdXN0IGJlIGludm9r ZWQgd2l0aCBhIDE6MSBtYXBwZWQgc3RhY2suCiAgKi8KLUVOVFJZKF9fZWZpNjRfdGh1bmspCitT WU1fRlVOQ19TVEFSVF9MT0NBTChfX2VmaTY0X3RodW5rKQogCW1vdmwJJWRzLCAlZWF4CiAJcHVz aAklcmF4CiAJbW92bAklZXMsICVlYXgKQEAgLTExNCwxNCArMTE0LDE0IEBAIEVOVFJZKF9fZWZp NjRfdGh1bmspCiAJb3IJJXJjeCwgJXJheAogMToKIAlyZXQKLUVORFBST0MoX19lZmk2NF90aHVu aykKK1NZTV9GVU5DX0VORChfX2VmaTY0X3RodW5rKQogCi1FTlRSWShlZmlfZXhpdDMyKQorU1lN X0ZVTkNfU1RBUlRfTE9DQUwoZWZpX2V4aXQzMikKIAltb3ZxCWZ1bmNfcnRfcHRyKCVyaXApLCAl cmF4CiAJcHVzaAklcmF4CiAJbW92CSVyZGksICVyYXgKIAlyZXQKLUVORFBST0MoZWZpX2V4aXQz MikKK1NZTV9GVU5DX0VORChlZmlfZXhpdDMyKQogCiAJLmNvZGUzMgogLyoKQEAgLTEyOSw3ICsx MjksNyBAQCBFTkRQUk9DKGVmaV9leGl0MzIpCiAgKgogICogVGhlIHN0YWNrIHNob3VsZCByZXBy ZXNlbnQgdGhlIDMyLWJpdCBjYWxsaW5nIGNvbnZlbnRpb24uCiAgKi8KLUVOVFJZKGVmaV9lbnRl cjMyKQorU1lNX0ZVTkNfU1RBUlRfTE9DQUwoZWZpX2VudGVyMzIpCiAJbW92bAkkX19LRVJORUxf RFMsICVlYXgKIAltb3ZsCSVlYXgsICVkcwogCW1vdmwJJWVheCwgJWVzCkBAIC0xNDUsNyArMTQ1 LDcgQEAgRU5UUlkoZWZpX2VudGVyMzIpCiAJcHVzaGwJJWVheAogCiAJbHJldAotRU5EUFJPQyhl ZmlfZW50ZXIzMikKK1NZTV9GVU5DX0VORChlZmlfZW50ZXIzMikKIAogCS5kYXRhCiAJLmJhbGln bgk4CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni94ZW4veGVuLXB2aC5TIGIvYXJjaC94ODYveGVuL3hl bi1wdmguUwppbmRleCA1MmIyODc5M2E2MjUuLmEyMGE1NWNjNTEzNSAxMDA2NDQKLS0tIGEvYXJj aC94ODYveGVuL3hlbi1wdmguUworKysgYi9hcmNoL3g4Ni94ZW4veGVuLXB2aC5TCkBAIC01NCw3 ICs1NCw3IEBACiAgKiBjaGFyZ2Ugb2Ygc2V0dGluZyB1cCBpdCdzIG93biBzdGFjaywgR0RUIGFu ZCBJRFQuCiAgKi8KIAotRU5UUlkocHZoX3N0YXJ0X3hlbikKK1NZTV9DT0RFX1NUQVJUX0xPQ0FM KHB2aF9zdGFydF94ZW4pCiAJY2xkCiAKIAlsZ2R0IChfcGEoZ2R0KSkKQEAgLTEzMyw3ICsxMzMs NyBAQCBFTlRSWShwdmhfc3RhcnRfeGVuKQogCiAJbGptcCAkX19CT09UX0NTLCAkX3BhKHN0YXJ0 dXBfMzIpCiAjZW5kaWYKLUVORChwdmhfc3RhcnRfeGVuKQorU1lNX0NPREVfRU5EKHB2aF9zdGFy dF94ZW4pCiAKIAkuc2VjdGlvbiAiLmluaXQuZGF0YSIsImF3IgogCS5iYWxpZ24gOAotLSAKMi4x Ni4zCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVu LWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKaHR0cHM6 Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hlbi1kZXZlbA==