[PATCH] fs: sys_poll with timeout -1 bug fix
[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         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 /*
550  * Fish for pollable events on the pollfd->fd file descriptor. We're only
551  * interested in events matching the pollfd->events mask, and the result
552  * matching that mask is both recorded in pollfd->revents and returned. The
553  * pwait poll_table will be used by the fd-provided poll handler for waiting,
554  * if non-NULL.
555  */
556 static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait)
557 {
558         unsigned int mask;
559         int fd;
560
561         mask = 0;
562         fd = pollfd->fd;
563         if (fd >= 0) {
564                 int fput_needed;
565                 struct file * file;
566
567                 file = fget_light(fd, &fput_needed);
568                 mask = POLLNVAL;
569                 if (file != NULL) {
570                         mask = DEFAULT_POLLMASK;
571                         if (file->f_op && file->f_op->poll)
572                                 mask = file->f_op->poll(file, pwait);
573                         /* Mask out unneeded events. */
574                         mask &= pollfd->events | POLLERR | POLLHUP;
575                         fput_light(file, fput_needed);
576                 }
577         }
578         pollfd->revents = mask;
579
580         return mask;
581 }
582
583 static int do_poll(unsigned int nfds,  struct poll_list *list,
584                    struct poll_wqueues *wait, s64 *timeout)
585 {
586         int count = 0;
587         poll_table* pt = &wait->pt;
588
589         /* Optimise the no-wait case */
590         if (!(*timeout))
591                 pt = NULL;
592  
593         for (;;) {
594                 struct poll_list *walk;
595                 long __timeout;
596
597                 set_current_state(TASK_INTERRUPTIBLE);
598                 for (walk = list; walk != NULL; walk = walk->next) {
599                         struct pollfd * pfd, * pfd_end;
600
601                         pfd = walk->entries;
602                         pfd_end = pfd + walk->len;
603                         for (; pfd != pfd_end; pfd++) {
604                                 /*
605                                  * Fish for events. If we found one, record it
606                                  * and kill the poll_table, so we don't
607                                  * needlessly register any other waiters after
608                                  * this. They'll get immediately deregistered
609                                  * when we break out and return.
610                                  */
611                                 if (do_pollfd(pfd, pt)) {
612                                         count++;
613                                         pt = NULL;
614                                 }
615                         }
616                 }
617                 /*
618                  * All waiters have already been registered, so don't provide
619                  * a poll_table to them on the next loop iteration.
620                  */
621                 pt = NULL;
622                 if (count || !*timeout || signal_pending(current))
623                         break;
624                 count = wait->error;
625                 if (count)
626                         break;
627
628                 if (*timeout < 0) {
629                         /* Wait indefinitely */
630                         __timeout = MAX_SCHEDULE_TIMEOUT;
631                 } else if (unlikely(*timeout >= (s64)MAX_SCHEDULE_TIMEOUT-1)) {
632                         /*
633                          * Wait for longer than MAX_SCHEDULE_TIMEOUT. Do it in
634                          * a loop
635                          */
636                         __timeout = MAX_SCHEDULE_TIMEOUT - 1;
637                         *timeout -= __timeout;
638                 } else {
639                         __timeout = *timeout;
640                         *timeout = 0;
641                 }
642
643                 __timeout = schedule_timeout(__timeout);
644                 if (*timeout >= 0)
645                         *timeout += __timeout;
646         }
647         __set_current_state(TASK_RUNNING);
648         return count;
649 }
650
651 #define N_STACK_PPS ((sizeof(stack_pps) - sizeof(struct poll_list))  / \
652                         sizeof(struct pollfd))
653
654 int do_sys_poll(struct pollfd __user *ufds, unsigned int nfds, s64 *timeout)
655 {
656         struct poll_wqueues table;
657         int fdcount, err;
658         unsigned int i;
659         struct poll_list *head;
660         struct poll_list *walk;
661         struct fdtable *fdt;
662         int max_fdset;
663         /* Allocate small arguments on the stack to save memory and be
664            faster - use long to make sure the buffer is aligned properly
665            on 64 bit archs to avoid unaligned access */
666         long stack_pps[POLL_STACK_ALLOC/sizeof(long)];
667         struct poll_list *stack_pp = NULL;
668
669         /* Do a sanity check on nfds ... */
670         rcu_read_lock();
671         fdt = files_fdtable(current->files);
672         max_fdset = fdt->max_fdset;
673         rcu_read_unlock();
674         if (nfds > max_fdset && nfds > OPEN_MAX)
675                 return -EINVAL;
676
677         poll_initwait(&table);
678
679         head = NULL;
680         walk = NULL;
681         i = nfds;
682         err = -ENOMEM;
683         while(i!=0) {
684                 struct poll_list *pp;
685                 int num, size;
686                 if (stack_pp == NULL)
687                         num = N_STACK_PPS;
688                 else
689                         num = POLLFD_PER_PAGE;
690                 if (num > i)
691                         num = i;
692                 size = sizeof(struct poll_list) + sizeof(struct pollfd)*num;
693                 if (!stack_pp)
694                         stack_pp = pp = (struct poll_list *)stack_pps;
695                 else {
696                         pp = kmalloc(size, GFP_KERNEL);
697                         if (!pp)
698                                 goto out_fds;
699                 }
700                 pp->next=NULL;
701                 pp->len = num;
702                 if (head == NULL)
703                         head = pp;
704                 else
705                         walk->next = pp;
706
707                 walk = pp;
708                 if (copy_from_user(pp->entries, ufds + nfds-i, 
709                                 sizeof(struct pollfd)*num)) {
710                         err = -EFAULT;
711                         goto out_fds;
712                 }
713                 i -= pp->len;
714         }
715
716         fdcount = do_poll(nfds, head, &table, timeout);
717
718         /* OK, now copy the revents fields back to user space. */
719         walk = head;
720         err = -EFAULT;
721         while(walk != NULL) {
722                 struct pollfd *fds = walk->entries;
723                 int j;
724
725                 for (j=0; j < walk->len; j++, ufds++) {
726                         if(__put_user(fds[j].revents, &ufds->revents))
727                                 goto out_fds;
728                 }
729                 walk = walk->next;
730         }
731         err = fdcount;
732         if (!fdcount && signal_pending(current))
733                 err = -EINTR;
734 out_fds:
735         walk = head;
736         while(walk!=NULL) {
737                 struct poll_list *pp = walk->next;
738                 if (walk != stack_pp)
739                         kfree(walk);
740                 walk = pp;
741         }
742         poll_freewait(&table);
743         return err;
744 }
745
746 asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
747                         long timeout_msecs)
748 {
749         s64 timeout_jiffies;
750
751         if (timeout_msecs > 0) {
752 #if HZ > 1000
753                 /* We can only overflow if HZ > 1000 */
754                 if (timeout_msecs / 1000 > (s64)0x7fffffffffffffffULL / (s64)HZ)
755                         timeout_jiffies = -1;
756                 else
757 #endif
758                         timeout_jiffies = msecs_to_jiffies(timeout_msecs);
759         } else {
760                 /* Infinite (< 0) or no (0) timeout */
761                 timeout_jiffies = timeout_msecs;
762         }
763
764         return do_sys_poll(ufds, nfds, &timeout_jiffies);
765 }
766
767 #ifdef TIF_RESTORE_SIGMASK
768 asmlinkage long sys_ppoll(struct pollfd __user *ufds, unsigned int nfds,
769         struct timespec __user *tsp, const sigset_t __user *sigmask,
770         size_t sigsetsize)
771 {
772         sigset_t ksigmask, sigsaved;
773         struct timespec ts;
774         s64 timeout = -1;
775         int ret;
776
777         if (tsp) {
778                 if (copy_from_user(&ts, tsp, sizeof(ts)))
779                         return -EFAULT;
780
781                 /* Cast to u64 to make GCC stop complaining */
782                 if ((u64)ts.tv_sec >= (u64)MAX_INT64_SECONDS)
783                         timeout = -1;   /* infinite */
784                 else {
785                         timeout = ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
786                         timeout += ts.tv_sec * HZ;
787                 }
788         }
789
790         if (sigmask) {
791                 /* XXX: Don't preclude handling different sized sigset_t's.  */
792                 if (sigsetsize != sizeof(sigset_t))
793                         return -EINVAL;
794                 if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
795                         return -EFAULT;
796
797                 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
798                 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
799         }
800
801         ret = do_sys_poll(ufds, nfds, &timeout);
802
803         /* We can restart this syscall, usually */
804         if (ret == -EINTR) {
805                 /*
806                  * Don't restore the signal mask yet. Let do_signal() deliver
807                  * the signal on the way back to userspace, before the signal
808                  * mask is restored.
809                  */
810                 if (sigmask) {
811                         memcpy(&current->saved_sigmask, &sigsaved,
812                                         sizeof(sigsaved));
813                         set_thread_flag(TIF_RESTORE_SIGMASK);
814                 }
815                 ret = -ERESTARTNOHAND;
816         } else if (sigmask)
817                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
818
819         if (tsp && timeout >= 0) {
820                 struct timespec rts;
821
822                 if (current->personality & STICKY_TIMEOUTS)
823                         goto sticky;
824                 /* Yes, we know it's actually an s64, but it's also positive. */
825                 rts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) *
826                                                 1000;
827                 rts.tv_sec = timeout;
828                 if (timespec_compare(&rts, &ts) >= 0)
829                         rts = ts;
830                 if (copy_to_user(tsp, &rts, sizeof(rts))) {
831                 sticky:
832                         /*
833                          * If an application puts its timeval in read-only
834                          * memory, we don't want the Linux-specific update to
835                          * the timeval to cause a fault after the select has
836                          * completed successfully. However, because we're not
837                          * updating the timeval, we can't restart the system
838                          * call.
839                          */
840                         if (ret == -ERESTARTNOHAND && timeout >= 0)
841                                 ret = -EINTR;
842                 }
843         }
844
845         return ret;
846 }
847 #endif /* TIF_RESTORE_SIGMASK */