Notifier Chain (알림 체인(Notifier Chain))

Notifier Chain은 Linux 커널의 이벤트 알림 메커니즘입니다. 발행자(publisher)가 이벤트를 발생시키면 등록된 구독자(subscriber) 콜백(Callback)들이 순서대로 호출됩니다. 잠금(Lock) 컨텍스트에 따라 4가지 변형(blocking, atomic, raw, srcu)을 제공하며, CPU 핫플러그(Hotplug)·전원관리·네트워크 디바이스 이벤트 등 커널 전반에서 사용됩니다.

이 문서에서는 각 변형의 API 나열에 그치지 않고 "콜백이 실행되는 잠금 문맥"과 "콜백 내부에서 허용되는 동작"을 중심으로 설계 기준을 정리합니다. registration/unregistration의 수명 주기 규칙, 우선순위(Priority) 체인의 부작용, NOTIFY_STOP 사용 시 전파 차단 영향, SRCU 비용 모델과 읽기 경로 이점까지 분석해 모듈 간 결합도를 낮추면서도 장애 전파를 제어할 수 있는 이벤트 설계 방법을 제공합니다.

개요

Notifier Chain의 핵심은 struct notifier_block의 단방향 연결 리스트(Linked List)입니다. 발행자는 이벤트 번호와 데이터를 인자로 체인을 순회하며 각 콜백을 호출합니다.

발행-구독 아키텍처

Notifier Chain은 발행-구독(Publish-Subscribe) 패턴을 커널 내부에서 구현한 것입니다. 이벤트 소스(발행자)가 체인 헤드를 통해 이벤트를 발행하면, 등록된 모든 구독자 콜백이 우선순위 순서대로 호출됩니다. 각 체인 헤드는 서로 다른 잠금 메커니즘을 사용하여 동시성을 제어합니다. 아래 다이어그램은 커널 전반의 주요 이벤트 소스가 어떻게 체인 헤드를 거쳐 구독자에게 전달되는지를 보여줍니다.

struct notifier_block

/* include/linux/notifier.h */
struct notifier_block {
    notifier_fn_t       notifier_call; /* 콜백 함수 포인터 */
    struct notifier_block __rcu *next; /* 다음 구독자 (RCU protected) */
    int                 priority;      /* 호출 우선순위 (높을수록 먼저) */
};

/* 콜백 함수 시그니처 */
typedef int (*notifier_fn_t)(struct notifier_block *nb,
                              unsigned long action,
                              void *data);

콜백 반환값

4가지 Notifier Chain 변형

4종 내부 잠금 흐름 비교

아래 다이어그램은 4가지 Notifier Chain 변형이 등록(register), 호출(call_chain), 해제(unregister) 경로에서 각각 어떤 잠금을 획득하고 해제하는지를 병렬로 비교합니다. 같은 작업이라도 변형에 따라 잠금 경로가 완전히 다르며, 이 차이가 사용 가능한 컨텍스트와 제약 조건을 결정합니다.

커스텀 Notifier Chain 구현

기존 커널 체인을 사용하는 것 외에, 자체 서브시스템용 Notifier Chain을 처음부터 설계하고 구현하는 방법을 설명합니다. 발행자 모듈이 체인 헤드를 소유하고, 별도의 구독자 모듈이 콜백을 등록하는 완전한 예제입니다.

발행자 모듈 (Publisher)

/* my_publisher.c — 커스텀 Notifier Chain 발행자 모듈 */
#include <linux/module.h>
#include <linux/notifier.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/timer.h>

/* === 이벤트 정의 (헤더 파일로 분리 권장) === */
#define MY_EVENT_TEMP_HIGH    0x01  /* 온도 상한 초과 */
#define MY_EVENT_TEMP_NORMAL  0x02  /* 온도 정상 복귀 */
#define MY_EVENT_TEMP_CRIT    0x03  /* 온도 임계 초과 */

/* 이벤트 데이터 구조체 */
struct my_temp_event {
    int           sensor_id;    /* 센서 번호 */
    int           temperature;  /* 밀리섭씨 (mC) */
    int           threshold;    /* 트리거 임계값 */
    ktime_t       timestamp;    /* 이벤트 발생 시간 */
};

/* === 체인 헤드: 정적 초기화 === */
static BLOCKING_NOTIFIER_HEAD(my_temp_chain);

/* === 외부 모듈용 등록/해제 API === */
int my_temp_register_notifier(struct notifier_block *nb)
{
    return blocking_notifier_chain_register(&my_temp_chain, nb);
}
EXPORT_SYMBOL_GPL(my_temp_register_notifier);

int my_temp_unregister_notifier(struct notifier_block *nb)
{
    return blocking_notifier_chain_unregister(&my_temp_chain, nb);
}
EXPORT_SYMBOL_GPL(my_temp_unregister_notifier);

/* === 이벤트 발행 함수 === */
static int my_temp_notify(unsigned long event,
                           struct my_temp_event *data)
{
    int ret;

    data->timestamp = ktime_get();
    ret = blocking_notifier_call_chain(&my_temp_chain, event, data);
    ret = notifier_to_errno(ret);

    if (ret)
        pr_warn("temp notifier returned error: %d\n", ret);

    return ret;
}

/* === 시뮬레이션: 주기적 온도 이벤트 발생 === */
static struct delayed_work temp_work;
static int simulated_temp = 45000; /* 45.000도C */

static void temp_check_worker(struct work_struct *work)
{
    struct my_temp_event evt = {
        .sensor_id   = 0,
        .temperature = simulated_temp,
        .threshold   = 85000,  /* 85도C */
    };

    if (simulated_temp > 95000)
        my_temp_notify(MY_EVENT_TEMP_CRIT, &evt);
    else if (simulated_temp > 85000)
        my_temp_notify(MY_EVENT_TEMP_HIGH, &evt);

    /* 시뮬레이션: 온도 점진적 상승 */
    simulated_temp += 5000;
    if (simulated_temp > 100000)
        simulated_temp = 45000;

    schedule_delayed_work(&temp_work, msecs_to_jiffies(5000));
}

static int __init my_publisher_init(void)
{
    pr_info("my_publisher: temperature notifier chain initialized\n");
    INIT_DELAYED_WORK(&temp_work, temp_check_worker);
    schedule_delayed_work(&temp_work, msecs_to_jiffies(1000));
    return 0;
}

static void __exit my_publisher_exit(void)
{
    cancel_delayed_work_sync(&temp_work);
    pr_info("my_publisher: unloaded\n");
}

module_init(my_publisher_init);
module_exit(my_publisher_exit);
MODULE_LICENSE("GPL");

구독자 모듈 (Subscriber)

/* my_subscriber.c — 발행자의 체인에 등록하는 구독자 모듈 */
#include <linux/module.h>
#include <linux/notifier.h>

/* 발행자 헤더 (실제로는 별도 .h 파일) */
extern int my_temp_register_notifier(struct notifier_block *nb);
extern int my_temp_unregister_notifier(struct notifier_block *nb);

#define MY_EVENT_TEMP_HIGH    0x01
#define MY_EVENT_TEMP_NORMAL  0x02
#define MY_EVENT_TEMP_CRIT    0x03

struct my_temp_event {
    int     sensor_id;
    int     temperature;
    int     threshold;
    ktime_t timestamp;
};

/* === 콜백 구현 === */
static int my_temp_handler(struct notifier_block *nb,
                            unsigned long event, void *data)
{
    struct my_temp_event *evt = data;

    switch (event) {
    case MY_EVENT_TEMP_HIGH:
        pr_warn("[subscriber] sensor %d: HIGH %d.%03d C (threshold %d.%03d)\n",
                evt->sensor_id,
                evt->temperature / 1000, evt->temperature % 1000,
                evt->threshold / 1000, evt->threshold % 1000);
        /* 예: 팬 속도 증가, 클럭 스로틀링 등 */
        break;

    case MY_EVENT_TEMP_CRIT:
        pr_emerg("[subscriber] sensor %d: CRITICAL %d.%03d C!\n",
                 evt->sensor_id,
                 evt->temperature / 1000, evt->temperature % 1000);
        /* 긴급 조치: 워크로드 중단, 안전 종료 시작 */
        return NOTIFY_BAD;  /* 발행자에게 위험 상태 알림 */

    case MY_EVENT_TEMP_NORMAL:
        pr_info("[subscriber] sensor %d: temperature normalized\n",
                evt->sensor_id);
        break;
    }
    return NOTIFY_OK;
}

/* notifier_block은 반드시 static (스택 변수 금지!) */
static struct notifier_block my_temp_nb = {
    .notifier_call = my_temp_handler,
    .priority      = 100,  /* 다른 구독자보다 먼저 실행 */
};

static int __init my_subscriber_init(void)
{
    int ret = my_temp_register_notifier(&my_temp_nb);
    if (ret) {
        pr_err("[subscriber] failed to register: %d\n", ret);
        return ret;
    }
    pr_info("[subscriber] registered with priority %d\n",
            my_temp_nb.priority);
    return 0;
}

static void __exit my_subscriber_exit(void)
{
    my_temp_unregister_notifier(&my_temp_nb);
    pr_info("[subscriber] unregistered\n");
}

module_init(my_subscriber_init);
module_exit(my_subscriber_exit);
MODULE_LICENSE("GPL");

Blocking Notifier Chain

가장 일반적인 변형으로, rwsem(읽기-쓰기 세마포어(Semaphore))으로 보호됩니다. 콜백에서 슬립이 허용되며, 프로세스(Process) 컨텍스트에서만 사용 가능합니다.

Blocking API

/* 선언 및 초기화 */
static BLOCKING_NOTIFIER_HEAD(my_chain);   /* 정적 초기화 */

/* 또는 동적 초기화 */
struct blocking_notifier_head my_chain;
BLOCKING_INIT_NOTIFIER_HEAD(&my_chain);

/* 구독자 등록/해제 */
int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
                                       struct notifier_block *nb);
int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
                                         struct notifier_block *nb);

/* 이벤트 발행 */
int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
                                   unsigned long val, void *v);

Blocking Notifier 실전 예제

/* === 발행자(publisher) 측 === */
static BLOCKING_NOTIFIER_HEAD(voltage_change_chain);

/* 외부에서 등록/해제할 수 있도록 함수 공개 */
int register_voltage_notifier(struct notifier_block *nb)
{
    return blocking_notifier_chain_register(&voltage_change_chain, nb);
}
EXPORT_SYMBOL(register_voltage_notifier);

int unregister_voltage_notifier(struct notifier_block *nb)
{
    return blocking_notifier_chain_unregister(&voltage_change_chain, nb);
}
EXPORT_SYMBOL(unregister_voltage_notifier);

/* 이벤트 정의 */
#define VOLTAGE_CHANGE_PRE  0x01
#define VOLTAGE_CHANGE_POST 0x02

static void notify_voltage_change(unsigned long event, int mv)
{
    blocking_notifier_call_chain(&voltage_change_chain, event, (void *)(long)mv);
}

/* === 구독자(subscriber) 측 === */
static int my_voltage_cb(struct notifier_block *nb,
                           unsigned long event, void *data)
{
    int mv = (int)(long)data;
    if (event == VOLTAGE_CHANGE_PRE)
        pr_info("Voltage will change to %dmV\n", mv);
    return NOTIFY_OK;
}

static struct notifier_block my_nb = {
    .notifier_call = my_voltage_cb,
    .priority      = 100,  /* 높을수록 먼저 호출 */
};

static int __init my_init(void)
{
    return register_voltage_notifier(&my_nb);
}

static void __exit my_exit(void)
{
    unregister_voltage_notifier(&my_nb); /* 반드시 해제! */
}

rwsem 잠금 동작 상세

Blocking notifier는 내부적으로 rw_semaphore(읽기-쓰기 세마포어)를 사용합니다. 이벤트 발행 시 down_read()로 읽기 잠금을 획득하고 체인을 순회합니다. 구독자 등록/해제 시에는 down_write()로 쓰기 잠금을 획득합니다. 읽기 잠금은 여러 CPU에서 동시에 획득할 수 있어 이벤트 발행의 병렬성이 보장됩니다. 그러나 쓰기 잠금은 모든 읽기 잠금이 해제될 때까지 대기해야 하므로, 콜백 실행 중 등록/해제가 지연될 수 있습니다.

Atomic Notifier Chain

스핀락으로 보호되어 인터럽트 핸들러에서도 호출 가능합니다. 콜백 내에서 슬립을 유발하는 어떠한 연산도 허용되지 않습니다.

/* 초기화 */
static ATOMIC_NOTIFIER_HEAD(netdev_chain);

/* API */
int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
                                     struct notifier_block *nb);
int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
                                       struct notifier_block *nb);
int atomic_notifier_call_chain(struct atomic_notifier_head *nh,
                                  unsigned long val, void *v);

RCU 기반 내부 구현

Atomic notifier의 핵심은 읽기 경로(call_chain)와 쓰기 경로(register/unregister)가 서로 다른 동기화를 사용하는 점입니다. 읽기 경로는 rcu_read_lock()으로 보호되어 스핀락 없이 체인을 순회합니다. 쓰기 경로만 spin_lock_irqsave()로 리스트를 수정합니다. 이 설계 덕분에 여러 CPU가 동시에 이벤트를 발행해도 스핀락 경합이 발생하지 않습니다. notifier_block의 next 포인터에 __rcu 어노테이션이 붙는 이유도 RCU로 보호되기 때문입니다.

내부 구현 코드

/* kernel/notifier.c — atomic notifier 내부 구현 (간략화) */

int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
                                     struct notifier_block *n)
{
    unsigned long flags;
    int ret;

    spin_lock_irqsave(&nh->lock, flags);
    ret = notifier_chain_register(&nh->head, n);  /* rcu_assign_pointer 사용 */
    spin_unlock_irqrestore(&nh->lock, flags);
    return ret;
}

int atomic_notifier_call_chain(struct atomic_notifier_head *nh,
                                  unsigned long val, void *v)
{
    int ret;

    rcu_read_lock();           /* 스핀락 없이 RCU만 사용 */
    ret = notifier_call_chain(&nh->head, val, v, -1, NULL);
    rcu_read_unlock();
    return ret;
}

/* notifier_call_chain 내부 순회 */
static int notifier_call_chain(struct notifier_block **nl,
                                unsigned long val, void *v, ...)
{
    struct notifier_block *nb, *next_nb;

    nb = rcu_dereference_raw(*nl);  /* __rcu 포인터 역참조 */
    while (nb) {
        next_nb = rcu_dereference_raw(nb->next);
        ret = nb->notifier_call(nb, val, v);
        if (ret & NOTIFY_STOP_MASK)
            break;
        nb = next_nb;
    }
    return ret;
}

SRCU Notifier Chain

SRCU(Sleepable RCU)로 보호되어 콜백 내에서 슬립이 허용되면서도, 콜백 실행 중 체인에서 등록/해제가 가능합니다. CPU 핫플러그 이벤트에 사용됩니다.

/* SRCU Notifier는 동적 초기화가 필수 */
struct srcu_notifier_head cpu_chain;

static int __init init_cpu_notifier(void)
{
    srcu_init_notifier_head(&cpu_chain);  /* SRCU struct 초기화 포함 */
    return 0;
}

/* 정리 시 반드시 호출 */
srcu_cleanup_notifier_head(&cpu_chain);

/* API */
int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
                                   struct notifier_block *nb);
int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
                                     struct notifier_block *nb);
int srcu_notifier_call_chain(struct srcu_notifier_head *nh,
                               unsigned long val, void *v);

SRCU vs RCU: 설계 차이와 비용

일반 RCU에서 rcu_read_lock()은 선점을 비활성화(Preemption Disable)합니다. 이 때문에 RCU 읽기 구간 내에서는 슬립이 불가능합니다. SRCU는 이 제약을 해결하기 위해 Per-CPU 카운터 기반의 참조 추적을 사용합니다. srcu_read_lock()은 현재 CPU의 Per-CPU 카운터를 증가시키고 인덱스를 반환합니다. srcu_read_unlock()은 해당 카운터를 감소시킵니다. 선점을 비활성화하지 않으므로 콜백에서 슬립이 가능합니다.

SRCU의 비용은 일반 RCU보다 큽니다. srcu_struct는 Per-CPU 카운터 배열을 포함하여 약 200바이트(Byte) 이상의 메모리를 사용합니다. 반면 atomic notifier의 spinlock_t는 4바이트에 불과합니다. 따라서 SRCU notifier는 콜백에서 슬립이 반드시 필요하고, 콜백 내에서 체인 수정이 요구되는 경우에만 사용해야 합니다.

SRCU Notifier 내부 구현 상세 분석

SRCU notifier는 4가지 변형 중 가장 복잡한 내부 구조를 가집니다. kernel/notifier.c의 실제 구현을 단계별로 분석합니다.

/* kernel/notifier.c — SRCU notifier 전체 구현 분석 */

/* srcu_notifier_head 구조체 */
struct srcu_notifier_head {
    struct mutex            mutex;  /* 쓰기 경로 직렬화 */
    struct srcu_struct      srcu;   /* SRCU 읽기 보호 (~200B) */
    struct notifier_block  *head;  /* 연결 리스트 시작 */
};

/* === 초기화: srcu_struct 동적 할당 필수 === */
int srcu_init_notifier_head(struct srcu_notifier_head *nh)
{
    mutex_init(&nh->mutex);
    if (init_srcu_struct(&nh->srcu))
        return -ENOMEM;       /* per-CPU 카운터 할당 실패 */
    nh->head = NULL;
    return 0;
}
/* 주의: BLOCKING_NOTIFIER_HEAD()처럼 정적 초기화 매크로 없음
 * srcu_struct는 per-CPU 메모리 할당이 필요하므로 반드시 동적 초기화 */

/* === 등록: mutex로 보호 === */
int srcu_notifier_chain_register(
    struct srcu_notifier_head *nh,
    struct notifier_block *n)
{
    int ret;

    mutex_lock(&nh->mutex);
    ret = notifier_chain_register(&nh->head, n);
    mutex_unlock(&nh->mutex);
    return ret;
}
/* mutex 사용 → 등록 중 슬립 가능
 * blocking의 down_write()와 달리 reader를 차단하지 않음
 * → 콜백 실행 중에도 등록이 가능한 핵심 차이 */

/* === 호출: SRCU 읽기 구간 === */
int srcu_notifier_call_chain(
    struct srcu_notifier_head *nh,
    unsigned long val, void *v)
{
    int ret, idx;

    idx = srcu_read_lock(&nh->srcu);
    /* idx: 현재 SRCU 인덱스 (0 또는 1, 더블 버퍼링)
     * srcu_read_lock은 선점을 비활성화하지 않음 → 슬립 가능
     * per-CPU 카운터를 증가시킬 뿐 */

    ret = notifier_call_chain(&nh->head, val, v, -1, NULL);
    /* 이 구간에서:
     * - 콜백 내 mutex_lock(), kmalloc(GFP_KERNEL) 등 가능
     * - 콜백 내 같은 체인의 register/unregister 가능!
     *   (mutex는 비재귀지만, 쓰기는 mutex로, 읽기는 SRCU로 분리) */

    srcu_read_unlock(&nh->srcu, idx);
    /* per-CPU 카운터 감소 */

    return ret;
}

/* === 해제: mutex + synchronize_srcu === */
int srcu_notifier_chain_unregister(
    struct srcu_notifier_head *nh,
    struct notifier_block *n)
{
    int ret;

    mutex_lock(&nh->mutex);
    ret = notifier_chain_unregister(&nh->head, n);
    mutex_unlock(&nh->mutex);

    /* 핵심: 해제 후 grace period 대기
     * 진행 중인 srcu_read_lock() ~ srcu_read_unlock() 구간이
     * 모두 완료될 때까지 대기한 후 반환
     * → unregister 반환 후 n->notifier_call이 호출되지 않음 보장 */
    synchronize_srcu(&nh->srcu);

    return ret;
}

/* === 정리: per-CPU 메모리 해제 === */
void srcu_cleanup_notifier_head(
    struct srcu_notifier_head *nh)
{
    mutex_destroy(&nh->mutex);
    cleanup_srcu_struct(&nh->srcu);
    /* 반드시 모든 구독자가 해제된 후 호출해야 함 */
}

SRCU 더블 버퍼링 메커니즘

SRCU가 일반 RCU와 다른 핵심 특성은 더블 버퍼링(Double Buffering) 인덱스 방식입니다. srcu_read_lock()은 현재 활성 인덱스(0 또는 1)의 per-CPU 카운터를 증가시키고 그 인덱스를 반환합니다. synchronize_srcu()는 인덱스를 뒤집고(flip), 이전 인덱스의 모든 per-CPU 카운터가 0이 될 때까지 대기합니다.

Raw Notifier Chain

잠금이 전혀 없는 최저수준 변형입니다. 동기화는 전적으로 호출자의 책임입니다. 시스템 초기화 단계나 이미 잠금이 보장된 특수 경로에서만 사용합니다.

/* 초기화 */
static RAW_NOTIFIER_HEAD(my_raw_chain);

/* API: 호출자가 적절한 잠금을 보유해야 함 */
int raw_notifier_chain_register(struct raw_notifier_head *nh,
                                  struct notifier_block *nb);
int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
                                    struct notifier_block *nb);
int raw_notifier_call_chain(struct raw_notifier_head *nh,
                              unsigned long val, void *v);

Raw Notifier 실전 예제 — Reboot 알림

/* kernel/reboot.c: 시스템 재부팅/종료 알림 (Raw Notifier 사용)
 * 재부팅 경로는 이미 잠금 보유 상태이고 특수 컨텍스트이므로 raw 사용 */

/* 구독자 측 */
static int my_reboot_cb(struct notifier_block *nb,
                          unsigned long code, void *data)
{
    switch (code) {
    case SYS_RESTART:
        pr_info("System restarting\n");
        my_flush_all();       /* 데이터 플러시 */
        break;
    case SYS_HALT:
    case SYS_POWER_OFF:
        pr_info("System halting\n");
        my_hw_shutdown();     /* 하드웨어 안전 종료 */
        break;
    }
    return NOTIFY_DONE;
}

static struct notifier_block my_reboot_nb = {
    .notifier_call = my_reboot_cb,
    .priority      = 128,   /* 0 = 기본, 양수 = 앞서 호출, 음수 = 나중 호출 */
};

static int __init my_init(void)
{
    return register_reboot_notifier(&my_reboot_nb);
}

static void __exit my_exit(void)
{
    unregister_reboot_notifier(&my_reboot_nb);
}

4종 비교

4종 잠금 메커니즘 비교 다이어그램

내부 동작 메커니즘

notifier_call_chain 내부 구조

모든 변형의 핵심은 notifier_call_chain()으로, 우선순위 정렬된 연결 리스트를 순회하며 콜백을 호출합니다.

/* kernel/notifier.c: 실제 순회 로직 (단순화) */
static int notifier_call_chain(struct notifier_block **nl,
                                  unsigned long val, void *v,
                                  int nr_to_call, int *nr_calls)
{
    int ret = NOTIFY_DONE;
    struct notifier_block *nb, *next_nb;

    nb = rcu_dereference_raw(*nl);

    while (nb && nr_to_call) {
        next_nb = rcu_dereference_raw(nb->next);

        if (nr_calls)
            (*nr_calls)++;

        ret = nb->notifier_call(nb, val, v);

        if (ret & NOTIFY_STOP_MASK) /* NOTIFY_STOP or NOTIFY_BAD with stop */
            break;

        nb = next_nb;
        nr_to_call--;
    }
    return ret;
}

notifier_call_chain 실행 흐름 다이어그램

notifier_call_chain 상세 코드 분석

notifier_call_chain()은 4종 모든 변형의 핵심 순회 함수입니다. 각 변형은 이 함수를 잠금으로 감싸서 호출합니다. 핵심 매개변수인 nr_to_call은 최대 호출 횟수를 제한하며, nr_calls는 실제 호출된 횟수를 돌려줍니다.

/* kernel/notifier.c — 전체 구현 (Linux 6.x) */
static int notifier_call_chain(
    struct notifier_block **nl,
    unsigned long val, void *v,
    int nr_to_call, int *nr_calls)
{
    int ret = NOTIFY_DONE;
    struct notifier_block *nb, *next_nb;

    nb = rcu_dereference_raw(*nl);

    while (nb && nr_to_call) {
        /* 콜백 실행 전에 next를 미리 저장 —
         * 콜백이 자기 자신을 해제해도 안전하게 순회 가능 (SRCU/raw) */
        next_nb = rcu_dereference_raw(nb->next);

        if (nr_calls)
            (*nr_calls)++;

        /* 핵심: 콜백 호출 */
        ret = nb->notifier_call(nb, val, v);

        if (notifier_to_errno(ret)) {
            /* ret에 NOTIFY_STOP_MASK 비트가 설정됨
             * → NOTIFY_STOP 또는 NOTIFY_BAD */
            break;
        }

        nb = next_nb;
        nr_to_call--;
    }
    return ret;
}

/* blocking 변형: rwsem read lock으로 감싸기 */
int blocking_notifier_call_chain(
    struct blocking_notifier_head *nh,
    unsigned long val, void *v)
{
    int ret = NOTIFY_DONE;

    if (rcu_access_pointer(nh->head)) {
        down_read(&nh->rwsem);       /* 읽기 잠금 획득 */
        ret = notifier_call_chain(&nh->head, val, v,
                                      -1, NULL);
        up_read(&nh->rwsem);         /* 읽기 잠금 해제 */
    }
    return ret;
}

/* atomic 변형: RCU read-side critical section */
int atomic_notifier_call_chain(
    struct atomic_notifier_head *nh,
    unsigned long val, void *v)
{
    int ret;

    rcu_read_lock();              /* RCU 읽기 진입 */
    ret = notifier_call_chain(&nh->head, val, v,
                                  -1, NULL);
    rcu_read_unlock();            /* RCU 읽기 종료 */
    return ret;
}

콜백 반환값 처리 로직

콜백 반환값은 비트 마스크로 처리됩니다. NOTIFY_STOP_MASK (0x8000) 비트가 설정되면 체인 순회가 중단됩니다.

/* include/linux/notifier.h — 반환값 정의 */
#define NOTIFY_DONE       0x0000   /* 관심 없음, 계속 */
#define NOTIFY_OK         0x0001   /* 처리 완료, 계속 */
#define NOTIFY_STOP_MASK  0x8000   /* 중단 비트 */
#define NOTIFY_BAD        (NOTIFY_STOP_MASK|0x0002)
                                     /* 0x8002: 에러 + 중단 */
#define NOTIFY_STOP       (NOTIFY_STOP_MASK|0x0001)
                                     /* 0x8001: 성공 + 중단 */

/* 변환 함수: 반환값에서 에러 코드 추출 */
static inline int notifier_from_errno(int err)
{
    if (err)
        return NOTIFY_STOP_MASK | (NOTIFY_OK - err);
    return NOTIFY_OK;
}

static inline int notifier_to_errno(int ret)
{
    return -(ret & ~NOTIFY_STOP_MASK);  /* STOP_MASK 제거 후 부호 반전 */
}

등록 시 우선순위 정렬

/* 등록 시 우선순위 내림차순으로 연결 리스트에 삽입 */
static int notifier_chain_register(struct notifier_block **nl,
                                     struct notifier_block *n)
{
    while ((*nl) != NULL) {
        if ((*nl)->priority < n->priority)
            break;   /* 삽입 위치 발견 */
        nl = &((*nl)->next);
    }
    n->next = *nl;
    rcu_assign_pointer(*nl, n);
    return 0;
}
/* → 등록 시마다 O(n) 탐색, 호출 시 순서 보장 */

우선순위 정렬 구조 다이어그램

등록/해제 생명주기 다이어그램

커널 주요 Notifier Chain 목록

전원 관리 (Blocking)

/* kernel/power/main.c: PM 상태 전환 알림 */
int register_pm_notifier(struct notifier_block *nb);
int unregister_pm_notifier(struct notifier_block *nb);

/* PM 이벤트 값 */
// PM_HIBERNATION_PREPARE : 하이버네이션 준비
// PM_POST_HIBERNATION    : 하이버네이션 복구 후
// PM_SUSPEND_PREPARE     : 서스펜드 진입 전
// PM_POST_SUSPEND        : 서스펜드 복구 후

static int my_pm_cb(struct notifier_block *nb,
                     unsigned long event, void *data)
{
    if (event == PM_SUSPEND_PREPARE)
        flush_my_work();  /* 서스펜드 전 작업 정리 */
    return NOTIFY_OK;
}

네트워크 디바이스 (Atomic)

/* net/core/dev.c: 네트워크 디바이스 이벤트 */
int register_netdevice_notifier(struct notifier_block *nb);
int unregister_netdevice_notifier(struct notifier_block *nb);

/* 이벤트: NETDEV_UP, NETDEV_DOWN, NETDEV_REGISTER, NETDEV_UNREGISTER, */
/*         NETDEV_CHANGE, NETDEV_CHANGEMTU, NETDEV_CHANGEADDR 등 */

static int my_netdev_cb(struct notifier_block *nb,
                          unsigned long event, void *ptr)
{
    struct net_device *dev = netdev_notifier_info_to_dev(ptr);
    if (event == NETDEV_UP)
        pr_info("%s is up\n", dev->name);
    return NOTIFY_DONE;
}

CPU 핫플러그 (SRCU 기반 state machine)

/* Linux 4.10+: cpuhp state machine으로 교체됨 */
/* 직접 notifier 대신 cpuhp_setup_state() 사용 권장 */
int cpuhp_setup_state(enum cpuhp_state state,
                       const char *name,
                       int (*startup)(unsigned int cpu),
                       int (*teardown)(unsigned int cpu));

/* 예제 */
static int my_cpu_online(unsigned int cpu)
{
    pr_info("CPU %u online\n", cpu);
    return 0;
}

static int __init my_init(void)
{
    return cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "my:online",
                              my_cpu_online, NULL);
}

CPU Hotplug Notifier 실행 시퀀스

CPU Hotplug 실전 코드

/* 완전한 CPU Hotplug 드라이버 예제 */
#include <linux/cpuhotplug.h>
#include <linux/percpu.h>

static DEFINE_PER_CPU(struct my_cpu_data, cpu_data);
static enum cpuhp_state hp_state;

static int my_cpu_online(unsigned int cpu)
{
    struct my_cpu_data *data = per_cpu_ptr(&cpu_data, cpu);

    pr_info("CPU %u online: 리소스 초기화\n", cpu);
    data->active = true;
    data->counter = 0;
    return 0;  /* 0: 성공, 음수: 실패 → CPU online 중단 */
}

static int my_cpu_offline(unsigned int cpu)
{
    struct my_cpu_data *data = per_cpu_ptr(&cpu_data, cpu);

    pr_info("CPU %u offline: 리소스 정리\n", cpu);
    data->active = false;
    flush_my_cpu_work(cpu);  /* CPU별 작업 완료 */
    return 0;
}

static int __init my_init(void)
{
    int ret;

    /* CPUHP_AP_ONLINE_DYN: 동적 state 번호 할당
     * 등록 즉시 모든 온라인 CPU에 startup 콜백 실행 */
    ret = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN,
                              "mydrv:online",
                              my_cpu_online,
                              my_cpu_offline);
    if (ret < 0)
        return ret;

    hp_state = ret;  /* 해제 시 필요한 state 번호 저장 */
    return 0;
}

static void __exit my_exit(void)
{
    /* 모든 온라인 CPU에 teardown 콜백 실행 후 등록 해제 */
    cpuhp_remove_state(hp_state);
}

Netdevice Notifier 실전 사용 흐름

Netdevice Notifier 완전한 예제

/* 네트워크 디바이스 이벤트 전체 처리 예제 */
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/notifier.h>

static int my_netdev_event(struct notifier_block *nb,
                            unsigned long event, void *ptr)
{
    struct net_device *dev = netdev_notifier_info_to_dev(ptr);

    /* 특정 디바이스만 필터링 */
    if (!(dev->flags & IFF_UP) && event != NETDEV_UP)
        return NOTIFY_DONE;

    switch (event) {
    case NETDEV_REGISTER:
        pr_info("[%s] 디바이스 등록됨\n", dev->name);
        break;
    case NETDEV_UP:
        pr_info("[%s] 인터페이스 UP (MTU=%d)\n",
                dev->name, dev->mtu);
        /* 필터 규칙 설치 등 */
        break;
    case NETDEV_DOWN:
        pr_info("[%s] 인터페이스 DOWN\n", dev->name);
        /* 필터 규칙 제거 등 */
        break;
    case NETDEV_CHANGEMTU:
        pr_info("[%s] MTU 변경: %d\n", dev->name, dev->mtu);
        break;
    case NETDEV_UNREGISTER:
        pr_info("[%s] 디바이스 해제 중\n", dev->name);
        break;
    }
    return NOTIFY_DONE;
}

static struct notifier_block my_netdev_nb = {
    .notifier_call = my_netdev_event,
    .priority      = 0,    /* 기본 우선순위 */
};

static int __init my_init(void)
{
    return register_netdevice_notifier(&my_netdev_nb);
}

static void __exit my_exit(void)
{
    unregister_netdevice_notifier(&my_netdev_nb);
}
module_init(my_init);
module_exit(my_exit);

네트워크 Notifier 실제 활용: 방화벽 규칙 자동 관리

아래 예제는 네트워크 인터페이스가 UP/DOWN될 때 자동으로 방화벽 규칙이나 라우팅 정책을 적용/제거하는 실전 패턴입니다. 이 패턴은 bonding, bridge, VLAN, nftables 등 주요 네트워크 서브시스템에서 실제로 사용됩니다.

/* 네트워크 Notifier 실전: 인터페이스별 정책 자동 관리 */
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/notifier.h>
#include <linux/inetdevice.h>
#include <linux/list.h>
#include <linux/slab.h>

/* 인터페이스별 관리 상태 */
struct my_iface_state {
    struct list_head   list;
    struct net_device  *dev;
    bool               rules_installed;
    u32                last_mtu;
};

static LIST_HEAD(iface_list);
static DEFINE_MUTEX(iface_mutex);

static struct my_iface_state *find_iface(struct net_device *dev)
{
    struct my_iface_state *s;
    list_for_each_entry(s, &iface_list, list) {
        if (s->dev == dev)
            return s;
    }
    return NULL;
}

static int my_netdev_handler(struct notifier_block *nb,
                              unsigned long event, void *ptr)
{
    struct net_device *dev = netdev_notifier_info_to_dev(ptr);
    struct my_iface_state *state;

    /* 물리 인터페이스만 대상 (loopback, veth 등 제외) */
    if (dev->type != ARPHRD_ETHER || !dev->dev.parent)
        return NOTIFY_DONE;

    /* 주의: netdev_chain은 raw notifier이므로
     * rtnl_lock()이 이미 보유된 상태 → mutex 사용 시 순서 주의 */

    switch (event) {
    case NETDEV_REGISTER:
        state = kzalloc(sizeof(*state), GFP_KERNEL);
        if (!state)
            return NOTIFY_BAD;  /* 등록 거부 */
        state->dev = dev;
        dev_hold(dev);  /* net_device 참조 카운터 증가 */
        list_add_tail(&state->list, &iface_list);
        pr_info("[my_fw] %s registered\n", dev->name);
        break;

    case NETDEV_UP:
        state = find_iface(dev);
        if (state && !state->rules_installed) {
            pr_info("[my_fw] %s UP — installing rules (MTU=%d)\n",
                    dev->name, dev->mtu);
            /* 방화벽 규칙/TC qdisc 설치 */
            state->rules_installed = true;
            state->last_mtu = dev->mtu;
        }
        break;

    case NETDEV_DOWN:
        state = find_iface(dev);
        if (state && state->rules_installed) {
            pr_info("[my_fw] %s DOWN — removing rules\n",
                    dev->name);
            state->rules_installed = false;
        }
        break;

    case NETDEV_CHANGEMTU:
        state = find_iface(dev);
        if (state && state->rules_installed) {
            pr_info("[my_fw] %s MTU %u → %u — updating rules\n",
                    dev->name, state->last_mtu, dev->mtu);
            /* MTU 기반 규칙 업데이트 */
            state->last_mtu = dev->mtu;
        }
        break;

    case NETDEV_UNREGISTER:
        state = find_iface(dev);
        if (state) {
            list_del(&state->list);
            dev_put(dev);  /* 참조 카운터 감소 */
            kfree(state);
            pr_info("[my_fw] %s unregistered\n", dev->name);
        }
        break;
    }
    return NOTIFY_DONE;
}

static struct notifier_block my_netdev_nb = {
    .notifier_call = my_netdev_handler,
};

static int __init my_fw_init(void)
{
    /* register_netdevice_notifier는 기존 디바이스에 대해
     * NETDEV_REGISTER + NETDEV_UP을 즉시 재생(replay)합니다.
     * 따라서 init 시점에 이미 존재하는 디바이스도 처리됩니다. */
    return register_netdevice_notifier(&my_netdev_nb);
}

static void __exit my_fw_exit(void)
{
    struct my_iface_state *s, *tmp;

    unregister_netdevice_notifier(&my_netdev_nb);

    /* 남은 상태 정리 */
    list_for_each_entry_safe(s, tmp, &iface_list, list) {
        list_del(&s->list);
        dev_put(s->dev);
        kfree(s);
    }
}

PM Notifier 실전 상세 예제

/* 전원 관리 Notifier — 서스펜드/하이버네이션 전후 처리 */
#include <linux/suspend.h>
#include <linux/notifier.h>

static int my_pm_notifier(struct notifier_block *nb,
                           unsigned long action, void *data)
{
    switch (action) {
    case PM_HIBERNATION_PREPARE:
        pr_info("하이버네이션 준비 중\n");
        my_save_state();
        break;
    case PM_SUSPEND_PREPARE:
        pr_info("서스펜드 준비 중\n");
        my_flush_buffers();
        my_disable_polling();
        break;
    case PM_POST_SUSPEND:
        pr_info("서스펜드 복귀\n");
        my_enable_polling();
        my_restore_state();
        break;
    case PM_POST_HIBERNATION:
        pr_info("하이버네이션 복귀\n");
        my_restore_state();
        break;
    case PM_RESTORE_PREPARE:
        /* 하이버네이션 이미지 복원 직전 */
        break;
    case PM_POST_RESTORE:
        /* 하이버네이션 이미지 복원 실패 시 */
        break;
    }
    return NOTIFY_OK;
}

static struct notifier_block my_pm_nb = {
    .notifier_call = my_pm_notifier,
    .priority      = 0,
};

/* 등록/해제 */
register_pm_notifier(&my_pm_nb);
unregister_pm_notifier(&my_pm_nb);

Reboot Notifier 실전 상세 예제

/* Reboot Notifier — 시스템 재부팅/종료/halt 처리
 * kernel/reboot.c에서 restart_handler_list 관리
 * 이 체인은 blocking_notifier_head (restart_handler) 또는
 * raw_notifier_head (reboot_notifier_list) 사용 */
#include <linux/reboot.h>

static int my_reboot_handler(struct notifier_block *nb,
                              unsigned long action, void *data)
{
    switch (action) {
    case SYS_RESTART:
        pr_emerg("시스템 재시작 — 하드웨어 안전 종료\n");
        my_hw_safe_shutdown();
        my_flush_nvram();      /* 비휘발 메모리 플러시 */
        break;
    case SYS_HALT:
        pr_emerg("시스템 정지\n");
        my_hw_safe_shutdown();
        break;
    case SYS_POWER_OFF:
        pr_emerg("시스템 전원 끄기\n");
        my_hw_power_down_sequence();
        break;
    }
    return NOTIFY_DONE;
}

static struct notifier_block my_reboot_nb = {
    .notifier_call = my_reboot_handler,
    .priority      = 200,  /* 높은 우선순위 — 먼저 실행 */
};

/* register_reboot_notifier()는 내부적으로
 * blocking_notifier_chain_register(&reboot_notifier_list, nb) 호출 */
register_reboot_notifier(&my_reboot_nb);
unregister_reboot_notifier(&my_reboot_nb);

기타 주요 Notifier Chain

inet 주소 변경 알림 예제

/* 네트워크 인터페이스 IP 주소 변경 감지 */
#include <linux/inetdevice.h>

static int my_inetaddr_cb(struct notifier_block *nb,
                             unsigned long event, void *ptr)
{
    struct in_ifaddr *ifa = ptr;
    struct net_device *dev = ifa->ifa_dev->dev;

    switch (event) {
    case NETDEV_UP:
        pr_info("%s: IP %pI4 added\n", dev->name, &ifa->ifa_address);
        break;
    case NETDEV_DOWN:
        pr_info("%s: IP %pI4 removed\n", dev->name, &ifa->ifa_address);
        break;
    }
    return NOTIFY_OK;
}

static struct notifier_block my_inetaddr_nb = {
    .notifier_call = my_inetaddr_cb,
};

register_inetaddr_notifier(&my_inetaddr_nb);

PANIC Notifier 예제

/* 커널 패닉 직전에 호출 — atomic 컨텍스트 */
static int my_panic_cb(struct notifier_block *nb,
                         unsigned long val, void *data)
{
    const char *msg = data;  /* 패닉 메시지 문자열 */

    /* 하드웨어 상태 레지스터 덤프 등 긴급 처리 */
    my_hw_emergency_dump();

    return NOTIFY_DONE;  /* NOTIFY_STOP 금지: 패닉을 막을 수 없음 */
}

static struct notifier_block my_panic_nb = {
    .notifier_call = my_panic_cb,
    .priority      = 200,  /* 높은 우선순위로 먼저 실행 */
};

/* panic_notifier_list는 atomic_notifier_head */
atomic_notifier_chain_register(&panic_notifier_list, &my_panic_nb);

성능 고려사항

콜백 최소화 패턴: 즉시 처리 vs 지연 처리

Notifier 콜백에서 무거운 작업을 수행하면 전체 이벤트 전파 지연이 증가합니다. 아래 코드는 콜백을 최소화하고 실제 작업을 workqueue로 위임하는 권장 패턴입니다.

/* 콜백 최소화 패턴: 이벤트를 큐잉하고 workqueue에서 처리 */
struct my_event_work {
    struct work_struct   work;
    unsigned long        event;
    struct net_device   *dev;
};

static struct workqueue_struct *my_wq;

static void my_event_worker(struct work_struct *work)
{
    struct my_event_work *ew =
        container_of(work, struct my_event_work, work);

    /* workqueue 컨텍스트: 잠금, 슬립, 무거운 작업 모두 가능 */
    switch (ew->event) {
    case NETDEV_UP:
        rtnl_lock();
        install_heavy_filter_rules(ew->dev);
        rtnl_unlock();
        break;
    case NETDEV_DOWN:
        rtnl_lock();
        remove_heavy_filter_rules(ew->dev);
        rtnl_unlock();
        break;
    }
    dev_put(ew->dev);
    kfree(ew);
}

/* 콜백: 최소한의 작업만 수행 */
static int my_fast_netdev_cb(struct notifier_block *nb,
                              unsigned long event, void *ptr)
{
    struct net_device *dev = netdev_notifier_info_to_dev(ptr);
    struct my_event_work *ew;

    if (event != NETDEV_UP && event != NETDEV_DOWN)
        return NOTIFY_DONE;

    /* 콜백 내에서는 GFP_ATOMIC만 사용 (atomic notifier 호환) */
    ew = kmalloc(sizeof(*ew), GFP_ATOMIC);
    if (!ew)
        return NOTIFY_DONE;

    INIT_WORK(&ew->work, my_event_worker);
    ew->event = event;
    ew->dev = dev;
    dev_hold(dev);  /* workqueue 실행 전 dev 해제 방지 */

    queue_work(my_wq, &ew->work);
    return NOTIFY_DONE;
    /* 총 콜백 시간: ~100ns (kmalloc + queue_work만)
     * 실제 작업은 workqueue에서 비동기 처리 */
}

성능 측정 결과 참고

일반적인 Notifier chain 호출 오버헤드입니다 (x86_64, CONFIG_PREEMPT 기준, 콜백 본문 제외).

디버깅(Debugging)

ftrace로 Notifier Chain 추적

ftrace의 function 트레이서와 function_graph 트레이서를 사용하면 notifier chain 콜백의 호출 순서와 소요 시간을 정밀하게 추적할 수 있습니다.

# 1. notifier_call_chain 함수 추적
echo 'notifier_call_chain' > /sys/kernel/debug/tracing/set_ftrace_filter
echo function > /sys/kernel/debug/tracing/current_tracer
echo 1 > /sys/kernel/debug/tracing/tracing_on
cat /sys/kernel/debug/tracing/trace

# 2. function_graph로 콜백 호출 계층 확인
echo function_graph > /sys/kernel/debug/tracing/current_tracer
echo 'blocking_notifier_call_chain' > /sys/kernel/debug/tracing/set_graph_function
echo 1 > /sys/kernel/debug/tracing/tracing_on
# 이벤트 발생 후 확인
cat /sys/kernel/debug/tracing/trace

# 출력 예시:
# | blocking_notifier_call_chain() {
#   | down_read() { ... }
#   | notifier_call_chain() {
#     | my_pm_notifier() { ... }        ← 콜백 1
#     | driver_xyz_notifier() { ... }    ← 콜백 2
#   }
#   | up_read() { ... }
# }

# 3. 특정 notifier chain만 필터링 (예: PM)
echo 'pm_notifier_call_chain' > /sys/kernel/debug/tracing/set_ftrace_filter
echo funcgraph-duration > /sys/kernel/debug/tracing/trace_options
echo funcgraph-proc > /sys/kernel/debug/tracing/trace_options

# 4. 추적 종료 및 정리
echo 0 > /sys/kernel/debug/tracing/tracing_on
echo nop > /sys/kernel/debug/tracing/current_tracer

lockdep을 이용한 잠금 순서 검증

# 커널 빌드 옵션 (디버그 커널에서 활성화)
CONFIG_DEBUG_LOCK_ALLOC=y
CONFIG_PROVE_LOCKING=y
CONFIG_LOCKDEP=y

# lockdep이 검출하는 Notifier Chain 관련 문제:
# 1. blocking_notifier 콜백에서 같은 체인의 register/unregister → 데드락
# 2. atomic_notifier 콜백에서 sleep 함수 호출 → BUG: scheduling while atomic
# 3. 중첩된 notifier chain 호출의 잠금 역순 → lockdep 경고

# lockdep 통계 확인
cat /proc/lockdep_stats
# lock_stat으로 경합 분석
cat /proc/lock_stat | grep notifier

printk를 이용한 콜백 디버깅

/* 콜백 진입/종료 추적 패턴 */
static int my_debug_cb(struct notifier_block *nb,
                         unsigned long event, void *data)
{
    pr_debug("[%s] event=%lu data=%p\n", __func__, event, data);

    /* 콜백 소요 시간 측정 */
    ktime_t start = ktime_get();

    /* ... 실제 처리 ... */

    pr_debug("[%s] took %lld ns\n", __func__,
             ktime_to_ns(ktime_sub(ktime_get(), start)));

    return NOTIFY_OK;
}

/* dynamic debug로 런타임에 활성화/비활성화 */
/* echo 'func my_debug_cb +p' > /sys/kernel/debug/dynamic_debug/control */

변형 선택 가이드

주의사항 및 흔한 실수

/* 잘못된 예: atomic notifier 콜백에서 sleep */
static int bad_atomic_cb(struct notifier_block *nb,
                           unsigned long event, void *data)
{
    struct my_data *d = kmalloc(sizeof(*d), GFP_KERNEL); /* BUG! sleep 가능 */
    mutex_lock(&my_mutex);   /* BUG! sleep 가능 */
    return NOTIFY_OK;
}

/* 올바른 예: atomic 안전한 할당 사용 */
static int good_atomic_cb(struct notifier_block *nb,
                            unsigned long event, void *data)
{
    struct my_data *d = kmalloc(sizeof(*d), GFP_ATOMIC); /* OK: 비수면 */
    spin_lock(&my_lock);     /* OK: 비수면 */
    /* 또는: 무거운 작업은 workqueue로 위임 */
    schedule_work(&my_work); /* OK: 작업 예약만 함 */
    return NOTIFY_OK;
}

/* 잘못된 예: 콜백에서 같은 체인 이벤트 재발생 */
static int bad_recursive_cb(struct notifier_block *nb,
                              unsigned long event, void *data)
{
    struct net_device *dev = netdev_notifier_info_to_dev(data);
    if (event == NETDEV_UP) {
        /* 위험! 이 호출이 NETDEV_CHANGE를 발생시킬 수 있음 */
        dev_change_flags(dev, dev->flags | IFF_PROMISC, NULL);
    }
    return NOTIFY_DONE;
}

/* 올바른 예: workqueue로 위임 */
static int good_deferred_cb(struct notifier_block *nb,
                              unsigned long event, void *data)
{
    if (event == NETDEV_UP) {
        /* 비동기로 처리하여 재귀 회피 */
        schedule_work(&my_promisc_work);
    }
    return NOTIFY_DONE;
}

흔한 실수 요약

데드락(Deadlock) 분석

Notifier chain에서 발생하는 데드락은 주로 잠금 중첩(Lock Nesting)과 재진입(Reentrancy)에서 비롯됩니다. 아래 다이어그램은 가장 흔한 3가지 데드락 시나리오와 각각의 해결 방법을 보여줍니다.

데드락 탐지: lockdep 출력 읽기

커널의 lockdep 서브시스템은 Notifier chain 관련 데드락을 런타임에 탐지합니다. 아래는 blocking notifier 콜백에서 같은 체인에 register를 시도했을 때 lockdep이 출력하는 경고 메시지 예시입니다.

# lockdep 경고 출력 예시
[  123.456789] ============================================
[  123.456790] WARNING: possible recursive locking detected
[  123.456791] --------------------------------------------
[  123.456792] kworker/0:1/123 is trying to acquire lock:
[  123.456793] ffff8880051a0000 (&nh->rwsem){++++}, at: blocking_notifier_chain_register+0x25/0x60
[  123.456795]
[  123.456796] but task is already holding lock:
[  123.456797] ffff8880051a0000 (&nh->rwsem){++++}, at: blocking_notifier_call_chain+0x1a/0x50
[  123.456799]
[  123.456800] other info that might help us debug this:
[  123.456801]  Possible unsafe locking scenario:
[  123.456802]        CPU0
[  123.456803]        ----
[  123.456804]   lock(&nh->rwsem);        # call_chain에서 read lock
[  123.456805]   lock(&nh->rwsem);        # register에서 write lock 시도
[  123.456806]
[  123.456807]  *** DEADLOCK ***

# 해결: 콜백에서 직접 register하지 말고 workqueue로 위임
# 또는 SRCU notifier로 전환

Workqueue 위임 패턴 상세

Blocking notifier 콜백에서 체인 수정이 필요한 경우, workqueue를 사용하여 데드락을 회피하는 패턴입니다.

/* 데드락 회피: blocking notifier 콜백에서 체인 수정 */
struct deferred_register {
    struct work_struct      work;
    struct notifier_block  *nb;
    bool                    is_register;  /* true=등록, false=해제 */
};

static void deferred_notifier_work(struct work_struct *work)
{
    struct deferred_register *dr =
        container_of(work, struct deferred_register, work);

    /* workqueue 컨텍스트: call_chain의 잠금 밖에서 실행 */
    if (dr->is_register)
        blocking_notifier_chain_register(&my_chain, dr->nb);
    else
        blocking_notifier_chain_unregister(&my_chain, dr->nb);

    kfree(dr);
}

/* 콜백 내에서 호출 */
static int my_callback(struct notifier_block *nb,
                        unsigned long event, void *data)
{
    if (event == SOME_EVENT) {
        struct deferred_register *dr;

        dr = kmalloc(sizeof(*dr), GFP_KERNEL);
        if (dr) {
            INIT_WORK(&dr->work, deferred_notifier_work);
            dr->nb = &another_nb;
            dr->is_register = true;
            schedule_work(&dr->work);
        }
    }
    return NOTIFY_OK;
}

die_chain / panic_notifier 상세

커널이 치명적 오류를 만나면 두 가지 알림 체인이 순서대로 동작합니다. die_chain은 oops/die 경로에서 호출되며, panic_notifier_list는 커널 패닉 직전 최후 정리 기회를 제공합니다. 두 체인 모두 Atomic Notifier이므로 콜백 내에서 슬립이 절대 허용되지 않습니다.

die_chain 구조

die_chain은 arch/x86/kernel/dumpstack.c(또는 아키텍처별 해당 파일)에서 notify_die()를 통해 호출됩니다. 이 함수는 트랩 핸들러, 페이지 폴트(Page Fault) 핸들러, MCE(Machine Check Exception) 경로 등에서 불립니다.

/* include/linux/kdebug.h */
enum die_val {
    DIE_OOPS = 1,
    DIE_INT3,          /* breakpoint */
    DIE_DEBUG,         /* debug exception */
    DIE_PANIC,         /* panic 직전 */
    DIE_NMI,           /* NMI */
    DIE_DIE,           /* 커널 die() 진입 */
    DIE_NMIUNKNOWN,    /* 출처 불명 NMI */
    DIE_NMIWATCHDOG,   /* NMI watchdog */
    DIE_KERNELDEBUG,   /* 커널 디버거 */
    DIE_TRAP,          /* 일반 트랩 */
    DIE_GPF,           /* General Protection Fault */
    DIE_CALL,          /* 소프트웨어 호출 */
    DIE_PAGE_FAULT,    /* 페이지 폴트 */
};

/* kernel/notifier.c */
static ATOMIC_NOTIFIER_HEAD(die_chain);

int register_die_notifier(struct notifier_block *nb)
{
    return atomic_notifier_chain_register(&die_chain, nb);
}

/* notify_die() — 아키텍처 트랩 핸들러에서 호출 */
int notify_die(enum die_val val, const char *str,
               struct pt_regs *regs, long err,
               int trap, int sig)
{
    struct die_args args = {
        .regs   = regs,
        .str    = str,
        .err    = err,
        .trapnr = trap,
        .signr  = sig,
    };
    return atomic_notifier_call_chain(&die_chain, val, &args);
}

panic_notifier_list

panic_notifier_list는 kernel/panic.c의 panic() 함수에서 호출됩니다. 시스템이 더 이상 복구 불가능한 상태에서 최후의 정리를 수행합니다.

/* kernel/panic.c */
ATOMIC_NOTIFIER_HEAD(panic_notifier_list);
EXPORT_SYMBOL(panic_notifier_list);

void panic(const char *fmt, ...)
{
    /* ... 초기 설정 ... */
    atomic_notifier_call_chain(&panic_notifier_list,
                                PANIC_NOTIFIER, buf);
    /* ... kmsg dump, kdump, reboot ... */
}

실제 사용 예

die_notifier 실전 구현: 커스텀 크래시 덤프

아래 예제는 커널 oops/die 이벤트를 가로채서 하드웨어 레지스터 상태를 비휘발 메모리(NVRAM)에 저장하는 die notifier의 실전 구현입니다. die 콜백은 매우 제한적인 환경에서 실행되므로 특별한 주의가 필요합니다.

/* 커스텀 die notifier: 하드웨어 상태를 비휘발 메모리에 저장
 * die 컨텍스트 제약: NMI 안전, sleep 불가, 최소 작업만 수행 */
#include <linux/module.h>
#include <linux/kdebug.h>
#include <linux/notifier.h>
#include <asm/io.h>

static void __iomem *nvram_base;

/* 크래시 정보 헤더 (NVRAM에 저장) */
struct crash_header {
    u32  magic;       /* 0xDEADC0DE */
    u32  die_val;     /* DIE_OOPS, DIE_GPF 등 */
    u64  timestamp;   /* RDTSC 값 */
    u64  rip;         /* 크래시 지점 명령 포인터 */
    u64  rsp;         /* 스택 포인터 */
    u64  cr2;         /* 페이지 폴트 주소 (해당 시) */
    int  trap_nr;     /* 트랩 번호 */
    int  error_code;  /* 에러 코드 */
} __packed;

static int my_die_handler(struct notifier_block *nb,
                           unsigned long val, void *data)
{
    struct die_args *args = data;
    struct crash_header hdr;

    /* NMI 안전한 작업만 수행 — 잠금 획득 금지 */

    switch (val) {
    case DIE_OOPS:
    case DIE_GPF:
    case DIE_TRAP:
    case DIE_PAGE_FAULT:
        hdr.magic      = 0xDEADC0DE;
        hdr.die_val    = (u32)val;
        hdr.timestamp  = rdtsc();
        hdr.rip        = args->regs ? args->regs->ip : 0;
        hdr.rsp        = args->regs ? args->regs->sp : 0;
        hdr.cr2        = (val == DIE_PAGE_FAULT) ?
                         read_cr2() : 0;
        hdr.trap_nr    = args->trapnr;
        hdr.error_code = (int)args->err;

        /* MMIO 쓰기: 잠금 없이 직접 접근 */
        memcpy_toio(nvram_base, &hdr, sizeof(hdr));
        break;

    case DIE_INT3:
        /* breakpoint — 디버거가 처리하도록 넘김 */
        return NOTIFY_DONE;

    case DIE_NMI:
        /* NMI watchdog — 타이머 상태만 간단히 기록 */
        writel(0xNMINMI00, nvram_base + sizeof(hdr));
        break;
    }

    /* NOTIFY_DONE: 다른 핸들러(kgdb, perf)도 이벤트 수신 가능
     * NOTIFY_STOP: 다른 핸들러 차단 — 일반적으로 사용하지 않음 */
    return NOTIFY_DONE;
}

static struct notifier_block my_die_nb = {
    .notifier_call = my_die_handler,
    .priority      = 0,  /* 기본: kgdb(INT_MAX)보다 낮은 우선순위 */
};

static int __init my_die_init(void)
{
    nvram_base = ioremap(0xFED10000, 4096);
    if (!nvram_base)
        return -ENOMEM;

    return register_die_notifier(&my_die_nb);
}

static void __exit my_die_exit(void)
{
    unregister_die_notifier(&my_die_nb);
    iounmap(nvram_base);
}

Reboot Notifier Chain

시스템이 재부팅, 종료(halt), 전원 차단(power off)될 때 드라이버와 서브시스템에 정리 기회를 제공하는 Blocking Notifier Chain입니다. kernel/reboot.c에 정의되어 있으며, sys_reboot() 시스템 콜(System Call) 경로에서 호출됩니다.

Reboot 이벤트 종류

API 및 등록

/* kernel/reboot.c */
static BLOCKING_NOTIFIER_HEAD(reboot_notifier_list);

int register_reboot_notifier(struct notifier_block *nb);
int unregister_reboot_notifier(struct notifier_block *nb);

/* devm 래퍼: device 수명과 자동 연결 */
int devm_register_reboot_notifier(struct device *dev,
                                   struct notifier_block *nb);

콜백 우선순위와 순서

reboot notifier는 우선순위가 높은 콜백부터 실행됩니다. 일반적으로 하드웨어 드라이버는 낮은 우선순위(먼저 호출되어 하드웨어 상태 저장), 파일시스템(Filesystem)은 높은 우선순위(나중에 호출되어 최종 플러시)로 등록합니다.

/* 예제: 커스텀 reboot notifier */
static int my_reboot_handler(struct notifier_block *nb,
                              unsigned long action, void *data)
{
    switch (action) {
    case SYS_RESTART:
        pr_info("my_driver: saving state before restart\n");
        my_hw_save_state();
        break;
    case SYS_HALT:
    case SYS_POWER_OFF:
        pr_info("my_driver: shutting down hardware\n");
        my_hw_shutdown();
        break;
    }
    return NOTIFY_DONE;
}

static struct notifier_block my_reboot_nb = {
    .notifier_call = my_reboot_handler,
    .priority      = 0,   /* 기본 우선순위 */
};

static int __init my_init(void)
{
    return register_reboot_notifier(&my_reboot_nb);
}

static void __exit my_exit(void)
{
    unregister_reboot_notifier(&my_reboot_nb);
}

restart_handler_list: SoC별 리셋 핸들러

restart_handler_list는 실제 하드웨어 리셋을 수행하는 별도의 체인입니다. SoC 드라이버가 아키텍처별 리셋 메커니즘(watchdog 리셋, PMIC 리셋 등)을 등록하며, 우선순위가 가장 높은 핸들러 하나만 실행됩니다.

/* kernel/reboot.c */
void do_kernel_restart(char *cmd)
{
    atomic_notifier_call_chain(&restart_handler_list,
                                reboot_mode, cmd);
}

/* 드라이버 등록 예: watchdog 기반 리셋 */
static int wdt_restart(struct notifier_block *nb,
                        unsigned long action, void *data)
{
    writel(0x1, wdt_base + WDT_RESET_REG);
    mdelay(100);
    return NOTIFY_DONE;
}

static struct notifier_block wdt_restart_nb = {
    .notifier_call = wdt_restart,
    .priority      = 128,  /* 높은 우선순위: 선호 리셋 방법 */
};

시스템 재부팅 전체 시퀀스

아래 다이어그램은 사용자 공간의 reboot 명령부터 실제 하드웨어 리셋까지의 전체 흐름에서 reboot notifier와 restart handler가 호출되는 시점을 보여줍니다.

devm_register_reboot_notifier 활용

devm_register_reboot_notifier()는 디바이스 수명 주기와 연동된 reboot notifier 등록 함수입니다. 디바이스가 제거될 때 자동으로 unregister가 호출되므로, module_exit에서 명시적으로 해제할 필요가 없습니다.

/* devm 기반 reboot notifier: 자동 수명 관리 */
static int my_reboot_cb(struct notifier_block *nb,
                          unsigned long action, void *data)
{
    struct my_device *mydev =
        container_of(nb, struct my_device, reboot_nb);

    switch (action) {
    case SYS_RESTART:
    case SYS_HALT:
    case SYS_POWER_OFF:
        /* 디바이스 고유 정리 작업 */
        my_hw_flush_and_stop(mydev);
        break;
    }
    return NOTIFY_DONE;
}

static int my_probe(struct platform_device *pdev)
{
    struct my_device *mydev;
    int ret;

    mydev = devm_kzalloc(&pdev->dev, sizeof(*mydev), GFP_KERNEL);
    if (!mydev)
        return -ENOMEM;

    mydev->reboot_nb.notifier_call = my_reboot_cb;
    mydev->reboot_nb.priority = 0;

    /* devm_: 디바이스 제거 시 자동 unregister */
    ret = devm_register_reboot_notifier(&pdev->dev,
                                         &mydev->reboot_nb);
    if (ret)
        return ret;

    /* remove 함수에서 unregister 불필요 — devm이 자동 처리 */
    return 0;
}

네트워크 Notifier Chain

리눅스 네트워크 스택(Network Stack)은 다양한 이벤트를 notifier chain으로 전파합니다. NIC 상태 변경, IP 주소 할당, 라우팅 테이블(Routing Table) 갱신 등 모든 네트워크 상태 변화가 구독자에게 알림됩니다.

netdev_chain 이벤트 목록

call_netdevice_notifiers() 호출 경로

/* net/core/dev.c */
static RAW_NOTIFIER_HEAD(netdev_chain);

int call_netdevice_notifiers(unsigned long val,
                              struct net_device *dev)
{
    struct netdev_notifier_info info = {
        .dev = dev,
    };
    return call_netdevice_notifiers_info(val, &info);
}

/* 내부적으로 rtnl_lock()으로 보호 — raw이지만 사실상 blocking처럼 동작 */
static int call_netdevice_notifiers_info(unsigned long val,
                                          struct netdev_notifier_info *info)
{
    ASSERT_RTNL();  /* rtnl_lock 보유 확인 */
    return raw_notifier_call_chain(&netdev_chain, val, info);
}

netevent_notifier: 이웃 서브시스템 이벤트

/* net/core/netevent.c */
static ATOMIC_NOTIFIER_HEAD(netevent_notif_chain);

/* 이벤트 종류 */
enum netevent_notif_type {
    NETEVENT_NEIGH_UPDATE,       /* ARP/NDP 엔트리 갱신 */
    NETEVENT_REDIRECT,           /* ICMP 리다이렉트 수신 */
    NETEVENT_DELAY_PROBE_TIME_UPDATE, /* 탐사 간격 변경 */
    NETEVENT_IPV4_MPATH_HASH_UPDATE,  /* 멀티패스 해시 정책 변경 */
    NETEVENT_IPV6_MPATH_HASH_UPDATE,
};

inet/inet6addr_chain: IP 주소 변경 알림

/* net/ipv4/devinet.c */
BLOCKING_NOTIFIER_HEAD(inetaddr_chain);  /* IPv4 주소 변경 */
int register_inetaddr_notifier(struct notifier_block *nb);

/* net/ipv6/addrconf.c */
BLOCKING_NOTIFIER_HEAD(inet6addr_chain); /* IPv6 주소 변경 */
int register_inet6addr_notifier(struct notifier_block *nb);

/* 이벤트: NETDEV_UP, NETDEV_DOWN (주소 추가/삭제 시) */
/* 콜백 데이터: struct in_ifaddr * (IPv4) / struct inet6_ifaddr * (IPv6) */

fib_chain: 라우팅 테이블 변경

/* net/ipv4/fib_trie.c */
static ATOMIC_NOTIFIER_HEAD(fib_chain);

/* 이벤트 */
#define FIB_EVENT_ENTRY_REPLACE  0
#define FIB_EVENT_ENTRY_APPEND   1
#define FIB_EVENT_ENTRY_ADD      2
#define FIB_EVENT_ENTRY_DEL      3
#define FIB_EVENT_RULE_ADD       4
#define FIB_EVENT_RULE_DEL       5

/* switchdev 드라이버가 이를 구독하여 HW FIB 오프로드 수행 */
int register_fib_notifier(struct net *net,
                          struct notifier_block *nb,
                          void (*cb)(struct notifier_block *nb,
                                      unsigned long event, void *ptr),
                          struct netlink_ext_ack *extack);

CPU 핫플러그 Notifier

Linux 4.10에서 기존 register_cpu_notifier() API는 deprecated되고, 상태 머신 기반의 cpuhp_setup_state()로 전환되었습니다. 새 API는 각 상태 전이마다 startup/teardown 콜백 쌍을 등록하여 대칭적 초기화/정리를 보장합니다.

핫플러그 상태 머신

CPU가 온라인/오프라인될 때 여러 단계(state)를 거칩니다. 각 단계마다 등록된 콜백이 호출되며, 실패 시 자동 롤백(Rollback)됩니다.

cpuhp_setup_state() API

/* include/linux/cpuhotplug.h */

/* 정적 상태: 미리 정의된 슬롯에 등록 */
int cpuhp_setup_state(enum cpuhp_state state,
                       const char *name,
                       int (*startup)(unsigned int cpu),
                       int (*teardown)(unsigned int cpu));

/* 동적 상태: CPUHP_AP_ONLINE_DYN에서 자동 할당 */
/* 반환값이 양수이면 할당된 state 번호 */
int cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, "my:online",
                       my_cpu_online, my_cpu_offline);

/* no-call 변형: 기존 온라인 CPU에 대해 콜백 미호출 */
int cpuhp_setup_state_nocalls(enum cpuhp_state state,
                              const char *name,
                              int (*startup)(unsigned int cpu),
                              int (*teardown)(unsigned int cpu));

/* 인스턴스 기반: 여러 인스턴스가 같은 state 공유 */
int cpuhp_setup_state_multi(enum cpuhp_state state,
                            const char *name,
                            int (*startup)(unsigned int cpu,
                                           struct hlist_node *node),
                            int (*teardown)(unsigned int cpu,
                                            struct hlist_node *node));

인스턴스 기반 vs 싱글턴 콜백

/* 인스턴스 기반 예제: 블록 디바이스 per-CPU 큐 */
static enum cpuhp_state blk_mq_hp_state;

static int blk_mq_hctx_notify_online(unsigned int cpu,
                                      struct hlist_node *node)
{
    struct blk_mq_hw_ctx *hctx =
        hlist_entry_safe(node, struct blk_mq_hw_ctx, cpuhp_online);
    /* CPU가 온라인되면 해당 CPU의 하드웨어 큐 활성화 */
    blk_mq_tag_wakeup_all(hctx->tags, true);
    return 0;
}

PM (Power Management) Notifier

전원 관리(PM) notifier는 시스템 서스펜드/하이버네이션 전후에 드라이버와 서브시스템에 알림을 보내는 Blocking Notifier Chain입니다. 콜백에서 NOTIFY_BAD를 반환하면 서스펜드를 거부할 수 있습니다.

PM 이벤트 종류

API 및 콜백 패턴

/* kernel/power/main.c */
static BLOCKING_NOTIFIER_HEAD(pm_chain_head);

int register_pm_notifier(struct notifier_block *nb);
int unregister_pm_notifier(struct notifier_block *nb);

/* 서스펜드 거부 예제 */
static int my_pm_handler(struct notifier_block *nb,
                          unsigned long event, void *data)
{
    switch (event) {
    case PM_SUSPEND_PREPARE:
        if (critical_operation_in_progress()) {
            pr_warn("my_driver: blocking suspend — critical op\n");
            return NOTIFY_BAD;  /* 서스펜드 거부! */
        }
        flush_all_pending_work();
        save_hardware_state();
        break;
    case PM_POST_SUSPEND:
        restore_hardware_state();
        break;
    }
    return NOTIFY_OK;
}

static struct notifier_block my_pm_nb = {
    .notifier_call = my_pm_handler,
    .priority      = 0,
};

콜백 순서 의존성

PM notifier의 호출 순서는 우선순위에 의해 결정됩니다. 일반적으로 서브시스템 수준 콜백이 먼저 실행되고 개별 드라이버 콜백이 나중에 실행됩니다. 디바이스 수준의 서스펜드/리줌은 별도의 dev_pm_ops 프레임워크가 담당하며, PM notifier는 그 이전 단계입니다.

서스펜드 진행 순서:

1. pm_notifier_call_chain(PM_SUSPEND_PREPARE) ← PM notifier
2. suspend_freeze_processes() ← 프로세스 동결
3. dpm_suspend_start() ← dev_pm_ops.prepare
4. dpm_suspend() ← dev_pm_ops.suspend
5. platform_suspend() ← 아키텍처별 진입

리줌은 역순:

1. platform_resume()
2. dpm_resume()
3. dpm_resume_end()
4. suspend_thaw_processes()
5. pm_notifier_call_chain(PM_POST_SUSPEND) ← PM notifier

서스펜드/리줌 전체 시퀀스

아래 다이어그램은 시스템 서스펜드(Suspend)와 리줌(Resume) 과정에서 PM notifier가 호출되는 시점과 NOTIFY_BAD 롤백 경로를 보여줍니다.

메모리 Notifier Chain

메모리 핫플러그와 메모리 압박 상황에서 서브시스템에 알림을 전달하는 notifier chain 그룹입니다.

memory_chain: 메모리 핫플러그

/* mm/memory_hotplug.c */
static BLOCKING_NOTIFIER_HEAD(memory_chain);

int register_memory_notifier(struct notifier_block *nb);
int unregister_memory_notifier(struct notifier_block *nb);

메모리 핫플러그 이벤트

/* 메모리 핫플러그 notifier 예제 */
static int my_memory_cb(struct notifier_block *nb,
                         unsigned long action, void *data)
{
    struct memory_notify *mn = data;

    switch (action) {
    case MEM_GOING_ONLINE:
        pr_info("memory block %lu going online (start_pfn=%lu, nr=%lu)\n",
                mn->start_pfn >> 15, mn->start_pfn, mn->nr_pages);
        /* 페이지 범위에 대한 자료구조 사전 할당 */
        if (expand_my_page_table(mn->start_pfn, mn->nr_pages))
            return NOTIFY_BAD;  /* 메모리 부족: 온라인 거부 */
        break;
    case MEM_CANCEL_ONLINE:
        shrink_my_page_table(mn->start_pfn, mn->nr_pages);
        break;
    case MEM_OFFLINE:
        shrink_my_page_table(mn->start_pfn, mn->nr_pages);
        break;
    }
    return NOTIFY_OK;
}

vmpressure notifier: 메모리 압박 알림

/* mm/vmpressure.c */
/* vmpressure는 memcg별 이벤트로, eventfd 기반 */
/* cgroup v2의 memory.pressure 인터페이스와 연동 */

/* 압박 수준 */
enum vmpressure_levels {
    VMPRESSURE_LOW,      /* 경미한 압박 (캐시 회수 시작) */
    VMPRESSURE_MEDIUM,   /* 중간 압박 (스왑 활발) */
    VMPRESSURE_CRITICAL, /* 위험 (OOM 임박) */
};

/* 사용자 공간에서 모니터링:
 * /sys/fs/cgroup//memory.pressure
 * PSI(Pressure Stall Information) 인터페이스
 */

OOM notifier

/* mm/oom_kill.c */
static BLOCKING_NOTIFIER_HEAD(oom_notify_list);

int register_oom_notifier(struct notifier_block *nb);
int unregister_oom_notifier(struct notifier_block *nb);

/* OOM notifier는 OOM killer 발동 전에 호출됨 */
/* 콜백이 메모리를 확보하면 NOTIFY_OK 반환 → OOM kill 회피 가능 */
static int my_oom_handler(struct notifier_block *nb,
                           unsigned long action, void *data)
{
    unsigned long freed = release_my_caches();
    if (freed > 0) {
        pr_info("my_driver: freed %lu pages, avoiding OOM\n", freed);
        return NOTIFY_OK;  /* OOM killer 호출 억제 시도 */
    }
    return NOTIFY_DONE;     /* 관심 없음 */
}

메모리 Notifier 이벤트 흐름

아래 다이어그램은 메모리 핫플러그 체인의 이벤트 상태 전이, vmpressure 알림 수준, OOM notifier의 동작을 한눈에 보여줍니다.

반환값 프로토콜

Notifier 콜백의 반환값은 체인 전파 동작을 제어하는 핵심 메커니즘입니다. 반환값은 단순 정수가 아니라 비트마스크 기반 프로토콜을 따릅니다.

반환값 정의

/* include/linux/notifier.h */
#define NOTIFY_DONE       0x0000   /* 관심 없음, 다음 콜백 계속 */
#define NOTIFY_OK         0x0001   /* 성공 처리, 다음 콜백 계속 */
#define NOTIFY_BAD        (NOTIFY_STOP_MASK | 0x0002)
                                    /* 에러/거부 + 즉시 중단 */
#define NOTIFY_STOP       (NOTIFY_STOP_MASK | NOTIFY_OK)
                                    /* 성공 + 즉시 중단 */

#define NOTIFY_STOP_MASK  0x8000   /* 이 비트가 설정되면 체인 중단 */

반환값 의미 비교

notifier_to_errno / errno_to_notifier 변환

/* include/linux/notifier.h */
static inline int notifier_from_errno(int err)
{
    if (err)
        return NOTIFY_STOP_MASK | (NOTIFY_OK - err);
    return NOTIFY_OK;
}

static inline int notifier_to_errno(int ret)
{
    ret &= ~NOTIFY_STOP_MASK;
    return ret > NOTIFY_OK ? NOTIFY_OK - ret : 0;
}

/* 사용 예: 호출자 측 */
ret = blocking_notifier_call_chain(&my_chain, EVENT, data);
ret = notifier_to_errno(ret);
if (ret) {
    pr_err("notifier returned error: %d\n", ret);
    goto rollback;
}

우선순위와 순서 제어

struct notifier_block의 priority 필드는 체인 내 콜백 실행 순서를 결정합니다. 높은 값이 먼저 실행되며, 같은 우선순위에서는 나중에 등록된 콜백이 먼저 실행됩니다(LIFO).

우선순위 메커니즘

/* kernel/notifier.c: 등록 시 정렬 삽입 */
static int notifier_chain_register(
    struct notifier_block **nl,
    struct notifier_block *n)
{
    while ((*nl) != NULL) {
        /* priority가 높은 것이 리스트 앞쪽 */
        if (n->priority > (*nl)->priority)
            break;
        if (n->priority == (*nl)->priority &&
            n == *nl)          /* 중복 등록 방지 */
            return -EEXIST;
        nl = &((*nl)->next);
    }
    n->next = *nl;
    rcu_assign_pointer(*nl, n);
    return 0;
}

커널 서브시스템별 우선순위 관례

우선순위 관련 문제

/* 안티패턴: 우선순위에 의존하는 취약한 설계 */
/* 모듈 A: 이벤트를 변환하여 전달 */
static struct notifier_block transformer_nb = {
    .notifier_call = transform_event,
    .priority      = 10,   /* 모듈 B보다 먼저 실행 의도 */
};

/* 모듈 B: 변환된 이벤트 소비 */
static struct notifier_block consumer_nb = {
    .notifier_call = consume_event,
    .priority      = 0,    /* 모듈 A 이후 실행 의도 */
};

/* 문제: 모듈 A가 로드되지 않으면 모듈 B는 원본 이벤트를 수신함
 * 해결: 모듈 간 직접 의존성이 있으면 notifier 대신 직접 함수 호출 사용
 */

디버깅과 트레이싱

Notifier chain 콜백의 지연, 오류, 충돌을 진단하기 위한 다양한 커널 디버깅 기법을 소개합니다.

ftrace를 이용한 notifier 추적

# notifier_call_chain 함수 진입/종료 추적
cd /sys/kernel/debug/tracing
echo 'notifier_call_chain' > set_ftrace_filter
echo 'function_graph' > current_tracer
echo 1 > tracing_on

# 특정 notifier chain 호출 추적
echo 'blocking_notifier_call_chain raw_notifier_call_chain atomic_notifier_call_chain' > set_ftrace_filter

# 결과 확인
cat trace

# 출력 예:
#  1)               |  blocking_notifier_call_chain() {
#  1)               |    notifier_call_chain() {
#  1)   0.892 us    |      my_pm_handler();
#  1)   0.341 us    |      driver_suspend_cb();
#  1)   2.104 us    |    }
#  1)   2.561 us    |  }

Notifier 트레이스포인트

# 사용 가능한 notifier 관련 트레이스포인트 확인
ls /sys/kernel/debug/tracing/events/notifier/

# notifier 등록/해제 이벤트 활성화 (커널 빌드 옵션 의존)
echo 1 > /sys/kernel/debug/tracing/events/notifier/enable

# CPU hotplug 관련 트레이스포인트
echo 1 > /sys/kernel/debug/tracing/events/cpuhp/enable
cat trace_pipe

BPF 기반 notifier 지연 분석

/* bpftrace 스크립트: notifier 콜백 지연 측정 */
/* bpftrace -e 아래 내용 */

/*
kprobe:notifier_call_chain
{
    @start[tid] = nsecs;
}

kretprobe:notifier_call_chain
/@start[tid]/
{
    $dur = nsecs - @start[tid];
    @latency = hist($dur);
    if ($dur > 1000000) {  // 1ms 이상
        printf("slow notifier chain: %d ns, comm=%s\n",
               $dur, comm);
    }
    delete(@start[tid]);
}
*/

# bpftrace로 느린 notifier 콜백 탐지
bpftrace -e '
kprobe:notifier_call_chain { @start[tid] = nsecs; }
kretprobe:notifier_call_chain /@start[tid]/ {
  $d = nsecs - @start[tid];
  @us = hist($d / 1000);
  if ($d > 1000000) {
    printf("SLOW %d us comm=%s\n", $d/1000, comm);
  }
  delete(@start[tid]);
}
'

kprobe를 이용한 notifier 콜백 인터셉트

kprobe를 사용하면 런타임에 특정 notifier 콜백의 진입/종료를 가로채서 인자 값, 반환값, 실행 시간을 기록할 수 있습니다. 모듈 수정 없이 디버깅이 가능하여 운영 환경에서 유용합니다.

/* kprobe 기반 notifier 콜백 모니터링 모듈 */
#include <linux/module.h>
#include <linux/kprobes.h>
#include <linux/notifier.h>

/* notifier_call_chain의 콜백 호출 지점을 추적 */
static struct kprobe kp = {
    .symbol_name = "notifier_call_chain",
};

static int handler_pre(struct kprobe *p,
                        struct pt_regs *regs)
{
    /* x86_64: rdi=**nl, rsi=val, rdx=*v, rcx=nr_to_call */
    struct notifier_block **nl =
        (struct notifier_block **)regs->di;
    unsigned long val = regs->si;

    if (*nl) {
        pr_info("notifier_call_chain: event=%lu first_cb=%ps pri=%d\n",
                val, (*nl)->notifier_call, (*nl)->priority);
    }
    return 0;
}

static int __init kp_init(void)
{
    kp.pre_handler = handler_pre;
    return register_kprobe(&kp);
}

static void __exit kp_exit(void)
{
    unregister_kprobe(&kp);
}
module_init(kp_init);
module_exit(kp_exit);
MODULE_LICENSE("GPL");

Notifier Error Injection 프레임워크

커널은 lib/notifier-error-inject.c에 notifier 콜백의 에러 반환을 시뮬레이션하는 테스트 프레임워크를 제공합니다. 이를 통해 NOTIFY_BAD 반환 시 시스템의 롤백 동작을 검증할 수 있습니다.

# 커널 빌드 옵션
CONFIG_NOTIFIER_ERROR_INJECTION=m
CONFIG_CPU_NOTIFIER_ERROR_INJECT=m
CONFIG_PM_NOTIFIER_ERROR_INJECT=m
CONFIG_MEMORY_NOTIFIER_ERROR_INJECT=m

# PM notifier 에러 주입 예제
modprobe pm-notifier-error-inject

# 다음 PM_SUSPEND_PREPARE에서 -ENOMEM 반환하도록 설정
echo -12 > /sys/kernel/debug/notifier-error-inject/pm/actions/PM_SUSPEND_PREPARE/error

# 서스펜드 시도 → PM notifier가 NOTIFY_BAD 반환 → 서스펜드 거부
echo mem > /sys/power/state
# dmesg에서 확인: "PM: Some devices failed to suspend, or early wake event detected"

# 에러 주입 해제
echo 0 > /sys/kernel/debug/notifier-error-inject/pm/actions/PM_SUSPEND_PREPARE/error

# CPU hotplug 에러 주입
modprobe cpu-notifier-error-inject
echo -12 > /sys/kernel/debug/notifier-error-inject/cpu/actions/CPU_UP_PREPARE/error
# CPU online 시도가 거부됨
echo 1 > /sys/devices/system/cpu/cpu1/online

# 메모리 핫플러그 에러 주입
modprobe memory-notifier-error-inject
echo -12 > /sys/kernel/debug/notifier-error-inject/memory/actions/MEM_GOING_ONLINE/error

콜백 내 크래시 디버깅

/* 크래시 진단을 위한 디버그 래퍼 */
static int debug_notifier_call_chain(
    struct notifier_block **nl,
    unsigned long val, void *v)
{
    struct notifier_block *nb;
    int ret;

    for (nb = rcu_dereference(*nl); nb; nb = rcu_dereference(nb->next)) {
        /* 콜백 주소가 유효한 커널 텍스트인지 검증 */
        if (!kernel_text_address((unsigned long)nb->notifier_call)) {
            WARN(1, "invalid notifier callback %px\n",
                 nb->notifier_call);
            continue;
        }
        ret = nb->notifier_call(nb, val, v);
        if (ret & NOTIFY_STOP_MASK)
            break;
    }
    return ret;
}

일반적 디버깅 시나리오

설계 패턴과 모범 사례

Notifier chain을 올바르게 설계하고 사용하기 위한 패턴과 안티패턴을 정리합니다.

언제 Notifier Chain을 사용해야 하는가

대안 메커니즘 비교

모듈 언로드 시 안전한 해제 패턴

/* 패턴 1: 기본 — module_exit에서 해제 */
static struct notifier_block my_nb = {
    .notifier_call = my_callback,
};

static int __init my_init(void)
{
    return register_netdevice_notifier(&my_nb);
}

static void __exit my_exit(void)
{
    unregister_netdevice_notifier(&my_nb);
    /* unregister 이후에만 모듈 리소스 해제 */
    kfree(my_data);
}

/* 패턴 2: devm — device 수명 자동 관리 */
static int my_probe(struct platform_device *pdev)
{
    return devm_register_reboot_notifier(&pdev->dev, &my_nb);
    /* 디바이스 제거 시 자동 unregister */
}

/* 패턴 3: 에러 경로 안전 — goto 패턴 */
static int __init my_init(void)
{
    int ret;

    ret = register_pm_notifier(&my_pm_nb);
    if (ret)
        return ret;

    ret = register_netdevice_notifier(&my_net_nb);
    if (ret)
        goto err_net;

    ret = register_reboot_notifier(&my_reboot_nb);
    if (ret)
        goto err_reboot;

    return 0;

err_reboot:
    unregister_netdevice_notifier(&my_net_nb);
err_net:
    unregister_pm_notifier(&my_pm_nb);
    return ret;
}

SRCU vs Blocking: 트레이드오프

커널 모듈(Kernel Module) Notifier 사용 템플릿

/* 완전한 커널 모듈 템플릿: notifier chain 사용 */
#include <linux/module.h>
#include <linux/notifier.h>
#include <linux/netdevice.h>
#include <linux/reboot.h>

static int my_netdev_event(struct notifier_block *nb,
                            unsigned long event, void *ptr)
{
    struct net_device *dev = netdev_notifier_info_to_dev(ptr);

    switch (event) {
    case NETDEV_UP:
        pr_info("[my_mod] %s is up\n", dev->name);
        break;
    case NETDEV_DOWN:
        pr_info("[my_mod] %s is down\n", dev->name);
        break;
    default:
        break;  /* 관심 없는 이벤트 무시 */
    }
    return NOTIFY_DONE;
}

static struct notifier_block my_netdev_nb = {
    .notifier_call = my_netdev_event,
};

static int __init my_mod_init(void)
{
    int ret;

    ret = register_netdevice_notifier(&my_netdev_nb);
    if (ret) {
        pr_err("[my_mod] failed to register notifier: %d\n", ret);
        return ret;
    }

    pr_info("[my_mod] loaded\n");
    return 0;
}

static void __exit my_mod_exit(void)
{
    unregister_netdevice_notifier(&my_netdev_nb);
    pr_info("[my_mod] unloaded\n");
}

module_init(my_mod_init);
module_exit(my_mod_exit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Notifier Chain example module");

흔한 실수 요약

/* 재진입 가드 패턴 */
static DEFINE_PER_CPU(int, in_notifier_cb);

static int my_netdev_cb(struct notifier_block *nb,
                          unsigned long event, void *ptr)
{
    if (__this_cpu_read(in_notifier_cb))
        return NOTIFY_DONE;  /* 재진입 방지 */

    __this_cpu_write(in_notifier_cb, 1);

    /* ... 작업 수행 ... */

    __this_cpu_write(in_notifier_cb, 0);
    return NOTIFY_DONE;
}

PREEMPT_RT 환경에서의 Notifier Chain

PREEMPT_RT(실시간 선점 패치)는 스핀락 시맨틱(Semantics)을 근본적으로 변경합니다. 일반 커널에서 spinlock_t는 선점과 인터럽트를 비활성화하지만, PREEMPT_RT에서는 rt_mutex로 대체되어 슬립이 가능한 잠금이 됩니다. 이 변화는 각 Notifier Chain 변형의 동작에 직접적인 영향을 미칩니다.

Atomic notifier의 경우, PREEMPT_RT에서 스핀락이 슬리핑 잠금으로 바뀌므로 등록 경로에서 슬립이 가능해집니다. 다만 읽기 경로는 여전히 rcu_read_lock()을 사용하므로, PREEMPT_RT에서 RCU 읽기 구간이 선점 가능해지는 효과가 있습니다. 이는 콜백 실행 중 더 높은 우선순위 태스크에 의해 선점될 수 있음을 의미합니다.

Blocking notifier와 SRCU notifier는 원래 슬립이 가능한 잠금을 사용하므로, PREEMPT_RT에서도 동작이 크게 변하지 않습니다. 따라서 RT 시스템에서는 blocking이나 SRCU notifier를 선호하는 것이 안전합니다.

커널 Notifier Chain 전체 맵

Linux 커널에는 수십 개의 Notifier Chain이 여러 서브시스템에 걸쳐 정의되어 있습니다. 아래 다이어그램은 주요 Notifier Chain을 서브시스템별로 분류하고, 각 체인의 유형과 대표 이벤트를 정리한 것입니다.

참고자료

공식 문서

• Notifier Error Injection — Linux Kernel Documentation — 알림 체인 오류 주입 테스트 프레임워크 공식 문서입니다
• Device Driver Infrastructure — Linux Kernel Documentation — 디바이스 드라이버 인프라에서 notifier 활용을 설명합니다
• CPU Hotplug in the Kernel — Linux Kernel Documentation — CPU 핫플러그 알림 체인 사용 방법을 다룹니다
• Suspend and CPU Hotplug — Linux Kernel Documentation — PM notifier와 CPU 핫플러그 간 상호작용을 설명합니다

LWN.net 및 주요 참고 글

• Notifier chains in the kernel (LWN, 2006) — Alan Stern의 notifier chain 타입 분리 패치 시리즈에 대한 기사로, blocking/atomic 분리 배경을 설명합니다
• Notifiers and blocking (LWN, 2006) — 기존 단일 notifier_head에서 blocking과 atomic을 분리한 이유와 설계 결정을 다룹니다
• SRCU-based notifier chains (LWN, 2008) — SRCU notifier chain 도입 배경과 성능 특성을 설명합니다
• LWN Kernel Index — Notifiers — LWN의 notifier 관련 기사 색인 페이지입니다
• Avoiding the OOM killer with notifiers (LWN, 2005) — 메모리 부족 상황에서 notifier chain 활용 사례를 설명합니다

커널 소스 경로

서적 및 학습 자료

• Linux Kernel Development, 3rd Edition (Robert Love, 2010) — Chapter 4에서 커널 알림 메커니즘과 콜백 체인 패턴을 설명합니다
• Understanding the Linux Kernel, 3rd Edition (Bovet & Cesati, 2005) — 커널 내부 이벤트 전달 구조와 notifier chain 구현을 다룹니다
• Linux Device Drivers, 3rd Edition (Corbet, Rubini & Kroah-Hartman, 2005) — 디바이스 드라이버에서 notifier chain 활용 패턴을 설명합니다. 온라인 무료 공개판을 확인할 수 있습니다
• Professional Linux Kernel Architecture (Wolfgang Mauerer, 2008) — 네트워크 서브시스템의 netdev notifier chain 분석을 포함합니다

블로그 및 커뮤니티 자료

• Kernel Newbies — Notifiers FAQ — 초심자를 위한 notifier chain 기본 개념 정리입니다
• linux-insides — Notification Chains — 커널 내부 알림 체인 구현을 코드와 함께 상세히 분석합니다
• Bootlin Elixir — notifier_block 전체 사용처 — 커널 소스 내 notifier_block 참조를 확인할 수 있습니다

관련 문서