custom virtio-drivers

add rng device and virtio rng

Author: lhw

Cargo.lock

@@ -59,6 +59,7 @@ V9P ?= n
 BUS ?= mmio
 RISCV_BIOS ?= default
 GICV3 ?= n
+RNG ?= n
 
 DISK_IMG ?= disk.img
 FS ?= fat32

Makefile

@@ -75,6 +75,9 @@ display = [
     "ruxruntime/display",
 ]
 
+#virtio random number generator
+virtio-rng = ["ruxdriver/virtio-rng","ruxruntime/rng"]
+
 # 9P
 virtio-9p = [
     "9pfs",

api/ruxfeat/Cargo.toml

@@ -32,6 +32,8 @@ poll = ["fd"]
 tls = ["ruxfeat/tls"]
 irq = ["ruxfeat/irq"]
 random-hw = []
+rng = ["ruxrand"]
+virtio-rng = ["driver_virtio/rng","rng"]
 
 musl = ["ruxhal/musl", "ruxruntime/musl", "axalloc/slab", "ruxtask/musl"]
 
@@ -51,6 +53,7 @@ ruxtask = { path = "../../modules/ruxtask", features = [
 ], optional = true }
 ruxfs = { path = "../../modules/ruxfs", optional = true }
 ruxnet = { path = "../../modules/ruxnet", optional = true }
+ruxrand = { path = "../../modules/ruxrand", optional = true }
 
 # Other crates
 tty = { path = "../../crates/tty" }
@@ -68,6 +71,8 @@ flatten_objects = { path = "../../crates/flatten_objects" }
 page_table = { path = "../../crates/page_table" }
 crate_interface = "0.1.1"
 capability = { path = "../../crates/capability" }
+driver_virtio = { path = "../../crates/driver_virtio" }
+
 
 cfg-if = "1.0"
 elf = { version = "0.7", default-features = false }

api/ruxos_posix_api/Cargo.toml

@@ -118,14 +118,19 @@ pub unsafe extern "C" fn sys_srand(_seed: c_uint) {
 /// Returns a 32-bit unsigned random integer
 #[no_mangle]
 pub unsafe extern "C" fn sys_rand() -> c_int {
+    #[cfg(feature = "rng")]
+    {
+        use ruxrand::random;
+        return random::<c_int>();
+    }
     #[cfg(feature = "random-hw")]
     {
         match has_rdrand() {
             true => (random_hw() >> 33) as c_int,
             false => rand_lcg32() as c_int,
         }
     }
-    #[cfg(not(feature = "random-hw"))]
+    #[cfg(not(any(feature = "random-hw", feature = "rng")))]
     {
         rand_lcg32() as c_int
     }
@@ -134,14 +139,19 @@ pub unsafe extern "C" fn sys_rand() -> c_int {
 /// Returns a 64-bit unsigned random integer
 #[no_mangle]
 pub unsafe extern "C" fn sys_random() -> c_long {
+    #[cfg(feature = "rng")]
+    {
+        use ruxrand::random;
+        return random::<c_long>();
+    }
     #[cfg(feature = "random-hw")]
     {
         match has_rdrand() {
             true => (random_hw() >> 1) as c_long,
             false => random_lcg64() as c_long,
         }
     }
-    #[cfg(not(feature = "random-hw"))]
+    #[cfg(not(any(feature = "random-hw", feature = "rng")))]
     {
         random_lcg64() as c_long
     }
@@ -162,15 +172,29 @@ pub unsafe extern "C" fn sys_getrandom(buf: *mut c_void, buflen: size_t, flags:
         if flags != 0 {
             warn!("flags are not implemented yet, flags: {}, ignored", flags);
         }
-        // fill the buffer 8 bytes at a time first, then fill the remaining bytes
-        let buflen_mod = buflen % (core::mem::size_of::<i64>() / core::mem::size_of::<u8>());
-        let buflen_div = buflen / (core::mem::size_of::<i64>() / core::mem::size_of::<u8>());
-        for i in 0..buflen_div {
-            *((buf as *mut u8 as *mut i64).add(i)) = sys_random() as i64;
+        #[cfg(feature = "rng")]
+        {
+            use ruxrand::request_entropy;
+            let slice: &mut [u8] =
+                unsafe { core::slice::from_raw_parts_mut(buf as *mut u8, buflen) };
+            request_entropy(slice).map_err(|e| {
+                warn!("Failed to get random bytes: {:?}", e);
+                LinuxError::EIO
+            })?;
+            Ok(buflen as ssize_t)
         }
-        for i in 0..buflen_mod {
-            *((buf as *mut u8).add(buflen - buflen_mod + i)) = sys_rand() as u8;
+        #[cfg(not(feature = "rng"))]
+        {
+            // fill the buffer 8 bytes at a time first, then fill the remaining bytes
+            let buflen_mod = buflen % (core::mem::size_of::<i64>() / core::mem::size_of::<u8>());
+            let buflen_div = buflen / (core::mem::size_of::<i64>() / core::mem::size_of::<u8>());
+            for i in 0..buflen_div {
+                *((buf as *mut u8 as *mut i64).add(i)) = sys_random() as i64;
+            }
+            for i in 0..buflen_mod {
+                *((buf as *mut u8).add(buflen - buflen_mod + i)) = sys_rand() as u8;
+            }
+            Ok(buflen as ssize_t)
         }
-        Ok(buflen as ssize_t)
     })
 }

api/ruxos_posix_api/src/imp/getrandom.rs

@@ -0,0 +1 @@
+virtio-rng

apps/c/random/features.txt

@@ -0,0 +1,21 @@
+#define _GNU_SOURCE
+#include <sys/random.h>
+#include <stdio.h>
+
+int main() {
+    printf("Using getrandom to fetch random bytes...\n");
+    unsigned char buf[16];
+    ssize_t n = getrandom(buf, sizeof(buf), 0);
+    if (n < 0) {
+        perror("getrandom");
+        return 1;
+    }
+
+    printf("Random bytes:\n");
+    for (int i = 0; i < n; ++i) {
+        printf("%02x ", buf[i]);
+    }
+    printf("\n");
+
+    return 0;
+}

apps/c/random/main.c

@@ -38,6 +38,8 @@ pub enum DeviceType {
     Display,
     /// Plan-9 device (e.g. 9pfs)
     _9P,
+    /// Random number generator device.
+    Rng,
 }
 
 /// The error type for device operation failures.

crates/driver_common/src/lib.rs

@@ -0,0 +1,28 @@
+[package]
+name = "driver_rng"
+version = "0.1.0"
+edition = "2021"
+authors = ["Haowen Liu <2401213328@stu.pku.edu.com>"]
+description = "Common traits and types for random number generator device drivers"
+license = "Mulan PSL v2"
+homepage = "https://github.com/syswonder/ruxos"
+repository = "https://github.com/syswonder/ruxos/tree/main/crates/driver_rng"
+
+[features]
+default = []
+xoshiro=  ["dep:rand_xoshiro"]
+
+easy-spin = []
+
+[dependencies]
+driver_common = { path = "../driver_common" }
+crate_interface = "0.1.1"
+rand = { version = "0.8.5", default-features = false }
+rand_xoshiro = { version = "0.6.0", default-features = false, optional = true }
+
+spinlock = { version = "0.1.0", path = "../../crates/spinlock" }
+percpu = "0.2"
+lazy_init = { version = "0.1.0", path = "../../crates/lazy_init", default-features = false }
+
+[dev-dependencies]
+rand = { version = "0.8.5" }

crates/driver_rng/Cargo.toml

@@ -0,0 +1,32 @@
+/* Copyright (c) [2023] [Syswonder Community]
+ *   [Ruxos] is licensed under Mulan PSL v2.
+ *   You can use this software according to the terms and conditions of the Mulan PSL v2.
+ *   You may obtain a copy of Mulan PSL v2 at:
+ *               http://license.coscl.org.cn/MulanPSL2
+ *   THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ *   See the Mulan PSL v2 for more details.
+ */
+
+//! Common traits and types for random number generator device drivers.
+
+#![no_std]
+
+#[doc(no_inline)]
+pub use driver_common::{BaseDriverOps, DevError, DevResult, DeviceType};
+use rand::{distributions::Standard, prelude::*};
+
+// TODO: use xoshiro as a fake rng
+#[cfg(feature = "xoshiro")]
+pub use rand_xoshiro::Xoshiro256Plus;
+
+/// The information of the graphics device.
+#[derive(Debug, Clone, Copy)]
+pub struct RngInfo {}
+
+/// Operations that require a graphics device driver to implement.
+pub trait RngDriverOps: BaseDriverOps {
+    /// Get the random number generator information.
+    fn info(&self) -> RngInfo;
+    /// Request random bytes from the device.
+    fn request_entropy(&mut self, dst: &mut [u8]) -> DevResult<usize>;
+}