Implement /dev/{u,}random

Author: Jiajie Chen

kernel/src/fs/mod.rs

@@ -13,6 +13,7 @@ pub use self::file::*;
 pub use self::file_like::*;
 pub use self::pipe::Pipe;
 pub use self::pseudo::*;
+pub use self::random::*;
 pub use self::stdio::{STDIN, STDOUT};
 pub use self::vga::*;
 
@@ -22,6 +23,7 @@ mod file_like;
 mod ioctl;
 mod pipe;
 mod pseudo;
+mod random;
 mod stdio;
 pub mod vga;
 
@@ -81,6 +83,8 @@ lazy_static! {
         let devfs = DevFS::new();
         devfs.add("null", Arc::new(NullINode::default())).expect("failed to mknod /dev/null");
         devfs.add("zero", Arc::new(ZeroINode::default())).expect("failed to mknod /dev/zero");
+        devfs.add("random", Arc::new(RandomINode::new(false))).expect("failed to mknod /dev/zero");
+        devfs.add("urandom", Arc::new(RandomINode::new(true))).expect("failed to mknod /dev/zero");
 
         // mount DevFS at /dev
         let dev = root.find(true, "dev").unwrap_or_else(|_| {

kernel/src/fs/pipe.rs

@@ -104,5 +104,7 @@ impl INode for Pipe {
         })
     }
 
-    fn as_any_ref(&self) -> &dyn Any { self }
+    fn as_any_ref(&self) -> &dyn Any {
+        self
+    }
 }

kernel/src/fs/pseudo.rs

@@ -56,5 +56,7 @@ impl INode for Pseudo {
             rdev: 0,
         })
     }
-    fn as_any_ref(&self) -> &dyn Any { self }
+    fn as_any_ref(&self) -> &dyn Any {
+        self
+    }
 }

kernel/src/fs/random.rs

@@ -0,0 +1,81 @@
+//! Implement INode for RandomINode
+
+use alloc::{collections::vec_deque::VecDeque, string::String, sync::Arc};
+use core::any::Any;
+
+use rcore_fs::vfs::*;
+
+use crate::sync::Condvar;
+use crate::sync::SpinNoIrqLock as Mutex;
+
+pub struct RandomINodeData {
+    seed: u32,
+}
+
+#[derive(Clone)]
+pub struct RandomINode {
+    data: Arc<Mutex<RandomINodeData>>,
+    secure: bool,
+}
+
+impl RandomINode {
+    // urandom -> secure=true
+    // random -> secure=false
+    pub fn new(secure: bool) -> RandomINode {
+        RandomINode {
+            secure,
+            data: Arc::new(Mutex::new(RandomINodeData { seed: 1 })),
+        }
+    }
+}
+
+impl INode for RandomINode {
+    fn read_at(&self, _offset: usize, buf: &mut [u8]) -> Result<usize> {
+        if buf.len() > 0 {
+            let mut data = self.data.lock();
+            // from K&R
+            for i in 0..buf.len() {
+                data.seed = data.seed.wrapping_mul(1103515245).wrapping_add(12345);
+                buf[i] = (data.seed / 65536) as u8;
+            }
+            Ok(buf.len())
+        } else {
+            Ok(0)
+        }
+    }
+
+    fn write_at(&self, _offset: usize, _buf: &[u8]) -> Result<usize> {
+        Err(FsError::NotSupported)
+    }
+
+    fn poll(&self) -> Result<PollStatus> {
+        Ok(PollStatus {
+            read: true,
+            write: false,
+            error: false,
+        })
+    }
+
+    fn metadata(&self) -> Result<Metadata> {
+        Ok(Metadata {
+            dev: 1,
+            inode: 1,
+            size: 0,
+            blk_size: 0,
+            blocks: 0,
+            atime: Timespec { sec: 0, nsec: 0 },
+            mtime: Timespec { sec: 0, nsec: 0 },
+            ctime: Timespec { sec: 0, nsec: 0 },
+            type_: FileType::CharDevice,
+            mode: 0o666,
+            nlinks: 1,
+            uid: 0,
+            gid: 0,
+            rdev: make_rdev(1, if self.secure { 9 } else { 8 }),
+        })
+    }
+
+    fn as_any_ref(&self) -> &dyn Any {
+        self
+    }
+}

kernel/src/fs/stdio.rs

@@ -53,7 +53,6 @@ lazy_static! {
     pub static ref STDOUT: Arc<Stdout> = Arc::new(Stdout::default());
 }
 
-
 impl INode for Stdin {
     fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize> {
         if self.can_read() {
@@ -78,19 +77,19 @@ impl INode for Stdin {
             TCGETS | TIOCGWINSZ | TIOCSPGRP => {
                 // pretend to be tty
                 Ok(())
-            },
+            }
             TIOCGPGRP => {
                 // pretend to be have a tty process group
                 // TODO: verify pointer
-                unsafe {
-                    *(data as *mut u32) = 0
-                };
+                unsafe { *(data as *mut u32) = 0 };
                 Ok(())
             }
-            _ => Err(FsError::NotSupported)
+            _ => Err(FsError::NotSupported),
         }
     }
-    fn as_any_ref(&self) -> &dyn Any { self }
+    fn as_any_ref(&self) -> &dyn Any {
+        self
+    }
 }
 
 impl INode for Stdout {
@@ -116,17 +115,17 @@ impl INode for Stdout {
             TCGETS | TIOCGWINSZ | TIOCSPGRP => {
                 // pretend to be tty
                 Ok(())
-            },
+            }
             TIOCGPGRP => {
                 // pretend to be have a tty process group
                 // TODO: verify pointer
-                unsafe {
-                    *(data as *mut u32) = 0
-                };
+                unsafe { *(data as *mut u32) = 0 };
                 Ok(())
             }
-            _ => Err(FsError::NotSupported)
+            _ => Err(FsError::NotSupported),
         }
     }
-    fn as_any_ref(&self) -> &dyn Any { self }
+    fn as_any_ref(&self) -> &dyn Any {
+        self
+    }
 }

kernel/src/fs/vga.rs

@@ -80,7 +80,9 @@ impl INode for Vga {
         //let fb_fix_info = unsafe{ &mut *(data as *mut fb_fix_screeninfo) };
         //Ok(())
     }
-    fn as_any_ref(&self) -> &dyn Any { self }
+    fn as_any_ref(&self) -> &dyn Any {
+        self
+    }
 }
 
 const FBIOGET_FSCREENINFO: u32 = 0x4602;