.cargo/config

-[build]
-rustflags = [
-  # Kernel should preserve floating-point registers
-  "-Csoft-float",
-]

.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://gitlab.redox-os.org/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"]
+

Cargo.toml

 [package]
 name = "kernel"
-version = "0.1.54"
+version = "0.4.1"
 build = "build.rs"
-edition = "2018"
+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]
-bitflags = "1.2.1"
-linked_list_allocator = "0.8.4"
-log = { version = "0.4" }
-raw-cpuid = "8.0.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.5.2"
-paste = "0.1.18"
+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.2.1"
@@ -28,30 +35,57 @@ features = ["elf32", "elf64"]
 version = "0.1.16"
 default-features = false
 
-[dependencies.x86]
-version = "0.32.0"
-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 = ["acpi", "multi_core", "serial_debug"]
+default = [
+  "acpi",
+  "multi_core",
+  "graphical_debug",
+  "serial_debug",
+  "self_modifying",
+  "x86_kvm_pv",
+]
+
+# Activates some limited code-overwriting optimizations, based on CPU features.
+self_modifying = []
+
 acpi = []
-doc = []
 graphical_debug = []
-live = []
 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 = []
 
-[profile.dev]
-# Kernel doesn't yet work great with debug mode :(
-opt-level = 3
+debugger = ["syscall_debug"]
+syscall_debug = []
 
-# LTO fixes some duplicate symbols of memcpy/memmove/etc
-lto = true
+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)
+	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
 ```
+
+## 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] or [lldb] client.
+This will start a virtual machine with and listen on port `1234` for a GDB or LLDB client.
 
-## [gdb]
+### GDB
 
-If you are going to use [gdb], run the following to load debug symbols and connect
-to your running kernel.
+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
 ```
 
-## [lldb]
+### LLDB
 
-If you are going to use [lldb], run the following to start debugging.
+If you are going to use [LLDB](https://lldb.llvm.org/), run these commands to start debugging:
 
 ```
 (lldb) target create -s build/kernel.sym build/kernel
 (lldb) gdb-remote localhost:1234
 ```
 
-## Debugging
-
 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.
 
-[qemu]: https://www.qemu.org
-[gdb]: https://www.gnu.org/software/gdb/
-[lldb]: https://lldb.llvm.org/
+## 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.

Xargo.toml

-[dependencies.alloc]

build.rs

-use std::collections::HashMap;
-use std::env;
-use std::fs;
-use std::io::{Error, Write};
-use std::path::Path;
+use rustc_cfg::Cfg;
+use std::{env, path::Path, process::Command};
+use toml::Table;
 
-// 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();
+fn parse_kconfig(arch: &str) -> Option<()> {
+    println!("cargo:rerun-if-changed=config.toml");
 
-    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);
+    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();
     }
-
-    (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;
-    }
-
-    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(())
-}
-
-#[cfg(not(target_arch = "x86_64"))]
-fn asm(_out_dir: &str) {}
-
-#[cfg(target_arch = "x86_64")]
-fn asm(out_dir: &str) {
-    use std::process::Command;
-
-    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);
-    }
+    Some(())
 }
 
 fn main() {
     println!("cargo:rustc-env=TARGET={}", env::var("TARGET").unwrap());
-    println!("cargo:rerun-if-env-changed=INITFS_FOLDER");
 
     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");
-
-    asm(&out_dir);
+    let cfg = Cfg::of(env::var("TARGET").unwrap().as_str()).unwrap();
+    let arch_str = cfg.target_arch.as_str();
 
-    // Write header
-    f.write_all(
-        b"
-mod gen {
-    use alloc::collections::BTreeMap;
-    pub fn gen() -> BTreeMap<&'static [u8], (&'static [u8], bool)> {
-        let mut files: BTreeMap<&'static [u8], (&'static [u8], bool)> = BTreeMap::new();
-",
-    )
-    .unwrap();
-
-    match src {
-        Ok(v) => {
-            println!("cargo:rerun-if-changed={}", v);
-            fill_from_location(&mut f, Path::new(&v)).unwrap()
+    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);
+            }
         }
-        Err(e) => {
-            f.write_all(
-                b"        files.clear();", // Silence mutability warning
-            )
-            .unwrap();
-            println!(
-                "cargo:warning=location not found: {}, please set proper INITFS_FOLDER.",
-                e
-            );
+        "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

@@ -2,15 +2,6 @@
 
 set -e
 
-# https://github.com/rust-lang/rust-clippy/issues/4579
-export RUSTUP_TOOLCHAIN="nightly-2019-07-19"
-rustup update "${RUSTUP_TOOLCHAIN}"
-rustup component add clippy --toolchain "${RUSTUP_TOOLCHAIN}"
-rustup component add rust-src --toolchain "${RUSTUP_TOOLCHAIN}"
-
-# Cause recompilation
-touch src/lib.rs
-
 export RUST_TARGET_PATH="${PWD}/targets"
 export RUSTFLAGS="-C soft-float -C debuginfo=2"
-xargo clippy --lib --release --target x86_64-unknown-none
+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 = .;

rmm @ 63669069

+Subproject commit 63669069f4eb2e3bf04c0399d28fb2e3e3c58166

rustfmt.toml

+blank_lines_lower_bound = 0 # default
+blank_lines_upper_bound = 1 # default
+brace_style = "SameLineWhere" # default
+disable_all_formatting = false # default
+edition = "2021"
+empty_item_single_line = true # default
+fn_single_line = false # default
+force_explicit_abi = true # default
+format_strings = false # default
+hard_tabs = false # default
+show_parse_errors = true # default
+imports_granularity = "Crate" # default = Preserve
+imports_indent = "Block" # default
+imports_layout = "Mixed" # default
+indent_style = "Block" # default
+max_width = 100 # default
+newline_style = "Unix" # default = Auto
+skip_children = false # default
+tab_spaces = 4 # default
+trailing_comma = "Vertical" # default
+where_single_line = false # default