【内核&驱动】字符设备驱动程序【2】

一些重要的数据结构(VFS核心结构体)
1.super_block
和mount一一对应，这也意味着如果mount操作，在内核中分配新的结构体，存储分区信息
umount时，VFS就把该结构体释放掉
mount几次内核中就有几个super_block结构体

2.inode
和打开文件一一对应,记录文件信息，关闭文件时，如果内存不紧张，不会释放，
如果多个人同时打开一个文件，VFS只需创建一个inode

3.file <linux/fs.h>
和用户态对文件操作open一一对应,每次open生成一个file结构体,
内核中有多个file结构体和打开的文件对应
该结构与用户空间的FILE没有任何关联，他代表一个打开的文件，它由内核在open时创建
直到最后的close函数，在文件的所有实例都被关闭之后，内核会释放这个数据结构
指向struct file的指针称为文件指针

1. struct file {
   
2. union {
   
3. struct list_headfu_list;
   
4. struct rcu_head fu_rcuhead;
   
5. } f_u;
   
6. struct pathf_path;
   
7. #define f_dentryf_path.dentry
   
8. //文件对应的目录项结构
   
9. #define f_vfsmntf_path.mnt
   
10. const struct file_operations*f_op;
    
11. atomic_long_tf_count;
    
12. unsigned int f_flags;
    
13. //文件标志， 如O_RDONLY, O_NONBLOCK, O_SYNC
    
14. fmode_tf_mode;
    
15. //文件模式
    
16. loff_tf_pos;
    
17. //文件当前读/写位置
    
18. struct fown_structf_owner;
    
19. unsigned intf_uid, f_gid;
    
20. struct file_ra_statef_ra;
    
21. 
    
22. u64f_version;
    
23. #ifdef CONFIG_SECURITY
    
24. void*f_security;
    
25. #endif
    
26. /* needed for tty driver, and maybe others */
    
27. void*private_data;
    
28. 
    
29. 
    
30. #ifdef CONFIG_EPOLL
    
31. /* Used by fs/eventpoll.c to link all the hooks to this file */
    
32. struct list_headf_ep_links;
    
33. spinlock_tf_ep_lock;
    
34. #endif /* #ifdef CONFIG_EPOLL */
    
35. struct address_space*f_mapping;
    
36. #ifdef CONFIG_DEBUG_WRITECOUNT
    
37. unsigned long f_mnt_write_state;
    
38. #endif
    
39. };

4.file_operations <linux/fs.h>
其中包括了一组函数指针，每个打开的文件和一组函数关联起来；这些操作用于实现系统调用
file_operations和指向这类结构的指针叫做fops

1. struct file_operations {
   
2. struct module *owner;
   
3. 指向拥有该结构的模块的指针,防止模块的操作在被使用的时候卸载该模块
   
4. .onwer = THIS_MODULE
   
5. loff_t (*llseek) (struct file *, loff_t, int);
   
6. 修改文件的当前读写位置，返回新位置
   
7. struct file*当前文件
   
8. loff_t 长偏移量
   
9. int
   
10. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    
11. 从设备中读数据
    
12. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    
13. 向设备发送数据
    
14. ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    
15. 初始化一个异步读取操作
    
16. ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
    
17. 初始化设备上的异步写入操作
    
18. int (*readdir) (struct file *, void *, filldir_t);
    
19. 对设备文件来说，应该置null，用于读取目录，只对文件系统有用
    
20. unsigned int (*poll) (struct file *, struct poll_table_struct *);
    
21. 是poll,epoll,select的后端实现
    
22. int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
    
23. 提供了一种执行设备特定命令的方法
    
24. long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    
25. long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    
26. int (*mmap) (struct file *, struct vm_area_struct *);
    
27. 用于请求将设备内存映射到进程地址空间
    
28. int (*open) (struct inode *, struct file *);
    
29. 对设备文件执行的第一个操作，但不要求驱动程序一定声明该方法，
    
30. 如果置为NULL，设备的打开永远有效，但系统不会通知驱动程序
    
31. int (*flush) (struct file *, fl_owner_t id);
    
32. 发生在进程关闭设备文件描述符副本的时候，用来执行设备上尚未完成的操作
    
33. int (*release) (struct inode *, struct file *);
    
34. 当file被释放时， 将调用这个操作，与open相仿，也可设置为NULL
    
35. int (*fsync) (struct file *, struct dentry *, int datasync);
    
36. 刷新待处理的数据
    
37. int (*aio_fsync) (struct kiocb *, int datasync);
    
38. fsync的异步方法
    
39. int (*fasync) (int, struct file *, int);
    
40. 通知设备其FASYNC状态发生了变化
    
41. int (*lock) (struct file *, int, struct file_lock *);
    
42. 实现文件锁
    
43. ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
    
44. 发送数据，每次一页
    
45. unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
    
46. 将底层设备中的内存段映射到进程空间的合适的位置
    
47. int (*check_flags)(int);
    
48. 检查传递给fcntl(F_SETFL...)调用的标志
    
49. int (*dir_notify)(struct file *filp, unsigned long arg);
    
50. int (*flock) (struct file *, int, struct file_lock *);
    
51. ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
    
52. ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    
53. int (*setlease)(struct file *, long, struct file_lock **);
    
54. };

file_operations的初始化方式

1. struct file_operations scull_fops = {
   
2. .owner = THIS_MODULE,
   
3. .llseek = scull_llseek,
   
4. .read = scull_read,
   
5. .write = scull_write,
   
6. .ioctl = scull_ioctl,
   
7. .open = scull_open,
   
8. .release = scull_release,
   
9. };

字符设备的注册
在运行的时候获得一个独立的cdev结构：

1. struct cdev *my_cdev = cdev_alloc();
   
2. my_cdev->ops = &my_fops;

此时就可以将cdev结构嵌入到自己的设备的特定结构中
以下代码用来初始化已分配到的结构：

1. void cdev_init(struct cdev *cdev, struct file_operations *fops);

通过以下代码告知内核结构的信息：

1. int cdev_add(struct cdev *dev, dev_t num, unsigned int count);

dev 是cdev结构
num 是该设备对应的第一设备编号
count 是应该和该设备关联的设备号的数量

scull中的设备注册
在scull内部， 他通过struct scull_dev的结构来表示每个设备

1. struct scull_dev {
   
2. struct scull_qset *data;/* 指向第一个量子集的指针 */
   
3. int quantum;/* 当前量子的大小 */
   
4. int qset;/* 当前数组的大小 */
   
5. unsigned long size;/* 保存在其中的数据总量 */
   
6. unsigned int access_key;/* 由sculluid和scullpriv使用 */
   
7. struct semaphore sem;/* 互斥信号量 */
   
8. struct cdev cdev/* 字符设备结构 */
   
9. };

量子：我们把每一个内存区域称之为量子，一个指向这些量子的指针数组称之为量子集

1. static void scull_setup_cdev(struct scull_dev *dev, int index)
   
2. {
   
3. int err, devno;
   
4. devno = MKDEV(scull_major, scull_minor index);
   
5. 
   
6. cdev_init(&dev->sdev, &scull_fops);
   
7. dev->cdev.owner = THIS_MODULE;
   
8. dev->cdev.ops = &scull_fops;
   
9. 
   
10. err = cdev_add(&dev->cdev, devno, 1);
    
11. if (err) {
    
12. printk(KERN_NOTICE "Error %d adding scull%d", err, index);
    
13. }
    
14. }

早期办法(内核2.6之前的版本的设备注册的方法)

注册：

1. int register_chrdev(unsigned int major,
   
2. const char * name,
   
3. struct file_operations *fops);

释放：

1. int unregister_chrdev(unsigned int major, const char * name);