03.驱动学习复盘（应用层和内核层数据传输）

1.Linux一切皆文件！文件对应的操作有打开、关闭、读写等。设备节点也是。

2.文件操作集中常用的几个函数：

struct file_operations {
	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
	unsigned int (*poll) (struct file *, struct poll_table_struct *);
	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
	int (*open) (struct inode *, struct file *);
	int (*release) (struct inode *, struct file *);
};

3.设备节点是应用层与内核层之间的桥梁。应用层和内核层是不能直接进行数据传输的。

static inline long copy_to_user(void __user *to, const void *from, unsigned long n)

static inline long copy_from_user(void *to, const void __user * from, unsigned long n)

4.app的代码：

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

int main(int argc, char *argv[])
{
	int fd;

	char rbuf[64] = {0};
	char wbuf[64] = "123456";

	fd = open("/dev/file_operations",O_RDWR);
	if(fd < 0)
	{
		perror("open error\n");
		return fd;
	}
	
	read(fd,rbuf,sizeof(rbuf));
	printf("rbuf is %s\n",rbuf);

	write(fd,wbuf,sizeof(wbuf));

	close(fd);

	return 0;
}

5.驱动的代码：

//包含宏定义的头文件
#include <linux/init.h>
//包含初始化加载模块的头文件
#include <linux/module.h>
//杂项设备头文件
#include <linux/miscdevice.h>
//文件操作符头文件
#include <linux/fs.h>
#include <linux/uaccess.h>

int misc_open(struct inode * inode, struct file * file)
{
	printk("misc_open\n");

	return 0;
}

int misc_release (struct inode *inode, struct file *file)
{
	printk("misc_release\n");

	return 0;
}

ssize_t misc_read (struct file *file, char __user *ubuf, size_t size, loff_t *loff_t)
{
	char kbuf[64] = "hahaha";
	
	if(copy_to_user(ubuf, kbuf, strlen(kbuf)) != 0)
	{
		printk("copy_to_user error\n");
		return -1;
	}

	return 0;
}

ssize_t misc_write (struct file *file, const char __user *ubuf, size_t size, loff_t *loff_t)
{
	char kbuf[64] = {0};
	
	if(copy_from_user(kbuf, ubuf, size) != 0)
	{
		printk("copy_from_user error\n");
		return -1;
	}
	
	printk("kbuf is %s\n",kbuf);

	return 0;
}

//定义文件操作符
struct file_operations misc_fops = {
	.owner = THIS_MODULE,
	.open = misc_open,
	.release = misc_release,
	.read = misc_read,
	.write = misc_write
};

//杂项设备结构体
struct miscdevice misc_dev = {
	//次设备号动态分配
	.minor = MISC_DYNAMIC_MINOR,
	//设备节点的名字
	.name = "file_operations",
	//文件操作符
	.fops = &misc_fops
};

//装载卸载函数实体
static int __init misc_init(void)
{
	int ret;
	//注册杂项设备
	ret = misc_register(&misc_dev);

	if(ret < 0)
	{
		printk("misc register is error\n");
		return -1;
	}
	
	printk("misc_init\n");
	return 0;
}

static void __exit misc_exit(void)
{
	//卸载杂项设备
	misc_deregister(&misc_dev);
	
	printk("misc_exit\n");
}

//装载卸载函数声明
module_init(misc_init);
module_exit(misc_exit);

//开源许可证GPL声明
MODULE_LICENSE("GPL");