1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* Processing of received RxRPC packets 3 * 4 * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10 #include "ar-internal.h" 11 12 static void rxrpc_proto_abort(const char *why, 13 struct rxrpc_call *call, rxrpc_seq_t seq) 14 { 15 if (rxrpc_abort_call(why, call, seq, RX_PROTOCOL_ERROR, -EBADMSG)) 16 rxrpc_send_abort_packet(call); 17 } 18 19 /* 20 * Do TCP-style congestion management [RFC 5681]. 21 */ 22 static void rxrpc_congestion_management(struct rxrpc_call *call, 23 struct sk_buff *skb, 24 struct rxrpc_ack_summary *summary, 25 rxrpc_serial_t acked_serial) 26 { 27 enum rxrpc_congest_change change = rxrpc_cong_no_change; 28 unsigned int cumulative_acks = call->cong_cumul_acks; 29 unsigned int cwnd = call->cong_cwnd; 30 bool resend = false; 31 32 summary->flight_size = 33 (call->tx_top - call->acks_hard_ack) - summary->nr_acks; 34 35 if (test_and_clear_bit(RXRPC_CALL_RETRANS_TIMEOUT, &call->flags)) { 36 summary->retrans_timeo = true; 37 call->cong_ssthresh = max_t(unsigned int, 38 summary->flight_size / 2, 2); 39 cwnd = 1; 40 if (cwnd >= call->cong_ssthresh && 41 call->cong_mode == RXRPC_CALL_SLOW_START) { 42 call->cong_mode = RXRPC_CALL_CONGEST_AVOIDANCE; 43 call->cong_tstamp = skb->tstamp; 44 cumulative_acks = 0; 45 } 46 } 47 48 cumulative_acks += summary->nr_new_acks; 49 cumulative_acks += summary->nr_rot_new_acks; 50 if (cumulative_acks > 255) 51 cumulative_acks = 255; 52 53 summary->mode = call->cong_mode; 54 summary->cwnd = call->cong_cwnd; 55 summary->ssthresh = call->cong_ssthresh; 56 summary->cumulative_acks = cumulative_acks; 57 summary->dup_acks = call->cong_dup_acks; 58 59 switch (call->cong_mode) { 60 case RXRPC_CALL_SLOW_START: 61 if (summary->saw_nacks) 62 goto packet_loss_detected; 63 if (summary->cumulative_acks > 0) 64 cwnd += 1; 65 if (cwnd >= call->cong_ssthresh) { 66 call->cong_mode = RXRPC_CALL_CONGEST_AVOIDANCE; 67 call->cong_tstamp = skb->tstamp; 68 } 69 goto out; 70 71 case RXRPC_CALL_CONGEST_AVOIDANCE: 72 if (summary->saw_nacks) 73 goto packet_loss_detected; 74 75 /* We analyse the number of packets that get ACK'd per RTT 76 * period and increase the window if we managed to fill it. 77 */ 78 if (call->peer->rtt_count == 0) 79 goto out; 80 if (ktime_before(skb->tstamp, 81 ktime_add_us(call->cong_tstamp, 82 call->peer->srtt_us >> 3))) 83 goto out_no_clear_ca; 84 change = rxrpc_cong_rtt_window_end; 85 call->cong_tstamp = skb->tstamp; 86 if (cumulative_acks >= cwnd) 87 cwnd++; 88 goto out; 89 90 case RXRPC_CALL_PACKET_LOSS: 91 if (!summary->saw_nacks) 92 goto resume_normality; 93 94 if (summary->new_low_nack) { 95 change = rxrpc_cong_new_low_nack; 96 call->cong_dup_acks = 1; 97 if (call->cong_extra > 1) 98 call->cong_extra = 1; 99 goto send_extra_data; 100 } 101 102 call->cong_dup_acks++; 103 if (call->cong_dup_acks < 3) 104 goto send_extra_data; 105 106 change = rxrpc_cong_begin_retransmission; 107 call->cong_mode = RXRPC_CALL_FAST_RETRANSMIT; 108 call->cong_ssthresh = max_t(unsigned int, 109 summary->flight_size / 2, 2); 110 cwnd = call->cong_ssthresh + 3; 111 call->cong_extra = 0; 112 call->cong_dup_acks = 0; 113 resend = true; 114 goto out; 115 116 case RXRPC_CALL_FAST_RETRANSMIT: 117 if (!summary->new_low_nack) { 118 if (summary->nr_new_acks == 0) 119 cwnd += 1; 120 call->cong_dup_acks++; 121 if (call->cong_dup_acks == 2) { 122 change = rxrpc_cong_retransmit_again; 123 call->cong_dup_acks = 0; 124 resend = true; 125 } 126 } else { 127 change = rxrpc_cong_progress; 128 cwnd = call->cong_ssthresh; 129 if (!summary->saw_nacks) 130 goto resume_normality; 131 } 132 goto out; 133 134 default: 135 BUG(); 136 goto out; 137 } 138 139 resume_normality: 140 change = rxrpc_cong_cleared_nacks; 141 call->cong_dup_acks = 0; 142 call->cong_extra = 0; 143 call->cong_tstamp = skb->tstamp; 144 if (cwnd < call->cong_ssthresh) 145 call->cong_mode = RXRPC_CALL_SLOW_START; 146 else 147 call->cong_mode = RXRPC_CALL_CONGEST_AVOIDANCE; 148 out: 149 cumulative_acks = 0; 150 out_no_clear_ca: 151 if (cwnd >= RXRPC_TX_MAX_WINDOW) 152 cwnd = RXRPC_TX_MAX_WINDOW; 153 call->cong_cwnd = cwnd; 154 call->cong_cumul_acks = cumulative_acks; 155 trace_rxrpc_congest(call, summary, acked_serial, change); 156 if (resend) 157 rxrpc_resend(call, skb); 158 return; 159 160 packet_loss_detected: 161 change = rxrpc_cong_saw_nack; 162 call->cong_mode = RXRPC_CALL_PACKET_LOSS; 163 call->cong_dup_acks = 0; 164 goto send_extra_data; 165 166 send_extra_data: 167 /* Send some previously unsent DATA if we have some to advance the ACK 168 * state. 169 */ 170 if (test_bit(RXRPC_CALL_TX_LAST, &call->flags) || 171 summary->nr_acks != call->tx_top - call->acks_hard_ack) { 172 call->cong_extra++; 173 wake_up(&call->waitq); 174 } 175 goto out_no_clear_ca; 176 } 177 178 /* 179 * Degrade the congestion window if we haven't transmitted a packet for >1RTT. 180 */ 181 void rxrpc_congestion_degrade(struct rxrpc_call *call) 182 { 183 ktime_t rtt, now; 184 185 if (call->cong_mode != RXRPC_CALL_SLOW_START && 186 call->cong_mode != RXRPC_CALL_CONGEST_AVOIDANCE) 187 return; 188 if (call->state == RXRPC_CALL_CLIENT_AWAIT_REPLY) 189 return; 190 191 rtt = ns_to_ktime(call->peer->srtt_us * (1000 / 8)); 192 now = ktime_get_real(); 193 if (!ktime_before(ktime_add(call->tx_last_sent, rtt), now)) 194 return; 195 196 trace_rxrpc_reset_cwnd(call, now); 197 rxrpc_inc_stat(call->rxnet, stat_tx_data_cwnd_reset); 198 call->tx_last_sent = now; 199 call->cong_mode = RXRPC_CALL_SLOW_START; 200 call->cong_ssthresh = max_t(unsigned int, call->cong_ssthresh, 201 call->cong_cwnd * 3 / 4); 202 call->cong_cwnd = max_t(unsigned int, call->cong_cwnd / 2, RXRPC_MIN_CWND); 203 } 204 205 /* 206 * Apply a hard ACK by advancing the Tx window. 207 */ 208 static bool rxrpc_rotate_tx_window(struct rxrpc_call *call, rxrpc_seq_t to, 209 struct rxrpc_ack_summary *summary) 210 { 211 struct rxrpc_txbuf *txb; 212 bool rot_last = false; 213 214 list_for_each_entry_rcu(txb, &call->tx_buffer, call_link, false) { 215 if (before_eq(txb->seq, call->acks_hard_ack)) 216 continue; 217 summary->nr_rot_new_acks++; 218 if (test_bit(RXRPC_TXBUF_LAST, &txb->flags)) { 219 set_bit(RXRPC_CALL_TX_LAST, &call->flags); 220 rot_last = true; 221 } 222 if (txb->seq == to) 223 break; 224 } 225 226 if (rot_last) 227 set_bit(RXRPC_CALL_TX_ALL_ACKED, &call->flags); 228 229 _enter("%x,%x,%x,%d", to, call->acks_hard_ack, call->tx_top, rot_last); 230 231 if (call->acks_lowest_nak == call->acks_hard_ack) { 232 call->acks_lowest_nak = to; 233 } else if (after(to, call->acks_lowest_nak)) { 234 summary->new_low_nack = true; 235 call->acks_lowest_nak = to; 236 } 237 238 smp_store_release(&call->acks_hard_ack, to); 239 240 trace_rxrpc_txqueue(call, (rot_last ? 241 rxrpc_txqueue_rotate_last : 242 rxrpc_txqueue_rotate)); 243 wake_up(&call->waitq); 244 return rot_last; 245 } 246 247 /* 248 * End the transmission phase of a call. 249 * 250 * This occurs when we get an ACKALL packet, the first DATA packet of a reply, 251 * or a final ACK packet. 252 */ 253 static bool rxrpc_end_tx_phase(struct rxrpc_call *call, bool reply_begun, 254 const char *abort_why) 255 { 256 unsigned int state; 257 258 ASSERT(test_bit(RXRPC_CALL_TX_LAST, &call->flags)); 259 260 write_lock(&call->state_lock); 261 262 state = call->state; 263 switch (state) { 264 case RXRPC_CALL_CLIENT_SEND_REQUEST: 265 case RXRPC_CALL_CLIENT_AWAIT_REPLY: 266 if (reply_begun) 267 call->state = state = RXRPC_CALL_CLIENT_RECV_REPLY; 268 else 269 call->state = state = RXRPC_CALL_CLIENT_AWAIT_REPLY; 270 break; 271 272 case RXRPC_CALL_SERVER_AWAIT_ACK: 273 __rxrpc_call_completed(call); 274 state = call->state; 275 break; 276 277 default: 278 goto bad_state; 279 } 280 281 write_unlock(&call->state_lock); 282 if (state == RXRPC_CALL_CLIENT_AWAIT_REPLY) 283 trace_rxrpc_txqueue(call, rxrpc_txqueue_await_reply); 284 else 285 trace_rxrpc_txqueue(call, rxrpc_txqueue_end); 286 _leave(" = ok"); 287 return true; 288 289 bad_state: 290 write_unlock(&call->state_lock); 291 kdebug("end_tx %s", rxrpc_call_states[call->state]); 292 rxrpc_proto_abort(abort_why, call, call->tx_top); 293 return false; 294 } 295 296 /* 297 * Begin the reply reception phase of a call. 298 */ 299 static bool rxrpc_receiving_reply(struct rxrpc_call *call) 300 { 301 struct rxrpc_ack_summary summary = { 0 }; 302 unsigned long now, timo; 303 rxrpc_seq_t top = READ_ONCE(call->tx_top); 304 305 if (call->ackr_reason) { 306 now = jiffies; 307 timo = now + MAX_JIFFY_OFFSET; 308 WRITE_ONCE(call->resend_at, timo); 309 WRITE_ONCE(call->delay_ack_at, timo); 310 trace_rxrpc_timer(call, rxrpc_timer_init_for_reply, now); 311 } 312 313 if (!test_bit(RXRPC_CALL_TX_LAST, &call->flags)) { 314 if (!rxrpc_rotate_tx_window(call, top, &summary)) { 315 rxrpc_proto_abort("TXL", call, top); 316 return false; 317 } 318 } 319 return rxrpc_end_tx_phase(call, true, "ETD"); 320 } 321 322 static void rxrpc_input_update_ack_window(struct rxrpc_call *call, 323 rxrpc_seq_t window, rxrpc_seq_t wtop) 324 { 325 atomic64_set_release(&call->ackr_window, ((u64)wtop) << 32 | window); 326 } 327 328 /* 329 * Push a DATA packet onto the Rx queue. 330 */ 331 static void rxrpc_input_queue_data(struct rxrpc_call *call, struct sk_buff *skb, 332 rxrpc_seq_t window, rxrpc_seq_t wtop, 333 enum rxrpc_receive_trace why) 334 { 335 struct rxrpc_skb_priv *sp = rxrpc_skb(skb); 336 bool last = sp->hdr.flags & RXRPC_LAST_PACKET; 337 338 __skb_queue_tail(&call->recvmsg_queue, skb); 339 rxrpc_input_update_ack_window(call, window, wtop); 340 341 trace_rxrpc_receive(call, last ? why + 1 : why, sp->hdr.serial, sp->hdr.seq); 342 } 343 344 /* 345 * Process a DATA packet. 346 */ 347 static void rxrpc_input_data_one(struct rxrpc_call *call, struct sk_buff *skb, 348 bool *_notify) 349 { 350 struct rxrpc_skb_priv *sp = rxrpc_skb(skb); 351 struct sk_buff *oos; 352 rxrpc_serial_t serial = sp->hdr.serial; 353 u64 win = atomic64_read(&call->ackr_window); 354 rxrpc_seq_t window = lower_32_bits(win); 355 rxrpc_seq_t wtop = upper_32_bits(win); 356 rxrpc_seq_t wlimit = window + call->rx_winsize - 1; 357 rxrpc_seq_t seq = sp->hdr.seq; 358 bool last = sp->hdr.flags & RXRPC_LAST_PACKET; 359 int ack_reason = -1; 360 361 rxrpc_inc_stat(call->rxnet, stat_rx_data); 362 if (sp->hdr.flags & RXRPC_REQUEST_ACK) 363 rxrpc_inc_stat(call->rxnet, stat_rx_data_reqack); 364 if (sp->hdr.flags & RXRPC_JUMBO_PACKET) 365 rxrpc_inc_stat(call->rxnet, stat_rx_data_jumbo); 366 367 if (last) { 368 if (test_and_set_bit(RXRPC_CALL_RX_LAST, &call->flags) && 369 seq + 1 != wtop) { 370 rxrpc_proto_abort("LSN", call, seq); 371 return; 372 } 373 } else { 374 if (test_bit(RXRPC_CALL_RX_LAST, &call->flags) && 375 after_eq(seq, wtop)) { 376 pr_warn("Packet beyond last: c=%x q=%x window=%x-%x wlimit=%x\n", 377 call->debug_id, seq, window, wtop, wlimit); 378 rxrpc_proto_abort("LSA", call, seq); 379 return; 380 } 381 } 382 383 if (after(seq, call->rx_highest_seq)) 384 call->rx_highest_seq = seq; 385 386 trace_rxrpc_rx_data(call->debug_id, seq, serial, sp->hdr.flags); 387 388 if (before(seq, window)) { 389 ack_reason = RXRPC_ACK_DUPLICATE; 390 goto send_ack; 391 } 392 if (after(seq, wlimit)) { 393 ack_reason = RXRPC_ACK_EXCEEDS_WINDOW; 394 goto send_ack; 395 } 396 397 /* Queue the packet. */ 398 if (seq == window) { 399 rxrpc_seq_t reset_from; 400 bool reset_sack = false; 401 402 if (sp->hdr.flags & RXRPC_REQUEST_ACK) 403 ack_reason = RXRPC_ACK_REQUESTED; 404 /* Send an immediate ACK if we fill in a hole */ 405 else if (!skb_queue_empty(&call->rx_oos_queue)) 406 ack_reason = RXRPC_ACK_DELAY; 407 else 408 atomic_inc_return(&call->ackr_nr_unacked); 409 410 window++; 411 if (after(window, wtop)) 412 wtop = window; 413 414 rxrpc_get_skb(skb, rxrpc_skb_get_to_recvmsg); 415 416 spin_lock(&call->recvmsg_queue.lock); 417 rxrpc_input_queue_data(call, skb, window, wtop, rxrpc_receive_queue); 418 *_notify = true; 419 420 while ((oos = skb_peek(&call->rx_oos_queue))) { 421 struct rxrpc_skb_priv *osp = rxrpc_skb(oos); 422 423 if (after(osp->hdr.seq, window)) 424 break; 425 426 __skb_unlink(oos, &call->rx_oos_queue); 427 last = osp->hdr.flags & RXRPC_LAST_PACKET; 428 seq = osp->hdr.seq; 429 if (!reset_sack) { 430 reset_from = seq; 431 reset_sack = true; 432 } 433 434 window++; 435 rxrpc_input_queue_data(call, oos, window, wtop, 436 rxrpc_receive_queue_oos); 437 } 438 439 spin_unlock(&call->recvmsg_queue.lock); 440 441 if (reset_sack) { 442 do { 443 call->ackr_sack_table[reset_from % RXRPC_SACK_SIZE] = 0; 444 } while (reset_from++, before(reset_from, window)); 445 } 446 } else { 447 bool keep = false; 448 449 ack_reason = RXRPC_ACK_OUT_OF_SEQUENCE; 450 451 if (!call->ackr_sack_table[seq % RXRPC_SACK_SIZE]) { 452 call->ackr_sack_table[seq % RXRPC_SACK_SIZE] = 1; 453 keep = 1; 454 } 455 456 if (after(seq + 1, wtop)) { 457 wtop = seq + 1; 458 rxrpc_input_update_ack_window(call, window, wtop); 459 } 460 461 if (!keep) { 462 ack_reason = RXRPC_ACK_DUPLICATE; 463 goto send_ack; 464 } 465 466 skb_queue_walk(&call->rx_oos_queue, oos) { 467 struct rxrpc_skb_priv *osp = rxrpc_skb(oos); 468 469 if (after(osp->hdr.seq, seq)) { 470 rxrpc_get_skb(skb, rxrpc_skb_get_to_recvmsg_oos); 471 __skb_queue_before(&call->rx_oos_queue, oos, skb); 472 goto oos_queued; 473 } 474 } 475 476 rxrpc_get_skb(skb, rxrpc_skb_get_to_recvmsg_oos); 477 __skb_queue_tail(&call->rx_oos_queue, skb); 478 oos_queued: 479 trace_rxrpc_receive(call, last ? rxrpc_receive_oos_last : rxrpc_receive_oos, 480 sp->hdr.serial, sp->hdr.seq); 481 } 482 483 send_ack: 484 if (ack_reason >= 0) 485 rxrpc_send_ACK(call, ack_reason, serial, 486 rxrpc_propose_ack_input_data); 487 else 488 rxrpc_propose_delay_ACK(call, serial, 489 rxrpc_propose_ack_input_data); 490 } 491 492 /* 493 * Split a jumbo packet and file the bits separately. 494 */ 495 static bool rxrpc_input_split_jumbo(struct rxrpc_call *call, struct sk_buff *skb) 496 { 497 struct rxrpc_jumbo_header jhdr; 498 struct rxrpc_skb_priv *sp = rxrpc_skb(skb), *jsp; 499 struct sk_buff *jskb; 500 unsigned int offset = sizeof(struct rxrpc_wire_header); 501 unsigned int len = skb->len - offset; 502 bool notify = false; 503 504 while (sp->hdr.flags & RXRPC_JUMBO_PACKET) { 505 if (len < RXRPC_JUMBO_SUBPKTLEN) 506 goto protocol_error; 507 if (sp->hdr.flags & RXRPC_LAST_PACKET) 508 goto protocol_error; 509 if (skb_copy_bits(skb, offset + RXRPC_JUMBO_DATALEN, 510 &jhdr, sizeof(jhdr)) < 0) 511 goto protocol_error; 512 513 jskb = skb_clone(skb, GFP_NOFS); 514 if (!jskb) { 515 kdebug("couldn't clone"); 516 return false; 517 } 518 rxrpc_new_skb(jskb, rxrpc_skb_new_jumbo_subpacket); 519 jsp = rxrpc_skb(jskb); 520 jsp->offset = offset; 521 jsp->len = RXRPC_JUMBO_DATALEN; 522 rxrpc_input_data_one(call, jskb, ¬ify); 523 rxrpc_free_skb(jskb, rxrpc_skb_put_jumbo_subpacket); 524 525 sp->hdr.flags = jhdr.flags; 526 sp->hdr._rsvd = ntohs(jhdr._rsvd); 527 sp->hdr.seq++; 528 sp->hdr.serial++; 529 offset += RXRPC_JUMBO_SUBPKTLEN; 530 len -= RXRPC_JUMBO_SUBPKTLEN; 531 } 532 533 sp->offset = offset; 534 sp->len = len; 535 rxrpc_input_data_one(call, skb, ¬ify); 536 if (notify) { 537 trace_rxrpc_notify_socket(call->debug_id, sp->hdr.serial); 538 rxrpc_notify_socket(call); 539 } 540 return true; 541 542 protocol_error: 543 return false; 544 } 545 546 /* 547 * Process a DATA packet, adding the packet to the Rx ring. The caller's 548 * packet ref must be passed on or discarded. 549 */ 550 static void rxrpc_input_data(struct rxrpc_call *call, struct sk_buff *skb) 551 { 552 struct rxrpc_skb_priv *sp = rxrpc_skb(skb); 553 enum rxrpc_call_state state; 554 rxrpc_serial_t serial = sp->hdr.serial; 555 rxrpc_seq_t seq0 = sp->hdr.seq; 556 557 _enter("{%llx,%x},{%u,%x}", 558 atomic64_read(&call->ackr_window), call->rx_highest_seq, 559 skb->len, seq0); 560 561 state = READ_ONCE(call->state); 562 if (state >= RXRPC_CALL_COMPLETE) 563 return; 564 565 if (state == RXRPC_CALL_SERVER_RECV_REQUEST) { 566 unsigned long timo = READ_ONCE(call->next_req_timo); 567 unsigned long now, expect_req_by; 568 569 if (timo) { 570 now = jiffies; 571 expect_req_by = now + timo; 572 WRITE_ONCE(call->expect_req_by, expect_req_by); 573 rxrpc_reduce_call_timer(call, expect_req_by, now, 574 rxrpc_timer_set_for_idle); 575 } 576 } 577 578 /* Received data implicitly ACKs all of the request packets we sent 579 * when we're acting as a client. 580 */ 581 if ((state == RXRPC_CALL_CLIENT_SEND_REQUEST || 582 state == RXRPC_CALL_CLIENT_AWAIT_REPLY) && 583 !rxrpc_receiving_reply(call)) 584 goto out_notify; 585 586 if (!rxrpc_input_split_jumbo(call, skb)) { 587 rxrpc_proto_abort("VLD", call, sp->hdr.seq); 588 goto out_notify; 589 } 590 skb = NULL; 591 592 out_notify: 593 trace_rxrpc_notify_socket(call->debug_id, serial); 594 rxrpc_notify_socket(call); 595 _leave(" [queued]"); 596 } 597 598 /* 599 * See if there's a cached RTT probe to complete. 600 */ 601 static void rxrpc_complete_rtt_probe(struct rxrpc_call *call, 602 ktime_t resp_time, 603 rxrpc_serial_t acked_serial, 604 rxrpc_serial_t ack_serial, 605 enum rxrpc_rtt_rx_trace type) 606 { 607 rxrpc_serial_t orig_serial; 608 unsigned long avail; 609 ktime_t sent_at; 610 bool matched = false; 611 int i; 612 613 avail = READ_ONCE(call->rtt_avail); 614 smp_rmb(); /* Read avail bits before accessing data. */ 615 616 for (i = 0; i < ARRAY_SIZE(call->rtt_serial); i++) { 617 if (!test_bit(i + RXRPC_CALL_RTT_PEND_SHIFT, &avail)) 618 continue; 619 620 sent_at = call->rtt_sent_at[i]; 621 orig_serial = call->rtt_serial[i]; 622 623 if (orig_serial == acked_serial) { 624 clear_bit(i + RXRPC_CALL_RTT_PEND_SHIFT, &call->rtt_avail); 625 smp_mb(); /* Read data before setting avail bit */ 626 set_bit(i, &call->rtt_avail); 627 if (type != rxrpc_rtt_rx_cancel) 628 rxrpc_peer_add_rtt(call, type, i, acked_serial, ack_serial, 629 sent_at, resp_time); 630 else 631 trace_rxrpc_rtt_rx(call, rxrpc_rtt_rx_cancel, i, 632 orig_serial, acked_serial, 0, 0); 633 matched = true; 634 } 635 636 /* If a later serial is being acked, then mark this slot as 637 * being available. 638 */ 639 if (after(acked_serial, orig_serial)) { 640 trace_rxrpc_rtt_rx(call, rxrpc_rtt_rx_obsolete, i, 641 orig_serial, acked_serial, 0, 0); 642 clear_bit(i + RXRPC_CALL_RTT_PEND_SHIFT, &call->rtt_avail); 643 smp_wmb(); 644 set_bit(i, &call->rtt_avail); 645 } 646 } 647 648 if (!matched) 649 trace_rxrpc_rtt_rx(call, rxrpc_rtt_rx_lost, 9, 0, acked_serial, 0, 0); 650 } 651 652 /* 653 * Process the extra information that may be appended to an ACK packet 654 */ 655 static void rxrpc_input_ackinfo(struct rxrpc_call *call, struct sk_buff *skb, 656 struct rxrpc_ackinfo *ackinfo) 657 { 658 struct rxrpc_skb_priv *sp = rxrpc_skb(skb); 659 struct rxrpc_peer *peer; 660 unsigned int mtu; 661 bool wake = false; 662 u32 rwind = ntohl(ackinfo->rwind); 663 664 if (rwind > RXRPC_TX_MAX_WINDOW) 665 rwind = RXRPC_TX_MAX_WINDOW; 666 if (call->tx_winsize != rwind) { 667 if (rwind > call->tx_winsize) 668 wake = true; 669 trace_rxrpc_rx_rwind_change(call, sp->hdr.serial, rwind, wake); 670 call->tx_winsize = rwind; 671 } 672 673 if (call->cong_ssthresh > rwind) 674 call->cong_ssthresh = rwind; 675 676 mtu = min(ntohl(ackinfo->rxMTU), ntohl(ackinfo->maxMTU)); 677 678 peer = call->peer; 679 if (mtu < peer->maxdata) { 680 spin_lock(&peer->lock); 681 peer->maxdata = mtu; 682 peer->mtu = mtu + peer->hdrsize; 683 spin_unlock(&peer->lock); 684 } 685 686 if (wake) 687 wake_up(&call->waitq); 688 } 689 690 /* 691 * Process individual soft ACKs. 692 * 693 * Each ACK in the array corresponds to one packet and can be either an ACK or 694 * a NAK. If we get find an explicitly NAK'd packet we resend immediately; 695 * packets that lie beyond the end of the ACK list are scheduled for resend by 696 * the timer on the basis that the peer might just not have processed them at 697 * the time the ACK was sent. 698 */ 699 static void rxrpc_input_soft_acks(struct rxrpc_call *call, u8 *acks, 700 rxrpc_seq_t seq, int nr_acks, 701 struct rxrpc_ack_summary *summary) 702 { 703 unsigned int i; 704 705 for (i = 0; i < nr_acks; i++) { 706 if (acks[i] == RXRPC_ACK_TYPE_ACK) { 707 summary->nr_acks++; 708 summary->nr_new_acks++; 709 } else { 710 if (!summary->saw_nacks && 711 call->acks_lowest_nak != seq + i) { 712 call->acks_lowest_nak = seq + i; 713 summary->new_low_nack = true; 714 } 715 summary->saw_nacks = true; 716 } 717 } 718 } 719 720 /* 721 * Return true if the ACK is valid - ie. it doesn't appear to have regressed 722 * with respect to the ack state conveyed by preceding ACKs. 723 */ 724 static bool rxrpc_is_ack_valid(struct rxrpc_call *call, 725 rxrpc_seq_t first_pkt, rxrpc_seq_t prev_pkt) 726 { 727 rxrpc_seq_t base = READ_ONCE(call->acks_first_seq); 728 729 if (after(first_pkt, base)) 730 return true; /* The window advanced */ 731 732 if (before(first_pkt, base)) 733 return false; /* firstPacket regressed */ 734 735 if (after_eq(prev_pkt, call->acks_prev_seq)) 736 return true; /* previousPacket hasn't regressed. */ 737 738 /* Some rx implementations put a serial number in previousPacket. */ 739 if (after_eq(prev_pkt, base + call->tx_winsize)) 740 return false; 741 return true; 742 } 743 744 /* 745 * Process an ACK packet. 746 * 747 * ack.firstPacket is the sequence number of the first soft-ACK'd/NAK'd packet 748 * in the ACK array. Anything before that is hard-ACK'd and may be discarded. 749 * 750 * A hard-ACK means that a packet has been processed and may be discarded; a 751 * soft-ACK means that the packet may be discarded and retransmission 752 * requested. A phase is complete when all packets are hard-ACK'd. 753 */ 754 static void rxrpc_input_ack(struct rxrpc_call *call, struct sk_buff *skb) 755 { 756 struct rxrpc_ack_summary summary = { 0 }; 757 struct rxrpc_ackpacket ack; 758 struct rxrpc_skb_priv *sp = rxrpc_skb(skb); 759 struct rxrpc_ackinfo info; 760 rxrpc_serial_t ack_serial, acked_serial; 761 rxrpc_seq_t first_soft_ack, hard_ack, prev_pkt; 762 int nr_acks, offset, ioffset; 763 764 _enter(""); 765 766 offset = sizeof(struct rxrpc_wire_header); 767 if (skb_copy_bits(skb, offset, &ack, sizeof(ack)) < 0) 768 return rxrpc_proto_abort("XAK", call, 0); 769 offset += sizeof(ack); 770 771 ack_serial = sp->hdr.serial; 772 acked_serial = ntohl(ack.serial); 773 first_soft_ack = ntohl(ack.firstPacket); 774 prev_pkt = ntohl(ack.previousPacket); 775 hard_ack = first_soft_ack - 1; 776 nr_acks = ack.nAcks; 777 summary.ack_reason = (ack.reason < RXRPC_ACK__INVALID ? 778 ack.reason : RXRPC_ACK__INVALID); 779 780 trace_rxrpc_rx_ack(call, ack_serial, acked_serial, 781 first_soft_ack, prev_pkt, 782 summary.ack_reason, nr_acks); 783 rxrpc_inc_stat(call->rxnet, stat_rx_acks[ack.reason]); 784 785 switch (ack.reason) { 786 case RXRPC_ACK_PING_RESPONSE: 787 rxrpc_complete_rtt_probe(call, skb->tstamp, acked_serial, ack_serial, 788 rxrpc_rtt_rx_ping_response); 789 break; 790 case RXRPC_ACK_REQUESTED: 791 rxrpc_complete_rtt_probe(call, skb->tstamp, acked_serial, ack_serial, 792 rxrpc_rtt_rx_requested_ack); 793 break; 794 default: 795 if (acked_serial != 0) 796 rxrpc_complete_rtt_probe(call, skb->tstamp, acked_serial, ack_serial, 797 rxrpc_rtt_rx_cancel); 798 break; 799 } 800 801 if (ack.reason == RXRPC_ACK_PING) { 802 rxrpc_send_ACK(call, RXRPC_ACK_PING_RESPONSE, ack_serial, 803 rxrpc_propose_ack_respond_to_ping); 804 } else if (sp->hdr.flags & RXRPC_REQUEST_ACK) { 805 rxrpc_send_ACK(call, RXRPC_ACK_REQUESTED, ack_serial, 806 rxrpc_propose_ack_respond_to_ack); 807 } 808 809 /* If we get an EXCEEDS_WINDOW ACK from the server, it probably 810 * indicates that the client address changed due to NAT. The server 811 * lost the call because it switched to a different peer. 812 */ 813 if (unlikely(ack.reason == RXRPC_ACK_EXCEEDS_WINDOW) && 814 first_soft_ack == 1 && 815 prev_pkt == 0 && 816 rxrpc_is_client_call(call)) { 817 rxrpc_set_call_completion(call, RXRPC_CALL_REMOTELY_ABORTED, 818 0, -ENETRESET); 819 return; 820 } 821 822 /* If we get an OUT_OF_SEQUENCE ACK from the server, that can also 823 * indicate a change of address. However, we can retransmit the call 824 * if we still have it buffered to the beginning. 825 */ 826 if (unlikely(ack.reason == RXRPC_ACK_OUT_OF_SEQUENCE) && 827 first_soft_ack == 1 && 828 prev_pkt == 0 && 829 call->acks_hard_ack == 0 && 830 rxrpc_is_client_call(call)) { 831 rxrpc_set_call_completion(call, RXRPC_CALL_REMOTELY_ABORTED, 832 0, -ENETRESET); 833 return; 834 } 835 836 /* Discard any out-of-order or duplicate ACKs (outside lock). */ 837 if (!rxrpc_is_ack_valid(call, first_soft_ack, prev_pkt)) { 838 trace_rxrpc_rx_discard_ack(call->debug_id, ack_serial, 839 first_soft_ack, call->acks_first_seq, 840 prev_pkt, call->acks_prev_seq); 841 return; 842 } 843 844 info.rxMTU = 0; 845 ioffset = offset + nr_acks + 3; 846 if (skb->len >= ioffset + sizeof(info) && 847 skb_copy_bits(skb, ioffset, &info, sizeof(info)) < 0) 848 return rxrpc_proto_abort("XAI", call, 0); 849 850 if (nr_acks > 0) 851 skb_condense(skb); 852 853 call->acks_latest_ts = skb->tstamp; 854 call->acks_first_seq = first_soft_ack; 855 call->acks_prev_seq = prev_pkt; 856 857 switch (ack.reason) { 858 case RXRPC_ACK_PING: 859 break; 860 default: 861 if (after(acked_serial, call->acks_highest_serial)) 862 call->acks_highest_serial = acked_serial; 863 break; 864 } 865 866 /* Parse rwind and mtu sizes if provided. */ 867 if (info.rxMTU) 868 rxrpc_input_ackinfo(call, skb, &info); 869 870 if (first_soft_ack == 0) 871 return rxrpc_proto_abort("AK0", call, 0); 872 873 /* Ignore ACKs unless we are or have just been transmitting. */ 874 switch (READ_ONCE(call->state)) { 875 case RXRPC_CALL_CLIENT_SEND_REQUEST: 876 case RXRPC_CALL_CLIENT_AWAIT_REPLY: 877 case RXRPC_CALL_SERVER_SEND_REPLY: 878 case RXRPC_CALL_SERVER_AWAIT_ACK: 879 break; 880 default: 881 return; 882 } 883 884 if (before(hard_ack, call->acks_hard_ack) || 885 after(hard_ack, call->tx_top)) 886 return rxrpc_proto_abort("AKW", call, 0); 887 if (nr_acks > call->tx_top - hard_ack) 888 return rxrpc_proto_abort("AKN", call, 0); 889 890 if (after(hard_ack, call->acks_hard_ack)) { 891 if (rxrpc_rotate_tx_window(call, hard_ack, &summary)) { 892 rxrpc_end_tx_phase(call, false, "ETA"); 893 return; 894 } 895 } 896 897 if (nr_acks > 0) { 898 if (offset > (int)skb->len - nr_acks) 899 return rxrpc_proto_abort("XSA", call, 0); 900 rxrpc_input_soft_acks(call, skb->data + offset, first_soft_ack, 901 nr_acks, &summary); 902 } 903 904 if (test_bit(RXRPC_CALL_TX_LAST, &call->flags) && 905 summary.nr_acks == call->tx_top - hard_ack && 906 rxrpc_is_client_call(call)) 907 rxrpc_propose_ping(call, ack_serial, 908 rxrpc_propose_ack_ping_for_lost_reply); 909 910 rxrpc_congestion_management(call, skb, &summary, acked_serial); 911 } 912 913 /* 914 * Process an ACKALL packet. 915 */ 916 static void rxrpc_input_ackall(struct rxrpc_call *call, struct sk_buff *skb) 917 { 918 struct rxrpc_ack_summary summary = { 0 }; 919 920 if (rxrpc_rotate_tx_window(call, call->tx_top, &summary)) 921 rxrpc_end_tx_phase(call, false, "ETL"); 922 } 923 924 /* 925 * Process an ABORT packet directed at a call. 926 */ 927 static void rxrpc_input_abort(struct rxrpc_call *call, struct sk_buff *skb) 928 { 929 struct rxrpc_skb_priv *sp = rxrpc_skb(skb); 930 931 trace_rxrpc_rx_abort(call, sp->hdr.serial, skb->priority); 932 933 rxrpc_set_call_completion(call, RXRPC_CALL_REMOTELY_ABORTED, 934 skb->priority, -ECONNABORTED); 935 } 936 937 /* 938 * Process an incoming call packet. 939 */ 940 void rxrpc_input_call_packet(struct rxrpc_call *call, struct sk_buff *skb) 941 { 942 struct rxrpc_skb_priv *sp = rxrpc_skb(skb); 943 unsigned long timo; 944 945 _enter("%p,%p", call, skb); 946 947 if (sp->hdr.serviceId != call->dest_srx.srx_service) 948 call->dest_srx.srx_service = sp->hdr.serviceId; 949 if ((int)sp->hdr.serial - (int)call->rx_serial > 0) 950 call->rx_serial = sp->hdr.serial; 951 if (!test_bit(RXRPC_CALL_RX_HEARD, &call->flags)) 952 set_bit(RXRPC_CALL_RX_HEARD, &call->flags); 953 954 timo = READ_ONCE(call->next_rx_timo); 955 if (timo) { 956 unsigned long now = jiffies, expect_rx_by; 957 958 expect_rx_by = now + timo; 959 WRITE_ONCE(call->expect_rx_by, expect_rx_by); 960 rxrpc_reduce_call_timer(call, expect_rx_by, now, 961 rxrpc_timer_set_for_normal); 962 } 963 964 switch (sp->hdr.type) { 965 case RXRPC_PACKET_TYPE_DATA: 966 rxrpc_input_data(call, skb); 967 break; 968 969 case RXRPC_PACKET_TYPE_ACK: 970 rxrpc_input_ack(call, skb); 971 break; 972 973 case RXRPC_PACKET_TYPE_BUSY: 974 /* Just ignore BUSY packets from the server; the retry and 975 * lifespan timers will take care of business. BUSY packets 976 * from the client don't make sense. 977 */ 978 break; 979 980 case RXRPC_PACKET_TYPE_ABORT: 981 rxrpc_input_abort(call, skb); 982 break; 983 984 case RXRPC_PACKET_TYPE_ACKALL: 985 rxrpc_input_ackall(call, skb); 986 break; 987 988 default: 989 break; 990 } 991 } 992 993 /* 994 * Handle a new service call on a channel implicitly completing the preceding 995 * call on that channel. This does not apply to client conns. 996 * 997 * TODO: If callNumber > call_id + 1, renegotiate security. 998 */ 999 void rxrpc_implicit_end_call(struct rxrpc_call *call, struct sk_buff *skb) 1000 { 1001 struct rxrpc_connection *conn = call->conn; 1002 1003 switch (READ_ONCE(call->state)) { 1004 case RXRPC_CALL_SERVER_AWAIT_ACK: 1005 rxrpc_call_completed(call); 1006 fallthrough; 1007 case RXRPC_CALL_COMPLETE: 1008 break; 1009 default: 1010 if (rxrpc_abort_call("IMP", call, 0, RX_CALL_DEAD, -ESHUTDOWN)) 1011 rxrpc_send_abort_packet(call); 1012 trace_rxrpc_improper_term(call); 1013 break; 1014 } 1015 1016 rxrpc_input_call_event(call, skb); 1017 1018 spin_lock(&conn->bundle->channel_lock); 1019 __rxrpc_disconnect_call(conn, call); 1020 spin_unlock(&conn->bundle->channel_lock); 1021 } 1022