From 08e96bee764066dc2fe708809a84af910ce68234 Mon Sep 17 00:00:00 2001
From: Jeehoon Kang <jeehoon.kang@kaist.ac.kr>
Date: Wed, 12 Aug 2020 01:02:15 +0900
Subject: [PATCH 1/2] Remove CChar

---
 kernel-rs/src/bio.rs         | 14 ++----
 kernel-rs/src/console.rs     | 15 +++---
 kernel-rs/src/exec.rs        | 21 +++-----
 kernel-rs/src/file.rs        | 24 ++++------
 kernel-rs/src/fs.rs          | 63 ++++++++++--------------
 kernel-rs/src/kalloc.rs      | 17 +++----
 kernel-rs/src/kernel_main.rs | 14 ++----
 kernel-rs/src/lib.rs         |  1 -
 kernel-rs/src/log.rs         | 17 ++-----
 kernel-rs/src/pipe.rs        | 22 ++++-----
 kernel-rs/src/printf.rs      | 24 +++++-----
 kernel-rs/src/proc.rs        | 71 ++++++++++++++--------------
 kernel-rs/src/sleeplock.rs   | 11 ++---
 kernel-rs/src/spinlock.rs    | 15 +++---
 kernel-rs/src/start.rs       |  3 +-
 kernel-rs/src/string.rs      | 22 +++------
 kernel-rs/src/syscall.rs     | 12 ++---
 kernel-rs/src/sysfile.rs     | 92 ++++++++++++++----------------------
 kernel-rs/src/sysproc.rs     |  2 +-
 kernel-rs/src/trap.rs        | 38 +++++----------
 kernel-rs/src/virtio_disk.rs | 48 +++++++------------
 kernel-rs/src/vm.rs          | 70 ++++++++++-----------------
 22 files changed, 240 insertions(+), 376 deletions(-)

diff --git a/kernel-rs/src/bio.rs b/kernel-rs/src/bio.rs
index c04d0cdfb..289db96b1 100644
--- a/kernel-rs/src/bio.rs
+++ b/kernel-rs/src/bio.rs
@@ -1,4 +1,3 @@
-use crate::libc;
 use crate::{
     buf::Buf, param::NBUF, printf::panic, spinlock::Spinlock, virtio_disk::virtio_disk_rw,
 };
@@ -30,7 +29,7 @@ impl Buf {
     /// Write self's contents to disk.  Must be locked.
     pub unsafe fn write(&mut self) {
         if (*self).lock.holding() == 0 {
-            panic(b"bwrite\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"bwrite\x00" as *const u8 as *mut u8);
         }
         virtio_disk_rw(self, 1);
     }
@@ -41,7 +40,7 @@ impl Buf {
         let bcache = BCACHE.get_mut();
 
         if (*self).lock.holding() == 0 {
-            panic(b"release\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"release\x00" as *const u8 as *mut u8);
         }
         (*self).lock.release();
         bcache.lock.acquire();
@@ -76,9 +75,7 @@ impl Buf {
 pub unsafe fn binit() {
     let bcache = BCACHE.get_mut();
 
-    bcache
-        .lock
-        .initlock(b"bcache\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    bcache.lock.initlock(b"bcache\x00" as *const u8 as *mut u8);
 
     // Create linked list of buffers
     bcache.head.prev = &mut bcache.head;
@@ -87,8 +84,7 @@ pub unsafe fn binit() {
     while b < bcache.buf.as_mut_ptr().offset(NBUF as isize) {
         (*b).next = bcache.head.next;
         (*b).prev = &mut bcache.head;
-        (*b).lock
-            .initlock(b"buffer\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        (*b).lock.initlock(b"buffer\x00" as *const u8 as *mut u8);
         (*bcache.head.next).prev = b;
         bcache.head.next = b;
         b = b.offset(1)
@@ -129,7 +125,7 @@ unsafe fn bget(dev: u32, blockno: u32) -> *mut Buf {
         }
         b = (*b).prev
     }
-    panic(b"bget: no buffers\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    panic(b"bget: no buffers\x00" as *const u8 as *mut u8);
 }
 
 /// Return a locked buf with the contents of the indicated block.
diff --git a/kernel-rs/src/console.rs b/kernel-rs/src/console.rs
index 262b11902..faced31cd 100644
--- a/kernel-rs/src/console.rs
+++ b/kernel-rs/src/console.rs
@@ -12,7 +12,7 @@ const INPUT_BUF: usize = 128;
 
 struct Console {
     lock: Spinlock,
-    buf: [libc::CChar; 128],
+    buf: [u8; 128],
 
     /// Read index
     r: u32,
@@ -74,9 +74,9 @@ static mut CONS: Console = Console::zeroed();
 unsafe fn consolewrite(user_src: i32, src: usize, n: i32) -> i32 {
     CONS.lock.acquire();
     for i in 0..n {
-        let mut c: libc::CChar = 0;
+        let mut c: u8 = 0;
         if either_copyin(
-            &mut c as *mut libc::CChar as *mut libc::CVoid,
+            &mut c as *mut u8 as *mut libc::CVoid,
             user_src,
             src.wrapping_add(i as usize),
             1usize,
@@ -121,11 +121,11 @@ unsafe fn consoleread(user_dst: i32, mut dst: usize, mut n: i32) -> i32 {
             break;
         } else {
             // copy the input byte to the user-space buffer.
-            let mut cbuf = cin as libc::CChar;
+            let mut cbuf = cin as u8;
             if either_copyout(
                 user_dst,
                 dst,
-                &mut cbuf as *mut libc::CChar as *mut libc::CVoid,
+                &mut cbuf as *mut u8 as *mut libc::CVoid,
                 1usize,
             ) == -1
             {
@@ -184,7 +184,7 @@ pub unsafe fn consoleintr(mut cin: i32) {
                 // store for consumption by consoleread().
                 let fresh1 = CONS.e;
                 CONS.e = CONS.e.wrapping_add(1);
-                CONS.buf[fresh1.wrapping_rem(INPUT_BUF as u32) as usize] = cin as libc::CChar;
+                CONS.buf[fresh1.wrapping_rem(INPUT_BUF as u32) as usize] = cin as u8;
                 if cin == '\n' as i32
                     || cin == ctrl('D')
                     || CONS.e == CONS.r.wrapping_add(INPUT_BUF as u32)
@@ -201,8 +201,7 @@ pub unsafe fn consoleintr(mut cin: i32) {
 }
 
 pub unsafe fn consoleinit() {
-    CONS.lock
-        .initlock(b"CONS\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    CONS.lock.initlock(b"CONS\x00" as *const u8 as *mut u8);
     uartinit();
 
     // connect read and write system calls
diff --git a/kernel-rs/src/exec.rs b/kernel-rs/src/exec.rs
index b3d9485af..5e1061066 100644
--- a/kernel-rs/src/exec.rs
+++ b/kernel-rs/src/exec.rs
@@ -1,4 +1,3 @@
-use crate::libc;
 use crate::{
     elf::{ElfHdr, ProgHdr, ELF_MAGIC, ELF_PROG_LOAD},
     file::Inode,
@@ -13,7 +12,7 @@ use crate::{
 };
 use core::ptr;
 
-pub unsafe fn exec(path: *mut libc::CChar, argv: *mut *mut libc::CChar) -> i32 {
+pub unsafe fn exec(path: *mut u8, argv: *mut *mut u8) -> i32 {
     let mut sz: usize = 0;
     let mut ustack: [usize; MAXARG + 1] = [0; MAXARG + 1];
     let mut elf: ElfHdr = Default::default();
@@ -154,7 +153,7 @@ pub unsafe fn exec(path: *mut libc::CChar, argv: *mut *mut libc::CChar) -> i32 {
                     && copyout(
                         pagetable,
                         sp,
-                        ustack.as_mut_ptr() as *mut libc::CChar,
+                        ustack.as_mut_ptr() as *mut u8,
                         argc.wrapping_add(1)
                             .wrapping_mul(::core::mem::size_of::<usize>()),
                     ) >= 0
@@ -166,8 +165,8 @@ pub unsafe fn exec(path: *mut libc::CChar, argv: *mut *mut libc::CChar) -> i32 {
                     (*(*p).tf).a1 = sp;
 
                     // Save program name for debugging.
-                    let mut s: *mut libc::CChar = path;
-                    let mut last: *mut libc::CChar = s;
+                    let mut s: *mut u8 = path;
+                    let mut last: *mut u8 = s;
                     while *s != 0 {
                         if *s as i32 == '/' as i32 {
                             last = s.offset(1isize)
@@ -177,7 +176,7 @@ pub unsafe fn exec(path: *mut libc::CChar, argv: *mut *mut libc::CChar) -> i32 {
                     safestrcpy(
                         (*p).name.as_mut_ptr(),
                         last,
-                        ::core::mem::size_of::<[libc::CChar; 16]>() as i32,
+                        ::core::mem::size_of::<[u8; 16]>() as i32,
                     );
 
                     // Commit to the user image.
@@ -214,19 +213,13 @@ unsafe fn loadseg(
     sz: u32,
 ) -> Result<(), ()> {
     if va.wrapping_rem(PGSIZE as usize) != 0 {
-        panic(
-            b"loadseg: va must be page aligned\x00" as *const u8 as *const libc::CChar
-                as *mut libc::CChar,
-        );
+        panic(b"loadseg: va must be page aligned\x00" as *const u8 as *mut u8);
     }
 
     for i in num_iter::range_step(0, sz, PGSIZE as _) {
         let pa = walkaddr(pagetable, va.wrapping_add(i as usize));
         if pa == 0 {
-            panic(
-                b"loadseg: address should exist\x00" as *const u8 as *const libc::CChar
-                    as *mut libc::CChar,
-            );
+            panic(b"loadseg: address should exist\x00" as *const u8 as *mut u8);
         }
 
         let n = if sz.wrapping_sub(i) < PGSIZE as u32 {
diff --git a/kernel-rs/src/file.rs b/kernel-rs/src/file.rs
index a6fd1c856..0413b1f43 100644
--- a/kernel-rs/src/file.rs
+++ b/kernel-rs/src/file.rs
@@ -1,5 +1,4 @@
 //! Support functions for system calls that involve file descriptors.
-use crate::libc;
 use crate::{
     fs::{stati, BSIZE},
     log::{begin_op, end_op},
@@ -23,8 +22,8 @@ pub struct File {
     /// reference count
     ref_0: i32,
 
-    pub readable: libc::CChar,
-    pub writable: libc::CChar,
+    pub readable: u8,
+    pub writable: u8,
 
     /// FD_PIPE
     pub pipe: *mut Pipe,
@@ -103,7 +102,7 @@ impl File {
     pub unsafe fn dup(&mut self) -> *mut File {
         FTABLE.lock.acquire();
         if (*self).ref_0 < 1 {
-            panic(b"File::dup\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"File::dup\x00" as *const u8 as *mut u8);
         }
         (*self).ref_0 += 1;
         FTABLE.lock.release();
@@ -114,7 +113,7 @@ impl File {
     pub unsafe fn close(&mut self) {
         FTABLE.lock.acquire();
         if (*self).ref_0 < 1 {
-            panic(b"File::close\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"File::close\x00" as *const u8 as *mut u8);
         }
         (*self).ref_0 -= 1;
         if (*self).ref_0 > 0 {
@@ -150,7 +149,7 @@ impl File {
             if copyout(
                 (*p).pagetable,
                 addr,
-                &mut st as *mut Stat as *mut libc::CChar,
+                &mut st as *mut Stat as *mut u8,
                 ::core::mem::size_of::<Stat>() as usize,
             ) < 0
             {
@@ -189,7 +188,7 @@ impl File {
             (*(*self).ip).unlock();
             r
         } else {
-            panic(b"File::read\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"File::read\x00" as *const u8 as *mut u8);
         }
     }
 
@@ -238,10 +237,7 @@ impl File {
                     break;
                 }
                 if r != n1 {
-                    panic(
-                        b"short File::write\x00" as *const u8 as *const libc::CChar
-                            as *mut libc::CChar,
-                    );
+                    panic(b"short File::write\x00" as *const u8 as *mut u8);
                 }
                 i += r
             }
@@ -251,7 +247,7 @@ impl File {
                 -1
             }
         } else {
-            panic(b"File::write\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"File::write\x00" as *const u8 as *mut u8);
         }
     }
 
@@ -289,7 +285,5 @@ pub static mut DEVSW: [Devsw; NDEV as usize] = [Devsw {
 static mut FTABLE: Ftable = Ftable::zeroed();
 
 pub unsafe fn fileinit() {
-    FTABLE
-        .lock
-        .initlock(b"FTABLE\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    FTABLE.lock.initlock(b"FTABLE\x00" as *const u8 as *mut u8);
 }
diff --git a/kernel-rs/src/fs.rs b/kernel-rs/src/fs.rs
index c07c4437c..9e90b0ece 100644
--- a/kernel-rs/src/fs.rs
+++ b/kernel-rs/src/fs.rs
@@ -68,7 +68,7 @@ pub struct Superblock {
 #[derive(Default, Copy, Clone)]
 pub struct Dirent {
     pub inum: u16,
-    name: [libc::CChar; DIRSIZ],
+    name: [u8; DIRSIZ],
 }
 
 /// On-disk inode structure
@@ -216,7 +216,7 @@ impl Inode {
     /// Reads the inode from disk if necessary.
     pub unsafe fn lock(&mut self) {
         if (self as *mut Inode).is_null() || (*self).ref_0 < 1 {
-            panic(b"Inode::lock\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"Inode::lock\x00" as *const u8 as *mut u8);
         }
         (*self).lock.acquire();
         if (*self).valid == 0 {
@@ -236,10 +236,7 @@ impl Inode {
             (*bp).release();
             (*self).valid = 1;
             if (*self).typ as i32 == 0 {
-                panic(
-                    b"Inode::lock: no type\x00" as *const u8 as *const libc::CChar
-                        as *mut libc::CChar,
-                );
+                panic(b"Inode::lock: no type\x00" as *const u8 as *mut u8);
             }
         };
     }
@@ -247,7 +244,7 @@ impl Inode {
     /// Unlock the given inode.
     pub unsafe fn unlock(&mut self) {
         if (self as *mut Inode).is_null() || (*self).lock.holding() == 0 || (*self).ref_0 < 1 {
-            panic(b"Inode::unlock\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"Inode::unlock\x00" as *const u8 as *mut u8);
         }
         (*self).lock.release();
     }
@@ -327,7 +324,7 @@ impl Inode {
             (*bp).release();
             return addr;
         }
-        panic(b"bmap: out of range\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"bmap: out of range\x00" as *const u8 as *mut u8);
     }
 
     /// Truncate inode (discard contents).
@@ -471,9 +468,7 @@ impl Inode {
             }
             (*bp).release();
         }
-        panic(
-            b"Inode::alloc: no inodes\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-        );
+        panic(b"Inode::alloc: no inodes\x00" as *const u8 as *mut u8);
     }
 
     pub const fn zeroed() -> Self {
@@ -559,7 +554,7 @@ pub static mut SB: Superblock = Superblock::zeroed();
 pub unsafe fn fsinit(dev: i32) {
     SB.read(dev);
     if SB.magic != FSMAGIC as u32 {
-        panic(b"invalid file system\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"invalid file system\x00" as *const u8 as *mut u8);
     }
     SB.initlog(dev);
 }
@@ -594,7 +589,7 @@ unsafe fn balloc(dev: u32) -> u32 {
         (*bp).release();
         b += BPB
     }
-    panic(b"balloc: out of blocks\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    panic(b"balloc: out of blocks\x00" as *const u8 as *mut u8);
 }
 
 /// Free a disk block.
@@ -603,7 +598,7 @@ unsafe fn bfree(dev: i32, b: u32) {
     let bi: i32 = b.wrapping_rem(BPB as u32) as i32;
     let m: i32 = (1) << (bi % 8);
     if (*bp).data[(bi / 8) as usize] as i32 & m == 0 {
-        panic(b"freeing free block\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"freeing free block\x00" as *const u8 as *mut u8);
     }
     (*bp).data[(bi / 8) as usize] = ((*bp).data[(bi / 8) as usize] as i32 & !m) as u8;
     log_write(bp);
@@ -613,13 +608,11 @@ unsafe fn bfree(dev: i32, b: u32) {
 static mut ICACHE: Icache = Icache::zeroed();
 
 pub unsafe fn iinit() {
-    ICACHE
-        .lock
-        .initlock(b"ICACHE\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    ICACHE.lock.initlock(b"ICACHE\x00" as *const u8 as *mut u8);
     for i in 0..NINODE {
         (*ICACHE.inode.as_mut_ptr().offset(i as isize))
             .lock
-            .initlock(b"inode\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            .initlock(b"inode\x00" as *const u8 as *mut u8);
     }
 }
 
@@ -647,7 +640,7 @@ unsafe fn iget(dev: u32, inum: u32) -> *mut Inode {
 
     // Recycle an inode cache entry.
     if empty.is_null() {
-        panic(b"iget: no inodes\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"iget: no inodes\x00" as *const u8 as *mut u8);
     }
     ip = empty;
     (*ip).dev = dev;
@@ -669,17 +662,17 @@ pub unsafe fn stati(ip: *mut Inode, mut st: *mut Stat) {
 }
 
 /// Directories
-pub unsafe fn namecmp(s: *const libc::CChar, t: *const libc::CChar) -> i32 {
+pub unsafe fn namecmp(s: *const u8, t: *const u8) -> i32 {
     strncmp(s, t, DIRSIZ as u32)
 }
 
 /// Look for a directory entry in a directory.
 /// If found, set *poff to byte offset of entry.
-pub unsafe fn dirlookup(dp: *mut Inode, name: *mut libc::CChar, poff: *mut u32) -> *mut Inode {
+pub unsafe fn dirlookup(dp: *mut Inode, name: *mut u8, poff: *mut u32) -> *mut Inode {
     let mut off: u32 = 0;
     let mut de: Dirent = Default::default();
     if (*dp).typ as i32 != T_DIR {
-        panic(b"dirlookup not DIR\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"dirlookup not DIR\x00" as *const u8 as *mut u8);
     }
     while off < (*dp).size {
         if (*dp).read(
@@ -690,7 +683,7 @@ pub unsafe fn dirlookup(dp: *mut Inode, name: *mut libc::CChar, poff: *mut u32)
         ) as usize
             != ::core::mem::size_of::<Dirent>()
         {
-            panic(b"dirlookup read\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"dirlookup read\x00" as *const u8 as *mut u8);
         }
         if de.inum as i32 != 0 && namecmp(name, de.name.as_mut_ptr()) == 0 {
             // entry matches path element
@@ -705,7 +698,7 @@ pub unsafe fn dirlookup(dp: *mut Inode, name: *mut libc::CChar, poff: *mut u32)
 }
 
 /// Write a new directory entry (name, inum) into the directory dp.
-pub unsafe fn dirlink(dp: *mut Inode, name: *mut libc::CChar, inum: u32) -> i32 {
+pub unsafe fn dirlink(dp: *mut Inode, name: *mut u8, inum: u32) -> i32 {
     let mut de: Dirent = Default::default();
 
     // Check that name is not present.
@@ -726,7 +719,7 @@ pub unsafe fn dirlink(dp: *mut Inode, name: *mut libc::CChar, inum: u32) -> i32
         ) as usize
             != ::core::mem::size_of::<Dirent>()
         {
-            panic(b"dirlink read\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"dirlink read\x00" as *const u8 as *mut u8);
         }
         if de.inum as i32 == 0 {
             break;
@@ -743,7 +736,7 @@ pub unsafe fn dirlink(dp: *mut Inode, name: *mut libc::CChar, inum: u32) -> i32
     ) as usize
         != ::core::mem::size_of::<Dirent>()
     {
-        panic(b"dirlink\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"dirlink\x00" as *const u8 as *mut u8);
     }
     0
 }
@@ -761,14 +754,14 @@ pub unsafe fn dirlink(dp: *mut Inode, name: *mut libc::CChar, inum: u32) -> i32
 ///   skipelem("///a//bb", name) = "bb", setting name = "a"
 ///   skipelem("a", name) = "", setting name = "a"
 ///   skipelem("", name) = skipelem("////", name) = 0
-unsafe fn skipelem(mut path: *mut libc::CChar, name: *mut libc::CChar) -> *mut libc::CChar {
+unsafe fn skipelem(mut path: *mut u8, name: *mut u8) -> *mut u8 {
     while *path as i32 == '/' as i32 {
         path = path.offset(1)
     }
     if *path as i32 == 0 {
         return ptr::null_mut();
     }
-    let s: *mut libc::CChar = path;
+    let s: *mut u8 = path;
     while *path as i32 != '/' as i32 && *path as i32 != 0 {
         path = path.offset(1)
     }
@@ -781,7 +774,7 @@ unsafe fn skipelem(mut path: *mut libc::CChar, name: *mut libc::CChar) -> *mut l
             name as *mut libc::CVoid,
             len as usize,
         );
-        *name.offset(len as isize) = 0 as libc::CChar
+        *name.offset(len as isize) = 0 as u8
     }
     while *path as i32 == '/' as i32 {
         path = path.offset(1)
@@ -793,11 +786,7 @@ unsafe fn skipelem(mut path: *mut libc::CChar, name: *mut libc::CChar) -> *mut l
 /// If parent != 0, return the inode for the parent and copy the final
 /// path element into name, which must have room for DIRSIZ bytes.
 /// Must be called inside a transaction since it calls Inode::put().
-unsafe fn namex(
-    mut path: *mut libc::CChar,
-    nameiparent_0: i32,
-    name: *mut libc::CChar,
-) -> *mut Inode {
+unsafe fn namex(mut path: *mut u8, nameiparent_0: i32, name: *mut u8) -> *mut Inode {
     let mut ip: *mut Inode;
 
     if *path as i32 == '/' as i32 {
@@ -835,11 +824,11 @@ unsafe fn namex(
     ip
 }
 
-pub unsafe fn namei(path: *mut libc::CChar) -> *mut Inode {
-    let mut name: [libc::CChar; DIRSIZ] = [0; DIRSIZ];
+pub unsafe fn namei(path: *mut u8) -> *mut Inode {
+    let mut name: [u8; DIRSIZ] = [0; DIRSIZ];
     namex(path, 0, name.as_mut_ptr())
 }
 
-pub unsafe fn nameiparent(path: *mut libc::CChar, name: *mut libc::CChar) -> *mut Inode {
+pub unsafe fn nameiparent(path: *mut u8, name: *mut u8) -> *mut Inode {
     namex(path, 1, name)
 }
diff --git a/kernel-rs/src/kalloc.rs b/kernel-rs/src/kalloc.rs
index 7a90cc45b..c045cbd5e 100644
--- a/kernel-rs/src/kalloc.rs
+++ b/kernel-rs/src/kalloc.rs
@@ -37,8 +37,7 @@ impl Kmem {
 static mut KMEM: Kmem = Kmem::zeroed();
 
 pub unsafe fn kinit() {
-    KMEM.lock
-        .initlock(b"KMEM\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    KMEM.lock.initlock(b"KMEM\x00" as *const u8 as *mut u8);
 
     // TODO: without this strange code, the kernel doesn't boot up.  Probably stack is not properly
     // initialized at the beginning...
@@ -52,8 +51,8 @@ pub unsafe fn kinit() {
 }
 
 pub unsafe fn freerange(pa_start: *mut libc::CVoid, pa_end: *mut libc::CVoid) {
-    let mut p = pgroundup(pa_start as usize) as *mut libc::CChar;
-    while p.offset(PGSIZE as isize) <= pa_end as *mut libc::CChar {
+    let mut p = pgroundup(pa_start as usize) as *mut u8;
+    while p.offset(PGSIZE as isize) <= pa_end as *mut u8 {
         kfree(p as *mut libc::CVoid);
         p = p.offset(PGSIZE as isize)
     }
@@ -65,10 +64,10 @@ pub unsafe fn freerange(pa_start: *mut libc::CVoid, pa_end: *mut libc::CVoid) {
 /// initializing the allocator; see kinit above.)
 pub unsafe fn kfree(pa: *mut libc::CVoid) {
     if (pa as usize).wrapping_rem(PGSIZE as usize) != 0
-        || (pa as *mut libc::CChar) < END.as_mut_ptr()
+        || (pa as *mut u8) < END.as_mut_ptr()
         || pa as usize >= PHYSTOP as usize
     {
-        panic(b"kfree\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"kfree\x00" as *const u8 as *mut u8);
     }
 
     // Fill with junk to catch dangling refs.
@@ -92,11 +91,7 @@ pub unsafe fn kalloc() -> *mut libc::CVoid {
     KMEM.lock.release();
     if !r.is_null() {
         // fill with junk
-        ptr::write_bytes(
-            r as *mut libc::CChar as *mut libc::CVoid,
-            5,
-            PGSIZE as usize,
-        );
+        ptr::write_bytes(r as *mut u8 as *mut libc::CVoid, 5, PGSIZE as usize);
     }
     r as *mut libc::CVoid
 }
diff --git a/kernel-rs/src/kernel_main.rs b/kernel-rs/src/kernel_main.rs
index 6fc5beee0..02cd402ff 100644
--- a/kernel-rs/src/kernel_main.rs
+++ b/kernel-rs/src/kernel_main.rs
@@ -1,4 +1,3 @@
-use crate::libc;
 use crate::{
     bio::binit,
     console::consoleinit,
@@ -22,11 +21,9 @@ pub unsafe fn kernel_main() {
         consoleinit();
         printfinit();
 
-        printf(b"\n\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
-        printf(
-            b"rv6 kernel is booting\n\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-        );
-        printf(b"\n\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        printf(b"\n\x00" as *const u8 as *mut u8);
+        printf(b"rv6 kernel is booting\n\x00" as *const u8 as *mut u8);
+        printf(b"\n\x00" as *const u8 as *mut u8);
 
         // physical page allocator
         kinit();
@@ -70,10 +67,7 @@ pub unsafe fn kernel_main() {
     } else {
         while !STARTED.load(Ordering::Acquire) {}
 
-        printf(
-            b"hart %d starting\n\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-            cpuid(),
-        );
+        printf(b"hart %d starting\n\x00" as *const u8 as *mut u8, cpuid());
 
         // turn on paging
         kvminithart();
diff --git a/kernel-rs/src/lib.rs b/kernel-rs/src/lib.rs
index fd65362c3..c16f7df40 100644
--- a/kernel-rs/src/lib.rs
+++ b/kernel-rs/src/lib.rs
@@ -19,7 +19,6 @@
 // https://github.com/rust-lang/libc/blob/master/src/unix/linux_like/linux/gnu/b64/riscv64/mod.rs
 mod libc {
     pub type CVoid = core::ffi::c_void;
-    pub type CChar = u8;
 }
 
 mod bio;
diff --git a/kernel-rs/src/log.rs b/kernel-rs/src/log.rs
index 5c152bbc7..5a61c9753 100644
--- a/kernel-rs/src/log.rs
+++ b/kernel-rs/src/log.rs
@@ -77,13 +77,9 @@ static mut LOG: Log = Log::zeroed();
 impl Superblock {
     pub unsafe fn initlog(&mut self, dev: i32) {
         if ::core::mem::size_of::<LogHeader>() >= BSIZE as usize {
-            panic(
-                b"initlog: too big LogHeader\x00" as *const u8 as *const libc::CChar
-                    as *mut libc::CChar,
-            );
+            panic(b"initlog: too big LogHeader\x00" as *const u8 as *mut u8);
         }
-        LOG.lock
-            .initlock(b"LOG\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        LOG.lock.initlock(b"LOG\x00" as *const u8 as *mut u8);
         LOG.start = (*self).logstart as i32;
         LOG.size = (*self).nlog as i32;
         LOG.dev = dev;
@@ -175,7 +171,7 @@ pub unsafe fn end_op() {
     LOG.lock.acquire();
     LOG.outstanding -= 1;
     if LOG.committing != 0 {
-        panic(b"LOG.committing\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"LOG.committing\x00" as *const u8 as *mut u8);
     }
     if LOG.outstanding == 0 {
         do_commit = 1;
@@ -248,13 +244,10 @@ unsafe fn commit() {
 ///   (*bp).release()
 pub unsafe fn log_write(b: *mut Buf) {
     if LOG.lh.n >= LOGSIZE || LOG.lh.n >= LOG.size - 1 {
-        panic(b"too big a transaction\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"too big a transaction\x00" as *const u8 as *mut u8);
     }
     if LOG.outstanding < 1 {
-        panic(
-            b"log_write outside of trans\x00" as *const u8 as *const libc::CChar
-                as *mut libc::CChar,
-        );
+        panic(b"log_write outside of trans\x00" as *const u8 as *mut u8);
     }
     LOG.lock.acquire();
     let mut absorbed = false;
diff --git a/kernel-rs/src/pipe.rs b/kernel-rs/src/pipe.rs
index 994b24db2..38e0e0d6c 100644
--- a/kernel-rs/src/pipe.rs
+++ b/kernel-rs/src/pipe.rs
@@ -13,7 +13,7 @@ pub const PIPESIZE: i32 = 512;
 
 pub struct Pipe {
     pub lock: Spinlock,
-    pub data: [libc::CChar; PIPESIZE as usize],
+    pub data: [u8; PIPESIZE as usize],
 
     /// number of bytes read
     pub nread: u32,
@@ -40,14 +40,14 @@ impl Pipe {
         }
         if (*self).readopen == 0 && (*self).writeopen == 0 {
             (*self).lock.release();
-            kfree(self as *mut Pipe as *mut libc::CChar as *mut libc::CVoid);
+            kfree(self as *mut Pipe as *mut u8 as *mut libc::CVoid);
         } else {
             (*self).lock.release();
         };
     }
     pub unsafe fn write(&mut self, addr: usize, n: i32) -> i32 {
         let mut i: i32 = 0;
-        let mut ch: libc::CChar = 0;
+        let mut ch: u8 = 0;
         let proc: *mut Proc = myproc();
         (*self).lock.acquire();
         while i < n {
@@ -108,7 +108,7 @@ impl Pipe {
             }
             let fresh1 = (*self).nread;
             (*self).nread = (*self).nread.wrapping_add(1);
-            let mut ch: libc::CChar = (*self).data[fresh1.wrapping_rem(PIPESIZE as u32) as usize];
+            let mut ch: u8 = (*self).data[fresh1.wrapping_rem(PIPESIZE as u32) as usize];
             if copyout(
                 (*proc).pagetable,
                 addr.wrapping_add(i as usize),
@@ -141,22 +141,20 @@ impl Pipe {
                 (*pi).writeopen = 1;
                 (*pi).nwrite = 0;
                 (*pi).nread = 0;
-                (*pi)
-                    .lock
-                    .initlock(b"pipe\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+                (*pi).lock.initlock(b"pipe\x00" as *const u8 as *mut u8);
                 (**f0).typ = FD_PIPE;
-                (**f0).readable = 1 as libc::CChar;
-                (**f0).writable = 0 as libc::CChar;
+                (**f0).readable = 1 as u8;
+                (**f0).writable = 0 as u8;
                 (**f0).pipe = pi;
                 (**f1).typ = FD_PIPE;
-                (**f1).readable = 0 as libc::CChar;
-                (**f1).writable = 1 as libc::CChar;
+                (**f1).readable = 0 as u8;
+                (**f1).writable = 1 as u8;
                 (**f1).pipe = pi;
                 return 0;
             }
         }
         if !pi.is_null() {
-            kfree(pi as *mut libc::CChar as *mut libc::CVoid);
+            kfree(pi as *mut u8 as *mut libc::CVoid);
         }
         if !(*f0).is_null() {
             (*(*f0)).close();
diff --git a/kernel-rs/src/printf.rs b/kernel-rs/src/printf.rs
index c694bc2a6..b98f6104b 100644
--- a/kernel-rs/src/printf.rs
+++ b/kernel-rs/src/printf.rs
@@ -1,6 +1,5 @@
 //! formatted console output -- printf, panic.
 use crate::console::consputc;
-use crate::libc;
 use crate::spinlock::Spinlock;
 
 /// lock to avoid interleaving concurrent printf's.
@@ -23,12 +22,12 @@ pub static mut PANICKED: i32 = 0;
 
 static mut PR: PrintfLock = PrintfLock::zeroed();
 
-static mut DIGITS: [libc::CChar; 17] = [
+static mut DIGITS: [u8; 17] = [
     48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 0,
 ];
 
 unsafe fn printint(xx: i32, base: i32, mut sign: i32) {
-    let mut buf: [libc::CChar; 16] = [0; 16];
+    let mut buf: [u8; 16] = [0; 16];
     let mut i: i32 = 0;
     let mut x: u32 = if sign != 0 && {
         sign = (xx < 0) as i32;
@@ -50,7 +49,7 @@ unsafe fn printint(xx: i32, base: i32, mut sign: i32) {
     if sign != 0 {
         let fresh1 = i;
         i += 1;
-        buf[fresh1 as usize] = '-' as i32 as libc::CChar
+        buf[fresh1 as usize] = '-' as i32 as u8
     }
     loop {
         i -= 1;
@@ -76,7 +75,7 @@ unsafe fn printptr(mut x: usize) {
 }
 
 /// Print to the console. only understands %d, %x, %p, %s.
-pub unsafe extern "C" fn printf(fmt: *mut libc::CChar, args: ...) {
+pub unsafe extern "C" fn printf(fmt: *mut u8, args: ...) {
     let mut ap: ::core::ffi::VaListImpl<'_>;
     let mut i: i32 = 0;
     let locking: i32 = PR.locking;
@@ -84,7 +83,7 @@ pub unsafe extern "C" fn printf(fmt: *mut libc::CChar, args: ...) {
         PR.lock.acquire();
     }
     if fmt.is_null() {
-        panic(b"null fmt\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"null fmt\x00" as *const u8 as *mut u8);
     }
     ap = args.clone();
     loop {
@@ -111,9 +110,9 @@ pub unsafe extern "C" fn printf(fmt: *mut libc::CChar, args: ...) {
                     printptr(ap.as_va_list().arg::<usize>());
                 }
                 115 => {
-                    let mut s = ap.as_va_list().arg::<*mut libc::CChar>();
+                    let mut s = ap.as_va_list().arg::<*mut u8>();
                     if s.is_null() {
-                        s = b"(null)\x00" as *const u8 as *const libc::CChar as *mut libc::CChar
+                        s = b"(null)\x00" as *const u8 as *mut u8
                     }
                     while *s != 0 {
                         consputc(*s as i32);
@@ -137,11 +136,11 @@ pub unsafe extern "C" fn printf(fmt: *mut libc::CChar, args: ...) {
     };
 }
 
-pub unsafe fn panic(s: *mut libc::CChar) -> ! {
+pub unsafe fn panic(s: *mut u8) -> ! {
     PR.locking = 0;
-    printf(b"panic: \x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    printf(b"panic: \x00" as *const u8 as *mut u8);
     printf(s);
-    printf(b"\n\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    printf(b"\n\x00" as *const u8 as *mut u8);
 
     // freeze other CPUs
     ::core::ptr::write_volatile(&mut PANICKED as *mut i32, 1);
@@ -149,7 +148,6 @@ pub unsafe fn panic(s: *mut libc::CChar) -> ! {
 }
 
 pub unsafe fn printfinit() {
-    PR.lock
-        .initlock(b"PR\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    PR.lock.initlock(b"PR\x00" as *const u8 as *mut u8);
     PR.locking = 1;
 }
diff --git a/kernel-rs/src/proc.rs b/kernel-rs/src/proc.rs
index 5fb1458b3..d9a6de08e 100644
--- a/kernel-rs/src/proc.rs
+++ b/kernel-rs/src/proc.rs
@@ -26,7 +26,7 @@ extern "C" {
 
     // trampoline.S
     #[no_mangle]
-    static mut trampoline: [libc::CChar; 0];
+    static mut trampoline: [u8; 0];
 }
 
 /// per-CPU-state
@@ -113,7 +113,7 @@ pub struct Proc {
     pub cwd: *mut Inode,
 
     /// Process name (debugging)
-    pub name: [libc::CChar; 16],
+    pub name: [u8; 16],
 }
 
 /// per-process data for the trap handling code in trampoline.S.
@@ -317,18 +317,17 @@ static mut PID_LOCK: Spinlock = Spinlock::zeroed();
 
 #[no_mangle]
 pub unsafe fn procinit() {
-    PID_LOCK.initlock(b"nextpid\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    PID_LOCK.initlock(b"nextpid\x00" as *const u8 as *mut u8);
     let mut p = PROC.as_mut_ptr();
     while p < &mut *PROC.as_mut_ptr().offset(NPROC as isize) as *mut Proc {
-        (*p).lock
-            .initlock(b"proc\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        (*p).lock.initlock(b"proc\x00" as *const u8 as *mut u8);
 
         // Allocate a page for the process's kernel stack.
         // Map it high in memory, followed by an invalid
         // guard page.
-        let pa: *mut libc::CChar = kalloc() as *mut libc::CChar;
+        let pa: *mut u8 = kalloc() as *mut u8;
         if pa.is_null() {
-            panic(b"kalloc\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"kalloc\x00" as *const u8 as *mut u8);
         }
         let va: usize = kstack(p.offset_from(PROC.as_mut_ptr()) as i64 as i32) as usize;
         kvmmap(va, pa as usize, PGSIZE as usize, (PTE_R | PTE_W) as i32);
@@ -431,7 +430,7 @@ unsafe fn freeproc(mut p: *mut Proc) {
     (*p).sz = 0;
     (*p).pid = 0;
     (*p).parent = ptr::null_mut();
-    (*p).name[0] = 0 as libc::CChar;
+    (*p).name[0] = 0 as u8;
     (*p).chan = ptr::null_mut();
     (*p).killed = 0;
     (*p).xstate = 0;
@@ -507,10 +506,10 @@ pub unsafe fn userinit() {
     (*(*p).tf).sp = PGSIZE as usize;
     safestrcpy(
         (*p).name.as_mut_ptr(),
-        b"initcode\x00" as *const u8 as *const libc::CChar,
-        ::core::mem::size_of::<[libc::CChar; 16]>() as i32,
+        b"initcode\x00" as *const u8,
+        ::core::mem::size_of::<[u8; 16]>() as i32,
     );
-    (*p).cwd = namei(b"/\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    (*p).cwd = namei(b"/\x00" as *const u8 as *mut u8);
     (*p).state = RUNNABLE;
     (*p).lock.release();
 }
@@ -579,7 +578,7 @@ pub unsafe fn fork() -> i32 {
     safestrcpy(
         (*np).name.as_mut_ptr(),
         (*p).name.as_mut_ptr(),
-        ::core::mem::size_of::<[libc::CChar; 16]>() as i32,
+        ::core::mem::size_of::<[u8; 16]>() as i32,
     );
     let pid: i32 = (*np).pid;
     (*np).state = RUNNABLE;
@@ -618,7 +617,7 @@ pub unsafe fn reparent(p: *mut Proc) {
 pub unsafe fn exit(status: i32) {
     let mut p: *mut Proc = myproc();
     if p == INITPROC {
-        panic(b"init exiting\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"init exiting\x00" as *const u8 as *mut u8);
     }
 
     // Close all open files.
@@ -670,7 +669,7 @@ pub unsafe fn exit(status: i32) {
 
     // Jump into the scheduler, never to return.
     sched();
-    panic(b"zombie exit\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    panic(b"zombie exit\x00" as *const u8 as *mut u8);
 }
 
 /// Wait for a child process to exit and return its pid.
@@ -701,7 +700,7 @@ pub unsafe fn wait(addr: usize) -> i32 {
                         && copyout(
                             (*p).pagetable,
                             addr,
-                            &mut (*np).xstate as *mut i32 as *mut libc::CChar,
+                            &mut (*np).xstate as *mut i32 as *mut u8,
                             ::core::mem::size_of::<i32>(),
                         ) < 0
                     {
@@ -776,16 +775,16 @@ pub unsafe fn scheduler() -> ! {
 unsafe fn sched() {
     let p: *mut Proc = myproc();
     if (*p).lock.holding() == 0 {
-        panic(b"sched p->lock\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"sched p->lock\x00" as *const u8 as *mut u8);
     }
     if (*mycpu()).noff != 1 {
-        panic(b"sched locks\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"sched locks\x00" as *const u8 as *mut u8);
     }
     if (*p).state as u32 == RUNNING as i32 as u32 {
-        panic(b"sched running\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"sched running\x00" as *const u8 as *mut u8);
     }
     if intr_get() != 0 {
-        panic(b"sched interruptible\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"sched interruptible\x00" as *const u8 as *mut u8);
     }
     let intena: i32 = (*mycpu()).intena;
     swtch(
@@ -873,7 +872,7 @@ pub unsafe fn wakeup(chan: *mut libc::CVoid) {
 /// Caller must hold p->lock.
 unsafe fn wakeup1(mut p: *mut Proc) {
     if (*p).lock.holding() == 0 {
-        panic(b"wakeup1\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"wakeup1\x00" as *const u8 as *mut u8);
     }
     if (*p).chan == p as *mut libc::CVoid && (*p).state as u32 == SLEEPING as u32 {
         (*p).state = RUNNABLE
@@ -909,9 +908,9 @@ pub unsafe fn kill(pid: i32) -> i32 {
 pub unsafe fn either_copyout(user_dst: i32, dst: usize, src: *mut libc::CVoid, len: usize) -> i32 {
     let p: *mut Proc = myproc();
     if user_dst != 0 {
-        copyout((*p).pagetable, dst, src as *mut libc::CChar, len)
+        copyout((*p).pagetable, dst, src as *mut u8, len)
     } else {
-        ptr::copy(src, dst as *mut libc::CChar as *mut libc::CVoid, len);
+        ptr::copy(src, dst as *mut u8 as *mut libc::CVoid, len);
         0
     }
 }
@@ -922,9 +921,9 @@ pub unsafe fn either_copyout(user_dst: i32, dst: usize, src: *mut libc::CVoid, l
 pub unsafe fn either_copyin(dst: *mut libc::CVoid, user_src: i32, src: usize, len: usize) -> i32 {
     let p: *mut Proc = myproc();
     if user_src != 0 {
-        copyin((*p).pagetable, dst as *mut libc::CChar, src, len)
+        copyin((*p).pagetable, dst as *mut u8, src, len)
     } else {
-        ptr::copy(src as *mut libc::CChar as *const libc::CVoid, dst, len);
+        ptr::copy(src as *mut u8 as *const libc::CVoid, dst, len);
         0
     }
 }
@@ -933,33 +932,33 @@ pub unsafe fn either_copyin(dst: *mut libc::CVoid, user_src: i32, src: usize, le
 /// Runs when user types ^P on console.
 /// No lock to avoid wedging a stuck machine further.
 pub unsafe fn procdump() {
-    static mut STATES: [*mut libc::CChar; 5] = [
-        b"unused\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-        b"sleep \x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-        b"runble\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-        b"run   \x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-        b"zombie\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
+    static mut STATES: [*mut u8; 5] = [
+        b"unused\x00" as *const u8 as *mut u8,
+        b"sleep \x00" as *const u8 as *mut u8,
+        b"runble\x00" as *const u8 as *mut u8,
+        b"run   \x00" as *const u8 as *mut u8,
+        b"zombie\x00" as *const u8 as *mut u8,
     ];
-    printf(b"\n\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    printf(b"\n\x00" as *const u8 as *mut u8);
     let mut p = PROC.as_mut_ptr();
     while p < &mut *PROC.as_mut_ptr().offset(NPROC as isize) as *mut Proc {
         if (*p).state as u32 != UNUSED as i32 as u32 {
             let state = if ((*p).state as usize)
-                < (::core::mem::size_of::<[*mut libc::CChar; 5]>() as usize)
-                    .wrapping_div(::core::mem::size_of::<*mut libc::CChar>())
+                < (::core::mem::size_of::<[*mut u8; 5]>() as usize)
+                    .wrapping_div(::core::mem::size_of::<*mut u8>())
                 && !STATES[(*p).state as usize].is_null()
             {
                 STATES[(*p).state as usize]
             } else {
-                b"???\x00" as *const u8 as *const libc::CChar as *mut libc::CChar
+                b"???\x00" as *const u8 as *mut u8
             };
             printf(
-                b"%d %s %s\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
+                b"%d %s %s\x00" as *const u8 as *mut u8,
                 (*p).pid,
                 state,
                 (*p).name.as_mut_ptr(),
             );
-            printf(b"\n\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            printf(b"\n\x00" as *const u8 as *mut u8);
         }
         p = p.offset(1)
     }
diff --git a/kernel-rs/src/sleeplock.rs b/kernel-rs/src/sleeplock.rs
index 483ec0721..14cf339bb 100644
--- a/kernel-rs/src/sleeplock.rs
+++ b/kernel-rs/src/sleeplock.rs
@@ -15,7 +15,7 @@ pub struct Sleeplock {
     /// For debugging:  
 
     /// Name of lock.
-    name: *mut libc::CChar,
+    name: *mut u8,
 
     /// Process holding lock
     pid: i32,
@@ -32,11 +32,10 @@ impl Sleeplock {
         }
     }
 
-    pub unsafe fn new(name: *mut libc::CChar) -> Self {
+    pub unsafe fn new(name: *mut u8) -> Self {
         let mut lk = Self::zeroed();
 
-        lk.lk
-            .initlock(b"sleep lock\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        lk.lk.initlock(b"sleep lock\x00" as *const u8 as *mut u8);
         lk.name = name;
         lk.locked = 0;
         lk.pid = 0;
@@ -44,10 +43,10 @@ impl Sleeplock {
         lk
     }
 
-    pub fn initlock(&mut self, name: *mut libc::CChar) {
+    pub fn initlock(&mut self, name: *mut u8) {
         (*self)
             .lk
-            .initlock(b"sleep lock\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            .initlock(b"sleep lock\x00" as *const u8 as *mut u8);
         (*self).name = name;
         (*self).locked = 0;
         (*self).pid = 0;
diff --git a/kernel-rs/src/spinlock.rs b/kernel-rs/src/spinlock.rs
index dc388301e..5d0438ef2 100644
--- a/kernel-rs/src/spinlock.rs
+++ b/kernel-rs/src/spinlock.rs
@@ -1,4 +1,3 @@
-use crate::libc;
 use crate::{
     printf::panic,
     proc::{mycpu, Cpu},
@@ -15,7 +14,7 @@ pub struct Spinlock {
     /// For debugging:
 
     /// Name of lock.
-    name: *mut libc::CChar,
+    name: *mut u8,
 
     /// The cpu holding the lock.
     cpu: *mut Cpu,
@@ -32,7 +31,7 @@ impl Spinlock {
     }
 
     /// Mutual exclusion spin locks.
-    pub fn initlock(&mut self, name: *mut libc::CChar) {
+    pub fn initlock(&mut self, name: *mut u8) {
         (*self).name = name;
         (*self).locked = AtomicBool::new(false);
         (*self).cpu = ptr::null_mut();
@@ -44,7 +43,7 @@ impl Spinlock {
         // disable interrupts to avoid deadlock.
         push_off();
         if self.holding() != 0 {
-            panic(b"acquire\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"acquire\x00" as *const u8 as *mut u8);
         }
 
         // On RISC-V, sync_lock_test_and_set turns into an atomic swap:
@@ -72,7 +71,7 @@ impl Spinlock {
     /// Release the lock.
     pub unsafe fn release(&mut self) {
         if self.holding() == 0 {
-            panic(b"release\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"release\x00" as *const u8 as *mut u8);
         }
         (*self).cpu = ptr::null_mut();
 
@@ -119,13 +118,11 @@ pub unsafe fn push_off() {
 pub unsafe fn pop_off() {
     let mut c: *mut Cpu = mycpu();
     if intr_get() != 0 {
-        panic(
-            b"pop_off - interruptible\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-        );
+        panic(b"pop_off - interruptible\x00" as *const u8 as *mut u8);
     }
     (*c).noff -= 1;
     if (*c).noff < 0 {
-        panic(b"pop_off\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"pop_off\x00" as *const u8 as *mut u8);
     }
     if (*c).noff == 0 && (*c).intena != 0 {
         intr_on();
diff --git a/kernel-rs/src/start.rs b/kernel-rs/src/start.rs
index 5d664159b..acbb713f9 100644
--- a/kernel-rs/src/start.rs
+++ b/kernel-rs/src/start.rs
@@ -1,4 +1,3 @@
-use crate::libc;
 use crate::{
     kernel_main::kernel_main,
     memlayout::{clint_mtimecmp, CLINT_MTIME},
@@ -17,7 +16,7 @@ extern "C" {
 
 /// entry.S needs one stack per CPU.
 #[repr(align(16))]
-pub struct Stack([libc::CChar; 4096 * NCPU as usize]);
+pub struct Stack([u8; 4096 * NCPU as usize]);
 
 impl Stack {
     const fn new() -> Self {
diff --git a/kernel-rs/src/string.rs b/kernel-rs/src/string.rs
index c5494a04b..ba6ddf04e 100644
--- a/kernel-rs/src/string.rs
+++ b/kernel-rs/src/string.rs
@@ -1,6 +1,4 @@
-use crate::libc;
-
-pub unsafe fn strncmp(mut p: *const libc::CChar, mut q: *const libc::CChar, mut n: u32) -> i32 {
+pub unsafe fn strncmp(mut p: *const u8, mut q: *const u8, mut n: u32) -> i32 {
     while n > 0 && *p as i32 != 0 && *p as i32 == *q as i32 {
         n = n.wrapping_sub(1);
         p = p.offset(1);
@@ -12,11 +10,7 @@ pub unsafe fn strncmp(mut p: *const libc::CChar, mut q: *const libc::CChar, mut
     *p as u8 as i32 - *q as u8 as i32
 }
 
-pub unsafe fn strncpy(
-    mut s: *mut libc::CChar,
-    mut t: *const libc::CChar,
-    mut n: i32,
-) -> *mut libc::CChar {
+pub unsafe fn strncpy(mut s: *mut u8, mut t: *const u8, mut n: i32) -> *mut u8 {
     let os = s;
     loop {
         let fresh5 = n;
@@ -40,17 +34,13 @@ pub unsafe fn strncpy(
         }
         let fresh9 = s;
         s = s.offset(1);
-        *fresh9 = 0 as libc::CChar
+        *fresh9 = 0 as u8
     }
     os
 }
 
 /// Like strncpy but guaranteed to NUL-terminate.
-pub unsafe fn safestrcpy(
-    mut s: *mut libc::CChar,
-    mut t: *const libc::CChar,
-    mut n: i32,
-) -> *mut libc::CChar {
+pub unsafe fn safestrcpy(mut s: *mut u8, mut t: *const u8, mut n: i32) -> *mut u8 {
     let os = s;
     if n <= 0 {
         return os;
@@ -68,11 +58,11 @@ pub unsafe fn safestrcpy(
             break;
         }
     }
-    *s = 0 as libc::CChar;
+    *s = 0 as u8;
     os
 }
 
-pub unsafe fn strlen(s: *const libc::CChar) -> i32 {
+pub unsafe fn strlen(s: *const u8) -> i32 {
     let mut n: i32 = 0;
     while *s.offset(n as isize) != 0 {
         n += 1
diff --git a/kernel-rs/src/syscall.rs b/kernel-rs/src/syscall.rs
index 000ece7d9..eabdbac95 100644
--- a/kernel-rs/src/syscall.rs
+++ b/kernel-rs/src/syscall.rs
@@ -1,4 +1,3 @@
-use crate::libc;
 use crate::{
     printf::{panic, printf},
     proc::{myproc, Proc},
@@ -16,7 +15,7 @@ pub unsafe fn fetchaddr(addr: usize, ip: *mut usize) -> i32 {
     }
     if copyin(
         (*p).pagetable,
-        ip as *mut libc::CChar,
+        ip as *mut u8,
         addr,
         ::core::mem::size_of::<usize>(),
     ) != 0
@@ -28,7 +27,7 @@ pub unsafe fn fetchaddr(addr: usize, ip: *mut usize) -> i32 {
 
 /// Fetch the nul-terminated string at addr from the current process.
 /// Returns length of string, not including nul, or -1 for error.
-pub unsafe fn fetchstr(addr: usize, buf: *mut libc::CChar, max: i32) -> i32 {
+pub unsafe fn fetchstr(addr: usize, buf: *mut u8, max: i32) -> i32 {
     let p: *mut Proc = myproc();
     let err: i32 = copyinstr((*p).pagetable, buf, addr, max as usize);
     if err < 0 {
@@ -48,7 +47,7 @@ unsafe fn argraw(n: i32) -> usize {
         5 => return (*(*p).tf).a5,
         _ => {}
     }
-    panic(b"argraw\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    panic(b"argraw\x00" as *const u8 as *mut u8);
 }
 
 /// Fetch the nth 32-bit system call argument.
@@ -68,7 +67,7 @@ pub unsafe fn argaddr(n: i32, ip: *mut usize) -> i32 {
 /// Fetch the nth word-sized system call argument as a null-terminated string.
 /// Copies into buf, at most max.
 /// Returns string length if OK (including nul), -1 if error.
-pub unsafe fn argstr(n: i32, buf: *mut libc::CChar, max: i32) -> i32 {
+pub unsafe fn argstr(n: i32, buf: *mut u8, max: i32) -> i32 {
     let mut addr: usize = 0;
     if argaddr(n, &mut addr) < 0 {
         return -1;
@@ -113,8 +112,7 @@ pub unsafe fn syscall() {
         (*(*p).tf).a0 = SYSCALLS[num as usize].expect("non-null function pointer")()
     } else {
         printf(
-            b"%d %s: unknown sys call %d\n\x00" as *const u8 as *const libc::CChar
-                as *mut libc::CChar,
+            b"%d %s: unknown sys call %d\n\x00" as *const u8 as *mut u8,
             (*p).pid,
             (*p).name.as_mut_ptr(),
             num,
diff --git a/kernel-rs/src/sysfile.rs b/kernel-rs/src/sysfile.rs
index 77b4ad844..7e7051638 100644
--- a/kernel-rs/src/sysfile.rs
+++ b/kernel-rs/src/sysfile.rs
@@ -122,9 +122,9 @@ pub unsafe fn sys_fstat() -> usize {
 
 /// Create the path new as a link to the same inode as old.
 pub unsafe fn sys_link() -> usize {
-    let mut name: [libc::CChar; DIRSIZ] = [0; DIRSIZ];
-    let mut new: [libc::CChar; MAXPATH as usize] = [0; MAXPATH as usize];
-    let mut old: [libc::CChar; MAXPATH as usize] = [0; MAXPATH as usize];
+    let mut name: [u8; DIRSIZ] = [0; DIRSIZ];
+    let mut new: [u8; MAXPATH as usize] = [0; MAXPATH as usize];
+    let mut old: [u8; MAXPATH as usize] = [0; MAXPATH as usize];
     if argstr(0, old.as_mut_ptr(), MAXPATH) < 0 || argstr(1, new.as_mut_ptr(), MAXPATH) < 0 {
         return usize::MAX;
     }
@@ -176,7 +176,7 @@ unsafe fn isdirempty(dp: *mut Inode) -> i32 {
         ) as usize
             != ::core::mem::size_of::<Dirent>()
         {
-            panic(b"isdirempty: readi\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"isdirempty: readi\x00" as *const u8 as *mut u8);
         }
         if de.inum as i32 != 0 {
             return 0;
@@ -188,8 +188,8 @@ unsafe fn isdirempty(dp: *mut Inode) -> i32 {
 
 pub unsafe fn sys_unlink() -> usize {
     let mut de: Dirent = Default::default();
-    let mut name: [libc::CChar; DIRSIZ] = [0; DIRSIZ];
-    let mut path: [libc::CChar; MAXPATH as usize] = [0; MAXPATH as usize];
+    let mut name: [u8; DIRSIZ] = [0; DIRSIZ];
+    let mut path: [u8; MAXPATH as usize] = [0; MAXPATH as usize];
     let mut off: u32 = 0;
     if argstr(0, path.as_mut_ptr(), MAXPATH) < 0 {
         return usize::MAX;
@@ -203,22 +203,14 @@ pub unsafe fn sys_unlink() -> usize {
     (*dp).lock();
 
     // Cannot unlink "." or "..".
-    if !(namecmp(
-        name.as_mut_ptr(),
-        b".\x00" as *const u8 as *const libc::CChar,
-    ) == 0
-        || namecmp(
-            name.as_mut_ptr(),
-            b"..\x00" as *const u8 as *const libc::CChar,
-        ) == 0)
+    if !(namecmp(name.as_mut_ptr(), b".\x00" as *const u8) == 0
+        || namecmp(name.as_mut_ptr(), b"..\x00" as *const u8) == 0)
     {
         let mut ip: *mut Inode = dirlookup(dp, name.as_mut_ptr(), &mut off);
         if !ip.is_null() {
             (*ip).lock();
             if ((*ip).nlink as i32) < 1 {
-                panic(
-                    b"unlink: nlink < 1\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-                );
+                panic(b"unlink: nlink < 1\x00" as *const u8 as *mut u8);
             }
             if (*ip).typ as i32 == T_DIR && isdirempty(ip) == 0 {
                 (*ip).unlockput();
@@ -232,10 +224,7 @@ pub unsafe fn sys_unlink() -> usize {
                 ) as usize
                     != ::core::mem::size_of::<Dirent>()
                 {
-                    panic(
-                        b"unlink: writei\x00" as *const u8 as *const libc::CChar
-                            as *mut libc::CChar,
-                    );
+                    panic(b"unlink: writei\x00" as *const u8 as *mut u8);
                 }
                 if (*ip).typ as i32 == T_DIR {
                     (*dp).nlink -= 1;
@@ -255,8 +244,8 @@ pub unsafe fn sys_unlink() -> usize {
     usize::MAX
 }
 
-unsafe fn create(path: *mut libc::CChar, typ: i16, major: i16, minor: i16) -> *mut Inode {
-    let mut name: [libc::CChar; DIRSIZ] = [0; DIRSIZ];
+unsafe fn create(path: *mut u8, typ: i16, major: i16, minor: i16) -> *mut Inode {
+    let mut name: [u8; DIRSIZ] = [0; DIRSIZ];
     let mut dp: *mut Inode = nameiparent(path, name.as_mut_ptr());
     if dp.is_null() {
         return ptr::null_mut();
@@ -274,7 +263,7 @@ unsafe fn create(path: *mut libc::CChar, typ: i16, major: i16, minor: i16) -> *m
     }
     ip = Inode::alloc((*dp).dev, typ);
     if ip.is_null() {
-        panic(b"create: Inode::alloc\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"create: Inode::alloc\x00" as *const u8 as *mut u8);
     }
     (*ip).lock();
     (*ip).major = major;
@@ -289,29 +278,21 @@ unsafe fn create(path: *mut libc::CChar, typ: i16, major: i16, minor: i16) -> *m
         (*dp).update();
 
         // No ip->nlink++ for ".": avoid cyclic ref count.
-        if dirlink(
-            ip,
-            b".\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-            (*ip).inum,
-        ) < 0
-            || dirlink(
-                ip,
-                b"..\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-                (*dp).inum,
-            ) < 0
+        if dirlink(ip, b".\x00" as *const u8 as *mut u8, (*ip).inum) < 0
+            || dirlink(ip, b"..\x00" as *const u8 as *mut u8, (*dp).inum) < 0
         {
-            panic(b"create dots\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"create dots\x00" as *const u8 as *mut u8);
         }
     }
     if dirlink(dp, name.as_mut_ptr(), (*ip).inum) < 0 {
-        panic(b"create: dirlink\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"create: dirlink\x00" as *const u8 as *mut u8);
     }
     (*dp).unlockput();
     ip
 }
 
 pub unsafe fn sys_open() -> usize {
-    let mut path: [libc::CChar; MAXPATH as usize] = [0; MAXPATH as usize];
+    let mut path: [u8; MAXPATH as usize] = [0; MAXPATH as usize];
     let mut fd: i32 = 0;
     let mut omode: i32 = 0;
     let ip: *mut Inode;
@@ -365,16 +346,15 @@ pub unsafe fn sys_open() -> usize {
         (*f).off = 0
     }
     (*f).ip = ip;
-    (*f).readable = (!omode.intersects(FcntlFlags::O_WRONLY)) as i32 as libc::CChar;
-    (*f).writable =
-        omode.intersects(FcntlFlags::O_WRONLY | FcntlFlags::O_RDWR) as i32 as libc::CChar;
+    (*f).readable = (!omode.intersects(FcntlFlags::O_WRONLY)) as i32 as u8;
+    (*f).writable = omode.intersects(FcntlFlags::O_WRONLY | FcntlFlags::O_RDWR) as i32 as u8;
     (*ip).unlock();
     end_op();
     fd as usize
 }
 
 pub unsafe fn sys_mkdir() -> usize {
-    let mut path: [libc::CChar; MAXPATH as usize] = [0; MAXPATH as usize];
+    let mut path: [u8; MAXPATH as usize] = [0; MAXPATH as usize];
     let mut ip: *mut Inode = ptr::null_mut();
     begin_op();
     if argstr(0, path.as_mut_ptr(), MAXPATH) < 0 || {
@@ -391,7 +371,7 @@ pub unsafe fn sys_mkdir() -> usize {
 
 pub unsafe fn sys_mknod() -> usize {
     let mut ip: *mut Inode = ptr::null_mut();
-    let mut path: [libc::CChar; MAXPATH as usize] = [0; MAXPATH as usize];
+    let mut path: [u8; MAXPATH as usize] = [0; MAXPATH as usize];
     let mut major: i32 = 0;
     let mut minor: i32 = 0;
     begin_op();
@@ -417,7 +397,7 @@ pub unsafe fn sys_mknod() -> usize {
 }
 
 pub unsafe fn sys_chdir() -> usize {
-    let mut path: [libc::CChar; MAXPATH as usize] = [0; MAXPATH as usize];
+    let mut path: [u8; MAXPATH as usize] = [0; MAXPATH as usize];
     let mut ip: *mut Inode = ptr::null_mut();
     let mut p: *mut Proc = myproc();
     begin_op();
@@ -443,8 +423,8 @@ pub unsafe fn sys_chdir() -> usize {
 
 pub unsafe fn sys_exec() -> usize {
     let current_block: usize;
-    let mut path: [libc::CChar; MAXPATH as usize] = [0; MAXPATH as usize];
-    let mut argv: [*mut libc::CChar; MAXARG] = [ptr::null_mut(); MAXARG];
+    let mut path: [u8; MAXPATH as usize] = [0; MAXPATH as usize];
+    let mut argv: [*mut u8; MAXARG] = [ptr::null_mut(); MAXARG];
     let mut i: i32 = 0;
     let mut uargv: usize = 0;
     let mut uarg: usize = 0;
@@ -454,8 +434,8 @@ pub unsafe fn sys_exec() -> usize {
     ptr::write_bytes(argv.as_mut_ptr(), 0, 1);
     loop {
         if i as usize
-            >= (::core::mem::size_of::<[*mut libc::CChar; 32]>())
-                .wrapping_div(::core::mem::size_of::<*mut libc::CChar>())
+            >= (::core::mem::size_of::<[*mut u8; 32]>())
+                .wrapping_div(::core::mem::size_of::<*mut u8>())
         {
             current_block = 12646643519710607562;
             break;
@@ -473,11 +453,9 @@ pub unsafe fn sys_exec() -> usize {
             current_block = 6009453772311597924;
             break;
         } else {
-            argv[i as usize] = kalloc() as *mut libc::CChar;
+            argv[i as usize] = kalloc() as *mut u8;
             if argv[i as usize].is_null() {
-                panic(
-                    b"sys_exec kalloc\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-                );
+                panic(b"sys_exec kalloc\x00" as *const u8 as *mut u8);
             }
             if fetchstr(uarg, argv[i as usize], PGSIZE) < 0 {
                 current_block = 12646643519710607562;
@@ -490,8 +468,8 @@ pub unsafe fn sys_exec() -> usize {
         12646643519710607562 => {
             i = 0;
             while (i as usize)
-                < (::core::mem::size_of::<[*mut libc::CChar; 32]>())
-                    .wrapping_div(::core::mem::size_of::<*mut libc::CChar>())
+                < (::core::mem::size_of::<[*mut u8; 32]>())
+                    .wrapping_div(::core::mem::size_of::<*mut u8>())
                 && !argv[i as usize].is_null()
             {
                 kfree(argv[i as usize] as *mut libc::CVoid);
@@ -503,8 +481,8 @@ pub unsafe fn sys_exec() -> usize {
             let ret = exec(path.as_mut_ptr(), argv.as_mut_ptr());
             i = 0;
             while (i as usize)
-                < (::core::mem::size_of::<[*mut libc::CChar; 32]>())
-                    .wrapping_div(::core::mem::size_of::<*mut libc::CChar>())
+                < (::core::mem::size_of::<[*mut u8; 32]>())
+                    .wrapping_div(::core::mem::size_of::<*mut u8>())
                 && !argv[i as usize].is_null()
             {
                 kfree(argv[i as usize] as *mut libc::CVoid);
@@ -544,13 +522,13 @@ pub unsafe fn sys_pipe() -> usize {
     if copyout(
         (*p).pagetable,
         fdarray,
-        &mut fd0 as *mut i32 as *mut libc::CChar,
+        &mut fd0 as *mut i32 as *mut u8,
         ::core::mem::size_of::<i32>(),
     ) < 0
         || copyout(
             (*p).pagetable,
             fdarray.wrapping_add(::core::mem::size_of::<i32>()),
-            &mut fd1 as *mut i32 as *mut libc::CChar,
+            &mut fd1 as *mut i32 as *mut u8,
             ::core::mem::size_of::<i32>(),
         ) < 0
     {
diff --git a/kernel-rs/src/sysproc.rs b/kernel-rs/src/sysproc.rs
index 457a98adb..7b5868490 100644
--- a/kernel-rs/src/sysproc.rs
+++ b/kernel-rs/src/sysproc.rs
@@ -13,7 +13,7 @@ pub unsafe fn sys_exit() -> usize {
     }
     exit(n);
 
-    panic(b"sys_exit: not reached\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    panic(b"sys_exit: not reached\x00" as *const u8 as *mut u8);
 }
 
 pub unsafe fn sys_getpid() -> usize {
diff --git a/kernel-rs/src/trap.rs b/kernel-rs/src/trap.rs
index 8e6220eb9..fa517ed3e 100644
--- a/kernel-rs/src/trap.rs
+++ b/kernel-rs/src/trap.rs
@@ -18,13 +18,13 @@ use core::mem;
 extern "C" {
     // trampoline.S
     #[no_mangle]
-    static mut trampoline: [libc::CChar; 0];
+    static mut trampoline: [u8; 0];
 
     #[no_mangle]
-    static mut uservec: [libc::CChar; 0];
+    static mut uservec: [u8; 0];
 
     #[no_mangle]
-    static mut userret: [libc::CChar; 0];
+    static mut userret: [u8; 0];
 
     // in kernelvec.S, calls kerneltrap().
     #[no_mangle]
@@ -35,7 +35,7 @@ pub static mut TICKSLOCK: Spinlock = Spinlock::zeroed();
 pub static mut TICKS: u32 = 0;
 
 pub unsafe fn trapinit() {
-    TICKSLOCK.initlock(b"time\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+    TICKSLOCK.initlock(b"time\x00" as *const u8 as *mut u8);
 }
 
 /// set up to take exceptions and traps while in the kernel.
@@ -50,10 +50,7 @@ pub unsafe extern "C" fn usertrap() {
     let mut which_dev: i32 = 0;
 
     if r_sstatus() & SSTATUS_SPP as usize != 0 {
-        panic(
-            b"usertrap: not from user mode\x00" as *const u8 as *const libc::CChar
-                as *mut libc::CChar,
-        );
+        panic(b"usertrap: not from user mode\x00" as *const u8 as *mut u8);
     }
 
     // send interrupts and exceptions to kerneltrap(),
@@ -83,14 +80,12 @@ pub unsafe extern "C" fn usertrap() {
         which_dev = devintr();
         if which_dev == 0 {
             printf(
-                b"usertrap(): unexpected scause %p pid=%d\n\x00" as *const u8 as *const libc::CChar
-                    as *mut libc::CChar,
+                b"usertrap(): unexpected scause %p pid=%d\n\x00" as *const u8 as *mut u8,
                 r_scause(),
                 (*p).pid,
             );
             printf(
-                b"            sepc=%p stval=%p\n\x00" as *const u8 as *const libc::CChar
-                    as *mut libc::CChar,
+                b"            sepc=%p stval=%p\n\x00" as *const u8 as *mut u8,
                 r_sepc(),
                 r_stval(),
             );
@@ -174,31 +169,22 @@ pub unsafe fn kerneltrap() {
     let scause: usize = r_scause();
 
     if sstatus & SSTATUS_SPP as usize == 0 {
-        panic(
-            b"kerneltrap: not from supervisor mode\x00" as *const u8 as *const libc::CChar
-                as *mut libc::CChar,
-        );
+        panic(b"kerneltrap: not from supervisor mode\x00" as *const u8 as *mut u8);
     }
 
     if intr_get() != 0 {
-        panic(
-            b"kerneltrap: interrupts enabled\x00" as *const u8 as *const libc::CChar
-                as *mut libc::CChar,
-        );
+        panic(b"kerneltrap: interrupts enabled\x00" as *const u8 as *mut u8);
     }
 
     let which_dev = devintr();
     if which_dev == 0 {
+        printf(b"scause %p\n\x00" as *const u8 as *mut u8, scause);
         printf(
-            b"scause %p\n\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-            scause,
-        );
-        printf(
-            b"sepc=%p stval=%p\n\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
+            b"sepc=%p stval=%p\n\x00" as *const u8 as *mut u8,
             r_sepc(),
             r_stval(),
         );
-        panic(b"kerneltrap\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"kerneltrap\x00" as *const u8 as *mut u8);
     }
 
     // give up the CPU if this is a timer interrupt.
diff --git a/kernel-rs/src/virtio_disk.rs b/kernel-rs/src/virtio_disk.rs
index 49b871fd5..bcc3e900f 100644
--- a/kernel-rs/src/virtio_disk.rs
+++ b/kernel-rs/src/virtio_disk.rs
@@ -32,13 +32,13 @@ struct Disk {
     /// this is a global instead of allocated because it must
     /// be multiple contiguous pages, which kalloc()
     /// doesn't support, and page aligned.
-    pages: [libc::CChar; 2 * PGSIZE as usize],
+    pages: [u8; 2 * PGSIZE as usize],
     desc: *mut VRingDesc,
     avail: *mut u16,
     used: *mut UsedArea,
 
     /// our own book-keeping.
-    free: [libc::CChar; NUM as usize],
+    free: [u8; NUM as usize],
     used_idx: u16,
 
     /// track info about in-flight operations,
@@ -52,7 +52,7 @@ struct Disk {
 #[derive(Copy, Clone)]
 struct InflightInfo {
     b: *mut Buf,
-    status: libc::CChar,
+    status: u8,
 }
 
 #[derive(Default, Copy, Clone)]
@@ -97,16 +97,13 @@ static mut DISK: Disk = Disk::zeroed();
 pub unsafe fn virtio_disk_init() {
     let mut status: u32 = 0;
     DISK.vdisk_lock
-        .initlock(b"virtio_disk\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        .initlock(b"virtio_disk\x00" as *const u8 as *mut u8);
     if *(r(VIRTIO_MMIO_MAGIC_VALUE)) != 0x74726976
         || *(r(VIRTIO_MMIO_VERSION)) != 1
         || *(r(VIRTIO_MMIO_DEVICE_ID)) != 2
         || *(r(VIRTIO_MMIO_VENDOR_ID)) != 0x554d4551
     {
-        panic(
-            b"could not find virtio disk\x00" as *const u8 as *const libc::CChar
-                as *mut libc::CChar,
-        );
+        panic(b"could not find virtio disk\x00" as *const u8 as *mut u8);
     }
     status |= VIRTIO_CONFIG_S_ACKNOWLEDGE as u32;
     ::core::ptr::write_volatile(r(VIRTIO_MMIO_STATUS), status);
@@ -138,16 +135,10 @@ pub unsafe fn virtio_disk_init() {
     ::core::ptr::write_volatile(r(VIRTIO_MMIO_QUEUE_SEL), 0);
     let max: u32 = *(r(VIRTIO_MMIO_QUEUE_NUM_MAX));
     if max == 0 {
-        panic(
-            b"virtio disk has no queue 0\x00" as *const u8 as *const libc::CChar
-                as *mut libc::CChar,
-        );
+        panic(b"virtio disk has no queue 0\x00" as *const u8 as *mut u8);
     }
     if max < NUM as u32 {
-        panic(
-            b"virtio disk max queue too short\x00" as *const u8 as *const libc::CChar
-                as *mut libc::CChar,
-        );
+        panic(b"virtio disk max queue too short\x00" as *const u8 as *mut u8);
     }
     ::core::ptr::write_volatile(r(VIRTIO_MMIO_QUEUE_NUM), NUM as u32);
     ptr::write_bytes(DISK.pages.as_mut_ptr(), 0, 1);
@@ -161,12 +152,12 @@ pub unsafe fn virtio_disk_init() {
     // used = pages + 4096 -- 2 * u16, then num * vRingUsedElem
 
     DISK.desc = DISK.pages.as_mut_ptr() as *mut VRingDesc;
-    DISK.avail = (DISK.desc as *mut libc::CChar)
+    DISK.avail = (DISK.desc as *mut u8)
         .add((NUM as usize).wrapping_mul(::core::mem::size_of::<VRingDesc>()))
         as *mut u16;
     DISK.used = DISK.pages.as_mut_ptr().offset(PGSIZE as isize) as *mut UsedArea;
     for i in 0..NUM {
-        DISK.free[i as usize] = 1 as libc::CChar;
+        DISK.free[i as usize] = 1 as u8;
     }
 
     // plic.c and trap.c arrange for interrupts from VIRTIO0_IRQ.
@@ -176,7 +167,7 @@ pub unsafe fn virtio_disk_init() {
 unsafe fn alloc_desc() -> i32 {
     for i in 0..NUM {
         if DISK.free[i as usize] != 0 {
-            DISK.free[i as usize] = 0 as libc::CChar;
+            DISK.free[i as usize] = 0 as u8;
             return i;
         }
     }
@@ -186,14 +177,14 @@ unsafe fn alloc_desc() -> i32 {
 /// mark a descriptor as free.
 unsafe fn free_desc(i: i32) {
     if i >= NUM {
-        panic(b"virtio_disk_intr 1\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"virtio_disk_intr 1\x00" as *const u8 as *mut u8);
     }
     if DISK.free[i as usize] != 0 {
-        panic(b"virtio_disk_intr 2\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"virtio_disk_intr 2\x00" as *const u8 as *mut u8);
     }
     (*DISK.desc.offset(i as isize)).addr = 0;
-    DISK.free[i as usize] = 1 as libc::CChar;
-    wakeup(&mut *DISK.free.as_mut_ptr().offset(0) as *mut libc::CChar as *mut libc::CVoid);
+    DISK.free[i as usize] = 1 as u8;
+    wakeup(&mut *DISK.free.as_mut_ptr().offset(0) as *mut u8 as *mut libc::CVoid);
 }
 
 /// free a chain of descriptors.
@@ -234,7 +225,7 @@ pub unsafe fn virtio_disk_rw(mut b: *mut Buf, write: i32) {
 
     while alloc3_desc(idx.as_mut_ptr()) != 0 {
         sleep(
-            &mut *DISK.free.as_mut_ptr().offset(0) as *mut libc::CChar as *mut libc::CVoid,
+            &mut *DISK.free.as_mut_ptr().offset(0) as *mut u8 as *mut libc::CVoid,
             &mut DISK.vdisk_lock,
         );
     }
@@ -276,13 +267,13 @@ pub unsafe fn virtio_disk_rw(mut b: *mut Buf, write: i32) {
 
     (*DISK.desc.offset(idx[1] as isize)).next = idx[2] as u16;
 
-    DISK.info[idx[0] as usize].status = 0 as libc::CChar;
+    DISK.info[idx[0] as usize].status = 0 as u8;
 
     (*DISK.desc.offset(idx[2] as isize)).addr = &mut (*DISK
         .info
         .as_mut_ptr()
         .offset(*idx.as_mut_ptr().offset(0) as isize))
-    .status as *mut libc::CChar as usize;
+    .status as *mut u8 as usize;
 
     (*DISK.desc.offset(idx[2] as isize)).len = 1;
 
@@ -321,10 +312,7 @@ pub unsafe fn virtio_disk_intr() {
     while DISK.used_idx as i32 % NUM != (*DISK.used).id as i32 % NUM {
         let id: i32 = (*DISK.used).elems[DISK.used_idx as usize].id as i32;
         if DISK.info[id as usize].status as i32 != 0 {
-            panic(
-                b"virtio_disk_intr status\x00" as *const u8 as *const libc::CChar
-                    as *mut libc::CChar,
-            );
+            panic(b"virtio_disk_intr status\x00" as *const u8 as *mut u8);
         }
         (*DISK.info[id as usize].b).disk = 0;
 
diff --git a/kernel-rs/src/vm.rs b/kernel-rs/src/vm.rs
index 603805af6..b06dc435a 100644
--- a/kernel-rs/src/vm.rs
+++ b/kernel-rs/src/vm.rs
@@ -12,11 +12,11 @@ use core::ptr;
 extern "C" {
     // kernel.ld sets this to end of kernel code.
     #[no_mangle]
-    static mut etext: [libc::CChar; 0];
+    static mut etext: [u8; 0];
 
     // trampoline.S
     #[no_mangle]
-    static mut trampoline: [libc::CChar; 0];
+    static mut trampoline: [u8; 0];
 }
 
 /*
@@ -106,7 +106,7 @@ pub unsafe fn kvminithart() {
 ///    0..12 -- 12 bits of byte offset within the page.
 unsafe fn walk(mut pagetable: PagetableT, va: usize, alloc: i32) -> *mut PteT {
     if va >= MAXVA as usize {
-        panic(b"walk\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"walk\x00" as *const u8 as *mut u8);
     }
     for level in (1..3).rev() {
         let pte: *mut PteT = &mut *pagetable.add(px(level, va)) as *mut usize;
@@ -152,7 +152,7 @@ pub unsafe fn walkaddr(pagetable: PagetableT, va: usize) -> usize {
 /// does not flush TLB or enable paging.
 pub unsafe fn kvmmap(va: usize, pa: usize, sz: usize, perm: i32) {
     if mappages(KERNEL_PAGETABLE, va, sz, pa, perm) != 0 {
-        panic(b"kvmmap\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"kvmmap\x00" as *const u8 as *mut u8);
     };
 }
 
@@ -164,10 +164,10 @@ pub unsafe fn kvmpa(va: usize) -> usize {
     let off: usize = va.wrapping_rem(PGSIZE as usize);
     let pte: *mut PteT = walk(KERNEL_PAGETABLE, va, 0);
     if pte.is_null() {
-        panic(b"kvmpa\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"kvmpa\x00" as *const u8 as *mut u8);
     }
     if *pte & PTE_V as usize == 0 {
-        panic(b"kvmpa\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"kvmpa\x00" as *const u8 as *mut u8);
     }
     let pa: usize = pte2pa(*pte);
     pa.wrapping_add(off)
@@ -192,7 +192,7 @@ pub unsafe fn mappages(
             return -1;
         }
         if *pte & PTE_V as usize != 0 {
-            panic(b"remap\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"remap\x00" as *const u8 as *mut u8);
         }
         *pte = pa2pte(pa) | perm as usize | PTE_V as usize;
         if a == last {
@@ -214,22 +214,14 @@ pub unsafe fn uvmunmap(pagetable: PagetableT, va: usize, size: usize, do_free: i
     loop {
         let pte = walk(pagetable, a, 0);
         if pte.is_null() {
-            panic(b"uvmunmap: walk\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"uvmunmap: walk\x00" as *const u8 as *mut u8);
         }
         if *pte & PTE_V as usize == 0 {
-            printf(
-                b"va=%p pte=%p\n\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-                a,
-                *pte,
-            );
-            panic(
-                b"uvmunmap: not mapped\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-            );
+            printf(b"va=%p pte=%p\n\x00" as *const u8 as *mut u8, a, *pte);
+            panic(b"uvmunmap: not mapped\x00" as *const u8 as *mut u8);
         }
         if pte_flags(*pte) == PTE_V as usize {
-            panic(
-                b"uvmunmap: not a leaf\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-            );
+            panic(b"uvmunmap: not a leaf\x00" as *const u8 as *mut u8);
         }
         if do_free != 0 {
             pa = pte2pa(*pte);
@@ -248,9 +240,7 @@ pub unsafe fn uvmunmap(pagetable: PagetableT, va: usize, size: usize, do_free: i
 pub unsafe fn uvmcreate() -> PagetableT {
     let pagetable: PagetableT = kalloc() as PagetableT;
     if pagetable.is_null() {
-        panic(
-            b"uvmcreate: out of memory\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-        );
+        panic(b"uvmcreate: out of memory\x00" as *const u8 as *mut u8);
     }
     ptr::write_bytes(pagetable as *mut libc::CVoid, 0, PGSIZE as usize);
     pagetable
@@ -261,11 +251,9 @@ pub unsafe fn uvmcreate() -> PagetableT {
 /// sz must be less than a page.
 pub unsafe fn uvminit(pagetable: PagetableT, src: *mut u8, sz: u32) {
     if sz >= PGSIZE as u32 {
-        panic(
-            b"inituvm: more than a page\x00" as *const u8 as *const libc::CChar as *mut libc::CChar,
-        );
+        panic(b"inituvm: more than a page\x00" as *const u8 as *mut u8);
     }
-    let mem: *mut libc::CChar = kalloc() as *mut libc::CChar;
+    let mem: *mut u8 = kalloc() as *mut u8;
     ptr::write_bytes(mem as *mut libc::CVoid, 0, PGSIZE as usize);
     mappages(
         pagetable,
@@ -290,7 +278,7 @@ pub unsafe fn uvmalloc(pagetable: PagetableT, mut oldsz: usize, newsz: usize) ->
     oldsz = pgroundup(oldsz);
     let mut a = oldsz;
     while a < newsz {
-        let mem = kalloc() as *mut libc::CChar;
+        let mem = kalloc() as *mut u8;
         if mem.is_null() {
             uvmdealloc(pagetable, a, oldsz);
             return 0;
@@ -340,7 +328,7 @@ unsafe fn freewalk(pagetable: PagetableT) {
             freewalk(child as PagetableT);
             *pagetable.offset(i as isize) = 0
         } else if pte & PTE_V as usize != 0 {
-            panic(b"freewalk: leaf\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+            panic(b"freewalk: leaf\x00" as *const u8 as *mut u8);
         }
     }
     kfree(pagetable as *mut libc::CVoid);
@@ -369,26 +357,20 @@ pub unsafe fn uvmcopy(old: PagetableT, new: PagetableT, sz: usize) -> i32 {
         }
         let pte = walk(old, i, 0);
         if pte.is_null() {
-            panic(
-                b"uvmcopy: pte should exist\x00" as *const u8 as *const libc::CChar
-                    as *mut libc::CChar,
-            );
+            panic(b"uvmcopy: pte should exist\x00" as *const u8 as *mut u8);
         }
         if *pte & PTE_V as usize == 0 {
-            panic(
-                b"uvmcopy: page not present\x00" as *const u8 as *const libc::CChar
-                    as *mut libc::CChar,
-            );
+            panic(b"uvmcopy: page not present\x00" as *const u8 as *mut u8);
         }
         let pa = pte2pa(*pte);
         let flags = pte_flags(*pte) as u32;
-        let mem = kalloc() as *mut libc::CChar;
+        let mem = kalloc() as *mut u8;
         if mem.is_null() {
             current_block = 9000140654394160520;
             break;
         }
         ptr::copy(
-            pa as *mut libc::CChar as *const libc::CVoid,
+            pa as *mut u8 as *const libc::CVoid,
             mem as *mut libc::CVoid,
             PGSIZE as usize,
         );
@@ -414,7 +396,7 @@ pub unsafe fn uvmcopy(old: PagetableT, new: PagetableT, sz: usize) -> i32 {
 pub unsafe fn uvmclear(pagetable: PagetableT, va: usize) {
     let pte: *mut PteT = walk(pagetable, va, 0);
     if pte.is_null() {
-        panic(b"uvmclear\x00" as *const u8 as *const libc::CChar as *mut libc::CChar);
+        panic(b"uvmclear\x00" as *const u8 as *mut u8);
     }
     *pte &= !PTE_U as usize;
 }
@@ -425,7 +407,7 @@ pub unsafe fn uvmclear(pagetable: PagetableT, va: usize) {
 pub unsafe fn copyout(
     pagetable: PagetableT,
     mut dstva: usize,
-    mut src: *mut libc::CChar,
+    mut src: *mut u8,
     mut len: usize,
 ) -> i32 {
     while len > 0 {
@@ -455,7 +437,7 @@ pub unsafe fn copyout(
 /// Return 0 on success, -1 on error.
 pub unsafe fn copyin(
     pagetable: PagetableT,
-    mut dst: *mut libc::CChar,
+    mut dst: *mut u8,
     mut srcva: usize,
     mut len: usize,
 ) -> i32 {
@@ -487,7 +469,7 @@ pub unsafe fn copyin(
 /// Return 0 on success, -1 on error.
 pub unsafe fn copyinstr(
     pagetable: PagetableT,
-    mut dst: *mut libc::CChar,
+    mut dst: *mut u8,
     mut srcva: usize,
     mut max: usize,
 ) -> i32 {
@@ -502,10 +484,10 @@ pub unsafe fn copyinstr(
         if n > max {
             n = max
         }
-        let mut p: *mut libc::CChar = pa0.wrapping_add(srcva.wrapping_sub(va0)) as *mut libc::CChar;
+        let mut p: *mut u8 = pa0.wrapping_add(srcva.wrapping_sub(va0)) as *mut u8;
         while n > 0 {
             if *p as i32 == '\u{0}' as i32 {
-                *dst = '\u{0}' as i32 as libc::CChar;
+                *dst = '\u{0}' as i32 as u8;
                 got_null = 1;
                 break;
             } else {

From f33360a63d9dd716b9e81502b5c174ee88cd40db Mon Sep 17 00:00:00 2001
From: Jeehoon Kang <jeehoon.kang@kaist.ac.kr>
Date: Wed, 12 Aug 2020 02:04:59 +0000
Subject: [PATCH 2/2] Address comments

---
 kernel-rs/src/fs.rs          | 2 +-
 kernel-rs/src/pipe.rs        | 8 ++++----
 kernel-rs/src/printf.rs      | 2 +-
 kernel-rs/src/proc.rs        | 2 +-
 kernel-rs/src/string.rs      | 6 +++---
 kernel-rs/src/sysfile.rs     | 4 ++--
 kernel-rs/src/virtio_disk.rs | 8 ++++----
 7 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/kernel-rs/src/fs.rs b/kernel-rs/src/fs.rs
index 9e90b0ece..0c9f14770 100644
--- a/kernel-rs/src/fs.rs
+++ b/kernel-rs/src/fs.rs
@@ -774,7 +774,7 @@ unsafe fn skipelem(mut path: *mut u8, name: *mut u8) -> *mut u8 {
             name as *mut libc::CVoid,
             len as usize,
         );
-        *name.offset(len as isize) = 0 as u8
+        *name.offset(len as isize) = 0
     }
     while *path as i32 == '/' as i32 {
         path = path.offset(1)
diff --git a/kernel-rs/src/pipe.rs b/kernel-rs/src/pipe.rs
index 38e0e0d6c..0638f1100 100644
--- a/kernel-rs/src/pipe.rs
+++ b/kernel-rs/src/pipe.rs
@@ -143,12 +143,12 @@ impl Pipe {
                 (*pi).nread = 0;
                 (*pi).lock.initlock(b"pipe\x00" as *const u8 as *mut u8);
                 (**f0).typ = FD_PIPE;
-                (**f0).readable = 1 as u8;
-                (**f0).writable = 0 as u8;
+                (**f0).readable = 1;
+                (**f0).writable = 0;
                 (**f0).pipe = pi;
                 (**f1).typ = FD_PIPE;
-                (**f1).readable = 0 as u8;
-                (**f1).writable = 1 as u8;
+                (**f1).readable = 0;
+                (**f1).writable = 1;
                 (**f1).pipe = pi;
                 return 0;
             }
diff --git a/kernel-rs/src/printf.rs b/kernel-rs/src/printf.rs
index b98f6104b..79e17b3fa 100644
--- a/kernel-rs/src/printf.rs
+++ b/kernel-rs/src/printf.rs
@@ -49,7 +49,7 @@ unsafe fn printint(xx: i32, base: i32, mut sign: i32) {
     if sign != 0 {
         let fresh1 = i;
         i += 1;
-        buf[fresh1 as usize] = '-' as i32 as u8
+        buf[fresh1 as usize] = b'-'
     }
     loop {
         i -= 1;
diff --git a/kernel-rs/src/proc.rs b/kernel-rs/src/proc.rs
index d9a6de08e..f41f8fbce 100644
--- a/kernel-rs/src/proc.rs
+++ b/kernel-rs/src/proc.rs
@@ -430,7 +430,7 @@ unsafe fn freeproc(mut p: *mut Proc) {
     (*p).sz = 0;
     (*p).pid = 0;
     (*p).parent = ptr::null_mut();
-    (*p).name[0] = 0 as u8;
+    (*p).name[0] = 0;
     (*p).chan = ptr::null_mut();
     (*p).killed = 0;
     (*p).xstate = 0;
diff --git a/kernel-rs/src/string.rs b/kernel-rs/src/string.rs
index ba6ddf04e..6213266a4 100644
--- a/kernel-rs/src/string.rs
+++ b/kernel-rs/src/string.rs
@@ -7,7 +7,7 @@ pub unsafe fn strncmp(mut p: *const u8, mut q: *const u8, mut n: u32) -> i32 {
     if n == 0 {
         return 0;
     }
-    *p as u8 as i32 - *q as u8 as i32
+    *p as i32 - *q as i32
 }
 
 pub unsafe fn strncpy(mut s: *mut u8, mut t: *const u8, mut n: i32) -> *mut u8 {
@@ -34,7 +34,7 @@ pub unsafe fn strncpy(mut s: *mut u8, mut t: *const u8, mut n: i32) -> *mut u8 {
         }
         let fresh9 = s;
         s = s.offset(1);
-        *fresh9 = 0 as u8
+        *fresh9 = 0
     }
     os
 }
@@ -58,7 +58,7 @@ pub unsafe fn safestrcpy(mut s: *mut u8, mut t: *const u8, mut n: i32) -> *mut u
             break;
         }
     }
-    *s = 0 as u8;
+    *s = 0;
     os
 }
 
diff --git a/kernel-rs/src/sysfile.rs b/kernel-rs/src/sysfile.rs
index 7e7051638..107518d5a 100644
--- a/kernel-rs/src/sysfile.rs
+++ b/kernel-rs/src/sysfile.rs
@@ -346,8 +346,8 @@ pub unsafe fn sys_open() -> usize {
         (*f).off = 0
     }
     (*f).ip = ip;
-    (*f).readable = (!omode.intersects(FcntlFlags::O_WRONLY)) as i32 as u8;
-    (*f).writable = omode.intersects(FcntlFlags::O_WRONLY | FcntlFlags::O_RDWR) as i32 as u8;
+    (*f).readable = (!omode.intersects(FcntlFlags::O_WRONLY)) as u8;
+    (*f).writable = omode.intersects(FcntlFlags::O_WRONLY | FcntlFlags::O_RDWR) as u8;
     (*ip).unlock();
     end_op();
     fd as usize
diff --git a/kernel-rs/src/virtio_disk.rs b/kernel-rs/src/virtio_disk.rs
index bcc3e900f..e7cd64219 100644
--- a/kernel-rs/src/virtio_disk.rs
+++ b/kernel-rs/src/virtio_disk.rs
@@ -157,7 +157,7 @@ pub unsafe fn virtio_disk_init() {
         as *mut u16;
     DISK.used = DISK.pages.as_mut_ptr().offset(PGSIZE as isize) as *mut UsedArea;
     for i in 0..NUM {
-        DISK.free[i as usize] = 1 as u8;
+        DISK.free[i as usize] = 1;
     }
 
     // plic.c and trap.c arrange for interrupts from VIRTIO0_IRQ.
@@ -167,7 +167,7 @@ pub unsafe fn virtio_disk_init() {
 unsafe fn alloc_desc() -> i32 {
     for i in 0..NUM {
         if DISK.free[i as usize] != 0 {
-            DISK.free[i as usize] = 0 as u8;
+            DISK.free[i as usize] = 0;
             return i;
         }
     }
@@ -183,7 +183,7 @@ unsafe fn free_desc(i: i32) {
         panic(b"virtio_disk_intr 2\x00" as *const u8 as *mut u8);
     }
     (*DISK.desc.offset(i as isize)).addr = 0;
-    DISK.free[i as usize] = 1 as u8;
+    DISK.free[i as usize] = 1;
     wakeup(&mut *DISK.free.as_mut_ptr().offset(0) as *mut u8 as *mut libc::CVoid);
 }
 
@@ -267,7 +267,7 @@ pub unsafe fn virtio_disk_rw(mut b: *mut Buf, write: i32) {
 
     (*DISK.desc.offset(idx[1] as isize)).next = idx[2] as u16;
 
-    DISK.info[idx[0] as usize].status = 0 as u8;
+    DISK.info[idx[0] as usize].status = 0;
 
     (*DISK.desc.offset(idx[2] as isize)).addr = &mut (*DISK
         .info