Merge branch 'net-smc-socket-closing-improvements'

+17 -23

net/smc/af_smc.c

··· 581 581 582 582 static int smc_clcsock_accept(struct smc_sock *lsmc, struct smc_sock **new_smc) 583 583 { 584 - struct sock *sk = &lsmc->sk; 585 - struct socket *new_clcsock; 584 + struct socket *new_clcsock = NULL; 585 + struct sock *lsk = &lsmc->sk; 586 586 struct sock *new_sk; 587 587 int rc; 588 588 589 - release_sock(&lsmc->sk); 590 - new_sk = smc_sock_alloc(sock_net(sk), NULL); 589 + release_sock(lsk); 590 + new_sk = smc_sock_alloc(sock_net(lsk), NULL); 591 591 if (!new_sk) { 592 592 rc = -ENOMEM; 593 - lsmc->sk.sk_err = ENOMEM; 593 + lsk->sk_err = ENOMEM; 594 594 *new_smc = NULL; 595 - lock_sock(&lsmc->sk); 595 + lock_sock(lsk); 596 596 goto out; 597 597 } 598 598 *new_smc = smc_sk(new_sk); 599 599 600 600 rc = kernel_accept(lsmc->clcsock, &new_clcsock, 0); 601 - lock_sock(&lsmc->sk); 602 - if (rc < 0) { 603 - lsmc->sk.sk_err = -rc; 604 - new_sk->sk_state = SMC_CLOSED; 605 - sock_set_flag(new_sk, SOCK_DEAD); 606 - sk->sk_prot->unhash(new_sk); 607 - sock_put(new_sk); 608 - *new_smc = NULL; 609 - goto out; 610 - } 611 - if (lsmc->sk.sk_state == SMC_CLOSED) { 601 + lock_sock(lsk); 602 + if (rc < 0) 603 + lsk->sk_err = -rc; 604 + if (rc < 0 || lsk->sk_state == SMC_CLOSED) { 612 605 if (new_clcsock) 613 606 sock_release(new_clcsock); 614 607 new_sk->sk_state = SMC_CLOSED; 615 608 sock_set_flag(new_sk, SOCK_DEAD); 616 - sk->sk_prot->unhash(new_sk); 609 + new_sk->sk_prot->unhash(new_sk); 617 610 sock_put(new_sk); 618 611 *new_smc = NULL; 619 612 goto out; ··· 929 936 { 930 937 struct smc_sock *lsmc = container_of(work, struct smc_sock, 931 938 tcp_listen_work); 939 + struct sock *lsk = &lsmc->sk; 932 940 struct smc_sock *new_smc; 933 941 int rc = 0; 934 942 935 - lock_sock(&lsmc->sk); 936 - while (lsmc->sk.sk_state == SMC_LISTEN) { 943 + lock_sock(lsk); 944 + while (lsk->sk_state == SMC_LISTEN) { 937 945 rc = smc_clcsock_accept(lsmc, &new_smc); 938 946 if (rc) 939 947 goto out; ··· 943 949 944 950 new_smc->listen_smc = lsmc; 945 951 new_smc->use_fallback = false; /* assume rdma capability first*/ 946 - sock_hold(&lsmc->sk); /* sock_put in smc_listen_work */ 952 + sock_hold(lsk); /* sock_put in smc_listen_work */ 947 953 INIT_WORK(&new_smc->smc_listen_work, smc_listen_work); 948 954 smc_copy_sock_settings_to_smc(new_smc); 949 955 schedule_work(&new_smc->smc_listen_work); 950 956 } 951 957 952 958 out: 953 - release_sock(&lsmc->sk); 954 - lsmc->sk.sk_data_ready(&lsmc->sk); /* no more listening, wake accept */ 959 + release_sock(lsk); 960 + lsk->sk_data_ready(lsk); /* no more listening, wake accept */ 955 961 } 956 962 957 963 static int smc_listen(struct socket *sock, int backlog)

-11

net/smc/smc_cdc.c

··· 57 57 cdcpend->conn); 58 58 } 59 59 smc_tx_sndbuf_nonfull(smc); 60 - if (smc->sk.sk_state != SMC_ACTIVE) 61 - /* wake up smc_close_wait_tx_pends() */ 62 - smc->sk.sk_state_change(&smc->sk); 63 60 bh_unlock_sock(&smc->sk); 64 61 } 65 62 ··· 150 153 smc_wr_tx_dismiss_slots(link, SMC_CDC_MSG_TYPE, 151 154 smc_cdc_tx_filter, smc_cdc_tx_dismisser, 152 155 (unsigned long)conn); 153 - } 154 - 155 - bool smc_cdc_tx_has_pending(struct smc_connection *conn) 156 - { 157 - struct smc_link *link = &conn->lgr->lnk[SMC_SINGLE_LINK]; 158 - 159 - return smc_wr_tx_has_pending(link, SMC_CDC_MSG_TYPE, 160 - smc_cdc_tx_filter, (unsigned long)conn); 161 156 } 162 157 163 158 /********************************* receive ***********************************/

-1

net/smc/smc_cdc.h

··· 214 214 int smc_cdc_msg_send(struct smc_connection *conn, struct smc_wr_buf *wr_buf, 215 215 struct smc_cdc_tx_pend *pend); 216 216 int smc_cdc_get_slot_and_msg_send(struct smc_connection *conn); 217 - bool smc_cdc_tx_has_pending(struct smc_connection *conn); 218 217 int smc_cdc_init(void) __init; 219 218 220 219 #endif /* SMC_CDC_H */

+46 -57

net/smc/smc_close.c

··· 19 19 #include "smc_cdc.h" 20 20 #include "smc_close.h" 21 21 22 - #define SMC_CLOSE_WAIT_TX_PENDS_TIME (5 * HZ) 23 - 24 22 static void smc_close_cleanup_listen(struct sock *parent) 25 23 { 26 24 struct sock *sk; ··· 26 28 /* Close non-accepted connections */ 27 29 while ((sk = smc_accept_dequeue(parent, NULL))) 28 30 smc_close_non_accepted(sk); 29 - } 30 - 31 - static void smc_close_wait_tx_pends(struct smc_sock *smc) 32 - { 33 - DEFINE_WAIT_FUNC(wait, woken_wake_function); 34 - struct sock *sk = &smc->sk; 35 - signed long timeout; 36 - 37 - timeout = SMC_CLOSE_WAIT_TX_PENDS_TIME; 38 - add_wait_queue(sk_sleep(sk), &wait); 39 - while (!signal_pending(current) && timeout) { 40 - int rc; 41 - 42 - rc = sk_wait_event(sk, &timeout, 43 - !smc_cdc_tx_has_pending(&smc->conn), 44 - &wait); 45 - if (rc) 46 - break; 47 - } 48 - remove_wait_queue(sk_sleep(sk), &wait); 49 31 } 50 32 51 33 /* wait for sndbuf data being transmitted */ ··· 93 115 */ 94 116 static void smc_close_active_abort(struct smc_sock *smc) 95 117 { 118 + struct sock *sk = &smc->sk; 119 + 96 120 struct smc_cdc_conn_state_flags *txflags = 97 121 &smc->conn.local_tx_ctrl.conn_state_flags; 98 122 99 - smc->sk.sk_err = ECONNABORTED; 123 + sk->sk_err = ECONNABORTED; 100 124 if (smc->clcsock && smc->clcsock->sk) { 101 125 smc->clcsock->sk->sk_err = ECONNABORTED; 102 126 smc->clcsock->sk->sk_state_change(smc->clcsock->sk); 103 127 } 104 - switch (smc->sk.sk_state) { 128 + switch (sk->sk_state) { 105 129 case SMC_INIT: 106 130 case SMC_ACTIVE: 107 - smc->sk.sk_state = SMC_PEERABORTWAIT; 131 + sk->sk_state = SMC_PEERABORTWAIT; 108 132 break; 109 133 case SMC_APPCLOSEWAIT1: 110 134 case SMC_APPCLOSEWAIT2: 111 135 txflags->peer_conn_abort = 1; 112 136 sock_release(smc->clcsock); 113 137 if (!smc_cdc_rxed_any_close(&smc->conn)) 114 - smc->sk.sk_state = SMC_PEERABORTWAIT; 138 + sk->sk_state = SMC_PEERABORTWAIT; 115 139 else 116 - smc->sk.sk_state = SMC_CLOSED; 140 + sk->sk_state = SMC_CLOSED; 117 141 break; 118 142 case SMC_PEERCLOSEWAIT1: 119 143 case SMC_PEERCLOSEWAIT2: 120 144 if (!txflags->peer_conn_closed) { 121 - smc->sk.sk_state = SMC_PEERABORTWAIT; 145 + sk->sk_state = SMC_PEERABORTWAIT; 122 146 txflags->peer_conn_abort = 1; 123 147 sock_release(smc->clcsock); 124 148 } else { 125 - smc->sk.sk_state = SMC_CLOSED; 149 + sk->sk_state = SMC_CLOSED; 126 150 } 127 151 break; 128 152 case SMC_PROCESSABORT: ··· 133 153 txflags->peer_conn_abort = 1; 134 154 sock_release(smc->clcsock); 135 155 } 136 - smc->sk.sk_state = SMC_CLOSED; 156 + sk->sk_state = SMC_CLOSED; 137 157 break; 138 158 case SMC_PEERFINCLOSEWAIT: 139 159 case SMC_PEERABORTWAIT: ··· 141 161 break; 142 162 } 143 163 144 - sock_set_flag(&smc->sk, SOCK_DEAD); 145 - smc->sk.sk_state_change(&smc->sk); 164 + sock_set_flag(sk, SOCK_DEAD); 165 + sk->sk_state_change(sk); 146 166 } 147 167 148 168 static inline bool smc_close_sent_any_close(struct smc_connection *conn) ··· 165 185 0 : sock_flag(sk, SOCK_LINGER) ? 166 186 sk->sk_lingertime : SMC_MAX_STREAM_WAIT_TIMEOUT; 167 187 168 - again: 169 188 old_state = sk->sk_state; 170 - switch (old_state) { 189 + again: 190 + switch (sk->sk_state) { 171 191 case SMC_INIT: 172 192 sk->sk_state = SMC_CLOSED; 173 193 if (smc->smc_listen_work.func) ··· 194 214 if (sk->sk_state == SMC_ACTIVE) { 195 215 /* send close request */ 196 216 rc = smc_close_final(conn); 217 + if (rc) 218 + break; 197 219 sk->sk_state = SMC_PEERCLOSEWAIT1; 198 220 } else { 199 221 /* peer event has changed the state */ ··· 208 226 !smc_close_sent_any_close(conn)) { 209 227 /* just shutdown wr done, send close request */ 210 228 rc = smc_close_final(conn); 229 + if (rc) 230 + break; 211 231 } 212 232 sk->sk_state = SMC_CLOSED; 213 - smc_close_wait_tx_pends(smc); 214 233 break; 215 234 case SMC_APPCLOSEWAIT1: 216 235 case SMC_APPCLOSEWAIT2: ··· 220 237 release_sock(sk); 221 238 cancel_delayed_work_sync(&conn->tx_work); 222 239 lock_sock(sk); 223 - if (sk->sk_err != ECONNABORTED) { 224 - /* confirm close from peer */ 225 - rc = smc_close_final(conn); 226 - if (rc) 227 - break; 228 - } 240 + if (sk->sk_state != SMC_APPCLOSEWAIT1 && 241 + sk->sk_state != SMC_APPCLOSEWAIT2) 242 + goto again; 243 + /* confirm close from peer */ 244 + rc = smc_close_final(conn); 245 + if (rc) 246 + break; 229 247 if (smc_cdc_rxed_any_close(conn)) 230 248 /* peer has closed the socket already */ 231 249 sk->sk_state = SMC_CLOSED; 232 250 else 233 251 /* peer has just issued a shutdown write */ 234 252 sk->sk_state = SMC_PEERFINCLOSEWAIT; 235 - smc_close_wait_tx_pends(smc); 236 253 break; 237 254 case SMC_PEERCLOSEWAIT1: 238 255 case SMC_PEERCLOSEWAIT2: ··· 240 257 !smc_close_sent_any_close(conn)) { 241 258 /* just shutdown wr done, send close request */ 242 259 rc = smc_close_final(conn); 260 + if (rc) 261 + break; 243 262 } 244 263 /* peer sending PeerConnectionClosed will cause transition */ 245 264 break; ··· 254 269 lock_sock(sk); 255 270 smc_close_abort(conn); 256 271 sk->sk_state = SMC_CLOSED; 257 - smc_close_wait_tx_pends(smc); 258 272 break; 259 273 case SMC_PEERABORTWAIT: 260 274 case SMC_CLOSED: ··· 262 278 } 263 279 264 280 if (old_state != sk->sk_state) 265 - sk->sk_state_change(&smc->sk); 281 + sk->sk_state_change(sk); 266 282 return rc; 267 283 } 268 284 ··· 315 331 struct sock *sk = &smc->sk; 316 332 int old_state; 317 333 318 - lock_sock(&smc->sk); 334 + lock_sock(sk); 319 335 old_state = sk->sk_state; 320 336 321 337 if (!conn->alert_token_local) { ··· 324 340 goto wakeup; 325 341 } 326 342 327 - rxflags = &smc->conn.local_rx_ctrl.conn_state_flags; 343 + rxflags = &conn->local_rx_ctrl.conn_state_flags; 328 344 if (rxflags->peer_conn_abort) { 329 345 smc_close_passive_abort_received(smc); 330 346 goto wakeup; ··· 332 348 333 349 switch (sk->sk_state) { 334 350 case SMC_INIT: 335 - if (atomic_read(&smc->conn.bytes_to_rcv) || 351 + if (atomic_read(&conn->bytes_to_rcv) || 336 352 (rxflags->peer_done_writing && 337 353 !smc_cdc_rxed_any_close(conn))) 338 354 sk->sk_state = SMC_APPCLOSEWAIT1; ··· 349 365 /* to check for closing */ 350 366 case SMC_PEERCLOSEWAIT2: 351 367 case SMC_PEERFINCLOSEWAIT: 352 - if (!smc_cdc_rxed_any_close(&smc->conn)) 368 + if (!smc_cdc_rxed_any_close(conn)) 353 369 break; 354 370 if (sock_flag(sk, SOCK_DEAD) && 355 371 smc_close_sent_any_close(conn)) { ··· 378 394 sk->sk_state_change(sk); 379 395 if ((sk->sk_state == SMC_CLOSED) && 380 396 (sock_flag(sk, SOCK_DEAD) || !sk->sk_socket)) { 381 - smc_conn_free(&smc->conn); 397 + smc_conn_free(conn); 382 398 schedule_delayed_work(&smc->sock_put_work, 383 399 SMC_CLOSE_SOCK_PUT_DELAY); 384 400 } 385 401 } 386 - release_sock(&smc->sk); 402 + release_sock(sk); 387 403 } 388 404 389 405 void smc_close_sock_put_work(struct work_struct *work) ··· 408 424 0 : sock_flag(sk, SOCK_LINGER) ? 409 425 sk->sk_lingertime : SMC_MAX_STREAM_WAIT_TIMEOUT; 410 426 411 - again: 412 427 old_state = sk->sk_state; 413 - switch (old_state) { 428 + again: 429 + switch (sk->sk_state) { 414 430 case SMC_ACTIVE: 415 431 smc_close_stream_wait(smc, timeout); 416 432 release_sock(sk); 417 433 cancel_delayed_work_sync(&conn->tx_work); 418 434 lock_sock(sk); 435 + if (sk->sk_state != SMC_ACTIVE) 436 + goto again; 419 437 /* send close wr request */ 420 438 rc = smc_close_wr(conn); 421 - if (sk->sk_state == SMC_ACTIVE) 422 - sk->sk_state = SMC_PEERCLOSEWAIT1; 423 - else 424 - goto again; 439 + if (rc) 440 + break; 441 + sk->sk_state = SMC_PEERCLOSEWAIT1; 425 442 break; 426 443 case SMC_APPCLOSEWAIT1: 427 444 /* passive close */ ··· 431 446 release_sock(sk); 432 447 cancel_delayed_work_sync(&conn->tx_work); 433 448 lock_sock(sk); 449 + if (sk->sk_state != SMC_APPCLOSEWAIT1) 450 + goto again; 434 451 /* confirm close from peer */ 435 452 rc = smc_close_wr(conn); 453 + if (rc) 454 + break; 436 455 sk->sk_state = SMC_APPCLOSEWAIT2; 437 456 break; 438 457 case SMC_APPCLOSEWAIT2: ··· 451 462 } 452 463 453 464 if (old_state != sk->sk_state) 454 - sk->sk_state_change(&smc->sk); 465 + sk->sk_state_change(sk); 455 466 return rc; 456 467 } 457 468

+2 -2

net/smc/smc_tx.c

··· 86 86 rc = -EPIPE; 87 87 break; 88 88 } 89 - if (conn->local_rx_ctrl.conn_state_flags.peer_conn_abort) { 89 + if (smc_cdc_rxed_any_close(conn)) { 90 90 rc = -ECONNRESET; 91 91 break; 92 92 } ··· 107 107 sk_wait_event(sk, &timeo, 108 108 sk->sk_err || 109 109 (sk->sk_shutdown & SEND_SHUTDOWN) || 110 - smc_cdc_rxed_any_close_or_senddone(conn) || 110 + smc_cdc_rxed_any_close(conn) || 111 111 atomic_read(&conn->sndbuf_space), 112 112 &wait); 113 113 }

+6 -25

net/smc/smc_wr.c

··· 122 122 again: 123 123 polled++; 124 124 do { 125 + memset(&wc, 0, sizeof(wc)); 125 126 rc = ib_poll_cq(dev->roce_cq_send, SMC_WR_MAX_POLL_CQE, wc); 126 127 if (polled == 1) { 127 128 ib_req_notify_cq(dev->roce_cq_send, ··· 186 185 if (rc) 187 186 return rc; 188 187 } else { 189 - rc = wait_event_interruptible_timeout( 188 + rc = wait_event_timeout( 190 189 link->wr_tx_wait, 191 190 (smc_wr_tx_get_free_slot_index(link, &idx) != -EBUSY), 192 191 SMC_WR_TX_WAIT_FREE_SLOT_TIME); ··· 199 198 smc_lgr_terminate(lgr); 200 199 return -EPIPE; 201 200 } 202 - if (rc == -ERESTARTSYS) 203 - return -EINTR; 204 201 if (idx == link->wr_tx_cnt) 205 202 return -EPIPE; 206 203 } ··· 299 300 return rc; 300 301 } 301 302 302 - void smc_wr_tx_dismiss_slots(struct smc_link *link, u8 wr_rx_hdr_type, 303 + void smc_wr_tx_dismiss_slots(struct smc_link *link, u8 wr_tx_hdr_type, 303 304 smc_wr_tx_filter filter, 304 305 smc_wr_tx_dismisser dismisser, 305 306 unsigned long data) 306 307 { 307 308 struct smc_wr_tx_pend_priv *tx_pend; 308 - struct smc_wr_rx_hdr *wr_rx; 309 + struct smc_wr_rx_hdr *wr_tx; 309 310 int i; 310 311 311 312 for_each_set_bit(i, link->wr_tx_mask, link->wr_tx_cnt) { 312 - wr_rx = (struct smc_wr_rx_hdr *)&link->wr_rx_bufs[i]; 313 - if (wr_rx->type != wr_rx_hdr_type) 313 + wr_tx = (struct smc_wr_rx_hdr *)&link->wr_tx_bufs[i]; 314 + if (wr_tx->type != wr_tx_hdr_type) 314 315 continue; 315 316 tx_pend = &link->wr_tx_pends[i].priv; 316 317 if (filter(tx_pend, data)) 317 318 dismisser(tx_pend); 318 319 } 319 - } 320 - 321 - bool smc_wr_tx_has_pending(struct smc_link *link, u8 wr_rx_hdr_type, 322 - smc_wr_tx_filter filter, unsigned long data) 323 - { 324 - struct smc_wr_tx_pend_priv *tx_pend; 325 - struct smc_wr_rx_hdr *wr_rx; 326 - int i; 327 - 328 - for_each_set_bit(i, link->wr_tx_mask, link->wr_tx_cnt) { 329 - wr_rx = (struct smc_wr_rx_hdr *)&link->wr_rx_bufs[i]; 330 - if (wr_rx->type != wr_rx_hdr_type) 331 - continue; 332 - tx_pend = &link->wr_tx_pends[i].priv; 333 - if (filter(tx_pend, data)) 334 - return true; 335 - } 336 - return false; 337 320 } 338 321 339 322 /****************************** receive queue ********************************/

-2

net/smc/smc_wr.h

··· 93 93 int smc_wr_tx_send(struct smc_link *link, 94 94 struct smc_wr_tx_pend_priv *wr_pend_priv); 95 95 void smc_wr_tx_cq_handler(struct ib_cq *ib_cq, void *cq_context); 96 - bool smc_wr_tx_has_pending(struct smc_link *link, u8 wr_rx_hdr_type, 97 - smc_wr_tx_filter filter, unsigned long data); 98 96 void smc_wr_tx_dismiss_slots(struct smc_link *lnk, u8 wr_rx_hdr_type, 99 97 smc_wr_tx_filter filter, 100 98 smc_wr_tx_dismisser dismisser,