41c3571e64edff36a22a29b5dd7e707c9cb5cf2f
[linux-2.6.git] / 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 || !*timeout || signal_pending(current))
620                         break;
621                 count = wait->error;
622                 if (count)
623                         break;
624
625                 if (*timeout < 0) {
626                         /* Wait indefinitely */
627                         __timeout = MAX_SCHEDULE_TIMEOUT;
628                 } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT-1)) {
629                         /*
630                          * Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in
631                          * a loop
632                          */
633                         __timeout = MAX_SCHEDULE_TIMEOUT - 1;
634                         *timeout -= __timeout;
635                 } else {
636                         __timeout = *timeout;
637                         *timeout = 0;
638                 }
639
640                 __timeout = schedule_timeout(__timeout);
641                 if (*timeout >= 0)
642                         *timeout += __timeout;
643         }
644         __set_current_state(TASK_RUNNING);
645         return count;
646 }
647
648 #define N_STACK_PPS ((sizeof(stack_pps) - sizeof(struct poll_list))  / \
649                         sizeof(struct pollfd))
650
651 int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds, s64 *timeout)
652 {
653         struct poll_wqueues table;
654         int err = -EFAULT, fdcount, len, size;
655         /* Allocate small arguments on the stack to save memory and be
656            faster - use long to make sure the buffer is aligned properly
657            on 64 bit archs to avoid unaligned access */
658         long stack_pps[POLL_STACK_ALLOC/sizeof(long)];
659         struct poll_list *const head = (struct poll_list *)stack_pps;
660         struct poll_list *walk = head;
661         unsigned long todo = nfds;
662
663         if (nfds > current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
664                 return -EINVAL;
665
666         len = min_t(unsigned int, nfds, N_STACK_PPS);
667         for (;;) {
668                 walk->next = NULL;
669                 walk->len = len;
670                 if (!len)
671                         break;
672
673                 if (copy_from_user(walk->entries, ufds + nfds-todo,
674                                         sizeof(struct pollfd) * walk->len))
675                         goto out_fds;
676
677                 todo -= walk->len;
678                 if (!todo)
679                         break;
680
681                 len = min(todo, POLLFD_PER_PAGE);
682                 size = sizeof(struct poll_list) + sizeof(struct pollfd) * len;
683                 walk = walk->next = kmalloc(size, GFP_KERNEL);
684                 if (!walk) {
685                         err = -ENOMEM;
686                         goto out_fds;
687                 }
688         }
689
690         poll_initwait(&table);
691         fdcount = do_poll(nfds, head, &table, timeout);
692         if (!fdcount && signal_pending(current))
693                 fdcount = -EINTR;
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 asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
718                         long timeout_msecs)
719 {
720         s64 timeout_jiffies;
721
722         if (timeout_msecs > 0) {
723 #if HZ > 1000
724                 /* We can only overflow if HZ > 1000 */
725                 if (timeout_msecs / 1000 > (s64)0x7fffffffffffffffULL / (s64)HZ)
726                         timeout_jiffies = -1;
727                 else
728 #endif
729                         timeout_jiffies = msecs_to_jiffies(timeout_msecs);
730         } else {
731                 /* Infinite (< 0) or no (0) timeout */
732                 timeout_jiffies = timeout_msecs;
733         }
734
735         return do_sys_poll(ufds, nfds, &timeout_jiffies);
736 }
737
738 #ifdef TIF_RESTORE_SIGMASK
739 asmlinkage long sys_ppoll(struct pollfd __user *ufds, unsigned int nfds,
740         struct timespec __user *tsp, const sigset_t __user *sigmask,
741         size_t sigsetsize)
742 {
743         sigset_t ksigmask, sigsaved;
744         struct timespec ts;
745         s64 timeout = -1;
746         int ret;
747
748         if (tsp) {
749                 if (copy_from_user(&ts, tsp, sizeof(ts)))
750                         return -EFAULT;
751
752                 /* Cast to u64 to make GCC stop complaining */
753                 if ((u64)ts.tv_sec >= (u64)MAX_INT64_SECONDS)
754                         timeout = -1;   /* infinite */
755                 else {
756                         timeout = DIV_ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
757                         timeout += ts.tv_sec * HZ;
758                 }
759         }
760
761         if (sigmask) {
762                 /* XXX: Don't preclude handling different sized sigset_t's.  */
763                 if (sigsetsize != sizeof(sigset_t))
764                         return -EINVAL;
765                 if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
766                         return -EFAULT;
767
768                 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
769                 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
770         }
771
772         ret = do_sys_poll(ufds, nfds, &timeout);
773
774         /* We can restart this syscall, usually */
775         if (ret == -EINTR) {
776                 /*
777                  * Don't restore the signal mask yet. Let do_signal() deliver
778                  * the signal on the way back to userspace, before the signal
779                  * mask is restored.
780                  */
781                 if (sigmask) {
782                         memcpy(&current->saved_sigmask, &sigsaved,
783                                         sizeof(sigsaved));
784                         set_thread_flag(TIF_RESTORE_SIGMASK);
785                 }
786                 ret = -ERESTARTNOHAND;
787         } else if (sigmask)
788                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
789
790         if (tsp && timeout >= 0) {
791                 struct timespec rts;
792
793                 if (current->personality & STICKY_TIMEOUTS)
794                         goto sticky;
795                 /* Yes, we know it's actually an s64, but it's also positive. */
796                 rts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) *
797                                                 1000;
798                 rts.tv_sec = timeout;
799                 if (timespec_compare(&rts, &ts) >= 0)
800                         rts = ts;
801                 if (copy_to_user(tsp, &rts, sizeof(rts))) {
802                 sticky:
803                         /*
804                          * If an application puts its timeval in read-only
805                          * memory, we don't want the Linux-specific update to
806                          * the timeval to cause a fault after the select has
807                          * completed successfully. However, because we're not
808                          * updating the timeval, we can't restart the system
809                          * call.
810                          */
811                         if (ret == -ERESTARTNOHAND && timeout >= 0)
812                                 ret = -EINTR;
813                 }
814         }
815
816         return ret;
817 }
818 #endif /* TIF_RESTORE_SIGMASK */