.gitignore

 target
+/config.toml
+.gitlab-ci-local/

.gitlab-ci.yml

+image: "redoxos/redoxer:latest"
+
+variables:
+  GIT_SUBMODULE_STRATEGY: recursive
+
+stages:
+  - host
+  - build
+  - test
+  # TODO: benchmarks and profiling (maybe manually enabled for relevant MRs)?
+
+build:
+  stage: build
+  script:
+    - mkdir -p target/${ARCH}
+    - TARGET=${ARCH}-unknown-redox redoxer env make BUILD=target/${ARCH}
+  parallel:
+    matrix:
+      - ARCH: [x86_64, i686, aarch64, riscv64gc]
+
+fmt:
+  stage: host
+  script:
+      - rustup component add rustfmt-preview
+      - cargo fmt -- --check
+
+unit_test:
+  stage: test
+  script:
+    - TARGET=x86_64-unknown-redox redoxer test

.gitmodules

-[submodule "syscall"]
-	path = syscall
-	url = https://github.com/redox-os/syscall.git
+[submodule "slab_allocator"]
+	path = slab_allocator
+	url = https://gitlab.redox-os.org/redox-os/slab_allocator
+[submodule "rmm"]
+	path = rmm
+	url = https://gitlab.redox-os.org/redox-os/rmm.git
+	branch = master
+[submodule "redox-path"]
+	path = redox-path
+	url = https://gitlab.redox-os.org/redox-os/redox-path.git
+	branch = main

.helix/config.toml

+[editor]
+auto-format = false

.helix/languages.toml

+[[language]]
+name = "rust"
+
+[[language-server.rust-analyzer.config.cargo]]
+extraEnv = ["RUST_TARGET_PATH=targets"]
+# Select one of targets to make lsp work for your confguration
+# Do not commit this change
+# TODO: find a better way to do this
+# target = "aarch64-unknown-kernel"
+
+[[language-server.rust-analyzer.config.check]]
+targets = ["x86_64-unknown-kernel", "i686-unknown-kernel", "aarch64-unknown-kernel"]
+

ARM-AARCH64-PORT-OUTLINE.md

+# Porting the core Redox kernel to arm AArch64: An outline
+
+## Intro
+
+This document is [my](https://github.com/raw-bin) attempt at:
+
+* Capturing thinking on the work needed for a core Redox kernel port
+* Sharing progress with the community as things evolve
+* Creating a template that can be used for ports to other architectures
+
+Core Redox kernel means everything needed to get to a non-graphical console-only multi-user shell.
+
+Only the 64-bit execution state (AArch64) with the 64-bit instruction set architecture (A64)  shall be supported for the moment. For more background/context read [this](https://developer.arm.com/products/architecture/a-profile/docs/den0024/latest/introduction).
+
+This document is intended to be kept *live*. It will be updated to reflect the current state of work and any feedback received.
+
+It is hard~futile to come up with a strict sequence of work for such ports but this document is a reasonable template to follow.
+
+## Intended target platform
+
+The primary focus is on [qemu's virt machine platform emulation for the AArch64 architecture](https://github.com/qemu/qemu/blob/master/hw/arm/virt.c#L127).
+
+Targeting a virtual platform is a convenient way to bring up the mechanics of architectural support and makes the jump to silicon easier. The preferred boot chain for AArch64 (explained later) is well supported on this platform and boot-over-tftp from localhost makes the debug cycle very efficient.
+
+Once the core kernel port is complete a similar follow on document will be created that is dedicated to silicon bring-up.
+
+## Boot protocol elements
+
+Item | Notes
+-----|-------
+[Linux kernel boot protocol for AArch64](https://www.kernel.org/doc/Documentation/arm64/booting.txt) | The linked document describes assumptions made from the bootloader which are field tested and worthwhile to have for Redox an AArch64. <br/> The intent is to consider most of the document except anything tied to the Linux kernel itself.
+[Flattened Device Tree](https://elinux.org/Device_Tree_Reference) | FDT binary blobs supplied by the bootloader shall provide the Redox kernel with misc platform \{memory, interrupt, devicemem} maps. Qemu's virt machine platform synthetically creates an FDT blob at a specific address which is very handy.
+
+## Boot flow elements
+
+The following table lists the boot flow in order.
+
+Item | Notes
+-----|-------
+[ARM Trusted Firmware (TF-A)](https://github.com/ARM-software/arm-trusted-firmware) | TF-A is a de-facto standard reference firmware implementation and proven in the field. <br/> TF-A runs post power-on on Armv8-A implementations and eventually hands off to further stages of the boot flow.<br />For qemu's virt machine platform, it is essentially absent but I mean to rely on it heavily for silicon bring up hence mentioning it here. 
+[u-boot](https://www.denx.de/wiki/U-Boot) | u-boot will handle early console access, media access for fetching redox kernel images from non-volatile storage/misc disk subsystems/off the network. <br /> u-boot supports loading EFI applications. If EFI support to AArch64 Redox is added in the future that should essentially work out of the box. <br /> u-boot will load redox and FDT binary blobs into RAM and jump to the redox kernel.
+Redox early-init stub | For AArch64, the redox kernel will contain an A64 assembly stub that will setup the MMU from scratch. This is akin to the [x86_64 redox bootloader](https://github.com/redox-os/bootloader/blob/master/x86_64/startup-x86_64.asm). <br /> This stub sets up identity maps for MMU initialization, maps the kernel image itself as well as the device memory for the UART console. At present this stub shall be a part of the kernel itself for simplicity.
+Redox kstart entry | The early init stub hands off here. kstart will then re-init the MMU more comprehensively.
+
+## Supported devices
+
+The following devices shall be supported. All necessary information specific to these devices will be provided to the redox kernel by the platform specific FDT binary blob.
+
+Device | Notes
+-------|-------
+[Generic Interrupt Controller v2](https://developer.arm.com/products/architecture/a-profile/docs/ihi0048/b/arm-generic-interrupt-controller-architecture-version-20-architecture-specification) | The GIC is an Arm-v8A architectural element and is supported by all architecturally compliant processor implementations. GICv2 is supported by qemu's virt machine emulation and most subsequent GIC implementations are backward compatible to GICv2.
+[Generic Timer](http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0500d/BGBBIJCB.html) | The Generic Timer Architecture is an Arm-v8A architectural element and is implemented by all compliant processor implementations. It is supported by qemu.
+[PrimeCell UART PL011](http://infocenter.arm.com/help/topic/com.arm.doc.ddi0183f/DDI0183.pdf) | The PL011 UART is supported by qemu and most ARM systems.
+
+## Intended development sequence and status
+
+Item | Description | Status | Notes
+-----|-------|-----|-----
+Redox AArch64 toolchain | Create an usable redox AArch64 toolchain specification | Done | Using this JSON spec in isolated tests produces valid AArch64 soft float code
+Stubbed kernel image | Stub out AArch64 kernel support using the existing x86_64 arch code as a template <br /> Modify redox kernel build glue and work iteratively to get a linkable (non-functional) image |  Not done yet |
+Boot flow | Create a self hosted u-boot -> redox kernel workflow <br /> Should obtain the stubbed image from a local TFTP server, load it into RAM and jump to it  | Not done yet |
+GDB Debug flow | Create a debug workflow centered around qemu's GDB stub <br /> This should allow connecting to qemu's GDB stub and debug u-boot/redox stub via a GDB client and single stepping through code | Not done yet |
+Verify Redox entry | Verify that control reaches the redox kernel from u-boot | Not done yet |
+AArch64 early init stub | Add support for raw asm code for early AArch64 init in the redox kernel <br /> Verify that this code is located appropriately in the link map and that control reaches this code from u-boot | Not done yet |
+Basic DTB support | Integrate the [device_tree crate](https://mbr.github.io/device_tree-rs/device_tree/) <br /> Use the crate to access the qemu supplied DTB image and extract the memory map | Not done yet |
+Basic UART support | Use the device_tree crate to get the UART address from the DTB image and set up the initial console <br /> This is a polling mode only setup | Not done yet |
+Initial MMU support | Implement initial MMU support in the early init stub <br /> This forces the MMU into a clean state overriding any bootloader specific setup <br /> Create an identity map for MMU init <br /> Create a mapping for the kernel image <br /> Create a mapping for any devices needed at this stage (UART)| Not done yet |
+kmain entry | Verify that kmain entry works post early MMU init | Not done yet |
+Basic Redox MMU support | Get Redox to create a final set of mappings for everything <br /> Verify that this works as expected| Not done yet |
+Basic libc support | Flesh out a basic set of libc calls as required for simple user-land apps | Not done yet |
+userspace_init entry | Verify user-space entry and /sbin/init invocation | Not done yet |
+Basic Interrupt controller support | Add a GIC driver <br /> Verify functionality | Not done yet |
+Basic Timer support | Add a Generic Timer driver <br /> Verify functionality | Not done yet |
+UART interrupt support | Add support for UART interrupts | Not done yet |
+Task context switch support | Add context switching support <br /> Verify functionality | Not done yet |
+Login shell | Iteratively add and verify multi-user login shell support | Not done yet |
+Publish development branch on github | Work with the community to post work done after employer approval | Not done yet |
+Break out the Bubbly | Drink copious quantities of alcohol to celebrate | Not done yet |
+Silicon bring-up | Plan silicon bring-up | Not done yet |

Cargo.toml

 [package]
 name = "kernel"
-version = "0.1.33"
+version = "0.4.1"
 build = "build.rs"
+edition = "2021"
 
-[lib]
-name = "kernel"
-path = "src/lib.rs"
-crate-type = ["staticlib"]
+[build-dependencies]
+cc = "1.0"
+rustc-cfg = "0.5"
+toml = "0.8"
 
 [dependencies]
-alloc_kernel = { path = "alloc_kernel" }
-bitflags = "1"
-clippy = { version = "*", optional = true }
-spin = "0.4"
-raw-cpuid = "3.0"
-redox_syscall = { path = "syscall" }
+bitflags = "2"
+bitfield = "0.13.2"
+hashbrown = { version = "0.14.3", default-features = false, features = ["ahash", "inline-more"] }
+linked_list_allocator = "0.9.0"
+log = "0.4"
+redox-path = "0.2.0"
+redox_syscall = { git = "https://gitlab.redox-os.org/redox-os/syscall.git", branch = "master", default-features = false }
+slab_allocator = { path = "slab_allocator", optional = true }
+spin = "0.9.8"
+spinning_top = { version = "0.3", features = ["arc_lock"] }
+rmm = { path = "rmm", default-features = false }
+arrayvec = { version = "0.7.4", default-features = false }
+slab = { version = "0.4", default-features = false }
+# TODO: Remove
+indexmap = { version = "2.5.0", default-features = false }
 
 [dependencies.goblin]
-version = "0.0.10"
+version = "0.2.1"
 default-features = false
 features = ["elf32", "elf64"]
 
-[dependencies.x86]
-version = "0.7"
+[dependencies.rustc-demangle]
+version = "0.1.16"
 default-features = false
 
+[target.'cfg(any(target_arch = "aarch64", target_arch = "riscv64"))'.dependencies]
+byteorder = { version = "1", default-features = false }
+fdt = { git = "https://github.com/repnop/fdt.git", rev = "2fb1409edd1877c714a0aa36b6a7c5351004be54" }
+
+[target.'cfg(any(target_arch = "x86", target_arch = "x86_64"))'.dependencies]
+raw-cpuid = "10.2.0"
+x86 = { version = "0.47.0", default-features = false }
+
+[target.'cfg(any(target_arch = "riscv64", target_arch = "riscv32"))'.dependencies]
+sbi-rt = "0.0.3"
+
 [features]
-default = ["pti"]
-doc = []
-live = []
-multi_core = []
+default = [
+  "acpi",
+  #TODO: issues with Alder Lake and newer CPUs: "multi_core",
+  "graphical_debug",
+  "serial_debug",
+  "self_modifying",
+  "x86_kvm_pv",
+  "syscall_debug",
+]
+
+# Activates some limited code-overwriting optimizations, based on CPU features.
+self_modifying = []
+
+acpi = []
+graphical_debug = []
+lpss_debug = []
+multi_core = ["acpi"]
+profiling = []
+#TODO: remove when threading issues are fixed
 pti = []
+qemu_debug = []
+serial_debug = []
+system76_ec_debug = []
+slab = ["slab_allocator"]
+sys_stat = []
+x86_kvm_pv = []
+
+debugger = ["syscall_debug"]
+syscall_debug = []
+
+sys_fdstat = []
+
+[profile.dev]
+# Avoids having to define the eh_personality lang item and reduces kernel size
+panic = "abort"
+
+[profile.release]
+# Avoids having to define the eh_personality lang item and reduces kernel size
+panic = "abort"
+
+lto = true
+
+debug = "full"

Makefile

+SOURCE:=$(dir $(realpath $(lastword $(MAKEFILE_LIST))))
+BUILD?=$(CURDIR)
+export RUST_TARGET_PATH=$(SOURCE)/targets
+
+ifeq ($(TARGET),)
+	ARCH?=$(shell uname -m)
+else
+	ARCH?=$(shell echo "$(TARGET)" | cut -d - -f1)
+endif
+
+ifeq ($(ARCH),riscv64gc)
+	override ARCH:=riscv64
+endif
+GNU_TARGET=$(ARCH)-unknown-redox
+
+
+all: $(BUILD)/kernel $(BUILD)/kernel.sym
+
+LD_SCRIPT=$(SOURCE)/linkers/$(ARCH).ld
+TARGET_SPEC=$(RUST_TARGET_PATH)/$(ARCH)-unknown-kernel.json
+
+$(BUILD)/kernel.all: $(LD_SCRIPT) $(TARGET_SPEC) $(shell find $(SOURCE) -name "*.rs" -type f)
+	cargo rustc \
+		--bin kernel \
+		--manifest-path "$(SOURCE)/Cargo.toml" \
+		--target "$(TARGET_SPEC)" \
+		--release \
+		-Z build-std=core,alloc \
+		-- \
+		-C link-arg=-T -Clink-arg="$(LD_SCRIPT)" \
+		-C link-arg=-z -Clink-arg=max-page-size=0x1000 \
+		--emit link="$(BUILD)/kernel.all"
+
+$(BUILD)/kernel.sym: $(BUILD)/kernel.all
+	$(GNU_TARGET)-objcopy \
+		--only-keep-debug \
+		"$(BUILD)/kernel.all" \
+		"$(BUILD)/kernel.sym"
+
+$(BUILD)/kernel: $(BUILD)/kernel.all
+	$(GNU_TARGET)-objcopy \
+		--strip-debug \
+		"$(BUILD)/kernel.all" \
+		"$(BUILD)/kernel"

README.md

-# kernel
+# Kernel
 
 Redox OS Microkernel
 
+[![docs](https://img.shields.io/badge/docs-master-blue.svg)](https://docs.rs/redox_syscall/latest/syscall/)
+[![SLOCs counter](https://tokei.rs/b1/github/redox-os/kernel?category=code)](https://github.com/XAMPPRocky/tokei)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
-[![docs](https://img.shields.io/badge/docs-master-blue.svg)](https://doc.redox-os.org/kernel/kernel/)
-[![](https://tokei.rs/b1/github/redox-os/kernel?category=code)](https://github.com/Aaronepower/tokei)
 
-## Debugging the redox kernel
+## Requirements
 
-Running [qemu] with the `-s` flag will set up [qemu] to listen on port 1234 for
-a [gdb] client to connect to it. To debug the redox kernel run.
+* [`nasm`](https://nasm.us/) needs to be available on the PATH at build time.
 
+## Building The Documentation
+
+Use this command:
+
+```sh
+cargo doc --open --target x86_64-unknown-none
 ```
-make qemu debug=yes
+
+## Debugging
+
+### QEMU
+
+Running [QEMU](https://www.qemu.org) with the `-s` flag will set up QEMU to listen on port `1234` for a GDB client to connect to it. To debug the redox kernel run.
+
+```sh
+make qemu gdb=yes
 ```
 
-This will start a VM with and listen on port 1234 for a [gdb] client. Run the following
-to connect to it.
+This will start a virtual machine with and listen on port `1234` for a GDB or LLDB client.
+
+### GDB
+
+If you are going to use [GDB](https://www.gnu.org/software/gdb/), run these commands to load debug symbols and connect to your running kernel:
 
 ```
+(gdb) symbol-file build/kernel.sym
 (gdb) target remote localhost:1234
 ```
 
-This is great, but without debug info debugging can be quite difficult. The
-redox build process strips the kernel of debug info and copies the debug info
-to a separate file `kernel.sym`. You can import these symbols in [gdb] with
-the following
+### LLDB
+
+If you are going to use [LLDB](https://lldb.llvm.org/), run these commands to start debugging:
 
 ```
-(gdb) symbol-file build/kernel.sym
+(lldb) target create -s build/kernel.sym build/kernel
+(lldb) gdb-remote localhost:1234
 ```
 
-Now you can set some interesting breakpoints and `continue` the process.
+After connecting to your kernel you can set some interesting breakpoints and `continue`
+the process. See your debuggers man page for more information on useful commands to run.
+
+## Notes
+
+- Always use `foo.get(n)` instead of `foo[n]` and try to cover for the possibility of `Option::None`. Doing the regular way may work fine for applications, but never in the kernel. No possible panics should ever exist in kernel space, because then the whole OS would just stop working.
+
+- If you receive a kernel panic in QEMU, use `pkill qemu-system` to kill the frozen QEMU process.
+
+## How To Contribute
+
+To learn how to contribute to this system component you need to read the following document:
+
+- [CONTRIBUTING.md](https://gitlab.redox-os.org/redox-os/redox/-/blob/master/CONTRIBUTING.md)
+
+## Development
+
+To learn how to do development with this system component inside the Redox build system you need to read the [Build System](https://doc.redox-os.org/book/build-system-reference.html) and [Coding and Building](https://doc.redox-os.org/book/coding-and-building.html) pages.
+
+### How To Build
+
+To build this system component you need to download the Redox build system, you can learn how to do it on the [Building Redox](https://doc.redox-os.org/book/podman-build.html) page.
+
+This is necessary because they only work with cross-compilation to a Redox virtual machine, but you can do some testing from Linux.
+
+## Funding - _Unix-style Signals and Process Management_
+
+This project is funded through [NGI Zero Core](https://nlnet.nl/core), a fund established by [NLnet](https://nlnet.nl) with financial support from the European Commission's [Next Generation Internet](https://ngi.eu) program. Learn more at the [NLnet project page](https://nlnet.nl/project/RedoxOS-Signals).
 
-[qemu]: https://www.qemu.org
-[gdb]: https://www.gnu.org/software/gdb/
+[<img src="https://nlnet.nl/logo/banner.png" alt="NLnet foundation logo" width="20%" />](https://nlnet.nl)
+[<img src="https://nlnet.nl/image/logos/NGI0_tag.svg" alt="NGI Zero Logo" width="20%" />](https://nlnet.nl/core)

Xargo.toml

-[dependencies.alloc]

alloc_kernel/Cargo.toml

-[package]
-authors = ["Philipp Oppermann <dev@phil-opp.com>"]
-name = "alloc_kernel"
-version = "0.1.0"
-
-[dependencies]
-linked_list_allocator = { git = "https://github.com/redox-os/linked-list-allocator.git" }
-spin = "*"

build.rs

-use std::env;
-use std::fs;
-use std::io::{Error, Write};
-use std::path::Path;
-use std::collections::HashMap;
+use rustc_cfg::Cfg;
+use std::{env, path::Path, process::Command};
+use toml::Table;
 
+fn parse_kconfig(arch: &str) -> Option<()> {
+    println!("cargo:rerun-if-changed=config.toml");
 
-// View loc folder with subfolders, get listings
-// Returns touple (folder_map, file_list)
-// folder_map keys are folders, and values are lists of direct childs
-// file_list is a vector of all detected files with full path
-fn scan_folder(loc: &Path) -> (HashMap<String, Vec<String>>, Vec<String>) {
-    let mut folders: HashMap<String, Vec<String>> = HashMap::new();
-    let mut files: Vec<String> = Vec::new();
-    let mut current = Vec::new();
-
-    if loc.is_dir() {
-        for entry in fs::read_dir(loc).unwrap() {
-            let entry = entry.unwrap();
-            let path = entry.path();
-            let path_str = String::from(path.to_str().unwrap()).replace("\\", "/");
-
-            current.push(path_str.clone());
-
-            // if folder then scan recursively
-            if path.is_dir() {
-                let (d, mut f) = scan_folder(&path);
-                for (key, value) in d.into_iter() {
-                    folders.insert(key, value);
-                }
-
-                files.append(&mut f);
-            } else {
-                files.push(path_str);
-            }
-        }
-
-        current.sort();
-        folders.entry(String::from(loc.to_str().unwrap()).replace("\\", "/")).or_insert(current);
-    } else {
-        panic!("{:?} is not a folder!", loc);
-    }
-
-    (folders, files)
-}
-
-// Write folder/file information to output file
-fn fill_from_location(f: &mut fs::File, loc: &Path ) -> Result<(), (Error)> {
-    let (folders, mut files) = scan_folder(loc);
-    let mut folder_it:Vec<_> = folders.keys().collect();
-
-    let loc_str = loc.to_str().unwrap();
-    let mut idx = loc_str.len();
-
-    if !loc_str.ends_with("/") {
-        idx += 1;
+    assert!(Path::new("config.toml.example").try_exists().unwrap());
+    if !Path::new("config.toml").try_exists().unwrap() {
+        std::fs::copy("config.toml.example", "config.toml").unwrap();
     }
-
-    folder_it.sort();
-    files.sort();
-    for dir in folder_it.iter() {
-        let strip: String = dir.chars().skip(idx).collect();
-        write!(f, "        files.insert(b\"{}\", (b\"", strip)?;
-
-        // Write child elements separated with \n
-        let sub = folders.get(*dir).unwrap();
-        let mut first = true;
-        for child in sub.iter() {
-            let idx = child.rfind('/').unwrap() + 1;
-            let (_, c) = child.split_at(idx);
-            if first {
-                write!(f, "{}", c)?;
-                first = false;
-            } else {
-                write!(f, "\\n{}", c)?;
-            }
+    let config_str = std::fs::read_to_string("config.toml").unwrap();
+    let root: Table = toml::from_str(&config_str).unwrap();
+
+    let altfeatures = root
+        .get("arch")?
+        .as_table()
+        .unwrap()
+        .get(arch)?
+        .as_table()
+        .unwrap()
+        .get("features")?
+        .as_table()
+        .unwrap();
+
+    let self_modifying = env::var("CARGO_FEATURE_SELF_MODIFYING").is_ok();
+
+    for (name, value) in altfeatures {
+        let mut choice = value.as_str().unwrap();
+        assert!(matches!(choice, "always" | "never" | "auto"));
+
+        if !self_modifying && choice == "auto" {
+            choice = "never";
         }
-        write!(f, "\", true));\n")?;
-    }
 
-    for name in files.iter() {
-        let (_, strip) = name.split_at(idx);
-        write!(f, "        files.insert(b\"{}\", (include_bytes!(\"{}\"), false));\n", strip, name)?;
+        println!("cargo:rustc-cfg=cpu_feature_{choice}=\"{name}\"");
     }
 
-    Ok(())
+    Some(())
 }
 
 fn main() {
     println!("cargo:rustc-env=TARGET={}", env::var("TARGET").unwrap());
 
     let out_dir = env::var("OUT_DIR").unwrap();
-    let dest_path = Path::new(&out_dir).join("gen.rs");
-    let mut f = fs::File::create(&dest_path).unwrap();
-    let src = env::var("INITFS_FOLDER");
-
-    // Write header
-    f.write_all(b"
-mod gen {
-    use alloc::BTreeMap;
-    pub fn gen() -> BTreeMap<&'static [u8], (&'static [u8], bool)> {
-        let mut files: BTreeMap<&'static [u8], (&'static [u8], bool)> = BTreeMap::new();
-").unwrap();
+    let cfg = Cfg::of(env::var("TARGET").unwrap().as_str()).unwrap();
+    let arch_str = cfg.target_arch.as_str();
 
-    match src {
-        Ok(v) => fill_from_location(&mut f, Path::new(&v)).unwrap(),
-        Err(e) => {
-            f.write_all(
-                b"        files.clear();" // Silence mutability warning
-            ).unwrap();
-            println!("cargo:warning=location not found: {}, please set proper INITFS_FOLDER.", e);
+    match arch_str {
+        "aarch64" => {
+            println!("cargo:rustc-cfg=dtb");
+        }
+        "x86" => {
+            println!("cargo:rerun-if-changed=src/asm/x86/trampoline.asm");
+
+            let status = Command::new("nasm")
+                .arg("-f")
+                .arg("bin")
+                .arg("-o")
+                .arg(format!("{}/trampoline", out_dir))
+                .arg("src/asm/x86/trampoline.asm")
+                .status()
+                .expect("failed to run nasm");
+            if !status.success() {
+                panic!("nasm failed with exit status {}", status);
+            }
+        }
+        "x86_64" => {
+            println!("cargo:rerun-if-changed=src/asm/x86_64/trampoline.asm");
+
+            let status = Command::new("nasm")
+                .arg("-f")
+                .arg("bin")
+                .arg("-o")
+                .arg(format!("{}/trampoline", out_dir))
+                .arg("src/asm/x86_64/trampoline.asm")
+                .status()
+                .expect("failed to run nasm");
+            if !status.success() {
+                panic!("nasm failed with exit status {}", status);
+            }
         }
+        "riscv64" => {
+            println!("cargo:rustc-cfg=dtb");
+        }
+        _ => (),
     }
 
-    f.write_all(b"
-        files
-    }
-}
-").unwrap();
+    let _ = parse_kconfig(arch_str);
 }

clippy.sh

@@ -3,15 +3,5 @@
 set -e
 
 export RUST_TARGET_PATH="${PWD}/targets"
-xargo rustc --lib --release \
-  --target x86_64-unknown-none \
-  --features clippy \
-  -- \
-  -C soft-float -C debuginfo=2 \
-  -W anonymous-parameters \
-  -W trivial-numeric-casts \
-  -W unused-extern-crates \
-  -W unused-import-braces \
-  -W unused-qualifications \
-  -W variant-size-differences \
-  -Z no-trans -Z extra-plugins=clippy
+export RUSTFLAGS="-C soft-float -C debuginfo=2"
+cargo clippy --lib --release --target x86_64-unknown-none "$@"

config.toml.example

+[arch.x86_64.features]
+smap = "auto"
+fsgsbase = "auto"
+xsave = "auto"
+xsaveopt = "auto"
+
+# vim: ft=toml

linkers/aarch64.ld

+ENTRY(kstart)
+OUTPUT_FORMAT("elf64-littleaarch64", "elf64-littleaarch64", "elf64-littleaarch64")
+
+KERNEL_OFFSET = 0xFFFFFF0000000000;
+
+SECTIONS {
+    . = KERNEL_OFFSET;
+
+    . += SIZEOF_HEADERS;
+
+    /* Force the zero page to be part of a segment by creating a
+     * dummy section in the zero page.
+     * Limine will map the segment with the lowest vaddr value at
+     * 0xFFFFFFFF80000000 even if the segment has a higher vaddr.
+     * As such without the zero page being part of a segment, the
+     * kernel would be loaded at an offset from the expected
+     * location. As the redox kernel is not currently relocatable,
+     * this would result in a crash. A similar issue likely exists
+     * with multiboot/multiboot2 and the paddr of the segment.
+     */
+    .dummy ALIGN(8) : AT(ADDR(.dummy) - KERNEL_OFFSET) {}
+
+    . = ALIGN(4096);
+
+    .text : AT(ADDR(.text) - KERNEL_OFFSET) {
+        __text_start = .;
+        *(.text*)
+        __usercopy_start = .;
+        *(.usercopy-fns)
+        __usercopy_end = .;
+	. = ALIGN(4096);
+        __text_end = .;
+    }
+
+    .rodata : AT(ADDR(.rodata) - KERNEL_OFFSET) {
+        __rodata_start = .;
+        *(.rodata*)
+	. = ALIGN(4096);
+        __rodata_end = .;
+    }
+
+    .data : AT(ADDR(.data) - KERNEL_OFFSET) {
+        __data_start = .;
+        *(.data*)
+	. = ALIGN(4096);
+        __data_end = .;
+        __bss_start = .;
+        *(.bss*)
+	. = ALIGN(4096);
+        __bss_end = .;
+    }
+
+    __end = .;
+
+    /DISCARD/ : {
+        *(.comment*)
+        *(.eh_frame*)
+        *(.gcc_except_table*)
+        *(.note*)
+        *(.rel.eh_frame*)
+    }
+}

linkers/i686.ld

+ENTRY(kstart)
+OUTPUT_FORMAT(elf32-i386)
+
+KERNEL_OFFSET = 0xC0000000;
+
+SECTIONS {
+    . = KERNEL_OFFSET;
+
+    . += SIZEOF_HEADERS;
+
+    /* Force the zero page to be part of a segment by creating a
+     * dummy section in the zero page.
+     * Limine will map the segment with the lowest vaddr value at
+     * 0xFFFFFFFF80000000 even if the segment has a higher vaddr.
+     * As such without the zero page being part of a segment, the
+     * kernel would be loaded at an offset from the expected
+     * location. As the redox kernel is not currently relocatable,
+     * this would result in a crash. A similar issue likely exists
+     * with multiboot/multiboot2 and the paddr of the segment.
+     */
+    .dummy : AT(ADDR(.dummy) - KERNEL_OFFSET) {}
+
+    .text ALIGN(4K) : AT(ADDR(.text) - KERNEL_OFFSET) {
+        __text_start = .;
+        *(.text*)
+        __usercopy_start = .;
+        *(.usercopy-fns)
+        __usercopy_end = .;
+    }
+
+    .rodata ALIGN(4K) : AT(ADDR(.rodata) - KERNEL_OFFSET) {
+        __text_end = .;
+        __rodata_start = .;
+        *(.rodata*)
+    }
+
+    .data ALIGN(4K) : AT(ADDR(.data) - KERNEL_OFFSET) {
+        __rodata_end = .;
+        __data_start = .;
+        *(.data*)
+        . = ALIGN(4K);
+        __data_end = .;
+        __bss_start = .;
+        *(.bss*)
+        . = ALIGN(4K);
+    }
+
+    __end = .;
+
+    /DISCARD/ : {
+        *(.comment*)
+        *(.eh_frame*)
+        *(.gcc_except_table*)
+        *(.note*)
+        *(.rel.eh_frame*)
+    }
+}

linkers/riscv64.ld

+ENTRY(kstart)
+OUTPUT_FORMAT("elf64-littleriscv", "elf64-littleriscv", "elf64-littleriscv" )
+
+KERNEL_OFFSET = 0xFFFFFF0000000000;
+
+SECTIONS {
+    . = KERNEL_OFFSET;
+
+    . += SIZEOF_HEADERS;
+
+    /* Force the zero page to be part of a segment by creating a
+     * dummy section in the zero page.
+     * Linker will map the segment with the lowest vaddr value at
+     * 0xFFFFFF0000000000 even if the segment has a higher vaddr.
+     * As such without the zero page being part of a segment, the
+     * kernel would be loaded at an offset from the expected
+     * location. As the redox kernel is not currently relocatable,
+     * this would result in a crash. A similar issue likely exists
+     * with multiboot/multiboot2 and the paddr of the segment.
+     */
+    .dummy ALIGN(8) : AT(ADDR(.dummy) - KERNEL_OFFSET) {}
+
+    . = ALIGN(4096);
+
+    .text : AT(ADDR(.text) - KERNEL_OFFSET) {
+        __text_start = .;
+	*(.early_init.text*)
+	. = ALIGN(4096);
+        *(.text*)
+        __usercopy_start = .;
+        *(.usercopy-fns)
+        __usercopy_end = .;
+	. = ALIGN(4096);
+        __text_end = .;
+    }
+
+    .rodata : AT(ADDR(.rodata) - KERNEL_OFFSET) {
+        __rodata_start = .;
+        *(.rodata*)
+	. = ALIGN(4096);
+        __rodata_end = .;
+    }
+
+    .data : AT(ADDR(.data) - KERNEL_OFFSET) {
+        __data_start = .;
+        *(.data*)
+        *(.sdata*)
+	. = ALIGN(4096);
+        __data_end = .;
+        *(.got*)
+	. = ALIGN(4096);
+        __bss_start = .;
+        *(.bss*)
+        *(.sbss*)
+	. = ALIGN(4096);
+        __bss_end = .;
+    }
+
+    __end = .;
+
+    /DISCARD/ : {
+        *(.comment*)
+        *(.eh_frame*)
+        *(.gcc_except_table*)
+        *(.note*)
+        *(.rel.eh_frame*)
+    }
+}

linkers/x86_64.ld

 ENTRY(kstart)
 OUTPUT_FORMAT(elf64-x86-64)
 
-KERNEL_OFFSET = 0xffffff0000100000;
+KERNEL_OFFSET = 0xFFFFFFFF80000000;
 
 SECTIONS {
     . = KERNEL_OFFSET;
 
     . += SIZEOF_HEADERS;
-    . = ALIGN(4096);
 
-    .text : AT(ADDR(.text) - KERNEL_OFFSET) {
+    /* Force the zero page to be part of a segment by creating a
+     * dummy section in the zero page.
+     * Limine will map the segment with the lowest vaddr value at
+     * 0xFFFFFFFF80000000 even if the segment has a higher vaddr.
+     * As such without the zero page being part of a segment, the
+     * kernel would be loaded at an offset from the expected
+     * location. As the redox kernel is not currently relocatable,
+     * this would result in a crash. A similar issue likely exists
+     * with multiboot/multiboot2 and the paddr of the segment.
+     */
+    .dummy : AT(ADDR(.dummy) - KERNEL_OFFSET) {}
+
+    .text ALIGN(4K) : AT(ADDR(.text) - KERNEL_OFFSET) {
         __text_start = .;
         *(.text*)
-		. = ALIGN(4096);
-        __text_end = .;
+        __usercopy_start = .;
+        *(.usercopy-fns)
+        __usercopy_end = .;
     }
 
-	.rodata : AT(ADDR(.rodata) - KERNEL_OFFSET) {
+    .rodata ALIGN(4K) : AT(ADDR(.rodata) - KERNEL_OFFSET) {
+        __text_end = .;
         __rodata_start = .;
         *(.rodata*)
-		. = ALIGN(4096);
-        __rodata_end = .;
+        __altcode_start = .;
+        KEEP(*(.altcode*))
+        __altcode_end = .;
+        . = ALIGN(8);
+        __altrelocs_start = .;
+        KEEP(*(.altrelocs*))
+        __altrelocs_end = .;
+        __altfeatures_start = .;
+        KEEP(*(.altfeatures*))
+        __altfeatures_end = .;
     }
 
-    .data : AT(ADDR(.data) - KERNEL_OFFSET) {
+    .data ALIGN(4K) : AT(ADDR(.data) - KERNEL_OFFSET) {
+        __rodata_end = .;
         __data_start = .;
         *(.data*)
-		. = ALIGN(4096);
+        . = ALIGN(4K);
         __data_end = .;
         __bss_start = .;
         *(.bss*)
-        . = ALIGN(4096);
-        __bss_end = .;
-    }
-
-    .tdata : AT(ADDR(.tdata) - KERNEL_OFFSET) {
-        __tdata_start = .;
-        *(.tdata*)
-        . = ALIGN(4096);
-        __tdata_end = .;
-        __tbss_start = .;
-        *(.tbss*)
-        . += 8;
-        . = ALIGN(4096);
-        __tbss_end = .;
     }
 
     __end = .;