rust: mem_cache: introduce MemCache

This is just the basics of `kmem_cache` to be used in file systems for
inodes. All dead-code annotations will be removed in the next commit.

Signed-off-by: Wedson Almeida Filho <[email protected]>

Author: wedsonaf

rust/bindings/bindings_helper.h

@@ -17,3 +17,7 @@
 const size_t BINDINGS_ARCH_SLAB_MINALIGN = ARCH_SLAB_MINALIGN;
 const gfp_t BINDINGS_GFP_KERNEL = GFP_KERNEL;
 const gfp_t BINDINGS___GFP_ZERO = __GFP_ZERO;
+
+const slab_flags_t BINDINGS_SLAB_RECLAIM_ACCOUNT = SLAB_RECLAIM_ACCOUNT;
+const slab_flags_t BINDINGS_SLAB_MEM_SPREAD = SLAB_MEM_SPREAD;
+const slab_flags_t BINDINGS_SLAB_ACCOUNT = SLAB_ACCOUNT;

rust/bindings/lib.rs

@@ -51,3 +51,7 @@ pub use bindings_raw::*;
 
 pub const GFP_KERNEL: gfp_t = BINDINGS_GFP_KERNEL;
 pub const __GFP_ZERO: gfp_t = BINDINGS___GFP_ZERO;
+
+pub const SLAB_RECLAIM_ACCOUNT: slab_flags_t = BINDINGS_SLAB_RECLAIM_ACCOUNT;
+pub const SLAB_MEM_SPREAD: slab_flags_t = BINDINGS_SLAB_MEM_SPREAD;
+pub const SLAB_ACCOUNT: slab_flags_t = BINDINGS_SLAB_ACCOUNT;

rust/kernel/lib.rs

@@ -38,6 +38,7 @@ pub mod init;
 pub mod ioctl;
 #[cfg(CONFIG_KUNIT)]
 pub mod kunit;
+pub mod mem_cache;
 pub mod prelude;
 pub mod print;
 mod static_assert;

rust/kernel/mem_cache.rs

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Kernel memory caches (kmem_cache).
+//!
+//! C headers: [`include/linux/slab.h`](../../include/linux/slab.h)
+
+use crate::error::{code::*, Result};
+use crate::{bindings, str::CStr};
+use core::ptr;
+
+/// A kernel memory cache.
+///
+/// This isn't ready to be made public yet because it only provides functionality useful for the
+/// allocation of inodes in file systems.
+pub(crate) struct MemCache {
+    ptr: ptr::NonNull<bindings::kmem_cache>,
+}
+
+impl MemCache {
+    /// Allocates a new `kmem_cache` for type `T`.
+    ///
+    /// `init` is called by the C code when entries are allocated.
+    #[allow(dead_code)]
+    pub(crate) fn try_new<T>(
+        name: &'static CStr,
+        init: Option<unsafe extern "C" fn(*mut core::ffi::c_void)>,
+    ) -> Result<Self> {
+        // SAFETY: `name` is static, so always valid.
+        let ptr = ptr::NonNull::new(unsafe {
+            bindings::kmem_cache_create(
+                name.as_char_ptr(),
+                core::mem::size_of::<T>().try_into()?,
+                core::mem::align_of::<T>().try_into()?,
+                bindings::SLAB_RECLAIM_ACCOUNT | bindings::SLAB_MEM_SPREAD | bindings::SLAB_ACCOUNT,
+                init,
+            )
+        })
+        .ok_or(ENOMEM)?;
+
+        Ok(Self { ptr })
+    }
+
+    /// Returns the pointer to the `kmem_cache` instance, or null if it's `None`.
+    ///
+    /// This is a helper for functions like `alloc_inode_sb` where the cache is optional.
+    #[allow(dead_code)]
+    pub(crate) fn ptr(c: &Option<Self>) -> *mut bindings::kmem_cache {
+        match c {
+            Some(m) => m.ptr.as_ptr(),
+            None => ptr::null_mut(),
+        }
+    }
+}
+
+impl Drop for MemCache {
+    fn drop(&mut self) {
+        // SAFETY: Just an FFI call with no additional safety requirements.
+        unsafe { bindings::rcu_barrier() };
+
+        // SAFETY: `ptr` was previously returned by successful call to `kmem_cache_create`, so it's
+        // ok to destroy it here.
+        unsafe { bindings::kmem_cache_destroy(self.ptr.as_ptr()) };
+    }
+}