release: v0.14.0

pkg/app/brk/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "ggos_brk"
+version = "0.0.1"
+edition = "2021"
+authors = ["GZTime <[email protected]>"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+lib = { path="../../lib", package="gglib", default-features=false, features=["kernel_alloc"] }

pkg/app/brk/src/main.rs

@@ -0,0 +1,116 @@
+#![no_std]
+#![no_main]
+
+extern crate alloc;
+
+use alloc::vec::Vec;
+use lib::*;
+
+extern crate lib;
+
+fn main() -> isize {
+ println!("Welcome to Brk Test!");
+
+ pre_test();
+
+ loop {
+ print!("$ ");
+ let command = stdin().read_line();
+ let line: Vec<&str> = command.trim().split(' ').collect();
+
+ match line[0] {
+ "brk" => {
+ if line.len() != 2 {
+ println!("Usage: brk <addr>");
+ continue;
+ }
+
+ let addr = if line[1].starts_with("0x") {
+ usize::from_str_radix(&line[1][2..], 16)
+ } else {
+ line[1].parse::<usize>()
+ };
+
+ let addr = match addr {
+ Ok(addr) => addr,
+ Err(_) => {
+ println!("Invalid address: {}", line[1]);
+ continue;
+ }
+ };
+
+ match sys_brk(Some(addr)) {
+ Some(new_brk) => {
+ println!("Brk to {:#x} success, new brk addr: {:#x}", addr, new_brk)
+ }
+ None => println!("Brk to {:#x} failed", addr),
+ }
+
+ sys_stat();
+ }
+ "cur" => match sys_brk(None) {
+ Some(brk) => println!("Current brk addr: {:#x}", brk),
+ None => println!("Failed to get current brk addr"),
+ },
+ "exit" => {
+ break;
+ }
+ _ => {
+ println!("Unknown command: {}", line[0]);
+ }
+ }
+ }
+
+ 0
+}
+
+fn pre_test() {
+ println!("Pre-test: Brk Test");
+
+ let brk = sys_brk(None);
+
+ let brk = match brk {
+ Some(brk) => {
+ println!("Current brk addr: {:#x}", brk);
+ brk
+ }
+ None => {
+ println!("Failed to get current brk addr");
+ sys_exit(1);
+ }
+ };
+
+ let new_brk = sys_brk(Some(brk + 0x1000));
+
+ match new_brk {
+ Some(new_brk) => {
+ println!(
+ "Brk to {:#x} success, new brk addr: {:#x}",
+ brk + 0x1000,
+ new_brk
+ );
+ sys_stat();
+ }
+ None => {
+ println!("Brk to {:#x} failed", brk + 0x1000);
+ sys_exit(1);
+ }
+ }
+
+ let new_brk = sys_brk(Some(brk));
+
+ match new_brk {
+ Some(new_brk) => {
+ println!("Brk to {:#x} success, new brk addr: {:#x}", brk, new_brk);
+ sys_stat();
+ }
+ None => {
+ println!("Brk to {:#x} failed", brk);
+ sys_exit(1);
+ }
+ }
+
+ println!("Pre-test finished");
+}
+
+entry!(main);

pkg/app/clock/src/display.rs

@@ -12,7 +12,7 @@ impl Dimensions for SysDisplay {
  }
 }
 
-impl<'a> DrawTarget for SysDisplay {
+impl DrawTarget for SysDisplay {
  type Color = Rgb888;
  type Error = ();
 

pkg/app/clock/src/main.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![no_main]
 #![allow(unreachable_code)]
+#![allow(clippy::diverging_sub_expression)]
 
 use embedded_graphics::pixelcolor::Rgb888;
 use lib::*;
@@ -39,7 +40,7 @@ fn clock() -> ! {
  let value = angle / 180f32 * core::f32::consts::PI;
 
  let len = 24i32;
- let (cx, cy) = (cx as i32 - len - 10, len + 8);
+ let (cx, cy) = (cx - len - 10, len + 8);
 
  let (dx, dy) = (
  (len as f32 * value.cos()) as i32,

pkg/app/dining/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ggos_dining"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 authors = ["GZTime <[email protected]>"]
 

pkg/app/dining/src/main.rs

@@ -6,20 +6,24 @@ use lib::*;
 extern crate lib;
 
 static CHOPSTICK: [Semaphore; 5] = semaphore_array![0, 1, 2, 3, 4];
+static WAITER: Semaphore = Semaphore::new(64);
 
-fn main() -> usize {
+fn main() -> isize {
  let mut pids = [0u16; 5];
 
- for i in 0..5 {
- CHOPSTICK[i].init(1);
+ // allow 4 philosophers to eat at the same time
+ WAITER.init(4);
+
+ for chop in &CHOPSTICK {
+ chop.init(1);
  }
 
- for i in 0..5 {
+ for (i, item) in pids.iter_mut().enumerate() {
  let pid = sys_fork();
  if pid == 0 {
  philosopher(i);
  } else {
- pids[i] = pid;
+ *item = pid;
  }
  }
 
@@ -29,33 +33,40 @@ fn main() -> usize {
 
  sys_stat();
 
- for i in 0..5 {
- println!("#{} Waiting for #{}...", cpid, pids[i]);
- sys_wait_pid(pids[i]);
+ for pid in pids {
+ println!("#{} Waiting for #{}...", cpid, pid);
+ sys_wait_pid(pid);
  }
 
  0
 }
 
 fn philosopher(id: usize) -> ! {
  let pid = sys_get_pid();
- for _ in 0..20 {
- if id == 0 {
- println!("philosopher #{}({}) is sleeping...", id, pid);
- core::hint::spin_loop();
- }
-
- println!("philosopher #{}({}) is thinking...", id, pid);
-
- CHOPSTICK[id].acquire();
- CHOPSTICK[(id + 1) % 5].acquire();
 
- println!("philosopher #{}({}) is eating...", id, pid);
-
- CHOPSTICK[(id + 1) % 5].release();
- CHOPSTICK[id].release();
+ for _ in 0..100 {
+ // thinking
+ println!("philosopher #{} ({}) is thinking...", id, pid);
+ delay();
+
+ // hungry
+ WAITER.wait();
+ CHOPSTICK[id].wait();
+ CHOPSTICK[(id + 1) % 5].wait();
+ println!("philosopher #{} ({}) is eating...", id, pid);
+ CHOPSTICK[(id + 1) % 5].signal();
+ CHOPSTICK[id].signal();
+ WAITER.signal();
  }
  sys_exit(0);
 }
 
+#[inline(never)]
+#[no_mangle]
+fn delay() {
+ for _ in 0..100 {
+ core::hint::spin_loop();
+ }
+}
+
 entry!(main);

pkg/app/fact/src/main.rs

@@ -15,7 +15,7 @@ fn factorial(n: u64) -> u64 {
  }
 }
 
-fn main() -> usize {
+fn main() -> isize {
  print!("Input n: ");
 
  let input = lib::stdin().read_line();

pkg/app/fork/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ggos_fork"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 authors = ["GZTime <[email protected]>"]
 

pkg/app/fork/src/main.rs

@@ -3,41 +3,53 @@
 
 extern crate alloc;
 extern crate lib;
+
 use lib::*;
 
 static mut M: u64 = 0xdeadbeef;
 
-fn main() -> usize {
+fn main() -> isize {
  let mut c = 32;
 
  // do not alloc heap before `fork`
  // which may cause unexpected behavior since we won't copy the heap in `fork`
- let ret = sys_fork();
+ let pid = sys_fork();
 
- if ret == 0 {
+ if pid == 0 {
  println!("I am the child process");
+
+ assert_eq!(c, 32);
+
  unsafe {
  println!("child read value of M: {:#x}", M);
  M = 0x2333;
  println!("child changed the value of M: {:#x}", M);
  }
+
  c += 32;
  } else {
  println!("I am the parent process");
 
  sys_stat();
 
+ assert_eq!(c, 32);
+
  println!("Waiting for child to exit...");
 
- let ret = sys_wait_pid(ret);
+ let ret = sys_wait_pid(pid);
 
  println!("Child exited with status {}", ret);
 
+ assert_eq!(ret, 64);
+
  unsafe {
  println!("parent read value of M: {:#x}", M);
+ assert_eq!(M, 0x2333);
  }
 
  c += 1024;
+
+ assert_eq!(c, 1056);
  }
 
  c