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