驱动实现select机制的步骤 / 开普饭

一、驱动实现select机制的步骤

1、首先初始化一个等待队列头

2、在驱动中实现poll函数，该函数只需做两件事情

a、使用poll_wait()函数将等待队列添加到poll_table中。

b、返回描述设备是否可读或可写的掩码。

3、在驱动的相应地方调用wake_up()函数，唤醒等待队列。

两点说明：

a、等待队列

select函数阻塞的原理，实际上是通过等待队列实现的，若对等待队列不熟悉，请看我的另一篇文章《等待队列的简单使用》。否则看以下的 “select机制内核代码走读” 会很吃力。

b、掩码值及含义

POLLIN

如果设备可被不阻塞地读, 这个位必须设置.

POLLRDNORM

这个位必须设置, 如果"正常"数据可用来读. 一个可读的设备返回( POLLIN|POLLRDNORM ).

POLLRDBAND

这个位指示带外数据可用来从设备中读取. 当前只用在 Linux 内核的一个地方( DECnet 代码 )并且通常对设备驱动不可用.

POLLPRI

高优先级数据(带外)可不阻塞地读取. 这个位使 select 报告在文件上遇到一个异常情况, 因为 selct 报告带外数据作为一个异常情况.

POLLHUP

当读这个设备的进程见到文件尾, 驱动必须设置 POLLUP(hang-up). 一个调用 select 的进程被告知设备是可读的, 如同 selcet 功能所规定的.

POLLERR

一个错误情况已在设备上发生. 当调用 poll, 设备被报告位可读可写, 因为读写都返回一个错误码而不阻塞.

POLLOUT

这个位在返回值中设置, 如果设备可被写入而不阻塞.

POLLWRNORM

这个位和 POLLOUT 有相同的含义, 并且有时它确实是相同的数. 一个可写的设备返回( POLLOUT|POLLWRNORM).

POLLWRBAND

如同 POLLRDBAND , 这个位意思是带有零优先级的数据可写入设备. 只有 poll 的数据报实现使用这个位, 因为一个数据报看传送带外数据.

注：应当重复一下 POLLRDBAND 和 POLLWRBAND 仅仅对关联到 socket 的文件描述符有意义: 通常设备驱动不使用这些标志！

二、以按键驱动为例

驱动代码button.c

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/types.h>

#include <linux/fcntl.h>

#include <linux/mm.h>

#include <linux/fs.h>

#include <linux/cdev.h>

#include <linux/errno.h>

#include <linux/init.h>

#include <linux/device.h>

#include <linux/init.h>

#include <linux/major.h>

#include <linux/delay.h>

#include <linux/io.h>

#include <asm/uaccess.h>

#include <linux/poll.h>

#include <linux/irq.h>

#include <asm/irq.h>

#include <linux/interrupt.h>

#include <asm/uaccess.h>

#include <linux/platform_device.h>

#include <linux/cdev.h>

#include <linux/miscdevice.h>

#include <linux/sched.h>

#include <linux/gpio.h>

#include <asm/gpio.h>

#define BUTTON_NAME "poll_button"

#define BUTTON_GPIO 140

static int button_major = 0;

static int button_minor = 0;

static struct cdev button_cdev;

static struct class *p_button_class = NULL;

static struct device *p_button_device = NULL;

static struct timer_list button_timer;

static volatile int ev_press = 0;

static volatile char key_value[] = {0};

static int old_value;

static int Button_Irq = 0;

static int flag_interrupt = 1;

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

static irqreturn_t buttons_interrupt(int irq, void *dev_id)

{

if(flag_interrupt) {

flag_interrupt = 0;

old_value = gpio_get_value(BUTTON_GPIO);

mod_timer(&button_timer,jiffies + HZ/100); //启动消抖定时器，消抖时间10ms

}

return IRQ_RETVAL(IRQ_HANDLED);

}

static void button_timer_handle(unsigned long arg)

{

int tmp_value;

tmp_value = gpio_get_value(BUTTON_GPIO);

if(tmp_value == old_value) {

key_value[0] = tmp_value;

ev_press= 1; //有按键按下，唤醒等待队列

wake_up_interruptible(&button_waitq);

}

flag_interrupt = 1;

}

static int button_open(struct inode *inode,struct file *file)

{

Button_Irq = gpio_to_irq(BUTTON_GPIO);

enable_irq(Button_Irq);

if(request_irq(Button_Irq, buttons_interrupt, IRQF_TRIGGER_FALLING, "BUTTON_IRQ", NULL) != 0) {

printk("request irq failed !!! \n");

disable_irq(Button_Irq);

free_irq(Button_Irq, NULL);

return -EBUSY;

}

return 0;

}

static int button_close(struct inode *inode, struct file *file)

{

free_irq(Button_Irq, NULL);

return 0;

}

static int button_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)

{

unsigned long err;

if (filp->f_flags & O_NONBLOCK) {

/*nothing to do*/

//如果没有使用select机制，并且应用程序设置了非阻塞O_NONBLOCK，那么驱动这里就不使用等待队列进行等待。

} else {

wait_event_interruptible(button_waitq, ev_press); //如果应用层没有使用select，直接读的话，这里会阻塞，直到按键按下。如果使用select机制，进来这里时ev_press为真，不会阻塞。

}

err = copy_to_user(buff, (const void *)key_value, min(sizeof(key_value), count));

key_value[0] = 0;

ev_press = 0;

return err ? -EFAULT : min(sizeof(key_value), count);

}

static unsigned int button_poll(struct file *file, struct poll_table_struct *wait)

{

unsigned int mask = 0;

//将等待队列添加到poll_table中

poll_wait(file, &button_waitq, wait);

if(ev_press) {

//返回描述设备是否可读或可写的掩码

mask = POLLIN | POLLRDNORM;

}

return mask;

}

static const struct file_operations button_fops = {

.owner = THIS_MODULE,

.open = button_open,

.release = button_close,

.read = button_read,

.poll = button_poll,

//.write = button_write,

//.ioctl = button_ioctl

};

static int button_setup_cdev(struct cdev *cdev, dev_t devno)

{

int ret = 0;

cdev_init(cdev, &button_fops);

cdev->owner = THIS_MODULE;

ret = cdev_add(cdev, devno, 1);

return ret;

}

static int __init button_init(void)

{

int ret;

dev_t devno;

printk("button driver init...\n");

init_timer(&button_timer);

button_timer.function = &button_timer_handle;

if(button_major) {

devno = MKDEV(button_major, button_minor);

ret = register_chrdev_region(devno, 1, BUTTON_NAME);

} else {

ret = alloc_chrdev_region(&devno, button_minor, 1, BUTTON_NAME);

button_major = MAJOR(devno);

}

if(ret < 0) {

printk("get button major failed\n");

return ret;

}

ret = button_setup_cdev(&button_cdev, devno);

if(ret) {

printk("button setup cdev failed, ret = %d\n",ret);

goto cdev_add_fail;

}

p_button_class = class_create(THIS_MODULE, BUTTON_NAME);

ret = IS_ERR(p_button_class);

if(ret) {

printk(KERN_WARNING "button class create failed\n");

goto class_create_fail;

}

p_button_device = device_create(p_button_class, NULL, devno, NULL, BUTTON_NAME);

ret = IS_ERR(p_button_device);

if (ret) {

printk(KERN_WARNING "button device create failed, error code %ld", PTR_ERR(p_button_device));

goto device_create_fail;

}

return 0;

device_create_fail:

class_destroy(p_button_class);

class_create_fail:

cdev_del(&button_cdev);

cdev_add_fail:

unregister_chrdev_region(devno, 1);

return ret;

}

static void __exit button_exit(void)

{

dev_t devno;

printk("button driver exit...\n");

del_timer_sync(&button_timer);

devno = MKDEV(button_major, button_minor);

device_destroy(p_button_class, devno);

class_destroy(p_button_class);

cdev_del(&button_cdev);

unregister_chrdev_region(devno, 1);

}

module_init(button_init);

module_exit(button_exit);

MODULE_AUTHOR("Jimmy");

MODULE_DESCRIPTION("button Driver");

MODULE_LICENSE("GPL");

驱动Makefile文件

ifneq ($(KERNELRELEASE),)

obj-m := button.o

else

KERNELDIR ?= /ljm/git_imx6/linux-fsl/src/linux-3-14-28-r0

TARGET_CROSS = arm-none-linux-gnueabi-

PWD := $(shell pwd)

default:

$(MAKE) ARCH=arm CROSS_COMPILE=$(TARGET_CROSS) -C $(KERNELDIR) M=$(PWD) modules

endif

install:

$(MAKE) ARCH=arm CROSS_COMPILE=$(TARGET_CROSS) -C $(KERNELDIR) M=$(PWD) modules_install

clean:

rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions *.symvers *.order

应用程序main.c

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <linux/ioctl.h>

#define DEV_BUTTON "/dev/poll_button"

int main(void)

{

int dev_fd;

int ret;

char read_buf[20] = {-1};

struct timeval rto;

fd_set read_fds;

rto.tv_sec = 10;

rto.tv_usec = 0;

dev_fd = open(DEV_BUTTON, O_RDWR /*| O_NONBLOCK*/);

if ( dev_fd == -1 ) {

printf("open %s failed, ret = %d\n", DEV_BUTTON, dev_fd);

return -1;

}

while(1)

{

rto.tv_sec =10;

rto.tv_usec = 0;

FD_ZERO(&read_fds);

FD_SET(dev_fd, &read_fds);

ret = select(dev_fd+1, &read_fds, NULL, NULL, &rto);

if(ret == -1) {

printf("error\n");

continue;

} else if(ret == 0) {

printf("timeout\n");

continue;

} else {

if(FD_ISSET(dev_fd, &read_fds)) {

read(dev_fd, read_buf, 1);

printf("button pressed, val = %d\n", read_buf[0]);

}

printf("clsoe %s\n", DEV_BUTTON);

close(dev_fd);

return 0;

}

应用程序Makefile

WORKDIR =

INCLUDES = -I.

LIBS =

LINKS = -lpthread

CC = arm-none-linux-gnueabi-gcc

TARGET = main

src=$(wildcard *.c ./callback/*.c)

C_OBJS=$(patsubst %.c, %.o,$(src))

#C_OBJS=$(dir:%.c=%.o)

compile:$(TARGET)

$(C_OBJS):%.o:%.c

$(CC) $(CFLAGS) $(INCLUDES) -o $*.o -c $*.c

$(TARGET):$(C_OBJS)

$(CC) -o $(TARGET) $^ $(LIBS) $(LINKS)

@echo

@echo Project has been successfully compiled.

@echo

install: $(TARGET)

cp $(TARGET) $(INSTALL_PATH)

uninstall:

rm -f $(INSTALL_PATH)/$(TARGET)

rebuild: clean compile

clean:

rm -rf *.o $(TARGET) *.log *~

三、select的整体流程

应用层的select函数会调用到内核函数do_select，do_select调用驱动的poll函数，若poll函数返回的掩码不可读写，那么do_select进入睡眠阻塞。要从睡眠中醒来并且跳出，有两种情况：a、超时跳出；b、驱动中唤醒等待队列，这时do_select再次调用poll函数，如果poll函数返回的掩码可读写，那么就跳出阻塞，否则继续睡眠。注意：上述是在select函数设成阻塞的情况，select函数可以设置成非阻塞的(将select函数的timeout参数设置成0)。

四、select机制内核代码走读

调用顺序如下select() -> core_sys_select() -> do_select() -> fop->poll()

1、select函数解析

<pre name="code">SYSCALL_DEFINE5(select, int, n, fd_set __user *, inp, fd_set __user *, outp,

fd_set __user *, exp, struct timeval __user *, tvp)

{

struct timespec end_time, *to = NULL;

struct timeval tv;

int ret;

if (tvp) {// 如果超时值非NULL

if (copy_from_user(&tv, tvp, sizeof(tv))) // 从用户空间取数据到内核空间

return -EFAULT;

to = &end_time;

// 得到timespec格式的未来超时时间

if (poll_select_set_timeout(to,

tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),

(tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))

return -EINVAL;

}

ret = core_sys_select(n, inp, outp, exp, to); // 关键函数

ret = poll_select_copy_remaining(&end_time, tvp, 1, ret);

/*如果有超时值, 并拷贝离超时时刻还剩的时间到用户空间的timeval中*/

return ret; // 返回就绪的文件描述符的个数

}

2、core_sys_select函数解析

int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,

fd_set __user *exp, struct timespec *end_time)

{

fd_set_bits fds;

/**

typedef struct {

unsigned long *in, *out, *ex;

unsigned long *res_in, *res_out, *res_ex;

} fd_set_bits;

这个结构体中定义的全是指针，这些指针都是用来指向描述符集合的。

**/

void *bits;

int ret, max_fds;

unsigned int size;

struct fdtable *fdt;

/* Allocate small arguments on the stack to save memory and be faster */

long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];

// 256/32 = 8, stack中分配的空间

/**

@ include/linux/poll.h

#define FRONTEND_STACK_ALLOC 256

#define SELECT_STACK_ALLOC FRONTEND_STACK_ALLOC

**/

ret = -EINVAL;

if (n < 0)

goto out_nofds;

/* max_fds can increase, so grab it once to avoid race */

rcu_read_lock();

fdt = files_fdtable(current->files); // RCU ref, 获取当前进程的文件描述符表

max_fds = fdt->max_fds;

rcu_read_unlock();

if (n > max_fds) // 如果传入的n大于当前进程最大的文件描述符，给予修正

n = max_fds;

* We need 6 bitmaps (in/out/ex for both incoming and outgoing),

* since we used fdset we need to allocate memory in units of

* long-words.

size = FDS_BYTES(n);

// 以一个文件描述符占一bit来计算，传递进来的这些fd_set需要用掉多少个字

bits = stack_fds;

if (size > sizeof(stack_fds) / 6) {

// 除6，为什么?因为每个文件描述符需要6个bitmaps

/* Not enough space in on-stack array; must use kmalloc */

ret = -ENOMEM;

bits = kmalloc(6 * size, GFP_KERNEL); // stack中分配的太小，直接kmalloc

if (!bits)

goto out_nofds;

}

// 这里就可以明显看出struct fd_set_bits结构体的用处了。

fds.in = bits;

fds.out = bits + size;

fds.ex = bits + 2*size;

fds.res_in = bits + 3*size;

fds.res_out = bits + 4*size;

fds.res_ex = bits + 5*size;

// get_fd_set仅仅调用copy_from_user从用户空间拷贝了fd_set

if ((ret = get_fd_set(n, inp, fds.in)) ||

(ret = get_fd_set(n, outp, fds.out)) ||

(ret = get_fd_set(n, exp, fds.ex)))

goto out;

zero_fd_set(n, fds.res_in); // 对这些存放返回状态的字段清0

zero_fd_set(n, fds.res_out);

zero_fd_set(n, fds.res_ex);

ret = do_select(n, &fds, end_time); // 关键函数，完成主要的工作

if (ret < 0) // 有错误

goto out;

if (!ret) { // 超时返回，无设备就绪

ret = -ERESTARTNOHAND;

if (signal_pending(current))

goto out;

ret = 0;

}

// 把结果集,拷贝回用户空间

if (set_fd_set(n, inp, fds.res_in) ||

set_fd_set(n, outp, fds.res_out) ||

set_fd_set(n, exp, fds.res_ex))

ret = -EFAULT;

out:

if (bits != stack_fds)

kfree(bits); // 如果有申请空间，那么释放fds对应的空间

out_nofds:

return ret; // 返回就绪的文件描述符的个数

}

3、do_select函数解析

int do_select(int n, fd_set_bits *fds, struct timespec *end_time)

{

ktime_t expire, *to = NULL;

struct poll_wqueues table;

poll_table *wait;

int retval, i, timed_out = 0;

unsigned long slack = 0;

rcu_read_lock();

// 根据已经设置好的fd位图检查用户打开的fd, 要求对应fd必须打开, 并且返回

// 最大的fd。

retval = max_select_fd(n, fds);

rcu_read_unlock();

if (retval < 0)

return retval;

n = retval;

// 一些重要的初始化:

// poll_wqueues.poll_table.qproc函数指针初始化，该函数是驱动程序中poll函数实

// 现中必须要调用的poll_wait()中使用的函数。

poll_initwait(&table);

wait = &table.pt;

if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {

wait = NULL;

timed_out = 1; // 如果系统调用带进来的超时时间为0，那么设置

// timed_out = 1，表示不阻塞，直接返回。

}

if (end_time && !timed_out)

slack = estimate_accuracy(end_time); // 超时时间转换

retval = 0;

for (;;) {

unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;

inp = fds->in; outp = fds->out; exp = fds->ex;

rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;

// 所有n个fd的循环

for (i = 0; i < n; ++rinp, ++routp, ++rexp) {

unsigned long in, out, ex, all_bits, bit = 1, mask, j;

unsigned long res_in = 0, res_out = 0, res_ex = 0;

const struct file_operations *f_op = NULL;

struct file *file = NULL;

// 先取出当前循环周期中的32个文件描述符对应的bitmaps

in = *inp++; out = *outp++; ex = *exp++;

all_bits = in | out | ex; // 组合一下，有的fd可能只监测读，或者写，或者e rr，或者同时都监测

if (all_bits == 0) { // 这32个描述符没有任何状态被监测，就跳入下一个32个fd的循环中

i += __NFDBITS; //每32个文件描述符一个循环，正好一个long型数

continue;

}

// 本次32个fd的循环中有需要监测的状态存在

for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {// 初始bit = 1

int fput_needed;

if (i >= n) // i用来检测是否超出了最大待监测的fd

break;

if (!(bit & all_bits))

continue; // bit每次循环后左移一位的作用在这里，用来跳过没有状态监测的fd

file = fget_light(i, &fput_needed); // 得到file结构指针，并增加引用计数字段f_count

if (file) { // 如果file存在

f_op = file->f_op;

mask = DEFAULT_POLLMASK;

if (f_op && f_op->poll) {

wait_key_set(wait, in, out, bit);// 设置当前fd待监测的事件掩码

mask = (*f_op->poll)(file, wait);

调用驱动程序中的poll函数，以evdev驱动中的

evdev_poll()为例该函数会调用函数poll_wait(file, &evdev->wait, wait)，

继续调用__pollwait()回调来分配一个poll_table_entry结构体，该结构体有一个内嵌的等待队列项，

设置好wake时调用的回调函数后将其添加到驱动程序中的等待队列头中。

}

fput_light(file, fput_needed);

// 释放file结构指针，实际就是减小他的一个引用计数字段f_count。

// mask是每一个fop->poll()程序返回的设备状态掩码。

if ((mask & POLLIN_SET) && (in & bit)) {

res_in |= bit; // fd对应的设备可读

retval++;

wait = NULL; // 后续有用，避免重复执行__pollwait()

}

if ((mask & POLLOUT_SET) && (out & bit)) {

res_out |= bit; // fd对应的设备可写

retval++;

wait = NULL;

}

if ((mask & POLLEX_SET) && (ex & bit)) {

res_ex |= bit;

retval++;

wait = NULL;

}

// 根据poll的结果写回到输出位图里,返回给上级函数

if (res_in)

*rinp = res_in;

if (res_out)

*routp = res_out;

if (res_ex)

*rexp = res_ex;

这里的目的纯粹是为了增加一个抢占点。

在支持抢占式调度的内核中（定义了CONFIG_PREEMPT），

cond_resched是空操作。

cond_resched();

}

wait = NULL; // 后续有用，避免重复执行__pollwait()

if (retval || timed_out || signal_pending(current))

break;

if (table.error) {

retval = table.error;

break;

}

/*跳出这个大循环的条件有: 有设备就绪或有异常(retval!=0), 超时(timed_out

= 1), 或者有中止信号出现*/

* If this is the first loop and we have a timeout

* given, then we convert to ktime_t and set the to

* pointer to the expiry value.

if (end_time && !to) {

expire = timespec_to_ktime(*end_time);

to = &expire;

}

// 第一次循环中，当前用户进程从这里进入休眠，

// 上面传下来的超时时间只是为了用在睡眠超时这里而已

// 超时，poll_schedule_timeout()返回0；被唤醒时返回-EINTR

if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE,

to, slack))

timed_out = 1; /* 超时后，将其设置成1，方便后面退出循环返回到上层 */

}

// 清理各个驱动程序的等待队列头，同时释放掉所有空出来的page页(poll_table_entry)

poll_freewait(&table);

return retval; // 返回就绪的文件描述符的个数

}

---------------------

作者：o倚楼听风雨o

来源：CSDN

原文：https://blog.csdn.net/silent123go/article/details/52577648

驱动实现select机制的步骤

相关推荐