Where do interrupts, events, and signals originate?

QUESTION

Does a hardware interrupt immediately become a userspace signal or epoll event?

STRUCTURE

Structure diagram

CALL PATH

Call path

SOURCE COORDINATES

Linux 6.18.37 LTS source locations

Go beyond the glibc function to the files where the syscall implementation meets kernel objects. Each link points to the original file at the same tag.

COMPLETE PROGRAM

Complete runnable example

The code below is not pseudocode with explanatory lines omitted. It is a minimal example that can be built and run as a file.

01#define _GNU_SOURCE
02#include <errno.h>
03#include <pthread.h>
04#include <signal.h>
05#include <stdint.h>
06#include <stdio.h>
07#include <sys/epoll.h>
08#include <sys/eventfd.h>
09#include <sys/signalfd.h>
10#include <sys/timerfd.h>
11#include <sys/wait.h>
12#include <time.h>
13#include <unistd.h>
14
15enum source_tag {
16    SOURCE_SIGNAL = 1,
17    SOURCE_TIMER,
18    SOURCE_EVENTFD
19};
20
21enum seen_bit {
22    SEEN_USR1  = 1U << 0,
23    SEEN_CHLD  = 1U << 1,
24    SEEN_TIMER = 1U << 2,
25    SEEN_EVENT = 1U << 3
26};
27
28static int add_source(int epfd, int fd, uint32_t tag)
29{
30    struct epoll_event event = {
31        .events = EPOLLIN,
32        .data.u32 = tag
33    };
34    return epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event);
35}
36
37static void *worker(void *argument)
38{
39    int event_fd = *(int *)argument;
40    struct timespec delay = { .tv_sec = 0, .tv_nsec = 150000000 };
41    uint64_t credit = 1;
42
43    nanosleep(&delay, NULL);
44    if (write(event_fd, &credit, sizeof(credit)) != sizeof(credit))
45        return (void *)1;
46    return NULL;
47}
48
49int main(void)
50{
51    sigset_t mask;
52    sigemptyset(&mask);
53    sigaddset(&mask, SIGUSR1);
54    sigaddset(&mask, SIGCHLD);
55    if (pthread_sigmask(SIG_BLOCK, &mask, NULL) != 0)
56        return 1;
57
58    int signal_fd = signalfd(-1, &mask, SFD_CLOEXEC | SFD_NONBLOCK);
59    int timer_fd = timerfd_create(CLOCK_MONOTONIC,
60                                  TFD_CLOEXEC | TFD_NONBLOCK);
61    int event_fd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
62    int epfd = epoll_create1(EPOLL_CLOEXEC);
63    if (signal_fd < 0 || timer_fd < 0 || event_fd < 0 || epfd < 0)
64        return 1;
65
66    struct itimerspec timer = {
67        .it_value = { .tv_sec = 0, .tv_nsec = 250000000 }
68    };
69    if (timerfd_settime(timer_fd, 0, &timer, NULL) < 0 ||
70        add_source(epfd, signal_fd, SOURCE_SIGNAL) < 0 ||
71        add_source(epfd, timer_fd, SOURCE_TIMER) < 0 ||
72        add_source(epfd, event_fd, SOURCE_EVENTFD) < 0)
73        return 1;
74
75    pid_t child = fork();
76    if (child < 0)
77        return 1;
78    if (child == 0)
79        _exit(42);
80
81    pthread_t thread;
82    if (pthread_create(&thread, NULL, worker, &event_fd) != 0)
83        return 1;
84    if (kill(getpid(), SIGUSR1) < 0)
85        return 1;
86
87    unsigned int seen = 0;
88    while (seen != (SEEN_USR1 | SEEN_CHLD | SEEN_TIMER | SEEN_EVENT)) {
89        struct epoll_event events[4];
90        int count = epoll_wait(epfd, events, 4, -1);
91        if (count < 0 && errno == EINTR)
92            continue;
93        if (count < 0)
94            return 1;
95
96        for (int i = 0; i < count; ++i) {
97            if (events[i].data.u32 == SOURCE_SIGNAL) {
98                for (;;) {
99                    struct signalfd_siginfo info;
100                    ssize_t n = read(signal_fd, &info, sizeof(info));
101                    if (n == (ssize_t)sizeof(info)) {
102                        printf("signal: signo=%u code=%d sender=%u\n",
103                               info.ssi_signo, info.ssi_code, info.ssi_pid);
104                        if (info.ssi_signo == SIGUSR1)
105                            seen |= SEEN_USR1;
106                        if (info.ssi_signo == SIGCHLD) {
107                            int status;
108                            if (waitpid(child, &status, 0) == child)
109                                printf("child: exit=%d\n", WEXITSTATUS(status));
110                            seen |= SEEN_CHLD;
111                        }
112                        continue;
113                    }
114                    if (n < 0 && errno == EAGAIN)
115                        break;
116                    return 1;
117                }
118            } else if (events[i].data.u32 == SOURCE_TIMER) {
119                uint64_t expirations;
120                if (read(timer_fd, &expirations, sizeof(expirations)) !=
121                    sizeof(expirations))
122                    return 1;
123                printf("timerfd: expirations=%llu\n",
124                       (unsigned long long)expirations);
125                seen |= SEEN_TIMER;
126            } else if (events[i].data.u32 == SOURCE_EVENTFD) {
127                uint64_t credits;
128                if (read(event_fd, &credits, sizeof(credits)) != sizeof(credits))
129                    return 1;
130                printf("eventfd: credits=%llu\n",
131                       (unsigned long long)credits);
132                seen |= SEEN_EVENT;
133            }
134        }
135    }
136
137    void *worker_result;
138    pthread_join(thread, &worker_result);
139    close(signal_fd);
140    close(timer_fd);
141    close(event_fd);
142    close(epfd);
143    return worker_result != NULL;
144}

CODE NOTES

Code notes

DETAILS

Detailed behavior

OBJECTS

Objects and lifetimes

FAILURE PATH

Failure conditions and common misconceptions

LAB

Verify it yourself

1. Run the example and record the arrival order of SIGUSR1, SIGCHLD, eventfd, and timerfd. The order is not guaranteed to be identical each time; verify that all four causes are observed through the same epoll_wait.
2. Call kill(getpid(), SIGUSR1) three times in a row and count signalfd records. After observing SIGUSR1 coalescing, switch to SIGRTMIN with a sigqueue payload and compare queue behavior.
3. Increase the worker's eventfd writes to three and delay the main read; verify that the returned counter is 3. Distinguish one readiness notification from three occurrences.
4. Set the timer interval to 10 ms and make main sleep for 200 ms, then compare accumulated timerfd expirations with POSIX signal-timer overrun reporting.
5. In strace -f output, confirm that kill does not appear as a write syscall to signal_fd and that signalfd read returns a separate record. Distinguish the generating syscall from the consuming fd.
6. Press Ctrl-C under stty -isig and stty isig and compare a 0x03 input byte with SIGINT generation. Record the foreground process group with tcgetpgrp as well.
7. Collect irq_handler_entry/exit, sched_wakeup, and sched_switch with perf trace or ftrace to separate the intervals between IRQ, wakeup, and userspace execution.
8. Create one thread that blocks SIGUSR1 and one that does not, then use signalfd/sigwaitinfo to compare the receiving thread for process-directed kill and pthread_kill.

PRIMARY REFERENCES

Primary sources