타이머 (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일)까지 커버합니다.

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 */

고해상도 타이머 (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 레드블랙 트리(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)를 유지하며, 사용 목적에 따라 적절한 클럭을 선택해야 합니다.

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를 한꺼번에 보정합니다.

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_create() → anon_inode_getfd() + hrtimer_init()
 * timerfd_settime() → hrtimer_start()
 * 만료 시 → timerfd_tmrproc() → wake_up_locked_poll()
 *   → timerfd의 wait queue에서 대기 중인 epoll/read를 깨움
 * read() → timerfd_read() → hrtimer_forward() → overrun 카운트 반환 */

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

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

/* 타이머를 "느슨하게" 설정하면 커널이 그룹핑 가능 */
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);
    }
}

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 루프 (전력 절약 비활성화)

타이머 디버깅 및 분석

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

/proc/timer_list

/proc/timer_list는 모든 CPU의 활성 hrtimer와 timer_list를 덤프(Dump)합니다.

# 전체 타이머 목록 보기
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

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 (비활성) */

타이머 디버깅

/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 선택 오류

기타 주의사항

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) 함수의 전체 레퍼런스입니다.

변환 함수 표

비교 매크로 표

64비트 버전: time_after64(a, b), time_before64(a, b), time_after_eq64(a, b), time_before_eq64(a, b), time_in_range64(a, b, c) 등이 있으며, u64 값에 대해 동일한 래핑 안전 비교를 수행합니다.

/* 올바른 타임아웃 확인 */
unsigned long deadline = jiffies + msecs_to_jiffies(5000);

/* ✅ 올바름: time_after 사용 (래핑 안전) */
if (time_after(jiffies, deadline)) {
    pr_err("timeout!\n");
    return -ETIMEDOUT;
}

/* ❌ 잘못됨: 직접 비교 (래핑 시 오동작) */
if (jiffies > deadline) {  /* 위험! jiffies 래핑 시 실패 */
    pr_err("timeout!\n");
    return -ETIMEDOUT;
}

/* time_is_before_jiffies를 사용한 간결한 패턴 */
if (time_is_before_jiffies(deadline)) {
    /* deadline이 jiffies보다 이전 = 만료됨 */
    return -ETIMEDOUT;
}

부팅 시 타이머 초기화 시퀀스

리눅스 커널의 타이머 서브시스템은 부팅 과정에서 정해진 순서대로 초기화됩니다. start_kernel()에서 시작하여 아키텍처 독립적인 초기화와 아키텍처별 초기화가 순차적으로 진행되며, 각 단계에서 clocksource 등록, clockevent 설정, hrtimer 프레임워크 활성화가 이루어집니다.

/* init/main.c - start_kernel() 내 타이머 초기화 순서 */
void start_kernel(void)
{
    ...
    tick_init();               /* tick 서브시스템 초기화 */
    init_timers();             /* Timer Wheel 초기화 */
    hrtimers_init();           /* hrtimer 프레임워크 초기화 */
    softirq_init();            /* softirq 인프라 (TIMER_SOFTIRQ 포함) */
    timekeeping_init();        /* timekeeping + jiffies clocksource */
    time_init();               /* arch별 타이머 HW 초기화 */
    ...
    if (late_time_init)
        late_time_init();      /* x86: HPET/TSC 최종 등록 */
    ...
}

/* arch/x86/kernel/time.c */
void __init time_init(void)
{
    late_time_init = x86_late_time_init;
}

static __initdata void (*x86_late_time_init)(void);
static void __init x86_late_time_init(void)
{
    x86_init.timers.timer_init();   /* hpet_time_init() 또는 setup_pit_timer() */
    tsc_init();                        /* TSC calibration 및 clocksource 등록 */
}

/* arch/arm64/kernel/time.c */
void __init time_init(void)
{
    timer_probe();              /* DT에서 timer 노드 탐색 → arch_timer_of_register() */
    tick_setup_hrtimer_broadcast();
}

저해상도 → 고해상도 전환

커널은 부팅 초기에 주기적(periodic) 모드의 저해상도 타이머로 시작합니다. 이후 one-shot 가능한 clockevent 장치가 등록되면 hrtimer 프레임워크가 활성화되어 고해상도 모드로 전환됩니다. 이 전환은 동적으로 이루어지며, tick_check_new_device()가 핵심 전환 트리거입니다.

/* kernel/time/tick-common.c - 새 clockevent 장치 감지 */
void tick_check_new_device(struct clock_event_device *newdev)
{
    struct clock_event_device *curdev;
    struct tick_device *td;
    int cpu;

    cpu = smp_processor_id();
    td = &per_cpu(tick_cpu_device, cpu);
    curdev = td->evtdev;

    /* one-shot 가능 여부 확인 */
    if (!tick_check_percpu(curdev, newdev, cpu))
        goto out;
    if (!tick_check_preferred(curdev, newdev))
        goto out;

    /* 교체 결정: 더 나은 장치로 전환 */
    tick_install_replacement(newdev);
    ...
}

/* kernel/time/hrtimer.c - 고해상도 모드 전환 */
static void hrtimer_switch_to_hres(void)
{
    struct hrtimer_cpu_base *base = this_cpu_ptr(&hrtimer_bases);

    if (tick_init_highres()) {   /* clockevent를 oneshot으로 전환 */
        return;
    }
    base->hres_active = 1;       /* 고해상도 모드 활성화 플래그 */
    hrtimer_resolution = HIGH_RES_NSEC;
    tick_setup_sched_timer();       /* tick_sched_timer를 hrtimer로 등록 */
    retrigger_next_event(NULL);
}

아키텍처별 타이머 하드웨어 상세 비교

각 CPU 아키텍처는 고유한 타이머 하드웨어를 제공합니다. x86은 TSC, HPET, APIC Timer, PM Timer 등 다양한 소스가 공존하며, ARM은 통합된 Generic Timer를, RISC-V는 SBI 기반 타이머 인터페이스를 사용합니다.

/* x86: TSC clocksource 등록 (arch/x86/kernel/tsc.c) */
static struct clocksource clocksource_tsc = {
    .name   = "tsc",
    .rating = 300,
    .read   = read_tsc,
    .mask   = CLOCKSOURCE_MASK(64),
    .flags  = CLOCK_SOURCE_IS_CONTINUOUS | CLOCK_SOURCE_MUST_VERIFY,
};

/* ARM64: Generic Timer clocksource (drivers/clocksource/arm_arch_timer.c) */
static struct clocksource clocksource_counter = {
    .name   = "arch_sys_counter",
    .rating = 400,
    .read   = arch_counter_read,
    .mask   = CLOCKSOURCE_MASK(56),
    .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
};

/* RISC-V: Timer 초기화 (drivers/clocksource/timer-riscv.c) */
static int __init riscv_timer_init_dt(struct device_node *n)
{
    int cpuid, error;

    cpuid = riscv_of_processor_hartid(n, &error);
    if (cpuid != smp_processor_id())
        return 0;

    pr_info("Timer frequency %lu Hz\n", riscv_timebase);
    clocksource_register_hz(&riscv_clocksource, riscv_timebase);
    ...
}

pending_map 비트맵 최적화

Timer Wheel은 5단계 × 64슬롯 = 총 320개의 슬롯을 관리합니다. 다음에 만료될 타이머를 찾기 위해 모든 슬롯을 순회하면 비효율적이므로, pending_map 비트맵을 사용하여 타이머가 등록된 슬롯만 빠르게 탐색합니다.

/* kernel/time/timer.c - pending_map 관련 핵심 코드 */

/* 타이머 등록 시 비트맵 설정 */
static void enqueue_timer(struct timer_base *base,
                          struct timer_list *timer,
                          unsigned int idx)
{
    hlist_add_head(&timer->entry, base->vectors + idx);
    __set_bit(idx, base->pending_map);  /* 해당 슬롯 비트 1로 설정 */
}

/* 타이머 제거 시 비트맵 갱신 */
static void dequeue_timer(struct timer_base *base,
                           struct timer_list *timer)
{
    unsigned int idx = timer->flags & TIMER_ARRAYMASK;

    hlist_del_init(&timer->entry);
    if (hlist_empty(base->vectors + idx))
        __clear_bit(idx, base->pending_map); /* 슬롯이 비면 0으로 */
}

/* 다음 만료 타이머 찾기 - 비트맵 스캔 */
static unsigned long __next_timer_interrupt(struct timer_base *base)
{
    unsigned long clk, next, adj;
    unsigned int lvl, offset;

    next = base->clk + NEXT_TIMER_MAX_DELTA;
    clk = base->clk;

    for (lvl = 0; lvl < LVL_DEPTH; lvl++, offset += LVL_SIZE) {
        int pos = find_next_bit(base->pending_map,
                               offset + LVL_SIZE, offset);
        if (pos < offset + LVL_SIZE) {
            unsigned long tmp = clk + (unsigned long)(pos - offset)
                                          << LVL_SHIFT(lvl);
            if (time_before(tmp, next))
                next = tmp;
        }
    }
    return next;
}

hrtimer Soft 모드 실행 경로

커널 5.4부터 hrtimer에 HRTIMER_MODE_SOFT 모드가 추가되었습니다. 기존 hrtimer 콜백은 하드 인터럽트 컨텍스트(hardirq)에서 실행되지만, soft 모드 타이머는 softirq 컨텍스트에서 실행됩니다. 이로써 더 긴 콜백 처리가 가능하고, hardirq 시간을 줄여 시스템 응답성을 개선할 수 있습니다.

/* include/linux/hrtimer.h - 모드 정의 */
enum hrtimer_mode {
    HRTIMER_MODE_ABS      = 0x00,  /* 절대 시간, hard */
    HRTIMER_MODE_REL      = 0x01,  /* 상대 시간, hard */
    HRTIMER_MODE_PINNED   = 0x02,  /* 현재 CPU 고정 */
    HRTIMER_MODE_SOFT     = 0x04,  /* softirq 컨텍스트 실행 */
    HRTIMER_MODE_HARD     = 0x08,  /* hardirq 컨텍스트 (PREEMPT_RT) */

    /* 조합 모드 */
    HRTIMER_MODE_ABS_SOFT = HRTIMER_MODE_ABS | HRTIMER_MODE_SOFT,
    HRTIMER_MODE_REL_SOFT = HRTIMER_MODE_REL | HRTIMER_MODE_SOFT,
    HRTIMER_MODE_ABS_HARD = HRTIMER_MODE_ABS | HRTIMER_MODE_HARD,
    ...
};

/* kernel/time/hrtimer.c - soft hrtimer 처리 */
static void hrtimer_run_softirq(struct softirq_action *h)
{
    struct hrtimer_cpu_base *cpu_base = this_cpu_ptr(&hrtimer_bases);
    unsigned long flags;
    ktime_t now;

    hrtimer_cpu_base_lock_expiry(cpu_base);
    raw_spin_lock_irqsave(&cpu_base->lock, flags);

    now = hrtimer_update_base(cpu_base);
    __hrtimer_run_queues(cpu_base, now, flags, HRTIMER_ACTIVE_SOFT);

    raw_spin_unlock_irqrestore(&cpu_base->lock, flags);
    hrtimer_cpu_base_unlock_expiry(cpu_base);
}

/* CFS bandwidth throttling - soft hrtimer 사용 예 */
void init_cfs_bandwidth(struct cfs_bandwidth *cfs_b)
{
    hrtimer_init(&cfs_b->period_timer, CLOCK_MONOTONIC,
                 HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_SOFT);  /* Soft 모드! */
    cfs_b->period_timer.function = sched_cfs_period_timer;

    hrtimer_init(&cfs_b->slack_timer, CLOCK_MONOTONIC,
                 HRTIMER_MODE_REL | HRTIMER_MODE_SOFT);
    cfs_b->slack_timer.function = sched_cfs_slack_timer;
}

Timer와 스케줄러 상호작용

타이머 서브시스템과 프로세스 스케줄러는 긴밀하게 연결되어 있습니다. 고해상도 모드에서 tick_sched_timer() hrtimer가 스케줄러의 심장 박동 역할을 하며, CFS 스케줄러는 hrtimer를 사용하여 대역폭 제한(bandwidth throttling)을 구현합니다.

/* kernel/time/tick-sched.c - 스케줄러 틱 hrtimer 콜백 */
static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
{
    struct tick_sched *ts = container_of(timer, struct tick_sched,
                                          sched_timer);
    struct pt_regs *regs = get_irq_regs();
    ktime_t now = ktime_get();

    tick_sched_do_timer(ts, now);   /* do_timer(): jiffies 갱신 */

    if (regs)
        tick_sched_handle(ts, regs);  /* scheduler_tick() 포함 */

    /* 다음 틱 재설정 (tick_period 간격) */
    hrtimer_forward(timer, now, TICK_NSEC);
    return HRTIMER_RESTART;
}

/* kernel/sched/fair.c - check_preempt_tick: 선점 판단 */
static void check_preempt_tick(struct cfs_rq *cfs_rq,
                                struct sched_entity *curr)
{
    unsigned long ideal_runtime, delta_exec;
    struct sched_entity *se;
    s64 delta;

    ideal_runtime = sched_slice(cfs_rq, curr);
    delta_exec = curr->sum_exec_runtime - curr->prev_sum_exec_runtime;

    /* 할당된 타임슬라이스를 초과했는가? */
    if (delta_exec > ideal_runtime) {
        resched_curr(rq_of(cfs_rq));  /* TIF_NEED_RESCHED 설정 */
        return;
    }
    ...
}

실전 디바이스 드라이버 타이머 패턴 총정리

디바이스 드라이버에서 타이머를 사용하는 대표적인 패턴들을 정리합니다. 각 패턴은 실제 커널 드라이버에서 자주 사용되는 검증된 방식입니다.

패턴 1: 지수 백오프 폴링 (mod_timer)

struct my_device {
    struct timer_list poll_timer;
    unsigned long poll_interval;  /* 현재 폴링 간격 (jiffies) */
    unsigned long max_interval;   /* 최대 간격 */
};

static void my_poll_callback(struct timer_list *t)
{
    struct my_device *dev = from_timer(dev, t, poll_timer);
    u32 status = readl(dev->regs + STATUS_REG);

    if (status & READY_BIT) {
        /* 성공: 작업 처리 후 간격 리셋 */
        handle_ready(dev);
        dev->poll_interval = msecs_to_jiffies(10);  /* 초기 간격으로 */
    } else {
        /* 미준비: 간격 2배 증가 (최대 제한) */
        dev->poll_interval = min(dev->poll_interval * 2,
                                 dev->max_interval);
    }
    mod_timer(&dev->poll_timer, jiffies + dev->poll_interval);
}

static int my_probe(struct platform_device *pdev)
{
    struct my_device *dev = ...;
    dev->poll_interval = msecs_to_jiffies(10);
    dev->max_interval = msecs_to_jiffies(1000);  /* 최대 1초 */
    timer_setup(&dev->poll_timer, my_poll_callback, 0);
    mod_timer(&dev->poll_timer, jiffies + dev->poll_interval);
    return 0;
}

패턴 2: 주기적 hrtimer 샘플링 (ADC 패턴)

struct adc_sampler {
    struct hrtimer sample_timer;
    ktime_t interval;        /* 샘플링 간격 */
    u16 *buffer;
    int buf_idx;
};

static enum hrtimer_restart adc_sample_callback(struct hrtimer *hr)
{
    struct adc_sampler *adc = container_of(hr, struct adc_sampler,
                                            sample_timer);

    /* ADC 레지스터 읽기 (짧은 작업만!) */
    adc->buffer[adc->buf_idx++] = readw(adc->regs + ADC_DATA);

    if (adc->buf_idx >= ADC_BUF_SIZE) {
        /* 버퍼 가득 → 워크큐에서 후처리 */
        schedule_work(&adc->process_work);
        adc->buf_idx = 0;
    }

    hrtimer_forward_now(hr, adc->interval);
    return HRTIMER_RESTART;  /* 주기적 반복 */
}

/* 100us 간격 샘플링 시작 */
hrtimer_init(&adc->sample_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
adc->sample_timer.function = adc_sample_callback;
adc->interval = ktime_set(0, 100 * NSEC_PER_USEC);  /* 100us */
hrtimer_start(&adc->sample_timer, adc->interval, HRTIMER_MODE_REL);

패턴 3: 워치독 타임아웃

struct hw_watchdog {
    struct timer_list wd_timer;
    unsigned long timeout_jiffies;
    bool hw_alive;
};

static void watchdog_expired(struct timer_list *t)
{
    struct hw_watchdog *wd = from_timer(wd, t, wd_timer);
    dev_err(wd->dev, "Hardware watchdog timeout! Resetting...\n");
    wd->hw_alive = false;
    writel(HW_RESET_CMD, wd->regs + CTRL_REG);  /* HW 리셋 */
}

/* 워치독 킥 — 정상 동작 시 주기적으로 호출 */
static void watchdog_kick(struct hw_watchdog *wd)
{
    mod_timer(&wd->wd_timer, jiffies + wd->timeout_jiffies);
}

/* 인터럽트 핸들러에서 킥 */
static irqreturn_t my_irq_handler(int irq, void *data)
{
    struct hw_watchdog *wd = data;
    handle_interrupt(wd);
    watchdog_kick(wd);  /* 인터럽트 발생 = HW 정상 → 타이머 리셋 */
    return IRQ_HANDLED;
}

패턴 4: delayed_work를 이용한 지연 초기화

static void deferred_init_work(struct work_struct *work)
{
    struct my_device *dev = container_of(work, struct my_device,
                                          init_work.work);
    /* 느린 HW 초기화 (프로세스 컨텍스트에서 안전하게) */
    firmware_load(dev);           /* sleep 가능 */
    calibrate_hardware(dev);     /* 시간 소요 작업 */
    dev->initialized = true;
}

static int my_probe(struct platform_device *pdev)
{
    struct my_device *dev = ...;
    INIT_DELAYED_WORK(&dev->init_work, deferred_init_work);
    /* 500ms 후 초기화 시작 (probe 완료를 블록하지 않음) */
    schedule_delayed_work(&dev->init_work, msecs_to_jiffies(500));
    return 0;
}

패턴 5: 안전한 종료 (remove 함수)

static void my_remove(struct platform_device *pdev)
{
    struct my_device *dev = platform_get_drvdata(pdev);

    /* 1. 먼저 재등록 방지 플래그 설정 */
    dev->shutting_down = true;

    /* 2. 모든 타이머 동기적으로 취소
     *    del_timer_sync는 콜백이 실행 중이면 완료까지 대기 */
    del_timer_sync(&dev->poll_timer);
    del_timer_sync(&dev->wd_timer);
    hrtimer_cancel(&dev->sample_timer);

    /* 3. delayed_work도 동기 취소 */
    cancel_delayed_work_sync(&dev->init_work);

    /* 4. 이제 안전하게 리소스 해제 */
    kfree(dev->buffer);
    ...
}

패턴 6: readl_poll_timeout (레지스터 폴링)

#include <linux/iopoll.h>

static int wait_for_hw_ready(struct my_device *dev)
{
    u32 val;
    int ret;

    /* STATUS_REG를 10us 간격으로 폴링, 최대 10ms 대기
     * val에 읽은 값 저장, READY_BIT이 설정되면 성공 반환 */
    ret = readl_poll_timeout(dev->regs + STATUS_REG, val,
                            val & READY_BIT,
                            10,      /* sleep_us: 폴링 간격 (us) */
                            10000);  /* timeout_us: 최대 대기 (us) */
    if (ret) {
        dev_err(dev->dev, "HW not ready (timeout)\n");
        return ret;  /* -ETIMEDOUT */
    }

    /* 인터럽트 컨텍스트에서는 _atomic 버전 사용 */
    ret = readl_poll_timeout_atomic(dev->regs + STATUS_REG, val,
                                    val & DONE_BIT, 1, 100);
    return ret;
}

타이머 관련 CONFIG 옵션 레퍼런스

커널 빌드 시 타이머 동작에 영향을 미치는 주요 CONFIG 옵션들을 정리합니다. 이 설정들은 타이머 해상도, 틱 동작, 디버깅 기능을 제어합니다.

/* 런타임에 현재 설정 확인하기 */

/* 1. HZ 값 확인 */
printk("HZ = %d, tick = %lu ns\n", HZ, TICK_NSEC);

/* 2. 고해상도 모드 활성화 여부 */
printk("hres_active = %d\n",
       this_cpu_ptr(&hrtimer_bases)->hres_active);

/* 3. NO_HZ 모드 확인 (커널 명령줄) */
/* nohz=on/off, nohz_full=1-3 */

/* 4. /proc/timer_list로 전체 상태 확인 */
/*    cat /proc/timer_list | grep -E "(hres_active|nohz_mode|Tick Device)" */

/* 5. sysfs로 clocksource 확인 */
/*    cat /sys/devices/system/clocksource/clocksource0/current_clocksource */
/*    cat /sys/devices/system/clocksource/clocksource0/available_clocksource */

참고 자료

• docs.kernel.org — Timers — 커널 공식 타이머 서브시스템 문서 인덱스입니다.
• docs.kernel.org — hrtimers — subsystem for high-resolution kernel timers — 고해상도 타이머 설계와 구현을 설명하는 공식 문서입니다.
• docs.kernel.org — NO_HZ: Reducing Scheduling-Clock Ticks — NO_HZ_IDLE, NO_HZ_FULL 구성 옵션과 동작 원리를 다루는 공식 문서입니다.
• docs.kernel.org — Timekeeping — clocksource, timekeeping 프레임워크에 대한 커널 공식 문서입니다.
• docs.kernel.org — Timer Stats — 타이머 통계 수집과 디버깅 인터페이스를 설명하는 문서입니다.
• docs.kernel.org — ktime accessors — ktime_get() 계열 API 사용 가이드 공식 문서입니다.
• kernel/time/timer.c — Bootlin Elixir — Timer Wheel 핵심 구현 소스 코드입니다. __run_timers(), mod_timer() 등이 정의되어 있습니다.
• kernel/time/hrtimer.c — Bootlin Elixir — hrtimer 서브시스템 핵심 구현입니다. hrtimer_start(), hrtimer_interrupt() 등이 포함됩니다.
• kernel/time/jiffies.c — Bootlin Elixir — jiffies 기반 clocksource 구현 소스 코드입니다.
• kernel/time/clocksource.c — Bootlin Elixir — clocksource 등록·선택·watchdog 메커니즘 구현입니다.
• kernel/time/clockevents.c — Bootlin Elixir — clock_event_device 관리 및 이벤트 프레임워크 구현입니다.
• kernel/time/tick-sched.c — Bootlin Elixir — tick_nohz_idle_enter/exit 등 tickless(NO_HZ) 핵심 로직입니다.
• kernel/time/tick-broadcast.c — Bootlin Elixir — tick broadcast 프레임워크 구현으로, deep idle 상태에서의 타이머 전달을 처리합니다.
• kernel/time/posix-timers.c — Bootlin Elixir — POSIX timer_create/timer_settime 시스템 콜 커널 측 구현입니다.
• kernel/time/timekeeping.c — Bootlin Elixir — ktime_get(), do_gettimeofday() 등 시간 관리 핵심 구현입니다.
• include/linux/timer.h — Bootlin Elixir — timer_list 구조체와 타이머 API 매크로/함수 선언부입니다.
• include/linux/hrtimer.h — Bootlin Elixir — hrtimer 구조체와 API 선언부입니다.
• include/linux/jiffies.h — Bootlin Elixir — jiffies 관련 매크로와 변환 함수 선언부입니다.
• LWN: A new approach to kernel timers (2005) — Thomas Gleixner의 hrtimer 프레임워크 최초 제안을 다룬 기사입니다.
• LWN: The high-resolution timer API (2006) — hrtimer API 설계와 사용법을 상세히 설명하는 기사입니다.
• LWN: Reinventing the timer wheel (2015) — Thomas Gleixner의 Timer Wheel 재설계(계층형 해시 휠)를 다룬 기사입니다.
• LWN: (Nearly) full tickless operation in 3.10 (2013) — NO_HZ_FULL 도입 배경과 구현을 설명하는 기사입니다.
• LWN: Clockevents and dyntick (2007) — clockevent 프레임워크와 dynamic tick의 관계를 설명하는 기사입니다.
• LWN: Dynamic tick for the x86 (2005) — x86 아키텍처에서 dynamic tick(NO_HZ) 최초 구현에 관한 기사입니다.
• LWN: Deferrable timers (2016) — TIMER_DEFERRABLE 플래그와 전력 절감 메커니즘을 다룬 기사입니다.
• LWN: Timer slack (2011) — timer_slack_ns와 타이머 병합(coalescing) 메커니즘을 설명하는 기사입니다.
• LWN: vDSO — virtual dynamic shared object (2010) — vDSO를 통한 고속 시간 조회 메커니즘에 관한 기사입니다.
• LWN: The tick broadcast framework (2017) — tick broadcast와 deep idle 상태 관리를 다룬 기사입니다.
• docs.kernel.org — Delaying and Scheduling Routines — msleep, usleep_range, schedule_timeout 등 지연 함수 API 공식 문서입니다.
• man timer_create(2) — POSIX per-process 타이머 생성 시스템 콜 매뉴얼입니다.
• man timerfd_create(2) — timerfd 인터페이스를 통한 파일 디스크립터 기반 타이머 매뉴얼입니다.
• man time(7) — 리눅스 시간 관련 개념(CLOCK_REALTIME, CLOCK_MONOTONIC 등)에 대한 개요 매뉴얼입니다.
• man clock_gettime(2) — clock_gettime/clock_settime 시스템 콜 매뉴얼로, vDSO 가속 대상 함수입니다.
• eLinux: Kernel Timer Systems — 커널 타이머 시스템에 대한 종합 개요와 발전 이력을 정리한 문서입니다.
• Thomas Gleixner — Timers and time management in the kernel (LPC 2017) — 커널 타이머 메인테이너 Thomas Gleixner의 발표로, hrtimer와 tickless 아키텍처를 설명합니다.

관련 문서

타이머와 관련된 다른 주제를 더 깊이 이해하고 싶다면 다음 문서를 참고하세요.

• 인터럽트 — 타이머 인터럽트, softirq 처리
• ktime / Clock — clocksource/clockevent, 지연 함수 상세
• Workqueue — delayed_work 내부 구조, kworker 스레드
• 프로세스 스케줄러 — 타임슬라이스, CFS bandwidth throttling
• 전원 관리(Power Management) — C-state, tickless와 절전의 연관성
• 실시간 시스템 — PREEMPT_RT, 지터 최소화, cyclictest