Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/torvalds/linux-2.6

20 files changed, 239 insertions, 78 deletions

diff --git a/net/802/psnap.c b/net/802/psnap.c
index ea4643931446..b3cfe5a14fca 100644
--- a/net/802/psnap.c
+++ b/net/802/psnap.c
@@ -31,11 +31,9 @@ static struct llc_sap *snap_sap;
  */
 static struct datalink_proto *find_snap_client(unsigned char *desc)
 {
-        struct list_head *entry;
         struct datalink_proto *proto = NULL, *p;
 
-        list_for_each_rcu(entry, &snap_list) {
-                p = list_entry(entry, struct datalink_proto, node);
+        list_for_each_entry_rcu(p, &snap_list, node) {
                 if (!memcmp(p->type, desc, 5)) {
                         proto = p;
                         break;
diff --git a/net/9p/trans_fd.c b/net/9p/trans_fd.c
index 4507f744f44e..cdf137af7adc 100644
--- a/net/9p/trans_fd.c
+++ b/net/9p/trans_fd.c
@@ -1285,7 +1285,7 @@ static int p9_socket_open(struct p9_trans *trans, struct socket *csocket)
         int fd, ret;
 
         csocket->sk->sk_allocation = GFP_NOIO;
-        fd = sock_map_fd(csocket);
+        fd = sock_map_fd(csocket, 0);
         if (fd < 0) {
                 P9_EPRINTK(KERN_ERR, "p9_socket_open: failed to map fd\n");
                 return fd;
diff --git a/net/compat.c b/net/compat.c
index 6e1b03b51933..67fb6a3834a3 100644
--- a/net/compat.c
+++ b/net/compat.c
@@ -722,9 +722,10 @@ EXPORT_SYMBOL(compat_mc_getsockopt);
 
 /* Argument list sizes for compat_sys_socketcall */
 #define AL(x) ((x) * sizeof(u32))
-static unsigned char nas[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
+static unsigned char nas[19]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
                                 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
-                                AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
+                                AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
+                                AL(6)};
 #undef AL
 
 asmlinkage long compat_sys_sendmsg(int fd, struct compat_msghdr __user *msg, unsigned flags)
@@ -737,13 +738,52 @@ asmlinkage long compat_sys_recvmsg(int fd, struct compat_msghdr __user *msg, uns
         return sys_recvmsg(fd, (struct msghdr __user *)msg, flags | MSG_CMSG_COMPAT);
 }
 
+asmlinkage long compat_sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
+                                   int __user *upeer_addrlen,
+                                   const compat_sigset_t __user *sigmask,
+                                   compat_size_t sigsetsize, int flags)
+{
+        compat_sigset_t ss32;
+        sigset_t ksigmask, sigsaved;
+        int ret;
+
+        if (sigmask) {
+                if (sigsetsize != sizeof(compat_sigset_t))
+                        return -EINVAL;
+                if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
+                        return -EFAULT;
+                sigset_from_compat(&ksigmask, &ss32);
+
+                sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
+                sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
+        }
+
+        ret = do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
+
+        if (ret == -ERESTARTNOHAND) {
+                /*
+                 * Don't restore the signal mask yet. Let do_signal() deliver
+                 * the signal on the way back to userspace, before the signal
+                 * mask is restored.
+                 */
+                if (sigmask) {
+                        memcpy(&current->saved_sigmask, &sigsaved,
+                               sizeof(sigsaved));
+                        set_restore_sigmask();
+                }
+        } else if (sigmask)
+                sigprocmask(SIG_SETMASK, &sigsaved, NULL);
+
+        return ret;
+}
+
 asmlinkage long compat_sys_socketcall(int call, u32 __user *args)
 {
         int ret;
         u32 a[6];
         u32 a0, a1;
 
-        if (call < SYS_SOCKET || call > SYS_RECVMSG)
+        if (call < SYS_SOCKET || call > SYS_PACCEPT)
                 return -EINVAL;
         if (copy_from_user(a, args, nas[call]))
                 return -EFAULT;
@@ -764,7 +804,7 @@ asmlinkage long compat_sys_socketcall(int call, u32 __user *args)
                 ret = sys_listen(a0, a1);
                 break;
         case SYS_ACCEPT:
-                ret = sys_accept(a0, compat_ptr(a1), compat_ptr(a[2]));
+                ret = do_accept(a0, compat_ptr(a1), compat_ptr(a[2]), 0);
                 break;
         case SYS_GETSOCKNAME:
                 ret = sys_getsockname(a0, compat_ptr(a1), compat_ptr(a[2]));
@@ -804,6 +844,10 @@ asmlinkage long compat_sys_socketcall(int call, u32 __user *args)
         case SYS_RECVMSG:
                 ret = compat_sys_recvmsg(a0, compat_ptr(a1), a[2]);
                 break;
+        case SYS_PACCEPT:
+                ret = compat_sys_paccept(a0, compat_ptr(a1), compat_ptr(a[2]),
+                                         compat_ptr(a[3]), a[4], a[5]);
+                break;
         default:
                 ret = -EINVAL;
                 break;
diff --git a/net/core/dev.c b/net/core/dev.c
index c6f9c83745e6..8d13a9b9f1df 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -2395,7 +2395,7 @@ out:
          */
         if (!cpus_empty(net_dma.channel_mask)) {
                 int chan_idx;
-                for_each_cpu_mask(chan_idx, net_dma.channel_mask) {
+                for_each_cpu_mask_nr(chan_idx, net_dma.channel_mask) {
                         struct dma_chan *chan = net_dma.channels[chan_idx];
                         if (chan)
                                 dma_async_memcpy_issue_pending(chan);
@@ -4530,7 +4530,7 @@ static void net_dma_rebalance(struct net_dma *net_dma)
         i = 0;
         cpu = first_cpu(cpu_online_map);
 
-        for_each_cpu_mask(chan_idx, net_dma->channel_mask) {
+        for_each_cpu_mask_nr(chan_idx, net_dma->channel_mask) {
                 chan = net_dma->channels[chan_idx];
 
                 n = ((num_online_cpus() / cpus_weight(net_dma->channel_mask))
diff --git a/net/core/sysctl_net_core.c b/net/core/sysctl_net_core.c
index a570e2af22cb..f686467ff12b 100644
--- a/net/core/sysctl_net_core.c
+++ b/net/core/sysctl_net_core.c
@@ -67,7 +67,7 @@ static struct ctl_table net_core_table[] = {
         {
                 .ctl_name       = NET_CORE_MSG_COST,
                 .procname       = "message_cost",
-                .data           = &net_msg_cost,
+                .data           = &net_ratelimit_state.interval,
                 .maxlen         = sizeof(int),
                 .mode           = 0644,
                 .proc_handler   = &proc_dointvec_jiffies,
@@ -76,7 +76,7 @@ static struct ctl_table net_core_table[] = {
         {
                 .ctl_name       = NET_CORE_MSG_BURST,
                 .procname       = "message_burst",
-                .data           = &net_msg_burst,
+                .data           = &net_ratelimit_state.burst,
                 .maxlen         = sizeof(int),
                 .mode           = 0644,
                 .proc_handler   = &proc_dointvec,
diff --git a/net/core/user_dma.c b/net/core/user_dma.c
index 53c6b67b2877..164b090d5ac3 100644
--- a/net/core/user_dma.c
+++ b/net/core/user_dma.c
@@ -33,6 +33,7 @@
 #define NET_DMA_DEFAULT_COPYBREAK 4096
 
 int sysctl_tcp_dma_copybreak = NET_DMA_DEFAULT_COPYBREAK;
+EXPORT_SYMBOL(sysctl_tcp_dma_copybreak);
 
 /**
  *      dma_skb_copy_datagram_iovec - Copy a datagram to an iovec.
diff --git a/net/core/utils.c b/net/core/utils.c
index 8031eb59054e..72e0ebe964a0 100644
--- a/net/core/utils.c
+++ b/net/core/utils.c
@@ -31,17 +31,16 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 
-int net_msg_cost __read_mostly = 5*HZ;
-int net_msg_burst __read_mostly = 10;
 int net_msg_warn __read_mostly = 1;
 EXPORT_SYMBOL(net_msg_warn);
 
+DEFINE_RATELIMIT_STATE(net_ratelimit_state, 5 * HZ, 10);
 /*
  * All net warning printk()s should be guarded by this function.
  */
 int net_ratelimit(void)
 {
-        return __printk_ratelimit(net_msg_cost, net_msg_burst);
+        return __ratelimit(&net_ratelimit_state);
 }
 EXPORT_SYMBOL(net_ratelimit);
 
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index a107f49eea41..8a3ac1fa71a9 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -264,7 +264,6 @@ static inline int inet_netns_ok(struct net *net, int protocol)
 static int inet_create(struct net *net, struct socket *sock, int protocol)
 {
         struct sock *sk;
-        struct list_head *p;
         struct inet_protosw *answer;
         struct inet_sock *inet;
         struct proto *answer_prot;
@@ -281,13 +280,12 @@ static int inet_create(struct net *net, struct socket *sock, int protocol)
         sock->state = SS_UNCONNECTED;
 
         /* Look for the requested type/protocol pair. */
-        answer = NULL;
 lookup_protocol:
         err = -ESOCKTNOSUPPORT;
         rcu_read_lock();
-        list_for_each_rcu(p, &inetsw[sock->type]) {
-                answer = list_entry(p, struct inet_protosw, list);
+        list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {
 
+                err = 0;
                 /* Check the non-wild match. */
                 if (protocol == answer->protocol) {
                         if (protocol != IPPROTO_IP)
@@ -302,10 +300,9 @@ lookup_protocol:
                                 break;
                 }
                 err = -EPROTONOSUPPORT;
-                answer = NULL;
         }
 
-        if (unlikely(answer == NULL)) {
+        if (unlikely(err)) {
                 if (try_loading_module < 2) {
                         rcu_read_unlock();
                         /*
@@ -1442,6 +1439,10 @@ static int __init inet_init(void)
 
         (void)sock_register(&inet_family_ops);
 
+#ifdef CONFIG_SYSCTL
+        ip_static_sysctl_init();
+#endif
+
         /*
          *      Add all the base protocols.
          */
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index 14ef202a2254..d63e9388d92d 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -882,4 +882,11 @@ static __init int sysctl_ipv4_init(void)
         return 0;
 }
 
+/* set enough of tree skeleton to get rid of ordering problems */
+void __init ip_static_sysctl_init(void)
+{
+        static ctl_table table[1];
+        register_sysctl_paths(net_ipv4_ctl_path, table);
+}
+
 __initcall(sysctl_ipv4_init);
diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c
index 0843c4d6218c..c708ca842298 100644
--- a/net/ipv6/af_inet6.c
+++ b/net/ipv6/af_inet6.c
@@ -83,7 +83,6 @@ static int inet6_create(struct net *net, struct socket *sock, int protocol)
         struct inet_sock *inet;
         struct ipv6_pinfo *np;
         struct sock *sk;
-        struct list_head *p;
         struct inet_protosw *answer;
         struct proto *answer_prot;
         unsigned char answer_flags;
@@ -97,13 +96,12 @@ static int inet6_create(struct net *net, struct socket *sock, int protocol)
                 build_ehash_secret();
 
         /* Look for the requested type/protocol pair. */
-        answer = NULL;
 lookup_protocol:
         err = -ESOCKTNOSUPPORT;
         rcu_read_lock();
-        list_for_each_rcu(p, &inetsw6[sock->type]) {
-                answer = list_entry(p, struct inet_protosw, list);
+        list_for_each_entry_rcu(answer, &inetsw6[sock->type], list) {
 
+                err = 0;
                 /* Check the non-wild match. */
                 if (protocol == answer->protocol) {
                         if (protocol != IPPROTO_IP)
@@ -118,10 +116,9 @@ lookup_protocol:
                                 break;
                 }
                 err = -EPROTONOSUPPORT;
-                answer = NULL;
         }
 
-        if (!answer) {
+        if (err) {
                 if (try_loading_module < 2) {
                         rcu_read_unlock();
                         /*
diff --git a/net/iucv/iucv.c b/net/iucv/iucv.c
index 265b1b289a32..705959b31e24 100644
--- a/net/iucv/iucv.c
+++ b/net/iucv/iucv.c
@@ -497,7 +497,7 @@ static void iucv_setmask_up(void)
         /* Disable all cpu but the first in cpu_irq_cpumask. */
         cpumask = iucv_irq_cpumask;
         cpu_clear(first_cpu(iucv_irq_cpumask), cpumask);
-        for_each_cpu_mask(cpu, cpumask)
+        for_each_cpu_mask_nr(cpu, cpumask)
                 smp_call_function_single(cpu, iucv_block_cpu, NULL, 1);
 }
 
diff --git a/net/sched/sch_atm.c b/net/sched/sch_atm.c
index 04faa835be17..6b517b9dac5b 100644
--- a/net/sched/sch_atm.c
+++ b/net/sched/sch_atm.c
@@ -162,7 +162,7 @@ static void atm_tc_put(struct Qdisc *sch, unsigned long cl)
         qdisc_destroy(flow->q);
         tcf_destroy_chain(&flow->filter_list);
         if (flow->sock) {
-                pr_debug("atm_tc_put: f_count %d\n",
+                pr_debug("atm_tc_put: f_count %ld\n",
                         file_count(flow->sock->file));
                 flow->vcc->pop = flow->old_pop;
                 sockfd_put(flow->sock);
@@ -259,7 +259,7 @@ static int atm_tc_change(struct Qdisc *sch, u32 classid, u32 parent,
         sock = sockfd_lookup(fd, &error);
         if (!sock)
                 return error;   /* f_count++ */
-        pr_debug("atm_tc_change: f_count %d\n", file_count(sock->file));
+        pr_debug("atm_tc_change: f_count %ld\n", file_count(sock->file));
         if (sock->ops->family != PF_ATMSVC && sock->ops->family != PF_ATMPVC) {
                 error = -EPROTOTYPE;
                 goto err_out;
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index 79bece16aede..dbb79adf8f3c 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -3910,7 +3910,7 @@ static int sctp_getsockopt_peeloff(struct sock *sk, int len, char __user *optval
                 goto out;
 
         /* Map the socket to an unused fd that can be returned to the user.  */
-        retval = sock_map_fd(newsock);
+        retval = sock_map_fd(newsock, 0);
         if (retval < 0) {
                 sock_release(newsock);
                 goto out;
diff --git a/net/socket.c b/net/socket.c
index 1ba57d888981..8ef8ba81b9e2 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -63,11 +63,13 @@
 #include <linux/file.h>
 #include <linux/net.h>
 #include <linux/interrupt.h>
+#include <linux/thread_info.h>
 #include <linux/rcupdate.h>
 #include <linux/netdevice.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/mutex.h>
+#include <linux/thread_info.h>
 #include <linux/wanrouter.h>
 #include <linux/if_bridge.h>
 #include <linux/if_frad.h>
@@ -263,7 +265,7 @@ static void sock_destroy_inode(struct inode *inode)
                         container_of(inode, struct socket_alloc, vfs_inode));
 }
 
-static void init_once(struct kmem_cache *cachep, void *foo)
+static void init_once(void *foo)
 {
         struct socket_alloc *ei = (struct socket_alloc *)foo;
 
@@ -349,11 +351,11 @@ static struct dentry_operations sockfs_dentry_operations = {
  *      but we take care of internal coherence yet.
  */
 
-static int sock_alloc_fd(struct file **filep)
+static int sock_alloc_fd(struct file **filep, int flags)
 {
         int fd;
 
-        fd = get_unused_fd();
+        fd = get_unused_fd_flags(flags);
         if (likely(fd >= 0)) {
                 struct file *file = get_empty_filp();
 
@@ -367,7 +369,7 @@ static int sock_alloc_fd(struct file **filep)
         return fd;
 }
 
-static int sock_attach_fd(struct socket *sock, struct file *file)
+static int sock_attach_fd(struct socket *sock, struct file *file, int flags)
 {
         struct dentry *dentry;
         struct qstr name = { .name = "" };
@@ -389,20 +391,20 @@ static int sock_attach_fd(struct socket *sock, struct file *file)
         init_file(file, sock_mnt, dentry, FMODE_READ | FMODE_WRITE,
                   &socket_file_ops);
         SOCK_INODE(sock)->i_fop = &socket_file_ops;
-        file->f_flags = O_RDWR;
+        file->f_flags = O_RDWR | (flags & O_NONBLOCK);
         file->f_pos = 0;
         file->private_data = sock;
 
         return 0;
 }
 
-int sock_map_fd(struct socket *sock)
+int sock_map_fd(struct socket *sock, int flags)
 {
         struct file *newfile;
-        int fd = sock_alloc_fd(&newfile);
+        int fd = sock_alloc_fd(&newfile, flags);
 
         if (likely(fd >= 0)) {
-                int err = sock_attach_fd(sock, newfile);
+                int err = sock_attach_fd(sock, newfile, flags);
 
                 if (unlikely(err < 0)) {
                         put_filp(newfile);
@@ -1218,12 +1220,27 @@ asmlinkage long sys_socket(int family, int type, int protocol)
 {
         int retval;
         struct socket *sock;
+        int flags;
+
+        /* Check the SOCK_* constants for consistency.  */
+        BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
+        BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
+        BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
+        BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
+
+        flags = type & ~SOCK_TYPE_MASK;
+        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
+                return -EINVAL;
+        type &= SOCK_TYPE_MASK;
+
+        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
+                flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
 
         retval = sock_create(family, type, protocol, &sock);
         if (retval < 0)
                 goto out;
 
-        retval = sock_map_fd(sock);
+        retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
         if (retval < 0)
                 goto out_release;
 
@@ -1246,6 +1263,15 @@ asmlinkage long sys_socketpair(int family, int type, int protocol,
         struct socket *sock1, *sock2;
         int fd1, fd2, err;
         struct file *newfile1, *newfile2;
+        int flags;
+
+        flags = type & ~SOCK_TYPE_MASK;
+        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
+                return -EINVAL;
+        type &= SOCK_TYPE_MASK;
+
+        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
+                flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
 
         /*
          * Obtain the first socket and check if the underlying protocol
@@ -1264,13 +1290,13 @@ asmlinkage long sys_socketpair(int family, int type, int protocol,
         if (err < 0)
                 goto out_release_both;
 
-        fd1 = sock_alloc_fd(&newfile1);
+        fd1 = sock_alloc_fd(&newfile1, flags & O_CLOEXEC);
         if (unlikely(fd1 < 0)) {
                 err = fd1;
                 goto out_release_both;
         }
 
-        fd2 = sock_alloc_fd(&newfile2);
+        fd2 = sock_alloc_fd(&newfile2, flags & O_CLOEXEC);
         if (unlikely(fd2 < 0)) {
                 err = fd2;
                 put_filp(newfile1);
@@ -1278,12 +1304,12 @@ asmlinkage long sys_socketpair(int family, int type, int protocol,
                 goto out_release_both;
         }
 
-        err = sock_attach_fd(sock1, newfile1);
+        err = sock_attach_fd(sock1, newfile1, flags & O_NONBLOCK);
         if (unlikely(err < 0)) {
                 goto out_fd2;
         }
 
-        err = sock_attach_fd(sock2, newfile2);
+        err = sock_attach_fd(sock2, newfile2, flags & O_NONBLOCK);
         if (unlikely(err < 0)) {
                 fput(newfile1);
                 goto out_fd1;
@@ -1401,14 +1427,20 @@ asmlinkage long sys_listen(int fd, int backlog)
  *      clean when we restucture accept also.
  */
 
-asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
-                           int __user *upeer_addrlen)
+long do_accept(int fd, struct sockaddr __user *upeer_sockaddr,
+               int __user *upeer_addrlen, int flags)
 {
         struct socket *sock, *newsock;
         struct file *newfile;
         int err, len, newfd, fput_needed;
         struct sockaddr_storage address;
 
+        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
+                return -EINVAL;
+
+        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
+                flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
+
         sock = sockfd_lookup_light(fd, &err, &fput_needed);
         if (!sock)
                 goto out;
@@ -1426,14 +1458,14 @@ asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
          */
         __module_get(newsock->ops->owner);
 
-        newfd = sock_alloc_fd(&newfile);
+        newfd = sock_alloc_fd(&newfile, flags & O_CLOEXEC);
         if (unlikely(newfd < 0)) {
                 err = newfd;
                 sock_release(newsock);
                 goto out_put;
         }
 
-        err = sock_attach_fd(newsock, newfile);
+        err = sock_attach_fd(newsock, newfile, flags & O_NONBLOCK);
         if (err < 0)
                 goto out_fd_simple;
 
@@ -1479,6 +1511,66 @@ out_fd:
         goto out_put;
 }
 
+#ifdef HAVE_SET_RESTORE_SIGMASK
+asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
+                            int __user *upeer_addrlen,
+                            const sigset_t __user *sigmask,
+                            size_t sigsetsize, int flags)
+{
+        sigset_t ksigmask, sigsaved;
+        int ret;
+
+        if (sigmask) {
+                /* XXX: Don't preclude handling different sized sigset_t's.  */
+                if (sigsetsize != sizeof(sigset_t))
+                        return -EINVAL;
+                if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
+                        return -EFAULT;
+
+                sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
+                sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
+        }
+
+        ret = do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
+
+        if (ret < 0 && signal_pending(current)) {
+                /*
+                 * Don't restore the signal mask yet. Let do_signal() deliver
+                 * the signal on the way back to userspace, before the signal
+                 * mask is restored.
+                 */
+                if (sigmask) {
+                        memcpy(&current->saved_sigmask, &sigsaved,
+                               sizeof(sigsaved));
+                        set_restore_sigmask();
+                }
+        } else if (sigmask)
+                sigprocmask(SIG_SETMASK, &sigsaved, NULL);
+
+        return ret;
+}
+#else
+asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
+                            int __user *upeer_addrlen,
+                            const sigset_t __user *sigmask,
+                            size_t sigsetsize, int flags)
+{
+        /* The platform does not support restoring the signal mask in the
+         * return path.  So we do not allow using paccept() with a signal
+         * mask.  */
+        if (sigmask)
+                return -EINVAL;
+
+        return do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
+}
+#endif
+
+asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
+                           int __user *upeer_addrlen)
+{
+        return do_accept(fd, upeer_sockaddr, upeer_addrlen, 0);
+}
+
 /*
  *      Attempt to connect to a socket with the server address.  The address
  *      is in user space so we verify it is OK and move it to kernel space.
@@ -1999,10 +2091,11 @@ out:
 
 /* Argument list sizes for sys_socketcall */
 #define AL(x) ((x) * sizeof(unsigned long))
-static const unsigned char nargs[18]={
+static const unsigned char nargs[19]={
         AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
         AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
-        AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)
+        AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
+        AL(6)
 };
 
 #undef AL
@@ -2021,7 +2114,7 @@ asmlinkage long sys_socketcall(int call, unsigned long __user *args)
         unsigned long a0, a1;
         int err;
 
-        if (call < 1 || call > SYS_RECVMSG)
+        if (call < 1 || call > SYS_PACCEPT)
                 return -EINVAL;
 
         /* copy_from_user should be SMP safe. */
@@ -2050,8 +2143,8 @@ asmlinkage long sys_socketcall(int call, unsigned long __user *args)
                 break;
         case SYS_ACCEPT:
                 err =
-                    sys_accept(a0, (struct sockaddr __user *)a1,
-                               (int __user *)a[2]);
+                    do_accept(a0, (struct sockaddr __user *)a1,
+                              (int __user *)a[2], 0);
                 break;
         case SYS_GETSOCKNAME:
                 err =
@@ -2098,6 +2191,13 @@ asmlinkage long sys_socketcall(int call, unsigned long __user *args)
         case SYS_RECVMSG:
                 err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
                 break;
+        case SYS_PACCEPT:
+                err =
+                    sys_paccept(a0, (struct sockaddr __user *)a1,
+                                (int __user *)a[2],
+                                (const sigset_t __user *) a[3],
+                                a[4], a[5]);
+                break;
         default:
                 err = -EINVAL;
                 break;
diff --git a/net/sunrpc/rpc_pipe.c b/net/sunrpc/rpc_pipe.c
index 5a9b0e7828cd..23a2b8f6dc49 100644
--- a/net/sunrpc/rpc_pipe.c
+++ b/net/sunrpc/rpc_pipe.c
@@ -897,7 +897,7 @@ static struct file_system_type rpc_pipe_fs_type = {
 };
 
 static void
-init_once(struct kmem_cache * cachep, void *foo)
+init_once(void *foo)
 {
         struct rpc_inode *rpci = (struct rpc_inode *) foo;
 
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index 5a32cb7c4bb4..835d27413083 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -310,7 +310,8 @@ svc_pool_map_set_cpumask(struct task_struct *task, unsigned int pidx)
         switch (m->mode) {
         case SVC_POOL_PERCPU:
         {
-                set_cpus_allowed_ptr(task, &cpumask_of_cpu(node));
+                cpumask_of_cpu_ptr(cpumask, node);
+                set_cpus_allowed_ptr(task, cpumask);
                 break;
         }
         case SVC_POOL_PERNODE:
diff --git a/net/sunrpc/xprtrdma/svc_rdma_sendto.c b/net/sunrpc/xprtrdma/svc_rdma_sendto.c
index a19b22b452a3..84d328329d98 100644
--- a/net/sunrpc/xprtrdma/svc_rdma_sendto.c
+++ b/net/sunrpc/xprtrdma/svc_rdma_sendto.c
@@ -169,7 +169,8 @@ static int send_write(struct svcxprt_rdma *xprt, struct svc_rqst *rqstp,
                                           (void *)
                                           vec->sge[xdr_sge_no].iov_base + sge_off,
                                           sge_bytes, DMA_TO_DEVICE);
-                if (dma_mapping_error(sge[sge_no].addr))
+                if (dma_mapping_error(xprt->sc_cm_id->device->dma_device,
+                                        sge[sge_no].addr))
                         goto err;
                 sge_off = 0;
                 sge_no++;
diff --git a/net/sysctl_net.c b/net/sysctl_net.c
index 007c1a6708ee..cefbc367d8be 100644
--- a/net/sysctl_net.c
+++ b/net/sysctl_net.c
@@ -29,23 +29,35 @@
 #include <linux/if_tr.h>
 #endif
 
-static struct list_head *
+static struct ctl_table_set *
 net_ctl_header_lookup(struct ctl_table_root *root, struct nsproxy *namespaces)
 {
-        return &namespaces->net_ns->sysctl_table_headers;
+        return &namespaces->net_ns->sysctls;
 }
 
-static struct ctl_table_root net_sysctl_root = {
-        .lookup = net_ctl_header_lookup,
-};
+static int is_seen(struct ctl_table_set *set)
+{
+        return &current->nsproxy->net_ns->sysctls == set;
+}
 
-static LIST_HEAD(net_sysctl_ro_tables);
-static struct list_head *net_ctl_ro_header_lookup(struct ctl_table_root *root,
-                struct nsproxy *namespaces)
+/* Return standard mode bits for table entry. */
+static int net_ctl_permissions(struct ctl_table_root *root,
+                               struct nsproxy *nsproxy,
+                               struct ctl_table *table)
 {
-        return &net_sysctl_ro_tables;
+        /* Allow network administrator to have same access as root. */
+        if (capable(CAP_NET_ADMIN)) {
+                int mode = (table->mode >> 6) & 7;
+                return (mode << 6) | (mode << 3) | mode;
+        }
+        return table->mode;
 }
 
+static struct ctl_table_root net_sysctl_root = {
+        .lookup = net_ctl_header_lookup,
+        .permissions = net_ctl_permissions,
+};
+
 static int net_ctl_ro_header_perms(struct ctl_table_root *root,
                 struct nsproxy *namespaces, struct ctl_table *table)
 {
@@ -56,19 +68,18 @@ static int net_ctl_ro_header_perms(struct ctl_table_root *root,
 }
 
 static struct ctl_table_root net_sysctl_ro_root = {
-        .lookup = net_ctl_ro_header_lookup,
         .permissions = net_ctl_ro_header_perms,
 };
 
 static int sysctl_net_init(struct net *net)
 {
-        INIT_LIST_HEAD(&net->sysctl_table_headers);
+        setup_sysctl_set(&net->sysctls, NULL, is_seen);
         return 0;
 }
 
 static void sysctl_net_exit(struct net *net)
 {
-        WARN_ON(!list_empty(&net->sysctl_table_headers));
+        WARN_ON(!list_empty(&net->sysctls.list));
         return;
 }
 
@@ -84,6 +95,7 @@ static __init int sysctl_init(void)
         if (ret)
                 goto out;
         register_sysctl_root(&net_sysctl_root);
+        setup_sysctl_set(&net_sysctl_ro_root.default_set, NULL, NULL);
         register_sysctl_root(&net_sysctl_ro_root);
 out:
         return ret;
diff --git a/net/unix/af_unix.c b/net/unix/af_unix.c
index 24eb214581d5..015606b54d9b 100644
--- a/net/unix/af_unix.c
+++ b/net/unix/af_unix.c
@@ -603,7 +603,7 @@ static struct sock * unix_create1(struct net *net, struct socket *sock)
         u->dentry = NULL;
         u->mnt    = NULL;
         spin_lock_init(&u->lock);
-        atomic_set(&u->inflight, 0);
+        atomic_long_set(&u->inflight, 0);
         INIT_LIST_HEAD(&u->link);
         mutex_init(&u->readlock); /* single task reading lock */
         init_waitqueue_head(&u->peer_wait);
diff --git a/net/unix/garbage.c b/net/unix/garbage.c
index ebdff3d877a1..2a27b84f740b 100644
--- a/net/unix/garbage.c
+++ b/net/unix/garbage.c
@@ -127,7 +127,7 @@ void unix_inflight(struct file *fp)
         if(s) {
                 struct unix_sock *u = unix_sk(s);
                 spin_lock(&unix_gc_lock);
-                if (atomic_inc_return(&u->inflight) == 1) {
+                if (atomic_long_inc_return(&u->inflight) == 1) {
                         BUG_ON(!list_empty(&u->link));
                         list_add_tail(&u->link, &gc_inflight_list);
                 } else {
@@ -145,7 +145,7 @@ void unix_notinflight(struct file *fp)
                 struct unix_sock *u = unix_sk(s);
                 spin_lock(&unix_gc_lock);
                 BUG_ON(list_empty(&u->link));
-                if (atomic_dec_and_test(&u->inflight))
+                if (atomic_long_dec_and_test(&u->inflight))
                         list_del_init(&u->link);
                 unix_tot_inflight--;
                 spin_unlock(&unix_gc_lock);
@@ -237,17 +237,17 @@ static void scan_children(struct sock *x, void (*func)(struct unix_sock *),
 
 static void dec_inflight(struct unix_sock *usk)
 {
-        atomic_dec(&usk->inflight);
+        atomic_long_dec(&usk->inflight);
 }
 
 static void inc_inflight(struct unix_sock *usk)
 {
-        atomic_inc(&usk->inflight);
+        atomic_long_inc(&usk->inflight);
 }
 
 static void inc_inflight_move_tail(struct unix_sock *u)
 {
-        atomic_inc(&u->inflight);
+        atomic_long_inc(&u->inflight);
         /*
          * If this is still a candidate, move it to the end of the
          * list, so that it's checked even if it was already passed
@@ -288,11 +288,11 @@ void unix_gc(void)
          * before the detach without atomicity guarantees.
          */
         list_for_each_entry_safe(u, next, &gc_inflight_list, link) {
-                int total_refs;
-                int inflight_refs;
+                long total_refs;
+                long inflight_refs;
 
                 total_refs = file_count(u->sk.sk_socket->file);
-                inflight_refs = atomic_read(&u->inflight);
+                inflight_refs = atomic_long_read(&u->inflight);
 
                 BUG_ON(inflight_refs < 1);
                 BUG_ON(total_refs < inflight_refs);
@@ -324,7 +324,7 @@ void unix_gc(void)
                 /* Move cursor to after the current position. */
                 list_move(&cursor, &u->link);
 
-                if (atomic_read(&u->inflight) > 0) {
+                if (atomic_long_read(&u->inflight) > 0) {
                         list_move_tail(&u->link, &gc_inflight_list);
                         u->gc_candidate = 0;
                         scan_children(&u->sk, inc_inflight_move_tail, NULL);