Commit 42523ceb authored by Lee Jones's avatar Lee Jones Committed by Greg Kroah-Hartman
Browse files

samples: rust_misc_device: Demonstrate additional get/set value functionality 



Expand the complexity of the sample driver by providing the ability to
get and set an integer.  The value is protected by a mutex.

Signed-off-by: default avatarLee Jones <lee@kernel.org>
Link: https://lore.kernel.org/r/20241213134715.601415-4-lee@kernel.org


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent fdb1ac6c

samples/rust/rust_misc_device.rs

+75 −14
Original line number Diff line number Diff line
@@ -4,17 +4,24 @@ 


//! Rust misc device sample.



use core::pin::Pin;



use kernel::{

    c_str,

    device::Device,

    fs::File,

    ioctl::_IO,

    ioctl::{_IO, _IOC_SIZE, _IOR, _IOW},

    miscdevice::{MiscDevice, MiscDeviceOptions, MiscDeviceRegistration},

    new_mutex,

    prelude::*,

    sync::Mutex,

    types::ARef,

    uaccess::{UserSlice, UserSliceReader, UserSliceWriter},

};



const RUST_MISC_DEV_HELLO: u32 = _IO('|' as u32, 0x80);

const RUST_MISC_DEV_GET_VALUE: u32 = _IOR::<i32>('|' as u32, 0x81);

const RUST_MISC_DEV_SET_VALUE: u32 = _IOW::<i32>('|' as u32, 0x82);



module! {

    type: RustMiscDeviceModule,
@@ -44,44 +51,98 @@ fn init(_module: &'static ThisModule) -> impl PinInit<Self, Error> { 
    }

}



struct Inner {

    value: i32,

}



#[pin_data(PinnedDrop)]

struct RustMiscDevice {

    #[pin]

    inner: Mutex<Inner>,

    dev: ARef<Device>,

}



#[vtable]

impl MiscDevice for RustMiscDevice {

    type Ptr = KBox<Self>;

    type Ptr = Pin<KBox<Self>>;



    fn open(_file: &File, misc: &MiscDeviceRegistration<Self>) -> Result<KBox<Self>> {

    fn open(_file: &File, misc: &MiscDeviceRegistration<Self>) -> Result<Pin<KBox<Self>>> {

        let dev = ARef::from(misc.device());



        dev_info!(dev, "Opening Rust Misc Device Sample\n");



        Ok(KBox::new(RustMiscDevice { dev }, GFP_KERNEL)?)

        KBox::try_pin_init(

            try_pin_init! {

                RustMiscDevice {

                    inner <- new_mutex!( Inner{ value: 0_i32 } ),

                    dev: dev,

                }

            },

            GFP_KERNEL,

        )

    }



    fn ioctl(

        me: <Self::Ptr as kernel::types::ForeignOwnable>::Borrowed<'_>,

        _file: &File,

        cmd: u32,

        _arg: usize,

    ) -> Result<isize> {

    fn ioctl(me: Pin<&RustMiscDevice>, _file: &File, cmd: u32, arg: usize) -> Result<isize> {

        dev_info!(me.dev, "IOCTLing Rust Misc Device Sample\n");



        let size = _IOC_SIZE(cmd);



        match cmd {

            RUST_MISC_DEV_HELLO => dev_info!(me.dev, "Hello from the Rust Misc Device\n"),

            RUST_MISC_DEV_GET_VALUE => me.get_value(UserSlice::new(arg, size).writer())?,

            RUST_MISC_DEV_SET_VALUE => me.set_value(UserSlice::new(arg, size).reader())?,

            RUST_MISC_DEV_HELLO => me.hello()?,

            _ => {

                dev_err!(me.dev, "-> IOCTL not recognised: {}\n", cmd);

                return Err(ENOTTY);

            }

        }

        };



        Ok(0)

    }

}



impl Drop for RustMiscDevice {

    fn drop(&mut self) {

#[pinned_drop]

impl PinnedDrop for RustMiscDevice {

    fn drop(self: Pin<&mut Self>) {

        dev_info!(self.dev, "Exiting the Rust Misc Device Sample\n");

    }

}



impl RustMiscDevice {

    fn set_value(&self, mut reader: UserSliceReader) -> Result<isize> {

        let new_value = reader.read::<i32>()?;

        let mut guard = self.inner.lock();



        dev_info!(

            self.dev,

            "-> Copying data from userspace (value: {})\n",

            new_value

        );



        guard.value = new_value;

        Ok(0)

    }



    fn get_value(&self, mut writer: UserSliceWriter) -> Result<isize> {

        let guard = self.inner.lock();

        let value = guard.value;



        // Free-up the lock and use our locally cached instance from here

        drop(guard);



        dev_info!(

            self.dev,

            "-> Copying data to userspace (value: {})\n",

            &value

        );



        writer.write::<i32>(&value)?;

        Ok(0)

    }



    fn hello(&self) -> Result<isize> {

        dev_info!(self.dev, "-> Hello from the Rust Misc Device\n");



        Ok(0)

    }

}