From nobody Fri Sep 25 07:55:59 2026 Received: from mail-pz2-f12.google.com (mail-pz2-f12.google.com [74.125.228.12]) (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 490B1441619 for ; Tue, 15 Sep 2026 09:05:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.228.12 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789463124; cv=none; b=jv5j295QmQ+z4BaB6DnLkwkpsE4eHVeQinRyjms+HtFCGypatqdfi9/Kt8nuegdhCS6WbfcS4QrrkSjxi69OgMqEQPYXoA6th5VLIZYf/tPsdh65ZIz5bR+qq2XyeeaJlCdG9/ck13PEvED/VkbxLBcSHcHaB/f2G4kPk5qhNQo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789463124; c=relaxed/simple; bh=ligEys563GaiRhNpINKM6nCfw+5Fhk/eneyMpl5W+uk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Sb4M2/KKV8KJEaDH0BBEj3tSVhT5tDlAuS1/GT7ZvK+GyTeClKRSJuJsEqsjCOZHoFBF+1KY9iJIoIr86Gb7Ub0VWaaUD3DENr8nj5x6vc8o7inUHleukz8Fv2wzfgHLiaNwJSDF6+F4uesxQMJVJn/1xgwKqjUdEl1sr/EmapY= 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=c4KDZ2kA; arc=none smtp.client-ip=74.125.228.12 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="c4KDZ2kA" Received: by mail-pz2-f12.google.com with SMTP id d2e1a72fcca58-85469b35611so1700929b3a.0 for ; Tue, 15 Sep 2026 02:05:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1789463121; x=1790067921; 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:content-type; bh=dRlgQjCaKIy4dVemjk8uAj0nWBn95cwji7bMZ4jS6zE=; b=c4KDZ2kA8TTX4tYnIsYvMfr5cj5yH4TLLw1zXlqFJEyZ5xihp7mq9j3R/WUSEWcAUF mOQZttEA89iKjWmG0dyuKya/8//BH7QW068TScA5RMDDLEXYWYnKX3UH8NkS+AE8HqUA kSk+XqIj8AeYDYrWPtRrDTXHPe3uG5edQF7pcCNrDtoz3F3+uubxhUj9HgqjI7bN1FwL kWf7Ekf6KZ+pjg6CRK1ZTRUrtQNgJ79INr8DZa1jnE1rZsEfQBGF0lEKWFfyn+8SQT6A Z0Pid12f/qlojRkMY3D9nQ+6hKvXPbNw6azJTI8jSLWWv2YqHYLFRJJ8AoxFwmfM+FLQ w3qw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1789463121; x=1790067921; 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:content-type; bh=dRlgQjCaKIy4dVemjk8uAj0nWBn95cwji7bMZ4jS6zE=; b=TePWuPiwicL5m8G7uhzB2f0L72h6JB6HxpqZn37mUtomuembIlLMzIGBub82+m2ANt L5pxua5yfxw9LeqEgX+R3yP3ajVfHQfofmlhNXW6l68GlLAuBmKZFy5B4YqBIi8bBf94 y7lkRClHOVGFEqgcfL9Yaf/FQbMgGIxjbA1Zf4MB+RhtbyefMFfdFcY4snCvEAB7TYzX 9kyePzGdHnYEpFJ2aKFLKym8AgoNYYb89y+93PLA0y8uF/J2brmMpYy/W5q3Q7Av07Mx 0JAfA12GJV/ozSKyrkQI8dVVs4Sg3k4Ch/QCw/39xZqjKDsSO91LZPzKsD5pDuHYMqEI 9Z2g== X-Forwarded-Encrypted: i=1; AKwUvBzbpsWuyJQKQqMhM7MwxmffWlbJz3nghye7B18OSte6gWPqwzPi1mC8I2zgKLY6ykpff8d1Z3IUuoxLShc=@vger.kernel.org X-Gm-Message-State: AFuF++kJ4JJupOKGgwjiAfRCKLLoEiBMCacuAj1qKqIiXepoGz/mi0eX 5+ZhRLksBdRn+RY7I3tMg/unX9vWK6hZ3oOZYJCNdRYkT5m8B00Ij/Q+ X-Gm-Gg: AYBFou07kons1We6P/I8NpKJEgnYwc8mkkAgqgEeEeijt4Kxv74W9x1le+wQ7UGc3ne lyR2iomvqwLI8DqqpeMs52QGesnbeicSQmgHWzSla9L90bx3qqpW6B0ZEOTH0R9kzNTW5ei20hy X2MZOiuw+hS4LdSqNRwr45EBubmkvHYqJ0NbND0dpRSVcq87FSulIdm0e+Qpo3DL4yduzaYtvTI g6RVq2NXNQ47ZNZV+7tQPhbMxSd6Kn4WfEKYbOo4G+duwoaMS0OnjALKO3u8Yqdtclf4iihoZFk dSN/t7+eahiwE0K1mQPCdCKjVXXzdQYjnoNZmeYhW/MYLbMog0tTg8QzXCdKYDKg+YixL4xmvuv cLyLLwRUCT4pJxYUuSEo1VhH/pyTvZTwIotu//Yaqx/F+yb2KubFg3VHEtJaqyfS6Pyx1sEyu85 o1ZT0wtOdBQZRd5N3rqpBub6fdQkc8IiVjARGdwEwCLOlcf79DAn8kePaE2cU7JsZfufoYYFvm8 FhaFPe5YS8cCYsqIZUC388M9Eoml2ISMKPhojjxkjAXIWTf1ONLyQ== X-Received: by 2002:a05:6a20:430e:b0:3d3:ad3c:49a6 with SMTP id adf61e73a8af0-3db4061f449mr14643678637.20.1789463121439; Tue, 15 Sep 2026 02:05:21 -0700 (PDT) Received: from li-1a3e774c-28e4-11b2-a85c-acc9f2883e29.bl1-in.ibm.com ([129.41.58.4]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-cc4c65a8120sm6495512a12.30.2026.09.15.02.05.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 15 Sep 2026 02:05:21 -0700 (PDT) From: "Mukesh Kumar Chaurasiya (IBM)" To: maddy@linux.ibm.com, mpe@ellerman.id.au, npiggin@gmail.com, chleroy@kernel.org, ojeda@kernel.org, boqun@kernel.org, gary@garyguo.net, bjorn3_gh@protonmail.com, lossin@kernel.org, a.hindborg@kernel.org, aliceryhl@google.com, tmgross@umich.edu, dakr@kernel.org, daniel.almeida@collabora.com, tamird@kernel.org, acourbot@nvidia.com, work@onurozkan.dev, pjw@kernel.org, palmer@dabbelt.com, aou@eecs.berkeley.edu, alex@ghiti.fr, nathan@kernel.org, ndesaulniers@google.com, morbo@google.com, justinstitt@google.com, mkchauras@gmail.com, ynorov@nvidia.com, david@davidgow.net, joelagnelf@nvidia.com, fujita.tomonori@gmail.com, linkmauve@linkmauve.fr, linuxppc-dev@lists.ozlabs.org, linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-riscv@lists.infradead.org, llvm@lists.linux.dev Cc: FUJITA Tomonori Subject: [PATCH V5 1/2] powerpc/bug: Add ARCH_WARN_ASM and refactor _EMIT_BUG_ENTRY for Rust support Date: Tue, 15 Sep 2026 14:34:52 +0530 Message-ID: <20260915090453.1227034-2-mkchauras@gmail.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260915090453.1227034-1-mkchauras@gmail.com> References: <20260915090453.1227034-1-mkchauras@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" The Rust kernel infrastructure generates inline asm for WARN() via ARCH_WARN_ASM(file, line, flags, size), expanding it through a C preprocessor pass (generated_arch_warn_asm.rs.S) to produce an arch-specific asm template string for use in Rust's core::arch macros. powerpc currently lacks ARCH_WARN_ASM and ARCH_WARN_REACHABLE, causing Rust builds to fail on powerpc with ``` error: no rules expected `ARCH_WARN_ASM` --> /home/linkmauve/dev/linux/wii/rust/kernel/generated_arch_warn_asm.rs= :1:28 | 1 | ::kernel::concat_literals!(ARCH_WARN_ASM("{file}", "{line}", "{flags}= ", "{size}")) | ^^^^^^^^^^^^^ no rules expected this token= in macro call | ::: ../rust/kernel/lib.rs:279:1 | 279 | macro_rules! concat_literals { | ---------------------------- when calling this macro | =3D note: while trying to match sequence start error: no rules expected `ARCH_WARN_REACHABLE` --> /home/linkmauve/dev/linux/wii/rust/kernel/generated_arch_reachable_a= sm.rs:1:28 | 1 | ::kernel::concat_literals!(ARCH_WARN_REACHABLE) | ^^^^^^^^^^^^^^^^^^^ no rules expected this= token in macro call | ::: ../rust/kernel/lib.rs:279:1 | 279 | macro_rules! concat_literals { | ---------------------------- when calling this macro | =3D note: while trying to match sequence start error: aborting due to 2 previous errors ``` To add ARCH_WARN_ASM, _EMIT_BUG_ENTRY first needs to be refactored. The old definition was a bare macro with no parameters, relying on positional asm operand references (%0-%3), hardcoding the backward reference to local label 1b, and including .org/.previous directives inline. That made it impossible to compose as a plain string outside of an asm operand context, and left an invisible contract that callers must always emit their trap at label 1:. Refactor _EMIT_BUG_ENTRY to take explicit (bug_entry, trap, file, line, fla= gs) string arguments via string concatenation. This removes the dependency on asm operand numbering and makes the labels an explicit argument, so the caller's intent is visible at the call site and a future caller using a different label cannot silently produce a wrong bug table entry. Move the .org and .previous directives out of _EMIT_BUG_ENTRY and into each call site, so BUG_ENTRY() can still pass sizeof(struct bug_entry) as an asm operand while ARCH_WARN_ASM can supply its own size string independently. Add ARCH_WARN_REACHABLE as an empty define, matching the arm64 convention, indicating that no additional reachability annotation is needed after a WARN on powerpc. Reported-by: FUJITA Tomonori Closes: https://lore.kernel.org/all/anG67Q6Y59kDqh-c@desktop Fixes: 73b741adb264 ("rust: Add PowerPC support") Signed-off-by: Mukesh Kumar Chaurasiya (IBM) --- arch/powerpc/include/asm/bug.h | 46 ++++++++++++++++++---------------- 1 file changed, 25 insertions(+), 21 deletions(-) diff --git a/arch/powerpc/include/asm/bug.h b/arch/powerpc/include/asm/bug.h index 0db48977c70c..bf31ee1e902a 100644 --- a/arch/powerpc/include/asm/bug.h +++ b/arch/powerpc/include/asm/bug.h @@ -32,34 +32,38 @@ #endif /* verbose */ =20 #else /* !__ASSEMBLER__ */ -/* _EMIT_BUG_ENTRY expects args %0,%1,%2,%3 to be FILE, LINE, flags and - sizeof(struct bug_entry), respectively */ #ifdef CONFIG_DEBUG_BUGVERBOSE -#define _EMIT_BUG_ENTRY \ - ".section __bug_table,\"aw\"\n" \ - "2: .4byte 1b - .\n" \ - " .4byte %0 - .\n" \ - " .short %1, %2\n" \ - ".org 2b+%3\n" \ - ".previous\n" +#define _EMIT_BUG_ENTRY(bug_entry, trap, file, line, flags) \ + ".section __bug_table,\"aw\"\n" \ + #bug_entry ": .4byte " #trap " - .\n" \ + " .4byte " file " - .\n" \ + " .short " line ", " flags "\n" #else -#define _EMIT_BUG_ENTRY \ - ".section __bug_table,\"aw\"\n" \ - "2: .4byte 1b - .\n" \ - " .short %2\n" \ - ".org 2b+%3\n" \ - ".previous\n" +#define _EMIT_BUG_ENTRY(bug_entry, trap, file, line, flags) \ + ".section __bug_table,\"aw\"\n" \ + #bug_entry ": .4byte " #trap " - .\n" \ + " .short " flags "\n" #endif =20 -#define BUG_ENTRY(cond_str, insn, flags, ...) \ - __asm__ __volatile__( \ - "1: " insn "\n" \ - _EMIT_BUG_ENTRY \ +#define BUG_ENTRY(cond_str, insn, flags, ...) \ + __asm__ __volatile__( \ + "1: " insn "\n" \ + _EMIT_BUG_ENTRY(2, 1b, "%0", "%1", "%2") \ + ".org 2b+%3\n" \ + ".previous\n" \ : : "i" (WARN_CONDITION_STR(cond_str) __FILE__), "i" (__LINE__), \ - "i" (flags), \ - "i" (sizeof(struct bug_entry)), \ + "i" (flags), \ + "i" (sizeof(struct bug_entry)), \ ##__VA_ARGS__) =20 +#define ARCH_WARN_ASM(file, line, flags, size) \ + "1: twi 31, 0, 0\n" \ + _EMIT_BUG_ENTRY(2, 1b, file, line, flags) \ + ".org 2b+" size "\n" \ + ".previous\n" + +#define ARCH_WARN_REACHABLE + /* * BUG_ON() and WARN_ON() do their best to cooperate with compile-time * optimisations. However depending on the complexity of the condition --=20 2.55.0 From nobody Fri Sep 25 07:55:59 2026 Received: from mail-pz2-f43.google.com (mail-pz2-f43.google.com [74.125.228.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 91A04440644 for ; Tue, 15 Sep 2026 09:05:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.228.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789463135; cv=none; b=J5ThBTaNq6COg1k4yIOudXMFtmSoD8mtaHaQZaZLJXAT3qyaV8HrnWqkqVZmZCFoR9tiKy/vM35n+PtKcXHVVfoCB0zXI5gZuxBLr90fuYZE6Wfu4FZceaw8M9UQJkWqql926Tm9gRO6v+bC4nUMmONeUueLTqdw9htMtrzT/k0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789463135; c=relaxed/simple; bh=uuU/l9JF/iZowlXBWJE6m0AYJaBt58n13GwlZUkEpvo=; h=From:To:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=MLX3ffIcOkU/lc3aZJcPEDLzgMgtr3Wdz9QRZc/jWaVllxetcB8F3Idwo0sh4T3npaPtvll/OKMj9nnY+j5+BKf3uamdd90rNHJw9UuNa9Jr2lo28CrMd0B0IPWrs+dlvQih/PAEPjDVSShvfG4Gl4WTYRw7xMAQsAyvJpFO3rY= 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=T4VW6TDW; arc=none smtp.client-ip=74.125.228.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="T4VW6TDW" Received: by mail-pz2-f43.google.com with SMTP id d2e1a72fcca58-8686f46e4adso2742745b3a.0 for ; Tue, 15 Sep 2026 02:05:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1789463133; x=1790067933; darn=vger.kernel.org; h=content-transfer-encoding:content-type:mime-version:references :in-reply-to:message-id:date:subject:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=vSfuwonf/WIHgTGI6ifOt5SgGmeBPJ0PHGizN2q97L8=; b=T4VW6TDW/qIgh1YlQrTnXqlhA7JlJ2OUTU6Lnunhr22/woI5AP43fV1gBKSxhtcGI1 MiQjvLSGIcU0oaULhZsLmvlifSEg65XY9oW/mgwKryxGDLLvlS2cWKClEN65UoH4XI6T XL6ZQNbEAESDgliuqu2mv9SDNjCAtm7Bcf2G64Am6fWK8+hF0GRwUiXj+fUw3/IurWWQ 6VCrqDhpuZwp/kBNlk5WXdyXTReE0AV+NrQ9/CBXPx++6JkfNMNyQVj6gaZTtzCe5M6+ kqUOo1A7KV7/xnd5nP1LUe9dhYk2rieJC+juKjdnwdRNC+/wFXLgPQxfZc4ak77djHrP kC8Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1789463133; x=1790067933; h=content-transfer-encoding:content-type:mime-version:references :in-reply-to:message-id:date:subject:to:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=vSfuwonf/WIHgTGI6ifOt5SgGmeBPJ0PHGizN2q97L8=; b=yf0Mnjijh4xArUKceUHCRKSdmo7THXOmwLZ/2zW7eP0Gq2a45GAySuqN9ZM48dh0VA 3g8qmKGsZUXY5SL26ExA5RlBQ0jBNecyBW6vIeEt93Mz+XQuZSYB5ux/dScRbxWFB/2b epfKwgFmzYKQYrfzIkMkeJWW7vqttrmyiGg2fH3HWx2nwj7AB5mATQLOJPbQSNff1qWv Tbi2j/AxHjtrsrP59RsUuThqCkw3GYdEYmaluN3ExdmXLcfAMbY9KeHT259Y3BiAyqBr F+6/iz5s4INWZ9QWUxt9LDEo6qPFYcy8510EI9y7iCtY/2T7qrXKkAhnnab03Boin1e5 7Gmw== X-Forwarded-Encrypted: i=1; AKwUvBwrEI1a/Rm6V/CE3DpKCwXr94cOvMkVQpuoW5dJDhOzrxfJhxuOcaH5v2SRTiiUXGfCs8N0XJrbi1Q2AEg=@vger.kernel.org X-Gm-Message-State: AFuF++lLpU46qgICN7oRRBgW9j4hbNArTCIIeloS8upl3BhmiPsaG57M toSRBwuDv0jCu54aOyIc/AAeXwVifdQZJEjGsRvD4AUMYkcGk49Bdb+P X-Gm-Gg: AYBFou1dSb/1ut6M7e0Fkzsd26G6KyqXdnA6rBgHJxiRPhzkMy+o5XCyRqrpmFPoZiJ HfQR7crptbQ7hyN5o/9chyqB1SlH2LalCQKkn3yy/HTuLSMB5zZ6WJwi2IZdaDbaOXsvc5nzYdK 76nJFF77Vr7oHWq7fKO+AFu9ohO6nhj6pegoyDJqayW98oOxEU9f40MnTl9KXsv4WrUWl/F+Ym4 ZLY9r0Va0/fyaH1Z0KskRXhlwIZgyvNvU/f5ZmX4qDPhXui8HFye4OXyPwrdNVWWtBdxP5mAfVg phBDSP0iz5MhFD6bPnIu+mwIQF9/Pohoueh7dm52RXnDYYsjy3tnexQMN5IsFJXQL/Qq4WTWqOr PgOsL54ld13ZbaFTB6bTjJF5MnFm4uuEhp637NEraKpGv2GMVebNIjbKhwUHd1DbVrKTd/9uXI6 EksKBL7muSEIImt7+iCoJRwVfmgdAiABlDyw691rvEHLVElE+VM3xTc8FOfZwyHAHtZ5Y4v6aua xi6A5G13iitPkpmTiT2MbcqGRLvdL+97PRfiwUUlqiQgNHQ9I0/d6ywiOkIpL4= X-Received: by 2002:a05:6a20:d090:b0:3cc:faf3:331a with SMTP id adf61e73a8af0-3db40422652mr13861188637.10.1789463132520; Tue, 15 Sep 2026 02:05:32 -0700 (PDT) Received: from li-1a3e774c-28e4-11b2-a85c-acc9f2883e29.bl1-in.ibm.com ([129.41.58.4]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-cc4c65a8120sm6495512a12.30.2026.09.15.02.05.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 15 Sep 2026 02:05:31 -0700 (PDT) From: "Mukesh Kumar Chaurasiya (IBM)" To: maddy@linux.ibm.com, mpe@ellerman.id.au, npiggin@gmail.com, chleroy@kernel.org, ojeda@kernel.org, boqun@kernel.org, gary@garyguo.net, bjorn3_gh@protonmail.com, lossin@kernel.org, a.hindborg@kernel.org, aliceryhl@google.com, tmgross@umich.edu, dakr@kernel.org, daniel.almeida@collabora.com, tamird@kernel.org, acourbot@nvidia.com, work@onurozkan.dev, pjw@kernel.org, palmer@dabbelt.com, aou@eecs.berkeley.edu, alex@ghiti.fr, nathan@kernel.org, ndesaulniers@google.com, morbo@google.com, justinstitt@google.com, mkchauras@gmail.com, ynorov@nvidia.com, david@davidgow.net, joelagnelf@nvidia.com, fujita.tomonori@gmail.com, linkmauve@linkmauve.fr, linuxppc-dev@lists.ozlabs.org, linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-riscv@lists.infradead.org, llvm@lists.linux.dev Subject: [PATCH V5 2/2] rust: kernel: Add KUnit tests for powerpc ARCH_WARN_ASM bug table emission Date: Tue, 15 Sep 2026 14:34:53 +0530 Message-ID: <20260915090453.1227034-3-mkchauras@gmail.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260915090453.1227034-1-mkchauras@gmail.com> References: <20260915090453.1227034-1-mkchauras@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Verify that the __bug_table entry emitted by ARCH_WARN_ASM has a correct bug_addr displacement =E2=80=94 i.e. the '1b' label reference in _EMIT_BUG_= ENTRY resolves to the trap instruction =E2=80=94 by calling find_bug() with the e= xact virtual address of the twi instruction, mirroring what the real powerpc trap handler does. The trap address is captured at link time via a .dc.a 1b relocation placed in .data by the global_asm! block. global_asm! is used instead of asm! because LLVM eliminates asm! blocks in dead branches; global_asm! is file-scope and always emitted. BUG_KUNIT_TRAP_ADDR is defined as a .global symbol directly on the .dc.a word so the linker relocation lands on it =E2= =80=94 a Rust static initialized to zero would end up in BSS where relocations are not applied. .dc.a emits a pointer-width word (4 bytes on ppc32, 8 bytes on ppc64), so BUG_KUNIT_TRAP_ADDR is declared as usize on the Rust side, making the tests correct on both ppc32 and ppc64. The global_asm! block is split into two cfg-gated variants (CONFIG_PPC64 / !CONFIG_PPC64) to select the right .balign since concat!() only accepts literals. Five tests are included in the rust_kernel_bug_powerpc suite: bug_entry_found - find_bug() returns non-NULL for the trap addres= s, proving the bug_addr displacement is correct bug_entry_is_warning - the emitted entry has BUGFLAG_WARNING set bug_entry_file - bug_get_file_line() returns the correct source file (requires CONFIG_DEBUG_BUGVERBOSE) bug_entry_line - the recorded line number is non-zero, confirming the {line} operand was substituted correctly (requires CONFIG_DEBUG_BUGVERBOSE) bug_entry_addr_is_in_text - kernel_text_address() confirms the trap addre= ss lies in kernel text, not data or zero The suite is named rust_kernel_bug_powerpc and the Kconfig option CONFIG_RUST_BUG_POWERPC_KUNIT_TEST depends on PPC && GENERIC_BUG, covering both ppc32 and ppc64. Tested on ppc64le (ltcfujiaac-lp3, 7.3.0-rc1+): pass:5 fail:0 skip:0. Tested on ppc32 Book3S (QEMU mac99 G4, chrp32_defconfig): pass:5 fail:0 ski= p:0. Tested on ppc64le (QEMU pseries, pseries_le_defconfig): pass:5 fail:0 skip:= 0. Signed-off-by: Mukesh Kumar Chaurasiya (IBM) --- rust/kernel/Kconfig.test | 13 +++ rust/kernel/bug.rs | 209 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 222 insertions(+) diff --git a/rust/kernel/Kconfig.test b/rust/kernel/Kconfig.test index e6a5c7a795f0..5a82f0812c89 100644 --- a/rust/kernel/Kconfig.test +++ b/rust/kernel/Kconfig.test @@ -83,4 +83,17 @@ config RUST_BITFIELD_KUNIT_TEST =20 If unsure, say N. =20 +config RUST_BUG_POWERPC_KUNIT_TEST + bool "KUnit tests for powerpc ARCH_WARN_ASM bug table emission" if !KUNIT= _ALL_TESTS + depends on PPC && GENERIC_BUG + default KUNIT_ALL_TESTS + help + This option enables KUnit tests that verify ARCH_WARN_ASM emits a + correct __bug_table entry on powerpc (both ppc32 and ppc64): the + bug_addr displacement must resolve back to the trap instruction so + that find_bug() can locate the entry =E2=80=94 exactly as the real trap + handler does. + + If unsure, say N. + endif diff --git a/rust/kernel/bug.rs b/rust/kernel/bug.rs index 3566f0234ca4..cd90bd511479 100644 --- a/rust/kernel/bug.rs +++ b/rust/kernel/bug.rs @@ -152,3 +152,212 @@ macro_rules! warn_on { cond }}; } + +// Test-only constants and file static referenced by the global_asm block = below. +// +// global_asm! is file-scope and always emitted =E2=80=94 LLVM cannot elim= inate it, +// unlike asm! inside a function which is subject to dead-code removal. +// +// BUG_KUNIT_TRAP_ADDR is declared as a .global symbol entirely inside the +// global_asm! block so the .dc.a 1b relocation lands directly on it. +// A Rust static initialized to zero would end up in BSS; the linker does +// not apply relocations to BSS, so the address would stay zero at runtime. +#[cfg(CONFIG_RUST_BUG_POWERPC_KUNIT_TEST)] +mod test_statics { + use crate::bindings::{bug_entry, BUGFLAG_WARNING, TAINT_WARN}; + + pub(super) const FLAGS: u32 =3D BUGFLAG_WARNING | (TAINT_WARN << 8); + pub(super) const SIZE: usize =3D core::mem::size_of::(); + + // LINE and BUG_KUNIT_FILE are only referenced by the {file}/{line} + // operands in global_asm!, which are only present when + // CONFIG_DEBUG_BUGVERBOSE is set (the non-verbose _EMIT_BUG_ENTRY + // drops the file/line fields from the bug table entry entirely). + #[cfg(CONFIG_DEBUG_BUGVERBOSE)] + pub(super) const LINE: u32 =3D line!(); + + // Null-terminated source file name =E2=80=94 the assembler references= this symbol + // for the verbose file pointer in __bug_table, same as warn_flags!. + #[cfg(CONFIG_DEBUG_BUGVERBOSE)] + const _FILE: &[u8] =3D file!().as_bytes(); + #[cfg(CONFIG_DEBUG_BUGVERBOSE)] + #[no_mangle] + pub(super) static BUG_KUNIT_FILE: [u8; _FILE.len() + 1] =3D { + let mut bytes =3D [0u8; _FILE.len() + 1]; + let mut i =3D 0; + while i < _FILE.len() { + bytes[i] =3D _FILE[i]; + i +=3D 1; + } + bytes + }; +} + +// Emit ARCH_WARN_ASM at file scope and capture the trap address. +// +// BUG_KUNIT_TRAP_ADDR is defined as a .global symbol right on top of the +// .dc.a 1b directive so the linker resolves the relocation directly into +// that symbol's storage =E2=80=94 no BSS, no zero-init problem. +// .dc.a emits a pointer-width word (4 bytes on ppc32, 8 bytes on ppc64), +// matching the usize declaration on the Rust side. +#[cfg(all(CONFIG_RUST_BUG_POWERPC_KUNIT_TEST, CONFIG_PPC64, CONFIG_DEBUG_B= UGVERBOSE))] +::core::arch::global_asm!( + concat!( + include!(concat!(env!("OBJTREE"), "/rust/kernel/generated_arch_war= n_asm.rs")), + ".pushsection .data\n\t", + ".balign 8\n\t", + ".global BUG_KUNIT_TRAP_ADDR\n\t", + "BUG_KUNIT_TRAP_ADDR:\n\t", + ".dc.a 1b\n\t", + ".popsection\n", + ), + file =3D sym test_statics::BUG_KUNIT_FILE, + line =3D const test_statics::LINE, + flags =3D const test_statics::FLAGS, + size =3D const test_statics::SIZE, +); + +#[cfg(all(CONFIG_RUST_BUG_POWERPC_KUNIT_TEST, CONFIG_PPC64, not(CONFIG_DEB= UG_BUGVERBOSE)))] +::core::arch::global_asm!( + concat!( + include!(concat!(env!("OBJTREE"), "/rust/kernel/generated_arch_war= n_asm.rs")), + ".pushsection .data\n\t", + ".balign 8\n\t", + ".global BUG_KUNIT_TRAP_ADDR\n\t", + "BUG_KUNIT_TRAP_ADDR:\n\t", + ".dc.a 1b\n\t", + ".popsection\n", + ), + flags =3D const test_statics::FLAGS, + size =3D const test_statics::SIZE, +); + +#[cfg(all(CONFIG_RUST_BUG_POWERPC_KUNIT_TEST, not(CONFIG_PPC64), CONFIG_DE= BUG_BUGVERBOSE))] +::core::arch::global_asm!( + concat!( + include!(concat!(env!("OBJTREE"), "/rust/kernel/generated_arch_war= n_asm.rs")), + ".pushsection .data\n\t", + ".balign 4\n\t", + ".global BUG_KUNIT_TRAP_ADDR\n\t", + "BUG_KUNIT_TRAP_ADDR:\n\t", + ".dc.a 1b\n\t", + ".popsection\n", + ), + file =3D sym test_statics::BUG_KUNIT_FILE, + line =3D const test_statics::LINE, + flags =3D const test_statics::FLAGS, + size =3D const test_statics::SIZE, +); + +#[cfg(all(CONFIG_RUST_BUG_POWERPC_KUNIT_TEST, not(CONFIG_PPC64), not(CONFI= G_DEBUG_BUGVERBOSE)))] +::core::arch::global_asm!( + concat!( + include!(concat!(env!("OBJTREE"), "/rust/kernel/generated_arch_war= n_asm.rs")), + ".pushsection .data\n\t", + ".balign 4\n\t", + ".global BUG_KUNIT_TRAP_ADDR\n\t", + "BUG_KUNIT_TRAP_ADDR:\n\t", + ".dc.a 1b\n\t", + ".popsection\n", + ), + flags =3D const test_statics::FLAGS, + size =3D const test_statics::SIZE, +); + +#[cfg(CONFIG_RUST_BUG_POWERPC_KUNIT_TEST)] +#[::kernel::macros::kunit_tests(rust_kernel_bug_powerpc)] +mod tests { + use crate::bindings; + + fn trap_addr() -> usize { + // BUG_KUNIT_TRAP_ADDR is a .global symbol defined in the global_a= sm! + // block above, placed in .data at the exact .dc.a 1b relocation w= ord. + // The linker resolves it to the virtual address of the twi instru= ction + // before any Rust code runs, so reading it here is always safe. + extern "C" { + // .dc.a emits a pointer-width word: 4 bytes on ppc32, 8 on pp= c64. + // usize matches the native pointer width on both. + static BUG_KUNIT_TRAP_ADDR: usize; + } + // SAFETY: read-only after link time, no concurrent mutation possi= ble. + unsafe { BUG_KUNIT_TRAP_ADDR } + } + + /// The `__bug_table` entry emitted by `ARCH_WARN_ASM` must be locatab= le + /// via `find_bug()` using the trap instruction's address. A NULL res= ult + /// means the `1b` label reference in `_EMIT_BUG_ENTRY` resolved to the + /// wrong address and the real trap handler would not recognise the si= te. + #[test] + fn bug_entry_found() { + // Non-zero proves the .dc.a relocation was resolved by the linker. + assert!(trap_addr() !=3D 0); + + // SAFETY: find_bug() is always safe to call with any address; it + // simply walks __bug_table and returns NULL if nothing matches. + let entry =3D unsafe { bindings::find_bug(trap_addr()) }; + // Non-NULL proves the bug_addr displacement in _EMIT_BUG_ENTRY is= correct. + assert!(!entry.is_null()); + } + + /// The emitted entry must be flagged as a warning (not a hard BUG). + #[test] + fn bug_entry_is_warning() { + assert!(trap_addr() !=3D 0); + let entry =3D unsafe { bindings::find_bug(trap_addr()) }; + assert!(!entry.is_null()); + // SAFETY: entry is non-null and points to a valid bug_entry. + let flags =3D unsafe { (*entry).flags } as u32; + assert!(flags & bindings::BUGFLAG_WARNING !=3D 0); + } + + /// With `CONFIG_DEBUG_BUGVERBOSE` the entry must record a non-null fi= le + /// pointer pointing back into this source file. + #[test] + #[cfg(CONFIG_DEBUG_BUGVERBOSE)] + fn bug_entry_file() { + use core::ffi::CStr; + + assert!(trap_addr() !=3D 0); + let entry =3D unsafe { bindings::find_bug(trap_addr()) }; + assert!(!entry.is_null()); + + let mut file_ptr: *const core::ffi::c_char =3D core::ptr::null(); + let mut line: u32 =3D 0; + // SAFETY: entry is non-null and valid; file_ptr and line are local + // variables passed as out-parameters. + unsafe { bindings::bug_get_file_line(entry, &mut file_ptr, &mut li= ne) }; + + assert!(!file_ptr.is_null()); + // SAFETY: file_ptr is a null-terminated C string from BUG_KUNIT_F= ILE. + let file_str =3D unsafe { CStr::from_ptr(file_ptr) }.to_str().unwr= ap_or(""); + assert!(file_str.contains("bug")); + } + + /// With `CONFIG_DEBUG_BUGVERBOSE` the recorded line number must be + /// non-zero (a zero line would mean the asm operand was not substitut= ed). + #[test] + #[cfg(CONFIG_DEBUG_BUGVERBOSE)] + fn bug_entry_line() { + assert!(trap_addr() !=3D 0); + let entry =3D unsafe { bindings::find_bug(trap_addr()) }; + assert!(!entry.is_null()); + + let mut file_ptr: *const core::ffi::c_char =3D core::ptr::null(); + let mut line: u32 =3D 0; + // SAFETY: entry is non-null and valid. + unsafe { bindings::bug_get_file_line(entry, &mut file_ptr, &mut li= ne) }; + + assert!(line !=3D 0); + } + + /// The trap address stored in `__bug_table` must lie within the kernel + /// text segment. If the label reference in `_EMIT_BUG_ENTRY` resolved + /// to data or zero, `kernel_text_address()` would return false. + #[test] + fn bug_entry_addr_is_in_text() { + assert!(trap_addr() !=3D 0); + // SAFETY: kernel_text_address() is always safe to call with any a= ddr. + let in_text =3D unsafe { bindings::kernel_text_address(trap_addr()= ) }; + assert!(in_text !=3D 0); + } +} --=20 2.55.0