Patched in Tegra support.

1 files changed, 52 insertions, 39 deletions

diff --git a/fs/select.c b/fs/select.c
index 2ef72d96503..d33418fdc85 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -17,7 +17,7 @@
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/syscalls.h>
-#include <linux/export.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
 #include <linux/personality.h> /* for STICKY_TIMEOUTS */
@@ -220,9 +220,10 @@ static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
         struct poll_table_entry *entry = poll_get_entry(pwq);
         if (!entry)
                 return;
-        entry->filp = get_file(filp);
+        get_file(filp);
+        entry->filp = filp;
         entry->wait_address = wait_address;
-        entry->key = p->_key;
+        entry->key = p->key;
         init_waitqueue_func_entry(&entry->wait, pollwake);
         entry->wait.private = pwq;
         add_wait_queue(wait_address, &entry->wait);
@@ -344,10 +345,10 @@ static int max_select_fd(unsigned long n, fd_set_bits *fds)
         struct fdtable *fdt;
 
         /* handle last in-complete long-word first */
-        set = ~(~0UL << (n & (BITS_PER_LONG-1)));
-        n /= BITS_PER_LONG;
+        set = ~(~0UL << (n & (__NFDBITS-1)));
+        n /= __NFDBITS;
         fdt = files_fdtable(current->files);
-        open_fds = fdt->open_fds + n;
+        open_fds = fdt->open_fds->fds_bits+n;
         max = 0;
         if (set) {
                 set &= BITS(fds, n);
@@ -372,7 +373,7 @@ get_max:
                         max++;
                         set >>= 1;
                 } while (set);
-                max += n * BITS_PER_LONG;
+                max += n * __NFDBITS;
         }
 
         return max;
@@ -385,11 +386,13 @@ get_max:
 static inline void wait_key_set(poll_table *wait, unsigned long in,
                                 unsigned long out, unsigned long bit)
 {
-        wait->_key = POLLEX_SET;
-        if (in & bit)
-                wait->_key |= POLLIN_SET;
-        if (out & bit)
-                wait->_key |= POLLOUT_SET;
+        if (wait) {
+                wait->key = POLLEX_SET;
+                if (in & bit)
+                        wait->key |= POLLIN_SET;
+                if (out & bit)
+                        wait->key |= POLLOUT_SET;
+        }
 }
 
 int do_select(int n, fd_set_bits *fds, struct timespec *end_time)
@@ -411,7 +414,7 @@ int do_select(int n, fd_set_bits *fds, struct timespec *end_time)
         poll_initwait(&table);
         wait = &table.pt;
         if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {
-                wait->_qproc = NULL;
+                wait = NULL;
                 timed_out = 1;
         }
 
@@ -428,44 +431,45 @@ int do_select(int n, fd_set_bits *fds, struct timespec *end_time)
                 for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
                         unsigned long in, out, ex, all_bits, bit = 1, mask, j;
                         unsigned long res_in = 0, res_out = 0, res_ex = 0;
+                        const struct file_operations *f_op = NULL;
+                        struct file *file = NULL;
 
                         in = *inp++; out = *outp++; ex = *exp++;
                         all_bits = in | out | ex;
                         if (all_bits == 0) {
-                                i += BITS_PER_LONG;
+                                i += __NFDBITS;
                                 continue;
                         }
 
-                        for (j = 0; j < BITS_PER_LONG; ++j, ++i, bit <<= 1) {
-                                struct fd f;
+                        for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {
+                                int fput_needed;
                                 if (i >= n)
                                         break;
                                 if (!(bit & all_bits))
                                         continue;
-                                f = fdget(i);
-                                if (f.file) {
-                                        const struct file_operations *f_op;
-                                        f_op = f.file->f_op;
+                                file = fget_light(i, &fput_needed);
+                                if (file) {
+                                        f_op = file->f_op;
                                         mask = DEFAULT_POLLMASK;
                                         if (f_op && f_op->poll) {
                                                 wait_key_set(wait, in, out, bit);
-                                                mask = (*f_op->poll)(f.file, wait);
+                                                mask = (*f_op->poll)(file, wait);
                                         }
-                                        fdput(f);
+                                        fput_light(file, fput_needed);
                                         if ((mask & POLLIN_SET) && (in & bit)) {
                                                 res_in |= bit;
                                                 retval++;
-                                                wait->_qproc = NULL;
+                                                wait = NULL;
                                         }
                                         if ((mask & POLLOUT_SET) && (out & bit)) {
                                                 res_out |= bit;
                                                 retval++;
-                                                wait->_qproc = NULL;
+                                                wait = NULL;
                                         }
                                         if ((mask & POLLEX_SET) && (ex & bit)) {
                                                 res_ex |= bit;
                                                 retval++;
-                                                wait->_qproc = NULL;
+                                                wait = NULL;
                                         }
                                 }
                         }
@@ -477,7 +481,7 @@ int do_select(int n, fd_set_bits *fds, struct timespec *end_time)
                                 *rexp = res_ex;
                         cond_resched();
                 }
-                wait->_qproc = NULL;
+                wait = NULL;
                 if (retval || timed_out || signal_pending(current))
                         break;
                 if (table.error) {
@@ -612,6 +616,7 @@ SYSCALL_DEFINE5(select, int, n, fd_set __user *, inp, fd_set __user *, outp,
         return ret;
 }
 
+#ifdef HAVE_SET_RESTORE_SIGMASK
 static long do_pselect(int n, fd_set __user *inp, fd_set __user *outp,
                        fd_set __user *exp, struct timespec __user *tsp,
                        const sigset_t __user *sigmask, size_t sigsetsize)
@@ -683,6 +688,7 @@ SYSCALL_DEFINE6(pselect6, int, n, fd_set __user *, inp, fd_set __user *, outp,
 
         return do_pselect(n, inp, outp, exp, tsp, up, sigsetsize);
 }
+#endif /* HAVE_SET_RESTORE_SIGMASK */
 
 #ifdef __ARCH_WANT_SYS_OLD_SELECT
 struct sel_arg_struct {
@@ -714,7 +720,7 @@ struct poll_list {
  * 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 pwait->_qproc is non-NULL.
+ * if non-NULL.
  */
 static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait)
 {
@@ -724,17 +730,22 @@ static inline unsigned int do_pollfd(struct pollfd *pollfd, poll_table *pwait)
         mask = 0;
         fd = pollfd->fd;
         if (fd >= 0) {
-                struct fd f = fdget(fd);
+                int fput_needed;
+                struct file * file;
+
+                file = fget_light(fd, &fput_needed);
                 mask = POLLNVAL;
-                if (f.file) {
+                if (file != NULL) {
                         mask = DEFAULT_POLLMASK;
-                        if (f.file->f_op && f.file->f_op->poll) {
-                                pwait->_key = pollfd->events|POLLERR|POLLHUP;
-                                mask = f.file->f_op->poll(f.file, pwait);
+                        if (file->f_op && file->f_op->poll) {
+                                if (pwait)
+                                        pwait->key = pollfd->events |
+                                                        POLLERR | POLLHUP;
+                                mask = file->f_op->poll(file, pwait);
                         }
                         /* Mask out unneeded events. */
                         mask &= pollfd->events | POLLERR | POLLHUP;
-                        fdput(f);
+                        fput_light(file, fput_needed);
                 }
         }
         pollfd->revents = mask;
@@ -752,7 +763,7 @@ static int do_poll(unsigned int nfds,  struct poll_list *list,
 
         /* Optimise the no-wait case */
         if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {
-                pt->_qproc = NULL;
+                pt = NULL;
                 timed_out = 1;
         }
 
@@ -770,22 +781,22 @@ static int do_poll(unsigned int nfds,  struct poll_list *list,
                         for (; pfd != pfd_end; pfd++) {
                                 /*
                                  * Fish for events. If we found one, record it
-                                 * and kill poll_table->_qproc, so we don't
+                                 * 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->_qproc = NULL;
+                                        pt = NULL;
                                 }
                         }
                 }
                 /*
                  * All waiters have already been registered, so don't provide
-                 * a poll_table->_qproc to them on the next loop iteration.
+                 * a poll_table to them on the next loop iteration.
                  */
-                pt->_qproc = NULL;
+                pt = NULL;
                 if (!count) {
                         count = wait->error;
                         if (signal_pending(current))
@@ -901,7 +912,7 @@ static long do_restart_poll(struct restart_block *restart_block)
 }
 
 SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds,
-                int, timeout_msecs)
+                long, timeout_msecs)
 {
         struct timespec end_time, *to = NULL;
         int ret;
@@ -934,6 +945,7 @@ SYSCALL_DEFINE3(poll, struct pollfd __user *, ufds, unsigned int, nfds,
         return ret;
 }
 
+#ifdef HAVE_SET_RESTORE_SIGMASK
 SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds, unsigned int, nfds,
                 struct timespec __user *, tsp, const sigset_t __user *, sigmask,
                 size_t, sigsetsize)
@@ -984,3 +996,4 @@ SYSCALL_DEFINE5(ppoll, struct pollfd __user *, ufds, unsigned int, nfds,
 
         return ret;
 }
+#endif /* HAVE_SET_RESTORE_SIGMASK */