select()/poll() 的内核实现

int select(int nfds, 	    fd_set *restrict readfds, 	    fd_set *restrict writefds, 	    fd_set *restrict errorfds, 	    struct timeval *restrict timeout);

SYSCALL_DEFINE5(select, int, n, 		fd_set __user *, inp, 		fd_set __user *, outp, 		fd_set __user *, exp, 		struct timeval __user *, tvp){	// …	ret = core_sys_select(n, inp, outp, exp, to);	ret = poll_select_copy_remaining(&end_time, tvp, 1, ret);	return ret;}

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;	// …	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);	zero_fd_set(n, fds.res_out);	zero_fd_set(n, fds.res_ex);	// …	ret = do_select(n, &fds, end_time);	// …}

int do_select(int n, fd_set_bits *fds, struct timespec *end_time){	// …	for (;;) {		// …		for (i = 0; i < n; ++rinp, ++routp, ++rexp) {			// …			struct fd f;			f = fdget(i);			if (f.file) {				const struct file_operations *f_op;				f_op = f.file->f_op;				mask = DEFAULT_POLLMASK;				if (f_op->poll) {					wait_key_set(wait, in, out,						     bit, busy_flag);					// 对每个fd进行I/O事件检测					mask = (*f_op->poll)(f.file, wait);				}				fdput(f);				// …			}		}		// 退出循环体		if (retval || timed_out || signal_pending(current))			break;		// 进入休眠		if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE,				to, slack))			timed_out = 1;	}}

int poll_schedule_timeout(struct poll_wqueues *pwq, int state,			  ktime_t *expires, unsigned long slack){	int rc = -EINTR;	// 休眠	set_current_state(state);	if (!pwq->triggered)		rc = schedule_hrtimeout_range(expires, slack, HRTIMER_MODE_ABS);	__set_current_state(TASK_RUNNING);	/*	 * Prepare for the next iteration.	 *	 * The following set_mb() serves two purposes.  First, it‘s	 * the counterpart rmb of the wmb in pollwake() such that data	 * written before wake up is always visible after wake up.	 * Second, the full barrier guarantees that triggered clearing	 * doesn‘t pass event check of the next iteration.  Note that	 * this problem doesn‘t exist for the first iteration as	 * add_wait_queue() has full barrier semantics.	 */	set_mb(pwq->triggered, 0);	return rc;}EXPORT_SYMBOL(poll_schedule_timeout);

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

struct file {	struct path		f_path;	struct inode		*f_inode;	/* cached value */	const struct file_operations	*f_op;	// …} __attribute__((aligned(4)));	/* lest something weird decides that 2 is OK */

struct file_operations {	struct module *owner;	loff_t (*llseek) (struct file *, loff_t, int);	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);	ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);	ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);	ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);	ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);	int (*iterate) (struct file *, struct dir_context *);	// select()轮询设备fd的操作函数	unsigned int (*poll) (struct file *, struct poll_table_struct *);	// …	};

unsigned int (*poll) (struct file *filp, struct poll_table_struct *pwait);

struct scull_pipe {        wait_queue_head_t inq, outq;       /* read and write queues */        char *buffer, *end;                /* begin of buf, end of buf */        int buffersize;                    /* used in pointer arithmetic */        char *rp, *wp;                     /* where to read, where to write */        int nreaders, nwriters;            /* number of openings for r/w */        struct fasync_struct *async_queue; /* asynchronous readers */        struct mutex mutex;              /* mutual exclusion semaphore */        struct cdev cdev;                  /* Char device structure */};

static unsigned int scull_p_poll(struct file *filp, poll_table *wait){	struct scull_pipe *dev = filp->private_data;	unsigned int mask = 0;	/*	 * The buffer is circular; it is considered full	 * if "wp" is right behind "rp" and empty if the	 * two are equal.	 */	mutex_lock(&dev->mutex);	poll_wait(filp, &dev->inq,  wait);	poll_wait(filp, &dev->outq, wait);	if (dev->rp != dev->wp)		mask |= POLLIN | POLLRDNORM;	/* readable */	if (spacefree(dev))		mask |= POLLOUT | POLLWRNORM;	/* writable */	mutex_unlock(&dev->mutex);	return mask;}

static ssize_t scull_p_write(struct file *filp, const char __user *buf, size_t count,                loff_t *f_pos){	// …	/* Make sure there‘s space to write */	// …	/* ok, space is there, accept something */	// …	/* finally, awake any reader */	wake_up_interruptible(&dev->inq);  /* blocked in read() and select() */	// …}

static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p){	if (p && p->_qproc && wait_address)		p->_qproc(filp, wait_address, p);}/* * Do not touch the structure directly, use the access functions * poll_does_not_wait() and poll_requested_events() instead. */typedef struct poll_table_struct {	poll_queue_proc _qproc;	unsigned long _key;} poll_table;/*  * structures and helpers for f_op->poll implementations */typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);

int do_select(int n, fd_set_bits *fds, struct timespec *end_time){	struct poll_wqueues table;	poll_table *wait;	poll_initwait(&table);	wait = &table.pt;	// …}void poll_initwait(struct poll_wqueues *pwq){	// 初始化poll_table里的函数指针	init_poll_funcptr(&pwq->pt, __pollwait);	pwq->polling_task = current;	pwq->triggered = 0;	pwq->error = 0;	pwq->table = NULL;	pwq->inline_index = 0;}EXPORT_SYMBOL(poll_initwait);static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc){	pt->_qproc = qproc;	pt->_key   = ~0UL; /* all events enabled */}

/* Add a new entry */static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,				poll_table *p){	struct poll_wqueues *pwq = container_of(p, struct poll_wqueues, pt);	struct poll_table_entry *entry = poll_get_entry(pwq);	if (!entry)		return;	entry->filp = get_file(filp);	entry->wait_address = wait_address;	entry->key = p->_key;	init_waitqueue_func_entry(&entry->wait, pollwake);	entry->wait.private = pwq;	// 把当前进程装到设备的等待队列	add_wait_queue(wait_address, &entry->wait);}void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait){	unsigned long flags;	wait->flags &= ~WQ_FLAG_EXCLUSIVE;	spin_lock_irqsave(&q->lock, flags);	__add_wait_queue(q, wait);	spin_unlock_irqrestore(&q->lock, flags);}EXPORT_SYMBOL(add_wait_queue);static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new){	list_add(&new->task_list, &head->task_list);}/** * Insert a new element after the given list head. The new element does not * need to be initialised as empty list. * The list changes from: *      head → some element → ... * to *      head → new element → older element → ... * * Example: * struct foo *newfoo = malloc(...); * list_add(&newfoo->entry, &bar->list_of_foos); * * @param entry The new element to prepend to the list. * @param head The existing list. */static inline voidlist_add(struct list_head *entry, struct list_head *head){    __list_add(entry, head, head->next);}

#define __FD_SETSIZE	1024typedef struct {	unsigned long fds_bits[__FD_SETSIZE / (8 * sizeof(long))];} __kernel_fd_set;typedef __kernel_fd_set		fd_set;

struct fd {	struct file *file;	unsigned int flags;};

/* * Structures and helpers for select/poll syscall */struct poll_wqueues {	poll_table pt;	struct poll_table_page *table;	struct task_struct *polling_task;	int triggered;	int error;	int inline_index;	struct poll_table_entry inline_entries[N_INLINE_POLL_ENTRIES];};struct poll_table_entry {	struct file *filp;	unsigned long key;	wait_queue_t wait;	wait_queue_head_t *wait_address;};

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