字符设备驱动基础（二）

news2025/1/13 10:19:41

目录

 一、五种IO模型------读写外设数据的方式

二、阻塞与非阻塞

三、多路复用

3.1 应用层：三套接口select、poll、epoll

3.2 驱动层：实现poll函数

四、信号驱动

4.1 应用层：信号注册+fcntl

4.2 驱动层：实现fasync函数

 一、五种IO模型------读写外设数据的方式


1. 阻塞: 不能操作就睡觉
（进入睡眠态，不参与时间片轮转机制）

2. 非阻塞：不能操作就返回错误

3. 多路复用：委托中介监控

4. 信号驱动：让内核如果能操作时发信号，在信号处理函数中操作

（不可靠，项目少用。序号小于32的信号连续发送内核只认第一次.多用于两个进程一对一）

（当程序发出一个信号给另一个程序时先到内核中的系统调用函数，当回到用户态时看看收没收到信号然后才进入信号处理函数。然后回到系统调用函数再回到用户态程序继续执行i。再处理时如果来的信号序号小于32都会被丢掉）

（让内核帮我们检查能不能做。如果能做再信号处理函数中操作）

5. 异步IO：向内核注册操作请求，内核完成操作后发通知信号

（在内核中注册一个信号，交给内核。内核完成操作后给程序发信号）

二、阻塞与非阻塞

应用层：

​   open时由O_NONBLOCK指示read、write时是否阻塞

（O_RDWD | O_NONBLOCK）非阻塞

 ​   open以后可以由fcntl函数来改变是否阻塞：

```

flags = fcntl(fd,F_GETFL,0);

flags |= O_NONBLOCK;                      //flags |= （~O_NONBLOCK）;

fcntl(fd, F_SETFL, flags);

```

（就绪态和运行态之间的转换

就绪态有一个链式队列，队列中有很多节点

当一个cpu时间片开始时取出队列中的头节点去运行一个时间片然后插入到队尾

睡眠态怎么实现呢，再搞一个队列叫等待队列。把一个任务放到等待队列就处于睡眠态了。把任务从等待队列放到就绪队列就会继续参与时间片轮转。

睡眠分两种，资源就位了，满足的条件成立了才会醒来的叫深度睡眠，除了这俩情况接收到信号也会醒来的叫浅睡眠）

驱动层：通过等待队列

严格来说下面这俩不是函数而是带参的宏

```c

wait_queue_head_t //等待队列头数据类型



init_waitqueue_head(wait_queue_head_t *pwq) //初始化等待队列头

   

wait_event_interruptible(wq,condition)

/*

功能：条件不成立则让任务进入浅度睡眠，直到条件成立醒来

    wq:等待队列头

    condition：C语言表达式

返回：正常唤醒返回0，信号唤醒返回非0（此时读写操作函数应返回-ERESTARTSYS）

*/

       

wait_event(wq,condition) //深度睡眠



wake_up_interruptible(wait_queue_head_t *pwq)

       

wake_up(wait_queue_head_t *pwq)

   

   

/*

1. 读、写用不同的等待队列头rq、wq

2. 无数据可读、可写时调用wait_event_interruptible(rq、wq,条件)

3. 写入数据成功时唤醒rq，读出数据成功唤醒wq

*/



```

make

sudo lsmod | grep char

sudo rmmod multimychar

sudo insmod char.ko

cat proc/devices | grep char

 

ll /dev/mydev*

 

gcc -o testread testnonblockread.c

./testread /dev/mydev0
 

 gcc -o testblockread testblockread.c

 echo hello > /dev/mydev0

验证写可以先把buf写满然后用cat取走数据就会停止阻塞 

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

#include "mychar.h"

#define BUF_LEN 100

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

struct mychar_dev
{
	struct cdev mydev;
	char mydev_buf[BUF_LEN];
	int curlen;

	/*Read wait queue and write wait queue*/
	wait_queue_head_t rq;
	wait_queue_head_t wq;
};

struct mychar_dev gmydev;

int mychar_open(struct inode *pnode, struct file *pfile)
{
	pfile->private_data = container_of(pnode->i_cdev, struct mychar_dev, mydev);
	printk("mychar_open\n");
	return 0;
}
int mychar_close(struct inode *pnode, struct file *pfile)
{
	printk("mychar_close\n");
	return 0;
}

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

	if(pmydev->curlen <= 0)
	{
		if(pfile->f_flags & O_NONBLOCK)
		{//non-blocking
			printk("O_NONBLOCK No Data Read\n");
			return -1;
		}
		else
		{//blocking
			wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);
			if(ret)
			{
				printk("Wake up by signal\n");
				return -ERESTARTSYS;
			}
		}
	}

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

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

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

	pmydev->curlen = pmydev->curlen - size;
	
	/*Wake up interrupt*/
	wake_up_interruptible(&pmydev->wq);
	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;
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;

	if(pmydev->curlen >= BUF_LEN)
	{
		if(pfile->f_flags & O_NONBLOCK)
		{
			printk("O_NONBLOCK can not write\n");
			return -1;
		}
		else
		{
			ret = wait_event_interruptible(pmydev->wq,
					pmydev->curlen < BUF_LEN);
			if(ret)
			{
				printk("wake up by signal\n");
				return -ERESTARTSYS;
			}
		}
	}

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

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

	/*Wake up interrupt*/
	wake_up_interruptible(&pmydev->rq);

	return size;
}

long mychar_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg)
{
	int __user *pret = (int *)arg;
	int maxlen = BUF_LEN;
	int ret = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;


	switch(cmd)
	{
		case MYCHAR_IOCTL_GET_MAXLEN:
			ret = copy_to_user(pret, &maxlen, sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		case MYCHAR_IOCTL_GET_CURLEN:
			ret = copy_to_user(pret, &pmydev->curlen, sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		default:
			printk("The cmd is unknow\n");
			return -1;
	}
	return 0;
}

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


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

	/*Apply for device number*/
	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;
		}
		printk("copy_to_user failed\n");
		major = MAJOR(devno);//Easy to miss *****
	}
	/*Assign the 'struct cdev' a set of operation functions*/
	cdev_init(&gmydev.mydev, &myops);
	/*Add 'struct cdev' to the kernel's data structure*/
	gmydev.mydev.owner = THIS_MODULE;
	cdev_add(&gmydev.mydev, devno, mychar_num);//add to Hash.
	
	/*initialize the wait queue header*/
	init_waitqueue_head(&gmydev.rq);
	init_waitqueue_head(&gmydev.wq);

	return 0;
}
void __exit mychar_exit(void)
{
	dev_t devno = MKDEV(major,minor);
	cdev_del(&gmydev.mydev);
	//printk("mychar will exit\n");
	unregister_chrdev_region(devno, mychar_num);
}
MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);


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


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

	if(argc < 2)
	{
		printf("The argument is too few\n");
		return 1;
	}
	fd = open(argv[1], O_RDWR | O_NONBLOCK);
	if(fd < 0)
	{
		printf("open %s failed\n", argv[1]);
		return 2;
	}

	ret = read(fd, buf, 8);
	if(ret < 0)
	{
		printf("read data failed\n");
	}
	printf("buf = %s\n", buf);
	close(fd);
	fd = -1;
	return 0;
}


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


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

	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;
	}

	ret = read(fd, buf, 8);
	if(ret < 0)
	{
		printf("read data failed\n");
	}
	printf("buf = %s\n", buf);
	close(fd);
	fd = -1;
	return 0;
}

三、多路复用

描述符：

1. 文件描述符：设备文件、管道文件

2. socket描述符

3.1 应用层：三套接口select、poll、epoll

select：位运算实现 监控的描述符数量有限（32位机1024,64位机2048） 效率差

poll：链表实现，监控的描述符数量不限  效率差

epoll：效率最高，监控的描述符数量不限

select

```c

int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);

/*  功能：监听多个描述符，阻塞等待有一个或者多个文件描述符，准备就绪。

        内核将没有准备就绪的文件描述符，从集合中清掉了。

    参数：  nfds           最大文件描述符数 ，加1

            readfds     读文件描述符集合

            writefds        写文件描述符集合

            exceptfds       其他异常的文件描述符集合

            timeout     超时时间（NULL）

    返回值：当timeout为NULL时返回0，成功:准备好的文件描述的个数  出错:-1

           当timeout不为NULL时，如超时设置为0，则select为非阻塞，超时设置 > 0，则无描述符可被操作的情况下阻塞指定长度的时间

*/

void FD_CLR(int fd, fd_set *set);

//功能：将fd 从集合中清除掉



int  FD_ISSET(int fd, fd_set *set);

//功能：判断fd 是否存在于集合中



void FD_SET(int fd, fd_set *set);

//功能：将fd 添加到集合中



void FD_ZERO(fd_set *set);

//功能：将集合清零



//使用模型:



while(1)

{

    /*得到最大的描述符maxfd*/

    /*FD_ZERO清空描述符集合*/

    /*将被监控描述符加到相应集合rfds里  FD_SET*/

    /*设置超时*/

    ret = select(maxfd+1,&rfds,&wfds,NULL,NULL);

    if(ret < 0)

    {

        if(errno == EINTR)//错误时信号引起的

        {

            continue;  

        }

        else

        {

            break;

        }

    }

    else if(ret == 0)

    {//超时

        //.....

    }

    else

    { //> 0 ret为可被操作的描述符个数

        if(FD_ISSET(fd1,&rfds))

        {//读数据

            //....

        }

        if(FD_ISSET(fd2,&rfds))

        {//读数据

            //....

        }

        ///.....

        if(FD_ISSET(fd1,&wfds))

        {//写数据

            //....

        }

    }

}

   

```



 

3.2 驱动层：实现poll函数

```c

void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)；

/*功能：将等待队列头添加至poll_table表中

  参数：struct file :设备文件

  Wait_queue_head_t :等待队列头

  Poll_table :poll_table表

*/



/*该函数与select、poll、epoll_wait函数相对应，协助这些多路监控函数判断本设备是否有数据可读写*/

unsigned int xxx_poll(struct file *filp, poll_table *wait) //函数名初始化给struct file_operations的成员.poll

{

    unsigned int mask = 0;

    /*

        1. 将所有等待队列头加入poll_table表中

        2. 判断是否可读，如可读则mask |= POLLIN | POLLRDNORM;

        3. 判断是否可写，如可写则mask |= POLLOUT | POLLWRNORM;

    */

   

    return mask;

}

```

 grep poll_wait ./ -r -n

阻塞在这

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>

#include "mychar.h"

#define BUF_LEN 100

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

struct mychar_dev
{
	struct cdev mydev;
	char mydev_buf[BUF_LEN];
	int curlen;

	/*Read wait queue and write wait queue*/
	wait_queue_head_t rq;
	wait_queue_head_t wq;
};

struct mychar_dev gmydev;

int mychar_open(struct inode *pnode, struct file *pfile)
{
	pfile->private_data = container_of(pnode->i_cdev, struct mychar_dev, mydev);
	printk("mychar_open\n");
	return 0;
}
int mychar_close(struct inode *pnode, struct file *pfile)
{
	printk("mychar_close\n");
	return 0;
}

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

	if(pmydev->curlen <= 0)
	{
		if(pfile->f_flags & O_NONBLOCK)
		{//non-blocking
			printk("O_NONBLOCK No Data Read\n");
			return -1;
		}
		else
		{//blocking
			wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);
			if(ret)
			{
				printk("Wake up by signal\n");
				return -ERESTARTSYS;
			}
		}
	}

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

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

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

	pmydev->curlen = pmydev->curlen - size;
	
	/*Wake up interrupt*/
	wake_up_interruptible(&pmydev->wq);
	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;
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;

	if(pmydev->curlen >= BUF_LEN)
	{
		if(pfile->f_flags & O_NONBLOCK)
		{
			printk("O_NONBLOCK can not write\n");
			return -1;
		}
		else
		{
			ret = wait_event_interruptible(pmydev->wq,
					pmydev->curlen < BUF_LEN);
			if(ret)
			{
				printk("wake up by signal\n");
				return -ERESTARTSYS;
			}
		}
	}

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

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

	/*Wake up interrupt*/
	wake_up_interruptible(&pmydev->rq);

	return size;
}

long mychar_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg)
{
	int __user *pret = (int *)arg;
	int maxlen = BUF_LEN;
	int ret = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;


	switch(cmd)
	{
		case MYCHAR_IOCTL_GET_MAXLEN:
			ret = copy_to_user(pret, &maxlen, sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		case MYCHAR_IOCTL_GET_CURLEN:
			ret = copy_to_user(pret, &pmydev->curlen, sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		default:
			printk("The cmd is unknow\n");
			return -1;
	}
	return 0;
}

unsigned int mychar_poll(struct file *pfile, poll_table *ptb)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
	unsigned int mask = 0;

	/*It not block. Adds the wait queue to the table*/
	poll_wait(pfile,&pmydev->rq,ptb);
	poll_wait(pfile,&pmydev->wq,ptb);

	if(pmydev->curlen > 0)
	{
		mask |= POLLIN | POLLRDNORM;
	}
	if(pmydev->curlen < BUF_LEN)
	{
		mask |= POLLOUT | POLLWRNORM;
	}
	return mask;

}

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


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

	/*Apply for device number*/
	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;
		}
		printk("copy_to_user failed\n");
		major = MAJOR(devno);//Easy to miss *****
	}
	/*Assign the 'struct cdev' a set of operation functions*/
	cdev_init(&gmydev.mydev, &myops);
	/*Add 'struct cdev' to the kernel's data structure*/
	gmydev.mydev.owner = THIS_MODULE;
	cdev_add(&gmydev.mydev, devno, mychar_num);//add to Hash.
	
	/*initialize the wait queue header*/
	init_waitqueue_head(&gmydev.rq);
	init_waitqueue_head(&gmydev.wq);

	return 0;
}
void __exit mychar_exit(void)
{
	dev_t devno = MKDEV(major,minor);
	cdev_del(&gmydev.mydev);
	//printk("mychar will exit\n");
	unregister_chrdev_region(devno, mychar_num);
}
MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);


#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include "mychar.h"
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>

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

	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;
	}

	while(1)
	{
		FD_ZERO(&rfds);
		FD_SET(fd, &rfds);
		ret = select(fd + 1,&rfds,NULL,NULL,NULL);
		if(ret < 0)
		{
			if(errno == EINTR)
			{
				continue;
			}
			else
			{
				printf("select error\n");
				break;
			}
		}
		if(FD_ISSET(fd, &rfds))
		{
			read(fd,buf,8);
			printf("buf = %s\n", buf);
		}
	}

	ret = read(fd, buf, 8);
	if(ret < 0)
	{
		printf("read data failed\n");
	}
	printf("buf = %s\n", buf);
	close(fd);
	fd = -1;
	return 0;
}

四、信号驱动

4.1 应用层：信号注册+fcntl

```c

signal(SIGIO, input_handler); //注册信号处理函数



fcntl(fd, F_SETOWN, getpid());//将描述符设置给对应进程，好由描述符获知PID



oflags = fcntl(fd, F_GETFL);

fcntl(fd, F_SETFL, oflags | FASYNC);//将该设备的IO模式设置成信号驱动模式



void input_handler(int signum)//应用自己实现的信号处理函数，在此函数中完成读写

{

    //读数据

}



//应用模板

int main()

{

    int fd = open("/dev/xxxx",O_RDONLY);



    fcntl(fd, F_SETOWN, getpid());



    oflags = fcntl(fd, F_GETFL);

    fcntl(fd, F_SETFL, oflags | FASYNC);



    signal(SIGIO,xxxx_handler);



    //......

}

   

void xxxx_handle(int signo)

{//读写数据

   

}




```

4.2 驱动层：实现fasync函数

```c

/*设备结构中添加如下成员*/

struct fasync_struct *pasync_obj;



/*应用调用fcntl设置FASYNC时调用该函数产生异步通知结构对象，并将其地址设置到设备结构成员中*/

static int hello_fasync(int fd, struct file *filp, int mode) //函数名初始化给struct file_operations的成员.fasync

{

    struct hello_device *dev = filp->private_data;

    return fasync_helper(fd, filp, mode, &dev->pasync_obj);

}



/*写函数中有数据可读时向应用层发信号*/

if (dev->pasync_obj)

       kill_fasync(&dev->pasync_obj, SIGIO, POLL_IN);

       

/*release函数中释放异步通知结构对象*/

if (dev->pasync_obj)

    fasync_helper(-1, filp, 0, &dev->pasync_obj);



int fasync_helper(int fd, struct file *filp, int mode, struct fasync_struct **pp);

/*

    功能：产生或释放异步通知结构对象

    参数：

    返回值：成功为>=0,失败负数

*/



void kill_fasync(struct fasync_struct **, int, int);

/*  

    功能：发信号

    参数：

        struct fasync_struct ** 指向保存异步通知结构地址的指针

        int     信号 SIGIO/SIGKILL/SIGCHLD/SIGCONT/SIGSTOP

        int     读写信息POLLIN、POLLOUT

*/

```

 

 写数据，信号处理函数会打印出来

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>

#include "mychar.h"

#define BUF_LEN 100

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

struct mychar_dev
{
	struct cdev mydev;
	char mydev_buf[BUF_LEN];
	int curlen;

	/*Read wait queue and write wait queue*/
	wait_queue_head_t rq;
	wait_queue_head_t wq;

	struct fasync_struct *pasync_obj;
};

struct mychar_dev gmydev;

int mychar_open(struct inode *pnode, struct file *pfile)
{
	pfile->private_data = container_of(pnode->i_cdev, struct mychar_dev, mydev);
	printk("mychar_open\n");
	return 0;
}
int mychar_close(struct inode *pnode, struct file *pfile)
{
	//printk("mychar_close\n");
	/*C90 requires printk after the variable declaration*/
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;

	if(pmydev->pasync_obj != NULL)
		fasync_helper(-1,pfile,0, &pmydev->pasync_obj);
	return 0;
}

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

	if(pmydev->curlen <= 0)
	{
		if(pfile->f_flags & O_NONBLOCK)
		{//non-blocking
			printk("O_NONBLOCK No Data Read\n");
			return -1;
		}
		else
		{//blocking
			wait_event_interruptible(pmydev->rq,pmydev->curlen > 0);
			if(ret)
			{
				printk("Wake up by signal\n");
				return -ERESTARTSYS;
			}
		}
	}

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

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

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

	pmydev->curlen = pmydev->curlen - size;
	
	/*Wake up interrupt*/
	wake_up_interruptible(&pmydev->wq);
	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;
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;

	if(pmydev->curlen >= BUF_LEN)
	{
		if(pfile->f_flags & O_NONBLOCK)
		{
			printk("O_NONBLOCK can not write\n");
			return -1;
		}
		else
		{
			ret = wait_event_interruptible(pmydev->wq,
					pmydev->curlen < BUF_LEN);
			if(ret)
			{
				printk("wake up by signal\n");
				return -ERESTARTSYS;
			}
		}
	}

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

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

	/*Wake up interrupt*/
	wake_up_interruptible(&pmydev->rq);

	if(pmydev->pasync_obj != NULL)
	{
		kill_fasync(&pmydev->pasync_obj, SIGIO, POLL_IN);
	}
	return size;
}

long mychar_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg)
{
	int __user *pret = (int *)arg;
	int maxlen = BUF_LEN;
	int ret = 0;
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;


	switch(cmd)
	{
		case MYCHAR_IOCTL_GET_MAXLEN:
			ret = copy_to_user(pret, &maxlen, sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		case MYCHAR_IOCTL_GET_CURLEN:
			ret = copy_to_user(pret, &pmydev->curlen, sizeof(int));
			if(ret)
			{
				printk("copy_to_user MAXLEN failed\n");
				return -1;
			}
			break;
		default:
			printk("The cmd is unknow\n");
			return -1;
	}
	return 0;
}

unsigned int mychar_poll(struct file *pfile, poll_table *ptb)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;
	unsigned int mask = 0;

	/*It not block. Adds the wait queue to the table*/
	poll_wait(pfile,&pmydev->rq,ptb);
	poll_wait(pfile,&pmydev->wq,ptb);

	if(pmydev->curlen > 0)
	{
		mask |= POLLIN | POLLRDNORM;
	}
	if(pmydev->curlen < BUF_LEN)
	{
		mask |= POLLOUT | POLLWRNORM;
	}
	return mask;

}

int mychar_fasync(int fd,struct file *pfile, int mode)
{
	struct mychar_dev *pmydev = (struct mychar_dev *)pfile->private_data;

	return fasync_helper(fd, pfile, mode, &pmydev->pasync_obj);
}
struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = mychar_open,
	.release = mychar_close,
	.read = mychar_read,
	.write = mychar_write,
	.unlocked_ioctl = mychar_ioctl,
	.poll = mychar_poll,
	.fasync = mychar_fasync,
};


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

	/*Apply for device number*/
	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;
		}
		printk("copy_to_user failed\n");
		major = MAJOR(devno);//Easy to miss *****
	}
	/*Assign the 'struct cdev' a set of operation functions*/
	cdev_init(&gmydev.mydev, &myops);
	/*Add 'struct cdev' to the kernel's data structure*/
	gmydev.mydev.owner = THIS_MODULE;
	cdev_add(&gmydev.mydev, devno, mychar_num);//add to Hash.
	
	/*initialize the wait queue header*/
	init_waitqueue_head(&gmydev.rq);
	init_waitqueue_head(&gmydev.wq);

	return 0;
}
void __exit mychar_exit(void)
{
	dev_t devno = MKDEV(major,minor);
	cdev_del(&gmydev.mydev);
	//printk("mychar will exit\n");
	unregister_chrdev_region(devno, mychar_num);
}
MODULE_LICENSE("GPL");

module_init(mychar_init);
module_exit(mychar_exit);

 

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include "mychar.h"
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/time.h>
#include <errno.h>
#include <signal.h>

int fd = -1;

void sigio_handler(int signo);

int main(int argc, char *argv[])
{
	
	int ret = 0;
	int flg = 0;

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

	signal(SIGIO, sigio_handler);

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

	fcntl(fd, F_SETOWN, getpid());
	flg = fcntl(fd, F_GETFL);
	flg |= FASYNC;
	fcntl(fd, F_SETFL, flg);
	while(1)
	{
	
	}

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

void sigio_handler(int signo)
{
	char buf[8] = "";
	read(fd, buf, 8);
	printf("buf = %s\n", buf);
}


---------------------------------------------------------------------------------------------------------------------------------好久没写小作文了，

有人说人生有三个境界：
第一层见自己，说的是格局；第二层见天地，说的是眼界；第三层见众生，讲的是良心。

格局大了，才有机会突破自己的圈子，成为更好的自己；

眼界宽了，才能看到更大的天地，公司才会越做越大；

良心有了，就想着去兼济天下，这才是一个伟大企业家该有的责任和使命。

活成自己的样式才是我的人生。不过这碗汤不错先干为敬。最近这驱动学的头都秃了。

人生三大错觉她喜欢我。舔了好久。突然有一天就惊醒了。还是活自己吧。不要在不可能的地方停留太久。那样只会降低你的价值。然后每天幽怨的像个怨妇。20多岁的大好年纪还是先提升自己吧。与看到此篇文章的诸君共勉。为了吸引流量的场面话的就免了。我回都回累了。你们是来学习的还是来吸引粉丝的。虽然有人关注有人喜欢的感觉很好。但是不要本末倒置。我也很喜欢这种感觉。但是现阶段还是先学技术。等我实现理想就去写书。疯狂给热血青年灌鸡汤哈哈。
---------------------------------------------------------------------------------------------------------------------------------

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/356828.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

CSAPP学习笔记——虚拟内存（二）

CSAPP学习笔记——虚拟内存（二）

案例研究 Intel Core i7 该处理底层的Haswell微体系结构允许64位的虚拟和物理地址空间&#xff0c;而现在的Core i7实现支持48位&#xff08;256TB&#xff09;虚拟地址空间和52位&#xff08;4PB&#xff09;物理地址空间&#xff0c;这对目前来说已经完全够用了。&#xff…
阅读更多...
Liunx(狂神课堂笔记)

Liunx(狂神课堂笔记)

一.常用命令 1. cd 切换目录 cd ./* 当前目录cd /* 绝对路径cd .. 返回上一级目录cd ~ 回到当前目录pwd …
阅读更多...
定点数的表示和运算

定点数的表示和运算

文章目录真值&#xff08;有正负号&#xff09;和机器数&#xff08;0正1负&#xff09;原码整数小数补码负数的补数正数的补数[y]~补~ > [-y]~补~反码小结移码移位运算加减法运算溢出判断真值&#xff08;有正负号&#xff09;和机器数&#xff08;0正1负&#xff09; 无符…
阅读更多...
链表OJ（六）链表相加(一) 链表相加(二)

链表OJ（六）链表相加(一) 链表相加(二)

目录 链表相加(一) 链表相加(二) 描述 二与一相比多了俩次反转而已 链表相加(一) 描述 给定两个非空链表逆序存储的的非负整数&#xff0c;每个节点只存储一位数组。 请你把两个链表相加以下相同方法返回链表&#xff0c;保证两个数都不会以 0 开头。 【我的解法】长到…
阅读更多...
实例五：MATLAB APP design-APP登录界面的设计

实例五：MATLAB APP design-APP登录界面的设计

一、APP 界面设计展示 注：在账号和密码提示框输入相应的账号和密码后，点击登录按钮，即可跳转到程序中设计的工作界面。 二、APP设计界面运行结果展示
阅读更多...
使用继承的虚函数表

使用继承的虚函数表

​ 代码 #include <iostream> using namespace std;class Father { public:virtual void func1() { cout << "Father::func1" << endl; }virtual void func2() { cout << "Father::func2" << endl; }virtual void func3()…
阅读更多...
一文彻底理解大小端和位域 BIGENDIAN LITTLEENDIAN

一文彻底理解大小端和位域 BIGENDIAN LITTLEENDIAN

一文彻底理解大小端和位域 为什么有大小端 人们一直认为大道至简&#xff0c;就好像物理学上的世界追求使用一个理论来统一所有的现象。为什么cpu存在大小端之分&#xff0c;一言以蔽之&#xff0c;这两种模式各有各的优点&#xff0c;其各自的优点就是对方的缺点&#xff0c…
阅读更多...
【C++学习】list的使用及模拟实现

【C++学习】list的使用及模拟实现

&#x1f431;作者&#xff1a;一只大喵咪1201 &#x1f431;专栏&#xff1a;《C学习》 &#x1f525;格言&#xff1a;你只管努力&#xff0c;剩下的交给时间&#xff01; list的使用及模拟实现&#x1f63c;构造函数&#x1f435;模拟实现&#x1f63c;迭代器&#x1f435;…
阅读更多...
[软件工程导论(第六版)]第6章 详细设计（复习笔记）

[软件工程导论(第六版)]第6章 详细设计（复习笔记）

文章目录6.1 结构程序设计6.2 人机界面设计6.3 过程设计的工具6.3.1 程序流程图&#xff08;程序框图&#xff09;6.3.2 盒图&#xff08;N-S图&#xff09;6.3.3 PAD图&#xff08;问题分析图&#xff09;6.3.4 判定表6.3.5 判断树6.3.6 过程设计语言6.4 面向数据结构的设计方…
阅读更多...
Spring Cloud Nacos实战（二）- 服务提供者注册

Spring Cloud Nacos实战（二）- 服务提供者注册

Nacos服务提供者注册 Nacos代替Eureka ​ Nacos可以直接提供注册中心&#xff08;Eureka&#xff09;配置中心&#xff08;Config&#xff09;&#xff0c;所以它的好处显而易见&#xff0c;我们在上节课成功安装和启动了Nacos以后就可以发现Nacos本身就是一个小平台&#xf…
阅读更多...
解决IDEA报错：无效的目标发行版: 17

解决IDEA报错：无效的目标发行版: 17

解决IDEA报错&#xff1a;无效的目标发行版: 17 目录解决IDEA报错&#xff1a;无效的目标发行版: 17报错由来解决报错【1】检查setting设置&#xff0c;查看编译器编译模块的编译版本是否是你需要的【2】尝试去修改当前项目的启动设置&#xff0c;设置JRE为你需要的版本。【3】…
阅读更多...
odoo如何完成员工借款、报销、归还余款的会计操作？【业财一体】

odoo如何完成员工借款、报销、归还余款的会计操作？【业财一体】

ODOO中如何实现财务场景&#xff1a;一个员工从公司借款1000元&#xff0c;然后用这个借款&#xff0c;支付了电费500元&#xff0c;然后又归还剩余500元呢&#xff1f; 一、基本流程如下&#xff1a; 二、基础科目的设置 1.1 预付账款科目&#xff1a;设置在 产品【Employee…
阅读更多...
DQL 多表查询

DQL 多表查询

1、多表关系 一对多&#xff08;多对一&#xff09; 案例: 部门 与 员工的关系 关系: 一个部门对应多个员工&#xff0c;一个员工对应一个部门 实现: 在从表的一方建立外键&#xff0c;指向主表一方的主键 多对多 案例: 学生 与 课程的关系 关系: 一个学生可以选修多门课程&am…
阅读更多...
Revisiting Distributed Synchronous SGD 带有Back-up机制的分布式同步SGD方法 论文精读

Revisiting Distributed Synchronous SGD 带有Back-up机制的分布式同步SGD方法 论文精读

论文链接&#xff1a;Revisiting Distributed Synchronous SGD ABS 本文介绍了用于分布式机器学习的同步和异步SGDSGDSGD&#xff0c;同时指出各自的缺点&#xff1a;stragglersstragglersstragglers和stalenessstalenessstaleness。 同时为了解决同步SGDSGDSGD存在straggle…
阅读更多...
【go语言grpc之client端源码分析二】

【go语言grpc之client端源码分析二】

go语言grpc之server端源码分析二DialContextparseTargetAndFindResolvergetResolvernewCCResolverWrapperccResolverWrapper.UpdateStatecc.maybeApplyDefaultServiceConfigccBalancerWrapper.updateClientConnState上一篇文章分析了ClientConn的主要结构体成员&#xff0c;然后…
阅读更多...
扫雷小游戏 - C语言

扫雷小游戏 - C语言

目录 一、扫雷游戏 1.游戏一共创建使用了三个文件 2.test.c 文件代码&#xff08;游戏逻辑&#xff09; 3.game.h - 必要的函数声明代码 4.game.c 游戏所有函数实现代码 一、扫雷游戏 1.游戏一共创建使用了三个文件 test.c - 测试游戏逻辑 game.h - 游戏代码包含的函数…
阅读更多...
低频量化之指数 PE-PB-偏离 数据

低频量化之指数 PE-PB-偏离 数据

目录历史文章股票明日涨停预测指数PEPB分位指数PE分位指数PB分位行业指数PEPB分位行业指数PE分位行业指数PB分位指数60日线偏离数据指数MA60偏离统计上证指数 MA60偏离度深证成指 MA60偏离度创业板指 MA60偏离度中小100 MA60偏离度上证50 MA60偏离度沪深300 MA60偏离度中证500 …
阅读更多...
代码随想录算法训练营第45天动态规划 背包基础 1 2、 416. 分割等和子集

代码随想录算法训练营第45天动态规划 背包基础 1 2、 416. 分割等和子集

文章目录01背包基础 &#xff08;二维数组&#xff09;思路递推公式初始化遍历顺序一维dp数组&#xff08;滚动数组&#xff09;一维数组的递推公式遍历顺序LeetCode 416. 分割等和子集思路总结01背包基础 &#xff08;二维数组&#xff09; 思路 根据动态规划五部进行分析&a…
阅读更多...
Vulnhub 渗透练习（八）—— THE ETHER: EVILSCIENCE

Vulnhub 渗透练习（八）—— THE ETHER: EVILSCIENCE

环境搭建 环境下载 靶机和攻击机网络适配都选 NAT 即可。 信息收集 主机扫描 两个端口&#xff0c;22 和 80&#xff0c;且 apache httpd 2.4.0~2.4.29 存在换行解析漏洞。 Apache HTTPD是一款HTTP服务器&#xff0c;它可以通过mod_php来运行PHP网页。其2.4.0~2.4.29版本中…
阅读更多...
跨域问题的三种解决办法

跨域问题的三种解决办法

我们平时对于前后端联调的项目&#xff0c;以下的错误是经常常见的&#xff0c;我们查看浏览器报错&#xff1a; Access to XMLHttpRequest at http://localhost:63110/system/dictionary/all fromorigin http://localhost:8601 has been blocked by CORS policy: No Access…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023