diff --git a/tools/trace-parser/rustfmt.toml b/.rustfmt.toml
similarity index 100%
rename from tools/trace-parser/rustfmt.toml
rename to .rustfmt.toml
diff --git a/lisa/_assets/kmodules/lisa/Makefile b/lisa/_assets/kmodules/lisa/Makefile
index 8db88eade79004231b98013b9fb99ceb594d7f14..857ef2eb4f8ae5101124a811e83d06f0e6e5fa04 100644
--- a/lisa/_assets/kmodules/lisa/Makefile
+++ b/lisa/_assets/kmodules/lisa/Makefile
@@ -50,6 +50,7 @@ RUST_C_SHIMS_DIR := $(RUST_BUILD_DIR)/rust_c_shims
 RUST_OBJECT_RAW := $(RUST_BUILD_DIR)/rust.raw.o
 RUST_SYMBOLS := $(RUST_BUILD_DIR)/exported.list
 RUST_SYMBOLS_CLI := $(RUST_BUILD_DIR)/exported.cli
+RUST_START_STOP_LDS := $(RUST_BUILD_DIR)/start_stop.lds
 
 RUST_CBINDGEN_H := $(RUST_SRC)/cbindgen.h
 RUST_CBINDGEN_BIN := $(CARGO_HOME)/bin/cbindgen
@@ -86,8 +87,15 @@ $(RUST_OBJECT_RAW): $(RUST_BUILD_DIR) $(CARGO_TARGET_DIR)
 
 
 $(RUST_OBJECT): $(RUST_BUILD_DIR) $(RUST_OBJECT_RAW)
-	# Get the list of exported symbols
-	python3 "$(MODULE_SRC)/rust_exported_symbols.py" --rust-object $(RUST_OBJECT_RAW) --out-symbols-plain $(RUST_SYMBOLS) --out-symbols-cli $(RUST_SYMBOLS_CLI)
+	# Get:
+	# * The list of exported symbols
+	# * A linker script with __start_SECNAME and __stop_SECNAME symbols so
+	#   that libraries relying on such encapsulation symbols like linkme
+	#   work, despite the fact that a kernel module is never linked into an
+	#   executable or DSO (a .ko is a relocatable object file) and
+	#   therefore never getting those symbols created by the linker
+	#   automatically.
+	python3 "$(MODULE_SRC)/rust_exported_symbols.py" --rust-object $(RUST_OBJECT_RAW) --out-symbols-plain $(RUST_SYMBOLS) --out-symbols-cli $(RUST_SYMBOLS_CLI) --out-start-stop-lds $(RUST_START_STOP_LDS)
 
 	# Garbage collect unused sections in the object file, after we have
 	# extracted the binstore sections (otherwise they get discarded).
@@ -96,7 +104,7 @@ $(RUST_OBJECT): $(RUST_BUILD_DIR) $(RUST_OBJECT_RAW)
 	# EXTERN() command in a linker script since older GNU ld version seem
 	# to ignore the EXTERN() command with --gc-sections.
 	$(LD) --version
-	$(LD) $(KBUILD_LDFLAGS) $$(cat $(RUST_SYMBOLS_CLI)) --gc-sections -nostdlib -r -o $(RUST_OBJECT) $(RUST_OBJECT_RAW)
+	$(LD) $(KBUILD_LDFLAGS) $$(cat $(RUST_SYMBOLS_CLI)) -T $(RUST_LDS) -T $(RUST_START_STOP_LDS) --gc-sections -nostdlib -r -o $(RUST_OBJECT) $(RUST_OBJECT_RAW)
 
 	# Only keep as GLOBAL symbols the ones that are to be exported (and the
 	# undefined ones to be provided by C code)
@@ -167,7 +175,7 @@ SYMBOL_NAMESPACES_H := $(GENERATED)/symbol_namespaces.h
 MODULE_VERSION_H := $(GENERATED)/module_version.h
 KALLSYMS := $(GENERATED)/kallsyms
 
-ldflags-y += -T $(FEATURES_LDS) -T $(RUST_LDS) -T $(SYMBOLS_LDS)
+ldflags-y += -T $(FEATURES_LDS) -T $(SYMBOLS_LDS)
 
 INTROSPECTION_DATA_H := $(GENERATED)/introspection_data.h
 
diff --git a/lisa/_assets/kmodules/lisa/features.h b/lisa/_assets/kmodules/lisa/features.h
index b03c5e48c0bcad9c855b2dbe0a29641dea2bb54f..b739d78bb18c4cf8494f00620fe8167fe2a55e24 100644
--- a/lisa/_assets/kmodules/lisa/features.h
+++ b/lisa/_assets/kmodules/lisa/features.h
@@ -62,22 +62,7 @@ int __placeholder_deinit(struct feature *feature);
 
 #define __FEATURE_NAME(name) __lisa_feature_##name
 
-/* Weak definition, can be useful to deal with compiled-out features */
-#define __DEFINE_FEATURE_WEAK(feature_name)				\
-	__attribute__((weak)) DEFINE_MUTEX(__lisa_mutex_feature_##feature_name); \
-	__attribute__((weak)) struct feature __FEATURE_NAME(feature_name) = { \
-		.name = #feature_name,					\
-		.data = NULL,						\
-		.enabled = 0,						\
-		.__explicitly_enabled = 0,				\
-		.enable = __placeholder_init,				\
-		.disable = __placeholder_deinit,			\
-		.lock = &__lisa_mutex_feature_##feature_name,		\
-		.__internal = true,					\
-		.__enable_ret = 0,					\
-	};
-
-#define __DEFINE_FEATURE_STRONG(feature_name, enable_f, disable_f, internal)	\
+#define __DEFINE_FEATURE(feature_name, enable_f, disable_f, internal)	\
 	DEFINE_MUTEX(__lisa_mutex_feature_##feature_name);		\
 	struct feature __FEATURE_NAME(feature_name) __attribute__((unused,section(".__lisa_features"))) = { \
 		.name = #feature_name,					\
@@ -102,7 +87,7 @@ int __placeholder_deinit(struct feature *feature);
  * DISABLE_FEATURE() on all the features that were enabled by ENABLE_FEATURE()
  * in enable_f() in order to keep accurate reference-counting.
  */
-#define DEFINE_FEATURE(feature_name, enable_f, disable_f) __DEFINE_FEATURE_STRONG(feature_name, enable_f, disable_f, false)
+#define DEFINE_FEATURE(feature_name, enable_f, disable_f) __DEFINE_FEATURE(feature_name, enable_f, disable_f, false)
 
 /**
  * DEFINE_INTERNAL_FEATURE() - Same as DEFINE_FEATURE() but for internal features.
@@ -112,23 +97,7 @@ int __placeholder_deinit(struct feature *feature);
  * multiple other features, e.g. to initialize and teardown the use of a kernel
  * API (workqueues, tracepoints etc).
  */
-#define DEFINE_INTERNAL_FEATURE(feature_name, enable_f, disable_f) __DEFINE_FEATURE_STRONG(feature_name, enable_f, disable_f, true)
-
-/**
- * DECLARE_FEATURE() - Declare a feature to test for its presence dynamically.
- * @feature_name: Name of the feature to declare.
- *
- * Very similar to DEFINE_FEATURE() but for user code that wants to deal with
- * features that might be entirely compiled-out. If the feature is compiled-in,
- * DECLARE_FEATURE() will essentially be a no-op. If the feature is
- * compiled-out, DECLARE_FEATURE() will still allow making use of it so that its
- * initialization fails with an error message, and its presence can be tested
- * with FEATURE_IS_AVAILABLE().
- *
- * Note that because of weak symbols limitations, a given compilation unit
- * cannot contain both DECLARE_FEATURE() and DEFINE_FEATURE().
- */
-#define DECLARE_FEATURE(feature_name) __DEFINE_FEATURE_WEAK(feature_name)
+#define DEFINE_INTERNAL_FEATURE(feature_name, enable_f, disable_f) __DEFINE_FEATURE(feature_name, enable_f, disable_f, true)
 
 /**
  * FEATURE() - Pointer the the struct feature
@@ -141,17 +110,6 @@ int __placeholder_deinit(struct feature *feature);
 	&__FEATURE_NAME(name);				\
 })
 
-/**
- * FEATURE_IS_AVAILABLE() - Runtime check if a feature is available.
- * @name: name of the feature
- *
- * Useful in conjunction with DECLARE_FEATURE() to test if a feature is available.
- * Note that it's not necessary to use it before calling
- * ENABLE_FEATURE()/DISABLE_FEATURE() in simple cases as they will fail with an
- * appropriate error message if the feature is missing.
- */
-#define FEATURE_IS_AVAILABLE(name) (FEATURE(name)->enable != &__placeholder_init)
-
 /**
  * ENABLE_FEATURE() - Enable a feature
  * @feature_name: Name of the feature, as a C identifier.
@@ -192,4 +150,31 @@ int init_features(char **selected, size_t selected_len);
  * Return: non-zero in case of errors.
  */
 int deinit_features(void);
+
+/**
+ * feature_name() - Get feature's name
+ * @feature: Pointer to feature to get the name of.
+ *
+ */
+static inline const char *feature_name(struct feature* feature) {
+	return feature->name;
+}
+
+/**
+ * feature_data() - Get feature's data pointer
+ * @feature: Pointer to feature to get the data of.
+ *
+ */
+static inline void *feature_data(struct feature* feature) {
+	return feature->data;
+}
+
+/**
+ * feature_set_data() - Set feature's data pointer
+ * @feature: Pointer to feature to set the data of.
+ *
+ */
+static inline void feature_data_set(struct feature* feature, void *data) {
+	feature->data = data;
+}
 #endif
diff --git a/lisa/_assets/kmodules/lisa/pixel6.c b/lisa/_assets/kmodules/lisa/pixel6.c
index 00db386483596ef000d28de6c01a4390b9e62c26..2f8934603c8b89c06859f46ecf7c6defef0c0884 100644
--- a/lisa/_assets/kmodules/lisa/pixel6.c
+++ b/lisa/_assets/kmodules/lisa/pixel6.c
@@ -128,7 +128,7 @@ static void read_and_process(char *buffer, unsigned int size, struct file *file,
 
 static int p6_emeter_worker(void *data) {
 	struct feature *feature = data;
-	struct p6_emeter_data *p6_emeter_data = feature->data;
+	struct p6_emeter_data *p6_emeter_data = feature_data(feature);
 	char content[POWER_METER_SAMPLE_FILE_MAX_SIZE];
 
 	read_and_process(content, ARRAY_SIZE(content), p6_emeter_data->sample_file_0, POWER_METER_SAMPLE_FILE_0, 0);
@@ -150,9 +150,9 @@ static int enable_p6_emeter(struct feature *feature) {
 	HANDLE_ERR(ENABLE_FEATURE(__workqueue))
 
 	data = kzalloc(sizeof(*data), GFP_KERNEL);
-	feature->data = data;
 	if (!data)
 		HANDLE_ERR(1);
+	feature_data_set(feature, data);
 
 	/* Note that this is the hardware sampling rate. Software will only see
 	 *an updated value every 8 hardware periods
@@ -185,7 +185,7 @@ finish:
 
 static int disable_p6_emeter(struct feature* feature) {
 	int ret = 0;
-	struct p6_emeter_data *data = feature->data;
+	struct p6_emeter_data *data = feature_data(feature);
 
 	if (data)
 		free_p6_emeter_data(data);
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/Cargo.lock b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/Cargo.lock
index 9524268281769d998ef007ebb7d9dbd9f49e76c8..b99020f2a499ae0e59168d6306dd4f460d558158 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/Cargo.lock
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/Cargo.lock
@@ -21,9 +21,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.164"
+version = "0.2.169"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "433bfe06b8c75da9b2e3fbea6e5329ff87748f0b144ef75306e674c3f6f7c13f"
+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
 
 [[package]]
 name = "lisakmod_macros"
@@ -60,18 +60,18 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "syn"
-version = "2.0.89"
+version = "2.0.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e"
+checksum = "70ae51629bf965c5c098cc9e87908a3df5301051a9e087d6f9bef5c9771ed126"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/cffi.h b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/cffi.h
index 09adb1711b4bdc4dcf44a398f4b51d7a87ced7ca..933540860ddca366e3c25150be554f74e499de83 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/cffi.h
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/cffi.h
@@ -1,5 +1,4 @@
 /* SPDX-License-Identifier: GPL-2.0 */
-#include <linux/types.h>
 
 /// Types defined in this header have ABI compatibility with some types
 /// manipulated in lisakmod_macros::inlinec module.
@@ -9,14 +8,23 @@
 #ifndef _CFFI_H
 #define _CFFI_H
 
+#include <linux/types.h>
+
+/* On recent kernels, kCFI is used instead of CFI and __cficanonical is therefore not
+ * defined anymore
+ */
+#ifndef __cficanonical
+#    define __cficanonical
+#endif
+
 struct slice_u8 {
 	uint8_t *data;
 	size_t len;
-};
+} __no_randomize_layout;
 
 struct slice_const_u8 {
 	const uint8_t *data;
 	const size_t len;
-};
+} __no_randomize_layout;
 
 #endif /* _CFFI_H */
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/Cargo.toml b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/Cargo.toml
index 6e2b94bb12965cb7bb65cbe71fc164c29cfb0596..e20f520626918266f05c5ee559b8ee6f8073a5ce 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/Cargo.toml
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lisakmod_macros_proc"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 syn = { version = "2.0", default-features = false, features = ["proc-macro", "parsing", "printing", "full", "clone-impls"]}
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/src/inlinec.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/src/inlinec.rs
index eb5b64b28bbdd71037a11b10c936967485ec0afe..5fe019a758670ffaa243226a2e8d07535737d7f3 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/src/inlinec.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/src/inlinec.rs
@@ -162,8 +162,36 @@ fn _make_c_func(
 ) -> Result<(TokenStream, TokenStream, TokenStream), Error> {
     let c_name_str: String = c_name.to_string();
     let f_where = f_generics.map(|x| x.where_clause.clone());
-    let c_proto = format!("{c_name_str}_proto");
-    let c_ret_ty = format!("{c_name_str}_ret_ty");
+
+    let c_type_of = |ty| {
+        (
+            quote! {
+                {
+                    // Use a const fn to introduce f_generics and f_where
+                    const fn get #f_generics() -> &'static str #f_where {
+                        (
+                            <#ty as ::lisakmod_macros::inlinec::FfiType>::C_TYPE
+                        )
+                    }
+                    get()
+                }
+            },
+            quote! {
+                {
+                    // Use a const fn to introduce f_generics and f_where
+                    const fn get #f_generics() -> &'static str #f_where {
+                        (
+                            match <#ty as ::lisakmod_macros::inlinec::FfiType>::C_HEADER {
+                                Some(c_header) => c_header,
+                                None => "linux/types.h",
+                            }
+                        )
+                    }
+                    get()
+                }
+            },
+        )
+    };
 
     let (pre_c_code, c_code, post_c_code) = c_code;
     // TODO: Due to this issue, the span reported by syn is currently always going to have
@@ -191,62 +219,60 @@ fn _make_c_func(
     };
 
     let c_nr_args = f_args.len();
-    let (arg_names, arg_tys): (Vec<_>, Vec<_>) = f_args.iter().cloned().unzip();
-    let c_args_name: Vec<_> = arg_names.iter().map(|name| name.to_string()).collect();
+    let (args_name, args_ty): (Vec<_>, Vec<_>) = f_args.iter().cloned().unzip();
+    let c_args_name: Vec<_> = args_name.iter().map(|name| name.to_string()).collect();
     let c_args_commas: Vec<_> = c_args_name
         .iter()
         .enumerate()
         .map(|(i, _)| if i == (c_nr_args - 1) { "" } else { ", " })
         .collect();
-    let (c_args_ty_macro, c_args_ty_typedef): (Vec<_>, Vec<_>) = arg_names
-        .iter()
-        .map(|arg| {
-            (
-                format!("{c_name_str}_arg_ty_macro_{arg}"),
-                format!("{c_name_str}_arg_ty_typedef_{arg}"),
-            )
-        })
-        .unzip();
-
-    // Argument types are encoded as a function-like macro. Calling this macro with an
-    // identifier declares a variable (or function argument) of that type.  This allows using
-    // any type, including more complex ones like arrays and function pointers.
-    let c_args_typedef = concatcp(quote! {
-        #(
-            "\n",
-            "#define ", #c_args_ty_macro, "(DECLARATOR)",
-            {
-                // Use a const fn to introduce f_generics and f_where
-                const fn get #f_generics() -> &'static str #f_where {
-                    <#arg_tys as ::lisakmod_macros::inlinec::FfiType>::C_DECL
-                }
-                get()
-            },
-            "\n",
-            "typedef ", #c_args_ty_macro, "(", #c_args_ty_typedef ,");"
-        ),*
-    })?;
 
-    let c_args = if c_nr_args == 0 {
-        quote! { "void "}
+    let (c_args, c_args_header) = if c_nr_args == 0 {
+        (quote! { "void" }, quote! { "" })
     } else {
-        concatcp(quote! {
-            #(
-                #c_args_ty_typedef, " ", #c_args_name,
-                #c_args_commas
-            ),*
-        })?
+        let (c_args_ty, c_args_header): (Vec<_>, Vec<_>) = args_ty.iter().map(c_type_of).unzip();
+        (
+            concatcp(quote! {
+                #(
+                    "__typeof__(" , #c_args_ty, ") ", #c_args_name,
+                    #c_args_commas
+                ),*
+            })?,
+            concatcp(quote! {
+                #(
+                    "#include \"" , #c_args_header, "\"\n"
+                ),*
+            })?,
+        )
     };
 
     let rust_extern_args = quote! {
         #(
-            #arg_names : <#arg_tys as ::lisakmod_macros::inlinec::FfiType>::FfiType
+            #args_name : <#args_ty as ::lisakmod_macros::inlinec::FfiType>::FfiType
         ),*
     };
 
     let pre_c_code = pre_c_code.unwrap_or(quote! {""});
     let post_c_code = post_c_code.unwrap_or(quote! {""});
 
+    // Disabling CFI inside the function allows us to call anything we want, including Rust
+    // functions if needed.
+    c_attrs.push(quote! {"__nocfi"});
+
+    let (c_ret_ty, c_ret_header) = c_type_of(f_ret_ty);
+    let c_proto = concatcp(quote! {
+        #c_args_header,
+        "\n",
+        "#include \"", #c_ret_header, "\"",
+        "\n",
+        #c_ret_ty, " ", #(#c_attrs, " "),* , " ", #c_name_str, "(", #c_args , ")",
+    })?;
+
+    let c_header_out = concatcp(quote! {
+        "\n#line ", #c_code_line, " \"", file!(), "\"\n",
+        #c_proto, ";\n",
+    })?;
+
     let c_funcdef = match c_code {
         Some(c_code) => concatcp(quote! {
             #c_proto,
@@ -257,47 +283,6 @@ fn _make_c_func(
         None => quote! {""},
     };
 
-    // Disabling CFI inside the function allows us to call anything we want, including Rust
-    // functions if needed.
-    c_attrs.push(quote!{"__nocfi"});
-
-    let c_header_out = concatcp(quote! {
-        r#"
-        #include <linux/types.h>
-
-        #define BUILTIN_TY_DECL(ty, declarator) ty declarator
-        #define PTR_TY_DECL(declarator) (*declarator)
-        #define ARR_TY_DECL(N, declarator) ((declarator)[N])
-        #define CONST_TY_DECL(declarator) const declarator
-        #define ATTR_TY_DECL(attributes, declarator) attributes declarator
-        #define FN_TY_DECL(args, declarator) ((declarator)args)
-
-        /* On recent kernels, kCFI is used instead of CFI and __cficanonical is therefore not
-         * defined anymore
-         */
-        #ifndef __cficanonical
-        #    define __cficanonical
-        #endif
-        "#,
-
-        "#line ", #c_code_line, " \"", file!(), "\"\n",
-        #c_args_typedef,
-
-        // See comment on how arguments type are handled, as we do the same for the return
-        // type.
-        "\n#define ", #c_ret_ty, "(DECLARATOR)",
-        {
-            // Use a const fn to introduce f_generics and f_where
-            const fn get #f_generics() -> &'static str #f_where {
-                <#f_ret_ty as ::lisakmod_macros::inlinec::FfiType>::C_DECL
-            }
-            get()
-        },
-        "\n#define ", #c_proto, " ", #c_ret_ty, "(FN_TY_DECL((", #c_args, "), ATTR_TY_DECL(", #(#c_attrs, " ",)* ", ", #c_name_str, ")))",
-        "\n#line ", #c_code_line, " \"", file!(), "\"\n",
-        #c_proto, ";\n",
-    })?;
-
     let c_out = concatcp(quote! {
         "#line ", #pre_c_code_line, " \"", file!(), "\"\n",
         #pre_c_code,
@@ -333,7 +318,7 @@ pub fn cfunc(_attrs: TokenStream, code: TokenStream) -> Result<TokenStream, Erro
     let f_generics = input.f_generics;
     let f_where = f_generics.where_clause.clone();
 
-    let shim_name_str = format!("__lisa_c_shim_{name}_{}", get_random());
+    let shim_name_str = format!("__lisa_c_shim_{name}_{:0>39}", get_random());
     let shim_name = format_ident!("{}", shim_name_str);
     let c_out = make_c_func(
         Some(&shim_name),
@@ -345,15 +330,15 @@ pub fn cfunc(_attrs: TokenStream, code: TokenStream) -> Result<TokenStream, Erro
         input.c_code,
     )?;
 
-    let (arg_names, arg_tys): (Vec<_>, Vec<_>) = f_args.into_iter().unzip();
+    let (args_name, args_ty): (Vec<_>, Vec<_>) = f_args.into_iter().unzip();
     let rust_args = quote! {
         #(
-            #arg_names : #arg_tys
+            #args_name : #args_ty
         ),*
     };
     let rust_extern_call_args = quote! {
         #(
-            ::lisakmod_macros::inlinec::IntoFfi::into_ffi(#arg_names)
+            ::lisakmod_macros::inlinec::IntoFfi::into_ffi(#args_name)
         ),*
     };
 
@@ -557,7 +542,7 @@ pub fn cexport(attrs: TokenStream, code: TokenStream) -> Result<TokenStream, Err
     let mut item_fn = input.item_fn;
     let f_args = get_f_args(&item_fn)?;
     let f_ret_ty = get_f_ret_ty(&item_fn)?;
-    let (arg_names, arg_tys): (Vec<_>, Vec<_>) = f_args.iter().cloned().unzip();
+    let (args_name, args_ty): (Vec<_>, Vec<_>) = f_args.iter().cloned().unzip();
 
     fn ffi_ty(ty: Type) -> syn::Result<Type> {
         Ok(parse_quote! {
@@ -588,7 +573,7 @@ pub fn cexport(attrs: TokenStream, code: TokenStream) -> Result<TokenStream, Err
     let body = item_fn.block;
     item_fn.block = Box::new(parse_quote! {{
         #(
-            let #arg_names: #arg_tys = ::lisakmod_macros::inlinec::FromFfi::from_ffi(#arg_names);
+            let #args_name: #args_ty = ::lisakmod_macros::inlinec::FromFfi::from_ffi(#args_name);
         );*
         <#ret_ty as ::lisakmod_macros::inlinec::IntoFfi>::into_ffi(
             #body
@@ -596,7 +581,7 @@ pub fn cexport(attrs: TokenStream, code: TokenStream) -> Result<TokenStream, Err
     }});
 
     let name = item_fn.sig.ident;
-    let rust_name = format_ident!("__lisa_rust_shim_{name}_{}", get_random());
+    let rust_name = format_ident!("__lisa_rust_shim_{name}_{:0>39}", get_random());
     item_fn.sig.ident = rust_name.clone();
 
     // Make the Rust function unsafe since we call FromFfi::from_ffi()
@@ -621,7 +606,7 @@ pub fn cexport(attrs: TokenStream, code: TokenStream) -> Result<TokenStream, Err
     let call_rust_func = concatcp(quote! {
         "return ", stringify!(#rust_name), "(",
             #(
-                stringify!(#arg_names),
+                stringify!(#args_name),
             )*
         ");"
     })?;
@@ -635,7 +620,7 @@ pub fn cexport(attrs: TokenStream, code: TokenStream) -> Result<TokenStream, Err
     let c_name = match attrs.export_name {
         None => match attrs.no_mangle {
             true => name.to_string(),
-            false => format!("__lisa_c_shim_{name}_{}", get_random()),
+            false => format!("__lisa_c_shim_{name}_{:0>39}", get_random()),
         },
         Some(name) => {
             export_markers.push(_export_symbol(format_ident!("{name}"))?);
@@ -684,7 +669,7 @@ pub fn cexport(attrs: TokenStream, code: TokenStream) -> Result<TokenStream, Err
 
 pub fn export_symbol(args: TokenStream) -> Result<TokenStream, Error> {
     let ident = syn::parse2::<Ident>(args)?;
-    _export_symbol(ident).map(Into::into)
+    _export_symbol(ident)
 }
 
 fn _export_symbol(ident: Ident) -> Result<TokenStream, Error> {
@@ -707,7 +692,7 @@ fn make_c_out(c_code: TokenStream, section: &str) -> Result<TokenStream, Error>
 
             // Store the C function in a section of the binary, that will be extracted by the
             // module Makefile and compiled separately as C code.
-            #[link_section = #section ]
+            #[unsafe(link_section = #section)]
             #[used]
             static CODE: [u8; CODE_LEN] = ::lisakmod_macros::private::misc::slice_to_array::<{CODE_LEN}>(CODE_SLICE);
         };
@@ -823,10 +808,19 @@ pub fn cstatic(attrs: TokenStream, code: TokenStream) -> Result<TokenStream, Err
     let c_name = match attrs.export_name {
         None => match attrs.no_mangle {
             true => name.to_string(),
-            false => format!("__lisa_c_shim_{name}_{}", get_random()),
+            false => format!("__lisa_c_shim_{name}_{:0>39}", get_random()),
         },
         Some(name) => name,
     };
+    let c_typecheck_name = format!("{c_name}_typecheck_{:0>39}", get_random());
+
+    let c_type = quote! { <#ty as ::lisakmod_macros::inlinec::FfiType>::C_TYPE };
+    let c_header = quote! {
+        match <#ty as ::lisakmod_macros::inlinec::FfiType>::C_HEADER {
+            Some(c_header) => c_header,
+            None => "linux/types.h",
+        }
+    };
 
     let section = format!(".binstore.c.code.{}", c_name);
     let c_out = concatcp(quote! {
@@ -834,13 +828,13 @@ pub fn cstatic(attrs: TokenStream, code: TokenStream) -> Result<TokenStream, Err
         "\n#line ", #pre_c_code_line, " \"", file!(), "\"\n",
         #pre_c_code,
         "\n#line ", #c_code_line, " \"", file!(), "\"\n",
+        "#include \"", #c_header, "\"\n",
+        "\n#line ", #c_code_line, " \"", file!(), "\"\n",
         #c_code,
 
         // Check that the variable created by the user has the correct type by taking its address
         // in a pointer to the type we expect.
-        "\n#define DECLARATOR PTR_TY_DECL(", #c_name, "_type_check)\n",
-        "static  __attribute__ ((unused)) ", <#ty as ::lisakmod_macros::inlinec::FfiType>::C_DECL, " = &", #c_name, ";\n",
-        "#undef DECLARATOR",
+        "static  __attribute__ ((unused)) __typeof__(", #c_type, ") *", #c_typecheck_name, " = &", #c_name, ";\n",
 
         "\n#line ", #post_c_code_line, " \"", file!(), "\"\n",
         #post_c_code,
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/src/misc.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/src/misc.rs
index e15b53d262eb672ff687e7e656d324c534343d93..9dcb07948dad01c1298a4dd047031d0b4f73f596 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/src/misc.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/macros/src/misc.rs
@@ -26,7 +26,7 @@ pub(crate) fn concatcp(args: TokenStream) -> Result<TokenStream, Error> {
 
     let item_names: Vec<Ident> = items
         .iter()
-        .map(|_| format_ident!("__concat_item_{}", get_random()))
+        .map(|_| format_ident!("__concat_item_{:0>39}", get_random()))
         .collect();
 
     let out = quote! {
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/src/inlinec.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/src/inlinec.rs
index 0cbc512399b28cbf02960ed2f7ee34d29ed6313c..4224330e3cf5acbbfaea98303abc0b2e787ec4e0 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/src/inlinec.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod-macros/src/inlinec.rs
@@ -18,7 +18,8 @@ pub trait FfiType {
     // TODO: if and when Rust gains const trait methods, we can just define a const function to
     // build a type rather than providing a C macro body and C preprocessor machinery to build full
     // type names.
-    const C_DECL: &'static str;
+    const C_TYPE: &'static str;
+    const C_HEADER: Option<&'static str>;
     type FfiType;
 }
 
@@ -101,7 +102,8 @@ macro_rules! impl_ptr {
             T: Sized,
             $nested_ptr: FfiType,
         {
-            const C_DECL: &'static str = <$nested_ptr as FfiType>::C_DECL;
+            const C_TYPE: &'static str = <$nested_ptr as FfiType>::C_TYPE;
+            const C_HEADER: Option<&'static str> = <$nested_ptr as FfiType>::C_HEADER;
             type FfiType = <$nested_ptr as FfiType>::FfiType;
         }
 
@@ -207,7 +209,8 @@ where
     T: ?Sized,
     ConstPtr<T>: FfiType,
 {
-    const C_DECL: &'static str = <ConstPtr<T> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <ConstPtr<T> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <ConstPtr<T> as FfiType>::C_HEADER;
     type FfiType = <ConstPtr<T> as FfiType>::FfiType;
 }
 
@@ -239,7 +242,8 @@ where
     T: ?Sized,
     ConstPtr<ConstPtr<T>>: FfiType,
 {
-    const C_DECL: &'static str = <ConstPtr<ConstPtr<T>> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <ConstPtr<ConstPtr<T>> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <ConstPtr<ConstPtr<T>> as FfiType>::C_HEADER;
     type FfiType = <ConstPtr<ConstPtr<T>> as FfiType>::FfiType;
 }
 
@@ -248,7 +252,8 @@ where
     T: ?Sized,
     ConstPtr<MutPtr<T>>: FfiType,
 {
-    const C_DECL: &'static str = <ConstPtr<MutPtr<T>> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <ConstPtr<MutPtr<T>> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <ConstPtr<MutPtr<T>> as FfiType>::C_HEADER;
     type FfiType = <ConstPtr<MutPtr<T>> as FfiType>::FfiType;
 }
 
@@ -257,7 +262,8 @@ where
     T: ?Sized,
     MutPtr<T>: FfiType,
 {
-    const C_DECL: &'static str = <MutPtr<T> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <MutPtr<T> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <MutPtr<T> as FfiType>::C_HEADER;
     type FfiType = <MutPtr<T> as FfiType>::FfiType;
 }
 
@@ -289,7 +295,8 @@ where
     T: ?Sized,
     MutPtr<ConstPtr<T>>: FfiType,
 {
-    const C_DECL: &'static str = <MutPtr<ConstPtr<T>> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <MutPtr<ConstPtr<T>> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <MutPtr<ConstPtr<T>> as FfiType>::C_HEADER;
     type FfiType = <MutPtr<ConstPtr<T>> as FfiType>::FfiType;
 }
 
@@ -298,7 +305,8 @@ where
     T: ?Sized,
     MutPtr<MutPtr<T>>: FfiType,
 {
-    const C_DECL: &'static str = <MutPtr<MutPtr<T>> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <MutPtr<MutPtr<T>> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <MutPtr<MutPtr<T>> as FfiType>::C_HEADER;
     type FfiType = <MutPtr<MutPtr<T>> as FfiType>::FfiType;
 }
 
@@ -330,17 +338,29 @@ impl<T: ?Sized> PtrToMaybeSized<T> for *mut T {
     }
 }
 
+impl<T> FfiType for Option<&T>
+where
+    T: ?Sized,
+    *const T: PtrToMaybeSized<T>,
+    ConstPtr<T>: FfiType,
+{
+    const C_TYPE: &'static str = <ConstPtr<T> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <ConstPtr<T> as FfiType>::C_HEADER;
+    type FfiType = <ConstPtr<T> as FfiType>::FfiType;
+}
+
 impl<T> FfiType for &T
 where
     T: ?Sized,
     *const T: PtrToMaybeSized<T>,
     ConstPtr<T>: FfiType,
 {
-    const C_DECL: &'static str = <ConstPtr<T> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <ConstPtr<T> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <ConstPtr<T> as FfiType>::C_HEADER;
     type FfiType = <ConstPtr<T> as FfiType>::FfiType;
 }
 
-impl<T> FromFfi for &T
+impl<T> FromFfi for Option<&T>
 where
     T: ?Sized,
     ConstPtr<T>: FfiType + FromFfi,
@@ -349,7 +369,33 @@ where
     unsafe fn from_ffi(x: Self::FfiType) -> Self {
         let ptr = <ConstPtr<T> as FromFfi>::from_ffi(x).0;
         assert!(PtrToMaybeSized::is_aligned(&ptr).unwrap_or(true));
-        ptr.as_ref().expect("Unexpected NULL pointer")
+        ptr.as_ref()
+    }
+}
+
+impl<'a, T> FromFfi for &'a T
+where
+    T: ?Sized,
+    ConstPtr<T>: FfiType + FromFfi,
+{
+    #[inline]
+    unsafe fn from_ffi(x: Self::FfiType) -> Self {
+        <Option<&'a T> as FromFfi>::from_ffi(x).expect("Unexpected NULL pointer")
+    }
+}
+
+impl<T> IntoFfi for Option<&T>
+where
+    // We need Sized here so that we can use core::ptr::null()
+    T: Sized,
+    ConstPtr<T>: FfiType + IntoFfi,
+{
+    #[inline]
+    fn into_ffi(self) -> Self::FfiType {
+        match self {
+            Some(x) => x.into_ffi(),
+            None => null::<T>().into_ffi(),
+        }
     }
 }
 
@@ -364,16 +410,27 @@ where
     }
 }
 
-impl<T> FfiType for &mut T
+impl<T> FfiType for Option<&mut T>
 where
     T: ?Sized,
     MutPtr<T>: FfiType,
 {
-    const C_DECL: &'static str = <MutPtr<T> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <MutPtr<T> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <MutPtr<T> as FfiType>::C_HEADER;
     type FfiType = <MutPtr<T> as FfiType>::FfiType;
 }
 
-impl<T> FromFfi for &mut T
+impl<'a, T> FfiType for &'a mut T
+where
+    T: ?Sized,
+    MutPtr<T>: FfiType,
+{
+    const C_TYPE: &'static str = <Option<&'a mut T> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <Option<&'a mut T> as FfiType>::C_HEADER;
+    type FfiType = <Option<&'a mut T> as FfiType>::FfiType;
+}
+
+impl<T> FromFfi for Option<&mut T>
 where
     T: ?Sized,
     *mut T: PtrToMaybeSized<T>,
@@ -383,7 +440,34 @@ where
     unsafe fn from_ffi(x: Self::FfiType) -> Self {
         let ptr = <MutPtr<T> as FromFfi>::from_ffi(x).0;
         assert!(PtrToMaybeSized::is_aligned(&ptr).unwrap_or(true));
-        ptr.as_mut().expect("Unexpected NULL pointer")
+        ptr.as_mut()
+    }
+}
+
+impl<'a, T> FromFfi for &'a mut T
+where
+    T: ?Sized,
+    *mut T: PtrToMaybeSized<T>,
+    MutPtr<T>: FfiType + FromFfi,
+{
+    #[inline]
+    unsafe fn from_ffi(x: Self::FfiType) -> Self {
+        <Option<&'a mut T> as FromFfi>::from_ffi(x).expect("Unexpected NULL pointer")
+    }
+}
+
+impl<T> IntoFfi for Option<&mut T>
+where
+    // We need Sized here so that we can use core::ptr::null_mut()
+    T: Sized,
+    MutPtr<T>: FfiType + IntoFfi,
+{
+    #[inline]
+    fn into_ffi(self) -> Self::FfiType {
+        match self {
+            Some(x) => x.into_ffi(),
+            None => null_mut::<T>().into_ffi(),
+        }
     }
 }
 
@@ -406,7 +490,8 @@ where
 {
     // Expose as a mutable pointer for C code, since the whole point of UnsafeCell<T> is to allow
     // mutation of T from a &UnsafeCell<T>.
-    const C_DECL: &'static str = <MutPtr<T> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <MutPtr<T> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <MutPtr<T> as FfiType>::C_HEADER;
     // Expose the pointer as *const for the FFI functions so that the signatures are compatible
     // with the other blanket implementations. This will effectively transmute the *const
     // UnsafeCell<T> into *mut T in the IntoFfi implementation at the FFI boundary.
@@ -418,7 +503,8 @@ where
     T: ?Sized,
     MutPtr<T>: FfiType,
 {
-    const C_DECL: &'static str = <MutPtr<T> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <MutPtr<T> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <MutPtr<T> as FfiType>::C_HEADER;
     type FfiType = *mut UnsafeCell<T>;
 }
 
@@ -428,7 +514,8 @@ macro_rules! impl_transparent_wrapper {
         where
             T: FfiType,
         {
-            const C_DECL: &'static str = <T as FfiType>::C_DECL;
+            const C_TYPE: &'static str = <T as FfiType>::C_TYPE;
+            const C_HEADER: Option<&'static str> = <T as FfiType>::C_HEADER;
             type FfiType = <T as FfiType>::FfiType;
         }
 
@@ -436,7 +523,8 @@ macro_rules! impl_transparent_wrapper {
         where
             ConstPtr<T>: FfiType,
         {
-            const C_DECL: &'static str = <ConstPtr<T> as FfiType>::C_DECL;
+            const C_TYPE: &'static str = <ConstPtr<T> as FfiType>::C_TYPE;
+            const C_HEADER: Option<&'static str> = <ConstPtr<T> as FfiType>::C_HEADER;
             type FfiType = *const $wrapper;
         }
 
@@ -444,7 +532,8 @@ macro_rules! impl_transparent_wrapper {
         where
             MutPtr<T>: FfiType,
         {
-            const C_DECL: &'static str = <MutPtr<T> as FfiType>::C_DECL;
+            const C_TYPE: &'static str = <MutPtr<T> as FfiType>::C_TYPE;
+            const C_HEADER: Option<&'static str> = <MutPtr<T> as FfiType>::C_HEADER;
             type FfiType = *mut $wrapper;
         }
     };
@@ -481,43 +570,44 @@ where
 
 #[macro_export]
 macro_rules! __impl_primitive_ptr {
-    ($pointee:ty, $c_pointee:literal) => {
+    ($pointee:ty, $c_pointee:literal, $c_header:expr) => {
         $crate::inlinec::__impl_primitive_ptr!(
-            @impl, $pointee, $pointee, $c_pointee,
-            "", ""
+            @impl, $pointee, $pointee, $c_header, $c_pointee
         );
 
         // TODO: These implementations are necessary since we cannot currently have a recursive
-        // implementation for ConstPtr<ConstPtr<T>>, because we cannot express the resulting C_DECL
+        // implementation for ConstPtr<ConstPtr<T>>, because we cannot express the resulting C_TYPE
         // (lack of const function in traits). We therefore unroll 2 level of pointers, since we
         // don't really need more in practice.
         $crate::inlinec::__impl_primitive_ptr!(
             @impl,
             $crate::inlinec::ConstPtr<$pointee>,
             <$crate::inlinec::ConstPtr<$pointee> as $crate::inlinec::FfiType>::FfiType,
-            $c_pointee,
-            "CONST_TY_DECL(PTR_TY_DECL(", "))"
+            $c_header,
+            "const __typeof__(", $c_pointee, ") *"
         );
         $crate::inlinec::__impl_primitive_ptr!(
             @impl,
             $crate::inlinec::MutPtr<$pointee>,
             <$crate::inlinec::MutPtr<$pointee> as $crate::inlinec::FfiType>::FfiType,
-            $c_pointee,
-            "PTR_TY_DECL(", ")"
+            $c_header,
+            "__typeof__(", $c_pointee, ") *"
         );
     };
-    (@impl, $pointee:ty, $ffi_pointee:ty, $c_pointee:literal, $decl_pre:literal, $decl_post:literal) => {
+    (@impl, $pointee:ty, $ffi_pointee:ty, $c_header:expr, $($c_pointee:literal),*) => {
         impl $crate::inlinec::FfiType for $crate::inlinec::ConstPtr<$pointee> {
-            const C_DECL: &'static str = $crate::misc::concatcp!(
-                "BUILTIN_TY_DECL(", $c_pointee, ", ", $decl_pre, "CONST_TY_DECL(PTR_TY_DECL(DECLARATOR))", $decl_post, ")"
+            const C_TYPE: &'static str = $crate::misc::concatcp!(
+                "const __typeof__(", $($c_pointee),*, ") *"
             );
+            const C_HEADER: Option<&'static str> = $c_header;
             type FfiType = *const $ffi_pointee;
         }
 
         impl $crate::inlinec::FfiType for $crate::inlinec::MutPtr<$pointee> {
-            const C_DECL: &'static str = $crate::misc::concatcp!(
-                "BUILTIN_TY_DECL(", $c_pointee, ", ", $decl_pre, "PTR_TY_DECL(DECLARATOR)", $decl_post, ")"
+            const C_TYPE: &'static str = $crate::misc::concatcp!(
+                "__typeof__(", $($c_pointee),*, ") *"
             );
+            const C_HEADER: Option<&'static str> = $c_header;
             type FfiType = *mut $ffi_pointee;
         }
     }
@@ -525,10 +615,10 @@ macro_rules! __impl_primitive_ptr {
 pub use crate::__impl_primitive_ptr;
 
 macro_rules! impl_primitive {
-    ($ty:ty, $c_name:literal) => {
+    ($ty:ty, $c_name:literal, $c_header:expr) => {
         impl FfiType for $ty {
-            const C_DECL: &'static str =
-                $crate::misc::concatcp!("BUILTIN_TY_DECL(", $c_name, ", DECLARATOR)");
+            const C_TYPE: &'static str = $c_name;
+            const C_HEADER: Option<&'static str> = $c_header;
             type FfiType = $ty;
         }
 
@@ -546,28 +636,29 @@ macro_rules! impl_primitive {
             }
         }
 
-        __impl_primitive_ptr!($ty, $c_name);
+        __impl_primitive_ptr!($ty, $c_name, $c_header);
     };
 }
 
-impl_primitive!(u8, "uint8_t");
-impl_primitive!(u16, "uint16_t");
-impl_primitive!(u32, "uint32_t");
-impl_primitive!(u64, "uint64_t");
-impl_primitive!(usize, "size_t");
+impl_primitive!(u8, "uint8_t", Some("linux/types.h"));
+impl_primitive!(u16, "uint16_t", Some("linux/types.h"));
+impl_primitive!(u32, "uint32_t", Some("linux/types.h"));
+impl_primitive!(u64, "uint64_t", Some("linux/types.h"));
+impl_primitive!(usize, "size_t", Some("linux/types.h"));
 
-impl_primitive!(i8, "int8_t");
-impl_primitive!(i16, "int16_t");
-impl_primitive!(i32, "int32_t");
-impl_primitive!(i64, "int64_t");
-impl_primitive!(isize, "ssize_t");
+impl_primitive!(i8, "int8_t", Some("linux/types.h"));
+impl_primitive!(i16, "int16_t", Some("linux/types.h"));
+impl_primitive!(i32, "int32_t", Some("linux/types.h"));
+impl_primitive!(i64, "int64_t", Some("linux/types.h"));
+impl_primitive!(isize, "ssize_t", Some("linux/types.h"));
 
-impl_primitive!(bool, "_Bool");
+impl_primitive!(bool, "_Bool", None);
 
 // This is used for function returning void exclusively. We never pass a void parameter to a
 // function.
 impl FfiType for () {
-    const C_DECL: &'static str = "BUILTIN_TY_DECL(void, DECLARATOR)";
+    const C_TYPE: &'static str = "void";
+    const C_HEADER: Option<&'static str> = None;
     type FfiType = ();
 }
 
@@ -584,11 +675,12 @@ impl IntoFfi for () {
 // This is used for C void pointers exclusively. The usage is distinct from a function returning
 // void, which is covered by the unit type ().
 impl FfiType for c_void {
-    const C_DECL: &'static str = "BUILTIN_TY_DECL(void, DECLARATOR)";
+    const C_TYPE: &'static str = "void";
+    const C_HEADER: Option<&'static str> = None;
     type FfiType = c_void;
 }
 // Only implement FromFfi/IntoFfi for pointers to c_void, never for c_void itself
-__impl_primitive_ptr!(c_void, "void");
+__impl_primitive_ptr!(c_void, "void", None);
 
 pub trait NullPtr {
     fn null_mut() -> *mut Self;
@@ -617,7 +709,8 @@ where
     T: ?Sized,
     MutPtr<T>: FfiType,
 {
-    const C_DECL: &'static str = <MutPtr<T> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <MutPtr<T> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <MutPtr<T> as FfiType>::C_HEADER;
     type FfiType = <MutPtr<T> as FfiType>::FfiType;
 }
 
@@ -658,7 +751,8 @@ where
     T: ?Sized,
     Option<NonNull<T>>: FfiType,
 {
-    const C_DECL: &'static str = <Option<NonNull<T>> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <Option<NonNull<T>> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <Option<NonNull<T>> as FfiType>::C_HEADER;
     type FfiType = <Option<NonNull<T>> as FfiType>::FfiType;
 }
 
@@ -686,7 +780,8 @@ where
 }
 
 impl FfiType for Option<&CStr> {
-    const C_DECL: &'static str = <&'static c_char as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <&'static c_char as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <&'static c_char as FfiType>::C_HEADER;
     type FfiType = <&'static c_char as FfiType>::FfiType;
 }
 
@@ -712,7 +807,8 @@ impl FromFfi for Option<&CStr> {
 }
 
 impl<'a> FfiType for &'a CStr {
-    const C_DECL: &'static str = <Option<&'a CStr> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <Option<&'a CStr> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <Option<&'a CStr> as FfiType>::C_HEADER;
     type FfiType = <Option<&'a CStr> as FfiType>::FfiType;
 }
 
@@ -732,7 +828,8 @@ impl FromFfi for &CStr {
 }
 
 impl<'a> FfiType for &'a str {
-    const C_DECL: &'static str = <&'a CStr as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <&'a CStr as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <&'a CStr as FfiType>::C_HEADER;
     type FfiType = <&'a CStr as FfiType>::FfiType;
 }
 
@@ -749,7 +846,8 @@ impl FromFfi for &str {
 // &CStr for that.
 
 impl<'a> FfiType for Option<&'a str> {
-    const C_DECL: &'static str = <&'a CStr as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <&'a CStr as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <&'a CStr as FfiType>::C_HEADER;
     type FfiType = <&'a CStr as FfiType>::FfiType;
 }
 
@@ -792,22 +890,27 @@ where
 }
 
 macro_rules! impl_slice {
-    ($ty:ty, $c_name_const:literal, $c_name_mut:literal) => {
+    ($ty:ty, $c_name_const:literal, $c_name_mut:literal, $c_header:expr) => {
         impl FfiType for ConstPtr<[$ty]> {
-            const C_DECL: &'static str =
-                $crate::misc::concatcp!("BUILTIN_TY_DECL(", $c_name_const, ", DECLARATOR)");
+            const C_TYPE: &'static str = $c_name_const;
+            const C_HEADER: Option<&'static str> = Some($c_header);
             type FfiType = FfiSlice<*const $ty>;
         }
 
         impl FfiType for MutPtr<[$ty]> {
-            const C_DECL: &'static str =
-                $crate::misc::concatcp!("BUILTIN_TY_DECL(", $c_name_mut, ", DECLARATOR)");
+            const C_TYPE: &'static str = $c_name_mut;
+            const C_HEADER: Option<&'static str> = Some($c_header);
             type FfiType = FfiSlice<*mut $ty>;
         }
     };
 }
 
-impl_slice!(u8, "struct slice_const_u8", "struct slice_u8");
+impl_slice!(
+    u8,
+    "struct slice_const_u8",
+    "struct slice_u8",
+    "rust/lisakmod-macros/cffi.h"
+);
 
 impl<T> IntoFfi for ConstPtr<[T]>
 where
@@ -858,7 +961,8 @@ where
 }
 
 impl FfiType for Result<(), c_int> {
-    const C_DECL: &'static str = "BUILTIN_TY_DECL(int, DECLARATOR)";
+    const C_TYPE: &'static str = "int";
+    const C_HEADER: Option<&'static str> = None;
     type FfiType = c_int;
 }
 
@@ -883,7 +987,8 @@ impl FromFfi for Result<(), c_int> {
 }
 
 impl FfiType for Result<(), Infallible> {
-    const C_DECL: &'static str = "BUILTIN_TY_DECL(void, DECLARATOR)";
+    const C_TYPE: &'static str = "void";
+    const C_HEADER: Option<&'static str> = None;
     type FfiType = ();
 }
 
@@ -983,7 +1088,7 @@ pub trait Opaque {
 
 #[macro_export]
 macro_rules! __internal_opaque_type {
-    ($vis:vis struct $name:ident, $c_name:literal, $c_header:literal $(, $($opt_name:ident {$($opt:tt)*}),* $(,)?)?) => {
+    ($vis:vis struct $name:ident, $c_name:literal, $c_header:expr $(, $($opt_name:ident {$($opt:tt)*}),* $(,)?)?) => {
         // Model opaque types as recommended in the Rustonomicon:
         // https://doc.rust-lang.org/nomicon/ffi.html#representing-opaque-structs
         // On top of that recipe, we add:
@@ -1001,7 +1106,7 @@ macro_rules! __internal_opaque_type {
                 () as $crate::inlinec::GetAlignedData<
                     {
                         match $crate::inlinec::cconstant!(
-                            ("#include <", $c_header, ">"),
+                            ("#include \"", $c_header, "\""),
                             ("sizeof (", $c_name, ")"),
                         ) {
                             Some(x) => x,
@@ -1010,7 +1115,7 @@ macro_rules! __internal_opaque_type {
                     },
                     {
                         match $crate::inlinec::cconstant!(
-                            ("#include <", $c_header, ">"),
+                            ("#include \"", $c_header, "\""),
                             ("_Alignof (", $c_name, ")"),
                         ) {
                             Some(x) => x,
@@ -1048,13 +1153,14 @@ macro_rules! __internal_opaque_type {
             );
         };
 
-        $crate::inlinec::__impl_primitive_ptr!($name, $c_name);
+        $crate::inlinec::__impl_primitive_ptr!($name, $c_name, Some($c_header));
 
         use $crate::inlinec::Opaque as _;
         impl $crate::inlinec::Opaque for $name {}
         impl $crate::inlinec::FfiType for $name {
             type FfiType = $name;
-            const C_DECL: &'static str = $crate::misc::concatcp!("BUILTIN_TY_DECL(", $c_name, ", DECLARATOR)");
+            const C_TYPE: &'static str = $c_name;
+            const C_HEADER: Option<&'static str> = Some($c_header);
         }
 
         impl $crate::inlinec::FromFfi for $name {
@@ -1077,7 +1183,7 @@ macro_rules! __internal_opaque_type {
                 #[$crate::inlinec::cfunc]
                 fn get(this: &$name) -> &$attr_ty {
                     $crate::misc::concatcp!(
-                        "#include <", $c_header, ">\n"
+                        "#include \"", $c_header, "\"\n"
                     );
 
                     $crate::misc::concatcp!(
@@ -1095,7 +1201,7 @@ macro_rules! __internal_opaque_type {
                 #[$crate::inlinec::cfunc]
                 fn get(this: &mut $name) -> &mut $attr_ty {
                     $crate::misc::concatcp!(
-                        "#include <", $c_header, ">\n"
+                        "#include \"", $c_header, "\"\n"
                     );
 
                     $crate::misc::concatcp!(
@@ -1113,7 +1219,7 @@ macro_rules! __internal_opaque_type {
                 #[$crate::inlinec::cfunc]
                 fn get(this: &$name) -> $attr_ty {
                     $crate::misc::concatcp!(
-                        "#include <", $c_header, ">\n"
+                        "#include \"", $c_header, "\"\n"
                     );
 
                     $crate::misc::concatcp!(
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/Cargo.lock b/lisa/_assets/kmodules/lisa/rust/lisakmod/Cargo.lock
index 08322245ee4e018316923fd9779721fbf4f7f439..40e3bc50cb9a910c131a6e32083487eb10992605 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/Cargo.lock
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/Cargo.lock
@@ -2,12 +2,24 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "anyhow"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "either"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
+
 [[package]]
 name = "getrandom"
 version = "0.2.15"
@@ -19,16 +31,48 @@ dependencies = [
  "wasi",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "libc"
-version = "0.2.164"
+version = "0.2.169"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
+
+[[package]]
+name = "linkme"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "566336154b9e58a4f055f6dd4cbab62c7dc0826ce3c0a04e63b2d2ecd784cdae"
+dependencies = [
+ "linkme-impl",
+]
+
+[[package]]
+name = "linkme-impl"
+version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "433bfe06b8c75da9b2e3fbea6e5329ff87748f0b144ef75306e674c3f6f7c13f"
+checksum = "edbe595006d355eaf9ae11db92707d4338cd2384d16866131cc1afdbdd35d8d9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
 name = "lisakmod"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
+ "itertools",
+ "linkme",
  "lisakmod_macros",
 ]
 
@@ -67,18 +111,18 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "syn"
-version = "2.0.89"
+version = "2.0.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d46482f1c1c87acd84dea20c1bf5ebff4c757009ed6bf19cfd36fb10e92c4e"
+checksum = "70ae51629bf965c5c098cc9e87908a3df5301051a9e087d6f9bef5c9771ed126"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/Cargo.toml b/lisa/_assets/kmodules/lisa/rust/lisakmod/Cargo.toml
index 030518f152fe038c654e4d316ecdd0db614fb73c..dac8d0ad629fb61d71b210073de0365e0121d85c 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/Cargo.toml
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/Cargo.toml
@@ -1,5 +1,3 @@
-cargo-features = ["edition2024"]
-
 [package]
 name = "lisakmod"
 version = "0.1.0"
@@ -9,6 +7,9 @@ edition = "2024"
 crate-type = ["staticlib"]
 
 [dependencies]
+anyhow = { version = "1.0", default-features = false }
+itertools = {version = "0.13", default-features = false, features = ["use_alloc"]}
+linkme = "0.3.31"
 # hashbrown = "0.15"
 lisakmod_macros = { path = "../lisakmod-macros" }
 
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/bindings.h b/lisa/_assets/kmodules/lisa/rust/lisakmod/bindings.h
index 6048dcaedeb38e337ae9acf2c469fba915190f74..7d2f524aa82b03652a74f07bbe33486e44a96a7b 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/bindings.h
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/bindings.h
@@ -1,6 +1,14 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 
+#ifndef _RUST_BINDINGS_H
+#define _RUST_BINDINGS_H
+
+// cbindgen relies on ISO C types such as uint32_t
+#include <linux/types.h>
 #include "rust/lisakmod/cbindgen.h"
+
+// rust_c_shims.h relies on types defined in cffi.h
 #include "rust/lisakmod-macros/cffi.h"
 #include "generated/rust/rust_c_shims.h"
 
+#endif /* _RUST_BINDINGS_H */
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/cbindgen.h b/lisa/_assets/kmodules/lisa/rust/lisakmod/cbindgen.h
index 97fac2acd2a2eeae071a2d75b007121653e037bc..360d86c03daf0d23b7d7d2f94b25cb738d321c2f 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/cbindgen.h
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/cbindgen.h
@@ -4,6 +4,5 @@
 
 /* Warning, this file is autogenerated by Rust cbindgen. Don't modify this manually. */
 
-
 extern uint64_t myc_callback(uint64_t x);
 
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/runtime.c b/lisa/_assets/kmodules/lisa/rust/lisakmod/runtime.c
index ee2b8f15db50660c170676077587a9896d3b2fd1..4e8cc8d278b6d8c830a5b1a401c0684aaff3db29 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/runtime.c
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/runtime.c
@@ -1,9 +1,7 @@
 /* SPDX-License-Identifier: GPL-2.0 */
-#include "main.h"
-#include "rust/lisakmod/bindings.h"
 
 /* Basic glue between Rust runtime and kernel functions */
+#include "rust/lisakmod/bindings.h"
 
 /* C shims generated by the lisakmod_macros::inlinec module */
-#include "rust/lisakmod-macros/cffi.h"
 #include "generated/rust/rust_c_shims.c"
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/error.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0f82cbddcf5af5c0e6c891c02fe7ba598fea5f5c
--- /dev/null
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/error.rs
@@ -0,0 +1,157 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+use alloc::{sync::Arc, vec::Vec};
+use core::{error::Error as StdError, fmt};
+
+use anyhow;
+
+/// Cloneable error type suitable for memoization
+#[derive(Clone)]
+pub struct Error {
+    inner: Arc<anyhow::Error>,
+}
+
+macro_rules! error {
+    ($($args:tt)*) => { ::core::convert::Into::<$crate::error::Error>::into(::anyhow::anyhow!($($args)*)) }
+}
+
+pub(crate) use error;
+
+impl Error {
+    #[inline]
+    pub fn new<E>(err: E) -> Self
+    where
+        E: StdError + Send + Sync + 'static,
+    {
+        Error {
+            inner: Arc::new(err.into()),
+        }
+    }
+
+    #[inline]
+    fn context<C>(self, context: C) -> Self
+    where
+        C: fmt::Display + Send + Sync + 'static,
+    {
+        <Result<(), Self> as anyhow::Context<_, _>>::context(Err(self), context)
+            .unwrap_err()
+            .into()
+    }
+}
+
+impl From<anyhow::Error> for Error {
+    fn from(err: anyhow::Error) -> Error {
+        Error {
+            inner: Arc::new(err),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+impl fmt::Debug for Error {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
+impl StdError for Error {
+    #[inline]
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.inner.source()
+    }
+
+    // Unstable API
+    // #[inline]
+    // fn provide<'a>(&'a self, request: &mut core::Error::Request<'a>) {
+    // self.inner.provide()
+    // }
+}
+
+/// Mirror the anyhow::Context API, but returns the original Result<T, E> type rather than
+/// Result<T, anyhow::Error>
+pub trait ContextExt {
+    fn context<C>(self, context: C) -> Self
+    where
+        C: fmt::Display + Send + Sync + 'static;
+
+    fn with_context<C, F>(self, f: F) -> Self
+    where
+        C: fmt::Display + Send + Sync + 'static,
+        F: FnOnce() -> C;
+}
+
+impl<T, E> ContextExt for Result<T, E>
+where
+    E: From<anyhow::Error> + Send + Sync + StdError + 'static,
+{
+    #[inline]
+    fn context<C>(self, context: C) -> Self
+    where
+        C: fmt::Display + Send + Sync + 'static,
+    {
+        Ok(<Self as anyhow::Context<_, _>>::context(self, context)?)
+    }
+
+    #[inline]
+    fn with_context<C, F>(self, f: F) -> Self
+    where
+        C: fmt::Display + Send + Sync + 'static,
+        F: FnOnce() -> C,
+    {
+        Ok(<Self as anyhow::Context<_, _>>::with_context(self, f)?)
+    }
+}
+
+/// Combine multiple errors in a single value, so they can later be inspected or combined together.
+#[derive(Debug)]
+pub struct AllErrors<E> {
+    errors: Vec<E>,
+}
+
+impl<E> AllErrors<E>
+where
+    E: core::fmt::Display + Send + Sync + 'static,
+{
+    #[inline]
+    pub fn combine(self, err: Error) -> Result<(), Error> {
+        let errors = self.errors;
+        if errors.is_empty() {
+            Ok(())
+        } else {
+            Err(errors.into_iter().fold(err, Error::context))
+        }
+    }
+}
+
+impl<T, E> FromIterator<Result<T, E>> for AllErrors<E> {
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = Result<T, E>>,
+    {
+        let mut errors = Vec::new();
+        for x in iter {
+            if let Err(err) = x {
+                errors.push(err);
+            }
+        }
+        AllErrors { errors }
+    }
+}
+
+impl<E> FromIterator<E> for AllErrors<E> {
+    #[inline]
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = E>,
+    {
+        AllErrors {
+            errors: iter.into_iter().collect(),
+        }
+    }
+}
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/features/events/mod.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/features/events/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5e5081556a8fbd3f029a3e48b072cc6b80954b0d
--- /dev/null
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/features/events/mod.rs
@@ -0,0 +1,23 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+macro_rules! define_event_feature {
+    (struct $type:ident) => {
+        $crate::features::define_feature! {
+            struct $type,
+            name: concat!("event__", stringify!($type)),
+            visibility: Public,
+            Service: (),
+            Config: (),
+            dependencies: [],
+            init: |_| {
+                Ok($crate::lifecycle::new_lifecycle!(|services| {
+                    $crate::runtime::printk::pr_info!("Enabling ftrace event: {}", stringify!($type));
+                    yield_!(Ok(::alloc::sync::Arc::new(())));
+                    $crate::runtime::printk::pr_info!("Disabling ftrace event: {}", stringify!($type));
+                    Ok(())
+                }))
+            },
+        }
+    };
+}
+pub(crate) use define_event_feature;
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/features/mod.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/features/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4e8dfd2242a1c348b6f06711154d12061099a8e6
--- /dev/null
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/features/mod.rs
@@ -0,0 +1,532 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+pub mod events;
+pub mod pixel6;
+
+use alloc::{sync::Arc, vec::Vec};
+use core::{
+    any::{Any, TypeId, type_name},
+    ffi::c_int,
+    fmt::Debug,
+};
+
+use linkme::distributed_slice;
+
+use crate::{
+    error::{AllErrors, Error},
+    graph::{Cursor, DfsPostTraversal, Graph, TraversalDirection},
+    lifecycle::{self, LifeCycle, new_lifecycle},
+    runtime::{
+        printk::{pr_debug, pr_err},
+        sync::Lock,
+    },
+    typemap,
+};
+
+typemap::make_index!(pub FeaturesConfigIndex, Send);
+impl<Feat> typemap::KeyOf<FeaturesConfigIndex> for Feat
+where
+    Feat: 'static + Feature,
+{
+    type Value = Vec<<Feat as Feature>::Config>;
+}
+pub type FeaturesConfig = typemap::TypeMap<FeaturesConfigIndex>;
+
+typemap::make_index!(pub FeaturesServiceIndex, Send);
+impl<Feat> typemap::KeyOf<FeaturesServiceIndex> for Feat
+where
+    Feat: 'static + Feature,
+{
+    type Value = Arc<<Feat as Feature>::Service>;
+}
+pub type FeaturesService = typemap::TypeMap<FeaturesServiceIndex>;
+
+type LifeCycleAlias<Feat> = LifeCycle<FeaturesService, Arc<<Feat as Feature>::Service>, Error>;
+
+// Tie together a LifeCycle for a Feature and its associated Service type to guide type inference
+// and allow impl blocks, unlike LifeCycleAlias.
+pub struct FeatureLifeCycle<Feat: Feature> {
+    inner: LifeCycleAlias<Feat>,
+}
+
+impl<Feat: Feature> FeatureLifeCycle<Feat> {
+    fn new(lifecycle: LifeCycleAlias<Feat>) -> Self {
+        FeatureLifeCycle { inner: lifecycle }
+    }
+}
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone)]
+pub enum Visibility {
+    Public,
+    Private,
+}
+
+#[derive(PartialOrd, Ord, PartialEq, Eq, Debug)]
+pub struct FeatureId {
+    type_id: TypeId,
+    type_name: &'static str,
+}
+
+impl FeatureId {
+    fn new<Feat: 'static + Feature>() -> Self {
+        FeatureId {
+            type_id: TypeId::of::<Feat>(),
+            type_name: type_name::<Feat>(),
+        }
+    }
+}
+
+mod private {
+    use alloc::{boxed::Box, format, sync::Arc, vec::Vec};
+
+    use super::*;
+    use crate::{
+        error::{ContextExt, Error, error},
+        runtime::sync::Mutex,
+    };
+
+    pub struct LiveFeature {
+        lifecycle: Mutex<Box<dyn Any + Send>>,
+        feature: Arc<dyn Feature + Send + Sync>,
+        children_config: FeaturesConfig,
+    }
+
+    // Split some methods in a super trait so we can have a blanket implementation for those, so the
+    // user only needs to implement the fundamental methods on the concrete types.
+    #[diagnostic::on_unimplemented(
+        message = "Implement the Feature trait for `{Self}` and it will gain a blanket implementation of BlanketFeature automatically"
+    )]
+    #[doc(hidden)]
+    pub trait BlanketFeature {
+        fn __configure(
+            self: Arc<Self>,
+            parents: &mut dyn Iterator<Item = &Result<Option<LiveFeature>, Error>>,
+            from_user: &FeaturesConfig,
+        ) -> Result<LiveFeature, Error>;
+
+        fn __start(
+            &self,
+            live: &LiveFeature,
+            parents_service: &mut FeaturesService,
+            start_children: &mut dyn FnMut(&mut FeaturesService) -> Result<(), Error>,
+        ) -> Result<(), Error>;
+
+        fn __stop(
+            &self,
+            live: &LiveFeature,
+            stop_parents: &mut dyn FnMut() -> Result<(), Error>,
+        ) -> Result<(), Error>;
+
+        fn __id(&self) -> FeatureId;
+    }
+
+    impl<Feat> BlanketFeature for Feat
+    where
+        Feat: 'static + Feature + Send + Sync,
+    {
+        fn __configure(
+            self: Arc<Self>,
+            parents: &mut dyn Iterator<Item = &Result<Option<LiveFeature>, Error>>,
+            from_user: &FeaturesConfig,
+        ) -> Result<LiveFeature, Error> {
+            let name = self.name();
+            let mut from_parents = Vec::new();
+            for parent in parents {
+                match parent {
+                    Ok(Some(parent)) => {
+                        if let Some(configs) = parent.children_config.get::<Self>() {
+                            from_parents.extend(configs.iter())
+                        }
+                    }
+                    Ok(None) => {}
+                    Err(_) => {
+                        return Err(error!("Could not configure parent of feature {name}"));
+                    }
+                }
+            }
+            let empty = Vec::new();
+            let from_user = from_user.get::<Self>().unwrap_or(&empty);
+            let mut for_us = from_user.iter().chain(from_parents);
+            let (children_config, lifecycle) = self
+                .configure(&mut for_us)
+                .with_context(|| format!("Failed to configure feature {name}"))?;
+            let lifecycle = FeatureLifeCycle::<Feat>::new(lifecycle);
+            let lifecycle = Mutex::new(Box::new(lifecycle) as Box<dyn Any + Send>);
+
+            Ok(LiveFeature {
+                feature: self as Arc<dyn Feature + Send + Sync>,
+                lifecycle,
+                children_config,
+            })
+        }
+        fn __id(&self) -> FeatureId {
+            FeatureId::new::<Self>()
+        }
+
+        fn __start(
+            &self,
+            live: &LiveFeature,
+            parents_service: &mut FeaturesService,
+            start_children: &mut dyn FnMut(&mut FeaturesService) -> Result<(), Error>,
+        ) -> Result<(), Error> {
+            let mut lifecycle = live.lifecycle.lock();
+            let lifecycle: &mut FeatureLifeCycle<Feat> = lifecycle
+                .downcast_mut()
+                .expect("A LiveFeature for the wrong Feature was given");
+            let lifecycle = &mut lifecycle.inner;
+
+            let mut register_service = |service: &_| {
+                parents_service.insert::<Feat>(Arc::clone(service));
+            };
+
+            match lifecycle.state() {
+                lifecycle::State::Init | lifecycle::State::Finished(Ok(_)) => {
+                    let mut children_service = FeaturesService::new();
+                    start_children(&mut children_service)?;
+
+                    // INVARIANT: if a child failed to start, then we do not attempt starting the
+                    // current level. That means that a started node is always reachable from the
+                    // leaves by following a path of other started nodes. Therefore, a
+                    // partially-started graph can always be stopped by traversing it from the
+                    // leaves.
+                    let service = lifecycle
+                        .start(children_service)
+                        .with_context(|| format!("Failed to start feature {}", self.name()))?;
+
+                    register_service(service);
+                    Ok(())
+                }
+                lifecycle::State::Started(Ok(service)) => {
+                    register_service(service);
+                    Ok(())
+                }
+                lifecycle::State::Started(Err(err)) => Err(err),
+                // Disallow re-starting a feature that failed to finish properly, as external
+                // resources may be in an unknown state.
+                lifecycle::State::Finished(Err(err)) => Err(err),
+            }
+        }
+
+        fn __stop(
+            &self,
+            live: &LiveFeature,
+            stop_parents: &mut dyn FnMut() -> Result<(), Error>,
+        ) -> Result<(), Error> {
+            let lifecycle = &mut *live.lifecycle.lock();
+            let lifecycle: &mut FeatureLifeCycle<Feat> = lifecycle
+                .downcast_mut()
+                .expect("A LiveFeature for the wrong Feature was given");
+            let lifecycle = &mut lifecycle.inner;
+
+            match lifecycle.state() {
+                // We rely on the invariant that if a feature was not started, none of its parent
+                // can be started either so we don't need to explore that way.
+                lifecycle::State::Started(_) => {
+                    // Bail out if we cannot stop the parents, as it would be unsafe to stop ourselves if a
+                    // parent has failed to stop and might still be relying on us.
+                    stop_parents()?;
+
+                    pr_debug!("Stopping feature {}", self.name());
+                    lifecycle
+                        .stop()
+                        .with_context(|| format!("Failed to stop feature {}", self.name()))?;
+                    pr_debug!("Stopped feature {}", self.name());
+                    Ok(())
+                }
+                lifecycle::State::Init => Ok(()),
+                lifecycle::State::Finished(res) => res,
+            }
+        }
+    }
+
+    pub fn start_features(graph: &Graph<Option<LiveFeature>>) -> Result<(), Error> {
+        fn process(
+            cursor: &Cursor<'_, Option<LiveFeature>>,
+            parents_service: &mut FeaturesService,
+        ) -> Result<(), Error> {
+            match cursor.value() {
+                Some(live) => {
+                    let mut start_children = |children_service: &mut _| {
+                        cursor.children().try_for_each(|child| {
+                            process(&child, children_service).with_context(|| {
+                                format!(
+                                    "Failed to start feature {} as child of feature {}",
+                                    match child.value() {
+                                        Some(child) => child.feature.name(),
+                                        None => "<unselected feature>",
+                                    },
+                                    live.feature.name()
+                                )
+                            })
+                        })
+                    };
+                    live.feature
+                        .__start(live, parents_service, &mut start_children)
+                }
+                None => cursor
+                    .children()
+                    .try_for_each(|child| process(&child, &mut FeaturesService::new())),
+            }
+        }
+
+        let mut parents_service = FeaturesService::new();
+        graph
+            .roots()
+            .try_for_each(|root| process(&root, &mut parents_service))
+    }
+
+    pub fn stop_features(graph: &Graph<Option<LiveFeature>>) -> Result<(), Error> {
+        fn process(cursor: Cursor<Option<LiveFeature>>) -> Result<(), Error> {
+            match cursor.value() {
+                Some(live) => {
+                    let mut stop_parents = || {
+                        cursor
+                            .parents()
+                            .map(process)
+                            // Stop all the features we can and only then propagate all the issues we
+                            // encountered.
+                            .collect::<AllErrors<Error>>()
+                            .combine(error!(
+                                "Error while stopping children of feature {}",
+                                &live.feature.name()
+                            ))
+                    };
+                    live.feature.__stop(live, &mut stop_parents)
+                }
+                None => cursor
+                    .parents()
+                    .map(process)
+                    .collect::<AllErrors<Error>>()
+                    .combine(error!("Error while stopping features",)),
+            }
+        }
+
+        graph
+            .leaves()
+            .map(process)
+            .collect::<AllErrors<Error>>()
+            .combine(error!("Error while stopping features"))
+    }
+}
+
+pub trait Feature: private::BlanketFeature {
+    // Add Self: Sized bound for all associated types so that Feature is dyn-usable.
+    type Service: Send + Sync + Debug
+    where
+        Self: Sized;
+    type Config: Send
+    where
+        Self: Sized;
+
+    fn name(&self) -> &str;
+    fn visibility(&self) -> Visibility;
+
+    // This associated method allows getting a FeatureId when specifying the dependencies without
+    // having a live instance of the feature.
+    fn id() -> FeatureId
+    where
+        Self: 'static + Sized,
+    {
+        FeatureId::new::<Self>()
+    }
+
+    fn configure(
+        &self,
+        configs: &mut dyn Iterator<Item = &Self::Config>,
+    ) -> Result<
+        (
+            FeaturesConfig,
+            LifeCycle<FeaturesService, Arc<Self::Service>, Error>,
+        ),
+        Error,
+    >
+    where
+        Self: Sized;
+
+    fn dependencies(&self) -> Vec<FeatureId> {
+        Vec::new()
+    }
+}
+
+pub fn features_lifecycle<Select>(select: Select) -> LifeCycle<(), (), c_int>
+where
+    Select: Fn(&dyn Feature) -> bool,
+{
+    let graph: Graph<Arc<dyn Feature>> = Graph::new(
+        __FEATURES
+            .into_iter()
+            .map(|f| f())
+            .map(|feature| (feature.__id(), feature.dependencies(), feature)),
+    );
+
+    let graph = graph.dfs_map(DfsPostTraversal::new(
+        TraversalDirection::FromLeaves,
+        |value: Arc<dyn Feature>, mut parents: &mut dyn Iterator<Item = &Option<_>>| {
+            // Select a feature if it has been directly selected or if any of its parent has been
+            // selected.
+            let selected = (&mut parents).any(|parent| parent.is_some()) || select(&*value);
+            if selected { Some(value) } else { None }
+        },
+    ));
+
+    let from_user = &FeaturesConfig::new();
+    let configure =
+        |feature: Option<Arc<dyn Feature>>,
+         parents: &mut dyn Iterator<Item = &Result<Option<private::LiveFeature>, Error>>| {
+            match feature {
+                Some(feature) => feature.__configure(parents, from_user).map(Some),
+                None => Ok(None),
+            }
+        };
+    let graph = graph.dfs_map(DfsPostTraversal::new(
+        TraversalDirection::FromLeaves,
+        configure,
+    ));
+
+    let graph = Into::<Result<_, _>>::into(graph);
+    let graph = graph.expect("Error while configuring features");
+
+    new_lifecycle!(|_| {
+        // FIXME: clean that up
+        // use crate::runtime::sysfs::{KObjType, KObject};
+
+        // let root = KObject::module_root();
+        // let kobj_type = Arc::new(KObjType::new());
+        // let kobject = KObject::new(kobj_type.clone());
+        // let kobject2 = KObject::new(kobj_type.clone());
+        // kobject.add(Some(&root), "foo");
+        // kobject2.add(Some(&kobject), "bar");
+        if let Err(err) = private::start_features(&graph) {
+            pr_err!("Error while starting features: {err}");
+        }
+        let res = match crate::tests::init_tests() {
+            Err(x) => {
+                pr_err!("Lisa module Rust support validation failed: {x}");
+                Ok(())
+            }
+            Ok(()) => Ok(()),
+        };
+
+        yield_!(res);
+
+        if let Err(err) = private::stop_features(&graph) {
+            pr_err!("Error while stopping features: {err}");
+        }
+        Ok(())
+    })
+}
+
+pub struct InitBundle<Feat: Feature> {
+    pub configs: FeaturesConfig,
+    pub lifecycle: LifeCycleAlias<Feat>,
+}
+
+impl<Feat> From<LifeCycleAlias<Feat>> for InitBundle<Feat>
+where
+    Feat: Feature,
+{
+    fn from(lifecycle: LifeCycleAlias<Feat>) -> InitBundle<Feat> {
+        InitBundle {
+            configs: FeaturesConfig::new(),
+            lifecycle,
+        }
+    }
+}
+
+impl<Feat, Service> From<FeaturesConfig> for InitBundle<Feat>
+where
+    Service: 'static + Send + Sync + From<()>,
+    Feat: Feature<Service = Service>,
+{
+    fn from(configs: FeaturesConfig) -> InitBundle<Feat> {
+        InitBundle {
+            configs,
+            lifecycle: new_lifecycle!(|_| {
+                yield_!(Ok(Arc::new(().into())));
+                Ok(())
+            }),
+        }
+    }
+}
+
+impl<Feat> From<(FeaturesConfig, LifeCycleAlias<Feat>)> for InitBundle<Feat>
+where
+    Feat: Feature,
+{
+    fn from((configs, lifecycle): (FeaturesConfig, LifeCycleAlias<Feat>)) -> InitBundle<Feat> {
+        InitBundle { configs, lifecycle }
+    }
+}
+
+impl<Feat, Service> From<()> for InitBundle<Feat>
+where
+    Service: 'static + Send + Sync + From<()>,
+    Feat: Feature<Service = Service>,
+{
+    fn from(_: ()) -> InitBundle<Feat> {
+        InitBundle {
+            configs: FeaturesConfig::new(),
+            lifecycle: new_lifecycle!(|_| {
+                yield_!(Ok(Arc::new(().into())));
+                Ok(())
+            }),
+        }
+    }
+}
+
+macro_rules! define_feature {
+    (
+        $vis:vis struct $type:ident,
+        name: $name:expr,
+        visibility: $visibility:ident,
+        Service: $service:ty,
+        Config: $config:ty,
+        dependencies: [$($dep:ty),* $(,)?],
+        init: $init:expr,
+    ) => {
+        $vis struct $type;
+
+        const _: () = {
+            #[::linkme::distributed_slice($crate::features::__FEATURES)]
+            fn register() -> ::alloc::sync::Arc<dyn $crate::features::Feature> {
+                ::alloc::sync::Arc::new($type)
+            }
+        };
+
+        impl $crate::features::Feature for  $type {
+            type Service = $service;
+            type Config = $config;
+
+            fn name(&self) -> &str {
+                $name
+            }
+            fn visibility(&self) -> $crate::features::Visibility {
+                $crate::features::Visibility::$visibility
+            }
+
+            fn dependencies(&self) -> Vec<$crate::features::FeatureId> {
+                [$(<$dep>::id()),*].into()
+            }
+
+            fn configure(
+                &self,
+                configs: &mut dyn Iterator<Item = &Self::Config>,
+            ) -> Result<
+                (
+                    FeaturesConfig,
+                    LifeCycle<FeaturesService, Arc<Self::Service>, $crate::error::Error>,
+                ),
+                $crate::error::Error,
+            >
+            {
+                let init: Result<_, Error> = $init(configs);
+                let init: $crate::features::InitBundle<Self> = init?.into();
+                Ok((init.configs, init.lifecycle))
+            }
+        }
+    };
+}
+pub(crate) use define_feature;
+
+#[distributed_slice]
+pub static __FEATURES: [fn() -> Arc<dyn Feature>];
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/features/pixel6.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/features/pixel6.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d7578bd71cbbf7d3e586cc15862e951f14dcaaf4
--- /dev/null
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/features/pixel6.rs
@@ -0,0 +1,17 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+// use crate::{
+// features::{Feature, Visibility},
+// lifecycle::new_lifecycle,
+// };
+
+// fn make_feature() -> Feature {
+// Feature::new(
+// "pixel6".into(),
+// Visibility::Public,
+// new_lifecycle!({
+// yield Ok(());
+// Ok(())
+// }),
+// )
+// }
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/graph.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/graph.rs
new file mode 100644
index 0000000000000000000000000000000000000000..50ee98791e211f8ab5b18bbd244778d941533c66
--- /dev/null
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/graph.rs
@@ -0,0 +1,382 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+use alloc::{collections::BTreeMap, sync::Arc, vec::Vec};
+use core::cell::{Cell, OnceCell};
+
+use itertools::Itertools;
+
+use crate::error::AllErrors;
+
+pub struct Cursor<'a, T> {
+    graph: &'a Graph<T>,
+    idx: usize,
+}
+
+#[derive(Clone, Copy)]
+enum LinkType {
+    Child,
+    Parent,
+}
+
+impl LinkType {
+    #[inline]
+    fn from_direction(direction: TraversalDirection) -> Self {
+        match direction {
+            TraversalDirection::FromRoots => LinkType::Child,
+            TraversalDirection::FromLeaves => LinkType::Parent,
+        }
+    }
+}
+
+impl<'a, T> Cursor<'a, T> {
+    pub fn value(&self) -> &'a T {
+        &self.graph.nodes[self.idx]
+    }
+
+    pub fn children(&self) -> impl Iterator<Item = Self> {
+        self.linked(LinkType::Child)
+    }
+
+    pub fn parents(&self) -> impl Iterator<Item = Self> {
+        self.linked(LinkType::Parent)
+    }
+
+    #[inline]
+    fn linked(&self, typ: LinkType) -> impl Iterator<Item = Self> {
+        let graph = self.graph;
+        graph
+            .links
+            .linked(typ, self.idx)
+            .map(|idx| graph.cursor(idx))
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum TraversalDirection {
+    FromRoots,
+    FromLeaves,
+}
+
+pub struct MapState<T, U> {
+    // Allow stealing the old value to compute new
+    old: Cell<Option<T>>,
+    // Allows sharing &U once initialized, unlike what would happen if it was behind a Cell
+    // or RefCell
+    new: OnceCell<U>,
+}
+
+pub trait DfsTraversal<T, U> {
+    fn visit(&mut self, cursor: Cursor<'_, MapState<T, U>>, old: T);
+
+    fn direction(&self) -> TraversalDirection;
+
+    #[inline]
+    fn visit_linked(&mut self, cursor: &Cursor<MapState<T, U>>) {
+        let link_type = LinkType::from_direction(self.direction());
+        for linked in cursor.linked(link_type) {
+            self._visit(linked);
+        }
+    }
+
+    #[inline]
+    fn _visit(&mut self, cursor: Cursor<'_, MapState<T, U>>) {
+        let state = cursor.value();
+        let old = state.old.take();
+        // If None, that means we already visited that node or we are currently visiting it.
+        if let Some(old) = old {
+            self.visit(cursor, old);
+        }
+    }
+
+    fn traverse(&mut self, graph: Graph<T>) -> Graph<U> {
+        let graph = graph.map(|x| MapState {
+            old: Cell::new(Some(x)),
+            new: OnceCell::new(),
+        });
+
+        {
+            let nodes: &mut dyn Iterator<Item = _> = match self.direction() {
+                TraversalDirection::FromRoots => &mut graph.roots(),
+                TraversalDirection::FromLeaves => &mut graph.leaves(),
+            };
+            for root in nodes {
+                self._visit(root);
+            }
+        }
+
+        // We can unwrap() here as we processed the entire tree.
+        graph.map(|value| value.new.into_inner().unwrap())
+    }
+}
+
+pub struct DfsPreTraversal<F> {
+    f: F,
+    direction: TraversalDirection,
+}
+
+impl<F> DfsPreTraversal<F> {
+    pub fn new(direction: TraversalDirection, f: F) -> Self {
+        DfsPreTraversal { direction, f }
+    }
+}
+
+impl<T, U, F> DfsTraversal<T, U> for DfsPreTraversal<F>
+where
+    F: FnMut(T) -> U,
+{
+    #[inline]
+    fn visit(&mut self, cursor: Cursor<'_, MapState<T, U>>, old: T) {
+        cursor.value().new.get_or_init(|| (self.f)(old));
+        self.visit_linked(&cursor);
+    }
+
+    #[inline]
+    fn direction(&self) -> TraversalDirection {
+        self.direction
+    }
+}
+
+pub struct DfsPostTraversal<F> {
+    f: F,
+    direction: TraversalDirection,
+}
+
+impl<F> DfsPostTraversal<F> {
+    pub fn new(direction: TraversalDirection, f: F) -> Self {
+        DfsPostTraversal { direction, f }
+    }
+}
+
+impl<T, U, F> DfsTraversal<T, U> for DfsPostTraversal<F>
+where
+    F: FnMut(T, &mut dyn Iterator<Item = &U>) -> U,
+{
+    #[inline]
+    fn visit(&mut self, cursor: Cursor<'_, MapState<T, U>>, old: T) {
+        self.visit_linked(&cursor);
+        cursor.value().new.get_or_init(|| {
+            let mut linked = cursor
+                .linked(LinkType::from_direction(self.direction))
+                // We can unwrap() here as we have visited the linked nodes
+                // already. If the value is still None, that could only be because
+                // we have a loop in the graph, which is a bug.
+                .map(|linked| linked.value().new.get().unwrap());
+            (self.f)(old, &mut linked)
+        });
+    }
+
+    #[inline]
+    fn direction(&self) -> TraversalDirection {
+        self.direction
+    }
+}
+
+struct Links {
+    children: Vec<Vec<usize>>,
+    parents: Vec<Vec<usize>>,
+}
+
+impl Links {
+    pub fn roots(&self) -> impl Iterator<Item = usize> {
+        self.parents
+            .iter()
+            .enumerate()
+            .filter_map(
+                |(idx, parents)| {
+                    if parents.is_empty() { Some(idx) } else { None }
+                },
+            )
+    }
+
+    pub fn leaves(&self) -> impl Iterator<Item = usize> {
+        self.children
+            .iter()
+            .enumerate()
+            .filter_map(
+                |(idx, children)| {
+                    if children.is_empty() { Some(idx) } else { None }
+                },
+            )
+    }
+
+    #[inline]
+    fn linked(&self, typ: LinkType, idx: usize) -> impl Iterator<Item = usize> {
+        match typ {
+            LinkType::Child => &self.children[idx],
+            LinkType::Parent => &self.parents[idx],
+        }
+        .iter()
+        .copied()
+    }
+}
+
+#[derive(Clone)]
+pub struct Graph<T> {
+    nodes: Vec<T>,
+    links: Arc<Links>,
+}
+
+impl<T> Graph<T> {
+    pub fn new<Spec, NodeId, ChildrenId>(nodes: Spec) -> Self
+    where
+        NodeId: Ord,
+        Spec: IntoIterator<Item = (NodeId, ChildrenId, T)>,
+        ChildrenId: IntoIterator<Item = NodeId>,
+    {
+        let mut idx_map = BTreeMap::new();
+        let mut nodes_value = Vec::new();
+        let mut nodes_children_id = Vec::new();
+
+        for (idx, (id, children_id, value)) in nodes.into_iter().enumerate() {
+            idx_map.insert(id, idx);
+            nodes_children_id.push(children_id);
+            nodes_value.push(value);
+        }
+
+        let mut children_idx = Vec::new();
+        let mut parents_idx = Vec::new();
+        children_idx.resize(nodes_value.len(), Vec::new());
+        parents_idx.resize(nodes_value.len(), Vec::new());
+
+        for (node_idx, (node_children_id, node_children_idx)) in nodes_children_id
+            .into_iter()
+            .zip(&mut children_idx)
+            .enumerate()
+        {
+            for child_id in node_children_id {
+                match idx_map.get(&child_id) {
+                    Some(child_idx) => {
+                        let child_idx = *child_idx;
+                        node_children_idx.push(child_idx);
+                        parents_idx[child_idx].push(node_idx);
+                    }
+                    None => panic!("Could not find child node for parent node {node_idx}"),
+                }
+            }
+        }
+
+        Graph {
+            nodes: nodes_value,
+            links: Arc::new(Links {
+                parents: parents_idx,
+                children: children_idx,
+            }),
+        }
+    }
+
+    #[inline]
+    pub fn map<U, F>(self, f: F) -> Graph<U>
+    where
+        F: FnMut(T) -> U,
+    {
+        Graph {
+            links: self.links,
+            nodes: self.nodes.into_iter().map(f).collect(),
+        }
+    }
+
+    #[inline]
+    pub fn map_ref<U, F>(&self, f: F) -> Graph<U>
+    where
+        F: FnMut(&T) -> U,
+    {
+        Graph {
+            links: self.links.clone(),
+            nodes: self.nodes.iter().map(f).collect(),
+        }
+    }
+
+    pub fn dfs_map<U, Traversal>(self, mut traversal: Traversal) -> Graph<U>
+    where
+        Traversal: DfsTraversal<T, U>,
+    {
+        traversal.traverse(self)
+    }
+
+    fn cursor(&self, idx: usize) -> Cursor<'_, T> {
+        Cursor { graph: self, idx }
+    }
+
+    pub fn roots(&self) -> impl Iterator<Item = Cursor<'_, T>> {
+        self.links.roots().map(|idx| self.cursor(idx))
+    }
+
+    pub fn leaves(&self) -> impl Iterator<Item = Cursor<'_, T>> {
+        self.links.leaves().map(|idx| self.cursor(idx))
+    }
+
+    // FIXME: remove it if implementation is not finished
+    pub fn children_of<F>(self, filter: F) -> Self
+    where
+        F: Fn(&T) -> bool,
+    {
+        let select = |value, parents: &mut dyn Iterator<Item = &(bool, _)>| {
+            let selected = parents
+                .collect::<Vec<_>>()
+                .into_iter()
+                .any(|(selected, _)| *selected)
+                || filter(&value);
+            (selected, value)
+        };
+
+        let graph = self.dfs_map(DfsPostTraversal::new(
+            TraversalDirection::FromLeaves,
+            select,
+        ));
+
+        let filter_links = |links: &Vec<Vec<usize>>| {
+            links
+                .iter()
+                .map(|nodes_idx| {
+                    nodes_idx
+                        .iter()
+                        .copied()
+                        .filter(|idx: &usize| {
+                            let (selected, _) = &graph.nodes[*idx];
+                            *selected
+                        })
+                        .collect::<Vec<_>>()
+                })
+                .collect::<Vec<_>>()
+        };
+
+        let parents_idx = filter_links(&graph.links.parents);
+        let children_idx = filter_links(&graph.links.children);
+
+        let links = Arc::new(Links {
+            parents: parents_idx,
+            children: children_idx,
+        });
+
+        // graph.nodes.into_iter().map(|(selected, value)|).collect(),
+        // for node in graph.nodes.into_iter() {
+
+        // }
+
+        // Graph {
+        // links: self.links,
+        // nodes: self.nodes.into_iter().map(f).collect(),
+        // }
+
+        // for node in self.
+
+        // for node in self.roots() {
+        // if filter(node.value())
+        // }
+        todo!()
+    }
+}
+
+impl<T, E> From<Graph<Result<T, E>>> for Result<Graph<T>, AllErrors<E>> {
+    fn from(graph: Graph<Result<T, E>>) -> Result<Graph<T>, AllErrors<E>> {
+        let (err, ok): (Vec<E>, Vec<T>) = graph.nodes.into_iter().partition_map(Into::into);
+        if err.is_empty() {
+            Ok(Graph {
+                nodes: ok,
+                links: graph.links,
+            })
+        } else {
+            Err(err.into_iter().collect())
+        }
+    }
+}
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/init.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/init.rs
index c30a565206676c6d52337629f937e27754b9f40d..3142b1e3057ef5cb01e73caf1631cac804998bc8 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/init.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/init.rs
@@ -1,25 +1,66 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 
+use alloc::{sync::Arc, vec::Vec};
 use core::ffi::c_int;
 
-use crate::runtime::printk::pr_err;
-
-pub fn module_main() -> impl Iterator<Item = c_int> {
-    gen {
-        // use crate::runtime::sysfs::{KObjType, KObject};
-
-        // let root = KObject::module_root();
-        // let kobj_type = Arc::new(KObjType::new());
-        // let kobject = KObject::new(kobj_type.clone());
-        // let kobject2 = KObject::new(kobj_type.clone());
-        // kobject.add(Some(&root), "foo");
-        // kobject2.add(Some(&kobject), "bar");
-        yield match crate::tests::init_tests() {
-            Err(x) => {
-                pr_err!("Lisa module Rust support validation failed: {x}");
-                0
-            }
-            Ok(()) => 0,
-        };
-    }
+use crate::{
+    error::Error,
+    features::{
+        Feature, FeaturesConfig, FeaturesService, Visibility, define_feature,
+        events::define_event_feature, features_lifecycle,
+    },
+    lifecycle::{LifeCycle, new_lifecycle},
+    runtime::printk::pr_info,
+};
+
+// define_feature! {
+    // struct Feature1,
+    // name: "feature1",
+    // visibility: Public,
+    // Service: (),
+    // Config: (),
+    // dependencies: [Feature2],
+    // init: |configs| {
+        // Ok(new_lifecycle!(|services| {
+            // let services: FeaturesService = services;
+            // pr_info!("FEATURE1 start");
+            // let feature2_service = services.get::<Feature2>();
+            // pr_info!("FEATURE2 service: {feature2_service:?}");
+            // yield_!(Ok(Arc::new(())));
+            // pr_info!("FEATURE1 stop");
+            // Ok(())
+        // }))
+    // },
+// }
+
+// #[derive(Debug)]
+// struct Feature2Service {
+    // a: u32,
+// }
+
+// define_feature! {
+    // struct Feature2,
+    // name: "feature2",
+    // visibility: Public,
+    // Service: Feature2Service,
+    // Config: (),
+    // dependencies: [],
+    // init: |configs| {
+        // Ok(new_lifecycle!(|services| {
+            // pr_info!("FEATURE2 start");
+            // let service = Feature2Service { a: 42 };
+            // yield_!(Ok(Arc::new(service)));
+            // pr_info!("FEATURE2 stop");
+            // Ok(())
+        // }))
+    // },
+// }
+
+// define_event_feature!(struct myevent);
+
+pub fn module_main() -> LifeCycle<(), (), c_int> {
+    let select = |feature: &dyn Feature| feature.visibility() == Visibility::Public;
+    // let select = |feature: &dyn Feature| feature.name() == "feature2";
+
+    features_lifecycle(select)
 }
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/lib.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/lib.rs
index 5fdf53118af710370bae8471e2fd9ef91e794bc5..226e0bea73d61f9ccef10ec5bd05624428b74464 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/lib.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/lib.rs
@@ -1,33 +1,24 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 #![no_std]
 #![no_builtins]
-#![feature(gen_blocks)]
-#![feature(const_pin)]
+#![feature(once_cell_try)]
+#![feature(adt_const_params)]
+#![feature(maybe_uninit_fill)]
+#![feature(coerce_unsized)]
+#![feature(unsize)]
+#![feature(maybe_uninit_write_slice)]
 
 extern crate alloc;
 
+pub mod error;
+pub mod features;
+pub mod graph;
 pub mod init;
 pub mod inlinec;
+pub mod lifecycle;
+pub mod misc;
 pub mod prelude;
+pub mod registry;
 pub mod runtime;
 pub mod tests;
-
-macro_rules! container_of {
-    ($container:ty, $member:ident, $ptr:expr) => {{
-        let ptr = $ptr;
-        let ptr: *const _ = (&*ptr);
-        let offset = core::mem::offset_of!($container, $member);
-        // SAFETY: Our contract is that c_kobj must be the member of a KObjectInner, so we can
-        // safely compute the pointer to the parent.
-        let container: *const $container = (ptr as *const $container).byte_sub(offset);
-        container
-    }};
-}
-pub(crate) use container_of;
-
-#[allow(unused_macros)]
-macro_rules! mut_container_of {
-    ($container:ty, $member:ident, $ptr:expr) => {{ $crate::container_of!($container, $member, $ptr) as *mut $container }};
-}
-#[allow(unused_imports)]
-pub(crate) use mut_container_of;
+pub mod typemap;
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/lifecycle.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/lifecycle.rs
new file mode 100644
index 0000000000000000000000000000000000000000..da84226ea02cfdfe5184496e1fbe995516c4d3c6
--- /dev/null
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/lifecycle.rs
@@ -0,0 +1,310 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+use alloc::boxed::Box;
+use core::{
+    marker::{PhantomData, Unpin},
+    pin::Pin,
+    task::{Context, Poll, RawWakerVTable, Waker},
+};
+
+use crate::runtime::sync::{Lock, Mutex};
+
+enum CoroutineOutput<Y, R> {
+    Yielded(Y),
+    Complete(R),
+}
+
+struct YieldSlot<T> {
+    // Since wakers have to be Sync, protect the inner value slot with a Mutex.
+    yielded: Mutex<Option<T>>,
+}
+
+impl<T> YieldSlot<T>
+where
+    T: Send,
+{
+    fn new() -> Self {
+        YieldSlot {
+            yielded: Mutex::new(None),
+        }
+    }
+
+    // SAFETY: The Waker in Context must have the "data" pointer set to a pointer to YieldSlot.
+    unsafe fn set_yielded(cx: &mut Context<'_>, yielded: T) {
+        let this = cx.waker().data() as *const Self;
+        // SAFETY: the pointer is converted back to its original type as per the safety contract.
+        let this: &Self = unsafe { this.as_ref().unwrap() };
+
+        // We have an &mut Context, but multiple Context could point at the same Waker, and as
+        // such, the same Waker might be used from multiple threads. To avoid any problem, we
+        // wrapped the slot in a Mutex.
+        *this.yielded.lock() = Some(yielded);
+    }
+}
+
+fn poll_lifecycle<T, R, F>(future: Pin<&mut F>) -> CoroutineOutput<T, R>
+where
+    T: Send,
+    F: Future<Output = R> + ?Sized,
+{
+    let data = YieldSlot::<T>::new();
+    let waker = {
+        const VTABLE: RawWakerVTable = RawWakerVTable::new(
+            |_| panic!("Cannot clone this waker"),
+            |_| {},
+            |_| {},
+            |_| {},
+        );
+        // SAFETY: The vtable functions trivially uphold the RawWakerVTable contract since they do
+        // nothing apart from panicking.
+        //
+        // On another note, the data pointer will be used by YieldSlot::set_yielded(), so "data"
+        // must be a pointer to YieldSlot.
+        unsafe { Waker::new(&data as *const _ as *const (), &VTABLE) }
+    };
+    let mut cx = Context::from_waker(&waker);
+
+    match future.poll(&mut cx) {
+        Poll::Ready(x) => CoroutineOutput::Complete(x),
+        Poll::Pending => {
+            let x = data
+                .yielded
+                .lock()
+                .take()
+                .expect("LifeCycle did not store any value in the YieldSlot");
+            CoroutineOutput::Yielded(x)
+        }
+    }
+}
+
+// This type needs to be public as it is used in the new_lifecycle!() macro, but is really a
+// private type. It is critical for safety that the user cannot create instances of that type
+// without going through the yield_!() macro available inside the new_lifecycle!() body.
+pub struct __YieldFuture<T> {
+    yielded: Option<T>,
+}
+
+impl<T> Future for __YieldFuture<T>
+where
+    T: Send + Unpin,
+{
+    type Output = ();
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.get_mut().yielded.take() {
+            // First call to poll, we pass the data via the YieldSlot and report ourselves as
+            // Pending. This way, poll_lifecycle() will be notified and have a chance to read from
+            // the YieldSlot.
+            Some(yielded) => {
+                // SAFETY: This type of future should only be used in a coroutine that is processed
+                // with poll_lifecycle(). If that is the case, the YieldSlot::set_yielded()
+                // invariant is upheld.
+                unsafe {
+                    YieldSlot::<T>::set_yielded(cx, yielded);
+                }
+                Poll::Pending
+            }
+            // Second call to poll, we unblock. The async function will catch that directly and
+            // carry on until the next yield/return point. poll_lifecycle() will not see our Ready
+            // state. It will only see as Ready the point at which the async function returns.
+            None => Poll::Ready(()),
+        }
+    }
+}
+
+type LifeCycleFuture<E> = Box<dyn Future<Output = Result<(), E>> + Send>;
+type LifeCycleFutureBuilder<A, E> = Box<dyn FnOnce(A) -> LifeCycleFuture<E> + Send>;
+
+enum LifeCycleCoroutineState<A, Y, E> {
+    Builder(LifeCycleFutureBuilder<A, E>),
+    Yielded {
+        future: Pin<LifeCycleFuture<E>>,
+        res: Result<Y, E>,
+    },
+}
+
+struct LifeCycleCoroutine<A, Y, E> {
+    // Use Option<> so we can temporarily move out of the enum when updating the state.
+    state: Option<LifeCycleCoroutineState<A, Y, E>>,
+}
+
+macro_rules! new_lifecycle {
+    (|$arg:pat_param| $body:expr) => {{
+        let funcs = $crate::lifecycle::__LifeCycleNewFuncs::new_funcs();
+
+        // SAFETY: The new_future() function is introduced in scope with an identifer from the
+        // macro, so its hygiene prevents the $body to use it apart from via the yield_!() macro.
+        // Since the new_future() function is the only way a __YieldFuture can be built outside of
+        // the current module, and yield_!() consumes the __YieldFuture immediately by awaiting it,
+        // there is no risk of the user ever passing __YieldFuture values around between
+        // lifecycles, which would lead to unsoundness if a __YieldFuture<T> is expected by
+        // poll_lifecycle() but __YieldFuture<U> is awaited.
+        unsafe {
+            funcs.new_lifecycle(::alloc::boxed::Box::new(move |$arg| {
+                ::alloc::boxed::Box::new(async move {
+                    macro_rules! yield_ {
+                        ($expr:expr) => {
+                            funcs.new_future($expr).await
+                        };
+                    }
+
+                    $body
+                })
+                    as ::alloc::boxed::Box<dyn ::core::future::Future<Output = _> + Send>
+            }))
+        }
+    }};
+}
+pub(crate) use new_lifecycle;
+
+enum InternalState<A, Y, E> {
+    Ready(LifeCycleCoroutine<A, Y, E>),
+    Complete(Result<(), E>),
+}
+
+pub enum State<Y, E> {
+    Init,
+    Started(Result<Y, E>),
+    Finished(Result<(), E>),
+}
+
+pub struct LifeCycle<A, Y, E> {
+    state: InternalState<A, Y, E>,
+}
+
+// FIXME: Is there a less verbose way of forcing unification of Y across __YieldFuture and
+// LifeCycle than creating this empty struct __LifeCycleNewFuncs ?
+// => Maybe we can just call a no-op function that takes the other functions as parameters with
+// generic parameters to force unification of the otherwise-unrelated generics.
+
+// This struct's only purpose is to provide a unification point between the function creating a
+// future and the one creating the lifecycle, so that all the type variables are equal.
+pub struct __LifeCycleNewFuncs<A, Y, E> {
+    _marker: PhantomData<(A, Y, E)>,
+}
+
+impl<A, Y, E> Clone for __LifeCycleNewFuncs<A, Y, E> {
+    #[inline]
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<A, Y, E> Copy for __LifeCycleNewFuncs<A, Y, E> {}
+
+impl<A, Y, E> __LifeCycleNewFuncs<A, Y, E> {
+    pub fn new_funcs() -> Self {
+        __LifeCycleNewFuncs {
+            _marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    pub fn new_future(self, yielded: Result<Y, E>) -> __YieldFuture<Result<Y, E>> {
+        __YieldFuture {
+            yielded: Some(yielded),
+        }
+    }
+
+    /// # Safety
+    ///
+    /// This function must only be used via the new_lifecycle!() macro, as it is the only public
+    /// gateway to poll_lifecycle(). new_lifecycle!() ensures via the yield_!() macro that it is
+    /// impossible for the user to ever create a __YieldFuture in a non-controlled way, thereby
+    /// preventing any scenario where a __YieldFuture<T> is awaited by poll_lifecycle() where it
+    /// would expect a __YieldFuture<U>
+    #[inline]
+    pub unsafe fn new_lifecycle(self, builder: LifeCycleFutureBuilder<A, E>) -> LifeCycle<A, Y, E> {
+        LifeCycle {
+            state: InternalState::Ready(LifeCycleCoroutine {
+                state: Some(LifeCycleCoroutineState::Builder(builder)),
+            }),
+        }
+    }
+}
+
+impl<A, Y, E> LifeCycle<A, Y, E>
+where
+    Y: Send,
+    E: Clone + Send,
+{
+    pub fn state(&self) -> State<&Y, E> {
+        match &self.state {
+            InternalState::Ready(coro) => match &coro.state.as_ref().unwrap() {
+                LifeCycleCoroutineState::Builder(_) => State::Init,
+                LifeCycleCoroutineState::Yielded { res, .. } => State::Started(match res {
+                    Err(err) => Err(err.clone()),
+                    Ok(x) => Ok(x),
+                }),
+            },
+            InternalState::Complete(res) => State::Finished(match res {
+                Err(err) => Err(err.clone()),
+                Ok(()) => Ok(()),
+            }),
+        }
+    }
+
+    pub fn start(&mut self, arg: A) -> Result<&mut Y, E> {
+        match &mut self.state {
+            InternalState::Ready(coro) => match coro.state.take().unwrap() {
+                LifeCycleCoroutineState::Yielded { .. } => {
+                    panic!("LifeCycle coroutine has already been started")
+                }
+                LifeCycleCoroutineState::Builder(f) => {
+                    let mut future = Box::into_pin(f(arg));
+                    match poll_lifecycle::<Result<Y, E>, _, _>(future.as_mut()) {
+                        CoroutineOutput::Yielded(res) => {
+                            coro.state = Some(LifeCycleCoroutineState::Yielded { future, res });
+                            match &mut coro.state {
+                                Some(LifeCycleCoroutineState::Yielded { res, .. }) => match res {
+                                    Err(err) => Err(err.clone()),
+                                    // SAFETY: Workaround NLL limitation where the compiler thinks
+                                    // the returned borrow is active until the end of the function,
+                                    // including on other paths where we need to modify self.state.
+                                    // We work around it by transmuting the lifetime so they are
+                                    // not considered conflicting anymore.
+                                    Ok(x) => {
+                                        Ok(unsafe { core::mem::transmute::<&mut Y, &mut Y>(x) })
+                                    }
+                                },
+                                _ => unreachable!(),
+                            }
+                        }
+                        CoroutineOutput::Complete(res) => match res {
+                            Err(err) => {
+                                self.state = InternalState::Complete(Err(err.clone()));
+                                Err(err)
+                            }
+                            Ok(_) => panic!(
+                                "LifeCycle coroutine is only allowed early returns (before yielding) if Result::Err() is returned."
+                            ),
+                        },
+                    }
+                }
+            },
+            _ => panic!("LifeCycle coroutine has already yielded or returned once."),
+        }
+    }
+
+    pub fn stop(&mut self) -> Result<(), E> {
+        match &mut self.state {
+            InternalState::Ready(coro) => match coro.state.as_mut().unwrap() {
+                LifeCycleCoroutineState::Builder(_) => {
+                    panic!("LifeCycle::stop() was called before LifeCycle::start()")
+                }
+                LifeCycleCoroutineState::Yielded { future, .. } => {
+                    match poll_lifecycle::<Result<Y, E>, _, _>(future.as_mut()) {
+                        CoroutineOutput::Yielded(_) => {
+                            panic!("LifeCycle coroutine yielded more than once")
+                        }
+                        CoroutineOutput::Complete(res) => {
+                            self.state = InternalState::Complete(res.clone());
+                            res
+                        }
+                    }
+                }
+            },
+            // If there was an early return, the error was already given to the caller, so the stop
+            // part is treated as an infaillble no-op.
+            InternalState::Complete(_) => Ok(()),
+        }
+    }
+}
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/misc.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/misc.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ff9182277d09ffa488c057f21bd86612ca561071
--- /dev/null
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/misc.rs
@@ -0,0 +1,239 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+use core::{
+    cmp::{max, min},
+    mem::MaybeUninit,
+};
+
+use crate::runtime::{alloc::KernelAlloc, kbox::KBox};
+
+macro_rules! container_of {
+    ($container:ty, $member:ident, $ptr:expr) => {{
+        let ptr = $ptr;
+        let ptr: *const _ = (&*ptr);
+        let offset = core::mem::offset_of!($container, $member);
+        // SAFETY: Our contract is that c_kobj must be the member of a KObjectInner, so we can
+        // safely compute the pointer to the parent.
+        let container: *const $container = (ptr as *const $container).byte_sub(offset);
+        container
+    }};
+}
+pub(crate) use container_of;
+
+#[allow(unused_macros)]
+macro_rules! mut_container_of {
+    ($container:ty, $member:ident, $ptr:expr) => {{ $crate::misc::container_of!($container, $member, $ptr) as *mut $container }};
+}
+#[allow(unused_imports)]
+pub(crate) use mut_container_of;
+
+pub struct SliceWriter<W, SnipSuffix> {
+    inner: W,
+    snip_suffix: SnipSuffix,
+    idx: usize,
+}
+
+impl<W, SnipSuffix> SliceWriter<W, SnipSuffix>
+where
+    W: AsMut<[u8]> + AsRef<[u8]>,
+    SnipSuffix: AsRef<[u8]>,
+{
+    pub fn new(inner: W, snip_suffix: SnipSuffix) -> Self {
+        SliceWriter {
+            inner,
+            snip_suffix,
+            idx: 0,
+        }
+    }
+
+    pub fn written(&self) -> &[u8] {
+        &self.inner.as_ref()[..self.idx]
+    }
+}
+
+impl<W, SnipSuffix> core::fmt::Write for SliceWriter<W, SnipSuffix>
+where
+    W: AsMut<[u8]>,
+    SnipSuffix: AsRef<[u8]>,
+{
+    fn write_str(&mut self, s: &str) -> Result<(), core::fmt::Error> {
+        let s: &[u8] = s.as_bytes();
+        let s_len = s.len();
+        match self.inner.as_mut().split_at_mut_checked(self.idx) {
+            Some((_, remaining)) => {
+                let buf_len = remaining.len();
+                let write = |src: &[u8], dst: &mut [u8], len| {
+                    let dst = &mut dst[..len];
+                    let src = &src[..len];
+                    dst.copy_from_slice(src);
+                    len
+                };
+
+                // Write what we can even if there is not room for everything. We then propagate
+                // the error, and the caller will still be able to use the written buffer to some
+                // extent.
+                if buf_len < s_len {
+                    self.idx += write(s, remaining, buf_len);
+                    let snip_suffix = self.snip_suffix.as_ref();
+                    let len = min(snip_suffix.len(), buf_len);
+                    write(snip_suffix, &mut remaining[buf_len - len..], len);
+                    Err(core::fmt::Error)
+                } else {
+                    self.idx += write(s, remaining, s_len);
+                    Ok(())
+                }
+            }
+            None => {
+                if s_len > 0 {
+                    Err(core::fmt::Error)
+                } else {
+                    Ok(())
+                }
+            }
+        }
+    }
+}
+
+pub struct KBoxWriter<'ka, KA: KernelAlloc, SnipSuffix> {
+    inner: KBox<[u8], &'ka KA>,
+    snip_suffix: SnipSuffix,
+    idx: usize,
+    requested_capacity: usize,
+}
+
+impl<'ka, KA, SnipSuffix> KBoxWriter<'ka, KA, SnipSuffix>
+where
+    KA: KernelAlloc,
+    SnipSuffix: AsRef<[u8]>,
+{
+    pub fn new_in(snip_suffix: SnipSuffix, capacity: usize, alloc: &'ka KA) -> Self {
+        KBoxWriter {
+            inner: KBox::<[u8; 0], _>::new_in([], alloc),
+            snip_suffix,
+            idx: 0,
+            requested_capacity: capacity,
+        }
+    }
+
+    pub fn with_writer<T, F>(snip_suffix: SnipSuffix, capacity: usize, f: F) -> T
+    where
+        KA: Default,
+        F: FnOnce(KBoxWriter<'_, KA, SnipSuffix>) -> T,
+    {
+        let alloc = Default::default();
+        let writer = KBoxWriter::new_in(snip_suffix, capacity, &alloc);
+        f(writer)
+    }
+
+    #[inline]
+    pub fn written(&self) -> &[u8] {
+        &self.inner.as_ref()[..self.idx]
+    }
+
+    fn extend_by(&mut self, n: usize) -> Result<(), core::fmt::Error> {
+        let cur_size = self.inner.len();
+        // First allocation, we try to provide the requested capacity to avoid too many subsequent
+        // re-allocations.
+        let new_size = if cur_size == 0 {
+            max(self.requested_capacity, n)
+        } else {
+            let new_size = cur_size.saturating_add(n);
+            let new_size = new_size.checked_next_power_of_two().unwrap_or(new_size);
+            new_size.max(64)
+        };
+        let mut new = KBox::<u8, _>::try_new_uninit_slice_in(new_size, *self.inner.allocator())
+            .map_err(|_| core::fmt::Error)?;
+        MaybeUninit::copy_from_slice(&mut new[..cur_size], &self.inner);
+        MaybeUninit::fill(&mut new[cur_size..], 0);
+        // SAFETY: We initialized both the first part of the buffer from the old data and the extra
+        // area with 0.
+        let new = unsafe { new.assume_init() };
+
+        self.inner = new;
+        Ok(())
+    }
+}
+
+impl<KA, SnipSuffix> core::fmt::Write for KBoxWriter<'_, KA, SnipSuffix>
+where
+    KA: KernelAlloc,
+    SnipSuffix: AsRef<[u8]>,
+{
+    fn write_str(&mut self, s: &str) -> Result<(), core::fmt::Error> {
+        // We need a partial borrow in some places, so we can't use a method.
+        macro_rules! remaining {
+            ($self:expr) => {{ &mut $self.inner.as_mut()[$self.idx..] }};
+        }
+
+        let write_bytes = |src: &[u8], dst: &mut [u8], len| {
+            let dst = &mut dst[..len];
+            let src = &src[..len];
+            dst.copy_from_slice(src);
+            len
+        };
+        let write = |src: &str, dst: &mut [u8], len| write_bytes(src.as_bytes(), dst, len);
+
+        let s_len = s.len();
+        let remaining = remaining!(self);
+        let buf_len = remaining.len();
+
+        if buf_len < s_len {
+            match self.extend_by(s_len - buf_len) {
+                Ok(()) => {
+                    // The buffer may have been extended by more (to avoid reallocating too often)
+                    // than what was asked, so recompute the length to write.
+                    let remaining = remaining!(self);
+                    let len = min(remaining.len(), s_len);
+                    self.idx += write(s, remaining, len);
+                    Ok(())
+                }
+                Err(err) => {
+                    let remaining = remaining!(self);
+                    // We write what we can and leave it at that.
+                    self.idx += write(s, remaining, remaining.len());
+
+                    // Write the snip marker as a suffix if there is enough room.
+                    let snip_suffix = self.snip_suffix.as_ref();
+                    let inner = &mut self.inner;
+                    let inner_len = inner.len();
+                    let len = min(snip_suffix.len(), inner_len);
+                    write_bytes(snip_suffix, &mut inner[inner_len - len..], len);
+
+                    Err(err)
+                }
+            }
+        } else {
+            self.idx += write(s, remaining, s_len);
+            Ok(())
+        }
+    }
+}
+
+macro_rules! destructure {
+    ($value:expr, $($field:ident),*) => {{
+        // Ensure there is no duplicate in the list of fields. If there is any duplicate, the code
+        // will not compile as parameter names cannot be duplicated. On top of that we even get a
+        // nice error message about duplicated parameters for the user of the macro !
+        {
+            #[allow(unused)]
+            fn check_duplicates($($field: ()),*){}
+        }
+        let value = $value;
+        let value = ::core::mem::MaybeUninit::new(value);
+        let value = ::core::mem::MaybeUninit::as_ptr(&value);
+        (
+            $(
+                // SAFETY: Once the value is wrapped in MaybeUninit, no custom Drop implementation
+                // will run anymore, so there is no risk of a Drop implementation to read from any
+                // of the attributes we moved out of.
+                //
+                // We also need to ensure that we never move out of the same field twice, which was
+                // checked earlier by ensuring there is no duplicated in the fields list.
+                unsafe {
+                    core::ptr::read(&(*value).$field)
+                },
+            )*
+        )
+    }}
+}
+pub(crate) use destructure;
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/prelude.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/prelude.rs
index f7ae663e5200d4efe4c4241bfb27db8e1f957ee4..35c56c56da37459cd18dd04ea2ff523b7f98ab79 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/prelude.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/prelude.rs
@@ -1,12 +1,12 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 
-pub use crate::{
-    inlinec::{cconstant, cexport, cfunc, cstatic},
-    runtime::kbox::KBox,
-};
+#[allow(unused_imports)]
+pub(crate) use ::alloc::boxed::Box;
 
 #[allow(unused_imports)]
 pub(crate) use crate::{
     inlinec::c_eval,
+    inlinec::{cconstant, cexport, cfunc, cstatic},
+    runtime::kbox::{KBox, KernelKBox},
     runtime::printk::{pr_err, pr_info},
 };
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/registry.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/registry.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b05860ce53673061c0d69e942a25f73beda02d41
--- /dev/null
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/registry.rs
@@ -0,0 +1,107 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+// FIXME: remove this module since we have linkme working
+
+/// # Safety
+///
+/// The start() and stop() methods must return pointers to boundaries of the section in which the
+/// values of type T are stored.
+pub unsafe trait Registry {
+    type T: 'static;
+    const NAME: &'static str;
+
+    fn start() -> *const Self::T;
+    fn stop() -> *const Self::T;
+
+    fn iter() -> impl Iterator<Item = &'static Self::T> {
+        RegistryIter {
+            start: Self::start(),
+            stop: Self::stop(),
+            curr: None,
+        }
+    }
+}
+
+struct RegistryIter<T> {
+    start: *const T,
+    stop: *const T,
+    curr: Option<*const T>,
+}
+
+impl<T> Iterator for RegistryIter<T>
+where
+    T: 'static,
+{
+    type Item = &'static T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let next = |ptr: *const T| {
+            if ptr >= self.stop {
+                (ptr, None)
+            } else {
+                let value: &'static T = unsafe { &*ptr };
+                (unsafe { ptr.offset(1) }, Some(value))
+            }
+        };
+
+        match self.curr {
+            None => {
+                let (curr, value) = next(self.start);
+                self.curr = Some(curr);
+                value
+            }
+            Some(curr) => {
+                let (curr, value) = next(curr);
+                self.curr = Some(curr);
+                value
+            }
+        }
+    }
+}
+
+macro_rules! define_registry {
+    ($name:ident, $ty:ty) => {
+        pub struct $name;
+        const _: () = {
+            unsafe extern "C" {
+                #[link_name = concat!("__start_", "rust_registry_", stringify!($name))]
+                static START: ();
+
+                #[link_name = concat!("__stop_", "rust_registry_", stringify!($name))]
+                static STOP: ();
+            }
+
+            unsafe impl $crate::registry::Registry for $name {
+                type T = $ty;
+                const NAME: &'static str = stringify!($name);
+
+                fn start() -> *const Self::T {
+                    unsafe { &START as *const () as *const Self::T }
+                }
+                fn stop() -> *const Self::T {
+                    unsafe { &STOP as *const () as *const Self::T }
+                }
+            }
+
+            unsafe impl Send for $name where $ty: Send {}
+            unsafe impl Sync for $name where $ty: Sync {}
+        };
+    };
+}
+
+macro_rules! add_to_registry {
+    ($name:ident, $value:expr) => {
+        const _: () = {
+            const NAME: &[u8] = stringify!($name).as_bytes();
+            match <$name as $crate::registry::Registry>::NAME.as_bytes() {
+                NAME => {},
+                _ => panic!("The original name as passed to define_registry!(<name>, ...) of the registry must be used",
+                )
+            }
+
+            #[unsafe(link_section = concat!("rust_registry_", stringify!($name)))]
+            #[used]
+            static ENTRY: <$name as $crate::registry::Registry>::T = $value;
+        };
+    };
+}
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/alloc.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/alloc.rs
index c053c57c6c65a1d7bbf611051ae9d9980410b8cf..ee993ac10a43b3d477b4f2280cb02b772b1bfc93 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/alloc.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/alloc.rs
@@ -11,8 +11,6 @@ use crate::{
     runtime::printk::pr_err,
 };
 
-struct KernelAllocator;
-
 #[inline]
 fn with_size<F: FnOnce(usize) -> *mut u8>(layout: Layout, f: F) -> *mut u8 {
     let minalign: usize =
@@ -35,6 +33,22 @@ fn with_size<F: FnOnce(usize) -> *mut u8>(layout: Layout, f: F) -> *mut u8 {
     }
 }
 
+// TODO: Replace by Option::unwrap_or() if it becomes const
+macro_rules! unwrap_or {
+    ($expr:expr, $default:expr) => {
+        match $expr {
+            Some(x) => x,
+            None => $default,
+        }
+    };
+}
+
+#[derive(core::marker::ConstParamTy, PartialEq, Eq)]
+pub enum GFPFlags {
+    Kernel = unwrap_or!(cconstant!("#include <linux/slab.h>", "GFP_KERNEL"), 0),
+    Atomic = unwrap_or!(cconstant!("#include <linux/slab.h>", "GFP_ATOMIC"), 1),
+}
+
 /// This function is guaranteed to return the pointer given by the kernel's kmalloc() without
 /// re-aligning it in any way. This makes it suitable to pass to kfree() without knowing the
 /// original layout.
@@ -42,16 +56,23 @@ fn with_size<F: FnOnce(usize) -> *mut u8>(layout: Layout, f: F) -> *mut u8 {
 /// Note that any layout is admissible here, including if layout.size() == 0 unlike when going
 /// through the GlobalAlloc API.
 #[inline]
-pub fn kmalloc(layout: Layout) -> *mut u8 {
+pub fn kmalloc(layout: Layout, flags: GFPFlags) -> *mut u8 {
     #[cfunc]
-    fn alloc(size: usize) -> *mut u8 {
-        "#include <linux/slab.h>";
+    fn alloc(size: usize, flags: u64) -> *mut u8 {
+        r#"
+        #include <linux/slab.h>
+        #include <linux/types.h>
+        "#;
 
-        "return kmalloc(size, GFP_KERNEL);"
+        "return kmalloc(size, (gfp_t)flags);"
     }
-    with_size(layout, alloc)
+    with_size(layout, |size| alloc(size, flags as u64))
 }
 
+/// Counterpart to [kmalloc]
+///
+/// # Safety
+/// This function can only be called with a pointer allocated with the kernel's kmalloc() function.
 #[inline]
 pub unsafe fn kfree<T: ?Sized>(ptr: *mut T) {
     #[cfunc]
@@ -63,32 +84,82 @@ pub unsafe fn kfree<T: ?Sized>(ptr: *mut T) {
     unsafe { dealloc(ptr as *mut c_void) }
 }
 
-unsafe impl GlobalAlloc for KernelAllocator {
+pub trait KernelAlloc {
+    /// # Safety
+    /// This method must comply with all [GlobalAlloc::alloc] requirements. Additionally, it must
+    /// be able to handle Layout with size=0.
+    fn alloc(&self, layout: Layout) -> *mut u8;
+    /// # Safety
+    /// This method must comply with all [GlobalAlloc::dealloc] requirements.
+    unsafe fn dealloc(&self, ptr: *mut u8);
+}
+
+impl KernelAlloc for &dyn KernelAlloc {
+    #[inline]
+    fn alloc(&self, layout: Layout) -> *mut u8 {
+        (*self).alloc(layout)
+    }
+    #[inline]
+    unsafe fn dealloc(&self, ptr: *mut u8) {
+        unsafe { (*self).dealloc(ptr) }
+    }
+}
+
+impl<T> KernelAlloc for &T
+where
+    T: KernelAlloc,
+{
+    #[inline]
+    fn alloc(&self, layout: Layout) -> *mut u8 {
+        (*self).alloc(layout)
+    }
+    #[inline]
+    unsafe fn dealloc(&self, ptr: *mut u8) {
+        unsafe { (*self).dealloc(ptr) }
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct KmallocAllocator<const FLAGS: GFPFlags>;
+
+impl<const FLAGS: GFPFlags> KernelAlloc for KmallocAllocator<FLAGS> {
+    #[inline]
+    fn alloc(&self, layout: Layout) -> *mut u8 {
+        kmalloc(layout, FLAGS)
+    }
+
+    #[inline]
+    unsafe fn dealloc(&self, ptr: *mut u8) {
+        unsafe { kfree(ptr) };
+    }
+}
+
+unsafe impl<const FLAGS: GFPFlags> GlobalAlloc for KmallocAllocator<FLAGS> {
     #[inline]
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        kmalloc(layout)
+        <Self as KernelAlloc>::alloc(self, layout)
     }
 
     #[inline]
     unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
-        unsafe { kfree(ptr) };
+        unsafe { <Self as KernelAlloc>::dealloc(self, ptr) }
     }
 
     #[inline]
     unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
         #[cfunc]
-        fn alloc_zeroed(size: usize) -> *mut u8 {
+        fn alloc_zeroed(size: usize, flags: u64) -> *mut u8 {
             "#include <linux/slab.h>";
 
-            "return kzalloc(size, GFP_KERNEL);"
+            "return kzalloc(size, (gfp_t)flags);"
         }
-        with_size(layout, alloc_zeroed)
+        with_size(layout, |size| alloc_zeroed(size, FLAGS as u64))
     }
 
     #[inline]
     unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
         #[cfunc]
-        unsafe fn realloc(ptr: *mut u8, size: usize) -> *mut u8 {
+        unsafe fn realloc(ptr: *mut u8, size: usize, flags: u64) -> *mut u8 {
             "#include <linux/slab.h>";
 
             r#"
@@ -97,7 +168,7 @@ unsafe impl GlobalAlloc for KernelAllocator {
                 // leading to a double-free.
                 size = 1;
             }
-            return krealloc(ptr, size, GFP_KERNEL);
+            return krealloc(ptr, size, (gfp_t)flags);
             "#
         }
         let new_layout = Layout::from_size_align(new_size, layout.align());
@@ -105,10 +176,12 @@ unsafe impl GlobalAlloc for KernelAllocator {
             Ok(layout) => layout,
             Err(_) => handle_alloc_error(layout),
         };
-        with_size(new_layout, |size| unsafe { realloc(ptr, size) })
+        with_size(new_layout, |size| unsafe {
+            realloc(ptr, size, FLAGS as u64)
+        })
     }
 }
 
 #[global_allocator]
 /// cbindgen:ignore
-static GLOBAL: KernelAllocator = KernelAllocator;
+static GLOBAL: KmallocAllocator<{ GFPFlags::Kernel }> = KmallocAllocator;
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/kbox.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/kbox.rs
index 9629ab1bfad67c309004cb3fe3765a594f61b58b..e40fc0a172fe750bcf62c78732d5c65c81b5a224 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/kbox.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/kbox.rs
@@ -1,59 +1,56 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 
 use core::{
-    alloc::Layout,
+    alloc::{Layout, LayoutError},
     borrow::{Borrow, BorrowMut},
     cmp::Ordering,
     convert::{AsMut, AsRef},
     fmt,
     hash::{Hash, Hasher},
+    marker::Unsize,
     mem::MaybeUninit,
-    mem::forget,
-    ops::{Deref, DerefMut},
+    ops::{CoerceUnsized, Deref, DerefMut},
     pin::Pin,
     ptr,
     ptr::NonNull,
 };
 
-use crate::runtime::alloc::{kfree, kmalloc};
 use lisakmod_macros::inlinec::{FfiType, FromFfi, IntoFfi, MutPtr, Opaque};
 
-pub struct KBox<T: ?Sized> {
-    ptr: NonNull<T>,
+use crate::{
+    misc::destructure,
+    runtime::alloc::{GFPFlags, KernelAlloc, KmallocAllocator},
+};
+
+#[derive(Debug)]
+pub enum AllocError {
+    KmallocFailed,
+    LayoutError(LayoutError),
 }
 
-impl<T: ?Sized> KBox<T> {
+impl From<LayoutError> for AllocError {
     #[inline]
-    pub fn new(x: T) -> Self
-    where
-        T: Sized,
-    {
-        let mut new = Self::new_uninit();
-        let maybe: &mut MaybeUninit<T> = &mut new;
-        maybe.write(x);
-        // SAFETY: The memory is now initialize.
-        unsafe { new.assume_init() }
+    fn from(err: LayoutError) -> AllocError {
+        AllocError::LayoutError(err)
     }
+}
 
-    #[inline]
-    pub fn new_uninit() -> KBox<MaybeUninit<T>>
-    where
-        T: Sized,
-    {
-        let layout = Layout::new::<T>();
-        Self::from_layout(layout)
-    }
+pub struct KBox<T: ?Sized, KA: KernelAlloc> {
+    ptr: NonNull<T>,
+    alloc: KA,
+}
 
+pub type KernelKBox<T> = KBox<T, KmallocAllocator<{ GFPFlags::Kernel }>>;
+pub type AtomicKBox<T> = KBox<T, KmallocAllocator<{ GFPFlags::Atomic }>>;
+
+impl<T, KA> KBox<T, KA>
+where
+    T: ?Sized,
+    KA: KernelAlloc,
+{
     #[inline]
-    fn from_layout(layout: Layout) -> KBox<MaybeUninit<T>>
-    where
-        T: Sized,
-    {
-        let ptr = kmalloc(layout);
-        let ptr = ptr::NonNull::new(ptr as *mut MaybeUninit<T>).expect("Allocation failed");
-        // SAFETY: MaybeUninit<T> does not mandate any bit pattern for its data, so it's safe to
-        // construct it without any initialization (that's the whole point).
-        KBox { ptr }
+    pub fn allocator(&self) -> &KA {
+        &self.alloc
     }
 
     #[inline]
@@ -67,16 +64,16 @@ impl<T: ?Sized> KBox<T> {
     }
 
     #[inline]
-    pub unsafe fn from_ptr(ptr: NonNull<T>) -> Self {
-        KBox { ptr }
-    }
-
-    #[inline]
-    fn into_ptr(mut self) -> *mut T {
-        let ptr = self.as_mut_ptr();
-        // SAFETY: Do not free memory here.
-        forget(self);
-        ptr
+    fn into_ptr_alloc(self) -> (*mut T, KA) {
+        let (alloc, ptr) = destructure!(self, alloc, ptr);
+
+        // // SAFETY: Since we are returning the raw pointer, we must absolutely avoid self from being
+        // // dropped. MaybeUninit does not drop the wrapped value so it is fine.
+        // let this = MaybeUninit::new(self);
+        // // SAFETY: we move the fields out of the value, which is ok since we will not make use of
+        // // the value anymore and it will not be dropped.
+        // let alloc = unsafe { core::ptr::read(&(*MaybeUninit::as_ptr(&this)).alloc) };
+        (ptr.as_ptr(), alloc)
     }
 
     #[inline]
@@ -97,40 +94,217 @@ impl<T: ?Sized> KBox<T> {
         unsafe { Pin::new_unchecked(self) }
     }
 
+    /// # Safety
+    ///
+    /// The passed pointer must have been allocated by the KA allocator and passing it moves the
+    /// data, so no-one else is allowed to keep a mutable reference to it, unless [`T`] is
+    /// [`core::cell::UnsafeCell<...>`]
     #[inline]
-    pub fn pin(x: T) -> Pin<Self>
+    pub unsafe fn from_ptr_in(ptr: NonNull<T>, alloc: KA) -> Self {
+        KBox { ptr, alloc }
+    }
+}
+
+impl<T, KA> KBox<T, KA>
+where
+    KA: KernelAlloc,
+{
+    #[inline]
+    pub fn new_in(x: T, alloc: KA) -> Self {
+        Self::try_new_in(x, alloc).expect("Allocation failed")
+    }
+
+    #[inline]
+    pub fn new_uninit_in(alloc: KA) -> KBox<MaybeUninit<T>, KA> {
+        Self::try_new_uninit_in(alloc).expect("Allocation failed")
+    }
+
+    #[inline]
+    pub fn pin_in(x: T, alloc: KA) -> Pin<Self> {
+        KBox::into_pin(KBox::new_in(x, alloc))
+    }
+
+    #[inline]
+    pub fn try_new_in(x: T, alloc: KA) -> Result<Self, AllocError> {
+        let mut new = Self::try_new_uninit_in(alloc)?;
+        let maybe: &mut MaybeUninit<T> = &mut new;
+        maybe.write(x);
+        // SAFETY: The memory is now initialize.
+        Ok(unsafe { new.assume_init() })
+    }
+
+    #[inline]
+    pub fn try_new_uninit_in(alloc: KA) -> Result<KBox<MaybeUninit<T>, KA>, AllocError> {
+        let new: KBox<[MaybeUninit<T>; 1], _> = Self::try_new_uninit_array_in::<1>(alloc)?;
+        let new = unsafe { new.transmute_inner::<MaybeUninit<T>>() };
+        Ok(new)
+    }
+
+    #[inline]
+    pub fn try_new_uninit_array_in<const N: usize>(
+        alloc: KA,
+    ) -> Result<KBox<[MaybeUninit<T>; N], KA>, AllocError> {
+        let mut new = Self::try_new_uninit_slice_in(N, alloc)?;
+        let arr: &mut [MaybeUninit<T>; N] = (&mut *new).try_into().unwrap();
+        let ptr = NonNull::new(arr as *mut _).unwrap();
+        let (alloc,) = destructure!(new, alloc);
+        Ok(KBox { ptr, alloc })
+    }
+
+    #[inline]
+    pub fn try_new_uninit_slice_in(
+        len: usize,
+        alloc: KA,
+    ) -> Result<KBox<[MaybeUninit<T>], KA>, AllocError> {
+        let layout = Layout::array::<T>(len)?;
+        let ptr = alloc.alloc(layout) as *mut MaybeUninit<T>;
+        let ptr: *mut [MaybeUninit<T>] = core::ptr::slice_from_raw_parts_mut(ptr, len);
+        let ptr = ptr::NonNull::new(ptr);
+        match ptr {
+            // SAFETY: MaybeUninit<T> does not mandate any bit pattern for its data, so it's safe
+            // to construct it without any initialization (that's the whole point).
+            Some(ptr) => Ok(unsafe { KBox::from_ptr_in(ptr, alloc) }),
+            None => Err(AllocError::KmallocFailed),
+        }
+    }
+
+    #[inline]
+    pub fn into_inner(this: Self) -> T {
+        let (ptr, _) = this.into_ptr_alloc();
+        // SAFETY: The pointer is still valid since:
+        // 1. We only store valid pointers
+        // 2. We used core::mem::forget() Drop does not run and the memory stays allocated.
+        unsafe { ptr.read() }
+    }
+
+    /// # Safety
+    /// It must be sound to transmute a [T] into a [U]
+    unsafe fn transmute_inner<U>(self) -> KBox<U, KA>
     where
-        T: Sized,
+        // Ensure we don't transmute between a fat and a thin pointer.
+        *mut T: Sized,
+        *mut U: Sized,
     {
-        KBox::into_pin(KBox::new(x))
+        let (ptr, alloc) = self.into_ptr_alloc();
+        // SAFETY: The caller guarantees that we can reinterpret the bytes of T as bytes of U.
+        let ptr: *mut U = unsafe { core::mem::transmute::<*mut T, *mut U>(ptr) };
+        let ptr = NonNull::new(ptr).unwrap();
+        KBox { ptr, alloc }
     }
 }
 
-impl<T> KBox<MaybeUninit<T>> {
+impl<T, KA> KBox<T, KA>
+where
+    T: ?Sized,
+    KA: KernelAlloc + Default,
+{
+    /// # Safety
+    ///
+    /// The passed pointer must have been allocated by [KA] and passing it moves the data, so
+    /// no-one else is allowed to keep a mutable reference to it, unless [`T`] is
+    /// [`core::cell::UnsafeCell<...>`]
     #[inline]
-    pub unsafe fn assume_init(self) -> KBox<T> {
-        let ptr: *const MaybeUninit<T> = self.into_ptr();
-        // SAFETY: It is sound to cast *const MaybeUninit<T> to *const T since MaybeUninit<T> is
-        // #[repr(transparent)]
-        KBox {
-            ptr: unsafe { NonNull::new_unchecked(ptr as *mut T) },
-        }
+    pub unsafe fn from_ptr(ptr: NonNull<T>) -> Self {
+        unsafe { Self::from_ptr_in(ptr, Default::default()) }
     }
 }
 
-impl<T: ?Sized> Drop for KBox<T> {
+impl<T, KA> KBox<T, KA>
+where
+    KA: KernelAlloc + Default,
+{
+    #[inline]
+    pub fn new(x: T) -> Self {
+        Self::new_in(x, Default::default())
+    }
+
+    #[inline]
+    pub fn new_uninit() -> KBox<MaybeUninit<T>, KA> {
+        Self::new_uninit_in(Default::default())
+    }
+
+    #[inline]
+    pub fn pin(x: T) -> Pin<Self> {
+        Self::pin_in(x, Default::default())
+    }
+
+    #[inline]
+    pub fn try_new(x: T) -> Result<Self, AllocError> {
+        Self::try_new_in(x, Default::default())
+    }
+
+    #[inline]
+    pub fn try_new_uninit() -> Result<KBox<MaybeUninit<T>, KA>, AllocError> {
+        Self::try_new_uninit_in(Default::default())
+    }
+
+    #[inline]
+    pub fn try_new_uninit_array<const N: usize>()
+    -> Result<KBox<[MaybeUninit<T>; N], KA>, AllocError> {
+        Self::try_new_uninit_array_in(Default::default())
+    }
+}
+
+impl<T, KA> KBox<MaybeUninit<T>, KA>
+where
+    KA: KernelAlloc,
+{
+    /// # Safety
+    /// This function inherits all the safety expectations of [MaybeUninit::assume_init]
+    #[inline]
+    pub unsafe fn assume_init(self) -> KBox<T, KA> {
+        unsafe { self.transmute_inner::<T>() }
+    }
+}
+
+impl<T, KA, const N: usize> KBox<[MaybeUninit<T>; N], KA>
+where
+    KA: KernelAlloc,
+{
+    /// # Safety
+    /// This function inherits all the safety expectations of [MaybeUninit::assume_init]
+    #[inline]
+    pub unsafe fn assume_init(self) -> KBox<[T; N], KA> {
+        unsafe { self.transmute_inner::<[T; N]>() }
+    }
+}
+
+impl<T, KA> KBox<[MaybeUninit<T>], KA>
+where
+    KA: KernelAlloc,
+{
+    /// # Safety
+    /// This function inherits all the safety expectations of [MaybeUninit::assume_init]
+    #[inline]
+    pub unsafe fn assume_init(self) -> KBox<[T], KA> {
+        let (ptr, alloc): (*mut [MaybeUninit<T>], _) = self.into_ptr_alloc();
+        // SAFETY: It is sound to cast *const [MaybeUninit<T>] to *const [T] since MaybeUninit<T>
+        // is #[repr(transparent)]
+        unsafe { KBox::from_ptr_in(NonNull::new_unchecked(ptr as *mut [T]), alloc) }
+    }
+}
+
+impl<T, KA> Drop for KBox<T, KA>
+where
+    T: ?Sized,
+    KA: KernelAlloc,
+{
     #[inline]
     fn drop(&mut self) {
+        let ptr = self.ptr;
         // SAFETY: KBox::ptr always points at an initialized and owned location.
         unsafe {
-            self.ptr.drop_in_place();
-            // Allocation was done with [kmalloc] so we can free with [kfree]
-            kfree(self.ptr.as_ptr());
+            ptr.drop_in_place();
+            // SAFETY: Allocation was done with the same allocator we are freeing it with.
+            self.alloc.dealloc(ptr.as_ptr() as *mut u8);
         }
     }
 }
 
-impl<T> From<T> for KBox<T> {
+impl<T, KA> From<T> for KBox<T, KA>
+where
+    KA: KernelAlloc + Default,
+{
     #[inline]
     fn from(t: T) -> Self {
         Self::new(t)
@@ -138,11 +312,17 @@ impl<T> From<T> for KBox<T> {
 }
 
 // SAFETY: KBox<T> owns the T, so it inherits T: Send
-unsafe impl<T: ?Sized + Send> Send for KBox<T> {}
+unsafe impl<T: ?Sized + Send, KA: KernelAlloc + Send> Send for KBox<T, KA> {}
 // SAFETY: KBox<T> owns the T, so it inherits T: Sync
-unsafe impl<T: ?Sized + Sync> Sync for KBox<T> {}
+unsafe impl<T: ?Sized + Sync, KA: KernelAlloc + Sync> Sync for KBox<T, KA> {}
 
-impl<T: ?Sized> Deref for KBox<T> {
+impl<T: ?Sized + Unsize<U>, U: ?Sized, KA: KernelAlloc> CoerceUnsized<KBox<U, KA>> for KBox<T, KA> {}
+
+impl<T, KA> Deref for KBox<T, KA>
+where
+    T: ?Sized,
+    KA: KernelAlloc,
+{
     type Target = T;
 
     #[inline]
@@ -152,7 +332,11 @@ impl<T: ?Sized> Deref for KBox<T> {
     }
 }
 
-impl<T: ?Sized> DerefMut for KBox<T> {
+impl<T, KA> DerefMut for KBox<T, KA>
+where
+    T: ?Sized,
+    KA: KernelAlloc,
+{
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target {
         // SAFETY: self.ptr is guaranteed to be valid and initialized
@@ -160,113 +344,131 @@ impl<T: ?Sized> DerefMut for KBox<T> {
     }
 }
 
-impl<T: ?Sized> AsRef<T> for KBox<T> {
+impl<T, KA> AsRef<T> for KBox<T, KA>
+where
+    T: ?Sized,
+    KA: KernelAlloc,
+{
     #[inline]
     fn as_ref(&self) -> &T {
         self.deref()
     }
 }
 
-impl<T: ?Sized> AsMut<T> for KBox<T> {
+impl<T, KA> AsMut<T> for KBox<T, KA>
+where
+    T: ?Sized,
+    KA: KernelAlloc,
+{
     #[inline]
     fn as_mut(&mut self) -> &mut T {
         self.deref_mut()
     }
 }
 
-impl<T: ?Sized> Borrow<T> for KBox<T> {
+impl<T, KA> Borrow<T> for KBox<T, KA>
+where
+    T: ?Sized,
+    KA: KernelAlloc,
+{
     #[inline]
     fn borrow(&self) -> &T {
         self.deref()
     }
 }
 
-impl<T: ?Sized> BorrowMut<T> for KBox<T> {
+impl<T, KA> BorrowMut<T> for KBox<T, KA>
+where
+    KA: KernelAlloc,
+{
     #[inline]
     fn borrow_mut(&mut self) -> &mut T {
         self.deref_mut()
     }
 }
 
-impl<T: Clone> Clone for KBox<T> {
+impl<T: Clone, KA: KernelAlloc + Clone> Clone for KBox<T, KA> {
     #[inline]
     fn clone(&self) -> Self {
         let x: T = <T as Clone>::clone(self.deref());
-        Self::new(x)
+        Self::new_in(x, self.alloc.clone())
     }
 }
 
-impl<T: ?Sized + fmt::Debug> fmt::Debug for KBox<T> {
+impl<T: ?Sized + fmt::Debug, KA: KernelAlloc> fmt::Debug for KBox<T, KA> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         fmt::Debug::fmt(self.deref(), f)
     }
 }
 
-impl<T: Default> Default for KBox<T> {
+impl<T: Default, KA: KernelAlloc + Default> Default for KBox<T, KA> {
     #[inline]
     fn default() -> Self {
-        KBox::new(<T as Default>::default())
+        KBox::new_in(Default::default(), Default::default())
     }
 }
 
-impl<T: ?Sized + fmt::Display> fmt::Display for KBox<T> {
+impl<T: ?Sized + fmt::Display, KA: KernelAlloc> fmt::Display for KBox<T, KA> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         fmt::Display::fmt(self.deref(), f)
     }
 }
 
-impl<T: ?Sized + PartialEq> PartialEq for KBox<T> {
+impl<T: ?Sized + PartialEq, KA: KernelAlloc> PartialEq for KBox<T, KA> {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
         PartialEq::eq(&**self, &**other)
     }
 }
 
-impl<T: ?Sized + Eq> Eq for KBox<T> {}
+impl<T: ?Sized + Eq, KA: KernelAlloc> Eq for KBox<T, KA> {}
 
-impl<T: ?Sized + PartialOrd> PartialOrd for KBox<T> {
+impl<T: ?Sized + PartialOrd, KA: KernelAlloc> PartialOrd for KBox<T, KA> {
     #[inline]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         PartialOrd::partial_cmp(&**self, &**other)
     }
 }
 
-impl<T: ?Sized + Ord> Ord for KBox<T> {
+impl<T: ?Sized + Ord, KA: KernelAlloc> Ord for KBox<T, KA> {
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         Ord::cmp(&**self, &**other)
     }
 }
 
-impl<T: ?Sized + Hash> Hash for KBox<T> {
+impl<T: ?Sized + Hash, KA: KernelAlloc> Hash for KBox<T, KA> {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         (**self).hash(state);
     }
 }
 
-impl<T: ?Sized> fmt::Pointer for KBox<T> {
+impl<T: ?Sized, KA: KernelAlloc> fmt::Pointer for KBox<T, KA> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Pointer::fmt(&self.ptr, f)
     }
 }
 
-impl<T: ?Sized> Unpin for KBox<T> {}
+impl<T: ?Sized, KA: KernelAlloc> Unpin for KBox<T, KA> {}
 
-impl<T> FfiType for KBox<T>
+impl<T, KA> FfiType for KBox<T, KA>
 where
+    KA: KernelAlloc,
     T: ?Sized,
     NonNull<T>: FfiType,
 {
-    const C_DECL: &'static str = <NonNull<T> as FfiType>::C_DECL;
+    const C_TYPE: &'static str = <NonNull<T> as FfiType>::C_TYPE;
+    const C_HEADER: Option<&'static str> = <NonNull<T> as FfiType>::C_HEADER;
     type FfiType = <NonNull<T> as FfiType>::FfiType;
 }
 
-impl<T> FromFfi for KBox<T>
+impl<T, KA> FromFfi for KBox<T, KA>
 where
+    KA: KernelAlloc + Default,
     T: ?Sized,
     MutPtr<T>: FromFfi,
 {
@@ -278,35 +480,58 @@ where
     }
 }
 
-impl<T> IntoFfi for KBox<T>
+impl<T, KA> IntoFfi for KBox<T, KA>
 where
+    KA: KernelAlloc,
     T: ?Sized,
     MutPtr<T>: IntoFfi,
 {
     #[inline]
     fn into_ffi(self) -> Self::FfiType {
-        let ptr: *mut T = self.into_ptr();
+        let (ptr, _alloc): (*mut T, _) = self.into_ptr_alloc();
         ptr.into_ffi()
     }
 }
 
 pub trait OpaqueExt: Opaque {
-    unsafe fn new_kbox<E, F>(init: F) -> Result<KBox<Self>, E>
+    /// # Safety
+    /// The `init` function will be passed a [core::mem::MaybeUninit] value, which it needs to
+    /// fully initialize before it successfully returns. If an [Result::Err] is returned, then not
+    /// fully initializing the object is allowed.
+    unsafe fn new_kbox_in<E, F, KA>(init: F, alloc: KA) -> Result<KBox<Self, KA>, E>
     where
-        F: FnOnce(*mut Self) -> Result<(), E>;
+        KA: KernelAlloc,
+        Self: Sized,
+        F: FnOnce(&mut MaybeUninit<Self>) -> Result<(), E>;
+
+    /// # Safety
+    /// The `init` function will be passed a [core::mem::MaybeUninit] value, which it needs to
+    /// fully initialize before it successfully returns. If an [Result::Err] is returned, then not
+    /// fully initializing the object is allowed.
+    #[inline]
+    unsafe fn new_kbox<E, F, KA>(init: F) -> Result<KBox<Self, KA>, E>
+    where
+        KA: KernelAlloc + Default,
+        Self: Sized,
+        F: FnOnce(&mut MaybeUninit<Self>) -> Result<(), E>,
+    {
+        let alloc: KA = Default::default();
+        unsafe { OpaqueExt::new_kbox_in(init, alloc) }
+    }
 }
 
 impl<T> OpaqueExt for T
 where
     T: Opaque,
 {
-    unsafe fn new_kbox<E, F>(init: F) -> Result<KBox<Self>, E>
+    unsafe fn new_kbox_in<E, F, KA>(init: F, alloc: KA) -> Result<KBox<Self, KA>, E>
     where
-        F: FnOnce(*mut Self) -> Result<(), E>,
+        KA: KernelAlloc,
+        Self: Sized,
+        F: FnOnce(&mut MaybeUninit<Self>) -> Result<(), E>,
     {
-        let mut b: KBox<MaybeUninit<T>> = KBox::new_uninit();
-        let ptr: *mut T = (*b).as_mut_ptr();
+        let mut b: KBox<MaybeUninit<T>, KA> = KBox::new_uninit_in(alloc);
         // SAFETY: If init() succeeded, the value is now initialized.
-        init(ptr).map(|_| unsafe { b.assume_init() })
+        init(&mut b).map(|_| unsafe { b.assume_init() })
     }
 }
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/mod.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/mod.rs
index afc0b7a3eda2c3db9e4eaa44a1eb0b243e3a5c54..f1e7c79b730c645295d29600ff6938891a6f5c9c 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/mod.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/mod.rs
@@ -7,3 +7,4 @@ pub mod panic;
 pub mod printk;
 pub mod sync;
 pub mod sysfs;
+pub mod tracepoint;
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/module.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/module.rs
index 2e75b352e016b66adff69dba78a8ab392b3619cf..8d2cc3de0394068d0a99512c8208d425e2c290ba 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/module.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/module.rs
@@ -1,44 +1,74 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 
-use alloc::boxed::Box;
 use core::ffi::c_int;
 
-use crate::init::module_main;
-use crate::prelude::*;
-use crate::runtime::sync::{Lock, new_static_mutex};
+use crate::{
+    init::module_main,
+    lifecycle::LifeCycle,
+    prelude::*,
+    runtime::{
+        printk::pr_err,
+        sync::{Lock, new_static_mutex},
+    },
+};
+
+enum State<T> {
+    Initial,
+    Initialized(T),
+    Deinitialized,
+}
 
 new_static_mutex!(
     MAIN_ITERATOR,
-    Option<Box<dyn Iterator<Item = c_int> + Send>>,
-    None
+    State<LifeCycle<(), (), c_int>>,
+    State::Initial
 );
 
 #[cexport(export_name = "rust_mod_init")]
 pub fn rust_mod_init() -> c_int {
-    let mut iterator = Box::new(module_main());
-    let ret = iterator.next().expect("Main iterator did not yield once");
-    if ret == 0 {
-        *MAIN_ITERATOR.lock() = Some(iterator);
-        0
-    } else {
-        assert_eq!(
-            iterator.next(),
-            None,
-            "Main iterator yielded more than once"
-        );
-        ret
+    // Take the lock at the beginning so there is no risk of nesting multiple calls or anything
+    // nasty like that.
+    let mut guard = MAIN_ITERATOR.lock();
+    assert!(
+        matches!(&*guard, State::Initial),
+        "rust_mod_init() was called multiple times"
+    );
+
+    let mut lifecycle = module_main();
+    match lifecycle.start(()) {
+        Ok(()) => {
+            *guard = State::Initialized(lifecycle);
+            0
+        }
+        Err(err) => {
+            pr_err!("rust_mod_init() returned an error: {err}");
+            // Immediately run the deinit() function, since the kernel will prevent the module from
+            // being unloaded if module_init returned non-zero.
+            pr_info!("Running rust_mod_exit() Immediately as rust_mod_init() returned an error.");
+            *guard = State::Deinitialized;
+            if let Err(err) = lifecycle.stop() {
+                pr_err!("rust_mod_exit() returned an error: {err}");
+            };
+
+            // We cleaned up behind us, so we can return success. If we return an error here, the
+            // kernel will not recover from that and it will not be possible to unload the module,
+            // which is going to be problematic for the user.
+            0
+        }
     }
 }
 
 #[cexport(export_name = "rust_mod_exit")]
 pub fn rust_mod_exit() {
-    let mut iterator = MAIN_ITERATOR.lock();
-    let iterator = iterator
-        .as_mut()
-        .expect("rust_mod_init() was not called before rust_mod_exit()");
-    assert_eq!(
-        iterator.next(),
-        None,
-        "Main iterator yielded more than once"
-    );
+    let mut guard = MAIN_ITERATOR.lock();
+    match &mut *guard {
+        State::Initial => panic!("rust_mod_init() was not called before rust_mod_exit()"),
+        State::Initialized(lifecycle) => {
+            if let Err(err) = lifecycle.stop() {
+                pr_err!("rust_mod_exit() returned an error: {err}")
+            }
+            *guard = State::Deinitialized;
+        }
+        State::Deinitialized => pr_info!("rust_mod_exit() already called, doing nothing"),
+    }
 }
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/panic.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/panic.rs
index 3c6fbb305089ef2daffce04e012c6ea4125c5bf2..3bb32d468b16cf87cc42ef0a3e88e63b55db6d1b 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/panic.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/panic.rs
@@ -1,53 +1,12 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 
-use core::{
-    cmp::min,
-    fmt::Write,
-    fmt::{self},
-    ops::{Deref, DerefMut},
-};
-
-use crate::inlinec::cfunc;
+use core::fmt::Write;
 
-struct SliceWriter<'a> {
-    slice: &'a mut [u8],
-    cursor: usize,
-}
-
-impl<'a> SliceWriter<'a> {
-    fn new(slice: &'a mut [u8]) -> Self {
-        SliceWriter { slice, cursor: 0 }
-    }
-}
-
-impl Deref for SliceWriter<'_> {
-    type Target = [u8];
-    #[inline(always)]
-    fn deref(&self) -> &Self::Target {
-        &self.slice[self.cursor..]
-    }
-}
-
-impl DerefMut for SliceWriter<'_> {
-    #[inline(always)]
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.slice[self.cursor..]
-    }
-}
-
-impl fmt::Write for SliceWriter<'_> {
-    #[inline(always)]
-    fn write_str(&mut self, s: &str) -> Result<(), fmt::Error> {
-        let src = s.as_bytes();
-        let dst = &mut *self;
-
-        // Crop to our size, so we don't risk panicking.
-        let len = min(src.len(), dst.len());
-        dst[0..len].clone_from_slice(&src[0..len]);
-        self.cursor += len;
-        Ok(())
-    }
-}
+use crate::{
+    inlinec::cfunc,
+    misc::KBoxWriter,
+    runtime::alloc::{GFPFlags, KmallocAllocator},
+};
 
 #[allow(dead_code)]
 fn _panic(info: &core::panic::PanicInfo) -> ! {
@@ -57,24 +16,26 @@ fn _panic(info: &core::panic::PanicInfo) -> ! {
         if (msg.data && msg.len) {
             panic("Rust panic: %.*s", (int)msg.len, msg.data);
         } else {
-            panic("Rust panic with no message");
+            panic("Rust panic with no message or panicking encountered an error");
         }
         "#
     }
 
-    let mut buf = [0; 128];
     let msg = info.message();
-    let out: &[u8] = match msg.as_str() {
-        Some(s) => s.as_bytes(),
+    match msg.as_str() {
+        Some(s) => panic(s.as_bytes()),
         None => {
-            let mut out = SliceWriter::new(buf.as_mut_slice());
-            match write!(out, "{}", msg) {
-                Ok(()) => &buf,
-                Err(_) => "<error while formatting panic message>".as_bytes(),
-            }
+            KBoxWriter::<KmallocAllocator<{ GFPFlags::Atomic }>, _>::with_writer(
+                "[...]",
+                128,
+                |mut writer| {
+                    // Not much we can do with a write error here since we already are panicking.
+                    let _ = write!(writer, "{}", msg);
+                    panic(writer.written())
+                },
+            );
         }
     };
-    panic(out);
 
     #[allow(clippy::empty_loop)]
     loop {}
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/printk.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/printk.rs
index f8dea14be82054ace1bb34c1d1d68070049de004..da7a49209d5bddc09d84afa45e3276136dff614c 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/printk.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/printk.rs
@@ -1,11 +1,12 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 
-use crate::inlinec::cfunc;
+use core::fmt::Write as _;
 
-enum DmesgWriterState {
-    Init,
-    Cont,
-}
+use crate::{
+    inlinec::cfunc,
+    misc::KBoxWriter,
+    runtime::alloc::{GFPFlags, KmallocAllocator},
+};
 
 #[derive(Copy, Clone)]
 #[repr(u8)]
@@ -21,34 +22,18 @@ pub enum DmesgLevel {
     Cont = 8,
 }
 
-pub struct __DmesgWriter {
-    state: DmesgWriterState,
-    level: DmesgLevel,
-}
-
-impl __DmesgWriter {
-    pub fn new(level: DmesgLevel) -> Self {
-        __DmesgWriter {
-            level,
-            state: DmesgWriterState::Init,
-        }
-    }
-}
-
-impl core::fmt::Write for __DmesgWriter {
-    fn write_str(&mut self, s: &str) -> core::fmt::Result {
-        let level = match self.state {
-            DmesgWriterState::Init => self.level,
-            DmesgWriterState::Cont => DmesgLevel::Cont,
-        };
-        self.state = DmesgWriterState::Cont;
-
+pub fn __pr_level_impl(level: DmesgLevel, fmt: core::fmt::Arguments<'_>) -> core::fmt::Result {
+    fn write_dmesg<T: AsRef<[u8]>>(level: DmesgLevel, msg: T) -> core::fmt::Result {
         #[cfunc]
         fn printk<'a>(level: u8, msg: &[u8]) {
-            "#include <main.h>";
+            "#include <linux/printk.h>";
 
             r#"
-            #define HANDLE(level, f) case level: f("%.*s", (int)msg.len, msg.data); break;
+            #pragma push_macro("pr_fmt")
+            #undef pr_fmt
+            #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+            #define HANDLE(level, f) case level: f("%.*s\n", (int)msg.len, msg.data); break;
             switch (level) {
                 HANDLE(0, pr_emerg);
                 HANDLE(1, pr_alert);
@@ -61,25 +46,54 @@ impl core::fmt::Write for __DmesgWriter {
                 HANDLE(8, pr_cont);
             }
             #undef HANDLE
+            #pragma pop_macro("pr_fmt")
             "#
         }
 
-        printk(level as u8, s.as_bytes());
+        printk(level as u8, msg.as_ref());
         Ok(())
     }
+
+    match fmt.as_str() {
+        // If the format is just a plain string, we can simply display it directly, no need to
+        // allocate anything.
+        Some(s) => write_dmesg(level, s),
+        None => {
+            KBoxWriter::<KmallocAllocator<{ GFPFlags::Atomic }>, _>::with_writer(
+                "[...]",
+                128,
+                |mut writer| {
+                    let res = writer.write_fmt(fmt);
+                    // Make sure we always print what we have, even if we had some errors when rendering the
+                    // string to the buffer. Errors could be as mundane as running out of space in the buffer,
+                    // but we still want to see what _could_ be rendered.
+                    write_dmesg(level, writer.written()).and(res)
+                },
+            )
+        }
+    }
 }
 
 macro_rules! __pr_level {
     ($level:expr, $($arg:tt)*) => {{
-        use ::core::fmt::Write as _;
-        ::core::write!(
-            $crate::runtime::printk::__DmesgWriter::new($level),
-            $($arg)*
+        $crate::runtime::printk::__pr_level_impl(
+            $level,
+            ::core::format_args!($($arg)*)
         ).expect("Could not write to dmesg")
     }}
 }
 pub(crate) use __pr_level;
 
+macro_rules! pr_debug {
+    ($($arg:tt)*) => {{
+        $crate::runtime::printk::__pr_level!(
+            $crate::runtime::printk::DmesgLevel::Debug,
+            $($arg)*
+        )
+    }}
+}
+pub(crate) use pr_debug;
+
 macro_rules! pr_info {
     ($($arg:tt)*) => {{
         $crate::runtime::printk::__pr_level!(
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/sync.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/sync.rs
index ee86041726fe20f50ca8f544549eb14eaa713ae1..3163d0899a19a31094521626f31762d65ea0eca3 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/sync.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/sync.rs
@@ -11,7 +11,7 @@ use core::{
 
 use crate::{
     inlinec::{cfunc, opaque_type},
-    runtime::kbox::KBox,
+    runtime::kbox::KernelKBox,
 };
 
 pub trait LockGuard<T>
@@ -55,14 +55,14 @@ pub struct SpinLock<T> {
     data: UnsafeCell<T>,
     // The Rust For Linux binding pins the spinlock binding, so do the same here to avoid any
     // problems.
-    c_lock: Pin<KBox<UnsafeCell<CSpinLock>>>,
+    c_lock: Pin<KernelKBox<UnsafeCell<CSpinLock>>>,
 }
 
 impl<T> SpinLock<T> {
     #[inline]
     pub fn new(x: T) -> Self {
         #[cfunc]
-        fn spinlock_alloc() -> Pin<KBox<UnsafeCell<CSpinLock>>> {
+        fn spinlock_alloc() -> Pin<KernelKBox<UnsafeCell<CSpinLock>>> {
             r#"
             #include <linux/spinlock.h>
             #include <linux/slab.h>
@@ -160,6 +160,8 @@ impl<T> Drop for SpinLockGuard<'_, T> {
 impl<T> LockGuard<T> for SpinLockGuard<'_, T> {}
 
 unsafe impl<T: Send> Sync for SpinLock<T> {}
+unsafe impl<T: Send> Send for SpinLock<T> {}
+
 impl<T: Send> Lock<T> for SpinLock<T> {
     type Guard<'a>
         = SpinLockGuard<'a, T>
@@ -189,7 +191,7 @@ impl<'a, T: 'a + Send> _LockMut<'a, T> for SpinLock<T> {}
 opaque_type!(pub struct CMutex, "struct mutex", "linux/mutex.h");
 
 enum AllocatedCMutex {
-    KBox(Pin<KBox<UnsafeCell<CMutex>>>),
+    KBox(Pin<KernelKBox<UnsafeCell<CMutex>>>),
     Static(Pin<&'static UnsafeCell<CMutex>>),
 }
 
@@ -242,7 +244,7 @@ impl<T> Mutex<T> {
     #[inline]
     pub fn new(x: T) -> Self {
         #[cfunc]
-        fn mutex_alloc() -> Pin<KBox<UnsafeCell<CMutex>>> {
+        fn mutex_alloc() -> Pin<KernelKBox<UnsafeCell<CMutex>>> {
             r#"
             #include <linux/mutex.h>
             #include <linux/slab.h>
@@ -346,7 +348,9 @@ impl<T> Drop for MutexGuard<'_, T> {
 
 impl<T> LockGuard<T> for MutexGuard<'_, T> {}
 
+unsafe impl<T: Send> Send for Mutex<T> {}
 unsafe impl<T: Send> Sync for Mutex<T> {}
+
 impl<T: Send> Lock<T> for Mutex<T> {
     type Guard<'a>
         = MutexGuard<'a, T>
@@ -479,6 +483,8 @@ impl<T> Drop for RcuGuard<'_, T> {
 }
 
 unsafe impl<T: Send> Sync for Rcu<T> {}
+unsafe impl<T: Send> Send for Rcu<T> {}
+
 impl<T: Send> Lock<T> for Rcu<T> {
     type Guard<'a>
         = RcuGuard<'a, T>
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/sysfs.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/sysfs.rs
index ec8eb8ddea3db162dd21f6ee8206128ff877046a..f5e6f0420e929c2ec00070a793ba74035d9f4357 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/sysfs.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/sysfs.rs
@@ -12,7 +12,7 @@ use core::{
 
 use crate::{
     inlinec::{c_eval, cexport, cfunc, opaque_type},
-    {container_of, mut_container_of},
+    misc::{container_of, mut_container_of},
 };
 
 opaque_type!(
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/tracepoint.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/tracepoint.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f720d71b7f8a4d93905a2eca1e31619eeabe24ed
--- /dev/null
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/runtime/tracepoint.rs
@@ -0,0 +1,79 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+use core::{cell::UnsafeCell, ffi::c_void};
+
+use crate::inlinec::{cfunc, opaque_type};
+
+opaque_type!(
+    struct CTracepoint,
+    "struct tracepoint",
+    "linux/tracepoint.h",
+);
+
+pub struct Tracepoint<'tp> {
+    // struct tracepoint API allows mutation but protects it with an internal mutex
+    // (tracepoint_mutex static variable in tracepoint.c)
+    c_tp: &'tp UnsafeCell<CTracepoint>,
+}
+
+impl Tracepoint<'static> {
+    /// # Safety
+    ///
+    /// The tracepoint being looked up must be defined in the base kernel image, not in a module.
+    /// Otherwise the lifetime of the resulting tracepoint is unknown.
+    pub unsafe fn lookup(name: &'static str) -> Option<Self> {
+        /// # Safety
+        ///
+        /// The lifetime of the tracepoint depends on where it was defined. If it was defined in the
+        /// base kernel Image, then it's (probably) 'static, but if it was defined in a module, then
+        /// it's as long as the owning module lives.
+        ///
+        /// ftrace does seem to provide a way to know who owns
+        /// a given tracepoint though (to be checked).
+        #[cfunc]
+        unsafe fn find_tp<'tp>(name: &'static [u8]) -> Option<&'tp UnsafeCell<CTracepoint>> {
+            r#"
+            #include <linux/tracepoint.h>
+            #include <linux/string.h>
+
+            struct __find_tracepoint_params {
+                const char *name;
+                struct tracepoint *found;
+            };
+
+            static void __do_find_tracepoint(struct tracepoint *tp, void *__finder) {
+                struct __find_tracepoint_params *finder = __finder;
+                if (!strcmp(tp->name, finder->name))
+                    finder->found = tp;
+            }
+            "#;
+
+            r#"
+            struct __find_tracepoint_params res = {.name = name.data, .found = NULL};
+            for_each_kernel_tracepoint(__do_find_tracepoint, &res);
+            return res.found;
+            "#
+        }
+
+        // SAFETY: The user guarantees that lookup() will only be used for tracepoints defined in
+        // the base kernel image, so with a 'static lifetime
+        let c_tp = unsafe { find_tp(name.as_bytes())? };
+        Some(Tracepoint { c_tp })
+    }
+
+    fn register_probe(&self, probe: *mut c_void) -> Result<(), ()> {
+        #[cfunc]
+        fn register(tp: *mut CTracepoint, probe: *mut c_void) {
+            r#"
+            #include <linux/tracepoint.h>
+            #include <linux/string.h>
+            "#;
+
+            r#"
+            tracepoint_probe_register(tp, probe, NULL); \
+            "#
+        }
+        register(self.c_tp.get(), probe);
+        Ok(())
+    }
+}
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/tests.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/tests.rs
index 9dda47fd2806302541e8bc6218a8c4b3a917b714..826569de2e5d82580c1cf7c5bb928a97f5455963 100644
--- a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/tests.rs
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/tests.rs
@@ -1,11 +1,7 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 
-use alloc::collections::BTreeMap;
-use alloc::sync::Arc;
-use alloc::vec;
-use alloc::vec::Vec;
-use core::ffi::CStr;
-use core::ffi::c_int;
+use alloc::{collections::BTreeMap, sync::Arc, vec, vec::Vec};
+use core::ffi::{CStr, c_int};
 
 use crate::prelude::*;
 
@@ -178,14 +174,14 @@ fn test_6() {
     pr_info!("Rust: test_6");
 
     {
-        let b = KBox::new(42u8);
+        let b = KernelKBox::new(42u8);
         assert_eq!(*b, 42);
         drop(b);
     }
 
     {
         let zst_addr = c_eval!("linux/slab.h", "ZERO_SIZE_PTR", *const u8);
-        let b = KBox::new(());
+        let b = KernelKBox::new(());
         assert_eq!(b.as_ptr() as usize, zst_addr as usize);
         drop(b);
     }
@@ -197,8 +193,9 @@ use crate::runtime::sync::new_static_mutex;
 fn test_7() {
     pr_info!("Rust: test_7");
 
-    use crate::runtime::sync::{Lock, Mutex, SpinLock};
     use core::ops::{Deref, DerefMut};
+
+    use crate::runtime::sync::{Lock, Mutex, SpinLock};
     {
         new_static_mutex!(STATIC_MUTEX, u32, 42);
         macro_rules! test_lock {
diff --git a/lisa/_assets/kmodules/lisa/rust/lisakmod/src/typemap.rs b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/typemap.rs
new file mode 100644
index 0000000000000000000000000000000000000000..510a90ac443b1a67fa3e8cedfb215ea89f5eb209
--- /dev/null
+++ b/lisa/_assets/kmodules/lisa/rust/lisakmod/src/typemap.rs
@@ -0,0 +1,199 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+use alloc::{boxed::Box, collections::BTreeMap, format};
+use core::{
+    any::{Any, TypeId},
+    fmt,
+    marker::PhantomData,
+};
+
+trait Value: Any + fmt::Debug {
+    fn as_any(&self) -> &dyn Any;
+    // We need to know the key name from the trait object directly for
+    // the Debug implementation. This way we can debug-print key/value without
+    // knowing what is the concrete type of any of the values.
+    fn key_name(&self) -> &str;
+}
+
+/// Wraps the value of a key in a struct that knows its associated `Key` type.
+/// This way, when abstracted behind a `&dyn Value`, it can still report
+/// the name of its key
+struct ValueOf<Idx, Key>
+where
+    Key: ?Sized + KeyOf<Idx>,
+{
+    value: <Key as KeyOf<Idx>>::Value,
+}
+
+impl<Idx, Key> ValueOf<Idx, Key>
+where
+    Key: ?Sized + KeyOf<Idx>,
+{
+    fn new(value: <Key as KeyOf<Idx>>::Value) -> Self {
+        ValueOf { value }
+    }
+}
+
+impl<Idx, Key> Value for ValueOf<Idx, Key>
+where
+    Idx: 'static,
+    Key: ?Sized + KeyOf<Idx>,
+    <Key as KeyOf<Idx>>::Value: Any + fmt::Debug,
+{
+    #[inline]
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    #[inline]
+    fn key_name(&self) -> &str {
+        core::any::type_name::<Key>()
+    }
+}
+
+impl<Idx, Key> fmt::Debug for ValueOf<Idx, Key>
+where
+    Key: ?Sized + KeyOf<Idx>,
+    <Key as KeyOf<Idx>>::Value: fmt::Debug,
+{
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.value.fmt(f)
+    }
+}
+
+/// Declare `Self` as being a valid type-level key for index `Idx`
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an valid key for index {Idx}, add it using: add_index_key!({Idx}, {Self}, <type of value>)"
+)]
+pub trait KeyOf<Idx>: Any {
+    /// Type of the values that will bound found for key `Self`
+    type Value: AllowedValueOf<Idx>;
+}
+
+/// # Safety
+/// An impl is sound iff Self satisfies all the bounds passed to make_index!(). This is relied upon
+/// to ensure all values satisfy certain bounds so we can provide auto-trait implementations for
+/// TypeMap.
+#[diagnostic::on_unimplemented(
+    message = "`{Self}` is not an valid Value for index {Idx} as it does not satisfy the bounds mentioned in make_index!({Idx}, <bounds>). DO NOT IMPLEMENT THIS TRAIT YOURSELF"
+)]
+pub unsafe trait AllowedValueOf<Idx> {}
+
+pub struct TypeMap<Idx> {
+    _marker: PhantomData<Idx>,
+    inner: BTreeMap<TypeId, Box<dyn Value>>,
+}
+
+impl<Idx> fmt::Debug for TypeMap<Idx> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_map()
+            .entries(
+                self.inner
+                    .values()
+                    .map(|v| (v.key_name(), format!("{v:?}"))),
+            )
+            .finish()
+    }
+}
+
+impl<Idx> Default for TypeMap<Idx>
+where
+    Idx: 'static,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<Idx> TypeMap<Idx>
+where
+    Idx: 'static,
+{
+    #[inline]
+    pub fn new() -> Self {
+        TypeMap {
+            _marker: PhantomData,
+            inner: BTreeMap::new(),
+        }
+    }
+
+    #[inline]
+    pub fn insert<Key>(&mut self, value: <Key as KeyOf<Idx>>::Value)
+    where
+        Key: ?Sized + KeyOf<Idx>,
+        <Key as KeyOf<Idx>>::Value: 'static + fmt::Debug,
+    {
+        let type_id = TypeId::of::<Key>();
+        let value = ValueOf::<Idx, Key>::new(value);
+        self.insert_any(type_id, Box::new(value));
+    }
+
+    #[inline]
+    pub fn get<Key>(&self) -> Option<&<Key as KeyOf<Idx>>::Value>
+    where
+        Key: ?Sized + KeyOf<Idx>,
+        <Key as KeyOf<Idx>>::Value: 'static,
+    {
+        let key = TypeId::of::<Key>();
+        self.get_any(&key).map(|v| {
+            &v.as_any()
+                .downcast_ref::<ValueOf<Idx, Key>>()
+                .expect("An Any value of the wrong concrete type was inserted for that key.")
+                .value
+        })
+    }
+
+    #[inline]
+    fn insert_any(&mut self, type_id: TypeId, value: Box<dyn Value>) {
+        self.inner.insert(type_id, value);
+    }
+
+    #[inline]
+    fn get_any(&self, type_id: &TypeId) -> Option<&dyn Value> {
+        self.inner.get(type_id).map(|x| &**x)
+    }
+}
+
+macro_rules! make_index {
+    ($vis:vis $index:ident $(, $($value_bound:ident),*)?) => {
+        $vis struct $index {
+            // Make the index an opaque struct
+            _dummy: (),
+        }
+
+        // SAFETY: We ensure all types implementing that trait satisfy the bounds they are supposed
+        // to.
+        unsafe impl<T> $crate::typemap::AllowedValueOf<$index> for T
+        where
+            $($(
+                T: $value_bound,
+
+            )*)?
+        {}
+
+        $($(
+            $crate::typemap::make_index!(@impl $value_bound, $crate::typemap::TypeMap<$index>);
+        )?)*
+
+    };
+    (@impl Send, $ty:ty) => {
+        unsafe impl Send for $ty {}
+    };
+    (@impl Sync, $ty:ty) => {
+        unsafe impl Sync for $ty {}
+    };
+    (@impl $trait:ident, $ty:ty) => {
+        impl $trait for $ty {}
+    };
+}
+pub(crate) use make_index;
+
+macro_rules! add_index_key {
+    ($index:ty, $key:ty, $value_ty:ty) => {
+        impl $crate::typemap::KeyOf<$index> for $key {
+            type Value = $value_ty;
+        }
+    };
+}
diff --git a/lisa/_assets/kmodules/lisa/rust_exported_symbols.py b/lisa/_assets/kmodules/lisa/rust_exported_symbols.py
index 9f1850cb71152a2ea1286ee8ad62b53fa1b5a3c3..76ed68af49164fa0b8f4f97210e1b1b63b9f6e1b 100755
--- a/lisa/_assets/kmodules/lisa/rust_exported_symbols.py
+++ b/lisa/_assets/kmodules/lisa/rust_exported_symbols.py
@@ -22,6 +22,7 @@ from pathlib import Path
 from shlex import quote
 import subprocess
 import os
+import textwrap
 
 
 def main():
@@ -33,6 +34,7 @@ def main():
     parser.add_argument('--rust-object', help='Built Rust object file', required=True)
     parser.add_argument('--out-symbols-plain', help='File to write the symbol list, one per line')
     parser.add_argument('--out-symbols-cli', help='File to write the symbol list as ld CLI --undefined options')
+    parser.add_argument('--out-start-stop-lds', help='File to write the linker script to provide __start_SECNAME and __stop_SECNAME symbols, which are not provided by Kbuild since the module is never linked into an executable or DSO')
 
     args = parser.parse_args()
 
@@ -40,28 +42,29 @@ def main():
     out = subprocess.check_output(
         [nm, '-gj', args.rust_object],
     )
+    all_symbols = sorted(set(out.decode().split()))
 
-    # For each symbol we want to export in Rust, we create a companion symbol
-    # with a prefix that we pick up here. There unfortunately seems to be no
-    # cleaner way to convey the list of exported symbols from Rust code as of
-    # 2024.
-    prefix = b'__export_rust_symbol_'
-    def parse(sym):
+    def parse(sym, prefix):
         if sym.startswith(prefix):
             sym = sym[len(prefix):]
-            return sym.decode()
+            return sym
         else:
             return None
 
-    symbols = sorted(
+    # For each symbol we want to export in Rust, we create a companion symbol
+    # with a prefix that we pick up here. There unfortunately seems to be no
+    # cleaner way to convey the list of exported symbols from Rust code as of
+    # 2024.
+    user_symbols = [
         sym
-        for _sym in out.split()
-        if (sym := parse(_sym))
-    )
+        for _sym in all_symbols
+        if (sym := parse(_sym, '__export_rust_symbol_'))
+    ]
+
+    symbols = sorted(user_symbols)
 
     sep = '\n  '
-    pretty_symbols = sep.join(symbols)
-    print(f'Found exported symbols:{sep}{pretty_symbols}')
+    print(f'Found exported symbols:{sep}{sep.join(symbols)}')
 
     if (path := args.out_symbols_plain):
         content = '\n'.join(symbols) + '\n'
@@ -74,5 +77,30 @@ def main():
         )) + '\n'
         Path(path).write_text(content)
 
+    if (path := args.out_start_stop_lds):
+        sections = sorted({
+            section
+            for sym in all_symbols
+            if (
+                (section := parse(sym, '__start_')) or
+                (section := parse(sym, '__stop_'))
+            )
+        })
+        print(f'Found sections to generate __start_SECNAME and __stop_SECNAME symbols for:{sep}{sep.join(sections)}')
+
+        def make_lds(section):
+            return textwrap.dedent(f'''
+                SECTIONS {{
+                    {section} : {{
+                        PROVIDE(__start_{section} = .);
+                        KEEP(*({section}));
+                        PROVIDE(__stop_{section} = .);
+                    }}
+                }}
+            ''')
+
+        lds = '\n'.join(map(make_lds, sections)) + '\n'
+        Path(path).write_text(lds)
+
 if __name__ == '__main__':
     main()
diff --git a/lisa/_assets/kmodules/lisa/tp.h b/lisa/_assets/kmodules/lisa/tp.h
index 15c5210da5a861fc05896878aa6fcc05a348bd53..35f7fd6e9465a81804d11dc2e9a161292bc959df 100644
--- a/lisa/_assets/kmodules/lisa/tp.h
+++ b/lisa/_assets/kmodules/lisa/tp.h
@@ -31,24 +31,17 @@ struct __tp_probe {
 #define TP_PROBE(_tp_name, _probe) (&(const struct __tp_probe){.tp_name=_tp_name, .probe=_probe})
 #define TP_PROBES(...) ((const struct __tp_probe **)(const struct __tp_probe *[]){__VA_ARGS__, NULL})
 
-#define DEFINE_TP_ENABLE_DISABLE(feature_name, tp_probes, enable_name, enable_f, disable_name, disable_f) \
+#define DEFINE_TP_ENABLE_DISABLE(feature_name, tp_probes, enable_name, disable_name) \
 	static u64 CONCATENATE(__feature_tp_registered_, feature_name) = 0; \
 	static int enable_name(struct feature* feature) {		\
 		int ret = 0;						\
 		int __ret;						\
 		struct tracepoint *tp;					\
-		int (*_enable_f)(struct feature*) = enable_f;		\
 		__ret = ENABLE_FEATURE(__tp);				\
 		ret |= __ret;						\
 		if (ret) {						\
 			pr_err(#feature_name ": could not enable tracepoint support: %i\n", __ret); \
 		} else { 						\
-			if (_enable_f) {				\
-				__ret = _enable_f(feature);		\
-				ret |= __ret;				\
-				if (__ret)				\
-					pr_err(#feature_name ": init function " #enable_f "() failed with error: %i\n", __ret); \
-			}						\
 			if (!ret) {					\
 				const struct __tp_probe **__tp_probes = tp_probes;	\
 				for (size_t i=0; __tp_probes[i]; i++) {			\
@@ -73,7 +66,6 @@ struct __tp_probe {
 	static int disable_name(struct feature* feature) {		\
 		int ret = 0;						\
 		int __ret;						\
-		int (*_disable_f)(struct feature*) = disable_f;		\
 		const struct __tp_probe **__tp_probes = tp_probes;	\
 		for (size_t i=0; __tp_probes[i]; i++) {			\
 			BUG_ON(i > (sizeof(CONCATENATE(__feature_tp_registered_, feature_name)) * 8 - 1));\
@@ -88,34 +80,22 @@ struct __tp_probe {
 				}					\
 			}						\
 		}							\
-		if (_disable_f)						\
-			ret |= _disable_f(feature);			\
 		ret |= DISABLE_FEATURE(__tp);				\
 		return ret;						\
 	}								\
 
 /**
- * DEFINE_EXTENDED_TP_FEATURE() - Define a feature linked to a tracepoint.
+ * DEFINE_TP_FEATURE() - Define a feature linked to a tracepoint.
  * @feature_name: Name of the feature.
  * @probes: List of tracepoint probes built using TP_PROBES(TP_PROBE("my_tp", my_probe), ...)
- * @enable_f: Additional enable function for the feature. It must take a struct
- * feature * and return a non-zero int in case of failure.
- * @disable_f: Additional disable function for the feature. Same signature as enable_f().
  *
- * Define a feature with a probe attached to a tracepoint, with additional
- * user-defined enable/disable functions. If the tracepoint is not found, the
- * user functions will not be called.
+ * Define a feature with a probe attached to a tracepoint. If the tracepoint is
+ * not found, the user functions will not be called.
  */
-#define DEFINE_EXTENDED_TP_FEATURE(feature_name, probes, enable_f, disable_f) \
-	DEFINE_TP_ENABLE_DISABLE(feature_name, probes, CONCATENATE(__tp_feature_enable_, feature_name), enable_f, CONCATENATE(__tp_feature_disable_, feature_name), disable_f); \
+#define DEFINE_TP_FEATURE(feature_name, probes) \
+	DEFINE_TP_ENABLE_DISABLE(feature_name, probes, CONCATENATE(__tp_feature_enable_, feature_name), CONCATENATE(__tp_feature_disable_, feature_name)); \
 	DEFINE_FEATURE(feature_name, CONCATENATE(__tp_feature_enable_, feature_name), CONCATENATE(__tp_feature_disable_, feature_name));
 
-/**
- * DEFINE_TP_FEATURE() - Same as DEFINE_EXTENDED_TP_FEATURE() without custom
- * enable/disable functions.
- */
-#define DEFINE_TP_FEATURE(feature_name, probes) DEFINE_EXTENDED_TP_FEATURE(feature_name, probes, NULL, NULL)
-
 #define __EVENT_FEATURE(event_name) CONCATENATE(event__, event_name)
 
 /**
@@ -124,22 +104,4 @@ struct __tp_probe {
  */
 #define DEFINE_TP_EVENT_FEATURE(event_name, probes) DEFINE_TP_FEATURE(__EVENT_FEATURE(event_name), probes)
 
-/**
- * DEFINE_EXTENDED_TP_EVENT_FEATURE() - Same as DEFINE_EXTENDED_TP_FEATURE()
- * with automatic "event__" prefixing of the feature name.
- */
-#define DEFINE_EXTENDED_TP_EVENT_FEATURE(event_name, probes, enable_f, disable_f) DEFINE_EXTENDED_TP_FEATURE(__EVENT_FEATURE(event_name), probes, enable_f, disable_f)
-
-#define __DEPRECATED_EVENT_ENABLE(event_name) CONCATENATE(__enable_deprecated_feature_, __EVENT_FEATURE(event_name))
-/**
- * DEFINE_TP_DEPRECATED_EVENT_FEATURE() - Same as DEFINE_TP_EVENT_FEATURE()
- * with extra deprecation warnings upon init.
- */
-#define DEFINE_TP_DEPRECATED_EVENT_FEATURE(msg, event_name, probes)	\
-static int __DEPRECATED_EVENT_ENABLE(event_name)(struct feature *feature)	\
-{										\
-	pr_warn("The feature %s is deprecated: " msg, feature->name);		\
-	return 0;								\
-}										\
-DEFINE_EXTENDED_TP_EVENT_FEATURE(event_name, probes, __DEPRECATED_EVENT_ENABLE(event_name), NULL)
-#endif
+#endif /* _TP_H */
diff --git a/lisa/_assets/kmodules/lisa/wq.c b/lisa/_assets/kmodules/lisa/wq.c
index be641ffefc858f8cef3ed204bcaea4351c34007e..315244e50e5d252bbf271950bf9d5e774d84e9a7 100644
--- a/lisa/_assets/kmodules/lisa/wq.c
+++ b/lisa/_assets/kmodules/lisa/wq.c
@@ -54,16 +54,16 @@ int destroy_work(struct work_item *item) {
 static int init_wq(struct feature *feature) {
 	struct workqueue_struct *wq;
 	wq = alloc_workqueue("lisa", WQ_FREEZABLE, 0);
-	feature->data = wq;
 	if (!wq) {
 		pr_err("Could not allocate workqueue\n");
 		return 1;
 	}
+	feature_data_set(feature, wq);
 	return 0;
 }
 
 static int deinit_wq(struct feature *feature) {
-	struct workqueue_struct *wq = feature->data;
+	struct workqueue_struct *wq = feature_data(feature);
 	if (wq)
 		destroy_workqueue(wq);
 	return 0;
@@ -81,7 +81,7 @@ struct example_data {
 
 static int example_worker(void *data) {
 	struct feature *feature = data;
-	pr_info("executing a wq item of feature %s\n", feature->name);
+	pr_info("executing a wq item of feature %s\n", feature_name(feature));
 
 	/* Schedule the next run in 3 seconds */
 	/* return HZ * 3; */
@@ -95,15 +95,15 @@ static int example_worker(void *data) {
 
 __maybe_unused static int example_init(struct feature *feature) {
 	struct example_data *data;
-	pr_info("Starting worker for feature %s\n", feature->name);
+	pr_info("Starting worker for feature %s\n", feature_name(feature));
 
 	if (ENABLE_FEATURE(__workqueue))
 		return 1;
 
 	data = kmalloc(sizeof(*data), GFP_KERNEL);
-	feature->data = data;
 	if (!data)
 		return 1;
+	feature_data_set(feature, data);
 
 	data->work = start_work(example_worker, 2 * HZ, feature);
 	if (!data->work)
@@ -114,9 +114,9 @@ __maybe_unused static int example_init(struct feature *feature) {
 
 __maybe_unused static int example_deinit(struct feature *feature) {
 	int ret = 0;
-	struct example_data *data = feature->data;
+	struct example_data *data = feature_data(feature);
 
-	pr_info("Stopping worker for feature %s\n", feature->name);
+	pr_info("Stopping worker for feature %s\n", feature_name(feature));
 
 	if (data) {
 		ret |= destroy_work(data->work);
diff --git a/lisa/_kmod.py b/lisa/_kmod.py
index c692421f7ece907f4d933bb5f3a83b0bdf0dfe62..f697518bd5e16af514240fed4acc81273f0afb07 100644
--- a/lisa/_kmod.py
+++ b/lisa/_kmod.py
@@ -3314,7 +3314,7 @@ class FtraceDynamicKmod(DynamicKmod):
 
 class _LISADynamicKmodSrc(KmodSrc):
     _RUST_SPEC = dict(
-        version='1.83.0',
+        version='1.85.0',
         components=[
             # rust-src for -Zbuild-std
             'rust-src',