The Signal Delivery Process in the Linux Kernel

1 Execute the default action of the signal
2 Capture the signal
3 Re-execute the system call
4 x86_64 architecture – do_signal()

Previously, we introduced how the kernel notices the arrival of a signal and calls related functions to update the process descriptor so that the process can receive and handle the signal. However, if the target process is not running at that moment, the kernel delays the signal delivery. Now, let’s see how the kernel handles signals that are pending for a process.

As mentioned in section 4 of Chapter 4, the kernel allows checking the process’s TIF_SIGPENDING flag before the process returns to user mode. Therefore, after the kernel completes handling an interrupt or exception, it checks for any pending signals. To handle non-blocking pending signals, the kernel calls the do_signal() function, which accepts two parameters:

regs

current The address of the location in the kernel stack where the user mode register contents of the current process are saved.
oldset

The address of the variable used to save the blocked signal bitmask array.

The description of do_signal() mainly focuses on the general mechanism of signal delivery; the actual code covers many details, such as handling race conditions and other special cases (like freezing the system, generating core dumps, stopping and killing the entire thread group, etc.). We will ignore these details.

As mentioned earlier, the do_signal() function is typically called only when the CPU intends to return to user mode. Therefore, if do_signal() is called within an interrupt handler, the function returns directly:

if ((regs->xcs & 3) != 3)
    return 1;

If oldset is NULL, it is initialized using the address of current->blocked:

if (!oldset)
    oldset = &amp;current->blocked;

do_signal() is centered around a loop that repeatedly calls the dequeue_signal() function until there are no unblocked pending signals in the private and shared pending signal queues. The return value of dequeue_signal() is stored in the local variable signr; if it equals 0, it means all pending signals have been processed, and do_signal() completes; if it returns a non-zero value, there are pending signals waiting to be processed. After handling this signal, do_signal() will call the dequeue_signal() function again.

dequeue_signal() first considers all signals in the private pending signal queue (in ascending order), followed by signals in the shared pending queue. It updates the corresponding data structures to indicate that the signal is no longer pending and returns the signal value. This involves clearing the corresponding bits in current->pending.signal or current->signal->shared_pending.signal, and calling recalc_sigpending() to update the value of TIF_SIGPENDING.

Let’s look at how do_signal() handles each pending signal returned by dequeue_signal(). First, it checks whether the currently receiving process is being monitored by other processes; if so, do_signal() calls do_notify_parent_cldstop() and schedule() to make the monitoring thread aware of the signal handling.

Then, do_signal() loads the address of the k_sigaction data structure for the pending signal into the local variable ka:

ka = &amp;current->sig-&gt;action[signr-1];

Depending on the specific content, it may execute three types of actions: ignore the signal, execute the default action, or execute the signal handler.

If the delivered signal is ignored, do_signal() continues to process other pending signals:

if (ka->sa.sa_handler == SIG_IGN)
    continue;

In the next two sections, we will describe how to execute the default action and the signal handler.

1 Execute the Default Action of the Signal

If ka->sa.sa_handler equals SIG_DFL, do_signal() executes the default action of the signal. The only exception is when the receiving process is init; in this case, the signal is discarded:

if (current->pid == 1)
    continue;

For other processes, the default handling of ignored signals is also very simple:

if (signr==SIGCONT || signr==SIGCHLD ||
        signr==SIGWINCH || signr==SIGURG)
    continue;

For signals with a default action of stop, all processes in the thread group will be stopped. To do this, do_signal() sets their state to TASK_STOPPED and then calls schedule() to schedule the processes:

if (signr==SIGSTOP || signr==SIGTSTP ||
        signr==SIGTTIN || signr==SIGTTOU) {
    if (signr != SIGSTOP &amp;&amp;
            is_orphaned_pgrp(current->signal->pgrp))
        continue;
    do_signal_stop(signr);
}

SIGSTOP and other signals are somewhat different: SIGSTOP always stops the thread group, while other signals only stop the thread group when it is in an orphaned process group. The POSIX standard specifies that as long as a process in the thread group has a parent process in a different process group of the same session, it is not an orphaned process group. Therefore, if the parent process has died, but the user of the initiating process is still logged in, the process group is not an orphaned process group.

do_signal_stop() checks whether the current process is the first process in the thread group to be stopped. If so, it is responsible for stopping all processes: essentially, this function sets the group_stop_count field in the signal descriptor to a positive value and wakes up each process in the thread group. Then, each process checks this field in turn to identify the ongoing group stop, changes its state to TASK_STOPPED, and calls schedule() to reschedule the processes. The do_signal_stop() function also sends a SIGCHLD signal to the parent process of the thread group leader, unless the parent process has set the SIGCHLD flag of SA_NOCLDSTOP.

The default action for signals that is dump creates a core dump file in the working directory of the process: this file lists the complete contents of the process’s address space and registers. After creating the core dump file, do_signal() kills the thread group. The default action for the remaining 18 signals is terminate, which means killing the process. To do this, it calls do_group_exit(), executing a graceful group exit handler (refer to section on process termination in Chapter 3).

2 Capture the Signal

If the signal specifies a handler, do_signal() executes that program by calling handle_signal()

handle_signal(signr, &amp;info, &amp;ka, oldset, regs);
if (ka->sa.sa_flags &amp; SA_ONESHOT)
    ka->sa.sa_handler = SIG_DFL;
return 1;

If the received signal has the SA_ONESHOT flag set, it must be reset to the default action so that the same signal will not trigger the signal handler again. Note how do_signal() returns after handling a single signal. No other pending signals will be considered until the next call to do_signal(). This approach ensures that real-time signals are processed in the appropriate order.

Executing a signal handler is a rather complex task because careful stack switching is required when transitioning between user mode and kernel mode. We will explain this in detail:

Signal handlers are functions defined by user processes, contained in the user code segment. The handle_signal() function runs in kernel mode, while the signal handler runs in user mode; this means the current process must first execute the signal handler in user mode before being allowed to resume its “normal” execution. Additionally, when the kernel attempts to restore the process’s normal execution, the kernel stack no longer contains the hardware context of the interrupted program because the kernel stack is cleared each time it transitions from user mode to kernel mode.

The following figure illustrates the execution flow of capturing a signal. Assume a non-blocking signal is sent to the process. When an interrupt or exception occurs, the process switches to kernel mode. Just before returning to user mode, the kernel calls the do_signal() function, sequentially handling signals (handle_signal()) and configuring the user mode stack (setup_frame() or setup_rt_frame()). When the process switches to user mode, it begins executing the signal handler because the address of that handler has been forcibly loaded into the <code>PC program counter. When the signal program terminates, setup_frame() or setup_rt_frame() will load the return code into the user mode stack. This return code will call the <code>sigreturn() and rt_sigreturn() system calls; the corresponding service routines will copy the hardware context of the normal program into the kernel mode stack and restore the user mode stack to its original state (restore_sigcontext()). When the system call terminates, the normal program continues its execution.

The Signal Delivery Process in the Linux Kernel

Figure 11-2 Capturing a Signal

Now, let’s look at the execution details:

2.1 Setting up the Frame

To correctly set up the user mode stack of the process, the handle_signal() function can either call setup_frame() (for signals that do not require siginfo_t) or call setup_rt_frame() (for signals that definitely require siginfo_t). Which function is called depends on the sigaction table’s sa_flags field’s SA_SIGINFO flag.

Next, let’s look at the specific implementation of the setup_frame() function: (Linux kernel version v2.6.11, file location: arch/x86_64/kernel/signal.c)

/* Definitions of these symbols are in the vsyscall memory page, see vsyscall-sigreturn.S file */
extern void __user __kernel_sigreturn;
extern void __user __kernel_rt_sigreturn;

static void setup_frame(int sig, struct k_sigaction *ka,
            sigset_t *set, struct pt_regs * regs) {
    void __user *restorer;
    struct sigframe __user *frame;
    int err = 0;
    int usig;

    frame = get_sigframe(ka, regs, sizeof(*frame));

    if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
        goto give_sigsegv;

    usig = current_thread_info()->exec_domain
        &amp;&amp; current_thread_info()->exec_domain->signal_invmap
        &amp;&amp; sig < 32
        ? current_thread_info()->exec_domain->signal_invmap[sig]
        : sig;

    err = __put_user(usig, &amp;frame->sig);
    if (err)
        goto give_sigsegv;

    err = setup_sigcontext(&amp;frame->sc, &amp;frame->fpstate, regs, set->sig[0]);
    if (err)
        goto give_sigsegv;

    if (_NSIG_WORDS > 1) {
        err = __copy_to_user(&amp;frame->extramask, &amp;set->sig[1],
                      sizeof(frame->extramask));
        if (err)
            goto give_sigsegv;
    }

    restorer = &amp;__kernel_sigreturn;
    if (ka->sa.sa_flags &amp; SA_RESTORER)
        restorer = ka->sa.sa_restorer;

    /* Set up to return from userspace.  */
    err |= __put_user(restorer, &amp;frame->pretcode);
     
    /*
     * This is popl %eax ; movl $,%eax ; int $0x80
     *
     * WE DO NOT USE IT ANY MORE! It's only left here for historical
     * reasons and because gdb uses it as a signature to notice
     * signal handler stack frames.
     */
    err |= __put_user(0xb858, (short __user *)(frame->retcode+0));
    err |= __put_user(__NR_sigreturn, (int __user *)(frame->retcode+2));
    err |= __put_user(0x80cd, (short __user *)(frame->retcode+6));

    if (err)
        goto give_sigsegv;

    /* Configure registers for the signal handler */
    regs->esp = (unsigned long) frame;
    regs->eip = (unsigned long) ka->sa.sa_handler;
    regs->eax = (unsigned long) sig;
    regs->edx = (unsigned long) 0;
    regs->ecx = (unsigned long) 0;

    /* Restore user mode segment registers */
    set_fs(USER_DS);
    regs->xds = __USER_DS;
    regs->xes = __USER_DS;
    regs->xss = __USER_DS;
    regs->xcs = __USER_CS;

    /* Clear the TF flag when entering the signal handler, but notify the tracer that is single stepping,
     * the tracer may also want to single step inside the signal handler
     */
    regs->eflags &amp;= ~TF_MASK;
    if (test_thread_flag(TIF_SINGLESTEP))
        ptrace_notify(SIGTRAP);
    // ... omitted, print debug info and then return.

give_sigsegv:
    force_sigsegv(sig, current);
}

setup_frame() receives four parameters as follows:

sig

Signal
ka

Address of the k_sigaction table for the signal
oldset

Address of the bitmask group for blocked signals
regs

Location where the user mode register contents are saved in the kernel stack

setup_frame() pushes a data structure called frame onto the user mode stack, which stores the information needed to handle the signal and correctly return to the sys_sigreturn() function. The frame is a sigframe table containing the following fields (see Figure 11-3):

pretcode

The return address of the signal handler. It is actually the address of the assembly code at the __kernel_sigreturn label.
sig

The signal, which is a parameter needed by the signal handler.
sc

Contains the process context content just before the user mode process switches to kernel mode, with the data type being sigcontext (this information is copied from the kernel mode stack of current). Additionally, it contains an array of bits for blocking signals for the process.
fpstate

Used to save the floating-point register information of the user mode process, with the data structure type being _fpstate. (Refer to the section on Saving and Loading FPU, MMX, and XMM Registers in Chapter 3).
extramask

Specifies the bit array for blocking real-time signals.
retcode

The 8-byte code that initiates the sigreturn() system call. In early versions of Linux, this code was used to return from the signal handler; however, after version Linux 2.6, it is only used as a signature so that the debugger can recognize signal stack frames.

The Signal Delivery Process in the Linux Kernel

Figure 11-3 The frame on the user mode stack

setup_frame() function calls get_sigframe() to calculate the first memory location of the frame; since this memory location is on the user mode stack, the value returned by the function is (regs->esp - sizeof(struct sigframe)) & 0xfffffff8.

Linux allows processes to call the signaltstack() system call to specify an alternate stack for their signal handlers; this feature is also required by the X/Open standard. If an alternate stack is used, the get_sigframe() function returns an address in the alternate stack. We will not discuss this feature in detail; conceptually, it is very similar to regular signal handling.

Because on the x86 architecture, the stack grows downwards, the address of the frame is equal to the current stack top position’s address minus the size of the frame, with the result aligned to 8 bytes.

The return address is verified using access_ok; if valid, the function repeatedly calls __put_user() to fill in all fields of the frame. The pretcode field is initialized to &__kernel_sigreturn, which is the address of a piece of assembly code on the vsyscall memory page. (Refer to the section on Making System Calls via the sysenter Instruction in Chapter 10).

Next, the contents of the regs in the kernel mode stack are modified to ensure that when current switches to user mode, the CPU control can be passed to the signal handler:

    regs->esp = (unsigned long) frame;
    regs->eip = (unsigned long) ka->sa.sa_handler;
    regs->eax = (unsigned long) sig;
    regs->edx = (unsigned long) 0;
    regs->ecx = (unsigned long) 0;

    /* Restore user mode segment registers */
    set_fs(USER_DS);
    regs->xds = __USER_DS;
    regs->xes = __USER_DS;
    regs->xss = __USER_DS;
    regs->xcs = __USER_CS;

    /* Clear the TF flag when entering the signal handler, but notify the tracer that is single stepping,
     * the tracer may also want to single step inside the signal handler
     */
    regs->eflags &amp;= ~TF_MASK;
    if (test_thread_flag(TIF_SINGLESTEP))
        ptrace_notify(SIGTRAP);
    // ... omitted, print debug info and then return.

Finally, the setup_frame() function resets the segment registers stored in the kernel mode stack to their user mode default values and terminates. Now, the information needed by the signal handler is at the top of the user mode stack.

setup_rt_frame() function is similar to setup_frame(), but it pushes an extended frame (data structure is rt_sigframe) onto the user mode stack, which also includes the contents of the siginfo_t table related to the signal. Additionally, this function points the pretcode field to the code segment of __kernel_rt_sigreturn in the vsyscall memory page.

2.2 Calculating Signal Flags

After configuring the user mode stack, the handle_signal() function checks the flags associated with the signal. If the signal does not have the SA_NODEFER flag set, all signals in the sa_mask field of the sigaction table must be blocked during the execution of the signal handler to ensure that the signal is processed quickly:

    if (!(ka->sa.sa_flags &amp; SA_NODEFER)) {
        spin_lock_irq(&amp;current->sighand-&gt;siglock);
        sigorsets(&amp;current->blocked, &amp;current->blocked, &amp;ka->sa.sa_mask);
        sigaddset(&amp;current->blocked, sig);
        recalc_sigpending(current);
        spin_unlock_irq(&amp;current->sighand-&gt;siglock);
    }

As previously described, the recalc_sigpending() function checks whether the process has any non-blocking pending signals and sets its corresponding TIF_SIGPENDING flag.

After this, it returns to do_signal(), which also returns.

2.3 Starting the Signal Handler

When returning from do_signal(), the current process switches to user mode for execution. Because of the preparations made by setup_frame(), the eip register points to the first instruction of the signal handler, while the esp points to the first memory location of the frame pushed onto the user mode stack. Thus, the execution of the signal handler begins.

2.4 Terminating the Signal Handler

When the signal handler execution completes, the return address at the top of its stack points to the vsyscall memory page (the pretcode field in the frame)

__kernel_sigreturn:
    popl %eax
    movl $__NR_sigreturn, %eax
    int $0x80

Thus, the signal (i.e., the sig field in the frame) is discarded from the stack; then, the sigreturn() system call is invoked.

sys_sigreturn() function calculates the address of regs (of type pt_regs), which contains the hardware context of the user process, to complete the transition from kernel mode to user mode execution. Since the kernel mode stack has been corrupted during the transition to user mode for executing the signal handler, a temporary kernel mode stack needs to be established, with data sourced from the frame data structure configured in the user mode stack.

asmlinkage int sys_sigreturn(unsigned long __unused) {
    /* Establish a temporary stack for the process in kernel mode */
    struct pt_regs *regs = (struct pt_regs *) &amp;__unused;
    // User storage in kernel mode stack
    struct sigframe __user *frame = (struct sigframe __user *)(regs->esp - 8);
    sigset_t set;
    int eax;

    /* Verify that the `frame` data structure is correct */
    if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
        goto badframe;
    /* Handle real-time signals */
    if (__get_user(set.sig[0], &amp;frame->sc.oldmask)
        || (_NSIG_WORDS > 1
        &amp;&amp; __copy_from_user(&amp;set.sig[1], &amp;frame->extramask,
                    sizeof(frame->extramask))))
        goto badframe;

    /* Restore pending signals that were blocked during the signal handler */
    sigdelsetmask(&amp;set, ~_BLOCKABLE);
    spin_lock_irq(&amp;current->sighand-&gt;siglock);
    current->blocked = set;
    recalc_sigpending();
    spin_unlock_irq(&amp;current->sighand-&gt;siglock);
    
    /* Copy the user process hardware context from the frame in the user mode stack to the kernel mode stack and remove the frame */
    if (restore_sigcontext(regs, &amp;frame->sc, &amp;eax))
        goto badframe;
    return eax;

    /* Error data handling */
badframe:
    force_sig(SIGSEGV, current);
    return 0;
}

sys_sigreturn() function calculates the address of regs (of type pt_regs), which contains the hardware context of the user process (refer to the section on Parameter Passing in Chapter 10). Based on the esp field in regs, the address of the frame in the user stack can be inferred.

Then, the blocked signals that were blocked during the execution of the signal handler are copied from the frame‘s sc field to the current process’s current‘s blocked field. This means these blocked signals are unblocked. The call to recalc_sigpending() will rejoin these signals to the pending signal queue.

Next, the sys_sigreturn() function needs to copy the process’s hardware context from the frame‘s sc field to the kernel mode stack and remove the frame data from the user mode stack. Both of these steps are implemented by the restore_sigcontext() function.

If the signal was sent by a system call (for example, rt_sigqueueinfo()), the signal-related siginfo_t table data is required, and its mechanism is similar to the above. The pretcode field in the extended frame points to the assembly code at the __kernel_rt_sigreturn label (located in the vsyscall memory page), which will call the rt_sigreturn() system call. The corresponding system service routine sys_rt_sigreturn() will copy the process’s hardware context from the extended frame to the kernel mode stack and remove the extended frame from the user mode stack to restore the original user mode stack.

3 Re-execution of System Calls

For system call requests, the kernel sometimes cannot fulfill them immediately. At this point, the process that initiated the system call will be set to TASK_INTERRUPTIBLE or TASK_UNINTERRUPTIBLE state.

If the process is in the TASK_INTERRUPTIBLE state and other processes send signals to it, the kernel will set the process to TASK_RUNNING without completing the system call (refer to the section on Returning from Interrupts and Exceptions in Chapter 4). When the process wants to switch back to user mode while a signal is being delivered, the system call service routine has not yet completed its work, so it will return error codes EINTR, ERESTARTNOHAND, ERESTART_RESTARTBLOCK, ERESTARTSYS, ERESTARTNOINTR.

In fact, in this scenario, the only error code that the user mode process can receive is EINTR, which means the system call has not been completed. Application programmers can check this error code and decide whether to re-initiate the system call. The other error codes are used internally by the kernel to specify whether to automatically re-execute the system call after the signal handler ends.

Table 11-11 lists the error codes related to unfinished system calls and their impact on the three default behaviors of signals. The terms in the table are explained as follows:

Terminate

The system call will not be automatically re-executed; the process will continue executing in user mode after the int $0x80 or sysenter instruction, returning the value -EINTR through the eax register.
Reexecute

The kernel forces the user process to reload the system call number (eax) and then re-invokes int $0x80 or sysenter; the process will not be aware of the re-execution and will not receive an error code.
Depends

The system call will only be re-executed if the signal that was delivered has the SA_RESTART flag set; otherwise, the system call will terminate and return the error code -EINTR.

Table 11-11 System Call Re-execution

Signal Behavior	EINTR	ERESTARTSYS	ERESTARTNOHAND ERESTART_RESTARTBLOCK*	ERESTARTNOINTR
Default	`<span>Terminate</span>`	`<span>Reexecute</span>`	`<span>Reexecute</span>`	`<span>Reexecute</span>`
Ignore	`<span>Terminate</span>`	`<span>Reexecute</span>`	`<span>Reexecute</span>`	`<span>Reexecute</span>`
Catch	`<span>Terminate</span>`	`<span>Depends</span>`	`<span>Terminate</span>`	`<span>Reexecute</span>`

ERESTARTNOHAND and ERESTART_RESTARTBLOCK have different mechanisms for restarting system calls.

When delivering signals, the kernel must ensure that the process initiated the system call before re-executing it. This is where the regs register context’s orig_eax field plays a crucial role. Let’s recall how this field is initialized when the interrupt or exception handler starts:

Interrupt

This field is set to the interrupt IRQ minus 256 (because the number of interrupt numbers is less than 224, subtracting 256 indicates that the kernel uses negative numbers to represent IRQ (refer to the section on Saving Registers for Interrupt Handlers in Chapter 4).
0x80 Exception (including sysenter)

This field contains the system call number (refer to the section on Entering and Exiting System Calls in Chapter 10).
Other Exceptions

This field is set to -1 (refer to the section on Saving Registers for Exception Handlers in Chapter 4).

Thus, a non-negative value in orig_eax indicates that the signal woke up a process that was sleeping in a system call (TASK_INTERRUPTIBLE). The service routine realizes that the system call has been interrupted and therefore returns one of the previously mentioned error codes.

3.1 Restarting System Calls Interrupted by Non-Caught Signals

For signals that are ignored or execute the default action, do_signal() analyzes the error codes of the system call to determine whether the system call should be automatically re-executed, as shown in Table 11-1. If the system call must be restarted, the regs context is modified:eip-2 indicates that the eip should point to int $0x80 or sysenter, while eax contains the system call number:

    if (regs->orig_eax >= 0) {
        if (regs->eax == -ERESTARTNOHAND || regs->eax == -ERESTARTSYS ||
                regs->eax == -ERESTARTNOINTR) {
            regs->eax = regs->orig_eax;
            regs->eip -= 2;
        }
        if (regs->eax == -ERESTART_RESTARTBLOCK) {
            regs->eax = __NR_restart_syscall;
            regs->eip -= 2;
        }
    }

regs->eax contains the return code of the system call service routine (refer to the section on Entering and Exiting System Calls in Chapter 10). Since both int $0x80 and sysenter instructions are two bytes long, eip-2 points to int $0x80 or sysenter, which can trigger the system call again.

The error code ERESTART_RESTARTBLOCK is special because eax is set to the system call number of restart_syscall(); therefore, the user will not restart the same system call that was interrupted by the signal. This error code is only used by time-related system calls, which should adjust their user mode parameters when restarted. A typical example is the nanosleep() system call (refer to the section on Dynamic Timers: nanosleep() System Call in Chapter 6): suppose the process calls it to pause execution for 20 milliseconds, and then a signal occurs after 10 milliseconds. If the system call is restarted as usual, the total delay time will exceed 30 milliseconds.

In contrast, if the nanosleep() system call service routine is interrupted, the address of a special service routine is filled into the current process’s thread_info structure’s restart_block field and returns the ERESTART_RESTARTBLOCK error code.sys_restart_syscall() service routine only executes the previous special service routine, calculating the time elapsed between the first call and the restart, thus adjusting the delay.

3.2 Restarting System Calls Interrupted by Caught Signals

If the signal requires capture handling, handle_signal() analyzes the error code and determines whether to restart based on the SA_RESTART flag in the sigaction:

    if (regs->orig_eax >= 0) {
        switch (regs->eax) {
            case -ERESTART_RESTARTBLOCK:
            case -ERESTARTNOHAND:
                regs->eax = -EINTR;
                break;
            case -ERESTARTSYS:
                if (!(ka->sa.sa_flags &amp; SA_RESTART)) {
                    regs->eax = -EINTR;
                    break;
                }
            /* fallthrough */
            case -ERESTARTNOINTR:
                regs->eax = regs->orig_eax;
                regs->eip -= 2;
        }
    }

If the system call must be restarted, the handling of handle_signal() is exactly the same as that of do_signal(); otherwise, it will return an -EINTR error code to the user process.

4 x86_64 Architecture – do_signal()

The Linux kernel version is v2.6.11, file location: arch/x86_64/kernel/signal.c:

/*
 * Note that init is a special process: it will not receive signals it does not want to handle. So, even if a `SIGKILL` signal is mistakenly sent to it, it will not be killed.
 */
int do_signal(struct pt_regs *regs, sigset_t *oldset) {
    struct k_sigaction ka;
    siginfo_t info;
    int signr;

    /* If not returning to user mode, return directly. */
    if ((regs->cs & 3) != 3) {
        return 1;
    }   

    // ... omitted

    if (!oldset)
        oldset = &amp;current->blocked;

    signr = get_signal_to_deliver(&amp;info, &amp;ka, regs, NULL);
    if (signr > 0) {
        /*
         * Restart all observation points before delivering the signal to user space.
         * If the observation point is triggered inside the kernel, the registers will be cleared.
         */
        if (current->thread.debugreg7)
            asm volatile("movq %0,%%db7"    : : "r" (current->thread.debugreg7));

        /* Deliver the signal */
        handle_signal(signr, &amp;info, &amp;ka, oldset, regs);
        return 1;
    }

no_signal:
    /* Is it a system call? */
    // ... omitted (see the handling in section 3.1)
    return 0;
}

x86-64 architecture’s handle_signal() function (file location: arch/x86_64/kernel/signal.c):

static void handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
        sigset_t *oldset, struct pt_regs *regs) {
    // ... omitted (debug signal info)

    // Omitted (handling of interrupted system calls)

    // Omitted (IA32_EMULATION configuration)

    setup_rt_frame(sig, ka, info, oldset, regs);

    if (!(ka->sa.sa_flags &amp; SA_NODEFER)) {
        spin_lock_irq(&amp;current->sighand-&gt;siglock);
        sigorsets(&amp;current->blocked,&amp;current->blocked,&amp;ka->sa.sa_mask);
        sigaddset(&amp;current->blocked,sig);
        recalc_sigpending();
        spin_unlock_irq(&amp;current->sighand-&gt;siglock);
    }
}

i386 architecture’s handle_signal() function (file location: arch/i386/kernel/signal.c):

static void handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
          sigset_t *oldset, struct pt_regs * regs) {
    // Omitted (handling of interrupted system calls)

    /* Set up the stack frame */
    if (ka->sa.sa_flags &amp; SA_SIGINFO)
        setup_rt_frame(sig, ka, info, oldset, regs);
    else
        setup_frame(sig, ka, oldset, regs);

    if (!(ka->sa.sa_flags &amp; SA_NODEFER)) {
        spin_lock_irq(&amp;current->sighand-&gt;siglock);
        sigorsets(&amp;current->blocked,&amp;current->blocked,&amp;ka->sa.sa_mask);
        sigaddset(&amp;current->blocked,sig);
        recalc_sigpending();
        spin_unlock_irq(&amp;current->sighand-&gt;siglock);
    }
}

static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
               sigset_t *set, struct pt_regs * regs) {
    struct rt_sigframe __user *frame;
    struct _fpstate __user *fp = NULL;
    int err = 0;
    struct task_struct *me = current;

    if (used_math()) {
        fp = get_stack(ka, regs, sizeof(struct _fpstate)); 
        frame = (void __user *)round_down((unsigned long)fp - sizeof(struct rt_sigframe), 16) - 8;

        if (!access_ok(VERIFY_WRITE, fp, sizeof(struct _fpstate))) { 
        goto give_sigsegv;
        }

        if (save_i387(fp) < 0) 
            err |= -1; 
    } else {
        frame = get_stack(ka, regs, sizeof(struct rt_sigframe)) - 8;
    }

    if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) {
        goto give_sigsegv;
    }

    if (ka->sa.sa_flags &amp; SA_SIGINFO) { 
        err |= copy_siginfo_to_user(&amp;frame->info, info);
        if (err) { 
            goto give_sigsegv;
    }
    }
        
    /* Create the ucontext.  */
    err |= __put_user(0, &amp;frame->uc.uc_flags);
    err |= __put_user(0, &amp;frame->uc.uc_link);
    err |= __put_user(me->sas_ss_sp, &amp;frame->uc.uc_stack.ss_sp);
    err |= __put_user(sas_ss_flags(regs->rsp),
              &amp;frame->uc.uc_stack.ss_flags);
    err |= __put_user(me->sas_ss_size, &amp;frame->uc.uc_stack.ss_size);
    err |= setup_sigcontext(&amp;frame->uc.uc_mcontext, regs, set->sig[0], me);
    err |= __put_user(fp, &amp;frame->uc.uc_mcontext.fpstate);
    if (sizeof(*set) == 16) { 
        __put_user(set->sig[0], &amp;frame->uc.uc_sigmask.sig[0]);
        __put_user(set->sig[1], &amp;frame->uc.uc_sigmask.sig[1]); 
    } else {        
    err |= __copy_to_user(&amp;frame->uc.uc_sigmask, set, sizeof(*set));
    }

    /* Set up to return from userspace.  If provided, use a stub
       already in userspace.  */
    /* x86-64 should always use SA_RESTORER. */
    if (ka->sa.sa_flags &amp; SA_RESTORER) {
        err |= __put_user(ka->sa.sa_restorer, &amp;frame->pretcode);
    } else {
        /* could use a vstub here */
        goto give_sigsegv; 
    }

    if (err) { 
        goto give_sigsegv;
    } 

#ifdef DEBUG_SIG
    printk("%d old rip %lx old rsp %lx old rax %lx\n", current->pid,regs->rip,regs->rsp,regs->rax);
#endif

    /* Set up registers for signal handler */
    { 
        struct exec_domain *ed = current_thread_info()->exec_domain;
        if (unlikely(ed &amp;&amp; ed->signal_invmap &amp;&amp; sig < 32))
            sig = ed->signal_invmap[sig];
    } 
    regs->rdi = sig;
    /* In case the signal handler was declared without prototypes */
    regs->rax = 0;  

    /* This also works for non SA_SIGINFO handlers because they expect the
       next argument after the signal number on the stack. */
    regs->rsi = (unsigned long)&amp;frame->info; 
    regs->rdx = (unsigned long)&amp;frame->uc; 
    regs->rip = (unsigned long) ka->sa.sa_handler;

    regs->rsp = (unsigned long)frame;

    set_fs(USER_DS);
    if (regs->eflags &amp; TF_MASK) {
        if ((current->ptrace &amp; (PT_PTRACED | PT_DTRACE)) == (PT_PTRACED | PT_DTRACE)) {
            ptrace_notify(SIGTRAP);
        } else {
            regs->eflags &amp;= ~TF_MASK;
        }
    }

#ifdef DEBUG_SIG
    printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
        current->comm, current->pid, frame, regs->rip, frame->pretcode);
#endif

    return;

give_sigsegv:
    force_sigsegv(sig, current);
}

All basic knowledge of C language and example codes organized by Yikou Jun are compiled into a PDF document 【Regularly Updated】

end

Yikou Linux

Follow, reply 【1024】 to receive a wealth of Linux materials

Collection of Wonderful Articles

Article Recommendations

☞【Collection】ARM☞【Collection】Fan Q&A☞【Collection】All Originals☞【Collection】LinuxIntroduction☞【Collection】Computer Networks☞【Collection】Linux Drivers☞【Essentials】Learning Path for Embedded Driver Engineers☞【Essentials】All Knowledge Points of Linux Embedded – Mind Map

1 Execute the Default Action of the Signal

2 Capture the Signal

2.1 Setting up the Frame

2.2 Calculating Signal Flags

2.3 Starting the Signal Handler

2.4 Terminating the Signal Handler

3 Re-execution of System Calls

3.1 Restarting System Calls Interrupted by Non-Caught Signals

3.2 Restarting System Calls Interrupted by Caught Signals

4 x86_64 Architecture – do_signal()

Related posts

Leave a Comment Cancel reply