ldd ch06: create a struct with completion

completion can be created with bindings::completion::default().

Basic file operation works as below.

/ # insmod share/rust_ldd06.ko
[    8.451416] rust_ldd06: module verification failed: signature and/or required key missing - tainting kernel
[    8.454343] rust_completion: rust_ldd06 is loaded
[    8.455645] rust_completion: completion_dev created
/ # cat /proc/misc
124 rust_ldd06
227 mcelog
125 udmabuf
237 loop-control
126 ecryptfs
127 userfaultfd
183 hw_random
/ # mknod /dev/rust_ldd06 c 10 124
/ # cat /dev/rust_ldd06
[   82.667663] rust_completion: open is invoked
[   82.668955] rust_completion: read is invoked
[   82.670173] rust_completion: release is invoked
/ # echo "asdf" > /dev/rust_ldd06
[   91.791434] rust_completion: open is invoked
[   91.792801] rust_completion: write: 5 bytes
[   91.794002] rust_completion: release is invoked
/ # rmmod rust_ldd06
[  106.630100] rust_completion: rust_ldd06 is unloaded

Signed-off-by: Gioh Kim <[email protected]>

Author: gurugio

rust/bindings/bindings_helper.h

@@ -22,6 +22,7 @@
 #include <linux/miscdevice.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/completion.h>
 
 /* `bindgen` gets confused at certain things. */
 const size_t BINDINGS_ARCH_SLAB_MINALIGN = ARCH_SLAB_MINALIGN;

samples/rust/Kconfig

@@ -71,4 +71,11 @@ config SAMPLE_RUST_LDD05
 
 	  If unsure, say N.
 
+config SAMPLE_RUST_LDD06
+	tristate "LDD06
+	help
+	  This option builds the Linux Device Driver examples in Rust.
+
+	  If unsure, say N.
+
 endif # SAMPLES_RUST

samples/rust/Makefile

@@ -7,5 +7,6 @@ obj-$(CONFIG_SAMPLE_RUST_LDD02)			+= rust_ldd02.o
 obj-$(CONFIG_SAMPLE_RUST_LDD03)			+= rust_ldd03.o
 obj-$(CONFIG_SAMPLE_RUST_LDD04)			+= rust_ldd04.o
 obj-$(CONFIG_SAMPLE_RUST_LDD05)			+= rust_ldd05.o
+obj-$(CONFIG_SAMPLE_RUST_LDD06)			+= rust_ldd06.o
 
 subdir-$(CONFIG_SAMPLE_RUST_HOSTPROGS)		+= hostprogs

samples/rust/rust_ldd06.rs

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Rust LDD scull
+//! reference: https://github.com/d0u9/Linux-Device-Driver/tree/master/eg_03_scull_basic
+//!
+//! How to build only modules:
+//! make LLVM=1 M=samples/rust
+use core::marker::PhantomPinned;
+use kernel::prelude::*;
+use kernel::{
+    bindings,
+    file::{self, File},
+    fmt,
+    io_buffer::{IoBufferReader, IoBufferWriter},
+    miscdev, pin_init,
+    sync::{Arc, ArcBorrow},
+    types::Opaque,
+};
+
+module! {
+    type: RustCompletion,
+    name: "rust_completion",
+    author: "Rust for Linux Contributors",
+    description: "Rust LDD ch06 scull",
+    license: "GPL",
+}
+
+// internal info between file operations
+#[pin_data]
+struct CompletionDev {
+    pub completion: bindings::completion,
+
+    #[pin]
+    _pin: PhantomPinned,
+}
+
+// TODO: impl CompletionDev::try_new
+impl CompletionDev {
+    fn try_new() -> Result<Arc<Self>> {
+        pr_info!("completion_dev created\n");
+
+        Ok(Arc::try_new(Self {
+            _pin: PhantomPinned,
+            completion: bindings::completion::default(),
+        })?)
+    }
+}
+
+unsafe impl Sync for CompletionDev {}
+unsafe impl Send for CompletionDev {}
+
+// unit struct for file operations
+struct RustFile;
+
+#[vtable]
+impl file::Operations for RustFile {
+    type Data = Arc<CompletionDev>;
+    type OpenData = Arc<CompletionDev>;
+
+    fn open(shared: &Arc<CompletionDev>, _file: &file::File) -> Result<Self::Data> {
+        pr_info!("open is invoked\n",);
+        Ok(shared.clone())
+    }
+
+    //
+    fn read(
+        shared: ArcBorrow<'_, CompletionDev>,
+        _: &File,
+        data: &mut impl IoBufferWriter,
+        offset: u64,
+    ) -> Result<usize> {
+        pr_info!("read is invoked\n");
+
+        Ok(0)
+    }
+
+    fn write(
+        shared: ArcBorrow<'_, CompletionDev>,
+        _: &File,
+        data: &mut impl IoBufferReader,
+        offset: u64,
+    ) -> Result<usize> {
+        pr_debug!("write is invoked\n");
+
+        let len: usize = data.len();
+        pr_info!("write: {} bytes\n", len);
+        Ok(len)
+    }
+
+    fn release(_data: Self::Data, _file: &File) {
+        pr_info!("release is invoked\n");
+    }
+}
+
+struct RustCompletion {
+    _dev: Pin<Box<miscdev::Registration<RustFile>>>,
+}
+
+impl kernel::Module for RustCompletion {
+    fn init(_module: &'static ThisModule) -> Result<Self> {
+        pr_info!("rust_ldd06 is loaded\n");
+
+        let dev: Arc<CompletionDev> = CompletionDev::try_new()?;
+        let reg = miscdev::Registration::new_pinned(fmt!("rust_ldd06"), dev)?;
+
+        Ok(RustCompletion { _dev: reg })
+    }
+}
+
+impl Drop for RustCompletion {
+    fn drop(&mut self) {
+        pr_info!("rust_ldd06 is unloaded\n");
+    }
+}