Re: [PATCH v11 2/7] rust: debugfs: Add support for read-only files

["Danilo Krummrich" <dakr@kernel.org>]

On Mon Sep 8, 2025 at 6:19 PM CEST, Greg Kroah-Hartman wrote:
> On Mon, Sep 08, 2025 at 04:59:16PM +0200, Danilo Krummrich wrote:

<snip>

>> We agree on the goal here, but unfortunately it's not really possible. There are
>> two options that were already exercised:
>> 
>> 	(1) Force that FooFiles (or FooDir) is bound to the lifetime of a
>> 	    reference of Foo with FooDir<&'a Foo>.
>> 
>> 	    This isn't workable because we then can't store both of them into
>> 	    the same parent structure.
>> 
>> 	(2) Reference count Foo (Arc<Foo>) and make FooDir own a referenc count
>> 	    of Foo.
>> 
>> 	    But this is bad for the mentioned reasons. :(
>> 
>> 	(3) The File<T> API we have now, which gives you the behavior you ask
>> 	    for with Scope<T>.
>> 
>> 	    Where Scope<T> creates a directory and owns the data you pass to it,
>> 	    e.g. a pci config descriptor.
>> 
>> 	    The user can create an arbitrary number of files exporting any of
>> 	    the fields in date that live in the scope and don't need to be tracked
>> 	    separately, i.e. don't create separate object instances.
>> 
>> 	    The directory (and hence all the files) is removed once the Scope<T>
>> 	    is dropped, including the data it owns.

<snip>

>> I can provide some working code later on (currently in a meeting). :)
>
> Working code for the simple "foo" example will be good.  Here's my
> horrible (and will not build) example I was trying to get to work.

Here it comes [1]. :)

[1] rust_debugfs_soc_info.rs

// SPDX-License-Identifier: GPL-2.0

//! Simple `debugfs::Scope` example.

use kernel::c_str;
use kernel::debugfs::{Dir, Scope};
use kernel::prelude::*;

module! {
    type: MyModule,
    name: "MyModule",
    description: "Just a simple test module.",
    license: "GPL",
}

#[derive(Debug)]
struct HwSocInfo {
    name: &'static CStr,
    ver: u32,
    id: u32,
}

impl HwSocInfo {
    fn new(name: &'static CStr, ver: u32, id: u32) -> Self {
        Self { name, ver, id }
    }
}

struct MyModule {
    // Dropped when MyModule is released (e.g. through `rmmod`).
    //
    // This will drop the inner `HwSocInfo`, the "foo" directory, and all files created within this
    // directory.
    _scope: Pin<KBox<Scope<HwSocInfo>>>,
}

impl kernel::Module for MyModule {
    fn init(_module: &'static kernel::ThisModule) -> Result<Self, Error> {
        let root_dir = Dir::new(c_str!("my_module"));

        // Obtain some `HwSocInfo`, could from anywhere.
        let soc_info = HwSocInfo::new(c_str!("foo"), 24, 42);

        let scope = KBox::pin_init(
            // Create directory scope, that contains some data and a bunch of files exporting this
            // data.
            root_dir.scope(soc_info, c_str!("hw_soc_info"), |soc_info, dir| {
                dir.read_only_file(c_str!("name"), &soc_info.name);
                dir.read_only_file(c_str!("ver"), &soc_info.ver);
                dir.read_only_file(c_str!("id"), &soc_info.id);
            }),
            GFP_KERNEL,
        )?;

        // Print the contents of `soc_info` that were moved into `scope`.
        pr_info!("HwSocInfo: {:?}\n", &**scope);

        Ok(Self { _scope: scope })
    }
}