内核，shell，文件系统，应用程序构成了基本的linux结构

Kernel

内核又分为内存管理，进程管理，设备驱动程序，文件系统和网络管理等

shell

提供了一个界面，用户通过这个界面访问操作系统内核的服务。

文件系统

linux有很丰富的文件系统，Linux 中最普遍使用的文件系统是 Ext2，还有nfs，ext4，ext3等等。linux将独立的文件系统组合成为了一个层次的树状结构，新的文件系统可以通过挂载到某一个目录进行访问，这些功能的基础是虚拟文件系统VFS，linux除进程以外全部视为文件。

应用程序

上层开发者根据对应的API，或者SDK来开发的软件

linux系统将设备分成三个基本类型

• 字符设备
• 块设备
• 网络接口

根据资料，我们对设备的所有操作基本上都可以简化成open、close、read、write、io control这几个操作。下面进行一个小的实验。

简单的驱动入门

创建一个文件夹

mkdir mydrvice

创建一个文件 mydrvice1.c

vim mydrvice1.c

写入以下内容

#include <linux/init.h>
#include <linux/sched.h>
#include <linux/module.h>//内核可以识别的许可证有“GPL”，“GPL v2”等等，如果模块没有显示地标记许可证，会被认为是私有开发
MODULE_LICENSE("GPL"); 
MODULE_AUTHOR("Kevin"); //模块作者
MODULE_DESCRIPTION("This is just a hello module!\n"); //模块的描述注释说明
//  MODULE_VERSION 代码修订号
//  MODULE_ALIAS 模块的别名
//  MODULE_DEVICE_TABLE 告诉用户空间模块支持的设备static int __init hello_init(void)
{printk(KERN_EMERG "hello, init\n"); // printk可以用来调试内核，查看值return 0;
}static void __exit hello_exit(void)
{printk(KERN_EMERG "hello, exit\n");
}module_init(hello_init);
module_exit(hello_exit);

编写Makefile

vim Makefile

ifneq ($(KERNELRELEASE),)
obj-m := mydrvice1.oelse
PWD  := $(shell pwd)
KVER := $(shell uname -r)
KDIR := /lib/modules/$(KVER)/build
all:$(MAKE) -C $(KDIR) M=$(PWD) modules
clean:rm -rf .*.cmd *.o *.mod.c *.ko .tmp_versions
endif

然后make一下

make

输入insmod 安装驱动程序

使用insmod安装模块，内部调用了 sys_init_module系统调用，在sys_init_module内部调用了load_module，把mydrvice1.ko创建成一个内核模块，返回一个struct module结构体，内核中便以这个结构体代表这个内核模块。

module->state(module结构体下的state枚举变量)

• MODULE_STATE_LIVE //正常使用中
• MODULE_STATE_COMING //正在被加载
• MODULE_STATE_GOING //正在被卸载

load_module函数中完成模块的部分创建工作后，把状态置为 MODULE_STATE_COMING

sys_init_module函数中完成模块的全部初始化工作后（包括把模块加入全局的模块列表，调用模块本身的初始化函数)，把模块状态置为MODULE_STATE_LIVE

使用rmmod工具卸载模块时，会调用系统调用 delete_module，会把模块的状态置为MODULE_STATE_GOING。

insmod mydrvice1.ko

输入dmesg

dmesg

结果输出

[ 253.346485] hello, init

输入rmmod 安装驱动程序

rmmod mydrvice1.ko

输入dmesg

dmesg

结果输出

[ 969.532449] hello, exit

字符设备驱动入门

创建char文件夹并且进入

mkdir char && cd char

编写char.c

#include <linux/module.h>#include <linux/kernel.h>#include <linux/fs.h>#include <linux/cdev.h> static struct cdev chr_dev;static dev_t ndev;//linux内核中表示不同的设备是通过major 和minor number实现的，通过major和minor Number来加载相应的驱动程序。//major number：表示不同的设备类型//minor number：表示同一个设备的的不同分区static int chr_open(struct inode* nd, struct file* filp){	int major ;	int minor;		major = MAJOR(nd->i_rdev);	minor = MINOR(nd->i_rdev);		printk("chr_open, major = %d, minor = %d\n", major, minor);	return 0;} static ssize_t chr_read(struct file* filp, char __user* u, size_t sz, loff_t* off){	printk("chr_read process!\n");	return 0;} struct file_operations chr_ops = {    //指定初始化 C99标准	.owner = THIS_MODULE, //THIS_MODULE是一个宏指向当前的本模块，#define THIS_MODULE (&__this_module)	.open = chr_open, //应该是把open操作变成了自定义的函数了	.read = chr_read  //应该是把read操作变成了自定义的函数了}; static int demo_init(void){	int ret;		cdev_init(&chr_dev, &chr_ops); //字符设备的注册	ret = alloc_chrdev_region(&ndev, 0, 1, "chr_dev"); //动态的申请注册一个设备号	if(ret < 0 )	{		return ret;	}		printk("demo_init(): major = %d, minor = %d\n", MAJOR(ndev), MINOR(ndev));	ret = cdev_add(&chr_dev, ndev, 1);//添加字符设备	if(ret < 0)	{		return ret;	}		return 0;} static void demo_exit(void){	printk("demo_exit process!\n");	cdev_del(&chr_dev);	unregister_chrdev_region(ndev, 1);}//实现模块加载和卸载入口函数module_init(demo_init);module_exit(demo_exit); MODULE_LICENSE("GPL");MODULE_AUTHOR("Kevin");MODULE_DESCRIPTION("A simple device example!");

编写Makefile

ifneq ($(KERNELRELEASE),)obj-m := char.o elsePWD  := $(shell pwd)KVER := $(shell uname -r)KDIR := /lib/modules/$(KVER)/buildall:	$(MAKE) -C $(KDIR) M=$(PWD) modulesclean:	rm -rf .*.cmd *.o *.mod.c *.ko .tmp_versions modules.*  Module.*endif

安装模块

insmod char.ko

输入dmesg

dmesg

显示

[ 3539.169209] demo_init(): major = 241, minor = 0

以利用major，minor直接创建设备节点，输入

mknod /dev/chr_dev c 241 0

验证

[root@localhost char]# ls /dev/chr_dev/dev/chr_dev

编写test.c来验证

#include <stdio.h>#include <fcntl.h>#include <unistd.h> #define CHAR_DEV_NAME "/dev/chr_dev" int main(){	int ret;	int fd;	char buf[32]; 	fd = open(CHAR_DEV_NAME, O_RDONLY | O_NDELAY); //只读 | O_NDELAY?	if(fd < 0)	{		printf("open failed!\n");		return -1;	}    //返回的文件描述符，然后开始读	read(fd, buf, 32);	close(fd);		return 0;}

然后

gcc -c test.c -o test

再

./test

最后使用dmesg查看

[ 3853.632993] chr_read process!

控制两种模式

MODE_1 MODE_2

使用open打开设备，先write写入name，再read返回

如果是MODE_1，返回 hello name（3环）

如果是MODE_2，返回 welcome name（3环）

#include <linux/module.h>    // included for all kernel modules#include <linux/kernel.h>    // included for KERN_INFO#include <linux/init.h>      // included for __init and __exit macros#include <linux/scpi_protocol.h>#include <asm/io.h>#include <linux/slab.h>#include <linux/fs.h>        // file_operation is defined in this header #include <linux/device.h>MODULE_LICENSE("GPL");MODULE_AUTHOR("Kevin");MODULE_DESCRIPTION("Driver as a test case"); static int      majorNumber;static struct   class*  test_module_class = NULL;static struct   device* test_module_device = NULL;#define DEVICE_NAME "test"      //定义设备名称#define CLASS_NAME  "test_module" //函数原型static long test_module_ioctl(struct file *, unsigned int, unsigned long);static int __init test_init(void);static void __exit test_exit(void); //linux/fs.h中的file_operations结构体列出了所有操作系统允许的对设备文件的操作。//在我们的驱动中，需要将其中需要的函数进行实现。//下面这个结构体就是向操作系统声明，那些规定好的操作在本模块里是由哪个函数实现的。static const struct file_operations test_module_fo = {        .owner = THIS_MODULE,        .unlocked_ioctl = test_module_ioctl, //unlocked_ioctl是由本模块中的test_module_ioctl()函数实现的}; //本模块ioctl回调函数的实现static long test_module_ioctl(struct file *file, unsigned int cmd, unsigned long param){                switch(cmd)        {            case MODE_1:            filp->f_pos += (int)arg;            case MODE_2:            filp->f_pos += (int)arg;        }        /* ioctl回调函数中一般都使用switch结构来处理不同的输入参数（cmd） */        switch(cmd){        case 0:        {                printk(KERN_INFO "[TestModule:] Inner function (ioctl 0) finished.\n");                break;        }        default:                printk(KERN_INFO "[TestModule:] Unknown ioctl cmd!\n");                return -EINVAL;        }        return 0;}  static int __init test_init(void){        printk(KERN_INFO "开始进行初始化\n");        // 在加载本模块时，首先向操作系统注册一个chrdev，也即字节设备，三个参数分别为：主设备号（填写0即为等待系统分配），设备名称以及file_operation的结构体。返回值为系统分配的主设备号。        majorNumber = register_chrdev(0, DEVICE_NAME, &test_module_fo);        if(majorNumber < 0){                printk(KERN_INFO "注册主设备号失败 \n");                return majorNumber;        }DEVICE_NAME        printk(KERN_INFO "注册主设备号成功 %d. \n", majorNumber);         //接下来，注册设备类        test_module_class = class_create(THIS_MODULE, CLASS_NAME);        if(IS_ERR(test_module_class)){                unregister_chrdev(majorNumber, DEVICE_NAME);                printk(KERN_INFO "注册设备类失败\n");                return PTR_ERR(test_module_class);        }        printk(KERN_INFO "注册设备类成功\n");         //最后，使用device_create函数注册设备驱动        test_module_device = device_create(test_module_class, NULL, MKDEV(majorNumber, 0), NULL, DEVICE_NAME);        if (IS_ERR(test_module_device)){          // Clean up if there is an error                class_destroy(test_module_class); // Repeated code but the alternative is goto statements                unregister_chrdev(majorNumber, DEVICE_NAME);                printk(KERN_ALERT "注册驱动失败\n");                return PTR_ERR(test_module_device);        }        printk(KERN_INFO "注册模块驱动成功\n");        return 0;}  static void __exit test_exit(void){	//退出时，依次清理生成的device,class和chrdev。这样就将系统/dev下的设备文件删除，并自动注销了/proc/devices的设备。    printk(KERN_INFO "[TestModule:] Start to clean up module.\n");    device_destroy(test_module_class, MKDEV(majorNumber, 0));    class_destroy(test_module_class);    unregister_chrdev(majorNumber, DEVICE_NAME);    printk(KERN_INFO "[TestModule:] Clean up successful. Bye.\n");} module_init(test_init);module_exit(test_exit);

实验

控制两种模式

MODE_1 MODE_2

使用open打开设备，先write写入name，再read返回

如果是MODE_1，返回 hello name（3环）

如果是MODE_2，返回 welcome name（3环）

编写char3.c

#include <linux/module.h>#include <linux/kernel.h>#include <linux/fs.h>#include <linux/cdev.h>#include "test.h"static struct cdev chr_dev;static dev_t ndev;static char name[32];MODULE_LICENSE("GPL");static int chr_open(struct inode* nd, struct file* filp){	int major;	int minor;		major = MAJOR(nd->i_rdev);	minor = MINOR(nd->i_rdev);		printk("chr_open, major = %d, minor = %d\n", major, minor);	return 0;}//filp是文件指针，count是请求传输的数据量，buff参数指向数据缓存，最后offp之处文件当前的访问位置。//ssize_t xxx_read(struct file* filp,char __user* buff,size_t count,loff_t*offp);static ssize_t chr_read(struct file* filp, char __user* buff, size_t count, loff_t* off){	int j;	for (j = 0; j < count; j++ )	{            buff[j] = name[j];    }	return 0;}static ssize_t chr_write(struct file* filp,const char __user* buff,size_t count,loff_t* off){	int i;	printk( "write--%ld\n", count );	printk( "write--%s\n", buff );	for (i = 0; i < count; i++ )	{		name[i] = buff[i];	}	printk( "write--name = %s\n", name );    return 0;}//本模块ioctl回调函数的实现long char_ioctl(struct file *filp, unsigned int cmd, unsigned long param){	int i;	//ioctl回调函数中一般都使用switch结构来处理不同的输入参数（cmd)	printk("char_ioctl: cmd=%d\n", cmd);	switch(cmd)    {        case MODULE_ONE:			printk("1\n");			for(i=31 ; i>=0 ;i--){				if(name[i]!="\0"){					name[i+6] = name[i];				}			}			name[0]='H'; //没想到好的算法，暂时就先这样赋值			name[1]='e';			name[2]='l';			name[3]='l';			name[4]='o';			name[5]=' ';			break;			        case MODULE_TWO:			printk("2\n");			for(i=31 ; i>=0 ;i--){                if(name[i]!="\0"){                    name[i+8] = name[i];                }            }            name[0]='W';            name[1]='e';            name[2]='l';            name[3]='c';            name[4]='o';            name[5]='m';			name[6]='e';			name[7]=' ';			break;    }	    return 0;}struct file_operations chr_ops = {	.owner = THIS_MODULE,	.open = chr_open, 	.read = chr_read,    .write = chr_write,	.unlocked_ioctl = char_ioctl}; static int demo_init(void){	int ret;		cdev_init(&chr_dev, &chr_ops); //字符设备的注册	ret = alloc_chrdev_region(&ndev, 0, 1, "chr_dev"); //动态的申请注册一个设备号	if(ret < 0 )	{	    printk("wrong 2\n");		return ret;	}		printk("demo_init(): major = %d, minor = %d\n", MAJOR(ndev), MINOR(ndev));	ret = cdev_add(&chr_dev, ndev, 1);//添加字符设备	if(ret < 0)	{	    printk("wrong 2\n");		return ret;	}		return 0;} static void demo_exit(void){	printk("demo_exit process!\n");	cdev_del(&chr_dev);	unregister_chrdev_region(ndev, 1);}//实现模块加载和卸载入口函数module_init(demo_init);module_exit(demo_exit);

编写test.h

#ifndef SCULL_H_#define SCULL_H_//定义幻数#define SCULL_IOC_MAGIC '$'//定义命令->//数据清零#define MODULE_ONE _IO(SCULL_IOC_MAGIC, 0)#define MODULE_TWO _IO(SCULL_IOC_MAGIC, 1)#endif

编写测试案例

#include <stdio.h>#include <fcntl.h>#include <unistd.h>#include <sys/ioctl.h>#include "test.h"#define CHAR_DEV_NAME "/dev/chr_dev" int main(){	int ret;	int fd;	char name[32]={"Kevin"};     char temp[50];	fd = open(CHAR_DEV_NAME, O_RDWR);	//fd = open(CHAR_DEV_NAME, O_RDWR);	if(fd < 0)	{		printf("open failed!\n");		return -1;	}    //返回的文件描述符，然后开始读	write(fd, name, 32);    	int r = ioctl(fd, MODULE_ONE);	printf("r=%d\n", r);	read(fd, temp, 32);	printf("\n%s\n", temp);	write(fd, name, 32);	ioctl(fd, MODULE_TWO);	read(fd, temp, 32);	printf("\n%s\n", temp);	close(fd);		return 0;}

编写Makefile

ifneq ($(KERNELRELEASE),)obj-m := char3.o elsePWD  := $(shell pwd)KVER := $(shell uname -r)KDIR := /lib/modules/$(KVER)/buildall:	$(MAKE) -C $(KDIR) M=$(PWD) modulesclean:	rm -rf .*.cmd *.o *.mod.c *.ko .tmp_versions modules.*  Module.*endif

然后生成

make

再安装模块

insmod char3

以利用major，minor直接创建设备节点，输入

mknod /dev/chr_dev c 237 0

编译测试程序

gcc test.c -o test

测试

./test

输出

[root@localhost char2]# ./testr=0Hello KevinWelcome Kevin

在dmesg日志里面

[ 6416.836095] chr_open, major = 237, minor = 0[ 6416.836097] write--32[ 6416.836098] write--Kevin[ 6416.836098] write--name = Kevin[ 6416.836099] char_ioctl: cmd=9216[ 6416.836099] 1[ 6416.836155] write--32[ 6416.836155] write--Kevin[ 6416.836156] write--name = Kevin[ 6416.836157] char_ioctl: cmd=9217[ 6416.836157] 2