lv 14 字符设备读写操作实现 5

一、读操作实现

ssize_t xxx_read(struct file *filp, char __user *pbuf, size_t count, loff_t *ppos);
完成功能：读取设备产生的数据
参数：
 ? ?filp：指向open产生的struct file类型的对象，表示本次read对应的那次open
 ? ?pbuf：指向用户空间一块内存，用来保存读到的数据
 ? ?count：用户期望读取的字节数
 ? ?ppos：对于需要位置指示器控制的设备操作有用，用来指示读取的起始位置，读完后也需要变更位置指示器的指示位置
 返回值：
 ? ?本次成功读取的字节数，失败返回-1

put_user(x,ptr)

x：char、int类型的简单变量名

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

成功为返回0，失败非0

二、写操作实现

ssize_t xxx_write (struct file *filp, const char __user *pbuf, size_t count, loff_t *ppos); ?
完成功能：向设备写入数据
参数：
 ? ?filp：指向open产生的struct file类型的对象，表示本次write对应的那次open
 ? ?pbuf：指向用户空间一块内存，用来保存被写的数据
 ? ?count：用户期望写入的字节数
 ? ?ppos：对于需要位置指示器控制的设备操作有用，用来指示写入的起始位置，写完后也需要变更位置指示器的指示位置
 返回值：
 ? ?本次成功写入的字节数，失败返回-1
?

get_user(x,ptr)

x：char、int类型的简单变量名

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

成功为返回0，失败非0

三、示例

mychar.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>

#define BUF_LEN 100

int major = 11;
int minor = 0;
int mychar_num = 1;

struct cdev mydev;

char mydev_buf[BUF_LEN];
int curlen = 0;

int mychar_open(struct inode *pnode,struct file *pfile)
{
	printk("mychar_open is called\n");
	return 0;
}

int mychar_close(struct inode *pnode,struct file *pfile)
{
	printk("mychar_close is called\n");
	return 0;
}

ssize_t mychar_read(struct file *pfile, char __user *puser, size_t count, loff_t *p_pos)
{
	int size = 0;
	int ret = 0;

	if(count > curlen)
	{
		size = curlen;
	}
	else
	{
		size = count;
	}

	ret = copy_to_user(puser,mydev_buf,size);
	if(ret)
	{
		printk("copy_to_user failed\n");
		return -1;
	}

	memcpy(mydev_buf,mydev_buf + size,curlen - size);

	curlen = curlen - size;
	return size;
}

ssize_t mychar_write(struct file *pfile,const char __user *puser,size_t count, loff_t *p_pos)
{
	int size = 0;
	int ret = 0;

	if(count > BUF_LEN-curlen)
	{
		size = BUF_LEN - curlen;
	}
	else
	{
		size = count;
	}

	ret = copy_from_user(mydev_buf + curlen,puser,size);
	if(ret)
	{
		printk("copy_from user failed\n");
		return -1;
	}
	curlen = curlen + size;

	return size;
}

struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = mychar_open,
	.release = mychar_close,
	.read = mychar_read,
	.write = mychar_write,
};

int __init mychar_init(void)
{
	int ret = 0;
	dev_t devno = MKDEV(major,minor);

	/*申请设备号*/
	ret = register_chrdev_region(devno,mychar_num, "mychar");
	if(ret)
	{
		ret = alloc_chrdev_region(&devno,minor,mychar_num,"mychar");
		if(ret)
		{
			printk("get devno failed\n");
			return -1;
		}
		major = MAJOR(devno);//容易遗漏，注意
	}

	/*给struct cdev对象指定操作函数集*/
	cdev_init(&mydev,&myops);

	/*将struct cdev对象添加到内核对应的数据结构里*/
	mydev.owner = THIS_MODULE;
	cdev_add(&mydev,devno,mychar_num);

	return 0;
}

void  __exit mychar_exit(void)
{
	dev_t devno = MKDEV(major,minor);

	cdev_del(&mydev);

	unregister_chrdev_region(devno,mychar_num);
}


MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);

"copy_to_user" 是一个在操作系统中常见的函数或操作，用于将内核空间中的数据复制到用户空间中。在Linux内核中，copy_to_user() 函数用于将内核缓冲区中的数据复制到用户空间的缓冲区中。它的原型如下：

unsigned long copy_to_user(void __user *dst, const void *src, unsigned long size);

其中，dst 是指向用户空间缓冲区的指针，src 是指向内核空间缓冲区的指针，size 是要复制的数据的字节数。该函数返回成功复制的字节数，如果出现错误则返回一个负数。

需要注意的是，由于我是一个AI机器人，无法直接执行代码或提供实际的编程环境。如果你有关于 copy_to_user() 函数的具体问题，可以提供更多的背景信息，我将尽力给予帮助。

testmychar_app.c

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

#include <stdio.h>


int main(int argc,char *argv[])
{
	int fd = -1;
	char buf[8] = "";

	if(argc < 2)
	{
		printf("The argument is too few\n");
		return 1;
	}

	fd = open(argv[1],O_RDWR);
	if(fd < 0)
	{
		printf("open %s failed\n",argv[1]);
		return 2;
	}

	write(fd,"hello",6);
	
	read(fd,buf,8);
	printf("buf=%s\n",buf);

	close(fd);
	fd = -1;
	return 0;
}

Makefile?

ifeq ($(KERNELRELEASE),)
 
ifeq ($(ARCH),arm)
KERNELDIR ?= /home/linux/Linux_4412/kernel/linux-3.14
ROOTFS ?= /opt/4412/rootfs
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
endif
PWD := $(shell pwd)
 
 
modules:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
 
modules_install:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules INSTALL_MOD_PATH=$(ROOTFS) modules_install
 
clean:
	rm -rf  *.o  *.ko  .*.cmd  *.mod.*  modules.order  Module.symvers   .tmp_versions
 
else
CONFIG_MODULE_SIG=n
obj-m += mychar.o
 
endif

避开使用全局变量，使得函数更通用一些