Linux Kernel Interrupt、Interrupt Priority、Prohibit Things Whthin CPU In The Interrupt Off State

0. 引言
1. Linux 中断的概念
2. Linux 中断相关的源代码分析
3. Linux 硬件中断
4. Linux 软中断
5. 中断优先级
6. CPU在关中断状态下编程要注意的事项

1. 程序查询：
CPU周期性询问外部设备是否准备就绪。该方式的明显的缺点就是浪费CPU资源，效率低下。但是在特定的场景下这种"程序查询"的方式还有有它的用武之地的
例如，在网络驱动中，通常接口(Interface)每接收一个报文，就发出一个中断。而对于高速网络，每秒就能接收几千个报文，在这样的负载下，系统性能会受到极大的损害。为了提高系统性能，内核开发者已经为网络子系统开发了一种可选的基于查询的接口NAPI(代表new API)。当系统拥有一个高流量的高速接口时，系统通常会收集足够多的报文，而不是马上中断CPU 

2. 中断方式
这是现代CPU最常用的与外围设备通信方式。相对于轮询，该方式不用浪费稀缺的CPU资源，所以高效而灵活。中断处理方式的缺点是每传送一个字符都要进行中断，启动中断控制器，还要保留和恢复现场以便能继续原程序的执行，花费的工作量很大，这样如果需要大量数据交换，系统的性能会很低 

3. DMA方式
通常用于高速设备，设备请求直接访问内存，不用CPU干涉。但是这种方式需要DMA控制器，增加了硬件成本。在进行DMA数据传送之前，DMA控制器会向CPU申请总线控制 权，CPU如果允许，则将控制权交出，因此，在数据交换时，总线控制权由DMA控制器掌握，在传输结束后，DMA控制器将总线控制权交还给CPU 

http://blog.sina.com.cn/s/blog_5d0e8d0d01019cds.html

http://www.cnblogs.com/LittleHann/p/4111692.html

1. 异步中断(外部中断)
外部中断是由外部设备引发的中断，这类中断的特点是中断的发生完全是"瞬发"的，例如
    1) 鼠标
    2) 键盘

2. 同步中断(内部中断)
从CPU的角度看，内部中断是一个同步事件，它是执行某条指令时产生的，例如
    1) 缺页异常
    2) 除零异常
    3) 系统调用systemcall trap

1. 可被屏蔽中断：允许延迟响应
2. 不可被屏蔽中断：高实时场景需求，必须立即被响应

1. 软件中断
    1) Ring3代码中触发的指令中断
    2) 操作系统自身触发的缺页中断
这是操作系统提供的对CPU中断的一个接口，以中断号的形式进行编号
2. 硬件中断
    1) 外部硬件设备触发的硬件中断(电平信号)

1. 建立一个适当的环境，即保存现场(entry path)
进入路径的关键任务有:
    1) 从用户态栈切换到和心态栈(内存栈的切换)
    2) 保存用户应用程序当前的寄存器状态，以便在中断活动结束后恢复

2. 调用处理程序自身

3. 将系统还原，即还原现场(exit path)
退出路径的关键任务有:
    1) 调度器是否应该选择一个新进程代替旧的进程
    2) 是否有信号必须投递到原进程
    3) 从中断返回后，只有确认了以上1.)、2.)问题后，内核才能完成其常规任务，即还原寄存器集合、切换到用户态栈、切换到适用于用户应用程序的适当的处理器状态

1. 实现(特别是在禁用其他中断时，即最高中断级情况下)的代码逻辑应该包含尽可能少的代码，已支持快速处理
2. 可以在其他ISR执行期间调用的中断处理程序例程，不能彼此干扰(即对全局资源、同步操作的锁操作)

1. 关键操作必须在中断发生后立即执行。否则，无法维持系统的稳定性，或计算机的正确运作，在执行此类操作期间，必须禁用其他中断
2. 非关键操作也应该尽快执行，但允许启用中断(因而可能被其他系统事件中断)
3. 可延期操作不是特别重要，不必在中断处理程序中实现。内核可以延迟这些操作，在时间充裕时进行。内核提供了tasklet，用于在稍后执行可延期操作

1. 汇编语言代码：与处理器高度相关，用于处理特定平台上相关的底层细节
2. 抽象接口：设备驱动程序及其他内核代码安装和管理IRQ处理程序所需的

struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = 
{
    /*
    IRQ的最大数量主要取决于辅助CPU管理IRQ的辅助芯片
    1. alpha: 32个中断
    2. wildfire: 2048个中断
    3. IA-64: 256个中断
    4. IA-32、8256A控制器: 16个中断
    */
    [0 ... NR_IRQS-1] = 
    {
        .status = IRQ_DISABLED,
        .chip = &no_irq_chip,
        //handle_bad_irq对没有安装处理程序的中断进行确认
        .handle_irq = handle_bad_irq,
        .depth = 1,
        .lock = __SPIN_LOCK_UNLOCKED(irq_desc->lock),
    }
};

1. 高层ISR(high-level interrupt service routines 高层中断服务例程)
针对设备驱动程序端(或其他内核组件)的中断，执行由此引起的所有必要的工作。例如，如果设备使用中断通知一些数据已经到达，那么高层ISR的工作应该是将数据复制到适当的位置

2. 中断电流处理(interrup flow handling)
处理不同的中断电流类型之间的各种差别，如
    1) 边沿触发(edge-triggering): 硬件通过感知线路上的点位差来检测中断
    2) 电平触发(level-triggering): 根据特定的电势值检测中断，与电势是否改变无关

3. 芯片级硬件封装(chip-level hardware encapsultion)
需要与在电子学层次上产生中断的底层硬件直接通信，该抽象层可以视为中断控制器的某种"设备驱动程序"

http://www.cnblogs.com/LittleHann/p/3865490.html

1. 电流层ISR: 由handle_irq提供
handler_data可以指向任意数据，该数据可以是特定于IRQ或处理程序的。每当发生中断时，特定于体系结构的代码都会调用handle_irq。该函数负责使用chip中提供的特定于控制器的方法，进行处理中断所必需的一些底层操作 

2. action提供了一个操作链: 需要在中断发生时执行
由中断通知的设备驱动程序，可以将与之相关的处理程序函数放置在此处

3. 电流处理和芯片相关操作被封装在chip中
chip_data指向可能与chip相关的任意数据

4. name指定了电流层处理程序的名称，将显示在/proc/interrupts中。对边沿触发中断，通常是"edge"，对电平触发中断，通常是"level"

5. delth: 用于确定IRQ电路是启用的还是禁用的
    1) 0: 表示启用
    2) 正值: 表示禁用

6. irq_count、irq_unhandled字段提供了一些统计量，可用于检测停顿和未处理，但持续发生的中断。即假中断(spurious interrupt)

7. status: 描述了IRQ的当前状态
IRQ不仅可以在处理程序安装期间改变其状态，而且可以在运行时改变，根据status当前的值，内核很容易获知某个IRQ的状态，而无需了解底层实现的硬件相关特性
irq.h中定义了各种表示当前状态的常数，可用于描述IRQ电路当前的状态。每个常数表示位串中的一个置为的标志位(可以同时设置)

http://www.cnblogs.com/LittleHann/p/3865490.html
//搜索：struct irq_chip
//搜索：struct irqaction

1. 设置控制器硬件
内核提供了一系列的标准函数，用于注册irq_chip和设置电流程序
    1) extern int set_irq_chip(unsigned int irq, struct irq_chip *chip);
    将一个IRQ芯片以irq_chip实例的形式关联到某个特定的中断

    2) static inline void set_irq_handler(unsigned int irq, irq_flow_handler_t handle);
    3) static inline void set_irq_chained_handler(unsigned int irq, irq_flow_handler_t handle);
    为某个给定的IRQ编号设置电流处理程序

    4) extern void set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip, irq_flow_handler_t handle);
    5) extern void set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip, irq_flow_handler_t handle, const char *name);
    这是一个快捷方式，它相当于连续调用上述的各函数

2. 电流处理
    1) 边沿触发中断
    2) 电平触发中断
    3) 其他中断类型

1. 注册IRQ
由设备驱动程序动态注册ISR的工作，IRQ注册的过程就是基础数据结构的创建和填充的过程

2. 释放IRQ
释放IRQ的过程和注册的过程正好相反，即将相关的数据结构从内核的一般数据结构中删除

3. 注册中断
我们知道，CPU需要响应的中断由两部分引起
    1) 系统外设的中断请求所引发的中断
    2) 由处理器本身、或用户进程中的软件机制所引发的中断

1. 进入路径从用户态切换到内核态
2. 执行实际的处理程序例程
3. 从和心态切换回用户态

http://www.cnblogs.com/LittleHann/p/3850655.html
http://www.cnblogs.com/LittleHann/p/3850653.html
http://www.cnblogs.com/LittleHann/p/3871630.html
http://blog.csdn.net/droidphone/article/details/7445825

1. 系统调用(在2.6以后，系统调用不采用中断而是采用sysenter进入内核了)
2. 键盘鼠标外设
3. 硬盘的数据传输
4. 网卡的数据通信
...

..
common_interrupt:
    addl $-0x80,(%esp)    /* Adjust vector into the [-256,-1] range */
    SAVE_ALL
    TRACE_IRQS_OFF
    movl %esp,%eax
    call do_IRQ
    jmp ret_from_intr
ENDPROC(common_interrupt)
    CFI_ENDPROC
..

1. x86
\linux-3.15.5\arch\x86\kernel\irq.c
__visible unsigned int __irq_entry do_IRQ(struct pt_regs *regs)

2. arm
\linux-3.15.5\arch\arm\kernel\irq.c
asmlinkage void __exception_irq_entry asm_do_IRQ(unsigned int irq, struct pt_regs *regs)

1. IA-32 CPU体系结构下，pt_regs通常定义如下
\linux-3.15.5\arch\x86\include\asm\ptrace.h 
struct pt_regs {
    unsigned long bx;
    unsigned long cx;
    unsigned long dx;
    unsigned long si;
    unsigned long di;
    unsigned long bp;
    unsigned long ax;
    unsigned long ds;
    unsigned long es;
    unsigned long fs;
    unsigned long gs;
    unsigned long orig_ax;
    unsigned long ip;
    unsigned long cs;
    unsigned long flags;
    unsigned long sp;
    unsigned long ss;
};
#else /* __i386__ */
struct pt_regs {
    unsigned long r15;
    unsigned long r14;
    unsigned long r13;
    unsigned long r12;
    unsigned long bp;
    unsigned long bx;
/* arguments: non interrupts/non tracing syscalls only save up to here*/
    unsigned long r11;
    unsigned long r10;
    unsigned long r9;
    unsigned long r8;
    unsigned long ax;
    unsigned long cx;
    unsigned long dx;
    unsigned long si;
    unsigned long di;
    unsigned long orig_ax;
/* end of arguments */
/* cpu exception frame or undefined */
    unsigned long ip;
    unsigned long cs;
    unsigned long flags;
    unsigned long sp;
    unsigned long ss;
/* top of stack page */
};


2. PA-Risc CPU体系结构下
\linux-3.15.5\arch\parisc\include\uapi\asm\ptrace.h 
struct pt_regs {
    unsigned long gr[32];    /* PSW is in gr[0] */
    __u64 fr[32];
    unsigned long sr[ 8];
    unsigned long iasq[2];
    unsigned long iaoq[2];
    unsigned long cr27;
    unsigned long pad0;     /* available for other uses */
    unsigned long orig_r28;
    unsigned long ksp;
    unsigned long kpc;
    unsigned long sar;    /* CR11 */
    unsigned long iir;    /* CR19 */
    unsigned long isr;    /* CR20 */
    unsigned long ior;    /* CR21 */
    unsigned long ipsw;    /* CR22 */
};

__visible unsigned int __irq_entry do_IRQ(struct pt_regs *regs)
{
    //将一个指向寄存器集合的指针保存在一个全局的CPU变量中(中断发生之前，变量中保存的旧指针会保留下来，供后续使用)。需要访问寄存器集合的中断处理程序，可以从该变量中访问
    struct pt_regs *old_regs = set_irq_regs(regs);

    /* high bit used in ret_from_ code  */
    unsigned vector = ~regs->orig_ax;
    unsigned irq;

    /*
    irq_enter负责更新一些统计量，对于具备动态时钟周期特性的系统，如果系统已经有很长一段时间没有发生时钟中断，则更新全局计时变量jiffiles
    接下来，调用所述IRQ注册的ISR的任务委托给体系结构无关的函数generic_handle_irq，它调用irq_desc[irq]->handle_irq来激活电流控制处理程序
    */
    irq_enter();
    exit_idle();

    irq = __this_cpu_read(vector_irq[vector]);

    if (!handle_irq(irq, regs)) 
    {
        ack_APIC_irq(); 
        if (irq != VECTOR_RETRIGGERED) 
        {
            pr_emerg_ratelimited("%s: %d.%d No irq handler for vector (irq %d)\n", __func__, smp_processor_id(), vector, irq);
        } 
        else 
        {
            __this_cpu_write(vector_irq[vector], VECTOR_UNDEFINED);
        }
    }

    /*
    irq_exit负责记录一些统计量，另外还要调用do_softirq来处理任何待决的软件IRQ
    */
    irq_exit(); 
    set_irq_regs(old_regs);
    return 1;
}

1. 限制
需要注意的是，内核代码的运行会处于两种上下文状态
    1) 中断上下文(interrupt context)
    2) 常规上下文
在实现ISR(interrupt service routines)时，ISR一定是在"中断上下文(interrupt context)"中执行的，为了区分当前内核的这两种情况，内核提供了in_interrupt函数，用于指明当前是否在处理中断
/*
中断上下文和普通上下文的区别之处在于
0x1: 中断是异步执行的，它可以在任何时间发生。因而从用户空间来看，处理程序例程不是在一个明确定义的环境中执行。这种情况下，禁止访问用户空间，特别是与用户空间地址之间来回复制内存数据的行为。
例如：网络驱动程序不能将接收到的数据直接转发到等待的应用程序，因为内核无法确定等待数据的应用程序此时是否正在运行(是否获得CPU调度资源)

0x2: 中断上下文中不能调用调度器，因而不能自愿地放弃控制权
换句话说，这个时候不能使用自旋锁等操作，因为在关中断的情况下，CPU已经不响应外部的中断请求了，这个时候进行CPU调度会直接导致panic

0x3: 处理程序例程不能进入睡眠状态。只有在外部事件导致状态改变并唤醒进程时，才能解除睡眠状态。但中断上下文不允许中断，进程睡眠后，内核只能永远等待下去，因为也不能调用调度器，不能选择进程来执行。
要特别注意的是：只确保处理程序例程的直接代码不进入睡眠状态这是不够的，其中调用的所有过程和函数(以及这些函数的子函数/子过程，以此类推)都不能进入睡眠状态
*/

2. 实现处理程序
中断处理程序只能使用两种返回值:
    1) 正确地处理了IRQ: 返回IRQ_HANDLED
    2) ISR不负责该ISR: 返回IRQ_NONE

ENTRY(resume_userspace)
    LOCKDEP_SYS_EXIT
     DISABLE_INTERRUPTS(CLBR_ANY)    # make sure we don‘t miss an interrupt
                    # setting need_resched or sigpending
                    # between sampling and the iret
    TRACE_IRQS_OFF
    movl TI_flags(%ebp), %ecx
    andl $_TIF_WORK_MASK, %ecx    # is there any work to be done on
                    # int/exception return?
    jne work_pending
    jmp restore_all
END(ret_from_exception)

深入linux内核架构(中文版).pdf 14章

http://blog.csdn.net/droidphone/article/details/7445825

1. 来自外设硬件的硬件中断，电气级别的中断触发
2. 由CPU自身执行中触发的软中断

1. 产生中断信号
2. 维护软中断向量
3. 进行中断处理 

1. 初始化: 定义一个新的可延迟函数，这个操作通常在内核自身初始化或加载过模块时进行 
2. 激活: 标记一个可延迟函数为"挂起"状态(可延迟函数的下一轮调度中可执行)，激活可以在任何时后进行(即是正在处理中断)
3. 屏蔽: 有选择的屏蔽一个可延迟函数，这样，即使它被激活，内核也不执行它 
4. 执行: 执行一个挂起的可延迟函数和同类型的其他所有挂起的可延迟函数，执行是在特定的时间内进行的 

enum
{
        HI_SOFTIRQ=0,
        TIMER_SOFTIRQ,
        NET_TX_SOFTIRQ,
        NET_RX_SOFTIRQ,
        BLOCK_SOFTIRQ,
        BLOCK_IOPOLL_SOFTIRQ,
        TASKLET_SOFTIRQ,
        SCHED_SOFTIRQ,
        HRTIMER_SOFTIRQ,
        RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */

        NR_SOFTIRQS
};

const char * const softirq_to_name[NR_SOFTIRQS] = 
{
    "HI", "TIMER", "NET_TX", "NET_RX", "BLOCK", "BLOCK_IOPOLL",
    "TASKLET", "SCHED", "HRTIMER", "RCU"
};

struct softirq_action
{
    //指向处理程序例程的指针，在软中断发生时由内核执行该处理程序例程
    void    (*action)(struct softirq_action *);
};

void open_softirq(int nr, void (*action)(struct softirq_action *))
{
    softirq_vec[nr].action = action;
}

void __init softirq_init(void)
{
    int cpu;

    for_each_possible_cpu(cpu) 
    {
        per_cpu(tasklet_vec, cpu).tail = &per_cpu(tasklet_vec, cpu).head;
        per_cpu(tasklet_hi_vec, cpu).tail = &per_cpu(tasklet_hi_vec, cpu).head;
    }

    open_softirq(TASKLET_SOFTIRQ, tasklet_action);
    open_softirq(HI_SOFTIRQ, tasklet_hi_action);
}

asmlinkage __visible void __do_softirq(void)
{
    unsigned long end = jiffies + MAX_SOFTIRQ_TIME;
    unsigned long old_flags = current->flags;
    int max_restart = MAX_SOFTIRQ_RESTART;
    struct softirq_action *h;
    bool in_hardirq;
    __u32 pending;
    int softirq_bit;
    int cpu;

    /*
     * Mask out PF_MEMALLOC s current task context is borrowed for the
     * softirq. A softirq handled such as network RX might set PF_MEMALLOC
     * again if the socket is related to swap
     */
    current->flags &= ~PF_MEMALLOC;

    /*
    首先要确认当前不处于中断上下文中，如果处于中断上下文，则立即结束，因为软中断用于执行ISR中非时间关键部分，所以其代码本身一定不能在中断处理程序内调用
    通过local_softirq_pending，确定当前CPU软中断位图中所置位的比特位
    */
    pending = local_softirq_pending();
    account_irq_enter_time(current);

    __local_bh_disable_ip(_RET_IP_, SOFTIRQ_OFFSET);
    in_hardirq = lockdep_softirq_start();

    cpu = smp_processor_id();
restart:
    /* Reset the pending bitmask before enabling irqs */
    set_softirq_pending(0);

    local_irq_enable();

    h = softirq_vec;

    while ((softirq_bit = ffs(pending))) {
        unsigned int vec_nr;
        int prev_count;

        h += softirq_bit - 1;

        vec_nr = h - softirq_vec;
        prev_count = preempt_count();

        kstat_incr_softirqs_this_cpu(vec_nr);

        trace_softirq_entry(vec_nr);
        h->action(h);
        trace_softirq_exit(vec_nr);
        if (unlikely(prev_count != preempt_count())) {
            pr_err("huh, entered softirq %u %s %p with preempt_count %08x, exited with %08x?\n",
                   vec_nr, softirq_to_name[vec_nr], h->action,
                   prev_count, preempt_count());
            preempt_count_set(prev_count);
        }
        rcu_bh_qs(cpu);
        h++;
        pending >>= softirq_bit;
    }

    local_irq_disable();

    pending = local_softirq_pending();
    if (pending) {
        if (time_before(jiffies, end) && !need_resched() &&
            --max_restart)
            goto restart;

        wakeup_softirqd();
    }

    lockdep_softirq_end(in_hardirq);
    account_irq_exit_time(current);
    __local_bh_enable(SOFTIRQ_OFFSET);
    WARN_ON_ONCE(in_interrupt());
    tsk_restore_flags(current, old_flags, PF_MEMALLOC);
}

http://rock3.info/blog/2013/11/20/%E8%BD%AF%E4%B8%AD%E6%96%AD%E5%8E%9F%E7%90%86/
http://blog.csdn.net/droidphone/article/details/7518428http://www.crashcourse.ca/wiki/index.php/Softirqs

1. 对内核来说，假设当前有两个设备同时发出中断请求 
2. CPU首先处理优先级最高的中断
3. 中断控制器向CPU报告优先级高的中断(中断A)，低优先级的中断(中断B)被延迟
4. 内核把当前运行级别提升到高优先级的IRQL
5. 在高优先级的中断处理例程中，如果出现了一个比当前优先级更高优先级的IRQL请求(中断C)，则将当前中断处理例程(中断A)放入就绪队列挂起
6. 当最高优先级的中断处理例程(中断C)处理完毕之后，然后处理延迟的调度请求(中断A、中断B)
/*
中断A->中断C->中断A->中断B
*/
7. 当全部中断都处理完毕后，就会处理延迟的软件中断(即在do_IRQ的末尾检测是否有软中断需要处理)
8. 最后再返回用户态

详细的信息请参阅《Intel® 64 and IA-32 Architectures Developer‘s Manual: Vol. 3A》
http://www.intel.com/content/www/us/en/architecture-and-technology/64-ia-32-architectures-software-developer-vol-3a-part-1-manual.html

void __init default_find_smp_config(void)
{
    unsigned int address;

    /*
     * FIXME: Linux assumes you have 640K of base ram..
     * this continues the error...
     *
     * 1) Scan the bottom 1K for a signature
     * 2) Scan the top 1K of base RAM
     * 3) Scan the 64K of bios
     */
    if (smp_scan_config(0x0, 0x400) ||
        smp_scan_config(639 * 0x400, 0x400) ||
        smp_scan_config(0xF0000, 0x10000))
        return;
    /*
     * If it is an SMP machine we should know now, unless the
     * configuration is in an EISA bus machine with an
     * extended bios data area.
     *
     * there is a real-mode segmented pointer pointing to the
     * 4K EBDA area at 0x40E, calculate and scan it here.
     *
     * NOTE! There are Linux loaders that will corrupt the EBDA
     * area, and as such this kind of SMP config may be less
     * trustworthy, simply because the SMP table may have been
     * stomped on during early boot. These loaders are buggy and
     * should be fixed.
     *
     * MP1.4 SPEC states to only scan first 1K of 4K EBDA.
     */

    address = get_bios_ebda();
    if (address)
        smp_scan_config(address, 0x400);
}

/*
 * Returns physical address of EBDA.  Returns 0 if there is no EBDA.
 */
static inline unsigned int get_bios_ebda(void)
{
    /*
     * There is a real-mode segmented pointer pointing to the
     * 4K EBDA area at 0x40E.
     */
    unsigned int address = *(unsigned short *)phys_to_virt(0x40E);
    address <<= 4;
    return address;    /* 0 means none */
}

static void __init apic_intr_init(void)
{
    smp_intr_init();

#ifdef CONFIG_X86_THERMAL_VECTOR
    alloc_intr_gate(THERMAL_APIC_VECTOR, thermal_interrupt);
#endif
#ifdef CONFIG_X86_MCE_THRESHOLD
    alloc_intr_gate(THRESHOLD_APIC_VECTOR, threshold_interrupt);
#endif

#if defined(CONFIG_X86_64) || defined(CONFIG_X86_LOCAL_APIC)
    /* self generated IPI for local APIC timer */
    alloc_intr_gate(LOCAL_TIMER_VECTOR, apic_timer_interrupt);

    /* IPI for X86 platform specific use */
    alloc_intr_gate(X86_PLATFORM_IPI_VECTOR, x86_platform_ipi);
#ifdef CONFIG_HAVE_KVM
    /* IPI for KVM to deliver posted interrupt */
    alloc_intr_gate(POSTED_INTR_VECTOR, kvm_posted_intr_ipi);
#endif

    /* IPI vectors for APIC spurious and error interrupts */
    alloc_intr_gate(SPURIOUS_APIC_VECTOR, spurious_interrupt);
    alloc_intr_gate(ERROR_APIC_VECTOR, error_interrupt);

    /* IRQ work interrupts: */
# ifdef CONFIG_IRQ_WORK
    alloc_intr_gate(IRQ_WORK_VECTOR, irq_work_interrupt);
# endif

#endif
}

1. 不能使用vmalloc
    1) vmalloc可能导致缺页中断
    2) vmalloc在内部使用了kmalloc(.., PAGE_KERNEL)，这可能导致在申请内存的时候的睡眠，因为这个使用CPU无法响应中断，随机导致kernel panic
2. 如果使用kmalloc
    1) 不能使用PAGE_KERNEL，原因和vmalloc的"2)"是相同的
    2) 必须使用GFP_ATOMIC

http://www.cnblogs.com/LittleHann/p/4113830.html

http://www.cnblogs.com/LittleHann/p/4116368.html

1. copy_from_user、strncpy_from_user都是在进行从用户态到内核态的内存复制
2. 内核无法确定等待数据的应用程序此时是否正在运行(是否获得CPU调度资源)
3. 在copy_from_user、strncpy_from_user运行中，有一定概率发生当前正在复制的UserSpace内存被Page Out，这个时候进行内存复制就会触发缺页中断(Page Fault)，缺页中断会引发一个CPU中断
4. 在Kprobe关中断情况下，回调Handler函数中引发的CPU中断是无法得到响应的
5. copy_from_user、strncpy_from_user在复制过程中引发的Page Fault，不能得到响应，只会被自身汇编代码中的.fixup函数段捕获，并打印:  do_page_fault....，但其实这个时候已经是不正常现象了
6. Linux在发生了Page Fault之后，不会立刻Kernel Panic，而是继续运行，但是此时系统已经处于不正常状态了，如果继续运行，最终可能导致Panic

1. http://lxr.free-electrons.com/source/arch/x86/include/asm/uaccess.h#L688
2. http://lxr.free-electrons.com/source/arch/x86/lib/usercopy_32.c#L681
3. http://lxr.free-electrons.com/source/arch/x86/include/asm/uaccess.h#L88
4. http://lxr.free-electrons.com/source/arch/x86/lib/usercopy_32.c#L583
5. http://lxr.free-electrons.com/source/arch/x86/lib/usercopy_32.c#L531

http://www.cs.fsu.edu/~baker/devices/lxr/http/source/2.6.25.8/linux/arch/x86/lib/usercopy_64.c?v=.
http://www.verydemo.com/demo_c378_i61436.html
http://www.tuicool.com/articles/uYzAzy
http://www.hep.by/gnu/kernel/kernel-api/API-strncpy-from-user.html
http://blog.csdn.net/justlinux2010/article/details/8972754
https://www.kernel.org/doc/htmldocs/device-drivers/API-might-sleep.html

http://blog.csdn.net/yangdelong/article/details/5491097
http://oss.org.cn/kernel-book/ldd3/ch06s02.html
http://blog.csdn.net/eroswang/article/details/3529750
http://blog.csdn.net/ce123_zhouwei/article/details/8454226