Start working on libc

Author: chronium

.gitignore

@@ -16,3 +16,5 @@ virtio-net.pcap
 /userland/tmp
 
 **/*.log
+**/target/**
+**/sysroot/**

.gitmodules

@@ -2,3 +2,6 @@
 	path = extern/limine
 	url = https://github.com/limine-bootloader/limine.git
 	branch = v2.0-branch
+[submodule "userland/libc/core_io"]
+	path = userland/libc/core_io
+	url = https://gitlab.redox-os.org/redox-os/core_io.git

Justfile

@@ -41,6 +41,17 @@ build init release:
     just build {{init}} circinus
     popd
 
+    just build_kern {{init}} {{release}}
+
+build_kern init release:
+    #!/usr/bin/env bash
+    set -e
+    export INIT_FILE={{init}}
+    if { [ release != "debug" ] && [ release != "release" ] ;} then \
+        echo Unknown build mode \"{{release}}\";\
+        exit 1; \
+    fi;
+
     cargo -Z build-std=core,alloc -Z build-std-features=compiler-builtins-mem build --target kernel/arch/x64/x64.json {{ if release == "debug" { "" } else { "--release" } }}
     cp target/{{target}}/{{release}}/kernel build/kernel.elf
 
@@ -106,3 +117,6 @@ run_gdb init="init" release="debug": (build init release) (image img)
 
 kvm init="init" release="debug": (build init release) (image img)
     sudo qemu-system-{{qemutarget}} -enable-kvm -cpu host {{qemu-args}}
+
+run_file file release="debug": (build_kern file release) (image img)
+  qemu-system-{{qemutarget}} -cpu Haswell {{qemu-args}}

environment/address.rs

@@ -75,8 +75,7 @@ impl VAddr {
 	}
 
 	pub const fn is_accessible_from_kernel(addr: usize) -> bool {
-		(addr) >= KERNEL_BASE_ADDR
-			&& (addr) < KERNEL_BASE_ADDR + KERNEL_STRAIGHT_MAP_PADDR_END
+		(addr) >= KERNEL_BASE_ADDR && (addr) < KERNEL_BASE_ADDR + KERNEL_STRAIGHT_MAP_PADDR_END
 	}
 
 	pub const fn as_ptr<T>(self) -> *const T {
@@ -140,8 +139,7 @@ impl fmt::Display for VAddr {
 
 extern "C" {
 	fn copy_from_user(dst: *mut u8, src: *const u8, len: usize);
-	fn strncpy_from_user(dst: *mut u8, src: *const u8, max_len: usize)
-		-> usize;
+	fn strncpy_from_user(dst: *mut u8, src: *const u8, max_len: usize) -> usize;
 	fn copy_to_user(dst: *mut u8, src: *const u8, len: usize);
 	fn memset_user(dst: *mut u8, value: u8, len: usize);
 }
@@ -177,9 +175,7 @@ impl UserVAddr {
 		}
 	}
 
-	pub const fn new_nonnull(
-		addr: usize,
-	) -> Result<Self, NullUserPointerError> {
+	pub const fn new_nonnull(addr: usize) -> Result<Self, NullUserPointerError> {
 		match Self::new(addr) {
 			Some(uaddr) => Ok(uaddr),
 			None => Err(NullUserPointerError),
@@ -227,10 +223,7 @@ impl UserVAddr {
 	pub fn read<T>(self) -> Result<T, AccessError> {
 		let mut buf: MaybeUninit<T> = MaybeUninit::uninit();
 		self.read_bytes(unsafe {
-			slice::from_raw_parts_mut(
-				buf.as_mut_ptr() as *mut u8,
-				size_of::<T>(),
-			)
+			slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut u8, size_of::<T>())
 		})?;
 		Ok(unsafe { buf.assume_init() })
 	}
@@ -239,11 +232,7 @@ impl UserVAddr {
 		call_usercopy_hook();
 		self.access_ok(buf.len())?;
 		unsafe {
-			copy_from_user(
-				buf.as_mut_ptr(),
-				self.value() as *const u8,
-				buf.len(),
-			);
+			copy_from_user(buf.as_mut_ptr(), self.value() as *const u8, buf.len());
 		}
 		Ok(())
 	}
@@ -255,21 +244,14 @@ impl UserVAddr {
 	pub fn read_cstr(self, buf: &mut [u8]) -> Result<usize, AccessError> {
 		call_usercopy_hook();
 		self.access_ok(buf.len())?;
-		let read_len = unsafe {
-			strncpy_from_user(
-				buf.as_mut_ptr(),
-				self.value() as *const u8,
-				buf.len(),
-			)
-		};
+		let read_len =
+			unsafe { strncpy_from_user(buf.as_mut_ptr(), self.value() as *const u8, buf.len()) };
 		Ok(read_len)
 	}
 
 	pub fn write<T>(self, buf: &T) -> Result<usize, AccessError> {
 		let len = size_of::<T>();
-		self.write_bytes(unsafe {
-			slice::from_raw_parts(buf as *const T as *const u8, len)
-		})?;
+		self.write_bytes(unsafe { slice::from_raw_parts(buf as *const T as *const u8, len) })?;
 		Ok(len)
 	}
 

extensions/api/kernel.rs

@@ -23,12 +23,7 @@ static OPS: StaticCell<&dyn KernelOps> = StaticCell::new(&NopOps);
 struct NopOps;
 
 impl KernelOps for NopOps {
-	fn attach_irq(
-		&self,
-		_irq: u8,
-		_f: Box<dyn FnMut() + Send + Sync + 'static>,
-	) {
-	}
+	fn attach_irq(&self, _irq: u8, _f: Box<dyn FnMut() + Send + Sync + 'static>) {}
 
 	fn register_block_driver(&self, _driver: Box<dyn BlockDriver>) {}
 

extensions/api/lib.rs

@@ -1,4 +1,5 @@
 #![no_std]
+#![allow(non_camel_case_types)]
 #![feature(box_syntax)]
 
 extern crate log;
@@ -13,7 +14,7 @@ use ctypes::c_int;
 use environment::spinlock::SpinLock;
 use kernel::kernel_ops;
 use process::{Pid, ProcessState};
-use vfs::mount::Rootfs;
+use vfs::{mount::Rootfs, opened_file::OpenedFileTable};
 
 pub use environment::{debug_warn, print, println, warn_if_err, warn_once};
 pub use log::{debug, error, info, trace, warn};
@@ -29,9 +30,7 @@ pub mod arch {
 }
 
 pub mod mm {
-	pub use environment::page_allocator::{
-		alloc_pages, AllocPageFlags, PageAllocError,
-	};
+	pub use environment::page_allocator::{alloc_pages, AllocPageFlags, PageAllocError};
 }
 
 pub mod sync {
@@ -71,9 +70,11 @@ impl Process {
 		proc!(kernel_ops()).exit(status)
 	}
 
-	pub fn get_open_file_by_fid(
-		fd: vfs::Fd,
-	) -> result::Result<Arc<vfs::opened_file::OpenedFile>> {
+	pub fn opened_files() -> Arc<SpinLock<OpenedFileTable>> {
+		proc!(kernel_ops()).opened_files()
+	}
+
+	pub fn get_open_file_by_fid(fd: vfs::Fd) -> result::Result<Arc<vfs::opened_file::OpenedFile>> {
 		proc!(kernel_ops()).get_open_file_by_fid(fd)
 	}
 
@@ -96,20 +97,10 @@ impl Process {
 
 pub unsafe trait AsBuf: Sized {
 	fn as_buf(&self) -> &[u8] {
-		unsafe {
-			core::slice::from_raw_parts(
-				self as *const _ as _,
-				size_of::<Self>(),
-			)
-		}
+		unsafe { core::slice::from_raw_parts(self as *const _ as _, size_of::<Self>()) }
 	}
 	fn as_buf_mut(&mut self) -> &mut [u8] {
-		unsafe {
-			core::slice::from_raw_parts_mut(
-				self as *mut _ as _,
-				size_of::<Self>(),
-			)
-		}
+		unsafe { core::slice::from_raw_parts_mut(self as *mut _ as _, size_of::<Self>()) }
 	}
 }
 
@@ -272,6 +263,7 @@ pub mod posix;
 pub mod process;
 pub mod result;
 pub mod schema;
+#[macro_use]
 pub mod user_buffer;
 pub mod uuid;
 pub mod vfs;

extensions/api/posix/mod.rs

@@ -1,3 +1,21 @@
+use crate::{vfs, ctypes::c_int};
+
 #[derive(Debug)]
 #[repr(transparent)]
 pub struct Timestamp(pub u32);
+
+pub enum CwdOrFd {
+    /// `AT_FDCWD`
+    AtCwd,
+    Fd(vfs::Fd),
+}
+
+impl CwdOrFd {
+    pub fn parse(value: c_int) -> CwdOrFd {
+        match value {
+            -100 => CwdOrFd::AtCwd,
+            _ => CwdOrFd::Fd(vfs::Fd::new(value)),
+        }
+    }
+}
+

extensions/api/process.rs

@@ -3,7 +3,7 @@ use environment::spinlock::SpinLock;
 
 use crate::{
 	ctypes::c_int,
-	vfs::{mount::Rootfs, opened_file::OpenedFile, Fd},
+	vfs::{mount::Rootfs, opened_file::{OpenedFile, OpenedFileTable}, Fd},
 	Result,
 };
 
@@ -34,6 +34,7 @@ impl Pid {
 pub trait ProcessOps {
 	fn rootfs(&self) -> &Arc<SpinLock<Rootfs>>;
 	fn exit(&self, status: c_int) -> !;
+	fn opened_files(&self) -> Arc<SpinLock<OpenedFileTable>>;
 	fn get_open_file_by_fid(&self, fd: Fd) -> Result<Arc<OpenedFile>>;
 	fn set_state(&self, new_state: ProcessState);
 	fn has_pending_signals(&self) -> bool;

extensions/api/result.rs

@@ -14,6 +14,8 @@ pub enum ErrorKind {
 	PageFault,
 	OutOfMemory,
 
+	NotSupported,
+
 	Invalid,
 
 	TooBig,
@@ -28,6 +30,8 @@ pub enum ErrorKind {
 	NoEntry,
 	Unsupported,
 
+	IsADirectory,
+
 	BadFile,
 
 	BufferError,

extensions/api/schema/posix.rs

@@ -61,6 +61,11 @@ pub const S_IFLNK: u32 = 0o120000;
 
 pub const O_ACCMODE: u32 = 0o3;
 
+#[allow(unused)]
+pub const O_RDONLY: u32 = 0o0;
+pub const O_WRONLY: u32 = 0o1;
+pub const O_RDWR: u32 = 0o2;
+
 #[derive(Debug, Copy, Clone)]
 #[repr(transparent)]
 pub struct FileMode(pub u32);

extensions/api/user_buffer.rs

@@ -7,6 +7,7 @@ use utils::alignment::align_up;
 use crate::{Error, ErrorKind, Result};
 
 /// Parses a bitflags field given from the user. Returns `Result<T>`.
+#[macro_export]
 macro_rules! bitflags_from_user {
 	($st:tt, $input:expr) => {{
 		let bits = $input;
@@ -16,7 +17,7 @@ macro_rules! bitflags_from_user {
 				bits
 			);
 
-			crate::Error::new(crate::result::Errno::ENOSYS)
+			api::result::Error::new(api::result::ErrorKind::NoSyscall)
 		})
 	}};
 }

extensions/api/vfs/mod.rs

@@ -1,12 +1,9 @@
-use alloc::sync::Arc;
+use alloc::{string::String, sync::Arc};
 
 use crate::{
 	ctypes::c_int,
 	io,
-	schema::{
-		posix::{DevId, FileMode, FileSize, INodeNo},
-		unix::PathBuf,
-	},
+	schema::posix::{FileMode, FileSize, INodeNo},
 	user_buffer::{UserBuffer, UserBufferMut},
 	ErrorKind, Result,
 };
@@ -60,32 +57,33 @@ pub trait Filesystem: Send + Sync {
 
 #[derive(Debug)]
 pub struct DirEntry {
-	pub path: PathBuf,
-	pub ftype: FileType,
+	pub node_id: NodeId,
+	pub file_type: FileType,
+	pub name: String,
 }
 
 pub trait Directory: Send + Sync + core::fmt::Debug {
 	fn _lookup(&self, name: &str) -> Result<Node>;
 
-	fn read_dir(&self, index: usize) -> Option<DirEntry>;
+	fn read_dir(&self, index: usize) -> Result<Option<DirEntry>>;
 
 	fn stat(&self) -> Result<Stat>;
 }
 
-pub struct ReadDir<'a> {
-	pub directory: Arc<&'a dyn Directory>,
-	pub current: usize,
-}
+// pub struct ReadDir<'a> {
+// 	pub directory: Arc<&'a dyn Directory>,
+// 	pub current: usize,
+// }
 
-impl Iterator for ReadDir<'_> {
-	type Item = DirEntry;
+// impl Iterator for ReadDir<'_> {
+// 	type Item = DirEntry;
 
-	fn next(&mut self) -> Option<Self::Item> {
-		let res = self.directory.read_dir(self.current);
-		self.current += 1;
-		res
-	}
-}
+// 	fn next(&mut self) -> Result<Self::Item> {
+// 		let res = self.directory.read_dir(self.current);
+// 		self.current += 1;
+// 		res
+// 	}
+// }
 
 pub trait File: Send + Sync + core::fmt::Debug {
 	fn open(&self, options: &io::OpenOptions) -> Result<Option<Arc<dyn File>>>;
@@ -173,20 +171,23 @@ pub enum FileKind {
 	RegularFile,
 	Directory,
 	CharDevice,
+	BlockDevice,
 }
 
 pub const S_IFMT: u32 = 0o170000;
 pub const S_IFCHR: u32 = 0o020000;
 pub const S_IFDIR: u32 = 0o040000;
 pub const S_IFREG: u32 = 0o100000;
 pub const S_IFLNK: u32 = 0o120000;
+pub const S_IFBLK: u32 = 0o060000;
 
 impl From<FileKind> for u32 {
 	fn from(mode: FileKind) -> Self {
 		match mode {
 			FileKind::RegularFile => S_IFREG,
 			FileKind::Directory => S_IFDIR,
 			FileKind::CharDevice => S_IFCHR,
+			FileKind::BlockDevice => S_IFBLK,
 		}
 	}
 }