linux-kernel - Re: [PATCH v3 10/15] rust: pin-init: add `#[default_error(<type>)]` attribute to initializer macros

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives

Hash Suite: Windows password security audit tool. GUI, reports in PDF.

[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]

Message-Id: <DFOJFXOFPXAJ.S2X6PE9EMAG3@garyguo.net>
Date: Wed, 14 Jan 2026 18:53:35 +0000
From: "Gary Guo" <gary@...yguo.net>
To: "Benno Lossin" <lossin@...nel.org>, "Gary Guo" <gary@...yguo.net>,
 "Miguel Ojeda" <ojeda@...nel.org>, "Boqun Feng" <boqun.feng@...il.com>,
 Björn Roy Baron <bjorn3_gh@...tonmail.com>, "Andreas
 Hindborg" <a.hindborg@...nel.org>, "Alice Ryhl" <aliceryhl@...gle.com>,
 "Trevor Gross" <tmgross@...ch.edu>, "Danilo Krummrich" <dakr@...nel.org>
Cc: <rust-for-linux@...r.kernel.org>, <linux-kernel@...r.kernel.org>
Subject: Re: [PATCH v3 10/15] rust: pin-init: add `#[default_error(<type>)]`
 attribute to initializer macros

On Wed Jan 14, 2026 at 6:18 PM GMT, Benno Lossin wrote:
> The `#[default_error(<type>)]` attribute can be used to supply a default
> type as the error used for the `[pin_]init!` macros. This way one can
> easily define custom `try_[pin_]init!` variants that default to your
> project specific error type. Just write the following declarative macro:
>
>     macro_rules! try_init {
>         ($($args:tt)*) => {
>             ::pin_init::init!(
>                 #[default_error(YourCustomErrorType)]
>                 $($args)*
>             )
>         }
>     }
>
> Tested-by: Andreas Hindborg <a.hindborg@...nel.org>
> Signed-off-by: Benno Lossin <lossin@...nel.org>
> ---
> Changes in v3: none
> Changes in v2:
> * improve error handling
> * improve parsing and default error evaluation
> ---
>  rust/pin-init/internal/src/init.rs | 42 ++++++++++++++++++++++++++++--
>  1 file changed, 40 insertions(+), 2 deletions(-)
>
> diff --git a/rust/pin-init/internal/src/init.rs b/rust/pin-init/internal/src/init.rs
> index b0eb66224341..5a66016bdf33 100644
> --- a/rust/pin-init/internal/src/init.rs
> +++ b/rust/pin-init/internal/src/init.rs
> @@ -8,12 +8,13 @@
>      parse_quote,
>      punctuated::Punctuated,
>      spanned::Spanned,
> -    token, Block, Expr, ExprCall, ExprPath, Ident, Path, Token, Type,
> +    token, Attribute, Block, Expr, ExprCall, ExprPath, Ident, Path, Token, Type,
>  };
>  
>  use crate::diagnostics::{DiagCtxt, ErrorGuaranteed};
>  
>  pub(crate) struct Initializer {
> +    attrs: Vec<InitializerAttribute>,
>      this: Option<This>,
>      path: Path,
>      brace_token: token::Brace,
> @@ -54,8 +55,17 @@ fn ident(&self) -> Option<&Ident> {
>      }
>  }
>  
> +enum InitializerAttribute {
> +    DefaultError(DefaultErrorAttribute),
> +}
> +
> +struct DefaultErrorAttribute {
> +    ty: Type,
> +}

Given the size of the struct, I would actually just make this `Box<Type>`
instead of suppressing the clippy warning in the last patch.

Otherwise this looks good to me.

Reviewed-by: Gary Guo <gary@...yguo.net>

> +
>  pub(crate) fn expand(
>      Initializer {
> +        attrs,
>          this,
>          path,
>          brace_token,
> @@ -69,7 +79,16 @@ pub(crate) fn expand(
>  ) -> Result<TokenStream, ErrorGuaranteed> {
>      let error = error.map_or_else(
>          || {
> -            if let Some(default_error) = default_error {
> +            if let Some(default_error) = attrs.iter().fold(None, |acc, attr| {
> +                #[expect(irrefutable_let_patterns)]
> +                if let InitializerAttribute::DefaultError(DefaultErrorAttribute { ty }) = attr {
> +                    Some(ty.clone())
> +                } else {
> +                    acc
> +                }
> +            }) {
> +                default_error
> +            } else if let Some(default_error) = default_error {
>                  syn::parse_str(default_error).unwrap()
>              } else {
>                  dcx.error(brace_token.span.close(), "expected `? <type>` after `}`");
> @@ -358,6 +377,7 @@ fn make_field_check(
>  
>  impl Parse for Initializer {
>      fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
> +        let attrs = input.call(Attribute::parse_outer)?;
>          let this = input.peek(Token![&]).then(|| input.parse()).transpose()?;
>          let path = input.parse()?;
>          let content;
> @@ -389,7 +409,19 @@ fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
>              .peek(Token![?])
>              .then(|| Ok::<_, syn::Error>((input.parse()?, input.parse()?)))
>              .transpose()?;
> +        let attrs = attrs
> +            .into_iter()
> +            .map(|a| {
> +                if a.path().is_ident("default_error") {
> +                    a.parse_args::<DefaultErrorAttribute>()
> +                        .map(InitializerAttribute::DefaultError)
> +                } else {
> +                    Err(syn::Error::new_spanned(a, "unknown initializer attribute"))
> +                }
> +            })
> +            .collect::<Result<Vec<_>, _>>()?;
>          Ok(Self {
> +            attrs,
>              this,
>              path,
>              brace_token,
> @@ -400,6 +432,12 @@ fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
>      }
>  }
>  
> +impl Parse for DefaultErrorAttribute {
> +    fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
> +        Ok(Self { ty: input.parse()? })
> +    }
> +}
> +
>  impl Parse for This {
>      fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
>          Ok(Self {