debug and add socket option level print

kernel/src/arch/x86_64/syscall/mod.rs

@@ -104,8 +104,9 @@ pub extern "sysv64" fn syscall_handler(frame: &mut TrapFrame) {
     ];
     mfence();
     let pid = ProcessManager::current_pcb().pid();
-    let mut show = (syscall_num != SYS_SCHED) && (pid.data() >= 7);
-    // let mut show = true;
+    let mut show = 
+        (syscall_num != SYS_SCHED) && (pid.data() >= 7);
+        // false;
 
     let to_print = SysCall::try_from(syscall_num);
     if let Ok(to_print) = to_print {
@@ -115,21 +116,21 @@ pub extern "sysv64" fn syscall_handler(frame: &mut TrapFrame) {
                 // show &= false;
             }
             SYS_RECVFROM | SYS_SENDTO | SYS_SENDMSG | SYS_RECVMSG => {
-                show &= false;
+                // show &= false;
             }
             SYS_SOCKET | SYS_GETSOCKNAME | SYS_GETPEERNAME | SYS_SOCKETPAIR | SYS_SETSOCKOPT
             | SYS_GETSOCKOPT => {
-                show &= false;
+                // show &= false;
             }
             SYS_OPEN | SYS_OPENAT | SYS_CREAT | SYS_CLOSE => {
-                show &= false;
+                // show &= false;
             }
             SYS_READ | SYS_WRITE | SYS_READV | SYS_WRITEV | SYS_PREAD64 | SYS_PWRITE64
             | SYS_PREADV | SYS_PWRITEV | SYS_PREADV2 => {
                 show &= false;
             }
             _ => {
-                show &= false;
+                // show &= false;
             }
         }
         if show {

kernel/src/net/socket/inet/stream/mod.rs

@@ -334,6 +334,86 @@ impl Socket for TcpSocket {
             })
             .unwrap_or(Ok(()))
     }
+
+    fn set_option(&self, level: PSOL, name: usize, val: &[u8]) -> Result<(), SystemError> {
+        if level != PSOL::TCP {
+            // return Err(EINVAL);
+            log::debug!("TcpSocket::set_option: not TCP");
+            return Ok(());
+        }
+        use option::Options::{self, *};
+        let option_name = Options::try_from(name as i32)?;
+        log::debug!("TCP Option: {:?}, value = {:?}", option_name, val);
+        match option_name {
+            NoDelay => {
+                let nagle_enabled = val[0] != 0;
+                let mut writer = self.inner.write();
+                let inner = writer.take().expect("Tcp Inner is None");
+                match inner {
+                    Inner::Established(established) => {
+                        established.with_mut(|socket| {
+                            socket.set_nagle_enabled(nagle_enabled);
+                        });
+                        writer.replace(Inner::Established(established));
+                    }
+                    _ => {
+                        writer.replace(inner);
+                        return Err(EINVAL);
+                    }
+                }
+            },
+            KeepIntvl => {
+                if val.len() == 4 {
+                    let mut writer = self.inner.write();
+                    let inner = writer.take().expect("Tcp Inner is None");
+                    match inner {
+                        Inner::Established(established) => {
+                            let interval = u32::from_ne_bytes([val[0], val[1], val[2], val[3]]);
+                            established.with_mut(|socket| {
+                                socket.set_keep_alive(Some(smoltcp::time::Duration::from_secs(interval as u64)));
+                            });
+                            writer.replace(Inner::Established(established));
+                        }
+                        _ => {
+                            writer.replace(inner);
+                            return Err(EINVAL);
+                        }
+                    }
+                } else {
+                    return Err(EINVAL);
+                }
+            },
+            KeepCnt => {
+                // if val.len() == 4 {
+                //     let mut writer = self.inner.write();
+                //     let inner = writer.take().expect("Tcp Inner is None");
+                //     match inner {
+                //         Inner::Established(established) => {
+                //             let count = u32::from_ne_bytes([val[0], val[1], val[2], val[3]]);
+                //             established.with_mut(|socket| {
+                //                 socket.set_keep_alive_count(count);
+                //             });
+                //             writer.replace(Inner::Established(established));
+                //         }
+                //         _ => {
+                //             writer.replace(inner);
+                //             return Err(EINVAL);
+                //         }
+                //     }
+                // } else {
+                //     return Err(EINVAL);
+                // }
+            },
+            KeepIdle => {
+                
+            },
+            _ => {
+                log::debug!("TcpSocket::set_option: not supported");
+                // return Err(ENOPROTOOPT);
+            }
+        }
+        Ok(())
+    }
 }
 
 impl InetSocket for TcpSocket {

kernel/src/net/syscall.rs

@@ -116,7 +116,7 @@ impl Syscall {
         let socket: Arc<socket::Inode> = ProcessManager::current_pcb()
             .get_socket(fd as i32)
             .ok_or(SystemError::EBADF)?;
-        debug!("setsockopt: level={:?}", level);
+        debug!("setsockopt: level = {:?} ", sol);
         return socket.set_option(sol, optname, optval).map(|_| 0);
     }