Compare commits
11 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 vasilito
|
670693e114 | ||
 Red Bear OS
|
395046ee3f | ||
|
Red Bear OS
|
25ae058f11 | ||
|
Red Bear OS
|
4173b68e17 | ||
|
vasilito
|
2636531bb3 | ||
|
vasilito
|
395bedfbea | ||
|
Red Bear OS
|
e913bacaa3 | ||
|
Red Bear OS
|
e5c076b0ea | ||
|
Red Bear OS
|
3c84baebed | ||
|
Red Bear OS
|
ea272706a7 | ||
|
Red Bear OS
|
5dc4a8364e |
@@ -1,7 +0,0 @@
|
||||
[**.c]
|
||||
indent_size = 4
|
||||
indent_style = space
|
||||
|
||||
[**.yml]
|
||||
indent_size = 4
|
||||
indent_style = space
|
||||
+1
-11
@@ -1,11 +1 @@
|
||||
.idea/
|
||||
prefix/
|
||||
sysroot/
|
||||
**/target/
|
||||
.gdb_history
|
||||
*.patch
|
||||
*.swp
|
||||
*.swo
|
||||
/.vim
|
||||
.vscode/
|
||||
|
||||
/target/
|
||||
|
||||
@@ -1,73 +0,0 @@
|
||||
image: "redoxos/redoxer:latest"
|
||||
|
||||
variables:
|
||||
GIT_SUBMODULE_STRATEGY: recursive
|
||||
|
||||
workflow:
|
||||
rules:
|
||||
- if: '$CI_COMMIT_BRANCH == "master" && $CI_PROJECT_NAMESPACE == "redox-os"'
|
||||
- if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "master"'
|
||||
|
||||
stages:
|
||||
- build
|
||||
- cross-build
|
||||
- test
|
||||
before_script:
|
||||
cargo install cbindgen
|
||||
|
||||
fmt:
|
||||
stage: build
|
||||
needs: []
|
||||
script:
|
||||
- rustup component add rustfmt-preview
|
||||
- ./fmt.sh -- --check
|
||||
|
||||
linux:
|
||||
stage: build
|
||||
script:
|
||||
- ./check.sh --host
|
||||
|
||||
x86_64:
|
||||
stage: build
|
||||
script:
|
||||
- ./check.sh --arch=x86_64
|
||||
|
||||
i586:
|
||||
stage: cross-build
|
||||
script:
|
||||
- ./check.sh --arch=i586
|
||||
|
||||
aarch64:
|
||||
stage: cross-build
|
||||
image: "redoxos/redoxer:aarch64"
|
||||
script:
|
||||
- ./check.sh --arch=aarch64
|
||||
|
||||
riscv64gc:
|
||||
stage: cross-build
|
||||
script:
|
||||
- ./check.sh --arch=riscv64gc
|
||||
|
||||
test:linux:
|
||||
stage: test
|
||||
needs: [linux]
|
||||
script:
|
||||
- ./check.sh --host --test
|
||||
|
||||
test:x86_64:
|
||||
stage: test
|
||||
needs: [x86_64]
|
||||
script:
|
||||
# timeout: https://gitlab.redox-os.org/redox-os/relibc/-/issues/238
|
||||
- timeout -s KILL 9m ./check.sh --arch=x86_64 --test
|
||||
|
||||
test:aarch64:
|
||||
stage: test
|
||||
needs: [aarch64]
|
||||
image: "redoxos/redoxer:aarch64"
|
||||
# many issues that not exist in x86_64, and lack of interest to fix so far
|
||||
allow_failure: true
|
||||
script:
|
||||
- timeout -s KILL 9m ./check.sh --arch=aarch64 --test
|
||||
|
||||
#TODO: Enable more arch once dynamic linker working
|
||||
@@ -1,7 +0,0 @@
|
||||
[submodule "openlibm"]
|
||||
path = openlibm
|
||||
url = https://gitlab.redox-os.org/redox-os/openlibm.git
|
||||
branch = master
|
||||
[submodule "src/dlmalloc-rs"]
|
||||
path = dlmalloc-rs
|
||||
url = https://gitlab.redox-os.org/redox-os/dlmalloc-rs.git
|
||||
@@ -0,0 +1,6 @@
|
||||
language: rust
|
||||
rust:
|
||||
- nightly
|
||||
sudo: false
|
||||
notifications:
|
||||
email: false
|
||||
-123
@@ -1,123 +0,0 @@
|
||||
# Contributing
|
||||
|
||||
## Table of contents
|
||||
1. [What to do](#what-to-do)
|
||||
2. [Code style](#code-style)
|
||||
3. [Sending merge requests](#sending-merge-requests)
|
||||
4. [Writing tests](#writing-tests)
|
||||
5. [Running tests](#running-tests)
|
||||
|
||||
Maintaining a libc is tough work, and we'd love some help!
|
||||
|
||||
## What to do
|
||||
|
||||
For now, we are still trying to get full libc compatibility before we move on to
|
||||
any optimisation.
|
||||
|
||||
- We currently have a number of unimplemented functions. Search for
|
||||
`unimplemented!()` and hop right in!
|
||||
- If you notice any missing functionality, feel free to add it in
|
||||
|
||||
## Code style
|
||||
|
||||
We have a `rustfmt.toml` in the root directory of relibc. Please run `./fmt.sh`
|
||||
before sending in any merge requests as it will automatically format your code.
|
||||
|
||||
With regards to general style:
|
||||
|
||||
### Where applicable, prefer using references to raw pointers
|
||||
|
||||
This is most obvious when looking at `stdio` functions. If raw pointers were
|
||||
used instead of references, then the resulting code would be significantly
|
||||
uglier. Instead try to check for pointer being valid with `pointer::as_ref()`
|
||||
and `pointer::as_mut()` and then immediately use those references instead.
|
||||
|
||||
Internal functions should always take references.
|
||||
|
||||
### Use the c types exposed in our platform module instead of Rust's inbuilt integer types
|
||||
|
||||
This is so we can guarantee that everything works across platforms. While it is
|
||||
generally accepted these days that an `int` has 32 bits (which matches against
|
||||
an `i32`), some platforms have `int` as having 16 bits, and others have long as
|
||||
being 32 bits instead of 64. If you use the types in platform, then we can
|
||||
guarantee that your code will "just work" should we port relibc to a different
|
||||
architecture.
|
||||
|
||||
### Use our internal functions
|
||||
|
||||
If you need to use a C string, don't reinvent the wheel. We have functions in
|
||||
the platform module that convert C strings to Rust slices.
|
||||
|
||||
We also have structures that wrap files, wrap writable strings, and wrap various
|
||||
other commonly used things that you should use instead of rolling your own.
|
||||
|
||||
## Sending merge requests
|
||||
|
||||
If you have sent us a merge request, first of all, thanks for taking your time
|
||||
to help us!
|
||||
|
||||
The first thing to note is that we do most of our development on our
|
||||
[GitLab server](https://gitlab.redox-os.org/redox-os/relibc), and as such it is
|
||||
possible that none of the maintainers will see your merge request if it is
|
||||
opened on GitHub.
|
||||
|
||||
In your merge request, please put in the description:
|
||||
- What functions (if any) have been implemented or changed
|
||||
- The rationale behind your merge request (e.g. why you thought this change was
|
||||
required. If you are just implementing some functions, you can ignore this)
|
||||
- Any issues that are related to the merge request
|
||||
|
||||
We have CI attached to our GitLab instance, so all merge requests are checked to
|
||||
make sure that they are tested before they are merged. Please write tests for
|
||||
the functions that you add/change and test locally on your own machine
|
||||
***before*** submitting a merge request.
|
||||
|
||||
## Writing tests
|
||||
|
||||
Every function that gets written needs to have a test in C in order to make sure
|
||||
it works as intended. Here are a few guidelines for writing good tests.
|
||||
|
||||
### Ensure that any literals you have are mapped to variables instead of being directly passed to a function.
|
||||
|
||||
Sometimes compilers take literals put into libc functions and run them
|
||||
internally during compilation, which can cause some false positives. All tests
|
||||
are compiled with `-fno-builtin`, which theoretically solves this issue, but
|
||||
just in case, it'd be a good idea to map inputs to variables.
|
||||
|
||||
```c
|
||||
#include "string.h"
|
||||
#include "stdio.h"
|
||||
|
||||
int main(void) {
|
||||
// Don't do this
|
||||
printf("%d\n", strcspn("Hello", "Hi"));
|
||||
|
||||
// Do this
|
||||
char *first = "Hello";
|
||||
char *second = "Hi";
|
||||
printf("%d\n", strcspn(first, second));
|
||||
}
|
||||
```
|
||||
|
||||
### Ensure your tests cover every section of code.
|
||||
|
||||
What happens if a string in `strcmp()` is shorter than the other string? What
|
||||
happens if the first argument to `strcspn()` is longer than the second string?
|
||||
In order to make sure that all functions work as expected, we ask that any tests
|
||||
cover as much of the code that you have written as possible.
|
||||
|
||||
## Running tests
|
||||
|
||||
Running tests is an important part in trying to find bugs. Before opening a
|
||||
merge request, we ask that you test on your own machine to make sure there are
|
||||
no regressions.
|
||||
|
||||
You can run tests with `make test` in the root directory of relibc to compile
|
||||
relibc, compile the tests and run them. This *will* print a lot of output to
|
||||
stdout, so be warned!
|
||||
|
||||
You can test against verified correct output with `make verify` in the tests
|
||||
directory. You will need to manually create the correct output and put it in the
|
||||
tests/expected directory. Running any `make` commands in the tests directory
|
||||
will ***not*** rebuild relibc, so you'll need to go back to the root directory
|
||||
if you need to rebuild relibc.
|
||||
Generated
+370
-443
File diff suppressed because it is too large
Load Diff
+63
-132
@@ -1,151 +1,82 @@
|
||||
[package]
|
||||
name = "relibc"
|
||||
version = "0.6.0+rb0.3.0"
|
||||
name = "userutils"
|
||||
version = "0.1.0+rb0.3.0"
|
||||
authors = ["Jeremy Soller <jackpot51@gmail.com>", "vasilito <adminpupkin@gmail.com>"]
|
||||
edition = "2024"
|
||||
|
||||
[lib]
|
||||
name = "relibc"
|
||||
crate-type = ["staticlib"]
|
||||
[[bin]]
|
||||
name = "id"
|
||||
path = "src/bin/id.rs"
|
||||
|
||||
[workspace]
|
||||
members = [
|
||||
"src/crt0",
|
||||
"src/crti",
|
||||
"src/crtn",
|
||||
"redox-rt",
|
||||
"ld_so",
|
||||
"generic-rt",
|
||||
]
|
||||
exclude = ["tests", "dlmalloc-rs"]
|
||||
[[bin]]
|
||||
name = "getty"
|
||||
path = "src/bin/getty.rs"
|
||||
|
||||
[workspace.lints.clippy]
|
||||
borrow_as_ptr = "deny"
|
||||
cast_lossless = "warn" # TODO review occurrences
|
||||
cast_possible_truncation = "allow" # TODO review occurrences
|
||||
cast_possible_wrap = "allow" # TODO review occurrences
|
||||
cast_precision_loss = "allow" # TODO review occurrences
|
||||
cast_ptr_alignment = "allow" # TODO review occurrences
|
||||
cast_sign_loss = "allow" # TODO review occurrences
|
||||
missing_errors_doc = "allow" # TODO review occurrences
|
||||
missing_panics_doc = "allow" # TODO review occurrences
|
||||
missing_safety_doc = "allow" # TODO review occurrences
|
||||
mut_from_ref = "warn" # TODO review occurrences
|
||||
precedence = "deny"
|
||||
ptr_as_ptr = "warn" # TODO review occurrences
|
||||
ptr_cast_constness = "warn" # TODO review occurrences
|
||||
ref_as_ptr = "warn" # TODO review occurrences
|
||||
upper_case_acronyms = "allow" # TODO review occurrences
|
||||
zero_ptr = "warn" # must allow on public constants due to cbindgen issue
|
||||
[[bin]]
|
||||
name = "groupadd"
|
||||
path = "src/bin/groupadd.rs"
|
||||
|
||||
[workspace.lints.rust]
|
||||
dangling_pointers_from_temporaries = "deny"
|
||||
dead_code = "allow" # TODO review occuurences
|
||||
deprecated = "deny"
|
||||
improper_ctypes_definitions = "deny"
|
||||
internal_features = "allow" # core_intrinsics and lang_items
|
||||
irrefutable_let_patterns = "deny"
|
||||
mismatched_lifetime_syntaxes = "deny"
|
||||
non_camel_case_types = "allow" # needed for most POSIX type names
|
||||
non_snake_case = "allow" # TODO review occuurences
|
||||
non_upper_case_globals = "allow" # TODO review occuurences
|
||||
unexpected_cfgs = "deny"
|
||||
unpredictable_function_pointer_comparisons = "deny"
|
||||
unreachable_code = "allow" # TODO review occuurences
|
||||
unsafe_op_in_unsafe_fn = "deny"
|
||||
unused_imports = "deny"
|
||||
unused_must_use = "deny"
|
||||
unused_mut = "deny"
|
||||
unused_unsafe = "deny"
|
||||
unused_variables = "allow" # TODO review occurrences (too many for now)
|
||||
[[bin]]
|
||||
name = "groupdel"
|
||||
path = "src/bin/groupdel.rs"
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
[[bin]]
|
||||
name = "groupmod"
|
||||
path = "src/bin/groupmod.rs"
|
||||
|
||||
[workspace.dependencies]
|
||||
bitflags = "2"
|
||||
ioslice = { version = "0.6", default-features = false }
|
||||
plain = "0.2"
|
||||
redox-path = "0.3"
|
||||
redox_protocols = { package = "libredox", path = "../libredox", default-features = false, features = ["protocol"] }
|
||||
redox_syscall = { path = "../syscall" }
|
||||
[[bin]]
|
||||
name = "login"
|
||||
path = "src/bin/login.rs"
|
||||
|
||||
[build-dependencies]
|
||||
cc = "1"
|
||||
[[bin]]
|
||||
name = "passwd"
|
||||
path = "src/bin/passwd.rs"
|
||||
|
||||
[[bin]]
|
||||
name = "su"
|
||||
path = "src/bin/su.rs"
|
||||
|
||||
[[bin]]
|
||||
name = "sudo"
|
||||
path = "src/bin/sudo.rs"
|
||||
|
||||
[[bin]]
|
||||
name = "useradd"
|
||||
path = "src/bin/useradd.rs"
|
||||
|
||||
[[bin]]
|
||||
name = "userdel"
|
||||
path = "src/bin/userdel.rs"
|
||||
|
||||
[[bin]]
|
||||
name = "usermod"
|
||||
path = "src/bin/usermod.rs"
|
||||
|
||||
[dependencies]
|
||||
bitflags.workspace = true
|
||||
cbitset = "0.2"
|
||||
posix-regex = { version = "0.1.4", features = ["no_std"] }
|
||||
|
||||
rand = { version = "0.10", default-features = false }
|
||||
rand_xorshift = "0.5"
|
||||
rand_jitter = "0.6"
|
||||
|
||||
memchr = { version = "2.2.0", default-features = false }
|
||||
plain.workspace = true
|
||||
unicode-width = "0.1"
|
||||
__libc_only_for_layout_checks = { package = "libc", version = "0.2.149", optional = true }
|
||||
md5-crypto = { package = "md-5", version = "0.10.6", default-features = false }
|
||||
sha-crypt = { version = "0.5", default-features = false }
|
||||
base64ct = { version = "1.6", default-features = false, features = ["alloc"] }
|
||||
bcrypt-pbkdf = { version = "0.10", default-features = false, features = [
|
||||
"alloc",
|
||||
] }
|
||||
scrypt = { version = "0.11", default-features = false, features = ["simple"] }
|
||||
pbkdf2 = { version = "0.12", features = ["sha2"] }
|
||||
sha2 = { version = "0.10", default-features = false }
|
||||
generic-rt = { path = "generic-rt" }
|
||||
chrono-tz = { version = "0.10", default-features = false }
|
||||
chrono = { version = "0.4", default-features = false, features = ["alloc"] }
|
||||
libm = "0.2"
|
||||
log = "0.4"
|
||||
spin = "0.9.8"
|
||||
argon2 = "0.5.3"
|
||||
|
||||
[dependencies.dlmalloc]
|
||||
path = "dlmalloc-rs"
|
||||
default-features = false
|
||||
features = ["c_api"]
|
||||
|
||||
[dependencies.object]
|
||||
version = "0.36.7"
|
||||
git = "https://gitlab.redox-os.org/andypython/object"
|
||||
default-features = false
|
||||
features = ["elf", "read_core"]
|
||||
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
sc = "0.2.7"
|
||||
clap = "2.33.0"
|
||||
extra = { git = "https://gitlab.redox-os.org/redox-os/libextra.git" }
|
||||
orbclient = "0.3.47"
|
||||
plain = "0.2.3"
|
||||
redox_liner = "0.5.2"
|
||||
libredox = { path = "../libredox", features = ["mkns"] }
|
||||
redox_termios = "0.1.3"
|
||||
redox_event = "0.4.3"
|
||||
redox-scheme = { path = "../redox-scheme" }
|
||||
redox_syscall = { path = "../syscall" }
|
||||
redox_users = "0.4.6"
|
||||
termion = "4"
|
||||
libc = "0.2"
|
||||
serde = { version = "1.0.203", features = ["derive"] }
|
||||
toml = "0.8.11"
|
||||
ioslice = "0.6"
|
||||
|
||||
[target.'cfg(target_os = "redox")'.dependencies]
|
||||
redox_syscall.workspace = true
|
||||
redox-rt = { path = "redox-rt" }
|
||||
redox-path.workspace = true
|
||||
redox_event = { version = "0.4.8", default-features = false, features = [
|
||||
"redox_syscall",
|
||||
] }
|
||||
ioslice.workspace = true
|
||||
redox-ioctl = { path = "redox-ioctl" }
|
||||
redox_protocols.workspace = true
|
||||
|
||||
[features]
|
||||
# to enable trace level, take out this `no_trace`
|
||||
default = ["ld_so_cache", "no_trace"]
|
||||
check_against_libc_crate = ["__libc_only_for_layout_checks"]
|
||||
ld_so_cache = []
|
||||
math_libm = []
|
||||
no_trace = ["log/release_max_level_debug"]
|
||||
# for very verbose activity beyond trace level
|
||||
trace_tls = []
|
||||
|
||||
[profile.dev]
|
||||
panic = "abort"
|
||||
|
||||
[profile.release]
|
||||
panic = "abort"
|
||||
redox-rt = { path = "../relibc/redox-rt", default-features = false }
|
||||
|
||||
[patch.crates-io]
|
||||
cc-11 = { git = "https://github.com/tea/cc-rs", branch = "riscv-abi-arch-fix", package = "cc" }
|
||||
redox_syscall = { path = "../syscall" }
|
||||
libredox = { path = "../libredox" }
|
||||
redox-scheme = { path = "../redox-scheme" }
|
||||
|
||||
[profile.release]
|
||||
lto = true
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
MIT License
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2018 Redox OS
|
||||
Copyright (c) 2016 The Redox developers
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
|
||||
@@ -1,226 +0,0 @@
|
||||
include config.mk
|
||||
|
||||
CARGO?=cargo
|
||||
CARGO_TEST?=$(CARGO)
|
||||
CARGO_COMMON_FLAGS=-Z build-std=core,alloc,compiler_builtins
|
||||
CARGOFLAGS?=$(CARGO_COMMON_FLAGS)
|
||||
CC_WRAPPER?=
|
||||
RUSTCFLAGS?=
|
||||
LINKFLAGS?=-lgcc
|
||||
USE_RUST_LIBM?=
|
||||
TESTBIN?=
|
||||
export OBJCOPY?=objcopy
|
||||
|
||||
export CARGO_TARGET_DIR?=$(shell pwd)/target
|
||||
BUILD?=$(CARGO_TARGET_DIR)/$(TARGET)
|
||||
CARGOFLAGS+=--target=$(TARGET)
|
||||
EXCEPT_MATH=-not -name "math"
|
||||
FEATURE_MATH=
|
||||
ifneq ($(USE_RUST_LIBM),)
|
||||
FEATURE_MATH=--features math_libm
|
||||
EXCEPT_MATH=
|
||||
endif
|
||||
|
||||
TARGET_HEADERS?=$(BUILD)/include
|
||||
export CFLAGS=-I$(TARGET_HEADERS)
|
||||
|
||||
PROFILE?=release
|
||||
|
||||
HEADERS_UNPARSED=$(shell find src/header -mindepth 1 -maxdepth 1 -type d -not -name "_*" $(EXCEPT_MATH) -printf "%f\n")
|
||||
HEADERS_DEPS=$(shell find src/header -type f \( -name "cbindgen.toml" -o -name "*.rs" \))
|
||||
#HEADERS=$(patsubst %,%.h,$(subst _,/,$(HEADERS_UNPARSED)))
|
||||
|
||||
SRC=\
|
||||
Cargo.* \
|
||||
$(shell find src/ redox-rt/src/ ld_so/src/ redox-ioctl/src/ include/ -type f)
|
||||
|
||||
BUILTINS_VERSION=0.1.70
|
||||
|
||||
.PHONY: all clean fmt install install-libs install-headers install-tests libs headers submodules test
|
||||
|
||||
all: | headers libs
|
||||
|
||||
headers: $(HEADERS_DEPS)
|
||||
rm -rf $(TARGET_HEADERS)
|
||||
mkdir -p $(TARGET_HEADERS)
|
||||
cp -r include/* $(TARGET_HEADERS)
|
||||
ifeq ($(USE_RUST_LIBM),)
|
||||
cp "openlibm/include"/*.h $(TARGET_HEADERS)
|
||||
cp "openlibm/src"/*.h $(TARGET_HEADERS)
|
||||
endif
|
||||
@set -e ; \
|
||||
for header in $(HEADERS_UNPARSED); do \
|
||||
if test -f "src/header/$$header/cbindgen.toml"; then \
|
||||
echo -e "\033[0;36;49mWriting Header $$header\033[0m"; \
|
||||
out=`echo "$$header" | sed 's/_/\//g'`; \
|
||||
out="$(TARGET_HEADERS)/$$out.h"; \
|
||||
cat "src/header/$$header/cbindgen.toml" cbindgen.globdefs.toml \
|
||||
| cbindgen "src/header/$$header/mod.rs" --config=/dev/stdin --output "$$out" 2>/dev/null; \
|
||||
fi \
|
||||
done; echo -e "\033[0;36;49mAll headers written\033[0m";
|
||||
|
||||
clean:
|
||||
$(CARGO) clean
|
||||
$(MAKE) -C tests clean
|
||||
rm -rf sysroot
|
||||
|
||||
check:
|
||||
$(CARGO) check
|
||||
|
||||
fmt:
|
||||
./fmt.sh
|
||||
|
||||
install-headers: headers libs
|
||||
mkdir -pv "$(DESTDIR)/include"
|
||||
cp -rv "$(TARGET_HEADERS)"/* "$(DESTDIR)/include"
|
||||
|
||||
libs: \
|
||||
$(BUILD)/$(PROFILE)/libc.a \
|
||||
$(BUILD)/$(PROFILE)/libc.so \
|
||||
$(BUILD)/$(PROFILE)/crt0.o \
|
||||
$(BUILD)/$(PROFILE)/crti.o \
|
||||
$(BUILD)/$(PROFILE)/crtn.o \
|
||||
$(BUILD)/$(PROFILE)/ld.so
|
||||
|
||||
install-libs: headers libs
|
||||
mkdir -pv "$(DESTDIR)/lib"
|
||||
cp -v "$(BUILD)/$(PROFILE)/libc.a" "$(DESTDIR)/lib"
|
||||
cp -v "$(BUILD)/$(PROFILE)/libc.so" "$(DESTDIR)/lib"
|
||||
ln -vnfs libc.so "$(DESTDIR)/lib/libc.so.6"
|
||||
cp -v "$(BUILD)/$(PROFILE)/crt0.o" "$(DESTDIR)/lib"
|
||||
ln -vnfs crt0.o "$(DESTDIR)/lib/crt1.o"
|
||||
cp -v "$(BUILD)/$(PROFILE)/crti.o" "$(DESTDIR)/lib"
|
||||
cp -v "$(BUILD)/$(PROFILE)/crtn.o" "$(DESTDIR)/lib"
|
||||
cp -v "$(BUILD)/$(PROFILE)/ld.so" "$(DESTDIR)/$(LD_SO_PATH)"
|
||||
ifeq ($(USE_RUST_LIBM),)
|
||||
cp -v "$(BUILD)/openlibm/libopenlibm.a" "$(DESTDIR)/lib/libm.a"
|
||||
endif
|
||||
# Empty libraries for dl, pthread, and rt
|
||||
$(AR) -rcs "$(DESTDIR)/lib/libdl.a"
|
||||
$(AR) -rcs "$(DESTDIR)/lib/libpthread.a"
|
||||
$(AR) -rcs "$(DESTDIR)/lib/librt.a"
|
||||
|
||||
install-tests: tests
|
||||
$(MAKE) -C tests
|
||||
mkdir -p "$(DESTDIR)/relibc-tests"
|
||||
cp -vr tests/build_$(TARGET)/* "$(DESTDIR)/relibc-tests/"
|
||||
|
||||
install: install-headers install-libs
|
||||
|
||||
submodules:
|
||||
git submodule sync
|
||||
git submodule update --init --recursive
|
||||
|
||||
sysroot:
|
||||
@mkdir -p $@
|
||||
|
||||
.PHONY: sysroot/$(TARGET)
|
||||
sysroot/$(TARGET): | sysroot
|
||||
rm -rf $@
|
||||
rm -rf $@.partial
|
||||
mkdir -p $@.partial
|
||||
$(MAKE) install DESTDIR=$(shell pwd)/$@.partial
|
||||
mv $@.partial $@
|
||||
touch $@
|
||||
|
||||
test: sysroot/$(TARGET)
|
||||
# TODO: Fix SIGILL when running cargo test
|
||||
# $(CARGO_TEST) test
|
||||
$(MAKE) -C tests run
|
||||
|
||||
test-once: sysroot/$(TARGET)
|
||||
$(MAKE) -C tests run-once TESTBIN=$(TESTBIN)
|
||||
|
||||
|
||||
$(BUILD)/$(PROFILE)/libc.so: $(BUILD)/$(PROFILE)/libc.a
|
||||
$(CC) -nostdlib \
|
||||
-shared \
|
||||
-Wl,--gc-sections \
|
||||
-Wl,-z,pack-relative-relocs \
|
||||
-Wl,--sort-common \
|
||||
-Wl,--whole-archive $^ -Wl,--no-whole-archive \
|
||||
-Wl,-soname,libc.so.6 \
|
||||
$(LINKFLAGS) \
|
||||
-o $@
|
||||
|
||||
$(BUILD)/$(PROFILE)/ld.so: $(BUILD)/$(PROFILE)/ld_so.o $(BUILD)/$(PROFILE)/libc.a
|
||||
# TODO: merge ld.so with libc.so: --dynamic-list=dynamic-list-file
|
||||
$(LD) --shared -Bsymbolic --no-relax -T ld_so/ld_script/$(TARGET).ld --gc-sections $^ -o $@
|
||||
|
||||
$(BUILD)/$(PROFILE)/libc.a: $(BUILD)/$(PROFILE)/librelibc.a $(BUILD)/openlibm/libopenlibm.a
|
||||
echo "create $@" > "$@.mri"
|
||||
for lib in $^; do\
|
||||
echo "addlib $$lib" >> "$@.mri"; \
|
||||
done
|
||||
echo "save" >> "$@.mri"
|
||||
echo "end" >> "$@.mri"
|
||||
$(AR) -M < "$@.mri"
|
||||
|
||||
# Debug targets
|
||||
|
||||
$(BUILD)/debug/librelibc.a: $(SRC)
|
||||
$(CARGO) rustc $(CARGOFLAGS) $(FEATURE_MATH) -- --emit link=$@ -g -C debug-assertions=no $(RUSTCFLAGS)
|
||||
./renamesyms.sh "$@" "$(BUILD)/debug/deps/"
|
||||
./stripcore.sh "$@"
|
||||
touch $@
|
||||
|
||||
$(BUILD)/debug/crt0.o: $(SRC)
|
||||
$(CARGO) rustc --manifest-path src/crt0/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
|
||||
touch $@
|
||||
|
||||
$(BUILD)/debug/crti.o: $(SRC)
|
||||
$(CARGO) rustc --manifest-path src/crti/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
|
||||
touch $@
|
||||
|
||||
$(BUILD)/debug/crtn.o: $(SRC)
|
||||
$(CARGO) rustc --manifest-path src/crtn/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
|
||||
touch $@
|
||||
|
||||
$(BUILD)/debug/ld_so.o: $(SRC)
|
||||
$(CARGO) rustc --manifest-path ld_so/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort -g -C debug-assertions=no $(RUSTCFLAGS)
|
||||
touch $@
|
||||
|
||||
# Release targets
|
||||
|
||||
$(BUILD)/release/librelibc.a: $(SRC)
|
||||
$(CARGO) rustc --release $(CARGOFLAGS) -- --emit link=$@ $(RUSTCFLAGS)
|
||||
@# TODO: Better to only allow a certain whitelisted set of symbols? Perhaps
|
||||
@# use some cbindgen hook, specify them manually, or grep for #[unsafe(no_mangle)].
|
||||
./renamesyms.sh "$@" "$(BUILD)/release/deps/"
|
||||
./stripcore.sh "$@"
|
||||
touch $@
|
||||
|
||||
$(BUILD)/release/crt0.o: $(SRC)
|
||||
$(CARGO) rustc --release --manifest-path src/crt0/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
|
||||
touch $@
|
||||
|
||||
$(BUILD)/release/crti.o: $(SRC)
|
||||
$(CARGO) rustc --release --manifest-path src/crti/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
|
||||
touch $@
|
||||
|
||||
$(BUILD)/release/crtn.o: $(SRC)
|
||||
$(CARGO) rustc --release --manifest-path src/crtn/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
|
||||
touch $@
|
||||
|
||||
$(BUILD)/release/ld_so.o: $(SRC)
|
||||
$(CARGO) rustc --release --manifest-path ld_so/Cargo.toml $(CARGOFLAGS) -- --emit obj=$@ -C panic=abort $(RUSTCFLAGS)
|
||||
touch $@
|
||||
|
||||
# Other targets
|
||||
|
||||
$(BUILD)/openlibm: openlibm
|
||||
rm -rf $@ $@.partial
|
||||
mkdir -p $(BUILD)
|
||||
cp -r $< $@.partial
|
||||
mv $@.partial $@
|
||||
touch $@
|
||||
|
||||
ifeq ($(USE_RUST_LIBM),)
|
||||
$(BUILD)/openlibm/libopenlibm.a: $(BUILD)/openlibm $(BUILD)/$(PROFILE)/librelibc.a
|
||||
$(MAKE) -s AR=$(AR) CC="$(CC_WRAPPER) $(CC)" LD=$(LD) CPPFLAGS="$(CPPFLAGS) -fno-stack-protector -I$(shell pwd)/include -I$(TARGET_HEADERS)" -C $< libopenlibm.a
|
||||
./renamesyms.sh "$@" "$(BUILD)/release/deps/"
|
||||
else
|
||||
$(BUILD)/openlibm/libopenlibm.a:
|
||||
mkdir -p "$(BUILD)/openlibm"
|
||||
$(AR) -rcs "$(BUILD)/openlibm/libopenlibm.a"
|
||||
endif
|
||||
@@ -1,173 +1,24 @@
|
||||
# Redox C Library (relibc)
|
||||
# Redox OS user and group utilities.
|
||||
|
||||
relibc is a portable C standard library written in Rust and is under heavy development, this library contain the following items:
|
||||
The `userutils` crate contains the utilities for dealing with users and groups in Redox OS.
|
||||
They are heavily influenced by UNIX and are, when needed, tailored to specific Redox use cases.
|
||||
|
||||
- C, Linux, BSD functions and extensions
|
||||
- POSIX compatibility layer
|
||||
- Interfaces for system components
|
||||
These implementations strive to be as simple as possible drawing particular
|
||||
inspiration by BSD systems. They are indeed small, by choice.
|
||||
|
||||
The motivation for this project is twofold: Reduce issues that the Redox developers were having with [newlib](https://sourceware.org/newlib/), and create a more stable and safe alternative to C standard libraries written in C. It is mainly designed to be used under Redox, as an alternative to newlib, but it also supports Linux via the [sc](https://crates.io/crates/sc) crate.
|
||||
[](https://travis-ci.org/redox-os/userutils)
|
||||
|
||||
Currently Redox and Linux are supported.
|
||||
**Currently included:**
|
||||
|
||||
## `redox-rt`
|
||||
|
||||
`redox-rt` is a runtime library that provides much of the code that enables POSIX on Redox, like `fork`, `exec`, signal handling, etc.
|
||||
Relibc uses it as backend in `src/platform/redox`, and it's intended to eventually be usable independently, without relibc.
|
||||
|
||||
## Repository Layout
|
||||
|
||||
- `include` - Header files (mostly macros and variadic functions `cbindgen` can't generate)
|
||||
- `src` - Source files
|
||||
- `src/c` - C code
|
||||
- `src/crt0` - Runtime code
|
||||
- `src/crti` - Runtime code
|
||||
- `src/crtn` - Runtime code
|
||||
- `src/header` - Header files implementation
|
||||
- `src/header/*` - Each folder has a `cbindgen.toml` file, it generates a C-to-Rust interface and header files
|
||||
- `src/ld_so` - Dynamic loader code
|
||||
- `src/platform` - Platform-specific and common code
|
||||
- `src/platform/redox` - Redox-specific code
|
||||
- `src/platform/linux` - Linux-specific code
|
||||
- `src/pthread` - pthread implementation
|
||||
- `src/sync` - Synchronization primitives
|
||||
- `tests` - C tests (each MR needs to give success in all of them)
|
||||
|
||||
## Download the sources
|
||||
|
||||
To download the relibc sources run the following command:
|
||||
|
||||
```sh
|
||||
git clone --recursive https://gitlab.redox-os.org/redox-os/relibc
|
||||
```
|
||||
|
||||
## Build Instructions
|
||||
|
||||
To build relibc out of the Redox build system, do the following steps:
|
||||
|
||||
### Dependencies
|
||||
|
||||
- Install `cbindgen`
|
||||
|
||||
```sh
|
||||
cargo install cbindgen
|
||||
```
|
||||
|
||||
#### Install the `expect` tool
|
||||
|
||||
- Debian, Ubuntu and PopOS:
|
||||
|
||||
```sh
|
||||
sudo apt install expect
|
||||
```
|
||||
|
||||
- Fedora:
|
||||
|
||||
```sh
|
||||
sudo dnf install expect
|
||||
```
|
||||
|
||||
- Arch Linux:
|
||||
|
||||
```sh
|
||||
sudo pacman -S expect
|
||||
```
|
||||
|
||||
### Build Relibc
|
||||
|
||||
To build the relibc library objects, run the following command:
|
||||
|
||||
```sh
|
||||
make all
|
||||
```
|
||||
|
||||
- Clean old library objects and tests
|
||||
|
||||
```sh
|
||||
make clean
|
||||
```
|
||||
|
||||
## Build relibc inside the Redox build system
|
||||
|
||||
Inside of your Redox build system, run:
|
||||
|
||||
```sh
|
||||
make prefix
|
||||
```
|
||||
|
||||
If you need to rebuild `relibc` for testing a Cookbook recipe, run:
|
||||
|
||||
```sh
|
||||
touch relibc
|
||||
make prefix r.recipe-name
|
||||
```
|
||||
|
||||
Touching (changing the "last modified time" of) the `relibc` folder is needed to trigger recompilation for `make prefix`. Replace `recipe-name` with your desired recipe name.
|
||||
|
||||
Note: Do not edit `relibc` inside `prefix` folder! Do your work on `relibc` folder directly inside your Redox build system instead.
|
||||
|
||||
## Tests
|
||||
|
||||
Relibc has a test suite that also runs every time a new commit get pushed. You can see `.gitlab-ci.yml` to see how it's being executed. That being said, `./check.sh` is the recommended way to run tests. Here's few examples:
|
||||
|
||||
+ `./check.sh` - Run build, without running the test
|
||||
+ `./check.sh --test` - Run all tests in x86_64 Redox using Redoxer
|
||||
+ `./check.sh --test --host` - Run all tests in host (Linux)
|
||||
+ `./check.sh --test --arch=aarch64` - Run all tests in specified arch
|
||||
- Arch can be `x86_64`, `aarch64`, `i586`, or `riscv64gc`
|
||||
+ `./check.sh --test=stdio/printf` - Run a single test
|
||||
- Can be combined with `--host` or `--arch`
|
||||
- Will run statically linked test in Linux, dynamically linked in Redox
|
||||
|
||||
Couple of notes:
|
||||
|
||||
- Relibc and its tests will rebuild if files changed, however switching between arch or host requires you to run `make clean`
|
||||
- Redoxer is needed to run tests for Redox without `--host`. You can install it using `cargo install redoxer`
|
||||
- Tests can hangs, the test runner can anticipate this, assuming the kernel doesn't hang too.
|
||||
|
||||
## Issues
|
||||
|
||||
#### I'm building for my own platform which I run, and am getting `x86_64-linux-gnu-ar: command not found` (or similar)
|
||||
|
||||
The Makefile expects GNU compiler tools prefixed with the platform specifier, as would be present when you installed a cross compiler. Since you are building for your own platform, some Linux distributions (like Manjaro) don't install/symlink the prefixed executables.
|
||||
|
||||
An easy fix would be to replace the corresponding lines in `config.mk`, e.g.
|
||||
|
||||
```diff
|
||||
ifeq ($(TARGET),x86_64-unknown-linux-gnu)
|
||||
- export CC=x86_64-linux-gnu-gcc
|
||||
- export LD=x86_64-linux-gnu-ld
|
||||
- export AR=x86_64-linux-gnu-ar
|
||||
- export NM=x86_64-linux-gnu-nm
|
||||
+ export CC=gcc
|
||||
+ export LD=ld
|
||||
+ export AR=ar
|
||||
+ export NM=nm
|
||||
export OBJCOPY=objcopy
|
||||
export CPPFLAGS=
|
||||
LD_SO_PATH=lib/ld64.so.1
|
||||
endif
|
||||
```
|
||||
|
||||
## Contributing
|
||||
|
||||
Before starting to contribute, read [this](CONTRIBUTING.md) document.
|
||||
|
||||
## Supported OSes
|
||||
|
||||
- Redox OS
|
||||
- Linux
|
||||
|
||||
## Supported architectures
|
||||
|
||||
- i586 (Intel/AMD)
|
||||
- x86_64 (Intel/AMD)
|
||||
- aarch64 (ARM64)
|
||||
- riscv64gc (RISC-V)
|
||||
|
||||
## Funding - _Unix-style Signals and Process Management_
|
||||
|
||||
This project is funded through [NGI Zero Core](https://nlnet.nl/core), a fund established by [NLnet](https://nlnet.nl) with financial support from the European Commission's [Next Generation Internet](https://ngi.eu) program. Learn more at the [NLnet project page](https://nlnet.nl/project/RedoxOS-Signals).
|
||||
|
||||
[<img src="https://nlnet.nl/logo/banner.png" alt="NLnet foundation logo" width="20%" />](https://nlnet.nl)
|
||||
[<img src="https://nlnet.nl/image/logos/NGI0_tag.svg" alt="NGI Zero Logo" width="20%" />](https://nlnet.nl/core)
|
||||
- `getty`: Used by `init(8)` to open and initialize the TTY line, read a login name and invoke `login(1)`.
|
||||
- `id`: Displays user identity.
|
||||
- `login`: Allows users to login into the system
|
||||
- `passwd`: Allows users to modify their passwords.
|
||||
- `su`: Allows users to substitute identity.
|
||||
- `sudo`: Enables users to execute a command as another user.
|
||||
- `useradd`: Add a user
|
||||
- `usermod`: Modify user information
|
||||
- `userdel`: Delete a user
|
||||
- `groupadd`: Add a user group
|
||||
- `groupmod`: Modify group information
|
||||
- `groupdel`: Remove a user group
|
||||
|
||||
@@ -1,62 +0,0 @@
|
||||
extern crate cc;
|
||||
|
||||
use std::{env, fs};
|
||||
|
||||
fn main() {
|
||||
let _crate_dir = env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set");
|
||||
let target = env::var("TARGET").unwrap();
|
||||
|
||||
println!("cargo:rerun-if-changed=src/c");
|
||||
|
||||
// The Redoxer toolchain and some upstream nightlies keep the older
|
||||
// `VaList<'a>` ABI for `extern "C" fn(...)` parameters, while others
|
||||
// pass `VaListImpl<'f>` and require `.as_va_list()` to obtain
|
||||
// `VaList<'_, '_>`. This is a host-compiler property, so probe
|
||||
// directly with the host rustc (avoiding autocfg's target probing).
|
||||
println!("cargo:rustc-check-cfg=cfg(relibc_valist_impl)");
|
||||
let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".to_string());
|
||||
let out_dir = env::var("OUT_DIR").unwrap_or_else(|_| "/tmp".to_string());
|
||||
let probe_file = std::path::Path::new(&out_dir).join("relibc_valist_probe.rs");
|
||||
let probe_out = std::path::Path::new(&out_dir).join("librelibc_valist_probe.rlib");
|
||||
std::fs::write(
|
||||
&probe_file,
|
||||
"#![feature(c_variadic)] pub fn _relibc_valist_probe(_: core::ffi::VaList<'_, '_>) {}",
|
||||
)
|
||||
.ok();
|
||||
let probe_ok = std::process::Command::new(&rustc)
|
||||
.args([
|
||||
"--crate-type",
|
||||
"lib",
|
||||
"--edition",
|
||||
"2024",
|
||||
probe_file.to_str().unwrap(),
|
||||
"-o",
|
||||
probe_out.to_str().unwrap(),
|
||||
])
|
||||
.status()
|
||||
.ok()
|
||||
.map_or(false, |s| s.success());
|
||||
if probe_ok {
|
||||
println!("cargo:rustc-cfg=relibc_valist_impl");
|
||||
}
|
||||
|
||||
let mut cc_builder = &mut cc::Build::new();
|
||||
|
||||
cc_builder = cc_builder.flag("-nostdinc").flag("-nostdlib");
|
||||
|
||||
if target.starts_with("aarch64") {
|
||||
cc_builder = cc_builder.flag("-mno-outline-atomics")
|
||||
}
|
||||
|
||||
cc_builder
|
||||
.flag("-fno-stack-protector")
|
||||
.flag("-Wno-expansion-to-defined")
|
||||
.files(
|
||||
fs::read_dir("src/c")
|
||||
.expect("src/c directory missing")
|
||||
.map(|res| res.expect("read_dir error").path()),
|
||||
)
|
||||
.compile("relibc_c");
|
||||
|
||||
println!("cargo:rustc-link-lib=static=relibc_c");
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
|
||||
# needs a leading newline
|
||||
[defines]
|
||||
"target_os=redox" = "__redox__"
|
||||
"target_os=linux" = "__linux__"
|
||||
"target_pointer_width=64" = "__LP64__"
|
||||
"target_pointer_width=32" = "__ILP32__"
|
||||
"target_arch=x86" = "__i386__"
|
||||
"target_arch=x86_64" = "__x86_64__"
|
||||
"target_arch=aarch64" = "__aarch64__"
|
||||
# This is not exact. It should be `defined(__riscv) && defined(__LP64__)`, or `defined(__riscv) && __riscv_xlen==64`
|
||||
# This will do however, as long as we only support riscv64 and not riscv32
|
||||
"target_arch=riscv64" = "__riscv"
|
||||
|
||||
# XXX: silences a warning
|
||||
"feature = no_std" = "__relibc__"
|
||||
|
||||
# Ensure attributes are passed down from Rust
|
||||
# <features.h> must be included where attributes are used in relibc
|
||||
[fn]
|
||||
must_use = "__nodiscard"
|
||||
deprecated = "__deprecated"
|
||||
deprecated_with_note = "__deprecatedNote({})"
|
||||
no_return = "__noreturn"
|
||||
@@ -1,168 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
RED='\033[1;38;5;196m'
|
||||
GREEN='\033[1;38;5;46m'
|
||||
NC='\033[0m'
|
||||
|
||||
show_help() {
|
||||
echo "Usage: $(basename "$0") [OPTIONS]"
|
||||
echo ""
|
||||
echo "Description:"
|
||||
echo " Wrapper for Makefile / Cargo to run checks or tests on Redox OS targets."
|
||||
echo ""
|
||||
echo "Options:"
|
||||
echo " --test Run 'make test' instead of 'make all'"
|
||||
echo " --test= Run single 'make test'"
|
||||
echo " --cargo Run 'cargo check' / 'cargo test' instead"
|
||||
echo " (note: cargo test is currently not maintained for relibc)"
|
||||
echo " --host Run the command on host (linux) target"
|
||||
echo " --all-target Run the command on all supported Redox architectures"
|
||||
echo " --target=<target> Override the target architecture (e.g., i586-unknown-redox)"
|
||||
echo " --arch=<arch> Override the target architecture using arch (e.g., i586)"
|
||||
echo " --help Show this help message"
|
||||
echo ""
|
||||
echo "Supported Targets:"
|
||||
for t in "${SUPPORTED_TARGETS[@]}"; do
|
||||
echo " - $t"
|
||||
done
|
||||
echo " - $(uname -m)-unknown-linux-gnu"
|
||||
echo ""
|
||||
echo "Environment:"
|
||||
echo " TARGET Sets the default target (overridden by --target)"
|
||||
}
|
||||
|
||||
if ! command -v cbindgen &> /dev/null; then
|
||||
echo "Error: 'cbindgen' CLI not found."
|
||||
echo "Please install it: cargo install cbindgen"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
SUPPORTED_TARGETS=(
|
||||
"x86_64-unknown-redox"
|
||||
"i586-unknown-redox"
|
||||
"aarch64-unknown-redox"
|
||||
"riscv64gc-unknown-redox"
|
||||
)
|
||||
|
||||
CURRENT_TARGET="${TARGET:-x86_64-unknown-redox}"
|
||||
CHECK_ALL=false
|
||||
CMD_ACTION="make"
|
||||
CARGO_ACTION="check"
|
||||
MAKE_ACTION="all"
|
||||
TEST_BIN=""
|
||||
IS_HOST=0
|
||||
|
||||
while [[ $# -gt 0 ]]; do
|
||||
case "$1" in
|
||||
--all-target)
|
||||
CHECK_ALL=true
|
||||
;;
|
||||
--test)
|
||||
MAKE_ACTION="test"
|
||||
CARGO_ACTION="test"
|
||||
;;
|
||||
--test=*)
|
||||
TEST_BIN="${1#*=}"
|
||||
MAKE_ACTION="test-once"
|
||||
;;
|
||||
--cargo)
|
||||
CMD_ACTION="cargo"
|
||||
;;
|
||||
--host)
|
||||
CURRENT_TARGET="$(uname -m)-unknown-linux-gnu"
|
||||
IS_HOST=1
|
||||
;;
|
||||
--target=*)
|
||||
CURRENT_TARGET="${1#*=}"
|
||||
;;
|
||||
--arch=*)
|
||||
CURRENT_TARGET="${1#*=}-unknown-redox"
|
||||
;;
|
||||
--help)
|
||||
show_help
|
||||
exit 0
|
||||
;;
|
||||
*)
|
||||
echo -e "${RED}Error: Unknown option '$1'${NC}"
|
||||
show_help
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
shift
|
||||
done
|
||||
|
||||
if [ "$IS_HOST" -eq 0 ]; then
|
||||
if ! command -v redoxer &> /dev/null; then
|
||||
echo "Error: 'redoxer' CLI not found."
|
||||
echo "Please install it: cargo install redoxer"
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
run_redoxer() {
|
||||
export TARGET=$1
|
||||
REDOXER_ENV="redoxer env"
|
||||
if [ "$IS_HOST" -eq 0 ]; then
|
||||
redoxer toolchain || { echo -e "${RED}Fail: redoxer toolchain for: $target.${NC}" && exit 1; }
|
||||
export CARGO_TEST="redoxer"
|
||||
export TEST_RUNNER="redoxer exec --folder ../../sysroot/$TARGET/:/usr --folder . --"
|
||||
# TODO: Identify hang issue with pthread/barrier and pthread/once tests in multi core to get rid of this limit
|
||||
export REDOXER_QEMU_ARGS="-smp 1"
|
||||
|
||||
MAKE_ACTION="$MAKE_ACTION IS_REDOX=1"
|
||||
else
|
||||
REDOXER_ENV=""
|
||||
fi
|
||||
|
||||
if [ "$TEST_BIN" != "" ]; then
|
||||
if [ "$IS_HOST" -eq 0 ]; then
|
||||
MAKE_ACTION="$MAKE_ACTION TESTBIN=bins_dynamic/$TEST_BIN"
|
||||
else
|
||||
MAKE_ACTION="$MAKE_ACTION TESTBIN=bins_static/$TEST_BIN"
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ "$CMD_ACTION" == "make" ]; then
|
||||
CMD_OPT="-j $(nproc) $MAKE_ACTION"
|
||||
else
|
||||
CMD_OPT="$CARGO_ACTION"
|
||||
fi
|
||||
|
||||
echo "----------------------------------------"
|
||||
echo "Running $REDOXER_ENV $CMD_ACTION $CMD_OPT for: $TARGET"
|
||||
|
||||
if $REDOXER_ENV $CMD_ACTION $CMD_OPT; then
|
||||
return 0
|
||||
else
|
||||
echo -e "${RED}Fail: $CMD_ACTION $CMD_OPT for $TARGET failed.${NC}"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
if [ "$CHECK_ALL" = true ]; then
|
||||
echo "Running $CMD_ACTION for all supported Redox targets..."
|
||||
|
||||
has_error=false
|
||||
|
||||
for target in "${SUPPORTED_TARGETS[@]}"; do
|
||||
if ! run_redoxer "$target"; then
|
||||
has_error=true
|
||||
fi
|
||||
done
|
||||
|
||||
echo "----------------------------------------"
|
||||
if [ "$has_error" = true ]; then
|
||||
echo -e "${RED}Summary: One or more targets failed.${NC}"
|
||||
exit 1
|
||||
else
|
||||
echo -e "${GREEN}Summary: All targets passed!${NC}"
|
||||
exit 0
|
||||
fi
|
||||
else
|
||||
if run_redoxer "$CURRENT_TARGET"; then
|
||||
echo -e "${GREEN}Success: $CARGO_ACTION for $CURRENT_TARGET passed.${NC}"
|
||||
exit 0
|
||||
else
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
@@ -1,73 +0,0 @@
|
||||
ifndef TARGET
|
||||
export TARGET:=$(shell rustc -Z unstable-options --print target-spec-json | grep llvm-target | cut -d '"' -f4)
|
||||
endif
|
||||
|
||||
ifeq ($(TARGET),aarch64-unknown-linux-gnu)
|
||||
export CC=aarch64-linux-gnu-gcc
|
||||
export LD=aarch64-linux-gnu-ld
|
||||
export AR=aarch64-linux-gnu-ar
|
||||
export NM=aarch64-linux-gnu-nm
|
||||
export OBJCOPY=aarch64-linux-gnu-objcopy
|
||||
export CPPFLAGS=
|
||||
LD_SO_PATH=lib/ld.so.1
|
||||
endif
|
||||
|
||||
ifeq ($(TARGET),aarch64-unknown-redox)
|
||||
export CC=aarch64-unknown-redox-gcc
|
||||
export LD=aarch64-unknown-redox-ld
|
||||
export AR=aarch64-unknown-redox-ar
|
||||
export NM=aarch64-unknown-redox-nm
|
||||
export OBJCOPY=aarch64-unknown-redox-objcopy
|
||||
export CPPFLAGS=
|
||||
LD_SO_PATH=lib/ld.so.1
|
||||
endif
|
||||
|
||||
ifeq ($(TARGET),i586-unknown-redox)
|
||||
export CC=i586-unknown-redox-gcc
|
||||
export LD=i586-unknown-redox-ld
|
||||
export AR=i586-unknown-redox-ar
|
||||
export NM=i586-unknown-redox-nm
|
||||
export OBJCOPY=i586-unknown-redox-objcopy
|
||||
export CPPFLAGS=
|
||||
LD_SO_PATH=lib/libc.so.1
|
||||
endif
|
||||
|
||||
ifeq ($(TARGET),i686-unknown-redox)
|
||||
export CC=i686-unknown-redox-gcc
|
||||
export LD=i686-unknown-redox-ld
|
||||
export AR=i686-unknown-redox-ar
|
||||
export NM=i686-unknown-redox-nm
|
||||
export OBJCOPY=i686-unknown-redox-objcopy
|
||||
export CPPFLAGS=
|
||||
LD_SO_PATH=lib/libc.so.1
|
||||
endif
|
||||
|
||||
ifeq ($(TARGET),x86_64-unknown-linux-gnu)
|
||||
export CC=x86_64-linux-gnu-gcc
|
||||
export LD=x86_64-linux-gnu-ld
|
||||
export AR=x86_64-linux-gnu-ar
|
||||
export NM=x86_64-linux-gnu-nm
|
||||
export OBJCOPY=objcopy
|
||||
export CPPFLAGS=
|
||||
LD_SO_PATH=lib/ld64.so.1
|
||||
endif
|
||||
|
||||
ifeq ($(TARGET),x86_64-unknown-redox)
|
||||
export CC=x86_64-unknown-redox-gcc
|
||||
export LD=x86_64-unknown-redox-ld
|
||||
export AR=x86_64-unknown-redox-ar
|
||||
export NM=x86_64-unknown-redox-nm
|
||||
export OBJCOPY=x86_64-unknown-redox-objcopy
|
||||
export CPPFLAGS=
|
||||
LD_SO_PATH=lib/ld64.so.1
|
||||
endif
|
||||
|
||||
ifeq ($(TARGET),riscv64gc-unknown-redox)
|
||||
export CC=riscv64-unknown-redox-gcc
|
||||
export LD=riscv64-unknown-redox-ld
|
||||
export AR=riscv64-unknown-redox-ar
|
||||
export NM=riscv64-unknown-redox-nm
|
||||
export OBJCOPY=riscv64-unknown-redox-objcopy
|
||||
export CPPFLAGS=-march=rv64gc -mabi=lp64d
|
||||
LD_SO_PATH=lib/ld.so.1
|
||||
endif
|
||||
-117
@@ -1,117 +0,0 @@
|
||||
name: CI
|
||||
on: [push, pull_request]
|
||||
|
||||
jobs:
|
||||
test:
|
||||
name: Test
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
matrix:
|
||||
include:
|
||||
- os: ubuntu-latest
|
||||
rust: stable
|
||||
- os: ubuntu-latest
|
||||
rust: beta
|
||||
- os: ubuntu-latest
|
||||
rust: nightly
|
||||
- os: macos-latest
|
||||
rust: stable
|
||||
- os: windows-latest
|
||||
rust: stable
|
||||
- os: ubuntu-latest
|
||||
rust: stable
|
||||
target: wasm32-wasip1
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- run: rustup update ${{ matrix.rust }} --no-self-update && rustup default ${{ matrix.rust }}
|
||||
shell: bash
|
||||
|
||||
# Configure cross-builds by adding the rustup target and configuring future
|
||||
# cargo invocations.
|
||||
- run: |
|
||||
rustup target add ${{ matrix.target }}
|
||||
echo CARGO_BUILD_TARGET=${{ matrix.target }} >> $GITHUB_ENV
|
||||
if: matrix.target != ''
|
||||
|
||||
# For wasm install wasmtime as a test runner and configure it with Cargo.
|
||||
- name: Setup `wasmtime`
|
||||
uses: bytecodealliance/actions/wasmtime/setup@v1
|
||||
if: matrix.target == 'wasm32-wasip1'
|
||||
- run: echo CARGO_TARGET_WASM32_WASIP1_RUNNER=wasmtime >> $GITHUB_ENV
|
||||
if: matrix.target == 'wasm32-wasip1'
|
||||
|
||||
- run: cargo test
|
||||
- run: cargo test --features debug
|
||||
- run: cargo test --features global
|
||||
- run: cargo test --release
|
||||
env:
|
||||
CARGO_PROFILE_RELEASE_DEBUG_ASSERTIONS: true
|
||||
- run: cargo test --release
|
||||
env:
|
||||
CARGO_PROFILE_RELEASE_DEBUG_ASSERTIONS: false
|
||||
- run: cargo test --features debug --release
|
||||
env:
|
||||
CARGO_PROFILE_RELEASE_DEBUG_ASSERTIONS: true
|
||||
- run: RUSTFLAGS='--cfg test_lots' cargo test --release
|
||||
shell: bash
|
||||
env:
|
||||
CARGO_PROFILE_RELEASE_DEBUG_ASSERTIONS: true
|
||||
- run: RUSTFLAGS='--cfg test_lots' cargo test --release --features debug
|
||||
shell: bash
|
||||
env:
|
||||
CARGO_PROFILE_RELEASE_DEBUG_ASSERTIONS: true
|
||||
|
||||
rustfmt:
|
||||
name: Rustfmt
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install Rust
|
||||
run: rustup update stable && rustup default stable && rustup component add rustfmt
|
||||
- run: cargo fmt -- --check
|
||||
|
||||
wasm:
|
||||
name: WebAssembly
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install Rust
|
||||
run: rustup update stable && rustup default stable && rustup target add wasm32-unknown-unknown
|
||||
- run: cargo build --target wasm32-unknown-unknown
|
||||
- run: cargo build --target wasm32-unknown-unknown --release
|
||||
|
||||
external-platform:
|
||||
name: external-platform
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install Rust
|
||||
run: rustup update stable && rustup default stable && rustup target add x86_64-fortanix-unknown-sgx
|
||||
- run: cargo build --target x86_64-fortanix-unknown-sgx
|
||||
|
||||
fuzz:
|
||||
name: Build Fuzzers
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install Rust
|
||||
run: rustup update nightly && rustup default nightly
|
||||
- run: cargo install cargo-fuzz
|
||||
- run: cargo fuzz build --dev
|
||||
|
||||
miri:
|
||||
name: Miri
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Install Miri
|
||||
run: |
|
||||
rustup toolchain install nightly --component miri
|
||||
rustup override set nightly
|
||||
cargo miri setup
|
||||
- name: Test with Miri Stack Borrows
|
||||
run: cargo miri test
|
||||
- name: Test with Miri Tree Borrows
|
||||
run: cargo miri test
|
||||
env:
|
||||
MIRIFLAGS: -Zmiri-tree-borrows
|
||||
@@ -1,3 +0,0 @@
|
||||
/target/
|
||||
**/*.rs.bk
|
||||
Cargo.lock
|
||||
@@ -1,70 +0,0 @@
|
||||
[package]
|
||||
name = "dlmalloc"
|
||||
version = "0.2.8"
|
||||
authors = ["Alex Crichton <alex@alexcrichton.com>"]
|
||||
license = "MIT/Apache-2.0"
|
||||
readme = "README.md"
|
||||
repository = "https://github.com/alexcrichton/dlmalloc-rs"
|
||||
homepage = "https://github.com/alexcrichton/dlmalloc-rs"
|
||||
documentation = "https://docs.rs/dlmalloc"
|
||||
description = """
|
||||
A Rust port of the dlmalloc allocator
|
||||
"""
|
||||
edition.workspace = true
|
||||
|
||||
[workspace]
|
||||
members = ['fuzz']
|
||||
|
||||
[workspace.package]
|
||||
edition = '2021'
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
features = ['global']
|
||||
|
||||
[lib]
|
||||
doctest = false
|
||||
|
||||
[target.'cfg(all(unix, not(target_arch = "wasm32")))'.dependencies]
|
||||
libc = { version = "0.2", default-features = false, optional = true }
|
||||
|
||||
[dependencies]
|
||||
# For more information on these dependencies see rust-lang/rust's
|
||||
# `src/tools/rustc-std-workspace` folder
|
||||
core = { version = '1.0.0', optional = true, package = 'rustc-std-workspace-core' }
|
||||
compiler_builtins = { version = '0.1.0', optional = true }
|
||||
cfg-if = "1.0"
|
||||
|
||||
[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
|
||||
version = ">=0.52.0, <=0.59.*"
|
||||
features = [
|
||||
"Win32_Foundation",
|
||||
"Win32_System_Memory",
|
||||
"Win32_System_Threading",
|
||||
"Win32_System_SystemInformation",
|
||||
]
|
||||
|
||||
[dev-dependencies]
|
||||
arbitrary = "1.3.2"
|
||||
rand = { version = "0.8", features = ['small_rng'] }
|
||||
|
||||
[profile.release]
|
||||
debug-assertions = true
|
||||
|
||||
[features]
|
||||
# Enable implementations of the `GlobalAlloc` standard library API, exporting a
|
||||
# new `GlobalDlmalloc` as well which implements this trait.
|
||||
global = ["system", "rust_api"]
|
||||
|
||||
# Enable very expensive debug checks in this crate
|
||||
debug = []
|
||||
|
||||
# Enables OS APIs based on the current target, can be implemented manually
|
||||
# otherwise.
|
||||
system = ["libc"]
|
||||
|
||||
rustc-dep-of-std = ['core', 'compiler_builtins/rustc-dep-of-std']
|
||||
|
||||
c_api = []
|
||||
rust_api = []
|
||||
|
||||
default = ["global", "rust_api"]
|
||||
@@ -1,201 +0,0 @@
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
@@ -1,25 +0,0 @@
|
||||
Copyright (c) 2014 Alex Crichton
|
||||
|
||||
Permission is hereby granted, free of charge, to any
|
||||
person obtaining a copy of this software and associated
|
||||
documentation files (the "Software"), to deal in the
|
||||
Software without restriction, including without
|
||||
limitation the rights to use, copy, modify, merge,
|
||||
publish, distribute, sublicense, and/or sell copies of
|
||||
the Software, and to permit persons to whom the Software
|
||||
is furnished to do so, subject to the following
|
||||
conditions:
|
||||
|
||||
The above copyright notice and this permission notice
|
||||
shall be included in all copies or substantial portions
|
||||
of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
DEALINGS IN THE SOFTWARE.
|
||||
@@ -1,40 +0,0 @@
|
||||
# dlmalloc-rs
|
||||
|
||||
A port of [dlmalloc] to Rust.
|
||||
|
||||
[Documentation](https://docs.rs/dlmalloc)
|
||||
|
||||
[dlmalloc]: https://gee.cs.oswego.edu/dl/html/malloc.html
|
||||
|
||||
## Why dlmalloc?
|
||||
|
||||
This crate is a port of [dlmalloc] to Rust, and doesn't rely on C. The primary
|
||||
purpose of this crate is to serve as the default allocator for Rust on the
|
||||
`wasm32-unknown-unknown` target. At the time this was written the wasm target
|
||||
didn't support C code, so it was required to have a Rust-only solution.
|
||||
|
||||
This allocator is not the most performant by a longshot. It is primarily, I
|
||||
think, intended for being easy to port and easy to learn. I didn't dive too deep
|
||||
into the implementation when writing it, it's just a straight port of the C
|
||||
version.
|
||||
|
||||
It's unlikely that Rust code needs to worry/interact with this allocator in
|
||||
general. Most of the time you'll be manually switching to a different allocator
|
||||
:)
|
||||
|
||||
# License
|
||||
|
||||
This project is licensed under either of
|
||||
|
||||
* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
|
||||
http://www.apache.org/licenses/LICENSE-2.0)
|
||||
* MIT license ([LICENSE-MIT](LICENSE-MIT) or
|
||||
http://opensource.org/licenses/MIT)
|
||||
|
||||
at your option.
|
||||
|
||||
### Contribution
|
||||
|
||||
Unless you explicitly state otherwise, any contribution intentionally submitted
|
||||
for inclusion in this project by you, as defined in the Apache-2.0 license,
|
||||
shall be dual licensed as above, without any additional terms or conditions.
|
||||
@@ -1,2 +0,0 @@
|
||||
corpus
|
||||
artifacts
|
||||
@@ -1,19 +0,0 @@
|
||||
[package]
|
||||
name = "dlmalloc-fuzz"
|
||||
version = "0.0.1"
|
||||
publish = false
|
||||
edition.workspace = true
|
||||
|
||||
[package.metadata]
|
||||
cargo-fuzz = true
|
||||
|
||||
[dependencies]
|
||||
arbitrary = "1.3.2"
|
||||
dlmalloc = { path = '..' }
|
||||
libfuzzer-sys = "0.4.7"
|
||||
|
||||
[[bin]]
|
||||
name = "alloc"
|
||||
path = "fuzz_targets/alloc.rs"
|
||||
test = false
|
||||
bench = false
|
||||
@@ -1,8 +0,0 @@
|
||||
#![no_main]
|
||||
|
||||
use arbitrary::Unstructured;
|
||||
use libfuzzer_sys::fuzz_target;
|
||||
|
||||
fuzz_target!(|bytes: &[u8]| {
|
||||
let _ = dlmalloc_fuzz::run(&mut Unstructured::new(bytes));
|
||||
});
|
||||
@@ -1,108 +0,0 @@
|
||||
use arbitrary::{Result, Unstructured};
|
||||
use dlmalloc::Dlmalloc;
|
||||
use std::cmp;
|
||||
|
||||
const MAX_ALLOCATED: usize = 100 << 20; // 100 MB
|
||||
|
||||
pub fn run(u: &mut Unstructured<'_>) -> Result<()> {
|
||||
let mut a = Dlmalloc::new();
|
||||
let mut ptrs = Vec::new();
|
||||
let mut allocated = 0;
|
||||
unsafe {
|
||||
while u.arbitrary()? {
|
||||
// If there are pointers to free then have a chance of deallocating
|
||||
// a pointer. Try not to deallocate things until there's a "large"
|
||||
// working set but afterwards give it a 50/50 chance of allocating
|
||||
// or deallocating.
|
||||
let free = match ptrs.len() {
|
||||
0 => false,
|
||||
0..=10_000 => u.ratio(1, 3)?,
|
||||
_ => u.arbitrary()?,
|
||||
};
|
||||
if free {
|
||||
let idx = u.choose_index(ptrs.len())?;
|
||||
let (ptr, size, align) = ptrs.swap_remove(idx);
|
||||
allocated -= size;
|
||||
a.free(ptr, size, align);
|
||||
continue;
|
||||
}
|
||||
|
||||
// 1/100 chance of reallocating a pointer to a different size.
|
||||
if ptrs.len() > 0 && u.ratio(1, 100)? {
|
||||
let idx = u.choose_index(ptrs.len())?;
|
||||
let (ptr, size, align) = ptrs.swap_remove(idx);
|
||||
|
||||
// Arbitrarily choose whether to make this allocation either
|
||||
// twice as large or half as small.
|
||||
let new_size = if u.arbitrary()? {
|
||||
u.int_in_range(size..=size * 2)?
|
||||
} else if size > 10 {
|
||||
u.int_in_range(size / 2..=size)?
|
||||
} else {
|
||||
continue;
|
||||
};
|
||||
if allocated + new_size - size > MAX_ALLOCATED {
|
||||
ptrs.push((ptr, size, align));
|
||||
continue;
|
||||
}
|
||||
allocated -= size;
|
||||
allocated += new_size;
|
||||
|
||||
// Perform the `realloc` and assert that all bytes were copied.
|
||||
let mut tmp = Vec::new();
|
||||
for i in 0..cmp::min(size, new_size) {
|
||||
tmp.push(*ptr.offset(i as isize));
|
||||
}
|
||||
let ptr = a.realloc(ptr, size, align, new_size);
|
||||
assert!(!ptr.is_null());
|
||||
for (i, byte) in tmp.iter().enumerate() {
|
||||
assert_eq!(*byte, *ptr.offset(i as isize));
|
||||
}
|
||||
ptrs.push((ptr, new_size, align));
|
||||
}
|
||||
|
||||
// Aribtrarily choose a size to allocate as well as an alignment.
|
||||
// Enable small sizes with standard alignment happening a fair bit.
|
||||
let size = if u.arbitrary()? {
|
||||
u.int_in_range(1..=128)?
|
||||
} else {
|
||||
u.int_in_range(1..=128 * 1024)?
|
||||
};
|
||||
let align = if u.ratio(1, 10)? {
|
||||
1 << u.int_in_range(3..=8)?
|
||||
} else {
|
||||
8
|
||||
};
|
||||
|
||||
if size + allocated > MAX_ALLOCATED {
|
||||
continue;
|
||||
}
|
||||
allocated += size;
|
||||
|
||||
// Choose arbitrarily between a zero-allocated chunk and a normal
|
||||
// allocated chunk.
|
||||
let zero = u.ratio(1, 50)?;
|
||||
let ptr = if zero {
|
||||
a.calloc(size, align)
|
||||
} else {
|
||||
a.malloc(size, align)
|
||||
};
|
||||
for i in 0..size {
|
||||
if zero {
|
||||
assert_eq!(*ptr.offset(i as isize), 0);
|
||||
}
|
||||
*ptr.offset(i as isize) = 0xce;
|
||||
}
|
||||
ptrs.push((ptr, size, align));
|
||||
}
|
||||
|
||||
// Deallocate everythign when we're done.
|
||||
for (ptr, size, align) in ptrs {
|
||||
a.free(ptr, size, align);
|
||||
}
|
||||
|
||||
a.destroy();
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,42 +0,0 @@
|
||||
use crate::Allocator;
|
||||
use core::ptr;
|
||||
|
||||
pub struct System {
|
||||
_priv: (),
|
||||
}
|
||||
|
||||
impl System {
|
||||
pub const fn new() -> System {
|
||||
System { _priv: () }
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl Allocator for System {
|
||||
fn alloc(&self, _size: usize) -> (*mut u8, usize, u32) {
|
||||
(ptr::null_mut(), 0, 0)
|
||||
}
|
||||
|
||||
fn remap(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize, _can_move: bool) -> *mut u8 {
|
||||
ptr::null_mut()
|
||||
}
|
||||
|
||||
fn free_part(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn free(&self, _ptr: *mut u8, _size: usize) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn can_release_part(&self, _flags: u32) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn allocates_zeros(&self) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn page_size(&self) -> usize {
|
||||
1
|
||||
}
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
use crate::Dlmalloc;
|
||||
use core::alloc::{GlobalAlloc, Layout};
|
||||
use core::ptr;
|
||||
|
||||
pub use crate::sys::enable_alloc_after_fork;
|
||||
|
||||
/// An instance of a "global allocator" backed by `Dlmalloc`
|
||||
///
|
||||
/// This API requires the `global` feature is activated, and this type
|
||||
/// implements the `GlobalAlloc` trait in the standard library.
|
||||
pub struct GlobalDlmalloc;
|
||||
|
||||
static mut DLMALLOC: Dlmalloc = Dlmalloc::new();
|
||||
|
||||
unsafe impl GlobalAlloc for GlobalDlmalloc {
|
||||
#[inline]
|
||||
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
|
||||
let _guard = lock();
|
||||
let dlmalloc = ptr::addr_of_mut!(DLMALLOC);
|
||||
(*dlmalloc).malloc(layout.size(), layout.align())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
|
||||
let _guard = lock();
|
||||
let dlmalloc = ptr::addr_of_mut!(DLMALLOC);
|
||||
(*dlmalloc).free(ptr, layout.size(), layout.align())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
|
||||
let _guard = lock();
|
||||
let dlmalloc = ptr::addr_of_mut!(DLMALLOC);
|
||||
(*dlmalloc).calloc(layout.size(), layout.align())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
|
||||
let _guard = lock();
|
||||
let dlmalloc = ptr::addr_of_mut!(DLMALLOC);
|
||||
(*dlmalloc).realloc(ptr, layout.size(), layout.align(), new_size)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn lock() -> impl Drop {
|
||||
crate::sys::acquire_global_lock();
|
||||
|
||||
struct Guard;
|
||||
impl Drop for Guard {
|
||||
fn drop(&mut self) {
|
||||
crate::sys::release_global_lock()
|
||||
}
|
||||
}
|
||||
|
||||
Guard
|
||||
}
|
||||
@@ -1,230 +0,0 @@
|
||||
//! A Rust port of the `dlmalloc` allocator.
|
||||
//!
|
||||
//! The `dlmalloc` allocator is described at
|
||||
//! <https://gee.cs.oswego.edu/dl/html/malloc.html> and this Rust crate is a straight
|
||||
//! port of the C code for the allocator into Rust. The implementation is
|
||||
//! wrapped up in a `Dlmalloc` type and has support for Linux, OSX, and Wasm
|
||||
//! currently.
|
||||
//!
|
||||
//! The primary purpose of this crate is that it serves as the default memory
|
||||
//! allocator for the `wasm32-unknown-unknown` target in the standard library.
|
||||
//! Support for other platforms is largely untested and unused, but is used when
|
||||
//! testing this crate.
|
||||
|
||||
#![allow(dead_code)]
|
||||
#![no_std]
|
||||
#![deny(missing_docs)]
|
||||
|
||||
#[cfg(feature = "rust_api")]
|
||||
use core::{cmp, ptr};
|
||||
|
||||
#[cfg(feature = "system")]
|
||||
use sys::System;
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
pub use self::global::{enable_alloc_after_fork, GlobalDlmalloc};
|
||||
|
||||
mod dlmalloc;
|
||||
|
||||
#[cfg(feature = "c_api")]
|
||||
pub use dlmalloc::Dlmalloc as DlmallocCApi;
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
mod global;
|
||||
|
||||
/// In order for this crate to efficiently manage memory, it needs a way to communicate with the
|
||||
/// underlying platform. This `Allocator` trait provides an interface for this communication.
|
||||
pub unsafe trait Allocator: Send {
|
||||
/// Allocates system memory region of at least `size` bytes
|
||||
/// Returns a triple of `(base, size, flags)` where `base` is a pointer to the beginning of the
|
||||
/// allocated memory region. `size` is the actual size of the region while `flags` specifies
|
||||
/// properties of the allocated region. If `EXTERN_BIT` (bit 0) set in flags, then we did not
|
||||
/// allocate this segment and so should not try to deallocate or merge with others.
|
||||
/// This function can return a `std::ptr::null_mut()` when allocation fails (other values of
|
||||
/// the triple will be ignored).
|
||||
fn alloc(&self, size: usize) -> (*mut u8, usize, u32);
|
||||
|
||||
/// Remaps system memory region at `ptr` with size `oldsize` to a potential new location with
|
||||
/// size `newsize`. `can_move` indicates if the location is allowed to move to a completely new
|
||||
/// location, or that it is only allowed to change in size. Returns a pointer to the new
|
||||
/// location in memory.
|
||||
/// This function can return a `std::ptr::null_mut()` to signal an error.
|
||||
fn remap(&self, ptr: *mut u8, oldsize: usize, newsize: usize, can_move: bool) -> *mut u8;
|
||||
|
||||
/// Frees a part of a memory chunk. The original memory chunk starts at `ptr` with size `oldsize`
|
||||
/// and is turned into a memory region starting at the same address but with `newsize` bytes.
|
||||
/// Returns `true` iff the access memory region could be freed.
|
||||
fn free_part(&self, ptr: *mut u8, oldsize: usize, newsize: usize) -> bool;
|
||||
|
||||
/// Frees an entire memory region. Returns `true` iff the operation succeeded. When `false` is
|
||||
/// returned, the `dlmalloc` may re-use the location on future allocation requests
|
||||
fn free(&self, ptr: *mut u8, size: usize) -> bool;
|
||||
|
||||
/// Indicates if the system can release a part of memory. For the `flags` argument, see
|
||||
/// `Allocator::alloc`
|
||||
fn can_release_part(&self, flags: u32) -> bool;
|
||||
|
||||
/// Indicates whether newly allocated regions contain zeros.
|
||||
fn allocates_zeros(&self) -> bool;
|
||||
|
||||
/// Returns the page size. Must be a power of two
|
||||
fn page_size(&self) -> usize;
|
||||
}
|
||||
|
||||
/// An allocator instance
|
||||
///
|
||||
/// Instances of this type are used to allocate blocks of memory. For best
|
||||
/// results only use one of these. Currently doesn't implement `Drop` to release
|
||||
/// lingering memory back to the OS. That may happen eventually though!
|
||||
#[cfg(feature = "rust_api")]
|
||||
pub struct Dlmalloc<
|
||||
#[cfg(feature = "system")]
|
||||
A = System,
|
||||
#[cfg(not(feature = "system"))]
|
||||
A,
|
||||
>(dlmalloc::Dlmalloc<A>);
|
||||
|
||||
cfg_if::cfg_if! {
|
||||
if #[cfg(all(feature = "system", target_family = "wasm"))] {
|
||||
#[path = "wasm.rs"]
|
||||
mod sys;
|
||||
} else if #[cfg(all(feature = "system", target_os = "windows"))] {
|
||||
#[path = "windows.rs"]
|
||||
mod sys;
|
||||
} else if #[cfg(all(feature = "system", target_os = "xous"))] {
|
||||
#[path = "xous.rs"]
|
||||
mod sys;
|
||||
} else if #[cfg(all(feature = "system", any(target_os = "linux", target_os = "macos", target_os = "redox")))] {
|
||||
#[path = "unix.rs"]
|
||||
mod sys;
|
||||
} else {
|
||||
#[path = "dummy.rs"]
|
||||
mod sys;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "system")]
|
||||
#[cfg(feature = "rust_api")]
|
||||
impl Dlmalloc<System> {
|
||||
/// Creates a new instance of an allocator
|
||||
pub const fn new() -> Dlmalloc<System> {
|
||||
Dlmalloc(dlmalloc::Dlmalloc::new(System::new()))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "rust_api")]
|
||||
impl<A> Dlmalloc<A> {
|
||||
/// Creates a new instance of an allocator
|
||||
pub const fn new_with_allocator(sys_allocator: A) -> Dlmalloc<A> {
|
||||
Dlmalloc(dlmalloc::Dlmalloc::new(sys_allocator))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "rust_api")]
|
||||
impl<A: Allocator> Dlmalloc<A> {
|
||||
/// Allocates `size` bytes with `align` align.
|
||||
///
|
||||
/// Returns a null pointer if allocation fails. Returns a valid pointer
|
||||
/// otherwise.
|
||||
///
|
||||
/// Safety and contracts are largely governed by the `GlobalAlloc::alloc`
|
||||
/// method contracts.
|
||||
#[inline]
|
||||
pub unsafe fn malloc(&mut self, size: usize, align: usize) -> *mut u8 {
|
||||
if align <= self.0.malloc_alignment() {
|
||||
self.0.malloc(size)
|
||||
} else {
|
||||
self.0.memalign(align, size)
|
||||
}
|
||||
}
|
||||
|
||||
/// Same as `malloc`, except if the allocation succeeds it's guaranteed to
|
||||
/// point to `size` bytes of zeros.
|
||||
#[inline]
|
||||
pub unsafe fn calloc(&mut self, size: usize, align: usize) -> *mut u8 {
|
||||
let ptr = self.malloc(size, align);
|
||||
if !ptr.is_null() && self.0.calloc_must_clear(ptr) {
|
||||
ptr::write_bytes(ptr, 0, size);
|
||||
}
|
||||
ptr
|
||||
}
|
||||
|
||||
/// Deallocates a `ptr` with `size` and `align` as the previous request used
|
||||
/// to allocate it.
|
||||
///
|
||||
/// Safety and contracts are largely governed by the `GlobalAlloc::dealloc`
|
||||
/// method contracts.
|
||||
#[inline]
|
||||
pub unsafe fn free(&mut self, ptr: *mut u8, size: usize, align: usize) {
|
||||
let _ = align;
|
||||
self.0.validate_size(ptr, size);
|
||||
self.0.free(ptr)
|
||||
}
|
||||
|
||||
/// Reallocates `ptr`, a previous allocation with `old_size` and
|
||||
/// `old_align`, to have `new_size` and the same alignment as before.
|
||||
///
|
||||
/// Returns a null pointer if the memory couldn't be reallocated, but `ptr`
|
||||
/// is still valid. Returns a valid pointer and frees `ptr` if the request
|
||||
/// is satisfied.
|
||||
///
|
||||
/// Safety and contracts are largely governed by the `GlobalAlloc::realloc`
|
||||
/// method contracts.
|
||||
#[inline]
|
||||
pub unsafe fn realloc(
|
||||
&mut self,
|
||||
ptr: *mut u8,
|
||||
old_size: usize,
|
||||
old_align: usize,
|
||||
new_size: usize,
|
||||
) -> *mut u8 {
|
||||
self.0.validate_size(ptr, old_size);
|
||||
|
||||
if old_align <= self.0.malloc_alignment() {
|
||||
self.0.realloc(ptr, new_size)
|
||||
} else {
|
||||
let res = self.malloc(new_size, old_align);
|
||||
if !res.is_null() {
|
||||
let size = cmp::min(old_size, new_size);
|
||||
ptr::copy_nonoverlapping(ptr, res, size);
|
||||
self.free(ptr, old_size, old_align);
|
||||
}
|
||||
res
|
||||
}
|
||||
}
|
||||
|
||||
/// If possible, gives memory back to the system if there is unused memory
|
||||
/// at the high end of the malloc pool or in unused segments.
|
||||
///
|
||||
/// You can call this after freeing large blocks of memory to potentially
|
||||
/// reduce the system-level memory requirements of a program. However, it
|
||||
/// cannot guarantee to reduce memory. Under some allocation patterns, some
|
||||
/// large free blocks of memory will be locked between two used chunks, so
|
||||
/// they cannot be given back to the system.
|
||||
///
|
||||
/// The `pad` argument represents the amount of free trailing space to
|
||||
/// leave untrimmed. If this argument is zero, only the minimum amount of
|
||||
/// memory to maintain internal data structures will be left. Non-zero
|
||||
/// arguments can be supplied to maintain enough trailing space to service
|
||||
/// future expected allocations without having to re-obtain memory from the
|
||||
/// system.
|
||||
///
|
||||
/// Returns `true` if it actually released any memory, else `false`.
|
||||
pub unsafe fn trim(&mut self, pad: usize) -> bool {
|
||||
self.0.trim(pad)
|
||||
}
|
||||
|
||||
/// Releases all allocations in this allocator back to the system,
|
||||
/// consuming self and preventing further use.
|
||||
///
|
||||
/// Returns the number of bytes released to the system.
|
||||
pub unsafe fn destroy(self) -> usize {
|
||||
self.0.destroy()
|
||||
}
|
||||
|
||||
/// Get a reference the underlying [`Allocator`] that this `Dlmalloc` was
|
||||
/// constructed with.
|
||||
pub fn allocator(&self) -> &A {
|
||||
self.0.allocator()
|
||||
}
|
||||
}
|
||||
@@ -1,131 +0,0 @@
|
||||
use crate::Allocator;
|
||||
use core::ptr;
|
||||
|
||||
/// System setting for Linux
|
||||
pub struct System {
|
||||
_priv: (),
|
||||
}
|
||||
|
||||
impl System {
|
||||
pub const fn new() -> System {
|
||||
System { _priv: () }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
static mut LOCK: libc::pthread_mutex_t = libc::PTHREAD_MUTEX_INITIALIZER;
|
||||
|
||||
unsafe impl Allocator for System {
|
||||
fn alloc(&self, size: usize) -> (*mut u8, usize, u32) {
|
||||
let addr = unsafe {
|
||||
libc::mmap(
|
||||
ptr::null_mut(),
|
||||
size,
|
||||
libc::PROT_WRITE | libc::PROT_READ,
|
||||
libc::MAP_ANON | libc::MAP_PRIVATE,
|
||||
-1,
|
||||
0,
|
||||
)
|
||||
};
|
||||
if addr == libc::MAP_FAILED {
|
||||
(ptr::null_mut(), 0, 0)
|
||||
} else {
|
||||
(addr.cast(), size, 0)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
fn remap(&self, ptr: *mut u8, oldsize: usize, newsize: usize, can_move: bool) -> *mut u8 {
|
||||
let flags = if can_move { libc::MREMAP_MAYMOVE } else { 0 };
|
||||
let ptr = unsafe { libc::mremap(ptr.cast(), oldsize, newsize, flags) };
|
||||
if ptr == libc::MAP_FAILED {
|
||||
ptr::null_mut()
|
||||
} else {
|
||||
ptr.cast()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "redox", target_os = "macos"))]
|
||||
fn remap(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize, _can_move: bool) -> *mut u8 {
|
||||
ptr::null_mut()
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
fn free_part(&self, ptr: *mut u8, oldsize: usize, newsize: usize) -> bool {
|
||||
unsafe {
|
||||
let rc = libc::mremap(ptr.cast(), oldsize, newsize, 0);
|
||||
if rc != libc::MAP_FAILED {
|
||||
return true;
|
||||
}
|
||||
libc::munmap(ptr.add(newsize).cast(), oldsize - newsize) == 0
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(any(target_os = "redox", target_os = "macos"))]
|
||||
fn free_part(&self, ptr: *mut u8, oldsize: usize, newsize: usize) -> bool {
|
||||
unsafe { libc::munmap(ptr.add(newsize).cast(), oldsize - newsize) == 0 }
|
||||
}
|
||||
|
||||
fn free(&self, ptr: *mut u8, size: usize) -> bool {
|
||||
unsafe { libc::munmap(ptr.cast(), size) == 0 }
|
||||
}
|
||||
|
||||
fn can_release_part(&self, _flags: u32) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn allocates_zeros(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn page_size(&self) -> usize {
|
||||
4096
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
pub fn acquire_global_lock() {
|
||||
unsafe { assert_eq!(libc::pthread_mutex_lock(ptr::addr_of_mut!(LOCK)), 0) }
|
||||
}
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
pub fn release_global_lock() {
|
||||
unsafe { assert_eq!(libc::pthread_mutex_unlock(ptr::addr_of_mut!(LOCK)), 0) }
|
||||
}
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
/// allows the allocator to remain unsable in the child process,
|
||||
/// after a call to `fork(2)`
|
||||
///
|
||||
/// #Safety
|
||||
///
|
||||
/// if used, this function must be called,
|
||||
/// before any allocations are made with the global allocator.
|
||||
pub unsafe fn enable_alloc_after_fork() {
|
||||
// atfork must only be called once, to avoid a deadlock,
|
||||
// where the handler attempts to acquire the global lock twice
|
||||
static mut FORK_PROTECTED: bool = false;
|
||||
|
||||
unsafe extern "C" fn _acquire_global_lock() {
|
||||
acquire_global_lock()
|
||||
}
|
||||
|
||||
unsafe extern "C" fn _release_global_lock() {
|
||||
release_global_lock()
|
||||
}
|
||||
|
||||
acquire_global_lock();
|
||||
// if a process forks,
|
||||
// it will acquire the lock before any other thread,
|
||||
// protecting it from deadlock,
|
||||
// due to the child being created with only the calling thread.
|
||||
if !FORK_PROTECTED {
|
||||
libc::pthread_atfork(
|
||||
Some(_acquire_global_lock),
|
||||
Some(_release_global_lock),
|
||||
Some(_release_global_lock),
|
||||
);
|
||||
FORK_PROTECTED = true;
|
||||
}
|
||||
release_global_lock();
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
use crate::Allocator;
|
||||
#[cfg(target_arch = "wasm32")]
|
||||
use core::arch::wasm32 as wasm;
|
||||
#[cfg(target_arch = "wasm64")]
|
||||
use core::arch::wasm64 as wasm;
|
||||
use core::ptr;
|
||||
|
||||
/// System setting for Wasm
|
||||
pub struct System {
|
||||
_priv: (),
|
||||
}
|
||||
|
||||
impl System {
|
||||
pub const fn new() -> System {
|
||||
System { _priv: () }
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl Allocator for System {
|
||||
fn alloc(&self, size: usize) -> (*mut u8, usize, u32) {
|
||||
let pages = size / self.page_size();
|
||||
let prev = wasm::memory_grow(0, pages);
|
||||
if prev == usize::max_value() {
|
||||
return (ptr::null_mut(), 0, 0);
|
||||
}
|
||||
(
|
||||
(prev * self.page_size()) as *mut u8,
|
||||
pages * self.page_size(),
|
||||
0,
|
||||
)
|
||||
}
|
||||
|
||||
fn remap(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize, _can_move: bool) -> *mut u8 {
|
||||
// TODO: I think this can be implemented near the end?
|
||||
ptr::null_mut()
|
||||
}
|
||||
|
||||
fn free_part(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn free(&self, _ptr: *mut u8, _size: usize) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn can_release_part(&self, _flags: u32) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn allocates_zeros(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn page_size(&self) -> usize {
|
||||
64 * 1024
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
pub fn acquire_global_lock() {
|
||||
// single threaded, no need!
|
||||
assert!(!cfg!(target_feature = "atomics"));
|
||||
}
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
pub fn release_global_lock() {
|
||||
// single threaded, no need!
|
||||
assert!(!cfg!(target_feature = "atomics"));
|
||||
}
|
||||
|
||||
#[allow(missing_docs)]
|
||||
#[cfg(feature = "global")]
|
||||
pub unsafe fn enable_alloc_after_fork() {
|
||||
// single threaded, no need!
|
||||
assert!(!cfg!(target_feature = "atomics"));
|
||||
}
|
||||
@@ -1,88 +0,0 @@
|
||||
use crate::Allocator;
|
||||
use core::mem::MaybeUninit;
|
||||
use core::ptr;
|
||||
use windows_sys::Win32::System::Memory::*;
|
||||
use windows_sys::Win32::System::SystemInformation::*;
|
||||
#[cfg(feature = "global")]
|
||||
use windows_sys::Win32::System::Threading::*;
|
||||
|
||||
pub struct System {
|
||||
_priv: (),
|
||||
}
|
||||
|
||||
impl System {
|
||||
pub const fn new() -> System {
|
||||
System { _priv: () }
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl Allocator for System {
|
||||
fn alloc(&self, size: usize) -> (*mut u8, usize, u32) {
|
||||
let addr = unsafe {
|
||||
VirtualAlloc(
|
||||
ptr::null_mut(),
|
||||
size,
|
||||
MEM_RESERVE | MEM_COMMIT,
|
||||
PAGE_READWRITE,
|
||||
)
|
||||
};
|
||||
|
||||
if addr.is_null() {
|
||||
(ptr::null_mut(), 0, 0)
|
||||
} else {
|
||||
(addr.cast(), size, 0)
|
||||
}
|
||||
}
|
||||
|
||||
fn remap(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize, _can_move: bool) -> *mut u8 {
|
||||
ptr::null_mut()
|
||||
}
|
||||
|
||||
fn free_part(&self, ptr: *mut u8, oldsize: usize, newsize: usize) -> bool {
|
||||
unsafe { VirtualFree(ptr.add(newsize).cast(), oldsize - newsize, MEM_DECOMMIT) != 0 }
|
||||
}
|
||||
|
||||
fn free(&self, ptr: *mut u8, _size: usize) -> bool {
|
||||
unsafe { VirtualFree(ptr.cast(), 0, MEM_DECOMMIT) != 0 }
|
||||
}
|
||||
|
||||
fn can_release_part(&self, _flags: u32) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn allocates_zeros(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn page_size(&self) -> usize {
|
||||
unsafe {
|
||||
let mut info = MaybeUninit::uninit();
|
||||
GetSystemInfo(info.as_mut_ptr());
|
||||
info.assume_init_ref().dwPageSize as usize
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// NB: `SRWLOCK_INIT` doesn't appear to be in `windows-sys`
|
||||
#[cfg(feature = "global")]
|
||||
static mut LOCK: SRWLOCK = SRWLOCK {
|
||||
Ptr: ptr::null_mut(),
|
||||
};
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
pub fn acquire_global_lock() {
|
||||
unsafe {
|
||||
AcquireSRWLockExclusive(ptr::addr_of_mut!(LOCK));
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
pub fn release_global_lock() {
|
||||
unsafe {
|
||||
ReleaseSRWLockExclusive(ptr::addr_of_mut!(LOCK));
|
||||
}
|
||||
}
|
||||
|
||||
/// Not needed on Windows
|
||||
#[cfg(feature = "global")]
|
||||
pub unsafe fn enable_alloc_after_fork() {}
|
||||
@@ -1,117 +0,0 @@
|
||||
use crate::Allocator;
|
||||
use core::ptr;
|
||||
|
||||
pub struct System {
|
||||
_priv: (),
|
||||
}
|
||||
|
||||
impl System {
|
||||
pub const fn new() -> System {
|
||||
System { _priv: () }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_arch = "riscv32")]
|
||||
mod sys {
|
||||
use core::arch::asm;
|
||||
|
||||
pub fn increase_heap(length: usize) -> Result<(usize, usize), ()> {
|
||||
let syscall_no_increase_heap = 10usize;
|
||||
let memory_flags_read_write = 2usize | 4usize;
|
||||
|
||||
let mut a0 = syscall_no_increase_heap;
|
||||
let mut a1 = length;
|
||||
let mut a2 = memory_flags_read_write;
|
||||
|
||||
unsafe {
|
||||
asm!(
|
||||
"ecall",
|
||||
inlateout("a0") a0,
|
||||
inlateout("a1") a1,
|
||||
inlateout("a2") a2,
|
||||
out("a3") _,
|
||||
out("a4") _,
|
||||
out("a5") _,
|
||||
out("a6") _,
|
||||
out("a7") _,
|
||||
)
|
||||
};
|
||||
|
||||
let result = a0;
|
||||
let address = a1;
|
||||
let length = a2;
|
||||
|
||||
// 3 is the "MemoryRange" type, and the result is only valid
|
||||
// if we get nonzero address and length.
|
||||
if result == 3 && address != 0 && length != 0 {
|
||||
Ok((address, length))
|
||||
} else {
|
||||
Err(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl Allocator for System {
|
||||
/// Allocate an additional `size` bytes on the heap, and return a new
|
||||
/// chunk of memory, as well as the size of the allocation and some
|
||||
/// flags. Since flags are unused on this platform, they will always
|
||||
/// be `0`.
|
||||
fn alloc(&self, size: usize) -> (*mut u8, usize, u32) {
|
||||
let size = if size == 0 {
|
||||
4096
|
||||
} else if size & 4095 == 0 {
|
||||
size
|
||||
} else {
|
||||
size + (4096 - (size & 4095))
|
||||
};
|
||||
|
||||
if let Ok((address, length)) = sys::increase_heap(size) {
|
||||
let start = address - size + length;
|
||||
(start as *mut u8, size, 0)
|
||||
} else {
|
||||
(ptr::null_mut(), 0, 0)
|
||||
}
|
||||
}
|
||||
|
||||
fn remap(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize, _can_move: bool) -> *mut u8 {
|
||||
// TODO
|
||||
ptr::null_mut()
|
||||
}
|
||||
|
||||
fn free_part(&self, _ptr: *mut u8, _oldsize: usize, _newsize: usize) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn free(&self, _ptr: *mut u8, _size: usize) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn can_release_part(&self, _flags: u32) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn allocates_zeros(&self) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn page_size(&self) -> usize {
|
||||
4 * 1024
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
pub fn acquire_global_lock() {
|
||||
// global feature should not be enabled
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
pub fn release_global_lock() {
|
||||
// global feature should not be enabled
|
||||
unimplemented!()
|
||||
}
|
||||
|
||||
#[cfg(feature = "global")]
|
||||
pub unsafe fn enable_alloc_after_fork() {
|
||||
// platform does not support `fork()` call
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
extern crate dlmalloc;
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::thread;
|
||||
|
||||
#[global_allocator]
|
||||
#[cfg(feature = "global")]
|
||||
static A: dlmalloc::GlobalDlmalloc = dlmalloc::GlobalDlmalloc;
|
||||
|
||||
#[test]
|
||||
fn foo() {
|
||||
println!("hello");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn map() {
|
||||
let mut m = HashMap::new();
|
||||
m.insert(1, 2);
|
||||
m.insert(5, 3);
|
||||
drop(m);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn strings() {
|
||||
format!("foo, bar, {}", "baz");
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(not(target_family = "wasm"))]
|
||||
fn threads() {
|
||||
assert!(thread::spawn(|| panic!()).join().is_err());
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
use arbitrary::Unstructured;
|
||||
use dlmalloc::Dlmalloc;
|
||||
use rand::{rngs::SmallRng, RngCore, SeedableRng};
|
||||
|
||||
#[test]
|
||||
fn smoke() {
|
||||
let mut a = Dlmalloc::new();
|
||||
unsafe {
|
||||
let ptr = a.malloc(1, 1);
|
||||
assert!(!ptr.is_null());
|
||||
*ptr = 9;
|
||||
assert_eq!(*ptr, 9);
|
||||
a.free(ptr, 1, 1);
|
||||
|
||||
let ptr = a.malloc(1, 1);
|
||||
assert!(!ptr.is_null());
|
||||
*ptr = 10;
|
||||
assert_eq!(*ptr, 10);
|
||||
a.free(ptr, 1, 1);
|
||||
}
|
||||
}
|
||||
|
||||
#[path = "../fuzz/src/lib.rs"]
|
||||
mod fuzz;
|
||||
|
||||
#[test]
|
||||
fn stress() {
|
||||
let mut rng = SmallRng::seed_from_u64(0);
|
||||
let mut buf = vec![0; 4096];
|
||||
let iters = if cfg!(miri) { 5 } else { 2000 };
|
||||
for _ in 0..iters {
|
||||
rng.fill_bytes(&mut buf);
|
||||
let mut u = Unstructured::new(&buf);
|
||||
let _ = fuzz::run(&mut u);
|
||||
}
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
cargo fmt --package relibc --package crt0 --package redox-rt "$@"
|
||||
@@ -1,7 +0,0 @@
|
||||
[package]
|
||||
name = "generic-rt"
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
@@ -1,133 +0,0 @@
|
||||
#![no_std]
|
||||
#![allow(internal_features)]
|
||||
#![feature(core_intrinsics)]
|
||||
#![deny(unsafe_op_in_unsafe_fn)]
|
||||
|
||||
use core::{
|
||||
arch::asm,
|
||||
mem::{self, offset_of},
|
||||
};
|
||||
|
||||
#[derive(Debug)]
|
||||
#[repr(C)]
|
||||
pub struct GenericTcb<Os> {
|
||||
/// Pointer to the end of static TLS. Must be the first member
|
||||
pub tls_end: *mut u8,
|
||||
/// Size of the memory allocated for the static TLS in bytes (multiple of page size)
|
||||
pub tls_len: usize,
|
||||
/// Pointer to this structure
|
||||
pub tcb_ptr: *mut Self,
|
||||
/// Size of the memory allocated for this structure in bytes (should be same as page size)
|
||||
pub tcb_len: usize,
|
||||
pub os_specific: Os,
|
||||
}
|
||||
impl<Os> GenericTcb<Os> {
|
||||
/// Architecture specific code to read a usize from the TCB - aarch64
|
||||
#[allow(unsafe_op_in_unsafe_fn)]
|
||||
#[inline(always)]
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
pub unsafe fn arch_read(offset: usize) -> usize {
|
||||
let abi_ptr: usize;
|
||||
asm!(
|
||||
"mrs {}, tpidr_el0",
|
||||
out(reg) abi_ptr,
|
||||
);
|
||||
|
||||
let tcb_ptr = *(abi_ptr as *const usize);
|
||||
*((tcb_ptr + offset) as *const usize)
|
||||
}
|
||||
|
||||
/// Architecture specific code to read a usize from the TCB - x86
|
||||
#[allow(unsafe_op_in_unsafe_fn)]
|
||||
#[inline(always)]
|
||||
#[cfg(target_arch = "x86")]
|
||||
pub unsafe fn arch_read(offset: usize) -> usize {
|
||||
let value;
|
||||
asm!(
|
||||
"
|
||||
mov {}, gs:[{}]
|
||||
",
|
||||
out(reg) value,
|
||||
in(reg) offset,
|
||||
);
|
||||
value
|
||||
}
|
||||
|
||||
/// Architecture specific code to read a usize from the TCB - x86_64
|
||||
#[allow(unsafe_op_in_unsafe_fn)]
|
||||
#[inline(always)]
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
pub unsafe fn arch_read(offset: usize) -> usize {
|
||||
let value;
|
||||
asm!(
|
||||
"
|
||||
mov {}, fs:[{}]
|
||||
",
|
||||
out(reg) value,
|
||||
in(reg) offset,
|
||||
);
|
||||
value
|
||||
}
|
||||
|
||||
/// Architecture specific code to read a usize from the TCB - riscv64
|
||||
#[allow(unsafe_op_in_unsafe_fn)]
|
||||
#[inline(always)]
|
||||
#[cfg(target_arch = "riscv64")]
|
||||
unsafe fn arch_read(offset: usize) -> usize {
|
||||
let value;
|
||||
asm!(
|
||||
"ld {value}, -8(tp)", // TCB
|
||||
"add {value}, {value}, {offset}",
|
||||
"ld {value}, 0({value})",
|
||||
value = out(reg) value,
|
||||
offset = in(reg) offset,
|
||||
);
|
||||
value
|
||||
}
|
||||
|
||||
pub unsafe fn current_ptr() -> Option<*mut Self> {
|
||||
let tcb_ptr = unsafe { Self::arch_read(offset_of!(Self, tcb_ptr)) as *mut Self };
|
||||
let tcb_len = unsafe { Self::arch_read(offset_of!(Self, tcb_len)) };
|
||||
if tcb_ptr.is_null() || tcb_len < mem::size_of::<Self>() {
|
||||
None
|
||||
} else {
|
||||
Some(tcb_ptr)
|
||||
}
|
||||
}
|
||||
pub unsafe fn current() -> Option<&'static mut Self> {
|
||||
unsafe { Some(&mut *Self::current_ptr()?) }
|
||||
}
|
||||
}
|
||||
pub fn panic_notls(_msg: impl core::fmt::Display) -> ! {
|
||||
// TODO: actually print _msg, perhaps by having panic_notls take a `T: DebugBackend` that can
|
||||
// propagate until called by e.g. relibc start
|
||||
core::intrinsics::abort();
|
||||
}
|
||||
|
||||
pub trait ExpectTlsFree {
|
||||
type Unwrapped;
|
||||
|
||||
fn expect_notls(self, msg: &str) -> Self::Unwrapped;
|
||||
}
|
||||
impl<T, E: core::fmt::Debug> ExpectTlsFree for Result<T, E> {
|
||||
type Unwrapped = T;
|
||||
|
||||
fn expect_notls(self, msg: &str) -> T {
|
||||
match self {
|
||||
Ok(t) => t,
|
||||
Err(err) => panic_notls(format_args!(
|
||||
"{msg}: expect failed for Result with err: {err:?}",
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<T> ExpectTlsFree for Option<T> {
|
||||
type Unwrapped = T;
|
||||
|
||||
fn expect_notls(self, msg: &str) -> T {
|
||||
match self {
|
||||
Some(t) => t,
|
||||
None => panic_notls(format_args!("{msg}: expect failed for Option")),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
#ifndef _ALLOCA_H
|
||||
#define _ALLOCA_H
|
||||
|
||||
#define alloca(size) __builtin_alloca (size)
|
||||
|
||||
#endif /* _ALLOCA_H */
|
||||
@@ -1 +0,0 @@
|
||||
#include <openlibm_complex.h>
|
||||
@@ -1,95 +0,0 @@
|
||||
/*
|
||||
* MIT License
|
||||
* Copyright (c) 2020 Rich Felker musl-libc
|
||||
*/
|
||||
|
||||
#ifndef _FEATURES_H__RELIBC
|
||||
#define _FEATURES_H__RELIBC
|
||||
|
||||
// Version metadata for feature gating
|
||||
// This is useful for divergent implementation specific behavior
|
||||
// glibc, ulibc, and likely others define a similar macro
|
||||
// musl does not define an equivalent macro
|
||||
#define __RELIBC__ 1
|
||||
#define __RELIBC__MAJOR 0
|
||||
#define __RELIBC__MINOR 2
|
||||
|
||||
/*
|
||||
* Sources:
|
||||
* https://en.cppreference.com/w/c/language/attributes
|
||||
* https://clang.llvm.org/docs/LanguageExtensions.html
|
||||
* https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005fc_005fattribute.html
|
||||
* https://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html
|
||||
*/
|
||||
|
||||
// Clang doesn't define __has_cpp_attribute if compiling C code
|
||||
#if !defined(__has_cpp_attribute)
|
||||
#define __has_cpp_attribute(x) 0
|
||||
#endif
|
||||
|
||||
// Clang doesn't define __has_c_attribute if compiling C++ code
|
||||
#if !defined(__has_c_attribute)
|
||||
#define __has_c_attribute(x) 0
|
||||
#endif
|
||||
|
||||
// Check if C23+ attributes are available
|
||||
#if defined(__cplusplus)
|
||||
// HACK: GCC backports C++ attributes to C++98 but doesn't accept attributes
|
||||
// placed before the function like cbindgen emits.
|
||||
// Let's just disable attributes for C++98 by checking if a random C++11
|
||||
// feature is available.
|
||||
#define __HAS_ATTRIBUTE(x) __cpp_variable_templates &&__has_cpp_attribute(x)
|
||||
#else
|
||||
#define __HAS_ATTRIBUTE(x) \
|
||||
(__has_c_attribute(x) || __STDC_VERSION__ >= 202311L || \
|
||||
__has_cpp_attribute(x))
|
||||
#endif
|
||||
|
||||
// TODO: Not emitted with cbindgen
|
||||
#if __STDC_VERSION__ >= 199901L
|
||||
#define __restrict restrict
|
||||
#elif !defined(__GNUC__)
|
||||
#define __restrict
|
||||
#endif
|
||||
|
||||
// TODO: Not emitted with cbindgen
|
||||
#if __STDC_VERSION__ >= 199901L || defined(__cplusplus)
|
||||
#define __inline inline
|
||||
#elif !defined(__GNUC__)
|
||||
#define __inline
|
||||
#endif
|
||||
|
||||
// Analogous to Rust's Never type
|
||||
//TODO: clang fails to compile C with [[noreturn]]
|
||||
#if defined(__cplusplus) && __HAS_ATTRIBUTE(noreturn) && !(__clang__)
|
||||
#define __noreturn [[noreturn]]
|
||||
// #elif __STDC_VERSION__ >= 201112L
|
||||
// FIXME: cbindgen incorrectly places _Noreturn
|
||||
// #define __noreturn _Noreturn
|
||||
#elif defined(__GNUC__)
|
||||
#define __noreturn __attribute__((__noreturn__))
|
||||
#else
|
||||
#define __noreturn
|
||||
#endif
|
||||
|
||||
// Analogous to Rust's #[must_use]
|
||||
// C23 only
|
||||
#if __HAS_ATTRIBUTE(nodiscard)
|
||||
#define __nodiscard [[nodiscard]]
|
||||
#define __nodiscardNote(x) [[nodiscard(x)]]
|
||||
#else
|
||||
#define __nodiscard
|
||||
#define __nodiscardNote(x)
|
||||
#endif
|
||||
|
||||
// Analogous to Rust's #[deprecated]
|
||||
// C23 only
|
||||
#if __HAS_ATTRIBUTE(deprecated)
|
||||
#define __deprecated [[deprecated]]
|
||||
#define __deprecatedNote(x) [[deprecated(x)]]
|
||||
#else
|
||||
#define __deprecated
|
||||
#define __deprecatedNote(x)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,3 +0,0 @@
|
||||
#include <openlibm_fenv.h>
|
||||
#undef complex
|
||||
#undef I
|
||||
@@ -1,22 +0,0 @@
|
||||
// Copied from musl
|
||||
|
||||
#ifndef _ISO646_H
|
||||
#define _ISO646_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
|
||||
#define and &&
|
||||
#define and_eq &=
|
||||
#define bitand &
|
||||
#define bitor |
|
||||
#define compl ~
|
||||
#define not !
|
||||
#define not_eq !=
|
||||
#define or ||
|
||||
#define or_eq |=
|
||||
#define xor ^
|
||||
#define xor_eq ^=
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,17 +0,0 @@
|
||||
#ifndef __MACHINE_ENDIAN_H__
|
||||
|
||||
/* TODO: Forcing little endian, if you need a big endian system, fix this { */
|
||||
#ifndef BIG_ENDIAN
|
||||
#define BIG_ENDIAN 4321
|
||||
#endif
|
||||
|
||||
#ifndef LITTLE_ENDIAN
|
||||
#define LITTLE_ENDIAN 1234
|
||||
#endif
|
||||
|
||||
#ifndef BYTE_ORDER
|
||||
#define BYTE_ORDER LITTLE_ENDIAN
|
||||
#endif
|
||||
/* } */
|
||||
|
||||
#endif /* __MACHINE_ENDIAN_H__ */
|
||||
-113
@@ -1,113 +0,0 @@
|
||||
#include <openlibm_math.h>
|
||||
|
||||
// Missing typedefs
|
||||
typedef float float_t;
|
||||
typedef double double_t;
|
||||
|
||||
/* double */
|
||||
|
||||
#ifndef M_PI
|
||||
#define M_PI 3.14159265358979323846 /* pi */
|
||||
#endif
|
||||
|
||||
#ifndef M_PI_2
|
||||
#define M_PI_2 1.57079632679489661923 /* pi/2 */
|
||||
#endif
|
||||
|
||||
#ifndef M_PI_4
|
||||
#define M_PI_4 0.78539816339744830962 /* pi/4 */
|
||||
#endif
|
||||
|
||||
#ifndef M_2_PI
|
||||
#define M_2_PI 0.63661977236758134308 /* 2/pi */
|
||||
#endif
|
||||
|
||||
#ifndef M_E
|
||||
#define M_E 2.7182818284590452354 /* e */
|
||||
#endif
|
||||
|
||||
#ifndef M_LOG2E
|
||||
#define M_LOG2E 1.4426950408889634074 /* log_2 e */
|
||||
#endif
|
||||
|
||||
#ifndef M_LOG10E
|
||||
#define M_LOG10E 0.43429448190325182765 /* log_10 e */
|
||||
#endif
|
||||
|
||||
#ifndef M_LN2
|
||||
#define M_LN2 0.69314718055994530942 /* log_e 2 */
|
||||
#endif
|
||||
|
||||
#ifndef M_LN10
|
||||
#define M_LN10 2.30258509299404568402 /* log_e 10 */
|
||||
#endif
|
||||
|
||||
#ifndef M_1_PI
|
||||
#define M_1_PI 0.31830988618379067154 /* 1/pi */
|
||||
#endif
|
||||
|
||||
#ifndef M_2_SQRTPI
|
||||
#define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
|
||||
#endif
|
||||
|
||||
#ifndef M_SQRT2
|
||||
#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
|
||||
#endif
|
||||
|
||||
#ifndef M_SQRT1_2
|
||||
#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
|
||||
#endif
|
||||
|
||||
/* long double */
|
||||
|
||||
#ifndef M_El
|
||||
#define M_El 2.718281828459045235360287471352662498L /* e */
|
||||
#endif
|
||||
|
||||
#ifndef M_LOG2El
|
||||
#define M_LOG2El 1.442695040888963407359924681001892137L /* log_2 e */
|
||||
#endif
|
||||
|
||||
#ifndef M_LOG10El
|
||||
#define M_LOG10El 0.434294481903251827651128918916605082L /* log_10 e */
|
||||
#endif
|
||||
|
||||
#ifndef M_LN2l
|
||||
#define M_LN2l 0.693147180559945309417232121458176568L /* log_e 2 */
|
||||
#endif
|
||||
|
||||
#ifndef M_LN10l
|
||||
#define M_LN10l 2.302585092994045684017991454684364208L /* log_e 10 */
|
||||
#endif
|
||||
|
||||
#ifndef M_PIl
|
||||
#define M_PIl 3.141592653589793238462643383279502884L /* pi */
|
||||
#endif
|
||||
|
||||
#ifndef M_PI_2l
|
||||
#define M_PI_2l 1.570796326794896619231321691639751442L /* pi/2 */
|
||||
#endif
|
||||
|
||||
#ifndef M_PI_4l
|
||||
#define M_PI_4l 0.785398163397448309615660845819875721L /* pi/4 */
|
||||
#endif
|
||||
|
||||
#ifndef M_1_PIl
|
||||
#define M_1_PIl 0.318309886183790671537767526745028724L /* 1/pi */
|
||||
#endif
|
||||
|
||||
#ifndef M_2_PIl
|
||||
#define M_2_PIl 0.636619772367581343075535053490057448L /* 2/pi */
|
||||
#endif
|
||||
|
||||
#ifndef M_2_SQRTPIl
|
||||
#define M_2_SQRTPIl 1.128379167095512573896158903121545172L /* 2/sqrt(pi) */
|
||||
#endif
|
||||
|
||||
#ifndef M_SQRT2l
|
||||
#define M_SQRT2l 1.414213562373095048801688724209698079L /* sqrt(2) */
|
||||
#endif
|
||||
|
||||
#ifndef M_SQRT1_2l
|
||||
#define M_SQRT1_2l 0.707106781186547524400844362104849039L /* 1/sqrt(2) */
|
||||
#endif
|
||||
@@ -1 +0,0 @@
|
||||
#include <string.h>
|
||||
@@ -1,10 +0,0 @@
|
||||
#ifndef _NETINET_IN_SYSTM_H
|
||||
#define _NETINET_IN_SYSTM_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
typedef uint16_t n_short;
|
||||
typedef uint32_t n_long;
|
||||
typedef uint32_t n_time;
|
||||
|
||||
#endif
|
||||
@@ -1,6 +0,0 @@
|
||||
#ifndef _RELIBC_PATHS_H
|
||||
#define _RELIBC_PATHS_H
|
||||
|
||||
#define _PATH_BSHELL "/bin/sh"
|
||||
|
||||
#endif
|
||||
@@ -1,81 +0,0 @@
|
||||
#ifndef _SETJMP_H
|
||||
#define _SETJMP_H
|
||||
|
||||
#ifdef __aarch64__
|
||||
typedef unsigned long jmp_buf[22];
|
||||
#endif
|
||||
|
||||
#ifdef __arm__
|
||||
typedef unsigned long long jmp_buf[32];
|
||||
#endif
|
||||
|
||||
#ifdef __i386__
|
||||
typedef unsigned long jmp_buf[6];
|
||||
#endif
|
||||
|
||||
#ifdef __m68k__
|
||||
typedef unsigned long jmp_buf[39];
|
||||
#endif
|
||||
|
||||
#ifdef __microblaze__
|
||||
typedef unsigned long jmp_buf[18];
|
||||
#endif
|
||||
|
||||
#ifdef __mips__
|
||||
typedef unsigned long long jmp_buf[13];
|
||||
#endif
|
||||
|
||||
#ifdef __mips64__
|
||||
typedef unsigned long long jmp_buf[23];
|
||||
#endif
|
||||
|
||||
#ifdef __mipsn32__
|
||||
typedef unsigned long long jmp_buf[23];
|
||||
#endif
|
||||
|
||||
#ifdef __or1k__
|
||||
typedef unsigned long jmp_buf[13];
|
||||
#endif
|
||||
|
||||
#ifdef __powerpc__
|
||||
typedef unsigned long long jmp_buf[56];
|
||||
#endif
|
||||
|
||||
#ifdef __powerpc64__
|
||||
typedef uint128_t jmp_buf[32];
|
||||
#endif
|
||||
|
||||
#ifdef __s390x__
|
||||
typedef unsigned long jmp_buf[18];
|
||||
#endif
|
||||
|
||||
#ifdef __sh__
|
||||
typedef unsigned long jmp_buf[15];
|
||||
#endif
|
||||
|
||||
#ifdef __x32__
|
||||
typedef unsigned long long jmp_buf[8];
|
||||
#endif
|
||||
|
||||
#ifdef __x86_64__
|
||||
typedef unsigned long jmp_buf[16];
|
||||
#endif
|
||||
|
||||
#ifdef __riscv
|
||||
typedef unsigned long jmp_buf[26];
|
||||
#endif
|
||||
|
||||
typedef jmp_buf sigjmp_buf;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int setjmp(jmp_buf buf);
|
||||
void longjmp(jmp_buf buf, int value);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
#endif /* _SETJMP_H */
|
||||
@@ -1,10 +0,0 @@
|
||||
#ifndef _STDARG_H
|
||||
#define _STDARG_H
|
||||
|
||||
typedef __builtin_va_list va_list;
|
||||
#define va_start(v,l) __builtin_va_start(v,l)
|
||||
#define va_end(v) __builtin_va_end(v)
|
||||
#define va_arg(v,l) __builtin_va_arg(v,l)
|
||||
#define va_copy(d,s) __builtin_va_copy(d,s)
|
||||
|
||||
#endif /* _STDARG_H */
|
||||
@@ -1,243 +0,0 @@
|
||||
/* Copyright (C) 2013-2022 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GCC.
|
||||
|
||||
GCC is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 3, or (at your option)
|
||||
any later version.
|
||||
|
||||
GCC is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
Under Section 7 of GPL version 3, you are granted additional
|
||||
permissions described in the GCC Runtime Library Exception, version
|
||||
3.1, as published by the Free Software Foundation.
|
||||
|
||||
You should have received a copy of the GNU General Public License and
|
||||
a copy of the GCC Runtime Library Exception along with this program;
|
||||
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
/* ISO C11 Standard: 7.17 Atomics <stdatomic.h>. */
|
||||
|
||||
#ifndef _STDATOMIC_H
|
||||
#define _STDATOMIC_H
|
||||
|
||||
typedef enum
|
||||
{
|
||||
memory_order_relaxed = __ATOMIC_RELAXED,
|
||||
memory_order_consume = __ATOMIC_CONSUME,
|
||||
memory_order_acquire = __ATOMIC_ACQUIRE,
|
||||
memory_order_release = __ATOMIC_RELEASE,
|
||||
memory_order_acq_rel = __ATOMIC_ACQ_REL,
|
||||
memory_order_seq_cst = __ATOMIC_SEQ_CST
|
||||
} memory_order;
|
||||
|
||||
|
||||
typedef _Atomic _Bool atomic_bool;
|
||||
typedef _Atomic char atomic_char;
|
||||
typedef _Atomic signed char atomic_schar;
|
||||
typedef _Atomic unsigned char atomic_uchar;
|
||||
typedef _Atomic short atomic_short;
|
||||
typedef _Atomic unsigned short atomic_ushort;
|
||||
typedef _Atomic int atomic_int;
|
||||
typedef _Atomic unsigned int atomic_uint;
|
||||
typedef _Atomic long atomic_long;
|
||||
typedef _Atomic unsigned long atomic_ulong;
|
||||
typedef _Atomic long long atomic_llong;
|
||||
typedef _Atomic unsigned long long atomic_ullong;
|
||||
typedef _Atomic __CHAR16_TYPE__ atomic_char16_t;
|
||||
typedef _Atomic __CHAR32_TYPE__ atomic_char32_t;
|
||||
typedef _Atomic __WCHAR_TYPE__ atomic_wchar_t;
|
||||
typedef _Atomic __INT_LEAST8_TYPE__ atomic_int_least8_t;
|
||||
typedef _Atomic __UINT_LEAST8_TYPE__ atomic_uint_least8_t;
|
||||
typedef _Atomic __INT_LEAST16_TYPE__ atomic_int_least16_t;
|
||||
typedef _Atomic __UINT_LEAST16_TYPE__ atomic_uint_least16_t;
|
||||
typedef _Atomic __INT_LEAST32_TYPE__ atomic_int_least32_t;
|
||||
typedef _Atomic __UINT_LEAST32_TYPE__ atomic_uint_least32_t;
|
||||
typedef _Atomic __INT_LEAST64_TYPE__ atomic_int_least64_t;
|
||||
typedef _Atomic __UINT_LEAST64_TYPE__ atomic_uint_least64_t;
|
||||
typedef _Atomic __INT_FAST8_TYPE__ atomic_int_fast8_t;
|
||||
typedef _Atomic __UINT_FAST8_TYPE__ atomic_uint_fast8_t;
|
||||
typedef _Atomic __INT_FAST16_TYPE__ atomic_int_fast16_t;
|
||||
typedef _Atomic __UINT_FAST16_TYPE__ atomic_uint_fast16_t;
|
||||
typedef _Atomic __INT_FAST32_TYPE__ atomic_int_fast32_t;
|
||||
typedef _Atomic __UINT_FAST32_TYPE__ atomic_uint_fast32_t;
|
||||
typedef _Atomic __INT_FAST64_TYPE__ atomic_int_fast64_t;
|
||||
typedef _Atomic __UINT_FAST64_TYPE__ atomic_uint_fast64_t;
|
||||
typedef _Atomic __INTPTR_TYPE__ atomic_intptr_t;
|
||||
typedef _Atomic __UINTPTR_TYPE__ atomic_uintptr_t;
|
||||
typedef _Atomic __SIZE_TYPE__ atomic_size_t;
|
||||
typedef _Atomic __PTRDIFF_TYPE__ atomic_ptrdiff_t;
|
||||
typedef _Atomic __INTMAX_TYPE__ atomic_intmax_t;
|
||||
typedef _Atomic __UINTMAX_TYPE__ atomic_uintmax_t;
|
||||
|
||||
|
||||
#define ATOMIC_VAR_INIT(VALUE) (VALUE)
|
||||
|
||||
/* Initialize an atomic object pointed to by PTR with VAL. */
|
||||
#define atomic_init(PTR, VAL) \
|
||||
atomic_store_explicit (PTR, VAL, __ATOMIC_RELAXED)
|
||||
|
||||
#define kill_dependency(Y) \
|
||||
__extension__ \
|
||||
({ \
|
||||
__auto_type __kill_dependency_tmp = (Y); \
|
||||
__kill_dependency_tmp; \
|
||||
})
|
||||
|
||||
extern void atomic_thread_fence (memory_order);
|
||||
#define atomic_thread_fence(MO) __atomic_thread_fence (MO)
|
||||
extern void atomic_signal_fence (memory_order);
|
||||
#define atomic_signal_fence(MO) __atomic_signal_fence (MO)
|
||||
#define atomic_is_lock_free(OBJ) __atomic_is_lock_free (sizeof (*(OBJ)), (OBJ))
|
||||
|
||||
#define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE
|
||||
#define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE
|
||||
#define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE
|
||||
#define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE
|
||||
#define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE
|
||||
#define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE
|
||||
#define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE
|
||||
#define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE
|
||||
#define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE
|
||||
#define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE
|
||||
|
||||
|
||||
/* Note that these macros require __auto_type to remove
|
||||
_Atomic qualifiers (and const qualifiers, if those are valid on
|
||||
macro operands).
|
||||
|
||||
Also note that the header file uses the generic form of __atomic
|
||||
builtins, which requires the address to be taken of the value
|
||||
parameter, and then we pass that value on. This allows the macros
|
||||
to work for any type, and the compiler is smart enough to convert
|
||||
these to lock-free _N variants if possible, and throw away the
|
||||
temps. */
|
||||
|
||||
#define atomic_store_explicit(PTR, VAL, MO) \
|
||||
__extension__ \
|
||||
({ \
|
||||
__auto_type __atomic_store_ptr = (PTR); \
|
||||
__typeof__ ((void)0, *__atomic_store_ptr) __atomic_store_tmp = (VAL); \
|
||||
__atomic_store (__atomic_store_ptr, &__atomic_store_tmp, (MO)); \
|
||||
})
|
||||
|
||||
#define atomic_store(PTR, VAL) \
|
||||
atomic_store_explicit (PTR, VAL, __ATOMIC_SEQ_CST)
|
||||
|
||||
|
||||
#define atomic_load_explicit(PTR, MO) \
|
||||
__extension__ \
|
||||
({ \
|
||||
__auto_type __atomic_load_ptr = (PTR); \
|
||||
__typeof__ ((void)0, *__atomic_load_ptr) __atomic_load_tmp; \
|
||||
__atomic_load (__atomic_load_ptr, &__atomic_load_tmp, (MO)); \
|
||||
__atomic_load_tmp; \
|
||||
})
|
||||
|
||||
#define atomic_load(PTR) atomic_load_explicit (PTR, __ATOMIC_SEQ_CST)
|
||||
|
||||
|
||||
#define atomic_exchange_explicit(PTR, VAL, MO) \
|
||||
__extension__ \
|
||||
({ \
|
||||
__auto_type __atomic_exchange_ptr = (PTR); \
|
||||
__typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_val = (VAL); \
|
||||
__typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_tmp; \
|
||||
__atomic_exchange (__atomic_exchange_ptr, &__atomic_exchange_val, \
|
||||
&__atomic_exchange_tmp, (MO)); \
|
||||
__atomic_exchange_tmp; \
|
||||
})
|
||||
|
||||
#define atomic_exchange(PTR, VAL) \
|
||||
atomic_exchange_explicit (PTR, VAL, __ATOMIC_SEQ_CST)
|
||||
|
||||
|
||||
#define atomic_compare_exchange_strong_explicit(PTR, VAL, DES, SUC, FAIL) \
|
||||
__extension__ \
|
||||
({ \
|
||||
__auto_type __atomic_compare_exchange_ptr = (PTR); \
|
||||
__typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
|
||||
= (DES); \
|
||||
__atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL), \
|
||||
&__atomic_compare_exchange_tmp, 0, \
|
||||
(SUC), (FAIL)); \
|
||||
})
|
||||
|
||||
#define atomic_compare_exchange_strong(PTR, VAL, DES) \
|
||||
atomic_compare_exchange_strong_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \
|
||||
__ATOMIC_SEQ_CST)
|
||||
|
||||
#define atomic_compare_exchange_weak_explicit(PTR, VAL, DES, SUC, FAIL) \
|
||||
__extension__ \
|
||||
({ \
|
||||
__auto_type __atomic_compare_exchange_ptr = (PTR); \
|
||||
__typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
|
||||
= (DES); \
|
||||
__atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL), \
|
||||
&__atomic_compare_exchange_tmp, 1, \
|
||||
(SUC), (FAIL)); \
|
||||
})
|
||||
|
||||
#define atomic_compare_exchange_weak(PTR, VAL, DES) \
|
||||
atomic_compare_exchange_weak_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \
|
||||
__ATOMIC_SEQ_CST)
|
||||
|
||||
|
||||
|
||||
#define atomic_fetch_add(PTR, VAL) __atomic_fetch_add ((PTR), (VAL), \
|
||||
__ATOMIC_SEQ_CST)
|
||||
#define atomic_fetch_add_explicit(PTR, VAL, MO) \
|
||||
__atomic_fetch_add ((PTR), (VAL), (MO))
|
||||
|
||||
#define atomic_fetch_sub(PTR, VAL) __atomic_fetch_sub ((PTR), (VAL), \
|
||||
__ATOMIC_SEQ_CST)
|
||||
#define atomic_fetch_sub_explicit(PTR, VAL, MO) \
|
||||
__atomic_fetch_sub ((PTR), (VAL), (MO))
|
||||
|
||||
#define atomic_fetch_or(PTR, VAL) __atomic_fetch_or ((PTR), (VAL), \
|
||||
__ATOMIC_SEQ_CST)
|
||||
#define atomic_fetch_or_explicit(PTR, VAL, MO) \
|
||||
__atomic_fetch_or ((PTR), (VAL), (MO))
|
||||
|
||||
#define atomic_fetch_xor(PTR, VAL) __atomic_fetch_xor ((PTR), (VAL), \
|
||||
__ATOMIC_SEQ_CST)
|
||||
#define atomic_fetch_xor_explicit(PTR, VAL, MO) \
|
||||
__atomic_fetch_xor ((PTR), (VAL), (MO))
|
||||
|
||||
#define atomic_fetch_and(PTR, VAL) __atomic_fetch_and ((PTR), (VAL), \
|
||||
__ATOMIC_SEQ_CST)
|
||||
#define atomic_fetch_and_explicit(PTR, VAL, MO) \
|
||||
__atomic_fetch_and ((PTR), (VAL), (MO))
|
||||
|
||||
|
||||
typedef _Atomic struct
|
||||
{
|
||||
#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1
|
||||
_Bool __val;
|
||||
#else
|
||||
unsigned char __val;
|
||||
#endif
|
||||
} atomic_flag;
|
||||
|
||||
#define ATOMIC_FLAG_INIT { 0 }
|
||||
|
||||
|
||||
extern _Bool atomic_flag_test_and_set (volatile atomic_flag *);
|
||||
#define atomic_flag_test_and_set(PTR) \
|
||||
__atomic_test_and_set ((PTR), __ATOMIC_SEQ_CST)
|
||||
extern _Bool atomic_flag_test_and_set_explicit (volatile atomic_flag *,
|
||||
memory_order);
|
||||
#define atomic_flag_test_and_set_explicit(PTR, MO) \
|
||||
__atomic_test_and_set ((PTR), (MO))
|
||||
|
||||
extern void atomic_flag_clear (volatile atomic_flag *);
|
||||
#define atomic_flag_clear(PTR) __atomic_clear ((PTR), __ATOMIC_SEQ_CST)
|
||||
extern void atomic_flag_clear_explicit (volatile atomic_flag *, memory_order);
|
||||
#define atomic_flag_clear_explicit(PTR, MO) __atomic_clear ((PTR), (MO))
|
||||
|
||||
#endif /* _STDATOMIC_H */
|
||||
@@ -1,19 +0,0 @@
|
||||
#ifndef _STDBOOL_H
|
||||
#define _STDBOOL_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
#define bool _Bool
|
||||
#define true 1
|
||||
#define false 0
|
||||
#else /* __cplusplus */
|
||||
#if __cplusplus < 201103L
|
||||
#define bool bool
|
||||
#define false false
|
||||
#define true true
|
||||
#endif /*__cplusplus < 201103L*/
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#define __bool_true_false_are_defined 1
|
||||
|
||||
|
||||
#endif /* _STDBOOL_H */
|
||||
@@ -1,377 +0,0 @@
|
||||
/* Copyright (C) 2008-2018 Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GCC.
|
||||
|
||||
GCC is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 3, or (at your option)
|
||||
any later version.
|
||||
|
||||
GCC is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
Under Section 7 of GPL version 3, you are granted additional
|
||||
permissions described in the GCC Runtime Library Exception, version
|
||||
3.1, as published by the Free Software Foundation.
|
||||
|
||||
You should have received a copy of the GNU General Public License and
|
||||
a copy of the GCC Runtime Library Exception along with this program;
|
||||
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
/*
|
||||
* ISO C Standard: 7.18 Integer types <stdint.h>
|
||||
*/
|
||||
|
||||
#ifndef _STDINT_H
|
||||
#define _STDINT_H
|
||||
|
||||
/* 7.8.1.1 Exact-width integer types */
|
||||
|
||||
#ifdef __INT8_TYPE__
|
||||
typedef __INT8_TYPE__ int8_t;
|
||||
#endif
|
||||
#ifdef __INT16_TYPE__
|
||||
typedef __INT16_TYPE__ int16_t;
|
||||
#endif
|
||||
#ifdef __INT32_TYPE__
|
||||
typedef __INT32_TYPE__ int32_t;
|
||||
#endif
|
||||
#ifdef __INT64_TYPE__
|
||||
typedef __INT64_TYPE__ int64_t;
|
||||
#endif
|
||||
#ifdef __UINT8_TYPE__
|
||||
typedef __UINT8_TYPE__ uint8_t;
|
||||
typedef __UINT8_TYPE__ u_int8_t;
|
||||
#endif
|
||||
#ifdef __UINT16_TYPE__
|
||||
typedef __UINT16_TYPE__ uint16_t;
|
||||
typedef __UINT16_TYPE__ u_int16_t;
|
||||
#endif
|
||||
#ifdef __UINT32_TYPE__
|
||||
typedef __UINT32_TYPE__ uint32_t;
|
||||
typedef __UINT32_TYPE__ u_int32_t;
|
||||
// Required by openlibm
|
||||
typedef __UINT32_TYPE__ __uint32_t;
|
||||
#endif
|
||||
#ifdef __UINT64_TYPE__
|
||||
typedef __UINT64_TYPE__ uint64_t;
|
||||
typedef __UINT64_TYPE__ u_int64_t;
|
||||
// Required by openlibm
|
||||
typedef __UINT64_TYPE__ __uint64_t;
|
||||
#endif
|
||||
|
||||
/* 7.8.1.2 Minimum-width integer types */
|
||||
|
||||
typedef __INT_LEAST8_TYPE__ int_least8_t;
|
||||
typedef __INT_LEAST16_TYPE__ int_least16_t;
|
||||
typedef __INT_LEAST32_TYPE__ int_least32_t;
|
||||
typedef __INT_LEAST64_TYPE__ int_least64_t;
|
||||
typedef __UINT_LEAST8_TYPE__ uint_least8_t;
|
||||
typedef __UINT_LEAST16_TYPE__ uint_least16_t;
|
||||
typedef __UINT_LEAST32_TYPE__ uint_least32_t;
|
||||
typedef __UINT_LEAST64_TYPE__ uint_least64_t;
|
||||
|
||||
/* 7.8.1.3 Fastest minimum-width integer types */
|
||||
|
||||
typedef __INT_FAST8_TYPE__ int_fast8_t;
|
||||
typedef __INT_FAST16_TYPE__ int_fast16_t;
|
||||
typedef __INT_FAST32_TYPE__ int_fast32_t;
|
||||
typedef __INT_FAST64_TYPE__ int_fast64_t;
|
||||
typedef __UINT_FAST8_TYPE__ uint_fast8_t;
|
||||
typedef __UINT_FAST16_TYPE__ uint_fast16_t;
|
||||
typedef __UINT_FAST32_TYPE__ uint_fast32_t;
|
||||
typedef __UINT_FAST64_TYPE__ uint_fast64_t;
|
||||
|
||||
/* 7.8.1.4 Integer types capable of holding object pointers */
|
||||
|
||||
#ifdef __INTPTR_TYPE__
|
||||
typedef __INTPTR_TYPE__ intptr_t;
|
||||
#endif
|
||||
#ifdef __UINTPTR_TYPE__
|
||||
typedef __UINTPTR_TYPE__ uintptr_t;
|
||||
#endif
|
||||
|
||||
/* 7.8.1.5 Greatest-width integer types */
|
||||
|
||||
typedef __INTMAX_TYPE__ intmax_t;
|
||||
typedef __UINTMAX_TYPE__ uintmax_t;
|
||||
|
||||
#if (!defined __cplusplus || __cplusplus >= 201103L \
|
||||
|| defined __STDC_LIMIT_MACROS)
|
||||
|
||||
/* 7.18.2 Limits of specified-width integer types */
|
||||
|
||||
#ifdef __INT8_MAX__
|
||||
# undef INT8_MAX
|
||||
# define INT8_MAX __INT8_MAX__
|
||||
# undef INT8_MIN
|
||||
# define INT8_MIN (-INT8_MAX - 1)
|
||||
#endif
|
||||
#ifdef __UINT8_MAX__
|
||||
# undef UINT8_MAX
|
||||
# define UINT8_MAX __UINT8_MAX__
|
||||
#endif
|
||||
#ifdef __INT16_MAX__
|
||||
# undef INT16_MAX
|
||||
# define INT16_MAX __INT16_MAX__
|
||||
# undef INT16_MIN
|
||||
# define INT16_MIN (-INT16_MAX - 1)
|
||||
#endif
|
||||
#ifdef __UINT16_MAX__
|
||||
# undef UINT16_MAX
|
||||
# define UINT16_MAX __UINT16_MAX__
|
||||
#endif
|
||||
#ifdef __INT32_MAX__
|
||||
# undef INT32_MAX
|
||||
# define INT32_MAX __INT32_MAX__
|
||||
# undef INT32_MIN
|
||||
# define INT32_MIN (-INT32_MAX - 1)
|
||||
#endif
|
||||
#ifdef __UINT32_MAX__
|
||||
# undef UINT32_MAX
|
||||
# define UINT32_MAX __UINT32_MAX__
|
||||
#endif
|
||||
#ifdef __INT64_MAX__
|
||||
# undef INT64_MAX
|
||||
# define INT64_MAX __INT64_MAX__
|
||||
# undef INT64_MIN
|
||||
# define INT64_MIN (-INT64_MAX - 1)
|
||||
#endif
|
||||
#ifdef __UINT64_MAX__
|
||||
# undef UINT64_MAX
|
||||
# define UINT64_MAX __UINT64_MAX__
|
||||
#endif
|
||||
|
||||
#undef INT_LEAST8_MAX
|
||||
#define INT_LEAST8_MAX __INT_LEAST8_MAX__
|
||||
#undef INT_LEAST8_MIN
|
||||
#define INT_LEAST8_MIN (-INT_LEAST8_MAX - 1)
|
||||
#undef UINT_LEAST8_MAX
|
||||
#define UINT_LEAST8_MAX __UINT_LEAST8_MAX__
|
||||
#undef INT_LEAST16_MAX
|
||||
#define INT_LEAST16_MAX __INT_LEAST16_MAX__
|
||||
#undef INT_LEAST16_MIN
|
||||
#define INT_LEAST16_MIN (-INT_LEAST16_MAX - 1)
|
||||
#undef UINT_LEAST16_MAX
|
||||
#define UINT_LEAST16_MAX __UINT_LEAST16_MAX__
|
||||
#undef INT_LEAST32_MAX
|
||||
#define INT_LEAST32_MAX __INT_LEAST32_MAX__
|
||||
#undef INT_LEAST32_MIN
|
||||
#define INT_LEAST32_MIN (-INT_LEAST32_MAX - 1)
|
||||
#undef UINT_LEAST32_MAX
|
||||
#define UINT_LEAST32_MAX __UINT_LEAST32_MAX__
|
||||
#undef INT_LEAST64_MAX
|
||||
#define INT_LEAST64_MAX __INT_LEAST64_MAX__
|
||||
#undef INT_LEAST64_MIN
|
||||
#define INT_LEAST64_MIN (-INT_LEAST64_MAX - 1)
|
||||
#undef UINT_LEAST64_MAX
|
||||
#define UINT_LEAST64_MAX __UINT_LEAST64_MAX__
|
||||
|
||||
#undef INT_FAST8_MAX
|
||||
#define INT_FAST8_MAX __INT_FAST8_MAX__
|
||||
#undef INT_FAST8_MIN
|
||||
#define INT_FAST8_MIN (-INT_FAST8_MAX - 1)
|
||||
#undef UINT_FAST8_MAX
|
||||
#define UINT_FAST8_MAX __UINT_FAST8_MAX__
|
||||
#undef INT_FAST16_MAX
|
||||
#define INT_FAST16_MAX __INT_FAST16_MAX__
|
||||
#undef INT_FAST16_MIN
|
||||
#define INT_FAST16_MIN (-INT_FAST16_MAX - 1)
|
||||
#undef UINT_FAST16_MAX
|
||||
#define UINT_FAST16_MAX __UINT_FAST16_MAX__
|
||||
#undef INT_FAST32_MAX
|
||||
#define INT_FAST32_MAX __INT_FAST32_MAX__
|
||||
#undef INT_FAST32_MIN
|
||||
#define INT_FAST32_MIN (-INT_FAST32_MAX - 1)
|
||||
#undef UINT_FAST32_MAX
|
||||
#define UINT_FAST32_MAX __UINT_FAST32_MAX__
|
||||
#undef INT_FAST64_MAX
|
||||
#define INT_FAST64_MAX __INT_FAST64_MAX__
|
||||
#undef INT_FAST64_MIN
|
||||
#define INT_FAST64_MIN (-INT_FAST64_MAX - 1)
|
||||
#undef UINT_FAST64_MAX
|
||||
#define UINT_FAST64_MAX __UINT_FAST64_MAX__
|
||||
|
||||
#ifdef __INTPTR_MAX__
|
||||
# undef INTPTR_MAX
|
||||
# define INTPTR_MAX __INTPTR_MAX__
|
||||
# undef INTPTR_MIN
|
||||
# define INTPTR_MIN (-INTPTR_MAX - 1)
|
||||
#endif
|
||||
#ifdef __UINTPTR_MAX__
|
||||
# undef UINTPTR_MAX
|
||||
# define UINTPTR_MAX __UINTPTR_MAX__
|
||||
#endif
|
||||
|
||||
#undef INTMAX_MAX
|
||||
#define INTMAX_MAX __INTMAX_MAX__
|
||||
#undef INTMAX_MIN
|
||||
#define INTMAX_MIN (-INTMAX_MAX - 1)
|
||||
#undef UINTMAX_MAX
|
||||
#define UINTMAX_MAX __UINTMAX_MAX__
|
||||
|
||||
/* 7.18.3 Limits of other integer types */
|
||||
|
||||
#undef PTRDIFF_MAX
|
||||
#define PTRDIFF_MAX __PTRDIFF_MAX__
|
||||
#undef PTRDIFF_MIN
|
||||
#define PTRDIFF_MIN (-PTRDIFF_MAX - 1)
|
||||
|
||||
#undef SIG_ATOMIC_MAX
|
||||
#define SIG_ATOMIC_MAX __SIG_ATOMIC_MAX__
|
||||
#undef SIG_ATOMIC_MIN
|
||||
#define SIG_ATOMIC_MIN __SIG_ATOMIC_MIN__
|
||||
|
||||
#undef SIZE_MAX
|
||||
#define SIZE_MAX __SIZE_MAX__
|
||||
|
||||
#undef WCHAR_MAX
|
||||
#define WCHAR_MAX __WCHAR_MAX__
|
||||
#undef WCHAR_MIN
|
||||
#define WCHAR_MIN __WCHAR_MIN__
|
||||
|
||||
#undef WINT_MAX
|
||||
#define WINT_MAX __WINT_MAX__
|
||||
#undef WINT_MIN
|
||||
#define WINT_MIN __WINT_MIN__
|
||||
|
||||
#endif /* (!defined __cplusplus || __cplusplus >= 201103L
|
||||
|| defined __STDC_LIMIT_MACROS) */
|
||||
|
||||
#if (!defined __cplusplus || __cplusplus >= 201103L \
|
||||
|| defined __STDC_CONSTANT_MACROS)
|
||||
|
||||
#undef INT8_C
|
||||
#define INT8_C(c) __INT8_C(c)
|
||||
#undef INT16_C
|
||||
#define INT16_C(c) __INT16_C(c)
|
||||
#undef INT32_C
|
||||
#define INT32_C(c) __INT32_C(c)
|
||||
#undef INT64_C
|
||||
#define INT64_C(c) __INT64_C(c)
|
||||
#undef UINT8_C
|
||||
#define UINT8_C(c) __UINT8_C(c)
|
||||
#undef UINT16_C
|
||||
#define UINT16_C(c) __UINT16_C(c)
|
||||
#undef UINT32_C
|
||||
#define UINT32_C(c) __UINT32_C(c)
|
||||
#undef UINT64_C
|
||||
#define UINT64_C(c) __UINT64_C(c)
|
||||
#undef INTMAX_C
|
||||
#define INTMAX_C(c) __INTMAX_C(c)
|
||||
#undef UINTMAX_C
|
||||
#define UINTMAX_C(c) __UINTMAX_C(c)
|
||||
|
||||
#endif /* (!defined __cplusplus || __cplusplus >= 201103L
|
||||
|| defined __STDC_CONSTANT_MACROS) */
|
||||
|
||||
#ifdef __STDC_WANT_IEC_60559_BFP_EXT__
|
||||
/* TS 18661-1 widths of integer types. */
|
||||
|
||||
#ifdef __INT8_TYPE__
|
||||
# undef INT8_WIDTH
|
||||
# define INT8_WIDTH 8
|
||||
#endif
|
||||
#ifdef __UINT8_TYPE__
|
||||
# undef UINT8_WIDTH
|
||||
# define UINT8_WIDTH 8
|
||||
#endif
|
||||
#ifdef __INT16_TYPE__
|
||||
# undef INT16_WIDTH
|
||||
# define INT16_WIDTH 16
|
||||
#endif
|
||||
#ifdef __UINT16_TYPE__
|
||||
# undef UINT16_WIDTH
|
||||
# define UINT16_WIDTH 16
|
||||
#endif
|
||||
#ifdef __INT32_TYPE__
|
||||
# undef INT32_WIDTH
|
||||
# define INT32_WIDTH 32
|
||||
#endif
|
||||
#ifdef __UINT32_TYPE__
|
||||
# undef UINT32_WIDTH
|
||||
# define UINT32_WIDTH 32
|
||||
#endif
|
||||
#ifdef __INT64_TYPE__
|
||||
# undef INT64_WIDTH
|
||||
# define INT64_WIDTH 64
|
||||
#endif
|
||||
#ifdef __UINT64_TYPE__
|
||||
# undef UINT64_WIDTH
|
||||
# define UINT64_WIDTH 64
|
||||
#endif
|
||||
|
||||
#undef INT_LEAST8_WIDTH
|
||||
#define INT_LEAST8_WIDTH __INT_LEAST8_WIDTH__
|
||||
#undef UINT_LEAST8_WIDTH
|
||||
#define UINT_LEAST8_WIDTH __INT_LEAST8_WIDTH__
|
||||
#undef INT_LEAST16_WIDTH
|
||||
#define INT_LEAST16_WIDTH __INT_LEAST16_WIDTH__
|
||||
#undef UINT_LEAST16_WIDTH
|
||||
#define UINT_LEAST16_WIDTH __INT_LEAST16_WIDTH__
|
||||
#undef INT_LEAST32_WIDTH
|
||||
#define INT_LEAST32_WIDTH __INT_LEAST32_WIDTH__
|
||||
#undef UINT_LEAST32_WIDTH
|
||||
#define UINT_LEAST32_WIDTH __INT_LEAST32_WIDTH__
|
||||
#undef INT_LEAST64_WIDTH
|
||||
#define INT_LEAST64_WIDTH __INT_LEAST64_WIDTH__
|
||||
#undef UINT_LEAST64_WIDTH
|
||||
#define UINT_LEAST64_WIDTH __INT_LEAST64_WIDTH__
|
||||
|
||||
#undef INT_FAST8_WIDTH
|
||||
#define INT_FAST8_WIDTH __INT_FAST8_WIDTH__
|
||||
#undef UINT_FAST8_WIDTH
|
||||
#define UINT_FAST8_WIDTH __INT_FAST8_WIDTH__
|
||||
#undef INT_FAST16_WIDTH
|
||||
#define INT_FAST16_WIDTH __INT_FAST16_WIDTH__
|
||||
#undef UINT_FAST16_WIDTH
|
||||
#define UINT_FAST16_WIDTH __INT_FAST16_WIDTH__
|
||||
#undef INT_FAST32_WIDTH
|
||||
#define INT_FAST32_WIDTH __INT_FAST32_WIDTH__
|
||||
#undef UINT_FAST32_WIDTH
|
||||
#define UINT_FAST32_WIDTH __INT_FAST32_WIDTH__
|
||||
#undef INT_FAST64_WIDTH
|
||||
#define INT_FAST64_WIDTH __INT_FAST64_WIDTH__
|
||||
#undef UINT_FAST64_WIDTH
|
||||
#define UINT_FAST64_WIDTH __INT_FAST64_WIDTH__
|
||||
|
||||
#ifdef __INTPTR_TYPE__
|
||||
# undef INTPTR_WIDTH
|
||||
# define INTPTR_WIDTH __INTPTR_WIDTH__
|
||||
#endif
|
||||
#ifdef __UINTPTR_TYPE__
|
||||
# undef UINTPTR_WIDTH
|
||||
# define UINTPTR_WIDTH __INTPTR_WIDTH__
|
||||
#endif
|
||||
|
||||
#undef INTMAX_WIDTH
|
||||
#define INTMAX_WIDTH __INTMAX_WIDTH__
|
||||
#undef UINTMAX_WIDTH
|
||||
#define UINTMAX_WIDTH __INTMAX_WIDTH__
|
||||
|
||||
#undef PTRDIFF_WIDTH
|
||||
#define PTRDIFF_WIDTH __PTRDIFF_WIDTH__
|
||||
|
||||
#undef SIG_ATOMIC_WIDTH
|
||||
#define SIG_ATOMIC_WIDTH __SIG_ATOMIC_WIDTH__
|
||||
|
||||
#undef SIZE_WIDTH
|
||||
#define SIZE_WIDTH __SIZE_WIDTH__
|
||||
|
||||
#undef WCHAR_WIDTH
|
||||
#define WCHAR_WIDTH __WCHAR_WIDTH__
|
||||
|
||||
#undef WINT_WIDTH
|
||||
#define WINT_WIDTH __WINT_WIDTH__
|
||||
|
||||
#ifdef __ILP32__
|
||||
#define SIZE_MAX UINT32_MAX
|
||||
#else
|
||||
#define SIZE_MAX UINT64_MAX
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif /* _GCC_STDINT_H */
|
||||
@@ -1,22 +0,0 @@
|
||||
#ifndef _STDIO_EXT_H
|
||||
#define _STDIO_EXT_H
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
size_t __freadahead(FILE *stream);
|
||||
size_t __fpending(FILE *stream);
|
||||
int __freadable(FILE *stream);
|
||||
int __freading(FILE *stream);
|
||||
void __fseterr(FILE *stream);
|
||||
int __fwritable(FILE *stream);
|
||||
int __fwriting(FILE *stream);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
#endif /* _STDIO_EXT_H */
|
||||
@@ -1,19 +0,0 @@
|
||||
/* Spec:
|
||||
* The <stdnoreturn.h> header shall define the macro noreturn which shall
|
||||
* expand to _Noreturn */
|
||||
|
||||
#ifndef _STDNORETURN_H
|
||||
#define _STDNORETURN_H
|
||||
|
||||
#ifndef __cplusplus
|
||||
/* Borrowed from musl */
|
||||
#if __STDC_VERSION__ >= 201112L
|
||||
#elif defined(__GNUC__)
|
||||
#define _Noreturn __attribute__((__noreturn__))
|
||||
#else
|
||||
#define _Noreturn
|
||||
#endif
|
||||
#define noreturn _Noreturn
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,36 +0,0 @@
|
||||
#ifndef _SYS_PARAM_H
|
||||
#define _SYS_PARAM_H
|
||||
|
||||
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
|
||||
#define MAX(a,b) (((a) > (b)) ? (a) : (b))
|
||||
|
||||
#define __bitop(array, index, op) ((array)[(index) / 8] op (1 << (index) % 8))
|
||||
#define setbit(array, index) __bitop(array, index, |=)
|
||||
#define clrbit(array, index) __bitop(array, index, &= ~)
|
||||
#define isset(array, index) __bitop(array, index, &)
|
||||
#define isclr(array, index) !isset(array, index)
|
||||
|
||||
#define howmany(bits, size) (((bits) + (size) - 1) / (size))
|
||||
#define roundup(bits, size) (howmany(bits, size) * (size))
|
||||
#define powerof2(n) !(((n) - 1) & (n))
|
||||
|
||||
// Shamelessly copied from musl.
|
||||
// Tweak as needed.
|
||||
#define MAXSYMLINKS 20
|
||||
#define MAXHOSTNAMELEN 64
|
||||
#define MAXNAMLEN 255
|
||||
#define MAXPATHLEN 4096
|
||||
#define NBBY 8
|
||||
#define NGROUPS 32
|
||||
#define CANBSIZ 255
|
||||
#define NOFILE 256
|
||||
#define NCARGS 131072
|
||||
#define DEV_BSIZE 512
|
||||
#define NOGROUP (-1)
|
||||
|
||||
#include <sys/resource.h>
|
||||
#include <limits.h>
|
||||
|
||||
#include <machine/endian.h>
|
||||
|
||||
#endif
|
||||
@@ -1 +0,0 @@
|
||||
#include <poll.h>
|
||||
@@ -1,846 +0,0 @@
|
||||
/* $NetBSD: queue.h,v 1.70 2015/11/02 15:21:23 christos Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1991, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* @(#)queue.h 8.5 (Berkeley) 8/20/94
|
||||
*/
|
||||
|
||||
#ifndef _SYS_QUEUE_H_
|
||||
#define _SYS_QUEUE_H_
|
||||
|
||||
/*
|
||||
* This file defines five types of data structures: singly-linked lists,
|
||||
* lists, simple queues, tail queues, and circular queues.
|
||||
*
|
||||
* A singly-linked list is headed by a single forward pointer. The
|
||||
* elements are singly linked for minimum space and pointer manipulation
|
||||
* overhead at the expense of O(n) removal for arbitrary elements. New
|
||||
* elements can be added to the list after an existing element or at the
|
||||
* head of the list. Elements being removed from the head of the list
|
||||
* should use the explicit macro for this purpose for optimum
|
||||
* efficiency. A singly-linked list may only be traversed in the forward
|
||||
* direction. Singly-linked lists are ideal for applications with large
|
||||
* datasets and few or no removals or for implementing a LIFO queue.
|
||||
*
|
||||
* A list is headed by a single forward pointer (or an array of forward
|
||||
* pointers for a hash table header). The elements are doubly linked
|
||||
* so that an arbitrary element can be removed without a need to
|
||||
* traverse the list. New elements can be added to the list before
|
||||
* or after an existing element or at the head of the list. A list
|
||||
* may only be traversed in the forward direction.
|
||||
*
|
||||
* A simple queue is headed by a pair of pointers, one the head of the
|
||||
* list and the other to the tail of the list. The elements are singly
|
||||
* linked to save space, so elements can only be removed from the
|
||||
* head of the list. New elements can be added to the list after
|
||||
* an existing element, at the head of the list, or at the end of the
|
||||
* list. A simple queue may only be traversed in the forward direction.
|
||||
*
|
||||
* A tail queue is headed by a pair of pointers, one to the head of the
|
||||
* list and the other to the tail of the list. The elements are doubly
|
||||
* linked so that an arbitrary element can be removed without a need to
|
||||
* traverse the list. New elements can be added to the list before or
|
||||
* after an existing element, at the head of the list, or at the end of
|
||||
* the list. A tail queue may be traversed in either direction.
|
||||
*
|
||||
* A circle queue is headed by a pair of pointers, one to the head of the
|
||||
* list and the other to the tail of the list. The elements are doubly
|
||||
* linked so that an arbitrary element can be removed without a need to
|
||||
* traverse the list. New elements can be added to the list before or after
|
||||
* an existing element, at the head of the list, or at the end of the list.
|
||||
* A circle queue may be traversed in either direction, but has a more
|
||||
* complex end of list detection.
|
||||
*
|
||||
* For details on the use of these macros, see the queue(3) manual page.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Include the definition of NULL only on NetBSD because sys/null.h
|
||||
* is not available elsewhere. This conditional makes the header
|
||||
* portable and it can simply be dropped verbatim into any system.
|
||||
* The caveat is that on other systems some other header
|
||||
* must provide NULL before the macros can be used.
|
||||
*/
|
||||
#ifdef __NetBSD__
|
||||
#include <sys/null.h>
|
||||
#endif
|
||||
|
||||
#if defined(QUEUEDEBUG)
|
||||
# if defined(_KERNEL)
|
||||
# define QUEUEDEBUG_ABORT(...) panic(__VA_ARGS__)
|
||||
# else
|
||||
# include <err.h>
|
||||
# define QUEUEDEBUG_ABORT(...) err(1, __VA_ARGS__)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Singly-linked List definitions.
|
||||
*/
|
||||
#define SLIST_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *slh_first; /* first element */ \
|
||||
}
|
||||
|
||||
#define SLIST_HEAD_INITIALIZER(head) \
|
||||
{ NULL }
|
||||
|
||||
#define SLIST_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *sle_next; /* next element */ \
|
||||
}
|
||||
|
||||
/*
|
||||
* Singly-linked List access methods.
|
||||
*/
|
||||
#define SLIST_FIRST(head) ((head)->slh_first)
|
||||
#define SLIST_END(head) NULL
|
||||
#define SLIST_EMPTY(head) ((head)->slh_first == NULL)
|
||||
#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
|
||||
|
||||
#define SLIST_FOREACH(var, head, field) \
|
||||
for((var) = (head)->slh_first; \
|
||||
(var) != SLIST_END(head); \
|
||||
(var) = (var)->field.sle_next)
|
||||
|
||||
#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = SLIST_FIRST((head)); \
|
||||
(var) != SLIST_END(head) && \
|
||||
((tvar) = SLIST_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
/*
|
||||
* Singly-linked List functions.
|
||||
*/
|
||||
#define SLIST_INIT(head) do { \
|
||||
(head)->slh_first = SLIST_END(head); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
|
||||
(elm)->field.sle_next = (slistelm)->field.sle_next; \
|
||||
(slistelm)->field.sle_next = (elm); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SLIST_INSERT_HEAD(head, elm, field) do { \
|
||||
(elm)->field.sle_next = (head)->slh_first; \
|
||||
(head)->slh_first = (elm); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SLIST_REMOVE_AFTER(slistelm, field) do { \
|
||||
(slistelm)->field.sle_next = \
|
||||
SLIST_NEXT(SLIST_NEXT((slistelm), field), field); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SLIST_REMOVE_HEAD(head, field) do { \
|
||||
(head)->slh_first = (head)->slh_first->field.sle_next; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SLIST_REMOVE(head, elm, type, field) do { \
|
||||
if ((head)->slh_first == (elm)) { \
|
||||
SLIST_REMOVE_HEAD((head), field); \
|
||||
} \
|
||||
else { \
|
||||
struct type *curelm = (head)->slh_first; \
|
||||
while(curelm->field.sle_next != (elm)) \
|
||||
curelm = curelm->field.sle_next; \
|
||||
curelm->field.sle_next = \
|
||||
curelm->field.sle_next->field.sle_next; \
|
||||
} \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
|
||||
/*
|
||||
* List definitions.
|
||||
*/
|
||||
#define LIST_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *lh_first; /* first element */ \
|
||||
}
|
||||
|
||||
#define LIST_HEAD_INITIALIZER(head) \
|
||||
{ NULL }
|
||||
|
||||
#define LIST_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *le_next; /* next element */ \
|
||||
struct type **le_prev; /* address of previous next element */ \
|
||||
}
|
||||
|
||||
/*
|
||||
* List access methods.
|
||||
*/
|
||||
#define LIST_FIRST(head) ((head)->lh_first)
|
||||
#define LIST_END(head) NULL
|
||||
#define LIST_EMPTY(head) ((head)->lh_first == LIST_END(head))
|
||||
#define LIST_NEXT(elm, field) ((elm)->field.le_next)
|
||||
|
||||
#define LIST_FOREACH(var, head, field) \
|
||||
for ((var) = ((head)->lh_first); \
|
||||
(var) != LIST_END(head); \
|
||||
(var) = ((var)->field.le_next))
|
||||
|
||||
#define LIST_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = LIST_FIRST((head)); \
|
||||
(var) != LIST_END(head) && \
|
||||
((tvar) = LIST_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
#define LIST_MOVE(head1, head2) do { \
|
||||
LIST_INIT((head2)); \
|
||||
if (!LIST_EMPTY((head1))) { \
|
||||
(head2)->lh_first = (head1)->lh_first; \
|
||||
LIST_INIT((head1)); \
|
||||
} \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
/*
|
||||
* List functions.
|
||||
*/
|
||||
#if defined(QUEUEDEBUG)
|
||||
#define QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field) \
|
||||
if ((head)->lh_first && \
|
||||
(head)->lh_first->field.le_prev != &(head)->lh_first) \
|
||||
QUEUEDEBUG_ABORT("LIST_INSERT_HEAD %p %s:%d", (head), \
|
||||
__FILE__, __LINE__);
|
||||
#define QUEUEDEBUG_LIST_OP(elm, field) \
|
||||
if ((elm)->field.le_next && \
|
||||
(elm)->field.le_next->field.le_prev != \
|
||||
&(elm)->field.le_next) \
|
||||
QUEUEDEBUG_ABORT("LIST_* forw %p %s:%d", (elm), \
|
||||
__FILE__, __LINE__); \
|
||||
if (*(elm)->field.le_prev != (elm)) \
|
||||
QUEUEDEBUG_ABORT("LIST_* back %p %s:%d", (elm), \
|
||||
__FILE__, __LINE__);
|
||||
#define QUEUEDEBUG_LIST_POSTREMOVE(elm, field) \
|
||||
(elm)->field.le_next = (void *)1L; \
|
||||
(elm)->field.le_prev = (void *)1L;
|
||||
#else
|
||||
#define QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field)
|
||||
#define QUEUEDEBUG_LIST_OP(elm, field)
|
||||
#define QUEUEDEBUG_LIST_POSTREMOVE(elm, field)
|
||||
#endif
|
||||
|
||||
#define LIST_INIT(head) do { \
|
||||
(head)->lh_first = LIST_END(head); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define LIST_INSERT_AFTER(listelm, elm, field) do { \
|
||||
QUEUEDEBUG_LIST_OP((listelm), field) \
|
||||
if (((elm)->field.le_next = (listelm)->field.le_next) != \
|
||||
LIST_END(head)) \
|
||||
(listelm)->field.le_next->field.le_prev = \
|
||||
&(elm)->field.le_next; \
|
||||
(listelm)->field.le_next = (elm); \
|
||||
(elm)->field.le_prev = &(listelm)->field.le_next; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
|
||||
QUEUEDEBUG_LIST_OP((listelm), field) \
|
||||
(elm)->field.le_prev = (listelm)->field.le_prev; \
|
||||
(elm)->field.le_next = (listelm); \
|
||||
*(listelm)->field.le_prev = (elm); \
|
||||
(listelm)->field.le_prev = &(elm)->field.le_next; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define LIST_INSERT_HEAD(head, elm, field) do { \
|
||||
QUEUEDEBUG_LIST_INSERT_HEAD((head), (elm), field) \
|
||||
if (((elm)->field.le_next = (head)->lh_first) != LIST_END(head))\
|
||||
(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
|
||||
(head)->lh_first = (elm); \
|
||||
(elm)->field.le_prev = &(head)->lh_first; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define LIST_REMOVE(elm, field) do { \
|
||||
QUEUEDEBUG_LIST_OP((elm), field) \
|
||||
if ((elm)->field.le_next != NULL) \
|
||||
(elm)->field.le_next->field.le_prev = \
|
||||
(elm)->field.le_prev; \
|
||||
*(elm)->field.le_prev = (elm)->field.le_next; \
|
||||
QUEUEDEBUG_LIST_POSTREMOVE((elm), field) \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define LIST_REPLACE(elm, elm2, field) do { \
|
||||
if (((elm2)->field.le_next = (elm)->field.le_next) != NULL) \
|
||||
(elm2)->field.le_next->field.le_prev = \
|
||||
&(elm2)->field.le_next; \
|
||||
(elm2)->field.le_prev = (elm)->field.le_prev; \
|
||||
*(elm2)->field.le_prev = (elm2); \
|
||||
QUEUEDEBUG_LIST_POSTREMOVE((elm), field) \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
/*
|
||||
* Simple queue definitions.
|
||||
*/
|
||||
#define SIMPLEQ_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *sqh_first; /* first element */ \
|
||||
struct type **sqh_last; /* addr of last next element */ \
|
||||
}
|
||||
|
||||
#define SIMPLEQ_HEAD_INITIALIZER(head) \
|
||||
{ NULL, &(head).sqh_first }
|
||||
|
||||
#define SIMPLEQ_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *sqe_next; /* next element */ \
|
||||
}
|
||||
|
||||
/*
|
||||
* Simple queue access methods.
|
||||
*/
|
||||
#define SIMPLEQ_FIRST(head) ((head)->sqh_first)
|
||||
#define SIMPLEQ_END(head) NULL
|
||||
#define SIMPLEQ_EMPTY(head) ((head)->sqh_first == SIMPLEQ_END(head))
|
||||
#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next)
|
||||
|
||||
#define SIMPLEQ_FOREACH(var, head, field) \
|
||||
for ((var) = ((head)->sqh_first); \
|
||||
(var) != SIMPLEQ_END(head); \
|
||||
(var) = ((var)->field.sqe_next))
|
||||
|
||||
#define SIMPLEQ_FOREACH_SAFE(var, head, field, next) \
|
||||
for ((var) = ((head)->sqh_first); \
|
||||
(var) != SIMPLEQ_END(head) && \
|
||||
((next = ((var)->field.sqe_next)), 1); \
|
||||
(var) = (next))
|
||||
|
||||
/*
|
||||
* Simple queue functions.
|
||||
*/
|
||||
#define SIMPLEQ_INIT(head) do { \
|
||||
(head)->sqh_first = NULL; \
|
||||
(head)->sqh_last = &(head)->sqh_first; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \
|
||||
if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \
|
||||
(head)->sqh_last = &(elm)->field.sqe_next; \
|
||||
(head)->sqh_first = (elm); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \
|
||||
(elm)->field.sqe_next = NULL; \
|
||||
*(head)->sqh_last = (elm); \
|
||||
(head)->sqh_last = &(elm)->field.sqe_next; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
|
||||
(head)->sqh_last = &(elm)->field.sqe_next; \
|
||||
(listelm)->field.sqe_next = (elm); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SIMPLEQ_REMOVE_HEAD(head, field) do { \
|
||||
if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
|
||||
(head)->sqh_last = &(head)->sqh_first; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SIMPLEQ_REMOVE_AFTER(head, elm, field) do { \
|
||||
if (((elm)->field.sqe_next = (elm)->field.sqe_next->field.sqe_next) \
|
||||
== NULL) \
|
||||
(head)->sqh_last = &(elm)->field.sqe_next; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SIMPLEQ_REMOVE(head, elm, type, field) do { \
|
||||
if ((head)->sqh_first == (elm)) { \
|
||||
SIMPLEQ_REMOVE_HEAD((head), field); \
|
||||
} else { \
|
||||
struct type *curelm = (head)->sqh_first; \
|
||||
while (curelm->field.sqe_next != (elm)) \
|
||||
curelm = curelm->field.sqe_next; \
|
||||
if ((curelm->field.sqe_next = \
|
||||
curelm->field.sqe_next->field.sqe_next) == NULL) \
|
||||
(head)->sqh_last = &(curelm)->field.sqe_next; \
|
||||
} \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SIMPLEQ_CONCAT(head1, head2) do { \
|
||||
if (!SIMPLEQ_EMPTY((head2))) { \
|
||||
*(head1)->sqh_last = (head2)->sqh_first; \
|
||||
(head1)->sqh_last = (head2)->sqh_last; \
|
||||
SIMPLEQ_INIT((head2)); \
|
||||
} \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define SIMPLEQ_LAST(head, type, field) \
|
||||
(SIMPLEQ_EMPTY((head)) ? \
|
||||
NULL : \
|
||||
((struct type *)(void *) \
|
||||
((char *)((head)->sqh_last) - offsetof(struct type, field))))
|
||||
|
||||
/*
|
||||
* Tail queue definitions.
|
||||
*/
|
||||
#define _TAILQ_HEAD(name, type, qual) \
|
||||
struct name { \
|
||||
qual type *tqh_first; /* first element */ \
|
||||
qual type *qual *tqh_last; /* addr of last next element */ \
|
||||
}
|
||||
#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,)
|
||||
|
||||
#define TAILQ_HEAD_INITIALIZER(head) \
|
||||
{ TAILQ_END(head), &(head).tqh_first }
|
||||
|
||||
#define _TAILQ_ENTRY(type, qual) \
|
||||
struct { \
|
||||
qual type *tqe_next; /* next element */ \
|
||||
qual type *qual *tqe_prev; /* address of previous next element */\
|
||||
}
|
||||
#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,)
|
||||
|
||||
/*
|
||||
* Tail queue access methods.
|
||||
*/
|
||||
#define TAILQ_FIRST(head) ((head)->tqh_first)
|
||||
#define TAILQ_END(head) (NULL)
|
||||
#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
|
||||
#define TAILQ_LAST(head, headname) \
|
||||
(*(((struct headname *)(void *)((head)->tqh_last))->tqh_last))
|
||||
#define TAILQ_PREV(elm, headname, field) \
|
||||
(*(((struct headname *)(void *)((elm)->field.tqe_prev))->tqh_last))
|
||||
#define TAILQ_EMPTY(head) (TAILQ_FIRST(head) == TAILQ_END(head))
|
||||
|
||||
|
||||
#define TAILQ_FOREACH(var, head, field) \
|
||||
for ((var) = ((head)->tqh_first); \
|
||||
(var) != TAILQ_END(head); \
|
||||
(var) = ((var)->field.tqe_next))
|
||||
|
||||
#define TAILQ_FOREACH_SAFE(var, head, field, next) \
|
||||
for ((var) = ((head)->tqh_first); \
|
||||
(var) != TAILQ_END(head) && \
|
||||
((next) = TAILQ_NEXT(var, field), 1); (var) = (next))
|
||||
|
||||
#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
|
||||
for ((var) = TAILQ_LAST((head), headname); \
|
||||
(var) != TAILQ_END(head); \
|
||||
(var) = TAILQ_PREV((var), headname, field))
|
||||
|
||||
#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, prev) \
|
||||
for ((var) = TAILQ_LAST((head), headname); \
|
||||
(var) != TAILQ_END(head) && \
|
||||
((prev) = TAILQ_PREV((var), headname, field), 1); (var) = (prev))
|
||||
|
||||
/*
|
||||
* Tail queue functions.
|
||||
*/
|
||||
#if defined(QUEUEDEBUG)
|
||||
#define QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field) \
|
||||
if ((head)->tqh_first && \
|
||||
(head)->tqh_first->field.tqe_prev != &(head)->tqh_first) \
|
||||
QUEUEDEBUG_ABORT("TAILQ_INSERT_HEAD %p %s:%d", (head), \
|
||||
__FILE__, __LINE__);
|
||||
#define QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field) \
|
||||
if (*(head)->tqh_last != NULL) \
|
||||
QUEUEDEBUG_ABORT("TAILQ_INSERT_TAIL %p %s:%d", (head), \
|
||||
__FILE__, __LINE__);
|
||||
#define QUEUEDEBUG_TAILQ_OP(elm, field) \
|
||||
if ((elm)->field.tqe_next && \
|
||||
(elm)->field.tqe_next->field.tqe_prev != \
|
||||
&(elm)->field.tqe_next) \
|
||||
QUEUEDEBUG_ABORT("TAILQ_* forw %p %s:%d", (elm), \
|
||||
__FILE__, __LINE__); \
|
||||
if (*(elm)->field.tqe_prev != (elm)) \
|
||||
QUEUEDEBUG_ABORT("TAILQ_* back %p %s:%d", (elm), \
|
||||
__FILE__, __LINE__);
|
||||
#define QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field) \
|
||||
if ((elm)->field.tqe_next == NULL && \
|
||||
(head)->tqh_last != &(elm)->field.tqe_next) \
|
||||
QUEUEDEBUG_ABORT("TAILQ_PREREMOVE head %p elm %p %s:%d",\
|
||||
(head), (elm), __FILE__, __LINE__);
|
||||
#define QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field) \
|
||||
(elm)->field.tqe_next = (void *)1L; \
|
||||
(elm)->field.tqe_prev = (void *)1L;
|
||||
#else
|
||||
#define QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field)
|
||||
#define QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field)
|
||||
#define QUEUEDEBUG_TAILQ_OP(elm, field)
|
||||
#define QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field)
|
||||
#define QUEUEDEBUG_TAILQ_POSTREMOVE(elm, field)
|
||||
#endif
|
||||
|
||||
#define TAILQ_INIT(head) do { \
|
||||
(head)->tqh_first = TAILQ_END(head); \
|
||||
(head)->tqh_last = &(head)->tqh_first; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define TAILQ_INSERT_HEAD(head, elm, field) do { \
|
||||
QUEUEDEBUG_TAILQ_INSERT_HEAD((head), (elm), field) \
|
||||
if (((elm)->field.tqe_next = (head)->tqh_first) != TAILQ_END(head))\
|
||||
(head)->tqh_first->field.tqe_prev = \
|
||||
&(elm)->field.tqe_next; \
|
||||
else \
|
||||
(head)->tqh_last = &(elm)->field.tqe_next; \
|
||||
(head)->tqh_first = (elm); \
|
||||
(elm)->field.tqe_prev = &(head)->tqh_first; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define TAILQ_INSERT_TAIL(head, elm, field) do { \
|
||||
QUEUEDEBUG_TAILQ_INSERT_TAIL((head), (elm), field) \
|
||||
(elm)->field.tqe_next = TAILQ_END(head); \
|
||||
(elm)->field.tqe_prev = (head)->tqh_last; \
|
||||
*(head)->tqh_last = (elm); \
|
||||
(head)->tqh_last = &(elm)->field.tqe_next; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
QUEUEDEBUG_TAILQ_OP((listelm), field) \
|
||||
if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != \
|
||||
TAILQ_END(head)) \
|
||||
(elm)->field.tqe_next->field.tqe_prev = \
|
||||
&(elm)->field.tqe_next; \
|
||||
else \
|
||||
(head)->tqh_last = &(elm)->field.tqe_next; \
|
||||
(listelm)->field.tqe_next = (elm); \
|
||||
(elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
|
||||
QUEUEDEBUG_TAILQ_OP((listelm), field) \
|
||||
(elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
|
||||
(elm)->field.tqe_next = (listelm); \
|
||||
*(listelm)->field.tqe_prev = (elm); \
|
||||
(listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define TAILQ_REMOVE(head, elm, field) do { \
|
||||
QUEUEDEBUG_TAILQ_PREREMOVE((head), (elm), field) \
|
||||
QUEUEDEBUG_TAILQ_OP((elm), field) \
|
||||
if (((elm)->field.tqe_next) != TAILQ_END(head)) \
|
||||
(elm)->field.tqe_next->field.tqe_prev = \
|
||||
(elm)->field.tqe_prev; \
|
||||
else \
|
||||
(head)->tqh_last = (elm)->field.tqe_prev; \
|
||||
*(elm)->field.tqe_prev = (elm)->field.tqe_next; \
|
||||
QUEUEDEBUG_TAILQ_POSTREMOVE((elm), field); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define TAILQ_REPLACE(head, elm, elm2, field) do { \
|
||||
if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != \
|
||||
TAILQ_END(head)) \
|
||||
(elm2)->field.tqe_next->field.tqe_prev = \
|
||||
&(elm2)->field.tqe_next; \
|
||||
else \
|
||||
(head)->tqh_last = &(elm2)->field.tqe_next; \
|
||||
(elm2)->field.tqe_prev = (elm)->field.tqe_prev; \
|
||||
*(elm2)->field.tqe_prev = (elm2); \
|
||||
QUEUEDEBUG_TAILQ_POSTREMOVE((elm), field); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define TAILQ_CONCAT(head1, head2, field) do { \
|
||||
if (!TAILQ_EMPTY(head2)) { \
|
||||
*(head1)->tqh_last = (head2)->tqh_first; \
|
||||
(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
|
||||
(head1)->tqh_last = (head2)->tqh_last; \
|
||||
TAILQ_INIT((head2)); \
|
||||
} \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
/*
|
||||
* Singly-linked Tail queue declarations.
|
||||
*/
|
||||
#define STAILQ_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *stqh_first; /* first element */ \
|
||||
struct type **stqh_last; /* addr of last next element */ \
|
||||
}
|
||||
|
||||
#define STAILQ_HEAD_INITIALIZER(head) \
|
||||
{ NULL, &(head).stqh_first }
|
||||
|
||||
#define STAILQ_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *stqe_next; /* next element */ \
|
||||
}
|
||||
|
||||
/*
|
||||
* Singly-linked Tail queue access methods.
|
||||
*/
|
||||
#define STAILQ_FIRST(head) ((head)->stqh_first)
|
||||
#define STAILQ_END(head) NULL
|
||||
#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
|
||||
#define STAILQ_EMPTY(head) (STAILQ_FIRST(head) == STAILQ_END(head))
|
||||
|
||||
/*
|
||||
* Singly-linked Tail queue functions.
|
||||
*/
|
||||
#define STAILQ_INIT(head) do { \
|
||||
(head)->stqh_first = NULL; \
|
||||
(head)->stqh_last = &(head)->stqh_first; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define STAILQ_INSERT_HEAD(head, elm, field) do { \
|
||||
if (((elm)->field.stqe_next = (head)->stqh_first) == NULL) \
|
||||
(head)->stqh_last = &(elm)->field.stqe_next; \
|
||||
(head)->stqh_first = (elm); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define STAILQ_INSERT_TAIL(head, elm, field) do { \
|
||||
(elm)->field.stqe_next = NULL; \
|
||||
*(head)->stqh_last = (elm); \
|
||||
(head)->stqh_last = &(elm)->field.stqe_next; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define STAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\
|
||||
(head)->stqh_last = &(elm)->field.stqe_next; \
|
||||
(listelm)->field.stqe_next = (elm); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define STAILQ_REMOVE_HEAD(head, field) do { \
|
||||
if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == NULL) \
|
||||
(head)->stqh_last = &(head)->stqh_first; \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define STAILQ_REMOVE(head, elm, type, field) do { \
|
||||
if ((head)->stqh_first == (elm)) { \
|
||||
STAILQ_REMOVE_HEAD((head), field); \
|
||||
} else { \
|
||||
struct type *curelm = (head)->stqh_first; \
|
||||
while (curelm->field.stqe_next != (elm)) \
|
||||
curelm = curelm->field.stqe_next; \
|
||||
if ((curelm->field.stqe_next = \
|
||||
curelm->field.stqe_next->field.stqe_next) == NULL) \
|
||||
(head)->stqh_last = &(curelm)->field.stqe_next; \
|
||||
} \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define STAILQ_FOREACH(var, head, field) \
|
||||
for ((var) = ((head)->stqh_first); \
|
||||
(var); \
|
||||
(var) = ((var)->field.stqe_next))
|
||||
|
||||
#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = STAILQ_FIRST((head)); \
|
||||
(var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
#define STAILQ_CONCAT(head1, head2) do { \
|
||||
if (!STAILQ_EMPTY((head2))) { \
|
||||
*(head1)->stqh_last = (head2)->stqh_first; \
|
||||
(head1)->stqh_last = (head2)->stqh_last; \
|
||||
STAILQ_INIT((head2)); \
|
||||
} \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define STAILQ_LAST(head, type, field) \
|
||||
(STAILQ_EMPTY((head)) ? \
|
||||
NULL : \
|
||||
((struct type *)(void *) \
|
||||
((char *)((head)->stqh_last) - offsetof(struct type, field))))
|
||||
|
||||
|
||||
#ifndef _KERNEL
|
||||
/*
|
||||
* Circular queue definitions. Do not use. We still keep the macros
|
||||
* for compatibility but because of pointer aliasing issues their use
|
||||
* is discouraged!
|
||||
*/
|
||||
|
||||
/*
|
||||
* __launder_type(): We use this ugly hack to work around the the compiler
|
||||
* noticing that two types may not alias each other and elide tests in code.
|
||||
* We hit this in the CIRCLEQ macros when comparing 'struct name *' and
|
||||
* 'struct type *' (see CIRCLEQ_HEAD()). Modern compilers (such as GCC
|
||||
* 4.8) declare these comparisons as always false, causing the code to
|
||||
* not run as designed.
|
||||
*
|
||||
* This hack is only to be used for comparisons and thus can be fully const.
|
||||
* Do not use for assignment.
|
||||
*
|
||||
* If we ever choose to change the ABI of the CIRCLEQ macros, we could fix
|
||||
* this by changing the head/tail sentinal values, but see the note above
|
||||
* this one.
|
||||
*/
|
||||
static __inline const void * __launder_type(const void *);
|
||||
static __inline const void *
|
||||
__launder_type(const void *__x)
|
||||
{
|
||||
__asm __volatile("" : "+r" (__x));
|
||||
return __x;
|
||||
}
|
||||
|
||||
#if defined(QUEUEDEBUG)
|
||||
#define QUEUEDEBUG_CIRCLEQ_HEAD(head, field) \
|
||||
if ((head)->cqh_first != CIRCLEQ_ENDC(head) && \
|
||||
(head)->cqh_first->field.cqe_prev != CIRCLEQ_ENDC(head)) \
|
||||
QUEUEDEBUG_ABORT("CIRCLEQ head forw %p %s:%d", (head), \
|
||||
__FILE__, __LINE__); \
|
||||
if ((head)->cqh_last != CIRCLEQ_ENDC(head) && \
|
||||
(head)->cqh_last->field.cqe_next != CIRCLEQ_ENDC(head)) \
|
||||
QUEUEDEBUG_ABORT("CIRCLEQ head back %p %s:%d", (head), \
|
||||
__FILE__, __LINE__);
|
||||
#define QUEUEDEBUG_CIRCLEQ_ELM(head, elm, field) \
|
||||
if ((elm)->field.cqe_next == CIRCLEQ_ENDC(head)) { \
|
||||
if ((head)->cqh_last != (elm)) \
|
||||
QUEUEDEBUG_ABORT("CIRCLEQ elm last %p %s:%d", \
|
||||
(elm), __FILE__, __LINE__); \
|
||||
} else { \
|
||||
if ((elm)->field.cqe_next->field.cqe_prev != (elm)) \
|
||||
QUEUEDEBUG_ABORT("CIRCLEQ elm forw %p %s:%d", \
|
||||
(elm), __FILE__, __LINE__); \
|
||||
} \
|
||||
if ((elm)->field.cqe_prev == CIRCLEQ_ENDC(head)) { \
|
||||
if ((head)->cqh_first != (elm)) \
|
||||
QUEUEDEBUG_ABORT("CIRCLEQ elm first %p %s:%d", \
|
||||
(elm), __FILE__, __LINE__); \
|
||||
} else { \
|
||||
if ((elm)->field.cqe_prev->field.cqe_next != (elm)) \
|
||||
QUEUEDEBUG_ABORT("CIRCLEQ elm prev %p %s:%d", \
|
||||
(elm), __FILE__, __LINE__); \
|
||||
}
|
||||
#define QUEUEDEBUG_CIRCLEQ_POSTREMOVE(elm, field) \
|
||||
(elm)->field.cqe_next = (void *)1L; \
|
||||
(elm)->field.cqe_prev = (void *)1L;
|
||||
#else
|
||||
#define QUEUEDEBUG_CIRCLEQ_HEAD(head, field)
|
||||
#define QUEUEDEBUG_CIRCLEQ_ELM(head, elm, field)
|
||||
#define QUEUEDEBUG_CIRCLEQ_POSTREMOVE(elm, field)
|
||||
#endif
|
||||
|
||||
#define CIRCLEQ_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *cqh_first; /* first element */ \
|
||||
struct type *cqh_last; /* last element */ \
|
||||
}
|
||||
|
||||
#define CIRCLEQ_HEAD_INITIALIZER(head) \
|
||||
{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }
|
||||
|
||||
#define CIRCLEQ_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *cqe_next; /* next element */ \
|
||||
struct type *cqe_prev; /* previous element */ \
|
||||
}
|
||||
|
||||
/*
|
||||
* Circular queue functions.
|
||||
*/
|
||||
#define CIRCLEQ_INIT(head) do { \
|
||||
(head)->cqh_first = CIRCLEQ_END(head); \
|
||||
(head)->cqh_last = CIRCLEQ_END(head); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
QUEUEDEBUG_CIRCLEQ_HEAD((head), field) \
|
||||
QUEUEDEBUG_CIRCLEQ_ELM((head), (listelm), field) \
|
||||
(elm)->field.cqe_next = (listelm)->field.cqe_next; \
|
||||
(elm)->field.cqe_prev = (listelm); \
|
||||
if ((listelm)->field.cqe_next == CIRCLEQ_ENDC(head)) \
|
||||
(head)->cqh_last = (elm); \
|
||||
else \
|
||||
(listelm)->field.cqe_next->field.cqe_prev = (elm); \
|
||||
(listelm)->field.cqe_next = (elm); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
|
||||
QUEUEDEBUG_CIRCLEQ_HEAD((head), field) \
|
||||
QUEUEDEBUG_CIRCLEQ_ELM((head), (listelm), field) \
|
||||
(elm)->field.cqe_next = (listelm); \
|
||||
(elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
|
||||
if ((listelm)->field.cqe_prev == CIRCLEQ_ENDC(head)) \
|
||||
(head)->cqh_first = (elm); \
|
||||
else \
|
||||
(listelm)->field.cqe_prev->field.cqe_next = (elm); \
|
||||
(listelm)->field.cqe_prev = (elm); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \
|
||||
QUEUEDEBUG_CIRCLEQ_HEAD((head), field) \
|
||||
(elm)->field.cqe_next = (head)->cqh_first; \
|
||||
(elm)->field.cqe_prev = CIRCLEQ_END(head); \
|
||||
if ((head)->cqh_last == CIRCLEQ_ENDC(head)) \
|
||||
(head)->cqh_last = (elm); \
|
||||
else \
|
||||
(head)->cqh_first->field.cqe_prev = (elm); \
|
||||
(head)->cqh_first = (elm); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \
|
||||
QUEUEDEBUG_CIRCLEQ_HEAD((head), field) \
|
||||
(elm)->field.cqe_next = CIRCLEQ_END(head); \
|
||||
(elm)->field.cqe_prev = (head)->cqh_last; \
|
||||
if ((head)->cqh_first == CIRCLEQ_ENDC(head)) \
|
||||
(head)->cqh_first = (elm); \
|
||||
else \
|
||||
(head)->cqh_last->field.cqe_next = (elm); \
|
||||
(head)->cqh_last = (elm); \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define CIRCLEQ_REMOVE(head, elm, field) do { \
|
||||
QUEUEDEBUG_CIRCLEQ_HEAD((head), field) \
|
||||
QUEUEDEBUG_CIRCLEQ_ELM((head), (elm), field) \
|
||||
if ((elm)->field.cqe_next == CIRCLEQ_ENDC(head)) \
|
||||
(head)->cqh_last = (elm)->field.cqe_prev; \
|
||||
else \
|
||||
(elm)->field.cqe_next->field.cqe_prev = \
|
||||
(elm)->field.cqe_prev; \
|
||||
if ((elm)->field.cqe_prev == CIRCLEQ_ENDC(head)) \
|
||||
(head)->cqh_first = (elm)->field.cqe_next; \
|
||||
else \
|
||||
(elm)->field.cqe_prev->field.cqe_next = \
|
||||
(elm)->field.cqe_next; \
|
||||
QUEUEDEBUG_CIRCLEQ_POSTREMOVE((elm), field) \
|
||||
} while (/*CONSTCOND*/0)
|
||||
|
||||
#define CIRCLEQ_FOREACH(var, head, field) \
|
||||
for ((var) = ((head)->cqh_first); \
|
||||
(var) != CIRCLEQ_ENDC(head); \
|
||||
(var) = ((var)->field.cqe_next))
|
||||
|
||||
#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \
|
||||
for ((var) = ((head)->cqh_last); \
|
||||
(var) != CIRCLEQ_ENDC(head); \
|
||||
(var) = ((var)->field.cqe_prev))
|
||||
|
||||
/*
|
||||
* Circular queue access methods.
|
||||
*/
|
||||
#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
|
||||
#define CIRCLEQ_LAST(head) ((head)->cqh_last)
|
||||
/* For comparisons */
|
||||
#define CIRCLEQ_ENDC(head) (__launder_type(head))
|
||||
/* For assignments */
|
||||
#define CIRCLEQ_END(head) ((void *)(head))
|
||||
#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
|
||||
#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
|
||||
#define CIRCLEQ_EMPTY(head) \
|
||||
(CIRCLEQ_FIRST(head) == CIRCLEQ_ENDC(head))
|
||||
|
||||
#define CIRCLEQ_LOOP_NEXT(head, elm, field) \
|
||||
(((elm)->field.cqe_next == CIRCLEQ_ENDC(head)) \
|
||||
? ((head)->cqh_first) \
|
||||
: (elm->field.cqe_next))
|
||||
#define CIRCLEQ_LOOP_PREV(head, elm, field) \
|
||||
(((elm)->field.cqe_prev == CIRCLEQ_ENDC(head)) \
|
||||
? ((head)->cqh_last) \
|
||||
: (elm->field.cqe_prev))
|
||||
#endif /* !_KERNEL */
|
||||
|
||||
#endif /* !_SYS_QUEUE_H_ */
|
||||
@@ -1,22 +0,0 @@
|
||||
#ifndef _SYS_REDOX_H
|
||||
#define _SYS_REDOX_H
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifdef __redox__
|
||||
|
||||
ssize_t redox_fpath(int fd, void * buf, size_t count);
|
||||
void * redox_physalloc(size_t size);
|
||||
int redox_physfree(void * physical_address, size_t size);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,16 +0,0 @@
|
||||
// From musl, license MIT
|
||||
#ifndef _SYS_SYSMACROS_H
|
||||
#define _SYS_SYSMACROS_H
|
||||
|
||||
#define major(x) \
|
||||
((unsigned)( (((x)>>31>>1) & 0xfffff000) | (((x)>>8) & 0x00000fff) ))
|
||||
#define minor(x) \
|
||||
((unsigned)( (((x)>>12) & 0xffffff00) | ((x) & 0x000000ff) ))
|
||||
|
||||
#define makedev(x,y) ( \
|
||||
(((x)&0xfffff000ULL) << 32) | \
|
||||
(((x)&0x00000fffULL) << 8) | \
|
||||
(((y)&0xffffff00ULL) << 12) | \
|
||||
(((y)&0x000000ffULL)) )
|
||||
|
||||
#endif
|
||||
@@ -1,13 +0,0 @@
|
||||
#ifndef _SYS_USER_H
|
||||
#define _SYS_USER_H
|
||||
#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__) || defined(__x86_64) || defined(_M_AMD64)
|
||||
#include <arch/x64/user.h>
|
||||
#elif defined(__aarch64__)
|
||||
#include <arch/aarch64/user.h>
|
||||
#elif defined(__riscv) && __riscv_xlen==64
|
||||
#include <arch/riscv64/user.h>
|
||||
#else
|
||||
#error "Unknown architecture"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -1,21 +0,0 @@
|
||||
#ifndef _SYSEXITS_H
|
||||
#define _SYSEXITS_H
|
||||
|
||||
#define EX_OK 0
|
||||
#define EX_USAGE 64
|
||||
#define EX_DATAERR 65
|
||||
#define EX_NOINPUT 66
|
||||
#define EX_NOUSER 67
|
||||
#define EX_NOHOST 68
|
||||
#define EX_UNAVAILABLE 69
|
||||
#define EX_SOFTWARE 70
|
||||
#define EX_OSERR 71
|
||||
#define EX_OSFILE 72
|
||||
#define EX_CANTCREAT 73
|
||||
#define EX_IOERR 74
|
||||
#define EX_TEMPFAIL 75
|
||||
#define EX_PROTOCOL 76
|
||||
#define EX_NOPERM 77
|
||||
#define EX_CONFIG 78
|
||||
|
||||
#endif /* _SYSEXITS_H */
|
||||
@@ -1 +0,0 @@
|
||||
#include <sys/syslog.h>
|
||||
@@ -1,12 +0,0 @@
|
||||
[package]
|
||||
name = "ld_so"
|
||||
version = "0.1.0"
|
||||
authors = ["Jeremy Soller <jackpot51@gmail.com>"]
|
||||
edition = "2024"
|
||||
|
||||
[lib]
|
||||
name = "ld_so"
|
||||
crate-type = ["staticlib"]
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
@@ -1,263 +0,0 @@
|
||||
/* Script for -z combreloc */
|
||||
/* Copyright (C) 2014-2025 Free Software Foundation, Inc.
|
||||
Copying and distribution of this script, with or without modification,
|
||||
are permitted in any medium without royalty provided the copyright
|
||||
notice and this notice are preserved. */
|
||||
OUTPUT_FORMAT("elf64-littleaarch64", "elf64-bigaarch64", "elf64-littleaarch64")
|
||||
OUTPUT_ARCH(aarch64)
|
||||
ENTRY(_start)
|
||||
SEARCH_DIR("=/usr/aarch64-linux-gnu/lib64"); SEARCH_DIR("=/usr/local/lib64"); SEARCH_DIR("=/lib64"); SEARCH_DIR("=/usr/lib64"); SEARCH_DIR("=/usr/aarch64-linux-gnu/lib"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib");
|
||||
SECTIONS
|
||||
{
|
||||
/* Read-only sections, merged into text segment: */
|
||||
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000));
|
||||
. = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
|
||||
/* Place the build-id as close to the ELF headers as possible. This
|
||||
maximises the chance the build-id will be present in core files,
|
||||
which GDB can then use to locate the associated debuginfo file. */
|
||||
.note.gnu.build-id : { *(.note.gnu.build-id) }
|
||||
.interp : { *(.interp) }
|
||||
.hash : { *(.hash) }
|
||||
.gnu.hash : { *(.gnu.hash) }
|
||||
.dynsym : { *(.dynsym) }
|
||||
.dynstr : { *(.dynstr) }
|
||||
.gnu.version : { *(.gnu.version) }
|
||||
.gnu.version_d : { *(.gnu.version_d) }
|
||||
.gnu.version_r : { *(.gnu.version_r) }
|
||||
.rela.dyn :
|
||||
{
|
||||
*(.rela.init)
|
||||
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
|
||||
*(.rela.fini)
|
||||
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
|
||||
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
|
||||
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
|
||||
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
|
||||
*(.rela.ctors)
|
||||
*(.rela.dtors)
|
||||
*(.rela.got)
|
||||
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
|
||||
*(.rela.ifunc)
|
||||
}
|
||||
.rela.plt :
|
||||
{
|
||||
*(.rela.plt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_start = .);
|
||||
*(.rela.iplt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_end = .);
|
||||
}
|
||||
.relr.dyn : { *(.relr.dyn) }
|
||||
/* Start of the executable code region. */
|
||||
.init :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.init)))
|
||||
} =0x1f2003d5
|
||||
.plt : ALIGN(16) { *(.plt) *(.iplt) }
|
||||
.text :
|
||||
{
|
||||
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
|
||||
*(.text.exit .text.exit.*)
|
||||
*(.text.startup .text.startup.*)
|
||||
*(.text.hot .text.hot.*)
|
||||
*(SORT(.text.sorted.*))
|
||||
*(.text .stub .text.* .gnu.linkonce.t.*)
|
||||
/* .gnu.warning sections are handled specially by elf.em. */
|
||||
*(.gnu.warning)
|
||||
} =0x1f2003d5
|
||||
.fini :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.fini)))
|
||||
} =0x1f2003d5
|
||||
PROVIDE (__etext = .);
|
||||
PROVIDE (_etext = .);
|
||||
PROVIDE (etext = .);
|
||||
/* Start of the Read Only Data region. */
|
||||
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
|
||||
.rodata1 : { *(.rodata1) }
|
||||
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
|
||||
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.sframe : ONLY_IF_RO { *(.sframe) *(.sframe.*) }
|
||||
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
|
||||
/* These sections are generated by the Sun/Oracle C++ compiler. */
|
||||
.exception_ranges : ONLY_IF_RO { *(.exception_ranges*) }
|
||||
/* Various note sections. Placed here so that they are always included
|
||||
in the read-only segment and not treated as orphan sections. The
|
||||
current orphan handling algorithm does place note sections after R/O
|
||||
data, but this is not guaranteed to always be the case. */
|
||||
.note.build-id : { *(.note.build-id) }
|
||||
.note.GNU-stack : { *(.note.GNU-stack) }
|
||||
.note.gnu-property : { *(.note.gnu-property) }
|
||||
.note.ABI-tag : { *(.note.ABI-tag) }
|
||||
.note.package : { *(.note.package) }
|
||||
.note.dlopen : { *(.note.dlopen) }
|
||||
.note.netbsd.ident : { *(.note.netbsd.ident) }
|
||||
.note.openbsd.ident : { *(.note.openbsd.ident) }
|
||||
/* Start of the Read Write Data region. */
|
||||
/* Adjust the address for the data segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
|
||||
/* Exception handling. */
|
||||
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.sframe : ONLY_IF_RW { *(.sframe) *(.sframe.*) }
|
||||
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
|
||||
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.exception_ranges : ONLY_IF_RW { *(.exception_ranges*) }
|
||||
/* Thread Local Storage sections. */
|
||||
/* .tdata :
|
||||
{
|
||||
PROVIDE_HIDDEN (__tdata_start = .);
|
||||
*(.tdata .tdata.* .gnu.linkonce.td.*)
|
||||
}
|
||||
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } */
|
||||
.preinit_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__preinit_array_start = .);
|
||||
KEEP (*(.preinit_array))
|
||||
PROVIDE_HIDDEN (__preinit_array_end = .);
|
||||
}
|
||||
/* .init_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__init_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
|
||||
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
|
||||
PROVIDE_HIDDEN (__init_array_end = .);
|
||||
} */
|
||||
.fini_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__fini_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
|
||||
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
|
||||
PROVIDE_HIDDEN (__fini_array_end = .);
|
||||
}
|
||||
.ctors :
|
||||
{
|
||||
/* gcc uses crtbegin.o to find the start of
|
||||
the constructors, so we make sure it is
|
||||
first. Because this is a wildcard, it
|
||||
doesn't matter if the user does not
|
||||
actually link against crtbegin.o; the
|
||||
linker won't look for a file to match a
|
||||
wildcard. The wildcard also means that it
|
||||
doesn't matter which directory crtbegin.o
|
||||
is in. */
|
||||
KEEP (*crtbegin.o(.ctors))
|
||||
KEEP (*crtbegin?.o(.ctors))
|
||||
/* We don't want to include the .ctor section from
|
||||
the crtend.o file until after the sorted ctors.
|
||||
The .ctor section from the crtend file contains the
|
||||
end of ctors marker and it must be last */
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
|
||||
KEEP (*(SORT(.ctors.*)))
|
||||
KEEP (*(.ctors))
|
||||
}
|
||||
.dtors :
|
||||
{
|
||||
KEEP (*crtbegin.o(.dtors))
|
||||
KEEP (*crtbegin?.o(.dtors))
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
|
||||
KEEP (*(SORT(.dtors.*)))
|
||||
KEEP (*(.dtors))
|
||||
}
|
||||
.jcr : { KEEP (*(.jcr)) }
|
||||
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
|
||||
.dynamic : { *(.dynamic) }
|
||||
.got : { *(.got) *(.igot) }
|
||||
. = DATA_SEGMENT_RELRO_END (24, .);
|
||||
.got.plt : { *(.got.plt) *(.igot.plt) }
|
||||
.data :
|
||||
{
|
||||
PROVIDE (__data_start = .);
|
||||
*(.data .data.* .gnu.linkonce.d.*)
|
||||
SORT(CONSTRUCTORS)
|
||||
}
|
||||
.data1 : { *(.data1) }
|
||||
_edata = .;
|
||||
PROVIDE (edata = .);
|
||||
. = ALIGN(ALIGNOF(NEXT_SECTION));
|
||||
__bss_start = .;
|
||||
__bss_start__ = .;
|
||||
.bss :
|
||||
{
|
||||
*(.dynbss)
|
||||
*(.bss .bss.* .gnu.linkonce.b.*)
|
||||
*(COMMON)
|
||||
/* Align here to ensure that in the common case of there only being one
|
||||
type of .bss section, the section occupies space up to _end.
|
||||
Align after .bss to ensure correct alignment even if the
|
||||
.bss section disappears because there are no input sections.
|
||||
FIXME: Why do we need it? When there is no .bss section, we do not
|
||||
pad the .data section. */
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
_bss_end__ = .; __bss_end__ = .;
|
||||
. = ALIGN(64 / 8);
|
||||
/* Start of the Large Data region. */
|
||||
. = SEGMENT_START("ldata-segment", .);
|
||||
. = ALIGN(64 / 8);
|
||||
__end__ = .;
|
||||
_end = .;
|
||||
PROVIDE (end = .);
|
||||
. = DATA_SEGMENT_END (.);
|
||||
/* Start of the Tiny Data region. */
|
||||
/* Stabs debugging sections. */
|
||||
.stab 0 : { *(.stab) }
|
||||
.stabstr 0 : { *(.stabstr) }
|
||||
.stab.excl 0 : { *(.stab.excl) }
|
||||
.stab.exclstr 0 : { *(.stab.exclstr) }
|
||||
.stab.index 0 : { *(.stab.index) }
|
||||
.stab.indexstr 0 : { *(.stab.indexstr) }
|
||||
.comment 0 (INFO) : { *(.comment); LINKER_VERSION; }
|
||||
.gnu.build.attributes : { *(.gnu.build.attributes .gnu.build.attributes.*) }
|
||||
/* DWARF debug sections.
|
||||
Symbols in the DWARF debugging sections are relative to the beginning
|
||||
of the section so we begin them at 0. */
|
||||
/* DWARF 1. */
|
||||
.debug 0 : { *(.debug) }
|
||||
.line 0 : { *(.line) }
|
||||
/* GNU DWARF 1 extensions. */
|
||||
.debug_srcinfo 0 : { *(.debug_srcinfo) }
|
||||
.debug_sfnames 0 : { *(.debug_sfnames) }
|
||||
/* DWARF 1.1 and DWARF 2. */
|
||||
.debug_aranges 0 : { *(.debug_aranges) }
|
||||
.debug_pubnames 0 : { *(.debug_pubnames) }
|
||||
/* DWARF 2. */
|
||||
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
|
||||
.debug_abbrev 0 : { *(.debug_abbrev) }
|
||||
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end) }
|
||||
.debug_frame 0 : { *(.debug_frame) }
|
||||
.debug_str 0 : { *(.debug_str) }
|
||||
.debug_loc 0 : { *(.debug_loc) }
|
||||
.debug_macinfo 0 : { *(.debug_macinfo) }
|
||||
/* SGI/MIPS DWARF 2 extensions. */
|
||||
.debug_weaknames 0 : { *(.debug_weaknames) }
|
||||
.debug_funcnames 0 : { *(.debug_funcnames) }
|
||||
.debug_typenames 0 : { *(.debug_typenames) }
|
||||
.debug_varnames 0 : { *(.debug_varnames) }
|
||||
/* DWARF 3. */
|
||||
.debug_pubtypes 0 : { *(.debug_pubtypes) }
|
||||
.debug_ranges 0 : { *(.debug_ranges) }
|
||||
/* DWARF 5. */
|
||||
.debug_addr 0 : { *(.debug_addr) }
|
||||
.debug_line_str 0 : { *(.debug_line_str) }
|
||||
.debug_loclists 0 : { *(.debug_loclists) }
|
||||
.debug_macro 0 : { *(.debug_macro) }
|
||||
.debug_names 0 : { *(.debug_names) }
|
||||
.debug_rnglists 0 : { *(.debug_rnglists) }
|
||||
.debug_str_offsets 0 : { *(.debug_str_offsets) }
|
||||
.debug_sup 0 : { *(.debug_sup) }
|
||||
.ARM.attributes 0 : { KEEP (*(.ARM.attributes)) KEEP (*(.gnu.attributes)) }
|
||||
.note.gnu.arm.ident 0 : { KEEP (*(.note.gnu.arm.ident)) }
|
||||
/DISCARD/ : {
|
||||
*(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*)
|
||||
/*
|
||||
* XXX: As of now, ld.so links with relibc which has the main functionality. In the next refactor,
|
||||
* ld.so will be moved out of relibc. So, till that time, we have to discard any sections
|
||||
* that may reference use thread local storage.
|
||||
*
|
||||
* .init_array also depends on TLS and is discarded as we don't need it.
|
||||
*/
|
||||
*(.gnu.linkonce.tb.*) *(.tcommon)
|
||||
*(.init_array)
|
||||
}
|
||||
}
|
||||
@@ -1,255 +0,0 @@
|
||||
/* Script for -z combreloc */
|
||||
/* Copyright (C) 2014-2020 Free Software Foundation, Inc.
|
||||
Copying and distribution of this script, with or without modification,
|
||||
are permitted in any medium without royalty provided the copyright
|
||||
notice and this notice are preserved. */
|
||||
OUTPUT_FORMAT("elf64-littleaarch64", "elf64-littleaarch64",
|
||||
"elf64-littleaarch64")
|
||||
OUTPUT_ARCH(aarch64)
|
||||
ENTRY(_start)
|
||||
SEARCH_DIR("/aarch64-unknown-redox/lib");
|
||||
SEARCH_DIR("/usr/local/lib64");
|
||||
SEARCH_DIR("/lib64");
|
||||
SEARCH_DIR("/usr/lib64");
|
||||
SEARCH_DIR("/usr/local/lib");
|
||||
SEARCH_DIR("/lib");
|
||||
SEARCH_DIR("/usr/lib");
|
||||
SECTIONS
|
||||
{
|
||||
/* Read-only sections, merged into text segment: */
|
||||
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x20000000) + SIZEOF_HEADERS;
|
||||
.interp : { *(.interp) }
|
||||
.note.gnu.build-id : { *(.note.gnu.build-id) }
|
||||
.hash : { *(.hash) }
|
||||
.gnu.hash : { *(.gnu.hash) }
|
||||
.dynsym : { *(.dynsym) }
|
||||
.dynstr : { *(.dynstr) }
|
||||
.gnu.version : { *(.gnu.version) }
|
||||
.gnu.version_d : { *(.gnu.version_d) }
|
||||
.gnu.version_r : { *(.gnu.version_r) }
|
||||
.rela.dyn :
|
||||
{
|
||||
*(.rela.init)
|
||||
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
|
||||
*(.rela.fini)
|
||||
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
|
||||
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
|
||||
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
|
||||
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
|
||||
*(.rela.ctors)
|
||||
*(.rela.dtors)
|
||||
*(.rela.got)
|
||||
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
|
||||
*(.rela.ldata .rela.ldata.* .rela.gnu.linkonce.l.*)
|
||||
*(.rela.lbss .rela.lbss.* .rela.gnu.linkonce.lb.*)
|
||||
*(.rela.lrodata .rela.lrodata.* .rela.gnu.linkonce.lr.*)
|
||||
*(.rela.ifunc)
|
||||
}
|
||||
.rela.plt :
|
||||
{
|
||||
*(.rela.plt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_start = .);
|
||||
*(.rela.iplt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_end = .);
|
||||
}
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
.init :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.init)))
|
||||
}
|
||||
.plt : { *(.plt) *(.iplt) }
|
||||
.plt.got : { *(.plt.got) }
|
||||
.plt.sec : { *(.plt.sec) }
|
||||
.text :
|
||||
{
|
||||
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
|
||||
*(.text.exit .text.exit.*)
|
||||
*(.text.startup .text.startup.*)
|
||||
*(.text.hot .text.hot.*)
|
||||
*(.text .stub .text.* .gnu.linkonce.t.*)
|
||||
/* .gnu.warning sections are handled specially by elf.em. */
|
||||
*(.gnu.warning)
|
||||
}
|
||||
.fini :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.fini)))
|
||||
}
|
||||
PROVIDE (__etext = .);
|
||||
PROVIDE (_etext = .);
|
||||
PROVIDE (etext = .);
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
/* Adjust the address for the rodata segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = SEGMENT_START("rodata-segment", ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)));
|
||||
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
|
||||
.rodata1 : { *(.rodata1) }
|
||||
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
|
||||
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
|
||||
/* These sections are generated by the Sun/Oracle C++ compiler. */
|
||||
.exception_ranges : ONLY_IF_RO { *(.exception_ranges*) }
|
||||
/* Adjust the address for the data segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
|
||||
/* Exception handling */
|
||||
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
|
||||
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.exception_ranges : ONLY_IF_RW { *(.exception_ranges*) }
|
||||
/* Thread Local Storage sections */
|
||||
/* .tdata :
|
||||
{
|
||||
PROVIDE_HIDDEN (__tdata_start = .);
|
||||
*(.tdata .tdata.* .gnu.linkonce.td.*)
|
||||
}
|
||||
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } */
|
||||
.preinit_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__preinit_array_start = .);
|
||||
KEEP (*(.preinit_array))
|
||||
PROVIDE_HIDDEN (__preinit_array_end = .);
|
||||
}
|
||||
.init_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__init_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
|
||||
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
|
||||
PROVIDE_HIDDEN (__init_array_end = .);
|
||||
}
|
||||
.fini_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__fini_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
|
||||
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
|
||||
PROVIDE_HIDDEN (__fini_array_end = .);
|
||||
}
|
||||
.ctors :
|
||||
{
|
||||
/* gcc uses crtbegin.o to find the start of
|
||||
the constructors, so we make sure it is
|
||||
first. Because this is a wildcard, it
|
||||
doesn't matter if the user does not
|
||||
actually link against crtbegin.o; the
|
||||
linker won't look for a file to match a
|
||||
wildcard. The wildcard also means that it
|
||||
doesn't matter which directory crtbegin.o
|
||||
is in. */
|
||||
KEEP (*crtbegin.o(.ctors))
|
||||
KEEP (*crtbegin?.o(.ctors))
|
||||
/* We don't want to include the .ctor section from
|
||||
the crtend.o file until after the sorted ctors.
|
||||
The .ctor section from the crtend file contains the
|
||||
end of ctors marker and it must be last */
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
|
||||
KEEP (*(SORT(.ctors.*)))
|
||||
KEEP (*(.ctors))
|
||||
}
|
||||
.dtors :
|
||||
{
|
||||
KEEP (*crtbegin.o(.dtors))
|
||||
KEEP (*crtbegin?.o(.dtors))
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
|
||||
KEEP (*(SORT(.dtors.*)))
|
||||
KEEP (*(.dtors))
|
||||
}
|
||||
.jcr : { KEEP (*(.jcr)) }
|
||||
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
|
||||
.dynamic : { *(.dynamic) }
|
||||
.got : { *(.got) *(.igot) }
|
||||
. = DATA_SEGMENT_RELRO_END (SIZEOF (.got.plt) >= 24 ? 24 : 0, .);
|
||||
.got.plt : { *(.got.plt) *(.igot.plt) }
|
||||
.data :
|
||||
{
|
||||
*(.data .data.* .gnu.linkonce.d.*)
|
||||
SORT(CONSTRUCTORS)
|
||||
}
|
||||
.data1 : { *(.data1) }
|
||||
_edata = .; PROVIDE (edata = .);
|
||||
. = .;
|
||||
__bss_start = .;
|
||||
.bss :
|
||||
{
|
||||
*(.dynbss)
|
||||
*(.bss .bss.* .gnu.linkonce.b.*)
|
||||
*(COMMON)
|
||||
/* Align here to ensure that the .bss section occupies space up to
|
||||
_end. Align after .bss to ensure correct alignment even if the
|
||||
.bss section disappears because there are no input sections.
|
||||
FIXME: Why do we need it? When there is no .bss section, we do not
|
||||
pad the .data section. */
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
.lbss :
|
||||
{
|
||||
*(.dynlbss)
|
||||
*(.lbss .lbss.* .gnu.linkonce.lb.*)
|
||||
*(LARGE_COMMON)
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
. = SEGMENT_START("ldata-segment", .);
|
||||
.lrodata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.lrodata .lrodata.* .gnu.linkonce.lr.*)
|
||||
}
|
||||
.ldata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.ldata .ldata.* .gnu.linkonce.l.*)
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
_end = .; PROVIDE (end = .);
|
||||
. = DATA_SEGMENT_END (.);
|
||||
/* Stabs debugging sections. */
|
||||
.stab 0 : { *(.stab) }
|
||||
.stabstr 0 : { *(.stabstr) }
|
||||
.stab.excl 0 : { *(.stab.excl) }
|
||||
.stab.exclstr 0 : { *(.stab.exclstr) }
|
||||
.stab.index 0 : { *(.stab.index) }
|
||||
.stab.indexstr 0 : { *(.stab.indexstr) }
|
||||
.comment 0 : { *(.comment) }
|
||||
.gnu.build.attributes : { *(.gnu.build.attributes .gnu.build.attributes.*) }
|
||||
/* DWARF debug sections.
|
||||
Symbols in the DWARF debugging sections are relative to the beginning
|
||||
of the section so we begin them at 0. */
|
||||
/* DWARF 1 */
|
||||
.debug 0 : { *(.debug) }
|
||||
.line 0 : { *(.line) }
|
||||
/* GNU DWARF 1 extensions */
|
||||
.debug_srcinfo 0 : { *(.debug_srcinfo) }
|
||||
.debug_sfnames 0 : { *(.debug_sfnames) }
|
||||
/* DWARF 1.1 and DWARF 2 */
|
||||
.debug_aranges 0 : { *(.debug_aranges) }
|
||||
.debug_pubnames 0 : { *(.debug_pubnames) }
|
||||
/* DWARF 2 */
|
||||
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
|
||||
.debug_abbrev 0 : { *(.debug_abbrev) }
|
||||
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end) }
|
||||
.debug_frame 0 : { *(.debug_frame) }
|
||||
.debug_str 0 : { *(.debug_str) }
|
||||
.debug_loc 0 : { *(.debug_loc) }
|
||||
.debug_macinfo 0 : { *(.debug_macinfo) }
|
||||
/* SGI/MIPS DWARF 2 extensions */
|
||||
.debug_weaknames 0 : { *(.debug_weaknames) }
|
||||
.debug_funcnames 0 : { *(.debug_funcnames) }
|
||||
.debug_typenames 0 : { *(.debug_typenames) }
|
||||
.debug_varnames 0 : { *(.debug_varnames) }
|
||||
/* DWARF 3 */
|
||||
.debug_pubtypes 0 : { *(.debug_pubtypes) }
|
||||
.debug_ranges 0 : { *(.debug_ranges) }
|
||||
/* DWARF Extension. */
|
||||
.debug_macro 0 : { *(.debug_macro) }
|
||||
.debug_addr 0 : { *(.debug_addr) }
|
||||
.gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
|
||||
/DISCARD/ : {
|
||||
*(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*)
|
||||
/*
|
||||
* XXX: As of now, ld.so links with relibc which has the main functionality. In the next refactor,
|
||||
* ld.so will be moved out of relibc. So, till that time, we have to discard any sections
|
||||
* that may reference use thread local storage.
|
||||
*
|
||||
* .init_array need to be not discarded unlike x86_64 linker variant
|
||||
*/
|
||||
*(.gnu.linkonce.tb.*) *(.tcommon)
|
||||
}
|
||||
}
|
||||
@@ -1,256 +0,0 @@
|
||||
/* Script for -z combreloc */
|
||||
/* Copyright (C) 2014-2020 Free Software Foundation, Inc.
|
||||
Copying and distribution of this script, with or without modification,
|
||||
are permitted in any medium without royalty provided the copyright
|
||||
notice and this notice are preserved. */
|
||||
OUTPUT_FORMAT("elf32-i386", "elf32-i386",
|
||||
"elf32-i386")
|
||||
OUTPUT_ARCH(i386)
|
||||
ENTRY(_start)
|
||||
SEARCH_DIR("/i686-unknown-redox/lib");
|
||||
SEARCH_DIR("/usr/local/lib32");
|
||||
SEARCH_DIR("/lib32");
|
||||
SEARCH_DIR("/usr/lib32");
|
||||
SEARCH_DIR("/usr/local/lib");
|
||||
SEARCH_DIR("/lib");
|
||||
SEARCH_DIR("/usr/lib");
|
||||
SECTIONS
|
||||
{
|
||||
/* Read-only sections, merged into text segment: */
|
||||
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x20000000) + SIZEOF_HEADERS;
|
||||
.interp : { *(.interp) }
|
||||
.note.gnu.build-id : { *(.note.gnu.build-id) }
|
||||
.hash : { *(.hash) }
|
||||
.gnu.hash : { *(.gnu.hash) }
|
||||
.dynsym : { *(.dynsym) }
|
||||
.dynstr : { *(.dynstr) }
|
||||
.gnu.version : { *(.gnu.version) }
|
||||
.gnu.version_d : { *(.gnu.version_d) }
|
||||
.gnu.version_r : { *(.gnu.version_r) }
|
||||
.rela.dyn :
|
||||
{
|
||||
*(.rela.init)
|
||||
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
|
||||
*(.rela.fini)
|
||||
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
|
||||
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
|
||||
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
|
||||
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
|
||||
*(.rela.ctors)
|
||||
*(.rela.dtors)
|
||||
*(.rela.got)
|
||||
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
|
||||
*(.rela.ldata .rela.ldata.* .rela.gnu.linkonce.l.*)
|
||||
*(.rela.lbss .rela.lbss.* .rela.gnu.linkonce.lb.*)
|
||||
*(.rela.lrodata .rela.lrodata.* .rela.gnu.linkonce.lr.*)
|
||||
*(.rela.ifunc)
|
||||
}
|
||||
.rela.plt :
|
||||
{
|
||||
*(.rela.plt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_start = .);
|
||||
*(.rela.iplt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_end = .);
|
||||
}
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
.init :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.init)))
|
||||
}
|
||||
.plt : { *(.plt) *(.iplt) }
|
||||
.plt.got : { *(.plt.got) }
|
||||
.plt.sec : { *(.plt.sec) }
|
||||
.text :
|
||||
{
|
||||
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
|
||||
*(.text.exit .text.exit.*)
|
||||
*(.text.startup .text.startup.*)
|
||||
*(.text.hot .text.hot.*)
|
||||
*(.text .stub .text.* .gnu.linkonce.t.*)
|
||||
/* .gnu.warning sections are handled specially by elf.em. */
|
||||
*(.gnu.warning)
|
||||
}
|
||||
.fini :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.fini)))
|
||||
}
|
||||
PROVIDE (__etext = .);
|
||||
PROVIDE (_etext = .);
|
||||
PROVIDE (etext = .);
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
/* Adjust the address for the rodata segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = SEGMENT_START("rodata-segment", ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)));
|
||||
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
|
||||
.rodata1 : { *(.rodata1) }
|
||||
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
|
||||
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
|
||||
/* These sections are generated by the Sun/Oracle C++ compiler. */
|
||||
.exception_ranges : ONLY_IF_RO { *(.exception_ranges*) }
|
||||
/* Adjust the address for the data segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
|
||||
/* Exception handling */
|
||||
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
|
||||
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.exception_ranges : ONLY_IF_RW { *(.exception_ranges*) }
|
||||
/* Thread Local Storage sections */
|
||||
/* .tdata :
|
||||
{
|
||||
PROVIDE_HIDDEN (__tdata_start = .);
|
||||
*(.tdata .tdata.* .gnu.linkonce.td.*)
|
||||
}
|
||||
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } */
|
||||
.preinit_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__preinit_array_start = .);
|
||||
KEEP (*(.preinit_array))
|
||||
PROVIDE_HIDDEN (__preinit_array_end = .);
|
||||
}
|
||||
/* .init_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__init_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
|
||||
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
|
||||
PROVIDE_HIDDEN (__init_array_end = .);
|
||||
} */
|
||||
.fini_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__fini_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
|
||||
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
|
||||
PROVIDE_HIDDEN (__fini_array_end = .);
|
||||
}
|
||||
.ctors :
|
||||
{
|
||||
/* gcc uses crtbegin.o to find the start of
|
||||
the constructors, so we make sure it is
|
||||
first. Because this is a wildcard, it
|
||||
doesn't matter if the user does not
|
||||
actually link against crtbegin.o; the
|
||||
linker won't look for a file to match a
|
||||
wildcard. The wildcard also means that it
|
||||
doesn't matter which directory crtbegin.o
|
||||
is in. */
|
||||
KEEP (*crtbegin.o(.ctors))
|
||||
KEEP (*crtbegin?.o(.ctors))
|
||||
/* We don't want to include the .ctor section from
|
||||
the crtend.o file until after the sorted ctors.
|
||||
The .ctor section from the crtend file contains the
|
||||
end of ctors marker and it must be last */
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
|
||||
KEEP (*(SORT(.ctors.*)))
|
||||
KEEP (*(.ctors))
|
||||
}
|
||||
.dtors :
|
||||
{
|
||||
KEEP (*crtbegin.o(.dtors))
|
||||
KEEP (*crtbegin?.o(.dtors))
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
|
||||
KEEP (*(SORT(.dtors.*)))
|
||||
KEEP (*(.dtors))
|
||||
}
|
||||
.jcr : { KEEP (*(.jcr)) }
|
||||
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
|
||||
.dynamic : { *(.dynamic) }
|
||||
.got : { *(.got) *(.igot) }
|
||||
. = DATA_SEGMENT_RELRO_END (SIZEOF (.got.plt) >= 24 ? 24 : 0, .);
|
||||
.got.plt : { *(.got.plt) *(.igot.plt) }
|
||||
.data :
|
||||
{
|
||||
*(.data .data.* .gnu.linkonce.d.*)
|
||||
SORT(CONSTRUCTORS)
|
||||
}
|
||||
.data1 : { *(.data1) }
|
||||
_edata = .; PROVIDE (edata = .);
|
||||
. = .;
|
||||
__bss_start = .;
|
||||
.bss :
|
||||
{
|
||||
*(.dynbss)
|
||||
*(.bss .bss.* .gnu.linkonce.b.*)
|
||||
*(COMMON)
|
||||
/* Align here to ensure that the .bss section occupies space up to
|
||||
_end. Align after .bss to ensure correct alignment even if the
|
||||
.bss section disappears because there are no input sections.
|
||||
FIXME: Why do we need it? When there is no .bss section, we do not
|
||||
pad the .data section. */
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
.lbss :
|
||||
{
|
||||
*(.dynlbss)
|
||||
*(.lbss .lbss.* .gnu.linkonce.lb.*)
|
||||
*(LARGE_COMMON)
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
. = SEGMENT_START("ldata-segment", .);
|
||||
.lrodata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.lrodata .lrodata.* .gnu.linkonce.lr.*)
|
||||
}
|
||||
.ldata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.ldata .ldata.* .gnu.linkonce.l.*)
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
_end = .; PROVIDE (end = .);
|
||||
. = DATA_SEGMENT_END (.);
|
||||
/* Stabs debugging sections. */
|
||||
.stab 0 : { *(.stab) }
|
||||
.stabstr 0 : { *(.stabstr) }
|
||||
.stab.excl 0 : { *(.stab.excl) }
|
||||
.stab.exclstr 0 : { *(.stab.exclstr) }
|
||||
.stab.index 0 : { *(.stab.index) }
|
||||
.stab.indexstr 0 : { *(.stab.indexstr) }
|
||||
.comment 0 : { *(.comment) }
|
||||
.gnu.build.attributes : { *(.gnu.build.attributes .gnu.build.attributes.*) }
|
||||
/* DWARF debug sections.
|
||||
Symbols in the DWARF debugging sections are relative to the beginning
|
||||
of the section so we begin them at 0. */
|
||||
/* DWARF 1 */
|
||||
.debug 0 : { *(.debug) }
|
||||
.line 0 : { *(.line) }
|
||||
/* GNU DWARF 1 extensions */
|
||||
.debug_srcinfo 0 : { *(.debug_srcinfo) }
|
||||
.debug_sfnames 0 : { *(.debug_sfnames) }
|
||||
/* DWARF 1.1 and DWARF 2 */
|
||||
.debug_aranges 0 : { *(.debug_aranges) }
|
||||
.debug_pubnames 0 : { *(.debug_pubnames) }
|
||||
/* DWARF 2 */
|
||||
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
|
||||
.debug_abbrev 0 : { *(.debug_abbrev) }
|
||||
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end) }
|
||||
.debug_frame 0 : { *(.debug_frame) }
|
||||
.debug_str 0 : { *(.debug_str) }
|
||||
.debug_loc 0 : { *(.debug_loc) }
|
||||
.debug_macinfo 0 : { *(.debug_macinfo) }
|
||||
/* SGI/MIPS DWARF 2 extensions */
|
||||
.debug_weaknames 0 : { *(.debug_weaknames) }
|
||||
.debug_funcnames 0 : { *(.debug_funcnames) }
|
||||
.debug_typenames 0 : { *(.debug_typenames) }
|
||||
.debug_varnames 0 : { *(.debug_varnames) }
|
||||
/* DWARF 3 */
|
||||
.debug_pubtypes 0 : { *(.debug_pubtypes) }
|
||||
.debug_ranges 0 : { *(.debug_ranges) }
|
||||
/* DWARF Extension. */
|
||||
.debug_macro 0 : { *(.debug_macro) }
|
||||
.debug_addr 0 : { *(.debug_addr) }
|
||||
.gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
|
||||
/DISCARD/ : {
|
||||
*(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*)
|
||||
/*
|
||||
* XXX: As of now, ld.so links with relibc which has the main functionality. In the next refactor,
|
||||
* ld.so will be moved out of relibc. So, till that time, we have to discard any sections
|
||||
* that may reference use thread local storage.
|
||||
*
|
||||
* .init_array also depends on TLS and is discarded as we don't need it.
|
||||
*/
|
||||
*(.gnu.linkonce.tb.*) *(.tcommon)
|
||||
*(.init_array)
|
||||
}
|
||||
}
|
||||
@@ -1,256 +0,0 @@
|
||||
/* Script for -z combreloc */
|
||||
/* Copyright (C) 2014-2020 Free Software Foundation, Inc.
|
||||
Copying and distribution of this script, with or without modification,
|
||||
are permitted in any medium without royalty provided the copyright
|
||||
notice and this notice are preserved. */
|
||||
OUTPUT_FORMAT("elf32-i386", "elf32-i386",
|
||||
"elf32-i386")
|
||||
OUTPUT_ARCH(i386)
|
||||
ENTRY(_start)
|
||||
SEARCH_DIR("/i686-unknown-redox/lib");
|
||||
SEARCH_DIR("/usr/local/lib32");
|
||||
SEARCH_DIR("/lib32");
|
||||
SEARCH_DIR("/usr/lib32");
|
||||
SEARCH_DIR("/usr/local/lib");
|
||||
SEARCH_DIR("/lib");
|
||||
SEARCH_DIR("/usr/lib");
|
||||
SECTIONS
|
||||
{
|
||||
/* Read-only sections, merged into text segment: */
|
||||
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x20000000) + SIZEOF_HEADERS;
|
||||
.interp : { *(.interp) }
|
||||
.note.gnu.build-id : { *(.note.gnu.build-id) }
|
||||
.hash : { *(.hash) }
|
||||
.gnu.hash : { *(.gnu.hash) }
|
||||
.dynsym : { *(.dynsym) }
|
||||
.dynstr : { *(.dynstr) }
|
||||
.gnu.version : { *(.gnu.version) }
|
||||
.gnu.version_d : { *(.gnu.version_d) }
|
||||
.gnu.version_r : { *(.gnu.version_r) }
|
||||
.rela.dyn :
|
||||
{
|
||||
*(.rela.init)
|
||||
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
|
||||
*(.rela.fini)
|
||||
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
|
||||
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
|
||||
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
|
||||
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
|
||||
*(.rela.ctors)
|
||||
*(.rela.dtors)
|
||||
*(.rela.got)
|
||||
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
|
||||
*(.rela.ldata .rela.ldata.* .rela.gnu.linkonce.l.*)
|
||||
*(.rela.lbss .rela.lbss.* .rela.gnu.linkonce.lb.*)
|
||||
*(.rela.lrodata .rela.lrodata.* .rela.gnu.linkonce.lr.*)
|
||||
*(.rela.ifunc)
|
||||
}
|
||||
.rela.plt :
|
||||
{
|
||||
*(.rela.plt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_start = .);
|
||||
*(.rela.iplt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_end = .);
|
||||
}
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
.init :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.init)))
|
||||
}
|
||||
.plt : { *(.plt) *(.iplt) }
|
||||
.plt.got : { *(.plt.got) }
|
||||
.plt.sec : { *(.plt.sec) }
|
||||
.text :
|
||||
{
|
||||
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
|
||||
*(.text.exit .text.exit.*)
|
||||
*(.text.startup .text.startup.*)
|
||||
*(.text.hot .text.hot.*)
|
||||
*(.text .stub .text.* .gnu.linkonce.t.*)
|
||||
/* .gnu.warning sections are handled specially by elf.em. */
|
||||
*(.gnu.warning)
|
||||
}
|
||||
.fini :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.fini)))
|
||||
}
|
||||
PROVIDE (__etext = .);
|
||||
PROVIDE (_etext = .);
|
||||
PROVIDE (etext = .);
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
/* Adjust the address for the rodata segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = SEGMENT_START("rodata-segment", ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)));
|
||||
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
|
||||
.rodata1 : { *(.rodata1) }
|
||||
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
|
||||
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
|
||||
/* These sections are generated by the Sun/Oracle C++ compiler. */
|
||||
.exception_ranges : ONLY_IF_RO { *(.exception_ranges*) }
|
||||
/* Adjust the address for the data segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
|
||||
/* Exception handling */
|
||||
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
|
||||
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.exception_ranges : ONLY_IF_RW { *(.exception_ranges*) }
|
||||
/* Thread Local Storage sections */
|
||||
/* .tdata :
|
||||
{
|
||||
PROVIDE_HIDDEN (__tdata_start = .);
|
||||
*(.tdata .tdata.* .gnu.linkonce.td.*)
|
||||
}
|
||||
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } */
|
||||
.preinit_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__preinit_array_start = .);
|
||||
KEEP (*(.preinit_array))
|
||||
PROVIDE_HIDDEN (__preinit_array_end = .);
|
||||
}
|
||||
/* .init_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__init_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
|
||||
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
|
||||
PROVIDE_HIDDEN (__init_array_end = .);
|
||||
} */
|
||||
.fini_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__fini_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
|
||||
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
|
||||
PROVIDE_HIDDEN (__fini_array_end = .);
|
||||
}
|
||||
.ctors :
|
||||
{
|
||||
/* gcc uses crtbegin.o to find the start of
|
||||
the constructors, so we make sure it is
|
||||
first. Because this is a wildcard, it
|
||||
doesn't matter if the user does not
|
||||
actually link against crtbegin.o; the
|
||||
linker won't look for a file to match a
|
||||
wildcard. The wildcard also means that it
|
||||
doesn't matter which directory crtbegin.o
|
||||
is in. */
|
||||
KEEP (*crtbegin.o(.ctors))
|
||||
KEEP (*crtbegin?.o(.ctors))
|
||||
/* We don't want to include the .ctor section from
|
||||
the crtend.o file until after the sorted ctors.
|
||||
The .ctor section from the crtend file contains the
|
||||
end of ctors marker and it must be last */
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
|
||||
KEEP (*(SORT(.ctors.*)))
|
||||
KEEP (*(.ctors))
|
||||
}
|
||||
.dtors :
|
||||
{
|
||||
KEEP (*crtbegin.o(.dtors))
|
||||
KEEP (*crtbegin?.o(.dtors))
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
|
||||
KEEP (*(SORT(.dtors.*)))
|
||||
KEEP (*(.dtors))
|
||||
}
|
||||
.jcr : { KEEP (*(.jcr)) }
|
||||
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
|
||||
.dynamic : { *(.dynamic) }
|
||||
.got : { *(.got) *(.igot) }
|
||||
. = DATA_SEGMENT_RELRO_END (SIZEOF (.got.plt) >= 24 ? 24 : 0, .);
|
||||
.got.plt : { *(.got.plt) *(.igot.plt) }
|
||||
.data :
|
||||
{
|
||||
*(.data .data.* .gnu.linkonce.d.*)
|
||||
SORT(CONSTRUCTORS)
|
||||
}
|
||||
.data1 : { *(.data1) }
|
||||
_edata = .; PROVIDE (edata = .);
|
||||
. = .;
|
||||
__bss_start = .;
|
||||
.bss :
|
||||
{
|
||||
*(.dynbss)
|
||||
*(.bss .bss.* .gnu.linkonce.b.*)
|
||||
*(COMMON)
|
||||
/* Align here to ensure that the .bss section occupies space up to
|
||||
_end. Align after .bss to ensure correct alignment even if the
|
||||
.bss section disappears because there are no input sections.
|
||||
FIXME: Why do we need it? When there is no .bss section, we do not
|
||||
pad the .data section. */
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
.lbss :
|
||||
{
|
||||
*(.dynlbss)
|
||||
*(.lbss .lbss.* .gnu.linkonce.lb.*)
|
||||
*(LARGE_COMMON)
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
. = SEGMENT_START("ldata-segment", .);
|
||||
.lrodata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.lrodata .lrodata.* .gnu.linkonce.lr.*)
|
||||
}
|
||||
.ldata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.ldata .ldata.* .gnu.linkonce.l.*)
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
_end = .; PROVIDE (end = .);
|
||||
. = DATA_SEGMENT_END (.);
|
||||
/* Stabs debugging sections. */
|
||||
.stab 0 : { *(.stab) }
|
||||
.stabstr 0 : { *(.stabstr) }
|
||||
.stab.excl 0 : { *(.stab.excl) }
|
||||
.stab.exclstr 0 : { *(.stab.exclstr) }
|
||||
.stab.index 0 : { *(.stab.index) }
|
||||
.stab.indexstr 0 : { *(.stab.indexstr) }
|
||||
.comment 0 : { *(.comment) }
|
||||
.gnu.build.attributes : { *(.gnu.build.attributes .gnu.build.attributes.*) }
|
||||
/* DWARF debug sections.
|
||||
Symbols in the DWARF debugging sections are relative to the beginning
|
||||
of the section so we begin them at 0. */
|
||||
/* DWARF 1 */
|
||||
.debug 0 : { *(.debug) }
|
||||
.line 0 : { *(.line) }
|
||||
/* GNU DWARF 1 extensions */
|
||||
.debug_srcinfo 0 : { *(.debug_srcinfo) }
|
||||
.debug_sfnames 0 : { *(.debug_sfnames) }
|
||||
/* DWARF 1.1 and DWARF 2 */
|
||||
.debug_aranges 0 : { *(.debug_aranges) }
|
||||
.debug_pubnames 0 : { *(.debug_pubnames) }
|
||||
/* DWARF 2 */
|
||||
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
|
||||
.debug_abbrev 0 : { *(.debug_abbrev) }
|
||||
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end) }
|
||||
.debug_frame 0 : { *(.debug_frame) }
|
||||
.debug_str 0 : { *(.debug_str) }
|
||||
.debug_loc 0 : { *(.debug_loc) }
|
||||
.debug_macinfo 0 : { *(.debug_macinfo) }
|
||||
/* SGI/MIPS DWARF 2 extensions */
|
||||
.debug_weaknames 0 : { *(.debug_weaknames) }
|
||||
.debug_funcnames 0 : { *(.debug_funcnames) }
|
||||
.debug_typenames 0 : { *(.debug_typenames) }
|
||||
.debug_varnames 0 : { *(.debug_varnames) }
|
||||
/* DWARF 3 */
|
||||
.debug_pubtypes 0 : { *(.debug_pubtypes) }
|
||||
.debug_ranges 0 : { *(.debug_ranges) }
|
||||
/* DWARF Extension. */
|
||||
.debug_macro 0 : { *(.debug_macro) }
|
||||
.debug_addr 0 : { *(.debug_addr) }
|
||||
.gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
|
||||
/DISCARD/ : {
|
||||
*(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*)
|
||||
/*
|
||||
* XXX: As of now, ld.so links with relibc which has the main functionality. In the next refactor,
|
||||
* ld.so will be moved out of relibc. So, till that time, we have to discard any sections
|
||||
* that may reference use thread local storage.
|
||||
*
|
||||
* .init_array also depends on TLS and is discarded as we don't need it.
|
||||
*/
|
||||
*(.gnu.linkonce.tb.*) *(.tcommon)
|
||||
*(.init_array)
|
||||
}
|
||||
}
|
||||
@@ -1,247 +0,0 @@
|
||||
/* Script for -z combreloc */
|
||||
/* Copyright (C) 2014-2020 Free Software Foundation, Inc.
|
||||
Copying and distribution of this script, with or without modification,
|
||||
are permitted in any medium without royalty provided the copyright
|
||||
notice and this notice are preserved. */
|
||||
OUTPUT_FORMAT("elf64-littleriscv", "elf64-littleriscv", "elf64-littleriscv" )
|
||||
OUTPUT_ARCH(riscv)
|
||||
ENTRY(_start)
|
||||
SEARCH_DIR("/riscv64-unknown-redox/lib");
|
||||
SEARCH_DIR("/usr/local/lib64");
|
||||
SEARCH_DIR("/lib64");
|
||||
SEARCH_DIR("/usr/lib64");
|
||||
SEARCH_DIR("/usr/local/lib");
|
||||
SEARCH_DIR("/lib");
|
||||
SEARCH_DIR("/usr/lib");
|
||||
SECTIONS
|
||||
{
|
||||
/* Read-only sections, merged into text segment: */
|
||||
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x20000000) + SIZEOF_HEADERS;
|
||||
.interp : { *(.interp) }
|
||||
.note.gnu.build-id : { *(.note.gnu.build-id) }
|
||||
.hash : { *(.hash) }
|
||||
.gnu.hash : { *(.gnu.hash) }
|
||||
.dynsym : { *(.dynsym) }
|
||||
.dynstr : { *(.dynstr) }
|
||||
.gnu.version : { *(.gnu.version) }
|
||||
.gnu.version_d : { *(.gnu.version_d) }
|
||||
.gnu.version_r : { *(.gnu.version_r) }
|
||||
.rela.dyn :
|
||||
{
|
||||
*(.rela.init)
|
||||
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
|
||||
*(.rela.fini)
|
||||
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
|
||||
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
|
||||
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
|
||||
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
|
||||
*(.rela.ctors)
|
||||
*(.rela.dtors)
|
||||
*(.rela.got)
|
||||
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
|
||||
*(.rela.ldata .rela.ldata.* .rela.gnu.linkonce.l.*)
|
||||
*(.rela.lbss .rela.lbss.* .rela.gnu.linkonce.lb.*)
|
||||
*(.rela.lrodata .rela.lrodata.* .rela.gnu.linkonce.lr.*)
|
||||
*(.rela.ifunc)
|
||||
}
|
||||
.rela.plt :
|
||||
{
|
||||
*(.rela.plt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_start = .);
|
||||
*(.rela.iplt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_end = .);
|
||||
}
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
.plt : { *(.plt) *(.iplt) }
|
||||
.plt.got : { *(.plt.got) }
|
||||
.plt.sec : { *(.plt.sec) }
|
||||
.text :
|
||||
{
|
||||
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
|
||||
*(.text.exit .text.exit.*)
|
||||
*(.text.startup .text.startup.*)
|
||||
*(.text.hot .text.hot.*)
|
||||
*(.text .stub .text.* .gnu.linkonce.t.*)
|
||||
/* .gnu.warning sections are handled specially by elf.em. */
|
||||
*(.gnu.warning)
|
||||
}
|
||||
PROVIDE (__etext = .);
|
||||
PROVIDE (_etext = .);
|
||||
PROVIDE (etext = .);
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
/* Adjust the address for the rodata segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = SEGMENT_START("rodata-segment", ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)));
|
||||
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
|
||||
.rodata1 : { *(.rodata1) }
|
||||
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
|
||||
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
|
||||
/* These sections are generated by the Sun/Oracle C++ compiler. */
|
||||
.exception_ranges : ONLY_IF_RO { *(.exception_ranges*) }
|
||||
/* Adjust the address for the data segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
|
||||
/* Exception handling */
|
||||
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
|
||||
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.exception_ranges : ONLY_IF_RW { *(.exception_ranges*) }
|
||||
/* Thread Local Storage sections */
|
||||
/* .tdata :
|
||||
{
|
||||
PROVIDE_HIDDEN (__tdata_start = .);
|
||||
*(.tdata .tdata.* .gnu.linkonce.td.*)
|
||||
}
|
||||
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } */
|
||||
.preinit_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__preinit_array_start = .);
|
||||
KEEP (*(.preinit_array))
|
||||
PROVIDE_HIDDEN (__preinit_array_end = .);
|
||||
}
|
||||
/* .init_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__init_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
|
||||
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
|
||||
PROVIDE_HIDDEN (__init_array_end = .);
|
||||
} */
|
||||
.fini_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__fini_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
|
||||
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
|
||||
PROVIDE_HIDDEN (__fini_array_end = .);
|
||||
}
|
||||
.ctors :
|
||||
{
|
||||
/* gcc uses crtbegin.o to find the start of
|
||||
the constructors, so we make sure it is
|
||||
first. Because this is a wildcard, it
|
||||
doesn't matter if the user does not
|
||||
actually link against crtbegin.o; the
|
||||
linker won't look for a file to match a
|
||||
wildcard. The wildcard also means that it
|
||||
doesn't matter which directory crtbegin.o
|
||||
is in. */
|
||||
KEEP (*crtbegin.o(.ctors))
|
||||
KEEP (*crtbegin?.o(.ctors))
|
||||
/* We don't want to include the .ctor section from
|
||||
the crtend.o file until after the sorted ctors.
|
||||
The .ctor section from the crtend file contains the
|
||||
end of ctors marker and it must be last */
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
|
||||
KEEP (*(SORT(.ctors.*)))
|
||||
KEEP (*(.ctors))
|
||||
}
|
||||
.dtors :
|
||||
{
|
||||
KEEP (*crtbegin.o(.dtors))
|
||||
KEEP (*crtbegin?.o(.dtors))
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
|
||||
KEEP (*(SORT(.dtors.*)))
|
||||
KEEP (*(.dtors))
|
||||
}
|
||||
.jcr : { KEEP (*(.jcr)) }
|
||||
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
|
||||
.dynamic : { *(.dynamic) }
|
||||
.got : { *(.got) *(.igot) }
|
||||
. = DATA_SEGMENT_RELRO_END (SIZEOF (.got.plt) >= 24 ? 24 : 0, .);
|
||||
.got.plt : { *(.got.plt) *(.igot.plt) }
|
||||
.data :
|
||||
{
|
||||
*(.data .data.* .gnu.linkonce.d.*)
|
||||
SORT(CONSTRUCTORS)
|
||||
}
|
||||
.data1 : { *(.data1) }
|
||||
_edata = .; PROVIDE (edata = .);
|
||||
. = .;
|
||||
__bss_start = .;
|
||||
.bss :
|
||||
{
|
||||
*(.dynbss)
|
||||
*(.bss .bss.* .gnu.linkonce.b.*)
|
||||
*(COMMON)
|
||||
/* Align here to ensure that the .bss section occupies space up to
|
||||
_end. Align after .bss to ensure correct alignment even if the
|
||||
.bss section disappears because there are no input sections.
|
||||
FIXME: Why do we need it? When there is no .bss section, we do not
|
||||
pad the .data section. */
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
.lbss :
|
||||
{
|
||||
*(.dynlbss)
|
||||
*(.lbss .lbss.* .gnu.linkonce.lb.*)
|
||||
*(LARGE_COMMON)
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
. = SEGMENT_START("ldata-segment", .);
|
||||
.lrodata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.lrodata .lrodata.* .gnu.linkonce.lr.*)
|
||||
}
|
||||
.ldata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.ldata .ldata.* .gnu.linkonce.l.*)
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
_end = .; PROVIDE (end = .);
|
||||
. = DATA_SEGMENT_END (.);
|
||||
/* Stabs debugging sections. */
|
||||
.stab 0 : { *(.stab) }
|
||||
.stabstr 0 : { *(.stabstr) }
|
||||
.stab.excl 0 : { *(.stab.excl) }
|
||||
.stab.exclstr 0 : { *(.stab.exclstr) }
|
||||
.stab.index 0 : { *(.stab.index) }
|
||||
.stab.indexstr 0 : { *(.stab.indexstr) }
|
||||
.comment 0 : { *(.comment) }
|
||||
.gnu.build.attributes : { *(.gnu.build.attributes .gnu.build.attributes.*) }
|
||||
/* DWARF debug sections.
|
||||
Symbols in the DWARF debugging sections are relative to the beginning
|
||||
of the section so we begin them at 0. */
|
||||
/* DWARF 1 */
|
||||
.debug 0 : { *(.debug) }
|
||||
.line 0 : { *(.line) }
|
||||
/* GNU DWARF 1 extensions */
|
||||
.debug_srcinfo 0 : { *(.debug_srcinfo) }
|
||||
.debug_sfnames 0 : { *(.debug_sfnames) }
|
||||
/* DWARF 1.1 and DWARF 2 */
|
||||
.debug_aranges 0 : { *(.debug_aranges) }
|
||||
.debug_pubnames 0 : { *(.debug_pubnames) }
|
||||
/* DWARF 2 */
|
||||
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
|
||||
.debug_abbrev 0 : { *(.debug_abbrev) }
|
||||
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end) }
|
||||
.debug_frame 0 : { *(.debug_frame) }
|
||||
.debug_str 0 : { *(.debug_str) }
|
||||
.debug_loc 0 : { *(.debug_loc) }
|
||||
.debug_macinfo 0 : { *(.debug_macinfo) }
|
||||
/* SGI/MIPS DWARF 2 extensions */
|
||||
.debug_weaknames 0 : { *(.debug_weaknames) }
|
||||
.debug_funcnames 0 : { *(.debug_funcnames) }
|
||||
.debug_typenames 0 : { *(.debug_typenames) }
|
||||
.debug_varnames 0 : { *(.debug_varnames) }
|
||||
/* DWARF 3 */
|
||||
.debug_pubtypes 0 : { *(.debug_pubtypes) }
|
||||
.debug_ranges 0 : { *(.debug_ranges) }
|
||||
/* DWARF Extension. */
|
||||
.debug_macro 0 : { *(.debug_macro) }
|
||||
.debug_addr 0 : { *(.debug_addr) }
|
||||
.gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
|
||||
/DISCARD/ : {
|
||||
*(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*)
|
||||
/*
|
||||
* XXX: As of now, ld.so links with relibc which has the main functionality. In the next refactor,
|
||||
* ld.so will be moved out of relibc. So, till that time, we have to discard any sections
|
||||
* that may reference use thread local storage.
|
||||
*
|
||||
* .init_array also depends on TLS and is discarded as we don't need it.
|
||||
*/
|
||||
*(.gnu.linkonce.tb.*) *(.tcommon)
|
||||
*(.init_array)
|
||||
}
|
||||
}
|
||||
@@ -1,259 +0,0 @@
|
||||
/* Script for -z combreloc */
|
||||
/* Copyright (C) 2014-2020 Free Software Foundation, Inc.
|
||||
Copying and distribution of this script, with or without modification,
|
||||
are permitted in any medium without royalty provided the copyright
|
||||
notice and this notice are preserved. */
|
||||
OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64",
|
||||
"elf64-x86-64")
|
||||
OUTPUT_ARCH(i386:x86-64)
|
||||
ENTRY(_start)
|
||||
SEARCH_DIR("/usr/x86_64-pc-linux-gnu/lib64");
|
||||
SEARCH_DIR("/usr/lib64/binutils/x86_64-pc-linux-gnu/2.33.164");
|
||||
SEARCH_DIR("/usr/local/lib64");
|
||||
SEARCH_DIR("/lib64");
|
||||
SEARCH_DIR("/usr/lib64");
|
||||
SEARCH_DIR("/usr/x86_64-pc-linux-gnu/lib");
|
||||
SEARCH_DIR("/usr/lib64/binutils/x86_64-pc-linux-gnu/2.33.1");
|
||||
SEARCH_DIR("/usr/local/lib");
|
||||
SEARCH_DIR("/lib");
|
||||
SEARCH_DIR("/usr/lib");
|
||||
SECTIONS
|
||||
{
|
||||
/* Read-only sections, merged into text segment: */
|
||||
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x20000000) + SIZEOF_HEADERS;
|
||||
.interp : { *(.interp) }
|
||||
.note.gnu.build-id : { *(.note.gnu.build-id) }
|
||||
.hash : { *(.hash) }
|
||||
.gnu.hash : { *(.gnu.hash) }
|
||||
.dynsym : { *(.dynsym) }
|
||||
.dynstr : { *(.dynstr) }
|
||||
.gnu.version : { *(.gnu.version) }
|
||||
.gnu.version_d : { *(.gnu.version_d) }
|
||||
.gnu.version_r : { *(.gnu.version_r) }
|
||||
.rela.dyn :
|
||||
{
|
||||
*(.rela.init)
|
||||
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
|
||||
*(.rela.fini)
|
||||
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
|
||||
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
|
||||
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
|
||||
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
|
||||
*(.rela.ctors)
|
||||
*(.rela.dtors)
|
||||
*(.rela.got)
|
||||
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
|
||||
*(.rela.ldata .rela.ldata.* .rela.gnu.linkonce.l.*)
|
||||
*(.rela.lbss .rela.lbss.* .rela.gnu.linkonce.lb.*)
|
||||
*(.rela.lrodata .rela.lrodata.* .rela.gnu.linkonce.lr.*)
|
||||
*(.rela.ifunc)
|
||||
}
|
||||
.rela.plt :
|
||||
{
|
||||
*(.rela.plt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_start = .);
|
||||
*(.rela.iplt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_end = .);
|
||||
}
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
.init :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.init)))
|
||||
}
|
||||
.plt : { *(.plt) *(.iplt) }
|
||||
.plt.got : { *(.plt.got) }
|
||||
.plt.sec : { *(.plt.sec) }
|
||||
.text :
|
||||
{
|
||||
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
|
||||
*(.text.exit .text.exit.*)
|
||||
*(.text.startup .text.startup.*)
|
||||
*(.text.hot .text.hot.*)
|
||||
*(.text .stub .text.* .gnu.linkonce.t.*)
|
||||
/* .gnu.warning sections are handled specially by elf.em. */
|
||||
*(.gnu.warning)
|
||||
}
|
||||
.fini :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.fini)))
|
||||
}
|
||||
PROVIDE (__etext = .);
|
||||
PROVIDE (_etext = .);
|
||||
PROVIDE (etext = .);
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
/* Adjust the address for the rodata segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = SEGMENT_START("rodata-segment", ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)));
|
||||
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
|
||||
.rodata1 : { *(.rodata1) }
|
||||
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
|
||||
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
|
||||
/* These sections are generated by the Sun/Oracle C++ compiler. */
|
||||
.exception_ranges : ONLY_IF_RO { *(.exception_ranges*) }
|
||||
/* Adjust the address for the data segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
|
||||
/* Exception handling */
|
||||
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
|
||||
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.exception_ranges : ONLY_IF_RW { *(.exception_ranges*) }
|
||||
/* Thread Local Storage sections */
|
||||
/* .tdata : ALIGN(4K)
|
||||
{
|
||||
PROVIDE_HIDDEN (__tdata_start = .);
|
||||
*(.tdata .tdata.* .gnu.linkonce.td.*)
|
||||
}
|
||||
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } */
|
||||
.preinit_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__preinit_array_start = .);
|
||||
KEEP (*(.preinit_array))
|
||||
PROVIDE_HIDDEN (__preinit_array_end = .);
|
||||
}
|
||||
/* .init_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__init_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
|
||||
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
|
||||
PROVIDE_HIDDEN (__init_array_end = .);
|
||||
} */
|
||||
.fini_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__fini_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
|
||||
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
|
||||
PROVIDE_HIDDEN (__fini_array_end = .);
|
||||
}
|
||||
.ctors :
|
||||
{
|
||||
/* gcc uses crtbegin.o to find the start of
|
||||
the constructors, so we make sure it is
|
||||
first. Because this is a wildcard, it
|
||||
doesn't matter if the user does not
|
||||
actually link against crtbegin.o; the
|
||||
linker won't look for a file to match a
|
||||
wildcard. The wildcard also means that it
|
||||
doesn't matter which directory crtbegin.o
|
||||
is in. */
|
||||
KEEP (*crtbegin.o(.ctors))
|
||||
KEEP (*crtbegin?.o(.ctors))
|
||||
/* We don't want to include the .ctor section from
|
||||
the crtend.o file until after the sorted ctors.
|
||||
The .ctor section from the crtend file contains the
|
||||
end of ctors marker and it must be last */
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
|
||||
KEEP (*(SORT(.ctors.*)))
|
||||
KEEP (*(.ctors))
|
||||
}
|
||||
.dtors :
|
||||
{
|
||||
KEEP (*crtbegin.o(.dtors))
|
||||
KEEP (*crtbegin?.o(.dtors))
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
|
||||
KEEP (*(SORT(.dtors.*)))
|
||||
KEEP (*(.dtors))
|
||||
}
|
||||
.jcr : { KEEP (*(.jcr)) }
|
||||
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
|
||||
.dynamic : { *(.dynamic) }
|
||||
.got : { *(.got) *(.igot) }
|
||||
. = DATA_SEGMENT_RELRO_END (SIZEOF (.got.plt) >= 24 ? 24 : 0, .);
|
||||
.got.plt : { *(.got.plt) *(.igot.plt) }
|
||||
.data :
|
||||
{
|
||||
*(.data .data.* .gnu.linkonce.d.*)
|
||||
SORT(CONSTRUCTORS)
|
||||
}
|
||||
.data1 : { *(.data1) }
|
||||
_edata = .; PROVIDE (edata = .);
|
||||
. = .;
|
||||
__bss_start = .;
|
||||
.bss :
|
||||
{
|
||||
*(.dynbss)
|
||||
*(.bss .bss.* .gnu.linkonce.b.*)
|
||||
*(COMMON)
|
||||
/* Align here to ensure that the .bss section occupies space up to
|
||||
_end. Align after .bss to ensure correct alignment even if the
|
||||
.bss section disappears because there are no input sections.
|
||||
FIXME: Why do we need it? When there is no .bss section, we do not
|
||||
pad the .data section. */
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
.lbss :
|
||||
{
|
||||
*(.dynlbss)
|
||||
*(.lbss .lbss.* .gnu.linkonce.lb.*)
|
||||
*(LARGE_COMMON)
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
. = SEGMENT_START("ldata-segment", .);
|
||||
.lrodata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.lrodata .lrodata.* .gnu.linkonce.lr.*)
|
||||
}
|
||||
.ldata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.ldata .ldata.* .gnu.linkonce.l.*)
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
_end = .; PROVIDE (end = .);
|
||||
. = DATA_SEGMENT_END (.);
|
||||
/* Stabs debugging sections. */
|
||||
.stab 0 : { *(.stab) }
|
||||
.stabstr 0 : { *(.stabstr) }
|
||||
.stab.excl 0 : { *(.stab.excl) }
|
||||
.stab.exclstr 0 : { *(.stab.exclstr) }
|
||||
.stab.index 0 : { *(.stab.index) }
|
||||
.stab.indexstr 0 : { *(.stab.indexstr) }
|
||||
.comment 0 : { *(.comment) }
|
||||
.gnu.build.attributes : { *(.gnu.build.attributes .gnu.build.attributes.*) }
|
||||
/* DWARF debug sections.
|
||||
Symbols in the DWARF debugging sections are relative to the beginning
|
||||
of the section so we begin them at 0. */
|
||||
/* DWARF 1 */
|
||||
.debug 0 : { *(.debug) }
|
||||
.line 0 : { *(.line) }
|
||||
/* GNU DWARF 1 extensions */
|
||||
.debug_srcinfo 0 : { *(.debug_srcinfo) }
|
||||
.debug_sfnames 0 : { *(.debug_sfnames) }
|
||||
/* DWARF 1.1 and DWARF 2 */
|
||||
.debug_aranges 0 : { *(.debug_aranges) }
|
||||
.debug_pubnames 0 : { *(.debug_pubnames) }
|
||||
/* DWARF 2 */
|
||||
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
|
||||
.debug_abbrev 0 : { *(.debug_abbrev) }
|
||||
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end) }
|
||||
.debug_frame 0 : { *(.debug_frame) }
|
||||
.debug_str 0 : { *(.debug_str) }
|
||||
.debug_loc 0 : { *(.debug_loc) }
|
||||
.debug_macinfo 0 : { *(.debug_macinfo) }
|
||||
/* SGI/MIPS DWARF 2 extensions */
|
||||
.debug_weaknames 0 : { *(.debug_weaknames) }
|
||||
.debug_funcnames 0 : { *(.debug_funcnames) }
|
||||
.debug_typenames 0 : { *(.debug_typenames) }
|
||||
.debug_varnames 0 : { *(.debug_varnames) }
|
||||
/* DWARF 3 */
|
||||
.debug_pubtypes 0 : { *(.debug_pubtypes) }
|
||||
.debug_ranges 0 : { *(.debug_ranges) }
|
||||
/* DWARF Extension. */
|
||||
.debug_macro 0 : { *(.debug_macro) }
|
||||
.debug_addr 0 : { *(.debug_addr) }
|
||||
.gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
|
||||
/DISCARD/ : {
|
||||
*(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*)
|
||||
/*
|
||||
* XXX: As of now, ld.so links with relibc which has the main functionality. In the next refactor,
|
||||
* ld.so will be moved out of relibc. So, till that time, we have to discard any sections
|
||||
* that may reference use thread local storage.
|
||||
*
|
||||
* .init_array also depends on TLS and is discarded as we don't need it.
|
||||
*/
|
||||
*(.gnu.linkonce.tb.*) *(.tcommon)
|
||||
*(.init_array)
|
||||
}
|
||||
}
|
||||
@@ -1,256 +0,0 @@
|
||||
/* Script for -z combreloc */
|
||||
/* Copyright (C) 2014-2020 Free Software Foundation, Inc.
|
||||
Copying and distribution of this script, with or without modification,
|
||||
are permitted in any medium without royalty provided the copyright
|
||||
notice and this notice are preserved. */
|
||||
OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64",
|
||||
"elf64-x86-64")
|
||||
OUTPUT_ARCH(i386:x86-64)
|
||||
ENTRY(_start)
|
||||
SEARCH_DIR("/x86_64-unknown-redox/lib");
|
||||
SEARCH_DIR("/usr/local/lib64");
|
||||
SEARCH_DIR("/lib64");
|
||||
SEARCH_DIR("/usr/lib64");
|
||||
SEARCH_DIR("/usr/local/lib");
|
||||
SEARCH_DIR("/lib");
|
||||
SEARCH_DIR("/usr/lib");
|
||||
SECTIONS
|
||||
{
|
||||
/* Read-only sections, merged into text segment: */
|
||||
PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x400000)); . = SEGMENT_START("text-segment", 0x20000000) + SIZEOF_HEADERS;
|
||||
.interp : { *(.interp) }
|
||||
.note.gnu.build-id : { *(.note.gnu.build-id) }
|
||||
.hash : { *(.hash) }
|
||||
.gnu.hash : { *(.gnu.hash) }
|
||||
.dynsym : { *(.dynsym) }
|
||||
.dynstr : { *(.dynstr) }
|
||||
.gnu.version : { *(.gnu.version) }
|
||||
.gnu.version_d : { *(.gnu.version_d) }
|
||||
.gnu.version_r : { *(.gnu.version_r) }
|
||||
.rela.dyn :
|
||||
{
|
||||
*(.rela.init)
|
||||
*(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
|
||||
*(.rela.fini)
|
||||
*(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
|
||||
*(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
|
||||
*(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
|
||||
*(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
|
||||
*(.rela.ctors)
|
||||
*(.rela.dtors)
|
||||
*(.rela.got)
|
||||
*(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
|
||||
*(.rela.ldata .rela.ldata.* .rela.gnu.linkonce.l.*)
|
||||
*(.rela.lbss .rela.lbss.* .rela.gnu.linkonce.lb.*)
|
||||
*(.rela.lrodata .rela.lrodata.* .rela.gnu.linkonce.lr.*)
|
||||
*(.rela.ifunc)
|
||||
}
|
||||
.rela.plt :
|
||||
{
|
||||
*(.rela.plt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_start = .);
|
||||
*(.rela.iplt)
|
||||
PROVIDE_HIDDEN (__rela_iplt_end = .);
|
||||
}
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
.init :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.init)))
|
||||
}
|
||||
.plt : { *(.plt) *(.iplt) }
|
||||
.plt.got : { *(.plt.got) }
|
||||
.plt.sec : { *(.plt.sec) }
|
||||
.text :
|
||||
{
|
||||
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
|
||||
*(.text.exit .text.exit.*)
|
||||
*(.text.startup .text.startup.*)
|
||||
*(.text.hot .text.hot.*)
|
||||
*(.text .stub .text.* .gnu.linkonce.t.*)
|
||||
/* .gnu.warning sections are handled specially by elf.em. */
|
||||
*(.gnu.warning)
|
||||
}
|
||||
.fini :
|
||||
{
|
||||
KEEP (*(SORT_NONE(.fini)))
|
||||
}
|
||||
PROVIDE (__etext = .);
|
||||
PROVIDE (_etext = .);
|
||||
PROVIDE (etext = .);
|
||||
. = ALIGN(CONSTANT (MAXPAGESIZE));
|
||||
/* Adjust the address for the rodata segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = SEGMENT_START("rodata-segment", ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)));
|
||||
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
|
||||
.rodata1 : { *(.rodata1) }
|
||||
.eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
|
||||
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gcc_except_table : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.gnu_extab : ONLY_IF_RO { *(.gnu_extab*) }
|
||||
/* These sections are generated by the Sun/Oracle C++ compiler. */
|
||||
.exception_ranges : ONLY_IF_RO { *(.exception_ranges*) }
|
||||
/* Adjust the address for the data segment. We want to adjust up to
|
||||
the same address within the page on the next page up. */
|
||||
. = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
|
||||
/* Exception handling */
|
||||
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
|
||||
.gnu_extab : ONLY_IF_RW { *(.gnu_extab) }
|
||||
.gcc_except_table : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
|
||||
.exception_ranges : ONLY_IF_RW { *(.exception_ranges*) }
|
||||
/* Thread Local Storage sections */
|
||||
/* .tdata : ALIGN(4K)
|
||||
{
|
||||
PROVIDE_HIDDEN (__tdata_start = .);
|
||||
*(.tdata .tdata.* .gnu.linkonce.td.*)
|
||||
}
|
||||
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) } */
|
||||
.preinit_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__preinit_array_start = .);
|
||||
KEEP (*(.preinit_array))
|
||||
PROVIDE_HIDDEN (__preinit_array_end = .);
|
||||
}
|
||||
/* .init_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__init_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
|
||||
KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
|
||||
PROVIDE_HIDDEN (__init_array_end = .);
|
||||
} */
|
||||
.fini_array :
|
||||
{
|
||||
PROVIDE_HIDDEN (__fini_array_start = .);
|
||||
KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
|
||||
KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
|
||||
PROVIDE_HIDDEN (__fini_array_end = .);
|
||||
}
|
||||
.ctors :
|
||||
{
|
||||
/* gcc uses crtbegin.o to find the start of
|
||||
the constructors, so we make sure it is
|
||||
first. Because this is a wildcard, it
|
||||
doesn't matter if the user does not
|
||||
actually link against crtbegin.o; the
|
||||
linker won't look for a file to match a
|
||||
wildcard. The wildcard also means that it
|
||||
doesn't matter which directory crtbegin.o
|
||||
is in. */
|
||||
KEEP (*crtbegin.o(.ctors))
|
||||
KEEP (*crtbegin?.o(.ctors))
|
||||
/* We don't want to include the .ctor section from
|
||||
the crtend.o file until after the sorted ctors.
|
||||
The .ctor section from the crtend file contains the
|
||||
end of ctors marker and it must be last */
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
|
||||
KEEP (*(SORT(.ctors.*)))
|
||||
KEEP (*(.ctors))
|
||||
}
|
||||
.dtors :
|
||||
{
|
||||
KEEP (*crtbegin.o(.dtors))
|
||||
KEEP (*crtbegin?.o(.dtors))
|
||||
KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
|
||||
KEEP (*(SORT(.dtors.*)))
|
||||
KEEP (*(.dtors))
|
||||
}
|
||||
.jcr : { KEEP (*(.jcr)) }
|
||||
.data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
|
||||
.dynamic : { *(.dynamic) }
|
||||
.got : { *(.got) *(.igot) }
|
||||
. = DATA_SEGMENT_RELRO_END (SIZEOF (.got.plt) >= 24 ? 24 : 0, .);
|
||||
.got.plt : { *(.got.plt) *(.igot.plt) }
|
||||
.data :
|
||||
{
|
||||
*(.data .data.* .gnu.linkonce.d.*)
|
||||
SORT(CONSTRUCTORS)
|
||||
}
|
||||
.data1 : { *(.data1) }
|
||||
_edata = .; PROVIDE (edata = .);
|
||||
. = .;
|
||||
__bss_start = .;
|
||||
.bss :
|
||||
{
|
||||
*(.dynbss)
|
||||
*(.bss .bss.* .gnu.linkonce.b.*)
|
||||
*(COMMON)
|
||||
/* Align here to ensure that the .bss section occupies space up to
|
||||
_end. Align after .bss to ensure correct alignment even if the
|
||||
.bss section disappears because there are no input sections.
|
||||
FIXME: Why do we need it? When there is no .bss section, we do not
|
||||
pad the .data section. */
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
.lbss :
|
||||
{
|
||||
*(.dynlbss)
|
||||
*(.lbss .lbss.* .gnu.linkonce.lb.*)
|
||||
*(LARGE_COMMON)
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
. = SEGMENT_START("ldata-segment", .);
|
||||
.lrodata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.lrodata .lrodata.* .gnu.linkonce.lr.*)
|
||||
}
|
||||
.ldata ALIGN(CONSTANT (MAXPAGESIZE)) + (. & (CONSTANT (MAXPAGESIZE) - 1)) :
|
||||
{
|
||||
*(.ldata .ldata.* .gnu.linkonce.l.*)
|
||||
. = ALIGN(. != 0 ? 64 / 8 : 1);
|
||||
}
|
||||
. = ALIGN(64 / 8);
|
||||
_end = .; PROVIDE (end = .);
|
||||
. = DATA_SEGMENT_END (.);
|
||||
/* Stabs debugging sections. */
|
||||
.stab 0 : { *(.stab) }
|
||||
.stabstr 0 : { *(.stabstr) }
|
||||
.stab.excl 0 : { *(.stab.excl) }
|
||||
.stab.exclstr 0 : { *(.stab.exclstr) }
|
||||
.stab.index 0 : { *(.stab.index) }
|
||||
.stab.indexstr 0 : { *(.stab.indexstr) }
|
||||
.comment 0 : { *(.comment) }
|
||||
.gnu.build.attributes : { *(.gnu.build.attributes .gnu.build.attributes.*) }
|
||||
/* DWARF debug sections.
|
||||
Symbols in the DWARF debugging sections are relative to the beginning
|
||||
of the section so we begin them at 0. */
|
||||
/* DWARF 1 */
|
||||
.debug 0 : { *(.debug) }
|
||||
.line 0 : { *(.line) }
|
||||
/* GNU DWARF 1 extensions */
|
||||
.debug_srcinfo 0 : { *(.debug_srcinfo) }
|
||||
.debug_sfnames 0 : { *(.debug_sfnames) }
|
||||
/* DWARF 1.1 and DWARF 2 */
|
||||
.debug_aranges 0 : { *(.debug_aranges) }
|
||||
.debug_pubnames 0 : { *(.debug_pubnames) }
|
||||
/* DWARF 2 */
|
||||
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
|
||||
.debug_abbrev 0 : { *(.debug_abbrev) }
|
||||
.debug_line 0 : { *(.debug_line .debug_line.* .debug_line_end) }
|
||||
.debug_frame 0 : { *(.debug_frame) }
|
||||
.debug_str 0 : { *(.debug_str) }
|
||||
.debug_loc 0 : { *(.debug_loc) }
|
||||
.debug_macinfo 0 : { *(.debug_macinfo) }
|
||||
/* SGI/MIPS DWARF 2 extensions */
|
||||
.debug_weaknames 0 : { *(.debug_weaknames) }
|
||||
.debug_funcnames 0 : { *(.debug_funcnames) }
|
||||
.debug_typenames 0 : { *(.debug_typenames) }
|
||||
.debug_varnames 0 : { *(.debug_varnames) }
|
||||
/* DWARF 3 */
|
||||
.debug_pubtypes 0 : { *(.debug_pubtypes) }
|
||||
.debug_ranges 0 : { *(.debug_ranges) }
|
||||
/* DWARF Extension. */
|
||||
.debug_macro 0 : { *(.debug_macro) }
|
||||
.debug_addr 0 : { *(.debug_addr) }
|
||||
.gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
|
||||
/DISCARD/ : {
|
||||
*(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*)
|
||||
/*
|
||||
* XXX: As of now, ld.so links with relibc which has the main functionality. In the next refactor,
|
||||
* ld.so will be moved out of relibc. So, till that time, we have to discard any sections
|
||||
* that may reference use thread local storage.
|
||||
*
|
||||
* .init_array also depends on TLS and is discarded as we don't need it.
|
||||
*/
|
||||
*(.gnu.linkonce.tb.*) *(.tcommon)
|
||||
*(.init_array)
|
||||
}
|
||||
}
|
||||
@@ -1,136 +0,0 @@
|
||||
#![no_std]
|
||||
#![feature(linkage)]
|
||||
#![deny(unsafe_op_in_unsafe_fn)]
|
||||
|
||||
use core::arch::global_asm;
|
||||
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
global_asm!(
|
||||
"
|
||||
.weak _DYNAMIC
|
||||
.hidden _DYNAMIC
|
||||
|
||||
.global _start
|
||||
_start:
|
||||
mov x28, sp
|
||||
// align stack to 16 bytes
|
||||
and sp, x28, #0xfffffffffffffff0
|
||||
adr x1, _start
|
||||
mov x0, x28
|
||||
adrp x2, _DYNAMIC
|
||||
add x2, x2, #:lo12:_DYNAMIC
|
||||
// ld_so_start(stack=x0, ld_entry=x1, dynamic=x2)
|
||||
bl relibc_ld_so_start
|
||||
// restore original stack, clear registers, and jump to the new start function
|
||||
mov sp, x28
|
||||
mov x1, xzr
|
||||
mov x2, xzr
|
||||
mov x3, xzr
|
||||
mov x4, xzr
|
||||
mov x5, xzr
|
||||
mov x6, xzr
|
||||
mov x7, xzr
|
||||
mov x8, xzr
|
||||
mov x9, xzr
|
||||
mov x10, xzr
|
||||
mov x11, xzr
|
||||
mov x12, xzr
|
||||
mov x13, xzr
|
||||
mov x14, xzr
|
||||
mov x15, xzr
|
||||
mov x16, xzr
|
||||
mov x17, xzr
|
||||
mov x18, xzr
|
||||
mov x19, xzr
|
||||
mov x20, xzr
|
||||
mov x21, xzr
|
||||
mov x22, xzr
|
||||
mov x23, xzr
|
||||
mov x24, xzr
|
||||
mov x25, xzr
|
||||
mov x26, xzr
|
||||
mov x27, xzr
|
||||
mov x28, xzr
|
||||
mov x29, xzr
|
||||
mov x30, xzr
|
||||
br x0
|
||||
udf #0
|
||||
"
|
||||
);
|
||||
|
||||
#[cfg(target_arch = "x86")]
|
||||
global_asm!(
|
||||
"
|
||||
.globl _start
|
||||
_start:
|
||||
push esp
|
||||
call relibc_ld_so_start
|
||||
pop esp
|
||||
# TODO: x86
|
||||
ud2
|
||||
"
|
||||
);
|
||||
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
global_asm!(
|
||||
"
|
||||
.weak _DYNAMIC
|
||||
.hidden _DYNAMIC
|
||||
|
||||
.globl _start
|
||||
_start:
|
||||
lea rsi, [rip + _start]
|
||||
|
||||
# Save original stack and align stack to 16 bytes
|
||||
mov rbp, rsp
|
||||
and rsp, 0xfffffffffffffff0
|
||||
|
||||
# Call ld_so_start(stack=rdi, ld_entry=rsi, dynamic=rdx)
|
||||
mov rdi, rbp
|
||||
lea rdx, [rip + _DYNAMIC]
|
||||
call relibc_ld_so_start
|
||||
|
||||
# Restore original stack, clear registers, and jump to new start function
|
||||
mov rsp, rbp
|
||||
xor rcx, rcx
|
||||
xor rdx, rdx
|
||||
xor rdi, rdi
|
||||
xor rsi, rsi
|
||||
xor r8, r8
|
||||
xor r9, r9
|
||||
xor r10, r10
|
||||
xor r11, r11
|
||||
fninit
|
||||
jmp rax
|
||||
ud2
|
||||
"
|
||||
);
|
||||
|
||||
#[cfg(target_arch = "riscv64")]
|
||||
global_asm!(
|
||||
"
|
||||
.globl _start
|
||||
_start:
|
||||
mv a0, sp
|
||||
jal relibc_ld_so_start
|
||||
unimp
|
||||
"
|
||||
);
|
||||
|
||||
#[unsafe(no_mangle)]
|
||||
pub unsafe extern "C" fn main(_argc: isize, _argv: *const *const i8) -> usize {
|
||||
// LD
|
||||
0x1D
|
||||
}
|
||||
|
||||
#[linkage = "weak"]
|
||||
#[unsafe(no_mangle)]
|
||||
extern "C" fn relibc_panic(_pi: &::core::panic::PanicInfo) -> ! {
|
||||
loop {}
|
||||
}
|
||||
|
||||
#[panic_handler]
|
||||
#[linkage = "weak"]
|
||||
pub unsafe fn rust_begin_unwind(pi: &::core::panic::PanicInfo) -> ! {
|
||||
relibc_panic(pi)
|
||||
}
|
||||
-1
Submodule openlibm deleted from e2da0dafd3
@@ -1,13 +0,0 @@
|
||||
[package]
|
||||
name = "redox-ioctl"
|
||||
authors = ["bjorn3 <bjorn3_gh@protonmail.com>"]
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
license = "MIT"
|
||||
description = "Ioctl definitions and (de)serialization for Redox"
|
||||
|
||||
[dependencies]
|
||||
drm-sys = "0.8.0"
|
||||
redox_syscall = { path = "../../syscall" }
|
||||
|
||||
[features]
|
||||
@@ -1,319 +0,0 @@
|
||||
use alloc::vec::Vec;
|
||||
use core::{
|
||||
cmp,
|
||||
ffi::{c_char, c_int, c_uint},
|
||||
iter, mem, slice,
|
||||
};
|
||||
use drm_sys::drm_clip_rect;
|
||||
|
||||
pub use drm_sys::{
|
||||
__kernel_size_t, DRM_PROP_NAME_LEN, drm_get_cap, drm_mode_card_res,
|
||||
drm_mode_connector_set_property, drm_mode_create_dumb, drm_mode_crtc,
|
||||
drm_mode_crtc_page_flip_target, drm_mode_cursor, drm_mode_cursor2, drm_mode_destroy_dumb,
|
||||
drm_mode_fb_cmd, drm_mode_fb_cmd2, drm_mode_fb_dirty_cmd, drm_mode_get_blob,
|
||||
drm_mode_get_connector, drm_mode_get_encoder, drm_mode_get_plane, drm_mode_get_plane_res,
|
||||
drm_mode_get_property, drm_mode_map_dumb, drm_mode_modeinfo, drm_mode_obj_get_properties,
|
||||
drm_mode_property_enum, drm_mode_set_plane, drm_set_client_cap, drm_version,
|
||||
};
|
||||
|
||||
pub const VERSION: u64 = 0;
|
||||
define_ioctl_data! {
|
||||
struct drm_version, DrmVersion {
|
||||
version_major: c_int,
|
||||
version_minor: c_int,
|
||||
version_patchlevel: c_int,
|
||||
name_len: __kernel_size_t,
|
||||
name: *mut c_char [array<c_char, name_len>],
|
||||
date_len: __kernel_size_t,
|
||||
date: *mut c_char [array<c_char, date_len>],
|
||||
desc_len: __kernel_size_t,
|
||||
desc: *mut c_char [array<c_char, desc_len>],
|
||||
}
|
||||
}
|
||||
|
||||
pub const GET_CAP: u64 = 0x0C;
|
||||
pub use drm_sys::DRM_CAP_DUMB_BUFFER;
|
||||
define_ioctl_data! {
|
||||
struct drm_get_cap, DrmGetCap {
|
||||
capability: u64,
|
||||
value: u64,
|
||||
}
|
||||
}
|
||||
|
||||
pub const SET_CLIENT_CAP: u64 = 0x0D;
|
||||
pub use drm_sys::DRM_CLIENT_CAP_CURSOR_PLANE_HOTSPOT;
|
||||
define_ioctl_data! {
|
||||
struct drm_set_client_cap, DrmSetClientCap {
|
||||
capability: u64,
|
||||
value: u64,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_CARD_RES: u64 = 0xA0;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_card_res, DrmModeCardRes {
|
||||
fb_id_ptr: u64 [array<u32, count_fbs>],
|
||||
crtc_id_ptr: u64 [array<u32, count_crtcs>],
|
||||
connector_id_ptr: u64 [array<u32, count_connectors>],
|
||||
encoder_id_ptr: u64 [array<u32, count_encoders>],
|
||||
count_fbs: u32,
|
||||
count_crtcs: u32,
|
||||
count_connectors: u32,
|
||||
count_encoders: u32,
|
||||
min_width: u32,
|
||||
max_width: u32,
|
||||
min_height: u32,
|
||||
max_height: u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_GET_CRTC: u64 = 0xA1;
|
||||
pub const MODE_SET_CRTC: u64 = 0xA2;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_crtc, DrmModeCrtc {
|
||||
set_connectors_ptr: u64 [array<u32, count_connectors>],
|
||||
count_connectors: u32,
|
||||
crtc_id: u32,
|
||||
fb_id: u32,
|
||||
x: u32,
|
||||
y: u32,
|
||||
gamma_size: u32,
|
||||
mode_valid: u32,
|
||||
mode: drm_mode_modeinfo,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_CURSOR: u64 = 0xA3;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_cursor, DrmModeCursor {
|
||||
flags: u32,
|
||||
crtc_id: u32,
|
||||
x: i32,
|
||||
y:i32,
|
||||
width:u32,
|
||||
height:u32,
|
||||
handle:u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_GET_ENCODER: u64 = 0xA6;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_get_encoder, DrmModeGetEncoder {
|
||||
encoder_id: u32,
|
||||
encoder_type: u32,
|
||||
crtc_id: u32,
|
||||
possible_crtcs: u32,
|
||||
possible_clones: u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_GET_CONNECTOR: u64 = 0xA7;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_get_connector, DrmModeGetConnector {
|
||||
encoders_ptr: u64 [array<u32, count_encoders>],
|
||||
modes_ptr: u64 [array<drm_mode_modeinfo, count_modes>],
|
||||
props_ptr: u64 [array<u32, count_props>],
|
||||
prop_values_ptr: u64 [array<u64, count_props>],
|
||||
count_modes: u32,
|
||||
count_props: u32,
|
||||
count_encoders: u32,
|
||||
encoder_id: u32,
|
||||
connector_id: u32,
|
||||
connector_type: u32,
|
||||
connector_type_id: u32,
|
||||
connection: u32,
|
||||
mm_width: u32,
|
||||
mm_height: u32,
|
||||
subpixel: u32,
|
||||
pad: u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_GET_PROPERTY: u64 = 0xAA;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_get_property, DrmModeGetProperty {
|
||||
values_ptr: u64 [array<u64, count_values>],
|
||||
enum_blob_ptr: u64 [array<drm_mode_property_enum, count_enum_blobs>],
|
||||
prop_id: u32,
|
||||
flags: u32,
|
||||
name: [c_char; DRM_PROP_NAME_LEN as usize],
|
||||
count_values: u32,
|
||||
count_enum_blobs: u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_SET_PROPERTY: u64 = 0xAB;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_connector_set_property, DrmModeConnectorSetProperty {
|
||||
value: u64,
|
||||
prop_id: u32,
|
||||
connector_id: u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_GET_PROP_BLOB: u64 = 0xAC;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_get_blob, DrmModeGetBlob {
|
||||
blob_id: u32,
|
||||
length: u32,
|
||||
data: u64 [array<u8, length>],
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_GET_FB: u64 = 0xAD;
|
||||
pub const MODE_ADD_FB: u64 = 0xAE;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_fb_cmd, DrmModeFbCmd {
|
||||
fb_id: u32,
|
||||
width: u32,
|
||||
height: u32,
|
||||
pitch: u32,
|
||||
bpp: u32,
|
||||
depth: u32,
|
||||
handle: u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_RM_FB: u64 = 0xAF;
|
||||
define_ioctl_data! {
|
||||
struct standin_for_uint, StandinForUint {
|
||||
inner: c_uint,
|
||||
}
|
||||
}
|
||||
|
||||
#[repr(transparent)]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub struct standin_for_uint {
|
||||
pub inner: c_uint,
|
||||
}
|
||||
|
||||
pub const MODE_PAGE_FLIP: u64 = 0xB0;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_crtc_page_flip_target, DrmModeCrtcPageFlipTarget {
|
||||
crtc_id: u32,
|
||||
fb_id: u32,
|
||||
flags: u32,
|
||||
sequence: u32,
|
||||
user_data: u64,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_DIRTYFB: u64 = 0xB1;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_fb_dirty_cmd, DrmModeFbDirtyCmd {
|
||||
fb_id: u32,
|
||||
flags: u32,
|
||||
color: u32,
|
||||
num_clips: u32,
|
||||
clips_ptr: u64 [array<drm_clip_rect, num_clips>],
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_CREATE_DUMB: u64 = 0xB2;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_create_dumb, DrmModeCreateDumb {
|
||||
height: u32,
|
||||
width: u32,
|
||||
bpp: u32,
|
||||
flags: u32,
|
||||
handle: u32,
|
||||
pitch: u32,
|
||||
size: u64,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_MAP_DUMB: u64 = 0xB3;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_map_dumb, DrmModeMapDumb {
|
||||
handle: u32,
|
||||
pad: u32,
|
||||
offset: u64,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_DESTROY_DUMB: u64 = 0xB4;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_destroy_dumb, DrmModeDestroyDumb {
|
||||
handle: u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_GET_PLANE_RES: u64 = 0xB5;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_get_plane_res, DrmModeGetPlaneRes {
|
||||
plane_id_ptr: u64 [array<u32, count_planes>],
|
||||
count_planes: u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_GET_PLANE: u64 = 0xB6;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_get_plane, DrmModeGetPlane {
|
||||
plane_id: u32,
|
||||
crtc_id: u32,
|
||||
fb_id: u32,
|
||||
possible_crtcs: u32,
|
||||
gamma_size: u32,
|
||||
count_format_types: u32,
|
||||
format_type_ptr: u64 [array<u32, count_format_types>],
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_SET_PLANE: u64 = 0xB7;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_set_plane, DrmModeSetPlane {
|
||||
plane_id: u32,
|
||||
crtc_id: u32,
|
||||
fb_id: u32,
|
||||
flags: u32,
|
||||
crtc_x: i32,
|
||||
crtc_y: i32,
|
||||
crtc_w: u32,
|
||||
crtc_h: u32,
|
||||
src_x: u32,
|
||||
src_y: u32,
|
||||
src_h: u32,
|
||||
src_w: u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_OBJ_GET_PROPERTIES: u64 = 0xB9;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_obj_get_properties, DrmModeObjGetProperties {
|
||||
props_ptr: u64 [array<u32, count_props>],
|
||||
prop_values_ptr: u64 [array<u64, count_props>],
|
||||
count_props: u32,
|
||||
obj_id: u32,
|
||||
obj_type: u32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_CURSOR2: u64 = 0xBB;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_cursor2, DrmModeCursor2 {
|
||||
flags: u32,
|
||||
crtc_id: u32,
|
||||
x: i32,
|
||||
y: i32,
|
||||
width: u32,
|
||||
height: u32,
|
||||
handle: u32,
|
||||
hot_x: i32,
|
||||
hot_y: i32,
|
||||
}
|
||||
}
|
||||
|
||||
pub const MODE_GET_FB2: u64 = 0xCE;
|
||||
define_ioctl_data! {
|
||||
struct drm_mode_fb_cmd2, DrmModeFbCmd2 {
|
||||
fb_id: u32,
|
||||
width: u32,
|
||||
height: u32,
|
||||
pixel_format: u32,
|
||||
flags: u32,
|
||||
handles: [u32; 4],
|
||||
pitches: [u32; 4],
|
||||
offsets: [u32; 4],
|
||||
modifier: [u64; 4],
|
||||
}
|
||||
}
|
||||
@@ -1,169 +0,0 @@
|
||||
use alloc::vec::Vec;
|
||||
|
||||
pub trait IoctlData {
|
||||
unsafe fn write(&self) -> Vec<u8>;
|
||||
unsafe fn read_from(&mut self, buf: &[u8]);
|
||||
}
|
||||
|
||||
macro_rules! define_ioctl_data {
|
||||
(struct $ioctl_ty:ident, $mem_ty:ident {
|
||||
$($rest:tt)*
|
||||
}) => {
|
||||
define_ioctl_data!(
|
||||
struct $ioctl_ty, $mem_ty { $($rest)* } => (), (), ()
|
||||
);
|
||||
};
|
||||
(struct $ioctl_ty:ident, $mem_ty:ident {
|
||||
$field:ident: $ty:ty,
|
||||
$($rest:tt)*
|
||||
} =>
|
||||
($($ioctl_fields:tt)*),
|
||||
($($counted_fields:tt)*),
|
||||
($($noncounted_fields:tt)*)
|
||||
) => {
|
||||
define_ioctl_data!(
|
||||
struct $ioctl_ty, $mem_ty { $($rest)* } =>
|
||||
($($ioctl_fields)* $field: $ty,),
|
||||
($($counted_fields)*),
|
||||
($($noncounted_fields)* $field: $ty,)
|
||||
);
|
||||
};
|
||||
(struct $ioctl_ty:ident, $mem_ty:ident {
|
||||
$field:ident: $ty:ty [array<$el:ty, $counted_by:ident>],
|
||||
$($rest:tt)*
|
||||
} =>
|
||||
($($ioctl_fields:tt)*),
|
||||
($($counted_fields:tt)*),
|
||||
($($noncounted_fields:tt)*)
|
||||
) => {
|
||||
define_ioctl_data!(
|
||||
struct $ioctl_ty, $mem_ty { $($rest)* } =>
|
||||
($($ioctl_fields)* $field: $ty,),
|
||||
($($counted_fields)* $field: $ty [array<$el, $counted_by>],),
|
||||
($($noncounted_fields)*)
|
||||
);
|
||||
};
|
||||
(struct $ioctl_ty:ident, $mem_ty:ident {} =>
|
||||
($($ioctl_field:ident: $ioctl_field_ty:ty,)*),
|
||||
($($counted_field:ident: $counted_ty:ty [array<$el:ty, $counted_by:ident>],)*),
|
||||
($($noncounted_field:ident: $noncounted_ty:ty,)*)
|
||||
) => {
|
||||
// FIXME check ioctl_ty doesn't have padding
|
||||
const _: $ioctl_ty = $ioctl_ty {
|
||||
$($ioctl_field: unsafe { mem::zeroed::<$ioctl_field_ty>() },)*
|
||||
};
|
||||
|
||||
#[repr(C)]
|
||||
pub struct ${concat(__, $mem_ty, Noncounted)} {
|
||||
$($noncounted_field: $noncounted_ty,)*
|
||||
}
|
||||
|
||||
pub struct $mem_ty<'a> {
|
||||
noncounted_fields: &'a mut ${concat(__, $mem_ty, Noncounted)},
|
||||
$($counted_field: &'a mut [$el],)*
|
||||
}
|
||||
|
||||
impl $crate::ioctl_data::IoctlData for $ioctl_ty {
|
||||
unsafe fn write(&self) -> Vec<u8> {
|
||||
let noncounted_fields = ${concat(__, $mem_ty, Noncounted)} {
|
||||
$($noncounted_field: self.$noncounted_field,)*
|
||||
};
|
||||
// FIXME use Vec::with_capacity
|
||||
let mut data = Vec::<u8>::new();
|
||||
data.extend_from_slice(&unsafe {
|
||||
mem::transmute::<
|
||||
${concat(__, $mem_ty, Noncounted)},
|
||||
[u8; size_of::<${concat(__, $mem_ty, Noncounted)}>()],
|
||||
>(noncounted_fields)
|
||||
});
|
||||
$(
|
||||
let size = self.$counted_by as usize * size_of::<$el>();
|
||||
if self.$counted_field as usize != 0 {
|
||||
let $counted_field = unsafe {
|
||||
slice::from_raw_parts(self.$counted_field as *const u8, size)
|
||||
};
|
||||
data.extend_from_slice(&$counted_field);
|
||||
} else {
|
||||
data.extend(iter::repeat(0u8).take(size));
|
||||
};
|
||||
|
||||
)*
|
||||
data
|
||||
}
|
||||
|
||||
unsafe fn read_from(&mut self, mut buf: &[u8]) {
|
||||
// FIXME be robust against malicious scheme implementations by returning an error
|
||||
// when the buf is the wrong size
|
||||
let noncounted_fields = buf.split_off(..size_of::<${concat(__, $mem_ty, Noncounted)}>()).unwrap();
|
||||
|
||||
$(
|
||||
let size = self.$counted_by as usize * size_of::<$el>();
|
||||
let $counted_field = buf.split_off(..size).unwrap();
|
||||
if self.$counted_field as usize != 0 {
|
||||
unsafe {
|
||||
slice::from_raw_parts_mut(self.$counted_field as *mut u8, size).copy_from_slice($counted_field);
|
||||
}
|
||||
}
|
||||
)*
|
||||
|
||||
assert!(buf.is_empty());
|
||||
|
||||
let noncounted_fields = unsafe { &*(noncounted_fields as *const _ as *const ${concat(__, $mem_ty, Noncounted)}) };
|
||||
$(self.$noncounted_field = noncounted_fields.$noncounted_field;)*
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> $mem_ty<'a> {
|
||||
pub fn with(
|
||||
mut buf: &'a mut [u8],
|
||||
f: impl FnOnce($mem_ty<'a>) -> syscall::Result<usize>,
|
||||
) -> syscall::Result<usize> {
|
||||
let noncounted_fields = buf.split_off_mut(..size_of::<${concat(__, $mem_ty, Noncounted)}>())
|
||||
.ok_or(syscall::Error::new(syscall::EINVAL))?;
|
||||
let noncounted_fields = unsafe { &mut *(noncounted_fields as *mut _ as *mut ${concat(__, $mem_ty, Noncounted)}) };
|
||||
|
||||
$(
|
||||
let $counted_field = buf.split_off_mut(..noncounted_fields.$counted_by as usize * size_of::<$el>())
|
||||
.ok_or(syscall::Error::new(syscall::EINVAL))?;
|
||||
let $counted_field = unsafe {
|
||||
slice::from_raw_parts_mut($counted_field as *mut _ as *mut $el, noncounted_fields.$counted_by as usize)
|
||||
};
|
||||
)*
|
||||
|
||||
if !buf.is_empty() {
|
||||
return Err(syscall::Error::new(syscall::EINVAL));
|
||||
}
|
||||
|
||||
|
||||
|
||||
Ok( f($mem_ty {
|
||||
noncounted_fields,
|
||||
$($counted_field,)*
|
||||
})?)
|
||||
}
|
||||
|
||||
$(
|
||||
pub fn $noncounted_field(&self) -> $noncounted_ty {
|
||||
self.noncounted_fields.$noncounted_field
|
||||
}
|
||||
|
||||
/// Should not be called for fields used as array length
|
||||
pub fn ${concat(set_, $noncounted_field)}(&mut self, data: $noncounted_ty) {
|
||||
self.noncounted_fields.$noncounted_field = data;
|
||||
}
|
||||
)*
|
||||
|
||||
$(
|
||||
pub fn $counted_field(&self) -> &[$el] {
|
||||
self.$counted_field
|
||||
}
|
||||
|
||||
pub fn ${concat(set_, $counted_field)}(&mut self, data: &[$el]) {
|
||||
let copied_count = cmp::min(data.len(), self.$counted_field.len());
|
||||
self.$counted_field[..copied_count].copy_from_slice(&data[..copied_count]);
|
||||
self.noncounted_fields.$counted_by = data.len() as _;
|
||||
}
|
||||
)*
|
||||
}
|
||||
};
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
#![feature(macro_metavar_expr_concat)]
|
||||
#![deny(unsafe_op_in_unsafe_fn)]
|
||||
#![no_std]
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
#[macro_use]
|
||||
mod ioctl_data;
|
||||
pub use ioctl_data::IoctlData;
|
||||
|
||||
pub mod drm;
|
||||
@@ -1,27 +0,0 @@
|
||||
[package]
|
||||
name = "redox-rt"
|
||||
authors = ["4lDO2 <4lDO2@protonmail.com>"]
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
license = "MIT"
|
||||
description = "Libc-independent runtime for Redox"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
bitflags.workspace = true
|
||||
goblin = { version = "0.10", default-features = false, features = ["elf32", "elf64", "endian_fd"] }
|
||||
plain.workspace = true
|
||||
ioslice.workspace = true
|
||||
redox_syscall.workspace = true
|
||||
redox-path.workspace = true
|
||||
redox_protocols.workspace = true
|
||||
|
||||
generic-rt = { path = "../generic-rt" }
|
||||
|
||||
[features]
|
||||
proc = []
|
||||
default = ["proc"]
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
@@ -1,485 +0,0 @@
|
||||
use core::{cell::SyncUnsafeCell, mem::offset_of, ptr::NonNull};
|
||||
|
||||
use syscall::{data::*, error::*};
|
||||
|
||||
use crate::{
|
||||
Tcb,
|
||||
proc::{FdGuard, FdGuardUpper, ForkArgs, fork_inner},
|
||||
signal::{PosixStackt, RtSigarea, SigStack, inner_c},
|
||||
};
|
||||
use redox_protocols::protocol::{ProcCall, RtSigInfo};
|
||||
|
||||
use super::ForkScratchpad;
|
||||
|
||||
// Setup a stack starting from the very end of the address space, and then growing downwards.
|
||||
pub const STACK_TOP: usize = 1 << 47;
|
||||
pub const STACK_SIZE: usize = 1024 * 1024;
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[repr(C)]
|
||||
pub struct SigArea {
|
||||
pub altstack_top: usize,
|
||||
pub altstack_bottom: usize,
|
||||
pub tmp_x1_x2: [usize; 2],
|
||||
pub tmp_x3_x4: [usize; 2],
|
||||
pub tmp_x5_x6: [usize; 2],
|
||||
pub tmp_x7_x8: [usize; 2],
|
||||
pub tmp_sp: usize,
|
||||
pub onstack: u64,
|
||||
pub disable_signals_depth: u64,
|
||||
pub pctl: usize, // TODO: remove
|
||||
pub last_sig_was_restart: bool,
|
||||
pub last_sigstack: Option<NonNull<SigStack>>,
|
||||
pub tmp_rt_inf: RtSigInfo,
|
||||
pub tmp_id_inf: u64,
|
||||
}
|
||||
#[repr(C)]
|
||||
#[derive(Debug, Default)]
|
||||
pub struct ArchIntRegs {
|
||||
pub x30: usize,
|
||||
pub x29: usize,
|
||||
pub x28: usize,
|
||||
pub x27: usize,
|
||||
pub x26: usize,
|
||||
pub x25: usize,
|
||||
pub x24: usize,
|
||||
pub x23: usize,
|
||||
pub x22: usize,
|
||||
pub x21: usize,
|
||||
pub x20: usize,
|
||||
pub x19: usize,
|
||||
pub x18: usize,
|
||||
pub x17: usize,
|
||||
pub x16: usize,
|
||||
pub x15: usize,
|
||||
pub x14: usize,
|
||||
pub x13: usize,
|
||||
pub x12: usize,
|
||||
pub x11: usize,
|
||||
pub x10: usize,
|
||||
pub x9: usize,
|
||||
pub x8: usize,
|
||||
pub x7: usize,
|
||||
pub x6: usize,
|
||||
pub x5: usize,
|
||||
pub x4: usize,
|
||||
pub x3: usize,
|
||||
pub x2: usize,
|
||||
pub x1: usize,
|
||||
|
||||
pub sp: usize,
|
||||
pub nzcv: usize, // user-accessible PSTATE bits
|
||||
|
||||
pub pc: usize,
|
||||
pub x0: usize,
|
||||
}
|
||||
|
||||
/// Deactive TLS, used before exec() on Redox to not trick target executable into thinking TLS
|
||||
/// is already initialized as if it was a thread.
|
||||
pub unsafe fn deactivate_tcb(open_via_dup: &FdGuardUpper) -> Result<()> {
|
||||
let mut env = syscall::EnvRegisters::default();
|
||||
|
||||
let file = open_via_dup.dup(b"regs/env")?;
|
||||
|
||||
env.tpidr_el0 = 0;
|
||||
|
||||
file.write(&mut env)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe extern "C" fn fork_impl(args: &ForkArgs, initial_rsp: *mut usize) -> usize {
|
||||
Error::mux(fork_inner(initial_rsp, args))
|
||||
}
|
||||
|
||||
unsafe extern "C" fn child_hook(scratchpad: &ForkScratchpad) {
|
||||
//let _ = syscall::write(1, alloc::format!("CUR{cur_filetable_fd}PROC{new_proc_fd}THR{new_thr_fd}\n").as_bytes());
|
||||
let _ = syscall::close(scratchpad.cur_filetable_fd);
|
||||
unsafe {
|
||||
crate::child_hook_common(crate::ChildHookCommonArgs {
|
||||
new_thr_fd: FdGuard::new(scratchpad.new_thr_fd),
|
||||
new_proc_fd: if scratchpad.new_proc_fd == usize::MAX {
|
||||
None
|
||||
} else {
|
||||
Some(FdGuard::new(scratchpad.new_proc_fd))
|
||||
},
|
||||
})
|
||||
};
|
||||
}
|
||||
|
||||
asmfunction!(__relibc_internal_fork_wrapper (usize) -> usize: ["
|
||||
stp x29, x30, [sp, #-16]!
|
||||
stp x27, x28, [sp, #-16]!
|
||||
stp x25, x26, [sp, #-16]!
|
||||
stp x23, x24, [sp, #-16]!
|
||||
stp x21, x22, [sp, #-16]!
|
||||
stp x19, x20, [sp, #-16]!
|
||||
|
||||
//TODO: store floating point regs
|
||||
|
||||
// x0: &ForkArgs
|
||||
mov x1, sp
|
||||
bl {fork_impl}
|
||||
|
||||
ldp x19, x20, [sp], #16
|
||||
ldp x21, x22, [sp], #16
|
||||
ldp x23, x24, [sp], #16
|
||||
ldp x25, x26, [sp], #16
|
||||
ldp x27, x28, [sp], #16
|
||||
ldp x29, x30, [sp], #16
|
||||
ret
|
||||
"] <= [fork_impl = sym fork_impl]);
|
||||
|
||||
asmfunction!(__relibc_internal_fork_ret: ["
|
||||
# scratchpad is in x1, move to x0 for child_hook
|
||||
mov x0, x1
|
||||
|
||||
bl {child_hook}
|
||||
|
||||
//TODO: load floating point regs
|
||||
|
||||
mov x0, xzr
|
||||
|
||||
ldp x19, x20, [sp], #16
|
||||
ldp x21, x22, [sp], #16
|
||||
ldp x23, x24, [sp], #16
|
||||
ldp x25, x26, [sp], #16
|
||||
ldp x27, x28, [sp], #16
|
||||
ldp x29, x30, [sp], #16
|
||||
|
||||
ret
|
||||
"] <= [child_hook = sym child_hook]);
|
||||
|
||||
// https://devblogs.microsoft.com/oldnewthing/20220811-00/?p=106963
|
||||
asmfunction!(__relibc_internal_sigentry: ["
|
||||
// Clear any active reservation.
|
||||
clrex
|
||||
|
||||
// The old pc and x0 are saved in the sigcontrol struct.
|
||||
mrs x0, tpidr_el0 // ABI ptr
|
||||
ldr x0, [x0] // TCB ptr
|
||||
|
||||
// Save x1-x6 and sp
|
||||
stp x1, x2, [x0, #{tcb_sa_off} + {sa_tmp_x1_x2}]
|
||||
stp x3, x4, [x0, #{tcb_sa_off} + {sa_tmp_x3_x4}]
|
||||
stp x5, x6, [x0, #{tcb_sa_off} + {sa_tmp_x5_x6}]
|
||||
stp x7, x8, [x0, #{tcb_sa_off} + {sa_tmp_x7_x8}]
|
||||
mov x1, sp
|
||||
str x1, [x0, #{tcb_sa_off} + {sa_tmp_sp}]
|
||||
|
||||
ldr x6, [x0, #{tcb_sa_off} + {sa_pctl}]
|
||||
1:
|
||||
// Load x1 with the thread's bits
|
||||
add x5, x0, #{tcb_sc_off} + {sc_word}
|
||||
ldaxr x1, [x5]
|
||||
|
||||
// First check if there are standard thread signals,
|
||||
and x4, x1, x1, lsr #32 // x4 := x1 & (x1 >> 32)
|
||||
cbnz x4, 3f // jump if x4 != 0
|
||||
clrex
|
||||
|
||||
// and if not, load process pending bitset.
|
||||
add x5, x6, #{pctl_pending}
|
||||
ldaxr x2, [x5]
|
||||
|
||||
// Check if there are standard proc signals:
|
||||
lsr x3, x1, #32 // mask
|
||||
and w3, w2, w3 // pending unblocked proc
|
||||
cbz w3, 4f // skip 'fetch_andn' step if zero
|
||||
|
||||
// If there was one, find which one, and try clearing the bit (last value in x3, addr in x6)
|
||||
// this picks the MSB rather than the LSB, unlike x86. POSIX does not require any specific
|
||||
// ordering though.
|
||||
clz w3, w3
|
||||
mov w4, #31
|
||||
sub w3, w4, w3
|
||||
// x3 now contains the sig_idx
|
||||
|
||||
mov x4, #1
|
||||
lsl x4, x4, x3 // bit to remove
|
||||
|
||||
sub x4, x2, x4 // bit was certainly set, so sub is allowed
|
||||
// x4 is now the new mask to be set
|
||||
add x5, x6, #{pctl_pending}
|
||||
|
||||
add x2, x5, #{pctl_sender_infos}
|
||||
add x2, x2, w3, uxtb 3
|
||||
ldar x2, [x2]
|
||||
|
||||
// Try clearing the bit, retrying on failure.
|
||||
stxr w1, x4, [x5] // try setting pending set to x4, set w1 := 0 on success
|
||||
cbnz w1, 1b // retry everything if this fails
|
||||
mov x1, x3
|
||||
b 2f
|
||||
4:
|
||||
// Check for realtime signals, thread/proc.
|
||||
clrex
|
||||
|
||||
// Load the pending set again. TODO: optimize this?
|
||||
// Process pending - realtime
|
||||
add x1, x6, #{pctl_pending}
|
||||
ldaxr x2, [x1]
|
||||
lsr x2, x2, #32
|
||||
|
||||
// Thread pending - realtime and allowset
|
||||
add x5, x0, #{tcb_sc_off} + {sc_word} + 8
|
||||
ldar x1, [x5]
|
||||
|
||||
orr x2, x1, x2 // combine proc and thread pending
|
||||
and x2, x2, x2, lsr #32 // AND pending with allowset
|
||||
cbz x2, 7f // spurious signal if realtime is clear
|
||||
|
||||
rbit x2, x2
|
||||
clz x2, x2
|
||||
// x2 now contains sig_idx - 32
|
||||
|
||||
// If realtime signal was directed at thread, handle it as an idempotent signal.
|
||||
lsr x3, x1, x2 // x3 := x1 >> x2; x1 is thread pending
|
||||
tbnz x3, #0, 5f // jump if bit is nonzero
|
||||
|
||||
// SYS_CALL(fd, payload_base, payload_len, metadata_len, metadata_base | (flags << 8))
|
||||
// x8 x0 x1 x2 x3 x4
|
||||
|
||||
mov x5, x0 // save TCB pointer
|
||||
mov x6, x2
|
||||
ldr x8, ={SYS_CALL}
|
||||
adrp x0, {proc_fd}
|
||||
ldr x0, [x0, #:lo12:{proc_fd}]
|
||||
add x1, x5, #{tcb_sa_off} + {sa_tmp_rt_inf}
|
||||
str x6, [x1]
|
||||
mov x2, #{RTINF_SIZE}
|
||||
adrp x4, {proc_call}
|
||||
add x4, x4, :lo12:{proc_call}
|
||||
mov x3, #1
|
||||
svc 0
|
||||
mov x3, x0
|
||||
mov x0, x5 // restore TCB pointer
|
||||
mov x2, x6 // restore signal number - 32
|
||||
add x1, x2, #32 // signal number
|
||||
cbnz x3, 1b
|
||||
b 2f
|
||||
5:
|
||||
// A realtime signal was sent to this thread, try clearing its bit.
|
||||
// x3 contains last rt signal word, x2 contains rt_idx
|
||||
clrex
|
||||
|
||||
// Calculate the absolute sig_idx
|
||||
add x1, x3, 32
|
||||
|
||||
// Load si_pid and si_uid
|
||||
add x2, x0, #{tcb_sc_off} + {sc_sender_infos}
|
||||
add x2, x2, w1, uxtb #3
|
||||
ldar x2, [x2]
|
||||
|
||||
add x3, x0, #{tcb_sc_off} + {sc_word} + 8
|
||||
ldxr x2, [x3]
|
||||
|
||||
// Calculate new mask
|
||||
mov x4, #1
|
||||
lsl x4, x4, x2
|
||||
sub x2, x2, x4 // remove bit
|
||||
|
||||
stxr w5, x2, [x3]
|
||||
cbnz w5, 1b
|
||||
str x2, [x0, #{tcb_sa_off} + {sa_tmp_id_inf}]
|
||||
b 2f
|
||||
3:
|
||||
// A standard signal was sent to this thread, try clearing its bit.
|
||||
clz w1, w1
|
||||
mov x2, #31
|
||||
sub x1, x2, x1
|
||||
|
||||
// Load si_pid and si_uid
|
||||
add x2, x0, #{tcb_sc_off} + {sc_sender_infos}
|
||||
add x2, x2, w1, uxtb #3
|
||||
ldar x2, [x2]
|
||||
|
||||
// Clear bit from mask
|
||||
mov x3, #1
|
||||
lsl x3, x3, x1
|
||||
sub x4, x4, x3
|
||||
|
||||
// Try updating the mask
|
||||
stxr w3, x1, [x5]
|
||||
cbnz w3, 1b
|
||||
|
||||
str x2, [x0, #{tcb_sa_off} + {sa_tmp_id_inf}]
|
||||
2:
|
||||
ldr x3, [x0, #{tcb_sa_off} + {sa_pctl}]
|
||||
add x3, x3, {pctl_actions}
|
||||
add x2, x3, w1, uxtb #4 // actions_base + sig_idx * sizeof Action
|
||||
// TODO: NOT ATOMIC (tearing allowed between regs)!
|
||||
ldxp x2, x3, [x2]
|
||||
clrex
|
||||
|
||||
// Calculate new sp wrt redzone and alignment
|
||||
mov x4, sp
|
||||
sub x4, x4, {REDZONE_SIZE}
|
||||
and x4, x4, -{STACK_ALIGN}
|
||||
mov sp, x4
|
||||
|
||||
// skip sigaltstack step if SA_ONSTACK is clear
|
||||
// tbz x2, #{SA_ONSTACK_BIT}, 2f
|
||||
|
||||
ldr x2, [x0, #{tcb_sc_off} + {sc_saved_pc}]
|
||||
ldr x3, [x0, #{tcb_sc_off} + {sc_saved_x0}]
|
||||
stp x2, x3, [sp, #-16]!
|
||||
|
||||
ldr x2, [x0, #{tcb_sa_off} + {sa_tmp_sp}]
|
||||
mrs x3, nzcv
|
||||
stp x2, x3, [sp, #-16]!
|
||||
|
||||
ldp x2, x3, [x0, #{tcb_sa_off} + {sa_tmp_x1_x2}]
|
||||
stp x2, x3, [sp, #-16]!
|
||||
ldp x3, x4, [x0, #{tcb_sa_off} + {sa_tmp_x3_x4}]
|
||||
stp x4, x3, [sp, #-16]!
|
||||
ldp x5, x6, [x0, #{tcb_sa_off} + {sa_tmp_x5_x6}]
|
||||
stp x6, x5, [sp, #-16]!
|
||||
ldp x7, x8, [x0, #{tcb_sa_off} + {sa_tmp_x7_x8}]
|
||||
stp x8, x7, [sp, #-16]!
|
||||
|
||||
stp x10, x9, [sp, #-16]!
|
||||
stp x12, x11, [sp, #-16]!
|
||||
stp x14, x13, [sp, #-16]!
|
||||
stp x16, x15, [sp, #-16]!
|
||||
stp x18, x17, [sp, #-16]!
|
||||
stp x20, x19, [sp, #-16]!
|
||||
stp x22, x21, [sp, #-16]!
|
||||
stp x24, x23, [sp, #-16]!
|
||||
stp x26, x25, [sp, #-16]!
|
||||
stp x28, x27, [sp, #-16]!
|
||||
stp x30, x29, [sp, #-16]!
|
||||
|
||||
str w1, [sp, #-4]
|
||||
sub sp, sp, #64
|
||||
|
||||
mov x0, sp
|
||||
bl {inner}
|
||||
|
||||
add sp, sp, #64
|
||||
|
||||
ldp x30, x29, [sp], #16
|
||||
ldp x28, x27, [sp], #16
|
||||
ldp x26, x25, [sp], #16
|
||||
ldp x24, x23, [sp], #16
|
||||
ldp x22, x21, [sp], #16
|
||||
ldp x20, x19, [sp], #16
|
||||
ldp x18, x17, [sp], #16
|
||||
ldp x16, x15, [sp], #16
|
||||
ldp x14, x13, [sp], #16
|
||||
ldp x12, x11, [sp], #16
|
||||
ldp x10, x9, [sp], #16
|
||||
ldp x8, x7, [sp], #16
|
||||
ldp x6, x5, [sp], #16
|
||||
ldp x4, x3, [sp], #16
|
||||
ldp x2, x1, [sp], #16
|
||||
|
||||
ldr x0, [sp, #8]
|
||||
msr nzcv, x0
|
||||
|
||||
8:
|
||||
// x18 is reserved by ABI as 'platform register', so clobbering it should be safe.
|
||||
mov x18, sp
|
||||
ldr x0, [x18]
|
||||
mov sp, x0
|
||||
|
||||
ldp x18, x0, [x18, #16]
|
||||
br x18
|
||||
7:
|
||||
// Spurious signal, i.e. all bitsets were 0 at the time they were checked
|
||||
clrex
|
||||
|
||||
ldr x1, [x0, #{tcb_sc_off} + {sc_flags}]
|
||||
and x1, x1, ~1
|
||||
str x1, [x0, #{tcb_sc_off} + {sc_flags}]
|
||||
|
||||
ldp x1, x2, [x0, #{tcb_sa_off} + {sa_tmp_x1_x2}]
|
||||
ldp x3, x4, [x0, #{tcb_sa_off} + {sa_tmp_x3_x4}]
|
||||
ldp x5, x6, [x0, #{tcb_sa_off} + {sa_tmp_x5_x6}]
|
||||
ldr x18, [x0, #{tcb_sc_off} + {sc_saved_pc}]
|
||||
ldr x0, [x0, #{tcb_sc_off} + {sc_saved_x0}]
|
||||
br x18
|
||||
"] <= [
|
||||
pctl_pending = const (offset_of!(SigProcControl, pending)),
|
||||
pctl_actions = const (offset_of!(SigProcControl, actions)),
|
||||
pctl_sender_infos = const (offset_of!(SigProcControl, sender_infos)),
|
||||
tcb_sc_off = const (offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control)),
|
||||
tcb_sa_off = const (offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, arch)),
|
||||
sa_tmp_x1_x2 = const offset_of!(SigArea, tmp_x1_x2),
|
||||
sa_tmp_x3_x4 = const offset_of!(SigArea, tmp_x3_x4),
|
||||
sa_tmp_x5_x6 = const offset_of!(SigArea, tmp_x5_x6),
|
||||
sa_tmp_x7_x8 = const offset_of!(SigArea, tmp_x7_x8),
|
||||
sa_tmp_sp = const offset_of!(SigArea, tmp_sp),
|
||||
sa_tmp_rt_inf = const offset_of!(SigArea, tmp_rt_inf),
|
||||
sa_tmp_id_inf = const offset_of!(SigArea, tmp_id_inf),
|
||||
sa_pctl = const offset_of!(SigArea, pctl),
|
||||
sc_saved_pc = const offset_of!(Sigcontrol, saved_ip),
|
||||
sc_saved_x0 = const offset_of!(Sigcontrol, saved_archdep_reg),
|
||||
sc_sender_infos = const offset_of!(Sigcontrol, sender_infos),
|
||||
sc_word = const offset_of!(Sigcontrol, word),
|
||||
sc_flags = const offset_of!(Sigcontrol, control_flags),
|
||||
proc_fd = sym PROC_FD,
|
||||
inner = sym inner_c,
|
||||
proc_call = sym PROC_CALL,
|
||||
|
||||
SA_ONSTACK_BIT = const 58, // (1 << 58) >> 32 = 0x0400_0000
|
||||
|
||||
SYS_CALL = const syscall::SYS_CALL,
|
||||
|
||||
STACK_ALIGN = const 16,
|
||||
REDZONE_SIZE = const 128,
|
||||
RTINF_SIZE = const size_of::<RtSigInfo>(),
|
||||
]);
|
||||
|
||||
asmfunction!(__relibc_internal_rlct_clone_ret: ["
|
||||
# Load registers
|
||||
ldp x8, x0, [sp], #16
|
||||
ldp x1, x2, [sp], #16
|
||||
ldp x3, x4, [sp], #16
|
||||
|
||||
# Call entry point
|
||||
blr x8
|
||||
|
||||
ret
|
||||
"] <= []);
|
||||
|
||||
pub fn current_sp() -> usize {
|
||||
let sp: usize;
|
||||
unsafe {
|
||||
core::arch::asm!("mov {}, sp", out(reg) sp);
|
||||
}
|
||||
sp
|
||||
}
|
||||
|
||||
pub unsafe fn manually_enter_trampoline() {
|
||||
let ctl = unsafe { &Tcb::current().unwrap().os_specific.control };
|
||||
|
||||
ctl.saved_archdep_reg.set(0);
|
||||
let ip_location = &ctl.saved_ip as *const _ as usize;
|
||||
|
||||
unsafe {
|
||||
core::arch::asm!("
|
||||
bl 2f
|
||||
b 3f
|
||||
2:
|
||||
str lr, [x0]
|
||||
b __relibc_internal_sigentry
|
||||
3:
|
||||
",
|
||||
inout("x0") ip_location => _, out("lr") _);
|
||||
}
|
||||
}
|
||||
|
||||
pub unsafe fn arch_pre(stack: &mut SigStack, os: &mut SigArea) -> PosixStackt {
|
||||
PosixStackt {
|
||||
sp: core::ptr::null_mut(), // TODO
|
||||
size: 0, // TODO
|
||||
flags: 0, // TODO
|
||||
}
|
||||
}
|
||||
pub fn arch_ret_to_sig(stack: &mut SigStack, control: &Sigcontrol) {
|
||||
let orig_pc = core::mem::replace(&mut stack.regs.pc, __relibc_internal_sigentry as usize);
|
||||
control.saved_ip.set(orig_pc);
|
||||
control.saved_archdep_reg.set(stack.regs.x0);
|
||||
}
|
||||
pub(crate) static PROC_FD: SyncUnsafeCell<usize> = SyncUnsafeCell::new(usize::MAX);
|
||||
static PROC_CALL: [usize; 1] = [ProcCall::Sigdeq as usize];
|
||||
@@ -1,411 +0,0 @@
|
||||
use core::{cell::SyncUnsafeCell, mem::offset_of, ptr::NonNull, sync::atomic::Ordering};
|
||||
|
||||
use syscall::*;
|
||||
|
||||
use crate::{
|
||||
proc::{FdGuard, FdGuardUpper, ForkArgs, fork_inner},
|
||||
signal::{PROC_CONTROL_STRUCT, PosixStackt, RtSigarea, SigStack, inner_fastcall},
|
||||
};
|
||||
use redox_protocols::protocol::{ProcCall, RtSigInfo};
|
||||
|
||||
use super::ForkScratchpad;
|
||||
|
||||
// Setup a stack starting from the very end of the address space, and then growing downwards.
|
||||
pub const STACK_TOP: usize = 1 << 31;
|
||||
pub const STACK_SIZE: usize = 1024 * 1024;
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[repr(C)]
|
||||
pub struct SigArea {
|
||||
pub altstack_top: usize,
|
||||
pub altstack_bottom: usize,
|
||||
pub tmp_eip: usize,
|
||||
pub tmp_esp: usize,
|
||||
pub tmp_eax: usize,
|
||||
pub tmp_ebx: usize,
|
||||
pub tmp_ecx: usize,
|
||||
pub tmp_edx: usize,
|
||||
pub tmp_edi: usize,
|
||||
pub tmp_esi: usize,
|
||||
pub tmp_rt_inf: RtSigInfo,
|
||||
pub tmp_signo: usize,
|
||||
pub tmp_id_inf: u64,
|
||||
pub tmp_mm0: u64,
|
||||
pub disable_signals_depth: u64,
|
||||
pub last_sig_was_restart: bool,
|
||||
pub last_sigstack: Option<NonNull<SigStack>>,
|
||||
}
|
||||
#[derive(Debug, Default)]
|
||||
#[repr(C, align(16))]
|
||||
pub struct ArchIntRegs {
|
||||
pub fxsave: [u16; 29],
|
||||
|
||||
// ensure fxsave region is 16 byte aligned
|
||||
pub _pad: [usize; 2], // fxsave "available" +0
|
||||
|
||||
pub ebp: usize, // fxsave "available" +8
|
||||
pub esi: usize, // avail +12
|
||||
pub edi: usize, // avail +16
|
||||
pub ebx: usize, // avail +20
|
||||
pub eax: usize, // avail +24
|
||||
pub ecx: usize, // avail +28
|
||||
pub edx: usize, // avail +32
|
||||
|
||||
pub eflags: usize, // avail +36
|
||||
pub eip: usize, // avail +40
|
||||
pub esp: usize, // avail +44
|
||||
}
|
||||
|
||||
/// Deactive TLS, used before exec() on Redox to not trick target executable into thinking TLS
|
||||
/// is already initialized as if it was a thread.
|
||||
pub unsafe fn deactivate_tcb(open_via_dup: &FdGuardUpper) -> Result<()> {
|
||||
let mut env = syscall::EnvRegisters::default();
|
||||
|
||||
let file = open_via_dup.dup(b"regs/env")?;
|
||||
|
||||
env.fsbase = 0;
|
||||
env.gsbase = 0;
|
||||
|
||||
file.write(&mut env)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe extern "fastcall" fn fork_impl(args: &ForkArgs, initial_rsp: *mut usize) -> usize {
|
||||
Error::mux(fork_inner(initial_rsp, args))
|
||||
}
|
||||
|
||||
// TODO: duplicate code with x86_64
|
||||
unsafe extern "cdecl" fn child_hook(scratchpad: ForkScratchpad) {
|
||||
let _ = syscall::close(scratchpad.cur_filetable_fd);
|
||||
unsafe {
|
||||
crate::child_hook_common(crate::ChildHookCommonArgs {
|
||||
new_thr_fd: FdGuard::new(scratchpad.new_thr_fd),
|
||||
new_proc_fd: if scratchpad.new_proc_fd == usize::MAX {
|
||||
None
|
||||
} else {
|
||||
Some(FdGuard::new(scratchpad.new_proc_fd))
|
||||
},
|
||||
})
|
||||
};
|
||||
}
|
||||
|
||||
asmfunction!(__relibc_internal_fork_wrapper (usize) -> usize: ["
|
||||
mov ecx, [esp+4]
|
||||
|
||||
push ebp
|
||||
mov ebp, esp
|
||||
|
||||
// Push preserved registers
|
||||
push ebx
|
||||
push edi
|
||||
push esi
|
||||
push ebp
|
||||
|
||||
sub esp, 32
|
||||
|
||||
//TODO stmxcsr [esp+16]
|
||||
fnstcw [esp+24]
|
||||
|
||||
mov edx, esp
|
||||
call {fork_impl}
|
||||
|
||||
jmp 2f
|
||||
"] <= [fork_impl = sym fork_impl]);
|
||||
|
||||
asmfunction!(__relibc_internal_fork_ret: ["
|
||||
// Arguments already on the stack
|
||||
call {child_hook}
|
||||
|
||||
//TODO ldmxcsr [esp+16]
|
||||
fldcw [esp+24]
|
||||
|
||||
xor eax, eax
|
||||
|
||||
.p2align 4
|
||||
2:
|
||||
add esp, 32
|
||||
|
||||
// Pop preserved registers
|
||||
pop ebp
|
||||
pop esi
|
||||
pop edi
|
||||
pop ebx
|
||||
|
||||
pop ebp
|
||||
|
||||
ret
|
||||
"] <= [child_hook = sym child_hook]);
|
||||
asmfunction!(__relibc_internal_sigentry: ["
|
||||
// Save some registers
|
||||
mov gs:[{tcb_sa_off} + {sa_tmp_esp}], esp
|
||||
mov gs:[{tcb_sa_off} + {sa_tmp_eax}], eax
|
||||
mov gs:[{tcb_sa_off} + {sa_tmp_edx}], edx
|
||||
mov gs:[{tcb_sa_off} + {sa_tmp_ecx}], ecx
|
||||
mov gs:[{tcb_sa_off} + {sa_tmp_ebx}], ebx
|
||||
mov gs:[{tcb_sa_off} + {sa_tmp_edi}], edi
|
||||
mov gs:[{tcb_sa_off} + {sa_tmp_esi}], esi
|
||||
1:
|
||||
// Read standard signal word - first for this thread
|
||||
mov edx, gs:[{tcb_sc_off} + {sc_word} + 4]
|
||||
mov eax, gs:[{tcb_sc_off} + {sc_word}]
|
||||
and eax, edx
|
||||
bsf eax, eax
|
||||
jnz 9f
|
||||
|
||||
// Read standard signal word - for the process
|
||||
lea ecx, [{pctl}]
|
||||
mov eax, [ecx + {pctl_pending}]
|
||||
and eax, edx
|
||||
bsf eax, eax
|
||||
jz 3f
|
||||
|
||||
// Read si_pid and si_uid, atomically.
|
||||
movq gs:[{tcb_sa_off} + {sa_tmp_mm0}], mm0
|
||||
movq mm0, [ecx + {pctl_sender_infos} + eax * 8]
|
||||
movq gs:[{tcb_sa_off} + {sa_tmp_id_inf}], mm0
|
||||
movq mm0, gs:[{tcb_sa_off} + {sa_tmp_mm0}]
|
||||
|
||||
// Try clearing the pending bit, otherwise retry if another thread did that first
|
||||
lock btr [ecx + {pctl_pending}], eax
|
||||
jnc 1b
|
||||
jmp 2f
|
||||
3:
|
||||
// Read realtime thread and process signal word together
|
||||
mov edx, [ecx + {pctl_pending} + 4]
|
||||
mov eax, gs:[{tcb_sc_off} + {sc_word} + 8]
|
||||
or eax, edx
|
||||
and eax, gs:[{tcb_sc_off} + {sc_word} + 12]
|
||||
bsf eax, eax
|
||||
jz 7f // spurious signal
|
||||
|
||||
// If thread rather than process was specifically targeted, send the signal to it first.
|
||||
bt edx, eax
|
||||
jnc 8f
|
||||
|
||||
// SYS_CALL(fd, payload_base, payload_len, metadata_len, metadata_base)
|
||||
// eax ebx ecx edx esi edi
|
||||
|
||||
mov ebx, [{proc_fd}]
|
||||
mov ecx, gs:[0]
|
||||
add ecx, {tcb_sa_off} + {sa_tmp_rt_inf}
|
||||
mov [ecx], eax
|
||||
mov gs:[{tcb_sa_off} + {sa_tmp_signo}], eax
|
||||
mov edx, {RTINF_SIZE}
|
||||
mov esi, 1
|
||||
lea edi, [{proc_call}]
|
||||
mov eax, {SYS_CALL}
|
||||
int 0x80
|
||||
test eax, eax
|
||||
jnz 1b
|
||||
|
||||
mov eax, gs:[{tcb_sa_off} + {sa_tmp_signo}]
|
||||
add eax, 32
|
||||
jmp 2f
|
||||
8:
|
||||
add eax, 32
|
||||
9:
|
||||
// Read si_pid and si_uid, atomically.
|
||||
movq gs:[{tcb_sa_off} + {sa_tmp_mm0}], mm0
|
||||
movq mm0, gs:[{tcb_sc_off} + {sc_sender_infos} + eax * 8]
|
||||
movq gs:[{tcb_sa_off} + {sa_tmp_id_inf}], mm0
|
||||
movq mm0, gs:[{tcb_sa_off} + {sa_tmp_mm0}]
|
||||
mov edx, eax
|
||||
shr edx, 5
|
||||
mov ecx, eax
|
||||
and ecx, 31
|
||||
lock btr gs:[{tcb_sc_off} + {sc_word} + edx * 8], ecx
|
||||
|
||||
add eax, 64
|
||||
2:
|
||||
and esp, -{STACK_ALIGN}
|
||||
|
||||
mov edx, eax
|
||||
add edx, edx
|
||||
bt dword ptr [{pctl} + {pctl_actions} + edx * 8 + 4], 28
|
||||
jnc 4f
|
||||
|
||||
mov edx, gs:[{tcb_sa_off} + {sa_altstack_top}]
|
||||
cmp esp, edx
|
||||
ja 3f
|
||||
|
||||
cmp esp, gs:[{tcb_sa_off} + {sa_altstack_bottom}]
|
||||
jnbe 4f
|
||||
3:
|
||||
mov esp, edx
|
||||
4:
|
||||
// Now that we have a stack, we can finally start populating the signal stack.
|
||||
push dword ptr gs:[{tcb_sa_off} + {sa_tmp_esp}]
|
||||
push dword ptr gs:[{tcb_sc_off} + {sc_saved_eip}]
|
||||
push dword ptr gs:[{tcb_sc_off} + {sc_saved_eflags}]
|
||||
|
||||
push dword ptr gs:[{tcb_sa_off} + {sa_tmp_edx}]
|
||||
push dword ptr gs:[{tcb_sa_off} + {sa_tmp_ecx}]
|
||||
push dword ptr gs:[{tcb_sa_off} + {sa_tmp_eax}]
|
||||
push dword ptr gs:[{tcb_sa_off} + {sa_tmp_ebx}]
|
||||
push dword ptr gs:[{tcb_sa_off} + {sa_tmp_edi}]
|
||||
push dword ptr gs:[{tcb_sa_off} + {sa_tmp_esi}]
|
||||
push ebp
|
||||
|
||||
sub esp, 2 * 4 + 29 * 16
|
||||
fxsave [esp]
|
||||
|
||||
mov [esp - 4], eax
|
||||
sub esp, 48
|
||||
|
||||
mov ecx, esp
|
||||
call {inner}
|
||||
|
||||
fxrstor [esp + 48]
|
||||
add esp, 48 + 29 * 16 + 2 * 4
|
||||
|
||||
pop ebp
|
||||
pop esi
|
||||
pop edi
|
||||
pop ebx
|
||||
pop eax
|
||||
pop ecx
|
||||
pop edx
|
||||
|
||||
popfd
|
||||
pop dword ptr gs:[{tcb_sa_off} + {sa_tmp_eip}]
|
||||
|
||||
.globl __relibc_internal_sigentry_crit_first
|
||||
__relibc_internal_sigentry_crit_first:
|
||||
pop esp
|
||||
|
||||
.globl __relibc_internal_sigentry_crit_second
|
||||
__relibc_internal_sigentry_crit_second:
|
||||
jmp dword ptr gs:[{tcb_sa_off} + {sa_tmp_eip}]
|
||||
7:
|
||||
mov eax, gs:[0]
|
||||
lea esp, [eax + {tcb_sc_off} + {sc_saved_eflags}]
|
||||
popfd
|
||||
|
||||
mov esp, gs:[{tcb_sa_off} + {sa_tmp_esp}]
|
||||
|
||||
mov eax, gs:[{tcb_sc_off} + {sc_saved_eip}]
|
||||
mov gs:[{tcb_sa_off} + {sa_tmp_eip}], eax
|
||||
|
||||
mov eax, gs:[{tcb_sa_off} + {sa_tmp_eax}]
|
||||
mov ebx, gs:[{tcb_sa_off} + {sa_tmp_ebx}]
|
||||
mov ecx, gs:[{tcb_sa_off} + {sa_tmp_ecx}]
|
||||
mov edx, gs:[{tcb_sa_off} + {sa_tmp_edx}]
|
||||
mov edi, gs:[{tcb_sa_off} + {sa_tmp_edi}]
|
||||
mov esi, gs:[{tcb_sa_off} + {sa_tmp_esi}]
|
||||
|
||||
and dword ptr gs:[{tcb_sc_off} + {sc_control}], ~1
|
||||
.globl __relibc_internal_sigentry_crit_third
|
||||
__relibc_internal_sigentry_crit_third:
|
||||
jmp dword ptr gs:[{tcb_sa_off} + {sa_tmp_eip}]
|
||||
"] <= [
|
||||
inner = sym inner_fastcall,
|
||||
sa_tmp_eip = const offset_of!(SigArea, tmp_eip),
|
||||
sa_tmp_esp = const offset_of!(SigArea, tmp_esp),
|
||||
sa_tmp_eax = const offset_of!(SigArea, tmp_eax),
|
||||
sa_tmp_ebx = const offset_of!(SigArea, tmp_ebx),
|
||||
sa_tmp_ecx = const offset_of!(SigArea, tmp_ecx),
|
||||
sa_tmp_edx = const offset_of!(SigArea, tmp_edx),
|
||||
sa_tmp_edi = const offset_of!(SigArea, tmp_edi),
|
||||
sa_tmp_esi = const offset_of!(SigArea, tmp_esi),
|
||||
sa_tmp_mm0 = const offset_of!(SigArea, tmp_mm0),
|
||||
sa_tmp_rt_inf = const offset_of!(SigArea, tmp_rt_inf),
|
||||
sa_tmp_id_inf = const offset_of!(SigArea, tmp_id_inf),
|
||||
sa_tmp_signo = const offset_of!(SigArea, tmp_signo),
|
||||
sa_altstack_top = const offset_of!(SigArea, altstack_top),
|
||||
sa_altstack_bottom = const offset_of!(SigArea, altstack_bottom),
|
||||
sc_control = const offset_of!(Sigcontrol, control_flags),
|
||||
sc_saved_eflags = const offset_of!(Sigcontrol, saved_archdep_reg),
|
||||
sc_saved_eip = const offset_of!(Sigcontrol, saved_ip),
|
||||
sc_word = const offset_of!(Sigcontrol, word),
|
||||
sc_sender_infos = const offset_of!(Sigcontrol, sender_infos),
|
||||
tcb_sa_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, arch),
|
||||
tcb_sc_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control),
|
||||
pctl_actions = const offset_of!(SigProcControl, actions),
|
||||
pctl_sender_infos = const offset_of!(SigProcControl, sender_infos),
|
||||
pctl_pending = const offset_of!(SigProcControl, pending),
|
||||
pctl = sym PROC_CONTROL_STRUCT,
|
||||
proc_fd = sym PROC_FD,
|
||||
proc_call = sym PROC_CALL,
|
||||
STACK_ALIGN = const 16,
|
||||
SYS_CALL = const syscall::SYS_CALL,
|
||||
RTINF_SIZE = const size_of::<RtSigInfo>(),
|
||||
]);
|
||||
|
||||
asmfunction!(__relibc_internal_rlct_clone_ret -> usize: ["
|
||||
# Load registers
|
||||
pop eax
|
||||
|
||||
sub esp, 8
|
||||
|
||||
mov DWORD PTR [esp], 0x00001F80
|
||||
# TODO: ldmxcsr [esp]
|
||||
mov WORD PTR [esp], 0x037F
|
||||
fldcw [esp]
|
||||
|
||||
add esp, 8
|
||||
|
||||
# Call entry point
|
||||
call eax
|
||||
|
||||
ret
|
||||
"] <= []);
|
||||
unsafe extern "C" {
|
||||
fn __relibc_internal_sigentry_crit_first();
|
||||
fn __relibc_internal_sigentry_crit_second();
|
||||
fn __relibc_internal_sigentry_crit_third();
|
||||
}
|
||||
pub unsafe fn arch_pre(stack: &mut SigStack, area: &mut SigArea) -> PosixStackt {
|
||||
if stack.regs.eip == __relibc_internal_sigentry_crit_first as usize {
|
||||
let stack_ptr = stack.regs.esp as *const usize;
|
||||
stack.regs.esp = unsafe { stack_ptr.read() };
|
||||
stack.regs.eip = unsafe { stack_ptr.sub(1).read() };
|
||||
} else if stack.regs.eip == __relibc_internal_sigentry_crit_second as usize
|
||||
|| stack.regs.eip == __relibc_internal_sigentry_crit_third as usize
|
||||
{
|
||||
stack.regs.eip = area.tmp_eip;
|
||||
}
|
||||
PosixStackt {
|
||||
sp: stack.regs.esp as *mut (),
|
||||
size: 0, // TODO
|
||||
flags: 0, // TODO
|
||||
}
|
||||
}
|
||||
pub fn arch_ret_to_sig(stack: &mut SigStack, control: &Sigcontrol) {
|
||||
let orig_eip = core::mem::replace(&mut stack.regs.eip, __relibc_internal_sigentry as usize);
|
||||
control.saved_ip.set(orig_eip);
|
||||
control.saved_archdep_reg.set(stack.regs.eflags);
|
||||
}
|
||||
#[unsafe(no_mangle)]
|
||||
pub unsafe fn manually_enter_trampoline() {
|
||||
let c = unsafe { &crate::Tcb::current().unwrap().os_specific.control };
|
||||
c.control_flags.store(
|
||||
c.control_flags.load(Ordering::Relaxed) | syscall::flag::INHIBIT_DELIVERY.bits(),
|
||||
Ordering::Release,
|
||||
);
|
||||
c.saved_archdep_reg.set(0); // TODO: Just reset DF on x86?
|
||||
|
||||
unsafe {
|
||||
core::arch::asm!("
|
||||
call 2f
|
||||
jmp 3f
|
||||
2:
|
||||
pop dword ptr gs:[{tcb_sc_off} + {sc_saved_eip}]
|
||||
jmp __relibc_internal_sigentry
|
||||
3:
|
||||
",
|
||||
tcb_sc_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control),
|
||||
sc_saved_eip = const offset_of!(Sigcontrol, saved_ip),
|
||||
);
|
||||
}
|
||||
}
|
||||
/// Get current stack pointer, weak granularity guarantees.
|
||||
pub fn current_sp() -> usize {
|
||||
let sp: usize;
|
||||
unsafe {
|
||||
core::arch::asm!("mov {}, esp", out(reg) sp);
|
||||
}
|
||||
sp
|
||||
}
|
||||
|
||||
pub static PROC_FD: SyncUnsafeCell<usize> = SyncUnsafeCell::new(usize::MAX);
|
||||
static PROC_CALL: u64 = ProcCall::Sigdeq as u64;
|
||||
@@ -1,27 +0,0 @@
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
pub use self::aarch64::*;
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
pub mod aarch64;
|
||||
|
||||
#[cfg(target_arch = "x86")]
|
||||
pub use self::i686::*;
|
||||
#[cfg(target_arch = "x86")]
|
||||
pub mod i686;
|
||||
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
pub use self::x86_64::*;
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
pub mod x86_64;
|
||||
|
||||
#[cfg(target_arch = "riscv64")]
|
||||
pub use self::riscv64::*;
|
||||
#[cfg(target_arch = "riscv64")]
|
||||
pub mod riscv64;
|
||||
|
||||
#[derive(Debug)]
|
||||
#[repr(C)]
|
||||
pub struct ForkScratchpad {
|
||||
pub cur_filetable_fd: usize,
|
||||
pub new_proc_fd: usize,
|
||||
pub new_thr_fd: usize,
|
||||
}
|
||||
@@ -1,654 +0,0 @@
|
||||
use core::cell::SyncUnsafeCell;
|
||||
|
||||
use crate::{
|
||||
Tcb,
|
||||
proc::{FdGuard, FdGuardUpper, ForkArgs, fork_inner},
|
||||
signal::{PosixStackt, RtSigarea, SigStack, get_sigaltstack, inner_c},
|
||||
};
|
||||
use core::{mem::offset_of, ptr::NonNull, sync::atomic::Ordering};
|
||||
use redox_protocols::protocol::{ProcCall, RtSigInfo};
|
||||
use syscall::{data::*, error::*};
|
||||
|
||||
use super::ForkScratchpad;
|
||||
|
||||
// Setup a stack starting from the very end of the address space, and then growing downwards.
|
||||
pub const STACK_TOP: usize = 1 << 38;
|
||||
pub const STACK_SIZE: usize = 1024 * 1024;
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[repr(C)]
|
||||
pub struct SigArea {
|
||||
pub tmp_sp: u64,
|
||||
pub tmp_t1: u64,
|
||||
pub tmp_t2: u64,
|
||||
pub tmp_t3: u64,
|
||||
pub tmp_t4: u64,
|
||||
pub tmp_a0: u64,
|
||||
pub tmp_a1: u64,
|
||||
pub tmp_a2: u64,
|
||||
pub tmp_a3: u64,
|
||||
pub tmp_a4: u64,
|
||||
pub tmp_a7: u64,
|
||||
|
||||
pub pctl: usize, // TODO: remove
|
||||
pub tmp_ip: u64,
|
||||
pub tmp_rt_inf: RtSigInfo,
|
||||
pub tmp_id_inf: u64,
|
||||
pub altstack_top: usize,
|
||||
pub altstack_bottom: usize,
|
||||
pub disable_signals_depth: u64,
|
||||
pub last_sig_was_restart: bool,
|
||||
pub last_sigstack: Option<NonNull<SigStack>>,
|
||||
}
|
||||
#[repr(C)]
|
||||
#[derive(Debug, Default)]
|
||||
pub struct ArchIntRegs {
|
||||
pub int_regs: [u64; 31],
|
||||
pub pc: u64,
|
||||
pub fp_regs: [u64; 32],
|
||||
pub fcsr: u32,
|
||||
_pad: u32,
|
||||
}
|
||||
|
||||
/// Deactive TLS, used before exec() on Redox to not trick target executable into thinking TLS
|
||||
/// is already initialized as if it was a thread.
|
||||
pub unsafe fn deactivate_tcb(open_via_dup: &FdGuardUpper) -> Result<()> {
|
||||
let mut env = syscall::EnvRegisters::default();
|
||||
|
||||
let file = open_via_dup.dup(b"regs/env")?;
|
||||
|
||||
env.tp = 0;
|
||||
|
||||
file.write(&mut env)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe extern "C" fn fork_impl(args: &ForkArgs, initial_rsp: *mut usize) -> usize {
|
||||
Error::mux(fork_inner(initial_rsp, args))
|
||||
}
|
||||
|
||||
unsafe extern "C" fn child_hook(scratchpad: &ForkScratchpad) {
|
||||
let _ = syscall::close(scratchpad.cur_filetable_fd);
|
||||
unsafe {
|
||||
crate::child_hook_common(crate::ChildHookCommonArgs {
|
||||
new_thr_fd: FdGuard::new(scratchpad.new_thr_fd),
|
||||
new_proc_fd: if scratchpad.new_proc_fd == usize::MAX {
|
||||
None
|
||||
} else {
|
||||
Some(FdGuard::new(scratchpad.new_proc_fd))
|
||||
},
|
||||
})
|
||||
};
|
||||
}
|
||||
|
||||
asmfunction!(__relibc_internal_fork_wrapper (usize) -> usize: ["
|
||||
.attribute arch, \"rv64gc\" # rust bug 80608
|
||||
addi sp, sp, -200
|
||||
sd s0, 0(sp)
|
||||
sd s1, 8(sp)
|
||||
sd s2, 16(sp)
|
||||
sd s3, 24(sp)
|
||||
sd s4, 32(sp)
|
||||
sd s5, 40(sp)
|
||||
sd s6, 48(sp)
|
||||
sd s7, 56(sp)
|
||||
sd s8, 64(sp)
|
||||
sd s9, 72(sp)
|
||||
sd s10, 80(sp)
|
||||
sd s11, 88(sp)
|
||||
sd ra, 96(sp)
|
||||
|
||||
fsd fs0, 104(sp)
|
||||
fsd fs1, 112(sp)
|
||||
fsd fs2, 120(sp)
|
||||
fsd fs3, 128(sp)
|
||||
fsd fs4, 136(sp)
|
||||
fsd fs5, 144(sp)
|
||||
fsd fs6, 152(sp)
|
||||
fsd fs7, 160(sp)
|
||||
fsd fs8, 168(sp)
|
||||
fsd fs9, 176(sp)
|
||||
fsd fs10, 184(sp)
|
||||
fsd fs11, 192(sp)
|
||||
|
||||
// a0 is forwarded from this function
|
||||
mv a1, sp
|
||||
jal {fork_impl}
|
||||
|
||||
ld s0, 0(sp)
|
||||
ld s1, 8(sp)
|
||||
ld s2, 16(sp)
|
||||
ld s3, 24(sp)
|
||||
ld s4, 32(sp)
|
||||
ld s5, 40(sp)
|
||||
ld s6, 48(sp)
|
||||
ld s7, 56(sp)
|
||||
ld s8, 64(sp)
|
||||
ld s9, 72(sp)
|
||||
ld s10, 80(sp)
|
||||
ld s11, 88(sp)
|
||||
ld ra, 96(sp)
|
||||
|
||||
fld fs0, 104(sp)
|
||||
fld fs1, 112(sp)
|
||||
fld fs2, 120(sp)
|
||||
fld fs3, 128(sp)
|
||||
fld fs4, 136(sp)
|
||||
fld fs5, 144(sp)
|
||||
fld fs6, 152(sp)
|
||||
fld fs7, 160(sp)
|
||||
fld fs8, 168(sp)
|
||||
fld fs9, 176(sp)
|
||||
fld fs10, 184(sp)
|
||||
fld fs11, 192(sp)
|
||||
|
||||
addi sp, sp, 200
|
||||
ret
|
||||
"] <= [fork_impl = sym fork_impl]);
|
||||
|
||||
asmfunction!(__relibc_internal_fork_ret: ["
|
||||
.attribute arch, \"rv64gc\" # rust bug 80608
|
||||
|
||||
# scratchpad is in a1, move to a0 for child_hook
|
||||
mv a0, a1
|
||||
|
||||
jal {child_hook}
|
||||
|
||||
mv a0, zero
|
||||
|
||||
ld s0, 0(sp)
|
||||
ld s1, 8(sp)
|
||||
ld s2, 16(sp)
|
||||
ld s3, 24(sp)
|
||||
ld s4, 32(sp)
|
||||
ld s5, 40(sp)
|
||||
ld s6, 48(sp)
|
||||
ld s7, 56(sp)
|
||||
ld s8, 64(sp)
|
||||
ld s9, 72(sp)
|
||||
ld s10, 80(sp)
|
||||
ld s11, 88(sp)
|
||||
ld ra, 96(sp)
|
||||
|
||||
fld fs0, 104(sp)
|
||||
fld fs1, 112(sp)
|
||||
fld fs2, 120(sp)
|
||||
fld fs3, 128(sp)
|
||||
fld fs4, 136(sp)
|
||||
fld fs5, 144(sp)
|
||||
fld fs6, 152(sp)
|
||||
fld fs7, 160(sp)
|
||||
fld fs8, 168(sp)
|
||||
fld fs9, 176(sp)
|
||||
fld fs10, 184(sp)
|
||||
fld fs11, 192(sp)
|
||||
|
||||
addi sp, sp, 200
|
||||
ret
|
||||
"] <= [child_hook = sym child_hook]);
|
||||
|
||||
asmfunction!(__relibc_internal_sigentry: ["
|
||||
.attribute arch, \"rv64gc\" # rust bug 80608
|
||||
// Save some registers
|
||||
ld t0, -8(tp) // Tcb
|
||||
sd sp, ({tcb_sa_off} + {sa_tmp_sp})(t0)
|
||||
sd t1, ({tcb_sa_off} + {sa_tmp_t1})(t0)
|
||||
sd t2, ({tcb_sa_off} + {sa_tmp_t2})(t0)
|
||||
sd t3, ({tcb_sa_off} + {sa_tmp_t3})(t0)
|
||||
sd t4, ({tcb_sa_off} + {sa_tmp_t4})(t0)
|
||||
ld t4, ({tcb_sa_off} + {sa_off_pctl})(t0)
|
||||
|
||||
// First, select signal, always pick first available bit
|
||||
99:
|
||||
// Read first signal word
|
||||
ld t1, ({tcb_sc_off} + {sc_word})(t0)
|
||||
srli t2, t1, 32 // bitset to low word
|
||||
and t1, t1, t2 // masked bitset in low word
|
||||
beqz t1, 3f
|
||||
|
||||
// Found in first thread signal word
|
||||
mv t3, x0
|
||||
2: andi t2, t1, 1
|
||||
bnez t2, 10f
|
||||
addi t3, t3, 1
|
||||
srli t1, t1, 1
|
||||
j 2b
|
||||
|
||||
// If no unblocked thread signal was found, check for process.
|
||||
// This is competitive; we need to atomically check if *we* cleared the process-wide pending
|
||||
// bit, otherwise restart.
|
||||
3: lw t1, {pctl_off_pending}(t4)
|
||||
and t1, t1, t2
|
||||
beqz t1, 3f
|
||||
// Found in first process signal word
|
||||
li t3, -1
|
||||
2: andi t2, t1, 1
|
||||
addi t3, t3, 1
|
||||
srli t1, t1, 1
|
||||
beqz t2, 2b
|
||||
slli t1, t3, 3 // * 8 == size_of SenderInfo
|
||||
add t1, t1, t4
|
||||
ld t1, {pctl_off_sender_infos}(t1)
|
||||
sd t1, ({tcb_sa_off} + {sa_tmp_id_inf})(t0)
|
||||
li t1, 1
|
||||
sll t1, t1, t3
|
||||
not t1, t1
|
||||
addi t2, t4, {pctl_off_pending}
|
||||
amoand.w.aq t2, t1, (t2)
|
||||
and t1, t1, t2
|
||||
bne t1, t2, 9f
|
||||
|
||||
3:
|
||||
// Read second signal word - both process and thread simultaneously.
|
||||
// This must be done since POSIX requires low realtime signals to be picked first.
|
||||
ld t1, ({tcb_sc_off} + {sc_word} + 8)(t0)
|
||||
lw t2, ({pctl_off_pending} + 4)(t4)
|
||||
or t4, t1, t2
|
||||
srli t2, t1, 32
|
||||
and t4, t2, t4
|
||||
beqz t4, 7f
|
||||
li t3, -1
|
||||
2: andi t2, t4, 1
|
||||
addi t3, t3, 1
|
||||
srli t4, t4, 1
|
||||
beqz t2, 2b
|
||||
li t2, 1
|
||||
sll t2, t2, t3
|
||||
and t1, t1, t2
|
||||
addi t3, t3, 32
|
||||
bnez t1, 10f // thread signal
|
||||
|
||||
// otherwise, try (competitively) dequeueing realtime signal
|
||||
|
||||
// SYS_CALL(fd, payload_base, payload_len, metadata_len, metadata_base)
|
||||
// a7 a0 a1 a2 a3 a4
|
||||
|
||||
// TODO: This SYS_CALL invocation has not yet been tested due to toolchain issues.
|
||||
|
||||
sd a0, ({tcb_sa_off} + {sa_tmp_a0})(t0)
|
||||
sd a1, ({tcb_sa_off} + {sa_tmp_a1})(t0)
|
||||
sd a2, ({tcb_sa_off} + {sa_tmp_a2})(t0)
|
||||
sd a3, ({tcb_sa_off} + {sa_tmp_a3})(t0)
|
||||
sd a4, ({tcb_sa_off} + {sa_tmp_a4})(t0)
|
||||
sd a7, ({tcb_sa_off} + {sa_tmp_a7})(t0)
|
||||
li a7, {SYS_CALL}
|
||||
addi a2, t3, -32
|
||||
add a1, t0, {tcb_sa_off} + {sa_tmp_rt_inf} // out pointer of dequeued realtime sig
|
||||
sd a2, (a1)
|
||||
li a2, {RTINF_SIZE}
|
||||
li a3, 1
|
||||
1337:
|
||||
auipc a4, %pcrel_hi({proc_fd})
|
||||
addi a4, a4, %pcrel_lo(1337b)
|
||||
ecall
|
||||
ld a3, ({tcb_sa_off} + {sa_tmp_a3})(t0)
|
||||
ld a4, ({tcb_sa_off} + {sa_tmp_a4})(t0)
|
||||
bnez a0, 99b // assumes error can only be EAGAIN
|
||||
j 9f
|
||||
|
||||
10: // thread signal. t3 holds signal number
|
||||
srli t1, t3, 5
|
||||
bnez t1, 2f // FIXME senderinfo?
|
||||
sll t2, t3, 3 // * 8 == size_of SenderInfo
|
||||
add t2, t2, t0
|
||||
ld t2, ({tcb_sc_off} + {sc_sender_infos})(t2)
|
||||
sd t2, ({tcb_sa_off} + {sa_tmp_id_inf})(t0)
|
||||
2: andi t4, t3, 31
|
||||
li t2, 1
|
||||
sll t2, t2, t4
|
||||
not t2, t2
|
||||
sll t1, t1, 3
|
||||
add t1, t1, t0
|
||||
addi t1, t1, {tcb_sc_off} + {sc_word}
|
||||
amoand.w.aq x0, t2, (t1)
|
||||
addi t3, t3, 64 // indicate signal was targeted at thread
|
||||
|
||||
9: // process signal t3 holds signal number
|
||||
|
||||
// By now we have selected a signal, stored in eax (6-bit). We now need to choose whether or
|
||||
// not to switch to the alternate signal stack. If SA_ONSTACK is clear for this signal, then
|
||||
// skip the sigaltstack logic.
|
||||
ld t4, ({tcb_sa_off} + {sa_off_pctl})(t0)
|
||||
andi t1, t3, 63
|
||||
slli t1, t1, 4 // * 16 == size_of RawAction
|
||||
add t1, t1, t4
|
||||
ld t1, {pctl_off_actions}(t1)
|
||||
slli t1, t1, 63-58 // SA_ONSTACK in sign bit
|
||||
bgez t1, 3f
|
||||
|
||||
// If current RSP is above altstack region, switch to altstack
|
||||
ld t1, ({tcb_sa_off} + {sa_altstack_top})(t0)
|
||||
bgtu sp, t1, 2f
|
||||
ld t2, ({tcb_sa_off} + {sa_altstack_bottom})(t0)
|
||||
bgtu sp, t3, 3f
|
||||
2: mv sp, t1
|
||||
3:
|
||||
// form mcontext on stack
|
||||
addi sp, sp, -33 * 8
|
||||
fsd f0, (0 * 8)(sp)
|
||||
fsd f1, (1 * 8)(sp)
|
||||
fsd f2, (2 * 8)(sp)
|
||||
fsd f3, (3 * 8)(sp)
|
||||
fsd f4, (4 * 8)(sp)
|
||||
fsd f5, (5 * 8)(sp)
|
||||
fsd f6, (6 * 8)(sp)
|
||||
fsd f7, (7 * 8)(sp)
|
||||
fsd f8, (8 * 8)(sp)
|
||||
fsd f9, (9 * 8)(sp)
|
||||
fsd f10, (10 * 8)(sp)
|
||||
fsd f11, (11 * 8)(sp)
|
||||
fsd f12, (12 * 8)(sp)
|
||||
fsd f13, (13 * 8)(sp)
|
||||
fsd f14, (14 * 8)(sp)
|
||||
fsd f15, (15 * 8)(sp)
|
||||
fsd f16, (16 * 8)(sp)
|
||||
fsd f17, (17 * 8)(sp)
|
||||
fsd f18, (18 * 8)(sp)
|
||||
fsd f19, (19 * 8)(sp)
|
||||
fsd f20, (20 * 8)(sp)
|
||||
fsd f21, (21 * 8)(sp)
|
||||
fsd f22, (22 * 8)(sp)
|
||||
fsd f23, (23 * 8)(sp)
|
||||
fsd f24, (24 * 8)(sp)
|
||||
fsd f25, (25 * 8)(sp)
|
||||
fsd f26, (26 * 8)(sp)
|
||||
fsd f27, (27 * 8)(sp)
|
||||
fsd f28, (28 * 8)(sp)
|
||||
fsd f29, (29 * 8)(sp)
|
||||
fsd f30, (30 * 8)(sp)
|
||||
fsd f31, (31 * 8)(sp)
|
||||
csrr t1, fcsr
|
||||
sw t1, (32 * 8)(sp)
|
||||
|
||||
addi sp, sp, -32 * 8
|
||||
sd x1, 0(sp)
|
||||
ld t1, ({tcb_sa_off} + {sa_tmp_sp})(t0)
|
||||
sd t1, (1 * 8)(sp) // x2 is sp
|
||||
sd x3, (2 * 8)(sp)
|
||||
sd x4, (3 * 8)(sp)
|
||||
ld t1, ({tcb_sc_off} + {sc_saved_t0})(t0)
|
||||
sd t1, (4 * 8)(sp) // x5 is t0
|
||||
ld t1, ({tcb_sa_off} + {sa_tmp_t1})(t0)
|
||||
sd t1, (5 * 8)(sp) // x6 is t1
|
||||
ld t1, ({tcb_sa_off} + {sa_tmp_t2})(t0)
|
||||
sd t1, (6 * 8)(sp) // x7 is t2
|
||||
sd x8, (7 * 8)(sp)
|
||||
sd x9, (8 * 8)(sp)
|
||||
sd x10, (9 * 8)(sp)
|
||||
sd x11, (10 * 8)(sp)
|
||||
sd x12, (11 * 8)(sp)
|
||||
sd x13, (12 * 8)(sp)
|
||||
sd x14, (13 * 8)(sp)
|
||||
sd x15, (14 * 8)(sp)
|
||||
sd x16, (15 * 8)(sp)
|
||||
sd x17, (16 * 8)(sp)
|
||||
sd x18, (17 * 8)(sp)
|
||||
sd x19, (18 * 8)(sp)
|
||||
sd x20, (19 * 8)(sp)
|
||||
sd x21, (20 * 8)(sp)
|
||||
sd x22, (21 * 8)(sp)
|
||||
sd x23, (22 * 8)(sp)
|
||||
sd x24, (23 * 8)(sp)
|
||||
sd x25, (24 * 8)(sp)
|
||||
sd x26, (25 * 8)(sp)
|
||||
sd x27, (26 * 8)(sp)
|
||||
ld t1, ({tcb_sa_off} + {sa_tmp_t3})(t0)
|
||||
sd t1, (27 * 8)(sp) // t3 is x28
|
||||
ld t1, ({tcb_sa_off} + {sa_tmp_t4})(t0)
|
||||
sd t1, (28 * 8)(sp) // t4 is x29
|
||||
sd x30, (29 * 8)(sp)
|
||||
sd x31, (30 * 8)(sp)
|
||||
ld t1, ({tcb_sc_off} + {sc_saved_ip})(t0)
|
||||
sd t1, (31 * 8)(sp)
|
||||
|
||||
// form ucontext
|
||||
addi sp, sp, -64
|
||||
sw t3, 60(sp)
|
||||
|
||||
mv t0, sp
|
||||
jal {inner}
|
||||
|
||||
addi sp, sp, 64
|
||||
|
||||
addi t0, sp, 32 * 8
|
||||
fld f0, (0 * 8)(t0)
|
||||
fld f1, (1 * 8)(t0)
|
||||
fld f2, (2 * 8)(t0)
|
||||
fld f3, (3 * 8)(t0)
|
||||
fld f4, (4 * 8)(t0)
|
||||
fld f5, (5 * 8)(t0)
|
||||
fld f6, (6 * 8)(t0)
|
||||
fld f7, (7 * 8)(t0)
|
||||
fld f8, (8 * 8)(t0)
|
||||
fld f9, (9 * 8)(t0)
|
||||
fld f10, (10 * 8)(t0)
|
||||
fld f11, (11 * 8)(t0)
|
||||
fld f12, (12 * 8)(t0)
|
||||
fld f13, (13 * 8)(t0)
|
||||
fld f14, (14 * 8)(t0)
|
||||
fld f15, (15 * 8)(t0)
|
||||
fld f16, (16 * 8)(t0)
|
||||
fld f17, (17 * 8)(t0)
|
||||
fld f18, (18 * 8)(t0)
|
||||
fld f19, (19 * 8)(t0)
|
||||
fld f20, (20 * 8)(t0)
|
||||
fld f21, (21 * 8)(t0)
|
||||
fld f22, (22 * 8)(t0)
|
||||
fld f23, (23 * 8)(t0)
|
||||
fld f24, (24 * 8)(t0)
|
||||
fld f25, (25 * 8)(t0)
|
||||
fld f26, (26 * 8)(t0)
|
||||
fld f27, (27 * 8)(t0)
|
||||
fld f28, (28 * 8)(t0)
|
||||
fld f29, (29 * 8)(t0)
|
||||
fld f30, (30 * 8)(t0)
|
||||
fld f31, (31 * 8)(t0)
|
||||
lw t1, (32 * 8)(t0)
|
||||
csrw fcsr, t1
|
||||
|
||||
ld x1, 0(sp)
|
||||
// skip sp
|
||||
// skip gp
|
||||
ld x4, (3 * 8)(sp)
|
||||
ld x5, (4 * 8)(sp)
|
||||
ld x6, (5 * 8)(sp)
|
||||
ld x7, (6 * 8)(sp)
|
||||
ld x8, (7 * 8)(sp)
|
||||
ld x9, (8 * 8)(sp)
|
||||
ld x10, (9 * 8)(sp)
|
||||
ld x11, (10 * 8)(sp)
|
||||
ld x12, (11 * 8)(sp)
|
||||
ld x13, (12 * 8)(sp)
|
||||
ld x14, (13 * 8)(sp)
|
||||
ld x15, (14 * 8)(sp)
|
||||
ld x16, (15 * 8)(sp)
|
||||
ld x17, (16 * 8)(sp)
|
||||
ld x18, (17 * 8)(sp)
|
||||
ld x19, (18 * 8)(sp)
|
||||
ld x20, (19 * 8)(sp)
|
||||
ld x21, (20 * 8)(sp)
|
||||
ld x22, (21 * 8)(sp)
|
||||
ld x23, (22 * 8)(sp)
|
||||
ld x24, (23 * 8)(sp)
|
||||
ld x25, (24 * 8)(sp)
|
||||
ld x26, (25 * 8)(sp)
|
||||
ld x27, (26 * 8)(sp)
|
||||
ld x28, (27 * 8)(sp)
|
||||
ld x29, (28 * 8)(sp)
|
||||
ld x30, (29 * 8)(sp)
|
||||
ld x31, (30 * 8)(sp)
|
||||
ld gp, (31 * 8)(sp) // new IP; this clobbers register x3/gp which is ABI reserved
|
||||
.global __relibc_internal_sigentry_crit_first
|
||||
__relibc_internal_sigentry_crit_first:
|
||||
ld sp, (1 * 8)(sp)
|
||||
.global __relibc_internal_sigentry_crit_second
|
||||
__relibc_internal_sigentry_crit_second:
|
||||
jr gp
|
||||
7:
|
||||
// A spurious signal occurred. Signals are still disabled here, but will need to be re-enabled.
|
||||
|
||||
// restore stack
|
||||
ld sp, ({tcb_sa_off} + {sa_tmp_sp})(t0)
|
||||
|
||||
// move saved IP away from control, allowing arch_pre to save us if interrupted.
|
||||
ld t1, ({tcb_sc_off} + {sc_saved_ip})(t0)
|
||||
sd t1, ({tcb_sa_off} + {sa_tmp_ip})(t0)
|
||||
|
||||
// restore regs
|
||||
ld t2, ({tcb_sa_off} + {sa_tmp_t2})(t0)
|
||||
ld t3, ({tcb_sa_off} + {sa_tmp_t3})(t0)
|
||||
ld t4, ({tcb_sa_off} + {sa_tmp_t4})(t0)
|
||||
|
||||
// move saved t0 away from control as well
|
||||
mv t1, t0
|
||||
ld t0, ({tcb_sc_off} + {sc_saved_t0})(t0)
|
||||
|
||||
// Re-enable signals. This code can be interrupted after this signal, so we need to define
|
||||
// 'crit_third'.
|
||||
ld gp, ({tcb_sc_off} + {sc_control})(t1)
|
||||
andi gp, gp, ~1
|
||||
sd gp, ({tcb_sc_off} + {sc_control})(t1)
|
||||
|
||||
.globl __relibc_internal_sigentry_crit_third
|
||||
__relibc_internal_sigentry_crit_third:
|
||||
ld gp, ({tcb_sa_off} + {sa_tmp_ip})(t1)
|
||||
.globl __relibc_internal_sigentry_crit_fourth
|
||||
__relibc_internal_sigentry_crit_fourth:
|
||||
ld t1, ({tcb_sa_off} + {sa_tmp_t1})(t1)
|
||||
.globl __relibc_internal_sigentry_crit_fifth
|
||||
__relibc_internal_sigentry_crit_fifth:
|
||||
jr gp
|
||||
"] <= [
|
||||
tcb_sc_off = const (offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control)),
|
||||
sc_word = const offset_of!(Sigcontrol, word),
|
||||
sc_saved_t0 = const offset_of!(Sigcontrol, saved_archdep_reg),
|
||||
sc_saved_ip = const offset_of!(Sigcontrol, saved_ip),
|
||||
sc_sender_infos = const offset_of!(Sigcontrol, sender_infos),
|
||||
sc_control = const offset_of!(Sigcontrol, control_flags),
|
||||
|
||||
tcb_sa_off = const (offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, arch)),
|
||||
sa_off_pctl = const offset_of!(SigArea, pctl),
|
||||
sa_tmp_sp = const offset_of!(SigArea, tmp_sp),
|
||||
sa_tmp_t1 = const offset_of!(SigArea, tmp_t1),
|
||||
sa_tmp_t2 = const offset_of!(SigArea, tmp_t2),
|
||||
sa_tmp_t3 = const offset_of!(SigArea, tmp_t3),
|
||||
sa_tmp_t4 = const offset_of!(SigArea, tmp_t4),
|
||||
sa_tmp_a0 = const offset_of!(SigArea, tmp_a0),
|
||||
sa_tmp_a1 = const offset_of!(SigArea, tmp_a1),
|
||||
sa_tmp_a2 = const offset_of!(SigArea, tmp_a2),
|
||||
sa_tmp_a3 = const offset_of!(SigArea, tmp_a3),
|
||||
sa_tmp_a4 = const offset_of!(SigArea, tmp_a4),
|
||||
sa_tmp_a7 = const offset_of!(SigArea, tmp_a7),
|
||||
sa_tmp_ip = const offset_of!(SigArea, tmp_ip),
|
||||
sa_tmp_id_inf = const offset_of!(SigArea, tmp_id_inf),
|
||||
sa_tmp_rt_inf = const offset_of!(SigArea, tmp_rt_inf),
|
||||
sa_altstack_top = const offset_of!(SigArea, altstack_top),
|
||||
sa_altstack_bottom = const offset_of!(SigArea, altstack_bottom),
|
||||
|
||||
pctl_off_actions = const offset_of!(SigProcControl, actions),
|
||||
inner = sym inner_c,
|
||||
pctl_off_pending = const offset_of!(SigProcControl, pending),
|
||||
pctl_off_sender_infos = const offset_of!(SigProcControl, sender_infos),
|
||||
SYS_CALL = const syscall::SYS_CALL,
|
||||
RTINF_SIZE = const size_of::<RtSigInfo>(),
|
||||
proc_fd = sym PROC_FD,
|
||||
]);
|
||||
|
||||
asmfunction!(__relibc_internal_rlct_clone_ret: ["
|
||||
ld t0, 0(sp)
|
||||
ld a0, 8(sp)
|
||||
ld a1, 16(sp)
|
||||
ld a2, 24(sp)
|
||||
ld a3, 32(sp)
|
||||
ld a4, 40(sp)
|
||||
ld a5, 48(sp)
|
||||
addi sp, sp, 56
|
||||
|
||||
jalr t0
|
||||
ret
|
||||
"] <= []);
|
||||
|
||||
pub fn current_sp() -> usize {
|
||||
let sp: usize;
|
||||
unsafe {
|
||||
core::arch::asm!(
|
||||
"mv {}, sp",
|
||||
out(reg) sp,
|
||||
options(nomem));
|
||||
}
|
||||
sp
|
||||
}
|
||||
|
||||
pub unsafe fn manually_enter_trampoline() {
|
||||
let ctl = unsafe { &Tcb::current().unwrap().os_specific.control };
|
||||
|
||||
ctl.control_flags.store(
|
||||
ctl.control_flags.load(Ordering::Relaxed) | syscall::flag::INHIBIT_DELIVERY.bits(),
|
||||
Ordering::Release,
|
||||
);
|
||||
ctl.saved_archdep_reg.set(0);
|
||||
let ip_location = &ctl.saved_ip as *const _ as usize;
|
||||
|
||||
unsafe {
|
||||
core::arch::asm!("
|
||||
jal 2f
|
||||
j 3f
|
||||
2:
|
||||
sd ra, 0(t0)
|
||||
la t0, __relibc_internal_sigentry
|
||||
jalr x0, t0
|
||||
3:
|
||||
",
|
||||
inout("t0") ip_location => _, out("ra") _);
|
||||
}
|
||||
}
|
||||
|
||||
unsafe extern "C" {
|
||||
fn __relibc_internal_sigentry_crit_first();
|
||||
fn __relibc_internal_sigentry_crit_second();
|
||||
fn __relibc_internal_sigentry_crit_third();
|
||||
fn __relibc_internal_sigentry_crit_fourth();
|
||||
fn __relibc_internal_sigentry_crit_fifth();
|
||||
}
|
||||
pub unsafe fn arch_pre(stack: &mut SigStack, area: &mut SigArea) -> PosixStackt {
|
||||
// It is impossible to update SP and PC atomically. Instead, we abuse the fact that
|
||||
// signals are disabled in the prologue of the signal trampoline, which allows us to emulate
|
||||
// atomicity inside the critical section, consisting of one instruction at 'crit_first', and
|
||||
// one at 'crit_second', see asm.
|
||||
|
||||
if stack.regs.pc == __relibc_internal_sigentry_crit_first as u64 {
|
||||
// Reexecute 'ld sp, (1 * 8)(sp)'
|
||||
let stack_ptr = stack.regs.int_regs[1] as *const u64; // x2
|
||||
stack.regs.int_regs[1] = unsafe { stack_ptr.add(1).read() };
|
||||
// and 'jr gp' steps.
|
||||
stack.regs.pc = stack.regs.int_regs[2];
|
||||
} else if stack.regs.pc == __relibc_internal_sigentry_crit_second as u64
|
||||
|| stack.regs.pc == __relibc_internal_sigentry_crit_fifth as u64
|
||||
{
|
||||
// just reexecute the jump
|
||||
stack.regs.pc = stack.regs.int_regs[2];
|
||||
} else if stack.regs.pc == __relibc_internal_sigentry_crit_third as u64 {
|
||||
// ld gp, ({tcb_sa_off} + {sa_tmp_ip})(t1)
|
||||
stack.regs.int_regs[2] = area.tmp_ip;
|
||||
// ld t1, ({tcb_sa_off} + {sa_tmp_t1})(t1)
|
||||
stack.regs.int_regs[5] = area.tmp_t1;
|
||||
// j gp
|
||||
stack.regs.pc = stack.regs.int_regs[2];
|
||||
} else if stack.regs.pc == __relibc_internal_sigentry_crit_fourth as u64 {
|
||||
// ld t1, ({tcb_sa_off} + {sa_tmp_t1})(t1)
|
||||
stack.regs.int_regs[5] = area.tmp_t1;
|
||||
// jr gp
|
||||
stack.regs.pc = stack.regs.int_regs[2];
|
||||
}
|
||||
|
||||
get_sigaltstack(area, stack.regs.int_regs[1] as usize).into()
|
||||
}
|
||||
pub fn arch_ret_to_sig(stack: &mut SigStack, control: &Sigcontrol) {
|
||||
let orig_pc = core::mem::replace(&mut stack.regs.pc, __relibc_internal_sigentry as u64);
|
||||
control.saved_ip.set(orig_pc as usize);
|
||||
control
|
||||
.saved_archdep_reg
|
||||
.set(stack.regs.int_regs[4] as usize); // t0
|
||||
}
|
||||
pub(crate) static PROC_FD: SyncUnsafeCell<usize> = SyncUnsafeCell::new(usize::MAX);
|
||||
static PROC_CALL: [usize; 1] = [ProcCall::Sigdeq as usize];
|
||||
@@ -1,528 +0,0 @@
|
||||
use core::{
|
||||
cell::SyncUnsafeCell,
|
||||
mem::offset_of,
|
||||
ptr::NonNull,
|
||||
sync::atomic::{AtomicU8, Ordering},
|
||||
};
|
||||
|
||||
use syscall::{
|
||||
data::{SigProcControl, Sigcontrol},
|
||||
error::*,
|
||||
};
|
||||
|
||||
use crate::{
|
||||
Tcb,
|
||||
proc::{FdGuard, FdGuardUpper, ForkArgs, fork_inner},
|
||||
signal::{PROC_CONTROL_STRUCT, PosixStackt, RtSigarea, SigStack, get_sigaltstack, inner_c},
|
||||
};
|
||||
use redox_protocols::protocol::{ProcCall, RtSigInfo};
|
||||
|
||||
use super::ForkScratchpad;
|
||||
|
||||
// Setup a stack starting from the very end of the address space, and then growing downwards.
|
||||
pub const STACK_TOP: usize = 1 << 47;
|
||||
pub const STACK_SIZE: usize = 8 * 1024 * 1024;
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[repr(C)]
|
||||
pub struct SigArea {
|
||||
pub tmp_rip: usize,
|
||||
pub tmp_rsp: usize,
|
||||
pub tmp_rax: usize,
|
||||
pub tmp_rdx: usize,
|
||||
pub tmp_rdi: usize,
|
||||
pub tmp_rsi: usize,
|
||||
pub tmp_r8: usize,
|
||||
pub tmp_r10: usize,
|
||||
pub tmp_r12: usize,
|
||||
pub tmp_rt_inf: RtSigInfo,
|
||||
pub tmp_id_inf: u64,
|
||||
|
||||
pub altstack_top: usize,
|
||||
pub altstack_bottom: usize,
|
||||
pub disable_signals_depth: u64,
|
||||
pub last_sig_was_restart: bool,
|
||||
pub last_sigstack: Option<NonNull<SigStack>>,
|
||||
}
|
||||
|
||||
#[repr(C, align(16))]
|
||||
#[derive(Debug, Default)]
|
||||
pub struct ArchIntRegs {
|
||||
pub ymm_upper: [u128; 16],
|
||||
pub fxsave: [u128; 29],
|
||||
pub r15: usize, // fxsave "available" +0
|
||||
pub r14: usize, // available +8
|
||||
pub r13: usize, // available +16
|
||||
pub r12: usize, // available +24
|
||||
pub rbp: usize, // available +32
|
||||
pub rbx: usize, // available +40
|
||||
pub r11: usize, // outside fxsave, and so on
|
||||
pub r10: usize,
|
||||
pub r9: usize,
|
||||
pub r8: usize,
|
||||
pub rax: usize,
|
||||
pub rcx: usize,
|
||||
pub rdx: usize,
|
||||
pub rsi: usize,
|
||||
pub rdi: usize,
|
||||
pub rflags: usize,
|
||||
pub rip: usize,
|
||||
pub rsp: usize,
|
||||
}
|
||||
|
||||
/// Deactive TLS, used before exec() on Redox to not trick target executable into thinking TLS
|
||||
/// is already initialized as if it was a thread.
|
||||
pub unsafe fn deactivate_tcb(open_via_dup: &FdGuardUpper) -> Result<()> {
|
||||
let mut env = syscall::EnvRegisters::default();
|
||||
|
||||
let file = open_via_dup.dup(b"regs/env")?;
|
||||
|
||||
env.fsbase = 0;
|
||||
env.gsbase = 0;
|
||||
|
||||
file.write(&mut env)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
unsafe extern "sysv64" fn fork_impl(args: &ForkArgs, initial_rsp: *mut usize) -> usize {
|
||||
Error::mux(fork_inner(initial_rsp, args))
|
||||
}
|
||||
|
||||
#[allow(unsafe_op_in_unsafe_fn)]
|
||||
unsafe extern "sysv64" fn child_hook(scratchpad: &ForkScratchpad) {
|
||||
let _ = syscall::close(scratchpad.cur_filetable_fd);
|
||||
crate::child_hook_common(crate::ChildHookCommonArgs {
|
||||
new_thr_fd: FdGuard::new(scratchpad.new_thr_fd),
|
||||
new_proc_fd: if scratchpad.new_proc_fd == usize::MAX {
|
||||
None
|
||||
} else {
|
||||
Some(FdGuard::new(scratchpad.new_proc_fd))
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
asmfunction!(__relibc_internal_fork_wrapper (usize) -> usize: ["
|
||||
push rbp
|
||||
mov rbp, rsp
|
||||
|
||||
push rbx
|
||||
push rbp
|
||||
push r12
|
||||
push r13
|
||||
push r14
|
||||
push r15
|
||||
|
||||
sub rsp, 16
|
||||
|
||||
stmxcsr [rsp+16]
|
||||
fnstcw [rsp+8]
|
||||
|
||||
// rdi: &ForkArgs
|
||||
// rsi: initial_rsp
|
||||
mov rsi, rsp
|
||||
call {fork_impl}
|
||||
|
||||
add rsp, 64
|
||||
|
||||
pop rbp
|
||||
ret
|
||||
|
||||
"] <= [fork_impl = sym fork_impl]);
|
||||
asmfunction!(__relibc_internal_fork_ret: ["
|
||||
# scratchpad is in rsi, move to rdi for child_hook
|
||||
mov rdi, rsi
|
||||
|
||||
call {child_hook}
|
||||
|
||||
ldmxcsr [rsp + 16]
|
||||
mov rcx, [rsp + 8]
|
||||
|
||||
xor rax, rax
|
||||
|
||||
add rsp, 16
|
||||
pop r15
|
||||
pop r14
|
||||
pop r13
|
||||
pop r12
|
||||
pop rbp
|
||||
pop rbx
|
||||
|
||||
pop rbp
|
||||
ret
|
||||
"] <= [child_hook = sym child_hook]);
|
||||
asmfunction!(__relibc_internal_rlct_clone_ret: ["
|
||||
# Load registers
|
||||
pop rax
|
||||
pop rdi
|
||||
pop rsi
|
||||
pop rdx
|
||||
pop rcx
|
||||
pop r8
|
||||
pop r9
|
||||
|
||||
mov DWORD PTR [rsp - 8], 0x00001F80
|
||||
ldmxcsr [rsp - 8]
|
||||
mov WORD PTR [rsp - 8], 0x037F
|
||||
fldcw [rsp - 8]
|
||||
|
||||
# Call entry point
|
||||
call rax
|
||||
|
||||
ret
|
||||
"] <= []);
|
||||
|
||||
asmfunction!(__relibc_internal_sigentry: ["
|
||||
// Save some registers
|
||||
mov fs:[{tcb_sa_off} + {sa_tmp_rsp}], rsp
|
||||
mov fs:[{tcb_sa_off} + {sa_tmp_rax}], rax
|
||||
mov fs:[{tcb_sa_off} + {sa_tmp_rdx}], rdx
|
||||
mov fs:[{tcb_sa_off} + {sa_tmp_rdi}], rdi
|
||||
mov fs:[{tcb_sa_off} + {sa_tmp_rsi}], rsi
|
||||
mov fs:[{tcb_sa_off} + {sa_tmp_r8}], r8
|
||||
mov fs:[{tcb_sa_off} + {sa_tmp_r10}], r10
|
||||
mov fs:[{tcb_sa_off} + {sa_tmp_r12}], r12
|
||||
|
||||
// First, select signal, always pick first available bit
|
||||
1:
|
||||
// Read standard signal word - first targeting this thread
|
||||
mov rax, fs:[{tcb_sc_off} + {sc_word}]
|
||||
mov rdx, rax
|
||||
shr rdx, 32
|
||||
and eax, edx
|
||||
bsf eax, eax
|
||||
jnz 2f
|
||||
|
||||
// If no unblocked thread signal was found, check for process.
|
||||
// This is competitive; we need to atomically check if *we* cleared the process-wide pending
|
||||
// bit, otherwise restart.
|
||||
mov eax, [rip + {pctl} + {pctl_off_pending}]
|
||||
and eax, edx
|
||||
bsf eax, eax
|
||||
jz 8f
|
||||
lea rdi, [rip + {pctl} + {pctl_off_sender_infos}]
|
||||
mov rdi, [rdi + rax * 8]
|
||||
lock btr [rip + {pctl} + {pctl_off_pending}], eax
|
||||
mov fs:[{tcb_sa_off} + {sa_tmp_id_inf}], rdi
|
||||
jc 9f
|
||||
8:
|
||||
// Read second signal word - both process and thread simultaneously.
|
||||
// This must be done since POSIX requires low realtime signals to be picked first.
|
||||
mov edx, fs:[{tcb_sc_off} + {sc_word} + 8]
|
||||
mov eax, [rip + {pctl} + {pctl_off_pending} + 4]
|
||||
or eax, edx
|
||||
and eax, fs:[{tcb_sc_off} + {sc_word} + 12]
|
||||
bsf eax, eax
|
||||
jz 7f
|
||||
|
||||
bt edx, eax // check if signal was sent to thread specifically
|
||||
jnc 81f
|
||||
// if so, continue as usual
|
||||
add eax, 32
|
||||
jmp 2f
|
||||
81:
|
||||
// otherwise, try (competitively) dequeueing realtime signal
|
||||
|
||||
// SYS_CALL(fd, payload_base, payload_len, metadata_len | (flags << 8), metadata_base)
|
||||
// rax rdi rsi rdx r10 r8
|
||||
|
||||
mov r12d, eax
|
||||
mov rsi, fs:[0]
|
||||
mov rdi, [rip+{proc_fd}]
|
||||
add rsi, {tcb_sa_off} + {sa_tmp_rt_inf} // out pointer of dequeued realtime sig
|
||||
mov rdx, {RTINF_SIZE}
|
||||
mov [rsi], eax
|
||||
lea r8, [rip + {proc_call_sigdeq}]
|
||||
mov r10, 1
|
||||
mov eax, {SYS_CALL}
|
||||
syscall
|
||||
test eax, eax
|
||||
jnz 1b // assumes error can only be EAGAIN
|
||||
lea eax, [r12d + 32]
|
||||
jmp 9f
|
||||
2:
|
||||
mov edx, eax
|
||||
shr edx, 5
|
||||
mov rdi, fs:[{tcb_sc_off} + {sc_sender_infos} + eax * 8]
|
||||
lock btr fs:[{tcb_sc_off} + {sc_word} + edx * 4], eax
|
||||
mov fs:[{tcb_sa_off} + {sa_tmp_id_inf}], rdi
|
||||
add eax, 64 // indicate signal was targeted at thread
|
||||
9:
|
||||
sub rsp, {REDZONE_SIZE}
|
||||
and rsp, -{STACK_ALIGN}
|
||||
|
||||
// By now we have selected a signal, stored in eax (6-bit). We now need to choose whether or
|
||||
// not to switch to the alternate signal stack. If SA_ONSTACK is clear for this signal, then
|
||||
// skip the sigaltstack logic.
|
||||
lea rdx, [rip + {pctl} + {pctl_off_actions}]
|
||||
|
||||
mov ecx, eax
|
||||
and ecx, 63
|
||||
|
||||
// LEA doesn't support 16x, so just do two x8s.
|
||||
lea rdx, [rdx + 8 * rcx]
|
||||
lea rdx, [rdx + 8 * rcx]
|
||||
|
||||
bt qword ptr [rdx], {SA_ONSTACK_BIT}
|
||||
jnc 4f
|
||||
|
||||
// Otherwise, the altstack is already active. The sigaltstack being disabled, is equivalent
|
||||
// to setting 'top' to usize::MAX and 'bottom' to 0.
|
||||
|
||||
// If current RSP is above altstack region, switch to altstack
|
||||
mov rdx, fs:[{tcb_sa_off} + {sa_altstack_top}]
|
||||
cmp rsp, rdx
|
||||
cmova rsp, rdx
|
||||
|
||||
// If current RSP is below altstack region, also switch to altstack
|
||||
cmp rsp, fs:[{tcb_sa_off} + {sa_altstack_bottom}]
|
||||
cmovbe rsp, rdx
|
||||
|
||||
.p2align 4
|
||||
4:
|
||||
// Now that we have a stack, we can finally start initializing the signal stack!
|
||||
|
||||
push fs:[{tcb_sa_off} + {sa_tmp_rsp}]
|
||||
push fs:[{tcb_sc_off} + {sc_saved_rip}]
|
||||
push fs:[{tcb_sc_off} + {sc_saved_rflags}]
|
||||
|
||||
push fs:[{tcb_sa_off} + {sa_tmp_rdi}]
|
||||
push fs:[{tcb_sa_off} + {sa_tmp_rsi}]
|
||||
push fs:[{tcb_sa_off} + {sa_tmp_rdx}]
|
||||
push rcx
|
||||
push fs:[{tcb_sa_off} + {sa_tmp_rax}]
|
||||
push fs:[{tcb_sa_off} + {sa_tmp_r8}]
|
||||
push r9
|
||||
push fs:[{tcb_sa_off} + {sa_tmp_r10}]
|
||||
push r11
|
||||
push rbx
|
||||
push rbp
|
||||
push fs:[{tcb_sa_off} + {sa_tmp_r12}]
|
||||
push r13
|
||||
push r14
|
||||
push r15
|
||||
sub rsp, (29 + 16) * 16 // fxsave region minus available bytes
|
||||
fxsave64 [rsp + 16 * 16]
|
||||
|
||||
// TODO: self-modifying?
|
||||
cmp byte ptr [rip + {supports_avx}], 0
|
||||
je 5f
|
||||
|
||||
// Prefer vextractf128 over vextracti128 since the former only requires AVX version 1.
|
||||
vextractf128 [rsp + 15 * 16], ymm0, 1
|
||||
vextractf128 [rsp + 14 * 16], ymm1, 1
|
||||
vextractf128 [rsp + 13 * 16], ymm2, 1
|
||||
vextractf128 [rsp + 12 * 16], ymm3, 1
|
||||
vextractf128 [rsp + 11 * 16], ymm4, 1
|
||||
vextractf128 [rsp + 10 * 16], ymm5, 1
|
||||
vextractf128 [rsp + 9 * 16], ymm6, 1
|
||||
vextractf128 [rsp + 8 * 16], ymm7, 1
|
||||
vextractf128 [rsp + 7 * 16], ymm8, 1
|
||||
vextractf128 [rsp + 6 * 16], ymm9, 1
|
||||
vextractf128 [rsp + 5 * 16], ymm10, 1
|
||||
vextractf128 [rsp + 4 * 16], ymm11, 1
|
||||
vextractf128 [rsp + 3 * 16], ymm12, 1
|
||||
vextractf128 [rsp + 2 * 16], ymm13, 1
|
||||
vextractf128 [rsp + 16], ymm14, 1
|
||||
vextractf128 [rsp], ymm15, 1
|
||||
5:
|
||||
mov [rsp - 4], eax
|
||||
sub rsp, 64 // alloc space for ucontext fields
|
||||
|
||||
mov rdi, rsp
|
||||
call {inner}
|
||||
|
||||
add rsp, 64
|
||||
|
||||
fxrstor64 [rsp + 16 * 16]
|
||||
|
||||
cmp byte ptr [rip + {supports_avx}], 0
|
||||
je 6f
|
||||
|
||||
vinsertf128 ymm0, ymm0, [rsp + 15 * 16], 1
|
||||
vinsertf128 ymm1, ymm1, [rsp + 14 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 13 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 12 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 11 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 10 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 9 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 8 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 7 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 6 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 5 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 4 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 3 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 2 * 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp + 16], 1
|
||||
vinsertf128 ymm2, ymm2, [rsp], 1
|
||||
6:
|
||||
add rsp, (29 + 16) * 16
|
||||
|
||||
pop r15
|
||||
pop r14
|
||||
pop r13
|
||||
pop r12
|
||||
pop rbp
|
||||
pop rbx
|
||||
pop r11
|
||||
pop r10
|
||||
pop r9
|
||||
pop r8
|
||||
pop rax
|
||||
pop rcx
|
||||
pop rdx
|
||||
pop rsi
|
||||
pop rdi
|
||||
|
||||
popfq
|
||||
pop qword ptr fs:[{tcb_sa_off} + {sa_tmp_rip}]
|
||||
|
||||
// x86 lacks atomic instructions for setting both the stack and instruction pointer
|
||||
// simultaneously, except the slow microcoded IRETQ instruction. Thus, we let the arch_pre
|
||||
// function emulate atomicity between the pop rsp and indirect jump.
|
||||
|
||||
.globl __relibc_internal_sigentry_crit_first
|
||||
__relibc_internal_sigentry_crit_first:
|
||||
|
||||
pop rsp
|
||||
|
||||
.globl __relibc_internal_sigentry_crit_second
|
||||
__relibc_internal_sigentry_crit_second:
|
||||
jmp qword ptr fs:[{tcb_sa_off} + {sa_tmp_rip}]
|
||||
7:
|
||||
// A spurious signal occurred. Signals are still disabled here, but will need to be re-enabled.
|
||||
|
||||
// restore flags
|
||||
mov rax, fs:[0] // load FS base
|
||||
// TODO: Use lahf/sahf rather than pushfq/popfq?
|
||||
lea rsp, [rax + {tcb_sc_off} + {sc_saved_rflags}]
|
||||
popfq
|
||||
|
||||
// restore stack
|
||||
mov rsp, fs:[{tcb_sa_off} + {sa_tmp_rsp}]
|
||||
|
||||
// move saved RIP away from control, allowing arch_pre to save us if interrupted.
|
||||
mov rax, fs:[{tcb_sc_off} + {sc_saved_rip}]
|
||||
mov fs:[{tcb_sa_off} + {sa_tmp_rip}], rax
|
||||
|
||||
// restore regs
|
||||
mov rax, fs:[{tcb_sa_off} + {sa_tmp_rax}]
|
||||
mov rdx, fs:[{tcb_sa_off} + {sa_tmp_rdx}]
|
||||
|
||||
// Re-enable signals. This code can be interrupted after this signal, so we need to define
|
||||
// 'crit_third'.
|
||||
and qword ptr fs:[{tcb_sc_off} + {sc_control}], ~1
|
||||
|
||||
.globl __relibc_internal_sigentry_crit_third
|
||||
__relibc_internal_sigentry_crit_third:
|
||||
jmp qword ptr fs:[{tcb_sa_off} + {sa_tmp_rip}]
|
||||
"] <= [
|
||||
inner = sym inner_c,
|
||||
sa_tmp_rip = const offset_of!(SigArea, tmp_rip),
|
||||
sa_tmp_rsp = const offset_of!(SigArea, tmp_rsp),
|
||||
sa_tmp_rax = const offset_of!(SigArea, tmp_rax),
|
||||
sa_tmp_rdx = const offset_of!(SigArea, tmp_rdx),
|
||||
sa_tmp_rdi = const offset_of!(SigArea, tmp_rdi),
|
||||
sa_tmp_rsi = const offset_of!(SigArea, tmp_rsi),
|
||||
sa_tmp_r8 = const offset_of!(SigArea, tmp_r8),
|
||||
sa_tmp_r10 = const offset_of!(SigArea, tmp_r10),
|
||||
sa_tmp_r12 = const offset_of!(SigArea, tmp_r12),
|
||||
sa_tmp_rt_inf = const offset_of!(SigArea, tmp_rt_inf),
|
||||
sa_tmp_id_inf = const offset_of!(SigArea, tmp_id_inf),
|
||||
sa_altstack_top = const offset_of!(SigArea, altstack_top),
|
||||
sa_altstack_bottom = const offset_of!(SigArea, altstack_bottom),
|
||||
sc_saved_rflags = const offset_of!(Sigcontrol, saved_archdep_reg),
|
||||
sc_saved_rip = const offset_of!(Sigcontrol, saved_ip),
|
||||
sc_word = const offset_of!(Sigcontrol, word),
|
||||
sc_sender_infos = const offset_of!(Sigcontrol, sender_infos),
|
||||
sc_control = const offset_of!(Sigcontrol, control_flags),
|
||||
tcb_sa_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, arch),
|
||||
tcb_sc_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control),
|
||||
pctl_off_actions = const offset_of!(SigProcControl, actions),
|
||||
pctl_off_pending = const offset_of!(SigProcControl, pending),
|
||||
pctl_off_sender_infos = const offset_of!(SigProcControl, sender_infos),
|
||||
pctl = sym PROC_CONTROL_STRUCT,
|
||||
supports_avx = sym SUPPORTS_AVX,
|
||||
REDZONE_SIZE = const 128,
|
||||
STACK_ALIGN = const 16,
|
||||
SA_ONSTACK_BIT = const 58, // (1 << 58) >> 32 = 0x0400_0000
|
||||
SYS_CALL = const syscall::SYS_CALL,
|
||||
proc_call_sigdeq = sym PROC_CALL_SIGDEQ,
|
||||
RTINF_SIZE = const size_of::<RtSigInfo>(),
|
||||
proc_fd = sym PROC_FD,
|
||||
]);
|
||||
|
||||
unsafe extern "C" {
|
||||
fn __relibc_internal_sigentry_crit_first();
|
||||
fn __relibc_internal_sigentry_crit_second();
|
||||
fn __relibc_internal_sigentry_crit_third();
|
||||
}
|
||||
/// Fixes some edge cases, and calculates the value for uc_stack.
|
||||
pub unsafe fn arch_pre(stack: &mut SigStack, area: &mut SigArea) -> PosixStackt {
|
||||
// It is impossible to update RSP and RIP atomically on x86_64, without using IRETQ, which is
|
||||
// almost as slow as calling a SIGRETURN syscall would be. Instead, we abuse the fact that
|
||||
// signals are disabled in the prologue of the signal trampoline, which allows us to emulate
|
||||
// atomicity inside the critical section, consisting of one instruction at 'crit_first', one at
|
||||
// 'crit_second', and one at 'crit_third', see asm.
|
||||
|
||||
if stack.regs.rip == __relibc_internal_sigentry_crit_first as usize {
|
||||
// Reexecute pop rsp and jump steps. This case needs to be different from the one below,
|
||||
// since rsp has not been overwritten with the previous context's stack, just yet. At this
|
||||
// point, we know [rsp+0] contains the saved RSP, and [rsp-8] contains the saved RIP.
|
||||
let stack_ptr = stack.regs.rsp as *const usize;
|
||||
stack.regs.rsp = unsafe { stack_ptr.read() };
|
||||
stack.regs.rip = unsafe { stack_ptr.sub(1).read() };
|
||||
} else if stack.regs.rip == __relibc_internal_sigentry_crit_second as usize
|
||||
|| stack.regs.rip == __relibc_internal_sigentry_crit_third as usize
|
||||
{
|
||||
// Almost finished, just reexecute the jump before tmp_rip is overwritten by this
|
||||
// deeper-level signal.
|
||||
stack.regs.rip = area.tmp_rip;
|
||||
}
|
||||
|
||||
get_sigaltstack(area, stack.regs.rsp).into()
|
||||
}
|
||||
|
||||
/// Rearrange the restore-stack and sigarea in a way that makes it look like a new signal was
|
||||
/// immediately delivered after restoring the allowset to what it was prior to the original signal delivery.
|
||||
pub fn arch_ret_to_sig(stack: &mut SigStack, control: &Sigcontrol) {
|
||||
let orig_rip = core::mem::replace(&mut stack.regs.rip, __relibc_internal_sigentry as usize);
|
||||
control.saved_ip.set(orig_rip);
|
||||
control.saved_archdep_reg.set(stack.regs.rflags);
|
||||
}
|
||||
|
||||
pub(crate) static SUPPORTS_AVX: AtomicU8 = AtomicU8::new(0);
|
||||
|
||||
// __relibc will be prepended to the name, so no_mangle is fine
|
||||
#[allow(unsafe_op_in_unsafe_fn)]
|
||||
#[unsafe(no_mangle)]
|
||||
pub unsafe fn manually_enter_trampoline() {
|
||||
let c = &Tcb::current().unwrap().os_specific.control;
|
||||
c.control_flags.store(
|
||||
c.control_flags.load(Ordering::Relaxed) | syscall::flag::INHIBIT_DELIVERY.bits(),
|
||||
Ordering::Release,
|
||||
);
|
||||
c.saved_archdep_reg.set(0); // TODO: Just reset DF on x86?
|
||||
|
||||
core::arch::asm!("
|
||||
lea rax, [rip + 2f]
|
||||
mov fs:[{tcb_sc_off} + {sc_saved_rip}], rax
|
||||
jmp __relibc_internal_sigentry
|
||||
2:
|
||||
",
|
||||
out("rax") _,
|
||||
tcb_sc_off = const offset_of!(crate::Tcb, os_specific) + offset_of!(RtSigarea, control),
|
||||
sc_saved_rip = const offset_of!(Sigcontrol, saved_ip),
|
||||
);
|
||||
}
|
||||
|
||||
/// Get current stack pointer, weak granularity guarantees.
|
||||
pub fn current_sp() -> usize {
|
||||
let sp: usize;
|
||||
unsafe {
|
||||
core::arch::asm!("mov {}, rsp", out(reg) sp);
|
||||
}
|
||||
sp
|
||||
}
|
||||
|
||||
static PROC_CALL_SIGDEQ: u64 = ProcCall::Sigdeq as u64;
|
||||
pub(crate) static PROC_FD: SyncUnsafeCell<usize> = SyncUnsafeCell::new(usize::MAX);
|
||||
@@ -1,313 +0,0 @@
|
||||
#![no_std]
|
||||
#![allow(internal_features)]
|
||||
#![deny(unsafe_op_in_unsafe_fn)]
|
||||
#![feature(core_intrinsics, int_roundings, slice_ptr_get, sync_unsafe_cell)]
|
||||
#![forbid(unreachable_patterns)]
|
||||
|
||||
use core::cell::UnsafeCell;
|
||||
|
||||
#[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
|
||||
use generic_rt::ExpectTlsFree; // not used on aarch64 or riscv64
|
||||
use generic_rt::GenericTcb;
|
||||
use redox_protocols::protocol::ProcMeta;
|
||||
use syscall::Sigcontrol;
|
||||
|
||||
use self::{
|
||||
proc::{FdGuard, FdGuardUpper, STATIC_PROC_INFO},
|
||||
sync::Mutex,
|
||||
};
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! asmfunction(
|
||||
($name:ident $(($($arg:ty),*))? $(-> $ret:ty)? : [$($asmstmt:expr),*$(,)?] <= [$($decl:ident = $(sym $symname:ident)?$(const $constval:expr)?),*$(,)?]$(,)? ) => {
|
||||
::core::arch::global_asm!(concat!("
|
||||
.p2align 4
|
||||
.section .text.", stringify!($name), ", \"ax\", @progbits
|
||||
.globl ", stringify!($name), "
|
||||
.type ", stringify!($name), ", @function
|
||||
", stringify!($name), ":
|
||||
", $($asmstmt, "\n",)* "
|
||||
.size ", stringify!($name), ", . - ", stringify!($name), "
|
||||
"), $($decl = $(sym $symname)?$(const $constval)?),*);
|
||||
|
||||
unsafe extern "C" {
|
||||
pub fn $name($($(_: $arg),*)?) $(-> $ret)?;
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
pub mod arch;
|
||||
pub mod proc;
|
||||
|
||||
// TODO: Replace auxvs with a non-stack-based interface, but keep getauxval for compatibility
|
||||
#[path = "../../src/platform/auxv_defs.rs"]
|
||||
pub mod auxv_defs;
|
||||
|
||||
pub mod signal;
|
||||
pub mod sync;
|
||||
pub mod sys;
|
||||
pub mod thread;
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
pub struct RtTcb {
|
||||
pub control: Sigcontrol,
|
||||
pub arch: UnsafeCell<crate::arch::SigArea>,
|
||||
pub thr_fd: UnsafeCell<Option<FdGuardUpper>>,
|
||||
}
|
||||
impl RtTcb {
|
||||
pub fn current() -> &'static Self {
|
||||
unsafe { &Tcb::current().unwrap().os_specific }
|
||||
}
|
||||
pub fn thread_fd(&self) -> &FdGuardUpper {
|
||||
unsafe { (&*self.thr_fd.get()).as_ref().unwrap() }
|
||||
}
|
||||
}
|
||||
|
||||
pub type Tcb = GenericTcb<RtTcb>;
|
||||
|
||||
/// OS and architecture specific code to activate TLS - Redox aarch64
|
||||
#[allow(unsafe_op_in_unsafe_fn)]
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
pub unsafe fn tcb_activate(_tcb: &RtTcb, tls_end: usize, tls_len: usize) {
|
||||
// Uses ABI page
|
||||
let abi_ptr = tls_end - tls_len - 16;
|
||||
core::ptr::write(abi_ptr as *mut usize, tls_end);
|
||||
core::arch::asm!(
|
||||
"msr tpidr_el0, {}",
|
||||
in(reg) abi_ptr,
|
||||
);
|
||||
}
|
||||
|
||||
/// OS and architecture specific code to activate TLS - Redox x86
|
||||
#[allow(unsafe_op_in_unsafe_fn)]
|
||||
#[cfg(target_arch = "x86")]
|
||||
pub unsafe fn tcb_activate(tcb: &RtTcb, tls_end: usize, _tls_len: usize) {
|
||||
let mut env = syscall::EnvRegisters::default();
|
||||
|
||||
let file = tcb
|
||||
.thread_fd()
|
||||
.dup(b"regs/env")
|
||||
.expect_notls("failed to open handle for process registers");
|
||||
|
||||
file.read(&mut env).expect_notls("failed to read gsbase");
|
||||
|
||||
env.gsbase = tls_end as u32;
|
||||
|
||||
file.write(&env).expect_notls("failed to write gsbase");
|
||||
}
|
||||
|
||||
/// OS and architecture specific code to activate TLS - Redox x86_64
|
||||
#[allow(unsafe_op_in_unsafe_fn)]
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
pub unsafe fn tcb_activate(tcb: &RtTcb, tls_end_and_tcb_start: usize, _tls_len: usize) {
|
||||
let mut env = syscall::EnvRegisters::default();
|
||||
|
||||
let file = tcb
|
||||
.thread_fd()
|
||||
.dup(b"regs/env")
|
||||
.expect_notls("failed to open handle for process registers");
|
||||
|
||||
file.read(&mut env).expect_notls("failed to read fsbase");
|
||||
|
||||
env.fsbase = tls_end_and_tcb_start as u64;
|
||||
|
||||
file.write(&env).expect_notls("failed to write fsbase");
|
||||
}
|
||||
|
||||
/// OS and architecture specific code to activate TLS - Redox riscv64
|
||||
#[allow(unsafe_op_in_unsafe_fn)]
|
||||
#[cfg(target_arch = "riscv64")]
|
||||
pub unsafe fn tcb_activate(_tcb: &RtTcb, tls_end: usize, tls_len: usize) {
|
||||
// tp points to static tls block
|
||||
// FIXME limited to a single initial master
|
||||
let tls_start = tls_end - tls_len;
|
||||
let abi_ptr = tls_start - 8;
|
||||
core::ptr::write(abi_ptr as *mut usize, tls_end);
|
||||
core::arch::asm!(
|
||||
"mv tp, {}",
|
||||
in(reg) tls_start
|
||||
);
|
||||
}
|
||||
|
||||
/// Initialize redox-rt in situations where relibc is not used
|
||||
#[allow(unsafe_op_in_unsafe_fn)]
|
||||
#[cfg(not(feature = "proc"))]
|
||||
pub unsafe fn initialize_freestanding(this_thr_fd: FdGuardUpper) -> &'static FdGuardUpper {
|
||||
// TODO: This code is a hack! Integrate the ld_so TCB code into generic-rt, and then use that
|
||||
// (this function will need pointers to the ELF structs normally passed in auxvs), so the TCB
|
||||
// is initialized properly.
|
||||
|
||||
// TODO: TLS
|
||||
let page = {
|
||||
&mut *(syscall::fmap(
|
||||
!0,
|
||||
&syscall::Map {
|
||||
offset: 0,
|
||||
size: syscall::PAGE_SIZE,
|
||||
flags: syscall::MapFlags::PROT_READ
|
||||
| syscall::MapFlags::PROT_WRITE
|
||||
| syscall::MapFlags::MAP_PRIVATE,
|
||||
address: 0,
|
||||
},
|
||||
)
|
||||
.unwrap() as *mut Tcb)
|
||||
};
|
||||
page.tcb_ptr = page;
|
||||
page.tcb_len = syscall::PAGE_SIZE;
|
||||
page.tls_end = (page as *mut Tcb).cast();
|
||||
|
||||
// Make sure to use ptr::write to prevent dropping the existing FdGuard
|
||||
page.os_specific.thr_fd.get().write(Some(this_thr_fd));
|
||||
|
||||
#[cfg(not(any(target_arch = "aarch64", target_arch = "riscv64")))]
|
||||
unsafe {
|
||||
let tcb_addr = page as *mut Tcb as usize;
|
||||
tcb_activate(&page.os_specific, tcb_addr, 0)
|
||||
}
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
unsafe {
|
||||
let abi_ptr = core::ptr::addr_of_mut!(page.tcb_ptr);
|
||||
core::arch::asm!("msr tpidr_el0, {}", in(reg) abi_ptr);
|
||||
}
|
||||
#[cfg(target_arch = "riscv64")]
|
||||
unsafe {
|
||||
let abi_ptr = core::ptr::addr_of_mut!(page.tcb_ptr) as usize;
|
||||
core::arch::asm!("mv tp, {}", in(reg) (abi_ptr + 8));
|
||||
}
|
||||
initialize();
|
||||
|
||||
(*page.os_specific.thr_fd.get()).as_ref().unwrap()
|
||||
}
|
||||
pub(crate) fn read_proc_meta(proc: &FdGuardUpper) -> syscall::Result<ProcMeta> {
|
||||
let mut bytes = [0_u8; size_of::<ProcMeta>()];
|
||||
proc.read(&mut bytes)?;
|
||||
Ok(*plain::from_bytes::<ProcMeta>(&bytes).unwrap())
|
||||
}
|
||||
pub unsafe fn initialize(
|
||||
#[cfg(feature = "proc")] proc_fd: FdGuardUpper,
|
||||
#[cfg(feature = "proc")] ns_fd: Option<FdGuardUpper>,
|
||||
) {
|
||||
#[cfg(feature = "proc")]
|
||||
let metadata = read_proc_meta(&proc_fd).unwrap();
|
||||
|
||||
#[cfg(not(feature = "proc"))]
|
||||
// Bootstrap mode, don't associate proc fds with PIDs
|
||||
let metadata = ProcMeta::default();
|
||||
|
||||
#[cfg(feature = "proc")]
|
||||
{
|
||||
unsafe { crate::arch::PROC_FD.get().write(proc_fd.as_raw_fd()) };
|
||||
}
|
||||
|
||||
unsafe {
|
||||
STATIC_PROC_INFO.get().write(StaticProcInfo {
|
||||
pid: metadata.pid,
|
||||
|
||||
#[cfg(feature = "proc")]
|
||||
proc_fd: Some(proc_fd),
|
||||
|
||||
#[cfg(not(feature = "proc"))]
|
||||
proc_fd: None,
|
||||
})
|
||||
};
|
||||
|
||||
#[cfg(feature = "proc")]
|
||||
{
|
||||
*DYNAMIC_PROC_INFO.lock() = DynamicProcInfo {
|
||||
pgid: metadata.pgid,
|
||||
ruid: metadata.ruid,
|
||||
euid: metadata.euid,
|
||||
suid: metadata.suid,
|
||||
egid: metadata.egid,
|
||||
rgid: metadata.rgid,
|
||||
sgid: metadata.sgid,
|
||||
ns_fd,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct StaticProcInfo {
|
||||
pid: u32,
|
||||
proc_fd: Option<FdGuardUpper>,
|
||||
}
|
||||
pub struct DynamicProcInfo {
|
||||
pub pgid: u32,
|
||||
pub euid: u32,
|
||||
pub suid: u32,
|
||||
pub ruid: u32,
|
||||
pub egid: u32,
|
||||
pub rgid: u32,
|
||||
pub sgid: u32,
|
||||
pub ns_fd: Option<FdGuardUpper>,
|
||||
}
|
||||
|
||||
static DYNAMIC_PROC_INFO: Mutex<DynamicProcInfo> = Mutex::new(DynamicProcInfo {
|
||||
pgid: u32::MAX,
|
||||
ruid: u32::MAX,
|
||||
euid: u32::MAX,
|
||||
suid: u32::MAX,
|
||||
rgid: u32::MAX,
|
||||
egid: u32::MAX,
|
||||
sgid: u32::MAX,
|
||||
ns_fd: None,
|
||||
});
|
||||
|
||||
#[inline]
|
||||
pub(crate) fn static_proc_info() -> &'static StaticProcInfo {
|
||||
unsafe { &*STATIC_PROC_INFO.get() }
|
||||
}
|
||||
#[inline]
|
||||
pub fn current_proc_fd() -> &'static FdGuardUpper {
|
||||
let info = static_proc_info();
|
||||
info.proc_fd.as_ref().unwrap()
|
||||
}
|
||||
#[inline]
|
||||
pub fn current_namespace_fd() -> syscall::Result<usize> {
|
||||
DYNAMIC_PROC_INFO
|
||||
.lock()
|
||||
.ns_fd
|
||||
.as_ref()
|
||||
.map(|g| g.as_raw_fd())
|
||||
.ok_or(syscall::Error::new(syscall::ENOENT))
|
||||
}
|
||||
struct ChildHookCommonArgs {
|
||||
new_thr_fd: FdGuard,
|
||||
new_proc_fd: Option<FdGuard>,
|
||||
}
|
||||
|
||||
unsafe fn child_hook_common(args: ChildHookCommonArgs) {
|
||||
let new_thr_fd = args.new_thr_fd.to_upper().unwrap();
|
||||
let new_proc_fd = args.new_proc_fd.map(|x| x.to_upper().unwrap());
|
||||
|
||||
// TODO: just pass PID to child rather than obtaining it via IPC?
|
||||
#[cfg(feature = "proc")]
|
||||
let metadata = read_proc_meta(
|
||||
new_proc_fd
|
||||
.as_ref()
|
||||
.expect("must be present with proc feature"),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
#[cfg(not(feature = "proc"))]
|
||||
let metadata = ProcMeta::default();
|
||||
|
||||
if let Some(proc_fd) = &new_proc_fd {
|
||||
unsafe { crate::arch::PROC_FD.get().write(proc_fd.as_raw_fd()) };
|
||||
}
|
||||
|
||||
let old_proc_fd = unsafe {
|
||||
STATIC_PROC_INFO
|
||||
.get()
|
||||
.replace(StaticProcInfo {
|
||||
pid: metadata.pid,
|
||||
proc_fd: new_proc_fd,
|
||||
})
|
||||
.proc_fd
|
||||
};
|
||||
drop(old_proc_fd);
|
||||
|
||||
let old_thr_fd = unsafe { RtTcb::current().thr_fd.get().replace(Some(new_thr_fd)) };
|
||||
drop(old_thr_fd);
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,68 +0,0 @@
|
||||
// TODO: Share code for simple futex-based mutex between relibc's Mutex<()> and this.
|
||||
|
||||
use core::{
|
||||
cell::UnsafeCell,
|
||||
ops::{Deref, DerefMut},
|
||||
sync::atomic::{AtomicU32, Ordering},
|
||||
};
|
||||
|
||||
pub struct Mutex<T> {
|
||||
pub lockword: AtomicU32,
|
||||
pub inner: UnsafeCell<T>,
|
||||
}
|
||||
|
||||
unsafe impl<T: Send> Send for Mutex<T> {}
|
||||
unsafe impl<T: Send> Sync for Mutex<T> {}
|
||||
|
||||
impl<T> Mutex<T> {
|
||||
/// Represents an unlocked [Mutex].
|
||||
pub const UNLOCKED: u32 = 0;
|
||||
/// Represents a locked [Mutex].
|
||||
pub const LOCKED: u32 = 1;
|
||||
/// Represents a waiting [Mutex].
|
||||
pub const WAITING: u32 = 2;
|
||||
|
||||
pub const fn new(t: T) -> Self {
|
||||
Self {
|
||||
lockword: AtomicU32::new(0),
|
||||
inner: UnsafeCell::new(t),
|
||||
}
|
||||
}
|
||||
pub fn lock(&self) -> MutexGuard<'_, T> {
|
||||
while self
|
||||
.lockword
|
||||
.compare_exchange(
|
||||
Self::UNLOCKED,
|
||||
Self::LOCKED,
|
||||
Ordering::Acquire,
|
||||
Ordering::Relaxed,
|
||||
)
|
||||
.is_err()
|
||||
{
|
||||
core::hint::spin_loop();
|
||||
}
|
||||
MutexGuard { lock: self }
|
||||
}
|
||||
}
|
||||
pub struct MutexGuard<'l, T> {
|
||||
lock: &'l Mutex<T>,
|
||||
}
|
||||
impl<T> Deref for MutexGuard<'_, T> {
|
||||
type Target = T;
|
||||
|
||||
fn deref(&self) -> &T {
|
||||
unsafe { &*self.lock.inner.get() }
|
||||
}
|
||||
}
|
||||
impl<T> DerefMut for MutexGuard<'_, T> {
|
||||
fn deref_mut(&mut self) -> &mut T {
|
||||
unsafe { &mut *self.lock.inner.get() }
|
||||
}
|
||||
}
|
||||
impl<T> Drop for MutexGuard<'_, T> {
|
||||
fn drop(&mut self) {
|
||||
self.lock
|
||||
.lockword
|
||||
.store(Mutex::<T>::UNLOCKED, Ordering::Release);
|
||||
}
|
||||
}
|
||||
@@ -1,569 +0,0 @@
|
||||
use core::{
|
||||
mem::{replace, size_of},
|
||||
ptr::addr_of,
|
||||
sync::atomic::{AtomicU32, Ordering},
|
||||
};
|
||||
|
||||
use ioslice::IoSlice;
|
||||
use syscall::{
|
||||
CallFlags, EINVAL, ERESTART, StdFsCallKind, TimeSpec,
|
||||
data::StdFsCallMeta,
|
||||
error::{self, EINTR, ENODEV, ESRCH, Error, Result},
|
||||
};
|
||||
|
||||
use crate::{
|
||||
DYNAMIC_PROC_INFO, DynamicProcInfo, RtTcb, Tcb,
|
||||
arch::manually_enter_trampoline,
|
||||
proc::{FdGuard, FdGuardUpper},
|
||||
read_proc_meta,
|
||||
signal::tmp_disable_signals,
|
||||
};
|
||||
use alloc::vec::Vec;
|
||||
use redox_protocols::protocol::{
|
||||
NsDup, ProcCall, ProcKillTarget, RtSigInfo, ThreadCall, WaitFlags,
|
||||
};
|
||||
|
||||
#[inline]
|
||||
fn wrapper<T>(restart: bool, erestart: bool, mut f: impl FnMut() -> Result<T>) -> Result<T> {
|
||||
loop {
|
||||
let _guard = tmp_disable_signals();
|
||||
let rt_sigarea = unsafe { &Tcb::current().unwrap().os_specific };
|
||||
let res = f();
|
||||
let code = if erestart { ERESTART } else { EINTR };
|
||||
|
||||
if let Err(err) = res
|
||||
&& err == Error::new(code)
|
||||
{
|
||||
unsafe {
|
||||
manually_enter_trampoline();
|
||||
}
|
||||
if restart && unsafe { (*rt_sigarea.arch.get()).last_sig_was_restart } {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
}
|
||||
// TODO: uninitialized memory?
|
||||
#[inline]
|
||||
pub fn posix_read(fd: usize, buf: &mut [u8]) -> Result<usize> {
|
||||
wrapper(true, false, || syscall::read(fd, buf))
|
||||
}
|
||||
#[inline]
|
||||
pub fn posix_write(fd: usize, buf: &[u8]) -> Result<usize> {
|
||||
wrapper(true, false, || syscall::write(fd, buf))
|
||||
}
|
||||
#[inline]
|
||||
pub fn posix_kill(target: ProcKillTarget, sig: usize) -> Result<()> {
|
||||
if sig > 64 {
|
||||
return Err(Error::new(EINVAL));
|
||||
}
|
||||
|
||||
match wrapper(false, true, || {
|
||||
this_proc_call(
|
||||
&mut [],
|
||||
CallFlags::empty(),
|
||||
&[ProcCall::Kill as u64, target.raw() as u64, sig as u64],
|
||||
)
|
||||
}) {
|
||||
Ok(_) | Err(Error { errno: ERESTART }) => Ok(()),
|
||||
Err(error) => Err(error),
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn posix_sigqueue(pid: usize, sig: usize, arg: usize) -> Result<()> {
|
||||
let target = ProcKillTarget::from_raw(pid);
|
||||
if !matches!(target, ProcKillTarget::SingleProc(_)) {
|
||||
return Err(Error::new(ESRCH));
|
||||
}
|
||||
if sig <= 32 {
|
||||
return posix_kill(target, sig);
|
||||
}
|
||||
let mut siginf = RtSigInfo {
|
||||
arg,
|
||||
code: -1, // TODO: SI_QUEUE constant
|
||||
uid: 0, // TODO
|
||||
pid: posix_getpid(),
|
||||
};
|
||||
match wrapper(false, true, || {
|
||||
this_proc_call(
|
||||
unsafe { plain::as_mut_bytes(&mut siginf) },
|
||||
CallFlags::empty(),
|
||||
&[ProcCall::Sigq as u64, pid as u64, sig as u64],
|
||||
)
|
||||
}) {
|
||||
Ok(_)
|
||||
| Err(Error {
|
||||
errno: error::ERESTART,
|
||||
}) => Ok(()),
|
||||
Err(error) => Err(error),
|
||||
}
|
||||
}
|
||||
#[inline]
|
||||
pub fn posix_getpid() -> u32 {
|
||||
// SAFETY: read-only except during program/fork child initialization
|
||||
unsafe { addr_of!((*crate::STATIC_PROC_INFO.get()).pid).read() }
|
||||
}
|
||||
#[inline]
|
||||
pub fn posix_getppid() -> u32 {
|
||||
this_proc_call(&mut [], CallFlags::empty(), &[ProcCall::Getppid as u64]).expect("cannot fail")
|
||||
as u32
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn posix_setpriority(which: i32, who: u32, prio: u32) -> Result<(), syscall::Error> {
|
||||
if which != 0 {
|
||||
return Err(syscall::Error::new(syscall::EINVAL)); // TODO: Add support for PRIO_PGRP and PRIO_PROCESS
|
||||
}
|
||||
|
||||
this_proc_call(
|
||||
&mut [],
|
||||
CallFlags::empty(),
|
||||
&[ProcCall::SetProcPriority as u64, who as u64, prio as u64],
|
||||
)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn posix_getpriority(which: i32, who: u32) -> Result<u32, syscall::Error> {
|
||||
if which != 0 {
|
||||
return Err(syscall::Error::new(syscall::EINVAL));
|
||||
}
|
||||
|
||||
let res = this_proc_call(
|
||||
&mut [],
|
||||
CallFlags::empty(),
|
||||
&[ProcCall::GetProcPriority as u64, who as u64],
|
||||
)?;
|
||||
|
||||
Ok(res as u32)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub unsafe fn sys_futex_wait(addr: *mut u32, val: u32, deadline: Option<&TimeSpec>) -> Result<()> {
|
||||
wrapper(true, false, || {
|
||||
unsafe {
|
||||
syscall::syscall5(
|
||||
syscall::SYS_FUTEX,
|
||||
addr as usize,
|
||||
syscall::FUTEX_WAIT,
|
||||
val as usize,
|
||||
deadline.map_or(0, |d| d as *const _ as usize),
|
||||
0,
|
||||
)
|
||||
}
|
||||
.map(|_| ())
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
pub unsafe fn sys_futex_wake(addr: *mut u32, num: u32) -> Result<u32> {
|
||||
unsafe {
|
||||
syscall::syscall5(
|
||||
syscall::SYS_FUTEX,
|
||||
addr as usize,
|
||||
syscall::FUTEX_WAKE,
|
||||
num as usize,
|
||||
0,
|
||||
0,
|
||||
)
|
||||
}
|
||||
.map(|awoken| awoken as u32)
|
||||
}
|
||||
unsafe fn raw_sys_call(
|
||||
fd: usize,
|
||||
payload_ptr: *const u8,
|
||||
len: usize,
|
||||
flags: CallFlags,
|
||||
metadata: &[u64],
|
||||
) -> Result<usize> {
|
||||
unsafe {
|
||||
syscall::syscall5(
|
||||
syscall::SYS_CALL,
|
||||
fd,
|
||||
payload_ptr as usize,
|
||||
len,
|
||||
metadata.len() | flags.bits(),
|
||||
metadata.as_ptr() as usize,
|
||||
)
|
||||
}
|
||||
}
|
||||
pub fn sys_call_ro(
|
||||
fd: usize,
|
||||
payload: &mut [u8],
|
||||
flags: CallFlags,
|
||||
metadata: &[u64],
|
||||
) -> Result<usize> {
|
||||
unsafe {
|
||||
raw_sys_call(
|
||||
fd,
|
||||
payload.as_mut_ptr(),
|
||||
payload.len(),
|
||||
flags | CallFlags::READ,
|
||||
metadata,
|
||||
)
|
||||
}
|
||||
}
|
||||
pub fn sys_call_wo(fd: usize, payload: &[u8], flags: CallFlags, metadata: &[u64]) -> Result<usize> {
|
||||
unsafe {
|
||||
raw_sys_call(
|
||||
fd,
|
||||
payload.as_ptr(),
|
||||
payload.len(),
|
||||
flags | CallFlags::WRITE,
|
||||
metadata,
|
||||
)
|
||||
}
|
||||
}
|
||||
pub fn sys_call_rw(
|
||||
fd: usize,
|
||||
payload: &mut [u8],
|
||||
flags: CallFlags,
|
||||
metadata: &[u64],
|
||||
) -> Result<usize> {
|
||||
unsafe {
|
||||
raw_sys_call(
|
||||
fd,
|
||||
payload.as_mut_ptr(),
|
||||
payload.len(),
|
||||
flags | CallFlags::READ | CallFlags::WRITE,
|
||||
metadata,
|
||||
)
|
||||
}
|
||||
}
|
||||
pub fn sys_call(
|
||||
fd: usize,
|
||||
payload: &mut [u8],
|
||||
flags: CallFlags,
|
||||
metadata: &[u64],
|
||||
) -> Result<usize> {
|
||||
unsafe { raw_sys_call(fd, payload.as_mut_ptr(), payload.len(), flags, metadata) }
|
||||
}
|
||||
pub fn this_proc_call(payload: &mut [u8], flags: CallFlags, metadata: &[u64]) -> Result<usize> {
|
||||
proc_call(
|
||||
crate::current_proc_fd().as_raw_fd(),
|
||||
payload,
|
||||
flags,
|
||||
metadata,
|
||||
)
|
||||
}
|
||||
pub fn proc_call(
|
||||
proc_fd: usize,
|
||||
payload: &mut [u8],
|
||||
flags: CallFlags,
|
||||
metadata: &[u64],
|
||||
) -> Result<usize> {
|
||||
sys_call(proc_fd, payload, flags, metadata)
|
||||
}
|
||||
pub fn thread_call(
|
||||
thread_fd: usize,
|
||||
payload: &mut [u8],
|
||||
flags: CallFlags,
|
||||
metadata: &[u64],
|
||||
) -> Result<usize> {
|
||||
sys_call(thread_fd, payload, flags, metadata)
|
||||
}
|
||||
pub fn this_thread_call(payload: &mut [u8], flags: CallFlags, metadata: &[u64]) -> Result<usize> {
|
||||
thread_call(
|
||||
RtTcb::current().thread_fd().as_raw_fd(),
|
||||
payload,
|
||||
flags,
|
||||
metadata,
|
||||
)
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum WaitpidTarget {
|
||||
AnyChild,
|
||||
AnyGroupMember,
|
||||
SingleProc { pid: usize },
|
||||
ProcGroup { pgid: usize },
|
||||
}
|
||||
impl WaitpidTarget {
|
||||
pub fn from_posix_arg(raw: isize) -> Self {
|
||||
match raw {
|
||||
0 => Self::AnyGroupMember,
|
||||
-1 => Self::AnyChild,
|
||||
1.. => Self::SingleProc { pid: raw as usize },
|
||||
..-1 => Self::ProcGroup {
|
||||
pgid: -raw as usize,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn sys_waitpid(target: WaitpidTarget, status: &mut usize, flags: WaitFlags) -> Result<usize> {
|
||||
let (call, pid) = match target {
|
||||
WaitpidTarget::AnyChild => (ProcCall::Waitpid, 0),
|
||||
WaitpidTarget::SingleProc { pid } => (ProcCall::Waitpid, pid),
|
||||
WaitpidTarget::AnyGroupMember => (ProcCall::Waitpgid, 0),
|
||||
WaitpidTarget::ProcGroup { pgid } => (ProcCall::Waitpgid, pgid),
|
||||
};
|
||||
wrapper(true, false, || {
|
||||
this_proc_call(
|
||||
unsafe { plain::as_mut_bytes(status) },
|
||||
CallFlags::empty(),
|
||||
&[call as u64, pid as u64, flags.bits() as u64],
|
||||
)
|
||||
})
|
||||
}
|
||||
pub fn posix_kill_thread(thread_fd: usize, signal: u32) -> Result<()> {
|
||||
// TODO: don't hardcode?
|
||||
if signal > 64 {
|
||||
return Err(Error::new(EINVAL));
|
||||
}
|
||||
|
||||
match wrapper(false, true, || {
|
||||
thread_call(
|
||||
thread_fd,
|
||||
&mut [],
|
||||
CallFlags::empty(),
|
||||
&[ThreadCall::SignalThread as u64, signal.into()],
|
||||
)
|
||||
}) {
|
||||
Ok(_) | Err(Error { errno: ERESTART }) => Ok(()),
|
||||
Err(error) => Err(error),
|
||||
}
|
||||
}
|
||||
|
||||
static UMASK: AtomicU32 = AtomicU32::new(0o022);
|
||||
|
||||
/// Controls the set of bits removed from the `mode` mask when new file descriptors are created.
|
||||
///
|
||||
/// Must be validated by the caller
|
||||
//
|
||||
// TODO: validate here?
|
||||
#[inline]
|
||||
pub fn swap_umask(mask: u32) -> u32 {
|
||||
UMASK.swap(mask, Ordering::AcqRel)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn get_umask() -> u32 {
|
||||
UMASK.load(Ordering::Acquire)
|
||||
}
|
||||
|
||||
/// Real/Effective/Set-User/Group ID
|
||||
pub struct Resugid<T> {
|
||||
pub ruid: T,
|
||||
pub euid: T,
|
||||
pub suid: T,
|
||||
pub rgid: T,
|
||||
pub egid: T,
|
||||
pub sgid: T,
|
||||
}
|
||||
|
||||
/// Sets [res][ug]id, fields that are None will be unchanged.
|
||||
pub fn posix_setresugid(ids: &Resugid<Option<u32>>) -> Result<()> {
|
||||
// TODO: not sure how "tmp" an IPC call is?
|
||||
let _sig_guard = tmp_disable_signals();
|
||||
let mut guard = DYNAMIC_PROC_INFO.lock();
|
||||
|
||||
let mut buf = [0_u8; size_of::<u32>() * 6];
|
||||
plain::slice_from_mut_bytes(&mut buf)
|
||||
.unwrap()
|
||||
.copy_from_slice(&[
|
||||
ids.ruid.unwrap_or(u32::MAX),
|
||||
ids.euid.unwrap_or(u32::MAX),
|
||||
ids.suid.unwrap_or(u32::MAX),
|
||||
ids.rgid.unwrap_or(u32::MAX),
|
||||
ids.egid.unwrap_or(u32::MAX),
|
||||
ids.sgid.unwrap_or(u32::MAX),
|
||||
]);
|
||||
|
||||
this_proc_call(&mut buf, CallFlags::empty(), &[ProcCall::SetResugid as u64])?;
|
||||
|
||||
if let Some(ruid) = ids.ruid {
|
||||
guard.ruid = ruid;
|
||||
}
|
||||
if let Some(euid) = ids.euid {
|
||||
guard.euid = euid;
|
||||
}
|
||||
if let Some(suid) = ids.suid {
|
||||
guard.suid = suid;
|
||||
}
|
||||
if let Some(rgid) = ids.rgid {
|
||||
guard.rgid = rgid;
|
||||
}
|
||||
if let Some(egid) = ids.egid {
|
||||
guard.egid = egid;
|
||||
}
|
||||
if let Some(sgid) = ids.sgid {
|
||||
guard.sgid = sgid;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
pub fn posix_getresugid() -> Resugid<u32> {
|
||||
let _sig_guard = tmp_disable_signals();
|
||||
let DynamicProcInfo {
|
||||
ruid,
|
||||
euid,
|
||||
suid,
|
||||
rgid,
|
||||
egid,
|
||||
sgid,
|
||||
..
|
||||
} = *DYNAMIC_PROC_INFO.lock();
|
||||
Resugid {
|
||||
ruid,
|
||||
euid,
|
||||
suid,
|
||||
rgid,
|
||||
egid,
|
||||
sgid,
|
||||
}
|
||||
}
|
||||
pub fn getens() -> Result<usize> {
|
||||
read_proc_meta(crate::current_proc_fd()).map(|meta| meta.ens as usize)
|
||||
}
|
||||
pub fn get_proc_credentials(cap_fd: usize, target_pid: usize, buf: &mut [u8]) -> Result<usize> {
|
||||
if buf.len() < size_of::<redox_protocols::protocol::ProcMeta>() {
|
||||
return Err(Error::new(EINVAL));
|
||||
}
|
||||
proc_call(
|
||||
cap_fd,
|
||||
buf,
|
||||
CallFlags::empty(),
|
||||
&[ProcCall::GetProcCredentials as u64, target_pid as u64],
|
||||
)
|
||||
}
|
||||
pub fn posix_exit(status: i32) -> ! {
|
||||
this_proc_call(
|
||||
&mut [],
|
||||
CallFlags::empty(),
|
||||
&[ProcCall::Exit as u64, (status & 0xFF) as u64],
|
||||
)
|
||||
.expect("failed to call proc mgr with Exit");
|
||||
let _ = syscall::write(1, b"redox-rt: ProcCall::Exit FAILED, abort()ing!\n");
|
||||
core::intrinsics::abort();
|
||||
}
|
||||
pub fn posix_getpgid(pid: usize) -> Result<usize> {
|
||||
this_proc_call(
|
||||
&mut [],
|
||||
CallFlags::empty(),
|
||||
&[ProcCall::Setpgid as u64, pid as u64, u64::wrapping_neg(1)],
|
||||
)
|
||||
}
|
||||
pub fn posix_setpgid(pid: usize, pgid: usize) -> Result<()> {
|
||||
if pgid == usize::wrapping_neg(1) {
|
||||
return Err(Error::new(EINVAL));
|
||||
}
|
||||
this_proc_call(
|
||||
&mut [],
|
||||
CallFlags::empty(),
|
||||
&[ProcCall::Setpgid as u64, pid as u64, pgid as u64],
|
||||
)?;
|
||||
Ok(())
|
||||
}
|
||||
pub fn posix_getsid(pid: usize) -> Result<usize> {
|
||||
this_proc_call(
|
||||
&mut [],
|
||||
CallFlags::empty(),
|
||||
&[ProcCall::Getsid as u64, pid as u64],
|
||||
)
|
||||
}
|
||||
pub fn posix_setsid() -> Result<u32> {
|
||||
this_proc_call(&mut [], CallFlags::empty(), &[ProcCall::Setsid as u64])?;
|
||||
Ok(posix_getpid())
|
||||
}
|
||||
pub fn posix_nanosleep(rqtp: &TimeSpec, rmtp: &mut TimeSpec) -> Result<()> {
|
||||
wrapper(false, false, || syscall::nanosleep(rqtp, rmtp))?;
|
||||
Ok(())
|
||||
}
|
||||
pub fn setns(fd: usize) -> Option<FdGuardUpper> {
|
||||
let mut info = DYNAMIC_PROC_INFO.lock();
|
||||
let new_fd_guard = FdGuard::new(fd).to_upper().unwrap();
|
||||
let old_fd_guard = replace(&mut info.ns_fd, Some(new_fd_guard));
|
||||
old_fd_guard
|
||||
}
|
||||
pub fn getns() -> Result<usize> {
|
||||
let cur_ns = crate::current_namespace_fd()?;
|
||||
if cur_ns == usize::MAX {
|
||||
Err(Error::new(ENODEV))
|
||||
} else {
|
||||
Ok(cur_ns)
|
||||
}
|
||||
}
|
||||
pub fn open<T: AsRef<str>>(path: T, flags: usize) -> Result<usize> {
|
||||
let path = path.as_ref();
|
||||
let fcntl_flags = flags & syscall::O_FCNTL_MASK;
|
||||
unsafe {
|
||||
syscall::syscall5(
|
||||
syscall::SYS_OPENAT,
|
||||
crate::current_namespace_fd()?,
|
||||
path.as_ptr() as usize,
|
||||
path.len(),
|
||||
flags,
|
||||
fcntl_flags,
|
||||
)
|
||||
}
|
||||
}
|
||||
pub fn openat<T: AsRef<str>>(
|
||||
fd: usize,
|
||||
path: T,
|
||||
flags: usize,
|
||||
fcntl_flags: usize,
|
||||
) -> Result<usize> {
|
||||
let path = path.as_ref();
|
||||
unsafe {
|
||||
syscall::syscall5(
|
||||
syscall::SYS_OPENAT,
|
||||
fd,
|
||||
path.as_ptr() as usize,
|
||||
path.len(),
|
||||
flags,
|
||||
fcntl_flags,
|
||||
)
|
||||
}
|
||||
}
|
||||
pub fn unlink<T: AsRef<str>>(path: T, flags: usize) -> Result<usize> {
|
||||
let path = path.as_ref();
|
||||
unsafe {
|
||||
syscall::syscall4(
|
||||
syscall::SYS_UNLINKAT,
|
||||
crate::current_namespace_fd()?,
|
||||
path.as_ptr() as usize,
|
||||
path.len(),
|
||||
flags,
|
||||
)
|
||||
}
|
||||
}
|
||||
pub fn mkns(names: &[IoSlice]) -> Result<FdGuardUpper> {
|
||||
let mut buf = Vec::from((NsDup::ForkNs as usize).to_ne_bytes());
|
||||
for name in names {
|
||||
let name_bytes = name.as_slice();
|
||||
let len = name_bytes.len();
|
||||
let _scheme_name = core::str::from_utf8(name_bytes).map_err(|_| Error::new(EINVAL))?;
|
||||
buf.extend_from_slice(&len.to_ne_bytes());
|
||||
buf.extend_from_slice(name_bytes);
|
||||
}
|
||||
FdGuard::new(syscall::dup(crate::current_namespace_fd()?, &buf)?).to_upper()
|
||||
}
|
||||
pub fn register_scheme_to_ns(ns_fd: usize, name: &str, cap_fd: usize) -> Result<()> {
|
||||
let mut buf = alloc::vec::Vec::from((NsDup::IssueRegister as usize).to_ne_bytes());
|
||||
buf.extend_from_slice(name.as_bytes());
|
||||
let ns_this_scheme = FdGuard::new(syscall::dup(ns_fd, &buf)?);
|
||||
let cap_bytes = cap_fd.to_ne_bytes();
|
||||
ns_this_scheme.call_wo(&cap_bytes, CallFlags::FD, &[])?;
|
||||
Ok(())
|
||||
}
|
||||
pub fn std_fs_call_ro(fd: usize, payload: &mut [u8], metadata: &StdFsCallMeta) -> Result<usize> {
|
||||
sys_call_ro(fd, payload, CallFlags::STD_FS, metadata)
|
||||
}
|
||||
pub fn std_fs_call_wo(fd: usize, payload: &[u8], metadata: &StdFsCallMeta) -> Result<usize> {
|
||||
sys_call_wo(fd, payload, CallFlags::STD_FS, metadata)
|
||||
}
|
||||
pub fn std_fs_call_rw(fd: usize, payload: &mut [u8], metadata: &StdFsCallMeta) -> Result<usize> {
|
||||
sys_call_rw(fd, payload, CallFlags::STD_FS, metadata)
|
||||
}
|
||||
pub fn fstat(fd: usize, stat: &mut syscall::Stat) -> Result<usize> {
|
||||
std_fs_call_ro(fd, stat, &StdFsCallMeta::new(StdFsCallKind::Fstat, 0, 0))
|
||||
}
|
||||
|
||||
pub fn fcntl(fd: usize, cmd: usize, arg: usize) -> Result<usize> {
|
||||
let _siglock = tmp_disable_signals();
|
||||
let raw_fd = syscall::fcntl(fd, cmd, arg)?;
|
||||
Ok(FdGuard::new(raw_fd).as_raw_fd())
|
||||
}
|
||||
@@ -1,70 +0,0 @@
|
||||
use core::mem::size_of;
|
||||
|
||||
use syscall::Result;
|
||||
|
||||
use crate::{RtTcb, arch::*, proc::*, signal::tmp_disable_signals, static_proc_info};
|
||||
|
||||
/// Spawns a new context sharing the same address space as the current one (i.e. a new thread).
|
||||
pub unsafe fn rlct_clone_impl(stack: *mut usize, tcb: &RtTcb) -> Result<usize> {
|
||||
let proc_info = static_proc_info();
|
||||
let cur_proc_fd = proc_info.proc_fd.as_ref().unwrap();
|
||||
|
||||
let cur_thr_fd = RtTcb::current().thread_fd();
|
||||
let new_thr_fd = cur_proc_fd.dup(b"new-thread")?.to_upper().unwrap();
|
||||
|
||||
// Inherit existing address space
|
||||
{
|
||||
let cur_addr_space_fd = cur_thr_fd.dup(b"addrspace")?;
|
||||
let new_addr_space_sel_fd = new_thr_fd.dup(b"current-addrspace")?;
|
||||
|
||||
let buf = create_set_addr_space_buf(
|
||||
cur_addr_space_fd.as_raw_fd(),
|
||||
__relibc_internal_rlct_clone_ret as *const () as usize,
|
||||
stack as usize,
|
||||
);
|
||||
new_addr_space_sel_fd.write(&buf)?;
|
||||
}
|
||||
|
||||
// Inherit reference to file table
|
||||
{
|
||||
let cur_filetable_fd = cur_thr_fd.dup(b"filetable")?;
|
||||
let new_filetable_sel_fd = new_thr_fd.dup(b"current-filetable")?;
|
||||
|
||||
new_filetable_sel_fd.write(&usize::to_ne_bytes(cur_filetable_fd.as_raw_fd()))?;
|
||||
}
|
||||
|
||||
// Since the signal handler is not yet initialized, signals specifically targeting the thread
|
||||
// (relibc is only required to implement thread-specific signals that already originate from
|
||||
// the same process) will be discarded. Process-specific signals will ignore this new thread,
|
||||
// until it has initialized its own signal handler.
|
||||
|
||||
let start_fd = new_thr_fd.dup(b"start")?;
|
||||
|
||||
let fd = new_thr_fd.as_raw_fd();
|
||||
unsafe {
|
||||
tcb.thr_fd.get().write(Some(new_thr_fd));
|
||||
}
|
||||
|
||||
// Unblock context.
|
||||
start_fd.write(&[0])?;
|
||||
|
||||
Ok(fd)
|
||||
}
|
||||
|
||||
pub unsafe fn exit_this_thread(stack_base: *mut (), stack_size: usize) -> ! {
|
||||
let _guard = tmp_disable_signals();
|
||||
|
||||
let tcb = RtTcb::current();
|
||||
// TODO: modify interface so it writes directly to the thread fd?
|
||||
let status_fd = tcb.thread_fd().dup(b"status").unwrap();
|
||||
|
||||
let _ = unsafe { syscall::funmap(tcb as *const RtTcb as usize, syscall::PAGE_SIZE) };
|
||||
|
||||
let mut buf = [0; size_of::<usize>() * 3];
|
||||
plain::slice_from_mut_bytes(&mut buf)
|
||||
.unwrap()
|
||||
.copy_from_slice(&[usize::MAX, stack_base as usize, stack_size]);
|
||||
// TODO: SYS_CALL w/CONSUME
|
||||
status_fd.write(&buf).unwrap();
|
||||
unreachable!()
|
||||
}
|
||||
@@ -1,58 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
set -e
|
||||
|
||||
target=$1
|
||||
deps_dir=$2
|
||||
|
||||
if [ -z "$target" ] || [ -z "$deps_dir" ]; then
|
||||
echo "Usage:\n\t./renamesyms.sh TARGET DEPS_DIR"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ ! -f "$target" ]; then
|
||||
echo "Target file '$target' does not exist"
|
||||
exit 1
|
||||
fi
|
||||
if [ ! -d "$deps_dir" ] ; then
|
||||
echo "Deps dir '$deps_dir' does not exist or not a directory"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
symbols_file=`mktemp`
|
||||
special_syms=(
|
||||
__rdl_oom
|
||||
__rg_alloc
|
||||
__rg_alloc_zeroed
|
||||
__rg_dealloc
|
||||
__rg_oom
|
||||
__rg_realloc
|
||||
__rust_alloc
|
||||
__rust_alloc_error_handler
|
||||
__rust_alloc_error_handler_should_panic
|
||||
__rust_alloc_zeroed
|
||||
__rust_dealloc
|
||||
__rust_no_alloc_shim_is_unstable
|
||||
__rust_realloc
|
||||
)
|
||||
|
||||
for dep in `find $deps_dir -type f -name "*.rlib"`; do
|
||||
"${NM}" --format=posix -g "$dep" 2>/dev/null | sed 's/.*:.*//g' | awk '{if ($2 == "T") print $1}' | sed 's/^\(.*\)$/\1 __relibc_\1/g' >> $symbols_file
|
||||
done
|
||||
|
||||
for special_sym in "${special_syms[@]}"; do
|
||||
echo "$special_sym __relibc_$special_sym" >> $symbols_file
|
||||
done
|
||||
|
||||
mangled_alloc_syms=$("${NM}" --format=posix -g "$target" 2>/dev/null | awk '{print $1}' | grep "7___rustc" || true)
|
||||
for sym in $mangled_alloc_syms; do
|
||||
echo "$sym __relibc_$sym" >> $symbols_file
|
||||
done
|
||||
|
||||
sorted_file=`mktemp`
|
||||
sort -u "$symbols_file" > "$sorted_file"
|
||||
rm -f "$symbols_file"
|
||||
|
||||
"${OBJCOPY}" --redefine-syms="$sorted_file" "$target"
|
||||
|
||||
rm -f "$sorted_file"
|
||||
@@ -0,0 +1,6 @@
|
||||
########## Red Bear OS #########
|
||||
# Login with the following: #
|
||||
# `user` #
|
||||
# `root`:`password` #
|
||||
################################
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
########## Redox OS ##########
|
||||
# Login with the following: #
|
||||
# `user` #
|
||||
# `root`:`password` #
|
||||
##############################
|
||||
|
||||
@@ -1,3 +0,0 @@
|
||||
[toolchain]
|
||||
channel = "nightly-2025-11-15"
|
||||
components = ["rust-src"]
|
||||
@@ -1,21 +0,0 @@
|
||||
blank_lines_lower_bound = 0
|
||||
blank_lines_upper_bound = 1
|
||||
brace_style = "SameLineWhere"
|
||||
disable_all_formatting = false
|
||||
edition = "2024"
|
||||
empty_item_single_line = true
|
||||
fn_single_line = false
|
||||
force_explicit_abi = true
|
||||
format_strings = false
|
||||
hard_tabs = false
|
||||
imports_granularity = "Crate"
|
||||
imports_indent = "Block"
|
||||
imports_layout = "Mixed"
|
||||
indent_style = "Block"
|
||||
max_width = 100
|
||||
newline_style = "Unix"
|
||||
show_parse_errors = true
|
||||
skip_children = false
|
||||
tab_spaces = 4
|
||||
trailing_comma = "Vertical"
|
||||
where_single_line = false
|
||||
@@ -0,0 +1,285 @@
|
||||
#[macro_use]
|
||||
extern crate clap;
|
||||
|
||||
use std::error::Error;
|
||||
use std::fs::File;
|
||||
use std::io::{self, ErrorKind, Read, Stderr, Write};
|
||||
use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
|
||||
use std::process::{Child, Command, Stdio};
|
||||
use std::str;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use event::{EventFlags, RawEventQueue};
|
||||
use extra::io::fail;
|
||||
use libredox::call as redox;
|
||||
use libredox::errno::EAGAIN;
|
||||
use libredox::flag;
|
||||
|
||||
const _MAN_PAGE: &'static str = /* @MANSTART{getty} */
|
||||
r#"
|
||||
NAME
|
||||
getty - set terminal mode
|
||||
|
||||
SYNOPSIS
|
||||
getty [-J | --noclear | -C | --contain ] tty
|
||||
getty [ -h | --help ]
|
||||
|
||||
DESCRIPTION
|
||||
The getty utility is called by init(8) to open and initialize the tty line,
|
||||
read a login name, and invoke login(1).
|
||||
|
||||
OPTIONS
|
||||
|
||||
-h, --help
|
||||
Display this help and exit.
|
||||
|
||||
-J, --noclear
|
||||
Do not clear the screen before forking login(1).
|
||||
|
||||
-C, --contain
|
||||
Run contain_login instead of login
|
||||
|
||||
AUTHOR
|
||||
Written by Jeremy Soller.
|
||||
"#; /* @MANEND */
|
||||
|
||||
const DEFAULT_COLS: u16 = 80;
|
||||
const DEFAULT_LINES: u16 = 30;
|
||||
|
||||
pub fn handle(
|
||||
event_queue: &mut RawEventQueue,
|
||||
tty_fd: RawFd,
|
||||
master_fd: RawFd,
|
||||
process: &mut Child,
|
||||
) {
|
||||
// tty_fd => Display
|
||||
// master_fd => PTY
|
||||
|
||||
let handle_event = |event_id: usize| {
|
||||
if event_id as RawFd == tty_fd {
|
||||
let mut packet = [0; 4096];
|
||||
loop {
|
||||
let count = match redox::read(tty_fd as usize, &mut packet) {
|
||||
Ok(0) => return,
|
||||
Ok(count) => count,
|
||||
Err(ref err) if err.errno() == EAGAIN => break,
|
||||
Err(_) => panic!("getty: failed to read from TTY"),
|
||||
};
|
||||
redox::write(master_fd as usize, &packet[..count])
|
||||
.expect("getty: failed to write master PTY");
|
||||
}
|
||||
} else if event_id as RawFd == master_fd {
|
||||
let mut packet = [0; 4096];
|
||||
loop {
|
||||
let count = match redox::read(master_fd as usize, &mut packet) {
|
||||
Ok(0) => return,
|
||||
Ok(count) => count,
|
||||
Err(ref err) if err.errno() == EAGAIN => break,
|
||||
Err(_) => panic!("getty: failed to read from master TTY"),
|
||||
};
|
||||
redox::write(tty_fd as usize, &packet[1..count])
|
||||
.expect("getty: failed to write to TTY");
|
||||
if packet[0] & 1 == 1 {
|
||||
let _ = redox::fsync(tty_fd as usize);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
handle_event(tty_fd as usize);
|
||||
handle_event(master_fd as usize);
|
||||
|
||||
'events: loop {
|
||||
let sys_event = event_queue
|
||||
.next()
|
||||
.expect("getty: event queue stopped")
|
||||
.expect("getty: failed to read event file");
|
||||
handle_event(sys_event.fd);
|
||||
|
||||
match process.try_wait() {
|
||||
Ok(status) => match status {
|
||||
Some(_code) => break 'events,
|
||||
None => (),
|
||||
},
|
||||
Err(err) => match err.kind() {
|
||||
ErrorKind::WouldBlock => (),
|
||||
_ => panic!("getty: failed to wait on child: {:?}", err),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
let _ = process.kill();
|
||||
process.wait().expect("getty: failed to wait on login");
|
||||
}
|
||||
|
||||
pub fn getpty(columns: u16, lines: u16) -> (RawFd, String) {
|
||||
let master = redox::open(
|
||||
"/scheme/pty",
|
||||
flag::O_CLOEXEC | flag::O_RDWR | flag::O_CREAT | flag::O_NONBLOCK,
|
||||
0,
|
||||
)
|
||||
.expect("getty: failed to create PTY");
|
||||
|
||||
if let Ok(winsize_fd) = redox::dup(master, b"winsize") {
|
||||
let _ = redox::write(
|
||||
winsize_fd,
|
||||
&redox_termios::Winsize {
|
||||
ws_row: lines,
|
||||
ws_col: columns,
|
||||
},
|
||||
);
|
||||
let _ = redox::close(winsize_fd);
|
||||
}
|
||||
|
||||
let mut buf: [u8; 4096] = [0; 4096];
|
||||
let count = redox::fpath(master, &mut buf).unwrap();
|
||||
(master as RawFd, unsafe {
|
||||
String::from_utf8_unchecked(Vec::from(&buf[..count]))
|
||||
})
|
||||
}
|
||||
|
||||
// termion cursor_pos prone to error and does not work on nonblocking files
|
||||
fn tty_cursor_pos(tty: &mut File) -> Result<(u16, u16), Box<dyn Error>> {
|
||||
write!(tty, "\x1B[6n")?;
|
||||
tty.flush()?;
|
||||
|
||||
let timeout = Duration::from_millis(500);
|
||||
let instant = Instant::now();
|
||||
let mut data = String::new();
|
||||
while instant.elapsed() < timeout {
|
||||
let mut bytes = [0];
|
||||
match tty.read(&mut bytes) {
|
||||
Ok(count) => if count == 1 {
|
||||
let c = bytes[0] as char;
|
||||
if c == 'R' {
|
||||
break;
|
||||
}
|
||||
data.push(c);
|
||||
},
|
||||
Err(err) => if err.kind() != ErrorKind::WouldBlock {
|
||||
return Err(err.into());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if data.is_empty() {
|
||||
return Err("cursor position timed out".into());
|
||||
}
|
||||
|
||||
let beg = data.rfind('[').ok_or("failed to find [")?;
|
||||
let coords: String = data.chars().skip(beg + 1).collect();
|
||||
let mut nums = coords.split(';');
|
||||
|
||||
let row = nums.next().ok_or("failed to find row")?.parse::<u16>()?;
|
||||
let col = nums.next().ok_or("failed to find col")?.parse::<u16>()?;
|
||||
|
||||
Ok((col, row))
|
||||
}
|
||||
|
||||
fn tty_columns_lines(tty: &mut File) -> Result<(u16, u16), Box<dyn Error>> {
|
||||
write!(tty, "{}", termion::cursor::Save)?;
|
||||
tty.flush()?;
|
||||
|
||||
write!(tty, "{}", termion::cursor::Goto(999, 999))?;
|
||||
tty.flush()?;
|
||||
|
||||
let res = tty_cursor_pos(tty);
|
||||
|
||||
write!(tty, "{}", termion::cursor::Restore)?;
|
||||
tty.flush()?;
|
||||
|
||||
res
|
||||
}
|
||||
|
||||
fn daemon(tty: &mut File, clear: bool, contain: bool, stderr: &mut Stderr) {
|
||||
let (columns, lines) = tty_columns_lines(tty).unwrap_or((DEFAULT_COLS, DEFAULT_LINES));
|
||||
let tty_fd = tty.as_raw_fd();
|
||||
|
||||
let (master_fd, pty) = getpty(columns, lines);
|
||||
|
||||
let mut event_queue = event::RawEventQueue::new().expect("getty: failed to open event queue");
|
||||
|
||||
event_queue
|
||||
.subscribe(tty_fd as usize, 0, EventFlags::READ)
|
||||
.expect("getty: failed to fevent TTY");
|
||||
|
||||
event_queue
|
||||
.subscribe(master_fd as usize, 0, EventFlags::READ)
|
||||
.expect("getty: failed to fevent master PTY");
|
||||
|
||||
loop {
|
||||
if clear {
|
||||
let _ = redox::write(tty_fd as usize, b"\x1Bc");
|
||||
}
|
||||
let _ = redox::fsync(tty_fd as usize);
|
||||
|
||||
let slave_stdin = redox::open(&pty, flag::O_CLOEXEC | flag::O_RDONLY, 0)
|
||||
.expect("getty: failed to open slave stdin");
|
||||
let slave_stdout = redox::open(&pty, flag::O_CLOEXEC | flag::O_WRONLY, 0)
|
||||
.expect("getty: failed to open slave stdout");
|
||||
let slave_stderr = redox::open(&pty, flag::O_CLOEXEC | flag::O_WRONLY, 0)
|
||||
.expect("getty: failed to open slave stderr");
|
||||
|
||||
let mut command = if contain {
|
||||
Command::new("contain_login")
|
||||
} else {
|
||||
Command::new("login")
|
||||
};
|
||||
unsafe {
|
||||
command
|
||||
.stdin(Stdio::from_raw_fd(slave_stdin as RawFd))
|
||||
.stdout(Stdio::from_raw_fd(slave_stdout as RawFd))
|
||||
.stderr(Stdio::from_raw_fd(slave_stderr as RawFd))
|
||||
.env("TERM", "xterm-256color")
|
||||
.env("TTY", &pty);
|
||||
}
|
||||
|
||||
match command.spawn() {
|
||||
Ok(mut process) => {
|
||||
handle(&mut event_queue, tty_fd, master_fd, &mut process);
|
||||
}
|
||||
Err(err) => fail(&format!("getty: failed to execute login: {}", err), stderr),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn main() {
|
||||
let mut stderr = io::stderr();
|
||||
|
||||
let args = clap_app!(getty =>
|
||||
(author: "Jeremy Soller")
|
||||
(about: "Set terminal mode")
|
||||
(@arg TTY: +required "")
|
||||
(@arg NO_CLEAR: -J --("no-clear") "Do not clear the screen before forking")
|
||||
(@arg CONTAIN: -C --("contain") "Run contain_login instead of login")
|
||||
)
|
||||
.get_matches();
|
||||
|
||||
let clear = !args.is_present("NO_CLEAR");
|
||||
|
||||
let contain = args.is_present("CONTAIN");
|
||||
|
||||
let vt = args.value_of("TTY").unwrap();
|
||||
|
||||
let buf: String;
|
||||
let vt_path = if vt.parse::<usize>().is_ok() {
|
||||
buf = format!("/scheme/fbcon/{vt}");
|
||||
&*buf
|
||||
} else {
|
||||
vt
|
||||
};
|
||||
|
||||
let mut tty = match redox::open(
|
||||
&vt_path,
|
||||
flag::O_CLOEXEC | flag::O_RDWR | flag::O_NONBLOCK,
|
||||
0,
|
||||
) {
|
||||
Ok(fd) => unsafe { File::from_raw_fd(fd as RawFd) },
|
||||
Err(err) => fail(
|
||||
&format!("getty: failed to open TTY {}: {}", vt_path, err),
|
||||
&mut stderr,
|
||||
),
|
||||
};
|
||||
|
||||
daemon(&mut tty, clear, contain, &mut stderr);
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
#[macro_use]
|
||||
extern crate clap;
|
||||
|
||||
use extra::option::OptionalExt;
|
||||
|
||||
use std::process::exit;
|
||||
|
||||
use redox_users::{All, AllGroups, Config, Error, GroupBuilder};
|
||||
|
||||
const _MAN_PAGE: &'static str = /* @MANSTART{groupadd} */
|
||||
r#"
|
||||
NAME
|
||||
groupadd - add a user group
|
||||
|
||||
SYNOPSIS
|
||||
groupadd [ -f | --force ] GROUP
|
||||
groupadd [ -h | --help ]
|
||||
|
||||
DESCRIPTION
|
||||
The groupadd utility adds a new user group using values
|
||||
passed on the command line and system defaults.
|
||||
|
||||
OPTIONS
|
||||
-f, --force
|
||||
Simply forces the exit status of the program to 0
|
||||
even if the group already exists. A message is still
|
||||
printed to stdout.
|
||||
|
||||
-g, --gid GID
|
||||
The group id to use. This value must not be used and must
|
||||
be non-negative. The default is to pick the smallest available
|
||||
group id (between values defined in redox_users).
|
||||
|
||||
-h, --help
|
||||
Display this help and exit.
|
||||
|
||||
AUTHOR
|
||||
Written by Wesley Hershberger.
|
||||
"#; /* @MANEND */
|
||||
|
||||
fn main() {
|
||||
let args = clap_app!(groupadd =>
|
||||
(author: "Wesley Hershberger")
|
||||
(about: "Add groups based on the system's redox_users backend")
|
||||
(@arg GROUP: +required "Add group GROUP")
|
||||
(@arg FORCE: -f --force "Force the status of the program to be 0 even if the group exists")
|
||||
(@arg GID: -g --gid +takes_value "Group id. Positive integer and must not be in use")
|
||||
)
|
||||
.get_matches();
|
||||
|
||||
let mut sys_groups = AllGroups::new(Config::default().writeable(true)).unwrap_or_exit(1);
|
||||
|
||||
let groupname = args.value_of("GROUP").unwrap();
|
||||
|
||||
let gid = match args.value_of("GID") {
|
||||
Some(gid) => {
|
||||
let id = gid.parse::<usize>().unwrap_or_exit(1);
|
||||
if let Some(_group) = sys_groups.get_by_id(id) {
|
||||
eprintln!("groupadd: group already exists");
|
||||
exit(1);
|
||||
}
|
||||
id
|
||||
}
|
||||
None => sys_groups.get_unique_id().unwrap_or_else(|| {
|
||||
eprintln!("groupadd: no available gid");
|
||||
exit(1);
|
||||
}),
|
||||
};
|
||||
|
||||
let group = GroupBuilder::new(groupname).gid(gid);
|
||||
match sys_groups.add_group(group) {
|
||||
Ok(_) => (),
|
||||
Err(Error::GroupAlreadyExists) if args.is_present("FORCE") => {
|
||||
exit(0);
|
||||
}
|
||||
Err(err) => {
|
||||
eprintln!("groupadd: {}", err);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
sys_groups.save().unwrap_or_exit(1);
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
#[macro_use]
|
||||
extern crate clap;
|
||||
|
||||
use extra::option::OptionalExt;
|
||||
use redox_users::{All, AllGroups, Config};
|
||||
|
||||
const _MAN_PAGE: &'static str = /* @MANSTART{groupdel} */
|
||||
r#"
|
||||
NAME
|
||||
groupdel - modify system files to delete groups
|
||||
|
||||
SYNOPSYS
|
||||
groupdel [ options ] GROUP
|
||||
groupdel [ -h | --help ]
|
||||
|
||||
DESCRIPTION
|
||||
groupdel removes groups from whatever backend is employed by
|
||||
the system's redox_users.
|
||||
|
||||
Note that you should not remove a primary user group before
|
||||
removing the user. It is also generally wise not to remove
|
||||
groups that still own files on the system.
|
||||
|
||||
OPTIONS
|
||||
-h, --help
|
||||
Print this help page and exit.
|
||||
|
||||
AUTHORS
|
||||
Wesley Hershberger.
|
||||
"#; /* @MANEND */
|
||||
|
||||
fn main() {
|
||||
let matches = clap_app!(groupdel =>
|
||||
(author: "Wesley Hershberger")
|
||||
(about: "Removes a group from the system using redox_users")
|
||||
(@arg GROUP: +required "Removes group GROUP")
|
||||
)
|
||||
.get_matches();
|
||||
|
||||
let group = matches.value_of("GROUP").unwrap();
|
||||
|
||||
let mut sys_groups = AllGroups::new(Config::default().writeable(true)).unwrap_or_exit(1);
|
||||
|
||||
sys_groups.remove_by_name(group.to_string());
|
||||
|
||||
sys_groups.save().unwrap_or_exit(1);
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
#[macro_use]
|
||||
extern crate clap;
|
||||
|
||||
use std::process::exit;
|
||||
|
||||
use extra::option::OptionalExt;
|
||||
use redox_users::{All, AllGroups, AllUsers, Config};
|
||||
|
||||
const _MAN_PAGE: &'static str = /* @MANSTART{groupmod} */
|
||||
r#"
|
||||
NAME
|
||||
groupmod - modify group information
|
||||
|
||||
SYNOPSYS
|
||||
groupmod [ options ] GROUP
|
||||
groupmod [ -h | --help ]
|
||||
|
||||
DESCRIPTION
|
||||
groupmod modifies a user group GROUP in the system's
|
||||
redox_users backend.
|
||||
|
||||
OPTIONS
|
||||
-h, --help
|
||||
Print this help page and exit.
|
||||
|
||||
-g, --gid GID
|
||||
Change GROUP's group id. GID must be a non-negative
|
||||
decimal integer.
|
||||
|
||||
Files with GROUP's old gid will not be updated.
|
||||
|
||||
User's who use the old gid as their primary gid will
|
||||
be updated.
|
||||
|
||||
-n, --name NAME
|
||||
The name of the group will be set to NAME
|
||||
|
||||
AUTHORS
|
||||
Wesley Hershberger.
|
||||
"#; /* @MANEND */
|
||||
|
||||
fn main() {
|
||||
let args = clap_app!(groupmod =>
|
||||
(author: "Wesley Hershberger")
|
||||
(about: "Modify users according to the system's redox_users backend")
|
||||
(@arg GROUP: +required "Modify GROUP")
|
||||
(@arg GID: -g --gid +takes_value "Change GROUP's group id. See man page for details")
|
||||
(@arg NAME: -n --name +takes_value "Change GROUP's name")
|
||||
)
|
||||
.get_matches();
|
||||
|
||||
let groupname = args.value_of("GROUP").unwrap();
|
||||
|
||||
let mut sys_groups = AllGroups::new(Config::default().writeable(true)).unwrap_or_exit(1);
|
||||
{
|
||||
let group = sys_groups.get_mut_by_name(groupname).unwrap_or_else(|| {
|
||||
eprintln!("groupmod: group not found: {}", groupname);
|
||||
exit(1);
|
||||
});
|
||||
|
||||
if let Some(gid) = args.value_of("GID") {
|
||||
let gid = gid.parse::<usize>().unwrap_or_exit(1);
|
||||
// Update users
|
||||
let mut sys_users =
|
||||
AllUsers::authenticator(Config::default().writeable(true)).unwrap_or_exit(1);
|
||||
for user in sys_users.iter_mut() {
|
||||
if user.gid == group.gid {
|
||||
user.gid = gid;
|
||||
}
|
||||
}
|
||||
sys_users.save().unwrap_or_exit(1);
|
||||
group.gid = gid;
|
||||
}
|
||||
|
||||
if let Some(name) = args.value_of("NAME") {
|
||||
group.group = name.to_string();
|
||||
}
|
||||
}
|
||||
|
||||
sys_groups.save().unwrap_or_exit(1);
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user