请选择 进入手机版 | 继续访问电脑版
查看: 821|回复: 0

[分享] 【经验分享】i.MX6ULL开发:驱动开发10——阻塞&非阻塞式按...

[复制链接]
  • TA的每日心情
    开心
    2020-12-18 12:56
  • 签到天数: 55 天

    [LV.5]常住居民I

    79

    主题

    229

    帖子

    0

    管理员

    Rank: 9Rank: 9Rank: 9

    积分
    1702
    最后登录
    2024-5-28
    发表于 2022-8-25 16:54:58 | 显示全部楼层 |阅读模式
    上篇文章:介绍了linux中的五种I/O模型,本篇,就来使用阻塞式I/O和非用阻塞式I/O两种方式进行按键的读取实验,并对比之前使用输入捕获和中断法检测的按键程序,查看CPU的使用率是否降低。

    1 阻塞I/O方式的按键检测1.1 阻塞I/O之等待队列
    阻塞访问最大的好处就是当设备文件不可操作的时候进程可以进入休眠态,这样可以将CPU资源让出来。但是,当设备文件可以操作的时候就必须唤醒进程,一般在中断函数里面完成唤醒工作。Linux 内核提供了等待队列(wait queue)来实现阻塞进程的唤醒工作。
    等待队列头使用结构体wait_queue_head_t 表示:
    1. <font face="Arial">struct __wait_queue_head {
    2. spinlock_t       lock;
    3. struct list_head task_list;
    4. };

    5. typedef struct __wait_queue_head wait_queue_head_t;</font>
    复制代码
    使用 init_waitqueue_head 函数初始化等待队列头:
    1. <font face="Arial">/**
    2. * q: 要初始化的等待队列头
    3. * return: 无
    4. */
    5. void init_waitqueue_head(wait_queue_head_t *q)</font>
    复制代码
    当设备不可用的时, 将这些进程对应的等待队列项(wait_queue_t )添加到等待队列里面:
    1. <font face="Arial">struct __wait_queue {
    2. unsigned int      flags;
    3.    void              *private;
    4.    wait_queue_func_t func;
    5.    struct list_head  task_list;
    6. };

    7. typedef struct __wait_queue wait_queue_t;</font>
    复制代码
    使用宏 DECLARE_WAITQUEUE 定义并初始化一个等待队列项:
    DECLARE_WAITQUEUE(name, tsk)
    当设备不可访问的时候就需要将进程对应的等待队列项添加到前面创建的等待队列头中:
    1. <font face="Arial">/**
    2. * q: 要加入的等待队列头
    3. * wait:要加入的等待队列项
    4. * return: 无
    5. */
    6. void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)</font>
    复制代码
    当设备可以访问以后再将进程对应的等待队列项从等待队列头中删除即可:
    1. <font face="Arial">/**
    2. * q: 要删除的等待队列头
    3. * wait:要删除的等待队列项
    4. * return: 无
    5. */
    6. void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)</font>
    复制代码
    当设备可以使用的时候就要唤醒进入休眠态的进程:
    1. <font face="Arial">void wake_up(wait_queue_head_t *q)
    2. void wake_up_interruptible(wait_queue_head_t *q)</font>
    复制代码
    1.2  阻塞I/O程序编写
    这里仅介绍与之前按键程序的主要区别。
    1.2.1驱动程序
    阻塞读取逻辑如下,首先要定义一个等待队列,当按键没有按下时,就要阻塞等待了(将等待队列添加到等待队列头),然后进行行一次任务切换,交出CPU的使用权。等待有按键按下时,会有信号唤醒该等待,并将按键值返回给应用层的程序。
    1. <font face="Arial">static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
    2. {
    3.    int ret = 0;
    4.    unsigned char keyvalue = 0;
    5.    unsigned char releasekey = 0;
    6.    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;

    7.    /* 定义一个等待队列 <-------------------------- */
    8.    DECLARE_WAITQUEUE(wait, current);

    9.    /* 没有按键按下 <------------------------------ */
    10.    if(atomic_read(&dev->releasekey) == 0)
    11.    {
    12.        /* 将等待队列添加到等待队列头 <------------ */
    13.        add_wait_queue(&dev->r_wait, &wait);

    14.        /* 设置任务状态 <-------------------------- */
    15.        __set_current_state(TASK_INTERRUPTIBLE);

    16.        /* 进行一次任务切换 <---------------------- */
    17.        schedule();

    18.        /* 判断是否为信号引起的唤醒 <-------------- */
    19.        if(signal_pending(current))
    20.        {
    21.            ret = -ERESTARTSYS;
    22.            goto wait_error;
    23.        }

    24.        /* 将当前任务设置为运行状态 <-------------- */
    25.        __set_current_state(TASK_RUNNING);

    26.        /* 将对应的队列项从等待队列头删除 <-------- */
    27.        remove_wait_queue(&dev->r_wait, &wait);
    28.    }

    29.    keyvalue = atomic_read(&dev->keyvalue);
    30.    releasekey = atomic_read(&dev->releasekey);

    31.    /* 有按键按下 */
    32.    if (releasekey)
    33.    {
    34.        //printk("releasekey!\r\n");
    35.        if (keyvalue & 0x80)
    36.        {
    37.            keyvalue &= ~0x80;
    38.            ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));
    39.        }
    40.        else
    41.        {
    42.            goto data_error;
    43.        }
    44.        atomic_set(&dev->releasekey, 0); /* 按下标志清零 */
    45.    }
    46.    else
    47.    {
    48.        goto data_error;
    49.    }
    50.    return 0;

    51. wait_error:
    52.    set_current_state(TASK_RUNNING);           /* 设置任务为运行态 */
    53.    remove_wait_queue(&dev->r_wait, &wait);    /* 将等待队列移除 */
    54.    return ret;

    55. data_error:
    56.    return -EINVAL;
    57. }</font>
    复制代码
    按键的定时器去抖逻辑中的,读取到按键后,触发唤醒,这里以其中的一个按键为例,其逻辑如下:
    1. <font face="Arial">void timer1_function(unsigned long arg)
    2. {
    3.    unsigned char value;
    4.    struct irq_keydesc *keydesc;
    5.    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;

    6.    keydesc = &dev->irqkeydesc[0];

    7.    value = gpio_get_value(keydesc->gpio); /* 读取IO值 */
    8.    if(value == 1) /* 按下按键 */
    9.    {
    10.        printk("get key1: high\r\n");
    11.        atomic_set(&dev->keyvalue, keydesc->value);
    12.    }
    13.    else /* 按键松开 */
    14.    {
    15.        printk("key1 release\r\n");
    16.        atomic_set(&dev->keyvalue, 0x80 | keydesc->value);
    17.        atomic_set(&dev->releasekey, 1); /* 标记松开按键,即完成一次完整的按键过程 */
    18.    }

    19.    /* 唤醒进程 */
    20.    if(atomic_read(&dev->releasekey))
    21.    {
    22.        wake_up_interruptible(&dev->r_wait);
    23.    }
    24. }</font>
    复制代码
    1.2.2 应用程序
    应用程序不需要修改,还使用之前的轮询读取的方式,为了在测试时看出阻塞与非阻塞方式的区别,在read函数前后添加打印,如果程序运行正常,会先打印read前一句的打印,直到有按键按下后,read函数才被接触阻塞,read后一句的打印才会打印出。
    1. <font face="Arial">/* 循环读取按键值数据! */
    2. while(1)
    3. {
    4.    printf("[APP] read begin...\r\n");
    5.    read(fd, &keyvalue, sizeof(keyvalue));
    6.    printf("[APP] read end\r\n");
    7.    if (keyvalue == KEY1VALUE)
    8.    {
    9.        printf("[APP] KEY1 Press, value = %#X\r\n", keyvalue);
    10.    }
    11.    else if (keyvalue == KEY2VALUE)
    12.    {
    13.        printf("[APP] KEY2 Press, value = %#X\r\n", keyvalue);
    14.    }
    15. }</font>
    复制代码
    1.2 实验
    和之前一样,使用Makefile编译驱动程序和应用程序,并复制到nfs根文件系统中。
    开始测试,按如下图,当没有按键按下时,应用程序被阻塞:
    图片 7.png
    按键程序在后台运行,此时使用top指令开查看CPU的使用率,可以发现阻塞式按键驱动这种方式,CPU的暂用率几乎为0,虽然按键应用程序中仍实现循环读取的方式,但因平时读取不到按键值,按键应用程序被阻塞住了,CPU的使用权被让出,自然CPU的使用率就降下来了。
    图片 8.png
    2 非阻塞I/O方式的按键检测
    按键应用程序以非阻塞的方式读取,按键驱动程序也要以非阻塞的方式立即返回。应用程序可以通过select、poll或epoll函数来 查询设备是否可以操作,驱动程序使用poll函数。
    2.1 非阻塞I/O之select/poll
    • select函数原型:

    1. <font face="Arial">/**
    2. * nfs: 所要监视的这三类文件描述集合中,最大文件描述符加1
    3. * readfds: 用于监视指定描述符集的读变化
    4. * writefds: 用于监视文件是否可以进行写操作
    5. * exceptfds: 用于监视文件的异常
    6. * timeout: 超时时间
    7. * return: 0 超时发生, -1 发生错误, 其他值 可以进行操作的文件描述符个数
    8. */
    9. int select(int    nfds,
    10.           fd_set *readfds,
    11.           fd_set *writefds,
    12.           fd_set *exceptfds,
    13.           struct timeval *timeout)</font>
    复制代码
    其中超时时间使用结构体timeval表示:
    1. <font face="Arial">struct timeval {
    2.   long tv_sec;  /* 秒   */
    3.   long tv_usec; /* 微妙 */
    4. };</font>
    复制代码
    当timeout为NULL的时候就表示无限等待。
    • poll函数原型:

    1. <font face="Arial">/**
    2. * fds: 要监视的文件描述符集合以及要监视的事件,为一个数组
    3. * nfds: 监视的文件描述符数量
    4. * timeout: 超时时间,单位为 ms
    5. * return: 0 超时发生, -1 发生错误, 其他值 可以进行操作的文件描述符个数
    6. */
    7. int poll(struct pollfd *fds,
    8.         nfds_t nfds,
    9.         nt     timeout)</font>
    复制代码
    2.2  非阻塞I/O程序编写
    2.2.1 驱动程序
    poll函数处理部分:
    1. <font face="Arial">unsigned int imx6uirq_poll(struct file *filp, struct poll_table_struct *wait)
    2. {
    3.    unsigned int mask = 0;
    4.    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;

    5.    /* 将等待队列头添加到poll_table中 */
    6.    poll_wait(filp, &dev->r_wait, wait);

    7.    /* 按键按下 */
    8.    if(atomic_read(&dev->releasekey))
    9.    {
    10.        mask = POLLIN | POLLRDNORM;            /* 返回PLLIN */
    11.    }
    12.    return mask;
    13. }

    14. /* 设备操作函数 */
    15. static struct file_operations imx6uirq_fops = {
    16.    .owner = THIS_MODULE,
    17.    .open = imx6uirq_open,
    18.    .read = imx6uirq_read,
    19.    .poll = imx6uirq_poll,
    20. };</font>
    复制代码
    read函数处理部分:
    1. <font face="Arial">static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
    2. {
    3.    int ret = 0;
    4.    unsigned char keyvalue = 0;
    5.    unsigned char releasekey = 0;
    6.    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;

    7.    /* 非阻塞访问 */
    8.    if (filp->f_flags & O_NONBLOCK)
    9.    {
    10.        /* 没有按键按下,返回-EAGAIN */
    11.        if(atomic_read(&dev->releasekey) == 0)
    12.        {
    13.            return -EAGAIN;
    14.        }
    15.    }
    16.    /* 阻塞访问 */
    17.    else
    18.    {
    19.        /* 加入等待队列,等待被唤醒,也就是有按键按下 */
    20.        ret = wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey));
    21.        if (ret)
    22.        {
    23.            goto wait_error;
    24.        }
    25.    }

    26.    keyvalue = atomic_read(&dev->keyvalue);
    27.    releasekey = atomic_read(&dev->releasekey);

    28.    /* 有按键按下 */
    29.    if (releasekey)
    30.    {
    31.        //printk("releasekey!\r\n");
    32.        if (keyvalue & 0x80)
    33.        {
    34.            keyvalue &= ~0x80;
    35.            ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));
    36.        }
    37.        else
    38.        {
    39.            goto data_error;
    40.        }
    41.        atomic_set(&dev->releasekey, 0); /* 按下标志清零 */
    42.    }
    43.    else
    44.    {
    45.        goto data_error;
    46.    }
    47.    return 0;

    48. wait_error:
    49.    return ret;
    50. data_error:
    51.    return -EINVAL;
    52. }</font>
    复制代码
    2.2.2 应用程序2.2.2.1 poll方式读取
    注意open函数的参数是O_NONBLOCK,即非阻塞访问,并且为了在测试时看出阻塞读取与非阻塞读取的区别,在poll函数前后添加打印,如果程序正常运行,poll函数则不会被阻塞,500ms超时未读取到按键值后会再次循环读取,实际效果就是可以看打一直有打印输出。
    1. <font face="Arial">filename = argv[1];
    2.    fd = open(filename, O_RDWR | O_NONBLOCK);    /* 非阻塞访问 */
    3.    if (fd < 0)
    4.    {
    5.        printf("[APP] Can't open file %s\r\n", filename);
    6.        return -1;
    7.    }

    8.    /* 构造结构体 */
    9.    fds.fd = fd;
    10.    fds.events = POLLIN;
    11.    while(1)
    12.    {
    13.        printf("[APP] poll begin... \r\n", data);
    14.        ret = poll(&fds, 1, 500);
    15.        printf("[APP] poll end \r\n", data);
    16.        /* 数据有效 */
    17.        if (ret > 0)
    18.        {
    19.            ret = read(fd, &data, sizeof(data));
    20.            if(ret < 0)
    21.            {
    22.                /* 读取错误 */
    23.            }
    24.            else
    25.            {
    26.                if(data)
    27.                {
    28.                    printf("[APP] key value = %d \r\n", data);
    29.                }
    30.            }
    31.        }
    32.        /* 超时 */
    33.        else if (ret == 0)
    34.        {
    35.            /* 用户自定义超时处理 */
    36.        }
    37.        /* 错误 */
    38.        else
    39.        {
    40.            /* 用户自定义错误处理 */
    41.        }
    42.    }</font>
    复制代码
    2.2.2.2 select方式读取
    select方式读取与poll方式类似,都是非阻塞读取,程序类似:
    1. <font face="Arial">while(1)
    2. {
    3.     FD_ZERO(&readfds);
    4.     FD_SET(fd, &readfds);
    5.     /* 构造超时时间 */
    6.     timeout.tv_sec = 0;
    7.     timeout.tv_usec = 500000; /* 500ms */
    8.     ret = select(fd + 1, &readfds, NULL, NULL, &timeout);
    9.     switch (ret)
    10.     {
    11.             /* 超时 */
    12.         case 0:
    13.             /* 用户自定义超时处理 */
    14.             break;
    15.             /* 错误 */
    16.         case -1:
    17.             /* 用户自定义错误处理 */
    18.             break;
    19.             /* 可以读取数据 */
    20.         default:
    21.             if(FD_ISSET(fd, &readfds))
    22.             {
    23.                 ret = read(fd, &data, sizeof(data));
    24.                 if (ret < 0)
    25.                 {
    26.                     /* 读取错误 */
    27.                 }
    28.                 else
    29.                 {
    30.                     if (data)
    31.                     {
    32.                         printf("key value=%d\r\n", data);
    33.                     }
    34.                 }
    35.             }
    36.             break;
    37.     }
    38. }</font>
    复制代码
    2.3 实验
    2.3.1 poll方式读取
    和之前一样,使用Makefile编译驱动程序和应用程序,并复制到nfs根文件系统中。
    开始测试,按如下图,当没有按键按下时,应用程序也没有被阻塞,从不断的打印就可以看出应用程序在循环运行。当有按键按下时,能够读取到对应的按键值。
    图片 9.png
    按键程序在后台运行,此时使用top指令开查看CPU的使用率,可以发现非阻塞式按键驱动这种方式,CPU的暂用率也几乎为0,虽然按键应用程序中仍实现循环读取的方式,但poll函数有500ms的超时设置,在超时等待的时间里,CPU的使用权也是被让出,所以CPU的使用率也降下来了。
    图片 10.png
    2.3.2 select方式读取
    select方式读取与poll方式读取的效果一样。
    使用ps指令查看poll方式的按键进行号,使用kill杀带该进程,再运行select方式的按键应用程序:
    图片 11.png
    select非阻塞读取的方式,CPU的暂用率也几乎为0:
    图片 12.png
    3 总结
    本篇使用两种I/O模型进行按键读取:阻塞式I/O和非用阻塞式I/O,通过实际的实验,对比两者方式的实际运行效果与主要区别,并查看CPU的占用率,两种方式的CPU使用率都几乎为0。




    签到
    回复

    使用道具 举报

    您需要登录后才可以回帖 注册/登录

    本版积分规则

    关闭

    站长推荐上一条 /4 下一条

    Archiver|手机版|小黑屋|恩智浦技术社区

    GMT+8, 2024-5-29 10:21 , Processed in 0.100536 second(s), 19 queries , MemCache On.

    Powered by Discuz! X3.4

    Copyright © 2001-2024, Tencent Cloud.

    快速回复 返回顶部 返回列表