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: use sk_sleep()

Commit aa395145 (net: sk_sleep() helper) missed three files in the
conversion.

Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

authored by

Eric Dumazet and committed by
David S. Miller 4a4771a5 be9e969d

+21 -21
+3 -3
drivers/net/macvtap.c
··· 181 181 return -ENOLINK; 182 182 183 183 skb_queue_tail(&q->sk.sk_receive_queue, skb); 184 - wake_up_interruptible_poll(q->sk.sk_sleep, POLLIN | POLLRDNORM | POLLRDBAND); 184 + wake_up_interruptible_poll(sk_sleep(&q->sk), POLLIN | POLLRDNORM | POLLRDBAND); 185 185 return 0; 186 186 } 187 187 ··· 562 562 struct sk_buff *skb; 563 563 ssize_t ret = 0; 564 564 565 - add_wait_queue(q->sk.sk_sleep, &wait); 565 + add_wait_queue(sk_sleep(&q->sk), &wait); 566 566 while (len) { 567 567 current->state = TASK_INTERRUPTIBLE; 568 568 ··· 587 587 } 588 588 589 589 current->state = TASK_RUNNING; 590 - remove_wait_queue(q->sk.sk_sleep, &wait); 590 + remove_wait_queue(sk_sleep(&q->sk), &wait); 591 591 return ret; 592 592 } 593 593
+15 -15
net/caif/caif_socket.c
··· 169 169 170 170 /* Signal reader that data is available. */ 171 171 172 - wake_up_interruptible(cf_sk->sk.sk_sleep); 172 + wake_up_interruptible(sk_sleep(&cf_sk->sk)); 173 173 174 174 return 0; 175 175 } ··· 203 203 dbfs_atomic_inc(&cnt.num_tx_flow_on_ind); 204 204 /* Signal reader that data is available. */ 205 205 SET_TX_FLOW_ON(cf_sk); 206 - wake_up_interruptible(cf_sk->sk.sk_sleep); 206 + wake_up_interruptible(sk_sleep(&cf_sk->sk)); 207 207 break; 208 208 209 209 case CAIF_CTRLCMD_FLOW_OFF_IND: ··· 217 217 caif_assert(STATE_IS_OPEN(cf_sk)); 218 218 SET_PENDING_OFF(cf_sk); 219 219 SET_TX_FLOW_ON(cf_sk); 220 - wake_up_interruptible(cf_sk->sk.sk_sleep); 220 + wake_up_interruptible(sk_sleep(&cf_sk->sk)); 221 221 break; 222 222 223 223 case CAIF_CTRLCMD_DEINIT_RSP: ··· 225 225 caif_assert(!STATE_IS_OPEN(cf_sk)); 226 226 SET_PENDING_OFF(cf_sk); 227 227 if (!STATE_IS_PENDING_DESTROY(cf_sk)) { 228 - if (cf_sk->sk.sk_sleep != NULL) 229 - wake_up_interruptible(cf_sk->sk.sk_sleep); 228 + if (sk_sleep(&cf_sk->sk) != NULL) 229 + wake_up_interruptible(sk_sleep(&cf_sk->sk)); 230 230 } 231 231 dbfs_atomic_inc(&cnt.num_deinit); 232 232 sock_put(&cf_sk->sk); ··· 238 238 SET_STATE_CLOSED(cf_sk); 239 239 SET_PENDING_OFF(cf_sk); 240 240 SET_TX_FLOW_OFF(cf_sk); 241 - wake_up_interruptible(cf_sk->sk.sk_sleep); 241 + wake_up_interruptible(sk_sleep(&cf_sk->sk)); 242 242 break; 243 243 244 244 case CAIF_CTRLCMD_REMOTE_SHUTDOWN_IND: ··· 247 247 /* Use sk_shutdown to indicate remote shutdown indication */ 248 248 cf_sk->sk.sk_shutdown |= RCV_SHUTDOWN; 249 249 cf_sk->file_mode = 0; 250 - wake_up_interruptible(cf_sk->sk.sk_sleep); 250 + wake_up_interruptible(sk_sleep(&cf_sk->sk)); 251 251 break; 252 252 253 253 default: ··· 325 325 release_sock(&cf_sk->sk); 326 326 327 327 result = 328 - wait_event_interruptible(*cf_sk->sk.sk_sleep, 328 + wait_event_interruptible(*sk_sleep(&cf_sk->sk), 329 329 !STATE_IS_PENDING(cf_sk)); 330 330 331 331 lock_sock(&(cf_sk->sk)); ··· 365 365 release_sock(&cf_sk->sk); 366 366 367 367 /* Block reader until data arrives or socket is closed. */ 368 - if (wait_event_interruptible(*cf_sk->sk.sk_sleep, 368 + if (wait_event_interruptible(*sk_sleep(&cf_sk->sk), 369 369 cfpkt_qpeek(cf_sk->pktq) 370 370 || STATE_IS_REMOTE_SHUTDOWN(cf_sk) 371 371 || !STATE_IS_OPEN(cf_sk)) == ··· 537 537 * for its conclusion. 538 538 */ 539 539 result = 540 - wait_event_interruptible(*cf_sk->sk.sk_sleep, 540 + wait_event_interruptible(*sk_sleep(&cf_sk->sk), 541 541 !STATE_IS_PENDING(cf_sk)); 542 542 /* I want to be alone on cf_sk (except status and queue) */ 543 543 lock_sock(&(cf_sk->sk)); ··· 573 573 release_sock(&cf_sk->sk); 574 574 575 575 /* Wait until flow is on or socket is closed */ 576 - if (wait_event_interruptible(*cf_sk->sk.sk_sleep, 576 + if (wait_event_interruptible(*sk_sleep(&cf_sk->sk), 577 577 TX_FLOW_IS_ON(cf_sk) 578 578 || !STATE_IS_OPEN(cf_sk) 579 579 || STATE_IS_REMOTE_SHUTDOWN(cf_sk) ··· 650 650 release_sock(&cf_sk->sk); 651 651 652 652 /* Wait until flow is on or socket is closed */ 653 - if (wait_event_interruptible(*cf_sk->sk.sk_sleep, 653 + if (wait_event_interruptible(*sk_sleep(&cf_sk->sk), 654 654 TX_FLOW_IS_ON(cf_sk) 655 655 || !STATE_IS_OPEN(cf_sk) 656 656 || STATE_IS_REMOTE_SHUTDOWN(cf_sk) ··· 898 898 * for its conclusion. 899 899 */ 900 900 result = 901 - wait_event_interruptible(*cf_sk->sk.sk_sleep, 901 + wait_event_interruptible(*sk_sleep(&cf_sk->sk), 902 902 !STATE_IS_PENDING(cf_sk)); 903 903 904 904 lock_sock(&(cf_sk->sk)); ··· 965 965 release_sock(&cf_sk->sk); 966 966 967 967 result = 968 - wait_event_interruptible(*cf_sk->sk.sk_sleep, 968 + wait_event_interruptible(*sk_sleep(&cf_sk->sk), 969 969 !STATE_IS_PENDING(cf_sk)); 970 970 971 971 lock_sock(&(cf_sk->sk)); ··· 1107 1107 * CAIF stack. 1108 1108 */ 1109 1109 if (!(sock->file->f_flags & O_NONBLOCK)) { 1110 - res = wait_event_interruptible(*cf_sk->sk.sk_sleep, 1110 + res = wait_event_interruptible(*sk_sleep(&cf_sk->sk), 1111 1111 !STATE_IS_PENDING(cf_sk)); 1112 1112 1113 1113 if (res == -ERESTARTSYS) {
+3 -3
net/rxrpc/ar-recvmsg.c
··· 91 91 92 92 /* wait for a message to turn up */ 93 93 release_sock(&rx->sk); 94 - prepare_to_wait_exclusive(rx->sk.sk_sleep, &wait, 94 + prepare_to_wait_exclusive(sk_sleep(&rx->sk), &wait, 95 95 TASK_INTERRUPTIBLE); 96 96 ret = sock_error(&rx->sk); 97 97 if (ret) ··· 102 102 goto wait_interrupted; 103 103 timeo = schedule_timeout(timeo); 104 104 } 105 - finish_wait(rx->sk.sk_sleep, &wait); 105 + finish_wait(sk_sleep(&rx->sk), &wait); 106 106 lock_sock(&rx->sk); 107 107 continue; 108 108 } ··· 356 356 wait_interrupted: 357 357 ret = sock_intr_errno(timeo); 358 358 wait_error: 359 - finish_wait(rx->sk.sk_sleep, &wait); 359 + finish_wait(sk_sleep(&rx->sk), &wait); 360 360 if (continue_call) 361 361 rxrpc_put_call(continue_call); 362 362 if (copied)