| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Nicholas Piggin | 417 | 58.98% | 19 | 41.30% |
| Xiongwei Song | 111 | 15.70% | 1 | 2.17% |
| Christophe Leroy | 77 | 10.89% | 7 | 15.22% |
| Mukesh Kumar Chaurasiya | 23 | 3.25% | 2 | 4.35% |
| Paul Mackerras | 16 | 2.26% | 2 | 4.35% |
| Alexander Graf | 14 | 1.98% | 3 | 6.52% |
| Anton Blanchard | 14 | 1.98% | 2 | 4.35% |
| Hollis Blanchard | 9 | 1.27% | 1 | 2.17% |
| Srikar Dronamraju | 6 | 0.85% | 1 | 2.17% |
| Daniel Axtens | 4 | 0.57% | 2 | 4.35% |
| Rohan McLure | 4 | 0.57% | 1 | 2.17% |
| Naveen N. Rao | 3 | 0.42% | 1 | 2.17% |
| Michael Ellerman | 3 | 0.42% | 1 | 2.17% |
| Benjamin Herrenschmidt | 3 | 0.42% | 1 | 2.17% |
| Thomas Huth | 2 | 0.28% | 1 | 2.17% |
| Mukesh Kumar Chaurasiya (IBM) | 1 | 0.14% | 1 | 2.17% |
| Total | 707 | 46 |
/* SPDX-License-Identifier: GPL-2.0-or-later */ #ifndef _ASM_POWERPC_INTERRUPT_H #define _ASM_POWERPC_INTERRUPT_H /* BookE/4xx */ #define INTERRUPT_CRITICAL_INPUT 0x100 /* BookE */ #define INTERRUPT_DEBUG 0xd00 #ifdef CONFIG_BOOKE #define INTERRUPT_PERFMON 0x260 #define INTERRUPT_DOORBELL 0x280 #endif /* BookS/4xx/8xx */ #define INTERRUPT_MACHINE_CHECK 0x200 /* BookS/8xx */ #define INTERRUPT_SYSTEM_RESET 0x100 /* BookS */ #define INTERRUPT_DATA_SEGMENT 0x380 #define INTERRUPT_INST_SEGMENT 0x480 #define INTERRUPT_TRACE 0xd00 #define INTERRUPT_H_DATA_STORAGE 0xe00 #define INTERRUPT_HMI 0xe60 #define INTERRUPT_H_FAC_UNAVAIL 0xf80 #ifdef CONFIG_PPC_BOOK3S #define INTERRUPT_DOORBELL 0xa00 #define INTERRUPT_PERFMON 0xf00 #define INTERRUPT_ALTIVEC_UNAVAIL 0xf20 #endif /* BookE/BookS/4xx/8xx */ #define INTERRUPT_DATA_STORAGE 0x300 #define INTERRUPT_INST_STORAGE 0x400 #define INTERRUPT_EXTERNAL 0x500 #define INTERRUPT_ALIGNMENT 0x600 #define INTERRUPT_PROGRAM 0x700 #define INTERRUPT_SYSCALL 0xc00 #define INTERRUPT_TRACE 0xd00 /* BookE/BookS/44x */ #define INTERRUPT_FP_UNAVAIL 0x800 /* BookE/BookS/44x/8xx */ #define INTERRUPT_DECREMENTER 0x900 #ifndef INTERRUPT_PERFMON #define INTERRUPT_PERFMON 0x0 #endif /* 8xx */ #define INTERRUPT_SOFT_EMU_8xx 0x1000 #define INTERRUPT_INST_TLB_MISS_8xx 0x1100 #define INTERRUPT_DATA_TLB_MISS_8xx 0x1200 #define INTERRUPT_INST_TLB_ERROR_8xx 0x1300 #define INTERRUPT_DATA_TLB_ERROR_8xx 0x1400 #define INTERRUPT_DATA_BREAKPOINT_8xx 0x1c00 #define INTERRUPT_INST_BREAKPOINT_8xx 0x1d00 /* 603 */ #define INTERRUPT_INST_TLB_MISS_603 0x1000 #define INTERRUPT_DATA_LOAD_TLB_MISS_603 0x1100 #define INTERRUPT_DATA_STORE_TLB_MISS_603 0x1200 #ifndef __ASSEMBLER__ #include <linux/sched/debug.h> /* for show_regs */ #include <linux/irq-entry-common.h> #include <asm/kprobes.h> #include <asm/runlatch.h> #ifdef CONFIG_PPC_IRQ_SOFT_MASK_DEBUG /* * WARN/BUG is handled with a program interrupt so minimise checks here to * avoid recursion and maximise the chance of getting the first oops handled. */ #define INT_SOFT_MASK_BUG_ON(regs, cond) \ do { \ if ((user_mode(regs) || (TRAP(regs) != INTERRUPT_PROGRAM))) \ BUG_ON(cond); \ } while (0) #else #define INT_SOFT_MASK_BUG_ON(regs, cond) #endif /* * Don't use noinstr here like x86, but rather add NOKPROBE_SYMBOL to each * function definition. The reason for this is the noinstr section is placed * after the main text section, i.e., very far away from the interrupt entry * asm. That creates problems with fitting linker stubs when building large * kernels. */ #define interrupt_handler __visible noinline notrace __no_kcsan __no_sanitize_address /** * DECLARE_INTERRUPT_HANDLER_RAW - Declare raw interrupt handler function * @func: Function name of the entry point * @returns: Returns a value back to asm caller */ #define DECLARE_INTERRUPT_HANDLER_RAW(func) \ __visible long func(struct pt_regs *regs) /** * DEFINE_INTERRUPT_HANDLER_RAW - Define raw interrupt handler function * @func: Function name of the entry point * @returns: Returns a value back to asm caller * * @func is called from ASM entry code. * * This is a plain function which does no tracing, reconciling, etc. * The macro is written so it acts as function definition. Append the * body with a pair of curly brackets. * * raw interrupt handlers must not enable or disable interrupts, or * schedule, tracing and instrumentation (ftrace, lockdep, etc) would * not be advisable either, although may be possible in a pinch, the * trace will look odd at least. * * A raw handler may call one of the other interrupt handler functions * to be converted into that interrupt context without these restrictions. * * On PPC64, _RAW handlers may return with fast_interrupt_return. * * Specific handlers may have additional restrictions. */ #define DEFINE_INTERRUPT_HANDLER_RAW(func) \ static __always_inline __no_sanitize_address __no_kcsan long \ ____##func(struct pt_regs *regs); \ \ interrupt_handler long func(struct pt_regs *regs) \ { \ long ret; \ \ __hard_RI_enable(); \ \ ret = ____##func (regs); \ \ return ret; \ } \ NOKPROBE_SYMBOL(func); \ \ static __always_inline __no_sanitize_address __no_kcsan long \ ____##func(struct pt_regs *regs) /** * DECLARE_INTERRUPT_HANDLER - Declare synchronous interrupt handler function * @func: Function name of the entry point */ #define DECLARE_INTERRUPT_HANDLER(func) \ __visible void func(struct pt_regs *regs) /** * DEFINE_INTERRUPT_HANDLER - Define synchronous interrupt handler function * @func: Function name of the entry point * * @func is called from ASM entry code. * * The macro is written so it acts as function definition. Append the * body with a pair of curly brackets. */ #define DEFINE_INTERRUPT_HANDLER(func) \ static __always_inline void ____##func(struct pt_regs *regs); \ \ interrupt_handler void func(struct pt_regs *regs) \ { \ irqentry_state_t state; \ arch_interrupt_enter_prepare(regs); \ state = irqentry_enter(regs); \ instrumentation_begin(); \ ____##func (regs); \ instrumentation_end(); \ arch_interrupt_exit_prepare(regs); \ irqentry_exit(regs, state); \ } \ NOKPROBE_SYMBOL(func); \ \ static __always_inline void ____##func(struct pt_regs *regs) /** * DECLARE_INTERRUPT_HANDLER_RET - Declare synchronous interrupt handler function * @func: Function name of the entry point * @returns: Returns a value back to asm caller */ #define DECLARE_INTERRUPT_HANDLER_RET(func) \ __visible long func(struct pt_regs *regs) /** * DEFINE_INTERRUPT_HANDLER_RET - Define synchronous interrupt handler function * @func: Function name of the entry point * @returns: Returns a value back to asm caller * * @func is called from ASM entry code. * * The macro is written so it acts as function definition. Append the * body with a pair of curly brackets. */ #define DEFINE_INTERRUPT_HANDLER_RET(func) \ static __always_inline long ____##func(struct pt_regs *regs); \ \ interrupt_handler long func(struct pt_regs *regs) \ { \ long ret; \ irqentry_state_t state; \ \ arch_interrupt_enter_prepare(regs); \ state = irqentry_enter(regs); \ instrumentation_begin(); \ ret = ____##func (regs); \ instrumentation_end(); \ arch_interrupt_exit_prepare(regs); \ irqentry_exit(regs, state); \ \ return ret; \ } \ NOKPROBE_SYMBOL(func); \ \ static __always_inline long ____##func(struct pt_regs *regs) /** * DECLARE_INTERRUPT_HANDLER_ASYNC - Declare asynchronous interrupt handler function * @func: Function name of the entry point */ #define DECLARE_INTERRUPT_HANDLER_ASYNC(func) \ __visible void func(struct pt_regs *regs) /** * DEFINE_INTERRUPT_HANDLER_ASYNC - Define asynchronous interrupt handler function * @func: Function name of the entry point * * @func is called from ASM entry code. * * The macro is written so it acts as function definition. Append the * body with a pair of curly brackets. */ #define DEFINE_INTERRUPT_HANDLER_ASYNC(func) \ static __always_inline void ____##func(struct pt_regs *regs); \ \ interrupt_handler void func(struct pt_regs *regs) \ { \ irqentry_state_t state; \ arch_interrupt_async_enter_prepare(regs); \ state = irqentry_enter(regs); \ instrumentation_begin(); \ irq_enter_rcu(); \ ____##func (regs); \ nap_adjust_return(regs); \ irq_exit_rcu(); \ instrumentation_end(); \ arch_interrupt_async_exit_prepare(regs); \ irqentry_exit(regs, state); \ } \ NOKPROBE_SYMBOL(func); \ \ static __always_inline void ____##func(struct pt_regs *regs) /** * DECLARE_INTERRUPT_HANDLER_NMI - Declare NMI interrupt handler function * @func: Function name of the entry point * @returns: Returns a value back to asm caller */ #define DECLARE_INTERRUPT_HANDLER_NMI(func) \ __visible long func(struct pt_regs *regs) /** * DEFINE_INTERRUPT_HANDLER_NMI - Define NMI interrupt handler function * @func: Function name of the entry point * @returns: Returns a value back to asm caller * * @func is called from ASM entry code. * * The macro is written so it acts as function definition. Append the * body with a pair of curly brackets. */ #define DEFINE_INTERRUPT_HANDLER_NMI(func) \ static __always_inline __no_sanitize_address __no_kcsan long \ ____##func(struct pt_regs *regs); \ \ interrupt_handler long func(struct pt_regs *regs) \ { \ irqentry_state_t state; \ struct interrupt_nmi_state nmi_state; \ long ret; \ \ arch_interrupt_nmi_enter_prepare(regs, &nmi_state); \ if (mfmsr() & MSR_DR) { \ /* nmi_entry if relocations are on */ \ state = irqentry_nmi_enter(regs); \ } else if (IS_ENABLED(CONFIG_PPC_BOOK3S_64) && \ firmware_has_feature(FW_FEATURE_LPAR) && \ !radix_enabled()) { \ /* no nmi_entry for a pseries hash guest \ * taking a real mode exception */ \ } else if (IS_ENABLED(CONFIG_KASAN)) { \ /* no nmi_entry for KASAN in real mode */ \ } else if (percpu_first_chunk_is_paged) { \ /* no nmi_entry if percpu first chunk is not embedded */\ } else { \ state = irqentry_nmi_enter(regs); \ } \ ret = ____##func (regs); \ arch_interrupt_nmi_exit_prepare(regs, &nmi_state); \ if (mfmsr() & MSR_DR) { \ /* nmi_exit if relocations are on */ \ irqentry_nmi_exit(regs, state); \ } else if (IS_ENABLED(CONFIG_PPC_BOOK3S_64) && \ firmware_has_feature(FW_FEATURE_LPAR) && \ !radix_enabled()) { \ /* no nmi_exit for a pseries hash guest \ * taking a real mode exception */ \ } else if (IS_ENABLED(CONFIG_KASAN)) { \ /* no nmi_exit for KASAN in real mode */ \ } else if (percpu_first_chunk_is_paged) { \ /* no nmi_exit if percpu first chunk is not embedded */ \ } else { \ irqentry_nmi_exit(regs, state); \ } \ \ return ret; \ } \ NOKPROBE_SYMBOL(func); \ \ static __always_inline __no_sanitize_address __no_kcsan long \ ____##func(struct pt_regs *regs) /* Interrupt handlers */ /* kernel/traps.c */ DECLARE_INTERRUPT_HANDLER_NMI(system_reset_exception); #ifdef CONFIG_PPC_BOOK3S_64 DECLARE_INTERRUPT_HANDLER_RAW(machine_check_early_boot); DECLARE_INTERRUPT_HANDLER_ASYNC(machine_check_exception_async); #endif DECLARE_INTERRUPT_HANDLER_NMI(machine_check_exception); DECLARE_INTERRUPT_HANDLER(SMIException); DECLARE_INTERRUPT_HANDLER(handle_hmi_exception); DECLARE_INTERRUPT_HANDLER(unknown_exception); DECLARE_INTERRUPT_HANDLER_ASYNC(unknown_async_exception); DECLARE_INTERRUPT_HANDLER_NMI(unknown_nmi_exception); DECLARE_INTERRUPT_HANDLER(instruction_breakpoint_exception); DECLARE_INTERRUPT_HANDLER(RunModeException); DECLARE_INTERRUPT_HANDLER(single_step_exception); DECLARE_INTERRUPT_HANDLER(program_check_exception); DECLARE_INTERRUPT_HANDLER(emulation_assist_interrupt); DECLARE_INTERRUPT_HANDLER(alignment_exception); DECLARE_INTERRUPT_HANDLER(StackOverflow); DECLARE_INTERRUPT_HANDLER(stack_overflow_exception); DECLARE_INTERRUPT_HANDLER(kernel_fp_unavailable_exception); DECLARE_INTERRUPT_HANDLER(altivec_unavailable_exception); DECLARE_INTERRUPT_HANDLER(vsx_unavailable_exception); DECLARE_INTERRUPT_HANDLER(facility_unavailable_exception); DECLARE_INTERRUPT_HANDLER(fp_unavailable_tm); DECLARE_INTERRUPT_HANDLER(altivec_unavailable_tm); DECLARE_INTERRUPT_HANDLER(vsx_unavailable_tm); DECLARE_INTERRUPT_HANDLER_NMI(performance_monitor_exception_nmi); DECLARE_INTERRUPT_HANDLER_ASYNC(performance_monitor_exception_async); DECLARE_INTERRUPT_HANDLER_RAW(performance_monitor_exception); DECLARE_INTERRUPT_HANDLER(DebugException); DECLARE_INTERRUPT_HANDLER(altivec_assist_exception); DECLARE_INTERRUPT_HANDLER(CacheLockingException); DECLARE_INTERRUPT_HANDLER(SPEFloatingPointException); DECLARE_INTERRUPT_HANDLER(SPEFloatingPointRoundException); DECLARE_INTERRUPT_HANDLER_NMI(WatchdogException); DECLARE_INTERRUPT_HANDLER(kernel_bad_stack); /* slb.c */ DECLARE_INTERRUPT_HANDLER_RAW(do_slb_fault); DECLARE_INTERRUPT_HANDLER(do_bad_segment_interrupt); /* hash_utils.c */ DECLARE_INTERRUPT_HANDLER(do_hash_fault); /* fault.c */ DECLARE_INTERRUPT_HANDLER(do_page_fault); DECLARE_INTERRUPT_HANDLER(do_bad_page_fault_segv); /* process.c */ DECLARE_INTERRUPT_HANDLER(do_break); /* time.c */ DECLARE_INTERRUPT_HANDLER_ASYNC(timer_interrupt); /* mce.c */ DECLARE_INTERRUPT_HANDLER_NMI(machine_check_early); DECLARE_INTERRUPT_HANDLER_NMI(hmi_exception_realmode); DECLARE_INTERRUPT_HANDLER_ASYNC(TAUException); /* irq.c */ DECLARE_INTERRUPT_HANDLER_ASYNC(do_IRQ); void __noreturn unrecoverable_exception(struct pt_regs *regs); void replay_system_reset(void); void replay_soft_interrupts(void); static inline void interrupt_cond_local_irq_enable(struct pt_regs *regs) { if (!regs_irqs_disabled(regs)) local_irq_enable(); } long system_call_exception(struct pt_regs *regs, unsigned long r0); notrace unsigned long syscall_exit_prepare(unsigned long r3, struct pt_regs *regs, long scv); notrace unsigned long interrupt_exit_user_prepare(struct pt_regs *regs); notrace unsigned long interrupt_exit_kernel_prepare(struct pt_regs *regs); #ifdef CONFIG_PPC64 unsigned long syscall_exit_restart(unsigned long r3, struct pt_regs *regs); unsigned long interrupt_exit_user_restart(struct pt_regs *regs); unsigned long interrupt_exit_kernel_restart(struct pt_regs *regs); #endif #endif /* __ASSEMBLER__ */ #endif /* _ASM_POWERPC_INTERRUPT_H */
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1