31 files changed, 264 insertions, 119 deletions

diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c
index 8db1b985dbf1..762896ebfcf5 100644
--- a/net/8021q/vlan_dev.c
+++ b/net/8021q/vlan_dev.c
@@ -539,7 +539,7 @@ static const struct net_device_ops vlan_netdev_ops;
 static int vlan_dev_init(struct net_device *dev)
 {
         struct net_device *real_dev = vlan_dev_priv(dev)->real_dev;
-        int subclass = 0;
+        int subclass = 0, i;
 
         netif_carrier_off(dev);
 
@@ -593,6 +593,13 @@ static int vlan_dev_init(struct net_device *dev)
         if (!vlan_dev_priv(dev)->vlan_pcpu_stats)
                 return -ENOMEM;
 
+        for_each_possible_cpu(i) {
+                struct vlan_pcpu_stats *vlan_stat;
+                vlan_stat = per_cpu_ptr(vlan_dev_priv(dev)->vlan_pcpu_stats, i);
+                u64_stats_init(&vlan_stat->syncp);
+        }
+
+
         return 0;
 }
 
diff --git a/net/9p/trans_virtio.c b/net/9p/trans_virtio.c
index 990afab2be1b..9c5a1aa34d12 100644
--- a/net/9p/trans_virtio.c
+++ b/net/9p/trans_virtio.c
@@ -544,9 +544,7 @@ static int p9_virtio_probe(struct virtio_device *vdev)
 
         chan->inuse = false;
         if (virtio_has_feature(vdev, VIRTIO_9P_MOUNT_TAG)) {
-                vdev->config->get(vdev,
-                                offsetof(struct virtio_9p_config, tag_len),
-                                &tag_len, sizeof(tag_len));
+                virtio_cread(vdev, struct virtio_9p_config, tag_len, &tag_len);
         } else {
                 err = -EINVAL;
                 goto out_free_vq;
@@ -556,8 +554,9 @@ static int p9_virtio_probe(struct virtio_device *vdev)
                 err = -ENOMEM;
                 goto out_free_vq;
         }
-        vdev->config->get(vdev, offsetof(struct virtio_9p_config, tag),
-                        tag, tag_len);
+
+        virtio_cread_bytes(vdev, offsetof(struct virtio_9p_config, tag),
+                           tag, tag_len);
         chan->tag = tag;
         chan->tag_len = tag_len;
         err = sysfs_create_file(&(vdev->dev.kobj), &dev_attr_mount_tag.attr);
diff --git a/net/bridge/br_device.c b/net/bridge/br_device.c
index e6b7fecb3af1..f00cfd2a0143 100644
--- a/net/bridge/br_device.c
+++ b/net/bridge/br_device.c
@@ -88,11 +88,18 @@ out:
 static int br_dev_init(struct net_device *dev)
 {
         struct net_bridge *br = netdev_priv(dev);
+        int i;
 
         br->stats = alloc_percpu(struct br_cpu_netstats);
         if (!br->stats)
                 return -ENOMEM;
 
+        for_each_possible_cpu(i) {
+                struct br_cpu_netstats *br_dev_stats;
+                br_dev_stats = per_cpu_ptr(br->stats, i);
+                u64_stats_init(&br_dev_stats->syncp);
+        }
+
         return 0;
 }
 
diff --git a/net/can/af_can.c b/net/can/af_can.c
index 3ab8dd2e1282..d249874a366d 100644
--- a/net/can/af_can.c
+++ b/net/can/af_can.c
@@ -420,7 +420,7 @@ static struct hlist_head *find_rcv_list(canid_t *can_id, canid_t *mask,
  * @mask: CAN mask (see description)
  * @func: callback function on filter match
  * @data: returned parameter for callback function
- * @ident: string for calling module indentification
+ * @ident: string for calling module identification
  *
  * Description:
  *  Invokes the callback function with the received sk_buff and the given
diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index 68af9aac91d0..70011e029ac1 100644
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -1503,6 +1503,7 @@ int snmp_mib_init(void __percpu *ptr[2], size_t mibsize, size_t align)
         ptr[0] = __alloc_percpu(mibsize, align);
         if (!ptr[0])
                 return -ENOMEM;
+
 #if SNMP_ARRAY_SZ == 2
         ptr[1] = __alloc_percpu(mibsize, align);
         if (!ptr[1]) {
@@ -1547,6 +1548,8 @@ static const struct net_protocol icmp_protocol = {
 
 static __net_init int ipv4_mib_init_net(struct net *net)
 {
+        int i;
+
         if (snmp_mib_init((void __percpu **)net->mib.tcp_statistics,
                           sizeof(struct tcp_mib),
                           __alignof__(struct tcp_mib)) < 0)
@@ -1555,6 +1558,17 @@ static __net_init int ipv4_mib_init_net(struct net *net)
                           sizeof(struct ipstats_mib),
                           __alignof__(struct ipstats_mib)) < 0)
                 goto err_ip_mib;
+
+        for_each_possible_cpu(i) {
+                struct ipstats_mib *af_inet_stats;
+                af_inet_stats = per_cpu_ptr(net->mib.ip_statistics[0], i);
+                u64_stats_init(&af_inet_stats->syncp);
+#if SNMP_ARRAY_SZ == 2
+                af_inet_stats = per_cpu_ptr(net->mib.ip_statistics[1], i);
+                u64_stats_init(&af_inet_stats->syncp);
+#endif
+        }
+
         if (snmp_mib_init((void __percpu **)net->mib.net_statistics,
                           sizeof(struct linux_mib),
                           __alignof__(struct linux_mib)) < 0)
diff --git a/net/ipv4/fib_trie.c b/net/ipv4/fib_trie.c
index ec9a9ef4ce50..5afeb5aa4c7c 100644
--- a/net/ipv4/fib_trie.c
+++ b/net/ipv4/fib_trie.c
@@ -2523,16 +2523,17 @@ static int fib_route_seq_show(struct seq_file *seq, void *v)
                 list_for_each_entry_rcu(fa, &li->falh, fa_list) {
                         const struct fib_info *fi = fa->fa_info;
                         unsigned int flags = fib_flag_trans(fa->fa_type, mask, fi);
-                        int len;
 
                         if (fa->fa_type == RTN_BROADCAST
                             || fa->fa_type == RTN_MULTICAST)
                                 continue;
 
+                        seq_setwidth(seq, 127);
+
                         if (fi)
                                 seq_printf(seq,
                                          "%s\t%08X\t%08X\t%04X\t%d\t%u\t"
-                                         "%d\t%08X\t%d\t%u\t%u%n",
+                                         "%d\t%08X\t%d\t%u\t%u",
                                          fi->fib_dev ? fi->fib_dev->name : "*",
                                          prefix,
                                          fi->fib_nh->nh_gw, flags, 0, 0,
@@ -2541,15 +2542,15 @@ static int fib_route_seq_show(struct seq_file *seq, void *v)
                                          (fi->fib_advmss ?
                                           fi->fib_advmss + 40 : 0),
                                          fi->fib_window,
-                                         fi->fib_rtt >> 3, &len);
+                                         fi->fib_rtt >> 3);
                         else
                                 seq_printf(seq,
                                          "*\t%08X\t%08X\t%04X\t%d\t%u\t"
-                                         "%d\t%08X\t%d\t%u\t%u%n",
+                                         "%d\t%08X\t%d\t%u\t%u",
                                          prefix, 0, flags, 0, 0, 0,
-                                         mask, 0, 0, 0, &len);
+                                         mask, 0, 0, 0);
 
-                        seq_printf(seq, "%*s\n", 127 - len, "");
+                        seq_pad(seq, '\n');
                 }
         }
 
diff --git a/net/ipv4/ip_tunnel.c b/net/ipv4/ip_tunnel.c
index 254f11c24aa5..90ff9570d7d4 100644
--- a/net/ipv4/ip_tunnel.c
+++ b/net/ipv4/ip_tunnel.c
@@ -976,13 +976,19 @@ int ip_tunnel_init(struct net_device *dev)
 {
         struct ip_tunnel *tunnel = netdev_priv(dev);
         struct iphdr *iph = &tunnel->parms.iph;
-        int err;
+        int i, err;
 
         dev->destructor = ip_tunnel_dev_free;
         dev->tstats = alloc_percpu(struct pcpu_tstats);
         if (!dev->tstats)
                 return -ENOMEM;
 
+        for_each_possible_cpu(i) {
+                struct pcpu_tstats *ipt_stats;
+                ipt_stats = per_cpu_ptr(dev->tstats, i);
+                u64_stats_init(&ipt_stats->syncp);
+        }
+
         err = gro_cells_init(&tunnel->gro_cells, dev);
         if (err) {
                 free_percpu(dev->tstats);
diff --git a/net/ipv4/ping.c b/net/ipv4/ping.c
index 91bfe0437e7a..876c6ca2d8f9 100644
--- a/net/ipv4/ping.c
+++ b/net/ipv4/ping.c
@@ -1075,7 +1075,7 @@ void ping_seq_stop(struct seq_file *seq, void *v)
 EXPORT_SYMBOL_GPL(ping_seq_stop);
 
 static void ping_v4_format_sock(struct sock *sp, struct seq_file *f,
-                int bucket, int *len)
+                int bucket)
 {
         struct inet_sock *inet = inet_sk(sp);
         __be32 dest = inet->inet_daddr;
@@ -1084,7 +1084,7 @@ static void ping_v4_format_sock(struct sock *sp, struct seq_file *f,
         __u16 srcp = ntohs(inet->inet_sport);
 
         seq_printf(f, "%5d: %08X:%04X %08X:%04X"
-                " %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %d%n",
+                " %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %d",
                 bucket, src, srcp, dest, destp, sp->sk_state,
                 sk_wmem_alloc_get(sp),
                 sk_rmem_alloc_get(sp),
@@ -1092,23 +1092,22 @@ static void ping_v4_format_sock(struct sock *sp, struct seq_file *f,
                 from_kuid_munged(seq_user_ns(f), sock_i_uid(sp)),
                 0, sock_i_ino(sp),
                 atomic_read(&sp->sk_refcnt), sp,
-                atomic_read(&sp->sk_drops), len);
+                atomic_read(&sp->sk_drops));
 }
 
 static int ping_v4_seq_show(struct seq_file *seq, void *v)
 {
+        seq_setwidth(seq, 127);
         if (v == SEQ_START_TOKEN)
-                seq_printf(seq, "%-127s\n",
-                           "  sl  local_address rem_address   st tx_queue "
+                seq_puts(seq, "  sl  local_address rem_address   st tx_queue "
                            "rx_queue tr tm->when retrnsmt   uid  timeout "
                            "inode ref pointer drops");
         else {
                 struct ping_iter_state *state = seq->private;
-                int len;
 
-                ping_v4_format_sock(v, seq, state->bucket, &len);
-                seq_printf(seq, "%*s\n", 127 - len, "");
+                ping_v4_format_sock(v, seq, state->bucket);
         }
+        seq_pad(seq, '\n');
         return 0;
 }
 
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 14bba8a1c5a7..59a6f8b90cd9 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -2541,13 +2541,13 @@ void tcp_proc_unregister(struct net *net, struct tcp_seq_afinfo *afinfo)
 EXPORT_SYMBOL(tcp_proc_unregister);
 
 static void get_openreq4(const struct sock *sk, const struct request_sock *req,
-                         struct seq_file *f, int i, kuid_t uid, int *len)
+                         struct seq_file *f, int i, kuid_t uid)
 {
         const struct inet_request_sock *ireq = inet_rsk(req);
         long delta = req->expires - jiffies;
 
         seq_printf(f, "%4d: %08X:%04X %08X:%04X"
-                " %02X %08X:%08X %02X:%08lX %08X %5u %8d %u %d %pK%n",
+                " %02X %08X:%08X %02X:%08lX %08X %5u %8d %u %d %pK",
                 i,
                 ireq->ir_loc_addr,
                 ntohs(inet_sk(sk)->inet_sport),
@@ -2562,11 +2562,10 @@ static void get_openreq4(const struct sock *sk, const struct request_sock *req,
                 0,  /* non standard timer */
                 0, /* open_requests have no inode */
                 atomic_read(&sk->sk_refcnt),
-                req,
-                len);
+                req);
 }
 
-static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
+static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i)
 {
         int timer_active;
         unsigned long timer_expires;
@@ -2605,7 +2604,7 @@ static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
                 rx_queue = max_t(int, tp->rcv_nxt - tp->copied_seq, 0);
 
         seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
-                        "%08X %5u %8d %lu %d %pK %lu %lu %u %u %d%n",
+                        "%08X %5u %8d %lu %d %pK %lu %lu %u %u %d",
                 i, src, srcp, dest, destp, sk->sk_state,
                 tp->write_seq - tp->snd_una,
                 rx_queue,
@@ -2622,12 +2621,11 @@ static void get_tcp4_sock(struct sock *sk, struct seq_file *f, int i, int *len)
                 tp->snd_cwnd,
                 sk->sk_state == TCP_LISTEN ?
                     (fastopenq ? fastopenq->max_qlen : 0) :
-                    (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh),
-                len);
+                    (tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh));
 }
 
 static void get_timewait4_sock(const struct inet_timewait_sock *tw,
-                               struct seq_file *f, int i, int *len)
+                               struct seq_file *f, int i)
 {
         __be32 dest, src;
         __u16 destp, srcp;
@@ -2639,10 +2637,10 @@ static void get_timewait4_sock(const struct inet_timewait_sock *tw,
         srcp  = ntohs(tw->tw_sport);
 
         seq_printf(f, "%4d: %08X:%04X %08X:%04X"
-                " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK%n",
+                " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK",
                 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
                 3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
-                atomic_read(&tw->tw_refcnt), tw, len);
+                atomic_read(&tw->tw_refcnt), tw);
 }
 
 #define TMPSZ 150
@@ -2651,11 +2649,10 @@ static int tcp4_seq_show(struct seq_file *seq, void *v)
 {
         struct tcp_iter_state *st;
         struct sock *sk = v;
-        int len;
 
+        seq_setwidth(seq, TMPSZ - 1);
         if (v == SEQ_START_TOKEN) {
-                seq_printf(seq, "%-*s\n", TMPSZ - 1,
-                           "  sl  local_address rem_address   st tx_queue "
+                seq_puts(seq, "  sl  local_address rem_address   st tx_queue "
                            "rx_queue tr tm->when retrnsmt   uid  timeout "
                            "inode");
                 goto out;
@@ -2666,16 +2663,16 @@ static int tcp4_seq_show(struct seq_file *seq, void *v)
         case TCP_SEQ_STATE_LISTENING:
         case TCP_SEQ_STATE_ESTABLISHED:
                 if (sk->sk_state == TCP_TIME_WAIT)
-                        get_timewait4_sock(v, seq, st->num, &len);
+                        get_timewait4_sock(v, seq, st->num);
                 else
-                        get_tcp4_sock(v, seq, st->num, &len);
+                        get_tcp4_sock(v, seq, st->num);
                 break;
         case TCP_SEQ_STATE_OPENREQ:
-                get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid, &len);
+                get_openreq4(st->syn_wait_sk, v, seq, st->num, st->uid);
                 break;
         }
-        seq_printf(seq, "%*s\n", TMPSZ - 1 - len, "");
 out:
+        seq_pad(seq, '\n');
         return 0;
 }
 
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 998431cd471a..5944d7d668dd 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -2326,7 +2326,7 @@ EXPORT_SYMBOL(udp_proc_unregister);
 
 /* ------------------------------------------------------------------------ */
 static void udp4_format_sock(struct sock *sp, struct seq_file *f,
-                int bucket, int *len)
+                int bucket)
 {
         struct inet_sock *inet = inet_sk(sp);
         __be32 dest = inet->inet_daddr;
@@ -2335,7 +2335,7 @@ static void udp4_format_sock(struct sock *sp, struct seq_file *f,
         __u16 srcp        = ntohs(inet->inet_sport);
 
         seq_printf(f, "%5d: %08X:%04X %08X:%04X"
-                " %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %d%n",
+                " %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %d",
                 bucket, src, srcp, dest, destp, sp->sk_state,
                 sk_wmem_alloc_get(sp),
                 sk_rmem_alloc_get(sp),
@@ -2343,23 +2343,22 @@ static void udp4_format_sock(struct sock *sp, struct seq_file *f,
                 from_kuid_munged(seq_user_ns(f), sock_i_uid(sp)),
                 0, sock_i_ino(sp),
                 atomic_read(&sp->sk_refcnt), sp,
-                atomic_read(&sp->sk_drops), len);
+                atomic_read(&sp->sk_drops));
 }
 
 int udp4_seq_show(struct seq_file *seq, void *v)
 {
+        seq_setwidth(seq, 127);
         if (v == SEQ_START_TOKEN)
-                seq_printf(seq, "%-127s\n",
-                           "  sl  local_address rem_address   st tx_queue "
+                seq_puts(seq, "  sl  local_address rem_address   st tx_queue "
                            "rx_queue tr tm->when retrnsmt   uid  timeout "
                            "inode ref pointer drops");
         else {
                 struct udp_iter_state *state = seq->private;
-                int len;
 
-                udp4_format_sock(v, seq, state->bucket, &len);
-                seq_printf(seq, "%*s\n", 127 - len, "");
+                udp4_format_sock(v, seq, state->bucket);
         }
+        seq_pad(seq, '\n');
         return 0;
 }
 
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index cdc14d0947f3..12c97d8aa6bb 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -271,10 +271,24 @@ static void addrconf_mod_dad_timer(struct inet6_ifaddr *ifp,
 
 static int snmp6_alloc_dev(struct inet6_dev *idev)
 {
+        int i;
+
         if (snmp_mib_init((void __percpu **)idev->stats.ipv6,
                           sizeof(struct ipstats_mib),
                           __alignof__(struct ipstats_mib)) < 0)
                 goto err_ip;
+
+        for_each_possible_cpu(i) {
+                struct ipstats_mib *addrconf_stats;
+                addrconf_stats = per_cpu_ptr(idev->stats.ipv6[0], i);
+                u64_stats_init(&addrconf_stats->syncp);
+#if SNMP_ARRAY_SZ == 2
+                addrconf_stats = per_cpu_ptr(idev->stats.ipv6[1], i);
+                u64_stats_init(&addrconf_stats->syncp);
+#endif
+        }
+
+
         idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device),
                                         GFP_KERNEL);
         if (!idev->stats.icmpv6dev)
diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c
index 56ca35b30dda..4fbdb7046d28 100644
--- a/net/ipv6/af_inet6.c
+++ b/net/ipv6/af_inet6.c
@@ -714,6 +714,8 @@ static void ipv6_packet_cleanup(void)
 
 static int __net_init ipv6_init_mibs(struct net *net)
 {
+        int i;
+
         if (snmp_mib_init((void __percpu **)net->mib.udp_stats_in6,
                           sizeof(struct udp_mib),
                           __alignof__(struct udp_mib)) < 0)
@@ -726,6 +728,18 @@ static int __net_init ipv6_init_mibs(struct net *net)
                           sizeof(struct ipstats_mib),
                           __alignof__(struct ipstats_mib)) < 0)
                 goto err_ip_mib;
+
+        for_each_possible_cpu(i) {
+                struct ipstats_mib *af_inet6_stats;
+                af_inet6_stats = per_cpu_ptr(net->mib.ipv6_statistics[0], i);
+                u64_stats_init(&af_inet6_stats->syncp);
+#if SNMP_ARRAY_SZ == 2
+                af_inet6_stats = per_cpu_ptr(net->mib.ipv6_statistics[1], i);
+                u64_stats_init(&af_inet6_stats->syncp);
+#endif
+        }
+
+
         if (snmp_mib_init((void __percpu **)net->mib.icmpv6_statistics,
                           sizeof(struct icmpv6_mib),
                           __alignof__(struct icmpv6_mib)) < 0)
diff --git a/net/ipv6/ip6_gre.c b/net/ipv6/ip6_gre.c
index bf4a9a084de5..8acb28621f9c 100644
--- a/net/ipv6/ip6_gre.c
+++ b/net/ipv6/ip6_gre.c
@@ -1252,6 +1252,7 @@ static void ip6gre_tunnel_setup(struct net_device *dev)
 static int ip6gre_tunnel_init(struct net_device *dev)
 {
         struct ip6_tnl *tunnel;
+        int i;
 
         tunnel = netdev_priv(dev);
 
@@ -1269,6 +1270,13 @@ static int ip6gre_tunnel_init(struct net_device *dev)
         if (!dev->tstats)
                 return -ENOMEM;
 
+        for_each_possible_cpu(i) {
+                struct pcpu_tstats *ip6gre_tunnel_stats;
+                ip6gre_tunnel_stats = per_cpu_ptr(dev->tstats, i);
+                u64_stats_init(&ip6gre_tunnel_stats->syncp);
+        }
+
+
         return 0;
 }
 
@@ -1449,6 +1457,7 @@ static void ip6gre_netlink_parms(struct nlattr *data[],
 static int ip6gre_tap_init(struct net_device *dev)
 {
         struct ip6_tnl *tunnel;
+        int i;
 
         tunnel = netdev_priv(dev);
 
@@ -1462,6 +1471,12 @@ static int ip6gre_tap_init(struct net_device *dev)
         if (!dev->tstats)
                 return -ENOMEM;
 
+        for_each_possible_cpu(i) {
+                struct pcpu_tstats *ip6gre_tap_stats;
+                ip6gre_tap_stats = per_cpu_ptr(dev->tstats, i);
+                u64_stats_init(&ip6gre_tap_stats->syncp);
+        }
+
         return 0;
 }
 
diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c
index 5e31a909a2b0..59df872e2f4d 100644
--- a/net/ipv6/ip6_output.c
+++ b/net/ipv6/ip6_output.c
@@ -910,7 +910,7 @@ static int ip6_dst_lookup_tail(struct sock *sk,
 
 out_err_release:
         if (err == -ENETUNREACH)
-                IP6_INC_STATS_BH(net, NULL, IPSTATS_MIB_OUTNOROUTES);
+                IP6_INC_STATS(net, NULL, IPSTATS_MIB_OUTNOROUTES);
         dst_release(*dst);
         *dst = NULL;
         return err;
diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c
index c1e11b5d6ccc..d6062325db08 100644
--- a/net/ipv6/ip6_tunnel.c
+++ b/net/ipv6/ip6_tunnel.c
@@ -1494,12 +1494,19 @@ static inline int
 ip6_tnl_dev_init_gen(struct net_device *dev)
 {
         struct ip6_tnl *t = netdev_priv(dev);
+        int i;
 
         t->dev = dev;
         t->net = dev_net(dev);
         dev->tstats = alloc_percpu(struct pcpu_tstats);
         if (!dev->tstats)
                 return -ENOMEM;
+
+        for_each_possible_cpu(i) {
+                struct pcpu_tstats *ip6_tnl_stats;
+                ip6_tnl_stats = per_cpu_ptr(dev->tstats, i);
+                u64_stats_init(&ip6_tnl_stats->syncp);
+        }
         return 0;
 }
 
diff --git a/net/ipv6/sit.c b/net/ipv6/sit.c
index 5a57f38a50d5..1b4a4a953675 100644
--- a/net/ipv6/sit.c
+++ b/net/ipv6/sit.c
@@ -1320,6 +1320,7 @@ static void ipip6_tunnel_setup(struct net_device *dev)
 static int ipip6_tunnel_init(struct net_device *dev)
 {
         struct ip_tunnel *tunnel = netdev_priv(dev);
+        int i;
 
         tunnel->dev = dev;
         tunnel->net = dev_net(dev);
@@ -1332,6 +1333,12 @@ static int ipip6_tunnel_init(struct net_device *dev)
         if (!dev->tstats)
                 return -ENOMEM;
 
+        for_each_possible_cpu(i) {
+                struct pcpu_tstats *ipip6_tunnel_stats;
+                ipip6_tunnel_stats = per_cpu_ptr(dev->tstats, i);
+                u64_stats_init(&ipip6_tunnel_stats->syncp);
+        }
+
         return 0;
 }
 
@@ -1341,6 +1348,7 @@ static int __net_init ipip6_fb_tunnel_init(struct net_device *dev)
         struct iphdr *iph = &tunnel->parms.iph;
         struct net *net = dev_net(dev);
         struct sit_net *sitn = net_generic(net, sit_net_id);
+        int i;
 
         tunnel->dev = dev;
         tunnel->net = dev_net(dev);
@@ -1354,6 +1362,13 @@ static int __net_init ipip6_fb_tunnel_init(struct net_device *dev)
         dev->tstats = alloc_percpu(struct pcpu_tstats);
         if (!dev->tstats)
                 return -ENOMEM;
+
+        for_each_possible_cpu(i) {
+                struct pcpu_tstats *ipip6_fb_stats;
+                ipip6_fb_stats = per_cpu_ptr(dev->tstats, i);
+                u64_stats_init(&ipip6_fb_stats->syncp);
+        }
+
         dev_hold(dev);
         rcu_assign_pointer(sitn->tunnels_wc[0], tunnel);
         return 0;
diff --git a/net/netfilter/ipvs/ip_vs_ctl.c b/net/netfilter/ipvs/ip_vs_ctl.c
index 393498704691..35be035ee0ce 100644
--- a/net/netfilter/ipvs/ip_vs_ctl.c
+++ b/net/netfilter/ipvs/ip_vs_ctl.c
@@ -842,7 +842,7 @@ ip_vs_new_dest(struct ip_vs_service *svc, struct ip_vs_dest_user_kern *udest,
                struct ip_vs_dest **dest_p)
 {
         struct ip_vs_dest *dest;
-        unsigned int atype;
+        unsigned int atype, i;
 
         EnterFunction(2);
 
@@ -869,6 +869,12 @@ ip_vs_new_dest(struct ip_vs_service *svc, struct ip_vs_dest_user_kern *udest,
         if (!dest->stats.cpustats)
                 goto err_alloc;
 
+        for_each_possible_cpu(i) {
+                struct ip_vs_cpu_stats *ip_vs_dest_stats;
+                ip_vs_dest_stats = per_cpu_ptr(dest->stats.cpustats, i);
+                u64_stats_init(&ip_vs_dest_stats->syncp);
+        }
+
         dest->af = svc->af;
         dest->protocol = svc->protocol;
         dest->vaddr = svc->addr;
@@ -1134,7 +1140,7 @@ static int
 ip_vs_add_service(struct net *net, struct ip_vs_service_user_kern *u,
                   struct ip_vs_service **svc_p)
 {
-        int ret = 0;
+        int ret = 0, i;
         struct ip_vs_scheduler *sched = NULL;
         struct ip_vs_pe *pe = NULL;
         struct ip_vs_service *svc = NULL;
@@ -1184,6 +1190,13 @@ ip_vs_add_service(struct net *net, struct ip_vs_service_user_kern *u,
                 goto out_err;
         }
 
+        for_each_possible_cpu(i) {
+                struct ip_vs_cpu_stats *ip_vs_stats;
+                ip_vs_stats = per_cpu_ptr(svc->stats.cpustats, i);
+                u64_stats_init(&ip_vs_stats->syncp);
+        }
+
+
         /* I'm the first user of the service */
         atomic_set(&svc->refcnt, 0);
 
@@ -3780,7 +3793,7 @@ static struct notifier_block ip_vs_dst_notifier = {
 
 int __net_init ip_vs_control_net_init(struct net *net)
 {
-        int idx;
+        int i, idx;
         struct netns_ipvs *ipvs = net_ipvs(net);
 
         /* Initialize rs_table */
@@ -3799,6 +3812,12 @@ int __net_init ip_vs_control_net_init(struct net *net)
         if (!ipvs->tot_stats.cpustats)
                 return -ENOMEM;
 
+        for_each_possible_cpu(i) {
+                struct ip_vs_cpu_stats *ipvs_tot_stats;
+                ipvs_tot_stats = per_cpu_ptr(ipvs->tot_stats.cpustats, i);
+                u64_stats_init(&ipvs_tot_stats->syncp);
+        }
+
         spin_lock_init(&ipvs->tot_stats.lock);
 
         proc_create("ip_vs", 0, net->proc_net, &ip_vs_info_fops);
diff --git a/net/netfilter/xt_set.c b/net/netfilter/xt_set.c
index e7c4e0e01ff5..80c2e2d603e0 100644
--- a/net/netfilter/xt_set.c
+++ b/net/netfilter/xt_set.c
@@ -84,7 +84,7 @@ set_match_v0_checkentry(const struct xt_mtchk_param *par)
         index = ip_set_nfnl_get_byindex(par->net, info->match_set.index);
 
         if (index == IPSET_INVALID_ID) {
-                pr_warning("Cannot find set indentified by id %u to match\n",
+                pr_warning("Cannot find set identified by id %u to match\n",
                            info->match_set.index);
                 return -ENOENT;
         }
@@ -134,7 +134,7 @@ set_match_v1_checkentry(const struct xt_mtchk_param *par)
         index = ip_set_nfnl_get_byindex(par->net, info->match_set.index);
 
         if (index == IPSET_INVALID_ID) {
-                pr_warning("Cannot find set indentified by id %u to match\n",
+                pr_warning("Cannot find set identified by id %u to match\n",
                            info->match_set.index);
                 return -ENOENT;
         }
diff --git a/net/openvswitch/datapath.c b/net/openvswitch/datapath.c
index 1de4d281e3f1..6f5e1dd3be2d 100644
--- a/net/openvswitch/datapath.c
+++ b/net/openvswitch/datapath.c
@@ -1199,6 +1199,12 @@ static int ovs_dp_cmd_new(struct sk_buff *skb, struct genl_info *info)
                 goto err_destroy_table;
         }
 
+        for_each_possible_cpu(i) {
+                struct dp_stats_percpu *dpath_stats;
+                dpath_stats = per_cpu_ptr(dp->stats_percpu, i);
+                u64_stats_init(&dpath_stats->sync);
+        }
+
         dp->ports = kmalloc(DP_VPORT_HASH_BUCKETS * sizeof(struct hlist_head),
                             GFP_KERNEL);
         if (!dp->ports) {
diff --git a/net/openvswitch/vport.c b/net/openvswitch/vport.c
index 6f65dbe13812..d830a95f03a4 100644
--- a/net/openvswitch/vport.c
+++ b/net/openvswitch/vport.c
@@ -118,6 +118,7 @@ struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops,
 {
         struct vport *vport;
         size_t alloc_size;
+        int i;
 
         alloc_size = sizeof(struct vport);
         if (priv_size) {
@@ -141,6 +142,13 @@ struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops,
                 return ERR_PTR(-ENOMEM);
         }
 
+        for_each_possible_cpu(i) {
+                struct pcpu_tstats *vport_stats;
+                vport_stats = per_cpu_ptr(vport->percpu_stats, i);
+                u64_stats_init(&vport_stats->syncp);
+        }
+
+
         spin_lock_init(&vport->stats_lock);
 
         return vport;
diff --git a/net/phonet/socket.c b/net/phonet/socket.c
index 77e38f733496..008214a3d5eb 100644
--- a/net/phonet/socket.c
+++ b/net/phonet/socket.c
@@ -595,26 +595,25 @@ static void pn_sock_seq_stop(struct seq_file *seq, void *v)
 
 static int pn_sock_seq_show(struct seq_file *seq, void *v)
 {
-        int len;
-
+        seq_setwidth(seq, 127);
         if (v == SEQ_START_TOKEN)
-                seq_printf(seq, "%s%n", "pt  loc  rem rs st tx_queue rx_queue "
-                        "  uid inode ref pointer drops", &len);
+                seq_puts(seq, "pt  loc  rem rs st tx_queue rx_queue "
+                        "  uid inode ref pointer drops");
         else {
                 struct sock *sk = v;
                 struct pn_sock *pn = pn_sk(sk);
 
                 seq_printf(seq, "%2d %04X:%04X:%02X %02X %08X:%08X %5d %lu "
-                        "%d %pK %d%n",
+                        "%d %pK %d",
                         sk->sk_protocol, pn->sobject, pn->dobject,
                         pn->resource, sk->sk_state,
                         sk_wmem_alloc_get(sk), sk_rmem_alloc_get(sk),
                         from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
                         sock_i_ino(sk),
                         atomic_read(&sk->sk_refcnt), sk,
-                        atomic_read(&sk->sk_drops), &len);
+                        atomic_read(&sk->sk_drops));
         }
-        seq_printf(seq, "%*s\n", 127 - len, "");
+        seq_pad(seq, '\n');
         return 0;
 }
 
@@ -785,20 +784,19 @@ static void pn_res_seq_stop(struct seq_file *seq, void *v)
 
 static int pn_res_seq_show(struct seq_file *seq, void *v)
 {
-        int len;
-
+        seq_setwidth(seq, 63);
         if (v == SEQ_START_TOKEN)
-                seq_printf(seq, "%s%n", "rs   uid inode", &len);
+                seq_puts(seq, "rs   uid inode");
         else {
                 struct sock **psk = v;
                 struct sock *sk = *psk;
 
-                seq_printf(seq, "%02X %5u %lu%n",
+                seq_printf(seq, "%02X %5u %lu",
                            (int) (psk - pnres.sk),
                            from_kuid_munged(seq_user_ns(seq), sock_i_uid(sk)),
-                           sock_i_ino(sk), &len);
+                           sock_i_ino(sk));
         }
-        seq_printf(seq, "%*s\n", 63 - len, "");
+        seq_pad(seq, '\n');
         return 0;
 }
 
diff --git a/net/sctp/objcnt.c b/net/sctp/objcnt.c
index 5ea573b37648..647396baa56f 100644
--- a/net/sctp/objcnt.c
+++ b/net/sctp/objcnt.c
@@ -79,12 +79,13 @@ static sctp_dbg_objcnt_entry_t sctp_dbg_objcnt[] = {
  */
 static int sctp_objcnt_seq_show(struct seq_file *seq, void *v)
 {
-        int i, len;
+        int i;
 
         i = (int)*(loff_t *)v;
-        seq_printf(seq, "%s: %d%n", sctp_dbg_objcnt[i].label,
-                                atomic_read(sctp_dbg_objcnt[i].counter), &len);
-        seq_printf(seq, "%*s\n", 127 - len, "");
+        seq_setwidth(seq, 127);
+        seq_printf(seq, "%s: %d", sctp_dbg_objcnt[i].label,
+                                atomic_read(sctp_dbg_objcnt[i].counter));
+        seq_pad(seq, '\n');
         return 0;
 }
 
diff --git a/net/sunrpc/auth_gss/gss_krb5_unseal.c b/net/sunrpc/auth_gss/gss_krb5_unseal.c
index 6cd930f3678f..6c981ddc19f8 100644
--- a/net/sunrpc/auth_gss/gss_krb5_unseal.c
+++ b/net/sunrpc/auth_gss/gss_krb5_unseal.c
@@ -150,7 +150,6 @@ gss_verify_mic_v2(struct krb5_ctx *ctx,
         struct xdr_netobj cksumobj = {.len = sizeof(cksumdata),
                                       .data = cksumdata};
         s32 now;
-        u64 seqnum;
         u8 *ptr = read_token->data;
         u8 *cksumkey;
         u8 flags;
@@ -197,9 +196,10 @@ gss_verify_mic_v2(struct krb5_ctx *ctx,
         if (now > ctx->endtime)
                 return GSS_S_CONTEXT_EXPIRED;
 
-        /* do sequencing checks */
-
-        seqnum = be64_to_cpup((__be64 *)ptr + 8);
+        /*
+         * NOTE: the sequence number at ptr + 8 is skipped, rpcsec_gss
+         * doesn't want it checked; see page 6 of rfc 2203.
+         */
 
         return GSS_S_COMPLETE;
 }
diff --git a/net/sunrpc/auth_gss/gss_krb5_wrap.c b/net/sunrpc/auth_gss/gss_krb5_wrap.c
index 1da52d1406fc..42560e55d978 100644
--- a/net/sunrpc/auth_gss/gss_krb5_wrap.c
+++ b/net/sunrpc/auth_gss/gss_krb5_wrap.c
@@ -489,7 +489,6 @@ static u32
 gss_unwrap_kerberos_v2(struct krb5_ctx *kctx, int offset, struct xdr_buf *buf)
 {
         s32             now;
-        u64             seqnum;
         u8              *ptr;
         u8              flags = 0x00;
         u16             ec, rrc;
@@ -525,7 +524,10 @@ gss_unwrap_kerberos_v2(struct krb5_ctx *kctx, int offset, struct xdr_buf *buf)
         ec = be16_to_cpup((__be16 *)(ptr + 4));
         rrc = be16_to_cpup((__be16 *)(ptr + 6));
 
-        seqnum = be64_to_cpup((__be64 *)(ptr + 8));
+        /*
+         * NOTE: the sequence number at ptr + 8 is skipped, rpcsec_gss
+         * doesn't want it checked; see page 6 of rfc 2203.
+         */
 
         if (rrc != 0)
                 rotate_left(offset + 16, buf, rrc);
@@ -574,8 +576,8 @@ gss_unwrap_kerberos_v2(struct krb5_ctx *kctx, int offset, struct xdr_buf *buf)
         buf->head[0].iov_len -= GSS_KRB5_TOK_HDR_LEN + headskip;
         buf->len -= GSS_KRB5_TOK_HDR_LEN + headskip;
 
-        /* Trim off the checksum blob */
-        xdr_buf_trim(buf, GSS_KRB5_TOK_HDR_LEN + tailskip);
+        /* Trim off the trailing "extra count" and checksum blob */
+        xdr_buf_trim(buf, ec + GSS_KRB5_TOK_HDR_LEN + tailskip);
         return GSS_S_COMPLETE;
 }
 
diff --git a/net/sunrpc/auth_gss/gss_rpc_upcall.c b/net/sunrpc/auth_gss/gss_rpc_upcall.c
index f1eb0d16666c..458f85e9b0ba 100644
--- a/net/sunrpc/auth_gss/gss_rpc_upcall.c
+++ b/net/sunrpc/auth_gss/gss_rpc_upcall.c
@@ -298,7 +298,8 @@ int gssp_accept_sec_context_upcall(struct net *net,
         if (res.context_handle) {
                 data->out_handle = rctxh.exported_context_token;
                 data->mech_oid.len = rctxh.mech.len;
-                memcpy(data->mech_oid.data, rctxh.mech.data,
+                if (rctxh.mech.data)
+                        memcpy(data->mech_oid.data, rctxh.mech.data,
                                                 data->mech_oid.len);
                 client_name = rctxh.src_name.display_name;
         }
diff --git a/net/sunrpc/auth_gss/gss_rpc_xdr.c b/net/sunrpc/auth_gss/gss_rpc_xdr.c
index f0f78c5f1c7d..1ec19f6f0c2b 100644
--- a/net/sunrpc/auth_gss/gss_rpc_xdr.c
+++ b/net/sunrpc/auth_gss/gss_rpc_xdr.c
@@ -559,6 +559,8 @@ static int gssx_enc_cred(struct xdr_stream *xdr,
 
         /* cred->elements */
         err = dummy_enc_credel_array(xdr, &cred->elements);
+        if (err)
+                return err;
 
         /* cred->cred_handle_reference */
         err = gssx_enc_buffer(xdr, &cred->cred_handle_reference);
@@ -740,22 +742,20 @@ void gssx_enc_accept_sec_context(struct rpc_rqst *req,
                 goto done;
 
         /* arg->context_handle */
-        if (arg->context_handle) {
+        if (arg->context_handle)
                 err = gssx_enc_ctx(xdr, arg->context_handle);
-                if (err)
-                        goto done;
-        } else {
+        else
                 err = gssx_enc_bool(xdr, 0);
-        }
+        if (err)
+                goto done;
 
         /* arg->cred_handle */
-        if (arg->cred_handle) {
+        if (arg->cred_handle)
                 err = gssx_enc_cred(xdr, arg->cred_handle);
-                if (err)
-                        goto done;
-        } else {
+        else
                 err = gssx_enc_bool(xdr, 0);
-        }
+        if (err)
+                goto done;
 
         /* arg->input_token */
         err = gssx_enc_in_token(xdr, &arg->input_token);
@@ -763,13 +763,12 @@ void gssx_enc_accept_sec_context(struct rpc_rqst *req,
                 goto done;
 
         /* arg->input_cb */
-        if (arg->input_cb) {
+        if (arg->input_cb)
                 err = gssx_enc_cb(xdr, arg->input_cb);
-                if (err)
-                        goto done;
-        } else {
+        else
                 err = gssx_enc_bool(xdr, 0);
-        }
+        if (err)
+                goto done;
 
         err = gssx_enc_bool(xdr, arg->ret_deleg_cred);
         if (err)
diff --git a/net/sunrpc/auth_gss/svcauth_gss.c b/net/sunrpc/auth_gss/svcauth_gss.c
index 09fb638bcaa4..008cdade5aae 100644
--- a/net/sunrpc/auth_gss/svcauth_gss.c
+++ b/net/sunrpc/auth_gss/svcauth_gss.c
@@ -1167,8 +1167,8 @@ static int gss_proxy_save_rsc(struct cache_detail *cd,
         if (!ud->found_creds) {
                 /* userspace seem buggy, we should always get at least a
                  * mapping to nobody */
-                dprintk("RPC:       No creds found, marking Negative!\n");
-                set_bit(CACHE_NEGATIVE, &rsci.h.flags);
+                dprintk("RPC:       No creds found!\n");
+                goto out;
         } else {
 
                 /* steal creds */
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index dab09dac8fc7..f09b7db2c492 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -750,14 +750,16 @@ EXPORT_SYMBOL_GPL(rpc_shutdown_client);
 /*
  * Free an RPC client
  */
-static void
+static struct rpc_clnt *
 rpc_free_client(struct rpc_clnt *clnt)
 {
+        struct rpc_clnt *parent = NULL;
+
         dprintk_rcu("RPC:       destroying %s client for %s\n",
                         clnt->cl_program->name,
                         rcu_dereference(clnt->cl_xprt)->servername);
         if (clnt->cl_parent != clnt)
-                rpc_release_client(clnt->cl_parent);
+                parent = clnt->cl_parent;
         rpc_clnt_remove_pipedir(clnt);
         rpc_unregister_client(clnt);
         rpc_free_iostats(clnt->cl_metrics);
@@ -766,18 +768,17 @@ rpc_free_client(struct rpc_clnt *clnt)
         rpciod_down();
         rpc_free_clid(clnt);
         kfree(clnt);
+        return parent;
 }
 
 /*
  * Free an RPC client
  */
-static void
+static struct rpc_clnt * 
 rpc_free_auth(struct rpc_clnt *clnt)
 {
-        if (clnt->cl_auth == NULL) {
-                rpc_free_client(clnt);
-                return;
-        }
+        if (clnt->cl_auth == NULL)
+                return rpc_free_client(clnt);
 
         /*
          * Note: RPCSEC_GSS may need to send NULL RPC calls in order to
@@ -788,7 +789,8 @@ rpc_free_auth(struct rpc_clnt *clnt)
         rpcauth_release(clnt->cl_auth);
         clnt->cl_auth = NULL;
         if (atomic_dec_and_test(&clnt->cl_count))
-                rpc_free_client(clnt);
+                return rpc_free_client(clnt);
+        return NULL;
 }
 
 /*
@@ -799,10 +801,13 @@ rpc_release_client(struct rpc_clnt *clnt)
 {
         dprintk("RPC:       rpc_release_client(%p)\n", clnt);
 
-        if (list_empty(&clnt->cl_tasks))
-                wake_up(&destroy_wait);
-        if (atomic_dec_and_test(&clnt->cl_count))
-                rpc_free_auth(clnt);
+        do {
+                if (list_empty(&clnt->cl_tasks))
+                        wake_up(&destroy_wait);
+                if (!atomic_dec_and_test(&clnt->cl_count))
+                        break;
+                clnt = rpc_free_auth(clnt);
+        } while (clnt != NULL);
 }
 EXPORT_SYMBOL_GPL(rpc_release_client);
 
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index b974571126fe..e7fbe368b4a3 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -1104,8 +1104,6 @@ svc_process_common(struct svc_rqst *rqstp, struct kvec *argv, struct kvec *resv)
         rqstp->rq_vers = vers = svc_getnl(argv);        /* version number */
         rqstp->rq_proc = proc = svc_getnl(argv);        /* procedure number */
 
-        progp = serv->sv_program;
-
         for (progp = serv->sv_program; progp; progp = progp->pg_next)
                 if (prog == progp->pg_prog)
                         break;
diff --git a/net/sunrpc/xprtsock.c b/net/sunrpc/xprtsock.c
index 17c88928b7db..dd9d295813cf 100644
--- a/net/sunrpc/xprtsock.c
+++ b/net/sunrpc/xprtsock.c
@@ -393,8 +393,10 @@ static int xs_send_kvec(struct socket *sock, struct sockaddr *addr, int addrlen,
         return kernel_sendmsg(sock, &msg, NULL, 0, 0);
 }
 
-static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned int base, int more)
+static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned int base, int more, bool zerocopy)
 {
+        ssize_t (*do_sendpage)(struct socket *sock, struct page *page,
+                        int offset, size_t size, int flags);
         struct page **ppage;
         unsigned int remainder;
         int err, sent = 0;
@@ -403,6 +405,9 @@ static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned i
         base += xdr->page_base;
         ppage = xdr->pages + (base >> PAGE_SHIFT);
         base &= ~PAGE_MASK;
+        do_sendpage = sock->ops->sendpage;
+        if (!zerocopy)
+                do_sendpage = sock_no_sendpage;
         for(;;) {
                 unsigned int len = min_t(unsigned int, PAGE_SIZE - base, remainder);
                 int flags = XS_SENDMSG_FLAGS;
@@ -410,7 +415,7 @@ static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned i
                 remainder -= len;
                 if (remainder != 0 || more)
                         flags |= MSG_MORE;
-                err = sock->ops->sendpage(sock, *ppage, base, len, flags);
+                err = do_sendpage(sock, *ppage, base, len, flags);
                 if (remainder == 0 || err != len)
                         break;
                 sent += err;
@@ -431,9 +436,10 @@ static int xs_send_pagedata(struct socket *sock, struct xdr_buf *xdr, unsigned i
  * @addrlen: UDP only -- length of destination address
  * @xdr: buffer containing this request
  * @base: starting position in the buffer
+ * @zerocopy: true if it is safe to use sendpage()
  *
  */
-static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base)
+static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen, struct xdr_buf *xdr, unsigned int base, bool zerocopy)
 {
         unsigned int remainder = xdr->len - base;
         int err, sent = 0;
@@ -461,7 +467,7 @@ static int xs_sendpages(struct socket *sock, struct sockaddr *addr, int addrlen,
         if (base < xdr->page_len) {
                 unsigned int len = xdr->page_len - base;
                 remainder -= len;
-                err = xs_send_pagedata(sock, xdr, base, remainder != 0);
+                err = xs_send_pagedata(sock, xdr, base, remainder != 0, zerocopy);
                 if (remainder == 0 || err != len)
                         goto out;
                 sent += err;
@@ -564,7 +570,7 @@ static int xs_local_send_request(struct rpc_task *task)
                         req->rq_svec->iov_base, req->rq_svec->iov_len);
 
         status = xs_sendpages(transport->sock, NULL, 0,
-                                                xdr, req->rq_bytes_sent);
+                                                xdr, req->rq_bytes_sent, true);
         dprintk("RPC:       %s(%u) = %d\n",
                         __func__, xdr->len - req->rq_bytes_sent, status);
         if (likely(status >= 0)) {
@@ -620,7 +626,7 @@ static int xs_udp_send_request(struct rpc_task *task)
         status = xs_sendpages(transport->sock,
                               xs_addr(xprt),
                               xprt->addrlen, xdr,
-                              req->rq_bytes_sent);
+                              req->rq_bytes_sent, true);
 
         dprintk("RPC:       xs_udp_send_request(%u) = %d\n",
                         xdr->len - req->rq_bytes_sent, status);
@@ -693,6 +699,7 @@ static int xs_tcp_send_request(struct rpc_task *task)
         struct rpc_xprt *xprt = req->rq_xprt;
         struct sock_xprt *transport = container_of(xprt, struct sock_xprt, xprt);
         struct xdr_buf *xdr = &req->rq_snd_buf;
+        bool zerocopy = true;
         int status;
 
         xs_encode_stream_record_marker(&req->rq_snd_buf);
@@ -700,13 +707,20 @@ static int xs_tcp_send_request(struct rpc_task *task)
         xs_pktdump("packet data:",
                                 req->rq_svec->iov_base,
                                 req->rq_svec->iov_len);
+        /* Don't use zero copy if this is a resend. If the RPC call
+         * completes while the socket holds a reference to the pages,
+         * then we may end up resending corrupted data.
+         */
+        if (task->tk_flags & RPC_TASK_SENT)
+                zerocopy = false;
 
         /* Continue transmitting the packet/record. We must be careful
          * to cope with writespace callbacks arriving _after_ we have
          * called sendmsg(). */
         while (1) {
                 status = xs_sendpages(transport->sock,
-                                        NULL, 0, xdr, req->rq_bytes_sent);
+                                        NULL, 0, xdr, req->rq_bytes_sent,
+                                        zerocopy);
 
                 dprintk("RPC:       xs_tcp_send_request(%u) = %d\n",
                                 xdr->len - req->rq_bytes_sent, status);
diff --git a/net/vmw_vsock/Kconfig b/net/vmw_vsock/Kconfig
index b5fa7e40cdcb..14810abedc2e 100644
--- a/net/vmw_vsock/Kconfig
+++ b/net/vmw_vsock/Kconfig
@@ -6,7 +6,7 @@ config VSOCKETS
         tristate "Virtual Socket protocol"
         help
           Virtual Socket Protocol is a socket protocol similar to TCP/IP
-          allowing comunication between Virtual Machines and hypervisor
+          allowing communication between Virtual Machines and hypervisor
           or host.
 
           You should also select one or more hypervisor-specific transports