unixbench centos6 测试 linux io测试

        在上一章 Linux 中断实验中，我们直接在应用程序中通过 read 函数不断的读取按键状态，
当按键有效的时候就打印出按键值。这种方法有个缺点，那就是 imx6uirqApp 这个测试应用程
序拥有很高的 CPU 占用率。

        原因就在于我们是直接在 while 循环中通过 read 函数读取按键值，因此 imx6uirqApp 这个软件会一直运行，一直读取按键值， CPU 使用率肯定就会很高。最好的方法就是在没有有效的按键事件发生的时候，imx6uirqApp 这个应用程序应该处于休眠状态，当有按键事件发生以后imx6uirqApp 这个应用程序才运行，打印出按键值，这样就会降低 CPU 使用率，本小节我们就使用阻塞 IO 来实现此功能

一、阻塞式IO

        当应用程序对设备驱动进行操作的时候，如果不能获取到设备资源，那么阻塞式 IO 就会将应用程序对应的线程挂起，直到设备资源可以获取为止。

        应用程序调用 read 函数从设备中读取数据，当设备不可用或数据未准备好的时候就会进入到休眠态。等设备可用的时候就会从休眠态唤醒，然后从设备中读取数据返回给应用程序。

二、等待队列

1.等待队列头

        Linux 内核提供了等待队列(wait queue)来实现阻塞进程的唤醒工作，如果我们要在驱动中使用等待队列，必须创建并初始化一个等待队列头，等待队列头使用结构体wait_queue_head_t 表示， wait_queue_head_t 结构体定义在文件 include/linux/wait.h 中，结构体内容如下所示：

struct __wait_queue_head {
         spinlock_t lock;
         struct list_head task_list;
 };
 typedef struct __wait_queue_head wait_queue_head_t;

        定义好等待队列头以后需要初始化， 使用 init_waitqueue_head 函数初始化等待队列头，函
数原型如下：void init_waitqueue_head(wait_queue_head_t *q)。
        参数 q ：就是要初始化的等待队列头
        宏 DECLARE_WAIT_QUEUE_HEAD 可以一次性完成等待队列头的定义的初始化。
 

2.等待队列项

        等待队列头类似于火车的头部，而一节火车肯定有很多车厢，每个访问设备的进程都是一个车厢，当设备不可用的时候需要将车厢连接在火车头上，因此出现了等待队列项。结构体 wait_queue_t 表示等待队列项，结构体内容如下：

struct __wait_queue {
    unsigned int flags;
    void *private;
    wait_queue_func_t func;
    struct list_head task_list;
};
typedef struct __wait_queue wait_queue_t;

        宏 DECLARE_WAITQUEUE(name, tsk)可以一次性完成等待队列头的定义的初始化。
        name 就是等待队列项的名字， tsk 表示这个等待队列项属于哪个任务(进程)，一般设置为
current ，在Linux内核中current相当于一个全局变量 ，表示当前进程 。

        当设备不可访问的时候就需要将进程对应的等待队列项添加到前面创建的等待队列头中，
只有添加到等待队列头中以后进程才能进入休眠态。
        等待队列项添加 API 函数如下：

void add_wait_queue(wait_queue_head_t *q,
                        wait_queue_t *wait)
/*函数参数和返回值含义如下：
q： 等待队列项要加入的等待队列头。
wait：要加入的等待队列项。*/

        等待队列项移除 API 函数如下：

void remove_wait_queue(wait_queue_head_t *q,
                        wait_queue_t *wait)
/*函数参数和返回值含义如下：
q： 要删除的等待队列项所处的等待队列头。
wait：要删除的等待队列项*/

        当设备可以使用的时候就要唤醒进入休眠态的进程，唤醒可以使用如下两个函数：

void wake_up(wait_queue_head_t *q)
void wake_up_interruptible(wait_queue_head_t *q)

/*参数 q 就是要唤醒的等待队列头，这两个函数会将这个等待队列头中的所有进程都唤醒。
wake_up 函数可以唤醒处于 TASK_INTERRUPTIBLE 和 TASK_UNINTERRUPTIBLE 状态的进
程，而 wake_up_interruptible 函数只能唤醒处于 TASK_INTERRUPTIBLE 状态的进程。*/

        除了主动唤醒以外，也可以设置等待队列等待某个事件，当这个事件满足以后就自动唤醒
等待队列中的进程，和等待事件有关的 API 函数如下所示：

wait_event()宏：

在等待会列中睡眠直到condition为真。在等待的期间，进程会被置为TASK_UNINTERRUPTIBLE进入睡眠，直到condition变量变为真。每次进程被唤醒的时候都会检查condition的值.

wait_event_interruptible()函数：

和wait_event()的区别是调用该宏在等待的过程中当前进程会被设置为TASK_INTERRUPTIBLE状态.在每次被唤醒的时候,首先检查 condition是否为真,如果为真则返回,否则检查如果进程是被信号唤醒,会返回-ERESTARTSYS错误码.如果是condition为真,则 返回0.

wait_event_timeout()宏:

也与wait_event()类似.不过如果所给的睡眠时间为负数则立即返回.如果在睡眠期间被唤醒,且condition为真则返回剩余的睡眠时间,否则继续睡眠直到到达或超过给定的睡眠时间,然后返回0.

wait_event_interruptible_timeout()宏

与wait_event_timeout()类似,不过如果在睡眠期间被信号打断则返回ERESTARTSYS错误码.

wait_event_interruptible_exclusive()宏

同样和wait_event_interruptible()一样,不过该睡眠的进程是一个互斥进程

三、实验代码

        代码流程如下：

         往复循环，这样就可以达到在中断时进程的休眠！！

代码如下：

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/slab.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <linux/string.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/ide.h>



#define IMX6ULIRQ_COUNT 1
#define IMX6ULIRQ_NAME "IMX6ULIRQ"

#define KEY_NUM 1   /*因为一块板子上按键不只有1个，所有创建一个结构体数组来描述按键*/
#define KEY0VALUE 0X01
#define INVALKEY 0X7F


/*按键结构体*/
struct irq_keydesc{
    int gpio;  /*io编号*/
    int irqnum; /*中断编号*/
    unsigned char value; /*按键值*/
    char name[10];  /*中断名字*/
    irqreturn_t (*handler) (int, void *);  /*中断处理函数*/
};

/*设备结构体*/
struct imx6ulirq_dev{
    dev_t devid;    /*设备号*/
    int major;  /*主设备号*/
    int minor;  /*次设备号*/
    struct cdev cdev;   /*字符设备*/
    struct class *class;    /*创建类*/
    struct device *device;  /*创建设备*/
    struct device_node *node; /*设备节点*/
    struct irq_keydesc irqkey[KEY_NUM]; 
    struct timer_list timer;    /*添加定时器*/
    atomic_t keyval; /*按键值*/
    atomic_t releasekey;
    wait_queue_head_t r_wait;   /*读等待队列头*/

};


struct imx6ulirq_dev imx6ulirq;


static int imx6ulirq_open(struct inode *inode, struct file *filp){
    filp->private_data = &imx6ulirq; /* 设置私有数据 */
    return 0;
}
 
 
static int imx6ulirq_release(struct inode *inode, struct file *filp){
    
    return 0;
}

static ssize_t imx6ulirq_read(struct file *filp, char __user *buf,size_t cnt, loff_t *offt){
    int ret = 0;
    unsigned char keyval;
    unsigned char releasekey;
    struct imx6ulirq_dev *dev = filp->private_data;

#if 0
    /*等待事件*/
    wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey)); /*等待按键有效*/    
#endif
    /*手动休眠*/
    DECLARE_WAITQUEUE(wait,current);    /*创建一个等待队列项*/
        add_wait_queue(&dev->r_wait, &wait);    /*将队列项添加到等待队列头*/
        __set_current_state(TASK_INTERRUPTIBLE);    /*将当前进程设置为可被打断状态*/
        schedule();     /*进程切换*/

        /*信号唤醒后从这运行*/
        if(signal_pending(current)){
            ret = -ERESTARTSYS;
            goto failed_error;
        }

    keyval = atomic_read(&dev->keyval);
    releasekey = atomic_read(&dev->releasekey);

    if(releasekey){ /*如果releasekey为真表示一次完整的按键过程*/
        if(keyval & 0X80){  /*前面将真实按键值或了0X80，现在判断是否为真，若为真则返回原按键值*/
            keyval &= ~0X80;
            ret = copy_to_user(buf, &keyval, sizeof(keyval));
        }
        else{
            goto failed_error;
        }
        atomic_set(&dev->releasekey, 0);    /*按下标志清0*/
    }
    else{
        goto failed_error;
    }

failed_error:
    __set_current_state(TASK_RUNNING);  /*将当前任务设置为运行状态*/
    remove_wait_queue(&dev->r_wait, &wait); /*移除等待队列项目*/
    return ret;

}



static const struct file_operations imx6ulirq_fops = { /*字符设备操作函数集合*/
    .owner = THIS_MODULE,
    .open = imx6ulirq_open,
    .read = imx6ulirq_read,
    .release = imx6ulirq_release,
    
};

/*中断处理函数*/
static irqreturn_t key0_handler(int irq, void *dev_id){
    struct imx6ulirq_dev *dev = dev_id;

    dev->timer.data = (volatile long)dev_id;
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(15)); /*15ms定时*/
    

    return IRQ_HANDLED;
}

/*定时器超市处理函数*/
static void timer_func(unsigned long arg) {
    int value = 0;
    struct imx6ulirq_dev *dev = (struct imx6ulirq_dev *)arg;

    value = gpio_get_value(dev->irqkey[0].gpio);
    if(value == 0 ){
        atomic_set(&dev->keyval, dev->irqkey[0].value); /*如果按键按下设置按键为设置的值*/
    }
    else if(value == 1){
        atomic_set(&dev->keyval, 0X80 | (dev->irqkey[0].value));/*松开则设置按键为设置的值高位或1,来区分*/
        atomic_set(&dev->releasekey, 1);    /*releasekey设置为1表示一次完整的按键过程*/
    }

    /*唤醒进程*/
    if(atomic_read(&dev->releasekey)){
        wake_up(&dev->r_wait);
    }
}

/*按键初始化*/
static int keyio_init(struct imx6ulirq_dev *dev){
    int ret = 0;
    int i = 0;
    /*1、按键初始化*/
    dev->node = of_find_node_by_path("/key");
    if(dev->node == NULL){
        ret = -EINVAL;
        goto failed_findnode;
    }

    /*循环找到节点*/
    for (i = 0; i < KEY_NUM; i++){
        dev->irqkey[i].gpio = of_get_named_gpio(dev->node, "key-gpios", i); 
        if(dev->irqkey[i].gpio < 0){
            printk("can't get gpio %d\r\n",i);
            ret = -EINVAL;
            goto failed_findnode;
        }   
    }
    /*循环申请gpio*/
     for (i = 0; i < KEY_NUM; i++){ 
        memset(dev->irqkey[i].name, 0, sizeof(dev->irqkey[i].name));
        sprintf(dev->irqkey[i].name, "KEY%d", i);
        ret = gpio_request(dev->irqkey[i].gpio, dev->irqkey[i].name);
        if(ret){
            printk("Failed to request gpio \r\n");
            ret = -EINVAL;
            goto failed_findnode;
    }
    ret = gpio_direction_input(dev->irqkey[i].gpio);
    if(ret < 0){
        goto failed_setinput;
     }
    dev->irqkey[i].irqnum = gpio_to_irq(dev->irqkey[i].gpio);   /*获取中断号*/
     }
    /*2、按键中断初始化*/

    dev->irqkey[0].handler = key0_handler;
    dev->irqkey[0].value = KEY0VALUE;

    for(i = 0;i< KEY_NUM; i++){
        ret = request_irq(dev->irqkey[i].irqnum, dev->irqkey[i].handler, 
                         IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, dev->irqkey[i].name, &imx6ulirq);
        if(ret){
            printk("irq %d request failed!\r\n",i);
            goto failed_irq;
        }
    }

    /*初始化定时器*/
    init_timer(&dev->timer);
    dev->timer.function = timer_func;    /*定时器超时处理函数*/

    return 0;

failed_irq:
failed_setinput:
    for(i = 0;i< KEY_NUM;i++) {
        gpio_free(dev->irqkey[i].gpio);
    }
failed_findnode:
    return ret;
}


/*入口函数*/
static int __init imx6ulirq_init(void){
    int ret = 0;


    /*注册字符设备*/
    imx6ulirq.major = 0;     /*内核自动申请设备号*/
    if(imx6ulirq.major){     /*如果定义了设备号*/
        imx6ulirq.devid = MKDEV(imx6ulirq.major, 0);
        ret = register_chrdev_region(imx6ulirq.devid, IMX6ULIRQ_COUNT, IMX6ULIRQ_NAME); 
    }
    else{   /*否则自动申请设备号*/
        ret = alloc_chrdev_region(&imx6ulirq.devid, 0, IMX6ULIRQ_COUNT, IMX6ULIRQ_NAME);
        imx6ulirq.major = MAJOR(imx6ulirq.devid); /*保存主设备号*/
        imx6ulirq.minor = MINOR(imx6ulirq.devid); /*保存次设备号*/
    }
    if(ret < 0){
        goto failed_devid;
    }
    printk("imx6ulirq_dev major = %d minor = %d \r\n",imx6ulirq.major,imx6ulirq.minor);  /*打印主次设备号*/

    /*添加字符设备*/
    imx6ulirq.cdev.owner = THIS_MODULE;
    cdev_init(&imx6ulirq.cdev, &imx6ulirq_fops);
    ret = cdev_add(&imx6ulirq.cdev, imx6ulirq.devid, IMX6ULIRQ_COUNT);
    if(ret < 0){    /*添加字符设备失败*/
        goto failed_cdev;
    }

    /*自动添加设备节点*/
    /*创建类*/
    imx6ulirq.class = class_create(THIS_MODULE, IMX6ULIRQ_NAME); /*class_creat(owner,name);*/
    if(IS_ERR(imx6ulirq.class)){   /*判断是否创建类成功*/
        ret = PTR_ERR(imx6ulirq.class);
        goto failed_class;
    }

    /*创建设备*/

    imx6ulirq.device = device_create(imx6ulirq.class, NULL, imx6ulirq.devid, NULL, IMX6ULIRQ_NAME);
     if(IS_ERR(imx6ulirq.device)){   /*判断是否创建类成功*/
        ret = PTR_ERR(imx6ulirq.device);
        goto failed_device;
    }

    /*初始化IO*/
    ret = keyio_init(&imx6ulirq);
    if(ret < 0) {
        goto failed_keyinit;
    }

    /*初始化原子变量*/
    atomic_set(&imx6ulirq.keyval, INVALKEY);
    atomic_set(&imx6ulirq.releasekey, 0);

    /*初始化等待队列头*/
    init_waitqueue_head(&imx6ulirq.r_wait);

    return 0;

failed_keyinit:
failed_device:
    class_destroy(imx6ulirq.class);
failed_class:
    cdev_del(&imx6ulirq.cdev);
failed_cdev:
    unregister_chrdev_region(imx6ulirq.devid, IMX6ULIRQ_COUNT);
failed_devid:
    return ret;
}

/*出口函数*/
static void __exit imx6ulirq_exit(void){
    int i = 0;

    /*释放中断*/
    for(i = 0;i< KEY_NUM;i++) {
        free_irq(imx6ulirq.irqkey[i].irqnum, &imx6ulirq); 
    }
    /*释放io*/
     for(i = 0;i< KEY_NUM;i++) {
        gpio_free(imx6ulirq.irqkey[i].gpio);
    }
    
    /*删除定时器*/
    del_timer_sync(&imx6ulirq.timer);

    /*注销字符设备*/
    cdev_del(&imx6ulirq.cdev);
    /*卸载设备*/
    unregister_chrdev_region(imx6ulirq.devid, IMX6ULIRQ_COUNT);

    device_destroy(imx6ulirq.class, imx6ulirq.devid);
    class_destroy(imx6ulirq.class);

}


/*模块入口和出口*/
module_init(imx6ulirq_init);
module_exit(imx6ulirq_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("ZYC");

app: 

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


int main(int argc, char *argv[])
{
    int fd, ret;
    char *filename;
    unsigned char data;


    if(argc != 2){
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];

    /* 打开 key 驱动 */
    fd = open(filename, O_RDWR);
    if(fd < 0){
        printf("file %s open failed!\r\n", argv[1]);
    return -1;
    }

    /*循环读取*/
    while(1){
        ret = read(fd, &data, sizeof(data));
        if(ret < 0){

        }
        else{
            if(data)
            printf("keyvalue = %#x \r\n", data);
        }
    }


    ret= close(fd); /* 关闭文件 */
    if(ret < 0){
        printf("file %s close failed!\r\n", argv[1]);
    return -1;
}
    return 0;
}