udp: Remove UDP-Lite SNMP stats.

Since UDP and UDP-Lite shared most of the code, we have had
to check the protocol every time we increment SNMP stats.

Now that the UDP-Lite paths are dead, let's remove UDP-Lite
SNMP stats.

Signed-off-by: Kuniyuki Iwashima <kuniyu@google.com>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Link: https://patch.msgid.link/20260311052020.1213705-6-kuniyu@google.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/include/net/netns/mib.h b/include/net/netns/mib.h
index 7e373664b1e7baaa7cdb3df572f2b5a78aff0a39..dce05f8e6a3363ff913f10032cdf0ae82d3dd389 100644 (file)
--- a/include/net/netns/mib.h
+++ b/include/net/netns/mib.h
@@ -28,11 +28,6 @@ struct netns_mib {
        DEFINE_SNMP_STAT(struct mptcp_mib, mptcp_statistics);
 #endif
 
-       DEFINE_SNMP_STAT(struct udp_mib, udplite_statistics);
-#if IS_ENABLED(CONFIG_IPV6)
-       DEFINE_SNMP_STAT(struct udp_mib, udplite_stats_in6);
-#endif
-
        DEFINE_SNMP_STAT(struct icmp_mib, icmp_statistics);
        DEFINE_SNMP_STAT_ATOMIC(struct icmpmsg_mib, icmpmsg_statistics);
 #if IS_ENABLED(CONFIG_IPV6)

diff --git a/include/net/udp.h b/include/net/udp.h
index 39223e2692e9416b0f7d8bee0eba4f6d44b59681..264c10607d2e9c28d477bb194b0170d99236f239 100644 (file)
--- a/include/net/udp.h
+++ b/include/net/udp.h
@@ -529,38 +529,28 @@ static inline int copy_linear_skb(struct sk_buff *skb, int len, int off,
 }
 
 /*
- *     SNMP statistics for UDP and UDP-Lite
+ *     SNMP statistics for UDP
  */
-#define UDP_INC_STATS(net, field, is_udplite)                do { \
-       if (unlikely(is_udplite)) SNMP_INC_STATS((net)->mib.udplite_statistics, field); \
-       else            SNMP_INC_STATS((net)->mib.udp_statistics, field);  }  while(0)
-#define __UDP_INC_STATS(net, field, is_udplite)              do { \
-       if (unlikely(is_udplite)) __SNMP_INC_STATS((net)->mib.udplite_statistics, field);       \
-       else            __SNMP_INC_STATS((net)->mib.udp_statistics, field);    }  while(0)
-
-#define __UDP6_INC_STATS(net, field, is_udplite)           do { \
-       if (unlikely(is_udplite)) __SNMP_INC_STATS((net)->mib.udplite_stats_in6, field);        \
-       else            __SNMP_INC_STATS((net)->mib.udp_stats_in6, field);  \
-} while(0)
-#define UDP6_INC_STATS(net, field, __lite)                 do { \
-       if (unlikely(__lite)) SNMP_INC_STATS((net)->mib.udplite_stats_in6, field);      \
-       else        SNMP_INC_STATS((net)->mib.udp_stats_in6, field);      \
-} while(0)
+#define __UDP_INC_STATS(net, field)                            \
+       __SNMP_INC_STATS((net)->mib.udp_statistics, field)
+#define UDP_INC_STATS(net, field)                              \
+       SNMP_INC_STATS((net)->mib.udp_statistics, field)
+#define __UDP6_INC_STATS(net, field)                           \
+       __SNMP_INC_STATS((net)->mib.udp_stats_in6, field)
+#define UDP6_INC_STATS(net, field)                             \
+       SNMP_INC_STATS((net)->mib.udp_stats_in6, field)
 
 #if IS_ENABLED(CONFIG_IPV6)
-#define __UDPX_MIB(sk, ipv4)                                           \
-({                                                                     \
-       ipv4 ? (IS_UDPLITE(sk) ? sock_net(sk)->mib.udplite_statistics : \
-                                sock_net(sk)->mib.udp_statistics) :    \
-               (IS_UDPLITE(sk) ? sock_net(sk)->mib.udplite_stats_in6 : \
-                                sock_net(sk)->mib.udp_stats_in6);      \
-})
+#define __UDPX_MIB(sk, ipv4)                                   \
+       ({                                                      \
+               ipv4 ? sock_net(sk)->mib.udp_statistics :       \
+                       sock_net(sk)->mib.udp_stats_in6;        \
+       })
 #else
-#define __UDPX_MIB(sk, ipv4)                                           \
-({                                                                     \
-       IS_UDPLITE(sk) ? sock_net(sk)->mib.udplite_statistics :         \
-                        sock_net(sk)->mib.udp_statistics;              \
-})
+#define __UDPX_MIB(sk, ipv4)                                   \
+       ({                                                      \
+               sock_net(sk)->mib.udp_statistics;               \
+       })
 #endif
 
 #define __UDPX_INC_STATS(sk, field) \

diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c
index 5d4bc4c1a731dcc4b50e8a6e674ecaebb6ff1952..f98e46ae3e301fc3849c5ada0a321732f0d5aea2 100644 (file)
--- a/net/ipv4/af_inet.c
+++ b/net/ipv4/af_inet.c
@@ -1733,9 +1733,6 @@ static __net_init int ipv4_mib_init_net(struct net *net)
        net->mib.udp_statistics = alloc_percpu(struct udp_mib);
        if (!net->mib.udp_statistics)
                goto err_udp_mib;
-       net->mib.udplite_statistics = alloc_percpu(struct udp_mib);
-       if (!net->mib.udplite_statistics)
-               goto err_udplite_mib;
        net->mib.icmp_statistics = alloc_percpu(struct icmp_mib);
        if (!net->mib.icmp_statistics)
                goto err_icmp_mib;
@@ -1749,8 +1746,6 @@ static __net_init int ipv4_mib_init_net(struct net *net)
 err_icmpmsg_mib:
        free_percpu(net->mib.icmp_statistics);
 err_icmp_mib:
-       free_percpu(net->mib.udplite_statistics);
-err_udplite_mib:
        free_percpu(net->mib.udp_statistics);
 err_udp_mib:
        free_percpu(net->mib.net_statistics);
@@ -1766,7 +1761,6 @@ static __net_exit void ipv4_mib_exit_net(struct net *net)
 {
        kfree(net->mib.icmpmsg_statistics);
        free_percpu(net->mib.icmp_statistics);
-       free_percpu(net->mib.udplite_statistics);
        free_percpu(net->mib.udp_statistics);
        free_percpu(net->mib.net_statistics);
        free_percpu(net->mib.ip_statistics);

diff --git a/net/ipv4/proc.c b/net/ipv4/proc.c
index cf51f8fcf34b83a6e025c1da7b4ef60e3eb80e9c..bfc06d1713ecb0eac6655860ba2a37f606c3beea 100644 (file)
--- a/net/ipv4/proc.c
+++ b/net/ipv4/proc.c
@@ -444,19 +444,6 @@ static int snmp_seq_show_tcp_udp(struct seq_file *seq, void *v)
        for (i = 0; i < udp_cnt; i++)
                seq_printf(seq, " %lu", buff[i]);
 
-       memset(buff, 0, udp_cnt * sizeof(unsigned long));
-
-       /* the UDP and UDP-Lite MIBs are the same */
-       seq_puts(seq, "\nUdpLite:");
-       snmp_get_cpu_field_batch_cnt(buff, snmp4_udp_list,
-                                    udp_cnt,
-                                    net->mib.udplite_statistics);
-       for (i = 0; i < udp_cnt; i++)
-               seq_printf(seq, " %s", snmp4_udp_list[i].name);
-       seq_puts(seq, "\nUdpLite:");
-       for (i = 0; i < udp_cnt; i++)
-               seq_printf(seq, " %lu", buff[i]);
-
        seq_putc(seq, '\n');
        return 0;
 }

diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index b3f63a5ea2a900e09c3c0243a9d3696a5edfb3a5..10082095e6338a30fcf2baf0cb82406e0b1f0c88 100644 (file)
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -1198,13 +1198,12 @@ send:
        if (unlikely(err)) {
                if (err == -ENOBUFS &&
                    !inet_test_bit(RECVERR, sk)) {
-                       UDP_INC_STATS(sock_net(sk),
-                                     UDP_MIB_SNDBUFERRORS, is_udplite);
+                       UDP_INC_STATS(sock_net(sk), UDP_MIB_SNDBUFERRORS);
                        err = 0;
                }
-       } else
-               UDP_INC_STATS(sock_net(sk),
-                             UDP_MIB_OUTDATAGRAMS, is_udplite);
+       } else {
+               UDP_INC_STATS(sock_net(sk), UDP_MIB_OUTDATAGRAMS);
+       }
        return err;
 }
 
@@ -1535,10 +1534,9 @@ out_free:
         * things).  We could add another new stat but at least for now that
         * seems like overkill.
         */
-       if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
-               UDP_INC_STATS(sock_net(sk),
-                             UDP_MIB_SNDBUFERRORS, is_udplite);
-       }
+       if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
+               UDP_INC_STATS(sock_net(sk), UDP_MIB_SNDBUFERRORS);
+
        return err;
 
 do_confirm:
@@ -1897,10 +1895,10 @@ static struct sk_buff *__first_packet_length(struct sock *sk,
 
        while ((skb = skb_peek(rcvq)) != NULL) {
                if (udp_lib_checksum_complete(skb)) {
-                       __UDP_INC_STATS(sock_net(sk), UDP_MIB_CSUMERRORS,
-                                       IS_UDPLITE(sk));
-                       __UDP_INC_STATS(sock_net(sk), UDP_MIB_INERRORS,
-                                       IS_UDPLITE(sk));
+                       struct net *net = sock_net(sk);
+
+                       __UDP_INC_STATS(net, UDP_MIB_CSUMERRORS);
+                       __UDP_INC_STATS(net, UDP_MIB_INERRORS);
                        udp_drops_inc(sk);
                        __skb_unlink(skb, rcvq);
                        *total += skb->truesize;
@@ -2052,11 +2050,10 @@ try_again:
                return err;
 
        if (udp_lib_checksum_complete(skb)) {
-               int is_udplite = IS_UDPLITE(sk);
                struct net *net = sock_net(sk);
 
-               __UDP_INC_STATS(net, UDP_MIB_CSUMERRORS, is_udplite);
-               __UDP_INC_STATS(net, UDP_MIB_INERRORS, is_udplite);
+               __UDP_INC_STATS(net, UDP_MIB_CSUMERRORS);
+               __UDP_INC_STATS(net, UDP_MIB_INERRORS);
                udp_drops_inc(sk);
                kfree_skb_reason(skb, SKB_DROP_REASON_UDP_CSUM);
                goto try_again;
@@ -2081,6 +2078,7 @@ int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags)
        unsigned int ulen, copied;
        int off, err, peeking = flags & MSG_PEEK;
        int is_udplite = IS_UDPLITE(sk);
+       struct net *net = sock_net(sk);
        bool checksum_valid = false;
 
        if (flags & MSG_ERRQUEUE)
@@ -2128,16 +2126,14 @@ try_again:
        if (unlikely(err)) {
                if (!peeking) {
                        udp_drops_inc(sk);
-                       UDP_INC_STATS(sock_net(sk),
-                                     UDP_MIB_INERRORS, is_udplite);
+                       UDP_INC_STATS(net, UDP_MIB_INERRORS);
                }
                kfree_skb(skb);
                return err;
        }
 
        if (!peeking)
-               UDP_INC_STATS(sock_net(sk),
-                             UDP_MIB_INDATAGRAMS, is_udplite);
+               UDP_INC_STATS(net, UDP_MIB_INDATAGRAMS);
 
        sock_recv_cmsgs(msg, sk, skb);
 
@@ -2170,8 +2166,8 @@ try_again:
 csum_copy_err:
        if (!__sk_queue_drop_skb(sk, &udp_sk(sk)->reader_queue, skb, flags,
                                 udp_skb_destructor)) {
-               UDP_INC_STATS(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
-               UDP_INC_STATS(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
+               UDP_INC_STATS(net, UDP_MIB_CSUMERRORS);
+               UDP_INC_STATS(net, UDP_MIB_INERRORS);
        }
        kfree_skb_reason(skb, SKB_DROP_REASON_UDP_CSUM);
 
@@ -2371,20 +2367,18 @@ static int __udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
 
        rc = __udp_enqueue_schedule_skb(sk, skb);
        if (rc < 0) {
-               int is_udplite = IS_UDPLITE(sk);
+               struct net *net = sock_net(sk);
                int drop_reason;
 
                /* Note that an ENOMEM error is charged twice */
                if (rc == -ENOMEM) {
-                       UDP_INC_STATS(sock_net(sk), UDP_MIB_RCVBUFERRORS,
-                                       is_udplite);
+                       UDP_INC_STATS(net, UDP_MIB_RCVBUFERRORS);
                        drop_reason = SKB_DROP_REASON_SOCKET_RCVBUFF;
                } else {
-                       UDP_INC_STATS(sock_net(sk), UDP_MIB_MEMERRORS,
-                                     is_udplite);
+                       UDP_INC_STATS(net, UDP_MIB_MEMERRORS);
                        drop_reason = SKB_DROP_REASON_PROTO_MEM;
                }
-               UDP_INC_STATS(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
+               UDP_INC_STATS(net, UDP_MIB_INERRORS);
                trace_udp_fail_queue_rcv_skb(rc, sk, skb);
                sk_skb_reason_drop(sk, skb, drop_reason);
                return -1;
@@ -2405,7 +2399,7 @@ static int udp_queue_rcv_one_skb(struct sock *sk, struct sk_buff *skb)
 {
        enum skb_drop_reason drop_reason = SKB_DROP_REASON_NOT_SPECIFIED;
        struct udp_sock *up = udp_sk(sk);
-       int is_udplite = IS_UDPLITE(sk);
+       struct net *net = sock_net(sk);
 
        /*
         *      Charge it to the socket, dropping if the queue is full.
@@ -2442,9 +2436,7 @@ static int udp_queue_rcv_one_skb(struct sock *sk, struct sk_buff *skb)
 
                        ret = encap_rcv(sk, skb);
                        if (ret <= 0) {
-                               __UDP_INC_STATS(sock_net(sk),
-                                               UDP_MIB_INDATAGRAMS,
-                                               is_udplite);
+                               __UDP_INC_STATS(net, UDP_MIB_INDATAGRAMS);
                                return -ret;
                        }
                }
@@ -2503,9 +2495,9 @@ static int udp_queue_rcv_one_skb(struct sock *sk, struct sk_buff *skb)
 
 csum_error:
        drop_reason = SKB_DROP_REASON_UDP_CSUM;
-       __UDP_INC_STATS(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
+       __UDP_INC_STATS(net, UDP_MIB_CSUMERRORS);
 drop:
-       __UDP_INC_STATS(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
+       __UDP_INC_STATS(net, UDP_MIB_INERRORS);
        udp_drops_inc(sk);
        sk_skb_reason_drop(sk, skb, drop_reason);
        return -1;
@@ -2592,10 +2584,8 @@ start_lookup:
 
                if (unlikely(!nskb)) {
                        udp_drops_inc(sk);
-                       __UDP_INC_STATS(net, UDP_MIB_RCVBUFERRORS,
-                                       IS_UDPLITE(sk));
-                       __UDP_INC_STATS(net, UDP_MIB_INERRORS,
-                                       IS_UDPLITE(sk));
+                       __UDP_INC_STATS(net, UDP_MIB_RCVBUFERRORS);
+                       __UDP_INC_STATS(net, UDP_MIB_INERRORS);
                        continue;
                }
                if (udp_queue_rcv_skb(sk, nskb) > 0)
@@ -2613,8 +2603,7 @@ start_lookup:
                        consume_skb(skb);
        } else {
                kfree_skb(skb);
-               __UDP_INC_STATS(net, UDP_MIB_IGNOREDMULTI,
-                               proto == IPPROTO_UDPLITE);
+               __UDP_INC_STATS(net, UDP_MIB_IGNOREDMULTI);
        }
        return 0;
 }
@@ -2764,7 +2753,7 @@ no_sk:
                goto csum_error;
 
        drop_reason = SKB_DROP_REASON_NO_SOCKET;
-       __UDP_INC_STATS(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
+       __UDP_INC_STATS(net, UDP_MIB_NOPORTS);
        icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
 
        /*
@@ -2793,9 +2782,9 @@ csum_error:
                            proto == IPPROTO_UDPLITE ? "Lite" : "",
                            &saddr, ntohs(uh->source), &daddr, ntohs(uh->dest),
                            ulen);
-       __UDP_INC_STATS(net, UDP_MIB_CSUMERRORS, proto == IPPROTO_UDPLITE);
+       __UDP_INC_STATS(net, UDP_MIB_CSUMERRORS);
 drop:
-       __UDP_INC_STATS(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
+       __UDP_INC_STATS(net, UDP_MIB_INERRORS);
        sk_skb_reason_drop(sk, skb, drop_reason);
        return 0;
 }

diff --git a/net/ipv6/af_inet6.c b/net/ipv6/af_inet6.c
index 61f7bc88526a16d2feb79a702f8fed9f351c2204..eb9fff86baa1162f214ee088f4b6cf0b8f5839aa 100644 (file)
--- a/net/ipv6/af_inet6.c
+++ b/net/ipv6/af_inet6.c
@@ -886,9 +886,7 @@ static int __net_init ipv6_init_mibs(struct net *net)
        net->mib.udp_stats_in6 = alloc_percpu(struct udp_mib);
        if (!net->mib.udp_stats_in6)
                return -ENOMEM;
-       net->mib.udplite_stats_in6 = alloc_percpu(struct udp_mib);
-       if (!net->mib.udplite_stats_in6)
-               goto err_udplite_mib;
+
        net->mib.ipv6_statistics = alloc_percpu(struct ipstats_mib);
        if (!net->mib.ipv6_statistics)
                goto err_ip_mib;
@@ -899,10 +897,10 @@ static int __net_init ipv6_init_mibs(struct net *net)
                u64_stats_init(&af_inet6_stats->syncp);
        }
 
-
        net->mib.icmpv6_statistics = alloc_percpu(struct icmpv6_mib);
        if (!net->mib.icmpv6_statistics)
                goto err_icmp_mib;
+
        net->mib.icmpv6msg_statistics = kzalloc_obj(struct icmpv6msg_mib);
        if (!net->mib.icmpv6msg_statistics)
                goto err_icmpmsg_mib;
@@ -913,8 +911,6 @@ err_icmpmsg_mib:
 err_icmp_mib:
        free_percpu(net->mib.ipv6_statistics);
 err_ip_mib:
-       free_percpu(net->mib.udplite_stats_in6);
-err_udplite_mib:
        free_percpu(net->mib.udp_stats_in6);
        return -ENOMEM;
 }
@@ -922,7 +918,6 @@ err_udplite_mib:
 static void ipv6_cleanup_mibs(struct net *net)
 {
        free_percpu(net->mib.udp_stats_in6);
-       free_percpu(net->mib.udplite_stats_in6);
        free_percpu(net->mib.ipv6_statistics);
        free_percpu(net->mib.icmpv6_statistics);
        kfree(net->mib.icmpv6msg_statistics);

diff --git a/net/ipv6/proc.c b/net/ipv6/proc.c
index 21bfc73152f0aa3fee18572adf37f1ed520a7942..813013ca4e750c43ee9b2a437409481d5d0051e6 100644 (file)
--- a/net/ipv6/proc.c
+++ b/net/ipv6/proc.c
@@ -108,17 +108,6 @@ static const struct snmp_mib snmp6_udp6_list[] = {
        SNMP_MIB_ITEM("Udp6MemErrors", UDP_MIB_MEMERRORS),
 };
 
-static const struct snmp_mib snmp6_udplite6_list[] = {
-       SNMP_MIB_ITEM("UdpLite6InDatagrams", UDP_MIB_INDATAGRAMS),
-       SNMP_MIB_ITEM("UdpLite6NoPorts", UDP_MIB_NOPORTS),
-       SNMP_MIB_ITEM("UdpLite6InErrors", UDP_MIB_INERRORS),
-       SNMP_MIB_ITEM("UdpLite6OutDatagrams", UDP_MIB_OUTDATAGRAMS),
-       SNMP_MIB_ITEM("UdpLite6RcvbufErrors", UDP_MIB_RCVBUFERRORS),
-       SNMP_MIB_ITEM("UdpLite6SndbufErrors", UDP_MIB_SNDBUFERRORS),
-       SNMP_MIB_ITEM("UdpLite6InCsumErrors", UDP_MIB_CSUMERRORS),
-       SNMP_MIB_ITEM("UdpLite6MemErrors", UDP_MIB_MEMERRORS),
-};
-
 static void snmp6_seq_show_icmpv6msg(struct seq_file *seq, atomic_long_t *smib)
 {
        char name[32];
@@ -226,9 +215,6 @@ static int snmp6_seq_show(struct seq_file *seq, void *v)
        snmp6_seq_show_item(seq, net->mib.udp_stats_in6,
                            NULL, snmp6_udp6_list,
                            ARRAY_SIZE(snmp6_udp6_list));
-       snmp6_seq_show_item(seq, net->mib.udplite_stats_in6,
-                           NULL, snmp6_udplite6_list,
-                           ARRAY_SIZE(snmp6_udplite6_list));
        return 0;
 }
 

diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index aa859bb0527de07ff00f726fa9d0e0768d687533..07308b7156a688ac216672ee2a5999e6387f6f6b 100644 (file)
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -796,20 +796,18 @@ static int __udpv6_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
 
        rc = __udp_enqueue_schedule_skb(sk, skb);
        if (rc < 0) {
-               int is_udplite = IS_UDPLITE(sk);
                enum skb_drop_reason drop_reason;
+               struct net *net = sock_net(sk);
 
                /* Note that an ENOMEM error is charged twice */
                if (rc == -ENOMEM) {
-                       UDP6_INC_STATS(sock_net(sk),
-                                        UDP_MIB_RCVBUFERRORS, is_udplite);
+                       UDP6_INC_STATS(net, UDP_MIB_RCVBUFERRORS);
                        drop_reason = SKB_DROP_REASON_SOCKET_RCVBUFF;
                } else {
-                       UDP6_INC_STATS(sock_net(sk),
-                                      UDP_MIB_MEMERRORS, is_udplite);
+                       UDP6_INC_STATS(net, UDP_MIB_MEMERRORS);
                        drop_reason = SKB_DROP_REASON_PROTO_MEM;
                }
-               UDP6_INC_STATS(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
+               UDP6_INC_STATS(net, UDP_MIB_INERRORS);
                trace_udp_fail_queue_rcv_skb(rc, sk, skb);
                sk_skb_reason_drop(sk, skb, drop_reason);
                return -1;
@@ -830,7 +828,7 @@ static int udpv6_queue_rcv_one_skb(struct sock *sk, struct sk_buff *skb)
 {
        enum skb_drop_reason drop_reason = SKB_DROP_REASON_NOT_SPECIFIED;
        struct udp_sock *up = udp_sk(sk);
-       int is_udplite = IS_UDPLITE(sk);
+       struct net *net = sock_net(sk);
 
        if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb)) {
                drop_reason = SKB_DROP_REASON_XFRM_POLICY;
@@ -864,9 +862,7 @@ static int udpv6_queue_rcv_one_skb(struct sock *sk, struct sk_buff *skb)
 
                        ret = encap_rcv(sk, skb);
                        if (ret <= 0) {
-                               __UDP6_INC_STATS(sock_net(sk),
-                                                UDP_MIB_INDATAGRAMS,
-                                                is_udplite);
+                               __UDP6_INC_STATS(net, UDP_MIB_INDATAGRAMS);
                                return -ret;
                        }
                }
@@ -909,9 +905,9 @@ static int udpv6_queue_rcv_one_skb(struct sock *sk, struct sk_buff *skb)
 
 csum_error:
        drop_reason = SKB_DROP_REASON_UDP_CSUM;
-       __UDP6_INC_STATS(sock_net(sk), UDP_MIB_CSUMERRORS, is_udplite);
+       __UDP6_INC_STATS(net, UDP_MIB_CSUMERRORS);
 drop:
-       __UDP6_INC_STATS(sock_net(sk), UDP_MIB_INERRORS, is_udplite);
+       __UDP6_INC_STATS(net, UDP_MIB_INERRORS);
        udp_drops_inc(sk);
        sk_skb_reason_drop(sk, skb, drop_reason);
        return -1;
@@ -1018,10 +1014,8 @@ start_lookup:
                nskb = skb_clone(skb, GFP_ATOMIC);
                if (unlikely(!nskb)) {
                        udp_drops_inc(sk);
-                       __UDP6_INC_STATS(net, UDP_MIB_RCVBUFERRORS,
-                                        IS_UDPLITE(sk));
-                       __UDP6_INC_STATS(net, UDP_MIB_INERRORS,
-                                        IS_UDPLITE(sk));
+                       __UDP6_INC_STATS(net, UDP_MIB_RCVBUFERRORS);
+                       __UDP6_INC_STATS(net, UDP_MIB_INERRORS);
                        continue;
                }
 
@@ -1040,8 +1034,7 @@ start_lookup:
                        consume_skb(skb);
        } else {
                kfree_skb(skb);
-               __UDP6_INC_STATS(net, UDP_MIB_IGNOREDMULTI,
-                                proto == IPPROTO_UDPLITE);
+               __UDP6_INC_STATS(net, UDP_MIB_IGNOREDMULTI);
        }
        return 0;
 }
@@ -1213,7 +1206,7 @@ no_sk:
        if (udp_lib_checksum_complete(skb))
                goto csum_error;
 
-       __UDP6_INC_STATS(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
+       __UDP6_INC_STATS(net, UDP_MIB_NOPORTS);
        icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
 
        sk_skb_reason_drop(sk, skb, reason);
@@ -1234,9 +1227,9 @@ report_csum_error:
 csum_error:
        if (reason == SKB_DROP_REASON_NOT_SPECIFIED)
                reason = SKB_DROP_REASON_UDP_CSUM;
-       __UDP6_INC_STATS(net, UDP_MIB_CSUMERRORS, proto == IPPROTO_UDPLITE);
+       __UDP6_INC_STATS(net, UDP_MIB_CSUMERRORS);
 discard:
-       __UDP6_INC_STATS(net, UDP_MIB_INERRORS, proto == IPPROTO_UDPLITE);
+       __UDP6_INC_STATS(net, UDP_MIB_INERRORS);
        sk_skb_reason_drop(sk, skb, reason);
        return 0;
 }
@@ -1490,13 +1483,11 @@ send:
        err = ip6_send_skb(skb);
        if (unlikely(err)) {
                if (err == -ENOBUFS && !inet6_test_bit(RECVERR6, sk)) {
-                       UDP6_INC_STATS(sock_net(sk),
-                                      UDP_MIB_SNDBUFERRORS, is_udplite);
+                       UDP6_INC_STATS(sock_net(sk), UDP_MIB_SNDBUFERRORS);
                        err = 0;
                }
        } else {
-               UDP6_INC_STATS(sock_net(sk),
-                              UDP_MIB_OUTDATAGRAMS, is_udplite);
+               UDP6_INC_STATS(sock_net(sk), UDP_MIB_OUTDATAGRAMS);
        }
        return err;
 }
@@ -1826,10 +1817,9 @@ out_no_dst:
         * things).  We could add another new stat but at least for now that
         * seems like overkill.
         */
-       if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
-               UDP6_INC_STATS(sock_net(sk),
-                              UDP_MIB_SNDBUFERRORS, is_udplite);
-       }
+       if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
+               UDP6_INC_STATS(sock_net(sk), UDP_MIB_SNDBUFERRORS);
+
        return err;
 
 do_confirm: