net: add queue argument to __skb_wait_for_more_packets and __skb_{,try_}recv_datagram

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

This will be used by ESP over TCP to handle the queue of IKE messages.

Signed-off-by: Sabrina Dubroca <sd@queasysnail.net>
Acked-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Steffen Klassert <steffen.klassert@secunet.com>

authored by

Sabrina Dubroca and committed by

Steffen Klassert 6 years ago b50b0580 e7096c13

+31 -17

4 changed files

expand all

include

linux

skbuff.h

net

core

datagram.c

ipv4

udp.c

unix

af_unix.c

+8 -3

include/linux/skbuff.h

··· 3459 3459 for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next) 3460 3460 3461 3461 3462 - int __skb_wait_for_more_packets(struct sock *sk, int *err, long *timeo_p, 3462 + int __skb_wait_for_more_packets(struct sock *sk, struct sk_buff_head *queue, 3463 + int *err, long *timeo_p, 3463 3464 const struct sk_buff *skb); 3464 3465 struct sk_buff *__skb_try_recv_from_queue(struct sock *sk, 3465 3466 struct sk_buff_head *queue, ··· 3469 3468 struct sk_buff *skb), 3470 3469 int *off, int *err, 3471 3470 struct sk_buff **last); 3472 - struct sk_buff *__skb_try_recv_datagram(struct sock *sk, unsigned flags, 3471 + struct sk_buff *__skb_try_recv_datagram(struct sock *sk, 3472 + struct sk_buff_head *queue, 3473 + unsigned int flags, 3473 3474 void (*destructor)(struct sock *sk, 3474 3475 struct sk_buff *skb), 3475 3476 int *off, int *err, 3476 3477 struct sk_buff **last); 3477 - struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags, 3478 + struct sk_buff *__skb_recv_datagram(struct sock *sk, 3479 + struct sk_buff_head *sk_queue, 3480 + unsigned int flags, 3478 3481 void (*destructor)(struct sock *sk, 3479 3482 struct sk_buff *skb), 3480 3483 int *off, int *err);

+17 -10

net/core/datagram.c

··· 84 84 /* 85 85 * Wait for the last received packet to be different from skb 86 86 */ 87 - int __skb_wait_for_more_packets(struct sock *sk, int *err, long *timeo_p, 87 + int __skb_wait_for_more_packets(struct sock *sk, struct sk_buff_head *queue, 88 + int *err, long *timeo_p, 88 89 const struct sk_buff *skb) 89 90 { 90 91 int error; ··· 98 97 if (error) 99 98 goto out_err; 100 99 101 - if (READ_ONCE(sk->sk_receive_queue.prev) != skb) 100 + if (READ_ONCE(queue->prev) != skb) 102 101 goto out; 103 102 104 103 /* Socket shut down? */ ··· 210 209 /** 211 210 * __skb_try_recv_datagram - Receive a datagram skbuff 212 211 * @sk: socket 212 + * @queue: socket queue from which to receive 213 213 * @flags: MSG\_ flags 214 214 * @destructor: invoked under the receive lock on successful dequeue 215 215 * @off: an offset in bytes to peek skb from. Returns an offset ··· 243 241 * quite explicitly by POSIX 1003.1g, don't change them without having 244 242 * the standard around please. 245 243 */ 246 - struct sk_buff *__skb_try_recv_datagram(struct sock *sk, unsigned int flags, 244 + struct sk_buff *__skb_try_recv_datagram(struct sock *sk, 245 + struct sk_buff_head *queue, 246 + unsigned int flags, 247 247 void (*destructor)(struct sock *sk, 248 248 struct sk_buff *skb), 249 249 int *off, int *err, 250 250 struct sk_buff **last) 251 251 { 252 - struct sk_buff_head *queue = &sk->sk_receive_queue; 253 252 struct sk_buff *skb; 254 253 unsigned long cpu_flags; 255 254 /* ··· 281 278 break; 282 279 283 280 sk_busy_loop(sk, flags & MSG_DONTWAIT); 284 - } while (READ_ONCE(sk->sk_receive_queue.prev) != *last); 281 + } while (READ_ONCE(queue->prev) != *last); 285 282 286 283 error = -EAGAIN; 287 284 ··· 291 288 } 292 289 EXPORT_SYMBOL(__skb_try_recv_datagram); 293 290 294 - struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned int flags, 291 + struct sk_buff *__skb_recv_datagram(struct sock *sk, 292 + struct sk_buff_head *sk_queue, 293 + unsigned int flags, 295 294 void (*destructor)(struct sock *sk, 296 295 struct sk_buff *skb), 297 296 int *off, int *err) ··· 304 299 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 305 300 306 301 do { 307 - skb = __skb_try_recv_datagram(sk, flags, destructor, off, err, 308 - &last); 302 + skb = __skb_try_recv_datagram(sk, sk_queue, flags, destructor, 303 + off, err, &last); 309 304 if (skb) 310 305 return skb; 311 306 312 307 if (*err != -EAGAIN) 313 308 break; 314 309 } while (timeo && 315 - !__skb_wait_for_more_packets(sk, err, &timeo, last)); 310 + !__skb_wait_for_more_packets(sk, sk_queue, err, 311 + &timeo, last)); 316 312 317 313 return NULL; 318 314 } ··· 324 318 { 325 319 int off = 0; 326 320 327 - return __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0), 321 + return __skb_recv_datagram(sk, &sk->sk_receive_queue, 322 + flags | (noblock ? MSG_DONTWAIT : 0), 328 323 NULL, &off, err); 329 324 } 330 325 EXPORT_SYMBOL(skb_recv_datagram);

+2 -1

net/ipv4/udp.c

··· 1708 1708 1709 1709 /* sk_queue is empty, reader_queue may contain peeked packets */ 1710 1710 } while (timeo && 1711 - !__skb_wait_for_more_packets(sk, &error, &timeo, 1711 + !__skb_wait_for_more_packets(sk, &sk->sk_receive_queue, 1712 + &error, &timeo, 1712 1713 (struct sk_buff *)sk_queue)); 1713 1714 1714 1715 *err = error;

+4 -3

net/unix/af_unix.c

··· 2058 2058 mutex_lock(&u->iolock); 2059 2059 2060 2060 skip = sk_peek_offset(sk, flags); 2061 - skb = __skb_try_recv_datagram(sk, flags, NULL, &skip, &err, 2062 - &last); 2061 + skb = __skb_try_recv_datagram(sk, &sk->sk_receive_queue, flags, 2062 + NULL, &skip, &err, &last); 2063 2063 if (skb) 2064 2064 break; 2065 2065 ··· 2068 2068 if (err != -EAGAIN) 2069 2069 break; 2070 2070 } while (timeo && 2071 - !__skb_wait_for_more_packets(sk, &err, &timeo, last)); 2071 + !__skb_wait_for_more_packets(sk, &sk->sk_receive_queue, 2072 + &err, &timeo, last)); 2072 2073 2073 2074 if (!skb) { /* implies iolock unlocked */ 2074 2075 unix_state_lock(sk);