From nobody Thu Jun 18 21:14:56 2026 Received: from mail-lf1-f47.google.com (mail-lf1-f47.google.com [209.85.167.47]) (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 25AF431F983 for ; Sun, 17 May 2026 21:40:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.47 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054004; cv=none; b=A+FkTprq3kAA3OmRD4PJE23OByHISB+RwXfw3L/1mr5b8GL0WUMCakHuXHTWpEHhtVWuVCsLz6KMTJCSZeiWfXEpclaqerzZLDFLrscjE9+fDJEnhsjTMrbSntEOLBv7xcRpo0+3lQ9azVF/jZVrH24yGwGyzf87RNOzukg8haw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054004; c=relaxed/simple; bh=6pLEKfmltNBR/DJwcFKXTHaS/L9LNQsd8GiZjWVlYTY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=MnhLl7yMHgGE1I/uNZ7aaOqSqXyjp6Y5luhVFHFA0EbTIAwuYyMy2y1fmOZWmbeJjchjq6V+o4r3fRrj/5Q9+vJm87wj79HHf2sLEZ3Wv7Gp9+z1jwOHP6gwnoxdCYvM/jBkPRd4zfIzjlHvHWctjB2qhQ4WEBSD0SZ36/K7mqA= 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=Uncq9ZI9; arc=none smtp.client-ip=209.85.167.47 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="Uncq9ZI9" Received: by mail-lf1-f47.google.com with SMTP id 2adb3069b0e04-5a8fbe18b1dso2573029e87.2 for ; Sun, 17 May 2026 14:40:01 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1779054000; x=1779658800; 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=Uncq9ZI9faMu9ZxL9IdgS0o5CiXAoiUSCcKBpw0XLVN8eIKfWUR7ISNuGgU0O7LxMX y6arhA7aHAd3cMAls+LRmKMJTSsGqqutluNHC4JGXnRX9IWn63xElHuAdZfK+ljacTaT eMr/cIjk8YF35f2CHoHAOw2vnGY/TpOLh+SW1e3x3nsr3lqS/Se+p4c+s3QnVzLYun9q ktbwmewZEg459Aq8zckH+UQZRBOXfjSYhGv2ZEjXQHpvJFW/FGi2GyrNjLzo60lxeZYS +iRM8ruMzOvrmkVu8NlaE017+gB5VEyfnbExVH0f+47jGj9yqSn6Bi/ix/D9+bGBnXbX cpGQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779054000; x=1779658800; 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=FBpMF0cw/RX+htCEhyT5bChXRF2LFGgEHU5Khj+7JVXyYqvYRfzjcmob4sd98y0KWX i8a/347OlqhtS4AoZzakGIL3WJGzeMvKK7hIEWzPeQtq2AKbW7Kl0aSG3QmZkt72mi5X 2env63RMvxnR1b9EzZ65EN6L1v3wPlLfxr96MerRSwsGkPH23YCpTr7Fyor/Hmv679aT dmR0qubaKxh+r5rBJI9xiQ9rZrjkuYM6JZQiP6zc7XsDf4aSpIpqI0oFfK2l0PyeBUrf gRj6/SfM+RmOPaXu7oyK0sN70SRhOY4Ayv3OQ9ESJoOJbcYUoaRpN1K+KsIeMVE6OkZx M6Rg== X-Forwarded-Encrypted: i=1; AFNElJ+G0cbWolqA+xfVMHSNlWPzpjouBXu9Edg2qN8nHD5OAPxlNhKlr6+/CzdbBqSTRO+Mq3sFPRqFMNa8tbE=@vger.kernel.org X-Gm-Message-State: AOJu0Yy9nRbalYxHPa6ec/fGL03A4pDaIevOupEvdIN5SvZABd85Tu1u +NjRiOfUIE7C2CJsItbfu61ZCQIEf5kkqO/5bpmIkqlzdiV9/drHZrcR X-Gm-Gg: Acq92OF4+Br+uSDJt77v11AEnKA9hcAqRm3G7It9AlkMhcQAFiQh7l/+DJ33JjQsvAl x/cnJGjHSHz2HLL3/d1CRl+4HwTws7k84n7jfRlOhTvEehs1bmEl3GXMHqCdDcpfPEbvtCMyPiv WPmpb4sbHXhIY6d+P8p6zh3djPVSR6hO35unFpmzmhqv2bcLuJC9mGb+CNUzdamag6s/Q95AL5A TGTxBf3g8Ix1/XtQgRzXbPZEAYXNnWOePagRoPejj9GqTK25TL03dxHVLoPyEPLo5+wjud+A9aX YiqfYk0hSrtssO1eCLbbb4q6lusoZf9Jl9yXfql+hnlAx8e4yQqbDUfDRcGckf5/lBR+Dqio2O1 GtWVddNYU6GRxNWHfQpM7G6j7YNHSVtLmb8ydYSsiiilLi0681NkTM2RTG4H3KLSo2eCsvClE6P q9meRa0JcJLHmPFQTaU7CdqaTDo8aCWqP5iQly1fMJnLl7lgGW5qlVSYvtfE2rY5TTpupQPJvrh jdV6nQhyp+tGCnpLaJU6DaFUFN7LIeew2gc31pqAYJaTA== X-Received: by 2002:ac2:531b:0:b0:5aa:10e2:4e1b with SMTP id 2adb3069b0e04-5aa10e24e26mr2307738e87.2.1779054000074; Sun, 17 May 2026 14:40:00 -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-5a91c1558f3sm2890076e87.77.2026.05.17.14.39.58 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 17 May 2026 14:39:59 -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 1/8] alpha: enable regset-based ptrace and core dumps Date: Sun, 17 May 2026 23:36:10 +0200 Message-ID: <20260517213919.347523-2-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260517213919.347523-1-linmag7@gmail.com> References: <20260517213919.347523-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 Thu Jun 18 21:14:56 2026 Received: from mail-lf1-f47.google.com (mail-lf1-f47.google.com [209.85.167.47]) (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 797AB31E84F for ; Sun, 17 May 2026 21:40:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.47 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054005; cv=none; b=iomBUQBz/jpse00uL3HcTb4egRuAqBk3KWBy4BAfVKXkSuGYfXHuDR9XBQQ/5LB64IcJUzo9sos66lpHiW3nKmRizgvxyY7hYDS0oR9ATigt/BYnm6mTtkTqlKyKo4lWThbh264H5WuVlHyHBrZVocf+H+0YNmDPCNZh3O5dwyk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054005; c=relaxed/simple; bh=8ZCTjRwEU90aOFjdM2BqJWPcGFCLfSq9sbu77JodwCg=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=AVd80SqS/0UcResygt3fITxjEhy23+7flYOtZlWAyr/NZIX4aBk2BH6uTbW9XdL3/mG8LnenwKd512j9+8KwyOd84h4fuPJAeWuZwzWcZWeTs8AE+Eh+L9crVVHUZu7Fa3AJ4NgjqxfZ9v52joV4+xNEZixuia+q3PVC2o9RYNo= 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=ib7p+O3n; arc=none smtp.client-ip=209.85.167.47 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="ib7p+O3n" Received: by mail-lf1-f47.google.com with SMTP id 2adb3069b0e04-5a877510541so1905915e87.2 for ; Sun, 17 May 2026 14:40:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1779054002; x=1779658802; 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=ib7p+O3nKiHlkLJeU0CZdzUMbTfqijH0cxC1ytP69aDG6vDu5OWH6WOKW3uMBmH/kH rfb2KTNbAg61w8EqObGhOIWAKhdJ6RJTf4ItxWQ2UFTTUUOzKcdlWoio5s6AuFjGDn3b AMr2IFgEOO0Z/ZdjCep+5K6WdLWaiXJjqwxwaJNqOrqPOmGMjjxM0AK1Ml9aHGi0irC1 VIw4X8O3wEAi4m4YYYzr5QntGOfb9f99UY3AWHv/pRpDnreKLYiW3UUpAgImxKyGDvhi jSZB5+gndiZ5FxMSAT5jBHj2XTz7j5IZEgBuBAxg3Z7EwLVI7htXrFtWvTan7gPOZbxF SniQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779054002; x=1779658802; 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=Lie4wEMDT6sG7NooIfIMhTGeFrPoh569zf+TpJdymBvVs308RO8IHq93LTJQdMhvir wYGyfKzINGJnIyPhAm8IABqPR7JfoeXKJcZowGvohIRoetbI+3/j/sNfjAWVMiDDdkbZ 66iOBZipY5WvKTvAAGNZIiDEubwdo7lM2zUHWGgPn8zs12FOTbRQvM8qqTY2tsM2Hyz+ FMfVlLSxFgzaBNSIqiIsHNNwp0MA9O6lTzIYk3tlWtqFFYkSg06RZJ3IjMUleHPy4z/A SrcxVlVnkd16HQeG4X0BTB64FuCTMYkdrYS4W7AbFaSA5kbiqSojUyFpB9Ulr16khpub 0Wtg== X-Forwarded-Encrypted: i=1; AFNElJ+gDiK6Fu4RnyY6RdtPVtsA0RMOh2wO3cKkMRANFMvDhZDiNA2aRdm9cw9smE+UGXShe7vg3ZjGrguBBjU=@vger.kernel.org X-Gm-Message-State: AOJu0Yz7gLPfBIL1WewxlITydwdjL0wJij5+FNhDraDtBgbakEFWFl+Z Z2CvTrJDbZQYEJUo5nXpmVNhl2x26RyVZtP1ahaAl02CqvrkQuJNTflz X-Gm-Gg: Acq92OFciL2M2duPUwDRe+o+LXVWWIYUW64ZZn5iwXhQhE0Jbn4CYQui3FA91TR1Ypb q7jSrmHxgyAOF1Z/5wpa2tvIq/qy/wNR65pKMixdyks5wwC98qSNrmoLvzVOY2DvlTj1SevWnAk YEbyBlMFZXbutfv847eGu7mCCKjHu+ZZdjmSwHAmZcZlA2ElEH7ks/LNL54673VYjl5u68tuo6U pRkURvGV/3l4zjySJxNOXHs+yw6ENm6LO77/mD9AEK6ETexLkz3iP2OnWv0TwB76vVHtVu5i5pD AqN6FukF6T+vDjqZhvsTtdez8gbLXOx0WNLmSM5HlRjOmFQvosY1IYpxiux2wkH0y/zVFha3e2t oHRvP8g4BY5ev/WgFWmGu9uzgHRpmus3lCpj2v0AQnJDqj67ydyQcVLq3IOQqqCQmv8CXZ3HOhf NF2fDHmfSmj2liE8MmpgnV9xXGp6E/FZdaRx0PhCEfbIeOm3FPZMWGFmEodo0Hqu1TLyyNrG+xH q2+BFvFzh1NeiJIiiuo78NUoj9Cpd7USCs= X-Received: by 2002:a05:6512:15a6:b0:5a8:b963:cef6 with SMTP id 2adb3069b0e04-5aa0e769c37mr3063617e87.38.1779054001648; Sun, 17 May 2026 14:40:01 -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-5a91c1558f3sm2890076e87.77.2026.05.17.14.40.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 17 May 2026 14:40:00 -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 2/8] alpha: add ARCH_STACKWALK-based stacktrace support Date: Sun, 17 May 2026 23:36:11 +0200 Message-ID: <20260517213919.347523-3-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260517213919.347523-1-linmag7@gmail.com> References: <20260517213919.347523-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 Thu Jun 18 21:14:56 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 BDA77322A1F for ; Sun, 17 May 2026 21:40:04 +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=1779054006; cv=none; b=Bub3y37x7fp540/Ile5ex1PTVftLvxRcBMf0d+crvup3VsFycSubWwnwXD7ufRxVxABYmGx2szSsbxGEOh8diqqOecxBfHXBYZU+kluZXhAk+63JC9Z3ClPRLLCDODqnJQ5OWGN+LPNsPSP6Z62OTt1k/v2u2Jj24Dbqi2OjYJ8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054006; c=relaxed/simple; bh=9Gis33Sp7AVsisa6JN4s5EdMk7i/H0Ra9vdSrPS89l0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=drUVRK/0PJx+Y5cz4H4xneUbUWgso/d3yOaQzU+GdseV1I64n3rMB7iMhczoe9HGUqqUNjcEubHyjjci8N217SKacExdsrvkgDSLJs8q64zZzUjvDc1+UmOfUJPec4hOGtLWKbWWbLVfhaSZq/aSoQVn1TB7jXX/YoDmOOHQ6s4= 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=CK/7skxu; 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="CK/7skxu" Received: by mail-lf1-f50.google.com with SMTP id 2adb3069b0e04-5a8891febd2so2315847e87.1 for ; Sun, 17 May 2026 14:40:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1779054003; x=1779658803; 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=CK/7skxuwkVfoMi0oED6dWzXo9FJicD2tuh/0Zd1QviLngub8Lv+u/XcpDbBrWPJkH bvi3pyA0lqYBT38jLhmZX0IIuE507rcHk5QSpzikffsLQq13RTyInDVUA/Wi/d2IlPCy HHHPrNNPLGpFS34P92lfrHIU4t/WEcsL8inLWdH9aSXkfa5G1ioL18p4Kgy6FyCmaC5A x1Nq56x+czkThqGydQGlkXP9F0w5UOvglg1PeAfjGq26F79rUEmFNmkAloQxtCEbrQdg ZnAOJw2DMEeA6WLOJ3zgGr6RZt+Wo+MpiHWHh/yHe8aevveWjC0AR+UpvgkaREkRJzZI YKyA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779054003; x=1779658803; 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=q1d0wg5AIpq2TqcmJTn0GDEq1B7M1To4YaJ05+SQmtSPrPy/hDo0vVeux1CklQo2Bq v47XFxdkvzY9SW53+P4HUts7Sptfm5nJMPPjWzkhG//zXQtqKPV51t0612g/BnrBfvX+ 7YP0vEC6UmNx6hNuO4h1lUl3iseF56I9MEbkrk639zsKlgyBDn5ITM2GCZz1G67ZNqav L6w7NBxd89ttYT7kXP7YuaLe4UtZeXDa52JTUayRVXluz5SLkZvlFOmEpagoWchX+KOO kuCj1zs2ENLFba6BX2G1TB9LvAJNQGzwNFD8u9nXxjgqKEUlj1ivXGKR8GKdqxWzZvpl gaLw== X-Forwarded-Encrypted: i=1; AFNElJ8Lfh0dKSMpmC9hc8FKUx+o1aGgMuocRYYerv3fbxPV2TgcIVlhoRtRBoQZLB2sFfXxcNC1a4SK4+3J/4Y=@vger.kernel.org X-Gm-Message-State: AOJu0YyMez1OPJ3L0rqdyUF9yaqpzp+fcb9FuSw8f2rbRByvEcInZfOs oPuzrCe3J2wLNheGQ6G5G0GGI1LpQye06RPRJvviaCcX9QMWG7FvHqFP X-Gm-Gg: Acq92OGUDVfOBhB+KnFkqdVYQQ1dr/oXkGlpDKfVddWXHSCyl/HjWeHRZ8K99t3TGiN An0MRkaDvYGcWWJ/wHJIffPABrblK/o/6nSewVcEHMOCHKf0SuLjuBCSAI+1qAFxqR+molu1tA+ xywivMB5KOMUHM8uMwZPOrGxFaUYGwE2KG4m4WeL1+zFLLRe9Hw51J6ifHOVjdyS850vkvqm0dv vogHskUJ+Dc+oA7sU/lVeCIxFj2SRdAapMMS0W77sSSsh7FtZLLOr6nkckCbnEsnyzJv60i+QvT MMRFcUdJooOIv6V4D4KbXnxyuhQDlM1Di947dJ4g//vfUqg29uU8ZA1zePUeuqFJ386kHzsjh/9 8UbJXOhRb5YDhQ5WuSjlLEJVh/VeQnZifZ/IOItnz8QCwb9NkcOrbP566zPUQ/HLKx5Ls8ClP2U 4N3xHZLL87FHcyExP6MYz2ZjppaXpN4scGLLLEE/CRiqu4vO/C+USTRZdxmH90lRPFBa/Nq5Nn7 GQNegXiEaTj0Vl7HvbBAdP3is/iDGePB2g= X-Received: by 2002:a05:6512:3d88:b0:5a8:7f52:62d1 with SMTP id 2adb3069b0e04-5aa0e733f44mr4523580e87.1.1779054002895; Sun, 17 May 2026 14:40:02 -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-5a91c1558f3sm2890076e87.77.2026.05.17.14.40.01 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 17 May 2026 14:40:02 -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 3/8] alpha: make irqflags helpers operate on IPL state Date: Sun, 17 May 2026 23:36:12 +0200 Message-ID: <20260517213919.347523-4-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260517213919.347523-1-linmag7@gmail.com> References: <20260517213919.347523-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 Thu Jun 18 21:14:56 2026 Received: from mail-lf1-f43.google.com (mail-lf1-f43.google.com [209.85.167.43]) (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 EFB56322C88 for ; Sun, 17 May 2026 21:40:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054009; cv=none; b=fkUF7fwz5Cl1DHgbBjnGE3/ncVIJ7N/52VURnHloATcUzwILH28nyPHcLOy0+96vurOMXwwbly7Q8MzxNSxneu05V6P2jSfKZRjtdpP6fOvQEVyz1WFvxLHMAXdXsZKgVJxD+e9FfeV5h8EV9cUDIXvwNcwRssjwzEAIlysNxEA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054009; c=relaxed/simple; bh=HE6RHHD80LhTOnOIxDn55ZV+XR4m0A2pX3dfr15Ejfk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=BMLotOvSrOHf2KDpisQNS7lazMZ1loTKkecZD5P0D5j+ik63RL3G9ELf94RbLU9pmahJjAJjYnDFP0G8u3dKDbr6Pw7MR4AIqJRvdW1dWlcg0/k0MDErQfXy1Bcw5EW0uqY82/jX5i9oEa4joy1GtYZ/8BnQ4JEZtoaICyJocw8= 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=L8T3U94o; arc=none smtp.client-ip=209.85.167.43 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="L8T3U94o" Received: by mail-lf1-f43.google.com with SMTP id 2adb3069b0e04-5a742b8b72eso2009090e87.1 for ; Sun, 17 May 2026 14:40:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1779054004; x=1779658804; 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=L8T3U94oL01yKLEsJnkDqK75FeqqMshPUV36gH7FGjzXKzCTY7HIJSujcHdSWi+nXd 44t2L9Vemv3BfJpiZGUIyc21ZleZtnBV5WRw7oCMjOuN3/dYrxYt/GvVm5bgd64hGr+A jp2wVo5O+19UqOOoHibamcFJuPZzE3s6p7wk0ZnbIGDGRqEInrwCcvA0Qp2ul+zrX8W8 HIWeOIXIQdIVERNKtezKzse/Kltx1TLURICAmeGw70K4t1/Fjnw21d4nZSL3UKj45fiS BZ0jHn0dn72bP2me8EFlZyBRfvtbYywBggGXHCNIt8v8FnRWUs3DtmVV3sWvjOtkCUv+ qVpw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779054004; x=1779658804; 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=N4bHISRLf0HwwL6tkGxBMKyLm5+m0NQr5R50Hd2Xrua+Syvhdcaq+6LjZsQ2lvf1VF uAXrTlz+ablz51tN+vsT4RzpyDpHojNAzQ8bQpZyHaN4ZLR+hUuDf+ADx31DDXYmZlsL cknFQgQeXkK3IBDuPvEP5FupyFPO47ncmNXxRMVUhF/yPuyAH+Qr4iwsnKYGE/XyCYbM Ib6USNU6pqYnKPwrDl3uvnnUAYak8xIJTqODdCLdZ8iuAE0Hoc7zRDxX+SFNF8k6QjrB kSEJM8z1tvcgrQvUx/+JC9H44A4E0fUDjIjdrRVF2HUM7eDBYIPr/nH6bcgp0p07HKp/ wECQ== X-Forwarded-Encrypted: i=1; AFNElJ/WSakkqsGyoqC1DZUR9zcFJERJA+Up3y8Pcqmm9lEseatZcqecL5TLBOuSDHj65db/kAdaECIULAI3rNs=@vger.kernel.org X-Gm-Message-State: AOJu0Yx++MlawLXHcVG8IqplagjTjITSqiE7lLfdU9rtAuCDtrVrYzc2 6kNB6HFMr7LNRHdSOZou526tiQEHfGBSWtjEn3LDxVju78WaNPn5HSPEu5Lz3oMd X-Gm-Gg: Acq92OEzP+WOlPNLK4RioSyAHvTiMlQbAqVg7wgNpSPMxe/KrD+K56LSECmQesMl0ty EEAZcXFoojhCZJM4rJvZ2WJQA140ZBEDtZgJdBXgHhWK//7LPxmK6E66UOzlnxzOu6O4PcjRBHv OARBmGYkEVIP3eNVUG6s4zMFCW5nKQVe1yIEIaEGYwZOXKyBxoSJ4k7S1FIYy0fKOVT/Dt1eRgd LB/iimlTiREhMd6gavWQGOnJgA676zZ87M/xWfTX0i4lUgnmvv/LT/t3EFnWHnZMeYV+SFg7Pc3 T5nSUWdcvgzHNflCuT8kvZYDkbCCU41PibtzF77EsqR7Wsp88g5ET2RX+aa6ToEoGJWMmQUcNJG EPI2oM8fb/UDohECxtQDnOPkQeUqdQOr21PcJXryCxLlL6PQOq31asweemcfG1MV2/XkCUHYJ5i kN9XVh+S88+8fvQdJpPfjg0Ig0XZSpfBIkoQBbDigoS+QBBtjDHsH035DMnnkyhaV/n+y3tPAgF gv0QshPkJqSTmkBvh9xCjBufbU2J6ZmXLX3NRG47JY/YA== X-Received: by 2002:a05:6512:3192:b0:5aa:b6b:93c1 with SMTP id 2adb3069b0e04-5aa0e744e11mr3627600e87.43.1779054004091; Sun, 17 May 2026 14:40:04 -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-5a91c1558f3sm2890076e87.77.2026.05.17.14.40.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 17 May 2026 14:40:03 -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 4/8] alpha: initialize PCI sysfs bin attributes for lockdep Date: Sun, 17 May 2026 23:36:13 +0200 Message-ID: <20260517213919.347523-5-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260517213919.347523-1-linmag7@gmail.com> References: <20260517213919.347523-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 Thu Jun 18 21:14:56 2026 Received: from mail-lf1-f45.google.com (mail-lf1-f45.google.com [209.85.167.45]) (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 53E6D3242D4 for ; Sun, 17 May 2026 21:40:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054012; cv=none; b=c4Ud2TQoZqhg3XgcFEzPtWzfJYOwuLn5WSZ8ZGAFpzF1H3jt2SGj3iOaavdzdONYahoMj7/jTFq2m3X1BUV/KclGgJDa6JsZ1+W/+KQtCD8K6v033oXJzwWF7s4FBK7yCcbHxtNaaESnZpnFZphKL13xpMzrBOSKhydQmwVhx4A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054012; c=relaxed/simple; bh=D04sp6jy24qV/d7jpV7qcj/FJRHhYaGlTiewOrERXrk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=PlvgdEnJdp5YdwssIgao5A8cjlQmyiMsdSMDqA4H4OuDRfE6U0L9qaDW04hg7t3+xOt3g1wvwEdEoL+c4ZVUSI+tEMm5eF5JvNNwzZxblRRfcWXl7kHTU3Vdff0QLwv4J/d6WYt69ZPxUuME90axExY8e5XJCVTIM3YmGxIT2rw= 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=Glk3lP0n; arc=none smtp.client-ip=209.85.167.45 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="Glk3lP0n" Received: by mail-lf1-f45.google.com with SMTP id 2adb3069b0e04-5a85b30dd54so1818622e87.2 for ; Sun, 17 May 2026 14:40:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1779054005; x=1779658805; 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=Glk3lP0nSxczV3/GAuqzg0dFgynKlS8jF8HlBx0n8ASyeR0LK0N7oGjrdBQqnNPADQ LogenKISw+Oa0HZPFcDPfDH7KSYsYCMp452+BdkQEBRYsN5jivzpGpfXCW7o9Wf0aE7U O14jp7dTaZWCN+xS5pQRkoYmfUyQO6sU/98VK8mpYneVOk3IZnmxW8kaeKNHa0D9Rz39 PkpmaymAU7uGmr2xxEjwjmNw5P3M8wicSX8f25EuuXCfeXvVOumlOZxssilkJsApsquv tJtCcYgCZq4lxolIqKSF23MDAbbwl/Kp7FI6a1yc8NWSy4YAkNqi37GH9V39YHiO0Djv h0bQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779054005; x=1779658805; 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=qlBNyJHJ/0aIN4exnWuES97lqC4KM+gX/rc6lxjmBs6/5Ib7ITABVohKOXHQVxxFfe MZbeCH4k84ZoflrlqYuLuk7UklKLpyRAYv0g64h1av5+K76/DBFbDI/5qZKasKEe0s2z sNwWFDfV3w13YOTnMCbxpfgclbmZj6ElRb3bt8MlaQ9FOKakbSXVfeNwH9TEVOUT1TfC af7dhiJxNE5omQPNfiGHZb5kuWmEllt+nuWofDIrNNTHluugGTLvnf/OlbBdgWPrxZCO p3nrsL6uYJI9sqXI6zMkajFmdzVFtyOZjH4n5BdLzhSw3wJw4KFihiPmUpSbcjIV2cvS q6LQ== X-Forwarded-Encrypted: i=1; AFNElJ+Jo3LbXgsIlKfAb+fW7Q4/2ittjgGU6gFajZz9IfVoJWWiBFbc/aOXphRe9KWNw4LWBHtYn6yU+VnY3LA=@vger.kernel.org X-Gm-Message-State: AOJu0YxnrF8IJ6SNtIcSYD36yjRJbvg6bef9LvpSDLyVR5M4rnAN3AiU wwxasfotvNQ6oNwiGR8f3bneCrTArswjVVKVDPyH9xhiVjBaMdZWu9Mg X-Gm-Gg: Acq92OHYW+iD/FteU2LoYWzYu2cF15JnpVAL4CQl7XXZfHGXl6UOthu8zlbGR3TnzZN o2FOK/0JjCUi8nQGnXC3Rb7MPUUa571tB1pKZig6HCtwRqevvYF1UTo+OwHxh+yDKOFs/HxkxuW hCTyaO9XzM+5/iBjrb9mPvQDX9Ff05RITP7/50pKA+UsRWq4zTOJ9i2KPs//wyqGMhBpIrIM3D3 XcRJhPkgJlcpk2/CIfGEBFq1vf3s6iTF0E2ykZolCPDuoOna6QVaPVYS/pLvwYibCUtp3grQpAU PbzMkenE6GLEYnEsq/06fauYWvlZi9Q84LHO4Ubjk21SY3teeYHiLZBs9S0RMUY0SJHSN2Z9tjN tDtWQ+mEnwsw/MMNY3Sno0zxitalsI2MurTjYcpyppeiGpNtZNjD1AxCoer0BFS/JUFQ2LS2ZP+ 8KUiAUhe6ZI3TGiLoo/zNuTjE3CfYaJ+18yv8/vqIjOHs71q/i3EGkmADxIeEV1lnE5zth+m02O c/QlBK7G9FAke4TgT8nwz7O8iWvjaEgMmmNN6uTsCOdlA== X-Received: by 2002:a05:6512:3a84:b0:5a8:88d5:a502 with SMTP id 2adb3069b0e04-5aa0e740342mr3142036e87.39.1779054005447; Sun, 17 May 2026 14:40:05 -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-5a91c1558f3sm2890076e87.77.2026.05.17.14.40.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 17 May 2026 14:40:04 -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 5/8] alpha: provide ftrace return address support for lockdep Date: Sun, 17 May 2026 23:36:14 +0200 Message-ID: <20260517213919.347523-6-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260517213919.347523-1-linmag7@gmail.com> References: <20260517213919.347523-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 Thu Jun 18 21:14:56 2026 Received: from mail-lf1-f42.google.com (mail-lf1-f42.google.com [209.85.167.42]) (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 EDEA731F9A8 for ; Sun, 17 May 2026 21:40:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054012; cv=none; b=Fr3Iht8T3hfWad1DdaSvVdmcbAJG0DjAvNZ40Euf/GQUJd1KFEHU9X4KQuV7qU9n6TJvXccRQdgjkNSFMfomCikXil6+SByIkyUp0geMkhHwXPDyUZCyjgo1Sr4hS0Zh1pS2JOxsqtI4oVbbGApydBThI3SYwZEuDsUU2ur0B2o= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054012; c=relaxed/simple; bh=OeW1Tq5ib65YfcgaRKyfCUETSHjLbYZg7diBythuaoc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=QVQKnIAvPeeVcpMV9tc6UvUM7Un0CbCc+xj9BFOFsvzwYbz8o1ePp9qxhHGcBBiytGXZckYPxWs2h4+WhY5RjZKsV5vWhqiSQCLBodDmP+WJVtV+UOPYWhEH6Gv2b6UY4AGXqT6wKFmIgdmkKN7kcqdoWkw3BCvhcmKYFUpsNfg= 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=oVIgs9oD; arc=none smtp.client-ip=209.85.167.42 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="oVIgs9oD" Received: by mail-lf1-f42.google.com with SMTP id 2adb3069b0e04-5a742b8b72eso2009117e87.1 for ; Sun, 17 May 2026 14:40:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1779054007; x=1779658807; 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=oVIgs9oDUb6RggoKrW0BGVc5qcjfs2O022/dQkeHn4iT8q0Wc92E7oh7kaKcxQzYcO sH+xfQIy/0kj9CLSSAeQcZd33zjZKXkegmA9NHFRbxGahI5z+cnuncFOn6o+OQX8yM76 s+6oadSUHsGK1BZig/vdNUd086u/GeZygbp9Z1Y/W+t0tvrT+px2trNyOU0TjMpvc0xr OFSSXP5nFz7cqyB/Mp3pR0WIy2k3WZ4KVWDEvmufHILE9sOlrClUnvNIAXwY4o3hUtL0 4P627e+ZDFSmv0mJ0LhnEtEvfSJcGOroKdddUODz4+9NW/nto9t3/GhVFbw190XZ+G7J NA0g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779054007; x=1779658807; 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=jNx+FtzYcu5bna+XwSTY7wJFeZDe/3hHbMfX2FS6pFunHkO2hD0FqRYecShp+LVLqf 3RG6v5n7wy/1st0W7NMtQAYxz3uUnsRPbVYMetyNYDqIwelV6EjjqA8brdln/YGl3tpW Ag9SnqmT8vhnRsw8kGJULrAh9JVi/aHGBK7Z0DnjmNLuq6QpPhVDiW2cak4xaADrMw+p oY91PPYC5R6kjERV4PbYvxaPnpcVXm1Jl1h1OKkbUHU+oZ0DnS+CcLZ9RhyCEEGbmjl3 HzXtiS0LB61F0n2Im+hcRah0x7m6QUP1Bk3hsBFQXGLjOsEp9ktAZ7aQD2PrdYYcgQrq 1RKA== X-Forwarded-Encrypted: i=1; AFNElJ92ekrcpe9qqNhvczgyAPAamhNJeIj8dQwgjizxeJ7mCKGsHOOEtcwY6evfxucWpvLkTXxTyWsmEYaYNh0=@vger.kernel.org X-Gm-Message-State: AOJu0YycNd9zstzURyQXcaJVa6BY2YgFD243nD6c2L2h7WTdmNwFAaLY M38vaZ2ff4HpOhQlw4DdvcoxrgGJyeWWUR4j+u/nnaKOzA5SdxwzILuo X-Gm-Gg: Acq92OF14Y5cisuazU3+agUvB4YvfVguMzpiW6Q5egRF/blfgn0oXeU9vnxXqxrq9Df ryIWDbFFjlU4WzYxD8jcMwODs3m+fn/0H5HltLTaEL312MZFEJrm67UFEnefk4UOpe9fgGdTCRH Pdwqs7TdJKG5JrqS4DetxgtQKbvIR7fBM0val5YcWK9MfP7JFnm4dXzAPVZvphdW1naSdkCgOJJ 7V6Zsn7drjAbduDvGgudCQxwte0G6fdi50+VetVDdRKM5ogJ4PpkHb4l2AsCUGkrenWOA/R7FAm HfZaYh5B3eAO/vqg3eSuPlMBvrO9Z2yR9zb7FP43Y/wTgPlsbA1dEHepopt03ecA58tMEXsV1fi htML+aaCX0tR40VLzrSWQWE6aBPA/wxnO9vlngXLylogvrv4gvJY/kCDFLqSKzH9YZkCGAdjWVt lUyNgVNGV3B3b267WT79VucUfq0MUxQ+//iOu0KYaoaWpNFbNNSgNv1GECL7j9PD1nyOzxBiIyH Ti09fS5OSpatLp0SCC8V1vJeyAof4+qSJw= X-Received: by 2002:a05:6512:691:b0:5a8:5288:28f with SMTP id 2adb3069b0e04-5aa0e7390c4mr3354132e87.28.1779054006941; Sun, 17 May 2026 14:40:06 -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-5a91c1558f3sm2890076e87.77.2026.05.17.14.40.05 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 17 May 2026 14:40:06 -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 6/8] alpha: use raw spinlocks for low-level platform locks Date: Sun, 17 May 2026 23:36:15 +0200 Message-ID: <20260517213919.347523-7-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260517213919.347523-1-linmag7@gmail.com> References: <20260517213919.347523-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 Thu Jun 18 21:14:56 2026 Received: from mail-lf1-f46.google.com (mail-lf1-f46.google.com [209.85.167.46]) (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 21F9331F9BA for ; Sun, 17 May 2026 21:40:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.46 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054017; cv=none; b=vDHGvCoAaKZ2OD16rP71KtV836hNw5FPlbVB8zrpfmFtA3Vekr2Hq5t76eiuhxMtpE8iZ3A9WrEFNWEI8MCos0R/nCSZdnPJjwalRJ5i1DYGv7cwE04sxOBRv4hgzTwK+IA/GlG9WxuF18/2k6oD3YiTLJvZJPMQChyUi7Wa9r0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054017; c=relaxed/simple; bh=rstuAOpzPRL3H4jqrx/1JVpnPt5XUiL8d1ntp57R1fs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=dAGT3Wf09GXb+edY5tbXwkxnJCRs0wZiJjdqS7Dq45ydTlYYeA5aoO2nM/W/uz9dwAjDfjcZHZU8zS9CkQ49n2zMjVqmNuQrnefPsq243+RKbl94GLWbLeraEeOJxsSeMwatj7HJvuFBJD/Wxa2RF5CHuMkhDivt5czSqVDNgW4= 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=WCuqT6mR; arc=none smtp.client-ip=209.85.167.46 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="WCuqT6mR" Received: by mail-lf1-f46.google.com with SMTP id 2adb3069b0e04-5a8dc2606a0so1749953e87.2 for ; Sun, 17 May 2026 14:40:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1779054008; x=1779658808; 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=WCuqT6mR/dWlMctMepKm4GQQc8OqtoBLRRSqUMg7uI1CxkuTMjHut6DT69UCdu9Bb2 jEBgxVFEtuldhnd1QTCUgmklQteTNrHgToszuGi4flJaU++cMT2BOKBzPppTMqevXh1G ka1XXpYksportfU7gj4gKqAMCxVrt0wZCFluSoYimiFSFirJSzk9WL7vtyUNP1yWMQw5 wEckFwPwytE2bwZ0qpohHqtIn8U78Yq8NB8uiFGL1sHI7bs39L8cjWilil3ukyZ0eR8R sKRBqSqbfP9Qqgcfn8B4mArEO2MI+FGqHJBR9ipCsH4rx9AUSBknBGVIJA4JnFX7EL+V N7DA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779054008; x=1779658808; 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=MUYfv7xiCgQXqITaXiiOPAXxyUPiwsi3P5XQXMMm9pbbhBJVYcVg/InkwY7t5tcKDM q9sY80b4EGI5o2xvs0VcVePgOIVBVmC+gSM/YOeYgXbm4y5YbJUER0tpPiGSiBfLphc1 59ZusswpbV5Y3HsgN7sY7vdXwlqQCIhfcmS7A5W88DKEfEmkyfk+KWY+hh65iNCY7Ne9 TLRVFP26fvL+arXwwRu/9PCKbZKywTSpWiOAWjqR7VTeQ5cJacv1ClqTSkyas/P2y+Za 2NZzY+U0ZPuOahmi7WXZBLGBPfx4OLQLjiUGO17JQSr4xISBR5sNaRmxKxDGfK1SMD8I imcg== X-Forwarded-Encrypted: i=1; AFNElJ83qfIeVgG0Wy38rzC7ioXGToy0CkS+YOehQBCwIIHr9NNk4CLo/92721h/oBQiD5MdQ4/ao/UUfI6TL48=@vger.kernel.org X-Gm-Message-State: AOJu0YxFsN3MgJGLLk0gsdRFfMP6NxhZ/dvAbLrVeLLPFHaleJdK67Ba pQV89BoDYAZgjamSF2JYY5PC1gSKz+YJqHR9ZEEldaXp3QkhiQ9ULc/J2eK+w6JT X-Gm-Gg: Acq92OHd8W8tiSHagqtB16ZdnEmhWgTnIOyc3vMyBoRRtyswdNqR29bWPQr+HbU+e3/ J1F6VZLcJVZGfM8AwMb7pqU6M/6JqmqNaydj8Kjdn/ctL80rfGIi1LHL3lg0depYGuZbjC01TiS RYNTaSB7VJ+cNCYKSY/IQ4ly7iKM47BytxN812qBsJ8BbOg4wxrHo6uY/YoEEaVty9WsglKYPeR j+9ihm5SOwAlyMqZNSVd1PLDbILYPfoTYYd8mhoX6SG0nRtR3e9z01UzZOHCba33Fodlqi1rTv+ nln9v1qZO1SVQ0r3bknOodKbbg4qpWZjI9bSm/r3RNSMiAiLNJ3rCXSTlzLWQLjrkSkDo+YhNRK CezAFoDUxvBAOGmMdFzpMIXmdQsj1tAgK9ioDmswvNzKU0leCXhFbbGvXBqycOGVcPnFzyu7vIN Q1X0I9RO5Oz+zOvHz8yA/xZr6+bF32ncSZC8IcGoI+60eiS3p6RFAiMcV8WwJ2QCUdo+jJH0/Mc +3TIZKm95hafGsKLrbjOSuyBVRV/2y7NM4= X-Received: by 2002:a05:6512:2397:b0:5a8:9909:50b1 with SMTP id 2adb3069b0e04-5aa0e610e9amr3263203e87.10.1779054008300; Sun, 17 May 2026 14:40:08 -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-5a91c1558f3sm2890076e87.77.2026.05.17.14.40.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 17 May 2026 14:40:07 -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 7/8] alpha: enable lockdep hardirq state tracking Date: Sun, 17 May 2026 23:36:16 +0200 Message-ID: <20260517213919.347523-8-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260517213919.347523-1-linmag7@gmail.com> References: <20260517213919.347523-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 Thu Jun 18 21:14:56 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 21444322527 for ; Sun, 17 May 2026 21:40:11 +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=1779054018; cv=none; b=tNtULM0HmtX/XxMG5Vb2JnAADP2zqu52GVHvQg160AkX6O2lcrQdkfVg0MILFrPj4Cti2nYzDrbGflWifpbnNvcOq2rmRYJKyDBEZljpI4sZ2DEpUEERmPrREc5O4/gkHvJTHxnw5ZkVdINF8KZVTra9h2dbgaT6gSmuHGQAwc8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1779054018; c=relaxed/simple; bh=O7Nk242wfJvUMANlyoLgOJwfBJS19DyjSTx4F/KPg5A=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=BOsiLw30DzRoxtTN5sx+OGqj0JzSTfMFc6osEQrPr5TKivrTqaXKjyKa/oL6zia2cd+LVhjcXl3lJxgWTGOVvQuG5C/zIpXn/eDsAQu7tYKV/1nbclA9aiySKUVqUDqMf9/WvF7sxS5vq8R14SYEQEbHhrXiSTBUv0fJ8mFhn/k= 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=NK5RHgBU; 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="NK5RHgBU" Received: by mail-lf1-f53.google.com with SMTP id 2adb3069b0e04-5a8891f0c51so1821955e87.1 for ; Sun, 17 May 2026 14:40:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1779054010; x=1779658810; 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=IJ7apvZurRpDxdpwSwzeY93JfiJrHnAvGkGE8cGrA74=; b=NK5RHgBUKIr1+f+ROYqDJag8FjNxZT79Arli4piiY7TZ+cCUPwZreUR/S/osZiK6Z+ vyGqVzVVa9u/pf5qVdomfO2fj27+8Ucg6grTshCQC/l+7PeCa/2w2ci1fUsMQ3rMW05q BfOpA70fnBNSAhqG8me5cmDvpCBgAuqbOX4QcTMeysHDfDg7BLGxU6eCTih+r4d8NDcp BssVu/wVIQjB8DzTEUohyu8RfWumP39NG1BrwvCtmOlav7HLpSL/2iQgNqsKh0ZQbmvX pbeF4DHX74NGp1F3zYLpWEg2EQBHSzSLn4TFis4RiQbd34F5hS/5oMp/d/m41Y3jR21F I5EQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1779054010; x=1779658810; 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=IJ7apvZurRpDxdpwSwzeY93JfiJrHnAvGkGE8cGrA74=; b=Ap7pDFucEU3SJPi6oBCP9BF5dKzYRI3RkPlzMK7xQnMWS6hx3nil2fH+Oub6Aap50M 42AKZe6OhjRgFLTceW9X9ecO1NYAv+JZl08YXcLsnUAuMqiuLUqb0tIBo9orz9WLkD4V YIIFNWC+g2I0nF2NxgzomCrEGFGifvr3+OPgn73Qyufn15tYtPBE+s8OLeDe/tlF5odh NPybnC1Mm/AfhUmhq2ZJkoaQ28OjiTFfl0aPtM5WH02SOksO5RxWc1R3pmfXvW5ACFOH 6ib45aXUT7vmMvAdZ0dPnKgWkLt3PDHKV4BDaBFjjc5MUSNxskqFlOrkHqT/DeylZ2EE NMmw== X-Forwarded-Encrypted: i=1; AFNElJ8qQ7w+YggTcM0/OmST/UWVaKKr64x7Y52qoMLvQQgzfDqgo7nQD90+Jd7u0DlYpcY4S9T/+C5MccgmeZo=@vger.kernel.org X-Gm-Message-State: AOJu0YxeEWLzpKVWNGJpvXpouqm/bdm82j8c2NSSQZlRiR2Qa3YUb6AA YSS4zRSsUpItS3b45+WrZ8behjluDD7u6zwYQreRbJ3T0gy0A2h62piN X-Gm-Gg: Acq92OHW4L/UpdD7QR09rqHIiSyPk0U3dcBgabyb9NdVQxVhQOy6BCeFtj0RVWaswvb ZeihLOAAOX+MjKPfhhxJOkojMqaH/93mx6lO52QBg2f9N9T3A/ofQtEpRTBlO7qnKdaqkdxukbH 2119NIUac564okT0ebSmmtAkWQzqPfaNW8zfZlfIsZXlP8h4Zb7K2EV1EwF1gOHGl13mgRU3xS0 eEy13ReARvdBGrjhQkNh/H54GRuHjJjoB5Ti212CLIAKdGizk2UHB0v4wHegAF+6SnjWi7YrhXn qxvHpmQUSXOH0afoTO47yzvlRjVAzmoE3nnQKdcBP415ZK36rI3j0A8ovQOHn0a3LWt4Xy3J1Pm uIYCxSVMsrkZIUWb2UBDfNa344hr9suL+skVLKJAWmWEUSB2/JdgjZrBbVrc8p87cpT5CtIVOd4 Gq0TZMGj2bKd7NSqG/OD56N5WtAx1jO40tADp9M7HzJ0GiDn2qx27iqsaQ8VmE0ZxmYGVgeHWou +JwSKNRmpGQmiWMElOgn6FO7klPN20o6Cc= X-Received: by 2002:a05:6512:32c7:b0:5a8:886a:1164 with SMTP id 2adb3069b0e04-5aa0e73c0e3mr4124123e87.28.1779054009848; Sun, 17 May 2026 14:40:09 -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-5a91c1558f3sm2890076e87.77.2026.05.17.14.40.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 17 May 2026 14:40:08 -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 8/8] alpha: enable GENERIC_ENTRY and GENERIC_IRQ_ENTRY Date: Sun, 17 May 2026 23:36:17 +0200 Message-ID: <20260517213919.347523-9-linmag7@gmail.com> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260517213919.347523-1-linmag7@gmail.com> References: <20260517213919.347523-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 | 152 +++++++++--- 12 files changed, 364 insertions(+), 365 deletions(-) create mode 100644 arch/alpha/include/asm/entry-common.h create mode 100644 arch/alpha/include/asm/stacktrace.h 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..3362f2b45d54 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,121 @@ 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 + * it still looks like untouched "-1 success", in which case + * Alpha normalizes it to ENOSYS/a3=3D1. + * + * Do not run syscall_exit_work() here. That is handled by + * syscall_exit_to_user_mode(). + */ + + if (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