타이머 (Timers)

jiffies, hrtimer, clocksource, clockevent, timer wheel, tickless 커널 등 Linux 커널의 시간 관리 체계를 설명합니다.

이 문서는 시간 측정(clocksource)과 이벤트 발생(clockevent), 그리고 커널 타이머 API(timer wheel, hrtimer)가 어떻게 결합되어 스케줄러(Scheduler)·네트워크·스토리지 경로의 지연(Latency) 특성을 결정하는지까지 다룹니다. 또한 NO_HZ 계열 설정, vDSO 기반 시간 읽기, delayed_work 선택 기준, watchdog과 lockup 탐지 로그 해석을 포함해 "정확도·전력·오버헤드(Overhead)" 사이의 균형을 시스템 목적에 맞게 조정하는 실무 관점을 제공합니다.

타이머 서브시스템의 정의와 역할

타이머 서브시스템은 커널이 시간의 흐름을 인식하고 미래 시점에 작업을 예약할 수 있게 하는 핵심 인프라입니다. 이 서브시스템이 없으면 프로세스 스케줄링, 네트워크 타임아웃, 디바이스 폴링, 슬립 등 시간 기반 동작이 모두 불가능합니다.

타이머 서브시스템은 크게 세 가지 계층으로 구성됩니다:

• 하드웨어 계층: TSC(Time Stamp Counter), HPET, Local APIC Timer 등 물리적 클럭 소스가 시간 측정과 인터럽트 생성을 담당합니다.
• 프레임워크 계층: clocksource(시간 읽기)와 clockevent(미래 인터럽트 예약)가 하드웨어를 추상화하여 플랫폼 독립적 인터페이스를 제공합니다.
• 타이머 API 계층: 커널 코드가 실제로 사용하는 timer_list(저해상도)와 hrtimer(고해상도) API입니다.

jiffies와 HZ

jiffies는 시스템 부팅 이후 발생한 타이머 틱(tick) 횟수를 저장하는 전역 변수입니다. HZ는 초당 틱 수를 나타내며, 일반적으로 x86에서는 250 (CONFIG_HZ_250)으로 설정됩니다. HZ 값의 선택은 타이머 해상도와 시스템 오버헤드 사이의 트레이드오프입니다 — HZ가 높을수록 타이머 정밀도가 향상되지만, 매 틱마다 인터럽트를 처리하므로 CPU 오버헤드가 증가합니다.

#include <linux/jiffies.h>

/* 현재 jiffies 값 */
unsigned long j = jiffies;

/* 시간 비교 (wraparound 안전) */
if (time_after(jiffies, timeout))
    pr_info("timeout expired\\n");

/* jiffies ↔ 시간 변환 */
unsigned long ms = jiffies_to_msecs(j);
unsigned long j2 = msecs_to_jiffies(500);  /* 500ms */

/* 64-bit jiffies (overflow 방지) */
u64 j64 = get_jiffies_64();

Timer Wheel (저해상도 타이머)

전통적인 커널 타이머는 struct timer_list를 사용하며, Timer Wheel 자료구조로 관리됩니다. 만료 시 softirq 컨텍스트(TIMER_SOFTIRQ)에서 콜백이 실행됩니다.

Timer Wheel 동작 원리

Timer Wheel은 계층적 해시 테이블(Hash Table)의 원리로 동작합니다. 핵심 아이디어는 "가까운 미래의 타이머는 정밀하게, 먼 미래의 타이머는 대략적으로 관리"하는 것입니다:

• 삽입(O(1)): 만료 시간의 비트 패턴에 따라 적절한 레벨과 슬롯을 즉시 결정합니다. 만료까지 남은 틱 수의 상위 비트가 레벨을, 하위 비트가 슬롯 인덱스를 결정합니다.
• 만료 처리: 매 틱마다 Level 0의 현재 슬롯만 확인합니다. Level 0이 한 바퀴 돌면(64 틱) Level 1의 한 슬롯에 있는 타이머들을 Level 0으로 재배치(cascade)합니다.
• 효율성: 대부분의 타이머가 Level 0에서 만료되므로, 상위 레벨의 cascade는 드물게 발생합니다. 이는 네트워크 타임아웃처럼 자주 설정/취소되는 타이머에 최적입니다.

#include <linux/timer.h>

static struct timer_list my_timer;

static void my_timer_callback(struct timer_list *t)
{
    pr_info("timer expired at jiffies=%lu\\n", jiffies);
    /* Reschedule for periodic timer */
    mod_timer(&my_timer, jiffies + msecs_to_jiffies(1000));
}

/* 초기화 및 시작 */
timer_setup(&my_timer, my_timer_callback, 0);
mod_timer(&my_timer, jiffies + msecs_to_jiffies(1000));

/* 해제 (동기적, 콜백 완료 대기) */
del_timer_sync(&my_timer);

Timer Wheel 5단계 내부 구조

커널 4.8+의 Timer Wheel은 5단계 계층(base[0]~base[4])으로 구성됩니다. 각 레벨은 64개 슬롯을 가지며, 상위 레벨로 갈수록 시간 해상도(granularity)가 8배씩 거칠어집니다. 이 설계를 통해 총 2³² 틱(HZ=250 기준 약 198일)까지 커버합니다.

Timer Wheel 슬롯(Bucket) 내부 구조

각 레벨의 64개 슬롯은 hlist_head로 구현되며, 동일 슬롯에 여러 타이머가 해시 리스트로 연결됩니다. 타이머 삽입 시 hlist_add_head()로 O(1) 삽입, 만료 시 hlist_move_list()로 전체 슬롯을 O(1)에 수집합니다.

Granularity 계산과 슬롯 결정

타이머가 삽입될 때 커널은 만료까지 남은 틱 수(delta)의 최상위 비트(MSB)를 검사하여 레벨을 결정합니다. 레벨 결정 후 해당 레벨의 granularity로 양자화된 슬롯 인덱스에 타이머를 삽입합니다:

/* kernel/time/timer.c - calc_wheel_index() 핵심 로직 */
static unsigned calc_wheel_index(unsigned long expires,
                                 unsigned long clk,
                                 unsigned long *bucket_expiry)
{
    unsigned long delta = expires - clk;
    unsigned int idx;

    if (delta < LVL_START(1)) {
        /* Level 0: delta < 64 ticks */
        idx = calc_index(expires, 0, bucket_expiry);
    } else if (delta < LVL_START(2)) {
        /* Level 1: 64 <= delta < 512 */
        idx = calc_index(expires, 1, bucket_expiry);
    } else if (delta < LVL_START(3)) {
        /* Level 2: 512 <= delta < 4096 */
        idx = calc_index(expires, 2, bucket_expiry);
    } else if (delta < LVL_START(4)) {
        /* Level 3: 4096 <= delta < 32768 */
        idx = calc_index(expires, 3, bucket_expiry);
    } else {
        /* Level 4: 32768 <= delta */
        idx = calc_index(expires, 4, bucket_expiry);
    }
    return idx;
}

/* 매크로 정의 (간략화) */
#define LVL_BITS     6                   /* 64 slots per level */
#define LVL_SIZE     (1 << LVL_BITS)      /* 64 */
#define LVL_SHIFT(n) ((n) * LVL_CLK_SHIFT) /* n * 3 (8배씩 증가) */
#define LVL_START(n) (LVL_SIZE << LVL_SHIFT(n))
/* LVL_START(1)=64, LVL_START(2)=512, LVL_START(3)=4096, LVL_START(4)=32768 */

calc_index() 내부 구현: 비트 시프트에 의한 양자화

calc_wheel_index()가 레벨을 결정한 후 호출하는 calc_index()는 실제로 슬롯 인덱스와 양자화된 만료 시각(bucket_expiry)을 계산하는 핵심 함수입니다. 이 함수의 동작을 이해하면 양자화 오차가 어디서, 얼마나, 왜 발생하는지 정확히 파악할 수 있습니다.

/* kernel/time/timer.c — calc_index() 실제 구현 (Linux 4.8+) */
#define LVL_CLK_SHIFT  3
#define LVL_SHIFT(n)   ((n) * LVL_CLK_SHIFT)  /* 0, 3, 6, 9, 12 */
#define LVL_GRAN(n)    (1UL << LVL_SHIFT(n))   /* 1, 8, 64, 512, 4096 */
#define LVL_MASK       (LVL_SIZE - 1)           /* 0x3F = 63 */
#define LVL_OFS(n)     ((n) * LVL_SIZE)         /* 0, 64, 128, 192, 256 */

static inline unsigned calc_index(
    unsigned long expires,         /* 원래 만료 시각 (jiffies) */
    unsigned int  lvl,              /* 선택된 레벨 (0~4) */
    unsigned long *bucket_expiry)   /* [출력] 양자화된 만료 시각 */
{
    /*
     * expires를 해당 레벨의 granularity로 오른쪽 시프트합니다.
     * 이것은 expires ÷ granularity 정수 나눗셈과 동일합니다.
     * 시프트 후 하위 6비트(& LVL_MASK)가 슬롯 인덱스가 됩니다.
     *
     * 예: Level 1 (LVL_SHIFT=3, granularity=8)
     *     expires = 100 → 100 >> 3 = 12 → 12 & 0x3F = 12
     *     슬롯 인덱스 = 64 + 12 = 76 (LVL_OFS(1) + 12)
     */
    unsigned long shifted = expires >> LVL_SHIFT(lvl);

    /*
     * bucket_expiry = 시프트된 값을 다시 왼쪽 시프트하여 복원합니다.
     * 이 과정에서 하위 비트가 잘려나가 양자화가 발생합니다.
     *
     * 예: expires=100, Level 1
     *     shifted = 100 >> 3 = 12
     *     bucket_expiry = 12 << 3 = 96  (원래 100이 96으로 절삭!)
     *     양자화 오차 = 100 - 96 = 4 ticks (16ms@250Hz, 4ms@1000Hz)
     */
    *bucket_expiry = shifted << LVL_SHIFT(lvl);

    /* 전체 벡터 배열 내 절대 인덱스 반환 */
    return LVL_OFS(lvl) + (shifted & LVL_MASK);
}

아래 수치 예제로 양자화 과정을 구체적으로 추적합니다. clk = 1000(현재 base->clk) 시점에서 다양한 expires 값이 어떤 레벨, 어떤 슬롯에 배치되고, 양자화 오차가 얼마인지 확인합니다.

Timer Wheel 호출 시간 오차 분석

Timer Wheel 타이머는 mod_timer()로 지정한 만료 시각과 실제 콜백 호출 시점 사이에 다양한 원인의 오차(Jitter)가 발생합니다. 커널 타이머의 근본 원칙은 "지정된 시점에 정확히 실행"이 아니라 "지정된 시점 이후 가능한 빨리 실행"이므로, 콜백은 항상 요청 시각보다 늦게 호출됩니다. 이 섹션에서는 오차를 유발하는 각 원인과 레벨별 최대 오차를 종합적으로 분석합니다.

(a) 양자화 오차(Quantization Error): calc_index()는 만료 시각을 오른쪽 비트 시프트(expires >> LVL_SHIFT(n))로 해당 레벨의 granularity 단위로 절삭(truncate)한 뒤, 왼쪽 시프트로 복원하여 bucket_expiry를 생성합니다. 이 과정에서 하위 LVL_SHIFT(n) 비트가 손실되어 양자화 오차가 발생합니다(상세 비트 연산 과정 참조). bucket_expiry ≤ expires가 항상 성립하므로 타이머가 일찍 실행되는 일은 없습니다. 최대 양자화 오차는 granularity - 1 ticks입니다. Level 0은 granularity가 1 tick이므로 양자화 오차가 0이지만, Level 4에서는 granularity가 4,096 ticks이므로 최대 4,095 ticks까지 오차가 발생합니다. 시간으로 환산하면 HZ=250에서는 ~16.4s, HZ=1000에서는 ~4.1s입니다. HZ가 높을수록 1 tick의 절대 시간이 짧아지므로 동일 레벨에서의 양자화 오차가 비례하여 감소합니다.

(b) softirq 처리 지연: Timer Wheel 콜백은 TIMER_SOFTIRQ 컨텍스트에서 실행됩니다. 타이머 틱 하드 인터럽트가 raise_softirq(TIMER_SOFTIRQ)를 호출한 후, 실제 __run_timers()가 실행되기까지 지연이 발생합니다. 일반적으로 수 마이크로초 수준이지만, 다른 softirq 핸들러(NET_RX_SOFTIRQ 등)가 먼저 실행되면 밀리초 단위로 늘어날 수 있습니다. 특히 __do_softirq()가 MAX_SOFTIRQ_TIME(2ms) 또는 MAX_SOFTIRQ_RESTART(10회) 한도를 초과하면, 나머지 처리를 ksoftirqd 커널 스레드에 위임합니다. ksoftirqd는 SCHED_OTHER 정책(nice 0)으로 동작하므로, CPU 부하가 높은 상황에서 수십 밀리초까지 스케줄링이 지연될 수 있습니다.

(c) NO_HZ/tickless 영향: NO_HZ 모드에서 idle CPU는 틱 인터럽트를 억제합니다. tick_nohz_idle_stop_tick()이 next_expiry 시점에 clockevent를 프로그래밍하므로, 정상적으로는 타이머 만료 시 CPU가 깨어납니다. 그러나 마지막 틱과 idle 진입 사이의 경합(Race) 구간에서 타이머가 삽입되면, 다른 CPU가 trigger_dyntick_cpu()로 IPI를 보내기 전까지 최대 1 tick(HZ=250에서 4ms, HZ=1000에서 1ms)의 추가 지연이 발생할 수 있습니다.

(d) TIMER_DEFERRABLE 추가 지연: TIMER_DEFERRABLE 플래그가 설정된 타이머는 BASE_DEF에 삽입되며, idle CPU를 깨우지 않습니다. CPU가 계속 idle 상태이면 다음 non-deferrable 이벤트(다른 타이머, 외부 인터럽트 등)가 발생할 때까지 콜백이 무기한 지연됩니다. idle 상태가 드문 서버에서는 영향이 적지만, 유휴 시간이 긴 임베디드 시스템에서는 수 분 이상 지연될 수 있습니다.

(e) PREEMPT_RT 스케줄링 지연: CONFIG_PREEMPT_RT 커널에서는 softirq가 전용 ksoftirqd/N 커널 스레드에서 항상 실행됩니다(일반 커널처럼 인터럽트 반환 경로에서 실행되지 않습니다). 이 스레드는 기본적으로 SCHED_OTHER 정책이므로, 높은 우선순위의 RT 태스크에 의해 선점되면 타이머 콜백 실행이 수 밀리초 이상 지연될 수 있습니다. chrt 명령으로 ksoftirqd의 우선순위를 높이면 이 지연을 줄일 수 있습니다.

(f) timer_slack_ns 영향: /proc/<pid>/timer_slack_ns는 유저스페이스 타이머(nanosleep(), select(), poll() 등)에 추가 여유 시간(slack)을 부여합니다. 커널 내부의 timer_list에는 직접 적용되지 않지만, hrtimer 기반의 유저스페이스 인터페이스에서 의도적 그룹핑(batching)을 유발하여 전력 효율을 높입니다. 기본값은 비-RT 프로세스에서 약 50µs이며, prctl(PR_SET_TIMERSLACK)으로 조정 가능합니다.

커널 버전별 Timer Wheel 오차 특성 변화: Timer Wheel의 내부 구조는 커널 역사에서 여러 차례 대폭 변경되었으며, 각 세대마다 오차의 성격과 크기가 다릅니다. 아래 표는 주요 커널 버전 구간별 Timer Wheel 구현 차이와 그에 따른 오차 특성을 요약합니다.

/* Pre-4.8 Cascading Timer Wheel 구조 (kernel/timer.c, Linux 2.6.x ~ 4.7) */
#define TVN_BITS  6                 /* 64 slots per upper level */
#define TVR_BITS  8                 /* 256 slots in level 0 */
#define TVN_SIZE  (1 << TVN_BITS)   /* 64 */
#define TVR_SIZE  (1 << TVR_BITS)   /* 256 */

struct tvec_base {
    spinlock_t       lock;
    struct timer_list *running_timer;
    unsigned long    timer_jiffies;     /* 현재 처리 중인 jiffies */
    struct tvec_root tv1;               /* Level 0: 256 slots (0~255 ticks) */
    struct tvec      tv2;               /* Level 1: 64 slots (256~16383 ticks) */
    struct tvec      tv3;               /* Level 2: 64 slots (~1M ticks) */
    struct tvec      tv4;               /* Level 3: 64 slots (~67M ticks) */
    struct tvec      tv5;               /* Level 4: 64 slots (~4G ticks) */
} ____cacheline_aligned;

/* cascade(): 상위 레벨 슬롯의 모든 타이머를 하위 레벨로 재배치 */
static int cascade(struct tvec_base *base,
                   struct tvec *tv, int index)
{
    struct list_head *head, *curr;
    head = tv->vec + index;
    /* 이 슬롯의 모든 타이머를 순회하며 재삽입 — O(n) */
    while (!list_empty(head)) {
        struct timer_list *timer;
        timer = list_first_entry(head, struct timer_list, entry);
        __internal_add_timer(base, timer);  /* 하위 레벨에 재삽입 */
    }
    return index;
}

struct timer_base 구현 분석

Timer Wheel의 핵심 자료구조인 struct timer_base는 Per-CPU로 할당되며, 모든 타이머 관리 상태를 캡슐화합니다. 커널 6.x에서의 실제 정의를 살펴봅니다.

/* kernel/time/timer.c — struct timer_base (Linux 6.x) */
struct timer_base {
    raw_spinlock_t     lock;           /* Per-CPU lock (IRQ 비활성화 필요) */
    struct timer_list  *running_timer;  /* 현재 콜백 실행 중인 타이머 */

    unsigned long      clk;            /* 현재 처리 중인 jiffies (≤ jiffies) */
    unsigned long      next_expiry;    /* 다음 만료 시각 (빠른 경로 최적화) */

    unsigned int       cpu;            /* 소속 CPU 번호 */
    bool               next_expiry_recalc; /* next_expiry 재계산 필요 플래그 */
    bool               is_idle;        /* CPU idle 상태 여부 */
    bool               timers_pending; /* 만료 대기 타이머 존재 */

    DECLARE_BITMAP(pending_map, WHEEL_SIZE);
                                        /* 5레벨×64슬롯=320비트 비트맵
                                         * 비트 1 = 해당 슬롯에 타이머 존재
                                         * find_next_bit()로 O(1) 만료 탐색 */
    struct hlist_head  vectors[WHEEL_SIZE];
                                        /* WHEEL_SIZE = 5×64 = 320 해시 버킷
                                         * 각 슬롯은 hlist(해시 리스트)로 타이머 연결 */
} ____cacheline_aligned;

/* Per-CPU 변수 선언 */
static DEFINE_PER_CPU(struct timer_base, timer_bases[NR_BASES]);
/* NR_BASES = 2: BASE_STD(일반) + BASE_DEF(deferrable) */

enqueue_timer() 내부 구현

타이머가 Timer Wheel에 삽입되는 실제 경로를 분석합니다. mod_timer() → __mod_timer() → enqueue_timer() 호출 체인으로 진행됩니다.

/* kernel/time/timer.c — enqueue_timer() (Linux 6.x, 간략화) */
static void enqueue_timer(struct timer_base *base,
                          struct timer_list *timer,
                          unsigned int idx,
                          unsigned long bucket_expiry)
{
    /* 1. 해당 슬롯의 해시 리스트에 타이머 추가 */
    hlist_add_head(&timer->entry, base->vectors + idx);

    /* 2. pending_map 비트맵 갱신 — 해당 슬롯 비트 ON */
    __set_bit(idx, base->pending_map);

    /* 3. next_expiry 갱신 — 더 빠른 만료가 추가되면 업데이트 */
    if (time_before(bucket_expiry, base->next_expiry)) {
        base->next_expiry = bucket_expiry;
        base->next_expiry_recalc = false;
        base->timers_pending = true;

        /* 4. idle 상태의 다른 CPU를 깨움 (NO_HZ 환경) */
        trigger_dyntick_cpu(base, timer);
    }
}

/* __mod_timer() — 타이머 삽입/변경의 핵심 경로 */
static inline int __mod_timer(struct timer_list *timer,
                              unsigned long expires, unsigned int options)
{
    struct timer_base *base;
    unsigned int idx;
    unsigned long clk, bucket_expiry;

    /* 이미 활성화된 타이머면 기존 슬롯에서 제거 */
    if (timer_pending(timer))
        detach_timer(timer, true);  /* hlist에서 제거 + pending_map 갱신 */

    base = lock_timer_base(timer, &flags);
    clk = base->clk;

    /* 레벨과 슬롯 인덱스 계산 */
    idx = calc_wheel_index(expires, clk, &bucket_expiry);
    timer->expires = expires;

    /* wheel에 삽입 */
    enqueue_timer(base, timer, idx, bucket_expiry);
    raw_spin_unlock_irqrestore(&base->lock, flags);
    return 0;
}

고해상도 타이머 (hrtimer)

hrtimer는 나노초 단위의 정밀한 타이머입니다. Timer Wheel 대신 red-black tree로 관리되며, 하드웨어 클럭 이벤트에 직접 프로그래밍합니다.

hrtimer 동작 원리

hrtimer가 Timer Wheel과 근본적으로 다른 점은 틱에 의존하지 않습니다는 것입니다:

• 자료구조: 모든 활성 hrtimer를 만료 시간 순으로 red-black tree에 정렬합니다. 가장 빨리 만료되는 타이머가 항상 leftmost 노드에 위치합니다.
• 하드웨어 프로그래밍: leftmost 타이머의 만료 시간을 clockevent 디바이스에 직접 설정합니다. 해당 시점에 하드웨어 인터럽트가 발생하여 콜백을 실행합니다.
• 재프로그래밍: 새 hrtimer가 삽입되어 leftmost가 바뀌면, clockevent를 즉시 재프로그래밍합니다.

이 방식은 Timer Wheel의 틱 해상도(1/HZ초 = 4ms@250Hz) 제약을 극복하여, 하드웨어가 지원하는 한 나노초 수준의 정밀도를 달성합니다. POSIX 타이머, nanosleep(), 스케줄러의 bandwidth throttling 등이 hrtimer를 기반으로 합니다.

#include <linux/hrtimer.h>
#include <linux/ktime.h>

static struct hrtimer my_hrtimer;

static enum hrtimer_restart my_hrtimer_callback(struct hrtimer *timer)
{
    pr_info("hrtimer fired!\\n");

    /* Periodic: restart after 10ms */
    hrtimer_forward_now(timer, ms_to_ktime(10));
    return HRTIMER_RESTART;

    /* One-shot: don't restart */
    /* return HRTIMER_NORESTART; */
}

/* 초기화 및 시작 */
hrtimer_init(&my_hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
my_hrtimer.function = my_hrtimer_callback;
hrtimer_start(&my_hrtimer, ms_to_ktime(10), HRTIMER_MODE_REL);

/* 취소 */
hrtimer_cancel(&my_hrtimer);

hrtimer 삽입 및 clockevent 재프로그래밍 내부

hrtimer_start() 호출 시 내부에서 실행되는 핵심 함수인 enqueue_hrtimer()와 hrtimer_reprogram()을 분석합니다. 이 두 함수가 hrtimer의 나노초 정밀도를 실현하는 핵심 메커니즘입니다.

/* kernel/time/hrtimer.c — enqueue_hrtimer() (Linux 6.x, 간략화) */
static void enqueue_hrtimer(struct hrtimer *timer,
                            struct hrtimer_clock_base *base,
                            enum hrtimer_mode mode)
{
    /* timerqueue(red-black tree)에 만료 시간순으로 삽입 */
    bool leftmost = timerqueue_add(&base->active, &timer->node);
    /* timerqueue_add():
     *   1. rb_add_cached()로 RB-tree에 삽입
     *   2. 삽입된 노드가 leftmost(가장 이른 만료)이면 true 반환
     *   3. leftmost 캐시 자동 갱신 (O(1) 접근 보장) */

    /* 타이머 상태를 ENQUEUED로 전환 */
    timer->state = HRTIMER_STATE_ENQUEUED;

    /* leftmost가 변경되었으면 clockevent 재프로그래밍 필요 */
    if (leftmost)
        base->cpu_base->softirq_expires_next = timer->node.expires;
}

/* kernel/time/hrtimer.c — hrtimer_reprogram() (Linux 6.x, 간략화) */
static void hrtimer_reprogram(struct hrtimer *timer,
                              bool reprogram)
{
    struct hrtimer_cpu_base *cpu_base = this_cpu_ptr(&hrtimer_bases);
    struct hrtimer_clock_base *base = timer->base;
    ktime_t expires = ktime_sub(
        hrtimer_get_expires(timer), base->offset);
                                /* 절대 시각 → monotonic 기준 변환 */

    /* 이미 만료된 시간이면 재프로그래밍 불필요 */
    if (ktime_before(expires, ktime_get()))
        return;

    /* 현재 설정된 다음 만료보다 더 이른 경우에만 재프로그래밍 */
    if (expires < cpu_base->expires_next) {
        cpu_base->expires_next = expires;

        /* clockevent 하드웨어에 새 만료 시각 프로그래밍 */
        tick_program_event(expires, 0);
        /* → clock_event_device->set_next_event()
         *   x86: APIC_TMICT 레지스터에 delta cycle 기록
         *   ARM64: CNTP_TVAL_EL0에 delta cycle 기록 */
    }
}

/* hrtimer_start() → __hrtimer_start_range_ns() 핵심 흐름 */
static void __hrtimer_start_range_ns(struct hrtimer *timer,
                                      ktime_t tim,
                                      u64 delta_ns,
                                      const enum hrtimer_mode mode,
                                      struct hrtimer_clock_base *base)
{
    /* 이미 활성화된 타이머면 먼저 제거 */
    remove_hrtimer(timer, base, true, false);

    /* soft range 설정 (timer slack) */
    hrtimer_set_expires_range_ns(timer, tim, delta_ns);

    /* RB-tree에 삽입 */
    enqueue_hrtimer(timer, base, mode);

    /* leftmost 변경 시 clockevent 재프로그래밍 */
    hrtimer_reprogram(timer, true);
}

hrtimer 레드블랙 트리(Red-Black Tree)와 timerqueue 구조

hrtimer는 내부적으로 struct timerqueue_head를 사용하여 Red-Black 트리에 타이머를 정렬합니다. timerqueue는 일반 rbtree에 leftmost 캐싱을 추가한 특수 자료구조로, 다음 만료 타이머를 O(1)에 접근할 수 있습니다.

/* include/linux/timerqueue.h - timerqueue 핵심 구조체 */
struct timerqueue_node {
    struct rb_node node;      /* RB-tree 노드 */
    ktime_t expires;           /* 만료 시각 (나노초) */
};

struct timerqueue_head {
    struct rb_root_cached rb_root; /* leftmost 캐싱된 RB-root */
};

/* include/linux/hrtimer.h - hrtimer 핵심 구조체 */
struct hrtimer {
    struct timerqueue_node node; /* timerqueue 노드 내장 */
    ktime_t _softexpires;        /* 소프트 만료 (range 하한) */
    enum hrtimer_restart (*function)(struct hrtimer *);
    struct hrtimer_clock_base *base;
    u8 state;                    /* HRTIMER_STATE_INACTIVE/ENQUEUED/CALLBACK */
    u8 is_rel;                   /* 상대 시간 여부 */
    u8 is_soft;                  /* softirq 모드 여부 */
    u8 is_hard;                  /* hardirq 모드 여부 */
};

/* hrtimer_clock_base: 클럭 베이스별 타이머 트리 */
struct hrtimer_clock_base {
    struct hrtimer_cpu_base *cpu_base;
    unsigned int index;          /* HRTIMER_BASE_MONOTONIC 등 */
    clockid_t clockid;           /* CLOCK_MONOTONIC 등 */
    seqcount_raw_spinlock_t seq;
    struct hrtimer *running;    /* 현재 실행 중인 타이머 */
    struct timerqueue_head active; /* 활성 타이머 RB-tree */
    ktime_t (*get_time)(void);  /* 시간 읽기 함수 */
    ktime_t offset;              /* 클럭 오프셋 */
};

hrtimer 클럭 베이스 4종

hrtimer는 4종의 클럭 베이스를 지원합니다. 각 클럭 베이스는 독립적인 timerqueue(RB-tree)를 유지하며, 사용 목적에 따라 적절한 클럭을 선택해야 합니다.

CLOCK_BOOTTIME과 CLOCK_MONOTONIC의 차이와 선택 기준

CLOCK_BOOTTIME과 CLOCK_MONOTONIC은 모두 단조 증가 클럭이지만, suspend/resume 시간 포함 여부에서 결정적으로 다릅니다. 이 차이를 무시하면 suspend 후 타이머가 의도와 다르게 동작하는 미묘한 버그가 발생합니다.

/* CLOCK_BOOTTIME vs CLOCK_MONOTONIC 커널 내부 차이 */

/* MONOTONIC: ktime_get() — suspend 시간 미포함 */
ktime_t now_mono = ktime_get();
/* 내부: tk->tkr_mono.base + cycles_to_ns(read_clocksource())
 * suspend 중에는 tkr_mono.base가 증가하지 않음 */

/* BOOTTIME: ktime_get_boottime() — suspend 시간 포함 */
ktime_t now_boot = ktime_get_boottime();
/* 내부: ktime_get() + tk->offs_boot
 * offs_boot는 resume 시 suspend 경과 시간만큼 증가
 * timekeeping_resume() → tk_update_sleep_time() */

/* 커널 드라이버에서 세션 타임아웃 구현 */
struct my_session {
    ktime_t start_time;
    ktime_t timeout;
};

void session_start(struct my_session *s)
{
    /* BOOTTIME 사용: suspend 중에도 시간 경과를 반영 */
    s->start_time = ktime_get_boottime();
    s->timeout = ktime_add_ms(s->start_time, 7200000); /* 2시간 */
}

bool session_expired(struct my_session *s)
{
    return ktime_after(ktime_get_boottime(), s->timeout);
}

/* hrtimer에서 BOOTTIME 클럭 사용 */
hrtimer_init(&my_timer, CLOCK_BOOTTIME, HRTIMER_MODE_REL);
/* → suspend 시간을 포함한 타이머, suspend 후에도 정확한 시점에 만료 */

/* timerfd에서 BOOTTIME 사용 (유저스페이스) */
int tfd = timerfd_create(CLOCK_BOOTTIME, TFD_NONBLOCK);
/* → suspend를 넘기는 타이머 FD */

clocksource와 clockevent

clocksource는 시간 측정용 하드웨어 클럭 추상화이고, clockevent는 미래 시점에 인터럽트를 발생시키는 하드웨어 타이머 추상화입니다. 대표적인 clocksource로 TSC, HPET, ACPI PM Timer, ARM Arch Timer가 있으며, clockevent는 LAPIC Timer, HPET, ARM Arch Timer가 담당합니다.

struct clocksource 핵심 필드

struct clocksource(include/linux/clocksource.h)는 하드웨어 카운터를 나노초로 변환하는 모든 정보를 캡슐화합니다.

/* include/linux/clocksource.h */
struct clocksource {
    u64   (*read)(struct clocksource *cs);  /* HW 카운터 읽기 */
    u64   mask;           /* 카운터 비트마스크 (예: TSC=~0ULL, HPET=0xFFFFFFFF) */
    u32   mult;           /* cycle→ns 곱셈 인수 */
    u32   shift;          /* cycle→ns 비트 시프트 */
    u32   max_idle_ns;    /* idle 시 최대 허용 ns (overflow 방지) */
    u32   maxadj;         /* NTP 최대 주파수 조정 범위 */
    int   rating;         /* 품질 등급 (높을수록 우선) */
    unsigned long flags;   /* CLOCK_SOURCE_IS_CONTINUOUS 등 */
    const char *name;
    struct list_head list; /* clocksource_list 연결 */
};
/* cycle → ns 변환: ns = (cycles * mult) >> shift
 * mult/shift는 clocksource_register_hz()가 자동 계산 */

struct clock_event_device 핵심 필드

/* include/linux/clockchips.h */
struct clock_event_device {
    void  (*event_handler)(struct clock_event_device *);
                            /* 핸들러: tick_handle_periodic 또는 hrtimer_interrupt */
    int   (*set_next_event)(unsigned long evt,
                            struct clock_event_device *);
                            /* delta cycle 단위로 다음 인터럽트 설정 */
    int   (*set_next_ktime)(ktime_t expires,
                            struct clock_event_device *);
                            /* 절대 ktime으로 설정 (옵션) */
    unsigned int features;  /* PERIODIC | ONESHOT | C3STOP 등 */
    int          rating;    /* clocksource와 같은 스케일 */
    u32          mult, shift; /* ns→cycle 변환 (clocksource 반대 방향) */
    ktime_t      min_delta_ticks;  /* 프로그래밍 최소 간격 */
    ktime_t      max_delta_ticks;  /* 프로그래밍 최대 간격 */
    const char  *name;
    int          irq;
    enum clock_event_state state_use_accessors;
                            /* DETACHED, SHUTDOWN, PERIODIC, ONESHOT */
};
#define CLOCK_EVT_FEAT_PERIODIC  0x01  /* 주기적 모드 */
#define CLOCK_EVT_FEAT_ONESHOT   0x02  /* 원샷 모드 (hrtimer 필수) */
#define CLOCK_EVT_FEAT_KTIME    0x04  /* set_next_ktime() 지원 */
#define CLOCK_EVT_FEAT_C3STOP   0x08  /* C3+에서 정지 → broadcast 필요 */

clocksource 등록과 선택 흐름

/* kernel/time/clocksource.c — 등록 핵심 경로 */
int clocksource_register_hz(struct clocksource *cs, u32 hz)
{
    return __clocksource_register_scale(cs, 1, hz);
}

static int __clocksource_register_scale(struct clocksource *cs,
                                        u32 scale, u32 freq)
{
    clocks_calc_mult_shift(&cs->mult, &cs->shift,
                           freq, NSEC_PER_SEC / scale, 3600);
    cs->max_idle_ns = clocksource_max_deferment(cs);
    clocksource_enqueue(cs);       /* rating순 정렬 리스트에 삽입 */
    clocksource_enqueue_watchdog(cs); /* watchdog 검증 등록 */
    clocksource_select();            /* 최적 clocksource 선택 */
}

/* 최적 선택: clocksource_list는 rating 내림차순
 * 리스트 헤드 = 최고 rating → timekeeping_notify() → tk_core 교체 */

/* clockevent 등록 */
void clockevents_register_device(struct clock_event_device *dev)
{
    list_add(&dev->list, &clockevent_devices);
    tick_check_new_device(dev);
    /* → tick_setup_device() → ONESHOT 지원 시 hrtimer 전환 */
}

# 현재 clocksource/clockevent 확인
cat /sys/devices/system/clocksource/clocksource0/current_clocksource
# tsc
cat /sys/devices/system/clocksource/clocksource0/available_clocksource
# tsc hpet acpi_pm

# clocksource 수동 변경 (디버깅용)
echo hpet > /sys/devices/system/clocksource/clocksource0/current_clocksource

# 초기화 로그 확인
dmesg | grep -iE "clocksource|clockevent|tsc|hpet"

지연 함수 (Delay Functions)

커널은 컨텍스트에 따라 다양한 지연 함수를 제공합니다. 인터럽트 컨텍스트에서는 busy-wait(udelay(), ndelay())만 사용 가능하고, 프로세스 컨텍스트에서는 슬립 기반(usleep_range(), msleep())을 권장합니다. 잘못된 선택은 CPU 낭비(busy-wait 과용), 스케줄링 미작동(인터럽트 컨텍스트에서 sleep), 우선순위 역전 등의 문제를 유발합니다.

지연 함수 비교표

udelay() 내부 구현

udelay()는 컴파일 타임 상수 여부에 따라 경로가 달라집니다. 상수 인자일 때는 __const_udelay()를 통해 루프 횟수를 컴파일 타임에 결정하고, 동적 값일 때는 __udelay()를 호출합니다. 두 경로 모두 내부적으로 loops_per_jiffy를 기준으로 보정된 루프를 실행하며, TSC(Time Stamp Counter)를 지원하는 아키텍처에서는 더 정밀한 TSC 기반 구현으로 대체될 수 있습니다.

/* include/linux/delay.h (요약) */
#define udelay(n)                                    \
  (__builtin_constant_p(n)                          \
   ? ((n) > 20000 ? __bad_udelay()                 \
              : __const_udelay((n) * 0x10c7ul))   \
   : __udelay(n))

/* arch/x86/lib/delay.c (요약) */
void __const_udelay(unsigned long xloops)
{
    unsigned long lpj = this_cpu_read(cpu_info.loops_per_jiffy);
    __delay(xloops * lpj >> 32);  /* 보정된 루프 실행 */
}

중요 제약: udelay()에 2000 µs를 초과하는 값을 전달하면 오버플로가 발생할 수 있습니다. 긴 busy-wait이 필요한 경우에는 mdelay()를 사용해야 합니다.

usleep_range() 내부 경로

usleep_range(min, max)는 프로세스 컨텍스트 전용 슬립 함수입니다. min/max 범위를 지정하는 이유는 hrtimer 만료 시점의 타이밍을 커널이 유연하게 조절하여 타이머 뭉침(timer coalescing)을 줄이고 에너지 효율을 높이기 위해서입니다.

/* kernel/time/sleep_timeout.c (요약) */
void usleep_range(unsigned long min, unsigned long max)
{
    do_usleep_range(min, max, TASK_UNINTERRUPTIBLE);
}

static void do_usleep_range(u64 min, u64 max, unsigned int state)
{
    ktime_t kmin = ns_to_ktime(min * NSEC_PER_USEC);
    ktime_t kmax = ns_to_ktime(max * NSEC_PER_USEC);
    hrtimer_nanosleep(kmin, kmax, state, CLOCK_MONOTONIC);
}

msleep() 내부 경로

msleep()은 jiffy 단위 정밀도로 동작하는 저수준 슬립입니다. 내부적으로 schedule_timeout_uninterruptible()을 호출하여 태스크를 TASK_UNINTERRUPTIBLE 상태로 전환하고 timer_list 기반 타이머를 설정합니다. 시그널로 깨어날 필요가 있다면 msleep_interruptible()을 사용해야 합니다.

/* kernel/time/sleep_timeout.c (요약) */
void msleep(unsigned int msecs)
{
    unsigned long timeout = msecs_to_jiffies(msecs) + 1;
    while (timeout)
        timeout = schedule_timeout_uninterruptible(timeout);
}

unsigned long msleep_interruptible(unsigned int msecs)
{
    unsigned long timeout = msecs_to_jiffies(msecs) + 1;
    while (timeout && !signal_pending(current))
        timeout = schedule_timeout_interruptible(timeout);
    return jiffies_to_msecs(timeout);
}

fsleep() 통합 API

fsleep()은 리눅스 5.10에 도입된 통합 지연 API입니다. 지연 시간 범위에 따라 최적의 내부 함수를 자동으로 선택하므로, 호출자가 컨텍스트와 범위를 직접 판단할 필요 없이 단일 인터페이스를 사용할 수 있습니다.

/* include/linux/delay.h */
static inline void fsleep(unsigned long usecs)
{
    if (usecs <= 10)              /* < 10 µs: busy-wait */
        udelay(usecs);
    else if (usecs <= 20000)      /* 10 µs ~ 20 ms: hrtimer sleep */
        usleep_range(usecs, usecs * 2);
    else                          /* > 20 ms: jiffy-based sleep */
        msleep(DIV_ROUND_UP(usecs, 1000));
}

지연 함수 선택 결정 트리

컨텍스트별 사용 예

#include <linux/delay.h>

/* 인터럽트 핸들러: busy-wait만 허용 */
static irqreturn_t my_irq_handler(int irq, void *dev)
{
    ndelay(500);       /* 500 ns 대기 (레지스터 안정화) */
    udelay(10);        /* 10 µs busy-wait */
    return IRQ_HANDLED;
}

/* 커널 스레드: sleep 가능 */
static int my_kthread(void *data)
{
    while (!kthread_should_stop()) {
        /* 정밀한 짧은 대기: hrtimer 기반 */
        usleep_range(1000, 1100);   /* 1~1.1 ms */

        /* 긴 대기: jiffy 기반, 인터럽트 불가 */
        msleep(100);                  /* 100 ms */

        /* 통합 API: 범위 자동 선택 */
        fsleep(5000);                 /* 5000 µs → usleep_range 경로 */
    }
    return 0;
}

/* 드라이버 probe: 시그널 인터럽트 가능한 슬립 */
static int my_probe(struct platform_device *pdev)
{
    unsigned long remaining;

    remaining = msleep_interruptible(200);
    if (remaining) {
        /* 시그널로 깨어남: 남은 시간 = remaining ms */
        return -EINTR;
    }
    return 0;
}

Tickless 커널 (NO_HZ)

전통적인 커널은 매 tick(1/HZ초)마다 타이머 인터럽트를 발생시켰지만, tickless 커널은 불필요한 tick을 제거하여 전력 소모를 줄입니다.

Tickless 동작 원리

Tickless의 핵심 원리는 "다음에 해야 할 일이 없으면 깨우지 않습니다"입니다:

1. CPU가 idle에 진입하기 전, 다음으로 만료될 타이머(Timer Wheel + hrtimer)의 시간을 확인합니다.
2. 그 시간까지 주기적 틱 인터럽트를 중단하고, 대신 하나의 oneshot clockevent만 해당 시점에 프로그래밍합니다.
3. CPU는 깊은 C-state(저전력 상태)에 진입하여 전력을 절약합니다.
4. 타이머 만료 시점에 clockevent 인터럽트가 CPU를 깨우고, 밀린 jiffies를 한꺼번에 보정합니다.

tick_nohz_idle_stop_tick() 구현 분석

Tickless 커널의 핵심인 tick_nohz_idle_stop_tick()은 CPU가 idle에 진입할 때 호출되어, 주기 tick을 중단하고 다음 타이머 만료 시점에만 인터럽트를 프로그래밍합니다.

/* kernel/time/tick-sched.c — tick_nohz_idle_stop_tick() (Linux 6.x, 간략화) */
static void tick_nohz_idle_stop_tick(void)
{
    struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
    ktime_t expires;
    int cpu = smp_processor_id();

    /* 1. 다음 만료 타이머 시각 조회 (Timer Wheel + hrtimer 통합) */
    expires = tick_nohz_next_event(ts, cpu);
    /* tick_nohz_next_event() 내부:
     *   - timer_base->next_expiry (Timer Wheel 최소 만료)
     *   - hrtimer_get_next_event() (hrtimer RB-tree leftmost)
     *   - 두 값 중 더 이른 쪽을 반환 */

    /* 2. 다음 이벤트까지 시간이 충분하지 않으면 tick 유지 */
    if (ktime_before(expires,
                     ktime_add_ns(ktime_get(), TICK_NSEC))) {
        /* 1 tick 미만 남음 → 주기 tick 유지가 더 효율적 */
        return;
    }

    /* 3. 주기 tick 중단 — oneshot 모드 전환 */
    ts->tick_stopped = 1;
    ts->idle_sleeptime_seq++;

    /* 4. clockevent를 다음 만료 시각으로 프로그래밍 */
    tick_program_event(expires, 1);
    /* → set_next_event()로 HW 타이머에 만료 시각 설정
     * expires가 KTIME_MAX면 clockevent 정지 (완전 무tick) */

    /* 5. 통계 갱신 */
    ts->idle_expires = expires;
    ts->idle_entrytime = ktime_get();
}

/* idle 복귀 시 — tick_nohz_idle_restart_tick() */
static void tick_nohz_idle_restart_tick(struct tick_sched *ts,
                                         ktime_t now)
{
    /* jiffies를 idle 기간만큼 보정 */
    tick_nohz_update_jiffies(now);

    /* 주기 tick 복원 */
    ts->tick_stopped = 0;
    hrtimer_cancel(&ts->sched_timer);
    tick_setup_sched_timer(false);
    /* 스케줄러 tick hrtimer 재설정 → 주기적 tick 복원 */
}

NO_HZ idle 진입/탈출 시 타이머 재프로그래밍 흐름

NO_HZ idle 진입과 탈출 과정에서 clockevent 하드웨어의 재프로그래밍이 어떤 순서로 이루어지는지 전체 흐름을 분석합니다. 이 과정은 타이머 정확도와 전력 효율의 핵심 경로입니다.

ktime API

ktime_t는 나노초 단위의 시간을 표현하는 64비트 통일 타입입니다. ktime_get()(monotonic), ktime_get_real()(wall clock), ktime_get_boottime()(suspend 포함) 등 다양한 시간 읽기 함수와 산술 연산 매크로(Macro)를 제공합니다.

ktime_t 내부 표현

ktime_t는 단순한 64비트 부호 있는 정수(signed 64-bit integer)로, 각 클럭 기준에 따라 에포크(epoch)로부터의 나노초 값을 저장합니다.

/* include/linux/ktime.h */
typedef s64 ktime_t;

/* 클럭 기준별 에포크 */
/* CLOCK_MONOTONIC   : 시스템 부팅 이후 경과 나노초 (suspend 제외) */
/* CLOCK_REALTIME    : 1970-01-01 00:00:00 UTC 이후 경과 나노초   */
/* CLOCK_BOOTTIME    : 시스템 부팅 이후 경과 나노초 (suspend 포함) */
/* CLOCK_TAI         : TAI 기준 나노초 (윤초 보정 없음)           */

/* 유효 범위: ±292년 (s64 나노초) */
KTIME_MAX     = 9223372036854775807LL   /* s64 최대값 */
KTIME_MIN     = -9223372036854775808LL  /* s64 최소값 */
KTIME_SEC_MAX = (KTIME_MAX / NSEC_PER_SEC)

시간 읽기 함수 내부 경로

각 ktime_get_*() 함수는 공통적으로 하드웨어 클럭소스(clocksource)를 읽은 뒤 mult/shift 변환을 통해 나노초로 환산하고, 클럭 종류에 따라 오프셋(offset)을 더합니다.

/* kernel/time/timekeeping.c — 단순화된 내부 경로 */

/* 1단계: 하드웨어 카운터 읽기 + mult/shift 변환 */
static u64 timekeeping_get_ns(const struct tk_read_base *tkr)
{
    u64 delta = timekeeping_get_delta(tkr);    /* clocksource.read() */
    return timekeeping_delta_to_ns(tkr, delta);  /* (delta * mult) >> shift */
}

/* ktime_get(): CLOCK_MONOTONIC (오프셋 없음) */
ktime_t ktime_get(void)
{
    return ktime_add_ns(tk->ktime_sec,
                        timekeeping_get_ns(&tk->tkr_mono));
}

/* ktime_get_real(): CLOCK_REALTIME = monotonic + wall_to_monotonic */
ktime_t ktime_get_real(void)
{
    return ktime_add(ktime_get(), tk->offs_real);
}

/* ktime_get_boottime(): CLOCK_BOOTTIME = monotonic + suspend 누적 */
ktime_t ktime_get_boottime(void)
{
    return ktime_add(ktime_get(), tk->offs_boot);
}

/* ktime_get_raw(): NTP/adjtime 보정 없이 raw 하드웨어 값 반환 */
ktime_t ktime_get_raw(void)
{
    return ktime_add_ns(tk->ktime_sec_raw,
                        timekeeping_get_ns(&tk->tkr_raw));
}

변환 함수 및 매크로

커널은 ktime_t와 다른 시간 단위 간 변환을 위한 인라인(inline) 함수를 제공합니다.

산술 및 비교 연산

ktime_t는 s64 별칭이므로 단순 덧셈·뺄셈도 동작하지만, 커널은 가독성과 오버플로 방지를 위해 전용 헬퍼(helper) 함수를 제공합니다.

/* 산술 연산 */
ktime_t ktime_add(ktime_t kt1, ktime_t kt2);       /* kt1 + kt2 */
ktime_t ktime_sub(ktime_t lhs, ktime_t rhs);       /* lhs - rhs */
ktime_t ktime_add_ns(ktime_t kt, u64 ns);          /* kt + ns */
ktime_t ktime_sub_ns(ktime_t kt, u64 ns);          /* kt - ns */
ktime_t ktime_add_us(ktime_t kt, u64 us);          /* kt + us*1,000 */
ktime_t ktime_add_ms(ktime_t kt, u64 ms);          /* kt + ms*1,000,000 */
ktime_t ktime_add_safe(ktime_t lhs, ktime_t rhs);   /* 오버플로 시 KTIME_MAX 반환 */

/* 비교 연산 */
bool ktime_before(ktime_t cmp1, ktime_t cmp2);   /* cmp1 < cmp2 이면 true */
bool ktime_after(ktime_t cmp1, ktime_t cmp2);    /* cmp1 > cmp2 이면 true */
int  ktime_compare(ktime_t cmp1, ktime_t cmp2);  /* -1 / 0 / 1 반환 */
bool ktime_equal(ktime_t cmp1, ktime_t cmp2);    /* cmp1 == cmp2 이면 true */

경과 시간 측정 패턴

커널 코드에서 특정 구간의 수행 시간을 나노초 단위로 측정할 때 가장 많이 쓰이는 패턴입니다.

#include <linux/ktime.h>
#include <linux/timekeeping.h>

static void measure_elapsed_example(void)
{
    ktime_t start, end;
    s64     elapsed_ns, elapsed_us, elapsed_ms;

    /* 시작 시각 캡처 (CLOCK_MONOTONIC 기반) */
    start = ktime_get();

    /* 측정 대상 작업 */
    do_some_work();

    /* 종료 시각 캡처 */
    end = ktime_get();

    /* 경과 시간 계산 */
    elapsed_ns = ktime_to_ns(ktime_sub(end, start));
    elapsed_us = ktime_to_us(ktime_sub(end, start));
    elapsed_ms = ktime_to_ms(ktime_sub(end, start));

    pr_info("elapsed: %lld ns / %lld us / %lld ms\n",
            elapsed_ns, elapsed_us, elapsed_ms);
}

/* 더 간결한 패턴: ktime_get_ns() 사용 */
static void measure_ns_example(void)
{
    u64 start_ns = ktime_get_ns();  /* ktime_to_ns(ktime_get()) 래퍼 */

    do_some_work();

    pr_info("elapsed: %llu ns\n", ktime_get_ns() - start_ns);
}

/* 벽시계 기준 측정이 필요한 경우 */
static void measure_realtime_example(void)
{
    ktime_t t1 = ktime_get_real();

    do_some_work();

    pr_info("wall elapsed: %lld ns\n",
            ktime_to_ns(ktime_sub(ktime_get_real(), t1)));
}

POSIX 타이머 (유저스페이스)

커널은 유저스페이스 POSIX 타이머를 hrtimer 기반으로 구현합니다. timer_create() 시스템 콜로 생성한 타이머는 커널 내부에서 struct k_itimer로 관리되며, 만료 시 시그널(Signal)을 통해 사용자 프로세스에 통지합니다.

POSIX 클럭 ID

/* 주요 클럭 ID (include/uapi/linux/time.h) */
CLOCK_REALTIME             /* 벽시계 (NTP 조정 가능, 점프 가능) */
CLOCK_MONOTONIC            /* 단조 증가 (NTP 주파수만 조정) */
CLOCK_BOOTTIME             /* MONOTONIC + suspend 시간 포함 */
CLOCK_PROCESS_CPUTIME_ID   /* 프로세스 CPU 시간 */
CLOCK_THREAD_CPUTIME_ID    /* 스레드 CPU 시간 */
CLOCK_REALTIME_ALARM       /* REALTIME + suspend 시 웨이크업 */
CLOCK_BOOTTIME_ALARM       /* BOOTTIME + suspend 시 웨이크업 */
CLOCK_TAI                  /* 국제원자시 (윤초 없음) */

struct k_itimer와 커널 내부 경로

유저스페이스의 timer_create() 호출은 커널에서 struct k_itimer를 할당하고, 내부적으로 hrtimer를 초기화하여 연결합니다.

/* kernel/time/posix-timers.c — 커널 내부 구조 */
struct k_itimer {
    struct list_head    list;        /* 프로세스의 타이머 리스트 */
    timer_t             it_id;       /* 유저스페이스 timer_t ID */
    int                 it_clock;    /* CLOCK_REALTIME 등 */
    int                 it_sigev_notify; /* SIGEV_SIGNAL, SIGEV_THREAD_ID 등 */
    struct signal_struct *it_signal; /* 시그널 전달 대상 프로세스 */
    union {
        struct {
            struct hrtimer   timer;    /* 핵심: 내장된 hrtimer */
            ktime_t         interval; /* 주기적 타이머 간격 */
        } real;
        /* CPU 타이머용 union 멤버도 존재 */
    } it;
    int                 it_overrun;    /* 누적 overrun 횟수 */
    int                 it_overrun_last; /* 이전 overrun 값 */
};

/* timer_create() syscall → do_timer_create() 핵심 흐름 */
static int do_timer_create(clockid_t which_clock,
                           struct sigevent *event, timer_t *id)
{
    struct k_itimer *new_timer = alloc_posix_timer();
    new_timer->it_clock = which_clock;
    new_timer->it_sigev_notify = event->sigev_notify;

    /* hrtimer 초기화 — clockid에 맞는 클럭 베이스에 연결 */
    hrtimer_init(&new_timer->it.real.timer, which_clock, HRTIMER_MODE_ABS);
    new_timer->it.real.timer.function = posix_timer_fn;
    /* ... ID 할당, 프로세스 타이머 리스트에 추가 */
}

/* posix_timer_fn() — hrtimer 만료 콜백 */
static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
{
    struct k_itimer *timr = container_of(timer,
                                struct k_itimer, it.real.timer);
    /* 시그널 전달 (SIGEV_SIGNAL: kill_pid_info 등) */
    posix_timer_event(timr);

    /* 주기적 타이머: interval이 0이 아니면 재시작 */
    if (timr->it.real.interval) {
        timr->it_overrun += hrtimer_forward_now(timer,
                                timr->it.real.interval);
        return HRTIMER_RESTART;
    }
    return HRTIMER_NORESTART;
}

timerfd — 파일 디스크립터 기반 타이머

timerfd는 시그널 대신 파일 디스크립터(FD)를 통해 타이머 만료를 통지하는 현대적 API입니다. epoll()/select()/poll()로 다른 I/O 이벤트와 함께 대기할 수 있어 이벤트 루프(Event Loop) 기반 아키텍처에 적합합니다.

/* 유저스페이스 timerfd 사용 예제 */
#include <sys/timerfd.h>
#include <sys/epoll.h>

int tfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);

struct itimerspec its = {
    .it_value    = { .tv_sec = 1, .tv_nsec = 0 },    /* 1초 후 첫 만료 */
    .it_interval = { .tv_sec = 0, .tv_nsec = 500000000 } /* 500ms 주기 */
};
timerfd_settime(tfd, 0, &its, NULL);

/* epoll에 등록하여 다른 FD와 함께 대기 */
struct epoll_event ev = { .events = EPOLLIN, .data.fd = tfd };
epoll_ctl(epfd, EPOLL_CTL_ADD, tfd, &ev);

/* 만료 시 read()로 overrun 카운트 읽기 */
uint64_t expirations;
read(tfd, &expirations, sizeof(expirations));
/* expirations = 1 (정상), > 1이면 overrun 발생 */

/* fs/timerfd.c — timerfd 커널측 핵심 구현 (Linux 6.x, 간략화) */

struct timerfd_ctx {
    union {
        struct hrtimer   tmr;    /* 내장 hrtimer */
        struct alarm    alarm;  /* CLOCK_REALTIME_ALARM용 */
    } t;
    ktime_t                  tintv;   /* 주기 간격 (0이면 one-shot) */
    ktime_t                  moffs;   /* REALTIME 오프셋 보정 */
    wait_queue_head_t        wqh;     /* epoll/read 대기 큐 */
    u64                      ticks;   /* 누적 만료 횟수 (overrun) */
    int                      clockid; /* CLOCK_MONOTONIC 등 */
    unsigned                 settime_flags; /* TFD_TIMER_ABSTIME 등 */
};

/* hrtimer 만료 콜백 — timerfd의 핵심 */
static enum hrtimer_restart timerfd_tmrproc(struct hrtimer *hrtimer)
{
    struct timerfd_ctx *ctx = container_of(hrtimer,
        struct timerfd_ctx, t.tmr);

    ctx->ticks++;   /* overrun 카운트 증가 */

    /* wait queue에서 대기 중인 epoll/read를 깨움 */
    wake_up_locked_poll(&ctx->wqh, EPOLLIN);

    /* 주기적 타이머면 자동 재시작 */
    if (ctx->tintv)
        return HRTIMER_RESTART;
    return HRTIMER_NORESTART;
}

/* read() 시스템 콜 → timerfd_read() */
static ssize_t timerfd_read(struct file *file,
                             char __user *buf,
                             size_t count, loff_t *ppos)
{
    struct timerfd_ctx *ctx = file->private_data;
    u64 ticks;

    /* 만료될 때까지 대기 (nonblock이면 -EAGAIN) */
    if (!ctx->ticks) {
        if (file->f_flags & O_NONBLOCK)
            return -EAGAIN;
        wait_event_interruptible(ctx->wqh, ctx->ticks);
    }

    /* overrun 카운트 읽고 리셋 */
    ticks = ctx->ticks;
    ctx->ticks = 0;

    /* 주기적: 다음 만료 시각 forward */
    if (ctx->tintv)
        hrtimer_forward_now(&ctx->t.tmr, ctx->tintv);

    /* 8바이트 uint64_t로 overrun 카운트 반환 */
    return put_user(ticks, (u64 __user *)buf) ? -EFAULT :
                    sizeof(u64);
}

타이머 마이그레이션과 그룹핑

전력 효율을 위해 커널은 여러 타이머를 같은 시점에 만료되도록 그룹핑합니다:

/* 타이머를 "느슨하게" 설정하면 커널이 그룹핑 가능 */
mod_timer(&timer, jiffies + msecs_to_jiffies(1000));

/* timer_setup_on_stack: 스택 기반 타이머 (짧은 수명) */

/* sysctl 파라미터 */
/* /proc/sys/kernel/timer_migration = 1 */
/* idle CPU의 타이머를 busy CPU로 마이그레이션 */
/* → idle CPU가 더 오래 슬립 가능 (전력 절약) */

매 틱(Tick) 처리 체인

타이머 인터럽트(tick)가 발생하면 커널은 tick_handle_periodic() 또는 hrtimer_interrupt()를 통해 여러 서브시스템에 시간 경과를 알립니다. 이 과정에서 jiffies 갱신, 프로세스 CPU 시간 계정, 스케줄러 시간 슬라이스 검사, 저해상도 타이머 처리 등이 순차적으로 수행됩니다.

/* kernel/time/tick-common.c — periodic 모드 핸들러 */
void tick_handle_periodic(struct clock_event_device *dev)
{
    int cpu = smp_processor_id();
    ktime_t next = dev->next_event;

    tick_periodic(cpu);

    /* oneshot 모드: 다음 tick을 직접 프로그래밍 */
    if (dev->state_use_accessors == CLOCK_EVT_STATE_ONESHOT) {
        next = ktime_add_ns(next, TICK_NSEC);
        clockevents_program_event(dev, next, 0);
    }
}

/* tick_periodic() 내부 */
static void tick_periodic(int cpu)
{
    if (tick_do_timer_cpu == cpu) {
        raw_spin_lock(&jiffies_lock);
        do_timer(1);        /* jiffies_64++, timekeeping_advance() */
        raw_spin_unlock(&jiffies_lock);
        update_wall_time(); /* tk_core 벽시계 갱신 */
    }
    update_process_times(user_mode(get_irq_regs()));
    profile_tick(CPU_PROFILING);
}

/* update_process_times() — 매 tick의 핵심 */
void update_process_times(int user_tick)
{
    struct task_struct *p = current;

    /* 1. CPU 시간 계정: user/system/irq/softirq 시간 누적 */
    account_process_tick(p, user_tick);

    /* 2. 저해상도 타이머 + hrtimer softirq 트리거 */
    run_local_timers();

    /* 3. RCU grace period 추적 */
    rcu_sched_clock_irq(user_tick);

    /* 4. 스케줄러 틱: vruntime 갱신, 선점 검사 */
    scheduler_tick();

    /* 5. perf 이벤트 업데이트 */
    if (IS_ENABLED(CONFIG_PERF_EVENTS))
        perf_event_task_tick();
}

Timer 콜백 실행 흐름

저해상도 타이머(timer_list)와 고해상도 타이머(hrtimer)는 각각 다른 경로로 콜백을 실행합니다. 저해상도 타이머는 TIMER_SOFTIRQ를 통해, 고해상도 타이머는 hrtimer_interrupt()를 통해 처리됩니다.

__run_timers() 흐름 (저해상도)

/* kernel/time/timer.c - __run_timers() 핵심 로직 (간략화) */
static inline void __run_timers(struct timer_base *base)
{
    struct hlist_head heads[LVL_DEPTH];
    int levels;

    if (time_before(jiffies, base->next_expiry))
        return;   /* 아직 만료된 타이머 없음 */

    raw_spin_lock_irq(&base->lock);

    /* base->clk를 jiffies까지 전진시키며 만료 타이머 수집 */
    while (time_after_eq(jiffies, base->clk) &&
           (levels = collect_expired_timers(base, heads))) {
        /* 상위 레벨 타이머를 하위로 cascade + 만료 타이머 수집 */
        base->clk++;
        expire_timers(base, heads);
    }

    base->running_timer = NULL;
    raw_spin_unlock_irq(&base->lock);
}

/* expire_timers: 수집된 타이머의 콜백 실행 */
static void expire_timers(struct timer_base *base,
                          struct hlist_head *head)
{
    while (!hlist_empty(head)) {
        struct timer_list *timer;
        void (*fn)(struct timer_list *);

        timer = hlist_entry(head->first, struct timer_list, entry);
        base->running_timer = timer;
        fn = timer->function;

        raw_spin_unlock_irq(&base->lock);
        fn(timer);           /* 콜백 실행 (lock 해제 상태) */
        raw_spin_lock_irq(&base->lock);
    }
}

collect_expired_timers()와 pending_map 비트맵 최적화

__run_timers()가 만료 타이머를 수집할 때, 320개 슬롯을 모두 순회하면 비효율적입니다. 커널은 pending_map 비트맵과 find_next_bit()을 사용하여, 타이머가 존재하는 슬롯만 O(1)에 찾아 처리합니다.

/* kernel/time/timer.c — collect_expired_timers() (Linux 6.x, 간략화) */
static int collect_expired_timers(struct timer_base *base,
                                  struct hlist_head *heads)
{
    unsigned long clk = base->clk;
    struct hlist_head *vec;
    int i, levels = 0;
    unsigned int idx;

    /* 현재 clk에서 각 레벨의 해당 슬롯 검사 */
    for (i = 0; i < LVL_DEPTH; i++) {
        /* clk에서 이 레벨의 슬롯 인덱스 계산 */
        idx = (clk & LVL_MASK) + i * LVL_SIZE;
        /* LVL_MASK = 0x3F (64-1), LVL_SIZE = 64
         * Level 0: idx = clk & 0x3F        (0~63)
         * Level 1: idx = 64 + (clk>>3 & 0x3F)  (64~127)
         * Level 2: idx = 128 + (clk>>6 & 0x3F) (128~191) ... */

        /* pending_map에서 해당 슬롯에 타이머 존재 확인 */
        if (!test_bit(idx, base->pending_map))
            continue;  /* 이 슬롯 비어있음 → 스킵 */

        vec = base->vectors + idx;

        /* 해당 슬롯의 모든 타이머를 수집 리스트로 이동 */
        hlist_move_list(vec, heads + levels);
        levels++;

        /* 슬롯이 비었으면 pending_map 비트 클리어 */
        __clear_bit(idx, base->pending_map);

        clk >>= LVL_CLK_SHIFT;  /* 상위 레벨로 (÷8) */
    }

    return levels;
}

/* next_expiry 계산 — find_next_bit()으로 O(1) 탐색 */
static unsigned long __next_timer_interrupt(
    struct timer_base *base)
{
    unsigned long clk, next = NEXT_TIMER_MAX_DELTA;
    unsigned int idx, bit;
    int lvl;

    clk = base->clk;

    for (lvl = 0; lvl < LVL_DEPTH; lvl++, clk >>= LVL_CLK_SHIFT) {
        unsigned int pos = clk & LVL_MASK;
        unsigned int start = pos + lvl * LVL_SIZE;

        /* 이 레벨에서 다음 비트가 세팅된 슬롯 탐색 */
        bit = find_next_bit(base->pending_map,
                            start + LVL_SIZE, start);
        /* find_next_bit(): 비트맵에서 start부터
         * 가장 가까운 1-비트 위치를 O(word_size)에 반환
         * → 320개 슬롯 순회 대신 비트 연산으로 탐색 */

        if (bit < start + LVL_SIZE) {
            /* 이 레벨에서 타이머 발견 → 만료 시각 계산 */
            unsigned long expires = clk + (bit - start);
            if (time_before(expires, next))
                next = expires;
        }
    }

    return next;
}

hrtimer_interrupt() 흐름 (고해상도)

hrtimer_interrupt()는 clockevent 인터럽트 핸들러(Handler)에서 직접 호출됩니다. 하드 IRQ 컨텍스트에서 만료된 hrtimer의 콜백을 실행하며, 처리 후 다음 만료 시각으로 clockevent를 재프로그래밍합니다.

/* kernel/time/hrtimer.c - hrtimer_interrupt() 핵심 로직 (간략화) */
void hrtimer_interrupt(struct clock_event_device *dev)
{
    struct hrtimer_cpu_base *cpu_base = this_cpu_ptr(&hrtimer_bases);
    ktime_t now = ktime_get();
    ktime_t expires_next;
    int i;

    cpu_base->in_hrtirq = 1;

    /* 모든 클럭 베이스 순회 */
    for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
        struct hrtimer_clock_base *base = &cpu_base->clock_base[i];
        struct timerqueue_node *node;

        while ((node = timerqueue_getnext(&base->active))) {
            struct hrtimer *timer = container_of(node, struct hrtimer, node);

            if (node->expires > now)
                break;  /* 아직 만료 안 됨 */

            __remove_hrtimer(timer, base, HRTIMER_STATE_INACTIVE, 0);
            __run_hrtimer(cpu_base, base, timer, &basenow, flags);
        }
    }

    /* 다음 만료 시각 계산 후 clockevent 재프로그래밍 */
    expires_next = hrtimer_update_next_event(cpu_base);
    tick_program_event(expires_next, 1);

    cpu_base->in_hrtirq = 0;
}

/* __run_hrtimer: 개별 hrtimer 콜백 실행 */
static void __run_hrtimer(struct hrtimer_cpu_base *cpu_base,
                          struct hrtimer_clock_base *base,
                          struct hrtimer *timer, ...)
{
    enum hrtimer_restart (*fn)(struct hrtimer *);
    fn = timer->function;

    base->running = timer;
    raw_write_seqcount_barrier(&base->seq);

    /* 콜백 실행 (RESTART면 다시 enqueue) */
    if (fn(timer) == HRTIMER_RESTART)
        enqueue_hrtimer(timer, base, HRTIMER_MODE_ABS);

    base->running = NULL;
}

Timer Softirq (TIMER_SOFTIRQ) 처리 상세

TIMER_SOFTIRQ는 softirq 벡터 0번으로, 저해상도 타이머의 만료를 처리합니다. 이 softirq는 매 tick마다 run_local_timers()에서 raise되며, do_softirq() 경로에서 run_timer_softirq()로 처리됩니다.

/* kernel/time/timer.c - softirq 등록 */
void __init init_timers(void)
{
    init_timer_cpus();
    open_softirq(TIMER_SOFTIRQ, run_timer_softirq);
}

/* run_timer_softirq: TIMER_SOFTIRQ 핸들러 */
static void run_timer_softirq(struct softirq_action *h)
{
    struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]);
    __run_timers(base);

    /* deferrable 타이머도 처리 (idle이 아닐 때만) */
    if (!tick_nohz_full_cpu(smp_processor_id())) {
        base = this_cpu_ptr(&timer_bases[BASE_DEF]);
        __run_timers(base);
    }
}

/* run_local_timers: 매 tick마다 호출 */
void run_local_timers(void)
{
    struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]);

    hrtimer_run_queues();  /* 저해상도 모드일 때 hrtimer도 처리 */

    if (time_after_eq(jiffies, base->next_expiry) ||
        time_after_eq(jiffies, this_cpu_read(timer_bases[BASE_DEF].next_expiry)))
        raise_softirq(TIMER_SOFTIRQ);
}

RTC (Real-Time Clock) 서브시스템

RTC는 시스템 전원이 꺼져 있을 때도 배터리로 유지되는 하드웨어 시계입니다. 커널은 부팅 시 RTC에서 시간을 읽어 시스템 시계를 초기화하고, RTC 알람으로 시스템을 깨울 수 있습니다.

RTC 아키텍처

RTC 드라이버 구현

#include <linux/rtc.h>

/* RTC 오퍼레이션 구조체 */
static const struct rtc_class_ops my_rtc_ops = {
    .read_time  = my_read_time,     /* 현재 시각 읽기 */
    .set_time   = my_set_time,      /* 시각 설정 */
    .read_alarm = my_read_alarm,    /* 알람 읽기 */
    .set_alarm  = my_set_alarm,     /* 알람 설정 */
    .alarm_irq_enable = my_alarm_irq_enable,
};

/* 시간 읽기 콜백 */
static int my_read_time(struct device *dev, struct rtc_time *tm)
{
    /* H/W 레지스터에서 BCD 또는 바이너리로 읽기 */
    tm->tm_sec  = readl(base + RTC_SEC);
    tm->tm_min  = readl(base + RTC_MIN);
    tm->tm_hour = readl(base + RTC_HOUR);
    tm->tm_mday = readl(base + RTC_DAY);
    tm->tm_mon  = readl(base + RTC_MON) - 1;  /* 0-based */
    tm->tm_year = readl(base + RTC_YEAR) - 1900;
    return 0;
}

/* RTC 디바이스 등록 */
struct rtc_device *rtc = devm_rtc_device_register(&pdev->dev,
    "my-rtc", &my_rtc_ops, THIS_MODULE);

/* 또는 현대적 API (5.x+) */
rtc = devm_rtc_allocate_device(&pdev->dev);
rtc->ops = &my_rtc_ops;
rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
rtc->range_max = RTC_TIMESTAMP_END_2099;
devm_rtc_register_device(rtc);

유저 공간 RTC 관리

# RTC 시간 읽기
hwclock --show                 # /dev/rtc0에서 읽기
cat /sys/class/rtc/rtc0/time   # sysfs에서 읽기
cat /proc/driver/rtc           # CMOS RTC 상세 정보 (x86)

# RTC에 시스템 시간 쓰기
hwclock --systohc              # 시스템 시간 → RTC
hwclock --hctosys              # RTC → 시스템 시간 (부팅 시)

# UTC vs Local Time (주의!)
hwclock --systohc --utc        # RTC를 UTC로 설정 (Linux 권장)
hwclock --systohc --localtime  # 로컬 시간 (Windows 듀얼부팅 시)
timedatectl set-local-rtc 0    # systemd에서 UTC 모드 설정

# RTC 알람 설정 (시스템 웨이크업)
echo +60 > /sys/class/rtc/rtc0/wakealarm     # 60초 후 깨우기
echo 0 > /sys/class/rtc/rtc0/wakealarm       # 알람 해제
rtcwake -m mem -s 300          # suspend 후 300초 뒤 깨우기

CMOS RTC 레지스터 상세

CMOS RTC 전체 레지스터 맵

Status Register A 비트 필드 (0x0A)

Status Register B 비트 필드 (0x0B)

CMOS RTC 인터럽트 종류

/* drivers/rtc/rtc-cmos.c — CMOS RTC 인터럽트 핸들러 */

/*
 * CMOS RTC는 IRQ 8을 통해 3가지 인터럽트를 생성합니다:
 * 1. Periodic Interrupt (PIE): RS 비트로 설정된 주파수 (2-8192 Hz)
 * 2. Alarm Interrupt (AIE): 설정된 알람 시각 도달
 * 3. Update-ended Interrupt (UIE): 매초 시간 업데이트 완료
 *
 * Status Register C를 읽어 어떤 인터럽트인지 확인합니다.
 * (읽으면 플래그가 자동 클리어됨)
 */

static irqreturn_t cmos_interrupt(int irq, void *p)
{
    struct cmos_rtc *cmos = p;
    u8 irqstat;

    spin_lock(&rtc_lock);
    /* Status C 읽기: IRQ 원인 확인 + 플래그 클리어 */
    irqstat = CMOS_READ(RTC_INTR_FLAGS);  /* 0x0C */
    irqstat &= (CMOS_READ(RTC_CONTROL)   /* 0x0B */
                & (RTC_PIE|RTC_AIE|RTC_UIE));
    spin_unlock(&rtc_lock);

    if (irqstat) {
        /* rtc-core에 이벤트 보고 */
        rtc_update_irq(cmos->rtc, 1, irqstat);
        return IRQ_HANDLED;
    }
    return IRQ_NONE;
}

/* RTC 시간 읽기 — UIP 비트 확인 필수 */
static int cmos_read_time(struct device *dev, struct rtc_time *t)
{
    unsigned char ctrl;

    spin_lock_irq(&rtc_lock);

    /* UIP=1이면 업데이트 중 — 최대 244μs 대기 */
    while (CMOS_READ(RTC_FREQ_SELECT) & RTC_UIP)
        cpu_relax();

    t->tm_sec  = CMOS_READ(RTC_SECONDS);   /* 0x00 */
    t->tm_min  = CMOS_READ(RTC_MINUTES);   /* 0x02 */
    t->tm_hour = CMOS_READ(RTC_HOURS);     /* 0x04 */
    t->tm_mday = CMOS_READ(RTC_DAY_OF_MONTH); /* 0x07 */
    t->tm_mon  = CMOS_READ(RTC_MONTH);     /* 0x08 */
    t->tm_year = CMOS_READ(RTC_YEAR);      /* 0x09 */

    ctrl = CMOS_READ(RTC_CONTROL);        /* 0x0B */
    spin_unlock_irq(&rtc_lock);

    /* BCD → 바이너리 변환 (DM 비트 확인) */
    if (!(ctrl & RTC_DM_BINARY)) {
        t->tm_sec  = bcd2bin(t->tm_sec);
        t->tm_min  = bcd2bin(t->tm_min);
        t->tm_hour = bcd2bin(t->tm_hour);
        t->tm_mday = bcd2bin(t->tm_mday);
        t->tm_mon  = bcd2bin(t->tm_mon);
        t->tm_year = bcd2bin(t->tm_year);
    }
    t->tm_mon--;  /* 커널: 0-based month */
    t->tm_year += (t->tm_year < 70) ? 100 : 0;  /* 2000+ 보정 */
    return 0;
}

NTP ↔ RTC 동기화

/* kernel/time/ntp.c — NTP → RTC 주기적 동기화 */

/*
 * CONFIG_RTC_SYSTOHC 설정 시 커널이 11분마다
 * 시스템 시간을 RTC에 기록하여 동기화합니다.
 *
 * 이 메커니즘은 NTP로 보정된 정확한 시스템 시간을
 * RTC에 반영하여, 다음 부팅 시 시간 오차를 최소화합니다.
 */

static void sync_hw_clock(struct work_struct *work)
{
    /* RTC 동기화 조건:
     * 1. NTP가 시간을 동기화한 상태 (STA_UNSYNC 해제)
     * 2. 잔여 보정량이 0.5초 이내
     * 3. 초 값이 정확한 시점 (0.5초 경계) */

    struct timespec64 now;
    ktime_get_real_ts64(&now);

    /* 0.5초 경계에서 RTC에 쓰기 (정수 초 정확도 보장) */
    if (now.tv_nsec >= (NSEC_PER_SEC >> 1))
        now.tv_sec++;

    struct rtc_time tm;
    rtc_time64_to_tm(now.tv_sec, &tm);
    rtc_set_time(rtc, &tm);
}

/* 11분 주기 타이머 — sync_cmos_clock() */
/* schedule_delayed_work(&sync_work, 660 * HZ); */

RTC sysfs 인터페이스

# /sys/class/rtc/rtc0/ 전체 파일 목록
$ ls /sys/class/rtc/rtc0/
date          # 현재 날짜 (YYYY-MM-DD)
hctosys       # 부팅 시 이 RTC에서 시간을 읽었는지 (1/0)
max_user_freq # 유저 공간 최대 periodic 주파수 (기본: 64)
name          # RTC 이름 (예: "rtc_cmos")
offset        # 보정 오프셋 (ppb 단위)
since_epoch   # Unix epoch 이후 초
time          # 현재 시각 (HH:MM:SS)
wakealarm     # 웨이크업 알람 (epoch 또는 +N초)

# /proc/driver/rtc 출력 해석 (x86 CMOS RTC 전용)
$ cat /proc/driver/rtc
rtc_time        : 14:30:25       # 현재 RTC 시간
rtc_date        : 2026-02-26     # 현재 RTC 날짜
rtc_epoch       : 1900           # epoch 기준 연도
alarm           : 00:00:00       # 알람 시각
alarm_IRQ       : no             # 알람 IRQ 활성 여부
alrm_date       : 2026-02-26    # 알람 날짜
update_IRQ      : no             # 매초 업데이트 IRQ
periodic_IRQ    : no             # periodic IRQ
periodic_freq   : 1024           # periodic 주파수 (Hz)
batt_status     : okay           # 배터리 상태 (VRT 비트)
24hr            : yes            # 24시간 모드
BCD             : yes            # BCD 모드

RTC 주의사항

delayed_work — 지연 실행 작업

delayed_work는 timer_list와 workqueue를 결합한 API입니다. timer_list로 지정한 시간 후에 workqueue(kworker 스레드)에 작업을 등록하므로, 타이머 콜백과 달리 프로세스 컨텍스트에서 실행됩니다. 슬립, mutex 잠금, 메모리 할당(GFP_KERNEL) 등이 모두 허용됩니다.

#include <linux/workqueue.h>
#include <linux/jiffies.h>

struct my_dev {
    struct delayed_work poll_work;  /* delayed_work 선언 */
    void __iomem *base;
};

/* workqueue 핸들러 — 프로세스 컨텍스트에서 실행 */
static void my_poll_handler(struct work_struct *work)
{
    struct delayed_work *dwork = to_delayed_work(work);
    struct my_dev *dev = container_of(dwork, struct my_dev, poll_work);

    /* 프로세스 컨텍스트: mutex, kmalloc(GFP_KERNEL), msleep() 가능 */
    u32 status = readl(dev->base + STATUS_REG);

    if (status & BUSY_BIT) {
        /* 아직 바쁨: 100ms 후 재시도 */
        schedule_delayed_work(&dev->poll_work, msecs_to_jiffies(100));
    } else {
        pr_info("device ready\n");
    }
}

/* 초기화 */
INIT_DELAYED_WORK(&dev->poll_work, my_poll_handler);

/* 200ms 후 실행 예약 */
schedule_delayed_work(&dev->poll_work, msecs_to_jiffies(200));

/* 특정 workqueue에 예약 (기본 system_wq 대신) */
queue_delayed_work(my_wq, &dev->poll_work, msecs_to_jiffies(200));

/* 취소 — 동기적으로 진행 중인 작업 완료까지 대기 */
cancel_delayed_work_sync(&dev->poll_work);

/* 재예약 (pending이면 취소 후 재등록) */
mod_delayed_work(system_wq, &dev->poll_work, msecs_to_jiffies(500));

커널 Watchdog — Lockup 감지

커널 watchdog은 CPU가 장기간 응답하지 않는 lockup 상태를 자동으로 감지합니다. softlockup과 hardlockup 두 종류가 있으며, 각각 다른 타이머 메커니즘을 사용합니다.

Softlockup vs Hardlockup

# watchdog 설정 확인
cat /proc/sys/kernel/watchdog           # 1=활성화
cat /proc/sys/kernel/watchdog_thresh    # 임계값 (기본 10, softlockup=2배=20초)
cat /proc/sys/kernel/softlockup_panic   # 1이면 softlockup 시 패닉
cat /proc/sys/kernel/hardlockup_panic   # 1이면 hardlockup 시 패닉

# watchdog 비활성화 (테스트/디버깅용)
echo 0 > /proc/sys/kernel/watchdog

# 임계값 변경 (20초 → 30초로 완화)
echo 15 > /proc/sys/kernel/watchdog_thresh   # softlockup=30초, hardlockup=15초

# softlockup 로그 (dmesg 출력 예시)
# [12345.678] watchdog: BUG: soft lockup - CPU#3 stuck for 22s! [my_task:4567]
# [12345.679] Modules linked in: ...                                          
# [12345.680] CPU: 3 PID: 4567 Comm: my_task Not tainted 6.1.0 #1            

# 커널 부트 파라미터로 watchdog 설정
# nosoftlockup   — softlockup 감지 비활성화
# nohlt          — halt 명령 대신 idle 루프 (전력 절약 비활성화)

watchdog_timer_fn() 구현 분석

Softlockup 감지의 핵심인 watchdog_timer_fn()은 Per-CPU hrtimer 콜백으로, 주기적으로 watchdog/N kthread가 정상 스케줄링되는지 확인합니다.

/* kernel/watchdog.c — watchdog_timer_fn() (Linux 6.x, 간략화) */
static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
{
    unsigned long touch_ts, now;
    struct rq *rq = this_rq();
    int duration;
    int softlockup_all_cpu_backtrace =
        sysctl_softlockup_all_cpu_backtrace;

    /* 1. hardlockup 감지용 카운터 증가
     *    NMI watchdog가 이 카운터를 모니터링 */
    watchdog_interrupt_count();
    /* __this_cpu_inc(hrtimer_interrupts);
     * NMI 핸들러에서 이 값이 변하지 않으면 hardlockup으로 판단 */

    /* 2. watchdog kthread의 마지막 실행 시각 조회 */
    touch_ts = __this_cpu_read(watchdog_touch_ts);
    now = get_timestamp();  /* sched_clock() 기반 */

    /* 3. watchdog kthread가 스케줄링되었으면 → 정상 */
    if (touch_ts == SOFTLOCKUP_RESET) {
        __this_cpu_write(watchdog_touch_ts, now);
        goto reprogram;
    }

    /* 4. 마지막 실행 후 경과 시간 계산 */
    duration = now - touch_ts;

    /* 5. watchdog_thresh * 2 초 초과 → softlockup 감지 */
    if (duration >= get_softlockup_thresh()) {
        /* watchdog_thresh 기본=10, softlockup 임계=20초 */
        pr_emerg("BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",
                 smp_processor_id(), duration,
                 current->comm, task_pid_nr(current));

        /* 스택 트레이스 출력 */
        dump_stack();

        /* softlockup_panic이 설정되었으면 패닉 */
        if (softlockup_panic)
            panic("softlockup: hung tasks");
    }

reprogram:
    /* 6. hrtimer 재프로그래밍 (watchdog_thresh/5 간격) */
    hrtimer_forward_now(hrtimer,
        ns_to_ktime(sample_period));
    /* sample_period = watchdog_thresh * (NSEC_PER_SEC / 5)
     * watchdog_thresh=10이면 2초 간격 */
    return HRTIMER_RESTART;
}

/* watchdog kthread — 스케줄링되면 타임스탬프 갱신 */
static int watchdog_kthread_fn(void *data)
{
    while (!kthread_should_stop()) {
        set_current_state(TASK_INTERRUPTIBLE);

        /* hrtimer 콜백이 깨워줌 → 타임스탬프 갱신 */
        __this_cpu_write(watchdog_touch_ts, SOFTLOCKUP_RESET);

        schedule();
    }
    return 0;
}

타이머 디버깅 및 분석

타이머 서브시스템 문제(지터, 지연, 불필요한 wake-up 등)를 진단하는 도구와 기법을 설명합니다.

/proc/timer_list 출력 해석 가이드

/proc/timer_list는 모든 CPU의 활성 hrtimer와 timer_list를 덤프(Dump)합니다. 출력을 정확히 해석하면 타이머 지연, 불필요한 wakeup, 만료 타이밍 문제를 진단할 수 있습니다.

# 전체 타이머 목록 보기
cat /proc/timer_list

# 출력 예시:
# cpu: 0                                                              
#  clock 0:                                                           
#   .base:       0xffff888003400000                                   
#   .index:      0                                                    
#   .resolution: 1 nsecs                                              
#   .get_time:   ktime_get                                            
#  active timers:                                                     
#   #0: <0xffff888012345678>, tick_sched_timer, S:01 ...              
#     # expires at 5000000000-5000000000 nsecs [in 4000000 to 4000000 nsecs]

# 특정 콜백 함수 이름 검색
grep "tick_sched_timer" /proc/timer_list

# 가장 빨리 만료될 타이머 확인
awk '/expires at/ {print NR": "$0}' /proc/timer_list | head -20

# timer_list의 상세 jiffies 정보
grep -A5 "^jiffies" /proc/timer_list

/proc/timer_list 출력 필드 상세 해석

출력은 크게 3개 섹션으로 구분됩니다: hrtimer(클럭 베이스별), Tick Device(clockevent), 전역 timekeeping 정보. 각 필드의 의미를 정확히 파악해야 실전 디버깅에 활용할 수 있습니다.

# 실전 진단 스크립트: CPU별 활성 타이머 수 집계
awk '/^cpu:/ {cpu=$2} /^  #[0-9]/ {count[cpu]++} END {for(c in count) print "CPU "c": "count[c]" active timers"}' /proc/timer_list

# 가장 자주 나타나는 콜백 함수 TOP 10
grep -oP '(?<=, )[a-z_]+(?=,)' /proc/timer_list | sort | uniq -c | sort -rn | head -10

# 1ms 이내에 만료될 hrtimer 찾기
awk '/\[in [0-9]+ to/ {
    match($0, /\[in ([0-9]+)/, a);
    if (a[1] < 1000000) print $0
}' /proc/timer_list

# Tick Device 섹션 해석
# Tick Device: mode:     1  (1=ONESHOT, 0=PERIODIC)
# Per CPU device: N
#  Clock Event Device: lapic-deadline  (clockevent 디바이스명)
#   event_handler:  hrtimer_interrupt  (현재 핸들러)
#   → hrtimer_interrupt이면 고해상도 모드 활성
#   → tick_handle_periodic이면 저해상도 모드
grep "event_handler" /proc/timer_list
# 모든 CPU가 hrtimer_interrupt를 사용해야 고해상도 모드가 정상 동작

# 전역 타이밍 정보
# jiffies: 4300012345      — 현재 jiffies 값
# last_jiffies_update: 5000000000  — 마지막 jiffies 갱신 시각(ns)
grep "^jiffies" /proc/timer_list

ftrace 타이머 이벤트

# ftrace로 타이머 이벤트 추적
cd /sys/kernel/debug/tracing

# timer 관련 이벤트 목록 확인
ls events/timer/
# timer_cancel  timer_expire_entry  timer_expire_exit
# timer_init    timer_start
# hrtimer_cancel  hrtimer_expire_entry  hrtimer_expire_exit
# hrtimer_init    hrtimer_start

# hrtimer 이벤트만 추적 (고해상도 타이머)
echo 1 > events/timer/hrtimer_expire_entry/enable
echo 1 > events/timer/hrtimer_expire_exit/enable
echo 1 > tracing_on
sleep 1
echo 0 > tracing_on
cat trace | head -50

# 특정 프로세스의 타이머 이벤트만 추적
echo $PID > set_ftrace_pid
echo 1 > events/timer/enable

# hrtimer 실행 지연 히스토그램
echo 1 > events/timer/hrtimer_expire_entry/enable
echo "lat" > trace_clock
cat trace | awk '/hrtimer_expire_entry/ {print $NF}' | sort -n | uniq -c

cyclictest — 타이머 지터 측정

cyclictest는 rt-tests 패키지의 도구로, nanosleep()을 이용한 실제 타이머 지터를 마이크로초 단위로 측정합니다. 실시간 시스템 튜닝의 기준 도구입니다.

# cyclictest 설치
apt install rt-tests     # Debian/Ubuntu
dnf install rt-tests     # Fedora/RHEL

# 기본 테스트: 실시간 우선순위 99, 1만 회 반복, 1ms 주기
cyclictest -m -n -p99 -i1000 -l10000

# 멀티 CPU 전체 테스트 (각 CPU별 스레드)
cyclictest -m -n -p99 -i1000 -l100000 -t $(nproc)

# 출력 예시:                                                          
# T: 0 (12345) P:99 I:1000 C:  10000 Min:      3 Act:    5 Avg:    5 Max:     42
# → Min/Avg/Max 지터(us): 최소 3us, 평균 5us, 최대 42us              

# 히스토그램 모드 (지터 분포 파일 저장)
cyclictest -m -n -p99 -i1000 -l1000000 -h 200 > /tmp/cyclictest.hist

# 히스토그램 출력 (지터 분포 확인)
python3 - <<'EOF'
import sys
data = open('/tmp/cyclictest.hist').readlines()
for line in data[1:20]:
    us, cnt = line.split()[:2]
    print(f"{int(us):4d}us: {'#' * int(cnt)}")
EOF

perf로 타이머 인터럽트 분석

# 타이머 인터럽트 통계
perf stat -e irq:irq_handler_entry/name=timer/ sleep 5

# 타이머 소프트IRQ 비율 확인
perf stat -e softirq:softirq_entry/vec=1/ sleep 5
# TIMER_SOFTIRQ = 0, NET_TX = 1 ...  vec=0이 TIMER_SOFTIRQ

# CPU별 타이머 인터럽트 횟수 (실시간)
watch -n1 'awk "/LOC:/ {for(i=2;i<=NF;i++) printf \"CPU%d: %d\\n\", i-2, \$i}" /proc/interrupts'

# /proc/interrupts로 Local Timer 인터럽트 확인
grep -E "^(LOC|TIM)" /proc/interrupts

# 타이머 관련 소프트IRQ 통계
cat /proc/softirqs | grep TIMER

vDSO — 빠른 시간 읽기

vDSO(Virtual Dynamic Shared Object)는 clock_gettime(), gettimeofday() 등의 시간 관련 시스템 콜을 커널 진입 없이 사용자 공간(User Space)에서 직접 실행할 수 있게 하는 메커니즘입니다. 커널이 관리하는 vvar 페이지(Page)를 읽어 수 나노초 수준의 오버헤드로 시간을 읽습니다.

vdso_data 구조체와 vvar 페이지

커널은 struct vdso_data를 vvar 페이지에 매핑하여 유저 공간이 읽을 수 있게 합니다. 이 구조체에는 시간 변환에 필요한 모든 파라미터가 담겨 있습니다.

/* include/vdso/datapage.h */
struct vdso_timestamp {
    u64   sec;    /* 초 단위 기준 시각 */
    u64   nsec;   /* 나노초 보정값 */
};

struct vdso_data {
    u32   seq;           /* seqcount — 홀수이면 갱신 중 */
    s32   clock_mode;    /* VDSO_CLOCKMODE_TSC 등, 음수면 fallback */
    u64   cycle_last;    /* 마지막 업데이트 시점의 TSC/카운터 값 */
    u64   mask;          /* clocksource 비트마스크 */
    u32   mult;          /* cycle→ns 곱셈 인수 */
    u32   shift;         /* cycle→ns 비트 시프트 */
    struct vdso_timestamp basetime[VDSO_BASES]; /* 클럭별 기준 시각 */
    /* VDSO_BASES: REALTIME, MONOTONIC, MONOTONIC_RAW,
     *             BOOTTIME, TAI, MONOTONIC_COARSE, REALTIME_COARSE */
};

vDSO clock_gettime() fast path

/* lib/vdso/gettimeofday.c — vDSO clock_gettime 핵심 로직 (간략화) */
static int __cvdso_clock_gettime_common(
    const struct vdso_data *vd, clockid_t clock,
    struct __kernel_timespec *ts)
{
    u32 seq;
    u64 cycles, ns;

    do {
        seq = vdso_read_begin(vd);  /* seq 읽기 (짝수 확인) */

        if (vd->clock_mode == VDSO_CLOCKMODE_NONE)
            return -1;  /* syscall 폴백 */

        cycles = __arch_get_hw_counter(vd->clock_mode);
                                       /* rdtsc 또는 cntvct */
        ns = vd->basetime[clock].nsec;
        ns += (cycles - vd->cycle_last) * vd->mult;
        ns >>= vd->shift;

    } while (vdso_read_retry(vd, seq));
                                /* seq 변경 시 재시도 (커널이 갱신 중) */

    ts->tv_sec  = vd->basetime[clock].sec + ns / NSEC_PER_SEC;
    ts->tv_nsec = ns % NSEC_PER_SEC;
    return 0;
}

/* 커널 측: 매 tick마다 vdso_data 갱신 */
/* kernel/time/vsyscall.c */
void update_vsyscall(struct timekeeper *tk)
{
    struct vdso_data *vdata = __arch_get_k_vdso_data();
    vdso_write_begin(vdata);       /* seq를 홀수로 → 갱신 중 */
    vdata->cycle_last = tk->tkr_mono.cycle_last;
    vdata->mult       = tk->tkr_mono.mult;
    vdata->shift      = tk->tkr_mono.shift;
    vdata->basetime[CLOCK_MONOTONIC].sec  = ...;
    vdata->basetime[CLOCK_MONOTONIC].nsec = ...;
    /* REALTIME, BOOTTIME 등 모든 클럭 기준 갱신 */
    vdso_write_end(vdata);         /* seq를 짝수로 → 갱신 완료 */
}

# vDSO 활성화 확인
cat /proc/self/maps | grep vdso
# 7ffe9a5fe000-7ffe9a600000 r-xp ... [vdso]
# 7ffe9a5fc000-7ffe9a5fe000 r--p ... [vvar]

# vDSO 비활성화 (디버깅용, syscall 오버헤드 비교)
# vdso=0 커널 부트 파라미터 또는:
echo 0 > /proc/sys/abi/vsyscall32  # 32비트 호환

# 성능 벤치마크
perf stat -e 'syscalls:sys_enter_clock_gettime' -- ./my_app
# vDSO 활성 시 syscall 카운트 ≈ 0, 비활성 시 수백만

NO_HZ_IDLE vs NO_HZ_FULL 상세 비교

Tickless 커널의 두 가지 주요 모드는 적용 범위와 동작 특성이 크게 다릅니다. NO_HZ_IDLE은 idle CPU에서만 tick을 중단하지만, NO_HZ_FULL은 단일 태스크가 실행 중인 CPU에서도 tick을 중단하여 사용자 공간 작업에 대한 커널 간섭을 최소화합니다.

# NO_HZ 설정 확인
grep CONFIG_NO_HZ /boot/config-$(uname -r)
# CONFIG_NO_HZ_IDLE=y      (기본: idle 시 tick 중단)
# CONFIG_NO_HZ_FULL=y      (선택: 단일 태스크 시에도 중단)

# nohz_full 활성화 CPU 확인
cat /sys/devices/system/cpu/nohz_full
# 1-7  (CPU 1~7이 NO_HZ_FULL 대상)

# NO_HZ_FULL 커널 부트 파라미터 예시
# nohz_full=1-7 rcu_nocbs=1-7 isolcpus=nohz,domain,managed_irq,1-7
#   → CPU 1-7: tick 중단 + RCU 오프로딩 + 스케줄링 도메인 격리
#   → CPU 0: housekeeping (tick 유지, RCU 처리, IRQ 처리)

# 런타임에 tick 상태 확인
cat /proc/timer_list | grep "jiffies:"
# 각 CPU의 현재 jiffies 값과 next_expiry 확인

# NO_HZ 통계 확인
cat /proc/stat | head -1
# CPU idle 비율로 tick 절약 효과 간접 확인

타이머 정확도와 오버헤드

타이머 서브시스템의 선택은 정확도(accuracy), 지연(latency), 오버헤드(overhead) 세 축 사이의 트레이드오프입니다. 워크로드 특성에 따라 적절한 타이머 메커니즘을 선택해야 합니다.

Timer Migration 계층 구조

커널은 idle CPU의 타이머를 busy CPU로 마이그레이션하여 idle CPU가 더 오래 슬립할 수 있게 합니다. 이 메커니즘은 CONFIG_NO_HZ_COMMON에서 활성화되며, Per-CPU timer_base와 그룹 계층 구조를 통해 관리됩니다.

/* Timer migration 관련 API 및 플래그 */

/* Pinned timer: 마이그레이션 불가 */
timer_setup(&my_timer, callback, TIMER_PINNED);
/* → 이 타이머는 항상 등록된 CPU에서만 실행 */

/* 일반 timer: 마이그레이션 가능 */
timer_setup(&my_timer, callback, 0);
/* → idle 시 busy CPU로 마이그레이션 가능 */

/* Deferrable timer: idle 시 처리 보류 */
timer_setup(&my_timer, callback, TIMER_DEFERRABLE);
/* → CPU가 idle이면 처리를 미루어 슬립 시간 연장 */

/* Deferrable + Pinned: 특정 CPU에서만, idle 시 보류 */
timer_setup(&my_timer, callback, TIMER_DEFERRABLE | TIMER_PINNED);

/* 특정 CPU에 타이머 추가 */
add_timer_on(&my_timer, smp_processor_id());

/* sysctl: 마이그레이션 활성/비활성 */
/* /proc/sys/kernel/timer_migration = 1 (활성) */
/* /proc/sys/kernel/timer_migration = 0 (비활성) */

타이머 마이그레이션의 NUMA 영향

NUMA(Non-Uniform Memory Access) 시스템에서 타이머 마이그레이션은 단순한 CPU 간 이동 이상의 성능 영향을 미칩니다. 타이머 콜백이 접근하는 데이터가 원래 CPU의 로컬 메모리에 있을 때, 다른 NUMA 노드의 CPU로 마이그레이션되면 원격 메모리 접근(Remote Memory Access)이 발생하여 지연이 크게 증가합니다.

/* NUMA-aware 타이머 사용 패턴 */

/* ✅ Per-CPU 데이터와 함께 PINNED 타이머 사용 */
struct my_percpu_data {
    struct timer_list timer;
    unsigned long local_counter;  /* 이 CPU의 로컬 메모리에 할당 */
};

static DEFINE_PER_CPU(struct my_percpu_data, pcpu_data);

static void percpu_timer_cb(struct timer_list *t)
{
    struct my_percpu_data *data = from_timer(data, t, timer);
    data->local_counter++;  /* 로컬 메모리 접근 → 빠름 */
    mod_timer(&data->timer, jiffies + HZ);
}

void init_percpu_timer(void)
{
    int cpu;
    for_each_online_cpu(cpu) {
        struct my_percpu_data *data = per_cpu_ptr(&pcpu_data, cpu);
        /* PINNED: 이 CPU에서만 실행, 마이그레이션 방지 */
        timer_setup(&data->timer, percpu_timer_cb, TIMER_PINNED);
        add_timer_on(&data->timer, cpu);
    }
}

/* ❌ NUMA 비친화적 패턴: 원격 데이터를 접근하는 마이그레이션 가능 타이머 */
struct my_dev {
    struct timer_list timer;  /* 마이그레이션 가능 (non-pinned) */
    char *big_buffer;          /* Node 0에 할당된 대용량 버퍼 */
};

static void bad_timer_cb(struct timer_list *t)
{
    struct my_dev *dev = from_timer(dev, t, timer);
    /* 타이머가 Node 1으로 마이그레이션되면 big_buffer 접근이
     * 원격 메모리 접근이 되어 지연이 2~3배 증가 */
    memset(dev->big_buffer, 0, PAGE_SIZE * 256);  /* 느림! */
}

타이머 디버깅

/proc/timer_stats (레거시)

/proc/timer_stats는 커널 4.10 이전에 제공되던 타이머 통계 인터페이스입니다. 활성화하면 어떤 프로세스가 어떤 타이머를 몇 번 발생시켰는지 추적합니다. 커널 4.11+에서는 CONFIG_TIMER_STATS가 제거되었으므로 ftrace 기반 대안을 사용해야 합니다.

# (커널 4.10 이하) /proc/timer_stats 사용
echo 1 > /proc/timer_stats    # 수집 시작
sleep 10                        # 10초간 수집
echo 0 > /proc/timer_stats    # 수집 중지
cat /proc/timer_stats
# 출력 예시:
#  1234,    5,  my_module     my_timer_callback (my_start_fn)
#  → PID 1234가 my_timer_callback을 5번 트리거

# (커널 4.11+) ftrace 대안: timer_start/timer_expire 추적
cd /sys/kernel/debug/tracing
echo 1 > events/timer/timer_start/enable
echo 1 > events/timer/timer_expire_entry/enable
echo 1 > tracing_on
sleep 5
echo 0 > tracing_on
cat trace | grep -E "(timer_start|timer_expire)" | head -30

# 타이머별 발생 횟수 집계
cat trace | grep timer_start | awk '{print $NF}' | sort | uniq -c | sort -rn | head -20

ftrace로 hrtimer 지연 측정

# hrtimer 만료 지연 측정 (예정 시각 vs 실제 실행 시각)
cd /sys/kernel/debug/tracing

# function_graph tracer로 hrtimer_interrupt 실행 시간 측정
echo function_graph > current_tracer
echo hrtimer_interrupt > set_graph_function
echo 1 > tracing_on
sleep 2
echo 0 > tracing_on
cat trace | head -50
# 출력 예시:
#  0)               |  hrtimer_interrupt() {
#  0)   0.234 us    |    __hrtimer_get_next_event();
#  0)               |    __run_hrtimer() {
#  0)   0.567 us    |      tick_sched_timer();
#  0)   1.123 us    |    }
#  0)   2.345 us    |  }

# trace_printk으로 커널 모듈에서 직접 지연 측정
# ktime_t start = ktime_get();
# /* ... 작업 ... */
# s64 delta_ns = ktime_to_ns(ktime_sub(ktime_get(), start));
# trace_printk("timer latency: %lld ns\n", delta_ns);

PowerTOP으로 불필요한 타이머 찾기

# PowerTOP: 불필요한 wakeup을 유발하는 타이머 식별
powertop --time=20
# "Timer Stats" 탭에서 초당 wakeup 횟수별로 정렬
# 높은 빈도의 타이머가 전력 소모의 주범

# PowerTOP CSV 리포트 생성
powertop --csv=report.csv --time=30

# turbostat: CPU C-state 거주 시간과 타이머의 상관관계
turbostat --interval 5
# C1/C3/C6 비율이 낮으면 타이머가 깊은 C-state 진입을 방해

일반적인 타이머 실수와 주의사항

타이머 서브시스템은 동시성, 컨텍스트 제약, 메모리 관리(Memory Management)와 밀접하게 관련되어 있어 다양한 실수가 발생합니다. 아래는 실무에서 자주 발생하는 버그 패턴과 올바른 사용법입니다.

Use-After-Free 패턴

/* ❌ 잘못된 예: 구조체 해제 후 타이머가 남아 있음 */
struct my_dev {
    struct timer_list timer;
    int data;
};

void remove_device(struct my_dev *dev)
{
    del_timer(&dev->timer);  /* ❌ 비동기: 콜백이 이미 실행 중일 수 있음 */
    kfree(dev);              /* ❌ 콜백이 dev->data에 접근하면 UAF! */
}

/* ✅ 올바른 예: 동기적 취소 후 해제 */
void remove_device(struct my_dev *dev)
{
    del_timer_sync(&dev->timer);  /* ✅ 콜백 실행 완료까지 대기 */
    kfree(dev);                   /* ✅ 안전하게 해제 */
}

/* hrtimer도 동일한 원칙 */
hrtimer_cancel(&dev->hrtimer);  /* ✅ 동기적 취소 */
kfree(dev);

컨텍스트 혼동

/* ❌ timer_list 콜백에서 슬립 시도 */
static void bad_timer_cb(struct timer_list *t)
{
    msleep(100);  /* ❌ softirq 컨텍스트에서 슬립 불가! */
    mutex_lock(&my_mutex);  /* ❌ 슬립 가능 잠금 불가! */
}

/* ✅ 슬립이 필요하면 delayed_work 사용 */
static void good_work_handler(struct work_struct *work)
{
    msleep(100);           /* ✅ 프로세스 컨텍스트에서 가능 */
    mutex_lock(&my_mutex); /* ✅ 가능 */
    mutex_unlock(&my_mutex);
}

timer_list vs hrtimer 선택 오류

기타 주의사항

타이머 콜백 재진입(Reentrancy) 문제

SMP 환경에서 주기적 타이머의 콜백 재진입은 미묘한 동시성 버그를 유발합니다. mod_timer()로 주기적 타이머를 구현할 때, 이전 콜백이 아직 다른 CPU에서 실행 중인 상태에서 새 콜백이 시작되는 시나리오를 고려해야 합니다.

/* ❌ 위험: 콜백 재진입 가능한 주기적 타이머 */
static struct timer_list my_timer;
static int shared_counter = 0;  /* 공유 데이터: 동시 접근 가능 */

static void risky_callback(struct timer_list *t)
{
    /* 문제: 이 콜백이 CPU 0에서 실행 중일 때,
     * mod_timer()가 다음 만료를 짧게 설정하면
     * CPU 1에서 동일 콜백이 동시에 실행될 수 있습니다.
     *
     * timer_list 콜백은 재진입 안전하지 않습니다:
     * - 단일 타이머의 동시 실행은 발생하지 않음 (하나의 timer_list는
     *   한 번에 한 CPU에서만 pending)
     * - 그러나 콜백 내에서 mod_timer()를 호출하면,
     *   현재 콜백 실행이 끝나기 전에 타이머가 재등록되어
     *   다른 CPU의 다음 softirq에서 실행될 수 있습니다 */

    shared_counter++;  /* ❌ 원자적이지 않은 연산 */
    mod_timer(&my_timer, jiffies + 1); /* 1 tick 후 재등록 */
    /* mod_timer() 후 즉시 반환, 아래 코드 실행 중
     * 다른 CPU에서 이미 새 콜백이 시작될 수 있음 */
    do_slow_work();  /* 시간이 오래 걸리는 작업 */
}

/* ✅ 안전: 콜백 완료 후 재등록 */
static void safe_callback(struct timer_list *t)
{
    spin_lock(&my_lock);
    shared_counter++;
    spin_unlock(&my_lock);

    do_slow_work();

    /* ✅ 모든 작업 완료 후 마지막에 재등록 */
    mod_timer(&my_timer, jiffies + msecs_to_jiffies(100));
}

/* ✅ 더 안전: timer_shutdown()으로 재등록 방지 (커널 6.2+) */
static bool shutting_down = false;

static void shutdown_safe_callback(struct timer_list *t)
{
    if (shutting_down)
        return;  /* 재등록하지 않음 */
    /* ... 작업 수행 ... */
    mod_timer(&my_timer, jiffies + HZ);
}

void cleanup(void)
{
    shutting_down = true;
    timer_shutdown_sync(&my_timer); /* ✅ 영구 비활성화 */
    /* timer_shutdown_sync() 이후에는 mod_timer()가 무시됨 */
}

타이머 관련 데드락 패턴

/* ❌ 데드락 패턴 1: 콜백에서 del_timer_sync() 호출 */
static void deadlock_callback(struct timer_list *t)
{
    struct my_dev *dev = from_timer(dev, t, timer);
    /* del_timer_sync()는 콜백 완료를 대기하지만,
     * 우리가 바로 그 콜백 안에 있으므로 영원히 대기 → 데드락! */
    del_timer_sync(&dev->other_timer);  /* ❌ 다른 타이머라도 문제 가능 */
    /* 같은 CPU의 같은 base lock을 획득하려고 하면 데드락 */
}

/* ✅ 올바른 패턴: 콜백에서는 del_timer()만 사용 */
static void safe_callback_v2(struct timer_list *t)
{
    struct my_dev *dev = from_timer(dev, t, timer);
    del_timer(&dev->other_timer);  /* ✅ 비동기 삭제 (대기 없음) */
}

/* ❌ 데드락 패턴 2: lock 순서 역전 */
static DEFINE_SPINLOCK(my_lock);
static struct timer_list my_timer;

/* 경로 A: 프로세스 컨텍스트 */
void process_path(void)
{
    spin_lock_bh(&my_lock);       /* (1) my_lock 획득 */
    del_timer_sync(&my_timer);    /* (2) base->lock 획득 시도
                                    * → timer_base lock 대기 */
    spin_unlock_bh(&my_lock);
}

/* 경로 B: 타이머 콜백 (softirq) */
static void timer_callback(struct timer_list *t)
{
    /* __run_timers()가 이미 base->lock 보유 상태에서 콜백 실행 */
    spin_lock(&my_lock);           /* (3) my_lock 획득 시도
                                    * 경로 A가 my_lock 보유 + base->lock 대기
                                    * 경로 B가 base->lock 보유 + my_lock 대기
                                    * → ABBA 데드락! */
    spin_unlock(&my_lock);
}

/* ✅ 올바른 해결: lock 순서 통일 또는 try_to_del_timer_sync() 사용 */
void safe_process_path(void)
{
    del_timer_sync(&my_timer);    /* ✅ lock 없이 먼저 타이머 취소 */
    spin_lock_bh(&my_lock);
    /* ... 안전하게 작업 ... */
    spin_unlock_bh(&my_lock);
}

PREEMPT_RT 환경의 타이머 동작 차이

PREEMPT_RT(실시간) 커널에서는 타이머 서브시스템의 동작이 상당히 달라집니다. softirq가 스레드화되고, spinlock이 mutex로 교체되며, hrtimer의 hard/soft 모드 구분이 중요해집니다. 실시간 시스템에서 타이머를 사용할 때 이러한 차이를 이해해야 예측 가능한 지연 시간을 달성할 수 있습니다.

/* PREEMPT_RT 환경에서의 hrtimer 모드 선택 */

/* 1. 기본 모드 — RT에서는 softirq 스레드에서 실행됨 */
hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
/* → RT 커널: 콜백이 ksoftirqd/N에서 실행
 *   → 다른 RT 태스크에 의해 선점(Preemption) 가능
 *   → 대부분의 드라이버 타이머에 적합 */

/* 2. Hard 모드 — RT에서도 hard IRQ 컨텍스트에서 실행 필요 시 */
hrtimer_init(&timer, CLOCK_MONOTONIC,
             HRTIMER_MODE_REL | HRTIMER_MODE_HARD);
/* → RT 커널: 콜백이 실제 hard IRQ 컨텍스트에서 실행
 *   → 선점 불가 — 최소 지연 보장
 *   → 사용 사례: watchdog, NMI 관련, 시간 동기화
 *   → 주의: 콜백에서 mutex/sleeping 절대 금지 */

/* 3. Soft 모드 명시 — 일반 커널에서도 softirq 스레드 실행 */
hrtimer_init(&timer, CLOCK_MONOTONIC,
             HRTIMER_MODE_REL | HRTIMER_MODE_SOFT);
/* → 일반/RT 모두: softirq 컨텍스트에서 실행
 *   → RT에서 ksoftirqd 스레드의 우선순위로 스케줄링됨
 *   → 정밀도가 약간 감소하나 시스템 응답성 향상 */

NO_HZ_FULL 내부 동작

NO_HZ_FULL은 단순 절전 기능이 아니라 격리 CPU의 주기 tick 제거를 통해 지터를 줄이는 메커니즘입니다. 다만 tick을 끄기 위해서는 RCU, timer, workqueue, unbound kthread를 housekeeping CPU로 오프로딩해야 하며, 그렇지 않으면 예상치 못한 인터럽트로 지터가 증가합니다.

# NO_HZ_FULL 실무 설정 예시
GRUB_CMDLINE_LINUX="nohz_full=1-7 rcu_nocbs=1-7 isolcpus=domain,managed_irq,1-7 irqaffinity=0"

# 부팅 후 확인
grep NO_HZ /boot/config-$(uname -r)
cat /sys/devices/system/cpu/nohz_full
cat /proc/cmdline

# 인터럽트가 CPU0(housekeeping)로 몰렸는지 확인
watch -n1 'grep -E "LOC|RES|CAL|TLB|NET_RX" /proc/interrupts'

Timer Slack과 Coalescing

타이머 정확도를 조금 양보하면 wakeup 횟수를 크게 줄일 수 있습니다. 커널은 timer slack으로 타이머 만료를 근접 시점에 묶어(coalescing) 전력 효율을 높입니다.

/* timer slack API: 정확도 대신 wakeup 절감 */
#include <linux/sched.h>
#include <linux/timer.h>

/* 현재 태스크의 slack 설정 (나노초) */
current->timer_slack_ns = 20 * 1000 * 1000;  /* 20ms */

/* hrtimer 범위 예약: [expires, expires+delta] 범위 내 만료 허용 */
hrtimer_start_range_ns(&timer,
                       ms_to_ktime(100),   /* 목표 만료 */
                       20 * 1000 * 1000, /* 허용 오차 */
                       HRTIMER_MODE_REL);

/* 유저 공간에서는 prctl(PR_SET_TIMERSLACK, ns) 사용 */

timekeeping과 NTP 보정 경로

타이머 정확도는 단순히 하드웨어 클럭 성능만으로 결정되지 않습니다. timekeeping 서브시스템은 clocksource 카운터를 ns로 변환하고, NTP PLL/FLL 보정을 적용해 장기 오차를 줄입니다.

/* 시간 읽기와 변환 흐름 요약 */
#include <linux/timekeeping.h>

/* monotonic 시간 읽기 */
ktime_t now = ktime_get();

/* ns 단위 */
u64 ns = ktime_to_ns(now);

/* realtime 읽기 (NTP/관리자 설정 반영) */
struct timespec64 ts;
ktime_get_real_ts64(&ts);

/* boottime: suspend 기간 포함 */
ktime_get_boottime_ts64(&ts);

타이머 트러블슈팅 플레이북

지연/지터 문제는 "타이머가 느린가"보다 "어떤 경로에서 늦어지는가"를 분리해야 해결됩니다. 아래 순서로 계측하면 원인을 빠르게 좁힐 수 있습니다.

# 1) 타이머/인터럽트 기본 상태
cat /proc/timer_list | head -80
grep -E "LOC|RES|CAL|TLB|TIMER" /proc/interrupts

# 2) 지터 측정
cyclictest -m -n -p99 -i 1000 -l 200000

# 3) timer/hrtimer tracepoint
echo 1 > /sys/kernel/debug/tracing/events/timer/timer_start/enable
echo 1 > /sys/kernel/debug/tracing/events/timer/hrtimer_start/enable
echo 1 > /sys/kernel/debug/tracing/events/timer/hrtimer_expire_entry/enable
sleep 3
cat /sys/kernel/debug/tracing/trace | tail -n 120

# 4) 전력/웨이크업 확인
powertop --time=10 --html

hrtimer backlog 제어와 우선순위 역전(Priority Inversion)

지연 문제에서 자주 놓치는 부분은 "타이머 만료 시각"보다 "콜백이 실제 실행되는 순서"입니다. softirq backlog가 길거나 callback 내부에서 긴 작업을 수행하면, 높은 중요도의 hrtimer도 후순위로 밀릴 수 있습니다.

/* 안티패턴: hrtimer callback에서 장시간 처리 */
enum hrtimer_restart bad_timer_fn(struct hrtimer *t)
{
    /* 금지: 긴 루프/슬립/복잡한 락 경합 */
    do_heavy_work();
    return HRTIMER_RESTART;
}

/* 권장: 최소 작업 후 deferred 처리 */
enum hrtimer_restart good_timer_fn(struct hrtimer *t)
{
    queue_work(system_unbound_wq, &ctx->work);
    hrtimer_forward_now(t, interval);
    return HRTIMER_RESTART;
}

운영 정책: 지연 목표와 전력 목표의 균형

타이머 튜닝은 "최저 지연"과 "최저 전력"을 동시에 만족시키기 어렵습니다. 서비스 SLO를 먼저 정하고, 타이머 정책을 등급별로 분리 운영하면 회귀를 줄일 수 있습니다.

Tick Broadcast와 Deep Idle 복귀 지연

tickless 시스템에서 일부 CPU가 deep idle(C-state 깊은 단계)로 내려가면, 로컬 timer event 대신 broadcast 장치를 통한 깨움 경로가 사용됩니다. 이 경로는 전력 효율에는 유리하지만, 특정 패턴에서 깨움 지연 편차를 키울 수 있습니다.

# tick/nohz/idle 상태 확인
cat /proc/timer_list | grep -E 'broadcast|tick|expires_next' -n
cat /sys/devices/system/cpu/cpuidle/current_driver
cat /sys/devices/system/cpu/cpuidle/current_governor_ro

# 지연 측정과 함께 C-state 영향 비교
cyclictest -m -n -p99 -i 1000 -l 200000
powertop --time=10 --html

timer_list API 함수 상세 레퍼런스

이 섹션에서는 커널 저해상도 타이머(struct timer_list) API의 모든 함수를 상세히 다룹니다. 각 함수의 내부 동작, 반환값, 사용 시 주의사항을 포함합니다.

timer_setup() 상세

timer_setup()은 struct timer_list를 초기화하는 현재 표준 API입니다. 커널 4.15에서 기존 init_timer()와 setup_timer()를 대체하며 도입되었습니다. 새로운 콜백 시그니처(struct timer_list * 인자)를 사용하여 container_of() 패턴을 강제합니다.

/* 함수 시그니처 */
void timer_setup(struct timer_list *timer,
                 void (*callback)(struct timer_list *),
                 unsigned int flags);

사용 가능한 플래그(Flags):

• 0 — 기본값. 표준 타이머 동작.
• TIMER_DEFERRABLE — 유휴(Idle) 상태에서 지연 허용. 전력 절약에 유리.
• TIMER_PINNED — 현재 CPU에 고정. 다른 CPU로 마이그레이션(Migration) 금지.
• TIMER_IRQSAFE — 하드 IRQ 컨텍스트에서 안전. 내부적으로 raw_spinlock 사용.

/* 기본 사용 예제 */
#include <linux/timer.h>

struct my_device {
    struct timer_list poll_timer;
    void __iomem *regs;
    int status;
};

static void my_timer_callback(struct timer_list *t)
{
    struct my_device *dev = from_timer(dev, t, poll_timer);

    dev->status = readl(dev->regs + STATUS_REG);
    if (dev->status & NEED_POLL)
        mod_timer(&dev->poll_timer, jiffies + msecs_to_jiffies(100));
}

static int my_probe(struct platform_device *pdev)
{
    struct my_device *dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);

    timer_setup(&dev->poll_timer, my_timer_callback, 0);
    mod_timer(&dev->poll_timer, jiffies + msecs_to_jiffies(100));
    return 0;
}

add_timer() / mod_timer() 상세

add_timer()는 mod_timer(timer, timer->expires)의 편의 래퍼(Convenience Wrapper)입니다. 실질적으로 모든 타이머 등록/변경은 mod_timer()를 통해 이루어집니다.

/* 함수 시그니처 */
int mod_timer(struct timer_list *timer, unsigned long expires);
int mod_timer_pending(struct timer_list *timer, unsigned long expires);
int timer_reduce(struct timer_list *timer, unsigned long expires);
void add_timer(struct timer_list *timer);

mod_timer()의 내부 동작은 타이머의 현재 상태에 따라 분기합니다:

• 타이머가 대기 중이 아닌 경우: 타이머 휠(Timer Wheel)에 새로 등록(Enqueue)합니다.
• 타이머가 대기 중이고 expires가 동일한 경우: 아무 작업도 하지 않습니다(최적화).
• 타이머가 대기 중이고 expires가 다른 경우: 기존 위치에서 제거(Dequeue) 후 새 위치에 재등록합니다.
• 반환값: 타이머가 이전에 대기 중이었으면 1, 아니면 0

관련 변형 함수:

• mod_timer_pending(timer, expires): 타이머가 대기 중인 경우에만 변경합니다. 대기 중이 아니면 0을 반환하고 아무 작업도 하지 않습니다.
• timer_reduce(timer, expires): 만료 시각을 앞당기기만 합니다(뒤로 미루지 않음). 데드라인 레이싱(Deadline Racing) 패턴에 유용합니다.

/* 주기적 타이머 패턴 */
static void periodic_callback(struct timer_list *t)
{
    struct my_device *dev = from_timer(dev, t, my_timer);

    do_periodic_work(dev);

    /* 다음 주기 등록 — mod_timer가 re-enqueue 처리 */
    mod_timer(&dev->my_timer, jiffies + HZ);
}

/* timer_reduce: 데드라인 레이싱 패턴 */
static void new_request(struct my_device *dev, unsigned long deadline)
{
    /* 현재 설정된 만료보다 이른 경우에만 갱신 */
    timer_reduce(&dev->timeout_timer, deadline);
}

del_timer() / del_timer_sync() / try_to_del_timer_sync() 비교

타이머 취소 함수는 사용 컨텍스트에 따라 올바르게 선택해야 합니다. 잘못된 함수 사용은 교착 상태(Deadlock)나 use-after-free를 유발합니다.

/* 안전한 모듈 정리 패턴 */
static void my_remove(struct platform_device *pdev)
{
    struct my_device *dev = platform_get_drvdata(pdev);

    /* 동기 취소: 콜백 완료까지 대기 */
    del_timer_sync(&dev->poll_timer);

    /* 이 시점에서 타이머가 절대 실행 중이 아님을 보장 */
    kfree(dev);
}

timer_pending() / timer_shutdown() / timer_shutdown_sync()

timer_pending()은 타이머가 휠에 등록되어 있는지 확인합니다. 스레드 안전(Thread-Safe)하지만 반환 직후 상태가 변경될 수 있으므로 참고용으로만 사용합니다.

커널 6.2에서 도입된 timer_shutdown() 계열은 타이머를 비활성화하고 재등록을 영구적으로 방지합니다. 콜백을 NULL로 설정하므로 이후 mod_timer() 호출 시 경고가 발생합니다.

/* 커널 6.2+ shutdown API */
int timer_shutdown(struct timer_list *timer);       /* 비동기 */
int timer_shutdown_sync(struct timer_list *timer);  /* 동기 */

/* 모듈 exit에서 권장 패턴 (6.2+) */
static void my_exit(void)
{
    /* shutdown_sync: 콜백 완료 대기 + 재등록 방지 */
    timer_shutdown_sync(&my_timer);
    /* 이 시점 이후 mod_timer()는 WARN 발생 */
}

/* 상태 확인 */
if (timer_pending(&dev->timer))
    pr_info("timer is queued in wheel\n");

timer_setup_on_stack() / destroy_timer_on_stack()

스택 할당(Stack-Allocated) 타이머를 위한 API입니다. CONFIG_DEBUG_OBJECTS가 활성화된 경우 디버그 오브젝트 추적기(Debug Object Tracker)가 이를 관리합니다. 함수 반환 전에 반드시 destroy_timer_on_stack()을 호출해야 합니다.

/* 스택 타이머 사용 패턴 */
static void wait_with_timeout(unsigned long timeout_jiffies)
{
    struct timer_list timeout_timer;

    timer_setup_on_stack(&timeout_timer, timeout_handler, 0);
    mod_timer(&timeout_timer, jiffies + timeout_jiffies);

    /* ... 대기 로직 ... */
    wait_event(wq, condition || timer_expired);

    del_timer_sync(&timeout_timer);
    destroy_timer_on_stack(&timeout_timer);  /* 반드시 호출! */
}

타이머 플래그 상세

hrtimer API 함수 상세 레퍼런스

고해상도 타이머(High-Resolution Timer, hrtimer)는 나노초(Nanosecond) 단위 정밀도를 제공하며, 레드-블랙 트리(Red-Black Tree) 기반으로 관리됩니다. 이 섹션에서는 hrtimer의 모든 주요 API를 상세히 다룹니다.

hrtimer_init() 상세

void hrtimer_init(struct hrtimer *timer,
                   clockid_t clock_id,
                   enum hrtimer_mode mode);

사용 가능한 클록 ID(Clock ID):

• CLOCK_MONOTONIC — 부팅 이후 단조 증가. 절전(Suspend) 시간 제외. 가장 일반적.
• CLOCK_REALTIME — 실제 시각(Wall Clock). NTP 조정 영향 받음. 사용자 공간 인터페이스용.
• CLOCK_BOOTTIME — MONOTONIC + 절전 시간 포함. 하드웨어 타임아웃에 적합.
• CLOCK_TAI — 국제원자시(International Atomic Time). 윤초(Leap Second) 영향 없음.

모드(Mode) 플래그:

• HRTIMER_MODE_ABS — 절대 시각(Absolute Time) 기준
• HRTIMER_MODE_REL — 상대 시간(Relative Time) 기준 (내부에서 절대 시각으로 변환)
• HRTIMER_MODE_PINNED — 현재 CPU 고정
• HRTIMER_MODE_SOFT — softirq 컨텍스트에서 실행 (5.4+)
• HRTIMER_MODE_HARD — PREEMPT_RT에서도 hardirq 강제
• 조합 가능: HRTIMER_MODE_REL_PINNED_SOFT 등

hrtimer_start() / hrtimer_start_range_ns() 상세

void hrtimer_start(struct hrtimer *timer, ktime_t tim,
                    const enum hrtimer_mode mode);
void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
                            u64 range_ns,
                            const enum hrtimer_mode mode);

range_ns 파라미터는 허용 슬랙(Slack)을 나노초로 지정합니다. 0이면 정확한 시점에 만료되고, 양수이면 해당 범위 내에서 다른 타이머와 통합(Coalescing)할 수 있어 전력 소비를 줄입니다. hrtimer_start()는 range_ns = 0으로 호출하는 래퍼입니다.

내부 흐름:

1. 이미 등록되어 있으면 RB-트리에서 제거
2. REL 모드이면 현재 시각을 더해 절대 시각으로 변환
3. _softexpires = tim, node.expires = tim + range_ns 설정
4. enqueue_hrtimer()로 RB-트리에 삽입
5. 새 타이머가 가장 왼쪽(Leftmost) 노드이면 hrtimer_reprogram() → tick_program_event()로 클록이벤트 재프로그래밍

/* 원샷(One-shot) hrtimer */
static enum hrtimer_restart my_hrt_callback(struct hrtimer *timer)
{
    struct my_device *dev = container_of(timer, struct my_device, hr_timer);
    do_work(dev);
    return HRTIMER_NORESTART;  /* 반복 안 함 */
}

/* 주기적(Periodic) hrtimer */
static enum hrtimer_restart periodic_callback(struct hrtimer *timer)
{
    struct my_device *dev = container_of(timer, struct my_device, hr_timer);
    do_periodic_work(dev);
    hrtimer_forward_now(timer, ms_to_ktime(10));
    return HRTIMER_RESTART;
}

/* range 기반 — 1ms ± 100us 슬랙 허용 */
hrtimer_start_range_ns(&dev->timer, ms_to_ktime(1),
                       100 * NSEC_PER_USEC,
                       HRTIMER_MODE_REL);

hrtimer_cancel() / hrtimer_try_to_cancel() 상세

int hrtimer_cancel(struct hrtimer *timer);
int hrtimer_try_to_cancel(struct hrtimer *timer);

hrtimer_cancel()은 콜백이 완료될 때까지 차단(Block)합니다. 내부적으로 hrtimer_try_to_cancel()을 반복 호출하며, 반환값이 -1(콜백 실행 중)인 동안 cpu_relax()로 스핀(Spin)합니다.

hrtimer_forward() / hrtimer_forward_now() 상세

u64 hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);
u64 hrtimer_forward_now(struct hrtimer *timer, ktime_t interval);

hrtimer_forward()는 타이머의 만료 시각을 now를 지나도록 interval 단위로 전진시킵니다. 오버런 횟수(Overrun Count)를 반환합니다. 반드시 콜백 내에서만 호출해야 합니다.

hrtimer_forward_now()는 hrtimer_forward(timer, hrtimer_cb_get_time(timer), interval)과 동일합니다.

hrtimer 상태 조회 함수

hrtimer 모드 플래그 상세

hrtimer_sleeper — 슬립/웨이크업(Sleep/Wakeup) 통합

struct hrtimer_sleeper는 hrtimer와 task_struct 포인터를 결합하여, 타이머 만료 시 자동으로 태스크를 깨우는 구조체입니다. nanosleep() 시스템 호출의 핵심 구현체입니다.

struct hrtimer_sleeper {
    struct hrtimer timer;
    struct task_struct *task;  /* 깨울 태스크 */
};

void hrtimer_init_sleeper(struct hrtimer_sleeper *sl,
                          clockid_t clock_id,
                          enum hrtimer_mode mode);

int hrtimer_nanosleep(ktime_t rqtp,
                      const enum hrtimer_mode mode,
                      const clockid_t clockid);

schedule_timeout() 상세

schedule_timeout()은 현재 태스크를 최대 timeout 지피(Jiffies) 동안 슬립시킵니다. 호출 전에 반드시 태스크 상태를 설정해야 합니다.

signed long schedule_timeout(signed long timeout);

태스크 상태별 동작:

• TASK_INTERRUPTIBLE — 시그널(Signal)에 의해 조기 깨움 가능. 잔여 지피 반환.
• TASK_UNINTERRUPTIBLE — 타이머만으로 깨움. 항상 0 반환.
• TASK_KILLABLE — 치명적 시그널(Fatal Signal)에만 반응. SIGKILL 등.

특수 값: schedule_timeout(MAX_SCHEDULE_TIMEOUT)은 타이머를 생성하지 않고 무기한 슬립합니다.

편의 래퍼 함수:

/* 태스크 상태를 내부에서 설정하는 래퍼 */
signed long schedule_timeout_interruptible(signed long timeout);
signed long schedule_timeout_uninterruptible(signed long timeout);
signed long schedule_timeout_killable(signed long timeout);

/* msleep: schedule_timeout_uninterruptible의 밀리초 래퍼 */
void msleep(unsigned int msecs);
/* = schedule_timeout_uninterruptible(msecs_to_jiffies(msecs)) */

/* msleep_interruptible: 잔여 밀리초 반환 */
unsigned long msleep_interruptible(unsigned int msecs);

지연 함수 완전 레퍼런스

리눅스 커널에서 지연(Delay)이 필요할 때 올바른 함수를 선택하는 것이 중요합니다. 지연 시간과 실행 컨텍스트에 따라 적절한 API가 다릅니다.

Busy-wait 지연 함수

바쁜 대기(Busy-Wait) 지연은 CPU를 점유하면서 정확한 지연을 제공합니다. 모든 컨텍스트(IRQ, softirq, 프로세스)에서 사용 가능합니다.

void udelay(unsigned long usecs);  /* 마이크로초 바쁜 대기 */
void ndelay(unsigned long nsecs);  /* 나노초 바쁜 대기 */
void mdelay(unsigned long msecs);  /* 밀리초 바쁜 대기 — 가능하면 사용 금지 */

내부 동작: __const_udelay()를 통해 부팅 시 보정된(Calibrated) loops_per_jiffy 값을 곱하여 지연 루프(Delay Loop) 또는 TSC 기반 대기를 수행합니다.

Sleep 기반 지연 함수

/* hrtimer 기반 — 정밀, 프로세스 컨텍스트 전용 */
void usleep_range(unsigned long min, unsigned long max);

/* timer_list 기반 — 프로세스 컨텍스트 전용 */
void msleep(unsigned int msecs);                    /* 비인터럽트 */
unsigned long msleep_interruptible(unsigned int msecs); /* 잔여 ms 반환 */
void ssleep(unsigned int seconds);                  /* = msleep(s * 1000) */

usleep_range(min, max)는 내부에서 hrtimer_sleeper를 생성하고 hrtimer_start_range_ns()로 타이머를 시작한 뒤 schedule()로 슬립합니다. [min, max] 범위 내에서 다른 웨이크업과 통합하여 전력을 절약합니다.

msleep()은 timer_list 기반이므로 지피 단위 정밀도입니다. 실제 슬립 시간은 최대 1 tick(보통 1ms ~ 10ms) 더 길 수 있습니다.

fsleep() — 통합 지연 API

커널 5.8에서 도입된 fsleep()(Flexible Sleep)은 지정된 지연 시간에 따라 최적의 함수를 자동 선택합니다:

void fsleep(unsigned long usecs);

/* 내부 동작:
 *   usecs < 10      → udelay(usecs)
 *   usecs < 20000   → usleep_range(usecs, 2 * usecs)
 *   usecs >= 20000  → msleep(usecs / 1000)
 */

/* 마이그레이션 전: 복잡한 조건 분기 */
if (delay_us < 10)
    udelay(delay_us);
else if (delay_us < 20000)
    usleep_range(delay_us, delay_us * 2);
else
    msleep(delay_us / 1000);

/* 마이그레이션 후: 한 줄 */
fsleep(delay_us);

readl_poll_timeout() — 하드웨어 레지스터 폴링(Polling)

하드웨어가 준비 상태가 될 때까지 레지스터를 반복 읽는 매크로입니다. 내부적으로 읽기 간 usleep_range()를 사용합니다.

/* 프로세스 컨텍스트 전용 */
int readl_poll_timeout(addr, val, cond, delay_us, timeout_us);

/* 원자적 컨텍스트 전용 (udelay 사용) */
int readl_poll_timeout_atomic(addr, val, cond, delay_us, timeout_us);

/* 범용 버전: 임의의 읽기 연산 사용 */
int read_poll_timeout(op, val, cond, sleep_us, timeout_us,
                      sleep_before, args...);

/* 사용 예: 하드웨어 준비 비트 대기 */
u32 val;
int ret;

/* 10us 간격으로 폴링, 최대 100ms 대기 */
ret = readl_poll_timeout(dev->regs + STATUS_REG, val,
                         val & STATUS_READY,
                         10,         /* delay_us */
                         100000);    /* timeout_us */
if (ret)
    dev_err(dev, "hardware timeout\n");

delayed_work API 완전 레퍼런스

struct delayed_work는 타이머(timer_list)와 워크큐(Workqueue)를 결합한 2단계 지연 실행 메커니즘(Two-Phase Deferred Execution)입니다. 타이머 만료 시 워크를 워크큐에 등록하고, kworker 스레드가 프로세스 컨텍스트에서 핸들러를 실행합니다.

내부 동작 흐름

함수별 상세

clockevent 프로그래밍 API 상세

클록이벤트 장치(Clock Event Device)는 하드웨어 타이머 인터럽트를 커널 타이머 프레임워크에 연결하는 추상화 계층(Abstraction Layer)입니다. 각 CPU에 하나의 tick 장치가 할당되며, hrtimer와 타이머 휠의 만료 이벤트를 하드웨어로 프로그래밍합니다.

struct clock_event_device 상세

등록 흐름

/* 주요 등록 API */
void clockevents_config_and_register(struct clock_event_device *dev,
                                     u32 freq,
                                     unsigned long min_delta,
                                     unsigned long max_delta);

/* 이미 mult/shift 설정된 경우 */
void clockevents_register_device(struct clock_event_device *dev);

tick_program_event() 상세

void tick_program_event(ktime_t expires, int force);

현재 CPU의 클록이벤트 장치에 다음 이벤트를 프로그래밍합니다. hrtimer_interrupt()가 만료된 타이머를 모두 처리한 후 다음 만료 시각으로 이 함수를 호출합니다.

• force = 1: expires가 과거 시점이어도 프로그래밍 (즉시 발생)
• force = 0: 과거 시점이면 프로그래밍 실패 시 재시도 루프
• 내부: clockevents_program_event() → 장치의 set_next_ktime() 또는 set_next_event() 호출

clockevent 모드 전환

클록이벤트 장치의 상태 전환(State Transition):

jiffies 유틸리티 함수 레퍼런스

jiffies 변환(Conversion) 및 비교(Comparison) 함수의 전체 레퍼런스입니다.

변환 함수 표