include/linux/poll.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_POLL_H
   3 #define _LINUX_POLL_H
   4
   5
   6 #include <linux/compiler.h>
   7 #include <linux/ktime.h>
   8 #include <linux/wait.h>
   9 #include <linux/string.h>
  10 #include <linux/fs.h>
  11 #include <linux/sysctl.h>
  12 #include <linux/uaccess.h>
  13 #include <uapi/linux/poll.h>
  14
  15 extern struct ctl_table epoll_table[]; /* for sysctl */
  16 /* ~832 bytes of stack space used max in sys_select/sys_poll before allocating
  17    additional memory. */
  18 #define MAX_STACK_ALLOC 832
  19 #define FRONTEND_STACK_ALLOC    256
  20 #define SELECT_STACK_ALLOC      FRONTEND_STACK_ALLOC
  21 #define POLL_STACK_ALLOC        FRONTEND_STACK_ALLOC
  22 #define WQUEUES_STACK_ALLOC     (MAX_STACK_ALLOC - FRONTEND_STACK_ALLOC)
  23 #define N_INLINE_POLL_ENTRIES   (WQUEUES_STACK_ALLOC / sizeof(struct poll_table_entry))
  24
  25 #define DEFAULT_POLLMASK (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)
  26
  27 struct poll_table_struct;
  28
  29 /*
  30  * structures and helpers for f_op->poll implementations
  31  */
  32 typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);
  33
  34 /*
  35  * Do not touch the structure directly, use the access functions
  36  * poll_does_not_wait() and poll_requested_events() instead.
  37  */
  38 typedef struct poll_table_struct {
  39         poll_queue_proc _qproc;
  40         __poll_t _key;
  41 } poll_table;
  42
  43 static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
  44 {
  45         if (p && p->_qproc && wait_address)
  46                 p->_qproc(filp, wait_address, p);
  47 }
  48
  49 /*
  50  * Return true if it is guaranteed that poll will not wait. This is the case
  51  * if the poll() of another file descriptor in the set got an event, so there
  52  * is no need for waiting.
  53  */
  54 static inline bool poll_does_not_wait(const poll_table *p)
  55 {
  56         return p == NULL || p->_qproc == NULL;
  57 }
  58
  59 /*
  60  * Return the set of events that the application wants to poll for.
  61  * This is useful for drivers that need to know whether a DMA transfer has
  62  * to be started implicitly on poll(). You typically only want to do that
  63  * if the application is actually polling for POLLIN and/or POLLOUT.
  64  */
  65 static inline __poll_t poll_requested_events(const poll_table *p)
  66 {
  67         return p ? p->_key : ~(__poll_t)0;
  68 }
  69
  70 static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
  71 {
  72         pt->_qproc = qproc;
  73         pt->_key   = ~(__poll_t)0; /* all events enabled */
  74 }
  75
  76 struct poll_table_entry {
  77         struct file *filp;
  78         __poll_t key;
  79         wait_queue_entry_t wait;
  80         wait_queue_head_t *wait_address;
  81 };
  82
  83 /*
  84  * Structures and helpers for select/poll syscall
  85  */
  86 struct poll_wqueues {
  87         poll_table pt;
  88         struct poll_table_page *table;
  89         struct task_struct *polling_task;
  90         int triggered;
  91         int error;
  92         int inline_index;
  93         struct poll_table_entry inline_entries[N_INLINE_POLL_ENTRIES];
  94 };
  95
  96 extern void poll_initwait(struct poll_wqueues *pwq);
  97 extern void poll_freewait(struct poll_wqueues *pwq);
  98 extern int poll_schedule_timeout(struct poll_wqueues *pwq, int state,
  99                                  ktime_t *expires, unsigned long slack);
 100 extern u64 select_estimate_accuracy(struct timespec64 *tv);
 101
 102 #define MAX_INT64_SECONDS (((s64)(~((u64)0)>>1)/HZ)-1)
 103
 104 extern int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
 105                            fd_set __user *exp, struct timespec64 *end_time);
 106
 107 extern int poll_select_set_timeout(struct timespec64 *to, time64_t sec,
 108                                    long nsec);
 109
 110 #endif /* _LINUX_POLL_H */