中断初探

中断初探

最近几个月调了很多中断的bug，啃了很久的源码。整理了一些东西，大佬们笑纳。
离开了架构谈中断都是不深刻的，大佬们肯定玩腻了X86了，今天就以龙芯内核（龙芯官网即可获得：git://cgit.loongnix.org/kernel/linux-3.10.git）为例简单介绍一下哈。中断在内核中的生命周期主要分为三个部分：初始化，注册和中断处理，剩余的所有事情都是硬件完成的。这部分打算分享四节内容：中断初始化、注册中断处理以及中断排错。这次先分享前两部分内容。
在一切的前面，先看看中断相关的数据结构。

数据结构

话不多说，上图

在linux kernel中，对于每一个外设的IRQ都用struct irq_desc来描述，我们称之中断描述符（struct irq_desc）。linux kernel中会有一个数据结构保存了关于所有IRQ的中断描述符信息，我们称之中断描述符DB（上图中的数据结构）。当发生中断后，首先获取触发中断的HW interupt ID，然后通过irq domain翻译成IRQ nuber，然后通过IRQ number就可以获取对应的中断描述符。调用中断描述符中的highlevel irq-events handler来进行中断处理就OK了。而highlevel irq-events handler主要进行下面两个操作：

（1）调用中断描述符的底层irq chip driver进行mask，ack等callback函数，进行interrupt flow control。

（2）调用该中断描述符上的action list中的specific handler（我们用这个术语来区分具体中断handler和high level的handler）。

接下来看中断初始化，很多架构中断初始化代码都在arch目录下，龙芯采用mips架构，因此关注点在arch/mips/目录中，一般架构都是定义好某个中断号被哪个设备占用，初始化工作是：申请中断处理需要的desc结构，每个扫描设备给每个desc填充好handle_irq 和chip结构，给中断号绑定处理函数。中断注册都是在init阶段通过两个接口完成的，为什么是两个接口呢,因为龙芯一部分中断是CPU控制，另一部分由桥片控制。由一个宏定义分开，宏定义定义在arch下，名字一般是XXX_IRQ_BASE，XXX是架构名，例如：LS7A_PCH_IRQ_BASE，。中断号小于该宏是有CPU直接控制的中断，比如说时钟中断，串口中断等等。大于该宏则是桥片上的，例如：显卡、网卡、硬盘等等。这也跟龙芯自己的硬件设计有关。

中断初始化

这个很容易理解，中断初始化肯定在内核启动中，因为内核非常需要时钟等中断。那就先从start_kernel开始看吧，这个函数执行的功能十分冗杂，现在我们只关注irq相关的部分。差不多翻两页以后，看到下面这个代码块：

        if (initcall_debug)
                initcall_debug_enable();

        context_tracking_init();
        /* init some links before init_ISA_irqs() */
        early_irq_init();
        init_IRQ();
        tick_init();
        rcu_init_nohz();
        init_timers();
        hrtimers_init();
        softirq_init();
        timekeeping_init();
        time_init();
        printk_safe_init();
        perf_event_init();
        profile_init();
        call_function_init();
        WARN(!irqs_disabled(), "Interrupts were enabled early\n");

        early_boot_irqs_disabled = false;
        local_irq_enable();

这是除了start_kenrel一进来就disable_irq之后第一个出现irq字样的代码块了，各种init irq，nice，盘他！先去看看early_init_irq。定义在kernel下。那就是通用的咯，那就应该是初始化前的准备工作，没关系，先进去看看。

int __init early_irq_init(void)
{
        int i, initcnt, node = first_online_node;
        struct irq_desc *desc;

        init_irq_default_affinity();

        /* Let arch update nr_irqs and return the nr of preallocated irqs */
        initcnt = arch_probe_nr_irqs();
        printk(KERN_INFO "NR_IRQS: %d, nr_irqs: %d, preallocated irqs: %d\n",
               NR_IRQS, nr_irqs, initcnt);

        if (WARN_ON(nr_irqs > IRQ_BITMAP_BITS))
                nr_irqs = IRQ_BITMAP_BITS;

        if (WARN_ON(initcnt > IRQ_BITMAP_BITS))
                initcnt = IRQ_BITMAP_BITS;

        if (initcnt > nr_irqs)
                nr_irqs = initcnt;

        for (i = 0; i < initcnt; i++) {
                desc = alloc_desc(i, node, 0, NULL, NULL);
                set_bit(i, allocated_irqs);
                irq_insert_desc(i, desc);
        }
        return arch_early_irq_init();
}

好，设置irq affinity标志，计算中断数量，分配中断描述符，中断描述符插入DB，然后去arch_early_irq_init，再跳进去看看，恩，kernel下的一个空函数。ok，这时候中断描述符DB已经创建完成了，只是每个desc还是空的。
接下来看init_IRQ——这个看名字就很重要的函数。ctrl+T，arch下的！！开心，一下就过去了。选择arch/mips/下的定义：

void __init init_IRQ(void)
{
        int i;
        unsigned int order = get_order(IRQ_STACK_SIZE);

        for (i = 0; i < NR_IRQS; i++)
                irq_set_noprobe(i);

        if (cpu_has_veic)
                clear_c0_status(ST0_IM);

        arch_init_irq();

        for_each_possible_cpu(i) {
                void *s = (void *)__get_free_pages(GFP_KERNEL, order);

                irq_stack[i] = s;
                pr_debug("CPU%d IRQ stack at 0x%p - 0x%p\n", i,
                        irq_stack[i], irq_stack[i] + IRQ_STACK_SIZE);
        }
}

挨个设置noprobe，判断cpu有没有扩展中断控制模式（external interrupt controller mode， eic），调arch_init_irq，多CPU挨个申请页面作为中断栈。毫无疑问，注册流在arch_init_irq里，就这样一个一个的跳转，最后到这里：

void __init mach_init_irq(void)
{               
        int i;
        u64 intenset_addr;
        u64 introuter_lpc_addr;
 
        clear_c0_status(ST0_IM | ST0_BEV);

        mips_cpu_irq_init();
        if (loongson_pch)
                loongson_pch->init_irq();

        /* setup CASCADE irq */
        setup_irq(LOONGSON_BRIDGE_IRQ, &cascade_irqaction);

        irq_set_chip_and_handler(LOONGSON_UART_IRQ,
                        &loongson_irq_chip, handle_level_irq);

        set_c0_status(STATUSF_IP2 | STATUSF_IP6);
}

这里可以看到，init是分两个过程的，先是mips架构通用的mips_cpu_irq_init,再是调用桥片自己的init_irq。这就是我一开始说的，注册是分两步完成的。mips_cpu_irq_init函数负责初始cpu直接控制的中断，挨个设置chip和handle_irq.

static int mips_cpu_intc_map(struct irq_domain *d, unsigned int irq,
                             irq_hw_number_t hw)
{
        static struct irq_chip *chip;

        if (hw < 2 && cpu_has_mipsmt) {
                /* Software interrupts are used for MT/CMT IPI */
                chip = &mips_mt_cpu_irq_controller;
        } else {
                chip = &mips_cpu_irq_controller;
        }

        if (cpu_has_vint)
                set_vi_handler(hw, plat_irq_dispatch);
        
        irq_set_chip_and_handler(irq, chip, handle_percpu_irq);

        return 0;
}

初始化流程还是比较简单，可以看到，在这里给每一个cpu产生的中断设置了chip和handle_irq。CPU检测到中断触发直接调用handle_percpu_irq最后到真正的中断处理函数。接下来看走msi中断的注册，这部分稍微复杂一点：

void __init ls7a_init_irq(void)
{
        writeq(0x0ULL, LS7A_INT_EDGE_REG);
        writeq(0x0ULL, LS7A_INT_STATUS_REG);
        /* Mask all interrupts except LPC (bit 19) */
        writeq(0xfffffffffff7ffffULL, LS7A_INT_MASK_REG);
        writeq(0xffffffffffffffffULL, LS7A_INT_CLEAR_REG);

        /* Enable the LPC interrupt */
        writel(0x80000000, LS7A_LPC_INT_CTL);
        /* Clear all 18-bit interrupt bits */
        writel(0x3ffff, LS7A_LPC_INT_CLR);

        if (pci_msi_enabled())
                loongson_pch->irq_dispatch = ls7a_msi_irq_dispatch;
        ....

        init_7a_irq(LS7A_IOAPIC_LPC_OFFSET          , LS7A_IOAPIC_LPC_IRQ          );
        init_7a_irq(LS7A_IOAPIC_UART0_OFFSET        , LS7A_IOAPIC_UART0_IRQ        );
        init_7a_irq(LS7A_IOAPIC_I2C0_OFFSET         , LS7A_IOAPIC_I2C0_IRQ         );
  
          .........
        }
}

设置中断掩码、中断清除等寄存器，设置中断分发函数，调用init_7a_irq为每个外设中断设置handle_irq和chip结构。代码如下：

static void init_7a_irq(int dev, int irq) {
        *irq_mask  &= ~(1ULL << dev);
        *(volatile unsigned char *)(LS7A_IOAPIC_ROUTE_ENTRY + dev) = USE_7A_INT0;
        smp_mb();
        irq_set_chip_and_handler(irq, &pch_irq_chip, handle_level_irq);
        if(ls3a_msi_enabled) {
                *irq_msi_en |= 1ULL << dev;
                *(volatile unsigned char *)(irq_msi_vec+dev) = irq;
                smp_mb();
        }
}

这里就是所有中断初始化流程了。看到这里很多人会觉得茫然了，按照上面的流程分析，第一个被初始化到的中断是MIPS_CPU_IRQ_BASE 也就是56，那前面的中断号干嘛去了？前面的中断号是故意留下来，具体原因先卖个关子 ?
接下来看中断生命周期的的第二个部分——注册。

中断注册

中断注册和初始化不一样，注册流程在设备驱动初始化操作里，注册简单点说就是给设备中断号对应的desc数据填充action字段。为了讲的更容易理解，看个中断注册的例子吧。根据上文描述，中断管理方式不一样，那中断注册肯定也不一样。选两个具有代表性的例子吧，第一个是cpu直接管理的中断——时钟中断注册，第二个是显卡中断注册。

时钟中断注册

这里想不到一个更好的引言了，直接开门见山，龙芯时钟中断初始化函数是r4k_clockevent_init。代码如下：

int r4k_clockevent_init(void)
{
        unsigned int cpu = smp_processor_id();
        struct clock_event_device *cd;
        unsigned int irq, min_delta;

        /*
         * With vectored interrupts things are getting platform specific.
         * get_c0_compare_int is a hook to allow a platform to return the
         * interrupt number of its liking.
         */
        irq = get_c0_compare_int();

        cd = &per_cpu(mips_clockevent_device, cpu);

        cd->name                = "MIPS";
        cd->features            = CLOCK_EVT_FEAT_ONESHOT |
                                  CLOCK_EVT_FEAT_C3STOP |
                                  CLOCK_EVT_FEAT_PERCPU;

        min_delta               = calculate_min_delta();

        cd->rating              = 300;
        cd->irq                 = irq;
        cd->cpumask             = cpumask_of(cpu);
        cd->set_next_event      = mips_next_event;
        cd->event_handler       = mips_event_handler;

        clockevents_config_and_register(cd, mips_hpt_frequency, min_delta, 0x7fffffff);

        if (cp0_timer_irq_installed)
                return 0;

        cp0_timer_irq_installed = 1;
        setup_irq(irq, &c0_compare_irqaction);

        return 0;
}

这是设备初始化函数，流程很清晰，获取中断号、初始化设备名称、标识符、频率、以及设备需要的一些钩子函数。这里我们且关注中断相关不跟。首先是中断号从哪里来的。其次是action结构里是什么。从代码中看到irq是调用函数得来的。如下：

unsigned int __weak get_c0_compare_int(void)
{
        return MIPS_CPU_IRQ_BASE + cp0_compare_irq;
}

cp0_compare_irq = (read_c0_intctl() >> INTCTLB_IPTI) & 7;

这就相当于时钟中断中断号从寄存器里读出来的。那接着看看action结构：

struct irqaction c0_compare_irqaction = {
        .handler = c0_compare_interrupt,
        /*
         * IRQF_SHARED: The timer interrupt may be shared with other interrupts
         * such as perf counter and FDC interrupts.
         */
        .flags = IRQF_PERCPU | IRQF_TIMER | IRQF_SHARED,
        .name = "timer",
};

只有一个handler，然后是中断标志位，名字。

显卡中断注册

和时钟中断注册相比，显卡中断稍微复杂一些。先看显卡初始化函数，目前我手头的显卡基本都是用radeon驱动的，那就看这个吧。

int radeon_device_init(struct radeon_device *rdev,
                       struct drm_device *ddev,
                       struct pci_dev *pdev,
                       uint32_t flags)
{
        ......

        r = radeon_asic_init(rdev);
        if (r)
                goto failed;
        ......
}
#define radeon_asic_init(rdev) (rdev)->asic->init((rdev))

显卡的init流程非常冗杂，这里只是拿出和本文相关的一部分代码， 这个init上挂的是evergreen_init函数，

int evergreen_init(struct radeon_device *rdev)
{
        int r;

        /* Read BIOS */
        if (!radeon_get_bios(rdev)) {
                if (ASIC_IS_AVIVO(rdev))
                        return -EINVAL;
        }
        ......
        /* Initialize clocks */
        radeon_get_clock_info(rdev->ddev);
        ......
        r = evergreen_startup(rdev);
        if (r) {
                dev_err(rdev->dev, "disabling GPU acceleration\n");
                ......
                rdev->accel_working = false;
        }

显卡读取bios参数，初始化始终，然后是setup。

static int evergreen_startup(struct radeon_device *rdev)
{
        struct radeon_ring *ring;
        int r;

        ......
        /* Enable IRQ */
        if (!rdev->irq.installed) {
                r = radeon_irq_kms_init(rdev);
                if (r)
                        return r;
        ......
}

int radeon_irq_kms_init(struct radeon_device *rdev)
{
        int r = 0;

        /* enable msi */
        rdev->msi_enabled = 0;

        if (radeon_msi_ok(rdev)) {
                int ret = pci_enable_msi(rdev->pdev);
                if (!ret) {
                        rdev->msi_enabled = 1;
                        dev_info(rdev->dev, "radeon: using MSI.\n");
                }
        }
        ......
        rdev->irq.installed = true;
        r = drm_irq_install(rdev->ddev, rdev->ddev->pdev->irq);


}

int radeon_irq_kms_init(struct drm_device *dev, int irq)
{
        /* Before installing handler */
        if (dev->driver->irq_preinstall)
                dev->driver->irq_preinstall(dev);

        /* Install handler */
        if (drm_core_check_feature(dev, DRIVER_IRQ_SHARED))
                sh_flags = IRQF_SHARED;

        ret = request_irq(irq, dev->driver->irq_handler,
                          sh_flags, dev->driver->name, dev);
}

哇，好深的一个调用啊，从evergreen_startup到radeon_irq_kms_init最后是radeon_irq_kms_init。这里注意有一个判断msi的过程。还记得前面留下的一个疑问吗？56号中断之前额中断都被空出来了，这是个msi或者一些老旧的设备预留的。中断注册时候，判断如果硬件支持MSI，则会优先选择MSI管理中断，而不是桥片自己。在pci_enable_msi函数中，pci设备释放已经申请好的中断号和中断描述符，由msi重新准备一份。

这里可以看出，显卡的中断号是从pci来的。当然了，显卡是pci设备嘛。pci设备的中断号是在启动时候扫描pci总线的时候读出来的，就是我们熟悉的dmesg总一开始输出的类似pci 0000:00:06.0: BAR 2: assigned [mem 0x48000000-0x4fffffff 64bit]这样的一大堆数据。

static int pci_device_probe(struct device *dev)
{
        int error;
        struct pci_dev *pci_dev = to_pci_dev(dev);
        struct pci_driver *drv = to_pci_driver(dev->driver);

        pci_assign_irq(pci_dev);

        error = pcibios_alloc_irq(pci_dev);
        if (error < 0)
                return error;

        pci_dev_get(pci_dev);
        if (pci_device_can_probe(pci_dev)) {
                error = __pci_device_probe(drv, pci_dev);
                if (error) {
                        pcibios_free_irq(pci_dev);
                        pci_dev_put(pci_dev);
                }
        }

        return error;
}

这是所有pci设备的探测入口，调用pci_assign_irq函数，读出每个slot的中断号。

void pci_assign_irq(struct pci_dev *dev)
{
        u8 pin;
        u8 slot = -1;
        int irq = 0;
        struct pci_host_bridge *hbrg = pci_find_host_bridge(dev->bus);

        pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);
        /* Cope with illegal. */
        if (pin > 4)
                pin = 1;

        if (pin) { 
                /* Follow the chain of bridges, swizzling as we go.  */
                if (hbrg->swizzle_irq)
                        slot = (*(hbrg->swizzle_irq))(dev, &pin);

                irq = (*(hbrg->map_irq))(dev, slot, pin);
                if (irq == -1)
                        irq = 0;
        }
        dev->irq = irq;
}

u8 pci_swizzle_interrupt_pin(const struct pci_dev *dev, u8 pin)
{
        int slot;

        if (pci_ari_enabled(dev->bus))
                slot = 0;
        else
                slot = PCI_SLOT(dev->devfn);

        return (((pin - 1) + slot) % 4) + 1;
}

从PCI总线上先读pin值，接着读出slot，计算出对应的irq。填充到的pci结构中。这就是中断注册的全部内容了。