30 files changed, 322 insertions, 135 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) {
+        list_for_each_entry_rcu(p, &snap_list, node) {
-                p = list_entry(entry, struct datalink_proto, 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/bridge/netfilter/ebtable_filter.c b/net/bridge/netfilter/ebtable_filter.c
index 690bc3ab186c..1a58af51a2e2 100644
--- a/net/bridge/netfilter/ebtable_filter.c
+++ b/net/bridge/netfilter/ebtable_filter.c
@@ -93,28 +93,20 @@ static struct nf_hook_ops ebt_ops_filter[] __read_mostly = {
 static int __init ebtable_filter_init(void)
 {
-        int i, j, ret;
+        int ret;
        ret = ebt_register_table(&frame_filter);
        if (ret < 0)
                return ret;
-        for (i = 0; i < ARRAY_SIZE(ebt_ops_filter); i++)
+        ret = nf_register_hooks(ebt_ops_filter, ARRAY_SIZE(ebt_ops_filter));
-                if ((ret = nf_register_hook(&ebt_ops_filter[i])) < 0)
+        if (ret < 0)
-                        goto cleanup;
+                ebt_unregister_table(&frame_filter);
-        return ret;
-cleanup:
-        for (j = 0; j < i; j++)
-                nf_unregister_hook(&ebt_ops_filter[j]);
-        ebt_unregister_table(&frame_filter);
        return ret;
 }
 static void __exit ebtable_filter_fini(void)
 {
-        int i;
+        nf_unregister_hooks(ebt_ops_filter, ARRAY_SIZE(ebt_ops_filter));
-        for (i = 0; i < ARRAY_SIZE(ebt_ops_filter); i++)
-                nf_unregister_hook(&ebt_ops_filter[i]);
        ebt_unregister_table(&frame_filter);
 }
diff --git a/net/bridge/netfilter/ebtable_nat.c b/net/bridge/netfilter/ebtable_nat.c
index 5b495fe2d0b6..f60c1e78e575 100644
--- a/net/bridge/netfilter/ebtable_nat.c
+++ b/net/bridge/netfilter/ebtable_nat.c
@@ -100,28 +100,20 @@ static struct nf_hook_ops ebt_ops_nat[] __read_mostly = {
 static int __init ebtable_nat_init(void)
 {
-        int i, ret, j;
+        int ret;
        ret = ebt_register_table(&frame_nat);
        if (ret < 0)
                return ret;
-        for (i = 0; i < ARRAY_SIZE(ebt_ops_nat); i++)
+        ret = nf_register_hooks(ebt_ops_nat, ARRAY_SIZE(ebt_ops_nat));
-                if ((ret = nf_register_hook(&ebt_ops_nat[i])) < 0)
+        if (ret < 0)
-                        goto cleanup;
+                ebt_unregister_table(&frame_nat);
-        return ret;
-cleanup:
-        for (j = 0; j < i; j++)
-                nf_unregister_hook(&ebt_ops_nat[j]);
-        ebt_unregister_table(&frame_nat);
        return ret;
 }
 static void __exit ebtable_nat_fini(void)
 {
-        int i;
+        nf_unregister_hooks(ebt_ops_nat, ARRAY_SIZE(ebt_ops_nat));
-        for (i = 0; i < ARRAY_SIZE(ebt_ops_nat); i++)
-                nf_unregister_hook(&ebt_ops_nat[i]);
        ebt_unregister_table(&frame_nat);
 }
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]) {
+        list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {
-                answer = list_entry(p, struct inet_protosw, 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/ipcomp.c b/net/ipv4/ipcomp.c
index a42b64d040c4..38ccb6dfb02e 100644
--- a/net/ipv4/ipcomp.c
+++ b/net/ipv4/ipcomp.c
@@ -104,9 +104,7 @@ out:
 static int ipcomp4_init_state(struct xfrm_state *x)
 {
-        int err;
+        int err = -EINVAL;
-        struct ipcomp_data *ipcd;
-        struct xfrm_algo_desc *calg_desc;
        x->props.header_len = 0;
        switch (x->props.mode) {
diff --git a/net/ipv4/netfilter/arptable_filter.c b/net/ipv4/netfilter/arptable_filter.c
index 3be4d07e7ed9..082f5dd3156c 100644
--- a/net/ipv4/netfilter/arptable_filter.c
+++ b/net/ipv4/netfilter/arptable_filter.c
@@ -55,32 +55,53 @@ static struct xt_table packet_filter = {
 };
 /* The work comes in here from netfilter.c */
-static unsigned int arpt_hook(unsigned int hook,
+static unsigned int arpt_in_hook(unsigned int hook,
-                              struct sk_buff *skb,
+                                 struct sk_buff *skb,
-                              const struct net_device *in,
+                                 const struct net_device *in,
-                              const struct net_device *out,
+                                 const struct net_device *out,
-                              int (*okfn)(struct sk_buff *))
+                                 int (*okfn)(struct sk_buff *))
 {
-        return arpt_do_table(skb, hook, in, out, init_net.ipv4.arptable_filter);
+        return arpt_do_table(skb, hook, in, out,
+                             dev_net(in)->ipv4.arptable_filter);
+}
+static unsigned int arpt_out_hook(unsigned int hook,
+                                  struct sk_buff *skb,
+                                  const struct net_device *in,
+                                  const struct net_device *out,
+                                  int (*okfn)(struct sk_buff *))
+{
+        return arpt_do_table(skb, hook, in, out,
+                             dev_net(out)->ipv4.arptable_filter);
+}
+static unsigned int arpt_forward_hook(unsigned int hook,
+                                      struct sk_buff *skb,
+                                      const struct net_device *in,
+                                      const struct net_device *out,
+                                      int (*okfn)(struct sk_buff *))
+{
+        return arpt_do_table(skb, hook, in, out,
+                             dev_net(in)->ipv4.arptable_filter);
 }
 static struct nf_hook_ops arpt_ops[] __read_mostly = {
        {
-                .hook           = arpt_hook,
+                .hook           = arpt_in_hook,
                .owner          = THIS_MODULE,
                .pf             = NF_ARP,
                .hooknum        = NF_ARP_IN,
                .priority       = NF_IP_PRI_FILTER,
        },
        {
-                .hook           = arpt_hook,
+                .hook           = arpt_out_hook,
                .owner          = THIS_MODULE,
                .pf             = NF_ARP,
                .hooknum        = NF_ARP_OUT,
                .priority       = NF_IP_PRI_FILTER,
        },
        {
-                .hook           = arpt_hook,
+                .hook           = arpt_forward_hook,
                .owner          = THIS_MODULE,
                .pf             = NF_ARP,
                .hooknum        = NF_ARP_FORWARD,
diff --git a/net/ipv4/netfilter/iptable_security.c b/net/ipv4/netfilter/iptable_security.c
index 2b472ac2263a..db6d312128e1 100644
--- a/net/ipv4/netfilter/iptable_security.c
+++ b/net/ipv4/netfilter/iptable_security.c
@@ -32,7 +32,7 @@ static struct
        struct ipt_replace repl;
        struct ipt_standard entries[3];
        struct ipt_error term;
-} initial_table __initdata = {
+} initial_table __net_initdata = {
        .repl = {
                .name = "security",
                .valid_hooks = SECURITY_VALID_HOOKS,
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index e4ab0ac94f92..380d6474cf66 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -1502,7 +1502,7 @@ unsigned short ip_rt_frag_needed(struct net *net, struct iphdr *iph,
                                    rth->fl.iif != 0 ||
                                    dst_metric_locked(&rth->u.dst, RTAX_MTU) ||
                                    !net_eq(dev_net(rth->u.dst.dev), net) ||
-                                    !rt_is_expired(rth))
+                                    rt_is_expired(rth))
                                        continue;
                                if (new_mtu < 68 || new_mtu >= old_mtu) {
@@ -2914,7 +2914,7 @@ static int ipv4_sysctl_rtcache_flush_strategy(ctl_table *table,
        return 0;
 }
-ctl_table ipv4_route_table[] = {
+static ctl_table ipv4_route_table[] = {
        {
                .ctl_name       = NET_IPV4_ROUTE_GC_THRESH,
                .procname       = "gc_thresh",
@@ -3216,6 +3216,15 @@ int __init ip_rt_init(void)
        return rc;
 }
+/*
+ * We really need to sanitize the damn ipv4 init order, then all
+ * this nonsense will go away.
+ */
+void __init ip_static_sysctl_init(void)
+{
+        register_sysctl_paths(ipv4_route_path, ipv4_route_table);
+}
 EXPORT_SYMBOL(__ip_select_ident);
 EXPORT_SYMBOL(ip_route_input);
 EXPORT_SYMBOL(ip_route_output_key);
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index 14ef202a2254..770d827f5ab8 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -401,13 +401,6 @@ static struct ctl_table ipv4_table[] = {
                .proc_handler   = &ipv4_local_port_range,
                .strategy       = &ipv4_sysctl_local_port_range,
        },
-        {
-                .ctl_name       = NET_IPV4_ROUTE,
-                .procname       = "route",
-                .maxlen         = 0,
-                .mode           = 0555,
-                .child          = ipv4_route_table
-        },
 #ifdef CONFIG_IP_MULTICAST
        {
                .ctl_name       = NET_IPV4_IGMP_MAX_MEMBERSHIPS,
diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c
index 0843c4d6218c..95055f8c3f35 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]) {
+        list_for_each_entry_rcu(answer, &inetsw6[sock->type], list) {
-                answer = list_entry(p, struct inet_protosw, 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();
                        /*
@@ -937,6 +934,11 @@ static int __init inet6_init(void)
        if (err)
                goto out_unregister_sock;
+#ifdef CONFIG_SYSCTL
+        err = ipv6_static_sysctl_register();
+        if (err)
+                goto static_sysctl_fail;
+#endif
        /*
         *      ipngwg API draft makes clear that the correct semantics
         *      for TCP and UDP is to consider one TCP and UDP instance
@@ -1061,6 +1063,10 @@ ipmr_fail:
 icmp_fail:
        unregister_pernet_subsys(&inet6_net_ops);
 register_pernet_fail:
+#ifdef CONFIG_SYSCTL
+        ipv6_static_sysctl_unregister();
+static_sysctl_fail:
+#endif
        cleanup_ipv6_mibs();
 out_unregister_sock:
        sock_unregister(PF_INET6);
@@ -1116,6 +1122,9 @@ static void __exit inet6_exit(void)
        rawv6_exit();
        unregister_pernet_subsys(&inet6_net_ops);
+#ifdef CONFIG_SYSCTL
+        ipv6_static_sysctl_unregister();
+#endif
        cleanup_ipv6_mibs();
        proto_unregister(&rawv6_prot);
        proto_unregister(&udplitev6_prot);
diff --git a/net/ipv6/ipcomp6.c b/net/ipv6/ipcomp6.c
index 0cfcea42153a..4545e4306862 100644
--- a/net/ipv6/ipcomp6.c
+++ b/net/ipv6/ipcomp6.c
@@ -134,9 +134,7 @@ out:
 static int ipcomp6_init_state(struct xfrm_state *x)
 {
-        int err;
+        int err = -EINVAL;
-        struct ipcomp_data *ipcd;
-        struct xfrm_algo_desc *calg_desc;
        x->props.header_len = 0;
        switch (x->props.mode) {
diff --git a/net/ipv6/netfilter/ip6table_security.c b/net/ipv6/netfilter/ip6table_security.c
index a07abee30497..6e7131036bc6 100644
--- a/net/ipv6/netfilter/ip6table_security.c
+++ b/net/ipv6/netfilter/ip6table_security.c
@@ -31,7 +31,7 @@ static struct
        struct ip6t_replace repl;
        struct ip6t_standard entries[3];
        struct ip6t_error term;
-} initial_table __initdata = {
+} initial_table __net_initdata = {
        .repl = {
                .name = "security",
                .valid_hooks = SECURITY_VALID_HOOKS,
diff --git a/net/ipv6/sysctl_net_ipv6.c b/net/ipv6/sysctl_net_ipv6.c
index 5c99274558bf..e6dfaeac6be3 100644
--- a/net/ipv6/sysctl_net_ipv6.c
+++ b/net/ipv6/sysctl_net_ipv6.c
@@ -150,3 +150,19 @@ void ipv6_sysctl_unregister(void)
        unregister_net_sysctl_table(ip6_header);
        unregister_pernet_subsys(&ipv6_sysctl_net_ops);
 }
+static struct ctl_table_header *ip6_base;
+int ipv6_static_sysctl_register(void)
+{
+        static struct ctl_table empty[1];
+        ip6_base = register_net_sysctl_rotable(net_ipv6_ctl_path, empty);
+        if (ip6_base == NULL)
+                return -ENOMEM;
+        return 0;
+}
+void ipv6_static_sysctl_unregister(void)
+{
+        unregister_net_sysctl_table(ip6_base);
+}
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/netfilter/nf_conntrack_extend.c b/net/netfilter/nf_conntrack_extend.c
index 3469bc71a385..4b2c769d555f 100644
--- a/net/netfilter/nf_conntrack_extend.c
+++ b/net/netfilter/nf_conntrack_extend.c
@@ -95,7 +95,7 @@ void *__nf_ct_ext_add(struct nf_conn *ct, enum nf_ct_ext_id id, gfp_t gfp)
        newlen = newoff + t->len;
        rcu_read_unlock();
-        new = krealloc(ct->ext, newlen, gfp);
+        new = __krealloc(ct->ext, newlen, gfp);
        if (!new)
                return NULL;
@@ -115,10 +115,10 @@ void *__nf_ct_ext_add(struct nf_conn *ct, enum nf_ct_ext_id id, gfp_t gfp)
                ct->ext = new;
        }
-        ct->ext->offset[id] = newoff;
+        new->offset[id] = newoff;
-        ct->ext->len = newlen;
+        new->len = newlen;
-        memset((void *)ct->ext + newoff, 0, newlen - newoff);
+        memset((void *)new + newoff, 0, newlen - newoff);
-        return (void *)ct->ext + newoff;
+        return (void *)new + newoff;
 }
 EXPORT_SYMBOL(__nf_ct_ext_add);
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,
+long do_accept(int fd, struct sockaddr __user *upeer_sockaddr,
-                           int __user *upeer_addrlen)
+               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,
+                    do_accept(a0, (struct sockaddr __user *)a1,
-                               (int __user *)a[2]);
+                              (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..972201cd5fa7 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 = {
+static int is_seen(struct ctl_table_set *set)
-        .lookup = net_ctl_header_lookup,
+{
-};
+        return &current->nsproxy->net_ns->sysctls == set;
+}
-static LIST_HEAD(net_sysctl_ro_tables);
+/* Return standard mode bits for table entry. */
-static struct list_head *net_ctl_ro_header_lookup(struct ctl_table_root *root,
+static int net_ctl_permissions(struct ctl_table_root *root,
-                struct nsproxy *namespaces)
+                               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,20 @@ 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,
+                         &net_sysctl_ro_root.default_set,
+                         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 +97,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;
+                long total_refs;
-                int inflight_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);