diff --git a/os/src/syscall/mod.rs b/os/src/syscall/mod.rs
index 4ee28f4c88eac6031552d2a0f00a5caf50364119..089838e60e9e909d726f556f772cb79405eeba44 100644
--- a/os/src/syscall/mod.rs
+++ b/os/src/syscall/mod.rs
@@ -51,6 +51,7 @@ const SYSCALL_SETUID: usize =146;
 const SYSCALL_KILL: usize = 129;
 const SYSCALL_SIGACTION: usize = 134;
 const SYSCALL_SIGPROCMASK: usize = 135;
+const SYSCALL_SIGRETURN: usize = 139;
 const SYSCALL_TIMES: usize = 153;
 const SYSCALL_SETPGID:usize = 154;
 const SYSCALL_GETPGID:usize = 155;
@@ -144,6 +145,9 @@ pub fn syscall(syscall_id: usize, args: [usize; 6]) -> isize {
         SYSCALL_SIGPROCMASK => {
             result = Ok(sys_sigprocmask(args[0] as i32, args[1] as *const _, args[2] as *mut _));
         }
+        SYSCALL_SIGRETURN => {
+            result = Ok(sys_sigreturn());
+        }
         SYSCALL_GET_TIME => {
             result = sys_get_time(args[0] as *mut TimeSpec);
         },
@@ -362,6 +366,9 @@ fn sysid_to_string(syscall_id: usize)->String{
         SYSCALL_SIGPROCMASK => {
             ret.push_str("sys_sigprocmask");
         },
+        SYSCALL_SIGRETURN => {
+            ret.push_str("sys_sigreturn");
+        }
         SYSCALL_GET_TIME => {
             ret.push_str("sys_gettime");
         },
diff --git a/os/src/syscall/process.rs b/os/src/syscall/process.rs
index a916b2fb4c5c967df90b7d56ae05e4c5c69870e8..7493cbcaf655eaf6d5ecd5a5ab76520b5a6de89d 100644
--- a/os/src/syscall/process.rs
+++ b/os/src/syscall/process.rs
@@ -553,17 +553,7 @@ pub fn sys_kill(pid: usize, signal: u32) -> SysResult<isize> {
     }
 }
 
-fn check_sigaction_error(signal: SignalFlags, action: usize, old_action: usize) -> bool {
-    if action == 0
-        || old_action == 0
-        || signal == SignalFlags::SIGKILL
-        || signal == SignalFlags::SIGSTOP
-    {
-        true
-    } else {
-        false
-    }
-}
+
 
 pub fn sys_sigaction(
     signum: i32,
@@ -575,41 +565,43 @@ pub fn sys_sigaction(
     let mut inner = task.inner_exclusive_access();
 
     // 检查信号编号是否合法
-    if signum as usize > MAX_SIG {
-        println!("[kernel] sys_sigaction: Invalid signal number: {}", signum);
+    if signum <= 0 || signum as usize > MAX_SIG {
+        
         return -1;
     }
 
     // 将 signum 转换为 SignalFlags
-    if let Some(flag) = SignalFlags::from_bits(1 << signum) {
-        // 检查参数是否合法
-        if check_sigaction_error(flag, action as usize, old_action as usize) {
-            println!(
-                "[kernel] sys_sigaction: Invalid parameters for signal: {:?}", flag
-            );
-            return -1;
+    let flag = match SignalFlags::from_bits(1 << signum) {
+        Some(flag) => flag,
+        None => {
+            
+            SignalFlags::empty()
         }
+    };
 
-        // 保存旧的信号处理函数
-        let prev_action = inner.signal_actions.table[signum as usize];
-        if !old_action.is_null() {
-            *translated_refmut(token, old_action) = prev_action;
-        }
+    // 检查参数是否合法
+    if check_sigaction_error(flag) {
+        
+        return -1;
+    }
 
-        // 设置新的信号处理函数
-        if !action.is_null() {
-            inner.signal_actions.table[signum as usize] = *translated_ref(token, action);
-        }
+    // 保存旧的信号处理函数
+    let prev_action = inner.signal_actions.table[signum as usize];
+    if !old_action.is_null() {
+        *translated_refmut(token, old_action) = prev_action;
+    }
 
-        println!(
-            "[kernel] sys_sigaction: Set signal handler for signum={}, handler={:#x}",
-            signum, inner.signal_actions.table[signum as usize].handler
-        );
-        0
-    } else {
-        println!("[kernel] sys_sigaction: Signal not supported: {}", signum);
-        -1
+    // 设置新的信号处理函数
+    if !action.is_null() {
+        inner.signal_actions.table[signum as usize] = *translated_ref(token, action);
     }
+
+    0
+}
+
+fn check_sigaction_error(signal: SignalFlags) -> bool {
+    // 只限制 SIGKILL 和 SIGSTOP
+    signal == SignalFlags::SIGKILL || signal == SignalFlags::SIGSTOP
 }
 
 // 定义 how 参数的可能值（参考 POSIX）
@@ -634,27 +626,18 @@ pub fn sys_sigprocmask(how: i32, set: *const SignalFlags, oldset: *mut SignalFla
             match how {
                 SIG_BLOCK => {
                     inner.signal_mask |= new_set;
-                    println!(
-                        "[kernel] sys_sigprocmask: Block signals, new mask: {:#x}",
-                        inner.signal_mask.bits()
-                    );
+                    
                 }
                 SIG_UNBLOCK => {
                     inner.signal_mask &= !new_set;
-                    println!(
-                        "[kernel] sys_sigprocmask: Unblock signals, new mask: {:#x}",
-                        inner.signal_mask.bits()
-                    );
+                    
                 }
                 SIG_SETMASK => {
                     inner.signal_mask = new_set;
-                    println!(
-                        "[kernel] sys_sigprocmask: Set signal mask to {:#x}",
-                        inner.signal_mask.bits()
-                    );
+                    
                 }
                 _ => {
-                    println!("[kernel] sys_sigprocmask: Invalid how value: {}", how);
+                    
                     return -1;
                 }
             }
@@ -662,7 +645,25 @@ pub fn sys_sigprocmask(how: i32, set: *const SignalFlags, oldset: *mut SignalFla
 
         0
     } else {
-        println!("[kernel] sys_sigprocmask: No current task found");
+        
         -1
     }
 }
+
+pub fn sys_sigreturn() -> isize {
+    if let Some(task) = current_task() {
+        let mut task_inner = task.inner_exclusive_access();
+        if let Some(backup) = task_inner.trap_ctx_backup.take() {
+            task_inner.handling_sig = -1;
+            task_inner.trap_cx = backup;
+            // 返回信号处理程序的返回值（通常为 0）
+            0
+        } else {
+
+            -1
+        }
+    } else {
+        
+        -1
+    }
+}
\ No newline at end of file
diff --git a/os/src/task/mod.rs b/os/src/task/mod.rs
index d8f75a758bafb5b343f9d3558ed04ff9ea2efc0f..afb78eb5ea827542640b26d7e59219fe84758d5f 100644
--- a/os/src/task/mod.rs
+++ b/os/src/task/mod.rs
@@ -151,11 +151,14 @@ fn check_pending_signals() {
         Some(task) => task,
         None => return,
     };
-    for sig in 0..=MAX_SIG {
+    for sig in 1..=MAX_SIG {
         let task_inner = task.inner_exclusive_access();
         let signal = match SignalFlags::from_bits(1 << sig) {
             Some(signal) => signal,
-            None => continue,
+            None => {
+                println!("[kernel] check_pending_signals: Signal {} not in SignalFlags, but proceeding", sig);
+                SignalFlags::empty()
+            }
         };
         // 检查信号是否被屏蔽
         if task_inner.signals.contains(signal) {
@@ -191,7 +194,6 @@ fn check_pending_signals() {
             if signal == SignalFlags::SIGKILL
                 || signal == SignalFlags::SIGSTOP
                 || signal == SignalFlags::SIGCONT
-                || signal == SignalFlags::SIGDEF
             {
                 call_kernel_signal_handler(sig, signal);
             } else {
@@ -203,29 +205,28 @@ fn check_pending_signals() {
 }
 
 /// 处理内核态信号
-fn call_kernel_signal_handler(_sig: usize, signal: SignalFlags) {
+fn call_kernel_signal_handler(sig: usize, signal: SignalFlags) {
     let task = current_task().unwrap();
     let mut task_inner = task.inner_exclusive_access();
     match signal {
         SignalFlags::SIGSTOP => {
             task_inner.frozen = true;
             task_inner.signals.remove(SignalFlags::SIGSTOP);
+            println!("[kernel] Task {} stopped by SIGSTOP", task.getpid());
         }
         SignalFlags::SIGCONT => {
             task_inner.frozen = false;
             task_inner.signals.remove(SignalFlags::SIGCONT);
+            println!("[kernel] Task {} continued by SIGCONT", task.getpid());
         }
         SignalFlags::SIGKILL => {
             task_inner.killed = true;
-            // 不要移除信号，保留以便 check_error 使用
-        }
-        SignalFlags::SIGDEF => {
-            // 默认信号处理：忽略
-            task_inner.signals.remove(SignalFlags::SIGDEF);
+            println!("[kernel] Task {} killed by SIGKILL", task.getpid());
         }
         _ => {
-            // 其他信号：终止进程
+            // 其他内核信号：终止进程
             task_inner.killed = true;
+            println!("[kernel] Task {} terminated by signal {}", task.getpid(), sig);
         }
     }
 }
@@ -248,16 +249,34 @@ fn call_user_signal_handler(sig: usize, signal: SignalFlags) {
         // 修改 trap 上下文以调用信号处理函数
         trap_ctx.sepc = handler;
         trap_ctx.x[10] = sig; // a0 = 信号编号
+        println!("[kernel] Calling user signal handler for signal {} at {:#x}", sig, handler);
     } else {
-        // 默认行为：终止进程
-        println!("[kernel] call_user_signal_handler: No handler for signal {}, default action: terminate", sig);
-        task_inner.killed = true;
+        // 默认行为
+        match signal {
+            SignalFlags::SIGCHLD => {
+                // SIGCHLD 默认忽略
+                task_inner.signals.remove(signal);
+                println!("[kernel] Signal {} (SIGCHLD) ignored by default", sig);
+            }
+            SignalFlags::SIGCONT => {
+                // SIGCONT 默认继续进程（已在 call_kernel_signal_handler 中处理）
+                task_inner.signals.remove(signal);
+                println!("[kernel] Signal {} (SIGCONT) handled by kernel", sig);
+            }
+            SignalFlags::SIGWINCH => {
+                // SIGWINCH 默认忽略
+                task_inner.signals.remove(signal);
+                println!("[kernel] Signal {} (SIGWINCH) ignored by default", sig);
+            }
+            _ => {
+                // 其他信号默认终止进程
+                task_inner.killed = true;
+                println!("[kernel] Task {} terminated by signal {} (default action)", task.getpid(), sig);
+            }
+        }
     }
 }
 
-/// 检查当前任务是否因信号被终止，并返回错误码和消息
-///
-/// 如果任务被标记为 `killed`，返回 `Some((error_code, error_message))`，否则返回 `None`。
 pub fn check_signals_error_of_current() -> Option<(isize, &'static str)> {
     let task = match current_task() {
         Some(task) => task,
@@ -272,5 +291,4 @@ pub fn check_signals_error_of_current() -> Option<(isize, &'static str)> {
     } else {
         None
     }
-}
-
+}
\ No newline at end of file
diff --git a/os/src/task/signal.rs b/os/src/task/signal.rs
index eec9ffeba08dfdd7064333a9613b3a82595d06cf..c6ebbc06f35fa73f021d89c979517db4c16ddcce 100644
--- a/os/src/task/signal.rs
+++ b/os/src/task/signal.rs
@@ -5,34 +5,69 @@ use bitflags::*;
 bitflags! {
     pub struct SignalFlags: u32 {
         /// 默认信号处理，信号编号为 0
-        const SIGDEF = 1 << 0;
-        
-        /// 挂起信号（Stop），信号编号为 1
-        const SIGSTOP = 1 << 1;
-        
+        const SIGDEF  = 1 << 0;  // 0
+        /// 挂起信号（Hangup），信号编号为 1
+        const SIGHUP  = 1 << 1;  // 1
         /// 中断信号（Interrupt），通常由 Ctrl+C 触发，信号编号为 2
-        const SIGINT = 1 << 2;
-        
-        /// 继续信号（Continue），信号编号为 3
-        const SIGCONT = 1 << 3;
-        
+        const SIGINT  = 1 << 2;  // 2
+        /// 退出信号（Quit），信号编号为 3
+        const SIGQUIT = 1 << 3;  // 3
         /// 非法指令信号（Illegal Instruction），信号编号为 4
-        const SIGILL = 1 << 4;
-        
+        const SIGILL  = 1 << 4;  // 4
+        /// 陷阱信号（Trap），信号编号为 5
+        const SIGTRAP = 1 << 5;  // 5
         /// 终止信号（Abort），通常由程序错误触发，信号编号为 6
-        const SIGABRT = 1 << 6;
-        
+        const SIGABRT = 1 << 6;  // 6
+        /// 总线错误信号（Bus Error），信号编号为 7
+        const SIGBUS  = 1 << 7;  // 7
         /// 浮点异常信号（Floating-Point Exception），信号编号为 8
-        const SIGFPE = 1 << 8;
-        
+        const SIGFPE  = 1 << 8;  // 8
         /// 杀死信号（Kill），信号编号为 9
-        const SIGKILL = 1 << 9;
-        
+        const SIGKILL = 1 << 9;  // 9
         /// 用户定义信号 1，信号编号为 10
-        const SIGUSR1 = 1 << 10;
-        
+        const SIGUSR1 = 1 << 10; // 10
         /// 分段错误信号（Segmentation Violation），通常由非法内存访问触发，信号编号为 11
-        const SIGSEGV = 1 << 11;
+        const SIGSEGV = 1 << 11; // 11
+        /// 用户定义信号 2，信号编号为 12
+        const SIGUSR2 = 1 << 12; // 12
+        /// 管道错误信号（Broken Pipe），信号编号为 13
+        const SIGPIPE = 1 << 13; // 13
+        /// 闹钟信号（Alarm Clock），信号编号为 14
+        const SIGALRM = 1 << 14; // 14
+        /// 终止信号（Terminate），信号编号为 15
+        const SIGTERM = 1 << 15; // 15
+        /// 堆栈错误信号（Stack Fault），信号编号为 16
+        const SIGSTKFLT = 1 << 16; // 16
+        /// 子进程状态改变信号（Child Status Changed），信号编号为 17
+        const SIGCHLD = 1 << 17; // 17
+        /// 继续信号（Continue），信号编号为 18
+        const SIGCONT = 1 << 18; // 18
+        /// 停止信号（Stop），信号编号为 19
+        const SIGSTOP = 1 << 19; // 19
+        /// 终端停止信号（Terminal Stop），信号编号为 20
+        const SIGTSTP = 1 << 20; // 20
+        /// 终端输入信号（Terminal Input），信号编号为 21
+        const SIGTTIN = 1 << 21; // 21
+        /// 终端输出信号（Terminal Output），信号编号为 22
+        const SIGTTOU = 1 << 22; // 22
+        /// 紧急信号（Urgent Condition），信号编号为 23
+        const SIGURG  = 1 << 23; // 23
+        /// CPU 时间限制信号（CPU Time Limit Exceeded），信号编号为 24
+        const SIGXCPU = 1 << 24; // 24
+        /// 文件大小限制信号（File Size Limit Exceeded），信号编号为 25
+        const SIGXFSZ = 1 << 25; // 25
+        /// 虚拟定时器信号（Virtual Timer Expired），信号编号为 26
+        const SIGVTALRM = 1 << 26; // 26
+        /// 性能分析定时器信号（Profiling Timer Expired），信号编号为 27
+        const SIGPROF = 1 << 27; // 27
+        /// 窗口大小改变信号（Window Size Change），信号编号为 28
+        const SIGWINCH = 1 << 28; // 28
+        /// I/O 信号（I/O Possible），信号编号为 29
+        const SIGIO   = 1 << 29; // 29
+        /// 电源故障信号（Power Failure），信号编号为 30
+        const SIGPWR  = 1 << 30; // 30
+        /// 系统调用错误信号（Bad System Call），信号编号为 31
+        const SIGSYS  = 1 << 31; // 31
     }
 }