文章目錄

• 前言
• 一、open概述
• 二、字符設備的注冊
• 二、創建inode
• 四、打開文件流程
• • 4.1 數據結構
  • 4.2 處理流程
  • • 4.2.1 open系統調用

---

前言

要解決的問題：

struct inode 和 struct file，cdev 和 inode的關系

open系統調用是如何通過設備號來找到

---

一、open概述

使用open函數打開設備文件，到底做了些什么工作？下圖中列出了open函數執行的大致過程。

二、字符設備的注冊

??linux內核cdev_init系列函數。
??內核中每個字符設備都對應一個 cdev 結構的變量，下面是它的定義：

struct cdev {struct kobject kobj; // 每個 cdev 都是一個 kobjectstruct module *owner; // 指向實現驅動的模塊const struct file_operations *ops; // 操縱這個字符設備文件的方法struct list_head list; // 與 cdev 對應的字符設備文件的 inode->i_devices 的鏈表頭dev_t dev; // 起始設備編號unsigned int count; // 設備范圍號大小 };

??一個 cdev 一般它有兩種定義初始化方式：靜態的和動態的。

靜態內存定義初始化：

struct cdev my_cdev; cdev_init(&my_cdev, &fops); my_cdev.owner = THIS_MODULE;

動態內存定義初始化：

struct cdev *my_cdev = cdev_alloc(); my_cdev->ops = &fops; my_cdev->owner = THIS_MODULE;

??兩種使用方式的功能是一樣的，只是使用的內存區不一樣，一般視實際的數據結構需求而定。

??下面貼出了兩個函數的代碼，以具體看一下它們之間的差異。

struct cdev *cdev_alloc(void) {struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);if (p) {INIT_LIST_HEAD(&p->list);kobject_init(&p->kobj, &ktype_cdev_dynamic);}return p; }void cdev_init(struct cdev *cdev, const struct file_operations *fops) {memset(cdev, 0, sizeof *cdev);INIT_LIST_HEAD(&cdev->list);kobject_init(&cdev->kobj, &ktype_cdev_default);cdev->ops = fops; }

??由此可見，兩個函數完成都功能基本一致，只是 cdev_init() 還多賦了一個 cdev->ops 的值。
??初始化 cdev 后，需要把它添加到系統中去。為此可以調用 cdev_add() 函數。傳入 cdev 結構的指針，起始設備編號，以及設備編號范圍。

int cdev_add(struct cdev *p, dev_t dev, unsigned count) {p->dev = dev;p->count = count;return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p); }

??內核中所有都字符設備都會記錄在一個 kobj_map 結構的 cdev_map 變量中。這個結構的變量中包含一個散列表用來快速存取所有的對象。kobj_map() 函數就是用來把字符設備編號和 cdev 結構變量一起保存到 cdev_map 這個散列表里。當后續要打開一個字符設備文件時，通過調用 kobj_lookup() 函數，根據設備編號就可以找到 cdev 結構變量，從而取出其中的 ops 字段。
??kobj_map函數中哈希表的實現原理和前面注冊分配設備號中的幾乎完全一樣，通過要加入系統的設備的主設備號major（major=MAJOR(dev)）來獲得probes數組的索引值i（i = major % 255），然后把一個類型為struct probe的節點對象加入到probes[i]所管理的鏈表中，如圖2-6所示。其中struct probe所在的矩形塊中的深色部分是我們重點關注的內容，記錄了當前正在加入系統的字符設備對象的有關信息。其中，dev是它的設備號，range是從次設備號開始連續的設備數量，data是一void *變量，指向當前正要加入系統的設備對象指針p。圖2-6展示了兩個滿足主設備號major % 255 = 2的字符設備通過調用cdev_add之后，cdev_map所展現出來的數據結構狀態。

??所以，簡單地說，設備驅動程序通過調用cdev_add把它所管理的設備對象的指針嵌入到一個類型為struct probe的節點之中，然后再把該節點加入到cdev_map所實現的哈希鏈表中。
??對系統而言，當設備驅動程序成功調用了cdev_add之后，就意味著一個字符設備對象已經加入到了系統，在需要的時候，系統就可以找到它。對用戶態的程序而言，cdev_add調用之后，就已經可以通過文件系統的接口呼叫到我們的驅動程序。
??當一個字符設備驅動不再需要的時候（比如模塊卸載），就可以用 cdev_del() 函數來釋放 cdev 占用的內存。

void cdev_del(struct cdev *p) {cdev_unmap(p->dev, p->count);kobject_put(&p->kobj); }

??其中 cdev_unmap() 調用 kobj_unmap() 來釋放 cdev_map 散列表中的對象。kobject_put() 釋放 cdev 結構本身。

二、創建inode

??設備文件通常在開機啟動時自動創建的，不過，我們仍然可以使用命令mknod來創建一個新的設備文件，命令的基本語法如下：
mknod 設備名 設備類型 主設備號 次設備號

??當我們使用上述命令，創建了一個字符設備文件時，實際上就是創建了一個設備節點inode結構體，并且將該設備的設備編號記錄在成員i_rdev，將成員i_fop指針指向了def_chr_fops結構體。這就是mknod負責的工作內容，具體代碼見如
命令mknod最終會調用init_special_inode函數，由于我們創建的是字符設備，因此，會執行第22~23行的代碼。這樣就完成了上圖的內容。

static struct inode *shmem_get_inode(struct super_block *sb, const struct inode *dir,umode_t mode, dev_t dev, unsigned long flags) {inode = new_inode(sb);if (inode) {......switch (mode & S_IFMT) {default:inode->i_op = &shmem_special_inode_operations;init_special_inode(inode, mode, dev);break;......}} elseshmem_free_inode(sb);return inode;}void init_special_inode(struct inode *inode, umode_t mode, dev_t rdev){inode->i_mode = mode;if (S_ISCHR(mode)) {inode->i_fop = &def_chr_fops;inode->i_rdev = rdev;}....}

四、打開文件流程

??當應用層通過open api打開一個文件，內核中究竟如何處理？ 本身用來描述內核中對應open 系統調用的處理流程。

4.1 數據結構

??struct fdtable 一個進程可以打開很多文件， 內核用fdtable來管理這些文件。

include/linux/fdtable.h struct fdtable {unsigned int max_fds;struct file __rcu **fd; /* current fd array */unsigned long *close_on_exec;unsigned long *open_fds;unsigned long *full_fds_bits;struct rcu_head rcu; }; fd: 文件描述符數組 open_fds: 為方便查找數組中的空閑項， 為該數組建立的位圖 close_on_exec: 在打開的文件中， 有些文件時用于執行目的， 在執行完成之后應該自動關閉

??struct files_struct 對于大多數進程， 打開文件的數量是有限的，一種優化的設計方式是為每個進程內置分配少量數目的文件描述符指針數組， 但進程需要更多的指針時， 再動態擴展。 為此， 進程并不直接使用fdtable, 而是使用files_struct結構體， 作為task_struct的一個域.fdt指向進程實際使用的fdtable。 對于大多數進程來說， 打開文件的梳理并不會很多， 這時候無需另外分配空間， 直接指向內嵌的結構， 即fdtab域。

/** Open file table structure*/ struct files_struct {/** read mostly part*/atomic_t count;bool resize_in_progress;wait_queue_head_t resize_wait;struct fdtable __rcu *fdt;struct fdtable fdtab;/** written part on a separate cache line in SMP*/spinlock_t file_lock ____cacheline_aligned_in_smp;unsigned int next_fd;unsigned long close_on_exec_init[1];unsigned long open_fds_init[1];unsigned long full_fds_bits_init[1];struct file __rcu * fd_array[NR_OPEN_DEFAULT]; };

??struct file每個打開的文件都會對應一個file結構體， 進程通過它對文件進行操作。

include/linux/fs.h struct file {union {struct llist_node fu_llist;struct rcu_head fu_rcuhead;} f_u;struct path f_path;struct inode *f_inode; /* cached value */const struct file_operations *f_op;/** Protects f_ep_links, f_flags.* Must not be taken from IRQ context.*/spinlock_t f_lock;enum rw_hint f_write_hint;atomic_long_t f_count;unsigned int f_flags;fmode_t f_mode;struct mutex f_pos_lock;loff_t f_pos;struct fown_struct f_owner;const struct cred *f_cred;struct file_ra_state f_ra;u64 f_version; #ifdef CONFIG_SECURITYvoid *f_security; #endif/* needed for tty driver, and maybe others */void *private_data;#ifdef CONFIG_EPOLL/* Used by fs/eventpoll.c to link all the hooks to this file */struct list_head f_ep_links;struct list_head f_tfile_llink; #endif /* #ifdef CONFIG_EPOLL */struct address_space *f_mapping;errseq_t f_wb_err;errseq_t f_sb_err; /* for syncfs */ } __randomize_layoutf_path: 文件路徑 f_op: 指向文件操作表， read/write等操作都會調用這里的回調 f_mapping: 指向文件地址空間描述符 f_pos: 當前文件的偏移值

struct inode
??VFS inode包含文件訪問權限、屬主、組、大小、生成時間、訪問時間、最后修改時間等信息。它是linux管理文件系統的最基本單位，也是文件系統連接任何子目錄、文件的橋梁。inode結構中的靜態信息取自物理設備上的文件系統，由文件系統指定的函數填寫，它只存在于內存中，可以通過inode緩存訪問。雖然每個文件都有相應的inode結點，但是只有在需要的時候系統才會在內存中為其建立相應的inode數據結構，建立的inode結構將形成一個鏈表，我們可以通過遍歷這個鏈表去得到我們需要的文件結點,VFS也為已分配的inode構造緩存和哈希表，以提 高系統性能。inode結構中的struct inode_operations *i_op為我們提供了一個inode操作列表，通過這個列表提供的函數我們可以對VFS inode結點進行各種操作。每個inode結構都有一個i結點號i_ino，在同一個文件系統中每個i結點號是唯一的

struct inode {struct list_headi_hash;struct list_headi_list;struct list_headi_dentry;struct list_headi_dirty_buffers;unsigned longi_ino; /*每一個inode都有一個序號，經由super block結構和其序號，我們可以很輕易的找到這個inode。*/atomic_t i_count; /*在Kernel里，很多的結構都會記錄其reference count，以確保如果某個結構正在使用，它不會被不小心釋放掉，i_count就是其reference count。*/kdev_t i_dev; /* inode所在的device代碼 */umode_t i_mode; /* inode的權限 */nlink_t i_nlink; /* hard link的個數 */uid_t i_uid; /* inode擁有者的id */gid_t i_gid; /* inode所屬的群組id */kdev_t i_rdev; /* 如果inode代表的是device的話，那此字段將記錄device的代碼 */............... }

4.2 處理流程

4.2.1 open系統調用

??整體調用棧

#3 0xffffffff81218174 in do_filp_open (dfd=dfd@entry=-100, pathname=pathname@entry=0xffff888004950000, op=op@entry=0xffffc90000173ee4) at fs/namei.c:3396 #4 0xffffffff81203cfd in do_sys_openat2 (dfd=-100, filename=<optimized out>, how=how@entry=0xffffc90000173f20) at fs/open.c:1168 #5 0xffffffff81205135 in do_sys_open (dfd=<optimized out>, filename=<optimized out>, flags=<optimized out>, mode=<optimized out>) at fs/open.c:1184 #6 0xffffffff819bf903 in do_syscall_64 (nr=<optimized out>, regs=0xffffc90000173f58) at arch/x86/entry/common.c:46 #7 0xffffffff81a0007c in entry_SYSCALL_64 () at arch/x86/entry/entry_64.S:120

??當我們在用戶空間調用open之后，會產生一個軟中斷，然后通過系統調用進入內核空間。通過系統調用號，我們就可以跳轉到該中斷例程的入口地址

SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode) {long ret;/*檢查是否應該不考慮用戶層傳遞的標志、總是強行設置O_LARGEFILE標志。如果底層處理器的字長不是32位，就是這種情況*/if (force_o_largefile())flags |= O_LARGEFILE;/*實際工作*/ret = do_sys_open(AT_FDCWD, filename, flags, mode);/* avoid REGPARM breakage on x86: */asmlinkage_protect(3, ret, filename, flags, mode);return ret; }

??我們看下*SYSCALL_DEFINE3(open, const char __user , filename, int, flags, int, mode) 展開是怎么樣的

#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)再看下SYSCALL_DEFINEx #define SYSCALL_DEFINEx(x, sname, ...) \ __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)再看下__SYSCALL_DEFINEx #define __SYSCALL_DEFINEx(x, name, ...) \ asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__))這里對對應__SC_DECL3 #define __SC_DECL1(t1, a1) t1 a1 #define __SC_DECL2(t2, a2, ...) t2 a2, __SC_DECL1(__VA_ARGS__) #define __SC_DECL3(t3, a3, ...) t3 a3, __SC_DECL2(__VA_ARGS__) 這們一步步展開SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode)代替進去，可以得到 SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode) = SYSCALL_DEFINEx(3, _##name, __VA_ARGS__) =asmlinkage long sys_open(__SC_DECL3(__VA_ARGS__)) =asmlinkage long sys_open(const char __user* filename, int flags, int mode) 這個才是真正的函數原型

??在sys_open里面繼續調用do_sys_open完成 open操作

long do_sys_open(int dfd, const char __user *filename, int flags, int mode) {/*從進程地址空間讀取該文件的路徑名*/char *tmp = getname(filename);int fd = PTR_ERR(tmp);if (!IS_ERR(tmp)) {/*在內核中，每個打開的文件由一個文件描述符表示該描述符在特定于進程的數組中充當位置索引(數組是task_struct->files->fd_arry)，該數組的元素包含了file結構，其中包括每個打開文件的所有必要信息。因此，調用下面函數查找一個未使用的文件描述符,返回的是上面說的數組的下標*/fd = get_unused_fd_flags(flags);if (fd >= 0) {/*fd獲取成功則開始打開文件，此函數是主要完成打開功能的函數*///如果分配fd成功，則創建一個file對象struct file *f = do_filp_open(dfd, tmp, flags, mode, 0);if (IS_ERR(f)) {put_unused_fd(fd);fd = PTR_ERR(f);}}} } else {/*文件如果打開成功，調用fsnoTIfy_open()函數，根據inode所指定的信息進行打開函數(參數為f)將該文件加入到文件監控的系統中。該系統是用來監控文件被打開，創建，讀寫，關閉，修改等操作的*/fsnotify_open(f->f_path.dentry);/*將文件指針安裝在fd數組中將struct file *f加入到fd索引位置處的數組中。如果后續過程中，有對該文件描述符的操作的話，就會通過查找該數組得到對應的文件結構，而后在進行相關操作。*/fd_install(fd, f);} }putname(tmp);return fd; }

該函數主要分為如下幾個步驟來完成打開文件的操作：
1.將文件名參數從用戶態拷貝至內核，調用函數get_name()；
2.從進程的文件表中找到一個空閑的文件表指針，調用了函數get_unused_fd_flgas()；
3.完成真正的打開操作，調用函數do_filp_open()；
4.將打開的文件添加到進程的文件表數組中，調用函數fd_install()；
??getname函數主要的任務是將文件名filename從用戶態拷貝至內核態

char * getname(const char __user * filename) {char *tmp, *result;result = ERR_PTR(-ENOMEM);tmp = __getname(); //從內核緩存中分配空間；if (tmp) {//將文件名從用戶態拷貝至內核態；int retval = do_getname(filename, tmp);result = tmp;if (retval){__putname(tmp);result = ERR_PTR(retval);}}audit_getname(result);return result; }

?? get_unused_fd_flags實際調用的是alloc_fd

#define get_unused_fd_flags(flags) alloc_fd(0, (flags)) /* * allocate a file descriptor, mark it busy. */ int alloc_fd(unsigned start, unsigned flags) {struct files_struct *files = current->files;//獲得當前進程的files_struct 結構unsigned int fd;int error;struct fdtable *fdt;spin_lock(&files->file_lock);repeat:fdt = files_fdtable(files);fd = start;if (fd next_fd) //從上一次打開的fd的下一個fd開始搜索空閑的fdfd = files->next_fd;if (fd max_fds)//尋找空閑的fd，返回值為空閑的fdfd = find_next_zero_bit(fdt->open_fds->fds_bits,fdt->max_fds, fd);//如果有必要，即打開的fd超過max_fds,則需要expand當前進程的fd表；//返回值error<0表示出錯，error=0表示無需expand，error=1表示進行了expand；error = expand_files(files, fd);if (error)goto out;/** If we needed to expand the fs array we* might have blocked - try again.*///error=1表示進行了expand，那么此時需要重新去查找空閑的fd；if (error)goto repeat;//設置下一次查找的起始fd，即本次找到的空閑的fd的下一個fd，記錄在files->next_fd中；if (start <= files->next_fd)files->next_fd = fd + 1;FD_SET(fd, fdt->open_fds);if (flags & O_CLOEXEC)FD_SET(fd, fdt->close_on_exec);elseFD_CLR(fd, fdt->close_on_exec);error = fd; #if 1 /* Sanity check */ if (rcu_dereference(fdt->fd[fd]) != NULL) {printk(KERN_WARNING "alloc_fd: slot %d not NULL!\n", fd);rcu_assign_pointer(fdt->fd[fd], NULL); } #endif out:spin_unlock(&files->file_lock);return error; }

??該函數為需要打開的文件在當前進程內分配一個空閑的文件描述符fd，該fd就是open()系統調用的返回值
??do_filp_open函數的一個重要作用就是根據傳遞近來的權限進行分析，并且分析傳遞近來的路徑名字，根據路徑名逐個解析成dentry，并且通過dentry找到inode，inode就是記錄著該文件相關的信息， 包括文件的創建時間和文件屬性所有者等等信息，根據這些信息就可以找到對應的文件操作方法。在這個過程當中有一個臨時的結構體用于保存在查找過程中的相關信息
??do_file_open 函數的處理如下， 主要調用了path_openat 函數去執行真正的open 流程：

fs/namei.cdo_sys_open->do_sys_openat2->do_filp_open struct file *do_filp_open(int dfd, struct filename *pathname,const struct open_flags *op) {struct nameidata nd;int flags = op->lookup_flags;struct file *filp;set_nameidata(&nd, dfd, pathname);filp = path_openat(&nd, op, flags | LOOKUP_RCU);if (unlikely(filp == ERR_PTR(-ECHILD)))filp = path_openat(&nd, op, flags);if (unlikely(filp == ERR_PTR(-ESTALE)))filp = path_openat(&nd, op, flags | LOOKUP_REVAL);restore_nameidata();return filp; }

??path_openat： 執行open的核心流程

fs/namei.cdo_sys_open->do_sys_openat2->do_filp_open->path_openatstatic struct file *path_openat(struct nameidata *nd,const struct open_flags *op, unsigned flags) {struct file *file;int error;file = alloc_empty_file(op->open_flag, current_cred()); /* 1 */if (IS_ERR(file))return file;if (unlikely(file->f_flags & __O_TMPFILE)) {error = do_tmpfile(nd, flags, op, file);} else if (unlikely(file->f_flags & O_PATH)) {error = do_o_path(nd, flags, file);} else {const char *s = path_init(nd, flags);while (!(error = link_path_walk(s, nd)) && /* 2 */(s = open_last_lookups(nd, file, op)) != NULL) /* 3 */;if (!error)error = do_open(nd, file, op); /* 4 */terminate_walk(nd);}if (likely(!error)) {if (likely(file->f_mode & FMODE_OPENED))return file;WARN_ON(1);error = -EINVAL;}fput(file);if (error == -EOPENSTALE) {if (flags & LOOKUP_RCU)error = -ECHILD;elseerror = -ESTALE;}return ERR_PTR(error); } (1) 申請 file 結構體， 并做初始化 (2) 找到路徑的最后一個分量 (3) 對于最后一個分量進行處理， 這里面會去查找文件是否存在，如果不存在則看條件創建 (4) 執行open的最后步驟， 例如調用open 回調

??我們使用的open函數在內核中對應的是sys_open函數，sys_open函數又會調用do_sys_open函數。在do_sys_open函數中，首先調用函數get_unused_fd_flags來獲取一個未被使用的文件描述符fd，該文件描述符就是我們最終通過open函數得到的值。緊接著，又調用了do_filp_open函數，該函數通過調用函數get_empty_filp得到一個新的file結構體，之后的代碼做了許多復雜的工作，如解析文件路徑，查找該文件的文件節點inode等，直接來到了函do_dentry_open函數，如下所示

fs/open.cdo_sys_open->do_sys_openat2->do_filp_open->path_openat->do_open->vfs_openint vfs_open(const struct path *path, struct file *file) {file->f_path = *path;return do_dentry_open(file, d_backing_inode(path->dentry), NULL); }static int do_dentry_open(struct file *f,struct inode *inode,int (*open)(struct inode *, struct file *)) {static const struct file_operations empty_fops = {};int error;path_get(&f->f_path);f->f_inode = inode;f->f_mapping = inode->i_mapping;f->f_wb_err = filemap_sample_wb_err(f->f_mapping);f->f_sb_err = file_sample_sb_err(f); /* 1 */if (unlikely(f->f_flags & O_PATH)) {f->f_mode = FMODE_PATH | FMODE_OPENED;f->f_op = &empty_fops;return 0;}if (f->f_mode & FMODE_WRITE && !special_file(inode->i_mode)) {error = get_write_access(inode);if (unlikely(error))goto cleanup_file;error = __mnt_want_write(f->f_path.mnt);if (unlikely(error)) {put_write_access(inode);goto cleanup_file;}f->f_mode |= FMODE_WRITER;}/* POSIX.1-2008/SUSv4 Section XSI 2.9.7 */if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))f->f_mode |= FMODE_ATOMIC_POS;f->f_op = fops_get(inode->i_fop); /*取該文件節點inode的成員變量i_fop*/if (WARN_ON(!f->f_op)) {error = -ENODEV;goto cleanup_all;}error = security_file_open(f);if (error)goto cleanup_all;error = break_lease(locks_inode(f), f->f_flags);if (error)goto cleanup_all;/* normally all 3 are set; ->open() can clear them if needed */f->f_mode |= FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE;if (!open)open = f->f_op->open;if (open) {error = open(inode, f); /* 3 */if (error)goto cleanup_all;}f->f_mode |= FMODE_OPENED;if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)i_readcount_inc(inode);if ((f->f_mode & FMODE_READ) &&likely(f->f_op->read || f->f_op->read_iter))f->f_mode |= FMODE_CAN_READ;if ((f->f_mode & FMODE_WRITE) &&likely(f->f_op->write || f->f_op->write_iter))f->f_mode |= FMODE_CAN_WRITE;f->f_write_hint = WRITE_LIFE_NOT_SET;f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);/* NB: we're sure to have correct a_ops only after f_op->open */if (f->f_flags & O_DIRECT) {if (!f->f_mapping->a_ops || !f->f_mapping->a_ops->direct_IO)return -EINVAL;}/** XXX: Huge page cache doesn't support writing yet. Drop all page* cache for this file before processing writes.*/if ((f->f_mode & FMODE_WRITE) && filemap_nr_thps(inode->i_mapping))truncate_pagecache(inode, 0);return 0;cleanup_all:if (WARN_ON_ONCE(error > 0))error = -EINVAL;fops_put(f->f_op);if (f->f_mode & FMODE_WRITER) {put_write_access(inode);__mnt_drop_write(f->f_path.mnt);} cleanup_file:path_put(&f->f_path);f->f_path.mnt = NULL;f->f_path.dentry = NULL;f->f_inode = NULL;return error; }def_chr_fops結構體（位于內核源碼/fs/char_dev.c文件） const struct file_operations def_chr_fops = {.open = chrdev_open,.llseek = noop_llseek, }; (1) (2) 設置file結構體的一些成員 (3) 找到open 回調， 并執行 以上代碼中的使用fops_get函數來獲取該文件節點inode的成員變量i_fop，在上圖中我們使用mknod創建字符設備文件時，將def_chr_fops結構體賦值給了該設備文件inode的i_fop成員。到了這里，我們新建的file結構體的成員f_op就指向了def_chr_fops。

最終，會執行def_chr_fops中的open函數，也就是chrdev_open函數，可以理解為一個字符設備的通用初始化函數，根據字符設備的設備號，找到相應的字符設備，從而得到操作該設備的方法，代碼實現如下。

chrdev_open函數（位于內核源碼/fs/char_dev.c文件）

static int chrdev_open(struct inode *inode, struct file *filp) {const struct file_operations *fops;struct cdev *p;struct cdev *new = NULL;int ret = 0;spin_lock(&cdev_lock);p = inode->i_cdev;if (!p) {struct kobject *kobj;int idx;spin_unlock(&cdev_lock);kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);if (!kobj)return -ENXIO;new = container_of(kobj, struct cdev, kobj);spin_lock(&cdev_lock);/* Check i_cdev again in case somebody beat us to it whilewe dropped the lock.*/p = inode->i_cdev;if (!p) {inode->i_cdev = p = new;list_add(&inode->i_devices, &p->list);new = NULL;} else if (!cdev_get(p))ret = -ENXIO;} else if (!cdev_get(p))ret = -ENXIO;spin_unlock(&cdev_lock);cdev_put(new);if (ret)return ret;ret = -ENXIO;fops = fops_get(p->ops);if (!fops)goto out_cdev_put;replace_fops(filp, fops);if (filp->f_op->open) {ret = filp->f_op->open(inode, filp);if (ret)goto out_cdev_put;}return 0;out_cdev_put:cdev_put(p);return ret;}

??在Linux內核中，使用結構體cdev來描述一個字符設備。在以上代碼中的第14行，inode->i_rdev中保存了字符設備的設備編號，通過函數kobj_lookup函數便可以找到該設備文件cdev結構體的kobj成員，再通過函數container_of便可以得到該字符設備對應的結構體cdev。函數container_of的作用就是通過一個結構變量中一個成員的地址找到這個結構體變量的首地址。同時，將cdev結構體記錄到文件節點inode中的i_cdev，便于下次打開該文件。繼續閱讀第36~45行代碼，我們可以發現，函數chrdev_open最終將該文件結構體file的成員f_op替換成了cdev對應的ops成員，并執行ops結構體中的open函數。
??最后，調用上圖的fd_install函數，完成文件描述符和文件結構體file的關聯，之后我們使用對該文件描述符fd調用read、write函數，最終都會調用file結構體對應的函數，實際上也就是調用cdev結構體中ops結構體內的相關函數

總結

以上是生活随笔為你收集整理的linux设备驱动模型一字符设备open系统调用流程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。