From 58dfd26452d37caa0b06ca1587107ca4b91350d2 Mon Sep 17 00:00:00 2001 From: Red Bear OS Date: Sun, 12 Jul 2026 05:32:20 +0300 Subject: [PATCH] diag: remove 31 FK: debug prints from redox-rt fork implementation Removes all syscall::write(1, b'FK:...') debug trace lines from fork_impl/fork_inner in redox-rt/src/proc.rs that were polluting serial output during every fork() call. --- redox-rt/src/proc.rs | 31 ------------------------------- 1 file changed, 31 deletions(-) diff --git a/redox-rt/src/proc.rs b/redox-rt/src/proc.rs index 7bc373d36c..46c4491004 100644 --- a/redox-rt/src/proc.rs +++ b/redox-rt/src/proc.rs @@ -962,9 +962,7 @@ pub fn create_set_addr_space_buf_for_fork( /// descriptors from other schemes are reobtained with `dup`, and grants referencing such file /// descriptors are reobtained through `fmap`. Other mappings are kept but duplicated using CoW. pub fn fork_impl(args: &ForkArgs<'_>) -> Result { - let _ = syscall::write(1, b"FK:ENTER\n"); let old_mask = crate::signal::get_sigmask()?; - let _ = syscall::write(1, b"FK:SIG OK\n"); let pid = unsafe { Error::demux(__relibc_internal_fork_wrapper( core::ptr::from_ref::(args) as usize, @@ -986,7 +984,6 @@ pub enum ForkArgs<'a> { } pub fn fork_inner(initial_rsp: *mut usize, args: &ForkArgs) -> Result { - let _ = syscall::write(1, b"FK:INNER\n"); let (cur_filetable_fd, new_filetable_fd, new_proc_fd, new_thr_fd, new_pid); { @@ -999,7 +996,6 @@ pub fn fork_inner(initial_rsp: *mut usize, args: &ForkArgs) -> Result { thr_fd, pid, } = new_child_process(args)?; - let _ = syscall::write(1, b"FK:N1\n"); new_proc_fd = proc_fd; new_thr_fd = thr_fd; new_pid = pid; @@ -1008,15 +1004,11 @@ pub fn fork_inner(initial_rsp: *mut usize, args: &ForkArgs) -> Result { // parent FDs will not show up for the child). let scratchpad = { cur_filetable_fd = cur_thr_fd.dup_into_upper(b"filetable-binary").map_err(|e| { - let _ = syscall::write(1, b"FK:FB\n"); e })?; - let _ = syscall::write(1, b"FK:F1\n"); new_filetable_fd = cur_filetable_fd.dup_into_upper(b"copy").map_err(|e| { - let _ = syscall::write(1, b"FK:CP\n"); e })?; - let _ = syscall::write(1, b"FK:F2\n"); // This must be done before the address space is copied. let proc_fd = new_proc_fd.as_ref().map_or(usize::MAX, |p| p.as_raw_fd()); @@ -1047,21 +1039,15 @@ pub fn fork_inner(initial_rsp: *mut usize, args: &ForkArgs) -> Result { // CoW-duplicate address space. { let new_addr_space_sel_fd = new_thr_fd.dup_into_upper(b"current-addrspace").map_err(|e| { - let _ = syscall::write(1, b"FK:CA\n"); e })?; - let _ = syscall::write(1, b"FK:A0\n"); let cur_addr_space_fd = cur_thr_fd.dup_into_upper(b"addrspace").map_err(|e| { - let _ = syscall::write(1, b"FK:AS\n"); e })?; - let _ = syscall::write(1, b"FK:A1\n"); let new_addr_space_fd = cur_addr_space_fd.dup_into_upper(b"exclusive").map_err(|e| { - let _ = syscall::write(1, b"FK:EX\n"); e })?; - let _ = syscall::write(1, b"FK:A2\n"); let mut grant_desc_buf = [GrantDesc::default(); 16]; loop { @@ -1122,7 +1108,6 @@ pub fn fork_inner(initial_rsp: *mut usize, args: &ForkArgs) -> Result { )?; } } - let _ = syscall::write(1, b"FK:A3\n"); #[cfg(any( target_arch = "x86_64", target_arch = "aarch64", @@ -1141,7 +1126,6 @@ pub fn fork_inner(initial_rsp: *mut usize, args: &ForkArgs) -> Result { initial_rsp as usize, ); new_addr_space_sel_fd.write(&buf)?; - let _ = syscall::write(1, b"FK:A4\n"); } { // Reuse the same sigaltstack and signal entry (all memory will be re-mapped CoW later). @@ -1150,9 +1134,7 @@ pub fn fork_inner(initial_rsp: *mut usize, args: &ForkArgs) -> Result { // reference to the TCB and whatever pages stores the signal proc control struct. { let new_sighandler_fd = new_thr_fd.dup_into_upper(b"sighandler")?; - let _ = syscall::write(1, b"FK:S0\n"); new_sighandler_fd.write(&crate::signal::current_setsighandler_struct())?; - let _ = syscall::write(1, b"FK:S1\n"); } if let Some(ref proc_fd) = new_proc_fd { proc_call( @@ -1161,47 +1143,37 @@ pub fn fork_inner(initial_rsp: *mut usize, args: &ForkArgs) -> Result { CallFlags::empty(), &[ProcCall::SyncSigPctl as u64], )?; - let _ = syscall::write(1, b"FK:P1\n"); thread_call( new_thr_fd.as_raw_fd(), &mut [], CallFlags::empty(), &[ThreadCall::SyncSigTctl as u64], )?; - let _ = syscall::write(1, b"FK:T1\n"); } } { // Copy environment registers. let cur_env_regs_fd = cur_thr_fd.dup_into_upper(b"regs/env")?; - let _ = syscall::write(1, b"FK:E0\n"); let new_env_regs_fd = new_thr_fd.dup_into_upper(b"regs/env")?; - let _ = syscall::write(1, b"FK:E1\n"); let mut env_regs = syscall::EnvRegisters::default(); cur_env_regs_fd.read(&mut env_regs)?; new_env_regs_fd.write(&env_regs)?; - let _ = syscall::write(1, b"FK:E2\n"); } } { // TODO: Use file descriptor forwarding or something similar to avoid copying the file // table in the kernel. let new_filetable_sel_fd = new_thr_fd.dup_into_upper(b"current-filetable")?; - let _ = syscall::write(1, b"FK:FT0\n"); new_filetable_sel_fd.write(&usize::to_ne_bytes(new_filetable_fd.as_raw_fd()))?; - let _ = syscall::write(1, b"FK:FT1\n"); } new_filetable_fd.call_wo( &new_filetable_fd.as_raw_fd().to_ne_bytes(), syscall::CallFlags::FD | syscall::CallFlags::FD_CLONE, &[new_filetable_fd.as_raw_fd() as u64], )?; - let _ = syscall::write(1, b"FK:FT2\n"); let start_fd = new_thr_fd.dup_into_upper(b"start")?; - let _ = syscall::write(1, b"FK:ST0\n"); start_fd.write(&[0])?; - let _ = syscall::write(1, b"FK:ST1\n"); Ok(new_pid) } @@ -1235,7 +1207,6 @@ pub fn new_child_process(args: &ForkArgs<'_>) -> Result { #[cfg(not(feature = "proc"))] ForkArgs::Init { this_thr_fd, auth } => { let thr_fd = auth.dup_into_upper(b"new-context").map_err(|e| { - let _ = syscall::write(1, b"FK:NC\n"); e })?; let buf = syscall::ProcSchemeAttrs { @@ -1252,11 +1223,9 @@ pub fn new_child_process(args: &ForkArgs<'_>) -> Result { }; let attr_fd = thr_fd .dup_into_upper(alloc::format!("auth-{}-attrs", auth.as_raw_fd()).as_bytes()).map_err(|e| { - let _ = syscall::write(1, b"FK:AT\n"); e })?; attr_fd.write(&buf).map_err(|e| { - let _ = syscall::write(1, b"FK:WR\n"); e })?; Ok(NewChildProc {