file_operation结构体详解

file_operation结构体详解
2011年06月22日
　　ile_operations结构体分析
　　2009年12月16日 星期三 16:40
　　结构体file_operations在头文件 linux/fs.h中定义，用来存储驱动内核模块提供的对 设备进行各种操作的函数的指针。该结构体的每个域都对应着驱动内核模块用来处理某个被请求的 事务的函数的地址。
　　举个例子，每个字符设备需要定义一个用来读取设备数据的函数。结构体 file_operations中存储着内核模块中执行这项操作的函数的地址。一下是该结构体 在内核2.6.5中看起来的样子：
　　struct file_operations {
　　struct module *owner;
　　loff_t(*llseek) (struct file *, loff_t, int);
　　ssize_t(*read) (struct file *, char __user *, size_t, loff_t *);
　　ssize_t(*aio_read) (struct kiocb *, char __user *, size_t, loff_t);
　　ssize_t(*write) (struct file *, const char __user *, size_t, loff_t *);
　　ssize_t(*aio_write) (struct kiocb *, const char __user *, size_t,
　　loff_t);
　　int (*readdir) (struct file *, void *, filldir_t);
　　unsigned int (*poll) (struct file *, struct poll_table_struct *);
　　int (*ioctl) (struct inode *, struct file *, unsigned int,
　　unsigned long);
　　int (*mmap) (struct file *, struct vm_area_struct *);
　　int (*open) (struct inode *, struct file *);
　　int (*flush) (struct file *);
　　int (*release) (struct inode *, struct file *);
　　int (*fsync) (struct file *, struct dentry *, int datasync);
　　int (*aio_fsync) (struct kiocb *, int datasync);
　　int (*fasync) (int, struct file *, int);
　　int (*lock) (struct file *, int, struct file_lock *);
　　ssize_t(*readv) (struct file *, const struct iovec *, unsigned long,
　　loff_t *);
　　ssize_t(*writev) (struct file *, const struct iovec *, unsigned long,
　　loff_t *);
　　ssize_t(*sendfile) (struct file *, loff_t *, size_t, read_actor_t,
　　void __user *);
　　ssize_t(*sendpage) (struct file *, struct page *, int, size_t,
　　loff_t *, int);
　　unsigned long (*get_unmapped_area) (struct file *, unsigned long,
　　unsigned long, unsigned long,
　　unsigned long);
　　};
　　驱动内核模块是不需要实现每个函数的。像视频卡的驱动就不需要从目录的结构 中读取数据。那么，相对应的file_operations重的项就为 NULL。
　　gcc还有一个方便使用这种结构体的扩展。你会在较现代的驱动内核模块中见到。 新的使用这种结构体的方式如下：
　　struct file_operations fops = {
　　read: device_read,
　　write: device_write,
　　open: device_open,
　　release: device_release
　　};
　　同样也有C99语法的使用该结构体的方法，并且它比GNU扩展更受推荐。我使用的版本为 2.95为了方便那些想移植你的代码的人，你最好使用这种语法。它将提高代码的兼容性：
　　struct file_operations fops = {
　　.read = device_read,
　　.write = device_write,
　　.open = device_open,
　　.release = device_release
　　};
　　这种语法很清晰，你也必须清楚的意识到没有显示声明的结构体成员都被gcc初始化为NULL。
　　指向结构体struct file_operations的指针通常命名为fops。
　　关于file结构体
　　每一个设备文件都代表着内核中的一个file结构体。该结构体在头文件linux/fs.h定义。注意，file结构体是内核空间的结构体， 这意味着它不会在用户程序的代码中出现。它绝对不是在glibc中定义的FILE。 FILE自己也从不在内核空间的函数中出现。它的名字确实挺让人迷惑的。 它代表着一个抽象的打开的文件，但不是那种在磁盘上用结构体 inode表示的文件。
　　指向结构体struct file的指针通常命名为filp。 你同样可以看到struct file file的表达方式，但不要被它诱惑。
　　去看看结构体file的定义。大部分的函数入口，像结构体 struct dentry没有被设备驱动模块使用，你大可忽略它们。这是因为设备驱动模块并不自己直接填充结构体 file：它们只是使用在别处建立的结构体file中的数据。
　　注册一个设备
　　如同先前讨论的，字符设备通常通过在路径/dev[1]设备文 件访问。主设备号告诉你哪些驱动模块是用来操纵哪些硬件设备的。从设备号是驱动模 块自己使用来区别它操纵的不同设备，当此驱动模块操纵不只一个设备时。
　　将内核驱动模块加载入内核意味着要向内核注册自己。这个工作是和驱动模块获 得主设备号时初始化一同进行的。你可以使用头文件 linux/fs.h中的函数register_chrdev来实现。
　　int register_chrdev(unsigned int major, const char *name, struct file_operations *fops);
　　其中unsigned int major是你申请的主设备号， const char *name是将要在文件/proc/devices struct file_operations *fops是指向你的驱动模块的 file_operations表的指针。负的返回值意味着注册失败。 注意注册并不需要提供从设备号。内核本身并不在意从设备号。
　　现在的问题是你如何申请到一个没有被使用的主设备号？最简单的方法是查看文件 Documentation/devices.txt从中挑选一个没有被使用的。这不是 一劳永逸的方法因为你无法得知该主设备号在将来会被占用。最终的方法是让内核为你动 态分配一个。
　　如果你向函数register_chrdev传递为0的主设备号，那么 返回的就是动态分配的主设备号。副作用就是既然你无法得知主设备号，你就无法预先建 立一个设备文件。 有多种解决方法。第一种方法是新注册的驱动模块会输出自己新分配 到的主设备号，所以我们可以手工建立需要的设备文件。第二种是利用文件 /proc/devices新注册的驱动模块的入口，要么手工建立设备文件， 要么编一个脚本去自动读取该文件并且生成设备文件。第三种是在我们的模块中，当注册 成功时，使用mknod统调用建立设备文件并且调用 rm 删除该设备 文件在驱动模块调用函数cleanup_module前。
　　注销一个设备
　　即使时root也不能允许随意卸载内核模块。当一个进程已经打开一个设备文件时我 们卸载了该设备文件使用的内核模块，我们此时再对该文件的访问将会导致对已卸载的内 核模块代码内存区的访问。幸运的话我们最多获得一个讨厌的错误警告。如果此时已经在 该内存区加载了另一个模块，倒霉的你将会在内核中跳转执行意料外的代码。结果是无法 预料的，而且多半是不那么令人愉快的。
　　平常，当你不允许某项操作时，你会得到该操作返回的错误值（一般为一负的值）。 但对于无返回值的函数cleanup_module这是不可能的。然而，却有 一个计数器跟踪着有多少进程正在使用该模块。你可以通过查看文件 /proc/modules的第三列来获取这些信息。如果该值非零，则卸载 就会失败。你不需要在你模块中的函数cleanup_module中检查该 计数器，因为该项检查由头文件linux/module.c中定义的系统调用 sys_delete_module完成。你也不应该直接对该计数器进行操作。 你应该使用在文件linux/modules.h定义的宏 来增加，减小和读取该计数器：
　　try_module_get(THIS_MODULE): Increment the use count.
　　try_module_put(THIS_MODULE): Decrement the use count.
　　保持该计数器时刻精确是非常重要的；如果你丢失了正确的计数，你将无法卸载模块， 那就只有重启了。不过这种情况在今后编写内核模块时也是无法避免的。
　　chardev.c
　　下面的代码示范了一个叫做chardev的字符设备。你可以用 cat输出该设备文件的内容（或用别的程序打开它）时，驱动模块 会将该设备文件被读取的次数显示。目前对设备文件的写操作还不被支持（像echo "hi" > /dev/hello），但会捕捉这些操作并且告诉用户该操作不被支持。不要担心我 们对读入缓冲区的数据做了什么；我们什么都没做。我们只是读入数据并输出我们已经接 收到的数据的信息。
　　Example 4-1. chardev.c
　　/*
　　* chardev.c: Creates a read-only char device that says how many times
　　* you've read from the dev file
　　*/
　　#include
　　#include
　　#include
　　#include /* for put_user */
　　/*
　　* Prototypes - this would normally go in a .h file
　　*/
　　int init_module(void);
　　void cleanup_module(void);
　　static int device_open(struct inode *, struct file *);
　　static int device_release(struct inode *, struct file *);
　　static ssize_t device_read(struct file *, char *, size_t, loff_t *);
　　static ssize_t device_write(struct file *, const char *, size_t, loff_t *);
　　#define SUCCESS 0
　　#define DEVICE_NAME "chardev" /* Dev name as it appears in /proc/devices */
　　#define BUF_LEN 80 /* Max length of the message from the device */
　　/*
　　* Global variables are declared as static, so are global within the file.
　　*/
　　static int Major; /* Major number assigned to our device driver */
　　static int Device_Open = 0; /* Is device open?
　　* Used to prevent multiple access to device */
　　static char msg[BUF_LEN]; /* The msg the device will give when asked */
　　static char *msg_Ptr;
　　static struct file_operations fops = {
　　.read = device_read,
　　.write = device_write,
　　.open = device_open,
　　.release = device_release
　　};
　　/*
　　* Functions
　　*/
　　int init_module(void)
　　{
　　Major = register_chrdev(0, DEVICE_NAME, &fops);
　　if (Major I was assigned major number %d. To talk to\n", Major);
　　printk("the driver, create a dev file with\n");
　　printk("'mknod /dev/hello c %d 0'.\n", Major);
　　printk("Try various minor numbers. Try to cat and echo to\n");
　　printk("the device file.\n");
　　printk("Remove the device file and module when done.\n");
　　return 0;
　　}
　　void cleanup_module(void)
　　{
　　/*
　　* Unregister the device
　　*/
　　int ret = unregister_chrdev(Major, DEVICE_NAME);
　　if (ret msg, "I already told you %d times Hello world!\n", counter++);
　　msg_Ptr = msg;
　　try_module_get(THIS_MODULE);
　　return SUCCESS;
　　}
　　/*
　　* Called when a process closes the device file.
　　*/
　　static int device_release(struct inode *inode, struct file *file)
　　{
　　Device_Open--; /* We're now ready for our next caller */
　　/*
　　* Decrement the usage count, or else once you opened the file, you'll
　　* never get get rid of the module.
　　*/
　　module_put(THIS_MODULE);
　　return 0;
　　}
　　/*
　　* Called when a process, which already opened the dev file, attempts to
　　* read from it.
　　*/
　　static ssize_t device_read(struct file *filp, /* see include/linux/fs.h */
　　char *buffer, /* buffer to fill with data */
　　size_t length, /* length of the buffer */
　　loff_t * offset)
　　{
　　/*
　　* Number of bytes actually written to the buffer
　　*/
　　int bytes_read = 0;
　　/*
　　* If we're at the end of the message,
　　* return 0 signifying end of file
　　*/
　　if (*msg_Ptr == 0)
　　return 0;
　　/*
　　* Actually put the data into the buffer
　　*/
　　while (length && *msg_Ptr) {
　　/*
　　* The buffer is in the user data segment, not the kernel
　　* segment so "*" assignment won't work. We have to use
　　* put_user which copies data from the kernel data segment to
　　* the user data segment.
　　*/
　　put_user(*(msg_Ptr++), buffer++);
　　length--;
　　bytes_read++;
　　}
　　/*
　　* Most read functions return the number of bytes put into the buffer
　　*/
　　return bytes_read;
　　}
　　/*
　　* Called when a process writes to dev file: echo "hi" > /dev/hello
　　*/
　　static ssize_t
　　device_write(struct file *filp, const char *buff, size_t len, loff_t * off)
　　{
　　printk("Sorry, this operation isn't supported.\n");
　　return -EINVAL;
　　}为多个版本的内核编写内核模块
　　系统调用，也就是内核提供给进程的接口，基本上是保持不变的。也许会添入新的 系统调用，但那些已有的不会被改动。这对于向下兼容是非常重要的。在多数情况下，设 备文件是保持不变的。但内核的内部在不同版本之间还是会有区别的。
　　Linux内核分为稳定版本（版本号中间为偶数）和试验版本（版本号中间为奇数）。 试验版本中可以试验各种各样的新而酷的主意，有些会被证实是一个错误，有些在下一版 中会被完善。总之，你不能依赖这些版本中的接口（这也是我不在本文档中支持它们的原因， 它们更新的太快了)。在稳定版本中，我们可以期望接口保持一致，除了那些修改代码中错误的版本。
　　如果你要支持多版本的内核，你需要编写为不同内核编译的代码树。可以通过比较宏 LINUX_VERSION_CODE和宏KERNEL_VERSION在版本号为a.b.c 的内核中，该宏的值应该为 2^16×a+2^8×b+c
　　在上一个版本中该文档还保留了详细的如何向后兼容老内核的介绍，现在我们决定打破这个传统。 对为老内核编写驱动感兴趣的读者应该参考对应版本的LKMPG，也就是说，2.4.x版本的LKMPG对应 2.4.x的内核，2.6.x版本的LKMPG对应2.6.x的内核。
　　本文来自优快云博客，转载请标明出处：http://blog.youkuaiyun.com/zkx1982/archive/2008/06/12/2540401.aspx
　　struct module *owner
　　第一个 file_operations 成员根本不是一个操作; 它是一个指向拥有这个结构的模块的指针.
　　这个成员用来在它的操作还在被使用时阻止模块被卸载. 几乎所有时间中, 它被简单初始化为
　　THIS_MODULE, 一个在 中定义的宏.这个宏比较复杂，在进行简单学习操作的时候，一般初始化为THIS_MODULE。
　　loff_t (*llseek) (struct file * filp , loff_t p, int orig);
　　(指针参数filp为进行读取信息的目标文件结构体指针；参数 p 为文件定位的目标偏移量；参数orig为对文件定位
　　的起始地址，这个值可以为文件开头（SEEK_SET，0,当前位置(SEEK_CUR,1)，文件末尾(SEEK_END,2)）
　　llseek 方法用作改变文件中的当前读/写位置, 并且新位置作为(正的)返回值.
　　loff_t 参数是一个"long offset", 并且就算在 32位平台上也至少 64 位宽. 错误由一个负返回值指示.
　　如果这个函数指针是 NULL, seek 调用会以潜在地无法预知的方式修改 file 结构中的位置计数器( 在"file 结构" 一节中描述).
　　ssize_t (*read) (struct file * filp, char __user * buffer, size_t size , loff_t * p);
　　(指针参数 filp 为进行读取信息的目标文件，指针参数buffer 为对应放置信息的缓冲区（即用户空间内存地址），
　　参数size为要读取的信息长度，参数 p 为读的位置相对于文件开头的偏移，在读取信息后，这个指针一般都会移动，移动的值为要读取信息的长度值）
　　这个函数用来从设备中获取数据. 在这个位置的一个空指针导致 read 系统调用以 -EINVAL("Invalid argument") 失败.
　　一个非负返回值代表了成功读取的字节数( 返回值是一个 "signed size" 类型, 常常是目标平台本地的整数类型).
　　ssize_t (*aio_read)(struct kiocb * , char __user * buffer, size_t size , loff_t p);
　　可以看出，这个函数的第一、三个参数和本结构体中的read()函数的第一、三个参数是不同 的，
　　异步读写的第三个参数直接传递值，而同步读写的第三个参数传递的是指针，因为AIO从来不需要改变文件的位置。
　　异步读写的第一个参数为指向kiocb结构体的指针，而同步读写的第一参数为指向file结构体的指针，每一个I/O请求都对应一个kiocb结构体);
　　初始化一个异步读 -- 可能在函数返回前不结束的读操作.如果这个方法是 NULL, 所有的操作会由 read 代替进行(同步地).
　　(有关linux异步I/O，可以参考有关的资料，《linux设备驱动开发详解》中给出了详细的解答)
　　ssize_t (*write) (struct file * filp, const char __user * buffer, size_t count, loff_t * ppos);
　　(参数filp为目标文件结构体指针，buffer为要写入文件的信息缓冲区，count为要写入信息的长度，
　　ppos为当前的偏移位置，这个值通常是用来判断写文件是否越界）
　　发送数据给设备. 如果 NULL, -EINVAL 返回给调用 write 系统调用的程序. 如果非负, 返回值代表成功写的字节数.
　　(注：这个操作和上面的对文件进行读的操作均为阻塞操作）
　　ssize_t (*aio_write)(struct kiocb *, const char __user * buffer, size_t count, loff_t * ppos);
　　初始化设备上的一个异步写.参数类型同aio_read()函数;
　　int (*readdir) (struct file * filp, void *, filldir_t);
　　对于设备文件这个成员应当为 NULL; 它用来读取目录, 并且仅对文件系统有用.
　　unsigned int (*poll) (struct file *, struct poll_table_struct *);
　　(这是一个设备驱动中的轮询函数，第一个参数为file结构指针，第二个为轮询表指针）
　　这个函数返回设备资源的可获取状态，即POLLIN，POLLOUT，POLLPRI，POLLERR，POLLNVAL等宏的位“或”结果。
　　每个宏都表明设备的一种状态，如：POLLIN（定义为0x0001）意味着设备可以无阻塞的读，POLLOUT（定义为0x0004）意味着设备可以无阻塞的写。
　　(poll 方法是 3 个系统调用的后端: poll, epoll, 和 select, 都用作查询对一个或多个文件描述符的读或写是否会阻塞.
　　poll 方法应当返回一个位掩码指示是否非阻塞的读或写是可能的, 并且, 可能地, 提供给内核信息用来使调用进程睡眠直到 I/O 变为可能.
　　如果一个驱动的 poll 方法为 NULL, 设备假定为不阻塞地可读可写.
　　(这里通常将设备看作一个文件进行相关的操作，而轮询操作的取值直接关系到设备的响应情况，可以是阻塞操作结果，同时也可以是非阻塞操作结果）
　　int (*ioctl) (struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);
　　(inode 和 filp 指针是对应应用程序传递的文件描述符 fd 的值, 和传递给 open 方法的相同参数.
　　cmd 参数从用户那里不改变地传下来, 并且可选的参数 arg 参数以一个 unsigned long 的形式传递, 不管它是否由用户给定为一个整数或一个指针.
　　如果调用程序不传递第 3 个参数, 被驱动操作收到的 arg 值是无定义的.
　　因为类型检查在这个额外参数上被关闭, 编译器不能警告你如果一个无效的参数被传递给 ioctl, 并且任何关联的错误将难以查找.）
　　ioctl 系统调用提供了发出设备特定命令的方法(例如格式化软盘的一个磁道, 这不是读也不是写). 另外, 几个 ioctl 命令被内核识别而不必引用 fops 表.
　　如果设备不提供 ioctl 方法, 对于任何未事先定义的请求(-ENOTTY, "设备无这样的 ioctl"), 系统调用返回一个错误.
　　int (*mmap) (struct file *, struct vm_area_struct *);
　　mmap 用来请求将设备内存映射到进程的地址空间. 如果这个方法是 NULL, mmap 系统调用返回 -ENODEV.
　　(如果想对这个函数有个彻底的了解，那么请看有关“进程地址空间”介绍的书籍)
　　int (*open) (struct inode * inode , struct file * filp ) ;
　　(inode 为文件节点,这个节点只有一个，无论用户打开多少个文件，都只是对应着一个inode结构；
　　但是filp就不同，只要打开一个文件，就对应着一个file结构体，file结构体通常用来追踪文件在运行时的状态信息）
　　尽管这常常是对设备文件进行的第一个操作, 不要求驱动声明一个对应的方法. 如果这个项是 NULL, 设备打开一直成功, 但是你的驱动不会得到通知.
　　与open()函数对应的是release()函数。
　　int (*flush) (struct file *);
　　flush 操作在进程关闭它的设备文件描述符的拷贝时调用; 它应当执行(并且等待)设备的任何未完成的操作.
　　这个必须不要和用户查询请求的 fsync 操作混淆了. 当前, flush 在很少驱动中使用;
　　SCSI 磁带驱动使用它, 例如, 为确保所有写的数据在设备关闭前写到磁带上. 如果 flush 为 NULL, 内核简单地忽略用户应用程序的请求.
　　int (*release) (struct inode *, struct file *);
　　release ()函数当最后一个打开设备的用户进程执行close()系统调用的时候，内核将调用驱动程序release()函数：
　　void release(struct inode inode,struct file *file),release函数的主要任务是清理未结束的输入输出操作，释放资源，用户自定义排他标志的复位等。
　　在文件结构被释放时引用这个操作. 如同 open, release 可以为 NULL.
　　int(*synch)(struct file *,struct dentry *,int datasync);
　　刷新待处理的数据,允许进程把所有的脏缓冲区刷新到磁盘。
　　int (*aio_fsync)(struct kiocb *, int);
　　这是 fsync 方法的异步版本.所谓的fsync方法是一个系统调用函数。系统调用fsync
　　把文件所指定的文件的所有脏缓冲区写到磁盘中（如果需要，还包括存有索引节点的缓冲区）。
　　相应的服务例程获得文件对象的地址，并随后调用fsync方法。通常这个方法以调用函数__writeback_single_inode()结束，
　　这个函数把与被选中的索引节点相关的脏页和索引节点本身都写回磁盘。
　　int (*fasync) (int, struct file *, int);
　　这个函数是系统支持异步通知的设备驱动，下面是这个函数的模板：
　　static int ***_fasync(int fd,struct file *filp,int mode)
　　{
　　struct ***_dev * dev=filp->private_data;
　　return fasync_helper(fd,filp,mode,&dev->async_queue);//第四个参数为 fasync_struct结构体指针的指针。
　　//这个函数是用来处理FASYNC标志的函数。（FASYNC：表示兼容BSD的fcntl同步操作）当这个标志改变时，驱动程序中的fasync（）函数将得到执行。
　　}
　　此操作用来通知设备它的 FASYNC 标志的改变. 异步通知是一个高级的主题, 在第 6 章中描述.
　　这个成员可以是NULL 如果驱动不支持异步通知.
　　int (*lock) (struct file *, int, struct file_lock *);
　　lock 方法用来实现文件加锁; 加锁对常规文件是必不可少的特性, 但是设备驱动几乎从不实现它.
　　ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);
　　ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);
　　这些方法实现发散/汇聚读和写操作. 应用程序偶尔需要做一个包含多个内存区的单个读或写操作;
　　这些系统调用允许它们这样做而不必对数据进行额外拷贝. 如果这些函数指针为 NULL, read 和 write 方法被调用( 可能多于一次 ).
　　ssize_t (*sendfile)(struct file *, loff_t *, size_t, read_actor_t, void *);
　　这个方法实现 sendfile 系统调用的读, 使用最少的拷贝从一个文件描述符搬移数据到另一个.
　　例如, 它被一个需要发送文件内容到一个网络连接的 web 服务器使用. 设备驱动常常使 sendfile 为 NULL.
　　ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
　　sendpage 是 sendfile 的另一半; 它由内核调用来发送数据, 一次一页, 到对应的文件. 设备驱动实际上不实现 sendpage.
　　unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
　　这个方法的目的是在进程的地址空间找一个合适的位置来映射在底层设备上的内存段中.
　　这个任务通常由内存管理代码进行; 这个方法存在为了使驱动能强制特殊设备可能有的任何的对齐请求. 大部分驱动可以置这个方法为 NULL.[10]
　　int (*check_flags)(int)
　　这个方法允许模块检查传递给 fnctl(F_SETFL...) 调用的标志.
　　int (*dir_notify)(struct file *, unsigned long);
　　这个方法在应用程序使用 fcntl 来请求目录改变通知时调用. 只对文件系统有用; 驱动不需要实现 dir_notify.
　　一般情况下，进行设备驱动程序的设计只是比较注重下面的几个方法：
　　struct file_operations ***_ops={
　　.owner = THIS_MODULE,
　　.llseek = ***_llseek,
　　.read = ***_read,
　　.write = ***_write,
　　.ioctl = ***_ioctl,
　　.open = ***_open,
　　.release = ***_release,
　　};