From nobody Mon Jun 8 10:56:38 2026 Received: from mail-lf1-f54.google.com (mail-lf1-f54.google.com [209.85.167.54]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E19453C1985 for ; Fri, 29 May 2026 14:23:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.54 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064628; cv=none; b=nAPHy6PBhccWS0uJA96/oHFvxK2Hl0uiyr2Cen/vyVMQXwEyvRr5mOEgbuPWqpcXKaReBMjXrt/+MUk9+lNNbI4IDOzuZ/+ahJU18YERkW46shWQSOhsXnbJfhvRWYl7Ma+7NzNsvogAEjSvEfTT89NQz6DcSjYXPt7xPqq0yVk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064628; c=relaxed/simple; bh=6pLEKfmltNBR/DJwcFKXTHaS/L9LNQsd8GiZjWVlYTY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=gl+FJuBElGIkPHe/5A1At0CYy1kt1Jf8hWl+8TiItlYkCLYaUHiYf5sUdjQzRcVJIt8YmAla4Ao0Du26kxuGpGZ0CPBLlDx68FpJhl20II+gG8/2JBl2uWk+YCHrfAEjZmnrEQKJrJGkX/lHt7kb1zI3Ir2EiqIPJTf+QSOeI3Y= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=r8TC0aVO; arc=none smtp.client-ip=209.85.167.54 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="r8TC0aVO" Received: by mail-lf1-f54.google.com with SMTP id 2adb3069b0e04-5aa21fa024cso12485357e87.2 for ; Fri, 29 May 2026 07:23:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1780064624; x=1780669424; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=wU8/o+8ByJs4UG31DLc0+Y6CQtUPzghKqNvi0QyXzAY=; b=r8TC0aVO0t6HLWRgL9AtzRkvlYEOZTiDEUHIw+daxjBNVaJ9HILo0pMeqqoGU985X9 giGkAmr6lNBJ1CyZzaJCsHkHkMOYtX7ukEjrWJBTE5CtVJrS6vw+LGoOTsJUrfZMDNsK AVRB8g6zgblFqbd/AZNF2vqOt5pupo5VMgLbyrDS/omSEuqNCWuDOmvkJWKXmrEtjH+w Lfw7HLFwk76zqCbrRjkG5U2kcqyCLdUWJ5P9+bGfNRwCB7C/eXeKNpqMrQHiXUTPd96U p6rgUK7nuthWYPNV7U11R5niQd7DxwT8/8rkU8RpKLDi0W2PrGtgEPMXq63DfNXASTRD 2JpA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1780064624; x=1780669424; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=wU8/o+8ByJs4UG31DLc0+Y6CQtUPzghKqNvi0QyXzAY=; b=KWHQbsa9O9C7bhedNeOPyCIcsRhZPcJu2UQb8mR+YzHdVWd8ha1XFtpGpHPd3/NxcS TvK65GkBCDd75QHDWb97Jb3k2M71tDwqcAj8tkf8BX4wnl5n/dod4NFw8GJlvfkRLwkv TqL5kb5OFWo8fjcxXq5k4Pwx2isVMZUFTHZLlE49gp6J+2vOkfe9XDjzY6SB3O2wlsC8 8gEOXytQmMDubHJinzkKd/cXRrVv9qZBDvkXYv9cOS/PP8H18uyWzGYe8hJnC/D0lj7x lKMt5H/jh82msfXhqQFuoMA5vDrkz7+x0okE+n98pm07AaBFxO7uwT2MLTTl+gGHesU/ dYCQ== X-Forwarded-Encrypted: i=1; AFNElJ8xsRMg6IFMiqrXA0rafkabq+JPQaHI+Urwh5PfWrLaKSaAO+VfTM8g56knW+DvMyyEB4QEvcIamOm71Gk=@vger.kernel.org X-Gm-Message-State: AOJu0Yw9YoU5l6AffUeSWzu1d6dJDWcGIHRFYm2CP9M0fnkYXe84tkhI ymDf1q6c2YV8RCnkgRLTZr3OdSNOQ5Ag6ltRxh1P1NMm51IRTwiTBNYD X-Gm-Gg: Acq92OGdsRlHdBS1playd+UkuDiWnxDYdwtlX27wyus0axBD4RXZZ2rRvFStBouPG4C FAZjXQUZn90LeW7WpX0HV2lVd1L3omt6PIqs5dkE6PwXycrD5wzI8wO6fZg+27PLNVVfZPpFjWJ ST7+s0WOnHtuTvF/+r0tyFgehFW5ipSjCGjVY1uhaDQuVAgsaI2EA4wFisvUrFQdRyuxHFOY/Ib QQ4wSKvFVGx2XQrQ6je8YISZpwU8AOzkwrg2cKTaigLDAqHkkkyVTlISFBimLfnj7emHtxo3NZD VQod/FCLAWf/Diees1vx+yFtvTDPS6WyqMArZ+DF9SxgXlzMadpwYTv1YbiPvcLREH08ov+klAD 0SoGBLjqQ6Z70f+E/Ksvq2r1AVTR/NhFtUka8VZfRLhGQvVTbqAYwQnSBQDROMuciVzQUePHDPu BUJ+8jK5R8mB7tP88Geal7OOIcucy45Cxy5NbiSH2P/+sJEarA9FAcoc5IkYPCN+Tge95iDc/WM +ZHzLln6ZROsZP+NC6ggLMrYLjfdvwrHmGj8Hpfb79m6A== X-Received: by 2002:a05:6512:2247:b0:5a8:6d98:df26 with SMTP id 2adb3069b0e04-5aa607a85f2mr19715e87.13.1780064623929; Fri, 29 May 2026 07:23:43 -0700 (PDT) Received: from buildhost.darklands.se (h-94-254-104-176.A469.priv.bahnhof.se. [94.254.104.176]) by smtp.gmail.com with ESMTPSA id 2adb3069b0e04-5aa5b0687e2sm310433e87.6.2026.05.29.07.23.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 May 2026 07:23:43 -0700 (PDT) From: Magnus Lindholm To: richard.henderson@linaro.org, mattst88@gmail.com, linux-kernel@vger.kernel.org, linux-alpha@vger.kernel.org Cc: glaubitz@physik.fu-berlin.de, mcree@orcon.net.nz, ink@unseen.parts, macro@orcam.me.uk, Magnus Lindholm Subject: [PATCH v2 1/8] alpha: enable regset-based ptrace and core dumps Date: Fri, 29 May 2026 16:21:57 +0200 Message-ID: <20260529142322.1362438-2-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260529142322.1362438-1-linmag7@gmail.com> References: <20260529142322.1362438-1-linmag7@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" 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. Signed-off-by: Magnus Lindholm --- .../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(-) diff --git a/Documentation/features/core/tracehook/arch-support.txt b/Docum= entation/features/core/tracehook/arch-support.txt index 4f36fcbfb6d5..654f38413d16 100644 --- a/Documentation/features/core/tracehook/arch-support.txt +++ b/Documentation/features/core/tracehook/arch-support.txt @@ -6,7 +6,7 @@ ----------------------- | arch |status| ----------------------- - | alpha: | TODO | + | alpha: | ok | | arc: | ok | | arm: | ok | | arm64: | ok | diff --git a/arch/alpha/Kconfig b/arch/alpha/Kconfig index 7b7dafe7d9df..f3b882835617 100644 --- a/arch/alpha/Kconfig +++ b/arch/alpha/Kconfig @@ -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 diff --git a/arch/alpha/include/asm/elf.h b/arch/alpha/include/asm/elf.h index 50c82187e60e..b15946621d57 100644 --- a/arch/alpha/include/asm/elf.h +++ b/arch/alpha/include/asm/elf.h @@ -53,6 +53,7 @@ =20 #define EF_ALPHA_32BIT 1 /* All addresses are below 2GB */ =20 +#define CORE_DUMP_USE_REGSET 1 /* * ELF register definitions.. */ diff --git a/arch/alpha/include/asm/ptrace.h b/arch/alpha/include/asm/ptrac= e.h index 3557ce64ed21..8e0a589e2d15 100644 --- a/arch/alpha/include/asm/ptrace.h +++ b/arch/alpha/include/asm/ptrace.h @@ -24,4 +24,11 @@ static inline unsigned long regs_return_value(struct pt_= regs *regs) return regs->r0; } =20 +/* 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 diff --git a/arch/alpha/include/asm/syscall.h b/arch/alpha/include/asm/sysc= all.h index 584b1ab2e325..1e78cbd46faf 100644 --- a/arch/alpha/include/asm/syscall.h +++ b/arch/alpha/include/asm/syscall.h @@ -19,6 +19,13 @@ static inline long syscall_get_return_value(struct task_= struct *task, return regs->r19 ? -(long)regs->r0 : (long)regs->r0; } =20 +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. diff --git a/arch/alpha/include/asm/thread_info.h b/arch/alpha/include/asm/= thread_info.h index 94ef9cfa30f5..1552ecca8520 100644 --- a/arch/alpha/include/asm/thread_info.h +++ b/arch/alpha/include/asm/thread_info.h @@ -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<r1 =3D shadow syscall nr */ stq $1, 16($sp) /* regs->r2 =3D 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 + =20 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) */ diff --git a/arch/alpha/kernel/ptrace.c b/arch/alpha/kernel/ptrace.c index 0687760ea466..69eb337347df 100644 --- a/arch/alpha/kernel/ptrace.c +++ b/arch/alpha/kernel/ptrace.c @@ -24,10 +24,15 @@ =20 #include "proto.h" #include +#include =20 #define DEBUG DBG_MEM #undef DEBUG =20 +#ifndef NT_FPREGSET +#define NT_FPREGSET NT_PRFPREG +#endif + #ifdef DEBUG enum { DBG_MEM =3D (1<<0), @@ -143,19 +148,163 @@ get_reg(struct task_struct * task, unsigned long reg= no) return *get_reg_addr(task, regno); } =20 +static void alpha_elf_fpregs_get(struct task_struct *target, + elf_fpreg_t *fpregs) /* points to ELF_NFPREG entries */ +{ + memcpy(fpregs, task_thread_info(target)->fp, sizeof(elf_fpregset_t)); +} + +static void alpha_elf_fpregs_set(struct task_struct *target, + const elf_fpreg_t *fpregs, + size_t nwords) +{ + size_t n =3D min_t(size_t, nwords, ELF_NFPREG); + + memcpy(task_thread_info(target)->fp, fpregs, n * sizeof(elf_fpreg_t)); +} + +static void alpha_elf_gregs_set(struct task_struct *child, + const elf_greg_t *src, + size_t nwords) +{ + struct pt_regs *pt =3D task_pt_regs(child); + struct thread_info *ti =3D task_thread_info(child); + struct switch_stack *sw =3D ((struct switch_stack *)pt) - 1; + + /* GPRs r0..r8 live in pt_regs */ + if (nwords > 0) + pt->r0 =3D src[0]; + if (nwords > 1) + pt->r1 =3D src[1]; + if (nwords > 2) + pt->r2 =3D src[2]; + if (nwords > 3) + pt->r3 =3D src[3]; + if (nwords > 4) + pt->r4 =3D src[4]; + if (nwords > 5) + pt->r5 =3D src[5]; + if (nwords > 6) + pt->r6 =3D src[6]; + if (nwords > 7) + pt->r7 =3D src[7]; + if (nwords > 8) + pt->r8 =3D src[8]; + + /* r9..r15 live in switch_stack */ + if (nwords > 9) + sw->r9 =3D src[9]; + if (nwords > 10) + sw->r10 =3D src[10]; + if (nwords > 11) + sw->r11 =3D src[11]; + if (nwords > 12) + sw->r12 =3D src[12]; + if (nwords > 13) + sw->r13 =3D src[13]; + if (nwords > 14) + sw->r14 =3D src[14]; + if (nwords > 15) + sw->r15 =3D src[15]; + + /* r16..r28 live in pt_regs */ + if (nwords > 16) + pt->r16 =3D src[16]; + if (nwords > 17) + pt->r17 =3D src[17]; + if (nwords > 18) + pt->r18 =3D src[18]; + if (nwords > 19) + pt->r19 =3D src[19]; + if (nwords > 20) + pt->r20 =3D src[20]; + if (nwords > 21) + pt->r21 =3D src[21]; + if (nwords > 22) + pt->r22 =3D src[22]; + if (nwords > 23) + pt->r23 =3D src[23]; + if (nwords > 24) + pt->r24 =3D src[24]; + if (nwords > 25) + pt->r25 =3D src[25]; + if (nwords > 26) + pt->r26 =3D src[26]; + if (nwords > 27) + pt->r27 =3D src[27]; + if (nwords > 28) + pt->r28 =3D src[28]; + + /* gp, usp, pc, unique */ + if (nwords > 29) + pt->gp =3D src[29]; + + if (nwords > 30) { + ti->pcb.usp =3D src[30]; + /* + * If someone ever does this to current (rare), keep the + * hardware usp consistent. + */ + if (child =3D=3D current) + wrusp(src[30]); + } + + if (nwords > 31) + pt->pc =3D src[31]; + + if (nwords > 32) + ti->pcb.unique =3D src[32]; + +/* + * PTRACE_SETREGSET can be used at a syscall-entry stop to skip the + * syscall by setting the syscall number to -1. The seccomp/ptrace + * selftests use this to synthesize errno returns. + * + * Alpha uses r19/a3 as the error flag, so a skipped syscall with a + * small positive r0 and a clear r19 must be normalized to an error + * return. + */ + if (pt->r1 =3D=3D (unsigned long)-1 && + pt->r19 =3D=3D 0 && + pt->r0 > 0 && + pt->r0 < MAX_ERRNO) + pt->r19 =3D 1; +} + + /* * Write contents of register REGNO in task TASK. */ static int put_reg(struct task_struct *task, unsigned long regno, unsigned long data) { + struct pt_regs *regs =3D task_pt_regs(task); + if (regno =3D=3D 63) { task_thread_info(task)->ieee_state =3D ((task_thread_info(task)->ieee_state & ~IEEE_SW_MASK) | (data & IEEE_SW_MASK)); data =3D (data & FPCR_DYN_MASK) | ieee_swcr_to_fpcr(data); } + *get_reg_addr(task, regno) =3D data; + + /* + * Alpha historically exposes r0/v0 as the syscall number at a + * syscall-entry stop. The generic-entry conversion keeps the + * mutable syscall number in regs->r1, so old ptrace users such + * as strace that skip a syscall by poking r0 to -1 must also + * update the internal shadow syscall number. + * + * Do not mirror other r0 writes. strace later pokes r0 to the + * injected return value, e.g. 42, while r1 must remain -1. + */ + + if (regno =3D=3D 0 && data =3D=3D (unsigned long)-1) { + regs->r1 =3D data; + regs->r19 =3D 0; + } + return 0; } =20 @@ -315,54 +464,6 @@ long arch_ptrace(struct task_struct *child, long reque= st, DBG(DBG_MEM, ("poke $%lu<-%#lx\n", addr, data)); ret =3D put_reg(child, addr, data); break; - case PTRACE_GETREGSET: - case PTRACE_SETREGSET: { - struct iovec __user *uiov =3D (struct iovec __user *)data; - struct iovec iov; - struct pt_regs *regs; - size_t len; - - /* Only support NT_PRSTATUS (general registers) for now. */ - if (addr !=3D NT_PRSTATUS) { - ret =3D -EIO; - break; - } - - if (copy_from_user(&iov, uiov, sizeof(iov))) { - ret =3D -EFAULT; - break; - } - - regs =3D task_pt_regs(child); - len =3D min_t(size_t, iov.iov_len, sizeof(*regs)); - - if (request =3D=3D PTRACE_GETREGSET) { - if (copy_to_user(iov.iov_base, regs, len)) { - ret =3D -EFAULT; - break; - } - } else { - /* - * Allow writing back regs. This is needed by the TRACE_syscall - * tests (they change PC/syscall nr/retval). - */ - if (copy_from_user(regs, iov.iov_base, len)) { - ret =3D -EFAULT; - break; - } - } - - /* Per API, update iov_len with amount transferred. */ - iov.iov_len =3D len; - if (copy_to_user(uiov, &iov, sizeof(iov))) { - ret =3D -EFAULT; - break; - } - - ret =3D 0; - break; - } - default: ret =3D ptrace_request(child, request, addr, data); break; @@ -410,3 +511,126 @@ syscall_trace_leave(void) if (test_thread_flag(TIF_SYSCALL_TRACE)) ptrace_report_syscall_exit(current_pt_regs(), 0); } + +/* + * Minimal regset support for Alpha. + * + * Alpha-specific notes: + * - Do NOT use ELF_CORE_COPY_REGS(): it uses current_thread_info(), + * which is wrong for non-current tasks. + * - dump_elf_task() returns 1 unconditionally in this tree, while + * regset_get should return 0 on success. So call dump_elf_thread() + * directly and return membuf_write()'s result. + */ + +static int alpha_regset_set(struct task_struct *target, + const struct user_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, + const void __user *ubuf) +{ + elf_gregset_t gregs; + unsigned int nwords; + + if (pos + count > sizeof(gregs)) + return -EIO; + + /* + * Preserve registers outside the written range. + */ + dump_elf_thread(gregs, task_pt_regs(target), + task_thread_info(target)); + + if (user_regset_copyin(&pos, &count, &kbuf, &ubuf, + gregs, 0, sizeof(gregs))) + return -EFAULT; + + nwords =3D sizeof(gregs) / sizeof(elf_greg_t); + alpha_elf_gregs_set(target, gregs, nwords); + + return 0; +} + +static int alpha_fpregset_set(struct task_struct *target, + const struct user_regset *regset, + unsigned int pos, unsigned int count, + const void *kbuf, + const void __user *ubuf) +{ + elf_fpregset_t fpregs; + unsigned int nwords; + + if (pos + count > sizeof(fpregs)) + return -EIO; + + alpha_elf_fpregs_get(target, fpregs); + + if (user_regset_copyin(&pos, &count, &kbuf, &ubuf, + fpregs, 0, sizeof(fpregs))) + return -EFAULT; + + nwords =3D sizeof(fpregs) / sizeof(elf_fpreg_t); + alpha_elf_fpregs_set(target, fpregs, nwords); + + return 0; +} + +static int alpha_regset_get(struct task_struct *target, + const struct user_regset *regset, + struct membuf to) +{ + struct pt_regs *pt =3D task_pt_regs(target); + struct thread_info *ti =3D task_thread_info(target); + elf_gregset_t gregs; + + dump_elf_thread(gregs, pt, ti); + return membuf_write(&to, gregs, sizeof(gregs)); +} + +static int alpha_fpregset_get(struct task_struct *target, + const struct user_regset *regset, + struct membuf to) +{ + elf_fpregset_t fpregs; + + alpha_elf_fpregs_get(target, fpregs); + return membuf_write(&to, fpregs, sizeof(fpregs)); +} + +enum alpha_regset { + REGSET_GPR, + REGSET_FPR, +}; + +static const struct user_regset alpha_user_regsets[] =3D { + [REGSET_GPR] =3D { + .core_note_type =3D NT_PRSTATUS, + .n =3D ELF_NGREG, + .size =3D sizeof(elf_greg_t), + .align =3D sizeof(elf_greg_t), + .regset_get =3D alpha_regset_get, + .set =3D alpha_regset_set, + }, + [REGSET_FPR] =3D { + .core_note_type =3D NT_PRFPREG, + .core_note_name =3D "CORE", + .n =3D ELF_NFPREG, + .size =3D sizeof(elf_fpreg_t), + .align =3D sizeof(elf_fpreg_t), + .regset_get =3D alpha_fpregset_get, + .set =3D alpha_fpregset_set, + }, +}; + +static const struct user_regset_view user_alpha_view =3D { + .name =3D "alpha", + .e_machine =3D EM_ALPHA, + .ei_osabi =3D ELF_OSABI, + .regsets =3D alpha_user_regsets, + .n =3D ARRAY_SIZE(alpha_user_regsets), +}; + +const struct user_regset_view *task_user_regset_view(struct task_struct *t= ask) +{ + return &user_alpha_view; +} diff --git a/arch/alpha/kernel/traps.c b/arch/alpha/kernel/traps.c index 7004397937cf..7631129ac914 100644 --- a/arch/alpha/kernel/traps.c +++ b/arch/alpha/kernel/traps.c @@ -30,6 +30,12 @@ =20 #include "proto.h" =20 +static __always_inline void alpha_snapshot_usp(struct pt_regs *regs) +{ + if (user_mode(regs)) + regs->usp =3D 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 =3D FPE_FLTINV; =20 + 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; =20 + alpha_snapshot_usp(regs); if (type =3D=3D 3) { /* FEN fault */ /* Irritating users can call PAL_clrfen to disable the FPU for the process. The kernel will then trap in --=20 2.53.0 From nobody Mon Jun 8 10:56:38 2026 Received: from mail-lf1-f41.google.com (mail-lf1-f41.google.com [209.85.167.41]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B23B6343884 for ; Fri, 29 May 2026 14:23:46 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.41 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064628; cv=none; b=miKDgPtJbGZu4/Osp3x+/13PjqpsRa9d/BZ/cDafSuaEm2voNDh84OmJ9lwF+/RQ2X9L7B8EJ30TITFAJ1ZGWRdx4HzUy1rekSj2DEwCywTIz0WG48sJAuCFaQVnbnU2AQ1nBkv4o/TGaiandhny9CAJDkjFc1CzA4ll5emoRRo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064628; c=relaxed/simple; bh=8ZCTjRwEU90aOFjdM2BqJWPcGFCLfSq9sbu77JodwCg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=O6dfrLrG5i4bCInS/V1U3hdUsymkwMxm6yyNtnijEuj/p8XzN5jgtzvnzMoDA7bKos3k8QasrVcWy3+zWoicHMzEJhb7U4eBQwJm0Sa60BDR2ztQdduU+pCUtF6xKHbbXzolTZzOW7WnG/kVRvfYsD9gXOwTmF1DwW9z3FPrbT0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=PoSOpOBS; arc=none smtp.client-ip=209.85.167.41 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="PoSOpOBS" Received: by mail-lf1-f41.google.com with SMTP id 2adb3069b0e04-5a8ee4b703fso12812757e87.0 for ; Fri, 29 May 2026 07:23:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1780064625; x=1780669425; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Vo/kqexim4ywDwuffxHgaw4wfPoKPS0jDc9dhEX2Cmk=; b=PoSOpOBSCH4iOVFZnFFIQup5huu+ekka3kpK2RFocUsxN1gP4xtGxNXdWsE7JZyMDG TTEsWN9QK1yYTAYyjnh8IwIEofQjwFX7JJovjc2Or85C+gAmHD5MG74G6zzdFqFzOaCN bVqC9ft2QHLF9uz2KfQt9TEYwyX2mB7dGrcrGI3cDROIsxnA+SnUqoeUZcchZKBfV4+Y EMQ2lz+iCbETru/CK94qehlNhNIb50Qrk6K/v5Q0rql76kp9PriOSlOr2TQXc4cY9bRI siORTkzEMQXmvXv6UofYnbQ/X255+D6a+1cRRl2yoBJpD1RtvGIozlpJdOyYk8nYWVPe vonA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1780064625; x=1780669425; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=Vo/kqexim4ywDwuffxHgaw4wfPoKPS0jDc9dhEX2Cmk=; b=OXiXg+EddFK9Ckgjy0hDZwAB71ntLSzjWX/8vh/3kqURlMOEiHURRDUFW/NuTJqFyw vDmHMxscTLLQ5MqhXflvqqBzv/lIqQylgdwfJzLaGToElxMtWu5RSys6aJGMjGIE9ikj cIH+lXzy0ZIqbIbs0Tm4MAOd1d9vWm4/D0GJfvoAVGSg/anPJlcuEJFJud0IsD/jR32Q ZepXHajkG6RN72w6M7q6JtCnHRMShnXLmC2RJzpcYCO4lZAlKJ6W0HZuY2nguW/UiwYT KV29wGmM9HMu+UoAj0yfBfbvmlCtgPd8w+iF6B8Bn401KZLQ1L+Wegnq1D8QyWGklPAa pN2Q== X-Forwarded-Encrypted: i=1; AFNElJ+Bc0boyY+Wr8vAX1EabjghQJzT5ET0PeJDCnbisU/22FknknV10+xVmY6BjCtIaD9RFXzyKKy8WIV4EmM=@vger.kernel.org X-Gm-Message-State: AOJu0YxE3LFYY0syDxGTQTfhIhv2p8oMY98wLOsEZijE1hiBkFiIheir YINFVCVmRcGdDoc814XbBStqpIEDtEgO9P/87Pgap88CQo/8v+TDXuA25GXGlOR3 X-Gm-Gg: Acq92OHzG1JYKMiq7bvC7H9z1gN5C1MSGUTpxYvgFvEJBgyAS4kZ3vTyFgNdHoG3PIt KDEf3aMfJwm8WatVKzOhNAMaD95IvUouPbDUe6fnCyab2LDIQPmEXvfVCtqsENM9ulVy6BQhh5v ku8mc8vDo3ZfixetWcfhQBstSf905NC85Pmn9tJL++3o6h+0DDr4t/mo3gkRBkU7X45blqubba1 lrG0AqXA2knjCnTKlAIdPGyvoJay+eYG28jxfuMTYaLbpVN1eeEtQRRVwCfFwflUAz5lBxpQWO/ fy37Vh62oTZE5vf3PuL5ImFMRXPiiV06dV0kYN10trgqommtJJSWc6HMuYpfzGTxUAljtQkd36v JkoQPWebqbF760BLk05PMhkutwfxxLsmYz6IuhvRAS5QcWrOqkT1cTuzzFcWaH8CyWIYtVYtAK4 ZTUPVKRFVY/tVX+TCXrKSnDtlaPnMnUaaSlQ8lZSkri3lPF5IO/bIX2kRakgzWJYnMsgeox2ECm 3irNwbm0klgsyLOPlXXQOmZ6JoyAVe72AsEor+IP6ZtYQ== X-Received: by 2002:a05:6512:3f09:b0:5a8:88a4:46a5 with SMTP id 2adb3069b0e04-5aa594b868fmr936899e87.40.1780064624780; Fri, 29 May 2026 07:23:44 -0700 (PDT) Received: from buildhost.darklands.se (h-94-254-104-176.A469.priv.bahnhof.se. [94.254.104.176]) by smtp.gmail.com with ESMTPSA id 2adb3069b0e04-5aa5b0687e2sm310433e87.6.2026.05.29.07.23.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 May 2026 07:23:44 -0700 (PDT) From: Magnus Lindholm To: richard.henderson@linaro.org, mattst88@gmail.com, linux-kernel@vger.kernel.org, linux-alpha@vger.kernel.org Cc: glaubitz@physik.fu-berlin.de, mcree@orcon.net.nz, ink@unseen.parts, macro@orcam.me.uk, Magnus Lindholm Subject: [PATCH v2 2/8] alpha: add ARCH_STACKWALK-based stacktrace support Date: Fri, 29 May 2026 16:21:58 +0200 Message-ID: <20260529142322.1362438-3-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260529142322.1362438-1-linmag7@gmail.com> References: <20260529142322.1362438-1-linmag7@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Implement 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. Signed-off-by: Magnus Lindholm --- 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 diff --git a/arch/alpha/Kconfig b/arch/alpha/Kconfig index f3b882835617..7ac435c56845 100644 --- a/arch/alpha/Kconfig +++ b/arch/alpha/Kconfig @@ -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 =20 +config STACKTRACE_SUPPORT + def_bool y + menu "System setup" =20 choice diff --git a/arch/alpha/kernel/Makefile b/arch/alpha/kernel/Makefile index 187cd8df2faf..4ea5c189e60e 100644 --- a/arch/alpha/kernel/Makefile +++ b/arch/alpha/kernel/Makefile @@ -9,7 +9,8 @@ ccflags-y :=3D -Wno-sign-compare =20 obj-y :=3D 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 =20 obj-$(CONFIG_VGA_HOSE) +=3D console.o obj-$(CONFIG_SMP) +=3D smp.o diff --git a/arch/alpha/kernel/stacktrace.c b/arch/alpha/kernel/stacktrace.c new file mode 100644 index 000000000000..74d95f591039 --- /dev/null +++ b/arch/alpha/kernel/stacktrace.c @@ -0,0 +1,61 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include +#include +#include + +#include +#include + +static __always_inline unsigned long alpha_get_current_ksp(void) +{ + unsigned long sp; + + asm volatile("mov $30, %0" : "=3Dr"(sp)); + return sp; +} + +static void alpha_scan_kernel_stack(unsigned long ksp, + stack_trace_consume_fn consume_entry, + void *cookie) +{ + unsigned long *p =3D (unsigned long *)ksp; + + if (unlikely(ksp & (sizeof(unsigned long) - 1))) + return; + + while (!kstack_end(p)) { + unsigned long addr =3D READ_ONCE_NOCHECK(*p++); + + if (!__kernel_text_address(addr)) + continue; + + if (!consume_entry(cookie, addr)) + break; + } +} + +noinline void arch_stack_walk(stack_trace_consume_fn consume_entry, + void *cookie, + struct task_struct *task, + struct pt_regs *regs) +{ + unsigned long ksp; + + if (!task) + task =3D current; + + if (regs && task =3D=3D current) { + /* + * pt_regs is stored on the kernel stack; regs+1 matches + * what arch/alpha/kernel/traps.c uses as the trace start. + */ + ksp =3D (unsigned long)(regs + 1); + } else if (task =3D=3D current) { + ksp =3D alpha_get_current_ksp(); + } else { + ksp =3D task_thread_info(task)->pcb.ksp; + } + + alpha_scan_kernel_stack(ksp, consume_entry, cookie); +} diff --git a/arch/alpha/kernel/vmlinux.lds.S b/arch/alpha/kernel/vmlinux.ld= s.S index 2d136c63db16..95704e64b6a6 100644 --- a/arch/alpha/kernel/vmlinux.lds.S +++ b/arch/alpha/kernel/vmlinux.lds.S @@ -28,6 +28,8 @@ SECTIONS TEXT_TEXT SCHED_TEXT LOCK_TEXT + IRQENTRY_TEXT + SOFTIRQENTRY_TEXT *(.fixup) *(.gnu.warning) } :text --=20 2.53.0 From nobody Mon Jun 8 10:56:38 2026 Received: from mail-lf1-f52.google.com (mail-lf1-f52.google.com [209.85.167.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 730593E9C2A for ; Fri, 29 May 2026 14:23:47 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.52 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064629; cv=none; b=GrsRA3fhlzHU+0kuTH+K47CuELHtUKUd8nMWVj4n5Aqp2pUc1TFGmk1BGCo7bzWh1gLDCXttQaWotJZgeWTHIbO1vLb7kT2eqX+nfTR6c1aktaVards/nI6BScRcV70ZImjSr1QZ7jfw6CPmCtxP6e1OkRoiGXF9JemRPbbF7As= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064629; c=relaxed/simple; bh=9Gis33Sp7AVsisa6JN4s5EdMk7i/H0Ra9vdSrPS89l0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=uHpQnwwCapd60j1VLXfbx6T0iVZXSVB4lxXA4IVeVD43girw8Rrk+jwZgiEu5mAzT7TZAtDmEc5ct+erQ+XHfH02qbtQE9wWk3Bohw21A3NJRwcRDVMUun4iTd/5TS4lvk1kVfLBvTRrlvIyHcPrNauMYc6KuBna0c/oVu69oxU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=LreKMlOa; arc=none smtp.client-ip=209.85.167.52 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="LreKMlOa" Received: by mail-lf1-f52.google.com with SMTP id 2adb3069b0e04-5aa2c25c632so9521647e87.1 for ; Fri, 29 May 2026 07:23:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1780064626; x=1780669426; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=+Zeom7iA0plPmE0dSLPeGIAyQiaLvJZwK3BO3d2pnzY=; b=LreKMlOaxfjsCNDmFAvT812VmLx57lDHzpOoXXLv3zIxq29AfRC1C2l31fiYdh6+E3 UMqiLKoOo6HdCPzQMjra/gnyzlJKen/lFbX/mgBnfqpUM5dr8MlNzBzAicxrXPD/r8U3 wU5qmk2Xeh2GyJPVpV0NyCB5A4lEYZXcWKP38Vt4Q/1+qO7FifCfaoPsb3XgensApF9U jn89sbDfPCW8ZBMEQZiO6e0oMCbPatWh7YyNKKuChBp3tab+jeS977HmTurKLWAUxL5Y mukN0Hnl6I3lBB0xWFMtxsFQqDz1NLrJQkY8qOgUGJcjC4VNUbi+FgwwcPnPX4gOyFx+ +FKQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1780064626; x=1780669426; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=+Zeom7iA0plPmE0dSLPeGIAyQiaLvJZwK3BO3d2pnzY=; b=OgcwsZ1pUwgGDuetptDEDAAVIysb9aKJkOgB1SZfJ4R/ayqfATh9Hf3Mq4ndWJJymv fk2dVppcgKxmzZ170CuTFWW6Y5pf78br49S1A25b7T6v0Rx3M+cuM9ei+fC+XXgx0u6f xXFTEnZoriuVmOaBRX+5HDiionTFvjKMt8ZfCapciJ9JqJTki4ImFdm7MIo7IHNrjWXi XWR7GHJQaP8+JdvbE9xQS5NTNoCCVwxBES4qj/n3MHRX5geZ4r4KQR73u0MjIBoi5DNf 3l35aTLTKSeEGaahy1jhnSXjRvGwTYhF72XLcZ05Ky3q6UlEX70Hp5R9oOnaVuBH8XVZ VAZg== X-Forwarded-Encrypted: i=1; AFNElJ/a3xJlmWOFDoiAvbNTv+TAaiGlyISrDeDmARn3I+C8L56SDNBbgpaDnOXOS24PbQt/XqnLJZbANK5FhEE=@vger.kernel.org X-Gm-Message-State: AOJu0YyJr8LRjrMEQVXXhlu/meYaNtXv0Q+urlFGKFRt7AQLh0KB8oyF KIEFXKglSf7YlhOvY61MPRLGP5qOyLSwCecMYYiNxh8quT6H7aCmWD+m X-Gm-Gg: Acq92OFDO38nj2ChtlB46BM7NUfLmLaVJfobBRqWMbV9ltlyMp8OY+07dPMxDWJqQ2+ giQEheSA/XDcKK4GwvYizbLiStbDNwOuplNxtAdhvDch+LCKAc0NjmHjEa7HHAD8lQrQKmSag9r fTUZCWfcScLD48qsTsWEHJ4PD24q5Dqhdo18SijeQl1pQkqb6zhUA+aGe8+ctv0y8jGK9s3wEuh pMU+NnmWd9mWXJ7kdgfW9LsFVJ2aAxaJNtEXVWMibfqQKQfm5mWRRoR3VRzBB600cRa1eRBOn8O cvo1psB4+6Xtae5OEgjlS3+Wcf7XSaIp02TT1exTmq6uOuS/PspaXunzjmzmaT1WZXJndto1fBl U+ZNKq37uJJIoGwHkpp3v6ITgWlsT5rqHPLvjEW7wBG2NjXC3GpB2bvl0e0+6XR7Ly60es1F4yN Iy75yaVmsToZhKnOvGdPZqd4oxmVaFRDZ+OdncJRL3xn+0FabGQWt5eHwRMDJij463yhorgwORe 1LwZAvlyjlmVZ5g7PS/RrVs7L3XBmWwM7Ds4ycFxnF7qg== X-Received: by 2002:a05:6512:3993:b0:5a8:89d6:93e0 with SMTP id 2adb3069b0e04-5aa607ce094mr13521e87.13.1780064625585; Fri, 29 May 2026 07:23:45 -0700 (PDT) Received: from buildhost.darklands.se (h-94-254-104-176.A469.priv.bahnhof.se. [94.254.104.176]) by smtp.gmail.com with ESMTPSA id 2adb3069b0e04-5aa5b0687e2sm310433e87.6.2026.05.29.07.23.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 May 2026 07:23:45 -0700 (PDT) From: Magnus Lindholm To: richard.henderson@linaro.org, mattst88@gmail.com, linux-kernel@vger.kernel.org, linux-alpha@vger.kernel.org Cc: glaubitz@physik.fu-berlin.de, mcree@orcon.net.nz, ink@unseen.parts, macro@orcam.me.uk, Magnus Lindholm Subject: [PATCH v2 3/8] alpha: make irqflags helpers operate on IPL state Date: Fri, 29 May 2026 16:21:59 +0200 Message-ID: <20260529142322.1362438-4-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260529142322.1362438-1-linmag7@gmail.com> References: <20260529142322.1362438-1-linmag7@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Alpha 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. Signed-off-by: Magnus Lindholm --- arch/alpha/include/asm/irqflags.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/arch/alpha/include/asm/irqflags.h b/arch/alpha/include/asm/irq= flags.h index 9f25d4e0d37e..f207544f52de 100644 --- a/arch/alpha/include/asm/irqflags.h +++ b/arch/alpha/include/asm/irqflags.h @@ -26,7 +26,7 @@ extern int __min_ipl; =20 static inline unsigned long arch_local_save_flags(void) { - return rdps(); + return getipl(); } =20 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(); } =20 static inline bool arch_irqs_disabled_flags(unsigned long flags) { - return flags =3D=3D IPL_MAX; + return (flags & 7) =3D=3D IPL_MAX; } =20 static inline bool arch_irqs_disabled(void) --=20 2.53.0 From nobody Mon Jun 8 10:56:38 2026 Received: from mail-lf1-f53.google.com (mail-lf1-f53.google.com [209.85.167.53]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4B0BD3EA946 for ; Fri, 29 May 2026 14:23:48 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064629; cv=none; b=fAKGVn89uKiak2bWASG/2JKGHEi/+x0ly5l0YrK0ilQOJeoBQ8x1zLqtCwa48AAPxRR7IxN8Xh8Z3fX2GnyGKsyBxapoDxoNgRoeYCrqMkg+rfCjxqW7D6npdAoaVxblK0rcaJbqoA55lL7iQUIf6cf31Y+ij+h+xM7xlZCUh9U= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064629; c=relaxed/simple; bh=HE6RHHD80LhTOnOIxDn55ZV+XR4m0A2pX3dfr15Ejfk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ZQ3i3dggOZMM4BnXvOXEwXb28B5UuZady87XQpmlhNjr0i9Q+ALhxK6bKc/xXIBFLCqT1nsdUG2jXMn41YdXs56qQa52IestH1nPNTMJPJhpubc1rRYtC0N3Ocp3zA97qxyjpSGy6axQLHZXEe3Thst8VB9fRn3XctnAaCx1FZY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=eyp34DGj; arc=none smtp.client-ip=209.85.167.53 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="eyp34DGj" Received: by mail-lf1-f53.google.com with SMTP id 2adb3069b0e04-5aa5ce4904eso453324e87.3 for ; Fri, 29 May 2026 07:23:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1780064626; x=1780669426; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=jM2g/fNisSlNBmuh3HXPnL9GcxMgIFTfKPUaQ1PrVMU=; b=eyp34DGjZb1mS04wWST5wvPiVMj1xDbttI3xqMfZWA+1QS9K2XJmP8Rj3wi4rnNKd+ 2+youVdrsCMQIwhtnU1y0c1Tk3K4yfF/3PvarHhQQgqb9+m3MMinyFgNQScNwsnd/gEg ldV/N3ap2cP97IDhRPChlcaNI/6Qvabfqpm2CmmEYbR9X8mWkrRtgM7OhjRvNuk50UMa R4SR5eMvbqsuSq0TDelffidySqAjnNDC2SpXs0xgUFXbx8JzhHya4vNkJrjQLq/Hf8m3 yxTPscYBQHTSY6YxFYSHt4H1U9eQ+2LOJqMqZ8JnPZ/WVzLXr7qCR5wrvWd/cfGFBG20 KwMA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1780064626; x=1780669426; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=jM2g/fNisSlNBmuh3HXPnL9GcxMgIFTfKPUaQ1PrVMU=; b=daIrWXYipLs9SU8aKA3jzzeFV5WPS0YylloKSf9T6Rf+/j6Ilp2wrkauRC6bv4qhuf e/4t5wT/kyVJuRvKBUj3KBgf+lYkZVVHx3b+DcZKuJGctOSCBKqU5K3xhN7WJ/CxAc4m wXpuppaaxL6GfoP3+HHLszVS1GVCa+aJ46oH6+I13tK7GHKvDKBmeGCIcERy0Y1FTNx8 eUrrusZ2z3xTZvAnuIFFHYKmWyocrxBdwTokcN9FZyfHdQ1pdp0jxNFQT6wOQ+BzbMSu QGD4kQ3yf3UbZvKmPj+Qs7Igj2uTz2ha53kVdmC0zeJcPzWxN1wS/npXuoAQR4LGwSxD uZ/g== X-Forwarded-Encrypted: i=1; AFNElJ9AynDH4O8gTreWNwFWqHsnUnlBcZu34NaTYH0mS49npMAkwRag6U8YVoCenqcI83/pbGPkVUJ1qoi8PUI=@vger.kernel.org X-Gm-Message-State: AOJu0Yz+7p88033cOPsouplUO2oMDbKgMwza3Tet+o28GTMsSh1gkkKF ksfdqYkOid4i29JN9UKQQDopp/F0Iy/f8g3uKcy/e8QK5nn/6HQ+0ETp X-Gm-Gg: Acq92OFYQZmHSf8NWb9zLgdCLpXlv7PDU0g5vrYKhnacW88OUQqoNT0Z9jvBqZuawWC wLB/0j3xk2ZBTlaQ6sx5v1k2lrIKm5KnVZ7vAh/kSMcChcdFpwPsqpt2GzVYvewkZvAfUA5A3KT UBq7dB+bc/TPRRLAwEjMSB/z1Fiy3yXvxlsYLBMVQav363YYuR/oD0zBBMYUM6kqn3X0qfLsDIk KpvwSWA0RE8JR/YrXTYinUi94jQOn/cYXNtUhFXmy/OE8QfUsZm8Rby0LjeC3tL5skFgdeDryV1 g3nvf3frr+DjmtrSxS6HjJUhws+dX4F24mjE81nC9lC4xO62Cx8jlrRW7lzoXSywthYOKZfkzfE ZSb19xDMph87aoOUX6/Ey9+JiL6EEi4d7q3aMLDoIahaibBl+q+LmLEt2siYJ/1udE4J0lzebcT DlG6tq4LEEZDw8fSIpBFNuS1hTvGb/iRFqyrpzLVZo0OP60cyHrRxRdq6xPLps4xnKBbkTiXgTk GPiNtnA7Ff1cVIHReTpGk5guCyyv3uoVU6yE4R5G4w0NA== X-Received: by 2002:a05:6512:1112:b0:5aa:36cf:50dc with SMTP id 2adb3069b0e04-5aa606a3825mr22695e87.3.1780064626373; Fri, 29 May 2026 07:23:46 -0700 (PDT) Received: from buildhost.darklands.se (h-94-254-104-176.A469.priv.bahnhof.se. [94.254.104.176]) by smtp.gmail.com with ESMTPSA id 2adb3069b0e04-5aa5b0687e2sm310433e87.6.2026.05.29.07.23.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 May 2026 07:23:46 -0700 (PDT) From: Magnus Lindholm To: richard.henderson@linaro.org, mattst88@gmail.com, linux-kernel@vger.kernel.org, linux-alpha@vger.kernel.org Cc: glaubitz@physik.fu-berlin.de, mcree@orcon.net.nz, ink@unseen.parts, macro@orcam.me.uk, Magnus Lindholm Subject: [PATCH v2 4/8] alpha: initialize PCI sysfs bin attributes for lockdep Date: Fri, 29 May 2026 16:22:00 +0200 Message-ID: <20260529142322.1362438-5-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260529142322.1362438-1-linmag7@gmail.com> References: <20260529142322.1362438-1-linmag7@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Alpha allocates PCI resource sysfs bin attributes dynamically. When lockdep is enabled, dynamically allocated sysfs attributes need their lockdep metadata initialized before registration. Call sysfs_bin_attr_init() before registering the resource bin attribute with sysfs. This avoids unrelated sysfs lock-class warnings once Alpha enables lockdep support. Signed-off-by: Magnus Lindholm --- arch/alpha/kernel/pci-sysfs.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/arch/alpha/kernel/pci-sysfs.c b/arch/alpha/kernel/pci-sysfs.c index 3048758304b5..ba08dbb43521 100644 --- a/arch/alpha/kernel/pci-sysfs.c +++ b/arch/alpha/kernel/pci-sysfs.c @@ -159,6 +159,8 @@ static int pci_create_one_attr(struct pci_dev *pdev, in= t num, char *name, { size_t size =3D pci_resource_len(pdev, num); =20 + sysfs_bin_attr_init(res_attr); + sprintf(name, "resource%d%s", num, suffix); res_attr->mmap =3D sparse ? pci_mmap_resource_sparse : pci_mmap_resource_dense; --=20 2.53.0 From nobody Mon Jun 8 10:56:38 2026 Received: from mail-lf1-f50.google.com (mail-lf1-f50.google.com [209.85.167.50]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id F275C3E8C70 for ; Fri, 29 May 2026 14:23:48 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.50 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064630; cv=none; b=pmQ1n9EClfzTXbU6NS0tC70dPkJ/RPB9z4s67+cV5z4WLlNvkfrNYmZLi6tIXPWoNzHqRMz5g6DKcvMczWWL9hPVelYVoscDFlHwG2a/48+LymYWZSSVtdXaIzZQr4edxcG+Rus2gC6JWRlnnhIRLJn0XDTwZk7rwjHfQTXORwU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064630; c=relaxed/simple; bh=D04sp6jy24qV/d7jpV7qcj/FJRHhYaGlTiewOrERXrk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=THqVHcGSODVspHBBk+A099jAqdLwXgE8133juqKKt8Rb6W95J/RH9OL73ufuloy3YCGWP46kXFFnw1KQw7+6tzhZwYQOqBobIvuLbjjPMVU0fdl92A71iEHAhvtuSctLha2Xgyf/bLkJTme61ulAhEMdf6p8vv6mzDvsI3i+gUc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=Ny9JX6Uz; arc=none smtp.client-ip=209.85.167.50 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Ny9JX6Uz" Received: by mail-lf1-f50.google.com with SMTP id 2adb3069b0e04-5a887ebb416so17486415e87.2 for ; Fri, 29 May 2026 07:23:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1780064627; x=1780669427; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=byIacLsO8qy3Mf9mbTJig4sdcp2UMDCGsxpnJNNgpcs=; b=Ny9JX6UzDxEKzGlFDMT3WF5Hm1Z7IaMlxOOaew61Dj6t1o5mnLoDDgWIo50wn47I9C imzaJmuwMYB5ugRUIv+ewcjzGW6exuflZXjp0YUJdGscAa3TzNsNnbC1XkAz4QsGejCl QBj+aFlZDUEVgeBpgcUV6Ctob/oc6yErVsBr41aXWnv0ehjkqhXYmY68ljI4YQ/8ufAg UIPTXtvHsC5LS1pyx0UQ0AA2txr2mbHHDJPi/MpCvSbl/WIlwTLKYeGmuLCr4th3Ccyw OLhZKJhEXdNYyn/e9QEnmbN96WK81UW4k/zZUy9YGJgmKYfyZfAc9EMaG8JC2YTQisLJ b8Iw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1780064627; x=1780669427; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=byIacLsO8qy3Mf9mbTJig4sdcp2UMDCGsxpnJNNgpcs=; b=jRzei+KW+TDqzVdCDCU+YMd8gsty0A79YuAY6OmYn6ey9QI7JNLNy31ZbT+LgS3Wlp ga2k23rTbm3USmpj4PYK4bdoVyF7Q5zJ0kHO0wQelqATMdPaPVRgNk80t1+i8/zMQorE 2nU1+dt8ws9zVsFo/1pC1RmgCwdbcLN/24bsNBiXwTC6+2GPlTYZceP8SY9JMoiJ1vcA yjm5LtlKrk7tJL0DNcIxi/4mHcOO5g4sO9enni3nrnddqOnxMljRG1jh0POmDZJ7/W54 Gsac0Ajj1VGyXPsBmZR8I8rmrxKIa3BUkYASix3w6y4LLCe4aZLhBnugSNotHv4HyChk odFQ== X-Forwarded-Encrypted: i=1; AFNElJ9CH6/AhUMeHhAXYhhWgyxrPa12MsHKd4qZKLC/eLzCyh555tdX05YZoVDD/Lwxo8+K6nMXJWBVNJ5trmE=@vger.kernel.org X-Gm-Message-State: AOJu0YwskGcyQCEL6niCojfl7i+LqSmbbX++JVDDm+Vlg9YPbrL4nkDP dvZjR+HyXZnAj2OUm37vgOBVY9zHGfvckbgkMFkRiIxGHgmKn7daZ/ab X-Gm-Gg: Acq92OEHVsHsE+aZlbJ3zJUP6wwYWbsMLyquIcJYllBS1Z9zq5Ez99yPiIQ57pnEmiy lpODkdHqqDiTwRnPpXj1jFJUwXBn0Ecvf2yC4/opq/XEouJk9NbvxWYIc33KnoIp26VppeXTbbI TMtoBlKZ76u6K2RnBagJ3Y9Mv9xguMIpqMl8IiyEO2SpNKyIYgGJC2lp8TomWupghtTi5jATj/T 5A4/DVn4mGP7MDYb75RiFYi58+V7cquRT+dQ3fl8Jf+vF1sDJJFpxT+F1NTEIyVWPzrlNGCieFO LYu8ZFkgDMcRiEbRazPBFlUNL5slqfKyZT/AnL8Uch9wVfGDRohmM9UiEQM4EdY/KX/5DVpLvxU scIZm4+oZmU8L5SyYmLg2bMOJgdzYtaZSk0R9Xm46HHksu5mQfvmCSnnHmk02b0OUOXDRZpKfBZ 4/lpHA8rAS/rGBrrIOZLqxJ5mrhp0WPiwWopFJrSMIMIlX5hlF3XRhOFqGZl1jgaX3oqMqvBY6/ 34k/BEpQ6pWtXvdi+D0t6MkweA22z2S95Z7XKycZVAb0A== X-Received: by 2002:a05:6512:66c1:20b0:5a8:8de0:4570 with SMTP id 2adb3069b0e04-5aa60923467mr1659e87.21.1780064627174; Fri, 29 May 2026 07:23:47 -0700 (PDT) Received: from buildhost.darklands.se (h-94-254-104-176.A469.priv.bahnhof.se. [94.254.104.176]) by smtp.gmail.com with ESMTPSA id 2adb3069b0e04-5aa5b0687e2sm310433e87.6.2026.05.29.07.23.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 May 2026 07:23:46 -0700 (PDT) From: Magnus Lindholm To: richard.henderson@linaro.org, mattst88@gmail.com, linux-kernel@vger.kernel.org, linux-alpha@vger.kernel.org Cc: glaubitz@physik.fu-berlin.de, mcree@orcon.net.nz, ink@unseen.parts, macro@orcam.me.uk, Magnus Lindholm Subject: [PATCH v2 5/8] alpha: provide ftrace return address support for lockdep Date: Fri, 29 May 2026 16:22:01 +0200 Message-ID: <20260529142322.1362438-6-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260529142322.1362438-1-linmag7@gmail.com> References: <20260529142322.1362438-1-linmag7@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Lockdep 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. Signed-off-by: Magnus Lindholm --- arch/alpha/include/asm/ftrace.h | 30 +++++++++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/arch/alpha/include/asm/ftrace.h b/arch/alpha/include/asm/ftrac= e.h index 40a8c178f10d..7ec44134c804 100644 --- a/arch/alpha/include/asm/ftrace.h +++ b/arch/alpha/include/asm/ftrace.h @@ -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 */ --=20 2.53.0 From nobody Mon Jun 8 10:56:38 2026 Received: from mail-lf1-f49.google.com (mail-lf1-f49.google.com [209.85.167.49]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 850FE3ECBD5 for ; Fri, 29 May 2026 14:23:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.49 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064632; cv=none; b=KAHc9C2fu5kKPOwc3UU2s40SKUqNGFyAMbIeSKXTHddMwXqTgMATkMSPR7pKuVYdunp3gPyfmacb4mLMhwTmejs9sGEHCd9hUJp3sk/jql5ycaXcnDsM05H6x4+zHk1RvpqmB1cSChqZqLvLMq+9wpYVIPwPCGPY+ABL1xR/yNE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064632; c=relaxed/simple; bh=OeW1Tq5ib65YfcgaRKyfCUETSHjLbYZg7diBythuaoc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=eUxrlLtgYzGWXsSe+88jsxAv6eQ8WKLZQsP0PhgkVBMAzy3bBoDgaPZ6l0+nmaC4Su+f+vuheJqB+W2kyzawXyUY3HsNs/5xzXadvRgoRiI4aVkuNIqmpQWHQW9dqL2g18Ha2Dlt1q3KItV9ekDgYbNvlZwgliBQ9CdeXRqIecQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=sZ3b0QKB; arc=none smtp.client-ip=209.85.167.49 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="sZ3b0QKB" Received: by mail-lf1-f49.google.com with SMTP id 2adb3069b0e04-5aa2691db86so14900232e87.3 for ; Fri, 29 May 2026 07:23:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1780064629; x=1780669429; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=eqwt2J6l0ZWPmkw65w0oYYHsmnLHukO+G7CDsx/E9qs=; b=sZ3b0QKBT5SmJFq83MhT0wiR8ABvNNHWOHPTSjGutftd7AkLnofGdzlfYlvho4Fq/k WbL/NuvtjYgpp07C4J1URmjJ6QAFmjHILWEPwS6WKdjks3uDM9OiwHW7+91psUslZjDL W/9tp5xuMdk4j43Cv8beOLT0V/JO6Hw0v/Z9OMmnQ98D/Py3HdcdPagKFj9KcYcLrcap AyXgHnOT9DsvS6PAtM+2cPwwSeMsxtGKGTSdEJECy7mRfipFeZlolSQmcaefkptIcFDk Aidr2OGDTo2NhigfF4JuHcDin0UausDjPV7xjXM+kkG6mcf8SUp6Oa+XxAncnoVeLPHC Sb6w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1780064629; x=1780669429; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=eqwt2J6l0ZWPmkw65w0oYYHsmnLHukO+G7CDsx/E9qs=; b=bAmZrrlr3EF84JLp5SSHRhna0xth1/jYqWW+YjOkttHKwXdo4HMquleXAuQeyjaONY HH8t5us0efBaYfw7KGNrNzEanRaHknBbtajO54C9+jhNIPZosuHjLPu6K5WUFFzsQ5XI Nf0IpshMMKvL3wBm8/S4iOLlKuf/SvtJ88PTbi1/+GL0Q67BoAq0QrrXtyowk/DSzZn5 93O9ybVNXl30YyD0gHF67/diMLb+ibD8uKL0ax9Tbyj8UCL+z4kvTTozy3nXnitZP9qN Z4eYQ81vsqd4lHRdbt8LTsU/3fcHMD3KI/Hiw+ULusLqVbxgrlkE1gVPqzgQ9CbuLvm/ ZFOA== X-Forwarded-Encrypted: i=1; AFNElJ9FjuA9oXG063OB4fpiEXwllGeE8xq1H5P1C0FgfB9aai//f+sPmdureDceqRAx4+UPi0aWC21JbPEzzYY=@vger.kernel.org X-Gm-Message-State: AOJu0YxUT6xK/OcMoML5h/OgKTxj28igK3wkLNvWZQhXnzjD/XbHE5NB Ia6s8XbMhmk2Xs9kI5qy5ZoSWRDxKpL0PSol1kB7Iqzgebi4S6tSX9Bq X-Gm-Gg: Acq92OHTWcFYLz/Ss0KhLueNjKAaZzN/Kg6jEL7dSEBo0f+Bqn+EJnTl8oXdaca6MZD v+K1bHGmqSwr9Mxf8Zj4vAdl8Bdzm9ByGnKATys+xORYKDdjPHFRRQ4iHMQ3JUmU17RCVfo8tQR cvCfbI8eHN+rhPr5i7E0Zty2HVtQPJrElk/gD4v7qMFH1QVJPfYaVOUscasviUOdq5175Uj0bHg g4oJacvih6lPD/hYQcQbjUuOLdQFuOocypLfTgNN5H9b/A7THksU7+IknCcBifOoQI69EbjxFmd dm9qjkAPWRAMCzEKZ5Z/Glae6NOm57+J8ucgS1YuPW11sGkp6c0JvLMDvtspplCptis9aGA88An 41hslLB/clI1Em4JH+x6xtQrPVO9P0845ouoru53kQUtZZlUiQFzgmadZt+nk93UGqQB29wgk3/ xDW2ludgD0y2Fu7I/FWXtQEmvjICSCrZd42pOCE+jDtnmSpVD7oJ/0TfyRp70J9PEx+5zzdiMBG 6rXKnIu9E2Sd7w/zpb4F2jz5MCPgE9GwEXoEGw9JZpXVg== X-Received: by 2002:a05:6512:65d1:20b0:5a8:94c2:d49a with SMTP id 2adb3069b0e04-5aa6090338emr4326e87.27.1780064628626; Fri, 29 May 2026 07:23:48 -0700 (PDT) Received: from buildhost.darklands.se (h-94-254-104-176.A469.priv.bahnhof.se. [94.254.104.176]) by smtp.gmail.com with ESMTPSA id 2adb3069b0e04-5aa5b0687e2sm310433e87.6.2026.05.29.07.23.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 May 2026 07:23:47 -0700 (PDT) From: Magnus Lindholm To: richard.henderson@linaro.org, mattst88@gmail.com, linux-kernel@vger.kernel.org, linux-alpha@vger.kernel.org Cc: glaubitz@physik.fu-berlin.de, mcree@orcon.net.nz, ink@unseen.parts, macro@orcam.me.uk, Magnus Lindholm Subject: [PATCH v2 6/8] alpha: use raw spinlocks for low-level platform locks Date: Fri, 29 May 2026 16:22:02 +0200 Message-ID: <20260529142322.1362438-7-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260529142322.1362438-1-linmag7@gmail.com> References: <20260529142322.1362438-1-linmag7@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Some 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. Signed-off-by: Magnus Lindholm --- 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(-) diff --git a/arch/alpha/kernel/irq_i8259.c b/arch/alpha/kernel/irq_i8259.c index 29c6c477ac35..28f7b0680564 100644 --- a/arch/alpha/kernel/irq_i8259.c +++ b/arch/alpha/kernel/irq_i8259.c @@ -22,7 +22,7 @@ =20 /* Note mask bit is true for DISABLED irqs. */ static unsigned int cached_irq_mask =3D 0xffff; -static DEFINE_SPINLOCK(i8259_irq_lock); +static DEFINE_RAW_SPINLOCK(i8259_irq_lock); =20 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 &=3D ~(1 << d->irq)); - spin_unlock(&i8259_irq_lock); + raw_spin_unlock_irqrestore(&i8259_irq_lock, flags); } =20 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); } =20 void i8259a_mask_and_ack_irq(struct irq_data *d) { unsigned int irq =3D d->irq; + unsigned long flags; =20 - spin_lock(&i8259_irq_lock); + raw_spin_lock_irqsave(&i8259_irq_lock, flags); __i8259a_disable_irq(irq); =20 /* Ack the interrupt making it the lowest priority. */ @@ -69,7 +74,7 @@ i8259a_mask_and_ack_irq(struct irq_data *d) irq =3D 2; } outb(0xE0 | irq, 0x20); /* ack the master */ - spin_unlock(&i8259_irq_lock); + raw_spin_unlock_irqrestore(&i8259_irq_lock, flags); } =20 struct irq_chip i8259a_irq_type =3D { diff --git a/arch/alpha/kernel/sys_dp264.c b/arch/alpha/kernel/sys_dp264.c index 9fb445d7dca5..0a2d319bb1c8 100644 --- a/arch/alpha/kernel/sys_dp264.c +++ b/arch/alpha/kernel/sys_dp264.c @@ -41,7 +41,7 @@ static unsigned long cached_irq_mask; /* dp264 boards handle at max four CPUs */ static unsigned long cpu_irq_affinity[4] =3D { 0UL, 0UL, 0UL, 0UL }; =20 -DEFINE_SPINLOCK(dp264_irq_lock); +static DEFINE_RAW_SPINLOCK(dp264_irq_lock); =20 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 |=3D 1UL << d->irq; tsunami_update_irq_hw(cached_irq_mask); - spin_unlock(&dp264_irq_lock); + raw_spin_unlock_irqrestore(&dp264_irq_lock, flags); } =20 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 &=3D ~(1UL << d->irq); tsunami_update_irq_hw(cached_irq_mask); - spin_unlock(&dp264_irq_lock); + raw_spin_unlock_irqrestore(&dp264_irq_lock, flags); } =20 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 |=3D 1UL << (d->irq - 16); tsunami_update_irq_hw(cached_irq_mask); - spin_unlock(&dp264_irq_lock); + raw_spin_unlock_irqrestore(&dp264_irq_lock, flags); } =20 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 &=3D ~(1UL << (d->irq - 16)); tsunami_update_irq_hw(cached_irq_mask); - spin_unlock(&dp264_irq_lock); + raw_spin_unlock_irqrestore(&dp264_irq_lock, flags); } =20 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); =20 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); =20 return 0; } diff --git a/arch/alpha/kernel/sys_rawhide.c b/arch/alpha/kernel/sys_rawhid= e.c index b5846ffdadce..b4a08890dce9 100644 --- a/arch/alpha/kernel/sys_rawhide.c +++ b/arch/alpha/kernel/sys_rawhide.c @@ -41,7 +41,7 @@ static unsigned int hose_irq_masks[4] =3D { 0xff0000, 0xfe0000, 0xff0000, 0xff0000 }; static unsigned int cached_irq_masks[4]; -DEFINE_SPINLOCK(rawhide_irq_lock); +DEFINE_RAW_SPINLOCK(rawhide_irq_lock); =20 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 =3D d->irq; + unsigned long flags; =20 irq -=3D 16; hose =3D irq / 24; @@ -68,11 +69,11 @@ rawhide_enable_irq(struct irq_data *d) irq -=3D hose * 24; mask =3D 1 << irq; =20 - spin_lock(&rawhide_irq_lock); + raw_spin_lock_irqsave(&rawhide_irq_lock, flags); mask |=3D cached_irq_masks[hose]; cached_irq_masks[hose] =3D mask; rawhide_update_irq_hw(hose, mask); - spin_unlock(&rawhide_irq_lock); + raw_spin_unlock_irqrestore(&rawhide_irq_lock, flags); } =20 static void=20 @@ -80,6 +81,7 @@ rawhide_disable_irq(struct irq_data *d) { unsigned int mask, hose; unsigned int irq =3D d->irq; + unsigned long flags; =20 irq -=3D 16; hose =3D irq / 24; @@ -89,11 +91,11 @@ rawhide_disable_irq(struct irq_data *d) irq -=3D hose * 24; mask =3D ~(1 << irq) | hose_irq_masks[hose]; =20 - spin_lock(&rawhide_irq_lock); + raw_spin_lock_irqsave(&rawhide_irq_lock, flags); mask &=3D cached_irq_masks[hose]; cached_irq_masks[hose] =3D mask; rawhide_update_irq_hw(hose, mask); - spin_unlock(&rawhide_irq_lock); + raw_spin_unlock_irqrestore(&rawhide_irq_lock, flags); } =20 static void @@ -101,6 +103,7 @@ rawhide_mask_and_ack_irq(struct irq_data *d) { unsigned int mask, mask1, hose; unsigned int irq =3D d->irq; + unsigned long flags; =20 irq -=3D 16; hose =3D irq / 24; @@ -111,7 +114,7 @@ rawhide_mask_and_ack_irq(struct irq_data *d) mask1 =3D 1 << irq; mask =3D ~mask1 | hose_irq_masks[hose]; =20 - spin_lock(&rawhide_irq_lock); + raw_spin_lock_irqsave(&rawhide_irq_lock, flags); =20 mask &=3D cached_irq_masks[hose]; cached_irq_masks[hose] =3D mask; @@ -120,7 +123,7 @@ rawhide_mask_and_ack_irq(struct irq_data *d) /* Clear the interrupt. */ *(vuip)MCPCIA_INT_REQ(MCPCIA_HOSE2MID(hose)) =3D mask1; =20 - spin_unlock(&rawhide_irq_lock); + raw_spin_unlock_irqrestore(&rawhide_irq_lock, flags); } =20 static struct irq_chip rawhide_irq_type =3D { --=20 2.53.0 From nobody Mon Jun 8 10:56:39 2026 Received: from mail-lf1-f41.google.com (mail-lf1-f41.google.com [209.85.167.41]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4D0C73ED3BA for ; Fri, 29 May 2026 14:23:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.41 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064634; cv=none; b=ohlrwRNzUM8+ZtoYMP6caKJ0tGgI/IisiGsuhmRSuWFWo0od0pSP3AqCCgbMvd+LRzn5zZ7Ft1nI1IWzRunmn+h4N/yjotE+Y1Qm4mVhL2fNFmMtWD5vWPahF6EjKt40w0Duj3p7e5ZTqHTHfu7WzWRh8s0y/vvCsy7Gz2iKEE8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064634; c=relaxed/simple; bh=rstuAOpzPRL3H4jqrx/1JVpnPt5XUiL8d1ntp57R1fs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=WEtKUhyD2cJNEbGE67ha9wHcLFN7kMzrqT4LDiPmj8Fsd2ZszWjDfxvdlF0WMURe1A+dhTtdnFORTL3cftjhAeHMhMtw/zq06Rf3E/Xkk43D0PyvHokcGHwuhKyiPNE48mQ9PbNd2JEBjWxtTX0ym4EbBxS3O4kvdqGgvRBRqlM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=P9KELAIk; arc=none smtp.client-ip=209.85.167.41 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="P9KELAIk" Received: by mail-lf1-f41.google.com with SMTP id 2adb3069b0e04-5aa0cf8bca3so12971803e87.0 for ; Fri, 29 May 2026 07:23:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1780064630; x=1780669430; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=a86MAytxrH2fF3O6D6kt7FPeAwppSxDYFF7ddN+lZOs=; b=P9KELAIkDmFyzObeutWWGVWCNg9FNUNEQY0v8XUaln9aYXR/PyqK6FdQ287P70mxq5 QoHA2bQgrj9mxN1lUw9R8m1aFD5CLLzTbaLtb7hk7/uU19yGeVfWkYhRtnFQRaOTLGMs GjOUNr0mImwhP/DK9+urbraC31LSBe3BeY0sd/vlbmNooxCu70lZNeoPKHokUW3NB2Dv GMTkFdjO39HiyvLoNyN0gQcCy2g0hzfVHFsWBsB8CiuuQOVdE7ogmnCCotstUjjTTioY Micegk1BprQnDFSh7ku1dfOXUUk0MNplHHZf3Q0D+wpNNjw6/zZgsqDS1ihHvfyM9zAR +xSg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1780064630; x=1780669430; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=a86MAytxrH2fF3O6D6kt7FPeAwppSxDYFF7ddN+lZOs=; b=BPRK0p7tY37HDX/53+yqrh6ZBr6SFpMF9n1VbfW6sHxq0B6HQiloVXz4VpC8+sCzSo +wySkcDPDMdZ/7OrgAEjyf9RILD0XJ32H16hfEfjSZ7/DJrKb47upQ7xV9vNJgpWls7F 9kNYpNkqjMHr9QcmHjATugLrY442FbWgeKmwUgmrUGnLpbdTKl9YKqwhsN7TtR5nlT6J mQ27T6P25+WI9QWzTtdwsf6tNYltwBC2aX/l30rdmYh6iqpfoXvqkCDXlKLuRUUx2If8 GlNKuYoEOw8/e2nz9dSuIMSEJPjjc0EdU5wcWLjUTEsBVXT360ZowNNEhenwT5Fp6eZD VYUA== X-Forwarded-Encrypted: i=1; AFNElJ9L3sIVaYtDDl5LAA4Km9A7d/RmP/ydOAy/D02dib1HkRl6ZzEJR416CaYxEekVHKxWBraI+lokd9wzYh8=@vger.kernel.org X-Gm-Message-State: AOJu0Ywi5K1dnP0Sx3IhpGBQFwvV5ypp/86OnQ0568PqonNxAIEeAHEC vtaiuTQXyCMxUH56U8UU7ihjpkU7DJvgvFyeVBMgwZOMbVB+EXiLC3Ki X-Gm-Gg: Acq92OEYkXQx+QYx4uV9xaIGL4OZFRiYo7WD5XxwSWl/XgjgNEjfrY3e+enSfEOpSw6 OOj8PL3QbLcV6DP/6yUvfeWwjreHNZSX28LPNniTLC/Vg0haq1/XDuOgwszZCa7itdaTNZwhta9 qj/dPiKsxBh70MuEgWSzo64vqPOTjFKdaNCP3rqWL5WdCRFnXh03DtlBdOYkjgxySlUEnyUAh4x exJgz7N8xZNLBEfhOO1/H9xSKAv5fhzp/PQWpnf1O6KpDUhz968MDx7kASR69FFt+1iweBsiWXf VSN0J7PrMGUHJ9qPHF7cpRAI6RjD9qiu8DeMUaPwCsWUIzRipAAuj2Wa7tNvA68CXSX0zDbyHPf +U43Sv1mLYAJR7zoRzDr112Lvp7vlm+yPXD3owQuV07SnSHTYpGHKNBXRUYsK0SHvGCIhER6CzS IM363eczbVCHNlWX7K3nhuzln5F3KWqvbDFIOuJrh5Yb6J0q2GlVO8zh2ULHjueK3fIjh7vnC6r rx1aO6gkssYvzIJ08KoheAQsj5z36bgP9OccK8WXh11hA== X-Received: by 2002:a05:6512:2345:b0:5aa:10e2:29ab with SMTP id 2adb3069b0e04-5aa607ccf24mr16499e87.18.1780064629470; Fri, 29 May 2026 07:23:49 -0700 (PDT) Received: from buildhost.darklands.se (h-94-254-104-176.A469.priv.bahnhof.se. [94.254.104.176]) by smtp.gmail.com with ESMTPSA id 2adb3069b0e04-5aa5b0687e2sm310433e87.6.2026.05.29.07.23.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 May 2026 07:23:49 -0700 (PDT) From: Magnus Lindholm To: richard.henderson@linaro.org, mattst88@gmail.com, linux-kernel@vger.kernel.org, linux-alpha@vger.kernel.org Cc: glaubitz@physik.fu-berlin.de, mcree@orcon.net.nz, ink@unseen.parts, macro@orcam.me.uk, Magnus Lindholm Subject: [PATCH v2 7/8] alpha: enable lockdep hardirq state tracking Date: Fri, 29 May 2026 16:22:03 +0200 Message-ID: <20260529142322.1362438-8-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260529142322.1362438-1-linmag7@gmail.com> References: <20260529142322.1362438-1-linmag7@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Alpha 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. Signed-off-by: Magnus Lindholm --- .../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(-) diff --git a/Documentation/features/locking/lockdep/arch-support.txt b/Docu= mentation/features/locking/lockdep/arch-support.txt index b6b00469f7d0..87a534c89636 100644 --- a/Documentation/features/locking/lockdep/arch-support.txt +++ b/Documentation/features/locking/lockdep/arch-support.txt @@ -6,7 +6,7 @@ ----------------------- | arch |status| ----------------------- - | alpha: | TODO | + | alpha: | ok | | arc: | ok | | arm: | ok | | arm64: | ok | diff --git a/arch/alpha/Kconfig b/arch/alpha/Kconfig index 7ac435c56845..e53ef2d88463 100644 --- a/arch/alpha/Kconfig +++ b/arch/alpha/Kconfig @@ -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 =20 +config LOCKDEP_SUPPORT + def_bool y + menu "System setup" =20 choice diff --git a/arch/alpha/kernel/entry.S b/arch/alpha/kernel/entry.S index 449092a31eef..9f2608de2544 100644 --- a/arch/alpha/kernel/entry.S +++ b/arch/alpha/kernel/entry.S @@ -93,6 +93,19 @@ 4: .endm =20 +.macro LOCKDEP_HARDIRQS_ON_RESTORE +#ifdef CONFIG_PROVE_LOCKING + /* a0 =3D saved PS */ + ldq $16, SP_OFF($sp) + + /* a1 =3D callsite IP for lockdep */ + lda $17, 1f + + jsr $26, lockdep_on_restore + ldgp $gp, 0($26) +1: +#endif +.endm =20 /* * 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 =20 .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 =20 @@ -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 =20 diff --git a/arch/alpha/kernel/irq_alpha.c b/arch/alpha/kernel/irq_alpha.c index d17e44c99df9..736294d3dd51 100644 --- a/arch/alpha/kernel/irq_alpha.c +++ b/arch/alpha/kernel/irq_alpha.c @@ -41,7 +41,7 @@ EXPORT_SYMBOL(perf_irq); * The main interrupt entry point. */ =20 -asmlinkage void=20 +asmlinkage void do_entInt(unsigned long type, unsigned long vector, unsigned long la_ptr, struct pt_regs *regs) { @@ -54,40 +54,78 @@ do_entInt(unsigned long type, unsigned long vector, * (namely LX164). */ local_irq_disable(); + old_regs =3D set_irq_regs(regs); + switch (type) { case 0: #ifdef CONFIG_SMP + irq_enter(); handle_ipi(regs); - return; + irq_exit(); + break; #else irq_err_count++; - printk(KERN_CRIT "Interprocessor interrupt? " - "You must be kidding!\n"); -#endif + pr_crit("Interprocessor interrupt? You must be kidding!\n"); break; +#endif case 1: - old_regs =3D set_irq_regs(regs); + /* handle_irq() already does irq_enter()/irq_exit() */ handle_irq(RTC_IRQ); - set_irq_regs(old_regs); - return; + break; case 2: - old_regs =3D set_irq_regs(regs); + irq_enter(); alpha_mv.machine_check(vector, la_ptr); - set_irq_regs(old_regs); - return; + irq_exit(); + break; case 3: - old_regs =3D set_irq_regs(regs); + irq_enter(); alpha_mv.device_interrupt(vector); - set_irq_regs(old_regs); - return; + irq_exit(); + break; case 4: + irq_enter(); perf_irq(la_ptr, regs); - return; + irq_exit(); + break; default: - printk(KERN_CRIT "Hardware intr %ld %lx? Huh?\n", - type, vector); + pr_crit("Hardware intr %lu %lx? Huh?\n", type, vector); + pr_crit("PC =3D %016lx PS=3D%04lx\n", regs->pc, regs->ps); + break; } - printk(KERN_CRIT "PC =3D %016lx PS=3D%04lx\n", regs->pc, regs->ps); + + set_irq_regs(old_regs); + + /* + * Intentionally no local_irq_enable(): Alpha historically avoids + * enabling at IPL0 here due to PAL/RTI issues (LX164/MILO note). + */ +} + +void notrace lockdep_on_restore(unsigned long ps, + unsigned long ip) +{ +#ifdef CONFIG_PROVE_LOCKING + /* Restoring IPL=3D=3D7 means interrupts remain disabled. */ + if ((ps & 7) =3D=3D 7) + return; + + /* + * If hardware IRQs are already enabled here, then emitting a + * hardirqs-on transition is redundant. + */ + if (!irqs_disabled()) + return; + + /* + * Only emit the transition if lockdep currently believes + * hardirqs are off. + */ + if (lockdep_hardirqs_enabled()) + return; + + lockdep_hardirqs_on_prepare(); + lockdep_hardirqs_on(ip); +#endif } =20 void __init diff --git a/arch/alpha/kernel/proto.h b/arch/alpha/kernel/proto.h index a8bc3ead776b..9b262ef09a3a 100644 --- a/arch/alpha/kernel/proto.h +++ b/arch/alpha/kernel/proto.h @@ -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); =20 /* 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, str= uct pt_regs *); =20 +/* irq_alpha.c */ +extern void notrace lockdep_on_restore(unsigned long ps, unsigned long ip); + /* sys_titan.c */ extern void titan_dispatch_irqs(u64); =20 diff --git a/arch/alpha/kernel/signal.c b/arch/alpha/kernel/signal.c index e62d1d461b1f..ce40a49b8496 100644 --- a/arch/alpha/kernel/signal.c +++ b/arch/alpha/kernel/signal.c @@ -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 thr= ead_flags, { do { if (thread_flags & _TIF_NEED_RESCHED) { + local_irq_enable(); schedule(); } else { local_irq_enable(); --=20 2.53.0 From nobody Mon Jun 8 10:56:39 2026 Received: from mail-lf1-f53.google.com (mail-lf1-f53.google.com [209.85.167.53]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9288E3EEAC4 for ; Fri, 29 May 2026 14:23:52 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064640; cv=none; b=h0zgYt87wIr0QSK6ZUNRHFHNKndNM7CZtvmigVbA6rb6b9i9iM6O6LO48pk8Psb18l0jWN3TbplKDaVPM0lNUhJkqNHi6x9blBYx4HwL//EOZpOuMmgx434eUk/HML6SxtlZkVXfKWVatMZoOX6yDJvVkkKKf/fyOo6i+zzHdqw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1780064640; c=relaxed/simple; bh=OpirQJpTLHX5vgiC/Iqt9cldSr9jkBiZpnCgQoK1U04=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=QHRSx/QobI5X+3+n08N+oyfvViP28JNoUrd+Vqo4HBzYMY1DYJokQykAJLBZEaiOaFt+N295+9okzOSlpIXEiQ2wyxNQw41+Bmm5aifc6SqRVsIlJC4Y3mlVc0O6mxgH00dosqsWOoaGYUt5QQ8L8+S3vgrSvRhi41jlMjKRsLw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=j/8fUnqr; arc=none smtp.client-ip=209.85.167.53 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="j/8fUnqr" Received: by mail-lf1-f53.google.com with SMTP id 2adb3069b0e04-5aa5aba358dso655085e87.2 for ; Fri, 29 May 2026 07:23:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1780064631; x=1780669431; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=ES1x4bbZIbuWfiJUjfoGqhMl01zFUAzDawD7+XjtYvQ=; b=j/8fUnqr4n0QRXOM+Lfu0tSTOchmvvHFNjpHJpcbXk1gdnX9196QXxx2PEaSxMjKD8 gw65zr3/vDdlotmHhUrxG7P1wPdoLXdRfKOwK92qfRwgDjBc5jhO7cdvt/kVFsn1UedK mbsX0XwqsIVeuzaa7PtVElcQKlbdZU5KeVUA5ny/FcXn456KYRqEd1/93k6J62VBl3/m px5qcIe+O0le+sD8ek5mRbhmcQEAING34/ADTGAye3xzlB6KJ4RM96AwUvD4ENkapqKI Gg5c/0Lf9F7wSa/hZbMbJ3vhmMDlfS5bx19n3A3gqlkaG1CwFHRpkXdC7gG+r44sbQCT 6X5w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1780064631; x=1780669431; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=ES1x4bbZIbuWfiJUjfoGqhMl01zFUAzDawD7+XjtYvQ=; b=WLhaQG3b5+Zr/gRW0YUOFIhUhgHrOC67tBaSHFSMq19fd1o9GuQBf7r6q1ugVhSO62 zKBJriwafTD3wmf1ycSY+PuT6+rMi1RTFBgcE+mzh7oa/QH2l3acaBWIXKIL7Y5JAQdc uwbaMR2j6GOCSeo+dZtYBlN35KLINKZzILn0Fy8MKVtMGORsSoihiOuI5p62segCFTvX hxrSyHP9JepMxDexA8Qbz3mPlMNkPnF6G2LITmqw2WTZTXwUkm1KPODJtKB70xrBFUov jm21Mw5WvweIcNcsTCkSvx/BJlBk4BIWwUcE6L74CoVrs5Pe5/Qx2s9QOPMHcrJfGAKD J1Cg== X-Forwarded-Encrypted: i=1; AFNElJ/vdBKDjrbVJN+3/JqdBcmyDey5x3I4EFWMsin+Us1j13ZRle6c6dr+M3if5ps5HEk30HYDN23JRF0X79c=@vger.kernel.org X-Gm-Message-State: AOJu0YwU64BrV/wAWgeK2QbPHBjkquzhk4yAGd4CfiCNlux49nSVrbnD 4zlYKm0cjG/uQE0ycJ5LtrzGSPvJAyjTnVsN8deTy5kpjnum/DUSVctx X-Gm-Gg: Acq92OGeK6ZAsa9+s/N7h/upUXGRUsaVShHR/RHCDiAr/S56pvqW7xiWMX4cSwpajuu OzcU+4+MVmr9M+yeFehWwxq+9KKU5aNZZKw3X5DL0ihFPHiB7P9uv5L8O4qRozG83p56db044zR sKHdY/e+eLNt/hKJT1OSHYm0z8mEHDX77gfCa8Qt3XolHPMni8//0wDuvV8vN8CXxDJkG0YOzlk b4VT0eGqjyupR5yJRLZMqTsr2o5e7xDx/6lBzed2hrsljdYdVyK72PeKWhQ72AKrBOD+zNlI/pR zvXBthZOZ9S5kDX0fbz1pYYw9Tvw1nCppzzXUyjTK4JAJfCltf9H9zMEZob4yQmLcUim8HJ/SI/ dUjGokuHpLkc9NB0fUgJELhjl2q58Jy3VI2cVYVmxao+VsfaEVBzqBXVx8Dfp/bTais1ZO8FXzL QY8SlL4asYexk8j+SKAxZXBJOmVO7oe5kss3yOCVNjM/ykBVreqFCKKJ6EXcMPSIMiJETVfK1li TaBDVwlfpb/SXfL5lxmMLeFkJfPDBKkXZdDm5Q4RwMyzg== X-Received: by 2002:a05:6512:3d02:b0:5aa:59e0:6c65 with SMTP id 2adb3069b0e04-5aa6090e2f4mr5985e87.35.1780064630413; Fri, 29 May 2026 07:23:50 -0700 (PDT) Received: from buildhost.darklands.se (h-94-254-104-176.A469.priv.bahnhof.se. [94.254.104.176]) by smtp.gmail.com with ESMTPSA id 2adb3069b0e04-5aa5b0687e2sm310433e87.6.2026.05.29.07.23.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 29 May 2026 07:23:49 -0700 (PDT) From: Magnus Lindholm To: richard.henderson@linaro.org, mattst88@gmail.com, linux-kernel@vger.kernel.org, linux-alpha@vger.kernel.org Cc: glaubitz@physik.fu-berlin.de, mcree@orcon.net.nz, ink@unseen.parts, macro@orcam.me.uk, Magnus Lindholm Subject: [PATCH v2 8/8] alpha: enable GENERIC_ENTRY and GENERIC_IRQ_ENTRY Date: Fri, 29 May 2026 16:22:04 +0200 Message-ID: <20260529142322.1362438-9-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260529142322.1362438-1-linmag7@gmail.com> References: <20260529142322.1362438-1-linmag7@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Wire 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. Signed-off-by: Magnus Lindholm --- arch/alpha/Kconfig | 3 + 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 | 135 ++++++----- arch/alpha/kernel/signal.c | 155 ++++++++++--- 12 files changed, 367 insertions(+), 365 deletions(-) create mode 100644 arch/alpha/include/asm/entry-common.h create mode 100644 arch/alpha/include/asm/stacktrace.h diff --git a/arch/alpha/Kconfig b/arch/alpha/Kconfig index e53ef2d88463..74795e22aafa 100644 --- a/arch/alpha/Kconfig +++ b/arch/alpha/Kconfig @@ -2,6 +2,9 @@ config ALPHA bool default y + select GENERIC_IRQ_ENTRY + 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 diff --git a/arch/alpha/include/asm/entry-common.h b/arch/alpha/include/asm= /entry-common.h new file mode 100644 index 000000000000..a811c73454d2 --- /dev/null +++ b/arch/alpha/include/asm/entry-common.h @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef ARCH_ALPHA_ENTRY_COMMON_H +#define ARCH_ALPHA_ENTRY_COMMON_H + +#include /* For on_thread_stack() */ +#include + +#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 *re= gs, + unsigned long ti_work) +{ +} +#endif diff --git a/arch/alpha/include/asm/ptrace.h b/arch/alpha/include/asm/ptrac= e.h index 8e0a589e2d15..430e8dc27ff7 100644 --- a/arch/alpha/include/asm/ptrace.h +++ b/arch/alpha/include/asm/ptrace.h @@ -3,7 +3,7 @@ #define _ASMAXP_PTRACE_H =20 #include - +#include =20 #define arch_has_single_step() (1) #define user_mode(regs) (((regs)->ps & 8) !=3D 0) @@ -17,7 +17,9 @@ #define current_pt_regs() \ ((struct pt_regs *) ((char *)current_thread_info() + 2*PAGE_SIZE) - 1) =20 -#define force_successful_syscall_return() (current_pt_regs()->r0 =3D 0) +#define force_successful_syscall_return() \ + (current_thread_info()->syscall_meta \ + |=3D ALPHA_SYSCALL_META_FORCE_SUCCESS) =20 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; } =20 +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 diff --git a/arch/alpha/include/asm/stacktrace.h b/arch/alpha/include/asm/s= tacktrace.h new file mode 100644 index 000000000000..f006d6f00fd0 --- /dev/null +++ b/arch/alpha/include/asm/stacktrace.h @@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_ALPHA_STACKTRACE_H +#define _ASM_ALPHA_STACKTRACE_H + +#include +#include + +#include +#include +#include + +static __always_inline bool on_thread_stack(void) +{ + unsigned long base =3D (unsigned long)current->stack; + unsigned long sp =3D (unsigned long)current_stack_pointer; + + return !((base ^ sp) & ~(THREAD_SIZE - 1)); +} + +#endif /* _ASM_ALPHA_STACKTRACE_H */ diff --git a/arch/alpha/include/asm/syscall.h b/arch/alpha/include/asm/sysc= all.h index 1e78cbd46faf..c1394910f584 100644 --- a/arch/alpha/include/asm/syscall.h +++ b/arch/alpha/include/asm/syscall.h @@ -8,6 +8,8 @@ #include #include =20 +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 ta= sk_struct *task, } =20 /* 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 =3D regs->r2; + unsigned long nr =3D task_thread_info(task)->syscall_saved_nr; + + regs->r1 =3D nr; } =20 +static inline bool arch_syscall_is_vdso_sigreturn(struct pt_regs *regs) +{ + return false; +} #endif /* _ASM_ALPHA_SYSCALL_H */ diff --git a/arch/alpha/include/asm/thread_info.h b/arch/alpha/include/asm/= thread_info.h index 1552ecca8520..d781ac79106d 100644 --- a/arch/alpha/include/asm/thread_info.h +++ b/arch/alpha/include/asm/thread_info.h @@ -12,16 +12,21 @@ #endif =20 #ifndef __ASSEMBLER__ + struct thread_info { struct pcb_struct pcb; /* palcode state */ =20 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 */ =20 unsigned cpu; /* current CPU */ - int preempt_count; /* 0 =3D> preemptable, <0 =3D> BUG */ + int preempt_count; /* 0 =3D> preemptable, <0 =3D> BUG */ unsigned int status; /* thread-synchronous flags */ + unsigned long syscall_saved_r19; + unsigned long syscall_meta; + unsigned long syscall_saved_nr; =20 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) =20 +#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 */ =20 @@ -80,22 +89,7 @@ register unsigned long *current_stack_pointer __asm__ ("= $30"); #define _TIF_SECCOMP (1< restart allowed - * $26 =3D 1 =3D> restart NOT allowed - * $18 =3D preserved syscall nr (regs->r2) if restart allowed, else= 0 - */ -.macro SYSCALL_SKIP_RETURN_RESTART_GATE - /* Fix up invalid "-1 success" return state. */ - ldq $19, 72($sp) /* a3 */ - bne $19, 1f /* already error =3D> skip fixup */ - - ldq $20, 0($sp) /* r0 */ - lda $21, -1($31) - cmpeq $20, $21, $22 - beq $22, 1f /* r0 !=3D -1 =3D> skip fixup */ - - - lda $20, ENOSYS($31) - stq $20, 0($sp) /* r0 =3D ENOSYS */ - lda $19, 1($31) - stq $19, 72($sp) /* a3 =3D 1 */ -1: - /* Restart gating: success is never restartable here. */ - ldq $19, 72($sp) /* a3 */ - beq $19, 3f /* success =3D> not restartable */ - - ldq $20, 0($sp) /* r0 (positive errno if a3=3D=3D1) */ - lda $21, ERESTARTSYS($31) - cmpeq $20, $21, $22 - bne $22, 2f - lda $21, ERESTARTNOINTR($31) - cmpeq $20, $21, $22 - bne $22, 2f - lda $21, ERESTARTNOHAND($31) - cmpeq $20, $21, $22 - bne $22, 2f - lda $21, ERESTART_RESTARTBLOCK($31) - cmpeq $20, $21, $22 - bne $22, 2f - -3: /* Not a restart code (or success) =3D> restart NOT allowed. */ - addq $31, 1, $26 /* $26=3D1 =3D> restart NOT allowed */ - mov 0, $18 - br 4f - -2: /* Restart allowed. */ - ldq $18, 16($sp) /* preserved syscall nr (regs->r2) */ - mov $31, $26 /* $26=3D0 =3D> restart allowed */ - br 4f -4: -.endm - -.macro LOCKDEP_HARDIRQS_ON_RESTORE +.macro LOCKDEP_HARDIRQS_ON_RESTORE psreg #ifdef CONFIG_PROVE_LOCKING /* a0 =3D saved PS */ - ldq $16, SP_OFF($sp) + ldq $16, \psreg =20 /* a1 =3D callsite IP for lockdep */ lda $17, 1f @@ -248,7 +191,7 @@ CFI_START_OSF_FRAME entInt SAVE_ALL lda $8, 0x3fff - lda $26, ret_from_sys_call + lda $26, ret_from_exception bic $sp, $8, $8 mov $sp, $19 jsr $31, do_entInt @@ -257,7 +200,7 @@ CFI_END_OSF_FRAME entInt CFI_START_OSF_FRAME entArith SAVE_ALL lda $8, 0x3fff - lda $26, ret_from_sys_call + lda $26, ret_from_exception bic $sp, $8, $8 mov $sp, $18 jsr $31, do_entArith @@ -305,13 +248,13 @@ CFI_START_OSF_FRAME entMM .cfi_restore $15 .cfi_adjust_cfa_offset -64 /* finish up the syscall as normal. */ - br ret_from_sys_call + br ret_from_exception CFI_END_OSF_FRAME entMM =20 CFI_START_OSF_FRAME entIF SAVE_ALL lda $8, 0x3fff - lda $26, ret_from_sys_call + lda $26, ret_from_exception bic $sp, $8, $8 mov $sp, $17 jsr $31, do_entIF @@ -440,7 +383,7 @@ CFI_START_OSF_FRAME entUna .cfi_restore $28 .cfi_restore $29 .cfi_adjust_cfa_offset -256 - LOCKDEP_HARDIRQS_ON_RESTORE + LOCKDEP_HARDIRQS_ON_RESTORE SP_OFF($sp) call_pal PAL_rti =20 .align 4 @@ -487,18 +430,19 @@ entUnaUser: .cfi_restore $14 .cfi_restore $15 .cfi_adjust_cfa_offset -64 - br ret_from_sys_call + br ret_from_exception CFI_END_OSF_FRAME entUna =20 CFI_START_OSF_FRAME entDbg SAVE_ALL lda $8, 0x3fff - lda $26, ret_from_sys_call + lda $26, ret_from_exception bic $sp, $8, $8 mov $sp, $16 jsr $31, do_entDbg CFI_END_OSF_FRAME entDbg =20 + /* * The system call entry point is special. Most importantly, it looks * like a function call to userspace as far as clobbered registers. We @@ -516,9 +460,7 @@ CFI_END_OSF_FRAME entDbg * For seccomp/ptrace/generic syscall helpers we track the syscall * number separately: * - regs->r1: current (mutable) syscall number (may be changed or set t= o -1) - * - regs->r2: original syscall number for restart/rollback * - * On entry PAL provides the syscall number in r0; copy it into r1/r2. */ =20 .align 4 @@ -531,203 +473,117 @@ CFI_END_OSF_FRAME entDbg .cfi_rel_offset $gp, 16 entSys: SAVE_ALL - ldq $1, 0($sp) /* syscall nr from saved r0 */ - stq $1, 8($sp) /* regs->r1 =3D shadow syscall nr */ - stq $1, 16($sp) /* regs->r2 =3D restart syscall nr */ - /* Syscalls always enter from user mode: snapshot USP into pt_regs->usp */ + ldq $1, 0($sp) /* syscall nr from saved r0 */ + stq $1, 8($sp) /* regs->r1 =3D shadow syscall nr */ + mov $0, $8 call_pal PAL_rdusp - stq $0, PT_REGS_USP($sp) + stq $0, PT_REGS_USP($sp) mov $8, $0 =20 - lda $8, 0x3fff bic $sp, $8, $8 - lda $4, NR_syscalls($31) + stq $16, SP_OFF+24($sp) - lda $5, sys_call_table - lda $27, sys_ni_syscall - cmpult $0, $4, $4 - ldl $3, TI_FLAGS($8) stq $17, SP_OFF+32($sp) - s8addq $0, $5, $5 stq $18, SP_OFF+40($sp) - .cfi_rel_offset $16, SP_OFF+24 - .cfi_rel_offset $17, SP_OFF+32 - .cfi_rel_offset $18, SP_OFF+40 - lda $6, _TIF_SYSCALL_WORK - and $3, $6, $3 - bne $3, strace =20 - beq $4, 1f - ldq $27, 0($5) -1: ldq $0, 8($sp) /* syscall nr shadow (regs->r1) */ + mov $0, $1 + lda $16, 7 + call_pal PAL_swpipl + mov $1, $0 + mov $sp, $16 + mov $0, $17 /* pv =3D selected syscall function */ + + DO_SWITCH_STACK + jsr $26, alpha_syscall_enter_select + ldgp $gp, 0($26) + UNDO_SWITCH_STACK + + /* + * C returned syscall function pointer in $0. + * It also stored SKIP in TI_SYSCALL_META if dispatch is skipped. + */ + lda $8, 0x3fff + bic $sp, $8, $8 + ldq $3, TI_SYSCALL_META($8) + lda $6, ALPHA_SYSCALL_META_SKIP + and $3, $6, $6 + bne $6, skip_dispatch + + + mov $0, $27 + ldq $16, SP_OFF+24($sp) + ldq $17, SP_OFF+32($sp) + ldq $18, SP_OFF+40($sp) + ldq $19, 72($sp) + ldq $20, 80($sp) + ldq $21, 88($sp) =20 jsr $26, ($27), sys_ni_syscall ldgp $gp, 0($26) - blt $0, $syscall_error /* the call failed */ -$ret_success: - stq $0, 0($sp) - stq $31, 72($sp) /* a3=3D0 =3D> no error */ =20 - .align 4 - .globl ret_from_sys_call -ret_from_sys_call: - cmovne $26, 0, $18 /* $18 =3D 0 =3D> non-restartable */ - ldq $0, SP_OFF($sp) - and $0, 8, $0 - beq $0, ret_to_kernel -ret_to_user: - /* Make sure need_resched and sigpending don't change between - sampling and the rti. */ - lda $16, 7 - call_pal PAL_swpipl - ldl $17, TI_FLAGS($8) - and $17, _TIF_WORK_MASK, $2 - bne $2, work_pending +skip_dispatch: + mov $0, $17 /* raw ret; ignored if SKIP is set */ + mov $sp, $16 /* regs */ + + DO_SWITCH_STACK + jsr $26, alpha_finish_syscall_to_user_mode + ldgp $gp, 0($26) + UNDO_SWITCH_STACK + restore_all: + lda $8, 0x3fff + bic $sp, $8, $8 ldl $2, TI_STATUS($8) and $2, TS_SAVED_FP | TS_RESTORE_FP, $3 bne $3, restore_fpu restore_other: .cfi_remember_state - LOCKDEP_HARDIRQS_ON_RESTORE RESTORE_ALL call_pal PAL_rti =20 -ret_to_kernel: - .cfi_restore_state - lda $16, 7 - call_pal PAL_swpipl - br restore_other - - .align 3 -$syscall_error: - /* Restart syscall nr comes from saved r2 (preserved even if r0 ov= erwritten). */ - ldq $18, 16($sp) /* old syscall nr for restart */ - - ldq $19, 72($sp) /* .. and this a3 */ - subq $31, $0, $0 /* with error in v0 */ - addq $31, 1, $1 /* set a3 for errno return */ - stq $0, 0($sp) - mov $31, $26 /* tell "ret_from_sys_call" we can restart */ - stq $1, 72($sp) /* a3 for return */ - br ret_from_sys_call - -/* - * Do all cleanup when returning from all interrupts and system calls. - * - * Arguments: - * $8: current. - * $17: TI_FLAGS. - * $18: The old syscall number, or zero if this is not a return - * from a syscall that errored and is possibly restartable. - * $19: The old a3 value - */ - - .align 4 - .type work_pending, @function -work_pending: - and $17, _TIF_NOTIFY_RESUME | _TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL, $2 - bne $2, $work_notifysig - -$work_resched: - /* - * We can get here only if we returned from syscall without SIGPENDING - * or got through work_notifysig already. Either case means no syscall - * restarts for us, so let $18 and $19 burn. - */ - jsr $26, alpha_schedule_user_work - mov 0, $18 - br ret_to_user +ret_to_user_from_syscall: + lda $8, 0x3fff + bic $sp, $8, $8 =20 -$work_notifysig: mov $sp, $16 DO_SWITCH_STACK - jsr $26, do_work_pending + jsr $26, alpha_syscall_exit_to_user_mode + ldgp $gp, 0($26) UNDO_SWITCH_STACK br restore_all =20 -/* - * PTRACE syscall handler - */ - .align 4 - .type strace, @function -strace: - /* set up signal stack, call syscall_trace */ - // NB: if anyone adds preemption, this block will need to be protected - ldl $1, TI_STATUS($8) - and $1, TS_SAVED_FP, $3 - or $1, TS_SAVED_FP, $2 - bne $3, 1f - stl $2, TI_STATUS($8) - bsr $26, __save_fpu -1: - DO_SWITCH_STACK - jsr $26, syscall_trace_enter /* returns the syscall number */ - UNDO_SWITCH_STACK - - stq $0, 8($sp) /* regs->r1 =3D shadow syscall nr */ - - /* get the arguments back.. */ - ldq $16, SP_OFF+24($sp) - ldq $17, SP_OFF+32($sp) - ldq $18, SP_OFF+40($sp) - ldq $19, 72($sp) - ldq $20, 80($sp) - ldq $21, 88($sp) + .globl ret_from_sys_call +ret_from_sys_call: + ldq $0, SP_OFF($sp) + and $0, 8, $0 + beq $0, ret_to_kernel + br ret_to_user_from_syscall =20 - /* nr =3D=3D -1: internal skip-dispatch or userspace syscall(-1)? */ - lda $6, -1($31) - cmpeq $0, $6, $6 - bne $6, $strace_skip_call /* nr =3D=3D -1 =3D> dispatch */ - - /* get the system call pointer.. */ - lda $1, NR_syscalls($31) - lda $2, sys_call_table - lda $27, sys_ni_syscall - cmpult $0, $1, $1 - s8addq $0, $2, $2 - beq $1, 1f - ldq $27, 0($2) -1: jsr $26, ($27), sys_gettimeofday -ret_from_straced: - ldgp $gp, 0($26) +ret_from_exception: + ldq $0, SP_OFF($sp) + and $0, 8, $0 + beq $0, ret_to_kernel + br ret_to_user_from_exception =20 - /* check return.. */ - blt $0, $strace_error /* the call failed */ -$strace_success: - stq $31, 72($sp) /* a3=3D0 =3D> no error */ - stq $0, 0($sp) /* save return value */ +ret_to_user_from_exception: =20 -$strace_skip_call: - SYSCALL_SKIP_RETURN_RESTART_GATE + mov $sp, $16 DO_SWITCH_STACK - jsr $26, syscall_trace_leave + jsr $26, alpha_exit_to_user_mode + ldgp $gp, 0($26) UNDO_SWITCH_STACK - br $31, ret_from_sys_call - - .align 3 -$strace_error: - ldq $18, 16($sp) /* restart syscall nr */ - ldq $19, 72($sp) /* .. and this a3 */ - - subq $31, $0, $0 /* with error in v0 */ - addq $31, 1, $1 /* set a3 for errno return */ - stq $0, 0($sp) - stq $1, 72($sp) /* a3 for return */ + br restore_all =20 - DO_SWITCH_STACK - mov $18, $9 /* save old syscall number */ - mov $19, $10 /* save old a3 */ - jsr $26, syscall_trace_leave - mov $9, $18 - mov $10, $19 - UNDO_SWITCH_STACK +ret_to_kernel: + .cfi_restore_state + lda $16, 7 + call_pal PAL_swpipl + LOCKDEP_HARDIRQS_ON_RESTORE SP_OFF($sp) + br restore_other =20 - mov $31, $26 /* tell "ret_from_sys_call" we can restart */ - br ret_from_sys_call CFI_END_OSF_FRAME entSys =20 /* @@ -815,7 +671,6 @@ restore_fpu: br restore_other #undef V =20 -=0C /* * The meat of the context switch code. */ @@ -851,7 +706,7 @@ alpha_switch_to: .align 4 .ent ret_from_fork ret_from_fork: - lda $26, ret_to_user + lda $26, ret_to_user_from_exception mov $17, $16 jmp $31, schedule_tail .end ret_from_fork @@ -868,7 +723,7 @@ ret_from_kernel_thread: mov $9, $27 mov $10, $16 jsr $26, ($9) - br $31, ret_to_user + br $31, ret_to_user_from_exception .end ret_from_kernel_thread =20 =0C @@ -910,12 +765,9 @@ fork_like clone3 .ent sys_\name sys_\name: .prologue 0 - lda $9, ret_from_straced - cmpult $26, $9, $9 + mov $sp, $10 lda $sp, -SWITCH_STACK_SIZE($sp) jsr $26, do_\name - bne $9, 1f - jsr $26, syscall_trace_leave 1: br $1, undo_switch_stack br ret_from_sys_call .end sys_\name diff --git a/arch/alpha/kernel/irq_alpha.c b/arch/alpha/kernel/irq_alpha.c index 736294d3dd51..ac941172ae66 100644 --- a/arch/alpha/kernel/irq_alpha.c +++ b/arch/alpha/kernel/irq_alpha.c @@ -105,20 +105,24 @@ void notrace lockdep_on_restore(unsigned long ps, unsigned long ip) { #ifdef CONFIG_PROVE_LOCKING - /* Restoring IPL=3D=3D7 means interrupts remain disabled. */ + /* + * If PAL_rti will restore IPL =3D=3D 7, IRQs remain disabled. + * There is no hardirqs-on transition to annotate. + */ if ((ps & 7) =3D=3D 7) return; =20 /* - * 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; =20 /* - * 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; diff --git a/arch/alpha/kernel/proto.h b/arch/alpha/kernel/proto.h index 9b262ef09a3a..f138bd494628 100644 --- a/arch/alpha/kernel/proto.h +++ b/arch/alpha/kernel/proto.h @@ -2,6 +2,7 @@ #include #include #include +#include =20 /* Prototypes of functions used across modules here in this directory. */ =20 @@ -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); =20 /* 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 lon= g 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 r= et); +extern unsigned long alpha_syscall_enter_select(struct pt_regs *regs, long= syscall); =20 /* traps.c */ extern void dik_show_regs(struct pt_regs *regs, unsigned long *r9_15); diff --git a/arch/alpha/kernel/ptrace.c b/arch/alpha/kernel/ptrace.c index 69eb337347df..d4a8937985be 100644 --- a/arch/alpha/kernel/ptrace.c +++ b/arch/alpha/kernel/ptrace.c @@ -134,18 +134,51 @@ get_reg_addr(struct task_struct * task, unsigned long= regno) /* * Get contents of register REGNO in task TASK. */ -static unsigned long -get_reg(struct task_struct * task, unsigned long regno) + +static bool +valid_regno(unsigned long regno) { - /* Special hack for fpcr -- combine hardware and software bits. */ + switch (regno) { + case 0 ... 31: + case 63: + case 65: + return true; + default: + return false; + } +} + +static long +get_reg(struct task_struct *task, unsigned long regno) +{ + unsigned long *addr; + + if (!valid_regno(regno)) + return -EIO; + + /* + * Special hack for fpcr -- combine hardware and software bits. + */ if (regno =3D=3D 63) { - unsigned long fpcr =3D *get_reg_addr(task, regno); - unsigned long swcr - =3D task_thread_info(task)->ieee_state & IEEE_SW_MASK; + unsigned long fpcr; + unsigned long swcr; + + addr =3D get_reg_addr(task, regno); + if (!addr) + return -EIO; + + fpcr =3D *addr; + swcr =3D task_thread_info(task)->ieee_state & IEEE_SW_MASK; swcr =3D swcr_update_status(swcr, fpcr); + return fpcr | swcr; } - return *get_reg_addr(task, regno); + + addr =3D get_reg_addr(task, regno); + if (!addr) + return -EIO; + + return *addr; } =20 static void alpha_elf_fpregs_get(struct task_struct *target, @@ -271,14 +304,15 @@ static void alpha_elf_gregs_set(struct task_struct *c= hild, pt->r19 =3D 1; } =20 - -/* - * Write contents of register REGNO in task TASK. - */ static int put_reg(struct task_struct *task, unsigned long regno, unsigned long data) { struct pt_regs *regs =3D task_pt_regs(task); + unsigned long *addr; + unsigned long old_r0 =3D regs->r0; + + if (regno =3D=3D 31) + return 0; =20 if (regno =3D=3D 63) { task_thread_info(task)->ieee_state @@ -287,24 +321,30 @@ put_reg(struct task_struct *task, unsigned long regno= , unsigned long data) data =3D (data & FPCR_DYN_MASK) | ieee_swcr_to_fpcr(data); } =20 - *get_reg_addr(task, regno) =3D data; + addr =3D get_reg_addr(task, regno); + if (!addr) + return -EIO; + + *addr =3D data; =20 /* * Alpha historically exposes r0/v0 as the syscall number at a * syscall-entry stop. The generic-entry conversion keeps the - * mutable syscall number in regs->r1, so old ptrace users such - * as strace that skip a syscall by poking r0 to -1 must also - * update the internal shadow syscall number. - * - * Do not mirror other r0 writes. strace later pokes r0 to the - * injected return value, e.g. 42, while r1 must remain -1. + * mutable syscall number in regs->r1. */ =20 - if (regno =3D=3D 0 && data =3D=3D (unsigned long)-1) { + if (regno =3D=3D 0 && regs->r1 =3D=3D old_r0 && + (data =3D=3D (unsigned long)-1 || + (regs->r19 =3D=3D 0 && data < NR_syscalls))) { regs->r1 =3D data; - regs->r19 =3D 0; - } =20 + /* + * Keep the skip path looking like a clean entry-side syscall + * rewrite. Do not touch r19 for ordinary syscall substitution. + */ + if (data =3D=3D (unsigned long)-1) + regs->r19 =3D 0; + } return 0; } =20 @@ -435,25 +475,24 @@ long arch_ptrace(struct task_struct *child, long requ= est, =20 switch (request) { /* When I and D space are separate, these will need to be fixed. */ - case PTRACE_PEEKTEXT: /* read word at location addr. */ + case PTRACE_PEEKTEXT: case PTRACE_PEEKDATA: copied =3D ptrace_access_vm(child, addr, &tmp, sizeof(tmp), FOLL_FORCE); ret =3D -EIO; if (copied !=3D sizeof(tmp)) break; - =09 force_successful_syscall_return(); ret =3D tmp; break; =20 - /* Read register number ADDR. */ case PTRACE_PEEKUSR: - force_successful_syscall_return(); ret =3D get_reg(child, addr); - DBG(DBG_MEM, ("peek $%lu->%#lx\n", addr, ret)); - break; + if (ret =3D=3D -EIO) + break; =20 + force_successful_syscall_return(); + break; /* When I and D space are separate, this will have to be fixed. */ case PTRACE_POKETEXT: /* write the word at location addr. */ case PTRACE_POKEDATA: @@ -471,47 +510,6 @@ long arch_ptrace(struct task_struct *child, long reque= st, return ret; } =20 -asmlinkage unsigned long syscall_trace_enter(void) -{ - struct pt_regs *regs =3D current_pt_regs(); - - if (test_thread_flag(TIF_SYSCALL_TRACE) && - ptrace_report_syscall_entry(regs)) { - syscall_set_nr(current, regs, -1); - if (regs->r19 =3D=3D 0 && regs->r0 =3D=3D (unsigned long)-1) - syscall_set_return_value(current, regs, -ENOSYS, 0); - return -1UL; - } - - /* - * Do the secure computing after ptrace; failures should be fast. - * If this fails, seccomp may already have set up the return value - * (e.g. SECCOMP_RET_ERRNO / TRACE). - */ - if (secure_computing() =3D=3D -1) { - if (regs->r19 =3D=3D 0 && regs->r0 =3D=3D (unsigned long)-1) - syscall_set_return_value(current, regs, -ENOSYS, 0); - syscall_set_nr(current, regs, -1); - return -1UL; - } - -#ifdef CONFIG_AUDITSYSCALL - audit_syscall_entry(syscall_get_nr(current, regs), - regs->r16, regs->r17, regs->r18, regs->r19); -#endif - return syscall_get_nr(current, regs); -} - - - -asmlinkage void -syscall_trace_leave(void) -{ - audit_syscall_exit(current_pt_regs()); - if (test_thread_flag(TIF_SYSCALL_TRACE)) - ptrace_report_syscall_exit(current_pt_regs(), 0); -} - /* * Minimal regset support for Alpha. * @@ -522,7 +520,6 @@ syscall_trace_leave(void) * regset_get should return 0 on success. So call dump_elf_thread() * directly and return membuf_write()'s result. */ - static int alpha_regset_set(struct task_struct *target, const struct user_regset *regset, unsigned int pos, unsigned int count, diff --git a/arch/alpha/kernel/signal.c b/arch/alpha/kernel/signal.c index ce40a49b8496..9dae17f288c4 100644 --- a/arch/alpha/kernel/signal.c +++ b/arch/alpha/kernel/signal.c @@ -27,10 +27,9 @@ #include #include #include - +#include #include "proto.h" =20 - #define DEBUG_SIG 0 =20 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) @@ -41,14 +40,6 @@ 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; @@ -465,6 +456,7 @@ syscall_restart(unsigned long r0, unsigned long r19, fallthrough; case ERESTARTNOINTR: regs->r0 =3D r0; /* reset v0 and a3 and replay syscall */ + regs->r1 =3D r0; regs->r19 =3D r19; regs->pc -=3D 4; break; @@ -488,7 +480,7 @@ syscall_restart(unsigned long r0, unsigned long r19, * restart. "r0" is also used as an indicator whether we can restart at * all (if we get here from anything but a syscall return, it will be 0) */ -static void +void do_signal(struct pt_regs *regs, unsigned long r0, unsigned long r19) { unsigned long single_stepping =3D ptrace_cancel_bpt(current); @@ -511,12 +503,14 @@ do_signal(struct pt_regs *regs, unsigned long r0, uns= igned long r19) case ERESTARTNOINTR: /* Reset v0 and a3 and replay syscall. */ regs->r0 =3D r0; + regs->r1 =3D r0; regs->r19 =3D r19; regs->pc -=3D 4; break; case ERESTART_RESTARTBLOCK: /* Set v0 to the restart_syscall and replay */ regs->r0 =3D __NR_restart_syscall; + regs->r1 =3D __NR_restart_syscall; regs->pc -=3D 4; break; } @@ -527,27 +521,124 @@ do_signal(struct pt_regs *regs, unsigned long r0, un= signed long r19) ptrace_set_bpt(current); /* re-set breakpoint */ } =20 -void -do_work_pending(struct pt_regs *regs, unsigned long thread_flags, - unsigned long r0, unsigned long r19) +asmlinkage void alpha_exit_to_user_mode(struct pt_regs *regs) { - do { - if (thread_flags & _TIF_NEED_RESCHED) { - local_irq_enable(); - schedule(); - } else { - local_irq_enable(); - if (thread_flags & (_TIF_SIGPENDING|_TIF_NOTIFY_SIGNAL)) { - preempt_disable(); - save_fpu(); - preempt_enable(); - do_signal(regs, r0, r19); - r0 =3D 0; - } else { - resume_user_mode_work(regs); - } + local_irq_disable(); + irqentry_exit_to_user_mode_prepare(regs); + exit_to_user_mode(); +} + +/* + * Syscall return reaches here after Alpha-specific r0/a3 result encoding. + * Delegate syscall-exit work and final exit-to-user handling to generic + * entry code; low-level PAL restore remains in assembly. + */ +asmlinkage void alpha_syscall_exit_to_user_mode(struct pt_regs *regs) +{ + syscall_exit_to_user_mode(regs); +} + +void arch_do_signal_or_restart(struct pt_regs *regs) +{ + struct thread_info *ti =3D current_thread_info(); + + do_signal(regs, ti->syscall_saved_nr, ti->syscall_saved_r19); +} + +asmlinkage unsigned long +alpha_syscall_enter_select(struct pt_regs *regs, long syscall) +{ + struct thread_info *ti =3D current_thread_info(); + unsigned long work; + unsigned long nr; + unsigned long fn =3D (unsigned long)sys_ni_syscall; + + ti->syscall_meta =3D 0; + ti->syscall_saved_nr =3D syscall; + + if (!(ti->status & TS_SAVED_FP)) { + ti->status |=3D TS_SAVED_FP; + __save_fpu(); + } + + work =3D READ_ONCE(ti->syscall_work) & SYSCALL_WORK_ENTER; + + nr =3D syscall_enter_from_user_mode(regs, syscall); + + syscall_set_nr(current, regs, nr); + /* + * In the unified path, nr =3D=3D -1 is ambiguous: + * - without syscall work: syscall(-1), dispatch to sys_ni_syscall + * - with syscall work: ptrace/seccomp skip marker + */ + if (work && (long)nr =3D=3D -1L) { + ti->syscall_meta =3D ALPHA_SYSCALL_META_SKIP; + return fn; /* ignored by asm when SKIP is set */ + } + + instrumentation_begin(); + if (likely(nr < (unsigned long)NR_syscalls)) { + nr =3D array_index_nospec(nr, NR_syscalls); + fn =3D (unsigned long)sys_call_table[nr]; + } + instrumentation_end(); + + return fn; +} + +asmlinkage noinstr void +alpha_finish_syscall_to_user_mode(struct pt_regs *regs, long ret) +{ + struct thread_info *ti =3D current_thread_info(); + unsigned long meta =3D ti->syscall_meta; + + ti->syscall_meta =3D 0; + ti->syscall_saved_r19 =3D regs->r19; + + instrumentation_begin(); + + if (meta & ALPHA_SYSCALL_META_SKIP) { + /* + * Skip-dispatch path: ptrace/seccomp may already have installed + * the return state in r0/r19. Preserve it unless the syscall was + * skipped with no explicit return value. + * + * Generic PTRACE_SET_SYSCALL_INFO changes only the syscall-number + * shadow, so r1 =3D=3D -1 while r0 still contains the original Alpha + * syscall number. Legacy PTRACE_POKEUSR based skipping can leave + * r0 =3D=3D -1 with a3/r19 still indicating success. Both represent + * an unhandled skipped syscall and should become ENOSYS/a3=3D1. + */ + if (regs->r1 =3D=3D (unsigned long)-1 && + (regs->r0 =3D=3D ti->syscall_saved_nr || + regs->r0 =3D=3D (unsigned long)-1)) { + regs->r0 =3D ENOSYS; + regs->r19 =3D 1; } - local_irq_disable(); - thread_flags =3D read_thread_flags(); - } while (thread_flags & _TIF_WORK_MASK); + + instrumentation_end(); + + syscall_exit_to_user_mode(regs); + return; + } + + /* + * Some successful syscalls, notably legacy ptrace PEEK requests, + * return arbitrary data in r0. That data may have the bit pattern + * of a negative errno, so do not infer failure from ret < 0 when + * arch code explicitly requested a successful Alpha return. + */ + if (meta & ALPHA_SYSCALL_META_FORCE_SUCCESS) { + regs->r0 =3D ret; + regs->r19 =3D 0; + } else if (ret < 0) { + regs->r0 =3D -ret; + regs->r19 =3D 1; + } else { + regs->r0 =3D ret; + regs->r19 =3D 0; + } + + instrumentation_end(); + syscall_exit_to_user_mode(regs); } --=20 2.53.0