[JFFS2] Fix section mismatch warnings in JFFS2.
[linux-2.6] / 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         void *bits;
314         int ret, max_fdset;
315         unsigned int size;
316         struct fdtable *fdt;
317         /* Allocate small arguments on the stack to save memory and be faster */
318         long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
319
320         ret = -EINVAL;
321         if (n < 0)
322                 goto out_nofds;
323
324         /* max_fdset can increase, so grab it once to avoid race */
325         rcu_read_lock();
326         fdt = files_fdtable(current->files);
327         max_fdset = fdt->max_fdset;
328         rcu_read_unlock();
329         if (n > max_fdset)
330                 n = max_fdset;
331
332         /*
333          * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
334          * since we used fdset we need to allocate memory in units of
335          * long-words. 
336          */
337         size = FDS_BYTES(n);
338         bits = stack_fds;
339         if (size > sizeof(stack_fds) / 6) {
340                 /* Not enough space in on-stack array; must use kmalloc */
341                 ret = -ENOMEM;
342                 bits = kmalloc(6 * size, GFP_KERNEL);
343                 if (!bits)
344                         goto out_nofds;
345         }
346         fds.in      = bits;
347         fds.out     = bits +   size;
348         fds.ex      = bits + 2*size;
349         fds.res_in  = bits + 3*size;
350         fds.res_out = bits + 4*size;
351         fds.res_ex  = bits + 5*size;
352
353         if ((ret = get_fd_set(n, inp, fds.in)) ||
354             (ret = get_fd_set(n, outp, fds.out)) ||
355             (ret = get_fd_set(n, exp, fds.ex)))
356                 goto out;
357         zero_fd_set(n, fds.res_in);
358         zero_fd_set(n, fds.res_out);
359         zero_fd_set(n, fds.res_ex);
360
361         ret = do_select(n, &fds, timeout);
362
363         if (ret < 0)
364                 goto out;
365         if (!ret) {
366                 ret = -ERESTARTNOHAND;
367                 if (signal_pending(current))
368                         goto out;
369                 ret = 0;
370         }
371
372         if (set_fd_set(n, inp, fds.res_in) ||
373             set_fd_set(n, outp, fds.res_out) ||
374             set_fd_set(n, exp, fds.res_ex))
375                 ret = -EFAULT;
376
377 out:
378         if (bits != stack_fds)
379                 kfree(bits);
380 out_nofds:
381         return ret;
382 }
383
384 asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
385                         fd_set __user *exp, struct timeval __user *tvp)
386 {
387         s64 timeout = -1;
388         struct timeval tv;
389         int ret;
390
391         if (tvp) {
392                 if (copy_from_user(&tv, tvp, sizeof(tv)))
393                         return -EFAULT;
394
395                 if (tv.tv_sec < 0 || tv.tv_usec < 0)
396                         return -EINVAL;
397
398                 /* Cast to u64 to make GCC stop complaining */
399                 if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)
400                         timeout = -1;   /* infinite */
401                 else {
402                         timeout = ROUND_UP(tv.tv_usec, USEC_PER_SEC/HZ);
403                         timeout += tv.tv_sec * HZ;
404                 }
405         }
406
407         ret = core_sys_select(n, inp, outp, exp, &timeout);
408
409         if (tvp) {
410                 struct timeval rtv;
411
412                 if (current->personality & STICKY_TIMEOUTS)
413                         goto sticky;
414                 rtv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ));
415                 rtv.tv_sec = timeout;
416                 if (timeval_compare(&rtv, &tv) >= 0)
417                         rtv = tv;
418                 if (copy_to_user(tvp, &rtv, sizeof(rtv))) {
419 sticky:
420                         /*
421                          * If an application puts its timeval in read-only
422                          * memory, we don't want the Linux-specific update to
423                          * the timeval to cause a fault after the select has
424                          * completed successfully. However, because we're not
425                          * updating the timeval, we can't restart the system
426                          * call.
427                          */
428                         if (ret == -ERESTARTNOHAND)
429                                 ret = -EINTR;
430                 }
431         }
432
433         return ret;
434 }
435
436 #ifdef TIF_RESTORE_SIGMASK
437 asmlinkage long sys_pselect7(int n, fd_set __user *inp, fd_set __user *outp,
438                 fd_set __user *exp, struct timespec __user *tsp,
439                 const sigset_t __user *sigmask, size_t sigsetsize)
440 {
441         s64 timeout = MAX_SCHEDULE_TIMEOUT;
442         sigset_t ksigmask, sigsaved;
443         struct timespec ts;
444         int ret;
445
446         if (tsp) {
447                 if (copy_from_user(&ts, tsp, sizeof(ts)))
448                         return -EFAULT;
449
450                 if (ts.tv_sec < 0 || ts.tv_nsec < 0)
451                         return -EINVAL;
452
453                 /* Cast to u64 to make GCC stop complaining */
454                 if ((u64)ts.tv_sec >= (u64)MAX_INT64_SECONDS)
455                         timeout = -1;   /* infinite */
456                 else {
457                         timeout = ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
458                         timeout += ts.tv_sec * HZ;
459                 }
460         }
461
462         if (sigmask) {
463                 /* XXX: Don't preclude handling different sized sigset_t's.  */
464                 if (sigsetsize != sizeof(sigset_t))
465                         return -EINVAL;
466                 if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
467                         return -EFAULT;
468
469                 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
470                 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
471         }
472
473         ret = core_sys_select(n, inp, outp, exp, &timeout);
474
475         if (tsp) {
476                 struct timespec rts;
477
478                 if (current->personality & STICKY_TIMEOUTS)
479                         goto sticky;
480                 rts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) *
481                                                 1000;
482                 rts.tv_sec = timeout;
483                 if (timespec_compare(&rts, &ts) >= 0)
484                         rts = ts;
485                 if (copy_to_user(tsp, &rts, sizeof(rts))) {
486 sticky:
487                         /*
488                          * If an application puts its timeval in read-only
489                          * memory, we don't want the Linux-specific update to
490                          * the timeval to cause a fault after the select has
491                          * completed successfully. However, because we're not
492                          * updating the timeval, we can't restart the system
493                          * call.
494                          */
495                         if (ret == -ERESTARTNOHAND)
496                                 ret = -EINTR;
497                 }
498         }
499
500         if (ret == -ERESTARTNOHAND) {
501                 /*
502                  * Don't restore the signal mask yet. Let do_signal() deliver
503                  * the signal on the way back to userspace, before the signal
504                  * mask is restored.
505                  */
506                 if (sigmask) {
507                         memcpy(&current->saved_sigmask, &sigsaved,
508                                         sizeof(sigsaved));
509                         set_thread_flag(TIF_RESTORE_SIGMASK);
510                 }
511         } else if (sigmask)
512                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
513
514         return ret;
515 }
516
517 /*
518  * Most architectures can't handle 7-argument syscalls. So we provide a
519  * 6-argument version where the sixth argument is a pointer to a structure
520  * which has a pointer to the sigset_t itself followed by a size_t containing
521  * the sigset size.
522  */
523 asmlinkage long sys_pselect6(int n, fd_set __user *inp, fd_set __user *outp,
524         fd_set __user *exp, struct timespec __user *tsp, void __user *sig)
525 {
526         size_t sigsetsize = 0;
527         sigset_t __user *up = NULL;
528
529         if (sig) {
530                 if (!access_ok(VERIFY_READ, sig, sizeof(void *)+sizeof(size_t))
531                     || __get_user(up, (sigset_t __user * __user *)sig)
532                     || __get_user(sigsetsize,
533                                 (size_t __user *)(sig+sizeof(void *))))
534                         return -EFAULT;
535         }
536
537         return sys_pselect7(n, inp, outp, exp, tsp, up, sigsetsize);
538 }
539 #endif /* TIF_RESTORE_SIGMASK */
540
541 struct poll_list {
542         struct poll_list *next;
543         int len;
544         struct pollfd entries[0];
545 };
546
547 #define POLLFD_PER_PAGE  ((PAGE_SIZE-sizeof(struct poll_list)) / sizeof(struct pollfd))
548
549 static void do_pollfd(unsigned int num, struct pollfd * fdpage,
550         poll_table ** pwait, int *count)
551 {
552         int i;
553
554         for (i = 0; i < num; i++) {
555                 int fd;
556                 unsigned int mask;
557                 struct pollfd *fdp;
558
559                 mask = 0;
560                 fdp = fdpage+i;
561                 fd = fdp->fd;
562                 if (fd >= 0) {
563                         int fput_needed;
564                         struct file * 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 &= fdp->events | POLLERR | POLLHUP;
571                                 fput_light(file, fput_needed);
572                         }
573                         if (mask) {
574                                 *pwait = NULL;
575                                 (*count)++;
576                         }
577                 }
578                 fdp->revents = mask;
579         }
580 }
581
582 static int do_poll(unsigned int nfds,  struct poll_list *list,
583                    struct poll_wqueues *wait, s64 *timeout)
584 {
585         int count = 0;
586         poll_table* pt = &wait->pt;
587
588         /* Optimise the no-wait case */
589         if (!(*timeout))
590                 pt = NULL;
591  
592         for (;;) {
593                 struct poll_list *walk;
594                 long __timeout;
595
596                 set_current_state(TASK_INTERRUPTIBLE);
597                 walk = list;
598                 while(walk != NULL) {
599                         do_pollfd( walk->len, walk->entries, &pt, &count);
600                         walk = walk->next;
601                 }
602                 pt = NULL;
603                 if (count || !*timeout || signal_pending(current))
604                         break;
605                 count = wait->error;
606                 if (count)
607                         break;
608
609                 if (*timeout < 0) {
610                         /* Wait indefinitely */
611                         __timeout = MAX_SCHEDULE_TIMEOUT;
612                 } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT-1)) {
613                         /*
614                          * Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in
615                          * a loop
616                          */
617                         __timeout = MAX_SCHEDULE_TIMEOUT - 1;
618                         *timeout -= __timeout;
619                 } else {
620                         __timeout = *timeout;
621                         *timeout = 0;
622                 }
623
624                 __timeout = schedule_timeout(__timeout);
625                 if (*timeout >= 0)
626                         *timeout += __timeout;
627         }
628         __set_current_state(TASK_RUNNING);
629         return count;
630 }
631
632 #define N_STACK_PPS ((sizeof(stack_pps) - sizeof(struct poll_list))  / \
633                         sizeof(struct pollfd))
634
635 int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds, s64 *timeout)
636 {
637         struct poll_wqueues table;
638         int fdcount, err;
639         unsigned int i;
640         struct poll_list *head;
641         struct poll_list *walk;
642         struct fdtable *fdt;
643         int max_fdset;
644         /* Allocate small arguments on the stack to save memory and be
645            faster - use long to make sure the buffer is aligned properly
646            on 64 bit archs to avoid unaligned access */
647         long stack_pps[POLL_STACK_ALLOC/sizeof(long)];
648         struct poll_list *stack_pp = NULL;
649
650         /* Do a sanity check on nfds ... */
651         rcu_read_lock();
652         fdt = files_fdtable(current->files);
653         max_fdset = fdt->max_fdset;
654         rcu_read_unlock();
655         if (nfds > max_fdset && nfds > OPEN_MAX)
656                 return -EINVAL;
657
658         poll_initwait(&table);
659
660         head = NULL;
661         walk = NULL;
662         i = nfds;
663         err = -ENOMEM;
664         while(i!=0) {
665                 struct poll_list *pp;
666                 int num, size;
667                 if (stack_pp == NULL)
668                         num = N_STACK_PPS;
669                 else
670                         num = POLLFD_PER_PAGE;
671                 if (num > i)
672                         num = i;
673                 size = sizeof(struct poll_list) + sizeof(struct pollfd)*num;
674                 if (!stack_pp)
675                         stack_pp = pp = (struct poll_list *)stack_pps;
676                 else {
677                         pp = kmalloc(size, GFP_KERNEL);
678                         if (!pp)
679                                 goto out_fds;
680                 }
681                 pp->next=NULL;
682                 pp->len = num;
683                 if (head == NULL)
684                         head = pp;
685                 else
686                         walk->next = pp;
687
688                 walk = pp;
689                 if (copy_from_user(pp->entries, ufds + nfds-i, 
690                                 sizeof(struct pollfd)*num)) {
691                         err = -EFAULT;
692                         goto out_fds;
693                 }
694                 i -= pp->len;
695         }
696
697         fdcount = do_poll(nfds, head, &table, timeout);
698
699         /* OK, now copy the revents fields back to user space. */
700         walk = head;
701         err = -EFAULT;
702         while(walk != NULL) {
703                 struct pollfd *fds = walk->entries;
704                 int j;
705
706                 for (j=0; j < walk->len; j++, ufds++) {
707                         if(__put_user(fds[j].revents, &ufds->revents))
708                                 goto out_fds;
709                 }
710                 walk = walk->next;
711         }
712         err = fdcount;
713         if (!fdcount && signal_pending(current))
714                 err = -EINTR;
715 out_fds:
716         walk = head;
717         while(walk!=NULL) {
718                 struct poll_list *pp = walk->next;
719                 if (walk != stack_pp)
720                         kfree(walk);
721                 walk = pp;
722         }
723         poll_freewait(&table);
724         return err;
725 }
726
727 asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
728                         long timeout_msecs)
729 {
730         s64 timeout_jiffies = 0;
731
732         if (timeout_msecs) {
733 #if HZ > 1000
734                 /* We can only overflow if HZ > 1000 */
735                 if (timeout_msecs / 1000 > (s64)0x7fffffffffffffffULL / (s64)HZ)
736                         timeout_jiffies = -1;
737                 else
738 #endif
739                         timeout_jiffies = msecs_to_jiffies(timeout_msecs);
740         }
741
742         return do_sys_poll(ufds, nfds, &timeout_jiffies);
743 }
744
745 #ifdef TIF_RESTORE_SIGMASK
746 asmlinkage long sys_ppoll(struct pollfd __user *ufds, unsigned int nfds,
747         struct timespec __user *tsp, const sigset_t __user *sigmask,
748         size_t sigsetsize)
749 {
750         sigset_t ksigmask, sigsaved;
751         struct timespec ts;
752         s64 timeout = -1;
753         int ret;
754
755         if (tsp) {
756                 if (copy_from_user(&ts, tsp, sizeof(ts)))
757                         return -EFAULT;
758
759                 /* Cast to u64 to make GCC stop complaining */
760                 if ((u64)ts.tv_sec >= (u64)MAX_INT64_SECONDS)
761                         timeout = -1;   /* infinite */
762                 else {
763                         timeout = ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
764                         timeout += ts.tv_sec * HZ;
765                 }
766         }
767
768         if (sigmask) {
769                 /* XXX: Don't preclude handling different sized sigset_t's.  */
770                 if (sigsetsize != sizeof(sigset_t))
771                         return -EINVAL;
772                 if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
773                         return -EFAULT;
774
775                 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
776                 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
777         }
778
779         ret = do_sys_poll(ufds, nfds, &timeout);
780
781         /* We can restart this syscall, usually */
782         if (ret == -EINTR) {
783                 /*
784                  * Don't restore the signal mask yet. Let do_signal() deliver
785                  * the signal on the way back to userspace, before the signal
786                  * mask is restored.
787                  */
788                 if (sigmask) {
789                         memcpy(&current->saved_sigmask, &sigsaved,
790                                         sizeof(sigsaved));
791                         set_thread_flag(TIF_RESTORE_SIGMASK);
792                 }
793                 ret = -ERESTARTNOHAND;
794         } else if (sigmask)
795                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
796
797         if (tsp && timeout >= 0) {
798                 struct timespec rts;
799
800                 if (current->personality & STICKY_TIMEOUTS)
801                         goto sticky;
802                 /* Yes, we know it's actually an s64, but it's also positive. */
803                 rts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) *
804                                                 1000;
805                 rts.tv_sec = timeout;
806                 if (timespec_compare(&rts, &ts) >= 0)
807                         rts = ts;
808                 if (copy_to_user(tsp, &rts, sizeof(rts))) {
809                 sticky:
810                         /*
811                          * If an application puts its timeval in read-only
812                          * memory, we don't want the Linux-specific update to
813                          * the timeval to cause a fault after the select has
814                          * completed successfully. However, because we're not
815                          * updating the timeval, we can't restart the system
816                          * call.
817                          */
818                         if (ret == -ERESTARTNOHAND && timeout >= 0)
819                                 ret = -EINTR;
820                 }
821         }
822
823         return ret;
824 }
825 #endif /* TIF_RESTORE_SIGMASK */