[[401919]]

本文轉載自微信公眾號「Linux內核那些事」，作者songsong001。轉載本文請聯系Linux內核那些事公眾號。

重要的數據結構

魯迅先生說過：程序 = 數據結構 + 算法

想想如果讓我們來設計 inotify 應該如何實現呢?下面來分析一下：

• 我們知道，inotify 是用來監控文件或目錄的變動事件，所以應該定義一個對象來存儲被監聽的文件或目錄列表和它們所發生的事件列表(在內核中定義了 inotify_device 對象來存儲被監聽的文件列表和事件列表)。
• 另外，當對被監聽的文件或目錄進行讀寫操作時會觸發相應的事件產生。所以，應該在讀寫操作相關的系統調用中嵌入產生事件的動作(在內核中由 inotify_dev_queue_event 函數產生事件)。

在介紹 inotify 的實現前，我們先來了解下其原理。inotify 的原理如下：

當用戶調用 read 或者 write 等系統調用對文件進行讀寫操作時，內核會把事件保存到 inotify_device 對象的事件隊列中，然后喚醒等待 inotify 事件的進程。正所謂一圖勝千言，所以我們通過下圖來描述此過程：

從上圖可知，當應用程序調用 read 函數讀取文件的內容時，最終會調用 inotify_dev_queue_event 函數來觸發事件，調用棧如下：

read() 
└→ sys_read() 
   └→ vfs_read() 
      └→ fsnotify_access() 
         └→ inotify_inode_queue_event() 
            └→ inotify_dev_queue_event() 

inotify_dev_queue_event 函數主要完成兩個工作：

• 創建一個表示事件的 inotify_kernel_event 對象，并且把其插入到 inotify_device 對象的 events 列表中。
• 喚醒正在等待 inotify 發生事件的進程，等待的進程放置在 inotify_device 對象的 wq 字段中。

上面主要涉及到兩個對象，inotify_device 和 inotify_kernel_event，我們先來介紹一下這兩個對象的作用。

• inotify_device：內核使用此對象來描述一個 inotify，是 inotify 的核心對象。
• intoify_kernel_event：內核使用此對象來描述一個事件。

我們來看看這兩個對象的定義。

1. inotify_device對象

內核使用 inotify_device 來管理 inotify 監聽的對象和發生的事件，其定義如下：

1struct inotify_device { 
2    wait_queue_head_t       wq; 
3    ... 
4    struct list_head        events; 
5    ... 
6    struct inotify_handle   *ih; 
7    unsigned int            event_count; 
8    unsigned int            max_events; 
9}; 

下面我們介紹一下各個字段的作用：

• wq：正在等待當前 inotify 發生事件的進程列表。
• events：保存由 inotify 監聽的文件或目錄所發生的事件。
• ih：內核用來存儲 inotify 監聽的文件或目錄，下面會介紹。
• event_count：inotify 監聽的文件或目錄所發生的事件數量。
• max_events：inotify 能夠保存最大的事件數量。

下圖描述了 inotify_device 對象中兩個比較重要的隊列(等待隊列 和 事件隊列)：

當事件隊列中有數據時，就可以通過調用 read 函數來讀取這些事件。

2. inotify_kernel_event對象

內核使用 inotify_kernel_event 對象來存儲一個事件，其定義如下：

struct inotify_kernel_event { 
   struct inotify_event    event; 
    struct list_head        list; 
    char                    *name; 
}; 

可以看出，inotify_kernel_event 對象只是對 inotify_event 對象進行擴展而已，而我們在《監聽風云 - inotify介紹》一文中已經介紹過 inotify_event 對象。

inotify_kernel_event 對象在 inotify_event 對象的基礎上增加了 list 字段和 name 字段：

• list：用于把所有由 inotify 監聽的文件或目錄所發生的事件連接起來，
• name：用于記錄發生事件的文件名或目錄名。

3. inotify_handle對象

在 inotify_device 對象中，有個類型為 inotify_handle 的字段 ih，這個字段主要用來存儲 inotify 監聽的文件或目錄。我們來看看 inotify_handle 對象的定義：

struct inotify_handle { 
    struct idr          idr; 
    ... 
    struct list_head    watches; 
    ... 
    const struct inotify_operations *in_ops; 
}; 

下面來介紹一下 inotify_handle 對象的各個字段作用：

• idr：ID生成器，用于生成被監聽對象(文件或目錄)的ID。
• watches：inotify 監聽的對象(文件或目錄)列表。
• in_ops：當事件發生時，被 inotify 回調的函數列表。

4. inotify_watch對象

內核使用 inotify_handle 來存儲被監聽的對象列表，那么被監聽對象是個什么東西呢?內核中使用 inotify_watch 對象來表示一個被監聽的對象。其定義如下：

struct inotify_watch { 
    struct list_head        h_list; 
    struct list_head        i_list; 
    ... 
    struct inotify_handle   *ih; 
    struct inode            *inode; 
    __s32                   wd; 
    __u32                   mask; 
}; 

下面介紹一下 inotify_watch 對象各個字段的作用：

• h_list：用于把屬于同一個 inotify 監聽的對象連接起來。
• i_list：由于同一個文件或目錄可以被多個 inotify 監聽，所以使用此字段來把所有監聽同一個文件的 inotify_handle 對象連接起來。
• ih：指向其所屬的 inotify_handle 對象。
• inode：由于在 Linux 內核中，每個文件或目錄都由一個 inode 對象來描述，這個字段就是指向被監聽的文件或目錄的 inode 對象。
• wd：被監聽對象的ID(或稱為描述符)。
• mask：被監聽的事件類型(在《監聽風云 - inotify介紹》一文中已經介紹)。

現在，我們通過下圖來描述一下 inotify_device、inotify_handle 和 inotify_watch 三者的關系：

inotify功能實現

上面我們把 inotify 功能涉及的所有數據結構都介紹了，有上面的基礎，現在我們可以開始分析 inotify 功能的實現了。

1. inotify_init 函數

在《監聽風云 - inotify介紹》一文中介紹過，要使用 inotify 功能，首先要調用 inotify_init 函數創建一個 inotify 的句柄，而 inotify_init 函數最終會調用內核函數 sys_inotify_init。我們來分析一下 sys_inotify_init 的實現：

long sys_inotify_init(void) 
{ 
    struct inotify_device *dev; 
    struct inotify_handle *ih; 
    struct user_struct *user; 
    struct file *filp; 
    int fd, ret; 
 
    // 1. 獲取一個沒用被占用的文件描述符 
    fd = get_unused_fd(); 
    ... 
    // 2. 獲取一個文件對象 
    filp = get_empty_filp(); 
    ... 
    // 3. 創建一個 inotify_device 對象 
    dev = kmalloc(sizeof(struct inotify_device), GFP_KERNEL); 
    ... 
    // 4. 創建一個 inotify_handle 對象 
    ih = inotify_init(&inotify_user_ops); 
    ... 
    // 5. 把 inotify_handle 對象與 inotify_device 對象進行綁定 
    dev->ih = ih; 
    // 6. 設置文件對象的操作函數列表為：inotify_fops 
    filp->f_op = &inotify_fops; 
    ... 
    // 7. 將 inotify_device 對象綁定到文件對象的 private_data 字段中 
    filp->private_data = dev; 
    ... 
    // 8. 把文件句柄與文件對象進行映射 
    fd_install(fd, filp); 
 
    return fd; 
} 

sys_inotify_init 函數主要完成以下幾個工作：

• 調用 get_unused_fd 函數從進程中獲取一個沒被使用的文件描述符(句柄)。
• 調用 get_empty_filp 獲取一個文件對象。
• 調用 kmalloc 函數申請一個 inotify_device 對象。
• 調用 inotify_init 函數創建并初始化一個 inotify_handle 對象。
• 把 inotify_handle 對象與 inotify_device 對象進行綁定。
• 設置文件對象的操作函數列表為：inotify_fops，主要提供 read 和 poll 等接口的實現。
• 將 inotify_device 對象綁定到文件對象的 private_data 字段中。
• 把文件描述符與文件對象進行映射。
• 返回文件描述符給應用層。

從上面的實現可以看出，sys_inotify_init 函數主要是創建 inotify_device 對象和 inotify_handle 對象，并且將它們與文件對象關聯起來。

另外需要注意的是，在 sys_inotify_init 函數中，還把文件對象的操作函數集設置為 inotify_fops，主要提供了 read 和 poll 等接口的實現，其定義如下：

static const struct file_operations inotify_fops = { 
    .poll           = inotify_poll, 
    .read           = inotify_read, 
    .release        = inotify_release, 
    ... 
}; 

所以，當調用 read 函數讀取 inotify 的句柄時，就會觸發調用 inotify_read 函數讀取 inotify 事件隊列中的事件。

2. inotify_add_watch 函數

當調用 inotify_init 函數創建好 inotify 句柄后，就可以通過調用 inotify_add_watch 函數向 inotify 句柄添加要監控的文件或目錄。inotify_add_watch 函數的實現如下：

long sys_inotify_add_watch(int fd, const char __user *path, u32 mask) 
{ 
    struct inode *inode; 
    struct inotify_device *dev; 
    struct nameidata nd; 
    struct file *filp; 
    int ret, fput_needed; 
    unsigned flags = 0; 
 
    // 通過文件句柄獲取文件對象 
    filp = fget_light(fd, &fput_needed); 
    ... 
    // 獲取文件或目錄對應的 inode 對象 
    ret = find_inode(path, &nd, flags); 
    ... 
    inode = nd.dentry->d_inode; 
    // 從文件對象的 private_data 字段獲取對應的 inotify_device 對象 
    dev = filp->private_data; 
    ... 
    // 創建一個新的 inotify_watch 對象 
    if (ret == -ENOENT) 
        ret = create_watch(dev, inode, mask); 
    ... 
    return ret; 
} 

sys_inotify_add_watch 函數主要完成以下幾個工作：

• 調用 fget_light 函數獲取 inotify 句柄對應的文件對象。
• 調用 find_inode 函數獲取 path 路徑對應的 inode 對象，也就是獲取要監聽的文件或目錄所對應的 inode 對象。
• 從 inotify 文件對象的 private_data 字段中，獲取對應的 inotify_device 對象。
• 調用 create_watch 函數創建一個新的 inotify_watch 對象，并且把這個 inotify_watch 對象添加到 inotify_handle 對象的 watches 列表和 inode 對象的 inotify_watches 列表中。

事件通知

到了 inotify 最關鍵的部分，就是 inotify 的事件是怎么產生的。

在本文的第一部分中介紹過，當用戶調用 read 系統調用讀取文件內容時，最終會調用 inotify_dev_queue_event 函數來產生一個事件，我們先來回顧一下 read 系統調用的調用棧：

read() 
└→ sys_read() 
   └→ vfs_read() 
      └→ fsnotify_access() 
         └→ inotify_inode_queue_event() 
            └→ inotify_dev_queue_event() 

下面我們來分析一下 inotify_dev_queue_event 函數的實現：

static void 
inotify_dev_queue_event(struct inotify_watch *w, u32 wd,   
    u32 mask, u32 cookie, const char *name, struct inode *ignored) 
{ 
    struct inotify_user_watch *watch; 
    struct inotify_device *dev; 
    struct inotify_kernel_event *kevent, *last; 
 
    watch = container_of(w, struct inotify_user_watch, wdata); 
   dev = watch->dev; 
   ... 
   // 1. 申請一個 inotify_kernel_event 事件對象 
   if (unlikely(dev->event_count == dev->max_events)) 
       kevent = kernel_event(-1, IN_Q_OVERFLOW, cookie, NULL); 
   else 
       kevent = kernel_event(wd, mask, cookie, name); 
   ... 
   // 2. 增加 inotify 事件隊列的計數器 
   dev->event_count++; 
   // 3. 增加 inotify 事件隊列所占用的內存大小 
   dev->queue_size += sizeof(struct inotify_event) + kevent->event.len; 
 
   // 4. 把事件對象添加到 inotify 的事件隊列中 
   list_add_tail(&kevent->list, &dev->events); 
 
   // 5. 喚醒正在等待讀取事件的進程 
   wake_up_interruptible(&dev->wq); 
   ... 

我們先來介紹一下 inotify_dev_queue_event 函數各個參數的意義：

• w：被監聽對象，用于描述被監聽的文件或目錄。
• wd：被監聽對象的ID。
• mask：發生的事件類型，可以參考《監聽風云 - inotify介紹》一文。
• cookie：比較少使用，忽略。
• name：發生事件的文件或目錄名稱。
• ignored：發生事件的文件或目錄的 inode 對象，在本函數中沒有使用。

inotify_dev_queue_event 函數主要完成以下幾個工作：

• 通過調用 kernel_event 函數申請一個 inotify_kernel_event 事件對象。
• 增加 inotify 事件隊列的計數器。
• 增加 inotify 事件隊列所占用的內存大小。
• 把第一步創建的事件對象添加到 inotify 的事件隊列中。
• 喚醒正在等待讀取事件的進程(因為已經有事件發生了)。

從上面的分析可以看出，inotify_dev_queue_event 函數只負責創建一個事件對象，并且添加到 inotify 的事件隊列中。但發生了什么事件是由哪個步驟指定的呢?

我們可以通過分析 read 系統調用的調用棧，會發現在 fsnotify_access 函數中指定了事件的類型，我們來看看 fsnotify_access 函數的實現：

static inline void fsnotify_access(struct dentry *dentry) 
{ 
    struct inode *inode = dentry->d_inode; 
    u32 mask = IN_ACCESS; // 指定事件類型為 IN_ACCESS 
 
    if (S_ISDIR(inode->i_mode)) 
        mask |= IN_ISDIR; // 如果是目錄, 增加 IN_ISDIR 標志 
    ... 
    // 創建事件 
    inotify_inode_queue_event(inode, mask, 0, NULL, NULL);  
} 

從上面的分析可知，當發生讀事件時，由 fsnotify_access 函數指定事件類型為 IN_ACCESS。在 include/linux/fsnotify.h 文件中還實現了其他事件的觸發函數，有興趣的可以自行查閱此文件 。

總結

inotify 的實現過程總結為以下兩點：

當用戶調用讀寫、創建或刪除文件的系統調用時，內核會注入相應的事件觸發函數來產生一個事件，并且添加到 inotify 的事件隊列中。

喚醒等待讀取事件的進程，當進程被喚醒后，就可以通過調用 read 函數來讀取 inotify 事件隊列中的事件。