interrupt, event, signal은 어디서 시작되는가

QUESTION

하드웨어 interrupt가 곧바로 userspace signal이나 epoll event가 되는가?

STRUCTURE

구조 그림

CALL PATH

호출 흐름

SOURCE COORDINATES

Linux 6.18.37 LTS 소스 위치

glibc 함수에서 멈추지 않고 syscall 구현과 커널 객체가 만나는 파일까지 내려간다. 링크는 동일한 태그의 원본 파일을 가리킨다.

COMPLETE PROGRAM

실행 예제 원본

아래 코드는 설명을 위해 중간 줄을 생략한 의사 코드가 아니다. 파일로 빌드해 실행할 수 있는 최소 예제다.

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

코드 조각별 설명

DETAILS

세부 동작

OBJECTS

객체와 수명

FAILURE PATH

실패 조건과 오해하기 쉬운 부분

LAB

직접 확인

1. 예제를 실행해 SIGUSR1, SIGCHLD, eventfd, timerfd가 도착하는 순서를 기록한다. 순서는 매번 같다는 계약이 없지만 네 원인이 모두 같은 epoll_wait에서 관찰되는지 확인한다.
2. kill(getpid(), SIGUSR1)을 세 번 연속 호출하고 signalfd record 수를 센다. SIGUSR1 coalescing을 본 뒤 SIGRTMIN과 sigqueue payload로 바꿔 queue 차이를 비교한다.
3. worker의 eventfd write를 세 번으로 늘리고 main read를 늦춰 반환 counter가 3인지 확인한다. readiness 한 번과 사건 수 세 번을 구분한다.
4. timer interval을 10 ms로 만들고 main을 200 ms sleep시켜 timerfd read의 expiration 누적값과 POSIX signal timer의 overrun 표현을 비교한다.
5. strace -f 출력에서 kill은 signal_fd write syscall로 보이지 않으며, signalfd read가 별도 record를 반환하는지 확인한다. 생성 syscall과 소비 fd를 구분한다.
6. stty -isig 상태와 stty isig 상태에서 Ctrl-C를 입력해 0x03 byte 입력과 SIGINT 생성의 차이를 확인한다. foreground process group도 tcgetpgrp로 함께 기록한다.
7. perf trace 또는 ftrace의 irq_handler_entry/exit, sched_wakeup, sched_switch를 함께 수집해 IRQ, wakeup, userspace 실행 시각 사이의 구간을 나눈다.
8. SIGUSR1을 block한 thread와 unblocked thread를 각각 만들고 process-directed kill과 pthread_kill의 수신 thread 차이를 signalfd/sigwaitinfo로 확인한다.

PRIMARY REFERENCES

원문