devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Linux 驱动基础】第一个驱动

作者：2023面试高手 | 2024-03-28 17:46:22

赞

踩

【Linux 驱动基础】第一个驱动

# 前置知识

        APP 打开文件时，可以得到一个整数，这个整数被称为文件句柄。对于 APP的每一个文件句柄，在内核里面都有一个“ struct file”与之对应。

  • 使用open函数时，用户态调用 API 触发异常进入内核
  • 内核识别异常后，取出异常值，从而调用sys_call_table[__NR_open]，sys_call_table就是一个数组，其值为typedef void (*sys_call_ptr_t)(void)类型的函数指针，内容大致如下：
  1. __SYSCALL_COMMON(0, sys_read, sys_read)
  2. __SYSCALL_COMMON(1, sys_write, sys_write)
  3. __SYSCALL_COMMON(2, sys_open, sys_open)
  4. __SYSCALL_COMMON(3, sys_close, sys_close)
  5. __SYSCALL_COMMON(5, sys_newfstat, sys_newfstat)
  6. ...
  7. ...
  8. ...
  •  最后调用sys_open函数，sys_open函数定义如下：
  1. SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, int, mode)
  2. {
  3. 	long ret;
  4.  
  5. 	if (force_o_largefile())
  6. 		flags |= O_LARGEFILE;
  7.  
  8. 	ret = do_sys_open(AT_FDCWD, filename, flags, mode);
  9. 	/* avoid REGPARM breakage on x86: */
  10. 	asmlinkage_protect(3, ret, filename, flags, mode);
  11. 	return ret;
  12. }
  • 在sys_open函数里面，又调用了 de_sys_open 函数，定义如下：
  1.  
  2. long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
  3. {
  4. 	char *tmp = getname(filename);
  5. 	int fd = PTR_ERR(tmp);
  6.  
  7. 	if (!IS_ERR(tmp)) {
  8. 		fd = get_unused_fd_flags(flags);        /* 获取未使用的函数句柄 */
  9. 		if (fd >= 0) {
  10. 			struct file *f = do_filp_open(dfd, tmp, flags, mode, 0);    /* 打开文件，得到file结构体 */
  11. 			if (IS_ERR(f)) {
  12. 				put_unused_fd(fd);
  13. 				fd = PTR_ERR(f);
  14. 			} else {
  15. 				fsnotify_open(f);
  16. 				fd_install(fd, f);    /* 在当前进程里面记录下来 */
  17. 			}
  18. 		}
  19. 		putname(tmp);
  20. 	}
  21. 	return fd;
  22. }

  • 通过以上过程，就绑定了文件句柄fd与file结构体，后续操作文件句柄fd，实际上就是操作文件结构体file，文件结构体file如下，在结构体中，有f_op，里面包含了读写等对文件的操作；有f_flags，这就是使用open函数时的打开模式；有f_pos，这就是使用读写函数时，指向文件的位置，整体情况如下图：

 # 驱动编写流程

         从上述可以得出，当我们使用open、write、read、close等函数操作驱动时，最终调用的是最底层file_operations结构体中的open、write、read、close函数。那么将这些函数完善，并且上报到系统，就是编写驱动程序。

  1. #include <linux/module.h>
  2. #include <asm/uaccess.h>
  3. #include <linux/fs.h>
  4. #include <linux/errno.h>
  5. #include <linux/miscdevice.h>
  6. #include <linux/kernel.h>
  7. #include <linux/major.h>
  8. #include <linux/mutex.h>
  9. #include <linux/proc_fs.h>
  10. #include <linux/seq_file.h>
  11. #include <linux/stat.h>
  12. #include <linux/init.h>
  13. #include <linux/device.h>
  14. #include <linux/tty.h>
  15. #include <linux/kmod.h>
  16. #include <linux/gfp.h>
  17.  
  18. #define __CHRDEV_REGION_
  19.  
  20. #define MIN(a, b) (a < b ? a : b)
  21.  
  22. #define DEVICE_DRIVER_NAME      "test_drv"      /* 设备驱动名称 */
  23. #define DEVICE_DRIVER_CNT       1               /* 设备号个数 */
  24.  
  25. static char kernal_buffer[1024];
  26.  
  27. typedef struct {
  28.     dev_t devid;			    /* 设备号 	 */
  29.     int major;                  /* 主设备号 */
  30.     int minor;				    /* 次设备号   */    
  31.  
  32.     struct cdev cdev;		    /* cdev 	*/
  33.     char class_name[20];        /* 类名称 */
  34.     struct class *class;		/* 类 */
  35.     struct device *device;	    /* 设备 */
  36. }test_drv_Typedef;
  37.  
  38. static test_drv_Typedef test_driver = {
  39.     .devid = 0,
  40.     .major = 0,
  41.     .minor = 0,
  42.     .class_name = "test_class",
  43.     .class = NULL,
  44.     .device = NULL
  45. };
  46.  
  47. static int test_drv_open(struct inode *node, struct file *fle)
  48. {
  49.     printk("test_drv_open\r\n");
  50.  
  51.     return 0;
  52. }
  53.  
  54. static int test_drv_release(struct inode *node, struct file *fle)
  55. {
  56.     printk("test_drv_open\r\n");
  57.  
  58.     return 0;
  59. }
  60.  
  61. static ssize_t test_drv_write(struct file *fle, const char __user *buf, size_t size, loff_t *offest)
  62. {
  63.     ssize_t err;
  64.  
  65.     printk("test_drv_write\r\n");
  66.  
  67.     err = copy_from_user(kernal_buffer, buf, MIN(sizeof(kernal_buffer), size));
  68.  
  69.     return err;
  70. }
  71.  
  72. static ssize_t test_drv_read(struct file *fle, char __user *buf, size_t size, loff_t *offest)
  73. {
  74.     ssize_t err;
  75.  
  76.     printk("test_drv_read\r\n");
  77.  
  78.     err = copy_to_user(buf, kernal_buffer, MIN(sizeof(kernal_buffer), size));
  79.  
  80.     return err;
  81. }
  82.  
  83. /* 2. 编写 file_operations 结构体 */
  84. static const struct file_operations test_drv_op = {
  85.     .owner = THIS_MODULE,
  86.     .open = test_drv_open,
  87.     .release = test_drv_release,
  88.     .write = test_drv_write,
  89.     .read = test_drv_read,
  90. };
  91.  
  92. /* 3. 编写字符设备驱动模块加载 */
  93. /* 3.1 创建设备号、注册字符设备驱动 */
  94. /* 3.2 创建一个class类型的对象 */
  95. /* 3.3 生成设备节点并导出到用户空间 */
  96. static int __init test_drv_init(void)
  97. {
  98.     int ret = 0;
  99.  
  100.     printk("test_drv_init\r\n");
  101.  
  102.     /* 创建设备号 */
  103. #ifndef __CHRDEV_REGION_
  104.     /* 静态和动态注册两种方法，主要是通过判断给定的主设备号是否为0来进行区别 */
  105.     test_driver.major = register_chrdev(0, DEVICE_DRIVER_NAME, &test_drv_op);
  106.     test_driver.devid = MKDEV(test_driver.major, test_driver.minor);
  107. #else
  108.     if(test_driver.major)   /* 静态注册 */
  109.     {
  110.         test_driver.devid = MKDEV(test_driver.major, test_driver.minor);
  111.         ret = register_chrdev_region(test_driver.devid, DEVICE_DRIVER_CNT, DEVICE_DRIVER_NAME);
  112.         if(ret < 0)
  113.         {
  114.             printk("register_chrdev_region fail\r\n");
  115.             goto _err_out_regchrdev;
  116.         }
  117.     }
  118.     else    /* 动态注册 */
  119.     {
  120.         ret = alloc_chrdev_region(&test_driver.devid, 0, DEVICE_DRIVER_CNT, DEVICE_DRIVER_NAME);
  121.         if(ret < 0)
  122.         {
  123.             printk("alloc_chrdev_region fail\r\n");
  124.             goto _err_out_regchrdev;
  125.         }
  126.  
  127.         test_driver.major = MAJOR(test_driver.devid);
  128.         test_driver.minor = MINOR(test_driver.devid);
  129.     }
  130.  
  131.     /* 初始化cdev */
  132.     test_driver.cdev.owner = THIS_MODULE;
  133.     cdev_init(&test_driver.cdev, &test_drv_op);
  134.  
  135.     /* 添加一个cdev */
  136.     cdev_add(&test_driver.cdev, test_driver.devid, DEVICE_DRIVER_CNT);
  137. #endif
  138.  
  139.     test_driver.class = class_create(THIS_MODULE, test_driver.class_name);
  140.     if (IS_ERR(test_driver.class)) 
  141.     {
  142.         printk("class_create fail\r\n");
  143.         ret = PTR_ERR(test_driver.class);
  144.         goto _err_out_class_crate;
  145. 	}
  146.  
  147.     test_driver.device = device_create(test_driver.class, NULL, test_driver.devid, NULL, DEVICE_DRIVER_NAME);
  148.     if(IS_ERR(test_driver.device))
  149.     {
  150.         printk("device_create fail\r\n");
  151.         ret = PTR_ERR(test_driver.device);
  152.         goto _err_out_device_create;
  153.     }
  154.  
  155.     return 0;
  156.  
  157. _err_out_device_create:
  158.     class_destroy(test_driver.class);
  159. _err_out_class_crate:
  160. #ifndef __CHRDEV_REGION_
  161.     unregister_chrdev(test_driver.devid, DEVICE_DRIVER_NAME);
  162. #else
  163.     unregister_chrdev_region(test_driver.devid, DEVICE_DRIVER_CNT);
  164.     cdev_del(&test_driver.cdev);
  165. _err_out_regchrdev:
  166. #endif 
  167.     return ret;
  168. }
  169.  
  170. /* 4. 编写字符设备驱动模块卸载*/
  171. /* 4.1 摧毁设备 */
  172. /* 4.2 摧毁类 */
  173. /* 4.3 卸载字符设备驱动 */
  174. static void __exit test_drv_exit(void)
  175. {
  176.     printk("test_drv_exit\r\n");
  177.  
  178.     device_destroy(test_driver.class, test_driver.devid);
  179.     class_destroy(test_driver.class);
  180. #ifndef __CHRDEV_REGION_
  181.     unregister_chrdev(test_driver.major, DEVICE_DRIVER_NAME);
  182. #else
  183.     unregister_chrdev_region(test_driver.devid, DEVICE_DRIVER_CNT);
  184.     cdev_del(&test_driver.cdev);
  185. #endif 
  186. }
  187.  
  188. /* 5. 指定驱动出入口 */
  189. module_init(test_drv_init);
  190. module_exit(test_drv_exit);
  191.  
  192. /* 6. 完善驱动信息 */
  193. MODULE_LICENSE("GPL");  //添加模块 LICENSE 信息
  194. MODULE_AUTHOR("JYW");   //添加模块作者信息

步骤1：确定主设备号和次设备号

        设备号的组成：

        为了方便管理， Linux 中每个设备都有一个设备号，设备号由主设备号和次设备号两部分组成，主设备号表示某一个具体的驱动，次设备号表示使用这个驱动的各个设备，Linux 提供了一个名为 dev_t 的数据类型表示设备号， dev_t 定义在文件 include/linux/types.h 里面，定义如下：

  1. typedef __u32 __kernel_dev_t;
  2. typedef __kernel_dev_t		dev_t;

        dev_t 其实就是 unsigned int 类型，是一个 32 位的数据类型。这 32 位的数据构成了主设备号和次设备号两部分，其中高 12 位为主设备号， 低 20 位为次设备号

        设备号的操作函数： 

  1. /* 从 dev_t 中获取主设备号 */
  2. #define MAJOR(dev)	((unsigned int) ((dev) >> MINORBITS))
  3.  
  4. /* 从 dev_t 中获取次设备号 */
  5. #define MINOR(dev)	((unsigned int) ((dev) & MINORMASK))
  6.  
  7. /* 给定的主设备号和次设备号的值组合成 dev_t 类型的设备号 */
  8. #define MKDEV(ma,mi)	(((ma) << MINORBITS) | (mi))

步骤2：编写 file_operations 结构体

        file_operations 的结构体就是 Linux 内核驱动操作函数集合，内容如下所示：

  1. struct file_operations {
  2. 	struct module *owner;															/* 拥有该结构体的模块的指针，一般设置为 THIS_MODULE */
  3. 	loff_t (*llseek) (struct file *, loff_t, int);									/* 修改文件当前的读写位置 */
  4. 	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);				/* 读取设备文件 */
  5. 	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);		/* 向设备文件写入(发送)数据 */
  6. 	ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
  7. 	ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
  8. 	int (*iterate) (struct file *, struct dir_context *);
  9. 	unsigned int (*poll) (struct file *, struct poll_table_struct *);				/* 轮询函数，用于查询设备是否可以进行非阻塞的读写 */
  10. 	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);			/* 提供对于设备的控制功能，与应用程序中的 ioctl 函数对应 */
  11. 	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);				/* 与unlocked_ioctl 函数功能一样 */
  12. 	int (*mmap) (struct file *, struct vm_area_struct *);							/* 将设备的内存映射到进程空间中(也就是用户空间) */
  13. 	int (*mremap)(struct file *, struct vm_area_struct *);
  14. 	int (*open) (struct inode *, struct file *);									/* 打开设备文件 */
  15. 	int (*flush) (struct file *, fl_owner_t id);
  16. 	int (*release) (struct inode *, struct file *);									/* 释放(关闭)设备文件 */
  17. 	int (*fsync) (struct file *, loff_t, loff_t, int datasync);						/* 刷新待处理的数据，用于将缓冲区中的数据刷新到磁盘中 */
  18. 	int (*aio_fsync) (struct kiocb *, int datasync);								/* 与 fasync 函数的功能类似，只是 aio_fsync 是异步刷新待处理的数据 */
  19. 	int (*fasync) (int, struct file *, int);
  20. 	int (*lock) (struct file *, int, struct file_lock *);
  21. 	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
  22. 	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
  23. 	int (*check_flags)(int);
  24. 	int (*flock) (struct file *, int, struct file_lock *);
  25. 	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
  26. 	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
  27. 	int (*setlease)(struct file *, long, struct file_lock **, void **);
  28. 	long (*fallocate)(struct file *file, int mode, loff_t offset,
  29. 			  loff_t len);
  30. 	void (*show_fdinfo)(struct seq_file *m, struct file *f);
  31. #ifndef CONFIG_MMU
  32. 	unsigned (*mmap_capabilities)(struct file *);
  33. #endif
  34. };

        常用函数介绍：

  1.  
  2. /*
  3. * @description : 打开设备
  4. * @param – : 传递给驱动的 inode
  5. * @param - : 设备文件， file 结构体有个叫做 private_data 的成员变量
  6. * 一般在 open 的时候将 private_data 指向设备结构体。
  7. * @return : 0 成功;其他 失败
  8. */
  9. int (*open) (struct inode *, struct file *);
  1. /*
  2. * @description : 关闭/释放设备
  3. * @param - : 要关闭的设备文件(文件描述符)
  4. * @return : 0 成功;其他 失败
  5. */
  6. int (*release) (struct inode *, struct file *);	
  1. /*
  2. * @description : 向设备写数据
  3. * @param - : 设备文件，表示打开的文件描述符
  4. * @param - : 要写给设备写入的数据
  5. * @param - : 要写入的数据长度
  6. * @param - : 相对于文件首地址的偏移
  7. * @return : 写入的字节数，如果为负值，表示写入失败
  8. */
  9. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
  1. /*
  2. * @description : 从设备读取数据
  3. * @param - : 要打开的设备文件(文件描述符)
  4. * @param - : 返回给用户空间的数据缓冲区
  5. * @param - : 要读取的数据长度
  6. * @param - : 相对于文件首地址的偏移
  7. * @return : 读取的字节数，如果为负值，表示读取失败
  8. */
  9. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
  1. unsigned long copy_from_user(void *to, const void __user *from, unsigned long n)
  2.  
  3. unsigned long copy_to_user(void *to, const void __user *from, unsigned long n)

以下是对参数进行讲解：

  • struct inode
  1. /*
  2. * 内核使用inode结构体在内核内部表示一个文件。因此，它与表示一个已经打开的文件描述符的结构体(file
  3. * 文件结构)是不同的，我们可以使用多个file 文件结构表示同一个文件的多个文件描述符，但此时，所有这
  4. * 些file文件结构全部都必须只能指向一个inode结构体
  5. */
  6. struct inode {
  7. 	umode_t			i_mode;				
  8. 	unsigned short		i_opflags;
  9. 	kuid_t			i_uid;				/* inode拥有者id   */
  10. 	kgid_t			i_gid;				/* inode所属群组id  */
  11. 	unsigned int		i_flags;
  12.  
  13. #ifdef CONFIG_FS_POSIX_ACL
  14. 	struct posix_acl	*i_acl;
  15. 	struct posix_acl	*i_default_acl;
  16. #endif
  17.  
  18. 	const struct inode_operations	*i_op;
  19. 	struct super_block	*i_sb;
  20. 	struct address_space	*i_mapping;
  21.  
  22. #ifdef CONFIG_SECURITY
  23. 	void			*i_security;
  24. #endif
  25.  
  26. 	/* Stat data, not accessed from path walking */
  27. 	unsigned long		i_ino;
  28. 	/*
  29. 	 * Filesystems may only read i_nlink directly.  They shall use the
  30. 	 * following functions for modification:
  31. 	 *
  32. 	 *    (set|clear|inc|drop)_nlink
  33. 	 *    inode_(inc|dec)_link_count
  34. 	 */
  35. 	union {
  36. 		const unsigned int i_nlink;
  37. 		unsigned int __i_nlink;
  38. 	};
  39. 	dev_t			i_rdev;			/* 若是设备文件，表示记录设备的设备号 */
  40. 	loff_t			i_size;			/* inode所代表大少  */
  41. 	struct timespec		i_atime;	/* inode最近一次的存取时间   */
  42. 	struct timespec		i_mtime;	/* inode最近一次修改时间  */
  43. 	struct timespec		i_ctime;	/* inode的生成时间 */
  44. 	spinlock_t		i_lock;	/* i_blocks, i_bytes, maybe i_size */
  45. 	unsigned short          i_bytes;
  46. 	unsigned int		i_blkbits;
  47. 	blkcnt_t		i_blocks;
  48.  
  49. #ifdef __NEED_I_SIZE_ORDERED
  50. 	seqcount_t		i_size_seqcount;
  51. #endif
  52.  
  53. 	/* Misc */
  54. 	unsigned long		i_state;
  55. 	struct mutex		i_mutex;
  56.  
  57. 	unsigned long		dirtied_when;	/* jiffies of first dirtying */
  58. 	unsigned long		dirtied_time_when;
  59.  
  60. 	struct hlist_node	i_hash;
  61. 	struct list_head	i_wb_list;	/* backing dev IO list */
  62. 	struct list_head	i_lru;		/* inode LRU list */
  63. 	struct list_head	i_sb_list;
  64. 	union {
  65. 		struct hlist_head	i_dentry;
  66. 		struct rcu_head		i_rcu;
  67. 	};
  68. 	u64			i_version;
  69. 	atomic_t		i_count;
  70. 	atomic_t		i_dio_count;
  71. 	atomic_t		i_writecount;
  72. #ifdef CONFIG_IMA
  73. 	atomic_t		i_readcount; /* struct files open RO */
  74. #endif
  75. 	const struct file_operations	*i_fop;	/* former ->i_op->default_file_ops */
  76. 	struct file_lock_context	*i_flctx;
  77. 	struct address_space	i_data;
  78. 	struct list_head	i_devices;
  79. 	union {
  80. 		struct pipe_inode_info	*i_pipe;
  81. 		struct block_device	*i_bdev;
  82. 		struct cdev		*i_cdev;		/* 若是字符设备，对应的为cdev结构  */
  83. 	};
  84.  
  85. 	__u32			i_generation;
  86.  
  87. #ifdef CONFIG_FSNOTIFY
  88. 	__u32			i_fsnotify_mask; /* all events this inode cares about */
  89. 	struct hlist_head	i_fsnotify_marks;
  90. #endif
  91.  
  92. 	void			*i_private; /* fs or device private pointer */
  93. };
  94.  
  95. /* 内核函数从inode中提取设备号 */
  96.  
  97. /* 提取主设备号 */
  98. static inline unsigned imajor(const struct inode *inode){　　return MAJOR(inode->i_rdev);
  99. }
  100. /* 提取次设备号 */
  101. static inline unsigned iminor(const struct inode *inode)
  102. {
  103. 　　return MINOR(inode->i_rdev);
  104. }
  • struct file
  1. /*
  2. * file结构体指示一个已经打开的文件（设备对应于设备文件），其实系统中的每个打开的文件在内核空间都有
  3. * 一个相应的struct file结构体，它由内核在打开文件时创建，并传递给在文件上进行操作的任何函数，直至文
  4. * 件被关闭。如果文件被关闭，内核就会释放相应的数据结构
  5. */
  6. struct file {
  7. 	union {
  8. 		struct llist_node	fu_llist;
  9. 		struct rcu_head 	fu_rcuhead;
  10. 	} f_u;
  11. 	struct path		f_path;
  12. 	struct inode		*f_inode;	/* cached value */
  13. 	const struct file_operations	*f_op;	/*   与文件相关的各种操作 */
  14.  
  15. 	/*
  16. 	 * Protects f_ep_links, f_flags.
  17. 	 * Must not be taken from IRQ context.
  18. 	 */
  19. 	spinlock_t		f_lock;
  20. 	atomic_long_t		f_count;
  21. 	unsigned int 		f_flags;		/* 文件标志，如 O_RDONLY ,  O_NONBLOCK 以及 O_SYNC  */
  22. 	fmode_t			f_mode;				/* 此文件模式通过 FMODE_READ ,  FMODE_WRITE 识别了文件为可读的，可写的，或者是二者 */
  23. 	struct mutex		f_pos_lock;
  24. 	loff_t			f_pos;				/*  当前读写文件的位置 */
  25. 	struct fown_struct	f_owner;
  26. 	const struct cred	*f_cred;
  27. 	struct file_ra_state	f_ra;
  28.  
  29. 	u64			f_version;
  30. #ifdef CONFIG_SECURITY
  31. 	void			*f_security;
  32. #endif
  33. 	/* needed for tty driver, and maybe others */
  34. 	void			*private_data;		/*  在驱动调用open方法之前，open系统调用设置此指针为NULL值。你可以很自由的将其做为你自己需要的一些数据域或者不管它 */
  35.  
  36. #ifdef CONFIG_EPOLL
  37. 	/* Used by fs/eventpoll.c to link all the hooks to this file */
  38. 	struct list_head	f_ep_links;
  39. 	struct list_head	f_tfile_llink;
  40. #endif /* #ifdef CONFIG_EPOLL */
  41. 	struct address_space	*f_mapping;
  42. } __attribute__((aligned(4)));	/* lest something weird decides that 2 is OK */

步骤3： 编写字符设备驱动模块加载 

步骤3.1：创建并注册设备号

  • register_chrdev
  1. /**
  2.  * register_chrdev() - create and register a cdev occupying a range of minors
  3.  * @major: major device number or 0 for dynamic allocation
  4.  * @name: name of this range of devices
  5.  * @fops: file operations associated with this devices
  6.  *
  7.  * If @major == 0 this functions will dynamically allocate a major and return
  8.  * its number.
  9.  *
  10.  * If @major > 0 this function will attempt to reserve a device with the given
  11.  * major number and will return zero on success.
  12.  *
  13.  * Returns a -ve errno on failure.
  14.  *
  15.  * The name of this device has nothing to do with the name of the device in
  16.  * /dev. It only helps to keep track of the different owners of devices. If
  17.  * your module name has only one type of devices it's ok to use e.g. the name
  18.  * of the module here.
  19.  */
  20. static inline int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops)
  21.  
  22. /**
  23.  * unregister_chrdev - unregister and destroy a cdev
  24.  * @major: major device number
  25.  * @name: name of this range of devices
  26.  *
  27.  * Unregister and destroy the cdev occupying the region described by
  28.  * @major, @baseminor and @count.  This function undoes what
  29.  * register_chrdev() did.
  30.  */
  31. static inline void unregister_chrdev(unsigned int major, const char *name)
  • register_chrdev_region/alloc_chrdev_region + cdev
  1. /**
  2.  * register_chrdev_region() - register a range of device numbers
  3.  * @from: the first in the desired range of device numbers; must include
  4.  *        the major number.
  5.  * @count: the number of consecutive device numbers required
  6.  * @name: the name of the device or driver.
  7.  *
  8.  * Return value is zero on success, a negative error code on failure.
  9.  */
  10. int register_chrdev_region(dev_t from, unsigned count, const char *name)
  11.  
  12. /**
  13.  * alloc_chrdev_region() - register a range of char device numbers
  14.  * @dev: output parameter for first assigned number
  15.  * @baseminor: first of the requested range of minor numbers
  16.  * @count: the number of minor numbers required
  17.  * @name: the name of the associated device or driver
  18.  *
  19.  * Allocates a range of char device numbers.  The major number will be
  20.  * chosen dynamically, and returned (along with the first minor number)
  21.  * in @dev.  Returns zero or a negative error code.
  22.  */
  23. int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)
  24.  
  25. /**
  26.  * unregister_chrdev_region() - return a range of device numbers
  27.  * @from: the first in the range of numbers to unregister
  28.  * @count: the number of device numbers to unregister
  29.  *
  30.  * This function will unregister a range of @count device numbers,
  31.  * starting with @from.  The caller should normally be the one who
  32.  * allocated those numbers in the first place...
  33.  */
  34. void unregister_chrdev_region(dev_t from, unsigned count)
  35.  
  36. /**
  37.  * cdev_alloc() - allocate a cdev structure
  38.  *
  39.  * Allocates and returns a cdev structure, or NULL on failure.
  40.  */
  41. struct cdev *cdev_alloc(void)
  42.  
  43. /**
  44.  * cdev_init() - initialize a cdev structure
  45.  * @cdev: the structure to initialize
  46.  * @fops: the file_operations for this device
  47.  *
  48.  * Initializes @cdev, remembering @fops, making it ready to add to the
  49.  * system with cdev_add().
  50.  */
  51. void cdev_init(struct cdev *cdev, const struct file_operations *fops)
  52.  
  53. /**
  54.  * cdev_add() - add a char device to the system
  55.  * @p: the cdev structure for the device
  56.  * @dev: the first device number for which this device is responsible
  57.  * @count: the number of consecutive minor numbers corresponding to this
  58.  *         device
  59.  *
  60.  * cdev_add() adds the device represented by @p to the system, making it
  61.  * live immediately.  A negative error code is returned on failure.
  62.  */
  63. int cdev_add(struct cdev *p, dev_t dev, unsigned count)
  64.  
  65. /**
  66.  * cdev_del() - remove a cdev from the system
  67.  * @p: the cdev structure to be removed
  68.  *
  69.  * cdev_del() removes @p from the system, possibly freeing the structure
  70.  * itself.
  71.  */
  72. void cdev_del(struct cdev *p)

步骤3.2：创建一个class类型的对象

  1. /* This is a #define to keep the compiler from merging different
  2.  * instances of the __key variable */
  3. #define class_create(owner, name)		\
  4. ({						\
  5. 	static struct lock_class_key __key;	\
  6. 	__class_create(owner, name, &__key);	\
  7. })
  8.  
  9. /**
  10.  * class_create - create a struct class structure
  11.  * @owner: pointer to the module that is to "own" this struct class
  12.  * @name: pointer to a string for the name of this class.
  13.  * @key: the lock_class_key for this class; used by mutex lock debugging
  14.  *
  15.  * This is used to create a struct class pointer that can then be used
  16.  * in calls to device_create().
  17.  *
  18.  * Returns &struct class pointer on success, or ERR_PTR() on error.
  19.  *
  20.  * Note, the pointer created here is to be destroyed when finished by
  21.  * making a call to class_destroy().
  22.  */
  23. struct class *__class_create(struct module *owner, const char *name, struct lock_class_key *key)
  24.  
  25. /**
  26.  * class_destroy - destroys a struct class structure
  27.  * @cls: pointer to the struct class that is to be destroyed
  28.  *
  29.  * Note, the pointer to be destroyed must have been created with a call
  30.  * to class_create().
  31.  */
  32. void class_destroy(struct class *cls)

步骤3.3：生成设备节点并导出到用户空间

  1. /**
  2.  * device_create- 创建设备
  3.  * @class: 该设备依附的类
  4.  * @parent: 父设备
  5.  * @devt: 设备号(此处的设备号为主次设备号)
  6.  * @drvdata：私有数据
  7.  * @fmt：设备名
  8.  * return：创建的设备指针
  9. */
  10. struct device *device_create(struct class *class, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...)
  11.  
  12.  
  13. /**
  14.  * device_create- 销毁设备
  15.  * @class: 该设备依附的类
  16.  * @devt: 设备号(此处的设备号为主次设备号)
  17. */
  18. void device_destroy(struct class *class, dev_t devt)

步骤4： 编写字符设备驱动模块卸载

          查看步骤3

步骤5：指定驱动出入口

  1. /**
  2.  * module_init() - driver initialization entry point
  3.  * @x: function to be run at kernel boot time or module insertion
  4.  * 
  5.  * module_init() will either be called during do_initcalls() (if
  6.  * builtin) or at module insertion time (if a module).  There can only
  7.  * be one per module.
  8.  */
  9. #define module_init(x)	__initcall(x);
  10.  
  11. /**
  12.  * module_exit() - driver exit entry point
  13.  * @x: function to be run when driver is removed
  14.  * 
  15.  * module_exit() will wrap the driver clean-up code
  16.  * with cleanup_module() when used with rmmod when
  17.  * the driver is a module.  If the driver is statically
  18.  * compiled into the kernel, module_exit() has no effect.
  19.  * There can only be one per module.
  20.  */
  21. #define module_exit(x)	__exitcall(x);

步骤6：完善驱动信息

  1. /*
  2.  * The following license idents are currently accepted as indicating free
  3.  * software modules
  4.  *
  5.  *	"GPL"				[GNU Public License v2 or later]
  6.  *	"GPL v2"			[GNU Public License v2]
  7.  *	"GPL and additional rights"	[GNU Public License v2 rights and more]
  8.  *	"Dual BSD/GPL"			[GNU Public License v2
  9.  *					 or BSD license choice]
  10.  *	"Dual MIT/GPL"			[GNU Public License v2
  11.  *					 or MIT license choice]
  12.  *	"Dual MPL/GPL"			[GNU Public License v2
  13.  *					 or Mozilla license choice]
  14.  *
  15.  * The following other idents are available
  16.  *
  17.  *	"Proprietary"			[Non free products]
  18.  *
  19.  * There are dual licensed components, but when running with Linux it is the
  20.  * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
  21.  * is a GPL combined work.
  22.  *
  23.  * This exists for several reasons
  24.  * 1.	So modinfo can show license info for users wanting to vet their setup
  25.  *	is free
  26.  * 2.	So the community can ignore bug reports including proprietary modules
  27.  * 3.	So vendors can do likewise based on their own policies
  28.  */
  29. #define MODULE_LICENSE(_license) MODULE_INFO(license, _license)
  30.  
  31. /*
  32.  * Author(s), use "Name <email>" or just "Name", for multiple
  33.  * authors use multiple MODULE_AUTHOR() statements/lines.
  34.  */
  35. #define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
  36.  
  37. /* What your module does. */
  38. #define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)

# 补充知识

1. 加载和卸载驱动模块

  • 加载模块

        驱动编译完成以后扩展名为.ko，有两种命令可以加载驱动模块： insmod和 modprobe，其中insmod 命令不能解决模块的依赖关系，比如 drv.ko 依赖 first.ko 这个模块，就必须先使用insmod 命令加载 first.ko 这个模块，然后再加载 drv.ko 这个模块。但是 modprobe 就不会存在这个问题， modprobe 会分析模块的依赖关系，然后会将所有的依赖模块都加载到内核中，因此modprobe 命令相比 insmod 要智能一些。 modprobe 命令主要智能在提供了模块的依赖性分析、错误检查、错误报告等功能，modprobe 命令默认会去/lib/modules/<kernel-version>目录中查找模块，比如本书使用的 Linux kernel 的版本号为 4.1.15，因此 modprobe 命令默认会到/lib/modules/4.1.15 这个目录中查找相应的驱动模块，一般自己制作的根文件系统中是不会有这个目录的，所以需要自己手动创建

insmod drv.ko
modprobe drv.ko

  • 卸载模块

        驱动模块的卸载使用命令“rmmod”即可，也可以使用“modprobe -r”命令卸载驱动

rmmod drv.ko
modprobe -r drv.ko 

  • 查看模块

        输入“lsmod”命令即可查看当前系统中存在的模块 

2. 查看驱动设备

  • 使用 cat /proc/devices 可以查看当前已经被使用掉的设备号

  • 使用  ls /sys/class/ 查看类

  • 使用 ls /sys/class/test_class/ -l 查看设备

3. 查看日志信息 

  •  printk

        printk 运行在内核态。在内核中想要向控制台输出或显示一些内容，必须使用printk 这个函数。不同之处在于， printk 可以根据日志级别对消息进行分类，一共有 8 个消息级别，这 8 个消息级别定义在文件 include/linux/kern_levels.h 里面，定义如下：

  1. #define KERN_SOH "\001"
  2. #define KERN_EMERG KERN_SOH "0" /* 紧急事件，一般是内核崩溃 */
  3. #define KERN_ALERT KERN_SOH "1" /* 必须立即采取行动 */
  4. #define KERN_CRIT KERN_SOH "2" /* 临界条件，比如严重的软件或硬件错误*/
  5. #define KERN_ERR KERN_SOH "3" /* 错误状态，一般设备驱动程序中使用
  6. KERN_ERR 报告硬件错误 */
  7. #define KERN_WARNING KERN_SOH "4" /* 警告信息，不会对系统造成严重影响 */
  8. #define KERN_NOTICE KERN_SOH "5" /* 有必要进行提示的一些信息 */
  9. #define KERN_INFO KERN_SOH "6" /* 提示性的信息 */
  10. #define KERN_DEBUG KERN_SOH "7" /* 调试信息 */

一共定义了 8 个级别，其中 0 的优先级最高， 7 的优先级最低。如果要设置消息级别，参考如下示例：printk(KERN_EMERG "gsmi: Log Shutdown Reason\n");用 printk 的 时 候 不 显 式 的 设 置 消 息 级 别 ， 那 么 printk 将 会 采 用 默 认 级 别MESSAGE_LOGLEVEL_DEFAULT， MESSAGE_LOGLEVEL_DEFAULT 默认为 4

  • printk等级

使用 # cat /proc/sys/kernel/printk  指令查看printk等级

        四个数字分表代表：DEFAULT_CONSOLE_LOGLEVEL(控制台输出等级)、DEFAULT_MESSAGE_LOGLEVEL(默认消息等级)、MINIMUM_CONSOLE_LOGLEVEL(最低输出等级)、DEFAULT_CONSOLE_LOGLEVEL(默认控制台输出等级) 

        当 printk() 中的消息日志级别小于当前控制台日志级别（CONSOLE_LOGLEVEL_DEFAULT）时，printk 的信息就会在控制台上显示，如果我们用 printk 的 时 候 不 显 式 的 设 置 消 息 级 别，即printk使用MESSAGE_LOGLEVEL_DEFAULT（级别为4），此时当前控制台日志级别为CONSOLE_LOGLEVEL_DEFAULT(级别为7)，所示直接使用 printk 输出的信息是可以显示在控制台上的。

  • 查看日志

        第一种是使用dmesg命令打印。第二种是通过cat /proc/kmsg来打印

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/330343
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号