alpha: enable generic entry infrastructure
Subsystems (5)
Magnus Lindholm
maintainerv4 cover alpha: enable generic entry infrastructure
Hi,
This series moves Alpha closer to the common architecture infrastructure and enables GENERIC_ENTRY. This is v4 of this patch
series, please see below for changes since v1, v2 and v3.
The main motivation is to reduce Alpha-specific syscall tracing, ptrace, seccomp, and return-to-user handling where common code already provides the required infrastructure. Alpha still has ABI-sensitive syscall details, most notably the assembly syscall invocation and the r0/r19 return-value encoding, so those remain Alpha-specific. The surrounding entry/exit decisions are moved towards common code.
The series first adds regset-based ptrace and core dump support. Alpha now provides a user_regset_view for NT_PRSTATUS and NT_PRFPREG, exports the ELF-visible general and floating-point register layouts, and uses the common ptrace regset implementation for PTRACE_GETREGSET and PTRACE_SETREGSET instead of open-coding iovec handling in arch_ptrace(). This also provides the basis for HAVE_ARCH_TRACEHOOK and common ptrace syscall-info support.
It then adds ARCH_STACKWALK support. The implementation uses a simple kernel stack scanning walker, starting after pt_regs for current tasks and using the saved PCB kernel stack pointer for blocked tasks. This enables common stacktrace users such as dump_stack(), /proc/*/stack, and SysRq backtraces, without introducing a frame-pointer-based unwinder. It also avoids relying on the legacy weak save_stack_trace_*() fallbacks, which is needed by the later generic IRQ-entry configuration in this series.
The next group of patches prepares Alpha for lockdep IRQ-state tracking. Alpha interrupt masking is controlled by the PAL IPL state, so the irqflags helpers are made to operate on IPL state rather than treating the full processor status word as the saved interrupt state. The series also provides ftrace return-address support for lockdep call-site reporting and converts low-level platform locks to raw spinlocks where regular spinlock instrumentation is not appropriate for the hardware and interrupt paths involved.
The lockdep patch then adds hardirq state tracking in Alpha's low-level entry/exit paths. It annotates PAL IPL transitions and the shared return path so lockdep can keep its interrupt state in sync with the hardware IPL state. This allows CONFIG_PROVE_LOCKING to remain useful on Alpha instead of quickly disabling debug_locks due to IRQ state mismatches.
The final patch enables GENERIC_ENTRY and. Syscall
entry now uses C helpers built around syscall_enter_from_user_mode(). The C entry helper handles the common syscall-entry work, including ptrace/seccomp entry processing, skip decisions, syscall-number shadowing, and syscall table lookup. It returns the selected syscall function pointer to assembly.
Assembly then performs only the Alpha-specific dispatch: it reloads the syscall arguments, preserves the required GP/stack conventions, and performs the indirect call through the function pointer returned by C. Skipped syscalls bypass that dispatch and return through the Alpha syscall-exit helper.
Syscall exit is split in the same way. Alpha first performs its ABI-specific result handling: r0/v0 carries the return value or positive errno, and r19/a3 carries the error flag. It also handles skipped syscall restart state and successful syscalls whose return values may look like negative errnos, such as legacy ptrace PEEK requests. Once the Alpha-specific r0/r19 state is encoded, the path enters syscall_exit_to_user_mode() for the common syscall-exit and exit-to-user-mode work.
The syscall number used by generic entry is kept separately from the return-value register. entSys copies the raw r0 syscall number into r1, and r1 is used as Alpha's generic-entry syscall-number shadow. Restart bookkeeping that used to be carried by low-level assembly state is now kept explicitly in thread_info. This avoids using user-visible general registers as hidden restart state while preserving Alpha's restart and ptrace semantics.
Testing was performed on an Alpha EV68/Tsunami SMP system (UP2000+) as well as an Alphaserver 4100 (rawhide) system.
For the regset, ptrace, tracehook, and generic-entry changes, testing included:
- custom ptrace/regset round-trip tests for both GPR and FPR regsets
- PTRACE_GET_SYSCALL_INFO validation, including the reported user stack pointer
- ELF core dump inspection with readelf
- strace testsuite (make check), with the remaining failures comparable to the pre-series baseline on the same system.
Kernel tools/testing/selftests:
- ptrace: syscall-info tests improved over the baseline.
- seccomp: seccomp_bpf passes all applicable tests.
- exec: check-exec now passes once loop block-device support is enabled.
- ipc: ipc selftests improved over the baseline.
- acct: acct selftests improved over the baseline.
Overall, the selftest comparison did not show an obvious regression introduced by this series. Instead, the patched kernel reduced the number of failing top-level selftests and fixed several failures in areas that exercise the new ptrace, tracehook, seccomp, and generic-entry paths. Some unrelated failures remain and need separate investigation, but they are either also present in the baseline run or explained by missing kernel configuration or test-environment support.
For the stacktrace changes, the following scenarios were verified:
- SysRq 'l' prints backtraces for all CPUs, including syscall and interrupt contexts
- /proc/<pid>/stack returns sensible call chains for both the current task and sleeping tasks, such as nanosleep
- stack traces remain stable under scheduler and I/O load, including ping, ext4 writes, and background workqueues
- no crashes, lockups, or obvious mis-unwinds were observed
For the lockdep changes, /proc/lockdep_stats shows debug_locks remaining enabled, with no redundant hardirq or softirq on/off annotations observed during testing.
Review feedback is very welcome. Additional testing on other Alpha systems, CPU variants, and workloads would also be much appreciated.
Patches:
1. alpha: enable regset-based ptrace and core dumps
2. alpha: add ARCH_STACKWALK-based stacktrace support
3. alpha: make irqflags helpers operate on IPL state
4. alpha: provide ftrace return address support for lockdep
5. alpha: convert low-level platform locks to raw spinlocks
6. alpha: enable lockdep hardirq state tracking
7. alpha: enable GENERIC_ENTRY
Thanks,
Magnus
---
Changes since v1:
- Fixed skipped-syscall exit handling so PTRACE_SET_SYSCALL_INFO and legacy POKEUSR skips return ENOSYS/a3=1 only when no ptrace/seccomp return value was installed.
Changes since v2:
- patch 8: add PTRACE_PEEKUSR support for FP registers and PC
- patch 8: add/fix focused ptrace single-step validation
- patches 1-7: add Reviewed-by and Tested-by tag
Changes since v3:
- Rebase on v7.2-rc1
- Restored Alpha's explicit FPU save before signal delivery in the generic return-to-user path, fixing FP state corruption seen with asynchronous signals and FP-heavy userspace.
- Dropped the explicit GENERIC_IRQ_ENTRY select from Kconfig, since GENERIC_ENTRY already selects it.
- Dropped the pci-sysfs bin_attribute initialization patch; it is no longer needed after rebasing onto v7.2-rc1, where Alpha PCI resource attributes are static attribute-group entries rather than dynamically allocated bin_attributes.
Magnus Lindholm (7):
alpha: enable regset-based ptrace and core dumps
alpha: add ARCH_STACKWALK-based stacktrace support
alpha: make irqflags helpers operate on IPL state
alpha: provide ftrace return address support for lockdep
alpha: use raw spinlocks for low-level platform locks
alpha: enable lockdep hardirq state tracking
alpha: enable GENERIC_ENTRY
.../features/core/tracehook/arch-support.txt | 2 +- .../features/locking/lockdep/arch-support.txt | 2 +- arch/alpha/Kconfig | 12 + arch/alpha/include/asm/elf.h | 1 + arch/alpha/include/asm/entry-common.h | 14 + arch/alpha/include/asm/ftrace.h | 30 +- arch/alpha/include/asm/irqflags.h | 6 +- arch/alpha/include/asm/ptrace.h | 21 +- arch/alpha/include/asm/stacktrace.h | 20 + arch/alpha/include/asm/syscall.h | 18 +- arch/alpha/include/asm/thread_info.h | 31 +- arch/alpha/include/uapi/asm/ptrace.h | 2 +- arch/alpha/kernel/Makefile | 3 +- arch/alpha/kernel/asm-offsets.c | 6 + arch/alpha/kernel/entry.S | 328 +++++--------- arch/alpha/kernel/irq_alpha.c | 78 +++- arch/alpha/kernel/irq_i8259.c | 19 +- arch/alpha/kernel/proto.h | 13 +- arch/alpha/kernel/ptrace.c | 400 ++++++++++++++---- arch/alpha/kernel/signal.c | 149 ++++++- arch/alpha/kernel/stacktrace.c | 61 +++ arch/alpha/kernel/sys_dp264.c | 38 +- arch/alpha/kernel/sys_rawhide.c | 17 +- arch/alpha/kernel/traps.c | 8 + arch/alpha/kernel/vmlinux.lds.S | 2 + 25 files changed, 860 insertions(+), 421 deletions(-) create mode 100644 arch/alpha/include/asm/entry-common.h create mode 100644 arch/alpha/include/asm/stacktrace.h create mode 100644 arch/alpha/kernel/stacktrace.c
Signature · 1 line
2.53.0
Magnus Lindholm
maintainerPATCH v4 1/7 alpha: enable regset-based ptrace and core dumps
Add a user_regset_view for Alpha and switch ELF core dumping to CORE_DUMP_USE_REGSET. General-purpose registers are exported in ELF gregs layout, including callee-saved registers and a correct user stack pointer.
The user stack pointer is not preserved in pt_regs on Alpha, so expose it from the PCB, or via rdusp() for the current task, when building the ELF register image. This makes the user stack pointer consistent for core dumps, ptrace regsets, and PTRACE_GET_SYSCALL_INFO.
Implement regset get/set callbacks for both NT_PRSTATUS and NT_PRFPREG. The callbacks translate between Alpha's pt_regs/thread state and the ELF-visible register layouts, while the common ptrace regset code handles PTRACE_GETREGSET and PTRACE_SETREGSET iovec semantics. This avoids duplicating subtle short-buffer and oversized-buffer behavior in arch_ptrace().
With these changes Alpha satisfies the requirements for HAVE_ARCH_TRACEHOOK and selects it, enabling generic tracehook and ptrace syscall-info code paths without changing the existing syscall entry ABI.
--- .../features/core/tracehook/arch-support.txt | 2 +- arch/alpha/Kconfig | 1 + arch/alpha/include/asm/elf.h | 1 + arch/alpha/include/asm/ptrace.h | 7 + arch/alpha/include/asm/syscall.h | 7 + arch/alpha/include/asm/thread_info.h | 7 +- arch/alpha/include/uapi/asm/ptrace.h | 2 +- arch/alpha/kernel/asm-offsets.c | 1 + arch/alpha/kernel/entry.S | 15 +- arch/alpha/kernel/ptrace.c | 320 +++++++++++++++--- arch/alpha/kernel/traps.c | 8 + 11 files changed, 312 insertions(+), 59 deletions(-)
Documentation/features/core/tracehook/arch-support.txt +1 -1
@@ -6,7 +6,7 @@ ----------------------- | arch |status| ----------------------- - | alpha: | TODO | + | alpha: | ok | | arc: | ok | | arm: | ok | | arm64: | ok |
arch/alpha/Kconfig +1 -0
@@ -33,6 +33,7 @@ config ALPHA select HAVE_ARCH_AUDITSYSCALL select HAVE_ARCH_SECCOMP select HAVE_ARCH_SECCOMP_FILTER + select HAVE_ARCH_TRACEHOOK select HAVE_MOD_ARCH_SPECIFIC select LOCK_MM_AND_FIND_VMA select MODULES_USE_ELF_RELA
arch/alpha/include/asm/elf.h +1 -0
@@ -53,6 +53,7 @@#define EF_ALPHA_32BIT 1/* All addresses are below 2GB */ +#define CORE_DUMP_USE_REGSET 1/* * ELF register definitions.. */
arch/alpha/include/asm/ptrace.h +7 -0
@@ -24,4 +24,11 @@ static inline unsigned long regs_return_value(struct pt_regs *regs) return regs->r0; } +/* Helpers for working with the user stack pointer */ +static inline unsigned long user_stack_pointer (struct pt_regs *regs) +{ +/* Valid for user-mode regs */ +return regs->usp; +} +#endif
arch/alpha/include/asm/syscall.h +7 -0
@@ -19,6 +19,13 @@ static inline long syscall_get_return_value(struct task_struct *task,return regs->r19 ? -(long )regs->r0 : (long )regs->r0; } +static inline long syscall_get_error (struct task_struct *task, +struct pt_regs *regs) +{ +return regs->r19 ? -(long )regs->r0 :0 ; +} + +/* * Alpha syscall ABI / kernel conventions: * - PAL provides syscall number in r0 on entry.
arch/alpha/include/asm/thread_info.h +5 -2
@@ -66,6 +66,7 @@ register unsigned long *current_stack_pointer __asm__ ("$30");#define TIF_SYSCALL_AUDIT 4/* syscall audit active */ #define TIF_NOTIFY_SIGNAL 5/* signal notifications exist */ #define TIF_SECCOMP 6/* seccomp syscall filtering active */ +#define TIF_SYSCALL_TRACEPOINT 7/* syscall tracepoint instrumentation */ #define TIF_DIE_IF_KERNEL 9/* dik recursion lock */ #define TIF_MEMDIE 13/* is terminating due to OOM killer */ #define TIF_POLLING_NRFLAG 14/* idle is polling for TIF_NEED_RESCHED */
@@ -78,6 +79,7 @@ register unsigned long *current_stack_pointer __asm__ ("$30");#define _TIF_NOTIFY_SIGNAL (1<<TIF_NOTIFY_SIGNAL)#define _TIF_SECCOMP (1<<TIF_SECCOMP)#define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG) +#define _TIF_SYSCALL_TRACEPOINT (1<<TIF_SYSCALL_TRACEPOINT)/* * Work to do on syscall entry (in entry.S).
@@ -85,9 +87,10 @@ register unsigned long *current_stack_pointer __asm__ ("$30");* with the mask used before branching to syscall_trace_enter(). */ #ifdef CONFIG_AUDITSYSCALL -# define _TIF_SYSCALL_WORK (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | _TIF_SECCOMP) +# define _TIF_SYSCALL_WORK (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | _TIF_SECCOMP \ + | _TIF_SYSCALL_TRACEPOINT)#else -# define _TIF_SYSCALL_WORK (_TIF_SYSCALL_TRACE | _TIF_SECCOMP) +# define _TIF_SYSCALL_WORK (_TIF_SYSCALL_TRACE | _TIF_SECCOMP | _TIF_SYSCALL_TRACEPOINT)#endif /* Work to do on interrupt/exception return. */
arch/alpha/include/uapi/asm/ptrace.h +1 -1
@@ -43,7 +43,7 @@ struct pt_regs {unsigned long trap_a1;unsigned long trap_a2;/* This makes the stack 16-byte aligned as GCC expects */ -unsigned long __pad0; +unsigned long usp;/* These are saved by PAL-code: */ unsigned long ps;unsigned long pc;
arch/alpha/kernel/asm-offsets.c +1 -0
@@ -29,4 +29,5 @@ static void __used foo(void)DEFINE (HAE_CACHE , offsetof(struct alpha_machine_vector , hae_cache));DEFINE (HAE_REG , offsetof(struct alpha_machine_vector , hae_register)); +DEFINE (PT_REGS_USP , offsetof(struct pt_regs , usp)); }
arch/alpha/kernel/entry.S +8 -7
@@ -520,6 +520,12 @@ entSys: ldq $1, 0($sp) /* syscall nr from saved r0 */ stq $1, 8($sp) /* regs->r1 = shadow syscall nr */ stq $1, 16($sp) /* regs->r2 = restart syscall nr */ + /* Syscalls always enter from user mode: snapshot USP into pt_regs->usp */ + mov $0, $8 + call_pal PAL_rdusp + stq $0, PT_REGS_USP($sp) + mov $8, $0 + lda $8, 0x3fff bic $sp, $8, $8
@@ -535,15 +541,10 @@ entSys: .cfi_rel_offset $16, SP_OFF+24 .cfi_rel_offset $17, SP_OFF+32 .cfi_rel_offset $18, SP_OFF+40 -#ifdef CONFIG_AUDITSYSCALL - lda $6, _TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | _TIF_SECCOMP - and $3, $6, $3 - bne $3, strace -#else - lda $6, _TIF_SYSCALL_TRACE | _TIF_SECCOMP + lda $6, _TIF_SYSCALL_WORK and $3, $6, $3 bne $3, strace -#endif + beq $4, 1f ldq $27, 0($5) 1: ldq $0, 8($sp) /* syscall nr shadow (regs->r1) */
arch/alpha/kernel/ptrace.c +272 -48
358 lines not on this page · raw message
arch/alpha/kernel/traps.c +8 -0
@@ -30,6 +30,12 @@#include "proto.h" +static __always_inline void alpha_snapshot_usp(struct pt_regs *regs) +{ +if (user_mode (regs)) + regs->usp =rdusp (); +} +void dik_show_regs (struct pt_regs *regs,unsigned long *r9_15) {
@@ -180,6 +186,7 @@ do_entArith(unsigned long summary, unsigned long write_mask, {long si_code =FPE_FLTINV ; +alpha_snapshot_usp (regs);if (summary &1 ) {/* Software-completion summary bit is set, so try to emulate the instruction. If the processor supports
@@ -201,6 +208,7 @@ do_entIF(unsigned long type, struct pt_regs *regs) {int signo, code; +alpha_snapshot_usp (regs);if (type ==3 ) {/* FEN fault */ /* Irritating users can call PAL_clrfen to disable the FPU for the process. The kernel will then trap in
Signature · 1 line
2.53.0
Magnus Lindholm
maintainerPATCH v4 2/7 alpha: add ARCH_STACKWALK-based stacktrace support
In reply to Magnus LindholmImplement arch_stack_walk() for Alpha using a simple kernel stack scanning walker. Start from regs+1 for current tasks to skip pt_regs and use pcb.ksp for blocked tasks. Filter candidates with __kernel_text_address() and stop at stack bounds via kstack_end().
Enable CONFIG_STACKTRACE_SUPPORT and CONFIG_ARCH_STACKWALK so generic stacktrace users (dump_stack(), /proc/*/stack, SysRq backtraces, etc.) work on Alpha.
This provides functional in-kernel stack traces without requiring frame pointer unwinding.
--- arch/alpha/Kconfig | 4 +++ arch/alpha/kernel/Makefile | 3 +- arch/alpha/kernel/stacktrace.c | 61 +++++++++++++++++++++++++++++++++ arch/alpha/kernel/vmlinux.lds.S | 2 ++ 4 files changed, 69 insertions(+), 1 deletion(-) create mode 100644 arch/alpha/kernel/stacktrace.c
arch/alpha/Kconfig +4 -0
@@ -39,6 +39,7 @@ config ALPHA select MODULES_USE_ELF_RELA select ODD_RT_SIGACTION select OLD_SIGSUSPEND + select ARCH_STACKWALK select CPU_NO_EFFICIENT_FFS if !ALPHA_EV67 select MMU_GATHER_NO_RANGE select MMU_GATHER_RCU_TABLE_FREE
@@ -80,6 +81,9 @@ config PGTABLE_LEVELS config AUDIT_ARCH bool +config STACKTRACE_SUPPORT + def_bool y + menu "System setup" choice
arch/alpha/kernel/Makefile +2 -1
@@ -9,7 +9,8 @@ ccflags-y := -Wno-sign-compare obj-y := head.o entry.o traps.o process.o osf_sys.o irq.o \ irq_alpha.o signal.o setup.o ptrace.o time.o \ - systbls.o err_common.o io.o bugs.o termios.o + systbls.o err_common.o io.o bugs.o termios.o \ + stacktrace.o obj-$(CONFIG_VGA_HOSE) += console.o obj-$(CONFIG_SMP) += smp.o
arch/alpha/kernel/stacktrace.c new file +61 -0
61 lines not on this page · raw message
arch/alpha/kernel/vmlinux.lds.S +2 -0
@@ -28,6 +28,8 @@ SECTIONS TEXT_TEXT SCHED_TEXT LOCK_TEXT + IRQENTRY_TEXT + SOFTIRQENTRY_TEXT *(.fixup) *(.gnu.warning) } :text
Signature · 1 line
2.53.0
Magnus Lindholm
maintainerPATCH v4 3/7 alpha: make irqflags helpers operate on IPL state
In reply to Magnus LindholmAlpha interrupt masking is controlled by the PAL IPL value, not by the full processor status word. Make arch_local_save_flags() return the current IPL directly, and make arch_local_irq_restore() and arch_irqs_disabled_flags() treat their argument as IPL state.
Mask the low IPL bits in the restore and test helpers so callers which still pass a saved PS value continue to behave as expected.
This prepares the irqflags helpers for lockdep IRQ-state tracking, where the saved flags value is used to determine whether hard IRQs are enabled or disabled.
--- arch/alpha/include/asm/irqflags.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
arch/alpha/include/asm/irqflags.h +3 -3
@@ -26,7 +26,7 @@ extern int __min_ipl;static inline unsigned long arch_local_save_flags (void ) { -return rdps (); +return getipl (); }static inline void arch_local_irq_disable (void )
@@ -51,13 +51,13 @@ static inline void arch_local_irq_enable(void)static inline void arch_local_irq_restore (unsigned long flags) {barrier (); -setipl (flags); +setipl (flags &7 );barrier (); }static inline bool arch_irqs_disabled_flags (unsigned long flags) { -return flags ==IPL_MAX ; +return (flags &7 ) ==IPL_MAX ; }static inline bool arch_irqs_disabled (void )
Signature · 1 line
2.53.0
Magnus Lindholm
maintainerPATCH v4 4/7 alpha: provide ftrace return address support for lockdep
In reply to Magnus LindholmLockdep uses ftrace_return_address() to report useful call sites for lock acquisition and IRQ-state tracking diagnostics. Provide the Alpha architecture hook using the compiler return-address builtin when frame pointers are available.
Return zero when frame pointers are disabled, matching the existing fallback behavior of architectures that cannot provide a reliable return address.
This is a preparatory change for enabling lockdep support on Alpha.
--- arch/alpha/include/asm/ftrace.h | 30 +++++++++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-)
arch/alpha/include/asm/ftrace.h +29 -1
@@ -1 +1,29 @@ -/* empty */ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_ALPHA_FTRACE_H +#define _ASM_ALPHA_FTRACE_H + +#ifdef CONFIG_FRAME_POINTER + +static void *alpha_ftrace_return_address0 (void ) + noinline notrace; +static void *alpha_ftrace_return_address0 (void ) +{ +return __builtin_return_address (0 ); +} + +#define ftrace_return_address0 alpha_ftrace_return_address0() + +/* +* __builtin_return_address() requires a constant integer argument. +* Keep this as a macro so the value is seen at the callsite. +*/ +#define ftrace_return_address (n) __builtin_return_address(n) + +#else /* !CONFIG_FRAME_POINTER */ + +#define ftrace_return_address0 0UL +#define ftrace_return_address (n) ((void)(n), 0UL) + +#endif /* CONFIG_FRAME_POINTER */ + +#endif /* _ASM_ALPHA_FTRACE_H */
Signature · 1 line
2.53.0
Magnus Lindholm
maintainerPATCH v4 5/7 alpha: use raw spinlocks for low-level platform locks
In reply to Magnus LindholmSome Alpha platform locks are used as low-level hardware serialization locks in interrupt-controller and chipset access paths. These paths can run while IRQ state is being changed or while lockdep is tracking that state, so regular spinlock instrumentation is not appropriate once lockdep is enabled.
Convert the affected Tsunami and Rawhide platform locks to raw_spinlock_t. This keeps the locks as simple hardware serialization locks and avoids lockdep recursion or IRQ-state mismatches when CONFIG_PROVE_LOCKING is enabled.
This is a preparatory change for enabling lockdep hardirq state tracking on Alpha.
--- arch/alpha/kernel/irq_i8259.c | 19 +++++++++++------ arch/alpha/kernel/sys_dp264.c | 38 ++++++++++++++++++++++----------- arch/alpha/kernel/sys_rawhide.c | 17 +++++++++------ 3 files changed, 47 insertions(+), 27 deletions(-)
arch/alpha/kernel/irq_i8259.c +12 -7
@@ -22,7 +22,7 @@/* Note mask bit is true for DISABLED irqs. */ static unsigned int cached_irq_mask =0xffff ; -static DEFINE_SPINLOCK (i8259_irq_lock); +static DEFINE_RAW_SPINLOCK (i8259_irq_lock);static inline void i8259_update_irq_hw (unsigned int irq,unsigned long mask)
@@ -36,9 +36,11 @@ i8259_update_irq_hw(unsigned int irq, unsigned long mask)inline void i8259a_enable_irq (struct irq_data *d) { -spin_lock (&i8259_irq_lock); +unsigned long flags; + +raw_spin_lock_irqsave (&i8259_irq_lock, flags);i8259_update_irq_hw (d->irq, cached_irq_mask &= ~(1 << d->irq)); -spin_unlock (&i8259_irq_lock); +raw_spin_unlock_irqrestore (&i8259_irq_lock, flags); } static inline void
@@ -50,17 +52,20 @@ __i8259a_disable_irq(unsigned int irq)void i8259a_disable_irq (struct irq_data *d) { -spin_lock (&i8259_irq_lock); +unsigned long flags; + +raw_spin_lock_irqsave (&i8259_irq_lock, flags);__i8259a_disable_irq (d->irq); -spin_unlock (&i8259_irq_lock); +raw_spin_unlock_irqrestore (&i8259_irq_lock, flags); }void i8259a_mask_and_ack_irq (struct irq_data *d) {unsigned int irq = d->irq; +unsigned long flags; -spin_lock (&i8259_irq_lock); +raw_spin_lock_irqsave (&i8259_irq_lock, flags);__i8259a_disable_irq (irq);/* Ack the interrupt making it the lowest priority. */
@@ -69,7 +74,7 @@ i8259a_mask_and_ack_irq(struct irq_data *d) irq =2 ; }outb (0xE0 | irq,0x20 );/* ack the master */ -spin_unlock (&i8259_irq_lock); +raw_spin_unlock_irqrestore (&i8259_irq_lock, flags); }struct irq_chip i8259a_irq_type = {
arch/alpha/kernel/sys_dp264.c +25 -13
@@ -41,7 +41,7 @@ static unsigned long cached_irq_mask;/* dp264 boards handle at max four CPUs */ static unsigned long cpu_irq_affinity[4 ] = {0UL ,0UL ,0UL ,0UL }; -DEFINE_SPINLOCK (dp264_irq_lock); +static DEFINE_RAW_SPINLOCK (dp264_irq_lock);static void tsunami_update_irq_hw (unsigned long mask)
@@ -99,37 +99,45 @@ tsunami_update_irq_hw(unsigned long mask)static void dp264_enable_irq (struct irq_data *d) { -spin_lock (&dp264_irq_lock); +unsigned long flags; + +raw_spin_lock_irqsave (&dp264_irq_lock, flags); cached_irq_mask |=1UL << d->irq;tsunami_update_irq_hw (cached_irq_mask); -spin_unlock (&dp264_irq_lock); +raw_spin_unlock_irqrestore (&dp264_irq_lock, flags); }static void dp264_disable_irq (struct irq_data *d) { -spin_lock (&dp264_irq_lock); +unsigned long flags; + +raw_spin_lock_irqsave (&dp264_irq_lock, flags); cached_irq_mask &= ~(1UL << d->irq);tsunami_update_irq_hw (cached_irq_mask); -spin_unlock (&dp264_irq_lock); +raw_spin_unlock_irqrestore (&dp264_irq_lock, flags); }static void clipper_enable_irq (struct irq_data *d) { -spin_lock (&dp264_irq_lock); +unsigned long flags; + +raw_spin_lock_irqsave (&dp264_irq_lock, flags); cached_irq_mask |=1UL << (d->irq -16 );tsunami_update_irq_hw (cached_irq_mask); -spin_unlock (&dp264_irq_lock); +raw_spin_unlock_irqrestore (&dp264_irq_lock, flags); }static void clipper_disable_irq (struct irq_data *d) { -spin_lock (&dp264_irq_lock); +unsigned long flags; + +raw_spin_lock_irqsave (&dp264_irq_lock, flags); cached_irq_mask &= ~(1UL << (d->irq -16 ));tsunami_update_irq_hw (cached_irq_mask); -spin_unlock (&dp264_irq_lock); +raw_spin_unlock_irqrestore (&dp264_irq_lock, flags); } static void
@@ -151,10 +159,12 @@ static int dp264_set_affinity(struct irq_data *d, const struct cpumask *affinity, bool force) { - spin_lock(&dp264_irq_lock); + unsigned long flags; + +raw_spin_lock_irqsave (&dp264_irq_lock, flags);cpu_set_irq_affinity (d->irq, *affinity);tsunami_update_irq_hw (cached_irq_mask); -spin_unlock (&dp264_irq_lock); +raw_spin_unlock_irqrestore (&dp264_irq_lock, flags);return 0 ; }
@@ -163,10 +173,12 @@ static int clipper_set_affinity(struct irq_data *d, const struct cpumask *affinity, bool force) { - spin_lock(&dp264_irq_lock); + unsigned long flags; + +raw_spin_lock_irqsave (&dp264_irq_lock, flags);cpu_set_irq_affinity (d->irq -16 , *affinity);tsunami_update_irq_hw (cached_irq_mask); -spin_unlock (&dp264_irq_lock); +raw_spin_unlock_irqrestore (&dp264_irq_lock, flags);return 0 ; }
arch/alpha/kernel/sys_rawhide.c +10 -7
@@ -41,7 +41,7 @@ static unsigned int hose_irq_masks[4] = { 0xff0000, 0xfe0000, 0xff0000, 0xff0000 };static unsigned int cached_irq_masks[4 ]; -DEFINE_SPINLOCK (rawhide_irq_lock); +DEFINE_RAW_SPINLOCK (rawhide_irq_lock);static inline void rawhide_update_irq_hw (int hose,int mask)
@@ -59,6 +59,7 @@ rawhide_enable_irq(struct irq_data *d) {unsigned int mask, hose;unsigned int irq = d->irq; +unsigned long flags; irq -=16 ; hose = irq /24 ;
@@ -68,11 +69,11 @@ rawhide_enable_irq(struct irq_data *d) irq -= hose *24 ; mask =1 << irq; -spin_lock (&rawhide_irq_lock); +raw_spin_lock_irqsave (&rawhide_irq_lock, flags); mask |= cached_irq_masks[hose]; cached_irq_masks[hose] = mask;rawhide_update_irq_hw (hose, mask); -spin_unlock (&rawhide_irq_lock); +raw_spin_unlock_irqrestore (&rawhide_irq_lock, flags); } static void
@@ -80,6 +81,7 @@ rawhide_disable_irq(struct irq_data *d) {unsigned int mask, hose;unsigned int irq = d->irq; +unsigned long flags; irq -=16 ; hose = irq /24 ;
@@ -89,11 +91,11 @@ rawhide_disable_irq(struct irq_data *d) irq -= hose *24 ; mask = ~(1 << irq) | hose_irq_masks[hose]; -spin_lock (&rawhide_irq_lock); +raw_spin_lock_irqsave (&rawhide_irq_lock, flags); mask &= cached_irq_masks[hose]; cached_irq_masks[hose] = mask;rawhide_update_irq_hw (hose, mask); -spin_unlock (&rawhide_irq_lock); +raw_spin_unlock_irqrestore (&rawhide_irq_lock, flags); } static void
@@ -101,6 +103,7 @@ rawhide_mask_and_ack_irq(struct irq_data *d) {unsigned int mask, mask1, hose;unsigned int irq = d->irq; +unsigned long flags; irq -=16 ; hose = irq /24 ;
@@ -111,7 +114,7 @@ rawhide_mask_and_ack_irq(struct irq_data *d) mask1 =1 << irq; mask = ~mask1 | hose_irq_masks[hose]; -spin_lock (&rawhide_irq_lock); +raw_spin_lock_irqsave (&rawhide_irq_lock, flags); mask &= cached_irq_masks[hose]; cached_irq_masks[hose] = mask;
@@ -120,7 +123,7 @@ rawhide_mask_and_ack_irq(struct irq_data *d)/* Clear the interrupt. */ *(vuip )MCPCIA_INT_REQ (MCPCIA_HOSE2MID (hose)) = mask1; -spin_unlock (&rawhide_irq_lock); +raw_spin_unlock_irqrestore (&rawhide_irq_lock, flags); }static struct irq_chip rawhide_irq_type = {
Signature · 1 line
2.53.0
Magnus Lindholm
maintainerPATCH v4 6/7 alpha: enable lockdep hardirq state tracking
In reply to Magnus LindholmAlpha masks interrupts through the PAL IPL state, so lockdep cannot infer hardirq state transitions from generic code alone. Add explicit hardirq on/off annotations to the low-level entry and return paths so lockdep's IRQ state follows the hardware IPL state.
Annotate the PAL IPL transitions and the shared return-to-user/kernel paths where interrupts become enabled or disabled. With the preceding irqflags, raw-lock, sysfs, and ftrace return-address preparations in place, select LOCKDEP_SUPPORT and TRACE_IRQFLAGS_SUPPORT for Alpha.
This keeps CONFIG_PROVE_LOCKING usable on Alpha instead of disabling debug_locks due to IRQ-state mismatches.
--- .../features/locking/lockdep/arch-support.txt | 2 +- arch/alpha/Kconfig | 5 ++ arch/alpha/kernel/entry.S | 17 ++++- arch/alpha/kernel/irq_alpha.c | 74 ++++++++++++++----- arch/alpha/kernel/proto.h | 4 + arch/alpha/kernel/signal.c | 9 +++ 6 files changed, 91 insertions(+), 20 deletions(-)
Documentation/features/locking/lockdep/arch-support.txt +1 -1
@@ -6,7 +6,7 @@ ----------------------- | arch |status| ----------------------- - | alpha: | TODO | + | alpha: | ok | | arc: | ok | | arm: | ok | | arm64: | ok |
arch/alpha/Kconfig +5 -0
@@ -45,6 +45,8 @@ config ALPHA select MMU_GATHER_RCU_TABLE_FREE select SPARSEMEM_EXTREME if SPARSEMEM select ZONE_DMA + select TRACE_IRQFLAGS_SUPPORT + select ARCH_WANT_FRAME_POINTERS help The Alpha is a 64-bit general-purpose processor designed and marketed by the Digital Equipment Corporation of blessed memory,
@@ -84,6 +86,9 @@ config AUDIT_ARCH config STACKTRACE_SUPPORT def_bool y +config LOCKDEP_SUPPORT + def_bool y + menu "System setup" choice
arch/alpha/kernel/entry.S +16 -1
@@ -93,6 +93,19 @@ 4: .endm +.macro LOCKDEP_HARDIRQS_ON_RESTORE +#ifdef CONFIG_PROVE_LOCKING + /* a0 = saved PS */ + ldq $16, SP_OFF($sp) + + /* a1 = callsite IP for lockdep */ + lda $17, 1f + + jsr $26, lockdep_on_restore + ldgp $gp, 0($26) +1: +#endif +.endm /* * This defines the normal kernel pt-regs layout.
@@ -427,6 +440,7 @@ CFI_START_OSF_FRAME entUna .cfi_restore $28 .cfi_restore $29 .cfi_adjust_cfa_offset -256 + LOCKDEP_HARDIRQS_ON_RESTORE call_pal PAL_rti .align 4
@@ -577,6 +591,7 @@ restore_all: bne $3, restore_fpu restore_other: .cfi_remember_state + LOCKDEP_HARDIRQS_ON_RESTORE RESTORE_ALL call_pal PAL_rti
@@ -622,7 +637,7 @@ $work_resched: * or got through work_notifysig already. Either case means no syscall * restarts for us, so let $18 and $19 burn. */ - jsr $26, schedule + jsr $26, alpha_schedule_user_work mov 0, $18 br ret_to_user
arch/alpha/kernel/irq_alpha.c +56 -18
103 lines not on this page · raw message
arch/alpha/kernel/proto.h +4 -0
@@ -173,6 +173,7 @@ extern void do_sigreturn(struct sigcontext __user *);struct rt_sigframe ;extern void do_rt_sigreturn (struct rt_sigframe __user *);extern void do_work_pending (struct pt_regs *,unsigned long ,unsigned long ,unsigned long ); +extern void alpha_schedule_user_work (void );/* traps.c */ extern void dik_show_regs (struct pt_regs *regs,unsigned long *r9_15);
@@ -185,6 +186,9 @@ struct allregs;extern void do_entUna (void *,unsigned long ,unsigned long ,struct allregs *);extern void do_entUnaUser (void __user *,unsigned long ,unsigned long ,struct pt_regs *); +/* irq_alpha.c */ +extern void notrace lockdep_on_restore(unsigned long ps, unsigned long ip); +/* sys_titan.c */ extern void titan_dispatch_irqs (u64 );
arch/alpha/kernel/signal.c +9 -0
@@ -41,6 +41,14 @@ asmlinkage void ret_from_sys_call(void);* The OSF/1 sigprocmask calling sequence is different from the * C sigprocmask() sequence.. */ + +asmlinkage void alpha_schedule_user_work(void) +{ +local_irq_enable (); +schedule (); +local_irq_disable (); +} + SYSCALL_DEFINE2(osf_sigprocmask, int, how, unsigned long, newmask) {sigset_t oldmask;
@@ -525,6 +533,7 @@ do_work_pending(struct pt_regs *regs, unsigned long thread_flags, { do { if (thread_flags & _TIF_NEED_RESCHED) { + local_irq_enable(); schedule(); } else { local_irq_enable();
Signature · 1 line
2.53.0
Magnus Lindholm
maintainerPATCH v4 7/7 alpha: enable GENERIC_ENTRY
In reply to Magnus LindholmWire Alpha into the generic entry code for syscall entry/exit and return-to-user handling, while keeping the low-level PALcode return paths Alpha-specific.
Move most of the syscall entry/exit logic out of entSys and into C helpers built around the generic entry API. Syscall entry now uses syscall_enter_from_user_mode(), records Alpha-local syscall metadata in thread_info, handles the ptrace/seccomp skip decision, and selects the syscall table target in C. The final target call remains in entry.S so Alpha can preserve its existing syscall ABI and assembly syscall-table wrappers.
On return from syscalls, finish Alpha's r0/r19 result encoding and skipped-syscall restart handling in C before calling syscall_exit_to_user_mode(). Non-syscall returns to user mode use a separate alpha_exit_to_user_mode() helper, which disables interrupts, runs irqentry_exit_to_user_mode_prepare(), and then enters the common exit_to_user_mode() path.
Keep the remaining PALcode restore handling in assembly. In particular, kernel-mode returns still need Alpha-specific lockdep IRQ-state annotation based on the saved processor status, while user-mode returns are handed to the generic exit-to-user code.
Add the generic-entry support bits needed by common code, including thread_info.syscall_work, syscall trace support, ptrace sysemu request numbers, and arch_syscall_is_vdso_sigreturn().
This has been tested by booting Alpha with GENERIC_ENTRY enabled, checking lockdep IRQ-state accounting, running fork/clone-heavy package builds, and running the seccomp as well as strace test suites.
--- arch/alpha/Kconfig | 2 + arch/alpha/include/asm/entry-common.h | 14 ++ arch/alpha/include/asm/ptrace.h | 14 +- arch/alpha/include/asm/stacktrace.h | 20 ++ arch/alpha/include/asm/syscall.h | 11 +- arch/alpha/include/asm/thread_info.h | 30 +-- arch/alpha/kernel/asm-offsets.c | 5 + arch/alpha/kernel/entry.S | 322 +++++++------------------- arch/alpha/kernel/irq_alpha.c | 14 +- arch/alpha/kernel/proto.h | 9 +- arch/alpha/kernel/ptrace.c | 130 +++++------ arch/alpha/kernel/signal.c | 158 ++++++++++--- 12 files changed, 364 insertions(+), 365 deletions(-) create mode 100644 arch/alpha/include/asm/entry-common.h create mode 100644 arch/alpha/include/asm/stacktrace.h
arch/alpha/Kconfig +2 -0
@@ -2,6 +2,8 @@ config ALPHA bool default y + select GENERIC_ENTRY + select HAVE_SYSCALL_TRACEPOINTS select ARCH_32BIT_USTAT_F_TINODE select ARCH_HAS_CURRENT_STACK_POINTER select ARCH_HAS_DMA_OPS if PCI
arch/alpha/include/asm/entry-common.h new file +14 -0
@@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef ARCH_ALPHA_ENTRY_COMMON_H +#define ARCH_ALPHA_ENTRY_COMMON_H + +#include <asm/stacktrace.h> /* For on_thread_stack() */ +#include <asm/syscall.h> + +#define arch_exit_to_user_mode_work arch_exit_to_user_mode_work + +static __always_inline void arch_exit_to_user_mode_work(struct pt_regs *regs, +unsigned long ti_work) +{ +} +#endif
arch/alpha/include/asm/ptrace.h +12 -2
@@ -3,7 +3,7 @@#define _ASMAXP_PTRACE_H#include <uapi/asm/ptrace.h> - +#include <asm/irqflags.h> #define arch_has_single_step () (1)#define user_mode (regs) (((regs)->ps & 8) != 0)
@@ -17,7 +17,9 @@#define current_pt_regs () \ ((struct pt_regs *) ((char *)current_thread_info() + 2*PAGE_SIZE) - 1) -#define force_successful_syscall_return () (current_pt_regs()->r0 = 0) +#define force_successful_syscall_return () \ + (current_thread_info()->syscall_meta \ + |= ALPHA_SYSCALL_META_FORCE_SUCCESS)static inline unsigned long regs_return_value (struct pt_regs *regs) {
@@ -31,4 +33,12 @@ static inline unsigned long user_stack_pointer(struct pt_regs *regs)return regs->usp; } +static __always_inline bool regs_irqs_disabled(struct pt_regs *regs) +{ +return arch_irqs_disabled_flags (regs->ps); +} + +/* Syscall emulation defines */ +#define PTRACE_SYSEMU 0x1d +#define PTRACE_SYSEMU_SINGLESTEP 0x1e#endif
arch/alpha/include/asm/stacktrace.h new file +20 -0
@@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_ALPHA_STACKTRACE_H +#define _ASM_ALPHA_STACKTRACE_H + +#include <linux/compiler_attributes.h> +#include <linux/types.h> + +#include <asm/current.h> +#include <asm/processor.h> +#include <asm/thread_info.h> + +static __always_inline bool on_thread_stack(void) +{ +unsigned long base = (unsigned long )current->stack; +unsigned long sp = (unsigned long )current_stack_pointer; + +return !((base ^ sp) & ~(THREAD_SIZE -1 )); +} + +#endif /* _ASM_ALPHA_STACKTRACE_H */
arch/alpha/include/asm/syscall.h +10 -1
@@ -8,6 +8,8 @@#include <linux/types.h> #include <asm/ptrace.h> +extern void *sys_call_table[]; +static inline int syscall_get_arch (struct task_struct *task) {return AUDIT_ARCH_ALPHA ;
@@ -104,10 +106,17 @@ static inline void syscall_set_return_value(struct task_struct *task, }/* Restore the original syscall nr after seccomp/ptrace modified regs->r1. */ +static inline void syscall_rollback (struct task_struct *task,struct pt_regs *regs) { - regs->r1 = regs->r2; +unsigned long nr =task_thread_info (task)->syscall_saved_nr; + + regs->r1 = nr; } +static inline bool arch_syscall_is_vdso_sigreturn (struct pt_regs *regs) +{ +return false; +}#endif /* _ASM_ALPHA_SYSCALL_H */
arch/alpha/include/asm/thread_info.h +12 -18
@@ -12,16 +12,21 @@#endif #ifndef __ASSEMBLER__ + struct thread_info { struct pcb_struct pcb; /* palcode state */ struct task_struct *task; /* main task structure */ - unsigned int flags; /* low level flags */ + unsigned long flags; /* low level flags */ + unsigned long syscall_work; /* SYSCALL_WORK_* flags */ unsigned int ieee_state; /* see fpu.h */ unsigned cpu; /* current CPU */ - int preempt_count; /* 0 => preemptable, <0 => BUG */ + int preempt_count; /* 0 => preemptable, <0 => BUG */ unsigned int status; /* thread-synchronous flags */ + unsigned long syscall_saved_r19; + unsigned long syscall_meta; + unsigned long syscall_saved_nr; int bpt_nsaved; unsigned long bpt_addr[2]; /* breakpoint handling */
@@ -50,6 +55,9 @@ register unsigned long *current_stack_pointer __asm__ ("$30");#define THREAD_SIZE_ORDER 1#define THREAD_SIZE (2*PAGE_SIZE) +#define ALPHA_SYSCALL_META_SKIP 0x2 +#define ALPHA_SYSCALL_META_FORCE_SUCCESS 0x4 +/* * Thread information flags: * - these are process state flags and used from assembly
@@ -68,6 +76,7 @@ register unsigned long *current_stack_pointer __asm__ ("$30");#define TIF_SECCOMP 6/* seccomp syscall filtering active */ #define TIF_SYSCALL_TRACEPOINT 7/* syscall tracepoint instrumentation */ #define TIF_DIE_IF_KERNEL 9/* dik recursion lock */ +#define TIF_UPROBE 10/* uprobe breakpoint or singlestep */ #define TIF_MEMDIE 13/* is terminating due to OOM killer */ #define TIF_POLLING_NRFLAG 14/* idle is polling for TIF_NEED_RESCHED */
@@ -80,22 +89,7 @@ register unsigned long *current_stack_pointer __asm__ ("$30");#define _TIF_SECCOMP (1<<TIF_SECCOMP)#define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG)#define _TIF_SYSCALL_TRACEPOINT (1<<TIF_SYSCALL_TRACEPOINT) - -/* -* Work to do on syscall entry (in entry.S). -* If you want this to exactly mirror what entry.S checks, keep it aligned -* with the mask used before branching to syscall_trace_enter(). -*/ -#ifdef CONFIG_AUDITSYSCALL -# define _TIF_SYSCALL_WORK (_TIF_SYSCALL_TRACE | _TIF_SYSCALL_AUDIT | _TIF_SECCOMP \ - | _TIF_SYSCALL_TRACEPOINT) -#else -# define _TIF_SYSCALL_WORK (_TIF_SYSCALL_TRACE | _TIF_SECCOMP | _TIF_SYSCALL_TRACEPOINT) -#endif - -/* Work to do on interrupt/exception return. */ -#define _TIF_WORK_MASK (_TIF_SIGPENDING | _TIF_NEED_RESCHED | \ - _TIF_NOTIFY_RESUME | _TIF_NOTIFY_SIGNAL) +#define _TIF_UPROBE (1 << TIF_UPROBE)#define TS_UAC_NOPRINT 0x0001/* ! Preserve the following three */ #define TS_UAC_NOFIX 0x0002/* ! flags as they match */
arch/alpha/kernel/asm-offsets.c +5 -0
@@ -22,6 +22,7 @@ static void __used foo(void)DEFINE (SP_OFF , offsetof(struct pt_regs , ps));DEFINE (SIZEOF_PT_REGS ,sizeof (struct pt_regs )); +DEFINE (TI_SYSCALL_META , offsetof(struct thread_info , syscall_meta));BLANK ();DEFINE (SWITCH_STACK_SIZE ,sizeof (struct switch_stack ));
@@ -30,4 +31,8 @@ static void __used foo(void)DEFINE (HAE_CACHE , offsetof(struct alpha_machine_vector , hae_cache));DEFINE (HAE_REG , offsetof(struct alpha_machine_vector , hae_register));DEFINE (PT_REGS_USP , offsetof(struct pt_regs , usp)); + +DEFINE (TI_FLAGS , offsetof(struct thread_info , flags)); +DEFINE (TI_SYSCALL_WORK , offsetof(struct thread_info , syscall_work)); +DEFINE (TI_STATUS , offsetof(struct thread_info , status)); }
arch/alpha/kernel/entry.S +87 -235
451 lines not on this page · raw message
arch/alpha/kernel/irq_alpha.c +9 -5
@@ -105,20 +105,24 @@ void notrace lockdep_on_restore(unsigned long ps, unsigned long ip) {#ifdef CONFIG_PROVE_LOCKING -/* Restoring IPL==7 means interrupts remain disabled. */ +/* +* If PAL_rti will restore IPL == 7, IRQs remain disabled. +* There is no hardirqs-on transition to annotate. +*/ if ((ps &7 ) ==7 )return ;/* -* If hardware IRQs are already enabled here, then emitting a -* hardirqs-on transition is redundant. +* This helper is meant to run before PAL_rti, after entry.S has +* forced IPL to 7. If IRQs are already enabled, do not emit a +* fake transition. */ if (!irqs_disabled ())return ;/* -* Only emit the transition if lockdep currently believes -* hardirqs are off. +* Only emit an ON transition if lockdep currently tracks hardirqs +* as off. */ if (lockdep_hardirqs_enabled ())return ;
arch/alpha/kernel/proto.h +6 -3
@@ -2,6 +2,7 @@#include <linux/interrupt.h> #include <linux/screen_info.h> #include <linux/io.h> +#include <asm/ptrace.h> /* Prototypes of functions used across modules here in this directory. */
@@ -164,16 +165,18 @@ extern void pcibios_claim_one_bus(struct pci_bus *);/* ptrace.c */ extern int ptrace_set_bpt (struct task_struct *child);extern int ptrace_cancel_bpt (struct task_struct *child); -extern void syscall_trace_leave (void ); -extern unsigned long syscall_trace_enter (void );/* signal.c */ struct sigcontext ;extern void do_sigreturn (struct sigcontext __user *);struct rt_sigframe ;extern void do_rt_sigreturn (struct rt_sigframe __user *); -extern void do_work_pending (struct pt_regs *,unsigned long ,unsigned long ,unsigned long );extern void alpha_schedule_user_work (void ); +extern void do_signal (struct pt_regs *regs,unsigned long r0,unsigned long r19); +extern void alpha_syscall_exit_to_user_mode (struct pt_regs *regs); +extern void alpha_exit_to_user_mode (struct pt_regs *regs); +extern void alpha_finish_syscall_to_user_mode (struct pt_regs *regs,long ret); +extern unsigned long alpha_syscall_enter_select (struct pt_regs *regs,long syscall);/* traps.c */ extern void dik_show_regs (struct pt_regs *regs,unsigned long *r9_15);
arch/alpha/kernel/ptrace.c +61 -69
196 lines not on this page · raw message
arch/alpha/kernel/signal.c +126 -32
202 lines not on this page · raw message
Signature · 1 line
2.53.0