[S390] appldata enhancements.

[linux-2.6-omap-h63xx.git] / fs / select.c

diff --git a/fs/select.c b/fs/select.c
index fce0fd1bb1d1210feeda5fbb328c064c5ca007f9..33b72ba0f86f45790bd7661053266cd8336c9757 100644 (file)
--- a/fs/select.c
+++ b/fs/select.c
@@ -311,7 +311,8 @@ static int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
 {
        fd_set_bits fds;
        void *bits;
-       int ret, size, max_fdset;
+       int ret, max_fdset;
+       unsigned int size;
        struct fdtable *fdt;
        /* Allocate small arguments on the stack to save memory and be faster */
        long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
@@ -333,14 +334,15 @@ static int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
         * since we used fdset we need to allocate memory in units of
         * long-words. 
         */
-       ret = -ENOMEM;
        size = FDS_BYTES(n);
-       if (6*size < SELECT_STACK_ALLOC)
-               bits = stack_fds;
-       else
+       bits = stack_fds;
+       if (size > sizeof(stack_fds) / 6) {
+               /* Not enough space in on-stack array; must use kmalloc */
+               ret = -ENOMEM;
                bits = kmalloc(6 * size, GFP_KERNEL);
-       if (!bits)
-               goto out_nofds;
+               if (!bits)
+                       goto out_nofds;
+       }
        fds.in      = bits;
        fds.out     = bits +   size;
        fds.ex      = bits + 2*size;
@@ -544,37 +546,38 @@ struct poll_list {
 
 #define POLLFD_PER_PAGE  ((PAGE_SIZE-sizeof(struct poll_list)) / sizeof(struct pollfd))
 
-static void do_pollfd(unsigned int num, struct pollfd * fdpage,
-       poll_table ** pwait, int *count)
+/*
+ * Fish for pollable events on the pollfd->fd file descriptor. We're only
+ * interested in events matching the pollfd->events mask, and the result
+ * matching that mask is both recorded in pollfd->revents and returned. The
+ * pwait poll_table will be used by the fd-provided poll handler for waiting,
+ * if non-NULL.
+ */
+static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait)
 {
-       int i;
-
-       for (i = 0; i < num; i++) {
-               int fd;
-               unsigned int mask;
-               struct pollfd *fdp;
-
-               mask = 0;
-               fdp = fdpage+i;
-               fd = fdp->fd;
-               if (fd >= 0) {
-                       int fput_needed;
-                       struct file * file = fget_light(fd, &fput_needed);
-                       mask = POLLNVAL;
-                       if (file != NULL) {
-                               mask = DEFAULT_POLLMASK;
-                               if (file->f_op && file->f_op->poll)
-                                       mask = file->f_op->poll(file, *pwait);
-                               mask &= fdp->events | POLLERR | POLLHUP;
-                               fput_light(file, fput_needed);
-                       }
-                       if (mask) {
-                               *pwait = NULL;
-                               (*count)++;
-                       }
+       unsigned int mask;
+       int fd;
+
+       mask = 0;
+       fd = pollfd->fd;
+       if (fd >= 0) {
+               int fput_needed;
+               struct file * file;
+
+               file = fget_light(fd, &fput_needed);
+               mask = POLLNVAL;
+               if (file != NULL) {
+                       mask = DEFAULT_POLLMASK;
+                       if (file->f_op && file->f_op->poll)
+                               mask = file->f_op->poll(file, pwait);
+                       /* Mask out unneeded events. */
+                       mask &= pollfd->events | POLLERR | POLLHUP;
+                       fput_light(file, fput_needed);
                }
-               fdp->revents = mask;
        }
+       pollfd->revents = mask;
+
+       return mask;
 }
 
 static int do_poll(unsigned int nfds,  struct poll_list *list,
@@ -592,11 +595,29 @@ static int do_poll(unsigned int nfds,  struct poll_list *list,
                long __timeout;
 
                set_current_state(TASK_INTERRUPTIBLE);
-               walk = list;
-               while(walk != NULL) {
-                       do_pollfd( walk->len, walk->entries, &pt, &count);
-                       walk = walk->next;
+               for (walk = list; walk != NULL; walk = walk->next) {
+                       struct pollfd * pfd, * pfd_end;
+
+                       pfd = walk->entries;
+                       pfd_end = pfd + walk->len;
+                       for (; pfd != pfd_end; pfd++) {
+                               /*
+                                * Fish for events. If we found one, record it
+                                * and kill the poll_table, so we don't
+                                * needlessly register any other waiters after
+                                * this. They'll get immediately deregistered
+                                * when we break out and return.
+                                */
+                               if (do_pollfd(pfd, pt)) {
+                                       count++;
+                                       pt = NULL;
+                               }
+                       }
                }
+               /*
+                * All waiters have already been registered, so don't provide
+                * a poll_table to them on the next loop iteration.
+                */
                pt = NULL;
                if (count || !*timeout || signal_pending(current))
                        break;
@@ -725,9 +746,9 @@ out_fds:
 asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
                        long timeout_msecs)
 {
-       s64 timeout_jiffies = 0;
+       s64 timeout_jiffies;
 
-       if (timeout_msecs) {
+       if (timeout_msecs > 0) {
 #if HZ > 1000
                /* We can only overflow if HZ > 1000 */
                if (timeout_msecs / 1000 > (s64)0x7fffffffffffffffULL / (s64)HZ)
@@ -735,6 +756,9 @@ asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
                else
 #endif
                        timeout_jiffies = msecs_to_jiffies(timeout_msecs);
+       } else {
+               /* Infinite (< 0) or no (0) timeout */
+               timeout_jiffies = timeout_msecs;
        }
 
        return do_sys_poll(ufds, nfds, &timeout_jiffies);