文章目录
一、前言
当某个进程请求的数据没有准备好时,那么让该进程睡眠直到数据准备好为止。
等待队列主要用来配合阻塞io来使用。
二、等待队列头
include/linux/wait.h
struct wait_queue_head
{
// 自旋锁
spinlock_t lock;
// 链表节点类型
struct list_head head;
};
// 起别名
typedef struct wait_queue_head wait_queue_head_t;
1、初始化等待队列头
(1)init_waitqueue_head()
include/linux/wait.h
// 初始化,注意wq_head是指针
#define init_waitqueue_head(wq_head) \
do { \
static struct lock_class_key __key; \
\
__init_waitqueue_head((wq_head), #wq_head, &__key); \
} while (0)
(2)静态定义并初始化
// 定义,再初始化
#define DECLARE_WAIT_QUEUE_HEAD(name) \
struct wait_queue_head name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
三、等待队列元素
include/linux/wait.h
struct wait_queue_entry
{
unsigned int flags;
void *private;
wait_queue_func_t func;
// 通过此节点链接到等待队列(头)上
struct list_head entry;
};
typedef struct wait_queue_entry wait_queue_entry_t
1、初始化静态队列
(1)静态定义并初始化
include/linux/wait.h
// 静态定义一个等待队列元素
#define DECLARE_WAITQUEUE(name, tsk) \
struct wait_queue_entry name = __WAITQUEUE_INITIALIZER(name, tsk)
(2)添加等待队列
add_wait_queue()函数
把等待队列元素加入等待队列头
kernel/sched/wait.c
void add_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
参数:
- q :等待队列项要加入的等待队列头。
- wq_entry:要加入的等待队列项。
返回值:无
(3)移除等待队列
remove_wait_queue()函数
把等待队列元素从等待队列头中移除
kernel/sched/wait.c
void remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
参数:
- q :等待队列项要加入的等待队列头。
- wq_entry:要删除的等待队列项。
返回值:无
四、等待事件
下面三个接口都是宏
include/linux/wait.h
让进程或者线程陷入休眠态
// 被唤醒时只有condition的值为1,进程才能被唤醒。唤醒函数详见下
// 下面三个api 第一个参数为结构体变量,不是结构体指针变量
// 陷入休眠态后,进程或者线程屏蔽信号
wait_event(wq_head, condition)
// 陷入休眠态后,进程或者线程仍能接收信号
wait_event_interruptible(wq_head, condition)
// 设置休眠的超时时间,进程或者线程休眠超过限定时间会自动唤醒
wait_event_timeout(wq_head, condition, timeout)
-
参数:
wq_head :等待队列项要加入的等待队列头。
condition:唤醒条件
timeout:超时时间 -
要从wait_event()函数跳出,需要两个条件:
1、condition = 1;
2、在内核的另一个地方调用了wake_up()函数来唤醒对应的等待队列。 -
wake_up() 每次只能唤醒一个进程,而且是从队列头开始唤醒的,而 wait_event() 函数每次会将新建的等待队列插到队列头,因此最后调用 wait_event() 函数的进程先被唤醒!如果要唤醒某个特定的进程,没有现成的函数,按照本人理解,只能使用wake_up_all()函数唤醒所有进程,然后在通过条件condition来控制(每个进程使用不同的变量来控制,在wake_up_all()函数后只将要唤醒的进程的变量置成真)。
五、唤醒
kernel/sched/wait.c
用来唤醒等待队列上休眠的进程或者线程
// 唤醒时,只有对应的condition为1才能被唤醒
void wake_up(wait_queue_head_t *q)
void wake_up_interruptible(wait_queue_head_t *q)
参数:
- q 就是要唤醒的等待队列头
返回值:无
六、测试例程
1、驱动源文件 test.c
#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/init.h>
#include <linux/fs.h>
#include<linux/slab.h>
#include<linux/io.h>
#include<linux/uaccess.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/gpio.h>
#include<linux/of_gpio.h>
#include<linux/atomic.h>
#include<linux/timer.h>
#include<linux/jiffies.h>
#include<linux/interrupt.h>
#include<linux/wait.h>
#include<linux/ide.h>
#define DTSLED_NAME "dtsled"
#define LED_OFF 0
#define LED_ON 1
// 定义一组全局变量,用于存放内存映射得到的虚拟地址
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;
// 定义一个等待队列头
wait_queue_head_t wait_queue;
static unsigned int write_data;
extern struct dtsled_dev dtsled;
static void led_switch(u8 state)
{
u32 val = 0;
if(state == LED_ON)
{
val = readl(GPIO1_DR);
val &= (~(1<<3));
writel(val, GPIO1_DR);
}
else if(state == LED_OFF)
{
val = readl(GPIO1_DR);
val |= (1<<3);
writel(val, GPIO1_DR);
}
}
static int dtsled_open(struct inode *inode, struct file *filp)
{
int ret;
if(filp->f_flags & O_NONBLOCK)
{
;
}
else
{
;
}
// struct file 结构体定义在 include/linux/fs.h 中
// struct file 有一个成员(空指针):void *private_data
filp->private_data = &dtsled;
return 0;
}
static int dtsled_release(struct inode *inode, struct file *filp)
{
//struct dtsled_dev *dev = (struct dtsled_dev *)filp->private_data;
return 0;
}
static ssize_t dtsled_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
{
int ret;
u8 databuf[32] = {0};
//struct dtsled_dev *dev = (struct dtsled_dev *)filp->private_data;
printk("%s(%d):buf=(%s), count=%d\n", __FILE__, __LINE__, buf, count);
ret = copy_from_user(databuf, buf, count);
printk("%s(%d):databuf=(%s)\n", __FILE__, __LINE__, databuf);
if(ret < 0)
{
printk("%s(%d):Kernel write failed.\r\n", __FILE__, __LINE__);
return -1;
}
// s是输入字符串,base可以是10(10进制)或16(16进制),或者是0自动识别,res存放转换后的整形值
// kstrtox.c
ret = kstrtoint(databuf, 16, &write_data);
printk("%s(%d):write_data=%d", __FILE__, __LINE__, write_data);
if(write_data)
{
wake_up(&wait_queue);
printk("%s(%d):have woken up.\n", __FILE__, __LINE__);
return count;
}
else
{
// 若用户空间写入的是0,熄灯,阻塞测试app进程,等待唤醒
led_switch(LED_OFF);
wait_event(wait_queue, write_data);
printk("%s(%d):\n", __FILE__, __LINE__);
}
led_switch(LED_ON);
return 0;
}
// 操作集结构体,是 struct cdev 的成员
static const struct file_operations dtsled_fops =
{
.owner = THIS_MODULE,
.write = dtsled_write,
.open = dtsled_open,
.release = dtsled_release,
};
// 自定义结构体类型来描述 LED
struct dtsled_dev
{
dev_t devid;
struct cdev cdev; // 用于注册字符设备,操作集结构体是其成员变量
struct file_operations dtsled_fops; // 操作集结构体
struct class *class; // 用于自动创建设备节点
struct device *device; // 用于自动创建设备节点
u32 major;
u32 minor;
struct device_node *nd; // 设备树结点,用来表示 LED 设备节点
};
// 自定结构体来描述 LED
struct dtsled_dev dtsled;
// 驱动入口函数
static int __init dtsled_init(void)
{
int ret = 0;
int val = 0;
const char *str;
u32 regdata[10];
u8 i;
// 1、使用新方法来获取设备号
dtsled.major = 0;
if(dtsled.major)
{
dtsled.devid = MKDEV(dtsled.major, 0);
ret = register_chrdev_region(dtsled.devid, 1, DTSLED_NAME);
}
else
{
ret = alloc_chrdev_region(&dtsled.devid, 0, 1, DTSLED_NAME);
dtsled.major = MAJOR(dtsled.devid);
dtsled.minor = MINOR(dtsled.devid);
}
if(ret < 0)
{
printk("%d:Register char dev error.\r\n", __LINE__);
goto fail_devid;
}
// 2、添加(注册)字符设备
dtsled.cdev.owner = THIS_MODULE;
// zhu yi liang ge qu di zhi fu !
cdev_init(&dtsled.cdev, &dtsled_fops);
ret = cdev_add(&dtsled.cdev, dtsled.devid, 1);
if(ret < 0)
{
goto fail_cdev;
}
// 3、自动创建设备节点,需要一个 struct class,一个 struct device
dtsled.class = class_create(THIS_MODULE, DTSLED_NAME);
if(IS_ERR(dtsled.class))
{
ret = PTR_ERR(dtsled.class);
goto fail_class;
}
// 第一个 NULL 表示副设备, 第二个 NULL 表示 drvdata
dtsled.device = device_create(dtsled.class, NULL, dtsled.devid, NULL, DTSLED_NAME);
if(IS_ERR(dtsled.device))
{
ret = PTR_ERR(dtsled.device);
goto fail_device;
}
// 4、设备树相关,读取属性值
dtsled.nd = of_find_node_by_path("/alpha_led");
if(dtsled.nd == NULL)
{
goto fail_findnd;
}
// 获取状态属性,注意是指针的指针
ret = of_property_read_string(dtsled.nd, "status", &str);
if(ret)
{
printk("%d:fail\r\n", __LINE__);
goto fail_rs;
}
else
{
printk("%d:status = \"%s\"\r\n", __LINE__, str);
}
//huoqu shuxing
ret = of_property_read_string(dtsled.nd, "compatible", &str);
if(ret)
{
printk("%d:fail\r\n", __LINE__);
goto fail_rs;
}
else
{
printk("%d:compatible = \"%s\"\r\n", __LINE__, str);
}
// 获取 reg 属性, 也就是获取 u32 类型属性值的方法
ret = of_property_read_u32_array(dtsled.nd, "reg", regdata, 10);
if(ret < 0)
{
printk("%d:fail\r\n", __LINE__);
goto fail_rs;
}
else
{
printk("< reg > = < ");
for(i=0; i<10; i++)
{
printk("%#X ", regdata[i]);
}
printk(">\r\n");
}
// 5、初始化 LED
IMX6U_CCM_CCGR1 = of_iomap(dtsled.nd, 0);
SW_MUX_GPIO1_IO03 = of_iomap(dtsled.nd, 1);
SW_PAD_GPIO1_IO03 = of_iomap(dtsled.nd, 2);
GPIO1_DR = of_iomap(dtsled.nd, 3);
GPIO1_GDIR = of_iomap(dtsled.nd, 4);
// 初始化 LED 相关寄存器
val = readl(IMX6U_CCM_CCGR1);
val &= (~(3<<26));
val |= (3<<26);
writel(val, IMX6U_CCM_CCGR1);
writel(0X5, SW_MUX_GPIO1_IO03);//io mux
writel(0X10B0, SW_PAD_GPIO1_IO03); // set electrical properity
val = readl(GPIO1_GDIR); // set bit3, out
val |= (1<<3);
writel(val, GPIO1_GDIR);
val = readl(GPIO1_DR);
val &= (~(1<<3));//turn on led
writel(val, GPIO1_DR);
// 6、初始化等待队列头
init_waitqueue_head(&wait_queue);
return 0;
fail_rs:
fail_findnd:
device_destroy(dtsled.class, dtsled.devid);
fail_device:
class_destroy(dtsled.class);
fail_class:
cdev_del(&dtsled.cdev);
fail_cdev:
unregister_chrdev_region(dtsled.devid, 1);
fail_devid:
return ret;
}
// 出口函数
static void __exit dtsled_exit(void)
{
unsigned int val = 0;
val = readl(GPIO1_DR);
val |= (1<<3); // turn off led
writel(val, GPIO1_DR);
// 取消地址映射
iounmap(IMX6U_CCM_CCGR1);
iounmap(SW_MUX_GPIO1_IO03);
iounmap(SW_PAD_GPIO1_IO03);
iounmap(GPIO1_DR);
iounmap(GPIO1_GDIR);
// 删除字符设备
cdev_del(&dtsled.cdev);
// 释放设备号
unregister_chrdev_region(dtsled.devid, 1);
// 删除设备
device_destroy(dtsled.class, dtsled.devid);
// 删除类
class_destroy(dtsled.class);
}
// 注册出口函数和入口函数
module_init(dtsled_init);
module_exit(dtsled_exit);
MODULE_LICENSE("GPL");
2. 测试app源文件 app.c
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
int main(int argc, char *argv[])
{
int error;
int fd;
if(argc != 3)
{
printf("%s(%d):command error!\n", __FILE__, __LINE__);
return -1;
}
/*打开文件*/
fd = open(argv[1], O_RDWR|O_NONBLOCK);
if(fd < 0)
{
printf("%s(%d):fail to open file : %s !!!\n", __FILE__, __LINE__, argv[1]);
return -1;
}
error = write(fd,argv[2],strlen(argv[2]));
if(error < 0)
{
printf("%s(%d):write file error! \n", __FILE__, __LINE__);
close(fd);
}
/*关闭文件*/
error = close(fd);
if(error < 0)
{
printf("%s(%d):close file error! \n", __FILE__, __LINE__);
}
return 0;
}
3、现象
/lib/modules/4.1.15 #
/lib/modules/4.1.15 # ./app /dev/dtsled 0 &
/lib/modules/4.1.15 # /home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(86):buf=(0), count=1
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(88):databuf=(0)
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(96):write_data=0
/lib/modules/4.1.15 #
/lib/modules/4.1.15 #
/lib/modules/4.1.15 # ./app /dev/dtsled 1
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(86):buf=(1), count=1
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(88):databuf=(1)
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(96):write_data=1
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(108):
/home/jl/linux/imx6ull/linux_driver/z_exercise/test.c(100):have woken up.
app.c(26):sizeof(argv[2])=4, strlen(argv[2])=1, error=0
app.c(26):sizeof(argv[2])=4, strlen(argv[2])=1, error=1
[1]+ Done ./app /dev/dtsled 0
/lib/modules/4.1.15 #
/lib/modules/4.1.15 # ps | grep app
92 root 0:00 grep app
/lib/modules/4.1.15 #
ssize_t write(int fd, const void *buf, size_t count);
参数2:buf 和参数3:count在传入内核空间时:
buf会整个传入,不论buf的长度比count长还是短。
count会原值传入。
在内核态下,会根据count来去buf。如果buf本身比count短,那就取整个buf