Linux 核心通知鏈機制的原理及實現

一、概念：

大多數核心子系統都是相互獨立的，因此某個子系統可能對其它子系統產生的事件感興趣。為了滿足這個需求，也即是讓某個子系統在發生某個事件時通知其它的子 系統，Linux核心提供了通知鏈的機制。通知連結串列只能夠在核心的子系統之間使用，而不能夠在核心與使用者空間之間進行事件的通知。 通知連結串列是一個函式連結串列，連結串列上的每一個節點都註冊了一個函式。當某個事情發生時，連結串列上所有節點對應的函式就會被執行。所以對於通知連結串列來說有一個通知 方與一個接收方。在通知這個事件時所執行的函式由被通知方決定，實際上也即是被通知方註冊了某個函式，在發生某個事件時這些函式就得到執行。其實和系統調 用signal的思想差不多。

二、資料結構：

通知鏈有四種型別：

1.原子通知鏈（ Atomic notifier chains ）：通知鏈元素的回撥函式（當事件發生時要執行的函式）只能在中斷上下文中執行，不允許阻塞。對應的連結串列頭結構：

struct atomic_notifier_head 
{
    spinlock_t lock;
    struct notifier_block *head;
};

2.可阻塞通知鏈（ Blocking notifier chains ）：通知鏈元素的回撥函式在程式上下文中執行，允許阻塞。對應的連結串列頭：

struct blocking_notifier_head 
{
    struct rw_semaphore rwsem;
    struct notifier_block *head;
};

3.原始通知鏈（ Raw notifier chains ）：對通知鏈元素的回撥函式沒有任何限制，所有鎖和保護機制都由呼叫者維護。對應的連結串列頭：

struct raw_notifier_head 
{
    struct notifier_block *head;
};

4.SRCU 通知鏈（ SRCU notifier chains ）：可阻塞通知鏈的一種變體。對應的連結串列頭：

struct srcu_notifier_head 
{
    struct mutex mutex;
    struct srcu_struct srcu;
    struct notifier_block *head;
};

通知鏈的核心結構：

struct notifier_block 
{
    int (*notifier_call)(struct notifier_block *, unsigned long, void *);
    struct notifier_block *next;
    int priority;
};

其中notifier_call是通知鏈要執行的函式指標，next用來連線其它的通知結構，priority是這個通知的優先順序，同一條鏈上的notifier_block{}是按優先順序排列的。核心程式碼中一般把通知鏈命名為xxx_chain, xxx_nofitier_chain這種形式的變數名。

三、運作機制：

通知鏈的運作機制包括兩個角色：

1. 被通知者：對某一事件感興趣一方。定義了當事件發生時，相應的處理函式，即回撥函式。但需要事先將其註冊到通知鏈中（被通知者註冊的動作就是在通知鏈中增加一項）。
2. 通知者：事件的通知者。當檢測到某事件，或者本身產生事件時，通知所有對該事件感興趣的一方事件發生。他定義了一個通知鏈，其中儲存了每一個被通知者對事件的處理函式（回撥函式）。通知這個過程實際上就是遍歷通知鏈中的每一項，然後呼叫相應的事件處理函式。

包括以下過程：

1. 通知者定義通知鏈。
2. 被通知者向通知鏈中註冊回撥函式。
3. 當事件發生時，通知者發出通知（執行通知鏈中所有元素的回撥函式）。

被通知者呼叫 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;
}

登出回撥函式則使用 notifier_chain_unregister 函式，即將回撥函式從通知鏈中刪除：

static int notifier_chain_unregister(struct notifier_block **nl, struct notifier_block *n)
{
    while ((*nl) != NULL) 
    {
        if ((*nl) == n) 
        {
            rcu_assign_pointer(*nl, n->next);

            return 0;
        }

        nl = &((*nl)->next);
    }

    return -ENOENT;
}

通知者呼叫 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;
}

引數nl是通知鏈的頭部，val表示事件型別，v用來指向通知鏈上的函式執行時需要用到的引數，一般不同的通知鏈，引數型別也不一樣，例如當通知一個網路卡被註冊時，v就指向net_device結構，nr_to_call表示準備最多通知幾個，-1表示整條鏈都通知，nr_calls非空的話，返回通知了多少個。

每個被執行的notifier_block回撥函式的返回值可能取值為以下幾個：

1. NOTIFY_DONE：表示對相關的事件型別不關心。
2. NOTIFY_OK：順利執行。
3. NOTIFY_BAD：執行有錯。
4. NOTIFY_STOP：停止執行後面的回撥函式。
5. NOTIFY_STOP_MASK：停止執行的掩碼。

Notifier_call_chain()把最後一個被呼叫的回撥函式的返回值作為它的返回值。

四、舉例應用：

在這裡，寫了一個簡單的通知連結串列的程式碼。實際上，整個通知鏈的編寫也就兩個過程：

1. 首先是定義自己的通知鏈的頭節點，並將要執行的函式註冊到自己的通知鏈中。
2. 其次則是由另外的子系統來通知這個鏈，讓其上面註冊的函式執行。

這裡將第一個過程分成了兩步來寫，第一步是定義了頭節點和一些自定義的註冊函式（針對該頭節點的），第二步則是使用自定義的註冊函式註冊了一些通知鏈節點。分別在程式碼buildchain.c與regchain.c中。傳送通知資訊的程式碼為notify.c。

程式碼1 buildchain.c。它的作用是自定義一個通知連結串列test_chain，然後再自定義兩個函式分別向這個通知鏈中加入或刪除節點，最後再定義一個函式通知這個test_chain鏈：

#include <asm/uaccess.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/notifier.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/module.h>
MODULE_LICENSE("GPL");

/*
* 定義自己的通知鏈頭結點以及註冊和解除安裝通知鏈的外包函式
*/

/*
* RAW_NOTIFIER_HEAD是定義一個通知鏈的頭部結點，
* 通過這個頭部結點可以找到這個鏈中的其它所有的notifier_block
*/
static RAW_NOTIFIER_HEAD(test_chain);

/*
* 自定義的註冊函式，將notifier_block節點加到剛剛定義的test_chain這個連結串列中來
* raw_notifier_chain_register會呼叫notifier_chain_register
*/
int register_test_notifier(struct notifier_block *nb)
{
  return raw_notifier_chain_register(&test_chain, nb);
}
EXPORT_SYMBOL(register_test_notifier);

int unregister_test_notifier(struct notifier_block *nb)
{
  return raw_notifier_chain_unregister(&test_chain, nb);
}
EXPORT_SYMBOL(unregister_test_notifier);

/*
* 自定義的通知連結串列的函式，即通知test_chain指向的連結串列中的所有節點執行相應的函式
*/
int test_notifier_call_chain(unsigned long val, void *v)
{
  return raw_notifier_call_chain(&test_chain, val, v);
}
EXPORT_SYMBOL(test_notifier_call_chain);

/*
* init and exit 
*/
static int __init init_notifier(void)
{
  printk("init_notifier\n");
  return 0;
}

static void __exit exit_notifier(void)
{
    printk("exit_notifier\n");
}

module_init(init_notifier);
module_exit(exit_notifier);

程式碼2 regchain.c。該程式碼的作用是將test_notifier1 test_notifier2 test_notifier3這三個節點加到之前定義的test_chain這個通知連結串列上，同時每個節點都註冊了一個函式：

#include <asm/uaccess.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/notifier.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/module.h>
MODULE_LICENSE("GPL");

/*
* 註冊通知鏈
*/
extern int register_test_notifier(struct notifier_block*);
extern int unregister_test_notifier(struct notifier_block*);

static int test_event1(struct notifier_block *this, unsigned long event, void *ptr)
{
  printk("In Event 1: Event Number is %d\n", event);
  return 0; 
}

static int test_event2(struct notifier_block *this, unsigned long event, void *ptr)
{
  printk("In Event 2: Event Number is %d\n", event);
  return 0; 
}

static int test_event3(struct notifier_block *this, unsigned long event, void *ptr)
{
  printk("In Event 3: Event Number is %d\n", event);
  return 0; 
}

/*
* 事件1，該節點執行的函式為test_event1
*/
static struct notifier_block test_notifier1 =
{
    .notifier_call = test_event1,
};

/*
* 事件2，該節點執行的函式為test_event1
*/
static struct notifier_block test_notifier2 =
{
    .notifier_call = test_event2,
};

/*
* 事件3，該節點執行的函式為test_event1
*/
static struct notifier_block test_notifier3 =
{
    .notifier_call = test_event3,
};

/*
* 對這些事件進行註冊
*/
static int __init reg_notifier(void)
{
  int err;
  printk("Begin to register:\n");

  err = register_test_notifier(&test_notifier1);
  if (err)
  {
    printk("register test_notifier1 error\n");
    return -1; 
  }
  printk("register test_notifier1 completed\n");

  err = register_test_notifier(&test_notifier2);
  if (err)
  {
    printk("register test_notifier2 error\n");
    return -1; 
  }
  printk("register test_notifier2 completed\n");

  err = register_test_notifier(&test_notifier3);
  if (err)
  {
    printk("register test_notifier3 error\n");
    return -1; 
  }
  printk("register test_notifier3 completed\n");

  return err;
}

/*
* 解除安裝剛剛註冊了的通知鏈
*/
static void __exit unreg_notifier(void)
{
  printk("Begin to unregister\n");
  unregister_test_notifier(&test_notifier1);
  unregister_test_notifier(&test_notifier2);
  unregister_test_notifier(&test_notifier3);
  printk("Unregister finished\n");
}

module_init(reg_notifier);
module_exit(unreg_notifier);

程式碼3 notify.c。該程式碼的作用就是向test_chain通知鏈中傳送訊息，讓鏈中的函式執行：

#include <asm/uaccess.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/notifier.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/module.h>
MODULE_LICENSE("GPL");

extern int test_notifier_call_chain(unsigned long val, void *v);

/*
* 向通知鏈傳送訊息以觸發註冊了的函式
*/
static int __init call_notifier(void)
{
  int err;
  printk("Begin to notify:\n");

  /*
  * 呼叫自定義的函式，向test_chain鏈傳送訊息
  */
  printk("==============================\n");
  err = test_notifier_call_chain(1, NULL);
  printk("==============================\n");
  if (err)
          printk("notifier_call_chain error\n");
  return err;
}

static void __exit uncall_notifier(void)
{
    printk("End notify\n");
}

module_init(call_notifier);
module_exit(uncall_notifier);

Makefile檔案：

obj-m:=buildchain.o regchain.o notify.o
CURRENT_PATH := $(shell pwd)
LINUX_KERNEL := $(shell uname -r)
KERNELDIR := /usr/src/linux-headers-$(LINUX_KERNEL)

all:
make -C $(KERNELDIR) M=$(CURRENT_PATH) modules

clean:

make -C $(KERNELDIR) M=$(CURRENT_PATH) clean

執行（注意insmod要root許可權）：

make

insmod buildchain.ko
insmod regchain.ko
insmod notify.ko

這樣就可以看到通知鏈執行的效果了：

init_notifier
Begin to register:
register test_notifier1 completed
register test_notifier2 completed
register test_notifier3 completed
Begin to notify:
==============================
In Event 1: Event Number is 1
In Event 2: Event Number is 1
In Event 3: Event Number is 1