커널 개발 주의사항

// Thread A
spin_lock(&lock_a);
spin_lock(&lock_b);  // 항상 A → B
// critical section
spin_unlock(&lock_b);
spin_unlock(&lock_a);

// Thread B
spin_lock(&lock_a);  // 동일하게 A → B
spin_lock(&lock_b);
// critical section
spin_unlock(&lock_b);
spin_unlock(&lock_a);

// 방법 1: 내부 함수는 락 없이 호출 (caller가 잡음)
spin_lock(&my_lock);
__helper_function_locked();  // 락 보유 전제
spin_unlock(&my_lock);

// 방법 2: lockdep 어노테이션
void __helper_function_locked(void)
{
    lockdep_assert_held(&my_lock);  // 디버그: 락 보유 확인
    // ...
}

// 방법 3: 공개 API는 래퍼 제공
void helper_function(void)
{
    spin_lock(&my_lock);
    __helper_function_locked();
    spin_unlock(&my_lock);
}

static atomic_t counter = ATOMIC_INIT(0);

void increment(void)
{
    atomic_inc(&counter);  // 하드웨어 수준에서 원자적 보장
}

// 또는 spinlock 사용
static int counter = 0;
static DEFINE_SPINLOCK(counter_lock);

void increment(void)
{
    spin_lock(&counter_lock);
    counter++;
    spin_unlock(&counter_lock);
}

spin_lock(&my_lock);
void *ptr = kmalloc(1024, GFP_ATOMIC);  // OK: sleep 안 함
if (!ptr) {
    spin_unlock(&my_lock);
    return -ENOMEM;
}
// ... 작업 ...
kfree(ptr);
spin_unlock(&my_lock);

// 또는 락 밖에서 미리 할당
void *ptr = kmalloc(1024, GFP_KERNEL);
if (!ptr)
    return -ENOMEM;
spin_lock(&my_lock);
// ... 작업 ...
spin_unlock(&my_lock);
kfree(ptr);

// 방법 1: 처음부터 쓰기 락
write_lock(&my_rwlock);
if (need_modification) {
    // ... 수정 ...
}
write_unlock(&my_rwlock);

// 방법 2: 읽기 후 다시 확인
retry:
read_lock(&my_rwlock);
if (need_modification) {
    read_unlock(&my_rwlock);
    write_lock(&my_rwlock);
    if (!need_modification) {  // 조건 재확인
        write_unlock(&my_rwlock);
        goto retry;
    }
    // ... 수정 ...
    write_unlock(&my_rwlock);
    return;
}
read_unlock(&my_rwlock);

// Producer
data->value = 42;
smp_wmb();  // Write Memory Barrier: 이전 쓰기가 먼저 완료됨을 보장
data->ready = 1;

// Consumer
if (data->ready) {
    smp_rmb();  // Read Memory Barrier: 이후 읽기가 나중에 수행됨을 보장
    process(data->value);
}

// 또는 smp_store_release / smp_load_acquire 사용 (권장)
smp_store_release(&data->ready, 1);  // 이전 모든 쓰기 완료 보장
if (smp_load_acquire(&data->ready))  // 이후 모든 읽기 보장
    process(data->value);

int process_data(struct device *dev)
{
    int ret = 0;

    spin_lock(&dev->lock);

    if (!dev->ready) {
        ret = -EAGAIN;
        goto out_unlock;  // 정리 경로로 점프
    }

    // ... 작업 ...

out_unlock:
    spin_unlock(&dev->lock);
    return ret;
}

// 또는 guard/cleanup 계열 매크로 사용 (지원 커널에서 활용)
int process_data(struct device *dev)
{
    guard(spinlock)(&dev->lock);  // 스코프 벗어나면 자동 unlock

    if (!dev->ready)
        return -EAGAIN;  // OK: guard가 자동 정리

    // ... 작업 ...
    return 0;
}

// 업데이트 측 (writer)
struct config *old = rcu_dereference_protected(global_config,
                        lockdep_is_held(&config_mutex));
rcu_assign_pointer(global_config, new_config);
synchronize_rcu();  // 모든 기존 reader 완료 대기
kfree(old);         // 이제 안전

// 또는 콜백으로 비동기 해제
call_rcu(&old->rcu_head, config_free_rcu);

// 읽기 측 (reader)
rcu_read_lock();
struct config *cfg = rcu_dereference(global_config);
use_config(cfg);
rcu_read_unlock();

static DEFINE_SRCU(my_srcu);

int idx = srcu_read_lock(&my_srcu);
struct node *n = srcu_dereference(head, &my_srcu);
mutex_lock(&n->lock);  // OK: SRCU read-side에서는 sleep 가능
// ...
mutex_unlock(&n->lock);
srcu_read_unlock(&my_srcu, idx);

// 방법 1: 명시적 preempt 비활성화
preempt_disable();
int cpu = smp_processor_id();
per_cpu(my_counter, cpu)++;
preempt_enable();

// 방법 2: get_cpu()/put_cpu() (preempt 관리 포함)
int cpu = get_cpu();  // preempt_disable() + smp_processor_id()
per_cpu(my_counter, cpu)++;
put_cpu();            // preempt_enable()

// 방법 3: this_cpu_inc() (원자적, preempt 불필요)
this_cpu_inc(my_counter);  // 가장 간결하고 안전

// 패턴 1: read 해제 후 write 획득
read_lock(&my_rwlock);
bool update = needs_update;
read_unlock(&my_rwlock);

if (update) {
    write_lock(&my_rwlock);
    // 다시 조건 확인 (그 사이 변경 가능)
    if (still_needs_update)
        do_update();
    write_unlock(&my_rwlock);
}

// 패턴 2: 읽기 대부분이면 RCU가 더 적합
rcu_read_lock();
entry = rcu_dereference(global_entry);
// 읽기 (락 없이, 대기 없이)
rcu_read_unlock();

// wait_event가 조건 체크와 sleep을 원자적으로 처리
wait_event(my_wq, data_ready);  // 조건: 부작용 없는 표현식

// 인터럽트 가능 (시그널로 취소)
ret = wait_event_interruptible(my_wq, data_ready);
if (ret)
    return -ERESTARTSYS;

// 타임아웃 (jiffies 단위)
timeout = wait_event_timeout(my_wq, data_ready,
    msecs_to_jiffies(5000));
if (!timeout)
    return -ETIMEDOUT;

// 깨우기 (다른 컨텍스트에서)
data_ready = true;
wake_up(&my_wq);          // 하나의 waiter 깨우기
wake_up_all(&my_wq);      // 모든 waiter 깨우기
wake_up_interruptible(&my_wq);  // interruptible만

// seqlock은 값 타입(구조체 복사)에만 사용
struct timestamp {
    u64 seconds;
    u32 nanoseconds;
};
static seqlock_t ts_lock;
static struct timestamp current_ts;

// Reader: 값 전체를 로컬에 복사
struct timestamp ts;
unsigned seq;
do {
    seq = read_seqbegin(&ts_lock);
    ts = current_ts;  // 구조체 전체 복사 (포인터 역참조 아님)
} while (read_seqretry(&ts_lock, seq));
// ts는 일관된 스냅샷

// Writer: 독점 접근
write_seqlock(&ts_lock);
current_ts.seconds = new_secs;
current_ts.nanoseconds = new_nsecs;
write_sequnlock(&ts_lock);

// 포인터가 관련되면 RCU를 사용할 것!

// CPU 0 (Producer)
buffer[idx] = data;
smp_wmb();  // Write Memory Barrier: ①이 ② 전에 완료 보장
WRITE_ONCE(ready, 1);  // 컴파일러 최적화 방지

// CPU 1 (Consumer)
while (!READ_ONCE(ready))  // 컴파일러가 루프 밖으로 끌어내지 못하게
    cpu_relax();
smp_rmb();  // Read Memory Barrier: ③이 ④ 전에 완료 보장
val = buffer[idx];

// 또는 acquire/release 의미론 (더 가벼움)
// Producer:
smp_store_release(&ready, 1);  // wmb + WRITE_ONCE
// Consumer:
while (!smp_load_acquire(&ready))
    cpu_relax();

int init_device(struct device *dev)
{
    dev->buffer = kmalloc(4096, GFP_KERNEL);
    if (!dev->buffer)
        return -ENOMEM;

    dev->data = kmalloc(2048, GFP_KERNEL);
    if (!dev->data)
        goto err_free_buffer;

    return 0;

err_free_buffer:
    kfree(dev->buffer);
    dev->buffer = NULL;
    return -ENOMEM;
}

struct data *ptr = kmalloc(sizeof(*ptr), GFP_KERNEL);
kfree(ptr);
ptr = NULL;  // 다시 사용 방지

// 패턴: 해제 후 즉시 NULL 대입
kfree(ptr);
ptr = NULL;

void cleanup_device(struct device *dev)
{
    kfree(dev->buffer);
    dev->buffer = NULL;  // kfree(NULL)은 안전
    // ... 다른 작업 ...
    kfree(dev->buffer);  // OK: NULL이므로 무시됨
}

char buf[64];
strscpy(buf, user_string, sizeof(buf));  // 크기 제한, NULL 종료 보장

// 또는
size_t len;
if (copy_from_user(&len, user_ptr, sizeof(len)))
    return -EFAULT;
if (len > MAX_SIZE)  // 상한 검사
    return -EINVAL;
memcpy(dest, src, len);

struct device *dev = find_device(id);
if (!dev) {
    pr_err("Device %d not found\\n", id);
    return -ENODEV;
}
dev->status = ACTIVE;

dma_addr_t dma_addr;
void *buf = dma_alloc_coherent(&dev->dev, 4096, &dma_addr, GFP_KERNEL);
if (!buf)
    return -ENOMEM;

device_start_dma(dev, dma_addr);
// ... DMA 완료 대기 ...

dma_free_coherent(&dev->dev, 4096, buf, dma_addr);

// 또는 streaming DMA
void *buf = kmalloc(4096, GFP_KERNEL);
dma_addr_t dma_addr = dma_map_single(&dev->dev, buf, 4096, DMA_TO_DEVICE);
if (dma_mapping_error(&dev->dev, dma_addr)) {
    kfree(buf);
    return -ENOMEM;
}
device_start_dma(dev, dma_addr);
// ... DMA 완료 대기 ...
dma_unmap_single(&dev->dev, dma_addr, 4096, DMA_TO_DEVICE);
kfree(buf);

struct device *dev = find_device(id);  // refcount++
if (!dev)
    return -ENODEV;
use_device(dev);
put_device(dev);  // refcount-- (짝을 맞춤)

// 또는
void create_device(void)
{
    struct device *dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    kref_init(&dev->kref);  // refcount = 1
    kref_get(&dev->kref);   // refcount = 2 (register를 위한 참조)
    register_device(dev);
    kref_put(&dev->kref, device_release);  // 생성자 참조 해제, 아직 살아있음
}

int process_data(void)
{
    char *buffer = kmalloc(8192, GFP_KERNEL);
    if (!buffer)
        return -ENOMEM;
    // ...
    kfree(buffer);
    return 0;
}

// 또는 반복으로 변환
void iterative_function(int depth)
{
    for (int i = 0; i < depth; i++) {
        // ...
    }
}

// slab 캐시에서 할당 → slab 캐시에서 해제
struct my_obj *obj = kmem_cache_alloc(my_cache, GFP_KERNEL);
// ...
kmem_cache_free(my_cache, obj);

// kmalloc으로 할당 → kfree로 해제
struct my_obj *obj = kmalloc(sizeof(*obj), GFP_KERNEL);
// ...
kfree(obj);

// 모듈 종료 시 캐시 파괴
kmem_cache_destroy(my_cache);  // 모든 객체 해제 후에만!

static void process_data(void)
{
    char *path = kmalloc(PATH_MAX, GFP_KERNEL);
    if (!path)
        return;

    // 사용 후 해제
    kfree(path);
}

// 또는 __getname()으로 커널 pathbuf 풀 사용
char *path = __getname();
// ...
__putname(path);

// 작은 할당 (≤ 페이지 크기 수 배): kmalloc
void *small = kmalloc(256, GFP_KERNEL);
kfree(small);

// 큰 할당 (물리 연속 불필요): vmalloc
void *big = vmalloc(1024 * 1024);  // 1MB OK
vfree(big);

// 자동 선택: kvmalloc (작으면 kmalloc, 크면 vmalloc)
void *auto_buf = kvmalloc(size, GFP_KERNEL);
kvfree(auto_buf);  // 어떤 할당자든 올바르게 해제

// DMA 용: 반드시 DMA API 사용
void *dma_buf = dma_alloc_coherent(dev, size, &handle, GFP_KERNEL);
dma_free_coherent(dev, size, dma_buf, handle);

if (copy_from_user(&kernel_buf, user_ptr, size)) {
    return -EFAULT;  // 사용자 메모리 접근 실패
}
process_data(&kernel_buf);

struct file *f = filp_open("/dev/null", O_RDONLY, 0);
if (IS_ERR(f)) {
    return PTR_ERR(f);  // 에러 코드 추출
}
if (!inode) {  // NULL 체크는 별도로
    return -ENOENT;
}
// 이제 안전하게 사용 가능

// 또는 IS_ERR_OR_NULL() 사용
if (IS_ERR_OR_NULL(inode))
    return inode ? PTR_ERR(inode) : -ENOENT;

void cleanup(void)
{
    free_irq(...);             // 3 (역순)
    destroy_workqueue(...);   // 2
    unregister_chrdev(...);   // 1
}

static void my_clk_disable(void *data)
{
    clk_disable_unprepare(data);
}

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

    clk = devm_clk_get(&pdev->dev, NULL);
    if (IS_ERR(clk))
        return PTR_ERR(clk);

    ret = clk_prepare_enable(clk);
    if (ret)
        return ret;

    // 자동 정리 등록: probe 실패 시 또는 remove 시 자동 호출됨
    ret = devm_add_action_or_reset(&pdev->dev, my_clk_disable, clk);
    if (ret)
        return ret;  // _or_reset: 등록 실패 시 즉시 action 호출

    // 이후 실패해도 clk은 자동으로 disable됨 — goto 불필요!
    ret = some_other_init();
    if (ret)
        return ret;  // 그냥 반환하면 됨

    return 0;
}

static int init_subsystem(void)
{
    int ret;

    ret = alloc_resources();
    if (ret) {
        pr_err("alloc_resources failed: %d\\n", ret);  // 에러 코드 포함
        return ret;  // 원래 에러 그대로 전파
    }

    ret = register_device();
    if (ret) {
        pr_err("register_device failed: %d\\n", ret);
        goto err_register;
    }
    return 0;

err_register:
    free_resources();
    return ret;  // 원래 에러 코드
}

void timer_callback(struct timer_list *t)
{
    struct my_device *dev = from_timer(dev, t, timer);

    spin_lock(&dev->lock);  // OK: spinlock 사용
    // ... 짧은 작업 ...
    spin_unlock(&dev->lock);

    // 긴 작업은 workqueue로 스케줄링
    schedule_work(&dev->work);
}

void cleanup(void)
{
    del_timer_sync(&my_timer);  // 콜백 완료를 기다림
    kfree(dev);  // 이제 안전
}

void trigger_work(void)
{
    // work가 이미 큐에 있는지 확인
    if (!work_pending(&my_work))
        schedule_work(&my_work);
}

void cleanup(void)
{
    cancel_work_sync(&my_work);  // work 완료를 기다림
    kfree(dev);  // 이제 안전
}

void outer_function(void)
{
    unsigned long flags;
    spin_lock_irqsave(&lock_a, flags);  // IRQ 상태 저장
    inner_function();
    spin_unlock_irqrestore(&lock_a, flags);  // 원래 상태 복원
}

void inner_function(void)
{
    unsigned long flags;
    spin_lock_irqsave(&lock_b, flags);
    // ... 작업 ...
    spin_unlock_irqrestore(&lock_b, flags);  // OK: 올바른 상태 복원
}

int value;
if (copy_from_user(&value, user_ptr, sizeof(value)))
    return -EFAULT;

// 스레드 A: 타임아웃 대기
unsigned long timeout = wait_for_completion_timeout(&my_completion,
                                                    msecs_to_jiffies(5000));
if (!timeout) {
    pr_err("Operation timed out\\n");
    return -ETIMEDOUT;
}

// 인터럽트 가능한 대기
if (wait_for_completion_interruptible(&my_completion)) {
    return -ERESTARTSYS;  // 시그널 수신 시
}

// 스레드 B: 모든 경로에서 complete()
int worker(void *data)
{
    int ret = 0;
    if (error_condition) {
        ret = -EIO;
        goto done;
    }
    do_work();
done:
    complete(&my_completion);  // 에러/성공 모두 완료 시그널
    return ret;
}

// 재사용 시 반드시 재초기화
reinit_completion(&my_completion);

complete_all(&comp);
reinit_completion(&comp);    // done = 0으로 초기화
start_new_operation();
wait_for_completion(&comp);  // OK: 새 complete() 대기

// 방법 1: 정수 나눗셈 (밀리 단위 사용)
int calculate_ratio_milli(int a, int b)
{
    return (a * 1000) / b;  // 밀리 단위 비율
}

// 방법 2: 고정소수점 (10^6 스케일)
int temp_micro = sensor_value;  // 이미 μ단위로 저장

// 방법 3: 반드시 FPU가 필요하면 kernel_fpu_begin/end
kernel_fpu_begin();
// FPU 연산 (최소한으로, 짧게)
kernel_fpu_end();
// ⚠ kernel_fpu_begin()은 preempt_disable() 포함 → 짧게 사용

// 포인터: %p (해시된 값), %pK (kptr_restrict 따름)
printk("ptr = %p\\n", ptr);    // 해시된 주소 출력 (안전)
printk("ptr = %pK\\n", ptr);   // kptr_restrict에 따라 제어

// 특수 포인터 포맷
printk("func = %ps\\n", func);   // 심볼 이름 출력 (my_function)
printk("func = %pS\\n", func);   // 심볼+오프셋 (my_function+0x10/0x20)
printk("res = %pr\\n", &res);    // struct resource 출력
printk("mac = %pM\\n", mac);     // MAC 주소 (01:02:03:04:05:06)
printk("ip4 = %pI4\\n", &addr);  // IPv4 주소
printk("ip6 = %pI6c\\n", &addr); // IPv6 주소 (축약형)

// 올바른 크기 포맷
printk("size = %zu\\n", size);      // size_t
printk("dma = %pad\\n", &dma_addr); // dma_addr_t
printk("phys = %pa\\n", &phys);     // phys_addr_t

static int do_operation(void)
{
    unsigned long timeout;

    reinit_completion(&my_done);  // 재사용 전 반드시 재초기화
    start_hw_operation();

    timeout = wait_for_completion_timeout(&my_done,
                msecs_to_jiffies(5000));  // 5초 타임아웃
    if (!timeout) {
        dev_err(dev, "operation timed out\\n");
        return -ETIMEDOUT;
    }

    return 0;
}

// 인터럽트 가능한 대기 (시그널로 취소 가능)
static int do_interruptible(void)
{
    long ret;

    reinit_completion(&my_done);
    start_hw_operation();

    ret = wait_for_completion_interruptible_timeout(&my_done,
            msecs_to_jiffies(5000));
    if (ret == 0)
        return -ETIMEDOUT;
    if (ret < 0)
        return ret;  // -ERESTARTSYS (시그널에 의해 중단)

    return 0;
}

static struct task_struct *my_thread;

static int thread_fn(void *data)
{
    while (!kthread_should_stop()) {  // 중지 요청 확인
        if (kthread_should_park()) {
            kthread_parkme();  // 일시 정지 지원
            continue;
        }

        do_work();

        // 인터럽트 가능한 sleep (kthread_stop 시 깨어남)
        set_current_state(TASK_INTERRUPTIBLE);
        if (!kthread_should_stop())
            schedule_timeout(msecs_to_jiffies(1000));
        set_current_state(TASK_RUNNING);
    }
    return 0;
}

static int __init my_init(void)
{
    my_thread = kthread_run(thread_fn, NULL, "my_worker");
    if (IS_ERR(my_thread))
        return PTR_ERR(my_thread);
    return 0;
}

static void __exit my_exit(void)
{
    if (my_thread)
        kthread_stop(my_thread);  // 스레드 중지 요청 + 완료 대기
}

struct my_entry *entry, *tmp;

// 삭제 안전한 순회: _safe 버전 사용
list_for_each_entry_safe(entry, tmp, &my_list, list) {
    if (entry->expired) {
        list_del(&entry->list);
        kfree(entry);  // tmp이 다음 노드를 이미 저장
    }
}

// RCU 리스트: _rcu 버전 사용
rcu_read_lock();
list_for_each_entry_rcu(entry, &my_rcu_list, list) {
    process(entry);
}
rcu_read_unlock();

// 추가/삭제는 적절한 락 아래에서
spin_lock(&list_lock);
list_add_rcu(&entry->list, &my_rcu_list);
spin_unlock(&list_lock);

// 항상 초기화
INIT_LIST_HEAD(&s.list);
// 또는 선언 시: LIST_HEAD(my_list);

// rate-limited 출력 (5초에 1번만)
static irqreturn_t irq_handler(int irq, void *data)
{
    printk_ratelimited(KERN_DEBUG "IRQ %d received\\n", irq);
    return IRQ_HANDLED;
}

// 한 번만 출력
pr_info_once("driver loaded\\n");

// 디바이스가 있으면 dev_* 사용 (디바이스 이름 자동 출력)
dev_err(&pdev->dev, "failed to init: %d\\n", ret);
dev_warn(&pdev->dev, "low battery\\n");
dev_dbg(&pdev->dev, "register 0x%x = 0x%x\\n", reg, val);

// 포인터 출력: %p (해시), %ps (심볼), %pS (심볼+오프셋)
pr_info("callback: %ps\\n", callback_fn);

// 동적 디버그 (런타임에 활성화/비활성화)
// echo 'module mydriver +p' > /sys/kernel/debug/dynamic_debug/control
pr_debug("detail: %d\\n", val);  // 기본 비활성화

// 고정 소수점: 1000배로 스케일링
int calculate_ratio_milli(int a, int b)
{
    if (b == 0)
        return 0;
    return (a * 1000) / b;  // 결과: 밀리 단위
}

// 또는 커널 제공 매크로
#include <linux/math64.h>
u64 result = div64_u64(a * 1000ULL, b);

// 퍼센트 계산
unsigned int pct = (count * 100) / total;

// 반드시 FPU가 필요하면 (암호화 등 극히 제한적):
kernel_fpu_begin();
// ... FPU 사용 ...
kernel_fpu_end();
// 주의: 이 구간에서 preempt 비활성화됨

static int my_seq_show(struct seq_file *m, void *v)
{
    int i = *(int *)v;
    seq_printf(m, "%d: %s\\n", i, entries[i].name);  // 자동 버퍼 관리
    return 0;
}

static void *my_seq_start(struct seq_file *m, loff_t *pos)
{
    if (*pos >= num_entries)
        return NULL;
    return pos;
}

static void *my_seq_next(struct seq_file *m, void *v, loff_t *pos)
{
    (*pos)++;
    if (*pos >= num_entries)
        return NULL;
    return pos;
}

static void my_seq_stop(struct seq_file *m, void *v)
{
}

static const struct seq_operations my_seq_ops = {
    .start = my_seq_start,
    .next  = my_seq_next,
    .stop  = my_seq_stop,
    .show  = my_seq_show,
};

static int my_open(struct inode *inode, struct file *file)
{
    return seq_open(file, &my_seq_ops);
}

static ssize_t value_store(struct device *dev,
                          struct device_attribute *attr,
                          const char *buf, size_t count)
{
    struct my_device *mydev = dev_get_drvdata(dev);
    int val;

    if (kstrtoint(buf, 10, &val))
        return -EINVAL;

    mutex_lock(&mydev->lock);
    mydev->value = val;
    mutex_unlock(&mydev->lock);

    return count;
}

static ssize_t value_show(struct device *dev,
                         struct device_attribute *attr,
                         char *buf)
{
    struct my_device *mydev = dev_get_drvdata(dev);
    int val;

    mutex_lock(&mydev->lock);
    val = mydev->value;
    mutex_unlock(&mydev->lock);

    return sprintf(buf, "%d\\n", val);
}

static struct dentry *dbg_dir;

static int my_probe(struct device *dev)
{
    // debugfs 실패는 무시 — 기능 동작에 영향 없음
    dbg_dir = debugfs_create_dir("mydriver", NULL);
    debugfs_create_u32("register_dump", 0444, dbg_dir, &mydev->reg_val);
    debugfs_create_file("stats", 0444, dbg_dir, mydev, &stats_fops);
    // 반환값 체크 불필요 (커널 정책)

    // 프로덕션 정보는 sysfs나 procfs로 노출
    return 0;
}

static void my_remove(struct device *dev)
{
    debugfs_remove_recursive(dbg_dir);  // 디렉토리 전체 제거
}

static ssize_t status_show(struct device *dev,
                          struct device_attribute *attr, char *buf)
{
    return sysfs_emit(buf, "%d\\n", mydev->status);
    // PAGE_SIZE 경계 자동 체크, 안전
}

// 여러 값 출력 시
static ssize_t multi_show(struct device *dev,
                        struct device_attribute *attr, char *buf)
{
    int len = 0;
    for (int i = 0; i < count && len < PAGE_SIZE; i++)
        len += sysfs_emit_at(buf, len, "%d\\n", values[i]);
    return len;
}

int index;
if (copy_from_user(&index, user_ptr, sizeof(index)))
    return -EFAULT;

if (index < 0 || index >= ARRAY_SIZE(device_array))
    return -EINVAL;

return device_array[index];

void *buf = kmalloc_array(count, item_size, GFP_KERNEL);
// 또는 kcalloc (0으로 초기화)
void *buf = kcalloc(count, item_size, GFP_KERNEL);

struct user_request req;
copy_from_user(&req, user_ptr, sizeof(req));

// 로컬 변수에 저장 (사용자가 변경 불가)
int index = req.index;

if (index >= MAX_ENTRIES)
    return -EINVAL;

// ... 다른 작업 ...

return entries[index];  // OK: index는 검증된 값

struct stats s = {};  // 0으로 초기화 (패딩 포함)
s.count = 100;
s.timestamp = ktime_get_seconds();
copy_to_user(user_ptr, &s, sizeof(s));  // OK

// 또는 memset 사용
struct stats s;
memset(&s, 0, sizeof(s));
s.count = 100;
s.timestamp = ktime_get_seconds();
copy_to_user(user_ptr, &s, sizeof(s));

// %p 사용: 해시된 값 출력 (주소 노출 안 됨)
seq_printf(m, "handler: %ps\\n", dev->handler);  // 심볼 이름만

// dmesg: 해시 포인터 또는 심볼
printk(KERN_INFO "buffer at %p\\n", buf);  // 해시된 값

// ioctl: ID나 핸들로 대체
response.device_id = dev->unique_id;  // 포인터 대신 ID
copy_to_user(user_resp, &response, sizeof(response));

// /proc/sys/kernel/kptr_restrict 설정:
// 0 = 모두 볼 수 있음 (비권장)
// 1 = CAP_SYSLOG 필요
// 2 = 항상 0으로 표시 (가장 안전)

// _IO, _IOR, _IOW, _IOWR 매크로 사용
#define MY_MAGIC 'M'  // Documentation/userspace-api/ioctl/ioctl-number.rst 참조
#define MY_IOCTL_GET  _IOR(MY_MAGIC, 0, struct my_ioctl_data)
#define MY_IOCTL_SET  _IOW(MY_MAGIC, 1, struct my_ioctl_data)

// 고정 크기 타입으로 32/64비트 호환
struct my_ioctl_data {
    __u64 buffer;     // 포인터 대신 __u64
    __u32 size;       // 고정 크기
    __u32 reserved;   // 미래 확장용 (0으로 초기화 검증)
};

// ioctl 핸들러
static long my_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
{
    struct my_ioctl_data data;
    if (copy_from_user(&data, (void __user *)arg, sizeof(data)))
        return -EFAULT;
    if (data.reserved != 0)  // 미래 호환성 검증
        return -EINVAL;
    // ...
}

static int my_function(void)
{
    char *buf;
    buf = kmalloc(4096, GFP_KERNEL);  // 힙에 할당
    if (!buf)
        return -ENOMEM;

    memset(buf, 0, 4096);
    // ...
    kfree(buf);
    return 0;
}

// 재귀 대신 명시적 스택(워크리스트) 사용
static int walk_tree_iterative(struct dentry *root)
{
    struct list_head work_list;
    INIT_LIST_HEAD(&work_list);
    list_add(&root->d_lru, &work_list);

    while (!list_empty(&work_list)) {
        struct dentry *d = list_first_entry(&work_list,
                            struct dentry, d_lru);
        list_del(&d->d_lru);
        process_dentry(d);
        // 자식을 워크리스트에 추가 (재귀 아님)
    }
    return 0;
}

static long my_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
{
    switch (cmd) {
    case MY_IOCTL_RESET_HW:
        if (!capable(CAP_SYS_ADMIN))  // 관리 권한 필요
            return -EPERM;
        reset_hardware();
        break;

    case MY_IOCTL_READ_RAW:
        if (!capable(CAP_SYS_RAWIO))  // Raw I/O 권한
            return -EPERM;
        break;

    case MY_IOCTL_NET_CONFIG:
        if (!capable(CAP_NET_ADMIN))  // 네트워크 관리
            return -EPERM;
        break;
    }
    return 0;
}

// 네임스페이스 인식 검사 (컨테이너 환경)
if (!ns_capable(current_user_ns(), CAP_SYS_ADMIN))
    return -EPERM;

spin_lock(&dev->lock);
int local_counter = dev->counter++;
spin_unlock(&dev->lock);

// 락 없이 계산
int result = expensive_calculation(local_counter);

spin_lock(&dev->lock);
dev->result = result;
spin_unlock(&dev->lock);

struct stats {
    long cpu0_count;
    char pad0[L1_CACHE_BYTES - sizeof(long)];  // 패딩
    long cpu1_count;
    char pad1[L1_CACHE_BYTES - sizeof(long)];
    // ...
} __aligned(L1_CACHE_BYTES);

// 또는 per-CPU 변수 사용 (권장)
DEFINE_PER_CPU(long, cpu_count);

// 사용
this_cpu_inc(cpu_count);  // 현재 CPU의 변수만 수정

struct device {
    /* 읽기 전용 필드 (캐시 라인 1) */
    const char *name;
    int id;
    const struct device_ops *ops;

    /* 쓰기 빈번 필드 (캐시 라인 2) */
    atomic_t refcount ____cacheline_aligned;
    struct list_head list;
};

mutex_lock(&dev->io_mutex);  // 긴 작업엔 mutex
struct bio *bio = bio_alloc(...);
submit_bio(bio);
mutex_unlock(&dev->io_mutex);

// 현재 CPU의 NUMA 노드에 할당
void *buf = kmalloc_node(4096, GFP_KERNEL, numa_node_id());

// 디바이스의 NUMA 노드에 할당
int node = dev_to_node(dev);
void *buf = kmalloc_node(4096, GFP_KERNEL, node);

// per-CPU 변수도 NUMA 인식
void *p = alloc_percpu(struct my_stats);
// 각 CPU의 로컬 노드에 자동 할당

// kthread를 특정 노드에 바인딩
struct task_struct *t = kthread_create_on_node(
    thread_fn, data, node, "worker/%d", node);
kthread_bind_mask(t, cpumask_of_node(node));

// 방법 1: 전용 slab 캐시 (동일 크기 반복 할당에 최적)
static struct kmem_cache *ctx_cache;

static int __init my_init(void)
{
    ctx_cache = kmem_cache_create("my_ctx",
        sizeof(struct work_context), 0,
        SLAB_HWCACHE_ALIGN, NULL);
    return ctx_cache ? 0 : -ENOMEM;
}

static int handle_request(struct request *req)
{
    struct work_context *ctx = kmem_cache_zalloc(ctx_cache, GFP_KERNEL);
    process(ctx, req);
    kmem_cache_free(ctx_cache, ctx);
    return 0;
}

// 방법 2: mempool (할당 실패가 허용되지 않는 경우)
static mempool_t *ctx_pool;
ctx_pool = mempool_create_slab_pool(64, ctx_cache);  // 최소 64개 예약

struct work_context *ctx = mempool_alloc(ctx_pool, GFP_NOIO);
// mempool은 예약 메모리에서 할당하므로 실패하지 않음
mempool_free(ctx, ctx_pool);

static int my_probe(struct platform_device *pdev)
{
    request_mem_region(...);
    ioremap(...);
    alloc_chrdev_region(...);
    request_irq(...);           // IRQ 먼저 등록
    cdev_add(...);               // 모든 준비 완료 후 장치 공개
    return 0;

err_irq:
    free_irq(...);
err_chrdev:
    unregister_chrdev_region(...);
err_ioremap:
    iounmap(...);
err_mem:
    release_mem_region(...);
    return ret;
}

static int my_remove(struct platform_device *pdev)
{
    cdev_del(...);                // 5 (역순) - 사용자 접근 차단
    free_irq(...);                // 4
    unregister_chrdev_region(...);  // 3
    iounmap(...);                 // 2
    release_mem_region(...);      // 1
    return 0;
}

static int my_probe(struct device *dev)
{
    void *buf = devm_kzalloc(dev, 1024, GFP_KERNEL);
    devm_request_irq(dev, ..., buf, ...);  // devm 버전 사용
    return 0;
}

static void my_remove(struct device *dev)
{
    // 아무것도 안 함 - 자동 정리됨
}

static irqreturn_t my_irq_handler(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;

    // Top-half: 최소한의 작업만
    u32 status = readl(dev->regs + STATUS_REG);
    if (!(status & IRQ_PENDING))
        return IRQ_NONE;  // 우리 인터럽트 아님

    // IRQ 비트 클리어
    writel(status, dev->regs + STATUS_REG);

    // Bottom-half로 지연
    schedule_work(&dev->work);

    return IRQ_HANDLED;
}

static void my_work_handler(struct work_struct *work)
{
    struct my_device *dev = container_of(work, struct my_device, work);

    // Bottom-half: 긴 처리 수행
    for (int i = 0; i < 1000; i++) {
        process_data(&dev->buffer[i]);
    }
}

static irqreturn_t my_irq_handler(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    u32 status = readl(dev->regs + STATUS_REG);

    if (!(status & MY_IRQ_BITS))
        return IRQ_NONE;  // 우리 인터럽트 아님

    process_interrupt(dev);
    return IRQ_HANDLED;
}

// 리틀 엔디안 하드웨어 → CPU 바이트 순서
u32 val = le32_to_cpu(*(__le32 *)hw_reg);
// 또는 MMIO: readl()이 자동 변환
u32 val = readl(hw_reg);

// 네트워크 (빅 엔디안) → CPU 바이트 순서
u16 port = ntohs(hdr->dest_port);   // 또는 be16_to_cpu()
u32 addr = ntohl(hdr->src_addr);     // 또는 be32_to_cpu()

// CPU → 네트워크 바이트 순서
hdr->dest_port = htons(port);

// 디스크 (리틀 엔디안) → CPU
u32 inode_num = le32_to_cpu(disk_inode->i_num);

// sparse 타입 어노테이션 (컴파일 시 체크)
__le32 hw_value;   // 리틀 엔디안으로 선언
__be16 net_port;   // 빅 엔디안으로 선언
// make C=1로 sparse 검사 시 엔디안 불일치 경고

void __iomem *base = ioremap(phys_addr, size);
if (!base)
    return -ENOMEM;

// 올바른 MMIO 접근
u32 status = readl(base + STATUS_REG);  // 순서 보장, 엔디안 변환 포함
writel(value, base + CTRL_REG);           // 쓰기 완료 보장

// relaxed 버전: 배리어 없음 (성능 필요 시)
u32 data = readl_relaxed(base + DATA_REG);

// 블록 복사
memcpy_fromio(buf, base + FIFO_REG, 1024);
memcpy_toio(base + FIFO_REG, buf, 1024);

// 해제
iounmap(base);

static int my_suspend(struct device *dev)
{
    struct my_device *mydev = dev_get_drvdata(dev);

    // 1. 새 작업 수신 차단
    netif_stop_queue(mydev->ndev);  // 네트워크 드라이버 예시

    // 2. 진행 중인 작업 완료 대기
    cancel_work_sync(&mydev->work);

    // 3. DMA 중지
    dma_stop(mydev);

    // 4. IRQ 비활성화
    disable_irq(mydev->irq);

    // 5. 하드웨어 상태 저장
    mydev->saved_ctrl = readl(mydev->regs + CTRL_REG);
    mydev->saved_config = readl(mydev->regs + CONFIG_REG);

    // 6. 클럭/전원 끄기
    clk_disable_unprepare(mydev->clk);

    return 0;
}

static int my_resume(struct device *dev)
{
    struct my_device *mydev = dev_get_drvdata(dev);

    // 역순으로 복원
    clk_prepare_enable(mydev->clk);
    writel(mydev->saved_ctrl, mydev->regs + CTRL_REG);
    writel(mydev->saved_config, mydev->regs + CONFIG_REG);
    enable_irq(mydev->irq);
    netif_wake_queue(mydev->ndev);

    return 0;
}

static DEFINE_SIMPLE_DEV_PM_OPS(my_pm_ops, my_suspend, my_resume);

// Streaming DMA: 일시적 매핑
dma_handle = dma_map_single(dev, buf, size, DMA_FROM_DEVICE);
if (dma_mapping_error(dev, dma_handle)) {
    dev_err(dev, "DMA mapping failed\\n");
    return -ENOMEM;
}

// DMA 완료 후 반드시 언매핑
dma_unmap_single(dev, dma_handle, size, DMA_FROM_DEVICE);

// Coherent DMA: 영구 매핑 (일관성 보장)
void *coherent_buf = dma_alloc_coherent(dev, size, &dma_handle, GFP_KERNEL);
if (!coherent_buf)
    return -ENOMEM;
// 사용 후
dma_free_coherent(dev, size, coherent_buf, dma_handle);

// DMA 방향 가이드:
// DMA_TO_DEVICE   — CPU → Device (전송)
// DMA_FROM_DEVICE — Device → CPU (수신)
// DMA_BIDIRECTIONAL — 양방향 (성능 약간 저하)

static void fw_loaded(const struct firmware *fw, void *context)
{
    struct my_device *mydev = context;

    if (!fw) {
        dev_err(mydev->dev, "firmware not found\\n");
        return;
    }

    // 펌웨어 헤더 검증
    if (fw->size < sizeof(struct fw_header)) {
        dev_err(mydev->dev, "firmware too small\\n");
        goto out;
    }

    struct fw_header *hdr = (struct fw_header *)fw->data;
    if (le32_to_cpu(hdr->magic) != FW_MAGIC) {
        dev_err(mydev->dev, "invalid firmware magic\\n");
        goto out;
    }

    memcpy_toio(mydev->fw_mem, fw->data, fw->size);
out:
    release_firmware(fw);
}

static int my_probe(struct device *dev)
{
    // 비동기 로딩 (파일시스템 준비 안 돼도 대기)
    ret = request_firmware_nowait(THIS_MODULE, true,
        "mydevice.bin", dev, GFP_KERNEL, mydev, fw_loaded);

    // 또는 동기 로딩 (probe 시점에 반드시 필요하면)
    ret = request_firmware(&fw, "mydevice.bin", dev);
    // 파일명만 지정 (커널이 /lib/firmware/ 검색)
}

static int my_probe(struct platform_device *pdev)
{
    struct clk *clk;
    struct regulator *reg;

    clk = devm_clk_get(&pdev->dev, NULL);
    if (IS_ERR(clk))
        return PTR_ERR(clk);

    reg = devm_regulator_get(&pdev->dev, "vdd");
    if (IS_ERR(reg))
        return PTR_ERR(reg);

    // 1. 레귤레이터 활성화
    ret = regulator_enable(reg);
    if (ret)
        return ret;

    // 2. 안정화 대기 (데이터시트 참조)
    usleep_range(1000, 2000);  // 1-2ms

    // 3. 클럭 활성화 (prepare + enable)
    ret = clk_prepare_enable(clk);
    if (ret)
        goto err_reg;

    ret = some_init();
    if (ret)
        goto err_clk;

    return 0;

err_clk:
    clk_disable_unprepare(clk);
err_reg:
    regulator_disable(reg);
    return ret;
}

static int my_probe(struct platform_device *pdev)
{
    struct device *dev = &pdev->dev;
    u32 freq;

    // 필수 프로퍼티: 에러 시 probe 실패
    ret = device_property_read_u32(dev, "clock-frequency", &freq);
    if (ret) {
        dev_err(dev, "missing clock-frequency property\\n");
        return ret;
    }

    // 선택적 프로퍼티: 기본값 사용
    u32 optional_val = 100;  // 기본값
    device_property_read_u32(dev, "optional-val", &optional_val);

    // MMIO 리소스 (platform_get_resource 대신 devm 사용)
    mydev->regs = devm_platform_ioremap_resource(pdev, 0);
    if (IS_ERR(mydev->regs))
        return PTR_ERR(mydev->regs);

    return 0;
}

// compatible: "vendor,device" 형식 필수
static const struct of_device_id my_dt_ids[] = {
    { .compatible = "myvendor,mydevice-v2" },
    { .compatible = "myvendor,mydevice" },  // 이전 버전 호환
    { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, my_dt_ids);

// device_property API 사용 (DT + ACPI 양쪽 지원)
// of_property_read_* → device_property_read_*로 마이그레이션 권장

static void delayed_callback(struct work_struct *work)
{
    do_something();
    module_put(THIS_MODULE);  // 작업 완료 후 참조 해제
}

static int my_ioctl(struct file *file, ...)
{
    if (!try_module_get(THIS_MODULE))  // 언로드 중이면 실패
        return -ENODEV;
    schedule_work(&my_work);
    return 0;
}

static void my_module_exit(void)
{
    cancel_work_sync(&my_work);  // work 완료 대기
    // ...
}

// 내부 함수 - export 안 함
static void internal_helper(void)
{
    // ...
}

// 공개 API - 다른 모듈이 사용 가능
void my_public_api(void)
{
    // ...
}
EXPORT_SYMBOL_GPL(my_public_api);  // GPL 모듈만 사용 가능

// 또는 독점 드라이버도 사용 가능하게
EXPORT_SYMBOL(my_public_api);

static int ring_size = 256;
module_param(ring_size, int, 0644);
MODULE_PARM_DESC(ring_size, "Ring buffer size (16-4096, default 256)");

static int my_init(void)
{
    // 범위 검증 + 2의 거듭제곱 강제
    if (ring_size < 16 || ring_size > 4096) {
        pr_err("ring_size %d out of range [16, 4096]\\n", ring_size);
        return -EINVAL;
    }
    ring_size = roundup_pow_of_two(ring_size);  // 2의 거듭제곱으로 정렬
    buf = kmalloc_array(ring_size, sizeof(*buf), GFP_KERNEL);
}

// 또는 set 콜백으로 런타임 검증
static int set_ring_size(const char *val, const struct kernel_param *kp)
{
    int n;
    if (kstrtoint(val, 10, &n) || n < 16 || n > 4096)
        return -EINVAL;
    return param_set_int(val, kp);
}
static const struct kernel_param_ops ring_size_ops = {
    .set = set_ring_size,
    .get = param_get_int,
};
module_param_cb(ring_size, &ring_size_ops, &ring_size, 0644);

// 빌트인 모듈: 적절한 initcall 레벨 사용
// early_initcall → pure_initcall → core_initcall → postcore_initcall
//   → arch_initcall → subsys_initcall → fs_initcall → device_initcall
//     → late_initcall

static int __init my_late_init(void)
{
    // PCI, USB 등 서브시스템이 이미 초기화된 후 실행
    return 0;
}
late_initcall(my_late_init);  // device_initcall 이후

// 드라이버 probe에서 의존성 처리: -EPROBE_DEFER
static int my_probe(struct platform_device *pdev)
{
    struct clk *clk = devm_clk_get(&pdev->dev, NULL);
    if (IS_ERR(clk)) {
        if (PTR_ERR(clk) == -EPROBE_DEFER)
            return -EPROBE_DEFER;  // 나중에 다시 시도
        return PTR_ERR(clk);
    }
    // ...
}

static void __exit my_exit(void)
{
    delete_all_entries();
    rcu_barrier();  // 모든 RCU 콜백 완료 대기
    // 이제 안전하게 모듈 언로드 가능
}

MODULE_LICENSE("GPL");            // GPL v2
MODULE_LICENSE("GPL v2");         // GPL v2 only
MODULE_LICENSE("Dual BSD/GPL");   // 듀얼 라이선스
MODULE_LICENSE("Dual MIT/GPL");   // 듀얼 라이선스

MODULE_AUTHOR("Your Name <email@example.com>");
MODULE_DESCRIPTION("My kernel module description");
MODULE_VERSION("1.0");

// 인자를 괄호로 감싸기
#define DOUBLE(x) ((x) * 2)

// 인자 다중 평가 방지: GCC 확장 사용
#define MAX(a, b) ({          \
    typeof(a) _a = (a);    \
    typeof(b) _b = (b);    \
    _a > _b ? _a : _b;      \
})
// 또는 커널 제공: max(), min(), clamp()

// 여러 문장: do { } while (0)
#define INIT_DEV(d) do {  \
    (d)->status = 0;       \
    (d)->count = 0;        \
} while (0)

// 가능하면 static inline 함수 사용 (타입 체크, 디버깅 가능)
static inline int safe_max(int a, int b)
{
    return a > b ? a : b;
}