kernel: revert -Z json-target-spec to original nightly-2025-10-03 build

Reverts the prior session's -Z json-target-spec addition
that was breaking the build on nightly-2025-10-03 (the
kernel's rust-toolchain.toml specified toolchain). The
flag did not exist in that nightly; only nightly-2026-04-11
has it. Since the prior toolchain can build custom .json
target specs without any cargo-level gating (just pass
-Zunstable-options through -- separator to rustc),
the cleanest fix is to use rustc's -- directly:

  cd SOURCE && cargo rustc -Z build-std=core,alloc ...
    --bin kernel --target FILE --release
    -- -C link-arg=...

  RUSTUP_TOOLCHAIN=nightly-2025-10-03 is explicit so the
  Makefile build works regardless of which toolchain the
  outer shell has.

  Also: restore rust-toolchain.toml to nightly-2025-10-03
  (the version pinned in this fork). The 2026-04-01 bump
  was a workaround attempt that did not work.

  And: add .cargo/config.toml with [unstable]
  json-target-spec = true as the new standard way (cargo
  PR #16557) of enabling custom .json target specs. This
  is harmless on older toolchains that don't have the feature
  (cargo ignores unknown config keys).

Discovered via research into the nightly-2026-04-11 vs
nightly-2025-10-03 divergence after the redbear-mini build
failed with 'unknown -Z flag specified: json-target-spec'.

.cargo/config.toml

@@ -0,0 +1,2 @@
+[unstable]
+json-target-spec = true

.editorconfig

@@ -1,7 +0,0 @@
-[**.c]
-indent_size = 4
-indent_style = space
-
-[**.yml]
-indent_size = 4
-indent_style = space

.gitignore

@@ -1,11 +1,3 @@
-.idea/
-prefix/
-sysroot/
-**/target/
-.gdb_history
-*.patch
-*.swp
-*.swo
-/.vim
-.vscode/
-
+target
+/config.toml
+.gitlab-ci-local/

.gitlab-ci.yml

@@ -5,83 +5,86 @@ variables:
 
 workflow:
   rules:
-    - if: '$CI_COMMIT_BRANCH == "master" && $CI_PROJECT_NAMESPACE == "redox-os"'
+    - if: '$CI_PROJECT_NAMESPACE == "redox-os"'
     - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "master"'
 
 stages:
-    - build
-    - cross-build
-    - test
-before_script:
-    cargo install cbindgen
-
-fmt:
-    stage: build
-    needs: []
-    script:
-        - rustup component add rustfmt-preview
-        - ./fmt.sh -- --check
-
-clippy:
-    stage: build
-    needs: []
-    # TODO: remove when passed
-    allow_failure: true
-    script:
-        - ./check.sh --clippy
-
-linux:
-    stage: build
-    script:
-        - rustup component add clippy
-        - ./check.sh --host
-#        - ./check.sh --host --clippy
+  - build
+  - cross-build
+  - test
+  - other-features
+  # TODO: benchmarks and profiling (maybe manually enabled for relevant MRs)?
 
 x86_64:
-    stage: build
-    script:
-        - ./check.sh --arch=x86_64
-
-i586:
-    stage: cross-build
-    script:
-        - ./check.sh --arch=i586
-#        - ./check.sh --arch=i586 --clippy
+  stage: build
+  script:
+    - mkdir -p target/${ARCH}
+    - redoxer env make BUILD=target/${ARCH}
+  variables:
+    ARCH: "x86_64"
 
 aarch64:
-    stage: cross-build
-    image: "redoxos/redoxer:aarch64"
-    script:
-        - ./check.sh --arch=aarch64
-#        - ./check.sh --arch=aarch64 --clippy
+  stage: cross-build
+  image: "redoxos/redoxer:aarch64"
+  script:
+    - mkdir -p target/${ARCH}
+    - redoxer env make BUILD=target/${ARCH}
+  variables:
+    ARCH: "aarch64"
+
+i586:
+  stage: cross-build
+  script:
+    - mkdir -p target/${ARCH}
+    - TARGET=${ARCH}-unknown-redox redoxer env make BUILD=target/${ARCH}
+  variables:
+    ARCH: "i586"
 
 riscv64gc:
-    stage: cross-build
-    script:
-        - ./check.sh --arch=riscv64gc
-#        - ./check.sh --arch=riscv64gc --clippy
+  stage: cross-build
+  script:
+    - mkdir -p target/${ARCH}
+    - TARGET=${ARCH}-unknown-redox redoxer env make BUILD=target/${ARCH}
+  variables:
+    ARCH: "riscv64gc"
 
-test:linux:
-    stage: test
-    needs: [linux]
-    script:
-        - ./check.sh --host --test
+fmt:
+  stage: build
+  script:
+      - rustup component add rustfmt
+      - rustfmt --check
 
-test:x86_64:
-    stage: test
-    needs: [x86_64]
-    script:
-        # timeout: https://gitlab.redox-os.org/redox-os/relibc/-/issues/238
-        - timeout -s KILL 9m ./check.sh --arch=x86_64 --test
+x86_64:boot:
+  stage: test
+  needs: [x86_64]
+  script:
+    - mkdir -p target/${ARCH}
+    - export COOKBOOK_SOURCE_IDENT=$CI_COMMIT_SHA
+    - redoxer env make BUILD=target/${ARCH}
+    - timeout -s KILL 9m redoxer exec --folder target/${ARCH}/:/usr/lib/boot uname -a
+  variables:
+    ARCH: "x86_64"
 
-test:aarch64:
-    stage: test
-    needs: [aarch64]
-    image: "redoxos/redoxer:aarch64"
-    # many issues that not exist in x86_64, and lack of interest to fix so far
-    allow_failure: true
-    when: manual
-    script:
-        - timeout -s KILL 9m ./check.sh --arch=aarch64 --test
+x86_64:relibc:
+  stage: test
+  needs: [x86_64]
+  script:
+    - redoxer pkg relibc-tests-bins
+    - export COOKBOOK_SOURCE_IDENT=$CI_COMMIT_SHA
+    - mkdir -p target/${TARGET}/sysroot/{usr/lib/boot,root} target/${TARGET}/root
+    - redoxer env make BUILD=target/${TARGET}/sysroot/usr/lib/boot
+    - (cd target/${TARGET}/sysroot && mv home/user/relibc-tests/* root/)
+    - timeout -s KILL 9m redoxer exec --folder target/${TARGET}/sysroot/:/ make run
+  # It is fine if failing sometimes
+  allow_failure: true
+  variables:
+    TARGET: "x86_64-unknown-redox"
 
-#TODO: Enable more arch once dynamic linker working
+profiling-compile:
+  stage: other-features
+  allow_failure: true
+  script:
+    make check
+  variables:
+    ARCH: "x86_64"
+    KERNEL_CHECK_FEATURES: profiling

.gitmodules

@@ -1,7 +1,4 @@
-[submodule "openlibm"]
-	path = openlibm
-	url = https://gitlab.redox-os.org/redox-os/openlibm.git
-	branch = master
-[submodule "src/dlmalloc-rs"]
-	path = dlmalloc-rs
-	url = https://gitlab.redox-os.org/redox-os/dlmalloc-rs.git
+[submodule "redox-path"]
+	path = redox-path
+	url = https://gitlab.redox-os.org/redox-os/redox-path.git
+	branch = main

.helix/config.toml

@@ -0,0 +1,2 @@
+[editor]
+auto-format = false

.helix/languages.toml

@@ -0,0 +1,13 @@
+[[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

@@ -0,0 +1,79 @@
+# 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 |                                                                               |

CONTRIBUTING.md

@@ -1,123 +0,0 @@
-# Contributing
-
-## Table of contents
-1. [What to do](#what-to-do)
-2. [Code style](#code-style)
-3. [Sending merge requests](#sending-merge-requests)
-4. [Writing tests](#writing-tests)
-5. [Running tests](#running-tests)
-
-Maintaining a libc is tough work, and we'd love some help!
-
-## What to do
-
-For now, we are still trying to get full libc compatibility before we move on to
-any optimisation.
-
-- We currently have a number of unimplemented functions. Search for 
-    `unimplemented!()` and hop right in!
-- If you notice any missing functionality, feel free to add it in
-
-## Code style
-
-We have a `rustfmt.toml` in the root directory of relibc. Please run `./fmt.sh`
-before sending in any merge requests as it will automatically format your code.
-
-With regards to general style:
-
-### Where applicable, prefer using references to raw pointers
-
-This is most obvious when looking at `stdio` functions. If raw pointers were
-used instead of references, then the resulting code would be significantly
-uglier. Instead try to check for pointer being valid with `pointer::as_ref()`
-and `pointer::as_mut()` and then immediately use those references instead.
-
-Internal functions should always take references.
-
-### Use the c types exposed in our platform module instead of Rust's inbuilt integer types
-
-This is so we can guarantee that everything works across platforms. While it is
-generally accepted these days that an `int` has 32 bits (which matches against
-an `i32`), some platforms have `int` as having 16 bits, and others have long as
-being 32 bits instead of 64. If you use the types in platform, then we can
-guarantee that your code will "just work" should we port relibc to a different
-architecture.
-
-### Use our internal functions
-
-If you need to use a C string, don't reinvent the wheel. We have functions in
-the platform module that convert C strings to Rust slices.
-
-We also have structures that wrap files, wrap writable strings, and wrap various
-other commonly used things that you should use instead of rolling your own.
-
-## Sending merge requests
-
-If you have sent us a merge request, first of all, thanks for taking your time
-to help us!
-
-The first thing to note is that we do most of our development on our 
-[GitLab server](https://gitlab.redox-os.org/redox-os/relibc), and as such it is
-possible that none of the maintainers will see your merge request if it is
-opened on GitHub.
-
-In your merge request, please put in the description:
-- What functions (if any) have been implemented or changed
-- The rationale behind your merge request (e.g. why you thought this change was
-    required. If you are just implementing some functions, you can ignore this)
-- Any issues that are related to the merge request
-
-We have CI attached to our GitLab instance, so all merge requests are checked to
-make sure that they are tested before they are merged. Please write tests for
-the functions that you add/change and test locally on your own machine
-***before*** submitting a merge request.
-
-## Writing tests
-
-Every function that gets written needs to have a test in C in order to make sure
-it works as intended. Here are a few guidelines for writing good tests.
-
-### Ensure that any literals you have are mapped to variables instead of being directly passed to a function.
-
-Sometimes compilers take literals put into libc functions and run them 
-internally during compilation, which can cause some false positives.  All tests
-are compiled with `-fno-builtin`, which theoretically solves this issue, but
-just in case, it'd be a good idea to map inputs to variables.
-
-```c
-#include "string.h"
-#include "stdio.h"
-
-int main(void) {
-    // Don't do this
-    printf("%d\n", strcspn("Hello", "Hi"));
-
-    // Do this
-    char *first = "Hello";
-    char *second = "Hi";
-    printf("%d\n", strcspn(first, second));
-}
-```
-
-### Ensure your tests cover every section of code.
-
-What happens if a string in `strcmp()` is shorter than the other string? What 
-happens if the first argument to `strcspn()` is longer than the second string?  
-In order to make sure that all functions work as expected, we ask that any tests
-cover as much of the code that you have written as possible.
-
-## Running tests
-
-Running tests is an important part in trying to find bugs. Before opening a
-merge request, we ask that you test on your own machine to make sure there are
-no regressions.
-
-You can run tests with `make test` in the root directory of relibc to compile
-relibc, compile the tests and run them. This *will* print a lot of output to
-stdout, so be warned!
-
-You can test against verified correct output with `make verify` in the tests 
-directory. You will need to manually create the correct output and put it in the
-tests/expected directory. Running any `make` commands in the tests directory
-will ***not*** rebuild relibc, so you'll need to go back to the root directory
-if you need to rebuild relibc.

Cargo.lock

@@ -3,100 +3,54 @@
 version = 4
 
 [[package]]
-name = "argon2"
-version = "0.5.3"
+name = "ahash"
+version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c3610892ee6e0cbce8ae2700349fcf8f98adb0dbfbee85aec3c9179d29cc072"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
 dependencies = [
- "base64ct",
- "blake2",
- "cpufeatures",
- "password-hash",
+ "cfg-if",
+ "once_cell",
+ "version_check",
+ "zerocopy",
 ]
 
 [[package]]
 name = "arrayvec"
-version = "0.7.8"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
-name = "autocfg"
-version = "1.5.1"
+name = "bit_field"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+checksum = "1e4b40c7323adcfc0a41c4b88143ed58346ff65a288fc144329c5c45e05d70c6"
 
 [[package]]
-name = "base64ct"
-version = "1.8.3"
+name = "bitfield"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
-
-[[package]]
-name = "bcrypt-pbkdf"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6aeac2e1fe888769f34f05ac343bbef98b14d1ffb292ab69d4608b3abc86f2a2"
-dependencies = [
- "blowfish",
- "pbkdf2",
- "sha2",
-]
+checksum = "46afbd2983a5d5a7bd740ccb198caf5b82f45c40c09c0eed36052d91cb92e719"
 
 [[package]]
 name = "bitflags"
-version = "2.13.0"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
-name = "blake2"
-version = "0.10.6"
+name = "bitflags"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "blowfish"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e412e2cd0f2b2d93e02543ceae7917b3c70331573df19ee046bcbc35e45e87d7"
-dependencies = [
- "byteorder",
- "cipher",
-]
-
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
-name = "cbitset"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29b6ad25ae296159fb0da12b970b2fe179b234584d7cd294c891e2bbb284466b"
-dependencies = [
- "num-traits",
-]
+checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 
 [[package]]
 name = "cc"
-version = "1.1.22"
-source = "git+https://github.com/tea/cc-rs?branch=riscv-abi-arch-fix#588ceacb084af41415690c57688e338a32a1f1b4"
+version = "1.2.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
 dependencies = [
+ "find-msvc-tools",
  "shlex",
 ]
 
@@ -107,174 +61,81 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
-name = "chrono"
-version = "0.4.45"
+name = "equivalent"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "fdt"
+version = "0.2.0-alpha1"
+source = "git+https://github.com/repnop/fdt.git?rev=2fb1409edd1877c714a0aa36b6a7c5351004be54#2fb1409edd1877c714a0aa36b6a7c5351004be54"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 dependencies = [
- "num-traits",
+ "ahash",
 ]
 
 [[package]]
-name = "chrono-tz"
-version = "0.10.4"
+name = "hashbrown"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6139a8597ed92cf816dfb33f5dd6cf0bb93a6adc938f11039f371bc5bcd26c3"
+checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
+
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
 dependencies = [
- "chrono",
- "phf",
+ "equivalent",
+ "hashbrown 0.17.0",
 ]
 
 [[package]]
-name = "cipher"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+name = "kernel"
+version = "0.5.12"
 dependencies = [
- "crypto-common",
- "inout",
+ "arrayvec",
+ "bitfield",
+ "bitflags 2.11.1",
+ "cc",
+ "fdt",
+ "hashbrown 0.14.5",
+ "linked_list_allocator",
+ "object",
+ "raw-cpuid",
+ "redox-path",
+ "redox_syscall",
+ "rmm",
+ "rustc-demangle",
+ "sbi-rt",
+ "slab",
+ "smallvec",
+ "spin",
+ "toml",
+ "x86",
 ]
 
 [[package]]
-name = "cpufeatures"
-version = "0.2.17"
+name = "linked_list_allocator"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+checksum = "549ce1740e46b291953c4340adcd74c59bcf4308f4cac050fd33ba91b7168f4a"
 dependencies = [
- "libc",
+ "spinning_top",
 ]
 
-[[package]]
-name = "crt0"
-version = "0.1.0"
-
-[[package]]
-name = "crti"
-version = "0.1.0"
-
-[[package]]
-name = "crtn"
-version = "0.1.0"
-
-[[package]]
-name = "crypto-common"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "crypto-common",
- "subtle",
-]
-
-[[package]]
-name = "dlmalloc"
-version = "0.2.8"
-dependencies = [
- "cfg-if",
- "windows-sys",
-]
-
-[[package]]
-name = "drm-sys"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecc8e1361066d91f5ffccff060a3c3be9c3ecde15be2959c1937595f7a82a9f8"
-dependencies = [
- "libc",
- "linux-raw-sys",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
-]
-
-[[package]]
-name = "generic-rt"
-version = "0.1.0"
-
-[[package]]
-name = "goblin"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17582616a7718cca54cec18e534a76c7c4aec11a8b9a85695712f262fd15a4c8"
-dependencies = [
- "log",
- "plain",
- "scroll",
-]
-
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "inout"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "ioslice"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e571352c8a3b89074d12e3ee5173ffe162159105352aaaf1fc5764da747e31b"
-
-[[package]]
-name = "ld_so"
-version = "0.1.0"
-
-[[package]]
-name = "libc"
-version = "0.2.189"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
-
-[[package]]
-name = "libm"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
-
-[[package]]
-name = "libredox"
-version = "0.1.18+rb0.3.1"
-dependencies = [
- "bitflags",
- "libc",
- "plain",
-]
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
-
 [[package]]
 name = "lock_api"
 version = "0.4.14"
@@ -284,96 +145,26 @@ dependencies = [
  "scopeguard",
 ]
 
-[[package]]
-name = "log"
-version = "0.4.33"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
-
-[[package]]
-name = "md-5"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
-dependencies = [
- "cfg-if",
- "digest",
-]
-
 [[package]]
 name = "memchr"
-version = "2.8.3"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
-
-[[package]]
-name = "num-traits"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
-dependencies = [
- "autocfg",
-]
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
 [[package]]
 name = "object"
-version = "0.36.7"
-source = "git+https://gitlab.redox-os.org/andypython/object?branch=new#da781336d847df0deb897ed1162785f6c2057c56"
+version = "0.37.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "password-hash"
-version = "0.5.0"
+name = "once_cell"
+version = "1.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
-dependencies = [
- "base64ct",
- "rand_core 0.6.4",
- "subtle",
-]
-
-[[package]]
-name = "pbkdf2"
-version = "0.12.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
-dependencies = [
- "digest",
- "hmac",
- "sha2",
-]
-
-[[package]]
-name = "phf"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "913273894cec178f401a31ec4b656318d95473527be05c0752cc41cdc32be8b7"
-dependencies = [
- "phf_shared",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06005508882fb681fd97892ecff4b7fd0fee13ef1aa569f8695dae7ab9099981"
-dependencies = [
- "siphasher",
-]
-
-[[package]]
-name = "plain"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
-
-[[package]]
-name = "posix-regex"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66df580334caab2f744839ab1be85493d7ec731a92d6cf928008ab0b212bf3bc"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "proc-macro2"
@@ -386,156 +177,62 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.46"
+version = "1.0.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
-name = "rand"
-version = "0.10.2"
+name = "raw-cpuid"
+version = "10.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
+checksum = "6c297679cb867470fa8c9f67dbba74a78d78e3e98d7cf2b08d6d71540f797332"
 dependencies = [
- "rand_core 0.10.1",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-
-[[package]]
-name = "rand_core"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
-
-[[package]]
-name = "rand_jitter"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdcd80e68f0a8f9ca5ec7cfd02fd5fbb8fbe6ef4e9b90ea2f48bb929b74f88e"
-dependencies = [
- "libc",
- "rand_core 0.10.1",
- "windows-sys",
-]
-
-[[package]]
-name = "rand_xorshift"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60aa6af80be32871323012e02e6e65f8a7cc7890931ae421d217ad8fe0df2ccf"
-dependencies = [
- "rand_core 0.10.1",
-]
-
-[[package]]
-name = "redox-ioctl"
-version = "0.1.0"
-dependencies = [
- "drm-sys",
- "redox_syscall",
+ "bitflags 1.3.2",
 ]
 
 [[package]]
 name = "redox-path"
-version = "0.4.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54ec1b67c01c63545205ea6d218b336751399f0d8974c1a635c28604bedb81bc"
-
-[[package]]
-name = "redox-rt"
-version = "0.1.0"
-dependencies = [
- "bitflags",
- "generic-rt",
- "goblin",
- "ioslice",
- "libredox",
- "plain",
- "redox-path",
- "redox_syscall",
-]
-
-[[package]]
-name = "redox_event"
-version = "0.4.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5018d583d6d2f5499352aea8d177e9067d1eb03ab17c78169d5ba7a30001b15"
-dependencies = [
- "bitflags",
- "libredox",
- "redox_syscall",
-]
+checksum = "64072665120942deff5fd5425d6c1811b854f4939e7f1c01ce755f64432bbea7"
 
 [[package]]
 name = "redox_syscall"
-version = "0.9.0+rb0.3.1"
+version = "0.8.1"
 dependencies = [
- "bitflags",
+ "bitflags 2.11.1",
 ]
 
 [[package]]
-name = "relibc"
-version = "0.2.5+rb0.3.1"
+name = "rmm"
+version = "0.1.0"
 dependencies = [
- "argon2",
- "arrayvec",
- "base64ct",
- "bcrypt-pbkdf",
- "bitflags",
- "cbitset",
- "cc",
- "chrono",
- "chrono-tz",
- "dlmalloc",
- "generic-rt",
- "ioslice",
- "libc",
- "libm",
- "libredox",
- "log",
- "md-5",
- "memchr",
- "object",
- "pbkdf2",
- "plain",
- "posix-regex",
- "rand",
- "rand_jitter",
- "rand_xorshift",
- "redox-ioctl",
- "redox-path",
- "redox-rt",
- "redox_event",
- "redox_syscall",
- "sc",
- "scrypt",
- "sha-crypt",
- "sha2",
- "spin",
- "unicode-width",
+ "bitflags 2.11.1",
 ]
 
 [[package]]
-name = "salsa20"
-version = "0.10.2"
+name = "rustc-demangle"
+version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d"
+
+[[package]]
+name = "sbi-rt"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fbaa69be1eedc61c426e6d489b2260482e928b465360576900d52d496a58bd0"
 dependencies = [
- "cipher",
+ "sbi-spec",
 ]
 
 [[package]]
-name = "sc"
-version = "0.2.7"
+name = "sbi-spec"
+version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "010e18bd3bfd1d45a7e666b236c78720df0d9a7698ebaa9c1c559961eb60a38b"
+checksum = "e6e36312fb5ddc10d08ecdc65187402baba4ac34585cb9d1b78522ae2358d890"
 
 [[package]]
 name = "scopeguard"
@@ -544,19 +241,28 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
-name = "scroll"
-version = "0.13.0"
+name = "serde"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1257cd4248b4132760d6524d6dda4e053bc648c9070b960929bf50cfb1e7add"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
- "scroll_derive",
+ "serde_core",
 ]
 
 [[package]]
-name = "scroll_derive"
-version = "0.13.1"
+name = "serde_core"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed76efe62313ab6610570951494bdaa81568026e0318eaa55f167de70eeea67d"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -564,36 +270,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "scrypt"
-version = "0.11.0"
+name = "serde_spanned"
+version = "0.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
 dependencies = [
- "password-hash",
- "pbkdf2",
- "salsa20",
- "sha2",
-]
-
-[[package]]
-name = "sha-crypt"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88e79009728d8311d42d754f2f319a975f9e38f156fd5e422d2451486c78b286"
-dependencies = [
- "base64ct",
- "sha2",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
+ "serde",
 ]
 
 [[package]]
@@ -603,31 +285,40 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
-name = "siphasher"
-version = "1.0.3"
+name = "slab"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "spin"
-version = "0.9.9"
+version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
 dependencies = [
  "lock_api",
 ]
 
 [[package]]
-name = "subtle"
-version = "2.6.1"
+name = "spinning_top"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+checksum = "5b9eb1a2f4c41445a3a0ff9abc5221c5fcd28e1f13cd7c0397706f9ac938ddb0"
+dependencies = [
+ "lock_api",
+]
 
 [[package]]
 name = "syn"
-version = "2.0.119"
+version = "2.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -635,10 +326,45 @@ dependencies = [
 ]
 
 [[package]]
-name = "typenum"
-version = "1.20.1"
+name = "toml"
+version = "0.8.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.22.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
+dependencies = [
+ "indexmap",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_write",
+ "winnow",
+]
+
+[[package]]
+name = "toml_write"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
 
 [[package]]
 name = "unicode-ident"
@@ -646,12 +372,6 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
-[[package]]
-name = "unicode-width"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
-
 [[package]]
 name = "version_check"
 version = "0.9.5"
@@ -659,74 +379,45 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
-name = "windows-sys"
-version = "0.59.0"
+name = "winnow"
+version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
 dependencies = [
- "windows-targets",
+ "memchr",
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.52.6"
+name = "x86"
+version = "0.47.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+checksum = "55b5be8cc34d017d8aabec95bc45a43d0f20e8b2a31a453cabc804fe996f8dca"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "bit_field",
+ "bitflags 1.3.2",
+ "raw-cpuid",
 ]
 
 [[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.52.6"
+name = "zerocopy"
+version = "0.8.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"
+dependencies = [
+ "zerocopy-derive",
+]
 
 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
+name = "zerocopy-derive"
+version = "0.8.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+[[patch.unused]]
+name = "libredox"
+version = "0.1.18"

Cargo.toml

@@ -1,154 +1,148 @@
+[workspace]
+resolver = "3"
+members = [".", "rmm"]
+
 [package]
-name = "relibc"
-version = "0.2.5+rb0.3.1"
-authors = ["Jeremy Soller <jackpot51@gmail.com>", "vasilito <adminpupkin@gmail.com>"]
+name = "kernel"
+version = "0.5.12"
+build = "build.rs"
 edition = "2024"
 
-[lib]
-name = "relibc"
-crate-type = ["staticlib"]
-
-[workspace]
-members = [
-    "src/crt0",
-    "src/crti",
-    "src/crtn",
-    "redox-rt",
-    "ld_so",
-    "generic-rt",
-]
-exclude = ["tests", "dlmalloc-rs"]
-
-[workspace.lints.clippy]
-borrow_as_ptr = "deny"
-cast_lossless = "warn" # TODO review occurrences
-cast_possible_truncation = "allow" # TODO review occurrences
-cast_possible_wrap = "allow" # TODO review occurrences
-cast_precision_loss = "allow" # TODO review occurrences
-cast_ptr_alignment = "allow" # TODO review occurrences
-cast_sign_loss = "allow" # TODO review occurrences
-ignored_unit_patterns = "deny"
-implicit_clone = "deny"
-manual_let_else = "deny"
-missing_errors_doc = "allow" # TODO review occurrences
-missing_panics_doc = "allow" # TODO review occurrences
-missing_safety_doc = "allow" # TODO review occurrences
-mut_from_ref = "deny"
-precedence = "deny"
-ptr_as_ptr = "warn" # TODO review occurrences
-ptr_cast_constness = "warn" # TODO review occurrences
-ptr_offset_by_literal = "deny"
-ref_as_ptr = "warn" # TODO review occurrences
-type_complexity = "allow" # TODO review occurrences
-upper_case_acronyms = "allow" # TODO review occurrences
-zero_ptr = "deny" # must allow on public constants due to cbindgen issue
-
-[workspace.lints.rust]
-dangling_pointers_from_temporaries = "deny"
-dead_code = "allow" # TODO review occuurences
-deprecated = "deny"
-improper_ctypes_definitions = "deny"
-internal_features = "allow" # core_intrinsics and lang_items
-irrefutable_let_patterns = "deny"
-mismatched_lifetime_syntaxes = "deny"
-non_camel_case_types = "allow" # needed for most POSIX type names
-non_snake_case = "allow" # TODO review occuurences
-non_upper_case_globals = "allow" # TODO review occuurences
-unexpected_cfgs = "deny"
-unpredictable_function_pointer_comparisons = "deny"
-unreachable_code = "allow" # TODO review occuurences
-unsafe_op_in_unsafe_fn = "deny"
-unused_imports = "deny"
-unused_must_use = "deny"
-unused_mut = "deny"
-unused_unsafe = "deny"
-unused_variables = "allow" # TODO review occurrences (too many for now)
-
-[lints]
-workspace = true
-
-[workspace.dependencies]
-bitflags = "2"
-ioslice = { version = "0.6", default-features = false }
-plain = "0.2"
-redox-path = "0.4.0"
-redox_protocols = { package = "libredox", path = "../libredox", default-features = false, features = ["protocol"] }
-redox_syscall = { path = "../syscall" }
-
 [build-dependencies]
-cc = "1"
+cc = "1.0"
+toml = "0.8"
 
 [dependencies]
-bitflags.workspace = true
-arrayvec = { version = "0.7.6", default-features = false }
-cbitset = "0.2"
-posix-regex = { version = "0.1.4", features = ["no_std"] }
-
-rand = { version = "0.10", default-features = false }
-rand_xorshift = "0.5"
-rand_jitter = "0.6"
-
-memchr = { version = "2.2.0", default-features = false }
-plain.workspace = true
-unicode-width = "0.1"
-__libc_only_for_layout_checks = { package = "libc", version = "0.2.149", optional = true }
-md5-crypto = { package = "md-5", version = "0.10.6", default-features = false }
-sha-crypt = { version = "0.5", default-features = false }
-base64ct = { version = "1.6", default-features = false, features = ["alloc"] }
-bcrypt-pbkdf = { version = "0.10", default-features = false, features = [
-    "alloc",
-] }
-scrypt = { version = "0.11", default-features = false, features = ["simple"] }
-pbkdf2 = { version = "0.12", features = ["sha2"] }
-sha2 = { version = "0.10", default-features = false }
-generic-rt = { path = "generic-rt" }
-chrono-tz = { version = "0.10", default-features = false }
-chrono = { version = "0.4", default-features = false, features = ["alloc"] }
-libm = "0.2"
-log = "0.4"
-spin = "0.9.8"
-argon2 = "0.5.3"
-
-[dependencies.dlmalloc]
-path = "dlmalloc-rs"
-default-features = false
-features = ["c_api"]
+arrayvec = { version = "0.7.4", default-features = false }
+bitfield = "0.13.2"
+bitflags = "2"
+fdt = { git = "https://github.com/repnop/fdt.git", rev = "2fb1409edd1877c714a0aa36b6a7c5351004be54" }
+hashbrown = { version = "0.14.3", default-features = false, features = ["ahash", "inline-more"] }
+linked_list_allocator = "0.9.0"
+redox-path = "0.2.0"
+redox_syscall = { git = "https://gitlab.redox-os.org/redox-os/syscall.git", default-features = false }
+rmm = { path = "rmm", default-features = false }
+slab = { version = "0.4", default-features = false }
+smallvec = { version = "1.15.1", default-features = false }
+spin = { version = "0.9.8" }
 
 [dependencies.object]
-version = "0.36.7"
-git = "https://gitlab.redox-os.org/andypython/object"
-branch = "new"
+version = "0.37.1"
 default-features = false
-features = ["elf", "read_core"]
+features = ["read_core", "elf"]
 
-[target.'cfg(target_os = "linux")'.dependencies]
-sc = "0.2.7"
+[dependencies.rustc-demangle]
+version = "0.1.16"
+default-features = false
 
-[target.'cfg(target_os = "redox")'.dependencies]
-redox_syscall.workspace = true
-redox-rt = { path = "redox-rt" }
-redox-path.workspace = true
-redox_event = { version = "0.4.8", default-features = false, features = ["redox_syscall"] }
-ioslice.workspace = true
-redox-ioctl = { path = "redox-ioctl" }
-redox_protocols.workspace = true
+[lints.clippy]
+# Overflows are very, very bad in kernel code as it may provide an attack vector for
+# userspace applications, and it is only checked in debug builds
+# TODO: address occurrences and then deny
+arithmetic_side_effects = "warn"
+cast_ptr_alignment = "warn" # TODO: address occurrences and then deny
+identity_op = "allow" # Used to allow stuff like 1 << 0 and 1 * 1024 * 1024
+if_same_then_else = "allow" # Useful for adding comments about different branches
+# Indexing a slice can cause panics and that is something we always want to avoid
+# in kernel code. Use .get and return an error instead
+# TODO: address occurrences and then deny
+indexing_slicing = "warn"
+many_single_char_names = "allow" # Useful in the syscall function
+module_inception = "allow" # Used for context::context
+# Not implementing default is sometimes useful in the case something has significant cost
+# to allocate. If you implement default, it can be allocated without evidence using the
+# ..Default::default() syntax. Not fun in kernel space
+new_without_default = "allow"
+not_unsafe_ptr_arg_deref = "deny"
+or_fun_call = "allow" # Used to make it nicer to return errors, for example, .ok_or(Error::new(ESRCH))
+precedence = "deny"
+ptr_cast_constness = "deny"
+too_many_arguments = "allow" # This is needed in some cases, like for syscall
+# Avoid panicking in the kernel without information about the panic. Use expect
+# TODO: address occurrences and then deny
+unwrap_used = "warn"
+
+[lints.rust]
+static_mut_refs = "warn" # FIXME deny once all occurrences are fixed
+# This is usually a serious issue - a missing import of a define where it is interpreted
+# as a catch-all variable in a match, for example
+unreachable_patterns = "deny"
+unused_must_use = "deny" # Ensure that all must_use results are used
+
+[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]
-# to enable trace level, take out this `no_trace`
-default = ["check_against_libc_crate", "no_trace"]
-check_against_libc_crate = ["__libc_only_for_layout_checks"]
-math_libm = []
-no_trace = ["log/release_max_level_debug"]
-# for very verbose activity beyond trace level
-trace_tls = []
+default = [
+  "acpi",
+  #"debugger",
+  "multi_core",
+  "serial_debug",
+  "self_modifying",
+  "x86_kvm_pv",
+  #"busy_panic",
+  #"drop_panic",
+  #"syscall_debug"
+]
+
+# Activates some limited code-overwriting optimizations, based on CPU features.
+self_modifying = []
+
+acpi = []
+lpss_debug = []
+multi_core = ["acpi"]
+profiling = []
+#TODO: remove when threading issues are fixed
+pti = []
+drop_panic = []
+busy_panic = []
+qemu_debug = []
+serial_debug = []
+system76_ec_debug = []
+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"
 
+# Red Bear OS Phase J: see local/sources/base/Cargo.toml for
+# the rationale. Both the kernel and the base workspace need
+# the libredox override so that the libredox::error::Error
+# type is the same compile-time type as syscall::Error. With
+# the local libredox fork at local/sources/libredox/ using
+# the local syscall fork at local/sources/syscall/, the
+# libredox::error::Error (re-exported from the local syscall)
+# and syscall::Error (also the local syscall) are now the
+# same type, so `?` conversions in scheme-utils / daemon
+# compile cleanly.
 [patch.crates-io]
-cc-11 = { git = "https://github.com/tea/cc-rs", branch = "riscv-abi-arch-fix", package = "cc" }
-redox_syscall = { path = "../syscall" }
+# Phase J: override libredox 0.1.17 to use the local
+# fork at ../libredox/ (which itself uses the local syscall
+# fork). This breaks the libredox::error::Error <->
+# syscall::Error type-identity barrier that previously
+# caused E0277 errors in scheme-utils and daemon.
 libredox = { path = "../libredox" }
+# Phase J: the kernel's redox_syscall dep is a git URL
+# (not crates.io), so [patch.crates-io] doesn't apply.
+# Use a [patch."<URL>"] section to match the dep source.
+# The local fork at ../syscall adds the EnterS2Idle /
+# ExitS2Idle AcpiVerb variants — the kernel's direct use
+# of AcpiVerb in src/scheme/acpi.rs's kcall handler
+# needs the fork to see these variants.
+[patch."https://gitlab.redox-os.org/redox-os/syscall.git"]
+redox_syscall = { path = "../syscall" }

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Redox OS
+Copyright (c) 2017 Jeremy Soller
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,230 +1,66 @@
-include config.mk
+.PHONY: all check
 
-CARGO?=cargo
-CARGO_TEST?=$(CARGO)
-CARGO_COMMON_FLAGS=-Z build-std=core,alloc,compiler_builtins
-CARGOFLAGS?=$(CARGO_COMMON_FLAGS)
-CC_WRAPPER?=
-RUSTCFLAGS?=
-LINKFLAGS?=-lgcc
-USE_RUST_LIBM?=
-TESTBIN?=
-export OBJCOPY?=objcopy
+SOURCE:=$(dir $(realpath $(lastword $(MAKEFILE_LIST))))
+BUILD?=$(CURDIR)
+export RUST_TARGET_PATH=$(SOURCE)/targets
 
-export CARGO_TARGET_DIR?=$(shell pwd)/target
-BUILD?=$(CARGO_TARGET_DIR)/$(TARGET)
-CARGOFLAGS+=--target=$(TARGET)
-EXCEPT_MATH=-not -name "math"
-FEATURE_MATH=
-ifneq ($(USE_RUST_LIBM),)
-FEATURE_MATH=--features math_libm
-EXCEPT_MATH=
+ifeq ($(TARGET),)
+	ARCH?=$(shell uname -m)
+else
+	ARCH?=$(shell echo "$(TARGET)" | cut -d - -f1)
 endif
 
-TARGET_HEADERS?=$(BUILD)/include
-export CFLAGS=-I$(TARGET_HEADERS)
-
-PROFILE?=release
-
-HEADERS_UNPARSED=$(shell find src/header -mindepth 1 -maxdepth 1 -type d -not -name "_*" $(EXCEPT_MATH) -printf "%f\n")
-HEADERS_DEPS=$(shell find src/header -type f \( -name "cbindgen.toml" -o -name "*.rs" \))
-#HEADERS=$(patsubst %,%.h,$(subst _,/,$(HEADERS_UNPARSED)))
-
-SRC=\
-	Cargo.* \
-	$(shell find src/ redox-rt/src/ ld_so/src/ redox-ioctl/src/ include/ -type f)
-
-BUILTINS_VERSION=0.1.70
-
-.PHONY: all clean fmt install install-libs install-headers install-tests libs headers submodules test
-
-all: | headers libs
-
-headers: $(BUILD)/$(PROFILE)/librelibc.a $(HEADERS_DEPS)
-	rm -rf $(TARGET_HEADERS)
-	mkdir -p $(TARGET_HEADERS)
-	cp -r include/* $(TARGET_HEADERS)
-ifeq ($(USE_RUST_LIBM),)
-	cp "openlibm/include"/*.h $(TARGET_HEADERS)
-	cp "openlibm/src"/*.h $(TARGET_HEADERS)
+ifeq ($(ARCH),riscv64gc)
+	override ARCH:=riscv64
+	GNU_TARGET=riscv64-unknown-redox
+else ifeq ($(ARCH),i686)
+	override ARCH:=i586
+	GNU_TARGET=i686-unknown-redox
+else
+	GNU_TARGET=$(ARCH)-unknown-redox
 endif
-	@set -e ; \
-	for header in $(HEADERS_UNPARSED); do \
-		if test -f "src/header/$$header/cbindgen.toml"; then \
-			printf "\033[0;36;49mWriting Header $$header\033[0m\n"; \
-			out=`echo "$$header" | sed 's/_/\//g'`; \
-			out="$(TARGET_HEADERS)/$$out.h"; \
-			cat "src/header/$$header/cbindgen.toml" cbindgen.globdefs.toml \
-				 | cbindgen "src/header/$$header/mod.rs" --config=/dev/stdin --output "$$out"; \
-		fi \
-	done; printf "\033[0;36;49mAll headers written\033[0m\n";
 
-clean:
-	$(CARGO) clean
-	$(MAKE) -C tests clean
-	rm -rf sysroot
+
+all: $(BUILD)/kernel $(BUILD)/kernel.sym
+
+LD_SCRIPT=$(SOURCE)/linkers/$(ARCH).ld
+LOCKFILE=$(SOURCE)/Cargo.lock
+MANIFEST=$(SOURCE)/Cargo.toml
+TARGET_SPEC=$(RUST_TARGET_PATH)/$(ARCH)-unknown-kernel.json
+
+KERNEL_CARGO_FEATURES?=
+
+$(BUILD)/kernel.all: $(LD_SCRIPT) $(LOCKFILE) $(MANIFEST) $(TARGET_SPEC) $(shell find $(SOURCE) -name "*.rs" -type f)
+	cd $(SOURCE) && RUSTUP_TOOLCHAIN=nightly-2025-10-03 cargo rustc \
+		-Z build-std=core,alloc -Zbuild-std-features=compiler-builtins-mem \
+		--bin kernel \
+		--manifest-path "$(MANIFEST)" \
+		--target "$(TARGET_SPEC)" \
+		--release \
+		--features=$(KERNEL_CARGO_FEATURES) \
+		-- \
+		-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"
+
+KERNEL_CHECK_FEATURES?=
 
 check:
-	$(CARGO) check
-
-fmt:
-	./fmt.sh
-
-install-headers: headers libs
-	mkdir -pv "$(DESTDIR)/include"
-	cp -rv "$(TARGET_HEADERS)"/* "$(DESTDIR)/include"
-
-libs: \
-	$(BUILD)/$(PROFILE)/libc.a \
-	$(BUILD)/$(PROFILE)/libc.so \
-	$(BUILD)/$(PROFILE)/crt0.o \
-	$(BUILD)/$(PROFILE)/crti.o \
-	$(BUILD)/$(PROFILE)/crtn.o
-
-install-libs: headers libs
-	mkdir -pv "$(DESTDIR)/lib"
-	cp -v "$(BUILD)/$(PROFILE)/libc.a" "$(DESTDIR)/lib"
-	cp -v "$(BUILD)/$(PROFILE)/libc.so" "$(DESTDIR)/lib"
-	ln -vnfs libc.so "$(DESTDIR)/lib/libc.so.6"
-	ln -vnfs libc.so "$(DESTDIR)/lib/$(LD_SONAME)"
-	cp -v "$(BUILD)/$(PROFILE)/crt0.o" "$(DESTDIR)/lib"
-	ln -vnfs crt0.o "$(DESTDIR)/lib/crt1.o"
-	ln -vnfs crt0.o "$(DESTDIR)/lib/Scrt1.o"
-	cp -v "$(BUILD)/$(PROFILE)/crti.o" "$(DESTDIR)/lib"
-	cp -v "$(BUILD)/$(PROFILE)/crtn.o" "$(DESTDIR)/lib"
-ifeq ($(USE_RUST_LIBM),)
-	cp -v "$(BUILD)/openlibm/libopenlibm.a" "$(DESTDIR)/lib/libm.a"
-else
-	$(AR) -rcs "$(DESTDIR)/lib/libm.a"
-endif
-	# Empty libraries for dl, pthread, and rt
-	$(AR) -rcs "$(DESTDIR)/lib/libdl.a"
-	$(AR) -rcs "$(DESTDIR)/lib/libpthread.a"
-	$(AR) -rcs "$(DESTDIR)/lib/librt.a"
-
-install-tests: tests
-	$(MAKE) -C tests
-	mkdir -p "$(DESTDIR)/relibc-tests"
-	cp -vr tests/build_$(TARGET)/* "$(DESTDIR)/relibc-tests/"
-
-install: install-headers install-libs
-
-submodules:
-	git submodule sync
-	git submodule update --init --recursive
-
-sysroot:
-	@mkdir -p $@
-
-.PHONY: sysroot/$(TARGET)
-sysroot/$(TARGET): | sysroot
-	rm -rf $@
-	rm -rf $@.partial
-	mkdir -p $@.partial
-	$(MAKE) install DESTDIR=$(shell pwd)/$@.partial
-	mv $@.partial $@
-	touch $@
-
-test: sysroot/$(TARGET)
-	# TODO: Fix SIGILL when running cargo test
-	# $(CARGO_TEST) test
-	$(MAKE) -C tests run
-
-test-once: sysroot/$(TARGET)
-	$(MAKE) -C tests run-once TESTBIN=$(TESTBIN)
-
-
-$(BUILD)/$(PROFILE)/libc.so: $(BUILD)/$(PROFILE)/ld_so.o $(BUILD)/$(PROFILE)/libc.a
-	# Specifying a dynamic list makes all non-local `STV_DEFAULT`
-	# definitions non-preemptible, except for the symbols listed in
-	# `dynlst.txt`. So, the symbols defined in `dynlst.txt` may be
-	# interposed by other definitions at runtime (either from the
-	# executable or some shared library).
-	$(CC) -nostdlib \
-		-shared \
-		-Wl,--gc-sections \
-		-Wl,--dynamic-list=dynlst.txt \
-		-Wl,-z,pack-relative-relocs \
-		-Wl,--sort-common \
-		-Wl,--whole-archive $^ -Wl,--no-whole-archive \
-		-Wl,-soname,libc.so.6 \
-		$(LINKFLAGS) \
-		-o $@
-
-$(BUILD)/$(PROFILE)/libc.a: $(BUILD)/$(PROFILE)/librelibc.a $(BUILD)/openlibm/libopenlibm.a
-	echo "create $@" > "$@.mri"
-	for lib in $^; do\
-		echo "addlib $$lib" >> "$@.mri"; \
-	done
-	echo "save" >> "$@.mri"
-	echo "end" >> "$@.mri"
-	$(AR) -M < "$@.mri"
-
-# Debug targets
-
-$(BUILD)/debug/librelibc.a: $(SRC)
-	$(CARGO) rustc $(CARGOFLAGS) $(FEATURE_MATH) -- --emit link=$@ -g -C debug-assertions=no $(RUSTCFLAGS)
-	./renamesyms.sh "$@" "$(BUILD)/debug/deps/"
-	./stripcore.sh "$@"
-	touch $@
-
-$(BUILD)/debug/crt0.o: $(SRC)
-	$(CARGO) rustc --manifest-path src/crt0/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
-	touch $@
-
-$(BUILD)/debug/crti.o: $(SRC)
-	$(CARGO) rustc --manifest-path src/crti/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
-	touch $@
-
-$(BUILD)/debug/crtn.o: $(SRC)
-	$(CARGO) rustc --manifest-path src/crtn/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
-	touch $@
-
-$(BUILD)/debug/ld_so.o: $(SRC)
-	$(CARGO) rustc --manifest-path ld_so/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort -g -C debug-assertions=no $(RUSTCFLAGS)
-	touch $@
-
-# Release targets
-
-$(BUILD)/release/librelibc.a: $(SRC)
-	$(CARGO) rustc --release $(CARGOFLAGS) $(FEATURE_MATH) -- --emit link=$@ $(RUSTCFLAGS)
-	@# TODO: Better to only allow a certain whitelisted set of symbols? Perhaps
-	@# use some cbindgen hook, specify them manually, or grep for #[unsafe(no_mangle)].
-	./renamesyms.sh "$@" "$(BUILD)/release/deps/"
-	./stripcore.sh "$@"
-	touch $@
-
-$(BUILD)/release/crt0.o: $(SRC)
-	$(CARGO) rustc --release --manifest-path src/crt0/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
-	touch $@
-
-$(BUILD)/release/crti.o: $(SRC)
-	$(CARGO) rustc --release --manifest-path src/crti/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
-	touch $@
-
-$(BUILD)/release/crtn.o: $(SRC)
-	$(CARGO) rustc --release --manifest-path src/crtn/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
-	touch $@
-
-$(BUILD)/release/ld_so.o: $(SRC)
-	$(CARGO) rustc --release --manifest-path ld_so/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
-	touch $@
-
-# Other targets
-
-$(BUILD)/openlibm: openlibm
-	rm -rf $@ $@.partial
-	mkdir -p $(BUILD)
-	cp -r $< $@.partial
-	mv $@.partial $@
-	touch $@
-
-ifeq ($(USE_RUST_LIBM),)
-$(BUILD)/openlibm/libopenlibm.a: $(BUILD)/openlibm headers $(BUILD)/$(PROFILE)/librelibc.a
-	$(MAKE) -s AR=$(AR) CC="$(CC_WRAPPER) $(CC)" LD=$(LD) CPPFLAGS="$(CPPFLAGS) -fno-stack-protector -I$(shell pwd)/include -I$(TARGET_HEADERS)" -C $< libopenlibm.a
-	./renamesyms.sh "$@" "$(BUILD)/$(PROFILE)/deps/"
-else
-$(BUILD)/openlibm/libopenlibm.a:
-	mkdir -p "$(BUILD)/openlibm"
-	$(AR) -rcs "$(BUILD)/openlibm/libopenlibm.a"
-endif
+	cargo check \
+		--bin kernel \
+		--manifest-path "$(MANIFEST)" \
+		--target "$(TARGET_SPEC)" \
+		-Z build-std=core,alloc -Zbuild-std-features=compiler-builtins-mem -Z target-spec-json \
+		--features=$(KERNEL_CHECK_FEATURES)

README.md

@@ -1,169 +1,77 @@
-# Redox C Library (relibc)
+# Kernel
 
-relibc is a portable C standard library written in Rust and is under heavy development, this library contains the following items:
+Redox OS Microkernel
 
-- C, Linux, BSD functions and extensions
-- POSIX compatibility layer
-- Interfaces for system components
+[![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)
 
-The motivation for this project is twofold: Reduce issues that the Redox developers were having with [newlib](https://sourceware.org/newlib/), and create a more stable and safe alternative to C standard libraries written in C. It is mainly designed to be used under Redox, as an alternative to newlib, but it also supports Linux via the [sc](https://crates.io/crates/sc) crate.
+## Requirements
 
-Currently Redox and Linux are supported.
+* [`nasm`](https://nasm.us/) needs to be available on the PATH at build time.
 
-## `redox-rt`
+## Building The Documentation
 
-`redox-rt` is a runtime library that provides much of the code that enables POSIX on Redox, like `fork`, `exec`, signal handling, etc.
-Relibc uses it as backend in `src/platform/redox`, and it's intended to eventually be usable independently, without relibc.
-
-## Repository Layout
-
-- `include` - Header files (mostly macros and variadic functions `cbindgen` can't generate)
-- `src` - Source files
-- `src/c` - C code
-- `src/crt0` - Runtime code
-- `src/crti` - Runtime code
-- `src/crtn` - Runtime code
-- `src/header` - Header files implementation
-- `src/header/*` - Each folder has a `cbindgen.toml` file, it generates a C-to-Rust interface and header files
-- `src/ld_so` - Dynamic loader code
-- `src/platform` - Platform-specific and common code
-- `src/platform/redox` - Redox-specific code
-- `src/platform/linux` - Linux-specific code
-- `src/pthread` - pthread implementation
-- `src/sync` - Synchronization primitives
-- `tests` - C tests (each MR needs to give success in all of them)
-
-## Download the sources
-
-To download the relibc sources run the following command:
+Use this command:
 
 ```sh
-git clone --recursive https://gitlab.redox-os.org/redox-os/relibc
+cargo doc --open --target x86_64-unknown-none
 ```
 
-## Build Instructions
+## Debugging
 
-To build relibc out of the Redox build system, do the following steps:
+### QEMU
 
-### Dependencies
-
-- Install `cbindgen`
+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
-cargo install cbindgen
+make qemu gdb=yes
 ```
 
-#### Install the `expect` tool
+This will start a virtual machine with and listen on port `1234` for a GDB or LLDB client.
 
-- Debian, Ubuntu and PopOS:
+### GDB
 
-```sh
-sudo apt install expect
+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
 ```
 
-- Fedora:
+### LLDB
 
-```sh
-sudo dnf install expect
+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
 ```
 
-- Arch Linux:
+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.
 
-```sh
-sudo pacman -S expect
-```
+## Notes
 
-### Build Relibc
+- 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.
 
-To build the relibc library objects, run the following command:
+- If you receive a kernel panic in QEMU, use `pkill qemu-system` to kill the frozen QEMU process.
 
-```sh
-make all
-```
+## How To Contribute
 
-- Clean old library objects and tests
+To learn how to contribute to this system component you need to read the following document:
 
-```sh
-make clean
-```
+- [CONTRIBUTING.md](https://gitlab.redox-os.org/redox-os/redox/-/blob/master/CONTRIBUTING.md)
 
-## Build relibc inside the Redox build system
+## Development
 
-Inside of your Redox build system, run:
+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.
 
-```sh
-make prefix
-```
+### How To Build
 
-If you need to rebuild `relibc` for testing a Cookbook recipe, run:
+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.
 
-```sh
-touch relibc
-make prefix r.recipe-name
-```
-
-Touching (changing the "last modified time" of) the `relibc` folder is needed to trigger recompilation for `make prefix`. Replace `recipe-name` with your desired recipe name.
-
-Note: Do not edit `relibc` inside `prefix` folder! Do your work on `relibc` folder directly inside your Redox build system instead.
-
-## Tests
-
-Relibc has a test suite that also runs every time a new commit get pushed. You can see `.gitlab-ci.yml` to see how it's being executed. That being said, `./check.sh` is the recommended way to run tests. Here's few examples:
-
-+ `./check.sh` - Run build, without running the test
-+ `./check.sh --test` - Run all tests in x86_64 Redox using Redoxer
-+ `./check.sh --test --host` - Run all tests in host (Linux)
-+ `./check.sh --test --arch=aarch64` - Run all tests in specified arch
-  - Arch can be `x86_64`, `aarch64`, `i586`, or `riscv64gc`
-+ `./check.sh --test=stdio/printf` - Run a single test
-  - Can be combined with `--host` or `--arch`
-  - Will run statically linked test in Linux, dynamically linked in Redox
-
-Couple of notes:
-
-- Relibc and its tests will rebuild if files are changed, however switching between arch or host requires you to run `make clean`
-- Redoxer is needed to run tests for Redox without `--host`. You can install it using `cargo install redoxer`
-- Tests can hang, the test runner can anticipate this, assuming the kernel doesn't hang too.
-
-## Issues
-
-#### I'm building for my own platform which I run, and am getting `x86_64-linux-gnu-ar: command not found` (or similar)
-
-The Makefile expects GNU compiler tools prefixed with the platform specifier, as would be present when you installed a cross compiler. Since you are building for your own platform, some Linux distributions (like Manjaro) don't install/symlink the prefixed executables.
-
-An easy fix would be to replace the corresponding lines in `config.mk`, e.g.
-
-```diff
-ifeq ($(TARGET),x86_64-unknown-linux-gnu)
--	export CC=x86_64-linux-gnu-gcc
--	export LD=x86_64-linux-gnu-ld
--	export AR=x86_64-linux-gnu-ar
--	export NM=x86_64-linux-gnu-nm
-+       export CC=gcc
-+       export LD=ld
-+       export AR=ar
-+       export NM=nm
-	export OBJCOPY=objcopy
-	export CPPFLAGS=
-	LD_SO_PATH=lib/ld64.so.1
-endif
-```
-
-## Contributing
-
-Before starting to contribute, read [this](CONTRIBUTING.md) document.
-
-## Supported OSes
-
-- Redox OS
-- Linux
-
-## Supported architectures
-
-- i586 (Intel/AMD)
-- x86_64 (Intel/AMD)
-- aarch64 (ARM64)
-- riscv64gc (RISC-V)
+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_
 

build.rs

@@ -1,30 +1,100 @@
-extern crate cc;
+#![allow(clippy::unwrap_used)] // the build script can panic
 
-use std::{env, fs};
+use std::{env, path::Path, process::Command};
+use toml::Table;
 
-fn main() {
-    let _crate_dir = env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set");
-    let target = env::var("TARGET").unwrap();
+fn parse_kconfig(arch: &str) -> Option<()> {
+    println!("cargo:rerun-if-changed=config.toml");
 
-    println!("cargo:rerun-if-changed=src/c");
+    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();
+    }
+    let config_str = std::fs::read_to_string("config.toml").unwrap();
+    let root: Table = toml::from_str(&config_str).unwrap();
 
-    let mut cc_builder = &mut cc::Build::new();
+    let altfeatures = root
+        .get("arch")?
+        .as_table()
+        .unwrap()
+        .get(arch)?
+        .as_table()
+        .unwrap()
+        .get("features")?
+        .as_table()
+        .unwrap();
 
-    cc_builder = cc_builder.flag("-nostdinc").flag("-nostdlib");
+    #[expect(clippy::format_collect)] // TODO: remove once version is bumped
+    let features_list = altfeatures
+        .keys()
+        .map(|feat| format!(", {feat:?}"))
+        .collect::<String>();
+    println!("cargo::rustc-check-cfg=cfg(cpu_feature_always, values(\"\"{features_list}))");
+    println!("cargo::rustc-check-cfg=cfg(cpu_feature_auto, values(\"\"{features_list}))");
+    println!("cargo::rustc-check-cfg=cfg(cpu_feature_never, values(\"\"{features_list}))");
 
-    if target.starts_with("aarch64") {
-        cc_builder = cc_builder.flag("-mno-outline-atomics")
+    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";
+        }
+
+        println!("cargo:rustc-cfg=cpu_feature_{choice}=\"{name}\"");
     }
 
-    cc_builder
-        .flag("-fno-stack-protector")
-        .flag("-Wno-expansion-to-defined")
-        .files(
-            fs::read_dir("src/c")
-                .expect("src/c directory missing")
-                .map(|res| res.expect("read_dir error").path()),
-        )
-        .compile("relibc_c");
-
-    println!("cargo:rustc-link-lib=static=relibc_c");
+    Some(())
+}
+
+fn main() {
+    println!("cargo::rustc-env=TARGET={}", env::var("TARGET").unwrap());
+    println!("cargo::rustc-check-cfg=cfg(dtb)");
+
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let arch_str = env::var("CARGO_CFG_TARGET_ARCH").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);
+            }
+        }
+        "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");
+        }
+        _ => (),
+    }
+
+    let _ = parse_kconfig(&arch_str);
 }

cbindgen.globdefs.toml

@@ -1,25 +0,0 @@
-
-# needs a leading newline
-[defines]
-"target_os=redox" = "__redox__"
-"target_os=linux" = "__linux__"
-"target_pointer_width=64" = "__LP64__"
-"target_pointer_width=32" = "__ILP32__"
-"target_arch=x86" = "__i386__"
-"target_arch=x86_64" = "__x86_64__"
-"target_arch=aarch64" = "__aarch64__"
-# This is not exact. It should be `defined(__riscv) && defined(__LP64__)`, or `defined(__riscv) && __riscv_xlen==64`
-# This will do however, as long as we only support riscv64 and not riscv32
-"target_arch=riscv64" = "__riscv"
-
-# XXX: silences a warning
-"feature = no_std" = "__relibc__"
-"feature = ip6" = "__ip6__"
-
-# Ensure attributes are passed down from Rust
-# <features.h> must be included where attributes are used in relibc
-[fn]
-must_use = "__nodiscard"
-deprecated = "__deprecated"
-deprecated_with_note = "__deprecatedNote({})"
-no_return = "__noreturn"

check.sh

@@ -1,170 +0,0 @@
-#!/bin/bash
-
-RED='\033[1;38;5;196m'
-GREEN='\033[1;38;5;46m'
-NC='\033[0m'
-
-show_help() {
-    echo "Usage: $(basename "$0") [OPTIONS]"
-    echo ""
-    echo "Description:"
-    echo "  Wrapper for Makefile / Cargo to run checks or tests on Redox OS targets."
-    echo ""
-    echo "Options:"
-    echo "  --test              Run 'make test' instead of 'make all'"
-    echo "  --test=             Run single 'make test'"
-    echo "  --cargo             Run 'cargo check' / 'cargo test' instead"
-    echo "                         (note: cargo test is currently not maintained for relibc)"
-    echo "  --host              Run the command on host (linux) target"
-    echo "  --all-target        Run the command on all supported Redox architectures"
-    echo "  --target=<target>   Override the target architecture (e.g., i586-unknown-redox)"
-    echo "  --arch=<arch>       Override the target architecture using arch (e.g., i586)"
-    echo "  --help              Show this help message"
-    echo ""
-    echo "Supported Targets:"
-    for t in "${SUPPORTED_TARGETS[@]}"; do
-        echo "  - $t"
-    done
-    echo "  - $(uname -m)-unknown-linux-gnu"
-    echo ""
-    echo "Environment:"
-    echo "  TARGET              Sets the default target (overridden by --target)"
-}
-
-if ! command -v cbindgen &> /dev/null; then
-    echo "Error: 'cbindgen' CLI not found."
-    echo "Please install it: cargo install cbindgen"
-    exit 1
-fi
-
-SUPPORTED_TARGETS=(
-    "x86_64-unknown-redox"
-    "i586-unknown-redox"
-    "aarch64-unknown-redox"
-    "riscv64gc-unknown-redox"
-)
-
-CURRENT_TARGET="${TARGET:-x86_64-unknown-redox}"
-CHECK_ALL=false
-CMD_ACTION="make"
-CARGO_ACTION="check"
-MAKE_ACTION="all"
-TEST_BIN=""
-IS_HOST=0
-
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --all-target)
-            CHECK_ALL=true
-            ;;
-        --test)
-            MAKE_ACTION="test"
-            CARGO_ACTION="test"
-            ;;
-        --test=*)
-            TEST_BIN="${1#*=}"
-            MAKE_ACTION="test-once"
-            ;;
-        --cargo)
-            CMD_ACTION="cargo"
-            ;;
-        --clippy)
-            CMD_ACTION="cargo"
-            CARGO_ACTION="clippy"
-            ;;
-        --host)
-            CURRENT_TARGET="$(uname -m)-unknown-linux-gnu"
-            IS_HOST=1
-            ;;
-        --target=*)
-            CURRENT_TARGET="${1#*=}"
-            ;;
-        --arch=*)
-            CURRENT_TARGET="${1#*=}-unknown-redox"
-            ;;
-        --help)
-            show_help
-            exit 0
-            ;;
-        *)
-            echo -e "${RED}Error: Unknown option '$1'${NC}"
-            show_help
-            exit 1
-            ;;
-    esac
-    shift
-done
-
-if [ "$IS_HOST" -eq 0 ]; then
-if ! command -v redoxer &> /dev/null; then
-    echo "Error: 'redoxer' CLI not found."
-    echo "Please install it: cargo install redoxer"
-    exit 1
-fi
-fi
-
-run_redoxer() {
-    export TARGET=$1
-    REDOXER_ENV="redoxer env"
-    if [ "$IS_HOST" -eq 0 ]; then
-        redoxer toolchain || { echo -e "${RED}Fail: redoxer toolchain for: $target.${NC}" && exit 1; }
-        export CARGO_TEST="redoxer"
-        export TEST_RUNNER="redoxer exec --folder ../../sysroot/$TARGET/:/usr --folder . --"
-
-        MAKE_ACTION="$MAKE_ACTION IS_REDOX=1"
-    else
-        REDOXER_ENV=""
-    fi
-
-    if [ "$TEST_BIN" != "" ]; then
-        if [ "$IS_HOST" -eq 0 ]; then
-            MAKE_ACTION="$MAKE_ACTION TESTBIN=bins_dynamic/$TEST_BIN"
-        else
-            MAKE_ACTION="$MAKE_ACTION TESTBIN=bins_static/$TEST_BIN"
-        fi
-    fi
-
-    if [ "$CMD_ACTION" == "make" ]; then
-        CMD_OPT="-j $(nproc) $MAKE_ACTION"
-    else
-        CMD_OPT="$CARGO_ACTION --target=$TARGET"
-    fi
-
-    echo "----------------------------------------"
-    echo "Running $REDOXER_ENV $CMD_ACTION $CMD_OPT for: $TARGET"
-    
-    if $REDOXER_ENV $CMD_ACTION $CMD_OPT; then
-        return 0
-    else
-        echo -e "${RED}Fail: $CMD_ACTION $CMD_OPT for $TARGET failed.${NC}"
-        return 1
-    fi
-}
-
-if [ "$CHECK_ALL" = true ]; then
-    echo "Running $CMD_ACTION for all supported Redox targets..."
-    
-    has_error=false
-    
-    for target in "${SUPPORTED_TARGETS[@]}"; do
-        if ! run_redoxer "$target"; then
-            has_error=true
-        fi
-    done
-    
-    echo "----------------------------------------"
-    if [ "$has_error" = true ]; then
-        echo -e "${RED}Summary: One or more targets failed.${NC}"
-        exit 1
-    else
-        echo -e "${GREEN}Summary: All targets passed!${NC}"
-        exit 0
-    fi
-else
-    if run_redoxer "$CURRENT_TARGET"; then
-        echo -e "${GREEN}Success: $CARGO_ACTION for $CURRENT_TARGET passed.${NC}"
-        exit 0
-    else
-        exit 1
-    fi
-fi

clippy.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+set -e
+
+export RUST_TARGET_PATH="${PWD}/targets"
+export RUSTFLAGS="-C debuginfo=2"
+cargo clippy --lib --release --target x86_64-unknown-none "$@"

config.mk

@@ -1,94 +0,0 @@
-ifndef TARGET
-	export TARGET:=$(shell rustc -Z unstable-options --print target-spec-json | grep llvm-target | cut -d '"' -f4)
-endif
-
-ifeq ($(TARGET),aarch64-unknown-linux-gnu)
-	export CC=aarch64-linux-gnu-gcc
-	export LD=aarch64-linux-gnu-ld
-	export AR=aarch64-linux-gnu-ar
-	export NM=aarch64-linux-gnu-nm
-	export OBJCOPY=aarch64-linux-gnu-objcopy
-	export CPPFLAGS=
-	LD_SONAME=ld.so.1
-endif
-
-ifeq ($(TARGET),aarch64-unknown-linux-relibc)
-	export CC=aarch64-linux-relibc-gcc
-	export LD=aarch64-linux-relibc-ld
-	export AR=aarch64-linux-relibc-ar
-	export NM=aarch64-linux-relibc-nm
-	export OBJCOPY=aarch64-linux-relibc-objcopy
-	export CPPFLAGS=
-	LD_SONAME=ld.so.1
-endif
-
-
-ifeq ($(TARGET),aarch64-unknown-redox)
-	export CC=aarch64-unknown-redox-gcc
-	export LD=aarch64-unknown-redox-ld
-	export AR=aarch64-unknown-redox-ar
-	export NM=aarch64-unknown-redox-nm
-	export OBJCOPY=aarch64-unknown-redox-objcopy
-	export CPPFLAGS=
-	LD_SONAME=ld.so.1
-endif
-
-ifeq ($(TARGET),i586-unknown-redox)
-	export CC=i586-unknown-redox-gcc
-	export LD=i586-unknown-redox-ld
-	export AR=i586-unknown-redox-ar
-	export NM=i586-unknown-redox-nm
-	export OBJCOPY=i586-unknown-redox-objcopy
-	export CPPFLAGS=
-	LD_SONAME=ld.so.1
-endif
-
-ifeq ($(TARGET),i686-unknown-redox)
-	export CC=i686-unknown-redox-gcc
-	export LD=i686-unknown-redox-ld
-	export AR=i686-unknown-redox-ar
-	export NM=i686-unknown-redox-nm
-	export OBJCOPY=i686-unknown-redox-objcopy
-	export CPPFLAGS=
-	LD_SONAME=ld.so.1
-endif
-
-ifeq ($(TARGET),x86_64-unknown-linux-gnu)
-	export CC=x86_64-linux-gnu-gcc
-	export LD=x86_64-linux-gnu-ld
-	export AR=x86_64-linux-gnu-ar
-	export NM=x86_64-linux-gnu-nm
-	export OBJCOPY=objcopy
-	export CPPFLAGS=
-	LD_SONAME=ld64.so.1
-endif
-
-ifeq ($(TARGET),x86_64-unknown-linux-relibc)
-	export CC=x86_64-linux-relibc-gcc
-	export LD=x86_64-linux-relibc-ld
-	export AR=x86_64-linux-relibc-ar
-	export NM=x86_64-linux-relibc-nm
-	export OBJCOPY=x86_64-linux-relibc-objcopy
-	export CPPFLAGS=
-	LD_SONAME=ld64.so.1
-endif
-
-ifeq ($(TARGET),x86_64-unknown-redox)
-	export CC=x86_64-unknown-redox-gcc
-	export LD=x86_64-unknown-redox-ld
-	export AR=x86_64-unknown-redox-ar
-	export NM=x86_64-unknown-redox-nm
-	export OBJCOPY=x86_64-unknown-redox-objcopy
-	export CPPFLAGS=
-	LD_SONAME=ld64.so.1
-endif
-
-ifeq ($(TARGET),riscv64gc-unknown-redox)
-	export CC=riscv64-unknown-redox-gcc
-	export LD=riscv64-unknown-redox-ld
-	export AR=riscv64-unknown-redox-ar
-	export NM=riscv64-unknown-redox-nm
-	export OBJCOPY=riscv64-unknown-redox-objcopy
-	export CPPFLAGS=-march=rv64gc -mabi=lp64d
-	LD_SONAME=ld.so.1
-endif

config.toml.example

@@ -0,0 +1,7 @@
+[arch.x86_64.features]
+smap = "auto"
+fsgsbase = "auto"
+xsave = "auto"
+xsaveopt = "auto"
+
+# vim: ft=toml

dynlst.txt

@@ -1,27 +0,0 @@
-{
-environ;
-
-stdin;
-stdout;
-stderr;
-
-timezone;
-daylight;
-tzname;
-__timezone;
-__daylight;
-__tzname;
-
-signgam;
-__signgam;
-
-optarg;
-optind;
-opterr;
-optreset;
-__optreset;
-
-getdate_err;
-
-__stack_chk_guard;
-};

fmt.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-
-cargo fmt --package relibc --package crt0 --package redox-rt "$@"

generic-rt/Cargo.toml

@@ -1,7 +0,0 @@
-[package]
-name = "generic-rt"
-version = "0.1.0"
-edition = "2024"
-
-[lints]
-workspace = true

generic-rt/src/lib.rs

@@ -1,99 +0,0 @@
-#![no_std]
-#![allow(internal_features)]
-#![deny(unsafe_op_in_unsafe_fn)]
-
-use core::{
-    arch::asm,
-    mem::{self, offset_of},
-};
-
-#[derive(Debug)]
-#[repr(C)]
-pub struct GenericTcb<Os> {
-    /// Pointer to the end of static TLS. Must be the first member
-    pub tls_end: *mut u8,
-    /// Size of the memory allocated for the static TLS in bytes (multiple of page size)
-    pub tls_len: usize,
-    /// Pointer to this structure
-    pub tcb_ptr: *mut Self,
-    /// Size of the memory allocated for this structure in bytes (should be same as page size)
-    pub tcb_len: usize,
-    pub os_specific: Os,
-}
-impl<Os> GenericTcb<Os> {
-    /// Architecture specific code to read a usize from the TCB - aarch64
-    #[allow(unsafe_op_in_unsafe_fn)]
-    #[inline(always)]
-    #[cfg(target_arch = "aarch64")]
-    pub unsafe fn arch_read(offset: usize) -> usize {
-        let abi_ptr: usize;
-        asm!(
-            "mrs {}, tpidr_el0",
-            out(reg) abi_ptr,
-        );
-
-        let tcb_ptr = *(abi_ptr as *const usize);
-        *((tcb_ptr + offset) as *const usize)
-    }
-
-    /// Architecture specific code to read a usize from the TCB - x86
-    #[allow(unsafe_op_in_unsafe_fn)]
-    #[inline(always)]
-    #[cfg(target_arch = "x86")]
-    pub unsafe fn arch_read(offset: usize) -> usize {
-        let value;
-        asm!(
-            "
-            mov {}, gs:[{}]
-            ",
-            out(reg) value,
-            in(reg) offset,
-        );
-        value
-    }
-
-    /// Architecture specific code to read a usize from the TCB - x86_64
-    #[allow(unsafe_op_in_unsafe_fn)]
-    #[inline(always)]
-    #[cfg(target_arch = "x86_64")]
-    pub unsafe fn arch_read(offset: usize) -> usize {
-        let value;
-        asm!(
-            "
-            mov {}, fs:[{}]
-            ",
-            out(reg) value,
-            in(reg) offset,
-        );
-        value
-    }
-
-    /// Architecture specific code to read a usize from the TCB - riscv64
-    #[allow(unsafe_op_in_unsafe_fn)]
-    #[inline(always)]
-    #[cfg(target_arch = "riscv64")]
-    unsafe fn arch_read(offset: usize) -> usize {
-        let value;
-        asm!(
-            "ld {value}, -8(tp)", // TCB
-            "add {value}, {value}, {offset}",
-            "ld {value}, 0({value})",
-            value = out(reg) value,
-            offset = in(reg) offset,
-        );
-        value
-    }
-
-    pub unsafe fn current_ptr() -> Option<*mut Self> {
-        let tcb_ptr = unsafe { Self::arch_read(offset_of!(Self, tcb_ptr)) as *mut Self };
-        let tcb_len = unsafe { Self::arch_read(offset_of!(Self, tcb_len)) };
-        if tcb_ptr.is_null() || tcb_len < mem::size_of::<Self>() {
-            None
-        } else {
-            Some(tcb_ptr)
-        }
-    }
-    pub unsafe fn current() -> Option<&'static mut Self> {
-        unsafe { Some(&mut *Self::current_ptr()?) }
-    }
-}

include/alloca.h

@@ -1,6 +0,0 @@
-#ifndef _ALLOCA_H
-#define _ALLOCA_H
-
-#define alloca(size) __builtin_alloca (size)
-
-#endif /* _ALLOCA_H */

include/ar.h

@@ -1,24 +0,0 @@
-/* ar.h — Unix archive (ar) file format.
- *
- * Red Bear OS / relibc. Defines the archive magic strings and per-member header
- * layout used by `ar(1)` archives (and consumed by libelf's archive support).
- * Header-only: purely a struct and string constants, no runtime symbols.
- */
-#ifndef _AR_H
-#define _AR_H 1
-
-#define ARMAG  "!<arch>\n"  /* String that begins an archive file.   */
-#define SARMAG 8            /* Size of ARMAG string.                 */
-#define ARFMAG "`\n"        /* String at the end of each header.     */
-
-struct ar_hdr {
-    char ar_name[16]; /* Member file name, blank/`/`-terminated. */
-    char ar_date[12]; /* File date, decimal seconds since epoch.  */
-    char ar_uid[6];   /* User id, in ASCII decimal.               */
-    char ar_gid[6];   /* Group id, in ASCII decimal.              */
-    char ar_mode[8];  /* File mode, in ASCII octal.               */
-    char ar_size[10]; /* File size, in ASCII decimal.             */
-    char ar_fmag[2];  /* Always contains ARFMAG.                  */
-};
-
-#endif /* ar.h */

include/byteswap.h

@@ -1,17 +0,0 @@
-/* byteswap.h — byte-order swapping macros.
- *
- * Red Bear OS / relibc. Mirrors the glibc <byteswap.h> interface. The macros
- * lower to the compiler byte-swap builtins, so they are constant-foldable and
- * need no runtime symbol. Provided because portable ELF/object tooling
- * (elfutils/libelf, etc.) uses bswap_16/32/64 directly.
- */
-#ifndef _BYTESWAP_H
-#define _BYTESWAP_H 1
-
-#include <stdint.h>
-
-#define bswap_16(x) __builtin_bswap16((uint16_t)(x))
-#define bswap_32(x) __builtin_bswap32((uint32_t)(x))
-#define bswap_64(x) __builtin_bswap64((uint64_t)(x))
-
-#endif /* byteswap.h */

include/complex.h

@@ -1 +0,0 @@
-#include <openlibm_complex.h>

include/error.h

@@ -1,40 +0,0 @@
-/* error.h — GNU-style error reporting.
- *
- * Red Bear OS / relibc. Mirrors glibc <error.h>: error() and error_at_line()
- * print the program name (best effort), a formatted message, and optionally a
- * strerror() of errnum to stderr, then exit() when status is non-zero.
- *
- * These are DECLARED here and IMPLEMENTED as real exported symbols in relibc
- * (src/header/error). They must NOT be static-inline: autotools/gnulib link-test
- * for a system error() and, finding one, skip compiling their own lib/error.c —
- * a header-only inline collides with that replacement ("redefinition of
- * 'error'", seen building m4/gnulib).
- */
-#ifndef _ERROR_H
-#define _ERROR_H 1
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Count of messages printed by error()/error_at_line(). */
-extern unsigned int error_message_count;
-
-/* When non-zero, error_at_line() prints each distinct file:line only once. */
-extern int error_one_per_line;
-
-/* Optional hook to print the program name instead of the default. */
-extern void (*error_print_progname)(void);
-
-extern void error(int __status, int __errnum, const char *__format, ...)
-    __attribute__((__format__(__printf__, 3, 4)));
-
-extern void error_at_line(int __status, int __errnum, const char *__fname,
-                          unsigned int __lineno, const char *__format, ...)
-    __attribute__((__format__(__printf__, 5, 6)));
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* error.h */

include/features.h

@@ -1,112 +0,0 @@
-/*
- * MIT License
- * Copyright (c) 2020 Rich Felker musl-libc
- */
-
-#ifndef _FEATURES_H__RELIBC
-#define _FEATURES_H__RELIBC
-
-// Version metadata for feature gating
-// This is useful for divergent implementation specific behavior
-// glibc, ulibc, and likely others define a similar macro
-// musl does not define an equivalent macro
-#define __RELIBC__ 1
-#define __RELIBC__MAJOR 0
-#define __RELIBC__MINOR 2
-
-/*
- * Sources:
- * https://en.cppreference.com/w/c/language/attributes
- * https://clang.llvm.org/docs/LanguageExtensions.html
- * https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005fc_005fattribute.html
- * https://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html
- */
-
-// Clang doesn't define __has_cpp_attribute if compiling C code
-#if !defined(__has_cpp_attribute)
-    #define __has_cpp_attribute(x) 0
-#endif
-
-// Clang doesn't define __has_c_attribute if compiling C++ code
-#if !defined(__has_c_attribute)
-    #define __has_c_attribute(x) 0
-#endif
-
-// Check if C23+ attributes are available
-#if defined(__cplusplus)
-// HACK: GCC backports C++ attributes to C++98 but doesn't accept attributes
-// placed before the function like cbindgen emits.
-// Let's just disable attributes for C++98 by checking if a random C++11
-// feature is available.
-#define __HAS_ATTRIBUTE(x) __cpp_variable_templates &&__has_cpp_attribute(x)
-#else
-#define __HAS_ATTRIBUTE(x)                                                     \
-  (__has_c_attribute(x) || __STDC_VERSION__ >= 202311L ||                      \
-   __has_cpp_attribute(x))
-#endif
-
-// From musl, license MIT {
-#if defined(_ALL_SOURCE) && !defined(_GNU_SOURCE)
-#define _GNU_SOURCE 1
-#endif
-
-#if defined(_DEFAULT_SOURCE) && !defined(_BSD_SOURCE)
-#define _BSD_SOURCE 1
-#endif
-
-#if !defined(_POSIX_SOURCE) && !defined(_POSIX_C_SOURCE) \
- && !defined(_XOPEN_SOURCE) && !defined(_GNU_SOURCE) \
- && !defined(_BSD_SOURCE) && !defined(__STRICT_ANSI__)
-#define _BSD_SOURCE 1
-#define _XOPEN_SOURCE 700
-#endif
-// } from musl
-
-// TODO: Not emitted with cbindgen
-#if __STDC_VERSION__ >= 199901L
-    #define __restrict restrict
-#elif !defined(__GNUC__)
-    #define __restrict
-#endif
-
-// TODO: Not emitted with cbindgen
-#if __STDC_VERSION__ >= 199901L || defined(__cplusplus)
-    #define __inline inline
-#elif !defined(__GNUC__)
-    #define __inline
-#endif
-
-// Analogous to Rust's Never type
-//TODO: clang fails to compile C with [[noreturn]]
-#if defined(__cplusplus) && __HAS_ATTRIBUTE(noreturn) && !(__clang__)
-    #define __noreturn [[noreturn]]
-// #elif __STDC_VERSION__ >= 201112L
-// FIXME: cbindgen incorrectly places _Noreturn
-// #define __noreturn _Noreturn
-#elif defined(__GNUC__)
-    #define __noreturn __attribute__((__noreturn__))
-#else
-    #define __noreturn
-#endif
-
-// Analogous to Rust's #[must_use]
-// C23 only
-#if __HAS_ATTRIBUTE(nodiscard)
-    #define __nodiscard [[nodiscard]]
-    #define __nodiscardNote(x) [[nodiscard(x)]]
-#else
-    #define __nodiscard
-    #define __nodiscardNote(x)
-#endif
-
-// Analogous to Rust's #[deprecated]
-// C23 only
-#if __HAS_ATTRIBUTE(deprecated)
-    #define __deprecated [[deprecated]]
-    #define __deprecatedNote(x) [[deprecated(x)]]
-#else
-    #define __deprecated
-    #define __deprecatedNote(x)
-#endif
-
-#endif

include/fenv.h

@@ -1,3 +0,0 @@
-#include <openlibm_fenv.h>
-#undef complex
-#undef I

include/iso646.h

@@ -1,22 +0,0 @@
-// Copied from musl
-
-#ifndef _ISO646_H
-#define _ISO646_H
-
-#ifndef __cplusplus
-
-#define and    &&
-#define and_eq &=
-#define bitand &
-#define bitor  |
-#define compl  ~
-#define not    !
-#define not_eq !=
-#define or     ||
-#define or_eq  |=
-#define xor    ^
-#define xor_eq ^=
-
-#endif
-
-#endif

include/libintl.h

@@ -1,74 +0,0 @@
-/* libintl.h — message translation (gettext) interface.
- *
- * Red Bear OS / relibc. Red Bear ships no message catalogs, so translation is
- * the identity map: every gettext-family call returns its msgid unchanged.
- * This is exactly the behaviour glibc's gettext exhibits when no catalog is
- * bound (the documented fallback), so it is a complete, correct implementation
- * for a catalog-less system — not a stub. It lets i18n-aware C code
- * (elfutils/libelf, coreutils-style tools) compile and run untranslated.
- */
-#ifndef _LIBINTL_H
-#define _LIBINTL_H 1
-
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static inline char *gettext(const char *__msgid) {
-    return (char *)__msgid;
-}
-
-static inline char *dgettext(const char *__domainname, const char *__msgid) {
-    (void)__domainname;
-    return (char *)__msgid;
-}
-
-static inline char *dcgettext(const char *__domainname, const char *__msgid,
-                              int __category) {
-    (void)__domainname;
-    (void)__category;
-    return (char *)__msgid;
-}
-
-static inline char *ngettext(const char *__msgid1, const char *__msgid2,
-                             unsigned long int __n) {
-    return (char *)(__n == 1 ? __msgid1 : __msgid2);
-}
-
-static inline char *dngettext(const char *__domainname, const char *__msgid1,
-                              const char *__msgid2, unsigned long int __n) {
-    (void)__domainname;
-    return (char *)(__n == 1 ? __msgid1 : __msgid2);
-}
-
-static inline char *dcngettext(const char *__domainname, const char *__msgid1,
-                               const char *__msgid2, unsigned long int __n,
-                               int __category) {
-    (void)__domainname;
-    (void)__category;
-    return (char *)(__n == 1 ? __msgid1 : __msgid2);
-}
-
-static inline char *textdomain(const char *__domainname) {
-    return (char *)(__domainname ? __domainname : "messages");
-}
-
-static inline char *bindtextdomain(const char *__domainname,
-                                   const char *__dirname) {
-    (void)__domainname;
-    return (char *)__dirname;
-}
-
-static inline char *bind_textdomain_codeset(const char *__domainname,
-                                            const char *__codeset) {
-    (void)__domainname;
-    return (char *)__codeset;
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* libintl.h */

include/link.h

@@ -1,59 +0,0 @@
-/*
- * link.h — dynamic-linker introspection (dl_iterate_phdr).
- *
- * Non-POSIX (glibc/BSD extension). The implementation of dl_iterate_phdr lives
- * in relibc's dynamic linker (src/header/link/mod.rs); this header only
- * declares the ABI. Keep `struct dl_phdr_info` in sync with the Rust
- * `DlPhdrInfo` struct in that module.
- */
-#ifndef _RELIBC_LINK_H
-#define _RELIBC_LINK_H
-
-#include <elf.h>
-#include <stddef.h>
-
-/*
- * glibc-compatible `ElfW(type)` macro: expands to the native-word-size ELF type
- * (Elf64_type on LP64, Elf32_type otherwise). Portable ELF code (Mesa's
- * util/build_id.c, unwinders) uses `ElfW(Nhdr)` etc. and expects <link.h> to
- * provide this.
- */
-#ifndef ElfW
-# if defined(__LP64__) || defined(_LP64) || (__SIZEOF_POINTER__ == 8)
-#  define ElfW(type) Elf64_##type
-# else
-#  define ElfW(type) Elf32_##type
-# endif
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct dl_phdr_info {
-    Elf64_Addr         dlpi_addr;      /* base / load bias of the object      */
-    const char        *dlpi_name;      /* object pathname (NUL-terminated)    */
-    const Elf64_Phdr  *dlpi_phdr;      /* pointer to the program header array */
-    Elf64_Half         dlpi_phnum;     /* number of program headers           */
-    /* glibc-compatible extension fields */
-    unsigned long long dlpi_adds;      /* # objects added since process start */
-    unsigned long long dlpi_subs;      /* # objects removed since start       */
-    size_t             dlpi_tls_modid; /* TLS module ID (0 if none)           */
-    void              *dlpi_tls_data;  /* TLS block for the calling thread    */
-};
-
-/*
- * Call `callback` once per loaded object. `size` is sizeof(struct dl_phdr_info).
- * Iteration stops as soon as a callback returns non-zero, and that value is
- * returned; otherwise the return value is that of the last callback (or 0 when
- * there are no objects).
- */
-int dl_iterate_phdr(int (*callback)(struct dl_phdr_info *info,
-                                    size_t size, void *data),
-                    void *data);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /* _RELIBC_LINK_H */

include/machine/endian.h

@@ -1,17 +0,0 @@
-#ifndef __MACHINE_ENDIAN_H__
-
-/* TODO: Forcing little endian, if you need a big endian system, fix this { */
-#ifndef BIG_ENDIAN
-#define BIG_ENDIAN 4321
-#endif
-
-#ifndef LITTLE_ENDIAN
-#define LITTLE_ENDIAN 1234
-#endif
-
-#ifndef BYTE_ORDER
-#define BYTE_ORDER LITTLE_ENDIAN
-#endif
-/* } */
-
-#endif /* __MACHINE_ENDIAN_H__ */

include/math.h

@@ -1,113 +0,0 @@
-#include <openlibm_math.h>
-
-// Missing typedefs
-typedef float float_t;
-typedef double double_t;
-
-/* double */
-
-#ifndef M_PI
-#define	M_PI		3.14159265358979323846	/* pi */
-#endif
-
-#ifndef M_PI_2
-#define	M_PI_2		1.57079632679489661923	/* pi/2 */
-#endif
-
-#ifndef M_PI_4
-#define	M_PI_4		0.78539816339744830962	/* pi/4 */
-#endif
-
-#ifndef M_2_PI
-#define M_2_PI		0.63661977236758134308	/* 2/pi */
-#endif
-
-#ifndef M_E
-#define M_E			2.7182818284590452354	/* e */
-#endif
-
-#ifndef M_LOG2E
-#define M_LOG2E		1.4426950408889634074	/* log_2 e */
-#endif
-
-#ifndef M_LOG10E
-#define M_LOG10E	0.43429448190325182765	/* log_10 e */
-#endif
-
-#ifndef M_LN2
-#define M_LN2		0.69314718055994530942	/* log_e 2 */
-#endif
-
-#ifndef M_LN10
-#define M_LN10		2.30258509299404568402	/* log_e 10 */
-#endif
-
-#ifndef M_1_PI
-#define M_1_PI		0.31830988618379067154	/* 1/pi */
-#endif
-
-#ifndef M_2_SQRTPI
-#define M_2_SQRTPI	1.12837916709551257390	/* 2/sqrt(pi) */
-#endif
-
-#ifndef M_SQRT2
-#define M_SQRT2		1.41421356237309504880	/* sqrt(2) */
-#endif
-
-#ifndef M_SQRT1_2
-#define M_SQRT1_2	0.70710678118654752440	/* 1/sqrt(2) */
-#endif
-
-/* long double */
-
-#ifndef M_El
-#define M_El        2.718281828459045235360287471352662498L /* e */
-#endif
-
-#ifndef M_LOG2El
-#define M_LOG2El    1.442695040888963407359924681001892137L /* log_2 e */
-#endif
-
-#ifndef M_LOG10El
-#define M_LOG10El   0.434294481903251827651128918916605082L /* log_10 e */
-#endif
-
-#ifndef M_LN2l
-#define M_LN2l      0.693147180559945309417232121458176568L /* log_e 2 */
-#endif
-
-#ifndef M_LN10l
-#define M_LN10l     2.302585092994045684017991454684364208L /* log_e 10 */
-#endif
-
-#ifndef M_PIl
-#define M_PIl       3.141592653589793238462643383279502884L /* pi */
-#endif
-
-#ifndef M_PI_2l
-#define M_PI_2l     1.570796326794896619231321691639751442L /* pi/2 */
-#endif
-
-#ifndef M_PI_4l
-#define M_PI_4l     0.785398163397448309615660845819875721L /* pi/4 */
-#endif
-
-#ifndef M_1_PIl
-#define M_1_PIl     0.318309886183790671537767526745028724L /* 1/pi */
-#endif
-
-#ifndef M_2_PIl
-#define M_2_PIl     0.636619772367581343075535053490057448L /* 2/pi */
-#endif
-
-#ifndef M_2_SQRTPIl
-#define M_2_SQRTPIl 1.128379167095512573896158903121545172L /* 2/sqrt(pi) */
-#endif
-
-#ifndef M_SQRT2l
-#define M_SQRT2l    1.414213562373095048801688724209698079L /* sqrt(2) */
-#endif
-
-#ifndef M_SQRT1_2l
-#define M_SQRT1_2l  0.707106781186547524400844362104849039L /* 1/sqrt(2) */
-#endif

include/memory.h

@@ -1 +0,0 @@
-#include <string.h>

include/netinet/in_systm.h

@@ -1,10 +0,0 @@
-#ifndef _NETINET_IN_SYSTM_H
-#define _NETINET_IN_SYSTM_H
-
-#include <stdint.h>
-
-typedef uint16_t n_short;
-typedef uint32_t n_long;
-typedef uint32_t n_time;
-
-#endif

include/paths.h

@@ -1,6 +0,0 @@
-#ifndef _RELIBC_PATHS_H
-#define _RELIBC_PATHS_H
-
-#define _PATH_BSHELL "/bin/sh"
-
-#endif

include/search.h

@@ -1,40 +0,0 @@
-/* search.h — POSIX search tables.
- *
- * Red Bear OS / relibc. Provides the binary-tree search family (tsearch,
- * tfind, tdelete, twalk) plus the GNU tdestroy extension. Implemented in
- * src/header/search/mod.rs; the VISIT enum order below MUST match the
- * PREORDER/POSTORDER/ENDORDER/LEAF constants there.
- */
-#ifndef _SEARCH_H
-#define _SEARCH_H 1
-
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
-    preorder,
-    postorder,
-    endorder,
-    leaf
-} VISIT;
-
-void *tsearch(const void *__key, void **__rootp,
-              int (*__compar)(const void *, const void *));
-void *tfind(const void *__key, void *const *__rootp,
-            int (*__compar)(const void *, const void *));
-void *tdelete(const void *__key, void **__rootp,
-              int (*__compar)(const void *, const void *));
-void twalk(const void *__root,
-           void (*__action)(const void *__nodep, VISIT __which, int __depth));
-
-/* GNU extension. */
-void tdestroy(void *__root, void (*__free_node)(void *__nodep));
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* search.h */

include/setjmp.h

@@ -1,35 +0,0 @@
-#ifndef _SETJMP_H
-#define _SETJMP_H
-
-#ifdef __aarch64__
-typedef unsigned long long jmp_buf[22];
-#endif
-
-#ifdef __i386__
-typedef unsigned long long jmp_buf[6];
-#endif
-
-#ifdef __x86_64__
-typedef unsigned long long jmp_buf[16];
-#endif
-
-#ifdef __riscv
-typedef unsigned long long jmp_buf[26];
-#endif
-
-typedef jmp_buf sigjmp_buf;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int setjmp(jmp_buf buf);
-void longjmp(jmp_buf buf, int value);
-int sigsetjmp(jmp_buf buf, int savemask);
-int siglongjmp(jmp_buf buf, int savemask);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif /* _SETJMP_H */

include/stdatomic.h

@@ -1,243 +0,0 @@
-/* Copyright (C) 2013-2022 Free Software Foundation, Inc.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 3, or (at your option)
-any later version.
-
-GCC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-Under Section 7 of GPL version 3, you are granted additional
-permissions described in the GCC Runtime Library Exception, version
-3.1, as published by the Free Software Foundation.
-
-You should have received a copy of the GNU General Public License and
-a copy of the GCC Runtime Library Exception along with this program;
-see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-<http://www.gnu.org/licenses/>.  */
-
-/* ISO C11 Standard:  7.17  Atomics <stdatomic.h>.  */
-
-#ifndef _STDATOMIC_H
-#define _STDATOMIC_H
-
-typedef enum
-  {
-    memory_order_relaxed = __ATOMIC_RELAXED,
-    memory_order_consume = __ATOMIC_CONSUME,
-    memory_order_acquire = __ATOMIC_ACQUIRE,
-    memory_order_release = __ATOMIC_RELEASE,
-    memory_order_acq_rel = __ATOMIC_ACQ_REL,
-    memory_order_seq_cst = __ATOMIC_SEQ_CST
-  } memory_order;
-
-
-typedef _Atomic _Bool atomic_bool;
-typedef _Atomic char atomic_char;
-typedef _Atomic signed char atomic_schar;
-typedef _Atomic unsigned char atomic_uchar;
-typedef _Atomic short atomic_short;
-typedef _Atomic unsigned short atomic_ushort;
-typedef _Atomic int atomic_int;
-typedef _Atomic unsigned int atomic_uint;
-typedef _Atomic long atomic_long;
-typedef _Atomic unsigned long atomic_ulong;
-typedef _Atomic long long atomic_llong;
-typedef _Atomic unsigned long long atomic_ullong;
-typedef _Atomic __CHAR16_TYPE__ atomic_char16_t;
-typedef _Atomic __CHAR32_TYPE__ atomic_char32_t;
-typedef _Atomic __WCHAR_TYPE__ atomic_wchar_t;
-typedef _Atomic __INT_LEAST8_TYPE__ atomic_int_least8_t;
-typedef _Atomic __UINT_LEAST8_TYPE__ atomic_uint_least8_t;
-typedef _Atomic __INT_LEAST16_TYPE__ atomic_int_least16_t;
-typedef _Atomic __UINT_LEAST16_TYPE__ atomic_uint_least16_t;
-typedef _Atomic __INT_LEAST32_TYPE__ atomic_int_least32_t;
-typedef _Atomic __UINT_LEAST32_TYPE__ atomic_uint_least32_t;
-typedef _Atomic __INT_LEAST64_TYPE__ atomic_int_least64_t;
-typedef _Atomic __UINT_LEAST64_TYPE__ atomic_uint_least64_t;
-typedef _Atomic __INT_FAST8_TYPE__ atomic_int_fast8_t;
-typedef _Atomic __UINT_FAST8_TYPE__ atomic_uint_fast8_t;
-typedef _Atomic __INT_FAST16_TYPE__ atomic_int_fast16_t;
-typedef _Atomic __UINT_FAST16_TYPE__ atomic_uint_fast16_t;
-typedef _Atomic __INT_FAST32_TYPE__ atomic_int_fast32_t;
-typedef _Atomic __UINT_FAST32_TYPE__ atomic_uint_fast32_t;
-typedef _Atomic __INT_FAST64_TYPE__ atomic_int_fast64_t;
-typedef _Atomic __UINT_FAST64_TYPE__ atomic_uint_fast64_t;
-typedef _Atomic __INTPTR_TYPE__ atomic_intptr_t;
-typedef _Atomic __UINTPTR_TYPE__ atomic_uintptr_t;
-typedef _Atomic __SIZE_TYPE__ atomic_size_t;
-typedef _Atomic __PTRDIFF_TYPE__ atomic_ptrdiff_t;
-typedef _Atomic __INTMAX_TYPE__ atomic_intmax_t;
-typedef _Atomic __UINTMAX_TYPE__ atomic_uintmax_t;        
-
-
-#define ATOMIC_VAR_INIT(VALUE)	(VALUE)
-
-/* Initialize an atomic object pointed to by PTR with VAL.  */
-#define atomic_init(PTR, VAL)                           \
-  atomic_store_explicit (PTR, VAL, __ATOMIC_RELAXED)
-
-#define kill_dependency(Y)			\
-  __extension__					\
-  ({						\
-    __auto_type __kill_dependency_tmp = (Y);	\
-    __kill_dependency_tmp;			\
-  })
-
-extern void atomic_thread_fence (memory_order);
-#define atomic_thread_fence(MO)	__atomic_thread_fence (MO)
-extern void atomic_signal_fence (memory_order);
-#define atomic_signal_fence(MO)	__atomic_signal_fence  (MO)
-#define atomic_is_lock_free(OBJ) __atomic_is_lock_free (sizeof (*(OBJ)), (OBJ))
-
-#define ATOMIC_BOOL_LOCK_FREE		__GCC_ATOMIC_BOOL_LOCK_FREE
-#define ATOMIC_CHAR_LOCK_FREE		__GCC_ATOMIC_CHAR_LOCK_FREE
-#define ATOMIC_CHAR16_T_LOCK_FREE	__GCC_ATOMIC_CHAR16_T_LOCK_FREE
-#define ATOMIC_CHAR32_T_LOCK_FREE	__GCC_ATOMIC_CHAR32_T_LOCK_FREE
-#define ATOMIC_WCHAR_T_LOCK_FREE	__GCC_ATOMIC_WCHAR_T_LOCK_FREE
-#define ATOMIC_SHORT_LOCK_FREE		__GCC_ATOMIC_SHORT_LOCK_FREE
-#define ATOMIC_INT_LOCK_FREE		__GCC_ATOMIC_INT_LOCK_FREE
-#define ATOMIC_LONG_LOCK_FREE		__GCC_ATOMIC_LONG_LOCK_FREE
-#define ATOMIC_LLONG_LOCK_FREE		__GCC_ATOMIC_LLONG_LOCK_FREE
-#define ATOMIC_POINTER_LOCK_FREE	__GCC_ATOMIC_POINTER_LOCK_FREE
-
-
-/* Note that these macros require __auto_type to remove
-   _Atomic qualifiers (and const qualifiers, if those are valid on
-   macro operands).
-   
-   Also note that the header file uses the generic form of __atomic
-   builtins, which requires the address to be taken of the value
-   parameter, and then we pass that value on.  This allows the macros
-   to work for any type, and the compiler is smart enough to convert
-   these to lock-free _N variants if possible, and throw away the
-   temps.  */
-
-#define atomic_store_explicit(PTR, VAL, MO)				\
-  __extension__								\
-  ({									\
-    __auto_type __atomic_store_ptr = (PTR);				\
-    __typeof__ ((void)0, *__atomic_store_ptr) __atomic_store_tmp = (VAL);	\
-    __atomic_store (__atomic_store_ptr, &__atomic_store_tmp, (MO));	\
-  })
-
-#define atomic_store(PTR, VAL)				\
-  atomic_store_explicit (PTR, VAL, __ATOMIC_SEQ_CST)
-
-
-#define atomic_load_explicit(PTR, MO)					\
-  __extension__								\
-  ({									\
-    __auto_type __atomic_load_ptr = (PTR);				\
-    __typeof__ ((void)0, *__atomic_load_ptr) __atomic_load_tmp;			\
-    __atomic_load (__atomic_load_ptr, &__atomic_load_tmp, (MO));	\
-    __atomic_load_tmp;							\
-  })
-
-#define atomic_load(PTR)  atomic_load_explicit (PTR, __ATOMIC_SEQ_CST)
-
-
-#define atomic_exchange_explicit(PTR, VAL, MO)				\
-  __extension__								\
-  ({									\
-    __auto_type __atomic_exchange_ptr = (PTR);				\
-    __typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_val = (VAL);	\
-    __typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_tmp;		\
-    __atomic_exchange (__atomic_exchange_ptr, &__atomic_exchange_val,	\
-		       &__atomic_exchange_tmp, (MO));			\
-    __atomic_exchange_tmp;						\
-  })
-
-#define atomic_exchange(PTR, VAL) 			\
-  atomic_exchange_explicit (PTR, VAL, __ATOMIC_SEQ_CST)
-
-
-#define atomic_compare_exchange_strong_explicit(PTR, VAL, DES, SUC, FAIL) \
-  __extension__								\
-  ({									\
-    __auto_type __atomic_compare_exchange_ptr = (PTR);			\
-    __typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
-      = (DES);								\
-    __atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL),	\
-			       &__atomic_compare_exchange_tmp, 0,	\
-			       (SUC), (FAIL));				\
-  })
-
-#define atomic_compare_exchange_strong(PTR, VAL, DES) 			   \
-  atomic_compare_exchange_strong_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \
-					   __ATOMIC_SEQ_CST)
-
-#define atomic_compare_exchange_weak_explicit(PTR, VAL, DES, SUC, FAIL) \
-  __extension__								\
-  ({									\
-    __auto_type __atomic_compare_exchange_ptr = (PTR);			\
-    __typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
-      = (DES);								\
-    __atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL),	\
-			       &__atomic_compare_exchange_tmp, 1,	\
-			       (SUC), (FAIL));				\
-  })
-
-#define atomic_compare_exchange_weak(PTR, VAL, DES)			\
-  atomic_compare_exchange_weak_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \
-					 __ATOMIC_SEQ_CST)
-
-
-
-#define atomic_fetch_add(PTR, VAL) __atomic_fetch_add ((PTR), (VAL), 	\
-						       __ATOMIC_SEQ_CST)
-#define atomic_fetch_add_explicit(PTR, VAL, MO) 			\
-			  __atomic_fetch_add ((PTR), (VAL), (MO))
-
-#define atomic_fetch_sub(PTR, VAL) __atomic_fetch_sub ((PTR), (VAL), 	\
-						       __ATOMIC_SEQ_CST)
-#define atomic_fetch_sub_explicit(PTR, VAL, MO) 			\
-			  __atomic_fetch_sub ((PTR), (VAL), (MO))
-
-#define atomic_fetch_or(PTR, VAL) __atomic_fetch_or ((PTR), (VAL), 	\
-						       __ATOMIC_SEQ_CST)
-#define atomic_fetch_or_explicit(PTR, VAL, MO) 			\
-			  __atomic_fetch_or ((PTR), (VAL), (MO))
-
-#define atomic_fetch_xor(PTR, VAL) __atomic_fetch_xor ((PTR), (VAL), 	\
-						       __ATOMIC_SEQ_CST)
-#define atomic_fetch_xor_explicit(PTR, VAL, MO) 			\
-			  __atomic_fetch_xor ((PTR), (VAL), (MO))
-
-#define atomic_fetch_and(PTR, VAL) __atomic_fetch_and ((PTR), (VAL), 	\
-						       __ATOMIC_SEQ_CST)
-#define atomic_fetch_and_explicit(PTR, VAL, MO) 			\
-			  __atomic_fetch_and ((PTR), (VAL), (MO))
-
-
-typedef _Atomic struct
-{
-#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1
-  _Bool __val;
-#else
-  unsigned char __val;
-#endif
-} atomic_flag;
-
-#define ATOMIC_FLAG_INIT	{ 0 }
-
-
-extern _Bool atomic_flag_test_and_set (volatile atomic_flag *);
-#define atomic_flag_test_and_set(PTR) 					\
-			__atomic_test_and_set ((PTR), __ATOMIC_SEQ_CST)
-extern _Bool atomic_flag_test_and_set_explicit (volatile atomic_flag *,
-						memory_order);
-#define atomic_flag_test_and_set_explicit(PTR, MO)			\
-			__atomic_test_and_set ((PTR), (MO))
-
-extern void atomic_flag_clear (volatile atomic_flag *);
-#define atomic_flag_clear(PTR)	__atomic_clear ((PTR), __ATOMIC_SEQ_CST)
-extern void atomic_flag_clear_explicit (volatile atomic_flag *, memory_order);
-#define atomic_flag_clear_explicit(PTR, MO)   __atomic_clear ((PTR), (MO))
-
-#endif  /* _STDATOMIC_H */

include/stdbool.h

@@ -1,18 +0,0 @@
-#ifndef _STDBOOL_H
-#define _STDBOOL_H
-
-#ifndef __cplusplus
-#define bool _Bool
-#define true 1
-#define false 0
-#else /* __cplusplus */
-#if __cplusplus < 201103L
-#define bool bool
-#define false false
-#define true true
-#endif /*__cplusplus < 201103L*/
-#endif /* __cplusplus */
-
-#define __bool_true_false_are_defined 1
-
-#endif /* _STDBOOL_H */

include/stdint.h

@@ -1,370 +0,0 @@
-/* Copyright (C) 2008-2018 Free Software Foundation, Inc.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 3, or (at your option)
-any later version.
-
-GCC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-Under Section 7 of GPL version 3, you are granted additional
-permissions described in the GCC Runtime Library Exception, version
-3.1, as published by the Free Software Foundation.
-
-You should have received a copy of the GNU General Public License and
-a copy of the GCC Runtime Library Exception along with this program;
-see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-<http://www.gnu.org/licenses/>.  */
-
-/*
- * ISO C Standard:  7.18  Integer types  <stdint.h>
- */
-
-#ifndef _STDINT_H
-#define _STDINT_H
-
-/* 7.8.1.1 Exact-width integer types */
-
-#ifdef __INT8_TYPE__
-typedef __INT8_TYPE__ int8_t;
-#endif
-#ifdef __INT16_TYPE__
-typedef __INT16_TYPE__ int16_t;
-#endif
-#ifdef __INT32_TYPE__
-typedef __INT32_TYPE__ int32_t;
-#endif
-#ifdef __INT64_TYPE__
-typedef __INT64_TYPE__ int64_t;
-#endif
-#ifdef __UINT8_TYPE__
-typedef __UINT8_TYPE__ uint8_t;
-typedef __UINT8_TYPE__ u_int8_t;
-#endif
-#ifdef __UINT16_TYPE__
-typedef __UINT16_TYPE__ uint16_t;
-typedef __UINT16_TYPE__ u_int16_t;
-#endif
-#include <bits/uint32-t.h> // for uint32_t
-#ifdef __UINT64_TYPE__
-typedef __UINT64_TYPE__ uint64_t;
-typedef __UINT64_TYPE__ u_int64_t;
-// Required by openlibm
-typedef __UINT64_TYPE__ __uint64_t;
-#endif
-
-/* 7.8.1.2 Minimum-width integer types */
-
-typedef __INT_LEAST8_TYPE__ int_least8_t;
-typedef __INT_LEAST16_TYPE__ int_least16_t;
-typedef __INT_LEAST32_TYPE__ int_least32_t;
-typedef __INT_LEAST64_TYPE__ int_least64_t;
-typedef __UINT_LEAST8_TYPE__ uint_least8_t;
-typedef __UINT_LEAST16_TYPE__ uint_least16_t;
-typedef __UINT_LEAST32_TYPE__ uint_least32_t;
-typedef __UINT_LEAST64_TYPE__ uint_least64_t;
-
-/* 7.8.1.3 Fastest minimum-width integer types */
-
-typedef __INT_FAST8_TYPE__ int_fast8_t;
-typedef __INT_FAST16_TYPE__ int_fast16_t;
-typedef __INT_FAST32_TYPE__ int_fast32_t;
-typedef __INT_FAST64_TYPE__ int_fast64_t;
-typedef __UINT_FAST8_TYPE__ uint_fast8_t;
-typedef __UINT_FAST16_TYPE__ uint_fast16_t;
-typedef __UINT_FAST32_TYPE__ uint_fast32_t;
-typedef __UINT_FAST64_TYPE__ uint_fast64_t;
-
-/* 7.8.1.4 Integer types capable of holding object pointers */
-
-#include <bits/intptr-t.h> // for intptr_t
-#ifdef __UINTPTR_TYPE__
-typedef __UINTPTR_TYPE__ uintptr_t;
-#endif
-
-/* 7.8.1.5 Greatest-width integer types */
-
-typedef __INTMAX_TYPE__ intmax_t;
-typedef __UINTMAX_TYPE__ uintmax_t;
-
-#if (!defined __cplusplus || __cplusplus >= 201103L \
-     || defined __STDC_LIMIT_MACROS)
-
-/* 7.18.2 Limits of specified-width integer types */
-
-#ifdef __INT8_MAX__
-# undef INT8_MAX
-# define INT8_MAX __INT8_MAX__
-# undef INT8_MIN
-# define INT8_MIN (-INT8_MAX - 1)
-#endif
-#ifdef __UINT8_MAX__
-# undef UINT8_MAX
-# define UINT8_MAX __UINT8_MAX__
-#endif
-#ifdef __INT16_MAX__
-# undef INT16_MAX
-# define INT16_MAX __INT16_MAX__
-# undef INT16_MIN
-# define INT16_MIN (-INT16_MAX - 1)
-#endif
-#ifdef __UINT16_MAX__
-# undef UINT16_MAX
-# define UINT16_MAX __UINT16_MAX__
-#endif
-#ifdef __INT32_MAX__
-# undef INT32_MAX
-# define INT32_MAX __INT32_MAX__
-# undef INT32_MIN
-# define INT32_MIN (-INT32_MAX - 1)
-#endif
-#ifdef __UINT32_MAX__
-# undef UINT32_MAX
-# define UINT32_MAX __UINT32_MAX__
-#endif
-#ifdef __INT64_MAX__
-# undef INT64_MAX
-# define INT64_MAX __INT64_MAX__
-# undef INT64_MIN
-# define INT64_MIN (-INT64_MAX - 1)
-#endif
-#ifdef __UINT64_MAX__
-# undef UINT64_MAX
-# define UINT64_MAX __UINT64_MAX__
-#endif
-
-#undef INT_LEAST8_MAX
-#define INT_LEAST8_MAX __INT_LEAST8_MAX__
-#undef INT_LEAST8_MIN
-#define INT_LEAST8_MIN (-INT_LEAST8_MAX - 1)
-#undef UINT_LEAST8_MAX
-#define UINT_LEAST8_MAX __UINT_LEAST8_MAX__
-#undef INT_LEAST16_MAX
-#define INT_LEAST16_MAX __INT_LEAST16_MAX__
-#undef INT_LEAST16_MIN
-#define INT_LEAST16_MIN (-INT_LEAST16_MAX - 1)
-#undef UINT_LEAST16_MAX
-#define UINT_LEAST16_MAX __UINT_LEAST16_MAX__
-#undef INT_LEAST32_MAX
-#define INT_LEAST32_MAX __INT_LEAST32_MAX__
-#undef INT_LEAST32_MIN
-#define INT_LEAST32_MIN (-INT_LEAST32_MAX - 1)
-#undef UINT_LEAST32_MAX
-#define UINT_LEAST32_MAX __UINT_LEAST32_MAX__
-#undef INT_LEAST64_MAX
-#define INT_LEAST64_MAX __INT_LEAST64_MAX__
-#undef INT_LEAST64_MIN
-#define INT_LEAST64_MIN (-INT_LEAST64_MAX - 1)
-#undef UINT_LEAST64_MAX
-#define UINT_LEAST64_MAX __UINT_LEAST64_MAX__
-
-#undef INT_FAST8_MAX
-#define INT_FAST8_MAX __INT_FAST8_MAX__
-#undef INT_FAST8_MIN
-#define INT_FAST8_MIN (-INT_FAST8_MAX - 1)
-#undef UINT_FAST8_MAX
-#define UINT_FAST8_MAX __UINT_FAST8_MAX__
-#undef INT_FAST16_MAX
-#define INT_FAST16_MAX __INT_FAST16_MAX__
-#undef INT_FAST16_MIN
-#define INT_FAST16_MIN (-INT_FAST16_MAX - 1)
-#undef UINT_FAST16_MAX
-#define UINT_FAST16_MAX __UINT_FAST16_MAX__
-#undef INT_FAST32_MAX
-#define INT_FAST32_MAX __INT_FAST32_MAX__
-#undef INT_FAST32_MIN
-#define INT_FAST32_MIN (-INT_FAST32_MAX - 1)
-#undef UINT_FAST32_MAX
-#define UINT_FAST32_MAX __UINT_FAST32_MAX__
-#undef INT_FAST64_MAX
-#define INT_FAST64_MAX __INT_FAST64_MAX__
-#undef INT_FAST64_MIN
-#define INT_FAST64_MIN (-INT_FAST64_MAX - 1)
-#undef UINT_FAST64_MAX
-#define UINT_FAST64_MAX __UINT_FAST64_MAX__
-
-#ifdef __INTPTR_MAX__
-# undef INTPTR_MAX
-# define INTPTR_MAX __INTPTR_MAX__
-# undef INTPTR_MIN
-# define INTPTR_MIN (-INTPTR_MAX - 1)
-#endif
-#ifdef __UINTPTR_MAX__
-# undef UINTPTR_MAX
-# define UINTPTR_MAX __UINTPTR_MAX__
-#endif
-
-#undef INTMAX_MAX
-#define INTMAX_MAX __INTMAX_MAX__
-#undef INTMAX_MIN
-#define INTMAX_MIN (-INTMAX_MAX - 1)
-#undef UINTMAX_MAX
-#define UINTMAX_MAX __UINTMAX_MAX__
-
-/* 7.18.3 Limits of other integer types */
-
-#undef PTRDIFF_MAX
-#define PTRDIFF_MAX __PTRDIFF_MAX__
-#undef PTRDIFF_MIN
-#define PTRDIFF_MIN (-PTRDIFF_MAX - 1)
-
-#undef SIG_ATOMIC_MAX
-#define SIG_ATOMIC_MAX __SIG_ATOMIC_MAX__
-#undef SIG_ATOMIC_MIN
-#define SIG_ATOMIC_MIN __SIG_ATOMIC_MIN__
-
-#undef SIZE_MAX
-#define SIZE_MAX __SIZE_MAX__
-
-#undef WCHAR_MAX
-#define WCHAR_MAX __WCHAR_MAX__
-#undef WCHAR_MIN
-#define WCHAR_MIN __WCHAR_MIN__
-
-#undef WINT_MAX
-#define WINT_MAX __WINT_MAX__
-#undef WINT_MIN
-#define WINT_MIN __WINT_MIN__
-
-#endif /* (!defined __cplusplus || __cplusplus >= 201103L
-	   || defined __STDC_LIMIT_MACROS)  */
-
-#if (!defined __cplusplus || __cplusplus >= 201103L \
-     || defined __STDC_CONSTANT_MACROS)
-
-#undef INT8_C
-#define INT8_C(c) __INT8_C(c)
-#undef INT16_C
-#define INT16_C(c) __INT16_C(c)
-#undef INT32_C
-#define INT32_C(c) __INT32_C(c)
-#undef INT64_C
-#define INT64_C(c) __INT64_C(c)
-#undef UINT8_C
-#define UINT8_C(c) __UINT8_C(c)
-#undef UINT16_C
-#define UINT16_C(c) __UINT16_C(c)
-#undef UINT32_C
-#define UINT32_C(c) __UINT32_C(c)
-#undef UINT64_C
-#define UINT64_C(c) __UINT64_C(c)
-#undef INTMAX_C
-#define INTMAX_C(c) __INTMAX_C(c)
-#undef UINTMAX_C
-#define UINTMAX_C(c) __UINTMAX_C(c)
-
-#endif /* (!defined __cplusplus || __cplusplus >= 201103L
-	   || defined __STDC_CONSTANT_MACROS) */
-
-#ifdef __STDC_WANT_IEC_60559_BFP_EXT__
-/* TS 18661-1 widths of integer types.  */
-
-#ifdef __INT8_TYPE__
-# undef INT8_WIDTH
-# define INT8_WIDTH 8
-#endif
-#ifdef __UINT8_TYPE__
-# undef UINT8_WIDTH
-# define UINT8_WIDTH 8
-#endif
-#ifdef __INT16_TYPE__
-# undef INT16_WIDTH
-# define INT16_WIDTH 16
-#endif
-#ifdef __UINT16_TYPE__
-# undef UINT16_WIDTH
-# define UINT16_WIDTH 16
-#endif
-#ifdef __INT32_TYPE__
-# undef INT32_WIDTH
-# define INT32_WIDTH 32
-#endif
-#ifdef __UINT32_TYPE__
-# undef UINT32_WIDTH
-# define UINT32_WIDTH 32
-#endif
-#ifdef __INT64_TYPE__
-# undef INT64_WIDTH
-# define INT64_WIDTH 64
-#endif
-#ifdef __UINT64_TYPE__
-# undef UINT64_WIDTH
-# define UINT64_WIDTH 64
-#endif
-
-#undef INT_LEAST8_WIDTH
-#define INT_LEAST8_WIDTH __INT_LEAST8_WIDTH__
-#undef UINT_LEAST8_WIDTH
-#define UINT_LEAST8_WIDTH __INT_LEAST8_WIDTH__
-#undef INT_LEAST16_WIDTH
-#define INT_LEAST16_WIDTH __INT_LEAST16_WIDTH__
-#undef UINT_LEAST16_WIDTH
-#define UINT_LEAST16_WIDTH __INT_LEAST16_WIDTH__
-#undef INT_LEAST32_WIDTH
-#define INT_LEAST32_WIDTH __INT_LEAST32_WIDTH__
-#undef UINT_LEAST32_WIDTH
-#define UINT_LEAST32_WIDTH __INT_LEAST32_WIDTH__
-#undef INT_LEAST64_WIDTH
-#define INT_LEAST64_WIDTH __INT_LEAST64_WIDTH__
-#undef UINT_LEAST64_WIDTH
-#define UINT_LEAST64_WIDTH __INT_LEAST64_WIDTH__
-
-#undef INT_FAST8_WIDTH
-#define INT_FAST8_WIDTH __INT_FAST8_WIDTH__
-#undef UINT_FAST8_WIDTH
-#define UINT_FAST8_WIDTH __INT_FAST8_WIDTH__
-#undef INT_FAST16_WIDTH
-#define INT_FAST16_WIDTH __INT_FAST16_WIDTH__
-#undef UINT_FAST16_WIDTH
-#define UINT_FAST16_WIDTH __INT_FAST16_WIDTH__
-#undef INT_FAST32_WIDTH
-#define INT_FAST32_WIDTH __INT_FAST32_WIDTH__
-#undef UINT_FAST32_WIDTH
-#define UINT_FAST32_WIDTH __INT_FAST32_WIDTH__
-#undef INT_FAST64_WIDTH
-#define INT_FAST64_WIDTH __INT_FAST64_WIDTH__
-#undef UINT_FAST64_WIDTH
-#define UINT_FAST64_WIDTH __INT_FAST64_WIDTH__
-
-#ifdef __INTPTR_TYPE__
-# undef INTPTR_WIDTH
-# define INTPTR_WIDTH __INTPTR_WIDTH__
-#endif
-#ifdef __UINTPTR_TYPE__
-# undef UINTPTR_WIDTH
-# define UINTPTR_WIDTH __INTPTR_WIDTH__
-#endif
-
-#undef INTMAX_WIDTH
-#define INTMAX_WIDTH __INTMAX_WIDTH__
-#undef UINTMAX_WIDTH
-#define UINTMAX_WIDTH __INTMAX_WIDTH__
-
-#undef PTRDIFF_WIDTH
-#define PTRDIFF_WIDTH __PTRDIFF_WIDTH__
-
-#undef SIG_ATOMIC_WIDTH
-#define SIG_ATOMIC_WIDTH __SIG_ATOMIC_WIDTH__
-
-#undef SIZE_WIDTH
-#define SIZE_WIDTH __SIZE_WIDTH__
-
-#undef WCHAR_WIDTH
-#define WCHAR_WIDTH __WCHAR_WIDTH__
-
-#undef WINT_WIDTH
-#define WINT_WIDTH __WINT_WIDTH__
-
-#ifdef __ILP32__
-#define SIZE_MAX UINT32_MAX
-#else
-#define SIZE_MAX UINT64_MAX
-#endif
-#endif
-
-#endif /* _GCC_STDINT_H */

include/stdio_ext.h

@@ -1,22 +0,0 @@
-#ifndef _STDIO_EXT_H
-#define _STDIO_EXT_H
-
-#include <stdio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-size_t __freadahead(FILE *stream);
-size_t __fpending(FILE *stream);
-int __freadable(FILE *stream);
-int __freading(FILE *stream);
-void __fseterr(FILE *stream);
-int __fwritable(FILE *stream);
-int __fwriting(FILE *stream);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif /* _STDIO_EXT_H */

include/stdnoreturn.h

@@ -1,19 +0,0 @@
-/* Spec:
- * The <stdnoreturn.h> header shall define the macro noreturn which shall
- * expand to _Noreturn */
-
-#ifndef _STDNORETURN_H
-#define _STDNORETURN_H
-
-#ifndef __cplusplus
-/* Borrowed from musl */
-#if __STDC_VERSION__ >= 201112L
-#elif defined(__GNUC__)
-    #define _Noreturn __attribute__((__noreturn__))
-#else
-    #define _Noreturn
-#endif
-#define noreturn _Noreturn
-#endif
-
-#endif

include/sys/ioccom.h

@@ -1,97 +0,0 @@
-#ifndef _SYS_IOCCOM_H
-#define _SYS_IOCCOM_H
-
-// Linux-compatible ioctl command encoding constants — supplements the
-// base _IOC / _IO / _IOR / _IOW / _IOWR macros from <sys/ioctl.h> with
-// the bitfield widths, masks, shifts, decoders, and IOC direction
-// macros that Linux UAPI headers (DRM, V4L2, etc.) expect.
-//
-// DRM headers include <sys/ioccom.h> as the BSD-naming path for ioctl
-// command encoding; relibc's <sys/ioctl.h> provides the basic macros
-// but not these constants. This header unifies them so DRM and other
-// Linux UAPI consumers build without a Mesa-side stub.
-
-#include <sys/ioctl.h>
-
-#ifndef _IOC_NRBITS
-#define _IOC_NRBITS    8
-#endif
-#ifndef _IOC_TYPEBITS
-#define _IOC_TYPEBITS  8
-#endif
-#ifndef _IOC_SIZEBITS
-#define _IOC_SIZEBITS  14
-#endif
-#ifndef _IOC_DIRBITS
-#define _IOC_DIRBITS   2
-#endif
-
-#ifndef _IOC_NRMASK
-#define _IOC_NRMASK    ((1 << _IOC_NRBITS) - 1)
-#endif
-#ifndef _IOC_TYPEMASK
-#define _IOC_TYPEMASK  ((1 << _IOC_TYPEBITS) - 1)
-#endif
-#ifndef _IOC_SIZEMASK
-#define _IOC_SIZEMASK  ((1 << _IOC_SIZEBITS) - 1)
-#endif
-#ifndef _IOC_DIRMASK
-#define _IOC_DIRMASK   ((1 << _IOC_DIRBITS) - 1)
-#endif
-
-#ifndef _IOC_NRSHIFT
-#define _IOC_NRSHIFT    0
-#endif
-#ifndef _IOC_TYPESHIFT
-#define _IOC_TYPESHIFT  (_IOC_NRSHIFT + _IOC_NRBITS)
-#endif
-#ifndef _IOC_SIZESHIFT
-#define _IOC_SIZESHIFT  (_IOC_TYPESHIFT + _IOC_TYPEBITS)
-#endif
-#ifndef _IOC_DIRSHIFT
-#define _IOC_DIRSHIFT   (_IOC_SIZESHIFT + _IOC_SIZEBITS)
-#endif
-
-// _IOC_TYPECHECK wraps the ioctl size argument in a sizeof() for type
-// safety. The musl/relibc _IOW / _IOR / _IOWR macros already call
-// sizeof internally on the third argument; this macro is provided for
-// callers that compose ioctl numbers directly (e.g. DRM).
-#ifndef _IOC_TYPECHECK
-#define _IOC_TYPECHECK(t) (sizeof(t))
-#endif
-
-// _IOC_DIR / _IOC_TYPE / _IOC_NR / _IOC_SIZE decode the fields of an
-// ioctl number. Linux UAPI callers use these to inspect ioctls.
-#ifndef _IOC_DIR
-#define _IOC_DIR(nr)  (((nr) >> _IOC_DIRSHIFT)  & _IOC_DIRMASK)
-#endif
-#ifndef _IOC_TYPE
-#define _IOC_TYPE(nr) (((nr) >> _IOC_TYPESHIFT) & _IOC_TYPEMASK)
-#endif
-#ifndef _IOC_NR
-#define _IOC_NR(nr)   (((nr) >> _IOC_NRSHIFT)   & _IOC_NRMASK)
-#endif
-#ifndef _IOC_SIZE
-#define _IOC_SIZE(nr) (((nr) >> _IOC_SIZESHIFT) & _IOC_SIZEMASK)
-#endif
-
-// IOC_IN / IOC_OUT / IOC_INOUT are the values stored in the direction
-// field of an ioctl number when constructing one without _IO / _IOR /
-// _IOW / _IOWR.
-#ifndef IOC_IN
-#define IOC_IN     (_IOC_WRITE  << _IOC_DIRSHIFT)
-#endif
-#ifndef IOC_OUT
-#define IOC_OUT    (_IOC_READ   << _IOC_DIRSHIFT)
-#endif
-#ifndef IOC_INOUT
-#define IOC_INOUT  ((_IOC_WRITE | _IOC_READ) << _IOC_DIRSHIFT)
-#endif
-#ifndef IOCSIZE_MASK
-#define IOCSIZE_MASK  (_IOC_SIZEMASK << _IOC_SIZESHIFT)
-#endif
-#ifndef IOCSIZE_SHIFT
-#define IOCSIZE_SHIFT (_IOC_SIZESHIFT)
-#endif
-
-#endif /* _SYS_IOCCOM_H */

include/sys/param.h

@@ -1,36 +0,0 @@
-#ifndef _SYS_PARAM_H
-#define _SYS_PARAM_H
-
-#define MIN(a,b) (((a) < (b)) ? (a) : (b))
-#define MAX(a,b) (((a) > (b)) ? (a) : (b))
-
-#define __bitop(array, index, op) ((array)[(index) / 8] op (1 << (index) % 8))
-#define setbit(array, index) __bitop(array, index, |=)
-#define clrbit(array, index) __bitop(array, index, &= ~)
-#define isset(array, index) __bitop(array, index, &)
-#define isclr(array, index) !isset(array, index)
-
-#define howmany(bits, size) (((bits) + (size) - 1) / (size))
-#define roundup(bits, size) (howmany(bits, size) * (size))
-#define powerof2(n) !(((n) - 1) & (n))
-
-// Shamelessly copied from musl.
-// Tweak as needed.
-#define MAXSYMLINKS 20
-#define MAXHOSTNAMELEN 64
-#define MAXNAMLEN 255
-#define MAXPATHLEN 4096
-#define NBBY 8
-#define NGROUPS 32
-#define CANBSIZ 255
-#define NOFILE 256
-#define NCARGS 131072
-#define DEV_BSIZE 512
-#define NOGROUP (-1)
-
-#include <sys/resource.h>
-#include <limits.h>
-
-#include <machine/endian.h>
-
-#endif

include/sys/poll.h

@@ -1 +0,0 @@
-#include <poll.h>

include/sys/queue.h

@@ -1,846 +0,0 @@
-/*	$NetBSD: queue.h,v 1.70 2015/11/02 15:21:23 christos Exp $	*/
-
-/*
- * Copyright (c) 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)queue.h	8.5 (Berkeley) 8/20/94
- */
-
-#ifndef	_SYS_QUEUE_H_
-#define	_SYS_QUEUE_H_
-
-/*
- * This file defines five types of data structures: singly-linked lists,
- * lists, simple queues, tail queues, and circular queues.
- *
- * A singly-linked list is headed by a single forward pointer. The
- * elements are singly linked for minimum space and pointer manipulation
- * overhead at the expense of O(n) removal for arbitrary elements. New
- * elements can be added to the list after an existing element or at the
- * head of the list.  Elements being removed from the head of the list
- * should use the explicit macro for this purpose for optimum
- * efficiency. A singly-linked list may only be traversed in the forward
- * direction.  Singly-linked lists are ideal for applications with large
- * datasets and few or no removals or for implementing a LIFO queue.
- *
- * A list is headed by a single forward pointer (or an array of forward
- * pointers for a hash table header). The elements are doubly linked
- * so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before
- * or after an existing element or at the head of the list. A list
- * may only be traversed in the forward direction.
- *
- * A simple queue is headed by a pair of pointers, one the head of the
- * list and the other to the tail of the list. The elements are singly
- * linked to save space, so elements can only be removed from the
- * head of the list. New elements can be added to the list after
- * an existing element, at the head of the list, or at the end of the
- * list. A simple queue may only be traversed in the forward direction.
- *
- * A tail queue is headed by a pair of pointers, one to the head of the
- * list and the other to the tail of the list. The elements are doubly
- * linked so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before or
- * after an existing element, at the head of the list, or at the end of
- * the list. A tail queue may be traversed in either direction.
- *
- * A circle queue is headed by a pair of pointers, one to the head of the
- * list and the other to the tail of the list. The elements are doubly
- * linked so that an arbitrary element can be removed without a need to
- * traverse the list. New elements can be added to the list before or after
- * an existing element, at the head of the list, or at the end of the list.
- * A circle queue may be traversed in either direction, but has a more
- * complex end of list detection.
- *
- * For details on the use of these macros, see the queue(3) manual page.
- */
-
-/*
- * Include the definition of NULL only on NetBSD because sys/null.h
- * is not available elsewhere.  This conditional makes the header
- * portable and it can simply be dropped verbatim into any system.
- * The caveat is that on other systems some other header
- * must provide NULL before the macros can be used.
- */
-#ifdef __NetBSD__
-#include <sys/null.h>
-#endif
-
-#if defined(QUEUEDEBUG)
-# if defined(_KERNEL)
-#  define QUEUEDEBUG_ABORT(...) panic(__VA_ARGS__)
-# else
-#  include <err.h>
-#  define QUEUEDEBUG_ABORT(...) err(1, __VA_ARGS__)
-# endif
-#endif
-
-/*
- * Singly-linked List definitions.
- */
-#define	SLIST_HEAD(name, type)						\
-struct name {								\
-	struct type *slh_first;	/* first element */			\
-}
-
-#define	SLIST_HEAD_INITIALIZER(head)					\
-	{ NULL }
-
-#define	SLIST_ENTRY(type)						\
-struct {								\
-	struct type *sle_next;	/* next element */			\
-}
-
-/*
- * Singly-linked List access methods.
- */
-#define	SLIST_FIRST(head)	((head)->slh_first)
-#define	SLIST_END(head)		NULL
-#define	SLIST_EMPTY(head)	((head)->slh_first == NULL)
-#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
-
-#define	SLIST_FOREACH(var, head, field)					\
-	for((var) = (head)->slh_first;					\
-	    (var) != SLIST_END(head);					\
-	    (var) = (var)->field.sle_next)
-
-#define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = SLIST_FIRST((head));				\
-	    (var) != SLIST_END(head) &&					\
-	    ((tvar) = SLIST_NEXT((var), field), 1);			\
-	    (var) = (tvar))
-
-/*
- * Singly-linked List functions.
- */
-#define	SLIST_INIT(head) do {						\
-	(head)->slh_first = SLIST_END(head);				\
-} while (/*CONSTCOND*/0)
-
-#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
-	(elm)->field.sle_next = (slistelm)->field.sle_next;		\
-	(slistelm)->field.sle_next = (elm);				\
-} while (/*CONSTCOND*/0)
-
-#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
-	(elm)->field.sle_next = (head)->slh_first;			\
-	(head)->slh_first = (elm);					\
-} while (/*CONSTCOND*/0)
-
-#define	SLIST_REMOVE_AFTER(slistelm, field) do {			\
-	(slistelm)->field.sle_next =					\
-	    SLIST_NEXT(SLIST_NEXT((slistelm), field), field);		\
-} while (/*CONSTCOND*/0)
-
-#define	SLIST_REMOVE_HEAD(head, field) do {				\
-	(head)->slh_first = (head)->slh_first->field.sle_next;		\
-} while (/*CONSTCOND*/0)
-
-#define	SLIST_REMOVE(head, elm, type, field) do {			\
-	if ((head)->slh_first == (elm)) {				\
-		SLIST_REMOVE_HEAD((head), field);			\
-	}								\
-	else {								\
-		struct type *curelm = (head)->slh_first;		\
-		while(curelm->field.sle_next != (elm))			\
-			curelm = curelm->field.sle_next;		\
-		curelm->field.sle_next =				\
-		    curelm->field.sle_next->field.sle_next;		\
-	}								\
-} while (/*CONSTCOND*/0)
-
-
-/*
- * List definitions.
- */
-#define	LIST_HEAD(name, type)						\
-struct name {								\
-	struct type *lh_first;	/* first element */			\
-}
-
-#define	LIST_HEAD_INITIALIZER(head)					\
-	{ NULL }
-
-#define	LIST_ENTRY(type)						\
-struct {								\
-	struct type *le_next;	/* next element */			\
-	struct type **le_prev;	/* address of previous next element */	\
-}
-
-/*
- * List access methods.
- */
-#define	LIST_FIRST(head)		((head)->lh_first)
-#define	LIST_END(head)			NULL
-#define	LIST_EMPTY(head)		((head)->lh_first == LIST_END(head))
-#define	LIST_NEXT(elm, field)		((elm)->field.le_next)
-
-#define	LIST_FOREACH(var, head, field)					\
-	for ((var) = ((head)->lh_first);				\
-	    (var) != LIST_END(head);					\
-	    (var) = ((var)->field.le_next))
-
-#define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = LIST_FIRST((head));				\
-	    (var) != LIST_END(head) &&					\
-	    ((tvar) = LIST_NEXT((var), field), 1);			\
-	    (var) = (tvar))
-
-#define	LIST_MOVE(head1, head2) do {					\
-	LIST_INIT((head2));						\
-	if (!LIST_EMPTY((head1))) {					\
-		(head2)->lh_first = (head1)->lh_first;			\
-		LIST_INIT((head1));					\
-	}								\
-} while (/*CONSTCOND*/0)
-
-/*
- * List functions.
- */
-#if defined(QUEUEDEBUG)
-#define	QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field)			\
-	if ((head)->lh_first &&						\
-	    (head)->lh_first->field.le_prev != &(head)->lh_first)	\
-		QUEUEDEBUG_ABORT("LIST_INSERT_HEAD %p %s:%d", (head),	\
-		    __FILE__, __LINE__);
-#define	QUEUEDEBUG_LIST_OP(elm, field)					\
-	if ((elm)->field.le_next &&					\
-	    (elm)->field.le_next->field.le_prev !=			\
-	    &(elm)->field.le_next)					\
-		QUEUEDEBUG_ABORT("LIST_* forw %p %s:%d", (elm),		\
-		    __FILE__, __LINE__);				\
-	if (*(elm)->field.le_prev != (elm))				\
-		QUEUEDEBUG_ABORT("LIST_* back %p %s:%d", (elm),		\
-		    __FILE__, __LINE__);
-#define	QUEUEDEBUG_LIST_POSTREMOVE(elm, field)				\
-	(elm)->field.le_next = (void *)1L;				\
-	(elm)->field.le_prev = (void *)1L;
-#else
-#define	QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field)
-#define	QUEUEDEBUG_LIST_OP(elm, field)
-#define	QUEUEDEBUG_LIST_POSTREMOVE(elm, field)
-#endif
-
-#define	LIST_INIT(head) do {						\
-	(head)->lh_first = LIST_END(head);				\
-} while (/*CONSTCOND*/0)
-
-#define	LIST_INSERT_AFTER(listelm, elm, field) do {			\
-	QUEUEDEBUG_LIST_OP((listelm), field)				\
-	if (((elm)->field.le_next = (listelm)->field.le_next) != 	\
-	    LIST_END(head))						\
-		(listelm)->field.le_next->field.le_prev =		\
-		    &(elm)->field.le_next;				\
-	(listelm)->field.le_next = (elm);				\
-	(elm)->field.le_prev = &(listelm)->field.le_next;		\
-} while (/*CONSTCOND*/0)
-
-#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
-	QUEUEDEBUG_LIST_OP((listelm), field)				\
-	(elm)->field.le_prev = (listelm)->field.le_prev;		\
-	(elm)->field.le_next = (listelm);				\
-	*(listelm)->field.le_prev = (elm);				\
-	(listelm)->field.le_prev = &(elm)->field.le_next;		\
-} while (/*CONSTCOND*/0)
-
-#define	LIST_INSERT_HEAD(head, elm, field) do {				\
-	QUEUEDEBUG_LIST_INSERT_HEAD((head), (elm), field)		\
-	if (((elm)->field.le_next = (head)->lh_first) != LIST_END(head))\
-		(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
-	(head)->lh_first = (elm);					\
-	(elm)->field.le_prev = &(head)->lh_first;			\
-} while (/*CONSTCOND*/0)
-
-#define	LIST_REMOVE(elm, field) do {					\
-	QUEUEDEBUG_LIST_OP((elm), field)				\
-	if ((elm)->field.le_next != NULL)				\
-		(elm)->field.le_next->field.le_prev = 			\
-		    (elm)->field.le_prev;				\
-	*(elm)->field.le_prev = (elm)->field.le_next;			\
-	QUEUEDEBUG_LIST_POSTREMOVE((elm), field)			\
-} while (/*CONSTCOND*/0)
-
-#define LIST_REPLACE(elm, elm2, field) do {				\
-	if (((elm2)->field.le_next = (elm)->field.le_next) != NULL)	\
-		(elm2)->field.le_next->field.le_prev =			\
-		    &(elm2)->field.le_next;				\
-	(elm2)->field.le_prev = (elm)->field.le_prev;			\
-	*(elm2)->field.le_prev = (elm2);				\
-	QUEUEDEBUG_LIST_POSTREMOVE((elm), field)			\
-} while (/*CONSTCOND*/0)
-
-/*
- * Simple queue definitions.
- */
-#define	SIMPLEQ_HEAD(name, type)					\
-struct name {								\
-	struct type *sqh_first;	/* first element */			\
-	struct type **sqh_last;	/* addr of last next element */		\
-}
-
-#define	SIMPLEQ_HEAD_INITIALIZER(head)					\
-	{ NULL, &(head).sqh_first }
-
-#define	SIMPLEQ_ENTRY(type)						\
-struct {								\
-	struct type *sqe_next;	/* next element */			\
-}
-
-/*
- * Simple queue access methods.
- */
-#define	SIMPLEQ_FIRST(head)		((head)->sqh_first)
-#define	SIMPLEQ_END(head)		NULL
-#define	SIMPLEQ_EMPTY(head)		((head)->sqh_first == SIMPLEQ_END(head))
-#define	SIMPLEQ_NEXT(elm, field)	((elm)->field.sqe_next)
-
-#define	SIMPLEQ_FOREACH(var, head, field)				\
-	for ((var) = ((head)->sqh_first);				\
-	    (var) != SIMPLEQ_END(head);					\
-	    (var) = ((var)->field.sqe_next))
-
-#define	SIMPLEQ_FOREACH_SAFE(var, head, field, next)			\
-	for ((var) = ((head)->sqh_first);				\
-	    (var) != SIMPLEQ_END(head) &&				\
-	    ((next = ((var)->field.sqe_next)), 1);			\
-	    (var) = (next))
-
-/*
- * Simple queue functions.
- */
-#define	SIMPLEQ_INIT(head) do {						\
-	(head)->sqh_first = NULL;					\
-	(head)->sqh_last = &(head)->sqh_first;				\
-} while (/*CONSTCOND*/0)
-
-#define	SIMPLEQ_INSERT_HEAD(head, elm, field) do {			\
-	if (((elm)->field.sqe_next = (head)->sqh_first) == NULL)	\
-		(head)->sqh_last = &(elm)->field.sqe_next;		\
-	(head)->sqh_first = (elm);					\
-} while (/*CONSTCOND*/0)
-
-#define	SIMPLEQ_INSERT_TAIL(head, elm, field) do {			\
-	(elm)->field.sqe_next = NULL;					\
-	*(head)->sqh_last = (elm);					\
-	(head)->sqh_last = &(elm)->field.sqe_next;			\
-} while (/*CONSTCOND*/0)
-
-#define	SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
-		(head)->sqh_last = &(elm)->field.sqe_next;		\
-	(listelm)->field.sqe_next = (elm);				\
-} while (/*CONSTCOND*/0)
-
-#define	SIMPLEQ_REMOVE_HEAD(head, field) do {				\
-	if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
-		(head)->sqh_last = &(head)->sqh_first;			\
-} while (/*CONSTCOND*/0)
-
-#define SIMPLEQ_REMOVE_AFTER(head, elm, field) do {			\
-	if (((elm)->field.sqe_next = (elm)->field.sqe_next->field.sqe_next) \
-	    == NULL)							\
-		(head)->sqh_last = &(elm)->field.sqe_next;		\
-} while (/*CONSTCOND*/0)
-
-#define	SIMPLEQ_REMOVE(head, elm, type, field) do {			\
-	if ((head)->sqh_first == (elm)) {				\
-		SIMPLEQ_REMOVE_HEAD((head), field);			\
-	} else {							\
-		struct type *curelm = (head)->sqh_first;		\
-		while (curelm->field.sqe_next != (elm))			\
-			curelm = curelm->field.sqe_next;		\
-		if ((curelm->field.sqe_next =				\
-			curelm->field.sqe_next->field.sqe_next) == NULL) \
-			    (head)->sqh_last = &(curelm)->field.sqe_next; \
-	}								\
-} while (/*CONSTCOND*/0)
-
-#define	SIMPLEQ_CONCAT(head1, head2) do {				\
-	if (!SIMPLEQ_EMPTY((head2))) {					\
-		*(head1)->sqh_last = (head2)->sqh_first;		\
-		(head1)->sqh_last = (head2)->sqh_last;		\
-		SIMPLEQ_INIT((head2));					\
-	}								\
-} while (/*CONSTCOND*/0)
-
-#define	SIMPLEQ_LAST(head, type, field)					\
-	(SIMPLEQ_EMPTY((head)) ?						\
-		NULL :							\
-	        ((struct type *)(void *)				\
-		((char *)((head)->sqh_last) - offsetof(struct type, field))))
-
-/*
- * Tail queue definitions.
- */
-#define	_TAILQ_HEAD(name, type, qual)					\
-struct name {								\
-	qual type *tqh_first;		/* first element */		\
-	qual type *qual *tqh_last;	/* addr of last next element */	\
-}
-#define TAILQ_HEAD(name, type)	_TAILQ_HEAD(name, struct type,)
-
-#define	TAILQ_HEAD_INITIALIZER(head)					\
-	{ TAILQ_END(head), &(head).tqh_first }
-
-#define	_TAILQ_ENTRY(type, qual)					\
-struct {								\
-	qual type *tqe_next;		/* next element */		\
-	qual type *qual *tqe_prev;	/* address of previous next element */\
-}
-#define TAILQ_ENTRY(type)	_TAILQ_ENTRY(struct type,)
-
-/*
- * Tail queue access methods.
- */
-#define	TAILQ_FIRST(head)		((head)->tqh_first)
-#define	TAILQ_END(head)			(NULL)
-#define	TAILQ_NEXT(elm, field)		((elm)->field.tqe_next)
-#define	TAILQ_LAST(head, headname) \
-	(*(((struct headname *)(void *)((head)->tqh_last))->tqh_last))
-#define	TAILQ_PREV(elm, headname, field) \
-	(*(((struct headname *)(void *)((elm)->field.tqe_prev))->tqh_last))
-#define	TAILQ_EMPTY(head)		(TAILQ_FIRST(head) == TAILQ_END(head))
-
-
-#define	TAILQ_FOREACH(var, head, field)					\
-	for ((var) = ((head)->tqh_first);				\
-	    (var) != TAILQ_END(head);					\
-	    (var) = ((var)->field.tqe_next))
-
-#define	TAILQ_FOREACH_SAFE(var, head, field, next)			\
-	for ((var) = ((head)->tqh_first);				\
-	    (var) != TAILQ_END(head) &&					\
-	    ((next) = TAILQ_NEXT(var, field), 1); (var) = (next))
-
-#define	TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
-	for ((var) = TAILQ_LAST((head), headname);			\
-	    (var) != TAILQ_END(head);					\
-	    (var) = TAILQ_PREV((var), headname, field))
-
-#define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, prev)	\
-	for ((var) = TAILQ_LAST((head), headname);			\
-	    (var) != TAILQ_END(head) && 				\
-	    ((prev) = TAILQ_PREV((var), headname, field), 1); (var) = (prev))
-
-/*
- * Tail queue functions.
- */
-#if defined(QUEUEDEBUG)
-#define	QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field)			\
-	if ((head)->tqh_first &&					\
-	    (head)->tqh_first->field.tqe_prev != &(head)->tqh_first)	\
-		QUEUEDEBUG_ABORT("TAILQ_INSERT_HEAD %p %s:%d", (head),	\
-		    __FILE__, __LINE__);
-#define	QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field)			\
-	if (*(head)->tqh_last != NULL)					\
-		QUEUEDEBUG_ABORT("TAILQ_INSERT_TAIL %p %s:%d", (head),	\
-		    __FILE__, __LINE__);
-#define	QUEUEDEBUG_TAILQ_OP(elm, field)					\
-	if ((elm)->field.tqe_next &&					\
-	    (elm)->field.tqe_next->field.tqe_prev !=			\
-	    &(elm)->field.tqe_next)					\
-		QUEUEDEBUG_ABORT("TAILQ_* forw %p %s:%d", (elm),	\
-		    __FILE__, __LINE__);				\
-	if (*(elm)->field.tqe_prev != (elm))				\
-		QUEUEDEBUG_ABORT("TAILQ_* back %p %s:%d", (elm),	\
-		    __FILE__, __LINE__);
-#define	QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field)			\
-	if ((elm)->field.tqe_next == NULL &&				\
-	    (head)->tqh_last != &(elm)->field.tqe_next)			\
-		QUEUEDEBUG_ABORT("TAILQ_PREREMOVE head %p elm %p %s:%d",\
-		    (head), (elm), __FILE__, __LINE__);
-#define	QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field)				\
-	(elm)->field.tqe_next = (void *)1L;				\
-	(elm)->field.tqe_prev = (void *)1L;
-#else
-#define	QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field)
-#define	QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field)
-#define	QUEUEDEBUG_TAILQ_OP(elm, field)
-#define	QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field)
-#define	QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field)
-#endif
-
-#define	TAILQ_INIT(head) do {						\
-	(head)->tqh_first = TAILQ_END(head);				\
-	(head)->tqh_last = &(head)->tqh_first;				\
-} while (/*CONSTCOND*/0)
-
-#define	TAILQ_INSERT_HEAD(head, elm, field) do {			\
-	QUEUEDEBUG_TAILQ_INSERT_HEAD((head), (elm), field)		\
-	if (((elm)->field.tqe_next = (head)->tqh_first) != TAILQ_END(head))\
-		(head)->tqh_first->field.tqe_prev =			\
-		    &(elm)->field.tqe_next;				\
-	else								\
-		(head)->tqh_last = &(elm)->field.tqe_next;		\
-	(head)->tqh_first = (elm);					\
-	(elm)->field.tqe_prev = &(head)->tqh_first;			\
-} while (/*CONSTCOND*/0)
-
-#define	TAILQ_INSERT_TAIL(head, elm, field) do {			\
-	QUEUEDEBUG_TAILQ_INSERT_TAIL((head), (elm), field)		\
-	(elm)->field.tqe_next = TAILQ_END(head);			\
-	(elm)->field.tqe_prev = (head)->tqh_last;			\
-	*(head)->tqh_last = (elm);					\
-	(head)->tqh_last = &(elm)->field.tqe_next;			\
-} while (/*CONSTCOND*/0)
-
-#define	TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	QUEUEDEBUG_TAILQ_OP((listelm), field)				\
-	if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != 	\
-	    TAILQ_END(head))						\
-		(elm)->field.tqe_next->field.tqe_prev = 		\
-		    &(elm)->field.tqe_next;				\
-	else								\
-		(head)->tqh_last = &(elm)->field.tqe_next;		\
-	(listelm)->field.tqe_next = (elm);				\
-	(elm)->field.tqe_prev = &(listelm)->field.tqe_next;		\
-} while (/*CONSTCOND*/0)
-
-#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
-	QUEUEDEBUG_TAILQ_OP((listelm), field)				\
-	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
-	(elm)->field.tqe_next = (listelm);				\
-	*(listelm)->field.tqe_prev = (elm);				\
-	(listelm)->field.tqe_prev = &(elm)->field.tqe_next;		\
-} while (/*CONSTCOND*/0)
-
-#define	TAILQ_REMOVE(head, elm, field) do {				\
-	QUEUEDEBUG_TAILQ_PREREMOVE((head), (elm), field)		\
-	QUEUEDEBUG_TAILQ_OP((elm), field)				\
-	if (((elm)->field.tqe_next) != TAILQ_END(head))			\
-		(elm)->field.tqe_next->field.tqe_prev = 		\
-		    (elm)->field.tqe_prev;				\
-	else								\
-		(head)->tqh_last = (elm)->field.tqe_prev;		\
-	*(elm)->field.tqe_prev = (elm)->field.tqe_next;			\
-	QUEUEDEBUG_TAILQ_POSTREMOVE((elm), field);			\
-} while (/*CONSTCOND*/0)
-
-#define TAILQ_REPLACE(head, elm, elm2, field) do {			\
-        if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != 	\
-	    TAILQ_END(head))   						\
-                (elm2)->field.tqe_next->field.tqe_prev =		\
-                    &(elm2)->field.tqe_next;				\
-        else								\
-                (head)->tqh_last = &(elm2)->field.tqe_next;		\
-        (elm2)->field.tqe_prev = (elm)->field.tqe_prev;			\
-        *(elm2)->field.tqe_prev = (elm2);				\
-	QUEUEDEBUG_TAILQ_POSTREMOVE((elm), field);			\
-} while (/*CONSTCOND*/0)
-
-#define	TAILQ_CONCAT(head1, head2, field) do {				\
-	if (!TAILQ_EMPTY(head2)) {					\
-		*(head1)->tqh_last = (head2)->tqh_first;		\
-		(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;	\
-		(head1)->tqh_last = (head2)->tqh_last;			\
-		TAILQ_INIT((head2));					\
-	}								\
-} while (/*CONSTCOND*/0)
-
-/*
- * Singly-linked Tail queue declarations.
- */
-#define	STAILQ_HEAD(name, type)						\
-struct name {								\
-	struct type *stqh_first;	/* first element */		\
-	struct type **stqh_last;	/* addr of last next element */	\
-}
-
-#define	STAILQ_HEAD_INITIALIZER(head)					\
-	{ NULL, &(head).stqh_first }
-
-#define	STAILQ_ENTRY(type)						\
-struct {								\
-	struct type *stqe_next;	/* next element */			\
-}
-
-/*
- * Singly-linked Tail queue access methods.
- */
-#define	STAILQ_FIRST(head)	((head)->stqh_first)
-#define	STAILQ_END(head)	NULL
-#define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
-#define	STAILQ_EMPTY(head)	(STAILQ_FIRST(head) == STAILQ_END(head))
-
-/*
- * Singly-linked Tail queue functions.
- */
-#define	STAILQ_INIT(head) do {						\
-	(head)->stqh_first = NULL;					\
-	(head)->stqh_last = &(head)->stqh_first;				\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
-	if (((elm)->field.stqe_next = (head)->stqh_first) == NULL)	\
-		(head)->stqh_last = &(elm)->field.stqe_next;		\
-	(head)->stqh_first = (elm);					\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
-	(elm)->field.stqe_next = NULL;					\
-	*(head)->stqh_last = (elm);					\
-	(head)->stqh_last = &(elm)->field.stqe_next;			\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\
-		(head)->stqh_last = &(elm)->field.stqe_next;		\
-	(listelm)->field.stqe_next = (elm);				\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_REMOVE_HEAD(head, field) do {				\
-	if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == NULL) \
-		(head)->stqh_last = &(head)->stqh_first;			\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_REMOVE(head, elm, type, field) do {			\
-	if ((head)->stqh_first == (elm)) {				\
-		STAILQ_REMOVE_HEAD((head), field);			\
-	} else {							\
-		struct type *curelm = (head)->stqh_first;		\
-		while (curelm->field.stqe_next != (elm))			\
-			curelm = curelm->field.stqe_next;		\
-		if ((curelm->field.stqe_next =				\
-			curelm->field.stqe_next->field.stqe_next) == NULL) \
-			    (head)->stqh_last = &(curelm)->field.stqe_next; \
-	}								\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_FOREACH(var, head, field)				\
-	for ((var) = ((head)->stqh_first);				\
-		(var);							\
-		(var) = ((var)->field.stqe_next))
-
-#define	STAILQ_FOREACH_SAFE(var, head, field, tvar)			\
-	for ((var) = STAILQ_FIRST((head));				\
-	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
-	    (var) = (tvar))
-
-#define	STAILQ_CONCAT(head1, head2) do {				\
-	if (!STAILQ_EMPTY((head2))) {					\
-		*(head1)->stqh_last = (head2)->stqh_first;		\
-		(head1)->stqh_last = (head2)->stqh_last;		\
-		STAILQ_INIT((head2));					\
-	}								\
-} while (/*CONSTCOND*/0)
-
-#define	STAILQ_LAST(head, type, field)					\
-	(STAILQ_EMPTY((head)) ?						\
-		NULL :							\
-	        ((struct type *)(void *)				\
-		((char *)((head)->stqh_last) - offsetof(struct type, field))))
-
-
-#ifndef _KERNEL
-/*
- * Circular queue definitions. Do not use. We still keep the macros
- * for compatibility but because of pointer aliasing issues their use
- * is discouraged!
- */
-
-/*
- * __launder_type():  We use this ugly hack to work around the the compiler
- * noticing that two types may not alias each other and elide tests in code.
- * We hit this in the CIRCLEQ macros when comparing 'struct name *' and
- * 'struct type *' (see CIRCLEQ_HEAD()).  Modern compilers (such as GCC
- * 4.8) declare these comparisons as always false, causing the code to
- * not run as designed.
- *
- * This hack is only to be used for comparisons and thus can be fully const.
- * Do not use for assignment.
- *
- * If we ever choose to change the ABI of the CIRCLEQ macros, we could fix
- * this by changing the head/tail sentinal values, but see the note above
- * this one.
- */
-static __inline const void * __launder_type(const void *);
-static __inline const void *
-__launder_type(const void *__x)
-{
-	__asm __volatile("" : "+r" (__x));
-	return __x;
-}
-
-#if defined(QUEUEDEBUG)
-#define QUEUEDEBUG_CIRCLEQ_HEAD(head, field)				\
-	if ((head)->cqh_first != CIRCLEQ_ENDC(head) &&			\
-	    (head)->cqh_first->field.cqe_prev != CIRCLEQ_ENDC(head))	\
-		QUEUEDEBUG_ABORT("CIRCLEQ head forw %p %s:%d", (head),	\
-		      __FILE__, __LINE__);				\
-	if ((head)->cqh_last != CIRCLEQ_ENDC(head) &&			\
-	    (head)->cqh_last->field.cqe_next != CIRCLEQ_ENDC(head))	\
-		QUEUEDEBUG_ABORT("CIRCLEQ head back %p %s:%d", (head),	\
-		      __FILE__, __LINE__);
-#define QUEUEDEBUG_CIRCLEQ_ELM(head, elm, field)			\
-	if ((elm)->field.cqe_next == CIRCLEQ_ENDC(head)) {		\
-		if ((head)->cqh_last != (elm))				\
-			QUEUEDEBUG_ABORT("CIRCLEQ elm last %p %s:%d",	\
-			    (elm), __FILE__, __LINE__);			\
-	} else {							\
-		if ((elm)->field.cqe_next->field.cqe_prev != (elm))	\
-			QUEUEDEBUG_ABORT("CIRCLEQ elm forw %p %s:%d",	\
-			    (elm), __FILE__, __LINE__);			\
-	}								\
-	if ((elm)->field.cqe_prev == CIRCLEQ_ENDC(head)) {		\
-		if ((head)->cqh_first != (elm))				\
-			QUEUEDEBUG_ABORT("CIRCLEQ elm first %p %s:%d",	\
-			    (elm), __FILE__, __LINE__);			\
-	} else {							\
-		if ((elm)->field.cqe_prev->field.cqe_next != (elm))	\
-			QUEUEDEBUG_ABORT("CIRCLEQ elm prev %p %s:%d",	\
-			    (elm), __FILE__, __LINE__);			\
-	}
-#define QUEUEDEBUG_CIRCLEQ_POSTREMOVE(elm, field)			\
-	(elm)->field.cqe_next = (void *)1L;				\
-	(elm)->field.cqe_prev = (void *)1L;
-#else
-#define QUEUEDEBUG_CIRCLEQ_HEAD(head, field)
-#define QUEUEDEBUG_CIRCLEQ_ELM(head, elm, field)
-#define QUEUEDEBUG_CIRCLEQ_POSTREMOVE(elm, field)
-#endif
-
-#define	CIRCLEQ_HEAD(name, type)					\
-struct name {								\
-	struct type *cqh_first;		/* first element */		\
-	struct type *cqh_last;		/* last element */		\
-}
-
-#define	CIRCLEQ_HEAD_INITIALIZER(head)					\
-	{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }
-
-#define	CIRCLEQ_ENTRY(type)						\
-struct {								\
-	struct type *cqe_next;		/* next element */		\
-	struct type *cqe_prev;		/* previous element */		\
-}
-
-/*
- * Circular queue functions.
- */
-#define	CIRCLEQ_INIT(head) do {						\
-	(head)->cqh_first = CIRCLEQ_END(head);				\
-	(head)->cqh_last = CIRCLEQ_END(head);				\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
-	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
-	QUEUEDEBUG_CIRCLEQ_ELM((head), (listelm), field)		\
-	(elm)->field.cqe_next = (listelm)->field.cqe_next;		\
-	(elm)->field.cqe_prev = (listelm);				\
-	if ((listelm)->field.cqe_next == CIRCLEQ_ENDC(head))		\
-		(head)->cqh_last = (elm);				\
-	else								\
-		(listelm)->field.cqe_next->field.cqe_prev = (elm);	\
-	(listelm)->field.cqe_next = (elm);				\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\
-	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
-	QUEUEDEBUG_CIRCLEQ_ELM((head), (listelm), field)		\
-	(elm)->field.cqe_next = (listelm);				\
-	(elm)->field.cqe_prev = (listelm)->field.cqe_prev;		\
-	if ((listelm)->field.cqe_prev == CIRCLEQ_ENDC(head))		\
-		(head)->cqh_first = (elm);				\
-	else								\
-		(listelm)->field.cqe_prev->field.cqe_next = (elm);	\
-	(listelm)->field.cqe_prev = (elm);				\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\
-	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
-	(elm)->field.cqe_next = (head)->cqh_first;			\
-	(elm)->field.cqe_prev = CIRCLEQ_END(head);			\
-	if ((head)->cqh_last == CIRCLEQ_ENDC(head))			\
-		(head)->cqh_last = (elm);				\
-	else								\
-		(head)->cqh_first->field.cqe_prev = (elm);		\
-	(head)->cqh_first = (elm);					\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\
-	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
-	(elm)->field.cqe_next = CIRCLEQ_END(head);			\
-	(elm)->field.cqe_prev = (head)->cqh_last;			\
-	if ((head)->cqh_first == CIRCLEQ_ENDC(head))			\
-		(head)->cqh_first = (elm);				\
-	else								\
-		(head)->cqh_last->field.cqe_next = (elm);		\
-	(head)->cqh_last = (elm);					\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_REMOVE(head, elm, field) do {				\
-	QUEUEDEBUG_CIRCLEQ_HEAD((head), field)				\
-	QUEUEDEBUG_CIRCLEQ_ELM((head), (elm), field)			\
-	if ((elm)->field.cqe_next == CIRCLEQ_ENDC(head))		\
-		(head)->cqh_last = (elm)->field.cqe_prev;		\
-	else								\
-		(elm)->field.cqe_next->field.cqe_prev =			\
-		    (elm)->field.cqe_prev;				\
-	if ((elm)->field.cqe_prev == CIRCLEQ_ENDC(head))		\
-		(head)->cqh_first = (elm)->field.cqe_next;		\
-	else								\
-		(elm)->field.cqe_prev->field.cqe_next =			\
-		    (elm)->field.cqe_next;				\
-	QUEUEDEBUG_CIRCLEQ_POSTREMOVE((elm), field)			\
-} while (/*CONSTCOND*/0)
-
-#define	CIRCLEQ_FOREACH(var, head, field)				\
-	for ((var) = ((head)->cqh_first);				\
-		(var) != CIRCLEQ_ENDC(head);				\
-		(var) = ((var)->field.cqe_next))
-
-#define	CIRCLEQ_FOREACH_REVERSE(var, head, field)			\
-	for ((var) = ((head)->cqh_last);				\
-		(var) != CIRCLEQ_ENDC(head);				\
-		(var) = ((var)->field.cqe_prev))
-
-/*
- * Circular queue access methods.
- */
-#define	CIRCLEQ_FIRST(head)		((head)->cqh_first)
-#define	CIRCLEQ_LAST(head)		((head)->cqh_last)
-/* For comparisons */
-#define	CIRCLEQ_ENDC(head)		(__launder_type(head))
-/* For assignments */
-#define	CIRCLEQ_END(head)		((void *)(head))
-#define	CIRCLEQ_NEXT(elm, field)	((elm)->field.cqe_next)
-#define	CIRCLEQ_PREV(elm, field)	((elm)->field.cqe_prev)
-#define	CIRCLEQ_EMPTY(head)						\
-    (CIRCLEQ_FIRST(head) == CIRCLEQ_ENDC(head))
-
-#define CIRCLEQ_LOOP_NEXT(head, elm, field)				\
-	(((elm)->field.cqe_next == CIRCLEQ_ENDC(head))			\
-	    ? ((head)->cqh_first)					\
-	    : (elm->field.cqe_next))
-#define CIRCLEQ_LOOP_PREV(head, elm, field)				\
-	(((elm)->field.cqe_prev == CIRCLEQ_ENDC(head))			\
-	    ? ((head)->cqh_last)					\
-	    : (elm->field.cqe_prev))
-#endif /* !_KERNEL */
-
-#endif	/* !_SYS_QUEUE_H_ */

include/sys/redox.h

@@ -1,22 +0,0 @@
-#ifndef _SYS_REDOX_H
-#define _SYS_REDOX_H
-
-#include <sys/types.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifdef __redox__
-
-ssize_t redox_fpath(int fd, void * buf, size_t count);
-void * redox_physalloc(size_t size);
-int redox_physfree(void * physical_address, size_t size);
-
-#endif
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
-#endif

include/sys/sysmacros.h

@@ -1,16 +0,0 @@
-// From musl, license MIT
-#ifndef _SYS_SYSMACROS_H
-#define _SYS_SYSMACROS_H
-
-#define major(x) \
-	((unsigned)( (((x)>>31>>1) & 0xfffff000) | (((x)>>8) & 0x00000fff) ))
-#define minor(x) \
-	((unsigned)( (((x)>>12) & 0xffffff00) | ((x) & 0x000000ff) ))
-
-#define makedev(x,y) ( \
-        (((x)&0xfffff000ULL) << 32) | \
-	(((x)&0x00000fffULL) << 8) | \
-        (((y)&0xffffff00ULL) << 12) | \
-	(((y)&0x000000ffULL)) )
-
-#endif

include/sys/user.h

@@ -1,13 +0,0 @@
-#ifndef _SYS_USER_H
-#define _SYS_USER_H
-#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_AMD64)
-#include <arch/x64/user.h>
-#elif defined(__aarch64__)
-#include <arch/aarch64/user.h>
-#elif defined(__riscv) && __riscv_xlen==64
-#include <arch/riscv64/user.h>
-#else
-#error "Unknown architecture"
-#endif
-
-#endif

include/sys/vfs.h

@@ -1,10 +0,0 @@
-#ifndef _RELIBC_SYS_VFS_H
-#define _RELIBC_SYS_VFS_H
-
-/* <sys/vfs.h> is the historical Linux/BSD name for the filesystem-statistics
- * interface; glibc ships it as a thin wrapper that simply re-exports
- * <sys/statfs.h> (struct statfs + statfs()/fstatfs()). Mirror that so code that
- * includes <sys/vfs.h> gets the same declarations. */
-#include <sys/statfs.h>
-
-#endif /* _RELIBC_SYS_VFS_H */

include/syslog.h

@@ -1 +0,0 @@
-#include <sys/syslog.h>

ld_so/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "ld_so"
-version = "0.1.0"
-authors = ["Jeremy Soller <jackpot51@gmail.com>"]
-edition = "2024"
-
-[lib]
-name = "ld_so"
-crate-type = ["staticlib"]
-
-[lints]
-workspace = true

ld_so/src/lib.rs

@@ -1,136 +0,0 @@
-#![no_std]
-#![feature(linkage)]
-#![deny(unsafe_op_in_unsafe_fn)]
-
-use core::arch::global_asm;
-
-#[cfg(target_arch = "aarch64")]
-global_asm!(
-    "
-.weak _DYNAMIC
-.hidden _DYNAMIC
-
-.global _start
-_start:
-    mov x28, sp
-    // align stack to 16 bytes
-    and sp, x28, #0xfffffffffffffff0
-    adr x1, _start
-    mov x0, x28
-    adrp x2, _DYNAMIC
-    add x2, x2, #:lo12:_DYNAMIC
-    // ld_so_start(stack=x0, ld_entry=x1, dynamic=x2)
-    bl relibc_ld_so_start
-    // restore original stack, clear registers, and jump to the new start function
-    mov sp, x28
-    mov x1, xzr
-    mov x2, xzr
-    mov x3, xzr
-    mov x4, xzr
-    mov x5, xzr
-    mov x6, xzr
-    mov x7, xzr
-    mov x8, xzr
-    mov x9, xzr
-    mov x10, xzr
-    mov x11, xzr
-    mov x12, xzr
-    mov x13, xzr
-    mov x14, xzr
-    mov x15, xzr
-    mov x16, xzr
-    mov x17, xzr
-    mov x18, xzr
-    mov x19, xzr
-    mov x20, xzr
-    mov x21, xzr
-    mov x22, xzr
-    mov x23, xzr
-    mov x24, xzr
-    mov x25, xzr
-    mov x26, xzr
-    mov x27, xzr
-    mov x28, xzr
-    mov x29, xzr
-    mov x30, xzr
-    br x0
-    udf #0
-"
-);
-
-#[cfg(target_arch = "x86")]
-global_asm!(
-    "
-.globl _start
-_start:
-    push esp
-    call relibc_ld_so_start
-    pop esp
-    # TODO: x86
-    ud2
-"
-);
-
-#[cfg(target_arch = "x86_64")]
-global_asm!(
-    "
-.weak _DYNAMIC
-.hidden _DYNAMIC
-
-.globl _start
-_start:
-    lea rsi, [rip + _start]
-
-    # Save original stack and align stack to 16 bytes
-    mov rbp, rsp
-    and rsp, 0xfffffffffffffff0
-
-    # Call ld_so_start(stack=rdi, ld_entry=rsi, dynamic=rdx)
-    mov rdi, rbp
-    lea rdx, [rip + _DYNAMIC]
-    call relibc_ld_so_start
-
-    # Restore original stack, clear registers, and jump to new start function
-    mov rsp, rbp
-    xor rcx, rcx
-    xor rdx, rdx
-    xor rdi, rdi
-    xor rsi, rsi
-    xor r8, r8
-    xor r9, r9
-    xor r10, r10
-    xor r11, r11
-    fninit
-    jmp rax
-    ud2
-"
-);
-
-#[cfg(target_arch = "riscv64")]
-global_asm!(
-    "
-.globl _start
-_start:
-    mv a0, sp
-    call relibc_ld_so_start
-    unimp
-"
-);
-
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn main(_argc: isize, _argv: *const *const i8) -> usize {
-    // LD
-    0x1D
-}
-
-#[linkage = "weak"]
-#[unsafe(no_mangle)]
-extern "C" fn relibc_panic(_pi: &::core::panic::PanicInfo) -> ! {
-    loop {}
-}
-
-#[panic_handler]
-#[linkage = "weak"]
-pub unsafe fn rust_begin_unwind(pi: &::core::panic::PanicInfo) -> ! {
-    relibc_panic(pi)
-}

linkers/aarch64.ld

@@ -0,0 +1,55 @@
+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*)
+	. = ALIGN(4096);
+        __text_end = .;
+    }
+
+    .rodata : AT(ADDR(.rodata) - KERNEL_OFFSET) {
+        __rodata_start = .;
+        *(.rodata*)
+	. = ALIGN(4096);
+        __rodata_end = .;
+    }
+
+    .data : AT(ADDR(.data) - KERNEL_OFFSET) {
+        *(.data*)
+	. = ALIGN(4096);
+        *(.bss*)
+	. = ALIGN(4096);
+    }
+
+    __end = .;
+
+    /DISCARD/ : {
+        *(.comment*)
+        *(.eh_frame*)
+        *(.gcc_except_table*)
+        *(.note*)
+        *(.rel.eh_frame*)
+    }
+}

linkers/i586.ld

@@ -0,0 +1,51 @@
+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*)
+    }
+
+    .rodata ALIGN(4K) : AT(ADDR(.rodata) - KERNEL_OFFSET) {
+        __text_end = .;
+        __rodata_start = .;
+        *(.rodata*)
+    }
+
+    .data ALIGN(4K) : AT(ADDR(.data) - KERNEL_OFFSET) {
+        __rodata_end = .;
+        *(.data*)
+        . = ALIGN(4K);
+        *(.bss*)
+        . = ALIGN(4K);
+    }
+
+    __end = .;
+
+    /DISCARD/ : {
+        *(.comment*)
+        *(.eh_frame*)
+        *(.gcc_except_table*)
+        *(.note*)
+        *(.rel.eh_frame*)
+    }
+}

linkers/riscv64.ld

@@ -0,0 +1,61 @@
+ENTRY(kstart)
+OUTPUT_FORMAT("elf64-littleriscv", "elf64-littleriscv", "elf64-littleriscv" )
+
+KERNEL_OFFSET = 0xFFFFFFFF80000000;
+
+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
+     * 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 = .;
+	*(.early_init.text*)
+	. = ALIGN(4096);
+        *(.text*)
+	. = ALIGN(4096);
+        __text_end = .;
+    }
+
+    .rodata : AT(ADDR(.rodata) - KERNEL_OFFSET) {
+        __rodata_start = .;
+        *(.rodata*)
+	. = ALIGN(4096);
+        __rodata_end = .;
+    }
+
+    .data : AT(ADDR(.data) - KERNEL_OFFSET) {
+        *(.data*)
+        *(.sdata*)
+	. = ALIGN(4096);
+        *(.got*)
+	. = ALIGN(4096);
+        *(.bss*)
+        *(.sbss*)
+	. = ALIGN(4096);
+    }
+
+    __end = .;
+
+    /DISCARD/ : {
+        *(.comment*)
+        *(.eh_frame*)
+        *(.gcc_except_table*)
+        *(.note*)
+        *(.rel.eh_frame*)
+    }
+}

linkers/x86_64.ld

@@ -0,0 +1,60 @@
+ENTRY(kstart)
+OUTPUT_FORMAT(elf64-x86-64)
+
+KERNEL_OFFSET = 0xFFFFFFFF80000000;
+
+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*)
+    }
+
+    .rodata ALIGN(4K) : AT(ADDR(.rodata) - KERNEL_OFFSET) {
+        __text_end = .;
+        __rodata_start = .;
+        *(.rodata*)
+        __altcode_start = .;
+        KEEP(*(.altcode*))
+        __altcode_end = .;
+        . = ALIGN(8);
+        __altrelocs_start = .;
+        KEEP(*(.altrelocs*))
+        __altrelocs_end = .;
+        __altfeatures_start = .;
+        KEEP(*(.altfeatures*))
+        __altfeatures_end = .;
+    }
+
+    .data ALIGN(4K) : AT(ADDR(.data) - KERNEL_OFFSET) {
+        __rodata_end = .;
+        *(.data*)
+        . = ALIGN(4K);
+        *(.bss*)
+    }
+
+    __end = .;
+
+    /DISCARD/ : {
+        *(.comment*)
+        *(.eh_frame*)
+        *(.gcc_except_table*)
+        *(.note*)
+        *(.rel.eh_frame*)
+    }
+}

redox-ioctl/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "redox-ioctl"
-authors = ["bjorn3 <bjorn3_gh@protonmail.com>"]
-version = "0.1.0"
-edition = "2024"
-license = "MIT"
-description = "Ioctl definitions and (de)serialization for Redox"
-
-[dependencies]
-drm-sys = "0.8.0"
-redox_syscall = "0.9.0"
-
-[features]
-
-[lints]
-workspace = true

redox-ioctl/src/drm.rs

@@ -1,347 +0,0 @@
-use alloc::vec::Vec;
-use core::{
-    cmp,
-    ffi::{c_char, c_int, c_uint},
-    iter, mem, slice,
-};
-
-pub use drm_sys::{
-    __kernel_size_t, DRM_PROP_NAME_LEN, drm_clip_rect, drm_get_cap, drm_mode_card_res,
-    drm_mode_closefb, drm_mode_connector_set_property, drm_mode_create_dumb, drm_mode_crtc,
-    drm_mode_crtc_page_flip_target, drm_mode_cursor, drm_mode_cursor2, drm_mode_destroy_dumb,
-    drm_mode_fb_cmd, drm_mode_fb_cmd2, drm_mode_fb_dirty_cmd, drm_mode_get_blob,
-    drm_mode_get_connector, drm_mode_get_encoder, drm_mode_get_plane, drm_mode_get_plane_res,
-    drm_mode_get_property, drm_mode_map_dumb, drm_mode_modeinfo, drm_mode_obj_get_properties,
-    drm_mode_property_enum, drm_mode_set_plane, drm_set_client_cap, drm_set_version, drm_unique,
-    drm_version,
-};
-
-pub const VERSION: u64 = 0;
-define_ioctl_data! {
-    struct drm_version, DrmVersion {
-        version_major: c_int,
-        version_minor: c_int,
-        version_patchlevel: c_int,
-        name_len: __kernel_size_t,
-        name: *mut c_char [array<c_char, name_len>],
-        date_len: __kernel_size_t,
-        date: *mut c_char [array<c_char, date_len>],
-        desc_len: __kernel_size_t,
-        desc: *mut c_char [array<c_char, desc_len>],
-    }
-}
-
-pub const GET_UNIQUE: u64 = 0x01;
-define_ioctl_data! {
-    struct drm_unique, DrmUnique {
-        unique_len: __kernel_size_t,
-        unique: *mut c_char [array<c_char, unique_len>],
-    }
-}
-
-pub const SET_VERSION: u64 = 0x07;
-define_ioctl_data! {
-    struct drm_set_version, DrmSetVersion {
-        drm_di_major: c_int,
-        drm_di_minor: c_int,
-        drm_dd_major: c_int,
-        drm_dd_minor: c_int,
-    }
-}
-
-pub const GET_CAP: u64 = 0x0C;
-pub use drm_sys::DRM_CAP_DUMB_BUFFER;
-define_ioctl_data! {
-    struct drm_get_cap, DrmGetCap {
-        capability: u64,
-        value: u64,
-    }
-}
-
-pub const SET_CLIENT_CAP: u64 = 0x0D;
-pub use drm_sys::DRM_CLIENT_CAP_CURSOR_PLANE_HOTSPOT;
-define_ioctl_data! {
-    struct drm_set_client_cap, DrmSetClientCap {
-        capability: u64,
-        value: u64,
-    }
-}
-
-pub const MODE_CARD_RES: u64 = 0xA0;
-define_ioctl_data! {
-    struct drm_mode_card_res, DrmModeCardRes {
-        fb_id_ptr: u64 [array<u32, count_fbs>],
-        crtc_id_ptr: u64 [array<u32, count_crtcs>],
-        connector_id_ptr: u64 [array<u32, count_connectors>],
-        encoder_id_ptr: u64 [array<u32, count_encoders>],
-        count_fbs: u32,
-        count_crtcs: u32,
-        count_connectors: u32,
-        count_encoders: u32,
-        min_width: u32,
-        max_width: u32,
-        min_height: u32,
-        max_height: u32,
-    }
-}
-
-pub const MODE_GET_CRTC: u64 = 0xA1;
-pub const MODE_SET_CRTC: u64 = 0xA2;
-define_ioctl_data! {
-    struct drm_mode_crtc, DrmModeCrtc {
-        set_connectors_ptr: u64 [array<u32, count_connectors>],
-        count_connectors: u32,
-        crtc_id: u32,
-        fb_id: u32,
-        x: u32,
-        y: u32,
-        gamma_size: u32,
-        mode_valid: u32,
-        mode: drm_mode_modeinfo,
-    }
-}
-
-pub const MODE_CURSOR: u64 = 0xA3;
-define_ioctl_data! {
-    struct drm_mode_cursor, DrmModeCursor {
-        flags: u32,
-        crtc_id: u32,
-        x: i32,
-        y:i32,
-        width:u32,
-        height:u32,
-        handle:u32,
-    }
-}
-
-pub const MODE_GET_ENCODER: u64 = 0xA6;
-define_ioctl_data! {
-    struct drm_mode_get_encoder, DrmModeGetEncoder {
-        encoder_id: u32,
-        encoder_type: u32,
-        crtc_id: u32,
-        possible_crtcs: u32,
-        possible_clones: u32,
-    }
-}
-
-pub const MODE_GET_CONNECTOR: u64 = 0xA7;
-define_ioctl_data! {
-    struct drm_mode_get_connector, DrmModeGetConnector {
-        encoders_ptr: u64 [array<u32, count_encoders>],
-        modes_ptr: u64 [array<drm_mode_modeinfo, count_modes>],
-        props_ptr: u64 [array<u32, count_props>],
-        prop_values_ptr: u64 [array<u64, count_props>],
-        count_modes: u32,
-        count_props: u32,
-        count_encoders: u32,
-        encoder_id: u32,
-        connector_id: u32,
-        connector_type: u32,
-        connector_type_id: u32,
-        connection: u32,
-        mm_width: u32,
-        mm_height: u32,
-        subpixel: u32,
-        pad: u32,
-    }
-}
-
-pub const MODE_GET_PROPERTY: u64 = 0xAA;
-define_ioctl_data! {
-    struct drm_mode_get_property, DrmModeGetProperty {
-        values_ptr: u64 [array<u64, count_values>],
-        enum_blob_ptr: u64 [array<drm_mode_property_enum, count_enum_blobs>],
-        prop_id: u32,
-        flags: u32,
-        name: [c_char; DRM_PROP_NAME_LEN as usize],
-        count_values: u32,
-        count_enum_blobs: u32,
-    }
-}
-
-pub const MODE_SET_PROPERTY: u64 = 0xAB;
-define_ioctl_data! {
-    struct drm_mode_connector_set_property, DrmModeConnectorSetProperty {
-        value: u64,
-        prop_id: u32,
-        connector_id: u32,
-    }
-}
-
-pub const MODE_GET_PROP_BLOB: u64 = 0xAC;
-define_ioctl_data! {
-    struct drm_mode_get_blob, DrmModeGetBlob {
-        blob_id: u32,
-        length: u32,
-        data: u64 [array<u8, length>],
-    }
-}
-
-pub const MODE_GET_FB: u64 = 0xAD;
-pub const MODE_ADD_FB: u64 = 0xAE;
-define_ioctl_data! {
-    struct drm_mode_fb_cmd, DrmModeFbCmd {
-        fb_id: u32,
-        width: u32,
-        height: u32,
-        pitch: u32,
-        bpp: u32,
-        depth: u32,
-        handle: u32,
-    }
-}
-
-pub const MODE_RM_FB: u64 = 0xAF;
-define_ioctl_data! {
-    struct standin_for_uint, StandinForUint {
-        inner: c_uint,
-    }
-}
-
-#[repr(transparent)]
-#[allow(non_camel_case_types)]
-pub struct standin_for_uint {
-    pub inner: c_uint,
-}
-
-pub const MODE_PAGE_FLIP: u64 = 0xB0;
-define_ioctl_data! {
-    struct drm_mode_crtc_page_flip_target, DrmModeCrtcPageFlipTarget {
-        crtc_id: u32,
-        fb_id: u32,
-        flags: u32,
-        sequence: u32,
-        user_data: u64,
-    }
-}
-
-pub const MODE_DIRTYFB: u64 = 0xB1;
-define_ioctl_data! {
-    struct drm_mode_fb_dirty_cmd, DrmModeFbDirtyCmd {
-        fb_id: u32,
-        flags: u32,
-        color: u32,
-        num_clips: u32,
-        clips_ptr: u64 [array<drm_clip_rect, num_clips>],
-    }
-}
-
-pub const MODE_CREATE_DUMB: u64 = 0xB2;
-define_ioctl_data! {
-    struct drm_mode_create_dumb, DrmModeCreateDumb {
-        height: u32,
-        width: u32,
-        bpp: u32,
-        flags: u32,
-        handle: u32,
-        pitch: u32,
-        size: u64,
-    }
-}
-
-pub const MODE_MAP_DUMB: u64 = 0xB3;
-define_ioctl_data! {
-    struct drm_mode_map_dumb, DrmModeMapDumb {
-        handle: u32,
-        pad: u32,
-        offset: u64,
-    }
-}
-
-pub const MODE_DESTROY_DUMB: u64 = 0xB4;
-define_ioctl_data! {
-    struct drm_mode_destroy_dumb, DrmModeDestroyDumb {
-        handle: u32,
-    }
-}
-
-pub const MODE_GET_PLANE_RES: u64 = 0xB5;
-define_ioctl_data! {
-    struct drm_mode_get_plane_res, DrmModeGetPlaneRes {
-        plane_id_ptr: u64 [array<u32, count_planes>],
-        count_planes: u32,
-    }
-}
-
-pub const MODE_GET_PLANE: u64 = 0xB6;
-define_ioctl_data! {
-    struct drm_mode_get_plane, DrmModeGetPlane {
-        plane_id: u32,
-        crtc_id: u32,
-        fb_id: u32,
-        possible_crtcs: u32,
-        gamma_size: u32,
-        count_format_types: u32,
-        format_type_ptr: u64 [array<u32, count_format_types>],
-    }
-}
-
-pub const MODE_SET_PLANE: u64 = 0xB7;
-define_ioctl_data! {
-    struct drm_mode_set_plane, DrmModeSetPlane {
-        plane_id: u32,
-        crtc_id: u32,
-        fb_id: u32,
-        flags: u32,
-        crtc_x: i32,
-        crtc_y: i32,
-        crtc_w: u32,
-        crtc_h: u32,
-        src_x: u32,
-        src_y: u32,
-        src_h: u32,
-        src_w: u32,
-    }
-}
-
-pub const MODE_ADD_FB2: u64 = 0xB8;
-
-pub const MODE_OBJ_GET_PROPERTIES: u64 = 0xB9;
-define_ioctl_data! {
-    struct drm_mode_obj_get_properties, DrmModeObjGetProperties {
-        props_ptr: u64 [array<u32, count_props>],
-        prop_values_ptr: u64 [array<u64, count_props>],
-        count_props: u32,
-        obj_id: u32,
-        obj_type: u32,
-    }
-}
-
-pub const MODE_CURSOR2: u64 = 0xBB;
-define_ioctl_data! {
-    struct drm_mode_cursor2, DrmModeCursor2 {
-        flags: u32,
-        crtc_id: u32,
-        x: i32,
-        y: i32,
-        width: u32,
-        height: u32,
-        handle: u32,
-        hot_x: i32,
-        hot_y: i32,
-    }
-}
-
-pub const MODE_GET_FB2: u64 = 0xCE;
-define_ioctl_data! {
-    struct drm_mode_fb_cmd2, DrmModeFbCmd2 {
-        fb_id: u32,
-        width: u32,
-        height: u32,
-        pixel_format: u32,
-        flags: u32,
-        handles: [u32; 4],
-        pitches: [u32; 4],
-        offsets: [u32; 4],
-        modifier: [u64; 4],
-    }
-}
-
-pub const MODE_CLOSE_FB: u64 = 0xD0;
-define_ioctl_data! {
-    struct drm_mode_closefb, DrmModeClosefb {
-        fb_id: u32,
-        pad: u32,
-    }
-}

redox-ioctl/src/ioctl_data.rs

@@ -1,168 +0,0 @@
-use alloc::vec::Vec;
-
-pub trait IoctlData {
-    unsafe fn write(&self) -> Vec<u8>;
-    unsafe fn read_from(&mut self, buf: &[u8]);
-}
-
-macro_rules! define_ioctl_data {
-    (struct $ioctl_ty:ident, $mem_ty:ident {
-        $($rest:tt)*
-    }) => {
-        define_ioctl_data!(
-            struct $ioctl_ty, $mem_ty { $($rest)* } => (), (), ()
-        );
-    };
-    (struct $ioctl_ty:ident, $mem_ty:ident {
-        $field:ident: $ty:ty,
-        $($rest:tt)*
-    } =>
-        ($($ioctl_fields:tt)*),
-        ($($counted_fields:tt)*),
-        ($($noncounted_fields:tt)*)
-    ) => {
-        define_ioctl_data!(
-            struct $ioctl_ty, $mem_ty { $($rest)* } =>
-                ($($ioctl_fields)* $field: $ty,),
-                ($($counted_fields)*),
-                ($($noncounted_fields)* $field: $ty,)
-        );
-    };
-    (struct $ioctl_ty:ident, $mem_ty:ident {
-        $field:ident: $ty:ty [array<$el:ty, $counted_by:ident>],
-        $($rest:tt)*
-    } =>
-        ($($ioctl_fields:tt)*),
-        ($($counted_fields:tt)*),
-        ($($noncounted_fields:tt)*)
-    ) => {
-        define_ioctl_data!(
-            struct $ioctl_ty, $mem_ty { $($rest)* } =>
-                ($($ioctl_fields)* $field: $ty,),
-                ($($counted_fields)* $field: $ty [array<$el, $counted_by>],),
-                ($($noncounted_fields)*)
-        );
-    };
-    (struct $ioctl_ty:ident, $mem_ty:ident {} =>
-        ($($ioctl_field:ident: $ioctl_field_ty:ty,)*),
-        ($($counted_field:ident: $counted_ty:ty [array<$el:ty, $counted_by:ident>],)*),
-        ($($noncounted_field:ident: $noncounted_ty:ty,)*)
-    ) => {
-        // FIXME check ioctl_ty doesn't have padding
-        const _: $ioctl_ty = $ioctl_ty {
-            $($ioctl_field: unsafe { mem::zeroed::<$ioctl_field_ty>() },)*
-        };
-
-        #[repr(C)]
-        pub struct ${concat(__, $mem_ty, Noncounted)} {
-            $($noncounted_field: $noncounted_ty,)*
-        }
-
-        pub struct $mem_ty<'a> {
-            noncounted_fields: &'a mut ${concat(__, $mem_ty, Noncounted)},
-            $($counted_field: &'a mut [$el],)*
-        }
-
-        impl $crate::ioctl_data::IoctlData for $ioctl_ty {
-            unsafe fn write(&self) -> Vec<u8> {
-                let noncounted_fields = ${concat(__, $mem_ty, Noncounted)} {
-                    $($noncounted_field: self.$noncounted_field,)*
-                };
-                // FIXME use Vec::with_capacity
-                let mut data = Vec::<u8>::new();
-                data.extend_from_slice(&unsafe {
-                    mem::transmute::<
-                        ${concat(__, $mem_ty, Noncounted)},
-                        [u8; size_of::<${concat(__, $mem_ty, Noncounted)}>()],
-                    >(noncounted_fields)
-                });
-                $(
-                    let size = self.$counted_by as usize * size_of::<$el>();
-                    if self.$counted_field as usize != 0 {
-                        let $counted_field = unsafe {
-                            slice::from_raw_parts(self.$counted_field as *const u8, size)
-                        };
-                        data.extend_from_slice(&$counted_field);
-                    } else {
-                        data.extend(iter::repeat(0u8).take(size));
-                    };
-
-                )*
-                data
-            }
-
-            unsafe fn read_from(&mut self, mut buf: &[u8]) {
-                // FIXME be robust against malicious scheme implementations by returning an error
-                // when the buf is the wrong size
-                let noncounted_fields = buf.split_off(..size_of::<${concat(__, $mem_ty, Noncounted)}>()).unwrap();
-
-                $(
-                    let size = self.$counted_by as usize * size_of::<$el>();
-                    let $counted_field = buf.split_off(..size).unwrap();
-                    if self.$counted_field as usize != 0 {
-                        unsafe {
-                            slice::from_raw_parts_mut(self.$counted_field as *mut u8, size).copy_from_slice($counted_field);
-                        }
-                    }
-                )*
-
-                assert!(buf.is_empty());
-
-                let noncounted_fields = unsafe { &*core::ptr::from_ref(noncounted_fields).cast::<${concat(__, $mem_ty, Noncounted)}>() };
-                $(self.$noncounted_field = noncounted_fields.$noncounted_field;)*
-            }
-        }
-
-        impl<'a> $mem_ty<'a> {
-            pub fn with(
-                mut buf: &'a mut [u8],
-                f: impl FnOnce($mem_ty<'a>) -> syscall::Result<usize>,
-            ) -> syscall::Result<usize> {
-                let noncounted_fields = buf.split_off_mut(..size_of::<${concat(__, $mem_ty, Noncounted)}>())
-                    .ok_or(syscall::Error::new(syscall::EINVAL))?;
-                let noncounted_fields = unsafe { &mut *core::ptr::from_mut(noncounted_fields).cast::<${concat(__, $mem_ty, Noncounted)}>() };
-
-                $(
-                    let $counted_field = buf.split_off_mut(..noncounted_fields.$counted_by as usize * size_of::<$el>())
-                        .ok_or(syscall::Error::new(syscall::EINVAL))?;
-                    let $counted_field = unsafe {
-                        slice::from_raw_parts_mut(core::ptr::from_mut($counted_field).cast::<$el>(), noncounted_fields.$counted_by as usize)
-                    };
-                )*
-
-                if !buf.is_empty() {
-                    return Err(syscall::Error::new(syscall::EINVAL));
-                }
-
-
-                f($mem_ty {
-                    noncounted_fields,
-                    $($counted_field,)*
-                })
-            }
-
-            $(
-                pub fn $noncounted_field(&self) -> $noncounted_ty {
-                    self.noncounted_fields.$noncounted_field
-                }
-
-                /// Should not be called for fields used as array length
-                pub fn ${concat(set_, $noncounted_field)}(&mut self, data: $noncounted_ty) {
-                    self.noncounted_fields.$noncounted_field = data;
-                }
-            )*
-
-            $(
-                pub fn $counted_field(&self) -> &[$el] {
-                    self.$counted_field
-                }
-
-                pub fn ${concat(set_, $counted_field)}(&mut self, data: &[$el]) {
-                    let copied_count = cmp::min(data.len(), self.$counted_field.len());
-                    self.$counted_field[..copied_count].copy_from_slice(&data[..copied_count]);
-                    self.noncounted_fields.$counted_by = data.len() as _;
-                }
-            )*
-        }
-    };
-}

redox-ioctl/src/lib.rs

@@ -1,11 +0,0 @@
-#![feature(macro_metavar_expr_concat)]
-#![deny(unsafe_op_in_unsafe_fn)]
-#![no_std]
-
-extern crate alloc;
-
-#[macro_use]
-mod ioctl_data;
-pub use ioctl_data::IoctlData;
-
-pub mod drm;

redox-rt/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-name = "redox-rt"
-authors = ["4lDO2 <4lDO2@protonmail.com>"]
-version = "0.1.0"
-edition = "2024"
-license = "MIT"
-description = "Libc-independent runtime for Redox"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-bitflags.workspace = true
-goblin = { version = "0.10", default-features = false, features = ["elf32", "elf64", "endian_fd"] }
-plain.workspace = true
-ioslice.workspace = true
-redox_syscall.workspace = true
-redox-path.workspace = true
-redox_protocols.workspace = true
-
-generic-rt = { path = "../generic-rt" }
-
-[features]
-proc = []
-default = ["proc"]
-
-[lints]
-workspace = true

redox-rt/src/arch/aarch64.rs

@@ -1,492 +0,0 @@
-use core::{cell::SyncUnsafeCell, mem::offset_of, ptr::NonNull};
-
-use syscall::{data::*, error::*};
-
-use crate::{
-    Tcb,
-    proc::{FdGuard, FdGuardUpper, ForkArgs, fork_inner},
-    signal::{PosixStackt, RtSigarea, SigStack, inner_c},
-};
-use redox_protocols::protocol::{ProcCall, RtSigInfo};
-
-use super::ForkScratchpad;
-
-// Setup a stack starting from the very end of the address space, and then growing downwards.
-pub const STACK_TOP: usize = 1 << 47;
-pub const STACK_SIZE: usize = 1024 * 1024;
-
-#[derive(Debug, Default)]
-#[repr(C)]
-pub struct SigArea {
-    pub altstack_top: usize,
-    pub altstack_bottom: usize,
-    pub tmp_x1_x2: [usize; 2],
-    pub tmp_x3_x4: [usize; 2],
-    pub tmp_x5_x6: [usize; 2],
-    pub tmp_x7_x8: [usize; 2],
-    pub tmp_sp: usize,
-    pub onstack: u64,
-    pub disable_signals_depth: u64,
-    pub pctl: usize, // TODO: remove
-    pub last_sig_was_restart: bool,
-    pub last_sigstack: Option<NonNull<SigStack>>,
-    pub tmp_rt_inf: RtSigInfo,
-    pub tmp_id_inf: u64,
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct ArchIntRegs {
-    pub x30: usize,
-    pub x29: usize,
-    pub x28: usize,
-    pub x27: usize,
-    pub x26: usize,
-    pub x25: usize,
-    pub x24: usize,
-    pub x23: usize,
-    pub x22: usize,
-    pub x21: usize,
-    pub x20: usize,
-    pub x19: usize,
-    pub x18: usize,
-    pub x17: usize,
-    pub x16: usize,
-    pub x15: usize,
-    pub x14: usize,
-    pub x13: usize,
-    pub x12: usize,
-    pub x11: usize,
-    pub x10: usize,
-    pub x9: usize,
-    pub x8: usize,
-    pub x7: usize,
-    pub x6: usize,
-    pub x5: usize,
-    pub x4: usize,
-    pub x3: usize,
-    pub x2: usize,
-    pub x1: usize,
-
-    pub sp: usize,
-    pub nzcv: usize, // user-accessible PSTATE bits
-
-    pub pc: usize,
-    pub x0: usize,
-}
-
-/// Deactive TLS, used before exec() on Redox to not trick target executable into thinking TLS
-/// is already initialized as if it was a thread.
-pub unsafe fn deactivate_tcb(open_via_dup: &FdGuardUpper) -> Result<()> {
-    let mut env = syscall::EnvRegisters::default();
-
-    let file = open_via_dup.dup_into_upper(b"regs/env")?;
-
-    env.tpidr_el0 = 0;
-
-    file.write(&mut env)?;
-    crate::TLS_ACTIVATED.store(false, core::sync::atomic::Ordering::Relaxed);
-    Ok(())
-}
-
-unsafe extern "C" fn fork_impl(args: &ForkArgs, initial_rsp: *mut usize) -> usize {
-    Error::mux(fork_inner(initial_rsp, args))
-}
-
-unsafe extern "C" fn child_hook(scratchpad: &ForkScratchpad) {
-    //let _ = syscall::write(1, alloc::format!("CUR{cur_filetable_fd}PROC{new_proc_fd}THR{new_thr_fd}\n").as_bytes());
-    let _ = crate::sys::close(scratchpad.cur_filetable_fd);
-    unsafe {
-        crate::child_hook_common(crate::ChildHookCommonArgs {
-            new_thr_fd: FdGuard::new(scratchpad.new_thr_fd),
-            new_proc_fd: if scratchpad.new_proc_fd == usize::MAX {
-                None
-            } else {
-                Some(FdGuard::new(scratchpad.new_proc_fd))
-            },
-            new_filetable_fd: FdGuard::new(scratchpad.new_filetable_fd)
-                .to_upper()
-                .unwrap(),
-        })
-    };
-}
-
-asmfunction!(__relibc_internal_fork_wrapper (usize) -> usize: ["
-    stp     x29, x30, [sp, #-16]!
-    stp     x27, x28, [sp, #-16]!
-    stp     x25, x26, [sp, #-16]!
-    stp     x23, x24, [sp, #-16]!
-    stp     x21, x22, [sp, #-16]!
-    stp     x19, x20, [sp, #-16]!
-
-    //TODO: store floating point regs
-
-    // x0: &ForkArgs
-    mov x1, sp
-    bl {fork_impl}
-
-    ldp     x19, x20, [sp], #16
-    ldp     x21, x22, [sp], #16
-    ldp     x23, x24, [sp], #16
-    ldp     x25, x26, [sp], #16
-    ldp     x27, x28, [sp], #16
-    ldp     x29, x30, [sp], #16
-    ret
-"] <= [fork_impl = sym fork_impl]);
-
-asmfunction!(__relibc_internal_fork_ret: ["
-    # scratchpad is in x1, move to x0 for child_hook
-    mov x0, x1
-
-    bl {child_hook}
-
-    //TODO: load floating point regs
-
-    mov x0, xzr
-
-    ldp     x19, x20, [sp], #16
-    ldp     x21, x22, [sp], #16
-    ldp     x23, x24, [sp], #16
-    ldp     x25, x26, [sp], #16
-    ldp     x27, x28, [sp], #16
-    ldp     x29, x30, [sp], #16
-
-    ret
-"] <= [child_hook = sym child_hook]);
-
-// https://devblogs.microsoft.com/oldnewthing/20220811-00/?p=106963
-asmfunction!(__relibc_internal_sigentry: ["
-    // Clear any active reservation.
-    clrex
-
-    // The old pc and x0 are saved in the sigcontrol struct.
-    mrs x0, tpidr_el0 // ABI ptr
-    ldr x0, [x0] // TCB ptr
-
-    // Save x1-x6 and sp
-    stp x1, x2, [x0, #{tcb_sa_off} + {sa_tmp_x1_x2}]
-    stp x3, x4, [x0, #{tcb_sa_off} + {sa_tmp_x3_x4}]
-    stp x5, x6, [x0, #{tcb_sa_off} + {sa_tmp_x5_x6}]
-    stp x7, x8, [x0, #{tcb_sa_off} + {sa_tmp_x7_x8}]
-    mov x1, sp
-    str x1, [x0, #{tcb_sa_off} + {sa_tmp_sp}]
-
-    ldr x6, [x0, #{tcb_sa_off} + {sa_pctl}]
-1:
-    // Load x1 with the thread's bits
-    add x5, x0, #{tcb_sc_off} + {sc_word}
-    ldaxr x1, [x5]
-
-    // First check if there are standard thread signals,
-    and x4, x1, x1, lsr #32 // x4 := x1 & (x1 >> 32)
-    cbnz x4, 3f // jump if x4 != 0
-    clrex
-
-    // and if not, load process pending bitset.
-    add x5, x6, #{pctl_pending}
-    ldaxr x2, [x5]
-
-    // Check if there are standard proc signals:
-    lsr x3, x1, #32 // mask
-    and w3, w2, w3 // pending unblocked proc
-    cbz w3, 4f // skip 'fetch_andn' step if zero
-
-    // If there was one, find which one, and try clearing the bit (last value in x3, addr in x6)
-    // this picks the MSB rather than the LSB, unlike x86. POSIX does not require any specific
-    // ordering though.
-    clz w3, w3
-    mov w4, #31
-    sub w3, w4, w3
-    // x3 now contains the sig_idx
-
-    mov x4, #1
-    lsl x4, x4, x3 // bit to remove
-
-    sub x4, x2, x4 // bit was certainly set, so sub is allowed
-    // x4 is now the new mask to be set
-    add x5, x6, #{pctl_pending}
-
-    add x2, x5, #{pctl_sender_infos}
-    add x2, x2, w3, uxtb 3
-    ldar x2, [x2]
-
-    // Try clearing the bit, retrying on failure.
-    stxr w1, x4, [x5] // try setting pending set to x4, set w1 := 0 on success
-    cbnz w1, 1b // retry everything if this fails
-    mov x1, x3
-    b 2f
-4:
-    // Check for realtime signals, thread/proc.
-    clrex
-
-    // Load the pending set again. TODO: optimize this?
-    // Process pending - realtime
-    add x1, x6, #{pctl_pending}
-    ldaxr x2, [x1]
-    lsr x2, x2, #32
-
-    // Thread pending - realtime and allowset
-    add x5, x0, #{tcb_sc_off} + {sc_word} + 8
-    ldar x1, [x5]
-
-    orr x2, x1, x2 // combine proc and thread pending
-    and x2, x2, x2, lsr #32 // AND pending with allowset
-    cbz x2, 7f // spurious signal if realtime is clear
-
-    rbit x2, x2
-    clz x2, x2
-    // x2 now contains sig_idx - 32
-
-    // If realtime signal was directed at thread, handle it as an idempotent signal.
-    lsr x3, x1, x2 // x3 := x1 >> x2; x1 is thread pending
-    tbnz x3, #0, 5f // jump if bit is nonzero
-
-    // SYS_CALL(fd, payload_base, payload_len, metadata_len, metadata_base | (flags << 8))
-    // x8       x0  x1            x2           x3            x4
-
-    mov x5, x0 // save TCB pointer
-    mov x6, x2
-    ldr x8, ={SYS_CALL}
-    adrp x0, {proc_fd}
-    ldr x0, [x0, #:lo12:{proc_fd}]
-    add x1, x5, #{tcb_sa_off} + {sa_tmp_rt_inf}
-    str x6, [x1]
-    mov x2, #{RTINF_SIZE}
-    adrp x4, {proc_call}
-    add x4, x4, :lo12:{proc_call}
-    mov x3, #1
-    svc 0
-    mov x3, x0
-    mov x0, x5 // restore TCB pointer
-    mov x2, x6 // restore signal number - 32
-    add x1, x2, #32 // signal number
-    cbnz x3, 1b
-    b 2f
-5:
-    // A realtime signal was sent to this thread, try clearing its bit.
-    // x3 contains last rt signal word, x2 contains rt_idx
-    clrex
-
-    // Calculate the absolute sig_idx
-    add x1, x3, 32
-
-    // Load si_pid and si_uid
-    add x2, x0, #{tcb_sc_off} + {sc_sender_infos}
-    add x2, x2, w1, uxtb #3
-    ldar x2, [x2]
-
-    add x3, x0, #{tcb_sc_off} + {sc_word} + 8
-    ldxr x2, [x3]
-
-    // Calculate new mask
-    mov x4, #1
-    lsl x4, x4, x2
-    sub x2, x2, x4 // remove bit
-
-    stxr w5, x2, [x3]
-    cbnz w5, 1b
-    str x2, [x0, #{tcb_sa_off} + {sa_tmp_id_inf}]
-    b 2f
-3:
-    // A standard signal was sent to this thread, try clearing its bit.
-    clz w1, w1
-    mov x2, #31
-    sub x1, x2, x1
-
-    // Load si_pid and si_uid
-    add x2, x0, #{tcb_sc_off} + {sc_sender_infos}
-    add x2, x2, w1, uxtb #3
-    ldar x2, [x2]
-
-    // Clear bit from mask
-    mov x3, #1
-    lsl x3, x3, x1
-    sub x4, x4, x3
-
-    // Try updating the mask
-    stxr w3, x1, [x5]
-    cbnz w3, 1b
-
-    str x2, [x0, #{tcb_sa_off} + {sa_tmp_id_inf}]
-2:
-    ldr x3, [x0, #{tcb_sa_off} + {sa_pctl}]
-    add x3, x3, {pctl_actions}
-    add x2, x3, w1, uxtb #4 // actions_base + sig_idx * sizeof Action
-    // TODO: NOT ATOMIC (tearing allowed between regs)!
-    ldxp x2, x3, [x2]
-    clrex
-
-    // Calculate new sp wrt redzone and alignment
-    mov x4, sp
-    sub x4, x4, {REDZONE_SIZE}
-    and x4, x4, -{STACK_ALIGN}
-    mov sp, x4
-
-    // skip sigaltstack step if SA_ONSTACK is clear
-    // tbz x2, #{SA_ONSTACK_BIT}, 2f
-
-    ldr x2, [x0, #{tcb_sc_off} + {sc_saved_pc}]
-    ldr x3, [x0, #{tcb_sc_off} + {sc_saved_x0}]
-    stp x2, x3, [sp, #-16]!
-
-    ldr x2, [x0, #{tcb_sa_off} + {sa_tmp_sp}]
-    mrs x3, nzcv
-    stp x2, x3, [sp, #-16]!
-
-    ldp x2, x3, [x0, #{tcb_sa_off} + {sa_tmp_x1_x2}]
-    stp x2, x3, [sp, #-16]!
-    ldp x3, x4, [x0, #{tcb_sa_off} + {sa_tmp_x3_x4}]
-    stp x4, x3, [sp, #-16]!
-    ldp x5, x6, [x0, #{tcb_sa_off} + {sa_tmp_x5_x6}]
-    stp x6, x5, [sp, #-16]!
-    ldp x7, x8, [x0, #{tcb_sa_off} + {sa_tmp_x7_x8}]
-    stp x8, x7, [sp, #-16]!
-
-    stp x10, x9, [sp, #-16]!
-    stp x12, x11, [sp, #-16]!
-    stp x14, x13, [sp, #-16]!
-    stp x16, x15, [sp, #-16]!
-    stp x18, x17, [sp, #-16]!
-    stp x20, x19, [sp, #-16]!
-    stp x22, x21, [sp, #-16]!
-    stp x24, x23, [sp, #-16]!
-    stp x26, x25, [sp, #-16]!
-    stp x28, x27, [sp, #-16]!
-    stp x30, x29, [sp, #-16]!
-
-    str w1, [sp, #-4]
-    sub sp, sp, #64
-
-    mov x0, sp
-    bl {inner}
-
-    add sp, sp, #64
-
-    ldp x30, x29, [sp], #16
-    ldp x28, x27, [sp], #16
-    ldp x26, x25, [sp], #16
-    ldp x24, x23, [sp], #16
-    ldp x22, x21, [sp], #16
-    ldp x20, x19, [sp], #16
-    ldp x18, x17, [sp], #16
-    ldp x16, x15, [sp], #16
-    ldp x14, x13, [sp], #16
-    ldp x12, x11, [sp], #16
-    ldp x10, x9, [sp], #16
-    ldp x8, x7, [sp], #16
-    ldp x6, x5, [sp], #16
-    ldp x4, x3, [sp], #16
-    ldp x2, x1, [sp], #16
-
-    ldr x0, [sp, #8]
-    msr nzcv, x0
-
-8:
-    // x18 is reserved by ABI as 'platform register', so clobbering it should be safe.
-    mov x18, sp
-    ldr x0, [x18]
-    mov sp, x0
-
-    ldp x18, x0, [x18, #16]
-    br x18
-7:
-    // Spurious signal, i.e. all bitsets were 0 at the time they were checked
-    clrex
-
-    ldr x1, [x0, #{tcb_sc_off} + {sc_flags}]
-    and x1, x1, ~1
-    str x1, [x0, #{tcb_sc_off} + {sc_flags}]
-
-    ldp x1, x2, [x0, #{tcb_sa_off} + {sa_tmp_x1_x2}]
-    ldp x3, x4, [x0, #{tcb_sa_off} + {sa_tmp_x3_x4}]
-    ldp x5, x6, [x0, #{tcb_sa_off} + {sa_tmp_x5_x6}]
-    ldr x18, [x0, #{tcb_sc_off} + {sc_saved_pc}]
-    ldr x0, [x0, #{tcb_sc_off} + {sc_saved_x0}]
-    br x18
-"] <= [
-    pctl_pending = const (offset_of!(SigProcControl, pending)),
-    pctl_actions = const (offset_of!(SigProcControl, actions)),
-    pctl_sender_infos = const (offset_of!(SigProcControl, sender_infos)),
-    tcb_sc_off = const (offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control)),
-    tcb_sa_off = const (offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, arch)),
-    sa_tmp_x1_x2 = const offset_of!(SigArea, tmp_x1_x2),
-    sa_tmp_x3_x4 = const offset_of!(SigArea, tmp_x3_x4),
-    sa_tmp_x5_x6 = const offset_of!(SigArea, tmp_x5_x6),
-    sa_tmp_x7_x8 = const offset_of!(SigArea, tmp_x7_x8),
-    sa_tmp_sp = const offset_of!(SigArea, tmp_sp),
-    sa_tmp_rt_inf = const offset_of!(SigArea, tmp_rt_inf),
-    sa_tmp_id_inf = const offset_of!(SigArea, tmp_id_inf),
-    sa_pctl = const offset_of!(SigArea, pctl),
-    sc_saved_pc = const offset_of!(Sigcontrol, saved_ip),
-    sc_saved_x0 = const offset_of!(Sigcontrol, saved_archdep_reg),
-    sc_sender_infos = const offset_of!(Sigcontrol, sender_infos),
-    sc_word = const offset_of!(Sigcontrol, word),
-    sc_flags = const offset_of!(Sigcontrol, control_flags),
-    proc_fd = sym PROC_FD,
-    inner = sym inner_c,
-    proc_call = sym PROC_CALL,
-
-    SA_ONSTACK_BIT = const 58, // (1 << 58) >> 32 = 0x0400_0000
-
-    SYS_CALL = const syscall::SYS_CALL,
-
-    STACK_ALIGN = const 16,
-    REDZONE_SIZE = const 128,
-    RTINF_SIZE = const size_of::<RtSigInfo>(),
-]);
-
-asmfunction!(__relibc_internal_rlct_clone_ret: ["
-    # Load registers
-    ldp x8, x0, [sp], #16
-    ldp x1, x2, [sp], #16
-    ldp x3, x4, [sp], #16
-
-    # Call entry point
-    blr x8
-
-    ret
-"] <= []);
-
-pub fn current_sp() -> usize {
-    let sp: usize;
-    unsafe {
-        core::arch::asm!("mov {}, sp", out(reg) sp);
-    }
-    sp
-}
-
-pub unsafe fn manually_enter_trampoline() {
-    let ctl = unsafe { &Tcb::current().unwrap().os_specific.control };
-
-    ctl.saved_archdep_reg.set(0);
-    let ip_location = &ctl.saved_ip as *const _ as usize;
-
-    unsafe {
-        core::arch::asm!("
-                bl 2f
-                b 3f
-            2:
-                str lr, [x0]
-                b __relibc_internal_sigentry
-            3:
-            ",
-            inout("x0") ip_location => _, out("lr") _);
-    }
-}
-
-pub unsafe fn arch_pre(stack: &mut SigStack, os: &mut SigArea) -> PosixStackt {
-    PosixStackt {
-        sp: core::ptr::null_mut(), // TODO
-        size: 0,                   // TODO
-        flags: 0,                  // TODO
-    }
-}
-pub fn arch_ret_to_sig(stack: &mut SigStack, control: &Sigcontrol) {
-    let orig_pc = core::mem::replace(
-        &mut stack.regs.pc,
-        __relibc_internal_sigentry as *const () as usize,
-    );
-    control.saved_ip.set(orig_pc);
-    control.saved_archdep_reg.set(stack.regs.x0);
-}
-pub(crate) static PROC_FD: SyncUnsafeCell<usize> = SyncUnsafeCell::new(usize::MAX);
-static PROC_CALL: [usize; 1] = [ProcCall::Sigdeq as usize];

redox-rt/src/arch/i686.rs

@@ -1,418 +0,0 @@
-use core::{cell::SyncUnsafeCell, mem::offset_of, ptr::NonNull, sync::atomic::Ordering};
-
-use syscall::*;
-
-use crate::{
-    proc::{FdGuard, FdGuardUpper, ForkArgs, fork_inner},
-    signal::{PROC_CONTROL_STRUCT, PosixStackt, RtSigarea, SigStack, inner_fastcall},
-};
-use redox_protocols::protocol::{ProcCall, RtSigInfo};
-
-use super::ForkScratchpad;
-
-// Setup a stack starting from the very end of the address space, and then growing downwards.
-pub const STACK_TOP: usize = 1 << 31;
-pub const STACK_SIZE: usize = 1024 * 1024;
-
-#[derive(Debug, Default)]
-#[repr(C)]
-pub struct SigArea {
-    pub altstack_top: usize,
-    pub altstack_bottom: usize,
-    pub tmp_eip: usize,
-    pub tmp_esp: usize,
-    pub tmp_eax: usize,
-    pub tmp_ebx: usize,
-    pub tmp_ecx: usize,
-    pub tmp_edx: usize,
-    pub tmp_edi: usize,
-    pub tmp_esi: usize,
-    pub tmp_rt_inf: RtSigInfo,
-    pub tmp_signo: usize,
-    pub tmp_id_inf: u64,
-    pub tmp_mm0: u64,
-    pub disable_signals_depth: u64,
-    pub last_sig_was_restart: bool,
-    pub last_sigstack: Option<NonNull<SigStack>>,
-}
-#[derive(Debug, Default)]
-#[repr(C, align(16))]
-pub struct ArchIntRegs {
-    pub fxsave: [u16; 29],
-
-    // ensure fxsave region is 16 byte aligned
-    pub _pad: [usize; 2], // fxsave "available" +0
-
-    pub ebp: usize, // fxsave "available" +8
-    pub esi: usize, // avail +12
-    pub edi: usize, // avail +16
-    pub ebx: usize, // avail +20
-    pub eax: usize, // avail +24
-    pub ecx: usize, // avail +28
-    pub edx: usize, // avail +32
-
-    pub eflags: usize, // avail +36
-    pub eip: usize,    // avail +40
-    pub esp: usize,    // avail +44
-}
-
-/// Deactive TLS, used before exec() on Redox to not trick target executable into thinking TLS
-/// is already initialized as if it was a thread.
-pub unsafe fn deactivate_tcb(open_via_dup: &FdGuardUpper) -> Result<()> {
-    let mut env = syscall::EnvRegisters::default();
-
-    let file = open_via_dup.dup_into_upper(b"regs/env")?;
-
-    env.fsbase = 0;
-    env.gsbase = 0;
-
-    file.write(&mut env)?;
-    crate::TLS_ACTIVATED.store(false, core::sync::atomic::Ordering::Relaxed);
-    Ok(())
-}
-
-unsafe extern "fastcall" fn fork_impl(args: &ForkArgs, initial_rsp: *mut usize) -> usize {
-    Error::mux(fork_inner(initial_rsp, args))
-}
-
-// TODO: duplicate code with x86_64
-unsafe extern "cdecl" fn child_hook(scratchpad: ForkScratchpad) {
-    let _ = crate::sys::close(scratchpad.cur_filetable_fd);
-    unsafe {
-        crate::child_hook_common(crate::ChildHookCommonArgs {
-            new_thr_fd: FdGuard::new(scratchpad.new_thr_fd),
-            new_proc_fd: if scratchpad.new_proc_fd == usize::MAX {
-                None
-            } else {
-                Some(FdGuard::new(scratchpad.new_proc_fd))
-            },
-            new_filetable_fd: FdGuard::new(scratchpad.new_filetable_fd)
-                .to_upper()
-                .unwrap(),
-        })
-    };
-}
-
-asmfunction!(__relibc_internal_fork_wrapper (usize) -> usize: ["
-    mov ecx, [esp+4]
-
-    push ebp
-    mov ebp, esp
-
-    // Push preserved registers
-    push ebx
-    push edi
-    push esi
-    push ebp
-
-    sub esp, 32
-
-    //TODO stmxcsr [esp+16]
-    fnstcw [esp+24]
-
-    mov edx, esp
-    call {fork_impl}
-
-    jmp 2f
-"] <= [fork_impl = sym fork_impl]);
-
-asmfunction!(__relibc_internal_fork_ret: ["
-    // Arguments already on the stack
-    call {child_hook}
-
-    //TODO ldmxcsr [esp+16]
-    fldcw [esp+24]
-
-    xor eax, eax
-
-    .p2align 4
-2:
-    add esp, 32
-
-    // Pop preserved registers
-    pop ebp
-    pop esi
-    pop edi
-    pop ebx
-
-    pop ebp
-
-    ret
-"] <= [child_hook = sym child_hook]);
-asmfunction!(__relibc_internal_sigentry: ["
-    // Save some registers
-    mov gs:[{tcb_sa_off} + {sa_tmp_esp}], esp
-    mov gs:[{tcb_sa_off} + {sa_tmp_eax}], eax
-    mov gs:[{tcb_sa_off} + {sa_tmp_edx}], edx
-    mov gs:[{tcb_sa_off} + {sa_tmp_ecx}], ecx
-    mov gs:[{tcb_sa_off} + {sa_tmp_ebx}], ebx
-    mov gs:[{tcb_sa_off} + {sa_tmp_edi}], edi
-    mov gs:[{tcb_sa_off} + {sa_tmp_esi}], esi
-1:
-    // Read standard signal word - first for this thread
-    mov edx, gs:[{tcb_sc_off} + {sc_word} + 4]
-    mov eax, gs:[{tcb_sc_off} + {sc_word}]
-    and eax, edx
-    bsf eax, eax
-    jnz 9f
-
-    // Read standard signal word - for the process
-    lea ecx, [{pctl}]
-    mov eax, [ecx + {pctl_pending}]
-    and eax, edx
-    bsf eax, eax
-    jz 3f
-
-    // Read si_pid and si_uid, atomically.
-    movq gs:[{tcb_sa_off} + {sa_tmp_mm0}], mm0
-    movq mm0, [ecx + {pctl_sender_infos} + eax * 8]
-    movq gs:[{tcb_sa_off} + {sa_tmp_id_inf}], mm0
-    movq mm0, gs:[{tcb_sa_off} + {sa_tmp_mm0}]
-
-    // Try clearing the pending bit, otherwise retry if another thread did that first
-    lock btr [ecx + {pctl_pending}], eax
-    jnc 1b
-    jmp 2f
-3:
-    // Read realtime thread and process signal word together
-    mov edx, [ecx + {pctl_pending} + 4]
-    mov eax, gs:[{tcb_sc_off} + {sc_word} + 8]
-    or eax, edx
-    and eax, gs:[{tcb_sc_off} + {sc_word} + 12]
-    bsf eax, eax
-    jz 7f // spurious signal
-
-    // If thread rather than process was specifically targeted, send the signal to it first.
-    bt edx, eax
-    jnc 8f
-
-    // SYS_CALL(fd, payload_base, payload_len, metadata_len, metadata_base)
-    // eax      ebx ecx           edx          esi           edi
-
-    mov ebx, [{proc_fd}]
-    mov ecx, gs:[0]
-    add ecx, {tcb_sa_off} + {sa_tmp_rt_inf}
-    mov [ecx], eax
-    mov gs:[{tcb_sa_off} + {sa_tmp_signo}], eax
-    mov edx, {RTINF_SIZE}
-    mov esi, 1
-    lea edi, [{proc_call}]
-    mov eax, {SYS_CALL}
-    int 0x80
-    test eax, eax
-    jnz 1b
-
-    mov eax, gs:[{tcb_sa_off} + {sa_tmp_signo}]
-    add eax, 32
-    jmp 2f
-8:
-    add eax, 32
-9:
-    // Read si_pid and si_uid, atomically.
-    movq gs:[{tcb_sa_off} + {sa_tmp_mm0}], mm0
-    movq mm0, gs:[{tcb_sc_off} + {sc_sender_infos} + eax * 8]
-    movq gs:[{tcb_sa_off} + {sa_tmp_id_inf}], mm0
-    movq mm0, gs:[{tcb_sa_off} + {sa_tmp_mm0}]
-    mov edx, eax
-    shr edx, 5
-    mov ecx, eax
-    and ecx, 31
-    lock btr gs:[{tcb_sc_off} + {sc_word} + edx * 8], ecx
-
-    add eax, 64
-2:
-    and esp, -{STACK_ALIGN}
-
-    mov edx, eax
-    add edx, edx
-    bt dword ptr [{pctl} + {pctl_actions} + edx * 8 + 4], 28
-    jnc 4f
-
-    mov edx, gs:[{tcb_sa_off} + {sa_altstack_top}]
-    cmp esp, edx
-    ja 3f
-
-    cmp esp, gs:[{tcb_sa_off} + {sa_altstack_bottom}]
-    jnbe 4f
-3:
-    mov esp, edx
-4:
-    // Now that we have a stack, we can finally start populating the signal stack.
-    push dword ptr gs:[{tcb_sa_off} + {sa_tmp_esp}]
-    push dword ptr gs:[{tcb_sc_off} + {sc_saved_eip}]
-    push dword ptr gs:[{tcb_sc_off} + {sc_saved_eflags}]
-
-    push dword ptr gs:[{tcb_sa_off} + {sa_tmp_edx}]
-    push dword ptr gs:[{tcb_sa_off} + {sa_tmp_ecx}]
-    push dword ptr gs:[{tcb_sa_off} + {sa_tmp_eax}]
-    push dword ptr gs:[{tcb_sa_off} + {sa_tmp_ebx}]
-    push dword ptr gs:[{tcb_sa_off} + {sa_tmp_edi}]
-    push dword ptr gs:[{tcb_sa_off} + {sa_tmp_esi}]
-    push ebp
-
-    sub esp, 2 * 4 + 29 * 16
-    fxsave [esp]
-
-    mov [esp - 4], eax
-    sub esp, 48
-
-    mov ecx, esp
-    call {inner}
-
-    fxrstor [esp + 48]
-    add esp, 48 + 29 * 16 + 2 * 4
-
-    pop ebp
-    pop esi
-    pop edi
-    pop ebx
-    pop eax
-    pop ecx
-    pop edx
-
-    popfd
-    pop dword ptr gs:[{tcb_sa_off} + {sa_tmp_eip}]
-
-    .globl __relibc_internal_sigentry_crit_first
-__relibc_internal_sigentry_crit_first:
-    pop esp
-
-    .globl __relibc_internal_sigentry_crit_second
-__relibc_internal_sigentry_crit_second:
-    jmp dword ptr gs:[{tcb_sa_off} + {sa_tmp_eip}]
-7:
-    mov eax, gs:[0]
-    lea esp, [eax + {tcb_sc_off} + {sc_saved_eflags}]
-    popfd
-
-    mov esp, gs:[{tcb_sa_off} + {sa_tmp_esp}]
-
-    mov eax, gs:[{tcb_sc_off} + {sc_saved_eip}]
-    mov gs:[{tcb_sa_off} + {sa_tmp_eip}], eax
-
-    mov eax, gs:[{tcb_sa_off} + {sa_tmp_eax}]
-    mov ebx, gs:[{tcb_sa_off} + {sa_tmp_ebx}]
-    mov ecx, gs:[{tcb_sa_off} + {sa_tmp_ecx}]
-    mov edx, gs:[{tcb_sa_off} + {sa_tmp_edx}]
-    mov edi, gs:[{tcb_sa_off} + {sa_tmp_edi}]
-    mov esi, gs:[{tcb_sa_off} + {sa_tmp_esi}]
-
-    and dword ptr gs:[{tcb_sc_off} + {sc_control}], ~1
-    .globl __relibc_internal_sigentry_crit_third
-__relibc_internal_sigentry_crit_third:
-    jmp dword ptr gs:[{tcb_sa_off} + {sa_tmp_eip}]
-"] <= [
-    inner = sym inner_fastcall,
-    sa_tmp_eip = const offset_of!(SigArea, tmp_eip),
-    sa_tmp_esp = const offset_of!(SigArea, tmp_esp),
-    sa_tmp_eax = const offset_of!(SigArea, tmp_eax),
-    sa_tmp_ebx = const offset_of!(SigArea, tmp_ebx),
-    sa_tmp_ecx = const offset_of!(SigArea, tmp_ecx),
-    sa_tmp_edx = const offset_of!(SigArea, tmp_edx),
-    sa_tmp_edi = const offset_of!(SigArea, tmp_edi),
-    sa_tmp_esi = const offset_of!(SigArea, tmp_esi),
-    sa_tmp_mm0 = const offset_of!(SigArea, tmp_mm0),
-    sa_tmp_rt_inf = const offset_of!(SigArea, tmp_rt_inf),
-    sa_tmp_id_inf = const offset_of!(SigArea, tmp_id_inf),
-    sa_tmp_signo = const offset_of!(SigArea, tmp_signo),
-    sa_altstack_top = const offset_of!(SigArea, altstack_top),
-    sa_altstack_bottom = const offset_of!(SigArea, altstack_bottom),
-    sc_control = const offset_of!(Sigcontrol, control_flags),
-    sc_saved_eflags = const offset_of!(Sigcontrol, saved_archdep_reg),
-    sc_saved_eip = const offset_of!(Sigcontrol, saved_ip),
-    sc_word = const offset_of!(Sigcontrol, word),
-    sc_sender_infos = const offset_of!(Sigcontrol, sender_infos),
-    tcb_sa_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, arch),
-    tcb_sc_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control),
-    pctl_actions = const offset_of!(SigProcControl, actions),
-    pctl_sender_infos = const offset_of!(SigProcControl, sender_infos),
-    pctl_pending = const offset_of!(SigProcControl, pending),
-    pctl = sym PROC_CONTROL_STRUCT,
-    proc_fd = sym PROC_FD,
-    proc_call = sym PROC_CALL,
-    STACK_ALIGN = const 16,
-    SYS_CALL = const syscall::SYS_CALL,
-    RTINF_SIZE = const size_of::<RtSigInfo>(),
-]);
-
-asmfunction!(__relibc_internal_rlct_clone_ret -> usize: ["
-    # Load registers
-    pop eax
-
-    sub esp, 8
-
-    mov DWORD PTR [esp], 0x00001F80
-    # TODO: ldmxcsr [esp]
-    mov WORD PTR [esp], 0x037F
-    fldcw [esp]
-
-    add esp, 8
-
-    # Call entry point
-    call eax
-
-    ret
-"] <= []);
-unsafe extern "C" {
-    fn __relibc_internal_sigentry_crit_first();
-    fn __relibc_internal_sigentry_crit_second();
-    fn __relibc_internal_sigentry_crit_third();
-}
-pub unsafe fn arch_pre(stack: &mut SigStack, area: &mut SigArea) -> PosixStackt {
-    if stack.regs.eip == __relibc_internal_sigentry_crit_first as *const () as usize {
-        let stack_ptr = stack.regs.esp as *const usize;
-        stack.regs.esp = unsafe { stack_ptr.read() };
-        stack.regs.eip = unsafe { stack_ptr.sub(1).read() };
-    } else if stack.regs.eip == __relibc_internal_sigentry_crit_second as *const () as usize
-        || stack.regs.eip == __relibc_internal_sigentry_crit_third as *const () as usize
-    {
-        stack.regs.eip = area.tmp_eip;
-    }
-    PosixStackt {
-        sp: stack.regs.esp as *mut (),
-        size: 0,  // TODO
-        flags: 0, // TODO
-    }
-}
-pub fn arch_ret_to_sig(stack: &mut SigStack, control: &Sigcontrol) {
-    let orig_eip = core::mem::replace(
-        &mut stack.regs.eip,
-        __relibc_internal_sigentry as *const () as usize,
-    );
-    control.saved_ip.set(orig_eip);
-    control.saved_archdep_reg.set(stack.regs.eflags);
-}
-#[unsafe(no_mangle)]
-pub unsafe fn manually_enter_trampoline() {
-    let c = unsafe { &crate::Tcb::current().unwrap().os_specific.control };
-    c.control_flags.store(
-        c.control_flags.load(Ordering::Relaxed) | syscall::flag::INHIBIT_DELIVERY.bits(),
-        Ordering::Release,
-    );
-    c.saved_archdep_reg.set(0); // TODO: Just reset DF on x86?
-
-    unsafe {
-        core::arch::asm!("
-                call 2f
-                jmp 3f
-            2:
-                pop dword ptr gs:[{tcb_sc_off} + {sc_saved_eip}]
-                jmp __relibc_internal_sigentry
-            3:
-            ",
-            tcb_sc_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control),
-            sc_saved_eip = const offset_of!(Sigcontrol, saved_ip),
-        );
-    }
-}
-/// Get current stack pointer, weak granularity guarantees.
-pub fn current_sp() -> usize {
-    let sp: usize;
-    unsafe {
-        core::arch::asm!("mov {}, esp", out(reg) sp);
-    }
-    sp
-}
-
-pub static PROC_FD: SyncUnsafeCell<usize> = SyncUnsafeCell::new(usize::MAX);
-static PROC_CALL: u64 = ProcCall::Sigdeq as u64;

redox-rt/src/arch/riscv64.rs

@@ -1,661 +0,0 @@
-use core::cell::SyncUnsafeCell;
-
-use crate::{
-    Tcb,
-    proc::{FdGuard, FdGuardUpper, ForkArgs, fork_inner},
-    signal::{PosixStackt, RtSigarea, SigStack, get_sigaltstack, inner_c},
-};
-use core::{mem::offset_of, ptr::NonNull, sync::atomic::Ordering};
-use redox_protocols::protocol::{ProcCall, RtSigInfo};
-use syscall::{data::*, error::*};
-
-use super::ForkScratchpad;
-
-// Setup a stack starting from the very end of the address space, and then growing downwards.
-pub const STACK_TOP: usize = 1 << 38;
-pub const STACK_SIZE: usize = 1024 * 1024;
-
-#[derive(Debug, Default)]
-#[repr(C)]
-pub struct SigArea {
-    pub tmp_sp: u64,
-    pub tmp_t1: u64,
-    pub tmp_t2: u64,
-    pub tmp_t3: u64,
-    pub tmp_t4: u64,
-    pub tmp_a0: u64,
-    pub tmp_a1: u64,
-    pub tmp_a2: u64,
-    pub tmp_a3: u64,
-    pub tmp_a4: u64,
-    pub tmp_a7: u64,
-
-    pub pctl: usize, // TODO: remove
-    pub tmp_ip: u64,
-    pub tmp_rt_inf: RtSigInfo,
-    pub tmp_id_inf: u64,
-    pub altstack_top: usize,
-    pub altstack_bottom: usize,
-    pub disable_signals_depth: u64,
-    pub last_sig_was_restart: bool,
-    pub last_sigstack: Option<NonNull<SigStack>>,
-}
-#[repr(C)]
-#[derive(Debug, Default)]
-pub struct ArchIntRegs {
-    pub int_regs: [u64; 31],
-    pub pc: u64,
-    pub fp_regs: [u64; 32],
-    pub fcsr: u32,
-    _pad: u32,
-}
-
-/// Deactive TLS, used before exec() on Redox to not trick target executable into thinking TLS
-/// is already initialized as if it was a thread.
-pub unsafe fn deactivate_tcb(open_via_dup: &FdGuardUpper) -> Result<()> {
-    let mut env = syscall::EnvRegisters::default();
-
-    let file = open_via_dup.dup_into_upper(b"regs/env")?;
-
-    env.tp = 0;
-
-    file.write(&mut env)?;
-    crate::TLS_ACTIVATED.store(false, core::sync::atomic::Ordering::Relaxed);
-    Ok(())
-}
-
-unsafe extern "C" fn fork_impl(args: &ForkArgs, initial_rsp: *mut usize) -> usize {
-    Error::mux(fork_inner(initial_rsp, args))
-}
-
-unsafe extern "C" fn child_hook(scratchpad: &ForkScratchpad) {
-    let _ = crate::sys::close(scratchpad.cur_filetable_fd);
-    unsafe {
-        crate::child_hook_common(crate::ChildHookCommonArgs {
-            new_thr_fd: FdGuard::new(scratchpad.new_thr_fd),
-            new_proc_fd: if scratchpad.new_proc_fd == usize::MAX {
-                None
-            } else {
-                Some(FdGuard::new(scratchpad.new_proc_fd))
-            },
-            new_filetable_fd: FdGuard::new(scratchpad.new_filetable_fd)
-                .to_upper()
-                .unwrap(),
-        })
-    };
-}
-
-asmfunction!(__relibc_internal_fork_wrapper (usize) -> usize: ["
-    .attribute arch, \"rv64gc\"  # rust bug 80608
-    addi sp, sp, -200
-    sd   s0, 0(sp)
-    sd   s1, 8(sp)
-    sd   s2, 16(sp)
-    sd   s3, 24(sp)
-    sd   s4, 32(sp)
-    sd   s5, 40(sp)
-    sd   s6, 48(sp)
-    sd   s7, 56(sp)
-    sd   s8, 64(sp)
-    sd   s9, 72(sp)
-    sd   s10, 80(sp)
-    sd   s11, 88(sp)
-    sd   ra, 96(sp)
-
-    fsd  fs0, 104(sp)
-    fsd  fs1, 112(sp)
-    fsd  fs2, 120(sp)
-    fsd  fs3, 128(sp)
-    fsd  fs4, 136(sp)
-    fsd  fs5, 144(sp)
-    fsd  fs6, 152(sp)
-    fsd  fs7, 160(sp)
-    fsd  fs8, 168(sp)
-    fsd  fs9, 176(sp)
-    fsd  fs10, 184(sp)
-    fsd  fs11, 192(sp)
-
-    // a0 is forwarded from this function
-    mv   a1, sp
-    jal  {fork_impl}
-
-    ld   s0, 0(sp)
-    ld   s1, 8(sp)
-    ld   s2, 16(sp)
-    ld   s3, 24(sp)
-    ld   s4, 32(sp)
-    ld   s5, 40(sp)
-    ld   s6, 48(sp)
-    ld   s7, 56(sp)
-    ld   s8, 64(sp)
-    ld   s9, 72(sp)
-    ld   s10, 80(sp)
-    ld   s11, 88(sp)
-    ld   ra, 96(sp)
-
-    fld  fs0, 104(sp)
-    fld  fs1, 112(sp)
-    fld  fs2, 120(sp)
-    fld  fs3, 128(sp)
-    fld  fs4, 136(sp)
-    fld  fs5, 144(sp)
-    fld  fs6, 152(sp)
-    fld  fs7, 160(sp)
-    fld  fs8, 168(sp)
-    fld  fs9, 176(sp)
-    fld  fs10, 184(sp)
-    fld  fs11, 192(sp)
-
-    addi sp, sp, 200
-    ret
-"] <= [fork_impl = sym fork_impl]);
-
-asmfunction!(__relibc_internal_fork_ret: ["
-    .attribute arch, \"rv64gc\"  # rust bug 80608
-
-    # scratchpad is in a1, move to a0 for child_hook
-    mv a0, a1
-
-    jal  {child_hook}
-
-    mv   a0, zero
-
-    ld   s0, 0(sp)
-    ld   s1, 8(sp)
-    ld   s2, 16(sp)
-    ld   s3, 24(sp)
-    ld   s4, 32(sp)
-    ld   s5, 40(sp)
-    ld   s6, 48(sp)
-    ld   s7, 56(sp)
-    ld   s8, 64(sp)
-    ld   s9, 72(sp)
-    ld   s10, 80(sp)
-    ld   s11, 88(sp)
-    ld   ra, 96(sp)
-
-    fld  fs0, 104(sp)
-    fld  fs1, 112(sp)
-    fld  fs2, 120(sp)
-    fld  fs3, 128(sp)
-    fld  fs4, 136(sp)
-    fld  fs5, 144(sp)
-    fld  fs6, 152(sp)
-    fld  fs7, 160(sp)
-    fld  fs8, 168(sp)
-    fld  fs9, 176(sp)
-    fld  fs10, 184(sp)
-    fld  fs11, 192(sp)
-
-    addi sp, sp, 200
-    ret
-"] <= [child_hook = sym child_hook]);
-
-asmfunction!(__relibc_internal_sigentry: ["
-    .attribute arch, \"rv64gc\"  # rust bug 80608
-    // Save some registers
-    ld   t0, -8(tp) // Tcb
-    sd   sp, ({tcb_sa_off} + {sa_tmp_sp})(t0)
-    sd   t1, ({tcb_sa_off} + {sa_tmp_t1})(t0)
-    sd   t2, ({tcb_sa_off} + {sa_tmp_t2})(t0)
-    sd   t3, ({tcb_sa_off} + {sa_tmp_t3})(t0)
-    sd   t4, ({tcb_sa_off} + {sa_tmp_t4})(t0)
-    ld   t4, ({tcb_sa_off} + {sa_off_pctl})(t0)
-
-    // First, select signal, always pick first available bit
-99:
-    // Read first signal word
-    ld   t1, ({tcb_sc_off} + {sc_word})(t0)
-    srli t2, t1, 32 // bitset to low word
-    and  t1, t1, t2  // masked bitset in low word
-    beqz t1, 3f
-
-    // Found in first thread signal word
-    mv   t3, x0
-2:  andi t2, t1, 1
-    bnez t2, 10f
-    addi t3, t3, 1
-    srli t1, t1, 1
-    j 2b
-
-    // If no unblocked thread signal was found, check for process.
-    // This is competitive; we need to atomically check if *we* cleared the process-wide pending
-    // bit, otherwise restart.
-3:  lw   t1, {pctl_off_pending}(t4)
-    and  t1, t1, t2
-    beqz t1, 3f
-    // Found in first process signal word
-    li   t3, -1
-2:  andi t2, t1, 1
-    addi t3, t3, 1
-    srli t1, t1, 1
-    beqz t2, 2b
-    slli t1, t3, 3 // * 8 == size_of SenderInfo
-    add  t1, t1, t4
-    ld   t1, {pctl_off_sender_infos}(t1)
-    sd   t1, ({tcb_sa_off} + {sa_tmp_id_inf})(t0)
-    li   t1, 1
-    sll  t1, t1, t3
-    not  t1, t1
-    addi t2, t4, {pctl_off_pending}
-    amoand.w.aq t2, t1, (t2)
-    and  t1, t1, t2
-    bne  t1, t2, 9f
-
-3:
-    // Read second signal word - both process and thread simultaneously.
-    // This must be done since POSIX requires low realtime signals to be picked first.
-    ld   t1, ({tcb_sc_off} + {sc_word} + 8)(t0)
-    lw   t2, ({pctl_off_pending} + 4)(t4)
-    or   t4, t1, t2
-    srli t2, t1, 32
-    and  t4, t2, t4
-    beqz t4, 7f
-    li   t3, -1
-2:  andi t2, t4, 1
-    addi t3, t3, 1
-    srli t4, t4, 1
-    beqz t2, 2b
-    li   t2, 1
-    sll  t2, t2, t3
-    and  t1, t1, t2
-    addi t3, t3, 32
-    bnez t1, 10f // thread signal
-
-    // otherwise, try (competitively) dequeueing realtime signal
-
-    // SYS_CALL(fd, payload_base, payload_len, metadata_len, metadata_base)
-    // a7       a0  a1            a2           a3            a4
-
-    // TODO: This SYS_CALL invocation has not yet been tested due to toolchain issues.
-
-    sd   a0, ({tcb_sa_off} + {sa_tmp_a0})(t0)
-    sd   a1, ({tcb_sa_off} + {sa_tmp_a1})(t0)
-    sd   a2, ({tcb_sa_off} + {sa_tmp_a2})(t0)
-    sd   a3, ({tcb_sa_off} + {sa_tmp_a3})(t0)
-    sd   a4, ({tcb_sa_off} + {sa_tmp_a4})(t0)
-    sd   a7, ({tcb_sa_off} + {sa_tmp_a7})(t0)
-    li   a7, {SYS_CALL}
-    addi a2, t3, -32
-    add  a1, t0, {tcb_sa_off} + {sa_tmp_rt_inf} // out pointer of dequeued realtime sig
-    sd a2, (a1)
-    li a2, {RTINF_SIZE}
-    li a3, 1
-1337:
-    auipc a4, %pcrel_hi({proc_fd})
-    addi a4, a4, %pcrel_lo(1337b)
-    ecall
-    ld   a3, ({tcb_sa_off} + {sa_tmp_a3})(t0)
-    ld   a4, ({tcb_sa_off} + {sa_tmp_a4})(t0)
-    bnez a0, 99b // assumes error can only be EAGAIN
-    j   9f
-
-10: // thread signal. t3 holds signal number
-    srli t1, t3, 5
-    bnez t1, 2f // FIXME senderinfo?
-    sll  t2, t3, 3 // * 8 == size_of SenderInfo
-    add  t2, t2, t0
-    ld   t2, ({tcb_sc_off} + {sc_sender_infos})(t2)
-    sd   t2, ({tcb_sa_off} + {sa_tmp_id_inf})(t0)
-2:  andi t4, t3, 31
-    li   t2, 1
-    sll  t2, t2, t4
-    not  t2, t2
-    sll  t1, t1, 3
-    add  t1, t1, t0
-    addi t1, t1, {tcb_sc_off} + {sc_word}
-    amoand.w.aq x0, t2, (t1)
-    addi t3, t3, 64 // indicate signal was targeted at thread
-
-9: // process signal t3 holds signal number
-
-    // By now we have selected a signal, stored in eax (6-bit). We now need to choose whether or
-    // not to switch to the alternate signal stack. If SA_ONSTACK is clear for this signal, then
-    // skip the sigaltstack logic.
-    ld   t4, ({tcb_sa_off} + {sa_off_pctl})(t0)
-    andi t1, t3, 63
-    slli t1, t1, 4 // * 16 == size_of RawAction
-    add  t1, t1, t4
-    ld   t1, {pctl_off_actions}(t1)
-    slli t1, t1, 63-58 // SA_ONSTACK in sign bit
-    bgez t1, 3f
-
-    // If current RSP is above altstack region, switch to altstack
-    ld  t1, ({tcb_sa_off} + {sa_altstack_top})(t0)
-    bgtu sp, t1, 2f
-    ld  t2, ({tcb_sa_off} + {sa_altstack_bottom})(t0)
-    bgtu sp, t3, 3f
-2:  mv  sp, t1
-3:
-    // form mcontext on stack
-    addi sp, sp, -33 * 8
-    fsd  f0, (0 * 8)(sp)
-    fsd  f1, (1 * 8)(sp)
-    fsd  f2, (2 * 8)(sp)
-    fsd  f3, (3 * 8)(sp)
-    fsd  f4, (4 * 8)(sp)
-    fsd  f5, (5 * 8)(sp)
-    fsd  f6, (6 * 8)(sp)
-    fsd  f7, (7 * 8)(sp)
-    fsd  f8, (8 * 8)(sp)
-    fsd  f9, (9 * 8)(sp)
-    fsd  f10, (10 * 8)(sp)
-    fsd  f11, (11 * 8)(sp)
-    fsd  f12, (12 * 8)(sp)
-    fsd  f13, (13 * 8)(sp)
-    fsd  f14, (14 * 8)(sp)
-    fsd  f15, (15 * 8)(sp)
-    fsd  f16, (16 * 8)(sp)
-    fsd  f17, (17 * 8)(sp)
-    fsd  f18, (18 * 8)(sp)
-    fsd  f19, (19 * 8)(sp)
-    fsd  f20, (20 * 8)(sp)
-    fsd  f21, (21 * 8)(sp)
-    fsd  f22, (22 * 8)(sp)
-    fsd  f23, (23 * 8)(sp)
-    fsd  f24, (24 * 8)(sp)
-    fsd  f25, (25 * 8)(sp)
-    fsd  f26, (26 * 8)(sp)
-    fsd  f27, (27 * 8)(sp)
-    fsd  f28, (28 * 8)(sp)
-    fsd  f29, (29 * 8)(sp)
-    fsd  f30, (30 * 8)(sp)
-    fsd  f31, (31 * 8)(sp)
-    csrr t1, fcsr
-    sw   t1, (32 * 8)(sp)
-
-    addi sp, sp, -32 * 8
-    sd   x1, 0(sp)
-    ld   t1, ({tcb_sa_off} + {sa_tmp_sp})(t0)
-    sd   t1, (1 * 8)(sp)  // x2 is sp
-    sd   x3, (2 * 8)(sp)
-    sd   x4, (3 * 8)(sp)
-    ld   t1, ({tcb_sc_off} + {sc_saved_t0})(t0)
-    sd   t1, (4 * 8)(sp) // x5 is t0
-    ld   t1, ({tcb_sa_off} + {sa_tmp_t1})(t0)
-    sd   t1, (5 * 8)(sp) // x6 is t1
-    ld   t1, ({tcb_sa_off} + {sa_tmp_t2})(t0)
-    sd   t1, (6 * 8)(sp) // x7 is t2
-    sd   x8, (7 * 8)(sp)
-    sd   x9, (8 * 8)(sp)
-    sd   x10, (9 * 8)(sp)
-    sd   x11, (10 * 8)(sp)
-    sd   x12, (11 * 8)(sp)
-    sd   x13, (12 * 8)(sp)
-    sd   x14, (13 * 8)(sp)
-    sd   x15, (14 * 8)(sp)
-    sd   x16, (15 * 8)(sp)
-    sd   x17, (16 * 8)(sp)
-    sd   x18, (17 * 8)(sp)
-    sd   x19, (18 * 8)(sp)
-    sd   x20, (19 * 8)(sp)
-    sd   x21, (20 * 8)(sp)
-    sd   x22, (21 * 8)(sp)
-    sd   x23, (22 * 8)(sp)
-    sd   x24, (23 * 8)(sp)
-    sd   x25, (24 * 8)(sp)
-    sd   x26, (25 * 8)(sp)
-    sd   x27, (26 * 8)(sp)
-    ld   t1, ({tcb_sa_off} + {sa_tmp_t3})(t0)
-    sd   t1, (27 * 8)(sp) // t3 is x28
-    ld   t1, ({tcb_sa_off} + {sa_tmp_t4})(t0)
-    sd   t1, (28 * 8)(sp) // t4 is x29
-    sd   x30, (29 * 8)(sp)
-    sd   x31, (30 * 8)(sp)
-    ld   t1, ({tcb_sc_off} + {sc_saved_ip})(t0)
-    sd   t1, (31 * 8)(sp)
-
-    // form ucontext
-    addi sp, sp, -64
-    sw   t3, 60(sp)
-
-    mv   t0, sp
-    jal  {inner}
-
-    addi sp, sp, 64
-
-    addi t0, sp, 32 * 8
-    fld  f0, (0 * 8)(t0)
-    fld  f1, (1 * 8)(t0)
-    fld  f2, (2 * 8)(t0)
-    fld  f3, (3 * 8)(t0)
-    fld  f4, (4 * 8)(t0)
-    fld  f5, (5 * 8)(t0)
-    fld  f6, (6 * 8)(t0)
-    fld  f7, (7 * 8)(t0)
-    fld  f8, (8 * 8)(t0)
-    fld  f9, (9 * 8)(t0)
-    fld  f10, (10 * 8)(t0)
-    fld  f11, (11 * 8)(t0)
-    fld  f12, (12 * 8)(t0)
-    fld  f13, (13 * 8)(t0)
-    fld  f14, (14 * 8)(t0)
-    fld  f15, (15 * 8)(t0)
-    fld  f16, (16 * 8)(t0)
-    fld  f17, (17 * 8)(t0)
-    fld  f18, (18 * 8)(t0)
-    fld  f19, (19 * 8)(t0)
-    fld  f20, (20 * 8)(t0)
-    fld  f21, (21 * 8)(t0)
-    fld  f22, (22 * 8)(t0)
-    fld  f23, (23 * 8)(t0)
-    fld  f24, (24 * 8)(t0)
-    fld  f25, (25 * 8)(t0)
-    fld  f26, (26 * 8)(t0)
-    fld  f27, (27 * 8)(t0)
-    fld  f28, (28 * 8)(t0)
-    fld  f29, (29 * 8)(t0)
-    fld  f30, (30 * 8)(t0)
-    fld  f31, (31 * 8)(t0)
-    lw   t1, (32 * 8)(t0)
-    csrw fcsr, t1
-
-    ld   x1, 0(sp)
-    // skip sp
-    // skip gp
-    ld   x4, (3 * 8)(sp)
-    ld   x5, (4 * 8)(sp)
-    ld   x6, (5 * 8)(sp)
-    ld   x7, (6 * 8)(sp)
-    ld   x8, (7 * 8)(sp)
-    ld   x9, (8 * 8)(sp)
-    ld   x10, (9 * 8)(sp)
-    ld   x11, (10 * 8)(sp)
-    ld   x12, (11 * 8)(sp)
-    ld   x13, (12 * 8)(sp)
-    ld   x14, (13 * 8)(sp)
-    ld   x15, (14 * 8)(sp)
-    ld   x16, (15 * 8)(sp)
-    ld   x17, (16 * 8)(sp)
-    ld   x18, (17 * 8)(sp)
-    ld   x19, (18 * 8)(sp)
-    ld   x20, (19 * 8)(sp)
-    ld   x21, (20 * 8)(sp)
-    ld   x22, (21 * 8)(sp)
-    ld   x23, (22 * 8)(sp)
-    ld   x24, (23 * 8)(sp)
-    ld   x25, (24 * 8)(sp)
-    ld   x26, (25 * 8)(sp)
-    ld   x27, (26 * 8)(sp)
-    ld   x28, (27 * 8)(sp)
-    ld   x29, (28 * 8)(sp)
-    ld   x30, (29 * 8)(sp)
-    ld   x31, (30 * 8)(sp)
-    ld   gp, (31 * 8)(sp) // new IP; this clobbers register x3/gp which is ABI reserved
-    .global __relibc_internal_sigentry_crit_first
-__relibc_internal_sigentry_crit_first:
-    ld   sp, (1 * 8)(sp)
-    .global __relibc_internal_sigentry_crit_second
-__relibc_internal_sigentry_crit_second:
-    jr   gp
-7:
-    // A spurious signal occurred. Signals are still disabled here, but will need to be re-enabled.
-
-    // restore stack
-    ld   sp, ({tcb_sa_off} + {sa_tmp_sp})(t0)
-
-    // move saved IP away from control, allowing arch_pre to save us if interrupted.
-    ld t1, ({tcb_sc_off} + {sc_saved_ip})(t0)
-    sd t1, ({tcb_sa_off} + {sa_tmp_ip})(t0)
-
-    // restore regs
-    ld   t2, ({tcb_sa_off} + {sa_tmp_t2})(t0)
-    ld   t3, ({tcb_sa_off} + {sa_tmp_t3})(t0)
-    ld   t4, ({tcb_sa_off} + {sa_tmp_t4})(t0)
-
-    // move saved t0 away from control as well
-    mv   t1, t0
-    ld   t0, ({tcb_sc_off} + {sc_saved_t0})(t0)
-
-    // Re-enable signals. This code can be interrupted after this signal, so we need to define
-    // 'crit_third'.
-    ld   gp, ({tcb_sc_off} + {sc_control})(t1)
-    andi gp, gp, ~1
-    sd   gp, ({tcb_sc_off} + {sc_control})(t1)
-
-    .globl __relibc_internal_sigentry_crit_third
-__relibc_internal_sigentry_crit_third:
-    ld   gp, ({tcb_sa_off} + {sa_tmp_ip})(t1)
-    .globl __relibc_internal_sigentry_crit_fourth
-__relibc_internal_sigentry_crit_fourth:
-    ld   t1, ({tcb_sa_off} + {sa_tmp_t1})(t1)
-    .globl __relibc_internal_sigentry_crit_fifth
-__relibc_internal_sigentry_crit_fifth:
-    jr   gp
- "] <= [
-    tcb_sc_off = const (offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control)),
-    sc_word = const offset_of!(Sigcontrol, word),
-    sc_saved_t0 = const offset_of!(Sigcontrol, saved_archdep_reg),
-    sc_saved_ip = const offset_of!(Sigcontrol, saved_ip),
-    sc_sender_infos = const offset_of!(Sigcontrol, sender_infos),
-    sc_control = const offset_of!(Sigcontrol, control_flags),
-
-    tcb_sa_off = const (offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, arch)),
-    sa_off_pctl = const offset_of!(SigArea, pctl),
-    sa_tmp_sp = const offset_of!(SigArea, tmp_sp),
-    sa_tmp_t1 = const offset_of!(SigArea, tmp_t1),
-    sa_tmp_t2 = const offset_of!(SigArea, tmp_t2),
-    sa_tmp_t3 = const offset_of!(SigArea, tmp_t3),
-    sa_tmp_t4 = const offset_of!(SigArea, tmp_t4),
-    sa_tmp_a0 = const offset_of!(SigArea, tmp_a0),
-    sa_tmp_a1 = const offset_of!(SigArea, tmp_a1),
-    sa_tmp_a2 = const offset_of!(SigArea, tmp_a2),
-    sa_tmp_a3 = const offset_of!(SigArea, tmp_a3),
-    sa_tmp_a4 = const offset_of!(SigArea, tmp_a4),
-    sa_tmp_a7 = const offset_of!(SigArea, tmp_a7),
-    sa_tmp_ip = const offset_of!(SigArea, tmp_ip),
-    sa_tmp_id_inf = const offset_of!(SigArea, tmp_id_inf),
-    sa_tmp_rt_inf = const offset_of!(SigArea, tmp_rt_inf),
-    sa_altstack_top = const offset_of!(SigArea, altstack_top),
-    sa_altstack_bottom = const offset_of!(SigArea, altstack_bottom),
-
-    pctl_off_actions = const offset_of!(SigProcControl, actions),
-    inner = sym inner_c,
-    pctl_off_pending = const offset_of!(SigProcControl, pending),
-    pctl_off_sender_infos = const offset_of!(SigProcControl, sender_infos),
-    SYS_CALL = const syscall::SYS_CALL,
-    RTINF_SIZE = const size_of::<RtSigInfo>(),
-    proc_fd = sym PROC_FD,
-]);
-
-asmfunction!(__relibc_internal_rlct_clone_ret: ["
-    ld t0, 0(sp)
-    ld a0, 8(sp)
-    ld a1, 16(sp)
-    ld a2, 24(sp)
-    ld a3, 32(sp)
-    ld a4, 40(sp)
-    ld a5, 48(sp)
-    addi sp, sp, 56
-
-    jalr t0
-    ret
-"] <= []);
-
-pub fn current_sp() -> usize {
-    let sp: usize;
-    unsafe {
-        core::arch::asm!(
-        "mv {}, sp",
-        out(reg) sp,
-        options(nomem));
-    }
-    sp
-}
-
-pub unsafe fn manually_enter_trampoline() {
-    let ctl = unsafe { &Tcb::current().unwrap().os_specific.control };
-
-    ctl.control_flags.store(
-        ctl.control_flags.load(Ordering::Relaxed) | syscall::flag::INHIBIT_DELIVERY.bits(),
-        Ordering::Release,
-    );
-    ctl.saved_archdep_reg.set(0);
-    let ip_location = &ctl.saved_ip as *const _ as usize;
-
-    unsafe {
-        core::arch::asm!("
-                jal 2f
-                j 3f
-            2:
-                sd ra, 0(t0)
-                la t0, __relibc_internal_sigentry
-                jalr x0, t0
-            3:
-            ",
-            inout("t0") ip_location => _, out("ra") _);
-    }
-}
-
-unsafe extern "C" {
-    fn __relibc_internal_sigentry_crit_first();
-    fn __relibc_internal_sigentry_crit_second();
-    fn __relibc_internal_sigentry_crit_third();
-    fn __relibc_internal_sigentry_crit_fourth();
-    fn __relibc_internal_sigentry_crit_fifth();
-}
-pub unsafe fn arch_pre(stack: &mut SigStack, area: &mut SigArea) -> PosixStackt {
-    // It is impossible to update SP and PC atomically. Instead, we abuse the fact that
-    // signals are disabled in the prologue of the signal trampoline, which allows us to emulate
-    // atomicity inside the critical section, consisting of one instruction at 'crit_first', and
-    // one at 'crit_second', see asm.
-
-    if stack.regs.pc == __relibc_internal_sigentry_crit_first as *const () as u64 {
-        // Reexecute 'ld sp, (1 * 8)(sp)'
-        let stack_ptr = stack.regs.int_regs[1] as *const u64; // x2
-        stack.regs.int_regs[1] = unsafe { stack_ptr.add(1).read() };
-        // and 'jr gp' steps.
-        stack.regs.pc = stack.regs.int_regs[2];
-    } else if stack.regs.pc == __relibc_internal_sigentry_crit_second as *const () as u64
-        || stack.regs.pc == __relibc_internal_sigentry_crit_fifth as *const () as u64
-    {
-        // just reexecute the jump
-        stack.regs.pc = stack.regs.int_regs[2];
-    } else if stack.regs.pc == __relibc_internal_sigentry_crit_third as *const () as u64 {
-        // ld   gp, ({tcb_sa_off} + {sa_tmp_ip})(t1)
-        stack.regs.int_regs[2] = area.tmp_ip;
-        // ld   t1, ({tcb_sa_off} + {sa_tmp_t1})(t1)
-        stack.regs.int_regs[5] = area.tmp_t1;
-        // j    gp
-        stack.regs.pc = stack.regs.int_regs[2];
-    } else if stack.regs.pc == __relibc_internal_sigentry_crit_fourth as *const () as u64 {
-        // ld   t1, ({tcb_sa_off} + {sa_tmp_t1})(t1)
-        stack.regs.int_regs[5] = area.tmp_t1;
-        // jr   gp
-        stack.regs.pc = stack.regs.int_regs[2];
-    }
-
-    get_sigaltstack(area, stack.regs.int_regs[1] as usize).into()
-}
-pub fn arch_ret_to_sig(stack: &mut SigStack, control: &Sigcontrol) {
-    let orig_pc = core::mem::replace(
-        &mut stack.regs.pc,
-        __relibc_internal_sigentry as *const () as u64,
-    );
-    control.saved_ip.set(orig_pc as usize);
-    control
-        .saved_archdep_reg
-        .set(stack.regs.int_regs[4] as usize); // t0
-}
-pub(crate) static PROC_FD: SyncUnsafeCell<usize> = SyncUnsafeCell::new(usize::MAX);
-static PROC_CALL: [usize; 1] = [ProcCall::Sigdeq as usize];

redox-rt/src/arch/x86_64.rs

@@ -1,535 +0,0 @@
-use core::{
-    cell::SyncUnsafeCell,
-    mem::offset_of,
-    ptr::NonNull,
-    sync::atomic::{AtomicU8, Ordering},
-};
-
-use syscall::{
-    data::{SigProcControl, Sigcontrol},
-    error::*,
-};
-
-use crate::{
-    Tcb,
-    proc::{FdGuard, FdGuardUpper, ForkArgs, fork_inner},
-    signal::{PROC_CONTROL_STRUCT, PosixStackt, RtSigarea, SigStack, get_sigaltstack, inner_c},
-};
-use redox_protocols::protocol::{ProcCall, RtSigInfo};
-
-use super::ForkScratchpad;
-
-// Setup a stack starting from the very end of the address space, and then growing downwards.
-pub const STACK_TOP: usize = 1 << 47;
-pub const STACK_SIZE: usize = 8 * 1024 * 1024;
-
-#[derive(Debug, Default)]
-#[repr(C)]
-pub struct SigArea {
-    pub tmp_rip: usize,
-    pub tmp_rsp: usize,
-    pub tmp_rax: usize,
-    pub tmp_rdx: usize,
-    pub tmp_rdi: usize,
-    pub tmp_rsi: usize,
-    pub tmp_r8: usize,
-    pub tmp_r10: usize,
-    pub tmp_r12: usize,
-    pub tmp_rt_inf: RtSigInfo,
-    pub tmp_id_inf: u64,
-
-    pub altstack_top: usize,
-    pub altstack_bottom: usize,
-    pub disable_signals_depth: u64,
-    pub last_sig_was_restart: bool,
-    pub last_sigstack: Option<NonNull<SigStack>>,
-}
-
-#[repr(C, align(16))]
-#[derive(Debug, Default)]
-pub struct ArchIntRegs {
-    pub ymm_upper: [u128; 16],
-    pub fxsave: [u128; 29],
-    pub r15: usize, // fxsave "available" +0
-    pub r14: usize, // available +8
-    pub r13: usize, // available +16
-    pub r12: usize, // available +24
-    pub rbp: usize, // available +32
-    pub rbx: usize, // available +40
-    pub r11: usize, // outside fxsave, and so on
-    pub r10: usize,
-    pub r9: usize,
-    pub r8: usize,
-    pub rax: usize,
-    pub rcx: usize,
-    pub rdx: usize,
-    pub rsi: usize,
-    pub rdi: usize,
-    pub rflags: usize,
-    pub rip: usize,
-    pub rsp: usize,
-}
-
-/// Deactive TLS, used before exec() on Redox to not trick target executable into thinking TLS
-/// is already initialized as if it was a thread.
-pub unsafe fn deactivate_tcb(open_via_dup: &FdGuardUpper) -> Result<()> {
-    let mut env = syscall::EnvRegisters::default();
-
-    let file = open_via_dup.dup_into_upper(b"regs/env")?;
-
-    env.fsbase = 0;
-    env.gsbase = 0;
-
-    file.write(&env)?;
-    crate::TLS_ACTIVATED.store(false, core::sync::atomic::Ordering::Relaxed);
-    Ok(())
-}
-
-unsafe extern "sysv64" fn fork_impl(args: &ForkArgs, initial_rsp: *mut usize) -> usize {
-    Error::mux(fork_inner(initial_rsp, args))
-}
-
-#[allow(unsafe_op_in_unsafe_fn)]
-unsafe extern "sysv64" fn child_hook(scratchpad: &ForkScratchpad) {
-    let _ = crate::sys::close(scratchpad.cur_filetable_fd);
-    crate::child_hook_common(crate::ChildHookCommonArgs {
-        new_thr_fd: FdGuard::new(scratchpad.new_thr_fd),
-        new_proc_fd: if scratchpad.new_proc_fd == usize::MAX {
-            None
-        } else {
-            Some(FdGuard::new(scratchpad.new_proc_fd))
-        },
-        new_filetable_fd: FdGuard::new(scratchpad.new_filetable_fd)
-            .to_upper()
-            .unwrap(),
-    });
-}
-
-asmfunction!(__relibc_internal_fork_wrapper (usize) -> usize: ["
-    push rbp
-    mov rbp, rsp
-
-    push rbx
-    push rbp
-    push r12
-    push r13
-    push r14
-    push r15
-
-    sub rsp, 16
-
-    stmxcsr [rsp+16]
-    fnstcw [rsp+8]
-
-    // rdi: &ForkArgs
-    // rsi: initial_rsp
-    mov rsi, rsp
-    call {fork_impl}
-
-    add rsp, 64
-
-    pop rbp
-    ret
-
-"] <= [fork_impl = sym fork_impl]);
-asmfunction!(__relibc_internal_fork_ret: ["
-    # scratchpad is in rsi, move to rdi for child_hook
-    mov rdi, rsi
-
-    call {child_hook}
-
-    ldmxcsr [rsp + 16]
-    mov rcx, [rsp + 8]
-
-    xor rax, rax
-
-    add rsp, 16
-    pop r15
-    pop r14
-    pop r13
-    pop r12
-    pop rbp
-    pop rbx
-
-    pop rbp
-    ret
-"] <= [child_hook = sym child_hook]);
-asmfunction!(__relibc_internal_rlct_clone_ret: ["
-    # Load registers
-    pop rax
-    pop rdi
-    pop rsi
-    pop rdx
-    pop rcx
-    pop r8
-    pop r9
-
-    mov DWORD PTR [rsp - 8], 0x00001F80
-    ldmxcsr [rsp - 8]
-    mov WORD PTR [rsp - 8], 0x037F
-    fldcw [rsp - 8]
-
-    # Call entry point
-    call rax
-
-    ret
-"] <= []);
-
-asmfunction!(__relibc_internal_sigentry: ["
-    // Save some registers
-    mov fs:[{tcb_sa_off} + {sa_tmp_rsp}], rsp
-    mov fs:[{tcb_sa_off} + {sa_tmp_rax}], rax
-    mov fs:[{tcb_sa_off} + {sa_tmp_rdx}], rdx
-    mov fs:[{tcb_sa_off} + {sa_tmp_rdi}], rdi
-    mov fs:[{tcb_sa_off} + {sa_tmp_rsi}], rsi
-    mov fs:[{tcb_sa_off} + {sa_tmp_r8}], r8
-    mov fs:[{tcb_sa_off} + {sa_tmp_r10}], r10
-    mov fs:[{tcb_sa_off} + {sa_tmp_r12}], r12
-
-    // First, select signal, always pick first available bit
-1:
-    // Read standard signal word - first targeting this thread
-    mov rax, fs:[{tcb_sc_off} + {sc_word}]
-    mov rdx, rax
-    shr rdx, 32
-    and eax, edx
-    bsf eax, eax
-    jnz 2f
-
-    // If no unblocked thread signal was found, check for process.
-    // This is competitive; we need to atomically check if *we* cleared the process-wide pending
-    // bit, otherwise restart.
-    mov eax, [rip + {pctl} + {pctl_off_pending}]
-    and eax, edx
-    bsf eax, eax
-    jz 8f
-    lea rdi, [rip + {pctl} + {pctl_off_sender_infos}]
-    mov rdi, [rdi + rax * 8]
-    lock btr [rip + {pctl} + {pctl_off_pending}], eax
-    mov fs:[{tcb_sa_off} + {sa_tmp_id_inf}], rdi
-    jc 9f
-8:
-    // Read second signal word - both process and thread simultaneously.
-    // This must be done since POSIX requires low realtime signals to be picked first.
-    mov edx, fs:[{tcb_sc_off} + {sc_word} + 8]
-    mov eax, [rip + {pctl} + {pctl_off_pending} + 4]
-    or eax, edx
-    and eax, fs:[{tcb_sc_off} + {sc_word} + 12]
-    bsf eax, eax
-    jz 7f
-
-    bt edx, eax // check if signal was sent to thread specifically
-    jnc 81f
-    // if so, continue as usual
-    add eax, 32
-    jmp 2f
-81:
-    // otherwise, try (competitively) dequeueing realtime signal
-
-    // SYS_CALL(fd, payload_base, payload_len, metadata_len | (flags << 8), metadata_base)
-    // rax      rdi rsi           rdx          r10                          r8
-
-    mov r12d, eax
-    mov rsi, fs:[0]
-    mov rdi, [rip+{proc_fd}]
-    add rsi, {tcb_sa_off} + {sa_tmp_rt_inf} // out pointer of dequeued realtime sig
-    mov rdx, {RTINF_SIZE}
-    mov [rsi], eax
-    lea r8, [rip + {proc_call_sigdeq}]
-    mov r10, 1
-    mov eax, {SYS_CALL}
-    syscall
-    test eax, eax
-    jnz 1b // assumes error can only be EAGAIN
-    lea eax, [r12d + 32]
-    jmp 9f
-2:
-    mov edx, eax
-    shr edx, 5
-    mov rdi, fs:[{tcb_sc_off} + {sc_sender_infos} + eax * 8]
-    lock btr fs:[{tcb_sc_off} + {sc_word} + edx * 4], eax
-    mov fs:[{tcb_sa_off} + {sa_tmp_id_inf}], rdi
-    add eax, 64 // indicate signal was targeted at thread
-9:
-    sub rsp, {REDZONE_SIZE}
-    and rsp, -{STACK_ALIGN}
-
-    // By now we have selected a signal, stored in eax (6-bit). We now need to choose whether or
-    // not to switch to the alternate signal stack. If SA_ONSTACK is clear for this signal, then
-    // skip the sigaltstack logic.
-    lea rdx, [rip + {pctl} + {pctl_off_actions}]
-
-    mov ecx, eax
-    and ecx, 63
-
-    // LEA doesn't support 16x, so just do two x8s.
-    lea rdx, [rdx + 8 * rcx]
-    lea rdx, [rdx + 8 * rcx]
-
-    bt qword ptr [rdx], {SA_ONSTACK_BIT}
-    jnc 4f
-
-    // Otherwise, the altstack is already active. The sigaltstack being disabled, is equivalent
-    // to setting 'top' to usize::MAX and 'bottom' to 0.
-
-    // If current RSP is above altstack region, switch to altstack
-    mov rdx, fs:[{tcb_sa_off} + {sa_altstack_top}]
-    cmp rsp, rdx
-    cmova rsp, rdx
-
-    // If current RSP is below altstack region, also switch to altstack
-    cmp rsp, fs:[{tcb_sa_off} + {sa_altstack_bottom}]
-    cmovbe rsp, rdx
-
-    .p2align 4
-4:
-    // Now that we have a stack, we can finally start initializing the signal stack!
-
-    push fs:[{tcb_sa_off} + {sa_tmp_rsp}]
-    push fs:[{tcb_sc_off} + {sc_saved_rip}]
-    push fs:[{tcb_sc_off} + {sc_saved_rflags}]
-
-    push fs:[{tcb_sa_off} + {sa_tmp_rdi}]
-    push fs:[{tcb_sa_off} + {sa_tmp_rsi}]
-    push fs:[{tcb_sa_off} + {sa_tmp_rdx}]
-    push rcx
-    push fs:[{tcb_sa_off} + {sa_tmp_rax}]
-    push fs:[{tcb_sa_off} + {sa_tmp_r8}]
-    push r9
-    push fs:[{tcb_sa_off} + {sa_tmp_r10}]
-    push r11
-    push rbx
-    push rbp
-    push fs:[{tcb_sa_off} + {sa_tmp_r12}]
-    push r13
-    push r14
-    push r15
-    sub rsp, (29 + 16) * 16 // fxsave region minus available bytes
-    fxsave64 [rsp + 16 * 16]
-
-    // TODO: self-modifying?
-    cmp byte ptr [rip + {supports_avx}], 0
-    je 5f
-
-    // Prefer vextractf128 over vextracti128 since the former only requires AVX version 1.
-    vextractf128 [rsp + 15 * 16], ymm0, 1
-    vextractf128 [rsp + 14 * 16], ymm1, 1
-    vextractf128 [rsp + 13 * 16], ymm2, 1
-    vextractf128 [rsp + 12 * 16], ymm3, 1
-    vextractf128 [rsp + 11 * 16], ymm4, 1
-    vextractf128 [rsp + 10 * 16], ymm5, 1
-    vextractf128 [rsp + 9 * 16], ymm6, 1
-    vextractf128 [rsp + 8 * 16], ymm7, 1
-    vextractf128 [rsp + 7 * 16], ymm8, 1
-    vextractf128 [rsp + 6 * 16], ymm9, 1
-    vextractf128 [rsp + 5 * 16], ymm10, 1
-    vextractf128 [rsp + 4 * 16], ymm11, 1
-    vextractf128 [rsp + 3 * 16], ymm12, 1
-    vextractf128 [rsp + 2 * 16], ymm13, 1
-    vextractf128 [rsp + 16], ymm14, 1
-    vextractf128 [rsp], ymm15, 1
-5:
-    mov [rsp - 4], eax
-    sub rsp, 64 // alloc space for ucontext fields
-
-    mov rdi, rsp
-    call {inner}
-
-    add rsp, 64
-
-    fxrstor64 [rsp + 16 * 16]
-
-    cmp byte ptr [rip + {supports_avx}], 0
-    je 6f
-
-    vinsertf128 ymm0, ymm0, [rsp + 15 * 16], 1
-    vinsertf128 ymm1, ymm1, [rsp + 14 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 13 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 12 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 11 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 10 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 9 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 8 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 7 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 6 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 5 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 4 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 3 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 2 * 16], 1
-    vinsertf128 ymm2, ymm2, [rsp + 16], 1
-    vinsertf128 ymm2, ymm2, [rsp], 1
-6:
-    add rsp, (29 + 16) * 16
-
-    pop r15
-    pop r14
-    pop r13
-    pop r12
-    pop rbp
-    pop rbx
-    pop r11
-    pop r10
-    pop r9
-    pop r8
-    pop rax
-    pop rcx
-    pop rdx
-    pop rsi
-    pop rdi
-
-    popfq
-    pop qword ptr fs:[{tcb_sa_off} + {sa_tmp_rip}]
-
-    // x86 lacks atomic instructions for setting both the stack and instruction pointer
-    // simultaneously, except the slow microcoded IRETQ instruction. Thus, we let the arch_pre
-    // function emulate atomicity between the pop rsp and indirect jump.
-
-    .globl __relibc_internal_sigentry_crit_first
-__relibc_internal_sigentry_crit_first:
-
-    pop rsp
-
-    .globl __relibc_internal_sigentry_crit_second
-__relibc_internal_sigentry_crit_second:
-    jmp qword ptr fs:[{tcb_sa_off} + {sa_tmp_rip}]
-7:
-    // A spurious signal occurred. Signals are still disabled here, but will need to be re-enabled.
-
-    // restore flags
-    mov rax, fs:[0] // load FS base
-    // TODO: Use lahf/sahf rather than pushfq/popfq?
-    lea rsp, [rax + {tcb_sc_off} + {sc_saved_rflags}]
-    popfq
-
-    // restore stack
-    mov rsp, fs:[{tcb_sa_off} + {sa_tmp_rsp}]
-
-    // move saved RIP away from control, allowing arch_pre to save us if interrupted.
-    mov rax, fs:[{tcb_sc_off} + {sc_saved_rip}]
-    mov fs:[{tcb_sa_off} + {sa_tmp_rip}], rax
-
-    // restore regs
-    mov rax, fs:[{tcb_sa_off} + {sa_tmp_rax}]
-    mov rdx, fs:[{tcb_sa_off} + {sa_tmp_rdx}]
-
-    // Re-enable signals. This code can be interrupted after this signal, so we need to define
-    // 'crit_third'.
-    and qword ptr fs:[{tcb_sc_off} + {sc_control}], ~1
-
-    .globl __relibc_internal_sigentry_crit_third
-__relibc_internal_sigentry_crit_third:
-    jmp qword ptr fs:[{tcb_sa_off} + {sa_tmp_rip}]
-"] <= [
-    inner = sym inner_c,
-    sa_tmp_rip = const offset_of!(SigArea, tmp_rip),
-    sa_tmp_rsp = const offset_of!(SigArea, tmp_rsp),
-    sa_tmp_rax = const offset_of!(SigArea, tmp_rax),
-    sa_tmp_rdx = const offset_of!(SigArea, tmp_rdx),
-    sa_tmp_rdi = const offset_of!(SigArea, tmp_rdi),
-    sa_tmp_rsi = const offset_of!(SigArea, tmp_rsi),
-    sa_tmp_r8 = const offset_of!(SigArea, tmp_r8),
-    sa_tmp_r10 = const offset_of!(SigArea, tmp_r10),
-    sa_tmp_r12 = const offset_of!(SigArea, tmp_r12),
-    sa_tmp_rt_inf = const offset_of!(SigArea, tmp_rt_inf),
-    sa_tmp_id_inf = const offset_of!(SigArea, tmp_id_inf),
-    sa_altstack_top = const offset_of!(SigArea, altstack_top),
-    sa_altstack_bottom = const offset_of!(SigArea, altstack_bottom),
-    sc_saved_rflags = const offset_of!(Sigcontrol, saved_archdep_reg),
-    sc_saved_rip = const offset_of!(Sigcontrol, saved_ip),
-    sc_word = const offset_of!(Sigcontrol, word),
-    sc_sender_infos = const offset_of!(Sigcontrol, sender_infos),
-    sc_control = const offset_of!(Sigcontrol, control_flags),
-    tcb_sa_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, arch),
-    tcb_sc_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control),
-    pctl_off_actions = const offset_of!(SigProcControl, actions),
-    pctl_off_pending = const offset_of!(SigProcControl, pending),
-    pctl_off_sender_infos = const offset_of!(SigProcControl, sender_infos),
-    pctl = sym PROC_CONTROL_STRUCT,
-    supports_avx = sym SUPPORTS_AVX,
-    REDZONE_SIZE = const 128,
-    STACK_ALIGN = const 16,
-    SA_ONSTACK_BIT = const 58, // (1 << 58) >> 32 = 0x0400_0000
-    SYS_CALL = const syscall::SYS_CALL,
-    proc_call_sigdeq = sym PROC_CALL_SIGDEQ,
-    RTINF_SIZE = const size_of::<RtSigInfo>(),
-    proc_fd = sym PROC_FD,
-]);
-
-unsafe extern "C" {
-    fn __relibc_internal_sigentry_crit_first();
-    fn __relibc_internal_sigentry_crit_second();
-    fn __relibc_internal_sigentry_crit_third();
-}
-/// Fixes some edge cases, and calculates the value for uc_stack.
-pub unsafe fn arch_pre(stack: &mut SigStack, area: &mut SigArea) -> PosixStackt {
-    // It is impossible to update RSP and RIP atomically on x86_64, without using IRETQ, which is
-    // almost as slow as calling a SIGRETURN syscall would be. Instead, we abuse the fact that
-    // signals are disabled in the prologue of the signal trampoline, which allows us to emulate
-    // atomicity inside the critical section, consisting of one instruction at 'crit_first', one at
-    // 'crit_second', and one at 'crit_third', see asm.
-
-    if stack.regs.rip == __relibc_internal_sigentry_crit_first as *const () as usize {
-        // Reexecute pop rsp and jump steps. This case needs to be different from the one below,
-        // since rsp has not been overwritten with the previous context's stack, just yet. At this
-        // point, we know [rsp+0] contains the saved RSP, and [rsp-8] contains the saved RIP.
-        let stack_ptr = stack.regs.rsp as *const usize;
-        stack.regs.rsp = unsafe { stack_ptr.read() };
-        stack.regs.rip = unsafe { stack_ptr.sub(1).read() };
-    } else if stack.regs.rip == __relibc_internal_sigentry_crit_second as *const () as usize
-        || stack.regs.rip == __relibc_internal_sigentry_crit_third as *const () as usize
-    {
-        // Almost finished, just reexecute the jump before tmp_rip is overwritten by this
-        // deeper-level signal.
-        stack.regs.rip = area.tmp_rip;
-    }
-
-    get_sigaltstack(area, stack.regs.rsp).into()
-}
-
-/// Rearrange the restore-stack and sigarea in a way that makes it look like a new signal was
-/// immediately delivered after restoring the allowset to what it was prior to the original signal delivery.
-pub fn arch_ret_to_sig(stack: &mut SigStack, control: &Sigcontrol) {
-    let orig_rip = core::mem::replace(
-        &mut stack.regs.rip,
-        __relibc_internal_sigentry as *const () as usize,
-    );
-    control.saved_ip.set(orig_rip);
-    control.saved_archdep_reg.set(stack.regs.rflags);
-}
-
-pub(crate) static SUPPORTS_AVX: AtomicU8 = AtomicU8::new(0);
-
-// __relibc will be prepended to the name, so no_mangle is fine
-#[allow(unsafe_op_in_unsafe_fn)]
-#[unsafe(no_mangle)]
-pub unsafe fn manually_enter_trampoline() {
-    let c = &Tcb::current().unwrap().os_specific.control;
-    c.control_flags.store(
-        c.control_flags.load(Ordering::Relaxed) | syscall::flag::INHIBIT_DELIVERY.bits(),
-        Ordering::Release,
-    );
-    c.saved_archdep_reg.set(0); // TODO: Just reset DF on x86?
-
-    core::arch::asm!("
-        lea rax, [rip + 2f]
-        mov fs:[{tcb_sc_off} + {sc_saved_rip}], rax
-        jmp __relibc_internal_sigentry
-    2:
-    ",
-        out("rax") _,
-        tcb_sc_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control),
-        sc_saved_rip = const offset_of!(Sigcontrol, saved_ip),
-    );
-}
-
-/// Get current stack pointer, weak granularity guarantees.
-pub fn current_sp() -> usize {
-    let sp: usize;
-    unsafe {
-        core::arch::asm!("mov {}, rsp", out(reg) sp);
-    }
-    sp
-}
-
-static PROC_CALL_SIGDEQ: u64 = ProcCall::Sigdeq as u64;
-pub(crate) static PROC_FD: SyncUnsafeCell<usize> = SyncUnsafeCell::new(usize::MAX);

redox-rt/src/lib.rs

@@ -1,366 +0,0 @@
-#![no_std]
-#![allow(internal_features)]
-#![deny(unsafe_op_in_unsafe_fn)]
-#![feature(core_intrinsics, int_roundings, slice_ptr_get, sync_unsafe_cell)]
-#![forbid(unreachable_patterns)]
-
-use core::cell::UnsafeCell;
-
-use generic_rt::GenericTcb;
-use redox_protocols::protocol::ProcMeta;
-use syscall::Sigcontrol;
-
-use self::{
-    proc::{FdGuard, FdGuardUpper, STATIC_PROC_INFO},
-    sync::Mutex,
-    sys::FdTbl,
-};
-
-extern crate alloc;
-
-#[macro_export]
-macro_rules! asmfunction(
-    ($name:ident $(($($arg:ty),*))? $(-> $ret:ty)? : [$($asmstmt:expr),*$(,)?] <= [$($decl:ident = $(sym $symname:ident)?$(const $constval:expr)?),*$(,)?]$(,)? ) => {
-        ::core::arch::global_asm!(concat!("
-            .p2align 4
-            .section .text.", stringify!($name), ", \"ax\", @progbits
-            .globl ", stringify!($name), "
-            .type ", stringify!($name), ", @function
-        ", stringify!($name), ":
-        ", $($asmstmt, "\n",)* "
-            .size ", stringify!($name), ", . - ", stringify!($name), "
-        "), $($decl = $(sym $symname)?$(const $constval)?),*);
-
-        unsafe extern "C" {
-            pub fn $name($($(_: $arg),*)?) $(-> $ret)?;
-        }
-    }
-);
-
-pub mod arch;
-pub mod proc;
-
-// TODO: Replace auxvs with a non-stack-based interface, but keep getauxval for compatibility
-#[path = "../../src/platform/auxv_defs.rs"]
-pub mod auxv_defs;
-
-pub mod signal;
-pub mod sync;
-pub mod sys;
-pub mod thread;
-
-#[derive(Debug, Default)]
-pub struct RtTcb {
-    pub control: Sigcontrol,
-    pub arch: UnsafeCell<crate::arch::SigArea>,
-    pub thr_fd: UnsafeCell<Option<FdGuardUpper>>,
-}
-impl RtTcb {
-    pub fn current() -> &'static Self {
-        unsafe { &Tcb::current().unwrap().os_specific }
-    }
-    pub fn thread_fd(&self) -> &FdGuardUpper {
-        unsafe { (&*self.thr_fd.get()).as_ref().unwrap() }
-    }
-}
-
-pub type Tcb = GenericTcb<RtTcb>;
-
-// TODO: Remove this by keeping the TCB initialized during exec
-// and informing ld.so through some other way.
-pub static TLS_ACTIVATED: core::sync::atomic::AtomicBool =
-    core::sync::atomic::AtomicBool::new(false);
-
-/// OS and architecture specific code to activate TLS - Redox aarch64
-#[allow(unsafe_op_in_unsafe_fn)]
-#[cfg(target_arch = "aarch64")]
-pub unsafe fn tcb_activate(_tcb: &RtTcb, tls_end: usize, tls_len: usize) {
-    // Uses ABI page
-    let abi_ptr = tls_end - tls_len - 16;
-    core::ptr::write(abi_ptr as *mut usize, tls_end);
-    core::arch::asm!(
-        "msr tpidr_el0, {}",
-        in(reg) abi_ptr,
-    );
-    TLS_ACTIVATED.store(true, core::sync::atomic::Ordering::Relaxed);
-}
-
-/// OS and architecture specific code to activate TLS - Redox x86
-#[allow(unsafe_op_in_unsafe_fn)]
-#[cfg(target_arch = "x86")]
-pub unsafe fn tcb_activate(tcb: &RtTcb, tls_end: usize, _tls_len: usize) {
-    let mut env = syscall::EnvRegisters::default();
-
-    let file_fd = crate::sys::dup_into_upper_raw(tcb.thread_fd().as_raw_fd(), b"regs/env")
-        .expect("failed to open handle for process registers");
-
-    syscall::read(file_fd, &mut env).expect("failed to read gsbase");
-
-    env.gsbase = tls_end as u32;
-
-    syscall::write(file_fd, &env).expect("failed to write gsbase");
-
-    let _ = crate::sys::close_raw(file_fd);
-
-    TLS_ACTIVATED.store(true, core::sync::atomic::Ordering::Relaxed);
-}
-
-/// OS and architecture specific code to activate TLS - Redox x86_64
-#[allow(unsafe_op_in_unsafe_fn)]
-#[cfg(target_arch = "x86_64")]
-pub unsafe fn tcb_activate(tcb: &RtTcb, tls_end_and_tcb_start: usize, _tls_len: usize) {
-    let mut env = syscall::EnvRegisters::default();
-
-    let file_fd = crate::sys::dup_into_upper_raw(tcb.thread_fd().as_raw_fd(), b"regs/env")
-        .expect("failed to open handle for process registers");
-
-    syscall::read(file_fd, &mut env).expect("failed to read fsbase");
-
-    env.fsbase = tls_end_and_tcb_start as u64;
-
-    syscall::write(file_fd, &env).expect("failed to write fsbase");
-
-    let _ = crate::sys::close_raw(file_fd);
-
-    TLS_ACTIVATED.store(true, core::sync::atomic::Ordering::Relaxed);
-}
-
-/// OS and architecture specific code to activate TLS - Redox riscv64
-#[allow(unsafe_op_in_unsafe_fn)]
-#[cfg(target_arch = "riscv64")]
-pub unsafe fn tcb_activate(_tcb: &RtTcb, tls_end: usize, tls_len: usize) {
-    // tp points to static tls block
-    // FIXME limited to a single initial master
-    let tls_start = tls_end - tls_len;
-    let abi_ptr = tls_start - 8;
-    core::ptr::write(abi_ptr as *mut usize, tls_end);
-    core::arch::asm!(
-        "mv tp, {}",
-        in(reg) tls_start
-    );
-    TLS_ACTIVATED.store(true, core::sync::atomic::Ordering::Relaxed);
-}
-
-/// Initialize redox-rt in situations where relibc is not used
-#[allow(unsafe_op_in_unsafe_fn)]
-#[cfg(not(feature = "proc"))]
-pub unsafe fn initialize_freestanding(this_thr_fd: FdGuardUpper) -> &'static FdGuardUpper {
-    // TODO: This code is a hack! Integrate the ld_so TCB code into generic-rt, and then use that
-    // (this function will need pointers to the ELF structs normally passed in auxvs), so the TCB
-    // is initialized properly.
-
-    // TODO: TLS
-    let page = {
-        &mut *(syscall::fmap(
-            !0,
-            &syscall::Map {
-                offset: 0,
-                size: syscall::PAGE_SIZE,
-                flags: syscall::MapFlags::PROT_READ
-                    | syscall::MapFlags::PROT_WRITE
-                    | syscall::MapFlags::MAP_PRIVATE,
-                address: 0,
-            },
-        )
-        .unwrap() as *mut Tcb)
-    };
-    page.tcb_ptr = page;
-    page.tcb_len = syscall::PAGE_SIZE;
-    page.tls_end = (page as *mut Tcb).cast();
-
-    let cur_filetable_fd = syscall::dup_into(
-        this_thr_fd.as_raw_fd(),
-        this_thr_fd.as_raw_fd() + 1,
-        b"filetable-binary",
-    )
-    .expect("failed to open filetable-binary");
-
-    *current_filetable() =
-        FdTbl::from_binary_fd(FdGuard::new(cur_filetable_fd).to_upper().unwrap())
-            .expect("failed to populate fds");
-
-    // Make sure to use ptr::write to prevent dropping the existing FdGuard
-    page.os_specific.thr_fd.get().write(Some(this_thr_fd));
-
-    #[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
-    unsafe {
-        let tcb_addr = page as *mut Tcb as usize;
-        tcb_activate(&page.os_specific, tcb_addr, 0)
-    }
-    #[cfg(target_arch = "aarch64")]
-    unsafe {
-        let abi_ptr = core::ptr::addr_of_mut!(page.tcb_ptr);
-        core::arch::asm!("msr tpidr_el0, {}", in(reg) abi_ptr);
-    }
-    #[cfg(target_arch = "riscv64")]
-    unsafe {
-        let abi_ptr = core::ptr::addr_of_mut!(page.tcb_ptr) as usize;
-        core::arch::asm!("mv tp, {}", in(reg) (abi_ptr + 8));
-    }
-    TLS_ACTIVATED.store(true, core::sync::atomic::Ordering::Relaxed);
-
-    initialize();
-
-    (*page.os_specific.thr_fd.get()).as_ref().unwrap()
-}
-pub(crate) fn read_proc_meta(proc: &FdGuardUpper) -> syscall::Result<ProcMeta> {
-    let mut bytes = [0_u8; size_of::<ProcMeta>()];
-    proc.read(&mut bytes)?;
-    Ok(*plain::from_bytes::<ProcMeta>(&bytes).unwrap())
-}
-pub unsafe fn initialize(
-    #[cfg(feature = "proc")] proc_fd: FdGuardUpper,
-    #[cfg(feature = "proc")] ns_fd: Option<FdGuardUpper>,
-) {
-    #[cfg(feature = "proc")]
-    let metadata = read_proc_meta(&proc_fd).unwrap();
-
-    #[cfg(not(feature = "proc"))]
-    // Bootstrap mode, don't associate proc fds with PIDs
-    let metadata = ProcMeta::default();
-
-    #[cfg(feature = "proc")]
-    {
-        unsafe { crate::arch::PROC_FD.get().write(proc_fd.as_raw_fd()) };
-    }
-
-    unsafe {
-        STATIC_PROC_INFO.get().write(StaticProcInfo {
-            pid: metadata.pid,
-
-            #[cfg(feature = "proc")]
-            proc_fd: Some(proc_fd),
-
-            #[cfg(not(feature = "proc"))]
-            proc_fd: None,
-        })
-    };
-
-    #[cfg(feature = "proc")]
-    {
-        *DYNAMIC_PROC_INFO.lock() = DynamicProcInfo {
-            pgid: metadata.pgid,
-            ruid: metadata.ruid,
-            euid: metadata.euid,
-            suid: metadata.suid,
-            egid: metadata.egid,
-            rgid: metadata.rgid,
-            sgid: metadata.sgid,
-            ns_fd,
-        };
-    }
-}
-
-pub(crate) struct StaticProcInfo {
-    pid: u32,
-    proc_fd: Option<FdGuardUpper>,
-}
-pub struct DynamicProcInfo {
-    pub pgid: u32,
-    pub euid: u32,
-    pub suid: u32,
-    pub ruid: u32,
-    pub egid: u32,
-    pub rgid: u32,
-    pub sgid: u32,
-    pub ns_fd: Option<FdGuardUpper>,
-}
-
-static DYNAMIC_PROC_INFO: Mutex<DynamicProcInfo> = Mutex::new(DynamicProcInfo {
-    pgid: u32::MAX,
-    ruid: u32::MAX,
-    euid: u32::MAX,
-    suid: u32::MAX,
-    rgid: u32::MAX,
-    egid: u32::MAX,
-    sgid: u32::MAX,
-    ns_fd: None,
-});
-
-#[inline]
-pub(crate) fn static_proc_info() -> &'static StaticProcInfo {
-    unsafe { &*STATIC_PROC_INFO.get() }
-}
-#[inline]
-pub fn current_proc_fd() -> &'static FdGuardUpper {
-    let info = static_proc_info();
-    info.proc_fd.as_ref().unwrap()
-}
-#[inline]
-pub fn current_namespace_fd() -> syscall::Result<usize> {
-    DYNAMIC_PROC_INFO
-        .lock()
-        .ns_fd
-        .as_ref()
-        .map(|g| g.as_raw_fd())
-        .ok_or(syscall::Error::new(syscall::ENOENT))
-}
-struct ChildHookCommonArgs {
-    new_thr_fd: FdGuard,
-    new_proc_fd: Option<FdGuard>,
-    new_filetable_fd: FdGuardUpper,
-}
-
-unsafe fn child_hook_common(args: ChildHookCommonArgs) {
-    let new_filetable_fd = args.new_filetable_fd;
-
-    let old_filetable_fd;
-    {
-        let mut guard = current_filetable();
-        old_filetable_fd = guard.take();
-        guard.set_fd(new_filetable_fd);
-        guard
-            .override_at(args.new_thr_fd.as_raw_fd(), args.new_thr_fd.as_raw_fd())
-            .expect("failed to add new_thr_fd");
-        if let Some(new_proc_fd) = args.new_proc_fd.as_ref() {
-            guard
-                .override_at(new_proc_fd.as_raw_fd(), new_proc_fd.as_raw_fd())
-                .expect("failed to add new_proc_fd");
-        }
-        if let Some(ref old) = old_filetable_fd {
-            let _ = guard.remove(old.as_raw_fd());
-        }
-    }
-
-    let new_thr_fd = args.new_thr_fd.to_upper().unwrap();
-    let new_proc_fd = args.new_proc_fd.map(|x| x.to_upper().unwrap());
-
-    // TODO: just pass PID to child rather than obtaining it via IPC?
-    #[cfg(feature = "proc")]
-    let metadata = read_proc_meta(
-        new_proc_fd
-            .as_ref()
-            .expect("must be present with proc feature"),
-    )
-    .unwrap();
-
-    #[cfg(not(feature = "proc"))]
-    let metadata = ProcMeta::default();
-
-    if let Some(proc_fd) = &new_proc_fd {
-        unsafe { crate::arch::PROC_FD.get().write(proc_fd.as_raw_fd()) };
-    }
-
-    let old_proc_fd = unsafe {
-        STATIC_PROC_INFO
-            .get()
-            .replace(StaticProcInfo {
-                pid: metadata.pid,
-                proc_fd: new_proc_fd,
-            })
-            .proc_fd
-    };
-    drop(old_proc_fd);
-
-    let old_thr_fd = unsafe { RtTcb::current().thr_fd.get().replace(Some(new_thr_fd)) };
-    drop(old_thr_fd);
-
-    drop(old_filetable_fd);
-}
-
-static FILETABLE: Mutex<FdTbl> = Mutex::new(FdTbl::new());
-
-#[inline]
-pub fn current_filetable() -> crate::sync::MutexGuard<'static, FdTbl> {
-    FILETABLE.lock()
-}

redox-rt/src/sync.rs

@@ -1,68 +0,0 @@
-// TODO: Share code for simple futex-based mutex between relibc's Mutex<()> and this.
-
-use core::{
-    cell::UnsafeCell,
-    ops::{Deref, DerefMut},
-    sync::atomic::{AtomicU32, Ordering},
-};
-
-pub struct Mutex<T> {
-    pub lockword: AtomicU32,
-    pub inner: UnsafeCell<T>,
-}
-
-unsafe impl<T: Send> Send for Mutex<T> {}
-unsafe impl<T: Send> Sync for Mutex<T> {}
-
-impl<T> Mutex<T> {
-    /// Represents an unlocked [Mutex].
-    pub const UNLOCKED: u32 = 0;
-    /// Represents a locked [Mutex].
-    pub const LOCKED: u32 = 1;
-    /// Represents a waiting [Mutex].
-    pub const WAITING: u32 = 2;
-
-    pub const fn new(t: T) -> Self {
-        Self {
-            lockword: AtomicU32::new(0),
-            inner: UnsafeCell::new(t),
-        }
-    }
-    pub fn lock(&self) -> MutexGuard<'_, T> {
-        while self
-            .lockword
-            .compare_exchange(
-                Self::UNLOCKED,
-                Self::LOCKED,
-                Ordering::Acquire,
-                Ordering::Relaxed,
-            )
-            .is_err()
-        {
-            core::hint::spin_loop();
-        }
-        MutexGuard { lock: self }
-    }
-}
-pub struct MutexGuard<'l, T> {
-    lock: &'l Mutex<T>,
-}
-impl<T> Deref for MutexGuard<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        unsafe { &*self.lock.inner.get() }
-    }
-}
-impl<T> DerefMut for MutexGuard<'_, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        unsafe { &mut *self.lock.inner.get() }
-    }
-}
-impl<T> Drop for MutexGuard<'_, T> {
-    fn drop(&mut self) {
-        self.lock
-            .lockword
-            .store(Mutex::<T>::UNLOCKED, Ordering::Release);
-    }
-}

redox-rt/src/thread.rs

@@ -1,76 +0,0 @@
-use core::mem::size_of;
-
-use syscall::Result;
-
-use crate::{RtTcb, arch::*, proc::*, static_proc_info};
-
-/// Spawns a new context sharing the same address space as the current one (i.e. a new thread).
-pub unsafe fn rlct_clone_impl(stack: *mut usize, tcb: &RtTcb) -> Result<usize> {
-    let proc_info = static_proc_info();
-    let cur_proc_fd = proc_info.proc_fd.as_ref().unwrap();
-
-    let cur_thr_fd = RtTcb::current().thread_fd();
-    let new_thr_fd = cur_proc_fd.dup_into_upper(b"new-thread")?;
-
-    // Inherit existing address space
-    {
-        let cur_addr_space_fd = cur_thr_fd.dup_into_upper(b"addrspace")?;
-        let new_addr_space_sel_fd = new_thr_fd.dup_into_upper(b"current-addrspace")?;
-
-        let buf = create_set_addr_space_buf(
-            cur_addr_space_fd.as_raw_fd(),
-            __relibc_internal_rlct_clone_ret as *const () as usize,
-            stack as usize,
-        );
-        new_addr_space_sel_fd.write(&buf)?;
-    }
-
-    // Inherit reference to file table
-    {
-        let cur_filetable_fd = cur_thr_fd.dup_into_upper(b"filetable")?;
-        let new_filetable_sel_fd = new_thr_fd.dup_into_upper(b"current-filetable")?;
-
-        new_filetable_sel_fd.write(&usize::to_ne_bytes(cur_filetable_fd.as_raw_fd()))?;
-    }
-
-    // Since the signal handler is not yet initialized, signals specifically targeting the thread
-    // (relibc is only required to implement thread-specific signals that already originate from
-    // the same process) will be discarded. Process-specific signals will ignore this new thread,
-    // until it has initialized its own signal handler.
-
-    let start_fd = new_thr_fd.dup_into_upper(b"start")?;
-
-    let fd = new_thr_fd.as_raw_fd();
-    unsafe {
-        tcb.thr_fd.get().write(Some(new_thr_fd));
-    }
-
-    // Unblock context.
-    start_fd.write(&[0])?;
-
-    Ok(fd)
-}
-
-pub unsafe fn exit_this_thread(stack_base: *mut (), stack_size: usize) -> ! {
-    let _guard = crate::signal::tmp_disable_signals();
-    let thread_fd = RtTcb::current().thread_fd();
-
-    // TODO: modify interface so it writes directly to the thread fd?
-    let status_fd = thread_fd.dup_into_upper(b"status").unwrap();
-    unsafe { exit_this_thread_inner(stack_base, stack_size, status_fd) }
-}
-
-/// exit_this_thread, but current thread_fd might has disappear
-pub unsafe fn exit_this_thread_inner(
-    stack_base: *mut (),
-    stack_size: usize,
-    status_fd: FdGuard<true>,
-) -> ! {
-    let mut buf = [0; size_of::<usize>() * 3];
-    plain::slice_from_mut_bytes(&mut buf)
-        .unwrap()
-        .copy_from_slice(&[usize::MAX, stack_base as usize, stack_size]);
-    // TODO: SYS_CALL w/CONSUME
-    status_fd.write(&buf).unwrap();
-    unreachable!()
-}

renamesyms.sh

@@ -1,58 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-target=$1
-deps_dir=$2
-
-if [ -z "$target" ] || [ -z "$deps_dir" ]; then
-    echo "Usage:\n\t./renamesyms.sh TARGET DEPS_DIR"
-    exit 1
-fi
-
-if [ ! -f "$target" ]; then
-    echo "Target file '$target' does not exist"
-    exit 1
-fi
-if [ ! -d "$deps_dir" ] ; then
-    echo "Deps dir '$deps_dir' does not exist or not a directory"
-    exit 1
-fi
-
-symbols_file=`mktemp`
-special_syms=(
-    __rdl_oom
-    __rg_alloc
-    __rg_alloc_zeroed
-    __rg_dealloc
-    __rg_oom
-    __rg_realloc
-    __rust_alloc
-    __rust_alloc_error_handler
-    __rust_alloc_error_handler_should_panic
-    __rust_alloc_zeroed
-    __rust_dealloc
-    __rust_no_alloc_shim_is_unstable
-    __rust_realloc
-)
-
-for dep in `find $deps_dir -type f -name "*.rlib"`; do
-    "${NM}" --format=posix -g "$dep" 2>/dev/null | sed 's/.*:.*//g' | awk '{if ($2 == "T") print $1}' | sed 's/^\(.*\)$/\1 __relibc_\1/g' >> $symbols_file
-done
-
-for special_sym in "${special_syms[@]}"; do
-    echo "$special_sym __relibc_$special_sym" >> $symbols_file
-done
-
-mangled_alloc_syms=$("${NM}" --format=posix -g "$target" 2>/dev/null | awk '{print $1}' | grep "7___rustc" || true)
-for sym in $mangled_alloc_syms; do
-    echo "$sym __relibc_$sym" >> $symbols_file
-done
-
-sorted_file=`mktemp`
-sort -u "$symbols_file" > "$sorted_file"
-rm -f "$symbols_file"
-
-"${OBJCOPY}" --redefine-syms="$sorted_file" "$target"
-
-rm -f "$sorted_file"

rmm/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "rmm"
+version = "0.1.0"
+authors = ["Jeremy Soller <jeremy@system76.com>"]
+edition = "2024"
+
+[dependencies]
+bitflags = "2"
+
+[features]
+std = []
+
+[[bin]]
+name = "rmm"
+path = "src/main.rs"
+required-features = ["std"]

rmm/README.md

@@ -0,0 +1,4 @@
+# Redox Memory Management
+
+This is a Rust crate to provide abstractions for hardware memory management. It
+also contains a mechanism for testing memory management with software emulation.

rmm/src/allocator/frame/buddy.rs

@@ -0,0 +1,296 @@
+use core::{marker::PhantomData, mem};
+
+use crate::{
+    Arch, BumpAllocator, FrameAllocator, FrameCount, FrameUsage, PhysicalAddress, VirtualAddress,
+};
+
+#[repr(transparent)]
+struct BuddyUsage(u8);
+
+#[repr(C, packed)]
+struct BuddyEntry<A> {
+    base: PhysicalAddress,
+    size: usize,
+    // Number of first free page
+    skip: usize,
+    // Count of used pages
+    used: usize,
+    phantom: PhantomData<A>,
+}
+
+impl<A> Clone for BuddyEntry<A> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<A> Copy for BuddyEntry<A> {}
+
+impl<A: Arch> BuddyEntry<A> {
+    fn empty() -> Self {
+        Self {
+            base: PhysicalAddress::new(0),
+            size: 0,
+            skip: 0,
+            used: 0,
+            phantom: PhantomData,
+        }
+    }
+
+    #[inline(always)]
+    fn pages(&self) -> usize {
+        self.size >> A::PAGE_SHIFT
+    }
+
+    fn usage_pages(&self) -> usize {
+        let bytes = self.pages() * mem::size_of::<BuddyUsage>();
+        // Round bytes used for usage to next page
+        (bytes + A::PAGE_OFFSET_MASK) >> A::PAGE_SHIFT
+    }
+
+    unsafe fn usage_addr(&self, page: usize) -> Option<VirtualAddress> {
+        if page < self.pages() {
+            let phys = self.base.add(page * mem::size_of::<BuddyUsage>());
+            Some(A::phys_to_virt(phys))
+        } else {
+            None
+        }
+    }
+
+    unsafe fn usage(&self, page: usize) -> Option<BuddyUsage> {
+        unsafe {
+            let addr = self.usage_addr(page)?;
+            Some(A::read(addr))
+        }
+    }
+
+    #[expect(clippy::unit_arg)]
+    unsafe fn set_usage(&self, page: usize, usage: BuddyUsage) -> Option<()> {
+        unsafe {
+            let addr = self.usage_addr(page)?;
+            Some(A::write(addr, usage))
+        }
+    }
+}
+
+pub struct BuddyAllocator<A> {
+    table_virt: VirtualAddress,
+    phantom: PhantomData<A>,
+}
+
+impl<A: Arch> BuddyAllocator<A> {
+    const BUDDY_ENTRIES: usize = A::PAGE_SIZE / mem::size_of::<BuddyEntry<A>>();
+
+    pub unsafe fn new(mut bump_allocator: BumpAllocator<A>) -> Option<Self> {
+        unsafe {
+            // Allocate buddy table
+            let table_phys = bump_allocator.allocate_one()?;
+            let table_virt = A::phys_to_virt(table_phys);
+            for i in 0..(A::PAGE_SIZE / mem::size_of::<BuddyEntry<A>>()) {
+                let virt = table_virt.add(i * mem::size_of::<BuddyEntry<A>>());
+                A::write(virt, BuddyEntry::<A>::empty());
+            }
+
+            let allocator = Self {
+                table_virt,
+                phantom: PhantomData,
+            };
+
+            // Add areas to buddy table, combining areas when possible, and skipping frames used
+            // by the bump allocator
+            let mut offset = bump_allocator.offset();
+            for old_area in bump_allocator.areas().iter() {
+                let mut area = *old_area;
+                if offset >= area.size {
+                    offset -= area.size;
+                    continue;
+                } else if offset > 0 {
+                    area.base = area.base.add(offset);
+                    area.size -= offset;
+                    offset = 0;
+                }
+                for i in 0..(A::PAGE_SIZE / mem::size_of::<BuddyEntry<A>>()) {
+                    let virt = table_virt.add(i * mem::size_of::<BuddyEntry<A>>());
+                    let mut entry = A::read::<BuddyEntry<A>>(virt);
+                    let inserted = if area.base.add(area.size) == { entry.base } {
+                        // Combine entry at start
+                        entry.base = area.base;
+                        entry.size += area.size;
+                        true
+                    } else if area.base == entry.base.add(entry.size) {
+                        // Combine entry at end
+                        entry.size += area.size;
+                        true
+                    } else if entry.size == 0 {
+                        // Create new entry
+                        entry.base = area.base;
+                        entry.size = area.size;
+                        true
+                    } else {
+                        false
+                    };
+                    if inserted {
+                        A::write(virt, entry);
+                        break;
+                    }
+                }
+            }
+
+            //TODO: sort areas?
+
+            // Allocate buddy maps
+            for i in 0..Self::BUDDY_ENTRIES {
+                let virt = table_virt.add(i * mem::size_of::<BuddyEntry<A>>());
+                let mut entry = A::read::<BuddyEntry<A>>(virt);
+
+                // Only set up entries that have enough space for their own usage map
+                let usage_pages = entry.usage_pages();
+                if entry.pages() > usage_pages {
+                    // Mark all usage bytes as unused
+                    let usage_start = entry.usage_addr(0)?;
+                    for page in 0..usage_pages {
+                        A::write_bytes(usage_start.add(page << A::PAGE_SHIFT), 0, A::PAGE_SIZE);
+                    }
+
+                    // Mark bytes used for usage as used
+                    for page in 0..usage_pages {
+                        entry.set_usage(page, BuddyUsage(1))?;
+                    }
+                }
+
+                // Skip the pages used for usage
+                entry.skip = usage_pages;
+
+                // Set used pages to pages used for usage
+                entry.used = usage_pages;
+
+                // Write updated entry
+                A::write(virt, entry);
+            }
+
+            Some(allocator)
+        }
+    }
+}
+
+unsafe impl<A: Arch> FrameAllocator for BuddyAllocator<A> {
+    fn allocate(&mut self, count: FrameCount) -> Option<PhysicalAddress> {
+        unsafe {
+            if self.table_virt.data() == 0 {
+                return None;
+            }
+
+            for entry_i in 0..Self::BUDDY_ENTRIES {
+                let virt = self
+                    .table_virt
+                    .add(entry_i * mem::size_of::<BuddyEntry<A>>());
+                let mut entry = A::read::<BuddyEntry<A>>(virt);
+
+                let mut free_page = entry.skip;
+                let mut free_count = 0;
+                for page in entry.skip..entry.pages() {
+                    let usage = entry.usage(page)?;
+                    if usage.0 == 0 {
+                        free_count += 1;
+
+                        if free_count == count.data() {
+                            break;
+                        }
+                    } else {
+                        free_page = page + 1;
+                        free_count = 0;
+                    }
+                }
+
+                if free_count == count.data() {
+                    for page in free_page..free_page + free_count {
+                        // Update usage
+                        let mut usage = entry.usage(page)?;
+                        usage.0 += 1;
+                        entry.set_usage(page, usage);
+
+                        // Zero page
+                        let page_phys = entry.base.add(page << A::PAGE_SHIFT);
+                        let page_virt = A::phys_to_virt(page_phys);
+                        A::write_bytes(page_virt, 0, A::PAGE_SIZE);
+                    }
+
+                    // Update skip if necessary
+                    if entry.skip == free_page {
+                        entry.skip = free_page + free_count;
+                    }
+
+                    // Update used page count
+                    entry.used += free_count;
+
+                    // Write updated entry
+                    A::write(virt, entry);
+
+                    return Some(entry.base.add(free_page << A::PAGE_SHIFT));
+                }
+            }
+
+            None
+        }
+    }
+
+    unsafe fn free(&mut self, base: PhysicalAddress, count: FrameCount) {
+        unsafe {
+            if self.table_virt.data() == 0 {
+                return;
+            }
+
+            let size = count.data() * A::PAGE_SIZE;
+            for i in 0..Self::BUDDY_ENTRIES {
+                let virt = self.table_virt.add(i * mem::size_of::<BuddyEntry<A>>());
+                let mut entry = A::read::<BuddyEntry<A>>(virt);
+
+                if base >= { entry.base } && base.add(size) <= entry.base.add(entry.size) {
+                    let start_page = (base.data() - { entry.base }.data()) >> A::PAGE_SHIFT;
+                    for page in start_page..start_page + count.data() {
+                        let mut usage = entry.usage(page).expect("failed to get usage during free");
+
+                        if usage.0 > 0 {
+                            usage.0 -= 1;
+                        } else {
+                            panic!("tried to free already free frame");
+                        }
+
+                        // If page was freed
+                        if usage.0 == 0 {
+                            // Update skip if necessary
+                            if page < entry.skip {
+                                entry.skip = page;
+                            }
+
+                            // Update used page count
+                            entry.used -= 1;
+                        }
+
+                        entry
+                            .set_usage(page, usage)
+                            .expect("failed to set usage during free");
+                    }
+
+                    // Write updated entry
+                    A::write(virt, entry);
+
+                    return;
+                }
+            }
+        }
+    }
+
+    fn usage(&self) -> FrameUsage {
+        unsafe {
+            let mut total = 0;
+            let mut used = 0;
+            for i in 0..Self::BUDDY_ENTRIES {
+                let virt = self.table_virt.add(i * mem::size_of::<BuddyEntry<A>>());
+                let entry = A::read::<BuddyEntry<A>>(virt);
+                total += entry.size >> A::PAGE_SHIFT;
+                used += entry.used;
+            }
+            FrameUsage::new(FrameCount::new(used), FrameCount::new(total))
+        }
+    }
+}

rmm/src/allocator/frame/bump.rs

@@ -0,0 +1,79 @@
+use core::marker::PhantomData;
+
+use crate::{Arch, FrameAllocator, FrameCount, FrameUsage, MemoryArea, PhysicalAddress};
+
+#[derive(Debug)]
+pub struct BumpAllocator<A> {
+    orig_areas: (&'static [MemoryArea], usize),
+    cur_areas: (&'static [MemoryArea], usize),
+    _marker: PhantomData<fn() -> A>,
+}
+
+impl<A: Arch> BumpAllocator<A> {
+    pub fn new(mut areas: &'static [MemoryArea], mut offset: usize) -> Self {
+        while let Some(first) = areas.first()
+            && first.size <= offset
+        {
+            offset -= first.size;
+            areas = &areas[1..];
+        }
+
+        Self {
+            orig_areas: (areas, offset),
+            cur_areas: (areas, offset),
+            _marker: PhantomData,
+        }
+    }
+    pub fn areas(&self) -> &'static [MemoryArea] {
+        self.orig_areas.0
+    }
+    /// Returns one semifree and the fully free areas. The offset is the number of bytes after
+    /// which the first area is free.
+    pub fn free_areas(&self) -> (&'static [MemoryArea], usize) {
+        self.cur_areas
+    }
+    pub fn abs_offset(&self) -> PhysicalAddress {
+        let (areas, off) = self.cur_areas;
+        areas
+            .first()
+            .map_or(PhysicalAddress::new(0), |a| a.base.add(off))
+    }
+    pub fn offset(&self) -> usize {
+        (self.usage().total().data() - self.usage().free().data()) * A::PAGE_SIZE
+    }
+}
+
+unsafe impl<A: Arch> FrameAllocator for BumpAllocator<A> {
+    fn allocate(&mut self, count: FrameCount) -> Option<PhysicalAddress> {
+        unsafe {
+            let req_size = count.data() * A::PAGE_SIZE;
+
+            let block = loop {
+                let area = self.cur_areas.0.first()?;
+                let off = self.cur_areas.1;
+                if area.size - off < req_size {
+                    self.cur_areas = (&self.cur_areas.0[1..], 0);
+                    continue;
+                }
+                self.cur_areas.1 += req_size;
+
+                break area.base.add(off);
+            };
+            A::write_bytes(A::phys_to_virt(block), 0, req_size);
+            Some(block)
+        }
+    }
+
+    unsafe fn free(&mut self, _address: PhysicalAddress, _count: FrameCount) {
+        unimplemented!("BumpAllocator::free not implemented");
+    }
+
+    fn usage(&self) -> FrameUsage {
+        let total = self.orig_areas.0.iter().map(|a| a.size).sum::<usize>() - self.orig_areas.1;
+        let free = self.cur_areas.0.iter().map(|a| a.size).sum::<usize>() - self.cur_areas.1;
+        FrameUsage::new(
+            FrameCount::new((total - free) / A::PAGE_SIZE),
+            FrameCount::new(total / A::PAGE_SIZE),
+        )
+    }
+}

rmm/src/allocator/frame/mod.rs

@@ -0,0 +1,83 @@
+use crate::PhysicalAddress;
+
+pub use self::{buddy::*, bump::*};
+
+mod buddy;
+mod bump;
+
+#[derive(Clone, Copy, Debug)]
+#[repr(transparent)]
+pub struct FrameCount(usize);
+
+impl FrameCount {
+    pub fn new(count: usize) -> Self {
+        Self(count)
+    }
+
+    pub fn data(&self) -> usize {
+        self.0
+    }
+}
+
+#[derive(Debug)]
+pub struct FrameUsage {
+    used: FrameCount,
+    total: FrameCount,
+}
+
+impl FrameUsage {
+    pub fn new(used: FrameCount, total: FrameCount) -> Self {
+        Self { used, total }
+    }
+
+    pub fn used(&self) -> FrameCount {
+        self.used
+    }
+
+    pub fn free(&self) -> FrameCount {
+        FrameCount(self.total.0 - self.used.0)
+    }
+
+    pub fn total(&self) -> FrameCount {
+        self.total
+    }
+}
+
+pub unsafe trait FrameAllocator {
+    fn allocate(&mut self, count: FrameCount) -> Option<PhysicalAddress>;
+
+    unsafe fn free(&mut self, address: PhysicalAddress, count: FrameCount);
+
+    fn allocate_one(&mut self) -> Option<PhysicalAddress> {
+        self.allocate(FrameCount::new(1))
+    }
+
+    unsafe fn free_one(&mut self, address: PhysicalAddress) {
+        unsafe {
+            self.free(address, FrameCount::new(1));
+        }
+    }
+
+    fn usage(&self) -> FrameUsage;
+}
+
+unsafe impl<T> FrameAllocator for &mut T
+where
+    T: FrameAllocator,
+{
+    fn allocate(&mut self, count: FrameCount) -> Option<PhysicalAddress> {
+        T::allocate(self, count)
+    }
+    unsafe fn free(&mut self, address: PhysicalAddress, count: FrameCount) {
+        unsafe { T::free(self, address, count) }
+    }
+    fn allocate_one(&mut self) -> Option<PhysicalAddress> {
+        T::allocate_one(self)
+    }
+    unsafe fn free_one(&mut self, address: PhysicalAddress) {
+        unsafe { T::free_one(self, address) }
+    }
+    fn usage(&self) -> FrameUsage {
+        T::usage(self)
+    }
+}

rmm/src/allocator/mod.rs

@@ -0,0 +1,3 @@
+pub use self::frame::*;
+
+mod frame;

rmm/src/arch/aarch64.rs

@@ -0,0 +1,153 @@
+use core::arch::asm;
+
+use crate::{Arch, PhysicalAddress, TableKind, VirtualAddress};
+
+#[derive(Clone, Copy)]
+pub struct AArch64Arch;
+
+impl Arch for AArch64Arch {
+    const KERNEL_SEPARATE_TABLE: bool = true;
+
+    const PAGE_SHIFT: usize = 12; // 4096 bytes
+    const PAGE_ENTRY_SHIFT: usize = 9; // 512 entries, 8 bytes each
+    const PAGE_LEVELS: usize = 4; // L0, L1, L2, L3
+
+    //TODO
+    const ENTRY_ADDRESS_WIDTH: usize = 40;
+    const ENTRY_FLAG_DEFAULT_PAGE: usize = Self::ENTRY_FLAG_PRESENT
+        | 1 << 1 // Page flag
+        | 1 << 10 // Access flag
+        | Self::ENTRY_FLAG_NO_GLOBAL;
+    const ENTRY_FLAG_DEFAULT_TABLE: usize
+        = Self::ENTRY_FLAG_PRESENT
+        | Self::ENTRY_FLAG_READWRITE
+        | 1 << 1 // Table flag
+        | 1 << 10 // Access flag
+        ;
+    const ENTRY_FLAG_PRESENT: usize = 1 << 0;
+    const ENTRY_FLAG_READONLY: usize = 1 << 7;
+    const ENTRY_FLAG_READWRITE: usize = 0;
+    const ENTRY_FLAG_PAGE_USER: usize = 1 << 6;
+    // This sets both userspace and privileged execute never
+    //TODO: Separate the two?
+    const ENTRY_FLAG_NO_EXEC: usize = 0b11 << 53;
+    const ENTRY_FLAG_EXEC: usize = 0;
+    const ENTRY_FLAG_GLOBAL: usize = 0;
+    const ENTRY_FLAG_NO_GLOBAL: usize = 1 << 11;
+    const ENTRY_FLAG_DEVICE_MEMORY: usize = MEM_ATTR_DEVICE_nGnRnE << 2;
+    const ENTRY_FLAG_UNCACHEABLE: usize = MEM_ATTR_NC << 2;
+    const ENTRY_FLAG_WRITE_COMBINING: usize = MEM_ATTR_NC << 2;
+
+    const PHYS_OFFSET: usize = 0xFFFF_8000_0000_0000;
+
+    #[inline(always)]
+    fn invalidate(address: VirtualAddress) {
+        unsafe {
+            asm!("
+            dsb ishst
+            tlbi vaae1is, {}
+            dsb ish
+            isb
+        ", in(reg) (address.data() >> Self::PAGE_SHIFT));
+        }
+    }
+
+    #[inline(always)]
+    fn invalidate_all() {
+        unsafe {
+            asm!(
+                "
+            dsb ishst
+            tlbi vmalle1is
+            dsb ish
+            isb
+        "
+            );
+        }
+    }
+
+    #[inline(always)]
+    fn table(table_kind: TableKind) -> PhysicalAddress {
+        let address: usize;
+        match table_kind {
+            TableKind::User => {
+                unsafe { asm!("mrs {0}, ttbr0_el1", out(reg) address) };
+            }
+            TableKind::Kernel => {
+                unsafe { asm!("mrs {0}, ttbr1_el1", out(reg) address) };
+            }
+        }
+        PhysicalAddress::new(address)
+    }
+
+    #[inline(always)]
+    unsafe fn set_table(table_kind: TableKind, address: PhysicalAddress) {
+        unsafe {
+            match table_kind {
+                TableKind::User => {
+                    asm!("msr ttbr0_el1, {0}", in(reg) address.data());
+                }
+                TableKind::Kernel => {
+                    asm!("msr ttbr1_el1, {0}", in(reg) address.data());
+                }
+            }
+            Self::invalidate_all();
+        }
+    }
+
+    fn virt_is_valid(_address: VirtualAddress) -> bool {
+        //TODO: what makes an address valid on aarch64?
+        true
+    }
+}
+
+#[cfg_attr(not(target_arch = "aarch64"), allow(unused))]
+const MEM_ATTR_WB: usize = 0;
+const MEM_ATTR_NC: usize = 1;
+#[allow(non_upper_case_globals)]
+const MEM_ATTR_DEVICE_nGnRnE: usize = 2;
+
+/// Setup Memory Access Indirection Register
+#[cfg(target_arch = "aarch64")]
+#[inline(always)]
+pub unsafe fn init_mair() {
+    // https://github.com/freebsd/freebsd-src/blob/d15733065c4221dcd5bb3622d225760f271f6fc9/sys/arm64/include/armreg.h#L1986-L1991
+    const fn mair_attr(attr: u64, idx: usize) -> u64 {
+        attr << (idx * 8)
+    }
+    #[allow(non_upper_case_globals)]
+    const MAIR_DEVICE_nGnRnE: u64 = 0x00;
+    #[allow(non_upper_case_globals)]
+    const _MAIR_DEVICE_nGnRE: u64 = 0x04;
+    const MAIR_NORMAL_NC: u64 = 0x44;
+    const _MAIR_NORMAL_WT: u64 = 0xbb;
+    const MAIR_NORMAL_WB: u64 = 0xff;
+
+    unsafe {
+        let val: u64 = const {
+            mair_attr(MAIR_DEVICE_nGnRnE, MEM_ATTR_DEVICE_nGnRnE)
+                | mair_attr(MAIR_NORMAL_NC, MEM_ATTR_NC)
+                | mair_attr(MAIR_NORMAL_WB, MEM_ATTR_WB)
+        };
+
+        asm!("msr mair_el1, {}", in(reg) val);
+    }
+}
+
+const _: () = {
+    assert!(AArch64Arch::PAGE_SIZE == 4096);
+    assert!(AArch64Arch::PAGE_OFFSET_MASK == 0xFFF);
+    assert!(AArch64Arch::PAGE_ADDRESS_SHIFT == 48);
+    assert!(AArch64Arch::PAGE_ADDRESS_SIZE == 0x0001_0000_0000_0000);
+    assert!(AArch64Arch::PAGE_ADDRESS_MASK == 0x0000_FFFF_FFFF_F000);
+    assert!(AArch64Arch::PAGE_ENTRY_SIZE == 8);
+    assert!(AArch64Arch::PAGE_ENTRIES == 512);
+    assert!(AArch64Arch::PAGE_ENTRY_MASK == 0x1FF);
+    assert!(AArch64Arch::PAGE_NEGATIVE_MASK == 0xFFFF_0000_0000_0000);
+
+    assert!(AArch64Arch::ENTRY_ADDRESS_SIZE == 0x0000_0100_0000_0000);
+    assert!(AArch64Arch::ENTRY_ADDRESS_MASK == 0x0000_00FF_FFFF_FFFF);
+    assert!(AArch64Arch::ENTRY_FLAGS_MASK == 0xFFF0_0000_0000_0FFF);
+
+    assert!(AArch64Arch::PHYS_OFFSET == 0xFFFF_8000_0000_0000);
+};

rmm/src/arch/emulate.rs

@@ -0,0 +1,355 @@
+extern crate std;
+
+use std::{boxed::Box, collections::BTreeMap, marker::PhantomData, mem, ptr, sync::Mutex, vec};
+
+use crate::{
+    arch::x86_64::X8664Arch, page::PageFlags, Arch, MemoryArea, PageEntry, PhysicalAddress,
+    TableKind, VirtualAddress, MEGABYTE,
+};
+
+#[derive(Clone, Copy)]
+pub struct EmulateArch;
+
+impl EmulateArch {
+    pub unsafe fn init() -> &'static [MemoryArea] {
+        unsafe {
+            // Create machine with PAGE_ENTRIES pages offset mapped (2 MiB on x86_64)
+            let mut machine = Machine::new(MEMORY_SIZE);
+
+            // PML4 index 256 (PHYS_OFFSET) link to PDP
+            let pml4 = 0;
+            let pdp = pml4 + Self::PAGE_SIZE;
+            let flags = Self::ENTRY_FLAG_READWRITE | Self::ENTRY_FLAG_PRESENT;
+            machine.write_phys::<usize>(
+                PhysicalAddress::new(pml4 + 256 * Self::PAGE_ENTRY_SIZE),
+                pdp | flags,
+            );
+
+            // PDP link to PD
+            let pd = pdp + Self::PAGE_SIZE;
+            machine.write_phys::<usize>(PhysicalAddress::new(pdp), pd | flags);
+
+            // PD link to PT
+            let pt = pd + Self::PAGE_SIZE;
+            machine.write_phys::<usize>(PhysicalAddress::new(pd), pt | flags);
+
+            // PT links to frames
+            for i in 0..Self::PAGE_ENTRIES {
+                let page = i * Self::PAGE_SIZE;
+                machine.write_phys::<usize>(
+                    PhysicalAddress::new(pt + i * Self::PAGE_ENTRY_SIZE),
+                    page | flags,
+                );
+            }
+
+            *MACHINE.lock().unwrap() = Some(machine);
+
+            // Set table to pml4
+            EmulateArch::set_table(TableKind::Kernel, PhysicalAddress::new(pml4));
+
+            &MEMORY_AREAS
+        }
+    }
+}
+
+impl Arch for EmulateArch {
+    const KERNEL_SEPARATE_TABLE: bool = false;
+
+    const PAGE_SHIFT: usize = X8664Arch::PAGE_SHIFT;
+    const PAGE_ENTRY_SHIFT: usize = X8664Arch::PAGE_ENTRY_SHIFT;
+    const PAGE_LEVELS: usize = X8664Arch::PAGE_LEVELS;
+
+    const ENTRY_ADDRESS_SHIFT: usize = X8664Arch::ENTRY_ADDRESS_SHIFT;
+    const ENTRY_FLAG_DEFAULT_PAGE: usize = X8664Arch::ENTRY_FLAG_DEFAULT_PAGE;
+    const ENTRY_FLAG_DEFAULT_TABLE: usize = X8664Arch::ENTRY_FLAG_DEFAULT_TABLE;
+    const ENTRY_FLAG_PRESENT: usize = X8664Arch::ENTRY_FLAG_PRESENT;
+    const ENTRY_FLAG_READONLY: usize = X8664Arch::ENTRY_FLAG_READONLY;
+    const ENTRY_FLAG_READWRITE: usize = X8664Arch::ENTRY_FLAG_READWRITE;
+    const ENTRY_FLAG_PAGE_USER: usize = X8664Arch::ENTRY_FLAG_PAGE_USER;
+    const ENTRY_FLAG_NO_EXEC: usize = X8664Arch::ENTRY_FLAG_NO_EXEC;
+    const ENTRY_FLAG_EXEC: usize = X8664Arch::ENTRY_FLAG_EXEC;
+
+    const PHYS_OFFSET: usize = X8664Arch::PHYS_OFFSET;
+
+    const ENTRY_FLAG_GLOBAL: usize = X8664Arch::ENTRY_FLAG_GLOBAL;
+    const ENTRY_FLAG_NO_GLOBAL: usize = X8664Arch::ENTRY_FLAG_NO_GLOBAL;
+
+    const ENTRY_ADDRESS_WIDTH: usize = X8664Arch::ENTRY_ADDRESS_WIDTH;
+
+    const ENTRY_FLAG_DEVICE_MEMORY: usize = X8664Arch::ENTRY_FLAG_DEVICE_MEMORY;
+    const ENTRY_FLAG_UNCACHEABLE: usize = X8664Arch::ENTRY_FLAG_UNCACHEABLE;
+    const ENTRY_FLAG_WRITE_COMBINING: usize = X8664Arch::ENTRY_FLAG_WRITE_COMBINING;
+
+    #[inline(always)]
+    unsafe fn read<T>(address: VirtualAddress) -> T {
+        MACHINE.lock().unwrap().as_ref().unwrap().read(address)
+    }
+
+    #[inline(always)]
+    unsafe fn write<T>(address: VirtualAddress, value: T) {
+        MACHINE
+            .lock()
+            .unwrap()
+            .as_mut()
+            .unwrap()
+            .write(address, value)
+    }
+
+    #[inline(always)]
+    unsafe fn write_bytes(address: VirtualAddress, value: u8, count: usize) {
+        MACHINE
+            .lock()
+            .unwrap()
+            .as_mut()
+            .unwrap()
+            .write_bytes(address, value, count)
+    }
+
+    #[inline(always)]
+    fn invalidate(address: VirtualAddress) {
+        MACHINE
+            .lock()
+            .unwrap()
+            .as_mut()
+            .unwrap()
+            .invalidate(address);
+    }
+
+    #[inline(always)]
+    fn invalidate_all() {
+        MACHINE.lock().unwrap().as_mut().unwrap().invalidate_all();
+    }
+
+    #[inline(always)]
+    fn table(_table_kind: TableKind) -> PhysicalAddress {
+        MACHINE.lock().unwrap().as_mut().unwrap().get_table()
+    }
+
+    #[inline(always)]
+    unsafe fn set_table(_table_kind: TableKind, address: PhysicalAddress) {
+        MACHINE.lock().unwrap().as_mut().unwrap().set_table(address);
+    }
+    fn virt_is_valid(_address: VirtualAddress) -> bool {
+        // TODO: Don't see why an emulated arch would have any problems with canonicalness...
+        true
+    }
+}
+
+const MEMORY_SIZE: usize = 64 * MEGABYTE;
+static MEMORY_AREAS: [MemoryArea; 2] = [
+    MemoryArea {
+        base: PhysicalAddress::new(EmulateArch::PAGE_SIZE * 4), // Initial PML4, PDP, PD, and PT wasted
+        size: MEMORY_SIZE / 2 - EmulateArch::PAGE_SIZE * 4,
+    },
+    // Second area for debugging
+    MemoryArea {
+        base: PhysicalAddress::new(MEMORY_SIZE / 2),
+        size: MEMORY_SIZE / 2,
+    },
+];
+
+static MACHINE: Mutex<Option<Machine<EmulateArch>>> = Mutex::new(None);
+
+struct Machine<A> {
+    memory: Box<[u8]>,
+    map: BTreeMap<VirtualAddress, PageEntry<A>>,
+    table_addr: PhysicalAddress,
+    phantom: PhantomData<A>,
+}
+
+impl<A: Arch> Machine<A> {
+    fn new(memory_size: usize) -> Self {
+        Self {
+            memory: vec![0; memory_size].into_boxed_slice(),
+            map: BTreeMap::new(),
+            table_addr: PhysicalAddress::new(0),
+            phantom: PhantomData,
+        }
+    }
+
+    fn read_phys<T>(&self, phys: PhysicalAddress) -> T {
+        let size = mem::size_of::<T>();
+        if phys.add(size).data() <= self.memory.len() {
+            unsafe { ptr::read(self.memory.as_ptr().add(phys.data()) as *const T) }
+        } else {
+            panic!(
+                "read_phys: 0x{:X} size 0x{:X} outside of memory",
+                phys.data(),
+                size
+            );
+        }
+    }
+
+    fn write_phys<T>(&mut self, phys: PhysicalAddress, value: T) {
+        let size = mem::size_of::<T>();
+        if phys.add(size).data() <= self.memory.len() {
+            unsafe {
+                ptr::write(self.memory.as_mut_ptr().add(phys.data()) as *mut T, value);
+            }
+        } else {
+            panic!(
+                "write_phys: 0x{:X} size 0x{:X} outside of memory",
+                phys.data(),
+                size
+            );
+        }
+    }
+
+    fn write_phys_bytes(&mut self, phys: PhysicalAddress, value: u8, count: usize) {
+        if phys.add(count).data() <= self.memory.len() {
+            unsafe {
+                ptr::write_bytes(self.memory.as_mut_ptr().add(phys.data()), value, count);
+            }
+        } else {
+            panic!(
+                "write_phys_bytes: 0x{:X} count 0x{:X} outside of memory",
+                phys.data(),
+                count
+            );
+        }
+    }
+
+    fn translate(&self, virt: VirtualAddress) -> Option<(PhysicalAddress, PageFlags<A>)> {
+        let virt_data = virt.data();
+        let page = virt_data & A::PAGE_ADDRESS_MASK;
+        let offset = virt_data & A::PAGE_OFFSET_MASK;
+        let entry = self.map.get(&VirtualAddress::new(page))?;
+        Some((entry.address().ok()?.add(offset), entry.flags()))
+    }
+
+    fn read<T>(&self, virt: VirtualAddress) -> T {
+        //TODO: allow reading past page boundaries
+        let virt_data = virt.data();
+        let size = mem::size_of::<T>();
+        if (virt_data & A::PAGE_ADDRESS_MASK) != ((virt_data + (size - 1)) & A::PAGE_ADDRESS_MASK) {
+            panic!(
+                "read: 0x{:X} size 0x{:X} passes page boundary",
+                virt_data, size
+            );
+        }
+
+        if let Some((phys, _flags)) = self.translate(virt) {
+            self.read_phys(phys)
+        } else {
+            panic!("read: 0x{:X} size 0x{:X} not present", virt_data, size);
+        }
+    }
+
+    fn write<T>(&mut self, virt: VirtualAddress, value: T) {
+        //TODO: allow writing past page boundaries
+        let virt_data = virt.data();
+        let size = mem::size_of::<T>();
+        if (virt_data & A::PAGE_ADDRESS_MASK) != ((virt_data + (size - 1)) & A::PAGE_ADDRESS_MASK) {
+            panic!(
+                "write: 0x{:X} size 0x{:X} passes page boundary",
+                virt_data, size
+            );
+        }
+
+        if let Some((phys, flags)) = self.translate(virt) {
+            if flags.has_write() {
+                self.write_phys(phys, value);
+            } else {
+                panic!("write: 0x{:X} size 0x{:X} not writable", virt_data, size);
+            }
+        } else {
+            panic!("write: 0x{:X} size 0x{:X} not present", virt_data, size);
+        }
+    }
+
+    fn write_bytes(&mut self, virt: VirtualAddress, value: u8, count: usize) {
+        //TODO: allow writing past page boundaries
+        let virt_data = virt.data();
+        if (virt_data & A::PAGE_ADDRESS_MASK) != ((virt_data + (count - 1)) & A::PAGE_ADDRESS_MASK)
+        {
+            panic!(
+                "write_bytes: 0x{:X} count 0x{:X} passes page boundary",
+                virt_data, count
+            );
+        }
+
+        if let Some((phys, flags)) = self.translate(virt) {
+            if flags.has_write() {
+                self.write_phys_bytes(phys, value, count);
+            } else {
+                panic!(
+                    "write_bytes: 0x{:X} count 0x{:X} not writable",
+                    virt_data, count
+                );
+            }
+        } else {
+            panic!(
+                "write_bytes: 0x{:X} count 0x{:X} not present",
+                virt_data, count
+            );
+        }
+    }
+
+    fn invalidate(&mut self, _address: VirtualAddress) {
+        unimplemented!("EmulateArch::invalidate not implemented");
+    }
+
+    //TODO: cleanup
+    fn invalidate_all(&mut self) {
+        self.map.clear();
+
+        // PML4
+        let a4 = self.table_addr.data();
+        for i4 in 0..A::PAGE_ENTRIES {
+            let e3 = self.read_phys::<usize>(PhysicalAddress::new(a4 + i4 * A::PAGE_ENTRY_SIZE));
+            let f3 = e3 & A::ENTRY_FLAGS_MASK;
+            if f3 & A::ENTRY_FLAG_PRESENT == 0 {
+                continue;
+            }
+
+            // Page directory pointer
+            let a3 = ((e3 >> A::ENTRY_ADDRESS_SHIFT) & A::ENTRY_ADDRESS_MASK) << A::PAGE_SHIFT;
+            for i3 in 0..A::PAGE_ENTRIES {
+                let e2 =
+                    self.read_phys::<usize>(PhysicalAddress::new(a3 + i3 * A::PAGE_ENTRY_SIZE));
+                let f2 = e2 & A::ENTRY_FLAGS_MASK;
+                if f2 & A::ENTRY_FLAG_PRESENT == 0 {
+                    continue;
+                }
+
+                // Page directory
+                let a2 = ((e2 >> A::ENTRY_ADDRESS_SHIFT) & A::ENTRY_ADDRESS_MASK) << A::PAGE_SHIFT;
+                for i2 in 0..A::PAGE_ENTRIES {
+                    let e1 =
+                        self.read_phys::<usize>(PhysicalAddress::new(a2 + i2 * A::PAGE_ENTRY_SIZE));
+                    let f1 = e1 & A::ENTRY_FLAGS_MASK;
+                    if f1 & A::ENTRY_FLAG_PRESENT == 0 {
+                        continue;
+                    }
+
+                    // Page table
+                    let a1 =
+                        ((e1 >> A::ENTRY_ADDRESS_SHIFT) & A::ENTRY_ADDRESS_MASK) << A::PAGE_SHIFT;
+                    for i1 in 0..A::PAGE_ENTRIES {
+                        let e = self
+                            .read_phys::<usize>(PhysicalAddress::new(a1 + i1 * A::PAGE_ENTRY_SIZE));
+                        let f = e & A::ENTRY_FLAGS_MASK;
+                        if f & A::ENTRY_FLAG_PRESENT == 0 {
+                            continue;
+                        }
+
+                        // Page
+                        let page = (i4 << 39) | (i3 << 30) | (i2 << 21) | (i1 << 12);
+                        //println!("map 0x{:X} to 0x{:X}, 0x{:X}", page, a, f);
+                        self.map
+                            .insert(VirtualAddress::new(page), PageEntry::from_data(e));
+                    }
+                }
+            }
+        }
+    }
+
+    fn get_table(&self) -> PhysicalAddress {
+        self.table_addr
+    }
+
+    fn set_table(&mut self, address: PhysicalAddress) {
+        self.table_addr = address;
+        self.invalidate_all();
+    }
+}

rmm/src/arch/mod.rs

@@ -0,0 +1,93 @@
+use core::ptr;
+
+use crate::{PhysicalAddress, TableKind, VirtualAddress};
+
+//TODO: Support having all page tables compile on all architectures
+#[cfg(target_pointer_width = "64")]
+pub mod aarch64;
+#[cfg(all(feature = "std", target_pointer_width = "64"))]
+pub mod emulate;
+#[cfg(target_pointer_width = "64")]
+pub mod riscv64;
+#[cfg(target_pointer_width = "32")]
+pub mod x86;
+#[cfg(target_pointer_width = "64")]
+pub mod x86_64;
+mod x86_shared;
+
+pub trait Arch: Clone + Copy {
+    /// Does the architecture use a separate page table for the kernel.
+    ///
+    /// If false, the page table entries corresponding to the top half of the
+    /// address space will be copied into the top level of every page table
+    /// and will never be unmapped when unmapping pages.
+    const KERNEL_SEPARATE_TABLE: bool;
+
+    const PAGE_SHIFT: usize;
+    const PAGE_ENTRY_SHIFT: usize;
+    const PAGE_LEVELS: usize;
+
+    const ENTRY_ADDRESS_WIDTH: usize; // Number of bits of physical address in PTE
+    const ENTRY_ADDRESS_SHIFT: usize = Self::PAGE_SHIFT; // Offset of physical address in PTE
+    const ENTRY_FLAG_DEFAULT_PAGE: usize;
+    const ENTRY_FLAG_DEFAULT_TABLE: usize;
+    const ENTRY_FLAG_PRESENT: usize;
+    const ENTRY_FLAG_READONLY: usize;
+    const ENTRY_FLAG_READWRITE: usize;
+    const ENTRY_FLAG_PAGE_USER: usize; // Leaf table user page flag
+    const ENTRY_FLAG_TABLE_USER: usize = Self::ENTRY_FLAG_PAGE_USER; // Directory user page table flag
+    const ENTRY_FLAG_NO_EXEC: usize;
+    const ENTRY_FLAG_EXEC: usize;
+    const ENTRY_FLAG_GLOBAL: usize;
+    const ENTRY_FLAG_NO_GLOBAL: usize;
+    const ENTRY_FLAG_DEVICE_MEMORY: usize;
+    const ENTRY_FLAG_UNCACHEABLE: usize;
+    const ENTRY_FLAG_WRITE_COMBINING: usize;
+
+    const PHYS_OFFSET: usize;
+
+    const PAGE_SIZE: usize = 1 << Self::PAGE_SHIFT;
+    const PAGE_OFFSET_MASK: usize = Self::PAGE_SIZE - 1;
+    const PAGE_ADDRESS_SHIFT: usize = Self::PAGE_LEVELS * Self::PAGE_ENTRY_SHIFT + Self::PAGE_SHIFT;
+    const PAGE_ADDRESS_SIZE: u64 = 1 << (Self::PAGE_ADDRESS_SHIFT as u64);
+    const PAGE_ADDRESS_MASK: usize = (Self::PAGE_ADDRESS_SIZE - (Self::PAGE_SIZE as u64)) as usize;
+    const PAGE_ENTRY_SIZE: usize = 1 << (Self::PAGE_SHIFT - Self::PAGE_ENTRY_SHIFT);
+    const PAGE_ENTRIES: usize = 1 << Self::PAGE_ENTRY_SHIFT;
+    const PAGE_ENTRY_MASK: usize = Self::PAGE_ENTRIES - 1;
+    const PAGE_NEGATIVE_MASK: usize = !(Self::PAGE_ADDRESS_SIZE - 1) as usize;
+
+    const ENTRY_ADDRESS_SIZE: usize = 1 << Self::ENTRY_ADDRESS_WIDTH; // size of addressable physical memory, in pages
+    const ENTRY_ADDRESS_MASK: usize = Self::ENTRY_ADDRESS_SIZE - 1; // Mask of physical address, starting at 0th bit
+    const ENTRY_FLAGS_MASK: usize = !(Self::ENTRY_ADDRESS_MASK << Self::ENTRY_ADDRESS_SHIFT);
+
+    #[inline(always)]
+    unsafe fn read<T>(address: VirtualAddress) -> T {
+        unsafe { ptr::read(address.data() as *const T) }
+    }
+
+    #[inline(always)]
+    unsafe fn write<T>(address: VirtualAddress, value: T) {
+        unsafe { ptr::write(address.data() as *mut T, value) }
+    }
+
+    #[inline(always)]
+    unsafe fn write_bytes(address: VirtualAddress, value: u8, count: usize) {
+        unsafe { ptr::write_bytes(address.data() as *mut u8, value, count) }
+    }
+
+    fn invalidate(address: VirtualAddress);
+    fn invalidate_all();
+
+    fn table(table_kind: TableKind) -> PhysicalAddress;
+    unsafe fn set_table(table_kind: TableKind, address: PhysicalAddress);
+
+    #[inline(always)]
+    fn phys_to_virt(phys: PhysicalAddress) -> VirtualAddress {
+        match phys.data().checked_add(Self::PHYS_OFFSET) {
+            Some(some) => VirtualAddress::new(some),
+            None => panic!("phys_to_virt({:#x}) overflow", phys.data()),
+        }
+    }
+
+    fn virt_is_valid(address: VirtualAddress) -> bool;
+}

rmm/src/arch/riscv64/mod.rs

@@ -0,0 +1,7 @@
+pub use sv39::RiscV64Sv39Arch;
+pub use sv48::RiscV64Sv48Arch;
+pub use sv57::RiscV64Sv57Arch;
+
+mod sv39;
+mod sv48;
+mod sv57;

rmm/src/arch/riscv64/sv39.rs

@@ -0,0 +1,124 @@
+use core::arch::asm;
+
+use crate::{Arch, PhysicalAddress, TableKind, VirtualAddress};
+
+#[derive(Clone, Copy)]
+pub struct RiscV64Sv39Arch;
+
+pub const ACCESSED: usize = 1 << 6;
+pub const DIRTY: usize = 1 << 7;
+
+impl Arch for RiscV64Sv39Arch {
+    const KERNEL_SEPARATE_TABLE: bool = false;
+
+    const PAGE_SHIFT: usize = 12; // 4096 bytes
+    const PAGE_ENTRY_SHIFT: usize = 9; // 512 entries, 8 bytes each
+    const PAGE_LEVELS: usize = 3; // L0, L1, L2
+
+    const ENTRY_ADDRESS_WIDTH: usize = 44;
+    const ENTRY_ADDRESS_SHIFT: usize = 10;
+
+    const ENTRY_FLAG_DEFAULT_PAGE: usize =
+        Self::ENTRY_FLAG_PRESENT | Self::ENTRY_FLAG_READONLY | ACCESSED | DIRTY;
+    const ENTRY_FLAG_DEFAULT_TABLE: usize = Self::ENTRY_FLAG_PRESENT;
+    const ENTRY_FLAG_PRESENT: usize = 1 << 0;
+    const ENTRY_FLAG_READONLY: usize = 1 << 1;
+    const ENTRY_FLAG_READWRITE: usize = 3 << 1;
+    const ENTRY_FLAG_PAGE_USER: usize = 1 << 4;
+    const ENTRY_FLAG_TABLE_USER: usize = 0;
+    const ENTRY_FLAG_NO_EXEC: usize = 0;
+    const ENTRY_FLAG_EXEC: usize = 1 << 3;
+    const ENTRY_FLAG_GLOBAL: usize = 1 << 5;
+    const ENTRY_FLAG_NO_GLOBAL: usize = 0;
+    const ENTRY_FLAG_DEVICE_MEMORY: usize = 0; // FIXME use Svpbmt
+    const ENTRY_FLAG_UNCACHEABLE: usize = 0; // FIXME use Svpbmt
+    const ENTRY_FLAG_WRITE_COMBINING: usize = 0; // FIXME use Svpbmt
+
+    const PHYS_OFFSET: usize = 0xFFFF_FFC0_0000_0000;
+
+    #[inline(always)]
+    fn invalidate(address: VirtualAddress) {
+        unsafe { asm!("sfence.vma {}", in(reg) address.data()) };
+    }
+
+    #[inline(always)]
+    fn invalidate_all() {
+        unsafe { asm!("sfence.vma") };
+    }
+
+    #[inline(always)]
+    fn table(_table_kind: TableKind) -> PhysicalAddress {
+        let satp: usize;
+        unsafe { asm!("csrr {0}, satp", out(reg) satp) };
+        PhysicalAddress::new(
+            (satp & Self::ENTRY_ADDRESS_MASK) << Self::PAGE_SHIFT, // Convert from PPN
+        )
+    }
+
+    #[inline(always)]
+    unsafe fn set_table(_table_kind: TableKind, address: PhysicalAddress) {
+        let satp = (8 << 60) | // Sv39 MODE
+            (address.data() >> Self::PAGE_SHIFT); // Convert to PPN (TODO: ensure alignment)
+        unsafe {
+            asm!("csrw satp, {0}", in(reg) satp);
+            Self::invalidate_all();
+        }
+    }
+
+    fn virt_is_valid(address: VirtualAddress) -> bool {
+        let mask = !((Self::PAGE_ADDRESS_SIZE as usize - 1) >> 1);
+        let masked = address.data() & mask;
+
+        masked == mask || masked == 0
+    }
+}
+
+const _: () = {
+    assert!(RiscV64Sv39Arch::PAGE_SIZE == 4096);
+    assert!(RiscV64Sv39Arch::PAGE_OFFSET_MASK == 0xFFF);
+    assert!(RiscV64Sv39Arch::PAGE_ADDRESS_SHIFT == 39);
+    assert!(RiscV64Sv39Arch::PAGE_ADDRESS_SIZE == 0x0000_0080_0000_0000);
+    assert!(RiscV64Sv39Arch::PAGE_ADDRESS_MASK == 0x0000_007F_FFFF_F000);
+    assert!(RiscV64Sv39Arch::PAGE_ENTRY_SIZE == 8);
+    assert!(RiscV64Sv39Arch::PAGE_ENTRIES == 512);
+    assert!(RiscV64Sv39Arch::PAGE_ENTRY_MASK == 0x1FF);
+    assert!(RiscV64Sv39Arch::PAGE_NEGATIVE_MASK == 0xFFFF_FF80_0000_0000);
+
+    assert!(RiscV64Sv39Arch::ENTRY_ADDRESS_SIZE == 0x0000_1000_0000_0000);
+    assert!(RiscV64Sv39Arch::ENTRY_ADDRESS_MASK == 0x0000_0FFF_FFFF_FFFF);
+    assert!(RiscV64Sv39Arch::ENTRY_FLAGS_MASK == 0xFFC0_0000_0000_03FF);
+
+    assert!(RiscV64Sv39Arch::PHYS_OFFSET == 0xFFFF_FFC0_0000_0000);
+};
+
+#[cfg(test)]
+mod tests {
+    use super::RiscV64Sv39Arch;
+    use crate::Arch;
+
+    #[test]
+    fn is_canonical() {
+        use super::VirtualAddress;
+
+        #[track_caller]
+        fn yes(addr: usize) {
+            assert!(RiscV64Sv39Arch::virt_is_valid(VirtualAddress::new(addr)));
+        }
+        #[track_caller]
+        fn no(addr: usize) {
+            assert!(!RiscV64Sv39Arch::virt_is_valid(VirtualAddress::new(addr)));
+        }
+
+        yes(0xFFFF_FFFF_FFFF_FFFF);
+        yes(0xFFFF_FFF0_1337_1337);
+        no(0x0000_0F00_0000_0000);
+        no(0x1337_0000_0000_0000);
+        no(1 << 38);
+        yes(1 << 37);
+
+        // Check for off-by-one errors.
+        yes(0xFFFF_FFC0_0000_0000 | (1 << 37));
+        yes(0xFFFF_FFE0_0000_0000 | (1 << 37));
+        no(0xFFFF_FF80_0000_0000 | (1 << 37));
+    }
+}

rmm/src/arch/riscv64/sv48.rs

@@ -0,0 +1,118 @@
+use core::arch::asm;
+
+use crate::{Arch, PhysicalAddress, TableKind, VirtualAddress};
+
+#[derive(Clone, Copy)]
+pub struct RiscV64Sv48Arch;
+
+impl Arch for RiscV64Sv48Arch {
+    const KERNEL_SEPARATE_TABLE: bool = false;
+
+    const PAGE_SHIFT: usize = 12; // 4096 bytes
+    const PAGE_ENTRY_SHIFT: usize = 9; // 512 entries, 8 bytes each
+    const PAGE_LEVELS: usize = 4; // L0, L1, L2, L3
+
+    const ENTRY_ADDRESS_WIDTH: usize = 44;
+    const ENTRY_ADDRESS_SHIFT: usize = 10;
+
+    const ENTRY_FLAG_DEFAULT_PAGE: usize = Self::ENTRY_FLAG_PRESENT | Self::ENTRY_FLAG_READONLY;
+    const ENTRY_FLAG_DEFAULT_TABLE: usize = Self::ENTRY_FLAG_PRESENT;
+    const ENTRY_FLAG_PRESENT: usize = 1 << 0;
+    const ENTRY_FLAG_READONLY: usize = 1 << 1;
+    const ENTRY_FLAG_READWRITE: usize = 3 << 1;
+    const ENTRY_FLAG_PAGE_USER: usize = 1 << 4;
+    const ENTRY_FLAG_TABLE_USER: usize = 0;
+    const ENTRY_FLAG_NO_EXEC: usize = 0;
+    const ENTRY_FLAG_EXEC: usize = 1 << 3;
+    const ENTRY_FLAG_GLOBAL: usize = 1 << 5;
+    const ENTRY_FLAG_NO_GLOBAL: usize = 0;
+    const ENTRY_FLAG_DEVICE_MEMORY: usize = 0; // FIXME use Svpbmt
+    const ENTRY_FLAG_UNCACHEABLE: usize = 0; // FIXME use Svpbmt
+    const ENTRY_FLAG_WRITE_COMBINING: usize = 0; // FIXME use Svpbmt
+
+    const PHYS_OFFSET: usize = 0xFFFF_8000_0000_0000;
+
+    #[inline(always)]
+    fn invalidate(address: VirtualAddress) {
+        unsafe { asm!("sfence.vma {}", in(reg) address.data()) };
+    }
+
+    #[inline(always)]
+    fn invalidate_all() {
+        unsafe { asm!("sfence.vma") };
+    }
+
+    #[inline(always)]
+    fn table(_table_kind: TableKind) -> PhysicalAddress {
+        let satp: usize;
+        unsafe { asm!("csrr {0}, satp", out(reg) satp) };
+        PhysicalAddress::new(
+            (satp & Self::ENTRY_ADDRESS_MASK) << Self::PAGE_SHIFT, // Convert from PPN
+        )
+    }
+
+    #[inline(always)]
+    unsafe fn set_table(_table_kind: TableKind, address: PhysicalAddress) {
+        let satp = (9 << 60) | // Sv48 MODE
+            (address.data() >> Self::PAGE_SHIFT); // Convert to PPN (TODO: ensure alignment)
+        unsafe {
+            asm!("csrw satp, {0}", in(reg) satp);
+            Self::invalidate_all();
+        }
+    }
+
+    fn virt_is_valid(address: VirtualAddress) -> bool {
+        // RISC-V SV48 uses 48-bit sign-extended addresses, identical to 4-level paging on x86_64.
+        let mask = !((Self::PAGE_ADDRESS_SIZE as usize - 1) >> 1);
+        let masked = address.data() & mask;
+
+        masked == mask || masked == 0
+    }
+}
+
+const _: () = {
+    assert!(RiscV64Sv48Arch::PAGE_SIZE == 4096);
+    assert!(RiscV64Sv48Arch::PAGE_OFFSET_MASK == 0xFFF);
+    assert!(RiscV64Sv48Arch::PAGE_ADDRESS_SHIFT == 48);
+    assert!(RiscV64Sv48Arch::PAGE_ADDRESS_SIZE == 0x0001_0000_0000_0000);
+    assert!(RiscV64Sv48Arch::PAGE_ADDRESS_MASK == 0x0000_FFFF_FFFF_F000);
+    assert!(RiscV64Sv48Arch::PAGE_ENTRY_SIZE == 8);
+    assert!(RiscV64Sv48Arch::PAGE_ENTRIES == 512);
+    assert!(RiscV64Sv48Arch::PAGE_ENTRY_MASK == 0x1FF);
+    assert!(RiscV64Sv48Arch::PAGE_NEGATIVE_MASK == 0xFFFF_0000_0000_0000);
+
+    assert!(RiscV64Sv48Arch::ENTRY_ADDRESS_SIZE == 0x0000_1000_0000_0000);
+    assert!(RiscV64Sv48Arch::ENTRY_ADDRESS_MASK == 0x0000_0FFF_FFFF_FFFF);
+    assert!(RiscV64Sv48Arch::ENTRY_FLAGS_MASK == 0xFFC0_0000_0000_03FF);
+
+    assert!(RiscV64Sv48Arch::PHYS_OFFSET == 0xFFFF_8000_0000_0000);
+};
+
+#[cfg(test)]
+mod tests {
+    use super::RiscV64Sv48Arch;
+    use crate::Arch;
+
+    #[test]
+    fn is_canonical() {
+        use super::VirtualAddress;
+
+        // Close to identical when compared to x86_64 test.
+        fn yes(address: usize) {
+            assert!(RiscV64Sv48Arch::virt_is_valid(VirtualAddress::new(address)));
+        }
+        fn no(address: usize) {
+            assert!(!RiscV64Sv48Arch::virt_is_valid(VirtualAddress::new(
+                address
+            )));
+        }
+
+        yes(0xFFFF_8000_1337_1337);
+        yes(0xFFFF_FFFF_FFFF_FFFF);
+        yes(0x0000_0000_0000_0042);
+        yes(0x0000_7FFF_FFFF_FFFF);
+        no(0x1337_0000_0000_0000);
+        no(0x1337_8000_0000_0000);
+        no(0x0000_8000_0000_0000);
+    }
+}

rmm/src/arch/riscv64/sv57.rs

@@ -0,0 +1,116 @@
+use core::arch::asm;
+
+use crate::{Arch, PhysicalAddress, TableKind, VirtualAddress};
+
+#[derive(Clone, Copy)]
+pub struct RiscV64Sv57Arch;
+
+impl Arch for RiscV64Sv57Arch {
+    const KERNEL_SEPARATE_TABLE: bool = false;
+
+    const PAGE_SHIFT: usize = 12; // 4096 bytes
+    const PAGE_ENTRY_SHIFT: usize = 9; // 512 entries, 8 bytes each
+    const PAGE_LEVELS: usize = 5; // L0, L1, L2, L3, L4
+
+    const ENTRY_ADDRESS_WIDTH: usize = 44;
+    const ENTRY_ADDRESS_SHIFT: usize = 10;
+
+    const ENTRY_FLAG_DEFAULT_PAGE: usize = Self::ENTRY_FLAG_PRESENT | Self::ENTRY_FLAG_READONLY;
+    const ENTRY_FLAG_DEFAULT_TABLE: usize = Self::ENTRY_FLAG_PRESENT;
+    const ENTRY_FLAG_PRESENT: usize = 1 << 0;
+    const ENTRY_FLAG_READONLY: usize = 1 << 1;
+    const ENTRY_FLAG_READWRITE: usize = 3 << 1;
+    const ENTRY_FLAG_PAGE_USER: usize = 1 << 4;
+    const ENTRY_FLAG_TABLE_USER: usize = 0;
+    const ENTRY_FLAG_NO_EXEC: usize = 0;
+    const ENTRY_FLAG_EXEC: usize = 1 << 3;
+    const ENTRY_FLAG_GLOBAL: usize = 1 << 5;
+    const ENTRY_FLAG_NO_GLOBAL: usize = 0;
+    const ENTRY_FLAG_DEVICE_MEMORY: usize = 0; // FIXME use Svpbmt
+    const ENTRY_FLAG_UNCACHEABLE: usize = 0; // FIXME use Svpbmt
+    const ENTRY_FLAG_WRITE_COMBINING: usize = 0; // FIXME use Svpbmt
+
+    const PHYS_OFFSET: usize = 0xFF00_0000_0000_0000;
+
+    #[inline(always)]
+    fn invalidate(address: VirtualAddress) {
+        unsafe { asm!("sfence.vma {}", in(reg) address.data()) };
+    }
+
+    #[inline(always)]
+    fn invalidate_all() {
+        unsafe { asm!("sfence.vma") };
+    }
+
+    #[inline(always)]
+    fn table(_table_kind: TableKind) -> PhysicalAddress {
+        let satp: usize;
+        unsafe { asm!("csrr {0}, satp", out(reg) satp) };
+        PhysicalAddress::new(
+            (satp & Self::ENTRY_ADDRESS_MASK) << Self::PAGE_SHIFT, // Convert from PPN
+        )
+    }
+
+    #[inline(always)]
+    unsafe fn set_table(_table_kind: TableKind, address: PhysicalAddress) {
+        let satp = (10 << 60) | // Sv57 MODE
+            (address.data() >> Self::PAGE_SHIFT); // Convert to PPN (TODO: ensure alignment)
+        unsafe {
+            asm!("csrw satp, {0}", in(reg) satp);
+            Self::invalidate_all();
+        }
+    }
+
+    fn virt_is_valid(address: VirtualAddress) -> bool {
+        let mask = !((Self::PAGE_ADDRESS_SIZE as usize - 1) >> 1);
+        let masked = address.data() & mask;
+
+        masked == mask || masked == 0
+    }
+}
+
+const _: () = {
+    assert!(RiscV64Sv57Arch::PAGE_SIZE == 4096);
+    assert!(RiscV64Sv57Arch::PAGE_OFFSET_MASK == 0xFFF);
+    assert!(RiscV64Sv57Arch::PAGE_ADDRESS_SHIFT == 57);
+    assert!(RiscV64Sv57Arch::PAGE_ADDRESS_SIZE == 0x0200_0000_0000_0000);
+    assert!(RiscV64Sv57Arch::PAGE_ADDRESS_MASK == 0x01FF_FFFF_FFFF_F000);
+    assert!(RiscV64Sv57Arch::PAGE_ENTRY_SIZE == 8);
+    assert!(RiscV64Sv57Arch::PAGE_ENTRIES == 512);
+    assert!(RiscV64Sv57Arch::PAGE_ENTRY_MASK == 0x1FF);
+    assert!(RiscV64Sv57Arch::PAGE_NEGATIVE_MASK == 0xFE00_0000_0000_0000);
+
+    assert!(RiscV64Sv57Arch::ENTRY_ADDRESS_SIZE == 0x0000_1000_0000_0000);
+    assert!(RiscV64Sv57Arch::ENTRY_ADDRESS_MASK == 0x0000_0FFF_FFFF_FFFF);
+    assert!(RiscV64Sv57Arch::ENTRY_FLAGS_MASK == 0xFFC0_0000_0000_03FF);
+
+    assert!(RiscV64Sv57Arch::PHYS_OFFSET == 0xFF00_0000_0000_0000);
+};
+
+#[cfg(test)]
+mod tests {
+    use super::RiscV64Sv57Arch;
+    use crate::Arch;
+
+    #[test]
+    fn is_canonical() {
+        use super::VirtualAddress;
+
+        fn yes(address: usize) {
+            assert!(RiscV64Sv57Arch::virt_is_valid(VirtualAddress::new(address)));
+        }
+        fn no(address: usize) {
+            assert!(!RiscV64Sv57Arch::virt_is_valid(VirtualAddress::new(
+                address
+            )));
+        }
+
+        yes(0xFF00_0000_1337_1337);
+        yes(0xFFFF_FFFF_FFFF_FFFF);
+        yes(0x0000_0000_0000_0042);
+        yes(0x00FF_FFFF_FFFF_FFFF);
+        no(0x1337_0000_0000_0000);
+        no(0x1337_8000_0000_0000);
+        no(0x0F00_0000_0000_0000);
+    }
+}

rmm/src/arch/x86.rs

@@ -0,0 +1,80 @@
+//TODO: USE PAE
+use core::arch::asm;
+
+use crate::{Arch, PhysicalAddress, TableKind, VirtualAddress};
+
+#[derive(Clone, Copy)]
+pub struct X86Arch;
+
+impl Arch for X86Arch {
+    const KERNEL_SEPARATE_TABLE: bool = false;
+
+    const PAGE_SHIFT: usize = 12; // 4096 bytes
+    const PAGE_ENTRY_SHIFT: usize = 10; // 1024 entries, 4 bytes each
+    const PAGE_LEVELS: usize = 2; // PD, PT
+
+    const ENTRY_ADDRESS_WIDTH: usize = 20;
+    const ENTRY_FLAG_DEFAULT_PAGE: usize = Self::ENTRY_FLAG_PRESENT;
+    const ENTRY_FLAG_DEFAULT_TABLE: usize = Self::ENTRY_FLAG_PRESENT | Self::ENTRY_FLAG_READWRITE;
+    const ENTRY_FLAG_PRESENT: usize = 1 << 0;
+    const ENTRY_FLAG_READONLY: usize = 0;
+    const ENTRY_FLAG_READWRITE: usize = 1 << 1;
+    const ENTRY_FLAG_PAGE_USER: usize = 1 << 2;
+    // Not used: const ENTRY_FLAG_HUGE: usize = 1 << 7;
+    const ENTRY_FLAG_GLOBAL: usize = 1 << 8;
+    const ENTRY_FLAG_NO_GLOBAL: usize = 0;
+    const ENTRY_FLAG_NO_EXEC: usize = 0; // NOT AVAILABLE UNLESS PAE IS USED!
+    const ENTRY_FLAG_EXEC: usize = 0;
+    const ENTRY_FLAG_DEVICE_MEMORY: usize = PAT_UC_;
+    const ENTRY_FLAG_UNCACHEABLE: usize = PAT_UC_;
+    const ENTRY_FLAG_WRITE_COMBINING: usize = PAT_WC;
+
+    const PHYS_OFFSET: usize = 0x8000_0000;
+
+    #[inline(always)]
+    fn invalidate(address: VirtualAddress) {
+        unsafe { asm!("invlpg [{0}]", in(reg) address.data()) };
+    }
+
+    #[inline(always)]
+    fn invalidate_all() {
+        unsafe { Self::set_table(TableKind::User, Self::table(TableKind::User)) };
+    }
+
+    #[inline(always)]
+    fn table(_table_kind: TableKind) -> PhysicalAddress {
+        let address: usize;
+        unsafe { asm!("mov {0}, cr3", out(reg) address) };
+        PhysicalAddress::new(address)
+    }
+
+    #[inline(always)]
+    unsafe fn set_table(_table_kind: TableKind, address: PhysicalAddress) {
+        unsafe { asm!("mov cr3, {0}", in(reg) address.data()) };
+    }
+
+    fn virt_is_valid(_address: VirtualAddress) -> bool {
+        // On 32-bit x86, every virtual address is valid
+        true
+    }
+}
+
+pub use super::x86_shared::*;
+
+const _: () = {
+    assert!(X86Arch::PAGE_SIZE == 4096);
+    assert!(X86Arch::PAGE_OFFSET_MASK == 0xFFF);
+    assert!(X86Arch::PAGE_ADDRESS_SHIFT == 32);
+    assert!(X86Arch::PAGE_ADDRESS_SIZE == 0x0000_0001_0000_0000);
+    assert!(X86Arch::PAGE_ADDRESS_MASK == 0xFFFF_F000);
+    assert!(X86Arch::PAGE_ENTRY_SIZE == 4);
+    assert!(X86Arch::PAGE_ENTRIES == 1024);
+    assert!(X86Arch::PAGE_ENTRY_MASK == 0x3FF);
+    assert!(X86Arch::PAGE_NEGATIVE_MASK == 0x0000_0000_0000);
+
+    assert!(X86Arch::ENTRY_ADDRESS_SIZE == 0x0000_0000_0010_0000);
+    assert!(X86Arch::ENTRY_ADDRESS_MASK == 0x000F_FFFF);
+    assert!(X86Arch::ENTRY_FLAGS_MASK == 0x0000_0FFF);
+
+    assert!(X86Arch::PHYS_OFFSET == 0x8000_0000);
+};

rmm/src/arch/x86_64.rs

@@ -0,0 +1,107 @@
+use core::arch::asm;
+
+use crate::{Arch, PhysicalAddress, TableKind, VirtualAddress};
+
+#[derive(Clone, Copy, Debug)]
+pub struct X8664Arch;
+
+impl Arch for X8664Arch {
+    const KERNEL_SEPARATE_TABLE: bool = false;
+
+    const PAGE_SHIFT: usize = 12; // 4096 bytes
+    const PAGE_ENTRY_SHIFT: usize = 9; // 512 entries, 8 bytes each
+    const PAGE_LEVELS: usize = 4; // PML4, PDP, PD, PT
+
+    const ENTRY_ADDRESS_WIDTH: usize = 40;
+    const ENTRY_FLAG_DEFAULT_PAGE: usize = Self::ENTRY_FLAG_PRESENT;
+    const ENTRY_FLAG_DEFAULT_TABLE: usize = Self::ENTRY_FLAG_PRESENT | Self::ENTRY_FLAG_READWRITE;
+    const ENTRY_FLAG_PRESENT: usize = 1 << 0;
+    const ENTRY_FLAG_READONLY: usize = 0;
+    const ENTRY_FLAG_READWRITE: usize = 1 << 1;
+    const ENTRY_FLAG_PAGE_USER: usize = 1 << 2;
+    // Not used: const ENTRY_FLAG_HUGE: usize = 1 << 7;
+    const ENTRY_FLAG_GLOBAL: usize = 1 << 8;
+    const ENTRY_FLAG_NO_GLOBAL: usize = 0;
+    const ENTRY_FLAG_NO_EXEC: usize = 1 << 63;
+    const ENTRY_FLAG_EXEC: usize = 0;
+    const ENTRY_FLAG_DEVICE_MEMORY: usize = PAT_UC_;
+    const ENTRY_FLAG_UNCACHEABLE: usize = PAT_UC_;
+    const ENTRY_FLAG_WRITE_COMBINING: usize = PAT_WC;
+
+    const PHYS_OFFSET: usize = Self::PAGE_NEGATIVE_MASK + (Self::PAGE_ADDRESS_SIZE >> 1) as usize; // PML4 slot 256 and onwards
+
+    #[inline(always)]
+    fn invalidate(address: VirtualAddress) {
+        unsafe { asm!("invlpg [{0}]", in(reg) address.data()) };
+    }
+
+    #[inline(always)]
+    fn invalidate_all() {
+        unsafe { Self::set_table(TableKind::User, Self::table(TableKind::User)) };
+    }
+
+    #[inline(always)]
+    fn table(_table_kind: TableKind) -> PhysicalAddress {
+        let address: usize;
+        unsafe { asm!("mov {0}, cr3", out(reg) address) };
+        PhysicalAddress::new(address)
+    }
+
+    #[inline(always)]
+    unsafe fn set_table(_table_kind: TableKind, address: PhysicalAddress) {
+        unsafe { asm!("mov cr3, {0}", in(reg) address.data()) };
+    }
+
+    fn virt_is_valid(address: VirtualAddress) -> bool {
+        // On x86_64, an address is valid if and only if it is canonical. It may still point to
+        // unmapped memory, but will always be valid once translated via the page table has
+        // suceeded.
+        let masked = address.data() & 0xFFFF_8000_0000_0000;
+        // TODO: 5-level paging
+        masked == 0xFFFF_8000_0000_0000 || masked == 0
+    }
+}
+
+pub use super::x86_shared::*;
+
+const _: () = {
+    assert!(X8664Arch::PAGE_SIZE == 4096);
+    assert!(X8664Arch::PAGE_OFFSET_MASK == 0xFFF);
+    assert!(X8664Arch::PAGE_ADDRESS_SHIFT == 48);
+    assert!(X8664Arch::PAGE_ADDRESS_SIZE == 0x0001_0000_0000_0000);
+    assert!(X8664Arch::PAGE_ADDRESS_MASK == 0x0000_FFFF_FFFF_F000);
+    assert!(X8664Arch::PAGE_ENTRY_SIZE == 8);
+    assert!(X8664Arch::PAGE_ENTRIES == 512);
+    assert!(X8664Arch::PAGE_ENTRY_MASK == 0x1FF);
+    assert!(X8664Arch::PAGE_NEGATIVE_MASK == 0xFFFF_0000_0000_0000);
+
+    assert!(X8664Arch::ENTRY_ADDRESS_SIZE == 0x0000_0100_0000_0000);
+    assert!(X8664Arch::ENTRY_ADDRESS_MASK == 0x0000_00FF_FFFF_FFFF);
+    assert!(X8664Arch::ENTRY_FLAGS_MASK == 0xFFF0_0000_0000_0FFF);
+
+    assert!(X8664Arch::PHYS_OFFSET == 0xFFFF_8000_0000_0000);
+};
+
+#[cfg(test)]
+mod tests {
+    use super::{VirtualAddress, X8664Arch};
+    use crate::Arch;
+
+    #[test]
+    fn is_canonical() {
+        fn yes(address: usize) {
+            assert!(X8664Arch::virt_is_valid(VirtualAddress::new(address)));
+        }
+        fn no(address: usize) {
+            assert!(!X8664Arch::virt_is_valid(VirtualAddress::new(address)));
+        }
+
+        yes(0xFFFF_8000_1337_1337);
+        yes(0xFFFF_FFFF_FFFF_FFFF);
+        yes(0x0000_0000_0000_0042);
+        yes(0x0000_7FFF_FFFF_FFFF);
+        no(0x1337_0000_0000_0000);
+        no(0x1337_8000_0000_0000);
+        no(0x0000_8000_0000_0000);
+    }
+}

rmm/src/arch/x86_shared.rs

@@ -0,0 +1,37 @@
+#![expect(clippy::identity_op)]
+
+// Page attribute table is indexed by PAT(7) PCD(4) PWT(3)
+pub(crate) const _PAT_WB: usize = (0b0 << 7) + (0b00 << 3);
+pub(crate) const _PAT_WT: usize = (0b0 << 7) + (0b01 << 3);
+pub(crate) const PAT_UC_: usize = (0b0 << 7) + (0b10 << 3); // UC-
+pub(crate) const _PAT_UC: usize = (0b0 << 7) + (0b11 << 3); // UC
+pub(crate) const PAT_WC: usize = (0b1 << 7) + (0b00 << 3);
+
+/// Setup page attribute table
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+#[inline(always)]
+pub unsafe fn init_pat() {
+    unsafe {
+        let uncacheable = 0; // UC
+        let write_combining = 1; // WC
+        let write_through = 4; // WT
+        let _write_protected = 5; // WP
+        let write_back = 6; // WB
+        let uncached = 7; // UC- (overridable by WC MTRR)
+
+        let pat0 = write_back;
+        let pat1 = write_through;
+        let pat2 = uncached;
+        let pat3 = uncacheable;
+
+        let pat4 = write_combining;
+        let pat5 = pat1;
+        let pat6 = pat2;
+        let pat7 = pat3;
+
+        let msr = 631; // IA32_PAT
+        let low = u32::from_be_bytes([pat3, pat2, pat1, pat0]);
+        let high = u32::from_be_bytes([pat7, pat6, pat5, pat4]);
+        core::arch::asm!("wrmsr", in("ecx") msr, in("eax") low, in("edx") high);
+    }
+}

rmm/src/lib.rs

@@ -0,0 +1,97 @@
+#![no_std]
+#![allow(clippy::new_without_default)]
+
+pub use crate::{allocator::*, arch::*, page::*};
+
+mod allocator;
+mod arch;
+mod page;
+
+pub const KILOBYTE: usize = 1024;
+pub const MEGABYTE: usize = KILOBYTE * 1024;
+pub const GIGABYTE: usize = MEGABYTE * 1024;
+#[cfg(target_pointer_width = "64")]
+pub const TERABYTE: usize = GIGABYTE * 1024;
+
+/// Specific table to be used, needed on some architectures
+//TODO: Use this throughout the code
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub enum TableKind {
+    /// Userspace page table
+    User,
+    /// Kernel page table
+    Kernel,
+}
+
+/// Physical memory address
+#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(transparent)]
+pub struct PhysicalAddress(usize);
+
+impl PhysicalAddress {
+    #[inline(always)]
+    pub const fn new(address: usize) -> Self {
+        Self(address)
+    }
+
+    #[inline(always)]
+    pub fn data(&self) -> usize {
+        self.0
+    }
+
+    #[expect(clippy::should_implement_trait)]
+    #[inline(always)]
+    pub fn add(self, offset: usize) -> Self {
+        Self(self.0 + offset)
+    }
+}
+
+impl core::fmt::Debug for PhysicalAddress {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "[phys {:#0x}]", self.data())
+    }
+}
+
+/// Virtual memory address
+#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[repr(transparent)]
+pub struct VirtualAddress(usize);
+
+impl VirtualAddress {
+    #[inline(always)]
+    pub const fn new(address: usize) -> Self {
+        Self(address)
+    }
+
+    #[inline(always)]
+    pub fn data(&self) -> usize {
+        self.0
+    }
+
+    #[expect(clippy::should_implement_trait)]
+    #[inline(always)]
+    pub fn add(self, offset: usize) -> Self {
+        Self(self.0 + offset)
+    }
+
+    #[inline(always)]
+    pub fn kind(&self) -> TableKind {
+        if (self.0 as isize) < 0 {
+            TableKind::Kernel
+        } else {
+            TableKind::User
+        }
+    }
+}
+
+impl core::fmt::Debug for VirtualAddress {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "[virt {:#0x}]", self.data())
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct MemoryArea {
+    pub base: PhysicalAddress,
+    pub size: usize,
+}

rmm/src/main.rs

@@ -0,0 +1,309 @@
+#![cfg(target_pointer_width = "64")]
+
+use rmm::{
+    emulate::EmulateArch, Arch, BuddyAllocator, BumpAllocator, Flusher, FrameAllocator, FrameCount,
+    MemoryArea, PageFlags, PageFlushAll, PageMapper, PageTable, PhysicalAddress, TableKind,
+    VirtualAddress, GIGABYTE, KILOBYTE, MEGABYTE, TERABYTE,
+};
+use std::marker::PhantomData;
+
+pub fn format_size(size: usize) -> String {
+    if size >= 2 * TERABYTE {
+        format!("{} TB", size / TERABYTE)
+    } else if size >= 2 * GIGABYTE {
+        format!("{} GB", size / GIGABYTE)
+    } else if size >= 2 * MEGABYTE {
+        format!("{} MB", size / MEGABYTE)
+    } else if size >= 2 * KILOBYTE {
+        format!("{} KB", size / KILOBYTE)
+    } else {
+        format!("{} B", size)
+    }
+}
+
+#[allow(dead_code)]
+unsafe fn dump_tables<A: Arch>(table: PageTable<A>) {
+    unsafe {
+        let level = table.level();
+        for i in 0..A::PAGE_ENTRIES {
+            if level == 0 {
+                if let Some(entry) = table.entry(i) {
+                    if entry.present() {
+                        let base = table.entry_base(i).unwrap();
+                        println!(
+                            "0x{:X}: 0x{:X}",
+                            base.data(),
+                            entry.address().unwrap().data()
+                        );
+                    }
+                }
+            } else {
+                if let Some(next) = table.next(i) {
+                    dump_tables(next);
+                }
+            }
+        }
+    }
+}
+
+pub struct SlabNode<A> {
+    next: PhysicalAddress,
+    count: usize,
+    phantom: PhantomData<A>,
+}
+
+impl<A: Arch> SlabNode<A> {
+    pub fn new(next: PhysicalAddress, count: usize) -> Self {
+        Self {
+            next,
+            count,
+            phantom: PhantomData,
+        }
+    }
+
+    pub fn empty() -> Self {
+        Self::new(PhysicalAddress::new(0), 0)
+    }
+
+    pub unsafe fn insert(&mut self, phys: PhysicalAddress) {
+        unsafe {
+            let virt = A::phys_to_virt(phys);
+            A::write(virt, self.next);
+            self.next = phys;
+            self.count += 1;
+        }
+    }
+
+    pub unsafe fn remove(&mut self) -> Option<PhysicalAddress> {
+        unsafe {
+            if self.count > 0 {
+                let phys = self.next;
+                let virt = A::phys_to_virt(phys);
+                self.next = A::read(virt);
+                self.count -= 1;
+                Some(phys)
+            } else {
+                None
+            }
+        }
+    }
+}
+
+pub struct SlabAllocator<A> {
+    //TODO: Allow allocations up to maximum pageable size
+    nodes: [SlabNode<A>; 4],
+    phantom: PhantomData<A>,
+}
+
+impl<A: Arch> SlabAllocator<A> {
+    pub unsafe fn new(areas: &'static [MemoryArea], offset: usize) -> Self {
+        unsafe {
+            let mut allocator = Self {
+                nodes: [
+                    SlabNode::empty(),
+                    SlabNode::empty(),
+                    SlabNode::empty(),
+                    SlabNode::empty(),
+                ],
+                phantom: PhantomData,
+            };
+
+            // Add unused areas to free lists
+            let mut area_offset = offset;
+            for area in areas.iter() {
+                if area_offset < area.size {
+                    let area_base = area.base.add(area_offset);
+                    let area_size = area.size - area_offset;
+                    allocator.free(area_base, area_size);
+                    area_offset = 0;
+                } else {
+                    area_offset -= area.size;
+                }
+            }
+
+            allocator
+        }
+    }
+
+    pub unsafe fn allocate(&mut self, size: usize) -> Option<PhysicalAddress> {
+        unsafe {
+            for level in 0..A::PAGE_LEVELS - 1 {
+                let level_shift = level * A::PAGE_ENTRY_SHIFT + A::PAGE_SHIFT;
+                let level_size = 1 << level_shift;
+                if size <= level_size {
+                    if let Some(base) = self.nodes[level].remove() {
+                        self.free(base.add(size), level_size - size);
+                        return Some(base);
+                    }
+                }
+            }
+            None
+        }
+    }
+
+    //TODO: This causes fragmentation, since neighbors are not identified
+    //TODO: remainders less than PAGE_SIZE will be lost
+    pub unsafe fn free(&mut self, mut base: PhysicalAddress, mut size: usize) {
+        unsafe {
+            for level in (0..A::PAGE_LEVELS - 1).rev() {
+                let level_shift = level * A::PAGE_ENTRY_SHIFT + A::PAGE_SHIFT;
+                let level_size = 1 << level_shift;
+                while size >= level_size {
+                    println!("Add {:X} {}", base.data(), format_size(level_size));
+                    self.nodes[level].insert(base);
+                    base = base.add(level_size);
+                    size -= level_size;
+                }
+            }
+        }
+    }
+
+    pub unsafe fn remaining(&mut self) -> usize {
+        let mut remaining = 0;
+        for level in (0..A::PAGE_LEVELS - 1).rev() {
+            let level_shift = level * A::PAGE_ENTRY_SHIFT + A::PAGE_SHIFT;
+            let level_size = 1 << level_shift;
+            remaining += self.nodes[level].count * level_size;
+        }
+        remaining
+    }
+}
+
+unsafe fn new_tables<A: Arch>(areas: &'static [MemoryArea]) {
+    unsafe {
+        // First, calculate how much memory we have
+        let mut size = 0;
+        for area in areas.iter() {
+            size += area.size;
+        }
+
+        println!("Memory: {}", format_size(size));
+
+        // Create a basic allocator for the first pages
+        let mut bump_allocator = BumpAllocator::<A>::new(areas, 0);
+
+        {
+            // Map all physical areas at PHYS_OFFSET
+            let mut mapper = PageMapper::<A, _>::create(TableKind::Kernel, &mut bump_allocator)
+                .expect("failed to create Mapper");
+            for area in areas.iter() {
+                for i in 0..area.size / A::PAGE_SIZE {
+                    let phys = area.base.add(i * A::PAGE_SIZE);
+                    let (_, flush) = mapper
+                        .map_linearly(phys, PageFlags::<A>::new().write(true))
+                        .expect("failed to map page to frame");
+                    flush.ignore(); // Not the active table
+                }
+            }
+
+            // Use the new table
+            mapper.make_current();
+        }
+
+        // Create the physical memory map
+        let offset = bump_allocator.offset();
+        println!("Permanently used: {}", format_size(offset));
+
+        let mut allocator = BuddyAllocator::<A>::new(bump_allocator).unwrap();
+
+        for i in 0..16 {
+            {
+                let phys_opt = allocator.allocate_one();
+                println!("page {}: {:X?}", i, phys_opt);
+                if i % 3 == 0 {
+                    if let Some(phys) = phys_opt {
+                        println!("free {}: {:X?}", i, phys_opt);
+                        allocator.free_one(phys);
+                    }
+                }
+            }
+
+            {
+                let phys_opt = allocator.allocate(FrameCount::new(16));
+                println!("page*16 {}: {:X?}", i, phys_opt);
+                if i % 2 == 0 {
+                    if let Some(phys) = phys_opt {
+                        println!("free*16 {}: {:X?}", i, phys_opt);
+                        allocator.free(phys, FrameCount::new(16));
+                    }
+                }
+            }
+        }
+
+        let mut mapper = PageMapper::<A, _>::current(TableKind::Kernel, &mut allocator);
+        let mut flush_all = PageFlushAll::new();
+        for i in 0..16 {
+            let virt = VirtualAddress::new(MEGABYTE + i * A::PAGE_SIZE);
+            let phys = mapper
+                .allocator_mut()
+                .allocate_one()
+                .expect("failed to map page");
+            let flush = mapper
+                .map_phys(virt, phys, PageFlags::<A>::new().user(true).write(true))
+                .expect("failed to map page");
+            flush_all.consume(flush);
+        }
+        flush_all.flush();
+
+        let mut flush_all = PageFlushAll::new();
+        for i in 0..16 {
+            let virt = VirtualAddress::new(MEGABYTE + i * A::PAGE_SIZE);
+            let (old, _, flush) = mapper.unmap_phys(virt).expect("failed to unmap page");
+            mapper.allocator_mut().free_one(old);
+            flush_all.consume(flush);
+        }
+        flush_all.flush();
+
+        let usage = allocator.usage();
+        println!("Allocator usage:");
+        println!(
+            "  Used: {}",
+            format_size(usage.used().data() * A::PAGE_SIZE)
+        );
+        println!(
+            "  Free: {}",
+            format_size(usage.free().data() * A::PAGE_SIZE)
+        );
+        println!(
+            "  Total: {}",
+            format_size(usage.total().data() * A::PAGE_SIZE)
+        );
+    }
+}
+
+fn main() {
+    unsafe {
+        let areas = EmulateArch::init();
+
+        // Debug table
+        //dump_tables(PageTable::<A>::top());
+
+        new_tables::<EmulateArch>(areas);
+
+        //dump_tables(PageTable::<A>::top());
+
+        for i in &[1, 2, 4, 8, 16, 32] {
+            let phys = PhysicalAddress::new(i * MEGABYTE);
+            let virt = EmulateArch::phys_to_virt(phys);
+
+            // Test read
+            println!(
+                "0x{:X} (0x{:X}) = 0x{:X}",
+                virt.data(),
+                phys.data(),
+                EmulateArch::read::<u8>(virt)
+            );
+
+            // Test write
+            EmulateArch::write::<u8>(virt, 0x5A);
+
+            // Test read
+            println!(
+                "0x{:X} (0x{:X}) = 0x{:X}",
+                virt.data(),
+                phys.data(),
+                EmulateArch::read::<u8>(virt)
+            );
+        }
+    }
+}

rmm/src/page/entry.rs

@@ -0,0 +1,59 @@
+use core::marker::PhantomData;
+
+use crate::{Arch, PageFlags, PhysicalAddress};
+
+#[derive(Clone, Copy, Debug)]
+pub struct PageEntry<A> {
+    data: usize,
+    phantom: PhantomData<A>,
+}
+
+impl<A: Arch> PageEntry<A> {
+    #[inline(always)]
+    pub fn new(address: usize, flags: usize) -> Self {
+        let data = (((address >> A::PAGE_SHIFT) & A::ENTRY_ADDRESS_MASK) << A::ENTRY_ADDRESS_SHIFT)
+            | flags;
+        Self::from_data(data)
+    }
+
+    #[inline(always)]
+    pub fn from_data(data: usize) -> Self {
+        Self {
+            data,
+            phantom: PhantomData,
+        }
+    }
+
+    #[inline(always)]
+    pub fn data(&self) -> usize {
+        self.data
+    }
+
+    #[inline(always)]
+    pub fn address(&self) -> Result<PhysicalAddress, PhysicalAddress> {
+        let addr = PhysicalAddress(
+            ((self.data >> A::ENTRY_ADDRESS_SHIFT) & A::ENTRY_ADDRESS_MASK) << A::PAGE_SHIFT,
+        );
+
+        if self.present() {
+            Ok(addr)
+        } else {
+            Err(addr)
+        }
+    }
+
+    #[inline(always)]
+    pub fn flags(&self) -> PageFlags<A> {
+        unsafe { PageFlags::from_data(self.data & A::ENTRY_FLAGS_MASK) }
+    }
+    #[inline(always)]
+    pub fn set_flags(&mut self, flags: PageFlags<A>) {
+        self.data &= !A::ENTRY_FLAGS_MASK;
+        self.data |= flags.data();
+    }
+
+    #[inline(always)]
+    pub fn present(&self) -> bool {
+        self.data & A::ENTRY_FLAG_PRESENT != 0
+    }
+}

rmm/src/page/flags.rs

@@ -0,0 +1,157 @@
+use core::{fmt, marker::PhantomData};
+
+use crate::Arch;
+
+#[derive(Clone, Copy)]
+pub struct PageFlags<A> {
+    data: usize,
+    arch: PhantomData<A>,
+}
+
+impl<A: Arch> PageFlags<A> {
+    #[inline(always)]
+    pub fn new() -> Self {
+        unsafe {
+            Self::from_data(
+                // Flags set to present, kernel space, read-only, no-execute by default
+                A::ENTRY_FLAG_DEFAULT_PAGE
+                    | A::ENTRY_FLAG_READONLY
+                    | A::ENTRY_FLAG_NO_EXEC
+                    | A::ENTRY_FLAG_NO_GLOBAL,
+            )
+        }
+    }
+
+    #[inline(always)]
+    pub fn new_table() -> Self {
+        unsafe {
+            Self::from_data(
+                // Flags set to present, kernel space, read-only, no-execute by default
+                A::ENTRY_FLAG_DEFAULT_TABLE | A::ENTRY_FLAG_NO_EXEC | A::ENTRY_FLAG_NO_GLOBAL,
+            )
+        }
+    }
+
+    #[inline(always)]
+    pub unsafe fn from_data(data: usize) -> Self {
+        Self {
+            data,
+            arch: PhantomData,
+        }
+    }
+
+    #[inline(always)]
+    pub fn data(&self) -> usize {
+        self.data
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn custom_flag(mut self, flag: usize, value: bool) -> Self {
+        if value {
+            self.data |= flag;
+        } else {
+            self.data &= !flag;
+        }
+        self
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn device_memory(self, value: bool) -> Self {
+        self.custom_flag(A::ENTRY_FLAG_DEVICE_MEMORY, value)
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn uncacheable(self, value: bool) -> Self {
+        self.custom_flag(A::ENTRY_FLAG_UNCACHEABLE, value)
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn write_combining(self, value: bool) -> Self {
+        self.custom_flag(A::ENTRY_FLAG_WRITE_COMBINING, value)
+    }
+
+    #[inline(always)]
+    pub fn has_flag(&self, flag: usize) -> bool {
+        self.data & flag == flag
+    }
+
+    #[inline(always)]
+    pub fn has_present(&self) -> bool {
+        self.has_flag(A::ENTRY_FLAG_PRESENT)
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn user(self, value: bool) -> Self {
+        self.custom_flag(A::ENTRY_FLAG_PAGE_USER, value)
+    }
+
+    #[inline(always)]
+    pub fn has_user(&self) -> bool {
+        self.has_flag(A::ENTRY_FLAG_PAGE_USER)
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn write(self, value: bool) -> Self {
+        // Architecture may use readonly or readwrite, or both, support either
+        if value {
+            self.custom_flag(A::ENTRY_FLAG_READONLY | A::ENTRY_FLAG_READWRITE, false)
+                .custom_flag(A::ENTRY_FLAG_READWRITE, true)
+        } else {
+            self.custom_flag(A::ENTRY_FLAG_READONLY | A::ENTRY_FLAG_READWRITE, false)
+                .custom_flag(A::ENTRY_FLAG_READONLY, true)
+        }
+    }
+
+    #[inline(always)]
+    pub fn has_write(&self) -> bool {
+        // Architecture may use readonly or readwrite, or both, support either
+        self.data & (A::ENTRY_FLAG_READONLY | A::ENTRY_FLAG_READWRITE) == A::ENTRY_FLAG_READWRITE
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn execute(self, value: bool) -> Self {
+        //TODO: write xor execute?
+        // Architecture may use no exec or exec, support either
+        self.custom_flag(A::ENTRY_FLAG_NO_EXEC, !value)
+            .custom_flag(A::ENTRY_FLAG_EXEC, value)
+    }
+
+    #[inline(always)]
+    pub fn has_execute(&self) -> bool {
+        // Architecture may use no exec or exec, support either
+        self.data & (A::ENTRY_FLAG_NO_EXEC | A::ENTRY_FLAG_EXEC) == A::ENTRY_FLAG_EXEC
+    }
+
+    #[must_use]
+    #[inline(always)]
+    pub fn global(self, value: bool) -> Self {
+        // Architecture may use global or non global, support either
+        self.custom_flag(A::ENTRY_FLAG_NO_GLOBAL, !value)
+            .custom_flag(A::ENTRY_FLAG_GLOBAL, value)
+    }
+
+    #[inline(always)]
+    pub fn is_global(&self) -> bool {
+        // Architecture may use global or non global, support either
+        self.data & (A::ENTRY_FLAG_GLOBAL | A::ENTRY_FLAG_NO_GLOBAL) == A::ENTRY_FLAG_GLOBAL
+    }
+}
+
+impl<A: Arch> fmt::Debug for PageFlags<A> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PageFlags")
+            .field("present", &self.has_present())
+            .field("write", &self.has_write())
+            .field("executable", &self.has_execute())
+            .field("user", &self.has_user())
+            .field("bits", &format_args!("{:#0x}", self.data))
+            .finish()
+    }
+}