From patchwork Fri Dec 13 11:30:46 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Hindborg X-Patchwork-Id: 13906927 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 661FE1E048D; Fri, 13 Dec 2024 11:33:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734089633; cv=none; b=QgstcbtfQq51snyOg3PjqrUhIh7PMJFGbS0v5WCSnwAreMYlh0hRvcM7xdM864MP1GtbM5ynPoEIHYb/SmBT/ZndpMRcWY0jrRoibEYuowA4vX2MwZnJ2JdWJPsWB905LF8Xg4U/6lhzh/zo+ADRtXAGBEuk9KJHf1hK5nHCkgU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734089633; c=relaxed/simple; bh=Dp/gvFkmxNIBlKIq3RmiSi90pByj3YD8mMLxDJjtVnA=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=FpJKm+Jth/xhGrNZkNBhIMB+S3b4khb/rVA4W7TRLJAbCYF4WFbkxkvUAti+bBH2nw8IbmAAfkavwKAYdIMUx+I18rSBeJYA3UIOU1qYGHQQzPkO8pbZ/JGqtMMpWVSxEhB89kVVkVdbCiY1DrS/X8bTQOOxXRGmrXyycJ/nOqI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=KuGf84i/; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="KuGf84i/" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 528DBC4CED4; Fri, 13 Dec 2024 11:33:49 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1734089632; bh=Dp/gvFkmxNIBlKIq3RmiSi90pByj3YD8mMLxDJjtVnA=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=KuGf84i/zqzGXLb5aqHVMi+DUU8yOau/WsWefGXPQsXvFG98Gzx88A/qrmhWByrZH 3/FjPWGiCKQvHSG8mON2U2Zr1OdET9HWaMrdyyjkHQgI6w65Tit9OLmGsW3E6HzzOp vhRFqAC2DjfAbqx/g5hRxHZAHiiylF9PwnFvq4SmHdzNB3DFVU45wHDDqK7KyaY2Dj BbVEGSd53me778lXOJKZ1FVmtFXsC6d/oQD6j6/CbPwnii5m9BqNe3uqgvhDQjr9x6 z9sR7sFfSKLbJ903hPI3EsNJ3zxI4jeE0NCOx3KbRnCTI9X+bX9h8a9HXsEaveVSBh 1FaoArAKNbHvg== From: Andreas Hindborg Date: Fri, 13 Dec 2024 12:30:46 +0100 Subject: [PATCH v3 1/4] rust: str: implement `PartialEq` for `BStr` Precedence: bulk X-Mailing-List: linux-kbuild@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241213-module-params-v3-v3-1-485a015ac2cf@kernel.org> References: <20241213-module-params-v3-v3-0-485a015ac2cf@kernel.org> In-Reply-To: <20241213-module-params-v3-v3-0-485a015ac2cf@kernel.org> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Alice Ryhl , Masahiro Yamada , Nathan Chancellor , Nicolas Schier Cc: Trevor Gross , Adam Bratschi-Kaye , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, Andreas Hindborg X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=759; i=a.hindborg@kernel.org; h=from:subject:message-id; bh=Dp/gvFkmxNIBlKIq3RmiSi90pByj3YD8mMLxDJjtVnA=; b=owEBbQKS/ZANAwAIAeG4Gj55KGN3AcsmYgBnXBr2G0ntAv+d0j0ttUW0UUxngyHE0apK9EFII uYYoYZKEkSJAjMEAAEIAB0WIQQSwflHVr98KhXWwBLhuBo+eShjdwUCZ1wa9gAKCRDhuBo+eShj dz30EACk4jCKHOR8AcbS+h2DduFfzrAbyuIOHuGDx4183ktSBE3ziP9Fd9CgcTOrDJ3imGcSmC4 zymjNKdttsGe+1KzPTJCgKKxAoF+/hdAmAfKj0eX2vf2hkkSv3fazu5X2oXyuJUtqUxhnlCM8h0 kC9/H3vCvFOa0+vtpXpFXwc+cyFpSe98aqsREW25w3/s57Z9vb8Ud7x5QHwgQ9saeWgNrTXlx1f RYHuDvePU19JZvo7nAAb9rajqC0+BxwYadcMa42X7TpQgS1aakHnZi2Rhuluj14gB6Z/E9rPOHO Z5o/qvA3hLOBjZ02N0qhKiWD3/9/oU8/O1wAG9GazXjJev6JPuQ2YwbfILwNTp9HwfyWo6r8St3 bP2W+j2HZN0oqlOmxClCB+fML0ICvOw1Z3BGVDrxzNsbZWBif/0erLnZFE5RNzuFcDxmdINU3ZO 6Lj4VHS0HxYXUM9I1WT89yq/xrCw1zT/8QqNrqneOM4w5Bk+aiMkLP6RmpCAUFx2VGLJ2+qq7GX 3sYEcerqs7+rvCGIw1qC3k9Ve3AQP54w2qMUDZ9xCAoX2owbsziuKSsdwuSM4LvHQeiOfE1VzFm EYvDerRBzQ8eo6246Q0GMfBtQzONVN1q1jDZWRSvHhkZ4DUK5LQUA90ldGxyFZ8tdxP/9pYDUKy V2081pHk+kx2vGQ== X-Developer-Key: i=a.hindborg@kernel.org; a=openpgp; fpr=3108C10F46872E248D1FB221376EB100563EF7A7 Implement `PartialEq` for `BStr` by comparing underlying byte slices. Signed-off-by: Andreas Hindborg Reviewed-by: Alice Ryhl --- rust/kernel/str.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs index d04c12a1426d1c1edeb88325bcd9c63bf45f9b60..c441acf76ebd1f14919b6d233edffbbbbf944619 100644 --- a/rust/kernel/str.rs +++ b/rust/kernel/str.rs @@ -106,6 +106,12 @@ fn deref(&self) -> &Self::Target { } } +impl PartialEq for BStr { + fn eq(&self, other: &Self) -> bool { + self.deref().eq(other.deref()) + } +} + /// Creates a new [`BStr`] from a string literal. /// /// `b_str!` converts the supplied string literal to byte string, so non-ASCII From patchwork Fri Dec 13 11:30:47 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Hindborg X-Patchwork-Id: 13906924 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 46683175AB; Fri, 13 Dec 2024 11:33:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734089620; cv=none; b=XzPH426bSeW+skDLftDxMNJysbLkTVXGEAximO/y/lISh4/8NfUNwqdF1NwjqecBunn8bK6149TOfCSZ+FfHtgGTRM7DAMgW7fFtrtn3rr2kTKJwEI29VrCWYw4qY7VgWVlHauF0BAHCUqIMHzZbR6+KNjA+orc4xNWoOEmt1Xg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734089620; c=relaxed/simple; bh=W1dON2DXJk8wtFufY6Ee10/Ghnqv3HpHBRkp7n4UJys=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=m8PtHgMhf2ybcLsniQ+GaqonyBrCJam4uZuM0/mEDwZ75tk4D5BHKzMHP1DM3UVfwQtRaxe6vS61f15HhiawzbtvgFE5TedMkf4j4zUAXUnyF/qPdmO2stLO7fJbfu/6xo8KUkiMlkqzec6bP/8Vtv00EAVLt5S9IWUe5ZTXbsk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=gYgRU3jZ; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="gYgRU3jZ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6F720C4CED0; Fri, 13 Dec 2024 11:33:36 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1734089620; bh=W1dON2DXJk8wtFufY6Ee10/Ghnqv3HpHBRkp7n4UJys=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=gYgRU3jZJ7TWQ48ScFxUDqYu44sr4/grgzSwhgqCch4qL61kKeFAyQXpixr7Nrgn4 SC/p3YQkCPGUx/rIsWG7FvcRWMoVPuYOnHJFlxtOIztU/W+ZJlnAYeP/9Y66xgK+ZQ 5i1udD+TBhOsZbThgSn+aPkz8B2fTpHtnnDCUrDJu285v3xWm3UuEiebf8MMXc3kWJ X4LVz2NKeIwzixSzMcZ3p+jQzHp/1uvgjp3oP3BSnvRzOC5vX8LPjAmzvXbOQPGufG 0w5Q/9TR591XpMLlKMoadu8ufn3ynjBvYIMBBCFYwYOgMZgYwEO30CZL2w3L6YZOp0 lp+l6yRYKNGqA== From: Andreas Hindborg Date: Fri, 13 Dec 2024 12:30:47 +0100 Subject: [PATCH v3 2/4] rust: str: implement `strip_prefix` for `BStr` Precedence: bulk X-Mailing-List: linux-kbuild@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241213-module-params-v3-v3-2-485a015ac2cf@kernel.org> References: <20241213-module-params-v3-v3-0-485a015ac2cf@kernel.org> In-Reply-To: <20241213-module-params-v3-v3-0-485a015ac2cf@kernel.org> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Alice Ryhl , Masahiro Yamada , Nathan Chancellor , Nicolas Schier Cc: Trevor Gross , Adam Bratschi-Kaye , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, Andreas Hindborg X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=1549; i=a.hindborg@kernel.org; h=from:subject:message-id; bh=W1dON2DXJk8wtFufY6Ee10/Ghnqv3HpHBRkp7n4UJys=; b=owEBbQKS/ZANAwAIAeG4Gj55KGN3AcsmYgBnXBr3TBAVUizS1xdUCu+XmO2/txTPKNdgAyR9X z1A8hN9gbSJAjMEAAEIAB0WIQQSwflHVr98KhXWwBLhuBo+eShjdwUCZ1wa9wAKCRDhuBo+eShj d4DFD/9QrT+VmKDUDncGxWzfaL0kcWBVEtqigswAs1ctsX2CZE1no8K6jiFd/BrjL7vj55NRHz9 fDQ7CQyYwNllhIMgvzTLVa1JoQjK2vgc1dEkqRdokr7tMz8AyDb7W0h5i2oeiOTUuq52IMdlcpq CNKBlpJRd3JlOPXrp/j73G55rqcF+WJYAZrSPW6vjenX2cDgCPPr1ItFAgejIB9Gx9AjQKUF51S ugsTcKHniOvT7kt8zYBiZuYokK7eUSM1zvqgUsWmsLTtzr71tzp2ZlIQsmaMoKUArqH1fcLIbzK C1AGlnfVrA/v6rNuovHe98xBY79Hl+qYXkQ+/mq053DGxMfKBGAtZS829XS2mbSnVZi6kIz10as NFXirS+gjM8eGf06toqQIQZMhOpQVdEeccg/5QgUDARAYD3046Nwv0/A20rJ/AYACw/J6+o8kFA 6xfdC2koARakfGvGLv3Eo0ARqtQpCDmi/nvBGpVw4caRq9PP1AgqINgUqpF2uVpCInHjrcPRjis yS9hqxg7RZoa5o5DE28yVcxMhtOd/zwZ9jqYUv52+SstFQgbuiuf28/me3ylRkjQFcdq1FAk6NP JBn8LPQgDv1iFk2jOJCysmSPeNcNteGBH0Tlti1mV3g67Xi46tYkoRRb63LkLxSY8cXrVHCnuNG l1/btl9t+IeBO9g== X-Developer-Key: i=a.hindborg@kernel.org; a=openpgp; fpr=3108C10F46872E248D1FB221376EB100563EF7A7 Implement `strip_prefix` for `BStr` by deferring to `slice::strip_prefix` on the underlying `&[u8]`. Signed-off-by: Andreas Hindborg --- It is also possible to get this method by implementing `core::slice::SlicePattern` for `BStr`. `SlicePattern` is unstable, so this seems more reasonable. --- rust/kernel/str.rs | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs index c441acf76ebd1f14919b6d233edffbbbbf944619..9c446ff1ad7adba7ca09a5ae9df00fd369a32899 100644 --- a/rust/kernel/str.rs +++ b/rust/kernel/str.rs @@ -31,6 +31,22 @@ pub const fn from_bytes(bytes: &[u8]) -> &Self { // SAFETY: `BStr` is transparent to `[u8]`. unsafe { &*(bytes as *const [u8] as *const BStr) } } + + /// Strip a prefix from `self`. Delegates to [`slice::strip_prefix`]. + /// + /// # Example + /// ``` + /// use kernel::b_str; + /// assert_eq!(Some(b_str!("bar")), b_str!("foobar").strip_prefix(b_str!("foo"))); + /// assert_eq!(None, b_str!("foobar").strip_prefix(b_str!("bar"))); + /// assert_eq!(Some(b_str!("foobar")), b_str!("foobar").strip_prefix(b_str!(""))); + /// assert_eq!(Some(b_str!("")), b_str!("foobar").strip_prefix(b_str!("foobar"))); + /// ``` + pub fn strip_prefix(&self, pattern: &Self) -> Option<&BStr> { + self.deref() + .strip_prefix(pattern.deref()) + .map(Self::from_bytes) + } } impl fmt::Display for BStr { From patchwork Fri Dec 13 11:30:48 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Hindborg X-Patchwork-Id: 13906926 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4E0E21E048D; Fri, 13 Dec 2024 11:33:48 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734089629; cv=none; b=sz6+I8qUAXiwKCfOgLlBIEi3eO0XzzOUPTyUv+99hEADUGXAI9akn7ym4HN5EOKsZSeYpEpCh6Y6K5Xj5f7j7Kuv0m6pnuNNYYcxg4xJa6MglIxVzIVd15Z2u++TRu+DJjKyRjexLE6vI0dZitZAtclO4LMEQ4zLrK4GdQZ2daQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734089629; c=relaxed/simple; bh=2xfkXc9JxYvg/POXeclE+sRiTUdiJ+lY/HbctFIl/tI=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=ffu++hY/nlziV5dcGh8XstRtBirDhm5QZ9BpXkvisQNiduT+EWiXsc0ZGaQ9TYsDQC1QMsUbsMgMPjBPf6ev4CHjjwN+Gs5V3WWbCjFRuWh29sg5FDjfvnURG44lXjf+fSTbUiIJagrjeY2Mm/Hm+BeUc2lTaC4VG77wXvhdr1A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=DWEZiEdu; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="DWEZiEdu" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0B720C4CED0; Fri, 13 Dec 2024 11:33:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1734089628; bh=2xfkXc9JxYvg/POXeclE+sRiTUdiJ+lY/HbctFIl/tI=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=DWEZiEdurY7hNN7EQzrIEFtjkqfVRAtHrJu2WcZmEpWS7mjW2ZoksKO+1LEf9QLc/ ZaexLZPa42SgSm4CbokkKlaVi+y5aeh31sE5sEHhicemfxXxIi81Q/VNEhWwSDiY7J Y0MJd3OUf3nSGygxipzB3cn+KP/tNzZoY0CwJHrvWpTOVn4korNnrA1xR9WaTZtaTI aRp6d5i21YKbt1TK7m5OdhKxL2GEaW9N0HVgzPPl158SXVSHAGvCPP2hbSvf4zilGt IbdyW3WTwYB+JmjLMZREJ20+orBn3uXRBC8bNf1wO8H96t0NGaCRrw93EQnu9i2kXM dfpN6F1dc2Tuw== From: Andreas Hindborg Date: Fri, 13 Dec 2024 12:30:48 +0100 Subject: [PATCH v3 3/4] rust: str: add radix prefixed integer parsing functions Precedence: bulk X-Mailing-List: linux-kbuild@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241213-module-params-v3-v3-3-485a015ac2cf@kernel.org> References: <20241213-module-params-v3-v3-0-485a015ac2cf@kernel.org> In-Reply-To: <20241213-module-params-v3-v3-0-485a015ac2cf@kernel.org> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Alice Ryhl , Masahiro Yamada , Nathan Chancellor , Nicolas Schier Cc: Trevor Gross , Adam Bratschi-Kaye , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, Andreas Hindborg X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=5609; i=a.hindborg@kernel.org; h=from:subject:message-id; bh=2xfkXc9JxYvg/POXeclE+sRiTUdiJ+lY/HbctFIl/tI=; b=owEBbQKS/ZANAwAIAeG4Gj55KGN3AcsmYgBnXBr4ks9NqeA8f5mQEuSCzCC6PY4bdZR32bCAb TRuzijQZ+KJAjMEAAEIAB0WIQQSwflHVr98KhXWwBLhuBo+eShjdwUCZ1wa+AAKCRDhuBo+eShj d9HZD/9ibilbr3zqmM9LVDxxDzfzYAVUXADOjH5Rb42BERoRQc5JGHwavcvEYQoD1VziCE6GSYF 2ilaVb8+XmsO459tnwAVqRehKwN5vYIQqJAi0XQc2nMytGDocV5a9m3u/qf4DBA0WuxrUYAmWwz MUrnfcx0QcvMprWjMnXGqR6ZfkIZIFcmD9txW7lgXKhP2ZbeQUu2Ah7pVivqCZcKl5pvgfzfNbA YDSFY+kSIrMtj+hSalMaEzczutQbjKp03/TMqHZuWDffHJyArzgQN4l8YQbHtL1GTn8PUo181LD Q9+Hj18jgEGyp8rJ7k/Xsk9KewvKqmii5bnWZqkUV+y3iymHxe6ymO7cGWXnzgYYdUL6vYbtX12 INZhn3RJl5AP0QAt+/QBfkQfptKSQfcq7GehmvsB+ZYcxzIcm1mNeLaO04P63VRjDd0e24y9xeZ 9oKApthTRn0eEcphrb1HXbdIDsU98WASD9dhqpcKB+FL/fdKho9UQ/GaSnYx2TOLR3nBdYtddtZ mZtxtFJEA8GUZ52zAXuqPRF4txi4UHpW0rNr5WEehV9D8V1FdsqFD1yN+H/ReHvYEgyMF9Q1fjD Hp3/pi1/CiNcEQPegqWZmm00oG9vSOfvRqMVGF0sKHKQVPKje7d5EofYA1hTP5irjOwY6y1ZDjP Zkmb25KN2/AFXew== X-Developer-Key: i=a.hindborg@kernel.org; a=openpgp; fpr=3108C10F46872E248D1FB221376EB100563EF7A7 Add the trait `ParseInt` for parsing string representations of integers where the string representations are optionally prefixed by a radix specifier. Implement the trait for the primitive integer types. Signed-off-by: Andreas Hindborg --- rust/kernel/str.rs | 116 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 116 insertions(+) diff --git a/rust/kernel/str.rs b/rust/kernel/str.rs index 9c446ff1ad7adba7ca09a5ae9df00fd369a32899..4da711f264397c7a1fce34edb69a71253d03911e 100644 --- a/rust/kernel/str.rs +++ b/rust/kernel/str.rs @@ -914,3 +914,119 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { macro_rules! fmt { ($($f:tt)*) => ( core::format_args!($($f)*) ) } + +pub mod parse_int { + //! Integer parsing functions for parsing signed and unsigned integers + //! potentially prefixed with `0x`, `0o`, or `0b`. + + use crate::alloc::flags; + use crate::prelude::*; + use crate::str::BStr; + + /// Trait that allows parsing a `&BStr` to an integer with a radix. + // This is required because the `from_str_radix` function on the primitive + // integer types is not part of any trait. + pub trait FromStrRadix: Sized { + /// Parse `src` to `Self` using radix `radix`. + fn from_str_radix(src: &BStr, radix: u32) -> Result; + } + + /// Extract the radix from an integer literal optionally prefixed with + /// one of `0x`, `0X`, `0o`, `0O`, `0b`, `0B`, `0`. + fn strip_radix(src: &BStr) -> (u32, &BStr) { + if let Some(n) = src.strip_prefix(b_str!("0x")) { + (16, n) + } else if let Some(n) = src.strip_prefix(b_str!("0X")) { + (16, n) + } else if let Some(n) = src.strip_prefix(b_str!("0o")) { + (8, n) + } else if let Some(n) = src.strip_prefix(b_str!("0O")) { + (8, n) + } else if let Some(n) = src.strip_prefix(b_str!("0b")) { + (2, n) + } else if let Some(n) = src.strip_prefix(b_str!("0B")) { + (2, n) + } else if let Some(n) = src.strip_prefix(b_str!("0")) { + (8, n) + } else { + (10, src) + } + } + + /// Trait for parsing string representations of integers. + /// + /// Strings beginning with `0x`, `0o`, or `0b` are parsed as hex, octal, or + /// binary respectively. Strings beginning with `0` otherwise are parsed as + /// octal. Anything else is parsed as decimal. A leading `+` or `-` is also + /// permitted. Any string parsed by [`kstrtol()`] or [`kstrtoul()`] will be + /// successfully parsed. + /// + /// [`kstrtol()`]: https://www.kernel.org/doc/html/latest/core-api/kernel-api.html#c.kstrtol + /// [`kstrtoul()`]: https://www.kernel.org/doc/html/latest/core-api/kernel-api.html#c.kstrtoul + /// + /// # Example + /// ``` + /// use kernel::str::parse_int::ParseInt; + /// use kernel::b_str; + /// + /// assert_eq!(Ok(0xa2u8), u8::from_str(b_str!("0xa2"))); + /// assert_eq!(Ok(-0xa2i32), i32::from_str(b_str!("-0xa2"))); + /// + /// assert_eq!(Ok(-0o57i8), i8::from_str(b_str!("-0o57"))); + /// assert_eq!(Ok(0o57i8), i8::from_str(b_str!("057"))); + /// + /// assert_eq!(Ok(0b1001i16), i16::from_str(b_str!("0b1001"))); + /// assert_eq!(Ok(-0b1001i16), i16::from_str(b_str!("-0b1001"))); + /// + /// assert_eq!(Ok(127), i8::from_str(b_str!("127"))); + /// assert!(i8::from_str(b_str!("128")).is_err()); + /// assert_eq!(Ok(-128), i8::from_str(b_str!("-128"))); + /// assert!(i8::from_str(b_str!("-129")).is_err()); + /// assert_eq!(Ok(255), u8::from_str(b_str!("255"))); + /// assert!(u8::from_str(b_str!("256")).is_err()); + /// ``` + pub trait ParseInt: FromStrRadix { + /// Parse a string according to the description in [`Self`]. + fn from_str(src: &BStr) -> Result { + match src.iter().next() { + None => Err(EINVAL), + Some(sign @ b'-') | Some(sign @ b'+') => { + let (radix, digits) = strip_radix(BStr::from_bytes(&src[1..])); + let mut n_digits: KVec = + KVec::with_capacity(digits.len() + 1, flags::GFP_KERNEL)?; + n_digits.push(*sign, flags::GFP_KERNEL)?; + n_digits.extend_from_slice(digits, flags::GFP_KERNEL)?; + Self::from_str_radix(BStr::from_bytes(&n_digits), radix).map_err(|_| EINVAL) + } + Some(_) => { + let (radix, digits) = strip_radix(src); + Self::from_str_radix(digits, radix).map_err(|_| EINVAL) + } + } + } + } + + macro_rules! impl_parse_int { + ($ty:ty) => { + impl FromStrRadix for $ty { + fn from_str_radix(src: &BStr, radix: u32) -> Result { + <$ty>::from_str_radix(core::str::from_utf8(src).map_err(|_| EINVAL)?, radix) + .map_err(|_| EINVAL) + } + } + + impl ParseInt for $ty {} + }; + } + + impl_parse_int!(i8); + impl_parse_int!(u8); + impl_parse_int!(i16); + impl_parse_int!(u16); + impl_parse_int!(i32); + impl_parse_int!(u32); + impl_parse_int!(i64); + impl_parse_int!(u64); + impl_parse_int!(isize); + impl_parse_int!(usize); +} From patchwork Fri Dec 13 11:30:49 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andreas Hindborg X-Patchwork-Id: 13906928 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9F1EE1DF759; Fri, 13 Dec 2024 11:33:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734089637; cv=none; b=Zx51EuHvgM8rFkzt2EvP/wvElh6NSNLuAi7E/C1J9Fm5cAvWqtkiUdtFMBjXRJFDWsjI0yYC2o9ZcEG4ichVK4js77Y2h0hHo4NZucIsV+Izcm3flPvflDfa21cSch0oIAvfqlYbMrpsJDrf3t4V9wwDti/72YnI0JH3DueebZs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1734089637; c=relaxed/simple; bh=ktGoI5KcC/svCt0+oyxoVWuisRCH4jrzYeg6g6BG3aU=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=dZSkQE5gf0+fQ1SRz4g0Ej7pz4KJQ9AoolZhECf66fJDWDuLUWFpFUPHrZ+WPfDofGTTp3DDPBqDi1bGkjHS+rtXXB+3Cz1JvUf+q/55wGcVv5C4+0DY0i70vYHj+hFi+wgOSJoGMcSkHnIX5oL36TpcmxaoPniiJopGuctuwV0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=ko1RCqCm; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="ko1RCqCm" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9BCA0C4CED0; Fri, 13 Dec 2024 11:33:53 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1734089637; bh=ktGoI5KcC/svCt0+oyxoVWuisRCH4jrzYeg6g6BG3aU=; h=From:Date:Subject:References:In-Reply-To:To:Cc:From; b=ko1RCqCmnTzNOiWlH3pFE0eDjV7B0xZrMJx7r/r6a+iW/JnAqC9xqjTvJVXVF6Osm tweyj2FlxfVMHEbUgyyObsnC+IhY9S37TnUvKmmIt1Zel8KYt1EF+8iO4Yo8ew8JSG Lfr7hkUCMF+EUhnxEi85EMlV5im/HzSuRzTV0cKm77tmbuUkKLb55yTUm0QWcurFl+ 0QoVhdVCV8B1gxjyd5w0A9Pbk8eurBSm5oVWbDLSfzAp9lOhRdxFvhd7rpUDhbfEFd dbcrKpBRVh0O2wVVjXn7fwIhrBUCCLYh7COfkn7w821Jsft44hKu4j1hoW6Bi9ApSw kz0wfWvRNj2ug== From: Andreas Hindborg Date: Fri, 13 Dec 2024 12:30:49 +0100 Subject: [PATCH v3 4/4] rust: add parameter support to the `module!` macro Precedence: bulk X-Mailing-List: linux-kbuild@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Message-Id: <20241213-module-params-v3-v3-4-485a015ac2cf@kernel.org> References: <20241213-module-params-v3-v3-0-485a015ac2cf@kernel.org> In-Reply-To: <20241213-module-params-v3-v3-0-485a015ac2cf@kernel.org> To: Miguel Ojeda , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?q?Bj=C3=B6rn_Roy_Baron?= , Benno Lossin , Alice Ryhl , Masahiro Yamada , Nathan Chancellor , Nicolas Schier Cc: Trevor Gross , Adam Bratschi-Kaye , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kbuild@vger.kernel.org, Andreas Hindborg X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=25123; i=a.hindborg@kernel.org; h=from:subject:message-id; bh=ktGoI5KcC/svCt0+oyxoVWuisRCH4jrzYeg6g6BG3aU=; b=owEBbQKS/ZANAwAIAeG4Gj55KGN3AcsmYgBnXBr5HsOTe9PRdAw4uhSYDUCNoYLsCvAKpxIVg K8Ztz0a6LyJAjMEAAEIAB0WIQQSwflHVr98KhXWwBLhuBo+eShjdwUCZ1wa+QAKCRDhuBo+eShj d13iD/wKw75zpmGSQ4pYx8B6GkA4QZAHfqTfmuTNAZTyq8AXIrvux9zZLm8et5XXVHxuLvbDP1C fId/v9NbkYAvb9S0WOV5BODelh6VAkvczVBuUQvRzdNCaZO6Xei2gI79vvOEKpouczMKjRml+tK WvVG/KDAyNlX0TpKDoDiZmjKyae5eQYh0E1C7zCu8pXqCaMGfw7xZDKxwHT9elaghmSN9tjFIea +Oy1mBQirSSxMmqkwOgY+UgeQt1k8ipVDLW5OU9oXQhWpW0tyQ79W/gcbPz6XvZ9I3cR0Sdijx8 pHPphSLBlYDWT8zgsxljyPhAlL/IN2RmmXOcs17KsNuomz/rjI7iYy6Jfmd/u1RFE8+nTBf60lY 0Aqt54+MbwJ+dE84eDJe9MRpeDAhWCQ7vbG+hbl/JpADqOlAYKLmeTaa4OCDOqDi8nHhxx2RhUI GC19BgkT4d9/4+t3z5z54LJMYi6f4eYAzRQ+gze6Yi/wDmnsHUfbtw1quI+OiZUdiYjYvyZXX+4 tNHvxpp4rau5ysPUrXY5pqhnorI7ST7MQVE/2az5b9K7RrPq5SAtQ6XNpYBAAr1Ey2SQ7rdiL5w sOPFZbm6LKNToTjjhfDPAUHRdAywQVMJf+mOzfgQOQ9MESx9QmLyCH5gZ7nuniojwd7w/E4RLTu iZ3zyvHK8XQKr4Q== X-Developer-Key: i=a.hindborg@kernel.org; a=openpgp; fpr=3108C10F46872E248D1FB221376EB100563EF7A7 This patch includes changes required for Rust kernel modules to utilize module parameters. This code implements read only support for integer types without `sysfs` support. Signed-off-by: Andreas Hindborg --- rust/kernel/lib.rs | 2 + rust/kernel/module_param.rs | 238 +++++++++++++++++++++++++++++++++++++++++++ rust/macros/helpers.rs | 10 ++ rust/macros/lib.rs | 31 ++++++ rust/macros/module.rs | 188 ++++++++++++++++++++++++++++++---- samples/rust/rust_minimal.rs | 10 ++ scripts/Makefile.build | 2 +- 7 files changed, 462 insertions(+), 19 deletions(-) diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index e1065a7551a39e68d6379031d80d4be336e652a3..7670c47a967cdd7e4f63e00b8338c6042e391fee 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -18,6 +18,7 @@ #![feature(inline_const)] #![feature(lint_reasons)] #![feature(unsize)] +#![feature(sync_unsafe_cell)] // Ensure conditional compilation based on the kernel configuration works; // otherwise we may silently break things like initcall handling. @@ -46,6 +47,7 @@ pub mod kunit; pub mod list; pub mod miscdevice; +pub mod module_param; #[cfg(CONFIG_NET)] pub mod net; pub mod page; diff --git a/rust/kernel/module_param.rs b/rust/kernel/module_param.rs new file mode 100644 index 0000000000000000000000000000000000000000..f63e50a6f02ff3f3fd1117717faf8fd37377c3f1 --- /dev/null +++ b/rust/kernel/module_param.rs @@ -0,0 +1,238 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! Types for module parameters. +//! +//! C header: [`include/linux/moduleparam.h`](../../../include/linux/moduleparam.h) + +use crate::prelude::*; +use crate::str::BStr; + +/// Newtype to make `bindings::kernel_param` `Sync`. +#[repr(transparent)] +#[doc(hidden)] +pub struct RacyKernelParam(pub ::kernel::bindings::kernel_param); + +// SAFETY: C kernel handles serializing access to this type. We never access +// from Rust module. +unsafe impl Sync for RacyKernelParam {} + +/// Types that can be used for module parameters. +/// +/// Note that displaying the type in `sysfs` will fail if +/// [`Display`](core::fmt::Display) implementation would write more than +/// [`PAGE_SIZE`] - 1 bytes. +/// +/// [`PAGE_SIZE`]: `bindings::PAGE_SIZE` +pub trait ModuleParam: Sized { + /// The `ModuleParam` will be used by the kernel module through this type. + /// + /// This may differ from `Self` if, for example, `Self` needs to track + /// ownership without exposing it or allocate extra space for other possible + /// parameter values. + // This is required to support string parameters in the future. + type Value: ?Sized; + + /// Parse a parameter argument into the parameter value. + /// + /// `Err(_)` should be returned when parsing of the argument fails. + /// + /// Parameters passed at boot time will be set before [`kmalloc`] is + /// available (even if the module is loaded at a later time). However, in + /// this case, the argument buffer will be valid for the entire lifetime of + /// the kernel. So implementations of this method which need to allocate + /// should first check that the allocator is available (with + /// [`crate::bindings::slab_is_available`]) and when it is not available + /// provide an alternative implementation which doesn't allocate. In cases + /// where the allocator is not available it is safe to save references to + /// `arg` in `Self`, but in other cases a copy should be made. + /// + /// [`kmalloc`]: ../../../include/linux/slab.h + fn try_from_param_arg(arg: &'static [u8]) -> Result; +} + +/// Set the module parameter from a string. +/// +/// Used to set the parameter value at kernel initialization, when loading +/// the module or when set through `sysfs`. +/// +/// `param.arg` is a pointer to `*mut T` as set up by the [`module!`] +/// macro. +/// +/// See `struct kernel_param_ops.set`. +/// +/// # Safety +/// +/// If `val` is non-null then it must point to a valid null-terminated +/// string. The `arg` field of `param` must be an instance of `T`. +/// +/// # Invariants +/// +/// Currently, we only support read-only parameters that are not readable +/// from `sysfs`. Thus, this function is only called at kernel +/// initialization time, or at module load time, and we have exclusive +/// access to the parameter for the duration of the function. +/// +/// [`module!`]: macros::module +unsafe extern "C" fn set_param( + val: *const core::ffi::c_char, + param: *const crate::bindings::kernel_param, +) -> core::ffi::c_int +where + T: ModuleParam, +{ + // NOTE: If we start supporting arguments without values, val _is_ allowed + // to be null here. + assert!(!val.is_null()); + + // SAFETY: By function safety requirement, val is non-null and + // null-terminated. By C API contract, `val` is live and valid for reads + // for the duration of this function. + let arg = unsafe { CStr::from_char_ptr(val).as_bytes() }; + + crate::error::from_result(|| { + let new_value = T::try_from_param_arg(arg)?; + + // SAFETY: `param` is guaranteed to be valid by C API contract + // and `arg` is guaranteed to point to an instance of `T`. + let old_value = unsafe { (*param).__bindgen_anon_1.arg as *mut T }; + + // SAFETY: `old_value` is valid for writes, as we have exclusive + // access. `old_value` is pointing to an initialized static, an + // so it is properly initialized. + unsafe { core::ptr::replace(old_value, new_value) }; + Ok(0) + }) +} + +/// Write a string representation of the current parameter value to `buf`. +/// +/// # Safety +/// +/// Must not be called. +/// +/// # Note +/// +/// This should not be called as we declare all parameters as read only. +#[allow(clippy::extra_unused_type_parameters)] +unsafe extern "C" fn get_param( + _buf: *mut core::ffi::c_char, + _param: *const crate::bindings::kernel_param, +) -> core::ffi::c_int +where + T: ModuleParam, +{ + unreachable!("Parameters are not readable"); +} + +/// Drop the parameter. +/// +/// Called when unloading a module. +/// +/// # Safety +/// +/// The `arg` field of `param` must be an initialized instance of `Self`. +unsafe extern "C" fn free(arg: *mut core::ffi::c_void) +where + T: ModuleParam, +{ + // SAFETY: By function safety requirement, `arg` is an initialized + // instance of `T`. By C API contract, `arg` will not be used after + // this function returns. + unsafe { core::ptr::drop_in_place(arg as *mut T) }; +} + +macro_rules! impl_int_module_param { + ($ty:ident) => { + impl ModuleParam for $ty { + type Value = $ty; + + fn try_from_param_arg(arg: &'static [u8]) -> Result { + let bstr = BStr::from_bytes(arg); + <$ty as crate::str::parse_int::ParseInt>::from_str(bstr) + } + } + }; +} + +impl_int_module_param!(i8); +impl_int_module_param!(u8); +impl_int_module_param!(i16); +impl_int_module_param!(u16); +impl_int_module_param!(i32); +impl_int_module_param!(u32); +impl_int_module_param!(i64); +impl_int_module_param!(u64); +impl_int_module_param!(isize); +impl_int_module_param!(usize); + +/// A wrapper for kernel parameters. +/// +/// This type is instantiated by the [`module!`] macro when module parameters are +/// defined. You should never need to instantiate this type directly. +#[repr(transparent)] +pub struct ModuleParamAccess { + data: core::cell::SyncUnsafeCell, +} + +impl ModuleParamAccess { + #[doc(hidden)] + pub const fn new(value: T) -> Self { + Self { + data: core::cell::SyncUnsafeCell::new(value), + } + } + + /// Get a shared reference to the parameter value. + // Note: When sysfs access to parameters are enabled, we have to pass in a + // held lock guard here. + pub fn get(&self) -> &T { + // SAFETY: As we only support read only parameters with no sysfs + // exposure, the kernel will not touch the parameter data after module + // initialization. + unsafe { &*self.data.get() } + } + + /// Get a mutable pointer to the parameter value. + pub const fn as_mut_ptr(&self) -> *mut T { + self.data.get() + } +} + +#[doc(hidden)] +#[macro_export] +/// Generate a static [`kernel_param_ops`](../../../include/linux/moduleparam.h) struct. +/// +/// # Examples +/// +/// ```ignore +/// make_param_ops!( +/// /// Documentation for new param ops. +/// PARAM_OPS_MYTYPE, // Name for the static. +/// MyType // A type which implements [`ModuleParam`]. +/// ); +/// ``` +macro_rules! make_param_ops { + ($ops:ident, $ty:ty) => { + /// + /// Static [`kernel_param_ops`](../../../include/linux/moduleparam.h) + /// struct generated by `make_param_ops` + #[doc = concat!("for [`", stringify!($ty), "`].")] + pub static $ops: $crate::bindings::kernel_param_ops = $crate::bindings::kernel_param_ops { + flags: 0, + set: Some(set_param::<$ty>), + get: Some(get_param::<$ty>), + free: Some(free::<$ty>), + }; + }; +} + +make_param_ops!(PARAM_OPS_I8, i8); +make_param_ops!(PARAM_OPS_U8, u8); +make_param_ops!(PARAM_OPS_I16, i16); +make_param_ops!(PARAM_OPS_U16, u16); +make_param_ops!(PARAM_OPS_I32, i32); +make_param_ops!(PARAM_OPS_U32, u32); +make_param_ops!(PARAM_OPS_I64, i64); +make_param_ops!(PARAM_OPS_U64, u64); +make_param_ops!(PARAM_OPS_ISIZE, isize); +make_param_ops!(PARAM_OPS_USIZE, usize); diff --git a/rust/macros/helpers.rs b/rust/macros/helpers.rs index 563dcd2b7ace5e8322d0fddb409571cca2dd31ea..e4f2751e0f6bbd6a980ba57d630480f05682f59f 100644 --- a/rust/macros/helpers.rs +++ b/rust/macros/helpers.rs @@ -107,6 +107,16 @@ pub(crate) struct Generics { pub(crate) ty_generics: Vec, } +/// Parse a token stream of the form `expected_name: "value",` and return the +/// string in the position of "value". Panics on parse error. +pub(crate) fn expect_string_field(it: &mut token_stream::IntoIter, expected_name: &str) -> String { + assert_eq!(expect_ident(it), expected_name); + assert_eq!(expect_punct(it), ':'); + let string = expect_string(it); + assert_eq!(expect_punct(it), ','); + string +} + /// Parses the given `TokenStream` into `Generics` and the rest. /// /// The generics are not present in the rest, but a where clause might remain. diff --git a/rust/macros/lib.rs b/rust/macros/lib.rs index 4ab94e44adfe3206faad159e81417ea41a35815b..a75d354e3eec49fd4066ac3dd96c4afda2606d50 100644 --- a/rust/macros/lib.rs +++ b/rust/macros/lib.rs @@ -24,6 +24,30 @@ /// The `type` argument should be a type which implements the [`Module`] /// trait. Also accepts various forms of kernel metadata. /// +/// The `params` field describe module parameters. Each entry has the form +/// +/// ```ignore +/// parameter_name: type { +/// default: default_value, +/// description: "Description", +/// } +/// ``` +/// +/// `type` may be one of +/// +/// - `i8` +/// - `u8` +/// - `i8` +/// - `u8` +/// - `i16` +/// - `u16` +/// - `i32` +/// - `u32` +/// - `i64` +/// - `u64` +/// - `isize` +/// - `usize` +/// /// C header: [`include/linux/moduleparam.h`](srctree/include/linux/moduleparam.h) /// /// [`Module`]: ../kernel/trait.Module.html @@ -40,6 +64,12 @@ /// description: "My very own kernel module!", /// license: "GPL", /// alias: ["alternate_module_name"], +/// params: { +/// my_parameter: i64 { +/// default: 1, +/// description: "This parameter has a default of 1", +/// }, +/// }, /// } /// /// struct MyModule(i32); @@ -48,6 +78,7 @@ /// fn init(_module: &'static ThisModule) -> Result { /// let foo: i32 = 42; /// pr_info!("I contain: {}\n", foo); +/// pr_info!("i32 param is: {}\n", module_parameters::my_parameter.read()); /// Ok(Self(foo)) /// } /// } diff --git a/rust/macros/module.rs b/rust/macros/module.rs index 2587f41b0d3929af7ceac5f42b4711f70b4f8749..627279cf318b14b50128045bce980f9d60b9c6d0 100644 --- a/rust/macros/module.rs +++ b/rust/macros/module.rs @@ -26,6 +26,7 @@ struct ModInfoBuilder<'a> { module: &'a str, counter: usize, buffer: String, + param_buffer: String, } impl<'a> ModInfoBuilder<'a> { @@ -34,10 +35,11 @@ fn new(module: &'a str) -> Self { module, counter: 0, buffer: String::new(), + param_buffer: String::new(), } } - fn emit_base(&mut self, field: &str, content: &str, builtin: bool) { + fn emit_base(&mut self, field: &str, content: &str, builtin: bool, param: bool) { let string = if builtin { // Built-in modules prefix their modinfo strings by `module.`. format!( @@ -51,8 +53,14 @@ fn emit_base(&mut self, field: &str, content: &str, builtin: bool) { format!("{field}={content}\0", field = field, content = content) }; + let buffer = if param { + &mut self.param_buffer + } else { + &mut self.buffer + }; + write!( - &mut self.buffer, + buffer, " {cfg} #[doc(hidden)] @@ -75,20 +83,113 @@ fn emit_base(&mut self, field: &str, content: &str, builtin: bool) { self.counter += 1; } - fn emit_only_builtin(&mut self, field: &str, content: &str) { - self.emit_base(field, content, true) + fn emit_only_builtin(&mut self, field: &str, content: &str, param: bool) { + self.emit_base(field, content, true, param) } - fn emit_only_loadable(&mut self, field: &str, content: &str) { - self.emit_base(field, content, false) + fn emit_only_loadable(&mut self, field: &str, content: &str, param: bool) { + self.emit_base(field, content, false, param) } fn emit(&mut self, field: &str, content: &str) { - self.emit_only_builtin(field, content); - self.emit_only_loadable(field, content); + self.emit_internal(field, content, false); + } + + fn emit_internal(&mut self, field: &str, content: &str, param: bool) { + self.emit_only_builtin(field, content, param); + self.emit_only_loadable(field, content, param); + } + + fn emit_param(&mut self, field: &str, param: &str, content: &str) { + let content = format!("{param}:{content}", param = param, content = content); + self.emit_internal(field, &content, true); + } + + fn emit_params(&mut self, info: &ModuleInfo) { + let Some(params) = &info.params else { + return; + }; + + for param in params { + let ops = param_ops_path(¶m.ptype); + + // Note: The spelling of these fields is dictated by the user space + // tool `modinfo`. + self.emit_param("parmtype", ¶m.name, ¶m.ptype); + self.emit_param("parm", ¶m.name, ¶m.description); + + write!( + self.param_buffer, + " + pub(crate) static {param_name}: + ::kernel::module_param::ModuleParamAccess<{param_type}> = + ::kernel::module_param::ModuleParamAccess::new({param_default}); + + #[link_section = \"__param\"] + #[used] + static __{module_name}_{param_name}_struct: + ::kernel::module_param::RacyKernelParam = + ::kernel::module_param::RacyKernelParam(::kernel::bindings::kernel_param {{ + name: if cfg!(MODULE) {{ + c\"{module_name}.{param_name}\" + }} else {{ + c\"{param_name}\" + }}.as_ptr(), + // SAFETY: `__this_module` is constructed by the kernel at load time + // and will not be freed until the module is unloaded. + #[cfg(MODULE)] + mod_: unsafe {{ + (&::kernel::bindings::__this_module + as *const ::kernel::bindings::module) + .cast_mut() + }}, + #[cfg(not(MODULE))] + mod_: ::core::ptr::null_mut(), + ops: &{ops} as *const ::kernel::bindings::kernel_param_ops, + perm: 0, // Will not appear in sysfs + level: -1, + flags: 0, + __bindgen_anon_1: + ::kernel::bindings::kernel_param__bindgen_ty_1 {{ + arg: {param_name}.as_mut_ptr().cast() + }}, + }}); + ", + module_name = info.name, + param_type = param.ptype, + param_default = param.default, + param_name = param.name, + ops = ops, + ) + .unwrap(); + } + } +} + +fn param_ops_path(param_type: &str) -> &'static str { + match param_type { + "i8" => "::kernel::module_param::PARAM_OPS_I8", + "u8" => "::kernel::module_param::PARAM_OPS_U8", + "i16" => "::kernel::module_param::PARAM_OPS_I16", + "u16" => "::kernel::module_param::PARAM_OPS_U16", + "i32" => "::kernel::module_param::PARAM_OPS_I32", + "u32" => "::kernel::module_param::PARAM_OPS_U32", + "i64" => "::kernel::module_param::PARAM_OPS_I64", + "u64" => "::kernel::module_param::PARAM_OPS_U64", + "isize" => "::kernel::module_param::PARAM_OPS_ISIZE", + "usize" => "::kernel::module_param::PARAM_OPS_USIZE", + t => panic!("Unsupported parameter type {}", t), } } +fn expect_param_default(param_it: &mut token_stream::IntoIter) -> String { + assert_eq!(expect_ident(param_it), "default"); + assert_eq!(expect_punct(param_it), ':'); + let default = try_literal(param_it).expect("Expected default param value"); + assert_eq!(expect_punct(param_it), ','); + default +} + #[derive(Debug, Default)] struct ModuleInfo { type_: String, @@ -98,6 +199,50 @@ struct ModuleInfo { description: Option, alias: Option>, firmware: Option>, + params: Option>, +} + +#[derive(Debug)] +struct Parameter { + name: String, + ptype: String, + default: String, + description: String, +} + +fn expect_params(it: &mut token_stream::IntoIter) -> Vec { + let params = expect_group(it); + assert_eq!(params.delimiter(), Delimiter::Brace); + let mut it = params.stream().into_iter(); + let mut parsed = Vec::new(); + + loop { + let param_name = match it.next() { + Some(TokenTree::Ident(ident)) => ident.to_string(), + Some(_) => panic!("Expected Ident or end"), + None => break, + }; + + assert_eq!(expect_punct(&mut it), ':'); + let param_type = expect_ident(&mut it); + let group = expect_group(&mut it); + assert_eq!(group.delimiter(), Delimiter::Brace); + assert_eq!(expect_punct(&mut it), ','); + + let mut param_it = group.stream().into_iter(); + let param_default = expect_param_default(&mut param_it); + let param_description = expect_string_field(&mut param_it, "description"); + expect_end(&mut param_it); + + parsed.push(Parameter { + name: param_name, + ptype: param_type, + default: param_default, + description: param_description, + }) + } + + parsed } impl ModuleInfo { @@ -112,6 +257,7 @@ fn parse(it: &mut token_stream::IntoIter) -> Self { "license", "alias", "firmware", + "params", ]; const REQUIRED_KEYS: &[&str] = &["type", "name", "license"]; let mut seen_keys = Vec::new(); @@ -140,6 +286,7 @@ fn parse(it: &mut token_stream::IntoIter) -> Self { "license" => info.license = expect_string_ascii(it), "alias" => info.alias = Some(expect_string_array(it)), "firmware" => info.firmware = Some(expect_string_array(it)), + "params" => info.params = Some(expect_params(it)), _ => panic!( "Unknown key \"{}\". Valid keys are: {:?}.", key, EXPECTED_KEYS @@ -183,28 +330,30 @@ pub(crate) fn module(ts: TokenStream) -> TokenStream { let info = ModuleInfo::parse(&mut it); let mut modinfo = ModInfoBuilder::new(info.name.as_ref()); - if let Some(author) = info.author { - modinfo.emit("author", &author); + if let Some(author) = &info.author { + modinfo.emit("author", author); } - if let Some(description) = info.description { - modinfo.emit("description", &description); + if let Some(description) = &info.description { + modinfo.emit("description", description); } modinfo.emit("license", &info.license); - if let Some(aliases) = info.alias { + if let Some(aliases) = &info.alias { for alias in aliases { - modinfo.emit("alias", &alias); + modinfo.emit("alias", alias); } } - if let Some(firmware) = info.firmware { + if let Some(firmware) = &info.firmware { for fw in firmware { - modinfo.emit("firmware", &fw); + modinfo.emit("firmware", fw); } } // Built-in modules also export the `file` modinfo string. let file = std::env::var("RUST_MODFILE").expect("Unable to fetch RUST_MODFILE environmental variable"); - modinfo.emit_only_builtin("file", &file); + modinfo.emit_only_builtin("file", &file, false); + + modinfo.emit_params(&info); format!( " @@ -358,14 +507,17 @@ unsafe fn __exit() {{ __MOD.assume_init_drop(); }} }} - {modinfo} }} }} + mod module_parameters {{ + {params} + }} ", type_ = info.type_, name = info.name, modinfo = modinfo.buffer, + params = modinfo.param_buffer, initcall_section = ".initcall6.init" ) .parse() diff --git a/samples/rust/rust_minimal.rs b/samples/rust/rust_minimal.rs index 4aaf117bf8e3c0cc77e188b1ad0708e3650a6654..d999a77c6eb9a0db9acf5fa03d4feca5e6525fc8 100644 --- a/samples/rust/rust_minimal.rs +++ b/samples/rust/rust_minimal.rs @@ -10,6 +10,12 @@ author: "Rust for Linux Contributors", description: "Rust minimal sample", license: "GPL", + params: { + test_parameter: i64 { + default: 1, + description: "This parameter has a default of 1", + }, + }, } struct RustMinimal { @@ -20,6 +26,10 @@ impl kernel::Module for RustMinimal { fn init(_module: &'static ThisModule) -> Result { pr_info!("Rust minimal sample (init)\n"); pr_info!("Am I built-in? {}\n", !cfg!(MODULE)); + pr_info!( + "My parameter: {}\n", + *module_parameters::test_parameter.get() + ); let mut numbers = KVec::new(); numbers.push(72, GFP_KERNEL)?; diff --git a/scripts/Makefile.build b/scripts/Makefile.build index c16e4cf54d770fd2cf585a65dc4ad9b6a6bd6e42..dabae1007afcb376218e65b022df72c494c8ab51 100644 --- a/scripts/Makefile.build +++ b/scripts/Makefile.build @@ -213,7 +213,7 @@ $(obj)/%.lst: $(obj)/%.c FORCE # Compile Rust sources (.rs) # --------------------------------------------------------------------------- -rust_allowed_features := asm_const,asm_goto,arbitrary_self_types,lint_reasons +rust_allowed_features := asm_const,asm_goto,arbitrary_self_types,lint_reasons,sync_unsafe_cell # `--out-dir` is required to avoid temporaries being created by `rustc` in the # current working directory, which may be not accessible in the out-of-tree