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

net: remove noblock parameter from recvmsg() entities

The internal recvmsg() functions have two parameters 'flags' and 'noblock'
that were merged inside skb_recv_datagram(). As a follow up patch to commit
f4b41f062c42 ("net: remove noblock parameter from skb_recv_datagram()")
this patch removes the separate 'noblock' parameter for recvmsg().

Analogue to the referenced patch for skb_recv_datagram() the 'flags' and
'noblock' parameters are unnecessarily split up with e.g.

err = sk->sk_prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT,
flags & ~MSG_DONTWAIT, &addr_len);

or in

err = INDIRECT_CALL_2(sk->sk_prot->recvmsg, tcp_recvmsg, udp_recvmsg,
sk, msg, size, flags & MSG_DONTWAIT,
flags & ~MSG_DONTWAIT, &addr_len);

instead of simply using only flags all the time and check for MSG_DONTWAIT
where needed (to preserve for the formerly separated no(n)block condition).

Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>
Link: https://lore.kernel.org/r/20220411124955.154876-1-socketcan@hartkopp.net
Signed-off-by: Paolo Abeni <pabeni@redhat.com>

authored by

Oliver Hartkopp and committed by
Paolo Abeni ec095263 f0159809

+91 -122
+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 nonblock, int flags, int *addr_len); 570 + size_t len, int flags, int *addr_len); 571 571 int chtls_sendpage(struct sock *sk, struct page *page, 572 572 int offset, size_t size, int flags); 573 573 int send_tx_flowc_wr(struct sock *sk, int compl,
+10 -12
drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c
··· 1426 1426 } 1427 1427 1428 1428 static int chtls_pt_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 1429 - int nonblock, int flags, int *addr_len) 1429 + int flags, int *addr_len) 1430 1430 { 1431 1431 struct chtls_sock *csk = rcu_dereference_sk_user_data(sk); 1432 1432 struct chtls_hws *hws = &csk->tlshws; ··· 1441 1441 1442 1442 buffers_freed = 0; 1443 1443 1444 - timeo = sock_rcvtimeo(sk, nonblock); 1444 + timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 1445 1445 target = sock_rcvlowat(sk, flags & MSG_WAITALL, len); 1446 1446 1447 1447 if (unlikely(csk_flag(sk, CSK_UPDATE_RCV_WND))) ··· 1616 1616 * Peek at data in a socket's receive buffer. 1617 1617 */ 1618 1618 static int peekmsg(struct sock *sk, struct msghdr *msg, 1619 - size_t len, int nonblock, int flags) 1619 + size_t len, int flags) 1620 1620 { 1621 1621 struct tcp_sock *tp = tcp_sk(sk); 1622 1622 u32 peek_seq, offset; ··· 1626 1626 long timeo; 1627 1627 1628 1628 lock_sock(sk); 1629 - timeo = sock_rcvtimeo(sk, nonblock); 1629 + timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 1630 1630 peek_seq = tp->copied_seq; 1631 1631 1632 1632 do { ··· 1737 1737 } 1738 1738 1739 1739 int chtls_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 1740 - int nonblock, int flags, int *addr_len) 1740 + int flags, int *addr_len) 1741 1741 { 1742 1742 struct tcp_sock *tp = tcp_sk(sk); 1743 1743 struct chtls_sock *csk; ··· 1750 1750 buffers_freed = 0; 1751 1751 1752 1752 if (unlikely(flags & MSG_OOB)) 1753 - return tcp_prot.recvmsg(sk, msg, len, nonblock, flags, 1754 - addr_len); 1753 + return tcp_prot.recvmsg(sk, msg, len, flags, addr_len); 1755 1754 1756 1755 if (unlikely(flags & MSG_PEEK)) 1757 - return peekmsg(sk, msg, len, nonblock, flags); 1756 + return peekmsg(sk, msg, len, flags); 1758 1757 1759 1758 if (sk_can_busy_loop(sk) && 1760 1759 skb_queue_empty_lockless(&sk->sk_receive_queue) && 1761 1760 sk->sk_state == TCP_ESTABLISHED) 1762 - sk_busy_loop(sk, nonblock); 1761 + sk_busy_loop(sk, flags & MSG_DONTWAIT); 1763 1762 1764 1763 lock_sock(sk); 1765 1764 csk = rcu_dereference_sk_user_data(sk); 1766 1765 1767 1766 if (is_tls_rx(csk)) 1768 - return chtls_pt_recvmsg(sk, msg, len, nonblock, 1769 - flags, addr_len); 1767 + return chtls_pt_recvmsg(sk, msg, len, flags, addr_len); 1770 1768 1771 - timeo = sock_rcvtimeo(sk, nonblock); 1769 + timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 1772 1770 target = sock_rcvlowat(sk, flags & MSG_WAITALL, len); 1773 1771 1774 1772 if (unlikely(csk_flag(sk, CSK_UPDATE_RCV_WND)))
+1 -1
include/net/ping.h
··· 71 71 int ping_getfrag(void *from, char *to, int offset, int fraglen, int odd, 72 72 struct sk_buff *); 73 73 74 - int ping_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int noblock, 74 + int ping_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 75 75 int flags, int *addr_len); 76 76 int ping_common_sendmsg(int family, struct msghdr *msg, size_t len, 77 77 void *user_icmph, size_t icmph_len);
+1 -1
include/net/sctp/sctp.h
··· 103 103 struct sctp_association *asoc); 104 104 extern struct percpu_counter sctp_sockets_allocated; 105 105 int sctp_asconf_mgmt(struct sctp_sock *, struct sctp_sockaddr_entry *); 106 - struct sk_buff *sctp_skb_recv_datagram(struct sock *, int, int, int *); 106 + struct sk_buff *sctp_skb_recv_datagram(struct sock *, int, int *); 107 107 108 108 typedef int (*sctp_callback_t)(struct sctp_endpoint *, struct sctp_transport *, void *); 109 109 void sctp_transport_walk_start(struct rhashtable_iter *iter);
+1 -2
include/net/sock.h
··· 1202 1202 int (*sendmsg)(struct sock *sk, struct msghdr *msg, 1203 1203 size_t len); 1204 1204 int (*recvmsg)(struct sock *sk, struct msghdr *msg, 1205 - size_t len, int noblock, int flags, 1206 - int *addr_len); 1205 + size_t len, int flags, int *addr_len); 1207 1206 int (*sendpage)(struct sock *sk, struct page *page, 1208 1207 int offset, size_t size, int flags); 1209 1208 int (*bind)(struct sock *sk,
+1 -1
include/net/tcp.h
··· 407 407 unsigned int optlen); 408 408 void tcp_set_keepalive(struct sock *sk, int val); 409 409 void tcp_syn_ack_timeout(const struct request_sock *req); 410 - int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock, 410 + int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 411 411 int flags, int *addr_len); 412 412 int tcp_set_rcvlowat(struct sock *sk, int val); 413 413 int tcp_set_window_clamp(struct sock *sk, int val);
+1 -1
include/net/tls.h
··· 371 371 void tls_sw_release_resources_rx(struct sock *sk); 372 372 void tls_sw_free_ctx_rx(struct tls_context *tls_ctx); 373 373 int tls_sw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 374 - int nonblock, int flags, int *addr_len); 374 + int flags, int *addr_len); 375 375 bool tls_sw_sock_is_readable(struct sock *sk); 376 376 ssize_t tls_sw_splice_read(struct socket *sock, loff_t *ppos, 377 377 struct pipe_inode_info *pipe,
+4 -4
include/net/udp.h
··· 250 250 void skb_consume_udp(struct sock *sk, struct sk_buff *skb, int len); 251 251 int __udp_enqueue_schedule_skb(struct sock *sk, struct sk_buff *skb); 252 252 void udp_skb_destructor(struct sock *sk, struct sk_buff *skb); 253 - struct sk_buff *__skb_recv_udp(struct sock *sk, unsigned int flags, 254 - int noblock, int *off, int *err); 253 + struct sk_buff *__skb_recv_udp(struct sock *sk, unsigned int flags, int *off, 254 + int *err); 255 255 static inline struct sk_buff *skb_recv_udp(struct sock *sk, unsigned int flags, 256 - int noblock, int *err) 256 + int *err) 257 257 { 258 258 int off = 0; 259 259 260 - return __skb_recv_udp(sk, flags, noblock, &off, err); 260 + return __skb_recv_udp(sk, flags, &off, err); 261 261 } 262 262 263 263 int udp_v4_early_demux(struct sk_buff *skb);
+1 -2
net/core/sock.c
··· 3506 3506 int addr_len = 0; 3507 3507 int err; 3508 3508 3509 - err = sk->sk_prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT, 3510 - flags & ~MSG_DONTWAIT, &addr_len); 3509 + err = sk->sk_prot->recvmsg(sk, msg, size, flags, &addr_len); 3511 3510 if (err >= 0) 3512 3511 msg->msg_namelen = addr_len; 3513 3512 return err;
+2 -2
net/dccp/dccp.h
··· 293 293 sockptr_t optval, unsigned int optlen); 294 294 int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg); 295 295 int dccp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size); 296 - int dccp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock, 297 - int flags, int *addr_len); 296 + int dccp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 297 + int *addr_len); 298 298 void dccp_shutdown(struct sock *sk, int how); 299 299 int inet_dccp_listen(struct socket *sock, int backlog); 300 300 __poll_t dccp_poll(struct file *file, struct socket *sock,
+3 -3
net/dccp/proto.c
··· 791 791 792 792 EXPORT_SYMBOL_GPL(dccp_sendmsg); 793 793 794 - int dccp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock, 795 - int flags, int *addr_len) 794 + int dccp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 795 + int *addr_len) 796 796 { 797 797 const struct dccp_hdr *dh; 798 798 long timeo; ··· 804 804 goto out; 805 805 } 806 806 807 - timeo = sock_rcvtimeo(sk, nonblock); 807 + timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 808 808 809 809 do { 810 810 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
+2 -4
net/ieee802154/socket.c
··· 308 308 } 309 309 310 310 static int raw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 311 - int noblock, int flags, int *addr_len) 311 + int flags, int *addr_len) 312 312 { 313 313 size_t copied = 0; 314 314 int err = -EOPNOTSUPP; 315 315 struct sk_buff *skb; 316 316 317 - flags |= (noblock ? MSG_DONTWAIT : 0); 318 317 skb = skb_recv_datagram(sk, flags, &err); 319 318 if (!skb) 320 319 goto out; ··· 695 696 } 696 697 697 698 static int dgram_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 698 - int noblock, int flags, int *addr_len) 699 + int flags, int *addr_len) 699 700 { 700 701 size_t copied = 0; 701 702 int err = -EOPNOTSUPP; ··· 703 704 struct dgram_sock *ro = dgram_sk(sk); 704 705 DECLARE_SOCKADDR(struct sockaddr_ieee802154 *, saddr, msg->msg_name); 705 706 706 - flags |= (noblock ? MSG_DONTWAIT : 0); 707 707 skb = skb_recv_datagram(sk, flags, &err); 708 708 if (!skb) 709 709 goto out;
+2 -3
net/ipv4/af_inet.c
··· 836 836 EXPORT_SYMBOL(inet_sendpage); 837 837 838 838 INDIRECT_CALLABLE_DECLARE(int udp_recvmsg(struct sock *, struct msghdr *, 839 - size_t, int, int, int *)); 839 + size_t, int, int *)); 840 840 int inet_recvmsg(struct socket *sock, struct msghdr *msg, size_t size, 841 841 int flags) 842 842 { ··· 848 848 sock_rps_record_flow(sk); 849 849 850 850 err = INDIRECT_CALL_2(sk->sk_prot->recvmsg, tcp_recvmsg, udp_recvmsg, 851 - sk, msg, size, flags & MSG_DONTWAIT, 852 - flags & ~MSG_DONTWAIT, &addr_len); 851 + sk, msg, size, flags, &addr_len); 853 852 if (err >= 0) 854 853 msg->msg_namelen = addr_len; 855 854 return err;
+2 -3
net/ipv4/ping.c
··· 844 844 goto out; 845 845 } 846 846 847 - int ping_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int noblock, 848 - int flags, int *addr_len) 847 + int ping_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 848 + int *addr_len) 849 849 { 850 850 struct inet_sock *isk = inet_sk(sk); 851 851 int family = sk->sk_family; ··· 861 861 if (flags & MSG_ERRQUEUE) 862 862 return inet_recv_error(sk, msg, len, addr_len); 863 863 864 - flags |= (noblock ? MSG_DONTWAIT : 0); 865 864 skb = skb_recv_datagram(sk, flags, &err); 866 865 if (!skb) 867 866 goto out;
+1 -2
net/ipv4/raw.c
··· 753 753 */ 754 754 755 755 static int raw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 756 - int noblock, int flags, int *addr_len) 756 + int flags, int *addr_len) 757 757 { 758 758 struct inet_sock *inet = inet_sk(sk); 759 759 size_t copied = 0; ··· 769 769 goto out; 770 770 } 771 771 772 - flags |= (noblock ? MSG_DONTWAIT : 0); 773 772 skb = skb_recv_datagram(sk, flags, &err); 774 773 if (!skb) 775 774 goto out;
+8 -11
net/ipv4/tcp.c
··· 1877 1877 } 1878 1878 1879 1879 static int tcp_recvmsg_locked(struct sock *sk, struct msghdr *msg, size_t len, 1880 - int nonblock, int flags, 1881 - struct scm_timestamping_internal *tss, 1880 + int flags, struct scm_timestamping_internal *tss, 1882 1881 int *cmsg_flags); 1883 1882 static int receive_fallback_to_copy(struct sock *sk, 1884 1883 struct tcp_zerocopy_receive *zc, int inq, ··· 1899 1900 if (err) 1900 1901 return err; 1901 1902 1902 - err = tcp_recvmsg_locked(sk, &msg, inq, /*nonblock=*/1, /*flags=*/0, 1903 + err = tcp_recvmsg_locked(sk, &msg, inq, MSG_DONTWAIT, 1903 1904 tss, &zc->msg_flags); 1904 1905 if (err < 0) 1905 1906 return err; ··· 2315 2316 */ 2316 2317 2317 2318 static int tcp_recvmsg_locked(struct sock *sk, struct msghdr *msg, size_t len, 2318 - int nonblock, int flags, 2319 - struct scm_timestamping_internal *tss, 2319 + int flags, struct scm_timestamping_internal *tss, 2320 2320 int *cmsg_flags) 2321 2321 { 2322 2322 struct tcp_sock *tp = tcp_sk(sk); ··· 2335 2337 2336 2338 if (tp->recvmsg_inq) 2337 2339 *cmsg_flags = TCP_CMSG_INQ; 2338 - timeo = sock_rcvtimeo(sk, nonblock); 2340 + timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 2339 2341 2340 2342 /* Urgent data needs to be handled specially. */ 2341 2343 if (flags & MSG_OOB) ··· 2554 2556 goto out; 2555 2557 } 2556 2558 2557 - int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock, 2558 - int flags, int *addr_len) 2559 + int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 2560 + int *addr_len) 2559 2561 { 2560 2562 int cmsg_flags = 0, ret, inq; 2561 2563 struct scm_timestamping_internal tss; ··· 2566 2568 if (sk_can_busy_loop(sk) && 2567 2569 skb_queue_empty_lockless(&sk->sk_receive_queue) && 2568 2570 sk->sk_state == TCP_ESTABLISHED) 2569 - sk_busy_loop(sk, nonblock); 2571 + sk_busy_loop(sk, flags & MSG_DONTWAIT); 2570 2572 2571 2573 lock_sock(sk); 2572 - ret = tcp_recvmsg_locked(sk, msg, len, nonblock, flags, &tss, 2573 - &cmsg_flags); 2574 + ret = tcp_recvmsg_locked(sk, msg, len, flags, &tss, &cmsg_flags); 2574 2575 release_sock(sk); 2575 2576 sk_defer_free_flush(sk); 2576 2577
+7 -8
net/ipv4/tcp_bpf.c
··· 174 174 static int tcp_bpf_recvmsg_parser(struct sock *sk, 175 175 struct msghdr *msg, 176 176 size_t len, 177 - int nonblock, 178 177 int flags, 179 178 int *addr_len) 180 179 { ··· 185 186 186 187 psock = sk_psock_get(sk); 187 188 if (unlikely(!psock)) 188 - return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len); 189 + return tcp_recvmsg(sk, msg, len, flags, addr_len); 189 190 190 191 lock_sock(sk); 191 192 msg_bytes_ready: ··· 210 211 goto out; 211 212 } 212 213 213 - timeo = sock_rcvtimeo(sk, nonblock); 214 + timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 214 215 if (!timeo) { 215 216 copied = -EAGAIN; 216 217 goto out; ··· 233 234 } 234 235 235 236 static int tcp_bpf_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 236 - int nonblock, int flags, int *addr_len) 237 + int flags, int *addr_len) 237 238 { 238 239 struct sk_psock *psock; 239 240 int copied, ret; ··· 243 244 244 245 psock = sk_psock_get(sk); 245 246 if (unlikely(!psock)) 246 - return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len); 247 + return tcp_recvmsg(sk, msg, len, flags, addr_len); 247 248 if (!skb_queue_empty(&sk->sk_receive_queue) && 248 249 sk_psock_queue_empty(psock)) { 249 250 sk_psock_put(sk, psock); 250 - return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len); 251 + return tcp_recvmsg(sk, msg, len, flags, addr_len); 251 252 } 252 253 lock_sock(sk); 253 254 msg_bytes_ready: ··· 256 257 long timeo; 257 258 int data; 258 259 259 - timeo = sock_rcvtimeo(sk, nonblock); 260 + timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 260 261 data = tcp_msg_wait_data(sk, psock, timeo); 261 262 if (data) { 262 263 if (!sk_psock_queue_empty(psock)) 263 264 goto msg_bytes_ready; 264 265 release_sock(sk); 265 266 sk_psock_put(sk, psock); 266 - return tcp_recvmsg(sk, msg, len, nonblock, flags, addr_len); 267 + return tcp_recvmsg(sk, msg, len, flags, addr_len); 267 268 } 268 269 copied = -EAGAIN; 269 270 }
+5 -6
net/ipv4/udp.c
··· 1726 1726 EXPORT_SYMBOL(udp_ioctl); 1727 1727 1728 1728 struct sk_buff *__skb_recv_udp(struct sock *sk, unsigned int flags, 1729 - int noblock, int *off, int *err) 1729 + int *off, int *err) 1730 1730 { 1731 1731 struct sk_buff_head *sk_queue = &sk->sk_receive_queue; 1732 1732 struct sk_buff_head *queue; ··· 1735 1735 int error; 1736 1736 1737 1737 queue = &udp_sk(sk)->reader_queue; 1738 - flags |= noblock ? MSG_DONTWAIT : 0; 1739 1738 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 1740 1739 do { 1741 1740 struct sk_buff *skb; ··· 1804 1805 struct sk_buff *skb; 1805 1806 int err, used; 1806 1807 1807 - skb = skb_recv_udp(sk, 0, 1, &err); 1808 + skb = skb_recv_udp(sk, MSG_DONTWAIT, &err); 1808 1809 if (!skb) 1809 1810 return err; 1810 1811 ··· 1842 1843 * return it, otherwise we block. 1843 1844 */ 1844 1845 1845 - int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int noblock, 1846 - int flags, int *addr_len) 1846 + int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 1847 + int *addr_len) 1847 1848 { 1848 1849 struct inet_sock *inet = inet_sk(sk); 1849 1850 DECLARE_SOCKADDR(struct sockaddr_in *, sin, msg->msg_name); ··· 1858 1859 1859 1860 try_again: 1860 1861 off = sk_peek_offset(sk, flags); 1861 - skb = __skb_recv_udp(sk, flags, noblock, &off, &err); 1862 + skb = __skb_recv_udp(sk, flags, &off, &err); 1862 1863 if (!skb) 1863 1864 return err; 1864 1865
+8 -9
net/ipv4/udp_bpf.c
··· 11 11 static struct proto *udpv6_prot_saved __read_mostly; 12 12 13 13 static int sk_udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 14 - int noblock, int flags, int *addr_len) 14 + int flags, int *addr_len) 15 15 { 16 16 #if IS_ENABLED(CONFIG_IPV6) 17 17 if (sk->sk_family == AF_INET6) 18 - return udpv6_prot_saved->recvmsg(sk, msg, len, noblock, flags, 19 - addr_len); 18 + return udpv6_prot_saved->recvmsg(sk, msg, len, flags, addr_len); 20 19 #endif 21 - return udp_prot.recvmsg(sk, msg, len, noblock, flags, addr_len); 20 + return udp_prot.recvmsg(sk, msg, len, flags, addr_len); 22 21 } 23 22 24 23 static bool udp_sk_has_data(struct sock *sk) ··· 60 61 } 61 62 62 63 static int udp_bpf_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 63 - int nonblock, int flags, int *addr_len) 64 + int flags, int *addr_len) 64 65 { 65 66 struct sk_psock *psock; 66 67 int copied, ret; ··· 70 71 71 72 psock = sk_psock_get(sk); 72 73 if (unlikely(!psock)) 73 - return sk_udp_recvmsg(sk, msg, len, nonblock, flags, addr_len); 74 + return sk_udp_recvmsg(sk, msg, len, flags, addr_len); 74 75 75 76 if (!psock_has_data(psock)) { 76 - ret = sk_udp_recvmsg(sk, msg, len, nonblock, flags, addr_len); 77 + ret = sk_udp_recvmsg(sk, msg, len, flags, addr_len); 77 78 goto out; 78 79 } 79 80 ··· 83 84 long timeo; 84 85 int data; 85 86 86 - timeo = sock_rcvtimeo(sk, nonblock); 87 + timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 87 88 data = udp_msg_wait_data(sk, psock, timeo); 88 89 if (data) { 89 90 if (psock_has_data(psock)) 90 91 goto msg_bytes_ready; 91 - ret = sk_udp_recvmsg(sk, msg, len, nonblock, flags, addr_len); 92 + ret = sk_udp_recvmsg(sk, msg, len, flags, addr_len); 92 93 goto out; 93 94 } 94 95 copied = -EAGAIN;
+2 -2
net/ipv4/udp_impl.h
··· 17 17 int udp_getsockopt(struct sock *sk, int level, int optname, 18 18 char __user *optval, int __user *optlen); 19 19 20 - int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int noblock, 21 - int flags, int *addr_len); 20 + int udp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 21 + int *addr_len); 22 22 int udp_sendpage(struct sock *sk, struct page *page, int offset, size_t size, 23 23 int flags); 24 24 void udp_destroy_sock(struct sock *sk);
+2 -3
net/ipv6/af_inet6.c
··· 654 654 } 655 655 656 656 INDIRECT_CALLABLE_DECLARE(int udpv6_recvmsg(struct sock *, struct msghdr *, 657 - size_t, int, int, int *)); 657 + size_t, int, int *)); 658 658 int inet6_recvmsg(struct socket *sock, struct msghdr *msg, size_t size, 659 659 int flags) 660 660 { ··· 669 669 /* IPV6_ADDRFORM can change sk->sk_prot under us. */ 670 670 prot = READ_ONCE(sk->sk_prot); 671 671 err = INDIRECT_CALL_2(prot->recvmsg, tcp_recvmsg, udpv6_recvmsg, 672 - sk, msg, size, flags & MSG_DONTWAIT, 673 - flags & ~MSG_DONTWAIT, &addr_len); 672 + sk, msg, size, flags, &addr_len); 674 673 if (err >= 0) 675 674 msg->msg_namelen = addr_len; 676 675 return err;
+1 -2
net/ipv6/raw.c
··· 460 460 */ 461 461 462 462 static int rawv6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 463 - int noblock, int flags, int *addr_len) 463 + int flags, int *addr_len) 464 464 { 465 465 struct ipv6_pinfo *np = inet6_sk(sk); 466 466 DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, msg->msg_name); ··· 477 477 if (np->rxpmtu && np->rxopt.bits.rxpmtu) 478 478 return ipv6_recv_rxpmtu(sk, msg, len, addr_len); 479 479 480 - flags |= (noblock ? MSG_DONTWAIT : 0); 481 480 skb = skb_recv_datagram(sk, flags, &err); 482 481 if (!skb) 483 482 goto out;
+2 -2
net/ipv6/udp.c
··· 322 322 */ 323 323 324 324 int udpv6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 325 - int noblock, int flags, int *addr_len) 325 + int flags, int *addr_len) 326 326 { 327 327 struct ipv6_pinfo *np = inet6_sk(sk); 328 328 struct inet_sock *inet = inet_sk(sk); ··· 342 342 343 343 try_again: 344 344 off = sk_peek_offset(sk, flags); 345 - skb = __skb_recv_udp(sk, flags, noblock, &off, &err); 345 + skb = __skb_recv_udp(sk, flags, &off, &err); 346 346 if (!skb) 347 347 return err; 348 348
+2 -2
net/ipv6/udp_impl.h
··· 20 20 int udpv6_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval, 21 21 unsigned int optlen); 22 22 int udpv6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len); 23 - int udpv6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int noblock, 24 - int flags, int *addr_len); 23 + int udpv6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int flags, 24 + int *addr_len); 25 25 void udpv6_destroy_sock(struct sock *sk); 26 26 27 27 #ifdef CONFIG_PROC_FS
+1 -2
net/l2tp/l2tp_ip.c
··· 515 515 } 516 516 517 517 static int l2tp_ip_recvmsg(struct sock *sk, struct msghdr *msg, 518 - size_t len, int noblock, int flags, int *addr_len) 518 + size_t len, int flags, int *addr_len) 519 519 { 520 520 struct inet_sock *inet = inet_sk(sk); 521 521 size_t copied = 0; ··· 526 526 if (flags & MSG_OOB) 527 527 goto out; 528 528 529 - flags |= (noblock ? MSG_DONTWAIT : 0); 530 529 skb = skb_recv_datagram(sk, flags, &err); 531 530 if (!skb) 532 531 goto out;
+1 -2
net/l2tp/l2tp_ip6.c
··· 657 657 } 658 658 659 659 static int l2tp_ip6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 660 - int noblock, int flags, int *addr_len) 660 + int flags, int *addr_len) 661 661 { 662 662 struct ipv6_pinfo *np = inet6_sk(sk); 663 663 DECLARE_SOCKADDR(struct sockaddr_l2tpip6 *, lsa, msg->msg_name); ··· 671 671 if (flags & MSG_ERRQUEUE) 672 672 return ipv6_recv_error(sk, msg, len, addr_len); 673 673 674 - flags |= (noblock ? MSG_DONTWAIT : 0); 675 674 skb = skb_recv_datagram(sk, flags, &err); 676 675 if (!skb) 677 676 goto out;
+2 -2
net/mptcp/protocol.c
··· 2012 2012 } 2013 2013 2014 2014 static int mptcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 2015 - int nonblock, int flags, int *addr_len) 2015 + int flags, int *addr_len) 2016 2016 { 2017 2017 struct mptcp_sock *msk = mptcp_sk(sk); 2018 2018 struct scm_timestamping_internal tss; ··· 2030 2030 goto out_err; 2031 2031 } 2032 2032 2033 - timeo = sock_rcvtimeo(sk, nonblock); 2033 + timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 2034 2034 2035 2035 len = min_t(size_t, len, INT_MAX); 2036 2036 target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
+1 -2
net/phonet/datagram.c
··· 112 112 } 113 113 114 114 static int pn_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 115 - int noblock, int flags, int *addr_len) 115 + int flags, int *addr_len) 116 116 { 117 117 struct sk_buff *skb = NULL; 118 118 struct sockaddr_pn sa; ··· 123 123 MSG_CMSG_COMPAT)) 124 124 goto out_nofree; 125 125 126 - flags |= (noblock ? MSG_DONTWAIT : 0); 127 126 skb = skb_recv_datagram(sk, flags, &rval); 128 127 if (skb == NULL) 129 128 goto out_nofree;
+1 -2
net/phonet/pep.c
··· 1239 1239 } 1240 1240 1241 1241 static int pep_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 1242 - int noblock, int flags, int *addr_len) 1242 + int flags, int *addr_len) 1243 1243 { 1244 1244 struct sk_buff *skb; 1245 1245 int err; ··· 1268 1268 return -EINVAL; 1269 1269 } 1270 1270 1271 - flags |= (noblock ? MSG_DONTWAIT : 0); 1272 1271 skb = skb_recv_datagram(sk, flags, &err); 1273 1272 lock_sock(sk); 1274 1273 if (skb == NULL) {
+7 -9
net/sctp/socket.c
··· 2084 2084 * 5 for complete description of the flags. 2085 2085 */ 2086 2086 static int sctp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 2087 - int noblock, int flags, int *addr_len) 2087 + int flags, int *addr_len) 2088 2088 { 2089 2089 struct sctp_ulpevent *event = NULL; 2090 2090 struct sctp_sock *sp = sctp_sk(sk); ··· 2093 2093 int err = 0; 2094 2094 int skb_len; 2095 2095 2096 - pr_debug("%s: sk:%p, msghdr:%p, len:%zd, noblock:%d, flags:0x%x, " 2097 - "addr_len:%p)\n", __func__, sk, msg, len, noblock, flags, 2098 - addr_len); 2096 + pr_debug("%s: sk:%p, msghdr:%p, len:%zd, flags:0x%x, addr_len:%p)\n", 2097 + __func__, sk, msg, len, flags, addr_len); 2099 2098 2100 2099 lock_sock(sk); 2101 2100 ··· 2104 2105 goto out; 2105 2106 } 2106 2107 2107 - skb = sctp_skb_recv_datagram(sk, flags, noblock, &err); 2108 + skb = sctp_skb_recv_datagram(sk, flags, &err); 2108 2109 if (!skb) 2109 2110 goto out; 2110 2111 ··· 8977 8978 * Note: This is pretty much the same routine as in core/datagram.c 8978 8979 * with a few changes to make lksctp work. 8979 8980 */ 8980 - struct sk_buff *sctp_skb_recv_datagram(struct sock *sk, int flags, 8981 - int noblock, int *err) 8981 + struct sk_buff *sctp_skb_recv_datagram(struct sock *sk, int flags, int *err) 8982 8982 { 8983 8983 int error; 8984 8984 struct sk_buff *skb; 8985 8985 long timeo; 8986 8986 8987 - timeo = sock_rcvtimeo(sk, noblock); 8987 + timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 8988 8988 8989 8989 pr_debug("%s: timeo:%ld, max:%ld\n", __func__, timeo, 8990 8990 MAX_SCHEDULE_TIMEOUT); ··· 9016 9018 break; 9017 9019 9018 9020 if (sk_can_busy_loop(sk)) { 9019 - sk_busy_loop(sk, noblock); 9021 + sk_busy_loop(sk, flags & MSG_DONTWAIT); 9020 9022 9021 9023 if (!skb_queue_empty_lockless(&sk->sk_receive_queue)) 9022 9024 continue;
+1 -1
net/sctp/ulpevent.c
··· 1063 1063 struct sk_buff *skb; 1064 1064 int err; 1065 1065 1066 - skb = sctp_skb_recv_datagram(sk, MSG_PEEK, 1, &err); 1066 + skb = sctp_skb_recv_datagram(sk, MSG_PEEK | MSG_DONTWAIT, &err); 1067 1067 if (skb != NULL) { 1068 1068 __sctp_ulpevent_read_nxtinfo(sctp_skb2event(skb), 1069 1069 msghdr, skb);
+1 -1
net/sunrpc/svcsock.c
··· 464 464 0, 0, MSG_PEEK | MSG_DONTWAIT); 465 465 if (err < 0) 466 466 goto out_recv_err; 467 - skb = skb_recv_udp(svsk->sk_sk, 0, 1, &err); 467 + skb = skb_recv_udp(svsk->sk_sk, MSG_DONTWAIT, &err); 468 468 if (!skb) 469 469 goto out_recv_err; 470 470
+1 -1
net/sunrpc/xprtsock.c
··· 1337 1337 if (sk == NULL) 1338 1338 goto out; 1339 1339 for (;;) { 1340 - skb = skb_recv_udp(sk, 0, 1, &err); 1340 + skb = skb_recv_udp(sk, MSG_DONTWAIT, &err); 1341 1341 if (skb == NULL) 1342 1342 break; 1343 1343 xs_udp_data_read_skb(&transport->xprt, sk, skb);
-3
net/tls/tls_sw.c
··· 1722 1722 int tls_sw_recvmsg(struct sock *sk, 1723 1723 struct msghdr *msg, 1724 1724 size_t len, 1725 - int nonblock, 1726 1725 int flags, 1727 1726 int *addr_len) 1728 1727 { ··· 1742 1743 bool is_peek = flags & MSG_PEEK; 1743 1744 bool bpf_strp_enabled; 1744 1745 bool zc_capable; 1745 - 1746 - flags |= nonblock; 1747 1746 1748 1747 if (unlikely(flags & MSG_ERRQUEUE)) 1749 1748 return sock_recv_errqueue(sk, msg, len, SOL_IP, IP_RECVERR);
+2 -4
net/unix/af_unix.c
··· 2484 2484 const struct proto *prot = READ_ONCE(sk->sk_prot); 2485 2485 2486 2486 if (prot != &unix_dgram_proto) 2487 - return prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT, 2488 - flags & ~MSG_DONTWAIT, NULL); 2487 + return prot->recvmsg(sk, msg, size, flags, NULL); 2489 2488 #endif 2490 2489 return __unix_dgram_recvmsg(sk, msg, size, flags); 2491 2490 } ··· 2916 2917 const struct proto *prot = READ_ONCE(sk->sk_prot); 2917 2918 2918 2919 if (prot != &unix_stream_proto) 2919 - return prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT, 2920 - flags & ~MSG_DONTWAIT, NULL); 2920 + return prot->recvmsg(sk, msg, size, flags, NULL); 2921 2921 #endif 2922 2922 return unix_stream_read_generic(&state, true); 2923 2923 }
+2 -3
net/unix/unix_bpf.c
··· 48 48 } 49 49 50 50 static int unix_bpf_recvmsg(struct sock *sk, struct msghdr *msg, 51 - size_t len, int nonblock, int flags, 52 - int *addr_len) 51 + size_t len, int flags, int *addr_len) 53 52 { 54 53 struct unix_sock *u = unix_sk(sk); 55 54 struct sk_psock *psock; ··· 72 73 long timeo; 73 74 int data; 74 75 75 - timeo = sock_rcvtimeo(sk, nonblock); 76 + timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 76 77 data = unix_msg_wait_data(sk, psock, timeo); 77 78 if (data) { 78 79 if (!sk_psock_queue_empty(psock))
+1 -3
net/xfrm/espintcp.c
··· 131 131 } 132 132 133 133 static int espintcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 134 - int nonblock, int flags, int *addr_len) 134 + int flags, int *addr_len) 135 135 { 136 136 struct espintcp_ctx *ctx = espintcp_getctx(sk); 137 137 struct sk_buff *skb; 138 138 int err = 0; 139 139 int copied; 140 140 int off = 0; 141 - 142 - flags |= nonblock ? MSG_DONTWAIT : 0; 143 141 144 142 skb = __skb_recv_datagram(sk, &ctx->ike_queue, flags, &off, &err); 145 143 if (!skb) {