Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * This file contains the procedures for the handling of select and poll
0004  *
0005  * Created for Linux based loosely upon Mathius Lattner's minix
0006  * patches by Peter MacDonald. Heavily edited by Linus.
0007  *
0008  *  4 February 1994
0009  *     COFF/ELF binary emulation. If the process has the STICKY_TIMEOUTS
0010  *     flag set in its personality we do *not* modify the given timeout
0011  *     parameter to reflect time remaining.
0012  *
0013  *  24 January 2000
0014  *     Changed sys_poll()/do_poll() to use PAGE_SIZE chunk-based allocation 
0015  *     of fds to overcome nfds < 16390 descriptors limit (Tigran Aivazian).
0016  */
0017 
0018 #include <linux/compat.h>
0019 #include <linux/kernel.h>
0020 #include <linux/sched/signal.h>
0021 #include <linux/sched/rt.h>
0022 #include <linux/syscalls.h>
0023 #include <linux/export.h>
0024 #include <linux/slab.h>
0025 #include <linux/poll.h>
0026 #include <linux/personality.h> /* for STICKY_TIMEOUTS */
0027 #include <linux/file.h>
0028 #include <linux/fdtable.h>
0029 #include <linux/fs.h>
0030 #include <linux/rcupdate.h>
0031 #include <linux/hrtimer.h>
0032 #include <linux/freezer.h>
0033 #include <net/busy_poll.h>
0034 #include <linux/vmalloc.h>
0035 
0036 #include <linux/uaccess.h>
0037 
0038 
0039 /*
0040  * Estimate expected accuracy in ns from a timeval.
0041  *
0042  * After quite a bit of churning around, we've settled on
0043  * a simple thing of taking 0.1% of the timeout as the
0044  * slack, with a cap of 100 msec.
0045  * "nice" tasks get a 0.5% slack instead.
0046  *
0047  * Consider this comment an open invitation to come up with even
0048  * better solutions..
0049  */
0050 
0051 #define MAX_SLACK   (100 * NSEC_PER_MSEC)
0052 
0053 static long __estimate_accuracy(struct timespec64 *tv)
0054 {
0055     long slack;
0056     int divfactor = 1000;
0057 
0058     if (tv->tv_sec < 0)
0059         return 0;
0060 
0061     if (task_nice(current) > 0)
0062         divfactor = divfactor / 5;
0063 
0064     if (tv->tv_sec > MAX_SLACK / (NSEC_PER_SEC/divfactor))
0065         return MAX_SLACK;
0066 
0067     slack = tv->tv_nsec / divfactor;
0068     slack += tv->tv_sec * (NSEC_PER_SEC/divfactor);
0069 
0070     if (slack > MAX_SLACK)
0071         return MAX_SLACK;
0072 
0073     return slack;
0074 }
0075 
0076 u64 select_estimate_accuracy(struct timespec64 *tv)
0077 {
0078     u64 ret;
0079     struct timespec64 now;
0080 
0081     /*
0082      * Realtime tasks get a slack of 0 for obvious reasons.
0083      */
0084 
0085     if (rt_task(current))
0086         return 0;
0087 
0088     ktime_get_ts64(&now);
0089     now = timespec64_sub(*tv, now);
0090     ret = __estimate_accuracy(&now);
0091     if (ret < current->timer_slack_ns)
0092         return current->timer_slack_ns;
0093     return ret;
0094 }
0095 
0096 
0097 
0098 struct poll_table_page {
0099     struct poll_table_page * next;
0100     struct poll_table_entry * entry;
0101     struct poll_table_entry entries[];
0102 };
0103 
0104 #define POLL_TABLE_FULL(table) \
0105     ((unsigned long)((table)->entry+1) > PAGE_SIZE + (unsigned long)(table))
0106 
0107 /*
0108  * Ok, Peter made a complicated, but straightforward multiple_wait() function.
0109  * I have rewritten this, taking some shortcuts: This code may not be easy to
0110  * follow, but it should be free of race-conditions, and it's practical. If you
0111  * understand what I'm doing here, then you understand how the linux
0112  * sleep/wakeup mechanism works.
0113  *
0114  * Two very simple procedures, poll_wait() and poll_freewait() make all the
0115  * work.  poll_wait() is an inline-function defined in <linux/poll.h>,
0116  * as all select/poll functions have to call it to add an entry to the
0117  * poll table.
0118  */
0119 static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
0120                poll_table *p);
0121 
0122 void poll_initwait(struct poll_wqueues *pwq)
0123 {
0124     init_poll_funcptr(&pwq->pt, __pollwait);
0125     pwq->polling_task = current;
0126     pwq->triggered = 0;
0127     pwq->error = 0;
0128     pwq->table = NULL;
0129     pwq->inline_index = 0;
0130 }
0131 EXPORT_SYMBOL(poll_initwait);
0132 
0133 static void free_poll_entry(struct poll_table_entry *entry)
0134 {
0135     remove_wait_queue(entry->wait_address, &entry->wait);
0136     fput(entry->filp);
0137 }
0138 
0139 void poll_freewait(struct poll_wqueues *pwq)
0140 {
0141     struct poll_table_page * p = pwq->table;
0142     int i;
0143     for (i = 0; i < pwq->inline_index; i++)
0144         free_poll_entry(pwq->inline_entries + i);
0145     while (p) {
0146         struct poll_table_entry * entry;
0147         struct poll_table_page *old;
0148 
0149         entry = p->entry;
0150         do {
0151             entry--;
0152             free_poll_entry(entry);
0153         } while (entry > p->entries);
0154         old = p;
0155         p = p->next;
0156         free_page((unsigned long) old);
0157     }
0158 }
0159 EXPORT_SYMBOL(poll_freewait);
0160 
0161 static struct poll_table_entry *poll_get_entry(struct poll_wqueues *p)
0162 {
0163     struct poll_table_page *table = p->table;
0164 
0165     if (p->inline_index < N_INLINE_POLL_ENTRIES)
0166         return p->inline_entries + p->inline_index++;
0167 
0168     if (!table || POLL_TABLE_FULL(table)) {
0169         struct poll_table_page *new_table;
0170 
0171         new_table = (struct poll_table_page *) __get_free_page(GFP_KERNEL);
0172         if (!new_table) {
0173             p->error = -ENOMEM;
0174             return NULL;
0175         }
0176         new_table->entry = new_table->entries;
0177         new_table->next = table;
0178         p->table = new_table;
0179         table = new_table;
0180     }
0181 
0182     return table->entry++;
0183 }
0184 
0185 static int __pollwake(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
0186 {
0187     struct poll_wqueues *pwq = wait->private;
0188     DECLARE_WAITQUEUE(dummy_wait, pwq->polling_task);
0189 
0190     /*
0191      * Although this function is called under waitqueue lock, LOCK
0192      * doesn't imply write barrier and the users expect write
0193      * barrier semantics on wakeup functions.  The following
0194      * smp_wmb() is equivalent to smp_wmb() in try_to_wake_up()
0195      * and is paired with smp_store_mb() in poll_schedule_timeout.
0196      */
0197     smp_wmb();
0198     pwq->triggered = 1;
0199 
0200     /*
0201      * Perform the default wake up operation using a dummy
0202      * waitqueue.
0203      *
0204      * TODO: This is hacky but there currently is no interface to
0205      * pass in @sync.  @sync is scheduled to be removed and once
0206      * that happens, wake_up_process() can be used directly.
0207      */
0208     return default_wake_function(&dummy_wait, mode, sync, key);
0209 }
0210 
0211 static int pollwake(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
0212 {
0213     struct poll_table_entry *entry;
0214 
0215     entry = container_of(wait, struct poll_table_entry, wait);
0216     if (key && !(key_to_poll(key) & entry->key))
0217         return 0;
0218     return __pollwake(wait, mode, sync, key);
0219 }
0220 
0221 /* Add a new entry */
0222 static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
0223                 poll_table *p)
0224 {
0225     struct poll_wqueues *pwq = container_of(p, struct poll_wqueues, pt);
0226     struct poll_table_entry *entry = poll_get_entry(pwq);
0227     if (!entry)
0228         return;
0229     entry->filp = get_file(filp);
0230     entry->wait_address = wait_address;
0231     entry->key = p->_key;
0232     init_waitqueue_func_entry(&entry->wait, pollwake);
0233     entry->wait.private = pwq;
0234     add_wait_queue(wait_address, &entry->wait);
0235 }
0236 
0237 static int poll_schedule_timeout(struct poll_wqueues *pwq, int state,
0238               ktime_t *expires, unsigned long slack)
0239 {
0240     int rc = -EINTR;
0241 
0242     set_current_state(state);
0243     if (!pwq->triggered)
0244         rc = schedule_hrtimeout_range(expires, slack, HRTIMER_MODE_ABS);
0245     __set_current_state(TASK_RUNNING);
0246 
0247     /*
0248      * Prepare for the next iteration.
0249      *
0250      * The following smp_store_mb() serves two purposes.  First, it's
0251      * the counterpart rmb of the wmb in pollwake() such that data
0252      * written before wake up is always visible after wake up.
0253      * Second, the full barrier guarantees that triggered clearing
0254      * doesn't pass event check of the next iteration.  Note that
0255      * this problem doesn't exist for the first iteration as
0256      * add_wait_queue() has full barrier semantics.
0257      */
0258     smp_store_mb(pwq->triggered, 0);
0259 
0260     return rc;
0261 }
0262 
0263 /**
0264  * poll_select_set_timeout - helper function to setup the timeout value
0265  * @to:     pointer to timespec64 variable for the final timeout
0266  * @sec:    seconds (from user space)
0267  * @nsec:   nanoseconds (from user space)
0268  *
0269  * Note, we do not use a timespec for the user space value here, That
0270  * way we can use the function for timeval and compat interfaces as well.
0271  *
0272  * Returns -EINVAL if sec/nsec are not normalized. Otherwise 0.
0273  */
0274 int poll_select_set_timeout(struct timespec64 *to, time64_t sec, long nsec)
0275 {
0276     struct timespec64 ts = {.tv_sec = sec, .tv_nsec = nsec};
0277 
0278     if (!timespec64_valid(&ts))
0279         return -EINVAL;
0280 
0281     /* Optimize for the zero timeout value here */
0282     if (!sec && !nsec) {
0283         to->tv_sec = to->tv_nsec = 0;
0284     } else {
0285         ktime_get_ts64(to);
0286         *to = timespec64_add_safe(*to, ts);
0287     }
0288     return 0;
0289 }
0290 
0291 enum poll_time_type {
0292     PT_TIMEVAL = 0,
0293     PT_OLD_TIMEVAL = 1,
0294     PT_TIMESPEC = 2,
0295     PT_OLD_TIMESPEC = 3,
0296 };
0297 
0298 static int poll_select_finish(struct timespec64 *end_time,
0299                   void __user *p,
0300                   enum poll_time_type pt_type, int ret)
0301 {
0302     struct timespec64 rts;
0303 
0304     restore_saved_sigmask_unless(ret == -ERESTARTNOHAND);
0305 
0306     if (!p)
0307         return ret;
0308 
0309     if (current->personality & STICKY_TIMEOUTS)
0310         goto sticky;
0311 
0312     /* No update for zero timeout */
0313     if (!end_time->tv_sec && !end_time->tv_nsec)
0314         return ret;
0315 
0316     ktime_get_ts64(&rts);
0317     rts = timespec64_sub(*end_time, rts);
0318     if (rts.tv_sec < 0)
0319         rts.tv_sec = rts.tv_nsec = 0;
0320 
0321 
0322     switch (pt_type) {
0323     case PT_TIMEVAL:
0324         {
0325             struct __kernel_old_timeval rtv;
0326 
0327             if (sizeof(rtv) > sizeof(rtv.tv_sec) + sizeof(rtv.tv_usec))
0328                 memset(&rtv, 0, sizeof(rtv));
0329             rtv.tv_sec = rts.tv_sec;
0330             rtv.tv_usec = rts.tv_nsec / NSEC_PER_USEC;
0331             if (!copy_to_user(p, &rtv, sizeof(rtv)))
0332                 return ret;
0333         }
0334         break;
0335     case PT_OLD_TIMEVAL:
0336         {
0337             struct old_timeval32 rtv;
0338 
0339             rtv.tv_sec = rts.tv_sec;
0340             rtv.tv_usec = rts.tv_nsec / NSEC_PER_USEC;
0341             if (!copy_to_user(p, &rtv, sizeof(rtv)))
0342                 return ret;
0343         }
0344         break;
0345     case PT_TIMESPEC:
0346         if (!put_timespec64(&rts, p))
0347             return ret;
0348         break;
0349     case PT_OLD_TIMESPEC:
0350         if (!put_old_timespec32(&rts, p))
0351             return ret;
0352         break;
0353     default:
0354         BUG();
0355     }
0356     /*
0357      * If an application puts its timeval in read-only memory, we
0358      * don't want the Linux-specific update to the timeval to
0359      * cause a fault after the select has completed
0360      * successfully. However, because we're not updating the
0361      * timeval, we can't restart the system call.
0362      */
0363 
0364 sticky:
0365     if (ret == -ERESTARTNOHAND)
0366         ret = -EINTR;
0367     return ret;
0368 }
0369 
0370 /*
0371  * Scalable version of the fd_set.
0372  */
0373 
0374 typedef struct {
0375     unsigned long *in, *out, *ex;
0376     unsigned long *res_in, *res_out, *res_ex;
0377 } fd_set_bits;
0378 
0379 /*
0380  * How many longwords for "nr" bits?
0381  */
0382 #define FDS_BITPERLONG  (8*sizeof(long))
0383 #define FDS_LONGS(nr)   (((nr)+FDS_BITPERLONG-1)/FDS_BITPERLONG)
0384 #define FDS_BYTES(nr)   (FDS_LONGS(nr)*sizeof(long))
0385 
0386 /*
0387  * Use "unsigned long" accesses to let user-mode fd_set's be long-aligned.
0388  */
0389 static inline
0390 int get_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset)
0391 {
0392     nr = FDS_BYTES(nr);
0393     if (ufdset)
0394         return copy_from_user(fdset, ufdset, nr) ? -EFAULT : 0;
0395 
0396     memset(fdset, 0, nr);
0397     return 0;
0398 }
0399 
0400 static inline unsigned long __must_check
0401 set_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset)
0402 {
0403     if (ufdset)
0404         return __copy_to_user(ufdset, fdset, FDS_BYTES(nr));
0405     return 0;
0406 }
0407 
0408 static inline
0409 void zero_fd_set(unsigned long nr, unsigned long *fdset)
0410 {
0411     memset(fdset, 0, FDS_BYTES(nr));
0412 }
0413 
0414 #define FDS_IN(fds, n)      (fds->in + n)
0415 #define FDS_OUT(fds, n)     (fds->out + n)
0416 #define FDS_EX(fds, n)      (fds->ex + n)
0417 
0418 #define BITS(fds, n)    (*FDS_IN(fds, n)|*FDS_OUT(fds, n)|*FDS_EX(fds, n))
0419 
0420 static int max_select_fd(unsigned long n, fd_set_bits *fds)
0421 {
0422     unsigned long *open_fds;
0423     unsigned long set;
0424     int max;
0425     struct fdtable *fdt;
0426 
0427     /* handle last in-complete long-word first */
0428     set = ~(~0UL << (n & (BITS_PER_LONG-1)));
0429     n /= BITS_PER_LONG;
0430     fdt = files_fdtable(current->files);
0431     open_fds = fdt->open_fds + n;
0432     max = 0;
0433     if (set) {
0434         set &= BITS(fds, n);
0435         if (set) {
0436             if (!(set & ~*open_fds))
0437                 goto get_max;
0438             return -EBADF;
0439         }
0440     }
0441     while (n) {
0442         open_fds--;
0443         n--;
0444         set = BITS(fds, n);
0445         if (!set)
0446             continue;
0447         if (set & ~*open_fds)
0448             return -EBADF;
0449         if (max)
0450             continue;
0451 get_max:
0452         do {
0453             max++;
0454             set >>= 1;
0455         } while (set);
0456         max += n * BITS_PER_LONG;
0457     }
0458 
0459     return max;
0460 }
0461 
0462 #define POLLIN_SET (EPOLLRDNORM | EPOLLRDBAND | EPOLLIN | EPOLLHUP | EPOLLERR |\
0463             EPOLLNVAL)
0464 #define POLLOUT_SET (EPOLLWRBAND | EPOLLWRNORM | EPOLLOUT | EPOLLERR |\
0465              EPOLLNVAL)
0466 #define POLLEX_SET (EPOLLPRI | EPOLLNVAL)
0467 
0468 static inline void wait_key_set(poll_table *wait, unsigned long in,
0469                 unsigned long out, unsigned long bit,
0470                 __poll_t ll_flag)
0471 {
0472     wait->_key = POLLEX_SET | ll_flag;
0473     if (in & bit)
0474         wait->_key |= POLLIN_SET;
0475     if (out & bit)
0476         wait->_key |= POLLOUT_SET;
0477 }
0478 
0479 static int do_select(int n, fd_set_bits *fds, struct timespec64 *end_time)
0480 {
0481     ktime_t expire, *to = NULL;
0482     struct poll_wqueues table;
0483     poll_table *wait;
0484     int retval, i, timed_out = 0;
0485     u64 slack = 0;
0486     __poll_t busy_flag = net_busy_loop_on() ? POLL_BUSY_LOOP : 0;
0487     unsigned long busy_start = 0;
0488 
0489     rcu_read_lock();
0490     retval = max_select_fd(n, fds);
0491     rcu_read_unlock();
0492 
0493     if (retval < 0)
0494         return retval;
0495     n = retval;
0496 
0497     poll_initwait(&table);
0498     wait = &table.pt;
0499     if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {
0500         wait->_qproc = NULL;
0501         timed_out = 1;
0502     }
0503 
0504     if (end_time && !timed_out)
0505         slack = select_estimate_accuracy(end_time);
0506 
0507     retval = 0;
0508     for (;;) {
0509         unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
0510         bool can_busy_loop = false;
0511 
0512         inp = fds->in; outp = fds->out; exp = fds->ex;
0513         rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;
0514 
0515         for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
0516             unsigned long in, out, ex, all_bits, bit = 1, j;
0517             unsigned long res_in = 0, res_out = 0, res_ex = 0;
0518             __poll_t mask;
0519 
0520             in = *inp++; out = *outp++; ex = *exp++;
0521             all_bits = in | out | ex;
0522             if (all_bits == 0) {
0523                 i += BITS_PER_LONG;
0524                 continue;
0525             }
0526 
0527             for (j = 0; j < BITS_PER_LONG; ++j, ++i, bit <<= 1) {
0528                 struct fd f;
0529                 if (i >= n)
0530                     break;
0531                 if (!(bit & all_bits))
0532                     continue;
0533                 mask = EPOLLNVAL;
0534                 f = fdget(i);
0535                 if (f.file) {
0536                     wait_key_set(wait, in, out, bit,
0537                              busy_flag);
0538                     mask = vfs_poll(f.file, wait);
0539 
0540                     fdput(f);
0541                 }
0542                 if ((mask & POLLIN_SET) && (in & bit)) {
0543                     res_in |= bit;
0544                     retval++;
0545                     wait->_qproc = NULL;
0546                 }
0547                 if ((mask & POLLOUT_SET) && (out & bit)) {
0548                     res_out |= bit;
0549                     retval++;
0550                     wait->_qproc = NULL;
0551                 }
0552                 if ((mask & POLLEX_SET) && (ex & bit)) {
0553                     res_ex |= bit;
0554                     retval++;
0555                     wait->_qproc = NULL;
0556                 }
0557                 /* got something, stop busy polling */
0558                 if (retval) {
0559                     can_busy_loop = false;
0560                     busy_flag = 0;
0561 
0562                 /*
0563                  * only remember a returned
0564                  * POLL_BUSY_LOOP if we asked for it
0565                  */
0566                 } else if (busy_flag & mask)
0567                     can_busy_loop = true;
0568 
0569             }
0570             if (res_in)
0571                 *rinp = res_in;
0572             if (res_out)
0573                 *routp = res_out;
0574             if (res_ex)
0575                 *rexp = res_ex;
0576             cond_resched();
0577         }
0578         wait->_qproc = NULL;
0579         if (retval || timed_out || signal_pending(current))
0580             break;
0581         if (table.error) {
0582             retval = table.error;
0583             break;
0584         }
0585 
0586         /* only if found POLL_BUSY_LOOP sockets && not out of time */
0587         if (can_busy_loop && !need_resched()) {
0588             if (!busy_start) {
0589                 busy_start = busy_loop_current_time();
0590                 continue;
0591             }
0592             if (!busy_loop_timeout(busy_start))
0593                 continue;
0594         }
0595         busy_flag = 0;
0596 
0597         /*
0598          * If this is the first loop and we have a timeout
0599          * given, then we convert to ktime_t and set the to
0600          * pointer to the expiry value.
0601          */
0602         if (end_time && !to) {
0603             expire = timespec64_to_ktime(*end_time);
0604             to = &expire;
0605         }
0606 
0607         if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE,
0608                        to, slack))
0609             timed_out = 1;
0610     }
0611 
0612     poll_freewait(&table);
0613 
0614     return retval;
0615 }
0616 
0617 /*
0618  * We can actually return ERESTARTSYS instead of EINTR, but I'd
0619  * like to be certain this leads to no problems. So I return
0620  * EINTR just for safety.
0621  *
0622  * Update: ERESTARTSYS breaks at least the xview clock binary, so
0623  * I'm trying ERESTARTNOHAND which restart only when you want to.
0624  */
0625 int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
0626                fd_set __user *exp, struct timespec64 *end_time)
0627 {
0628     fd_set_bits fds;
0629     void *bits;
0630     int ret, max_fds;
0631     size_t size, alloc_size;
0632     struct fdtable *fdt;
0633     /* Allocate small arguments on the stack to save memory and be faster */
0634     long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
0635 
0636     ret = -EINVAL;
0637     if (n < 0)
0638         goto out_nofds;
0639 
0640     /* max_fds can increase, so grab it once to avoid race */
0641     rcu_read_lock();
0642     fdt = files_fdtable(current->files);
0643     max_fds = fdt->max_fds;
0644     rcu_read_unlock();
0645     if (n > max_fds)
0646         n = max_fds;
0647 
0648     /*
0649      * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
0650      * since we used fdset we need to allocate memory in units of
0651      * long-words. 
0652      */
0653     size = FDS_BYTES(n);
0654     bits = stack_fds;
0655     if (size > sizeof(stack_fds) / 6) {
0656         /* Not enough space in on-stack array; must use kmalloc */
0657         ret = -ENOMEM;
0658         if (size > (SIZE_MAX / 6))
0659             goto out_nofds;
0660 
0661         alloc_size = 6 * size;
0662         bits = kvmalloc(alloc_size, GFP_KERNEL);
0663         if (!bits)
0664             goto out_nofds;
0665     }
0666     fds.in      = bits;
0667     fds.out     = bits +   size;
0668     fds.ex      = bits + 2*size;
0669     fds.res_in  = bits + 3*size;
0670     fds.res_out = bits + 4*size;
0671     fds.res_ex  = bits + 5*size;
0672 
0673     if ((ret = get_fd_set(n, inp, fds.in)) ||
0674         (ret = get_fd_set(n, outp, fds.out)) ||
0675         (ret = get_fd_set(n, exp, fds.ex)))
0676         goto out;
0677     zero_fd_set(n, fds.res_in);
0678     zero_fd_set(n, fds.res_out);
0679     zero_fd_set(n, fds.res_ex);
0680 
0681     ret = do_select(n, &fds, end_time);
0682 
0683     if (ret < 0)
0684         goto out;
0685     if (!ret) {
0686         ret = -ERESTARTNOHAND;
0687         if (signal_pending(current))
0688             goto out;
0689         ret = 0;
0690     }
0691 
0692     if (set_fd_set(n, inp, fds.res_in) ||
0693         set_fd_set(n, outp, fds.res_out) ||
0694         set_fd_set(n, exp, fds.res_ex))
0695         ret = -EFAULT;
0696 
0697 out:
0698     if (bits != stack_fds)
0699         kvfree(bits);
0700 out_nofds:
0701     return ret;
0702 }
0703 
0704 static int kern_select(int n, fd_set __user *inp, fd_set __user *outp,
0705                fd_set __user *exp, struct __kernel_old_timeval __user *tvp)
0706 {
0707     struct timespec64 end_time, *to = NULL;
0708     struct __kernel_old_timeval tv;
0709     int ret;
0710 
0711     if (tvp) {
0712         if (copy_from_user(&tv, tvp, sizeof(tv)))
0713             return -EFAULT;
0714 
0715         to = &end_time;
0716         if (poll_select_set_timeout(to,
0717                 tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),
0718                 (tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))
0719             return -EINVAL;
0720     }
0721 
0722     ret = core_sys_select(n, inp, outp, exp, to);
0723     return poll_select_finish(&end_time, tvp, PT_TIMEVAL, ret);
0724 }
0725 
0726 SYSCALL_DEFINE5(select, int, n, fd_set __user *, inp, fd_set __user *, outp,
0727         fd_set __user *, exp, struct __kernel_old_timeval __user *, tvp)
0728 {
0729     return kern_select(n, inp, outp, exp, tvp);
0730 }
0731 
0732 static long do_pselect(int n, fd_set __user *inp, fd_set __user *outp,
0733                fd_set __user *exp, void __user *tsp,
0734                const sigset_t __user *sigmask, size_t sigsetsize,
0735                enum poll_time_type type)
0736 {
0737     struct timespec64 ts, end_time, *to = NULL;
0738     int ret;
0739 
0740     if (tsp) {
0741         switch (type) {
0742         case PT_TIMESPEC:
0743             if (get_timespec64(&ts, tsp))
0744                 return -EFAULT;
0745             break;
0746         case PT_OLD_TIMESPEC:
0747             if (get_old_timespec32(&ts, tsp))
0748                 return -EFAULT;
0749             break;
0750         default:
0751             BUG();
0752         }
0753 
0754         to = &end_time;
0755         if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
0756             return -EINVAL;
0757     }
0758 
0759     ret = set_user_sigmask(sigmask, sigsetsize);
0760     if (ret)
0761         return ret;
0762 
0763     ret = core_sys_select(n, inp, outp, exp, to);
0764     return poll_select_finish(&end_time, tsp, type, ret);
0765 }
0766 
0767 /*
0768  * Most architectures can't handle 7-argument syscalls. So we provide a
0769  * 6-argument version where the sixth argument is a pointer to a structure
0770  * which has a pointer to the sigset_t itself followed by a size_t containing
0771  * the sigset size.
0772  */
0773 struct sigset_argpack {
0774     sigset_t __user *p;
0775     size_t size;
0776 };
0777 
0778 static inline int get_sigset_argpack(struct sigset_argpack *to,
0779                      struct sigset_argpack __user *from)
0780 {
0781     // the path is hot enough for overhead of copy_from_user() to matter
0782     if (from) {
0783         if (!user_read_access_begin(from, sizeof(*from)))
0784             return -EFAULT;
0785         unsafe_get_user(to->p, &from->p, Efault);
0786         unsafe_get_user(to->size, &from->size, Efault);
0787         user_read_access_end();
0788     }
0789     return 0;
0790 Efault:
0791     user_access_end();
0792     return -EFAULT;
0793 }
0794 
0795 SYSCALL_DEFINE6(pselect6, int, n, fd_set __user *, inp, fd_set __user *, outp,
0796         fd_set __user *, exp, struct __kernel_timespec __user *, tsp,
0797         void __user *, sig)
0798 {
0799     struct sigset_argpack x = {NULL, 0};
0800 
0801     if (get_sigset_argpack(&x, sig))
0802         return -EFAULT;
0803 
0804     return do_pselect(n, inp, outp, exp, tsp, x.p, x.size, PT_TIMESPEC);
0805 }
0806 
0807 #if defined(CONFIG_COMPAT_32BIT_TIME) && !defined(CONFIG_64BIT)
0808 
0809 SYSCALL_DEFINE6(pselect6_time32, int, n, fd_set __user *, inp, fd_set __user *, outp,
0810         fd_set __user *, exp, struct old_timespec32 __user *, tsp,
0811         void __user *, sig)
0812 {
0813     struct sigset_argpack x = {NULL, 0};
0814 
0815     if (get_sigset_argpack(&x, sig))
0816         return -EFAULT;
0817 
0818     return do_pselect(n, inp, outp, exp, tsp, x.p, x.size, PT_OLD_TIMESPEC);
0819 }
0820 
0821 #endif
0822 
0823 #ifdef __ARCH_WANT_SYS_OLD_SELECT
0824 struct sel_arg_struct {
0825     unsigned long n;
0826     fd_set __user *inp, *outp, *exp;
0827     struct __kernel_old_timeval __user *tvp;
0828 };
0829 
0830 SYSCALL_DEFINE1(old_select, struct sel_arg_struct __user *, arg)
0831 {
0832     struct sel_arg_struct a;
0833 
0834     if (copy_from_user(&a, arg, sizeof(a)))
0835         return -EFAULT;
0836     return kern_select(a.n, a.inp, a.outp, a.exp, a.tvp);
0837 }
0838 #endif
0839 
0840 struct poll_list {
0841     struct poll_list *next;
0842     int len;
0843     struct pollfd entries[];
0844 };
0845 
0846 #define POLLFD_PER_PAGE  ((PAGE_SIZE-sizeof(struct poll_list)) / sizeof(struct pollfd))
0847 
0848 /*
0849  * Fish for pollable events on the pollfd->fd file descriptor. We're only
0850  * interested in events matching the pollfd->events mask, and the result
0851  * matching that mask is both recorded in pollfd->revents and returned. The
0852  * pwait poll_table will be used by the fd-provided poll handler for waiting,
0853  * if pwait->_qproc is non-NULL.
0854  */
0855 static inline __poll_t do_pollfd(struct pollfd *pollfd, poll_table *pwait,
0856                      bool *can_busy_poll,
0857                      __poll_t busy_flag)
0858 {
0859     int fd = pollfd->fd;
0860     __poll_t mask = 0, filter;
0861     struct fd f;
0862 
0863     if (fd < 0)
0864         goto out;
0865     mask = EPOLLNVAL;
0866     f = fdget(fd);
0867     if (!f.file)
0868         goto out;
0869 
0870     /* userland u16 ->events contains POLL... bitmap */
0871     filter = demangle_poll(pollfd->events) | EPOLLERR | EPOLLHUP;
0872     pwait->_key = filter | busy_flag;
0873     mask = vfs_poll(f.file, pwait);
0874     if (mask & busy_flag)
0875         *can_busy_poll = true;
0876     mask &= filter;     /* Mask out unneeded events. */
0877     fdput(f);
0878 
0879 out:
0880     /* ... and so does ->revents */
0881     pollfd->revents = mangle_poll(mask);
0882     return mask;
0883 }
0884 
0885 static int do_poll(struct poll_list *list, struct poll_wqueues *wait,
0886            struct timespec64 *end_time)
0887 {
0888     poll_table* pt = &wait->pt;
0889     ktime_t expire, *to = NULL;
0890     int timed_out = 0, count = 0;
0891     u64 slack = 0;
0892     __poll_t busy_flag = net_busy_loop_on() ? POLL_BUSY_LOOP : 0;
0893     unsigned long busy_start = 0;
0894 
0895     /* Optimise the no-wait case */
0896     if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {
0897         pt->_qproc = NULL;
0898         timed_out = 1;
0899     }
0900 
0901     if (end_time && !timed_out)
0902         slack = select_estimate_accuracy(end_time);
0903 
0904     for (;;) {
0905         struct poll_list *walk;
0906         bool can_busy_loop = false;
0907 
0908         for (walk = list; walk != NULL; walk = walk->next) {
0909             struct pollfd * pfd, * pfd_end;
0910 
0911             pfd = walk->entries;
0912             pfd_end = pfd + walk->len;
0913             for (; pfd != pfd_end; pfd++) {
0914                 /*
0915                  * Fish for events. If we found one, record it
0916                  * and kill poll_table->_qproc, so we don't
0917                  * needlessly register any other waiters after
0918                  * this. They'll get immediately deregistered
0919                  * when we break out and return.
0920                  */
0921                 if (do_pollfd(pfd, pt, &can_busy_loop,
0922                           busy_flag)) {
0923                     count++;
0924                     pt->_qproc = NULL;
0925                     /* found something, stop busy polling */
0926                     busy_flag = 0;
0927                     can_busy_loop = false;
0928                 }
0929             }
0930         }
0931         /*
0932          * All waiters have already been registered, so don't provide
0933          * a poll_table->_qproc to them on the next loop iteration.
0934          */
0935         pt->_qproc = NULL;
0936         if (!count) {
0937             count = wait->error;
0938             if (signal_pending(current))
0939                 count = -ERESTARTNOHAND;
0940         }
0941         if (count || timed_out)
0942             break;
0943 
0944         /* only if found POLL_BUSY_LOOP sockets && not out of time */
0945         if (can_busy_loop && !need_resched()) {
0946             if (!busy_start) {
0947                 busy_start = busy_loop_current_time();
0948                 continue;
0949             }
0950             if (!busy_loop_timeout(busy_start))
0951                 continue;
0952         }
0953         busy_flag = 0;
0954 
0955         /*
0956          * If this is the first loop and we have a timeout
0957          * given, then we convert to ktime_t and set the to
0958          * pointer to the expiry value.
0959          */
0960         if (end_time && !to) {
0961             expire = timespec64_to_ktime(*end_time);
0962             to = &expire;
0963         }
0964 
0965         if (!poll_schedule_timeout(wait, TASK_INTERRUPTIBLE, to, slack))
0966             timed_out = 1;
0967     }
0968     return count;
0969 }
0970 
0971 #define N_STACK_PPS ((sizeof(stack_pps) - sizeof(struct poll_list))  / \
0972             sizeof(struct pollfd))
0973 
0974 static int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds,
0975         struct timespec64 *end_time)
0976 {
0977     struct poll_wqueues table;
0978     int err = -EFAULT, fdcount, len;
0979     /* Allocate small arguments on the stack to save memory and be
0980        faster - use long to make sure the buffer is aligned properly
0981        on 64 bit archs to avoid unaligned access */
0982     long stack_pps[POLL_STACK_ALLOC/sizeof(long)];
0983     struct poll_list *const head = (struct poll_list *)stack_pps;
0984     struct poll_list *walk = head;
0985     unsigned long todo = nfds;
0986 
0987     if (nfds > rlimit(RLIMIT_NOFILE))
0988         return -EINVAL;
0989 
0990     len = min_t(unsigned int, nfds, N_STACK_PPS);
0991     for (;;) {
0992         walk->next = NULL;
0993         walk->len = len;
0994         if (!len)
0995             break;
0996 
0997         if (copy_from_user(walk->entries, ufds + nfds-todo,
0998                     sizeof(struct pollfd) * walk->len))
0999             goto out_fds;
1000 
1001         todo -= walk->len;
1002         if (!todo)
1003             break;
1004 
1005         len = min(todo, POLLFD_PER_PAGE);
1006         walk = walk->next = kmalloc(struct_size(walk, entries, len),
1007                         GFP_KERNEL);
1008         if (!walk) {
1009             err = -ENOMEM;
1010             goto out_fds;
1011         }
1012     }
1013 
1014     poll_initwait(&table);
1015     fdcount = do_poll(head, &table, end_time);
1016     poll_freewait(&table);
1017 
1018     if (!user_write_access_begin(ufds, nfds * sizeof(*ufds)))
1019         goto out_fds;
1020 
1021     for (walk = head; walk; walk = walk->next) {
1022         struct pollfd *fds = walk->entries;
1023         int j;
1024 
1025         for (j = walk->len; j; fds++, ufds++, j--)
1026             unsafe_put_user(fds->revents, &ufds->revents, Efault);
1027     }
1028     user_write_access_end();
1029 
1030     err = fdcount;
1031 out_fds:
1032     walk = head->next;
1033     while (walk) {
1034         struct poll_list *pos = walk;
1035         walk = walk->next;
1036         kfree(pos);
1037     }
1038 
1039     return err;
1040 
1041 Efault:
1042     user_write_access_end();
1043     err = -EFAULT;
1044     goto out_fds;
1045 }
1046 
1047 static long do_restart_poll(struct restart_block *restart_block)
1048 {
1049     struct pollfd __user *ufds = restart_block->poll.ufds;
1050     int nfds = restart_block->poll.nfds;
1051     struct timespec64 *to = NULL, end_time;
1052     int ret;
1053 
1054     if (restart_block->poll.has_timeout) {
1055         end_time.tv_sec = restart_block->poll.tv_sec;
1056         end_time.tv_nsec = restart_block->poll.tv_nsec;
1057         to = &end_time;
1058     }
1059 
1060     ret = do_sys_poll(ufds, nfds, to);
1061 
1062     if (ret == -ERESTARTNOHAND)
1063         ret = set_restart_fn(restart_block, do_restart_poll);
1064 
1065     return ret;
1066 }
1067 
1068 SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds,
1069         int, timeout_msecs)
1070 {
1071     struct timespec64 end_time, *to = NULL;
1072     int ret;
1073 
1074     if (timeout_msecs >= 0) {
1075         to = &end_time;
1076         poll_select_set_timeout(to, timeout_msecs / MSEC_PER_SEC,
1077             NSEC_PER_MSEC * (timeout_msecs % MSEC_PER_SEC));
1078     }
1079 
1080     ret = do_sys_poll(ufds, nfds, to);
1081 
1082     if (ret == -ERESTARTNOHAND) {
1083         struct restart_block *restart_block;
1084 
1085         restart_block = &current->restart_block;
1086         restart_block->poll.ufds = ufds;
1087         restart_block->poll.nfds = nfds;
1088 
1089         if (timeout_msecs >= 0) {
1090             restart_block->poll.tv_sec = end_time.tv_sec;
1091             restart_block->poll.tv_nsec = end_time.tv_nsec;
1092             restart_block->poll.has_timeout = 1;
1093         } else
1094             restart_block->poll.has_timeout = 0;
1095 
1096         ret = set_restart_fn(restart_block, do_restart_poll);
1097     }
1098     return ret;
1099 }
1100 
1101 SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds, unsigned int, nfds,
1102         struct __kernel_timespec __user *, tsp, const sigset_t __user *, sigmask,
1103         size_t, sigsetsize)
1104 {
1105     struct timespec64 ts, end_time, *to = NULL;
1106     int ret;
1107 
1108     if (tsp) {
1109         if (get_timespec64(&ts, tsp))
1110             return -EFAULT;
1111 
1112         to = &end_time;
1113         if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
1114             return -EINVAL;
1115     }
1116 
1117     ret = set_user_sigmask(sigmask, sigsetsize);
1118     if (ret)
1119         return ret;
1120 
1121     ret = do_sys_poll(ufds, nfds, to);
1122     return poll_select_finish(&end_time, tsp, PT_TIMESPEC, ret);
1123 }
1124 
1125 #if defined(CONFIG_COMPAT_32BIT_TIME) && !defined(CONFIG_64BIT)
1126 
1127 SYSCALL_DEFINE5(ppoll_time32, struct pollfd __user *, ufds, unsigned int, nfds,
1128         struct old_timespec32 __user *, tsp, const sigset_t __user *, sigmask,
1129         size_t, sigsetsize)
1130 {
1131     struct timespec64 ts, end_time, *to = NULL;
1132     int ret;
1133 
1134     if (tsp) {
1135         if (get_old_timespec32(&ts, tsp))
1136             return -EFAULT;
1137 
1138         to = &end_time;
1139         if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
1140             return -EINVAL;
1141     }
1142 
1143     ret = set_user_sigmask(sigmask, sigsetsize);
1144     if (ret)
1145         return ret;
1146 
1147     ret = do_sys_poll(ufds, nfds, to);
1148     return poll_select_finish(&end_time, tsp, PT_OLD_TIMESPEC, ret);
1149 }
1150 #endif
1151 
1152 #ifdef CONFIG_COMPAT
1153 #define __COMPAT_NFDBITS       (8 * sizeof(compat_ulong_t))
1154 
1155 /*
1156  * Ooo, nasty.  We need here to frob 32-bit unsigned longs to
1157  * 64-bit unsigned longs.
1158  */
1159 static
1160 int compat_get_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
1161             unsigned long *fdset)
1162 {
1163     if (ufdset) {
1164         return compat_get_bitmap(fdset, ufdset, nr);
1165     } else {
1166         zero_fd_set(nr, fdset);
1167         return 0;
1168     }
1169 }
1170 
1171 static
1172 int compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
1173               unsigned long *fdset)
1174 {
1175     if (!ufdset)
1176         return 0;
1177     return compat_put_bitmap(ufdset, fdset, nr);
1178 }
1179 
1180 
1181 /*
1182  * This is a virtual copy of sys_select from fs/select.c and probably
1183  * should be compared to it from time to time
1184  */
1185 
1186 /*
1187  * We can actually return ERESTARTSYS instead of EINTR, but I'd
1188  * like to be certain this leads to no problems. So I return
1189  * EINTR just for safety.
1190  *
1191  * Update: ERESTARTSYS breaks at least the xview clock binary, so
1192  * I'm trying ERESTARTNOHAND which restart only when you want to.
1193  */
1194 static int compat_core_sys_select(int n, compat_ulong_t __user *inp,
1195     compat_ulong_t __user *outp, compat_ulong_t __user *exp,
1196     struct timespec64 *end_time)
1197 {
1198     fd_set_bits fds;
1199     void *bits;
1200     int size, max_fds, ret = -EINVAL;
1201     struct fdtable *fdt;
1202     long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
1203 
1204     if (n < 0)
1205         goto out_nofds;
1206 
1207     /* max_fds can increase, so grab it once to avoid race */
1208     rcu_read_lock();
1209     fdt = files_fdtable(current->files);
1210     max_fds = fdt->max_fds;
1211     rcu_read_unlock();
1212     if (n > max_fds)
1213         n = max_fds;
1214 
1215     /*
1216      * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
1217      * since we used fdset we need to allocate memory in units of
1218      * long-words.
1219      */
1220     size = FDS_BYTES(n);
1221     bits = stack_fds;
1222     if (size > sizeof(stack_fds) / 6) {
1223         bits = kmalloc_array(6, size, GFP_KERNEL);
1224         ret = -ENOMEM;
1225         if (!bits)
1226             goto out_nofds;
1227     }
1228     fds.in      = (unsigned long *)  bits;
1229     fds.out     = (unsigned long *) (bits +   size);
1230     fds.ex      = (unsigned long *) (bits + 2*size);
1231     fds.res_in  = (unsigned long *) (bits + 3*size);
1232     fds.res_out = (unsigned long *) (bits + 4*size);
1233     fds.res_ex  = (unsigned long *) (bits + 5*size);
1234 
1235     if ((ret = compat_get_fd_set(n, inp, fds.in)) ||
1236         (ret = compat_get_fd_set(n, outp, fds.out)) ||
1237         (ret = compat_get_fd_set(n, exp, fds.ex)))
1238         goto out;
1239     zero_fd_set(n, fds.res_in);
1240     zero_fd_set(n, fds.res_out);
1241     zero_fd_set(n, fds.res_ex);
1242 
1243     ret = do_select(n, &fds, end_time);
1244 
1245     if (ret < 0)
1246         goto out;
1247     if (!ret) {
1248         ret = -ERESTARTNOHAND;
1249         if (signal_pending(current))
1250             goto out;
1251         ret = 0;
1252     }
1253 
1254     if (compat_set_fd_set(n, inp, fds.res_in) ||
1255         compat_set_fd_set(n, outp, fds.res_out) ||
1256         compat_set_fd_set(n, exp, fds.res_ex))
1257         ret = -EFAULT;
1258 out:
1259     if (bits != stack_fds)
1260         kfree(bits);
1261 out_nofds:
1262     return ret;
1263 }
1264 
1265 static int do_compat_select(int n, compat_ulong_t __user *inp,
1266     compat_ulong_t __user *outp, compat_ulong_t __user *exp,
1267     struct old_timeval32 __user *tvp)
1268 {
1269     struct timespec64 end_time, *to = NULL;
1270     struct old_timeval32 tv;
1271     int ret;
1272 
1273     if (tvp) {
1274         if (copy_from_user(&tv, tvp, sizeof(tv)))
1275             return -EFAULT;
1276 
1277         to = &end_time;
1278         if (poll_select_set_timeout(to,
1279                 tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),
1280                 (tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))
1281             return -EINVAL;
1282     }
1283 
1284     ret = compat_core_sys_select(n, inp, outp, exp, to);
1285     return poll_select_finish(&end_time, tvp, PT_OLD_TIMEVAL, ret);
1286 }
1287 
1288 COMPAT_SYSCALL_DEFINE5(select, int, n, compat_ulong_t __user *, inp,
1289     compat_ulong_t __user *, outp, compat_ulong_t __user *, exp,
1290     struct old_timeval32 __user *, tvp)
1291 {
1292     return do_compat_select(n, inp, outp, exp, tvp);
1293 }
1294 
1295 struct compat_sel_arg_struct {
1296     compat_ulong_t n;
1297     compat_uptr_t inp;
1298     compat_uptr_t outp;
1299     compat_uptr_t exp;
1300     compat_uptr_t tvp;
1301 };
1302 
1303 COMPAT_SYSCALL_DEFINE1(old_select, struct compat_sel_arg_struct __user *, arg)
1304 {
1305     struct compat_sel_arg_struct a;
1306 
1307     if (copy_from_user(&a, arg, sizeof(a)))
1308         return -EFAULT;
1309     return do_compat_select(a.n, compat_ptr(a.inp), compat_ptr(a.outp),
1310                 compat_ptr(a.exp), compat_ptr(a.tvp));
1311 }
1312 
1313 static long do_compat_pselect(int n, compat_ulong_t __user *inp,
1314     compat_ulong_t __user *outp, compat_ulong_t __user *exp,
1315     void __user *tsp, compat_sigset_t __user *sigmask,
1316     compat_size_t sigsetsize, enum poll_time_type type)
1317 {
1318     struct timespec64 ts, end_time, *to = NULL;
1319     int ret;
1320 
1321     if (tsp) {
1322         switch (type) {
1323         case PT_OLD_TIMESPEC:
1324             if (get_old_timespec32(&ts, tsp))
1325                 return -EFAULT;
1326             break;
1327         case PT_TIMESPEC:
1328             if (get_timespec64(&ts, tsp))
1329                 return -EFAULT;
1330             break;
1331         default:
1332             BUG();
1333         }
1334 
1335         to = &end_time;
1336         if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
1337             return -EINVAL;
1338     }
1339 
1340     ret = set_compat_user_sigmask(sigmask, sigsetsize);
1341     if (ret)
1342         return ret;
1343 
1344     ret = compat_core_sys_select(n, inp, outp, exp, to);
1345     return poll_select_finish(&end_time, tsp, type, ret);
1346 }
1347 
1348 struct compat_sigset_argpack {
1349     compat_uptr_t p;
1350     compat_size_t size;
1351 };
1352 static inline int get_compat_sigset_argpack(struct compat_sigset_argpack *to,
1353                         struct compat_sigset_argpack __user *from)
1354 {
1355     if (from) {
1356         if (!user_read_access_begin(from, sizeof(*from)))
1357             return -EFAULT;
1358         unsafe_get_user(to->p, &from->p, Efault);
1359         unsafe_get_user(to->size, &from->size, Efault);
1360         user_read_access_end();
1361     }
1362     return 0;
1363 Efault:
1364     user_access_end();
1365     return -EFAULT;
1366 }
1367 
1368 COMPAT_SYSCALL_DEFINE6(pselect6_time64, int, n, compat_ulong_t __user *, inp,
1369     compat_ulong_t __user *, outp, compat_ulong_t __user *, exp,
1370     struct __kernel_timespec __user *, tsp, void __user *, sig)
1371 {
1372     struct compat_sigset_argpack x = {0, 0};
1373 
1374     if (get_compat_sigset_argpack(&x, sig))
1375         return -EFAULT;
1376 
1377     return do_compat_pselect(n, inp, outp, exp, tsp, compat_ptr(x.p),
1378                  x.size, PT_TIMESPEC);
1379 }
1380 
1381 #if defined(CONFIG_COMPAT_32BIT_TIME)
1382 
1383 COMPAT_SYSCALL_DEFINE6(pselect6_time32, int, n, compat_ulong_t __user *, inp,
1384     compat_ulong_t __user *, outp, compat_ulong_t __user *, exp,
1385     struct old_timespec32 __user *, tsp, void __user *, sig)
1386 {
1387     struct compat_sigset_argpack x = {0, 0};
1388 
1389     if (get_compat_sigset_argpack(&x, sig))
1390         return -EFAULT;
1391 
1392     return do_compat_pselect(n, inp, outp, exp, tsp, compat_ptr(x.p),
1393                  x.size, PT_OLD_TIMESPEC);
1394 }
1395 
1396 #endif
1397 
1398 #if defined(CONFIG_COMPAT_32BIT_TIME)
1399 COMPAT_SYSCALL_DEFINE5(ppoll_time32, struct pollfd __user *, ufds,
1400     unsigned int,  nfds, struct old_timespec32 __user *, tsp,
1401     const compat_sigset_t __user *, sigmask, compat_size_t, sigsetsize)
1402 {
1403     struct timespec64 ts, end_time, *to = NULL;
1404     int ret;
1405 
1406     if (tsp) {
1407         if (get_old_timespec32(&ts, tsp))
1408             return -EFAULT;
1409 
1410         to = &end_time;
1411         if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
1412             return -EINVAL;
1413     }
1414 
1415     ret = set_compat_user_sigmask(sigmask, sigsetsize);
1416     if (ret)
1417         return ret;
1418 
1419     ret = do_sys_poll(ufds, nfds, to);
1420     return poll_select_finish(&end_time, tsp, PT_OLD_TIMESPEC, ret);
1421 }
1422 #endif
1423 
1424 /* New compat syscall for 64 bit time_t*/
1425 COMPAT_SYSCALL_DEFINE5(ppoll_time64, struct pollfd __user *, ufds,
1426     unsigned int,  nfds, struct __kernel_timespec __user *, tsp,
1427     const compat_sigset_t __user *, sigmask, compat_size_t, sigsetsize)
1428 {
1429     struct timespec64 ts, end_time, *to = NULL;
1430     int ret;
1431 
1432     if (tsp) {
1433         if (get_timespec64(&ts, tsp))
1434             return -EFAULT;
1435 
1436         to = &end_time;
1437         if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
1438             return -EINVAL;
1439     }
1440 
1441     ret = set_compat_user_sigmask(sigmask, sigsetsize);
1442     if (ret)
1443         return ret;
1444 
1445     ret = do_sys_poll(ufds, nfds, to);
1446     return poll_select_finish(&end_time, tsp, PT_TIMESPEC, ret);
1447 }
1448 
1449 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!