superrob1500
/
mirror-linux
mirror of https://github.com/torvalds/linux
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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>
master
Kuniyuki Iwashima 2026-03-11 05:19:52 +00:00 committed by Jakub Kicinski
parent 56520b398e
commit 7accba6fd1
8 changed files with 71 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/net/netns/mib.h
View File

@ -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)

46
include/net/udp.h
View File

@ -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) \

6
net/ipv4/af_inet.c
View File

@ -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);

13
net/ipv4/proc.c
View File

@ -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;
}

75
net/ipv4/udp.c
View File

@ -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;
}

9
net/ipv6/af_inet6.c
View File

@ -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);

14
net/ipv6/proc.c
View File

@ -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;
}

48
net/ipv6/udp.c
View File

@ -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: