Merge pull request #1 from MemoryShore/dev

NovaShell初代版本

.gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "rust-analyzer.linkedProjects": [
+        "./Cargo.toml",
+        "./Cargo.toml",
+        "./Cargo.toml"
+    ],
+    "rust-analyzer.checkOnSave": true
+}

Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "NovaShell"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[[bin]]
+name = "NovaShell"
+path = "src/main.rs"
+
+[dependencies]
+dragonos-dsc = { git = "https://git.mirrors.dragonos.org/DragonOS-Community/dragonos-dsc.git", rev = "7c654bcccc" }
+lazy_static = "1.4.0"
+regex = "1.10.2"
+libc = "0.2"
+
+[profile.release]
+panic = 'abort'
+
+[profile.dev]
+panic = 'abort'

Makefile

@@ -0,0 +1,28 @@
+export RUSTUP_DIST_SERVER=https://mirrors.ustc.edu.cn/rust-static
+export RUSTUP_UPDATE_ROOT=https://mirrors.ustc.edu.cn/rust-static/rustup
+
+OUTPUT_DIR = $(DADK_BUILD_CACHE_DIR_NOVA_SHELL_0_1_0)
+TMP_INSTALL_DIR=$(OUTPUT_DIR)/tmp_install
+
+all: build
+
+build:
+	RUSTFLAGS='-C target-feature=+crt-static -C link-arg=-no-pie' cargo build --target=x86_64-unknown-linux-musl --release
+
+install:
+	mkdir -p $(TMP_INSTALL_DIR)
+	mkdir -p $(OUTPUT_DIR)
+
+	RUSTFLAGS='-C target-feature=+crt-static -C link-arg=-no-pie' cargo install --target=x86_64-unknown-linux-musl --path .  --root $(TMP_INSTALL_DIR)
+	mv $(TMP_INSTALL_DIR)/bin/NovaShell $(OUTPUT_DIR)/NovaShell
+	rm -rf $(TMP_INSTALL_DIR)
+
+clean:
+	cargo clean
+
+
+fmt:
+	cargo fmt
+
+fmt-check:
+	cargo fmt --check

rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "nightly-2023-08-15"
+components = ["rust-src"]

src/main.rs

@@ -0,0 +1,101 @@
+extern crate libc;
+
+#[macro_use]
+extern crate lazy_static;
+
+use std::{
+    collections::HashMap,
+    fs::File,
+    io::{Read, Write},
+    path::Path,
+    string::String,
+    vec::Vec,
+};
+
+pub const ROOT_PATH: &str = "/";
+
+mod shell;
+
+pub mod special_keycode {
+    pub const LF: u8 = b'\n';
+    pub const CR: u8 = b'\r';
+    pub const DL: u8 = b'\x7f';
+    pub const BS: u8 = b'\x08';
+    pub const SPACE: u8 = b' ';
+    pub const TAB: u8 = b'\t';
+
+    pub const UP: u8 = 72;
+    pub const DOWN: u8 = 80;
+    pub const LEFT: u8 = 75;
+    pub const RIGHT: u8 = 77;
+}
+
+struct Env(std::collections::HashMap<String, String>);
+
+lazy_static! {
+    static ref ENV: std::sync::Mutex<Env> = std::sync::Mutex::new(Env(HashMap::new()));
+}
+
+impl Env {
+    fn init_env() {
+        let mut file = File::create("/etc/profile").unwrap();
+        file.write_all("PATH=/bin:/usr/bin:/usr/local/bin\n".as_bytes())
+            .unwrap();
+        file.write_all("PWD=/\n".as_bytes()).unwrap();
+    }
+
+    fn read_env() {
+        let env = &mut ENV.lock().unwrap().0;
+        let mut file = File::open("/etc/profile").unwrap();
+        let mut buf: Vec<u8> = Vec::new();
+        file.read_to_end(&mut buf).unwrap();
+        for (name, value) in String::from_utf8(buf)
+            .unwrap()
+            .split('\n')
+            .filter_map(|str| {
+                let v = str.split('=').collect::<Vec<&str>>();
+                if v.len() == 2 && !v.contains(&"") {
+                    Some((*v.get(0).unwrap(), *v.get(1).unwrap()))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<(&str, &str)>>()
+        {
+            env.insert(String::from(name), String::from(value));
+        }
+    }
+
+    fn get(key: &String) -> Option<String> {
+        let env = &mut ENV.lock().unwrap().0;
+        env.get(key).map(|value| value.clone())
+    }
+
+    fn insert(key: String, value: String) {
+        ENV.lock().unwrap().0.insert(key, value);
+    }
+
+    fn path() -> Vec<String> {
+        let env = &ENV.lock().unwrap().0;
+        let paths = env.get("PATH").unwrap();
+        paths
+            .split(':')
+            .filter_map(|str| {
+                let path = String::from(str);
+                if Path::new(&path).is_dir() {
+                    Some(path)
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<String>>()
+    }
+}
+
+fn main() {
+    Env::init_env();
+    Env::read_env();
+    let mut shell = shell::Shell::new();
+    shell.exec();
+    return;
+}

src/shell/command/help.rs

@@ -0,0 +1,70 @@
+pub struct Help {}
+
+impl Help {
+    pub fn shell_help(cmd: &str) {
+        match cmd {
+            "cd" => Self::shell_help_cd(),
+            "ls" => Self::shell_help_ls(),
+            "cat" => Self::shell_help_cat(),
+            "touch" => Self::shell_help_touch(),
+            "mkdir" => Self::shell_help_mkdir(),
+            "rm" => Self::shell_help_rm(),
+            "rmdir" => Self::shell_help_rmdir(),
+            "pwd" => Self::shell_help_pwd(),
+            "cp" => Self::shell_help_cp(),
+            "exec" => Self::shell_help_exec(),
+            "echo" => Self::shell_help_echo(),
+            "reboot" => Self::shell_help_reboot(),
+            "compgen" => Self::shell_help_compgen(),
+            "complete" => Self::shell_help_complete(),
+
+            _ => {}
+        };
+    }
+
+    fn shell_help_cd() {
+        println!("Usage: cd [directory]");
+    }
+
+    fn shell_help_ls() {}
+
+    fn shell_help_cat() {
+        println!("cat: cat file");
+    }
+
+    fn shell_help_touch() {
+        println!("touch: touch file");
+    }
+
+    fn shell_help_mkdir() {
+        println!("mkdir: mkdir directory");
+    }
+
+    fn shell_help_rm() {
+        println!("rm: rm file");
+    }
+
+    fn shell_help_rmdir() {
+        println!("rmdir: rmdir directory");
+    }
+
+    fn shell_help_pwd() {}
+
+    fn shell_help_cp() {
+        println!("cp: cp file file | directory");
+    }
+
+    fn shell_help_exec() {
+        println!("exec: exec file");
+    }
+
+    fn shell_help_echo() {
+        println!("echo: echo string");
+    }
+
+    fn shell_help_reboot() {}
+
+    fn shell_help_compgen() {}
+
+    fn shell_help_complete() {}
+}

src/shell/command/mod.rs

@@ -0,0 +1,675 @@
+use help::Help;
+use regex::{Captures, Regex};
+use std::io::Read;
+use std::os::unix::ffi::OsStrExt;
+use std::{
+    format,
+    fs::{self, File, OpenOptions},
+    io::Write,
+    path::Path,
+    print, println,
+    string::String,
+    vec::Vec,
+};
+
+use crate::shell::Shell;
+use crate::Env;
+use crate::{special_keycode::*, ROOT_PATH};
+
+mod help;
+
+enum CommandType {
+    InternalCommand(BuildInCmd),
+    ExternalCommand(String),
+}
+
+pub struct Command {
+    args: Vec<String>,
+    cmd_type: CommandType,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum CommandError {
+    CommandNotFound(String),
+    InvalidArgument(String),
+    WrongArgumentCount(usize),
+    EnvironmentVariableNotFound(String),
+    PathNotFound(String),
+    FileNotFound(String),
+    DirectoryNotFound(String),
+    NotDirectory(String),
+    NotFile(String),
+}
+
+impl CommandError {
+    pub fn handle(e: CommandError) {
+        match e {
+            CommandError::CommandNotFound(command) => {
+                println!("cannot find command: {}", command)
+            }
+            CommandError::InvalidArgument(argument) => {
+                println!("invalid argument: {}", argument)
+            }
+            CommandError::WrongArgumentCount(count) => {
+                println!("argument count incorrect: {}", count)
+            }
+            CommandError::EnvironmentVariableNotFound(env) => {
+                println!("environment variable not found: {}", env);
+            }
+            CommandError::PathNotFound(path) => {
+                println!("cannot found file or dirctory: {}", path)
+            }
+            CommandError::FileNotFound(path) => {
+                println!("cannot found file: {}", path)
+            }
+            CommandError::DirectoryNotFound(path) => {
+                println!("cannot found dirctory: {}", path)
+            }
+            CommandError::NotDirectory(path) => {
+                println!("path is not a dirctory: {}", path)
+            }
+            CommandError::NotFile(path) => {
+                println!("path is not a file: {}", path)
+            }
+        };
+    }
+}
+
+impl Command {
+    fn new(name: String, args: Vec<String>) -> Result<Command, CommandError> {
+        for BuildInCmd(cmd) in BuildInCmd::BUILD_IN_CMD {
+            if name == *cmd {
+                return Ok(Command {
+                    args,
+                    cmd_type: CommandType::InternalCommand(BuildInCmd(cmd)),
+                });
+            }
+        }
+
+        return Ok(Command {
+            args,
+            cmd_type: CommandType::ExternalCommand(name),
+        });
+    }
+
+    fn from_string(str: String) -> Result<Command, CommandError> {
+        let regex: Regex = Regex::new(r#"([^\s'"]|("[^"]*"|'[^']*'))+"#).unwrap();
+        let hay = str.clone();
+        let mut iter = regex
+            .captures_iter(hay.as_str())
+            .map(|c| String::from(c.get(0).unwrap().as_str()));
+        // let mut iter = str.split_ascii_whitespace();
+        let name = iter.next().unwrap();
+        let re: Regex = Regex::new(r"\$[\w_]+").unwrap();
+        let replacement = |caps: &Captures| -> String {
+            match Env::get(&String::from(&caps[0][1..])) {
+                Some(value) => value,
+                None => String::from(&caps[0]),
+            }
+        };
+        let mut args: Vec<String> = Vec::new();
+        for arg in iter.collect::<Vec<String>>().iter() {
+            let arg = re.replace_all(arg.as_str(), &replacement).to_string();
+            match re.captures(arg.as_str()) {
+                Some(caps) => {
+                    return Err(CommandError::EnvironmentVariableNotFound(String::from(
+                        caps.get(0).unwrap().as_str(),
+                    )))
+                }
+                None => args.push(arg),
+            }
+        }
+        Command::new(name, args)
+    }
+
+    pub fn from_strings(str: String) -> Vec<Command> {
+        str.split(';')
+            .filter_map(|s| match Command::from_string(String::from(s)) {
+                Ok(s) => Some(s),
+                Err(e) => {
+                    CommandError::handle(e);
+                    None
+                }
+            })
+            .collect::<Vec<Command>>()
+    }
+}
+
+pub struct BuildInCmd(pub &'static str);
+
+impl BuildInCmd {
+    pub const BUILD_IN_CMD: &[BuildInCmd] = &[
+        BuildInCmd("cd"),
+        BuildInCmd("ls"),
+        BuildInCmd("cat"),
+        BuildInCmd("touch"),
+        BuildInCmd("mkdir"),
+        BuildInCmd("rm"),
+        BuildInCmd("rmdir"),
+        BuildInCmd("pwd"),
+        BuildInCmd("cp"),
+        BuildInCmd("exec"),
+        BuildInCmd("echo"),
+        BuildInCmd("reboot"),
+        BuildInCmd("free"),
+        BuildInCmd("kill"),
+        BuildInCmd("help"),
+        BuildInCmd("export"),
+        BuildInCmd("env"),
+        BuildInCmd("compgen"),
+        BuildInCmd("complete"),
+    ];
+}
+
+impl Shell {
+    pub fn exec_internal_command(
+        &mut self,
+        cmd: &str,
+        args: &Vec<String>,
+    ) -> Result<(), CommandError> {
+        match cmd {
+            "cd" => self.shell_cmd_cd(args),
+            "ls" => self.shell_cmd_ls(args),
+            "cat" => self.shell_cmd_cat(args),
+            "touch" => self.shell_cmd_touch(args),
+            "mkdir" => self.shell_cmd_mkdir(args),
+            "rm" => self.shell_cmd_rm(args),
+            "rmdir" => self.shell_cmd_rmdir(args),
+            "pwd" => self.shell_cmd_pwd(args),
+            "cp" => self.shell_cmd_cp(args),
+            "exec" => self.shell_cmd_exec(args),
+            "echo" => self.shell_cmd_echo(args),
+            "reboot" => self.shell_cmd_reboot(args),
+            "free" => self.shell_cmd_free(args),
+            "kill" => self.shell_cmd_kill(args),
+            "help" => self.shell_cmd_help(args),
+            "export" => self.shell_cmd_export(args),
+            "env" => self.shell_cmd_env(args),
+            "compgen" => self.shell_cmd_compgen(args),
+            "complete" => self.shell_cmd_complete(args),
+
+            _ => Err(CommandError::CommandNotFound(String::from(cmd))),
+        }
+    }
+
+    pub fn exec_external_command(&mut self, path: String, args: &Vec<String>) {
+        let mut full_args = args.clone();
+        full_args.insert(0, path.clone());
+        self.shell_cmd_exec(&full_args).unwrap_or_else(|e| {
+            let err = match e {
+                CommandError::FileNotFound(_) => CommandError::CommandNotFound(path.clone()),
+                _ => e,
+            };
+            CommandError::handle(err);
+        })
+    }
+
+    pub fn exec_command(&mut self, command: &Command) {
+        match &command.cmd_type {
+            CommandType::ExternalCommand(path) => {
+                self.exec_external_command(path.to_string(), &command.args);
+            }
+
+            CommandType::InternalCommand(BuildInCmd(cmd)) => {
+                match self.exec_internal_command(cmd, &command.args) {
+                    Ok(_) => {}
+                    Err(e) => CommandError::handle(e),
+                }
+                if command.args.contains(&String::from("--help")) {
+                    Help::shell_help(cmd);
+                }
+            }
+        }
+    }
+
+    fn shell_cmd_cd(&mut self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 0 {
+            self.set_current_dir(String::from(ROOT_PATH));
+            return Ok(());
+        }
+        if args.len() == 1 {
+            let path = self.to_absolute_path(args.get(0).unwrap());
+            if Path::new(&path).is_dir() {
+                self.set_current_dir(String::from(path));
+                return Ok(());
+            } else {
+                return Err(CommandError::NotDirectory(path));
+            }
+        } else {
+            return Err(CommandError::WrongArgumentCount(args.len()));
+        }
+    }
+
+    fn shell_cmd_ls(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        let mut path = String::new();
+        if args.len() == 0 {
+            path = self.current_dir();
+        }
+        if args.len() == 1 {
+            path = self.to_absolute_path(args.get(0).unwrap());
+        }
+
+        if path.is_empty() {
+            return Err(CommandError::WrongArgumentCount(args.len()));
+        }
+
+        let dir: fs::ReadDir;
+        match fs::read_dir(Path::new(&path)) {
+            Ok(readdir) => dir = readdir,
+            Err(_) => return Err(CommandError::InvalidArgument(path)),
+        }
+        for entry in dir {
+            let entry = entry.unwrap();
+            if entry.file_type().unwrap().is_dir() {
+                crate::shell::Printer::print_color(
+                    entry.file_name().as_bytes(),
+                    0x000088ff,
+                    0x00000000,
+                );
+                print!("    ");
+            } else {
+                print!("{}    ", entry.file_name().into_string().unwrap());
+            }
+        }
+        print!("{}", String::from_utf8(vec![CR, LF]).unwrap());
+        return Ok(());
+    }
+
+    fn shell_cmd_cat(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() > 0 {
+            let path = self.to_absolute_path(args.get(0).unwrap());
+            let mut buf: Vec<u8> = Vec::new();
+            if !Path::new(&path).exists() {
+                return Err(CommandError::PathNotFound(path));
+            } else if !Path::new(&path).is_file() {
+                return Err(CommandError::NotFile(path));
+            }
+
+            File::open(path).unwrap().read_to_end(&mut buf).unwrap();
+            if args.len() == 1 {
+                println!("{}", String::from_utf8(buf.clone()).unwrap());
+            }
+
+            if args.len() == 3 {
+                let target_path = self.to_absolute_path(args.get(2).unwrap());
+                if !Path::new(&target_path).is_file() {
+                    return Err(CommandError::NotFile(target_path));
+                }
+
+                if args[1] == ">" {
+                    match OpenOptions::new().write(true).open(target_path) {
+                        Ok(mut file) => {
+                            file.write_all(&buf).unwrap();
+                        }
+                        Err(e) => print!("{e}"),
+                    }
+                } else if args[1] == ">>" {
+                    match OpenOptions::new().append(true).open(target_path) {
+                        Ok(mut file) => {
+                            file.write_all(&buf).unwrap();
+                        }
+                        Err(e) => print!("{e}"),
+                    }
+                }
+            }
+            return Ok(());
+        }
+        return Err(CommandError::WrongArgumentCount(args.len()));
+    }
+
+    fn shell_cmd_touch(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 1 {
+            let path = self.to_absolute_path(args.get(0).unwrap());
+            match File::create(path) {
+                Ok(_) => {}
+                Err(e) => {
+                    print!("{e}")
+                }
+            };
+            return Ok(());
+        }
+        return Err(CommandError::WrongArgumentCount(args.len()));
+    }
+
+    fn shell_cmd_mkdir(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 1 {
+            let path = self.to_absolute_path(args.get(0).unwrap());
+            let dir = &path[0..path.rfind('/').unwrap_or(0)];
+            if !Path::new(dir).is_dir() {
+                return Err(CommandError::DirectoryNotFound(dir.to_string()));
+            }
+            match fs::create_dir_all(path) {
+                Ok(_) => {}
+                Err(e) => {
+                    print!("{e}")
+                }
+            }
+            return Ok(());
+        } else {
+            return Err(CommandError::WrongArgumentCount(args.len()));
+        }
+    }
+
+    fn shell_cmd_rm(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 1 {
+            let path = self.to_absolute_path(args.get(0).unwrap());
+            // match fs::remove_file(path) {
+            //     Ok(_) => {}
+            //     Err(e) => {
+            //         print!("{e}")
+            //     }
+            // }
+            if Path::new(&path).is_file() {
+                let path_cstr = std::ffi::CString::new(path).unwrap();
+                unsafe {
+                    // libc::unlinkat(0, path_cstr.as_ptr(), 0);
+                    libc::syscall(libc::SYS_unlinkat, 0, path_cstr.as_ptr(), 0, 0, 0, 0);
+                }
+                return Ok(());
+            } else {
+                return Err(CommandError::FileNotFound(path));
+            }
+        }
+        return Err(CommandError::WrongArgumentCount(args.len()));
+    }
+
+    fn shell_cmd_rmdir(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 1 {
+            let path = self.to_absolute_path(args.get(0).unwrap());
+            if Path::new(&path).is_dir() {
+                let path_cstr = std::ffi::CString::new(path).unwrap();
+                unsafe { libc::unlinkat(0, path_cstr.as_ptr(), libc::AT_REMOVEDIR) };
+                return Ok(());
+            } else {
+                return Err(CommandError::DirectoryNotFound(path));
+            }
+        } else {
+            return Err(CommandError::WrongArgumentCount(args.len()));
+        }
+    }
+
+    fn shell_cmd_pwd(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 0 {
+            println!("{}", self.current_dir());
+            return Ok(());
+        } else {
+            return Err(CommandError::WrongArgumentCount(args.len()));
+        }
+    }
+
+    fn shell_cmd_cp(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 2 {
+            let src_path = self.to_absolute_path(args.get(0).unwrap());
+            let mut target_path = self.to_absolute_path(args.get(1).unwrap());
+            if !Path::new(&src_path).is_file() {
+                return Err(CommandError::NotFile(src_path));
+            };
+            let mut src_file = File::open(&src_path).unwrap();
+            let name = &src_path[src_path.rfind('/').unwrap_or(0)..];
+
+            if !Path::new(&target_path).exists() {
+                return Err(CommandError::PathNotFound(target_path));
+            } else if Path::new(&target_path).is_dir() {
+                target_path = format!("{}/{}", target_path, name);
+            }
+            let mut target_file = File::create(target_path).unwrap();
+            let mut buf: Vec<u8> = Vec::new();
+            src_file.read_to_end(&mut buf).unwrap();
+            target_file.write_all(&buf).unwrap();
+            return Ok(());
+        } else {
+            return Err(CommandError::WrongArgumentCount(args.len()));
+        }
+    }
+
+    pub fn shell_cmd_exec(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        let path = args.get(0).unwrap();
+        let mut real_path = String::new();
+        if !path.starts_with('/') {
+            let mut prefix_collection = Env::path();
+            prefix_collection.insert(0, self.current_dir());
+            for prefix in prefix_collection {
+                real_path = Self::path_format(&format!("{}/{}", prefix, path));
+                if Path::new(&real_path).is_file() {
+                    break;
+                }
+            }
+        }
+
+        if !Path::new(&real_path).is_file() {
+            return Err(CommandError::FileNotFound(path.clone()));
+        }
+
+        let pid: libc::pid_t = unsafe {
+            libc::syscall(libc::SYS_fork, 0, 0, 0, 0, 0, 0)
+                .try_into()
+                .unwrap()
+        };
+        let mut retval = 0;
+        if pid == 0 {
+            let path_cstr = std::ffi::CString::new(real_path).unwrap();
+            let mut argv: *const *const i8 = std::ptr::null();
+            if args.len() > 1 {
+                let args_cstr = args
+                    .iter()
+                    .skip(1)
+                    .map(|str| std::ffi::CString::new(str.as_str()).unwrap())
+                    .collect::<Vec<std::ffi::CString>>();
+                let mut args_ptr = args_cstr
+                    .iter()
+                    .map(|c_str| c_str.as_ptr())
+                    .collect::<Vec<*const i8>>();
+                args_ptr.push(std::ptr::null());
+                argv = args_ptr.as_ptr();
+            }
+            unsafe {
+                libc::execv(path_cstr.as_ptr(), argv);
+            }
+        } else {
+            if args.last().unwrap() != &"&" {
+                unsafe { libc::waitpid(pid, &mut retval as *mut i32, 0) };
+            } else {
+                println!("[1] {}", pid);
+            }
+        }
+        return Ok(());
+    }
+
+    fn shell_cmd_echo(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() > 0 {
+            let str = args.get(0).unwrap();
+            if args.len() == 1 {
+                println!("{str}");
+            }
+
+            if args.len() == 3 {
+                let target_path = self.to_absolute_path(args.get(2).unwrap());
+                if args[1] == ">" {
+                    match OpenOptions::new().write(true).open(target_path) {
+                        Ok(mut file) => {
+                            file.write_all(str.as_bytes()).unwrap();
+                        }
+                        Err(e) => print!("{e}"),
+                    }
+                } else if args[1] == ">>" {
+                    match OpenOptions::new().append(true).open(target_path) {
+                        Ok(mut file) => {
+                            file.write_all(str.as_bytes()).unwrap();
+                        }
+                        Err(e) => print!("{e}"),
+                    }
+                }
+            }
+            return Ok(());
+        } else {
+            return Err(CommandError::WrongArgumentCount(args.len()));
+        }
+    }
+
+    fn shell_cmd_reboot(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 0 {
+            unsafe { libc::syscall(libc::SYS_reboot, 0, 0, 0, 0, 0, 0) };
+            return Ok(());
+        } else {
+            return Err(CommandError::WrongArgumentCount(args.len()));
+        }
+    }
+
+    fn shell_cmd_free(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 1 && args.get(0).unwrap() != "-m" {
+            return Err(CommandError::InvalidArgument(
+                args.get(0).unwrap().to_string(),
+            ));
+        }
+
+        struct mstat_t {
+            total: u64,      // 计算机的总内存数量大小
+            used: u64,       // 已使用的内存大小
+            free: u64,       // 空闲物理页所占的内存大小
+            shared: u64,     // 共享的内存大小
+            cache_used: u64, // 位于slab缓冲区中的已使用的内存大小
+            cache_free: u64, // 位于slab缓冲区中的空闲的内存大小
+            available: u64,  // 系统总空闲内存大小（包括kmalloc缓冲区）
+        };
+
+        let mut mst = mstat_t {
+            total: 0,
+            used: 0,
+            free: 0,
+            shared: 0,
+            cache_used: 0,
+            cache_free: 0,
+            available: 0,
+        };
+
+        let mut info_file = File::open("/proc/meminfo").unwrap();
+        let mut buf: Vec<u8> = Vec::new();
+        info_file.read_to_end(&mut buf).unwrap();
+        let str = String::from_utf8(buf).unwrap();
+        let info = str
+            .split(&['\n', '\t', ' '])
+            .filter_map(|str| str.parse::<u64>().ok())
+            .collect::<Vec<u64>>();
+        mst.total = *info.get(0).unwrap();
+        mst.free = *info.get(1).unwrap();
+        mst.used = mst.total - mst.free;
+
+        print!("\ttotal\tused\tfree\tshared\tcache\tavailable\n");
+        print!("Mem:\t");
+
+        if args.len() == 0 {
+            print!(
+                "{}\t{}\t{}\t{}\t{}\t{}\t\n",
+                mst.total, mst.used, mst.free, mst.shared, mst.cache_used, mst.available
+            );
+        } else {
+            print!(
+                "{}\t{}\t{}\t{}\t{}\t{}\t\n",
+                mst.total >> 10,
+                mst.used >> 10,
+                mst.free >> 10,
+                mst.shared >> 10,
+                mst.cache_used >> 10,
+                mst.available >> 10
+            );
+        }
+        Ok(())
+    }
+
+    fn shell_cmd_kill(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 1 {
+            let pid: i32;
+            match args.get(0).unwrap().parse::<i32>() {
+                Ok(x) => pid = x,
+                Err(_) => {
+                    return Err(CommandError::InvalidArgument(
+                        args.get(0).unwrap().to_string(),
+                    ))
+                }
+            }
+            unsafe {
+                libc::kill(pid, libc::SIGKILL);
+            }
+            return Ok(());
+        } else {
+            return Err(CommandError::WrongArgumentCount(args.len()));
+        }
+    }
+
+    fn shell_cmd_help(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 0 {
+            for BuildInCmd(cmd) in BuildInCmd::BUILD_IN_CMD {
+                Help::shell_help(cmd)
+            }
+            return Ok(());
+        }
+        return Err(CommandError::WrongArgumentCount(args.len()));
+    }
+
+    fn shell_cmd_export(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 1 {
+            let pair = args.get(0).unwrap().split('=').collect::<Vec<&str>>();
+
+            if pair.len() == 2 && !pair.contains(&"") {
+                let name = pair.get(0).unwrap().to_string();
+                let value = pair.get(1).unwrap().to_string();
+                Env::insert(name, value);
+                return Ok(());
+            } else {
+                return Err(CommandError::InvalidArgument(args.get(0).unwrap().clone()));
+            }
+        }
+        return Err(CommandError::WrongArgumentCount(args.len()));
+    }
+
+    fn shell_cmd_env(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        if args.len() == 0 {
+            let mut file = File::open("/etc/profile").unwrap();
+            let mut buf: Vec<u8> = Vec::new();
+            file.read_to_end(&mut buf).unwrap();
+            println!("{}", String::from_utf8(buf).unwrap());
+            return Ok(());
+        } else {
+            return Err(CommandError::InvalidArgument(args.get(0).unwrap().clone()));
+        }
+    }
+
+    fn shell_cmd_compgen(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        Ok(())
+    }
+
+    fn shell_cmd_complete(&self, args: &Vec<String>) -> Result<(), CommandError> {
+        Ok(())
+    }
+
+    fn to_absolute_path(&self, path: &String) -> String {
+        let mut fmt_path = Self::path_format(path);
+        if !path.starts_with('/') {
+            if self.current_dir() == "/" {
+                fmt_path = format!("/{}", fmt_path);
+            } else {
+                fmt_path = format!("{}/{}", self.current_dir(), fmt_path);
+            }
+        }
+        if fmt_path.ends_with('/') {
+            fmt_path.pop().unwrap();
+        }
+
+        let re = regex::Regex::new(r"\/\.\/").unwrap();
+        let replacement = |_caps: &regex::Captures| -> String { String::from("/") };
+        fmt_path = re.replace_all(fmt_path.as_str(), replacement).to_string();
+
+        let re = regex::Regex::new(r"\/[^\/]+\/\.\.").unwrap();
+        let replacement = |_caps: &regex::Captures| -> String { String::from("/") };
+        fmt_path = re.replace_all(fmt_path.as_str(), replacement).to_string();
+        fmt_path = Self::path_format(&fmt_path);
+        return fmt_path;
+    }
+
+    fn path_format(path: &String) -> String {
+        let re = regex::Regex::new(r"\/{2,}").unwrap();
+        let replacement = |_caps: &regex::Captures| -> String { String::from("/") };
+        let fmt_path = re.replace_all(path, replacement).to_string();
+        return fmt_path;
+    }
+}

src/shell/mod.rs

@@ -0,0 +1,360 @@
+use libc::syscall;
+use std::{
+    fs::{self, File, OpenOptions},
+    io::{self, BufRead, BufReader, Read, Write},
+    print,
+    string::String,
+    vec::Vec,
+};
+
+use crate::{special_keycode::*, Env};
+
+use command::{BuildInCmd, Command};
+
+pub mod command;
+
+pub struct Shell {
+    history_commands: Vec<Vec<u8>>,
+    executed_commands: Vec<Vec<u8>>,
+    current_dir: String,
+}
+
+impl Shell {
+    pub fn new() -> Shell {
+        let mut shell = Shell {
+            history_commands: Vec::new(),
+            executed_commands: Vec::new(),
+            current_dir: String::from("/"),
+        };
+        shell.read_commands();
+        shell
+    }
+
+    pub fn current_dir(&self) -> String {
+        self.current_dir.clone()
+    }
+
+    pub fn set_current_dir(&mut self, new_dir: String) {
+        self.current_dir = new_dir;
+        Env::insert(String::from("PWD"), self.current_dir());
+    }
+
+    pub fn exec(&mut self) {
+        let mut buf: Vec<u8>;
+        loop {
+            buf = Vec::new();
+            buf.push(b' ');
+            self.history_commands.push(buf);
+            Printer::print_prompt(&self.current_dir);
+            if self.readline(0) == 0 {
+                Printer::print(&[CR, LF]);
+                break;
+            }
+            let command_bytes = self.history_commands.last().unwrap().clone();
+            self.exec_command_in_bytes(&command_bytes);
+        }
+        self.write_commands();
+    }
+
+    fn exec_command_in_bytes(&mut self, command_bytes: &Vec<u8>) {
+        let commands = Command::from_strings(String::from_utf8(command_bytes.clone()).unwrap());
+        commands
+            .iter()
+            .for_each(|command| self.exec_command(command));
+    }
+
+    fn read_commands(&mut self) {
+        for line in BufReader::new(match File::open("history_commands.txt") {
+            Ok(file) => file,
+            Err(_) => File::create("history_commands.txt").unwrap(),
+        })
+        .lines()
+        {
+            match line {
+                Ok(s) => self.history_commands.push(s.into_bytes()),
+                Err(_) => {
+                    break;
+                }
+            }
+        }
+    }
+
+    fn write_commands(&self) {
+        let mut file = OpenOptions::new()
+            .append(true)
+            .open("history_commands.txt")
+            .unwrap();
+        for command_line in &self.executed_commands {
+            file.write_all(&command_line[..]).unwrap();
+            file.write_all(&[LF]).unwrap();
+        }
+    }
+
+    fn readline(&mut self, fd: usize) -> usize {
+        let mut stdin = std::io::stdin();
+        let mut stdout = std::io::stdout();
+        let prompt: String = self.current_dir.clone();
+        let history_commands = &mut self.history_commands;
+        let len = history_commands.len() - 1;
+        let mut key: [u8; 1] = [0];
+        let mut command_index = len;
+        let mut buf = history_commands.get_mut(command_index).unwrap();
+        let mut cursor = 0;
+
+        Printer::print_cursor(b' ');
+        stdout.flush().unwrap();
+        loop {
+            let mut c: libc::c_uchar = 0;
+            unsafe {
+                let p = &mut c as *mut libc::c_uchar as *mut libc::c_void;
+                libc::read(0, p, 1);
+                key[0] = c;
+            }
+            // if stdin.read(&mut key).ok() != Some(1) {
+            //     continue;
+            // }
+            if key[0] == 224 {
+                stdin.read(&mut key).unwrap();
+                if key[0] == b'\x1b' {
+                    panic!();
+                }
+                if key[0] == UP || key[0] == DOWN {
+                    Printer::delete_from_index(0, buf.len());
+
+                    match key[0] {
+                        UP => {
+                            if command_index > 0 {
+                                command_index -= 1;
+                            }
+                        }
+
+                        DOWN => {
+                            if command_index < len {
+                                command_index += 1;
+                            }
+                        }
+
+                        _ => {}
+                    }
+                    buf = history_commands.get_mut(command_index).unwrap();
+                    Printer::print(&buf[..buf.len() - 1]);
+                    cursor = buf.len() - 1;
+                    Printer::print_cursor(b' ');
+                }
+
+                if key[0] == LEFT || key[0] == RIGHT {
+                    match key[0] {
+                        LEFT => {
+                            if cursor > 0 {
+                                Printer::set_cursor(buf, cursor, cursor - 1);
+                                cursor -= 1;
+                            }
+                        }
+
+                        RIGHT => {
+                            if cursor < buf.len() - 1 {
+                                Printer::set_cursor(buf, cursor, cursor + 1);
+                                cursor += 1;
+                            }
+                        }
+
+                        _ => {}
+                    }
+                }
+            } else {
+                if key[0] == TAB && buf.len() > 1 && buf[cursor - 1] != b' ' {
+                    let command: String = String::from_utf8(buf[..cursor].to_vec()).unwrap();
+                    let mut command_frag = command.split_ascii_whitespace().collect::<Vec<_>>();
+                    let incomplete_frag = command_frag.pop().unwrap();
+                    let mut incomplete_len: usize = incomplete_frag.len();
+                    let candidates = match command_frag.len() {
+                        0 => Printer::complete_command(incomplete_frag),
+                        1.. => {
+                            if let Some(index) = incomplete_frag.rfind('/') {
+                                incomplete_len = incomplete_frag.len() - index - 1;
+                            } else {
+                                incomplete_len = incomplete_frag.len();
+                            }
+                            Printer::complete_path(incomplete_frag)
+                        }
+                        _ => Vec::new(),
+                    };
+                    match candidates.len() {
+                        1 => {
+                            let complete_part = candidates[0][incomplete_len..].as_bytes();
+
+                            Printer::delete_from_index(cursor, buf.len());
+
+                            // stdout.write_all(complete_part).unwrap();
+                            Printer::print(complete_part);
+
+                            Printer::print_cursor(buf[cursor]);
+                            Printer::print(&buf[cursor + 1..]);
+
+                            buf.splice(cursor..cursor, complete_part.iter().cloned());
+                            cursor += candidates[0].len() - incomplete_len;
+                        }
+                        2.. => {
+                            Printer::delete_from_index(cursor, buf.len());
+                            Printer::print(&buf[cursor..buf.len()]);
+                            Printer::print(&[CR, LF]);
+                            for candidate in candidates {
+                                print!("{candidate}    ");
+                            }
+                            Printer::print(&[CR, LF]);
+                            Printer::print_prompt(&prompt);
+                            Printer::print(&buf[..buf.len() - 1]);
+                            Printer::print_cursor(b' ');
+                        }
+                        _ => {}
+                    }
+                }
+
+                match key[0] {
+                    CR | LF => {
+                        if cursor > 0 {
+                            Printer::set_cursor(buf, cursor, buf.len());
+                            Printer::print(&[CR, LF]);
+                            let mut command = buf.clone();
+                            buf = history_commands.get_mut(len).unwrap();
+                            buf.clear();
+                            buf.append(&mut command);
+
+                            return 1;
+                        }
+                    }
+                    BS | DL => {
+                        if cursor > 0 {
+                            Printer::delete_from_index(cursor, buf.len());
+                            cursor -= 1;
+                            buf.remove(cursor);
+                            // stdout.write_all(&[BS]).unwrap();
+                            Printer::print(&[BS]);
+                            Printer::print_cursor(buf[cursor]);
+                            Printer::print(&buf[cursor + 1..]);
+                        }
+                    }
+                    1..=31 => {}
+                    c => {
+                        Printer::delete_from_index(cursor, buf.len());
+                        Printer::print(&[c]);
+                        buf.insert(cursor, c);
+                        cursor += 1;
+                        Printer::print_cursor(buf[cursor]);
+                        Printer::print(&buf[cursor + 1..]);
+                    }
+                }
+            }
+            stdout.flush().unwrap();
+        }
+    }
+}
+
+struct Printer;
+
+impl Printer {
+    fn print_prompt(current_dir: &String) {
+        io::stdout().flush().unwrap();
+        unsafe {
+            syscall(100000, "[DragonOS]:\0".as_ptr(), 0x0000ff90, 0x00000000);
+
+            syscall(
+                100000,
+                format!("{}\0", current_dir).as_ptr(),
+                0x000088ff,
+                0x00000000,
+            );
+            print!("$ ");
+        }
+    }
+
+    fn print_cursor(c: u8) {
+        Self::print_color(&[c], 0x00000000, 0x00ffffff);
+    }
+
+    fn delete_from_index(index: usize, length: usize) {
+        for _i in 0..length - index {
+            Printer::print(&[BS, SPACE, BS]);
+        }
+    }
+
+    fn print(bytes: &[u8]) {
+        print!("{}", String::from_utf8(bytes.to_vec()).unwrap());
+    }
+
+    fn print_color(bytes: &[u8], front_color: usize, background_color: usize) {
+        std::io::stdout().flush().unwrap();
+        let cstr = std::ffi::CString::new(bytes).unwrap();
+        unsafe {
+            dsc::syscall!(SYS_PUT_STRING, cstr.as_ptr(), front_color, background_color);
+        }
+    }
+
+    fn set_cursor(buf: &mut Vec<u8>, old_index: usize, new_index: usize) {
+        if new_index < buf.len() {
+            let index = std::cmp::min(old_index, new_index);
+            Printer::delete_from_index(index, buf.len());
+            Printer::print(&buf[index..new_index]);
+            Printer::print_cursor(buf[new_index]);
+            Printer::print(&buf[new_index + 1..]);
+        } else {
+            Printer::delete_from_index(old_index, buf.len());
+            Printer::print(&buf[old_index..]);
+        }
+    }
+
+    fn complete_command(command: &str) -> Vec<String> {
+        let mut candidates: Vec<String> = Vec::new();
+        for BuildInCmd(cmd) in BuildInCmd::BUILD_IN_CMD {
+            if cmd.starts_with(command) {
+                candidates.push(String::from(*cmd));
+            }
+        }
+        candidates
+    }
+
+    fn complete_path(path: &str) -> Vec<String> {
+        let mut candidates: Vec<String> = Vec::new();
+        let dir: &str;
+        let incomplete_name: &str;
+        if let Some(index) = path.rfind('/') {
+            dir = &path[..=index];
+            if index < path.len() {
+                incomplete_name = &path[index + 1..];
+            } else {
+                incomplete_name = "";
+            }
+        } else {
+            dir = ".";
+            incomplete_name = &path[..];
+        }
+        match fs::read_dir(dir) {
+            Ok(read_dir) => {
+                if incomplete_name == "" {
+                    for entry in read_dir {
+                        let entry = entry.unwrap();
+                        let mut file_name = entry.file_name().into_string().unwrap();
+                        if entry.file_type().unwrap().is_dir() {
+                            file_name.push('/');
+                        }
+                        candidates.push(file_name);
+                    }
+                } else {
+                    for entry in read_dir {
+                        let entry = entry.unwrap();
+                        let mut file_name = entry.file_name().into_string().unwrap();
+                        if file_name.starts_with(incomplete_name) {
+                            if entry.file_type().unwrap().is_dir() {
+                                file_name.push('/');
+                            }
+                            candidates.push(file_name);
+                        }
+                    }
+                }
+            }
+
+            Err(_) => {}
+        }
+        return candidates;
+    }
+}

x86_64-unknown-dragonos.json

@@ -0,0 +1,35 @@
+{
+    "arch": "x86_64",
+    "code-model": "kernel",
+    "cpu": "x86-64",
+    "os": "dragonos",
+    "target-endian": "little",
+    "target-pointer-width": "64",
+    "target-family": [
+        "unix"
+    ],
+    "env": "musl",
+    "target-c-int-width": "32",
+    "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128",
+    "disable-redzone": true,
+    "features": "-3dnow,-3dnowa,-avx,-avx2",
+    "linker": "rust-lld",
+    "linker-flavor": "ld.lld",
+    "llvm-target": "x86_64-unknown-none",
+    "max-atomic-width": 64,
+    "panic-strategy": "abort",
+    "position-independent-executables": true,
+    "relro-level": "full",
+    "stack-probes": {
+        "kind": "inline-or-call",
+        "min-llvm-version-for-inline": [
+            16,
+            0,
+            0
+        ]
+    },
+    "static-position-independent-executables": true,
+    "supported-sanitizers": [
+        "kcfi"
+    ]
+}