From nobody Sun Sep 21 21:39:52 2025 Received: from mail-qv1-f51.google.com (mail-qv1-f51.google.com [209.85.219.51]) (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 462B72857EA; Wed, 13 Aug 2025 15:45:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.219.51 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755099917; cv=none; b=Zf7/eAjLAfAkcONCiezInAqiCUxUaZpERdyuXmYbapx0avUvfx7Y0pjPnrJIjQ7tBK0gqgpDUEWXI5TCiu2kILNjKzJgXjA10pGh6nb5CbfAQXxeG5rWn92Ws/nUGFn8jk8xUHi7AyJmyXpgbUVa36mi1o1RedtTHwOuqQIgmAE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755099917; c=relaxed/simple; bh=PTDvM2HBIQtiHRjiaQnIp9LPfNsXH8zj3ZtohuuvaLA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=ha3X2v7+4L8b1CwCtVX1wn5TKDe1/wpzvSc94f2phErTj8UjVVpip/vA68Ml7xs+ZZP5Iccq/9jnzbJVIjc3zPamreWp64pC2z0LUqSMRZsvlGeh3lu8GG3syoRjf5Xh1vgjIQReKUXS1zVaCYnFDuT0pR/KuMkbV1Td766Rm+w= 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=W1Zs/MAk; arc=none smtp.client-ip=209.85.219.51 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="W1Zs/MAk" Received: by mail-qv1-f51.google.com with SMTP id 6a1803df08f44-70a9f5e1c2aso439056d6.3; Wed, 13 Aug 2025 08:45:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1755099914; x=1755704714; 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=0y+gnC6bXE+JfrQZkTYH2GNP1c2kKpqC9hVlpupTTFc=; b=W1Zs/MAkYt1HYE54kta9tyqj1zo1xcFfqGGV6wdV3/87UWBe9HZp+M49VjZ0opJ/3k oLzNnBV9/IitYr1t5o8/5niS5jY+KJijjQT24FlME+JJkv6Ixx0RXD5OJn/tZzfanS82 faEcZ0e92rddsvCroLP23Os7lMKb+GDGyukH0bTOFzD9FYAB/Z3wrPuFmtDXXDnV5ddt yw59Q7MCI29TGdSlqcaSngf5Amq2SFpRFIQCDkhfnRXcA4ruqAtsDsA0JReooj8a6gf9 Hy5oNt+DwoU7Owrb4TIMpS0QyCDz3qoEQH6xWbmWcNigVbCzT7RxpGwnguyY0kcW4UjF ycfA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1755099914; x=1755704714; 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=0y+gnC6bXE+JfrQZkTYH2GNP1c2kKpqC9hVlpupTTFc=; b=dwEVh9VpR2S+lhNctyEI8YI4k2iA1cqNptyup6//QN+8W0B8VNjZjbI7WE9wBTNr32 fCGPvOPlHGoQffGSJnCeSd8Wt7tko3DnKMVkiaEh4rxbgoWdTwlehhUrwZyanMf4mlzs +ysGfv17Vgrw2EGWII7MmPD4WgeZi8N1SuXNzWWsfgKXfTZvp+J00760bt1VifT/fy6q G8MlEOZ81Pw46+TTl20QXX9npelGaWhXAk4nEq3qOaGmMkfoIb+P3DlbCEXV9On4KAaU bxlK2BJucCnnOY9gIJQz2/wPuB7yn8vUni0+VNRo55suPtKxcmxywxBfjNZmV5jdXJ0B So+A== X-Forwarded-Encrypted: i=1; AJvYcCVriGDFp+ds4Nll/0M9VWnThP5FDjkzh5RBmLuoRqKzOnk2VUof2SiIvkyV65w23JJuFNkBX0ECECimWD8B@vger.kernel.org, AJvYcCWrFujThb6MH2rCHaJhSyB1njBVccVpIqOEAhmNb1Ls+vR7MAWtpZcBH5XcNBDtLA2dbUqvk2nC1WPxvyOl@vger.kernel.org X-Gm-Message-State: AOJu0Yxcw/1pDU5BT15qiYtTavJv0RXVB3iBWSaJnMRt0X6k/v2PZMnv YTiMWJxcLC2LhXrxonzTJwkUOnaoHVLrAc1tAVica9IJfLCed9L/sWqr X-Gm-Gg: ASbGncv//vPKOwtemECdTOJFkWMZ5oefNHtJGlP7db5IifJxUmXNBQJL4rKz3sbkEMT Zl7lOouCzazXSzg6qfpxL2Vp4L75Cj82P8wBN/iZckH/zGH6RsMo7MS+FAf55eoZldu4j7aPKyz dS4gSIMWppM08jUaEEQybuFEonv4GqQT9zHQACS20M4qLSBsaV8oschTqqiT0RnFH0r0/yuUdNM 2fFof7ubhR61WoPMIBSXZ5JFLuw+0I2E4sYQmteHzblnfqgP7kpspI7G/SQ/wJVrNmHLou3TmWO BTGZwaXZfQfWb8SblVxLEDMPKxsXsAuZzYTRlDW0vqLNcpIe6P7ziLnmJF4gWhlzcLRQ8bACxOv B9wXVaIaxq4NJmqYGw6KgFw5LCdIsQKurw+hQtuIVb7Q/YO2q7ZMt8RRApIgO5KyqnPAwBCiAJY xdDqtgo7rXMdceU1T8p42K+8Udb7mOT3q3dw== X-Google-Smtp-Source: AGHT+IHtLspbw3Tqyywo/LjGQ4g7+P+EzXr8xJKhOKm/r+Oa+FAmGtFSkFP7kWNYQjC+LEzUuxX5Hg== X-Received: by 2002:a05:6214:2587:b0:6fa:c408:5a3b with SMTP id 6a1803df08f44-709e87eb75emr38852556d6.9.1755099913733; Wed, 13 Aug 2025 08:45:13 -0700 (PDT) Received: from 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa ([2600:4808:6353:5c00:d445:7694:2051:518c]) by smtp.gmail.com with ESMTPSA id 6a1803df08f44-7077ca3621asm194127396d6.33.2025.08.13.08.45.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Aug 2025 08:45:12 -0700 (PDT) From: Tamir Duberstein Date: Wed, 13 Aug 2025 11:45:05 -0400 Subject: [PATCH v15 1/4] rust: macros: reduce collections in `quote!` macro Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250813-cstr-core-v15-1-c732d9223f4e@gmail.com> References: <20250813-cstr-core-v15-0-c732d9223f4e@gmail.com> In-Reply-To: <20250813-cstr-core-v15-0-c732d9223f4e@gmail.com> 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 , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Luis Chamberlain , Russ Weight , Peter Zijlstra , Ingo Molnar , Will Deacon , Waiman Long , Nathan Chancellor , Nick Desaulniers , Bill Wendling , Justin Stitt , Christian Brauner , Alexander Viro , Jan Kara Cc: rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, llvm@lists.linux.dev, linux-fsdevel@vger.kernel.org, Tamir Duberstein X-Mailer: b4 0.15-dev X-Developer-Signature: v=1; a=openssh-sha256; t=1755099909; l=8730; i=tamird@gmail.com; h=from:subject:message-id; bh=PTDvM2HBIQtiHRjiaQnIp9LPfNsXH8zj3ZtohuuvaLA=; b=U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgtYz36g7iDMSkY5K7Ab51ksGX7hJgs MRt+XVZTrIzMVIAAAAGcGF0YXR0AAAAAAAAAAZzaGE1MTIAAABTAAAAC3NzaC1lZDI1NTE5AAAA QDmMTBy3KylRjaSxoOn6HVmt++mJSXkDOp3JVyI3SaRT41raCRvnlfJf1bMl3uR1+0uOFSYNuSO 2Pbl50BvO7AQ= X-Developer-Key: i=tamird@gmail.com; a=openssh; fpr=SHA256:264rPmnnrb+ERkS7DDS3tuwqcJss/zevJRzoylqMsbc Remove a handful of unncessary intermediate vectors and token streams; mainly the top-level stream can be directly extended with the notable exception of groups. Remove an unnecessary `#[allow(dead_code)]` added in commit dbd5058ba60c ("rust: make pin-init its own crate"). Acked-by: Greg Kroah-Hartman Reviewed-by: Alice Ryhl Acked-by: Danilo Krummrich Signed-off-by: Tamir Duberstein --- rust/macros/quote.rs | 104 ++++++++++++++++++++++++-----------------------= ---- 1 file changed, 49 insertions(+), 55 deletions(-) diff --git a/rust/macros/quote.rs b/rust/macros/quote.rs index 92cacc4067c9..acc140c18653 100644 --- a/rust/macros/quote.rs +++ b/rust/macros/quote.rs @@ -2,7 +2,6 @@ =20 use proc_macro::{TokenStream, TokenTree}; =20 -#[allow(dead_code)] pub(crate) trait ToTokens { fn to_tokens(&self, tokens: &mut TokenStream); } @@ -47,121 +46,116 @@ fn to_tokens(&self, tokens: &mut TokenStream) { /// `quote` crate but provides only just enough functionality needed by th= e current `macros` crate. macro_rules! quote_spanned { ($span:expr =3D> $($tt:tt)*) =3D> {{ - let mut tokens: ::std::vec::Vec<::proc_macro::TokenTree>; - #[allow(clippy::vec_init_then_push)] + let mut tokens =3D ::proc_macro::TokenStream::new(); { - tokens =3D ::std::vec::Vec::new(); let span =3D $span; quote_spanned!(@proc tokens span $($tt)*); } - ::proc_macro::TokenStream::from_iter(tokens) + tokens }}; (@proc $v:ident $span:ident) =3D> {}; (@proc $v:ident $span:ident #$id:ident $($tt:tt)*) =3D> { - let mut ts =3D ::proc_macro::TokenStream::new(); - $crate::quote::ToTokens::to_tokens(&$id, &mut ts); - $v.extend(ts); + $crate::quote::ToTokens::to_tokens(&$id, &mut $v); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident #(#$id:ident)* $($tt:tt)*) =3D> { for token in $id { - let mut ts =3D ::proc_macro::TokenStream::new(); - $crate::quote::ToTokens::to_tokens(&token, &mut ts); - $v.extend(ts); + $crate::quote::ToTokens::to_tokens(&token, &mut $v); } quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident ( $($inner:tt)* ) $($tt:tt)*) =3D> { #[allow(unused_mut)] - let mut tokens =3D ::std::vec::Vec::<::proc_macro::TokenTree>::new= (); + let mut tokens =3D ::proc_macro::TokenStream::new(); quote_spanned!(@proc tokens $span $($inner)*); - $v.push(::proc_macro::TokenTree::Group(::proc_macro::Group::new( + $v.extend([::proc_macro::TokenTree::Group(::proc_macro::Group::new( ::proc_macro::Delimiter::Parenthesis, - ::proc_macro::TokenStream::from_iter(tokens) - ))); + tokens, + ))]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident [ $($inner:tt)* ] $($tt:tt)*) =3D> { - let mut tokens =3D ::std::vec::Vec::new(); + let mut tokens =3D ::proc_macro::TokenStream::new(); quote_spanned!(@proc tokens $span $($inner)*); - $v.push(::proc_macro::TokenTree::Group(::proc_macro::Group::new( + $v.extend([::proc_macro::TokenTree::Group(::proc_macro::Group::new( ::proc_macro::Delimiter::Bracket, - ::proc_macro::TokenStream::from_iter(tokens) - ))); + tokens, + ))]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident { $($inner:tt)* } $($tt:tt)*) =3D> { - let mut tokens =3D ::std::vec::Vec::new(); + let mut tokens =3D ::proc_macro::TokenStream::new(); quote_spanned!(@proc tokens $span $($inner)*); - $v.push(::proc_macro::TokenTree::Group(::proc_macro::Group::new( + $v.extend([::proc_macro::TokenTree::Group(::proc_macro::Group::new( ::proc_macro::Delimiter::Brace, - ::proc_macro::TokenStream::from_iter(tokens) - ))); + tokens, + ))]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident :: $($tt:tt)*) =3D> { - $v.push(::proc_macro::TokenTree::Punct( - ::proc_macro::Punct::new(':', ::proc_macro::Spacing::Joint) - )); - $v.push(::proc_macro::TokenTree::Punct( - ::proc_macro::Punct::new(':', ::proc_macro::Spacing::Alone) - )); + $v.extend([::proc_macro::Spacing::Joint, ::proc_macro::Spacing::Al= one].map(|spacing| { + ::proc_macro::TokenTree::Punct(::proc_macro::Punct::new(':', s= pacing)) + })); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident : $($tt:tt)*) =3D> { - $v.push(::proc_macro::TokenTree::Punct( - ::proc_macro::Punct::new(':', ::proc_macro::Spacing::Alone) - )); + $v.extend([::proc_macro::TokenTree::Punct( + ::proc_macro::Punct::new(':', ::proc_macro::Spacing::Alone), + )]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident , $($tt:tt)*) =3D> { - $v.push(::proc_macro::TokenTree::Punct( - ::proc_macro::Punct::new(',', ::proc_macro::Spacing::Alone) - )); + $v.extend([::proc_macro::TokenTree::Punct( + ::proc_macro::Punct::new(',', ::proc_macro::Spacing::Alone), + )]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident @ $($tt:tt)*) =3D> { - $v.push(::proc_macro::TokenTree::Punct( - ::proc_macro::Punct::new('@', ::proc_macro::Spacing::Alone) - )); + $v.extend([::proc_macro::TokenTree::Punct( + ::proc_macro::Punct::new('@', ::proc_macro::Spacing::Alone), + )]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident ! $($tt:tt)*) =3D> { - $v.push(::proc_macro::TokenTree::Punct( - ::proc_macro::Punct::new('!', ::proc_macro::Spacing::Alone) - )); + $v.extend([::proc_macro::TokenTree::Punct( + ::proc_macro::Punct::new('!', ::proc_macro::Spacing::Alone), + )]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident ; $($tt:tt)*) =3D> { - $v.push(::proc_macro::TokenTree::Punct( - ::proc_macro::Punct::new(';', ::proc_macro::Spacing::Alone) - )); + $v.extend([::proc_macro::TokenTree::Punct( + ::proc_macro::Punct::new(';', ::proc_macro::Spacing::Alone), + )]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident + $($tt:tt)*) =3D> { - $v.push(::proc_macro::TokenTree::Punct( - ::proc_macro::Punct::new('+', ::proc_macro::Spacing::Alone) - )); + $v.extend([::proc_macro::TokenTree::Punct( + ::proc_macro::Punct::new('+', ::proc_macro::Spacing::Alone), + )]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident =3D $($tt:tt)*) =3D> { - $v.push(::proc_macro::TokenTree::Punct( - ::proc_macro::Punct::new('=3D', ::proc_macro::Spacing::Alo= ne) - )); + $v.extend([::proc_macro::TokenTree::Punct( + ::proc_macro::Punct::new('=3D', ::proc_macro::Spacing::Alone), + )]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident # $($tt:tt)*) =3D> { - $v.push(::proc_macro::TokenTree::Punct( - ::proc_macro::Punct::new('#', ::proc_macro::Spacing::Alone) - )); + $v.extend([::proc_macro::TokenTree::Punct( + ::proc_macro::Punct::new('#', ::proc_macro::Spacing::Alone), + )]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident _ $($tt:tt)*) =3D> { - $v.push(::proc_macro::TokenTree::Ident(::proc_macro::Ident::new("_= ", $span))); + $v.extend([::proc_macro::TokenTree::Ident( + ::proc_macro::Ident::new("_", $span), + )]); quote_spanned!(@proc $v $span $($tt)*); }; (@proc $v:ident $span:ident $id:ident $($tt:tt)*) =3D> { - $v.push(::proc_macro::TokenTree::Ident(::proc_macro::Ident::new(st= ringify!($id), $span))); + $v.extend([::proc_macro::TokenTree::Ident( + ::proc_macro::Ident::new(stringify!($id), $span), + )]); quote_spanned!(@proc $v $span $($tt)*); }; } --=20 2.50.1 From nobody Sun Sep 21 21:39:52 2025 Received: from mail-qv1-f47.google.com (mail-qv1-f47.google.com [209.85.219.47]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 197B22882D7; Wed, 13 Aug 2025 15:45:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.219.47 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755099920; cv=none; b=q5oEtFIe8+MmPSfMz+bM9d11vsEq/lypY+3YHgXaNyG+CgWHKpSfpUnTcmIRICjv+cnGFs1GP6f4Xxc3FsN6VdojxJZFkSj/KMlB7yWowVsMVBIVEBBKArDKbl4nTcIblSz9TXUOKkORbfKJLruj53vfINPpMYSUFLb0npN99CM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755099920; c=relaxed/simple; bh=LjcCbHMUoV3TltewN0HsJRdLdRD1ekMI3/F3iYl7gdo=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=bahdf4pSukb7vPp1oSORaRpa4cI2FUMWuw6DeT0wJN9NmFYIqRWCekxnanJj8Emb7LS3/JaYrDr0YZK39EcMG5DfZJfL2HnSaowWgGKVwXXDB/AnNsuTq2HcnAOVvWAFZmB9Y934xsI5I1S3dsvM9VBdPS3knsi675rR/9N0Bfk= 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=VHFZStIw; arc=none smtp.client-ip=209.85.219.47 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="VHFZStIw" Received: by mail-qv1-f47.google.com with SMTP id 6a1803df08f44-70a88db0416so812186d6.0; Wed, 13 Aug 2025 08:45:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1755099916; x=1755704716; 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=QjwWWlaiSxuBLrutmj24/qoTYXM0TidVt0sz9ukj7i4=; b=VHFZStIwJ4OZMmgAfTzH0Her9ZCFg0PztOm+vxDk2MM11DHkrmfb28Ia/xCuUbXXJJ mKnf2ZYGD0FYj8z4btZK7tSnFiOxDIWQLzm+uZklqi5F7pl3SYSG5t3wgvMwkTB4b7FN SvrJ5RuSsB6HGJ22E6ZMohEmyOPeSUkoqi79LEEA6zmKeo5dm7epA3QakZSRGtXSS9q6 eIKRrXfQX0oghJ2ZdSLnOGObBhvO8zRUZJP5uV7jAtqP9PqVlgdlJtfjBwKdJmik0nWD F55TySfIIRo5+hTU02FIN77k3jnHvBjXUwWBBbbR7Bid5Xv5EgDP5QDfb9gzg/AZnubu zJKQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1755099916; x=1755704716; 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=QjwWWlaiSxuBLrutmj24/qoTYXM0TidVt0sz9ukj7i4=; b=TJU5Z1TnGOQz/OAeLaOp3+WrTWxu/BD8j9esiHMOVe1ST9PpzdIqt8GFCSAY3PhuoV urIUceaSGt/riWam4zJJYEQbgMgtN+vh+n2jXBNIcT43gFLwvEN9udufkZm3s91jVVhy jHQx79811wHA0N+JpIhw+VsUwGM6vL23huElwwHNvHOpgtak9PcytK7gTXIUgKkh0HvG rWI+UNJ1/Q74/4b15g6QF284EUUO1pqewub+1gsY3Se0wqjXx3S5KCV5ViNvftQMZ43z sVBX6m9HqTaNam98wrMY+ahQdv4YNVNOfckt2dEohQkvVH2ql1a3U2nQ+NBRfTNWiZi4 /tCg== X-Forwarded-Encrypted: i=1; AJvYcCUWJtR8TR5XwmZjaffBCFI8FO7+wAq+fPvjataovrla3x1CxZDB1YKYfPk3iKwRetQ5A+5LdMIBc01FIyMD@vger.kernel.org, AJvYcCW72D+PqlSigIttMaBH13gFXTCS+WLDy8tAI/NXOJWy6PQ21I/wnxztc/MWvv1mW1f/IRrfdTn8yGZFFMPN@vger.kernel.org X-Gm-Message-State: AOJu0Yz/vW+M+suMFUBP970oxU/kyF+/VOAmuMet2oOCc5f02l3WUMWe kczeOadqLe4aDt/pVYZHl5ZOYjcUKfiUhtnoeYL5PwpIv4eYDQjxhELw X-Gm-Gg: ASbGncsXOt/K9SE0nWiUO3C0yoYhINWM9XWtBt4VIkAcrg8q4Wuo0f6+UAHuU1x3+N5 tH2EvGGrlhsDkNa9Dn8sVdAxac+umr5w9jq74tLtGbORoZkQEp6NXKCeFA2wQpnC9iQCuibh8VC QexbN9bfV2lnyapQLjqTAvv3AQGdXV74JiWARlV5Ro005h3/YofLmF15KFsEm9cwuGxWjLT9BO9 ToMGxt0IasNj5OtjIAzdgPhfz2ecAP21kd1CVuXr61SUiFngDPHatUNDhGFeWdWfNbYN6UPit91 unfQo5sZrEz7B3pxvw0ITHhH3U7bEPGV3aakbhP7tdYTrhYcWB7HdZ0yCTtVZYEl8T7VHNtkxWY 5WhMdo767aliGmTmnjA62tvu1ZbJP9sjsQs8MAZWb4zr5zVurIM5iDZxcDVVwMtqOJBhciaDs0m 2m4LSGQV/rXDmciNl1CZBNkoaRh4eFkPpZQw== X-Google-Smtp-Source: AGHT+IFo4WArkDrsCUK9t4B6jzw/aFmRiBWP2yrzAvS/zR6ACJmHYfP/VTbhopmm+LesuhQ0Tnd1Gg== X-Received: by 2002:a05:6214:c62:b0:707:5d90:5e92 with SMTP id 6a1803df08f44-709e8969c59mr52606936d6.23.1755099915764; Wed, 13 Aug 2025 08:45:15 -0700 (PDT) Received: from 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa ([2600:4808:6353:5c00:d445:7694:2051:518c]) by smtp.gmail.com with ESMTPSA id 6a1803df08f44-7077ca3621asm194127396d6.33.2025.08.13.08.45.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Aug 2025 08:45:15 -0700 (PDT) From: Tamir Duberstein Date: Wed, 13 Aug 2025 11:45:06 -0400 Subject: [PATCH v15 2/4] samples: rust: platform: remove trailing commas Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250813-cstr-core-v15-2-c732d9223f4e@gmail.com> References: <20250813-cstr-core-v15-0-c732d9223f4e@gmail.com> In-Reply-To: <20250813-cstr-core-v15-0-c732d9223f4e@gmail.com> 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 , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Luis Chamberlain , Russ Weight , Peter Zijlstra , Ingo Molnar , Will Deacon , Waiman Long , Nathan Chancellor , Nick Desaulniers , Bill Wendling , Justin Stitt , Christian Brauner , Alexander Viro , Jan Kara Cc: rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, llvm@lists.linux.dev, linux-fsdevel@vger.kernel.org, Tamir Duberstein X-Mailer: b4 0.15-dev X-Developer-Signature: v=1; a=openssh-sha256; t=1755099909; l=1557; i=tamird@gmail.com; h=from:subject:message-id; bh=LjcCbHMUoV3TltewN0HsJRdLdRD1ekMI3/F3iYl7gdo=; b=U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgtYz36g7iDMSkY5K7Ab51ksGX7hJgs MRt+XVZTrIzMVIAAAAGcGF0YXR0AAAAAAAAAAZzaGE1MTIAAABTAAAAC3NzaC1lZDI1NTE5AAAA QO8mU4ZtUTy2WAWiBRXSVqeaRSmzF3VR/fQVAMv11BPx81UtsH2jPBVrPoOeIFZIGeK9uRKIC2T lF7fw1KgGMA0= X-Developer-Key: i=tamird@gmail.com; a=openssh; fpr=SHA256:264rPmnnrb+ERkS7DDS3tuwqcJss/zevJRzoylqMsbc This prepares for the next commit in which we introduce a custom formatting macro; that macro doesn't handle these spurious commas, so just remove them. Signed-off-by: Tamir Duberstein --- samples/rust/rust_driver_platform.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/samples/rust/rust_driver_platform.rs b/samples/rust/rust_drive= r_platform.rs index 69ed55b7b0fa..ad08df0d73f0 100644 --- a/samples/rust/rust_driver_platform.rs +++ b/samples/rust/rust_driver_platform.rs @@ -146,7 +146,7 @@ fn properties_parse(dev: &device::Device) -> Result { =20 let name =3D c_str!("test,u32-optional-prop"); let prop =3D fwnode.property_read::(name).or(0x12); - dev_info!(dev, "'{name}'=3D'{prop:#x}' (default =3D 0x12)\n",); + dev_info!(dev, "'{name}'=3D'{prop:#x}' (default =3D 0x12)\n"); =20 // A missing required property will print an error. Discard the er= ror to // prevent properties_parse from failing in that case. @@ -161,7 +161,7 @@ fn properties_parse(dev: &device::Device) -> Result { let prop: [i16; 4] =3D fwnode.property_read(name).required_by(dev)= ?; dev_info!(dev, "'{name}'=3D'{prop:?}'\n"); let len =3D fwnode.property_count_elem::(name)?; - dev_info!(dev, "'{name}' length is {len}\n",); + dev_info!(dev, "'{name}' length is {len}\n"); =20 let name =3D c_str!("test,i16-array"); let prop: KVec =3D fwnode.property_read_array_vec(name, 4)?.r= equired_by(dev)?; --=20 2.50.1 From nobody Sun Sep 21 21:39:52 2025 Received: from mail-qv1-f46.google.com (mail-qv1-f46.google.com [209.85.219.46]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 740D02D4B5C; Wed, 13 Aug 2025 15:45:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.219.46 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755099922; cv=none; b=eG4/N5lcOZmxyC4cbdtCg9PKAzW9T4KsrW9CXGT5vmjcH2P6sbbbKfyL8fjHZqiF00I6ykFXiyzqPqh9n/4gONkcXHM07CZi+oOHqEarEKXsYggoNWmAYlNG+cme7VNsEc8Yxs4Srfq34x2Y2PkATcKresKTtfqE/0rbrXwmedE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755099922; c=relaxed/simple; bh=vFj4Kj4gdGAAiuKpEiaISxfj2jMvIiARTXTrnu7UdP4=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=LyF1GLsXC1W2+ByMs79W3aYOTYi5TEoY4N2Tcb78VIb0c+PYZ7080Jaw5Y9yky7gvw13CvgSpyJXXPDSb8AkdBytFaTwOX5OLo4c/FxJYea7hX2og87mtsXpFEBqNpB06LiOTqGvOWCtbcMTrZYg0PJyE/BiXqx2pEJKhD2BP7U= 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=AtpJEtIt; arc=none smtp.client-ip=209.85.219.46 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="AtpJEtIt" Received: by mail-qv1-f46.google.com with SMTP id 6a1803df08f44-70a88ddc0aeso678616d6.0; Wed, 13 Aug 2025 08:45:19 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1755099918; x=1755704718; 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=pqHnTh9G0udZLShhBAncZJ6bJA8ChUukQPXANGnkywc=; b=AtpJEtItdmLEQsTAsSyHmSsmMB5eNjzdedN39k64oFm+7kKbd8qIaySCKw2ORz44NQ 1rCJxB1JX08RwzEzHZZcqyzV17LZbt5yGRKFbBaFCGHoBaa0MpOg1fuaVriRF87ZDylt 9bzy6Xlk9r/Pe3RPdsCXXyvdVaKLUR+lLh/J+R8gyG2xZ2brIXJWFizlvpVHddzHFEeh GFS/JcxEvB5J+yp6a26z11K8Oo9qqlYnxcAoVMTTmu3qnfRYlvKH+hPP1OJ5tHsW0HU3 GBZto3lB/zjEy2QPsriwWApPKKakiHxxBNZn5cHrcU6V6WNUe0z8pMImSnKVW76fkW+o JExg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1755099918; x=1755704718; 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=pqHnTh9G0udZLShhBAncZJ6bJA8ChUukQPXANGnkywc=; b=Wgqq+bAYtZ+pgbw1IoZnGZNH3Dei69OcHyXFPlrFj7++4xgKERAo40v19MxneDhLsr bCrh/3VlcNjJEzDwcqIK12mFJ4PWgsSaB9UL6fJn63loTxzUIdEpKgvS2/2pnYaGPPrT NQlOSLOLe38usGcB2wbAcKLs6r0TCbrCkM1hZ6G9BcUK0NwKnq06LwCQdBMacM1vUtZM bTnrHEdnKEJbf+uf/Wrm51myzubbTNzMLhDEzdI5VlrROQL7tAzIwBmYi8GzTnx/APbf f51ygr0obkGXeYrXWheHfMiB1gc0YYuhIFPVpYZFdTUjjVaAX5Iw71ZQ1abzAgYnHp5v ygUQ== X-Forwarded-Encrypted: i=1; AJvYcCUpwk1gcGxiwnWIFRGoIHGNtftadwcUOhx5bjY1jtdpyOcWZrWFsLojbCY5TwA7XPYni9iQ0zB8Itq0qvRj@vger.kernel.org, AJvYcCUsisyzr7M4ZCa/mkEEbFTG4lqDkc0MIDzckqWdkNnZSe0BWwJ9/k/2UZJw6XNl6vM5kMWN2d1oy94wH/pe@vger.kernel.org X-Gm-Message-State: AOJu0YwxV7CErl4G5tUNC4l5CBkMoS4jD/9apEpEzXuZX1j5Zm1bima5 7PXa+8KxYFD9eqKK7e+NPn4Y+wVN/uwF3Qr/qJJV6M/2viC5Yl80zVEc9XgrO3YMweg= X-Gm-Gg: ASbGnctTmtfL1b2MHs6eZllb0qozbRkeSRCrmVj85RJU1BX8DIJE3Fo+Sg1MedLUZ8n RE6XpHK2K6JhE7YhxYHokC+VbBgYsVe9Kclu8WZZ6/YitLamp79u+QjyNirU9P1AKpzmTgtBsgv 5Ga9L15jD7kvARgiQRH10a1TajpZZdllB8QPODNxmoO/yILzk7leg1Kl+vpQCyuPqkurXJRCKju MzulP0DlUGFCwIUXK9Mxh4pW88ExD8Z+oYbEx0ujIAO2dPjZF2RCy2lUVBeTYm4s7lolEXKeDl7 b/DCvfqHnlDWDB71rbgvWzmm6jle6Ywoa3iW76rs4xQN8E6rFfWxBDxD/giLaIlc3GLRv50cZjD ny3yfgDirLhwAwH7oT9kr+72sE8LilJHPnZoO1v/kZdRmGjuzZU4QstaU6W5ube34/wgnX8Ns7M boJfRjCv5Go+jQTzXu9i0CJAIjrGfwuWSE+h6IoScMheFb X-Google-Smtp-Source: AGHT+IGm8Ovwlui4lrOs7HJtodxwpEoGiNYokhIOdK7RMa9PMfandCB6/lRFZX3GGMHhMCbUjfUDGQ== X-Received: by 2002:a05:6214:29c4:b0:709:e54d:3dc0 with SMTP id 6a1803df08f44-709e87c908bmr40933786d6.5.1755099917987; Wed, 13 Aug 2025 08:45:17 -0700 (PDT) Received: from 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa ([2600:4808:6353:5c00:d445:7694:2051:518c]) by smtp.gmail.com with ESMTPSA id 6a1803df08f44-7077ca3621asm194127396d6.33.2025.08.13.08.45.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Aug 2025 08:45:17 -0700 (PDT) From: Tamir Duberstein Date: Wed, 13 Aug 2025 11:45:07 -0400 Subject: [PATCH v15 3/4] rust: support formatting of foreign types Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250813-cstr-core-v15-3-c732d9223f4e@gmail.com> References: <20250813-cstr-core-v15-0-c732d9223f4e@gmail.com> In-Reply-To: <20250813-cstr-core-v15-0-c732d9223f4e@gmail.com> 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 , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Luis Chamberlain , Russ Weight , Peter Zijlstra , Ingo Molnar , Will Deacon , Waiman Long , Nathan Chancellor , Nick Desaulniers , Bill Wendling , Justin Stitt , Christian Brauner , Alexander Viro , Jan Kara Cc: rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, llvm@lists.linux.dev, linux-fsdevel@vger.kernel.org, Tamir Duberstein X-Mailer: b4 0.15-dev X-Developer-Signature: v=1; a=openssh-sha256; t=1755099909; l=11126; i=tamird@gmail.com; h=from:subject:message-id; bh=vFj4Kj4gdGAAiuKpEiaISxfj2jMvIiARTXTrnu7UdP4=; b=U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgtYz36g7iDMSkY5K7Ab51ksGX7hJgs MRt+XVZTrIzMVIAAAAGcGF0YXR0AAAAAAAAAAZzaGE1MTIAAABTAAAAC3NzaC1lZDI1NTE5AAAA QKpgt5aRwi6YFy5wQKpEFG8BX8+4R+4BW6w0uvb3Kqq4Q8MCq+37Obt804zO0u0HtNkI5n2GLai y8xVK3zzKLgE= X-Developer-Key: i=tamird@gmail.com; a=openssh; fpr=SHA256:264rPmnnrb+ERkS7DDS3tuwqcJss/zevJRzoylqMsbc Introduce a `fmt!` macro which wraps all arguments in `kernel::fmt::Adapter` and a `kernel::fmt::Display` trait. This enables formatting of foreign types (like `core::ffi::CStr`) that do not implement `core::fmt::Display` due to concerns around lossy conversions which do not apply in the kernel. Suggested-by: Alice Ryhl Link: https://rust-for-linux.zulipchat.com/#narrow/channel/288089-General/t= opic/Custom.20formatting/with/516476467 Acked-by: Greg Kroah-Hartman Reviewed-by: Alice Ryhl Acked-by: Danilo Krummrich Reviewed-by: Benno Lossin Signed-off-by: Tamir Duberstein --- rust/kernel/fmt.rs | 87 +++++++++++++++++++++++++++++++++++++++++++++- rust/kernel/prelude.rs | 3 +- rust/macros/fmt.rs | 94 ++++++++++++++++++++++++++++++++++++++++++++++= ++++ rust/macros/lib.rs | 19 ++++++++++ rust/macros/quote.rs | 7 ++++ 5 files changed, 207 insertions(+), 3 deletions(-) diff --git a/rust/kernel/fmt.rs b/rust/kernel/fmt.rs index 0306e8388968..84d634201d90 100644 --- a/rust/kernel/fmt.rs +++ b/rust/kernel/fmt.rs @@ -4,4 +4,89 @@ //! //! This module is intended to be used in place of `core::fmt` in kernel c= ode. =20 -pub use core::fmt::{Arguments, Debug, Display, Error, Formatter, Result, W= rite}; +pub use core::fmt::{Arguments, Debug, Error, Formatter, Result, Write}; + +/// Internal adapter used to route allow implementations of formatting tra= its for foreign types. +/// +/// It is inserted automatically by the [`fmt!`] macro and is not meant to= be used directly. +/// +/// [`fmt!`]: crate::prelude::fmt! +#[doc(hidden)] +pub struct Adapter(pub T); + +macro_rules! impl_fmt_adapter_forward { + ($($trait:ident),* $(,)?) =3D> { + $( + impl $trait for Adapter { + fn fmt(&self, f: &mut Formatter<'_>) -> Result { + let Self(t) =3D self; + $trait::fmt(t, f) + } + } + )* + }; +} + +use core::fmt::{Binary, LowerExp, LowerHex, Octal, Pointer, UpperExp, Uppe= rHex}; +impl_fmt_adapter_forward!(Debug, LowerHex, UpperHex, Octal, Binary, Pointe= r, LowerExp, UpperExp); + +/// A copy of [`core::fmt::Display`] that allows us to implement it for fo= reign types. +/// +/// Types should implement this trait rather than [`core::fmt::Display`]. = Together with the +/// [`Adapter`] type and [`fmt!`] macro, it allows for formatting foreign = types (e.g. types from +/// core) which do not implement [`core::fmt::Display`] directly. +/// +/// [`fmt!`]: crate::prelude::fmt! +pub trait Display { + /// Same as [`core::fmt::Display::fmt`]. + fn fmt(&self, f: &mut Formatter<'_>) -> Result; +} + +impl Display for &T { + fn fmt(&self, f: &mut Formatter<'_>) -> Result { + Display::fmt(*self, f) + } +} + +impl core::fmt::Display for Adapter<&T> { + fn fmt(&self, f: &mut Formatter<'_>) -> Result { + let Self(t) =3D self; + Display::fmt(t, f) + } +} + +macro_rules! impl_display_forward { + ($( + $( { $($generics:tt)* } )? $ty:ty $( { where $($where:tt)* } )? + ),* $(,)?) =3D> { + $( + impl$($($generics)*)? Display for $ty $(where $($where)*)? { + fn fmt(&self, f: &mut Formatter<'_>) -> Result { + core::fmt::Display::fmt(self, f) + } + } + )* + }; +} + +impl_display_forward!( + bool, + char, + core::panic::PanicInfo<'_>, + Arguments<'_>, + i128, + i16, + i32, + i64, + i8, + isize, + str, + u128, + u16, + u32, + u64, + u8, + usize, + {} crate::sync::Arc {where crate::sync::Arc: core::fm= t::Display}, + {} crate::sync::UniqueArc {where crate::sync::UniqueArc<= T>: core::fmt::Display}, +); diff --git a/rust/kernel/prelude.rs b/rust/kernel/prelude.rs index 25fe97aafd02..f009f198f593 100644 --- a/rust/kernel/prelude.rs +++ b/rust/kernel/prelude.rs @@ -22,7 +22,7 @@ pub use crate::alloc::{flags::*, Box, KBox, KVBox, KVVec, KVec, VBox, VVec= , Vec}; =20 #[doc(no_inline)] -pub use macros::{export, kunit_tests, module, vtable}; +pub use macros::{export, fmt, kunit_tests, module, vtable}; =20 pub use pin_init::{init, pin_data, pin_init, pinned_drop, InPlaceWrite, In= it, PinInit, Zeroable}; =20 @@ -33,7 +33,6 @@ pub use super::dbg; pub use super::{dev_alert, dev_crit, dev_dbg, dev_emerg, dev_err, dev_info= , dev_notice, dev_warn}; pub use super::{pr_alert, pr_crit, pr_debug, pr_emerg, pr_err, pr_info, pr= _notice, pr_warn}; -pub use core::format_args as fmt; =20 pub use super::{try_init, try_pin_init}; =20 diff --git a/rust/macros/fmt.rs b/rust/macros/fmt.rs new file mode 100644 index 000000000000..2f4b9f6e2211 --- /dev/null +++ b/rust/macros/fmt.rs @@ -0,0 +1,94 @@ +// SPDX-License-Identifier: GPL-2.0 + +use proc_macro::{Ident, TokenStream, TokenTree}; +use std::collections::BTreeSet; + +/// Please see [`crate::fmt`] for documentation. +pub(crate) fn fmt(input: TokenStream) -> TokenStream { + let mut input =3D input.into_iter(); + + let first_opt =3D input.next(); + let first_owned_str; + let mut names =3D BTreeSet::new(); + let first_span =3D { + let Some((mut first_str, first_span)) =3D (match first_opt.as_ref(= ) { + Some(TokenTree::Literal(first_lit)) =3D> { + first_owned_str =3D first_lit.to_string(); + Some(first_owned_str.as_str()).and_then(|first| { + let first =3D first.strip_prefix('"')?; + let first =3D first.strip_suffix('"')?; + Some((first, first_lit.span())) + }) + } + _ =3D> None, + }) else { + return first_opt.into_iter().chain(input).collect(); + }; + + // Parse `identifier`s from the format string. + // + // See https://doc.rust-lang.org/std/fmt/index.html#syntax. + while let Some((_, rest)) =3D first_str.split_once('{') { + first_str =3D rest; + if let Some(rest) =3D first_str.strip_prefix('{') { + first_str =3D rest; + continue; + } + if let Some((name, rest)) =3D first_str.split_once('}') { + first_str =3D rest; + let name =3D name.split_once(':').map_or(name, |(name, _)|= name); + if !name.is_empty() && !name.chars().all(|c| c.is_ascii_di= git()) { + names.insert(name); + } + } + } + first_span + }; + + let adapter =3D quote_spanned!(first_span =3D> ::kernel::fmt::Adapter); + + let mut args =3D TokenStream::from_iter(first_opt); + { + let mut flush =3D |args: &mut TokenStream, current: &mut TokenStre= am| { + let current =3D std::mem::take(current); + if !current.is_empty() { + let (lhs, rhs) =3D (|| { + let mut current =3D current.into_iter(); + let mut acc =3D TokenStream::new(); + while let Some(tt) =3D current.next() { + // Split on `=3D` only once to handle cases like `= a =3D b =3D c`. + if matches!(&tt, TokenTree::Punct(p) if p.as_char(= ) =3D=3D '=3D') { + names.remove(acc.to_string().as_str()); + // Include the `=3D` itself to keep the handli= ng below uniform. + acc.extend([tt]); + return (Some(acc), current.collect::()); + } + acc.extend([tt]); + } + (None, acc) + })(); + args.extend(quote_spanned!(first_span =3D> #lhs #adapter(&= #rhs))); + } + }; + + let mut current =3D TokenStream::new(); + for tt in input { + match &tt { + TokenTree::Punct(p) if p.as_char() =3D=3D ',' =3D> { + flush(&mut args, &mut current); + &mut args + } + _ =3D> &mut current, + } + .extend([tt]); + } + flush(&mut args, &mut current); + } + + for name in names { + let name =3D Ident::new(name, first_span); + args.extend(quote_spanned!(first_span =3D> , #name =3D #adapter(&#= name))); + } + + quote_spanned!(first_span =3D> ::core::format_args!(#args)) +} diff --git a/rust/macros/lib.rs b/rust/macros/lib.rs index fa847cf3a9b5..793f712dbf7c 100644 --- a/rust/macros/lib.rs +++ b/rust/macros/lib.rs @@ -15,6 +15,7 @@ mod quote; mod concat_idents; mod export; +mod fmt; mod helpers; mod kunit; mod module; @@ -201,6 +202,24 @@ pub fn export(attr: TokenStream, ts: TokenStream) -> T= okenStream { export::export(attr, ts) } =20 +/// Like [`core::format_args!`], but automatically wraps arguments in [`ke= rnel::fmt::Adapter`]. +/// +/// This macro allows generating `fmt::Arguments` while ensuring that each= argument is wrapped with +/// `::kernel::fmt::Adapter`, which customizes formatting behavior for ker= nel logging. +/// +/// Named arguments used in the format string (e.g. `{foo}`) are detected = and resolved from local +/// bindings. All positional and named arguments are automatically wrapped. +/// +/// This macro is an implementation detail of other kernel logging macros = like [`pr_info!`] and +/// should not typically be used directly. +/// +/// [`kernel::fmt::Adapter`]: ../kernel/fmt/struct.Adapter.html +/// [`pr_info!`]: ../kernel/macro.pr_info.html +#[proc_macro] +pub fn fmt(input: TokenStream) -> TokenStream { + fmt::fmt(input) +} + /// Concatenate two identifiers. /// /// This is useful in macros that need to declare or reference items with = names diff --git a/rust/macros/quote.rs b/rust/macros/quote.rs index acc140c18653..ddfc21577539 100644 --- a/rust/macros/quote.rs +++ b/rust/macros/quote.rs @@ -48,6 +48,7 @@ macro_rules! quote_spanned { ($span:expr =3D> $($tt:tt)*) =3D> {{ let mut tokens =3D ::proc_macro::TokenStream::new(); { + #[allow(unused_variables)] let span =3D $span; quote_spanned!(@proc tokens span $($tt)*); } @@ -146,6 +147,12 @@ macro_rules! quote_spanned { )]); quote_spanned!(@proc $v $span $($tt)*); }; + (@proc $v:ident $span:ident & $($tt:tt)*) =3D> { + $v.extend([::proc_macro::TokenTree::Punct( + ::proc_macro::Punct::new('&', ::proc_macro::Spacing::Alone), + )]); + quote_spanned!(@proc $v $span $($tt)*); + }; (@proc $v:ident $span:ident _ $($tt:tt)*) =3D> { $v.extend([::proc_macro::TokenTree::Ident( ::proc_macro::Ident::new("_", $span), --=20 2.50.1 From nobody Sun Sep 21 21:39:52 2025 Received: from mail-qv1-f43.google.com (mail-qv1-f43.google.com [209.85.219.43]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id DA4742E54DA; Wed, 13 Aug 2025 15:45:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.219.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755099924; cv=none; b=K3PYGQEnbNekccRZXQPpaV1cF5CR2Fwvb3zKHmkpzKvo8aId8YcZGeUiHncQzwhYoqke48/8+lGqDGcvfdBfKKX/L9KFSLYnMw3l9XQimfygZ8M05+aAQu9nOeByzqezI06QgbCheWMQEL+LHyrLyi0Icd3zRuP9CWGR6Hu388Y= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755099924; c=relaxed/simple; bh=qfS0kfQECB19+Ypx6xseAbkoiYllqnFbGMOxOFYL0bY=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=SbsAWC7bmgQ0lcWbymItII3jOQV6RLUew6o2h+nd522aM+eFGtEmbYc216esPiH5lBw1A/NdJGS0gZipWV715/bF7GBoWznDI/t0lZwjn1cwsWkcpfoOX00NCSj+b6ulRNG6c1SetEFsTYQDMCjH/ceXfTN0UEV1D49DqAZXYnQ= 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=KlkC/w42; arc=none smtp.client-ip=209.85.219.43 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="KlkC/w42" Received: by mail-qv1-f43.google.com with SMTP id 6a1803df08f44-70a88dcb665so666986d6.0; Wed, 13 Aug 2025 08:45:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1755099921; x=1755704721; 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=ixdAhMC6SFQwUTuQzdGA/YXfwtXyNL0hC9cNjok7Fbw=; b=KlkC/w42r09xF0RNpU0QK537pey+gzTD7PMgW5EI17trKRQQDKWI79A6cDIVkd8aFQ 1H7MtCLbVM3gDAqM0T30I7Rz2NylsTwKPXhCcBkvr2mjBgqQNSMX9j+Hrb3cItn/3ukw Hn6L79RyZMN2/Pr+xDFs2rt8yjgblZwzLO1bYzOVny3+sThSpwA0QR3SmUGJgGhmf3pV 8gppoP2o6bLnhJF0/0TYOHkSE9WJlQX0Sj5XPrOZ37cxd5QjhBDhV5dL2Pmr74ZOh1Xf 0ARtmZYwuZ2/uO0teyrlQHY8dpGqv0a8u18BYIoyauiO1Aj/d2G89ZHPpk9QqujYaJ0v +WqQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1755099921; x=1755704721; 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=ixdAhMC6SFQwUTuQzdGA/YXfwtXyNL0hC9cNjok7Fbw=; b=vn3uQb7pyPZVXNj5VsZq2fROK8q11/DrRfNp3kuRVU7dhVkt2v/OdGbL7MWkbg2rDO kAo62f6/Jm3kaamMGKVTGxllspDaLNDJPtjUHsZEehlb8d0cpxbrf3TyPsewH5P7Dw/5 jIvrsYNi0dcrJ8niSqtIqRv/1GzV/B7VK1zZrdK1S54qjtNYoDNICwmFwyLM6nmbWX2y A2eK8Z9icOWygGTZ8IviseG5oOt0hJROMQqh1EHjEIKtXRO8TwlWyP0GU8xmF4ahp2x/ 8ryAPkus4G0/1ITtkQlXoe7Pz6fSONqdban8NIdPckHArb+JId/HX2oymR8rv8hoq6fo K5uw== X-Forwarded-Encrypted: i=1; AJvYcCXe++dK1UdJPATbudigZDCPn857M1CIEawKWaipQmdvqv/pJL8/XxOyWAKJPwD8dgeQv4LfkaWCB20yHUTL@vger.kernel.org, AJvYcCXztiduVsTnW1vZ3H8lRn6TLMa4MHhSViL4fa3xrUOIrXucwPs38VQMxw6NJAuFGGtXXG65iQ1lIJq8DC8d@vger.kernel.org X-Gm-Message-State: AOJu0Yw+7Fk4DolZpEeu5jnkTwTopV/7tMhWbz+jqXRt2zl8wlhC87vG 8n4XaveVIwDZ/vmYT6JhOvDOZ68FLIfoFbLWDCksliglChUovhea0ku4 X-Gm-Gg: ASbGnctPS9pVJcFyUnH2P6sXekFlOMoWL99iuC0+0NbdVYX3UsHSnMISa/3QyCPFcWh KVeKt1ou+Pq0ooXAlmNvRbIdk03jJZbt+QffSoWvHogVEeyh98ADPkJtBt1T5TyUIQfUZTXGkWJ x34cZCsutssHEVIBuP5qdQJvm+Vf4xy0CBe9xf4Tnthd59Ov58sXEdnCr/684+p/6XdSylNx5qF jNJp0uXqPsisD2UdcUQLi7JiYcmbDKADkUDwysiQLIU04D9pvl9uxjlJvbwpo/Ek6KQ97KHxmFB iYONMFGntGtrN5XoLttfDRHdVhymxllRCXP+rPQWxq+UnAbI1OVkwNtj4l0O9p6ffkaKKICFEKg +kQbocZv511DY509owt88n238UqkAVHs8JRtVTeRDm3j8ZU85fxEROnVCdTs5Xt0OiCPRv+qq1J unqGs703dN08JRNaWZdOP0ptf6bExRV5zJIPQRhFYa/xOH X-Google-Smtp-Source: AGHT+IG7RdAPuUz9wXTr6NCNF9AvoGenPeMPTlDCf69su8SMYZ4tMYdI9xvNZk67HW8uu5kqC/pOpg== X-Received: by 2002:a05:6214:2c04:b0:709:ee07:daae with SMTP id 6a1803df08f44-709ee07db70mr32202876d6.34.1755099920154; Wed, 13 Aug 2025 08:45:20 -0700 (PDT) Received: from 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa ([2600:4808:6353:5c00:d445:7694:2051:518c]) by smtp.gmail.com with ESMTPSA id 6a1803df08f44-7077ca3621asm194127396d6.33.2025.08.13.08.45.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 13 Aug 2025 08:45:19 -0700 (PDT) From: Tamir Duberstein Date: Wed, 13 Aug 2025 11:45:08 -0400 Subject: [PATCH v15 4/4] rust: replace `CStr` with `core::ffi::CStr` Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20250813-cstr-core-v15-4-c732d9223f4e@gmail.com> References: <20250813-cstr-core-v15-0-c732d9223f4e@gmail.com> In-Reply-To: <20250813-cstr-core-v15-0-c732d9223f4e@gmail.com> 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 , Danilo Krummrich , Greg Kroah-Hartman , "Rafael J. Wysocki" , Luis Chamberlain , Russ Weight , Peter Zijlstra , Ingo Molnar , Will Deacon , Waiman Long , Nathan Chancellor , Nick Desaulniers , Bill Wendling , Justin Stitt , Christian Brauner , Alexander Viro , Jan Kara Cc: rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, llvm@lists.linux.dev, linux-fsdevel@vger.kernel.org, Tamir Duberstein X-Mailer: b4 0.15-dev X-Developer-Signature: v=1; a=openssh-sha256; t=1755099909; l=25735; i=tamird@gmail.com; h=from:subject:message-id; bh=qfS0kfQECB19+Ypx6xseAbkoiYllqnFbGMOxOFYL0bY=; b=U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgtYz36g7iDMSkY5K7Ab51ksGX7hJgs MRt+XVZTrIzMVIAAAAGcGF0YXR0AAAAAAAAAAZzaGE1MTIAAABTAAAAC3NzaC1lZDI1NTE5AAAA QO5GKlZAZobe7o2QjKC+3NAGdYCuBzfduPpo00C/O5fJH7vlk2RJ/SctKCdc8+FojishFjyfQiG YoXc6K+t3ewY= X-Developer-Key: i=tamird@gmail.com; a=openssh; fpr=SHA256:264rPmnnrb+ERkS7DDS3tuwqcJss/zevJRzoylqMsbc `kernel::ffi::CStr` was introduced in commit d126d2380131 ("rust: str: add `CStr` type") in November 2022 as an upstreaming of earlier work that was done in May 2021[0]. That earlier work, having predated the inclusion of `CStr` in `core`, largely duplicated the implementation of `std::ffi::CStr`. `std::ffi::CStr` was moved to `core::ffi::CStr` in Rust 1.64 in September 2022. Hence replace `kernel::str::CStr` with `core::ffi::CStr` to reduce our custom code footprint, and retain needed custom functionality through an extension trait. Add `CStr` to `ffi` and the kernel prelude. Link: https://github.com/Rust-for-Linux/linux/commit/faa3cbcca03d0dec8f8e43= f1d8d5c0860d98a23f [0] Acked-by: Greg Kroah-Hartman Reviewed-by: Alice Ryhl Acked-by: Danilo Krummrich Reviewed-by: Benno Lossin Signed-off-by: Tamir Duberstein --- rust/ffi.rs | 2 + rust/kernel/device.rs | 1 + rust/kernel/error.rs | 2 + rust/kernel/firmware.rs | 9 +- rust/kernel/prelude.rs | 4 +- rust/kernel/seq_file.rs | 2 +- rust/kernel/str.rs | 395 +++++++++---------------------------= ---- rust/kernel/sync/condvar.rs | 2 +- rust/kernel/sync/lock.rs | 2 +- rust/kernel/sync/lock/global.rs | 2 +- 10 files changed, 109 insertions(+), 312 deletions(-) diff --git a/rust/ffi.rs b/rust/ffi.rs index d60aad792af4..f961e9728f59 100644 --- a/rust/ffi.rs +++ b/rust/ffi.rs @@ -46,3 +46,5 @@ macro_rules! alias { } =20 pub use core::ffi::c_void; + +pub use core::ffi::CStr; diff --git a/rust/kernel/device.rs b/rust/kernel/device.rs index 65306e77d97d..449776474044 100644 --- a/rust/kernel/device.rs +++ b/rust/kernel/device.rs @@ -12,6 +12,7 @@ =20 #[cfg(CONFIG_PRINTK)] use crate::c_str; +use crate::str::CStrExt as _; =20 pub mod property; =20 diff --git a/rust/kernel/error.rs b/rust/kernel/error.rs index a41de293dcd1..266947c59322 100644 --- a/rust/kernel/error.rs +++ b/rust/kernel/error.rs @@ -165,6 +165,8 @@ pub fn name(&self) -> Option<&'static CStr> { if ptr.is_null() { None } else { + use crate::str::CStrExt as _; + // SAFETY: The string returned by `errname` is static and `NUL= `-terminated. Some(unsafe { CStr::from_char_ptr(ptr) }) } diff --git a/rust/kernel/firmware.rs b/rust/kernel/firmware.rs index 94e6bb88b903..376e7e77453f 100644 --- a/rust/kernel/firmware.rs +++ b/rust/kernel/firmware.rs @@ -4,7 +4,14 @@ //! //! C header: [`include/linux/firmware.h`](srctree/include/linux/firmware.= h) =20 -use crate::{bindings, device::Device, error::Error, error::Result, ffi, st= r::CStr}; +use crate::{ + bindings, + device::Device, + error::Error, + error::Result, + ffi, + str::{CStr, CStrExt as _}, +}; use core::ptr::NonNull; =20 /// # Invariants diff --git a/rust/kernel/prelude.rs b/rust/kernel/prelude.rs index f009f198f593..3f286f90cd07 100644 --- a/rust/kernel/prelude.rs +++ b/rust/kernel/prelude.rs @@ -16,7 +16,7 @@ =20 pub use ::ffi::{ c_char, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, = c_ulong, c_ulonglong, - c_ushort, c_void, + c_ushort, c_void, CStr, }; =20 pub use crate::alloc::{flags::*, Box, KBox, KVBox, KVVec, KVec, VBox, VVec= , Vec}; @@ -40,7 +40,7 @@ =20 pub use super::error::{code::*, Error, Result}; =20 -pub use super::{str::CStr, ThisModule}; +pub use super::{str::CStrExt as _, ThisModule}; =20 pub use super::init::InPlaceInit; =20 diff --git a/rust/kernel/seq_file.rs b/rust/kernel/seq_file.rs index 59fbfc2473f8..855e533813a6 100644 --- a/rust/kernel/seq_file.rs +++ b/rust/kernel/seq_file.rs @@ -4,7 +4,7 @@ //! //! C header: [`include/linux/seq_file.h`](srctree/include/linux/seq_file.= h) =20 -use crate::{bindings, c_str, fmt, types::NotThreadSafe, types::Opaque}; +use crate::{bindings, c_str, fmt, str::CStrExt as _, types::NotThreadSafe,= types::Opaque}; =20 /// A utility for generating the contents of a seq file. #[repr(transparent)] diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs index 6c892550c0ba..624386cb07be 100644 --- a/rust/kernel/str.rs +++ b/rust/kernel/str.rs @@ -4,10 +4,12 @@ =20 use crate::alloc::{flags::*, AllocError, KVec}; use crate::fmt::{self, Write}; -use core::ops::{self, Deref, DerefMut, Index}; +use core::ops::{Deref, DerefMut, Index}; =20 use crate::prelude::*; =20 +pub use crate::prelude::CStr; + /// Byte string without UTF-8 validity guarantee. #[repr(transparent)] pub struct BStr([u8]); @@ -181,58 +183,17 @@ macro_rules! b_str { // - error[E0379]: functions in trait impls cannot be declared const #[inline] pub const fn as_char_ptr_in_const_context(c_str: &CStr) -> *const c_char { - c_str.0.as_ptr() + c_str.as_ptr().cast() } =20 -/// Possible errors when using conversion functions in [`CStr`]. -#[derive(Debug, Clone, Copy)] -pub enum CStrConvertError { - /// Supplied bytes contain an interior `NUL`. - InteriorNul, - - /// Supplied bytes are not terminated by `NUL`. - NotNulTerminated, -} +mod private { + pub trait Sealed {} =20 -impl From for Error { - #[inline] - fn from(_: CStrConvertError) -> Error { - EINVAL - } + impl Sealed for super::CStr {} } =20 -/// A string that is guaranteed to have exactly one `NUL` byte, which is a= t the -/// end. -/// -/// Used for interoperability with kernel APIs that take C strings. -#[repr(transparent)] -pub struct CStr([u8]); - -impl CStr { - /// Returns the length of this string excluding `NUL`. - #[inline] - pub const fn len(&self) -> usize { - self.len_with_nul() - 1 - } - - /// Returns the length of this string with `NUL`. - #[inline] - pub const fn len_with_nul(&self) -> usize { - if self.0.is_empty() { - // SAFETY: This is one of the invariant of `CStr`. - // We add a `unreachable_unchecked` here to hint the optimizer= that - // the value returned from this function is non-zero. - unsafe { core::hint::unreachable_unchecked() }; - } - self.0.len() - } - - /// Returns `true` if the string only includes `NUL`. - #[inline] - pub const fn is_empty(&self) -> bool { - self.len() =3D=3D 0 - } - +/// Extensions to [`CStr`]. +pub trait CStrExt: private::Sealed { /// Wraps a raw C string pointer. /// /// # Safety @@ -240,54 +201,9 @@ pub const fn is_empty(&self) -> bool { /// `ptr` must be a valid pointer to a `NUL`-terminated C string, and = it must /// last at least `'a`. When `CStr` is alive, the memory pointed by `p= tr` /// must not be mutated. - #[inline] - pub unsafe fn from_char_ptr<'a>(ptr: *const c_char) -> &'a Self { - // SAFETY: The safety precondition guarantees `ptr` is a valid poi= nter - // to a `NUL`-terminated C string. - let len =3D unsafe { bindings::strlen(ptr) } + 1; - // SAFETY: Lifetime guaranteed by the safety precondition. - let bytes =3D unsafe { core::slice::from_raw_parts(ptr.cast(), len= ) }; - // SAFETY: As `len` is returned by `strlen`, `bytes` does not cont= ain 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) } - } - - /// Creates a [`CStr`] from a `[u8]`. - /// - /// The provided slice must be `NUL`-terminated, does not contain any - /// interior `NUL` bytes. - pub const fn from_bytes_with_nul(bytes: &[u8]) -> Result<&Self, CStrCo= nvertError> { - if bytes.is_empty() { - return Err(CStrConvertError::NotNulTerminated); - } - if bytes[bytes.len() - 1] !=3D 0 { - return Err(CStrConvertError::NotNulTerminated); - } - let mut i =3D 0; - // `i + 1 < bytes.len()` allows LLVM to optimize away bounds check= ing, - // while it couldn't optimize away bounds checks for `i < bytes.le= n() - 1`. - while i + 1 < bytes.len() { - if bytes[i] =3D=3D 0 { - return Err(CStrConvertError::InteriorNul); - } - i +=3D 1; - } - // SAFETY: We just checked that all properties hold. - Ok(unsafe { Self::from_bytes_with_nul_unchecked(bytes) }) - } - - /// Creates a [`CStr`] from a `[u8]` without performing any additional - /// checks. - /// - /// # Safety - /// - /// `bytes` *must* end with a `NUL` byte, and should only have a single - /// `NUL` byte (or the string will be truncated). - #[inline] - pub const unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CS= tr { - // SAFETY: Properties of `bytes` guaranteed by the safety precondi= tion. - unsafe { core::mem::transmute(bytes) } - } + // This function exists to paper over the fact that `CStr::from_ptr` t= akes a `*const + // core::ffi::c_char` rather than a `*const crate::ffi::c_char`. + unsafe fn from_char_ptr<'a>(ptr: *const c_char) -> &'a Self; =20 /// Creates a mutable [`CStr`] from a `[u8]` without performing any /// additional checks. @@ -296,99 +212,16 @@ pub const fn from_bytes_with_nul(bytes: &[u8]) -> Res= ult<&Self, CStrConvertError /// /// `bytes` *must* end with a `NUL` byte, and should only have a single /// `NUL` byte (or the string will be truncated). - #[inline] - pub unsafe fn from_bytes_with_nul_unchecked_mut(bytes: &mut [u8]) -> &= mut CStr { - // SAFETY: Properties of `bytes` guaranteed by the safety precondi= tion. - unsafe { &mut *(core::ptr::from_mut(bytes) as *mut CStr) } - } + unsafe fn from_bytes_with_nul_unchecked_mut(bytes: &mut [u8]) -> &mut = Self; =20 /// Returns a C pointer to the string. - /// - /// Using this function in a const context is deprecated in favor of - /// [`as_char_ptr_in_const_context`] in preparation for replacing `CSt= r` with `core::ffi::CStr` - /// which does not have this method. - #[inline] - pub const fn as_char_ptr(&self) -> *const c_char { - as_char_ptr_in_const_context(self) - } - - /// Convert the string to a byte slice without the trailing `NUL` byte. - #[inline] - pub fn to_bytes(&self) -> &[u8] { - &self.0[..self.len()] - } - - /// Convert the string to a byte slice without the trailing `NUL` byte. - /// - /// This function is deprecated in favor of [`Self::to_bytes`] in prep= aration for replacing - /// `CStr` with `core::ffi::CStr` which does not have this method. - #[inline] - pub fn as_bytes(&self) -> &[u8] { - self.to_bytes() - } - - /// Convert the string to a byte slice containing the trailing `NUL` b= yte. - #[inline] - pub const fn to_bytes_with_nul(&self) -> &[u8] { - &self.0 - } - - /// Convert the string to a byte slice containing the trailing `NUL` b= yte. - /// - /// This function is deprecated in favor of [`Self::to_bytes_with_nul`= ] in preparation for - /// replacing `CStr` with `core::ffi::CStr` which does not have this m= ethod. - #[inline] - pub const fn as_bytes_with_nul(&self) -> &[u8] { - self.to_bytes_with_nul() - } - - /// Yields a [`&str`] slice if the [`CStr`] contains valid UTF-8. - /// - /// If the contents of the [`CStr`] are valid UTF-8 data, this - /// function will return the corresponding [`&str`] slice. Otherwise, - /// it will return an error with details of where UTF-8 validation fai= led. - /// - /// # Examples - /// - /// ``` - /// # use kernel::str::CStr; - /// let cstr =3D CStr::from_bytes_with_nul(b"foo\0")?; - /// assert_eq!(cstr.to_str(), Ok("foo")); - /// # Ok::<(), kernel::error::Error>(()) - /// ``` - #[inline] - pub fn to_str(&self) -> Result<&str, core::str::Utf8Error> { - core::str::from_utf8(self.as_bytes()) - } - - /// Unsafely convert this [`CStr`] into a [`&str`], without checking f= or - /// valid UTF-8. - /// - /// # Safety - /// - /// The contents must be valid UTF-8. - /// - /// # Examples - /// - /// ``` - /// # use kernel::c_str; - /// # use kernel::str::CStr; - /// let bar =3D c_str!("=E3=83=84"); - /// // SAFETY: String literals are guaranteed to be valid UTF-8 - /// // by the Rust compiler. - /// assert_eq!(unsafe { bar.as_str_unchecked() }, "=E3=83=84"); - /// ``` - #[inline] - pub unsafe fn as_str_unchecked(&self) -> &str { - // SAFETY: TODO. - unsafe { core::str::from_utf8_unchecked(self.as_bytes()) } - } + // This function exists to paper over the fact that `CStr::as_ptr` ret= urns a `*const + // core::ffi::c_char` rather than a `*const crate::ffi::c_char`. + fn as_char_ptr(&self) -> *const c_char; =20 /// Convert this [`CStr`] into a [`CString`] by allocating memory and /// copying over the string data. - pub fn to_cstring(&self) -> Result { - CString::try_from(self) - } + fn to_cstring(&self) -> Result; =20 /// Converts this [`CStr`] to its ASCII lower case equivalent in-place. /// @@ -399,11 +232,7 @@ pub fn to_cstring(&self) -> Result { /// [`to_ascii_lowercase()`]. /// /// [`to_ascii_lowercase()`]: #method.to_ascii_lowercase - pub fn make_ascii_lowercase(&mut self) { - // INVARIANT: This doesn't introduce or remove NUL bytes in the C - // string. - self.0.make_ascii_lowercase(); - } + fn make_ascii_lowercase(&mut self); =20 /// Converts this [`CStr`] to its ASCII upper case equivalent in-place. /// @@ -414,11 +243,7 @@ pub fn make_ascii_lowercase(&mut self) { /// [`to_ascii_uppercase()`]. /// /// [`to_ascii_uppercase()`]: #method.to_ascii_uppercase - pub fn make_ascii_uppercase(&mut self) { - // INVARIANT: This doesn't introduce or remove NUL bytes in the C - // string. - self.0.make_ascii_uppercase(); - } + fn make_ascii_uppercase(&mut self); =20 /// Returns a copy of this [`CString`] where each character is mapped = to its /// ASCII lower case equivalent. @@ -429,13 +254,7 @@ pub fn make_ascii_uppercase(&mut self) { /// To lowercase the value in-place, use [`make_ascii_lowercase`]. /// /// [`make_ascii_lowercase`]: str::make_ascii_lowercase - pub fn to_ascii_lowercase(&self) -> Result { - let mut s =3D self.to_cstring()?; - - s.make_ascii_lowercase(); - - Ok(s) - } + fn to_ascii_lowercase(&self) -> Result; =20 /// Returns a copy of this [`CString`] where each character is mapped = to its /// ASCII upper case equivalent. @@ -446,13 +265,7 @@ pub fn to_ascii_lowercase(&self) -> Result { /// To uppercase the value in-place, use [`make_ascii_uppercase`]. /// /// [`make_ascii_uppercase`]: str::make_ascii_uppercase - pub fn to_ascii_uppercase(&self) -> Result { - let mut s =3D self.to_cstring()?; - - s.make_ascii_uppercase(); - - Ok(s) - } + fn to_ascii_uppercase(&self) -> Result; } =20 impl fmt::Display for CStr { @@ -485,98 +298,75 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Res= ult { } } =20 -impl fmt::Debug for CStr { - /// Formats printable ASCII characters with a double quote on either e= nd, escaping the rest. - /// - /// ``` - /// # use kernel::c_str; - /// # use kernel::prelude::fmt; - /// # use kernel::str::CStr; - /// # use kernel::str::CString; - /// let penguin =3D c_str!("=F0=9F=90=A7"); - /// let s =3D CString::try_from_fmt(fmt!("{penguin:?}"))?; - /// assert_eq!(s.as_bytes_with_nul(), "\"\\xf0\\x9f\\x90\\xa7\"\0".as_= bytes()); - /// - /// // Embedded double quotes are escaped. - /// let ascii =3D c_str!("so \"cool\""); - /// let s =3D CString::try_from_fmt(fmt!("{ascii:?}"))?; - /// assert_eq!(s.as_bytes_with_nul(), "\"so \\\"cool\\\"\"\0".as_bytes= ()); - /// # Ok::<(), kernel::error::Error>(()) - /// ``` - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str("\"")?; - for &c in self.as_bytes() { - match c { - // Printable characters. - b'\"' =3D> f.write_str("\\\"")?, - 0x20..=3D0x7e =3D> f.write_char(c as char)?, - _ =3D> write!(f, "\\x{c:02x}")?, - } - } - f.write_str("\"") - } +/// Converts a mutable C string to a mutable byte slice. +/// +/// # Safety +/// +/// The caller must ensure that the slice ends in a NUL byte and contains = no other NUL bytes before +/// the borrow ends and the underlying [`CStr`] is used. +unsafe fn to_bytes_mut(s: &mut CStr) -> &mut [u8] { + // SAFETY: the cast from `&CStr` to `&[u8]` is safe since `CStr` has t= he same layout as `&[u8]` + // (this is technically not guaranteed, but we rely on it here). The p= ointer dereference is + // safe since it comes from a mutable reference which is guaranteed to= be valid for writes. + unsafe { &mut *(core::ptr::from_mut(s) as *mut [u8]) } } =20 -impl AsRef for CStr { +impl CStrExt for CStr { #[inline] - fn as_ref(&self) -> &BStr { - BStr::from_bytes(self.as_bytes()) + unsafe fn from_char_ptr<'a>(ptr: *const c_char) -> &'a Self { + // SAFETY: The safety preconditions are the same as for `CStr::fro= m_ptr`. + unsafe { CStr::from_ptr(ptr.cast()) } } -} =20 -impl Deref for CStr { - type Target =3D BStr; + #[inline] + unsafe fn from_bytes_with_nul_unchecked_mut(bytes: &mut [u8]) -> &mut = Self { + // SAFETY: the cast from `&[u8]` to `&CStr` is safe since the prop= erties of `bytes` are + // guaranteed by the safety precondition and `CStr` has the same l= ayout as `&[u8]` (this is + // technically not guaranteed, but we rely on it here). The pointe= r dereference is safe + // since it comes from a mutable reference which is guaranteed to = be valid for writes. + unsafe { &mut *(core::ptr::from_mut(bytes) as *mut CStr) } + } =20 #[inline] - fn deref(&self) -> &Self::Target { - self.as_ref() + fn as_char_ptr(&self) -> *const c_char { + self.as_ptr().cast() + } + + fn to_cstring(&self) -> Result { + CString::try_from(self) } -} =20 -impl Index> for CStr { - type Output =3D CStr; + fn make_ascii_lowercase(&mut self) { + // SAFETY: This doesn't introduce or remove NUL bytes in the C str= ing. + unsafe { to_bytes_mut(self) }.make_ascii_lowercase(); + } =20 - #[inline] - fn index(&self, index: ops::RangeFrom) -> &Self::Output { - // Delegate bounds checking to slice. - // Assign to _ to mute clippy's unnecessary operation warning. - let _ =3D &self.as_bytes()[index.start..]; - // SAFETY: We just checked the bounds. - unsafe { Self::from_bytes_with_nul_unchecked(&self.0[index.start..= ]) } + fn make_ascii_uppercase(&mut self) { + // SAFETY: This doesn't introduce or remove NUL bytes in the C str= ing. + unsafe { to_bytes_mut(self) }.make_ascii_uppercase(); } -} =20 -impl Index for CStr { - type Output =3D CStr; + fn to_ascii_lowercase(&self) -> Result { + let mut s =3D self.to_cstring()?; =20 - #[inline] - fn index(&self, _index: ops::RangeFull) -> &Self::Output { - self + s.make_ascii_lowercase(); + + Ok(s) } -} =20 -mod private { - use core::ops; + fn to_ascii_uppercase(&self) -> Result { + let mut s =3D self.to_cstring()?; =20 - // Marker trait for index types that can be forward to `BStr`. - pub trait CStrIndex {} + s.make_ascii_uppercase(); =20 - impl CStrIndex for usize {} - impl CStrIndex for ops::Range {} - impl CStrIndex for ops::RangeInclusive {} - impl CStrIndex for ops::RangeToInclusive {} + Ok(s) + } } =20 -impl Index for CStr -where - Idx: private::CStrIndex, - BStr: Index, -{ - type Output =3D >::Output; - +impl AsRef for CStr { #[inline] - fn index(&self, index: Idx) -> &Self::Output { - &self.as_ref()[index] + fn as_ref(&self) -> &BStr { + BStr::from_bytes(self.to_bytes()) } } =20 @@ -607,6 +397,13 @@ macro_rules! c_str { mod tests { use super::*; =20 + impl From for Error { + #[inline] + fn from(_: core::ffi::FromBytesWithNulError) -> Error { + EINVAL + } + } + macro_rules! format { ($($f:tt)*) =3D> ({ CString::try_from_fmt(fmt!($($f)*))?.to_str()? @@ -629,40 +426,28 @@ macro_rules! format { =20 #[test] fn test_cstr_to_str() -> Result { - let good_bytes =3D b"\xf0\x9f\xa6\x80\0"; - let checked_cstr =3D CStr::from_bytes_with_nul(good_bytes)?; - let checked_str =3D checked_cstr.to_str()?; + let cstr =3D c"\xf0\x9f\xa6\x80"; + let checked_str =3D cstr.to_str()?; assert_eq!(checked_str, "=F0=9F=A6=80"); Ok(()) } =20 #[test] fn test_cstr_to_str_invalid_utf8() -> Result { - let bad_bytes =3D b"\xc3\x28\0"; - let checked_cstr =3D CStr::from_bytes_with_nul(bad_bytes)?; - assert!(checked_cstr.to_str().is_err()); - Ok(()) - } - - #[test] - fn test_cstr_as_str_unchecked() -> Result { - let good_bytes =3D b"\xf0\x9f\x90\xA7\0"; - let checked_cstr =3D CStr::from_bytes_with_nul(good_bytes)?; - // SAFETY: The contents come from a string literal which contains = valid UTF-8. - let unchecked_str =3D unsafe { checked_cstr.as_str_unchecked() }; - assert_eq!(unchecked_str, "=F0=9F=90=A7"); + let cstr =3D c"\xc3\x28"; + assert!(cstr.to_str().is_err()); Ok(()) } =20 #[test] fn test_cstr_display() -> Result { - let hello_world =3D CStr::from_bytes_with_nul(b"hello, world!\0")?; + let hello_world =3D c"hello, world!"; assert_eq!(format!("{hello_world}"), "hello, world!"); - let non_printables =3D CStr::from_bytes_with_nul(b"\x01\x09\x0a\0"= )?; + let non_printables =3D c"\x01\x09\x0a"; assert_eq!(format!("{non_printables}"), "\\x01\\x09\\x0a"); - let non_ascii =3D CStr::from_bytes_with_nul(b"d\xe9j\xe0 vu\0")?; + let non_ascii =3D c"d\xe9j\xe0 vu"; assert_eq!(format!("{non_ascii}"), "d\\xe9j\\xe0 vu"); - let good_bytes =3D CStr::from_bytes_with_nul(b"\xf0\x9f\xa6\x80\0"= )?; + let good_bytes =3D c"\xf0\x9f\xa6\x80"; assert_eq!(format!("{good_bytes}"), "\\xf0\\x9f\\xa6\\x80"); Ok(()) } @@ -681,13 +466,13 @@ fn test_cstr_display_all_bytes() -> Result { =20 #[test] fn test_cstr_debug() -> Result { - let hello_world =3D CStr::from_bytes_with_nul(b"hello, world!\0")?; + let hello_world =3D c"hello, world!"; assert_eq!(format!("{hello_world:?}"), "\"hello, world!\""); - let non_printables =3D CStr::from_bytes_with_nul(b"\x01\x09\x0a\0"= )?; - assert_eq!(format!("{non_printables:?}"), "\"\\x01\\x09\\x0a\""); - let non_ascii =3D CStr::from_bytes_with_nul(b"d\xe9j\xe0 vu\0")?; + let non_printables =3D c"\x01\x09\x0a"; + assert_eq!(format!("{non_printables:?}"), "\"\\x01\\t\\n\""); + let non_ascii =3D c"d\xe9j\xe0 vu"; assert_eq!(format!("{non_ascii:?}"), "\"d\\xe9j\\xe0 vu\""); - let good_bytes =3D CStr::from_bytes_with_nul(b"\xf0\x9f\xa6\x80\0"= )?; + let good_bytes =3D c"\xf0\x9f\xa6\x80"; assert_eq!(format!("{good_bytes:?}"), "\"\\xf0\\x9f\\xa6\\x80\""); Ok(()) } diff --git a/rust/kernel/sync/condvar.rs b/rust/kernel/sync/condvar.rs index c6ec64295c9f..a24e25a690ee 100644 --- a/rust/kernel/sync/condvar.rs +++ b/rust/kernel/sync/condvar.rs @@ -8,7 +8,7 @@ use super::{lock::Backend, lock::Guard, LockClassKey}; use crate::{ ffi::{c_int, c_long}, - str::CStr, + str::{CStr, CStrExt as _}, task::{ MAX_SCHEDULE_TIMEOUT, TASK_FREEZABLE, TASK_INTERRUPTIBLE, TASK_NOR= MAL, TASK_UNINTERRUPTIBLE, }, diff --git a/rust/kernel/sync/lock.rs b/rust/kernel/sync/lock.rs index 27202beef90c..5d7991e6d373 100644 --- a/rust/kernel/sync/lock.rs +++ b/rust/kernel/sync/lock.rs @@ -7,7 +7,7 @@ =20 use super::LockClassKey; use crate::{ - str::CStr, + str::{CStr, CStrExt as _}, types::{NotThreadSafe, Opaque, ScopeGuard}, }; use core::{cell::UnsafeCell, marker::PhantomPinned, pin::Pin}; diff --git a/rust/kernel/sync/lock/global.rs b/rust/kernel/sync/lock/global= .rs index d65f94b5caf2..79d0ef7fda86 100644 --- a/rust/kernel/sync/lock/global.rs +++ b/rust/kernel/sync/lock/global.rs @@ -5,7 +5,7 @@ //! Support for defining statics containing locks. =20 use crate::{ - str::CStr, + str::{CStr, CStrExt as _}, sync::lock::{Backend, Guard, Lock}, sync::{LockClassKey, LockedBy}, types::Opaque, --=20 2.50.1