net/rxrpc/call_event.c

23 void rxrpc_propose_ping(struct rxrpc_call *call, u32 serial,
30 	trace_rxrpc_propose_ack(call, why, RXRPC_ACK_PING, serial);
31 	if (ktime_before(ping_at, call->ping_at)) {
32 		call->ping_at = ping_at;
33 		trace_rxrpc_timer_set(call, delay, rxrpc_timer_trace_ping);
40 void rxrpc_propose_delay_ACK(struct rxrpc_call *call, rxrpc_serial_t serial,
45 	trace_rxrpc_propose_ack(call, why, RXRPC_ACK_DELAY, serial);
47 	if (call->peer->srtt_us)
48 		delay = (call->peer->srtt_us >> 3) * NSEC_PER_USEC;
51 	ktime_add_ms(delay, call->tx_backoff);
53 	call->delay_ack_at = ktime_add(now, delay);
54 	trace_rxrpc_timer_set(call, delay, rxrpc_timer_trace_delayed_ack);
60 static void rxrpc_congestion_timeout(struct rxrpc_call *call)
62 	set_bit(RXRPC_CALL_RETRANS_TIMEOUT, &call->flags);
68 void rxrpc_resend(struct rxrpc_call *call, struct sk_buff *ack_skb)
73 	rxrpc_seq_t transmitted = call->tx_transmitted;
74 	ktime_t next_resend = KTIME_MAX, rto = ns_to_ktime(call->peer->rto_us * NSEC_PER_USEC);
79 	_enter("{%d,%d}", call->acks_hard_ack, call->tx_top);
83 	if (list_empty(&call->tx_buffer))
86 	trace_rxrpc_resend(call, ack_skb);
87 	txb = list_first_entry(&call->tx_buffer, struct rxrpc_txbuf, call_link);
106 			list_for_each_entry_from(txb, &call->tx_buffer, call_link) {
114 			if (after(txb->serial, call->acks_highest_serial)) {
123 			trace_rxrpc_retransmit(call, txb->seq, txb->serial,
127 			rxrpc_transmit_one(call, txb);
131 			if (list_is_last(&txb->call_link, &call->tx_buffer))
142 	if (after_eq(call->acks_prev_seq, call->tx_transmitted))
145 	list_for_each_entry_from(txb, &call->tx_buffer, call_link) {
148 		if (before_eq(txb->seq, call->acks_prev_seq))
150 		if (after(txb->seq, call->tx_transmitted))
167 		rxrpc_transmit_one(call, txb);
169 		rxrpc_inc_stat(call->rxnet, stat_tx_data_retrans);
176 		delay = rxrpc_get_rto_backoff(call->peer, did_send);
178 		trace_rxrpc_timer_set(call, resend_at - now, rxrpc_timer_trace_resend_reset);
180 	call->resend_at = resend_at;
183 		rxrpc_congestion_timeout(call);
190 		ktime_t next_ping = ktime_add_us(call->acks_latest_ts,
191 						 call->peer->srtt_us >> 3);
194 			rxrpc_send_ACK(call, RXRPC_ACK_PING, 0,
205 static void rxrpc_begin_service_reply(struct rxrpc_call *call)
207 	rxrpc_set_call_state(call, RXRPC_CALL_SERVER_SEND_REPLY);
208 	if (call->ackr_reason == RXRPC_ACK_DELAY)
209 		call->ackr_reason = 0;
210 	call->delay_ack_at = KTIME_MAX;
211 	trace_rxrpc_timer_can(call, rxrpc_timer_trace_delayed_ack);
216  * transmitted in the call.
218 static void rxrpc_close_tx_phase(struct rxrpc_call *call)
222 	switch (__rxrpc_call_state(call)) {
224 		rxrpc_set_call_state(call, RXRPC_CALL_CLIENT_AWAIT_REPLY);
227 		rxrpc_set_call_state(call, RXRPC_CALL_SERVER_AWAIT_ACK);
234 static bool rxrpc_tx_window_has_space(struct rxrpc_call *call)
236 	unsigned int winsize = min_t(unsigned int, call->tx_winsize,
237 				     call->cong_cwnd + call->cong_extra);
238 	rxrpc_seq_t window = call->acks_hard_ack, wtop = window + winsize;
239 	rxrpc_seq_t tx_top = call->tx_top;
249 static void rxrpc_decant_prepared_tx(struct rxrpc_call *call)
253 	if (!test_bit(RXRPC_CALL_EXPOSED, &call->flags)) {
254 		if (list_empty(&call->tx_sendmsg))
256 		rxrpc_expose_client_call(call);
259 	while ((txb = list_first_entry_or_null(&call->tx_sendmsg,
261 		spin_lock(&call->tx_lock);
263 		spin_unlock(&call->tx_lock);
265 		call->tx_top = txb->seq;
266 		list_add_tail(&txb->call_link, &call->tx_buffer);
269 			rxrpc_close_tx_phase(call);
271 		rxrpc_transmit_one(call, txb);
273 		if (!rxrpc_tx_window_has_space(call))
278 static void rxrpc_transmit_some_data(struct rxrpc_call *call)
280 	switch (__rxrpc_call_state(call)) {
282 		if (list_empty(&call->tx_sendmsg))
284 		rxrpc_begin_service_reply(call);
289 		if (!rxrpc_tx_window_has_space(call))
291 		if (list_empty(&call->tx_sendmsg)) {
292 			rxrpc_inc_stat(call->rxnet, stat_tx_data_underflow);
295 		rxrpc_decant_prepared_tx(call);
306 static void rxrpc_send_initial_ping(struct rxrpc_call *call)
308 	if (call->peer->rtt_count < 3 ||
309 	    ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000),
311 		rxrpc_send_ACK(call, RXRPC_ACK_PING, 0,
318 bool rxrpc_input_call_event(struct rxrpc_call *call, struct sk_buff *skb)
324 	rxrpc_see_call(call, rxrpc_call_see_input);
328 	       call->debug_id, rxrpc_call_states[__rxrpc_call_state(call)],
329 	       call->events);
331 	if (__rxrpc_call_is_complete(call))
335 	abort_code = smp_load_acquire(&call->send_abort);
337 		rxrpc_abort_call(call, 0, call->send_abort, call->send_abort_err,
338 				 call->send_abort_why);
346 		rxrpc_input_call_packet(call, skb);
350 	t = ktime_sub(call->expect_rx_by, now);
352 		trace_rxrpc_timer_exp(call, t, rxrpc_timer_trace_expect_rx);
356 	t = ktime_sub(call->expect_req_by, now);
358 		call->expect_req_by = KTIME_MAX;
359 		if (__rxrpc_call_state(call) == RXRPC_CALL_SERVER_RECV_REQUEST) {
360 			trace_rxrpc_timer_exp(call, t, rxrpc_timer_trace_idle);
365 	t = ktime_sub(READ_ONCE(call->expect_term_by), now);
367 		trace_rxrpc_timer_exp(call, t, rxrpc_timer_trace_hard);
371 	t = ktime_sub(call->delay_ack_at, now);
373 		trace_rxrpc_timer_exp(call, t, rxrpc_timer_trace_delayed_ack);
374 		call->delay_ack_at = KTIME_MAX;
375 		rxrpc_send_ACK(call, RXRPC_ACK_DELAY, 0,
379 	t = ktime_sub(call->ack_lost_at, now);
381 		trace_rxrpc_timer_exp(call, t, rxrpc_timer_trace_lost_ack);
382 		call->ack_lost_at = KTIME_MAX;
383 		set_bit(RXRPC_CALL_EV_ACK_LOST, &call->events);
386 	t = ktime_sub(call->ping_at, now);
388 		trace_rxrpc_timer_exp(call, t, rxrpc_timer_trace_ping);
389 		call->ping_at = KTIME_MAX;
390 		rxrpc_send_ACK(call, RXRPC_ACK_PING, 0,
394 	t = ktime_sub(call->resend_at, now);
396 		trace_rxrpc_timer_exp(call, t, rxrpc_timer_trace_resend);
397 		call->resend_at = KTIME_MAX;
401 	rxrpc_transmit_some_data(call);
404 	t = ktime_sub(call->keepalive_at, now);
406 		trace_rxrpc_timer_exp(call, t, rxrpc_timer_trace_keepalive);
407 		call->keepalive_at = KTIME_MAX;
408 		rxrpc_send_ACK(call, RXRPC_ACK_PING, 0,
416 			rxrpc_congestion_degrade(call);
419 	if (test_and_clear_bit(RXRPC_CALL_EV_INITIAL_PING, &call->events))
420 		rxrpc_send_initial_ping(call);
423 	if (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST, &call->events))
424 		rxrpc_send_ACK(call, RXRPC_ACK_PING, 0,
428 	    __rxrpc_call_state(call) != RXRPC_CALL_CLIENT_RECV_REPLY &&
429 	    !test_bit(RXRPC_CALL_TX_ALL_ACKED, &call->flags))
430 		rxrpc_resend(call, NULL);
432 	if (test_and_clear_bit(RXRPC_CALL_RX_IS_IDLE, &call->flags))
433 		rxrpc_send_ACK(call, RXRPC_ACK_IDLE, 0,
436 	if (call->ackr_nr_unacked > 2) {
437 		if (call->peer->rtt_count < 3)
438 			rxrpc_send_ACK(call, RXRPC_ACK_PING, 0,
440 		else if (ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000),
442 			rxrpc_send_ACK(call, RXRPC_ACK_PING, 0,
445 			rxrpc_send_ACK(call, RXRPC_ACK_IDLE, 0,
450 	if (!__rxrpc_call_is_complete(call)) {
451 		ktime_t next = READ_ONCE(call->expect_term_by), delay;
455 		set(call->expect_req_by);
456 		set(call->expect_rx_by);
457 		set(call->delay_ack_at);
458 		set(call->ack_lost_at);
459 		set(call->resend_at);
460 		set(call->keepalive_at);
461 		set(call->ping_at);
466 			rxrpc_poke_call(call, rxrpc_call_poke_timer_now);
472 			if (time_before(nextj, call->timer.expires) ||
473 			    !timer_pending(&call->timer)) {
474 				trace_rxrpc_timer_restart(call, delay, delayj);
475 				timer_reduce(&call->timer, nextj);
481 	if (__rxrpc_call_is_complete(call)) {
482 		del_timer_sync(&call->timer);
483 		if (!test_bit(RXRPC_CALL_DISCONNECTED, &call->flags))
484 			rxrpc_disconnect_call(call);
485 		if (call->security)
486 			call->security->free_call_crypto(call);
488 	if (call->acks_hard_ack != call->tx_bottom)
489 		rxrpc_shrink_call_tx_buffer(call);
494 	if (test_bit(RXRPC_CALL_RX_HEARD, &call->flags) &&
495 	    (int)call->conn->hi_serial - (int)call->rx_serial > 0) {
496 		trace_rxrpc_call_reset(call);
497 		rxrpc_abort_call(call, 0, RX_CALL_DEAD, -ECONNRESET,
500 		rxrpc_abort_call(call, 0, RX_CALL_TIMEOUT, -ETIME,