简单字符设备驱动程序的设计-无删减范文

如何编写Linux设备驱动程序Linux是Unix操作系统的一种变种，在Linux下编写驱动程序的原理和思想完全类似于其他的Unix系统，但它dos或window环境下的驱动程序有很大的区别。

在Linux环境下设计驱动程序，思想简洁，操作方便，功能也很强大，但是支持函数少，只能依赖kernel中的函数，有些常用的操作要自己来编写，而且调试也不方便。

本文是在编写一块多媒体卡编制的驱动程序后的总结，获得了一些经验，愿与Linux fans共享，有不当之处，请予指正。

以下的一些文字主要来源于khg，johnsonm的Write linux device driver，Brennan's Guide to Inline Assembly，The Linux A-Z，还有清华BBS上的有关device driver的一些资料. 这些资料有的已经过时，有的还有一些错误，我依据自己的试验结果进行了修正.一、Linux device driver 的概念系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。

设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。

设备驱动程序是内核的一部分，它完成以下的功能：1）对设备初始化和释放；2）把数据从内核传送到硬件和从硬件读取数据；3）读取应用程序传送给设备文件的数据和回送应用程序请求的数据；4）检测和处理设备出现的错误。

在Linux操作系统下有两类主要的设备文件类型，一种是字符设备，另一种是块设备。

字符设备和块设备的主要区别是：在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作。

块设备是主要针对磁盘等慢速设备设计的，以免耗费过多的CPU时间来等待.已经提到，用户进程是通过设备文件来与实际的硬件打交道。

操作系统课程设计报告字符驱动设备程序一、概述1.1课程设计目的设备驱动充当了硬件和应用软件之间的纽带，它使得应用软件只需要调用软件的应用编程接口（API）就可以让硬件去完成要求的工作，在有操作系统的情况下，必须按照相应的架构设计驱动，才能将驱动良好的整合入操作系统的内核。

通过这次课程设计可以了解linux的模块机制，懂得如何加载模块和卸载模块，进一步熟悉模块的相关操作。

加深对驱动程序定义和设计的了解，了解linux驱动的编写过程。

1.2 课程设计内容与要求(1)设计Windows XP或者Linux操作系统下的设备驱动程序;(2)设备类型可以是字符设备、块设备或者网络设备;(3)设备可以是虚拟的也可以是实际设备;1.3设计步骤1)file_operations结构体设计2)模块初始化、模块卸载函数实现3)读写函数的实现4)测试程序编写5)驱动程序编译和加载6)驱动程序测试二、基本概念和原理Linux系统从各异的设备中提取了共性的特征，将设备分为三类：字符设备、块设备和网络设备。

内核针对每一类设备都提供了对应的驱动模型框架，包括基本的内核设施和文件接口。

系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。

设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。

设备驱动程序是内核的一部分，它完成以下的功能:1、对设备初始化和释放；2、把数据从内核传送到硬件和从硬件读取数据；3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据；4、检测和处理设备出现的错误。

字符设备驱动程序：控制长短不一致字符列，应用程序直接呼叫的、没有缓存的设备驱动程序。

字符设备驱动程序所提供的功能是以设备文件的形式提供给用户空间程序使用，应用程序中使用open（）、close（）、read（）、write（）等文件处理函数，并且以普通文件方式处理设备文件，从而控制硬件。

最简单的字符设备驱动程序⾸先，先理清⼀下简单字符设备驱动程序的思路：（1）申请设备号动态申请：int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,const char *name)静态申请：int register_chrdev_region(dev_t from, unsigned count, const char *name)成功返回0，失败返回负数，并置于errno（2）分配cdev ，可以使⽤struct cdev *cdev_alloc(void) ，或者静态定义全局cdev变量（3）初始化cdev若使⽤动态分配，则需要进⾏初始化：void cdev_init(struct cdev *cdev, const structfile_operations *fops) ，mem_cdev.owner = THIS_MODULE;若动态内存定义初始化：struct cdev *mem_cdev = cdev_alloc(); mem_cdev->ops =&fops; mem_cdev->owner = THIS_MODULE（4）添加cdevint cdev_add(struct cdev *p, dev_t dev,unsigned count)若使⽤内存模拟字符设备，则还需申请空间：mem_devp = kmalloc( 2 * sizeof(struct mem_dev), GFP_KERNEL);if(!mem_devp){result = -ENOMEM;goto fail_malloc;}memset(mem_devp, 0, sizeof(struct mem_dev));for(i = 0; i < 2; i++){mem_devp[i].size = MEMDEV_SIZE;mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);memset(mem_devp[i].data, 0, MEMDEV_SIZE);}申请失败情况下，记得注销设备号，使⽤void unregister_chrdev_region(dev_t from, unsigned count)（5）构造file_operations结构体（结构体字段的初始化）static const struct file_operations mem_fops ={.owner = THIS_MODULE,.llseek = mem_llseek,.read = mem_read,.write = mem_write,.open = mem_open,.release = mem_release,};（6）实现file_operations⽀持的函数int mem_open(struct inode *inode, struct file *filp){struct mem_dev *dev;int num = MINOR(inode->i_rdev);if(num >= MEMDEV_NR_DEVS)return -ENODEV;dev = &mem_devp[num];filp->private_data = dev;return 0;}static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos){unsigned long p = *ppos;unsigned int count = size;int ret = 0;struct mem_dev *dev = filp->private_data;if(p > MEMDEV_SIZE)return 0;if(count > MEMDEV_SIZE - p)count = MEMDEV_SIZE - p;if(copy_to_user(buf, (void *)(dev->data + p), count)){ret = -EFAULT;}else{*ppos += count;ret = count;printk(KERN_INFO "read %d bytes from %ld", count, p);}return ret;}static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos) {unsigned long p = *ppos;unsigned int count = size;int ret = 0;struct mem_dev *dev = filp->private_data;if(p > MEMDEV_SIZE)return 0;if(count > MEMDEV_SIZE - p)count = MEMDEV_SIZE - p;if(copy_from_user(dev->data + p, buf, count)){ret = -EFAULT;}else{*ppos += count;ret = count;printk(KERN_INFO "writen %d bytes from %ld", count, p);}return ret;}static loff_t mem_llseek(struct file *filp, loff_t offset, int whence){loff_t newpos;switch(whence){case 0:newpos = offset;break;case 1:newpos = filp->f_pos+offset;break;case 2:newpos = MEMDEV_SIZE - 1 + offset;break;default:return -EINVAL;}if((newpos < 0) || (newpos > MEMDEV_SIZE)) return -EINVAL;filp->f_pos = newpos;return newpos;}int mem_release(struct inode *inode, struct file *filp) {return 0;}测试代码：#include <stdio.h>int main(){FILE *fp = NULL;char Buf[4096];strcpy(Buf, "mem is char dev!");printf("Buf:%s\n",Buf);fp = fopen("/dev/memdev1", "r+");if(fp == NULL){printf("open memdev1 error!\n");}fwrite(Buf, sizeof(Buf), 1, fp);fseek(fp, 0, SEEK_SET);strcpy(Buf,"Buf is NULL!");printf("Buf: %s\n",Buf);fread(Buf, sizeof(Buf), 1, fp);printf("Buf: %s\n",Buf);return 0;}。

基于Linux的字符设备驱动程序的设计1 选题意义驱动程序在 Linux 内核里扮演着特殊的角色. 它们是截然不同的"黑盒子", 使硬件的特殊的一部分响应定义好的内部编程接口.它们完全隐藏了设备工作的细节. 用户的活动通过一套标准化的调用来进行,这些调用与特别的驱动是独立的; 设备驱动的角色就是将这些调用映射到作用于实际硬件的和设备相关的操作上. 这个编程接口是这样, 驱动可以与内核的其他部分分开建立, 并在需要的时候在运行时"插入". 这种模块化使得 Linux 驱动易写, 以致于目前有几百个驱动可用.尽管编写设备代码并不一定比编写应用程序更困难，但它需要掌握一些新函数库，并考虑一些新问题，而这些问题是在应用程序空间里不曾遇到的。

在应用程序空间写程序，内核能够为犯的一些错误提供一张安全网，但当我们工作在内核空间时，这张安全网已不复存在。

因为内核代码对计算机有绝对的控制权，它能够阻止其他任何进程的执行，所以编写的设备代码绝对小心不能滥用这种权利。

在 Linux 设备驱动中，字符设备驱动较为基础,所以本次实验设计一个简单的字符设备驱动程序，然后通过模块机制加载该驱动，并通过一个测试程序来检验驱动设计的正确与否，并对出现的问题进行调试解决。

2 技术路线模块实际上是一种目标对象文件(后缀名为ko )，没有链接，不能独立运行，但是其代码可以在运行时链接到系统中作为内核的一部分运行或从内核中取下，从而可以动态扩充内核的功能。

模块有一个入口（init_module()）和一个出口(exit_module())函数，分别是模块加载和卸载时执行的操作，加载模块使用insmod命令，卸载使用rmmod命令。

字符设备以字节为单位进行数据处理，一般不适用缓存。

大多数字符设备仅仅是数据通道，只能按照顺序读写。

主设备号表示设备对应的驱动程序,次设备号用来区分具体设备的实例。

LINUX为文件和设备提供一致的用户接口，对用户来说，设备文件与普通文件并无区别，设备文件也可以挂接到任何需要的地方。

简单字符设备驱动程序的设计简单字符设备驱动程序设计文档
1.引言
1.1 简述设备驱动程序的作用及背景
1.2 文档目的和范围
1.3 读者对象和前提知识
2.设备驱动程序概述
2.1 什么是字符设备驱动程序
2.2 设备驱动程序的结构和组成部分
2.3 设备驱动程序的工作流程
3.设备驱动程序的环境配置
3.1 硬件平台的选择和准备
3.2 操作系统的选择和安装
3.3 开发工具的选择和安装
4.驱动程序的编写步骤
4.1 设备驱动程序的初始化
4.2 设册和注销
4.3 设备文件的创建和销毁
4.4 设备文件的打开和关闭
4.5 设备数据的读取和写入
4.6 设备的控制和管理
5.驱动程序的调试和测试
5.1 驱动程序的编译和调试
5.2 驱动程序的单元测试和集成测试
5.3 驱动程序的性能测试和稳定性测试
6.驱动程序的优化和改进
6.1 驱动程序的性能优化
6.2 驱动程序的可靠性改进
6.3 驱动程序的功能扩展
7.附件
在本文档中，我们提供了以下附件供参考：
●设备驱动程序代码示例
●设备驱动程序编译和调试指南
8.法律名词及注释
●设备驱动程序：一种软件程序，用于控制特定设备的输入和输出操作。

●字符设备：一种设备，可按字符为单位进行读写操作，如终端或打印机。

●注册：将设备驱动程序与操作系统内核绑定的过程。

●注销：解除设备驱动程序与操作系统内核的绑定的过程。

●文件操作：对设备驱动程序提供的文件进行打开、读取、写入、关闭等操作。

实现一个简单的linux字符设备驱动步骤1：编写驱动程序view plaincopy to clipboardprint?1. #include <linux/module.h>2. #include <linux/init.h>3. #include <linux/kernel.h>4. #include <linux/cdev.h>5. #include <linux/fs.h>6. #include <linux/kdev_t.h>7. #include <asm/uaccess.h>8. #include <linux/device.h>9. #define DEVICE_NAME "cdev_zhangwei"10. int number_of_devices = 1;11. struct cdev mydev;12. dev_t dev = 0;13. char data[128] = "/0"; // the data of my device14. struct class *myclass;15. static int mydev_open(struct inode *inode, struct file *file)16. {17. pr_info("mydev driver open!/n");18. return 0;19. }20. static int mydev_release(struct inode *inode, struct file *file)21. {22. pr_info("mydev driver released!/n");23. return 0;24. }25. ssize_t mydev_write(struct file *file, const char __user *buf, size_t count, loff_t *f_pos)26. {27. ssize_t ret = 0;28. pr_info("mydev_write!/n");29. pr_info("writing %d bytes/n", count);30. if (count > 127)31. return -ENOMEM;32. if (count < 0)33. return -EINVAL;34. if (copy_from_user(data, buf, count)) {35. ret = -EFAULT;36. }37. else {38. data[127] = ''/0'';39. pr_info("kernel received: %s/n", data);40. ret = count;41. }42. return ret;43. }44. static ssize_t mydev_read(struct file* filp, char* buf, size_t len,loff_t* off)45. {46. if( copy_to_user(buf,data,len) )47. {48. return -EFAULT;49. }50.51. return len;52. }53. struct file_operations mydev_fops = {54. .owner = THIS_MODULE,55. .open = mydev_open,56. .read = mydev_read,57. .write = mydev_write,58. .release = mydev_release59.60. };61. static int __init mydev_init(void)62. {63. int result, error;64. result = register_chrdev(0, DEVICE_NAME, &mydev_fops);65. pr_info("udev_cdev: get major number: %d/n", result);66. dev = MKDEV(result, 0);67. myclass = class_create(THIS_MODULE, "mydev_class");68. device_create(myclass, NULL, dev, NULL, DEVICE_NAME);69. return 0;70. }71. static void __exit mydev_exit(void)72. {73. cdev_del(&mydev);74. unregister_chrdev_region(dev, number_of_devices);75. device_destroy(myclass, dev);76. class_destroy(myclass);77. pr_info("Goodbye cdev!/n");78. }79. module_init(mydev_init);80. module_exit(mydev_exit);81. MODULE_LICENSE("GPL");82. MODULE_DESCRIPTION("Simple cdev udev driver test");Makefile:obj-m := mydrive.oKDIR := /lib/modules/$(shell uname -r)/buildPWD := $(shell pwd)default:$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modulesclean:$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) cleanrm -rf Module.markers modules.order Module.symversinsmod mydrive.kolsmod查看步骤3：创建设备节点：mknod /dev/mydriver c 主设备号次设备号次设备号这里填0，主设备号可以利用cat /proc/devices 查看ls –l /dev/mydriver用df看看/dev/mydriver的使用情况了步骤4：编写用户程序（测试咱们的驱动是否可行），如以下代码，这个嘛，简单的用gcc 命令编译就好了1. #include <stdio.h>2. #include <sys/types.h>3. #include <unistd.h>4. #include <stdlib.h>5. #include <fcntl.h>6. i nt main (void)7. {8. int fd,len;9. pid_t pid;10. char buff[] = "This is from userspace zhangwei fight it!";11. char buff_read[100] ;12. fd = open ("/dev/cdev_zhangwei", O_RDWR);13. if (fd < 0) {14. perror("open failed");15. exit(0);16. }17. pid = fork();18. if(pid>0)19. {20. len = write (fd, buff, sizeof(buff));21. printf ("son Write returns %d/n",len );22. }23. else // parent24. {25. //waitpid(pid);26. printf ("read returns %d/n", read(fd,buff_read,len) );27. printf("buff_read = %s/n",buff_read);28. }29. close (fd);30. return 0;31. }。

实验五：简单字符设备驱动程序的设计实验学时：4实验类型：（设计）一、实验目的1. 理解设备驱动程序的处理过程；2. 掌握Linux设备驱动程序开发的基本过程和设计方法；3. 学会编写简单的字符设备驱动程序。

二、实验条件Linux操作系统gcc三、实验原理及相关知识设备驱动程序是I/O进程与设备控制器之间的通信程序。

驱动程序的功能：⑴接收由设备独立性软件发来的命令和参数，并将命令中的抽象要求转换为具体的要求。

⑵检查用户I/O请求的合法性，了解I/O设备的状态，传递有关参数，设置设备的工作方式。

⑶发出I/O命令。

⑷及时响应由控制器或通道发来的中断请求，并根据其中断类型调用相应的中断处理程序进行处理。

⑸对于设置有通道的计算机系统，驱动程序还应能够根据用户的I/O请求，自动地构建通道程序。

设备驱动程序的处理过程：⑴将抽象要求转换为具体要求⑵检查I/O设备请求的合法性⑶读出和检查设备的状态⑷传送必要的参数⑸工作方式的设置⑹启动I/O设备Linux系统中，设备驱动程序是操作系统内核的重要组成部分，它与硬件设备之间建立了标准的抽象接口。

通过这个接口，用户可以像处理普通文件一样，对硬件设备进行打开(open)、关闭(close)、读写(read/write)等操作。

通常设备驱动程序接口是由结构file_operations结构体向系统说明的，它定义在include/linux/fs.h中。

file_operations的数据结构如下：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 (*write) (struct file *, const char _user *, size_t, loff_t *);ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, 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);long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);long (*compat_ioctl) (struct file *, unsigned int, unsigned long);int (*mmap) (struct file *, struct vm_area_struct *);int (*open) (struct inode *, struct file *);int (*flush) (struct file *, fl_owner_t id);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);...};⑴open 入口点：open函数负责打开设备、准备I/O。

linux设备驱动程序之简单字符设备驱动⼀、linux系统将设备分为3类：字符设备、块设备、⽹络设备。

使⽤驱动程序：1、字符设备：是指只能⼀个字节⼀个字节读写的设备，不能随机读取设备内存中的某⼀数据，读取数据需要按照先后数据。

字符设备是⾯向流的设备，常见的字符设备有⿏标、键盘、串⼝、控制台和LED设备等。

2、块设备：是指可以从设备的任意位置读取⼀定长度数据的设备。

块设备包括硬盘、磁盘、U盘和SD卡等。

每⼀个字符设备或块设备都在/dev⽬录下对应⼀个设备⽂件。

linux⽤户程序通过设备⽂件（或称设备节点）来使⽤驱动程序操作字符设备和块设备。

⼆、字符设备驱动程序基础:1、主设备号和次设备号（⼆者⼀起为设备号）： ⼀个字符设备或块设备都有⼀个主设备号和⼀个次设备号。

主设备号⽤来标识与设备⽂件相连的驱动程序，⽤来反映设备类型。

次设备号被驱动程序⽤来辨别操作的是哪个设备，⽤来区分同类型的设备。

linux内核中，设备号⽤dev_t来描述，2.6.28中定义如下： typedef u_long dev_t; 在32位机中是4个字节，⾼12位表⽰主设备号，低12位表⽰次设备号。

可以使⽤下列宏从dev_t中获得主次设备号： 也可以使⽤下列宏通过主次设备号⽣成dev_t: MAJOR(dev_t dev); MKDEV(int major,int minor);MINOR(dev_t dev);View Code//宏定义：#define MINORBITS 20#define MINORMASK ((1U << MINORBITS) - 1)#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))2、分配设备号（两种⽅法）：（1）静态申请：int register_chrdev_region(dev_t from, unsigned count, const char *name)；View Code/*** register_chrdev_region() - register a range of device numbers* @from: the first in the desired range of device numbers; must include* the major number.* @count: the number of consecutive device numbers required* @name: the name of the device or driver.** Return value is zero on success, a negative error code on failure.*/（2）动态分配：int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)；View Codeint alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)；/*** alloc_chrdev_region() - register a range of char device numbers* @dev: output parameter for first assigned number* @baseminor: first of the requested range of minor numbers* @count: the number of minor numbers required* @name: the name of the associated device or driver** Allocates a range of char device numbers. The major number will be* chosen dynamically, and returned (along with the first minor number)* in @dev. Returns zero or a negative error code.*/注销设备号：void unregister_chrdev_region(dev_t from, unsigned count)；创建设备⽂件：利⽤cat /proc/devices查看申请到的设备名，设备号。

简单字符设备驱动程序的设计简单字符设备驱动程序的设计1. 引言字符设备驱动程序是一种用于管理与操作字符设备的软件模块。

字符设备是指每次读写以字符为单位进行的设备，如终端设备、串口设备等。

本文将介绍如何设计一个简单的字符设备驱动程序。

2. 设计目标本文所设计的字符设备驱动程序具备以下目标：- 支持对字符设备的打开、关闭、读取和写入操作- 实现对字符设备的基本管理功能- 提供简单的错误处理机制3. 设计概述为了实现上述目标，我们将分为以下几个步骤来设计简单字符设备驱动程序。

步骤一：注册字符设备在设计字符设备驱动程序之前，我们首先需要在内核中注册字符设备。

在Linux系统中，可以使用`register_chrdev`函数来注册字符设备。

该函数将分配一个主设备号，并将字符设备驱动程序与该主设备号关联起来。

步骤二：编写设备打开函数设备打开函数是字符设备驱动程序的入口函数，它在应用程序打开设备文件时被调用。

在设备打开函数中，我们可以完成设备的初始化工作，并分配资源给设备。

步骤三：编写设备关闭函数设备关闭函数在应用程序关闭设备文件时被调用。

在设备关闭函数中，我们可以释放设备所占用的资源，并做一些清理工作。

步骤四：编写设备读取函数设备读取函数用于从设备中读取数据。

在设备读取函数中，我们可以读取设备缓冲区中的数据，并将数据返回给应用程序。

步骤五：编写设备写入函数设备写入函数用于向设备中写入数据。

在设备写入函数中，我们可以将应用程序传递的数据写入设备缓冲区，以供后续读取。

步骤六：添加文件操作结构体为了将设备驱动程序与设备文件相关联，我们需要在字符设备驱动程序中定义一个文件操作结构体。

该结构体中包含了与设备操作相关的函数指针，如打开函数、关闭函数、读取函数和写入函数。

步骤七：注册字符设备驱动程序完成上述步骤后，我们需要将字符设备驱动程序注册到内核中。

可以使用`cdev_init`函数来初始化字符设备，然后使用`cdev_add`函数将字符设备添加到内核的字符设备列表中。

linux设备驱动第三篇：写⼀个简单的字符设备驱动在linux设备驱动第⼀篇：设备驱动程序简介中简单介绍了字符驱动，本篇简单介绍如何写⼀个简单的字符设备驱动。

本篇借鉴LDD中的源码，实现⼀个与硬件设备⽆关的字符设备驱动，仅仅操作从内核中分配的⼀些内存。

下⾯就开始学习如何写⼀个简单的字符设备驱动。

⾸先我们来分解⼀下字符设备驱动都有那些结构或者⽅法组成，也就是说实现⼀个可以使⽤的字符设备驱动我们必须做些什么⼯作。

1、主设备号和次设备号对于字符设备的访问是通过⽂件系统中的设备名称进⾏的。

他们通常位于/dev⽬录下。

如下：xxx@ubuntu:~$ ls -l /dev/total 0brw-rw---- 1 root disk 7, 0 3⽉ 25 10:34 loop0brw-rw---- 1 root disk 7, 1 3⽉ 25 10:34 loop1brw-rw---- 1 root disk 7, 2 3⽉ 25 10:34 loop2crw-rw-rw- 1 root tty 5, 0 3⽉ 25 12:48 ttycrw--w---- 1 root tty 4, 0 3⽉ 25 10:34 tty0crw-rw---- 1 root tty 4, 1 3⽉ 25 10:34 tty1crw--w---- 1 root tty 4, 10 3⽉ 25 10:34 tty10其中b代表块设备，c代表字符设备。

对于普通⽂件来说，ls -l会列出⽂件的长度，⽽对于设备⽂件来说，上⾯的7,5,4等代表的是对应设备的主设备号，⽽后⾯的0,1,2,10等则是对应设备的次设备号。

那么主设备号和次设备号分别代表什么意义呢？⼀般情况下，可以这样理解，主设备号标识设备对应的驱动程序，也就是说1个主设备号对应⼀个驱动程序。

当然，现在也有多个驱动程序共享主设备号的情况。

⽽次设备号有内核使⽤，⽤于确定/dev下的设备⽂件对应的具体设备。