| Message ID | 20170421141305.25180-4-jslaby@suse.cz (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On Fri, Apr 21, 2017 at 04:12:40PM +0200, Jiri Slaby wrote: > Somewhere END was used to end a function. It is not intended to be used > for functions, because it does not mark the actual symbols as functions. > Use ENDPROC in such cases which does the right job. > > Signed-off-by: Jiri Slaby <jslaby@suse.cz> > Cc: Thomas Gleixner <tglx@linutronix.de> > Cc: Ingo Molnar <mingo@redhat.com> > Cc: "H. Peter Anvin" <hpa@zytor.com> > Cc: <x86@kernel.org> > Cc: Boris Ostrovsky <boris.ostrovsky@oracle.com> > Cc: Juergen Gross <jgross@suse.com> > Reviewed-by: Juergen Gross <jgross@suse.com> [xen parts] > Cc: <xen-devel@lists.xenproject.org> > --- > arch/x86/entry/entry_32.S | 58 ++++++++++++++++++++-------------------- > arch/x86/entry/entry_64.S | 40 +++++++++++++-------------- > arch/x86/entry/entry_64_compat.S | 4 +-- > arch/x86/kernel/ftrace_32.S | 8 +++--- > arch/x86/kernel/ftrace_64.S | 10 +++---- > arch/x86/xen/xen-pvh.S | 2 +- > 6 files changed, 61 insertions(+), 61 deletions(-) > > diff --git a/arch/x86/entry/entry_32.S b/arch/x86/entry/entry_32.S > index 50bc26949e9e..a546b84aec01 100644 > --- a/arch/x86/entry/entry_32.S > +++ b/arch/x86/entry/entry_32.S > @@ -249,7 +249,7 @@ ENTRY(__switch_to_asm) > popl %ebp > > jmp __switch_to > -END(__switch_to_asm) > +ENDPROC(__switch_to_asm) > > /* > * A newly forked process directly context switches into this address. > @@ -289,7 +289,7 @@ ENTRY(ret_from_fork) > */ > movl $0, PT_EAX(%esp) > jmp 2b > -END(ret_from_fork) > +ENDPROC(ret_from_fork) > > /* > * Return to user mode is not as complex as all this looks, > @@ -323,7 +323,7 @@ ENTRY(resume_userspace) > movl %esp, %eax > call prepare_exit_to_usermode > jmp restore_all > -END(ret_from_exception) > +ENDPROC(ret_from_exception) What exactly is the motivation of this patch? It would be good to describe that in the commit message. Is the point to allow objtool to generate CFI for it? If so, I don't really see how that would work. Today, objtool considers ENDPROC to annotate a *callable* function which conforms to the C calling ABI and can be called by another function. The stack is in a known state at function entry, and so the CFI (or frame pointer info) can be reliably determined. But entry code is different. In most cases, the global symbols aren't actually called, and they don't follow any conventions. The code is spaghetti-esque, with HW handlers and jumps everywhere. The state of the stack at symbol entry varies per "function". That's why objtool ignores these files. For special cases (like entry code), I was thinking we'd need manual CFI annotations, like we had before. Or maybe there's another way, like some new macros which tell objtool about the HW entry points and the state of the registers there. But I'm having trouble seeing how marking these code snippets with ENTRY/ENDPROC would help objtool make any sense of the code and where things are on the stack.
On 04/26/2017, 03:42 AM, Josh Poimboeuf wrote: >> @@ -323,7 +323,7 @@ ENTRY(resume_userspace) >> movl %esp, %eax >> call prepare_exit_to_usermode >> jmp restore_all >> -END(ret_from_exception) >> +ENDPROC(ret_from_exception) > > What exactly is the motivation of this patch? It would be good to > describe that in the commit message. > > Is the point to allow objtool to generate CFI for it? If so, I don't > really see how that would work. Today, objtool considers ENDPROC to > annotate a *callable* function which conforms to the C calling ABI and > can be called by another function. The stack is in a known state at > function entry, and so the CFI (or frame pointer info) can be reliably > determined. Ugh, I haven't checked this in 100 % of cases, but this looks pretty fragile to me. From reading the code, the use of END or ENDPROC is rather random -- depending on mood and who wrote the code. > But entry code is different. In most cases, the global symbols aren't > actually called, and they don't follow any conventions. The code is > spaghetti-esque, with HW handlers and jumps everywhere. The state of > the stack at symbol entry varies per "function". That's why objtool > ignores these files. Unfortunately, this is true. > For special cases (like entry code), I was thinking we'd need manual CFI > annotations, like we had before. Or maybe there's another way, like > some new macros which tell objtool about the HW entry points and the > state of the registers there. > > But I'm having trouble seeing how marking these code snippets with > ENTRY/ENDPROC would help objtool make any sense of the code and where > things are on the stack. Ok, my intention was to have every line of assembly code in between of FUNC_START/FUNC_END. That way, every rsp related push/pop/sub/add can be annotated very easily. For the C-like functions this is all what needs to be done. Then there is the spaghetti code. And I was thinking about manual annotations like: # skip the frame pointer checking between START+END here OBJTOOL(SKIP_CHECKING) # this fn has unusual frame (like interrupts have), and you can find return RIP stored at fp + 0x20 OBJTOOL(RIP_IS_AT, 0x20) # put this raw CFI for this location into eh_frame OBJTOOL(RAW_CFI, 0x00, 0x00, 0x00) Similarly, I have OBJTOOL(START_FUNC) and OBJTOOL(END_FUNC) emitted with each FUNC_START/FUNC_END. So far, when manually expanded for simplicity, it looks like this: #define OBJTOOL_START_FUNC \ .pushsection .discard.asmfunctions ASM_NL \ .long 0xfd111111 ASM_NL \ .long 1f - . ASM_NL \ .popsection ASM_NL \ 1: #define OBJTOOL_END_FUNC \ .pushsection .discard.asmfunctions ASM_NL \ .long 0xfe111111 ASM_NL \ .long 1f - . ASM_NL \ .popsection ASM_NL \ 1: 0xfd111111, 0xfe111111 are "opcodes" for objtool meaning START_FUNC/END_FUNC. Similar would be SKIP_CHECKING, RIP_IS_AT, and RAW_CFI from the above. So on the objtool side, it looks like: switch (data->magic) { case 0xfd111111: pc_begin = rela->addend; break; case 0xfe111111: ret = dwarf_annotate_func(dwarf, rela->sym->sec, pc_begin, rela->addend - pc_begin); if (ret < 0) return -1; break; So this was my idea -- having all code marked as function and manually annotate those which are different. thanks,
On Fri, May 12, 2017 at 09:53:48AM +0200, Jiri Slaby wrote: > On 04/26/2017, 03:42 AM, Josh Poimboeuf wrote: > >> @@ -323,7 +323,7 @@ ENTRY(resume_userspace) > >> movl %esp, %eax > >> call prepare_exit_to_usermode > >> jmp restore_all > >> -END(ret_from_exception) > >> +ENDPROC(ret_from_exception) > > > > What exactly is the motivation of this patch? It would be good to > > describe that in the commit message. > > > > Is the point to allow objtool to generate CFI for it? If so, I don't > > really see how that would work. Today, objtool considers ENDPROC to > > annotate a *callable* function which conforms to the C calling ABI and > > can be called by another function. The stack is in a known state at > > function entry, and so the CFI (or frame pointer info) can be reliably > > determined. > > Ugh, I haven't checked this in 100 % of cases, but this looks pretty > fragile to me. From reading the code, the use of END or ENDPROC is > rather random -- depending on mood and who wrote the code. Yes, it would be fragile, but objtool has a fix for that. It looks at every instruction in the object file and warns if it finds a return instruction outside of an ENDPROC function. That works because all callable instructions have return instructions (except when they have sibling calls, but objtool detects those too). So objtool will flag any C-type functions that forgot to use ENDPROC. > > But entry code is different. In most cases, the global symbols aren't > > actually called, and they don't follow any conventions. The code is > > spaghetti-esque, with HW handlers and jumps everywhere. The state of > > the stack at symbol entry varies per "function". That's why objtool > > ignores these files. > > Unfortunately, this is true. > > > For special cases (like entry code), I was thinking we'd need manual CFI > > annotations, like we had before. Or maybe there's another way, like > > some new macros which tell objtool about the HW entry points and the > > state of the registers there. > > > > But I'm having trouble seeing how marking these code snippets with > > ENTRY/ENDPROC would help objtool make any sense of the code and where > > things are on the stack. > > Ok, my intention was to have every line of assembly code in between of > FUNC_START/FUNC_END. That way, every rsp related push/pop/sub/add can be > annotated very easily. For the C-like functions this is all what needs > to be done. > > Then there is the spaghetti code. And I was thinking about manual > annotations like: > > # skip the frame pointer checking between START+END here > OBJTOOL(SKIP_CHECKING) > > # this fn has unusual frame (like interrupts have), > and you can find return RIP stored at fp + 0x20 > OBJTOOL(RIP_IS_AT, 0x20) > > # put this raw CFI for this location into eh_frame > OBJTOOL(RAW_CFI, 0x00, 0x00, 0x00) > > > Similarly, I have OBJTOOL(START_FUNC) and OBJTOOL(END_FUNC) emitted with > each FUNC_START/FUNC_END. So far, when manually expanded for simplicity, > it looks like this: I like the idea of making objtool smart enough to read the entry code, and of combining automated annotations (where possible) with manual annotations (where necessary). And it does make sense for objtool to automate every rsp-related push/pop/sub/add annotation. That will make the entry code quite a bit cleaner since we don't need 'push_cfi' and friends anymore. However, I think trying to force the entry code snippets into being normal functions would be awkward. For example, C-type functions all start off with the following initial CFI state: LOC CFA ra 0000000000000000 rsp+8 c-8 That means the previous frame's stack pointer was at rsp+8 and the return instruction pointer is (rsp). But those assumptions don't hold for non-C-type functions, which usually start with pt_regs or iret regs on the stack, or a blank slate. So the initial CFI state is different between the two types of "functions". And there are a lot of other differences. C-type functions have to follow frame pointer conventions, for example. So your FUNC_START macro (and objtool) would have to somehow figure out a way to make a distinction between the two. So it would probably work out better if we kept the distinction between C-type functions and other code. I think ENDPROC (or FUNC_START/FUNC_END) should mean "this function is 100% standardized to the C ABI and its debuginfo can be completely automated". And any code outside of that would be "this code is special and needs a mix of automated and manual debuginfo annotations." I'm also not sure we need the objtool-specific macros. It might be simpler to have macros which just output the cfi instead. I guess this goes back to our previous discussions about whether objtool's CFI access should be read/write or write-only. I don't remember, did we ever to come to a conclusion with that? Either way, from looking at the entry code, we may be able to get away with only the following .macros: - DWARF_EMPTY_FRAME signal=0 Mark all registers as undefined and potentially mark the frame as a signal frame. - DWARF_SET_CFA base=rsp offset=0 c_regs=0 extra_regs=0 iret_regs=0 Set the CFA value. Set c_regs, extra_regs, and/or iret_regs to indicate which regs (if any) are stored just below the CFA. - DWARF_SET_INDIRECT_CFA base=rsp offset=0 val_offset=0 Set CFA = *(base + offset) + val_offset. I only saw a few places where this is needed, where it switches to the irq stack. We might be able to figure out a way to simplify the code in a non-intrusive way to get rid of the need for this one. And we could create higher-level macros from these primitives if needed. I think we'd only need the macros in relatively few places in the entry code. It would be a lot less intrusive than what we had before.
diff --git a/arch/x86/entry/entry_32.S b/arch/x86/entry/entry_32.S index 50bc26949e9e..a546b84aec01 100644 --- a/arch/x86/entry/entry_32.S +++ b/arch/x86/entry/entry_32.S @@ -249,7 +249,7 @@ ENTRY(__switch_to_asm) popl %ebp jmp __switch_to -END(__switch_to_asm) +ENDPROC(__switch_to_asm) /* * A newly forked process directly context switches into this address. @@ -289,7 +289,7 @@ ENTRY(ret_from_fork) */ movl $0, PT_EAX(%esp) jmp 2b -END(ret_from_fork) +ENDPROC(ret_from_fork) /* * Return to user mode is not as complex as all this looks, @@ -323,7 +323,7 @@ ENTRY(resume_userspace) movl %esp, %eax call prepare_exit_to_usermode jmp restore_all -END(ret_from_exception) +ENDPROC(ret_from_exception) #ifdef CONFIG_PREEMPT ENTRY(resume_kernel) @@ -335,7 +335,7 @@ ENTRY(resume_kernel) jz restore_all call preempt_schedule_irq jmp .Lneed_resched -END(resume_kernel) +ENDPROC(resume_kernel) #endif GLOBAL(__begin_SYSENTER_singlestep_region) @@ -635,7 +635,7 @@ ENTRY(irq_entries_start) jmp common_interrupt .align 8 .endr -END(irq_entries_start) +ENDPROC(irq_entries_start) /* * the CPU automatically disables interrupts when executing an IRQ vector, @@ -684,7 +684,7 @@ ENTRY(coprocessor_error) pushl $0 pushl $do_coprocessor_error jmp common_exception -END(coprocessor_error) +ENDPROC(coprocessor_error) ENTRY(simd_coprocessor_error) ASM_CLAC @@ -698,20 +698,20 @@ ENTRY(simd_coprocessor_error) pushl $do_simd_coprocessor_error #endif jmp common_exception -END(simd_coprocessor_error) +ENDPROC(simd_coprocessor_error) ENTRY(device_not_available) ASM_CLAC pushl $-1 # mark this as an int pushl $do_device_not_available jmp common_exception -END(device_not_available) +ENDPROC(device_not_available) #ifdef CONFIG_PARAVIRT ENTRY(native_iret) iret _ASM_EXTABLE(native_iret, iret_exc) -END(native_iret) +ENDPROC(native_iret) #endif ENTRY(overflow) @@ -719,59 +719,59 @@ ENTRY(overflow) pushl $0 pushl $do_overflow jmp common_exception -END(overflow) +ENDPROC(overflow) ENTRY(bounds) ASM_CLAC pushl $0 pushl $do_bounds jmp common_exception -END(bounds) +ENDPROC(bounds) ENTRY(invalid_op) ASM_CLAC pushl $0 pushl $do_invalid_op jmp common_exception -END(invalid_op) +ENDPROC(invalid_op) ENTRY(coprocessor_segment_overrun) ASM_CLAC pushl $0 pushl $do_coprocessor_segment_overrun jmp common_exception -END(coprocessor_segment_overrun) +ENDPROC(coprocessor_segment_overrun) ENTRY(invalid_TSS) ASM_CLAC pushl $do_invalid_TSS jmp common_exception -END(invalid_TSS) +ENDPROC(invalid_TSS) ENTRY(segment_not_present) ASM_CLAC pushl $do_segment_not_present jmp common_exception -END(segment_not_present) +ENDPROC(segment_not_present) ENTRY(stack_segment) ASM_CLAC pushl $do_stack_segment jmp common_exception -END(stack_segment) +ENDPROC(stack_segment) ENTRY(alignment_check) ASM_CLAC pushl $do_alignment_check jmp common_exception -END(alignment_check) +ENDPROC(alignment_check) ENTRY(divide_error) ASM_CLAC pushl $0 # no error code pushl $do_divide_error jmp common_exception -END(divide_error) +ENDPROC(divide_error) #ifdef CONFIG_X86_MCE ENTRY(machine_check) @@ -779,7 +779,7 @@ ENTRY(machine_check) pushl $0 pushl machine_check_vector jmp common_exception -END(machine_check) +ENDPROC(machine_check) #endif ENTRY(spurious_interrupt_bug) @@ -787,7 +787,7 @@ ENTRY(spurious_interrupt_bug) pushl $0 pushl $do_spurious_interrupt_bug jmp common_exception -END(spurious_interrupt_bug) +ENDPROC(spurious_interrupt_bug) #ifdef CONFIG_XEN ENTRY(xen_hypervisor_callback) @@ -888,7 +888,7 @@ ENTRY(trace_page_fault) ASM_CLAC pushl $trace_do_page_fault jmp common_exception -END(trace_page_fault) +ENDPROC(trace_page_fault) #endif ENTRY(page_fault) @@ -896,7 +896,7 @@ ENTRY(page_fault) pushl $do_page_fault ALIGN jmp common_exception -END(page_fault) +ENDPROC(page_fault) common_exception: /* the function address is in %gs's slot on the stack */ @@ -928,7 +928,7 @@ common_exception: movl %esp, %eax # pt_regs pointer call *%edi jmp ret_from_exception -END(common_exception) +ENDPROC(common_exception) ENTRY(debug) /* @@ -965,7 +965,7 @@ ENTRY(debug) call do_debug movl %ebx, %esp jmp ret_from_exception -END(debug) +ENDPROC(debug) /* * NMI is doubly nasty. It can happen on the first instruction of @@ -1033,7 +1033,7 @@ ENTRY(nmi) lss 12+4(%esp), %esp # back to espfix stack jmp .Lirq_return #endif -END(nmi) +ENDPROC(nmi) ENTRY(int3) ASM_CLAC @@ -1045,19 +1045,19 @@ ENTRY(int3) movl %esp, %eax # pt_regs pointer call do_int3 jmp ret_from_exception -END(int3) +ENDPROC(int3) ENTRY(general_protection) pushl $do_general_protection jmp common_exception -END(general_protection) +ENDPROC(general_protection) #ifdef CONFIG_KVM_GUEST ENTRY(async_page_fault) ASM_CLAC pushl $do_async_page_fault jmp common_exception -END(async_page_fault) +ENDPROC(async_page_fault) #endif ENTRY(rewind_stack_do_exit) @@ -1069,4 +1069,4 @@ ENTRY(rewind_stack_do_exit) call do_exit 1: jmp 1b -END(rewind_stack_do_exit) +ENDPROC(rewind_stack_do_exit) diff --git a/arch/x86/entry/entry_64.S b/arch/x86/entry/entry_64.S index 607d72c4a485..1fe8758102cb 100644 --- a/arch/x86/entry/entry_64.S +++ b/arch/x86/entry/entry_64.S @@ -321,7 +321,7 @@ syscall_return_via_sysret: opportunistic_sysret_failed: SWAPGS jmp restore_c_regs_and_iret -END(entry_SYSCALL_64) +ENDPROC(entry_SYSCALL_64) ENTRY(stub_ptregs_64) /* @@ -347,13 +347,13 @@ ENTRY(stub_ptregs_64) 1: jmp *%rax /* Called from C */ -END(stub_ptregs_64) +ENDPROC(stub_ptregs_64) .macro ptregs_stub func ENTRY(ptregs_\func) leaq \func(%rip), %rax jmp stub_ptregs_64 -END(ptregs_\func) +ENDPROC(ptregs_\func) .endm /* Instantiate ptregs_stub for each ptregs-using syscall */ @@ -396,7 +396,7 @@ ENTRY(__switch_to_asm) popq %rbp jmp __switch_to -END(__switch_to_asm) +ENDPROC(__switch_to_asm) /* * A newly forked process directly context switches into this address. @@ -432,7 +432,7 @@ ENTRY(ret_from_fork) */ movq $0, RAX(%rsp) jmp 2b -END(ret_from_fork) +ENDPROC(ret_from_fork) /* * Build the entry stubs with some assembler magic. @@ -447,7 +447,7 @@ ENTRY(irq_entries_start) jmp common_interrupt .align 8 .endr -END(irq_entries_start) +ENDPROC(irq_entries_start) /* * Interrupt entry/exit. @@ -649,7 +649,7 @@ native_irq_return_ldt: */ jmp native_irq_return_iret #endif -END(common_interrupt) +ENDPROC(common_interrupt) /* * APIC interrupts. @@ -661,7 +661,7 @@ ENTRY(\sym) .Lcommon_\sym: interrupt \do_sym jmp ret_from_intr -END(\sym) +ENDPROC(\sym) .endm #ifdef CONFIG_TRACING @@ -827,7 +827,7 @@ ENTRY(\sym) jmp error_exit /* %ebx: no swapgs flag */ .endif -END(\sym) +ENDPROC(\sym) .endm #ifdef CONFIG_TRACING @@ -870,7 +870,7 @@ ENTRY(native_load_gs_index) SWAPGS popfq ret -END(native_load_gs_index) +ENDPROC(native_load_gs_index) EXPORT_SYMBOL(native_load_gs_index) _ASM_EXTABLE(.Lgs_change, bad_gs) @@ -900,7 +900,7 @@ ENTRY(do_softirq_own_stack) leaveq decl PER_CPU_VAR(irq_count) ret -END(do_softirq_own_stack) +ENDPROC(do_softirq_own_stack) #ifdef CONFIG_XEN idtentry xen_hypervisor_callback xen_do_hypervisor_callback has_error_code=0 @@ -936,7 +936,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) +ENDPROC(xen_do_hypervisor_callback) /* * Hypervisor uses this for application faults while it executes. @@ -982,7 +982,7 @@ ENTRY(xen_failsafe_callback) SAVE_EXTRA_REGS ENCODE_FRAME_POINTER jmp error_exit -END(xen_failsafe_callback) +ENDPROC(xen_failsafe_callback) apicinterrupt3 HYPERVISOR_CALLBACK_VECTOR \ xen_hvm_callback_vector xen_evtchn_do_upcall @@ -1033,7 +1033,7 @@ ENTRY(paranoid_entry) SWAPGS xorl %ebx, %ebx 1: ret -END(paranoid_entry) +ENDPROC(paranoid_entry) /* * "Paranoid" exit path from exception stack. This is invoked @@ -1062,7 +1062,7 @@ paranoid_exit_restore: RESTORE_C_REGS REMOVE_PT_GPREGS_FROM_STACK 8 INTERRUPT_RETURN -END(paranoid_exit) +ENDPROC(paranoid_exit) /* * Save all registers in pt_regs, and switch gs if needed. @@ -1144,7 +1144,7 @@ ENTRY(error_entry) mov %rax, %rsp decl %ebx jmp .Lerror_entry_from_usermode_after_swapgs -END(error_entry) +ENDPROC(error_entry) /* @@ -1158,7 +1158,7 @@ ENTRY(error_exit) testl %ebx, %ebx jnz retint_kernel jmp retint_user -END(error_exit) +ENDPROC(error_exit) /* Runs on exception stack */ ENTRY(nmi) @@ -1506,12 +1506,12 @@ nmi_restore: * mode, so this cannot result in a fault. */ INTERRUPT_RETURN -END(nmi) +ENDPROC(nmi) ENTRY(ignore_sysret) mov $-ENOSYS, %eax sysret -END(ignore_sysret) +ENDPROC(ignore_sysret) ENTRY(rewind_stack_do_exit) /* Prevent any naive code from trying to unwind to our caller. */ @@ -1522,4 +1522,4 @@ ENTRY(rewind_stack_do_exit) call do_exit 1: jmp 1b -END(rewind_stack_do_exit) +ENDPROC(rewind_stack_do_exit) diff --git a/arch/x86/entry/entry_64_compat.S b/arch/x86/entry/entry_64_compat.S index e1721dafbcb1..966c09ffd62d 100644 --- a/arch/x86/entry/entry_64_compat.S +++ b/arch/x86/entry/entry_64_compat.S @@ -262,7 +262,7 @@ sysret32_from_system_call: movq RSP-ORIG_RAX(%rsp), %rsp swapgs sysretl -END(entry_SYSCALL_compat) +ENDPROC(entry_SYSCALL_compat) /* * 32-bit legacy system call entry. @@ -340,7 +340,7 @@ ENTRY(entry_INT80_compat) TRACE_IRQS_ON SWAPGS jmp restore_regs_and_iret -END(entry_INT80_compat) +ENDPROC(entry_INT80_compat) ALIGN GLOBAL(stub32_clone) diff --git a/arch/x86/kernel/ftrace_32.S b/arch/x86/kernel/ftrace_32.S index 07f40359c9ea..30bc4af8b0de 100644 --- a/arch/x86/kernel/ftrace_32.S +++ b/arch/x86/kernel/ftrace_32.S @@ -31,7 +31,7 @@ EXPORT_SYMBOL(mcount) ENTRY(function_hook) ret -END(function_hook) +ENDPROC(function_hook) ENTRY(ftrace_caller) @@ -98,7 +98,7 @@ ftrace_graph_call: /* This is weak to keep gas from relaxing the jumps */ WEAK(ftrace_stub) ret -END(ftrace_caller) +ENDPROC(ftrace_caller) ENTRY(ftrace_regs_caller) /* @@ -202,7 +202,7 @@ ftrace_stub: popl %ecx popl %eax jmp ftrace_stub -END(function_hook) +ENDPROC(function_hook) #endif /* CONFIG_DYNAMIC_FTRACE */ #ifdef CONFIG_FUNCTION_GRAPH_TRACER @@ -225,7 +225,7 @@ ENTRY(ftrace_graph_caller) popl %ecx popl %eax ret -END(ftrace_graph_caller) +ENDPROC(ftrace_graph_caller) .globl return_to_handler return_to_handler: diff --git a/arch/x86/kernel/ftrace_64.S b/arch/x86/kernel/ftrace_64.S index 1dfac634bbf7..823e31577333 100644 --- a/arch/x86/kernel/ftrace_64.S +++ b/arch/x86/kernel/ftrace_64.S @@ -147,7 +147,7 @@ EXPORT_SYMBOL(mcount) ENTRY(function_hook) retq -END(function_hook) +ENDPROC(function_hook) ENTRY(ftrace_caller) /* save_mcount_regs fills in first two parameters */ @@ -183,7 +183,7 @@ GLOBAL(ftrace_graph_call) /* This is weak to keep gas from relaxing the jumps */ WEAK(ftrace_stub) retq -END(ftrace_caller) +ENDPROC(ftrace_caller) ENTRY(ftrace_regs_caller) /* Save the current flags before any operations that can change them */ @@ -254,7 +254,7 @@ GLOBAL(ftrace_regs_caller_end) jmp ftrace_epilogue -END(ftrace_regs_caller) +ENDPROC(ftrace_regs_caller) #else /* ! CONFIG_DYNAMIC_FTRACE */ @@ -290,7 +290,7 @@ trace: restore_mcount_regs jmp fgraph_trace -END(function_hook) +ENDPROC(function_hook) #endif /* CONFIG_DYNAMIC_FTRACE */ #ifdef CONFIG_FUNCTION_GRAPH_TRACER @@ -312,7 +312,7 @@ ENTRY(ftrace_graph_caller) restore_mcount_regs retq -END(ftrace_graph_caller) +ENDPROC(ftrace_graph_caller) GLOBAL(return_to_handler) subq $24, %rsp diff --git a/arch/x86/xen/xen-pvh.S b/arch/x86/xen/xen-pvh.S index 5e246716d58f..512fda03c93f 100644 --- a/arch/x86/xen/xen-pvh.S +++ b/arch/x86/xen/xen-pvh.S @@ -133,7 +133,7 @@ ENTRY(pvh_start_xen) ljmp $__BOOT_CS, $_pa(startup_32) #endif -END(pvh_start_xen) +ENDPROC(pvh_start_xen) .section ".init.data","aw" .balign 8