LCOV - code coverage report
Current view: top level - fs - select.c (source / functions) Hit Total Coverage
Test: Real Lines: 285 375 76.0 %
Date: 2020-10-17 15:46:16 Functions: 0 35 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * This file contains the procedures for the handling of select and poll
       4                 :            :  *
       5                 :            :  * Created for Linux based loosely upon Mathius Lattner's minix
       6                 :            :  * patches by Peter MacDonald. Heavily edited by Linus.
       7                 :            :  *
       8                 :            :  *  4 February 1994
       9                 :            :  *     COFF/ELF binary emulation. If the process has the STICKY_TIMEOUTS
      10                 :            :  *     flag set in its personality we do *not* modify the given timeout
      11                 :            :  *     parameter to reflect time remaining.
      12                 :            :  *
      13                 :            :  *  24 January 2000
      14                 :            :  *     Changed sys_poll()/do_poll() to use PAGE_SIZE chunk-based allocation 
      15                 :            :  *     of fds to overcome nfds < 16390 descriptors limit (Tigran Aivazian).
      16                 :            :  */
      17                 :            : 
      18                 :            : #include <linux/kernel.h>
      19                 :            : #include <linux/sched/signal.h>
      20                 :            : #include <linux/sched/rt.h>
      21                 :            : #include <linux/syscalls.h>
      22                 :            : #include <linux/export.h>
      23                 :            : #include <linux/slab.h>
      24                 :            : #include <linux/poll.h>
      25                 :            : #include <linux/personality.h> /* for STICKY_TIMEOUTS */
      26                 :            : #include <linux/file.h>
      27                 :            : #include <linux/fdtable.h>
      28                 :            : #include <linux/fs.h>
      29                 :            : #include <linux/rcupdate.h>
      30                 :            : #include <linux/hrtimer.h>
      31                 :            : #include <linux/freezer.h>
      32                 :            : #include <net/busy_poll.h>
      33                 :            : #include <linux/vmalloc.h>
      34                 :            : 
      35                 :            : #include <linux/uaccess.h>
      36                 :            : 
      37                 :            : 
      38                 :            : /*
      39                 :            :  * Estimate expected accuracy in ns from a timeval.
      40                 :            :  *
      41                 :            :  * After quite a bit of churning around, we've settled on
      42                 :            :  * a simple thing of taking 0.1% of the timeout as the
      43                 :            :  * slack, with a cap of 100 msec.
      44                 :            :  * "nice" tasks get a 0.5% slack instead.
      45                 :            :  *
      46                 :            :  * Consider this comment an open invitation to come up with even
      47                 :            :  * better solutions..
      48                 :            :  */
      49                 :            : 
      50                 :            : #define MAX_SLACK       (100 * NSEC_PER_MSEC)
      51                 :            : 
      52                 :          3 : static long __estimate_accuracy(struct timespec64 *tv)
      53                 :            : {
      54                 :            :         long slack;
      55                 :            :         int divfactor = 1000;
      56                 :            : 
      57                 :          3 :         if (tv->tv_sec < 0)
      58                 :            :                 return 0;
      59                 :            : 
      60                 :          3 :         if (task_nice(current) > 0)
      61                 :            :                 divfactor = divfactor / 5;
      62                 :            : 
      63                 :          3 :         if (tv->tv_sec > MAX_SLACK / (NSEC_PER_SEC/divfactor))
      64                 :            :                 return MAX_SLACK;
      65                 :            : 
      66                 :          3 :         slack = tv->tv_nsec / divfactor;
      67                 :          3 :         slack += tv->tv_sec * (NSEC_PER_SEC/divfactor);
      68                 :            : 
      69                 :          3 :         if (slack > MAX_SLACK)
      70                 :            :                 return MAX_SLACK;
      71                 :            : 
      72                 :          3 :         return slack;
      73                 :            : }
      74                 :            : 
      75                 :          3 : u64 select_estimate_accuracy(struct timespec64 *tv)
      76                 :            : {
      77                 :            :         u64 ret;
      78                 :            :         struct timespec64 now;
      79                 :            : 
      80                 :            :         /*
      81                 :            :          * Realtime tasks get a slack of 0 for obvious reasons.
      82                 :            :          */
      83                 :            : 
      84                 :          3 :         if (rt_task(current))
      85                 :            :                 return 0;
      86                 :            : 
      87                 :          3 :         ktime_get_ts64(&now);
      88                 :          3 :         now = timespec64_sub(*tv, now);
      89                 :          3 :         ret = __estimate_accuracy(&now);
      90                 :            :         if (ret < current->timer_slack_ns)
      91                 :            :                 return current->timer_slack_ns;
      92                 :          3 :         return ret;
      93                 :            : }
      94                 :            : 
      95                 :            : 
      96                 :            : 
      97                 :            : struct poll_table_page {
      98                 :            :         struct poll_table_page * next;
      99                 :            :         struct poll_table_entry * entry;
     100                 :            :         struct poll_table_entry entries[0];
     101                 :            : };
     102                 :            : 
     103                 :            : #define POLL_TABLE_FULL(table) \
     104                 :            :         ((unsigned long)((table)->entry+1) > PAGE_SIZE + (unsigned long)(table))
     105                 :            : 
     106                 :            : /*
     107                 :            :  * Ok, Peter made a complicated, but straightforward multiple_wait() function.
     108                 :            :  * I have rewritten this, taking some shortcuts: This code may not be easy to
     109                 :            :  * follow, but it should be free of race-conditions, and it's practical. If you
     110                 :            :  * understand what I'm doing here, then you understand how the linux
     111                 :            :  * sleep/wakeup mechanism works.
     112                 :            :  *
     113                 :            :  * Two very simple procedures, poll_wait() and poll_freewait() make all the
     114                 :            :  * work.  poll_wait() is an inline-function defined in <linux/poll.h>,
     115                 :            :  * as all select/poll functions have to call it to add an entry to the
     116                 :            :  * poll table.
     117                 :            :  */
     118                 :            : static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
     119                 :            :                        poll_table *p);
     120                 :            : 
     121                 :          0 : void poll_initwait(struct poll_wqueues *pwq)
     122                 :            : {
     123                 :            :         init_poll_funcptr(&pwq->pt, __pollwait);
     124                 :          3 :         pwq->polling_task = current;
     125                 :          3 :         pwq->triggered = 0;
     126                 :          3 :         pwq->error = 0;
     127                 :          3 :         pwq->table = NULL;
     128                 :          3 :         pwq->inline_index = 0;
     129                 :          0 : }
     130                 :            : EXPORT_SYMBOL(poll_initwait);
     131                 :            : 
     132                 :          3 : static void free_poll_entry(struct poll_table_entry *entry)
     133                 :            : {
     134                 :          3 :         remove_wait_queue(entry->wait_address, &entry->wait);
     135                 :          3 :         fput(entry->filp);
     136                 :          3 : }
     137                 :            : 
     138                 :          3 : void poll_freewait(struct poll_wqueues *pwq)
     139                 :            : {
     140                 :          3 :         struct poll_table_page * p = pwq->table;
     141                 :            :         int i;
     142                 :          3 :         for (i = 0; i < pwq->inline_index; i++)
     143                 :          3 :                 free_poll_entry(pwq->inline_entries + i);
     144                 :          3 :         while (p) {
     145                 :            :                 struct poll_table_entry * entry;
     146                 :            :                 struct poll_table_page *old;
     147                 :            : 
     148                 :          0 :                 entry = p->entry;
     149                 :            :                 do {
     150                 :          0 :                         entry--;
     151                 :          0 :                         free_poll_entry(entry);
     152                 :          0 :                 } while (entry > p->entries);
     153                 :            :                 old = p;
     154                 :          0 :                 p = p->next;
     155                 :          0 :                 free_page((unsigned long) old);
     156                 :            :         }
     157                 :          3 : }
     158                 :            : EXPORT_SYMBOL(poll_freewait);
     159                 :            : 
     160                 :          3 : static struct poll_table_entry *poll_get_entry(struct poll_wqueues *p)
     161                 :            : {
     162                 :          3 :         struct poll_table_page *table = p->table;
     163                 :            : 
     164                 :          3 :         if (p->inline_index < N_INLINE_POLL_ENTRIES)
     165                 :          3 :                 return p->inline_entries + p->inline_index++;
     166                 :            : 
     167                 :          0 :         if (!table || POLL_TABLE_FULL(table)) {
     168                 :            :                 struct poll_table_page *new_table;
     169                 :            : 
     170                 :          0 :                 new_table = (struct poll_table_page *) __get_free_page(GFP_KERNEL);
     171                 :          0 :                 if (!new_table) {
     172                 :          0 :                         p->error = -ENOMEM;
     173                 :          0 :                         return NULL;
     174                 :            :                 }
     175                 :          0 :                 new_table->entry = new_table->entries;
     176                 :          0 :                 new_table->next = table;
     177                 :          0 :                 p->table = new_table;
     178                 :            :                 table = new_table;
     179                 :            :         }
     180                 :            : 
     181                 :          0 :         return table->entry++;
     182                 :            : }
     183                 :            : 
     184                 :          3 : static int __pollwake(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
     185                 :            : {
     186                 :          3 :         struct poll_wqueues *pwq = wait->private;
     187                 :          3 :         DECLARE_WAITQUEUE(dummy_wait, pwq->polling_task);
     188                 :            : 
     189                 :            :         /*
     190                 :            :          * Although this function is called under waitqueue lock, LOCK
     191                 :            :          * doesn't imply write barrier and the users expect write
     192                 :            :          * barrier semantics on wakeup functions.  The following
     193                 :            :          * smp_wmb() is equivalent to smp_wmb() in try_to_wake_up()
     194                 :            :          * and is paired with smp_store_mb() in poll_schedule_timeout.
     195                 :            :          */
     196                 :          3 :         smp_wmb();
     197                 :          3 :         pwq->triggered = 1;
     198                 :            : 
     199                 :            :         /*
     200                 :            :          * Perform the default wake up operation using a dummy
     201                 :            :          * waitqueue.
     202                 :            :          *
     203                 :            :          * TODO: This is hacky but there currently is no interface to
     204                 :            :          * pass in @sync.  @sync is scheduled to be removed and once
     205                 :            :          * that happens, wake_up_process() can be used directly.
     206                 :            :          */
     207                 :          3 :         return default_wake_function(&dummy_wait, mode, sync, key);
     208                 :            : }
     209                 :            : 
     210                 :          3 : static int pollwake(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
     211                 :            : {
     212                 :            :         struct poll_table_entry *entry;
     213                 :            : 
     214                 :            :         entry = container_of(wait, struct poll_table_entry, wait);
     215                 :          3 :         if (key && !(key_to_poll(key) & entry->key))
     216                 :            :                 return 0;
     217                 :          3 :         return __pollwake(wait, mode, sync, key);
     218                 :            : }
     219                 :            : 
     220                 :            : /* Add a new entry */
     221                 :          3 : static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
     222                 :            :                                 poll_table *p)
     223                 :            : {
     224                 :            :         struct poll_wqueues *pwq = container_of(p, struct poll_wqueues, pt);
     225                 :          3 :         struct poll_table_entry *entry = poll_get_entry(pwq);
     226                 :          3 :         if (!entry)
     227                 :          3 :                 return;
     228                 :          3 :         entry->filp = get_file(filp);
     229                 :          3 :         entry->wait_address = wait_address;
     230                 :          3 :         entry->key = p->_key;
     231                 :            :         init_waitqueue_func_entry(&entry->wait, pollwake);
     232                 :          3 :         entry->wait.private = pwq;
     233                 :          3 :         add_wait_queue(wait_address, &entry->wait);
     234                 :            : }
     235                 :            : 
     236                 :          3 : static int poll_schedule_timeout(struct poll_wqueues *pwq, int state,
     237                 :            :                           ktime_t *expires, unsigned long slack)
     238                 :            : {
     239                 :            :         int rc = -EINTR;
     240                 :            : 
     241                 :          3 :         set_current_state(state);
     242                 :          3 :         if (!pwq->triggered)
     243                 :          3 :                 rc = schedule_hrtimeout_range(expires, slack, HRTIMER_MODE_ABS);
     244                 :          3 :         __set_current_state(TASK_RUNNING);
     245                 :            : 
     246                 :            :         /*
     247                 :            :          * Prepare for the next iteration.
     248                 :            :          *
     249                 :            :          * The following smp_store_mb() serves two purposes.  First, it's
     250                 :            :          * the counterpart rmb of the wmb in pollwake() such that data
     251                 :            :          * written before wake up is always visible after wake up.
     252                 :            :          * Second, the full barrier guarantees that triggered clearing
     253                 :            :          * doesn't pass event check of the next iteration.  Note that
     254                 :            :          * this problem doesn't exist for the first iteration as
     255                 :            :          * add_wait_queue() has full barrier semantics.
     256                 :            :          */
     257                 :          3 :         smp_store_mb(pwq->triggered, 0);
     258                 :            : 
     259                 :          3 :         return rc;
     260                 :            : }
     261                 :            : 
     262                 :            : /**
     263                 :            :  * poll_select_set_timeout - helper function to setup the timeout value
     264                 :            :  * @to:         pointer to timespec64 variable for the final timeout
     265                 :            :  * @sec:        seconds (from user space)
     266                 :            :  * @nsec:       nanoseconds (from user space)
     267                 :            :  *
     268                 :            :  * Note, we do not use a timespec for the user space value here, That
     269                 :            :  * way we can use the function for timeval and compat interfaces as well.
     270                 :            :  *
     271                 :            :  * Returns -EINVAL if sec/nsec are not normalized. Otherwise 0.
     272                 :            :  */
     273                 :          3 : int poll_select_set_timeout(struct timespec64 *to, time64_t sec, long nsec)
     274                 :            : {
     275                 :            :         struct timespec64 ts = {.tv_sec = sec, .tv_nsec = nsec};
     276                 :            : 
     277                 :          3 :         if (!timespec64_valid(&ts))
     278                 :            :                 return -EINVAL;
     279                 :            : 
     280                 :            :         /* Optimize for the zero timeout value here */
     281                 :          3 :         if (!sec && !nsec) {
     282                 :          3 :                 to->tv_sec = to->tv_nsec = 0;
     283                 :            :         } else {
     284                 :          3 :                 ktime_get_ts64(to);
     285                 :          3 :                 *to = timespec64_add_safe(*to, ts);
     286                 :            :         }
     287                 :            :         return 0;
     288                 :            : }
     289                 :            : 
     290                 :            : enum poll_time_type {
     291                 :            :         PT_TIMEVAL = 0,
     292                 :            :         PT_OLD_TIMEVAL = 1,
     293                 :            :         PT_TIMESPEC = 2,
     294                 :            :         PT_OLD_TIMESPEC = 3,
     295                 :            : };
     296                 :            : 
     297                 :          3 : static int poll_select_finish(struct timespec64 *end_time,
     298                 :            :                               void __user *p,
     299                 :            :                               enum poll_time_type pt_type, int ret)
     300                 :            : {
     301                 :            :         struct timespec64 rts;
     302                 :            : 
     303                 :          3 :         restore_saved_sigmask_unless(ret == -ERESTARTNOHAND);
     304                 :            : 
     305                 :          3 :         if (!p)
     306                 :            :                 return ret;
     307                 :            : 
     308                 :          3 :         if (current->personality & STICKY_TIMEOUTS)
     309                 :            :                 goto sticky;
     310                 :            : 
     311                 :            :         /* No update for zero timeout */
     312                 :          3 :         if (!end_time->tv_sec && !end_time->tv_nsec)
     313                 :            :                 return ret;
     314                 :            : 
     315                 :          3 :         ktime_get_ts64(&rts);
     316                 :          3 :         rts = timespec64_sub(*end_time, rts);
     317                 :          3 :         if (rts.tv_sec < 0)
     318                 :          3 :                 rts.tv_sec = rts.tv_nsec = 0;
     319                 :            : 
     320                 :            : 
     321                 :          3 :         switch (pt_type) {
     322                 :            :         case PT_TIMEVAL:
     323                 :            :                 {
     324                 :            :                         struct timeval rtv;
     325                 :            : 
     326                 :            :                         if (sizeof(rtv) > sizeof(rtv.tv_sec) + sizeof(rtv.tv_usec))
     327                 :            :                                 memset(&rtv, 0, sizeof(rtv));
     328                 :          3 :                         rtv.tv_sec = rts.tv_sec;
     329                 :          3 :                         rtv.tv_usec = rts.tv_nsec / NSEC_PER_USEC;
     330                 :          3 :                         if (!copy_to_user(p, &rtv, sizeof(rtv)))
     331                 :          3 :                                 return ret;
     332                 :            :                 }
     333                 :          0 :                 break;
     334                 :            :         case PT_OLD_TIMEVAL:
     335                 :            :                 {
     336                 :            :                         struct old_timeval32 rtv;
     337                 :            : 
     338                 :          0 :                         rtv.tv_sec = rts.tv_sec;
     339                 :          0 :                         rtv.tv_usec = rts.tv_nsec / NSEC_PER_USEC;
     340                 :          0 :                         if (!copy_to_user(p, &rtv, sizeof(rtv)))
     341                 :          0 :                                 return ret;
     342                 :            :                 }
     343                 :          0 :                 break;
     344                 :            :         case PT_TIMESPEC:
     345                 :          0 :                 if (!put_timespec64(&rts, p))
     346                 :            :                         return ret;
     347                 :            :                 break;
     348                 :            :         case PT_OLD_TIMESPEC:
     349                 :          3 :                 if (!put_old_timespec32(&rts, p))
     350                 :            :                         return ret;
     351                 :            :                 break;
     352                 :            :         default:
     353                 :          0 :                 BUG();
     354                 :            :         }
     355                 :            :         /*
     356                 :            :          * If an application puts its timeval in read-only memory, we
     357                 :            :          * don't want the Linux-specific update to the timeval to
     358                 :            :          * cause a fault after the select has completed
     359                 :            :          * successfully. However, because we're not updating the
     360                 :            :          * timeval, we can't restart the system call.
     361                 :            :          */
     362                 :            : 
     363                 :            : sticky:
     364                 :          0 :         if (ret == -ERESTARTNOHAND)
     365                 :            :                 ret = -EINTR;
     366                 :          0 :         return ret;
     367                 :            : }
     368                 :            : 
     369                 :            : /*
     370                 :            :  * Scalable version of the fd_set.
     371                 :            :  */
     372                 :            : 
     373                 :            : typedef struct {
     374                 :            :         unsigned long *in, *out, *ex;
     375                 :            :         unsigned long *res_in, *res_out, *res_ex;
     376                 :            : } fd_set_bits;
     377                 :            : 
     378                 :            : /*
     379                 :            :  * How many longwords for "nr" bits?
     380                 :            :  */
     381                 :            : #define FDS_BITPERLONG  (8*sizeof(long))
     382                 :            : #define FDS_LONGS(nr)   (((nr)+FDS_BITPERLONG-1)/FDS_BITPERLONG)
     383                 :            : #define FDS_BYTES(nr)   (FDS_LONGS(nr)*sizeof(long))
     384                 :            : 
     385                 :            : /*
     386                 :            :  * Use "unsigned long" accesses to let user-mode fd_set's be long-aligned.
     387                 :            :  */
     388                 :            : static inline
     389                 :          3 : int get_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset)
     390                 :            : {
     391                 :          3 :         nr = FDS_BYTES(nr);
     392                 :          3 :         if (ufdset)
     393                 :          3 :                 return copy_from_user(fdset, ufdset, nr) ? -EFAULT : 0;
     394                 :            : 
     395                 :          3 :         memset(fdset, 0, nr);
     396                 :          3 :         return 0;
     397                 :            : }
     398                 :            : 
     399                 :            : static inline unsigned long __must_check
     400                 :            : set_fd_set(unsigned long nr, void __user *ufdset, unsigned long *fdset)
     401                 :            : {
     402                 :          3 :         if (ufdset)
     403                 :            :                 return __copy_to_user(ufdset, fdset, FDS_BYTES(nr));
     404                 :            :         return 0;
     405                 :            : }
     406                 :            : 
     407                 :            : static inline
     408                 :            : void zero_fd_set(unsigned long nr, unsigned long *fdset)
     409                 :            : {
     410                 :          3 :         memset(fdset, 0, FDS_BYTES(nr));
     411                 :            : }
     412                 :            : 
     413                 :            : #define FDS_IN(fds, n)          (fds->in + n)
     414                 :            : #define FDS_OUT(fds, n)         (fds->out + n)
     415                 :            : #define FDS_EX(fds, n)          (fds->ex + n)
     416                 :            : 
     417                 :            : #define BITS(fds, n)    (*FDS_IN(fds, n)|*FDS_OUT(fds, n)|*FDS_EX(fds, n))
     418                 :            : 
     419                 :          3 : static int max_select_fd(unsigned long n, fd_set_bits *fds)
     420                 :            : {
     421                 :            :         unsigned long *open_fds;
     422                 :            :         unsigned long set;
     423                 :            :         int max;
     424                 :            :         struct fdtable *fdt;
     425                 :            : 
     426                 :            :         /* handle last in-complete long-word first */
     427                 :          3 :         set = ~(~0UL << (n & (BITS_PER_LONG-1)));
     428                 :          3 :         n /= BITS_PER_LONG;
     429                 :          3 :         fdt = files_fdtable(current->files);
     430                 :          3 :         open_fds = fdt->open_fds + n;
     431                 :            :         max = 0;
     432                 :          3 :         if (set) {
     433                 :          3 :                 set &= BITS(fds, n);
     434                 :          3 :                 if (set) {
     435                 :          3 :                         if (!(set & ~*open_fds))
     436                 :            :                                 goto get_max;
     437                 :            :                         return -EBADF;
     438                 :            :                 }
     439                 :            :         }
     440                 :          3 :         while (n) {
     441                 :          0 :                 open_fds--;
     442                 :          0 :                 n--;
     443                 :          0 :                 set = BITS(fds, n);
     444                 :          0 :                 if (!set)
     445                 :          0 :                         continue;
     446                 :          0 :                 if (set & ~*open_fds)
     447                 :            :                         return -EBADF;
     448                 :          0 :                 if (max)
     449                 :          0 :                         continue;
     450                 :            : get_max:
     451                 :            :                 do {
     452                 :          3 :                         max++;
     453                 :          3 :                         set >>= 1;
     454                 :          3 :                 } while (set);
     455                 :          3 :                 max += n * BITS_PER_LONG;
     456                 :            :         }
     457                 :            : 
     458                 :          3 :         return max;
     459                 :            : }
     460                 :            : 
     461                 :            : #define POLLIN_SET (EPOLLRDNORM | EPOLLRDBAND | EPOLLIN | EPOLLHUP | EPOLLERR)
     462                 :            : #define POLLOUT_SET (EPOLLWRBAND | EPOLLWRNORM | EPOLLOUT | EPOLLERR)
     463                 :            : #define POLLEX_SET (EPOLLPRI)
     464                 :            : 
     465                 :            : static inline void wait_key_set(poll_table *wait, unsigned long in,
     466                 :            :                                 unsigned long out, unsigned long bit,
     467                 :            :                                 __poll_t ll_flag)
     468                 :            : {
     469                 :          3 :         wait->_key = POLLEX_SET | ll_flag;
     470                 :          3 :         if (in & bit)
     471                 :          3 :                 wait->_key |= POLLIN_SET;
     472                 :          3 :         if (out & bit)
     473                 :          0 :                 wait->_key |= POLLOUT_SET;
     474                 :            : }
     475                 :            : 
     476                 :          3 : static int do_select(int n, fd_set_bits *fds, struct timespec64 *end_time)
     477                 :            : {
     478                 :            :         ktime_t expire, *to = NULL;
     479                 :            :         struct poll_wqueues table;
     480                 :            :         poll_table *wait;
     481                 :            :         int retval, i, timed_out = 0;
     482                 :            :         u64 slack = 0;
     483                 :          3 :         __poll_t busy_flag = net_busy_loop_on() ? POLL_BUSY_LOOP : 0;
     484                 :            :         unsigned long busy_start = 0;
     485                 :            : 
     486                 :            :         rcu_read_lock();
     487                 :          3 :         retval = max_select_fd(n, fds);
     488                 :            :         rcu_read_unlock();
     489                 :            : 
     490                 :          3 :         if (retval < 0)
     491                 :            :                 return retval;
     492                 :            :         n = retval;
     493                 :            : 
     494                 :            :         poll_initwait(&table);
     495                 :            :         wait = &table.pt;
     496                 :          3 :         if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {
     497                 :          3 :                 wait->_qproc = NULL;
     498                 :            :                 timed_out = 1;
     499                 :            :         }
     500                 :            : 
     501                 :          3 :         if (end_time && !timed_out)
     502                 :          3 :                 slack = select_estimate_accuracy(end_time);
     503                 :            : 
     504                 :            :         retval = 0;
     505                 :            :         for (;;) {
     506                 :            :                 unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
     507                 :            :                 bool can_busy_loop = false;
     508                 :            : 
     509                 :          3 :                 inp = fds->in; outp = fds->out; exp = fds->ex;
     510                 :          3 :                 rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;
     511                 :            : 
     512                 :          3 :                 for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
     513                 :            :                         unsigned long in, out, ex, all_bits, bit = 1, j;
     514                 :            :                         unsigned long res_in = 0, res_out = 0, res_ex = 0;
     515                 :            :                         __poll_t mask;
     516                 :            : 
     517                 :          3 :                         in = *inp++; out = *outp++; ex = *exp++;
     518                 :          3 :                         all_bits = in | out | ex;
     519                 :          3 :                         if (all_bits == 0) {
     520                 :          0 :                                 i += BITS_PER_LONG;
     521                 :          0 :                                 continue;
     522                 :            :                         }
     523                 :            : 
     524                 :          3 :                         for (j = 0; j < BITS_PER_LONG; ++j, ++i, bit <<= 1) {
     525                 :            :                                 struct fd f;
     526                 :          3 :                                 if (i >= n)
     527                 :            :                                         break;
     528                 :          3 :                                 if (!(bit & all_bits))
     529                 :          3 :                                         continue;
     530                 :          3 :                                 f = fdget(i);
     531                 :          3 :                                 if (f.file) {
     532                 :            :                                         wait_key_set(wait, in, out, bit,
     533                 :            :                                                      busy_flag);
     534                 :            :                                         mask = vfs_poll(f.file, wait);
     535                 :            : 
     536                 :            :                                         fdput(f);
     537                 :          3 :                                         if ((mask & POLLIN_SET) && (in & bit)) {
     538                 :          3 :                                                 res_in |= bit;
     539                 :          3 :                                                 retval++;
     540                 :          3 :                                                 wait->_qproc = NULL;
     541                 :            :                                         }
     542                 :          3 :                                         if ((mask & POLLOUT_SET) && (out & bit)) {
     543                 :          0 :                                                 res_out |= bit;
     544                 :          0 :                                                 retval++;
     545                 :          0 :                                                 wait->_qproc = NULL;
     546                 :            :                                         }
     547                 :          3 :                                         if ((mask & POLLEX_SET) && (ex & bit)) {
     548                 :          0 :                                                 res_ex |= bit;
     549                 :          0 :                                                 retval++;
     550                 :          0 :                                                 wait->_qproc = NULL;
     551                 :            :                                         }
     552                 :            :                                         /* got something, stop busy polling */
     553                 :          3 :                                         if (retval) {
     554                 :            :                                                 can_busy_loop = false;
     555                 :            :                                                 busy_flag = 0;
     556                 :            : 
     557                 :            :                                         /*
     558                 :            :                                          * only remember a returned
     559                 :            :                                          * POLL_BUSY_LOOP if we asked for it
     560                 :            :                                          */
     561                 :          3 :                                         } else if (busy_flag & mask)
     562                 :            :                                                 can_busy_loop = true;
     563                 :            : 
     564                 :            :                                 }
     565                 :            :                         }
     566                 :          3 :                         if (res_in)
     567                 :          3 :                                 *rinp = res_in;
     568                 :          3 :                         if (res_out)
     569                 :          0 :                                 *routp = res_out;
     570                 :          3 :                         if (res_ex)
     571                 :          0 :                                 *rexp = res_ex;
     572                 :          3 :                         cond_resched();
     573                 :            :                 }
     574                 :          3 :                 wait->_qproc = NULL;
     575                 :          3 :                 if (retval || timed_out || signal_pending(current))
     576                 :            :                         break;
     577                 :          3 :                 if (table.error) {
     578                 :          0 :                         retval = table.error;
     579                 :          0 :                         break;
     580                 :            :                 }
     581                 :            : 
     582                 :            :                 /* only if found POLL_BUSY_LOOP sockets && not out of time */
     583                 :          3 :                 if (can_busy_loop && !need_resched()) {
     584                 :          0 :                         if (!busy_start) {
     585                 :            :                                 busy_start = busy_loop_current_time();
     586                 :          0 :                                 continue;
     587                 :            :                         }
     588                 :          0 :                         if (!busy_loop_timeout(busy_start))
     589                 :          0 :                                 continue;
     590                 :            :                 }
     591                 :            :                 busy_flag = 0;
     592                 :            : 
     593                 :            :                 /*
     594                 :            :                  * If this is the first loop and we have a timeout
     595                 :            :                  * given, then we convert to ktime_t and set the to
     596                 :            :                  * pointer to the expiry value.
     597                 :            :                  */
     598                 :          3 :                 if (end_time && !to) {
     599                 :          3 :                         expire = timespec64_to_ktime(*end_time);
     600                 :            :                         to = &expire;
     601                 :            :                 }
     602                 :            : 
     603                 :          3 :                 if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE,
     604                 :            :                                            to, slack))
     605                 :            :                         timed_out = 1;
     606                 :            :         }
     607                 :            : 
     608                 :          3 :         poll_freewait(&table);
     609                 :            : 
     610                 :          3 :         return retval;
     611                 :            : }
     612                 :            : 
     613                 :            : /*
     614                 :            :  * We can actually return ERESTARTSYS instead of EINTR, but I'd
     615                 :            :  * like to be certain this leads to no problems. So I return
     616                 :            :  * EINTR just for safety.
     617                 :            :  *
     618                 :            :  * Update: ERESTARTSYS breaks at least the xview clock binary, so
     619                 :            :  * I'm trying ERESTARTNOHAND which restart only when you want to.
     620                 :            :  */
     621                 :          3 : int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
     622                 :            :                            fd_set __user *exp, struct timespec64 *end_time)
     623                 :            : {
     624                 :            :         fd_set_bits fds;
     625                 :            :         void *bits;
     626                 :            :         int ret, max_fds;
     627                 :            :         size_t size, alloc_size;
     628                 :            :         struct fdtable *fdt;
     629                 :            :         /* Allocate small arguments on the stack to save memory and be faster */
     630                 :            :         long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
     631                 :            : 
     632                 :            :         ret = -EINVAL;
     633                 :          3 :         if (n < 0)
     634                 :            :                 goto out_nofds;
     635                 :            : 
     636                 :            :         /* max_fds can increase, so grab it once to avoid race */
     637                 :            :         rcu_read_lock();
     638                 :          3 :         fdt = files_fdtable(current->files);
     639                 :          3 :         max_fds = fdt->max_fds;
     640                 :            :         rcu_read_unlock();
     641                 :          3 :         if (n > max_fds)
     642                 :            :                 n = max_fds;
     643                 :            : 
     644                 :            :         /*
     645                 :            :          * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
     646                 :            :          * since we used fdset we need to allocate memory in units of
     647                 :            :          * long-words. 
     648                 :            :          */
     649                 :          3 :         size = FDS_BYTES(n);
     650                 :            :         bits = stack_fds;
     651                 :          3 :         if (size > sizeof(stack_fds) / 6) {
     652                 :            :                 /* Not enough space in on-stack array; must use kmalloc */
     653                 :            :                 ret = -ENOMEM;
     654                 :          0 :                 if (size > (SIZE_MAX / 6))
     655                 :            :                         goto out_nofds;
     656                 :            : 
     657                 :          0 :                 alloc_size = 6 * size;
     658                 :            :                 bits = kvmalloc(alloc_size, GFP_KERNEL);
     659                 :          0 :                 if (!bits)
     660                 :            :                         goto out_nofds;
     661                 :            :         }
     662                 :          3 :         fds.in      = bits;
     663                 :          3 :         fds.out     = bits +   size;
     664                 :          3 :         fds.ex      = bits + 2*size;
     665                 :          3 :         fds.res_in  = bits + 3*size;
     666                 :          3 :         fds.res_out = bits + 4*size;
     667                 :          3 :         fds.res_ex  = bits + 5*size;
     668                 :            : 
     669                 :          3 :         if ((ret = get_fd_set(n, inp, fds.in)) ||
     670                 :          3 :             (ret = get_fd_set(n, outp, fds.out)) ||
     671                 :          3 :             (ret = get_fd_set(n, exp, fds.ex)))
     672                 :            :                 goto out;
     673                 :          3 :         zero_fd_set(n, fds.res_in);
     674                 :          3 :         zero_fd_set(n, fds.res_out);
     675                 :          3 :         zero_fd_set(n, fds.res_ex);
     676                 :            : 
     677                 :          3 :         ret = do_select(n, &fds, end_time);
     678                 :            : 
     679                 :          3 :         if (ret < 0)
     680                 :            :                 goto out;
     681                 :          3 :         if (!ret) {
     682                 :            :                 ret = -ERESTARTNOHAND;
     683                 :          3 :                 if (signal_pending(current))
     684                 :            :                         goto out;
     685                 :            :                 ret = 0;
     686                 :            :         }
     687                 :            : 
     688                 :          3 :         if (set_fd_set(n, inp, fds.res_in) ||
     689                 :          3 :             set_fd_set(n, outp, fds.res_out) ||
     690                 :          3 :             set_fd_set(n, exp, fds.res_ex))
     691                 :            :                 ret = -EFAULT;
     692                 :            : 
     693                 :            : out:
     694                 :          3 :         if (bits != stack_fds)
     695                 :          0 :                 kvfree(bits);
     696                 :            : out_nofds:
     697                 :          3 :         return ret;
     698                 :            : }
     699                 :            : 
     700                 :          3 : static int kern_select(int n, fd_set __user *inp, fd_set __user *outp,
     701                 :            :                        fd_set __user *exp, struct timeval __user *tvp)
     702                 :            : {
     703                 :            :         struct timespec64 end_time, *to = NULL;
     704                 :            :         struct timeval tv;
     705                 :            :         int ret;
     706                 :            : 
     707                 :          3 :         if (tvp) {
     708                 :          3 :                 if (copy_from_user(&tv, tvp, sizeof(tv)))
     709                 :            :                         return -EFAULT;
     710                 :            : 
     711                 :            :                 to = &end_time;
     712                 :          3 :                 if (poll_select_set_timeout(to,
     713                 :          3 :                                 tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),
     714                 :          3 :                                 (tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))
     715                 :            :                         return -EINVAL;
     716                 :            :         }
     717                 :            : 
     718                 :          3 :         ret = core_sys_select(n, inp, outp, exp, to);
     719                 :          3 :         return poll_select_finish(&end_time, tvp, PT_TIMEVAL, ret);
     720                 :            : }
     721                 :            : 
     722                 :          3 : SYSCALL_DEFINE5(select, int, n, fd_set __user *, inp, fd_set __user *, outp,
     723                 :            :                 fd_set __user *, exp, struct timeval __user *, tvp)
     724                 :            : {
     725                 :          3 :         return kern_select(n, inp, outp, exp, tvp);
     726                 :            : }
     727                 :            : 
     728                 :          3 : static long do_pselect(int n, fd_set __user *inp, fd_set __user *outp,
     729                 :            :                        fd_set __user *exp, void __user *tsp,
     730                 :            :                        const sigset_t __user *sigmask, size_t sigsetsize,
     731                 :            :                        enum poll_time_type type)
     732                 :            : {
     733                 :            :         struct timespec64 ts, end_time, *to = NULL;
     734                 :            :         int ret;
     735                 :            : 
     736                 :          3 :         if (tsp) {
     737                 :          0 :                 switch (type) {
     738                 :            :                 case PT_TIMESPEC:
     739                 :          0 :                         if (get_timespec64(&ts, tsp))
     740                 :            :                                 return -EFAULT;
     741                 :            :                         break;
     742                 :            :                 case PT_OLD_TIMESPEC:
     743                 :          0 :                         if (get_old_timespec32(&ts, tsp))
     744                 :            :                                 return -EFAULT;
     745                 :            :                         break;
     746                 :            :                 default:
     747                 :          0 :                         BUG();
     748                 :            :                 }
     749                 :            : 
     750                 :            :                 to = &end_time;
     751                 :          0 :                 if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
     752                 :            :                         return -EINVAL;
     753                 :            :         }
     754                 :            : 
     755                 :          3 :         ret = set_user_sigmask(sigmask, sigsetsize);
     756                 :          3 :         if (ret)
     757                 :            :                 return ret;
     758                 :            : 
     759                 :          3 :         ret = core_sys_select(n, inp, outp, exp, to);
     760                 :          3 :         return poll_select_finish(&end_time, tsp, type, ret);
     761                 :            : }
     762                 :            : 
     763                 :            : /*
     764                 :            :  * Most architectures can't handle 7-argument syscalls. So we provide a
     765                 :            :  * 6-argument version where the sixth argument is a pointer to a structure
     766                 :            :  * which has a pointer to the sigset_t itself followed by a size_t containing
     767                 :            :  * the sigset size.
     768                 :            :  */
     769                 :          0 : SYSCALL_DEFINE6(pselect6, int, n, fd_set __user *, inp, fd_set __user *, outp,
     770                 :            :                 fd_set __user *, exp, struct __kernel_timespec __user *, tsp,
     771                 :            :                 void __user *, sig)
     772                 :            : {
     773                 :            :         size_t sigsetsize = 0;
     774                 :            :         sigset_t __user *up = NULL;
     775                 :            : 
     776                 :          0 :         if (sig) {
     777                 :          0 :                 if (!access_ok(sig, sizeof(void *)+sizeof(size_t))
     778                 :          0 :                     || __get_user(up, (sigset_t __user * __user *)sig)
     779                 :          0 :                     || __get_user(sigsetsize,
     780                 :            :                                 (size_t __user *)(sig+sizeof(void *))))
     781                 :            :                         return -EFAULT;
     782                 :            :         }
     783                 :            : 
     784                 :          0 :         return do_pselect(n, inp, outp, exp, tsp, up, sigsetsize, PT_TIMESPEC);
     785                 :            : }
     786                 :            : 
     787                 :            : #if defined(CONFIG_COMPAT_32BIT_TIME) && !defined(CONFIG_64BIT)
     788                 :            : 
     789                 :          3 : SYSCALL_DEFINE6(pselect6_time32, int, n, fd_set __user *, inp, fd_set __user *, outp,
     790                 :            :                 fd_set __user *, exp, struct old_timespec32 __user *, tsp,
     791                 :            :                 void __user *, sig)
     792                 :            : {
     793                 :            :         size_t sigsetsize = 0;
     794                 :            :         sigset_t __user *up = NULL;
     795                 :            : 
     796                 :          3 :         if (sig) {
     797                 :          3 :                 if (!access_ok(sig, sizeof(void *)+sizeof(size_t))
     798                 :          3 :                     || __get_user(up, (sigset_t __user * __user *)sig)
     799                 :          3 :                     || __get_user(sigsetsize,
     800                 :            :                                 (size_t __user *)(sig+sizeof(void *))))
     801                 :            :                         return -EFAULT;
     802                 :            :         }
     803                 :            : 
     804                 :          3 :         return do_pselect(n, inp, outp, exp, tsp, up, sigsetsize, PT_OLD_TIMESPEC);
     805                 :            : }
     806                 :            : 
     807                 :            : #endif
     808                 :            : 
     809                 :            : #ifdef __ARCH_WANT_SYS_OLD_SELECT
     810                 :            : struct sel_arg_struct {
     811                 :            :         unsigned long n;
     812                 :            :         fd_set __user *inp, *outp, *exp;
     813                 :            :         struct timeval __user *tvp;
     814                 :            : };
     815                 :            : 
     816                 :          0 : SYSCALL_DEFINE1(old_select, struct sel_arg_struct __user *, arg)
     817                 :            : {
     818                 :            :         struct sel_arg_struct a;
     819                 :            : 
     820                 :          0 :         if (copy_from_user(&a, arg, sizeof(a)))
     821                 :            :                 return -EFAULT;
     822                 :          0 :         return kern_select(a.n, a.inp, a.outp, a.exp, a.tvp);
     823                 :            : }
     824                 :            : #endif
     825                 :            : 
     826                 :            : struct poll_list {
     827                 :            :         struct poll_list *next;
     828                 :            :         int len;
     829                 :            :         struct pollfd entries[0];
     830                 :            : };
     831                 :            : 
     832                 :            : #define POLLFD_PER_PAGE  ((PAGE_SIZE-sizeof(struct poll_list)) / sizeof(struct pollfd))
     833                 :            : 
     834                 :            : /*
     835                 :            :  * Fish for pollable events on the pollfd->fd file descriptor. We're only
     836                 :            :  * interested in events matching the pollfd->events mask, and the result
     837                 :            :  * matching that mask is both recorded in pollfd->revents and returned. The
     838                 :            :  * pwait poll_table will be used by the fd-provided poll handler for waiting,
     839                 :            :  * if pwait->_qproc is non-NULL.
     840                 :            :  */
     841                 :          3 : static inline __poll_t do_pollfd(struct pollfd *pollfd, poll_table *pwait,
     842                 :            :                                      bool *can_busy_poll,
     843                 :            :                                      __poll_t busy_flag)
     844                 :            : {
     845                 :          3 :         int fd = pollfd->fd;
     846                 :            :         __poll_t mask = 0, filter;
     847                 :            :         struct fd f;
     848                 :            : 
     849                 :          3 :         if (fd < 0)
     850                 :            :                 goto out;
     851                 :            :         mask = EPOLLNVAL;
     852                 :          3 :         f = fdget(fd);
     853                 :          3 :         if (!f.file)
     854                 :            :                 goto out;
     855                 :            : 
     856                 :            :         /* userland u16 ->events contains POLL... bitmap */
     857                 :          3 :         filter = demangle_poll(pollfd->events) | EPOLLERR | EPOLLHUP;
     858                 :          3 :         pwait->_key = filter | busy_flag;
     859                 :            :         mask = vfs_poll(f.file, pwait);
     860                 :          3 :         if (mask & busy_flag)
     861                 :          0 :                 *can_busy_poll = true;
     862                 :          3 :         mask &= filter;             /* Mask out unneeded events. */
     863                 :            :         fdput(f);
     864                 :            : 
     865                 :            : out:
     866                 :            :         /* ... and so does ->revents */
     867                 :          3 :         pollfd->revents = mangle_poll(mask);
     868                 :          3 :         return mask;
     869                 :            : }
     870                 :            : 
     871                 :          3 : static int do_poll(struct poll_list *list, struct poll_wqueues *wait,
     872                 :            :                    struct timespec64 *end_time)
     873                 :            : {
     874                 :          3 :         poll_table* pt = &wait->pt;
     875                 :            :         ktime_t expire, *to = NULL;
     876                 :            :         int timed_out = 0, count = 0;
     877                 :            :         u64 slack = 0;
     878                 :          3 :         __poll_t busy_flag = net_busy_loop_on() ? POLL_BUSY_LOOP : 0;
     879                 :            :         unsigned long busy_start = 0;
     880                 :            : 
     881                 :            :         /* Optimise the no-wait case */
     882                 :          3 :         if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {
     883                 :          3 :                 pt->_qproc = NULL;
     884                 :            :                 timed_out = 1;
     885                 :            :         }
     886                 :            : 
     887                 :          3 :         if (end_time && !timed_out)
     888                 :          3 :                 slack = select_estimate_accuracy(end_time);
     889                 :            : 
     890                 :            :         for (;;) {
     891                 :            :                 struct poll_list *walk;
     892                 :          3 :                 bool can_busy_loop = false;
     893                 :            : 
     894                 :          3 :                 for (walk = list; walk != NULL; walk = walk->next) {
     895                 :            :                         struct pollfd * pfd, * pfd_end;
     896                 :            : 
     897                 :          3 :                         pfd = walk->entries;
     898                 :          3 :                         pfd_end = pfd + walk->len;
     899                 :          3 :                         for (; pfd != pfd_end; pfd++) {
     900                 :            :                                 /*
     901                 :            :                                  * Fish for events. If we found one, record it
     902                 :            :                                  * and kill poll_table->_qproc, so we don't
     903                 :            :                                  * needlessly register any other waiters after
     904                 :            :                                  * this. They'll get immediately deregistered
     905                 :            :                                  * when we break out and return.
     906                 :            :                                  */
     907                 :          3 :                                 if (do_pollfd(pfd, pt, &can_busy_loop,
     908                 :            :                                               busy_flag)) {
     909                 :          3 :                                         count++;
     910                 :          3 :                                         pt->_qproc = NULL;
     911                 :            :                                         /* found something, stop busy polling */
     912                 :            :                                         busy_flag = 0;
     913                 :          3 :                                         can_busy_loop = false;
     914                 :            :                                 }
     915                 :            :                         }
     916                 :            :                 }
     917                 :            :                 /*
     918                 :            :                  * All waiters have already been registered, so don't provide
     919                 :            :                  * a poll_table->_qproc to them on the next loop iteration.
     920                 :            :                  */
     921                 :          3 :                 pt->_qproc = NULL;
     922                 :          3 :                 if (!count) {
     923                 :          3 :                         count = wait->error;
     924                 :          3 :                         if (signal_pending(current))
     925                 :            :                                 count = -ERESTARTNOHAND;
     926                 :            :                 }
     927                 :          3 :                 if (count || timed_out)
     928                 :            :                         break;
     929                 :            : 
     930                 :            :                 /* only if found POLL_BUSY_LOOP sockets && not out of time */
     931                 :          3 :                 if (can_busy_loop && !need_resched()) {
     932                 :          0 :                         if (!busy_start) {
     933                 :            :                                 busy_start = busy_loop_current_time();
     934                 :          0 :                                 continue;
     935                 :            :                         }
     936                 :          0 :                         if (!busy_loop_timeout(busy_start))
     937                 :          0 :                                 continue;
     938                 :            :                 }
     939                 :            :                 busy_flag = 0;
     940                 :            : 
     941                 :            :                 /*
     942                 :            :                  * If this is the first loop and we have a timeout
     943                 :            :                  * given, then we convert to ktime_t and set the to
     944                 :            :                  * pointer to the expiry value.
     945                 :            :                  */
     946                 :          3 :                 if (end_time && !to) {
     947                 :          3 :                         expire = timespec64_to_ktime(*end_time);
     948                 :            :                         to = &expire;
     949                 :            :                 }
     950                 :            : 
     951                 :          3 :                 if (!poll_schedule_timeout(wait, TASK_INTERRUPTIBLE, to, slack))
     952                 :            :                         timed_out = 1;
     953                 :            :         }
     954                 :          3 :         return count;
     955                 :            : }
     956                 :            : 
     957                 :            : #define N_STACK_PPS ((sizeof(stack_pps) - sizeof(struct poll_list))  / \
     958                 :            :                         sizeof(struct pollfd))
     959                 :            : 
     960                 :          3 : static int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds,
     961                 :            :                 struct timespec64 *end_time)
     962                 :            : {
     963                 :            :         struct poll_wqueues table;
     964                 :            :         int err = -EFAULT, fdcount, len;
     965                 :            :         /* Allocate small arguments on the stack to save memory and be
     966                 :            :            faster - use long to make sure the buffer is aligned properly
     967                 :            :            on 64 bit archs to avoid unaligned access */
     968                 :            :         long stack_pps[POLL_STACK_ALLOC/sizeof(long)];
     969                 :            :         struct poll_list *const head = (struct poll_list *)stack_pps;
     970                 :            :         struct poll_list *walk = head;
     971                 :            :         unsigned long todo = nfds;
     972                 :            : 
     973                 :          3 :         if (nfds > rlimit(RLIMIT_NOFILE))
     974                 :            :                 return -EINVAL;
     975                 :            : 
     976                 :          3 :         len = min_t(unsigned int, nfds, N_STACK_PPS);
     977                 :            :         for (;;) {
     978                 :          3 :                 walk->next = NULL;
     979                 :          3 :                 walk->len = len;
     980                 :          3 :                 if (!len)
     981                 :            :                         break;
     982                 :            : 
     983                 :          3 :                 if (copy_from_user(walk->entries, ufds + nfds-todo,
     984                 :          3 :                                         sizeof(struct pollfd) * walk->len))
     985                 :            :                         goto out_fds;
     986                 :            : 
     987                 :          3 :                 todo -= walk->len;
     988                 :          3 :                 if (!todo)
     989                 :            :                         break;
     990                 :            : 
     991                 :          0 :                 len = min(todo, POLLFD_PER_PAGE);
     992                 :          0 :                 walk = walk->next = kmalloc(struct_size(walk, entries, len),
     993                 :            :                                             GFP_KERNEL);
     994                 :          0 :                 if (!walk) {
     995                 :            :                         err = -ENOMEM;
     996                 :            :                         goto out_fds;
     997                 :            :                 }
     998                 :            :         }
     999                 :            : 
    1000                 :            :         poll_initwait(&table);
    1001                 :          3 :         fdcount = do_poll(head, &table, end_time);
    1002                 :          3 :         poll_freewait(&table);
    1003                 :            : 
    1004                 :          3 :         for (walk = head; walk; walk = walk->next) {
    1005                 :          3 :                 struct pollfd *fds = walk->entries;
    1006                 :            :                 int j;
    1007                 :            : 
    1008                 :          3 :                 for (j = 0; j < walk->len; j++, ufds++)
    1009                 :          3 :                         if (__put_user(fds[j].revents, &ufds->revents))
    1010                 :            :                                 goto out_fds;
    1011                 :            :         }
    1012                 :            : 
    1013                 :            :         err = fdcount;
    1014                 :            : out_fds:
    1015                 :          3 :         walk = head->next;
    1016                 :          3 :         while (walk) {
    1017                 :            :                 struct poll_list *pos = walk;
    1018                 :          0 :                 walk = walk->next;
    1019                 :          0 :                 kfree(pos);
    1020                 :            :         }
    1021                 :            : 
    1022                 :            :         return err;
    1023                 :            : }
    1024                 :            : 
    1025                 :          3 : static long do_restart_poll(struct restart_block *restart_block)
    1026                 :            : {
    1027                 :          3 :         struct pollfd __user *ufds = restart_block->poll.ufds;
    1028                 :          3 :         int nfds = restart_block->poll.nfds;
    1029                 :            :         struct timespec64 *to = NULL, end_time;
    1030                 :            :         int ret;
    1031                 :            : 
    1032                 :          3 :         if (restart_block->poll.has_timeout) {
    1033                 :          0 :                 end_time.tv_sec = restart_block->poll.tv_sec;
    1034                 :          0 :                 end_time.tv_nsec = restart_block->poll.tv_nsec;
    1035                 :            :                 to = &end_time;
    1036                 :            :         }
    1037                 :            : 
    1038                 :          3 :         ret = do_sys_poll(ufds, nfds, to);
    1039                 :            : 
    1040                 :          3 :         if (ret == -ERESTARTNOHAND) {
    1041                 :          3 :                 restart_block->fn = do_restart_poll;
    1042                 :            :                 ret = -ERESTART_RESTARTBLOCK;
    1043                 :            :         }
    1044                 :          3 :         return ret;
    1045                 :            : }
    1046                 :            : 
    1047                 :          3 : SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds,
    1048                 :            :                 int, timeout_msecs)
    1049                 :            : {
    1050                 :            :         struct timespec64 end_time, *to = NULL;
    1051                 :            :         int ret;
    1052                 :            : 
    1053                 :          3 :         if (timeout_msecs >= 0) {
    1054                 :            :                 to = &end_time;
    1055                 :          3 :                 poll_select_set_timeout(to, timeout_msecs / MSEC_PER_SEC,
    1056                 :          3 :                         NSEC_PER_MSEC * (timeout_msecs % MSEC_PER_SEC));
    1057                 :            :         }
    1058                 :            : 
    1059                 :          3 :         ret = do_sys_poll(ufds, nfds, to);
    1060                 :            : 
    1061                 :          3 :         if (ret == -ERESTARTNOHAND) {
    1062                 :            :                 struct restart_block *restart_block;
    1063                 :            : 
    1064                 :          3 :                 restart_block = &current->restart_block;
    1065                 :          3 :                 restart_block->fn = do_restart_poll;
    1066                 :          3 :                 restart_block->poll.ufds = ufds;
    1067                 :          3 :                 restart_block->poll.nfds = nfds;
    1068                 :            : 
    1069                 :          3 :                 if (timeout_msecs >= 0) {
    1070                 :          3 :                         restart_block->poll.tv_sec = end_time.tv_sec;
    1071                 :          3 :                         restart_block->poll.tv_nsec = end_time.tv_nsec;
    1072                 :          3 :                         restart_block->poll.has_timeout = 1;
    1073                 :            :                 } else
    1074                 :          3 :                         restart_block->poll.has_timeout = 0;
    1075                 :            : 
    1076                 :            :                 ret = -ERESTART_RESTARTBLOCK;
    1077                 :            :         }
    1078                 :          3 :         return ret;
    1079                 :            : }
    1080                 :            : 
    1081                 :          0 : SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds, unsigned int, nfds,
    1082                 :            :                 struct __kernel_timespec __user *, tsp, const sigset_t __user *, sigmask,
    1083                 :            :                 size_t, sigsetsize)
    1084                 :            : {
    1085                 :            :         struct timespec64 ts, end_time, *to = NULL;
    1086                 :            :         int ret;
    1087                 :            : 
    1088                 :          0 :         if (tsp) {
    1089                 :          0 :                 if (get_timespec64(&ts, tsp))
    1090                 :            :                         return -EFAULT;
    1091                 :            : 
    1092                 :            :                 to = &end_time;
    1093                 :          0 :                 if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
    1094                 :            :                         return -EINVAL;
    1095                 :            :         }
    1096                 :            : 
    1097                 :          0 :         ret = set_user_sigmask(sigmask, sigsetsize);
    1098                 :          0 :         if (ret)
    1099                 :            :                 return ret;
    1100                 :            : 
    1101                 :          0 :         ret = do_sys_poll(ufds, nfds, to);
    1102                 :          0 :         return poll_select_finish(&end_time, tsp, PT_TIMESPEC, ret);
    1103                 :            : }
    1104                 :            : 
    1105                 :            : #if defined(CONFIG_COMPAT_32BIT_TIME) && !defined(CONFIG_64BIT)
    1106                 :            : 
    1107                 :          3 : SYSCALL_DEFINE5(ppoll_time32, struct pollfd __user *, ufds, unsigned int, nfds,
    1108                 :            :                 struct old_timespec32 __user *, tsp, const sigset_t __user *, sigmask,
    1109                 :            :                 size_t, sigsetsize)
    1110                 :            : {
    1111                 :            :         struct timespec64 ts, end_time, *to = NULL;
    1112                 :            :         int ret;
    1113                 :            : 
    1114                 :          3 :         if (tsp) {
    1115                 :          3 :                 if (get_old_timespec32(&ts, tsp))
    1116                 :            :                         return -EFAULT;
    1117                 :            : 
    1118                 :            :                 to = &end_time;
    1119                 :          3 :                 if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
    1120                 :            :                         return -EINVAL;
    1121                 :            :         }
    1122                 :            : 
    1123                 :          3 :         ret = set_user_sigmask(sigmask, sigsetsize);
    1124                 :          3 :         if (ret)
    1125                 :            :                 return ret;
    1126                 :            : 
    1127                 :          3 :         ret = do_sys_poll(ufds, nfds, to);
    1128                 :          3 :         return poll_select_finish(&end_time, tsp, PT_OLD_TIMESPEC, ret);
    1129                 :            : }
    1130                 :            : #endif
    1131                 :            : 
    1132                 :            : #ifdef CONFIG_COMPAT
    1133                 :            : #define __COMPAT_NFDBITS       (8 * sizeof(compat_ulong_t))
    1134                 :            : 
    1135                 :            : /*
    1136                 :            :  * Ooo, nasty.  We need here to frob 32-bit unsigned longs to
    1137                 :            :  * 64-bit unsigned longs.
    1138                 :            :  */
    1139                 :            : static
    1140                 :            : int compat_get_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
    1141                 :            :                         unsigned long *fdset)
    1142                 :            : {
    1143                 :            :         if (ufdset) {
    1144                 :            :                 return compat_get_bitmap(fdset, ufdset, nr);
    1145                 :            :         } else {
    1146                 :            :                 zero_fd_set(nr, fdset);
    1147                 :            :                 return 0;
    1148                 :            :         }
    1149                 :            : }
    1150                 :            : 
    1151                 :            : static
    1152                 :            : int compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
    1153                 :            :                       unsigned long *fdset)
    1154                 :            : {
    1155                 :            :         if (!ufdset)
    1156                 :            :                 return 0;
    1157                 :            :         return compat_put_bitmap(ufdset, fdset, nr);
    1158                 :            : }
    1159                 :            : 
    1160                 :            : 
    1161                 :            : /*
    1162                 :            :  * This is a virtual copy of sys_select from fs/select.c and probably
    1163                 :            :  * should be compared to it from time to time
    1164                 :            :  */
    1165                 :            : 
    1166                 :            : /*
    1167                 :            :  * We can actually return ERESTARTSYS instead of EINTR, but I'd
    1168                 :            :  * like to be certain this leads to no problems. So I return
    1169                 :            :  * EINTR just for safety.
    1170                 :            :  *
    1171                 :            :  * Update: ERESTARTSYS breaks at least the xview clock binary, so
    1172                 :            :  * I'm trying ERESTARTNOHAND which restart only when you want to.
    1173                 :            :  */
    1174                 :            : static int compat_core_sys_select(int n, compat_ulong_t __user *inp,
    1175                 :            :         compat_ulong_t __user *outp, compat_ulong_t __user *exp,
    1176                 :            :         struct timespec64 *end_time)
    1177                 :            : {
    1178                 :            :         fd_set_bits fds;
    1179                 :            :         void *bits;
    1180                 :            :         int size, max_fds, ret = -EINVAL;
    1181                 :            :         struct fdtable *fdt;
    1182                 :            :         long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
    1183                 :            : 
    1184                 :            :         if (n < 0)
    1185                 :            :                 goto out_nofds;
    1186                 :            : 
    1187                 :            :         /* max_fds can increase, so grab it once to avoid race */
    1188                 :            :         rcu_read_lock();
    1189                 :            :         fdt = files_fdtable(current->files);
    1190                 :            :         max_fds = fdt->max_fds;
    1191                 :            :         rcu_read_unlock();
    1192                 :            :         if (n > max_fds)
    1193                 :            :                 n = max_fds;
    1194                 :            : 
    1195                 :            :         /*
    1196                 :            :          * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
    1197                 :            :          * since we used fdset we need to allocate memory in units of
    1198                 :            :          * long-words.
    1199                 :            :          */
    1200                 :            :         size = FDS_BYTES(n);
    1201                 :            :         bits = stack_fds;
    1202                 :            :         if (size > sizeof(stack_fds) / 6) {
    1203                 :            :                 bits = kmalloc_array(6, size, GFP_KERNEL);
    1204                 :            :                 ret = -ENOMEM;
    1205                 :            :                 if (!bits)
    1206                 :            :                         goto out_nofds;
    1207                 :            :         }
    1208                 :            :         fds.in      = (unsigned long *)  bits;
    1209                 :            :         fds.out     = (unsigned long *) (bits +   size);
    1210                 :            :         fds.ex      = (unsigned long *) (bits + 2*size);
    1211                 :            :         fds.res_in  = (unsigned long *) (bits + 3*size);
    1212                 :            :         fds.res_out = (unsigned long *) (bits + 4*size);
    1213                 :            :         fds.res_ex  = (unsigned long *) (bits + 5*size);
    1214                 :            : 
    1215                 :            :         if ((ret = compat_get_fd_set(n, inp, fds.in)) ||
    1216                 :            :             (ret = compat_get_fd_set(n, outp, fds.out)) ||
    1217                 :            :             (ret = compat_get_fd_set(n, exp, fds.ex)))
    1218                 :            :                 goto out;
    1219                 :            :         zero_fd_set(n, fds.res_in);
    1220                 :            :         zero_fd_set(n, fds.res_out);
    1221                 :            :         zero_fd_set(n, fds.res_ex);
    1222                 :            : 
    1223                 :            :         ret = do_select(n, &fds, end_time);
    1224                 :            : 
    1225                 :            :         if (ret < 0)
    1226                 :            :                 goto out;
    1227                 :            :         if (!ret) {
    1228                 :            :                 ret = -ERESTARTNOHAND;
    1229                 :            :                 if (signal_pending(current))
    1230                 :            :                         goto out;
    1231                 :            :                 ret = 0;
    1232                 :            :         }
    1233                 :            : 
    1234                 :            :         if (compat_set_fd_set(n, inp, fds.res_in) ||
    1235                 :            :             compat_set_fd_set(n, outp, fds.res_out) ||
    1236                 :            :             compat_set_fd_set(n, exp, fds.res_ex))
    1237                 :            :                 ret = -EFAULT;
    1238                 :            : out:
    1239                 :            :         if (bits != stack_fds)
    1240                 :            :                 kfree(bits);
    1241                 :            : out_nofds:
    1242                 :            :         return ret;
    1243                 :            : }
    1244                 :            : 
    1245                 :            : static int do_compat_select(int n, compat_ulong_t __user *inp,
    1246                 :            :         compat_ulong_t __user *outp, compat_ulong_t __user *exp,
    1247                 :            :         struct old_timeval32 __user *tvp)
    1248                 :            : {
    1249                 :            :         struct timespec64 end_time, *to = NULL;
    1250                 :            :         struct old_timeval32 tv;
    1251                 :            :         int ret;
    1252                 :            : 
    1253                 :            :         if (tvp) {
    1254                 :            :                 if (copy_from_user(&tv, tvp, sizeof(tv)))
    1255                 :            :                         return -EFAULT;
    1256                 :            : 
    1257                 :            :                 to = &end_time;
    1258                 :            :                 if (poll_select_set_timeout(to,
    1259                 :            :                                 tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),
    1260                 :            :                                 (tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))
    1261                 :            :                         return -EINVAL;
    1262                 :            :         }
    1263                 :            : 
    1264                 :            :         ret = compat_core_sys_select(n, inp, outp, exp, to);
    1265                 :            :         return poll_select_finish(&end_time, tvp, PT_OLD_TIMEVAL, ret);
    1266                 :            : }
    1267                 :            : 
    1268                 :            : COMPAT_SYSCALL_DEFINE5(select, int, n, compat_ulong_t __user *, inp,
    1269                 :            :         compat_ulong_t __user *, outp, compat_ulong_t __user *, exp,
    1270                 :            :         struct old_timeval32 __user *, tvp)
    1271                 :            : {
    1272                 :            :         return do_compat_select(n, inp, outp, exp, tvp);
    1273                 :            : }
    1274                 :            : 
    1275                 :            : struct compat_sel_arg_struct {
    1276                 :            :         compat_ulong_t n;
    1277                 :            :         compat_uptr_t inp;
    1278                 :            :         compat_uptr_t outp;
    1279                 :            :         compat_uptr_t exp;
    1280                 :            :         compat_uptr_t tvp;
    1281                 :            : };
    1282                 :            : 
    1283                 :            : COMPAT_SYSCALL_DEFINE1(old_select, struct compat_sel_arg_struct __user *, arg)
    1284                 :            : {
    1285                 :            :         struct compat_sel_arg_struct a;
    1286                 :            : 
    1287                 :            :         if (copy_from_user(&a, arg, sizeof(a)))
    1288                 :            :                 return -EFAULT;
    1289                 :            :         return do_compat_select(a.n, compat_ptr(a.inp), compat_ptr(a.outp),
    1290                 :            :                                 compat_ptr(a.exp), compat_ptr(a.tvp));
    1291                 :            : }
    1292                 :            : 
    1293                 :            : static long do_compat_pselect(int n, compat_ulong_t __user *inp,
    1294                 :            :         compat_ulong_t __user *outp, compat_ulong_t __user *exp,
    1295                 :            :         void __user *tsp, compat_sigset_t __user *sigmask,
    1296                 :            :         compat_size_t sigsetsize, enum poll_time_type type)
    1297                 :            : {
    1298                 :            :         struct timespec64 ts, end_time, *to = NULL;
    1299                 :            :         int ret;
    1300                 :            : 
    1301                 :            :         if (tsp) {
    1302                 :            :                 switch (type) {
    1303                 :            :                 case PT_OLD_TIMESPEC:
    1304                 :            :                         if (get_old_timespec32(&ts, tsp))
    1305                 :            :                                 return -EFAULT;
    1306                 :            :                         break;
    1307                 :            :                 case PT_TIMESPEC:
    1308                 :            :                         if (get_timespec64(&ts, tsp))
    1309                 :            :                                 return -EFAULT;
    1310                 :            :                         break;
    1311                 :            :                 default:
    1312                 :            :                         BUG();
    1313                 :            :                 }
    1314                 :            : 
    1315                 :            :                 to = &end_time;
    1316                 :            :                 if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
    1317                 :            :                         return -EINVAL;
    1318                 :            :         }
    1319                 :            : 
    1320                 :            :         ret = set_compat_user_sigmask(sigmask, sigsetsize);
    1321                 :            :         if (ret)
    1322                 :            :                 return ret;
    1323                 :            : 
    1324                 :            :         ret = compat_core_sys_select(n, inp, outp, exp, to);
    1325                 :            :         return poll_select_finish(&end_time, tsp, type, ret);
    1326                 :            : }
    1327                 :            : 
    1328                 :            : COMPAT_SYSCALL_DEFINE6(pselect6_time64, int, n, compat_ulong_t __user *, inp,
    1329                 :            :         compat_ulong_t __user *, outp, compat_ulong_t __user *, exp,
    1330                 :            :         struct __kernel_timespec __user *, tsp, void __user *, sig)
    1331                 :            : {
    1332                 :            :         compat_size_t sigsetsize = 0;
    1333                 :            :         compat_uptr_t up = 0;
    1334                 :            : 
    1335                 :            :         if (sig) {
    1336                 :            :                 if (!access_ok(sig,
    1337                 :            :                                 sizeof(compat_uptr_t)+sizeof(compat_size_t)) ||
    1338                 :            :                                 __get_user(up, (compat_uptr_t __user *)sig) ||
    1339                 :            :                                 __get_user(sigsetsize,
    1340                 :            :                                 (compat_size_t __user *)(sig+sizeof(up))))
    1341                 :            :                         return -EFAULT;
    1342                 :            :         }
    1343                 :            : 
    1344                 :            :         return do_compat_pselect(n, inp, outp, exp, tsp, compat_ptr(up),
    1345                 :            :                                  sigsetsize, PT_TIMESPEC);
    1346                 :            : }
    1347                 :            : 
    1348                 :            : #if defined(CONFIG_COMPAT_32BIT_TIME)
    1349                 :            : 
    1350                 :            : COMPAT_SYSCALL_DEFINE6(pselect6_time32, int, n, compat_ulong_t __user *, inp,
    1351                 :            :         compat_ulong_t __user *, outp, compat_ulong_t __user *, exp,
    1352                 :            :         struct old_timespec32 __user *, tsp, void __user *, sig)
    1353                 :            : {
    1354                 :            :         compat_size_t sigsetsize = 0;
    1355                 :            :         compat_uptr_t up = 0;
    1356                 :            : 
    1357                 :            :         if (sig) {
    1358                 :            :                 if (!access_ok(sig,
    1359                 :            :                                 sizeof(compat_uptr_t)+sizeof(compat_size_t)) ||
    1360                 :            :                         __get_user(up, (compat_uptr_t __user *)sig) ||
    1361                 :            :                         __get_user(sigsetsize,
    1362                 :            :                                 (compat_size_t __user *)(sig+sizeof(up))))
    1363                 :            :                         return -EFAULT;
    1364                 :            :         }
    1365                 :            : 
    1366                 :            :         return do_compat_pselect(n, inp, outp, exp, tsp, compat_ptr(up),
    1367                 :            :                                  sigsetsize, PT_OLD_TIMESPEC);
    1368                 :            : }
    1369                 :            : 
    1370                 :            : #endif
    1371                 :            : 
    1372                 :            : #if defined(CONFIG_COMPAT_32BIT_TIME)
    1373                 :            : COMPAT_SYSCALL_DEFINE5(ppoll_time32, struct pollfd __user *, ufds,
    1374                 :            :         unsigned int,  nfds, struct old_timespec32 __user *, tsp,
    1375                 :            :         const compat_sigset_t __user *, sigmask, compat_size_t, sigsetsize)
    1376                 :            : {
    1377                 :            :         struct timespec64 ts, end_time, *to = NULL;
    1378                 :            :         int ret;
    1379                 :            : 
    1380                 :            :         if (tsp) {
    1381                 :            :                 if (get_old_timespec32(&ts, tsp))
    1382                 :            :                         return -EFAULT;
    1383                 :            : 
    1384                 :            :                 to = &end_time;
    1385                 :            :                 if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
    1386                 :            :                         return -EINVAL;
    1387                 :            :         }
    1388                 :            : 
    1389                 :            :         ret = set_compat_user_sigmask(sigmask, sigsetsize);
    1390                 :            :         if (ret)
    1391                 :            :                 return ret;
    1392                 :            : 
    1393                 :            :         ret = do_sys_poll(ufds, nfds, to);
    1394                 :            :         return poll_select_finish(&end_time, tsp, PT_OLD_TIMESPEC, ret);
    1395                 :            : }
    1396                 :            : #endif
    1397                 :            : 
    1398                 :            : /* New compat syscall for 64 bit time_t*/
    1399                 :            : COMPAT_SYSCALL_DEFINE5(ppoll_time64, struct pollfd __user *, ufds,
    1400                 :            :         unsigned int,  nfds, struct __kernel_timespec __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_timespec64(&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_TIMESPEC, ret);
    1421                 :            : }
    1422                 :            : 
    1423                 :            : #endif
    

Generated by: LCOV version 1.14