Linux 檔案系統 API 概述¶

本節包含 API 級別的文件，主要來自原始碼本身。

Linux VFS¶

檔案系統型別¶

enum positive_aop_returns¶: 具有特定語義的 aop 返回程式碼

常量

AOP_WRITEPAGE_ACTIVATE: 通知呼叫者頁面寫回已完成，該頁面仍處於鎖定狀態，並且應被視為活動狀態。 VM 使用此提示將頁面返回到活動列表 - 在不久的將來它不會再次成為寫回的候選者。其他呼叫者必須小心，如果他們獲得此返回值，則解鎖頁面。由 writepage() 返回；
AOP_TRUNCATED_PAGE: 已傳遞鎖定頁面的 AOP 方法已將其解鎖，並且該頁面可能已被截斷。呼叫者應該備份到獲取一個新頁面並再次嘗試。 aop 將採取合理的預防措施，以防止發生死鎖。如果呼叫者持有頁面引用，則在重試之前應將其刪除。由 read_folio() 返回。

描述

address_space_operation 函式返回這些大的常量，以向呼叫者指示特殊的語義。這些常量遠大於頁面中的位元組數，以便允許函式返回給定頁面中操作的位元組數。

struct address_space¶: 可快取、可對映物件的內容。

定義:

struct address_space {
    struct inode            *host;
    struct xarray           i_pages;
    struct rw_semaphore     invalidate_lock;
    gfp_t gfp_mask;
    atomic_t i_mmap_writable;
#ifdef CONFIG_READ_ONLY_THP_FOR_FS;
    atomic_t nr_thps;
#endif;
    struct rb_root_cached   i_mmap;
    unsigned long           nrpages;
    pgoff_t writeback_index;
    const struct address_space_operations *a_ops;
    unsigned long           flags;
    errseq_t wb_err;
    spinlock_t i_private_lock;
    struct list_head        i_private_list;
    struct rw_semaphore     i_mmap_rwsem;
    void *                  i_private_data;
};

成員

host: 所有者，inode 或 block_device。
i_pages: 快取的頁面。
invalidate_lock: 在無效期間，保護頁面快取內容和檔案偏移量->磁碟塊對映之間的連貫性。它還用於阻止透過記憶體對映修改頁面快取內容。
gfp_mask: 用於分配頁面的記憶體分配標誌。
i_mmap_writable: VM_SHARED、VM_MAYWRITE 對映的數量。
nr_thps: 頁面快取中 THP 的數量（僅限非 shmem）。
i_mmap: 私有和共享對映的樹。
nrpages: 頁面條目的數量，由 i_pages 鎖保護。
writeback_index: 寫回從這裡開始。
a_ops: 方法。
flags: 錯誤位和標誌 (AS_*)。
wb_err: 最近發生的錯誤。
i_private_lock: 供 address_space 的所有者使用。
i_private_list: 供 address_space 的所有者使用。
i_mmap_rwsem: 保護 i_mmap 和 i_mmap_writable。
i_private_data: 供 address_space 的所有者使用。

struct file_ra_state¶: 跟蹤檔案的預讀狀態。

定義:

struct file_ra_state {
    pgoff_t start;
    unsigned int size;
    unsigned int async_size;
    unsigned int ra_pages;
    unsigned int mmap_miss;
    loff_t prev_pos;
};

成員

start: 最近一次預讀開始的位置。
size: 最近一次預讀中讀取的頁數。
async_size: 不需要立即使用，因此確實是“超前”的頁數。當訪問這些頁面的第一頁時，啟動下一次預讀。
ra_pages: 預讀請求的最大大小，從 bdi 複製。
mmap_miss: 頁面快取中有多少 mmap 訪問未命中。
prev_pos: 最近一次讀取請求中的最後一個位元組。

描述

當此結構傳遞給 ->readahead() 時，“最近”的預讀意味著當前的預讀。

struct file¶: 表示一個檔案

定義:

struct file {
    spinlock_t f_lock;
    fmode_t f_mode;
    const struct file_operations    *f_op;
    struct address_space            *f_mapping;
    void *private_data;
    struct inode                    *f_inode;
    unsigned int                    f_flags;
    unsigned int                    f_iocb_flags;
    const struct cred               *f_cred;
    struct fown_struct              *f_owner;
    struct path                     f_path;
    union {
        struct mutex            f_pos_lock;
        u64 f_pipe;
    };
    loff_t f_pos;
#ifdef CONFIG_SECURITY;
    void *f_security;
#endif;
    errseq_t f_wb_err;
    errseq_t f_sb_err;
#ifdef CONFIG_EPOLL;
    struct hlist_head               *f_ep;
#endif;
    union {
        struct callback_head    f_task_work;
        struct llist_node       f_llist;
        struct file_ra_state    f_ra;
        freeptr_t f_freeptr;
    };
    file_ref_t f_ref;
};

成員

f_lock: 保護 f_ep、f_flags。不能從 IRQ 上下文中獲取。
f_mode: 熱路徑中常用的 FMODE_* 標誌
f_op: 檔案操作
f_mapping: 可快取、可對映物件的內容。
private_data: 檔案系統或驅動程式特定的資料
f_inode: 快取的 inode
f_flags: 檔案標誌
f_iocb_flags: iocb 標誌
f_cred: 建立者/開啟者的隱藏憑據
f_owner: 檔案所有者
f_path: 檔案的路徑
{unnamed_union}: 匿名
f_pos_lock: 保護檔案位置的鎖
f_pipe: 特定於管道
f_pos: 檔案位置
f_security: 此檔案的 LSM 安全上下文
f_wb_err: 寫回錯誤
f_sb_err: 每個 sb 的寫回錯誤
f_ep: 此檔案的所有 epoll 鉤子的連結
{unnamed_union}: 匿名
f_task_work: 任務工作入口點
f_llist: 工作佇列入口點
f_ra: 檔案的預讀狀態
f_freeptr: SLAB_TYPESAFE_BY_RCU 檔案快取使用的指標（請勿觸控。）
f_ref: 引用計數

vfsuid_t i_uid_into_vfsuid(struct mnt_idmap *idmap, const struct inode *inode)¶: 根據 idmapping 對映 inode 的 i_uid

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
const struct inode *inode: 要對映的 inode

返回

根據 idmap 對映的 whe inode 的 i_uid。如果 inode 的 i_uid 沒有對映，則返回 INVALID_VFSUID。

bool i_uid_needs_update(struct mnt_idmap *idmap, const struct iattr *attr, const struct inode *inode)¶: 檢查 inode 的 i_uid 是否需要更新

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
const struct iattr *attr: inode 的新屬性
const struct inode *inode: 要更新的 inode

描述

如果檔案系統支援，請檢查是否需要更新 $inode 的 i_uid 欄位，並考慮 idmapped 掛載點。

返回

如果 inode 的 i_uid 欄位需要更新，則為 true；否則為 false。

void i_uid_update(struct mnt_idmap *idmap, const struct iattr *attr, struct inode *inode)¶: 更新 inode 的 i_uid 欄位

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
const struct iattr *attr: inode 的新屬性
struct inode *inode: 要更新的 inode

描述

安全地更新 inode 的 i_uid 欄位，將任何 idmapped 掛載點的 vfsuid 轉換為檔案系統 kuid。

vfsgid_t i_gid_into_vfsgid(struct mnt_idmap *idmap, const struct inode *inode)¶: 根據 idmapping 對映 inode 的 i_gid

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
const struct inode *inode: 要對映的 inode

返回

根據 idmap 對映的 inode 的 i_gid。如果 inode 的 i_gid 沒有對映，則返回 INVALID_VFSGID。

bool i_gid_needs_update(struct mnt_idmap *idmap, const struct iattr *attr, const struct inode *inode)¶: 檢查 inode 的 i_gid 是否需要更新

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
const struct iattr *attr: inode 的新屬性
const struct inode *inode: 要更新的 inode

描述

如果檔案系統支援，請檢查是否需要更新 $inode 的 i_gid 欄位，並考慮 idmapped 掛載點。

返回

如果 inode 的 i_gid 欄位需要更新，則為 true；否則為 false。

void i_gid_update(struct mnt_idmap *idmap, const struct iattr *attr, struct inode *inode)¶: 更新 inode 的 i_gid 欄位

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
const struct iattr *attr: inode 的新屬性
struct inode *inode: 要更新的 inode

描述

安全地更新 inode 的 i_gid 欄位，將任何 idmapped 掛載點的 vfsgid 轉換為檔案系統 kgid。

void inode_fsuid_set(struct inode *inode, struct mnt_idmap *idmap)¶: 使用呼叫者的 fsuid 初始化 inode 的 i_uid 欄位

引數

struct inode *inode: 要初始化的 inode
struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap

描述

初始化 inode 的 i_uid 欄位。如果透過 idmapped 掛載點找到/建立了 inode，則根據 idmap 對映呼叫者的 fsuid。

void inode_fsgid_set(struct inode *inode, struct mnt_idmap *idmap)¶: 使用呼叫者的 fsgid 初始化 inode 的 i_gid 欄位

引數

struct inode *inode: 要初始化的 inode
struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap

描述

初始化 inode 的 i_gid 欄位。如果透過 idmapped 掛載點找到/建立了 inode，則根據 idmap 對映呼叫者的 fsgid。

bool fsuidgid_has_mapping(struct super_block *sb, struct mnt_idmap *idmap)¶: 檢查是否映射了呼叫者的 fsuid/fsgid

引數

struct super_block *sb: 我們想要在其中進行對映的超級塊
struct mnt_idmap *idmap: 相關掛載點的 idmap

描述

檢查呼叫者的 fsuid 和 fsgid 在超級塊 sb 的 s_user_ns 中是否具有有效的對映。如果呼叫者位於 idmapped 掛載點，則首先根據 idmap 對映呼叫者的 fsuid 和 fsgid。

返回

如果映射了 fsuid 和 fsgid，則為 true；否則為 false。

struct timespec64 inode_set_ctime(struct inode *inode, time64_t sec, long nsec)¶: 在 inode 中設定 ctime

引數

struct inode *inode: 要在其中設定 ctime 的 inode
time64_t sec: 要設定的 tv_sec 值
long nsec: 要設定的 tv_nsec 值

描述

將 inode 中的 ctime 設定為 { sec, nsec }

int __sb_write_started(const struct super_block *sb, int level)¶: 檢查是否持有 sb 凍結級別

引數

const struct super_block *sb: 我們要寫入的 super
int level: 凍結級別

描述

> 0 - 持有 sb 凍結級別
0 - 未持有 sb 凍結級別
< 0 - !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN

bool sb_write_started(const struct super_block *sb)¶: 檢查是否持有 SB_FREEZE_WRITE

引數

const struct super_block *sb: 我們要寫入的 super

描述

在 !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN 的情況下可能是誤報。

bool sb_write_not_started(const struct super_block *sb)¶: 檢查是否未持有 SB_FREEZE_WRITE

引數

const struct super_block *sb: 我們要寫入的 super

描述

在 !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN 的情況下可能是誤報。

bool file_write_started(const struct file *file)¶: 檢查是否持有 SB_FREEZE_WRITE

引數

const struct file *file: 我們要寫入的檔案

描述

在 !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN 的情況下可能是誤報。在 !S_ISREG 的情況下可能是誤報，因為 file_start_write() 對 !S_ISREG 沒有影響。

bool file_write_not_started(const struct file *file)¶: 檢查是否未持有 SB_FREEZE_WRITE

引數

const struct file *file: 我們要寫入的檔案

描述

在 !CONFIG_LOCKDEP/LOCK_STATE_UNKNOWN 的情況下可能是誤報。在 !S_ISREG 的情況下可能是誤報，因為 file_start_write() 對 !S_ISREG 沒有影響。

void sb_end_write(struct super_block *sb)¶: 釋放對超級塊的寫訪問權

引數

struct super_block *sb: 我們寫入的超級塊

描述

減少檔案系統的寫入者數量。喚醒可能想要凍結檔案系統的等待者。

void sb_end_pagefault(struct super_block *sb)¶: 從頁面錯誤中釋放對超級塊的寫訪問權

引數

struct super_block *sb: 我們寫入的超級塊

描述

減少處理檔案系統寫入頁面錯誤的程序數量。喚醒可能想要凍結檔案系統的等待者。

void sb_end_intwrite(struct super_block *sb)¶: 為了檔案系統內部目的，釋放對超級塊的寫訪問權

引數

struct super_block *sb: 我們寫入的超級塊

描述

減少檔案系統內部寫入者數量。喚醒可能想要凍結檔案系統的等待者。

void sb_start_write(struct super_block *sb)¶: 獲取對超級塊的寫訪問權

引數

struct super_block *sb: 我們要寫入的 super

描述

當程序想要向檔案系統寫入資料或元資料（即，弄髒頁面或 inode）時，它應該將操作嵌入到 sb_start_write() - sb_end_write() 對中，以獲得針對檔案系統凍結的互斥。此函式增加寫入者數量，防止凍結。如果檔案系統已經凍結，該函式將等待直到檔案系統解凍。

由於凍結保護行為類似於鎖，因此使用者必須保持凍結保護和其他檔案系統鎖的順序。通常，凍結保護應該是最外層的鎖。特別是，我們有

sb_start_write: -> i_mutex（寫入路徑、截斷、目錄操作...） -> s_umount（freeze_super、thaw_super）

void sb_start_pagefault(struct super_block *sb)¶: 從頁面錯誤中獲取對超級塊的寫訪問權

引數

struct super_block *sb: 我們要寫入的 super

描述

當程序開始處理寫入頁面錯誤時，它應該將操作嵌入到 sb_start_pagefault() - sb_end_pagefault() 對中，以獲得針對檔案系統凍結的互斥。這是必需的，因為頁面錯誤將會弄髒頁面。此函式增加正在執行的頁面錯誤數量，防止凍結。如果檔案系統已經凍結，該函式將等待直到檔案系統解凍。

由於頁面錯誤凍結保護行為類似於鎖，因此使用者必須保持凍結保護和其他檔案系統鎖的順序。建議將 sb_start_pagefault() 放置在鎖定順序中靠近 mmap_lock 的位置。頁面錯誤處理程式碼暗示鎖定依賴關係

mmap_lock: -> sb_start_pagefault

void sb_start_intwrite(struct super_block *sb)¶: 為了檔案系統內部目的，獲取對超級塊的寫訪問權

引數

struct super_block *sb: 我們要寫入的 super

描述

這是防止檔案系統凍結的第三級保護。檔案系統可以自由使用它。唯一的要求是它必須低於 sb_start_pagefault。

例如，檔案系統可以在啟動事務時呼叫 sb_start_intwrite()，這在一定程度上簡化了檔案系統更改的內部源（內部檔案系統執行緒、在檔案關閉時丟棄預分配等）的凍結處理。

struct renamedata¶: 包含重新命名所需的所有資訊

定義:

struct renamedata {
    struct mnt_idmap *old_mnt_idmap;
    struct inode *old_dir;
    struct dentry *old_dentry;
    struct mnt_idmap *new_mnt_idmap;
    struct inode *new_dir;
    struct dentry *new_dentry;
    struct inode **delegated_inode;
    unsigned int flags;
};

成員

old_mnt_idmap: 找到 inode 的舊掛載的 idmap
old_dir: 源的父目錄
old_dentry: 源
new_mnt_idmap: 找到 inode 的新掛載的 idmap
new_dir: 目標的父目錄
new_dentry: 目標
delegated_inode: 返回需要中斷委託的 inode
flags: 重新命名標誌

enum freeze_holder¶: 凍結的持有者

常量

FREEZE_HOLDER_KERNEL: 核心想要凍結或解凍檔案系統
FREEZE_HOLDER_USERSPACE: 使用者空間想要凍結或解凍檔案系統
FREEZE_MAY_NEST: 是否允許巢狀凍結和解凍請求
FREEZE_EXCL: 只能由所有者撤消的凍結

描述

指示凍結或解凍請求的所有者是誰，以及凍結是否需要是獨佔的或可以巢狀。如果沒有 FREEZE_MAY_NEST，則不允許來自同一持有者的多個凍結和解凍請求。但是，允許同時持有單個 FREEZE_HOLDER_USERSPACE 和單個 FREEZE_HOLDER_KERNEL 凍結。某些檔案系統在線上修復或類似過程中依賴於此。

bool is_mgtime(const struct inode *inode)¶: 此 inode 是否使用多粒度時間戳

引數

const struct inode *inode: 要測試多粒度時間戳的 inode

描述

如果 inode 使用多粒度時間戳，則返回 true，否則返回 false。

bool is_idmapped_mnt(const struct vfsmount *mnt)¶: 檢查掛載是否已對映

引數

const struct vfsmount *mnt: 要檢查的掛載

描述

如果 mnt 附加了非 nop_mnt_idmap，則 mnt 已對映。

返回

如果掛載已對映，則為 true，否則為 false。

void file_start_write(struct file *file)¶: 獲取對常規檔案 IO 的超級塊的寫訪問權

引數

struct file *file: 我們要寫入的檔案

描述

這是 sb_start_write() 的變體，它在非常規檔案上是空操作。應與對 file_end_write() 的呼叫相匹配。

void file_end_write(struct file *file)¶: 釋放對常規檔案的超級塊的寫訪問權

引數

struct file *file: 我們寫入的檔案

描述

應與對 file_start_write() 的呼叫相匹配。

void kiocb_start_write(struct kiocb *iocb)¶: 獲取對非同步檔案 IO 的超級塊的寫訪問權

引數

struct kiocb *iocb: 我們想要提交寫入的 IO 上下文

描述

這是 sb_start_write() 的變體，用於非同步 IO 提交。應與對 kiocb_end_write() 的呼叫相匹配。

void kiocb_end_write(struct kiocb *iocb)¶: 在非同步檔案 IO 之後釋放對超級塊的寫訪問權

引數

struct kiocb *iocb: 我們提交寫入的 IO 上下文

描述

應與對 kiocb_start_write() 的呼叫相匹配。

bool is_dot_dotdot(const char *name, size_t len)¶: 僅當 name 是“.”或“..”時才返回 true

引數

const char *name: 要檢查的檔名
size_t len: 檔名的長度，以位元組為單位

void inode_dio_begin(struct inode *inode)¶: 發出直接 I/O 請求開始的訊號

引數

struct inode *inode: 直接 I/O 發生的 inode

描述

一旦我們完成了直接 I/O 請求的處理，就會呼叫此函式，並用於喚醒等待直接 I/O 靜止的呼叫者。

void inode_dio_end(struct inode *inode)¶: 發出直接 I/O 請求完成的訊號

引數

struct inode *inode: 直接 I/O 發生的 inode

描述

一旦我們完成了直接 I/O 請求的處理，就會呼叫此函式，並用於喚醒等待直接 I/O 靜止的呼叫者。

bool generic_ci_validate_strict_name(struct inode *dir, struct qstr *name)¶: 檢查給定的名稱是否適合目錄

引數

struct inode *dir: 將在其中建立新檔案的目錄的 inode
struct qstr *name: 新檔案的名稱

描述

此函式檢查建議的檔名對於父目錄是否有效。這意味著對於使用嚴格編碼標誌建立的檔案系統中區分大小寫摺疊的目錄，將僅接受有效的 UTF-8 檔名。這也意味著對於未啟用區分大小寫摺疊或未嚴格編碼的目錄，將接受任何名稱。

返回

True：如果檔名適合此目錄。如果給定的名稱不適合嚴格編碼目錄，但正在使用的目錄不嚴格，則可能為 true
False：如果檔名不適合此目錄。這僅在目錄區分大小寫摺疊且檔案系統對其編碼嚴格時才會發生。

目錄快取¶

void d_drop(struct dentry *dentry)¶: 丟棄一個 dentry

引數

struct dentry *dentry: 要丟棄的 dentry

描述

d_drop() 從父 dentry 雜湊中取消雜湊條目，以便透過 VFS 查詢不再找到它。請注意，這與刪除 dentry 不同 - d_delete 將嘗試儘可能將 dentry 標記為負數，從而給出成功的 _negative_ 查詢，而 d_drop 只會使快取查詢失敗。

d_drop() 主要用於想要因某種原因使 dentry 無效的元件（NFS 超時或 autofs 刪除）。

__d_drop 需要 dentry->d_lock

___d_drop 不會將 dentry 標記為“未雜湊”（dentry->d_hash.pprev 將是 LIST_POISON2，而不是 NULL）。

struct dentry *d_find_any_alias(struct inode *inode)¶: 查詢給定 inode 的任何別名

引數

struct inode *inode: 要查詢別名的 inode

描述

如果給定inode存在任何別名，則獲取並返回其中一個別名的引用。如果不存在別名，則返回 NULL。

struct dentry *d_find_alias(struct inode *inode)¶: 獲取inode的雜湊別名

引數

struct inode *inode: 有問題的inode

描述

如果inode有一個雜湊別名，或者是一個目錄並且有任何別名，則獲取對別名的引用並返回它。否則返回NULL。請注意，如果inode是一個目錄，則只能有一個別名，並且只有在它沒有子目錄、或者它是檔案系統的根目錄、或者目錄被重新命名且d_revalidate是第一個注意到此點的VFS操作時，它才可能是不雜湊的。

如果inode有一個IS_ROOT、DCACHE_DISCONNECTED別名，那麼優先選擇任何其他的雜湊別名而不是該別名。

void shrink_dcache_sb(struct super_block *sb)¶: 收縮超級塊的dcache

引數

struct super_block *sb: 超級塊

描述

收縮指定超級塊的dcache。這用於在解除安裝檔案系統之前釋放dcache。

int path_has_submounts(const struct path *parent)¶: 檢查當前名稱空間中的dentry上是否存在掛載點。

引數

const struct path *parent: 要檢查的路徑。

描述

如果父路徑或其子目錄包含當前名稱空間中的掛載點，則返回true。

void shrink_dcache_parent(struct dentry *parent)¶: 修剪dcache

引數

struct dentry *parent: 要修剪的條目的父dentry

描述

修剪dcache以刪除父dentry未使用的子條目。

void d_invalidate(struct dentry *dentry)¶: 分離子掛載點、修剪dcache並刪除

引數

struct dentry *dentry: 要失效的dentry（也就是分離、修剪和刪除）

struct dentry *d_alloc(struct dentry *parent, const struct qstr *name)¶: 分配一個dcache條目

引數

struct dentry * parent: 要分配的條目的父條目
const struct qstr *name: 名稱的qstr

描述

分配一個dentry。如果可用記憶體不足，則返回NULL。成功後，將返回dentry。傳入的名稱將被複制，並且在此呼叫後可以重複使用傳入的副本。

void d_instantiate(struct dentry *entry, struct inode *inode)¶: 填寫dentry的inode資訊

引數

struct dentry *entry: 要完成的dentry
struct inode * inode: 要附加到此dentry的inode

描述

填寫條目中的inode資訊。

這將使負dentry變成社會中有用的完全成員。

注意！這假定inode計數已由呼叫者遞增（或以其他方式設定），以指示它現在正被dcache使用。

struct dentry *d_obtain_alias(struct inode *inode)¶: 查詢或分配給定inode的DISCONNECTED dentry

引數

struct inode *inode: 要為其分配dentry的inode

描述

獲取用於NFS檔案控制代碼轉換或類似透過控制代碼操作開啟的inode的dentry。返回的dentry可能是匿名的，或者可能具有完整的名稱（如果inode已在快取中）。

當在目錄inode上呼叫時，我們必須確保inode只有一個dentry。如果找到dentry，則返回該dentry而不是分配新的dentry。

在成功返回時，inode的引用已轉移到dentry。如果發生錯誤，則釋放inode上的引用。為了更容易在匯出操作中使用，可以傳入NULL或IS_ERR的inode，並且錯誤將傳播到返回值，NULL inode替換為ERR_PTR(-ESTALE)。

struct dentry *d_obtain_root(struct inode *inode)¶: 查詢或分配給定inode的dentry

引數

struct inode *inode: 要為其分配dentry的inode

描述

獲取檔案系統根的IS_ROOT dentry。

我們必須確保目錄inode只有一個dentry。如果找到dentry，則返回該dentry而不是分配新的dentry。

在成功返回時，inode的引用已轉移到dentry。如果發生錯誤，則釋放inode上的引用。可以傳入NULL或IS_ERR的inode，並且錯誤將傳播到返回值，NULL inode替換為ERR_PTR(-ESTALE)。

struct dentry *d_add_ci(struct dentry *dentry, struct inode *inode, struct qstr *name)¶: 查詢或分配具有區分大小寫名稱的新dentry

引數

struct dentry *dentry: 傳遞給父條目的lookup函式的負dentry
struct inode *inode: 不區分大小寫查詢發現的inode
struct qstr *name: 要與返回的dentry關聯的區分大小寫的名稱

描述

這是為了避免用不區分大小寫的名稱填充dcache到同一個inode，只有實際正確的區分大小寫的名稱儲存在不區分大小寫的檔案系統的dcache中。

對於不區分大小寫的查詢匹配，並且如果區分大小寫的dentry已存在於dcache中，則使用它並返回它。

如果不存在具有區分大小寫的名稱的條目，則分配具有區分大小寫的名稱的新dentry，並返回拼接的條目。

bool d_same_name(const struct dentry *dentry, const struct dentry *parent, const struct qstr *name)¶: 將dentry名稱與區分大小寫的名稱進行比較

引數

const struct dentry *dentry: 傳遞給父條目的lookup函式的負dentry
const struct dentry *parent: 父dentry
const struct qstr *name: 要與返回的dentry關聯的區分大小寫的名稱

返回

如果名稱相同，則為true，否則為false

struct dentry *d_lookup(const struct dentry *parent, const struct qstr *name)¶: 搜尋dentry

引數

const struct dentry *parent: 父dentry
const struct qstr *name: 我們希望找到的名稱的qstr

返回

dentry或NULL

描述

d_lookup搜尋父dentry的子條目以查詢有問題的名稱。如果找到dentry，則其引用計數將遞增並返回dentry。呼叫者必須使用dput在完成使用後釋放該條目。如果dentry不存在，則返回NULL。

void d_delete(struct dentry *dentry)¶: 刪除dentry

引數

struct dentry * dentry: 要刪除的dentry

描述

如果可能，將dentry轉換為負dentry，否則將其從雜湊佇列中刪除，以便以後可以刪除它

void d_rehash(struct dentry *entry)¶: 將條目添加回雜湊

引數

struct dentry * entry: 要新增到雜湊的dentry

描述

根據dentry的名稱將其新增到雜湊。

void d_add(struct dentry *entry, struct inode *inode)¶: 將dentry新增到雜湊佇列

引數

struct dentry *entry: 要新增的dentry
struct inode *inode: 要附加到此dentry的inode

描述

這會將條目新增到雜湊佇列並初始化 inode。該條目實際上是在之前的d_alloc()期間填充的。

struct dentry *d_splice_alias(struct inode *inode, struct dentry *dentry)¶: 如果存在斷開連線的dentry，則將其拼接到樹中

引數

struct inode *inode: 可能具有斷開連線的dentry的inode
struct dentry *dentry: 我們希望指向inode的負dentry。

描述

如果inode是一個目錄並且具有IS_ROOT別名，則d_move它以代替給定的dentry並返回它，否則只需將inode d_add到dentry並返回NULL。

如果找到非IS_ROOT目錄，則檔案系統已損壞，我們應該報錯：目錄不能有多個別名。

任何可匯出的檔案系統（透過knfsd）的查詢例程中都需要此功能，以便我們可以有效地構建到目錄的dcache路徑。

如果找到並移動了dentry，則返回它。否則返回NULL。這與->lookup的預期返回值匹配。

叢集檔案系統可以使用已雜湊的負dentry呼叫此函式。在這種情況下，我們知道inode將是一個常規檔案，並且這隻會發生在atomic_open期間。因此，我們只需要在最後一種情況下檢查dentry是否已經雜湊。

bool is_subdir(struct dentry *new_dentry, struct dentry *old_dentry)¶: new_dentry是否是old_dentry的子目錄

引數

struct dentry *new_dentry: 新的dentry
struct dentry *old_dentry: 舊的dentry

描述

如果new_dentry是父條目的子目錄（在任何深度），則返回true。否則返回false。呼叫者必須確保在呼叫is_subdir()之前固定“new_dentry”

struct dentry *dget_dlock(struct dentry *dentry)¶: 獲取dentry的引用

引數

struct dentry *dentry: 要獲取引用的dentry

描述

給定一個活動的dentry，遞增引用計數並返回dentry。呼叫者必須持有 dentry->d_lock。確保dentry處於活動狀態是呼叫者的責任。有很多條件足以保證這一點；例如，任何具有非負引用計數的條目都是活動的，任何雜湊的條目、任何正條目、任何條目的父條目等等。

struct dentry *dget(struct dentry *dentry)¶: 獲取dentry的引用

引數

struct dentry *dentry: 要獲取引用的dentry

描述

給定一個dentry或NULL指標，如果合適，則遞增引用計數並返回dentry。當dentry具有引用時，不會銷燬dentry。相反，沒有引用的dentry可能會因多種原因而消失，從記憶體壓力開始。換句話說，該原語用於克隆現有引用；在引用計數為零的物件上使用它是bug。

注意

如果持有 dentry->d_lock，它將旋轉。從避免死鎖的角度來看，它等同於spin_lock()/遞增引用計數/spin_unlock()，因此在 dentry->d_lock下呼叫它始終是bug；在它的任何子條目上在->d_lock下呼叫它也是如此。

int d_unhashed(const struct dentry *dentry)¶: dentry 是否已雜湊

引數

const struct dentry *dentry: 要檢查的條目

描述

如果傳遞的 dentry 當前未雜湊，則返回 true。

bool d_really_is_negative(const struct dentry *dentry)¶: 確定 dentry 是否真的為負（忽略 fallthrough）

引數

const struct dentry *dentry: 有問題的 dentry

描述

如果 dentry 表示一個不存在的名稱或一個不對映到 inode 的名稱（即 ->d_inode 為 NULL），則返回 true。dentry 可以表示一個真正的未命中，一個不由 0,0 chardev 表示的 whiteout，或者一個不透明目錄中的 fallthrough 標記。

注意！（1）這應該僅由檔案系統使用來檢查它自己的 dentry。不應該用於檢視其他檔案系統的 dentry。（2）它也應該與 d_inode() 結合使用來獲取 inode。（3）dentry 可能有一些東西附加到 ->d_lower，並且標誌的型別欄位可能被設定為除 miss 或 whiteout 之外的其他東西。

bool d_really_is_positive(const struct dentry *dentry)¶: 確定 dentry 是否真的為正（忽略 fallthrough）

引數

const struct dentry *dentry: 有問題的 dentry

描述

如果 dentry 表示一個對映到 inode 的名稱（即 ->d_inode 不為 NULL），則返回 true。如果 whiteout 在介質上表示為 0,0 chardev，則 dentry 仍然可能表示一個 whiteout。

注意！（1）這應該僅由檔案系統使用來檢查它自己的 dentry。不應該用於檢視其他檔案系統的 dentry。（2）它也應該與 d_inode() 結合使用來獲取 inode。

struct inode *d_inode(const struct dentry *dentry)¶: 獲取此 dentry 的實際 inode

引數

const struct dentry *dentry: 要查詢的 dentry

描述

這是普通檔案系統應該用來獲取它們自己的 inode 在它們自己的 dentry 中的助手函式，並忽略疊加在它們之上的分層。

struct inode *d_inode_rcu(const struct dentry *dentry)¶: 使用 READ_ONCE() 獲取此 dentry 的實際 inode

引數

const struct dentry *dentry: 要查詢的 dentry

描述

這是普通檔案系統應該用來獲取它們自己的 inode 在它們自己的 dentry 中的助手函式，並忽略疊加在它們之上的分層。

struct inode *d_backing_inode(const struct dentry *upper)¶: 獲取我們應該使用的上層或下層 inode

引數

const struct dentry *upper: 上層

描述

這是應該用來獲取 inode 的助手函式，如果這個 dentry 要作為檔案開啟，將會使用該 inode。inode 可能在上層 dentry 上，也可能在由上層固定的下層 dentry 上。

普通檔案系統不應該使用它來訪問它們自己的 inode。

struct dentry *d_real(struct dentry *dentry, enum d_real_type type)¶: 返回真實的 dentry

引數

struct dentry *dentry: 要查詢的 dentry
enum d_real_type type: 真實 dentry 的型別（資料或元資料）

描述

如果 dentry 在 union/overlay 上，則返回底層的真實 dentry。否則返回 dentry 本身。

另請參閱：Linux 虛擬檔案系統概述

struct inode *d_real_inode(const struct dentry *dentry)¶: 返回託管資料的真實 inode

引數

const struct dentry *dentry: 要查詢的 dentry

描述

如果 dentry 在 union/overlay 上，則返回底層的真實 inode。否則返回 d_inode()。

Inode 處理¶

int inode_init_always_gfp(struct super_block *sb, struct inode *inode, gfp_t gfp)¶: 執行 inode 結構初始化

引數

struct super_block *sb: inode 所屬的超級塊
struct inode *inode: 要初始化的 inode
gfp_t gfp: 分配標誌

描述

這些是在每次 inode 分配時都需要完成的初始化，因為這些欄位沒有被 slab 分配初始化。如果需要額外的分配，則使用 gfp。

void drop_nlink(struct inode *inode)¶: 直接減少 inode 的連結計數

引數

struct inode *inode: inode

描述

這是一個低階檔案系統助手，用於替換任何對 i_nlink 的直接檔案系統操作。在我們嘗試跟蹤對檔案系統的寫入的情況下，減為零意味著當檔案被截斷並在檔案系統上實際取消連結時，即將進行寫入。

void clear_nlink(struct inode *inode)¶: 直接將 inode 的連結計數清零

引數

struct inode *inode: inode

描述

這是一個低階檔案系統助手，用於替換任何對 i_nlink 的直接檔案系統操作。有關我們為什麼關心 i_nlink 達到零的資訊，請參閱 drop_nlink()。

void set_nlink(struct inode *inode, unsigned int nlink)¶: 直接設定 inode 的連結計數

引數

struct inode *inode: inode
unsigned int nlink: 新的 nlink（應為非零）

描述

這是一個低階檔案系統助手，用於替換任何對 i_nlink 的直接檔案系統操作。

void inc_nlink(struct inode *inode)¶: 直接遞增 inode 的連結計數

引數

struct inode *inode: inode

描述

這是一個低階檔案系統助手，用於替換任何對 i_nlink 的直接檔案系統操作。目前，它只是為了與 dec_nlink() 保持一致。

void inode_sb_list_add(struct inode *inode)¶: 將 inode 新增到 inode 的超級塊列表

引數

struct inode *inode: 要新增的 inode

void __insert_inode_hash(struct inode *inode, unsigned long hashval)¶: 雜湊一個 inode

引數

struct inode *inode

未雜湊的 inode

unsigned long hashval

用於在 inode_hashtable 中定位此物件的 unsigned long 值。

將 inode 新增到此超級塊的 inode 雜湊中。

void __remove_inode_hash(struct inode *inode)¶: 從雜湊中刪除一個 inode

引數

struct inode *inode

要取消雜湊的 inode

從超級塊中刪除一個 inode。

void evict_inodes(struct super_block *sb)¶: 逐出超級塊的所有可逐出的 inode

引數

struct super_block *sb: 要操作的超級塊

描述

確保不保留任何具有零引用計數的 inode。這在移除 SB_ACTIVE 標誌後由超級塊關閉呼叫，因此在此呼叫期間或之後達到零引用計數的任何 inode 將立即被逐出。

struct inode *new_inode(struct super_block *sb)¶: 獲取一個 inode

引數

struct super_block *sb

超級塊

為給定的超級塊分配一個新的 inode。與 inode->i_mapping 相關的分配的預設 gfp_mask 是 GFP_HIGHUSER_MOVABLE。如果 HIGHMEM 頁面不合適，或者已知為頁面快取分配的頁面不可回收或不可遷移，則必須使用新建立的 inode 對映上的適當標誌呼叫 mapping_set_gfp_mask()

void unlock_new_inode(struct inode *inode)¶: 清除 I_NEW 狀態並喚醒任何等待者

引數

struct inode *inode: 要解鎖的新 inode

描述

當 inode 完全初始化時呼叫，以清除 inode 的新狀態並喚醒任何等待 inode 完成初始化的人。

void lock_two_nondirectories(struct inode *inode1, struct inode *inode2)¶: 在非目錄物件上獲取兩個 i_mutex

引數

struct inode *inode1: 要鎖定的第一個 inode
struct inode *inode2: 要鎖定的第二個 inode

描述

鎖定任何非 NULL 引數。傳遞的物件不能是目錄。此函式可以鎖定零個、一個或兩個物件。

void unlock_two_nondirectories(struct inode *inode1, struct inode *inode2)¶: 從 lock_two_nondirectories() 釋放鎖

引數

struct inode *inode1: 要解鎖的第一個 inode
struct inode *inode2: 要解鎖的第二個 inode

struct inode *inode_insert5(struct inode *inode, unsigned long hashval, int (*test)(struct inode*, void*), int (*set)(struct inode*, void*), void *data)¶: 從已掛載的檔案系統獲取一個 inode

引數

struct inode *inode: 用於插入到快取的預分配 inode
unsigned long hashval: 要獲取的雜湊值（通常是 inode 編號）
int (*test)(struct inode *, void *): 用於比較 inode 之間的回撥
int (*set)(struct inode *, void *): 用於初始化新 struct inode 的回撥函式
void *data: 傳遞給 test 和 set 的不透明資料指標

描述

在 inode 快取中搜索由 hashval 和 data 指定的 inode，如果存在，則返回它並增加引用計數。這是 iget5_locked() 的一個變體，它不分配 inode。

如果 inode 不在快取中，則插入預先分配的 inode 並返回它，此時它是被鎖定的、已雜湊的，並且設定了 I_NEW 標誌。檔案系統可以在透過 unlock_new_inode() 解鎖它之前填充它。

請注意，test 和 set 都是在持有 inode_hash_lock 的情況下呼叫的，因此它們無法睡眠。

struct inode *iget5_locked(struct super_block *sb, unsigned long hashval, int (*test)(struct inode*, void*), int (*set)(struct inode*, void*), void *data)¶: 從已掛載的檔案系統獲取一個 inode

引數

struct super_block *sb: 檔案系統的超級塊
unsigned long hashval: 要獲取的雜湊值（通常是 inode 編號）
int (*test)(struct inode *, void *): 用於比較 inode 之間的回撥
int (*set)(struct inode *, void *): 用於初始化新 struct inode 的回撥函式
void *data: 傳遞給 test 和 set 的不透明資料指標

描述

在 inode 快取中搜索由 hashval 和 data 指定的 inode，如果存在，則返回它並增加引用計數。這是 iget_locked() 的一個通用版本，用於 inode 編號不足以唯一標識 inode 的檔案系統。

如果 inode 不在快取中，則分配並插入一個新的 inode 並返回它，此時它是被鎖定的、已雜湊的，並且設定了 I_NEW 標誌。檔案系統可以在透過 unlock_new_inode() 解鎖它之前填充它。

請注意，test 和 set 都是在持有 inode_hash_lock 的情況下呼叫的，因此它們無法睡眠。

struct inode *iget5_locked_rcu(struct super_block *sb, unsigned long hashval, int (*test)(struct inode*, void*), int (*set)(struct inode*, void*), void *data)¶: 從已掛載的檔案系統獲取一個 inode

引數

struct super_block *sb: 檔案系統的超級塊
unsigned long hashval: 要獲取的雜湊值（通常是 inode 編號）
int (*test)(struct inode *, void *): 用於比較 inode 之間的回撥
int (*set)(struct inode *, void *): 用於初始化新 struct inode 的回撥函式
void *data: 傳遞給 test 和 set 的不透明資料指標

描述

這等效於 iget5_locked，但 test 回撥必須容忍 inode 不穩定，包括正在拆卸過程中。

struct inode *iget_locked(struct super_block *sb, unsigned long ino)¶: 從已掛載的檔案系統獲取一個 inode

引數

struct super_block *sb: 檔案系統的超級塊
unsigned long ino: 要獲取的 inode 編號

描述

在 inode 快取中搜索由 ino 指定的 inode，如果存在，則返回它並增加引用計數。這適用於 inode 編號足以唯一標識 inode 的檔案系統。

如果 inode 不在快取中，則分配一個新的 inode 並返回它，此時它是被鎖定的、已雜湊的，並且設定了 I_NEW 標誌。檔案系統可以在透過 unlock_new_inode() 解鎖它之前填充它。

ino_t iunique(struct super_block *sb, ino_t max_reserved)¶: 獲取唯一的 inode 編號

引數

struct super_block *sb

超級塊

ino_t max_reserved

最高保留的 inode 編號

獲取對於給定的超級塊在系統上唯一的 inode 編號。這適用於沒有自然永久 inode 編號系統的檔案系統。返回的 inode 編號高於保留限制但唯一。

錯誤：如果檔案系統上有大量 inode，則此函式目前會變得非常慢。

struct inode *ilookup5_nowait(struct super_block *sb, unsigned long hashval, int (*test)(struct inode*, void*), void *data)¶: 在 inode 快取中搜索 inode

引數

struct super_block *sb: 要搜尋的檔案系統的超級塊
unsigned long hashval: 要搜尋的雜湊值（通常是 inode 編號）
int (*test)(struct inode *, void *): 用於比較 inode 之間的回撥
void *data: 傳遞給 test 的不透明資料指標

描述

在 inode 快取中搜索由 hashval 和 data 指定的 inode。如果 inode 在快取中，則返回該 inode 並增加引用計數。

注意2：test 是在持有 inode_hash_lock 的情況下呼叫的，因此無法睡眠。

注意

I_NEW 不會被等待，因此您必須非常小心如何處理返回的 inode。您可能應該使用 ilookup5() 來代替。

struct inode *ilookup5(struct super_block *sb, unsigned long hashval, int (*test)(struct inode*, void*), void *data)¶: 在 inode 快取中搜索 inode

引數

struct super_block *sb: 要搜尋的檔案系統的超級塊
unsigned long hashval: 要搜尋的雜湊值（通常是 inode 編號）
int (*test)(struct inode *, void *): 用於比較 inode 之間的回撥
void *data: 傳遞給 test 的不透明資料指標

描述

在 inode 快取中搜索由 hashval 和 data 指定的 inode，如果 inode 在快取中，則返回該 inode 並增加引用計數。在返回 inode 之前等待 I_NEW。返回的 inode 增加引用計數。

這是 ilookup() 的一個通用版本，用於 inode 編號不足以唯一標識 inode 的檔案系統。

注意

test 是在持有 inode_hash_lock 的情況下呼叫的，因此無法睡眠。

struct inode *ilookup(struct super_block *sb, unsigned long ino)¶: 在 inode 快取中搜索 inode

引數

struct super_block *sb: 要搜尋的檔案系統的超級塊
unsigned long ino: 要搜尋的 inode 編號

描述

在 inode 快取中搜索 inode ino，如果 inode 在快取中，則返回該 inode 並增加引用計數。

struct inode *find_inode_nowait(struct super_block *sb, unsigned long hashval, int (*match)(struct inode*, unsigned long, void*), void *data)¶: 在 inode 快取中查詢 inode

引數

struct super_block *sb: 要搜尋的檔案系統的超級塊
unsigned long hashval: 要搜尋的雜湊值（通常是 inode 編號）
int (*match)(struct inode *, unsigned long, void *): 用於比較 inode 之間的回撥
void *data: 傳遞給 match 的不透明資料指標

描述

在 inode 快取中搜索由 hashval 和 data 指定的 inode，其中輔助函式 match 將在 inode 不匹配時返回 0，在 inode 匹配時返回 1，在應停止搜尋時返回 -1。 match 函式必須負責獲取 i_lock 自旋鎖並檢查 i_state 以查詢正在釋放或正在初始化的 inode，並在返回 1 之前增加引用計數。它也不能睡眠，因為它是在持有 inode_hash_lock 自旋鎖的情況下呼叫的。

這是 ilookup5() 的更通用版本，當該函式絕不能阻塞時 --- find_inode() 可以在 __wait_on_freeing_inode() 中阻塞 --- 或者當呼叫者無法增加引用計數時，因為生成的 iput() 可能會導致 inode 逐出。權衡之處在於，match 函式必須非常小心地實現。

struct inode *find_inode_rcu(struct super_block *sb, unsigned long hashval, int (*test)(struct inode*, void*), void *data)¶: 在 inode 快取中查詢 inode

引數

struct super_block *sb: 要搜尋的檔案系統的超級塊
unsigned long hashval: 要雜湊的鍵
int (*test)(struct inode *, void *): 用於測試 inode 上的匹配項的函式
void *data: 測試函式的資料

描述

在 inode 快取中搜索由 hashval 和 data 指定的 inode，其中輔助函式 test 將在 inode 不匹配時返回 0，匹配時返回 1。 test 函式必須負責獲取 i_lock 自旋鎖並檢查 i_state 以查詢正在釋放或正在初始化的 inode。

如果成功，這將返回 test 函式返回 1 的 inode，否則返回 NULL。

不允許 test 函式獲取呈現的任何 inode 的引用。也不允許睡眠。

呼叫者必須持有 RCU 讀鎖。

struct inode *find_inode_by_ino_rcu(struct super_block *sb, unsigned long ino)¶: 在 inode 快取中查詢 inode

引數

struct super_block *sb: 要搜尋的檔案系統的超級塊
unsigned long ino: 要匹配的 inode 編號

描述

在 inode 快取中搜索由 hashval 和 data 指定的 inode，其中輔助函式 test 將在 inode 不匹配時返回 0，匹配時返回 1。 test 函式必須負責獲取 i_lock 自旋鎖並檢查 i_state 以查詢正在釋放或正在初始化的 inode。

如果成功，這將返回 test 函式返回 1 的 inode，否則返回 NULL。

不允許 test 函式獲取呈現的任何 inode 的引用。也不允許睡眠。

呼叫者必須持有 RCU 讀鎖。

void iput(struct inode *inode)¶: 釋放 inode

引數

struct inode *inode

要釋放的 inode

釋放一個 inode，刪除其使用計數。如果 inode 使用計數達到零，則釋放該 inode，也可能被銷燬。

因此，iput() 可以睡眠。

int bmap(struct inode *inode, sector_t *block)¶: 在檔案中查詢塊編號

引數

struct inode *inode

擁有所請求的塊編號的 inode

sector_t *block

包含要查詢的塊的指標

將 *block 中的值替換為裝置上儲存與檔案中所請求的塊編號相對應的塊的塊編號。也就是說，要求 inode 1 的塊 4，該函式將 *block 中的 4 替換為相對於磁碟開始處，儲存該檔案的塊的磁碟塊。

如果發生錯誤，則返回 -EINVAL，否則返回 0。如果對映落入一個空洞，則返回 0，並且 *block 也設定為 0。

int inode_update_timestamps(struct inode *inode, int flags)¶: 更新 inode 上的時間戳

引數

struct inode *inode: 要更新的 inode
int flags: 需要更新的 S_* 標誌

描述

當需要為讀取或寫入操作更新 inode 的時間戳時，呼叫 update_time 函式。此函式處理更新實際時間戳。由呼叫者負責確保 inode 已被適當標記為髒。

在任何 S_MTIME、S_CTIME 或 S_VERSION 需要更新的情況下，嘗試更新所有三個時間戳。 S_ATIME 更新可以獨立於其餘更新處理。

返回一組指示哪些值已更改的 S_* 標誌。

int generic_update_time(struct inode *inode, int flags)¶: 更新 inode 上的時間戳

引數

struct inode *inode: 要更新的 inode
int flags: 需要更新的 S_* 標誌

描述

當需要為讀取或寫入操作更新 inode 的時間戳時，將呼叫 update_time 函式。如果需要更新 S_MTIME、S_CTIME 或 S_VERSION 中的任何一個，我們將嘗試更新所有這三個。 S_ATIME 的更新可以獨立於其餘部分進行處理。

返回一個 S_* 掩碼，指示哪些欄位已更新。

int file_remove_privs(struct file *file)¶: 移除特殊檔案許可權 (suid, capabilities)

引數

struct file *file: 要移除許可權的檔案

描述

當檔案被寫入或截斷修改時，確保移除特殊檔案許可權。

返回

成功時返回 0，失敗時返回負的 errno。

struct timespec64 current_time(struct inode *inode)¶: 返回 FS 時間（可能為細粒度）

引數

struct inode *inode: inode。

描述

返回截斷到檔案系統支援的時間粒度的當前時間，適用於 ctime/mtime 更改。如果 ctime 被標記為已 QUERIED，則獲取細粒度的時間戳，但不要更新 floor。

對於 multigrain inode，這實際上是檔案將收到的時間戳的估計值。實際的更新必須透過 inode_set_ctime_current()。

int file_update_time(struct file *file)¶: 更新 mtime 和 ctime 時間

引數

struct file *file: 訪問的檔案

描述

更新 inode 的 mtime 和 ctime 成員，並將 inode 標記為寫回。請注意，此函式專門用於檔案系統的檔案寫入路徑，並且檔案系統可以選擇使用 _NOCMTIME inode 標誌顯式忽略透過此函式進行的更新，例如，對於網路檔案系統，這些時間戳由伺服器處理。對於需要分配空間才能更新 inode 的檔案系統，這可能會返回錯誤。

返回

成功時返回 0，失敗時返回負的 errno。

int file_modified(struct file *file)¶: 處理修改檔案時強制執行的 vfs 更改

引數

struct file *file: 已修改的檔案

描述

當檔案被修改時，確保移除特殊檔案許可權並更新時間設定。

上下文

呼叫者必須持有檔案的 inode 鎖。

返回

成功時返回 0，失敗時返回負的 errno。

int kiocb_modified(struct kiocb *iocb)¶: 處理修改檔案時強制執行的 vfs 更改

引數

struct kiocb *iocb: 已修改的 iocb

描述

當檔案被修改時，確保移除特殊檔案許可權並更新時間設定。

上下文

呼叫者必須持有檔案的 inode 鎖。

返回

成功時返回 0，失敗時返回負的 errno。

void inode_init_owner(struct mnt_idmap *idmap, struct inode *inode, const struct inode *dir, umode_t mode)¶: 根據 posix 標準初始化新 inode 的 uid、gid、mode

引數

struct mnt_idmap *idmap: 建立 inode 的掛載的 idmap
struct inode *inode: 新的 inode
const struct inode *dir: 目錄 inode
umode_t mode: 新 inode 的模式

描述

如果 inode 是透過 idmapped 掛載建立的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權並初始化 i_uid 和 i_gid。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

bool inode_owner_or_capable(struct mnt_idmap *idmap, const struct inode *inode)¶: 檢查當前任務對 inode 的許可權

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
const struct inode *inode: 正在檢查的 inode

描述

如果當前使用者在具有對映的 inode 所有者 uid 的名稱空間中具有 CAP_FOWNER，或者擁有該檔案，則返回 true。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

void inode_dio_wait(struct inode *inode)¶: 等待未完成的 DIO 請求完成

引數

struct inode *inode: 要等待的 inode

描述

等待所有掛起的直接 I/O 請求完成，以便我們可以繼續進行截斷或等效操作。

必須在序列化獲取對 i_dio_count 的新引用的鎖下呼叫，通常透過 inode->i_mutex。

struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode)¶: 將 timespec 截斷為粒度

引數

struct timespec64 t: Timespec
struct inode *inode: 正在更新的 inode

描述

將 timespec 截斷為包含 inode 的檔案系統支援的粒度。始終向下舍入。 gran 不得為 0，也不得大於 1 秒（NSEC_PER_SEC 或 10^9 納秒）。

struct timespec64 inode_set_ctime_current(struct inode *inode)¶: 將 ctime 設定為 current_time

引數

struct inode *inode: inode

描述

將 inode 的 ctime 設定為 inode 的當前值。返回已分配的當前值。如果這不是 multigrain inode，則我們將其設定為粗略時間和 floor 值的較晚者。

如果是 multigrain，則我們首先檢視粗粒度時間戳是否與已有的時間戳不同。如果是，則使用它。否則，獲取細粒度時間戳。

之後，嘗試將新值交換到 i_ctime_nsec 中。接受結果 ctime，無論交換結果如何。如果它已經被替換，則該時間戳晚於早期不可接受的時間戳，因此是可以接受的。

struct timespec64 inode_set_ctime_deleg(struct inode *inode, struct timespec64 update)¶: 嘗試更新委託 inode 上的 ctime

引數

struct inode *inode: 要更新的 inode
struct timespec64 update: 用於設定 ctime 的 timespec64

描述

嘗試代表委託持有者原子地更新 ctime。

nfs 伺服器可以回撥委託的持有者以獲取更新的 inode 屬性，包括 mtime。更新 mtime 時，將 ctime 更新為至少等於該值的值。

這可能會與對 inode 的併發更新競爭，在這種情況下，更新將被跳過。

請注意，即使未啟用 multigrain 時間戳，這也可以工作，因此在任何一種情況下都會使用它。

bool in_group_or_capable(struct mnt_idmap *idmap, const struct inode *inode, vfsgid_t vfsgid)¶: 檢查呼叫方是否具有 CAP_FSETID 許可權

引數

struct mnt_idmap *idmap: 從 inode 中找到的掛載的 idmap
const struct inode *inode: 要檢查的 inode
vfsgid_t vfsgid: inode 的新/當前 vfsgid

描述

檢查 vfsgid 是否在呼叫方的組列表中，或者呼叫方是否對 inode 具有 CAP_FSETID 許可權。這可以用於確定是否可以保留 setgid 位或必須刪除它。

返回

如果呼叫方具有足夠的許可權，則為 true，否則為 false。

umode_t mode_strip_sgid(struct mnt_idmap *idmap, const struct inode *dir, umode_t mode)¶: 處理非目錄的 sgid 位

引數

struct mnt_idmap *idmap: 建立 inode 的掛載的 idmap
const struct inode *dir: 父目錄 inode
umode_t mode: 要在 dir 中建立的檔案的模式

描述

如果新檔案的 mode 同時提高了 S_ISGID 和 S_IXGRP 位，並且 dir 提高了 S_ISGID 位，則確保呼叫方要麼在父目錄的組中，要麼在其使用者名稱空間中具有 CAP_FSETID 許可權，並且對父目錄具有許可權。在所有其他情況下，從 mode 中刪除 S_ISGID 位。

返回

用於檔案的新模式

void make_bad_inode(struct inode *inode)¶: 由於 I/O 錯誤，將 inode 標記為壞

引數

struct inode *inode

要標記為壞的 Inode

當由於介質或遠端網路故障而無法讀取 inode 時，此函式會使 inode “損壞”，並導致從此開始對其進行的 I/O 操作失敗。

bool is_bad_inode(struct inode *inode)¶: inode 是否出錯

引數

struct inode *inode

要測試的 inode

如果問題中的 inode 已被標記為壞，則返回 true。

void iget_failed(struct inode *inode)¶: 將正在構建的 inode 標記為死並釋放它

引數

struct inode *inode: 要丟棄的 inode

描述

將正在構建的 inode 標記為死並釋放它。

註冊和超級塊¶

void deactivate_locked_super(struct super_block *s)¶: 刪除對超級塊的活動引用

引數

struct super_block *s

要停用的超級塊

刪除對超級塊的活動引用，如果沒有其他活動引用，則將其轉換為臨時引用。在這種情況下，我們告訴 fs 驅動程式將其關閉並刪除我們剛剛獲得的臨時引用。

呼叫方持有對超級塊的獨佔鎖；該鎖將被釋放。

void deactivate_super(struct super_block *s)¶: 刪除對超級塊的活動引用

引數

struct super_block *s

要停用的超級塊

deactivate_locked_super() 的變體，不同之處在於超級塊未被呼叫方鎖定。如果我們要刪除最終的活動引用，則會在刪除之前獲取鎖。

void retire_super(struct super_block *sb)¶: 防止超級塊被重用

引數

struct super_block *sb

要停用的超級塊

該函式將超級塊標記為在超級塊測試中被忽略，這可以防止它被重用於任何新的掛載。如果超級塊具有私有 bdi，它也會登出它，但不會減少超級塊的引用計數以防止潛在的競爭。引用計數由 generic_shutdown_super() 減少。該函式不能與 generic_shutdown_super() 併發呼叫。多次呼叫該函式是安全的，後續呼叫無效。

該標記只會影響基於塊裝置的超級塊的重用。如果使用此函式，其他超級塊仍將被標記，但這不會影響它們的可重用性。

void generic_shutdown_super(struct super_block *sb)¶: 用於 ->kill_sb() 的常見助手

引數

struct super_block *sb

要終止的超級塊

generic_shutdown_super() 在超級塊關閉時執行所有 fs 獨立的工作。典型的 ->kill_sb() 應該從超級塊中挑選出所有需要銷燬的 fs 特定物件，呼叫 generic_shutdown_super() 並釋放上述物件。注意：dentry 和 inode _已_得到處理，不需要特定的處理。

呼叫此函式後，檔案系統可能不再更改或重新排列屬於此 super_block 的 dentry 集合，也不得更改 dentry 到 inode 的連線。

struct super_block *sget_fc(struct fs_context *fc, int (*test)(struct super_block*, struct fs_context*), int (*set)(struct super_block*, struct fs_context*))¶: 查詢或建立超級塊

引數

struct fs_context *fc: 檔案系統上下文。
int (*test)(struct super_block *, struct fs_context *): 比較回撥函式
int (*set)(struct super_block *, struct fs_context *): 設定回撥函式

描述

建立一個新的超級塊或查詢一個已存在的超級塊。

test 回撥函式用於查詢匹配的現有超級塊。fc 中請求的引數是否被考慮取決於所使用的 test 回撥函式。它們甚至可能被完全忽略。

如果匹配到一個現有的超級塊，它將被返回，除非

檔案系統上下文 fc 和現有超級塊的名稱空間不同
檔案系統上下文 fc 已經請求不允許重用現有的超級塊

在這兩種情況下，都會返回 EBUSY。

如果沒有找到匹配項，將分配一個新的超級塊並執行基本的初始化（s_type、s_fs_info 和 s_id 將被設定，並且 set 回撥函式將被呼叫），超級塊將被髮布，並且它將在部分構建的狀態下返回，SB_BORN 和 SB_ACTIVE 尚未設定。

返回

成功時，返回一個已存在的或新建立的超級塊。: 失敗時，返回一個錯誤指標。

struct super_block *sget(struct file_system_type *type, int (*test)(struct super_block*, void*), int (*set)(struct super_block*, void*), int flags, void *data)¶: 查詢或建立一個超級塊

引數

struct file_system_type *type: 超級塊所屬的檔案系統型別
int (*test)(struct super_block *,void *): 比較回撥函式
int (*set)(struct super_block *,void *): 設定回撥函式
int flags: 掛載標誌
void *data: 傳遞給每個回撥函式的引數

void iterate_supers_type(struct file_system_type *type, void (*f)(struct super_block*, void*), void *arg)¶: 為給定型別的所有超級塊呼叫函式

引數

struct file_system_type *type

檔案系統型別

void (*f)(struct super_block *, void *)

要呼叫的函式

void *arg

傳遞給函式的引數

掃描超級塊列表並呼叫給定函式，傳遞鎖定的超級塊和給定引數。

int get_anon_bdev(dev_t *p)¶: 為沒有塊裝置的檔案系統分配一個塊裝置。

引數

dev_t *p: 指向 dev_t 的指標。

描述

不使用真實塊裝置的檔案系統可以呼叫此函式來分配一個虛擬塊裝置。

上下文

任何上下文。經常在持有 sb_lock 時呼叫。

返回

成功時返回 0，如果沒有剩餘的匿名 bdevs，則返回 -EMFILE，如果記憶體分配失敗，則返回 -ENOMEM。

struct super_block *sget_dev(struct fs_context *fc, dev_t dev)¶: 透過裝置號查詢或建立超級塊

引數

struct fs_context *fc: 檔案系統上下文。
dev_t dev: 裝置號

描述

使用提供的裝置號查詢或建立超級塊，該裝置號將儲存在 fc->sget_key 中。

如果匹配到一個現有的超級塊，則將返回該超級塊，並增加其引用計數，呼叫者必須傳輸或丟棄該引用計數。

如果沒有找到匹配項，將分配一個新的超級塊並執行基本的初始化（s_type、s_fs_info、s_id、s_dev 將被設定）。超級塊將被髮布，並且它將在部分構建的狀態下返回，SB_BORN 和 SB_ACTIVE 尚未設定。

返回

成功時，返回一個已存在的或新建立的超級塊，失敗時返回一個錯誤指標。: 失敗時返回指標。

int get_tree_bdev_flags(struct fs_context *fc, int (*fill_super)(struct super_block *sb, struct fs_context *fc), unsigned int flags)¶: 基於單個塊裝置獲取超級塊

引數

struct fs_context *fc: 包含引數的檔案系統上下文
int (*fill_super)(struct super_block *sb, struct fs_context *fc): 用於初始化新超級塊的輔助函式
unsigned int flags: GET_TREE_BDEV_* 標誌

int get_tree_bdev(struct fs_context *fc, int (*fill_super)(struct super_block*, struct fs_context*))¶: 基於單個塊裝置獲取超級塊

引數

struct fs_context *fc: 包含引數的檔案系統上下文
int (*fill_super)(struct super_block *, struct fs_context *): 用於初始化新超級塊的輔助函式

int vfs_get_tree(struct fs_context *fc)¶: 獲取可掛載的根

引數

struct fs_context *fc: 超級塊配置上下文。

描述

呼叫檔案系統以獲取或建立超級塊，然後可以將其用於掛載。檔案系統將指向要用於掛載的根的指標放置在 fc->root 中。

int freeze_super(struct super_block *sb, enum freeze_holder who, const void *freeze_owner)¶: 鎖定檔案系統並強制其進入一致狀態

引數

struct super_block *sb: 要鎖定的超級塊
enum freeze_holder who: 想要凍結的上下文
const void *freeze_owner: 凍結的所有者

描述

同步超級塊以確保檔案系統一致，並呼叫檔案系統的 freeze_fs。在沒有首先解凍檔案系統的情況下，後續的呼叫可能會返回 -EBUSY。

who 應該是：* 如果使用者空間想要凍結檔案系統，則為 FREEZE_HOLDER_USERSPACE；* 如果核心想要凍結檔案系統，則為 FREEZE_HOLDER_KERNEL。* FREEZE_MAY_NEST 是否允許巢狀凍結和解凍請求。

who 引數區分了核心和使用者空間嘗試凍結檔案系統。雖然在任何給定時間都不能有多個核心凍結或多個使用者空間凍結生效，但核心和使用者空間都可以保持檔案系統凍結。檔案系統保持凍結狀態，直到沒有核心或使用者空間凍結生效。

一個檔案系統可能持有多個裝置，因此可以透過塊層透過多個塊裝置凍結檔案系統。在這種情況下，透過傳遞 FREEZE_MAY_NEST 將該請求標記為允許巢狀。檔案系統保持凍結狀態，直到所有塊裝置都被解凍。如果在沒有 FREEZE_MAY_NEST 的情況下嘗試多個凍結，則會返回 -EBUSY。

在此函式期間，sb->s_writers.frozen 經歷以下值

SB_UNFROZEN：檔案系統正常，所有寫入照常進行。

SB_FREEZE_WRITE：檔案系統正在被凍結的過程中。應該阻止新的寫入，但仍然允許頁面錯誤。我們等待所有寫入完成，然後進行到下一個階段。

SB_FREEZE_PAGEFAULT：凍結繼續。現在頁面錯誤也被阻止了，但是內部 fs 執行緒仍然可以修改檔案系統（儘管它們不應該修改新的髒頁面或 inode），回寫可以執行等等。在等待所有正在執行的頁面錯誤後，我們同步檔案系統，這將清理所有髒頁面和 inode（當同步執行時，無法建立新的髒頁面或 inode）。

SB_FREEZE_FS：檔案系統已凍結。現在，所有檔案系統修改的內部來源都被阻止（例如，XFS 預分配在 inode 回收時截斷）。這通常是透過阻止具有它們並需要此額外保護的檔案系統的新事務來實現的。在所有內部寫入器完成後，我們呼叫 ->freeze_fs() 以完成檔案系統的凍結。然後我們轉換到 SB_FREEZE_COMPLETE 狀態。此狀態主要用於檔案系統驗證它們是否不修改凍結的 fs。

sb->s_writers.frozen 受 sb->s_umount 保護。

返回

如果凍結成功，則返回零。如果凍結失敗，則返回負錯誤程式碼。: 如果失敗，則返回一個負的錯誤程式碼。

int thaw_super(struct super_block *sb, enum freeze_holder who, const void *freeze_owner)¶

解鎖檔案系統

引數

struct super_block *sb: 要解凍的超級塊
enum freeze_holder who: 想要凍結的上下文
const void *freeze_owner: 凍結的所有者

描述

在 freeze_super() 之後，如果檔案系統上沒有剩餘的凍結，則解鎖檔案系統並將其標記為可再次寫入。

who 應該是：* 如果使用者空間想要解凍檔案系統，則為 FREEZE_HOLDER_USERSPACE；* 如果核心想要解凍檔案系統，則為 FREEZE_HOLDER_KERNEL。* FREEZE_MAY_NEST 是否允許巢狀凍結和解凍請求。

一個檔案系統可能持有多個裝置，因此可以透過塊層透過多個塊裝置凍結檔案系統。檔案系統保持凍結狀態，直到所有塊裝置都被解凍。

檔案鎖¶

bool locks_owner_has_blockers(struct file_lock_context *flctx, fl_owner_t owner)¶: 檢查是否存在阻塞鎖請求

引數

struct file_lock_context *flctx: 檔案鎖上下文
fl_owner_t owner: 鎖所有者

描述

返回值: true：owner 至少有一個阻塞者 false：owner 沒有阻塞者

int locks_delete_block(struct file_lock *waiter)¶: 停止等待檔案鎖

引數

struct file_lock *waiter

正在等待的鎖

lockd/nfsd 需要在處理鎖時斷開連線。

int posix_lock_file(struct file *filp, struct file_lock *fl, struct file_lock *conflock)¶: 將 POSIX 風格的鎖應用於檔案

引數

struct file *filp: 要應用鎖的檔案
struct file_lock *fl: 要應用的鎖
struct file_lock *conflock: 如果找到衝突鎖，則返回衝突鎖的副本的位置。

描述

將 POSIX 風格的鎖新增到檔案。我們儘可能地合併相鄰和重疊的鎖。POSIX 鎖按所有者任務排序，然後按起始地址排序

請注意，如果使用 FL_EXISTS 引數呼叫，則呼叫者可以透過測試返回值是否為 -ENOENT 來確定是否成功釋放了鎖。

int __break_lease(struct inode *inode, unsigned int mode, unsigned int type)¶: 撤銷檔案上的所有未完成的租約

引數

struct inode *inode

要返回的檔案的 inode

unsigned int mode

O_RDONLY: 僅中斷寫租約；O_WRONLY 或 O_RDWR: 中斷所有租約

unsigned int type

FL_LEASE: 中斷租約和委託；FL_DELEG: 僅中斷委託

break_lease（為了速度內聯）已經檢查過此檔案上至少存在某種型別的鎖（可能是租約）。租約在呼叫 open() 或 truncate() 時中斷。除非您在 open() 中指定了 O_NONBLOCK，否則此函式可以休眠。

void lease_get_mtime(struct inode *inode, struct timespec64 *time)¶: 使用獨佔租約更新 inode 的修改時間

引數

struct inode *inode: inode
struct timespec64 *time: 指向包含上次修改時間的 timespec 的指標

描述

這是為了強制 NFS 客戶端重新整理具有獨佔租約的檔案的快取。理由是如果有人擁有獨佔租約，那麼他們可能會修改它。

int generic_setlease(struct file *filp, int arg, struct file_lease **flp, void **priv)¶: 在開啟的檔案上設定租約

引數

struct file *filp

檔案指標

int arg

要獲得的租約的型別

struct file_lease **flp

輸入 - 要使用的 file_lock，輸出 - 插入的 file_lock

void **priv

lm_setup 的私有資料（如果 lm_setup 不需要，則可以為 NULL）

(輸入) flp->fl_lmops->lm_break 函式是 break_lease() 所必需的。

int vfs_setlease(struct file *filp, int arg, struct file_lease **lease, void **priv)¶: 在開啟的檔案上設定租約

引數

struct file *filp: 檔案指標
int arg: 要獲得的租約的型別
struct file_lease **lease: 新增租約時要使用的 file_lock
void **priv: 新增租約時 lm_setup 的私有資訊（如果 lm_setup 不需要，則可以為 NULL）

描述

呼叫此函式以在檔案上建立租約。 “lease”引數不用於 F_UNLCK 請求，可以為 NULL。對於設定或更改現有租約的命令，必須設定 (*lease)->fl_lmops->lm_break 操作；如果沒有，此函式將返回 -ENOLCK（並生成一個看起來很可怕的堆疊跟蹤）。

“priv”指標直接傳遞給 lm_setup 函式，並且按原樣傳遞。如果 lm_setup 操作不需要，則可以為 NULL。

int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl)¶: 將鎖應用於 inode

引數

struct inode *inode: 要應用到的檔案的 inode
struct file_lock *fl: 要應用的鎖

描述

將 POSIX 或 FLOCK 樣式的鎖請求應用於 inode。

int vfs_test_lock(struct file *filp, struct file_lock *fl)¶: 測試檔案位元組範圍鎖

引數

struct file *filp: 要測試鎖定的檔案
struct file_lock *fl: 要測試的鎖；也用於儲存結果

描述

失敗時返回 -ERRNO。透過將 conf->fl_type 設定為 F_UNLCK 以外的值來指示是否存在衝突鎖。

int vfs_lock_file(struct file *filp, unsigned int cmd, struct file_lock *fl, struct file_lock *conf)¶: 檔案位元組範圍鎖

引數

struct file *filp: 要應用鎖的檔案
unsigned int cmd: 鎖定操作的型別 (F_SETLK、F_GETLK 等)
struct file_lock *fl: 要應用的鎖
struct file_lock *conf: 如果找到衝突鎖，則返回衝突鎖的副本的位置。

描述

不關心衝突鎖的呼叫者可以將 NULL 作為最後一個引數傳遞。

如果檔案系統定義了一個私有的 ->lock() 方法，那麼 conf 將保持不變；因此，關心的呼叫者應將其初始化為一些可接受的預設值。

為了避免阻塞需要獲取 POSIX 鎖的核心守護程序（例如 lockd），如果設定了 lm_grant，則 ->lock() 介面可能會非同步返回，在底層檔案系統授予或拒絕鎖之前。(並且只有在這種情況下) 此外，需要設定 export_operations 標誌中的 EXPORT_OP_ASYNC_LOCK。

期望 ->lock() 非同步返回的呼叫者將只使用 F_SETLK，而不是 F_SETLKW；如果（並且只有在這種情況下）該請求用於阻塞鎖，它們將設定 FL_SLEEP。當 ->lock() 非同步返回時，它必須返回 FILE_LOCK_DEFERRED，並在鎖請求完成時呼叫 ->lm_grant()。如果請求用於非阻塞鎖，則檔案系統應返回 FILE_LOCK_DEFERRED，然後嘗試獲取鎖並使用結果呼叫回撥例程。如果請求超時，則回撥例程將返回一個非零的返回碼，並且檔案系統應釋放該鎖。檔案系統還有責任在授予鎖時保持相應的 posix 鎖，以便 VFS 可以找出哪些鎖在本地持有，並在需要時進行正確的鎖清理。在以 FILE_LOCK_DEFERRED 返回碼返回到呼叫者之前，底層檔案系統不得刪除核心鎖或呼叫 ->lm_grant()。

int vfs_cancel_lock(struct file *filp, struct file_lock *fl)¶: 檔案位元組範圍取消阻塞鎖定

引數

struct file *filp: 要應用取消阻塞的檔案
struct file_lock *fl: 要取消阻塞的鎖

描述

鎖管理器使用此功能來取消阻塞的請求

bool vfs_inode_has_locks(struct inode *inode)¶: 是否在 inode 上持有任何檔案鎖？

引數

struct inode *inode: 要檢查鎖的 inode

描述

如果當前在 inode 上設定了任何 FL_POSIX 或 FL_FLOCK 鎖，則返回 true。

int posix_lock_inode_wait(struct inode *inode, struct file_lock *fl)¶: 將 POSIX 風格的鎖應用於檔案

引數

struct inode *inode: 應向其應用鎖請求的檔案的 inode
struct file_lock *fl: 要應用的鎖

描述

將 POSIX 樣式的鎖請求應用於 inode。

int fcntl_getlease(struct file *filp)¶: 查詢當前活動的租約是什麼

引數

struct file *filp

檔案

此函式返回的值將是以下之一（如果未掛起任何租約中斷）

F_RDLCK 指示持有共享租約。

F_WRLCK 指示持有獨佔租約。

F_UNLCK 指示未持有任何租約。

（如果掛起租約中斷）

F_RDLCK 指示獨佔租約需要: 更改為共享租約（或刪除）。

F_UNLCK 指示需要刪除租約。

XXX：sfr & willy 對是否應將 F_INPROGRESS 返回給使用者空間存在分歧。

int check_conflicting_open(struct file *filp, const int arg, int flags)¶: 檢視給定檔案是否指向一個現有的開啟的 inode，該 inode 會與所需的租約衝突。

引數

struct file *filp: 要檢查的檔案
const int arg: 我們正在嘗試獲得的租約的型別
int flags: 當前鎖定標誌

描述

檢查此檔案上是否存在現有的開啟的 fd，該 fd 會與我們嘗試設定的租約衝突。

int fcntl_setlease(unsigned int fd, struct file *filp, int arg)¶: 在開啟的檔案上設定租約

引數

unsigned int fd

開啟的檔案描述符

struct file *filp

檔案指標

int arg

要獲得的租約的型別

呼叫此 fcntl 以在檔案上建立租約。請注意，您還需要呼叫 F_SETSIG 以在租約中斷時收到訊號。

int flock_lock_inode_wait(struct inode *inode, struct file_lock *fl)¶: 將 FLOCK 樣式的鎖應用於檔案

引數

struct inode *inode: 要應用到的檔案的 inode
struct file_lock *fl: 要應用的鎖

描述

將 FLOCK 樣式的鎖請求應用於 inode。

long sys_flock(unsigned int fd, unsigned int cmd)¶

flock() 系統呼叫。

引數

unsigned int fd

要鎖定的檔案描述符。

unsigned int cmd

要應用的鎖的型別。

將 FL_FLOCK 樣式的鎖應用於開啟的檔案描述符。 cmd 可以是以下之一

LOCK_SH -- 共享鎖。
LOCK_EX -- 獨佔鎖。
LOCK_UN -- 刪除現有鎖。
LOCK_MAND -- “強制” flock。（已棄用）

LOCK_MAND 支援已從核心中刪除。

pid_t locks_translate_pid(struct file_lock_core *fl, struct pid_namespace *ns)¶: 將 file_lock 的 fl_pid 編號轉換為名稱空間

引數

struct file_lock_core *fl: 應該轉換其 fl_pid 的 file_lock
struct pid_namespace *ns: 應該將 pid 轉換成的名稱空間

描述

用於將 fl_pid 轉換為名稱空間虛擬 pid 編號

其他函式¶

void mpage_readahead(struct readahead_control *rac, get_block_t get_block)¶: 針對頁面啟動讀取

引數

struct readahead_control *rac: 描述要讀取的頁面。
get_block_t get_block: 檔案系統的塊對映器函式。

描述

此函式遍歷頁面和每個頁面中的塊，構建和發出大型 BIO。

如果發生任何不尋常的事情，例如

遇到一個帶有緩衝區的頁面
在孔之後遇到一個沒有孔的頁面
遇到一個帶有非連續塊的頁面

然後，此程式碼只是放棄並呼叫基於 buffer_head 的讀取函式。它可以處理在末尾有孔的頁面 - 這是一種常見情況：blocksize < PAGE_SIZE 設定上的檔案結尾。

BH_Boundary 解釋

存在一個問題。 mpage 讀取程式碼組裝多個頁面，獲取它們的所有磁碟對映，然後提交它們。這很好，但是獲取磁碟對映可能需要 I/O。例如，讀取間接塊。

因此，讀取 ext2 檔案的前 16 個塊的 mpage 將導致按以下順序提交 I/O

12 0 1 2 3 4 5 6 7 8 9 10 11 13 14 15 16

因為必須讀取間接塊才能獲取塊 13、14、15、16 的對映。顯然，這會影響效能。

因此，我們所做的是允許檔案系統的 get_block() 函式在對映塊 11 時設定 BH_Boundary。 BH_Boundary 說：此塊之後的塊的對映將需要針對可能與此塊接近的塊進行 I/O。因此，您應該推送當前已累積的 I/O。

所有這些都會導致按正確的順序發出磁碟請求。

int mpage_writepages(struct address_space *mapping, struct writeback_control *wbc, get_block_t get_block)¶: 遍歷給定地址空間的髒頁列表並對所有頁執行 writepage()

引數

struct address_space *mapping: 要寫入的地址空間結構
struct writeback_control *wbc: 從 *wbc->nr_to_write 中減去已寫入頁面的數量
get_block_t get_block: 檔案系統的塊對映函式。

描述

這是一個庫函式，實現了 writepages() address_space_operation。

int generic_permission(struct mnt_idmap *idmap, struct inode *inode, int mask)¶: 檢查類 Posix 檔案系統上的訪問許可權

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
struct inode *inode: 要檢查訪問許可權的 inode
int mask: 要檢查的許可權（MAY_READ、MAY_WRITE、MAY_EXEC、MAY_NOT_BLOCK ...）

描述

用於檢查檔案上的讀/寫/執行許可權。我們使用 "fsuid" 來實現這一點，允許我們在不更改用於其他事物的 "normal" uid 的情況下，為檔案系統訪問設定任意許可權。

generic_permission 知道 rcu-walk。如果無法滿足 rcu-walk 請求（例如，需要阻塞或過於複雜），則返回 -ECHILD。然後將在 ref-walk 模式下再次呼叫它。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

int inode_permission(struct mnt_idmap *idmap, struct inode *inode, int mask)¶: 檢查對給定 inode 的訪問許可權

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
struct inode *inode: 要檢查許可權的 Inode
int mask: 要檢查的許可權（MAY_READ，MAY_WRITE，MAY_EXEC）

描述

檢查 inode 上的讀/寫/執行許可權。我們使用 fs[ug]id 來實現這一點，允許我們在不更改用於其他事物的“normal”UID 的情況下，為檔案系統訪問設定任意許可權。

在檢查 MAY_APPEND 時，mask 中也必須設定 MAY_WRITE。

void path_get(const struct path *path)¶: 獲取對路徑的引用

引數

const struct path *path: 要獲取引用的路徑

描述

給定一個路徑，遞增對 dentry 和 vfsmount 的引用計數。

void path_put(const struct path *path)¶: 釋放對路徑的引用

引數

const struct path *path: 要釋放引用的路徑

描述

給定一個路徑，遞減對 dentry 和 vfsmount 的引用計數。

int vfs_path_parent_lookup(struct filename *filename, unsigned int flags, struct path *parent, struct qstr *last, int *type, const struct path *root)¶: 查詢相對於 dentry-vfsmount 對的父路徑

引數

struct filename *filename: 檔名結構
unsigned int flags: 查詢標誌
struct path *parent: 指向要填充的 struct path 的指標
struct qstr *last: 最後一個元件
int *type: 最後一個元件的型別
const struct path *root: 指向基本目錄的 struct path 的指標

int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt, const char *name, unsigned int flags, struct path *path)¶: 查詢相對於 dentry-vfsmount 對的檔案路徑

引數

struct dentry *dentry: 指向基本目錄的 dentry 的指標
struct vfsmount *mnt: 指向基本目錄的 vfs mount 的指標
const char *name: 指向檔名的指標
unsigned int flags: 查詢標誌
struct path *path: 指向要填充的 struct path 的指標

struct dentry *try_lookup_noperm(struct qstr *name, struct dentry *base)¶: 檔案系統幫助程式，用於查詢單個路徑名元件

引數

struct qstr *name: qstr 儲存要查詢的路徑名元件
struct dentry *base: 要從中查詢的基本目錄

描述

按名稱在 dcache 中查詢 dentry，如果當前不存在，則返回 NULL。該函式不嘗試建立 dentry，如果找到 dentry，也不會嘗試重新驗證它。

請注意，此例程純粹是檔案系統使用的幫助程式，不應由通用程式碼呼叫。它不進行任何許可權檢查。

不需要持有鎖 - 只需要對 base 的計數引用。

struct dentry *lookup_noperm(struct qstr *name, struct dentry *base)¶: 檔案系統幫助程式，用於查詢單個路徑名元件

引數

struct qstr *name: qstr 儲存要查詢的路徑名元件
struct dentry *base: 要從中查詢的基本目錄

描述

請注意，此例程純粹是檔案系統使用的幫助程式，不應由通用程式碼呼叫。它不進行任何許可權檢查。

呼叫者必須持有 base->i_mutex。

struct dentry *lookup_one(struct mnt_idmap *idmap, struct qstr *name, struct dentry *base)¶: 查詢單個路徑名元件

引數

struct mnt_idmap *idmap: 執行查詢的掛載的 idmap
struct qstr *name: qstr 儲存要查詢的路徑名元件
struct dentry *base: 要從中查詢的基本目錄

描述

這可以用於核心檔案系統客戶端，例如檔案伺服器。

呼叫者必須持有 base->i_mutex。

struct dentry *lookup_one_unlocked(struct mnt_idmap *idmap, struct qstr *name, struct dentry *base)¶: 查詢單個路徑名元件

引數

struct mnt_idmap *idmap: 執行查詢的掛載的 idmap
struct qstr *name: qstr olding 要查詢的路徑名元件
struct dentry *base: 要從中查詢的基本目錄

描述

這可以用於核心檔案系統客戶端，例如檔案伺服器。

與 lookup_one 不同，它應該在沒有持有父 i_rwsem 的情況下呼叫，並且如果需要，它將獲取 i_rwsem 本身。

struct dentry *lookup_one_positive_unlocked(struct mnt_idmap *idmap, struct qstr *name, struct dentry *base)¶: 查詢單個路徑名元件

引數

struct mnt_idmap *idmap: 執行查詢的掛載的 idmap
struct qstr *name: qstr 儲存要查詢的路徑名元件
struct dentry *base: 要從中查詢的基本目錄

描述

如果為負數，此幫助程式將產生 ERR_PTR(-ENOENT)。幫助程式返回已知的正數或 ERR_PTR()。這是大多數使用者想要的。

請注意，帶有未鎖定父級的已固定的負數_可以_隨時變為正數，因此 lookup_one_unlocked() 的呼叫者需要非常小心；已固定的正數具有 >d_inode 穩定，因此這一個避免了此類問題。

這可以用於核心檔案系統客戶端，例如檔案伺服器。

該幫助程式應在未持有 i_rwsem 的情況下呼叫。

struct dentry *lookup_noperm_unlocked(struct qstr *name, struct dentry *base)¶: 檔案系統幫助程式，用於查詢單個路徑名元件

引數

struct qstr *name: 要查詢的路徑名元件
struct dentry *base: 要從中查詢的基本目錄

描述

請注意，此例程純粹是檔案系統使用的幫助程式，不應由通用程式碼呼叫。它不進行任何許可權檢查。

與 lookup_noperm() 不同，它應該在沒有持有父 i_rwsem 的情況下呼叫，並且如果需要，它將獲取 i_rwsem 本身。

與 try_lookup_noperm() 不同，如果 dentry 已經存在，它會重新驗證 dentry。

int vfs_create(struct mnt_idmap *idmap, struct inode *dir, struct dentry *dentry, umode_t mode, bool want_excl)¶: 建立新檔案

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
struct inode *dir: 父目錄的 inode
struct dentry *dentry: 子檔案的 dentry
umode_t mode: 子檔案的模式
bool want_excl: 該檔案是否必須尚不存在

描述

建立一個新檔案。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

struct file *kernel_tmpfile_open(struct mnt_idmap *idmap, const struct path *parentpath, umode_t mode, int open_flag, const struct cred *cred)¶: 為核心內部使用開啟一個 tmpfile

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
const struct path *parentpath: 基本目錄的路徑
umode_t mode: 新 tmpfile 的模式
int open_flag: flags
const struct cred *cred: 用於開啟的憑據

描述

建立並開啟一個臨時檔案。該檔案未在 nr_files 中進行核算，因此這僅用於核心內部使用，並且不得安裝到檔案表等中。

int vfs_mknod(struct mnt_idmap *idmap, struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev)¶: 建立裝置節點或檔案

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
struct inode *dir: 父目錄的 inode
struct dentry *dentry: 子裝置節點的 dentry
umode_t mode: 子裝置節點的模式
dev_t dev: 要建立的裝置的裝置編號

描述

建立一個裝置節點或檔案。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

struct dentry *vfs_mkdir(struct mnt_idmap *idmap, struct inode *dir, struct dentry *dentry, umode_t mode)¶: 建立目錄，如果可能，返回正確的dentry

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
struct inode *dir: 父目錄的 inode
struct dentry *dentry: 子目錄的dentry
umode_t mode: 子目錄的模式

描述

建立一個目錄。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

如果檔案系統不使用**dentry**，而是將其保留為負值或取消雜湊，並可能拼接一個不同的dentry並返回，則原始dentry將被dput()，並返回備用dentry。

如果發生錯誤，則dentry將被dput()，並返回一個ERR_PTR()。

int vfs_rmdir(struct mnt_idmap *idmap, struct inode *dir, struct dentry *dentry)¶: 刪除目錄

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
struct inode *dir: 父目錄的 inode
struct dentry *dentry: 子目錄的dentry

描述

刪除一個目錄。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

int vfs_unlink(struct mnt_idmap *idmap, struct inode *dir, struct dentry *dentry, struct inode **delegated_inode)¶: 取消連結一個檔案系統物件

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
struct inode *dir: 父目錄
struct dentry *dentry: 受害者
struct inode **delegated_inode: 如果 inode 被委託，則返回受害者的 inode。

描述

呼叫者必須持有 dir->i_mutex。

如果 vfs_unlink 發現一個委託，它將返回 -EWOULDBLOCK 並在 delegated_inode 中返回一個指向 inode 的引用。然後，呼叫者應該在該 inode 上打破委託並重試。由於打破委託可能需要很長時間，因此呼叫者應該在這樣做之前釋放 dir->i_mutex。

或者，呼叫者可以為 delegated_inode 傳遞 NULL。這可能適用於期望底層檔案系統不被 NFS 匯出的呼叫者。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

int vfs_symlink(struct mnt_idmap *idmap, struct inode *dir, struct dentry *dentry, const char *oldname)¶: 建立符號連結

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
struct inode *dir: 父目錄的 inode
struct dentry *dentry: 子符號連結檔案的dentry
const char *oldname: 要連結到的檔案的名稱

描述

建立一個符號連結。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

int vfs_link(struct dentry *old_dentry, struct mnt_idmap *idmap, struct inode *dir, struct dentry *new_dentry, struct inode **delegated_inode)¶: 建立一個新連結

引數

struct dentry *old_dentry: 要連結的物件
struct mnt_idmap *idmap: 掛載的 idmap
struct inode *dir: 新的父目錄
struct dentry *new_dentry: 在哪裡建立新的連結
struct inode **delegated_inode: 返回需要委託中斷的 inode

描述

呼叫者必須持有 dir->i_mutex

如果 vfs_link 在需要中斷的待連結檔案上發現委託，它將返回 -EWOULDBLOCK 並在 delegated_inode 中返回一個指向 inode 的引用。然後，呼叫者應該中斷委託並重試。由於打破委託可能需要很長時間，因此呼叫者應該在這樣做之前釋放 i_mutex。

或者，呼叫者可以為 delegated_inode 傳遞 NULL。這可能適用於期望底層檔案系統不被 NFS 匯出的呼叫者。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

int vfs_rename(struct renamedata *rd)¶: 重新命名一個檔案系統物件

引數

struct renamedata *rd: 指向struct renamedata資訊的指標

描述

呼叫者必須持有多個互斥鎖--請參見 lock_rename()。

如果 vfs_rename 在源或目標上發現需要中斷的委託，它將返回 -EWOULDBLOCK 並在 delegated_inode 中返回一個指向 inode 的引用。然後，呼叫者應該中斷委託並重試。由於打破委託可能需要很長時間，因此呼叫者應該在這樣做之前釋放所有鎖。

或者，呼叫者可以為 delegated_inode 傳遞 NULL。這可能適用於期望底層檔案系統不被 NFS 匯出的呼叫者。

所有名稱空間操作中最糟糕的 - 重新命名目錄。“變態”甚至不足以形容它。UCB 中的某個人度過了一段糟糕的旅程... 問題

我們可以進入迴圈建立。

競爭潛力 - 兩個無辜的重新命名可以一起建立一個迴圈。這就是 4.4BSD 搞砸的地方。目前的修復：sb->s_vfs_rename_mutex 上的序列化。我們可能會更準確，但那是另一個故事。

我們可能必須鎖定多達 _四個_ 物件 - 父目錄和受害者（如果存在），以及源（如果它是一個非目錄或移動到不同父目錄的子目錄）。而且是在我們獲取父母的 ->i_mutex 之後（在此之前我們不知道目標是否存在）。解決方案：嘗試在 inode 的鎖定順序方面變得聰明。我們依賴於樹拓撲只能在 ->s_vfs_rename_mutex _和_ 我們移動的物件的父目錄將被鎖定的事實。因此，我們可以按樹對目錄進行排序（祖先優先），並將所有非目錄排在它們之後。這之所以有效，是因為除了重新命名之外的每個人都執行“鎖定父目錄，查詢，鎖定子目錄”，並且重新命名在 ->s_vfs_rename_mutex 下。但是，它依賴於這樣一個假設：任何具有 ->lookup() 的物件都只有一個 dentry。如果“混合”物件將來出現，我們最好確保它們沒有 link(2)。

從 fhandle 到 dentry 的轉換可能會在錯誤的時刻發生 - 當我們刪除目標時。解決方案：我們必須在 fhandle_to_dentry 程式碼中獲取 ->i_mutex。[FIXME - 當前的 nfsfh.c 依賴於父母的 ->i_mutex，這雖然有效，但會導致一些真正過度的鎖定]。

int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen)¶: 將符號連結主體複製到使用者空間緩衝區

引數

struct dentry *dentry: 要在其上獲取符號連結的 dentry
char __user *buffer: 使用者記憶體指標
int buflen: 緩衝區大小

描述

不接觸 atime。如有必要，這取決於呼叫者

不呼叫安全鉤子。

const char *vfs_get_link(struct dentry *dentry, struct delayed_call *done)¶: 獲取符號連結主體

引數

struct dentry *dentry: 要在其上獲取符號連結的 dentry
struct delayed_call *done: 呼叫者需要使用它來釋放返回的資料

描述

在提供的 inode 上呼叫安全鉤子和 i_op->get_link()。

它不接觸 atime。如有必要，這取決於呼叫者。

不適用於“特殊”符號連結，如 /proc/$$/fd/N

const char *page_get_link(struct dentry *dentry, struct inode *inode, struct delayed_call *callback)¶: get_link inode_operation 的一個實現。

引數

struct dentry *dentry: 作為符號連結的目錄條目。
struct inode *inode: 符號連結的 inode。
struct delayed_call *callback: 用於刪除對符號連結的引用。

描述

將其符號連結儲存在頁面快取中的檔案系統應使用此方法來實現其 inode_operations 的 get_link() 成員。

返回

指向以 NUL 結尾的符號連結的指標。

void page_put_link(void *arg)¶: 刪除對符號連結的引用。

引數

void *arg: 包含符號連結的區域。

描述

這是 page_get_link() 內部使用的。匯出它是為了供需要實現 page_get_link() 變體本身的檔案系統使用。儘管表面上對稱，但使用 page_get_link() 的檔案系統不需要呼叫 page_put_link()。

引數雖然具有 void 指標型別，但必須是指向從頁面快取中檢索的區域的指標。delayed_call 基礎設施用於在呼叫者完成符號連結後刪除引用計數。

void bio_reset(struct bio *bio, struct block_device *bdev, blk_opf_t opf)¶: 重新初始化一個 bio

引數

struct bio *bio: 要重置的 bio
struct block_device *bdev: 要使用 bio 的塊裝置
blk_opf_t opf: bio 的操作和標誌

描述

在呼叫 bio_reset() 之後，**bio** 將處於與 bio bio_alloc_bioset() 返回的全新分配的 bio 相同的狀態 - 唯一保留的欄位是由 bio_alloc_bioset() 初始化的欄位。請參閱 struct bio 中的註釋。

void bio_chain(struct bio *bio, struct bio *parent)¶: 鏈式 bio 完成

引數

struct bio *bio: 目標 bio
struct bio *parent: **bio** 的父 bio

描述

當 **bio** 完成時，不會呼叫呼叫者的 bi_end_io - 相反，在 **parent** 和 **bio** 都完成之前，不會呼叫 **parent** 的 bi_end_io；連結的 bio 也將在完成時被釋放。

呼叫者不得在 **bio** 中設定 bi_private 或 bi_end_io。

struct bio *bio_alloc_bioset(struct block_device *bdev, unsigned short nr_vecs, blk_opf_t opf, gfp_t gfp_mask, struct bio_set *bs)¶: 為 I/O 分配一個 bio

引數

struct block_device *bdev: 為其分配 bio 的塊裝置（可以為 NULL）
unsigned short nr_vecs: 要預分配的 bvecs 的數量
blk_opf_t opf: bio 的操作和標誌
gfp_t gfp_mask: 提供給 slab 分配器的 GFP_* 掩碼
struct bio_set *bs: 要從中分配的 bio_set。

描述

從 **bs** 中的記憶體池分配一個 bio。

如果設定了 __GFP_DIRECT_RECLAIM，則 bio_alloc 將始終能夠分配一個 bio。這是由於記憶體池保證。為了使這項工作能夠正常進行，呼叫者絕不能一次從通用池中分配超過 1 個 bio。需要分配超過 1 個 bio 的呼叫者必須始終在嘗試分配新 bio 之前提交先前分配的 bio 以進行 IO。否則可能會導致記憶體壓力下的死鎖。

請注意，在 submit_bio_noacct() 下執行時（即任何塊驅動程式），bio 不會被提交，直到您返回之後 - 請參見 submit_bio_noacct() 中的程式碼，該程式碼將遞迴轉換為迭代，以防止堆疊溢位。

這通常意味著在 submit_bio_noacct() 下分配多個 bio 容易發生死鎖，但我們有死鎖避免程式碼，該程式碼從救援執行緒重新提交任何被阻止的 bio。

但是，我們不保證從其他記憶體池進行分配能夠取得進展。應避免在 submit_bio_noacct() 下從同一記憶體池進行多次分配 - 而應使用 bio_set 的 front_pad 進行每個 bio 的分配。

返回

成功時指向新 bio 的指標，失敗時為 NULL。

struct bio *bio_kmalloc(unsigned short nr_vecs, gfp_t gfp_mask)¶: kmalloc 一個 bio

引數

unsigned short nr_vecs: 要分配的 bio_vecs 的數量
gfp_t gfp_mask: 提供給 slab 分配器的 GFP_* 掩碼

描述

使用 kmalloc 分配一個 bio（包括 bvecs）。在使用前，必須使用 bio_init() 初始化 bio。要釋放從此函式返回的 bio，在使用 bio_uninit() 之後使用 kfree()。可以透過在再次呼叫 bio_init() 之前呼叫 bio_uninit() 來重用從此函式返回的 bio。

請注意，與 bio_alloc() 或 bio_alloc_bioset() 不同，從此函式分配的記憶體沒有 mempool 支援，可能會失敗。不要在檔案系統 I/O 路徑中使用此函式進行分配。

返回

成功時指向新 bio 的指標，失敗時為 NULL。

void bio_put(struct bio *bio)¶: 釋放對 bio 的引用

引數

struct bio *bio: 要釋放引用的 bio

描述

釋放對 struct bio 的引用，這個 bio 可以是你透過 bio_alloc、bio_get 或 bio_clone_* 獲取的。對 bio 的最後一次 put 操作將會釋放它。

struct bio *bio_alloc_clone(struct block_device *bdev, struct bio *bio_src, gfp_t gfp, struct bio_set *bs)¶: 克隆一個 bio，該 bio 共享原始 bio 的 biovec

引數

struct block_device *bdev: 要克隆到的 block_device
struct bio *bio_src: 要克隆的 bio
gfp_t gfp: 分配優先順序
struct bio_set *bs: 要從中分配的 bio_set

描述

分配一個新的 bio，它是 bio_src 的克隆。呼叫者擁有返回的 bio，但不擁有它指向的實際資料。

呼叫者必須確保在 bio_src 之前不要釋放返回的 bio。

int bio_init_clone(struct block_device *bdev, struct bio *bio, struct bio *bio_src, gfp_t gfp)¶: 克隆一個 bio，該 bio 共享原始 bio 的 biovec

引數

struct block_device *bdev: 要克隆到的 block_device
struct bio *bio: 要克隆到的 bio
struct bio *bio_src: 要克隆的 bio
gfp_t gfp: 分配優先順序

描述

在呼叫者提供的記憶體中初始化一個新的 bio，它是 bio_src 的克隆。呼叫者擁有返回的 bio，但不擁有它指向的實際資料。

呼叫者必須確保在 bio 之前不要釋放 bio_src。

void __bio_add_page(struct bio *bio, struct page *page, unsigned int len, unsigned int off)¶: 將頁面新增到新段中的 bio

引數

struct bio *bio: 目標 bio
struct page *page: 要新增的起始頁
unsigned int len: 要新增的資料的長度，可能跨越多個頁面
unsigned int off: 資料相對於 page 的偏移量，可能跨越多個頁面

描述

將 page + off 處的資料作為新的 bvec 新增到 bio。呼叫者必須確保 bio 有足夠的空間容納另一個 bvec。

void bio_add_virt_nofail(struct bio *bio, void *vaddr, unsigned len)¶: 將直接核心對映中的資料新增到 bio

引數

struct bio *bio: 目標 bio
void *vaddr: 要新增的資料
unsigned len: 要新增的資料的長度，可能跨越多個頁面

描述

將 vaddr 處的資料新增到 bio。呼叫者必須確保有一個段可用於新增的資料。不會執行與現有段的合併。

int bio_add_page(struct bio *bio, struct page *page, unsigned int len, unsigned int offset)¶: 嘗試將頁面新增到 bio

引數

struct bio *bio

目標 bio

struct page *page

要新增的起始頁

unsigned int len

vec 條目長度，可能跨越多個頁面

unsigned int offset

vec 條目相對於 page 的偏移量，可能跨越多個頁面

嘗試將頁面新增到 bio_vec maplist。只有當 bio->bi_vcnt == bio->bi_max_vecs 或它是克隆的 bio 時，此操作才會失敗。

bool bio_add_folio(struct bio *bio, struct folio *folio, size_t len, size_t off)¶: 嘗試將 folio 的一部分新增到 bio。

引數

struct bio *bio: 要新增到的 BIO。
struct folio *folio: 要新增的 Folio。
size_t len: 要從 folio 新增多少位元組。
size_t off: 要新增的此 folio 中的第一個位元組。

描述

使用 folio 的檔案系統可以呼叫此函式，而不是為 folio 中的每個頁面呼叫 bio_add_page()。如果 off 大於 PAGE_SIZE，則此函式可以建立一個 bio_vec，它從 bv_page 之後的頁面開始。BIO 不支援 4GiB 或更大的 folio。

返回

新增是否成功。

unsigned int bio_add_vmalloc_chunk(struct bio *bio, void *vaddr, unsigned len)¶: 將 vmalloc 塊新增到 bio

引數

struct bio *bio: 目標 bio
void *vaddr: 要新增的 vmalloc 地址
unsigned len: 要新增的資料的總長度（以位元組為單位）

描述

將從 vaddr 開始的資料新增到 bio 並返回已新增的位元組數。這可能小於最初要求的數量。如果無法將資料新增到 bio，則返回 0。

此 helper 函式為新增的範圍呼叫 flush_kernel_vmap_range()。對於讀取，呼叫者仍然需要在完成處理程式中手動呼叫 invalidate_kernel_vmap_range()。

bool bio_add_vmalloc(struct bio *bio, void *vaddr, unsigned int len)¶: 將 vmalloc 區域新增到 bio

引數

struct bio *bio: 目標 bio
void *vaddr: 要新增的 vmalloc 地址
unsigned int len: 要新增的資料的總長度（以位元組為單位）

描述

將從 vaddr 開始的資料新增到 bio。如果成功，則返回 true，如果 bio 沒有足夠的空間容納有效負載，則返回 false。

此 helper 函式為新增的範圍呼叫 flush_kernel_vmap_range()。對於讀取，呼叫者仍然需要在完成處理程式中手動呼叫 invalidate_kernel_vmap_range()。

int bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter)¶: 將使用者或核心頁面新增到 bio

引數

struct bio *bio: 要新增頁面的 bio
struct iov_iter *iter: 描述要新增區域的 iov 迭代器

描述

這需要一個指向使用者記憶體的迭代器，或者一個指向核心頁面（BVEC 迭代器）的迭代器。如果我們正在新增使用者頁面，我們會固定它們並將它們對映到核心中。在 IO 完成時，呼叫者應該 put 那些頁面。對於基於 bvec 的迭代器，bio_iov_iter_get_pages() 使用提供的 bvecs 而不是複製它們。因此，任何發出基於 kiocb 的 IO 的人都需要確保 bvecs 和頁面保持引用狀態，直到提交的 I/O 透過呼叫 ->ki_complete() 完成，或者返回一個錯誤（除了 -EIOCBQUEUED）。呼叫者需要在 IO 完成時檢查 bio 是否標記了 BIO_NO_PAGE_REF。如果沒有，則應該釋放頁面。

該函式嘗試但不能保證固定儘可能多的頁面，這些頁面可以放入 bio 中，或者在 iter 中請求，無論哪個更小。如果 MM 在固定請求的頁面時遇到錯誤，它會停止。僅當無法固定 0 個頁面時，才會返回錯誤。

int submit_bio_wait(struct bio *bio)¶: 提交一個 bio，並等待它完成

引數

struct bio *bio: 描述 I/O 的 struct bio

描述

圍繞 submit_bio() 的簡單包裝器。成功時返回 0，失敗時返回來自 bio_endio() 的錯誤。

警告：與通常使用 submit_bio() 的方式不同，此函式不會導致 bio 引用被消耗。呼叫者必須自行釋放引用。

int bdev_rw_virt(struct block_device *bdev, sector_t sector, void *data, size_t len, enum req_op op)¶: 同步讀取到/寫入到核心對映

引數

struct block_device *bdev: 要訪問的塊裝置
sector_t sector: 要訪問的扇區
void *data: 要讀取/寫入的資料
size_t len: 要讀取/寫入的長度（以位元組為單位）
enum req_op op: 操作（例如，REQ_OP_READ/REQ_OP_WRITE）

描述

對 bdev 執行同步 I/O 以處理 data/len。 data 必須位於核心直接對映中，而不是 vmalloc 地址。

void bio_copy_data(struct bio *dst, struct bio *src)¶: 將資料緩衝區的內容從一個 bio 複製到另一個 bio

引數

struct bio *dst: 目標 bio
struct bio *src: 源 bio

描述

當到達 src 或 dst 的末尾時停止 - 即，複製 min(src->bi_size, dst->bi_size) 位元組（或 bio 列表的等效位元組數）。

void bio_endio(struct bio *bio)¶: 結束 bio 上的 I/O

引數

struct bio *bio: bio

描述

bio_endio() 將結束整個 bio 上的 I/O。 bio_endio() 是結束 bio 上的 I/O 的首選方式。除非他們擁有 bio 並因此知道它具有 end_io 函式，否則任何人都不能直接在 bio 上呼叫 bi_end_io()。

可以在使用 bio_chain() 連結的 bio 上多次呼叫 bio_endio()。 ->bi_end_io() 函式只會在最後一次呼叫。

struct bio *bio_split(struct bio *bio, int sectors, gfp_t gfp, struct bio_set *bs)¶: 拆分一個 bio

引數

struct bio *bio: bio 分割
int sectors: 從 bio 前面分割的扇區數
gfp_t gfp: gfp 掩碼
struct bio_set *bs: 用於分配的 bio 集

描述

分配並返回一個新的 bio，它表示從 bio 開始的 sectors 扇區，並更新 bio 以表示剩餘的扇區。

除非這是一個丟棄請求，否則新分配的 bio 將指向 bio 的 bi_io_vec。呼叫者有責任確保在拆分 bio 之前，bio 和 bs 都不會被釋放。

void bio_trim(struct bio *bio, sector_t offset, sector_t size)¶: 修剪 bio

引數

struct bio *bio: 要修剪的 bio
sector_t offset: 要從 bio 前面修剪的扇區數
sector_t size: 我們希望將 bio 修剪到的尺寸，以扇區為單位

描述

此函式通常用於克隆並以部分形式提交給底層裝置的 bio。

int bioset_init(struct bio_set *bs, unsigned int pool_size, unsigned int front_pad, int flags)¶: 初始化 bio_set

引數

struct bio_set *bs: 要初始化的池
unsigned int pool_size: 要在記憶體池中快取的 bio 和 bio_vecs 的數量
unsigned int front_pad: 要在返回的 bio 前面分配的位元組數
int flags: 修改行為的標誌，當前為 BIOSET_NEED_BVECS 和 BIOSET_NEED_RESCUER

描述

設定一個 bio_set 以與 bio_alloc_bioset 一起使用。允許呼叫者請求在 bio 前面分配一定數量的位元組。前端填充分配對於將 bio 嵌入到另一個結構中非常有用，以避免分配額外的與 bio 一起使用的資料。請注意，bio 必須始終嵌入到該結構的末尾，否則會嚴重損壞。如果在 flags 中設定了 BIOSET_NEED_BVECS，則將分配一個單獨的池來分配 iovec。例如，對於 bio_init_clone()，不需要此池。如果設定了 BIOSET_NEED_RESCUER，則會建立一個工作佇列，該佇列可用於在記憶體池空間不足時排程排隊的請求。

int seq_open(struct file *file, const struct seq_operations *op)¶: 初始化順序檔案

引數

struct file *file

我們初始化的檔案

const struct seq_operations *op

描述序列的方法表

seq_open() 設定 file，將其與由 op 描述的序列相關聯。 op->start() 設定迭代器並返回序列的第一個元素。 op->stop() 關閉它。 op->next() 返回序列的下一個元素。 op->show() 將元素列印到緩衝區中。如果出現錯誤，->start() 和 ->next() 返回 ERR_PTR(錯誤)。在序列的末尾，它們返回 NULL。 ->show() 在成功時返回 0，在出錯時返回負數。返回 SEQ_SKIP 表示“放棄此元素並繼續”。

注意

seq_open() 將分配一個 struct seq_file 並將其儲存在: file->private_data 中。不應修改此指標。

ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)¶: 順序檔案的 ->read() 方法。

引數

struct file *file

要從中讀取的檔案

char __user *buf

要讀取到的緩衝區

size_t size

要讀取的最大位元組數

loff_t *ppos

檔案中的當前位置

現成的 ->f_op->read()

loff_t seq_lseek(struct file *file, loff_t offset, int whence)¶: 順序檔案的 ->llseek() 方法。

引數

struct file *file

有問題的檔案

loff_t offset

新位置

int whence

0 表示絕對位置，1 表示相對位置

現成的 ->f_op->llseek()

int seq_release(struct inode *inode, struct file *file)¶: 釋放與順序檔案關聯的結構。

引數

struct inode *inode

它的 inode

struct file *file

有問題的檔案

釋放與順序檔案關聯的結構；如果您沒有要銷燬的私有資料，則可以用作 ->f_op->release()。

void seq_escape_mem(struct seq_file *m, const char *src, size_t len, unsigned int flags, const char *esc)¶: 將資料列印到緩衝區中，轉義某些字元

引數

struct seq_file *m: 目標緩衝區
const char *src: 源緩衝區
size_t len: 源緩衝區的大小
unsigned int flags: 要傳遞給 string_escape_mem() 的標誌
const char *esc: 需要轉義的字元集

描述

將資料放入緩衝區，將給定類（由 flags 和 esc 定義）中每個字元的出現替換為可列印的轉義序列。

使用 seq_has_overflowed() 檢查錯誤。

char *mangle_path(char *s, const char *p, const char *esc)¶: 處理並將路徑複製到緩衝區開頭

引數

char *s

緩衝區開始

const char *p

上述緩衝區中路徑的開頭

const char *esc

需要轉義的字元集

將路徑從 p 複製到 s，將 esc 中每個字元的出現替換為常用的八進位制轉義。返回指向 s 中最後一個寫入字元之後的指標，如果失敗則返回 NULL。

int seq_path(struct seq_file *m, const struct path *path, const char *esc)¶: seq_file 介面，用於列印路徑名

引數

struct seq_file *m: seq_file 控制代碼
const struct path *path: 要列印的結構路徑
const char *esc: 要在輸出中轉義的字元集

描述

返回 'path' 的絕對路徑，由路徑引數中的 dentry / mnt 對錶示。

int seq_file_path(struct seq_file *m, struct file *file, const char *esc)¶: seq_file 介面，用於列印檔案的路徑名

引數

struct seq_file *m: seq_file 控制代碼
struct file *file: 要列印的 struct file
const char *esc: 要在輸出中轉義的字元集

描述

返回檔案的絕對路徑。

int seq_write(struct seq_file *seq, const void *data, size_t len)¶: 將任意資料寫入緩衝區

引數

struct seq_file *seq: 標識應在其中寫入資料的緩衝區的 seq_file
const void *data: 資料地址
size_t len: 位元組數

描述

成功時返回 0，否則返回非零值。

void seq_pad(struct seq_file *m, char c)¶: 將填充空格寫入緩衝區

引數

struct seq_file *m: 標識應在其中寫入資料的緩衝區的 seq_file
char c: 如果非零，則在填充後追加的位元組

struct hlist_node *seq_hlist_start(struct hlist_head *head, loff_t pos)¶: 開始 hlist 的迭代

引數

struct hlist_head *head: hlist 的頭
loff_t pos: 序列的起始位置

描述

在 seq_file->op->start() 處呼叫。

struct hlist_node *seq_hlist_start_head(struct hlist_head *head, loff_t pos)¶: 開始 hlist 的迭代

引數

struct hlist_head *head: hlist 的頭
loff_t pos: 序列的起始位置

描述

在 seq_file->op->start() 處呼叫。如果您想在輸出頂部列印標題，請呼叫此函式。

struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head, loff_t *ppos)¶: 移動到 hlist 的下一個位置

引數

void *v: 當前迭代器
struct hlist_head *head: hlist 的頭
loff_t *ppos: 當前位置

描述

在 seq_file->op->next() 處呼叫。

struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head, loff_t pos)¶: 開始由 RCU 保護的 hlist 的迭代

引數

struct hlist_head *head: hlist 的頭
loff_t pos: 序列的起始位置

描述

在 seq_file->op->start() 處呼叫。

只要遍歷受 rcu_read_lock() 的保護，此列表遍歷原語就可以與 _rcu 列表修改原語（例如 hlist_add_head_rcu()）安全地併發執行。

struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head, loff_t pos)¶: 開始由 RCU 保護的 hlist 的迭代

引數

struct hlist_head *head: hlist 的頭
loff_t pos: 序列的起始位置

描述

在 seq_file->op->start() 處呼叫。如果您想在輸出頂部列印標題，請呼叫此函式。

只要遍歷受 rcu_read_lock() 的保護，此列表遍歷原語就可以與 _rcu 列表修改原語（例如 hlist_add_head_rcu()）安全地併發執行。

struct hlist_node *seq_hlist_next_rcu(void *v, struct hlist_head *head, loff_t *ppos)¶: 移動到受 RCU 保護的 hlist 的下一個位置

引數

void *v: 當前迭代器
struct hlist_head *head: hlist 的頭
loff_t *ppos: 當前位置

描述

在 seq_file->op->next() 處呼叫。

只要遍歷受 rcu_read_lock() 的保護，此列表遍歷原語就可以與 _rcu 列表修改原語（例如 hlist_add_head_rcu()）安全地併發執行。

struct hlist_node *seq_hlist_start_percpu(struct hlist_head __percpu *head, int *cpu, loff_t pos)¶: 啟動一個 percpu hlist 陣列的迭代

引數

struct hlist_head __percpu *head: 指向 struct hlist_heads 的 percpu 陣列的指標
int *cpu: 指向 cpu “游標” 的指標
loff_t pos: 序列的起始位置

描述

在 seq_file->op->start() 處呼叫。

struct hlist_node *seq_hlist_next_percpu(void *v, struct hlist_head __percpu *head, int *cpu, loff_t *pos)¶: 移動到 percpu hlist 陣列的下一個位置

引數

void *v: 指向當前 hlist_node 的指標
struct hlist_head __percpu *head: 指向 struct hlist_heads 的 percpu 陣列的指標
int *cpu: 指向 cpu “游標” 的指標
loff_t *pos: 序列的起始位置

描述

在 seq_file->op->next() 處呼叫。

int register_filesystem(struct file_system_type *fs)¶: 註冊一個新的檔案系統

引數

struct file_system_type * fs

檔案系統結構

將傳遞的檔案系統新增到核心知道的用於掛載和其他系統呼叫的檔案系統列表中。成功時返回 0，錯誤時返回負 errno 程式碼。

傳遞的 struct file_system_type 連結到核心結構中，並且在檔案系統登出之前不得釋放。

int unregister_filesystem(struct file_system_type *fs)¶: 登出一個檔案系統

引數

struct file_system_type * fs

要登出的檔案系統

刪除先前已成功向核心註冊的檔案系統。如果未找到檔案系統，則返回錯誤。成功時返回零。

一旦此函式返回，struct file_system_type 結構就可以釋放或重用。

void wbc_attach_fdatawrite_inode(struct writeback_control *wbc, struct inode *inode)¶: 關聯 wbc 和 inode 以進行 fdatawrite

引數

struct writeback_control *wbc: 感興趣的 writeback_control
struct inode *inode: 目標 inode

描述

此函式由 __filemap_fdatawrite_range() 使用，它是寫入程式碼的備用入口點，並且首先確保 inode 與 bdi_writeback 關聯並將其附加到 wbc。

void wbc_detach_inode(struct writeback_control *wbc)¶: 將 wbc 與 inode 分離並執行外部檢測

引數

struct writeback_control *wbc: 剛剛完成的回寫的 writeback_control

描述

在 inode 的回寫嘗試完成後呼叫，並撤消 wbc_attach_and_unlock_inode()。可以在任何上下文中呼叫。

由於 inode 的併發寫入共享預計非常罕見，並且 memcg 僅根據首次使用情況跟蹤頁面所有權，嚴重限制了此類共享的有用性，因此 cgroup 回寫跟蹤每個 inode 的所有權。雖然對 inode 的併發寫入共享的支援被認為是不必要的，但在不同時間點由不同 cgroup 寫入 inode 更為常見，而且更重要的是，僅根據首次使用情況收費很容易導致嚴重不正確的行為（單個外部頁面可能導致千兆位元組的回寫被錯誤地歸因）。

為了解決這個問題，cgroup 回寫檢測 inode 的主要髒頁者，並將所有權轉移給它。為了避免不必要的振盪，檢測機制會跟蹤歷史記錄，並且僅當外部使用模式在一定時間內和/或回寫嘗試中保持穩定時才給出切換判斷。

在每次回寫嘗試時，wbc 嘗試使用 Boyer-Moore 多數投票演算法檢測主要寫入者。除了來自多數投票的位元組數之外，它還計算當前 wb 和上一輪獲勝者 wb 的寫入位元組數（上一輪當前 wb 的最大值、兩個輪次之前的獲勝者以及上一輪的多數候選者）。跟蹤歷史獲勝者有助於該演算法半可靠地檢測最活躍的寫入者，即使它不是絕對多數。

一旦確定了該輪的獲勝者，無論獲勝者是外部的還是否，以及該輪消耗了多少 IO 時間，都會記錄在 inode->i_wb_frn_history 中。如果記錄的外部 IO 時間量超過某個閾值，則給出切換判斷。

void wbc_account_cgroup_owner(struct writeback_control *wbc, struct folio *folio, size_t bytes)¶: 記賬回寫以更新 inode cgroup 所有權

引數

struct writeback_control *wbc: 正在進行的回寫的 writeback_control
struct folio *folio: 正在寫出的 folio
size_t bytes: 正在寫出的位元組數

描述

來自 folio 的 bytes 將要在由 wbc 控制的回寫期間寫出。保留外部 inode 檢測的賬本。請參閱 wbc_detach_inode()。

void __mark_inode_dirty(struct inode *inode, int flags)¶: 用於將 inode 標記為髒的內部函式

引數

struct inode *inode: 要標記的 inode
int flags: 什麼樣的髒，例如 I_DIRTY_SYNC。這可以是多個 I_DIRTY_* 標誌的組合，但 I_DIRTY_TIME 不能與 I_DIRTY_PAGES 組合。

描述

將 inode 標記為髒。我們通知檔案系統，然後更新 inode 的髒標誌。然後，如果需要，我們將 inode 新增到相應的髒列表中。

大多數呼叫者應使用 mark_inode_dirty() 或 mark_inode_dirty_sync() 而不是直接呼叫此函式。

小心！我們僅在 inode 被雜湊或引用 blockdev 時才將其新增到髒列表中。未雜湊的 inode 永遠不會被新增到髒列表中，即使它們稍後被雜湊，因為它們已經被標記為髒。

簡而言之，請確保在開始將任何 inode 標記為髒_之前_對其進行雜湊。

請注意，對於 blockdev，inode->dirtied_when 表示塊特殊 inode (/dev/hda1) 本身的髒時間。核心內部 blockdev inode 的 ->dirtied_when 欄位表示 blockdev 頁面的髒時間。這就是為什麼對於 I_DIRTY_PAGES，我們總是使用 page->mapping->host，因此頁面髒時間記錄在內部 blockdev inode 中。

void writeback_inodes_sb_nr(struct super_block *sb, unsigned long nr, enum wb_reason reason)¶: 從給定的超級塊回寫髒 inode

引數

struct super_block *sb: 超級塊
unsigned long nr: 要寫入的頁面數
enum wb_reason reason: 啟動某些回寫工作的原因

描述

在此超級塊上啟動某些 inode 的回寫。不保證將寫入多少（如果有的話），並且此函式不會等待提交 IO 的 IO 完成。

void writeback_inodes_sb(struct super_block *sb, enum wb_reason reason)¶: 從給定的超級塊回寫髒 inode

引數

struct super_block *sb: 超級塊
enum wb_reason reason: 啟動某些回寫工作的原因

描述

在此超級塊上啟動某些 inode 的回寫。不保證將寫入多少（如果有的話），並且此函式不會等待提交 IO 的 IO 完成。

void try_to_writeback_inodes_sb(struct super_block *sb, enum wb_reason reason)¶: 如果沒有正在進行的回寫，則嘗試啟動回寫

引數

struct super_block *sb: 超級塊
enum wb_reason reason: 啟動某些回寫工作的原因

描述

如果沒有正在進行的回寫，則呼叫 __writeback_inodes_sb_nr。

void sync_inodes_sb(struct super_block *sb)¶: 同步 sb inode 頁面

引數

struct super_block *sb: 超級塊

描述

此函式寫入並等待屬於此超級塊的任何髒 inode。

int write_inode_now(struct inode *inode, int sync)¶: 將 inode 寫入磁碟

引數

struct inode *inode: 要寫入磁碟的 inode
int sync: 寫入是否應該是同步的

描述

如果 inode 是髒的，此函式會立即將其提交到磁碟。這主要是 knfsd 所需的。

呼叫者必須對 inode 具有引用，或者必須已設定 I_WILL_FREE。

int sync_inode_metadata(struct inode *inode, int wait)¶: 將 inode 寫入磁碟

引數

struct inode *inode: 要同步的 inode
int wait: 等待 I/O 完成。

描述

將 inode 寫入磁碟並在完成後調整其髒狀態。

注意

僅寫入實際的 inode，不寫入任何關聯的資料或其他元資料。

struct file *anon_inode_getfile(const char *name, const struct file_operations *fops, void *priv, int flags)¶: 透過將其連線到匿名 inode 和描述檔案“類”的 dentry 來建立一個新的檔案例項

引數

const char *name: [in] 新檔案“類”的名稱
const struct file_operations *fops: [in] 新檔案的檔案操作
void *priv: [in] 新檔案的私有資料（將是檔案的 private_data）
int flags: [in] 標誌

描述

透過將其連線到單個 inode 來建立一個新檔案。這對於不需要具有完整的 inode 才能正確操作的檔案非常有用。所有使用 anon_inode_getfile() 建立的檔案將共享單個 inode，從而節省記憶體並避免檔案/inode/dentry 設定的程式碼重複。返回新建立的 file* 或錯誤指標。

struct file *anon_inode_getfile_fmode(const char *name, const struct file_operations *fops, void *priv, int flags, fmode_t f_mode)¶: 透過將其連線到匿名 inode 和描述檔案“類”的 dentry 來建立一個新的檔案例項

引數

const char *name: [in] 新檔案“類”的名稱
const struct file_operations *fops: [in] 新檔案的檔案操作
void *priv: [in] 新檔案的私有資料（將是檔案的 private_data）
int flags: [in] 標誌
fmode_t f_mode: [in] fmode

描述

透過將其連線到單個 inode 來建立一個新檔案。這對於不需要具有完整的 inode 才能正確操作的檔案非常有用。所有使用 anon_inode_getfile() 建立的檔案將共享單個 inode，從而節省記憶體並避免檔案/inode/dentry 設定的程式碼重複。允許設定 fmode。返回新建立的 file* 或錯誤指標。

struct file *anon_inode_create_getfile(const char *name, const struct file_operations *fops, void *priv, int flags, const struct inode *context_inode)¶: 類似於 anon_inode_getfile()，但會建立一個新的 !S_PRIVATE 匿名 inode，而不是重用單例匿名 inode，並呼叫 inode_init_security_anon() LSM 鉤子。

引數

const char *name: [in] 新檔案“類”的名稱
const struct file_operations *fops: [in] 新檔案的檔案操作
void *priv: [in] 新檔案的私有資料（將是檔案的 private_data）
int flags: [in] 標誌
const struct inode *context_inode: [in] 與新 inode 的邏輯關係（可選）

描述

建立新的匿名 inode 和檔案對。這可以出於兩個原因完成

為了使 inode 具有自己的安全上下文，以便 LSM 可以強制執行對 inode 建立的策略；
如果呼叫者需要唯一的 inode，例如為了自定義 fstat() 返回的大小

LSM 可能會在 inode_init_security_anon() 中使用 context_inode，但不會持有對它的引用。

返回新建立的 file* 或錯誤指標。

int anon_inode_getfd(const char *name, const struct file_operations *fops, void *priv, int flags)¶: 透過將其連線到匿名 inode 和描述檔案“類”的 dentry 來建立新的檔案例項

引數

const char *name: [in] 新檔案“類”的名稱
const struct file_operations *fops: [in] 新檔案的檔案操作
void *priv: [in] 新檔案的私有資料（將是檔案的 private_data）
int flags: [in] 標誌

描述

透過將其連線到單個 inode 來建立新檔案。這對於不需要具有完整 inode 才能正確操作的檔案很有用。使用 anon_inode_getfd() 建立的所有檔案將使用相同的單例 inode，從而減少記憶體使用並避免檔案/inode/dentry 設定的程式碼重複。返回新建立的檔案描述符或錯誤程式碼。

int setattr_should_drop_sgid(struct mnt_idmap *idmap, const struct inode *inode)¶: 確定是否需要刪除 setgid 位

引數

struct mnt_idmap *idmap: 從 inode 中找到的掛載的 idmap
const struct inode *inode: 要檢查的 inode

描述

此函式確定是否需要刪除 setgid 位。我們保留向後相容性，並且如果設定了 S_IXGRP，則需要無條件刪除 setgid 位。否則，我們具有與 setattr_prepare() 和 setattr_copy() 完全相同的要求。

返回

如果需要刪除 setgid 位，則為 ATTR_KILL_SGID，否則為 0。

int setattr_should_drop_suidgid(struct mnt_idmap *idmap, struct inode *inode)¶: 確定是否需要刪除 set{g,u}id 位

引數

struct mnt_idmap *idmap: 從 inode 中找到的掛載的 idmap
struct inode *inode: 要檢查的 inode

描述

此函式確定是否需要刪除 set{g,u}id 位。如果需要刪除 setuid 位，則返回 ATTR_KILL_SUID。如果需要刪除 setgid 位，則返回 ATTR_KILL_SGID。如果需要刪除 set{g,u}id 位，則返回兩個標誌的相應掩碼。

返回

指示要刪除哪些 setid 位（如果有）的 ATTR_KILL_S{G,U}ID 的掩碼，否則為 0。

int setattr_prepare(struct mnt_idmap *idmap, struct dentry *dentry, struct iattr *attr)¶: 檢查是否允許更改 dentry 的屬性

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
struct dentry *dentry: 要檢查的 dentry
struct iattr *attr: 要更改的屬性

描述

檢查是否允許更改給定 dentry 中包含在 attr 中的屬性。這包括正常的 unix 訪問許可權檢查，以及對 rlimit 和其他內容的檢查。如果使用者無權設定 SGID 位，該函式還會從模式中清除該位。如果設定了 ATTR_KILL_PRIV，還會清除檔案功能和 IMA 擴充套件屬性。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

應在 ->setattr 實現中作為第一件事呼叫，可能在獲取其他鎖之後。

int inode_newsize_ok(const struct inode *inode, loff_t offset)¶: 是否可以將此 inode 截斷為給定大小

引數

const struct inode *inode: 要截斷的 inode
loff_t offset: 要分配給 inode 的新大小

描述

必須在持有 i_mutex 的情況下呼叫 inode_newsize_ok。

inode_newsize_ok 將檢查檔案系統限制和 ulimit，以檢查新的 inode 大小是否在限制範圍內。inode_newsize_ok 還將在必要時傳送 SIGXFSZ。如果返回失敗，呼叫者不得繼續進行 inode 大小更改。inode 必須是檔案（而不是目錄），並且具有允許截斷的適當許可權（inode_newsize_ok 不檢查這些條件）。

返回

成功時為 0，失敗時為 -ve errno

void setattr_copy(struct mnt_idmap *idmap, struct inode *inode, const struct iattr *attr)¶: 將簡單的元資料更新複製到通用 inode 中

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
struct inode *inode: 要更新的 inode
const struct iattr *attr: 新屬性

描述

必須在持有 i_mutex 的情況下呼叫 setattr_copy。

setattr_copy 使用 attr 中指定的元資料更新 idmapped 掛載上的 inode 元資料。使用正確的 idmapped 掛載許可權助手執行必要的許可權檢查，以確定是否需要刪除 S_ISGID 屬性。明顯缺少的是 inode 大小更新，因為它需要更復雜的 pagecache 更新。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

此操作後，inode 不會標記為髒。理由是對於“簡單”檔案系統，struct inode 是 inode 儲存。如果需要，呼叫者可以隨意在之後將 inode 標記為髒。

int notify_change(struct mnt_idmap *idmap, struct dentry *dentry, struct iattr *attr, struct inode **delegated_inode)¶: 修改檔案系統物件的屬性

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
struct dentry *dentry: 受影響的物件
struct iattr *attr: 新屬性
struct inode **delegated_inode: 如果 inode 已委託，則返回 inode

描述

呼叫者必須持有受影響物件上的 i_mutex。

如果 notify_change 發現需要中斷的委託，它將返回 -EWOULDBLOCK 並在 delegated_inode 中返回對 inode 的引用。然後，呼叫者應中斷委託並重試。由於中斷委託可能需要很長時間，因此呼叫者應在執行此操作之前釋放 i_mutex。

或者，呼叫者可以為 delegated_inode 傳遞 NULL。這可能適用於期望底層檔案系統未匯出 NFS 的呼叫者。此外，對於為寫入開啟檔案的呼叫者來說，傳遞 NULL 是可以的，因為在這種情況下不可能存在衝突的委託。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

char *d_path(const struct path *path, char *buf, int buflen)¶: 返回 dentry 的路徑

引數

const struct path *path: 要報告的路徑
char *buf: 用於在其中返回值的緩衝區
int buflen: 緩衝區長度

描述

將 dentry 轉換為 ASCII 路徑名。如果條目已被刪除，則會附加字串“ (已刪除)”。請注意，這不明確。

如果路徑太長，則返回指向緩衝區中的指標或錯誤程式碼。注意：呼叫者應使用返回的指標，而不是傳入的緩衝區，來使用名稱！該實現通常從緩衝區中的偏移量開始，並且可能會在開頭留下 0 個位元組。

“buflen”應為正數。

struct page *dax_layout_busy_page_range(struct address_space *mapping, loff_t start, loff_t end)¶: 在 mapping 中查詢第一個固定的頁面

引數

struct address_space *mapping: 要掃描引用計數 > 1 的頁面的地址空間
loff_t start: 起始偏移量。包含“start”的頁面包含在內。
loff_t end: 結束偏移量。包含“end”的頁面包含在內。如果“end”為 LLONG_MAX，則包含從“start”到檔案結尾的頁面。

描述

DAX 需要 ZONE_DEVICE 對映的頁面。這些頁面從未“聯機”到頁面分配器，因此當 page->count == 1 時，它們被認為是空閒的。檔案系統使用此介面來確定對映中的任何頁面是否繁忙，即用於 DMA 或其他 get_user_pages() 用法。

預期檔案系統持有鎖以阻止在此 address_space 中建立新對映。即，它期望能夠執行 unmap_mapping_range()，隨後不會競爭 mapping_mapped() 變為 true。

ssize_t dax_iomap_rw(struct kiocb *iocb, struct iov_iter *iter, const struct iomap_ops *ops)¶: 對 DAX 檔案執行 I/O

引數

struct kiocb *iocb: 此 I/O 的控制塊
struct iov_iter *iter: 從或向其執行 I/O 的地址
const struct iomap_ops *ops: 從檔案系統傳遞的 iomap ops

描述

此函式對直接對映的持久記憶體執行讀取和寫入操作。呼叫者需要注意讀取/寫入排除以及驅逐 I/O 下區域中的任何頁面快取頁面。

vm_fault_t dax_iomap_fault(struct vm_fault *vmf, unsigned int order, pfn_t *pfnp, int *iomap_errp, const struct iomap_ops *ops)¶: 處理 DAX 檔案上的頁面錯誤

引數

struct vm_fault *vmf: 錯誤的描述
unsigned int order: 要錯誤獲取的頁面的順序
pfn_t *pfnp: 如果需要 fsync，則為同步錯誤的要插入的 PFN
int *iomap_errp: 用於在發生錯誤時儲存詳細錯誤程式碼的儲存
const struct iomap_ops *ops: 從檔案系統傳遞的 Iomap ops

描述

發生頁面錯誤時，檔案系統可能會在其 DAX 檔案的錯誤處理程式中呼叫此幫助程式。dax_iomap_fault() 假定呼叫者已完成所有必要的鎖定，以便頁面錯誤成功進行。

vm_fault_t dax_finish_sync_fault(struct vm_fault *vmf, unsigned int order, pfn_t pfn)¶: 完成同步頁面錯誤

引數

struct vm_fault *vmf: 錯誤的描述
unsigned int order: 要插入的條目的順序
pfn_t pfn: 要插入的 PFN

描述

此函式確保頁面錯誤觸及的檔案範圍持久儲存在介質上，並處理插入適當的頁表條目。

void simple_rename_timestamp(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry)¶: 更新重新命名的各種 inode 時間戳

引數

struct inode *old_dir: 舊的父目錄
struct dentry *old_dentry: 正在重新命名的 dentry
struct inode *new_dir: 新的父目錄
struct dentry *new_dentry: 重新命名的目標

描述

POSIX 規定舊的和新的父目錄都需要更新其 ctime 和 mtime，並且 old_dentry 和 new_dentry 的 inode（如果有）需要更新其 ctime。

int simple_setattr(struct mnt_idmap *idmap, struct dentry *dentry, struct iattr *iattr)¶: 為簡單檔案系統設定屬性

引數

struct mnt_idmap *idmap: 目標掛載的idmap
struct dentry *dentry: 目錄項（dentry）
struct iattr *iattr: iattr 結構體

描述

成功時返回 0，失敗時返回 -error。

simple_setattr 是一個簡單的 ->setattr 實現，沒有正確實現大小更改。

它既可以用於記憶體檔案系統，也可以用於簡單常規檔案系統上的特殊檔案。任何需要在大小更改時更改磁碟上或網路狀態的內容都需要自己的 setattr 方法。

ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos, const void *from, size_t available)¶: 將資料從緩衝區複製到使用者空間

引數

void __user *to: 要讀取到的使用者空間緩衝區
size_t count: 要讀取的最大位元組數
loff_t *ppos: 緩衝區中的當前位置
const void *from: 要從中讀取的緩衝區
size_t available: 緩衝區的大小

描述

simple_read_from_buffer() 函式從 from 緩衝區的 ppos 偏移量處讀取最多 count 個位元組到從 to 開始的使用者空間地址。

成功時，返回讀取的位元組數，並且偏移量 ppos 會增加此數字；出錯時，返回負值。

ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos, const void __user *from, size_t count)¶: 將資料從使用者空間複製到緩衝區

引數

void *to: 要寫入的緩衝區
size_t available: 緩衝區的大小
loff_t *ppos: 緩衝區中的當前位置
const void __user *from: 要從中讀取的使用者空間緩衝區
size_t count: 要讀取的最大位元組數

描述

simple_write_to_buffer() 函式從 from 開始的使用者空間地址讀取最多 count 個位元組到 to 緩衝區中的 ppos 偏移量處。

成功時，返回寫入的位元組數，並且偏移量 ppos 會增加此數字；出錯時，返回負值。

ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos, const void *from, size_t available)¶: 從緩衝區複製資料

引數

void *to: 要讀取到的核心空間緩衝區
size_t count: 要讀取的最大位元組數
loff_t *ppos: 緩衝區中的當前位置
const void *from: 要從中讀取的緩衝區
size_t available: 緩衝區的大小

描述

memory_read_from_buffer() 函式從 from 緩衝區的 ppos 偏移量處讀取最多 count 個位元組到從 to 開始的核心空間地址。

成功時，返回讀取的位元組數，並且偏移量 ppos 會增加此數字；出錯時，返回負值。

int generic_encode_ino32_fh(struct inode *inode, __u32 *fh, int *max_len, struct inode *parent)¶: 通用的 export_operations->encode_fh 函式

引數

struct inode *inode: 要編碼的物件
__u32 *fh: 檔案控制代碼片段的儲存位置
int *max_len: 儲存的最大長度（以 4 位元組為單位）
struct inode *parent: 父目錄 inode（如果需要）

描述

此通用 encode_fh 函式假定 32 位 inode 編號適合用於定位 inode，並且可以使用生成號來檢查它是否仍然有效。它將它們放置在 export_decode_fh 期望找到它們的 filehandle 片段中。

struct dentry *generic_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, int fh_type, struct inode *(*get_inode)(struct super_block *sb, u64 ino, u32 gen))¶: fh_to_dentry 匯出操作的通用助手函式

引數

struct super_block *sb: 要在其上執行檔案控制代碼轉換的檔案系統
struct fid *fid: 要轉換的檔案控制代碼
int fh_len: 檔案控制代碼的長度（以位元組為單位）
int fh_type: 檔案控制代碼的型別
struct inode *(*get_inode) (struct super_block *sb, u64 ino, u32 gen): 檔案系統回撥，用於檢索 inode

描述

只要 fid 具有已知的 Linux 檔案控制代碼型別之一，此函式就會解碼 fid，並在其上呼叫 get_inode 以檢索檔案控制代碼中指定的物件的 inode。

struct dentry *generic_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, int fh_type, struct inode *(*get_inode)(struct super_block *sb, u64 ino, u32 gen))¶: fh_to_parent 匯出操作的通用助手函式

引數

struct super_block *sb: 要在其上執行檔案控制代碼轉換的檔案系統
struct fid *fid: 要轉換的檔案控制代碼
int fh_len: 檔案控制代碼的長度（以位元組為單位）
int fh_type: 檔案控制代碼的型別
struct inode *(*get_inode) (struct super_block *sb, u64 ino, u32 gen): 檔案系統回撥，用於檢索 inode

描述

只要 fid 具有已知的 Linux 檔案控制代碼型別之一，此函式就會解碼 fid，並在其上呼叫 get_inode 以檢索檔案控制代碼中指定的 _parent_ 物件的 inode（如果在檔案控制代碼中指定），否則返回 NULL。

int __generic_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)¶: 簡單檔案系統的通用 fsync 實現

引數

struct file *file: 要同步的檔案
loff_t start: 起始偏移量（以位元組為單位）
loff_t end: 結束偏移量（包含）
int datasync: 如果為 true，則僅同步基本元資料

描述

這是簡單檔案系統的 fsync 方法的通用實現，它在 address_space 結構掛起的緩衝區列表中跟蹤所有非 inode 元資料。

int generic_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)¶: 帶有 flush 的簡單檔案系統的通用 fsync 實現

引數

struct file *file: 要同步的檔案
loff_t start: 起始偏移量（以位元組為單位）
loff_t end: 結束偏移量（包含）
int datasync: 如果為 true，則僅同步基本元資料

int generic_check_addressable(unsigned blocksize_bits, u64 num_blocks)¶: 檢查檔案系統的可定址性

引數

unsigned blocksize_bits: 檔案系統塊大小的對數
u64 num_blocks: 檔案系統中的塊數

描述

確定具有 num_blocks 個塊（以及 2****blocksize_bits** 的塊大小）的檔案系統是否可由系統的 sector_t 和頁面快取定址。如果是，則返回 0；否則返回 -EFBIG。

int simple_nosetlease(struct file *filp, int arg, struct file_lease **flp, void **priv)¶: 禁止租約的通用助手函式

引數

struct file *filp: 檔案指標
int arg: 要獲得的租約的型別
struct file_lease **flp: 提供插入的新租約
void **priv: lm_setup 操作的私有資料

描述

用於不希望允許設定租約的檔案系統的通用助手函式。所有引數都將被忽略，它只返回 -EINVAL。

const char *simple_get_link(struct dentry *dentry, struct inode *inode, struct delayed_call *done)¶: 用於獲取“快速”符號連結目標的通用助手函式

引數

struct dentry *dentry: 此處未使用
struct inode *inode: 符號連結 inode
struct delayed_call *done: 此處未使用

描述

用於檔案系統的通用助手函式，用於符號連結 inode，其中指向符號連結目標的指標儲存在 ->i_link 中。注意：這通常不會被呼叫，因為作為一種最佳化，路徑查詢程式碼直接使用任何非 NULL ->i_link，而不呼叫 ->get_link()。但是 ->get_link() 仍然必須設定，以將 inode_operations 標記為用於符號連結。

返回

符號連結目標

int generic_ci_d_compare(const struct dentry *dentry, unsigned int len, const char *str, const struct qstr *name)¶: 區分大小寫的檔案系統的通用 d_compare 實現

引數

const struct dentry *dentry: 要檢查其名稱的目錄項
unsigned int len: 目錄項名稱的長度
const char *str: 指向目錄項名稱的 str 指標
const struct qstr *name: 要比較的名稱

返回

如果名稱匹配，則為 0；如果名稱不匹配，則為 1；或者為 -ERRNO

int generic_ci_d_hash(const struct dentry *dentry, struct qstr *str)¶: 區分大小寫的檔案系統的通用 d_hash 實現

引數

const struct dentry *dentry: 父目錄的目錄項
struct qstr *str: 需要填充雜湊值的名稱的 qstr

返回

如果雜湊成功或未更改，則為 0；如果發生錯誤，則為 -EINVAL

int generic_ci_match(const struct inode *parent, const struct qstr *name, const struct qstr *folded_name, const u8 *de_name, u32 de_name_len)¶: 將名稱（不區分大小寫）與目錄項進行匹配。這是用於與目錄條目進行比較的檔案系統輔助函式。在 VFS 的 ->d_compare 中應使用 generic_ci_d_compare。

引數

const struct inode *parent: 正在比較的目錄項的父 inode
const struct qstr *name: 查詢下的名稱。
const struct qstr *folded_name: 查詢下可選的預摺疊名稱
const u8 *de_name: 目錄項名稱。
u32 de_name_len: 目錄項名稱長度。

描述

測試不區分大小寫的目錄項是否與正在搜尋的檔名匹配。如果提供了 folded_name，則使用它而不是重新計算 name 的 casefold。

返回

> 如果目錄項匹配，則為 0；如果不匹配，則為 0；如果出錯，則 < 0。

void generic_set_sb_d_ops(struct super_block *sb)¶: 用於為已啟用的特性選擇檔案系統範圍的目錄項操作集的輔助函式

引數

struct super_block *sb: 要配置的超級塊

描述

支援 casefolding 和/或 fscrypt 的檔案系統可以在掛載時呼叫此輔助函式，以配置 sb->s_d_op 為已啟用特性所需的最佳目錄項操作集。必須在配置這些特性之後，但在建立根目錄項之前呼叫此輔助函式。

bool inode_maybe_inc_iversion(struct inode *inode, bool force)¶: 遞增 i_version

引數

struct inode *inode: 帶有應更新的 i_version 的 inode
bool force: 即使沒有必要，也要遞增計數器？

描述

每次修改 inode 時，任何觀察者都必須看到 i_version 欄位已更改。

如果設定了“force”或設定了 QUERIED 標誌，則確保我們遞增該值並清除 queried 標誌。

在未設定兩者的一般情況下，我們可以返回“false”而不更新 i_version。

如果此函式返回 false 並且沒有其他元資料已更改，則我們可以避免記錄元資料。

u64 inode_query_iversion(struct inode *inode)¶: 讀取 i_version 以供以後使用

引數

struct inode *inode: 從中讀取 i_version 的 inode

描述

讀取 inode i_version 計數器。希望儲存返回的 i_version 以供以後比較的呼叫方應使用此計數器。這將保證如果任何內容發生更改，則以後對 i_version 的查詢將產生不同的值。

在此實現中，我們獲取當前值，設定 QUERIED 標誌，然後嘗試使用 cmpxchg 將其交換到位，如果尚未設定。如果失敗，我們將使用來自 cmpxchg 的新獲取的值重試。

struct timespec64 simple_inode_init_ts(struct inode *inode)¶: 初始化新 inode 的時間戳

引數

struct inode *inode: 要初始化的 inode

描述

建立新 inode 時，大多數檔案系統會將時間戳設定為當前時間。新增一個輔助函式來執行此操作。

int posix_acl_chmod(struct mnt_idmap *idmap, struct dentry *dentry, umode_t mode)¶: chmod 一個 posix acl

引數

struct mnt_idmap *idmap: 從 inode 中找到的掛載的 idmap
struct dentry *dentry: 在其上檢查許可權的 dentry
umode_t mode: inode 的新模式

描述

如果透過 idmapped 掛載找到了該目錄項，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

int posix_acl_update_mode(struct mnt_idmap *idmap, struct inode *inode, umode_t *mode_p, struct posix_acl **acl)¶: 更新 set_acl 中的模式

引數

struct mnt_idmap *idmap: 從 inode 中找到的掛載的 idmap
struct inode *inode: 目標 inode
umode_t *mode_p: 用於更新的模式（指標）
struct posix_acl **acl: acl 指標

描述

設定 ACL 時更新檔案模式：基於 ACL 計算新的檔案許可權位。此外，如果 ACL 等效於新的檔案模式，則將 *acl 設定為 NULL，以指示不應設定任何 ACL。

與 chmod 一樣，如果呼叫方不在擁有的組中，或者沒有 CAP_FSETID 的功能，則清除 setgid 位（請參閱 inode_change_ok）。

如果 inode 是透過 idmapped 掛載找到的，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再檢查許可權。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

從 set_acl inode 操作呼叫。

struct posix_acl *posix_acl_from_xattr(struct user_namespace *userns, const void *value, size_t size)¶: 將 POSIX ACL 從後備儲存轉換為 VFS 格式

引數

struct user_namespace *userns: 檔案系統的 idmapping
const void *value: POSIX ACL 的 uapi 表示形式
size_t size: void 的大小

描述

以未更改的 uapi 格式儲存 POSIX ACL 的檔案系統應在從後備儲存讀取 POSIX ACL 並將其轉換為 struct posix_acl VFS 格式時使用 posix_acl_from_xattr()。該輔助函式專門用於從 acl inode 操作中呼叫。

posix_acl_from_xattr() 函式會將儲存在 ACL_{GROUP,USER} 條目中的原始 {g,u}id 值對映到 userns 中的 idmapping。

請注意，posix_acl_from_xattr() 不考慮 idmapped 掛載。如果考慮了，則從 get acl inode 操作呼叫它將返回根據 idmapped 掛載對映的 POSIX ACL，這意味著該值無法為檔案系統快取。Idmapped 掛載在許可權檢查期間或在將它們報告給使用者之前就在 VFS - 使用者空間邊界上動態考慮。

返回

成功時分配的 struct posix_acl，對於有效的標頭為 NULL，但: 沒有實際的 POSIX ACL 條目，或 ERR_PTR() 編碼的錯誤程式碼。

int vfs_set_acl(struct mnt_idmap *idmap, struct dentry *dentry, const char *acl_name, struct posix_acl *kacl)¶: 設定 posix acls

引數

struct mnt_idmap *idmap: 掛載的 idmap
struct dentry *dentry: 在其上設定 posix acls 的 dentry
const char *acl_name: posix acl 的名稱
struct posix_acl *kacl: 採用適當 VFS 格式的 posix acls

描述

此函式設定 kacl。呼叫方必須在此後對 kacl 呼叫 posix_acl_release()。

返回

成功時為 0，出錯時為負 errno。

struct posix_acl *vfs_get_acl(struct mnt_idmap *idmap, struct dentry *dentry, const char *acl_name)¶: 獲取 posix acls

引數

struct mnt_idmap *idmap: 掛載的 idmap
struct dentry *dentry: 在其上檢索 posix acls 的 dentry
const char *acl_name: posix acl 的名稱

描述

此函式從檔案系統檢索 kacl。呼叫方必須對 kacl 呼叫 posix_acl_release()。

返回

成功時為 VFS 格式的 POSIX ACL，出錯時為負 errno。

int vfs_remove_acl(struct mnt_idmap *idmap, struct dentry *dentry, const char *acl_name)¶: 刪除 posix acls

引數

struct mnt_idmap *idmap: 掛載的 idmap
struct dentry *dentry: 在其上檢索 posix acls 的 dentry
const char *acl_name: posix acl 的名稱

描述

此函式刪除 posix acls。

返回

成功時為 0，出錯時為負 errno。

void fill_mg_cmtime(struct kstat *stat, u32 request_mask, struct inode *inode)¶: 填充 mtime 和 ctime 並將 ctime 標記為 QUERIED

引數

struct kstat *stat: 在何處儲存結果值
u32 request_mask: 請求的 STATX_* 值
struct inode *inode: 從中抓取 c/mtime 的 inode

描述

給定 inode，如果存在，則從中抓取 ctime 和 mtime，並將結果儲存在 stat 中。在獲取該值時，將其標記為 QUERIED（如果尚未標記），以便下次寫入將記錄不同的時間戳。

注意：QUERIED 標誌在 ctime 中進行跟蹤，但即使僅請求了 mtime，我們也會在此處設定它，因為這可以確保下次 mtime 更改將是不同的。

void generic_fillattr(struct mnt_idmap *idmap, u32 request_mask, struct inode *inode, struct kstat *stat)¶: 從 inode 結構填充基本屬性

引數

struct mnt_idmap *idmap: 找到 inode 的掛載點的 idmap
u32 request_mask: statx request_mask
struct inode *inode: 用作源的 Inode
struct kstat *stat: 在何處填充屬性

描述

從 VFS inode 結構上可以找到的資料填充 kstat 結構中的基本屬性。如果沒有提供 getattr inode 操作，則這是預設值。

如果透過 idmapped 掛載找到了該 inode，則必須透過 idmap 傳遞 vfsmount 的 idmap。然後，此函式將負責根據 idmap 對映 inode，然後再填充 uid 和 gid filds。在非 idmapped 掛載上，或者如果要在原始 inode 上執行許可權檢查，只需傳遞 nop_mnt_idmap。

void generic_fill_statx_attr(struct inode *inode, struct kstat *stat)¶: 從 inode 標誌填充 statx 屬性

引數

struct inode *inode: 用作源的 Inode
struct kstat *stat: 在何處填充屬性標誌

描述

填充 kstat 結構中的 STATX_ATTR_* 標誌，以表示在 i_flags 上釋出並由 VFS 強制執行的 inode 的屬性。

void generic_fill_statx_atomic_writes(struct kstat *stat, unsigned int unit_min, unsigned int unit_max, unsigned int unit_max_opt)¶: 填充原子寫入 statx 屬性

引數

struct kstat *stat: 在何處填充屬性標誌
unsigned int unit_min: 支援的最小原子寫入長度（以位元組為單位）
unsigned int unit_max: 支援的最大原子寫入長度（以位元組為單位）
unsigned int unit_max_opt: 最佳化的最大支援原子寫入長度（以位元組為單位）

描述

從原子寫入 unit_min 和 unit_max 值填充 kstat 結構中的 STATX{_ATTR}_WRITE_ATOMIC 標誌。

int vfs_getattr_nosec(const struct path *path, struct kstat *stat, u32 request_mask, unsigned int query_flags)¶: 獲取屬性但不進行安全檢查

引數

const struct path *path: 從中獲取屬性的檔案
struct kstat *stat: 用於返回屬性的結構
u32 request_mask: 指示呼叫者需要什麼的STATX_xxx 標誌
unsigned int query_flags: 查詢模式 (AT_STATX_SYNC_TYPE)

描述

獲取屬性而不呼叫 security_inode_getattr。

目前，除了 vfs_getattr 之外，唯一的呼叫者是檔案控制代碼查詢程式碼內部，它僅使用 inode 編號，不向任何使用者返回任何屬性。任何其他程式碼可能需要 vfs_getattr。

int vfs_fsync_range(struct file *file, loff_t start, loff_t end, int datasync)¶: 用於將一定範圍的資料和元資料同步到磁碟的輔助函式

引數

struct file *file: 要同步的檔案
loff_t start: 要同步的資料範圍起點的位元組偏移量
loff_t end: 資料範圍終點的位元組偏移量（包含）
int datasync: 僅執行 datasync

描述

將範圍 **start**..**end** 中的資料和 **file** 的元資料寫回磁碟。如果設定了 **datasync**，則僅寫入訪問修改的檔案資料所需的元資料。

int vfs_fsync(struct file *file, int datasync)¶: 對檔案執行 fsync 或 fdatasync

引數

struct file *file: 要同步的檔案
int datasync: 僅執行 fdatasync 操作

描述

將 **file** 的資料和元資料寫回磁碟。如果設定了 **datasync**，則僅寫入訪問修改的檔案資料所需的元資料。

int __vfs_setxattr_locked(struct mnt_idmap *idmap, struct dentry *dentry, const char *name, const void *value, size_t size, int flags, struct inode **delegated_inode)¶: 在持有 inode 鎖時設定擴充套件屬性

引數

struct mnt_idmap *idmap: 目標 inode 的掛載的 idmap
struct dentry *dentry: 要在其上執行 setxattr 的物件
const char *name: 要設定的 xattr 名稱
const void *value: 要將 **name** 設定為的值
size_t size: **value** 的大小
int flags: 要傳遞到檔案系統操作的標誌
struct inode **delegated_inode: 返回時，將包含一個委派被破壞的 inode 指標，如果沒有，則為 NULL。

ssize_t vfs_listxattr(struct dentry *dentry, char *list, size_t size)¶: 檢索 0 分隔的 xattr 名稱列表

引數

struct dentry *dentry: 從中檢索 xattr 名稱的 inode 的 dentry
char *list: 用於儲存 xattr 名稱的緩衝區
size_t size: 緩衝區的大小

描述

此函式返回與 **dentry** 的 inode 關聯的所有 xattr 的名稱。

請注意，由於歷史原因，vfs_listxattr() 函式也列出了 POSIX ACL。由於 POSIX ACL 與 IOP_XATTR 解耦，因此 vfs_listxattr() 函式不檢查此標誌，因為檔案系統可以在不實現任何其他 xattr 的情況下實現 POSIX ACL。

但是，由於所有刪除 IOP_XATTR 的程式碼路徑也分配了不實現或實現存根 ->listxattr() 操作的 inode 操作。

返回

成功時，使用緩衝區的位元組大小。出錯時，返回一個: 負錯誤程式碼。

int __vfs_removexattr_locked(struct mnt_idmap *idmap, struct dentry *dentry, const char *name, struct inode **delegated_inode)¶: 在持有 inode 鎖時設定擴充套件屬性

引數

struct mnt_idmap *idmap: 目標 inode 的掛載的 idmap
struct dentry *dentry: 要在其上執行 setxattr 的物件
const char *name: 要刪除的 xattr 的名稱
struct inode **delegated_inode: 返回時，將包含一個委派被破壞的 inode 指標，如果沒有，則為 NULL。

ssize_t generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)¶: 執行透過 dentry 的 xattr list() 操作

引數

struct dentry *dentry: 要列出 xattr 的 dentry
char *buffer: 結果緩衝區
size_t buffer_size: **buffer** 的大小

描述

合併來自 xattr_handler 堆疊中每個 xattr_handler 的 list() 操作的結果。

請注意，這不包括 POSIX ACL 的條目。

const char *xattr_full_name(const struct xattr_handler *handler, const char *name)¶: 從字尾計算完整屬性名稱

引數

const struct xattr_handler *handler: xattr_handler 操作的處理程式
const char *name: 傳遞給 xattr_handler 操作的名稱

描述

get 和 set xattr 處理程式操作在跳過處理程式的字首後，使用屬性名稱的其餘部分呼叫：例如，“foo”傳遞給具有字首“user.”的處理程式的 get 操作，以獲取屬性“user.foo”。完整名稱仍然在名稱中“存在”。

注意

當從 vfs 呼叫時，list xattr 處理程式操作會傳遞一個 NULL 名稱；一些檔案系統在內部使用此操作，語義各不相同。

int mnt_get_write_access(struct vfsmount *m)¶: 獲取對掛載的寫入許可權，沒有凍結保護

引數

struct vfsmount *m: 要在其上進行寫入的掛載

描述

這告訴底層檔案系統即將對其執行寫入操作，並確保允許寫入（mnt 是讀寫），然後才返回成功。此操作不防止檔案系統被凍結。寫入操作完成後，必須呼叫 mnt_put_write_access()。這實際上是一個引用計數。

int mnt_want_write(struct vfsmount *m)¶: 獲取對掛載的寫入許可權

引數

struct vfsmount *m: 要在其上進行寫入的掛載

描述

這告訴底層檔案系統即將對其執行寫入操作，並確保允許寫入（掛載是讀寫，檔案系統未凍結），然後才返回成功。寫入操作完成後，必須呼叫 mnt_drop_write()。這實際上是一個引用計數。

int mnt_want_write_file(struct file *file)¶: 獲取對檔案掛載的寫入許可權

引數

struct file *file: 要在其上進行寫入的檔案的掛載

描述

這類似於 mnt_want_write，但如果該檔案已經開啟以進行寫入，它將跳過遞增 mnt_writers（因為開啟的檔案已經具有引用），而是僅執行凍結保護和緊急 r/o 重新掛載檢查。這必須與 mnt_drop_write_file 配對。

void mnt_put_write_access(struct vfsmount *mnt)¶: 放棄對掛載的寫入許可權

引數

struct vfsmount *mnt: 要放棄寫入許可權的掛載

描述

告訴底層檔案系統，我們已完成對其執行寫入操作。必須與上面的 mnt_get_write_access() 呼叫匹配。

void mnt_drop_write(struct vfsmount *mnt)¶: 放棄對掛載的寫入許可權

引數

struct vfsmount *mnt: 要放棄寫入許可權的掛載

描述

告訴底層檔案系統，我們已完成對其執行寫入操作，並且還允許再次凍結檔案系統。必須與上面的 mnt_want_write() 呼叫匹配。

struct vfsmount *vfs_create_mount(struct fs_context *fc)¶: 為已配置的超級塊建立掛載

引數

struct fs_context *fc: 帶有附加的超級塊的配置上下文

描述

建立到已配置的超級塊的掛載。如有必要，呼叫者應在呼叫此函式之前呼叫 vfs_get_tree()。

請注意，這不會將掛載附加到任何內容。

bool path_is_mountpoint(const struct path *path)¶: 檢查路徑是否為當前名稱空間中的掛載點。

引數

const struct path *path

要檢查的路徑

d_mountpoint() 只能可靠地用於確定 dentry 是否未掛載在任何名稱空間中，並且內聯處理了常見的這種情況。d_mountpoint() 不知道可能存在多個在不同名稱空間中使用給定 dentry 的掛載。此函式檢查傳入的路徑是否為掛載點，而不是僅檢查 dentry。

int may_umount_tree(struct vfsmount *m)¶: 檢查掛載樹是否繁忙

引數

struct vfsmount *m: 掛載樹的根

描述

呼叫此函式是為了檢查掛載樹是否具有任何開啟的檔案、pwds、chroot 或繁忙的子掛載。

int may_umount(struct vfsmount *mnt)¶: 檢查掛載點是否繁忙

引數

struct vfsmount *mnt: 掛載的根

描述

呼叫此函式是為了檢查掛載點是否具有任何開啟的檔案、pwds、chroot 或子掛載。如果掛載具有子掛載，則無論子掛載是否繁忙，此函式都將返回繁忙。

不考慮配額和其他內容。換句話說，在某些情況下，它會給出錯誤的否定結果。它存在的主要原因是我們需要一種非破壞性的方式來查詢易於解除安裝的檔案系統。

struct vfsmount *clone_private_mount(const struct path *path)¶: 建立路徑的私有克隆

引數

const struct path *path: 要克隆的路徑

描述

這將建立一個新的 vfsmount，它將是 **path** 的克隆。新的掛載將不會附加到名稱空間中的任何位置，並且將是私有的（即，對原始掛載的更改將不會傳播到此掛載中）。

這假定呼叫者已呼叫或執行了與 may_mount() 等效的操作。

使用 mntput() 釋放。

void mnt_set_expiry(struct vfsmount *mnt, struct list_head *expiry_list)¶: 將掛載放在到期列表中

引數

struct vfsmount *mnt: 要列出的掛載。
struct list_head *expiry_list: 要將掛載新增到的列表。

proc 檔案系統¶

sysctl 介面¶

int proc_dostring(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 讀取一個字串 sysctl

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案位置

描述

從使用者緩衝區讀取/寫入字串。如果核心緩衝區不夠大，無法容納字串，則字串將被截斷。複製的字串以 NULL 結尾。如果字串正在被使用者程序讀取，則會被複制並新增換行符“n”。如果緩衝區不夠大，則會被截斷。

成功時返回 0。

int proc_dobool(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 讀取/寫入一個布林值

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案位置

描述

從/向用戶緩衝區讀取/寫入一個整數值，將其視為 ASCII 字串。

table->data 必須指向一個 bool 變數，並且 table->maxlen 必須為 sizeof(bool)。

成功時返回 0。

int proc_dointvec(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 讀取一個整數向量

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案位置

描述

從/向用戶緩衝區讀取/寫入最多 table->maxlen/sizeof(unsigned int) 個整數值，將其視為 ASCII 字串。

成功時返回 0。

int proc_douintvec(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 讀取一個無符號整數向量

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案位置

描述

從/向用戶緩衝區讀取/寫入最多 table->maxlen/sizeof(unsigned int) 個無符號整數值，將其視為 ASCII 字串。

成功時返回 0。

int proc_dointvec_minmax(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 讀取具有最小值/最大值的整數向量

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案位置

描述

從/向用戶緩衝區讀取/寫入最多 table->maxlen/sizeof(unsigned int) 個整數值，將其視為 ASCII 字串。

此例程將確保這些值在 table->extra1（最小值）和 table->extra2（最大值）指定的範圍內。

成功時返回 0，如果寫入時範圍檢查失敗，則返回 -EINVAL。

int proc_douintvec_minmax(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 讀取具有最小值/最大值的無符號整數向量

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案位置

描述

從/向用戶緩衝區讀取/寫入最多 table->maxlen/sizeof(unsigned int) 個無符號整數值，將其視為 ASCII 字串。不允許使用負字串。

此例程將確保這些值在 table->extra1（最小值）和 table->extra2（最大值）指定的範圍內。最終會對 UINT_MAX 進行健全性檢查，以避免不得不支援來自使用者空間的環繞使用。

成功時返回 0，如果寫入時範圍檢查失敗，則返回 -ERANGE。

int proc_dou8vec_minmax(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 讀取具有最小值/最大值的無符號字元向量

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案位置

描述

從/向用戶緩衝區讀取/寫入最多 table->maxlen/sizeof(u8) 個無符號字元值，將其視為 ASCII 字串。不允許使用負字串。

此例程將確保這些值在 table->extra1（最小值）和 table->extra2（最大值）指定的範圍內。

成功時返回 0，如果寫入時範圍檢查失敗，則返回錯誤。

int proc_doulongvec_minmax(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 讀取具有最小值/最大值的長整數向量

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案位置

描述

從/向用戶緩衝區讀取/寫入最多 table->maxlen/sizeof(unsigned long) 個無符號長整數值，將其視為 ASCII 字串。

此例程將確保這些值在 table->extra1（最小值）和 table->extra2（最大值）指定的範圍內。

成功時返回 0。

int proc_doulongvec_ms_jiffies_minmax(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 讀取具有最小值/最大值的毫秒值向量

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案位置

描述

從/向用戶緩衝區讀取/寫入最多 table->maxlen/sizeof(unsigned long) 個無符號長整數值，將其視為 ASCII 字串。這些值被視為毫秒，並在儲存時轉換為節拍數。

此例程將確保這些值在 table->extra1（最小值）和 table->extra2（最大值）指定的範圍內。

成功時返回 0。

int proc_dointvec_jiffies(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 將整數向量讀取為秒

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案位置

描述

從/向用戶緩衝區讀取/寫入最多 table->maxlen/sizeof(unsigned int) 個整數值，將其視為 ASCII 字串。假定讀取的值以秒為單位，並轉換為節拍數。

成功時返回 0。

int proc_dointvec_userhz_jiffies(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 將整數向量讀取為 1/USER_HZ 秒

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 指向檔案位置的指標

描述

從/向用戶緩衝區讀取/寫入最多 table->maxlen/sizeof(unsigned int) 個整數值，將其視為 ASCII 字串。假定讀取的值以 1/USER_HZ 秒為單位，並轉換為節拍數。

成功時返回 0。

int proc_dointvec_ms_jiffies(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 將整數向量讀取為 1 毫秒

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案中的當前位置

描述

從/向用戶緩衝區讀取/寫入最多 table->maxlen/sizeof(unsigned int) 個整數值，將其視為 ASCII 字串。假定讀取的值以 1/1000 秒為單位，並轉換為節拍數。

成功時返回 0。

int proc_do_large_bitmap(const struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos)¶: 從/向大型點陣圖讀取/寫入

引數

const struct ctl_table *table: sysctl 表
int write: 如果這是對 sysctl 檔案的寫入，則為 TRUE
void *buffer: 使用者緩衝區
size_t *lenp: 使用者緩衝區的大小
loff_t *ppos: 檔案位置

描述

點陣圖儲存在 table->data 中，點陣圖長度（以位為單位）儲存在 table->maxlen 中。

我們使用範圍逗號分隔格式（例如 1,3-4,10-10），以便大型點陣圖可以以緊湊的方式表示。寫入檔案將清除點陣圖，然後使用給定的輸入更新它。

成功時返回 0。

proc 檔案系統介面¶

void proc_flush_pid(struct pid *pid)¶: 從 /proc dcache 中刪除 pid 的 dcache 條目。

引數

struct pid *pid: 應該重新整理的 pid。

描述

此函式遍歷附加到 pid 的 inode 列表（屬於任何 proc 檔案系統），並將它們從目錄項快取中重新整理。

在任務退出之前快取該任務的 /proc 條目是安全合理的。在此之後，它們只會用無用的條目阻塞目錄項快取，可能會導致有用的目錄項快取條目被重新整理。提供此例程是為了在重新獲得程序時重新整理這些無用的目錄項快取條目。

注意

此例程只是一種最佳化，因此不保證: 在重新獲得程序後不存在任何目錄項快取條目，它只是使任何條目持續存在的可能性很小。

基於檔案描述符的事件¶

void eventfd_signal_mask(struct eventfd_ctx *ctx, __poll_t mask)¶: 遞增事件計數器

引數

struct eventfd_ctx *ctx: [in] 指向 eventfd 上下文的指標。
__poll_t mask: [in] 輪詢掩碼

描述

此函式應該由核心在不允許睡眠的路徑中呼叫。在此函式中，我們允許計數器達到 ULLONG_MAX 值，並透過向 poll(2) 返回 EPOLLERR 來指示此溢位情況。

void eventfd_ctx_put(struct eventfd_ctx *ctx)¶: 釋放對內部 eventfd 上下文的引用。

引數

struct eventfd_ctx *ctx: [in] 指向 eventfd 上下文的指標。

描述

eventfd 上下文引用必須先前已透過 eventfd_ctx_fdget() 或 eventfd_ctx_fileget() 獲取。

int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_entry_t *wait, __u64 *cnt)¶: 讀取當前計數器並刪除等待佇列。

引數

struct eventfd_ctx *ctx: [in] 指向 eventfd 上下文的指標。
wait_queue_entry_t *wait: [輸入] 要移除的等待佇列。
__u64 *cnt: [輸出] 指向 64 位計數器值的指標。

描述

如果成功，返回 0，否則返回以下錯誤程式碼

-EAGAIN: : 操作將會阻塞。

此函式用於從 eventfd 等待佇列頭原子性地移除一個等待佇列條目，並讀取/重置計數器值。

struct file *eventfd_fget(int fd)¶: 獲取 eventfd 檔案描述符的引用。

引數

int fd: [輸入] Eventfd 檔案描述符。

描述

如果成功，返回指向 eventfd 檔案結構的指標，否則返回以下錯誤指標

-EBADF: : 無效的 fd 檔案描述符。
-EINVAL: : fd 檔案描述符不是 eventfd 檔案。

struct eventfd_ctx *eventfd_ctx_fdget(int fd)¶: 獲取對內部 eventfd 上下文的引用。

引數

int fd: [輸入] Eventfd 檔案描述符。

描述

返回指向內部 eventfd 上下文的指標，否則返回以下函式返回的錯誤指標

eventfd_fget

struct eventfd_ctx *eventfd_ctx_fileget(struct file *file)¶: 獲取對內部 eventfd 上下文的引用。

引數

struct file *file: [輸入] Eventfd 檔案指標。

描述

返回指向內部 eventfd 上下文的指標，否則返回錯誤指標

-EINVAL: : fd 檔案描述符不是 eventfd 檔案。

eventpoll (epoll) 介面¶

int ep_events_available(struct eventpoll *ep)¶: 檢查是否有準備好的事件可用。

引數

struct eventpoll *ep: 指向 eventpoll 上下文的指標。

返回

如果準備好的事件可用，則返回一個不同於 zero 的值，: 否則返回 zero。

bool busy_loop_ep_timeout(unsigned long start_time, struct eventpoll *ep)¶: 檢查忙輪詢是否超時。優先使用 epoll 例項 ep 中的超時值，但如果未設定，則回退到透過 busy_loop_timeout 設定的全系統全域性超時值。

引數

unsigned long start_time: 用於計算到超時剩餘時間的開始時間。
struct eventpoll *ep: 指向 eventpoll 上下文的指標。

返回

如果超時已過期，則為 true，否則為 false。

int reverse_path_check(void)¶: tfile_check_list 是 epitem_head 的列表，其中包含提議新新增的連結。我們需要確保這些新增的連結不會新增過多的路徑，以免我們花費所有時間喚醒 eventpoll 物件。

引數

void: 無引數

返回

如果提議的連結沒有建立過多的路徑，則返回 zero，: 否則返回 -1。

int ep_poll(struct eventpoll *ep, struct epoll_event __user *events, int maxevents, struct timespec64 *timeout)¶: 檢索就緒事件，並將它們傳遞給呼叫者提供的事件緩衝區。

引數

struct eventpoll *ep: 指向 eventpoll 上下文的指標。
struct epoll_event __user *events: 指向使用者空間緩衝區的指標，就緒事件應儲存在該緩衝區中。
int maxevents: 呼叫者事件緩衝區的大小（以事件數為單位）。
struct timespec64 *timeout: 用於獲取就緒事件的最大超時時間（以 timespec 為單位）。如果超時時間為零，則該函式不會阻塞；如果 timeout 指標為 NULL，則該函式將阻塞，直到至少檢索到一個事件（或發生錯誤）。

返回

已獲取的就緒事件數，或一個: 錯誤程式碼（如果發生錯誤）。

int ep_loop_check_proc(struct eventpoll *ep, int depth)¶: 驗證將一個 epoll 檔案新增到另一個 epoll 結構中是否違反了約束，包括閉環或過深的鏈（可能導致過多的堆疊使用）。

引數

struct eventpoll *ep: 要當前檢查的 struct eventpoll。
int depth: 正在檢查的路徑的當前深度。

返回

如果將 epoll file 新增到當前 epoll: 結構 ep 中沒有違反約束，則返回 zero，否則返回 -1。

int ep_loop_check(struct eventpoll *ep, struct eventpoll *to)¶: 執行檢查以驗證將一個 epoll 檔案 (to) 新增到另一個 epoll 檔案（由 ep 表示）中是否會建立閉環或過深的鏈。

引數

struct eventpoll *ep: 指向要插入到的 epoll。
struct eventpoll *to: 指向要插入的 epoll。

返回

如果將 epoll to 新增到 epoll from 中沒有違反約束，則返回 zero，否則返回 -1。

用於匯出核心物件的檔案系統¶

int sysfs_create_file_ns(struct kobject *kobj, const struct attribute *attr, const void *ns)¶: 為具有自定義 ns 的物件建立屬性檔案

引數

struct kobject *kobj: 我們正在為其建立的物件
const struct attribute *attr: 屬性描述符
const void *ns: 新檔案應屬於的名稱空間

int sysfs_add_file_to_group(struct kobject *kobj, const struct attribute *attr, const char *group)¶: 將屬性檔案新增到預先存在的組。

引數

struct kobject *kobj: 我們正在操作的物件。
const struct attribute *attr: 屬性描述符。
const char *group: 組名。

int sysfs_chmod_file(struct kobject *kobj, const struct attribute *attr, umode_t mode)¶: 更新物件屬性上的修改後的模式值。

引數

struct kobject *kobj: 我們正在操作的物件。
const struct attribute *attr: 屬性描述符。
umode_t mode: 檔案許可權。

struct kernfs_node *sysfs_break_active_protection(struct kobject *kobj, const struct attribute *attr)¶: 打破“活動”保護

引數

struct kobject *kobj: 與核心物件 attr 關聯。
const struct attribute *attr: 要打破“活動”保護的屬性。

描述

與 kernfs 一樣，使用 sysfs 時，屬性的刪除將推遲到所有活動的 .show() 和 .store() 回撥完成之後，除非呼叫此函式。因此，此函式在實現自刪除的方法中很有用。

void sysfs_unbreak_active_protection(struct kernfs_node *kn)¶: 恢復“活動”保護

引數

struct kernfs_node *kn: 由 sysfs_break_active_protection() 返回的指標。

描述

撤消 sysfs_break_active_protection() 的效果。由於此函式在與傳遞給 sysfs_break_active_protection() 的 'attr' 引數對應的 kernfs 節點上呼叫 kernfs_put()，因此在該屬性已被刪除，所以在 sysfs_break_active_protection() 和 sysfs_unbreak_active_protection() 呼叫之間訪問 kn 是不安全的。

void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr, const void *ns)¶: 刪除具有自定義 ns 標籤的物件屬性

引數

struct kobject *kobj: 我們正在操作的物件
const struct attribute *attr: 屬性描述符
const void *ns: 要刪除的檔案的名稱空間標籤

描述

雜湊屬性名稱和名稱空間標籤，然後殺死目標。

bool sysfs_remove_file_self(struct kobject *kobj, const struct attribute *attr)¶: 從其自身的方法中刪除物件屬性

引數

struct kobject *kobj: 我們正在操作的物件
const struct attribute *attr: 屬性描述符

描述

有關詳細資訊，請參閱 kernfs_remove_self()。

void sysfs_remove_file_from_group(struct kobject *kobj, const struct attribute *attr, const char *group)¶: 從組中刪除屬性檔案。

引數

struct kobject *kobj: 我們正在操作的物件。
const struct attribute *attr: 屬性描述符。
const char *group: 組名。

int sysfs_create_bin_file(struct kobject *kobj, const struct bin_attribute *attr)¶: 為物件建立二進位制檔案。

引數

struct kobject *kobj: 物件。
const struct bin_attribute *attr: 屬性描述符。

void sysfs_remove_bin_file(struct kobject *kobj, const struct bin_attribute *attr)¶: 刪除物件的二進位制檔案。

引數

struct kobject *kobj: 物件。
const struct bin_attribute *attr: 屬性描述符。

int sysfs_file_change_owner(struct kobject *kobj, const char *name, kuid_t kuid, kgid_t kgid)¶: 更改 sysfs 檔案的所有者。

引數

struct kobject *kobj: 物件。
const char *name: 要更改的檔案的名稱。
kuid_t kuid: 新所有者的 kuid
kgid_t kgid: 新所有者的 kgid

描述

此函式查詢 kobj 下的 sysfs 條目 name，並將所有權更改為 kuid/kgid。

成功時返回 0，失敗時返回錯誤程式碼。

int sysfs_change_owner(struct kobject *kobj, kuid_t kuid, kgid_t kgid)¶: 更改給定物件的所有者。

引數

struct kobject *kobj: 物件。
kuid_t kuid: 新所有者的 kuid
kgid_t kgid: 新所有者的 kgid

描述

將 kobj 的預設目錄、檔案、組和屬性的所有者更改為 kuid/kgid。請注意，sysfs_change_owner 反映了驅動程式核心如何新增 kobject 的 sysfs 條目。總之，sysfs_change_owner() 負責 kobj 的預設目錄條目、與 kobj 的 ktype 關聯的預設屬性以及與 kobj 的 ktype 關聯的預設屬性。驅動程式核心未新增的其他屬性必須由建立它們的驅動程式或子系統更改。這類似於刪除特定於驅動程式/子系統的條目的方式。

成功時返回 0，失敗時返回錯誤程式碼。

int sysfs_emit(char *buf, const char *fmt, ...)¶: scnprintf 等效項，瞭解 PAGE_SIZE 緩衝區。

引數

char *buf: PAGE_SIZE 緩衝區的開始。
const char *fmt: 格式
...: format 的可選引數

描述

返回寫入 buf 的字元數。

int sysfs_emit_at(char *buf, int at, const char *fmt, ...)¶: scnprintf 等效項，瞭解 PAGE_SIZE 緩衝區。

引數

char *buf: PAGE_SIZE 緩衝區的開始。
int at: buf 中的偏移量，以位元組為單位開始寫入。at 必須 >= 0 && < PAGE_SIZE
const char *fmt: 格式
...: fmt 的可選引數

描述

返回從 &**buf**[at] 開始寫入的字元數。

ssize_t sysfs_bin_attr_simple_read(struct file *file, struct kobject *kobj, const struct bin_attribute *attr, char *buf, loff_t off, size_t count)¶: 讀取回調以簡單地從記憶體複製。

引數

struct file *file: 正在讀取的屬性檔案。
struct kobject *kobj: 屬性所屬的物件。
const struct bin_attribute *attr: 屬性描述符。
char *buf: 目標緩衝區。
loff_t off: 要從中讀取的位元組偏移量。
size_t count: 要讀取的最大位元組數。

描述

由記憶體中的緩衝區支援的 bin_attributes 的簡單 ->read() 回撥。在 sysfs 中建立 bin_attribute 之前，必須將 struct bin_attribute 中的 private 和 size 成員設定為緩衝區的位置和大小。

off 和 count 的邊界檢查在 sysfs_kf_bin_read() 中完成。off 的負值檢查在 vfs_setpos() 和 default_llseek() 中完成。

返回寫入 buf 的位元組數。

int sysfs_create_link(struct kobject *kobj, struct kobject *target, const char *name)¶: 在兩個物件之間建立符號連結。

引數

struct kobject *kobj: 我們要在其中建立連結的目錄的物件。
struct kobject *target: 我們要指向的物件。
const char *name: 符號連結的名稱。

int sysfs_create_link_nowarn(struct kobject *kobj, struct kobject *target, const char *name)¶: 在兩個物件之間建立符號連結。

引數

struct kobject *kobj

我們要在其中建立連結的目錄的物件。

struct kobject *target

我們要指向的物件。

const char *name

符號連結的名稱。

此函式與 sysfs_create_link() 的作用相同，但如果連結已存在，則不會發出警告。

void sysfs_remove_link(struct kobject *kobj, const char *name)¶: 刪除物件目錄中的符號連結。

引數

struct kobject *kobj: 我們正在操作的物件。
const char *name: 要刪除的符號連結的名稱。

int sysfs_rename_link_ns(struct kobject *kobj, struct kobject *targ, const char *old, const char *new, const void *new_ns)¶: 重新命名物件目錄中的符號連結。

引數

struct kobject *kobj

我們正在操作的物件。

struct kobject *targ

我們要指向的物件。

const char *old

符號連結的先前名稱。

const char *new

符號連結的新名稱。

const void *new_ns

符號連結的新名稱空間。

用於常見重新命名符號連結習慣用法的輔助函式。

debugfs 檔案系統¶

debugfs 介面¶

struct dentry *debugfs_lookup(const char *name, struct dentry *parent)¶: 查詢現有 debugfs 檔案

引數

const char *name: 指向包含要查詢的檔案的名稱的字串的指標。
struct dentry *parent: 指向檔案的父 dentry 的指標。

描述

如果此函式成功，將返回指向 dentry 的指標。如果檔案不存在或發生錯誤，將返回 NULL。不再需要時，必須將返回的 dentry 傳遞給 dput()。

如果核心中未啟用 debugfs，將返回值 -ENODEV。

struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode, struct dentry *parent, void *data, const struct file_operations *fops)¶: 在 debugfs 檔案系統中建立一個檔案

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權。
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應為目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
void *data: 指向呼叫方稍後想要訪問的內容的指標。inode.i_private 指標將在 open() 呼叫時指向此值。
const struct file_operations *fops: 指向應用於此檔案的 struct file_operations 的指標。

描述

debugfs_create_file_unsafe() 與 debugfs_create_file() 完全類似，唯一的區別是傳遞給它的 fops 不會受到 debugfs 核心的檔案刪除的保護。

您有責任透過 debugfs_file_get() 和 debugfs_file_put() 來保護您的 struct file_operation 方法免受檔案刪除。但是，->open() 仍然受到 debugfs 的保護。

任何透過 DEFINE_DEBUGFS_ATTRIBUTE() 定義的 struct file_operations 都受到檔案刪除的保護，因此，可以在此處使用。

void debugfs_create_file_size(const char *name, umode_t mode, struct dentry *parent, void *data, const struct file_operations *fops, loff_t file_size)¶: 在 debugfs 檔案系統中建立一個檔案

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權。
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應為目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
void *data: 指向呼叫方稍後想要訪問的內容的指標。inode.i_private 指標將在 open() 呼叫時指向此值。
const struct file_operations *fops: 指向應用於此檔案的 struct file_operations 的指標。
loff_t file_size: 初始檔案大小

描述

這是 debugfs 的基本“建立檔案”函式。它允許在建立檔案或目錄時具有廣泛的靈活性（如果要建立目錄，建議使用 debugfs_create_dir() 函式）。

struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)¶: 在 debugfs 檔案系統中建立一個目錄

引數

const char *name: 指向包含要建立的目錄的名稱的字串的指標。
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應為目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該目錄。

描述

此函式使用給定的名稱在 debugfs 中建立一個目錄。

如果此函式成功，將返回指向 dentry 的指標。刪除檔案時，必須將此指標傳遞給 debugfs_remove() 函式（如果您的模組已解除安裝，則不會自動清理，您在此處負責。）如果發生錯誤，將返回 ERR_PTR(-ERROR)。

如果核心中未啟用 debugfs，將返回值 -ENODEV。

注意

期望大多數呼叫方應 _ignore_ 此函式返回的錯誤。其他 debugfs 函式會處理傳遞給它們的“dentry”可能是錯誤的事實，並且它們在這種情況下不會崩潰。即使 debugfs 無法初始化，驅動程式通常也能正常工作。

struct dentry *debugfs_create_automount(const char *name, struct dentry *parent, debugfs_automount_t f, void *data)¶: 在 debugfs 檔案系統中建立自動掛載點

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應為目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
debugfs_automount_t f: 當路徑名解析步驟執行該步驟時要呼叫的函式。
void *data: 要傳遞給 f() 的不透明引數。

描述

f 應返回 ->d_automount() 將返回的內容。

struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent, const char *target)¶: 在 debugfs 檔案系統中建立符號連結

引數

const char *name: 指向包含要建立的符號連結的名稱的字串的指標。
struct dentry *parent: 指向此符號連結的父 dentry 的指標。如果設定，這應為目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立符號連結。
const char *target: 指向包含符號連結目標的路徑的字串的指標。

描述

此函式使用給定的名稱在 debugfs 中建立一個連結到給定目標路徑的符號連結。

如果此函式成功，將返回指向 dentry 的指標。刪除符號連結時，必須將此指標傳遞給 debugfs_remove() 函式（如果您的模組已解除安裝，則不會自動清理，您在此處負責。）如果發生錯誤，將返回 ERR_PTR(-ERROR)。

如果核心中未啟用 debugfs，將返回值 -ENODEV。

void debugfs_remove(struct dentry *dentry)¶: 遞迴刪除目錄

引數

struct dentry *dentry: 指向要刪除的目錄的 dentry 的指標。如果此引數為 NULL 或錯誤值，則不執行任何操作。

描述

此函式遞迴刪除 debugfs 中的目錄樹，該目錄樹先前透過呼叫另一個 debugfs 函式（如 debugfs_create_file() 或其變體）建立。

需要呼叫此函式才能刪除檔案，當模組被刪除時，不會自動清理檔案，您在此處負責。

void debugfs_lookup_and_remove(const char *name, struct dentry *parent)¶: 查詢目錄或檔案並遞迴地刪除它

引數

const char *name: 指向包含要查詢專案名稱的字串的指標。
struct dentry *parent: 指向專案的父 dentry 的指標。

描述

這相當於執行類似 debugfs_remove(debugfs_lookup(..)) 的操作，但為正在查詢的目錄處理了正確的引用計數。

int debugfs_change_name(struct dentry *dentry, const char *fmt, ...)¶: 在 debugfs 檔案系統中重新命名檔案/目錄

引數

struct dentry *dentry: 要重新命名的物件的 dentry。
const char *fmt: 新名稱的格式
...: 可變引數

描述

此函式在 debugfs 中重新命名檔案/目錄。目標必須不存在才能成功重新命名。

此函式成功時返回 0，失敗時返回 -E...

如果核心中未啟用 debugfs，將返回值 -ENODEV。

bool debugfs_initialized(void)¶: 告知 debugfs 是否已註冊

引數

void: 無引數

int debugfs_file_get(struct dentry *dentry)¶: 標記檔案資料訪問的開始

引數

struct dentry *dentry: 正在訪問資料的 dentry 物件。

描述

直到匹配的 debugfs_file_put() 呼叫為止，對檔案刪除函式 debugfs_remove() 和 debugfs_remove_recursive() 的任何後續呼叫都將阻塞。由於關聯的私有檔案資料可能僅在任何刪除函式成功返回後才能釋放，因此您可以在成功呼叫 debugfs_file_get() 後安全地訪問它，而不必擔心生存期問題。

如果返回 -EIO，則該檔案已被刪除，因此訪問其任何資料都是不安全的。另一方面，如果允許訪問檔案資料，則返回零。

void debugfs_file_put(struct dentry *dentry)¶: 標記檔案資料訪問的結束

引數

struct dentry *dentry: 先前傳遞給 debugfs_file_get() 的 dentry 物件。

描述

允許任何正在進行的併發呼叫 debugfs_remove() 或 debugfs_remove_recursive() 被先前呼叫 debugfs_file_get() 阻止，以便繼續並返回其呼叫方。

void debugfs_enter_cancellation(struct file *file, struct debugfs_cancellation *cancellation)¶: 進入 debugfs 取消

引數

struct file *file: 正在訪問的檔案
struct debugfs_cancellation *cancellation: 取消物件，其中的取消回撥必須已初始化

描述

刪除 debugfs 檔案時，它需要等待所有活動操作完成。但是，操作本身可能需要等待硬體或某些非同步程序的完成或類似情況。因此，可能需要取消它以避免長時間的等待甚至死鎖。

此函式可以在可能需要取消的 debugfs 處理程式中使用。一旦呼叫此函式，就可以呼叫 cancellation 的“cancel”回撥，此時呼叫者應繼續呼叫 debugfs_leave_cancellation() 並儘快離開 debugfs 處理程式函式。請注意，“cancel”回撥僅在某種 debugfs_remove() 的上下文中呼叫。

此函式必須與 debugfs_leave_cancellation() 配對使用。

void debugfs_leave_cancellation(struct file *file, struct debugfs_cancellation *cancellation)¶: 離開取消部分

引數

struct file *file: 正在訪問的檔案
struct debugfs_cancellation *cancellation: 先前使用 debugfs_enter_cancellation() 註冊的取消

描述

請參閱 debugfs_enter_cancellation() 的文件。

void debugfs_create_u8(const char *name, umode_t mode, struct dentry *parent, u8 *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入無符號 8 位值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
u8 *value: 指向檔案應從中讀取和寫入的變數的指標。

描述

此函式在 debugfs 中建立一個具有給定名稱的檔案，其中包含變數 **value** 的值。如果設定了 **mode** 變數，則可以從中讀取和寫入。

void debugfs_create_u16(const char *name, umode_t mode, struct dentry *parent, u16 *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入無符號 16 位值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
u16 *value: 指向檔案應從中讀取和寫入的變數的指標。

描述

此函式在 debugfs 中建立一個具有給定名稱的檔案，其中包含變數 **value** 的值。如果設定了 **mode** 變數，則可以從中讀取和寫入。

void debugfs_create_u32(const char *name, umode_t mode, struct dentry *parent, u32 *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入無符號 32 位值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
u32 *value: 指向檔案應從中讀取和寫入的變數的指標。

描述

此函式在 debugfs 中建立一個具有給定名稱的檔案，其中包含變數 **value** 的值。如果設定了 **mode** 變數，則可以從中讀取和寫入。

void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent, u64 *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入無符號 64 位值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
u64 *value: 指向檔案應從中讀取和寫入的變數的指標。

描述

此函式在 debugfs 中建立一個具有給定名稱的檔案，其中包含變數 **value** 的值。如果設定了 **mode** 變數，則可以從中讀取和寫入。

void debugfs_create_ulong(const char *name, umode_t mode, struct dentry *parent, unsigned long *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入無符號長整型值。

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
unsigned long *value: 指向檔案應從中讀取和寫入的變數的指標。

描述

此函式在 debugfs 中建立一個具有給定名稱的檔案，其中包含變數 **value** 的值。如果設定了 **mode** 變數，則可以從中讀取和寫入。

void debugfs_create_x8(const char *name, umode_t mode, struct dentry *parent, u8 *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入無符號 8 位值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
u8 *value: 指向檔案應從中讀取和寫入的變數的指標。

void debugfs_create_x16(const char *name, umode_t mode, struct dentry *parent, u16 *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入無符號 16 位值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
u16 *value: 指向檔案應從中讀取和寫入的變數的指標。

void debugfs_create_x32(const char *name, umode_t mode, struct dentry *parent, u32 *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入無符號 32 位值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
u32 *value: 指向檔案應從中讀取和寫入的變數的指標。

void debugfs_create_x64(const char *name, umode_t mode, struct dentry *parent, u64 *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入無符號 64 位值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
u64 *value: 指向檔案應從中讀取和寫入的變數的指標。

void debugfs_create_size_t(const char *name, umode_t mode, struct dentry *parent, size_t *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入 size_t 值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
size_t *value: 指向檔案應從中讀取和寫入的變數的指標。

void debugfs_create_atomic_t(const char *name, umode_t mode, struct dentry *parent, atomic_t *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入 atomic_t 值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
atomic_t *value: 指向檔案應從中讀取和寫入的變數的指標。

void debugfs_create_bool(const char *name, umode_t mode, struct dentry *parent, bool *value)¶: 建立一個 debugfs 檔案，用於讀取和寫入布林值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
bool *value: 指向檔案應從中讀取和寫入的變數的指標。

描述

此函式在 debugfs 中建立一個具有給定名稱的檔案，其中包含變數 **value** 的值。如果設定了 **mode** 變數，則可以從中讀取和寫入。

void debugfs_create_str(const char *name, umode_t mode, struct dentry *parent, char **value)¶: 建立一個 debugfs 檔案，用於讀取和寫入字串值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
char **value: 指向檔案應從中讀取和寫入的變數的指標。

描述

此函式在 debugfs 中建立一個具有給定名稱的檔案，其中包含變數 **value** 的值。如果設定了 **mode** 變數，則可以從中讀取和寫入。

struct dentry *debugfs_create_blob(const char *name, umode_t mode, struct dentry *parent, struct debugfs_blob_wrapper *blob)¶: 建立一個 debugfs 檔案，用於讀寫二進位制 blob

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
struct debugfs_blob_wrapper *blob: 指向 struct debugfs_blob_wrapper 的指標，該結構包含指向 blob 資料的指標和資料大小。

描述

此函式在 debugfs 中建立一個具有給定名稱的檔案，該檔案將 blob->data 匯出為二進位制 blob。如果設定了 mode 變數，則可以對其進行讀取和寫入。

如果此函式成功，將返回指向 dentry 的指標。刪除檔案時，必須將此指標傳遞給 debugfs_remove() 函式（如果您的模組已解除安裝，則不會自動清理，您在此處負責。）如果發生錯誤，將返回 ERR_PTR(-ERROR)。

如果核心中未啟用 debugfs，則將返回 ERR_PTR(-ENODEV) 值。

void debugfs_create_u32_array(const char *name, umode_t mode, struct dentry *parent, struct debugfs_u32_array *array)¶: 建立一個 debugfs 檔案，用於讀取 u32 陣列。

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權。
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
struct debugfs_u32_array *array: 包含資料指標和陣列大小的包裝結構體。

描述

此函式在 debugfs 中建立一個具有給定名稱的檔案，該檔案將 array 匯出為資料。如果設定了 mode 變數，則可以讀取該資料。不支援寫入。也不支援在檔案中搜索。一旦建立了陣列，就無法更改其大小。

void debugfs_print_regs32(struct seq_file *s, const struct debugfs_reg32 *regs, int nregs, void __iomem *base, char *prefix)¶: 使用 seq_print 來描述一組暫存器

引數

struct seq_file *s: 用於生成輸出的 seq_file 結構
const struct debugfs_reg32 *regs: struct debugfs_reg32 結構體的陣列
int nregs: 上述陣列的長度
void __iomem *base: 用於讀取暫存器的基地址
char *prefix: 要新增到每個輸出行前面的字串

描述

此函式輸出一個文字塊，描述一些 32 位硬體暫存器的當前值。它旨在用於基於 seq_file 的 debugfs 檔案中，這些檔案需要顯示與其他資訊混合的暫存器。 prefix 引數可用於指定前導字串，因為某些外圍裝置具有多個相同的暫存器塊，例如 dma 通道的配置

void debugfs_create_regset32(const char *name, umode_t mode, struct dentry *parent, struct debugfs_regset32 *regset)¶: 建立一個 debugfs 檔案，該檔案返回暫存器值

引數

const char *name: 指向包含要建立的檔案的名稱的字串的指標。
umode_t mode: 檔案應具有的許可權
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
struct debugfs_regset32 *regset: 指向 struct debugfs_regset32 的指標，該結構包含指向暫存器定義陣列的指標、陣列大小和要查詢暫存器組的基地址。

描述

此函式在 debugfs 中建立一個具有給定名稱的檔案，該檔案報告一組 32 位暫存器的名稱和值。如果設定了 mode 變數，則可以從中讀取。不支援寫入。

void debugfs_create_devm_seqfile(struct device *dev, const char *name, struct dentry *parent, int (*read_fn)(struct seq_file *s, void *data))¶: 建立一個繫結到裝置的 debugfs 檔案。

引數

struct device *dev: 與此 debugfs 檔案相關的裝置。
const char *name: debugfs 檔案的名稱。
struct dentry *parent: 指向此檔案的父 dentry 的指標。如果設定，這應該是目錄 dentry。如果此引數為 NULL，則將在 debugfs 檔案系統的根目錄中建立該檔案。
int (*read_fn)(struct seq_file *s, void *data): 用於列印 seq_file 內容的函式指標。

Linux 核心

目錄

本頁

Linux 檔案系統 API 概述¶

Linux VFS¶

檔案系統型別¶

目錄快取¶

Inode 處理¶

註冊和超級塊¶

檔案鎖¶

其他函式¶

proc 檔案系統¶

sysctl 介面¶

proc 檔案系統介面¶

基於檔案描述符的事件¶

eventpoll (epoll) 介面¶

用於匯出核心物件的檔案系統¶

debugfs 檔案系統¶

debugfs 介面¶