Lines Matching +full:diff +full:- +full:channels
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Client connection-specific management code.
13 * (2) DONT_REUSE - The connection should be discarded as soon as possible and
31 #include "ar-internal.h"
38 * We use machine-unique IDs for our client connections.
52 struct rxrpc_net *rxnet = conn->params.local->rxnet; in rxrpc_get_client_connection_id()
68 conn->proto.epoch = rxnet->epoch; in rxrpc_get_client_connection_id()
69 conn->proto.cid = id << RXRPC_CIDSHIFT; in rxrpc_get_client_connection_id()
70 set_bit(RXRPC_CONN_HAS_IDR, &conn->flags); in rxrpc_get_client_connection_id()
71 _leave(" [CID %x]", conn->proto.cid); in rxrpc_get_client_connection_id()
86 if (test_bit(RXRPC_CONN_HAS_IDR, &conn->flags)) { in rxrpc_put_client_connection_id()
89 conn->proto.cid >> RXRPC_CIDSHIFT); in rxrpc_put_client_connection_id()
105 conn, atomic_read(&conn->usage)); in rxrpc_destroy_client_conn_ids()
123 bundle->params = *cp; in rxrpc_alloc_bundle()
124 rxrpc_get_peer(bundle->params.peer); in rxrpc_alloc_bundle()
125 atomic_set(&bundle->usage, 1); in rxrpc_alloc_bundle()
126 spin_lock_init(&bundle->channel_lock); in rxrpc_alloc_bundle()
127 INIT_LIST_HEAD(&bundle->waiting_calls); in rxrpc_alloc_bundle()
134 atomic_inc(&bundle->usage); in rxrpc_get_bundle()
140 rxrpc_put_peer(bundle->params.peer); in rxrpc_free_bundle()
146 unsigned int d = bundle->debug_id; in rxrpc_put_bundle()
147 unsigned int u = atomic_dec_return(&bundle->usage); in rxrpc_put_bundle()
161 struct rxrpc_net *rxnet = bundle->params.local->rxnet; in rxrpc_alloc_client_connection()
168 _leave(" = -ENOMEM"); in rxrpc_alloc_client_connection()
169 return ERR_PTR(-ENOMEM); in rxrpc_alloc_client_connection()
172 atomic_set(&conn->usage, 1); in rxrpc_alloc_client_connection()
173 conn->bundle = bundle; in rxrpc_alloc_client_connection()
174 conn->params = bundle->params; in rxrpc_alloc_client_connection()
175 conn->out_clientflag = RXRPC_CLIENT_INITIATED; in rxrpc_alloc_client_connection()
176 conn->state = RXRPC_CONN_CLIENT; in rxrpc_alloc_client_connection()
177 conn->service_id = conn->params.service_id; in rxrpc_alloc_client_connection()
187 ret = conn->security->prime_packet_security(conn); in rxrpc_alloc_client_connection()
191 atomic_inc(&rxnet->nr_conns); in rxrpc_alloc_client_connection()
192 write_lock(&rxnet->conn_lock); in rxrpc_alloc_client_connection()
193 list_add_tail(&conn->proc_link, &rxnet->conn_proc_list); in rxrpc_alloc_client_connection()
194 write_unlock(&rxnet->conn_lock); in rxrpc_alloc_client_connection()
197 rxrpc_get_peer(conn->params.peer); in rxrpc_alloc_client_connection()
198 rxrpc_get_local(conn->params.local); in rxrpc_alloc_client_connection()
199 key_get(conn->params.key); in rxrpc_alloc_client_connection()
201 trace_rxrpc_conn(conn->debug_id, rxrpc_conn_new_client, in rxrpc_alloc_client_connection()
202 atomic_read(&conn->usage), in rxrpc_alloc_client_connection()
205 atomic_inc(&rxnet->nr_client_conns); in rxrpc_alloc_client_connection()
206 trace_rxrpc_client(conn, -1, rxrpc_client_alloc); in rxrpc_alloc_client_connection()
211 conn->security->clear(conn); in rxrpc_alloc_client_connection()
231 rxnet = conn->params.local->rxnet; in rxrpc_may_reuse_conn()
232 if (test_bit(RXRPC_CONN_DONT_REUSE, &conn->flags)) in rxrpc_may_reuse_conn()
235 if (conn->state != RXRPC_CONN_CLIENT || in rxrpc_may_reuse_conn()
236 conn->proto.epoch != rxnet->epoch) in rxrpc_may_reuse_conn()
246 id = conn->proto.cid >> RXRPC_CIDSHIFT; in rxrpc_may_reuse_conn()
247 distance = id - id_cursor; in rxrpc_may_reuse_conn()
249 distance = -distance; in rxrpc_may_reuse_conn()
250 limit = max_t(unsigned long, atomic_read(&rxnet->nr_conns) * 4, 1024); in rxrpc_may_reuse_conn()
257 set_bit(RXRPC_CONN_DONT_REUSE, &conn->flags); in rxrpc_may_reuse_conn()
271 struct rxrpc_local *local = cp->local; in rxrpc_look_up_bundle()
273 long diff; in rxrpc_look_up_bundle() local
276 cp->peer, key_serial(cp->key), cp->security_level, cp->upgrade); in rxrpc_look_up_bundle()
278 if (cp->exclusive) in rxrpc_look_up_bundle()
283 spin_lock(&local->client_bundles_lock); in rxrpc_look_up_bundle()
284 p = local->client_bundles.rb_node; in rxrpc_look_up_bundle()
288 #define cmp(X) ((long)bundle->params.X - (long)cp->X) in rxrpc_look_up_bundle()
289 diff = (cmp(peer) ?: in rxrpc_look_up_bundle()
294 if (diff < 0) in rxrpc_look_up_bundle()
295 p = p->rb_left; in rxrpc_look_up_bundle()
296 else if (diff > 0) in rxrpc_look_up_bundle()
297 p = p->rb_right; in rxrpc_look_up_bundle()
301 spin_unlock(&local->client_bundles_lock); in rxrpc_look_up_bundle()
310 spin_lock(&local->client_bundles_lock); in rxrpc_look_up_bundle()
311 pp = &local->client_bundles.rb_node; in rxrpc_look_up_bundle()
317 #define cmp(X) ((long)bundle->params.X - (long)cp->X) in rxrpc_look_up_bundle()
318 diff = (cmp(peer) ?: in rxrpc_look_up_bundle()
323 if (diff < 0) in rxrpc_look_up_bundle()
324 pp = &(*pp)->rb_left; in rxrpc_look_up_bundle()
325 else if (diff > 0) in rxrpc_look_up_bundle()
326 pp = &(*pp)->rb_right; in rxrpc_look_up_bundle()
332 candidate->debug_id = atomic_inc_return(&rxrpc_bundle_id); in rxrpc_look_up_bundle()
333 rb_link_node(&candidate->local_node, parent, pp); in rxrpc_look_up_bundle()
334 rb_insert_color(&candidate->local_node, &local->client_bundles); in rxrpc_look_up_bundle()
336 spin_unlock(&local->client_bundles_lock); in rxrpc_look_up_bundle()
337 _leave(" = %u [new]", candidate->debug_id); in rxrpc_look_up_bundle()
344 spin_unlock(&local->client_bundles_lock); in rxrpc_look_up_bundle()
345 _leave(" = %u [found]", bundle->debug_id); in rxrpc_look_up_bundle()
363 _enter("{%d,%lx},", call->debug_id, call->user_call_ID); in rxrpc_prep_call()
365 cp->peer = rxrpc_lookup_peer(rx, cp->local, srx, gfp); in rxrpc_prep_call()
366 if (!cp->peer) in rxrpc_prep_call()
369 call->cong_cwnd = cp->peer->cong_cwnd; in rxrpc_prep_call()
370 if (call->cong_cwnd >= call->cong_ssthresh) in rxrpc_prep_call()
371 call->cong_mode = RXRPC_CALL_CONGEST_AVOIDANCE; in rxrpc_prep_call()
373 call->cong_mode = RXRPC_CALL_SLOW_START; in rxrpc_prep_call()
374 if (cp->upgrade) in rxrpc_prep_call()
375 __set_bit(RXRPC_CALL_UPGRADE, &call->flags); in rxrpc_prep_call()
385 spin_lock(&bundle->channel_lock); in rxrpc_prep_call()
386 list_add_tail(&call->chan_wait_link, &bundle->waiting_calls); in rxrpc_prep_call()
387 spin_unlock(&bundle->channel_lock); in rxrpc_prep_call()
389 _leave(" = [B=%x]", bundle->debug_id); in rxrpc_prep_call()
393 _leave(" = -ENOMEM"); in rxrpc_prep_call()
394 return ERR_PTR(-ENOMEM); in rxrpc_prep_call()
401 __releases(bundle->channel_lock) in rxrpc_add_conn_to_bundle()
409 conflict = bundle->alloc_conn; in rxrpc_add_conn_to_bundle()
411 bundle->alloc_conn = true; in rxrpc_add_conn_to_bundle()
412 spin_unlock(&bundle->channel_lock); in rxrpc_add_conn_to_bundle()
420 spin_lock(&bundle->channel_lock); in rxrpc_add_conn_to_bundle()
421 bundle->alloc_conn = false; in rxrpc_add_conn_to_bundle()
424 bundle->alloc_error = PTR_ERR(candidate); in rxrpc_add_conn_to_bundle()
425 spin_unlock(&bundle->channel_lock); in rxrpc_add_conn_to_bundle()
430 bundle->alloc_error = 0; in rxrpc_add_conn_to_bundle()
432 for (i = 0; i < ARRAY_SIZE(bundle->conns); i++) { in rxrpc_add_conn_to_bundle()
436 old = bundle->conns[i]; in rxrpc_add_conn_to_bundle()
439 trace_rxrpc_client(old, -1, rxrpc_client_replace); in rxrpc_add_conn_to_bundle()
440 candidate->bundle_shift = shift; in rxrpc_add_conn_to_bundle()
441 bundle->conns[i] = candidate; in rxrpc_add_conn_to_bundle()
443 set_bit(shift + j, &bundle->avail_chans); in rxrpc_add_conn_to_bundle()
451 spin_unlock(&bundle->channel_lock); in rxrpc_add_conn_to_bundle()
454 _debug("discard C=%x", candidate->debug_id); in rxrpc_add_conn_to_bundle()
455 trace_rxrpc_client(candidate, -1, rxrpc_client_duplicate); in rxrpc_add_conn_to_bundle()
474 spin_lock(&bundle->channel_lock); in rxrpc_maybe_add_conn()
478 for (i = 0; i < ARRAY_SIZE(bundle->conns); i++) in rxrpc_maybe_add_conn()
479 if (rxrpc_may_reuse_conn(bundle->conns[i])) in rxrpc_maybe_add_conn()
482 if (!usable && !list_empty(&bundle->waiting_calls)) { in rxrpc_maybe_add_conn()
483 call = list_first_entry(&bundle->waiting_calls, in rxrpc_maybe_add_conn()
485 if (test_bit(RXRPC_CALL_UPGRADE, &call->flags)) in rxrpc_maybe_add_conn()
486 bundle->try_upgrade = true; in rxrpc_maybe_add_conn()
492 if (!bundle->avail_chans && in rxrpc_maybe_add_conn()
493 !bundle->try_upgrade && in rxrpc_maybe_add_conn()
494 !list_empty(&bundle->waiting_calls) && in rxrpc_maybe_add_conn()
495 usable < ARRAY_SIZE(bundle->conns)) in rxrpc_maybe_add_conn()
498 spin_unlock(&bundle->channel_lock); in rxrpc_maybe_add_conn()
514 struct rxrpc_channel *chan = &conn->channels[channel]; in rxrpc_activate_one_channel()
515 struct rxrpc_bundle *bundle = conn->bundle; in rxrpc_activate_one_channel()
516 struct rxrpc_call *call = list_entry(bundle->waiting_calls.next, in rxrpc_activate_one_channel()
518 u32 call_id = chan->call_counter + 1; in rxrpc_activate_one_channel()
520 _enter("C=%x,%u", conn->debug_id, channel); in rxrpc_activate_one_channel()
527 clear_bit(RXRPC_CONN_FINAL_ACK_0 + channel, &conn->flags); in rxrpc_activate_one_channel()
528 clear_bit(conn->bundle_shift + channel, &bundle->avail_chans); in rxrpc_activate_one_channel()
531 list_del_init(&call->chan_wait_link); in rxrpc_activate_one_channel()
532 call->peer = rxrpc_get_peer(conn->params.peer); in rxrpc_activate_one_channel()
533 call->conn = rxrpc_get_connection(conn); in rxrpc_activate_one_channel()
534 call->cid = conn->proto.cid | channel; in rxrpc_activate_one_channel()
535 call->call_id = call_id; in rxrpc_activate_one_channel()
536 call->security = conn->security; in rxrpc_activate_one_channel()
537 call->security_ix = conn->security_ix; in rxrpc_activate_one_channel()
538 call->service_id = conn->service_id; in rxrpc_activate_one_channel()
542 call->cid, call->call_id, call->debug_id, conn->debug_id); in rxrpc_activate_one_channel()
544 write_lock_bh(&call->state_lock); in rxrpc_activate_one_channel()
545 call->state = RXRPC_CALL_CLIENT_SEND_REQUEST; in rxrpc_activate_one_channel()
546 write_unlock_bh(&call->state_lock); in rxrpc_activate_one_channel()
560 chan->call_id = call_id; in rxrpc_activate_one_channel()
561 chan->call_debug_id = call->debug_id; in rxrpc_activate_one_channel()
562 rcu_assign_pointer(chan->call, call); in rxrpc_activate_one_channel()
563 wake_up(&call->waitq); in rxrpc_activate_one_channel()
571 struct rxrpc_net *rxnet = bundle->params.local->rxnet; in rxrpc_unidle_conn()
574 if (!list_empty(&conn->cache_link)) { in rxrpc_unidle_conn()
576 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_unidle_conn()
577 if (!list_empty(&conn->cache_link)) { in rxrpc_unidle_conn()
578 list_del_init(&conn->cache_link); in rxrpc_unidle_conn()
581 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_unidle_conn()
588 * Assign channels and callNumbers to waiting calls with channel_lock
597 if (bundle->try_upgrade) in rxrpc_activate_channels_locked()
602 while (!list_empty(&bundle->waiting_calls)) { in rxrpc_activate_channels_locked()
603 avail = bundle->avail_chans & mask; in rxrpc_activate_channels_locked()
607 clear_bit(channel, &bundle->avail_chans); in rxrpc_activate_channels_locked()
610 conn = bundle->conns[slot]; in rxrpc_activate_channels_locked()
614 if (bundle->try_upgrade) in rxrpc_activate_channels_locked()
615 set_bit(RXRPC_CONN_PROBING_FOR_UPGRADE, &conn->flags); in rxrpc_activate_channels_locked()
618 channel &= (RXRPC_MAXCALLS - 1); in rxrpc_activate_channels_locked()
619 conn->act_chans |= 1 << channel; in rxrpc_activate_channels_locked()
625 * Assign channels and callNumbers to waiting calls.
629 _enter("B=%x", bundle->debug_id); in rxrpc_activate_channels()
631 trace_rxrpc_client(NULL, -1, rxrpc_client_activate_chans); in rxrpc_activate_channels()
633 if (!bundle->avail_chans) in rxrpc_activate_channels()
636 spin_lock(&bundle->channel_lock); in rxrpc_activate_channels()
638 spin_unlock(&bundle->channel_lock); in rxrpc_activate_channels()
651 _enter("%d", call->debug_id); in rxrpc_wait_for_channel()
656 ret = bundle->alloc_error ?: -EAGAIN; in rxrpc_wait_for_channel()
660 add_wait_queue_exclusive(&call->waitq, &myself); in rxrpc_wait_for_channel()
664 ret = bundle->alloc_error; in rxrpc_wait_for_channel()
668 switch (call->interruptibility) { in rxrpc_wait_for_channel()
678 if (READ_ONCE(call->state) != RXRPC_CALL_CLIENT_AWAIT_CONN) in rxrpc_wait_for_channel()
680 if ((call->interruptibility == RXRPC_INTERRUPTIBLE || in rxrpc_wait_for_channel()
681 call->interruptibility == RXRPC_PREINTERRUPTIBLE) && in rxrpc_wait_for_channel()
683 ret = -ERESTARTSYS; in rxrpc_wait_for_channel()
688 remove_wait_queue(&call->waitq, &myself); in rxrpc_wait_for_channel()
698 * - called in process context with IRQs enabled
707 struct rxrpc_net *rxnet = cp->local->rxnet; in rxrpc_connect_call()
710 _enter("{%d,%lx},", call->debug_id, call->user_call_ID); in rxrpc_connect_call()
712 rxrpc_discard_expired_client_conns(&rxnet->client_conn_reaper); in rxrpc_connect_call()
720 if (call->state == RXRPC_CALL_CLIENT_AWAIT_CONN) { in rxrpc_connect_call()
737 spin_lock(&bundle->channel_lock); in rxrpc_connect_call()
738 list_del_init(&call->chan_wait_link); in rxrpc_connect_call()
739 spin_unlock(&bundle->channel_lock); in rxrpc_connect_call()
741 if (call->state != RXRPC_CALL_CLIENT_AWAIT_CONN) { in rxrpc_connect_call()
746 trace_rxrpc_client(call->conn, ret, rxrpc_client_chan_wait_failed); in rxrpc_connect_call()
758 unsigned int channel = call->cid & RXRPC_CHANNELMASK; in rxrpc_expose_client_call()
759 struct rxrpc_connection *conn = call->conn; in rxrpc_expose_client_call()
760 struct rxrpc_channel *chan = &conn->channels[channel]; in rxrpc_expose_client_call()
762 if (!test_and_set_bit(RXRPC_CALL_EXPOSED, &call->flags)) { in rxrpc_expose_client_call()
768 chan->call_counter++; in rxrpc_expose_client_call()
769 if (chan->call_counter >= INT_MAX) in rxrpc_expose_client_call()
770 set_bit(RXRPC_CONN_DONT_REUSE, &conn->flags); in rxrpc_expose_client_call()
780 if (!rxnet->kill_all_client_conns) { in rxrpc_set_client_reap_timer()
784 if (rxnet->live) in rxrpc_set_client_reap_timer()
785 timer_reduce(&rxnet->client_conn_reap_timer, reap_at); in rxrpc_set_client_reap_timer()
796 struct rxrpc_net *rxnet = bundle->params.local->rxnet; in rxrpc_disconnect_client_call()
801 _enter("c=%x", call->debug_id); in rxrpc_disconnect_client_call()
803 spin_lock(&bundle->channel_lock); in rxrpc_disconnect_client_call()
804 set_bit(RXRPC_CALL_DISCONNECTED, &call->flags); in rxrpc_disconnect_client_call()
809 conn = call->conn; in rxrpc_disconnect_client_call()
812 ASSERTCMP(call->call_id, ==, 0); in rxrpc_disconnect_client_call()
813 ASSERT(!test_bit(RXRPC_CALL_EXPOSED, &call->flags)); in rxrpc_disconnect_client_call()
814 list_del_init(&call->chan_wait_link); in rxrpc_disconnect_client_call()
818 cid = call->cid; in rxrpc_disconnect_client_call()
820 chan = &conn->channels[channel]; in rxrpc_disconnect_client_call()
823 if (rcu_access_pointer(chan->call) != call) { in rxrpc_disconnect_client_call()
824 spin_unlock(&bundle->channel_lock); in rxrpc_disconnect_client_call()
839 if (test_bit(RXRPC_CALL_EXPOSED, &call->flags)) { in rxrpc_disconnect_client_call()
840 _debug("exposed %u,%u", call->call_id, call->abort_code); in rxrpc_disconnect_client_call()
843 if (test_and_clear_bit(RXRPC_CONN_PROBING_FOR_UPGRADE, &conn->flags)) { in rxrpc_disconnect_client_call()
845 bundle->try_upgrade = false; in rxrpc_disconnect_client_call()
853 if (may_reuse && !list_empty(&bundle->waiting_calls)) { in rxrpc_disconnect_client_call()
860 * can be skipped if we find a follow-on call. The first DATA packet in rxrpc_disconnect_client_call()
863 if (call->completion == RXRPC_CALL_SUCCEEDED && in rxrpc_disconnect_client_call()
864 test_bit(RXRPC_CALL_EXPOSED, &call->flags)) { in rxrpc_disconnect_client_call()
867 WRITE_ONCE(chan->final_ack_at, final_ack_at); in rxrpc_disconnect_client_call()
869 set_bit(RXRPC_CONN_FINAL_ACK_0 + channel, &conn->flags); in rxrpc_disconnect_client_call()
874 rcu_assign_pointer(chan->call, NULL); in rxrpc_disconnect_client_call()
875 set_bit(conn->bundle_shift + channel, &conn->bundle->avail_chans); in rxrpc_disconnect_client_call()
876 conn->act_chans &= ~(1 << channel); in rxrpc_disconnect_client_call()
878 /* If no channels remain active, then put the connection on the idle in rxrpc_disconnect_client_call()
882 if (!conn->act_chans) { in rxrpc_disconnect_client_call()
884 conn->idle_timestamp = jiffies; in rxrpc_disconnect_client_call()
887 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_disconnect_client_call()
888 list_move_tail(&conn->cache_link, &rxnet->idle_client_conns); in rxrpc_disconnect_client_call()
889 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_disconnect_client_call()
895 spin_unlock(&bundle->channel_lock); in rxrpc_disconnect_client_call()
905 struct rxrpc_bundle *bundle = conn->bundle; in rxrpc_unbundle_conn()
906 struct rxrpc_local *local = bundle->params.local; in rxrpc_unbundle_conn()
911 _enter("C=%x", conn->debug_id); in rxrpc_unbundle_conn()
913 if (conn->flags & RXRPC_CONN_FINAL_ACK_MASK) in rxrpc_unbundle_conn()
916 spin_lock(&bundle->channel_lock); in rxrpc_unbundle_conn()
917 bindex = conn->bundle_shift / RXRPC_MAXCALLS; in rxrpc_unbundle_conn()
918 if (bundle->conns[bindex] == conn) { in rxrpc_unbundle_conn()
920 bundle->conns[bindex] = NULL; in rxrpc_unbundle_conn()
922 clear_bit(conn->bundle_shift + i, &bundle->avail_chans); in rxrpc_unbundle_conn()
925 spin_unlock(&bundle->channel_lock); in rxrpc_unbundle_conn()
928 if (!bundle->avail_chans) { in rxrpc_unbundle_conn()
930 spin_lock(&local->client_bundles_lock); in rxrpc_unbundle_conn()
932 for (i = 0; i < ARRAY_SIZE(bundle->conns); i++) in rxrpc_unbundle_conn()
933 if (bundle->conns[i]) in rxrpc_unbundle_conn()
935 if (i == ARRAY_SIZE(bundle->conns) && !bundle->params.exclusive) { in rxrpc_unbundle_conn()
937 rb_erase(&bundle->local_node, &local->client_bundles); in rxrpc_unbundle_conn()
941 spin_unlock(&local->client_bundles_lock); in rxrpc_unbundle_conn()
956 struct rxrpc_local *local = conn->params.local; in rxrpc_kill_client_conn()
957 struct rxrpc_net *rxnet = local->rxnet; in rxrpc_kill_client_conn()
959 _enter("C=%x", conn->debug_id); in rxrpc_kill_client_conn()
961 trace_rxrpc_client(conn, -1, rxrpc_client_cleanup); in rxrpc_kill_client_conn()
962 atomic_dec(&rxnet->nr_client_conns); in rxrpc_kill_client_conn()
974 unsigned int debug_id = conn->debug_id; in rxrpc_put_client_conn()
977 n = atomic_dec_return(&conn->usage); in rxrpc_put_client_conn()
990 * considered non-reentrant.
1002 if (list_empty(&rxnet->idle_client_conns)) { in rxrpc_discard_expired_client_conns()
1008 if (!spin_trylock(&rxnet->client_conn_discard_lock)) { in rxrpc_discard_expired_client_conns()
1016 nr_conns = atomic_read(&rxnet->nr_client_conns); in rxrpc_discard_expired_client_conns()
1019 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_discard_expired_client_conns()
1021 if (list_empty(&rxnet->idle_client_conns)) in rxrpc_discard_expired_client_conns()
1024 conn = list_entry(rxnet->idle_client_conns.next, in rxrpc_discard_expired_client_conns()
1027 if (!rxnet->kill_all_client_conns) { in rxrpc_discard_expired_client_conns()
1031 * final-ACK or ABORT retransmission. in rxrpc_discard_expired_client_conns()
1036 if (conn->params.local->service_closed) in rxrpc_discard_expired_client_conns()
1039 conn_expires_at = conn->idle_timestamp + expiry; in rxrpc_discard_expired_client_conns()
1046 trace_rxrpc_client(conn, -1, rxrpc_client_discard); in rxrpc_discard_expired_client_conns()
1047 list_del_init(&conn->cache_link); in rxrpc_discard_expired_client_conns()
1049 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_discard_expired_client_conns()
1052 rxrpc_put_connection(conn); /* Drop the ->cache_link ref */ in rxrpc_discard_expired_client_conns()
1054 nr_conns--; in rxrpc_discard_expired_client_conns()
1061 * We don't worry if the work item is already scheduled - it can look in rxrpc_discard_expired_client_conns()
1066 if (!rxnet->kill_all_client_conns) in rxrpc_discard_expired_client_conns()
1067 timer_reduce(&rxnet->client_conn_reap_timer, conn_expires_at); in rxrpc_discard_expired_client_conns()
1070 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_discard_expired_client_conns()
1071 spin_unlock(&rxnet->client_conn_discard_lock); in rxrpc_discard_expired_client_conns()
1083 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_destroy_all_client_connections()
1084 rxnet->kill_all_client_conns = true; in rxrpc_destroy_all_client_connections()
1085 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_destroy_all_client_connections()
1087 del_timer_sync(&rxnet->client_conn_reap_timer); in rxrpc_destroy_all_client_connections()
1089 if (!rxrpc_queue_work(&rxnet->client_conn_reaper)) in rxrpc_destroy_all_client_connections()
1101 struct rxrpc_net *rxnet = local->rxnet; in rxrpc_clean_up_local_conns()
1106 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_clean_up_local_conns()
1108 list_for_each_entry_safe(conn, tmp, &rxnet->idle_client_conns, in rxrpc_clean_up_local_conns()
1110 if (conn->params.local == local) { in rxrpc_clean_up_local_conns()
1111 trace_rxrpc_client(conn, -1, rxrpc_client_discard); in rxrpc_clean_up_local_conns()
1112 list_move(&conn->cache_link, &graveyard); in rxrpc_clean_up_local_conns()
1116 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_clean_up_local_conns()
1121 list_del_init(&conn->cache_link); in rxrpc_clean_up_local_conns()