Merge pull request #1799 from hermit-os/kernel_function

refactor: inline kernel_function macro to allow non-Copy arguments

Author: mkroening

hermit-macro/src/system.rs

@@ -165,14 +165,26 @@ fn emit_func(func: ItemFn, sig: &ParsedSig, errno: bool) -> Result<ItemFn> {
 			ret
 		}},
 	};
+	let kernel_function_ident =
+		Ident::new(&format!("kernel_function{}", args.len()), Span::call_site());
 
 	let sys_func = ItemFn {
 		block: parse_quote! {{
 			#inner_func
 
 			#kernel_func
 
-			#unsafety { kernel_function!(#kernel_ident(#(#args),*)) }
+			#[cfg(not(any(
+				target_arch = "riscv64",
+				feature = "common-os"
+			)))]
+			unsafe { crate::arch::switch::#kernel_function_ident(#kernel_ident, #(#args),*) }
+
+			#[cfg(any(
+				target_arch = "riscv64",
+				feature = "common-os"
+			))]
+			#unsafety { #kernel_ident(#(#args),*) }
 		}},
 		..func
 	};
@@ -243,7 +255,17 @@ mod tests {
 					ret
 				}
 
-				{ kernel_function!(_sys_test(a, b)) }
+				#[cfg(not(any(
+					target_arch = "riscv64",
+					feature = "common-os"
+				)))]
+				unsafe { crate::arch::switch::kernel_function2(_sys_test, a, b) }
+
+				#[cfg(any(
+					target_arch = "riscv64",
+					feature = "common-os"
+				))]
+				{ _sys_test(a, b) }
 			}
 		};
 
@@ -302,7 +324,17 @@ mod tests {
 					ret
 				}
 
-				unsafe { kernel_function!(_sys_test(a, b)) }
+				#[cfg(not(any(
+					target_arch = "riscv64",
+					feature = "common-os"
+				)))]
+				unsafe { crate::arch::switch::kernel_function2(_sys_test, a, b) }
+
+				#[cfg(any(
+					target_arch = "riscv64",
+					feature = "common-os"
+				))]
+				unsafe { _sys_test(a, b) }
 			}
 		};
 
@@ -363,7 +395,17 @@ mod tests {
 					ret
 				}
 
-				{ kernel_function!(_sys_test(a, b)) }
+				#[cfg(not(any(
+					target_arch = "riscv64",
+					feature = "common-os"
+				)))]
+				unsafe { crate::arch::switch::kernel_function2(_sys_test, a, b) }
+
+				#[cfg(any(
+					target_arch = "riscv64",
+					feature = "common-os"
+				))]
+				{ _sys_test(a, b) }
 			}
 		};
 

src/macros.rs

@@ -76,129 +76,6 @@ macro_rules! dbg {
     };
 }
 
-cfg_if::cfg_if! {
-	if #[cfg(not(any(
-		target_arch = "riscv64",
-		feature = "common-os"
-	)))] {
-		/// Runs `f` on the kernel stack.
-		///
-		/// All arguments and return values have to fit into registers:
-		///
-		/// ```
-		/// assert!(mem::size_of::<T>() <= mem::size_of::<usize>());
-		/// ```
-		///
-		/// When working with bigger types, manually route the data over pointers:
-		///
-		/// ```
-		/// f(&arg1, &mut ret);
-		/// // instead of
-		/// let ret = f(arg);
-		/// ```
-		#[allow(unused_macro_rules)]
-		macro_rules! kernel_function {
-			($f:ident()) => {{
-				// This propagates any unsafety requirements of `f` to the caller.
-				if false {
-					$f();
-				}
-
-				#[allow(unreachable_code)]
-				#[allow(unused_unsafe)]
-				unsafe {
-					$crate::arch::switch::kernel_function0($f)
-				}
-			}};
-
-			($f:ident($arg1:expr)) => {{
-				// This propagates any unsafety requirements of `f` to the caller.
-				if false {
-					$f($arg1);
-				}
-
-				#[allow(unreachable_code)]
-				#[allow(unused_unsafe)]
-				unsafe {
-					$crate::arch::switch::kernel_function1($f, $arg1)
-				}
-			}};
-
-			($f:ident($arg1:expr, $arg2:expr)) => {{
-				// This propagates any unsafety requirements of `f` to the caller.
-				if false {
-					$f($arg1, $arg2);
-				}
-
-				#[allow(unreachable_code)]
-				#[allow(unused_unsafe)]
-				unsafe {
-					$crate::arch::switch::kernel_function2($f, $arg1, $arg2)
-				}
-			}};
-
-			($f:ident($arg1:expr, $arg2:expr, $arg3:expr)) => {{
-				// This propagates any unsafety requirements of `f` to the caller.
-				if false {
-					$f($arg1, $arg2, $arg3);
-				}
-
-				#[allow(unreachable_code)]
-				#[allow(unused_unsafe)]
-				unsafe {
-					$crate::arch::switch::kernel_function3($f, $arg1, $arg2, $arg3)
-				}
-			}};
-
-			($f:ident($arg1:expr, $arg2:expr, $arg3:expr, $arg4:expr)) => {{
-				// This propagates any unsafety requirements of `f` to the caller.
-				if false {
-					$f($arg1, $arg2, $arg3, $arg4);
-				}
-
-				#[allow(unreachable_code)]
-				#[allow(unused_unsafe)]
-				unsafe {
-					$crate::arch::switch::kernel_function4($f, $arg1, $arg2, $arg3, $arg4)
-				}
-			}};
-
-			($f:ident($arg1:expr, $arg2:expr, $arg3:expr, $arg4:expr, $arg5:expr)) => {{
-				// This propagates any unsafety requirements of `f` to the caller.
-				if false {
-					$f($arg1, $arg2, $arg3, $arg4, $arg5);
-				}
-
-				#[allow(unreachable_code)]
-				#[allow(unused_unsafe)]
-				unsafe {
-					$crate::arch::switch::kernel_function5($f, $arg1, $arg2, $arg3, $arg4, $arg5)
-				}
-			}};
-
-			($f:ident($arg1:expr, $arg2:expr, $arg3:expr, $arg4:expr, $arg5:expr, $arg6:expr)) => {{
-				// This propagates any unsafety requirements of `f` to the caller.
-				if false {
-					$f($arg1, $arg2, $arg3, $arg4, $arg5, $arg6);
-				}
-
-				#[allow(unreachable_code)]
-				#[allow(unused_unsafe)]
-				unsafe {
-					$crate::arch::switch::kernel_function6($f, $arg1, $arg2, $arg3, $arg4, $arg5, $arg6)
-				}
-			}};
-		}
-	} else {
-		// TODO: Switch kernel stack on RISC-V
-		macro_rules! kernel_function {
-			($f:ident($($x:tt)*)) => {{
-				$f($($x)*)
-			}};
-		}
-	}
-}
-
 /// Returns the value of the specified environment variable.
 ///
 /// The value is fetched from the current runtime environment and, if not

src/syscalls/entropy.rs

@@ -45,18 +45,15 @@ unsafe fn read_entropy(buf: *mut u8, len: usize, flags: u32) -> isize {
 	}
 }
 
-unsafe extern "C" fn __sys_read_entropy(buf: *mut u8, len: usize, flags: u32) -> isize {
-	unsafe { read_entropy(buf, len, flags) }
-}
-
 /// Fill `len` bytes in `buf` with cryptographically secure random data.
 ///
 /// Returns either the number of bytes written to buf (a positive value) or
 /// * `-EINVAL` if `flags` contains unknown flags.
 /// * `-ENOSYS` if the system does not support random data generation.
+#[hermit_macro::system]
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn sys_read_entropy(buf: *mut u8, len: usize, flags: u32) -> isize {
-	unsafe { kernel_function!(__sys_read_entropy(buf, len, flags)) }
+	unsafe { read_entropy(buf, len, flags) }
 }
 
 /// Create a cryptographicly secure 32bit random number with the support of