From patchwork Sun Feb 2 13:05:43 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Asahi Lina X-Patchwork-Id: 13956518 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 46F94C02194 for ; Sun, 2 Feb 2025 13:06:46 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 0B2126B007B; Sun, 2 Feb 2025 08:06:44 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 062356B0085; Sun, 2 Feb 2025 08:06:44 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id D82DF6B0089; Sun, 2 Feb 2025 08:06:43 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0013.hostedemail.com [216.40.44.13]) by kanga.kvack.org (Postfix) with ESMTP id A4D796B007B for ; Sun, 2 Feb 2025 08:06:43 -0500 (EST) Received: from smtpin05.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay04.hostedemail.com (Postfix) with ESMTP id 1F14B1A20B2 for ; Sun, 2 Feb 2025 13:06:43 +0000 (UTC) X-FDA: 83075029086.05.6581D9B Received: from mail.marcansoft.com (marcansoft.com [212.63.210.85]) by imf18.hostedemail.com (Postfix) with ESMTP id D4FA51C000C for ; Sun, 2 Feb 2025 13:06:40 +0000 (UTC) Authentication-Results: imf18.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=a6FbgBjV; spf=pass (imf18.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net; dmarc=pass (policy=quarantine) header.from=asahilina.net ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1738501601; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=JCfjxk6jBLm4PuhXdtZUIC5jGtPufrSGA9FWY7XOt7o=; b=GTTPZoaYDhwg1nm8li0s9mveITek2Fx2GMbU08geYV7420yYJhMwXOwLOCg9X+6TBo+E9B JH0QVa2J43vuHMivfn8qD42/PeHSrrw8kR8Tkq4xDShHmFOj4KA2kJWN5U0PLILoewQSfM WvDyIYJV4FsVoOCaCbO3AN+IbigUp8c= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1738501601; a=rsa-sha256; cv=none; b=MmtHPKkOMpynjOe21iTS1CUnsa45UuRp+dljcqUi6Wzi7IigCakSzqNlVblObHRymSLs6E QXBasWGcKgdvRyyOVgcVdhB9yUt1Y3YdfQ7qaQ85D4XK32yav0ADoLgg3ziCgzyP8dSyFw srPDwHtGyD7ii3NqRHSR8WYEKgGChY4= ARC-Authentication-Results: i=1; imf18.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=a6FbgBjV; spf=pass (imf18.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net; dmarc=pass (policy=quarantine) header.from=asahilina.net Received: from [127.0.0.1] (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: sendonly@marcansoft.com) by mail.marcansoft.com (Postfix) with ESMTPSA id C261F42601; Sun, 2 Feb 2025 13:06:36 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=asahilina.net; s=default; t=1738501598; bh=db+CTl7vXN85Dcw+hwBoMAovv2p9XLFk8QMb0+h2eUk=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=a6FbgBjVng3G981fDt43dF40MXlTw0rneaJMabBeyx+aIR56WSn59r40VougNzdn9 sAN00S22Hl9EimtHryyQ2WLebuOp1SFD1vHROBQQm6o5hLtff/bVxEfldzY26ZVKCs 90Iz6seFHpmJcG0RC9KmKpu9BAkJYuL4ZW+Ue+5w8gLxQ0berFYK9GcuremJ+f6LvT q8Kf9DMk8LmruH8sMGyzTRbNisX6FmMrS7gXSJFmY9l8H3XOCDyvP7fQDgR1XFX6jr Z+/7MUCQliMV8rJrfuUhi+igiiZ2uSyYJIZs8Cf6A0ZQqHkSnIj13WdS1w9EADuKLK I2PobK+BvOepA== From: Asahi Lina Date: Sun, 02 Feb 2025 22:05:43 +0900 Subject: [PATCH 1/6] rust: types: Add Ownable/Owned types MIME-Version: 1.0 Message-Id: <20250202-rust-page-v1-1-e3170d7fe55e@asahilina.net> References: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> In-Reply-To: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross Cc: Jann Horn , Matthew Wilcox , Paolo Bonzini , Danilo Krummrich , Wedson Almeida Filho , Valentin Obst , Andrew Morton , linux-mm@kvack.org, airlied@redhat.com, Abdiel Janulgue , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, asahi@lists.linux.dev, Asahi Lina X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1738501594; l=5188; i=lina@asahilina.net; s=20240902; h=from:subject:message-id; bh=db+CTl7vXN85Dcw+hwBoMAovv2p9XLFk8QMb0+h2eUk=; b=v4PEmnpGzrguSNB9PT6BnZr6+ea6iCaG0tCqNXz3t0LXfHn0sXubw18gYdI27epEwjEXxH8Ou PmgIcPGn+PiB7ALp4QLTfYWJgBI28JDbm3gcQoszN3vZbwEzEW2Tw8a X-Developer-Key: i=lina@asahilina.net; a=ed25519; pk=tpv7cWfUnHNw5jwf6h4t0gGgglt3/xcwlfs0+A/uUu8= X-Rspamd-Queue-Id: D4FA51C000C X-Stat-Signature: 9jf99f7opb79cnq3nshtitjkwqwr4nyb X-Rspam-User: X-Rspamd-Server: rspam12 X-HE-Tag: 1738501600-990688 X-HE-Meta: U2FsdGVkX19prK/zZweujjmGnJ86OeOxAtA6Id03eUzYa5f88+6aAFGvtGUnquLrFjckWdnU+dw7bHIHBwReAg1ehQX6epIum0ZGam2hvGHyHi5Q/AntF/Elai/B37lcgLAMfOBa+bAx2MVXWpljR5d6XBOG21UHqWZvVLkAlxUA2is+1lp6n0c6llIx1rN/5YNQJt5BEUk0RttZz1bxu/+alDoP+5APSiDTd3J/a1/C8FvayJ1y19WaEqVXPBG5slTUpeWNN9mpFRL7Lq7YRbpax0Yv32dORn97Cwklx1utFFkk5Y5vvx1xu81TCJeUUUI6Ostzt02B2AzTEe0WRlcEdP3ks12ElG4dtF9Me0g3Jn821oXmuudX2mnWULaIX14u5Wy/utJjAq1uCUOCK8FyNXebZJCg8Oz9bwayDDO0dPwIJtpHQZnmxqoGKcr1RKeMC+CBzZy80pCLYpkde+ElISFPBKTUjz6vAYQE9YTk6A4IVyU/keB9ve5rTSiD5mDbu9eqX3ZkhaWsjshYfssFEFMwLv4aYMsODuBzLfibp7Mo0eTg++hOlMtJco6wmAPmKyt+oZbvmJajFYOEKHGw/1Ww6uIqz5w4Q5GAnqkBvcqcWm9Y+PZCHaSSb3UUcA3KPgXeWsHE2hlswlkhLBhgp4KAAXLByT21x3CX06NHcSvyOIyppItXxvZJFdeZnI14dZSAvVL6axUFEnTYHbE0d0FKc5QrsnRz0ZCBuc+J9GMvsFHIgDRlgZiCd34hj4zwZnPOOMh8lWeXkb/ajunZA11kgNJ6hyyS2v2UmSrP0/JzEr674Gj3/6q2a6nA0kWfVacBLADfm20pR050rjwF85LnF8PSbajfjiIVfXQq3rJUWhdDCYIjBgXCp8Drh2zX/Y+8+Ix3+y5dNs2Dq6E1Bmdr0BGu6fsChqLGIRlA5n00drkHbau1u9mgtM+sQZRYi1o5lrG7IHfXvbx 1dSZM8nK Y43IlQWTggfIb+Mw/Z06UeXcAqUTywtm+q0lNM3XoQrWGIF/+KBGzDdPdNJfO3icpU9oggxA2peSoEPMdlQne6atZul+QiwPP/9BrDMYjjOrpxE5PM/0qgVyIQYxTvuUp3jqfBsndwVz3UNoqo4h4sl21Mkfjc2GhJKU6G8fiUIpqZsOApI6MAu5ePv3zn8f/xDbk/GbQ6RUpVA+PRXOZa50r9zq5paEtLe9Atq8K3UwfDwIWXPcxCNa5qfMyS7Xip6VLYXvfkDYtS3u85LlJRRwRlX0I9kaCNMJDKZvTWHtaOovqvHRBPfduKH3wBO2dlUeIF8SmFstpMeqhDvlYM6DgbZx5kmdBuEAJeBhpkPuAbHz1tnCcXwEQ7mKly01su9WISZTPZ9fwYMsy3aLY2sHim2QJo3+wN18mmufbbrttI8Q= X-Bogosity: Unsure, tests=bogofilter, spamicity=0.500000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: By analogy to AlwaysRefCounted and ARef, an Ownable type is a (typically C FFI) type that *may* be owned by Rust, but need not be. Unlike AlwaysRefCounted, this mechanism expects the reference to be unique within Rust, and does not allow cloning. Conceptually, this is similar to a KBox, except that it delegates resource management to the T instead of using a generic allocator. Signed-off-by: Asahi Lina --- rust/kernel/types.rs | 110 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 110 insertions(+) diff --git a/rust/kernel/types.rs b/rust/kernel/types.rs index ec6457bb3084ae327c38ba4ba79b1601aef38244..0bee56153dcea47fb1321162df6b8765b5436e9f 100644 --- a/rust/kernel/types.rs +++ b/rust/kernel/types.rs @@ -479,6 +479,116 @@ fn drop(&mut self) { } } +/// Types that may be owned by Rust code or borrowed, but have a lifetime managed by C code. +/// +/// It allows such types to define their own custom destructor function to be called when +/// a Rust-owned reference is dropped. +/// +/// This is usually implemented by wrappers to existing structures on the C side of the code. +/// +/// # Safety +/// +/// Implementers must ensure that any objects borrowed directly as `&T` stay alive for the duration +/// of the lifetime, and that any objects owned by Rust as `Owned`) stay alive while that owned +/// reference exists, until the [`Ownable::release()`] trait method is called. +pub unsafe trait Ownable { + /// Releases the object (frees it or returns it to foreign ownership). + /// + /// # Safety + /// + /// Callers must ensure that the object is no longer referenced after this call. + unsafe fn release(this: NonNull); +} + +/// A subtrait of Ownable that asserts that an `Owned` Rust reference is not only unique +/// within Rust and keeps the `T` alive, but also guarantees that the C code follows the +/// usual mutable reference requirements. That is, the kernel will never mutate the +/// `T` (excluding internal mutability that follows the usual rules) while Rust owns it. +/// +/// When this type is implemented for an [`Ownable`] type, it allows `Owned` to be +/// dereferenced into a &mut T. +/// +/// # Safety +/// +/// Implementers must ensure that the kernel never mutates the underlying type while +/// Rust owns it. +pub unsafe trait OwnableMut: Ownable {} + +/// An owned reference to an ownable kernel object. +/// +/// The object is automatically freed or released when an instance of [`Owned`] is +/// dropped. +/// +/// # Invariants +/// +/// The pointer stored in `ptr` is non-null and valid for the lifetime of the [`Owned`] instance. +pub struct Owned { + ptr: NonNull, + _p: PhantomData, +} + +// SAFETY: It is safe to send `Owned` to another thread when the underlying `T` is `Send` because +// it effectively means sending a unique `&mut T` pointer (which is safe because `T` is `Send`). +unsafe impl Send for Owned {} + +// SAFETY: It is safe to send `&Owned` to another thread when the underlying `T` is `Sync` +// because it effectively means sharing `&T` (which is safe because `T` is `Sync`). +unsafe impl Sync for Owned {} + +impl Owned { + /// Creates a new instance of [`Owned`]. + /// + /// It takes over ownership of the underlying object. + /// + /// # Safety + /// + /// Callers must ensure that the underlying object is acquired and can be considered owned by + /// Rust. + pub(crate) unsafe fn from_raw(ptr: NonNull) -> Self { + // INVARIANT: The safety requirements guarantee that the new instance now owns the + // reference. + Self { + ptr, + _p: PhantomData, + } + } + + /// Consumes the `Owned`, returning a raw pointer. + /// + /// This function does not actually relinquish ownership of the object. + /// After calling this function, the caller is responsible for ownership previously managed + /// by the `Owned`. + #[allow(dead_code)] + pub(crate) fn into_raw(me: Self) -> NonNull { + ManuallyDrop::new(me).ptr + } +} + +impl Deref for Owned { + type Target = T; + + fn deref(&self) -> &Self::Target { + // SAFETY: The type invariants guarantee that the object is valid. + unsafe { self.ptr.as_ref() } + } +} + +impl DerefMut for Owned { + fn deref_mut(&mut self) -> &mut Self::Target { + // SAFETY: The type invariants guarantee that the object is valid, + // and that we can safely return a mutable reference to it. + unsafe { self.ptr.as_mut() } + } +} + +impl Drop for Owned { + fn drop(&mut self) { + // SAFETY: The type invariants guarantee that the `Owned` owns the object we're about to + // release. + unsafe { T::release(self.ptr) }; + } +} + /// A sum type that always holds either a value of type `L` or `R`. /// /// # Examples From patchwork Sun Feb 2 13:05:44 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Asahi Lina X-Patchwork-Id: 13956519 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0324FC02193 for ; Sun, 2 Feb 2025 13:06:49 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 065676B0085; Sun, 2 Feb 2025 08:06:46 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 014946B0088; Sun, 2 Feb 2025 08:06:45 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id DA8A86B0089; Sun, 2 Feb 2025 08:06:45 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id BD6586B0085 for ; Sun, 2 Feb 2025 08:06:45 -0500 (EST) Received: from smtpin21.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay09.hostedemail.com (Postfix) with ESMTP id 5C3E381F92 for ; Sun, 2 Feb 2025 13:06:45 +0000 (UTC) X-FDA: 83075029170.21.3009D4D Received: from mail.marcansoft.com (marcansoft.com [212.63.210.85]) by imf20.hostedemail.com (Postfix) with ESMTP id 6B0831C000F for ; Sun, 2 Feb 2025 13:06:43 +0000 (UTC) Authentication-Results: imf20.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=j13+77B4; dmarc=pass (policy=quarantine) header.from=asahilina.net; spf=pass (imf20.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1738501603; a=rsa-sha256; cv=none; b=W0V+SEI/LtWga4ikQQKVBxJ1byGdIcfhSzrTGfmYd1Ja1OQX7JhctKjGPaJaxd4tIbBcx6 roDxss6riN9Cc0EYOvew7gLnms4NS1RFj0dlFy8xMqDunZaNn7bkK2V0P/ui/T4RmWorw6 33hy8cUtwza+ibTnGhmVQ1HrkGT+9Bk= ARC-Authentication-Results: i=1; imf20.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=j13+77B4; dmarc=pass (policy=quarantine) header.from=asahilina.net; spf=pass (imf20.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1738501603; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=PVqe0RlXqOVlirCUFA1CMDAUAAVS3t+d1iTU1+IF6fk=; b=qjMLRaoildy5KVSfFKF74TfD3X0Xq50WbHpxBppV9+3l/YfgBc6m0QOhcqCIEdjK69EEoi yZib123O3c+Tpjs//RrlfmXeZY3VGkS884jUiJwbeAanrGOtSK4Itc9Xx7IvE8bVjR3MZv Pi3lM8vv+1tcPoGlyUJ2NjX7i1VxfaQ= Received: from [127.0.0.1] (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: sendonly@marcansoft.com) by mail.marcansoft.com (Postfix) with ESMTPSA id 0AE3C4269B; Sun, 2 Feb 2025 13:06:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=asahilina.net; s=default; t=1738501601; bh=i4Ab3HjgvvGhPot4YFk4jEpbbo5OwUVep0fKUcItVqY=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=j13+77B4uDEiUiAv4VmriWW3KBa28+PJ+rGSbk9sG6oe+/Vc9YDMzmV7eNxU4Ovbe fcZvQetCX39EHEG00wlsexJZddtS+9Q0eYfuh+ZpU/Itzhea8VcX+R07bC5utcvT7v UL096wFWUozQwwAur7vKnZvzJ69/LuSXUmiP514WLvkNQb1OXmuodgNTxNI3s/WEjc QBbr6bR2qpm7Kpe92vLmd24v4QKLjhjKs8O/Xjobmulm5S/oEk9r7ipJKAoSLcAmq7 0ek/0u6XcL/YLJ1hpUkz3zcAgRBVmKPlWUB9p9RA2cO9tz98sdjH0jBx+6Yvkz2U6m 9FiA+JGRbSyow== From: Asahi Lina Date: Sun, 02 Feb 2025 22:05:44 +0900 Subject: [PATCH 2/6] rust: page: Convert to Ownable MIME-Version: 1.0 Message-Id: <20250202-rust-page-v1-2-e3170d7fe55e@asahilina.net> References: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> In-Reply-To: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross Cc: Jann Horn , Matthew Wilcox , Paolo Bonzini , Danilo Krummrich , Wedson Almeida Filho , Valentin Obst , Andrew Morton , linux-mm@kvack.org, airlied@redhat.com, Abdiel Janulgue , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, asahi@lists.linux.dev, Asahi Lina X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1738501594; l=3247; i=lina@asahilina.net; s=20240902; h=from:subject:message-id; bh=i4Ab3HjgvvGhPot4YFk4jEpbbo5OwUVep0fKUcItVqY=; b=gUHcqq+q5mqcWHe6iq9f1yxIulhbcJU+/xJBVOGRrtI5rZfJKz3keo8IzgHn3owhyqq53MKvh /PP7nIbYuJVA+cau3fDKRYqaejphd+pg0QPqP6nq+mCd5L8wHvID/MN X-Developer-Key: i=lina@asahilina.net; a=ed25519; pk=tpv7cWfUnHNw5jwf6h4t0gGgglt3/xcwlfs0+A/uUu8= X-Rspamd-Server: rspam04 X-Rspamd-Queue-Id: 6B0831C000F X-Stat-Signature: tf5cckpz7w74dydgw47dxm9mo9pnd8fq X-Rspam-User: X-HE-Tag: 1738501603-566730 X-HE-Meta: U2FsdGVkX18DMoIrGxqaFvkq2B4Ym5PpWd6VgRHJvpfCGBnHujc2CZuE1B5B9RJZaFj+fHnplt8oNH5Y9VP0/hak/7sOTKO9TgPkpOI3RHHqB6N7UlKUXWbsiPWRYk0YEp6vKMmBDhcL6pEcHaaMJ2kblJSKxM3A6skfjof3VmmJWx++iycrvj9R5boDJXdgKYKrbhqwQ7RBfp+nmNKjOtTVGenFE8VWfOvgSr8RtV3j7jNvtm2buXXmJbuQh5p24m52CaNGiCFaNlMeRuZwuAhwWeyIRnD5lhV6Kj9Bsapg6rKwRXlkveDKJ1OIVaVMPnWOV5Ww7dzIrmFLbIWub8jAnIaP69DiqHAdu/mLAPrhp4fQ08ccY7BI3q4CAGCRRQp9iB0oAzB2lDCOIQ+5SnRhLOCsCMM8HDFlsW0YfCCPMu5KFmeG7wjO8GbrtH1UDShpvj+ElDJDZBEejh4msEjoZG+IZelG6Bl5A7s4RA0CfZk0yMN7mvJ2IR5mdz3TR2lFBDAS4Gvq8vdNLU6B8Tby3K93S9691FVx6ojSm5e1SWEPBQAvSlRZRhEfMcGDIsc5ZKw1EHSVO+E4oEPu5QXABmKbZpm3VPaIAB8CwKZaRAozDehJG/HYKNLFqEJ9xJiAsYTlvhYxoQNX38P+F8/CyNemNjVofLw3GjIaUl8vf8gS0VJnNfbR8ofHpSAV49c63TvZuWeDgGrepi8Wz1Pp29ALR1qiy0V67SJatKZ0O2YU7jKYJibrzG90uLDBSj08tNS2aFTep2zblHKGtI68E1zA79D+JE/l5oEpgZkzLv2VktVmLMAFN8TAm6fbgW3GrsCI7uesYwulZEAwu0UJgMscHYHeIT6wco0I4PeK9EIiGiYK6oEVOgox8QaIZkODpRn1b3YYtVsef7WaqbjX8SVAEFi9Rl6rzpZt/BSGcQZs4uqjijetjnYe0hnY6WQNr9TttU7Rclg6jo/ eh2UPutc qms0b4YC8TDYGh/LIfr1GgSGDxSws6HkkZ6UpLSHToV7JbArhh2d8R7wf7IHp276awY94FT9Ie3G4R+w9K1vS/vUISd9zTmORHbUv+NQmAUSf2cLddnmWEnXQkvLorHm0gFYqjxHE4tITfbclohEbt7zpOAPYUVwrTL7iUhf9O0nh0hkB4ByrwF5fhGA4NNxaJfzJLjK+CPQjF06pQ+9QQCImSZWRcnzc35+9YLF75jVi6BzYtMLFa1gkJy7G8CFCK5CRsYAuMG0GrNJ9FAPrtrjI2ix14L+S4r7sf0F6DgA0wDOUjH7HJ3Cj/7JtXrIURWPaQ+NTZgRZPgR8c0Vta6Qu+4EgsPa5CDbSz72wHLwt/Bqau315xTi4NdQIT+B1T4bB3Td8VjlyMT9KJQvQt8wVfPk2IXa5KzH9 X-Bogosity: Unsure, tests=bogofilter, spamicity=0.499980, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: This allows Page references to be returned as borrowed references, without necessarily owning the struct page. Signed-off-by: Asahi Lina Reviewed-by: Alice Ryhl Reviewed-by: Fiona Behrens --- rust/kernel/page.rs | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/rust/kernel/page.rs b/rust/kernel/page.rs index fdac6c375fe46e1ba589f1640afeae3e001e39ae..0b6cbe02522ab6e6e1810288ad23af4e4aa587d8 100644 --- a/rust/kernel/page.rs +++ b/rust/kernel/page.rs @@ -7,6 +7,7 @@ bindings, error::code::*, error::Result, + types::{Opaque, Ownable, Owned}, uaccess::UserSliceReader, }; use core::ptr::{self, NonNull}; @@ -30,13 +31,10 @@ pub const fn page_align(addr: usize) -> usize { (addr + (PAGE_SIZE - 1)) & PAGE_MASK } -/// A pointer to a page that owns the page allocation. -/// -/// # Invariants -/// -/// The pointer is valid, and has ownership over the page. +/// An object representing a memory page in the kernel (`struct page`). +#[repr(transparent)] pub struct Page { - page: NonNull, + page: Opaque, } // SAFETY: Pages have no logic that relies on them staying on a given thread, so moving them across @@ -71,19 +69,20 @@ impl Page { /// let page = Page::alloc_page(GFP_KERNEL | __GFP_ZERO)?; /// # Ok(()) } /// ``` - pub fn alloc_page(flags: Flags) -> Result { + pub fn alloc_page(flags: Flags) -> Result, AllocError> { // SAFETY: Depending on the value of `gfp_flags`, this call may sleep. Other than that, it // is always safe to call this method. let page = unsafe { bindings::alloc_pages(flags.as_raw(), 0) }; let page = NonNull::new(page).ok_or(AllocError)?; - // INVARIANT: We just successfully allocated a page, so we now have ownership of the newly - // allocated page. We transfer that ownership to the new `Page` object. - Ok(Self { page }) + // SAFETY: We just successfully allocated a page, so we now have ownership of the newly + // allocated page. We transfer that ownership to the new `Owned` object. + // Since `Page` is transparent, we can cast the pointer directly. + Ok(unsafe { Owned::from_raw(page.cast()) }) } /// Returns a raw pointer to the page. pub fn as_ptr(&self) -> *mut bindings::page { - self.page.as_ptr() + Opaque::raw_get(&self.page) } /// Runs a piece of code with this page mapped to an address. @@ -252,9 +251,12 @@ pub unsafe fn copy_from_user_slice_raw( } } -impl Drop for Page { - fn drop(&mut self) { +// SAFETY: `Owned` objects returned by Page::alloc_page() follow the requirements of +// the Ownable abstraction. +unsafe impl Ownable for Page { + unsafe fn release(this: NonNull) { // SAFETY: By the type invariants, we have ownership of the page and can free it. - unsafe { bindings::__free_pages(self.page.as_ptr(), 0) }; + // Since Page is transparent, we can cast the raw pointer directly. + unsafe { bindings::__free_pages(this.cast().as_ptr(), 0) }; } } From patchwork Sun Feb 2 13:05:45 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Asahi Lina X-Patchwork-Id: 13956520 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5601FC02193 for ; Sun, 2 Feb 2025 13:06:53 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 126CB6B0088; Sun, 2 Feb 2025 08:06:47 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 0D93C6B0089; Sun, 2 Feb 2025 08:06:47 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id E45336B008A; Sun, 2 Feb 2025 08:06:46 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id C80FA6B0088 for ; Sun, 2 Feb 2025 08:06:46 -0500 (EST) Received: from smtpin26.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay07.hostedemail.com (Postfix) with ESMTP id 84011161445 for ; Sun, 2 Feb 2025 13:06:46 +0000 (UTC) X-FDA: 83075029212.26.3E7D98F Received: from mail.marcansoft.com (marcansoft.com [212.63.210.85]) by imf05.hostedemail.com (Postfix) with ESMTP id 93FE410000D for ; Sun, 2 Feb 2025 13:06:44 +0000 (UTC) Authentication-Results: imf05.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=Fvp6scyW; spf=pass (imf05.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net; dmarc=pass (policy=quarantine) header.from=asahilina.net ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1738501604; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=vscU1xjFmj4aBYakNmliZy/hBTXSOf5iED3uMi6fmY4=; b=lsAA4jbGhqLHI08vvaZCZogOkfmslsbIQyI9Lmx6HBLFIa07XEwQ7qCkqh4aH4jMl4hYOu o1vICAIfWjDW0QVGW12s0vnlN6S8Y7FJZmbe4Cvo6xDIIQJLuEJbVK8BE6QZ/lmfWdEhLZ 4IkVrYh33Z3Hyy8KeHIbbopkJg2f1p8= ARC-Authentication-Results: i=1; imf05.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=Fvp6scyW; spf=pass (imf05.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net; dmarc=pass (policy=quarantine) header.from=asahilina.net ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1738501604; a=rsa-sha256; cv=none; b=At4cXmno2CTZZuMqnlz2IYnc+jKHfgGvY8S0g2HOWu8C8ZNwerpZ5l0XoaTCLCmhGDe0Ph LaYsL2QB2nDxZwcjfX9BFNW0o/lUcRyzKU2hsgyh05QzSjbUw02OWSthEM8q5aPGHbSfxG qDqxXELagZPI8NGK63Y+rvCyRr4MVyw= Received: from [127.0.0.1] (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: sendonly@marcansoft.com) by mail.marcansoft.com (Postfix) with ESMTPSA id 4777C426EE; Sun, 2 Feb 2025 13:06:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=asahilina.net; s=default; t=1738501603; bh=wOJkjoDFrNnJZtmpG6nyyGH0hn+2uCbf5uZhqGJfbOE=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=Fvp6scyWPHGaA2V+QtyuriDLEbcXsPS3f5VQzFRpnxbamCxSPxBedHEen0IFXWxI3 YpG4MxVaHryxse2Zqd/1ZE5kfg99dK0flO2MBOZwVwfLEIa8aIY9t/BtajndBSbJKP vXpovHQtURT/97O6uaWV91LU/u2gQkiSCOdP+mlZ16N76lYLszA9uFuuB3NSJMcoR3 eBc0Pwz76K/7PDiK61AjtwRc6LVbD6Zfxe7H2fG/uUEMNx401uBjatAwdXSc9FhxlB u35iD2Iy3pgteYWwwyJC5K0Am0M6ZTqwH9j72pgRPDMuWGuEyUswkTqgTPOnu+iml2 PmrctezEUpDEg== From: Asahi Lina Date: Sun, 02 Feb 2025 22:05:45 +0900 Subject: [PATCH 3/6] rust: page: Make with_page_mapped() and with_pointer_into_page() public MIME-Version: 1.0 Message-Id: <20250202-rust-page-v1-3-e3170d7fe55e@asahilina.net> References: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> In-Reply-To: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross Cc: Jann Horn , Matthew Wilcox , Paolo Bonzini , Danilo Krummrich , Wedson Almeida Filho , Valentin Obst , Andrew Morton , linux-mm@kvack.org, airlied@redhat.com, Abdiel Janulgue , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, asahi@lists.linux.dev, Asahi Lina X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1738501594; l=1782; i=lina@asahilina.net; s=20240902; h=from:subject:message-id; bh=wOJkjoDFrNnJZtmpG6nyyGH0hn+2uCbf5uZhqGJfbOE=; b=VjxsvTln6z9TApE7nyNtlOcBYymzTzlwnEi76qRMUo4C7bukspMosskksBKgJRb59MWQFy45P mX7u6UyqsyPA8vfivipTf0JTGImVnVxXhDriizPvUyNcNyrkbI4lmXC X-Developer-Key: i=lina@asahilina.net; a=ed25519; pk=tpv7cWfUnHNw5jwf6h4t0gGgglt3/xcwlfs0+A/uUu8= X-Rspamd-Server: rspam07 X-Rspamd-Queue-Id: 93FE410000D X-Stat-Signature: ap478ce3nmb1osht6kf9josd338dokcg X-Rspam-User: X-HE-Tag: 1738501604-589699 X-HE-Meta: U2FsdGVkX1/5jeuMJSW7YNi4RmLiBIjxuHk2JTR2C8GojCz1I44ECCfuOUC1JTQFJ2NshVyxX4ToBtld7Wis37ftGDBpPAv3Agkx0GlOE+IsRmv5RIOJuQjQMUD5zrbZ+nyi7XXQpBbdZfZh85rW76AX08D1uAHoFxgrU819M9DTTj8pmittMyjQq0OkVRCEyZD3VmQ8JE+fWpOMFU7pvlOn0nZTPV6hzmoasjmafatlr++Vw5EJ/A+aBGA3ImSt1ivmusqbUomJmOXYT8ABDQB1/F/FNHR1NtwdmyHtGtA2t3+B1OJUfiKRyB1wEkV/Yd9XnKYwiNPHB4PRjEvHfCAPS/PTCFX8FOyZPdDVoSEdX+bXxaCNCuusizw+kyE/a7eWcQ2aX8fRe+I8K+HvAMhGhc+km83LhGvYAWkSkiYCWLKHSdslPehkzwCV/A9BlCfpSG3dm9vvtbYGgO7P9vhLLGhbUWOQg3yy5ol3f739UPrS9uWoxZR1AOs+4a2R33G4G8P26BnxjRpT9Z6/T5n9iexdOYGqsknp92rbIPXr1GABOD3auz8y53XMrWcLroa58kZzp8jey9wAc9Y14yNt9uacubk+N9SM9Oq7hgsXNP5GqKszR20wDRlXkDAwXUVw9DNWoz2mU9xPkukxHp4i2F3wdHy5OJXofmSgeKS1LxFp6nVJpQQnz4Dng72CCyGG3vXiaKLFv4PH/SMe3NR8ChorN3Y6rvzMwuPO8xxyQ0laitzfUWAGQTYDx7XPxH6rfeISyu50HBI5xecfql8/NXkcgObjsQG4NB/JE58gHJslpnWl8XMj1qO9mXZRuP1lffcNuUW+z31iwKbNQTFrc8lPUZrO27j82ROXI0JjtZIQ6c+DzhZF0yKboERbf2v3H0Z6mI6PwHAL70FD64l7ftgyayoqgpa3fAClnslPVZBcwmqXMVUovbEFbBq4bjC5MSoWTeWPaYIxB2S 6CFhaS5j RqI/os8i071ijEEoHBzMGKjwPkDDkZ+TS1vJL83ERApT33ZcktJ8O+219vdVI6rP64qyML4FjOqBHx/jkqbVpRHhWXJR/eoiBjTAuDEnRz6ONfQtUQHhlsCDIL7S2qM5s7VLBcy8Hnw4xycyTzGsm5LownBwWW0XpwWHFqOmI+9wRBUW/QfRGsP+xU9YGzoEZZSwOZj6Xdzx0BLv2mKptlEL77lCKbSSoMfQUtGmNhVfoy155OeeFMynMskPOa/NY7T3zlGXUrPf7Ac0L+VBkZOWcfFAR5dgcdzuLR2bqgXPmc9srjifNlPa1kywW68AGmmBVQ0sj3A4vdU/x/NahK8OdaFvpHYDS6FQM8h/F4hZVkKGScU/5YO5DkxdIdDxv34rE+sdBqGhtvJNXeZtSF/gH7lwyBlG7s30YCY8G9uLrRReNnhUlvI50Arx5IuZkdMg86bTSa0HgBwf1aBop9S8Aqw== X-Bogosity: Unsure, tests=bogofilter, spamicity=0.500000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: Lets users do (unsafe) complex page read/write operations without having to repeatedly call into read_raw()/write_raw() (which may be expensive in some cases). The functions themselves are not unsafe, but they do take a closure that receives a raw pointer, so actually making the access requires unsafe code. Signed-off-by: Asahi Lina Reviewed-by: Alice Ryhl Reviewed-by: Fiona Behrens --- rust/kernel/page.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rust/kernel/page.rs b/rust/kernel/page.rs index 0b6cbe02522ab6e6e1810288ad23af4e4aa587d8..fe5f879f9d1a86083fd55c682fad9d52466f79a2 100644 --- a/rust/kernel/page.rs +++ b/rust/kernel/page.rs @@ -101,7 +101,7 @@ pub fn as_ptr(&self) -> *mut bindings::page { /// different addresses. However, even if the addresses are different, the underlying memory is /// still the same for these purposes (e.g., it's still a data race if they both write to the /// same underlying byte at the same time). - fn with_page_mapped(&self, f: impl FnOnce(*mut u8) -> T) -> T { + pub fn with_page_mapped(&self, f: impl FnOnce(*mut u8) -> T) -> T { // SAFETY: `page` is valid due to the type invariants on `Page`. let mapped_addr = unsafe { bindings::kmap_local_page(self.as_ptr()) }; @@ -142,7 +142,7 @@ fn with_page_mapped(&self, f: impl FnOnce(*mut u8) -> T) -> T { /// different addresses. However, even if the addresses are different, the underlying memory is /// still the same for these purposes (e.g., it's still a data race if they both write to the /// same underlying byte at the same time). - fn with_pointer_into_page( + pub fn with_pointer_into_page( &self, off: usize, len: usize, From patchwork Sun Feb 2 13:05:46 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Asahi Lina X-Patchwork-Id: 13956521 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 909E3C02193 for ; Sun, 2 Feb 2025 13:06:56 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id DF9B86B008A; Sun, 2 Feb 2025 08:06:50 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id DD386280002; Sun, 2 Feb 2025 08:06:50 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id C6FBA280001; Sun, 2 Feb 2025 08:06:50 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0013.hostedemail.com [216.40.44.13]) by kanga.kvack.org (Postfix) with ESMTP id A96FA6B008A for ; Sun, 2 Feb 2025 08:06:50 -0500 (EST) Received: from smtpin25.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay05.hostedemail.com (Postfix) with ESMTP id 5DCAF4470F for ; Sun, 2 Feb 2025 13:06:50 +0000 (UTC) X-FDA: 83075029380.25.2A0C6BB Received: from mail.marcansoft.com (marcansoft.com [212.63.210.85]) by imf02.hostedemail.com (Postfix) with ESMTP id 17A6F8001B for ; Sun, 2 Feb 2025 13:06:47 +0000 (UTC) Authentication-Results: imf02.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=T2h4y9OU; dmarc=pass (policy=quarantine) header.from=asahilina.net; spf=pass (imf02.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1738501608; a=rsa-sha256; cv=none; b=giyPjTvIK1mII3sfGUBGNNRK7nvqX85/Si/t8CKXQEy7hnbvOxHE8MOXxaZFsaooEnnCKu XwFOxcZjt1fQsJVwgC4RXuQ89ItW4120Vcm3Gq+kxsIxIDNW6HnnpbdC6/y46h1WdjN9uU kLSeH5YviW/0te3jJuGFXhWlaKaqfOQ= ARC-Authentication-Results: i=1; imf02.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=T2h4y9OU; dmarc=pass (policy=quarantine) header.from=asahilina.net; spf=pass (imf02.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1738501608; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=TzZu7kPlD4VbHsvB6TLjofd8ClooLrsfXC1n8Bidkrk=; b=xCTHgLtgbLsqr2EPN3R2GctEzXXzg4oaTc2luS1sd/iRhQIoZIxXh4btGfF4hOONtHAMUh njKq3WIdM1fWnDzGuPZRtb5mMH8nyXEcGIlWiDlyHMAoU9/768SLhtvUNZIbASHk5GQ+mJ 5aSiDCe72Ta6b+M64sdwepYErsg2PGs= Received: from [127.0.0.1] (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: sendonly@marcansoft.com) by mail.marcansoft.com (Postfix) with ESMTPSA id 8453742769; Sun, 2 Feb 2025 13:06:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=asahilina.net; s=default; t=1738501605; bh=0hDjuQHDG3NyTLjzY3YRf98j+prtIAJUg+wcnreGVnU=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=T2h4y9OUV23hl0E27AGlIKbSuOI9FSr/Qfou1x4vaF+kpMEWyoB7lE2oXSt2ZC4W/ Vcaf5Jwqm3JTOsI85ryMwJoWD1yS1mJqti15Dezaeahhg22IbqOwd+iujr4UKk7aug H0lVZemGdZg71svn3NaFnIvjah5m2azg1qcWNwNdaXJ218VVIrliNcN6rfxeqOp7Tb iZ+YGqU0Kkrc1su5UsafpzWEtc9JWSeHMoheGQTvGzVkSc/LQ9cP/wuQkcoS6bp/2g XCjB9AVWWdiP50DvfftpFU+nBZXXL22EjJ36ptc8mlCu81Dg3K0r/izBMeiNI5rVMi 8ehO67zamuuvQ== From: Asahi Lina Date: Sun, 02 Feb 2025 22:05:46 +0900 Subject: [PATCH 4/6] rust: addr: Add a module to declare core address types MIME-Version: 1.0 Message-Id: <20250202-rust-page-v1-4-e3170d7fe55e@asahilina.net> References: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> In-Reply-To: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross Cc: Jann Horn , Matthew Wilcox , Paolo Bonzini , Danilo Krummrich , Wedson Almeida Filho , Valentin Obst , Andrew Morton , linux-mm@kvack.org, airlied@redhat.com, Abdiel Janulgue , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, asahi@lists.linux.dev, Asahi Lina X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1738501594; l=1443; i=lina@asahilina.net; s=20240902; h=from:subject:message-id; bh=0hDjuQHDG3NyTLjzY3YRf98j+prtIAJUg+wcnreGVnU=; b=StouHNNdGl6LXXun36/Ktt4NhZHoitHEaj40BWBfZvKzmLuZ2Y4LDldrYuJmpt3jJeuKqqIwg B+kPBJA/qaKDiEavoI6E1b0JF0yulanuwYHgzUwBeL6uQl0npRPVkny X-Developer-Key: i=lina@asahilina.net; a=ed25519; pk=tpv7cWfUnHNw5jwf6h4t0gGgglt3/xcwlfs0+A/uUu8= X-Rspam-User: X-Rspamd-Server: rspam01 X-Rspamd-Queue-Id: 17A6F8001B X-Stat-Signature: 7m91xieafq45qr1yaz4iu5sqwimsq61y X-HE-Tag: 1738501607-146530 X-HE-Meta: U2FsdGVkX1913UQY5iv9gUboRPW39cXWmm3/s6VOq2Dn8TlAJHgdWFNvgA1kyMFFYYDWMaoP8rnbe25mxwMLmff/tHTmwhGQOyKxjebw2AmMDfuU10z6Ynqp6+1szQNkp4ipVjHwuk4r4jyzViiSGS5CfWzVDG3a0IOB8P2lN1undGIF3u2dbqvwqeEw/7CkR75GajbaPIjYHwRO+m6lVwjnriniVZt1PrBByNm12VebTuVVmCPEw51zOd8i6uIEbSsuvR2cwoNGmQ06aEUbqZy6eGrakrkRsEPwX430EqqwapSXBRM4er7EpOg8WqoVoto2/P/1wtRv/raSDrppA5eNXeWueS2ROBmgCqqbdVkJ2P5gsQau7iXWTtjvqAUd+dK+vOSDkJEssaENMqCafzr3kCySdbv3rKRog7zxej8S0loKXE4gub5x0NwuepksPdlmSzgaeNYIG9dnHx5aOQcxWg9WXoEAvNclkyWhia5WppUqicU0LayIxHa9IPoqsI+KlS4d10KG9DpoCD70t8lzVjK3baL7ZBo9belmI5N//CCy5qHGW+SCJhhk9sAU/OELtx9FQkD/316ZnqrypY8WbirboiVJyjm72dRJukqEnwzuhBKStI2cAWJdvjIxJfEUwL4e7MoAXLUupOUFrx/wpJ2HPc1bPmcy3P6KkkCOsDGLYVfPi9iP1sfMWo9BzUdaNSjSd9Uqr6b0+D0ouPk0gkK7bzsO47425AGM9B+1G1Id0SjiPGCzR2c1R4+XcGxhWumPhpAzHRd/0sLkGle111JqfOBZGbdZxP4Bah3AV2akyyEWEApM2Vk4rNZyJb/RgVK3CZyi8Uiawxl2gS+uZg/muwxzmv89tQ1ipq1Q9lcCEP73RqPDwCxuc3wkaYHvnMWoNoivnFOq602fdD1WtHkHtXG8dKJSHOwcFK/bvZXRQ+WcpDAKRyHEuH48YX/Md5czEVE6eFSMVH+ 14pICV5c ukNEL0mOgjkhvaJMFgL2pHHZ1M7f7GHX1yJaPSg8LpRpNZEXRdMTDhGSYda1MPIsf3KU8yVIveDwD5dVRJK3dMUwFFs0CSTFmL3/HVxpD5Gfeps1usl0h7yzPRJWlGcTj6wRTq5dHOpY7fV9+KhJGu62MgekidvT9y7dHD0o4WweXYeENP2zH4NXGyadStLN+eOGrGrh4iA6wwlFOlTamGtAqlvCcfwlx6lI6j4tCsX4a1vVT1GNQ6rBskuT8xy4lDoMsBdK+sEKc4pcVXll9AJ9wNjLuugEIgixpCdlGhz4NhmXv/x4bxPQVwmjSnWRkOS0nSTMW70/MUxhIh1vhbg0Bkl7XcO1F3Ox/SqWTl/VdTJKnuiumMroDjACEOFRmZvMnqn5EEtwgFO5uMrWe338afjQIx4z4e5BX2PtJHpjB+po= X-Bogosity: Unsure, tests=bogofilter, spamicity=0.500000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: Encapsulates the core physical/DMA address types, so they can be used by Rust abstractions. Signed-off-by: Asahi Lina Reviewed-by: Alice Ryhl --- rust/kernel/addr.rs | 15 +++++++++++++++ rust/kernel/lib.rs | 1 + 2 files changed, 16 insertions(+) diff --git a/rust/kernel/addr.rs b/rust/kernel/addr.rs new file mode 100644 index 0000000000000000000000000000000000000000..06aff10a0332355597060c5518d7fd6e114cf630 --- /dev/null +++ b/rust/kernel/addr.rs @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Kernel core address types. + +use bindings; +use core::ffi; + +/// A physical memory address (which may be wider than the CPU pointer size) +pub type PhysicalAddr = bindings::phys_addr_t; +/// A DMA memory address (which may be narrower than `PhysicalAddr` on some systems) +pub type DmaAddr = bindings::dma_addr_t; +/// A physical resource size, typically the same width as `PhysicalAddr` +pub type ResourceSize = bindings::resource_size_t; +/// A raw page frame number, not to be confused with the C `pfn_t` which also encodes flags. +pub type Pfn = ffi::c_ulong; diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index e1065a7551a39e68d6379031d80d4be336e652a3..eb1a80ba8ff83ab2d1b3b1d11fed4fb704c7a4f5 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -29,6 +29,7 @@ pub use ffi; +pub mod addr; pub mod alloc; #[cfg(CONFIG_BLOCK)] pub mod block; From patchwork Sun Feb 2 13:05:47 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Asahi Lina X-Patchwork-Id: 13956522 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0418CC02193 for ; Sun, 2 Feb 2025 13:06:59 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id DD30B280001; Sun, 2 Feb 2025 08:06:51 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id D81B36B0093; Sun, 2 Feb 2025 08:06:51 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id BFAD0280001; Sun, 2 Feb 2025 08:06:51 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0017.hostedemail.com [216.40.44.17]) by kanga.kvack.org (Postfix) with ESMTP id 9E9076B0092 for ; Sun, 2 Feb 2025 08:06:51 -0500 (EST) Received: from smtpin14.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay06.hostedemail.com (Postfix) with ESMTP id 56F30AE7C5 for ; Sun, 2 Feb 2025 13:06:51 +0000 (UTC) X-FDA: 83075029422.14.955BE7B Received: from mail.marcansoft.com (marcansoft.com [212.63.210.85]) by imf09.hostedemail.com (Postfix) with ESMTP id 267CA140009 for ; Sun, 2 Feb 2025 13:06:48 +0000 (UTC) Authentication-Results: imf09.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=Q1d6zRTZ; spf=pass (imf09.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net; dmarc=pass (policy=quarantine) header.from=asahilina.net ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1738501609; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=vyzCt0IDTC6cprzdZ6t4DBu1aNbP5XTeaYh7YF6GG9E=; b=SqWTwdquSP6sR1IGtGE2vVe2aJg2GGOScxw2VFb6asz9AaxXy3GditMmO5oEfwqVaVKFt3 CYVDz9j5o08zHGUGKKQ1zyW6UraDjwZACd/Hma7/sq3LpCuOT5228rywvhhQIi2zX2iyan n/INapvKaqzgYbBNi5ryFdHgbcdMG9k= ARC-Authentication-Results: i=1; imf09.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=Q1d6zRTZ; spf=pass (imf09.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net; dmarc=pass (policy=quarantine) header.from=asahilina.net ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1738501609; a=rsa-sha256; cv=none; b=h2ja0qfJY9ow7YK+euYDHvtarEL9zh5XhKaAnPkX+TQh6+tsNaiMYR699XkUsegt8PKXPS QfLEIXFPknPOjQ5n8STPJeNdhwX3cJM9M6WZw6f/DXakBHs8XE8YM8Ow14xhkKW5ccBpzn LA3Gw97nsr0IHj+8ADb3gVSQ5oB+FJk= Received: from [127.0.0.1] (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: sendonly@marcansoft.com) by mail.marcansoft.com (Postfix) with ESMTPSA id C0B3242CC4; Sun, 2 Feb 2025 13:06:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=asahilina.net; s=default; t=1738501607; bh=/l/yqYUI25JHcLzcwMcBrWhtbhlMTOGAR488Z8bons4=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=Q1d6zRTZJ4O6vYmZeKYI/dMmURcPQcUkgzn7B0XvDog6QeDRPMPNjRMBp5Oh+dDWs fBKDBU6JMWUawsCrpr+SCfTXQnkcnfb5I3cwQbqLHu2mf+BRrHDcBcJiTDnDY9siL6 m6p+zuQZoIez31D62jvfEf0R9fnoa3LDPuhdrc18zVYA6dsnHDASD8vVK2finjxFXD 9+GkECLq4Vigayi1UGdSEgoy4ynEWax1Q/RkcUFIlmWVZMgVh23du/1cBc8QyRdqhD TMuB9MR8N2FLceLZtF6GbPWpGwVq+BarP2VPQSigR+sdaG+H5fFDHQ3bGFfzxgNb4L +8SDCfsLI9j6Q== From: Asahi Lina Date: Sun, 02 Feb 2025 22:05:47 +0900 Subject: [PATCH 5/6] rust: page: Add physical address conversion functions MIME-Version: 1.0 Message-Id: <20250202-rust-page-v1-5-e3170d7fe55e@asahilina.net> References: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> In-Reply-To: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross Cc: Jann Horn , Matthew Wilcox , Paolo Bonzini , Danilo Krummrich , Wedson Almeida Filho , Valentin Obst , Andrew Morton , linux-mm@kvack.org, airlied@redhat.com, Abdiel Janulgue , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, asahi@lists.linux.dev, Asahi Lina X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1738501594; l=5914; i=lina@asahilina.net; s=20240902; h=from:subject:message-id; bh=/l/yqYUI25JHcLzcwMcBrWhtbhlMTOGAR488Z8bons4=; b=smOvr2ghPdeB8WGsuSZMnK+RdiZl/ggO1sjUJa9nF7n897PX4BZqpGtxrsCgRD0xgyLMFsN4C lONdvO0e8EiCCt7Wqof9tOCVkpiKbnePQ+jExk4ZKxJ5pM1CvRROa5X X-Developer-Key: i=lina@asahilina.net; a=ed25519; pk=tpv7cWfUnHNw5jwf6h4t0gGgglt3/xcwlfs0+A/uUu8= X-Rspamd-Server: rspam05 X-Rspamd-Queue-Id: 267CA140009 X-Stat-Signature: wnsypufheeust9877eapphfyeprqixga X-Rspam-User: X-HE-Tag: 1738501608-387165 X-HE-Meta: U2FsdGVkX196shhY3uNv1z3YGvmxySq66g/PMYFNUqCKYnr6mUENoB0vFIjJ6ap0ZeNnDg+hmSiCSYZ/GF7qDpXBzwa1XA+jEYH45p1tOaK295GJ2V8h8nWmIG2IcexTZ5ulocsd4y8c4q6PrRh2rlSXIocIcwBCYZZFStqnm/tFV4DJNvnWY9YmzzNL5NVprb/64m7B7FonjqEHMYtS3qmmoTLBmr4V901RSKlUOZaABu7CkxMUG3VJKlo/MhH7XlA9NfRe+d43FdjVj/3pWxeS1hUzha6ASLYwkViPSs5GsHfwGYvzLth+WaMi2MXFmyhw5XuCjf7jI0MWnk9f8E7vqnFheUSRIxenGkVbjA47xFf/0JDrRuhffNoZnVuL/43JuE6VN7jx/jnQT4m1SNyXfFHbbD902ur6xEvxABPlJHhPHbmJaiy5Qupep5iP1iP51Ql3pe+E7Y+fH5yMLzULIvob2zeMHkJtQCpOLNUQVtDeJR8nCO+HAY9RN1ZMcKLKkDoD1xBXhg5nQ3hwFxvsT/S1a0sW3ojFdB1+kD1WUpE0QY5SVNgF+TP+43fixOSgVQ4e8bpg1cR5dJ6VNgXPYtFI3JTdI4fUL2bxEFmqpnYS+cUbLwMmh9AnCjOjEWsLKod5yHVzqWSasKLg2H0YFR7uIozelI7UkXwDC013eiQrJkBx5SVsElwoNiO4TIXwU5SyyDjsk58W5dDJ/vNZnQgfV7vQQRyKN+gzyGtYQEaCB38liJGkvffj1rbSzVcZJTVQMAhm0Gtl4z51iuEdzoaOcoidUDNQu+R57P2gFilZwzD+E7y0v1LN1yk2yYJYBGa4OWKs9vS+wfhXhOdPOvo1/cZoKRYRclksz++s9GCs6wIl7htS4YcHSSPL5TRcG14XNSA3/XqSNq3dZeLAZVck/xQflFcvv5d8ehQfN4VivdjH9CNpDltwO0qHkNIR8ISyBRIwcPq8OyE hfAPp6iQ b5qFc9in8Tt6VCmVRUU5OKQr9hz9ABVsqw3gIFTJbBV/M2Z6eSNB6bqw0TxVKDX+SfjXpMt6uwH6C9jUWvH/DJPtHbmzp4H+cI9ytV/LzVUyhJpAnWk/g/AV9AZD06a4ZdamMwvB2I6Ax98ZcAElypCxNhZ7XUrJjvlJPA3WI5pKnTX4vh/+62DSF9CM78Kxiog5cSU9k7zPmVRpkDQTa/ANKRSawJaG+iaOhoNr/nxUpDBPQ9XcZgCvrn5EWTvE599Dbua/htwHM6rvCLwwYZgSEz2iE/6+tUkdKeqIUY5Y1+rGgyqg//KbLgqJRL8yEQ0LXvp9zFpRl8hrZvYWjcRBHxvYYARJBHu5ovNo2CiE2FtD+W561Z8aw4azkJ5OeS51+nh2NqojU2gZwKrhMKpgllX3ExUdnfw3zm9jXkzK9LE8= X-Bogosity: Unsure, tests=bogofilter, spamicity=0.499369, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: Add methods to allow code using the Page type to obtain the physical address of a page, convert to and from an (owned) physical address, and borrow a Page from a physical address. Most of these operations are, as you might expect, unsafe. These primitives are useful to implement page table structures in Rust, and to implement arbitrary physical memory access (as needed to walk arbitrary page tables and dereference through them). These mechanisms are, of course, fraught with danger, and are only expected to be used for core memory management code (in e.g. drivers with their own device page table implementations) and for debug features such as crash dumps of device memory. Signed-off-by: Asahi Lina --- rust/helpers/page.c | 26 +++++++++++++++++++++ rust/kernel/page.rs | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 91 insertions(+) diff --git a/rust/helpers/page.c b/rust/helpers/page.c index b3f2b8fbf87fc9aa89cb1636736c52be16411301..1c3bd68818d77f7ce7806329b8f040a7d4205bb3 100644 --- a/rust/helpers/page.c +++ b/rust/helpers/page.c @@ -1,5 +1,6 @@ // SPDX-License-Identifier: GPL-2.0 +#include #include #include @@ -17,3 +18,28 @@ void rust_helper_kunmap_local(const void *addr) { kunmap_local(addr); } + +struct page *rust_helper_phys_to_page(phys_addr_t phys) +{ + return phys_to_page(phys); +} + +phys_addr_t rust_helper_page_to_phys(struct page *page) +{ + return page_to_phys(page); +} + +unsigned long rust_helper_phys_to_pfn(phys_addr_t phys) +{ + return __phys_to_pfn(phys); +} + +struct page *rust_helper_pfn_to_page(unsigned long pfn) +{ + return pfn_to_page(pfn); +} + +bool rust_helper_pfn_valid(unsigned long pfn) +{ + return pfn_valid(pfn); +} diff --git a/rust/kernel/page.rs b/rust/kernel/page.rs index fe5f879f9d1a86083fd55c682fad9d52466f79a2..67cd7006fa63ab5aed4c4de2be639ed8e1fbc2ba 100644 --- a/rust/kernel/page.rs +++ b/rust/kernel/page.rs @@ -3,6 +3,7 @@ //! Kernel page allocation and management. use crate::{ + addr::*, alloc::{AllocError, Flags}, bindings, error::code::*, @@ -10,6 +11,7 @@ types::{Opaque, Ownable, Owned}, uaccess::UserSliceReader, }; +use core::mem::ManuallyDrop; use core::ptr::{self, NonNull}; /// A bitwise shift for the page size. @@ -249,6 +251,69 @@ pub unsafe fn copy_from_user_slice_raw( reader.read_raw(unsafe { core::slice::from_raw_parts_mut(dst.cast(), len) }) }) } + + /// Returns the physical address of this page. + pub fn phys(&self) -> PhysicalAddr { + // SAFETY: `page` is valid due to the type invariants on `Page`. + unsafe { bindings::page_to_phys(self.as_ptr()) } + } + + /// Converts a Rust-owned Page into its physical address. + /// + /// The caller is responsible for calling [`Page::from_phys()`] to avoid leaking memory. + pub fn into_phys(this: Owned) -> PhysicalAddr { + ManuallyDrop::new(this).phys() + } + + /// Converts a physical address to a Rust-owned Page. + /// + /// # Safety + /// The caller must ensure that the physical address was previously returned by a call to + /// [`Page::into_phys()`], and that the physical address is no longer used after this call, + /// nor is [`Page::from_phys()`] called again on it. + pub unsafe fn from_phys(phys: PhysicalAddr) -> Owned { + // SAFETY: By the safety requirements, the physical address must be valid and + // have come from `into_phys()`, so phys_to_page() cannot fail and + // must return the original struct page pointer. + unsafe { Owned::from_raw(NonNull::new_unchecked(bindings::phys_to_page(phys)).cast()) } + } + + /// Borrows a Page from a physical address, without taking over ownership. + /// + /// If the physical address does not have a `struct page` entry or is not + /// part of a System RAM region, returns None. + /// + /// # Safety + /// The caller must ensure that the physical address, if it is backed by a `struct page`, + /// remains available for the duration of the borrowed lifetime. + pub unsafe fn borrow_phys(phys: &PhysicalAddr) -> Option<&Self> { + // SAFETY: This is always safe, as it is just arithmetic + let pfn = unsafe { bindings::phys_to_pfn(*phys) }; + // SAFETY: This function is safe to call with any pfn + if !unsafe { bindings::pfn_valid(pfn) && bindings::page_is_ram(pfn) != 0 } { + None + } else { + // SAFETY: We have just checked that the pfn is valid above, so it must + // have a corresponding struct page. By the safety requirements, we can + // return a borrowed reference to it. + Some(unsafe { &*(bindings::pfn_to_page(pfn) as *mut Self as *const Self) }) + } + } + + /// Borrows a Page from a physical address, without taking over ownership + /// nor checking for validity. + /// + /// # Safety + /// The caller must ensure that the physical address is backed by a `struct page` and + /// corresponds to System RAM. This is true when the address was returned by + /// [`Page::into_phys()`]. + pub unsafe fn borrow_phys_unchecked(phys: &PhysicalAddr) -> &Self { + // SAFETY: This is always safe, as it is just arithmetic + let pfn = unsafe { bindings::phys_to_pfn(*phys) }; + // SAFETY: The caller guarantees that the pfn is valid. By the safety + // requirements, we can return a borrowed reference to it. + unsafe { &*(bindings::pfn_to_page(pfn) as *mut Self as *const Self) } + } } // SAFETY: `Owned` objects returned by Page::alloc_page() follow the requirements of From patchwork Sun Feb 2 13:05:48 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Asahi Lina X-Patchwork-Id: 13956523 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0D6DEC0218F for ; Sun, 2 Feb 2025 13:11:55 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 8CA17280003; Sun, 2 Feb 2025 08:11:54 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 87B44280002; Sun, 2 Feb 2025 08:11:54 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 76A5B280003; Sun, 2 Feb 2025 08:11:54 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0013.hostedemail.com [216.40.44.13]) by kanga.kvack.org (Postfix) with ESMTP id 5708C280002 for ; Sun, 2 Feb 2025 08:11:54 -0500 (EST) Received: from smtpin14.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id EFAC614208F for ; Sun, 2 Feb 2025 13:11:53 +0000 (UTC) X-FDA: 83075042106.14.8D4A453 Received: from mail.marcansoft.com (marcansoft.com [212.63.210.85]) by imf11.hostedemail.com (Postfix) with ESMTP id 0684F40004 for ; Sun, 2 Feb 2025 13:11:51 +0000 (UTC) Authentication-Results: imf11.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=W68hCmAT; dmarc=pass (policy=quarantine) header.from=asahilina.net; spf=pass (imf11.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1738501912; a=rsa-sha256; cv=none; b=UoaxUBTk7wNE0dmP68m/PW3WY7fN2c8iydYbF7ITV3pPzwIswnFEI5en76pdcwtXv2fGqT zudEBBTkeeoTNH0MRk6dDuC0EwITxRDuXTL5cx8w8w4DBqNozpmZ6G79a4hBGDuyexit8K OWKXAJOEzEzsUOzFKPC6bnNh/ducC+k= ARC-Authentication-Results: i=1; imf11.hostedemail.com; dkim=pass header.d=asahilina.net header.s=default header.b=W68hCmAT; dmarc=pass (policy=quarantine) header.from=asahilina.net; spf=pass (imf11.hostedemail.com: domain of lina@asahilina.net designates 212.63.210.85 as permitted sender) smtp.mailfrom=lina@asahilina.net ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1738501912; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=/01sb/E6WwcQBnxJNx4gho0AAYivKOblbFmtJqE21sA=; b=pLfyuZGuAMXlg3HaeIS4gvov2mhj9zxNcpJkL66tTiOfQVwKSN3FWG0U7pYCIE38vV5CiK STLz9S570q/GKOnHXrvWiCrEICQU3+xJFB+5N+NqcBL8ZOHH1rPVOvhXLSEEXlTZqOG6yz dk0pzKsKUJfyd+bCUvCSaAiwgviZTtA= Received: from [127.0.0.1] (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: sendonly@marcansoft.com) by mail.marcansoft.com (Postfix) with ESMTPSA id 0E6D142CF1; Sun, 2 Feb 2025 13:06:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=asahilina.net; s=default; t=1738501610; bh=jAxlx0oKPYhbCLOndVQegKI/zkoqLO2seAFvco9COAE=; h=From:Date:Subject:References:In-Reply-To:To:Cc; b=W68hCmATDKo9EiH/xMtAcdph4x+tpmPmNtxtu+tx82fwJBpSxeMQbd/aWh5QzcOKr G0ENO9GNbN8fsm1e0DDj/5x8+TN5kGJOiYdCd69beGzF/I1BDJ6P7Jq86/lwzga3cP Dujgi22bP8LU8ZB+fDML04o3s7g4Y+AHNSFxOosjo/msGdpUFqAtZypGs7yghtqruD TALKh0aV8LdMcXODde+LkiY6rV637Jn9uvFqd2LhpV135qKBe1dUi5H0eFWmpa+yIK JI2eDyF5njHMDptbSKSnURDe34XUmvYbXU/u0qe+0ttIPTE3LlL6M0rgArHX61eeX4 sf2dw0y2kuKzw== From: Asahi Lina Date: Sun, 02 Feb 2025 22:05:48 +0900 Subject: [PATCH 6/6] rust: page: Make Page::as_ptr() pub(crate) MIME-Version: 1.0 Message-Id: <20250202-rust-page-v1-6-e3170d7fe55e@asahilina.net> References: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> In-Reply-To: <20250202-rust-page-v1-0-e3170d7fe55e@asahilina.net> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross Cc: Jann Horn , Matthew Wilcox , Paolo Bonzini , Danilo Krummrich , Wedson Almeida Filho , Valentin Obst , Andrew Morton , linux-mm@kvack.org, airlied@redhat.com, Abdiel Janulgue , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, asahi@lists.linux.dev, Asahi Lina X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1738501594; l=869; i=lina@asahilina.net; s=20240902; h=from:subject:message-id; bh=jAxlx0oKPYhbCLOndVQegKI/zkoqLO2seAFvco9COAE=; b=Yx1gVXvO3w0R4qdGomFIq+0RwKj460R5wvIbngoMuX6wHDoesKQMqRxKU0o3unMwKL69zlqrR En16s28Jr/vB388LQY8FUK1/cVO+HCe4enKe0BKjctozf6HJnt9HVbf X-Developer-Key: i=lina@asahilina.net; a=ed25519; pk=tpv7cWfUnHNw5jwf6h4t0gGgglt3/xcwlfs0+A/uUu8= X-Rspamd-Server: rspam04 X-Rspamd-Queue-Id: 0684F40004 X-Stat-Signature: xrtu8qfc69qb4aokqqm1pghn4pme6irt X-Rspam-User: X-HE-Tag: 1738501911-202568 X-HE-Meta: U2FsdGVkX19LE87NKdoT7+h1wq6OUmRl3kgfw0gP3ATXk+Ion3UTZf7IAQEIiAoFas8OXqb8S7j01ze1Xff2hA+8BfgoOLF4XC+LukxfRTmSrcfb1r8QA3RIqrYsVEIhnuTz4nKGry/4XQF0Z5/rarmAUe5dB/kh7xO2BU8pm2tArGI/77AsY42Z5F+2g5ni+tVkwEd+DJkHXRAlqIPvKFAfcCcsF4M6hDChB6xLLZTWvm1rV1rFedJnTDNl65Dx+4tzhfbrP6uAUktrU3jNOeKIkZGuA1sjUQX/lfwsf1pl9lsqOIIIudCtu0AcLcq97Kg029L1Xz6dxB2zGESKZvXpsC/CaG48Uks1uw9pw60WgZiJOk4+RE642K4JBhgvlfqlWmQKl8JmGUvseq7kNu/AAZ8qvl2SWboYLsY9Tej3BmGibtI9cgQODAieN4q9sD5xrwGNkBL+8hxjR/gh3zezePRaZGO0bC8uzij+6ob/gzGV7PzUtLkjKALySSrM9PDPnne7vSot9DHQuYp1ureff6LBOHBlkKeRbVPbSYvlPWyLU4QPSAIa0fGGGR6cXZkijbSd9vzPA2uw3FHfSrBjGDOq2ZkgiJvCr2tX7qaGJx0daBcZkO2xYJXy14WXsa7EXsVWd/irQfA5297fA3zC1meJuwQgcRFtr1ci20cSGvkXlNzuQuZ3lzyR2SZMcgjyyJ2a7Q9+L2O0I01I9IF7vwBoL/tIWx4l7y1ajs4qha4uJStou3hmkr90P++tPxP8DvumULv+JsslkB8DMW0W5NzQEDUxw/RPhVaBqbC2jwIxzF6Ndd3OpTSz+KaUCnG1TF2uZfn0Rydu24z6bs2RSIB12VvEO+JKnk0WfxvVN+/qRdkv7744WRf60eilLh6yoXsV6RzrSL/MxLHgVWFdBGLzWL7mre1Ugc3mzkzP9YliSz+DBgBEm5sEJaQv8ijTormaLlvdxXDx555 /E6bN6kj 0Ne0Gcgp5mUvGj0aFh+W9Ql4/F6b38eDXwqYYJEMwNwBbiEbLYUoxOY0xpQhggSW7Dih0ZN77J4AQNzwflDKjPz+uwT25quE3dqUUmupT5vb11MudxvfjYXy/spwu2HJVdQtwJ77fH4dDN2JgyMjHpCwtUD2it8oor7zpxjrVULY5daZDpwv8y2JvmuoKyBySqTHM1hmeCq3EgpMZz/K8CzMGCku8Cum0TkF3LBJlfQCmtlR1JJR9sTo0nc7WE6xelMkFZVaPmw6A7rspCYcmJRVfj1oBkJKBirWdJGKcMwhotTM3yd59M8gn2TE8iRGTpU1LKQLtR5Nl08pIGDI2Nd8ioJl/vP0xA8ZkHxDZBdSUIn2tTlmX44GcjdZYQHYT/C11qdQ0Y6rYC4m871z2oCcJJB6yCecDjngprvXQf4JVV34KDOx8PetPMoReb8vjdUEFpfGcYbFrLhJrc7jjFZ/vg1U8ePDi6cDEKAyGj9eXNw78xmC72uVe+Q== X-Bogosity: Unsure, tests=bogofilter, spamicity=0.500000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: There's no good reason for drivers to need access to the raw `struct page` pointer, since that should be handled by Rust abstractions. Make this method pub(crate) so it is only visible to the kernel crate. Signed-off-by: Asahi Lina --- rust/kernel/page.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rust/kernel/page.rs b/rust/kernel/page.rs index 67cd7006fa63ab5aed4c4de2be639ed8e1fbc2ba..b7bce033b53682eca6e61f47e4fd3aa902da7900 100644 --- a/rust/kernel/page.rs +++ b/rust/kernel/page.rs @@ -83,7 +83,7 @@ pub fn alloc_page(flags: Flags) -> Result, AllocError> { } /// Returns a raw pointer to the page. - pub fn as_ptr(&self) -> *mut bindings::page { + pub(crate) fn as_ptr(&self) -> *mut bindings::page { Opaque::raw_get(&self.page) }