tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

net: remove addr_len argument of recvmsg() handlers

Use msg->msg_namelen as a place holder instead of a
temporary variable, notably in inet[6]_recvmsg().

This removes stack canaries and allows tail-calls.

$ scripts/bloat-o-meter -t vmlinux.old vmlinux
add/remove: 0/0 grow/shrink: 2/19 up/down: 26/-532 (-506)
Function old new delta
rawv6_recvmsg 744 767 +23
vsock_dgram_recvmsg 55 58 +3
vsock_connectible_recvmsg 50 47 -3
unix_stream_recvmsg 161 158 -3
unix_seqpacket_recvmsg 62 59 -3
unix_dgram_recvmsg 42 39 -3
tcp_recvmsg 546 543 -3
mptcp_recvmsg 1568 1565 -3
ping_recvmsg 806 800 -6
tcp_bpf_recvmsg_parser 983 974 -9
ip_recv_error 588 576 -12
ipv6_recv_rxpmtu 442 428 -14
udp_recvmsg 1243 1224 -19
ipv6_recv_error 1046 1024 -22
udpv6_recvmsg 1487 1461 -26
raw_recvmsg 465 437 -28
udp_bpf_recvmsg 1027 984 -43
sock_common_recvmsg 103 27 -76
inet_recvmsg 257 175 -82
inet6_recvmsg 257 175 -82
tcp_bpf_recvmsg 663 568 -95
Total: Before=25143834, After=25143328, chg -0.00%

Signed-off-by: Eric Dumazet <edumazet@google.com>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Link: https://patch.msgid.link/20260227151120.1346573-1-edumazet@google.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

authored by

Eric Dumazet and committed by
Jakub Kicinski 8341c989 f5ada26d

+99 -127
+1 -1
drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls.h
··· 567 567 void chtls_destroy_sock(struct sock *sk); 568 568 int chtls_sendmsg(struct sock *sk, struct msghdr *msg, size_t size); 569 569 int chtls_recvmsg(struct sock *sk, struct msghdr *msg, 570 - size_t len, int flags, int *addr_len); 570 + size_t len, int flags); 571 571 void chtls_splice_eof(struct socket *sock); 572 572 int send_tx_flowc_wr(struct sock *sk, int compl, 573 573 u32 snd_nxt, u32 rcv_nxt);
+4 -4
drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c
··· 1332 1332 } 1333 1333 1334 1334 static int chtls_pt_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 1335 - int flags, int *addr_len) 1335 + int flags) 1336 1336 { 1337 1337 struct chtls_sock *csk = rcu_dereference_sk_user_data(sk); 1338 1338 struct chtls_hws *hws = &csk->tlshws; ··· 1656 1656 } 1657 1657 1658 1658 int chtls_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 1659 - int flags, int *addr_len) 1659 + int flags) 1660 1660 { 1661 1661 struct tcp_sock *tp = tcp_sk(sk); 1662 1662 struct chtls_sock *csk; ··· 1670 1670 buffers_freed = 0; 1671 1671 1672 1672 if (unlikely(flags & MSG_OOB)) 1673 - return tcp_prot.recvmsg(sk, msg, len, flags, addr_len); 1673 + return tcp_prot.recvmsg(sk, msg, len, flags); 1674 1674 1675 1675 if (unlikely(flags & MSG_PEEK)) 1676 1676 return peekmsg(sk, msg, len, flags); ··· 1684 1684 csk = rcu_dereference_sk_user_data(sk); 1685 1685 1686 1686 if (is_tls_rx(csk)) 1687 - return chtls_pt_recvmsg(sk, msg, len, flags, addr_len); 1687 + return chtls_pt_recvmsg(sk, msg, len, flags); 1688 1688 1689 1689 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 1690 1690 target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
+1 -1
drivers/net/ovpn/tcp.c
··· 158 158 } 159 159 160 160 static int ovpn_tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 161 - int flags, int *addr_len) 161 + int flags) 162 162 { 163 163 int err = 0, off, copied = 0, ret; 164 164 struct ovpn_socket *sock;
+1 -2
include/net/inet_common.h
··· 59 59 int inet_ctl_sock_create(struct sock **sk, unsigned short family, 60 60 unsigned short type, unsigned char protocol, 61 61 struct net *net); 62 - int inet_recv_error(struct sock *sk, struct msghdr *msg, int len, 63 - int *addr_len); 62 + int inet_recv_error(struct sock *sk, struct msghdr *msg, int len); 64 63 65 64 struct sk_buff *inet_gro_receive(struct list_head *head, struct sk_buff *skb); 66 65 int inet_gro_complete(struct sk_buff *skb, int nhoff);
+1 -1
include/net/ip.h
··· 812 812 int ip_ra_control(struct sock *sk, unsigned char on, 813 813 void (*destructor)(struct sock *)); 814 814 815 - int ip_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len); 815 + int ip_recv_error(struct sock *sk, struct msghdr *msg, int len); 816 816 void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err, __be16 port, 817 817 u32 info, u8 *payload); 818 818 void ip_local_error(struct sock *sk, int err, __be32 daddr, __be16 dport,
+2 -4
include/net/ipv6.h
··· 1129 1129 int ip6_datagram_dst_update(struct sock *sk, bool fix_sk_saddr); 1130 1130 void ip6_datagram_release_cb(struct sock *sk); 1131 1131 1132 - int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len, 1133 - int *addr_len); 1134 - int ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len, 1135 - int *addr_len); 1132 + int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len); 1133 + int ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len); 1136 1134 void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err, __be16 port, 1137 1135 u32 info, u8 *payload); 1138 1136 void ipv6_local_error(struct sock *sk, int err, struct flowi6 *fl6, u32 info);
+2 -3
include/net/ping.h
··· 20 20 21 21 /* Compatibility glue so we can support IPv6 when it's compiled as a module */ 22 22 struct pingv6_ops { 23 - int (*ipv6_recv_error)(struct sock *sk, struct msghdr *msg, int len, 24 - int *addr_len); 23 + int (*ipv6_recv_error)(struct sock *sk, struct msghdr *msg, int len); 25 24 void (*ip6_datagram_recv_common_ctl)(struct sock *sk, 26 25 struct msghdr *msg, 27 26 struct sk_buff *skb); ··· 63 64 struct sk_buff *); 64 65 65 66 int ping_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 66 - int flags, int *addr_len); 67 + int flags); 67 68 int ping_common_sendmsg(int family, struct msghdr *msg, size_t len, 68 69 void *user_icmph, size_t icmph_len); 69 70 int ping_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
+1 -1
include/net/sock.h
··· 1321 1321 int (*sendmsg)(struct sock *sk, struct msghdr *msg, 1322 1322 size_t len); 1323 1323 int (*recvmsg)(struct sock *sk, struct msghdr *msg, 1324 - size_t len, int flags, int *addr_len); 1324 + size_t len, int flags); 1325 1325 void (*splice_eof)(struct socket *sock); 1326 1326 int (*bind)(struct sock *sk, 1327 1327 struct sockaddr_unsized *addr, int addr_len);
+1 -1
include/net/tcp.h
··· 500 500 void tcp_set_keepalive(struct sock *sk, int val); 501 501 void tcp_syn_ack_timeout(const struct request_sock *req); 502 502 int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 503 - int flags, int *addr_len); 503 + int flags); 504 504 int tcp_set_rcvlowat(struct sock *sk, int val); 505 505 int tcp_set_window_clamp(struct sock *sk, int val); 506 506 void tcp_update_recv_tstamps(struct sk_buff *skb,
+1 -6
net/core/sock.c
··· 3967 3967 int flags) 3968 3968 { 3969 3969 struct sock *sk = sock->sk; 3970 - int addr_len = 0; 3971 - int err; 3972 3970 3973 - err = sk->sk_prot->recvmsg(sk, msg, size, flags, &addr_len); 3974 - if (err >= 0) 3975 - msg->msg_namelen = addr_len; 3976 - return err; 3971 + return sk->sk_prot->recvmsg(sk, msg, size, flags); 3977 3972 } 3978 3973 EXPORT_SYMBOL(sock_common_recvmsg); 3979 3974
+3 -3
net/ieee802154/socket.c
··· 313 313 } 314 314 315 315 static int raw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 316 - int flags, int *addr_len) 316 + int flags) 317 317 { 318 318 size_t copied = 0; 319 319 int err = -EOPNOTSUPP; ··· 703 703 } 704 704 705 705 static int dgram_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 706 - int flags, int *addr_len) 706 + int flags) 707 707 { 708 708 size_t copied = 0; 709 709 int err = -EOPNOTSUPP; ··· 737 737 738 738 saddr->family = AF_IEEE802154; 739 739 ieee802154_addr_to_sa(&saddr->addr, &mac_cb(skb)->source); 740 - *addr_len = sizeof(*saddr); 740 + msg->msg_namelen = sizeof(*saddr); 741 741 } 742 742 743 743 if (ro->want_lqi) {
+6 -11
net/ipv4/af_inet.c
··· 877 877 EXPORT_SYMBOL_GPL(inet_splice_eof); 878 878 879 879 INDIRECT_CALLABLE_DECLARE(int udp_recvmsg(struct sock *, struct msghdr *, 880 - size_t, int, int *)); 880 + size_t, int)); 881 881 int inet_recvmsg(struct socket *sock, struct msghdr *msg, size_t size, 882 882 int flags) 883 883 { 884 884 struct sock *sk = sock->sk; 885 - int addr_len = 0; 886 - int err; 887 885 888 886 if (likely(!(flags & MSG_ERRQUEUE))) 889 887 sock_rps_record_flow(sk); 890 888 891 - err = INDIRECT_CALL_2(sk->sk_prot->recvmsg, tcp_recvmsg, udp_recvmsg, 892 - sk, msg, size, flags, &addr_len); 893 - if (err >= 0) 894 - msg->msg_namelen = addr_len; 895 - return err; 889 + return INDIRECT_CALL_2(sk->sk_prot->recvmsg, tcp_recvmsg, udp_recvmsg, 890 + sk, msg, size, flags); 896 891 } 897 892 EXPORT_SYMBOL(inet_recvmsg); 898 893 ··· 1572 1577 } 1573 1578 EXPORT_SYMBOL(inet_current_timestamp); 1574 1579 1575 - int inet_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len) 1580 + int inet_recv_error(struct sock *sk, struct msghdr *msg, int len) 1576 1581 { 1577 1582 unsigned int family = READ_ONCE(sk->sk_family); 1578 1583 1579 1584 if (family == AF_INET) 1580 - return ip_recv_error(sk, msg, len, addr_len); 1585 + return ip_recv_error(sk, msg, len); 1581 1586 #if IS_ENABLED(CONFIG_IPV6) 1582 1587 if (family == AF_INET6) 1583 - return pingv6_ops.ipv6_recv_error(sk, msg, len, addr_len); 1588 + return pingv6_ops.ipv6_recv_error(sk, msg, len); 1584 1589 #endif 1585 1590 return -EINVAL; 1586 1591 }
+2 -2
net/ipv4/ip_sockglue.c
··· 520 520 /* 521 521 * Handle MSG_ERRQUEUE 522 522 */ 523 - int ip_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len) 523 + int ip_recv_error(struct sock *sk, struct msghdr *msg, int len) 524 524 { 525 525 struct sock_exterr_skb *serr; 526 526 struct sk_buff *skb; ··· 557 557 serr->addr_offset); 558 558 sin->sin_port = serr->port; 559 559 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero)); 560 - *addr_len = sizeof(*sin); 560 + msg->msg_namelen = sizeof(*sin); 561 561 } 562 562 563 563 memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
+4 -5
net/ipv4/ping.c
··· 848 848 goto out; 849 849 } 850 850 851 - int ping_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 852 - int *addr_len) 851 + int ping_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags) 853 852 { 854 853 struct inet_sock *isk = inet_sk(sk); 855 854 int family = sk->sk_family; ··· 863 864 goto out; 864 865 865 866 if (flags & MSG_ERRQUEUE) 866 - return inet_recv_error(sk, msg, len, addr_len); 867 + return inet_recv_error(sk, msg, len); 867 868 868 869 skb = skb_recv_datagram(sk, flags, &err); 869 870 if (!skb) ··· 891 892 sin->sin_port = 0 /* skb->h.uh->source */; 892 893 sin->sin_addr.s_addr = ip_hdr(skb)->saddr; 893 894 memset(sin->sin_zero, 0, sizeof(sin->sin_zero)); 894 - *addr_len = sizeof(*sin); 895 + msg->msg_namelen = sizeof(*sin); 895 896 } 896 897 897 898 if (inet_cmsg_flags(isk)) ··· 912 913 sin6->sin6_scope_id = 913 914 ipv6_iface_scope_id(&sin6->sin6_addr, 914 915 inet6_iif(skb)); 915 - *addr_len = sizeof(*sin6); 916 + msg->msg_namelen = sizeof(*sin6); 916 917 } 917 918 918 919 if (inet6_sk(sk)->rxopt.all)
+3 -3
net/ipv4/raw.c
··· 739 739 */ 740 740 741 741 static int raw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 742 - int flags, int *addr_len) 742 + int flags) 743 743 { 744 744 struct inet_sock *inet = inet_sk(sk); 745 745 size_t copied = 0; ··· 751 751 goto out; 752 752 753 753 if (flags & MSG_ERRQUEUE) { 754 - err = ip_recv_error(sk, msg, len, addr_len); 754 + err = ip_recv_error(sk, msg, len); 755 755 goto out; 756 756 } 757 757 ··· 777 777 sin->sin_addr.s_addr = ip_hdr(skb)->saddr; 778 778 sin->sin_port = 0; 779 779 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero)); 780 - *addr_len = sizeof(*sin); 780 + msg->msg_namelen = sizeof(*sin); 781 781 } 782 782 if (inet_cmsg_flags(inet)) 783 783 ip_cmsg_recv(msg, skb);
+2 -3
net/ipv4/tcp.c
··· 2961 2961 goto out; 2962 2962 } 2963 2963 2964 - int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 2965 - int *addr_len) 2964 + int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags) 2966 2965 { 2967 2966 int cmsg_flags = 0, ret; 2968 2967 struct scm_timestamping_internal tss; 2969 2968 2970 2969 if (unlikely(flags & MSG_ERRQUEUE)) 2971 - return inet_recv_error(sk, msg, len, addr_len); 2970 + return inet_recv_error(sk, msg, len); 2972 2971 2973 2972 if (sk_can_busy_loop(sk) && 2974 2973 skb_queue_empty_lockless(&sk->sk_receive_queue) &&
+8 -9
net/ipv4/tcp_bpf.c
··· 221 221 static int tcp_bpf_recvmsg_parser(struct sock *sk, 222 222 struct msghdr *msg, 223 223 size_t len, 224 - int flags, 225 - int *addr_len) 224 + int flags) 226 225 { 227 226 int peek = flags & MSG_PEEK; 228 227 struct sk_psock *psock; ··· 231 232 u32 seq; 232 233 233 234 if (unlikely(flags & MSG_ERRQUEUE)) 234 - return inet_recv_error(sk, msg, len, addr_len); 235 + return inet_recv_error(sk, msg, len); 235 236 236 237 if (!len) 237 238 return 0; 238 239 239 240 psock = sk_psock_get(sk); 240 241 if (unlikely(!psock)) 241 - return tcp_recvmsg(sk, msg, len, flags, addr_len); 242 + return tcp_recvmsg(sk, msg, len, flags); 242 243 243 244 lock_sock(sk); 244 245 tcp = tcp_sk(sk); ··· 351 352 } 352 353 353 354 static int tcp_bpf_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 354 - int flags, int *addr_len) 355 + int flags) 355 356 { 356 357 struct sk_psock *psock; 357 358 int copied, ret; 358 359 359 360 if (unlikely(flags & MSG_ERRQUEUE)) 360 - return inet_recv_error(sk, msg, len, addr_len); 361 + return inet_recv_error(sk, msg, len); 361 362 362 363 if (!len) 363 364 return 0; 364 365 365 366 psock = sk_psock_get(sk); 366 367 if (unlikely(!psock)) 367 - return tcp_recvmsg(sk, msg, len, flags, addr_len); 368 + return tcp_recvmsg(sk, msg, len, flags); 368 369 if (!skb_queue_empty(&sk->sk_receive_queue) && 369 370 sk_psock_queue_empty(psock)) { 370 371 sk_psock_put(sk, psock); 371 - return tcp_recvmsg(sk, msg, len, flags, addr_len); 372 + return tcp_recvmsg(sk, msg, len, flags); 372 373 } 373 374 lock_sock(sk); 374 375 msg_bytes_ready: ··· 388 389 goto msg_bytes_ready; 389 390 release_sock(sk); 390 391 sk_psock_put(sk, psock); 391 - return tcp_recvmsg(sk, msg, len, flags, addr_len); 392 + return tcp_recvmsg(sk, msg, len, flags); 392 393 } 393 394 copied = -EAGAIN; 394 395 }
+4 -5
net/ipv4/udp.c
··· 2070 2070 * return it, otherwise we block. 2071 2071 */ 2072 2072 2073 - int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 2074 - int *addr_len) 2073 + int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags) 2075 2074 { 2076 2075 struct inet_sock *inet = inet_sk(sk); 2077 2076 DECLARE_SOCKADDR(struct sockaddr_in *, sin, msg->msg_name); ··· 2081 2082 bool checksum_valid = false; 2082 2083 2083 2084 if (flags & MSG_ERRQUEUE) 2084 - return ip_recv_error(sk, msg, len, addr_len); 2085 + return ip_recv_error(sk, msg, len); 2085 2086 2086 2087 try_again: 2087 2088 off = sk_peek_offset(sk, flags); ··· 2144 2145 sin->sin_port = udp_hdr(skb)->source; 2145 2146 sin->sin_addr.s_addr = ip_hdr(skb)->saddr; 2146 2147 memset(sin->sin_zero, 0, sizeof(sin->sin_zero)); 2147 - *addr_len = sizeof(*sin); 2148 + msg->msg_namelen = sizeof(*sin); 2148 2149 2149 2150 BPF_CGROUP_RUN_PROG_UDP4_RECVMSG_LOCK(sk, 2150 2151 (struct sockaddr *)sin, 2151 - addr_len); 2152 + &msg->msg_namelen); 2152 2153 } 2153 2154 2154 2155 if (udp_test_bit(GRO_ENABLED, sk))
+8 -8
net/ipv4/udp_bpf.c
··· 12 12 static struct proto *udpv6_prot_saved __read_mostly; 13 13 14 14 static int sk_udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 15 - int flags, int *addr_len) 15 + int flags) 16 16 { 17 17 #if IS_ENABLED(CONFIG_IPV6) 18 18 if (sk->sk_family == AF_INET6) 19 - return udpv6_prot_saved->recvmsg(sk, msg, len, flags, addr_len); 19 + return udpv6_prot_saved->recvmsg(sk, msg, len, flags); 20 20 #endif 21 - return udp_prot.recvmsg(sk, msg, len, flags, addr_len); 21 + return udp_prot.recvmsg(sk, msg, len, flags); 22 22 } 23 23 24 24 static bool udp_sk_has_data(struct sock *sk) ··· 61 61 } 62 62 63 63 static int udp_bpf_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 64 - int flags, int *addr_len) 64 + int flags) 65 65 { 66 66 struct sk_psock *psock; 67 67 int copied, ret; 68 68 69 69 if (unlikely(flags & MSG_ERRQUEUE)) 70 - return inet_recv_error(sk, msg, len, addr_len); 70 + return inet_recv_error(sk, msg, len); 71 71 72 72 if (!len) 73 73 return 0; 74 74 75 75 psock = sk_psock_get(sk); 76 76 if (unlikely(!psock)) 77 - return sk_udp_recvmsg(sk, msg, len, flags, addr_len); 77 + return sk_udp_recvmsg(sk, msg, len, flags); 78 78 79 79 if (!psock_has_data(psock)) { 80 - ret = sk_udp_recvmsg(sk, msg, len, flags, addr_len); 80 + ret = sk_udp_recvmsg(sk, msg, len, flags); 81 81 goto out; 82 82 } 83 83 ··· 92 92 if (data) { 93 93 if (psock_has_data(psock)) 94 94 goto msg_bytes_ready; 95 - ret = sk_udp_recvmsg(sk, msg, len, flags, addr_len); 95 + ret = sk_udp_recvmsg(sk, msg, len, flags); 96 96 goto out; 97 97 } 98 98 copied = -EAGAIN;
+1 -2
net/ipv4/udp_impl.h
··· 18 18 int udp_getsockopt(struct sock *sk, int level, int optname, 19 19 char __user *optval, int __user *optlen); 20 20 21 - int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 22 - int *addr_len); 21 + int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags); 23 22 void udp_destroy_sock(struct sock *sk); 24 23 25 24 #ifdef CONFIG_PROC_FS
+3 -8
net/ipv6/af_inet6.c
··· 661 661 } 662 662 663 663 INDIRECT_CALLABLE_DECLARE(int udpv6_recvmsg(struct sock *, struct msghdr *, 664 - size_t, int, int *)); 664 + size_t, int)); 665 665 int inet6_recvmsg(struct socket *sock, struct msghdr *msg, size_t size, 666 666 int flags) 667 667 { 668 668 struct sock *sk = sock->sk; 669 669 const struct proto *prot; 670 - int addr_len = 0; 671 - int err; 672 670 673 671 if (likely(!(flags & MSG_ERRQUEUE))) 674 672 sock_rps_record_flow(sk); 675 673 676 674 /* IPV6_ADDRFORM can change sk->sk_prot under us. */ 677 675 prot = READ_ONCE(sk->sk_prot); 678 - err = INDIRECT_CALL_2(prot->recvmsg, tcp_recvmsg, udpv6_recvmsg, 679 - sk, msg, size, flags, &addr_len); 680 - if (err >= 0) 681 - msg->msg_namelen = addr_len; 682 - return err; 676 + return INDIRECT_CALL_2(prot->recvmsg, tcp_recvmsg, udpv6_recvmsg, 677 + sk, msg, size, flags); 683 678 } 684 679 685 680 const struct proto_ops inet6_stream_ops = {
+4 -5
net/ipv6/datagram.c
··· 452 452 /* 453 453 * Handle MSG_ERRQUEUE 454 454 */ 455 - int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len) 455 + int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len) 456 456 { 457 457 struct ipv6_pinfo *np = inet6_sk(sk); 458 458 struct sock_exterr_skb *serr; ··· 503 503 &sin->sin6_addr); 504 504 sin->sin6_scope_id = 0; 505 505 } 506 - *addr_len = sizeof(*sin); 506 + msg->msg_namelen = sizeof(*sin); 507 507 } 508 508 509 509 memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err)); ··· 545 545 /* 546 546 * Handle IPV6_RECVPATHMTU 547 547 */ 548 - int ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len, 549 - int *addr_len) 548 + int ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len) 550 549 { 551 550 struct ipv6_pinfo *np = inet6_sk(sk); 552 551 struct sk_buff *skb; ··· 578 579 sin->sin6_port = 0; 579 580 sin->sin6_scope_id = mtu_info.ip6m_addr.sin6_scope_id; 580 581 sin->sin6_addr = mtu_info.ip6m_addr.sin6_addr; 581 - *addr_len = sizeof(*sin); 582 + msg->msg_namelen = sizeof(*sin); 582 583 } 583 584 584 585 put_cmsg(msg, SOL_IPV6, IPV6_PATHMTU, sizeof(mtu_info), &mtu_info);
+1 -2
net/ipv6/ping.c
··· 24 24 #include <net/ping.h> 25 25 26 26 /* Compatibility glue so we can support IPv6 when it's compiled as a module */ 27 - static int dummy_ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len, 28 - int *addr_len) 27 + static int dummy_ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len) 29 28 { 30 29 return -EAFNOSUPPORT; 31 30 }
+4 -4
net/ipv6/raw.c
··· 432 432 */ 433 433 434 434 static int rawv6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 435 - int flags, int *addr_len) 435 + int flags) 436 436 { 437 437 struct ipv6_pinfo *np = inet6_sk(sk); 438 438 DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name); ··· 444 444 return -EOPNOTSUPP; 445 445 446 446 if (flags & MSG_ERRQUEUE) 447 - return ipv6_recv_error(sk, msg, len, addr_len); 447 + return ipv6_recv_error(sk, msg, len); 448 448 449 449 if (np->rxopt.bits.rxpmtu && READ_ONCE(np->rxpmtu)) 450 - return ipv6_recv_rxpmtu(sk, msg, len, addr_len); 450 + return ipv6_recv_rxpmtu(sk, msg, len); 451 451 452 452 skb = skb_recv_datagram(sk, flags, &err); 453 453 if (!skb) ··· 481 481 sin6->sin6_flowinfo = 0; 482 482 sin6->sin6_scope_id = ipv6_iface_scope_id(&sin6->sin6_addr, 483 483 inet6_iif(skb)); 484 - *addr_len = sizeof(*sin6); 484 + msg->msg_namelen = sizeof(*sin6); 485 485 } 486 486 487 487 sock_recv_cmsgs(msg, sk, skb);
+5 -5
net/ipv6/udp.c
··· 465 465 */ 466 466 467 467 int udpv6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 468 - int flags, int *addr_len) 468 + int flags) 469 469 { 470 470 struct ipv6_pinfo *np = inet6_sk(sk); 471 471 struct inet_sock *inet = inet_sk(sk); ··· 478 478 int is_udp4; 479 479 480 480 if (flags & MSG_ERRQUEUE) 481 - return ipv6_recv_error(sk, msg, len, addr_len); 481 + return ipv6_recv_error(sk, msg, len); 482 482 483 483 if (np->rxopt.bits.rxpmtu && READ_ONCE(np->rxpmtu)) 484 - return ipv6_recv_rxpmtu(sk, msg, len, addr_len); 484 + return ipv6_recv_rxpmtu(sk, msg, len); 485 485 486 486 try_again: 487 487 off = sk_peek_offset(sk, flags); ··· 553 553 ipv6_iface_scope_id(&sin6->sin6_addr, 554 554 inet6_iif(skb)); 555 555 } 556 - *addr_len = sizeof(*sin6); 556 + msg->msg_namelen = sizeof(*sin6); 557 557 558 558 BPF_CGROUP_RUN_PROG_UDP6_RECVMSG_LOCK(sk, 559 559 (struct sockaddr *)sin6, 560 - addr_len); 560 + &msg->msg_namelen); 561 561 } 562 562 563 563 if (udp_test_bit(GRO_ENABLED, sk))
+1 -2
net/ipv6/udp_impl.h
··· 22 22 int udpv6_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval, 23 23 unsigned int optlen); 24 24 int udpv6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len); 25 - int udpv6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 26 - int *addr_len); 25 + int udpv6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags); 27 26 void udpv6_destroy_sock(struct sock *sk); 28 27 29 28 #ifdef CONFIG_PROC_FS
+2 -2
net/l2tp/l2tp_ip.c
··· 537 537 } 538 538 539 539 static int l2tp_ip_recvmsg(struct sock *sk, struct msghdr *msg, 540 - size_t len, int flags, int *addr_len) 540 + size_t len, int flags) 541 541 { 542 542 struct inet_sock *inet = inet_sk(sk); 543 543 size_t copied = 0; ··· 570 570 sin->sin_addr.s_addr = ip_hdr(skb)->saddr; 571 571 sin->sin_port = 0; 572 572 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero)); 573 - *addr_len = sizeof(*sin); 573 + msg->msg_namelen = sizeof(*sin); 574 574 } 575 575 if (inet_cmsg_flags(inet)) 576 576 ip_cmsg_recv(msg, skb);
+3 -3
net/l2tp/l2tp_ip6.c
··· 679 679 } 680 680 681 681 static int l2tp_ip6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 682 - int flags, int *addr_len) 682 + int flags) 683 683 { 684 684 struct ipv6_pinfo *np = inet6_sk(sk); 685 685 DECLARE_SOCKADDR(struct sockaddr_l2tpip6 *, lsa, msg->msg_name); ··· 691 691 goto out; 692 692 693 693 if (flags & MSG_ERRQUEUE) 694 - return ipv6_recv_error(sk, msg, len, addr_len); 694 + return ipv6_recv_error(sk, msg, len); 695 695 696 696 skb = skb_recv_datagram(sk, flags, &err); 697 697 if (!skb) ··· 719 719 lsa->l2tp_conn_id = 0; 720 720 if (ipv6_addr_type(&lsa->l2tp_addr) & IPV6_ADDR_LINKLOCAL) 721 721 lsa->l2tp_scope_id = inet6_iif(skb); 722 - *addr_len = sizeof(*lsa); 722 + msg->msg_namelen = sizeof(*lsa); 723 723 } 724 724 725 725 if (np->rxopt.all)
+2 -2
net/mptcp/protocol.c
··· 2259 2259 } 2260 2260 2261 2261 static int mptcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 2262 - int flags, int *addr_len) 2262 + int flags) 2263 2263 { 2264 2264 struct mptcp_sock *msk = mptcp_sk(sk); 2265 2265 struct scm_timestamping_internal tss; ··· 2269 2269 2270 2270 /* MSG_ERRQUEUE is really a no-op till we support IP_RECVERR */ 2271 2271 if (unlikely(flags & MSG_ERRQUEUE)) 2272 - return inet_recv_error(sk, msg, len, addr_len); 2272 + return inet_recv_error(sk, msg, len); 2273 2273 2274 2274 lock_sock(sk); 2275 2275 if (unlikely(sk->sk_state == TCP_LISTEN)) {
+2 -2
net/phonet/datagram.c
··· 109 109 } 110 110 111 111 static int pn_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 112 - int flags, int *addr_len) 112 + int flags) 113 113 { 114 114 struct sk_buff *skb = NULL; 115 115 struct sockaddr_pn sa; ··· 143 143 if (msg->msg_name != NULL) { 144 144 __sockaddr_check_size(sizeof(sa)); 145 145 memcpy(msg->msg_name, &sa, sizeof(sa)); 146 - *addr_len = sizeof(sa); 146 + msg->msg_namelen = sizeof(sa); 147 147 } 148 148 149 149 out:
+1 -1
net/phonet/pep.c
··· 1262 1262 } 1263 1263 1264 1264 static int pep_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 1265 - int flags, int *addr_len) 1265 + int flags) 1266 1266 { 1267 1267 struct sk_buff *skb; 1268 1268 int err;
+6 -6
net/sctp/socket.c
··· 2087 2087 * 5 for complete description of the flags. 2088 2088 */ 2089 2089 static int sctp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 2090 - int flags, int *addr_len) 2090 + int flags) 2091 2091 { 2092 2092 struct sctp_ulpevent *event = NULL; 2093 2093 struct sctp_sock *sp = sctp_sk(sk); ··· 2096 2096 int err = 0; 2097 2097 int skb_len; 2098 2098 2099 - pr_debug("%s: sk:%p, msghdr:%p, len:%zd, flags:0x%x, addr_len:%p)\n", 2100 - __func__, sk, msg, len, flags, addr_len); 2099 + pr_debug("%s: sk:%p, msghdr:%p, len:%zd, flags:0x%x)\n", 2100 + __func__, sk, msg, len, flags); 2101 2101 2102 2102 if (unlikely(flags & MSG_ERRQUEUE)) 2103 - return inet_recv_error(sk, msg, len, addr_len); 2103 + return inet_recv_error(sk, msg, len); 2104 2104 2105 2105 if (sk_can_busy_loop(sk) && 2106 2106 skb_queue_empty_lockless(&sk->sk_receive_queue)) ··· 2141 2141 sock_recv_cmsgs(msg, sk, head_skb); 2142 2142 if (sctp_ulpevent_is_notification(event)) { 2143 2143 msg->msg_flags |= MSG_NOTIFICATION; 2144 - sp->pf->event_msgname(event, msg->msg_name, addr_len); 2144 + sp->pf->event_msgname(event, msg->msg_name, &msg->msg_namelen); 2145 2145 } else { 2146 - sp->pf->skb_msgname(head_skb, msg->msg_name, addr_len); 2146 + sp->pf->skb_msgname(head_skb, msg->msg_name, &msg->msg_namelen); 2147 2147 } 2148 2148 2149 2149 /* Check if we allow SCTP_NXTINFO. */
+1 -1
net/tls/tls.h
··· 161 161 void tls_sw_release_resources_rx(struct sock *sk); 162 162 void tls_sw_free_ctx_rx(struct tls_context *tls_ctx); 163 163 int tls_sw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 164 - int flags, int *addr_len); 164 + int flags); 165 165 bool tls_sw_sock_is_readable(struct sock *sk); 166 166 ssize_t tls_sw_splice_read(struct socket *sock, loff_t *ppos, 167 167 struct pipe_inode_info *pipe,
+1 -2
net/tls/tls_sw.c
··· 2031 2031 int tls_sw_recvmsg(struct sock *sk, 2032 2032 struct msghdr *msg, 2033 2033 size_t len, 2034 - int flags, 2035 - int *addr_len) 2034 + int flags) 2036 2035 { 2037 2036 struct tls_context *tls_ctx = tls_get_ctx(sk); 2038 2037 struct tls_sw_context_rx *ctx = tls_sw_ctx_rx(tls_ctx);
+2 -2
net/unix/af_unix.c
··· 2665 2665 const struct proto *prot = READ_ONCE(sk->sk_prot); 2666 2666 2667 2667 if (prot != &unix_dgram_proto) 2668 - return prot->recvmsg(sk, msg, size, flags, NULL); 2668 + return prot->recvmsg(sk, msg, size, flags); 2669 2669 #endif 2670 2670 return __unix_dgram_recvmsg(sk, msg, size, flags); 2671 2671 } ··· 3139 3139 const struct proto *prot = READ_ONCE(sk->sk_prot); 3140 3140 3141 3141 if (prot != &unix_stream_proto) 3142 - return prot->recvmsg(sk, msg, size, flags, NULL); 3142 + return prot->recvmsg(sk, msg, size, flags); 3143 3143 #endif 3144 3144 return unix_stream_read_generic(&state, true); 3145 3145 }
+1 -1
net/unix/unix_bpf.c
··· 49 49 } 50 50 51 51 static int unix_bpf_recvmsg(struct sock *sk, struct msghdr *msg, 52 - size_t len, int flags, int *addr_len) 52 + size_t len, int flags) 53 53 { 54 54 struct unix_sock *u = unix_sk(sk); 55 55 struct sk_psock *psock;
+2 -2
net/vmw_vsock/af_vsock.c
··· 1502 1502 1503 1503 prot = READ_ONCE(sk->sk_prot); 1504 1504 if (prot != &vsock_proto) 1505 - return prot->recvmsg(sk, msg, len, flags, NULL); 1505 + return prot->recvmsg(sk, msg, len, flags); 1506 1506 #endif 1507 1507 1508 1508 return __vsock_dgram_recvmsg(sock, msg, len, flags); ··· 2575 2575 2576 2576 prot = READ_ONCE(sk->sk_prot); 2577 2577 if (prot != &vsock_proto) 2578 - return prot->recvmsg(sk, msg, len, flags, NULL); 2578 + return prot->recvmsg(sk, msg, len, flags); 2579 2579 #endif 2580 2580 2581 2581 return __vsock_connectible_recvmsg(sock, msg, len, flags);
+1 -1
net/vmw_vsock/vsock_bpf.c
··· 74 74 } 75 75 76 76 static int vsock_bpf_recvmsg(struct sock *sk, struct msghdr *msg, 77 - size_t len, int flags, int *addr_len) 77 + size_t len, int flags) 78 78 { 79 79 struct sk_psock *psock; 80 80 struct vsock_sock *vsk;
+1 -1
net/xfrm/espintcp.c
··· 133 133 } 134 134 135 135 static int espintcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 136 - int flags, int *addr_len) 136 + int flags) 137 137 { 138 138 struct espintcp_ctx *ctx = espintcp_getctx(sk); 139 139 struct sk_buff *skb;