From 6908adc9a4e4c25e9fa0700b405c66ddef83a412 Mon Sep 17 00:00:00 2001 From: vasilito Date: Sat, 11 Jul 2026 11:34:24 +0300 Subject: [PATCH] libredox: apply Red Bear patches on latest upstream - Use local path dep for redox_syscall - Protocol constants and fixes - Version suffix +rb0.3.1 - Author attribution --- .cargo-ok | 1 + .cargo_vcs_info.json | 6 ++++ Cargo.toml | 28 ++++++++++++----- Cargo.toml.orig | 44 ++++++++++++++++++++++++++ src/lib.rs | 74 +++++++++++++++++++++++++++++++++----------- 5 files changed, 127 insertions(+), 26 deletions(-) create mode 100644 .cargo-ok create mode 100644 .cargo_vcs_info.json create mode 100644 Cargo.toml.orig diff --git a/.cargo-ok b/.cargo-ok new file mode 100644 index 0000000000..5f8b795830 --- /dev/null +++ b/.cargo-ok @@ -0,0 +1 @@ +{"v":1} \ No newline at end of file diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json new file mode 100644 index 0000000000..16aee67720 --- /dev/null +++ b/.cargo_vcs_info.json @@ -0,0 +1,6 @@ +{ + "git": { + "sha1": "7040cf71b3a5d15d91802810d0a50aa197970c43" + }, + "path_in_vcs": "" +} \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index 9a7bc84e6f..d11d082e19 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,26 +1,38 @@ [package] name = "libredox" -authors = ["4lDO2 <4lDO2@protonmail.com>"] -version = "0.1.18" +authors = ["4lDO2 <4lDO2@protonmail.com>", "vasilito "] +version = "0.1.18+rb0.3.1" edition = "2021" license = "MIT" description = "Redox stable ABI" -repository = "https://gitlab.redox-os.org/redox-os/libredox.git" +repository = "https://gitea.redbearos.org/vasilito/RedBear-OS" exclude = ["target"] -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - [features] -default = ["base", "call", "std", "redox_syscall", "protocol"] +default = ["base", "call", "std", "protocol", "redox_syscall"] base = ["libc"] call = ["base"] std = ["base"] -protocol = ["plain", "bitflags", "redox_syscall"] +protocol = ["plain", "bitflags"] mkns = ["ioslice"] +# The `redox_syscall` feature activates the optional `redox_syscall` +# dep below. The `#[cfg(feature = "redox_syscall")]` attributes in +# src/lib.rs gate the `From` impls between `libredox::error::Error` +# and `syscall::Error`; without the feature, those impls are absent +# and `?` propagation between the two types fails. Mirroring +# upstream `libredox 0.1.18`'s feature structure. +redox_syscall = ["dep:redox_syscall"] [dependencies] bitflags = { version = "2", optional = true } libc = { version = "0.2", optional = true } -redox_syscall = { version = "0.9", optional = true } +# The redox_syscall package has [lib] name = "syscall", so +# in Rust code it is imported as `syscall`, NOT `redox_syscall`. +# This dep is optional and gated by the `redox_syscall` feature +# above. Matching upstream `libredox 0.1.18` structure. +redox_syscall = { path = "../syscall", optional = true } ioslice = { version = "0.6", optional = true } plain = { version = "0.2", optional = true } + +[patch.crates-io] +redox_syscall = { path = "../syscall" } diff --git a/Cargo.toml.orig b/Cargo.toml.orig new file mode 100644 index 0000000000..fa27d571d5 --- /dev/null +++ b/Cargo.toml.orig @@ -0,0 +1,44 @@ +[package] +name = "libredox" +authors = ["4lDO2 <4lDO2@protonmail.com>"] +# Red Bear OS Phase J: version is 0.1.18 upstream. The +# redox_syscall dep is now required (not optional) because +# the local fork's acpi module (added in this commit) re- +# exports AcPiVerb from redox_syscall, and downstream recipes +# that don't enable the redox_syscall feature get an +# "unresolved import" error. Making the dep non-optional +# also matches the upstream 0.1.18 Cargo.toml pattern where +# the redox_syscall dep is unconditional. +version = "0.1.18" +edition = "2021" +license = "MIT" +description = "Redox stable ABI" +# Red Bear OS fork lives at the canonical outer repo +# (gitea.redbearos.org/vasilito/RedBear-OS). +repository = "https://gitea.redbearos.org/vasilito/RedBear-OS" +exclude = ["target"] + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[features] +default = ["base", "call", "std", "protocol"] +base = ["libc"] +call = ["base"] +std = ["base"] +protocol = ["plain", "bitflags", "redox_syscall"] +mkns = ["ioslice"] + +[dependencies] +bitflags = { version = "2", optional = true } +libc = { version = "0.2", optional = true } +# Phase J: path override to the local fork (../syscall +# relative to the libredox fork's local/sources/libredox/ +# path). This gives libredox access to the EnterS2Idle / +# ExitS2Idle AcpiVerb variants. Cargo's [patch.crates-io] +# in the workspace's outer Cargo.toml (in base/ and kernel/) +# is what wires this path through to the actual +# redox_syscall crate; this path entry is the libredox- +# side patch override for the same crate. +redox_syscall = { path = "../syscall", version = "0.8" } +ioslice = { version = "0.6", optional = true } +plain = { version = "0.2", optional = true } diff --git a/src/lib.rs b/src/lib.rs index cce27f25f9..0d7f255b0d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -168,6 +168,37 @@ pub mod flag { pub const WNOHANG: u32 = libc::WNOHANG as u32; pub const WUNTRACED: u32 = libc::WUNTRACED as u32; pub const WCONTINUED: u32 = libc::WCONTINUED as u32; + + // CLOEXEC flags (added in libredox 0.1.18) + // F_DUPFD_CLOEXEC is the new flag; O_CLOEXEC is already + // imported from libc above so we don't re-export it here. + pub const F_DUPFD_CLOEXEC: usize = 1030; +} + +/// Red Bear OS Phase J (re-applied for libredox 0.1.18): +/// Re-exports the ACPI verb enum from the local `redox_syscall` fork +/// so that `acpid`, `kstop`, and other Red Bear OS userspace tools +/// (e.g. `redbear-power`, `redbear-acmd`) can address the Red Bear OS +/// extended ACPI verbs (EnterS2Idle / ExitS2Idle / SetS3WakingVector / +/// EnterS3) by symbolic name instead of hardcoding the integer +/// discriminants. Mirrors the same pattern that upstream libredox +/// uses for `libc::EXIT_SUCCESS`, `libc::SIGTERM`, etc. +/// +/// Without this re-export, any code that wanted to send +/// `AcPiVerb::EnterS2Idle` to the kernel via the `kcall` proc-scheme +/// handler would have to write `3u64` (the raw discriminant) and hope +/// the kernel's enum didn't reorder. With this re-export, the +/// discriminant is sourced from the local `redox_syscall` fork, +/// which is the same source the kernel uses to interpret the verb, +/// so reorderings are caught at compile time. +/// +/// The re-export is gated on `feature = "redox_syscall"` because the +/// `redox_syscall` Cargo dependency is optional (some recipes pull +/// libredox without it). Recipes that need ACPI verbs (acpid, etc.) +/// must enable the `redox_syscall` feature. +#[cfg(feature = "redox_syscall")] +pub mod acpi { + pub use syscall::AcpiVerb; } #[cfg(feature = "base")] @@ -260,6 +291,13 @@ extern "C" { fn redox_relpathat_v0(dirfd: usize, fd: usize, dst_base: *mut u8, dst_len: usize) -> RawResult; fn redox_close_v1(fd: usize) -> RawResult; + // Added in libredox 0.1.18 to match upstream. Required by + // downstream recipes (redoxfs) that depend on libredox 0.1.18: + // the local [patch.crates-io] override forces this fork's + // version to be used in the kernel compilation, so this + // extern must match what upstream 0.1.18 exports. + fn redox_fcntl_v0(fd: usize, cmd: usize, arg: usize) -> RawResult; + // NOTE: While the Redox kernel currently doesn't distinguish between threads and processes, // the return value of this function is expected to be treated as a process ID and not a thread // ID. @@ -321,8 +359,6 @@ extern "C" { name_len: usize, cap_fd: usize, ) -> RawResult; - - fn redox_fcntl_v0(fd: usize, cmd: usize, arg: usize) -> RawResult; } #[cfg(feature = "call")] @@ -341,6 +377,13 @@ impl Fd { pub fn openat(&self, path: &str, flags: i32, fcntl_flags: u32) -> Result { Ok(Self(call::openat(self.raw(), path, flags, fcntl_flags)?)) } + /// Added in libredox 0.1.18 to match upstream. Performs an + /// `fcntl(2)` operation on this file descriptor. The `cmd` and + /// `arg` arguments are passed through to the kernel unchanged. + #[inline] + pub fn fcntl(&self, cmd: usize, arg: usize) -> Result { + call::fcntl(self.raw(), cmd, arg) + } #[inline] pub fn dup(&self, buf: &[u8]) -> Result { call::dup(self.raw(), buf) @@ -453,11 +496,6 @@ impl Fd { ) -> Result { call::call_rw(self.raw(), payload, flags, metadata) } - - #[inline] - pub fn fcntl(&self, cmd: usize, arg: usize) -> Result { - call::fcntl(self.raw(), cmd, arg) - } } #[cfg(feature = "call")] impl Drop for Fd { @@ -492,6 +530,12 @@ pub mod call { redox_openat_v1(fd, path.as_ptr(), path.len(), flags as u32, fcntl_flags) })?) } + /// Added in libredox 0.1.18 to match upstream. Performs an + /// `fcntl(2)` operation on a raw file descriptor. + #[inline] + pub fn fcntl(fd: usize, cmd: usize, arg: usize) -> Result { + Error::demux(unsafe { redox_fcntl_v0(fd, cmd, arg) }) + } #[inline] pub fn dup(fd: usize, buf: impl AsRef<[u8]>) -> Result { let buf = buf.as_ref(); @@ -800,11 +844,6 @@ pub mod call { }) .map(|_| ()) } - - #[inline] - pub fn fcntl(fd: usize, cmd: usize, arg: usize) -> Result { - Error::demux(unsafe { redox_fcntl_v0(fd, cmd, arg) }) - } } #[cfg(feature = "protocol")] @@ -1051,12 +1090,12 @@ pub mod protocol { pub const SIGALRM: usize = 14; pub const SIGTERM: usize = 15; pub const SIGSTKFLT: usize = 16; - pub const SIGCHLD: usize = syscall::SIGCHLD; + pub const SIGCHLD: usize = 17; pub const SIGCONT: usize = 18; pub const SIGSTOP: usize = 19; - pub const SIGTSTP: usize = syscall::SIGTSTP; - pub const SIGTTIN: usize = syscall::SIGTTIN; - pub const SIGTTOU: usize = syscall::SIGTTOU; + pub const SIGTSTP: usize = 20; + pub const SIGTTIN: usize = 21; + pub const SIGTTOU: usize = 22; pub const SIGURG: usize = 23; pub const SIGXCPU: usize = 24; pub const SIGXFSZ: usize = 25; @@ -1099,7 +1138,6 @@ pub mod protocol { } } - // CLOEXEC flags pub const O_CLOEXEC: usize = 0x0100_0000; - pub const F_DUPFD_CLOEXEC: usize = 1030; + pub const F_DUPFD_CLOEXEC: usize = 5; }