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

    NR_SOFTIRQS
};

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);
}

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

void raise_softirq(unsigned int nr)
{
    unsigned long flags;

    local_irq_save(flags);
    raise_softirq_irqoff(nr);
    local_irq_restore(flags);
}

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>
 
static struct tasklet_struct my_tasklet;
 
static void my_tasklet_handle(unsigned long data)
{
    printk("tasklet handle running...\n");
}
 
static irqreturn_t xxx_interrupt(int irq, void *dev_id)
{
    // 调度 tasklet
    tasklet_schedule(&my_tasklet);
}
 
static int __init demo_driver_init(void)
{
    // 初始化一个 tasklet ，关联处理函数
    tasklet_init(&my_tasklet, my_tasklet_handle, 0);
    request_irq(xxx, xxx_interrupt, IRQF_SHARED, xxx, xxx);
    return 0;
}
 
static void __exit demo_driver_exit(void)
{
    tasklet_kill(&my_tasklet);
    return ;
}
 
module_init(demo_driver_init);
module_exit(demo_driver_exit);
MODULE_LICENSE("GPL v2");

struct tasklet_struct
{
    struct tasklet_struct *next;
    unsigned long state;
    atomic_t count;
    bool use_callback;
    union {
        void (*func)(unsigned long data);
        void (*callback)(struct tasklet_struct *t);
    };
    unsigned long data;
};

static inline void tasklet_schedule(struct tasklet_struct *t)
{
    if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
        __tasklet_schedule(t);
}
void __tasklet_schedule(struct tasklet_struct *t)
{
    __tasklet_schedule_common(t, &tasklet_vec,
                  TASKLET_SOFTIRQ);
}
static void __tasklet_schedule_common(struct tasklet_struct *t,
                      struct tasklet_head __percpu *headp,
                      unsigned int softirq_nr)
{
    struct tasklet_head *head;
    unsigned long flags;

    local_irq_save(flags);
    head = this_cpu_ptr(headp);
    t->next = NULL;
    *head->tail = t;
    head->tail = &(t->next);
    raise_softirq_irqoff(softirq_nr);
    local_irq_restore(flags);
}

static __latent_entropy void tasklet_action(struct softirq_action *a)
{
    tasklet_action_common(a, this_cpu_ptr(&tasklet_vec), TASKLET_SOFTIRQ);
}

static void tasklet_action_common(struct softirq_action *a,
                  struct tasklet_head *tl_head,
                  unsigned int softirq_nr)
{
    struct tasklet_struct *list;

    local_irq_disable();
    list = tl_head->head; // 获取 tasklet 链表
    tl_head->head = NULL; // 清空 tasklet 链表，即 tasklet_vec
    tl_head->tail = &tl_head->head;
    local_irq_enable();

    while (list) {
        struct tasklet_struct *t = list;

        list = list->next;
// TASKLET_STATE_SCHED: 表示该 tasklet 已经被挂接到某个 CPU 上
// TASKLET_STATE_RUN: 表示该 tasklet 正在某个 CPU 上执行
// 检查并设置 TASKLET_STATE_RUN 标记，返回 1: 表示 tasklet 没有被执行 返回 0: 表示 tasklet 已经被执行
        if (tasklet_trylock(t)) {
            if (!atomic_read(&t->count)) { // 如果当前 tasklet 没有被 tasklet_disable()
                if (tasklet_clear_sched(t)) { // 清除 TASKLET_STATE_SCHED 状态，便于该 tasklet 可以再次被添加到某个 cpu 的链表中
// 这期间，该 tasklet 可以被 tasklet_schedule()并添加到某个 cpu 的链表中，从而引出下面第二种情况
                    if (t->use_callback)
                        t->callback(t);
                    else
                        t->func(t->data); // 如果没有执行且没有 disable 则执行
                }
                tasklet_unlock(t); // 清理 TASKLET_STATE_RUN 标记
                continue; // 继续下一个 tasklet
            }
            tasklet_unlock(t);// 如果当前已经被 disable 了，那就清理 TASKLET_STATE_RUN 标记
        }

// 有两种情况下，会将该 tasklet 再挂接回链表内，并重新触发，等待下一次执行的机会
// 1. 如果没有被执行，但是被调用 tasklet_disable() 接口 disable 了
// 2. 当前 tasklet 正在某 CPU 执行 func，这时候 tasklet 又被挂到某个 cpu 的
// 链表中并准备执行 tasklet 对应的函数，为了满足同一个 tasklet 只能在一个 CPU 上执行的设计原则
// 因此此次不执行 tasklet，挂入链表后等待下一次被执行的时机执行

        local_irq_disable();
        t->next = NULL;
        *tl_head->tail = t;
        tl_head->tail = &t->next;
        __raise_softirq_irqoff(softirq_nr);
        local_irq_enable();
    }
}

void tasklet_kill(struct tasklet_struct *t)
{
    if (in_interrupt())
        pr_notice("Attempt to kill tasklet from interrupt\n");

    while (test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
        wait_var_event(&t->state, !test_bit(TASKLET_STATE_SCHED, &t->state));

    tasklet_unlock_wait(t);
    tasklet_clear_sched(t);
}

void tasklet_unlock_wait(struct tasklet_struct *t)
{
    wait_var_event(&t->state, !test_bit(TASKLET_STATE_RUN, &t->state));
}