Linux Notifier Chains

分手后的思念是犯贱 2022-06-13 07:39 109阅读 0赞

Linux Notifier Chains  
1.    引言  
Linux是单内核架构(monolithic kernel)，大多数内核子系统和模块是相互独立的，它们被动态地加载或卸载，以使内核变得小巧和可扩展。然而，子系统或模块之间需要通信，或者说某个特定模块扑捉到的事件可能其它模块对此感兴趣，这就需要一种机制来满足子系统或模块之间交互的需求。  
Linux使用通知链表来实现这一需求，它是一个简单的函数链表，当某件事件发生时，链表上的函数就会执行。这是一种发布-订阅(publish-subscribe)模式，当客户（订阅者）需要某个特定事件的通知时，会向主机（发布者）注册自己；接下来，只要感兴趣的事件一发生，主机便会通知客户。  
2.    Notifier定义  
在/include/linux/notifier.h文件中定义了通知链表节点  
struct notifier\_block \{  
    int (\*notifier\_call)(struct notifier\_block \*, unsigned long, void \*);  
    struct notifier\_block \*next;  
    int priority;  
\};  
其中，函数指针notifier\_call注册了当某个事件发生时需要调用的函数；next指向下一个链表节点；priority设定链表节点的优先级，数值越大优先级越高，默认为0。因此，所有的通知链表节点组成了一个单链表，并以优先级(priority)排列。  
3.    Notifier类型  
内核提供了四种类型的通知链表，它们的分类是基于执行上下文和调用通知链所需的锁保护机制：  
·Atomic notifier chains：该通知链表在中断或原子上下文执行，不能阻塞，链表事件对响应时间要求高，定义如下  
    struct atomic\_notifier\_head \{  
        spinlock\_t lock;  
        struct notifier\_block \*head;  
\};  
·Blocking notifier chains：在进程上下文执行，能够阻塞，链表事件对响应时间要求不高，定义如下  
    struct blocking\_notifier\_head \{  
        struct rw\_semaphore rwsem;  
        struct notifier\_block \*head;  
\};  
·Raw notifier chains：调用，注册或卸载链表通知时无限制，所需保护机制由调用者提供，定义如下  
    struct raw\_notifier\_head \{  
        struct notifier\_block \*head;  
\};  
·SRCU notifier chains：这是一种Sleepable Read Copy Update (SRCU)的链表通知，与block链表通知类似，不同在处理锁与保护上，SRCU在调用通知时的系统开销小，而从通知链表中去除通知调用的系统开销大，因此适合用在调用通知频繁，而移除调用通知少的情况中，定义如下  
struct srcu\_notifier\_head \{  
    struct mutex mutex;  
    struct srcu\_struct srcu;  
    struct notifier\_block \*head;  
\};  
4.    Notifier注册  
以blocking notifier chains为例，通常用一个宏来定义并初始化一个通知链表头，代码如下  
\#define BLOCKING\_NOTIFIER\_HEAD(name)                \\  
    struct blocking\_notifier\_head name =            \\  
        BLOCKING\_NOTIFIER\_INIT(name)  
然后向通知链表中注册通知节点，代码如下  
int blocking\_notifier\_chain\_register(struct blocking\_notifier\_head \*nh,  
        struct notifier\_block \*n)  
\{  
    int ret;  
  
    /\*  
     \* This code gets used during boot-up, when task switching is  
     \* not yet working and interrupts must remain disabled.  At  
     \* such times we must not call down\_write().  
     \*/  
    if (unlikely(system\_state == SYSTEM\_BOOTING))  
        return notifier\_chain\_register(&nh->head, n);  
  
    down\_write(&nh->rwsem);  
    ret = notifier\_chain\_register(&nh->head, n);  
    up\_write(&nh->rwsem);  
    return ret;  
\}  
第一个参数为通知链表头指针，而第二参数是要注册到该通知链表中的链表节点，调用函数notifier\_chain\_register( )实现了真正的注册，代码如下  
static int notifier\_chain\_register(struct notifier\_block \*\*nl,  
        struct notifier\_block \*n)  
\{  
    while ((\*nl) != NULL) \{  
        if (n->priority > (\*nl)->priority)  
            break;  
        nl = &((\*nl)->next);  
    \}  
    n->next = \*nl;  
    rcu\_assign\_pointer(\*nl, n);  
    return 0;  
\}  
当blocking notifier chains的头指针head为NULL时，将所要注册的notifier block  
赋给head，而该链表节点的next设为NULL；当blocking notifier chains的头指针head为非空时，若所要注册的notifier block的优先级比头节点的高，则将该链表节点的next指向头节点，而将该链表节点作为新的头节点；当blocking notifier chains的头指针head为非空时，且所要注册的notifier block的优先级比头节点的低，则将依据优先级高低遍历该通知链表上的节点，找到链表上第一个比自身优先级低的节点，将所要注册的链表节点插入到该节点之前。  
5.    Notifier发送  
仍以blocking notifier chains为例，当一个通知链表上注册了链表节点后，需要一个函数去按优先级去激活链表上注册的函数，代码如下  
int blocking\_notifier\_call\_chain(struct blocking\_notifier\_head \*nh,  
        unsigned long val, void \*v)  
\{  
    return \_\_blocking\_notifier\_call\_chain(nh, val, v, -1, NULL);  
\}  
  
int \_\_blocking\_notifier\_call\_chain(struct blocking\_notifier\_head \*nh,  
                   unsigned long val, void \*v,  
                   int nr\_to\_call, int \*nr\_calls)  
\{  
    int ret = NOTIFY\_DONE;  
  
    /\*  
     \* We check the head outside the lock, but if this access is  
     \* racy then it does not matter what the result of the test  
     \* is, we re-check the list after having taken the lock anyway:  
     \*/  
    if (rcu\_dereference(nh->head)) \{  
        down\_read(&nh->rwsem);  
        ret = notifier\_call\_chain(&nh->head, val, v, nr\_to\_call,  
                    nr\_calls);  
        up\_read(&nh->rwsem);  
    \}  
    return ret;  
\}  
我们发现调用的底层函数是notifier\_call\_chain( )，代码如下  
static int \_\_kprobes notifier\_call\_chain(struct notifier\_block \*\*nl,  
                    unsigned long val, void \*v,  
                    int nr\_to\_call,    int \*nr\_calls)  
\{  
    int ret = NOTIFY\_DONE;  
    struct notifier\_block \*nb, \*next\_nb;  
  
    nb = rcu\_dereference(\*nl);  
  
    while (nb && nr\_to\_call) \{  
        next\_nb = rcu\_dereference(nb->next);  
  
\#ifdef CONFIG\_DEBUG\_NOTIFIERS  
        if (unlikely(!func\_ptr\_is\_kernel\_text(nb->notifier\_call))) \{  
            WARN(1, "Invalid notifier called!");  
            nb = next\_nb;  
            continue;  
        \}  
\#endif  
        ret = nb->notifier\_call(nb, val, v);  
  
        if (nr\_calls)  
            (\*nr\_calls)++;  
  
        if ((ret & NOTIFY\_STOP\_MASK) == NOTIFY\_STOP\_MASK)  
            break;  
        nb = next\_nb;  
        nr\_to\_call--;  
    \}  
    return ret;  
\}  
第一个参数传入的是所要通知的链表头指针，第二个和第三个参数是要传递给通知函数的整型和指针参数，第四个参数nr\_to\_call限定了通知链表上响应的函数个数，为-1时无限制，第五个参数nr\_call记录了实际调用的通知链表上的函数个数，为NULL时不记录。  
6.    Notifier实例应用  
以framebuffer子系统为例，简单介绍通知链表的实现。  
在/drivers/video/fb\_notify.c中初始化了一个名为fb\_notifier\_list的通知链表头，代码如下  
static BLOCKING\_NOTIFIER\_HEAD(fb\_notifier\_list);  
在/drivers/video/console/fbcon.c文件中，函数fb\_console\_init( )在初始化framebuffer控制台时调用了函数fb\_register\_client(&fbcon\_event\_notifier)向通知链表头fb\_notifier\_list注册了一个名为fbcon\_event\_notifier的通知节点，定义如下  
static struct notifier\_block fbcon\_event\_notifier = \{  
    .notifier\_call    = fbcon\_event\_notify,  
\};  
其中fbcon\_event\_notify就是通知回调函数；而fb\_register\_client最终调用的就是注册通知节点的底层函数notifier\_chain\_register( )。  
在/drivers/video/fbmem.c文件中，函数register\_framebuffer( )在初始化注册framebuffer驱动时，在所有初始化工作完成后调用了函数fb\_notifier\_call\_chain(FB\_EVENT\_FB\_REGISTERED, &event)给通知链表fb\_notifier\_list发送事件FB\_EVENT\_FB\_REGISTERED，表明framebuffer已注册成功了，该函数最终调用了底层的链表通知函数notifier\_call\_chain( )，此时将遍历通知链表上所用的通知节点，显然节点fbcon\_event\_notifier的通知函数fbcon\_event\_notify将最终被调用执行。