rxrpc: Adjust names and types of congestion-related fields

+35 -23

include/trace/events/rxrpc.h

··· 378 378 EM(rxrpc_propose_ack_rx_idle, "RxIdle ") \ 379 379 E_(rxrpc_propose_ack_terminal_ack, "ClTerm ") 380 380 381 - #define rxrpc_congest_modes \ 382 - EM(RXRPC_CALL_CONGEST_AVOIDANCE, "CongAvoid") \ 383 - EM(RXRPC_CALL_FAST_RETRANSMIT, "FastReTx ") \ 384 - EM(RXRPC_CALL_PACKET_LOSS, "PktLoss ") \ 385 - E_(RXRPC_CALL_SLOW_START, "SlowStart") 381 + #define rxrpc_ca_states \ 382 + EM(RXRPC_CA_CONGEST_AVOIDANCE, "CongAvoid") \ 383 + EM(RXRPC_CA_FAST_RETRANSMIT, "FastReTx ") \ 384 + EM(RXRPC_CA_PACKET_LOSS, "PktLoss ") \ 385 + E_(RXRPC_CA_SLOW_START, "SlowStart") 386 386 387 387 #define rxrpc_congest_changes \ 388 388 EM(rxrpc_cong_begin_retransmission, " Retrans") \ ··· 550 550 551 551 rxrpc_abort_reasons; 552 552 rxrpc_bundle_traces; 553 + rxrpc_ca_states; 553 554 rxrpc_call_poke_traces; 554 555 rxrpc_call_traces; 555 556 rxrpc_client_traces; 556 557 rxrpc_congest_changes; 557 - rxrpc_congest_modes; 558 558 rxrpc_conn_traces; 559 559 rxrpc_local_traces; 560 560 rxrpc_pmtud_reduce_traces; ··· 1688 1688 1689 1689 TRACE_EVENT(rxrpc_congest, 1690 1690 TP_PROTO(struct rxrpc_call *call, struct rxrpc_ack_summary *summary, 1691 - rxrpc_serial_t ack_serial, enum rxrpc_congest_change change), 1691 + rxrpc_serial_t ack_serial), 1692 1692 1693 - TP_ARGS(call, summary, ack_serial, change), 1693 + TP_ARGS(call, summary, ack_serial), 1694 1694 1695 1695 TP_STRUCT__entry( 1696 1696 __field(unsigned int, call) 1697 - __field(enum rxrpc_congest_change, change) 1697 + __field(enum rxrpc_ca_state, ca_state) 1698 1698 __field(rxrpc_seq_t, hard_ack) 1699 1699 __field(rxrpc_seq_t, top) 1700 1700 __field(rxrpc_seq_t, lowest_nak) 1701 1701 __field(rxrpc_serial_t, ack_serial) 1702 + __field(u16, nr_sacks) 1703 + __field(u16, nr_snacks) 1704 + __field(u16, cwnd) 1705 + __field(u16, ssthresh) 1706 + __field(u16, cumul_acks) 1707 + __field(u16, dup_acks) 1702 1708 __field_struct(struct rxrpc_ack_summary, sum) 1703 1709 ), 1704 1710 1705 1711 TP_fast_assign( 1706 1712 __entry->call = call->debug_id; 1707 - __entry->change = change; 1713 + __entry->ca_state = call->cong_ca_state; 1708 1714 __entry->hard_ack = call->acks_hard_ack; 1709 1715 __entry->top = call->tx_top; 1710 1716 __entry->lowest_nak = call->acks_lowest_nak; 1711 1717 __entry->ack_serial = ack_serial; 1718 + __entry->nr_sacks = call->acks_nr_sacks; 1719 + __entry->nr_snacks = call->acks_nr_snacks; 1720 + __entry->cwnd = call->cong_cwnd; 1721 + __entry->ssthresh = call->cong_ssthresh; 1722 + __entry->cumul_acks = call->cong_cumul_acks; 1723 + __entry->dup_acks = call->cong_dup_acks; 1712 1724 memcpy(&__entry->sum, summary, sizeof(__entry->sum)); 1713 1725 ), 1714 1726 ··· 1729 1717 __entry->ack_serial, 1730 1718 __print_symbolic(__entry->sum.ack_reason, rxrpc_ack_names), 1731 1719 __entry->hard_ack, 1732 - __print_symbolic(__entry->sum.mode, rxrpc_congest_modes), 1733 - __entry->sum.cwnd, 1734 - __entry->sum.ssthresh, 1735 - __entry->sum.nr_acks, __entry->sum.nr_retained_nacks, 1736 - __entry->sum.nr_new_acks, 1737 - __entry->sum.nr_new_nacks, 1720 + __print_symbolic(__entry->ca_state, rxrpc_ca_states), 1721 + __entry->cwnd, 1722 + __entry->ssthresh, 1723 + __entry->nr_sacks, __entry->sum.nr_retained_snacks, 1724 + __entry->sum.nr_new_sacks, 1725 + __entry->sum.nr_new_snacks, 1738 1726 __entry->top - __entry->hard_ack, 1739 - __entry->sum.cumulative_acks, 1740 - __entry->sum.dup_acks, 1741 - __entry->lowest_nak, __entry->sum.new_low_nack ? "!" : "", 1742 - __print_symbolic(__entry->change, rxrpc_congest_changes), 1727 + __entry->cumul_acks, 1728 + __entry->dup_acks, 1729 + __entry->lowest_nak, __entry->sum.new_low_snack ? "!" : "", 1730 + __print_symbolic(__entry->sum.change, rxrpc_congest_changes), 1743 1731 __entry->sum.retrans_timeo ? " rTxTo" : "") 1744 1732 ); 1745 1733 ··· 1750 1738 1751 1739 TP_STRUCT__entry( 1752 1740 __field(unsigned int, call) 1753 - __field(enum rxrpc_congest_mode, mode) 1741 + __field(enum rxrpc_ca_state, ca_state) 1754 1742 __field(unsigned short, cwnd) 1755 1743 __field(unsigned short, extra) 1756 1744 __field(rxrpc_seq_t, hard_ack) ··· 1761 1749 1762 1750 TP_fast_assign( 1763 1751 __entry->call = call->debug_id; 1764 - __entry->mode = call->cong_mode; 1752 + __entry->ca_state = call->cong_ca_state; 1765 1753 __entry->cwnd = call->cong_cwnd; 1766 1754 __entry->extra = call->cong_extra; 1767 1755 __entry->hard_ack = call->acks_hard_ack; ··· 1773 1761 TP_printk("c=%08x q=%08x %s cw=%u+%u pr=%u tm=%llu d=%u", 1774 1762 __entry->call, 1775 1763 __entry->hard_ack, 1776 - __print_symbolic(__entry->mode, rxrpc_congest_modes), 1764 + __print_symbolic(__entry->ca_state, rxrpc_ca_states), 1777 1765 __entry->cwnd, 1778 1766 __entry->extra, 1779 1767 __entry->prepared,

+24 -27

net/rxrpc/ar-internal.h

··· 623 623 /* 624 624 * Call Tx congestion management modes. 625 625 */ 626 - enum rxrpc_congest_mode { 627 - RXRPC_CALL_SLOW_START, 628 - RXRPC_CALL_CONGEST_AVOIDANCE, 629 - RXRPC_CALL_PACKET_LOSS, 630 - RXRPC_CALL_FAST_RETRANSMIT, 631 - NR__RXRPC_CONGEST_MODES 632 - }; 626 + enum rxrpc_ca_state { 627 + RXRPC_CA_SLOW_START, 628 + RXRPC_CA_CONGEST_AVOIDANCE, 629 + RXRPC_CA_PACKET_LOSS, 630 + RXRPC_CA_FAST_RETRANSMIT, 631 + NR__RXRPC_CA_STATES 632 + } __mode(byte); 633 633 634 634 /* 635 635 * RxRPC call definition ··· 727 727 */ 728 728 #define RXRPC_TX_SMSS RXRPC_JUMBO_DATALEN 729 729 #define RXRPC_MIN_CWND 4 730 - u8 cong_cwnd; /* Congestion window size */ 730 + enum rxrpc_ca_state cong_ca_state; /* Congestion control state */ 731 731 u8 cong_extra; /* Extra to send for congestion management */ 732 - u8 cong_ssthresh; /* Slow-start threshold */ 733 - enum rxrpc_congest_mode cong_mode:8; /* Congestion management mode */ 734 - u8 cong_dup_acks; /* Count of ACKs showing missing packets */ 735 - u8 cong_cumul_acks; /* Cumulative ACK count */ 732 + u16 cong_cwnd; /* Congestion window size */ 733 + u16 cong_ssthresh; /* Slow-start threshold */ 734 + u16 cong_dup_acks; /* Count of ACKs showing missing packets */ 735 + u16 cong_cumul_acks; /* Cumulative ACK count */ 736 736 ktime_t cong_tstamp; /* Last time cwnd was changed */ 737 737 struct sk_buff *cong_last_nack; /* Last ACK with nacks received */ 738 738 ··· 763 763 rxrpc_seq_t acks_prev_seq; /* Highest previousPacket received */ 764 764 rxrpc_seq_t acks_lowest_nak; /* Lowest NACK in the buffer (or ==tx_hard_ack) */ 765 765 rxrpc_serial_t acks_highest_serial; /* Highest serial number ACK'd */ 766 + unsigned short acks_nr_sacks; /* Number of soft acks recorded */ 767 + unsigned short acks_nr_snacks; /* Number of soft nacks recorded */ 766 768 }; 767 769 768 770 /* 769 771 * Summary of a new ACK and the changes it made to the Tx buffer packet states. 770 772 */ 771 773 struct rxrpc_ack_summary { 772 - u16 nr_acks; /* Number of ACKs in packet */ 773 - u16 nr_new_acks; /* Number of new ACKs in packet */ 774 - u16 nr_new_nacks; /* Number of new nacks in packet */ 775 - u16 nr_retained_nacks; /* Number of nacks retained between ACKs */ 776 - u8 ack_reason; 777 - bool saw_nacks; /* Saw NACKs in packet */ 778 - bool new_low_nack; /* T if new low NACK found */ 779 - bool retrans_timeo; /* T if reTx due to timeout happened */ 780 - u8 flight_size; /* Number of unreceived transmissions */ 781 - /* Place to stash values for tracing */ 782 - enum rxrpc_congest_mode mode:8; 783 - u8 cwnd; 784 - u8 ssthresh; 785 - u8 dup_acks; 786 - u8 cumulative_acks; 774 + u16 in_flight; /* Number of unreceived transmissions */ 775 + u16 nr_new_hacks; /* Number of rotated new ACKs */ 776 + u16 nr_new_sacks; /* Number of new soft ACKs in packet */ 777 + u16 nr_new_snacks; /* Number of new soft nacks in packet */ 778 + u16 nr_retained_snacks; /* Number of nacks retained between ACKs */ 779 + u8 ack_reason; 780 + bool saw_snacks:1; /* T if we saw a soft NACK */ 781 + bool new_low_snack:1; /* T if new low soft NACK found */ 782 + bool retrans_timeo:1; /* T if reTx due to timeout happened */ 783 + u8 /*enum rxrpc_congest_change*/ change; 787 784 }; 788 785 789 786 /*

+2 -2

net/rxrpc/conn_client.c

··· 437 437 call->dest_srx.srx_service = conn->service_id; 438 438 call->cong_ssthresh = call->peer->cong_ssthresh; 439 439 if (call->cong_cwnd >= call->cong_ssthresh) 440 - call->cong_mode = RXRPC_CALL_CONGEST_AVOIDANCE; 440 + call->cong_ca_state = RXRPC_CA_CONGEST_AVOIDANCE; 441 441 else 442 - call->cong_mode = RXRPC_CALL_SLOW_START; 442 + call->cong_ca_state = RXRPC_CA_SLOW_START; 443 443 444 444 chan->call_id = call_id; 445 445 chan->call_debug_id = call->debug_id;

+70 -81

net/rxrpc/input.c

··· 34 34 struct rxrpc_ack_summary *summary, 35 35 rxrpc_serial_t acked_serial) 36 36 { 37 - enum rxrpc_congest_change change = rxrpc_cong_no_change; 38 - unsigned int cumulative_acks = call->cong_cumul_acks; 39 - unsigned int cwnd = call->cong_cwnd; 40 37 bool resend = false; 41 38 42 - summary->flight_size = 43 - (call->tx_top - call->tx_bottom) - summary->nr_acks; 39 + summary->change = rxrpc_cong_no_change; 40 + summary->in_flight = (call->tx_top - call->tx_bottom) - call->acks_nr_sacks; 44 41 45 42 if (test_and_clear_bit(RXRPC_CALL_RETRANS_TIMEOUT, &call->flags)) { 46 43 summary->retrans_timeo = true; 47 - call->cong_ssthresh = umax(summary->flight_size / 2, 2); 48 - cwnd = 1; 49 - if (cwnd >= call->cong_ssthresh && 50 - call->cong_mode == RXRPC_CALL_SLOW_START) { 51 - call->cong_mode = RXRPC_CALL_CONGEST_AVOIDANCE; 44 + call->cong_ssthresh = umax(summary->in_flight / 2, 2); 45 + call->cong_cwnd = 1; 46 + if (call->cong_cwnd >= call->cong_ssthresh && 47 + call->cong_ca_state == RXRPC_CA_SLOW_START) { 48 + call->cong_ca_state = RXRPC_CA_CONGEST_AVOIDANCE; 52 49 call->cong_tstamp = skb->tstamp; 53 - cumulative_acks = 0; 50 + call->cong_cumul_acks = 0; 54 51 } 55 52 } 56 53 57 - cumulative_acks += summary->nr_new_acks; 58 - if (cumulative_acks > 255) 59 - cumulative_acks = 255; 54 + call->cong_cumul_acks += summary->nr_new_sacks; 55 + if (call->cong_cumul_acks > 255) 56 + call->cong_cumul_acks = 255; 60 57 61 - summary->cwnd = call->cong_cwnd; 62 - summary->ssthresh = call->cong_ssthresh; 63 - summary->cumulative_acks = cumulative_acks; 64 - summary->dup_acks = call->cong_dup_acks; 65 - 66 - switch (call->cong_mode) { 67 - case RXRPC_CALL_SLOW_START: 68 - if (summary->saw_nacks) 58 + switch (call->cong_ca_state) { 59 + case RXRPC_CA_SLOW_START: 60 + if (summary->saw_snacks) 69 61 goto packet_loss_detected; 70 - if (summary->cumulative_acks > 0) 71 - cwnd += 1; 72 - if (cwnd >= call->cong_ssthresh) { 73 - call->cong_mode = RXRPC_CALL_CONGEST_AVOIDANCE; 62 + if (call->cong_cumul_acks > 0) 63 + call->cong_cwnd += 1; 64 + if (call->cong_cwnd >= call->cong_ssthresh) { 65 + call->cong_ca_state = RXRPC_CA_CONGEST_AVOIDANCE; 74 66 call->cong_tstamp = skb->tstamp; 75 67 } 76 68 goto out; 77 69 78 - case RXRPC_CALL_CONGEST_AVOIDANCE: 79 - if (summary->saw_nacks) 70 + case RXRPC_CA_CONGEST_AVOIDANCE: 71 + if (summary->saw_snacks) 80 72 goto packet_loss_detected; 81 73 82 74 /* We analyse the number of packets that get ACK'd per RTT ··· 80 88 ktime_add_us(call->cong_tstamp, 81 89 call->peer->srtt_us >> 3))) 82 90 goto out_no_clear_ca; 83 - change = rxrpc_cong_rtt_window_end; 91 + summary->change = rxrpc_cong_rtt_window_end; 84 92 call->cong_tstamp = skb->tstamp; 85 - if (cumulative_acks >= cwnd) 86 - cwnd++; 93 + if (call->cong_cumul_acks >= call->cong_cwnd) 94 + call->cong_cwnd++; 87 95 goto out; 88 96 89 - case RXRPC_CALL_PACKET_LOSS: 90 - if (!summary->saw_nacks) 97 + case RXRPC_CA_PACKET_LOSS: 98 + if (!summary->saw_snacks) 91 99 goto resume_normality; 92 100 93 - if (summary->new_low_nack) { 94 - change = rxrpc_cong_new_low_nack; 101 + if (summary->new_low_snack) { 102 + summary->change = rxrpc_cong_new_low_nack; 95 103 call->cong_dup_acks = 1; 96 104 if (call->cong_extra > 1) 97 105 call->cong_extra = 1; ··· 102 110 if (call->cong_dup_acks < 3) 103 111 goto send_extra_data; 104 112 105 - change = rxrpc_cong_begin_retransmission; 106 - call->cong_mode = RXRPC_CALL_FAST_RETRANSMIT; 107 - call->cong_ssthresh = umax(summary->flight_size / 2, 2); 108 - cwnd = call->cong_ssthresh + 3; 113 + summary->change = rxrpc_cong_begin_retransmission; 114 + call->cong_ca_state = RXRPC_CA_FAST_RETRANSMIT; 115 + call->cong_ssthresh = umax(summary->in_flight / 2, 2); 116 + call->cong_cwnd = call->cong_ssthresh + 3; 109 117 call->cong_extra = 0; 110 118 call->cong_dup_acks = 0; 111 119 resend = true; 112 120 goto out; 113 121 114 - case RXRPC_CALL_FAST_RETRANSMIT: 115 - if (!summary->new_low_nack) { 116 - if (summary->nr_new_acks == 0) 117 - cwnd += 1; 122 + case RXRPC_CA_FAST_RETRANSMIT: 123 + if (!summary->new_low_snack) { 124 + if (summary->nr_new_sacks == 0) 125 + call->cong_cwnd += 1; 118 126 call->cong_dup_acks++; 119 127 if (call->cong_dup_acks == 2) { 120 - change = rxrpc_cong_retransmit_again; 128 + summary->change = rxrpc_cong_retransmit_again; 121 129 call->cong_dup_acks = 0; 122 130 resend = true; 123 131 } 124 132 } else { 125 - change = rxrpc_cong_progress; 126 - cwnd = call->cong_ssthresh; 127 - if (!summary->saw_nacks) 133 + summary->change = rxrpc_cong_progress; 134 + call->cong_cwnd = call->cong_ssthresh; 135 + if (!summary->saw_snacks) 128 136 goto resume_normality; 129 137 } 130 138 goto out; ··· 135 143 } 136 144 137 145 resume_normality: 138 - change = rxrpc_cong_cleared_nacks; 146 + summary->change = rxrpc_cong_cleared_nacks; 139 147 call->cong_dup_acks = 0; 140 148 call->cong_extra = 0; 141 149 call->cong_tstamp = skb->tstamp; 142 - if (cwnd < call->cong_ssthresh) 143 - call->cong_mode = RXRPC_CALL_SLOW_START; 150 + if (call->cong_cwnd < call->cong_ssthresh) 151 + call->cong_ca_state = RXRPC_CA_SLOW_START; 144 152 else 145 - call->cong_mode = RXRPC_CALL_CONGEST_AVOIDANCE; 153 + call->cong_ca_state = RXRPC_CA_CONGEST_AVOIDANCE; 146 154 out: 147 - cumulative_acks = 0; 155 + call->cong_cumul_acks = 0; 148 156 out_no_clear_ca: 149 - if (cwnd >= RXRPC_TX_MAX_WINDOW) 150 - cwnd = RXRPC_TX_MAX_WINDOW; 151 - call->cong_cwnd = cwnd; 152 - call->cong_cumul_acks = cumulative_acks; 153 - summary->mode = call->cong_mode; 154 - trace_rxrpc_congest(call, summary, acked_serial, change); 157 + if (call->cong_cwnd >= RXRPC_TX_MAX_WINDOW) 158 + call->cong_cwnd = RXRPC_TX_MAX_WINDOW; 159 + trace_rxrpc_congest(call, summary, acked_serial); 155 160 if (resend) 156 161 rxrpc_resend(call, skb); 157 162 return; 158 163 159 164 packet_loss_detected: 160 - change = rxrpc_cong_saw_nack; 161 - call->cong_mode = RXRPC_CALL_PACKET_LOSS; 165 + summary->change = rxrpc_cong_saw_nack; 166 + call->cong_ca_state = RXRPC_CA_PACKET_LOSS; 162 167 call->cong_dup_acks = 0; 163 168 goto send_extra_data; 164 169 ··· 164 175 * state. 165 176 */ 166 177 if (test_bit(RXRPC_CALL_TX_LAST, &call->flags) || 167 - summary->nr_acks != call->tx_top - call->tx_bottom) { 178 + call->acks_nr_sacks != call->tx_top - call->tx_bottom) { 168 179 call->cong_extra++; 169 180 wake_up(&call->waitq); 170 181 } ··· 178 189 { 179 190 ktime_t rtt, now; 180 191 181 - if (call->cong_mode != RXRPC_CALL_SLOW_START && 182 - call->cong_mode != RXRPC_CALL_CONGEST_AVOIDANCE) 192 + if (call->cong_ca_state != RXRPC_CA_SLOW_START && 193 + call->cong_ca_state != RXRPC_CA_CONGEST_AVOIDANCE) 183 194 return; 184 195 if (__rxrpc_call_state(call) == RXRPC_CALL_CLIENT_AWAIT_REPLY) 185 196 return; ··· 192 203 trace_rxrpc_reset_cwnd(call, now); 193 204 rxrpc_inc_stat(call->rxnet, stat_tx_data_cwnd_reset); 194 205 call->tx_last_sent = now; 195 - call->cong_mode = RXRPC_CALL_SLOW_START; 206 + call->cong_ca_state = RXRPC_CA_SLOW_START; 196 207 call->cong_ssthresh = umax(call->cong_ssthresh, call->cong_cwnd * 3 / 4); 197 208 call->cong_cwnd = umax(call->cong_cwnd / 2, RXRPC_MIN_CWND); 198 209 } ··· 271 282 if (call->acks_lowest_nak == call->tx_bottom) { 272 283 call->acks_lowest_nak = to; 273 284 } else if (after(to, call->acks_lowest_nak)) { 274 - summary->new_low_nack = true; 285 + summary->new_low_snack = true; 275 286 call->acks_lowest_nak = to; 276 287 } 277 288 ··· 784 795 u8 *acks = skb->data + sizeof(struct rxrpc_wire_header) + sizeof(struct rxrpc_ackpacket); 785 796 786 797 if (after_eq(seq, old_seq + sp->ack.nr_acks)) { 787 - summary->nr_new_acks += sp->ack.nr_nacks; 788 - summary->nr_new_acks += seq - (old_seq + sp->ack.nr_acks); 789 - summary->nr_retained_nacks = 0; 798 + summary->nr_new_sacks += sp->ack.nr_nacks; 799 + summary->nr_new_sacks += seq - (old_seq + sp->ack.nr_acks); 800 + summary->nr_retained_snacks = 0; 790 801 } else if (seq == old_seq) { 791 - summary->nr_retained_nacks = sp->ack.nr_nacks; 802 + summary->nr_retained_snacks = sp->ack.nr_nacks; 792 803 } else { 793 804 for (i = 0; i < sp->ack.nr_acks; i++) { 794 805 if (acks[i] == RXRPC_ACK_TYPE_NACK) { ··· 799 810 } 800 811 } 801 812 802 - summary->nr_new_acks += new_acks; 803 - summary->nr_retained_nacks = retained_nacks; 813 + summary->nr_new_sacks += new_acks; 814 + summary->nr_retained_snacks = retained_nacks; 804 815 } 805 816 806 817 return old_seq + sp->ack.nr_acks - 1; ··· 829 840 for (i = 0; i < sp->ack.nr_acks; i++) { 830 841 seq++; 831 842 if (acks[i] == RXRPC_ACK_TYPE_ACK) { 832 - summary->nr_acks++; 843 + call->acks_nr_sacks++; 833 844 if (after(seq, since)) 834 - summary->nr_new_acks++; 845 + summary->nr_new_sacks++; 835 846 } else { 836 - summary->saw_nacks = true; 847 + summary->saw_snacks = true; 837 848 if (before_eq(seq, since)) { 838 849 /* Overlap with previous ACK */ 839 850 old_nacks++; 840 851 } else { 841 - summary->nr_new_nacks++; 852 + summary->nr_new_snacks++; 842 853 sp->ack.nr_nacks++; 843 854 } 844 855 ··· 849 860 850 861 if (lowest_nak != call->acks_lowest_nak) { 851 862 call->acks_lowest_nak = lowest_nak; 852 - summary->new_low_nack = true; 863 + summary->new_low_snack = true; 853 864 } 854 865 855 866 /* We *can* have more nacks than we did - the peer is permitted to drop ··· 857 868 * possible for the nack distribution to change whilst the number of 858 869 * nacks stays the same or goes down. 859 870 */ 860 - if (old_nacks < summary->nr_retained_nacks) 861 - summary->nr_new_acks += summary->nr_retained_nacks - old_nacks; 862 - summary->nr_retained_nacks = old_nacks; 871 + if (old_nacks < summary->nr_retained_snacks) 872 + summary->nr_new_sacks += summary->nr_retained_snacks - old_nacks; 873 + summary->nr_retained_snacks = old_nacks; 863 874 } 864 875 865 876 /* ··· 985 996 rxrpc_free_skb(call->cong_last_nack, rxrpc_skb_put_last_nack); 986 997 call->cong_last_nack = NULL; 987 998 } else { 988 - summary.nr_new_acks = hard_ack - call->acks_hard_ack; 999 + summary.nr_new_sacks = hard_ack - call->acks_hard_ack; 989 1000 call->acks_lowest_nak = hard_ack + nr_acks; 990 1001 since = hard_ack; 991 1002 } ··· 1043 1054 } 1044 1055 1045 1056 if (test_bit(RXRPC_CALL_TX_LAST, &call->flags) && 1046 - summary.nr_acks == call->tx_top - hard_ack && 1057 + call->acks_nr_sacks == call->tx_top - hard_ack && 1047 1058 rxrpc_is_client_call(call)) 1048 1059 rxrpc_propose_ping(call, ack_serial, 1049 1060 rxrpc_propose_ack_ping_for_lost_reply);

+1 -1

net/rxrpc/output.c

··· 419 419 why = rxrpc_reqack_ack_lost; 420 420 else if (txb->flags & RXRPC_TXBUF_RESENT) 421 421 why = rxrpc_reqack_retrans; 422 - else if (call->cong_mode == RXRPC_CALL_SLOW_START && call->cong_cwnd <= 2) 422 + else if (call->cong_ca_state == RXRPC_CA_SLOW_START && call->cong_cwnd <= 2) 423 423 why = rxrpc_reqack_slow_start; 424 424 else if (call->tx_winsize <= 2) 425 425 why = rxrpc_reqack_small_txwin;

Configure Feed

Configure Feed