建立linux内核机制学习的模板

最新推荐文章于 2024-10-02 14:03:05 发布

恰冯同学年少

最新推荐文章于 2024-10-02 14:03:05 发布

阅读量614

点赞数

分类专栏： linux kernel mechanism 文章标签： linux 字符设备

本文链接：https://blog.csdn.net/golf_research/article/details/53438033

版权

linux kernel mechanism 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1：概述

打算总结一下linux内核中的一些机制，所以建立了一个字符设备的模板，本驱动中申请一个1k的内存当作全局变量，应用程序操作的对象都是这个1k内存；

2：驱动分析

2.1：驱动的私有数据

buff指针指向1k内存的起始地址，current_len描述内存中的有效数据长度，写进程写数据，current_len增加，读进程读数据，current_len减小，当current_len为正，有数据可读，当current_len为0，内存中无数据更新，读进程返回0；

//申明驱动数据结构
struct hello_dev
{
	char *buff;                    //内存的起始地址
	int current_len;               //内存中的有效数据长度
	struct semaphore sem;          //用于防止并发的信号量
	struct cdev cdev;              //字符设备结构
};

2.2：文件操作集合

/*字符设备文件操作结构体*/
static struct file_operations hello_device_fops =
{
	.owner = THIS_MODULE,
	.llseek = hello_llseek,
	.read = hello_read,
	.write = hello_write,
	.compat_ioctl = hello_ioctl,
	.open = hello_open,
	.release = hello_release,
};

2.3：代码分享

hello.c驱动文件

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <asm/io.h>
#include <linux/slab.h>
#include <asm/uaccess.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/semaphore.h>
#include <linux/cdev.h>

#define HELLO_MEM_LENGTH 1024
#define CLEAR_MEM 0xff
//申明驱动数据结构
struct hello_dev
{
	char *buff;                    //内存的起始地址
	int current_len;               //内存中的有效数据长度
	struct semaphore sem;          //用于防止并发的信号量
	struct cdev cdev;              //字符设备结构
};

/*主设备号和次设备号变量*/
static int hello_major = 0;
static int hello_minor = 0;

/*定义设备私有结构体指针*/
static struct hello_dev *hello_dev = NULL;
static struct class *hello_class = NULL;


static loff_t hello_llseek (struct file *filp, loff_t offset, int whence)
{
	struct hello_dev *dev = filp->private_data;
	loff_t newpos = 0;
	
	switch(whence)
	{
		case 0:    //SEEK_SET
			newpos = offset;
			break;
		case 1:    //SEEK_CUR
			newpos = filp->f_pos + offset;
			break;
		case 2:    //SEEK_END
			newpos = HELLO_MEM_LENGTH + offset;
			break;
		default:   //can't happen
			return -EINVAL;
			break;
	}

	filp->f_pos = newpos;
	if(newpos < 0)
		return -EINVAL;
	return newpos;
}

static int hello_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	struct hello_dev *dev = filp->private_data;

	switch(cmd)
	{
		case CLEAR_MEM:
			memset(dev->buff,0,HELLO_MEM_LENGTH);
			break;
		default:
			return -EINVAL;
			break;
	}
	return 0;
}

static ssize_t hello_write(struct file *filp, const char __user *buf, size_t count,loff_t *f_pos)
{
	ssize_t result = 0;

	/*取出用户自定义设备结构体*/
	struct hello_dev *dev = filp->private_data;

	/*信号量使用，用于多个写进程之间互斥以及读进程同步*/
	if(down_interruptible(&(dev->sem)))
	{
		return -ERESTARTSYS;
	}

	/*写界限控制*/
	if(*f_pos >= HELLO_MEM_LENGTH)
	{
		result = 0;
		goto out;
	}

	/*写数据字节数控制*/
	if(count > HELLO_MEM_LENGTH - *f_pos)
	{
		count = HELLO_MEM_LENGTH - *f_pos;
	}

	/*从用户空间读取count个字节的数据给val变量*/
	if(copy_from_user(dev->buff + *f_pos,buf,count))
	{
		result = -EFAULT;
		goto out;
	}

	/*每次跟新pos指针*/
	*f_pos += count;
	dev->current_len += count;
	if(dev->current_len > HELLO_MEM_LENGTH)
	{
		dev->current_len = HELLO_MEM_LENGTH;
	}
	result = count;

out:
	up(&(dev->sem));
	return result; 
}

static ssize_t hello_read(struct file *filp, char __user *buf, size_t count,loff_t *f_pos)
{
	ssize_t result = 0;
	struct hello_dev *dev = filp->private_data;

	 if(down_interruptible(&(dev->sem)))
	 {
		 return -ERESTARTSYS;
	 }
	
	 if(*f_pos > dev->current_len)
		  goto out;

	 if(count > dev->current_len - *f_pos)
	 {
		count = dev->current_len - *f_pos;
	 }

	 if(copy_to_user(buf,dev->buff + *f_pos,count))
     {
		 result = -EFAULT;
		 goto out;
	 }
	
	 *f_pos += count;
	 dev->current_len -= count;
	 result = count;
	
out:
	up(&(dev->sem));

	return result;
}

static int hello_open(struct inode *inode, struct file *filp)
{
	struct hello_dev *dev;

	/*将文件节点的私有数据指针指向用户自定义的数据结构体，方便read和write方法中使用*/
	dev = container_of(inode->i_cdev, struct hello_dev, cdev);
	filp->private_data = dev;

	if(down_interruptible(&(dev->sem)))
	{
		return -ERESTARTSYS;
	}

	//如果内存为申请，申请内存
	if(!dev->buff)
	{
		dev->buff = kmalloc(HELLO_MEM_LENGTH,GFP_KERNEL);
		if(!dev->buff)
		{
			up(&dev->sem);
			return -ENOMEM;
		}
	}

	up(&dev->sem);
	return 0;
}

/*设备文件释放时调用*/
int hello_release(struct inode *inode, struct file *filp)
{
	printk(KERN_ALERT "Release dev->buff source\r\n");
	return 0;
}

/*字符设备文件操作结构体*/
static struct file_operations hello_device_fops =
{
	.owner = THIS_MODULE,
	.llseek = hello_llseek,
	.read = hello_read,
	.write = hello_write,
	.compat_ioctl = hello_ioctl,
	.open = hello_open,
	.release = hello_release,
};

/*注册字符设备和初始化信号量*/
static int hello_setup_chardev(void)
{
	int err;
	dev_t devno = 0;
	devno = MKDEV(hello_major,hello_minor);

	memset(hello_dev,0,sizeof(struct hello_dev));

	cdev_init(&(hello_dev->cdev),&hello_device_fops);
	hello_dev->cdev.owner = THIS_MODULE;
	hello_dev->cdev.ops = &hello_device_fops;	
	err = cdev_add(&(hello_dev->cdev),devno,1); 
	if(err)
	{
		return err;
	}

	sema_init(&(hello_dev->sem),1);

	return 0;
}

static int __init hello_init(void)
{
	int result = 0;
	dev_t devno = 0;
	struct device *dev = NULL;

	/*申请字符设备号*/
	if(hello_major)
	{
		devno = MKDEV(hello_major,hello_minor);
		result = register_chrdev_region(devno,1,"hello_device");  /*hello_device是字符设备名字，在proc/devices下可见*/
	}
	else
	{
		result = alloc_chrdev_region(&devno,0,1,"hello_device"); /*动态申请一个字符设备，从设备号为0*/
	}

	if(result < 0)
	{
		printk(KERN_ALERT "Failed register char dev region\n");
		goto fail;
	}

	hello_major = MAJOR(devno);
	hello_minor = MINOR(devno);

	/*动态分配hello_dev结构体*/
	hello_dev = kmalloc(sizeof(struct hello_dev),GFP_KERNEL);
	if(hello_dev == NULL)
	{
		result = -ENOMEM;
		printk(KERN_ALERT "Failed alloc hello_dev\n");
		goto unregister;
	}

	/*注册字符设备，初始化信号量*/
	result = hello_setup_chardev();
	if(result)
	{
		printk(KERN_ALERT "Failed setup char dev\n");
		goto free;
	}

	/*在sys/class/目录下创建hello目录*/
	hello_class = class_create(THIS_MODULE,"hello");
	if(IS_ERR(hello_class))
	{
		result = PTR_ERR(hello_class);
		printk(KERN_ALERT "Failed to create hello class.\n");
		goto cdev_destroy;
	}

	/*在/dev/目录和/sys/class/hello目录下分别创建设备文件hello*/
	dev = device_create(hello_class,NULL,devno,NULL,"hello");
	if(IS_ERR(dev))
	{
		result = PTR_ERR(dev);
		printk(KERN_ALERT "Failed to create hello device.\n");
		goto class_destroy;
	}

	printk(KERN_ALERT "hello char device init ok\n");
	return 0;

class_destroy:
	class_destroy(hello_class);
	
cdev_destroy:
	cdev_del(&(hello_dev->cdev));

free:
	kfree(hello_dev);

unregister:
	unregister_chrdev_region(devno,1);

fail:
	return result;
}

static void __exit hello_exit(void)
{
	dev_t devno = 0;
	printk(KERN_ALERT "hello char device exit\n");
	devno = MKDEV(hello_major,hello_minor);

	device_destroy(hello_class,devno);
	class_destroy(hello_class);
	cdev_del(&(hello_dev->cdev));
	kfree(hello_dev->buff);
	kfree(hello_dev);
	unregister_chrdev_region(devno,1);
}

module_init(hello_init);
module_exit(hello_exit);

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("GOLF/FXB,<1029930509@qq.com>");
MODULE_DESCRIPTION("A SIMPLE CHAR DEVICE DRIVER");

Makefile

#Kbuild Makefile

#Kbuild的生成规则，编译对象chardev依赖文件char_device.o文件
#将编译对象hello_word编译成模块
obj-m := hello.o
#hello-objs := hello.o   

#ubuntu使用的内核源代码，build是链接文件
KERNEL_DIR := /lib/modules/$(shell uname -r)/build   


#当前目录
PWD := $(shell pwd)                               

#首先执行内核源代码中的TOP Makefile文件，设置内核编译环境，再执行用户定义的Kbuile Makefile文件
all:
	make -C $(KERNEL_DIR) M=$(PWD) modules   

#make clean命令
clean:                                                 
	rm *.o *.ko *.mod.c *.order *.symvers 

#执行"make clean"会无视"clean"文件存在与否。
.PHONY :clean

3：编写测试程序

3.1：加载insmod hello.ko模块，在/dev目录出现hello节点

3.2：测试程序代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define LENGTH 1024
char buff[LENGTH+1];

int main(int  argc,char **argv)
{
	int cnt = 0;
	int fd = 0;
	fd = open("/dev/hello",O_RDWR);
	if(fd < 0)
		perror("file is not found\r\n");

	while(1)
	{
		cnt = read(fd,buff,LENGTH);
		if(cnt > 0)
		{
			buff[cnt] = '\0';
			printf("%s",buff);
			lseek(fd,0,SEEK_SET);
		}
	}
}

此应用程序一直去读节点，程序中判断是否有数据读出，如果有数据更新，打印读到的数据；

3.3：编译上述代码，然后运行，此时应用程序相当于一个读进程，然后开启一个写进程，比如：cat demo.c > /dev/hello，此时，观察读进程，窗口会打印出demo.c文件；

4：总结

驱动代码中没有实现阻塞机制，所以应用程序的执行很浪费cpu资源，因为进程一直在while循环去读节点，下一篇博文，将在此驱动模板的基础上，增加read和write的阻塞机制；