vasilito
475f96ecab
Phase II.X.W: comprehensive FACS parser + SetS3WakingVector +
EnterS3 AcPiVerbs. The full S3 round-trip is now wired.
* FACS parser (src/acpi/facs.rs): comprehensive implementation
matching Linux 7.1's struct acpi_table_facs from
include/acpi/actbl.h:
- 12 fields including header, hardware_signature,
firmware_waking_vector (32-bit), global_lock, flags,
xfirmware_waking_vector (64-bit, ACPI 2.0+), version,
reserved[3], ospm_flags (ACPI 4.0+), reserved1[24].
- 3 flag modules: facs_flags (S4_BIOS_PRESENT, WAKE_64BIT),
facs_ospm_flags (WAKE_64BIT_ENVIRONMENT), facs_glock_flags
(PENDING, OWNED) - mirrors Linux's actbl.h constants.
- Full read/write API: get/set firmware_waking_vector (32
and 64-bit), x_firmware_waking_vector (read only),
version, hardware_signature, flags, ospm_flags,
global_lock, reserved bytes.
- Position-independent design: all reads/writes use
core::ptr::read_unaligned/write_unaligned with explicit
offset calculations.
- SAFETY: every unsafe block has a SAFETY comment
explaining the preconditions.
* FADT parser (src/acpi/fadt.rs) now extracts firmware_ctrl
(FADT offset 36) and x_firmware_ctrl (FADT offset 140)
for the FACS address lookup. Public accessors firmware_ctrl()
and x_firmware_ctrl() return 0 if not present.
* acpi init (src/acpi/mod.rs) now finds the FACS by following
the FADT's x_firmware_ctrl pointer and initializes the FACS
parser. Logs a warning if FACS is not found.
* AcPiScheme kcall handler (src/scheme/acpi.rs) now dispatches
on two new Phase II.X.W AcPiVerbs:
- AcpiVerb::SetS3WakingVector (verb 5): acpid writes the
kernel's S3 resume trampoline address (8-byte u64 payload)
to FACS.xfirmware_waking_vector. A zero payload is a
sentinel for 'use the kernel's default trampoline
address' (s3_trampoline symbol). Mirrors Linux 7.1's
acpi_set_firmware_waking_vector in ACPICA.
- AcpiVerb::EnterS3 (verb 6): acpid requests the kernel to
enter S3. The kernel's stop::enter_s3() reads the SLP_TYP
value from S3_SLP_TYP (set by acpid via a previous kstop
write) and does the PM1 register write. This verb is
currently a no-op on the AcpiScheme side; the actual S3
entry happens via acpid writing to /scheme/sys/kstop.
* Hardware-agnostic: works on any x86_64 system with standard
ACPI S3 support (Dell, HP, Lenovo, LG Gram 14). On Modern
Standby-only systems (LG Gram 16 (2025)), the kernel never
enters S3 so these verbs are no-ops.
Kernel
Redox OS Microkernel
Requirements
nasmneeds to be available on the PATH at build time.
Building The Documentation
Use this command:
cargo doc --open --target x86_64-unknown-none
Debugging
QEMU
Running QEMU with the -s flag will set up QEMU to listen on port 1234 for a GDB client to connect to it. To debug the redox kernel run.
make qemu gdb=yes
This will start a virtual machine with and listen on port 1234 for a GDB or LLDB client.
GDB
If you are going to use GDB, run these commands to load debug symbols and connect to your running kernel:
(gdb) symbol-file build/kernel.sym
(gdb) target remote localhost:1234
LLDB
If you are going to use LLDB, run these commands to start debugging:
(lldb) target create -s build/kernel.sym build/kernel
(lldb) gdb-remote localhost:1234
After connecting to your kernel you can set some interesting breakpoints and continue
the process. See your debuggers man page for more information on useful commands to run.
Notes
-
Always use
foo.get(n)instead offoo[n]and try to cover for the possibility ofOption::None. Doing the regular way may work fine for applications, but never in the kernel. No possible panics should ever exist in kernel space, because then the whole OS would just stop working. -
If you receive a kernel panic in QEMU, use
pkill qemu-systemto kill the frozen QEMU process.
How To Contribute
To learn how to contribute to this system component you need to read the following document:
Development
To learn how to do development with this system component inside the Redox build system you need to read the Build System and Coding and Building pages.
How To Build
To build this system component you need to download the Redox build system, you can learn how to do it on the Building Redox page.
This is necessary because they only work with cross-compilation to a Redox virtual machine, but you can do some testing from Linux.
Funding - Unix-style Signals and Process Management
This project is funded through NGI Zero Core, a fund established by NLnet with financial support from the European Commission's Next Generation Internet program. Learn more at the NLnet project page.
