diag(kernel): trace fd passing through pipe and syscall layers

Add error! diagnostics to pinpoint the fd-table desync hang:
- pipe.kfdwrite/kfdread: log queued/transferred fd counts
- syscall/fs.rs fdwrite_inner/call_fdread: log socket, target fds, scheme, flags
- context/context.rs bulk_add_fds/bulk_insert_fds: log counts and first_fd

These are temporary diagnostics for the boot-hang investigation.

src/context/context.rs

@@ -1088,6 +1088,7 @@ pub fn bulk_add_fds(
     if descriptions.is_empty() {
         return Ok(0);
     }
+    error!("bulk_add_fds: cnt={}", cnt);
     let current_lock = context::current();
     let mut current = current_lock.write(token.token());
     let (current, mut token) = current.token_split();
@@ -1132,6 +1133,8 @@ pub fn bulk_insert_fds(
         .ok_or(Error::new(EINVAL))?
         .read_usize()?;
 
+    error!("bulk_insert_fds: first_fd={} cnt={}", first_fd, cnt);
+
     let current_lock = context::current();
     let mut current = current_lock.write(token.token());
     let (current, mut token) = current.token_split();

src/scheme/pipe.rs

@@ -397,6 +397,8 @@ impl KernelScheme for PipeScheme {
             }
         };
 
+        error!("pipe.kfdwrite: id={} key={} descs={}", id, key, descs.len());
+
         loop {
             let vec = pipe.fd_queue.lock(token.token());
             let (mut vec, mut token) = vec.into_split();
@@ -421,6 +423,7 @@ impl KernelScheme for PipeScheme {
             let fds_written = vec.len() - before_len;
 
             if fds_written > 0 {
+                error!("pipe.kfdwrite: queued {} fds, total={}", fds_written, vec.len());
                 event::trigger_locked(
                     GlobalSchemes::Pipe.scheme_id(),
                     key,
@@ -464,6 +467,8 @@ impl KernelScheme for PipeScheme {
             return Ok(0);
         }
 
+        error!("pipe.kfdread: id={} key={} flags={:?}", id, key, flags);
+
         loop {
             let vec = pipe.fd_queue.lock(token.token());
             let (mut vec, mut token) = vec.into_split();
@@ -474,6 +479,8 @@ impl KernelScheme for PipeScheme {
             if fds_to_read > 0 {
                 let fds_to_transfer: Vec<_> = vec.drain(..fds_to_read).collect();
 
+                error!("pipe.kfdread: transferring {} fds (avail={})", fds_to_read, fds_available);
+
                 if flags.contains(CallFlags::FD_UPPER) {
                     bulk_insert_fds(
                         fds_to_transfer,

src/syscall/fs.rs

@@ -337,6 +337,8 @@ pub fn call(
 ) -> Result<usize> {
     let mut meta = [0_u64; 3];
 
+    error!("kernel::call: fd={} flags={:?}", fd.get(), flags);
+
     // TODO: bytemuck/plain
     let copied = metadata.copy_common_bytes_to_slice(unsafe {
         core::slice::from_raw_parts_mut(meta.as_mut_ptr().cast(), meta.len() * 8)
@@ -414,6 +416,7 @@ fn fdwrite_inner(
     token: &mut CleanLockToken,
 ) -> Result<usize> {
     // TODO: Ensure deadlocks can't happen
+    error!("fdwrite_inner: socket={} target_fds={:?} flags={:?}", socket.get(), target_fds, flags);
     let (scheme, number, descs_to_send) = {
         let (scheme, number) = {
             let current_lock = context::current();
@@ -483,6 +486,8 @@ fn call_fdread(
         (scheme, number)
     };
 
+    error!("call_fdread: fd={} number={} flags={:?}", fd.get(), number, flags);
+
     scheme.kfdread(number, payload, flags, metadata, token)
 }