From patchwork Sat Mar 15 12:17:25 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tamir Duberstein X-Patchwork-Id: 14017994 Received: from mail-qk1-f178.google.com (mail-qk1-f178.google.com [209.85.222.178]) (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 3A64D1FAC25; Sat, 15 Mar 2025 12:17:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.222.178 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041056; cv=none; b=aIOtxA6N5Awwz/JoSmPiw5+J6PXcOwLli0slB4yB23lhcYC5RQc8P93ZHSaBRcJUZ+9vRjtHQYflD3saq34Sd1fAbNDPji+TJr5VRIE/Vl8IUcuNrsVyduqQiS8UVe47SBZxz5zbB+65xU3Sha1xO3HkymZiBjlODcmWf2mmPro= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041056; c=relaxed/simple; bh=dDQupNav3SXw5VhrEjMVEy17ST8KxvEPfS1MsDl/Bvg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=ExXOhsqDWINEX2Twyu9RA1r4A7lk9X6yJ+z1W0geCe9wiKHxatXrMq8g/FzSYaywBUt/RpwuCqB0yI3UobU5VdI87QUgA3LgNXYTZgPZ+MXOtknJpMfLNbvl8yW6bInEoaTkTh9NibqgResbktvnlferVkukbEueE/iuMG/n8ww= 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=lDCjajY+; arc=none smtp.client-ip=209.85.222.178 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="lDCjajY+" Received: by mail-qk1-f178.google.com with SMTP id af79cd13be357-7c54a9d3fcaso306209985a.2; Sat, 15 Mar 2025 05:17:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742041053; x=1742645853; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=wRSqdfwSx/UEQwa1Uc/BINHa6oMwpSmypgRT8Rx991M=; b=lDCjajY+OFRthBtomcZxvVTr/wmj8YidFraczG6vnRdH7bkVecDVZlKiBeDALNjGgW 8f/4XfryBrvqSb5qbJ1OsROBY0Ku+Lrm60AOdgJ6Wf9BIE9J2Yxl/r4Sjn9ek7NRQSke PudXg1t5KVosrwVZwHWkbw2SGM1k/tZiuO82JdkxJMkBxPCt6kz8zBUcisjSNKdVui4v ayFOJcYAm406mk6JWVctbsNormFNVNbq6ghsRSsYe7G2XMTKH6E78KJIkDQqxlgefmyt oN9w+sKcjWo3+xGvXzI8OdiDhtv7Hd1twC6TEZhn0zIdCFZdVTOyVFkJvuhhvQVZOFqC RmbQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742041053; x=1742645853; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=wRSqdfwSx/UEQwa1Uc/BINHa6oMwpSmypgRT8Rx991M=; b=Qqu9T3OrnoTAK3Nta0LlwjKwfuyHDeWWH4U8q/xNENKnoVFIU7WSGcJmVYWUWoZQzx QT23TfA+GSrxqNhQPlistxeiu8f0XIU9+I6HNbC3UzHuwnGz79mUrZDoT9bwmCsMWcrY PjCbQ8v1ujOLwnh0j0X8960CtPo2SZ3WKDAB17ZCNAEKwKdRpeMCI2Gz6Wliuo3yWYi6 5GwExpgBtGk4oFLSMqXv2hdmBNcXXY69f2GkSs/3tIVBdrA/ST8to1ekVD5M23YjJuQ9 zrxUKnkCdug8ExxJ1GkpB0vi/UKuduLB9xOiY2u8QBhbveMTyHdP98ZMiki06hX5CtmF QYSQ== X-Forwarded-Encrypted: i=1; AJvYcCUGrmKD1pFna82ZwvZrOHtyXAA0wNNBLgk5hwcSiK58uPXXUU7ADjR/UJuwhSh6n2+onz6GQyNGrcC6@vger.kernel.org, AJvYcCUk9AwhPe529m0kGiQfZRh7iu5qPXJB1P7lcq7GphnPb1YmT3AA6pN6ymWJt0lREXhCo5GsARiMjN37N3h0qUcj@vger.kernel.org, AJvYcCVo3bPSoZZivzpfOQSiClSIpOqOODGaSNHsepbZZZvoSR6ukTWYjeYyIAvWuibJw/2V2DDPFnvukdfCRmYa@vger.kernel.org, AJvYcCVzUd2hvk1P5L5vuEstnPtbrTHlQm+gIicCQEGDraXCkOlrixy8ameEV3GiHyFBOAwyXyz5CaBIBgE0SpI=@vger.kernel.org, AJvYcCWKKKM/EVFQQJd7bJM+N1SdnKM/HQ0G5mdRVjF0LYk+jxg+3qL/xv46lr0HpmtQC4NhiIVgLsXuFHYu@vger.kernel.org, AJvYcCXsqTEvfmCAyoFQfiXxV27OnHrLYqhGXZWbRRQ0uKJvRQLGi0SX+/1zOjq4T6/b3Urs9EevuSPGTYeYHCeHEAo=@vger.kernel.org X-Gm-Message-State: AOJu0YxSBxYNK/6pl8/nRQoLBwBWTHNRcEZ4sR6muygfJKe9xEZREjsI Z+tK4M1e0M1FT3kZmqeMDJfA2Znr0fQYJ14xmySnyHcO7h5XY75z X-Gm-Gg: ASbGncvFOIPFP/5bCH74fU24JsaJ7pDPOu+FmySgBzpzeXrJ8PInFm2Jru9dymsvu4F QpkpvsjSJC4fPSdmtf4iekWC61i8L5tcSy8yFt+MDAxBYCWCFZSla+jtR03RPHC3lY2n71gDBs6 n3L0yBO0xlaUqfvbWuZRomDdNxAqHo5+B7+D5f1GFqcBztqS29aWP2nDP7oynKq++LF4zEja8ih A0Qq5uyjhpCkDiFvB+YgrUWA5Nz5ZNbLOBtaQ8p/ymJ5O10BsgA4dhwhPoYhtfAjDS1KtLcRU9i zZIoWLylqagbwCowDjS1z5HONHYiwScPWrrYcH4Ca7rBvCzWbuFz25Dnbz0q+51l6wbO X-Google-Smtp-Source: AGHT+IG1vnCieJ3RWkOOw8/wbjPXdpDTmdmbwTkVwCHDxheeJxvF/ub82RKoP5sQ2V2Uv4kVSZ+SGg== X-Received: by 2002:a05:620a:1a22:b0:7c5:5229:2f1f with SMTP id af79cd13be357-7c57c79b7edmr740854585a.5.1742041052894; Sat, 15 Mar 2025 05:17:32 -0700 (PDT) Received: from tamird-mac.local ([2600:4041:5be7:7c00:cd19:6a0f:e1a6:e800]) by smtp.gmail.com with ESMTPSA id af79cd13be357-7c573c9be48sm371885185a.60.2025.03.15.05.17.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 15 Mar 2025 05:17:31 -0700 (PDT) From: Tamir Duberstein Date: Sat, 15 Mar 2025 08:17:25 -0400 Subject: [PATCH v4 1/6] rust: retain pointer mut-ness in `container_of!` Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20250315-ptr-as-ptr-v4-1-b2d72c14dc26@gmail.com> References: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> In-Reply-To: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> To: Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Brendan Higgins , David Gow , Rae Moar , Bjorn Helgaas , Luis Chamberlain , Russ Weight , Rob Herring , Saravana Kannan Cc: linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com, linux-pci@vger.kernel.org, linux-block@vger.kernel.org, devicetree@vger.kernel.org, Tamir Duberstein X-Mailer: b4 0.15-dev Avoid casting the input pointer to `*const _`, allowing the output pointer to be `*mut` if the input is `*mut`. This allows a number of `*const` to `*mut` conversions to be removed at the cost of slightly worse ergonomics when the macro is used with a reference rather than a pointer; the only example of this was in the macro's own doctest. Reviewed-by: Benno Lossin Signed-off-by: Tamir Duberstein --- rust/kernel/lib.rs | 5 ++--- rust/kernel/pci.rs | 2 +- rust/kernel/platform.rs | 2 +- rust/kernel/rbtree.rs | 23 ++++++++++------------- 4 files changed, 14 insertions(+), 18 deletions(-) diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index 398242f92a96..486715528587 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -187,7 +187,7 @@ fn panic(info: &core::panic::PanicInfo<'_>) -> ! { /// } /// /// let test = Test { a: 10, b: 20 }; -/// let b_ptr = &test.b; +/// let b_ptr: *const _ = &test.b; /// // SAFETY: The pointer points at the `b` field of a `Test`, so the resulting pointer will be /// // in-bounds of the same allocation as `b_ptr`. /// let test_alias = unsafe { container_of!(b_ptr, Test, b) }; @@ -196,9 +196,8 @@ fn panic(info: &core::panic::PanicInfo<'_>) -> ! { #[macro_export] macro_rules! container_of { ($ptr:expr, $type:ty, $($f:tt)*) => {{ - let ptr = $ptr as *const _ as *const u8; let offset: usize = ::core::mem::offset_of!($type, $($f)*); - ptr.sub(offset) as *const $type + $ptr.byte_sub(offset).cast::<$type>() }} } diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs index f7b2743828ae..271a7690a9a0 100644 --- a/rust/kernel/pci.rs +++ b/rust/kernel/pci.rs @@ -364,7 +364,7 @@ pub unsafe fn from_dev(dev: ARef) -> Self { fn as_raw(&self) -> *mut bindings::pci_dev { // SAFETY: By the type invariant `self.0.as_raw` is a pointer to the `struct device` // embedded in `struct pci_dev`. - unsafe { container_of!(self.0.as_raw(), bindings::pci_dev, dev) as _ } + unsafe { container_of!(self.0.as_raw(), bindings::pci_dev, dev) } } /// Returns the PCI vendor ID. diff --git a/rust/kernel/platform.rs b/rust/kernel/platform.rs index 1297f5292ba9..84a4ecc642a1 100644 --- a/rust/kernel/platform.rs +++ b/rust/kernel/platform.rs @@ -189,7 +189,7 @@ unsafe fn from_dev(dev: ARef) -> Self { fn as_raw(&self) -> *mut bindings::platform_device { // SAFETY: By the type invariant `self.0.as_raw` is a pointer to the `struct device` // embedded in `struct platform_device`. - unsafe { container_of!(self.0.as_raw(), bindings::platform_device, dev) }.cast_mut() + unsafe { container_of!(self.0.as_raw(), bindings::platform_device, dev) } } } diff --git a/rust/kernel/rbtree.rs b/rust/kernel/rbtree.rs index 1ea25c7092fb..27de954a0889 100644 --- a/rust/kernel/rbtree.rs +++ b/rust/kernel/rbtree.rs @@ -424,7 +424,7 @@ pub fn cursor_lower_bound(&mut self, key: &K) -> Option> while !node.is_null() { // SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node` objects. - let this = unsafe { container_of!(node, Node, links) }.cast_mut(); + let this = unsafe { container_of!(node, Node, links) }; // SAFETY: `this` is a non-null node so it is valid by the type invariants. let this_key = unsafe { &(*this).key }; // SAFETY: `node` is a non-null node so it is valid by the type invariants. @@ -496,7 +496,7 @@ fn drop(&mut self) { // but it is not observable. The loop invariant is still maintained. // SAFETY: `this` is valid per the loop invariant. - unsafe { drop(KBox::from_raw(this.cast_mut())) }; + unsafe { drop(KBox::from_raw(this)) }; } } } @@ -761,7 +761,7 @@ pub fn remove_current(self) -> (Option, RBTreeNode) { let next = self.get_neighbor_raw(Direction::Next); // SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node` objects. - let this = unsafe { container_of!(self.current.as_ptr(), Node, links) }.cast_mut(); + let this = unsafe { container_of!(self.current.as_ptr(), Node, links) }; // SAFETY: `this` is valid by the type invariants as described above. let node = unsafe { KBox::from_raw(this) }; let node = RBTreeNode { node }; @@ -806,7 +806,7 @@ fn remove_neighbor(&mut self, direction: Direction) -> Option> unsafe { bindings::rb_erase(neighbor, addr_of_mut!(self.tree.root)) }; // SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node` objects. - let this = unsafe { container_of!(neighbor, Node, links) }.cast_mut(); + let this = unsafe { container_of!(neighbor, Node, links) }; // SAFETY: `this` is valid by the type invariants as described above. let node = unsafe { KBox::from_raw(this) }; return Some(RBTreeNode { node }); @@ -912,7 +912,7 @@ unsafe fn to_key_value_mut<'b>(node: NonNull) -> (&'b K, &'b unsafe fn to_key_value_raw<'b>(node: NonNull) -> (&'b K, *mut V) { // SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node` objects. - let this = unsafe { container_of!(node.as_ptr(), Node, links) }.cast_mut(); + let this = unsafe { container_of!(node.as_ptr(), Node, links) }; // SAFETY: The passed `node` is the current node or a non-null neighbor, // thus `this` is valid by the type invariants. let k = unsafe { &(*this).key }; @@ -1021,7 +1021,7 @@ fn next(&mut self) -> Option { // SAFETY: By the type invariant of `IterRaw`, `self.next` is a valid node in an `RBTree`, // and by the type invariant of `RBTree`, all nodes point to the links field of `Node` objects. - let cur = unsafe { container_of!(self.next, Node, links) }.cast_mut(); + let cur = unsafe { container_of!(self.next, Node, links) }; // SAFETY: `self.next` is a valid tree node by the type invariants. self.next = unsafe { bindings::rb_next(self.next) }; @@ -1216,7 +1216,7 @@ pub fn get_mut(&mut self) -> &mut V { // SAFETY: // - `self.node_links` is a valid pointer to a node in the tree. // - We have exclusive access to the underlying tree, and can thus give out a mutable reference. - unsafe { &mut (*(container_of!(self.node_links, Node, links).cast_mut())).value } + unsafe { &mut (*(container_of!(self.node_links, Node, links))).value } } /// Converts the entry into a mutable reference to its value. @@ -1226,7 +1226,7 @@ pub fn into_mut(self) -> &'a mut V { // SAFETY: // - `self.node_links` is a valid pointer to a node in the tree. // - This consumes the `&'a mut RBTree`, therefore it can give out a mutable reference that lives for `'a`. - unsafe { &mut (*(container_of!(self.node_links, Node, links).cast_mut())).value } + unsafe { &mut (*(container_of!(self.node_links, Node, links))).value } } /// Remove this entry from the [`RBTree`]. @@ -1239,9 +1239,7 @@ pub fn remove_node(self) -> RBTreeNode { RBTreeNode { // SAFETY: The node was a node in the tree, but we removed it, so we can convert it // back into a box. - node: unsafe { - KBox::from_raw(container_of!(self.node_links, Node, links).cast_mut()) - }, + node: unsafe { KBox::from_raw(container_of!(self.node_links, Node, links)) }, } } @@ -1272,8 +1270,7 @@ fn replace(self, node: RBTreeNode) -> RBTreeNode { // SAFETY: // - `self.node_ptr` produces a valid pointer to a node in the tree. // - Now that we removed this entry from the tree, we can convert the node to a box. - let old_node = - unsafe { KBox::from_raw(container_of!(self.node_links, Node, links).cast_mut()) }; + let old_node = unsafe { KBox::from_raw(container_of!(self.node_links, Node, links)) }; RBTreeNode { node: old_node } } From patchwork Sat Mar 15 12:17:26 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tamir Duberstein X-Patchwork-Id: 14017995 Received: from mail-qk1-f169.google.com (mail-qk1-f169.google.com [209.85.222.169]) (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 2BC741FBC9E; Sat, 15 Mar 2025 12:17:35 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.222.169 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041058; cv=none; b=t/pYJF6DY5jlcHZw6IW1QVLB1mSuOk3/uP4YZbMF6I+arKnbI3jTn8fopOrRP6TEgMKoPI9Qn0EPHDuQlz+c5Gd0gMkE/cUXR8nz+W2AOmvFCS/qFe7Q6+1Qouvuzf6V+VeveYS7HB6+Yz6D5eb59yo1IMt5cEBstOjAUENGCwQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041058; c=relaxed/simple; bh=A0p0QU7vKtKHyDtZnqhwCkBs8pZUG0p1EEX78FN0cQA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=Y3JWB0/HJA/WYD/817pdolGZ3U7lj0sytgEEbYI7xFyIACmyLKyAOfqb9WuPzyKXTrCNGIZN+nFei/U3n5QS8a7kG74HywdtPrbFaCqgpn3hmA8awirqduGsaYq4UL/WKSE6Y8yBcTnLQRZZAzUORRwiBwc60OhN3QuYsok83YU= 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=NZDSGTiX; arc=none smtp.client-ip=209.85.222.169 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="NZDSGTiX" Received: by mail-qk1-f169.google.com with SMTP id af79cd13be357-7c3bf231660so356528985a.0; Sat, 15 Mar 2025 05:17:35 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742041055; x=1742645855; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=8r03cVoFEobWgoxTEx4IE1/g/z2OCy2I/gCSkusCOVw=; b=NZDSGTiXxadpYGYBG5KVAih+tVBwyvTgBoci+1qnSCp4dkix2sFI36xxq27qfbKCOR f4cpjAIWdpjeP1WEkPH4zx4ad1k3c90KDRNVemyGFTC3HQqhFF4819RGcmHyXjMUI4j5 T3nyPPPYLF7AyhPR1f78NeWj2WkLLo7XBfjMwIMj/wmSSeAaZ4IbGk+AxvBOYhYeKyDB 7JmIpg17ug3j7MmChHe4fuVKe7/mHsut8XLw02b+c4LzFMTdXdPoNpcrsQoHv6qlzIzO +CnrzPfxXQb2/T6JadkIdTb72+IhSlyDYsiNiYHjI5QY4JXoq65Ht70mMu+eSGHrWf7V P6tQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742041055; x=1742645855; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=8r03cVoFEobWgoxTEx4IE1/g/z2OCy2I/gCSkusCOVw=; b=rIYVq+Ub/L5Qz+3wxHPKXUJZpRiH3WOvXrNm2xwziNUJUgpqa9GOPIOOUGoZrFL/r+ q38B6pu8upuSIfLlBD/ujzynDRi2YPMT2tujEbeOt5D1U5tQP+vcn2KuTNZ9o2nxR0bb 2NO8PiECap4tSqEQCoXss3AsIxfQhVRMfdjxiE0895++GNjf47g/ipxqumXT4tjoXDyz D8AIlDDZE2SQCk6KZp4Inpu/rWg2EoukADGVe/waSmMxZCOIxaX0AXk4V9l9iwpX9LSY iAlkE1AZEuL+tNOmKl7YNP+HhRqMxGlCEngwDlDbPKjtj4c4TFtn/zW/B1D1DTT06FVe 1W3g== X-Forwarded-Encrypted: i=1; AJvYcCVllQJKpQdl+k4HzdeqiYU20LKRG8lpSXYs3TQd9ya+B+LTR841MQOEN/QG9Hh4/GwTbqCrhuAThOey@vger.kernel.org, AJvYcCVm8VYqVzEfcxXA1fPhf5GOHFs9kf/56SpFOuIBU/tPaNvbYv9Mfn9Dd4vq+0U2/QitIdjQQ50svmwk@vger.kernel.org, AJvYcCWGkZ2t7EDC9dZq56fikIx0xEuSBoHuFvO09pVJ1a6EeJ0JCKcLa4BfH7hRI06rsnhKOSRxfEmlUjr1imKjratz@vger.kernel.org, AJvYcCXQyv6/sym/URL7hD/SBdomlnParQbV4fTsOTDsBPzOCCYr+4vIcplYRkerxaaLNns1mYrTtGf6EUta7SM+@vger.kernel.org, AJvYcCXa+aLilwbF9w/tNpd+L5rYX6WbLE2pxnNJtBSqqd2HBAhNVlh6K3MqjXBOG+T817897+YK4ArzwlUsfdM=@vger.kernel.org, AJvYcCXktHvf0qQkyzlFAJksinLjFmVwuajyuYU1d0fTayWOFhlRz8V34wHtvZ4hKbnNzrs0eioKhLSOgFWVmqTfFwY=@vger.kernel.org X-Gm-Message-State: AOJu0YyqsZydcXbx3u8Z7/bQgdS5YzDxXi+rntwEOwIpSrnp0S7l2lzF KGk3N6VpoYleNHTLvc9F9Ec7ZHL36GlnwG/B4vlNbxKiuhkveLjj X-Gm-Gg: ASbGncsghpq36mKiAKDkiQbhpD7AMhH+yIKark/K4buchwGFa3gAnYjSdx2blP9HTsp x8u1QRD0A80WOqwKjovEA2uNhGjJLumbojtf1JUNTKWwBp2c1gLb8FwQZq6WsF8EvR6LAleDQtd nLEd41Li9IpaUloVBWVyJhtW1XJ8BikfaN9plmSvYHuQJQyoSan/Xw+79T+8MHte71n4sgm13kG r3XFGfhWf94uY/yjKCZbh8vtDJFKog/lo7vuLB7sir5+EimeE+Nzz3cs8V/1RZea1y4c8zKzkqy Anm6ju+/3+mRRb8lROAEwi4HD41iaDClHrB+MKO1YGpSEJXf8c/PRSn1epdFO3NScQOvR1k88FK CLys= X-Google-Smtp-Source: AGHT+IEpIreYO/Me7lBhCwuhSt2RjRhFJd0x/jsUAJvzPS2v7QvsyFnjUGML4K+xubqD8oc+kemFXg== X-Received: by 2002:a05:620a:318a:b0:7c5:4913:500a with SMTP id af79cd13be357-7c57c79be6dmr638691485a.19.1742041054799; Sat, 15 Mar 2025 05:17:34 -0700 (PDT) Received: from tamird-mac.local ([2600:4041:5be7:7c00:cd19:6a0f:e1a6:e800]) by smtp.gmail.com with ESMTPSA id af79cd13be357-7c573c9be48sm371885185a.60.2025.03.15.05.17.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 15 Mar 2025 05:17:34 -0700 (PDT) From: Tamir Duberstein Date: Sat, 15 Mar 2025 08:17:26 -0400 Subject: [PATCH v4 2/6] rust: enable `clippy::ptr_as_ptr` lint Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20250315-ptr-as-ptr-v4-2-b2d72c14dc26@gmail.com> References: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> In-Reply-To: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> To: Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Brendan Higgins , David Gow , Rae Moar , Bjorn Helgaas , Luis Chamberlain , Russ Weight , Rob Herring , Saravana Kannan Cc: linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com, linux-pci@vger.kernel.org, linux-block@vger.kernel.org, devicetree@vger.kernel.org, Tamir Duberstein X-Mailer: b4 0.15-dev In Rust 1.51.0, Clippy introduced the `ptr_as_ptr` lint [1]: > Though `as` casts between raw pointers are not terrible, > `pointer::cast` is safer because it cannot accidentally change the > pointer's mutability, nor cast the pointer to other types like `usize`. There are a few classes of changes required: - Modules generated by bindgen are marked `#[allow(clippy::ptr_as_ptr)]`. - Inferred casts (` as _`) are replaced with `.cast()`. - Ascribed casts (` as *... T`) are replaced with `.cast::()`. - Multistep casts from references (` as *const _ as *const T`) are replaced with `let x: *const _ = &x;` and `.cast()` or `.cast::()` according to the previous rules. The intermediate `let` binding is required because `(x as *const _).cast::()` results in inference failure. - Native literal C strings are replaced with `c_str!().as_char_ptr()`. - `*mut *mut T as _` is replaced with `let *mut *const T = (*mut *mut T)`.cast();` since pointer to pointer can be confusing. Apply these changes and enable the lint -- no functional change intended. Link: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr [1] Reviewed-by: Benno Lossin Signed-off-by: Tamir Duberstein --- Makefile | 1 + rust/bindings/lib.rs | 1 + rust/kernel/alloc/allocator_test.rs | 2 +- rust/kernel/alloc/kvec.rs | 4 ++-- rust/kernel/device.rs | 5 +++-- rust/kernel/devres.rs | 2 +- rust/kernel/error.rs | 2 +- rust/kernel/firmware.rs | 3 ++- rust/kernel/fs/file.rs | 2 +- rust/kernel/kunit.rs | 15 +++++++-------- rust/kernel/list/impl_list_item_mod.rs | 2 +- rust/kernel/pci.rs | 2 +- rust/kernel/platform.rs | 4 +++- rust/kernel/print.rs | 11 +++++------ rust/kernel/seq_file.rs | 3 ++- rust/kernel/str.rs | 2 +- rust/kernel/sync/poll.rs | 2 +- rust/kernel/workqueue.rs | 10 +++++----- rust/uapi/lib.rs | 1 + 19 files changed, 40 insertions(+), 34 deletions(-) diff --git a/Makefile b/Makefile index 70bdbf2218fc..ec8efc8e23ba 100644 --- a/Makefile +++ b/Makefile @@ -483,6 +483,7 @@ export rust_common_flags := --edition=2021 \ -Wclippy::needless_continue \ -Aclippy::needless_lifetimes \ -Wclippy::no_mangle_with_rust_abi \ + -Wclippy::ptr_as_ptr \ -Wclippy::undocumented_unsafe_blocks \ -Wclippy::unnecessary_safety_comment \ -Wclippy::unnecessary_safety_doc \ diff --git a/rust/bindings/lib.rs b/rust/bindings/lib.rs index 014af0d1fc70..0486a32ed314 100644 --- a/rust/bindings/lib.rs +++ b/rust/bindings/lib.rs @@ -25,6 +25,7 @@ )] #[allow(dead_code)] +#[allow(clippy::ptr_as_ptr)] #[allow(clippy::undocumented_unsafe_blocks)] mod bindings_raw { // Manual definition for blocklisted types. diff --git a/rust/kernel/alloc/allocator_test.rs b/rust/kernel/alloc/allocator_test.rs index c37d4c0c64e9..8017aa9d5213 100644 --- a/rust/kernel/alloc/allocator_test.rs +++ b/rust/kernel/alloc/allocator_test.rs @@ -82,7 +82,7 @@ unsafe fn realloc( // SAFETY: Returns either NULL or a pointer to a memory allocation that satisfies or // exceeds the given size and alignment requirements. - let dst = unsafe { libc_aligned_alloc(layout.align(), layout.size()) } as *mut u8; + let dst = unsafe { libc_aligned_alloc(layout.align(), layout.size()) }.cast::(); let dst = NonNull::new(dst).ok_or(AllocError)?; if flags.contains(__GFP_ZERO) { diff --git a/rust/kernel/alloc/kvec.rs b/rust/kernel/alloc/kvec.rs index ae9d072741ce..c12844764671 100644 --- a/rust/kernel/alloc/kvec.rs +++ b/rust/kernel/alloc/kvec.rs @@ -262,7 +262,7 @@ pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit] { // - `self.len` is smaller than `self.capacity` and hence, the resulting pointer is // guaranteed to be part of the same allocated object. // - `self.len` can not overflow `isize`. - let ptr = unsafe { self.as_mut_ptr().add(self.len) } as *mut MaybeUninit; + let ptr = unsafe { self.as_mut_ptr().add(self.len) }.cast::>(); // SAFETY: The memory between `self.len` and `self.capacity` is guaranteed to be allocated // and valid, but uninitialized. @@ -554,7 +554,7 @@ fn drop(&mut self) { // - `ptr` points to memory with at least a size of `size_of::() * len`, // - all elements within `b` are initialized values of `T`, // - `len` does not exceed `isize::MAX`. - unsafe { Vec::from_raw_parts(ptr as _, len, len) } + unsafe { Vec::from_raw_parts(ptr.cast(), len, len) } } } diff --git a/rust/kernel/device.rs b/rust/kernel/device.rs index db2d9658ba47..9e500498835d 100644 --- a/rust/kernel/device.rs +++ b/rust/kernel/device.rs @@ -168,16 +168,17 @@ pub fn pr_dbg(&self, args: fmt::Arguments<'_>) { /// `KERN_*`constants, for example, `KERN_CRIT`, `KERN_ALERT`, etc. #[cfg_attr(not(CONFIG_PRINTK), allow(unused_variables))] unsafe fn printk(&self, klevel: &[u8], msg: fmt::Arguments<'_>) { + let msg: *const _ = &msg; // SAFETY: `klevel` is null-terminated and one of the kernel constants. `self.as_raw` // is valid because `self` is valid. The "%pA" format string expects a pointer to // `fmt::Arguments`, which is what we're passing as the last argument. #[cfg(CONFIG_PRINTK)] unsafe { bindings::_dev_printk( - klevel as *const _ as *const crate::ffi::c_char, + klevel.as_ptr().cast::(), self.as_raw(), c_str!("%pA").as_char_ptr(), - &msg as *const _ as *const crate::ffi::c_void, + msg.cast::(), ) }; } diff --git a/rust/kernel/devres.rs b/rust/kernel/devres.rs index 942376f6f3af..3a9d998ec371 100644 --- a/rust/kernel/devres.rs +++ b/rust/kernel/devres.rs @@ -157,7 +157,7 @@ fn remove_action(this: &Arc) { #[allow(clippy::missing_safety_doc)] unsafe extern "C" fn devres_callback(ptr: *mut kernel::ffi::c_void) { - let ptr = ptr as *mut DevresInner; + let ptr = ptr.cast::>(); // Devres owned this memory; now that we received the callback, drop the `Arc` and hence the // reference. // SAFETY: Safe, since we leaked an `Arc` reference to devm_add_action() in diff --git a/rust/kernel/error.rs b/rust/kernel/error.rs index f6ecf09cb65f..8654d52b0bb9 100644 --- a/rust/kernel/error.rs +++ b/rust/kernel/error.rs @@ -152,7 +152,7 @@ pub(crate) fn to_blk_status(self) -> bindings::blk_status_t { /// Returns the error encoded as a pointer. pub fn to_ptr(self) -> *mut T { // SAFETY: `self.0` is a valid error due to its invariant. - unsafe { bindings::ERR_PTR(self.0.get() as _) as *mut _ } + unsafe { bindings::ERR_PTR(self.0.get() as _).cast() } } /// Returns a string representing the error, if one exists. diff --git a/rust/kernel/firmware.rs b/rust/kernel/firmware.rs index c5162fdc95ff..74df815d2f4e 100644 --- a/rust/kernel/firmware.rs +++ b/rust/kernel/firmware.rs @@ -58,10 +58,11 @@ impl Firmware { fn request_internal(name: &CStr, dev: &Device, func: FwFunc) -> Result { let mut fw: *mut bindings::firmware = core::ptr::null_mut(); let pfw: *mut *mut bindings::firmware = &mut fw; + let pfw: *mut *const bindings::firmware = pfw.cast(); // SAFETY: `pfw` is a valid pointer to a NULL initialized `bindings::firmware` pointer. // `name` and `dev` are valid as by their type invariants. - let ret = unsafe { func.0(pfw as _, name.as_char_ptr(), dev.as_raw()) }; + let ret = unsafe { func.0(pfw, name.as_char_ptr(), dev.as_raw()) }; if ret != 0 { return Err(Error::from_errno(ret)); } diff --git a/rust/kernel/fs/file.rs b/rust/kernel/fs/file.rs index ed57e0137cdb..9e2639aee61a 100644 --- a/rust/kernel/fs/file.rs +++ b/rust/kernel/fs/file.rs @@ -364,7 +364,7 @@ fn deref(&self) -> &LocalFile { // // By the type invariants, there are no `fdget_pos` calls that did not take the // `f_pos_lock` mutex. - unsafe { LocalFile::from_raw_file(self as *const File as *const bindings::file) } + unsafe { LocalFile::from_raw_file((self as *const Self).cast()) } } } diff --git a/rust/kernel/kunit.rs b/rust/kernel/kunit.rs index 824da0e9738a..7ed2063c1af0 100644 --- a/rust/kernel/kunit.rs +++ b/rust/kernel/kunit.rs @@ -8,19 +8,20 @@ use core::{ffi::c_void, fmt}; +#[cfg(CONFIG_PRINTK)] +use crate::c_str; + /// Prints a KUnit error-level message. /// /// Public but hidden since it should only be used from KUnit generated code. #[doc(hidden)] pub fn err(args: fmt::Arguments<'_>) { + let args: *const _ = &args; // SAFETY: The format string is null-terminated and the `%pA` specifier matches the argument we // are passing. #[cfg(CONFIG_PRINTK)] unsafe { - bindings::_printk( - c"\x013%pA".as_ptr() as _, - &args as *const _ as *const c_void, - ); + bindings::_printk(c_str!("\x013%pA").as_char_ptr(), args.cast::()); } } @@ -29,14 +30,12 @@ pub fn err(args: fmt::Arguments<'_>) { /// Public but hidden since it should only be used from KUnit generated code. #[doc(hidden)] pub fn info(args: fmt::Arguments<'_>) { + let args: *const _ = &args; // SAFETY: The format string is null-terminated and the `%pA` specifier matches the argument we // are passing. #[cfg(CONFIG_PRINTK)] unsafe { - bindings::_printk( - c"\x016%pA".as_ptr() as _, - &args as *const _ as *const c_void, - ); + bindings::_printk(c_str!("\x016%pA").as_char_ptr(), args.cast::()); } } diff --git a/rust/kernel/list/impl_list_item_mod.rs b/rust/kernel/list/impl_list_item_mod.rs index a0438537cee1..1f9498c1458f 100644 --- a/rust/kernel/list/impl_list_item_mod.rs +++ b/rust/kernel/list/impl_list_item_mod.rs @@ -34,7 +34,7 @@ pub unsafe trait HasListLinks { unsafe fn raw_get_list_links(ptr: *mut Self) -> *mut ListLinks { // SAFETY: The caller promises that the pointer is valid. The implementer promises that the // `OFFSET` constant is correct. - unsafe { (ptr as *mut u8).add(Self::OFFSET) as *mut ListLinks } + unsafe { ptr.cast::().add(Self::OFFSET).cast() } } } diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs index 271a7690a9a0..003c9aaafb24 100644 --- a/rust/kernel/pci.rs +++ b/rust/kernel/pci.rs @@ -75,7 +75,7 @@ extern "C" fn probe_callback( // Let the `struct pci_dev` own a reference of the driver's private data. // SAFETY: By the type invariant `pdev.as_raw` returns a valid pointer to a // `struct pci_dev`. - unsafe { bindings::pci_set_drvdata(pdev.as_raw(), data.into_foreign() as _) }; + unsafe { bindings::pci_set_drvdata(pdev.as_raw(), data.into_foreign().cast()) }; } Err(err) => return Error::to_errno(err), } diff --git a/rust/kernel/platform.rs b/rust/kernel/platform.rs index 84a4ecc642a1..26b2502970ef 100644 --- a/rust/kernel/platform.rs +++ b/rust/kernel/platform.rs @@ -66,7 +66,9 @@ extern "C" fn probe_callback(pdev: *mut bindings::platform_device) -> kernel::ff // Let the `struct platform_device` own a reference of the driver's private data. // SAFETY: By the type invariant `pdev.as_raw` returns a valid pointer to a // `struct platform_device`. - unsafe { bindings::platform_set_drvdata(pdev.as_raw(), data.into_foreign() as _) }; + unsafe { + bindings::platform_set_drvdata(pdev.as_raw(), data.into_foreign().cast()) + }; } Err(err) => return Error::to_errno(err), } diff --git a/rust/kernel/print.rs b/rust/kernel/print.rs index cf4714242e14..8ae57d2cd36c 100644 --- a/rust/kernel/print.rs +++ b/rust/kernel/print.rs @@ -25,7 +25,7 @@ // SAFETY: The C contract guarantees that `buf` is valid if it's less than `end`. let mut w = unsafe { RawFormatter::from_ptrs(buf.cast(), end.cast()) }; // SAFETY: TODO. - let _ = w.write_fmt(unsafe { *(ptr as *const fmt::Arguments<'_>) }); + let _ = w.write_fmt(unsafe { *ptr.cast::>() }); w.pos().cast() } @@ -102,6 +102,7 @@ pub unsafe fn call_printk( module_name: &[u8], args: fmt::Arguments<'_>, ) { + let args: *const _ = &args; // `_printk` does not seem to fail in any path. #[cfg(CONFIG_PRINTK)] // SAFETY: TODO. @@ -109,7 +110,7 @@ pub unsafe fn call_printk( bindings::_printk( format_string.as_ptr(), module_name.as_ptr(), - &args as *const _ as *const c_void, + args.cast::(), ); } } @@ -122,15 +123,13 @@ pub unsafe fn call_printk( #[doc(hidden)] #[cfg_attr(not(CONFIG_PRINTK), allow(unused_variables))] pub fn call_printk_cont(args: fmt::Arguments<'_>) { + let args: *const _ = &args; // `_printk` does not seem to fail in any path. // // SAFETY: The format string is fixed. #[cfg(CONFIG_PRINTK)] unsafe { - bindings::_printk( - format_strings::CONT.as_ptr(), - &args as *const _ as *const c_void, - ); + bindings::_printk(format_strings::CONT.as_ptr(), args.cast::()); } } diff --git a/rust/kernel/seq_file.rs b/rust/kernel/seq_file.rs index 4c03881a9eba..d7a530d3eb07 100644 --- a/rust/kernel/seq_file.rs +++ b/rust/kernel/seq_file.rs @@ -31,12 +31,13 @@ pub unsafe fn from_raw<'a>(ptr: *mut bindings::seq_file) -> &'a SeqFile { /// Used by the [`seq_print`] macro. pub fn call_printf(&self, args: core::fmt::Arguments<'_>) { + let args: *const _ = &args; // SAFETY: Passing a void pointer to `Arguments` is valid for `%pA`. unsafe { bindings::seq_printf( self.inner.get(), c_str!("%pA").as_char_ptr(), - &args as *const _ as *const crate::ffi::c_void, + args.cast::(), ); } } diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs index 28e2201604d6..6a1a982b946d 100644 --- a/rust/kernel/str.rs +++ b/rust/kernel/str.rs @@ -191,7 +191,7 @@ pub unsafe fn from_char_ptr<'a>(ptr: *const crate::ffi::c_char) -> &'a Self { // to a `NUL`-terminated C string. let len = unsafe { bindings::strlen(ptr) } + 1; // SAFETY: Lifetime guaranteed by the safety precondition. - let bytes = unsafe { core::slice::from_raw_parts(ptr as _, len) }; + let bytes = unsafe { core::slice::from_raw_parts(ptr.cast(), len) }; // SAFETY: As `len` is returned by `strlen`, `bytes` does not contain interior `NUL`. // As we have added 1 to `len`, the last byte is known to be `NUL`. unsafe { Self::from_bytes_with_nul_unchecked(bytes) } diff --git a/rust/kernel/sync/poll.rs b/rust/kernel/sync/poll.rs index e105477a3cb1..d04d90486b09 100644 --- a/rust/kernel/sync/poll.rs +++ b/rust/kernel/sync/poll.rs @@ -73,7 +73,7 @@ pub fn register_wait(&mut self, file: &File, cv: &PollCondVar) { // be destroyed, the destructor must run. That destructor first removes all waiters, // and then waits for an rcu grace period. Therefore, `cv.wait_queue_head` is valid for // long enough. - unsafe { qproc(file.as_ptr() as _, cv.wait_queue_head.get(), self.0.get()) }; + unsafe { qproc(file.as_ptr().cast(), cv.wait_queue_head.get(), self.0.get()) }; } } } diff --git a/rust/kernel/workqueue.rs b/rust/kernel/workqueue.rs index 0cd100d2aefb..8ff54105be3f 100644 --- a/rust/kernel/workqueue.rs +++ b/rust/kernel/workqueue.rs @@ -170,7 +170,7 @@ impl Queue { pub unsafe fn from_raw<'a>(ptr: *const bindings::workqueue_struct) -> &'a Queue { // SAFETY: The `Queue` type is `#[repr(transparent)]`, so the pointer cast is valid. The // caller promises that the pointer is not dangling. - unsafe { &*(ptr as *const Queue) } + unsafe { &*ptr.cast::() } } /// Enqueues a work item. @@ -457,7 +457,7 @@ fn get_work_offset(&self) -> usize { #[inline] unsafe fn raw_get_work(ptr: *mut Self) -> *mut Work { // SAFETY: The caller promises that the pointer is valid. - unsafe { (ptr as *mut u8).add(Self::OFFSET) as *mut Work } + unsafe { ptr.cast::().add(Self::OFFSET).cast::>() } } /// Returns a pointer to the struct containing the [`Work`] field. @@ -472,7 +472,7 @@ unsafe fn work_container_of(ptr: *mut Work) -> *mut Self { // SAFETY: The caller promises that the pointer points at a field of the right type in the // right kind of struct. - unsafe { (ptr as *mut u8).sub(Self::OFFSET) as *mut Self } + unsafe { ptr.cast::().sub(Self::OFFSET).cast::() } } } @@ -538,7 +538,7 @@ unsafe impl WorkItemPointer for Arc { unsafe extern "C" fn run(ptr: *mut bindings::work_struct) { // The `__enqueue` method always uses a `work_struct` stored in a `Work`. - let ptr = ptr as *mut Work; + let ptr = ptr.cast::>(); // SAFETY: This computes the pointer that `__enqueue` got from `Arc::into_raw`. let ptr = unsafe { T::work_container_of(ptr) }; // SAFETY: This pointer comes from `Arc::into_raw` and we've been given back ownership. @@ -591,7 +591,7 @@ unsafe impl WorkItemPointer for Pin> { unsafe extern "C" fn run(ptr: *mut bindings::work_struct) { // The `__enqueue` method always uses a `work_struct` stored in a `Work`. - let ptr = ptr as *mut Work; + let ptr = ptr.cast::>(); // SAFETY: This computes the pointer that `__enqueue` got from `Arc::into_raw`. let ptr = unsafe { T::work_container_of(ptr) }; // SAFETY: This pointer comes from `Arc::into_raw` and we've been given back ownership. diff --git a/rust/uapi/lib.rs b/rust/uapi/lib.rs index 13495910271f..fe9bf7b5a306 100644 --- a/rust/uapi/lib.rs +++ b/rust/uapi/lib.rs @@ -15,6 +15,7 @@ #![allow( clippy::all, clippy::undocumented_unsafe_blocks, + clippy::ptr_as_ptr, dead_code, missing_docs, non_camel_case_types, From patchwork Sat Mar 15 12:17:27 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tamir Duberstein X-Patchwork-Id: 14017996 Received: from mail-qk1-f171.google.com (mail-qk1-f171.google.com [209.85.222.171]) (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 489BC1FC0EB; Sat, 15 Mar 2025 12:17:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.222.171 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041060; cv=none; b=GmGLWLxp4Q6sFpDEMDSct8iIzPt6jFVvKpC006s9xi8D8fydFwvZS8BAXC+FRHdFkUdezDuVos0LYj4Ijk93lEf1auMcZH+fhuBYniRjoJPZSoU0w/OEiyPbuE3b1ZL+idkApTUq+s/tnfk7E/jWrf4Rik2/5ktkMZ/Q6Z/Ga0E= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041060; c=relaxed/simple; bh=/r0m5YzIWWRQazZFOJwTQSRLej9n6gB2sGQQ7S4a1Yg=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=YYAxWIJfLTnAK/qtVpIlPGo8SA4GjZwKhpve+OZlzd7TuKUwJ3L+TE9MJUApM+IMMj5S8LUnx7T3zMBWyVmCS83Iqk6bgVk91LpLiFCBIze1E6/7BMFLrsASVVqUqxYcP23WIf0/F2sLyLzQqgZkyFy+0xVHclQSSJsAUjcDNZA= 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=QVyrdJUL; arc=none smtp.client-ip=209.85.222.171 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="QVyrdJUL" Received: by mail-qk1-f171.google.com with SMTP id af79cd13be357-7c559b3eb0bso178412085a.1; Sat, 15 Mar 2025 05:17:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742041057; x=1742645857; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=3pDD8iTOqsV2dG/t13s+olVTpQHy7nswKrZLCkN6NIk=; b=QVyrdJULlr/xSLFugkS9sHH6tqR+KeRmNKyFM+hBLR/ncVEkrlqb82+hKBMur96PF0 gu3P9Ezn32dFML+b1CYc64GCMTk0vFQY+qywz8H7+nedrbNNAtkDw3RjUbAbo5XyABzS 7K1+8CNzLzf1+Fs/Ly50X3UvgMBn/fEbfrw9urqYujS6gdJc8Lyf4rNVk0j/N3bker+L rBYyyuv1lNh7rnPrcusb8JXvvYfxERt871WzH1gDS6rGxuU/TCX7QF/78iJ+dICnHHov rRgR4mlDFJbbJ26fTUB5Wic36ohdRkCN/K1TNo0lLXinkvwpq/Mk6UEto/rhwj0Y4/73 1EIA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742041057; x=1742645857; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=3pDD8iTOqsV2dG/t13s+olVTpQHy7nswKrZLCkN6NIk=; b=kjv9HWbSXvdJBkDi9bbFqyaKk129HTFguYgogZHFLkfktutss9kAclkBHVYPVlmv5z HaPvyhfMiGur5i2fMBjomie4zwf9AIUi8D5QAStlVEt7J3k0h2oYC24tKQWnjhoqwE5m nnEvmg4NDznSHmJteK1hrSsa722B3Vg52aX9i7oQVhXZ0P+0UNgx2lRYEnX1dxCeAiJj 7pUSOxNw8s9xxuQ86pUZ9g0LLLKOIGl7Rlq1UxYFS3S6K/WACZGcyPZBa96V7R22hXrb m0WZwKDkIuKCpWi6JfQWvx56kcWwVnh7gyDO9rOKdL1lMjGionvJuGfoK5byilN7BduA /Apw== X-Forwarded-Encrypted: i=1; AJvYcCVbH3j3CUQAsumdwcrE6M1laubacITkMRqo2drPgQ6IyeF5KMzk3b1Sro7vZo7fZrrjofgphqLhiwX+l1A=@vger.kernel.org, AJvYcCVcP7ofIF/Oox6Ce1HAoM2gBQFcSJpZ45yqC1cPIsfqWDcGZB7nXnHYcD7JblFvPeg8jmrq4SaBfYQ/@vger.kernel.org, AJvYcCVfV+9mycxOoaPp40b8I1EZcGLZXKUDrdBc/2bKFDFcHpf+mG5t2hyZ0OV2ur2I0FedVXk2z9m3YaL0pzwAeec=@vger.kernel.org, AJvYcCVzBx+6RNNFFcT4srVgBlVc671QGnNq25yAcxAGsFP2BKz7njvCtWgq9YHKA3di0AVS09hcWPfZk5yu+jDZ@vger.kernel.org, AJvYcCWmH2hnRafR+H8ZaIxt9HyOP6AouxSLTdV1tbR+wfxbXJP9LCfk/3CRAhiZXuZklR6MZEuELJ/myD3n@vger.kernel.org, AJvYcCWuvwAqfA1ZRcdNaI4YfxyKRlXPyCoxjhND6Ns1qMkeDcnSIuVNUAGrPSCQRdTrg00d17r7uNQq1xKtxRUySfVw@vger.kernel.org X-Gm-Message-State: AOJu0YyRl0COl45eG7lHtwTdZHVWaabn9MSCx3xUKcKqgUj9q6NPRA7j 9E1GQ0mhQ5kazDBLH123F0uOQtcoUciI3tAmlOCWFu2U94M6Ftlk X-Gm-Gg: ASbGncuDYlVmV9lGLs6HEsyVWgtHwWEFiHYgw2MeWxAXeA6wUX7SapIfcHIQemBtHqG rI4mY3bKm00jF2NqkEepuWPhRpgtMD5pxyNItxj1I+Qrm/JX0yaFC5D5Vwm1FhwUt1xVDk8YVBO eUuWlJ4Kin6slE7goydHvbGEWINGqO7H8U2VXTcKctae3+hA+PWWch1ss+0lV35r/1TwSVOH9MQ M9OLecVPwneUWlYwWb1HYn4p2tQhHybhLM1Fhqlg6P473WUrzazgP4F5296s7yxpbT50kCXUoHX qjRmEeUHRP7DhKPCp2eN6Jcv5Doqqa3AO+k0A43hAwZL+k1FPfXU3Fg5phX4JAPHDmqj X-Google-Smtp-Source: AGHT+IHUekxau7xPaW0+KxmpDa26nJyHAMk6CCMOp1FyRE4XYEfSDw97ppwK31w6YhjIZwLpPqNs2Q== X-Received: by 2002:a05:620a:46aa:b0:7c5:4349:2f19 with SMTP id af79cd13be357-7c57c8f0c02mr1066084785a.49.1742041057002; Sat, 15 Mar 2025 05:17:37 -0700 (PDT) Received: from tamird-mac.local ([2600:4041:5be7:7c00:cd19:6a0f:e1a6:e800]) by smtp.gmail.com with ESMTPSA id af79cd13be357-7c573c9be48sm371885185a.60.2025.03.15.05.17.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 15 Mar 2025 05:17:36 -0700 (PDT) From: Tamir Duberstein Date: Sat, 15 Mar 2025 08:17:27 -0400 Subject: [PATCH v4 3/6] rust: enable `clippy::ptr_cast_constness` lint Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20250315-ptr-as-ptr-v4-3-b2d72c14dc26@gmail.com> References: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> In-Reply-To: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> To: Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Brendan Higgins , David Gow , Rae Moar , Bjorn Helgaas , Luis Chamberlain , Russ Weight , Rob Herring , Saravana Kannan Cc: linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com, linux-pci@vger.kernel.org, linux-block@vger.kernel.org, devicetree@vger.kernel.org, Tamir Duberstein X-Mailer: b4 0.15-dev In Rust 1.72.0, Clippy introduced the `ptr_cast_constness` lint [1]: > Though `as` casts between raw pointers are not terrible, > `pointer::cast_mut` and `pointer::cast_const` are safer because they > cannot accidentally cast the pointer to another type. There are only 2 affected sites: - `*mut T as *const U as *mut U` becomes `(*mut T).cast()` - `&self as *const Self as *mut Self` becomes a reference-to-pointer coercion + `(*const Self).cast()`. Apply these changes and enable the lint -- no functional change intended. Link: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_cast_constness [1] Reviewed-by: Benno Lossin Signed-off-by: Tamir Duberstein --- Makefile | 1 + rust/kernel/block/mq/request.rs | 5 +++-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index ec8efc8e23ba..c62bae2b107b 100644 --- a/Makefile +++ b/Makefile @@ -484,6 +484,7 @@ export rust_common_flags := --edition=2021 \ -Aclippy::needless_lifetimes \ -Wclippy::no_mangle_with_rust_abi \ -Wclippy::ptr_as_ptr \ + -Wclippy::ptr_cast_constness \ -Wclippy::undocumented_unsafe_blocks \ -Wclippy::unnecessary_safety_comment \ -Wclippy::unnecessary_safety_doc \ diff --git a/rust/kernel/block/mq/request.rs b/rust/kernel/block/mq/request.rs index 7943f43b9575..10c6d69be7f3 100644 --- a/rust/kernel/block/mq/request.rs +++ b/rust/kernel/block/mq/request.rs @@ -69,7 +69,7 @@ pub(crate) unsafe fn aref_from_raw(ptr: *mut bindings::request) -> ARef { // INVARIANT: By the safety requirements of this function, invariants are upheld. // SAFETY: By the safety requirement of this function, we own a // reference count that we can pass to `ARef`. - unsafe { ARef::from_raw(NonNull::new_unchecked(ptr as *const Self as *mut Self)) } + unsafe { ARef::from_raw(NonNull::new_unchecked(ptr.cast())) } } /// Notify the block layer that a request is going to be processed now. @@ -151,11 +151,12 @@ pub(crate) unsafe fn wrapper_ptr(this: *mut Self) -> NonNull /// Return a reference to the [`RequestDataWrapper`] stored in the private /// area of the request structure. pub(crate) fn wrapper_ref(&self) -> &RequestDataWrapper { + let this: *const _ = self; // SAFETY: By type invariant, `self.0` is a valid allocation. Further, // the private data associated with this request is initialized and // valid. The existence of `&self` guarantees that the private data is // valid as a shared reference. - unsafe { Self::wrapper_ptr(self as *const Self as *mut Self).as_ref() } + unsafe { Self::wrapper_ptr(this.cast_mut()).as_ref() } } } From patchwork Sat Mar 15 12:17:28 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Tamir Duberstein X-Patchwork-Id: 14017997 Received: from mail-qk1-f171.google.com (mail-qk1-f171.google.com [209.85.222.171]) (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 DFEBA1FCCE2; Sat, 15 Mar 2025 12:17:41 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.222.171 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041063; cv=none; b=u34cEPNZdC6++i9Kpm6k2on7rPAk7NmAdcaobzMzkVjLlHBwbRwxsdEMlyGHfajJMxel2EYx8TXa82CQ4H4Jsac9rkdaqNLCp9gP0uXjpQlAwXQa775zZUdTsAtfRRSe9aFJ7u92oxMLPqExrHaxNi8eLwiSwVkSWUfU3IAhjYw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041063; c=relaxed/simple; bh=eOC8GNYrVfiMmJjIlMnjsi5R6euOkfd+217Ym/0TGMU=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=TgPT3hPLI3NtojkTDq30kKH7BjnKM5858aePnXS7RdVJTO7SwKj78nEUgxE85n59Ii2tZ00fgoWizDffyq+rMSGi/fzFp2e5rke9naVtWg54c8VKazxzPV1iKfbJFMCOkYbIDTHtpsJCxzL8BPPvQXpozdXvCEmm+mGWlAo3Ebo= 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=lw5RwqVB; arc=none smtp.client-ip=209.85.222.171 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="lw5RwqVB" Received: by mail-qk1-f171.google.com with SMTP id af79cd13be357-7c58974ed57so6734885a.2; Sat, 15 Mar 2025 05:17:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742041061; x=1742645861; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=0DKJLM7Z9Stu40Q/kKnTtPbAzpv2yQ1EFXVOPNeWeiM=; b=lw5RwqVB8GUADajLqsBoR76EKxCewxQ2Su2Zr6Se/yOIrj66wfwUiRkMYkKiyFDOL6 h8nKK3w8ySa2p4rPUBvWQxa8cJCmplBd43495Wo16bueYYRSy3l2WHLmGmkjr6w23Z1V TbWaJCTxw2vYTv9Mrg+s+Y29Ao2Dh6HW4fC4dkdUsK+mIZHAADAvxBanrcym+n9jURFc 3scUqlvy7V92PH1TzcH0bci/zNQFJZIf5g6tgqwW/4BzEkiU6hSvUTE0ww6CcMVJJjNt JDfKWS2UTuB4mUIbyr/mjLmlOL4V/qMnhXg0cr5GqICy69QFa4mFHKvCyJgRQvWcEHnJ xtVg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742041061; x=1742645861; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=0DKJLM7Z9Stu40Q/kKnTtPbAzpv2yQ1EFXVOPNeWeiM=; b=XO27b3QWrLgW5lVIM3XBROsImPxp0YfgPTvPw+Ea+sRxuJ9yMuUZv8iPFRh2OWOrWI RASUXUfMFX2fsUemuGiQHaJOdI6auVGl3LBZmUBMuyyOxtEHuuw+42P9aa4r87ttbdy7 NC4OPSz5E82WN6oJ4J/nkYGKBke0mGPE18Glyd76ufJRGFj8sCTDftiyYVnx6uW0jjsP TNp5XXOFsV6jlXpvWhJWuw6EGv50uABcnaZoePWlQZ0ZlEXqRahAf0MzSTZB4K7pRD8l rKzMnTTa+uWhUXV0xNI54oDjQDWUSAGTGTHNA81kuqy/vMIHO0qdnbnvW0G3wu/Pyvgf yj7w== X-Forwarded-Encrypted: i=1; AJvYcCUFYhHGdXEdmjB+mBC3Em6lHpveGGI/U3ONANZoDU6LQw65h/9oblF8jMleZxGOpstJjeKTp1nK0aMKtra1@vger.kernel.org, AJvYcCUjw+FPWi0LEk08z/TktCK4VKpkcKFMAWgpasnAOruQLc/+Bf944QGHCsXgROdURTO/SGn3nA/5eOs1@vger.kernel.org, AJvYcCV/yneLmvvlZqpu/6MqZ6lg43mkzyqMV9M5Jay9FfUnozqLL4Woq9HU5zpIW9rBgp59sSlo+crcyqTz+S+JJQE=@vger.kernel.org, AJvYcCWwz5R/zAVsHnQ29u4KPOYkDutoDMkf08gptpjR5mnMhUsagOagZtpOFJANFyNQvAFr+4O1nFOTlXqlcp22/Z5h@vger.kernel.org, AJvYcCXXgG0fNKcrBsiAxwdjyoyFd6T58XR7igqmO07k0OWSQEsuPEEjDv5qGrzv9CFiOvpPB17tUJAMBWw3@vger.kernel.org, AJvYcCXrLFACW8kU2LlYmo/2xmrt6uP1kfGQ44VzmHI6ZhnLvMQcoSC6jUAEFf+5NN65zkMny+pUFGZ1RXE5K1E=@vger.kernel.org X-Gm-Message-State: AOJu0Yyz5N8EZSPd4T0LhvUNI0GS6u2ZeGPL+T1qh9zeIONv+F6WugHN 7OM3y50K+tV1BRcYS8TWyNGxWeJRR+ovh1a8WiW62wZpGGWh/Gdv X-Gm-Gg: ASbGnct6Yy05FCBluBBmdxG4BhdUvfjf6F6HnDCDe+LRGzcZdhWXNVTfehR+kklLZQd iauuXk7M1X8AZ52Wiob1vENWvApqyNwLUtntILr942vmjv/eWCeFMCwIu/PV/fNS77txtvr8K1/ wN8NiMsDZ0dbRUunIsNTdjNqzBZa3Lj7DKxBI5KJOtFGEkXCdmm8TpEiZ03Qn8WjSvdWtocatKm NBhSe1f60zRl2F66/5zWCXXvg0iOcAEokGi45wrpzp6B89ZWH6VD2jeygtmUD3g0KGQiLmIBd/p +HWF5MoRKLeLR37wGkvkbeyxmcgVJZWemGv+Qw7fKcAG5s9Tz2Aqungf80acO5clk9LH X-Google-Smtp-Source: AGHT+IFyXw5wRW9zVMT6PEc03Fq+30rTHftgs+ooHPQ0kqyQOsP2npeNaRrfM9vlMPYzF1SwXif3IA== X-Received: by 2002:a05:620a:1929:b0:7c5:5343:8c2c with SMTP id af79cd13be357-7c57c80efb4mr849773285a.27.1742041060753; Sat, 15 Mar 2025 05:17:40 -0700 (PDT) Received: from tamird-mac.local ([2600:4041:5be7:7c00:cd19:6a0f:e1a6:e800]) by smtp.gmail.com with ESMTPSA id af79cd13be357-7c573c9be48sm371885185a.60.2025.03.15.05.17.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 15 Mar 2025 05:17:39 -0700 (PDT) From: Tamir Duberstein Date: Sat, 15 Mar 2025 08:17:28 -0400 Subject: [PATCH v4 4/6] rust: enable `clippy::as_ptr_cast_mut` lint Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20250315-ptr-as-ptr-v4-4-b2d72c14dc26@gmail.com> References: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> In-Reply-To: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> To: Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Brendan Higgins , David Gow , Rae Moar , Bjorn Helgaas , Luis Chamberlain , Russ Weight , Rob Herring , Saravana Kannan Cc: linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com, linux-pci@vger.kernel.org, linux-block@vger.kernel.org, devicetree@vger.kernel.org, Tamir Duberstein X-Mailer: b4 0.15-dev In Rust 1.66.0, Clippy introduced the `as_ptr_cast_mut` lint [1]: > Since `as_ptr` takes a `&self`, the pointer won’t have write > permissions unless interior mutability is used, making it unlikely > that having it as a mutable pointer is correct. There is only one affected callsite, and the change amounts to replacing `as _` with `.cast_mut().cast()`. This doesn't change the semantics, but is more descriptive of what's going on. Apply this change and enable the lint -- no functional change intended. Link: https://rust-lang.github.io/rust-clippy/master/index.html#as_ptr_cast_mut [1] Reviewed-by: Benno Lossin Signed-off-by: Tamir Duberstein --- Makefile | 1 + rust/kernel/devres.rs | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index c62bae2b107b..bb15b86182a3 100644 --- a/Makefile +++ b/Makefile @@ -477,6 +477,7 @@ export rust_common_flags := --edition=2021 \ -Wrust_2018_idioms \ -Wunreachable_pub \ -Wclippy::all \ + -Wclippy::as_ptr_cast_mut \ -Wclippy::ignored_unit_patterns \ -Wclippy::mut_mut \ -Wclippy::needless_bitwise_bool \ diff --git a/rust/kernel/devres.rs b/rust/kernel/devres.rs index 3a9d998ec371..598001157293 100644 --- a/rust/kernel/devres.rs +++ b/rust/kernel/devres.rs @@ -143,7 +143,7 @@ fn remove_action(this: &Arc) { bindings::devm_remove_action_nowarn( this.dev.as_raw(), Some(this.callback), - this.as_ptr() as _, + this.as_ptr().cast_mut().cast(), ) }; From patchwork Sat Mar 15 12:17:29 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tamir Duberstein X-Patchwork-Id: 14017998 Received: from mail-qk1-f169.google.com (mail-qk1-f169.google.com [209.85.222.169]) (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 3D8AC1FCD18; Sat, 15 Mar 2025 12:17:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.222.169 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041066; cv=none; b=aLEy3PVYEs+sgDE6nOK2QMkydgNGdyPBZLeZZtIFV+XR+R1+ynUbOB1QJ/B+9/cdRp7/vPjqIEBWyGWdZd1BohUbJoLfDfGNoC+FuIKVHtWW1D0BA3btRjIdhT3ATtSqIj5gxDpzx3W1o9AdK5kzBhbHH9KySka8pxCail59zTw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041066; c=relaxed/simple; bh=TF/8zGlMJ4E9NmH4cFcUtqgW2z0T3RSo4sDN1zkvRXA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=I1Fit01245zatBRnofhI8Wye0fIwcgM+tMW9Mc9jcwSqm+cKe5xgC4WuP0BW2/sPMHLI2oVRyHB2LrKacczNOPQgDE6/xymj//GsZBSj2luLQvjOn1mUw/YvRBrCFiYfU0hbVZXkcIebUwdTjmYRzBXIndFWrvAYjHDyJLevSig= 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=d3sDP0jU; arc=none smtp.client-ip=209.85.222.169 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="d3sDP0jU" Received: by mail-qk1-f169.google.com with SMTP id af79cd13be357-7c089b2e239so300878885a.0; Sat, 15 Mar 2025 05:17:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742041063; x=1742645863; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=7i7Dn1Qr2XJRZDCeVpIFYEbR3k/nukUqNxJLxugoZJ4=; b=d3sDP0jUhtBF9O33vRyMMu2w3VieRvRtJznT+GxCv83liMsxGsB9ea9S8ePdqHgknW JDkeItWygIiVaIxCxbqRR8pMkMT9H/hjV+EtTcg4wb6AawSBF2yemyQw1wMqsmtc7smI 6r+s8XTxmL9WWSLmS1XdSoimNhIpY11EQsdhEgig1B66szHt7/lHvxLOsO+4QL3lWpRV ZoxCSwUTcyNO7v9mOah4y4di4a8E21pIbFLTdlO5Blg5oUa5OeWikFjAP0QOhLXzAx39 gSim1dFa2Kme0AvVf3pU9E4kkM1ubRoJGEtp92dVYaJzlJNcgkyq13E1C+gIn9O/k3H4 QEEQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742041063; x=1742645863; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=7i7Dn1Qr2XJRZDCeVpIFYEbR3k/nukUqNxJLxugoZJ4=; b=K4ZtM6W2L2P5IBFtHgwpbr3m9uEDevRw6oI4bUatC5PkCZ4NopB9yn5adni2Jni4y6 WX2g3Wi1mXz5YWDbmHhYP3mMhwUczD9sz1RT39tLzZLO81o4V5ThRfhIfyqGoSE/V3oa pCu22BC0CN2lvuOi7w647cLSo1YqaouII/vCahncy/DpS+0msayySDMmmUXc5p+C2nWu 8FRpFOhv8QFQHQbdef9e7/FOU5qyVPFQNfA/yBnDxAN6hACOebNEZ5Xaf6kBsGGpUK87 Rr89c5kGVJ6w9G3GamVguq0UrXDcHxCly9niWMErwxdNuTvuX4gpieshJtglp6tO/JR1 s+GQ== X-Forwarded-Encrypted: i=1; AJvYcCUKzLCdMTa29Rby0twwQphI4sLg4Ea4kuyn6aAe0QER7gW2S3Nq+FZUHf1uu6//cMDjIGFtvU+zYIo9ffv9TpU=@vger.kernel.org, AJvYcCUUkMD6O9mYxI0wcoQwleCU4EJC6b3nAVMODCkqkYP/5QsnuwFBQzw/F9M+pv6MO6SnLwggzKTmM/JAewpqhNis@vger.kernel.org, AJvYcCVJiMGiZ/rrGKPG0motmJCIoIV2kmD5JCeuVMjr0darORnus64TBcEXkhyFy47pT5UyaEcZFjFQ8KBL@vger.kernel.org, AJvYcCWlAtZCUf134jTc7pl0M64Y7i8Rtp+rJyKlcxEfkkG5PjMEN+OaNPYhjGTMwKtIXVRz+mh189moVC2VAMRc@vger.kernel.org, AJvYcCWr61XENmqMT3xPt1mpvSFp/B2cKwJVsXySfb42oq6DUDrkgLKYst88m+74/Iv13G1w9F647TLm6XytsDI=@vger.kernel.org, AJvYcCWsvq46iUEXSO8BgXjecG/oniN/CTyWG6PxDACL8LMWK63ypmGv0naEnzRKgVD04KacR1SEd0ISkBDA@vger.kernel.org X-Gm-Message-State: AOJu0Yy95jyA9rXv1V0KHPPz5ah2cfbtfB5YJMZXm1s+8Dyljd57PHwj jcXOD58YQJyJyDJaKaxuNKci7MT3gUJewM4KK4IfsbTGKrKGyOAl X-Gm-Gg: ASbGncsKiMoqjrnEzezO23j1W3Kkp7Ab111vp4fgIL18KH5guP8GZCIkVd0KpFsDTdj tHO0zgcw1jtjR9l5b0NBoqXJYwEWBQGiOVEwfO9l4atMhQu33bBv5RhMebQlPJPWlLVzIvOpV9C rXjrxVFsrmbC/HlO4tabSvICDiOx6PAKvHABlE0pn1rCjvTo4XYR2ckVRvZ5/DGohkk84bVlZUy OuWFU+q23pCq0o2ovZSH55wIxpkf5WkJzSXdoa3zGrb5PwVwhGJ+BpuDeI88nj90tupBb5EL4Q4 1FxXU9Id70dXql5wO6CKgvJjCFRrvd3kirIRJS3l2/58tB3LOlNvBc1hwCbCRcq6x1xm2DFIPKu ZWp8= X-Google-Smtp-Source: AGHT+IHfZphSyX36SKO3UZqD1UaHk6k8ejeOInrUYOxCmtd4tI+8CzVGoaMRdfpsUegQX1AZ3G7mng== X-Received: by 2002:a05:620a:2b82:b0:7c0:a260:ec1b with SMTP id af79cd13be357-7c57c6ea8cdmr723710685a.25.1742041062791; Sat, 15 Mar 2025 05:17:42 -0700 (PDT) Received: from tamird-mac.local ([2600:4041:5be7:7c00:cd19:6a0f:e1a6:e800]) by smtp.gmail.com with ESMTPSA id af79cd13be357-7c573c9be48sm371885185a.60.2025.03.15.05.17.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 15 Mar 2025 05:17:42 -0700 (PDT) From: Tamir Duberstein Date: Sat, 15 Mar 2025 08:17:29 -0400 Subject: [PATCH v4 5/6] rust: enable `clippy::as_underscore` lint Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20250315-ptr-as-ptr-v4-5-b2d72c14dc26@gmail.com> References: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> In-Reply-To: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> To: Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Brendan Higgins , David Gow , Rae Moar , Bjorn Helgaas , Luis Chamberlain , Russ Weight , Rob Herring , Saravana Kannan Cc: linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com, linux-pci@vger.kernel.org, linux-block@vger.kernel.org, devicetree@vger.kernel.org, Tamir Duberstein X-Mailer: b4 0.15-dev In Rust 1.63.0, Clippy introduced the `as_underscore` lint [1]: > The conversion might include lossy conversion or a dangerous cast that > might go undetected due to the type being inferred. > > The lint is allowed by default as using `_` is less wordy than always > specifying the type. Always specifying the type is especially helpful in function call contexts where the inferred type may change at a distance. Specifying the type also allows Clippy to spot more cases of `useless_conversion`. The primary downside is the need to specify the type in trivial getters. There are 4 such functions: 3 have become slightly less ergonomic, 1 was revealed to be a `useless_conversion`. While this doesn't eliminate unchecked `as` conversions, it makes such conversions easier to scrutinize. It also has the slight benefit of removing a degree of freedom on which to bikeshed. Thus apply the changes and enable the lint -- no functional change intended. Link: https://rust-lang.github.io/rust-clippy/master/index.html#as_underscore [1] Reviewed-by: Benno Lossin Signed-off-by: Tamir Duberstein --- Makefile | 1 + rust/kernel/block/mq/operations.rs | 2 +- rust/kernel/block/mq/request.rs | 2 +- rust/kernel/device_id.rs | 2 +- rust/kernel/devres.rs | 15 ++++++++------- rust/kernel/error.rs | 2 +- rust/kernel/io.rs | 18 +++++++++--------- rust/kernel/miscdevice.rs | 2 +- rust/kernel/of.rs | 6 +++--- rust/kernel/pci.rs | 9 ++++++--- rust/kernel/str.rs | 8 ++++---- rust/kernel/workqueue.rs | 2 +- 12 files changed, 37 insertions(+), 32 deletions(-) diff --git a/Makefile b/Makefile index bb15b86182a3..2af40bfed9ce 100644 --- a/Makefile +++ b/Makefile @@ -478,6 +478,7 @@ export rust_common_flags := --edition=2021 \ -Wunreachable_pub \ -Wclippy::all \ -Wclippy::as_ptr_cast_mut \ + -Wclippy::as_underscore \ -Wclippy::ignored_unit_patterns \ -Wclippy::mut_mut \ -Wclippy::needless_bitwise_bool \ diff --git a/rust/kernel/block/mq/operations.rs b/rust/kernel/block/mq/operations.rs index 864ff379dc91..d18ef55490da 100644 --- a/rust/kernel/block/mq/operations.rs +++ b/rust/kernel/block/mq/operations.rs @@ -101,7 +101,7 @@ impl OperationsVTable { if let Err(e) = ret { e.to_blk_status() } else { - bindings::BLK_STS_OK as _ + bindings::BLK_STS_OK as u8 } } diff --git a/rust/kernel/block/mq/request.rs b/rust/kernel/block/mq/request.rs index 10c6d69be7f3..bcf2b73d9189 100644 --- a/rust/kernel/block/mq/request.rs +++ b/rust/kernel/block/mq/request.rs @@ -125,7 +125,7 @@ pub fn end_ok(this: ARef) -> Result<(), ARef> { // success of the call to `try_set_end` guarantees that there are no // `ARef`s pointing to this request. Therefore it is safe to hand it // back to the block layer. - unsafe { bindings::blk_mq_end_request(request_ptr, bindings::BLK_STS_OK as _) }; + unsafe { bindings::blk_mq_end_request(request_ptr, bindings::BLK_STS_OK as u8) }; Ok(()) } diff --git a/rust/kernel/device_id.rs b/rust/kernel/device_id.rs index e5859217a579..4063f09d76d9 100644 --- a/rust/kernel/device_id.rs +++ b/rust/kernel/device_id.rs @@ -82,7 +82,7 @@ impl IdArray { unsafe { raw_ids[i] .as_mut_ptr() - .byte_offset(T::DRIVER_DATA_OFFSET as _) + .byte_add(T::DRIVER_DATA_OFFSET) .cast::() .write(i); } diff --git a/rust/kernel/devres.rs b/rust/kernel/devres.rs index 598001157293..34571f992f0d 100644 --- a/rust/kernel/devres.rs +++ b/rust/kernel/devres.rs @@ -45,7 +45,7 @@ struct DevresInner { /// # Example /// /// ```no_run -/// # use kernel::{bindings, c_str, device::Device, devres::Devres, io::{Io, IoRaw}}; +/// # use kernel::{bindings, c_str, device::Device, devres::Devres, ffi::c_void, io::{Io, IoRaw}}; /// # use core::ops::Deref; /// /// // See also [`pci::Bar`] for a real example. @@ -59,19 +59,19 @@ struct DevresInner { /// unsafe fn new(paddr: usize) -> Result{ /// // SAFETY: By the safety requirements of this function [`paddr`, `paddr` + `SIZE`) is /// // valid for `ioremap`. -/// let addr = unsafe { bindings::ioremap(paddr as _, SIZE as _) }; +/// let addr = unsafe { bindings::ioremap(paddr as bindings::phys_addr_t, SIZE) }; /// if addr.is_null() { /// return Err(ENOMEM); /// } /// -/// Ok(IoMem(IoRaw::new(addr as _, SIZE)?)) +/// Ok(IoMem(IoRaw::new(addr as usize, SIZE)?)) /// } /// } /// /// impl Drop for IoMem { /// fn drop(&mut self) { /// // SAFETY: `self.0.addr()` is guaranteed to be properly mapped by `Self::new`. -/// unsafe { bindings::iounmap(self.0.addr() as _); }; +/// unsafe { bindings::iounmap(self.0.addr() as *mut c_void); }; /// } /// } /// @@ -115,8 +115,9 @@ fn new(dev: &Device, data: T, flags: Flags) -> Result>> { // SAFETY: `devm_add_action` guarantees to call `Self::devres_callback` once `dev` is // detached. - let ret = - unsafe { bindings::devm_add_action(dev.as_raw(), Some(inner.callback), data as _) }; + let ret = unsafe { + bindings::devm_add_action(dev.as_raw(), Some(inner.callback), data.cast_mut().cast()) + }; if ret != 0 { // SAFETY: We just created another reference to `inner` in order to pass it to @@ -130,7 +131,7 @@ fn new(dev: &Device, data: T, flags: Flags) -> Result>> { } fn as_ptr(&self) -> *const Self { - self as _ + self } fn remove_action(this: &Arc) { diff --git a/rust/kernel/error.rs b/rust/kernel/error.rs index 8654d52b0bb9..eb8fa52f08ba 100644 --- a/rust/kernel/error.rs +++ b/rust/kernel/error.rs @@ -152,7 +152,7 @@ pub(crate) fn to_blk_status(self) -> bindings::blk_status_t { /// Returns the error encoded as a pointer. pub fn to_ptr(self) -> *mut T { // SAFETY: `self.0` is a valid error due to its invariant. - unsafe { bindings::ERR_PTR(self.0.get() as _).cast() } + unsafe { bindings::ERR_PTR(self.0.get() as isize).cast() } } /// Returns a string representing the error, if one exists. diff --git a/rust/kernel/io.rs b/rust/kernel/io.rs index d4a73e52e3ee..9d2aadf40edf 100644 --- a/rust/kernel/io.rs +++ b/rust/kernel/io.rs @@ -5,7 +5,7 @@ //! C header: [`include/asm-generic/io.h`](srctree/include/asm-generic/io.h) use crate::error::{code::EINVAL, Result}; -use crate::{bindings, build_assert}; +use crate::{bindings, build_assert, ffi::c_void}; /// Raw representation of an MMIO region. /// @@ -56,7 +56,7 @@ pub fn maxsize(&self) -> usize { /// # Examples /// /// ```no_run -/// # use kernel::{bindings, io::{Io, IoRaw}}; +/// # use kernel::{bindings, ffi::c_void, io::{Io, IoRaw}}; /// # use core::ops::Deref; /// /// // See also [`pci::Bar`] for a real example. @@ -70,19 +70,19 @@ pub fn maxsize(&self) -> usize { /// unsafe fn new(paddr: usize) -> Result{ /// // SAFETY: By the safety requirements of this function [`paddr`, `paddr` + `SIZE`) is /// // valid for `ioremap`. -/// let addr = unsafe { bindings::ioremap(paddr as _, SIZE as _) }; +/// let addr = unsafe { bindings::ioremap(paddr as bindings::phys_addr_t, SIZE) }; /// if addr.is_null() { /// return Err(ENOMEM); /// } /// -/// Ok(IoMem(IoRaw::new(addr as _, SIZE)?)) +/// Ok(IoMem(IoRaw::new(addr as usize, SIZE)?)) /// } /// } /// /// impl Drop for IoMem { /// fn drop(&mut self) { /// // SAFETY: `self.0.addr()` is guaranteed to be properly mapped by `Self::new`. -/// unsafe { bindings::iounmap(self.0.addr() as _); }; +/// unsafe { bindings::iounmap(self.0.addr() as *mut c_void); }; /// } /// } /// @@ -119,7 +119,7 @@ pub fn $name(&self, offset: usize) -> $type_name { let addr = self.io_addr_assert::<$type_name>(offset); // SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(addr as _) } + unsafe { bindings::$name(addr as *const c_void) } } /// Read IO data from a given offset. @@ -131,7 +131,7 @@ pub fn $try_name(&self, offset: usize) -> Result<$type_name> { let addr = self.io_addr::<$type_name>(offset)?; // SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - Ok(unsafe { bindings::$name(addr as _) }) + Ok(unsafe { bindings::$name(addr as *const c_void) }) } }; } @@ -148,7 +148,7 @@ pub fn $name(&self, value: $type_name, offset: usize) { let addr = self.io_addr_assert::<$type_name>(offset); // SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(value, addr as _, ) } + unsafe { bindings::$name(value, addr as *mut c_void) } } /// Write IO data from a given offset. @@ -160,7 +160,7 @@ pub fn $try_name(&self, value: $type_name, offset: usize) -> Result { let addr = self.io_addr::<$type_name>(offset)?; // SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(value, addr as _) } + unsafe { bindings::$name(value, addr as *mut c_void) } Ok(()) } }; diff --git a/rust/kernel/miscdevice.rs b/rust/kernel/miscdevice.rs index e14433b2ab9d..2c66e926bffb 100644 --- a/rust/kernel/miscdevice.rs +++ b/rust/kernel/miscdevice.rs @@ -33,7 +33,7 @@ impl MiscDeviceOptions { pub const fn into_raw(self) -> bindings::miscdevice { // SAFETY: All zeros is valid for this C type. let mut result: bindings::miscdevice = unsafe { MaybeUninit::zeroed().assume_init() }; - result.minor = bindings::MISC_DYNAMIC_MINOR as _; + result.minor = bindings::MISC_DYNAMIC_MINOR as i32; result.name = self.name.as_char_ptr(); result.fops = create_vtable::(); result diff --git a/rust/kernel/of.rs b/rust/kernel/of.rs index 04f2d8ef29cb..40d1bd13682c 100644 --- a/rust/kernel/of.rs +++ b/rust/kernel/of.rs @@ -22,7 +22,7 @@ unsafe impl RawDeviceId for DeviceId { const DRIVER_DATA_OFFSET: usize = core::mem::offset_of!(bindings::of_device_id, data); fn index(&self) -> usize { - self.0.data as _ + self.0.data as usize } } @@ -34,10 +34,10 @@ pub const fn new(compatible: &'static CStr) -> Self { // SAFETY: FFI type is valid to be zero-initialized. let mut of: bindings::of_device_id = unsafe { core::mem::zeroed() }; - // TODO: Use `clone_from_slice` once the corresponding types do match. + // TODO: Use `copy_from_slice` once stabilized for `const`. let mut i = 0; while i < src.len() { - of.compatible[i] = src[i] as _; + of.compatible[i] = src[i]; i += 1; } diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs index 003c9aaafb24..a26f154ae1b9 100644 --- a/rust/kernel/pci.rs +++ b/rust/kernel/pci.rs @@ -166,7 +166,7 @@ unsafe impl RawDeviceId for DeviceId { const DRIVER_DATA_OFFSET: usize = core::mem::offset_of!(bindings::pci_device_id, driver_data); fn index(&self) -> usize { - self.0.driver_data as _ + self.0.driver_data } } @@ -201,7 +201,10 @@ macro_rules! pci_device_table { /// MODULE_PCI_TABLE, /// ::IdInfo, /// [ -/// (pci::DeviceId::from_id(bindings::PCI_VENDOR_ID_REDHAT, bindings::PCI_ANY_ID as _), ()) +/// ( +/// pci::DeviceId::from_id(bindings::PCI_VENDOR_ID_REDHAT, bindings::PCI_ANY_ID as u32), +/// (), +/// ) /// ] /// ); /// @@ -317,7 +320,7 @@ unsafe fn do_release(pdev: &Device, ioptr: usize, num: i32) { // `ioptr` is valid by the safety requirements. // `num` is valid by the safety requirements. unsafe { - bindings::pci_iounmap(pdev.as_raw(), ioptr as _); + bindings::pci_iounmap(pdev.as_raw(), ioptr as *mut kernel::ffi::c_void); bindings::pci_release_region(pdev.as_raw(), num); } } diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs index 6a1a982b946d..0b80a119d5f0 100644 --- a/rust/kernel/str.rs +++ b/rust/kernel/str.rs @@ -692,9 +692,9 @@ fn new() -> Self { pub(crate) unsafe fn from_ptrs(pos: *mut u8, end: *mut u8) -> Self { // INVARIANT: The safety requirements guarantee the type invariants. Self { - beg: pos as _, - pos: pos as _, - end: end as _, + beg: pos as usize, + pos: pos as usize, + end: end as usize, } } @@ -719,7 +719,7 @@ pub(crate) unsafe fn from_buffer(buf: *mut u8, len: usize) -> Self { /// /// N.B. It may point to invalid memory. pub(crate) fn pos(&self) -> *mut u8 { - self.pos as _ + self.pos as *mut u8 } /// Returns the number of bytes written to the formatter. diff --git a/rust/kernel/workqueue.rs b/rust/kernel/workqueue.rs index 8ff54105be3f..d03f3440cb5a 100644 --- a/rust/kernel/workqueue.rs +++ b/rust/kernel/workqueue.rs @@ -198,7 +198,7 @@ pub fn enqueue(&self, w: W) -> W::EnqueueOutput unsafe { w.__enqueue(move |work_ptr| { bindings::queue_work_on( - bindings::wq_misc_consts_WORK_CPU_UNBOUND as _, + bindings::wq_misc_consts_WORK_CPU_UNBOUND as i32, queue_ptr, work_ptr, ) From patchwork Sat Mar 15 12:17:30 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tamir Duberstein X-Patchwork-Id: 14017999 Received: from mail-qk1-f172.google.com (mail-qk1-f172.google.com [209.85.222.172]) (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 D04F11FCFF4; Sat, 15 Mar 2025 12:17:46 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.222.172 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041068; cv=none; b=jfmlGOOYVNU8jGUgjgljrJUgfCa9fycRBQbblsMWWqvBIeIQCQYsBdhvl4DiwXap1eM094CJBwRPiZlKEXXk5iWK8Tq6hJHu3c5Km7uzeZTvOg9xRXqhYdQ9iAzizxxrilm6fdRoknINV5h+3bNv6tBtNYqOghr4zHqzftuXzE0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1742041068; c=relaxed/simple; bh=yaR2RNMclDEe2oxhZxsOZJPcppVyJqpKplax5Sz5tfs=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=dzkeW3P+KCnbRXWcjpCKtA3YNfgDYzPIVwxU+W+J9aXdT1JQNM4Pce+3qF97vLOqBDhMe0Rg0xilH7c9dhqPhCQrGZDFCWpMR6xJvHf2JY/iYGWuzWf7Ls8UXMC72glL1KPD6Gi5Z7z4No/uB3Ecyagg9aceghUp4Aq1idoBPxY= 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=U/aqbEwt; arc=none smtp.client-ip=209.85.222.172 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="U/aqbEwt" Received: by mail-qk1-f172.google.com with SMTP id af79cd13be357-7c554d7dc2aso487107085a.3; Sat, 15 Mar 2025 05:17:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1742041066; x=1742645866; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=ZmDD127x0lAlRqKT+AD63PeS3MznGvR7OFvUC/Gs3yg=; b=U/aqbEwt6mPV3SnG26pqGsNod7tgV1jcZ2j00y1sIQpcSPMX+PVLYPrQEBpXw25y66 /+Sxuxr42kziVcHRNuzqhU0p5OKIkv27TEislEqkcOfpP83NvUjwI9EbtLSG1G7y0cnB NCFzu8xVOoBlwp61Efkl64p8f6pQ/6qEEn23qHpKSRuLviYc/Qsakof5q1tqaiGtIfFw zrk42dhS3pnQm5rzamfKhG4OGEDt+DEv4E38h8TnhMcSMlQaTvCDOXek2WLcRqh7hFEx XKgUjFph+/Laa2QyXr0wiXlz74kPzU3f6nmTmd8uvW1l1C6YRuo8O26dm7O2nYJ79QPZ xjOQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1742041066; x=1742645866; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ZmDD127x0lAlRqKT+AD63PeS3MznGvR7OFvUC/Gs3yg=; b=JQdlDjrzT7FW+5fGTCSZ6npKosG+617KtjloxZb0cyWdM4LBFV/P1IFLjHn8FtD1pk zw7V5w3Q/5HfYHkL8hJRScooymmij6sXSlLz5V3vn/IAu/UleiXyZ4MU9cgX1VVwyyjc bbVFhNK8a3kBVEUGb/24aqWvWY6MjavB4yWaAdC28RepOage0fT9ahMEOMbNPsPUUdBF cE/10wWPUaLo5iMPUTTvXpvjiRoI55LGd1HCKjzi0gOdf4E7/a+xGdn8PpxTD7mnvnv4 8scSUsf4znhAzHM6BP9a4WfSuuzO30rw89Bj+kOqBMk+sqi2WDZ9Ba2/wjpd3g7jMolN K9bA== X-Forwarded-Encrypted: i=1; AJvYcCUHmcC3AVQnIwRbpBLGPtpuBe8YJAPtmp1F9OvJ0pTytn4H82QFOGyDxfxNDRtse/Fy04HiCRO4TUi5@vger.kernel.org, AJvYcCUShUbeG/+flbpEQOtwkmupmB5m7Tp/JJQGeVQKTj7be0dCPrzR3nrDWFAzRWDe849CKqNSCgkl4kfuj78jQml/@vger.kernel.org, AJvYcCVs9ZNBdVdYVSnNYwWL7TpnEePRhIugsBMM8dDmLgxWxled8FtqUH3DCsLefPzVPBUXll7lz6GVwoGDQ5E=@vger.kernel.org, AJvYcCW+b+apAB4PHBW5H7/1FfaAIDdaG7t8KtGLNLeE32FClcY+TTR3thbDAPYyXkKX1k8jFN/wOYcRNI4X@vger.kernel.org, AJvYcCWQAUdsbOeusL9rLrskBuTNVxwKWcAQsic0c/R3gabrhZivYAqI8is+13KqmIo2yunB8jxdvyiLifC/1EFK@vger.kernel.org, AJvYcCXJEkV44/dPtogrpFVQIquKv3DKkhYAY1Q7nmaWcZqdFHXDe9KogONoQVVCduUGxqSz6tOwSyx1v3q/z+twYcs=@vger.kernel.org X-Gm-Message-State: AOJu0YwClYAuAZ6jvkEdgcLAXpzuaZX1VWmbVRHop/ZGPWcTzxfT50X2 YBOeIDsHjXnHcjVo0OrTGzL0lezaVmUh5FiPc46Ki6l5XkcK3uxCfTWM12WAtlE= X-Gm-Gg: ASbGnctLs8zUUE2EWtLvYUIDsgryTe2GTjWB03YdwBGvUdf8M69wPRhsDJSrrd0xJ00 rqWBY8nGz6R2kasyoboYvsbGa5vGrn3jPSPxbI+3ciIAkMkINURXAKWYr6ZTI0zvvly6LDo6wVD L61pMrepnF1ZVIleV//nqBzAg6Ql8pbfE7i/8aZ0XWfYXM2hyRmvng9pHSN2qMjtaePWzocljTF u9AleuN0KAp872gX8/7Uc6GdwHI2cvYwxYBexlRX4Bo6uSTa9gh1ypH8FBZKtzlAvxUKQkvwTb2 UknJYq9S6Eg01gTaVds8JSRZoZb9S7r8qRRdmCYr8yL6i6b+WObx8/cZjqXF3iQHu3bWBlU8wl9 9tAY= X-Google-Smtp-Source: AGHT+IGFO2XaGxZWtn54X3IHTN4qcmkX7qVjMghQaQsBMMpKHMkUbNwx3po9zDfLeAVOTZ7QeVglQQ== X-Received: by 2002:a05:620a:1a88:b0:7c5:6375:1459 with SMTP id af79cd13be357-7c57c91a1c4mr1061297585a.55.1742041065538; Sat, 15 Mar 2025 05:17:45 -0700 (PDT) Received: from tamird-mac.local ([2600:4041:5be7:7c00:cd19:6a0f:e1a6:e800]) by smtp.gmail.com with ESMTPSA id af79cd13be357-7c573c9be48sm371885185a.60.2025.03.15.05.17.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 15 Mar 2025 05:17:45 -0700 (PDT) From: Tamir Duberstein Date: Sat, 15 Mar 2025 08:17:30 -0400 Subject: [PATCH v4 6/6] rust: use strict provenance APIs Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20250315-ptr-as-ptr-v4-6-b2d72c14dc26@gmail.com> References: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> In-Reply-To: <20250315-ptr-as-ptr-v4-0-b2d72c14dc26@gmail.com> To: Masahiro Yamada , Nathan Chancellor , Nicolas Schier , Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Andreas Hindborg , Alice Ryhl , Trevor Gross , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Brendan Higgins , David Gow , Rae Moar , Bjorn Helgaas , Luis Chamberlain , Russ Weight , Rob Herring , Saravana Kannan Cc: linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, rust-for-linux@vger.kernel.org, linux-kselftest@vger.kernel.org, kunit-dev@googlegroups.com, linux-pci@vger.kernel.org, linux-block@vger.kernel.org, devicetree@vger.kernel.org, Tamir Duberstein X-Mailer: b4 0.15-dev Throughout the tree, use the strict provenance APIs stabilized in Rust 1.84.0[1]. Retain backwards-compatibility by introducing forwarding functions at the `kernel` crate root along with polyfills for rustc < 1.84.0. Use `#[allow(clippy::incompatible_msrv)]` to avoid warnings on rustc < 1.84.0 as our MSRV is 1.78.0. In the `kernel` crate, enable the strict provenance lints on rustc >= 1.84.0; do this in `lib.rs` rather than `Makefile` to avoid introducing compiler flags that are dependent on the rustc version in use. Link: https://blog.rust-lang.org/2025/01/09/Rust-1.84.0.html#strict-provenance-apis [1] Suggested-by: Benno Lossin Link: https://lore.kernel.org/all/D8EIXDMRXMJP.36TFCGWZBRS3Y@proton.me/ Signed-off-by: Tamir Duberstein --- init/Kconfig | 3 +++ rust/kernel/alloc.rs | 2 +- rust/kernel/devres.rs | 4 ++-- rust/kernel/io.rs | 14 +++++++------- rust/kernel/lib.rs | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++ rust/kernel/of.rs | 2 +- rust/kernel/pci.rs | 4 ++-- rust/kernel/str.rs | 16 ++++++---------- rust/kernel/uaccess.rs | 12 ++++++++---- 9 files changed, 82 insertions(+), 27 deletions(-) diff --git a/init/Kconfig b/init/Kconfig index d0d021b3fa3b..82e28d6f7c3f 100644 --- a/init/Kconfig +++ b/init/Kconfig @@ -132,6 +132,9 @@ config CC_HAS_COUNTED_BY config RUSTC_HAS_COERCE_POINTEE def_bool RUSTC_VERSION >= 108400 +config RUSTC_HAS_STABLE_STRICT_PROVENANCE + def_bool RUSTC_VERSION >= 108400 + config PAHOLE_VERSION int default $(shell,$(srctree)/scripts/pahole-version.sh $(PAHOLE)) diff --git a/rust/kernel/alloc.rs b/rust/kernel/alloc.rs index fc9c9c41cd79..a1d282e48249 100644 --- a/rust/kernel/alloc.rs +++ b/rust/kernel/alloc.rs @@ -217,7 +217,7 @@ unsafe fn free(ptr: NonNull, layout: Layout) { /// Returns a properly aligned dangling pointer from the given `layout`. pub(crate) fn dangling_from_layout(layout: Layout) -> NonNull { - let ptr = layout.align() as *mut u8; + let ptr = crate::without_provenance_mut(layout.align()); // SAFETY: `layout.align()` (and hence `ptr`) is guaranteed to be non-zero. unsafe { NonNull::new_unchecked(ptr) } diff --git a/rust/kernel/devres.rs b/rust/kernel/devres.rs index 34571f992f0d..e8232bb771b2 100644 --- a/rust/kernel/devres.rs +++ b/rust/kernel/devres.rs @@ -64,14 +64,14 @@ struct DevresInner { /// return Err(ENOMEM); /// } /// -/// Ok(IoMem(IoRaw::new(addr as usize, SIZE)?)) +/// Ok(IoMem(IoRaw::new(kernel::expose_provenance(addr), SIZE)?)) /// } /// } /// /// impl Drop for IoMem { /// fn drop(&mut self) { /// // SAFETY: `self.0.addr()` is guaranteed to be properly mapped by `Self::new`. -/// unsafe { bindings::iounmap(self.0.addr() as *mut c_void); }; +/// unsafe { bindings::iounmap(kernel::with_exposed_provenance_mut(self.0.addr())); }; /// } /// } /// diff --git a/rust/kernel/io.rs b/rust/kernel/io.rs index 9d2aadf40edf..0a018ad7478a 100644 --- a/rust/kernel/io.rs +++ b/rust/kernel/io.rs @@ -5,7 +5,7 @@ //! C header: [`include/asm-generic/io.h`](srctree/include/asm-generic/io.h) use crate::error::{code::EINVAL, Result}; -use crate::{bindings, build_assert, ffi::c_void}; +use crate::{bindings, build_assert}; /// Raw representation of an MMIO region. /// @@ -75,14 +75,14 @@ pub fn maxsize(&self) -> usize { /// return Err(ENOMEM); /// } /// -/// Ok(IoMem(IoRaw::new(addr as usize, SIZE)?)) +/// Ok(IoMem(IoRaw::new(kernel::expose_provenance(addr), SIZE)?)) /// } /// } /// /// impl Drop for IoMem { /// fn drop(&mut self) { /// // SAFETY: `self.0.addr()` is guaranteed to be properly mapped by `Self::new`. -/// unsafe { bindings::iounmap(self.0.addr() as *mut c_void); }; +/// unsafe { bindings::iounmap(kernel::with_exposed_provenance_mut(self.0.addr())); }; /// } /// } /// @@ -119,7 +119,7 @@ pub fn $name(&self, offset: usize) -> $type_name { let addr = self.io_addr_assert::<$type_name>(offset); // SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(addr as *const c_void) } + unsafe { bindings::$name(crate::with_exposed_provenance(addr)) } } /// Read IO data from a given offset. @@ -131,7 +131,7 @@ pub fn $try_name(&self, offset: usize) -> Result<$type_name> { let addr = self.io_addr::<$type_name>(offset)?; // SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - Ok(unsafe { bindings::$name(addr as *const c_void) }) + Ok(unsafe { bindings::$name(crate::with_exposed_provenance(addr)) }) } }; } @@ -148,7 +148,7 @@ pub fn $name(&self, value: $type_name, offset: usize) { let addr = self.io_addr_assert::<$type_name>(offset); // SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(value, addr as *mut c_void) } + unsafe { bindings::$name(value, crate::with_exposed_provenance_mut(addr)) } } /// Write IO data from a given offset. @@ -160,7 +160,7 @@ pub fn $try_name(&self, value: $type_name, offset: usize) -> Result { let addr = self.io_addr::<$type_name>(offset)?; // SAFETY: By the type invariant `addr` is a valid address for MMIO operations. - unsafe { bindings::$name(value, addr as *mut c_void) } + unsafe { bindings::$name(value, crate::with_exposed_provenance_mut(addr)) } Ok(()) } }; diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index 486715528587..84eb2602e79e 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -17,6 +17,9 @@ #![cfg_attr(not(CONFIG_RUSTC_HAS_COERCE_POINTEE), feature(coerce_unsized))] #![cfg_attr(not(CONFIG_RUSTC_HAS_COERCE_POINTEE), feature(dispatch_from_dyn))] #![cfg_attr(not(CONFIG_RUSTC_HAS_COERCE_POINTEE), feature(unsize))] +#![cfg_attr(CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE, feature(strict_provenance_lints))] +#![cfg_attr(CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE, deny(fuzzy_provenance_casts))] +#![cfg_attr(CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE, deny(lossy_provenance_casts))] #![feature(inline_const)] #![feature(lint_reasons)] // Stable in Rust 1.83 @@ -25,6 +28,55 @@ #![feature(const_ptr_write)] #![feature(const_refs_to_cell)] +#[cfg(CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE)] +#[allow(clippy::incompatible_msrv)] +mod strict_provenance { + #[doc(hidden)] + pub fn expose_provenance(addr: *const T) -> usize { + addr.expose_provenance() + } + + #[doc(hidden)] + pub fn without_provenance_mut(addr: usize) -> *mut T { + core::ptr::without_provenance_mut(addr) + } + + #[doc(hidden)] + pub fn with_exposed_provenance(addr: usize) -> *const T { + core::ptr::with_exposed_provenance(addr) + } + + #[doc(hidden)] + pub fn with_exposed_provenance_mut(addr: usize) -> *mut T { + core::ptr::with_exposed_provenance_mut(addr) + } +} + +#[cfg(not(CONFIG_RUSTC_HAS_STABLE_STRICT_PROVENANCE))] +mod strict_provenance { + #[doc(hidden)] + pub fn expose_provenance(addr: *const T) -> usize { + addr.cast::<()>() as usize + } + + #[doc(hidden)] + pub fn without_provenance_mut(addr: usize) -> *mut T { + addr as *mut T + } + + #[doc(hidden)] + pub fn with_exposed_provenance(addr: usize) -> *const T { + addr as *const T + } + + #[doc(hidden)] + pub fn with_exposed_provenance_mut(addr: usize) -> *mut T { + addr as *mut T + } +} + +pub use strict_provenance::*; + // Ensure conditional compilation based on the kernel configuration works; // otherwise we may silently break things like initcall handling. #[cfg(not(CONFIG_RUST))] diff --git a/rust/kernel/of.rs b/rust/kernel/of.rs index 40d1bd13682c..f9459694cbdc 100644 --- a/rust/kernel/of.rs +++ b/rust/kernel/of.rs @@ -22,7 +22,7 @@ unsafe impl RawDeviceId for DeviceId { const DRIVER_DATA_OFFSET: usize = core::mem::offset_of!(bindings::of_device_id, data); fn index(&self) -> usize { - self.0.data as usize + crate::expose_provenance(self.0.data) } } diff --git a/rust/kernel/pci.rs b/rust/kernel/pci.rs index a26f154ae1b9..87c9f67b3f0f 100644 --- a/rust/kernel/pci.rs +++ b/rust/kernel/pci.rs @@ -287,7 +287,7 @@ fn new(pdev: Device, num: u32, name: &CStr) -> Result { // `pdev` is valid by the invariants of `Device`. // `num` is checked for validity by a previous call to `Device::resource_len`. // `name` is always valid. - let ioptr: usize = unsafe { bindings::pci_iomap(pdev.as_raw(), num, 0) } as usize; + let ioptr = crate::expose_provenance(unsafe { bindings::pci_iomap(pdev.as_raw(), num, 0) }); if ioptr == 0 { // SAFETY: // `pdev` valid by the invariants of `Device`. @@ -320,7 +320,7 @@ unsafe fn do_release(pdev: &Device, ioptr: usize, num: i32) { // `ioptr` is valid by the safety requirements. // `num` is valid by the safety requirements. unsafe { - bindings::pci_iounmap(pdev.as_raw(), ioptr as *mut kernel::ffi::c_void); + bindings::pci_iounmap(pdev.as_raw(), crate::with_exposed_provenance_mut(ioptr)); bindings::pci_release_region(pdev.as_raw(), num); } } diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs index 0b80a119d5f0..6bc6357293e4 100644 --- a/rust/kernel/str.rs +++ b/rust/kernel/str.rs @@ -692,9 +692,9 @@ fn new() -> Self { pub(crate) unsafe fn from_ptrs(pos: *mut u8, end: *mut u8) -> Self { // INVARIANT: The safety requirements guarantee the type invariants. Self { - beg: pos as usize, - pos: pos as usize, - end: end as usize, + beg: crate::expose_provenance(pos), + pos: crate::expose_provenance(pos), + end: crate::expose_provenance(end), } } @@ -705,7 +705,7 @@ pub(crate) unsafe fn from_ptrs(pos: *mut u8, end: *mut u8) -> Self { /// The memory region starting at `buf` and extending for `len` bytes must be valid for writes /// for the lifetime of the returned [`RawFormatter`]. pub(crate) unsafe fn from_buffer(buf: *mut u8, len: usize) -> Self { - let pos = buf as usize; + let pos = crate::expose_provenance(buf); // INVARIANT: We ensure that `end` is never less then `buf`, and the safety requirements // guarantees that the memory region is valid for writes. Self { @@ -719,7 +719,7 @@ pub(crate) unsafe fn from_buffer(buf: *mut u8, len: usize) -> Self { /// /// N.B. It may point to invalid memory. pub(crate) fn pos(&self) -> *mut u8 { - self.pos as *mut u8 + crate::with_exposed_provenance_mut(self.pos) } /// Returns the number of bytes written to the formatter. @@ -741,11 +741,7 @@ fn write_str(&mut self, s: &str) -> fmt::Result { // SAFETY: If `len_to_copy` is non-zero, then we know `pos` has not gone past `end` // yet, so it is valid for write per the type invariants. unsafe { - core::ptr::copy_nonoverlapping( - s.as_bytes().as_ptr(), - self.pos as *mut u8, - len_to_copy, - ) + core::ptr::copy_nonoverlapping(s.as_bytes().as_ptr(), self.pos(), len_to_copy) }; } diff --git a/rust/kernel/uaccess.rs b/rust/kernel/uaccess.rs index 719b0a48ff55..96393bcf6bd7 100644 --- a/rust/kernel/uaccess.rs +++ b/rust/kernel/uaccess.rs @@ -226,7 +226,9 @@ pub fn read_raw(&mut self, out: &mut [MaybeUninit]) -> Result { } // SAFETY: `out_ptr` points into a mutable slice of length `len`, so we may write // that many bytes to it. - let res = unsafe { bindings::copy_from_user(out_ptr, self.ptr as *const c_void, len) }; + let res = unsafe { + bindings::copy_from_user(out_ptr, crate::with_exposed_provenance(self.ptr), len) + }; if res != 0 { return Err(EFAULT); } @@ -264,7 +266,7 @@ pub fn read(&mut self) -> Result { let res = unsafe { bindings::_copy_from_user( out.as_mut_ptr().cast::(), - self.ptr as *const c_void, + crate::with_exposed_provenance(self.ptr), len, ) }; @@ -330,7 +332,9 @@ pub fn write_slice(&mut self, data: &[u8]) -> Result { } // SAFETY: `data_ptr` points into an immutable slice of length `len`, so we may read // that many bytes from it. - let res = unsafe { bindings::copy_to_user(self.ptr as *mut c_void, data_ptr, len) }; + let res = unsafe { + bindings::copy_to_user(crate::with_exposed_provenance_mut(self.ptr), data_ptr, len) + }; if res != 0 { return Err(EFAULT); } @@ -357,7 +361,7 @@ pub fn write(&mut self, value: &T) -> Result { // is a compile-time constant. let res = unsafe { bindings::_copy_to_user( - self.ptr as *mut c_void, + crate::with_exposed_provenance_mut(self.ptr), (value as *const T).cast::(), len, )