Get pcid to work using this pthread impl.

.gitignore

···
 *.patch
 *.swp
 *.swo
+/.vim

Cargo.lock

···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
- "hermit-abi",
+ "hermit-abi 0.1.19",
  "libc",
  "winapi",
 ]
···
  "heck",
  "indexmap",
  "log",
- "proc-macro2 1.0.51",
- "quote 1.0.23",
+ "proc-macro2 1.0.56",
+ "quote 1.0.26",
  "serde",
  "serde_json",
  "syn 1.0.109",
···
 
 [[package]]
 name = "errno"
-version = "0.2.8"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
+checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a"
 dependencies = [
  "errno-dragonfly",
  "libc",
- "winapi",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "hermit-abi"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286"
+
+[[package]]
 name = "indexmap"
-version = "1.9.2"
+version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
 dependencies = [
  "autocfg",
  "hashbrown",
···
 
 [[package]]
 name = "io-lifetimes"
-version = "1.0.6"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfa919a82ea574332e2de6e74b4c36e74d41982b335080fa59d4ef31be20fdf3"
+checksum = "9c66c74d2ae7e79a5a8f7ac924adbe38ee42a859c6539ad869eb51f0b52dc220"
 dependencies = [
+ "hermit-abi 0.3.1",
  "libc",
- "windows-sys 0.45.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "libc"
-version = "0.2.140"
+version = "0.2.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99227334921fae1a979cf0bfdfcc6b3e5ce376ef57e16fb6fb3ea2ed6095f80c"
+checksum = "3304a64d199bb964be99741b7a14d26972741915b3649639149b2479bb46f4b5"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.1.4"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
+checksum = "d59d8c75012853d2e872fb56bc8a2e53718e2cafe1a4c823143141c6d90c322f"
 
 [[package]]
 name = "lock_api"
···
 
 [[package]]
 name = "os_str_bytes"
-version = "6.4.1"
+version = "6.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"
+checksum = "ceedf44fb00f2d1984b0bc98102627ce622e083e49a5bacdb3e514fa4238e267"
 
 [[package]]
 name = "plain"
···
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.51"
+version = "1.0.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d727cae5b39d21da60fa540906919ad737832fe0b1c165da3a34d6548c849d6"
+checksum = "2b63bdb0cd06f1f4dedf69b254734f9b45af66e4a031e42a7480257d9898b435"
 dependencies = [
  "unicode-ident",
 ]
···
 
 [[package]]
 name = "quote"
-version = "1.0.23"
+version = "1.0.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
+checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc"
 dependencies = [
- "proc-macro2 1.0.51",
+ "proc-macro2 1.0.56",
 ]
 
 [[package]]
···
 dependencies = [
  "goblin",
  "plain",
- "redox_syscall 0.3.4",
+ "redox_syscall 0.3.5",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "redox_syscall"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.3.4"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb02a9aee8e8c7ad8d86890f1e16b49e0bbbffc9961ff3788c31d57c98bcbf03"
+checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
 dependencies = [
  "bitflags",
 ]
···
 name = "relibc"
 version = "0.2.5"
 dependencies = [
+ "bitflags",
  "cbindgen",
  "cbitset",
  "cc",
···
  "ralloc",
  "rand",
  "redox-exec",
- "redox_syscall 0.3.4",
+ "redox_syscall 0.3.5",
  "sc",
- "spin 0.9.5",
+ "spin 0.9.8",
  "unicode-width",
 ]
 
···
 
 [[package]]
 name = "rustix"
-version = "0.36.9"
+version = "0.37.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd5c6ff11fecd55b40746d1995a02f2eb375bf8c00d192d521ee09f42bef37bc"
+checksum = "85597d61f83914ddeba6a47b3b8ffe7365107221c2e557ed94426489fefb5f77"
 dependencies = [
  "bitflags",
  "errno",
  "io-lifetimes",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.45.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "serde"
-version = "1.0.154"
+version = "1.0.160"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cdd151213925e7f1ab45a9bbfb129316bd00799784b174b7cc7bcd16961c49e"
+checksum = "bb2f3770c8bce3bcda7e149193a069a0f4365bda1fa5cd88e03bca26afc1216c"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.154"
+version = "1.0.160"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fc80d722935453bcafdc2c9a73cd6fac4dc1938f0346035d84bf99fa9e33217"
+checksum = "291a097c63d8497e00160b166a967a4a79c64f3facdd01cbd7502231688d77df"
 dependencies = [
- "proc-macro2 1.0.51",
- "quote 1.0.23",
- "syn 1.0.109",
+ "proc-macro2 1.0.56",
+ "quote 1.0.26",
+ "syn 2.0.15",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.94"
+version = "1.0.96"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c533a59c9d8a93a09c6ab31f0fd5e5f4dd1b8fc9434804029839884765d04ea"
+checksum = "057d394a50403bcac12672b2b18fb387ab6d289d957dab67dd201875391e52f1"
 dependencies = [
  "itoa",
  "ryu",
···
 
 [[package]]
 name = "spin"
-version = "0.9.5"
+version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dccf47db1b41fa1573ed27ccf5e08e3ca771cb994f776668c5ebda893b248fc"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
 dependencies = [
  "lock_api",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
 dependencies = [
- "proc-macro2 1.0.51",
- "quote 1.0.23",
+ "proc-macro2 1.0.56",
+ "quote 1.0.26",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a34fcf3e8b60f57e6a14301a2e916d323af98b0ea63c599441eec8558660c822"
+dependencies = [
+ "proc-macro2 1.0.56",
+ "quote 1.0.26",
  "unicode-ident",
 ]
 
 [[package]]
 name = "tempfile"
-version = "3.4.0"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af18f7ae1acd354b992402e9ec5864359d693cd8a79dcbef59f76891701c1e95"
+checksum = "b9fbec84f381d5795b08656e4912bec604d162bff9291d6189a78f4c8ab87998"
 dependencies = [
  "cfg-if",
  "fastrand",
- "redox_syscall 0.2.16",
+ "redox_syscall 0.3.5",
  "rustix",
- "windows-sys 0.42.0",
+ "windows-sys 0.45.0",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "windows-sys"
-version = "0.42.0"
+version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows-targets 0.42.2",
 ]
 
 [[package]]
 name = "windows-sys"
-version = "0.45.0"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.0",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
 dependencies = [
- "windows-targets",
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
 ]
 
 [[package]]
 name = "windows-targets"
-version = "0.42.1"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e2522491fbfcd58cc84d47aeb2958948c4b8982e9a2d8a2a35bbaed431390e7"
+checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.48.0",
+ "windows_aarch64_msvc 0.48.0",
+ "windows_i686_gnu 0.48.0",
+ "windows_i686_msvc 0.48.0",
+ "windows_x86_64_gnu 0.48.0",
+ "windows_x86_64_gnullvm 0.48.0",
+ "windows_x86_64_msvc 0.48.0",
 ]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.42.1"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c9864e83243fdec7fc9c5444389dcbbfd258f745e7853198f365e3c4968a608"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.42.1"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8b1b673ffc16c47a9ff48570a9d85e25d265735c503681332589af6253c6c7"
+checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.42.1"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3887528ad530ba7bdbb1faa8275ec7a1155a45ffa57c37993960277145d640"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.42.1"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf4d1122317eddd6ff351aa852118a2418ad4214e6613a50e0191f7004372605"
+checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.42.1"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1040f221285e17ebccbc2591ffdc2d44ee1f9186324dd3e84e99ac68d699c45"
+checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.42.1"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "628bfdf232daa22b0d64fdb62b09fcc36bb01f05a3939e20ab73aaf9470d0463"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.42.1"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"
+checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"

Cargo.toml

···
 [build-dependencies]
 cbindgen = "0.24.3"
 cc = "1.0.25"
+#env_logger = "0.10"
 
 [dependencies]
+bitflags = "1"
 cbitset = "0.1.0"
 core_io = { path = "core_io", features = ["collections"] }
 lazy_static = { version = "1.4.0", default-features = false, features = ["spin_no_std"] }

src/header/bits_pthread/cbindgen.toml

···
+sys_includes = ["bits/sched.h"]
+include_guard = "_RELIBC_BITS_PTHREAD_H"
+language = "C"
+style = "type"
+no_includes = true
+cpp_compat = true
+trailer = """
+#define PTHREAD_COND_INITIALIZER {0}
+#define PTHREAD_MUTEX_INITIALIZER {0}
+#define PTHREAD_ONCE_INIT {0}
+#define PTHREAD_RWLOCK_INITIALIZER {0}
+"""
+
+[export.rename]
+"sched_param" = "struct sched_param"
+"AtomicInt" = "int"
+"AtomicUint" = "unsigned"
+
+[export]
+include = [
+  "pthread_attr_t",
+  "pthread_rwlockattr_t",
+  "pthread_rwlock_t",
+  "pthread_barrier_t",
+  "pthread_barrierattr_t",
+  "pthread_mutex_t",
+  "pthread_mutexattr_t",
+  "pthread_condattr_t",
+  "pthread_cond_t",
+  "pthread_spinlock_t",
+  "pthread_once_t",
+  "pthread_t",
+  "pthread_key_t",
+]
+
+[enum]
+prefix_with_name = true

src/header/bits_pthread/mod.rs

···
+#![allow(non_camel_case_types)]
+
+use crate::platform::types::*;
+
+use crate::header::sched::sched_param;
+
+use crate::sync::AtomicLock;
+use core::sync::atomic::{AtomicU32 as AtomicUint, AtomicI32 as AtomicInt};
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct pthread_attr_t {
+    pub detachstate: c_uchar,
+    pub inheritsched: c_uchar,
+    pub schedpolicy: c_uchar,
+    pub scope: c_uchar,
+    pub guardsize: size_t,
+    pub stacksize: size_t,
+    pub stack: size_t,
+    pub param: sched_param,
+}
+
+#[repr(C)]
+pub struct pthread_rwlockattr_t {
+    pub pshared: c_int,
+}
+
+#[repr(C)]
+pub struct pthread_rwlock_t {
+    pub state: AtomicInt,
+}
+
+#[repr(C)]
+pub struct pthread_barrier_t {
+    pub count: AtomicUint,
+    pub original_count: c_uint,
+    pub epoch: AtomicInt,
+}
+
+#[repr(C)]
+pub struct pthread_barrierattr_t {
+    pub pshared: c_int,
+}
+
+#[repr(C)]
+pub struct pthread_mutex_t {
+    pub inner: AtomicInt,
+}
+
+#[repr(C)]
+pub struct pthread_mutexattr_t {
+    pub prioceiling: c_int,
+    pub protocol: c_int,
+    pub pshared: c_int,
+    pub robust: c_int,
+    pub ty: c_int,
+}
+
+#[repr(C)]
+pub struct pthread_condattr_t {
+    pub clock: clockid_t,
+    pub pshared: c_int,
+}
+
+#[repr(C)]
+pub struct pthread_cond_t {
+    pub cur: AtomicInt,
+    pub prev: AtomicInt,
+}
+#[repr(C)]
+pub struct pthread_spinlock_t {
+    pub inner: AtomicInt,
+}
+
+#[repr(C)]
+pub struct pthread_once_t {
+    pub inner: AtomicInt,
+}
+
+pub type pthread_t = *mut ();
+pub type pthread_key_t = c_ulong;

src/header/bits_sched/cbindgen.toml

···
+sys_includes = []
+include_guard = "_RELIBC_BITS_SCHED_H"
+language = "C"
+style = "tag"
+no_includes = true
+cpp_compat = true
+
+[export]
+include = [
+  "sched_param",
+]

src/header/bits_sched/mod.rs

···
+#![allow(non_camel_case_types)]
+
+use crate::platform::types::*;
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub struct sched_param {
+    pub sched_priority: c_int,
+}

src/header/mod.rs

···
 pub mod _fenv;
 pub mod arpa_inet;
 pub mod assert;
+pub mod bits_pthread;
+pub mod bits_sched;
 pub mod ctype;
 pub mod dirent;
 #[path = "dl-tls/mod.rs"]

src/header/netdb/dns/mod.rs

···
 
 impl n16 {
     pub fn as_bytes(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts((&self.inner as *const u16) as *const u8, 2) }
+        unsafe { slice::from_raw_parts(core::ptr::addr_of!(self.inner).cast::<u8>(), 2) }
     }
 
     pub fn from_bytes(bytes: &[u8]) -> Self {

src/header/pthread/attr.rs

···
 use super::*;
 
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct Attr {
-    pub detachstate: u8,
-    pub inheritsched: u8,
-    pub schedpolicy: u8,
-    pub scope: u8,
-    pub guardsize: usize,
-    pub stacksize: usize,
-    pub stack: usize,
-    pub param: sched_param,
-}
-impl Default for Attr {
+use crate::header::bits_pthread::pthread_attr_t;
+
+impl Default for pthread_attr_t {
     fn default() -> Self {
         Self {
             // Default according to POSIX.
···
 
 #[no_mangle]
 pub unsafe extern "C" fn pthread_attr_init(attr: *mut pthread_attr_t) -> c_int {
-    core::ptr::write(attr, Attr::default());
+    core::ptr::write(attr, pthread_attr_t::default());
     0
 }
 

src/header/pthread/barrier.rs

···
 use crate::header::errno::*;
 
-use crate::sync::AtomicLock;
-use core::sync::atomic::{AtomicU32, Ordering};
+use core::sync::atomic::{AtomicU32, AtomicI32 as AtomicInt, Ordering};
 
 use super::*;
 
-#[repr(C)]
-pub struct Barrier {
-    count: AtomicU32,
-    original_count: u32,
-    epoch: AtomicLock,
-}
-
-#[repr(C)]
-pub struct BarrierAttr {
-    pshared: c_int,
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn pthread_barrier_destroy(barrier: *mut pthread_barrier_t) -> c_int {
     // Behavior is undefined if any thread is currently waiting.
···
         return EINVAL;
     }
 
-    core::ptr::write(barrier, Barrier {
+    core::ptr::write(barrier, pthread_barrier_t {
         count: AtomicU32::new(0),
         original_count: count,
-        epoch: AtomicLock::new(0),
+        epoch: AtomicInt::new(0),
     });
     0
 }
···
 #[no_mangle]
 pub unsafe extern "C" fn pthread_barrierattr_init(attr: *mut pthread_barrierattr_t) -> c_int {
     // PTHREAD_PROCESS_PRIVATE is default according to POSIX.
-    core::ptr::write(attr, BarrierAttr { pshared: PTHREAD_PROCESS_PRIVATE });
+    core::ptr::write(attr, pthread_barrierattr_t { pshared: PTHREAD_PROCESS_PRIVATE });
 
     0
 }

src/header/pthread/cbindgen.toml

···
-sys_includes = ["sched.h", "time.h"]
+sys_includes = ["sched.h", "time.h", "bits/pthread.h"]
 include_guard = "_RELIBC_PTHREAD_H"
 language = "C"
-style = "Tag"
+style = "tag"
 no_includes = true
 cpp_compat = true
+
+[export.rename]
+"sched_param" = "struct sched_param"
+"timespec" = "struct timespec"
 
 [enum]
 prefix_with_name = true

src/header/pthread/cond.rs

···
 
 // PTHREAD_COND_INITIALIZER
 
-#[repr(C)]
-pub struct CondAttr {
-    clock: clockid_t,
-    pshared: c_int,
-}
-
-#[repr(C)]
-pub struct Cond {
-    cur: AtomicInt,
-    prev: AtomicInt,
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn pthread_cond_broadcast(cond: *mut pthread_cond_t) -> c_int {
     wake(cond, i32::MAX)
···
 
 #[no_mangle]
 pub unsafe extern "C" fn pthread_cond_init(cond: *mut pthread_cond_t, _attr: *const pthread_condattr_t) -> c_int {
-    cond.write(Cond {
+    cond.write(pthread_cond_t {
         cur: AtomicInt::new(0),
         prev: AtomicInt::new(0),
     });
···
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn pthread_cond_timedwait(cond: *mut pthread_cond_t, mutex_ptr: *const pthread_mutex_t, timeout: *const timespec) -> c_int {
+pub unsafe extern "C" fn pthread_cond_timedwait(cond: *mut pthread_cond_t, mutex_ptr: *mut pthread_mutex_t, timeout: *const timespec) -> c_int {
     // TODO: Error checking for certain types (i.e. robust and errorcheck) of mutexes, e.g. if the
     // mutex is not locked.
     let cond: &pthread_cond_t = &*cond;
-    let mutex: &pthread_mutex_t = &*mutex_ptr;
     let timeout: Option<&timespec> = timeout.as_ref();
 
     let current = cond.cur.load(Ordering::Relaxed);
     cond.prev.store(current, Ordering::SeqCst);
 
-    mutex.inner.manual_unlock();
+    pthread_mutex_unlock(mutex_ptr);
     crate::sync::futex_wait(&cond.cur, current, timeout);
-    mutex.inner.manual_lock();
+    pthread_mutex_lock(mutex_ptr);
 
     0
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn pthread_cond_wait(cond: *mut pthread_cond_t, mutex: *const pthread_mutex_t) -> c_int {
+pub unsafe extern "C" fn pthread_cond_wait(cond: *mut pthread_cond_t, mutex: *mut pthread_mutex_t) -> c_int {
     pthread_cond_timedwait(cond, mutex, core::ptr::null())
 }
 
···
 
 #[no_mangle]
 pub unsafe extern "C" fn pthread_condattr_init(condattr: *mut pthread_condattr_t) -> c_int {
-    core::ptr::write(condattr, CondAttr {
+    core::ptr::write(condattr, pthread_condattr_t {
         // FIXME: system clock
         clock: 0,
         // Default

src/header/pthread/mod.rs

···
 pub mod rwlock;
 pub use self::rwlock::*;
 
+#[no_mangle]
 pub unsafe extern "C" fn pthread_self() -> pthread_t {
     pthread::current_thread().unwrap_unchecked() as *const _ as *mut _
 }

src/header/pthread/mutex.rs

···
 
 // PTHREAD_MUTEX_INITIALIZER
 
-#[repr(C)]
-pub struct Mutex {
-    pub(crate) inner: crate::sync::Mutex<()>,
-}
-
-#[repr(C)]
-pub struct MutexAttr {
-    prioceiling: c_int,
-    protocol: c_int,
-    pshared: c_int,
-    robust: c_int,
-    ty: c_int,
-}
-
 // #[no_mangle]
 pub extern "C" fn pthread_mutex_consistent(mutex: *mut pthread_mutex_t) -> c_int {
     todo!();
···
 #[no_mangle]
 pub unsafe extern "C" fn pthread_mutex_init(mutex: *mut pthread_mutex_t, _attr: *const pthread_mutexattr_t) -> c_int {
     // TODO: attr
-    mutex.write(Mutex {
-        inner: crate::sync::Mutex::new(()),
+    mutex.write(pthread_mutex_t {
+        inner: crate::sync::mutex::UNLOCKED.into(),
     });
     0
 }
 #[no_mangle]
 pub unsafe extern "C" fn pthread_mutex_lock(mutex: *mut pthread_mutex_t) -> c_int {
-    (&*mutex).inner.manual_lock();
+    crate::sync::mutex::manual_lock_generic(&(&*mutex).inner);
 
     0
 }
···
 }
 #[no_mangle]
 pub unsafe extern "C" fn pthread_mutex_trylock(mutex: *mut pthread_mutex_t) -> c_int {
-    match (&*mutex).inner.manual_try_lock() {
-        Ok(_) => 0,
-        Err(_) => EBUSY,
+    if crate::sync::mutex::manual_try_lock_generic(&(&*mutex).inner) {
+        0
+    } else {
+        EBUSY
     }
 }
 #[no_mangle]
 pub unsafe extern "C" fn pthread_mutex_unlock(mutex: *mut pthread_mutex_t) -> c_int {
-    (&*mutex).inner.manual_unlock();
+    crate::sync::mutex::manual_unlock_generic(&(&*mutex).inner);
     0
 }
 
···
 }
 #[no_mangle]
 pub unsafe extern "C" fn pthread_mutexattr_init(attr: *mut pthread_mutexattr_t) -> c_int {
-    attr.write(MutexAttr {
+    attr.write(pthread_mutexattr_t {
         robust: PTHREAD_MUTEX_STALLED,
         pshared: PTHREAD_PROCESS_PRIVATE,
         protocol: PTHREAD_PRIO_NONE,

src/header/pthread/once.rs

···
 use super::*;
 
-#[repr(C)]
-pub struct Once {
-    inner: crate::sync::Once<()>,
-}
-
 // PTHREAD_ONCE_INIT
 
 #[no_mangle]
···
     let once: &pthread_once_t = &*once;
 
     // TODO: Cancellation points
-    once.inner.call_once(|| constructor());
+    crate::sync::once::call_once_generic(&once.inner, || constructor());
 
     0
 }

src/header/pthread/rwlock.rs

···
 use super::*;
 
-use crate::sync::AtomicLock;
-use core::sync::atomic::Ordering;
+use core::sync::atomic::{AtomicI32 as AtomicInt, Ordering};
 
 use crate::header::errno::EBUSY;
 
···
 // Separate "waiting for wrlocks" and "waiting for rdlocks"?
 //const WAITING: u32 = 1 << (u32::BITS - 1);
 
-#[repr(C)]
-pub struct Rwlock {
-    state: AtomicLock,
-}
-
-#[repr(C)]
-pub struct RwlockAttr {
-    pshared: c_int,
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn pthread_rwlock_destroy(rwlock: *mut pthread_rwlock_t) -> c_int {
     // (Informing the compiler that this pointer is valid, might improve optimizations.)
···
 }
 #[no_mangle]
 pub unsafe extern "C" fn pthread_rwlock_init(rwlock: *mut pthread_rwlock_t, _attr: *const pthread_rwlockattr_t) -> c_int {
-    core::ptr::write(rwlock, Rwlock {
-        state: AtomicLock::new(0),
+    core::ptr::write(rwlock, pthread_rwlock_t {
+        state: AtomicInt::new(0),
     });
 
     0
···
 
     loop {
         if pthread_rwlock_tryrdlock(rwlock as *const _ as *mut _) == EBUSY {
-            rwlock.state.wait_if(EXCLUSIVE as i32, timeout);
+            crate::sync::futex_wait(&rwlock.state, EXCLUSIVE as i32, timeout);
         }
         return 0;
     }
···
     let rwlock: &pthread_rwlock_t = &*rwlock;
     let timeout = timeout.as_ref();
 
-    loop {
+    /*loop {
         if pthread_rwlock_trywrlock(rwlock as *const _ as *mut _) == EBUSY {
-            rwlock.state.wait_if(EXCLUSIVE as i32, timeout);
+            crate::sync::futex_wait(&rwlock.state, EXCLUSIVE as i32, timeout);
         }
         return 0;
+    }*/
+    loop {
+        match rwlock.state.compare_exchange(0, EXCLUSIVE as i32, Ordering::Acquire, Ordering::Relaxed) {
+            Ok(_) => return 0,
+            Err(value) => {
+                // TODO: More than just forwarding the timeout.
+                crate::sync::futex_wait(&rwlock.state, value, timeout);
+            }
+        }
     }
 }
 #[no_mangle]
···
     let old = rwlock.state.swap(0, Ordering::Release) as u32;
 
     if old == EXCLUSIVE {
-        rwlock.state.notify_all();
+        crate::sync::futex_wake(&rwlock.state, i32::MAX);
     }
 
     0
···
 
 #[no_mangle]
 pub unsafe extern "C" fn pthread_rwlockattr_init(attr: *mut pthread_rwlockattr_t) -> c_int {
-    core::ptr::write(attr, RwlockAttr {
+    core::ptr::write(attr, pthread_rwlockattr_t {
         // Default according to POSIX.
         pshared: PTHREAD_PROCESS_PRIVATE,
     });

src/header/pthread/spin.rs

···
 
 use super::*;
 
-#[repr(C)]
-pub struct Spinlock {
-    inner: AtomicInt,
-}
-
 pub const UNLOCKED: c_int = 0;
 pub const LOCKED: c_int = 1;
 
···
     // TODO: pshared doesn't matter in most situations, as memory is just memory, but this may be
     // different on some architectures...
 
-    core::ptr::write(spinlock, Spinlock { inner: AtomicInt::new(UNLOCKED) });
+    core::ptr::write(spinlock, pthread_spinlock_t { inner: AtomicInt::new(UNLOCKED) });
 
     0
 }
 pub unsafe extern "C" fn pthread_spin_lock(spinlock: *mut pthread_spinlock_t) -> c_int {
-    let spinlock: &Spinlock = &*spinlock;
+    let spinlock: &pthread_spinlock_t = &*spinlock;
 
     loop {
         match spinlock.inner.compare_exchange_weak(UNLOCKED, LOCKED, Ordering::Acquire, Ordering::Relaxed) {
···
     }
 }
 pub unsafe extern "C" fn pthread_spin_trylock(spinlock: *mut pthread_spinlock_t) -> c_int {
-    let spinlock: &Spinlock = &*spinlock;
+    let spinlock: &pthread_spinlock_t = &*spinlock;
 
     match spinlock.inner.compare_exchange(UNLOCKED, LOCKED, Ordering::Acquire, Ordering::Relaxed) {
         Ok(_) => 0,
···
     }
 }
 pub unsafe extern "C" fn pthread_spin_unlock(spinlock: *mut pthread_spinlock_t) -> c_int {
-    let spinlock: &Spinlock = &*spinlock;
+    let spinlock: &pthread_spinlock_t = &*spinlock;
 
     spinlock.inner.store(UNLOCKED, Ordering::Release);
 

src/header/pthread/tls.rs

···
 use core::cell::{Cell, RefCell};
 
 use crate::header::errno::EINVAL;
+use crate::sync::Mutex;
 
 // TODO: What should this limit be?
 pub const PTHREAD_KEYS_MAX: u32 = 4096 * 32;
 
 #[no_mangle]
 pub unsafe extern "C" fn pthread_getspecific(key: pthread_key_t) -> *mut c_void {
-    let Some(&Record { data, .. }) = DICT.borrow_mut().get(&key) else {
+    //print!("pthread_getspecific key={:#0x}: ", key);
+
+    // TODO: Right?
+    if !KEYS.lock().contains_key(&key) {
+        //println!("= not found");
+        return core::ptr::null_mut();
+    }
+
+    let Some(&Record { data, .. }) = VALUES.borrow_mut().get(&key) else {
+        //println!("= NULL");
         return core::ptr::null_mut();
     };
+    //println!("= {:p}", data);
 
     data
 }
···
 pub unsafe extern "C" fn pthread_key_create(key_ptr: *mut pthread_key_t, destructor: extern "C" fn(value: *mut c_void)) -> c_int {
     let key = NEXTKEY.get();
     NEXTKEY.set(key + 1);
+    //println!("pthread_key_create new key {:#0x}, dtor {:p}", key, destructor);
 
     // TODO
     //if key >= PTHREAD_KEYS_MAX {
     //}
 
-    DICT.borrow_mut().insert(key, Record {
+    KEYS.lock().insert(key, Dtor { destructor });
+
+    VALUES.borrow_mut().insert(key, Record {
         data: core::ptr::null_mut(),
-        destructor,
     });
 
     key_ptr.write(key);
···
 
 #[no_mangle]
 pub unsafe extern "C" fn pthread_key_delete(key: pthread_key_t) -> c_int {
-    if DICT.borrow_mut().remove(&key).is_none() {
+    if KEYS.lock().remove(&key).is_none() || VALUES.borrow_mut().remove(&key).is_none() {
         // We don't have to return anything, but it's not less expensive to ignore it.
         return EINVAL;
     }
+    //println!("pthread_key_delete {:#0x}", key);
 
     0
 }
 
  #[no_mangle]
 pub unsafe extern "C" fn pthread_setspecific(key: pthread_key_t, value: *const c_void) -> c_int {
-    let mut guard = DICT.borrow_mut();
-
-    let Some(Record { data, .. }) = guard.get_mut(&key) else {
+    if !KEYS.lock().contains_key(&key) {
         // We don't have to return anything, but it's not less expensive to ignore it.
+        //println!("Invalid key for pthread_setspecific key {:#0x} value {:p}", key, value);
         return EINVAL;
-    };
+    }
+
+    let mut guard = VALUES.borrow_mut();
+
+    let Record { ref mut data, .. } = guard.entry(key).or_insert(Record { data: core::ptr::null_mut() });
+    //println!("Valid key for pthread_setspecific key {:#0x} value {:p} (was {:p})", key, value, *data);
 
     *data = value as *mut c_void;
 
     0
 }
 
+static KEYS: Mutex<BTreeMap<pthread_key_t, Dtor>> = Mutex::new(BTreeMap::new());
+
+struct Dtor {
+    destructor: extern "C" fn(value: *mut c_void)
+}
+
 #[thread_local]
-static DICT: RefCell<BTreeMap<u32, Record>> = RefCell::new(BTreeMap::new());
+static VALUES: RefCell<BTreeMap<pthread_key_t, Record>> = RefCell::new(BTreeMap::new());
 
 struct Record {
     data: *mut c_void,
-    destructor: extern "C" fn(value: *mut c_void),
 }
 
 #[thread_local]
-static NEXTKEY: Cell<u32> = Cell::new(1);
+static NEXTKEY: Cell<pthread_key_t> = Cell::new(1);

src/header/sched/cbindgen.toml

···
-sys_includes = ["time.h"]
+sys_includes = ["time.h", "bits/sched.h"]
 include_guard = "_RELIBC_SCHED_H"
 language = "C"
 style = "Tag"

src/header/sched/mod.rs

···
 use crate::platform::{Pal, Sys, types::*};
 use crate::header::time::timespec;
 
-#[repr(C)]
-#[derive(Clone, Copy, Debug)]
-pub struct sched_param {
-    pub sched_priority: c_int,
-}
+pub use crate::header::bits_sched::sched_param;
 
 pub const SCHED_FIFO: c_int = 0;
 pub const SCHED_RR: c_int = 1;

src/header/stdlib/mod.rs

···
         static __fini_array_start: extern "C" fn();
         static __fini_array_end: extern "C" fn();
 
-        fn pthread_terminate();
         fn _fini();
     }
 
···
 
     ld_so::fini();
 
-    pthread_terminate();
+    crate::pthread::terminate_from_main_thread();
 
     flush_io_streams();
 

src/header/sys_types/cbindgen.toml

···
     "sys/types_internal.h",
 
     "stddef.h",
-    "sys/select.h"
+    "sys/select.h",
+    "bits/pthread.h",
 ]
 
 include_guard = "_SYS_TYPES_H"

src/platform/redox/clone.rs

···
 pub use redox_exec::*;
 
 /// Spawns a new context sharing the same address space as the current one (i.e. a new thread).
-pub unsafe fn pte_clone_impl(stack: *mut usize) -> Result<usize> {
+pub unsafe fn rlct_clone_impl(stack: *mut usize) -> Result<usize> {
     let cur_pid_fd = FdGuard::new(syscall::open("thisproc:current/open_via_dup", O_CLOEXEC)?);
     let (new_pid_fd, new_pid) = new_context()?;
 
···
 
         let buf = create_set_addr_space_buf(
             *cur_addr_space_fd,
-            __relibc_internal_pte_clone_ret as usize,
+            __relibc_internal_rlct_clone_ret as usize,
             stack as usize,
         );
         let _ = syscall::write(*new_addr_space_sel_fd, &buf)?;
···
 }
 
 extern "C" {
-    fn __relibc_internal_pte_clone_ret();
+    fn __relibc_internal_rlct_clone_ret();
 }
 
 #[cfg(target_arch = "aarch64")]
 core::arch::global_asm!(
     "
-    .globl __relibc_internal_pte_clone_ret
-    .type __relibc_internal_pte_clone_ret, @function
+    .globl __relibc_internal_rlct_clone_ret
+    .type __relibc_internal_rlct_clone_ret, @function
     .p2align 6
-__relibc_internal_pte_clone_ret:
+__relibc_internal_rlct_clone_ret:
     # Load registers
     ldr x8, [sp], #8
     ldr x0, [sp], #8
···
     blr x8
 
     ret
-    .size __relibc_internal_pte_clone_ret, . - __relibc_internal_pte_clone_ret
+    .size __relibc_internal_rlct_clone_ret, . - __relibc_internal_rlct_clone_ret
 "
 );
 
 #[cfg(target_arch = "x86")]
 core::arch::global_asm!(
     "
-    .globl __relibc_internal_pte_clone_ret
-    .type __relibc_internal_pte_clone_ret, @function
+    .globl __relibc_internal_rlct_clone_ret
+    .type __relibc_internal_rlct_clone_ret, @function
     .p2align 6
-__relibc_internal_pte_clone_ret:
+__relibc_internal_rlct_clone_ret:
     # Load registers
     pop eax
 
···
     call eax
 
     ret
-    .size __relibc_internal_pte_clone_ret, . - __relibc_internal_pte_clone_ret
+    .size __relibc_internal_rlct_clone_ret, . - __relibc_internal_rlct_clone_ret
 "
 );
 
 #[cfg(target_arch = "x86_64")]
 core::arch::global_asm!(
     "
-    .globl __relibc_internal_pte_clone_ret
-    .type __relibc_internal_pte_clone_ret, @function
+    .globl __relibc_internal_rlct_clone_ret
+    .type __relibc_internal_rlct_clone_ret, @function
     .p2align 6
-__relibc_internal_pte_clone_ret:
+__relibc_internal_rlct_clone_ret:
     # Load registers
     pop rax
     pop rdi
···
     call rax
 
     ret
-    .size __relibc_internal_pte_clone_ret, . - __relibc_internal_pte_clone_ret
+    .size __relibc_internal_rlct_clone_ret, . - __relibc_internal_rlct_clone_ret
 "
 );

src/platform/redox/mod.rs

···
     }
 
     unsafe fn rlct_clone(stack: *mut usize) -> Result<crate::pthread::OsTid, crate::pthread::Errno> {
-        clone::pte_clone_impl(stack).map(|context_id| crate::pthread::OsTid { context_id }).map_err(|error| crate::pthread::Errno(error.errno))
+        clone::rlct_clone_impl(stack).map(|context_id| crate::pthread::OsTid { context_id }).map_err(|error| crate::pthread::Errno(error.errno))
     }
     unsafe fn rlct_kill(os_tid: crate::pthread::OsTid, signal: usize) -> Result<(), crate::pthread::Errno> {
         syscall::kill(os_tid.context_id, signal).map_err(|error| crate::pthread::Errno(error.errno))?;

src/platform/types.rs

···
 pub type clockid_t = c_int;
 pub type timer_t = *mut c_void;
 
-pub type pthread_attr_t = crate::header::pthread::attr::Attr;
-pub type pthread_barrier_t = crate::header::pthread::barrier::Barrier;
-pub type pthread_barrierattr_t = crate::header::pthread::barrier::BarrierAttr;
-pub type pthread_cond_t = crate::header::pthread::cond::Cond;
-pub type pthread_condattr_t = crate::header::pthread::cond::CondAttr;
-pub type pthread_key_t = u32;
-pub type pthread_mutex_t = crate::header::pthread::mutex::Mutex;
-pub type pthread_mutexattr_t = crate::header::pthread::mutex::MutexAttr;
-pub type pthread_once_t = crate::header::pthread::once::Once;
-pub type pthread_rwlock_t = crate::header::pthread::rwlock::Rwlock;
-pub type pthread_rwlockattr_t = crate::header::pthread::rwlock::RwlockAttr;
-pub type pthread_spinlock_t = crate::header::pthread::spin::Spinlock;
-pub type pthread_t = *mut c_void;
+pub use crate::header::bits_pthread::*;
+pub use crate::header::bits_sched::*;

src/pthread/mod.rs

···
 
 use core::cell::{Cell, UnsafeCell};
 use core::ptr::NonNull;
-use core::sync::atomic::{AtomicBool, Ordering};
+use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 
 use alloc::boxed::Box;
 use alloc::collections::BTreeMap;
···
 use crate::header::sched::sched_param;
 use crate::header::errno::*;
 use crate::header::sys_mman;
+use crate::header::pthread as header;
 use crate::ld_so::{linker::Linker, tcb::{Master, Tcb}};
 use crate::ALLOCATOR;
 
 use crate::sync::{Mutex, waitval::Waitval};
 
-#[no_mangle]
-extern "C" fn pthread_init() {
+const MAIN_PTHREAD_ID: usize = 1;
+
+/// Called only by the main thread, as part of relibc_start.
+pub unsafe fn init() {
+    let obj = Box::into_raw(Box::new(Pthread {
+        waitval: Waitval::new(),
+        wants_cancel: AtomicBool::new(false),
+        flags: PthreadFlags::empty().bits().into(),
+
+        // TODO
+        stack_base: core::ptr::null_mut(),
+        stack_size: 0,
+
+        os_tid: UnsafeCell::new(Sys::current_os_tid()),
+    }));
+
+    PTHREAD_SELF.set(obj);
+}
+pub unsafe fn terminate_from_main_thread() {
+    for (tid, pthread) in OS_TID_TO_PTHREAD.lock().iter() {
+        // TODO: Cancel?
+        Sys::rlct_kill(*tid, crate::header::signal::SIGTERM);
+    }
 }
-#[no_mangle]
-extern "C" fn pthread_terminate() {
+
+bitflags::bitflags! {
+    struct PthreadFlags: usize {
+        const DETACHED = 1;
+    }
 }
 
 pub struct Pthread {
     waitval: Waitval<Retval>,
     wants_cancel: AtomicBool,
+    flags: AtomicUsize,
 
     stack_base: *mut c_void,
     stack_size: usize,
···
 unsafe impl Send for Pthread {}
 unsafe impl Sync for Pthread {}
 
-use crate::header::pthread::attr::Attr;
+use crate::header::bits_pthread::pthread_attr_t;
 
 /// Positive error codes (EINVAL, not -EINVAL).
 #[derive(Debug, Eq, PartialEq)]
···
     // TODO: Custom stacks
     let stack_base = sys_mman::mmap(
         core::ptr::null_mut(),
-        attrs.stacksize,
+        stack_size,
         sys_mman::PROT_READ | sys_mman::PROT_WRITE,
         sys_mman::MAP_SHARED | sys_mman::MAP_ANONYMOUS,
         -1,
···
         return Err(Errno(EAGAIN));
     }
 
+    let mut flags = PthreadFlags::empty();
+    match i32::from(attrs.detachstate) {
+        header::PTHREAD_CREATE_DETACHED => flags |= PthreadFlags::DETACHED,
+        header::PTHREAD_CREATE_JOINABLE => (),
+
+        other => unreachable!("unknown detachstate {}", other),
+    }
+
     let pthread = Pthread {
         waitval: Waitval::new(),
+        flags: flags.bits().into(),
         wants_cancel: AtomicBool::new(false),
         stack_base,
         stack_size,
···
     let Ok(os_tid) = Sys::rlct_clone(stack) else {
         return Err(Errno(EAGAIN));
     };
+    core::mem::forget(stack_raii);
 
     let _ = (&*synchronization_mutex).lock();
 
     OS_TID_TO_PTHREAD.lock().insert(os_tid, ForceSendSync(ptr.cast()));
-
-    core::mem::forget(stack_raii);
 
     Ok(ptr.cast())
 }
···
     if core::ptr::eq(thread, current_thread().unwrap_unchecked()) {
         return Err(Errno(EDEADLK));
     }
+
     // Waitval starts locked, and is unlocked when the thread finishes.
     let retval = *thread.waitval.wait();
 
-    // TODO: Deinitialization code
+    // We have now awaited the thread and received its return value. POSIX states that the
+    // pthread_t of this thread, will no longer be valid. In practice, we can thus deallocate the
+    // thread state.
+
+    OS_TID_TO_PTHREAD.lock().remove(&thread.os_tid.get().read());
+
+    dealloc_thread(thread);
 
     Ok(retval)
 }
 
 pub unsafe fn detach(thread: &Pthread) -> Result<(), Errno> {
-    todo!()
+    thread.flags.fetch_or(PthreadFlags::DETACHED.bits(), Ordering::Release);
+    Ok(())
 }
 
 // Returns option because that's a no-op, but PTHREAD_SELF should always be initialized except in
···
 }
 
 pub unsafe fn exit_current_thread(retval: Retval) -> ! {
-    let this = current_thread().unwrap_unchecked();
-    this.waitval.post(retval);
+    let this = current_thread().expect("failed to obtain current thread when exiting");
+
+    if this.flags.load(Ordering::Acquire) & PthreadFlags::DETACHED.bits() != 0 {
+        // When detached, the thread state no longer makes any sense, and can immediately be
+        // deallocated.
+        dealloc_thread(this);
+    } else {
+        // When joinable, the return value should be made available to other threads.
+        this.waitval.post(retval);
+    }
 
     Sys::exit_thread()
 }
 
+// TODO: Use Arc? One strong reference from each OS_TID_TO_PTHREAD and one strong reference from
+// PTHREAD_SELF. The latter ref disappears when the thread exits, while the former disappears when
+// detaching. Isn't that sufficient?
+unsafe fn dealloc_thread(thread: &Pthread) {
+    drop(Box::from_raw(thread as *const Pthread as *mut Pthread));
+}
 pub const SIGRT_RLCT_CANCEL: usize = 32;
 pub const SIGRT_RLCT_TIMER: usize = 33;
 
+unsafe fn cancel_sighandler(_: c_int) {
+    // TODO: pthread_cleanup_push stack
+    // TODO: thread-specific data
+
+    // Terminate the thread
+    exit_current_thread(Retval(header::PTHREAD_CANCELED));
+}
+
 pub unsafe fn cancel(thread: &Pthread) -> Result<(), Errno> {
+    // TODO: Ordering
     thread.wants_cancel.store(true, Ordering::SeqCst);
+
     Sys::rlct_kill(thread.os_tid.get().read(), SIGRT_RLCT_CANCEL)?;
+
     todo!();
     Ok(())
 }
 
 // TODO: Hash map?
-static OS_TID_TO_PTHREAD: Mutex<BTreeMap<OsTid, ForceSendSync<pthread_t>>> = Mutex::new(BTreeMap::new());
+// TODO: RwLock
+static OS_TID_TO_PTHREAD: Mutex<BTreeMap<OsTid, ForceSendSync<*mut Pthread>>> = Mutex::new(BTreeMap::new());
 
+#[derive(Clone, Copy)]
 struct ForceSendSync<T>(T);
 unsafe impl<T> Send for ForceSendSync<T> {}
 unsafe impl<T> Sync for ForceSendSync<T> {}

src/start.rs

···
         }
     }
 
-    extern "C" {
-        fn pthread_init();
-    }
     unsafe {
-        pthread_init();
+        crate::pthread::init();
         init_complete = true
     }
 }

src/sync/mod.rs

···
     Sys::futex(ptr, FUTEX_WAIT, value, timeout_opt.map_or(0, |t| t as *const _ as usize)) == Ok(0)
 }
 pub fn futex_wake(atomic: &AtomicInt, n: i32) -> usize {
-    unsafe { futex_wake_ptr(atomic.as_mut_ptr(), n) }
+    unsafe { futex_wake_ptr(atomic.as_ptr(), n) }
 }
 pub fn futex_wait(atomic: &AtomicInt, value: i32, timeout_opt: Option<&timespec>) -> bool {
-    unsafe { futex_wait_ptr(atomic.as_mut_ptr(), value, timeout_opt) }
+    unsafe { futex_wait_ptr(atomic.as_ptr(), value, timeout_opt) }
+}
+pub fn wait_until_generic<F1, F2>(word: &AtomicInt, attempt: F1, mark_long: F2, long: c_int)
+where
+    F1: Fn(&AtomicInt) -> AttemptStatus,
+    F2: Fn(&AtomicInt) -> AttemptStatus,
+{
+    // First, try spinning for really short durations
+    for _ in 0..999 {
+        atomic::spin_loop_hint();
+        if attempt(word) == AttemptStatus::Desired {
+            return;
+        }
+    }
+
+    // One last attempt, to initiate "previous"
+    let mut previous = attempt(word);
+
+    // Ok, that seems to take quite some time. Let's go into a
+    // longer, more patient, wait.
+    loop {
+        if previous == AttemptStatus::Desired {
+            return;
+        }
+
+        if
+        // If we or somebody else already initiated a long
+        // wait, OR
+        previous == AttemptStatus::Waiting ||
+            // Otherwise, unless our attempt to initiate a long
+            // wait informed us that we might be done waiting
+            mark_long(word) != AttemptStatus::Desired
+        {
+            futex_wait(word, long, None);
+        }
+
+        previous = attempt(word);
+    }
 }
 
 /// Convenient wrapper around the "futex" system call for
···
         F1: Fn(&AtomicInt) -> AttemptStatus,
         F2: Fn(&AtomicInt) -> AttemptStatus,
     {
-        // First, try spinning for really short durations
-        for _ in 0..999 {
-            atomic::spin_loop_hint();
-            if attempt(self) == AttemptStatus::Desired {
-                return;
-            }
-        }
-
-        // One last attempt, to initiate "previous"
-        let mut previous = attempt(self);
-
-        // Ok, that seems to take quite some time. Let's go into a
-        // longer, more patient, wait.
-        loop {
-            if previous == AttemptStatus::Desired {
-                return;
-            }
-
-            if
-            // If we or somebody else already initiated a long
-            // wait, OR
-            previous == AttemptStatus::Waiting ||
-                // Otherwise, unless our attempt to initiate a long
-                // wait informed us that we might be done waiting
-                mark_long(self) != AttemptStatus::Desired
-            {
-                self.wait_if(long, None);
-            }
-
-            previous = attempt(self);
-        }
+        wait_until_generic(&self.atomic, attempt, mark_long, long)
     }
 }
 impl Deref for AtomicLock {

src/sync/mutex.rs

···
 use core::{
     cell::UnsafeCell,
     ops::{Deref, DerefMut},
-    sync::atomic::Ordering::SeqCst,
+    sync::atomic::{AtomicI32 as AtomicInt, Ordering},
 };
 
-const UNLOCKED: c_int = 0;
-const LOCKED: c_int = 1;
-const WAITING: c_int = 2;
+pub(crate) const UNLOCKED: c_int = 0;
+pub(crate) const LOCKED: c_int = 1;
+pub(crate) const WAITING: c_int = 2;
 
 pub struct Mutex<T> {
     pub(crate) lock: AtomicLock,
···
 }
 unsafe impl<T: Send> Send for Mutex<T> {}
 unsafe impl<T: Send> Sync for Mutex<T> {}
+
+pub(crate) unsafe fn manual_try_lock_generic(word: &AtomicInt) -> bool {
+    word.compare_exchange(UNLOCKED, LOCKED, Ordering::Acquire, Ordering::Relaxed).is_ok()
+}
+pub(crate) unsafe fn manual_lock_generic(word: &AtomicInt) {
+    crate::sync::wait_until_generic(
+        word,
+        |lock| {
+            lock.compare_exchange_weak(UNLOCKED, LOCKED, Ordering::Acquire, Ordering::Relaxed)
+                .map(|_| AttemptStatus::Desired)
+                .unwrap_or_else(|e| match e {
+                    WAITING => AttemptStatus::Waiting,
+                    _ => AttemptStatus::Other,
+                })
+        },
+        |lock| match lock
+        // TODO: Ordering
+            .compare_exchange_weak(LOCKED, WAITING, Ordering::SeqCst, Ordering::SeqCst)
+            .unwrap_or_else(|e| e)
+        {
+            UNLOCKED => AttemptStatus::Desired,
+            WAITING => AttemptStatus::Waiting,
+            _ => AttemptStatus::Other,
+        },
+        WAITING,
+    );
+}
+pub(crate) unsafe fn manual_unlock_generic(word: &AtomicInt) {
+    if word.swap(UNLOCKED, Ordering::Release) == WAITING {
+        crate::sync::futex_wake(word, 1);
+    }
+}
+
 impl<T> Mutex<T> {
     /// Create a new mutex
     pub const fn new(content: T) -> Self {
···
     /// on failure. You should probably not worry about this, it's used for
     /// internal optimizations.
     pub unsafe fn manual_try_lock(&self) -> Result<&mut T, c_int> {
-        self.lock
-            .compare_exchange(UNLOCKED, LOCKED, SeqCst, SeqCst)
-            .map(|_| &mut *self.content.get())
+        if manual_try_lock_generic(&self.lock) {
+            Ok(&mut *self.content.get())
+        } else {
+            Err(0)
+        }
     }
     /// Lock the mutex, returning the inner content. After doing this, it's
     /// your responsibility to unlock it after usage. Mostly useful for FFI:
     /// Prefer normal .lock() where possible.
     pub unsafe fn manual_lock(&self) -> &mut T {
-        self.lock.wait_until(
-            |lock| {
-                lock.compare_exchange_weak(UNLOCKED, LOCKED, SeqCst, SeqCst)
-                    .map(|_| AttemptStatus::Desired)
-                    .unwrap_or_else(|e| match e {
-                        WAITING => AttemptStatus::Waiting,
-                        _ => AttemptStatus::Other,
-                    })
-            },
-            |lock| match lock
-                .compare_exchange_weak(LOCKED, WAITING, SeqCst, SeqCst)
-                .unwrap_or_else(|e| e)
-            {
-                UNLOCKED => AttemptStatus::Desired,
-                WAITING => AttemptStatus::Waiting,
-                _ => AttemptStatus::Other,
-            },
-            WAITING,
-        );
+        manual_lock_generic(&self.lock);
         &mut *self.content.get()
     }
     /// Unlock the mutex, if it's locked.
     pub unsafe fn manual_unlock(&self) {
-        if self.lock.swap(UNLOCKED, SeqCst) == WAITING {
-            self.lock.notify_one();
-        }
+        manual_unlock_generic(&self.lock)
     }
 
     /// Tries to lock the mutex and returns a guard that automatically unlocks

src/sync/once.rs

···
 use super::{AtomicLock, AttemptStatus};
 use crate::platform::types::*;
-use core::{cell::UnsafeCell, mem::MaybeUninit, sync::atomic::Ordering::SeqCst};
+use core::{cell::UnsafeCell, mem::MaybeUninit};
+use core::sync::atomic::{AtomicI32 as AtomicInt, Ordering::SeqCst};
 
 const UNINITIALIZED: c_int = 0;
 const INITIALIZING: c_int = 1;
 const WAITING: c_int = 2;
 const INITIALIZED: c_int = 3;
 
+pub(crate) fn call_once_generic(word: &AtomicInt, f: impl FnOnce()) {
+    match word.compare_and_swap(UNINITIALIZED, INITIALIZING, SeqCst) {
+        UNINITIALIZED => {
+            // We now have a lock, let's initiate things!
+
+            // Mark the data as initialized
+            if word.swap(INITIALIZED, SeqCst) == WAITING {
+                // At least one thread is waiting on this to finish
+                crate::sync::futex_wake(word, i32::MAX);
+            }
+        }
+        INITIALIZING | WAITING => crate::sync::wait_until_generic(
+            word,
+            |lock| match lock.load(SeqCst) {
+                WAITING => AttemptStatus::Waiting,
+                INITIALIZED => AttemptStatus::Desired,
+                _ => AttemptStatus::Other,
+            },
+            |lock| match lock
+                .compare_exchange_weak(INITIALIZING, WAITING, SeqCst, SeqCst)
+                .unwrap_or_else(|e| e)
+            {
+                WAITING => AttemptStatus::Waiting,
+                INITIALIZED => AttemptStatus::Desired,
+                _ => AttemptStatus::Other,
+            },
+            WAITING,
+        ),
+        INITIALIZED => (),
+        _ => unreachable!("invalid state for Once<T>"),
+    }
+
+}
+
 pub struct Once<T> {
-    status: AtomicLock,
+    status: AtomicInt,
     data: UnsafeCell<MaybeUninit<T>>,
 }
 unsafe impl<T: Send> Send for Once<T> {}
···
 impl<T> Once<T> {
     pub const fn new() -> Self {
         Self {
-            status: AtomicLock::new(UNINITIALIZED),
+            status: AtomicInt::new(UNINITIALIZED),
             data: UnsafeCell::new(MaybeUninit::uninit()),
         }
     }
+    // FIXME: Isn't &mut UB?
     pub fn call_once<F>(&self, f: F) -> &mut T
     where
         F: FnOnce() -> T,
     {
-        match self
-            .status
-            .compare_and_swap(UNINITIALIZED, INITIALIZING, SeqCst)
-        {
-            UNINITIALIZED => {
-                // We now have a lock, let's initiate things!
-                let ret = unsafe { &mut *self.data.get() }.write(f());
-
-                // Mark the data as initialized
-                if self.status.swap(INITIALIZED, SeqCst) == WAITING {
-                    // At least one thread is waiting on this to finish
-                    self.status.notify_all();
-                }
-            }
-            INITIALIZING | WAITING => self.status.wait_until(
-                |lock| match lock.load(SeqCst) {
-                    WAITING => AttemptStatus::Waiting,
-                    INITIALIZED => AttemptStatus::Desired,
-                    _ => AttemptStatus::Other,
-                },
-                |lock| match lock
-                    .compare_exchange_weak(INITIALIZING, WAITING, SeqCst, SeqCst)
-                    .unwrap_or_else(|e| e)
-                {
-                    WAITING => AttemptStatus::Waiting,
-                    INITIALIZED => AttemptStatus::Desired,
-                    _ => AttemptStatus::Other,
-                },
-                WAITING,
-            ),
-            INITIALIZED => (),
-            _ => unreachable!("invalid state for Once<T>"),
-        }
+        call_once_generic(&self.status, || {
+            unsafe { &mut *self.data.get() }.write(f());
+        });
 
         // At this point the data must be initialized!
         unsafe { &mut *(&mut *self.data.get()).as_mut_ptr() }