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 skb_recv_datagram()

skb_recv_datagram() has two parameters 'flags' and 'noblock' that are
merged inside skb_recv_datagram() by 'flags | (noblock ? MSG_DONTWAIT : 0)'

As 'flags' may contain MSG_DONTWAIT as value most callers split the 'flags'
into 'flags' and 'noblock' with finally obsolete bit operations like this:

skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &rc);

And this is not even done consistently with the 'flags' parameter.

This patch removes the obsolete and costly splitting into two parameters
and only performs bit operations when really needed on the caller side.

One missing conversion thankfully reported by kernel test robot. I missed
to enable kunit tests to build the mctp code.

Reported-by: kernel test robot <lkp@intel.com>
Signed-off-by: Oliver Hartkopp <socketcan@hartkopp.net>
Signed-off-by: David S. Miller <davem@davemloft.net>

authored by

Oliver Hartkopp and committed by
David S. Miller f4b41f06 0b5c21bb

+57 -70
+1 -1
drivers/isdn/mISDN/socket.c
··· 121 121 if (sk->sk_state == MISDN_CLOSED) 122 122 return 0; 123 123 124 - skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err); 124 + skb = skb_recv_datagram(sk, flags, &err); 125 125 if (!skb) 126 126 return err; 127 127
+1 -2
drivers/net/ppp/pppoe.c
··· 1011 1011 goto end; 1012 1012 } 1013 1013 1014 - skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 1015 - flags & MSG_DONTWAIT, &error); 1014 + skb = skb_recv_datagram(sk, flags, &error); 1016 1015 if (error < 0) 1017 1016 goto end; 1018 1017
+1 -2
include/linux/skbuff.h
··· 3836 3836 struct sk_buff *__skb_recv_datagram(struct sock *sk, 3837 3837 struct sk_buff_head *sk_queue, 3838 3838 unsigned int flags, int *off, int *err); 3839 - struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock, 3840 - int *err); 3839 + struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned int flags, int *err); 3841 3840 __poll_t datagram_poll(struct file *file, struct socket *sock, 3842 3841 struct poll_table_struct *wait); 3843 3842 int skb_copy_datagram_iter(const struct sk_buff *from, int offset,
+1 -2
net/appletalk/ddp.c
··· 1753 1753 int err = 0; 1754 1754 struct sk_buff *skb; 1755 1755 1756 - skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 1757 - flags & MSG_DONTWAIT, &err); 1756 + skb = skb_recv_datagram(sk, flags, &err); 1758 1757 lock_sock(sk); 1759 1758 1760 1759 if (!skb)
+1 -1
net/atm/common.c
··· 540 540 !test_bit(ATM_VF_READY, &vcc->flags)) 541 541 return 0; 542 542 543 - skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &error); 543 + skb = skb_recv_datagram(sk, flags, &error); 544 544 if (!skb) 545 545 return error; 546 546
+1 -2
net/ax25/af_ax25.c
··· 1669 1669 } 1670 1670 1671 1671 /* Now we can treat all alike */ 1672 - skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 1673 - flags & MSG_DONTWAIT, &err); 1672 + skb = skb_recv_datagram(sk, flags, &err); 1674 1673 if (skb == NULL) 1675 1674 goto out; 1676 1675
+1 -2
net/bluetooth/af_bluetooth.c
··· 251 251 int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, 252 252 int flags) 253 253 { 254 - int noblock = flags & MSG_DONTWAIT; 255 254 struct sock *sk = sock->sk; 256 255 struct sk_buff *skb; 257 256 size_t copied; ··· 262 263 if (flags & MSG_OOB) 263 264 return -EOPNOTSUPP; 264 265 265 - skb = skb_recv_datagram(sk, flags, noblock, &err); 266 + skb = skb_recv_datagram(sk, flags, &err); 266 267 if (!skb) { 267 268 if (sk->sk_shutdown & RCV_SHUTDOWN) 268 269 return 0;
+1 -2
net/bluetooth/hci_sock.c
··· 1453 1453 static int hci_sock_recvmsg(struct socket *sock, struct msghdr *msg, 1454 1454 size_t len, int flags) 1455 1455 { 1456 - int noblock = flags & MSG_DONTWAIT; 1457 1456 struct sock *sk = sock->sk; 1458 1457 struct sk_buff *skb; 1459 1458 int copied, err; ··· 1469 1470 if (sk->sk_state == BT_CLOSED) 1470 1471 return 0; 1471 1472 1472 - skb = skb_recv_datagram(sk, flags, noblock, &err); 1473 + skb = skb_recv_datagram(sk, flags, &err); 1473 1474 if (!skb) 1474 1475 return err; 1475 1476
+1 -1
net/caif/caif_socket.c
··· 282 282 if (flags & MSG_OOB) 283 283 goto read_error; 284 284 285 - skb = skb_recv_datagram(sk, flags, 0 , &ret); 285 + skb = skb_recv_datagram(sk, flags, &ret); 286 286 if (!skb) 287 287 goto read_error; 288 288 copylen = skb->len;
+1 -4
net/can/bcm.c
··· 1632 1632 struct sock *sk = sock->sk; 1633 1633 struct sk_buff *skb; 1634 1634 int error = 0; 1635 - int noblock; 1636 1635 int err; 1637 1636 1638 - noblock = flags & MSG_DONTWAIT; 1639 - flags &= ~MSG_DONTWAIT; 1640 - skb = skb_recv_datagram(sk, flags, noblock, &error); 1637 + skb = skb_recv_datagram(sk, flags, &error); 1641 1638 if (!skb) 1642 1639 return error; 1643 1640
+1 -3
net/can/isotp.c
··· 1047 1047 struct sock *sk = sock->sk; 1048 1048 struct sk_buff *skb; 1049 1049 struct isotp_sock *so = isotp_sk(sk); 1050 - int noblock = flags & MSG_DONTWAIT; 1051 1050 int ret = 0; 1052 1051 1053 1052 if (flags & ~(MSG_DONTWAIT | MSG_TRUNC | MSG_PEEK)) ··· 1055 1056 if (!so->bound) 1056 1057 return -EADDRNOTAVAIL; 1057 1058 1058 - flags &= ~MSG_DONTWAIT; 1059 - skb = skb_recv_datagram(sk, flags, noblock, &ret); 1059 + skb = skb_recv_datagram(sk, flags, &ret); 1060 1060 if (!skb) 1061 1061 return ret; 1062 1062
+1 -1
net/can/j1939/socket.c
··· 802 802 return sock_recv_errqueue(sock->sk, msg, size, SOL_CAN_J1939, 803 803 SCM_J1939_ERRQUEUE); 804 804 805 - skb = skb_recv_datagram(sk, flags, 0, &ret); 805 + skb = skb_recv_datagram(sk, flags, &ret); 806 806 if (!skb) 807 807 return ret; 808 808
+1 -5
net/can/raw.c
··· 846 846 struct sock *sk = sock->sk; 847 847 struct sk_buff *skb; 848 848 int err = 0; 849 - int noblock; 850 - 851 - noblock = flags & MSG_DONTWAIT; 852 - flags &= ~MSG_DONTWAIT; 853 849 854 850 if (flags & MSG_ERRQUEUE) 855 851 return sock_recv_errqueue(sk, msg, size, 856 852 SOL_CAN_RAW, SCM_CAN_RAW_ERRQUEUE); 857 853 858 - skb = skb_recv_datagram(sk, flags, noblock, &err); 854 + skb = skb_recv_datagram(sk, flags, &err); 859 855 if (!skb) 860 856 return err; 861 857
+2 -3
net/core/datagram.c
··· 310 310 EXPORT_SYMBOL(__skb_recv_datagram); 311 311 312 312 struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned int flags, 313 - int noblock, int *err) 313 + int *err) 314 314 { 315 315 int off = 0; 316 316 317 - return __skb_recv_datagram(sk, &sk->sk_receive_queue, 318 - flags | (noblock ? MSG_DONTWAIT : 0), 317 + return __skb_recv_datagram(sk, &sk->sk_receive_queue, flags, 319 318 &off, err); 320 319 } 321 320 EXPORT_SYMBOL(skb_recv_datagram);
+4 -2
net/ieee802154/socket.c
··· 314 314 int err = -EOPNOTSUPP; 315 315 struct sk_buff *skb; 316 316 317 - skb = skb_recv_datagram(sk, flags, noblock, &err); 317 + flags |= (noblock ? MSG_DONTWAIT : 0); 318 + skb = skb_recv_datagram(sk, flags, &err); 318 319 if (!skb) 319 320 goto out; 320 321 ··· 704 703 struct dgram_sock *ro = dgram_sk(sk); 705 704 DECLARE_SOCKADDR(struct sockaddr_ieee802154 *, saddr, msg->msg_name); 706 705 707 - skb = skb_recv_datagram(sk, flags, noblock, &err); 706 + flags |= (noblock ? MSG_DONTWAIT : 0); 707 + skb = skb_recv_datagram(sk, flags, &err); 708 708 if (!skb) 709 709 goto out; 710 710
+2 -1
net/ipv4/ping.c
··· 861 861 if (flags & MSG_ERRQUEUE) 862 862 return inet_recv_error(sk, msg, len, addr_len); 863 863 864 - skb = skb_recv_datagram(sk, flags, noblock, &err); 864 + flags |= (noblock ? MSG_DONTWAIT : 0); 865 + skb = skb_recv_datagram(sk, flags, &err); 865 866 if (!skb) 866 867 goto out; 867 868
+2 -1
net/ipv4/raw.c
··· 769 769 goto out; 770 770 } 771 771 772 - skb = skb_recv_datagram(sk, flags, noblock, &err); 772 + flags |= (noblock ? MSG_DONTWAIT : 0); 773 + skb = skb_recv_datagram(sk, flags, &err); 773 774 if (!skb) 774 775 goto out; 775 776
+2 -1
net/ipv6/raw.c
··· 477 477 if (np->rxpmtu && np->rxopt.bits.rxpmtu) 478 478 return ipv6_recv_rxpmtu(sk, msg, len, addr_len); 479 479 480 - skb = skb_recv_datagram(sk, flags, noblock, &err); 480 + flags |= (noblock ? MSG_DONTWAIT : 0); 481 + skb = skb_recv_datagram(sk, flags, &err); 481 482 if (!skb) 482 483 goto out; 483 484
+1 -2
net/iucv/af_iucv.c
··· 1223 1223 static int iucv_sock_recvmsg(struct socket *sock, struct msghdr *msg, 1224 1224 size_t len, int flags) 1225 1225 { 1226 - int noblock = flags & MSG_DONTWAIT; 1227 1226 struct sock *sk = sock->sk; 1228 1227 struct iucv_sock *iucv = iucv_sk(sk); 1229 1228 unsigned int copied, rlen; ··· 1241 1242 1242 1243 /* receive/dequeue next skb: 1243 1244 * the function understands MSG_PEEK and, thus, does not dequeue skb */ 1244 - skb = skb_recv_datagram(sk, flags, noblock, &err); 1245 + skb = skb_recv_datagram(sk, flags, &err); 1245 1246 if (!skb) { 1246 1247 if (sk->sk_shutdown & RCV_SHUTDOWN) 1247 1248 return 0;
+1 -1
net/key/af_key.c
··· 3696 3696 if (flags & ~(MSG_PEEK|MSG_DONTWAIT|MSG_TRUNC|MSG_CMSG_COMPAT)) 3697 3697 goto out; 3698 3698 3699 - skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err); 3699 + skb = skb_recv_datagram(sk, flags, &err); 3700 3700 if (skb == NULL) 3701 3701 goto out; 3702 3702
+2 -1
net/l2tp/l2tp_ip.c
··· 526 526 if (flags & MSG_OOB) 527 527 goto out; 528 528 529 - skb = skb_recv_datagram(sk, flags, noblock, &err); 529 + flags |= (noblock ? MSG_DONTWAIT : 0); 530 + skb = skb_recv_datagram(sk, flags, &err); 530 531 if (!skb) 531 532 goto out; 532 533
+2 -1
net/l2tp/l2tp_ip6.c
··· 671 671 if (flags & MSG_ERRQUEUE) 672 672 return ipv6_recv_error(sk, msg, len, addr_len); 673 673 674 - skb = skb_recv_datagram(sk, flags, noblock, &err); 674 + flags |= (noblock ? MSG_DONTWAIT : 0); 675 + skb = skb_recv_datagram(sk, flags, &err); 675 676 if (!skb) 676 677 goto out; 677 678
+1 -2
net/l2tp/l2tp_ppp.c
··· 191 191 goto end; 192 192 193 193 err = 0; 194 - skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 195 - flags & MSG_DONTWAIT, &err); 194 + skb = skb_recv_datagram(sk, flags, &err); 196 195 if (!skb) 197 196 goto end; 198 197
+1 -1
net/mctp/af_mctp.c
··· 196 196 if (flags & ~(MSG_DONTWAIT | MSG_TRUNC | MSG_PEEK)) 197 197 return -EOPNOTSUPP; 198 198 199 - skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &rc); 199 + skb = skb_recv_datagram(sk, flags, &rc); 200 200 if (!skb) 201 201 return rc; 202 202
+4 -4
net/mctp/test/route-test.c
··· 352 352 if (params->deliver) { 353 353 KUNIT_EXPECT_EQ(test, rc, 0); 354 354 355 - skb2 = skb_recv_datagram(sock->sk, 0, 1, &rc); 355 + skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 356 356 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2); 357 357 KUNIT_EXPECT_EQ(test, skb->len, 1); 358 358 ··· 360 360 361 361 } else { 362 362 KUNIT_EXPECT_NE(test, rc, 0); 363 - skb2 = skb_recv_datagram(sock->sk, 0, 1, &rc); 363 + skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 364 364 KUNIT_EXPECT_PTR_EQ(test, skb2, NULL); 365 365 } 366 366 ··· 423 423 rc = mctp_route_input(&rt->rt, skb); 424 424 } 425 425 426 - skb2 = skb_recv_datagram(sock->sk, 0, 1, &rc); 426 + skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 427 427 428 428 if (params->rx_len) { 429 429 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2); ··· 582 582 rc = mctp_route_input(&rt->rt, skb); 583 583 584 584 /* (potentially) receive message */ 585 - skb2 = skb_recv_datagram(sock->sk, 0, 1, &rc); 585 + skb2 = skb_recv_datagram(sock->sk, MSG_DONTWAIT, &rc); 586 586 587 587 if (params->deliver) 588 588 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, skb2);
+1 -2
net/netlink/af_netlink.c
··· 1931 1931 struct scm_cookie scm; 1932 1932 struct sock *sk = sock->sk; 1933 1933 struct netlink_sock *nlk = nlk_sk(sk); 1934 - int noblock = flags & MSG_DONTWAIT; 1935 1934 size_t copied; 1936 1935 struct sk_buff *skb, *data_skb; 1937 1936 int err, ret; ··· 1940 1941 1941 1942 copied = 0; 1942 1943 1943 - skb = skb_recv_datagram(sk, flags, noblock, &err); 1944 + skb = skb_recv_datagram(sk, flags, &err); 1944 1945 if (skb == NULL) 1945 1946 goto out; 1946 1947
+2 -1
net/netrom/af_netrom.c
··· 1159 1159 } 1160 1160 1161 1161 /* Now we can treat all alike */ 1162 - if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL) { 1162 + skb = skb_recv_datagram(sk, flags, &er); 1163 + if (!skb) { 1163 1164 release_sock(sk); 1164 1165 return er; 1165 1166 }
+1 -2
net/nfc/llcp_sock.c
··· 821 821 static int llcp_sock_recvmsg(struct socket *sock, struct msghdr *msg, 822 822 size_t len, int flags) 823 823 { 824 - int noblock = flags & MSG_DONTWAIT; 825 824 struct sock *sk = sock->sk; 826 825 unsigned int copied, rlen; 827 826 struct sk_buff *skb, *cskb; ··· 841 842 if (flags & (MSG_OOB)) 842 843 return -EOPNOTSUPP; 843 844 844 - skb = skb_recv_datagram(sk, flags, noblock, &err); 845 + skb = skb_recv_datagram(sk, flags, &err); 845 846 if (!skb) { 846 847 pr_err("Recv datagram failed state %d %d %d", 847 848 sk->sk_state, err, sock_error(sk));
+1 -2
net/nfc/rawsock.c
··· 238 238 static int rawsock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, 239 239 int flags) 240 240 { 241 - int noblock = flags & MSG_DONTWAIT; 242 241 struct sock *sk = sock->sk; 243 242 struct sk_buff *skb; 244 243 int copied; ··· 245 246 246 247 pr_debug("sock=%p sk=%p len=%zu flags=%d\n", sock, sk, len, flags); 247 248 248 - skb = skb_recv_datagram(sk, flags, noblock, &rc); 249 + skb = skb_recv_datagram(sk, flags, &rc); 249 250 if (!skb) 250 251 return rc; 251 252
+1 -1
net/packet/af_packet.c
··· 3421 3421 * but then it will block. 3422 3422 */ 3423 3423 3424 - skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err); 3424 + skb = skb_recv_datagram(sk, flags, &err); 3425 3425 3426 3426 /* 3427 3427 * An error occurred so return it. Because skb_recv_datagram()
+2 -1
net/phonet/datagram.c
··· 123 123 MSG_CMSG_COMPAT)) 124 124 goto out_nofree; 125 125 126 - skb = skb_recv_datagram(sk, flags, noblock, &rval); 126 + flags |= (noblock ? MSG_DONTWAIT : 0); 127 + skb = skb_recv_datagram(sk, flags, &rval); 127 128 if (skb == NULL) 128 129 goto out_nofree; 129 130
+4 -2
net/phonet/pep.c
··· 772 772 u8 pipe_handle, enabled, n_sb; 773 773 u8 aligned = 0; 774 774 775 - skb = skb_recv_datagram(sk, 0, flags & O_NONBLOCK, errp); 775 + skb = skb_recv_datagram(sk, (flags & O_NONBLOCK) ? MSG_DONTWAIT : 0, 776 + errp); 776 777 if (!skb) 777 778 return NULL; 778 779 ··· 1268 1267 return -EINVAL; 1269 1268 } 1270 1269 1271 - skb = skb_recv_datagram(sk, flags, noblock, &err); 1270 + flags |= (noblock ? MSG_DONTWAIT : 0); 1271 + skb = skb_recv_datagram(sk, flags, &err); 1272 1272 lock_sock(sk); 1273 1273 if (skb == NULL) { 1274 1274 if (err == -ENOTCONN && sk->sk_state == TCP_CLOSE_WAIT)
+1 -2
net/qrtr/af_qrtr.c
··· 1035 1035 return -EADDRNOTAVAIL; 1036 1036 } 1037 1037 1038 - skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 1039 - flags & MSG_DONTWAIT, &rc); 1038 + skb = skb_recv_datagram(sk, flags, &rc); 1040 1039 if (!skb) { 1041 1040 release_sock(sk); 1042 1041 return rc;
+2 -1
net/rose/af_rose.c
··· 1230 1230 return -ENOTCONN; 1231 1231 1232 1232 /* Now we can treat all alike */ 1233 - if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL) 1233 + skb = skb_recv_datagram(sk, flags, &er); 1234 + if (!skb) 1234 1235 return er; 1235 1236 1236 1237 qbit = (skb->data[0] & ROSE_Q_BIT) == ROSE_Q_BIT;
+3 -2
net/unix/af_unix.c
··· 1643 1643 * so that no locks are necessary. 1644 1644 */ 1645 1645 1646 - skb = skb_recv_datagram(sk, 0, flags&O_NONBLOCK, &err); 1646 + skb = skb_recv_datagram(sk, (flags & O_NONBLOCK) ? MSG_DONTWAIT : 0, 1647 + &err); 1647 1648 if (!skb) { 1648 1649 /* This means receive shutdown. */ 1649 1650 if (err == 0) ··· 2501 2500 int used, err; 2502 2501 2503 2502 mutex_lock(&u->iolock); 2504 - skb = skb_recv_datagram(sk, 0, 1, &err); 2503 + skb = skb_recv_datagram(sk, MSG_DONTWAIT, &err); 2505 2504 mutex_unlock(&u->iolock); 2506 2505 if (!skb) 2507 2506 return err;
+1 -4
net/vmw_vsock/vmci_transport.c
··· 1732 1732 int flags) 1733 1733 { 1734 1734 int err; 1735 - int noblock; 1736 1735 struct vmci_datagram *dg; 1737 1736 size_t payload_len; 1738 1737 struct sk_buff *skb; 1739 - 1740 - noblock = flags & MSG_DONTWAIT; 1741 1738 1742 1739 if (flags & MSG_OOB || flags & MSG_ERRQUEUE) 1743 1740 return -EOPNOTSUPP; 1744 1741 1745 1742 /* Retrieve the head sk_buff from the socket's receive queue. */ 1746 1743 err = 0; 1747 - skb = skb_recv_datagram(&vsk->sk, flags, noblock, &err); 1744 + skb = skb_recv_datagram(&vsk->sk, flags, &err); 1748 1745 if (!skb) 1749 1746 return err; 1750 1747
+1 -2
net/x25/af_x25.c
··· 1315 1315 } else { 1316 1316 /* Now we can treat all alike */ 1317 1317 release_sock(sk); 1318 - skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 1319 - flags & MSG_DONTWAIT, &rc); 1318 + skb = skb_recv_datagram(sk, flags, &rc); 1320 1319 lock_sock(sk); 1321 1320 if (!skb) 1322 1321 goto out;