存在关中断机制，低优先级的进程如果关闭了中断（进入临界区等），高优先级的进程中断发生也无法响应。
内核禁止抢占，进程进入内核，直到系统调用结束/被阻塞，高优先级进程无法被调度。
调度策略，分为实时任务和普通任务，只意味着谁优先被CPU调度，而没有保证完成时间。
虚拟内存机制通过 swap 可能让进程访问内存的时间不可预测。
高优先级的进程不能抢占低优先级进程的资源。如果高优先级的进程要使用低优先级进程正在使用的资源时，它必须等待低优先级的进程释放资源，容易产生优先级倒置；
Linux的周期模式定时器频率仅为100Hz，远不能满足多种实时应用的要求

中断线程化：把传统硬中断 top-half 的大部分逻辑移到内核线程里运行。可以被调度，减少CPU被不可抢占硬中断占用的时间。
开启可抢占RCU配置。
当低优先级任务（持锁）阻塞高优先级任务时，临时提升持锁低优先级任务的优先级，防止中等优先级任务抢占，缩短高优先级任务的等待时间。
使用rt_mutex替代spin lock，可抢占。支持优先级继承。
使用hwtimer替代jeffies等等。

主要负责
使能/禁止中断。
把中断分组到group0还是group1，0作为安全模式使用连接FIQ,1作为非安全模式，连接IRQ.
多核系统中将中断分配到不同处理器上。
设置电平的触发方式。
虚拟化扩展。

打开或关闭每个中断，Distributor对中断的控制分成两个级别，一个是全局中断的控制(GIC_DIST_CTRL),一旦关闭了全局中断，那么任何的中断源产生的中断事件都不会被传递到cpu interface。另一个级别是针对各个中断源进行控制，(GIC_DIST_ENABLE_CLEAR)，关闭一个中断源会导致该中断事件不会分发到CPU interface，但不影响其他中断源产生中断事件的分发。
控制将当前优先级最高的中断事件分发到一个或者一组CPU interface，当一个中断事件分发到多个CPU interface的时候，GIC的内部逻辑应该只保证assert一个CPU。
优先级控制
interrupt属性设定。电平触发，边缘触发等等。
interrupt group设定。设置每个中断的group。
将SGI中断分发到目标CPU上。
每个中断状态可见。
提供软件机制来设置和清楚外设终端的pending状态。

打开或关闭cpu interface 向连接的CPU assert中断事件，对于arm，cpu interface和cpu之间的中断信号线是nIRQCPU 和 nFIQCPU, 如果关闭了中断，即便是distributor分发了一个中断事件到CPU interface，也不会assert指定的IRQ或者FIQ通知core。
中断的确认。core会向cpu interface应答中断，应答当前优先级最高的那个中断，中断一旦被应答，distributor就会把该中断的状态从pending修改为active。ack了之后，cpu就会deassert nirqcpu和nfiqcpu信号线。
中断处理完毕的通知。当interruput handler处理完了一个中断的时候，会向写CPU interface的寄存器通知GIC CPU已经处理完该中断，做这个动作一方面是通知 Distributor 将中断状态修改为 deactive，另外一方面，CPU interface 会 priority drop，从而允许其他的 pending 的中断向 CPU 提交。
为 CPU 设置中断优先级掩码。通过 priority mask，可以 mask 掉一些优先级比较低的中断，这些中断不会通知到 CPU。
设置中断抢占策略。
在多个中断同时到来的时候，选择一个优先级最高的通知CPU。

GICV2:

SGI software generated interrupt。软件触发的中断，件可以通过写 GICD_SGIR 寄存器来触发一个中断事件，一般用于核间通信，内核中的 IPI：inter-processor interrupts 就是基于 SGI。
PPI private peripheral interrupt。私有外设中断，是每个核心私有的中断，PPI会送达到指定的cpu上，应用场景有CPU的本地时钟。
SPI Shared peripheral interrupt。公用的外部设备中断，也定义为共享中断。中断产生后，可以分发到某一CPU上，中断号ID32 - ID1019用于SPI，ID1020 - ID1023保留用于特殊用途；

GICV3：

SGI,SPI, LPI（locality spicific peripheral interrupt）GICV3中引入，是基于消息的中断，他们的配置保存在表中而不是寄存器。

GIC决定每个中断的 使能 状态，不使能的中断，是不能发送中断的
如果某个中断的中断源有效，GIC将该中断的状态设置为pending状态，然后判断该中断的目标core
对于每一个core，GIC将当前处于pending状态的优先级最高的中断，发送给该core的cpu interface
cpu interface接收GIC发送的中断请求，判断优先级是否满足要求，如果满足，就将中断通过nFIQ或nIRQ管脚，发送给core。
core响应该中断，通过读取 GICC_IAR 寄存器，来认可该中断。读取该寄存器，如果是软中断，返回源处理器ID，否则返回中断号。
当core认可该中断后，GIC将该中断的状态，修改为active状态
当core完成该中断后，通过写 EOIR （end of interrupt register）来实现优先级重置，写 GICC_DIR 寄存器，来无效该中断。

每个中断都维护了一个状态机。

inactive: 无中断状态，没有pending也没有active。
pending：硬件或软件触发了中断，该中断事件已经通过硬件信号通知到了GIC，等待GIC分配的CPU进行处理，在电平触发模式下，产生中断的同时保持pengding状态。
Active：cpu已经应答该中断请求，并且正在处理中。
Active and pending：当一个中断源处于Active时，同一中断源又触发了中断，进入pending状态，挂起来状态。

主要分为四部分：

1.硬件无关代码
2.cpu架构相关的中断处理
3.中断控制器代码
4.普通其他驱动

常见术语

irq number 软件定义，和硬件无关，CPU需要为每一个外设中断编号，
irq domain,irq域，将某一类资源划分成不同的领域，相同的域下共享一些共同的属性。irq domain负责GIC中hwirq到 虚拟irq的映射。
中断上半部/下半部：中断上半部处理简单的紧急的功能，清楚中断处理标志。大部分任务放到下半部处理。

gic: interrupt-controller@fd400000 {
           compatible = "arm,gic-v3";
           #interrupt-cells = <3>;		  // 参数个数
           #address-cells = <2>;
           #size-cells = <2>;
           ranges;
           interrupt-controller;

           reg = <0x0 0xfd400000 0 0x10000>, /* GICD */
                 <0x0 0xfd460000 0 0xc0000>; /* GICR */
           interrupts = <GIC_PPI 9 IRQ_TYPE_LEVEL_HIGH>;
           its: interrupt-controller@fd440000 {		// 在gic设备节点下，有一个子设备节点its，ITS设备用于将消息信号中断(MSI)路由到cpu
                   compatible = "arm,gic-v3-its";
                   msi-controller;
                   #msi-cells = <1>; // MSI设备的DeviceID
                   reg = <0x0 0xfd440000 0x0 0x20000>; /*ITS寄存器的物理地址*/
           };
   };

IRQCHIP_DECLARE(gic_v3, "arm,gic-v3", gicv3_of_init);  //初始化一个struct of_device_id的静态常量，并放置在__irqchip_of_table中

drivers/irqchip/irq-gic.c 
IRQCHIP_DECLARE(cortex_a7_gic, "arm,cortex-a7-gic", gic_of_init);
--> gic_of_init


init/main.c asmlinkage __visible void __init __no_sanitize_address start_kernel(void)
    --> early_irq_init(); init_IRQ();
      --> arch/arm64/kernel/irq.c --> irqchip_init();
          --> driver/irqchip/irqchip.c --> of_irq_init(__irqchip_of_table);
            --> drivers/of/irq.c ????

https://doc.embedfire.com/linux/rk356x/driver/zh/latest/linux_driver/subsystem_interrupt.html

某个进程时间片耗尽，会被系统挂起，切换到其他等待 CPU 的进程。
进程所需系统资源不足，需要等到资源满足时才可运行，此时会被挂起，其他进程会被调度。
进程通过 sleep 方法主动挂起，其他进程就有机会被调度。
有更高优先级的进程，当前进程会被挂起，高优先级进程会被调度。
硬件中断时，CPU 上的进程会被中断挂起，转而执行内核中的中断服务程序。

同一进程内线程切换：由于线程共享进程的虚拟内存和大部分资源，调度器只需切换线程私有的寄存器、内核栈和调度信息，而不需要切换虚拟内存，因此开销较小、

不同进程间切换：由于不共享虚拟内存和资源，切换时除了保存/恢复寄存器等线程上下文，还需要切换虚拟内存（mm_struct/CR3），这就是完整的进程上下文切换。

中断上下文切换指的是为了响应硬件的事件，中断处理会打断进程的正常调度和执行，转而调用中断处理程序，响应设备事件。而在打断其他进程时，就需要将当前的状态保存下来。这样在中断结束后，进程仍然可以从原来的状态恢复运行。
中断上下文切换，并不需要保存和恢复进程的虚拟内存等用户态资源，只需要处理 CPU 寄存器、内核堆栈等内核态的资源即可。

中断代码不能：
睡眠/放弃CPU，因为内核在进入中断前会 关闭进程调度，一旦睡眠/放弃CPU，这时内核无法调度别的进程来执行，系统就会死掉。
尝试获得信号量，如果获得不到信号量，代码就会睡眠，导致如上的结果。
执行耗时的任务，中断处理应该尽可能快，如果一个处理程序是IRQF_DISABLE类型，它执行的时候会禁止所有中断。
访问用户空间的虚拟地址，因为中断允许在内核空间。

enum {
    HI_SOFTIRQ = 0, /* 优先级高的tasklets */
    TIMER_SOFTIRQ, /* 定时器的下半部 */
    NET_TX_SOFTIRQ, /* 发送网络数据包 */
    NET_RX_SOFTIRQ, /* 接收网络数据包 */
    BLOCK_SOFTIRQ, /* BLOCK装置 */
    BLOCK_IOPOLL_SOFTIRQ,
    TASKLET_SOFTIRQ, /* 正常优先级的tasklets */
    SCHED_SOFTIRQ, /* 调度程序 */
    HRTIMER_SOFTIRQ, /* 高分辨率定时器 */
    RCU_SOFTIRQ, /* RCU锁定 */
    NR_SOFTIRQS /* 10 */
};

open_softirq(TASKLET_SOFTIRQ, tasklet_action);
tasklet_action_common中Tasklet确保同一时间只有一个特定的tasklet实例在运行，避免了竞争条件：

声明且初始化
DECLARE_WORK(name , void (*function)(struct work_struct *));
DECLARE_DELAYED_WORK(name, void(*function)(struct work_struct *));
EG:
void my_work_handler(struct work_struct *work);
DECLARE_WORK(my_work, my_work_handler);

初始化一个已经声明的工作队列
INIT_WORK(struct work_struct *work, void(*function)(struct work_struct *));
INIT_DELAYED_WORK(struct delayed_work *work, void(*function)(struct work_struct *));
EG:
void my_work_handler(struct work_struct * work);
struct work_struct my_work;
INIT_WORK(&my_work, my_work_handler);

schedule_work(struct work_struct *work);
schedule_delayed_work(struct delayed_work *work, unsigned long delay);

将work提交到系统默认的global workqueue，true 成功入队，false 已经在队列中。不需要自己控制 workqueue 的亲和性

普通 work
static void my_work_func(struct work_struct *work)
{
    pr_info("work executed\n");
}

static DECLARE_WORK(my_work, my_work_func);

void test(void)
{
    schedule_work(&my_work);  // 提交到系统 workqueue
}

延迟 work
static void my_delayed_work_func(struct work_struct *work)
{
    struct delayed_work *dwork = to_delayed_work(work);
    pr_info("delayed work executed\n");
}

static DECLARE_DELAYED_WORK(my_dwork, my_delayed_work_func);

void test(void)
{
    schedule_delayed_work(&my_dwork, msecs_to_jiffies(1000)); // 1s 后执行
}

// 取消work 模块卸载退出时使用
int cancel_work_sync(struct delayed_work *work);
int cancel_delayed_work_sync(struct delayed_work *work);

// 等待队列执行完成。常用于 模块退出时，确保没有遗留 work 在运行。
void flush_scheduled_work(void);
int schedule_delayed_work_on(int cpu, struct delayed_work *work, unsigned long delay);
int schedule_on_each_cpu(void(*function)(struct work_struct *));

// 自定义workqueue
// uses one thread for each processor in the system;
struct workqueue_struct *create_workqueue(const char *name);  
// uses a single thread.
struct workqueue_struct *create_singlethread_workqueue(const char *name);

WQ_UNBOUND 不绑定CPU
WQ_HIGHPRI 高优先级
WQ_MEM_RECLAIM 允许内存回收路径

// 提交work到自定义的队列 区别于 schedule_work：可选择具体的 workqueue。
int queue_work(struct workqueue_struct * queue, struct work_struct *work);
int queue_delayed_work(struct workqueue_struct *queue,
struct delayed_work * work , unsigned long delay);

static struct workqueue_struct *my_wq;
static DECLARE_WORK(my_work, my_work_func);

int init_module(void)
{
    my_wq = alloc_workqueue("my_wq", WQ_UNBOUND | WQ_MEM_RECLAIM, 1);
    queue_work(my_wq, &my_work);
    return 0;
}

void cleanup_module(void)
{
    flush_workqueue(my_wq);
    destroy_workqueue(my_wq);
}

如果推后执行的任务需要睡眠，那么就选择工作队列；如果推后执行的任务不需要睡眠，那么就选择tasklet。
另外，如果需要用一个可以重新调度的实体来执行你的下半部处理，也应该使用工作队列。它是唯一能在进程上下文运行的下半部实现的机制，也只有它才可以睡眠。这意味着在需要获得大量的内存时、在需要获取信号量时，在需要执行阻塞式的I/O操作时，它都会非常有用。如果不需要用一个内核线程来推后执行工作，那么就考虑使用tasklet。
  一般，不要轻易的去使用工作队列，因为每当创建一条工作队列，内核就会为这条工作队列创建一条内核线程。工作队列位于进程上下文，与软中断，tasklet有所区别，工作队列里允许延时，睡眠操作，而软中断，tasklet位于中断上下文，不允许睡眠和延时操作。

-i 显示网卡驱动的信息，名称，版本等
-S 查看收发包统计情况
-g/-G 查看或修改RingBuffer的大小
-l/-L 查看或修改网卡队列数
-c/-C 查看或修改硬中断合并策略

RX packets：接收的总包数
RX bytes：接收的字节数
RX errors：表示总的收包的错误数量
RX dropped：数据包已经进入了 Ring Buffer，但是由于其它原因导致的丢包
RX overruns：表示了 fifo 的 overruns，这是由于 Ring Buffer不足导致的丢包

/proc/net/dev 下有节点可以统计网卡工作数据
/sys/class/net/eth0/statistics 下也包含了网卡的统计信息

# ethtool -G eth1 rx 4096 tx 4096

ethtool -l eth0

ethtool -L eth0 combined 32

ethtool -c eth0

Adaptive RX: 自适应中断合并，网卡驱动自己判断啥时候该合并啥时候不合并
rx-usecs：当过这么长时间过后，一个RX interrupt就会被产生
rx-frames：当累计接收到这么多个帧后，一个RX interrupt就会被产生

ethtool -C eth0 adaptive-rx on可以直接修改。

cat /proc/softirqs 可以查看软中断信息
cat /proc/sys/net/core/netdev_budget 内核参数 

sysctl -w net.core.netdev_budget=600
（static struct ctl_table xxx注册后 就可以通过 sysctl -w xxx 来赋值）

ethtool -k eth0 | grep generic-receive-offload
generic-receive-offload: on
ethtool -K eth0 gro on 
GRO说的仅仅只是包的接收阶段的优化方式，对于发送来说是GSO。

取出指数和尾数。
对齐指数（移位操作）。
尾数执行整数加减/乘除。
结果归一化（调整指数和尾数）。
处理溢出/舍入/NaN/无穷大等特殊情况。

add_executable(one two.cpp three.h)     	生成一个one可执行文件
add_library(one STATIC two.cpp three.h)		生成一个库
STATIC,SHARED, 或者MODULE、BUILD_SHARED_LIBS
target_include_directories(one PUBLIC include) 添加包含目录，public，任何链接到这个目标的库都必须包含这个目录，PRIVATE 只影响当前，不影响依赖。INTERFACE，之影响依赖。
target_link_libraries(another PUBLIC one) 指定目标another。
set(MY_VARIABLE "value")  声明本地变量 变量名全部大写 变量值跟在后面 声明后，只能在它的作用域内访问这个变量。可以在 变量声明末尾加PARENT_SCOPE来将它的作用域置定为当前的上一级作用域。

set(MY_CACHE_VARIABLE "VALUE" CACHE STRING "" FORCE)
mark_as_advanced(MY_CACHE_VARIABLE)
将缓存的变量作为临时的全局变量

set(ENV{variable_name} value) 和 $ENV{variable_name} 设置/获取环境变量
CmakeCache.txt是缓存。当运行Cmake构建目录的时候会创建它。

set_property(TARGET TargetName PROPERTY CXX_STANDARD 11)     设置属性
get_property(ResultVariable TARGET TargetName PROPERTY CXX_STANDARD)  获取属性
             
if(variable)
else()
endif()

function()
	xxx
endfunction()



记得在任何使用目标的地方都指定关键字PUBLIC PRIVATE INTERFACE，那么就不会有问题

--trace 选项能够打印出运行的 CMake 的每一行。
CMake 3.7 添加了 --trace-source="filename" 选项，这让你可以打印出你想看的特定文件运行时执行的每一行。