网站运维推广怎么做/计算机编程培训学校哪家好
目录
一、五种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时间片开始时取出队列中的头节点去运行一个时间片然后插入到队尾
睡眠态怎么实现呢,再搞一个队列叫等待队列。把一个任务放到等待队列就处于睡眠态了。把任务从等待队列放到就绪队列就会继续参与时间片轮转。
睡眠分两种,资源就位了,满足的条件成立了才会醒来的叫深度睡眠,除了这俩情况接收到信号也会醒来的叫浅睡眠)
驱动层:通过等待队列
严格来说下面这俩不是函数而是带参的宏
```cwait_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、wq2. 无数据可读、可写时调用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 100int 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-blockingprintk("O_NONBLOCK No Data Read\n");return -1;}else{//blockingwait_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
```cint select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);/* 功能:监听多个描述符,阻塞等待有一个或者多个文件描述符,准备就绪。内核将没有准备就绪的文件描述符,从集合中清掉了。参数: nfds 最大文件描述符数 ,加1readfds 读文件描述符集合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函数
```cvoid 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 100int 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-blockingprintk("O_NONBLOCK No Data Read\n");return -1;}else{//blockingwait_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
```csignal(SIGIO, input_handler); //注册信号处理函数fcntl(fd, F_SETOWN, getpid());//将描述符设置给对应进程,好由描述符获知PIDoflags = 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/SIGSTOPint 读写信息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 100int 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-blockingprintk("O_NONBLOCK No Data Read\n");return -1;}else{//blockingwait_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多岁的大好年纪还是先提升自己吧。与看到此篇文章的诸君共勉。为了吸引流量的场面话的就免了。我回都回累了。你们是来学习的还是来吸引粉丝的。虽然有人关注有人喜欢的感觉很好。但是不要本末倒置。我也很喜欢这种感觉。但是现阶段还是先学技术。等我实现理想就去写书。疯狂给热血青年灌鸡汤哈哈。
---------------------------------------------------------------------------------------------------------------------------------
相关文章:

字符设备驱动基础(二)
目录 一、五种IO模型------读写外设数据的方式 二、阻塞与非阻塞 三、多路复用 3.1 应用层:三套接口select、poll、epoll 3.2 驱动层:实现poll函数 四、信号驱动 4.1 应用层:信号注册fcntl 4.2 驱动层:实现fasync函数 一、…...

看见统计——第三章 概率分布
看见统计——第三章 概率分布 参考 https://github.com/seeingtheory/Seeing-Theory中心极限定理 概率分布描述了随机变量取值的规律。 随机变量Random Variables 🔥 定义:将样本空间中的结果映射到实数的函数 XXX 称为随机变量(random variable)&a…...

【基于众包标注的语文教材句子难易度评估研究 论文精读】
基于众包标注的语文教材句子难易度评估研究 论文精读信息摘 要0 引言1 相关研究2 众包标注方法3 语料库构建3.1 数据收集3.1 基于五点量表的专家标注3.3 基于成对比较的众包标注4 特征及模型4.1 特征抽取4.2 模型与实验设计4.2.1 任务一:单句绝对难度评估4.2.2 任务二:句对相对…...

实例五:MATLAB APP design-APP登录界面的设计
一、APP 界面设计展示 注:在账号和密码提示框输入相应的账号和密码后,点击登录按钮,即可跳转到程序中设计的工作界面。 二、APP设计界面运行结果展示...

作用域和闭包:
1、LHS和RHS查询编译一段代码,需要js引擎和编译器(js引擎负责整个程序运行时所需的各种资源的调度,编译器只是js引擎的一部分,负责将JavaScript源码编译成机器能识别的机器指令,然后交给引擎运行)编译的过程…...

Vue常见面试题?
1、说说你对SPA单页面的理解,它的优缺点是什么? SPA(single-page application)仅在Web页面初始化时加载相应的HTML、JavaScript和CSS。一旦页面加载完成,SPA不会因为用户的操作而进行页面的重新加载或跳转;取而代之的是利用路由机…...

前端借助Canvas实现压缩图片两种方法
一、具体代码 1、利用canvas压缩图片方法一 // 第一种压缩图片方法(图片base64,图片类型,压缩比例,回调函数)// 图片类型是指 image/png、image/jpeg、image/webp(仅Chrome支持)// 该方法对以上三种图片类型都适用 压缩结果的图片base64与原类型相同// …...

2023年美赛C题Wordle预测问题二建模及Python代码详细讲解
更新时间:2023-2-19 相关链接 (1)2023年美赛C题Wordle预测问题一建模及Python代码详细讲解 (2)2023年美赛C题Wordle预测问题二建模及Python代码详细讲解 (3)2023年美赛C题Wordle预测问题三、四…...

【算法】双指针
作者:指针不指南吗 专栏:算法篇 🐾或许会很慢,但是不可以停下来🐾 文章目录1.双指针分类2.双指针思想3.双指针应用1.双指针分类 常见问题分类 (1) 对于一个序列,用两个指针维护一段区间, 比如快速排序。 …...

Flutter-Widget-学习笔记
Widget 是整个视图描述的基础。 参考:https://docs.flutter.dev/resources/architectural-overview Widget 到底是什么呢? Widget 是 Flutter 功能的抽象描述,是视图的配置信息,同样也是数据的映射,是 Flutter 开发框…...

easyExcel 写复杂表头
写模板 模板图片: 实体类(这里没有用Data 是因为Lombok和easyExcal的版本冲突,在导入读取的时候获取不到值) package cn.iocoder.yudao.module.project.controller.admin.goods.vo;import com.alibaba.excel.annotation.ExcelI…...

关于线程池的执行流程和拒绝策略
使用线程池的好处为: 降低资源消耗:减少线程的创建和销毁带来的性能开销。 提高响应速度:当任务来时可以直接使用,不用等待线程创建 可管理性: 进行统一的分配,监控,避免大量的线程间因互相抢…...

【李忍考研传】二、约定
因为收学生证用了好些时间,李忍把学生证都交给班长后,就赶忙跑去食堂。远远地,他就看到那个瘦小的身影立在食堂正门前,那是他们约定每天午餐集合的地方。 “你咋这么慢啊……” “害!帮班长收东西耽误了点时间&#…...

2023-2-19 刷题情况
修改两个元素的最小分数 题目描述 给你一个下标从 0 开始的整数数组 nums 。 nums 的 最小 得分是满足 0 < i < j < nums.length 的 |nums[i] - nums[j]| 的最小值。nums的 最大 得分是满足 0 < i < j < nums.length 的 |nums[i] - nums[j]| 的最大值。nu…...

LeetCode笔记:Weekly Contest 333
LeetCode笔记:Weekly Contest 333 1. 题目一 1. 解题思路2. 代码实现 2. 题目二 1. 解题思路2. 代码实现 3. 题目三 1. 解题思路2. 代码实现 4. 题目四 比赛链接:https://leetcode.com/contest/weekly-contest-333 1. 题目一 给出题目一的试题链接如下…...

元数据管理 1
1、关于元数据管理原则说法正确的是 (知识点: 三月份模拟题)A.确保员工了解如何访问和使用元数据。B.制定、实施和审核元数据标准,以简化元数据的集成和使用。C.创建反馈机制,以便数据使用者可以将错误或过时的元数据反馈给元数据管理团队。D.以上都对正…...

统计二进制中比特1的个数
快速统计比特1的数量int CountBitOnes(int32_t n) {int result 0;for(;n;result) {n & n-1;}return result; }原理很简单,n-1会将n中最靠近结尾的1减一,这样n&n-1,n中最靠近结尾的1就变成了0;假设n 0b xxxxxxxx100n - 1…...

第三方实现跑马灯和手写实现跑马灯
目录第三方实现跑马灯手写实现跑马灯手写实现跑马灯【整体代码】自己细心研究一下上述代码第三方实现跑马灯 https://vue3-marquee.vercel.app/guide.html#changes-from-v2https://evodiaaut.github.io/vue-marquee-text-component/ 手写实现跑马灯 CSS部分 <style>.m…...

React Native Cannot run program “node“问题
概述 前几天mac重装系统了,用Android studio重新构建React native项目时,报Cannot run program "node"错误。 电脑系统为macOS 12.6.3 (Monterey),M1 Pro芯片。设备信息如下图所示: 完整错误信息如下图所示ÿ…...

python基于vue微信小程序 房屋租赁出租系统
目录 1 绪论 1 1.1课题背景 1 1.2课题研究现状 1 1.3初步设计方法与实施方案 2 1.4本文研究内容 2 2 系统开发环境 4 2.1 2.2MyEclipse环境配置 4 2.3 B/S结构简介 4 2.4MySQL数据库 5 2. 3 系统分析 6 3.1系统可行性分析 6 3.1.1经济可行性 6 3.1.2技术可行性 6 3.1.3运行可行…...

ThreadPoolExecutor管理异步线程笔记
为什么使用线程池? 线程的创建和销毁都需要不小的系统开销,不加以控制管理容易发生OOM错误。避免线程并发抢占系统资源导致系统阻塞。具备一定的线程管理能力(数量、存活时间,任务管理) new ThreadPoolExecutor(int …...

MotoSimEG-VRC教程:动态输送带创建以及示教编程与仿真运行
目录 任务描述 简易输送带外部设备创建 输送带模型添加与配置 工件安装到输送带 输送带输送工件程序编写与仿真运行 任务描述 在MotoSimEG-VRC中创建1条输送带,并且能够实现将工件从输送带起始点位置处输送到结束点位置处。 简易输送带外部设备创建 在MotoS…...

PyTorch 并行训练 DistributedDataParallel完整代码示例
使用大型数据集训练大型深度神经网络 (DNN) 的问题是深度学习领域的主要挑战。 随着 DNN 和数据集规模的增加,训练这些模型的计算和内存需求也会增加。 这使得在计算资源有限的单台机器上训练这些模型变得困难甚至不可能。 使用大型数据集训练大型 DNN 的一些主要挑…...

Golang实现ttl机制保存内存数据
ttl(time-to-live) 数据存活时间,我们这里指数据在内存中保存一段时间,超过期限则不能被读取到,与Redis的ttl机制类似。本文仅实现ttl部分,不考虑序列化和反序列化。 获取当前时间 涉及时间计算,这里首先介绍如何获取…...

js中数字运算结果与预期不一致的问题和解决方案
本文主要是和大家聊聊关于js中经常出现数字运算结果与预期结果不一致的问题,与及解决该问题的的方案。 一、问题现象 如:0.1 0.2的预期结果是0.3,但是在js中得到的计算结果却是0.30000000000000004,如下图所示 如:0…...

C++ Primer Plus 学习笔记(一)——基本类型
字节与字符 计算机内存的基本单位是位(bit),字节(byte)通常指的是8位的内存单元,从这个意义上来说,字节指的就是描述计算机内存量的度量单位。 C对字节的定义则有些不同,C字节由至…...

ChatGpt与Google 谁能给出最好的回答
ChatGPT由于其先进的会话和技术功能而越来越受欢迎。你可以问聊天机器人任何你想问的问题,它会在几秒钟内输出答案。虽然它不是一个搜索引擎,你应该使用ChatGPT作为你的信息来源而不是谷歌,百度吗? 我们来根据国外的一场测试来看一下 ChatG…...

【Redis】一、CentOS64 安装 Redis
1.下载redis https://download.redis.io/releases/2.将 redis 安装包拷贝到 /opt/ 目录 最好自己创建一个文件夹 3.解压 tar -zvxf redis-6.2.1.tar.gz4. 安装gcc yum install gcc5. 进入目录 cd /opt/redis/redis-6.2.1/6. 编译 make7.执行 make install 进行安装 8. …...

Redis底层原理(持久化+分布式锁)
Redis底层原理 持久化 Redis虽然是个内存数据库,但是Redis支持RDB和AOF (Redis Database Backup file(Redis数据备份文件),也被叫做Redis数据快照。简单来说就是把内存中的所有数据都记录到磁盘中 ;Appen…...

Spring Cloud Nacos实战(八) - Nacos集群配置
Nacos集群配置 更改Nacos启动命令配置原理 我们现在知道,想要启动Naocs只需要启动startup.sh命令即可,但是如果启动3个Nacos那?所以如果我们需要启动多个Nacos,其实Nacos本身默认启动就是集群模式。 注意点:如果是l…...