【深入内核】中断真的不能睡眠吗？

当前函数 → 保存返回地址 → 执行 → 返回

#define in_irq()                (hardirq_count())
#define hardirq_count()        (preempt_count() & HARDIRQ_MASK)

void irq_enter(void){
        rcu_irq_enter();
        irq_enter_rcu();  ////这儿
}

void irq_enter_rcu(void){
        __irq_enter_raw();   ///这个就是标记进入中断上下文

        if (is_idle_task(current) && (irq_count() == HARDIRQ_OFFSET))
                tick_irq_enter();

        account_hardirq_enter(current);
}

#define __irq_enter_raw()                                \
        do {                                                \
                preempt_count_add(HARDIRQ_OFFSET);        \
                lockdep_hardirq_enter();                \
        } while (0)

void dangerous_irq_handler(void)
{
    // 1. 中断发生，保存了当前进程A的现场到它的内核栈
    // 2. 现在我们处于中断上下文，但没有任何保护标志
    
    // 3. 我们做了一些处理...
    handle_hardware();
    
    // 4. 然后我们直接调用调度器！
    schedule();  // 假设schedule()没有任何检查
}

内存布局（简化）：
+-------------------+   <-- 高地址
|   进程A用户栈     |
+-------------------+
|   进程A内核栈     |
|   ...             |
|   A的保存现场     |  <-- 中断发生时保存的A的寄存器
|   中断处理栈帧    |  <-- dangerous_irq_handler的栈帧  ← 我们在这里！
+-------------------+   <-- 当前栈指针SP
|   进程B内核栈     |
|   ...             |
+-------------------+

// 原本的中断返回应该是：
eret   // 返回到进程A被中断的位置

// 但现在中断处理被schedule()打断，可能：
// 1. 永远无法执行到eret
// 2. 或者eret时寄存器状态完全错误

进程A恢复执行时：
+------------------------+
| 想象中的流程           |      | 实际发生的流程
+------------------------+      +------------------------
| 恢复寄存器             | ---> | 恢复的是中断处理中的寄存器
| 跳转到被中断的代码     | ---> | 跳转到中断处理函数中部
| 继续正常执行           | ---> | 栈混乱，立即崩溃
+------------------------+      +------------------------

# 假设中断处理时保存的PC指向这里：
ldr x0, [x1]   # 从x1指向的地址加载

# 但恢复时：
# x1 = 中断处理时的某个值（可能是设备寄存器地址）
# 尝试访问这个地址 → 可能是非法地址 → 页错误

中断处理栈：
+----------------+
| 局部变量1      | ← 中断处理函数的栈帧
| 返回地址       |
| 保存的x29      |
| 保存的x30      |
+----------------+

恢复时当作进程A栈：
+----------------+
| 进程A的局部变量| ← 但这里实际上是中断栈！
| 进程A返回地址  |
| ...            |
+----------------+

结果：读写完全错误的内存区域

# 中断处理在EL1（内核模式）
# 但恢复时可能错误地设置了PSTATE
# 可能以内核特权执行用户代码，或以用户特权执行内核代码

T0: 进程A在用户模式执行
T1: 中断发生，保存A的现场到A的内核栈
T2: 执行dangerous_irq_handler
T3: 在handler中调用schedule() ← 灾难开始！
T4: 调度器保存"当前上下文"（实际是handler状态）到A的任务结构
T5: 恢复进程B的上下文，运行B
    ↓
    （一段时间后...）
    ↓
T6: 再次调度到进程A
T7: 恢复错误的上下文到寄存器
T8: 立即崩溃：页错误、非法指令、栈错误等
T9: 可能触发另一个异常，但异常处理也可能混乱
T10: 系统完全死锁或重启

进程A → IRQ1（开始） → schedule() → 进程B
进程B → IRQ2（嵌套） → schedule() → 进程C
...

static void __sched notrace __schedule(unsigned int sched_mode){
    //..
        ///判断是否是atomic上下文(硬件中断上下文，软件中断上下文)，若是则报dbug
        schedule_debug(prev, !!sched_mode);
    
    //...

}

static inline void schedule_debug(struct task_struct *prev, bool preempt)
{
// 栈溢出检查
#ifdef CONFIG_SCHED_STACK_END_CHECK
        if (task_stack_end_corrupted(prev))
                panic("corrupted stack end detected inside scheduler\n");

        if (task_scs_end_corrupted(prev))
                panic("corrupted shadow stack detected inside scheduler\n");
#endif

// 原子上下文休眠检查
#ifdef CONFIG_DEBUG_ATOMIC_SLEEP
        if (!preempt && READ_ONCE(prev->__state) && prev->non_block_count) {
                printk(KERN_ERR "BUG: scheduling in a non-blocking section: %s/%d/%i\n",
                        prev->comm, prev->pid, prev->non_block_count);
                dump_stack();
                add_taint(TAINT_WARN, LOCKDEP_STILL_OK);
        }
#endif

        if (unlikely(in_atomic_preempt_off())) {
                __schedule_bug(prev);
                preempt_count_set(PREEMPT_DISABLED);
        }
        rcu_sleep_check();
        SCHED_WARN_ON(ct_state() == CONTEXT_USER);

        profile_hit(SCHED_PROFILING, __builtin_return_address(0));

        schedstat_inc(this_rq()->sched_count);
}

     #define in_atomic_preempt_off() (preempt_count() != PREEMPT_DISABLE_OFFSET)
      // 检查是否处于中断处理中/软中断处理中
        if (unlikely(in_atomic_preempt_off())) {
                __schedule_bug(prev); /// 如果处于中断处理调用
                preempt_count_set(PREEMPT_DISABLED); //强制设置PREEMPT_DISABLED防止进一步调度
        }

static noinline void __schedule_bug(struct task_struct *prev)
{
        /* Save this before calling printk(), since that will clobber it */
        unsigned long preempt_disable_ip = get_preempt_disable_ip(current);

        if (oops_in_progress)
                return;
        // 打印熟悉的日志
        printk(KERN_ERR "BUG: scheduling while atomic: %s/%d/0x%08x\n",
                prev->comm, prev->pid, preempt_count());

        debug_show_held_locks(prev);
        print_modules();
        if (irqs_disabled())
                print_irqtrace_events(prev);
        if (IS_ENABLED(CONFIG_DEBUG_PREEMPT)
            && in_atomic_preempt_off()) {
                pr_err("Preemption disabled at:");
                print_ip_sym(KERN_ERR, preempt_disable_ip);
        }
        // 触发panic
        if (panic_on_warn)
                panic("scheduling while atomic\n");
        // 打印栈
        dump_stack();
        add_taint(TAINT_WARN, LOCKDEP_STILL_OK);
}

BUG: scheduling while atomic:

BUG: scheduling while atomic: ...
__schedule（kernel/sched/core.c）
schedule
某个阻塞 API（比如 mutex 竞争、wait_event、msleep、内存回收路径等）
你的驱动中断处理函数（xxx_irq_handler）
handle_irq_event / __handle_irq_event_percpu（kernel/irq/handle.c 一类）
generic_handle_irq / handle_domain_irq
gic_handle_irq（drivers/irqchip/irq-gic-*.c）
el1_irq 入口链路（arch/arm64/kernel/entry.S）

// 可以：使用GFP_ATOMIC标志，从不睡眠
void *ptr = kmalloc(size, GFP_ATOMIC);

// 可以：使用kmem_cache_alloc的原子版本
void *ptr = kmem_cache_alloc(cachep, GFP_ATOMIC);

// 不可以：使用可能睡眠的标志
void *ptr = kmalloc(size, GFP_KERNEL);  // 可能睡眠！

// 可以：自旋锁（spinlock）
DEFINE_SPINLOCK(my_lock);
unsigned long flags;

spin_lock_irqsave(&my_lock, flags);
// 临界区
spin_unlock_irqrestore(&my_lock, flags);

// 可以：读-写自旋锁
DEFINE_RWLOCK(my_rwlock);
read_lock(&my_rwlock);
// 读取临界区
read_unlock(&my_rwlock);

// 不可以：互斥锁（mutex）
// mutex_lock(&my_mutex);  // 可能睡眠！

// 不可以：信号量（semaphore）
// down(&my_sem);  // 可能睡眠！

// 可以：忙等待（不睡眠）
udelay(10);     // 微秒级延时（忙等待）
ndelay(1000);   // 纳秒级延时（忙等待）

// 不可以：睡眠延时
// msleep(10);    // 毫秒级睡眠
// ssleep(1);     // 秒级睡眠

// 最简单通用的方式
struct work_struct my_work;
INIT_WORK(&my_work, my_work_function);
schedule_work(&my_work);  // 调度到系统工作队列

// 高性能但固定类型
// 内核预定义了几种软中断类型
// 如：网络接收、块设备、定时器等

// 基于软中断，但更易用
struct tasklet_struct my_tasklet;

void my_tasklet_function(unsigned long data) {
    // 处理函数
}

tasklet_init(&my_tasklet, my_tasklet_function, 0);
tasklet_schedule(&my_tasklet);  // 调度任务

// 中断处理直接在内核线程中运行
int request_threaded_irq(unsigned int irq, 
                        irq_handler_t handler,
                        irq_handler_t thread_fn,
                        unsigned long flags,
                        const char *name, 
                        void *dev);