git.oblomov.eu Git - linux-2.6/blob - fs/select.c

   1 /*
   2  * This file contains the procedures for the handling of select and poll
   3  *
   4  * Created for Linux based loosely upon Mathius Lattner's minix
   5  * patches by Peter MacDonald. Heavily edited by Linus.
   6  *
   7  *  4 February 1994
   8  *     COFF/ELF binary emulation. If the process has the STICKY_TIMEOUTS
   9  *     flag set in its personality we do *not* modify the given timeout
  10  *     parameter to reflect time remaining.
  11  *
  12  *  24 January 2000
  13  *     Changed sys_poll()/do_poll() to use PAGE_SIZE chunk-based allocation
  14  *     of fds to overcome nfds < 16390 descriptors limit (Tigran Aivazian).
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/syscalls.h>
  19 #include <linux/module.h>
  20 #include <linux/slab.h>
  21 #include <linux/poll.h>
  22 #include <linux/personality.h> /* for STICKY_TIMEOUTS */
  23 #include <linux/file.h>
  24 #include <linux/fs.h>
  25 #include <linux/rcupdate.h>
  26
  27 #include <asm/uaccess.h>
  28
  29 struct poll_table_page {
  30         struct poll_table_page * next;
  31         struct poll_table_entry * entry;
  32         struct poll_table_entry entries[0];
  33 };
  34
  35 #define POLL_TABLE_FULL(table) \
  36         ((unsigned long)((table)->entry+1) > PAGE_SIZE + (unsigned long)(table))
  37
  38 /*
  39  * Ok, Peter made a complicated, but straightforward multiple_wait() function.
  40  * I have rewritten this, taking some shortcuts: This code may not be easy to
  41  * follow, but it should be free of race-conditions, and it's practical. If you
  42  * understand what I'm doing here, then you understand how the linux
  43  * sleep/wakeup mechanism works.
  44  *
  45  * Two very simple procedures, poll_wait() and poll_freewait() make all the
  46  * work.  poll_wait() is an inline-function defined in <linux/poll.h>,
  47  * as all select/poll functions have to call it to add an entry to the
  48  * poll table.
  49  */
  50 static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
  51                        poll_table *p);
  52
  53 void poll_initwait(struct poll_wqueues *pwq)
  54 {
  55         init_poll_funcptr(&pwq->pt, __pollwait);
  56         pwq->error = 0;
  57         pwq->table = NULL;
  58         pwq->inline_index = 0;
  59 }
  60
  61 EXPORT_SYMBOL(poll_initwait);
  62
  63 static void free_poll_entry(struct poll_table_entry *entry)
  64 {
  65         remove_wait_queue(entry->wait_address, &entry->wait);
  66         fput(entry->filp);
  67 }
  68
  69 void poll_freewait(struct poll_wqueues *pwq)
  70 {
  71         struct poll_table_page * p = pwq->table;
  72         int i;
  73         for (i = 0; i < pwq->inline_index; i++)
  74                 free_poll_entry(pwq->inline_entries + i);
  75         while (p) {
  76                 struct poll_table_entry * entry;
  77                 struct poll_table_page *old;
  78
  79                 entry = p->entry;
  80                 do {
  81                         entry--;
  82                         free_poll_entry(entry);
  83                 } while (entry > p->entries);
  84                 old = p;
  85                 p = p->next;
  86                 free_page((unsigned long) old);
  87         }
  88 }
  89
  90 EXPORT_SYMBOL(poll_freewait);
  91
  92 static struct poll_table_entry *poll_get_entry(poll_table *_p)
  93 {
  94         struct poll_wqueues *p = container_of(_p, struct poll_wqueues, pt);
  95         struct poll_table_page *table = p->table;
  96
  97         if (p->inline_index < N_INLINE_POLL_ENTRIES)
  98                 return p->inline_entries + p->inline_index++;
  99
 100         if (!table || POLL_TABLE_FULL(table)) {
 101                 struct poll_table_page *new_table;
 102
 103                 new_table = (struct poll_table_page *) __get_free_page(GFP_KERNEL);
 104                 if (!new_table) {
 105                         p->error = -ENOMEM;
 106                         __set_current_state(TASK_RUNNING);
 107                         return NULL;
 108                 }
 109                 new_table->entry = new_table->entries;
 110                 new_table->next = table;
 111                 p->table = new_table;
 112                 table = new_table;
 113         }
 114
 115         return table->entry++;
 116 }
 117
 118 /* Add a new entry */
 119 static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
 120                                 poll_table *p)
 121 {
 122         struct poll_table_entry *entry = poll_get_entry(p);
 123         if (!entry)
 124                 return;
 125         get_file(filp);
 126         entry->filp = filp;
 127         entry->wait_address = wait_address;
 128         init_waitqueue_entry(&entry->wait, current);
 129         add_wait_queue(wait_address, &entry->wait);
 130 }
 131
 132 #define FDS_IN(fds, n)          (fds->in + n)
 133 #define FDS_OUT(fds, n)         (fds->out + n)
 134 #define FDS_EX(fds, n)          (fds->ex + n)
 135
 136 #define BITS(fds, n)    (*FDS_IN(fds, n)|*FDS_OUT(fds, n)|*FDS_EX(fds, n))
 137
 138 static int max_select_fd(unsigned long n, fd_set_bits *fds)
 139 {
 140         unsigned long *open_fds;
 141         unsigned long set;
 142         int max;
 143         struct fdtable *fdt;
 144
 145         /* handle last in-complete long-word first */
 146         set = ~(~0UL << (n & (__NFDBITS-1)));
 147         n /= __NFDBITS;
 148         fdt = files_fdtable(current->files);
 149         open_fds = fdt->open_fds->fds_bits+n;
 150         max = 0;
 151         if (set) {
 152                 set &= BITS(fds, n);
 153                 if (set) {
 154                         if (!(set & ~*open_fds))
 155                                 goto get_max;
 156                         return -EBADF;
 157                 }
 158         }
 159         while (n) {
 160                 open_fds--;
 161                 n--;
 162                 set = BITS(fds, n);
 163                 if (!set)
 164                         continue;
 165                 if (set & ~*open_fds)
 166                         return -EBADF;
 167                 if (max)
 168                         continue;
 169 get_max:
 170                 do {
 171                         max++;
 172                         set >>= 1;
 173                 } while (set);
 174                 max += n * __NFDBITS;
 175         }
 176
 177         return max;
 178 }
 179
 180 #define BIT(i)          (1UL << ((i)&(__NFDBITS-1)))
 181 #define MEM(i,m)        ((m)+(unsigned)(i)/__NFDBITS)
 182 #define ISSET(i,m)      (((i)&*(m)) != 0)
 183 #define SET(i,m)        (*(m) |= (i))
 184
 185 #define POLLIN_SET (POLLRDNORM | POLLRDBAND | POLLIN | POLLHUP | POLLERR)
 186 #define POLLOUT_SET (POLLWRBAND | POLLWRNORM | POLLOUT | POLLERR)
 187 #define POLLEX_SET (POLLPRI)
 188
 189 int do_select(int n, fd_set_bits *fds, s64 *timeout)
 190 {
 191         struct poll_wqueues table;
 192         poll_table *wait;
 193         int retval, i;
 194
 195         rcu_read_lock();
 196         retval = max_select_fd(n, fds);
 197         rcu_read_unlock();
 198
 199         if (retval < 0)
 200                 return retval;
 201         n = retval;
 202
 203         poll_initwait(&table);
 204         wait = &table.pt;
 205         if (!*timeout)
 206                 wait = NULL;
 207         retval = 0;
 208         for (;;) {
 209                 unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
 210                 long __timeout;
 211
 212                 set_current_state(TASK_INTERRUPTIBLE);
 213
 214                 inp = fds->in; outp = fds->out; exp = fds->ex;
 215                 rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;
 216
 217                 for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
 218                         unsigned long in, out, ex, all_bits, bit = 1, mask, j;
 219                         unsigned long res_in = 0, res_out = 0, res_ex = 0;
 220                         const struct file_operations *f_op = NULL;
 221                         struct file *file = NULL;
 222
 223                         in = *inp++; out = *outp++; ex = *exp++;
 224                         all_bits = in | out | ex;
 225                         if (all_bits == 0) {
 226                                 i += __NFDBITS;
 227                                 continue;
 228                         }
 229
 230                         for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {
 231                                 int fput_needed;
 232                                 if (i >= n)
 233                                         break;
 234                                 if (!(bit & all_bits))
 235                                         continue;
 236                                 file = fget_light(i, &fput_needed);
 237                                 if (file) {
 238                                         f_op = file->f_op;
 239                                         mask = DEFAULT_POLLMASK;
 240                                         if (f_op && f_op->poll)
 241                                                 mask = (*f_op->poll)(file, retval ? NULL : wait);
 242                                         fput_light(file, fput_needed);
 243                                         if ((mask & POLLIN_SET) && (in & bit)) {
 244                                                 res_in |= bit;
 245                                                 retval++;
 246                                         }
 247                                         if ((mask & POLLOUT_SET) && (out & bit)) {
 248                                                 res_out |= bit;
 249                                                 retval++;
 250                                         }
 251                                         if ((mask & POLLEX_SET) && (ex & bit)) {
 252                                                 res_ex |= bit;
 253                                                 retval++;
 254                                         }
 255                                 }
 256                                 cond_resched();
 257                         }
 258                         if (res_in)
 259                                 *rinp = res_in;
 260                         if (res_out)
 261                                 *routp = res_out;
 262                         if (res_ex)
 263                                 *rexp = res_ex;
 264                 }
 265                 wait = NULL;
 266                 if (retval || !*timeout || signal_pending(current))
 267                         break;
 268                 if(table.error) {
 269                         retval = table.error;
 270                         break;
 271                 }
 272
 273                 if (*timeout < 0) {
 274                         /* Wait indefinitely */
 275                         __timeout = MAX_SCHEDULE_TIMEOUT;
 276                 } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT - 1)) {
 277                         /* Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in a loop */
 278                         __timeout = MAX_SCHEDULE_TIMEOUT - 1;
 279                         *timeout -= __timeout;
 280                 } else {
 281                         __timeout = *timeout;
 282                         *timeout = 0;
 283                 }
 284                 __timeout = schedule_timeout(__timeout);
 285                 if (*timeout >= 0)
 286                         *timeout += __timeout;
 287         }
 288         __set_current_state(TASK_RUNNING);
 289
 290         poll_freewait(&table);
 291
 292         return retval;
 293 }
 294
 295 /*
 296  * We can actually return ERESTARTSYS instead of EINTR, but I'd
 297  * like to be certain this leads to no problems. So I return
 298  * EINTR just for safety.
 299  *
 300  * Update: ERESTARTSYS breaks at least the xview clock binary, so
 301  * I'm trying ERESTARTNOHAND which restart only when you want to.
 302  */
 303 #define MAX_SELECT_SECONDS \
 304         ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
 305
 306 static int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
 307                            fd_set __user *exp, s64 *timeout)
 308 {
 309         fd_set_bits fds;
 310         void *bits;
 311         int ret, max_fds;
 312         unsigned int size;
 313         struct fdtable *fdt;
 314         /* Allocate small arguments on the stack to save memory and be faster */
 315         long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
 316
 317         ret = -EINVAL;
 318         if (n < 0)
 319                 goto out_nofds;
 320
 321         /* max_fds can increase, so grab it once to avoid race */
 322         rcu_read_lock();
 323         fdt = files_fdtable(current->files);
 324         max_fds = fdt->max_fds;
 325         rcu_read_unlock();
 326         if (n > max_fds)
 327                 n = max_fds;
 328
 329         /*
 330          * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
 331          * since we used fdset we need to allocate memory in units of
 332          * long-words.
 333          */
 334         size = FDS_BYTES(n);
 335         bits = stack_fds;
 336         if (size > sizeof(stack_fds) / 6) {
 337                 /* Not enough space in on-stack array; must use kmalloc */
 338                 ret = -ENOMEM;
 339                 bits = kmalloc(6 * size, GFP_KERNEL);
 340                 if (!bits)
 341                         goto out_nofds;
 342         }
 343         fds.in      = bits;
 344         fds.out     = bits +   size;
 345         fds.ex      = bits + 2*size;
 346         fds.res_in  = bits + 3*size;
 347         fds.res_out = bits + 4*size;
 348         fds.res_ex  = bits + 5*size;
 349
 350         if ((ret = get_fd_set(n, inp, fds.in)) ||
 351             (ret = get_fd_set(n, outp, fds.out)) ||
 352             (ret = get_fd_set(n, exp, fds.ex)))
 353                 goto out;
 354         zero_fd_set(n, fds.res_in);
 355         zero_fd_set(n, fds.res_out);
 356         zero_fd_set(n, fds.res_ex);
 357
 358         ret = do_select(n, &fds, timeout);
 359
 360         if (ret < 0)
 361                 goto out;
 362         if (!ret) {
 363                 ret = -ERESTARTNOHAND;
 364                 if (signal_pending(current))
 365                         goto out;
 366                 ret = 0;
 367         }
 368
 369         if (set_fd_set(n, inp, fds.res_in) ||
 370             set_fd_set(n, outp, fds.res_out) ||
 371             set_fd_set(n, exp, fds.res_ex))
 372                 ret = -EFAULT;
 373
 374 out:
 375         if (bits != stack_fds)
 376                 kfree(bits);
 377 out_nofds:
 378         return ret;
 379 }
 380
 381 asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
 382                         fd_set __user *exp, struct timeval __user *tvp)
 383 {
 384         s64 timeout = -1;
 385         struct timeval tv;
 386         int ret;
 387
 388         if (tvp) {
 389                 if (copy_from_user(&tv, tvp, sizeof(tv)))
 390                         return -EFAULT;
 391
 392                 if (tv.tv_sec < 0 || tv.tv_usec < 0)
 393                         return -EINVAL;
 394
 395                 /* Cast to u64 to make GCC stop complaining */
 396                 if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)
 397                         timeout = -1;   /* infinite */
 398                 else {
 399                         timeout = DIV_ROUND_UP(tv.tv_usec, USEC_PER_SEC/HZ);
 400                         timeout += tv.tv_sec * HZ;
 401                 }
 402         }
 403
 404         ret = core_sys_select(n, inp, outp, exp, &timeout);
 405
 406         if (tvp) {
 407                 struct timeval rtv;
 408
 409                 if (current->personality & STICKY_TIMEOUTS)
 410                         goto sticky;
 411                 rtv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));
 412                 rtv.tv_sec = timeout;
 413                 if (timeval_compare(&rtv, &tv) >= 0)
 414                         rtv = tv;
 415                 if (copy_to_user(tvp, &rtv, sizeof(rtv))) {
 416 sticky:
 417                         /*
 418                          * If an application puts its timeval in read-only
 419                          * memory, we don't want the Linux-specific update to
 420                          * the timeval to cause a fault after the select has
 421                          * completed successfully. However, because we're not
 422                          * updating the timeval, we can't restart the system
 423                          * call.
 424                          */
 425                         if (ret == -ERESTARTNOHAND)
 426                                 ret = -EINTR;
 427                 }
 428         }
 429
 430         return ret;
 431 }
 432
 433 #ifdef TIF_RESTORE_SIGMASK
 434 asmlinkage long sys_pselect7(int n, fd_set __user *inp, fd_set __user *outp,
 435                 fd_set __user *exp, struct timespec __user *tsp,
 436                 const sigset_t __user *sigmask, size_t sigsetsize)
 437 {
 438         s64 timeout = MAX_SCHEDULE_TIMEOUT;
 439         sigset_t ksigmask, sigsaved;
 440         struct timespec ts;
 441         int ret;
 442
 443         if (tsp) {
 444                 if (copy_from_user(&ts, tsp, sizeof(ts)))
 445                         return -EFAULT;
 446
 447                 if (ts.tv_sec < 0 || ts.tv_nsec < 0)
 448                         return -EINVAL;
 449
 450                 /* Cast to u64 to make GCC stop complaining */
 451                 if ((u64)ts.tv_sec >= (u64)MAX_INT64_SECONDS)
 452                         timeout = -1;   /* infinite */
 453                 else {
 454                         timeout = DIV_ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
 455                         timeout += ts.tv_sec * HZ;
 456                 }
 457         }
 458
 459         if (sigmask) {
 460                 /* XXX: Don't preclude handling different sized sigset_t's.  */
 461                 if (sigsetsize != sizeof(sigset_t))
 462                         return -EINVAL;
 463                 if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
 464                         return -EFAULT;
 465
 466                 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
 467                 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
 468         }
 469
 470         ret = core_sys_select(n, inp, outp, exp, &timeout);
 471
 472         if (tsp) {
 473                 struct timespec rts;
 474
 475                 if (current->personality & STICKY_TIMEOUTS)
 476                         goto sticky;
 477                 rts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) *
 478                                                 1000;
 479                 rts.tv_sec = timeout;
 480                 if (timespec_compare(&rts, &ts) >= 0)
 481                         rts = ts;
 482                 if (copy_to_user(tsp, &rts, sizeof(rts))) {
 483 sticky:
 484                         /*
 485                          * If an application puts its timeval in read-only
 486                          * memory, we don't want the Linux-specific update to
 487                          * the timeval to cause a fault after the select has
 488                          * completed successfully. However, because we're not
 489                          * updating the timeval, we can't restart the system
 490                          * call.
 491                          */
 492                         if (ret == -ERESTARTNOHAND)
 493                                 ret = -EINTR;
 494                 }
 495         }
 496
 497         if (ret == -ERESTARTNOHAND) {
 498                 /*
 499                  * Don't restore the signal mask yet. Let do_signal() deliver
 500                  * the signal on the way back to userspace, before the signal
 501                  * mask is restored.
 502                  */
 503                 if (sigmask) {
 504                         memcpy(&current->saved_sigmask, &sigsaved,
 505                                         sizeof(sigsaved));
 506                         set_thread_flag(TIF_RESTORE_SIGMASK);
 507                 }
 508         } else if (sigmask)
 509                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
 510
 511         return ret;
 512 }
 513
 514 /*
 515  * Most architectures can't handle 7-argument syscalls. So we provide a
 516  * 6-argument version where the sixth argument is a pointer to a structure
 517  * which has a pointer to the sigset_t itself followed by a size_t containing
 518  * the sigset size.
 519  */
 520 asmlinkage long sys_pselect6(int n, fd_set __user *inp, fd_set __user *outp,
 521         fd_set __user *exp, struct timespec __user *tsp, void __user *sig)
 522 {
 523         size_t sigsetsize = 0;
 524         sigset_t __user *up = NULL;
 525
 526         if (sig) {
 527                 if (!access_ok(VERIFY_READ, sig, sizeof(void *)+sizeof(size_t))
 528                     || __get_user(up, (sigset_t __user * __user *)sig)
 529                     || __get_user(sigsetsize,
 530                                 (size_t __user *)(sig+sizeof(void *))))
 531                         return -EFAULT;
 532         }
 533
 534         return sys_pselect7(n, inp, outp, exp, tsp, up, sigsetsize);
 535 }
 536 #endif /* TIF_RESTORE_SIGMASK */
 537
 538 struct poll_list {
 539         struct poll_list *next;
 540         int len;
 541         struct pollfd entries[0];
 542 };
 543
 544 #define POLLFD_PER_PAGE  ((PAGE_SIZE-sizeof(struct poll_list)) / sizeof(struct pollfd))
 545
 546 /*
 547  * Fish for pollable events on the pollfd->fd file descriptor. We're only
 548  * interested in events matching the pollfd->events mask, and the result
 549  * matching that mask is both recorded in pollfd->revents and returned. The
 550  * pwait poll_table will be used by the fd-provided poll handler for waiting,
 551  * if non-NULL.
 552  */
 553 static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait)
 554 {
 555         unsigned int mask;
 556         int fd;
 557
 558         mask = 0;
 559         fd = pollfd->fd;
 560         if (fd >= 0) {
 561                 int fput_needed;
 562                 struct file * file;
 563
 564                 file = fget_light(fd, &fput_needed);
 565                 mask = POLLNVAL;
 566                 if (file != NULL) {
 567                         mask = DEFAULT_POLLMASK;
 568                         if (file->f_op && file->f_op->poll)
 569                                 mask = file->f_op->poll(file, pwait);
 570                         /* Mask out unneeded events. */
 571                         mask &= pollfd->events | POLLERR | POLLHUP;
 572                         fput_light(file, fput_needed);
 573                 }
 574         }
 575         pollfd->revents = mask;
 576
 577         return mask;
 578 }
 579
 580 static int do_poll(unsigned int nfds,  struct poll_list *list,
 581                    struct poll_wqueues *wait, s64 *timeout)
 582 {
 583         int count = 0;
 584         poll_table* pt = &wait->pt;
 585
 586         /* Optimise the no-wait case */
 587         if (!(*timeout))
 588                 pt = NULL;
 589
 590         for (;;) {
 591                 struct poll_list *walk;
 592                 long __timeout;
 593
 594                 set_current_state(TASK_INTERRUPTIBLE);
 595                 for (walk = list; walk != NULL; walk = walk->next) {
 596                         struct pollfd * pfd, * pfd_end;
 597
 598                         pfd = walk->entries;
 599                         pfd_end = pfd + walk->len;
 600                         for (; pfd != pfd_end; pfd++) {
 601                                 /*
 602                                  * Fish for events. If we found one, record it
 603                                  * and kill the poll_table, so we don't
 604                                  * needlessly register any other waiters after
 605                                  * this. They'll get immediately deregistered
 606                                  * when we break out and return.
 607                                  */
 608                                 if (do_pollfd(pfd, pt)) {
 609                                         count++;
 610                                         pt = NULL;
 611                                 }
 612                         }
 613                 }
 614                 /*
 615                  * All waiters have already been registered, so don't provide
 616                  * a poll_table to them on the next loop iteration.
 617                  */
 618                 pt = NULL;
 619                 if (!count) {
 620                         count = wait->error;
 621                         if (signal_pending(current))
 622                                 count = -EINTR;
 623                 }
 624                 if (count || !*timeout)
 625                         break;
 626
 627                 if (*timeout < 0) {
 628                         /* Wait indefinitely */
 629                         __timeout = MAX_SCHEDULE_TIMEOUT;
 630                 } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT-1)) {
 631                         /*
 632                          * Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in
 633                          * a loop
 634                          */
 635                         __timeout = MAX_SCHEDULE_TIMEOUT - 1;
 636                         *timeout -= __timeout;
 637                 } else {
 638                         __timeout = *timeout;
 639                         *timeout = 0;
 640                 }
 641
 642                 __timeout = schedule_timeout(__timeout);
 643                 if (*timeout >= 0)
 644                         *timeout += __timeout;
 645         }
 646         __set_current_state(TASK_RUNNING);
 647         return count;
 648 }
 649
 650 #define N_STACK_PPS ((sizeof(stack_pps) - sizeof(struct poll_list))  / \
 651                         sizeof(struct pollfd))
 652
 653 int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds, s64 *timeout)
 654 {
 655         struct poll_wqueues table;
 656         int err = -EFAULT, fdcount, len, size;
 657         /* Allocate small arguments on the stack to save memory and be
 658            faster - use long to make sure the buffer is aligned properly
 659            on 64 bit archs to avoid unaligned access */
 660         long stack_pps[POLL_STACK_ALLOC/sizeof(long)];
 661         struct poll_list *const head = (struct poll_list *)stack_pps;
 662         struct poll_list *walk = head;
 663         unsigned long todo = nfds;
 664
 665         if (nfds > current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
 666                 return -EINVAL;
 667
 668         len = min_t(unsigned int, nfds, N_STACK_PPS);
 669         for (;;) {
 670                 walk->next = NULL;
 671                 walk->len = len;
 672                 if (!len)
 673                         break;
 674
 675                 if (copy_from_user(walk->entries, ufds + nfds-todo,
 676                                         sizeof(struct pollfd) * walk->len))
 677                         goto out_fds;
 678
 679                 todo -= walk->len;
 680                 if (!todo)
 681                         break;
 682
 683                 len = min(todo, POLLFD_PER_PAGE);
 684                 size = sizeof(struct poll_list) + sizeof(struct pollfd) * len;
 685                 walk = walk->next = kmalloc(size, GFP_KERNEL);
 686                 if (!walk) {
 687                         err = -ENOMEM;
 688                         goto out_fds;
 689                 }
 690         }
 691
 692         poll_initwait(&table);
 693         fdcount = do_poll(nfds, head, &table, timeout);
 694         poll_freewait(&table);
 695
 696         for (walk = head; walk; walk = walk->next) {
 697                 struct pollfd *fds = walk->entries;
 698                 int j;
 699
 700                 for (j = 0; j < walk->len; j++, ufds++)
 701                         if (__put_user(fds[j].revents, &ufds->revents))
 702                                 goto out_fds;
 703         }
 704
 705         err = fdcount;
 706 out_fds:
 707         walk = head->next;
 708         while (walk) {
 709                 struct poll_list *pos = walk;
 710                 walk = walk->next;
 711                 kfree(pos);
 712         }
 713
 714         return err;
 715 }
 716
 717 static long do_restart_poll(struct restart_block *restart_block)
 718 {
 719         struct pollfd __user *ufds = (struct pollfd __user*)restart_block->arg0;
 720         int nfds = restart_block->arg1;
 721         s64 timeout = ((s64)restart_block->arg3<<32) | (s64)restart_block->arg2;
 722         int ret;
 723
 724         ret = do_sys_poll(ufds, nfds, &timeout);
 725         if (ret == -EINTR) {
 726                 restart_block->fn = do_restart_poll;
 727                 restart_block->arg2 = timeout & 0xFFFFFFFF;
 728                 restart_block->arg3 = (u64)timeout >> 32;
 729                 ret = -ERESTART_RESTARTBLOCK;
 730         }
 731         return ret;
 732 }
 733
 734 asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
 735                         long timeout_msecs)
 736 {
 737         s64 timeout_jiffies;
 738         int ret;
 739
 740         if (timeout_msecs > 0) {
 741 #if HZ > 1000
 742                 /* We can only overflow if HZ > 1000 */
 743                 if (timeout_msecs / 1000 > (s64)0x7fffffffffffffffULL / (s64)HZ)
 744                         timeout_jiffies = -1;
 745                 else
 746 #endif
 747                         timeout_jiffies = msecs_to_jiffies(timeout_msecs);
 748         } else {
 749                 /* Infinite (< 0) or no (0) timeout */
 750                 timeout_jiffies = timeout_msecs;
 751         }
 752
 753         ret = do_sys_poll(ufds, nfds, &timeout_jiffies);
 754         if (ret == -EINTR) {
 755                 struct restart_block *restart_block;
 756                 restart_block = &current_thread_info()->restart_block;
 757                 restart_block->fn = do_restart_poll;
 758                 restart_block->arg0 = (unsigned long)ufds;
 759                 restart_block->arg1 = nfds;
 760                 restart_block->arg2 = timeout_jiffies & 0xFFFFFFFF;
 761                 restart_block->arg3 = (u64)timeout_jiffies >> 32;
 762                 ret = -ERESTART_RESTARTBLOCK;
 763         }
 764         return ret;
 765 }
 766
 767 #ifdef TIF_RESTORE_SIGMASK
 768 asmlinkage long sys_ppoll(struct pollfd __user *ufds, unsigned int nfds,
 769         struct timespec __user *tsp, const sigset_t __user *sigmask,
 770         size_t sigsetsize)
 771 {
 772         sigset_t ksigmask, sigsaved;
 773         struct timespec ts;
 774         s64 timeout = -1;
 775         int ret;
 776
 777         if (tsp) {
 778                 if (copy_from_user(&ts, tsp, sizeof(ts)))
 779                         return -EFAULT;
 780
 781                 /* Cast to u64 to make GCC stop complaining */
 782                 if ((u64)ts.tv_sec >= (u64)MAX_INT64_SECONDS)
 783                         timeout = -1;   /* infinite */
 784                 else {
 785                         timeout = DIV_ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
 786                         timeout += ts.tv_sec * HZ;
 787                 }
 788         }
 789
 790         if (sigmask) {
 791                 /* XXX: Don't preclude handling different sized sigset_t's.  */
 792                 if (sigsetsize != sizeof(sigset_t))
 793                         return -EINVAL;
 794                 if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
 795                         return -EFAULT;
 796
 797                 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
 798                 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
 799         }
 800
 801         ret = do_sys_poll(ufds, nfds, &timeout);
 802
 803         /* We can restart this syscall, usually */
 804         if (ret == -EINTR) {
 805                 /*
 806                  * Don't restore the signal mask yet. Let do_signal() deliver
 807                  * the signal on the way back to userspace, before the signal
 808                  * mask is restored.
 809                  */
 810                 if (sigmask) {
 811                         memcpy(&current->saved_sigmask, &sigsaved,
 812                                         sizeof(sigsaved));
 813                         set_thread_flag(TIF_RESTORE_SIGMASK);
 814                 }
 815                 ret = -ERESTARTNOHAND;
 816         } else if (sigmask)
 817                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
 818
 819         if (tsp && timeout >= 0) {
 820                 struct timespec rts;
 821
 822                 if (current->personality & STICKY_TIMEOUTS)
 823                         goto sticky;
 824                 /* Yes, we know it's actually an s64, but it's also positive. */
 825                 rts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) *
 826                                                 1000;
 827                 rts.tv_sec = timeout;
 828                 if (timespec_compare(&rts, &ts) >= 0)
 829                         rts = ts;
 830                 if (copy_to_user(tsp, &rts, sizeof(rts))) {
 831                 sticky:
 832                         /*
 833                          * If an application puts its timeval in read-only
 834                          * memory, we don't want the Linux-specific update to
 835                          * the timeval to cause a fault after the select has
 836                          * completed successfully. However, because we're not
 837                          * updating the timeval, we can't restart the system
 838                          * call.
 839                          */
 840                         if (ret == -ERESTARTNOHAND && timeout >= 0)
 841                                 ret = -EINTR;
 842                 }
 843         }
 844
 845         return ret;
 846 }
 847 #endif /* TIF_RESTORE_SIGMASK */