From 911b37533b95dbe160f5ff655e84d19aa8eb51be Mon Sep 17 00:00:00 2001
From: Able <abl3theabove@gmail.com>
Date: Tue, 16 Nov 2021 00:09:27 -0600
Subject: [PATCH] ableOS build system
---
.cargo/config.toml | 2 +
.gitignore | 2 +
ableos/.cargo/config.toml | 11 +
ableos/.github/workflows/rust.yml | 22 +
ableos/.vscode/settings.json | 5 +
ableos/Cargo.lock | 202 +
ableos/Cargo.toml | 40 +
ableos/README.md | 22 +
ableos/TODO.md | 2 +
ableos/json_targets/.rustc_info.json | 1 +
ableos/json_targets/aarch32-ableos.json | 15 +
ableos/json_targets/aarch64-ableos.json | 24 +
ableos/json_targets/arm-ableos.json | 15 +
ableos/json_targets/x86_64-ableos.json | 15 +
ableos/keymaps/empty.keymap | 256 +
ableos/keymaps/qwerty.keymap | 252 +
ableos/notes/NOTES.md | 9 +
ableos/notes/USER.md | 3 +
ableos/rust-toolchain | 1 +
ableos/shitty_code_to_rewrite/shutdown.rs | 27 +
ableos/shitty_code_to_rewrite/shutdown_in_c.c | 302 +
ableos/shitty_code_to_rewrite/signal.c | 4947 +++++++++++++++++
ableos/src/arch/aarch32/boot.s | 52 +
ableos/src/arch/aarch32/build.sh | 7 +
ableos/src/arch/aarch32/drivers/graphics.rs | 1 +
ableos/src/arch/aarch32/drivers/mod.rs | 1 +
ableos/src/arch/aarch32/init.rs | 4 +
ableos/src/arch/aarch32/linker.ld | 43 +
ableos/src/arch/aarch32/mbox.rs | 2 +
ableos/src/arch/aarch32/mod.rs | 38 +
ableos/src/arch/aarch32/run.sh | 3 +
ableos/src/arch/aarch64/aarch64-qemu.ld | 14 +
ableos/src/arch/aarch64/boot.s | 15 +
ableos/src/arch/aarch64/drivers/graphics.rs | 31 +
ableos/src/arch/aarch64/drivers/mod.rs | 2 +
ableos/src/arch/aarch64/drivers/nrf52.rs | 73 +
ableos/src/arch/aarch64/init.rs | 1 +
ableos/src/arch/aarch64/mod.rs | 67 +
ableos/src/arch/aarch64/run.sh | 4 +
ableos/src/arch/aarch64/serial.rs | 12 +
.../src/arch/ps_portable/drivers/graphics.rs | 1 +
ableos/src/arch/ps_portable/drivers/mod.rs | 1 +
ableos/src/arch/ps_portable/init.rs | 2 +
ableos/src/arch/ps_portable/mod.rs | 47 +
.../src/arch/ps_portable/simple_graphics.rs | 27 +
ableos/src/arch/ps_portable/timer.rs | 13 +
ableos/src/arch/riscv/asm/boot.asm | 58 +
ableos/src/arch/riscv/asm/trap.asm | 8 +
ableos/src/arch/x86_64/.runners/debug.sh | 2 +
ableos/src/arch/x86_64/.runners/run-debug.sh | 2 +
ableos/src/arch/x86_64/.runners/run-test.sh | 2 +
ableos/src/arch/x86_64/.runners/run.sh | 2 +
ableos/src/arch/x86_64/drivers/graphics.rs | 35 +
ableos/src/arch/x86_64/drivers/mod.rs | 5 +
ableos/src/arch/x86_64/drivers/serial.rs | 33 +
ableos/src/arch/x86_64/drivers/vga.rs | 133 +
ableos/src/arch/x86_64/gdt.rs | 46 +
ableos/src/arch/x86_64/init.rs | 11 +
ableos/src/arch/x86_64/interrupts.rs | 112 +
ableos/src/arch/x86_64/mod.rs | 27 +
ableos/src/driver_traits/device.rs | 4 +
ableos/src/driver_traits/graphics.rs | 37 +
ableos/src/driver_traits/mod.rs | 2 +
ableos/src/driver_traits/mouse.rs | 9 +
ableos/src/driver_traits/serial.rs | 4 +
ableos/src/experiments/EXPLAIN.md | 1 +
ableos/src/experiments/banner.txt | 7 +
ableos/src/experiments/clip.rs | 55 +
ableos/src/experiments/file.rs | 22 +
ableos/src/experiments/filesystem.txt | 15 +
ableos/src/experiments/kinfo.rs | 34 +
ableos/src/experiments/mail.rs | 72 +
ableos/src/experiments/mod.rs | 10 +
ableos/src/experiments/pkg.rs | 44 +
ableos/src/experiments/schedule.rs | 24 +
ableos/src/experiments/server.rs | 10 +
ableos/src/experiments/syscalls.md | 39 +
ableos/src/experiments/systeminfo.rs | 33 +
ableos/src/experiments/user.rs | 4 +
ableos/src/experiments/virtual_memory.rs | 7 +
ableos/src/experiments/wm.rs | 23 +
ableos/src/keyboard/abstractions.rs | 623 +++
ableos/src/keyboard/mod.rs | 273 +
ableos/src/keyboard/small_types.rs | 246 +
ableos/src/keyboard/traits.rs | 21 +
ableos/src/kmain.rs | 74 +
ableos/src/lib.rs | 43 +
ableos/src/main.rs | 3 +
ableos/src/panic.rs | 9 +
ableos/src/print.rs | 60 +
ableos/src/relib/math/mod.rs | 1 +
ableos/src/relib/math/rand/linearshift.rs | 35 +
ableos/src/relib/math/rand/mod.rs | 87 +
ableos/src/relib/math/rand/prand.rs | 17 +
ableos/src/relib/math/rand/wichmanhillrand.rs | 27 +
ableos/src/relib/mod.rs | 6 +
ableos/src/relib/time/kilotime.rs | 72 +
ableos/src/relib/time/mod.rs | 20 +
repbuild/Cargo.lock | 248 +
repbuild/Cargo.toml | 12 +
repbuild/README.md | 2 +
repbuild/src/main.rs | 43 +
rust-toolchain | 1 +
103 files changed, 9491 insertions(+)
create mode 100644 .cargo/config.toml
create mode 100644 .gitignore
create mode 100644 ableos/.cargo/config.toml
create mode 100644 ableos/.github/workflows/rust.yml
create mode 100644 ableos/.vscode/settings.json
create mode 100644 ableos/Cargo.lock
create mode 100644 ableos/Cargo.toml
create mode 100644 ableos/README.md
create mode 100644 ableos/TODO.md
create mode 100644 ableos/json_targets/.rustc_info.json
create mode 100644 ableos/json_targets/aarch32-ableos.json
create mode 100644 ableos/json_targets/aarch64-ableos.json
create mode 100644 ableos/json_targets/arm-ableos.json
create mode 100644 ableos/json_targets/x86_64-ableos.json
create mode 100644 ableos/keymaps/empty.keymap
create mode 100644 ableos/keymaps/qwerty.keymap
create mode 100644 ableos/notes/NOTES.md
create mode 100644 ableos/notes/USER.md
create mode 100644 ableos/rust-toolchain
create mode 100644 ableos/shitty_code_to_rewrite/shutdown.rs
create mode 100644 ableos/shitty_code_to_rewrite/shutdown_in_c.c
create mode 100644 ableos/shitty_code_to_rewrite/signal.c
create mode 100644 ableos/src/arch/aarch32/boot.s
create mode 100644 ableos/src/arch/aarch32/build.sh
create mode 100644 ableos/src/arch/aarch32/drivers/graphics.rs
create mode 100644 ableos/src/arch/aarch32/drivers/mod.rs
create mode 100644 ableos/src/arch/aarch32/init.rs
create mode 100644 ableos/src/arch/aarch32/linker.ld
create mode 100644 ableos/src/arch/aarch32/mbox.rs
create mode 100644 ableos/src/arch/aarch32/mod.rs
create mode 100644 ableos/src/arch/aarch32/run.sh
create mode 100644 ableos/src/arch/aarch64/aarch64-qemu.ld
create mode 100644 ableos/src/arch/aarch64/boot.s
create mode 100644 ableos/src/arch/aarch64/drivers/graphics.rs
create mode 100644 ableos/src/arch/aarch64/drivers/mod.rs
create mode 100644 ableos/src/arch/aarch64/drivers/nrf52.rs
create mode 100644 ableos/src/arch/aarch64/init.rs
create mode 100644 ableos/src/arch/aarch64/mod.rs
create mode 100644 ableos/src/arch/aarch64/run.sh
create mode 100644 ableos/src/arch/aarch64/serial.rs
create mode 100644 ableos/src/arch/ps_portable/drivers/graphics.rs
create mode 100644 ableos/src/arch/ps_portable/drivers/mod.rs
create mode 100644 ableos/src/arch/ps_portable/init.rs
create mode 100644 ableos/src/arch/ps_portable/mod.rs
create mode 100644 ableos/src/arch/ps_portable/simple_graphics.rs
create mode 100644 ableos/src/arch/ps_portable/timer.rs
create mode 100644 ableos/src/arch/riscv/asm/boot.asm
create mode 100644 ableos/src/arch/riscv/asm/trap.asm
create mode 100644 ableos/src/arch/x86_64/.runners/debug.sh
create mode 100644 ableos/src/arch/x86_64/.runners/run-debug.sh
create mode 100644 ableos/src/arch/x86_64/.runners/run-test.sh
create mode 100644 ableos/src/arch/x86_64/.runners/run.sh
create mode 100644 ableos/src/arch/x86_64/drivers/graphics.rs
create mode 100644 ableos/src/arch/x86_64/drivers/mod.rs
create mode 100644 ableos/src/arch/x86_64/drivers/serial.rs
create mode 100644 ableos/src/arch/x86_64/drivers/vga.rs
create mode 100644 ableos/src/arch/x86_64/gdt.rs
create mode 100644 ableos/src/arch/x86_64/init.rs
create mode 100644 ableos/src/arch/x86_64/interrupts.rs
create mode 100644 ableos/src/arch/x86_64/mod.rs
create mode 100644 ableos/src/driver_traits/device.rs
create mode 100644 ableos/src/driver_traits/graphics.rs
create mode 100644 ableos/src/driver_traits/mod.rs
create mode 100644 ableos/src/driver_traits/mouse.rs
create mode 100644 ableos/src/driver_traits/serial.rs
create mode 100644 ableos/src/experiments/EXPLAIN.md
create mode 100644 ableos/src/experiments/banner.txt
create mode 100644 ableos/src/experiments/clip.rs
create mode 100644 ableos/src/experiments/file.rs
create mode 100644 ableos/src/experiments/filesystem.txt
create mode 100644 ableos/src/experiments/kinfo.rs
create mode 100644 ableos/src/experiments/mail.rs
create mode 100644 ableos/src/experiments/mod.rs
create mode 100644 ableos/src/experiments/pkg.rs
create mode 100644 ableos/src/experiments/schedule.rs
create mode 100644 ableos/src/experiments/server.rs
create mode 100644 ableos/src/experiments/syscalls.md
create mode 100644 ableos/src/experiments/systeminfo.rs
create mode 100644 ableos/src/experiments/user.rs
create mode 100644 ableos/src/experiments/virtual_memory.rs
create mode 100644 ableos/src/experiments/wm.rs
create mode 100644 ableos/src/keyboard/abstractions.rs
create mode 100644 ableos/src/keyboard/mod.rs
create mode 100644 ableos/src/keyboard/small_types.rs
create mode 100644 ableos/src/keyboard/traits.rs
create mode 100644 ableos/src/kmain.rs
create mode 100644 ableos/src/lib.rs
create mode 100644 ableos/src/main.rs
create mode 100644 ableos/src/panic.rs
create mode 100644 ableos/src/print.rs
create mode 100644 ableos/src/relib/math/mod.rs
create mode 100644 ableos/src/relib/math/rand/linearshift.rs
create mode 100644 ableos/src/relib/math/rand/mod.rs
create mode 100644 ableos/src/relib/math/rand/prand.rs
create mode 100644 ableos/src/relib/math/rand/wichmanhillrand.rs
create mode 100644 ableos/src/relib/mod.rs
create mode 100644 ableos/src/relib/time/kilotime.rs
create mode 100644 ableos/src/relib/time/mod.rs
create mode 100644 repbuild/Cargo.lock
create mode 100644 repbuild/Cargo.toml
create mode 100644 repbuild/README.md
create mode 100644 repbuild/src/main.rs
create mode 100644 rust-toolchain
diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 0000000..22b6ca6
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,2 @@
+[alias]
+repbuild = "run --manifest-path ./repbuild/Cargo.toml --"
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6ea2636
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+repbuild/target
+ableos/target
diff --git a/ableos/.cargo/config.toml b/ableos/.cargo/config.toml
new file mode 100644
index 0000000..3526375
--- /dev/null
+++ b/ableos/.cargo/config.toml
@@ -0,0 +1,11 @@
+[build]
+target = "./json_targets/x86_64-ableos.json"
+
+[unstable]
+build-std-features = ["compiler-builtins-mem"]
+build-std = ["core", "compiler_builtins"]
+
+
+[target.'cfg(target_arch = "x86_64")']
+# --quiet suppresses warning messages from the bootimage crate
+runner = "bootimage runner --quiet"
diff --git a/ableos/.github/workflows/rust.yml b/ableos/.github/workflows/rust.yml
new file mode 100644
index 0000000..8941734
--- /dev/null
+++ b/ableos/.github/workflows/rust.yml
@@ -0,0 +1,22 @@
+name: Build
+
+on:
+ - push
+ - pull_request
+
+env:
+ CARGO_TERM_COLOR: always
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+
+ steps:
+ - uses: actions/checkout@v2
+ - uses: actions-rs/toolchain@v1
+ with:
+ components: rust-src
+ - uses: actions-rs/cargo@v1
+ with:
+ command: build
+ args: --release
diff --git a/ableos/.vscode/settings.json b/ableos/.vscode/settings.json
new file mode 100644
index 0000000..f5dcd89
--- /dev/null
+++ b/ableos/.vscode/settings.json
@@ -0,0 +1,5 @@
+{
+ "files.associations": {
+ "stddef.h": "c"
+ }
+}
\ No newline at end of file
diff --git a/ableos/Cargo.lock b/ableos/Cargo.lock
new file mode 100644
index 0000000..571238b
--- /dev/null
+++ b/ableos/Cargo.lock
@@ -0,0 +1,202 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "ableos"
+version = "0.1.0"
+dependencies = [
+ "bootloader",
+ "cpuio",
+ "lazy_static",
+ "pic8259",
+ "psp",
+ "spin",
+ "uart_16550",
+ "volatile 0.2.7",
+ "x86_64",
+]
+
+[[package]]
+name = "bit_field"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcb6dd1c2376d2e096796e234a70e17e94cc2d5d54ff8ce42b28cef1d0d359a4"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bootloader"
+version = "0.9.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c452074efc3c0bfb241fb7bc87df04741c7c85e926f6a07c05f8fbd6008240"
+
+[[package]]
+name = "cpuio"
+version = "0.3.0"
+source = "git+https://github.com/anyusernameworks/cpuio.git#3908ecab79df80670ee1c5121870fc131f07627b"
+
+[[package]]
+name = "derivative"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+dependencies = [
+ "spin",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9bd055fb730c4f8f4f57d45d35cd6b3f0980535b056dc7ff119cee6a66ed6f"
+dependencies = [
+ "derivative",
+ "num_enum_derive",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "486ea01961c4a818096de679a8b740b26d9033146ac5291b1c98557658f8cdd9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "paste"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45ca20c77d80be666aef2b45486da86238fabe33e38306bd3118fe4af33fa880"
+dependencies = [
+ "paste-impl",
+ "proc-macro-hack",
+]
+
+[[package]]
+name = "paste-impl"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d95a7db200b97ef370c8e6de0088252f7e0dfff7d047a28528e47456c0fc98b6"
+dependencies = [
+ "proc-macro-hack",
+]
+
+[[package]]
+name = "pic8259"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24ec21f514e2e16e94649f1d041ca4a7069b512c037ac156360652a775e6229d"
+dependencies = [
+ "x86_64",
+]
+
+[[package]]
+name = "proc-macro-hack"
+version = "0.5.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "psp"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b3021953a10d1bc6735a606ab9d5a1510282df7a55a160a270e9ea3cf479669"
+dependencies = [
+ "bitflags",
+ "num_enum",
+ "num_enum_derive",
+ "paste",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
+[[package]]
+name = "syn"
+version = "1.0.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "uart_16550"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65ad019480ef5ff8ffe66d6f6a259cd87cf317649481394981db1739d844f374"
+dependencies = [
+ "bitflags",
+ "x86_64",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "volatile"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6b06ad3ed06fef1713569d547cdbdb439eafed76341820fb0e0344f29a41945"
+
+[[package]]
+name = "volatile"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4c2dbd44eb8b53973357e6e207e370f0c1059990df850aca1eca8947cf464f0"
+
+[[package]]
+name = "x86_64"
+version = "0.14.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbc6ed1ed2cd4536b083c34041aff7b84448ee25ac4aa5e9d54802ce226f9815"
+dependencies = [
+ "bit_field",
+ "bitflags",
+ "volatile 0.4.4",
+]
diff --git a/ableos/Cargo.toml b/ableos/Cargo.toml
new file mode 100644
index 0000000..077645a
--- /dev/null
+++ b/ableos/Cargo.toml
@@ -0,0 +1,40 @@
+[package]
+name = "ableos"
+version = "0.1.0"
+edition = "2021"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[profile.release]
+panic = "abort"
+
+[package.metadata.bootimage]
+test-args = [
+ "-device", "isa-debug-exit,iobase=0xf4,iosize=0x04", "-serial", "stdio"
+]
+run-args=["-serial", "stdio"]
+
+[dependencies]
+spin = "0.5.2"
+# linked_list_allocator = "0.9.0"
+
+[dependencies.lazy_static]
+features = ["spin_no_std"]
+version = "1.0"
+
+# alloc required
+# [dependencies.wasmi]
+# version = "*"
+# default-features = false
+# features = ["core"]
+
+
+[target.'cfg(target_arch = "mips")'.dependencies]
+psp = "0.1.5"
+
+[target.'cfg(target_arch = "x86_64")'.dependencies]
+volatile = "0.2.6"
+bootloader = "0.9.8"
+cpuio = { git = "https://github.com/anyusernameworks/cpuio.git" }
+x86_64 = "*"
+uart_16550 = "0.2.0"
+pic8259 = "0.10.1"
diff --git a/ableos/README.md b/ableos/README.md
new file mode 100644
index 0000000..7bf8b0c
--- /dev/null
+++ b/ableos/README.md
@@ -0,0 +1,22 @@
+# ableOS
+ 
+## Set up
+Install [Qemu](https://www.qemu.org/)
+
+> On Windows be sure to add `C:\Program Files\qemu` to your `PATH` variable
+
+`rustup component add rust-src`
+
+`rustup component add llvm-tools-preview`
+
+`cargo install bootimage`
+
+## Srange workarounds
+- arm/build.rs has to move main.rs
+- conditional dependencies for bootloader are broken
+## Testing on real hardware
+I recommend using an old x86_64 computer
+* `cargo run --release` to generate a binary image that is bootable
+* flash it to a USB device via `dd` or belenaEtcher
+* Remove said USB device and plug into test machine
+* assure test machine boots from USB devices
diff --git a/ableos/TODO.md b/ableos/TODO.md
new file mode 100644
index 0000000..cedd21b
--- /dev/null
+++ b/ableos/TODO.md
@@ -0,0 +1,2 @@
+- [ ] Simple interactive "painting" "program"
+- [ ] monotty like desktop environment
diff --git a/ableos/json_targets/.rustc_info.json b/ableos/json_targets/.rustc_info.json
new file mode 100644
index 0000000..29caa8f
--- /dev/null
+++ b/ableos/json_targets/.rustc_info.json
@@ -0,0 +1 @@
+{"rustc_fingerprint":3542195962280373086,"outputs":{"17598535894874457435":{"success":true,"status":"","code":0,"stdout":"rustc 1.58.0-nightly (efd048394 2021-10-20)\nbinary: rustc\ncommit-hash: efd0483949496b067cd5f7569d1b28cd3d5d3c72\ncommit-date: 2021-10-20\nhost: x86_64-unknown-linux-gnu\nrelease: 1.58.0-nightly\nLLVM version: 13.0.0\n","stderr":""},"2797684049618456168":{"success":false,"status":"exit status: 1","code":1,"stdout":"","stderr":"error: `-Csplit-debuginfo` is unstable on this platform\n\n"},"15537503139010883884":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n","stderr":""},"931469667778813386":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n/home/elfein/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu\ndebug_assertions\npanic=\"unwind\"\nproc_macro\ntarget_abi=\"\"\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_has_atomic_equal_alignment=\"16\"\ntarget_has_atomic_equal_alignment=\"32\"\ntarget_has_atomic_equal_alignment=\"64\"\ntarget_has_atomic_equal_alignment=\"8\"\ntarget_has_atomic_equal_alignment=\"ptr\"\ntarget_has_atomic_load_store=\"16\"\ntarget_has_atomic_load_store=\"32\"\ntarget_has_atomic_load_store=\"64\"\ntarget_has_atomic_load_store=\"8\"\ntarget_has_atomic_load_store=\"ptr\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"64\"\ntarget_thread_local\ntarget_vendor=\"unknown\"\nunix\n","stderr":""}},"successes":{}}
\ No newline at end of file
diff --git a/ableos/json_targets/aarch32-ableos.json b/ableos/json_targets/aarch32-ableos.json
new file mode 100644
index 0000000..0fe31e6
--- /dev/null
+++ b/ableos/json_targets/aarch32-ableos.json
@@ -0,0 +1,15 @@
+{
+ "llvm-target": "arm-none-eabihf",
+ "target-endian": "little",
+ "target-pointer-width": "32",
+ "target-c-int-width": "32",
+ "os": "ableos",
+ "env": "eabi",
+ "vendor": "unknown",
+ "arch": "arm",
+ "linker-flavor": "gcc",
+ "linker": "arm-none-eabi-gcc",
+ "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
+ "executables": true,
+ "relocation-model": "static"
+}
diff --git a/ableos/json_targets/aarch64-ableos.json b/ableos/json_targets/aarch64-ableos.json
new file mode 100644
index 0000000..77631b3
--- /dev/null
+++ b/ableos/json_targets/aarch64-ableos.json
@@ -0,0 +1,24 @@
+{
+ "arch": "aarch64",
+ "data-layout": "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128",
+ "disable-redzone": true,
+ "env": "",
+ "executables": true,
+ "features": "+strict-align,+neon,+fp-armv8",
+ "is-builtin": false,
+ "linker": "rust-lld",
+ "linker-flavor": "ld.lld",
+ "linker-is-gnu": true,
+ "pre-link-args": {
+ "ld.lld": ["-Tsrc/arch/aarch64/aarch64-qemu.ld"]
+ },
+ "llvm-target": "aarch64-unknown-none",
+ "max-atomic-width": 128,
+ "os": "none",
+ "panic-strategy": "abort",
+ "relocation-model": "static",
+ "target-c-int-width": "32",
+ "target-endian": "little",
+ "target-pointer-width": "64",
+ "vendor": ""
+}
diff --git a/ableos/json_targets/arm-ableos.json b/ableos/json_targets/arm-ableos.json
new file mode 100644
index 0000000..0fe31e6
--- /dev/null
+++ b/ableos/json_targets/arm-ableos.json
@@ -0,0 +1,15 @@
+{
+ "llvm-target": "arm-none-eabihf",
+ "target-endian": "little",
+ "target-pointer-width": "32",
+ "target-c-int-width": "32",
+ "os": "ableos",
+ "env": "eabi",
+ "vendor": "unknown",
+ "arch": "arm",
+ "linker-flavor": "gcc",
+ "linker": "arm-none-eabi-gcc",
+ "data-layout": "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64",
+ "executables": true,
+ "relocation-model": "static"
+}
diff --git a/ableos/json_targets/x86_64-ableos.json b/ableos/json_targets/x86_64-ableos.json
new file mode 100644
index 0000000..23da62b
--- /dev/null
+++ b/ableos/json_targets/x86_64-ableos.json
@@ -0,0 +1,15 @@
+{
+ "llvm-target": "x86_64-unknown-none",
+ "data-layout": "e-m:e-i64:64-f80:128-n8:16:32:64-S128",
+ "arch": "x86_64",
+ "target-endian": "little",
+ "target-pointer-width": "64",
+ "target-c-int-width": "32",
+ "os": "none",
+ "executables": true,
+ "linker-flavor": "ld.lld",
+ "linker": "rust-lld",
+ "panic-strategy": "abort",
+ "disable-redzone": true,
+ "features": "-mmx,-sse,+soft-float"
+}
diff --git a/ableos/keymaps/empty.keymap b/ableos/keymaps/empty.keymap
new file mode 100644
index 0000000..996078b
--- /dev/null
+++ b/ableos/keymaps/empty.keymap
@@ -0,0 +1,256 @@
+0-
+1-
+2-
+3-
+4-
+5-
+6-
+7-
+8-
+9-
+10-
+11-
+12-
+13-
+14-
+15-
+16-
+17-
+18-
+19-
+20-
+21-
+22-
+23-
+24-
+25-
+26-
+27-
+28-
+29-
+30-
+31-
+32-
+33-
+34-
+35-
+36-
+37-
+38-
+39-
+40-
+41-
+42-
+43-
+44-
+45-
+46-
+47-
+48-
+49-
+50-
+51-
+52-
+53-
+54-
+55-
+56-
+57-
+58-
+59-
+60-
+61-
+62-
+63-
+64-
+65-
+66-
+67-
+68-
+69-
+70-
+71-
+72-
+73-
+74-
+75-
+76-
+77-
+78-
+79-
+80-
+81-
+82-
+83-
+84-
+85-
+86-
+87-
+88-
+89-
+90-
+91-
+92-
+93-
+94-
+95-
+96-
+97-
+98-
+99-
+100-
+101-
+102-
+103-
+104-
+105-
+106-
+107-
+108-
+109-
+110-
+111-
+112-
+113-
+114-
+115-
+116-
+117-
+118-
+119-
+120-
+121-
+122-
+123-
+124-
+125-
+126-
+127-
+128-
+129-
+130-
+131-
+132-
+133-
+134-
+135-
+136-
+137-
+138-
+139-
+140-
+141-
+142-
+143-
+144-
+145-
+146-
+147-
+148-
+149-
+150-
+151-
+152-
+153-
+154-
+155-
+156-
+157-
+158-
+159-
+160-
+161-
+162-
+163-
+164-
+165-
+166-
+167-
+168-
+169-
+170-
+171-
+172-
+173-
+174-
+175-
+176-
+177-
+178-
+179-
+180-
+181-
+182-
+183-
+184-
+185-
+186-
+187-
+188-
+189-
+190-
+191-
+192-
+193-
+194-
+195-
+196-
+197-
+198-
+199-
+200-
+201-
+202-
+203-
+204-
+205-
+206-
+207-
+208-
+209-
+210-
+211-
+212-
+213-
+214-
+215-
+216-
+217-
+218-
+219-
+220-
+221-
+222-
+223-
+224-
+225-
+226-
+227-
+228-
+229-
+230-
+231-
+232-
+233-
+234-
+235-
+236-
+237-
+238-
+239-
+240-
+241-
+242-
+243-
+244-
+245-
+246-
+247-
+248-
+249-
+250-
+251-
+252-
+253-
+254-
+255-
diff --git a/ableos/keymaps/qwerty.keymap b/ableos/keymaps/qwerty.keymap
new file mode 100644
index 0000000..541b6a7
--- /dev/null
+++ b/ableos/keymaps/qwerty.keymap
@@ -0,0 +1,252 @@
+# Able doesn't have a full keyboard
+0-NONE
+1-
+2-
+3-BACKSPACE
+4-
+5-
+6-
+7-
+8-
+9-TAB
+10-
+11-
+12-
+13-ENTER
+14-
+15-
+16-SHIFT
+17-CONTROL
+18-ALT
+19-PAUSE
+20-CAPS_LOCK
+21-
+22-
+23-
+24-
+25-
+26-
+27-
+28-
+29-
+30-
+31-
+32-SPACE
+33-PAGE_UP
+34-PAGE_DOWN
+35-END
+36-HOME
+37-ARROW_LEFT
+38-ARROW_UP
+39-ARROW_RIGHT
+40-ARROW_DOWN
+41-
+42-
+43-
+44-
+45-INSERT
+46-DELETE
+47-
+48-0
+49-1
+50-2
+51-3
+52-4
+53-5
+54-6
+55-7
+56-8
+57-9
+58-
+59-SEMICOLON
+60-
+61-EQUAL
+62-
+63-
+64-
+65-a
+66-b
+67-c
+68-d
+69-e
+70-f
+71-g
+72-h
+73-i
+74-j
+75-k
+76-l
+77-m
+78-n
+79-o
+80-p
+81-q
+82-r
+83-s
+84-t
+85-u
+86-v
+87-w
+88-x
+89-
+90-z
+91-
+92-
+93-
+94-
+95-
+96-
+97-
+98-
+99-
+100-
+101-
+102-
+103-
+106-
+107-
+108-
+109-
+110-
+111-
+112-FUNCTION_1
+113-FUNCTION_2
+114-FUNCTION_3
+115-FUNCTION_4
+116-FUNCTION_5
+117-FUNCTION_6
+118-FUNCTION_7
+119-FUNCTION_8
+120-FUNCTION_9
+121-FUNCTION_10
+122-FUNCTION_11
+123-FUNCTION_12
+124-
+125-
+126-
+127-
+128-
+129-
+130-
+131-
+132-
+134-
+135-
+136-
+137-
+138-
+139-
+140-
+141-
+142-
+143-
+145-SCROLL_LOCK
+146-
+147-
+148-
+149-
+150-
+151-
+152-
+153-
+154-
+155-
+156-
+157-
+158-
+159-
+160-
+161-
+162-
+163-
+164-
+165-
+166-
+167-
+168-
+169-
+170-
+171-
+172-
+173-MINUS
+174-
+175-
+176-
+177-
+178-
+179-
+180-
+181-
+182-
+183-
+184-
+185-
+186-
+187-
+188-COMMA
+189-
+190-PERIOD
+191-FORWARD_SLASH
+192-GRAVE
+193-
+194-
+195-
+196-
+197-
+198-
+199-
+200-
+201-
+202-
+203-
+204-
+205-
+206-
+207-
+208-
+209-
+210-
+211-
+212-
+213-
+214-
+215-
+216-
+218-
+219-BRACKET_LEFT
+220-BACK_SLASH
+221-BRACKET_RIGHT
+222-QUOTE
+223-
+224-
+225-
+226-
+227-
+228-
+229-
+230-
+231-
+232-
+233-
+234-
+235-
+236-
+237-
+238-
+239-
+240-
+241-
+242-
+243-
+244-
+245-
+246-
+247-
+248-
+249-
+250-
+251-
+252-
+253-
+254-
+255-
diff --git a/ableos/notes/NOTES.md b/ableos/notes/NOTES.md
new file mode 100644
index 0000000..59da4d3
--- /dev/null
+++ b/ableos/notes/NOTES.md
@@ -0,0 +1,9 @@
+Don't keep piling on API shit
+Good docs are a must!!!!!!!!!!!!
+No Bloat
+One thing One Way
+Bloat makes M!nt sad
+Have rust-like strings only
+
+# Don't
+memory gun
diff --git a/ableos/notes/USER.md b/ableos/notes/USER.md
new file mode 100644
index 0000000..6e755fa
--- /dev/null
+++ b/ableos/notes/USER.md
@@ -0,0 +1,3 @@
+user
+> execute
+> file system
diff --git a/ableos/rust-toolchain b/ableos/rust-toolchain
new file mode 100644
index 0000000..bf867e0
--- /dev/null
+++ b/ableos/rust-toolchain
@@ -0,0 +1 @@
+nightly
diff --git a/ableos/shitty_code_to_rewrite/shutdown.rs b/ableos/shitty_code_to_rewrite/shutdown.rs
new file mode 100644
index 0000000..3514d1b
--- /dev/null
+++ b/ableos/shitty_code_to_rewrite/shutdown.rs
@@ -0,0 +1,27 @@
+#[repr(C)]
+pub struct ShutterDowner {
+ smi_cmd: u32,
+ acpi_enable: u8,
+ acpi_disable: u8,
+ pm1a_cnt: u32,
+ pm1b_cnt: u32,
+ slp_typa: u16,
+ slp_typb: u16,
+ slp_en: u16,
+ scii_en: u16,
+ pm1_cnt_len: u8,
+}
+
+pub structRSDPtr {
+ signature: [u8; 8],
+ checksum: u8,
+ oem_id: [u8; 6],
+ revision: u8,
+ rsdt_address: u32,
+}
+
+struct FACP {
+ signature: [u8; 4],
+ length: u32,
+
+}
\ No newline at end of file
diff --git a/ableos/shitty_code_to_rewrite/shutdown_in_c.c b/ableos/shitty_code_to_rewrite/shutdown_in_c.c
new file mode 100644
index 0000000..84fa838
--- /dev/null
+++ b/ableos/shitty_code_to_rewrite/shutdown_in_c.c
@@ -0,0 +1,302 @@
+// //
+// // here is the slighlty complicated ACPI poweroff code
+// //
+
+#include <stddef.h>
+#include <print.h>
+#include <string.h>
+#include <io.h>
+#include <time.h>
+
+dword *SMI_CMD;
+byte ACPI_ENABLE;
+byte ACPI_DISABLE;
+dword *PM1a_CNT;
+dword *PM1b_CNT;
+word SLP_TYPa;
+word SLP_TYPb;
+word SLP_EN;
+word SCI_EN;
+byte PM1_CNT_LEN;
+
+struct RSDPtr
+{
+ byte Signature[8];
+ byte CheckSum;
+ byte OemID[6];
+ byte Revision;
+ dword *RsdtAddress;
+};
+
+struct FACP
+{
+ byte Signature[4];
+ dword Length;
+ byte unneded1[40 - 8];
+ dword *DSDT;
+ byte unneded2[48 - 44];
+ dword *SMI_CMD;
+ byte ACPI_ENABLE;
+ byte ACPI_DISABLE;
+ byte unneded3[64 - 54];
+ dword *PM1a_CNT_BLK;
+ dword *PM1b_CNT_BLK;
+ byte unneded4[89 - 72];
+ byte PM1_CNT_LEN;
+};
+
+// check if the given address has a valid header
+unsigned int *acpiCheckRSDPtr(unsigned int *ptr)
+{
+ char *sig = "RSD PTR ";
+ struct RSDPtr *rsdp = (struct RSDPtr *)ptr;
+ byte *bptr;
+ byte check = 0;
+ int i;
+
+ if (memcmp(sig, rsdp, 8) == 0)
+ {
+ // check checksum rsdpd
+ bptr = (byte *)ptr;
+ for (i = 0; i < sizeof(struct RSDPtr); i++)
+ {
+ check += *bptr;
+ bptr++;
+ }
+
+ // found valid rsdpd
+ if (check == 0)
+ {
+ /*
+ if (desc->Revision == 0)
+ wrstr("acpi 1");
+ else
+ wrstr("acpi 2");
+ */
+ return (unsigned int *)rsdp->RsdtAddress;
+ }
+ }
+
+ return NULL;
+}
+
+// finds the acpi header and returns the address of the rsdt
+unsigned int *acpiGetRSDPtr(void)
+{
+ unsigned int *addr;
+ unsigned int *rsdp;
+
+ // search below the 1mb mark for RSDP signature
+ for (addr = (unsigned int *)0x000E0000; (int)addr < 0x00100000; addr += 0x10 / sizeof(addr))
+ {
+ rsdp = acpiCheckRSDPtr(addr);
+ if (rsdp != NULL)
+ return rsdp;
+ }
+
+ // at address 0x40:0x0E is the RM segment of the ebda
+ int ebda = *((short *)0x40E); // get pointer
+ ebda = ebda * 0x10 & 0x000FFFFF; // transform segment into linear address
+
+ // search Extended BIOS Data Area for the Root System Description Pointer signature
+ for (addr = (unsigned int *)ebda; (int)addr < ebda + 1024; addr += 0x10 / sizeof(addr))
+ {
+ rsdp = acpiCheckRSDPtr(addr);
+ if (rsdp != NULL)
+ return rsdp;
+ }
+
+ return NULL;
+}
+
+// checks for a given header and validates checksum
+int acpiCheckHeader(unsigned int *ptr, char *sig)
+{
+ if (memcmp(ptr, sig, 4) == 0)
+ {
+ char *checkPtr = (char *)ptr;
+ int len = *(ptr + 1);
+ char check = 0;
+ while (0 < len--)
+ {
+ check += *checkPtr;
+ checkPtr++;
+ }
+ if (check == 0)
+ return 0;
+ }
+ return -1;
+}
+
+int acpiEnable(void)
+{
+ // check if acpi is enabled
+ if ((inw((unsigned int)PM1a_CNT) & SCI_EN) == 0)
+ {
+ // check if acpi can be enabled
+ if (SMI_CMD != 0 && ACPI_ENABLE != 0)
+ {
+ outb((unsigned int)SMI_CMD, ACPI_ENABLE); // send acpi enable command
+ // give 3 seconds time to enable acpi
+ int i;
+ for (i = 0; i < 300; i++)
+ {
+ if ((inw((unsigned int)PM1a_CNT) & SCI_EN) == 1)
+ break;
+ sleep(10);
+ }
+ if (PM1b_CNT != 0)
+ for (; i < 300; i++)
+ {
+ if ((inw((unsigned int)PM1b_CNT) & SCI_EN) == 1)
+ break;
+ sleep(10);
+ }
+ if (i < 300)
+ {
+ wrstr("enabled acpi.\n");
+ return 0;
+ }
+ else
+ {
+ wrstr("couldn't enable acpi.\n");
+ return -1;
+ }
+ }
+ else
+ {
+ wrstr("no known way to enable acpi.\n");
+ return -1;
+ }
+ }
+ else
+ {
+ //wrstr("acpi was already enabled.\n");
+ return 0;
+ }
+}
+
+//
+// bytecode of the \_S5 object
+// -----------------------------------------
+// | (optional) | | | |
+// NameOP | \ | _ | S | 5 | _
+// 08 | 5A | 5F | 53 | 35 | 5F
+//
+// -----------------------------------------------------------------------------------------------------------
+// | | | ( SLP_TYPa ) | ( SLP_TYPb ) | ( Reserved ) | (Reserved )
+// PackageOP | PkgLength | NumElements | byteprefix Num | byteprefix Num | byteprefix Num | byteprefix Num
+// 12 | 0A | 04 | 0A 05 | 0A 05 | 0A 05 | 0A 05
+//
+//----this-structure-was-also-seen----------------------
+// PackageOP | PkgLength | NumElements |
+// 12 | 06 | 04 | 00 00 00 00
+//
+// (Pkglength bit 6-7 encode additional PkgLength bytes [shouldn't be the case here])
+//
+int initAcpi(void)
+{
+ unsigned int *ptr = acpiGetRSDPtr();
+
+ // check if address is correct ( if acpi is available on this pc )
+ if (ptr != NULL && acpiCheckHeader(ptr, "RSDT") == 0)
+ {
+ // the RSDT contains an unknown number of pointers to acpi tables
+ int entrys = *(ptr + 1);
+ entrys = (entrys - 36) / 4;
+ ptr += 36 / 4; // skip header information
+
+ while (0 < entrys--)
+ {
+ // check if the desired table is reached
+ if (acpiCheckHeader((unsigned int *)*ptr, "FACP") == 0)
+ {
+ entrys = -2;
+ struct FACP *facp = (struct FACP *)*ptr;
+ if (acpiCheckHeader((unsigned int *)facp->DSDT, "DSDT") == 0)
+ {
+ // search the \_S5 package in the DSDT
+ char *S5Addr = (char *)facp->DSDT + 36; // skip header
+ int dsdtLength = *(facp->DSDT + 1) - 36;
+ while (0 < dsdtLength--)
+ {
+ if (memcmp(S5Addr, "_S5_", 4) == 0)
+ break;
+ S5Addr++;
+ }
+ // check if \_S5 was found
+ if (dsdtLength > 0)
+ {
+ // check for valid AML structure
+ if ((*(S5Addr - 1) == 0x08 || (*(S5Addr - 2) == 0x08 && *(S5Addr - 1) == '\\')) && *(S5Addr + 4) == 0x12)
+ {
+ S5Addr += 5;
+ // calculate PkgLength size
+ S5Addr += ((*S5Addr &0xC0)>>6) +2;
+
+ if (*S5Addr == 0x0A)
+ S5Addr++; // skip byteprefix
+ SLP_TYPa = *(S5Addr) << 10;
+ S5Addr++;
+
+ if (*S5Addr == 0x0A)
+ S5Addr++; // skip byteprefix
+ SLP_TYPb = *(S5Addr) << 10;
+
+ SMI_CMD = facp->SMI_CMD;
+
+ ACPI_ENABLE = facp->ACPI_ENABLE;
+ ACPI_DISABLE = facp->ACPI_DISABLE;
+
+ PM1a_CNT = facp->PM1a_CNT_BLK;
+ PM1b_CNT = facp->PM1b_CNT_BLK;
+
+ PM1_CNT_LEN = facp->PM1_CNT_LEN;
+
+ SLP_EN = 1 << 13;
+ SCI_EN = 1;
+
+ return 0;
+ }
+ else
+ {
+ wrstr("\\_S5 parse error.\n");
+ }
+ }
+ else
+ {
+ wrstr("\\_S5 not present.\n");
+ }
+ }
+ else
+ {
+ wrstr("DSDT invalid.\n");
+ }
+ }
+ ptr++;
+ }
+ wrstr("no valid FACP present.\n");
+ }
+ else
+ {
+ wrstr("no acpi.\n");
+ }
+
+ return -1;
+}
+
+void acpiPowerOff(void)
+{
+ // SCI_EN is set to 1 if acpi shutdown is possible
+ if (SCI_EN == 0)
+ return;
+
+ acpiEnable();
+
+ // send the shutdown command
+ outw((unsigned int)PM1a_CNT, SLP_TYPa | SLP_EN);
+ if (PM1b_CNT != 0)
+ outw((unsigned int)PM1b_CNT, SLP_TYPb | SLP_EN);
+
+ wrstr("acpi poweroff failed.\n");
+}
diff --git a/ableos/shitty_code_to_rewrite/signal.c b/ableos/shitty_code_to_rewrite/signal.c
new file mode 100644
index 0000000..9b894ac
--- /dev/null
+++ b/ableos/shitty_code_to_rewrite/signal.c
@@ -0,0 +1,4947 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * linux/kernel/signal.c
+ *
+ * Copyright (C) 1991, 1992 Linus Torvalds
+ *
+ * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
+ *
+ * 2003-06-02 Jim Houston - Concurrent Computer Corp.
+ * Changes to use preallocated sigqueue structures
+ * to allow signals to be sent reliably.
+ */
+
+#include <linux/slab.h>
+#include <linux/export.h>
+#include <linux/init.h>
+#include <linux/sched/mm.h>
+#include <linux/sched/user.h>
+#include <linux/sched/debug.h>
+#include <linux/sched/task.h>
+#include <linux/sched/task_stack.h>
+#include <linux/sched/cputime.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/proc_fs.h>
+#include <linux/tty.h>
+#include <linux/binfmts.h>
+#include <linux/coredump.h>
+#include <linux/security.h>
+#include <linux/syscalls.h>
+#include <linux/ptrace.h>
+#include <linux/signal.h>
+#include <linux/signalfd.h>
+#include <linux/ratelimit.h>
+#include <linux/tracehook.h>
+#include <linux/capability.h>
+#include <linux/freezer.h>
+#include <linux/pid_namespace.h>
+#include <linux/nsproxy.h>
+#include <linux/user_namespace.h>
+#include <linux/uprobes.h>
+#include <linux/compat.h>
+#include <linux/cn_proc.h>
+#include <linux/compiler.h>
+#include <linux/posix-timers.h>
+#include <linux/cgroup.h>
+#include <linux/audit.h>
+
+#define CREATE_TRACE_POINTS
+#include <trace/events/signal.h>
+
+#include <asm/param.h>
+#include <linux/uaccess.h>
+#include <asm/unistd.h>
+#include <asm/siginfo.h>
+#include <asm/cacheflush.h>
+#include <asm/syscall.h> /* for syscall_get_* */
+
+/*
+ * SLAB caches for signal bits.
+ */
+
+static struct kmem_cache *sigqueue_cachep;
+
+int print_fatal_signals __read_mostly;
+
+static void __user *sig_handler(struct task_struct *t, int sig)
+{
+ return t->sighand->action[sig - 1].sa.sa_handler;
+}
+
+static inline bool sig_handler_ignored(void __user *handler, int sig)
+{
+ /* Is it explicitly or implicitly ignored? */
+ return handler == SIG_IGN ||
+ (handler == SIG_DFL && sig_kernel_ignore(sig));
+}
+
+static bool sig_task_ignored(struct task_struct *t, int sig, bool force)
+{
+ void __user *handler;
+
+ handler = sig_handler(t, sig);
+
+ /* SIGKILL and SIGSTOP may not be sent to the global init */
+ if (unlikely(is_global_init(t) && sig_kernel_only(sig)))
+ return true;
+
+ if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
+ handler == SIG_DFL && !(force && sig_kernel_only(sig)))
+ return true;
+
+ /* Only allow kernel generated signals to this kthread */
+ if (unlikely((t->flags & PF_KTHREAD) &&
+ (handler == SIG_KTHREAD_KERNEL) && !force))
+ return true;
+
+ return sig_handler_ignored(handler, sig);
+}
+
+static bool sig_ignored(struct task_struct *t, int sig, bool force)
+{
+ /*
+ * Blocked signals are never ignored, since the
+ * signal handler may change by the time it is
+ * unblocked.
+ */
+ if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
+ return false;
+
+ /*
+ * Tracers may want to know about even ignored signal unless it
+ * is SIGKILL which can't be reported anyway but can be ignored
+ * by SIGNAL_UNKILLABLE task.
+ */
+ if (t->ptrace && sig != SIGKILL)
+ return false;
+
+ return sig_task_ignored(t, sig, force);
+}
+
+/*
+ * Re-calculate pending state from the set of locally pending
+ * signals, globally pending signals, and blocked signals.
+ */
+static inline bool has_pending_signals(sigset_t *signal, sigset_t *blocked)
+{
+ unsigned long ready;
+ long i;
+
+ switch (_NSIG_WORDS)
+ {
+ default:
+ for (i = _NSIG_WORDS, ready = 0; --i >= 0;)
+ ready |= signal->sig[i] & ~blocked->sig[i];
+ break;
+
+ case 4:
+ ready = signal->sig[3] & ~blocked->sig[3];
+ ready |= signal->sig[2] & ~blocked->sig[2];
+ ready |= signal->sig[1] & ~blocked->sig[1];
+ ready |= signal->sig[0] & ~blocked->sig[0];
+ break;
+
+ case 2:
+ ready = signal->sig[1] & ~blocked->sig[1];
+ ready |= signal->sig[0] & ~blocked->sig[0];
+ break;
+
+ case 1:
+ ready = signal->sig[0] & ~blocked->sig[0];
+ }
+ return ready != 0;
+}
+
+#define PENDING(p, b) has_pending_signals(&(p)->signal, (b))
+
+static bool recalc_sigpending_tsk(struct task_struct *t)
+{
+ if ((t->jobctl & (JOBCTL_PENDING_MASK | JOBCTL_TRAP_FREEZE)) ||
+ PENDING(&t->pending, &t->blocked) ||
+ PENDING(&t->signal->shared_pending, &t->blocked) ||
+ cgroup_task_frozen(t))
+ {
+ set_tsk_thread_flag(t, TIF_SIGPENDING);
+ return true;
+ }
+
+ /*
+ * We must never clear the flag in another thread, or in current
+ * when it's possible the current syscall is returning -ERESTART*.
+ * So we don't clear it here, and only callers who know they should do.
+ */
+ return false;
+}
+
+/*
+ * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
+ * This is superfluous when called on current, the wakeup is a harmless no-op.
+ */
+void recalc_sigpending_and_wake(struct task_struct *t)
+{
+ if (recalc_sigpending_tsk(t))
+ signal_wake_up(t, 0);
+}
+
+void recalc_sigpending(void)
+{
+ if (!recalc_sigpending_tsk(current) && !freezing(current))
+ clear_thread_flag(TIF_SIGPENDING);
+}
+EXPORT_SYMBOL(recalc_sigpending);
+
+void calculate_sigpending(void)
+{
+ /* Have any signals or users of TIF_SIGPENDING been delayed
+ * until after fork?
+ */
+ spin_lock_irq(¤t->sighand->siglock);
+ set_tsk_thread_flag(current, TIF_SIGPENDING);
+ recalc_sigpending();
+ spin_unlock_irq(¤t->sighand->siglock);
+}
+
+/* Given the mask, find the first available signal that should be serviced. */
+
+#define SYNCHRONOUS_MASK \
+ (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
+ sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
+
+int next_signal(struct sigpending *pending, sigset_t *mask)
+{
+ unsigned long i, *s, *m, x;
+ int sig = 0;
+
+ s = pending->signal.sig;
+ m = mask->sig;
+
+ /*
+ * Handle the first word specially: it contains the
+ * synchronous signals that need to be dequeued first.
+ */
+ x = *s & ~*m;
+ if (x)
+ {
+ if (x & SYNCHRONOUS_MASK)
+ x &= SYNCHRONOUS_MASK;
+ sig = ffz(~x) + 1;
+ return sig;
+ }
+
+ switch (_NSIG_WORDS)
+ {
+ default:
+ for (i = 1; i < _NSIG_WORDS; ++i)
+ {
+ x = *++s & ~*++m;
+ if (!x)
+ continue;
+ sig = ffz(~x) + i * _NSIG_BPW + 1;
+ break;
+ }
+ break;
+
+ case 2:
+ x = s[1] & ~m[1];
+ if (!x)
+ break;
+ sig = ffz(~x) + _NSIG_BPW + 1;
+ break;
+
+ case 1:
+ /* Nothing to do */
+ break;
+ }
+
+ return sig;
+}
+
+static inline void print_dropped_signal(int sig)
+{
+ static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
+
+ if (!print_fatal_signals)
+ return;
+
+ if (!__ratelimit(&ratelimit_state))
+ return;
+
+ pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
+ current->comm, current->pid, sig);
+}
+
+/**
+ * task_set_jobctl_pending - set jobctl pending bits
+ * @task: target task
+ * @mask: pending bits to set
+ *
+ * Clear @mask from @task->jobctl. @mask must be subset of
+ * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
+ * %JOBCTL_TRAPPING. If stop signo is being set, the existing signo is
+ * cleared. If @task is already being killed or exiting, this function
+ * becomes noop.
+ *
+ * CONTEXT:
+ * Must be called with @task->sighand->siglock held.
+ *
+ * RETURNS:
+ * %true if @mask is set, %false if made noop because @task was dying.
+ */
+bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
+{
+ BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
+ JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
+ BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
+
+ if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
+ return false;
+
+ if (mask & JOBCTL_STOP_SIGMASK)
+ task->jobctl &= ~JOBCTL_STOP_SIGMASK;
+
+ task->jobctl |= mask;
+ return true;
+}
+
+/**
+ * task_clear_jobctl_trapping - clear jobctl trapping bit
+ * @task: target task
+ *
+ * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
+ * Clear it and wake up the ptracer. Note that we don't need any further
+ * locking. @task->siglock guarantees that @task->parent points to the
+ * ptracer.
+ *
+ * CONTEXT:
+ * Must be called with @task->sighand->siglock held.
+ */
+void task_clear_jobctl_trapping(struct task_struct *task)
+{
+ if (unlikely(task->jobctl & JOBCTL_TRAPPING))
+ {
+ task->jobctl &= ~JOBCTL_TRAPPING;
+ smp_mb(); /* advised by wake_up_bit() */
+ wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
+ }
+}
+
+/**
+ * task_clear_jobctl_pending - clear jobctl pending bits
+ * @task: target task
+ * @mask: pending bits to clear
+ *
+ * Clear @mask from @task->jobctl. @mask must be subset of
+ * %JOBCTL_PENDING_MASK. If %JOBCTL_STOP_PENDING is being cleared, other
+ * STOP bits are cleared together.
+ *
+ * If clearing of @mask leaves no stop or trap pending, this function calls
+ * task_clear_jobctl_trapping().
+ *
+ * CONTEXT:
+ * Must be called with @task->sighand->siglock held.
+ */
+void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
+{
+ BUG_ON(mask & ~JOBCTL_PENDING_MASK);
+
+ if (mask & JOBCTL_STOP_PENDING)
+ mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
+
+ task->jobctl &= ~mask;
+
+ if (!(task->jobctl & JOBCTL_PENDING_MASK))
+ task_clear_jobctl_trapping(task);
+}
+
+/**
+ * task_participate_group_stop - participate in a group stop
+ * @task: task participating in a group stop
+ *
+ * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
+ * Group stop states are cleared and the group stop count is consumed if
+ * %JOBCTL_STOP_CONSUME was set. If the consumption completes the group
+ * stop, the appropriate `SIGNAL_*` flags are set.
+ *
+ * CONTEXT:
+ * Must be called with @task->sighand->siglock held.
+ *
+ * RETURNS:
+ * %true if group stop completion should be notified to the parent, %false
+ * otherwise.
+ */
+static bool task_participate_group_stop(struct task_struct *task)
+{
+ struct signal_struct *sig = task->signal;
+ bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
+
+ WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
+
+ task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
+
+ if (!consume)
+ return false;
+
+ if (!WARN_ON_ONCE(sig->group_stop_count == 0))
+ sig->group_stop_count--;
+
+ /*
+ * Tell the caller to notify completion iff we are entering into a
+ * fresh group stop. Read comment in do_signal_stop() for details.
+ */
+ if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED))
+ {
+ signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED);
+ return true;
+ }
+ return false;
+}
+
+void task_join_group_stop(struct task_struct *task)
+{
+ unsigned long mask = current->jobctl & JOBCTL_STOP_SIGMASK;
+ struct signal_struct *sig = current->signal;
+
+ if (sig->group_stop_count)
+ {
+ sig->group_stop_count++;
+ mask |= JOBCTL_STOP_CONSUME;
+ }
+ else if (!(sig->flags & SIGNAL_STOP_STOPPED))
+ return;
+
+ /* Have the new thread join an on-going signal group stop */
+ task_set_jobctl_pending(task, mask | JOBCTL_STOP_PENDING);
+}
+
+/*
+ * allocate a new signal queue record
+ * - this may be called without locks if and only if t == current, otherwise an
+ * appropriate lock must be held to stop the target task from exiting
+ */
+static struct sigqueue *
+__sigqueue_alloc(int sig, struct task_struct *t, gfp_t gfp_flags,
+ int override_rlimit, const unsigned int sigqueue_flags)
+{
+ struct sigqueue *q = NULL;
+ struct ucounts *ucounts = NULL;
+ long sigpending;
+
+ /*
+ * Protect access to @t credentials. This can go away when all
+ * callers hold rcu read lock.
+ *
+ * NOTE! A pending signal will hold on to the user refcount,
+ * and we get/put the refcount only when the sigpending count
+ * changes from/to zero.
+ */
+ rcu_read_lock();
+ ucounts = task_ucounts(t);
+ sigpending = inc_rlimit_get_ucounts(ucounts, UCOUNT_RLIMIT_SIGPENDING);
+ rcu_read_unlock();
+ if (!sigpending)
+ return NULL;
+
+ if (override_rlimit || likely(sigpending <= task_rlimit(t, RLIMIT_SIGPENDING)))
+ {
+ q = kmem_cache_alloc(sigqueue_cachep, gfp_flags);
+ }
+ else
+ {
+ print_dropped_signal(sig);
+ }
+
+ if (unlikely(q == NULL))
+ {
+ dec_rlimit_put_ucounts(ucounts, UCOUNT_RLIMIT_SIGPENDING);
+ }
+ else
+ {
+ INIT_LIST_HEAD(&q->list);
+ q->flags = sigqueue_flags;
+ q->ucounts = ucounts;
+ }
+ return q;
+}
+
+static void __sigqueue_free(struct sigqueue *q)
+{
+ if (q->flags & SIGQUEUE_PREALLOC)
+ return;
+ if (q->ucounts)
+ {
+ dec_rlimit_put_ucounts(q->ucounts, UCOUNT_RLIMIT_SIGPENDING);
+ q->ucounts = NULL;
+ }
+ kmem_cache_free(sigqueue_cachep, q);
+}
+
+void flush_sigqueue(struct sigpending *queue)
+{
+ struct sigqueue *q;
+
+ sigemptyset(&queue->signal);
+ while (!list_empty(&queue->list))
+ {
+ q = list_entry(queue->list.next, struct sigqueue, list);
+ list_del_init(&q->list);
+ __sigqueue_free(q);
+ }
+}
+
+/*
+ * Flush all pending signals for this kthread.
+ */
+void flush_signals(struct task_struct *t)
+{
+ unsigned long flags;
+
+ spin_lock_irqsave(&t->sighand->siglock, flags);
+ clear_tsk_thread_flag(t, TIF_SIGPENDING);
+ flush_sigqueue(&t->pending);
+ flush_sigqueue(&t->signal->shared_pending);
+ spin_unlock_irqrestore(&t->sighand->siglock, flags);
+}
+EXPORT_SYMBOL(flush_signals);
+
+#ifdef CONFIG_POSIX_TIMERS
+static void __flush_itimer_signals(struct sigpending *pending)
+{
+ sigset_t signal, retain;
+ struct sigqueue *q, *n;
+
+ signal = pending->signal;
+ sigemptyset(&retain);
+
+ list_for_each_entry_safe(q, n, &pending->list, list)
+ {
+ int sig = q->info.si_signo;
+
+ if (likely(q->info.si_code != SI_TIMER))
+ {
+ sigaddset(&retain, sig);
+ }
+ else
+ {
+ sigdelset(&signal, sig);
+ list_del_init(&q->list);
+ __sigqueue_free(q);
+ }
+ }
+
+ sigorsets(&pending->signal, &signal, &retain);
+}
+
+void flush_itimer_signals(void)
+{
+ struct task_struct *tsk = current;
+ unsigned long flags;
+
+ spin_lock_irqsave(&tsk->sighand->siglock, flags);
+ __flush_itimer_signals(&tsk->pending);
+ __flush_itimer_signals(&tsk->signal->shared_pending);
+ spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
+}
+#endif
+
+void ignore_signals(struct task_struct *t)
+{
+ int i;
+
+ for (i = 0; i < _NSIG; ++i)
+ t->sighand->action[i].sa.sa_handler = SIG_IGN;
+
+ flush_signals(t);
+}
+
+/*
+ * Flush all handlers for a task.
+ */
+
+void flush_signal_handlers(struct task_struct *t, int force_default)
+{
+ int i;
+ struct k_sigaction *ka = &t->sighand->action[0];
+ for (i = _NSIG; i != 0; i--)
+ {
+ if (force_default || ka->sa.sa_handler != SIG_IGN)
+ ka->sa.sa_handler = SIG_DFL;
+ ka->sa.sa_flags = 0;
+#ifdef __ARCH_HAS_SA_RESTORER
+ ka->sa.sa_restorer = NULL;
+#endif
+ sigemptyset(&ka->sa.sa_mask);
+ ka++;
+ }
+}
+
+bool unhandled_signal(struct task_struct *tsk, int sig)
+{
+ void __user *handler = tsk->sighand->action[sig - 1].sa.sa_handler;
+ if (is_global_init(tsk))
+ return true;
+
+ if (handler != SIG_IGN && handler != SIG_DFL)
+ return false;
+
+ /* if ptraced, let the tracer determine */
+ return !tsk->ptrace;
+}
+
+static void collect_signal(int sig, struct sigpending *list, kernel_siginfo_t *info,
+ bool *resched_timer)
+{
+ struct sigqueue *q, *first = NULL;
+
+ /*
+ * Collect the siginfo appropriate to this signal. Check if
+ * there is another siginfo for the same signal.
+ */
+ list_for_each_entry(q, &list->list, list)
+ {
+ if (q->info.si_signo == sig)
+ {
+ if (first)
+ goto still_pending;
+ first = q;
+ }
+ }
+
+ sigdelset(&list->signal, sig);
+
+ if (first)
+ {
+ still_pending:
+ list_del_init(&first->list);
+ copy_siginfo(info, &first->info);
+
+ *resched_timer =
+ (first->flags & SIGQUEUE_PREALLOC) &&
+ (info->si_code == SI_TIMER) &&
+ (info->si_sys_private);
+
+ __sigqueue_free(first);
+ }
+ else
+ {
+ /*
+ * Ok, it wasn't in the queue. This must be
+ * a fast-pathed signal or we must have been
+ * out of queue space. So zero out the info.
+ */
+ clear_siginfo(info);
+ info->si_signo = sig;
+ info->si_errno = 0;
+ info->si_code = SI_USER;
+ info->si_pid = 0;
+ info->si_uid = 0;
+ }
+}
+
+static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
+ kernel_siginfo_t *info, bool *resched_timer)
+{
+ int sig = next_signal(pending, mask);
+
+ if (sig)
+ collect_signal(sig, pending, info, resched_timer);
+ return sig;
+}
+
+/*
+ * Dequeue a signal and return the element to the caller, which is
+ * expected to free it.
+ *
+ * All callers have to hold the siglock.
+ */
+int dequeue_signal(struct task_struct *tsk, sigset_t *mask, kernel_siginfo_t *info)
+{
+ bool resched_timer = false;
+ int signr;
+
+ /* We only dequeue private signals from ourselves, we don't let
+ * signalfd steal them
+ */
+ signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
+ if (!signr)
+ {
+ signr = __dequeue_signal(&tsk->signal->shared_pending,
+ mask, info, &resched_timer);
+#ifdef CONFIG_POSIX_TIMERS
+ /*
+ * itimer signal ?
+ *
+ * itimers are process shared and we restart periodic
+ * itimers in the signal delivery path to prevent DoS
+ * attacks in the high resolution timer case. This is
+ * compliant with the old way of self-restarting
+ * itimers, as the SIGALRM is a legacy signal and only
+ * queued once. Changing the restart behaviour to
+ * restart the timer in the signal dequeue path is
+ * reducing the timer noise on heavy loaded !highres
+ * systems too.
+ */
+ if (unlikely(signr == SIGALRM))
+ {
+ struct hrtimer *tmr = &tsk->signal->real_timer;
+
+ if (!hrtimer_is_queued(tmr) &&
+ tsk->signal->it_real_incr != 0)
+ {
+ hrtimer_forward(tmr, tmr->base->get_time(),
+ tsk->signal->it_real_incr);
+ hrtimer_restart(tmr);
+ }
+ }
+#endif
+ }
+
+ recalc_sigpending();
+ if (!signr)
+ return 0;
+
+ if (unlikely(sig_kernel_stop(signr)))
+ {
+ /*
+ * Set a marker that we have dequeued a stop signal. Our
+ * caller might release the siglock and then the pending
+ * stop signal it is about to process is no longer in the
+ * pending bitmasks, but must still be cleared by a SIGCONT
+ * (and overruled by a SIGKILL). So those cases clear this
+ * shared flag after we've set it. Note that this flag may
+ * remain set after the signal we return is ignored or
+ * handled. That doesn't matter because its only purpose
+ * is to alert stop-signal processing code when another
+ * processor has come along and cleared the flag.
+ */
+ current->jobctl |= JOBCTL_STOP_DEQUEUED;
+ }
+#ifdef CONFIG_POSIX_TIMERS
+ if (resched_timer)
+ {
+ /*
+ * Release the siglock to ensure proper locking order
+ * of timer locks outside of siglocks. Note, we leave
+ * irqs disabled here, since the posix-timers code is
+ * about to disable them again anyway.
+ */
+ spin_unlock(&tsk->sighand->siglock);
+ posixtimer_rearm(info);
+ spin_lock(&tsk->sighand->siglock);
+
+ /* Don't expose the si_sys_private value to userspace */
+ info->si_sys_private = 0;
+ }
+#endif
+ return signr;
+}
+EXPORT_SYMBOL_GPL(dequeue_signal);
+
+static int dequeue_synchronous_signal(kernel_siginfo_t *info)
+{
+ struct task_struct *tsk = current;
+ struct sigpending *pending = &tsk->pending;
+ struct sigqueue *q, *sync = NULL;
+
+ /*
+ * Might a synchronous signal be in the queue?
+ */
+ if (!((pending->signal.sig[0] & ~tsk->blocked.sig[0]) & SYNCHRONOUS_MASK))
+ return 0;
+
+ /*
+ * Return the first synchronous signal in the queue.
+ */
+ list_for_each_entry(q, &pending->list, list)
+ {
+ /* Synchronous signals have a positive si_code */
+ if ((q->info.si_code > SI_USER) &&
+ (sigmask(q->info.si_signo) & SYNCHRONOUS_MASK))
+ {
+ sync = q;
+ goto next;
+ }
+ }
+ return 0;
+next:
+ /*
+ * Check if there is another siginfo for the same signal.
+ */
+ list_for_each_entry_continue(q, &pending->list, list)
+ {
+ if (q->info.si_signo == sync->info.si_signo)
+ goto still_pending;
+ }
+
+ sigdelset(&pending->signal, sync->info.si_signo);
+ recalc_sigpending();
+still_pending:
+ list_del_init(&sync->list);
+ copy_siginfo(info, &sync->info);
+ __sigqueue_free(sync);
+ return info->si_signo;
+}
+
+/*
+ * Tell a process that it has a new active signal..
+ *
+ * NOTE! we rely on the previous spin_lock to
+ * lock interrupts for us! We can only be called with
+ * "siglock" held, and the local interrupt must
+ * have been disabled when that got acquired!
+ *
+ * No need to set need_resched since signal event passing
+ * goes through ->blocked
+ */
+void signal_wake_up_state(struct task_struct *t, unsigned int state)
+{
+ set_tsk_thread_flag(t, TIF_SIGPENDING);
+ /*
+ * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
+ * case. We don't check t->state here because there is a race with it
+ * executing another processor and just now entering stopped state.
+ * By using wake_up_state, we ensure the process will wake up and
+ * handle its death signal.
+ */
+ if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
+ kick_process(t);
+}
+
+/*
+ * Remove signals in mask from the pending set and queue.
+ * Returns 1 if any signals were found.
+ *
+ * All callers must be holding the siglock.
+ */
+static void flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
+{
+ struct sigqueue *q, *n;
+ sigset_t m;
+
+ sigandsets(&m, mask, &s->signal);
+ if (sigisemptyset(&m))
+ return;
+
+ sigandnsets(&s->signal, &s->signal, mask);
+ list_for_each_entry_safe(q, n, &s->list, list)
+ {
+ if (sigismember(mask, q->info.si_signo))
+ {
+ list_del_init(&q->list);
+ __sigqueue_free(q);
+ }
+ }
+}
+
+static inline int is_si_special(const struct kernel_siginfo *info)
+{
+ return info <= SEND_SIG_PRIV;
+}
+
+static inline bool si_fromuser(const struct kernel_siginfo *info)
+{
+ return info == SEND_SIG_NOINFO ||
+ (!is_si_special(info) && SI_FROMUSER(info));
+}
+
+/*
+ * called with RCU read lock from check_kill_permission()
+ */
+static bool kill_ok_by_cred(struct task_struct *t)
+{
+ const struct cred *cred = current_cred();
+ const struct cred *tcred = __task_cred(t);
+
+ return uid_eq(cred->euid, tcred->suid) ||
+ uid_eq(cred->euid, tcred->uid) ||
+ uid_eq(cred->uid, tcred->suid) ||
+ uid_eq(cred->uid, tcred->uid) ||
+ ns_capable(tcred->user_ns, CAP_KILL);
+}
+
+/*
+ * Bad permissions for sending the signal
+ * - the caller must hold the RCU read lock
+ */
+static int check_kill_permission(int sig, struct kernel_siginfo *info,
+ struct task_struct *t)
+{
+ struct pid *sid;
+ int error;
+
+ if (!valid_signal(sig))
+ return -EINVAL;
+
+ if (!si_fromuser(info))
+ return 0;
+
+ error = audit_signal_info(sig, t); /* Let audit system see the signal */
+ if (error)
+ return error;
+
+ if (!same_thread_group(current, t) &&
+ !kill_ok_by_cred(t))
+ {
+ switch (sig)
+ {
+ case SIGCONT:
+ sid = task_session(t);
+ /*
+ * We don't return the error if sid == NULL. The
+ * task was unhashed, the caller must notice this.
+ */
+ if (!sid || sid == task_session(current))
+ break;
+ fallthrough;
+ default:
+ return -EPERM;
+ }
+ }
+
+ return security_task_kill(t, info, sig, NULL);
+}
+
+/**
+ * ptrace_trap_notify - schedule trap to notify ptracer
+ * @t: tracee wanting to notify tracer
+ *
+ * This function schedules sticky ptrace trap which is cleared on the next
+ * TRAP_STOP to notify ptracer of an event. @t must have been seized by
+ * ptracer.
+ *
+ * If @t is running, STOP trap will be taken. If trapped for STOP and
+ * ptracer is listening for events, tracee is woken up so that it can
+ * re-trap for the new event. If trapped otherwise, STOP trap will be
+ * eventually taken without returning to userland after the existing traps
+ * are finished by PTRACE_CONT.
+ *
+ * CONTEXT:
+ * Must be called with @task->sighand->siglock held.
+ */
+static void ptrace_trap_notify(struct task_struct *t)
+{
+ WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
+ assert_spin_locked(&t->sighand->siglock);
+
+ task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
+ ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
+}
+
+/*
+ * Handle magic process-wide effects of stop/continue signals. Unlike
+ * the signal actions, these happen immediately at signal-generation
+ * time regardless of blocking, ignoring, or handling. This does the
+ * actual continuing for SIGCONT, but not the actual stopping for stop
+ * signals. The process stop is done as a signal action for SIG_DFL.
+ *
+ * Returns true if the signal should be actually delivered, otherwise
+ * it should be dropped.
+ */
+static bool prepare_signal(int sig, struct task_struct *p, bool force)
+{
+ struct signal_struct *signal = p->signal;
+ struct task_struct *t;
+ sigset_t flush;
+
+ if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP))
+ {
+ if (!(signal->flags & SIGNAL_GROUP_EXIT))
+ return sig == SIGKILL;
+ /*
+ * The process is in the middle of dying, nothing to do.
+ */
+ }
+ else if (sig_kernel_stop(sig))
+ {
+ /*
+ * This is a stop signal. Remove SIGCONT from all queues.
+ */
+ siginitset(&flush, sigmask(SIGCONT));
+ flush_sigqueue_mask(&flush, &signal->shared_pending);
+ for_each_thread(p, t)
+ flush_sigqueue_mask(&flush, &t->pending);
+ }
+ else if (sig == SIGCONT)
+ {
+ unsigned int why;
+ /*
+ * Remove all stop signals from all queues, wake all threads.
+ */
+ siginitset(&flush, SIG_KERNEL_STOP_MASK);
+ flush_sigqueue_mask(&flush, &signal->shared_pending);
+ for_each_thread(p, t)
+ {
+ flush_sigqueue_mask(&flush, &t->pending);
+ task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
+ if (likely(!(t->ptrace & PT_SEIZED)))
+ wake_up_state(t, __TASK_STOPPED);
+ else
+ ptrace_trap_notify(t);
+ }
+
+ /*
+ * Notify the parent with CLD_CONTINUED if we were stopped.
+ *
+ * If we were in the middle of a group stop, we pretend it
+ * was already finished, and then continued. Since SIGCHLD
+ * doesn't queue we report only CLD_STOPPED, as if the next
+ * CLD_CONTINUED was dropped.
+ */
+ why = 0;
+ if (signal->flags & SIGNAL_STOP_STOPPED)
+ why |= SIGNAL_CLD_CONTINUED;
+ else if (signal->group_stop_count)
+ why |= SIGNAL_CLD_STOPPED;
+
+ if (why)
+ {
+ /*
+ * The first thread which returns from do_signal_stop()
+ * will take ->siglock, notice SIGNAL_CLD_MASK, and
+ * notify its parent. See get_signal().
+ */
+ signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED);
+ signal->group_stop_count = 0;
+ signal->group_exit_code = 0;
+ }
+ }
+
+ return !sig_ignored(p, sig, force);
+}
+
+/*
+ * Test if P wants to take SIG. After we've checked all threads with this,
+ * it's equivalent to finding no threads not blocking SIG. Any threads not
+ * blocking SIG were ruled out because they are not running and already
+ * have pending signals. Such threads will dequeue from the shared queue
+ * as soon as they're available, so putting the signal on the shared queue
+ * will be equivalent to sending it to one such thread.
+ */
+static inline bool wants_signal(int sig, struct task_struct *p)
+{
+ if (sigismember(&p->blocked, sig))
+ return false;
+
+ if (p->flags & PF_EXITING)
+ return false;
+
+ if (sig == SIGKILL)
+ return true;
+
+ if (task_is_stopped_or_traced(p))
+ return false;
+
+ return task_curr(p) || !task_sigpending(p);
+}
+
+static void complete_signal(int sig, struct task_struct *p, enum pid_type type)
+{
+ struct signal_struct *signal = p->signal;
+ struct task_struct *t;
+
+ /*
+ * Now find a thread we can wake up to take the signal off the queue.
+ *
+ * If the main thread wants the signal, it gets first crack.
+ * Probably the least surprising to the average bear.
+ */
+ if (wants_signal(sig, p))
+ t = p;
+ else if ((type == PIDTYPE_PID) || thread_group_empty(p))
+ /*
+ * There is just one thread and it does not need to be woken.
+ * It will dequeue unblocked signals before it runs again.
+ */
+ return;
+ else
+ {
+ /*
+ * Otherwise try to find a suitable thread.
+ */
+ t = signal->curr_target;
+ while (!wants_signal(sig, t))
+ {
+ t = next_thread(t);
+ if (t == signal->curr_target)
+ /*
+ * No thread needs to be woken.
+ * Any eligible threads will see
+ * the signal in the queue soon.
+ */
+ return;
+ }
+ signal->curr_target = t;
+ }
+
+ /*
+ * Found a killable thread. If the signal will be fatal,
+ * then start taking the whole group down immediately.
+ */
+ if (sig_fatal(p, sig) &&
+ !(signal->flags & SIGNAL_GROUP_EXIT) &&
+ !sigismember(&t->real_blocked, sig) &&
+ (sig == SIGKILL || !p->ptrace))
+ {
+ /*
+ * This signal will be fatal to the whole group.
+ */
+ if (!sig_kernel_coredump(sig))
+ {
+ /*
+ * Start a group exit and wake everybody up.
+ * This way we don't have other threads
+ * running and doing things after a slower
+ * thread has the fatal signal pending.
+ */
+ signal->flags = SIGNAL_GROUP_EXIT;
+ signal->group_exit_code = sig;
+ signal->group_stop_count = 0;
+ t = p;
+ do
+ {
+ task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
+ sigaddset(&t->pending.signal, SIGKILL);
+ signal_wake_up(t, 1);
+ }
+ while_each_thread(p, t);
+ return;
+ }
+ }
+
+ /*
+ * The signal is already in the shared-pending queue.
+ * Tell the chosen thread to wake up and dequeue it.
+ */
+ signal_wake_up(t, sig == SIGKILL);
+ return;
+}
+
+static inline bool legacy_queue(struct sigpending *signals, int sig)
+{
+ return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
+}
+
+static int __send_signal(int sig, struct kernel_siginfo *info, struct task_struct *t,
+ enum pid_type type, bool force)
+{
+ struct sigpending *pending;
+ struct sigqueue *q;
+ int override_rlimit;
+ int ret = 0, result;
+
+ assert_spin_locked(&t->sighand->siglock);
+
+ result = TRACE_SIGNAL_IGNORED;
+ if (!prepare_signal(sig, t, force))
+ goto ret;
+
+ pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
+ /*
+ * Short-circuit ignored signals and support queuing
+ * exactly one non-rt signal, so that we can get more
+ * detailed information about the cause of the signal.
+ */
+ result = TRACE_SIGNAL_ALREADY_PENDING;
+ if (legacy_queue(pending, sig))
+ goto ret;
+
+ result = TRACE_SIGNAL_DELIVERED;
+ /*
+ * Skip useless siginfo allocation for SIGKILL and kernel threads.
+ */
+ if ((sig == SIGKILL) || (t->flags & PF_KTHREAD))
+ goto out_set;
+
+ /*
+ * Real-time signals must be queued if sent by sigqueue, or
+ * some other real-time mechanism. It is implementation
+ * defined whether kill() does so. We attempt to do so, on
+ * the principle of least surprise, but since kill is not
+ * allowed to fail with EAGAIN when low on memory we just
+ * make sure at least one signal gets delivered and don't
+ * pass on the info struct.
+ */
+ if (sig < SIGRTMIN)
+ override_rlimit = (is_si_special(info) || info->si_code >= 0);
+ else
+ override_rlimit = 0;
+
+ q = __sigqueue_alloc(sig, t, GFP_ATOMIC, override_rlimit, 0);
+
+ if (q)
+ {
+ list_add_tail(&q->list, &pending->list);
+ switch ((unsigned long)info)
+ {
+ case (unsigned long)SEND_SIG_NOINFO:
+ clear_siginfo(&q->info);
+ q->info.si_signo = sig;
+ q->info.si_errno = 0;
+ q->info.si_code = SI_USER;
+ q->info.si_pid = task_tgid_nr_ns(current,
+ task_active_pid_ns(t));
+ rcu_read_lock();
+ q->info.si_uid =
+ from_kuid_munged(task_cred_xxx(t, user_ns),
+ current_uid());
+ rcu_read_unlock();
+ break;
+ case (unsigned long)SEND_SIG_PRIV:
+ clear_siginfo(&q->info);
+ q->info.si_signo = sig;
+ q->info.si_errno = 0;
+ q->info.si_code = SI_KERNEL;
+ q->info.si_pid = 0;
+ q->info.si_uid = 0;
+ break;
+ default:
+ copy_siginfo(&q->info, info);
+ break;
+ }
+ }
+ else if (!is_si_special(info) &&
+ sig >= SIGRTMIN && info->si_code != SI_USER)
+ {
+ /*
+ * Queue overflow, abort. We may abort if the
+ * signal was rt and sent by user using something
+ * other than kill().
+ */
+ result = TRACE_SIGNAL_OVERFLOW_FAIL;
+ ret = -EAGAIN;
+ goto ret;
+ }
+ else
+ {
+ /*
+ * This is a silent loss of information. We still
+ * send the signal, but the *info bits are lost.
+ */
+ result = TRACE_SIGNAL_LOSE_INFO;
+ }
+
+out_set:
+ signalfd_notify(t, sig);
+ sigaddset(&pending->signal, sig);
+
+ /* Let multiprocess signals appear after on-going forks */
+ if (type > PIDTYPE_TGID)
+ {
+ struct multiprocess_signals *delayed;
+ hlist_for_each_entry(delayed, &t->signal->multiprocess, node)
+ {
+ sigset_t *signal = &delayed->signal;
+ /* Can't queue both a stop and a continue signal */
+ if (sig == SIGCONT)
+ sigdelsetmask(signal, SIG_KERNEL_STOP_MASK);
+ else if (sig_kernel_stop(sig))
+ sigdelset(signal, SIGCONT);
+ sigaddset(signal, sig);
+ }
+ }
+
+ complete_signal(sig, t, type);
+ret:
+ trace_signal_generate(sig, info, t, type != PIDTYPE_PID, result);
+ return ret;
+}
+
+static inline bool has_si_pid_and_uid(struct kernel_siginfo *info)
+{
+ bool ret = false;
+ switch (siginfo_layout(info->si_signo, info->si_code))
+ {
+ case SIL_KILL:
+ case SIL_CHLD:
+ case SIL_RT:
+ ret = true;
+ break;
+ case SIL_TIMER:
+ case SIL_POLL:
+ case SIL_FAULT:
+ case SIL_FAULT_TRAPNO:
+ case SIL_FAULT_MCEERR:
+ case SIL_FAULT_BNDERR:
+ case SIL_FAULT_PKUERR:
+ case SIL_FAULT_PERF_EVENT:
+ case SIL_SYS:
+ ret = false;
+ break;
+ }
+ return ret;
+}
+
+static int send_signal(int sig, struct kernel_siginfo *info, struct task_struct *t,
+ enum pid_type type)
+{
+ /* Should SIGKILL or SIGSTOP be received by a pid namespace init? */
+ bool force = false;
+
+ if (info == SEND_SIG_NOINFO)
+ {
+ /* Force if sent from an ancestor pid namespace */
+ force = !task_pid_nr_ns(current, task_active_pid_ns(t));
+ }
+ else if (info == SEND_SIG_PRIV)
+ {
+ /* Don't ignore kernel generated signals */
+ force = true;
+ }
+ else if (has_si_pid_and_uid(info))
+ {
+ /* SIGKILL and SIGSTOP is special or has ids */
+ struct user_namespace *t_user_ns;
+
+ rcu_read_lock();
+ t_user_ns = task_cred_xxx(t, user_ns);
+ if (current_user_ns() != t_user_ns)
+ {
+ kuid_t uid = make_kuid(current_user_ns(), info->si_uid);
+ info->si_uid = from_kuid_munged(t_user_ns, uid);
+ }
+ rcu_read_unlock();
+
+ /* A kernel generated signal? */
+ force = (info->si_code == SI_KERNEL);
+
+ /* From an ancestor pid namespace? */
+ if (!task_pid_nr_ns(current, task_active_pid_ns(t)))
+ {
+ info->si_pid = 0;
+ force = true;
+ }
+ }
+ return __send_signal(sig, info, t, type, force);
+}
+
+static void print_fatal_signal(int signr)
+{
+ struct pt_regs *regs = signal_pt_regs();
+ pr_info("potentially unexpected fatal signal %d.\n", signr);
+
+#if defined(__i386__) && !defined(__arch_um__)
+ pr_info("code at %08lx: ", regs->ip);
+ {
+ int i;
+ for (i = 0; i < 16; i++)
+ {
+ unsigned char insn;
+
+ if (get_user(insn, (unsigned char *)(regs->ip + i)))
+ break;
+ pr_cont("%02x ", insn);
+ }
+ }
+ pr_cont("\n");
+#endif
+ preempt_disable();
+ show_regs(regs);
+ preempt_enable();
+}
+
+static int __init setup_print_fatal_signals(char *str)
+{
+ get_option(&str, &print_fatal_signals);
+
+ return 1;
+}
+
+__setup("print-fatal-signals=", setup_print_fatal_signals);
+
+int __group_send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p)
+{
+ return send_signal(sig, info, p, PIDTYPE_TGID);
+}
+
+int do_send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p,
+ enum pid_type type)
+{
+ unsigned long flags;
+ int ret = -ESRCH;
+
+ if (lock_task_sighand(p, &flags))
+ {
+ ret = send_signal(sig, info, p, type);
+ unlock_task_sighand(p, &flags);
+ }
+
+ return ret;
+}
+
+/*
+ * Force a signal that the process can't ignore: if necessary
+ * we unblock the signal and change any SIG_IGN to SIG_DFL.
+ *
+ * Note: If we unblock the signal, we always reset it to SIG_DFL,
+ * since we do not want to have a signal handler that was blocked
+ * be invoked when user space had explicitly blocked it.
+ *
+ * We don't want to have recursive SIGSEGV's etc, for example,
+ * that is why we also clear SIGNAL_UNKILLABLE.
+ */
+static int
+force_sig_info_to_task(struct kernel_siginfo *info, struct task_struct *t, bool sigdfl)
+{
+ unsigned long int flags;
+ int ret, blocked, ignored;
+ struct k_sigaction *action;
+ int sig = info->si_signo;
+
+ spin_lock_irqsave(&t->sighand->siglock, flags);
+ action = &t->sighand->action[sig - 1];
+ ignored = action->sa.sa_handler == SIG_IGN;
+ blocked = sigismember(&t->blocked, sig);
+ if (blocked || ignored || sigdfl)
+ {
+ action->sa.sa_handler = SIG_DFL;
+ action->sa.sa_flags |= SA_IMMUTABLE;
+ if (blocked)
+ {
+ sigdelset(&t->blocked, sig);
+ recalc_sigpending_and_wake(t);
+ }
+ }
+ /*
+ * Don't clear SIGNAL_UNKILLABLE for traced tasks, users won't expect
+ * debugging to leave init killable.
+ */
+ if (action->sa.sa_handler == SIG_DFL && !t->ptrace)
+ t->signal->flags &= ~SIGNAL_UNKILLABLE;
+ ret = send_signal(sig, info, t, PIDTYPE_PID);
+ spin_unlock_irqrestore(&t->sighand->siglock, flags);
+
+ return ret;
+}
+
+int force_sig_info(struct kernel_siginfo *info)
+{
+ return force_sig_info_to_task(info, current, false);
+}
+
+/*
+ * Nuke all other threads in the group.
+ */
+int zap_other_threads(struct task_struct *p)
+{
+ struct task_struct *t = p;
+ int count = 0;
+
+ p->signal->group_stop_count = 0;
+
+ while_each_thread(p, t)
+ {
+ task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
+ count++;
+
+ /* Don't bother with already dead threads */
+ if (t->exit_state)
+ continue;
+ sigaddset(&t->pending.signal, SIGKILL);
+ signal_wake_up(t, 1);
+ }
+
+ return count;
+}
+
+struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
+ unsigned long *flags)
+{
+ struct sighand_struct *sighand;
+
+ rcu_read_lock();
+ for (;;)
+ {
+ sighand = rcu_dereference(tsk->sighand);
+ if (unlikely(sighand == NULL))
+ break;
+
+ /*
+ * This sighand can be already freed and even reused, but
+ * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which
+ * initializes ->siglock: this slab can't go away, it has
+ * the same object type, ->siglock can't be reinitialized.
+ *
+ * We need to ensure that tsk->sighand is still the same
+ * after we take the lock, we can race with de_thread() or
+ * __exit_signal(). In the latter case the next iteration
+ * must see ->sighand == NULL.
+ */
+ spin_lock_irqsave(&sighand->siglock, *flags);
+ if (likely(sighand == rcu_access_pointer(tsk->sighand)))
+ break;
+ spin_unlock_irqrestore(&sighand->siglock, *flags);
+ }
+ rcu_read_unlock();
+
+ return sighand;
+}
+
+#ifdef CONFIG_LOCKDEP
+void lockdep_assert_task_sighand_held(struct task_struct *task)
+{
+ struct sighand_struct *sighand;
+
+ rcu_read_lock();
+ sighand = rcu_dereference(task->sighand);
+ if (sighand)
+ lockdep_assert_held(&sighand->siglock);
+ else
+ WARN_ON_ONCE(1);
+ rcu_read_unlock();
+}
+#endif
+
+/*
+ * send signal info to all the members of a group
+ */
+int group_send_sig_info(int sig, struct kernel_siginfo *info,
+ struct task_struct *p, enum pid_type type)
+{
+ int ret;
+
+ rcu_read_lock();
+ ret = check_kill_permission(sig, info, p);
+ rcu_read_unlock();
+
+ if (!ret && sig)
+ ret = do_send_sig_info(sig, info, p, type);
+
+ return ret;
+}
+
+/*
+ * __kill_pgrp_info() sends a signal to a process group: this is what the tty
+ * control characters do (^C, ^Z etc)
+ * - the caller must hold at least a readlock on tasklist_lock
+ */
+int __kill_pgrp_info(int sig, struct kernel_siginfo *info, struct pid *pgrp)
+{
+ struct task_struct *p = NULL;
+ int retval, success;
+
+ success = 0;
+ retval = -ESRCH;
+ do_each_pid_task(pgrp, PIDTYPE_PGID, p)
+ {
+ int err = group_send_sig_info(sig, info, p, PIDTYPE_PGID);
+ success |= !err;
+ retval = err;
+ }
+ while_each_pid_task(pgrp, PIDTYPE_PGID, p);
+ return success ? 0 : retval;
+}
+
+int kill_pid_info(int sig, struct kernel_siginfo *info, struct pid *pid)
+{
+ int error = -ESRCH;
+ struct task_struct *p;
+
+ for (;;)
+ {
+ rcu_read_lock();
+ p = pid_task(pid, PIDTYPE_PID);
+ if (p)
+ error = group_send_sig_info(sig, info, p, PIDTYPE_TGID);
+ rcu_read_unlock();
+ if (likely(!p || error != -ESRCH))
+ return error;
+
+ /*
+ * The task was unhashed in between, try again. If it
+ * is dead, pid_task() will return NULL, if we race with
+ * de_thread() it will find the new leader.
+ */
+ }
+}
+
+static int kill_proc_info(int sig, struct kernel_siginfo *info, pid_t pid)
+{
+ int error;
+ rcu_read_lock();
+ error = kill_pid_info(sig, info, find_vpid(pid));
+ rcu_read_unlock();
+ return error;
+}
+
+static inline bool kill_as_cred_perm(const struct cred *cred,
+ struct task_struct *target)
+{
+ const struct cred *pcred = __task_cred(target);
+
+ return uid_eq(cred->euid, pcred->suid) ||
+ uid_eq(cred->euid, pcred->uid) ||
+ uid_eq(cred->uid, pcred->suid) ||
+ uid_eq(cred->uid, pcred->uid);
+}
+
+/*
+ * The usb asyncio usage of siginfo is wrong. The glibc support
+ * for asyncio which uses SI_ASYNCIO assumes the layout is SIL_RT.
+ * AKA after the generic fields:
+ * kernel_pid_t si_pid;
+ * kernel_uid32_t si_uid;
+ * sigval_t si_value;
+ *
+ * Unfortunately when usb generates SI_ASYNCIO it assumes the layout
+ * after the generic fields is:
+ * void __user *si_addr;
+ *
+ * This is a practical problem when there is a 64bit big endian kernel
+ * and a 32bit userspace. As the 32bit address will encoded in the low
+ * 32bits of the pointer. Those low 32bits will be stored at higher
+ * address than appear in a 32 bit pointer. So userspace will not
+ * see the address it was expecting for it's completions.
+ *
+ * There is nothing in the encoding that can allow
+ * copy_siginfo_to_user32 to detect this confusion of formats, so
+ * handle this by requiring the caller of kill_pid_usb_asyncio to
+ * notice when this situration takes place and to store the 32bit
+ * pointer in sival_int, instead of sival_addr of the sigval_t addr
+ * parameter.
+ */
+int kill_pid_usb_asyncio(int sig, int errno, sigval_t addr,
+ struct pid *pid, const struct cred *cred)
+{
+ struct kernel_siginfo info;
+ struct task_struct *p;
+ unsigned long flags;
+ int ret = -EINVAL;
+
+ if (!valid_signal(sig))
+ return ret;
+
+ clear_siginfo(&info);
+ info.si_signo = sig;
+ info.si_errno = errno;
+ info.si_code = SI_ASYNCIO;
+ *((sigval_t *)&info.si_pid) = addr;
+
+ rcu_read_lock();
+ p = pid_task(pid, PIDTYPE_PID);
+ if (!p)
+ {
+ ret = -ESRCH;
+ goto out_unlock;
+ }
+ if (!kill_as_cred_perm(cred, p))
+ {
+ ret = -EPERM;
+ goto out_unlock;
+ }
+ ret = security_task_kill(p, &info, sig, cred);
+ if (ret)
+ goto out_unlock;
+
+ if (sig)
+ {
+ if (lock_task_sighand(p, &flags))
+ {
+ ret = __send_signal(sig, &info, p, PIDTYPE_TGID, false);
+ unlock_task_sighand(p, &flags);
+ }
+ else
+ ret = -ESRCH;
+ }
+out_unlock:
+ rcu_read_unlock();
+ return ret;
+}
+EXPORT_SYMBOL_GPL(kill_pid_usb_asyncio);
+
+/*
+ * kill_something_info() interprets pid in interesting ways just like kill(2).
+ *
+ * POSIX specifies that kill(-1,sig) is unspecified, but what we have
+ * is probably wrong. Should make it like BSD or SYSV.
+ */
+
+static int kill_something_info(int sig, struct kernel_siginfo *info, pid_t pid)
+{
+ int ret;
+
+ if (pid > 0)
+ return kill_proc_info(sig, info, pid);
+
+ /* -INT_MIN is undefined. Exclude this case to avoid a UBSAN warning */
+ if (pid == INT_MIN)
+ return -ESRCH;
+
+ read_lock(&tasklist_lock);
+ if (pid != -1)
+ {
+ ret = __kill_pgrp_info(sig, info,
+ pid ? find_vpid(-pid) : task_pgrp(current));
+ }
+ else
+ {
+ int retval = 0, count = 0;
+ struct task_struct *p;
+
+ for_each_process(p)
+ {
+ if (task_pid_vnr(p) > 1 &&
+ !same_thread_group(p, current))
+ {
+ int err = group_send_sig_info(sig, info, p,
+ PIDTYPE_MAX);
+ ++count;
+ if (err != -EPERM)
+ retval = err;
+ }
+ }
+ ret = count ? retval : -ESRCH;
+ }
+ read_unlock(&tasklist_lock);
+
+ return ret;
+}
+
+/*
+ * These are for backward compatibility with the rest of the kernel source.
+ */
+
+int send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p)
+{
+ /*
+ * Make sure legacy kernel users don't send in bad values
+ * (normal paths check this in check_kill_permission).
+ */
+ if (!valid_signal(sig))
+ return -EINVAL;
+
+ return do_send_sig_info(sig, info, p, PIDTYPE_PID);
+}
+EXPORT_SYMBOL(send_sig_info);
+
+#define __si_special(priv) \
+ ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
+
+int send_sig(int sig, struct task_struct *p, int priv)
+{
+ return send_sig_info(sig, __si_special(priv), p);
+}
+EXPORT_SYMBOL(send_sig);
+
+void force_sig(int sig)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = sig;
+ info.si_errno = 0;
+ info.si_code = SI_KERNEL;
+ info.si_pid = 0;
+ info.si_uid = 0;
+ force_sig_info(&info);
+}
+EXPORT_SYMBOL(force_sig);
+
+void force_fatal_sig(int sig)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = sig;
+ info.si_errno = 0;
+ info.si_code = SI_KERNEL;
+ info.si_pid = 0;
+ info.si_uid = 0;
+ force_sig_info_to_task(&info, current, true);
+}
+
+/*
+ * When things go south during signal handling, we
+ * will force a SIGSEGV. And if the signal that caused
+ * the problem was already a SIGSEGV, we'll want to
+ * make sure we don't even try to deliver the signal..
+ */
+void force_sigsegv(int sig)
+{
+ if (sig == SIGSEGV)
+ force_fatal_sig(SIGSEGV);
+ else
+ force_sig(SIGSEGV);
+}
+
+int force_sig_fault_to_task(int sig, int code, void __user *addr ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr), struct task_struct *t)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = sig;
+ info.si_errno = 0;
+ info.si_code = code;
+ info.si_addr = addr;
+#ifdef __ia64__
+ info.si_imm = imm;
+ info.si_flags = flags;
+ info.si_isr = isr;
+#endif
+ return force_sig_info_to_task(&info, t, false);
+}
+
+int force_sig_fault(int sig, int code, void __user *addr ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr))
+{
+ return force_sig_fault_to_task(sig, code, addr ___ARCH_SI_IA64(imm, flags, isr), current);
+}
+
+int send_sig_fault(int sig, int code, void __user *addr ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr), struct task_struct *t)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = sig;
+ info.si_errno = 0;
+ info.si_code = code;
+ info.si_addr = addr;
+#ifdef __ia64__
+ info.si_imm = imm;
+ info.si_flags = flags;
+ info.si_isr = isr;
+#endif
+ return send_sig_info(info.si_signo, &info, t);
+}
+
+int force_sig_mceerr(int code, void __user *addr, short lsb)
+{
+ struct kernel_siginfo info;
+
+ WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
+ clear_siginfo(&info);
+ info.si_signo = SIGBUS;
+ info.si_errno = 0;
+ info.si_code = code;
+ info.si_addr = addr;
+ info.si_addr_lsb = lsb;
+ return force_sig_info(&info);
+}
+
+int send_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct *t)
+{
+ struct kernel_siginfo info;
+
+ WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
+ clear_siginfo(&info);
+ info.si_signo = SIGBUS;
+ info.si_errno = 0;
+ info.si_code = code;
+ info.si_addr = addr;
+ info.si_addr_lsb = lsb;
+ return send_sig_info(info.si_signo, &info, t);
+}
+EXPORT_SYMBOL(send_sig_mceerr);
+
+int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = SIGSEGV;
+ info.si_errno = 0;
+ info.si_code = SEGV_BNDERR;
+ info.si_addr = addr;
+ info.si_lower = lower;
+ info.si_upper = upper;
+ return force_sig_info(&info);
+}
+
+#ifdef SEGV_PKUERR
+int force_sig_pkuerr(void __user *addr, u32 pkey)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = SIGSEGV;
+ info.si_errno = 0;
+ info.si_code = SEGV_PKUERR;
+ info.si_addr = addr;
+ info.si_pkey = pkey;
+ return force_sig_info(&info);
+}
+#endif
+
+int force_sig_perf(void __user *addr, u32 type, u64 sig_data)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = SIGTRAP;
+ info.si_errno = 0;
+ info.si_code = TRAP_PERF;
+ info.si_addr = addr;
+ info.si_perf_data = sig_data;
+ info.si_perf_type = type;
+
+ return force_sig_info(&info);
+}
+
+/**
+ * force_sig_seccomp - signals the task to allow in-process syscall emulation
+ * @syscall: syscall number to send to userland
+ * @reason: filter-supplied reason code to send to userland (via si_errno)
+ *
+ * Forces a SIGSYS with a code of SYS_SECCOMP and related sigsys info.
+ */
+int force_sig_seccomp(int syscall, int reason, bool force_coredump)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = SIGSYS;
+ info.si_code = SYS_SECCOMP;
+ info.si_call_addr = (void __user *)KSTK_EIP(current);
+ info.si_errno = reason;
+ info.si_arch = syscall_get_arch(current);
+ info.si_syscall = syscall;
+ return force_sig_info_to_task(&info, current, force_coredump);
+}
+
+/* For the crazy architectures that include trap information in
+ * the errno field, instead of an actual errno value.
+ */
+int force_sig_ptrace_errno_trap(int errno, void __user *addr)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = SIGTRAP;
+ info.si_errno = errno;
+ info.si_code = TRAP_HWBKPT;
+ info.si_addr = addr;
+ return force_sig_info(&info);
+}
+
+/* For the rare architectures that include trap information using
+ * si_trapno.
+ */
+int force_sig_fault_trapno(int sig, int code, void __user *addr, int trapno)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = sig;
+ info.si_errno = 0;
+ info.si_code = code;
+ info.si_addr = addr;
+ info.si_trapno = trapno;
+ return force_sig_info(&info);
+}
+
+/* For the rare architectures that include trap information using
+ * si_trapno.
+ */
+int send_sig_fault_trapno(int sig, int code, void __user *addr, int trapno,
+ struct task_struct *t)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = sig;
+ info.si_errno = 0;
+ info.si_code = code;
+ info.si_addr = addr;
+ info.si_trapno = trapno;
+ return send_sig_info(info.si_signo, &info, t);
+}
+
+int kill_pgrp(struct pid *pid, int sig, int priv)
+{
+ int ret;
+
+ read_lock(&tasklist_lock);
+ ret = __kill_pgrp_info(sig, __si_special(priv), pid);
+ read_unlock(&tasklist_lock);
+
+ return ret;
+}
+EXPORT_SYMBOL(kill_pgrp);
+
+int kill_pid(struct pid *pid, int sig, int priv)
+{
+ return kill_pid_info(sig, __si_special(priv), pid);
+}
+EXPORT_SYMBOL(kill_pid);
+
+/*
+ * These functions support sending signals using preallocated sigqueue
+ * structures. This is needed "because realtime applications cannot
+ * afford to lose notifications of asynchronous events, like timer
+ * expirations or I/O completions". In the case of POSIX Timers
+ * we allocate the sigqueue structure from the timer_create. If this
+ * allocation fails we are able to report the failure to the application
+ * with an EAGAIN error.
+ */
+struct sigqueue *sigqueue_alloc(void)
+{
+ return __sigqueue_alloc(-1, current, GFP_KERNEL, 0, SIGQUEUE_PREALLOC);
+}
+
+void sigqueue_free(struct sigqueue *q)
+{
+ unsigned long flags;
+ spinlock_t *lock = ¤t->sighand->siglock;
+
+ BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
+ /*
+ * We must hold ->siglock while testing q->list
+ * to serialize with collect_signal() or with
+ * __exit_signal()->flush_sigqueue().
+ */
+ spin_lock_irqsave(lock, flags);
+ q->flags &= ~SIGQUEUE_PREALLOC;
+ /*
+ * If it is queued it will be freed when dequeued,
+ * like the "regular" sigqueue.
+ */
+ if (!list_empty(&q->list))
+ q = NULL;
+ spin_unlock_irqrestore(lock, flags);
+
+ if (q)
+ __sigqueue_free(q);
+}
+
+int send_sigqueue(struct sigqueue *q, struct pid *pid, enum pid_type type)
+{
+ int sig = q->info.si_signo;
+ struct sigpending *pending;
+ struct task_struct *t;
+ unsigned long flags;
+ int ret, result;
+
+ BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
+
+ ret = -1;
+ rcu_read_lock();
+ t = pid_task(pid, type);
+ if (!t || !likely(lock_task_sighand(t, &flags)))
+ goto ret;
+
+ ret = 1; /* the signal is ignored */
+ result = TRACE_SIGNAL_IGNORED;
+ if (!prepare_signal(sig, t, false))
+ goto out;
+
+ ret = 0;
+ if (unlikely(!list_empty(&q->list)))
+ {
+ /*
+ * If an SI_TIMER entry is already queue just increment
+ * the overrun count.
+ */
+ BUG_ON(q->info.si_code != SI_TIMER);
+ q->info.si_overrun++;
+ result = TRACE_SIGNAL_ALREADY_PENDING;
+ goto out;
+ }
+ q->info.si_overrun = 0;
+
+ signalfd_notify(t, sig);
+ pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
+ list_add_tail(&q->list, &pending->list);
+ sigaddset(&pending->signal, sig);
+ complete_signal(sig, t, type);
+ result = TRACE_SIGNAL_DELIVERED;
+out:
+ trace_signal_generate(sig, &q->info, t, type != PIDTYPE_PID, result);
+ unlock_task_sighand(t, &flags);
+ret:
+ rcu_read_unlock();
+ return ret;
+}
+
+static void do_notify_pidfd(struct task_struct *task)
+{
+ struct pid *pid;
+
+ WARN_ON(task->exit_state == 0);
+ pid = task_pid(task);
+ wake_up_all(&pid->wait_pidfd);
+}
+
+/*
+ * Let a parent know about the death of a child.
+ * For a stopped/continued status change, use do_notify_parent_cldstop instead.
+ *
+ * Returns true if our parent ignored us and so we've switched to
+ * self-reaping.
+ */
+bool do_notify_parent(struct task_struct *tsk, int sig)
+{
+ struct kernel_siginfo info;
+ unsigned long flags;
+ struct sighand_struct *psig;
+ bool autoreap = false;
+ u64 utime, stime;
+
+ BUG_ON(sig == -1);
+
+ /* do_notify_parent_cldstop should have been called instead. */
+ BUG_ON(task_is_stopped_or_traced(tsk));
+
+ BUG_ON(!tsk->ptrace &&
+ (tsk->group_leader != tsk || !thread_group_empty(tsk)));
+
+ /* Wake up all pidfd waiters */
+ do_notify_pidfd(tsk);
+
+ if (sig != SIGCHLD)
+ {
+ /*
+ * This is only possible if parent == real_parent.
+ * Check if it has changed security domain.
+ */
+ if (tsk->parent_exec_id != READ_ONCE(tsk->parent->self_exec_id))
+ sig = SIGCHLD;
+ }
+
+ clear_siginfo(&info);
+ info.si_signo = sig;
+ info.si_errno = 0;
+ /*
+ * We are under tasklist_lock here so our parent is tied to
+ * us and cannot change.
+ *
+ * task_active_pid_ns will always return the same pid namespace
+ * until a task passes through release_task.
+ *
+ * write_lock() currently calls preempt_disable() which is the
+ * same as rcu_read_lock(), but according to Oleg, this is not
+ * correct to rely on this
+ */
+ rcu_read_lock();
+ info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
+ info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
+ task_uid(tsk));
+ rcu_read_unlock();
+
+ task_cputime(tsk, &utime, &stime);
+ info.si_utime = nsec_to_clock_t(utime + tsk->signal->utime);
+ info.si_stime = nsec_to_clock_t(stime + tsk->signal->stime);
+
+ info.si_status = tsk->exit_code & 0x7f;
+ if (tsk->exit_code & 0x80)
+ info.si_code = CLD_DUMPED;
+ else if (tsk->exit_code & 0x7f)
+ info.si_code = CLD_KILLED;
+ else
+ {
+ info.si_code = CLD_EXITED;
+ info.si_status = tsk->exit_code >> 8;
+ }
+
+ psig = tsk->parent->sighand;
+ spin_lock_irqsave(&psig->siglock, flags);
+ if (!tsk->ptrace && sig == SIGCHLD &&
+ (psig->action[SIGCHLD - 1].sa.sa_handler == SIG_IGN ||
+ (psig->action[SIGCHLD - 1].sa.sa_flags & SA_NOCLDWAIT)))
+ {
+ /*
+ * We are exiting and our parent doesn't care. POSIX.1
+ * defines special semantics for setting SIGCHLD to SIG_IGN
+ * or setting the SA_NOCLDWAIT flag: we should be reaped
+ * automatically and not left for our parent's wait4 call.
+ * Rather than having the parent do it as a magic kind of
+ * signal handler, we just set this to tell do_exit that we
+ * can be cleaned up without becoming a zombie. Note that
+ * we still call __wake_up_parent in this case, because a
+ * blocked sys_wait4 might now return -ECHILD.
+ *
+ * Whether we send SIGCHLD or not for SA_NOCLDWAIT
+ * is implementation-defined: we do (if you don't want
+ * it, just use SIG_IGN instead).
+ */
+ autoreap = true;
+ if (psig->action[SIGCHLD - 1].sa.sa_handler == SIG_IGN)
+ sig = 0;
+ }
+ /*
+ * Send with __send_signal as si_pid and si_uid are in the
+ * parent's namespaces.
+ */
+ if (valid_signal(sig) && sig)
+ __send_signal(sig, &info, tsk->parent, PIDTYPE_TGID, false);
+ __wake_up_parent(tsk, tsk->parent);
+ spin_unlock_irqrestore(&psig->siglock, flags);
+
+ return autoreap;
+}
+
+/**
+ * do_notify_parent_cldstop - notify parent of stopped/continued state change
+ * @tsk: task reporting the state change
+ * @for_ptracer: the notification is for ptracer
+ * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
+ *
+ * Notify @tsk's parent that the stopped/continued state has changed. If
+ * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
+ * If %true, @tsk reports to @tsk->parent which should be the ptracer.
+ *
+ * CONTEXT:
+ * Must be called with tasklist_lock at least read locked.
+ */
+static void do_notify_parent_cldstop(struct task_struct *tsk,
+ bool for_ptracer, int why)
+{
+ struct kernel_siginfo info;
+ unsigned long flags;
+ struct task_struct *parent;
+ struct sighand_struct *sighand;
+ u64 utime, stime;
+
+ if (for_ptracer)
+ {
+ parent = tsk->parent;
+ }
+ else
+ {
+ tsk = tsk->group_leader;
+ parent = tsk->real_parent;
+ }
+
+ clear_siginfo(&info);
+ info.si_signo = SIGCHLD;
+ info.si_errno = 0;
+ /*
+ * see comment in do_notify_parent() about the following 4 lines
+ */
+ rcu_read_lock();
+ info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
+ info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
+ rcu_read_unlock();
+
+ task_cputime(tsk, &utime, &stime);
+ info.si_utime = nsec_to_clock_t(utime);
+ info.si_stime = nsec_to_clock_t(stime);
+
+ info.si_code = why;
+ switch (why)
+ {
+ case CLD_CONTINUED:
+ info.si_status = SIGCONT;
+ break;
+ case CLD_STOPPED:
+ info.si_status = tsk->signal->group_exit_code & 0x7f;
+ break;
+ case CLD_TRAPPED:
+ info.si_status = tsk->exit_code & 0x7f;
+ break;
+ default:
+ BUG();
+ }
+
+ sighand = parent->sighand;
+ spin_lock_irqsave(&sighand->siglock, flags);
+ if (sighand->action[SIGCHLD - 1].sa.sa_handler != SIG_IGN &&
+ !(sighand->action[SIGCHLD - 1].sa.sa_flags & SA_NOCLDSTOP))
+ __group_send_sig_info(SIGCHLD, &info, parent);
+ /*
+ * Even if SIGCHLD is not generated, we must wake up wait4 calls.
+ */
+ __wake_up_parent(tsk, parent);
+ spin_unlock_irqrestore(&sighand->siglock, flags);
+}
+
+/*
+ * This must be called with current->sighand->siglock held.
+ *
+ * This should be the path for all ptrace stops.
+ * We always set current->last_siginfo while stopped here.
+ * That makes it a way to test a stopped process for
+ * being ptrace-stopped vs being job-control-stopped.
+ *
+ * If we actually decide not to stop at all because the tracer
+ * is gone, we keep current->exit_code unless clear_code.
+ */
+static void ptrace_stop(int exit_code, int why, int clear_code, kernel_siginfo_t *info)
+ __releases(¤t->sighand->siglock)
+ __acquires(¤t->sighand->siglock)
+{
+ bool gstop_done = false;
+
+ if (arch_ptrace_stop_needed())
+ {
+ /*
+ * The arch code has something special to do before a
+ * ptrace stop. This is allowed to block, e.g. for faults
+ * on user stack pages. We can't keep the siglock while
+ * calling arch_ptrace_stop, so we must release it now.
+ * To preserve proper semantics, we must do this before
+ * any signal bookkeeping like checking group_stop_count.
+ */
+ spin_unlock_irq(¤t->sighand->siglock);
+ arch_ptrace_stop();
+ spin_lock_irq(¤t->sighand->siglock);
+ }
+
+ /*
+ * schedule() will not sleep if there is a pending signal that
+ * can awaken the task.
+ */
+ set_special_state(TASK_TRACED);
+
+ /*
+ * We're committing to trapping. TRACED should be visible before
+ * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
+ * Also, transition to TRACED and updates to ->jobctl should be
+ * atomic with respect to siglock and should be done after the arch
+ * hook as siglock is released and regrabbed across it.
+ *
+ * TRACER TRACEE
+ *
+ * ptrace_attach()
+ * [L] wait_on_bit(JOBCTL_TRAPPING) [S] set_special_state(TRACED)
+ * do_wait()
+ * set_current_state() smp_wmb();
+ * ptrace_do_wait()
+ * wait_task_stopped()
+ * task_stopped_code()
+ * [L] task_is_traced() [S] task_clear_jobctl_trapping();
+ */
+ smp_wmb();
+
+ current->last_siginfo = info;
+ current->exit_code = exit_code;
+
+ /*
+ * If @why is CLD_STOPPED, we're trapping to participate in a group
+ * stop. Do the bookkeeping. Note that if SIGCONT was delievered
+ * across siglock relocks since INTERRUPT was scheduled, PENDING
+ * could be clear now. We act as if SIGCONT is received after
+ * TASK_TRACED is entered - ignore it.
+ */
+ if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
+ gstop_done = task_participate_group_stop(current);
+
+ /* any trap clears pending STOP trap, STOP trap clears NOTIFY */
+ task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
+ if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
+ task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
+
+ /* entering a trap, clear TRAPPING */
+ task_clear_jobctl_trapping(current);
+
+ spin_unlock_irq(¤t->sighand->siglock);
+ read_lock(&tasklist_lock);
+ if (likely(current->ptrace))
+ {
+ /*
+ * Notify parents of the stop.
+ *
+ * While ptraced, there are two parents - the ptracer and
+ * the real_parent of the group_leader. The ptracer should
+ * know about every stop while the real parent is only
+ * interested in the completion of group stop. The states
+ * for the two don't interact with each other. Notify
+ * separately unless they're gonna be duplicates.
+ */
+ do_notify_parent_cldstop(current, true, why);
+ if (gstop_done && ptrace_reparented(current))
+ do_notify_parent_cldstop(current, false, why);
+
+ /*
+ * Don't want to allow preemption here, because
+ * sys_ptrace() needs this task to be inactive.
+ *
+ * XXX: implement read_unlock_no_resched().
+ */
+ preempt_disable();
+ read_unlock(&tasklist_lock);
+ cgroup_enter_frozen();
+ preempt_enable_no_resched();
+ freezable_schedule();
+ cgroup_leave_frozen(true);
+ }
+ else
+ {
+ /*
+ * By the time we got the lock, our tracer went away.
+ * Don't drop the lock yet, another tracer may come.
+ *
+ * If @gstop_done, the ptracer went away between group stop
+ * completion and here. During detach, it would have set
+ * JOBCTL_STOP_PENDING on us and we'll re-enter
+ * TASK_STOPPED in do_signal_stop() on return, so notifying
+ * the real parent of the group stop completion is enough.
+ */
+ if (gstop_done)
+ do_notify_parent_cldstop(current, false, why);
+
+ /* tasklist protects us from ptrace_freeze_traced() */
+ __set_current_state(TASK_RUNNING);
+ if (clear_code)
+ current->exit_code = 0;
+ read_unlock(&tasklist_lock);
+ }
+
+ /*
+ * We are back. Now reacquire the siglock before touching
+ * last_siginfo, so that we are sure to have synchronized with
+ * any signal-sending on another CPU that wants to examine it.
+ */
+ spin_lock_irq(¤t->sighand->siglock);
+ current->last_siginfo = NULL;
+
+ /* LISTENING can be set only during STOP traps, clear it */
+ current->jobctl &= ~JOBCTL_LISTENING;
+
+ /*
+ * Queued signals ignored us while we were stopped for tracing.
+ * So check for any that we should take before resuming user mode.
+ * This sets TIF_SIGPENDING, but never clears it.
+ */
+ recalc_sigpending_tsk(current);
+}
+
+static void ptrace_do_notify(int signr, int exit_code, int why)
+{
+ kernel_siginfo_t info;
+
+ clear_siginfo(&info);
+ info.si_signo = signr;
+ info.si_code = exit_code;
+ info.si_pid = task_pid_vnr(current);
+ info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
+
+ /* Let the debugger run. */
+ ptrace_stop(exit_code, why, 1, &info);
+}
+
+void ptrace_notify(int exit_code)
+{
+ BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
+ if (unlikely(current->task_works))
+ task_work_run();
+
+ spin_lock_irq(¤t->sighand->siglock);
+ ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
+ spin_unlock_irq(¤t->sighand->siglock);
+}
+
+/**
+ * do_signal_stop - handle group stop for SIGSTOP and other stop signals
+ * @signr: signr causing group stop if initiating
+ *
+ * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
+ * and participate in it. If already set, participate in the existing
+ * group stop. If participated in a group stop (and thus slept), %true is
+ * returned with siglock released.
+ *
+ * If ptraced, this function doesn't handle stop itself. Instead,
+ * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
+ * untouched. The caller must ensure that INTERRUPT trap handling takes
+ * places afterwards.
+ *
+ * CONTEXT:
+ * Must be called with @current->sighand->siglock held, which is released
+ * on %true return.
+ *
+ * RETURNS:
+ * %false if group stop is already cancelled or ptrace trap is scheduled.
+ * %true if participated in group stop.
+ */
+static bool do_signal_stop(int signr)
+ __releases(¤t->sighand->siglock)
+{
+ struct signal_struct *sig = current->signal;
+
+ if (!(current->jobctl & JOBCTL_STOP_PENDING))
+ {
+ unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
+ struct task_struct *t;
+
+ /* signr will be recorded in task->jobctl for retries */
+ WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
+
+ if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
+ unlikely(signal_group_exit(sig)))
+ return false;
+ /*
+ * There is no group stop already in progress. We must
+ * initiate one now.
+ *
+ * While ptraced, a task may be resumed while group stop is
+ * still in effect and then receive a stop signal and
+ * initiate another group stop. This deviates from the
+ * usual behavior as two consecutive stop signals can't
+ * cause two group stops when !ptraced. That is why we
+ * also check !task_is_stopped(t) below.
+ *
+ * The condition can be distinguished by testing whether
+ * SIGNAL_STOP_STOPPED is already set. Don't generate
+ * group_exit_code in such case.
+ *
+ * This is not necessary for SIGNAL_STOP_CONTINUED because
+ * an intervening stop signal is required to cause two
+ * continued events regardless of ptrace.
+ */
+ if (!(sig->flags & SIGNAL_STOP_STOPPED))
+ sig->group_exit_code = signr;
+
+ sig->group_stop_count = 0;
+
+ if (task_set_jobctl_pending(current, signr | gstop))
+ sig->group_stop_count++;
+
+ t = current;
+ while_each_thread(current, t)
+ {
+ /*
+ * Setting state to TASK_STOPPED for a group
+ * stop is always done with the siglock held,
+ * so this check has no races.
+ */
+ if (!task_is_stopped(t) &&
+ task_set_jobctl_pending(t, signr | gstop))
+ {
+ sig->group_stop_count++;
+ if (likely(!(t->ptrace & PT_SEIZED)))
+ signal_wake_up(t, 0);
+ else
+ ptrace_trap_notify(t);
+ }
+ }
+ }
+
+ if (likely(!current->ptrace))
+ {
+ int notify = 0;
+
+ /*
+ * If there are no other threads in the group, or if there
+ * is a group stop in progress and we are the last to stop,
+ * report to the parent.
+ */
+ if (task_participate_group_stop(current))
+ notify = CLD_STOPPED;
+
+ set_special_state(TASK_STOPPED);
+ spin_unlock_irq(¤t->sighand->siglock);
+
+ /*
+ * Notify the parent of the group stop completion. Because
+ * we're not holding either the siglock or tasklist_lock
+ * here, ptracer may attach inbetween; however, this is for
+ * group stop and should always be delivered to the real
+ * parent of the group leader. The new ptracer will get
+ * its notification when this task transitions into
+ * TASK_TRACED.
+ */
+ if (notify)
+ {
+ read_lock(&tasklist_lock);
+ do_notify_parent_cldstop(current, false, notify);
+ read_unlock(&tasklist_lock);
+ }
+
+ /* Now we don't run again until woken by SIGCONT or SIGKILL */
+ cgroup_enter_frozen();
+ freezable_schedule();
+ return true;
+ }
+ else
+ {
+ /*
+ * While ptraced, group stop is handled by STOP trap.
+ * Schedule it and let the caller deal with it.
+ */
+ task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
+ return false;
+ }
+}
+
+/**
+ * do_jobctl_trap - take care of ptrace jobctl traps
+ *
+ * When PT_SEIZED, it's used for both group stop and explicit
+ * SEIZE/INTERRUPT traps. Both generate PTRACE_EVENT_STOP trap with
+ * accompanying siginfo. If stopped, lower eight bits of exit_code contain
+ * the stop signal; otherwise, %SIGTRAP.
+ *
+ * When !PT_SEIZED, it's used only for group stop trap with stop signal
+ * number as exit_code and no siginfo.
+ *
+ * CONTEXT:
+ * Must be called with @current->sighand->siglock held, which may be
+ * released and re-acquired before returning with intervening sleep.
+ */
+static void do_jobctl_trap(void)
+{
+ struct signal_struct *signal = current->signal;
+ int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
+
+ if (current->ptrace & PT_SEIZED)
+ {
+ if (!signal->group_stop_count &&
+ !(signal->flags & SIGNAL_STOP_STOPPED))
+ signr = SIGTRAP;
+ WARN_ON_ONCE(!signr);
+ ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
+ CLD_STOPPED);
+ }
+ else
+ {
+ WARN_ON_ONCE(!signr);
+ ptrace_stop(signr, CLD_STOPPED, 0, NULL);
+ current->exit_code = 0;
+ }
+}
+
+/**
+ * do_freezer_trap - handle the freezer jobctl trap
+ *
+ * Puts the task into frozen state, if only the task is not about to quit.
+ * In this case it drops JOBCTL_TRAP_FREEZE.
+ *
+ * CONTEXT:
+ * Must be called with @current->sighand->siglock held,
+ * which is always released before returning.
+ */
+static void do_freezer_trap(void)
+ __releases(¤t->sighand->siglock)
+{
+ /*
+ * If there are other trap bits pending except JOBCTL_TRAP_FREEZE,
+ * let's make another loop to give it a chance to be handled.
+ * In any case, we'll return back.
+ */
+ if ((current->jobctl & (JOBCTL_PENDING_MASK | JOBCTL_TRAP_FREEZE)) !=
+ JOBCTL_TRAP_FREEZE)
+ {
+ spin_unlock_irq(¤t->sighand->siglock);
+ return;
+ }
+
+ /*
+ * Now we're sure that there is no pending fatal signal and no
+ * pending traps. Clear TIF_SIGPENDING to not get out of schedule()
+ * immediately (if there is a non-fatal signal pending), and
+ * put the task into sleep.
+ */
+ __set_current_state(TASK_INTERRUPTIBLE);
+ clear_thread_flag(TIF_SIGPENDING);
+ spin_unlock_irq(¤t->sighand->siglock);
+ cgroup_enter_frozen();
+ freezable_schedule();
+}
+
+static int ptrace_signal(int signr, kernel_siginfo_t *info)
+{
+ /*
+ * We do not check sig_kernel_stop(signr) but set this marker
+ * unconditionally because we do not know whether debugger will
+ * change signr. This flag has no meaning unless we are going
+ * to stop after return from ptrace_stop(). In this case it will
+ * be checked in do_signal_stop(), we should only stop if it was
+ * not cleared by SIGCONT while we were sleeping. See also the
+ * comment in dequeue_signal().
+ */
+ current->jobctl |= JOBCTL_STOP_DEQUEUED;
+ ptrace_stop(signr, CLD_TRAPPED, 0, info);
+
+ /* We're back. Did the debugger cancel the sig? */
+ signr = current->exit_code;
+ if (signr == 0)
+ return signr;
+
+ current->exit_code = 0;
+
+ /*
+ * Update the siginfo structure if the signal has
+ * changed. If the debugger wanted something
+ * specific in the siginfo structure then it should
+ * have updated *info via PTRACE_SETSIGINFO.
+ */
+ if (signr != info->si_signo)
+ {
+ clear_siginfo(info);
+ info->si_signo = signr;
+ info->si_errno = 0;
+ info->si_code = SI_USER;
+ rcu_read_lock();
+ info->si_pid = task_pid_vnr(current->parent);
+ info->si_uid = from_kuid_munged(current_user_ns(),
+ task_uid(current->parent));
+ rcu_read_unlock();
+ }
+
+ /* If the (new) signal is now blocked, requeue it. */
+ if (sigismember(¤t->blocked, signr))
+ {
+ send_signal(signr, info, current, PIDTYPE_PID);
+ signr = 0;
+ }
+
+ return signr;
+}
+
+static void hide_si_addr_tag_bits(struct ksignal *ksig)
+{
+ switch (siginfo_layout(ksig->sig, ksig->info.si_code))
+ {
+ case SIL_FAULT:
+ case SIL_FAULT_TRAPNO:
+ case SIL_FAULT_MCEERR:
+ case SIL_FAULT_BNDERR:
+ case SIL_FAULT_PKUERR:
+ case SIL_FAULT_PERF_EVENT:
+ ksig->info.si_addr = arch_untagged_si_addr(
+ ksig->info.si_addr, ksig->sig, ksig->info.si_code);
+ break;
+ case SIL_KILL:
+ case SIL_TIMER:
+ case SIL_POLL:
+ case SIL_CHLD:
+ case SIL_RT:
+ case SIL_SYS:
+ break;
+ }
+}
+
+bool get_signal(struct ksignal *ksig)
+{
+ struct sighand_struct *sighand = current->sighand;
+ struct signal_struct *signal = current->signal;
+ int signr;
+
+ if (unlikely(current->task_works))
+ task_work_run();
+
+ /*
+ * For non-generic architectures, check for TIF_NOTIFY_SIGNAL so
+ * that the arch handlers don't all have to do it. If we get here
+ * without TIF_SIGPENDING, just exit after running signal work.
+ */
+ if (!IS_ENABLED(CONFIG_GENERIC_ENTRY))
+ {
+ if (test_thread_flag(TIF_NOTIFY_SIGNAL))
+ tracehook_notify_signal();
+ if (!task_sigpending(current))
+ return false;
+ }
+
+ if (unlikely(uprobe_deny_signal()))
+ return false;
+
+ /*
+ * Do this once, we can't return to user-mode if freezing() == T.
+ * do_signal_stop() and ptrace_stop() do freezable_schedule() and
+ * thus do not need another check after return.
+ */
+ try_to_freeze();
+
+relock:
+ spin_lock_irq(&sighand->siglock);
+
+ /*
+ * Every stopped thread goes here after wakeup. Check to see if
+ * we should notify the parent, prepare_signal(SIGCONT) encodes
+ * the CLD_ si_code into SIGNAL_CLD_MASK bits.
+ */
+ if (unlikely(signal->flags & SIGNAL_CLD_MASK))
+ {
+ int why;
+
+ if (signal->flags & SIGNAL_CLD_CONTINUED)
+ why = CLD_CONTINUED;
+ else
+ why = CLD_STOPPED;
+
+ signal->flags &= ~SIGNAL_CLD_MASK;
+
+ spin_unlock_irq(&sighand->siglock);
+
+ /*
+ * Notify the parent that we're continuing. This event is
+ * always per-process and doesn't make whole lot of sense
+ * for ptracers, who shouldn't consume the state via
+ * wait(2) either, but, for backward compatibility, notify
+ * the ptracer of the group leader too unless it's gonna be
+ * a duplicate.
+ */
+ read_lock(&tasklist_lock);
+ do_notify_parent_cldstop(current, false, why);
+
+ if (ptrace_reparented(current->group_leader))
+ do_notify_parent_cldstop(current->group_leader,
+ true, why);
+ read_unlock(&tasklist_lock);
+
+ goto relock;
+ }
+
+ /* Has this task already been marked for death? */
+ if (signal_group_exit(signal))
+ {
+ ksig->info.si_signo = signr = SIGKILL;
+ sigdelset(¤t->pending.signal, SIGKILL);
+ trace_signal_deliver(SIGKILL, SEND_SIG_NOINFO,
+ &sighand->action[SIGKILL - 1]);
+ recalc_sigpending();
+ goto fatal;
+ }
+
+ for (;;)
+ {
+ struct k_sigaction *ka;
+
+ if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
+ do_signal_stop(0))
+ goto relock;
+
+ if (unlikely(current->jobctl &
+ (JOBCTL_TRAP_MASK | JOBCTL_TRAP_FREEZE)))
+ {
+ if (current->jobctl & JOBCTL_TRAP_MASK)
+ {
+ do_jobctl_trap();
+ spin_unlock_irq(&sighand->siglock);
+ }
+ else if (current->jobctl & JOBCTL_TRAP_FREEZE)
+ do_freezer_trap();
+
+ goto relock;
+ }
+
+ /*
+ * If the task is leaving the frozen state, let's update
+ * cgroup counters and reset the frozen bit.
+ */
+ if (unlikely(cgroup_task_frozen(current)))
+ {
+ spin_unlock_irq(&sighand->siglock);
+ cgroup_leave_frozen(false);
+ goto relock;
+ }
+
+ /*
+ * Signals generated by the execution of an instruction
+ * need to be delivered before any other pending signals
+ * so that the instruction pointer in the signal stack
+ * frame points to the faulting instruction.
+ */
+ signr = dequeue_synchronous_signal(&ksig->info);
+ if (!signr)
+ signr = dequeue_signal(current, ¤t->blocked, &ksig->info);
+
+ if (!signr)
+ break; /* will return 0 */
+
+ if (unlikely(current->ptrace) && (signr != SIGKILL) &&
+ !(sighand->action[signr - 1].sa.sa_flags & SA_IMMUTABLE))
+ {
+ signr = ptrace_signal(signr, &ksig->info);
+ if (!signr)
+ continue;
+ }
+
+ ka = &sighand->action[signr - 1];
+
+ /* Trace actually delivered signals. */
+ trace_signal_deliver(signr, &ksig->info, ka);
+
+ if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
+ continue;
+ if (ka->sa.sa_handler != SIG_DFL)
+ {
+ /* Run the handler. */
+ ksig->ka = *ka;
+
+ if (ka->sa.sa_flags & SA_ONESHOT)
+ ka->sa.sa_handler = SIG_DFL;
+
+ break; /* will return non-zero "signr" value */
+ }
+
+ /*
+ * Now we are doing the default action for this signal.
+ */
+ if (sig_kernel_ignore(signr)) /* Default is nothing. */
+ continue;
+
+ /*
+ * Global init gets no signals it doesn't want.
+ * Container-init gets no signals it doesn't want from same
+ * container.
+ *
+ * Note that if global/container-init sees a sig_kernel_only()
+ * signal here, the signal must have been generated internally
+ * or must have come from an ancestor namespace. In either
+ * case, the signal cannot be dropped.
+ */
+ if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
+ !sig_kernel_only(signr))
+ continue;
+
+ if (sig_kernel_stop(signr))
+ {
+ /*
+ * The default action is to stop all threads in
+ * the thread group. The job control signals
+ * do nothing in an orphaned pgrp, but SIGSTOP
+ * always works. Note that siglock needs to be
+ * dropped during the call to is_orphaned_pgrp()
+ * because of lock ordering with tasklist_lock.
+ * This allows an intervening SIGCONT to be posted.
+ * We need to check for that and bail out if necessary.
+ */
+ if (signr != SIGSTOP)
+ {
+ spin_unlock_irq(&sighand->siglock);
+
+ /* signals can be posted during this window */
+
+ if (is_current_pgrp_orphaned())
+ goto relock;
+
+ spin_lock_irq(&sighand->siglock);
+ }
+
+ if (likely(do_signal_stop(ksig->info.si_signo)))
+ {
+ /* It released the siglock. */
+ goto relock;
+ }
+
+ /*
+ * We didn't actually stop, due to a race
+ * with SIGCONT or something like that.
+ */
+ continue;
+ }
+
+ fatal:
+ spin_unlock_irq(&sighand->siglock);
+ if (unlikely(cgroup_task_frozen(current)))
+ cgroup_leave_frozen(true);
+
+ /*
+ * Anything else is fatal, maybe with a core dump.
+ */
+ current->flags |= PF_SIGNALED;
+
+ if (sig_kernel_coredump(signr))
+ {
+ if (print_fatal_signals)
+ print_fatal_signal(ksig->info.si_signo);
+ proc_coredump_connector(current);
+ /*
+ * If it was able to dump core, this kills all
+ * other threads in the group and synchronizes with
+ * their demise. If we lost the race with another
+ * thread getting here, it set group_exit_code
+ * first and our do_group_exit call below will use
+ * that value and ignore the one we pass it.
+ */
+ do_coredump(&ksig->info);
+ }
+
+ /*
+ * PF_IO_WORKER threads will catch and exit on fatal signals
+ * themselves. They have cleanup that must be performed, so
+ * we cannot call do_exit() on their behalf.
+ */
+ if (current->flags & PF_IO_WORKER)
+ goto out;
+
+ /*
+ * Death signals, no core dump.
+ */
+ do_group_exit(ksig->info.si_signo);
+ /* NOTREACHED */
+ }
+ spin_unlock_irq(&sighand->siglock);
+out:
+ ksig->sig = signr;
+
+ if (!(ksig->ka.sa.sa_flags & SA_EXPOSE_TAGBITS))
+ hide_si_addr_tag_bits(ksig);
+
+ return ksig->sig > 0;
+}
+
+/**
+ * signal_delivered -
+ * @ksig: kernel signal struct
+ * @stepping: nonzero if debugger single-step or block-step in use
+ *
+ * This function should be called when a signal has successfully been
+ * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
+ * is always blocked, and the signal itself is blocked unless %SA_NODEFER
+ * is set in @ksig->ka.sa.sa_flags. Tracing is notified.
+ */
+static void signal_delivered(struct ksignal *ksig, int stepping)
+{
+ sigset_t blocked;
+
+ /* A signal was successfully delivered, and the
+ saved sigmask was stored on the signal frame,
+ and will be restored by sigreturn. So we can
+ simply clear the restore sigmask flag. */
+ clear_restore_sigmask();
+
+ sigorsets(&blocked, ¤t->blocked, &ksig->ka.sa.sa_mask);
+ if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
+ sigaddset(&blocked, ksig->sig);
+ set_current_blocked(&blocked);
+ if (current->sas_ss_flags & SS_AUTODISARM)
+ sas_ss_reset(current);
+ tracehook_signal_handler(stepping);
+}
+
+void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
+{
+ if (failed)
+ force_sigsegv(ksig->sig);
+ else
+ signal_delivered(ksig, stepping);
+}
+
+/*
+ * It could be that complete_signal() picked us to notify about the
+ * group-wide signal. Other threads should be notified now to take
+ * the shared signals in @which since we will not.
+ */
+static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
+{
+ sigset_t retarget;
+ struct task_struct *t;
+
+ sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
+ if (sigisemptyset(&retarget))
+ return;
+
+ t = tsk;
+ while_each_thread(tsk, t)
+ {
+ if (t->flags & PF_EXITING)
+ continue;
+
+ if (!has_pending_signals(&retarget, &t->blocked))
+ continue;
+ /* Remove the signals this thread can handle. */
+ sigandsets(&retarget, &retarget, &t->blocked);
+
+ if (!task_sigpending(t))
+ signal_wake_up(t, 0);
+
+ if (sigisemptyset(&retarget))
+ break;
+ }
+}
+
+void exit_signals(struct task_struct *tsk)
+{
+ int group_stop = 0;
+ sigset_t unblocked;
+
+ /*
+ * @tsk is about to have PF_EXITING set - lock out users which
+ * expect stable threadgroup.
+ */
+ cgroup_threadgroup_change_begin(tsk);
+
+ if (thread_group_empty(tsk) || signal_group_exit(tsk->signal))
+ {
+ tsk->flags |= PF_EXITING;
+ cgroup_threadgroup_change_end(tsk);
+ return;
+ }
+
+ spin_lock_irq(&tsk->sighand->siglock);
+ /*
+ * From now this task is not visible for group-wide signals,
+ * see wants_signal(), do_signal_stop().
+ */
+ tsk->flags |= PF_EXITING;
+
+ cgroup_threadgroup_change_end(tsk);
+
+ if (!task_sigpending(tsk))
+ goto out;
+
+ unblocked = tsk->blocked;
+ signotset(&unblocked);
+ retarget_shared_pending(tsk, &unblocked);
+
+ if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
+ task_participate_group_stop(tsk))
+ group_stop = CLD_STOPPED;
+out:
+ spin_unlock_irq(&tsk->sighand->siglock);
+
+ /*
+ * If group stop has completed, deliver the notification. This
+ * should always go to the real parent of the group leader.
+ */
+ if (unlikely(group_stop))
+ {
+ read_lock(&tasklist_lock);
+ do_notify_parent_cldstop(tsk, false, group_stop);
+ read_unlock(&tasklist_lock);
+ }
+}
+
+/*
+ * System call entry points.
+ */
+
+/**
+ * sys_restart_syscall - restart a system call
+ */
+SYSCALL_DEFINE0(restart_syscall)
+{
+ struct restart_block *restart = ¤t->restart_block;
+ return restart->fn(restart);
+}
+
+long do_no_restart_syscall(struct restart_block *param)
+{
+ return -EINTR;
+}
+
+static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
+{
+ if (task_sigpending(tsk) && !thread_group_empty(tsk))
+ {
+ sigset_t newblocked;
+ /* A set of now blocked but previously unblocked signals. */
+ sigandnsets(&newblocked, newset, ¤t->blocked);
+ retarget_shared_pending(tsk, &newblocked);
+ }
+ tsk->blocked = *newset;
+ recalc_sigpending();
+}
+
+/**
+ * set_current_blocked - change current->blocked mask
+ * @newset: new mask
+ *
+ * It is wrong to change ->blocked directly, this helper should be used
+ * to ensure the process can't miss a shared signal we are going to block.
+ */
+void set_current_blocked(sigset_t *newset)
+{
+ sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
+ __set_current_blocked(newset);
+}
+
+void __set_current_blocked(const sigset_t *newset)
+{
+ struct task_struct *tsk = current;
+
+ /*
+ * In case the signal mask hasn't changed, there is nothing we need
+ * to do. The current->blocked shouldn't be modified by other task.
+ */
+ if (sigequalsets(&tsk->blocked, newset))
+ return;
+
+ spin_lock_irq(&tsk->sighand->siglock);
+ __set_task_blocked(tsk, newset);
+ spin_unlock_irq(&tsk->sighand->siglock);
+}
+
+/*
+ * This is also useful for kernel threads that want to temporarily
+ * (or permanently) block certain signals.
+ *
+ * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
+ * interface happily blocks "unblockable" signals like SIGKILL
+ * and friends.
+ */
+int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
+{
+ struct task_struct *tsk = current;
+ sigset_t newset;
+
+ /* Lockless, only current can change ->blocked, never from irq */
+ if (oldset)
+ *oldset = tsk->blocked;
+
+ switch (how)
+ {
+ case SIG_BLOCK:
+ sigorsets(&newset, &tsk->blocked, set);
+ break;
+ case SIG_UNBLOCK:
+ sigandnsets(&newset, &tsk->blocked, set);
+ break;
+ case SIG_SETMASK:
+ newset = *set;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ __set_current_blocked(&newset);
+ return 0;
+}
+EXPORT_SYMBOL(sigprocmask);
+
+/*
+ * The api helps set app-provided sigmasks.
+ *
+ * This is useful for syscalls such as ppoll, pselect, io_pgetevents and
+ * epoll_pwait where a new sigmask is passed from userland for the syscalls.
+ *
+ * Note that it does set_restore_sigmask() in advance, so it must be always
+ * paired with restore_saved_sigmask_unless() before return from syscall.
+ */
+int set_user_sigmask(const sigset_t __user *umask, size_t sigsetsize)
+{
+ sigset_t kmask;
+
+ if (!umask)
+ return 0;
+ if (sigsetsize != sizeof(sigset_t))
+ return -EINVAL;
+ if (copy_from_user(&kmask, umask, sizeof(sigset_t)))
+ return -EFAULT;
+
+ set_restore_sigmask();
+ current->saved_sigmask = current->blocked;
+ set_current_blocked(&kmask);
+
+ return 0;
+}
+
+#ifdef CONFIG_COMPAT
+int set_compat_user_sigmask(const compat_sigset_t __user *umask,
+ size_t sigsetsize)
+{
+ sigset_t kmask;
+
+ if (!umask)
+ return 0;
+ if (sigsetsize != sizeof(compat_sigset_t))
+ return -EINVAL;
+ if (get_compat_sigset(&kmask, umask))
+ return -EFAULT;
+
+ set_restore_sigmask();
+ current->saved_sigmask = current->blocked;
+ set_current_blocked(&kmask);
+
+ return 0;
+}
+#endif
+
+/**
+ * sys_rt_sigprocmask - change the list of currently blocked signals
+ * @how: whether to add, remove, or set signals
+ * @nset: stores pending signals
+ * @oset: previous value of signal mask if non-null
+ * @sigsetsize: size of sigset_t type
+ */
+SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
+ sigset_t __user *, oset, size_t, sigsetsize)
+{
+ sigset_t old_set, new_set;
+ int error;
+
+ /* XXX: Don't preclude handling different sized sigset_t's. */
+ if (sigsetsize != sizeof(sigset_t))
+ return -EINVAL;
+
+ old_set = current->blocked;
+
+ if (nset)
+ {
+ if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
+ return -EFAULT;
+ sigdelsetmask(&new_set, sigmask(SIGKILL) | sigmask(SIGSTOP));
+
+ error = sigprocmask(how, &new_set, NULL);
+ if (error)
+ return error;
+ }
+
+ if (oset)
+ {
+ if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
+ return -EFAULT;
+ }
+
+ return 0;
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
+ compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
+{
+ sigset_t old_set = current->blocked;
+
+ /* XXX: Don't preclude handling different sized sigset_t's. */
+ if (sigsetsize != sizeof(sigset_t))
+ return -EINVAL;
+
+ if (nset)
+ {
+ sigset_t new_set;
+ int error;
+ if (get_compat_sigset(&new_set, nset))
+ return -EFAULT;
+ sigdelsetmask(&new_set, sigmask(SIGKILL) | sigmask(SIGSTOP));
+
+ error = sigprocmask(how, &new_set, NULL);
+ if (error)
+ return error;
+ }
+ return oset ? put_compat_sigset(oset, &old_set, sizeof(*oset)) : 0;
+}
+#endif
+
+static void do_sigpending(sigset_t *set)
+{
+ spin_lock_irq(¤t->sighand->siglock);
+ sigorsets(set, ¤t->pending.signal,
+ ¤t->signal->shared_pending.signal);
+ spin_unlock_irq(¤t->sighand->siglock);
+
+ /* Outside the lock because only this thread touches it. */
+ sigandsets(set, ¤t->blocked, set);
+}
+
+/**
+ * sys_rt_sigpending - examine a pending signal that has been raised
+ * while blocked
+ * @uset: stores pending signals
+ * @sigsetsize: size of sigset_t type or larger
+ */
+SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
+{
+ sigset_t set;
+
+ if (sigsetsize > sizeof(*uset))
+ return -EINVAL;
+
+ do_sigpending(&set);
+
+ if (copy_to_user(uset, &set, sigsetsize))
+ return -EFAULT;
+
+ return 0;
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
+ compat_size_t, sigsetsize)
+{
+ sigset_t set;
+
+ if (sigsetsize > sizeof(*uset))
+ return -EINVAL;
+
+ do_sigpending(&set);
+
+ return put_compat_sigset(uset, &set, sigsetsize);
+}
+#endif
+
+static const struct
+{
+ unsigned char limit, layout;
+} sig_sicodes[] = {
+ [SIGILL] = {NSIGILL, SIL_FAULT},
+ [SIGFPE] = {NSIGFPE, SIL_FAULT},
+ [SIGSEGV] = {NSIGSEGV, SIL_FAULT},
+ [SIGBUS] = {NSIGBUS, SIL_FAULT},
+ [SIGTRAP] = {NSIGTRAP, SIL_FAULT},
+#if defined(SIGEMT)
+ [SIGEMT] = {NSIGEMT, SIL_FAULT},
+#endif
+ [SIGCHLD] = {NSIGCHLD, SIL_CHLD},
+ [SIGPOLL] = {NSIGPOLL, SIL_POLL},
+ [SIGSYS] = {NSIGSYS, SIL_SYS},
+};
+
+static bool known_siginfo_layout(unsigned sig, int si_code)
+{
+ if (si_code == SI_KERNEL)
+ return true;
+ else if ((si_code > SI_USER))
+ {
+ if (sig_specific_sicodes(sig))
+ {
+ if (si_code <= sig_sicodes[sig].limit)
+ return true;
+ }
+ else if (si_code <= NSIGPOLL)
+ return true;
+ }
+ else if (si_code >= SI_DETHREAD)
+ return true;
+ else if (si_code == SI_ASYNCNL)
+ return true;
+ return false;
+}
+
+enum siginfo_layout siginfo_layout(unsigned sig, int si_code)
+{
+ enum siginfo_layout layout = SIL_KILL;
+ if ((si_code > SI_USER) && (si_code < SI_KERNEL))
+ {
+ if ((sig < ARRAY_SIZE(sig_sicodes)) &&
+ (si_code <= sig_sicodes[sig].limit))
+ {
+ layout = sig_sicodes[sig].layout;
+ /* Handle the exceptions */
+ if ((sig == SIGBUS) &&
+ (si_code >= BUS_MCEERR_AR) && (si_code <= BUS_MCEERR_AO))
+ layout = SIL_FAULT_MCEERR;
+ else if ((sig == SIGSEGV) && (si_code == SEGV_BNDERR))
+ layout = SIL_FAULT_BNDERR;
+#ifdef SEGV_PKUERR
+ else if ((sig == SIGSEGV) && (si_code == SEGV_PKUERR))
+ layout = SIL_FAULT_PKUERR;
+#endif
+ else if ((sig == SIGTRAP) && (si_code == TRAP_PERF))
+ layout = SIL_FAULT_PERF_EVENT;
+ else if (IS_ENABLED(CONFIG_SPARC) &&
+ (sig == SIGILL) && (si_code == ILL_ILLTRP))
+ layout = SIL_FAULT_TRAPNO;
+ else if (IS_ENABLED(CONFIG_ALPHA) &&
+ ((sig == SIGFPE) ||
+ ((sig == SIGTRAP) && (si_code == TRAP_UNK))))
+ layout = SIL_FAULT_TRAPNO;
+ }
+ else if (si_code <= NSIGPOLL)
+ layout = SIL_POLL;
+ }
+ else
+ {
+ if (si_code == SI_TIMER)
+ layout = SIL_TIMER;
+ else if (si_code == SI_SIGIO)
+ layout = SIL_POLL;
+ else if (si_code < 0)
+ layout = SIL_RT;
+ }
+ return layout;
+}
+
+static inline char __user *si_expansion(const siginfo_t __user *info)
+{
+ return ((char __user *)info) + sizeof(struct kernel_siginfo);
+}
+
+int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from)
+{
+ char __user *expansion = si_expansion(to);
+ if (copy_to_user(to, from, sizeof(struct kernel_siginfo)))
+ return -EFAULT;
+ if (clear_user(expansion, SI_EXPANSION_SIZE))
+ return -EFAULT;
+ return 0;
+}
+
+static int post_copy_siginfo_from_user(kernel_siginfo_t *info,
+ const siginfo_t __user *from)
+{
+ if (unlikely(!known_siginfo_layout(info->si_signo, info->si_code)))
+ {
+ char __user *expansion = si_expansion(from);
+ char buf[SI_EXPANSION_SIZE];
+ int i;
+ /*
+ * An unknown si_code might need more than
+ * sizeof(struct kernel_siginfo) bytes. Verify all of the
+ * extra bytes are 0. This guarantees copy_siginfo_to_user
+ * will return this data to userspace exactly.
+ */
+ if (copy_from_user(&buf, expansion, SI_EXPANSION_SIZE))
+ return -EFAULT;
+ for (i = 0; i < SI_EXPANSION_SIZE; i++)
+ {
+ if (buf[i] != 0)
+ return -E2BIG;
+ }
+ }
+ return 0;
+}
+
+static int __copy_siginfo_from_user(int signo, kernel_siginfo_t *to,
+ const siginfo_t __user *from)
+{
+ if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
+ return -EFAULT;
+ to->si_signo = signo;
+ return post_copy_siginfo_from_user(to, from);
+}
+
+int copy_siginfo_from_user(kernel_siginfo_t *to, const siginfo_t __user *from)
+{
+ if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
+ return -EFAULT;
+ return post_copy_siginfo_from_user(to, from);
+}
+
+#ifdef CONFIG_COMPAT
+/**
+ * copy_siginfo_to_external32 - copy a kernel siginfo into a compat user siginfo
+ * @to: compat siginfo destination
+ * @from: kernel siginfo source
+ *
+ * Note: This function does not work properly for the SIGCHLD on x32, but
+ * fortunately it doesn't have to. The only valid callers for this function are
+ * copy_siginfo_to_user32, which is overriden for x32 and the coredump code.
+ * The latter does not care because SIGCHLD will never cause a coredump.
+ */
+void copy_siginfo_to_external32(struct compat_siginfo *to,
+ const struct kernel_siginfo *from)
+{
+ memset(to, 0, sizeof(*to));
+
+ to->si_signo = from->si_signo;
+ to->si_errno = from->si_errno;
+ to->si_code = from->si_code;
+ switch (siginfo_layout(from->si_signo, from->si_code))
+ {
+ case SIL_KILL:
+ to->si_pid = from->si_pid;
+ to->si_uid = from->si_uid;
+ break;
+ case SIL_TIMER:
+ to->si_tid = from->si_tid;
+ to->si_overrun = from->si_overrun;
+ to->si_int = from->si_int;
+ break;
+ case SIL_POLL:
+ to->si_band = from->si_band;
+ to->si_fd = from->si_fd;
+ break;
+ case SIL_FAULT:
+ to->si_addr = ptr_to_compat(from->si_addr);
+ break;
+ case SIL_FAULT_TRAPNO:
+ to->si_addr = ptr_to_compat(from->si_addr);
+ to->si_trapno = from->si_trapno;
+ break;
+ case SIL_FAULT_MCEERR:
+ to->si_addr = ptr_to_compat(from->si_addr);
+ to->si_addr_lsb = from->si_addr_lsb;
+ break;
+ case SIL_FAULT_BNDERR:
+ to->si_addr = ptr_to_compat(from->si_addr);
+ to->si_lower = ptr_to_compat(from->si_lower);
+ to->si_upper = ptr_to_compat(from->si_upper);
+ break;
+ case SIL_FAULT_PKUERR:
+ to->si_addr = ptr_to_compat(from->si_addr);
+ to->si_pkey = from->si_pkey;
+ break;
+ case SIL_FAULT_PERF_EVENT:
+ to->si_addr = ptr_to_compat(from->si_addr);
+ to->si_perf_data = from->si_perf_data;
+ to->si_perf_type = from->si_perf_type;
+ break;
+ case SIL_CHLD:
+ to->si_pid = from->si_pid;
+ to->si_uid = from->si_uid;
+ to->si_status = from->si_status;
+ to->si_utime = from->si_utime;
+ to->si_stime = from->si_stime;
+ break;
+ case SIL_RT:
+ to->si_pid = from->si_pid;
+ to->si_uid = from->si_uid;
+ to->si_int = from->si_int;
+ break;
+ case SIL_SYS:
+ to->si_call_addr = ptr_to_compat(from->si_call_addr);
+ to->si_syscall = from->si_syscall;
+ to->si_arch = from->si_arch;
+ break;
+ }
+}
+
+int __copy_siginfo_to_user32(struct compat_siginfo __user *to,
+ const struct kernel_siginfo *from)
+{
+ struct compat_siginfo new;
+
+ copy_siginfo_to_external32(&new, from);
+ if (copy_to_user(to, &new, sizeof(struct compat_siginfo)))
+ return -EFAULT;
+ return 0;
+}
+
+static int post_copy_siginfo_from_user32(kernel_siginfo_t *to,
+ const struct compat_siginfo *from)
+{
+ clear_siginfo(to);
+ to->si_signo = from->si_signo;
+ to->si_errno = from->si_errno;
+ to->si_code = from->si_code;
+ switch (siginfo_layout(from->si_signo, from->si_code))
+ {
+ case SIL_KILL:
+ to->si_pid = from->si_pid;
+ to->si_uid = from->si_uid;
+ break;
+ case SIL_TIMER:
+ to->si_tid = from->si_tid;
+ to->si_overrun = from->si_overrun;
+ to->si_int = from->si_int;
+ break;
+ case SIL_POLL:
+ to->si_band = from->si_band;
+ to->si_fd = from->si_fd;
+ break;
+ case SIL_FAULT:
+ to->si_addr = compat_ptr(from->si_addr);
+ break;
+ case SIL_FAULT_TRAPNO:
+ to->si_addr = compat_ptr(from->si_addr);
+ to->si_trapno = from->si_trapno;
+ break;
+ case SIL_FAULT_MCEERR:
+ to->si_addr = compat_ptr(from->si_addr);
+ to->si_addr_lsb = from->si_addr_lsb;
+ break;
+ case SIL_FAULT_BNDERR:
+ to->si_addr = compat_ptr(from->si_addr);
+ to->si_lower = compat_ptr(from->si_lower);
+ to->si_upper = compat_ptr(from->si_upper);
+ break;
+ case SIL_FAULT_PKUERR:
+ to->si_addr = compat_ptr(from->si_addr);
+ to->si_pkey = from->si_pkey;
+ break;
+ case SIL_FAULT_PERF_EVENT:
+ to->si_addr = compat_ptr(from->si_addr);
+ to->si_perf_data = from->si_perf_data;
+ to->si_perf_type = from->si_perf_type;
+ break;
+ case SIL_CHLD:
+ to->si_pid = from->si_pid;
+ to->si_uid = from->si_uid;
+ to->si_status = from->si_status;
+#ifdef CONFIG_X86_X32_ABI
+ if (in_x32_syscall())
+ {
+ to->si_utime = from->_sifields._sigchld_x32._utime;
+ to->si_stime = from->_sifields._sigchld_x32._stime;
+ }
+ else
+#endif
+ {
+ to->si_utime = from->si_utime;
+ to->si_stime = from->si_stime;
+ }
+ break;
+ case SIL_RT:
+ to->si_pid = from->si_pid;
+ to->si_uid = from->si_uid;
+ to->si_int = from->si_int;
+ break;
+ case SIL_SYS:
+ to->si_call_addr = compat_ptr(from->si_call_addr);
+ to->si_syscall = from->si_syscall;
+ to->si_arch = from->si_arch;
+ break;
+ }
+ return 0;
+}
+
+static int __copy_siginfo_from_user32(int signo, struct kernel_siginfo *to,
+ const struct compat_siginfo __user *ufrom)
+{
+ struct compat_siginfo from;
+
+ if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
+ return -EFAULT;
+
+ from.si_signo = signo;
+ return post_copy_siginfo_from_user32(to, &from);
+}
+
+int copy_siginfo_from_user32(struct kernel_siginfo *to,
+ const struct compat_siginfo __user *ufrom)
+{
+ struct compat_siginfo from;
+
+ if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
+ return -EFAULT;
+
+ return post_copy_siginfo_from_user32(to, &from);
+}
+#endif /* CONFIG_COMPAT */
+
+/**
+ * do_sigtimedwait - wait for queued signals specified in @which
+ * @which: queued signals to wait for
+ * @info: if non-null, the signal's siginfo is returned here
+ * @ts: upper bound on process time suspension
+ */
+static int do_sigtimedwait(const sigset_t *which, kernel_siginfo_t *info,
+ const struct timespec64 *ts)
+{
+ ktime_t *to = NULL, timeout = KTIME_MAX;
+ struct task_struct *tsk = current;
+ sigset_t mask = *which;
+ int sig, ret = 0;
+
+ if (ts)
+ {
+ if (!timespec64_valid(ts))
+ return -EINVAL;
+ timeout = timespec64_to_ktime(*ts);
+ to = &timeout;
+ }
+
+ /*
+ * Invert the set of allowed signals to get those we want to block.
+ */
+ sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
+ signotset(&mask);
+
+ spin_lock_irq(&tsk->sighand->siglock);
+ sig = dequeue_signal(tsk, &mask, info);
+ if (!sig && timeout)
+ {
+ /*
+ * None ready, temporarily unblock those we're interested
+ * while we are sleeping in so that we'll be awakened when
+ * they arrive. Unblocking is always fine, we can avoid
+ * set_current_blocked().
+ */
+ tsk->real_blocked = tsk->blocked;
+ sigandsets(&tsk->blocked, &tsk->blocked, &mask);
+ recalc_sigpending();
+ spin_unlock_irq(&tsk->sighand->siglock);
+
+ __set_current_state(TASK_INTERRUPTIBLE);
+ ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
+ HRTIMER_MODE_REL);
+ spin_lock_irq(&tsk->sighand->siglock);
+ __set_task_blocked(tsk, &tsk->real_blocked);
+ sigemptyset(&tsk->real_blocked);
+ sig = dequeue_signal(tsk, &mask, info);
+ }
+ spin_unlock_irq(&tsk->sighand->siglock);
+
+ if (sig)
+ return sig;
+ return ret ? -EINTR : -EAGAIN;
+}
+
+/**
+ * sys_rt_sigtimedwait - synchronously wait for queued signals specified
+ * in @uthese
+ * @uthese: queued signals to wait for
+ * @uinfo: if non-null, the signal's siginfo is returned here
+ * @uts: upper bound on process time suspension
+ * @sigsetsize: size of sigset_t type
+ */
+SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
+ siginfo_t __user *, uinfo,
+ const struct __kernel_timespec __user *, uts,
+ size_t, sigsetsize)
+{
+ sigset_t these;
+ struct timespec64 ts;
+ kernel_siginfo_t info;
+ int ret;
+
+ /* XXX: Don't preclude handling different sized sigset_t's. */
+ if (sigsetsize != sizeof(sigset_t))
+ return -EINVAL;
+
+ if (copy_from_user(&these, uthese, sizeof(these)))
+ return -EFAULT;
+
+ if (uts)
+ {
+ if (get_timespec64(&ts, uts))
+ return -EFAULT;
+ }
+
+ ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
+
+ if (ret > 0 && uinfo)
+ {
+ if (copy_siginfo_to_user(uinfo, &info))
+ ret = -EFAULT;
+ }
+
+ return ret;
+}
+
+#ifdef CONFIG_COMPAT_32BIT_TIME
+SYSCALL_DEFINE4(rt_sigtimedwait_time32, const sigset_t __user *, uthese,
+ siginfo_t __user *, uinfo,
+ const struct old_timespec32 __user *, uts,
+ size_t, sigsetsize)
+{
+ sigset_t these;
+ struct timespec64 ts;
+ kernel_siginfo_t info;
+ int ret;
+
+ if (sigsetsize != sizeof(sigset_t))
+ return -EINVAL;
+
+ if (copy_from_user(&these, uthese, sizeof(these)))
+ return -EFAULT;
+
+ if (uts)
+ {
+ if (get_old_timespec32(&ts, uts))
+ return -EFAULT;
+ }
+
+ ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
+
+ if (ret > 0 && uinfo)
+ {
+ if (copy_siginfo_to_user(uinfo, &info))
+ ret = -EFAULT;
+ }
+
+ return ret;
+}
+#endif
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time64, compat_sigset_t __user *, uthese,
+ struct compat_siginfo __user *, uinfo,
+ struct __kernel_timespec __user *, uts, compat_size_t, sigsetsize)
+{
+ sigset_t s;
+ struct timespec64 t;
+ kernel_siginfo_t info;
+ long ret;
+
+ if (sigsetsize != sizeof(sigset_t))
+ return -EINVAL;
+
+ if (get_compat_sigset(&s, uthese))
+ return -EFAULT;
+
+ if (uts)
+ {
+ if (get_timespec64(&t, uts))
+ return -EFAULT;
+ }
+
+ ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
+
+ if (ret > 0 && uinfo)
+ {
+ if (copy_siginfo_to_user32(uinfo, &info))
+ ret = -EFAULT;
+ }
+
+ return ret;
+}
+
+#ifdef CONFIG_COMPAT_32BIT_TIME
+COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time32, compat_sigset_t __user *, uthese,
+ struct compat_siginfo __user *, uinfo,
+ struct old_timespec32 __user *, uts, compat_size_t, sigsetsize)
+{
+ sigset_t s;
+ struct timespec64 t;
+ kernel_siginfo_t info;
+ long ret;
+
+ if (sigsetsize != sizeof(sigset_t))
+ return -EINVAL;
+
+ if (get_compat_sigset(&s, uthese))
+ return -EFAULT;
+
+ if (uts)
+ {
+ if (get_old_timespec32(&t, uts))
+ return -EFAULT;
+ }
+
+ ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
+
+ if (ret > 0 && uinfo)
+ {
+ if (copy_siginfo_to_user32(uinfo, &info))
+ ret = -EFAULT;
+ }
+
+ return ret;
+}
+#endif
+#endif
+
+static inline void prepare_kill_siginfo(int sig, struct kernel_siginfo *info)
+{
+ clear_siginfo(info);
+ info->si_signo = sig;
+ info->si_errno = 0;
+ info->si_code = SI_USER;
+ info->si_pid = task_tgid_vnr(current);
+ info->si_uid = from_kuid_munged(current_user_ns(), current_uid());
+}
+
+/**
+ * sys_kill - send a signal to a process
+ * @pid: the PID of the process
+ * @sig: signal to be sent
+ */
+SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
+{
+ struct kernel_siginfo info;
+
+ prepare_kill_siginfo(sig, &info);
+
+ return kill_something_info(sig, &info, pid);
+}
+
+/*
+ * Verify that the signaler and signalee either are in the same pid namespace
+ * or that the signaler's pid namespace is an ancestor of the signalee's pid
+ * namespace.
+ */
+static bool access_pidfd_pidns(struct pid *pid)
+{
+ struct pid_namespace *active = task_active_pid_ns(current);
+ struct pid_namespace *p = ns_of_pid(pid);
+
+ for (;;)
+ {
+ if (!p)
+ return false;
+ if (p == active)
+ break;
+ p = p->parent;
+ }
+
+ return true;
+}
+
+static int copy_siginfo_from_user_any(kernel_siginfo_t *kinfo,
+ siginfo_t __user *info)
+{
+#ifdef CONFIG_COMPAT
+ /*
+ * Avoid hooking up compat syscalls and instead handle necessary
+ * conversions here. Note, this is a stop-gap measure and should not be
+ * considered a generic solution.
+ */
+ if (in_compat_syscall())
+ return copy_siginfo_from_user32(
+ kinfo, (struct compat_siginfo __user *)info);
+#endif
+ return copy_siginfo_from_user(kinfo, info);
+}
+
+static struct pid *pidfd_to_pid(const struct file *file)
+{
+ struct pid *pid;
+
+ pid = pidfd_pid(file);
+ if (!IS_ERR(pid))
+ return pid;
+
+ return tgid_pidfd_to_pid(file);
+}
+
+/**
+ * sys_pidfd_send_signal - Signal a process through a pidfd
+ * @pidfd: file descriptor of the process
+ * @sig: signal to send
+ * @info: signal info
+ * @flags: future flags
+ *
+ * The syscall currently only signals via PIDTYPE_PID which covers
+ * kill(<positive-pid>, <signal>. It does not signal threads or process
+ * groups.
+ * In order to extend the syscall to threads and process groups the @flags
+ * argument should be used. In essence, the @flags argument will determine
+ * what is signaled and not the file descriptor itself. Put in other words,
+ * grouping is a property of the flags argument not a property of the file
+ * descriptor.
+ *
+ * Return: 0 on success, negative errno on failure
+ */
+SYSCALL_DEFINE4(pidfd_send_signal, int, pidfd, int, sig,
+ siginfo_t __user *, info, unsigned int, flags)
+{
+ int ret;
+ struct fd f;
+ struct pid *pid;
+ kernel_siginfo_t kinfo;
+
+ /* Enforce flags be set to 0 until we add an extension. */
+ if (flags)
+ return -EINVAL;
+
+ f = fdget(pidfd);
+ if (!f.file)
+ return -EBADF;
+
+ /* Is this a pidfd? */
+ pid = pidfd_to_pid(f.file);
+ if (IS_ERR(pid))
+ {
+ ret = PTR_ERR(pid);
+ goto err;
+ }
+
+ ret = -EINVAL;
+ if (!access_pidfd_pidns(pid))
+ goto err;
+
+ if (info)
+ {
+ ret = copy_siginfo_from_user_any(&kinfo, info);
+ if (unlikely(ret))
+ goto err;
+
+ ret = -EINVAL;
+ if (unlikely(sig != kinfo.si_signo))
+ goto err;
+
+ /* Only allow sending arbitrary signals to yourself. */
+ ret = -EPERM;
+ if ((task_pid(current) != pid) &&
+ (kinfo.si_code >= 0 || kinfo.si_code == SI_TKILL))
+ goto err;
+ }
+ else
+ {
+ prepare_kill_siginfo(sig, &kinfo);
+ }
+
+ ret = kill_pid_info(sig, &kinfo, pid);
+
+err:
+ fdput(f);
+ return ret;
+}
+
+static int
+do_send_specific(pid_t tgid, pid_t pid, int sig, struct kernel_siginfo *info)
+{
+ struct task_struct *p;
+ int error = -ESRCH;
+
+ rcu_read_lock();
+ p = find_task_by_vpid(pid);
+ if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid))
+ {
+ error = check_kill_permission(sig, info, p);
+ /*
+ * The null signal is a permissions and process existence
+ * probe. No signal is actually delivered.
+ */
+ if (!error && sig)
+ {
+ error = do_send_sig_info(sig, info, p, PIDTYPE_PID);
+ /*
+ * If lock_task_sighand() failed we pretend the task
+ * dies after receiving the signal. The window is tiny,
+ * and the signal is private anyway.
+ */
+ if (unlikely(error == -ESRCH))
+ error = 0;
+ }
+ }
+ rcu_read_unlock();
+
+ return error;
+}
+
+static int do_tkill(pid_t tgid, pid_t pid, int sig)
+{
+ struct kernel_siginfo info;
+
+ clear_siginfo(&info);
+ info.si_signo = sig;
+ info.si_errno = 0;
+ info.si_code = SI_TKILL;
+ info.si_pid = task_tgid_vnr(current);
+ info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
+
+ return do_send_specific(tgid, pid, sig, &info);
+}
+
+/**
+ * sys_tgkill - send signal to one specific thread
+ * @tgid: the thread group ID of the thread
+ * @pid: the PID of the thread
+ * @sig: signal to be sent
+ *
+ * This syscall also checks the @tgid and returns -ESRCH even if the PID
+ * exists but it's not belonging to the target process anymore. This
+ * method solves the problem of threads exiting and PIDs getting reused.
+ */
+SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
+{
+ /* This is only valid for single tasks */
+ if (pid <= 0 || tgid <= 0)
+ return -EINVAL;
+
+ return do_tkill(tgid, pid, sig);
+}
+
+/**
+ * sys_tkill - send signal to one specific task
+ * @pid: the PID of the task
+ * @sig: signal to be sent
+ *
+ * Send a signal to only one task, even if it's a CLONE_THREAD task.
+ */
+SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
+{
+ /* This is only valid for single tasks */
+ if (pid <= 0)
+ return -EINVAL;
+
+ return do_tkill(0, pid, sig);
+}
+
+static int do_rt_sigqueueinfo(pid_t pid, int sig, kernel_siginfo_t *info)
+{
+ /* Not even root can pretend to send signals from the kernel.
+ * Nor can they impersonate a kill()/tgkill(), which adds source info.
+ */
+ if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
+ (task_pid_vnr(current) != pid))
+ return -EPERM;
+
+ /* POSIX.1b doesn't mention process groups. */
+ return kill_proc_info(sig, info, pid);
+}
+
+/**
+ * sys_rt_sigqueueinfo - send signal information to a signal
+ * @pid: the PID of the thread
+ * @sig: signal to be sent
+ * @uinfo: signal info to be sent
+ */
+SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
+ siginfo_t __user *, uinfo)
+{
+ kernel_siginfo_t info;
+ int ret = __copy_siginfo_from_user(sig, &info, uinfo);
+ if (unlikely(ret))
+ return ret;
+ return do_rt_sigqueueinfo(pid, sig, &info);
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
+ compat_pid_t, pid,
+ int, sig,
+ struct compat_siginfo __user *, uinfo)
+{
+ kernel_siginfo_t info;
+ int ret = __copy_siginfo_from_user32(sig, &info, uinfo);
+ if (unlikely(ret))
+ return ret;
+ return do_rt_sigqueueinfo(pid, sig, &info);
+}
+#endif
+
+static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, kernel_siginfo_t *info)
+{
+ /* This is only valid for single tasks */
+ if (pid <= 0 || tgid <= 0)
+ return -EINVAL;
+
+ /* Not even root can pretend to send signals from the kernel.
+ * Nor can they impersonate a kill()/tgkill(), which adds source info.
+ */
+ if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
+ (task_pid_vnr(current) != pid))
+ return -EPERM;
+
+ return do_send_specific(tgid, pid, sig, info);
+}
+
+SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
+ siginfo_t __user *, uinfo)
+{
+ kernel_siginfo_t info;
+ int ret = __copy_siginfo_from_user(sig, &info, uinfo);
+ if (unlikely(ret))
+ return ret;
+ return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
+ compat_pid_t, tgid,
+ compat_pid_t, pid,
+ int, sig,
+ struct compat_siginfo __user *, uinfo)
+{
+ kernel_siginfo_t info;
+ int ret = __copy_siginfo_from_user32(sig, &info, uinfo);
+ if (unlikely(ret))
+ return ret;
+ return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
+}
+#endif
+
+/*
+ * For kthreads only, must not be used if cloned with CLONE_SIGHAND
+ */
+void kernel_sigaction(int sig, __sighandler_t action)
+{
+ spin_lock_irq(¤t->sighand->siglock);
+ current->sighand->action[sig - 1].sa.sa_handler = action;
+ if (action == SIG_IGN)
+ {
+ sigset_t mask;
+
+ sigemptyset(&mask);
+ sigaddset(&mask, sig);
+
+ flush_sigqueue_mask(&mask, ¤t->signal->shared_pending);
+ flush_sigqueue_mask(&mask, ¤t->pending);
+ recalc_sigpending();
+ }
+ spin_unlock_irq(¤t->sighand->siglock);
+}
+EXPORT_SYMBOL(kernel_sigaction);
+
+void __weak sigaction_compat_abi(struct k_sigaction *act,
+ struct k_sigaction *oact)
+{
+}
+
+int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
+{
+ struct task_struct *p = current, *t;
+ struct k_sigaction *k;
+ sigset_t mask;
+
+ if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
+ return -EINVAL;
+
+ k = &p->sighand->action[sig - 1];
+
+ spin_lock_irq(&p->sighand->siglock);
+ if (k->sa.sa_flags & SA_IMMUTABLE)
+ {
+ spin_unlock_irq(&p->sighand->siglock);
+ return -EINVAL;
+ }
+ if (oact)
+ *oact = *k;
+
+ /*
+ * Make sure that we never accidentally claim to support SA_UNSUPPORTED,
+ * e.g. by having an architecture use the bit in their uapi.
+ */
+ BUILD_BUG_ON(UAPI_SA_FLAGS & SA_UNSUPPORTED);
+
+ /*
+ * Clear unknown flag bits in order to allow userspace to detect missing
+ * support for flag bits and to allow the kernel to use non-uapi bits
+ * internally.
+ */
+ if (act)
+ act->sa.sa_flags &= UAPI_SA_FLAGS;
+ if (oact)
+ oact->sa.sa_flags &= UAPI_SA_FLAGS;
+
+ sigaction_compat_abi(act, oact);
+
+ if (act)
+ {
+ sigdelsetmask(&act->sa.sa_mask,
+ sigmask(SIGKILL) | sigmask(SIGSTOP));
+ *k = *act;
+ /*
+ * POSIX 3.3.1.3:
+ * "Setting a signal action to SIG_IGN for a signal that is
+ * pending shall cause the pending signal to be discarded,
+ * whether or not it is blocked."
+ *
+ * "Setting a signal action to SIG_DFL for a signal that is
+ * pending and whose default action is to ignore the signal
+ * (for example, SIGCHLD), shall cause the pending signal to
+ * be discarded, whether or not it is blocked"
+ */
+ if (sig_handler_ignored(sig_handler(p, sig), sig))
+ {
+ sigemptyset(&mask);
+ sigaddset(&mask, sig);
+ flush_sigqueue_mask(&mask, &p->signal->shared_pending);
+ for_each_thread(p, t)
+ flush_sigqueue_mask(&mask, &t->pending);
+ }
+ }
+
+ spin_unlock_irq(&p->sighand->siglock);
+ return 0;
+}
+
+#ifdef CONFIG_DYNAMIC_SIGFRAME
+static inline void sigaltstack_lock(void)
+ __acquires(¤t->sighand->siglock)
+{
+ spin_lock_irq(¤t->sighand->siglock);
+}
+
+static inline void sigaltstack_unlock(void)
+ __releases(¤t->sighand->siglock)
+{
+ spin_unlock_irq(¤t->sighand->siglock);
+}
+#else
+static inline void sigaltstack_lock(void)
+{
+}
+static inline void sigaltstack_unlock(void) {}
+#endif
+
+static int
+do_sigaltstack(const stack_t *ss, stack_t *oss, unsigned long sp,
+ size_t min_ss_size)
+{
+ struct task_struct *t = current;
+ int ret = 0;
+
+ if (oss)
+ {
+ memset(oss, 0, sizeof(stack_t));
+ oss->ss_sp = (void __user *)t->sas_ss_sp;
+ oss->ss_size = t->sas_ss_size;
+ oss->ss_flags = sas_ss_flags(sp) |
+ (current->sas_ss_flags & SS_FLAG_BITS);
+ }
+
+ if (ss)
+ {
+ void __user *ss_sp = ss->ss_sp;
+ size_t ss_size = ss->ss_size;
+ unsigned ss_flags = ss->ss_flags;
+ int ss_mode;
+
+ if (unlikely(on_sig_stack(sp)))
+ return -EPERM;
+
+ ss_mode = ss_flags & ~SS_FLAG_BITS;
+ if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
+ ss_mode != 0))
+ return -EINVAL;
+
+ sigaltstack_lock();
+ if (ss_mode == SS_DISABLE)
+ {
+ ss_size = 0;
+ ss_sp = NULL;
+ }
+ else
+ {
+ if (unlikely(ss_size < min_ss_size))
+ ret = -ENOMEM;
+ if (!sigaltstack_size_valid(ss_size))
+ ret = -ENOMEM;
+ }
+ if (!ret)
+ {
+ t->sas_ss_sp = (unsigned long)ss_sp;
+ t->sas_ss_size = ss_size;
+ t->sas_ss_flags = ss_flags;
+ }
+ sigaltstack_unlock();
+ }
+ return ret;
+}
+
+SYSCALL_DEFINE2(sigaltstack, const stack_t __user *, uss, stack_t __user *, uoss)
+{
+ stack_t new, old;
+ int err;
+ if (uss && copy_from_user(&new, uss, sizeof(stack_t)))
+ return -EFAULT;
+ err = do_sigaltstack(uss ? &new : NULL, uoss ? &old : NULL,
+ current_user_stack_pointer(),
+ MINSIGSTKSZ);
+ if (!err && uoss && copy_to_user(uoss, &old, sizeof(stack_t)))
+ err = -EFAULT;
+ return err;
+}
+
+int restore_altstack(const stack_t __user *uss)
+{
+ stack_t new;
+ if (copy_from_user(&new, uss, sizeof(stack_t)))
+ return -EFAULT;
+ (void)do_sigaltstack(&new, NULL, current_user_stack_pointer(),
+ MINSIGSTKSZ);
+ /* squash all but EFAULT for now */
+ return 0;
+}
+
+int __save_altstack(stack_t __user *uss, unsigned long sp)
+{
+ struct task_struct *t = current;
+ int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
+ __put_user(t->sas_ss_flags, &uss->ss_flags) |
+ __put_user(t->sas_ss_size, &uss->ss_size);
+ return err;
+}
+
+#ifdef CONFIG_COMPAT
+static int do_compat_sigaltstack(const compat_stack_t __user *uss_ptr,
+ compat_stack_t __user *uoss_ptr)
+{
+ stack_t uss, uoss;
+ int ret;
+
+ if (uss_ptr)
+ {
+ compat_stack_t uss32;
+ if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
+ return -EFAULT;
+ uss.ss_sp = compat_ptr(uss32.ss_sp);
+ uss.ss_flags = uss32.ss_flags;
+ uss.ss_size = uss32.ss_size;
+ }
+ ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss,
+ compat_user_stack_pointer(),
+ COMPAT_MINSIGSTKSZ);
+ if (ret >= 0 && uoss_ptr)
+ {
+ compat_stack_t old;
+ memset(&old, 0, sizeof(old));
+ old.ss_sp = ptr_to_compat(uoss.ss_sp);
+ old.ss_flags = uoss.ss_flags;
+ old.ss_size = uoss.ss_size;
+ if (copy_to_user(uoss_ptr, &old, sizeof(compat_stack_t)))
+ ret = -EFAULT;
+ }
+ return ret;
+}
+
+COMPAT_SYSCALL_DEFINE2(sigaltstack,
+ const compat_stack_t __user *, uss_ptr,
+ compat_stack_t __user *, uoss_ptr)
+{
+ return do_compat_sigaltstack(uss_ptr, uoss_ptr);
+}
+
+int compat_restore_altstack(const compat_stack_t __user *uss)
+{
+ int err = do_compat_sigaltstack(uss, NULL);
+ /* squash all but -EFAULT for now */
+ return err == -EFAULT ? err : 0;
+}
+
+int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
+{
+ int err;
+ struct task_struct *t = current;
+ err = __put_user(ptr_to_compat((void __user *)t->sas_ss_sp),
+ &uss->ss_sp) |
+ __put_user(t->sas_ss_flags, &uss->ss_flags) |
+ __put_user(t->sas_ss_size, &uss->ss_size);
+ return err;
+}
+#endif
+
+#ifdef __ARCH_WANT_SYS_SIGPENDING
+
+/**
+ * sys_sigpending - examine pending signals
+ * @uset: where mask of pending signal is returned
+ */
+SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, uset)
+{
+ sigset_t set;
+
+ if (sizeof(old_sigset_t) > sizeof(*uset))
+ return -EINVAL;
+
+ do_sigpending(&set);
+
+ if (copy_to_user(uset, &set, sizeof(old_sigset_t)))
+ return -EFAULT;
+
+ return 0;
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32)
+{
+ sigset_t set;
+
+ do_sigpending(&set);
+
+ return put_user(set.sig[0], set32);
+}
+#endif
+
+#endif
+
+#ifdef __ARCH_WANT_SYS_SIGPROCMASK
+/**
+ * sys_sigprocmask - examine and change blocked signals
+ * @how: whether to add, remove, or set signals
+ * @nset: signals to add or remove (if non-null)
+ * @oset: previous value of signal mask if non-null
+ *
+ * Some platforms have their own version with special arguments;
+ * others support only sys_rt_sigprocmask.
+ */
+
+SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
+ old_sigset_t __user *, oset)
+{
+ old_sigset_t old_set, new_set;
+ sigset_t new_blocked;
+
+ old_set = current->blocked.sig[0];
+
+ if (nset)
+ {
+ if (copy_from_user(&new_set, nset, sizeof(*nset)))
+ return -EFAULT;
+
+ new_blocked = current->blocked;
+
+ switch (how)
+ {
+ case SIG_BLOCK:
+ sigaddsetmask(&new_blocked, new_set);
+ break;
+ case SIG_UNBLOCK:
+ sigdelsetmask(&new_blocked, new_set);
+ break;
+ case SIG_SETMASK:
+ new_blocked.sig[0] = new_set;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ set_current_blocked(&new_blocked);
+ }
+
+ if (oset)
+ {
+ if (copy_to_user(oset, &old_set, sizeof(*oset)))
+ return -EFAULT;
+ }
+
+ return 0;
+}
+#endif /* __ARCH_WANT_SYS_SIGPROCMASK */
+
+#ifndef CONFIG_ODD_RT_SIGACTION
+/**
+ * sys_rt_sigaction - alter an action taken by a process
+ * @sig: signal to be sent
+ * @act: new sigaction
+ * @oact: used to save the previous sigaction
+ * @sigsetsize: size of sigset_t type
+ */
+SYSCALL_DEFINE4(rt_sigaction, int, sig,
+ const struct sigaction __user *, act,
+ struct sigaction __user *, oact,
+ size_t, sigsetsize)
+{
+ struct k_sigaction new_sa, old_sa;
+ int ret;
+
+ /* XXX: Don't preclude handling different sized sigset_t's. */
+ if (sigsetsize != sizeof(sigset_t))
+ return -EINVAL;
+
+ if (act && copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
+ return -EFAULT;
+
+ ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
+ if (ret)
+ return ret;
+
+ if (oact && copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
+ return -EFAULT;
+
+ return 0;
+}
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
+ const struct compat_sigaction __user *, act,
+ struct compat_sigaction __user *, oact,
+ compat_size_t, sigsetsize)
+{
+ struct k_sigaction new_ka, old_ka;
+#ifdef __ARCH_HAS_SA_RESTORER
+ compat_uptr_t restorer;
+#endif
+ int ret;
+
+ /* XXX: Don't preclude handling different sized sigset_t's. */
+ if (sigsetsize != sizeof(compat_sigset_t))
+ return -EINVAL;
+
+ if (act)
+ {
+ compat_uptr_t handler;
+ ret = get_user(handler, &act->sa_handler);
+ new_ka.sa.sa_handler = compat_ptr(handler);
+#ifdef __ARCH_HAS_SA_RESTORER
+ ret |= get_user(restorer, &act->sa_restorer);
+ new_ka.sa.sa_restorer = compat_ptr(restorer);
+#endif
+ ret |= get_compat_sigset(&new_ka.sa.sa_mask, &act->sa_mask);
+ ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
+ if (ret)
+ return -EFAULT;
+ }
+
+ ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
+ if (!ret && oact)
+ {
+ ret = put_user(ptr_to_compat(old_ka.sa.sa_handler),
+ &oact->sa_handler);
+ ret |= put_compat_sigset(&oact->sa_mask, &old_ka.sa.sa_mask,
+ sizeof(oact->sa_mask));
+ ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
+#ifdef __ARCH_HAS_SA_RESTORER
+ ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
+ &oact->sa_restorer);
+#endif
+ }
+ return ret;
+}
+#endif
+#endif /* !CONFIG_ODD_RT_SIGACTION */
+
+#ifdef CONFIG_OLD_SIGACTION
+SYSCALL_DEFINE3(sigaction, int, sig,
+ const struct old_sigaction __user *, act,
+ struct old_sigaction __user *, oact)
+{
+ struct k_sigaction new_ka, old_ka;
+ int ret;
+
+ if (act)
+ {
+ old_sigset_t mask;
+ if (!access_ok(act, sizeof(*act)) ||
+ __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
+ __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
+ __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
+ __get_user(mask, &act->sa_mask))
+ return -EFAULT;
+#ifdef __ARCH_HAS_KA_RESTORER
+ new_ka.ka_restorer = NULL;
+#endif
+ siginitset(&new_ka.sa.sa_mask, mask);
+ }
+
+ ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
+
+ if (!ret && oact)
+ {
+ if (!access_ok(oact, sizeof(*oact)) ||
+ __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
+ __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
+ __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
+ __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
+ return -EFAULT;
+ }
+
+ return ret;
+}
+#endif
+#ifdef CONFIG_COMPAT_OLD_SIGACTION
+COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
+ const struct compat_old_sigaction __user *, act,
+ struct compat_old_sigaction __user *, oact)
+{
+ struct k_sigaction new_ka, old_ka;
+ int ret;
+ compat_old_sigset_t mask;
+ compat_uptr_t handler, restorer;
+
+ if (act)
+ {
+ if (!access_ok(act, sizeof(*act)) ||
+ __get_user(handler, &act->sa_handler) ||
+ __get_user(restorer, &act->sa_restorer) ||
+ __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
+ __get_user(mask, &act->sa_mask))
+ return -EFAULT;
+
+#ifdef __ARCH_HAS_KA_RESTORER
+ new_ka.ka_restorer = NULL;
+#endif
+ new_ka.sa.sa_handler = compat_ptr(handler);
+ new_ka.sa.sa_restorer = compat_ptr(restorer);
+ siginitset(&new_ka.sa.sa_mask, mask);
+ }
+
+ ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
+
+ if (!ret && oact)
+ {
+ if (!access_ok(oact, sizeof(*oact)) ||
+ __put_user(ptr_to_compat(old_ka.sa.sa_handler),
+ &oact->sa_handler) ||
+ __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
+ &oact->sa_restorer) ||
+ __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
+ __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
+ return -EFAULT;
+ }
+ return ret;
+}
+#endif
+
+#ifdef CONFIG_SGETMASK_SYSCALL
+
+/*
+ * For backwards compatibility. Functionality superseded by sigprocmask.
+ */
+SYSCALL_DEFINE0(sgetmask)
+{
+ /* SMP safe */
+ return current->blocked.sig[0];
+}
+
+SYSCALL_DEFINE1(ssetmask, int, newmask)
+{
+ int old = current->blocked.sig[0];
+ sigset_t newset;
+
+ siginitset(&newset, newmask);
+ set_current_blocked(&newset);
+
+ return old;
+}
+#endif /* CONFIG_SGETMASK_SYSCALL */
+
+#ifdef __ARCH_WANT_SYS_SIGNAL
+/*
+ * For backwards compatibility. Functionality superseded by sigaction.
+ */
+SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
+{
+ struct k_sigaction new_sa, old_sa;
+ int ret;
+
+ new_sa.sa.sa_handler = handler;
+ new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
+ sigemptyset(&new_sa.sa.sa_mask);
+
+ ret = do_sigaction(sig, &new_sa, &old_sa);
+
+ return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
+}
+#endif /* __ARCH_WANT_SYS_SIGNAL */
+
+#ifdef __ARCH_WANT_SYS_PAUSE
+
+SYSCALL_DEFINE0(pause)
+{
+ while (!signal_pending(current))
+ {
+ __set_current_state(TASK_INTERRUPTIBLE);
+ schedule();
+ }
+ return -ERESTARTNOHAND;
+}
+
+#endif
+
+static int sigsuspend(sigset_t *set)
+{
+ current->saved_sigmask = current->blocked;
+ set_current_blocked(set);
+
+ while (!signal_pending(current))
+ {
+ __set_current_state(TASK_INTERRUPTIBLE);
+ schedule();
+ }
+ set_restore_sigmask();
+ return -ERESTARTNOHAND;
+}
+
+/**
+ * sys_rt_sigsuspend - replace the signal mask for a value with the
+ * @unewset value until a signal is received
+ * @unewset: new signal mask value
+ * @sigsetsize: size of sigset_t type
+ */
+SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
+{
+ sigset_t newset;
+
+ /* XXX: Don't preclude handling different sized sigset_t's. */
+ if (sigsetsize != sizeof(sigset_t))
+ return -EINVAL;
+
+ if (copy_from_user(&newset, unewset, sizeof(newset)))
+ return -EFAULT;
+ return sigsuspend(&newset);
+}
+
+#ifdef CONFIG_COMPAT
+COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
+{
+ sigset_t newset;
+
+ /* XXX: Don't preclude handling different sized sigset_t's. */
+ if (sigsetsize != sizeof(sigset_t))
+ return -EINVAL;
+
+ if (get_compat_sigset(&newset, unewset))
+ return -EFAULT;
+ return sigsuspend(&newset);
+}
+#endif
+
+#ifdef CONFIG_OLD_SIGSUSPEND
+SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
+{
+ sigset_t blocked;
+ siginitset(&blocked, mask);
+ return sigsuspend(&blocked);
+}
+#endif
+#ifdef CONFIG_OLD_SIGSUSPEND3
+SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
+{
+ sigset_t blocked;
+ siginitset(&blocked, mask);
+ return sigsuspend(&blocked);
+}
+#endif
+
+__weak const char *arch_vma_name(struct vm_area_struct *vma)
+{
+ return NULL;
+}
+
+static inline void siginfo_buildtime_checks(void)
+{
+ BUILD_BUG_ON(sizeof(struct siginfo) != SI_MAX_SIZE);
+
+ /* Verify the offsets in the two siginfos match */
+#define CHECK_OFFSET(field) \
+ BUILD_BUG_ON(offsetof(siginfo_t, field) != offsetof(kernel_siginfo_t, field))
+
+ /* kill */
+ CHECK_OFFSET(si_pid);
+ CHECK_OFFSET(si_uid);
+
+ /* timer */
+ CHECK_OFFSET(si_tid);
+ CHECK_OFFSET(si_overrun);
+ CHECK_OFFSET(si_value);
+
+ /* rt */
+ CHECK_OFFSET(si_pid);
+ CHECK_OFFSET(si_uid);
+ CHECK_OFFSET(si_value);
+
+ /* sigchld */
+ CHECK_OFFSET(si_pid);
+ CHECK_OFFSET(si_uid);
+ CHECK_OFFSET(si_status);
+ CHECK_OFFSET(si_utime);
+ CHECK_OFFSET(si_stime);
+
+ /* sigfault */
+ CHECK_OFFSET(si_addr);
+ CHECK_OFFSET(si_trapno);
+ CHECK_OFFSET(si_addr_lsb);
+ CHECK_OFFSET(si_lower);
+ CHECK_OFFSET(si_upper);
+ CHECK_OFFSET(si_pkey);
+ CHECK_OFFSET(si_perf_data);
+ CHECK_OFFSET(si_perf_type);
+
+ /* sigpoll */
+ CHECK_OFFSET(si_band);
+ CHECK_OFFSET(si_fd);
+
+ /* sigsys */
+ CHECK_OFFSET(si_call_addr);
+ CHECK_OFFSET(si_syscall);
+ CHECK_OFFSET(si_arch);
+#undef CHECK_OFFSET
+
+ /* usb asyncio */
+ BUILD_BUG_ON(offsetof(struct siginfo, si_pid) !=
+ offsetof(struct siginfo, si_addr));
+ if (sizeof(int) == sizeof(void __user *))
+ {
+ BUILD_BUG_ON(sizeof_field(struct siginfo, si_pid) !=
+ sizeof(void __user *));
+ }
+ else
+ {
+ BUILD_BUG_ON((sizeof_field(struct siginfo, si_pid) +
+ sizeof_field(struct siginfo, si_uid)) !=
+ sizeof(void __user *));
+ BUILD_BUG_ON(offsetofend(struct siginfo, si_pid) !=
+ offsetof(struct siginfo, si_uid));
+ }
+#ifdef CONFIG_COMPAT
+ BUILD_BUG_ON(offsetof(struct compat_siginfo, si_pid) !=
+ offsetof(struct compat_siginfo, si_addr));
+ BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
+ sizeof(compat_uptr_t));
+ BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
+ sizeof_field(struct siginfo, si_pid));
+#endif
+}
+
+void __init signals_init(void)
+{
+ siginfo_buildtime_checks();
+
+ sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC | SLAB_ACCOUNT);
+}
+
+#ifdef CONFIG_KGDB_KDB
+#include <linux/kdb.h>
+/*
+ * kdb_send_sig - Allows kdb to send signals without exposing
+ * signal internals. This function checks if the required locks are
+ * available before calling the main signal code, to avoid kdb
+ * deadlocks.
+ */
+void kdb_send_sig(struct task_struct *t, int sig)
+{
+ static struct task_struct *kdb_prev_t;
+ int new_t, ret;
+ if (!spin_trylock(&t->sighand->siglock))
+ {
+ kdb_printf("Can't do kill command now.\n"
+ "The sigmask lock is held somewhere else in "
+ "kernel, try again later\n");
+ return;
+ }
+ new_t = kdb_prev_t != t;
+ kdb_prev_t = t;
+ if (!task_is_running(t) && new_t)
+ {
+ spin_unlock(&t->sighand->siglock);
+ kdb_printf("Process is not RUNNING, sending a signal from "
+ "kdb risks deadlock\n"
+ "on the run queue locks. "
+ "The signal has _not_ been sent.\n"
+ "Reissue the kill command if you want to risk "
+ "the deadlock.\n");
+ return;
+ }
+ ret = send_signal(sig, SEND_SIG_PRIV, t, PIDTYPE_PID);
+ spin_unlock(&t->sighand->siglock);
+ if (ret)
+ kdb_printf("Fail to deliver Signal %d to process %d.\n",
+ sig, t->pid);
+ else
+ kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
+}
+#endif /* CONFIG_KGDB_KDB */
diff --git a/ableos/src/arch/aarch32/boot.s b/ableos/src/arch/aarch32/boot.s
new file mode 100644
index 0000000..6ff3a59
--- /dev/null
+++ b/ableos/src/arch/aarch32/boot.s
@@ -0,0 +1,52 @@
+// AArch32 mode
+
+// To keep this in the first portion of the binary.
+.section ".text.boot"
+
+// Make _start global.
+.globl _start
+
+ .org 0x8000
+// Entry point for the kernel.
+// r15 -> should begin execution at 0x8000.
+// r0 -> 0x00000000
+// r1 -> 0x00000C42 - machine id
+// r2 -> 0x00000100 - start of ATAGS
+// preserve these registers as argument for kernel_main
+_start:
+ // Shut off extra cores
+ mrc p15, 0, r5, c0, c0, 5
+ and r5, r5, #3
+ cmp r5, #0
+ bne halt
+
+ // Setup the stack.
+ ldr r5, =_start
+ mov sp, r5
+
+ // Clear out bss.
+ ldr r4, =__bss_start
+ ldr r9, =__bss_end
+ mov r5, #0
+ mov r6, #0
+ mov r7, #0
+ mov r8, #0
+ b 2f
+
+1:
+ // store multiple at r4.
+ stmia r4!, {r5-r8}
+
+ // If we are still below bss_end, loop.
+2:
+ cmp r4, r9
+ blo 1b
+
+ // Call kernel_main
+ ldr r3, =kernel_main
+ blx r3
+
+ // halt
+halt:
+ wfe
+ b halt
diff --git a/ableos/src/arch/aarch32/build.sh b/ableos/src/arch/aarch32/build.sh
new file mode 100644
index 0000000..e1cc335
--- /dev/null
+++ b/ableos/src/arch/aarch32/build.sh
@@ -0,0 +1,7 @@
+arm-none-eabi-gcc -mcpu=cortex-a7 -fpic -ffreestanding -c src/arch/aarch32/boot.s -o boot.o
+mv src/main.rs src/main.rs.pass
+cargo build --release --target json_targets/aarch32-ableos.json
+arm-none-eabi-gcc -T src/arch/aarch32/linker.ld -o ableos.elf -ffreestanding -O2 -nostdlib boot.o \
+target/aarch32-ableos/release/libableos.rlib
+mv src/main.rs.pass src/main.rs
+rm boot.o
diff --git a/ableos/src/arch/aarch32/drivers/graphics.rs b/ableos/src/arch/aarch32/drivers/graphics.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/ableos/src/arch/aarch32/drivers/graphics.rs
@@ -0,0 +1 @@
+
diff --git a/ableos/src/arch/aarch32/drivers/mod.rs b/ableos/src/arch/aarch32/drivers/mod.rs
new file mode 100644
index 0000000..175de44
--- /dev/null
+++ b/ableos/src/arch/aarch32/drivers/mod.rs
@@ -0,0 +1 @@
+pub mod graphics;
diff --git a/ableos/src/arch/aarch32/init.rs b/ableos/src/arch/aarch32/init.rs
new file mode 100644
index 0000000..e74274f
--- /dev/null
+++ b/ableos/src/arch/aarch32/init.rs
@@ -0,0 +1,4 @@
+use super::write;
+pub fn init() {
+ write("booted on arm :>\n");
+}
diff --git a/ableos/src/arch/aarch32/linker.ld b/ableos/src/arch/aarch32/linker.ld
new file mode 100644
index 0000000..1f51675
--- /dev/null
+++ b/ableos/src/arch/aarch32/linker.ld
@@ -0,0 +1,43 @@
+ENTRY(_start)
+
+SECTIONS
+{
+ /* Starts at LOADER_ADDR. */
+ . = 0x80000;
+ __start = .;
+ __text_start = .;
+ .text :
+ {
+ KEEP(*(.text.boot))
+ *(.text)
+ }
+ . = ALIGN(4096); /* align to page size */
+ __text_end = .;
+
+ __rodata_start = .;
+ .rodata :
+ {
+ *(.rodata)
+ }
+ . = ALIGN(4096); /* align to page size */
+ __rodata_end = .;
+
+ __data_start = .;
+ .data :
+ {
+ *(.data)
+ }
+ . = ALIGN(4096); /* align to page size */
+ __data_end = .;
+
+ __bss_start = .;
+ .bss :
+ {
+ bss = .;
+ *(.bss)
+ }
+ . = ALIGN(4096); /* align to page size */
+ __bss_end = .;
+ __bss_size = __bss_end - __bss_start;
+ __end = .;
+}
diff --git a/ableos/src/arch/aarch32/mbox.rs b/ableos/src/arch/aarch32/mbox.rs
new file mode 100644
index 0000000..46230d8
--- /dev/null
+++ b/ableos/src/arch/aarch32/mbox.rs
@@ -0,0 +1,2 @@
+const MMIO_BASE: u32 = 0x3F00_0000;
+const VIDEOCORE_MBOX: u32 = MMIO_BASE + 0xB880;
diff --git a/ableos/src/arch/aarch32/mod.rs b/ableos/src/arch/aarch32/mod.rs
new file mode 100644
index 0000000..68809b1
--- /dev/null
+++ b/ableos/src/arch/aarch32/mod.rs
@@ -0,0 +1,38 @@
+#![allow(warnings)]
+pub const ARCH: &'static str = "aarch32";
+use core::intrinsics::{volatile_load, volatile_store};
+pub mod drivers;
+pub mod init;
+pub mod mbox;
+// raspi2 and raspi3 have peripheral base address 0x3F000000,
+// b ut raspi1 has peripheral base address 0x20000000. Ensure
+// you are using the correct peripheral address for your
+// hardware.
+const UART_DR: u32 = 0x3F201000;
+const UART_FR: u32 = 0x3F201018;
+pub fn mmio_write(reg: u32, val: u32) {
+ unsafe { volatile_store(reg as *mut u32, val) }
+}
+pub fn mmio_read(reg: u32) -> u32 {
+ unsafe { volatile_load(reg as *const u32) }
+}
+pub fn transmit_fifo_full() -> bool {
+ mmio_read(UART_FR) & (1 << 5) > 0
+}
+pub fn receive_fifo_empty() -> bool {
+ mmio_read(UART_FR) & (1 << 4) > 0
+}
+pub fn writec(c: u8) {
+ while transmit_fifo_full() {}
+ mmio_write(UART_DR, c as u32);
+}
+pub fn getc() -> u8 {
+ while receive_fifo_empty() {}
+ mmio_read(UART_DR) as u8
+}
+pub fn write(msg: &str) {
+ for c in msg.chars() {
+ writec(c as u8)
+ }
+}
+pub fn shutdown() {}
diff --git a/ableos/src/arch/aarch32/run.sh b/ableos/src/arch/aarch32/run.sh
new file mode 100644
index 0000000..a30d46c
--- /dev/null
+++ b/ableos/src/arch/aarch32/run.sh
@@ -0,0 +1,3 @@
+sh src/arch/aarch32/build.sh && \
+qemu-system-arm -M raspi2 -kernel ableos.elf --serial stdio && \
+rm ableos.elf
diff --git a/ableos/src/arch/aarch64/aarch64-qemu.ld b/ableos/src/arch/aarch64/aarch64-qemu.ld
new file mode 100644
index 0000000..66ca0ce
--- /dev/null
+++ b/ableos/src/arch/aarch64/aarch64-qemu.ld
@@ -0,0 +1,14 @@
+ENTRY(_start)
+SECTIONS
+{
+ . = 0x40000000;
+ .text.boot : { *(.text.boot) }
+ .text : { *(.text) }
+ .data : { *(.data) }
+ .rodata : { *(.rodata) }
+ .bss : { *(.bss) }
+
+ . = ALIGN(8);
+ . = . + 0x4000;
+ LD_STACK_PTR = .;
+}
diff --git a/ableos/src/arch/aarch64/boot.s b/ableos/src/arch/aarch64/boot.s
new file mode 100644
index 0000000..40680ed
--- /dev/null
+++ b/ableos/src/arch/aarch64/boot.s
@@ -0,0 +1,15 @@
+.globl _start
+.extern LD_STACK_PTR
+
+.section ".text.boot"
+
+_start:
+ ldr x30, =LD_STACK_PTR
+ mov sp, x30
+ bl not_main
+
+.equ PSCI_SYSTEM_OFF, 0x84000008
+.globl system_off
+system_off:
+ ldr x0, =PSCI_SYSTEM_OFF
+ hvc #0
diff --git a/ableos/src/arch/aarch64/drivers/graphics.rs b/ableos/src/arch/aarch64/drivers/graphics.rs
new file mode 100644
index 0000000..66ad297
--- /dev/null
+++ b/ableos/src/arch/aarch64/drivers/graphics.rs
@@ -0,0 +1,31 @@
+use crate::driver_traits::graphics::{Graphics, Point, Rgb};
+
+pub struct GraphicsBuffer;
+
+#[allow(unused)]
+impl Graphics for GraphicsBuffer {
+ fn put_line(coords_start: Point, coords_end: Point, thickness: u32, color: Rgb) {
+ todo!()
+ }
+ fn put_rect(coords_start: Point, coords_end: Point, color: Rgb) {
+ todo!()
+ }
+ fn put_circle(coords: Point, radius: u32) {
+ todo!()
+ }
+ fn put_triangle(coords_1: Point, coords_2: Point, coords_3: Point, thickness: u32, color: Rgb) {
+ todo!();
+ }
+ fn put_pixel(coords: Point, color: Rgb) {
+ todo!()
+ }
+ fn paint_cursor(coords: Point) {
+ todo!()
+ }
+ fn hide_cursor() {}
+ fn show_cursor() {}
+ fn draw() {}
+ fn clear() {
+ todo!()
+ }
+}
diff --git a/ableos/src/arch/aarch64/drivers/mod.rs b/ableos/src/arch/aarch64/drivers/mod.rs
new file mode 100644
index 0000000..ae69ade
--- /dev/null
+++ b/ableos/src/arch/aarch64/drivers/mod.rs
@@ -0,0 +1,2 @@
+pub mod graphics;
+pub mod nrf52;
diff --git a/ableos/src/arch/aarch64/drivers/nrf52.rs b/ableos/src/arch/aarch64/drivers/nrf52.rs
new file mode 100644
index 0000000..1aa8348
--- /dev/null
+++ b/ableos/src/arch/aarch64/drivers/nrf52.rs
@@ -0,0 +1,73 @@
+#![allow(dead_code)]
+
+// A not-very-useful abstraction of GPIOs in Rust
+
+use core::sync::atomic::{AtomicBool, Ordering::SeqCst};
+
+/// A struct that represents an nRF52 Pin
+pub struct Pin(u8);
+
+/// A struct that represents P0 of the nRF52
+pub struct Pins {
+ pub p0_31: Pin,
+}
+
+impl Pins {
+ /// A function to obtain a Port 0 singleton structure
+ pub fn take() -> Self {
+ static TAKEN: AtomicBool = AtomicBool::new(false);
+
+ // Enforce this as a singleton
+ assert!(!TAKEN.swap(true, SeqCst));
+
+ Self { p0_31: Pin(31) }
+ }
+}
+
+/// The level of a GPIO
+#[derive(Copy, Clone)]
+pub enum Level {
+ Low,
+ High,
+}
+
+const REG_P0_PIN_CNF_BASE: *mut u32 = 0x5000_0700 as *mut u32;
+const REG_P0_OUT_SET: *mut u32 = 0x5000_0508 as *mut u32;
+const REG_P0_OUT_CLR: *mut u32 = 0x5000_050C as *mut u32;
+
+const PIN_CNF_DIR_OUTPUT: u32 = 0x0000_0001;
+const PIN_CNF_INPUT_CONNECT: u32 = 0x0000_0000;
+const PIN_CNF_PULL_DISABLED: u32 = 0x0000_0000;
+const PIN_CNF_DRIVE_S0S1: u32 = 0x0000_0000;
+const PIN_CNF_SENSE_DISABLED: u32 = 0x0000_0000;
+
+impl Pin {
+ /// Set a pin to be a push pull output
+ pub fn set_push_pull_output(&mut self, level: Level) {
+ // set level
+ match level {
+ Level::High => self.set_high(),
+ Level::Low => self.set_low(),
+ }
+
+ let set_val = PIN_CNF_DIR_OUTPUT
+ | PIN_CNF_INPUT_CONNECT
+ | PIN_CNF_PULL_DISABLED
+ | PIN_CNF_DRIVE_S0S1
+ | PIN_CNF_SENSE_DISABLED;
+
+ unsafe {
+ core::ptr::write_volatile(REG_P0_PIN_CNF_BASE.offset(self.0 as isize), set_val);
+ }
+ }
+
+ /// Set a pin to output level low
+ pub fn set_low(&mut self) {
+ unsafe { core::ptr::write_volatile(REG_P0_OUT_SET, 1 << (self.0 as u32)) }
+ }
+
+ /// Set a pin to output level high
+ pub fn set_high(&mut self) {
+ unsafe { core::ptr::write_volatile(REG_P0_OUT_CLR, 1 << (self.0 as u32)) }
+ }
+}
diff --git a/ableos/src/arch/aarch64/init.rs b/ableos/src/arch/aarch64/init.rs
new file mode 100644
index 0000000..12cd021
--- /dev/null
+++ b/ableos/src/arch/aarch64/init.rs
@@ -0,0 +1 @@
+pub fn init() {}
diff --git a/ableos/src/arch/aarch64/mod.rs b/ableos/src/arch/aarch64/mod.rs
new file mode 100644
index 0000000..40f5a8f
--- /dev/null
+++ b/ableos/src/arch/aarch64/mod.rs
@@ -0,0 +1,67 @@
+use core::ptr;
+
+// mod panic;
+pub mod drivers;
+pub mod init;
+
+pub mod serial;
+use crate::arch::drivers::nrf52::{Level, Pins};
+use core::ptr::write_volatile;
+global_asm!(include_str!("boot.s"));
+
+fn delay(ticks: usize) {
+ static mut DUMMY: usize = 0;
+
+ // Reduce the number of iterations when in debug mode
+ #[cfg(debug_assertions)]
+ let ticks = ticks / 128;
+
+ for t in 0..ticks {
+ // Prevent the optimizer from removing this loop
+ unsafe {
+ write_volatile(&mut DUMMY, t);
+ }
+ }
+}
+use crate::print;
+
+#[no_mangle]
+pub extern "C" fn not_main() {
+ const UART0: *mut u8 = 0x0900_0000 as *mut u8;
+ for byte in b"ableOS Arm 64" {
+ unsafe {
+ ptr::write_volatile(UART0, *byte);
+ }
+ }
+
+ let gpios = Pins::take();
+ let mut led = gpios.p0_31;
+
+ loop {
+ led.set_high();
+ delay(2_000_000);
+
+ led.set_low();
+ delay(6_000_000);
+ }
+
+ led.set_push_pull_output(Level::Low);
+ crate::kmain::kernel_main();
+
+ sloop();
+}
+
+pub fn sloop() -> ! {
+ loop {}
+}
+pub fn print() {
+ for byte in b"ableOS Arm 64" {
+ const UART0: *mut u8 = 0x0900_0000 as *mut u8;
+
+ unsafe {
+ ptr::write_volatile(UART0, *byte);
+ }
+ }
+}
+
+pub fn shutdown() {}
diff --git a/ableos/src/arch/aarch64/run.sh b/ableos/src/arch/aarch64/run.sh
new file mode 100644
index 0000000..494f5b8
--- /dev/null
+++ b/ableos/src/arch/aarch64/run.sh
@@ -0,0 +1,4 @@
+cargo build --target=json_targets/aarch64-ableos.json --release &&\
+qemu-system-aarch64 -machine virt -m 1024M -cpu cortex-a53 \
+-kernel target/aarch64-ableos/release/ableos -serial stdio \
+-device virtio-keyboard
diff --git a/ableos/src/arch/aarch64/serial.rs b/ableos/src/arch/aarch64/serial.rs
new file mode 100644
index 0000000..98a22e4
--- /dev/null
+++ b/ableos/src/arch/aarch64/serial.rs
@@ -0,0 +1,12 @@
+#[macro_export]
+macro_rules! serial_print {
+ ($($arg:tt)*) => {};
+}
+
+/// Prints to the host through the serial interface, appending a newline.
+#[macro_export]
+macro_rules! serial_println {
+ () => {};
+ ($fmt:expr) => {};
+ ($fmt:expr, $($arg:tt)*) => {};
+}
diff --git a/ableos/src/arch/ps_portable/drivers/graphics.rs b/ableos/src/arch/ps_portable/drivers/graphics.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/ableos/src/arch/ps_portable/drivers/graphics.rs
@@ -0,0 +1 @@
+
diff --git a/ableos/src/arch/ps_portable/drivers/mod.rs b/ableos/src/arch/ps_portable/drivers/mod.rs
new file mode 100644
index 0000000..175de44
--- /dev/null
+++ b/ableos/src/arch/ps_portable/drivers/mod.rs
@@ -0,0 +1 @@
+pub mod graphics;
diff --git a/ableos/src/arch/ps_portable/init.rs b/ableos/src/arch/ps_portable/init.rs
new file mode 100644
index 0000000..8dd6519
--- /dev/null
+++ b/ableos/src/arch/ps_portable/init.rs
@@ -0,0 +1,2 @@
+use super::*;
+pub fn init() {}
diff --git a/ableos/src/arch/ps_portable/mod.rs b/ableos/src/arch/ps_portable/mod.rs
new file mode 100644
index 0000000..d293b61
--- /dev/null
+++ b/ableos/src/arch/ps_portable/mod.rs
@@ -0,0 +1,47 @@
+#![no_std]
+#![no_main]
+pub const ARCH: &'static str = "mipsr4000";
+pub mod drivers;
+static mut LIST: psp::Align16<[u32; 0x40000]> = psp::Align16([0; 0x40000]);
+// Create a module named "sample_module" with version 1.0
+psp::module!("ableos", 1, 0);
+fn psp_main() {
+ // println!("AbleOS booted on PSP");
+ // todo
+ // println!("{}", crate::experiments::systeminfo::format_system_info());
+ // gl_basic();
+ println!("{}", crate::time::kilotime::Kilosecond::from_sec(23944));
+ let mut second = timer_update().seconds;
+ loop {
+ /*
+ {
+ let time = timer_update();
+ // FIXME: this is a little broken
+ if (second) == time.seconds {
+ if second == 59 {
+ second = 0;
+ }
+ // time
+ print!(
+ "{:?}/{:?}/{:?} {:02}:{:02}:{:02} UTC\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n",
+ time.year, time.month, time.day, time.hour, time.minutes, time.seconds
+ );
+ second += 1;
+ }
+ }
+ */
+ }
+}
+pub fn shutdown() {}
+mod simple_graphics;
+use simple_graphics::gl_basic;
+mod timer;
+use crate::arch::timer::timer_update;
+use core::ffi::c_void;
+use psp::{
+ sys::{self, DisplayPixelFormat, GuState, TexturePixelFormat},
+ vram_alloc::get_vram_allocator,
+ {BUF_WIDTH, SCREEN_HEIGHT, SCREEN_WIDTH},
+};
+pub mod init;
+use crate::println;
diff --git a/ableos/src/arch/ps_portable/simple_graphics.rs b/ableos/src/arch/ps_portable/simple_graphics.rs
new file mode 100644
index 0000000..bfcd766
--- /dev/null
+++ b/ableos/src/arch/ps_portable/simple_graphics.rs
@@ -0,0 +1,27 @@
+use crate::arch::*;
+/// used as a very basic bare minimum gl example
+pub fn gl_basic() {
+ unsafe {
+ let mut allocator = get_vram_allocator().unwrap();
+ let fbp0 = allocator
+ .alloc_texture_pixels(BUF_WIDTH, SCREEN_HEIGHT, TexturePixelFormat::Psm8888)
+ .as_mut_ptr_from_zero();
+ sys::sceGuInit();
+ sys::sceGuStart(
+ sys::GuContextType::Direct,
+ &mut LIST as *mut _ as *mut c_void,
+ );
+ sys::sceGuDrawBuffer(DisplayPixelFormat::Psm8888, fbp0 as _, BUF_WIDTH as i32);
+ sys::sceGuDebugPrint(
+ 100,
+ 100,
+ 0xff0000ff,
+ b"hi there from ableOS PSP graphics\0" as *const u8,
+ );
+ sys::sceGuDebugFlush();
+ sys::sceGuFinish();
+ sys::sceGuSync(sys::GuSyncMode::Finish, sys::GuSyncBehavior::Wait);
+ sys::sceDisplayWaitVblankStart();
+ sys::sceGuDisplay(true);
+ }
+}
diff --git a/ableos/src/arch/ps_portable/timer.rs b/ableos/src/arch/ps_portable/timer.rs
new file mode 100644
index 0000000..5a11b40
--- /dev/null
+++ b/ableos/src/arch/ps_portable/timer.rs
@@ -0,0 +1,13 @@
+pub fn timer_update() -> ScePspDateTime {
+ unsafe {
+ let mut tick = 0;
+ psp::sys::sceRtcGetCurrentTick(&mut tick);
+ // Convert the tick to an instance of `ScePspDateTime`
+ let mut date = MaybeUninit::uninit();
+ psp::sys::sceRtcSetTick(date.as_mut_ptr(), &tick);
+ let date = date.assume_init();
+ return date;
+ }
+}
+use core::mem::MaybeUninit;
+use psp::sys::ScePspDateTime;
diff --git a/ableos/src/arch/riscv/asm/boot.asm b/ableos/src/arch/riscv/asm/boot.asm
new file mode 100644
index 0000000..2259f6c
--- /dev/null
+++ b/ableos/src/arch/riscv/asm/boot.asm
@@ -0,0 +1,58 @@
+.S
+# bootloader for SoS
+# Stephen Marz
+# 8 February 2019
+.option norvc
+.section .data
+
+.section .text.init
+.global _start
+_start:
+ # Any hardware threads (hart) that are not bootstrapping
+ # need to wait for an IPI
+ csrr t0, mhartid
+ bnez t0, 3f
+ # SATP should be zero, but let's make sure
+ csrw satp, zero
+.option push
+.option norelax
+ la gp, _global_pointer
+.option pop
+
+ # The BSS section is expected to be zero
+ la a0, _bss_start
+ la a1, _bss_end
+ bgeu a0, a1, 2f
+1:
+ sd zero, (a0)
+ addi a0, a0, 8
+ bltu a0, a1, 1b
+2:
+
+
+
+3:
+ wfi
+ j 3b
+
+# Control registers, set the stack, mstatus, mepc,
+# and mtvec to return to the main function.
+# li t5, 0xffff;
+# csrw medeleg, t5
+# csrw mideleg, t5
+la sp, _stack
+# We use mret here so that the mstatus register
+# is properly updated.
+li t0, (0b11 << 11) | (1 << 7) | (1 << 3)
+csrw mstatus, t0
+la t1, kernel_main
+csrw mepc, t1
+la t2, asm_trap_vector
+csrw mtvec, t2
+li t3, (1 << 3) | (1 << 7) | (1 << 11)
+csrw mie, t3
+la ra, 4f
+mret
+4:
+ wfi
+ j 4b
diff --git a/ableos/src/arch/riscv/asm/trap.asm b/ableos/src/arch/riscv/asm/trap.asm
new file mode 100644
index 0000000..60e9351
--- /dev/null
+++ b/ableos/src/arch/riscv/asm/trap.asm
@@ -0,0 +1,8 @@
+# trap.S
+# Assembly-level trap handler.
+.section .text
+.global asm_trap_vector
+asm_trap_vector:
+ # We get here when the CPU is interrupted
+ # for any reason.
+ mret
diff --git a/ableos/src/arch/x86_64/.runners/debug.sh b/ableos/src/arch/x86_64/.runners/debug.sh
new file mode 100644
index 0000000..caac024
--- /dev/null
+++ b/ableos/src/arch/x86_64/.runners/debug.sh
@@ -0,0 +1,2 @@
+cargo bootimage --target json_targets/x86_64-ableos.json && \
+qemu-system-x86_64 -S -gdb tcp::9000 -drive format=raw,file=target/x86_64-ableos/debug/bootimage-ableos.bin
diff --git a/ableos/src/arch/x86_64/.runners/run-debug.sh b/ableos/src/arch/x86_64/.runners/run-debug.sh
new file mode 100644
index 0000000..448bf8c
--- /dev/null
+++ b/ableos/src/arch/x86_64/.runners/run-debug.sh
@@ -0,0 +1,2 @@
+cargo bootimage --target json_targets/x86_64-ableos.json && \
+qemu-system-x86_64 -drive format=raw,file=target/x86_64-ableos/debug/bootimage-ableos.bin
diff --git a/ableos/src/arch/x86_64/.runners/run-test.sh b/ableos/src/arch/x86_64/.runners/run-test.sh
new file mode 100644
index 0000000..448bf8c
--- /dev/null
+++ b/ableos/src/arch/x86_64/.runners/run-test.sh
@@ -0,0 +1,2 @@
+cargo bootimage --target json_targets/x86_64-ableos.json && \
+qemu-system-x86_64 -drive format=raw,file=target/x86_64-ableos/debug/bootimage-ableos.bin
diff --git a/ableos/src/arch/x86_64/.runners/run.sh b/ableos/src/arch/x86_64/.runners/run.sh
new file mode 100644
index 0000000..afd3b54
--- /dev/null
+++ b/ableos/src/arch/x86_64/.runners/run.sh
@@ -0,0 +1,2 @@
+cargo bootimage --release --target json_targets/x86_64-ableos.json && \
+qemu-system-x86_64 -drive format=raw,file=target/x86_64-ableos/release/bootimage-ableos.bin
diff --git a/ableos/src/arch/x86_64/drivers/graphics.rs b/ableos/src/arch/x86_64/drivers/graphics.rs
new file mode 100644
index 0000000..b78999f
--- /dev/null
+++ b/ableos/src/arch/x86_64/drivers/graphics.rs
@@ -0,0 +1,35 @@
+use crate::driver_traits::graphics::{Graphics, Point, Rgb};
+use cpuio::outw;
+
+pub struct GraphicsBuffer;
+
+#[allow(unused)]
+impl Graphics for GraphicsBuffer {
+ fn put_line(coords_start: Point, coords_end: Point, thickness: u32, color: Rgb) {
+ todo!()
+ }
+ fn put_rect(coords_start: Point, coords_end: Point, color: Rgb) {}
+ fn put_circle(coords: Point, radius: u32) {
+ todo!()
+ }
+ fn put_triangle(coords_1: Point, coords_2: Point, coords_3: Point, thickness: u32, color: Rgb) {
+ todo!();
+ }
+ fn put_pixel(coords: Point, color: Rgb) {
+ todo!()
+ }
+ fn paint_cursor(coords: Point) {
+ todo!()
+ }
+ fn hide_cursor() {
+ unsafe {
+ outw(0x0A, 0x3D4);
+ outw(0x20, 0x3D5);
+ }
+ }
+ fn show_cursor() {}
+ fn draw() {}
+ fn clear() {
+ todo!()
+ }
+}
diff --git a/ableos/src/arch/x86_64/drivers/mod.rs b/ableos/src/arch/x86_64/drivers/mod.rs
new file mode 100644
index 0000000..d5087e9
--- /dev/null
+++ b/ableos/src/arch/x86_64/drivers/mod.rs
@@ -0,0 +1,5 @@
+pub mod graphics;
+pub mod serial;
+
+#[deprecated(note = "The use of hardware specific drivers for VGA is discouraged")]
+pub mod vga;
diff --git a/ableos/src/arch/x86_64/drivers/serial.rs b/ableos/src/arch/x86_64/drivers/serial.rs
new file mode 100644
index 0000000..16703c4
--- /dev/null
+++ b/ableos/src/arch/x86_64/drivers/serial.rs
@@ -0,0 +1,33 @@
+use lazy_static::lazy_static;
+use spin::Mutex;
+use uart_16550::SerialPort;
+lazy_static! {
+ pub static ref SERIAL1: Mutex<SerialPort> = {
+ let mut serial_port = unsafe { SerialPort::new(0x3F8) };
+ serial_port.init();
+ Mutex::new(serial_port)
+ };
+}
+#[doc(hidden)]
+pub fn _print(args: ::core::fmt::Arguments) {
+ use core::fmt::Write;
+ SERIAL1
+ .lock()
+ .write_fmt(args)
+ .expect("Printing to serial failed");
+}
+/// Prints to the host through the serial interface.
+#[macro_export]
+macro_rules! serial_print {
+ ($($arg:tt)*) => {
+ $crate::arch::drivers::serial::_print(format_args!($($arg)*));
+ };
+}
+/// Prints to the host through the serial interface, appending a newline.
+#[macro_export]
+macro_rules! serial_println {
+ () => ($crate::serial_print!("\n"));
+ ($fmt:expr) => ($crate::serial_print!(concat!($fmt, "\n")));
+ ($fmt:expr, $($arg:tt)*) => ($crate::serial_print!(
+ concat!($fmt, "\n"), $($arg)*));
+}
diff --git a/ableos/src/arch/x86_64/drivers/vga.rs b/ableos/src/arch/x86_64/drivers/vga.rs
new file mode 100644
index 0000000..c7746f9
--- /dev/null
+++ b/ableos/src/arch/x86_64/drivers/vga.rs
@@ -0,0 +1,133 @@
+#[allow(dead_code)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum Color {
+ Black = 0,
+ Blue = 1,
+ Green = 2,
+ Cyan = 3,
+ Red = 4,
+ Magenta = 5,
+ Brown = 6,
+ LightGray = 7,
+ DarkGray = 8,
+ LightBlue = 9,
+ LightGreen = 10,
+ LightCyan = 11,
+ LightRed = 12,
+ Pink = 13,
+ Yellow = 14,
+ White = 15,
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+struct ColorCode(u8);
+impl ColorCode {
+ fn new(foreground: Color, background: Color) -> ColorCode {
+ ColorCode((background as u8) << 4 | (foreground as u8))
+ }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(C)]
+struct ScreenChar {
+ ascii_character: u8,
+ color_code: ColorCode,
+}
+const BUFFER_HEIGHT: usize = 25;
+const BUFFER_WIDTH: usize = 80;
+#[repr(transparent)]
+struct Buffer {
+ chars: [[Volatile<ScreenChar>; BUFFER_WIDTH]; BUFFER_HEIGHT],
+}
+pub struct Writer {
+ column_position: usize,
+ color_code: ColorCode,
+ buffer: &'static mut Buffer,
+}
+impl Writer {
+ pub fn write_byte(&mut self, byte: u8) {
+ match byte {
+ b'\n' => self.new_line(),
+ byte => {
+ if self.column_position >= BUFFER_WIDTH {
+ self.new_line();
+ }
+ let row = BUFFER_HEIGHT - 1;
+ let col = self.column_position;
+ let color_code = self.color_code;
+ self.buffer.chars[row][col].write(ScreenChar {
+ ascii_character: byte,
+ color_code,
+ });
+ self.column_position += 1;
+ }
+ }
+ }
+ pub fn write_string(&mut self, s: &str) {
+ for byte in s.bytes() {
+ match byte {
+ // printable ASCII byte or newline
+ 0x20..=0x7e | b'\n' => self.write_byte(byte),
+ // not part of printable ASCII range
+ _ => self.write_byte(0xfe),
+ }
+ }
+ }
+ fn new_line(&mut self) {
+ for row in 1..BUFFER_HEIGHT {
+ for col in 0..BUFFER_WIDTH {
+ let character = self.buffer.chars[row][col].read();
+ self.buffer.chars[row - 1][col].write(character);
+ }
+ }
+ self.clear_row(BUFFER_HEIGHT - 1);
+ self.column_position = 0;
+ }
+ fn clear_row(&mut self, row: usize) {
+ let blank = ScreenChar {
+ ascii_character: b' ',
+ color_code: self.color_code,
+ };
+ for col in 0..BUFFER_WIDTH {
+ self.buffer.chars[row][col].write(blank);
+ }
+ }
+}
+impl fmt::Write for Writer {
+ fn write_str(&mut self, s: &str) -> fmt::Result {
+ self.write_string(s);
+ Ok(())
+ }
+}
+lazy_static! {
+ pub static ref WRITER: Mutex<Writer> = Mutex::new(Writer {
+ column_position: 0,
+ color_code: ColorCode::new(Color::Green, Color::Black),
+ buffer: unsafe { &mut *(0xb8000 as *mut Buffer) },
+ });
+}
+#[allow(dead_code)]
+pub fn set_vga_color() {
+ WRITER.lock().color_code = ColorCode::new(Color::White, Color::Yellow);
+}
+use core::fmt;
+use lazy_static::lazy_static;
+use spin::Mutex;
+use volatile::Volatile;
+#[macro_export]
+macro_rules! kprint {
+ ($($arg:tt)*) => ($crate::arch::drivers::vga::_kprint(format_args!($($arg)*)));
+}
+#[macro_export]
+macro_rules! kprintln {
+ () => ($crate::kprint!("\n"));
+ ($($arg:tt)*) => ($crate::kprint!("{}\n", format_args!($($arg)*)));
+}
+#[doc(hidden)]
+pub fn _kprint(args: fmt::Arguments) {
+ use core::fmt::Write;
+ use x86_64::instructions::interrupts;
+ interrupts::without_interrupts(|| {
+ WRITER.lock().write_fmt(args).unwrap();
+ });
+}
diff --git a/ableos/src/arch/x86_64/gdt.rs b/ableos/src/arch/x86_64/gdt.rs
new file mode 100644
index 0000000..3a0ff77
--- /dev/null
+++ b/ableos/src/arch/x86_64/gdt.rs
@@ -0,0 +1,46 @@
+use lazy_static::lazy_static;
+use x86_64::structures::gdt::{Descriptor, GlobalDescriptorTable, SegmentSelector};
+use x86_64::structures::tss::TaskStateSegment;
+use x86_64::VirtAddr;
+pub const DOUBLE_FAULT_IST_INDEX: u16 = 0;
+lazy_static! {
+ static ref TSS: TaskStateSegment = {
+ let mut tss = TaskStateSegment::new();
+ tss.interrupt_stack_table[DOUBLE_FAULT_IST_INDEX as usize] = {
+ const STACK_SIZE: usize = 4096 * 5;
+ static mut STACK: [u8; STACK_SIZE] = [0; STACK_SIZE];
+
+ let stack_start = VirtAddr::from_ptr(unsafe { &STACK });
+ stack_start + STACK_SIZE
+ };
+ tss
+ };
+}
+struct Selectors {
+ code_selector: SegmentSelector,
+ tss_selector: SegmentSelector,
+}
+lazy_static! {
+ static ref GDT: (GlobalDescriptorTable, Selectors) = {
+ let mut gdt = GlobalDescriptorTable::new();
+ let code_selector = gdt.add_entry(Descriptor::kernel_code_segment());
+ let tss_selector = gdt.add_entry(Descriptor::tss_segment(&TSS));
+ (
+ gdt,
+ Selectors {
+ code_selector,
+ tss_selector,
+ },
+ )
+ };
+}
+pub fn init() {
+ use x86_64::instructions::segmentation::{Segment, CS};
+ use x86_64::instructions::tables::load_tss;
+
+ GDT.0.load();
+ unsafe {
+ CS::set_reg(GDT.1.code_selector);
+ load_tss(GDT.1.tss_selector);
+ }
+}
diff --git a/ableos/src/arch/x86_64/init.rs b/ableos/src/arch/x86_64/init.rs
new file mode 100644
index 0000000..853310c
--- /dev/null
+++ b/ableos/src/arch/x86_64/init.rs
@@ -0,0 +1,11 @@
+#![allow(clippy::print_literal)]
+use super::{gdt, interrupts};
+use crate::{println, serial_println};
+pub fn init() {
+ gdt::init();
+ interrupts::init_idt();
+ unsafe { interrupts::PICS.lock().initialize() };
+ x86_64::instructions::interrupts::enable();
+ println!("Initialized");
+ serial_println!("Initialized");
+}
diff --git a/ableos/src/arch/x86_64/interrupts.rs b/ableos/src/arch/x86_64/interrupts.rs
new file mode 100644
index 0000000..2fe3570
--- /dev/null
+++ b/ableos/src/arch/x86_64/interrupts.rs
@@ -0,0 +1,112 @@
+use crate::{arch::gdt, print, println};
+use lazy_static::lazy_static;
+use pic8259::ChainedPics;
+use spin;
+use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame};
+pub const PIC_1_OFFSET: u8 = 32;
+pub const PIC_2_OFFSET: u8 = PIC_1_OFFSET + 8;
+pub static PICS: spin::Mutex<ChainedPics> =
+ spin::Mutex::new(unsafe { ChainedPics::new(PIC_1_OFFSET, PIC_2_OFFSET) });
+
+use crate::arch::sloop;
+use x86_64::structures::idt::PageFaultErrorCode;
+/// Interrupt offsets.
+#[derive(Debug, Clone, Copy)]
+#[repr(u8)]
+pub enum InterruptIndex {
+ Timer = PIC_1_OFFSET,
+ Keyboard,
+}
+impl InterruptIndex {
+ fn as_u8(self) -> u8 {
+ self as u8
+ }
+ fn as_usize(self) -> usize {
+ usize::from(self.as_u8())
+ }
+}
+pub fn init_idt() {
+ IDT.load();
+}
+lazy_static! {
+ static ref IDT: InterruptDescriptorTable = {
+ let mut idt = InterruptDescriptorTable::new();
+ idt.breakpoint.set_handler_fn(breakpoint_handler);
+ unsafe {
+ idt.double_fault.set_handler_fn(double_fault_handler)
+ .set_stack_index(gdt::DOUBLE_FAULT_IST_INDEX); // new
+ }
+ idt[InterruptIndex::Timer.as_usize()].set_handler_fn(timer_interrupt_handler);
+ idt[InterruptIndex::Keyboard.as_usize()] .set_handler_fn(keyboard_interrupt_handler);
+ idt
+ };
+}
+extern "x86-interrupt" fn breakpoint_handler(stack_frame: InterruptStackFrame) {
+ println!("EXCEPTION: BREAKPOINT\n{:#?}", stack_frame);
+}
+// new
+extern "x86-interrupt" fn double_fault_handler(
+ stack_frame: InterruptStackFrame,
+ _error_code: u64,
+) -> ! {
+ panic!("EXCEPTION: DOUBLE FAULT\n{:#?}", stack_frame);
+}
+extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFrame) {
+ crate::kmain::tick();
+ unsafe {
+ PICS.lock()
+ .notify_end_of_interrupt(InterruptIndex::Timer.as_u8());
+ }
+}
+extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStackFrame) {
+ use crate::keyboard::{
+ CustomLayout, CustomScanCodeSet, DecodedKey, DecodedKeyKind, HandleControl, KeyCode,
+ Keyboard,
+ };
+ use spin::Mutex;
+ use x86_64::instructions::port::Port;
+ lazy_static! {
+ static ref KEYBOARD: Mutex<Keyboard<CustomLayout, CustomScanCodeSet>> =
+ Mutex::new(Keyboard::new(
+ CustomLayout::new_us104key(),
+ CustomScanCodeSet::default(),
+ HandleControl::Ignore
+ ));
+ }
+ let mut keyboard = KEYBOARD.lock();
+ let mut port = Port::new(0x60);
+ let scancode: u8 = unsafe { port.read() };
+ if let Ok(Some(key_event)) = keyboard.add_byte(scancode) {
+ if let Some(key) = keyboard.process_keyevent(key_event) {
+ match key {
+ DecodedKey {
+ kind: DecodedKeyKind::Unicode,
+ value: character,
+ } => {
+ print!("{}", char::try_from(character).unwrap());
+ // serial_print!("{}", character);
+ crate::kmain::key_entropy(character.try_into().unwrap());
+ }
+ DecodedKey {
+ kind: DecodedKeyKind::RawKey,
+ value: key,
+ } => print!("{:?}", KeyCode::from(key)),
+ }
+ }
+ }
+ unsafe {
+ PICS.lock()
+ .notify_end_of_interrupt(InterruptIndex::Keyboard.as_u8());
+ }
+}
+extern "x86-interrupt" fn page_fault_handler(
+ stack_frame: InterruptStackFrame,
+ error_code: PageFaultErrorCode,
+) {
+ use x86_64::registers::control::Cr2;
+ println!["Exception: Page Fault"];
+ println!["Address: {:?}", Cr2::read()];
+ println!["Error Code: {:?}", error_code];
+ println!["{:#?}", stack_frame];
+ sloop();
+}
diff --git a/ableos/src/arch/x86_64/mod.rs b/ableos/src/arch/x86_64/mod.rs
new file mode 100644
index 0000000..3aec32e
--- /dev/null
+++ b/ableos/src/arch/x86_64/mod.rs
@@ -0,0 +1,27 @@
+use x86_64::instructions::hlt;
+pub mod drivers;
+pub mod gdt;
+pub mod init;
+pub mod interrupts;
+#[no_mangle]
+pub extern "C" fn _start() -> ! {
+ crate::kmain::kernel_main();
+ sloop();
+}
+
+#[allow(unused)]
+pub fn shutdown() -> ! {
+ sloop();
+}
+
+pub fn sloop() -> ! {
+ loop {
+ hlt();
+ }
+}
+#[cfg(test)]
+pub fn test_runner(tests: &[&dyn Fn()]) {
+ for test in tests {
+ test();
+ }
+}
diff --git a/ableos/src/driver_traits/device.rs b/ableos/src/driver_traits/device.rs
new file mode 100644
index 0000000..58004d0
--- /dev/null
+++ b/ableos/src/driver_traits/device.rs
@@ -0,0 +1,4 @@
+pub trait Device {
+ fn probe();
+ fn reset();
+}
diff --git a/ableos/src/driver_traits/graphics.rs b/ableos/src/driver_traits/graphics.rs
new file mode 100644
index 0000000..c95178c
--- /dev/null
+++ b/ableos/src/driver_traits/graphics.rs
@@ -0,0 +1,37 @@
+#![allow(unused)]
+pub enum GModes {
+ Vga800x600,
+ Custom(u16, u16),
+}
+pub type GCoord = usize;
+pub struct Rgb {
+ pub r: u32,
+ pub g: u32,
+ pub b: u32,
+}
+
+impl Rgb {
+ fn to_vga_color() {
+ todo!();
+ }
+}
+pub type RefreshRate = u8;
+
+pub const REFRESH_RATE: u8 = 60;
+pub type Resolution = (usize, usize);
+pub type Point = (GCoord, GCoord);
+pub struct FrameBuffer;
+// [[Rgb; 5]; 5]
+pub trait Graphics {
+ fn put_line(coords_start: Point, coords_end: Point, thickness: u32, color: Rgb);
+ fn put_rect(coords_start: Point, coords_end: Point, color: Rgb);
+ fn put_circle(coords: Point, radius: u32);
+ fn put_pixel(coords: Point, color: Rgb);
+ fn put_triangle(coords_1: Point, coords_2: Point, coords_3: Point, thickness: u32, color: Rgb);
+ fn paint_cursor(coords: Point);
+ fn hide_cursor();
+ fn show_cursor();
+ /// Actually move the double buffer to the single buffer and "update" the screen
+ fn draw();
+ fn clear();
+}
diff --git a/ableos/src/driver_traits/mod.rs b/ableos/src/driver_traits/mod.rs
new file mode 100644
index 0000000..b832ebf
--- /dev/null
+++ b/ableos/src/driver_traits/mod.rs
@@ -0,0 +1,2 @@
+pub mod graphics;
+pub mod serial;
diff --git a/ableos/src/driver_traits/mouse.rs b/ableos/src/driver_traits/mouse.rs
new file mode 100644
index 0000000..892a57e
--- /dev/null
+++ b/ableos/src/driver_traits/mouse.rs
@@ -0,0 +1,9 @@
+pub enum PS2MouseButton {
+ LeftMB,
+ RightMB,
+}
+
+pub trait PS2Mouse {
+ fn movement();
+ fn button();
+}
diff --git a/ableos/src/driver_traits/serial.rs b/ableos/src/driver_traits/serial.rs
new file mode 100644
index 0000000..6ffc40a
--- /dev/null
+++ b/ableos/src/driver_traits/serial.rs
@@ -0,0 +1,4 @@
+pub trait Serial {
+ fn print();
+ fn recieve();
+}
diff --git a/ableos/src/experiments/EXPLAIN.md b/ableos/src/experiments/EXPLAIN.md
new file mode 100644
index 0000000..8dd9fe8
--- /dev/null
+++ b/ableos/src/experiments/EXPLAIN.md
@@ -0,0 +1 @@
+Anything in experiments is heavily unstable and likely to change
diff --git a/ableos/src/experiments/banner.txt b/ableos/src/experiments/banner.txt
new file mode 100644
index 0000000..fdea73b
--- /dev/null
+++ b/ableos/src/experiments/banner.txt
@@ -0,0 +1,7 @@
+ ##### #####
+ ## ##### # ###### ## ## # #
+ # # # # # # # # #
+# # ##### # ##### # # #####
+###### # # # # # # #
+# # # # # # ## ## # #
+# # ##### ###### ###### ##### #####
diff --git a/ableos/src/experiments/clip.rs b/ableos/src/experiments/clip.rs
new file mode 100644
index 0000000..5f63ffd
--- /dev/null
+++ b/ableos/src/experiments/clip.rs
@@ -0,0 +1,55 @@
+use crate::alloc::vec;
+use crate::String;
+use crate::Vec;
+use lazy_static::lazy_static;
+#[derive(Debug)]
+pub enum Mime {
+ None,
+ Text(String),
+}
+
+lazy_static! {
+ pub static ref CLIPBOARD: spin::Mutex<Clipboard> = {
+ let clipboard = Clipboard::new();
+
+ spin::Mutex::new(clipboard)
+ };
+}
+
+// ctrl+v paste but not pop and pastes
+// ctrl+shift+v pops from the stack and pastes
+// ctrl+c pushes to the stack
+// ctrl+shift+< move stack pointer left
+// ctrl+shift+> move stack pointer right
+
+pub struct Clipboard {
+ pub index: usize,
+ pub pages: Vec<Mime>,
+}
+impl Clipboard {
+ pub fn new() -> Clipboard {
+ Clipboard {
+ index: 0,
+ pages: vec![],
+ }
+ }
+ pub fn clear(&mut self) {
+ self.pages = vec![];
+ }
+ pub fn set_index(&mut self, index_new: usize) {
+ self.index = index_new;
+ }
+ pub fn clip_end(&mut self) {
+ self.index = 0;
+ }
+ pub fn clip_home(&mut self) {
+ self.index = self.pages.len();
+ }
+ pub fn copy(&mut self, copy_mime: Mime) {
+ self.pages.push(copy_mime);
+ }
+ pub fn paste(&mut self) -> &Mime {
+ let paste_pos = &self.pages[self.index];
+ paste_pos
+ }
+}
diff --git a/ableos/src/experiments/file.rs b/ableos/src/experiments/file.rs
new file mode 100644
index 0000000..bb0a5d3
--- /dev/null
+++ b/ableos/src/experiments/file.rs
@@ -0,0 +1,22 @@
+struct Permissions {
+ write_files: bool,
+ read_files: bool,
+ execute_files: bool,
+ // Every other user is part of global
+ global_write_files: bool,
+ global_read_files: bool,
+ global_execute_files: bool,
+}
+
+pub struct File {
+ owner: u8,
+ permissions: Permissions,
+ data: Vec<u8>,
+}
+
+pub struct Folder {
+ owner: u8,
+ permissions: Permissions,
+ folders: Vec<Folder>,
+ files: Vec<File>,
+}
diff --git a/ableos/src/experiments/filesystem.txt b/ableos/src/experiments/filesystem.txt
new file mode 100644
index 0000000..f1fe2cd
--- /dev/null
+++ b/ableos/src/experiments/filesystem.txt
@@ -0,0 +1,15 @@
+<user>/home/app1
+<user>/conf/app1
+<user>/apps/app1
+
+file:app1
+conf:app1
+apps:app1
+// Discouraged
+raw:
+
+/<user>/<protocol>/app1
+protocol.toml
+
+
+hi = ""
diff --git a/ableos/src/experiments/kinfo.rs b/ableos/src/experiments/kinfo.rs
new file mode 100644
index 0000000..193d0ac
--- /dev/null
+++ b/ableos/src/experiments/kinfo.rs
@@ -0,0 +1,34 @@
+// Can be standardized
+// NOTE: Move this to relib
+pub struct SemanticVersion {
+ pub major: u8,
+ pub minor: u8,
+ pub patch: u8,
+}
+impl core::fmt::Display for SemanticVersion {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ write!(f, "v{}.{}.{}", self.major, self.minor, self.patch)
+ }
+}
+// NOTE: Move to somewhere else
+lazy_static! {
+ pub static ref KINFO: KernelInfo = KernelInfo {
+ kernel_version: SemanticVersion {
+ major: 0,
+ minor: 0,
+ patch: 0,
+ },
+ memory: SystemMemory { used: 0, total: 0 }
+ };
+}
+/// simple info you would want to know in a neofetch like program
+pub struct KernelInfo {
+ // os: String,
+ // host: String,
+ pub kernel_version: SemanticVersion,
+ // cpu: String,
+ // gpu: String,
+ pub memory: SystemMemory,
+}
+use super::systeminfo::SystemMemory;
+use lazy_static::lazy_static;
diff --git a/ableos/src/experiments/mail.rs b/ableos/src/experiments/mail.rs
new file mode 100644
index 0000000..63e5b97
--- /dev/null
+++ b/ableos/src/experiments/mail.rs
@@ -0,0 +1,72 @@
+#![allow(dead_code)]
+use crate::serial_println;
+pub struct MailBoxes {
+ flags: u8,
+ mailboxes: [u64; 4],
+}
+impl MailBoxes {
+ pub fn new() -> Self {
+ Self {
+ flags: 0b0000_0000,
+ mailboxes: [0; 4],
+ }
+ }
+ pub fn reset(&mut self) {
+ self.flags = 0b0000_0000;
+ self.mailboxes = [0; 4];
+ }
+ pub fn set_mailbox(&mut self, mailbox_num: u8, mailbox_data: u64) {
+ if let 0..=3 = mailbox_num {
+ self.mailboxes[mailbox_num as usize] = mailbox_data
+ }
+ }
+ pub fn set_flag(&mut self, flag_num: u8) {
+ match flag_num {
+ 0 => {
+ self.flags |= 0b0000_0001;
+ }
+ 1 => {
+ self.flags |= 0b0000_0010;
+ }
+ 2 => {
+ self.flags |= 0b0000_0100;
+ }
+ 3 => {
+ self.flags |= 0b0000_1000;
+ }
+ 4 => {
+ self.flags |= 0b0001_0000;
+ }
+ 5 => {
+ self.flags |= 0b0010_0000;
+ }
+ 6 => {
+ self.flags |= 0b0100_0000;
+ }
+ 7 => {
+ self.flags |= 0b1000_0000;
+ }
+
+ _ => {}
+ }
+ }
+ pub fn dump_flags(&self) {
+ serial_println!("Flag 0: {:08b}", self.flags & 0b0000_0001);
+ serial_println!("Flag 1: {:08b}", self.flags & 0b0000_0010);
+ serial_println!("Flag 2: {:08b}", self.flags & 0b0000_0100);
+ serial_println!("Flag 3: {:08b}", self.flags & 0b0000_1000);
+ serial_println!("Flag 4: {:08b}", self.flags & 0b0001_0000);
+ serial_println!("Flag 5: {:08b}", self.flags & 0b0010_0000);
+ serial_println!("Flag 6: {:08b}", self.flags & 0b0100_0000);
+ serial_println!("Flag 7: {:08b}", self.flags & 0b1000_0000);
+
+ serial_println!("Flag 0: {}", self.flags & 0b0000_0001);
+ serial_println!("Flag 1: {}", self.flags >> 1 & 0b0000_0001);
+ serial_println!("Flag 2: {}", self.flags >> 2 & 0b0000_0001);
+ serial_println!("Flag 3: {}", self.flags >> 3 & 0b0000_0001);
+ serial_println!("Flag 4: {}", self.flags >> 4 & 0b0000_0001);
+ serial_println!("Flag 5: {}", self.flags >> 5 & 0b0000_0001);
+ serial_println!("Flag 6: {}", self.flags >> 6 & 0b0000_0001);
+ serial_println!("Flag 7: {}", self.flags >> 7 & 0b0000_0001);
+ }
+}
diff --git a/ableos/src/experiments/mod.rs b/ableos/src/experiments/mod.rs
new file mode 100644
index 0000000..d8bf70f
--- /dev/null
+++ b/ableos/src/experiments/mod.rs
@@ -0,0 +1,10 @@
+#![allow(dead_code)]
+
+pub mod server;
+pub mod systeminfo;
+pub mod virtual_memory;
+// pub mod wm;
+// added for experimental use
+pub mod kinfo;
+pub mod mail;
+pub const BANNER: &str = include_str!("banner.txt");
diff --git a/ableos/src/experiments/pkg.rs b/ableos/src/experiments/pkg.rs
new file mode 100644
index 0000000..ef3f54e
--- /dev/null
+++ b/ableos/src/experiments/pkg.rs
@@ -0,0 +1,44 @@
+pub type PackageName = String;
+use crate::experiments::kinfo::SemanticVersion;
+
+// Scuffed
+pub type Hash = u8;
+pub struct MetaPackage {
+ pub name: u8,
+ pub version: SemanticVersion,
+ pub authors: [u8; 8],
+ pub support_email: u8,
+ pub hash: Hash,
+}
+
+impl MetaPackage {
+ pub fn new() -> Self {
+ Self {
+ name: 0,
+ version: SemanticVersion {
+ major: 0,
+ minor: 0,
+ patch: 0,
+ },
+ authors: [0; 8],
+ support_email: 8,
+ hash: 0,
+ }
+ }
+
+ fn validate_hash(&self) {}
+}
+
+impl core::fmt::Display {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ write!(
+ f,
+ "Packname: {}
+Version: {}
+Authors: {:?}
+Support Email: {}
+Hash: {}",
+ self.name, self.version, self.authors, self.support_email, self.hash
+ )
+ }
+}
diff --git a/ableos/src/experiments/schedule.rs b/ableos/src/experiments/schedule.rs
new file mode 100644
index 0000000..0384d48
--- /dev/null
+++ b/ableos/src/experiments/schedule.rs
@@ -0,0 +1,24 @@
+pub type Priority = [Process; 512];
+
+pub struct VirtualMemoryTable {}
+
+struct Process {
+ id: u64,
+ mem_table: *mut VirtualMemoryTable, // Pointer to a memory table
+}
+
+pub struct Scheduler {
+ pub high_priority: Priority, //150
+ pub medium_priority: Priority, //100
+ pub low_priority: Priority, // 50
+ pub next_pid: u64,
+}
+
+impl Scheduler {
+ pub fn bump_up() {}
+ pub fn bump_down() {}
+ pub fn schedule(&mut self) {
+ let current_pid = self.next_pid;
+ self.next_pid += 1;
+ }
+}
diff --git a/ableos/src/experiments/server.rs b/ableos/src/experiments/server.rs
new file mode 100644
index 0000000..42d82ac
--- /dev/null
+++ b/ableos/src/experiments/server.rs
@@ -0,0 +1,10 @@
+pub trait Server {
+ /// Initialize the server and return a number
+ fn initialize() -> u32;
+ /// kill the server
+ fn kill() -> bool;
+ // put data in the servers outbox
+ fn send();
+ // put data in the servers inbox and notify it
+ fn recieve();
+}
diff --git a/ableos/src/experiments/syscalls.md b/ableos/src/experiments/syscalls.md
new file mode 100644
index 0000000..b5e654a
--- /dev/null
+++ b/ableos/src/experiments/syscalls.md
@@ -0,0 +1,39 @@
+
+| low \\ high | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F |
+| ----------- | ------------------- | ------------------------ | ------------------------------------------------------------------------------------------ | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- |
+| 0 | **kill** | <sub>reserved</sub> | **sleep** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 1 | **stdout_reset** | <sub>reserved</sub> | **sleep_until** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 2 | **stdin** | <sub>reserved</sub> | [**nanosleep**](https://www.reddit.com/r/anime/comments/e7sg7g/nichijou_trouble_sleeping/) | **aes_encrypt** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 3 | **stdout** | <sub>reserved</sub> | **nanosleep_until** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 4 | **stdin_get_title** | <sub>reserved</sub> | **get_time** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 5 | **stdin_set_title** | <sub>reserved</sub> | **set_time** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 6 | **get_pid** | **make_directory** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 7 | **pinfo** | **delete_directory** | **socket_bind** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 8 | <sub>reserved</sub> | **rename_directory** | **socket_connect** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 9 | <sub>reserved</sub> | **set_directory_access** | **socket_disconnect** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| A | **set_priority** | **make_file** | **socket_send** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| B | **get_priority** | **delete_file** | **socket_receive** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| C | **get_hostname** | **rename_file** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| D | **set_hostname** | **set_file_access** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| E | <sub>reserved</sub> | **file_read** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| F | <sub>reserved</sub> | **file_write** | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+
+| low \\ high | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 1A | 1B | 1C | 1D | 1E | 1F |
+| ----------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- |
+| 0 | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 1 | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 2 | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 3 | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 4 | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 5 | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 6 | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 7 | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 8 | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| 9 | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| A | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| B | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| C | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| D | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| E | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+| F | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> | <sub>reserved</sub> |
+
diff --git a/ableos/src/experiments/systeminfo.rs b/ableos/src/experiments/systeminfo.rs
new file mode 100644
index 0000000..552ad7f
--- /dev/null
+++ b/ableos/src/experiments/systeminfo.rs
@@ -0,0 +1,33 @@
+// Can be standardized
+// NOTE: move the file to the src/ dir
+pub struct SystemMemory {
+ pub used: u64,
+ pub total: u64,
+}
+impl core::fmt::Display for SystemMemory {
+ fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+ write!(f, "{} Bytes / {} Bytes", self.used, self.total)
+ }
+}
+/*
+pub fn format_system_info() -> core::string::String {
+ let x = format!(
+ "{}
+OS: AbleOS
+Host: ComputAble
+Kernel: {}
+Uptime: 0:0:0
+Packages: 0
+Shell: Ashell
+Gpu: MIPS32 R4000 R4k
+Cpu: {}
+Memory: {}
+",
+ crate::experiments::BANNER,
+ crate::experiments::kinfo::KINFO.kernel_version,
+ crate::arch::ARCH,
+ crate::experiments::kinfo::KINFO.memory
+ );
+ return x;
+}
+*/
diff --git a/ableos/src/experiments/user.rs b/ableos/src/experiments/user.rs
new file mode 100644
index 0000000..645a57a
--- /dev/null
+++ b/ableos/src/experiments/user.rs
@@ -0,0 +1,4 @@
+pub struct User {
+ id: u8,
+ clipboard: Clipboard,
+}
diff --git a/ableos/src/experiments/virtual_memory.rs b/ableos/src/experiments/virtual_memory.rs
new file mode 100644
index 0000000..dd791e4
--- /dev/null
+++ b/ableos/src/experiments/virtual_memory.rs
@@ -0,0 +1,7 @@
+#![allow(dead_code)]
+
+pub struct Scheduler {
+ executables: usize,
+}
+
+pub struct RunQueue {}
diff --git a/ableos/src/experiments/wm.rs b/ableos/src/experiments/wm.rs
new file mode 100644
index 0000000..cd02d3c
--- /dev/null
+++ b/ableos/src/experiments/wm.rs
@@ -0,0 +1,23 @@
+//! used to give a base line example of windows and window handling
+use crate::driver_traits::graphics::Point;
+pub struct Window {
+ // title: String,
+ position: Point,
+ fullscreen: bool,
+}
+// all of these should return a result
+impl Window {
+ pub fn fullscreen(&mut self) -> Result<(), u8> {
+ self.fullscreen = true;
+ Ok(())
+ }
+ pub fn revert_fullscreen(&mut self) {
+ self.fullscreen = false;
+ }
+ pub fn set_title(&mut self) {
+ todo!();
+ }
+ pub fn set_position(&mut self, pos: Point) {
+ self.position = pos;
+ }
+}
diff --git a/ableos/src/keyboard/abstractions.rs b/ableos/src/keyboard/abstractions.rs
new file mode 100644
index 0000000..36f3e0c
--- /dev/null
+++ b/ableos/src/keyboard/abstractions.rs
@@ -0,0 +1,623 @@
+#![allow(clippy::too_many_arguments)]
+use super::*;
+pub struct CustomScanCodeSet {
+ single_byte: [Option<KeyCode>; 256],
+ extended: [Option<KeyCode>; 256],
+}
+impl Default for CustomScanCodeSet {
+ fn default() -> Self {
+ Self::scancode_set1()
+ }
+}
+impl CustomScanCodeSet {
+ pub fn scancode_set1() -> Self {
+ let mut scancode_set = Self {
+ single_byte: [None; 256],
+ extended: [None; 256],
+ };
+ scancode_set.single_byte[0x01] = Some(KeyCode::Escape); // 01
+ scancode_set.single_byte[0x02] = Some(KeyCode::Key1); // 02
+ scancode_set.single_byte[0x03] = Some(KeyCode::Key2); // 03
+ scancode_set.single_byte[0x04] = Some(KeyCode::Key3); // 04
+ scancode_set.single_byte[0x05] = Some(KeyCode::Key4); // 05
+ scancode_set.single_byte[0x06] = Some(KeyCode::Key5); // 06
+ scancode_set.single_byte[0x07] = Some(KeyCode::Key6); // 07
+ scancode_set.single_byte[0x08] = Some(KeyCode::Key7); // 08
+ scancode_set.single_byte[0x09] = Some(KeyCode::Key8); // 09
+ scancode_set.single_byte[0x0A] = Some(KeyCode::Key9); // 0A
+ scancode_set.single_byte[0x0B] = Some(KeyCode::Key0); // 0B
+ scancode_set.single_byte[0x0C] = Some(KeyCode::Minus); // 0C
+ scancode_set.single_byte[0x0D] = Some(KeyCode::Equals); // 0D
+ scancode_set.single_byte[0x0E] = Some(KeyCode::Backspace); // 0E
+ scancode_set.single_byte[0x0F] = Some(KeyCode::Tab); // 0F
+ scancode_set.single_byte[0x10] = Some(KeyCode::Q); // 10
+ scancode_set.single_byte[0x11] = Some(KeyCode::W); // 11
+ scancode_set.single_byte[0x12] = Some(KeyCode::E); // 12
+ scancode_set.single_byte[0x13] = Some(KeyCode::R); // 13
+ scancode_set.single_byte[0x14] = Some(KeyCode::T); // 14
+ scancode_set.single_byte[0x15] = Some(KeyCode::Y); // 15
+ scancode_set.single_byte[0x16] = Some(KeyCode::U); // 16
+ scancode_set.single_byte[0x17] = Some(KeyCode::I); // 17
+ scancode_set.single_byte[0x18] = Some(KeyCode::O); // 18
+ scancode_set.single_byte[0x19] = Some(KeyCode::P); // 19
+ scancode_set.single_byte[0x1A] = Some(KeyCode::BracketSquareLeft); // 1A
+ scancode_set.single_byte[0x1B] = Some(KeyCode::BracketSquareRight); // 1B
+ scancode_set.single_byte[0x1C] = Some(KeyCode::Enter); // 1C
+ scancode_set.single_byte[0x1D] = Some(KeyCode::ControlLeft); // 1D
+ scancode_set.single_byte[0x1E] = Some(KeyCode::A); // 1E
+ scancode_set.single_byte[0x1F] = Some(KeyCode::S); // 1F
+ scancode_set.single_byte[0x20] = Some(KeyCode::D); // 20
+ scancode_set.single_byte[0x21] = Some(KeyCode::F); // 21
+ scancode_set.single_byte[0x22] = Some(KeyCode::G); // 22
+ scancode_set.single_byte[0x23] = Some(KeyCode::H); // 23
+ scancode_set.single_byte[0x24] = Some(KeyCode::J); // 24
+ scancode_set.single_byte[0x25] = Some(KeyCode::K); // 25
+ scancode_set.single_byte[0x26] = Some(KeyCode::L); // 26
+ scancode_set.single_byte[0x27] = Some(KeyCode::SemiColon); // 27
+ scancode_set.single_byte[0x28] = Some(KeyCode::Quote); // 28
+ scancode_set.single_byte[0x29] = Some(KeyCode::BackTick); // 29
+ scancode_set.single_byte[0x2A] = Some(KeyCode::ShiftLeft); // 2A
+ scancode_set.single_byte[0x2B] = Some(KeyCode::BackSlash); // 2B
+ scancode_set.single_byte[0x2C] = Some(KeyCode::Z); // 2C
+ scancode_set.single_byte[0x2D] = Some(KeyCode::X); // 2D
+ scancode_set.single_byte[0x2E] = Some(KeyCode::C); // 2E
+ scancode_set.single_byte[0x2F] = Some(KeyCode::V); // 2F
+ scancode_set.single_byte[0x30] = Some(KeyCode::B); // 30
+ scancode_set.single_byte[0x31] = Some(KeyCode::N); // 31
+ scancode_set.single_byte[0x32] = Some(KeyCode::M); // 32
+ scancode_set.single_byte[0x33] = Some(KeyCode::Comma); // 33
+ scancode_set.single_byte[0x34] = Some(KeyCode::Fullstop); // 34
+ scancode_set.single_byte[0x35] = Some(KeyCode::Slash); // 35
+ scancode_set.single_byte[0x36] = Some(KeyCode::ShiftRight); // 36
+ scancode_set.single_byte[0x37] = Some(KeyCode::NumpadStar); // 37
+ scancode_set.single_byte[0x38] = Some(KeyCode::AltLeft); // 38
+ scancode_set.single_byte[0x39] = Some(KeyCode::Spacebar); // 39
+ scancode_set.single_byte[0x3A] = Some(KeyCode::CapsLock); // 3A
+ scancode_set.single_byte[0x3B] = Some(KeyCode::F1); // 3B
+ scancode_set.single_byte[0x3C] = Some(KeyCode::F2); // 3C
+ scancode_set.single_byte[0x3D] = Some(KeyCode::F3); // 3D
+ scancode_set.single_byte[0x3E] = Some(KeyCode::F4); // 3E
+ scancode_set.single_byte[0x3F] = Some(KeyCode::F5); // 3F
+ scancode_set.single_byte[0x40] = Some(KeyCode::F6); // 40
+ scancode_set.single_byte[0x41] = Some(KeyCode::F7); // 41
+ scancode_set.single_byte[0x42] = Some(KeyCode::F8); // 42
+ scancode_set.single_byte[0x43] = Some(KeyCode::F9); // 43
+ scancode_set.single_byte[0x44] = Some(KeyCode::F10); // 44
+ scancode_set.single_byte[0x45] = Some(KeyCode::NumpadLock); // 45
+ scancode_set.single_byte[0x46] = Some(KeyCode::ScrollLock); // 46
+ scancode_set.single_byte[0x47] = Some(KeyCode::Numpad7); // 47
+ scancode_set.single_byte[0x48] = Some(KeyCode::Numpad8); // 48
+ scancode_set.single_byte[0x49] = Some(KeyCode::Numpad9); // 49
+ scancode_set.single_byte[0x4A] = Some(KeyCode::NumpadMinus); // 4A
+ scancode_set.single_byte[0x4B] = Some(KeyCode::Numpad4); // 4B
+ scancode_set.single_byte[0x4C] = Some(KeyCode::Numpad5); // 4C
+ scancode_set.single_byte[0x4D] = Some(KeyCode::Numpad6); // 4D
+ scancode_set.single_byte[0x4E] = Some(KeyCode::NumpadPlus); // 4E
+ scancode_set.single_byte[0x4F] = Some(KeyCode::Numpad1); // 4F
+ scancode_set.single_byte[0x50] = Some(KeyCode::Numpad2); // 50
+ scancode_set.single_byte[0x51] = Some(KeyCode::Numpad3); // 51
+ scancode_set.single_byte[0x52] = Some(KeyCode::Numpad0); // 52
+ scancode_set.single_byte[0x53] = Some(KeyCode::NumpadPeriod); // 53
+ // 0x54
+ // 0x55
+ // 0x56
+ scancode_set.single_byte[0x57] = Some(KeyCode::F11); // 57
+ scancode_set.single_byte[0x58] = Some(KeyCode::F12); // 58
+ for i in 0x81..=0xD8 {
+ scancode_set.single_byte[i] = scancode_set.single_byte[i - 0x80];
+ }
+ scancode_set.extended[0x10] = Some(KeyCode::PrevTrack); // E010
+ //0x11
+ //0x12
+ //0x13
+ //0x14
+ //0x15
+ //0x16
+ //0x17
+ //0x18
+ scancode_set.extended[0x19] = Some(KeyCode::NextTrack); // E019
+ //0x1A
+ //0x1B
+ scancode_set.extended[0x1C] = Some(KeyCode::NumpadEnter); // E01C
+ scancode_set.extended[0x1D] = Some(KeyCode::ControlRight); // E01D
+ //0x1E
+ //0x1F
+ scancode_set.extended[0x20] = Some(KeyCode::Mute); // E020
+ scancode_set.extended[0x21] = Some(KeyCode::Calculator); // E021
+ scancode_set.extended[0x22] = Some(KeyCode::Play); // E022
+ //0x23
+ scancode_set.extended[0x24] = Some(KeyCode::Stop); // E024
+ //0x25
+ //0x26
+ //0x27
+ //0x28
+ //0x29
+ //0x2A
+ //0x2B
+ //0x2C
+ //0x2D
+ scancode_set.extended[0x2E] = Some(KeyCode::VolumeDown); // E02E
+ //0x2F
+ scancode_set.extended[0x30] = Some(KeyCode::VolumeUp); // E030
+ //0x31
+ scancode_set.extended[0x32] = Some(KeyCode::WWWHome); // E032
+ //0x33
+ //0x34
+ scancode_set.extended[0x35] = Some(KeyCode::NumpadSlash); // E035
+ //0x36
+ //0x37
+ scancode_set.extended[0x38] = Some(KeyCode::AltRight); // E038
+ //0x39
+ //0x3A
+ //0x3B
+ //0x3C
+ //0x3D
+ //0x3E
+ //0x3F
+ //0x40
+ //0x41
+ //0x42
+ //0x43
+ //0x44
+ //0x45
+ //0x46
+ scancode_set.extended[0x47] = Some(KeyCode::Home); // E047
+ scancode_set.extended[0x48] = Some(KeyCode::ArrowUp); // E048
+ scancode_set.extended[0x49] = Some(KeyCode::PageUp); // E049
+ //0x4A
+ scancode_set.extended[0x4B] = Some(KeyCode::ArrowLeft); // E04B
+ //0x4C
+ scancode_set.extended[0x4D] = Some(KeyCode::ArrowRight); // E04D
+ //0x4E
+ scancode_set.extended[0x4F] = Some(KeyCode::End); // E04F
+ scancode_set.extended[0x50] = Some(KeyCode::ArrowDown); // E050
+ scancode_set.extended[0x51] = Some(KeyCode::PageDown); // E051
+ scancode_set.extended[0x52] = Some(KeyCode::Insert); // E052
+ scancode_set.extended[0x53] = Some(KeyCode::Delete); // E053
+ for i in 0x90..=0xED {
+ scancode_set.extended[i] = scancode_set.extended[i - 0x80];
+ }
+ scancode_set
+ }
+ pub fn scancode_set2() -> Self {
+ Self {
+ single_byte: [None; 256],
+ extended: [None; 256],
+ }
+ }
+}
+impl ScancodeSet for CustomScanCodeSet {
+ fn advance_state(&self, state: &mut DecodeState, code: u8) -> Result<Option<KeyEvent>, Error> {
+ match *state {
+ DecodeState::Start => {
+ match code {
+ EXTENDED_KEY_CODE => {
+ *state = DecodeState::Extended;
+ Ok(None)
+ }
+ 0x80..=0xFF => {
+ // Release codes
+ Ok(Some(KeyEvent::new(
+ self.map_scancode(code - 0x80)?,
+ KeyState::Up,
+ )))
+ }
+ _ => {
+ // Normal codes
+ Ok(Some(KeyEvent::new(
+ self.map_scancode(code)?,
+ KeyState::Down,
+ )))
+ }
+ }
+ }
+ DecodeState::Extended => {
+ *state = DecodeState::Start;
+ match code {
+ 0x80..=0xFF => {
+ // Extended Release codes
+ Ok(Some(KeyEvent::new(
+ self.map_extended_scancode(code - 0x80)?,
+ KeyState::Up,
+ )))
+ }
+ _ => {
+ // Normal release codes
+ Ok(Some(KeyEvent::new(
+ self.map_extended_scancode(code)?,
+ KeyState::Down,
+ )))
+ }
+ }
+ }
+ _ => {
+ // Can't get in to this state
+ unimplemented!();
+ }
+ }
+ }
+ fn map_scancode(&self, code: u8) -> Result<KeyCode, Error> {
+ if let Some(kc) = self.single_byte[code as usize] {
+ Ok(kc)
+ } else {
+ Err(Error::UnknownKeyCode)
+ }
+ }
+ fn map_extended_scancode(&self, code: u8) -> Result<KeyCode, Error> {
+ if let Some(kc) = self.extended[code as usize] {
+ Ok(kc)
+ } else {
+ Err(Error::UnknownKeyCode)
+ }
+ }
+}
+#[derive(Debug, Clone, Copy)]
+pub enum LayoutEntry {
+ Regular {
+ unshifted: Option<DecodedKey>,
+ shifted: Option<DecodedKey>,
+ altgr: Option<DecodedKey>,
+ raw_unicode: Option<DecodedKey>,
+ },
+ Numlockable {
+ unshifted: Option<DecodedKey>,
+ shifted: Option<DecodedKey>,
+ locked: Option<DecodedKey>,
+ locked_shifted: Option<DecodedKey>,
+ },
+ Capslockable {
+ unshifted: Option<DecodedKey>,
+ shifted: Option<DecodedKey>,
+ locked: Option<DecodedKey>,
+ locked_shifted: Option<DecodedKey>,
+ altgr: Option<DecodedKey>,
+ raw_unicode: Option<DecodedKey>,
+ },
+}
+// Do not edit this file directly. Instead, create a `Keyboard` and modify that.
+pub struct CustomLayout {
+ mapping: [LayoutEntry; 256],
+}
+impl Default for CustomLayout {
+ fn default() -> Self {
+ Self::new_us104key()
+ }
+}
+impl CustomLayout {
+ #[rustfmt::skip]
+ pub fn new_us104key() -> Self {
+ let mut mapping = Self {
+ mapping: [LayoutEntry::Regular { unshifted: None, shifted: None, altgr: None, raw_unicode: None }; 256],
+ };
+ mapping.set_ab_c(KeyCode::BackTick, Some('`'.into()), Some('~'.into()), None);
+ mapping.set_aa_a(KeyCode::Escape, Some('\x1B'.into()));
+ mapping.set_ab_n(KeyCode::Key0, Some('0'.into()), Some(')'.into()));
+ mapping.set_ab_n(KeyCode::Key1, Some('1'.into()), Some('!'.into()));
+ mapping.set_ab_n(KeyCode::Key2, Some('2'.into()), Some('@'.into()));
+ mapping.set_ab_n(KeyCode::Key3, Some('3'.into()), Some('#'.into()));
+ mapping.set_ab_n(KeyCode::Key4, Some('4'.into()), Some('$'.into()));
+ mapping.set_ab_n(KeyCode::Key5, Some('5'.into()), Some('%'.into()));
+ mapping.set_ab_n(KeyCode::Key6, Some('6'.into()), Some('^'.into()));
+ mapping.set_ab_n(KeyCode::Key7, Some('7'.into()), Some('&'.into()));
+ mapping.set_ab_n(KeyCode::Key8, Some('8'.into()), Some('*'.into()));
+ mapping.set_ab_n(KeyCode::Key9, Some('9'.into()), Some('('.into()));
+ mapping.set_ab_n(KeyCode::Minus, Some('-'.into()), Some('_'.into()));
+ mapping.set_ab_n(KeyCode::Equals, Some('='.into()), Some('+'.into()));
+ mapping.set_aa_a(KeyCode::Backspace,Some('\x08'.into()));
+ mapping.set_aa_a(KeyCode::Tab,Some('\x09'.into()));
+ mapping.set_abcd_e_letter(KeyCode::Q, Some('q'.into()), Some('Q'.into()), Some('Q'.into()),Some('q'.into()), Some('\u{0011}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::W, Some('w'.into()), Some('W'.into()), Some('W'.into()),Some('w'.into()), Some('\u{0017}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::E, Some('e'.into()), Some('E'.into()), Some('E'.into()),Some('e'.into()), Some('\u{0005}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::R, Some('r'.into()), Some('R'.into()), Some('R'.into()),Some('r'.into()), Some('\u{0012}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::T, Some('t'.into()), Some('T'.into()), Some('T'.into()),Some('t'.into()), Some('\u{0014}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::Y, Some('y'.into()), Some('Y'.into()), Some('Y'.into()),Some('y'.into()), Some('\u{0019}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::U, Some('u'.into()), Some('U'.into()), Some('U'.into()),Some('u'.into()), Some('\u{0015}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::I, Some('i'.into()), Some('I'.into()), Some('I'.into()),Some('i'.into()), Some('\u{0009}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::O, Some('o'.into()), Some('O'.into()), Some('O'.into()),Some('o'.into()), Some('\u{000F}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::P, Some('p'.into()), Some('P'.into()), Some('P'.into()),Some('p'.into()), Some('\u{0010}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::A, Some('a'.into()), Some('A'.into()), Some('A'.into()),Some('a'.into()), Some('\u{0001}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::S, Some('s'.into()), Some('S'.into()), Some('S'.into()),Some('s'.into()), Some('\u{0013}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::D, Some('d'.into()), Some('D'.into()), Some('D'.into()),Some('d'.into()), Some('\u{0004}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::F, Some('f'.into()), Some('F'.into()), Some('F'.into()),Some('f'.into()), Some('\u{0006}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::G, Some('g'.into()), Some('G'.into()), Some('G'.into()),Some('g'.into()), Some('\u{0007}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::H, Some('h'.into()), Some('H'.into()), Some('H'.into()),Some('h'.into()), Some('\u{0008}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::J, Some('j'.into()), Some('J'.into()), Some('J'.into()),Some('j'.into()), Some('\u{000A}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::K, Some('k'.into()), Some('K'.into()), Some('K'.into()),Some('k'.into()), Some('\u{000B}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::L, Some('l'.into()), Some('L'.into()), Some('L'.into()),Some('l'.into()), Some('\u{000C}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::Z, Some('z'.into()), Some('Z'.into()), Some('Z'.into()),Some('z'.into()), Some('\u{001A}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::X, Some('x'.into()), Some('X'.into()), Some('X'.into()),Some('x'.into()), Some('\u{0018}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::C, Some('c'.into()), Some('C'.into()), Some('C'.into()),Some('c'.into()), Some('\u{0003}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::V, Some('v'.into()), Some('V'.into()), Some('V'.into()),Some('v'.into()), Some('\u{0016}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::B, Some('b'.into()), Some('B'.into()), Some('B'.into()),Some('b'.into()), Some('\u{0002}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::N, Some('n'.into()), Some('N'.into()), Some('N'.into()),Some('n'.into()), Some('\u{000E}'.into()));
+ mapping.set_abcd_e_letter(KeyCode::M, Some('m'.into()), Some('M'.into()), Some('M'.into()),Some('m'.into()), Some('\u{000D}'.into()));
+ mapping.set_ab_n(KeyCode::BracketSquareLeft, Some('{'.into()), Some('['.into()));
+ mapping.set_ab_n(KeyCode::BracketSquareRight, Some('}'.into()), Some(']'.into()));
+ mapping.set_ab_n(KeyCode::BackSlash, Some('|'.into()), Some('\\'.into()));
+ mapping.set_ab_n(KeyCode::SemiColon, Some(';'.into()), Some(':'.into()));
+ mapping.set_ab_n(KeyCode::Quote, Some('\''.into()), Some('"'.into()));
+ mapping.set_aa_a(KeyCode::Enter,Some('\x0A'.into()));
+ mapping.set_ab_n(KeyCode::Comma, Some(','.into()), Some('<'.into()));
+ mapping.set_ab_n(KeyCode::Fullstop, Some('.'.into()), Some('>'.into()));
+ mapping.set_ab_n(KeyCode::Slash, Some('/'.into()), Some('?'.into()));
+ mapping.set_aa_a(KeyCode::Spacebar,Some(' '.into()));
+ mapping.set_aa_a(KeyCode::Delete,Some('\x7F'.into()));
+ mapping.set_aaaa_num(KeyCode::NumpadSlash, Some('/'.into()), );
+ mapping.set_aaaa_num(KeyCode::NumpadStar, Some('*'.into()), );
+ mapping.set_aaaa_num(KeyCode::NumpadMinus, Some('-'.into()), );
+ mapping.set_abba_num(KeyCode::Numpad7, Some('7'.into()), Some(DecodedKey{ kind: DecodedKeyKind::RawKey, value: KeyCode::Home as u32 }));
+ mapping.set_abba_num(KeyCode::Numpad8, Some('8'.into()), Some(DecodedKey{ kind: DecodedKeyKind::RawKey, value: KeyCode::ArrowUp as u32 }));
+ mapping.set_abba_num(KeyCode::Numpad9, Some('9'.into()), Some(DecodedKey{ kind: DecodedKeyKind::RawKey, value: KeyCode::PageUp as u32 }));
+ mapping.set_aaaa_num(KeyCode::NumpadPlus, Some('+'.into()));
+ mapping.set_abba_num(KeyCode::Numpad4, Some('4'.into()), Some(DecodedKey{ kind: DecodedKeyKind::RawKey, value: KeyCode::ArrowLeft as u32 }));
+ mapping.set_aaaa_num(KeyCode::Numpad5, Some('5'.into()));
+ mapping.set_abba_num(KeyCode::Numpad6, Some('6'.into()), Some(DecodedKey{ kind: DecodedKeyKind::RawKey, value: KeyCode::ArrowRight as u32 }));
+ mapping.set_abba_num(KeyCode::Numpad1, Some('1'.into()), Some(DecodedKey{ kind: DecodedKeyKind::RawKey, value: KeyCode::End as u32 }));
+ mapping.set_abba_num(KeyCode::Numpad2, Some('2'.into()), Some(DecodedKey{ kind: DecodedKeyKind::RawKey, value: KeyCode::ArrowDown as u32 }));
+ mapping.set_abba_num(KeyCode::Numpad3, Some('3'.into()), Some(DecodedKey{ kind: DecodedKeyKind::RawKey, value: KeyCode::PageDown as u32 }));
+ mapping.set_abba_num(KeyCode::Numpad0, Some('0'.into()), Some(DecodedKey{ kind: DecodedKeyKind::RawKey, value: KeyCode::Insert as u32 }));
+ mapping.set_abba_num(KeyCode::NumpadPeriod, Some('.'.into()), Some('\x7F'.into()));
+ mapping.set_aaaa_num(KeyCode::NumpadEnter, Some('\x0A'.into()));
+ mapping
+ }
+ #[rustfmt::skip]
+ pub fn new_us105key() -> Self {
+ let mut mapping = Self::new_us104key();
+ mapping.set_abcde(KeyCode::BackTick, Some('`'.into()), Some('¬'.into()), Some('|'.into()), None);
+ mapping.set_ab_n(KeyCode::Key2, Some('2'.into()), Some('"'.into()));
+ mapping.set_ab_n(KeyCode::Quote, Some('\''.into()), Some('@'.into()));
+ mapping.set_ab_n(KeyCode::Key3, Some('3'.into()), Some('£'.into()));
+ mapping.set_abcde(KeyCode::BackTick, Some('4'.into()), Some('$'.into()), Some('€'.into()), None);
+ mapping.set_ab_n(KeyCode::HashTilde, Some('#'.into()), Some('~'.into()));
+ mapping
+ }
+}
+impl KeyboardLayout for CustomLayout {
+ fn map_keycode(
+ &self,
+ keycode: KeyCode,
+ modifiers: &Modifiers,
+ handle_ctrl: HandleControl,
+ ) -> DecodedKey {
+ let map_to_unicode = handle_ctrl == HandleControl::MapLettersToUnicode;
+ let spot = &self.mapping[keycode as usize];
+ if let Some(k) = if map_to_unicode && modifiers.is_ctrl() {
+ match spot {
+ LayoutEntry::Regular {
+ unshifted: _,
+ shifted: _,
+ altgr: _,
+ raw_unicode,
+ } => raw_unicode,
+ LayoutEntry::Numlockable {
+ unshifted: _,
+ shifted: _,
+ locked: _,
+ locked_shifted: _,
+ } => &None,
+ LayoutEntry::Capslockable {
+ unshifted: _,
+ shifted: _,
+ locked: _,
+ locked_shifted: _,
+ raw_unicode,
+ altgr: _,
+ } => raw_unicode,
+ }
+ } else if modifiers.alt_gr {
+ match spot {
+ LayoutEntry::Regular {
+ unshifted: _,
+ shifted: _,
+ altgr,
+ raw_unicode: _,
+ } => altgr,
+ LayoutEntry::Numlockable {
+ unshifted: _,
+ shifted: _,
+ locked: _,
+ locked_shifted: _,
+ } => &None,
+ LayoutEntry::Capslockable {
+ unshifted: _,
+ shifted: _,
+ locked: _,
+ locked_shifted: _,
+ raw_unicode: _,
+ altgr,
+ } => altgr,
+ }
+ } else if modifiers.is_shifted() {
+ match spot {
+ LayoutEntry::Regular {
+ unshifted: _,
+ shifted,
+ altgr: _,
+ raw_unicode: _,
+ } => shifted,
+ LayoutEntry::Numlockable {
+ unshifted: _,
+ shifted,
+ locked: _,
+ locked_shifted,
+ } => {
+ if modifiers.numlock {
+ locked_shifted
+ } else {
+ shifted
+ }
+ }
+ LayoutEntry::Capslockable {
+ unshifted: _,
+ shifted,
+ locked: _,
+ locked_shifted,
+ raw_unicode: _,
+ altgr: _,
+ } => {
+ if modifiers.is_caps() {
+ locked_shifted
+ } else {
+ shifted
+ }
+ }
+ }
+ } else {
+ match spot {
+ LayoutEntry::Regular {
+ unshifted,
+ shifted: _,
+ altgr: _,
+ raw_unicode: _,
+ } => unshifted,
+ LayoutEntry::Numlockable {
+ unshifted,
+ shifted: _,
+ locked,
+ locked_shifted: _,
+ } => {
+ if modifiers.numlock {
+ locked
+ } else {
+ unshifted
+ }
+ }
+ LayoutEntry::Capslockable {
+ unshifted,
+ shifted: _,
+ locked,
+ locked_shifted: _,
+ raw_unicode: _,
+ altgr: _,
+ } => {
+ if modifiers.is_caps() {
+ locked
+ } else {
+ unshifted
+ }
+ }
+ }
+ } {
+ *k
+ } else {
+ DecodedKey::RawKey(keycode as u8)
+ }
+ }
+}
+// Note(elfein) Not super hard to get right, but still- DO NOT TOUCH
+impl CustomLayout {
+ pub fn set_abcde(
+ &mut self,
+ index: KeyCode,
+ a: Option<DecodedKey>,
+ b: Option<DecodedKey>,
+ c: Option<DecodedKey>,
+ d: Option<DecodedKey>,
+ ) {
+ self.mapping[index as usize] = {
+ LayoutEntry::Regular {
+ unshifted: a,
+ shifted: b,
+ altgr: c,
+ raw_unicode: d,
+ }
+ };
+ }
+ pub fn set_ab_c(
+ &mut self,
+ index: KeyCode,
+ a: Option<DecodedKey>,
+ b: Option<DecodedKey>,
+ c: Option<DecodedKey>,
+ ) {
+ self.mapping[index as usize] = {
+ LayoutEntry::Regular {
+ unshifted: a,
+ shifted: b,
+ altgr: None,
+ raw_unicode: c,
+ }
+ };
+ }
+ pub fn set_ab_n(&mut self, index: KeyCode, a: Option<DecodedKey>, b: Option<DecodedKey>) {
+ self.mapping[index as usize] = {
+ LayoutEntry::Regular {
+ unshifted: a,
+ shifted: b,
+ altgr: None,
+ raw_unicode: None,
+ }
+ };
+ }
+ pub fn set_aa_a(&mut self, index: KeyCode, a: Option<DecodedKey>) {
+ self.mapping[index as usize] = {
+ LayoutEntry::Regular {
+ unshifted: a,
+ shifted: a,
+ altgr: None,
+ raw_unicode: a,
+ }
+ };
+ }
+ pub fn set_abcdef_letter(
+ &mut self,
+ index: KeyCode,
+ a: Option<DecodedKey>,
+ b: Option<DecodedKey>,
+ c: Option<DecodedKey>,
+ d: Option<DecodedKey>,
+ e: Option<DecodedKey>,
+ f: Option<DecodedKey>,
+ ) {
+ self.mapping[index as usize] = {
+ LayoutEntry::Capslockable {
+ unshifted: a,
+ shifted: b,
+ altgr: c,
+ locked: d,
+ locked_shifted: e,
+ raw_unicode: f,
+ }
+ };
+ }
+ pub fn set_abcd_e_letter(
+ &mut self,
+ index: KeyCode,
+ a: Option<DecodedKey>,
+ b: Option<DecodedKey>,
+ c: Option<DecodedKey>,
+ d: Option<DecodedKey>,
+ e: Option<DecodedKey>,
+ ) {
+ self.mapping[index as usize] = {
+ LayoutEntry::Capslockable {
+ unshifted: a,
+ shifted: b,
+ locked: c,
+ locked_shifted: d,
+ altgr: None,
+ raw_unicode: e,
+ }
+ };
+ }
+ pub fn set_aaaa_num(&mut self, index: KeyCode, a: Option<DecodedKey>) {
+ self.mapping[index as usize] = {
+ LayoutEntry::Numlockable {
+ unshifted: a,
+ shifted: a,
+ locked: a,
+ locked_shifted: a,
+ }
+ };
+ }
+ pub fn set_abba_num(&mut self, index: KeyCode, a: Option<DecodedKey>, b: Option<DecodedKey>) {
+ self.mapping[index as usize] = {
+ LayoutEntry::Numlockable {
+ unshifted: a,
+ shifted: b,
+ locked: b,
+ locked_shifted: a,
+ }
+ };
+ }
+}
diff --git a/ableos/src/keyboard/mod.rs b/ableos/src/keyboard/mod.rs
new file mode 100644
index 0000000..c669dc6
--- /dev/null
+++ b/ableos/src/keyboard/mod.rs
@@ -0,0 +1,273 @@
+#![allow(dead_code)]
+mod abstractions;
+mod small_types;
+mod traits;
+pub use abstractions::*;
+pub use small_types::*;
+pub use traits::*;
+const KEYCODE_BITS: u8 = 11;
+const EXTENDED_KEY_CODE: u8 = 0xE0;
+const KEY_RELEASE_CODE: u8 = 0xF0;
+#[derive(Debug)]
+pub struct Keyboard<T, S>
+where
+ T: KeyboardLayout,
+ S: ScancodeSet,
+{
+ register: u16,
+ num_bits: u8,
+ decode_state: DecodeState,
+ handle_ctrl: HandleControl,
+ modifiers: Modifiers,
+ layout: T,
+ set: S,
+}
+impl<T, S> Keyboard<T, S>
+where
+ T: KeyboardLayout + Default,
+ S: ScancodeSet + Default,
+{
+ /// Make a new Keyboard object with the given layout.
+ pub fn new(_layout: T, _set: S, handle_ctrl: HandleControl) -> Keyboard<T, S> {
+ Keyboard {
+ register: 0,
+ num_bits: 0,
+ decode_state: DecodeState::Start,
+ handle_ctrl,
+ modifiers: Modifiers {
+ lshift: false,
+ rshift: false,
+ lctrl: false,
+ rctrl: false,
+ numlock: true,
+ capslock: false,
+ alt_gr: false,
+ },
+ layout: T::default(),
+ set: S::default(),
+ }
+ }
+ // /// Change the Ctrl key mapping.
+ pub fn set_ctrl_handling(&mut self, new_value: HandleControl) {
+ self.handle_ctrl = new_value;
+ }
+ // /// Get the current Ctrl key mapping.
+ pub fn get_ctrl_handling(&self) -> HandleControl {
+ self.handle_ctrl
+ }
+ /// Clears the bit register.
+ ///
+ /// Call this when there is a timeout reading data from the keyboard.
+ pub fn clear(&mut self) {
+ self.register = 0;
+ self.num_bits = 0;
+ self.decode_state = DecodeState::Start;
+ }
+ /// Processes a 16-bit word from the keyboard.
+ ///
+ /// * The start bit (0) must be in bit 0.
+ /// * The data octet must be in bits 1..8, with the LSB in bit 1 and the
+ /// MSB in bit 8.
+ /// * The parity bit must be in bit 9.
+ /// * The stop bit (1) must be in bit 10.
+ pub fn add_word(&mut self, word: u16) -> Result<Option<KeyEvent>, Error> {
+ let byte = self.check_word(word)?;
+ self.add_byte(byte)
+ }
+ /// Processes an 8-bit byte from the keyboard.
+ ///
+ /// We assume the start, stop and parity bits have been processed and
+ /// verified.
+ pub fn add_byte(&mut self, byte: u8) -> Result<Option<KeyEvent>, Error> {
+ self.set.advance_state(&mut self.decode_state, byte)
+ }
+ /// Shift a bit into the register.
+ ///
+ /// Call this /or/ call `add_word` - don't call both.
+ /// Until the last bit is added you get Ok(None) returned.
+ pub fn add_bit(&mut self, bit: bool) -> Result<Option<KeyEvent>, Error> {
+ self.register |= (bit as u16) << self.num_bits;
+ self.num_bits += 1;
+ if self.num_bits == KEYCODE_BITS {
+ let word = self.register;
+ self.register = 0;
+ self.num_bits = 0;
+ self.add_word(word)
+ } else {
+ Ok(None)
+ }
+ }
+ /// Processes a `KeyEvent` returned from `add_bit`, `add_byte` or `add_word`
+ /// and produces a decoded key.
+ ///
+ /// For example, the KeyEvent for pressing the '5' key on your keyboard
+ /// gives a DecodedKey of unicode character '5', unless the shift key is
+ /// held in which case you get the unicode character '%'.
+ pub fn process_keyevent(&mut self, ev: KeyEvent) -> Option<DecodedKey> {
+ match ev {
+ KeyEvent {
+ code: KeyCode::ShiftLeft,
+ state: KeyState::Down,
+ } => {
+ self.modifiers.lshift = true;
+ None
+ }
+ KeyEvent {
+ code: KeyCode::ShiftRight,
+ state: KeyState::Down,
+ } => {
+ self.modifiers.rshift = true;
+ None
+ }
+ KeyEvent {
+ code: KeyCode::ShiftLeft,
+ state: KeyState::Up,
+ } => {
+ self.modifiers.lshift = false;
+ None
+ }
+ KeyEvent {
+ code: KeyCode::ShiftRight,
+ state: KeyState::Up,
+ } => {
+ self.modifiers.rshift = false;
+ None
+ }
+ KeyEvent {
+ code: KeyCode::CapsLock,
+ state: KeyState::Down,
+ } => {
+ self.modifiers.capslock = !self.modifiers.capslock;
+ None
+ }
+ KeyEvent {
+ code: KeyCode::NumpadLock,
+ state: KeyState::Down,
+ } => {
+ self.modifiers.numlock = !self.modifiers.numlock;
+ None
+ }
+ KeyEvent {
+ code: KeyCode::ControlLeft,
+ state: KeyState::Down,
+ } => {
+ self.modifiers.lctrl = true;
+ None
+ }
+ KeyEvent {
+ code: KeyCode::ControlLeft,
+ state: KeyState::Up,
+ } => {
+ self.modifiers.lctrl = false;
+ None
+ }
+ KeyEvent {
+ code: KeyCode::ControlRight,
+ state: KeyState::Down,
+ } => {
+ self.modifiers.rctrl = true;
+ None
+ }
+ KeyEvent {
+ code: KeyCode::ControlRight,
+ state: KeyState::Up,
+ } => {
+ self.modifiers.rctrl = false;
+ None
+ }
+ KeyEvent {
+ code: KeyCode::AltRight,
+ state: KeyState::Down,
+ } => {
+ self.modifiers.alt_gr = true;
+ None
+ }
+ KeyEvent {
+ code: KeyCode::AltRight,
+ state: KeyState::Up,
+ } => {
+ self.modifiers.alt_gr = false;
+ None
+ }
+ KeyEvent {
+ code: c,
+ state: KeyState::Down,
+ } => Some(
+ self.layout
+ .map_keycode(c, &self.modifiers, self.handle_ctrl),
+ ),
+ _ => None,
+ }
+ }
+ fn get_bit(&self, word: u16, offset: usize) -> bool {
+ ((word >> offset) & 0x0001) != 0
+ }
+ fn has_even_number_bits(&self, data: u8) -> bool {
+ (data.count_ones() % 2) == 0
+ }
+ /// Check 11-bit word has 1 start bit, 1 stop bit and an odd parity bit.
+ fn check_word(&self, word: u16) -> Result<u8, Error> {
+ let start_bit = self.get_bit(word, 0);
+ let parity_bit = self.get_bit(word, 9);
+ let stop_bit = self.get_bit(word, 10);
+ let data = ((word >> 1) & 0xFF) as u8;
+ if start_bit {
+ return Err(Error::BadStartBit);
+ }
+ if !stop_bit {
+ return Err(Error::BadStopBit);
+ }
+ let need_parity = self.has_even_number_bits(data);
+ // Odd parity, so these must not match
+ if need_parity != parity_bit {
+ return Err(Error::ParityError);
+ }
+ Ok(data)
+ }
+}
+pub fn parse_format() {
+ let test = include_str!("../../keymaps/qwerty.keymap").lines();
+ // r#"0-NONE\n1-HI#Says HI"#
+ for x in test {
+ for y in x.split('-') {
+ if y.parse::<u64>().is_ok() {
+ todo![];
+ // NOTE: this unwrap is ok bcause of the above check
+ // println!("NUM: {:?}", y.parse::<u64>().unwrap());
+ // serial_println!("NUM: {:?}", y.parse::<u64>().unwrap());
+ } else if y.starts_with('#') {
+ // ignore all # delimeted lines
+ } else {
+ // println!("STR: {:?}", y);
+ // serial_println!("STR: {:?}", y);
+ match y.trim() {
+ "NONE" => {}
+ "TAB" => {}
+ "SHIFT" => {}
+ "SCROLL_LOCK" => {}
+ "FUNCTION_1" => {}
+ "FUNCTION_2" => {}
+ "FUNCTION_3" => {}
+ "FUNCTION_4" => {}
+ "FUNCTION_5" => {}
+ "FUNCTION_6" => {}
+ "FUNCTION_7" => {}
+ "FUNCTION_8" => {}
+ "FUNCTION_9" => {}
+ "FUNCTION_10" => {}
+ "FUNCTION_11" => {}
+ "FUNCTION_12" => {}
+ "COMMA" => {}
+ "PERIOD" => {}
+ "FORWARDSLASH" => {}
+ "GRAVE" => {}
+ "BRACKET_LEFT" => {}
+ "BACK_SLASH" => {}
+ "BRACKET_RIGHT" => {}
+ "QUOTE" => {}
+ _ => {}
+ }
+ }
+ }
+ }
+}
diff --git a/ableos/src/keyboard/small_types.rs b/ableos/src/keyboard/small_types.rs
new file mode 100644
index 0000000..75ea706
--- /dev/null
+++ b/ableos/src/keyboard/small_types.rs
@@ -0,0 +1,246 @@
+#![allow(non_snake_case)]
+#[derive(Debug)]
+pub struct Modifiers {
+ pub lshift: bool,
+ pub rshift: bool,
+ pub lctrl: bool,
+ pub rctrl: bool,
+ pub numlock: bool,
+ pub capslock: bool,
+ pub alt_gr: bool,
+}
+impl Modifiers {
+ pub fn is_shifted(&self) -> bool {
+ self.lshift | self.rshift
+ }
+ pub fn is_ctrl(&self) -> bool {
+ self.lctrl | self.rctrl
+ }
+ pub fn is_caps(&self) -> bool {
+ self.capslock
+ }
+}
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum KeyState {
+ Up,
+ Down,
+}
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct KeyEvent {
+ pub code: KeyCode,
+ pub state: KeyState,
+}
+impl KeyEvent {
+ pub fn new(code: KeyCode, state: KeyState) -> KeyEvent {
+ KeyEvent { code, state }
+ }
+}
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum HandleControl {
+ /// If either Ctrl key is held down, convert the letters A through Z into
+ /// Unicode chars U+0001 through U+001A. If the Ctrl keys are not held
+ /// down, letters go through normally.
+ MapLettersToUnicode,
+ /// Don't do anything special - send through the Ctrl key up/down events,
+ /// and leave the letters as letters.
+ Ignore,
+}
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum DecodeState {
+ Start,
+ Extended,
+ Release,
+ ExtendedRelease,
+}
+/// Indicates different error conditions.
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum Error {
+ BadStartBit,
+ BadStopBit,
+ ParityError,
+ UnknownKeyCode,
+ InvalidState,
+}
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[repr(u8)]
+pub enum DecodedKeyKind {
+ RawKey = 0,
+ Unicode = 1,
+}
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+#[repr(C)]
+pub struct DecodedKey {
+ pub kind: DecodedKeyKind,
+ pub value: u32,
+}
+impl From<char> for DecodedKey {
+ fn from(ch: char) -> Self {
+ Self {
+ kind: DecodedKeyKind::Unicode,
+ value: ch as u32,
+ }
+ }
+}
+impl DecodedKey {
+ pub const ZERO: Self = Self {
+ kind: DecodedKeyKind::Unicode,
+ value: 0,
+ };
+ pub fn Unicode(ch: char) -> Self {
+ Self {
+ kind: DecodedKeyKind::Unicode,
+ value: ch.into(),
+ }
+ }
+ pub fn RawKey(byte: u8) -> Self {
+ Self {
+ kind: DecodedKeyKind::RawKey,
+ value: byte.into(),
+ }
+ }
+}
+macro_rules! keycode_enum {
+ (@get_last $Variant:ident) => {
+ Self::$Variant
+ };
+ (@get_last $Variant:ident, $($VariantTail:ident),*) => {
+ keycode_enum![@get_last $($VariantTail),*]
+ };
+ ($($Variant:ident=$Value:expr,)*) => {
+ #[derive(Debug, PartialEq, Eq, Clone, Copy)]
+ #[repr(u8)]
+ pub enum KeyCode {
+ $($Variant = $Value),*
+ }
+
+ impl core::convert::From<u32> for KeyCode {
+ fn from(n: u32) -> Self {
+ match n {
+ $($Value => Self::$Variant),*,
+ _ => keycode_enum![@get_last $($Variant),*]
+ }
+ }
+ }
+ };
+ ($($Variant:ident=$Value:expr),* ) => {
+ keycode_enum!($($Variant=$Value,)* );
+ };
+}
+// This will be a way to map keys to other keys / keyyngs / macros
+keycode_enum! {
+ AltLeft = 0x00,
+ AltRight = 0x01,
+ ArrowDown = 0x02,
+ ArrowLeft = 0x03,
+ ArrowRight = 0x04,
+ ArrowUp = 0x05,
+ BackSlash = 0x06,
+ Backspace = 0x07,
+ BackTick = 0x08,
+ BracketSquareLeft = 0x09,
+ BracketSquareRight = 0x0A,
+ CapsLock = 0x0B,
+ Comma = 0x0C,
+ ControlLeft = 0x0D,
+ ControlRight = 0x0E,
+ Delete = 0x0F,
+ End = 0x10,
+ Enter = 0x11,
+ Escape = 0x12,
+ Equals = 0x13,
+ F1 = 0x14,
+ F2 = 0x15,
+ F3 = 0x16,
+ F4 = 0x17,
+ F5 = 0x18,
+ F6 = 0x19,
+ F7 = 0x1A,
+ F8 = 0x1B,
+ F9 = 0x1C,
+ F10 = 0x1D,
+ F11 = 0x1E,
+ F12 = 0x1F,
+ Fullstop = 0x20,
+ Home = 0x21,
+ Insert = 0x22,
+ Key1 = 0x23,
+ Key2 = 0x24,
+ Key3 = 0x25,
+ Key4 = 0x26,
+ Key5 = 0x27,
+ Key6 = 0x28,
+ Key7 = 0x29,
+ Key8 = 0x2A,
+ Key9 = 0x2B,
+ Key0 = 0x2C,
+ Menus = 0x2D,
+ Minus = 0x2E,
+ Numpad0 = 0x2F,
+ Numpad1 = 0x30,
+ Numpad2 = 0x31,
+ Numpad3 = 0x32,
+ Numpad4 = 0x33,
+ Numpad5 = 0x34,
+ Numpad6 = 0x35,
+ Numpad7 = 0x36,
+ Numpad8 = 0x37,
+ Numpad9 = 0x38,
+ NumpadEnter = 0x39,
+ NumpadLock = 0x3A,
+ NumpadSlash = 0x3B,
+ NumpadStar = 0x3C,
+ NumpadMinus = 0x3D,
+ NumpadPeriod = 0x3E,
+ NumpadPlus = 0x3F,
+ PageDown = 0x40,
+ PageUp = 0x41,
+ PauseBreak = 0x42,
+ PrintScreen = 0x43,
+ ScrollLock = 0x44,
+ SemiColon = 0x45,
+ ShiftLeft = 0x46,
+ ShiftRight = 0x47,
+ Slash = 0x48,
+ Spacebar = 0x49,
+ Tab = 0x4A,
+ Quote = 0x4B,
+ WindowsLeft = 0x4C,
+ WindowsRight = 0x4D,
+ A = 0x4E,
+ B = 0x4F,
+ C = 0x50,
+ D = 0x51,
+ E = 0x52,
+ F = 0x53,
+ G = 0x54,
+ H = 0x55,
+ I = 0x56,
+ J = 0x57,
+ K = 0x58,
+ L = 0x59,
+ M = 0x5A,
+ N = 0x5B,
+ O = 0x5C,
+ P = 0x5D,
+ Q = 0x5E,
+ R = 0x5F,
+ S = 0x60,
+ T = 0x61,
+ U = 0x62,
+ V = 0x63,
+ W = 0x64,
+ X = 0x65,
+ Y = 0x66,
+ Z = 0x67,
+ HashTilde = 0x68,
+ PrevTrack = 0x69,
+ NextTrack = 0x6A,
+ Mute = 0x6B,
+ Calculator = 0x6C,
+ Play = 0x6D,
+ Stop = 0x6E,
+ VolumeDown = 0x6F,
+ VolumeUp = 0x70,
+ WWWHome = 0x71,
+ PowerOnTestOk = 0x72,
+}
diff --git a/ableos/src/keyboard/traits.rs b/ableos/src/keyboard/traits.rs
new file mode 100644
index 0000000..789464e
--- /dev/null
+++ b/ableos/src/keyboard/traits.rs
@@ -0,0 +1,21 @@
+use super::*;
+pub trait ScancodeSet {
+ /// Handles the state logic for the decoding of scan codes into key events.
+ fn advance_state(&self, state: &mut DecodeState, code: u8) -> Result<Option<KeyEvent>, Error>;
+ /// Convert a Scan Code set X byte to our 'KeyType' enum
+ fn map_scancode(&self, code: u8) -> Result<KeyCode, Error>;
+ /// Convert a Scan Code Set X extended byte (prefixed E0) to our `KeyType`
+ /// enum.
+ fn map_extended_scancode(&self, code: u8) -> Result<KeyCode, Error>;
+}
+pub trait KeyboardLayout {
+ /// Convert a `KeyType` enum to a Unicode character, if possible.
+ /// `KeyType::A` maps to `Some('a')` (or `Some('A')` if shifted), while
+ /// `KeyType::AltLeft` returns `None`
+ fn map_keycode(
+ &self,
+ keycode: KeyCode,
+ modifiers: &Modifiers,
+ handle_ctrl: HandleControl,
+ ) -> DecodedKey;
+}
diff --git a/ableos/src/kmain.rs b/ableos/src/kmain.rs
new file mode 100644
index 0000000..0a87b50
--- /dev/null
+++ b/ableos/src/kmain.rs
@@ -0,0 +1,74 @@
+#![allow(clippy::empty_loop)]
+use crate::{
+ arch::{drivers::graphics::GraphicsBuffer, init},
+ driver_traits::{graphics::Graphics, serial::Serial},
+ relib::math::rand::{linearshift::LinearShiftRegister, prand::PRand, RAND_HANDLE, RNG},
+ serial_print, serial_println,
+};
+use lazy_static::lazy_static;
+#[no_mangle]
+#[allow(unconditional_recursion)]
+pub extern "C" fn stack_overflow() -> u8 {
+ stack_overflow();
+ 69 // NOTE: Any specific reason for this number asside from memes?
+}
+
+use crate::keyboard::DecodedKey;
+
+lazy_static! {
+ pub static ref KEY_BUFFER: [DecodedKey; 256] = [DecodedKey::RawKey(123); 256];
+ pub static ref KEY_BUFFER_POINTER: u8 = 0;
+}
+#[no_mangle]
+pub extern "C" fn kernel_main() {
+ init::init();
+
+ GraphicsBuffer::draw();
+ GraphicsBuffer::hide_cursor();
+ GraphicsBuffer::show_cursor();
+ seed_rng();
+
+ /* If AES is present then AES init rng as well
+ // Maybe via a cfg
+ AES::init_rng();
+
+ */
+
+ println!("init");
+ {
+ use crate::experiments::mail::MailBoxes;
+ let mut x = MailBoxes::new();
+ x.set_flag(1);
+ x.set_flag(2);
+ // x.dump_flags();
+ }
+
+ // stack_overflow();
+
+ loop {}
+}
+// TODO: reimplement for the random handler
+pub fn seed_rng() -> PRand {
+ println!("Seeding PRNG");
+ let data = TICK.lock();
+ let mut rand = PRand::new();
+ let seed = rand.rand();
+ println!("{:?}", seed);
+ rand.seed(*data);
+ println!("Seeded PRNG");
+ rand
+}
+lazy_static! {
+ // TODO: should have a sin wave influence contribution to entropy
+ pub static ref TICK: spin::Mutex<u64> = spin::Mutex::new(0);
+}
+/// called by arch specific timers to tick up all kernel related functions
+pub fn tick() {
+ let mut data = TICK.lock();
+ *data += 1;
+ // serial_println!("{}", *data);
+ RAND_HANDLE.lock().seed_entropy_timer(*data);
+}
+pub fn key_entropy(key: u8) {
+ RAND_HANDLE.lock().seed_entropy_keyboard(key);
+}
diff --git a/ableos/src/lib.rs b/ableos/src/lib.rs
new file mode 100644
index 0000000..33f5828
--- /dev/null
+++ b/ableos/src/lib.rs
@@ -0,0 +1,43 @@
+#![no_std]
+// #![deny(warnings)]
+#![feature(asm)]
+#![feature(global_asm)]
+#![feature(abi_x86_interrupt)]
+#![feature(core_intrinsics, lang_items, llvm_asm)]
+// #![feature(alloc_error_handler)] // at the top of the file
+#![reexport_test_harness_main = "test_main"]
+#![feature(custom_test_frameworks)]
+#![test_runner(crate::arch::test_runner)]
+#[cfg(target_arch = "arm")]
+#[path = "arch/aarch32/mod.rs"]
+mod arch;
+
+#[cfg(target_arch = "aarch64")]
+#[path = "arch/aarch64/mod.rs"]
+mod arch;
+
+#[cfg(target_arch = "x86_64")]
+#[path = "arch/x86_64/mod.rs"]
+mod arch;
+#[cfg(target_arch = "mips")]
+#[path = "arch/ps_portable/mod.rs"]
+mod arch;
+#[macro_use]
+pub mod print;
+#[cfg(not(target_arch = "mips"))]
+// pub mod allocator;
+mod kmain;
+#[cfg(not(target_arch = "mips"))]
+mod panic;
+mod driver_traits;
+mod experiments;
+pub use experiments::server;
+pub mod keyboard;
+pub mod relib;
+pub const KERNEL_VERSION: &str = env!("CARGO_PKG_VERSION");
+#[cfg(debug_assertions)]
+/// A constant to check if the kernel is in debug mode
+pub const RELEASE_TYPE: &str = "debug";
+#[cfg(not(debug_assertions))]
+/// A constant to check if the kernel is in release mode
+pub const RELEASE_TYPE: &str = "release";
diff --git a/ableos/src/main.rs b/ableos/src/main.rs
new file mode 100644
index 0000000..04916ef
--- /dev/null
+++ b/ableos/src/main.rs
@@ -0,0 +1,3 @@
+#![no_std]
+#![no_main]
+pub use ableos::*;
diff --git a/ableos/src/panic.rs b/ableos/src/panic.rs
new file mode 100644
index 0000000..794139a
--- /dev/null
+++ b/ableos/src/panic.rs
@@ -0,0 +1,9 @@
+use crate::{arch::sloop, println, serial_println};
+use core::panic::PanicInfo;
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+ println!("{}", info);
+ serial_println!("{}", info);
+ sloop()
+}
diff --git a/ableos/src/print.rs b/ableos/src/print.rs
new file mode 100644
index 0000000..8579f70
--- /dev/null
+++ b/ableos/src/print.rs
@@ -0,0 +1,60 @@
+pub struct Stdout;
+use core::fmt::Arguments;
+use core::fmt::Error;
+impl Stdout {
+ pub fn write_fmt(&mut self, arg: Arguments<'_>) /*-> Result<(), Error> */
+ {
+ core::fmt::Write::write_fmt(self, arg);
+ // Ok(())
+ }
+}
+impl core::fmt::Write for Stdout {
+ #[cfg(target_arch = "arm")]
+ fn write_str(&mut self, s: &str) -> Result<(), Error> {
+ use crate::arch::write;
+ write(s);
+ Ok(())
+ }
+
+ #[cfg(target_arch = "aarch64")]
+ fn write_str(&mut self, s: &str) -> Result<(), Error> {
+ // Don't actually print anything yet lmao
+
+ Ok(())
+ }
+
+ #[cfg(target_arch = "x86_64")]
+ fn write_str(&mut self, s: &str) -> Result<(), Error> {
+ use crate::kprint;
+ // FIXME: causes issues
+ kprint!("{}", s);
+ Ok(())
+ }
+
+ #[cfg(target_arch = "mips")]
+ fn write_str(&mut self, s: &str) -> Result<(), Error> {
+ use psp::dprint;
+ dprint!("{}", s);
+ Ok(())
+ }
+}
+#[macro_export]
+macro_rules! print {
+ () => {
+ ::core::writeln!($crate::print::Stdout, "")
+ };
+ ($($tt:tt)*) => {
+ ::core::write!($crate::print::Stdout, $($tt)*)
+ };
+}
+#[macro_export]
+macro_rules! println {
+ () =>{
+ // ::core::writeln!($crate::print::Stdout, "\n")
+ panic![];
+ };
+ ($($tt:tt)*) => {
+ ::core::writeln!($crate::print::Stdout, $($tt)*)
+ // panic![];
+ };
+}
diff --git a/ableos/src/relib/math/mod.rs b/ableos/src/relib/math/mod.rs
new file mode 100644
index 0000000..63945bc
--- /dev/null
+++ b/ableos/src/relib/math/mod.rs
@@ -0,0 +1 @@
+pub mod rand;
diff --git a/ableos/src/relib/math/rand/linearshift.rs b/ableos/src/relib/math/rand/linearshift.rs
new file mode 100644
index 0000000..8e0c715
--- /dev/null
+++ b/ableos/src/relib/math/rand/linearshift.rs
@@ -0,0 +1,35 @@
+use crate::relib::math::rand::RNG;
+pub struct LinearShiftRegister {
+ reg: u64,
+}
+// 64 bit
+// non-cryptographically secure
+impl RNG for LinearShiftRegister {
+ fn new() -> Self {
+ Self { reg: (1 << 63) | 1 }
+ }
+ fn rand(&mut self) -> u64 {
+ let newbit = (self.reg >> 1) ^ (self.reg >> 2) ^ (self.reg >> 7);
+ self.reg = (self.reg >> 1) | (newbit << 3);
+ newbit
+ }
+ fn seed(&mut self, seed: u64) {
+ let entropy = 34; // replace with hardware entropy
+
+ let shifted = (self.reg >> 1) ^ ((self.reg >> 2) + entropy);
+ let x: u64 = 2983745;
+ let x123: u64 = 100000000;
+ let multitude: u64 = x123.wrapping_mul(x) / x;
+ let mult = shifted.wrapping_mul(multitude);
+ let seeded_bit = seed / mult;
+
+ if false {
+ // crate::serial_println!("Entropy {}", entropy);
+ // crate::serial_println!("Multitude {}", multitude);
+ // crate::serial_println!("Seeded Bit {}", seeded_bit);
+ }
+ for _ in 0..seeded_bit {
+ self.rand();
+ }
+ }
+}
diff --git a/ableos/src/relib/math/rand/mod.rs b/ableos/src/relib/math/rand/mod.rs
new file mode 100644
index 0000000..78c66ab
--- /dev/null
+++ b/ableos/src/relib/math/rand/mod.rs
@@ -0,0 +1,87 @@
+#![allow(dead_code)]
+pub mod linearshift;
+pub mod prand;
+pub mod wichmanhillrand; // FIXEME: Reimplement
+use crate::serial_println;
+use lazy_static::lazy_static;
+use linearshift::LinearShiftRegister;
+use prand::PRand;
+pub trait RNG {
+ fn new() -> Self;
+ fn rand(&mut self) -> u64;
+ fn seed(&mut self, seed: u64);
+}
+
+pub type KeyEntropyHandler = u8;
+
+pub struct Entropy {
+ // Everytime entropy is used decrement bits count
+ bytes_count: u8, // 167 is our lower desired bit count
+ pool_index: u8,
+ pool: [u64; 255],
+}
+impl Entropy {
+ pub fn new() -> Self {
+ Self {
+ bytes_count: 0,
+ pool: [0; 255],
+ pool_index: 0,
+ }
+ }
+ pub fn poll_hardware() {
+ todo!();
+ }
+ pub fn read_entropy(&mut self) -> u8 {
+ self.bytes_count -= 1;
+ 1
+ }
+}
+impl Default for Entropy {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+pub struct RandomHandeler {
+ prand: prand::PRand,
+ linearshift: linearshift::LinearShiftRegister,
+ entropy: Entropy,
+}
+impl RandomHandeler {
+ pub fn seed_entropy(&mut self) {
+ // n is even
+ self.prand
+ .seed(self.entropy.pool[self.entropy.pool_index as usize]);
+ //otherwise odd
+ self.linearshift
+ .seed(self.entropy.pool[self.entropy.pool_index as usize]);
+ }
+ // FIXME: Likely to panic
+
+ pub fn seed_entropy_keyboard(&mut self, key: u8) {
+ self.entropy.pool_index += key;
+ if self.entropy.pool_index > 254 {
+ self.entropy.pool_index = 0
+ }
+ self.entropy.pool[self.entropy.pool_index as usize] += key as u64;
+
+ self.entropy.pool_index += 1;
+ }
+ pub fn seed_entropy_timer(&mut self, seed: u64) {
+ let bytes = seed.to_be_bytes();
+
+ for byte in bytes {
+ if self.entropy.pool_index > 254 {
+ self.entropy.pool_index = 0
+ }
+ self.entropy.pool[self.entropy.pool_index as usize] += byte as u64;
+ self.entropy.pool_index += 1;
+ }
+ }
+}
+lazy_static! {
+ pub static ref RAND_HANDLE: spin::Mutex<RandomHandeler> = spin::Mutex::new(RandomHandeler {
+ prand: PRand::new(),
+ linearshift: LinearShiftRegister::new(),
+ entropy: Entropy::new(),
+ });
+}
diff --git a/ableos/src/relib/math/rand/prand.rs b/ableos/src/relib/math/rand/prand.rs
new file mode 100644
index 0000000..509df21
--- /dev/null
+++ b/ableos/src/relib/math/rand/prand.rs
@@ -0,0 +1,17 @@
+use crate::relib::math::rand::RNG;
+pub struct PRand {
+ next: u64,
+}
+impl RNG for PRand {
+ fn new() -> Self {
+ Self { next: 7 }
+ }
+ fn rand(&mut self) -> u64 {
+ let internal_seed_1 = 21354;
+ self.next = self.next.wrapping_mul(1103515245) + internal_seed_1;
+ (self.next / 65536) % 32768
+ }
+ fn seed(&mut self, seed: u64) {
+ self.next = seed;
+ }
+}
diff --git a/ableos/src/relib/math/rand/wichmanhillrand.rs b/ableos/src/relib/math/rand/wichmanhillrand.rs
new file mode 100644
index 0000000..9857c6d
--- /dev/null
+++ b/ableos/src/relib/math/rand/wichmanhillrand.rs
@@ -0,0 +1,27 @@
+use crate::relib::math::rand::RNG;
+pub struct WichmannHillRand {
+ seed0: u16,
+ seed1: u16,
+ seed2: u16,
+}
+impl RNG for WichmannHillRand {
+ fn new() -> Self {
+ Self {
+ seed0: 123,
+ seed1: 456,
+ seed2: 789,
+ }
+ }
+ fn rand(&mut self) -> u64 {
+ self.seed0 = (self.seed0.wrapping_mul(170)) % 30269;
+ self.seed1 = (self.seed1.wrapping_mul(172)) % 30307;
+ self.seed2 = (self.seed2.wrapping_mul(173)) % 30323;
+
+ (self.seed0 / 30269 + self.seed1 / 30307 + self.seed2 / 30323).into()
+ }
+ fn seed(&mut self, seed: u64) {
+ self.seed0 = (seed >> 48) as u16;
+ self.seed1 = ((seed << 16) >> 48) as u16;
+ self.seed2 = ((seed << 32) >> 48) as u16;
+ }
+}
diff --git a/ableos/src/relib/mod.rs b/ableos/src/relib/mod.rs
new file mode 100644
index 0000000..9be1b43
--- /dev/null
+++ b/ableos/src/relib/mod.rs
@@ -0,0 +1,6 @@
+pub mod math;
+pub mod time;
+pub struct VectorTwo {
+ pub x: i32,
+ pub y: i32,
+}
diff --git a/ableos/src/relib/time/kilotime.rs b/ableos/src/relib/time/kilotime.rs
new file mode 100644
index 0000000..4941da8
--- /dev/null
+++ b/ableos/src/relib/time/kilotime.rs
@@ -0,0 +1,72 @@
+use super::Time;
+use core::fmt::{Display, Error, Formatter};
+#[derive(Debug, Clone, Copy)]
+#[repr(transparent)]
+pub struct Kilosecond(usize);
+impl Display for Kilosecond {
+ fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
+ let mut reg = self.0;
+ let mut buf = [0u8, 0, 0, 0, 0];
+ let mut n = 0;
+ while n < 8 {
+ if n > 2 {
+ buf[7 - n] = match reg % 10 {
+ 0 => b'0',
+ 1 => b'1',
+ 2 => b'2',
+ 3 => b'3',
+ 4 => b'4',
+ 5 => b'5',
+ 6 => b'6',
+ 7 => b'7',
+ 8 => b'8',
+ 9 => b'9',
+ _ => unreachable!["CPU is borken"],
+ };
+ }
+ reg /= 10;
+ n += 1;
+ }
+ for (n, b) in buf.iter().enumerate() {
+ write![f, "{}", *b as char]?;
+ if n == 1 {
+ write![f, "."]?;
+ }
+ }
+ Ok(())
+ }
+}
+impl core::ops::Add for Kilosecond {
+ type Output = Self;
+ fn add(self, rhs: Self) -> Self {
+ Self(self.0 + rhs.0)
+ }
+}
+impl core::ops::Sub for Kilosecond {
+ type Output = Self;
+ fn sub(self, rhs: Self) -> Self {
+ Self(self.0 - rhs.0)
+ }
+}
+impl From<Time> for Kilosecond {
+ fn from(t: Time) -> Self {
+ Self((t.hour as usize * 3600 + t.minutes as usize * 60 + t.seconds as usize) * 1000)
+ }
+}
+impl Kilosecond {
+ pub fn from_ms(ms: usize) -> Self {
+ Self(ms)
+ }
+ pub fn from_sec(sec: usize) -> Self {
+ Self(sec * 1000)
+ }
+ pub fn from_minutes(min: usize) -> Self {
+ Self(min * 60 * 1000)
+ }
+ pub fn from_hours(hrs: usize) -> Self {
+ Self(hrs * 60 * 60 * 1000)
+ }
+ pub fn from_days(days: usize) -> Self {
+ Self(days * 24 * 60 * 60 * 1000)
+ }
+}
diff --git a/ableos/src/relib/time/mod.rs b/ableos/src/relib/time/mod.rs
new file mode 100644
index 0000000..b87e328
--- /dev/null
+++ b/ableos/src/relib/time/mod.rs
@@ -0,0 +1,20 @@
+pub struct Time {
+ pub year: u16,
+ pub month: u16,
+ pub day: u16,
+ pub hour: u16,
+ pub minutes: u16,
+ pub seconds: u16,
+ pub microseconds: u32,
+}
+impl fmt::Display for Time {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(
+ f,
+ "{:?}/{:?}/{:?} {:02}:{:02}:{:02}",
+ self.year, self.month, self.day, self.hour, self.minutes, self.seconds
+ )
+ }
+}
+pub mod kilotime;
+use core::fmt;
diff --git a/repbuild/Cargo.lock b/repbuild/Cargo.lock
new file mode 100644
index 0000000..4f03bc7
--- /dev/null
+++ b/repbuild/Cargo.lock
@@ -0,0 +1,248 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "ansi_term"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee10e43ae4a853c0a3591d4e2ada1719e553be18199d9da9d4a83f5927c2f5c7"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "clap"
+version = "2.33.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "bitflags",
+ "strsim",
+ "textwrap",
+ "unicode-width",
+ "vec_map",
+]
+
+[[package]]
+name = "heck"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "libc"
+version = "0.2.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbe5e23404da5b4f555ef85ebed98fb4083e55a00c317800bc2a50ede9f3d219"
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "repbuild"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "structopt",
+ "xshell",
+]
+
+[[package]]
+name = "strsim"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
+
+[[package]]
+name = "structopt"
+version = "0.3.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40b9788f4202aa75c240ecc9c15c65185e6a39ccdeb0fd5d008b98825464c87c"
+dependencies = [
+ "clap",
+ "lazy_static",
+ "structopt-derive",
+]
+
+[[package]]
+name = "structopt-derive"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcb5ae327f9cc13b68763b5749770cb9e048a99bd9dfdfa58d0cf05d5f64afe0"
+dependencies = [
+ "heck",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+
+[[package]]
+name = "vec_map"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
+
+[[package]]
+name = "version_check"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "xshell"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eaad2035244c56da05573d4d7fda5f903c60a5f35b9110e157a14a1df45a9f14"
+dependencies = [
+ "xshell-macros",
+]
+
+[[package]]
+name = "xshell-macros"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4916a4a3cad759e499a3620523bf9545cc162d7a06163727dde97ce9aaa4cf39"
diff --git a/repbuild/Cargo.toml b/repbuild/Cargo.toml
new file mode 100644
index 0000000..44d91f4
--- /dev/null
+++ b/repbuild/Cargo.toml
@@ -0,0 +1,12 @@
+cargo-features = ["edition2021"]
+[package]
+name = "repbuild"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.39"
+structopt = "0.3.21"
+xshell = "0.1.9"
diff --git a/repbuild/README.md b/repbuild/README.md
new file mode 100644
index 0000000..921a8d0
--- /dev/null
+++ b/repbuild/README.md
@@ -0,0 +1,2 @@
+# AbleOS Build system
+The ableOS build system was ripped from repnops xtask build system in the risc-v kernel (hence the name)
diff --git a/repbuild/src/main.rs b/repbuild/src/main.rs
new file mode 100644
index 0000000..af72e7e
--- /dev/null
+++ b/repbuild/src/main.rs
@@ -0,0 +1,43 @@
+use structopt::StructOpt;
+
+#[derive(StructOpt)]
+enum Command {
+ Run {
+ #[structopt(long)]
+ debug: bool,
+ },
+}
+
+fn build_kernel() -> anyhow::Result<()> {
+ let _dir = xshell::pushd("./ableos");
+
+ // Used for the x86-64 variant only
+ xshell::cmd!("cargo run --release").run()?;
+ // xshell::cmd!("cargo build --release").run()?;
+
+ Ok(())
+}
+
+fn main() -> anyhow::Result<()> {
+ let args = Command::from_args();
+
+ match args {
+ Command::Run { debug } => {
+ build_kernel()?;
+
+ let debug_log: &[&str] = match debug {
+ true => &["-D", "debug.log"],
+ false => &[],
+ };
+ #[rustfmt::skip]
+ xshell::cmd!("
+ qemu-system-x86_64
+ -drive format=raw,file=../../ableos/target/x86_64-ableos/release/bootimage-ableos.bin
+ {debug_log...}
+ "
+ ).run()?;
+ }
+ }
+
+ Ok(())
+}
diff --git a/rust-toolchain b/rust-toolchain
new file mode 100644
index 0000000..bf867e0
--- /dev/null
+++ b/rust-toolchain
@@ -0,0 +1 @@
+nightly