Lines Matching +full:diff +full:- +full:channels
1 /* Client connection-specific management code.
18 * (1) INACTIVE - The connection is not held in any list and may not have been
22 * (2) WAITING - The connection is waiting for the number of client conns to
27 * in to-be-granted order. Culled conns with waiters go to the back of
30 * (3) ACTIVE - The connection has at least one call in progress upon it, it
31 * may freely grant available channels to new calls and calls may be
32 * waiting on it for channels to become available.
34 * The connection is on the rxnet->active_client_conns list which is kept
39 * (4) UPGRADE - As for ACTIVE, but only one call may be in progress and is
42 * (5) CULLED - The connection got summarily culled to try and free up
45 * this state - the conn would have to go to the WAITING state instead.
47 * (6) IDLE - The connection has no calls in progress upon it and must have
52 * The connection is on the rxnet->idle_client_conns list which is kept in
57 * (1) EXPOSED - The connection ID got exposed to the world. If this flag is
66 * (2) DONT_REUSE - The connection should be discarded as soon as possible and
84 #include "ar-internal.h"
92 * We use machine-unique IDs for our client connections.
108 struct rxrpc_net *rxnet = conn->params.local->rxnet; in rxrpc_get_client_connection_id()
124 conn->proto.epoch = rxnet->epoch; in rxrpc_get_client_connection_id()
125 conn->proto.cid = id << RXRPC_CIDSHIFT; in rxrpc_get_client_connection_id()
126 set_bit(RXRPC_CONN_HAS_IDR, &conn->flags); in rxrpc_get_client_connection_id()
127 _leave(" [CID %x]", conn->proto.cid); in rxrpc_get_client_connection_id()
142 if (test_bit(RXRPC_CONN_HAS_IDR, &conn->flags)) { in rxrpc_put_client_connection_id()
145 conn->proto.cid >> RXRPC_CIDSHIFT); in rxrpc_put_client_connection_id()
161 conn, atomic_read(&conn->usage)); in rxrpc_destroy_client_conn_ids()
176 struct rxrpc_net *rxnet = cp->local->rxnet; in rxrpc_alloc_client_connection()
183 _leave(" = -ENOMEM"); in rxrpc_alloc_client_connection()
184 return ERR_PTR(-ENOMEM); in rxrpc_alloc_client_connection()
187 atomic_set(&conn->usage, 1); in rxrpc_alloc_client_connection()
188 if (cp->exclusive) in rxrpc_alloc_client_connection()
189 __set_bit(RXRPC_CONN_DONT_REUSE, &conn->flags); in rxrpc_alloc_client_connection()
190 if (cp->upgrade) in rxrpc_alloc_client_connection()
191 __set_bit(RXRPC_CONN_PROBING_FOR_UPGRADE, &conn->flags); in rxrpc_alloc_client_connection()
193 conn->params = *cp; in rxrpc_alloc_client_connection()
194 conn->out_clientflag = RXRPC_CLIENT_INITIATED; in rxrpc_alloc_client_connection()
195 conn->state = RXRPC_CONN_CLIENT; in rxrpc_alloc_client_connection()
196 conn->service_id = cp->service_id; in rxrpc_alloc_client_connection()
206 ret = conn->security->prime_packet_security(conn); in rxrpc_alloc_client_connection()
210 atomic_inc(&rxnet->nr_conns); in rxrpc_alloc_client_connection()
211 write_lock(&rxnet->conn_lock); in rxrpc_alloc_client_connection()
212 list_add_tail(&conn->proc_link, &rxnet->conn_proc_list); in rxrpc_alloc_client_connection()
213 write_unlock(&rxnet->conn_lock); in rxrpc_alloc_client_connection()
216 cp->peer = NULL; in rxrpc_alloc_client_connection()
217 rxrpc_get_local(conn->params.local); in rxrpc_alloc_client_connection()
218 key_get(conn->params.key); in rxrpc_alloc_client_connection()
220 trace_rxrpc_conn(conn->debug_id, rxrpc_conn_new_client, in rxrpc_alloc_client_connection()
221 atomic_read(&conn->usage), in rxrpc_alloc_client_connection()
223 trace_rxrpc_client(conn, -1, rxrpc_client_alloc); in rxrpc_alloc_client_connection()
228 conn->security->clear(conn); in rxrpc_alloc_client_connection()
242 struct rxrpc_net *rxnet = conn->params.local->rxnet; in rxrpc_may_reuse_conn()
245 if (test_bit(RXRPC_CONN_DONT_REUSE, &conn->flags)) in rxrpc_may_reuse_conn()
248 if (conn->proto.epoch != rxnet->epoch) in rxrpc_may_reuse_conn()
258 id = conn->proto.cid >> RXRPC_CIDSHIFT; in rxrpc_may_reuse_conn()
259 distance = id - id_cursor; in rxrpc_may_reuse_conn()
261 distance = -distance; in rxrpc_may_reuse_conn()
269 set_bit(RXRPC_CONN_DONT_REUSE, &conn->flags); in rxrpc_may_reuse_conn()
287 struct rxrpc_local *local = cp->local; in rxrpc_get_client_conn()
289 long diff; in rxrpc_get_client_conn() local
290 int ret = -ENOMEM; in rxrpc_get_client_conn()
292 _enter("{%d,%lx},", call->debug_id, call->user_call_ID); in rxrpc_get_client_conn()
294 cp->peer = rxrpc_lookup_peer(rx, cp->local, srx, gfp); in rxrpc_get_client_conn()
295 if (!cp->peer) in rxrpc_get_client_conn()
298 call->cong_cwnd = cp->peer->cong_cwnd; in rxrpc_get_client_conn()
299 if (call->cong_cwnd >= call->cong_ssthresh) in rxrpc_get_client_conn()
300 call->cong_mode = RXRPC_CALL_CONGEST_AVOIDANCE; in rxrpc_get_client_conn()
302 call->cong_mode = RXRPC_CALL_SLOW_START; in rxrpc_get_client_conn()
307 if (!cp->exclusive) { in rxrpc_get_client_conn()
309 spin_lock(&local->client_conns_lock); in rxrpc_get_client_conn()
310 p = local->client_conns.rb_node; in rxrpc_get_client_conn()
314 #define cmp(X) ((long)conn->params.X - (long)cp->X) in rxrpc_get_client_conn()
315 diff = (cmp(peer) ?: in rxrpc_get_client_conn()
320 if (diff < 0) { in rxrpc_get_client_conn()
321 p = p->rb_left; in rxrpc_get_client_conn()
322 } else if (diff > 0) { in rxrpc_get_client_conn()
323 p = p->rb_right; in rxrpc_get_client_conn()
336 spin_unlock(&local->client_conns_lock); in rxrpc_get_client_conn()
357 list_add(&call->chan_wait_link, &candidate->waiting_calls); in rxrpc_get_client_conn()
359 if (cp->exclusive) { in rxrpc_get_client_conn()
360 call->conn = candidate; in rxrpc_get_client_conn()
361 call->security_ix = candidate->security_ix; in rxrpc_get_client_conn()
362 call->service_id = candidate->service_id; in rxrpc_get_client_conn()
363 _leave(" = 0 [exclusive %d]", candidate->debug_id); in rxrpc_get_client_conn()
372 spin_lock(&local->client_conns_lock); in rxrpc_get_client_conn()
374 pp = &local->client_conns.rb_node; in rxrpc_get_client_conn()
380 #define cmp(X) ((long)conn->params.X - (long)candidate->params.X) in rxrpc_get_client_conn()
381 diff = (cmp(peer) ?: in rxrpc_get_client_conn()
386 if (diff < 0) { in rxrpc_get_client_conn()
387 pp = &(*pp)->rb_left; in rxrpc_get_client_conn()
388 } else if (diff > 0) { in rxrpc_get_client_conn()
389 pp = &(*pp)->rb_right; in rxrpc_get_client_conn()
396 clear_bit(RXRPC_CONN_IN_CLIENT_CONNS, &conn->flags); in rxrpc_get_client_conn()
397 rb_replace_node(&conn->client_node, in rxrpc_get_client_conn()
398 &candidate->client_node, in rxrpc_get_client_conn()
399 &local->client_conns); in rxrpc_get_client_conn()
400 trace_rxrpc_client(conn, -1, rxrpc_client_replace); in rxrpc_get_client_conn()
406 rb_link_node(&candidate->client_node, parent, pp); in rxrpc_get_client_conn()
407 rb_insert_color(&candidate->client_node, &local->client_conns); in rxrpc_get_client_conn()
410 set_bit(RXRPC_CONN_IN_CLIENT_CONNS, &candidate->flags); in rxrpc_get_client_conn()
411 call->conn = candidate; in rxrpc_get_client_conn()
412 call->security_ix = candidate->security_ix; in rxrpc_get_client_conn()
413 call->service_id = candidate->service_id; in rxrpc_get_client_conn()
414 spin_unlock(&local->client_conns_lock); in rxrpc_get_client_conn()
415 _leave(" = 0 [new %d]", candidate->debug_id); in rxrpc_get_client_conn()
424 spin_unlock(&local->client_conns_lock); in rxrpc_get_client_conn()
427 trace_rxrpc_client(candidate, -1, rxrpc_client_duplicate); in rxrpc_get_client_conn()
432 spin_lock(&conn->channel_lock); in rxrpc_get_client_conn()
433 call->conn = conn; in rxrpc_get_client_conn()
434 call->security_ix = conn->security_ix; in rxrpc_get_client_conn()
435 call->service_id = conn->service_id; in rxrpc_get_client_conn()
436 list_add_tail(&call->chan_wait_link, &conn->waiting_calls); in rxrpc_get_client_conn()
437 spin_unlock(&conn->channel_lock); in rxrpc_get_client_conn()
438 _leave(" = 0 [extant %d]", conn->debug_id); in rxrpc_get_client_conn()
442 rxrpc_put_peer(cp->peer); in rxrpc_get_client_conn()
443 cp->peer = NULL; in rxrpc_get_client_conn()
455 if (test_bit(RXRPC_CONN_PROBING_FOR_UPGRADE, &conn->flags)) { in rxrpc_activate_conn()
456 trace_rxrpc_client(conn, -1, rxrpc_client_to_upgrade); in rxrpc_activate_conn()
457 conn->cache_state = RXRPC_CONN_CLIENT_UPGRADE; in rxrpc_activate_conn()
459 trace_rxrpc_client(conn, -1, rxrpc_client_to_active); in rxrpc_activate_conn()
460 conn->cache_state = RXRPC_CONN_CLIENT_ACTIVE; in rxrpc_activate_conn()
462 rxnet->nr_active_client_conns++; in rxrpc_activate_conn()
463 list_move_tail(&conn->cache_link, &rxnet->active_client_conns); in rxrpc_activate_conn()
475 * channels if it has been culled to make space and then re-requested by a new
483 _enter("%d,%d", conn->debug_id, conn->cache_state); in rxrpc_animate_client_conn()
485 if (conn->cache_state == RXRPC_CONN_CLIENT_ACTIVE || in rxrpc_animate_client_conn()
486 conn->cache_state == RXRPC_CONN_CLIENT_UPGRADE) in rxrpc_animate_client_conn()
489 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_animate_client_conn()
491 nr_conns = rxnet->nr_client_conns; in rxrpc_animate_client_conn()
492 if (!test_and_set_bit(RXRPC_CONN_COUNTED, &conn->flags)) { in rxrpc_animate_client_conn()
493 trace_rxrpc_client(conn, -1, rxrpc_client_count); in rxrpc_animate_client_conn()
494 rxnet->nr_client_conns = nr_conns + 1; in rxrpc_animate_client_conn()
497 switch (conn->cache_state) { in rxrpc_animate_client_conn()
515 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_animate_client_conn()
517 _leave(" [%d]", conn->cache_state); in rxrpc_animate_client_conn()
527 trace_rxrpc_client(conn, -1, rxrpc_client_to_waiting); in rxrpc_animate_client_conn()
528 conn->cache_state = RXRPC_CONN_CLIENT_WAITING; in rxrpc_animate_client_conn()
529 list_move_tail(&conn->cache_link, &rxnet->waiting_client_conns); in rxrpc_animate_client_conn()
539 struct rxrpc_channel *chan = &conn->channels[channel]; in rxrpc_deactivate_one_channel()
541 rcu_assign_pointer(chan->call, NULL); in rxrpc_deactivate_one_channel()
542 conn->active_chans &= ~(1 << channel); in rxrpc_deactivate_one_channel()
553 struct rxrpc_channel *chan = &conn->channels[channel]; in rxrpc_activate_one_channel()
554 struct rxrpc_call *call = list_entry(conn->waiting_calls.next, in rxrpc_activate_one_channel()
556 u32 call_id = chan->call_counter + 1; in rxrpc_activate_one_channel()
563 clear_bit(RXRPC_CONN_FINAL_ACK_0 + channel, &conn->flags); in rxrpc_activate_one_channel()
565 write_lock_bh(&call->state_lock); in rxrpc_activate_one_channel()
566 if (!test_bit(RXRPC_CALL_TX_LASTQ, &call->flags)) in rxrpc_activate_one_channel()
567 call->state = RXRPC_CALL_CLIENT_SEND_REQUEST; in rxrpc_activate_one_channel()
569 call->state = RXRPC_CALL_CLIENT_AWAIT_REPLY; in rxrpc_activate_one_channel()
570 write_unlock_bh(&call->state_lock); in rxrpc_activate_one_channel()
573 list_del_init(&call->chan_wait_link); in rxrpc_activate_one_channel()
574 conn->active_chans |= 1 << channel; in rxrpc_activate_one_channel()
575 call->peer = rxrpc_get_peer(conn->params.peer); in rxrpc_activate_one_channel()
576 call->cid = conn->proto.cid | channel; in rxrpc_activate_one_channel()
577 call->call_id = call_id; in rxrpc_activate_one_channel()
581 call->cid, call->call_id, call->debug_id, conn->debug_id); in rxrpc_activate_one_channel()
594 chan->call_id = call_id; in rxrpc_activate_one_channel()
595 chan->call_debug_id = call->debug_id; in rxrpc_activate_one_channel()
596 rcu_assign_pointer(chan->call, call); in rxrpc_activate_one_channel()
597 wake_up(&call->waitq); in rxrpc_activate_one_channel()
601 * Assign channels and callNumbers to waiting calls with channel_lock
608 switch (conn->cache_state) { in rxrpc_activate_channels_locked()
619 while (!list_empty(&conn->waiting_calls) && in rxrpc_activate_channels_locked()
620 (avail = ~conn->active_chans, in rxrpc_activate_channels_locked()
627 * Assign channels and callNumbers to waiting calls.
631 _enter("%d", conn->debug_id); in rxrpc_activate_channels()
633 trace_rxrpc_client(conn, -1, rxrpc_client_activate_chans); in rxrpc_activate_channels()
635 if (conn->active_chans == RXRPC_ACTIVE_CHANS_MASK) in rxrpc_activate_channels()
638 spin_lock(&conn->channel_lock); in rxrpc_activate_channels()
640 spin_unlock(&conn->channel_lock); in rxrpc_activate_channels()
651 _enter("%d", call->debug_id); in rxrpc_wait_for_channel()
653 if (!call->call_id) { in rxrpc_wait_for_channel()
657 ret = -EAGAIN; in rxrpc_wait_for_channel()
661 add_wait_queue_exclusive(&call->waitq, &myself); in rxrpc_wait_for_channel()
664 if (call->call_id) in rxrpc_wait_for_channel()
667 ret = -ERESTARTSYS; in rxrpc_wait_for_channel()
672 remove_wait_queue(&call->waitq, &myself); in rxrpc_wait_for_channel()
686 * - called in process context with IRQs enabled
694 struct rxrpc_net *rxnet = cp->local->rxnet; in rxrpc_connect_call()
697 _enter("{%d,%lx},", call->debug_id, call->user_call_ID); in rxrpc_connect_call()
699 rxrpc_discard_expired_client_conns(&rxnet->client_conn_reaper); in rxrpc_connect_call()
706 rxrpc_animate_client_conn(rxnet, call->conn); in rxrpc_connect_call()
707 rxrpc_activate_channels(call->conn); in rxrpc_connect_call()
711 trace_rxrpc_client(call->conn, ret, rxrpc_client_chan_wait_failed); in rxrpc_connect_call()
716 spin_lock_bh(&call->conn->params.peer->lock); in rxrpc_connect_call()
717 hlist_add_head_rcu(&call->error_link, in rxrpc_connect_call()
718 &call->conn->params.peer->error_targets); in rxrpc_connect_call()
719 spin_unlock_bh(&call->conn->params.peer->lock); in rxrpc_connect_call()
730 * had a chance at re-use (the per-connection security negotiation is
736 if (!test_and_set_bit(RXRPC_CONN_EXPOSED, &conn->flags)) { in rxrpc_expose_client_conn()
748 unsigned int channel = call->cid & RXRPC_CHANNELMASK; in rxrpc_expose_client_call()
749 struct rxrpc_connection *conn = call->conn; in rxrpc_expose_client_call()
750 struct rxrpc_channel *chan = &conn->channels[channel]; in rxrpc_expose_client_call()
752 if (!test_and_set_bit(RXRPC_CALL_EXPOSED, &call->flags)) { in rxrpc_expose_client_call()
758 chan->call_counter++; in rxrpc_expose_client_call()
759 if (chan->call_counter >= INT_MAX) in rxrpc_expose_client_call()
760 set_bit(RXRPC_CONN_DONT_REUSE, &conn->flags); in rxrpc_expose_client_call()
773 if (rxnet->live) in rxrpc_set_client_reap_timer()
774 timer_reduce(&rxnet->client_conn_reap_timer, reap_at); in rxrpc_set_client_reap_timer()
782 struct rxrpc_connection *conn = call->conn; in rxrpc_disconnect_client_call()
784 struct rxrpc_net *rxnet = conn->params.local->rxnet; in rxrpc_disconnect_client_call()
785 unsigned int channel = -1; in rxrpc_disconnect_client_call()
788 spin_lock(&conn->channel_lock); in rxrpc_disconnect_client_call()
789 set_bit(RXRPC_CALL_DISCONNECTED, &call->flags); in rxrpc_disconnect_client_call()
791 cid = call->cid; in rxrpc_disconnect_client_call()
794 chan = &conn->channels[channel]; in rxrpc_disconnect_client_call()
802 if (!list_empty(&call->chan_wait_link)) { in rxrpc_disconnect_client_call()
804 ASSERTCMP(call->call_id, ==, 0); in rxrpc_disconnect_client_call()
805 ASSERT(!test_bit(RXRPC_CALL_EXPOSED, &call->flags)); in rxrpc_disconnect_client_call()
806 list_del_init(&call->chan_wait_link); in rxrpc_disconnect_client_call()
813 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_disconnect_client_call()
814 if (conn->cache_state == RXRPC_CONN_CLIENT_WAITING && in rxrpc_disconnect_client_call()
815 list_empty(&conn->waiting_calls) && in rxrpc_disconnect_client_call()
816 !conn->active_chans) in rxrpc_disconnect_client_call()
821 if (rcu_access_pointer(chan->call) != call) { in rxrpc_disconnect_client_call()
822 spin_unlock(&conn->channel_lock); in rxrpc_disconnect_client_call()
835 if (test_bit(RXRPC_CALL_EXPOSED, &call->flags)) { in rxrpc_disconnect_client_call()
836 _debug("exposed %u,%u", call->call_id, call->abort_code); in rxrpc_disconnect_client_call()
841 if (conn->cache_state == RXRPC_CONN_CLIENT_ACTIVE && in rxrpc_disconnect_client_call()
842 !list_empty(&conn->waiting_calls)) { in rxrpc_disconnect_client_call()
849 * can be skipped if we find a follow-on call. The first DATA packet in rxrpc_disconnect_client_call()
852 if (call->completion == RXRPC_CALL_SUCCEEDED && in rxrpc_disconnect_client_call()
853 test_bit(RXRPC_CALL_EXPOSED, &call->flags)) { in rxrpc_disconnect_client_call()
856 WRITE_ONCE(chan->final_ack_at, final_ack_at); in rxrpc_disconnect_client_call()
858 set_bit(RXRPC_CONN_FINAL_ACK_0 + channel, &conn->flags); in rxrpc_disconnect_client_call()
867 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_disconnect_client_call()
869 switch (conn->cache_state) { in rxrpc_disconnect_client_call()
872 if (test_bit(RXRPC_CONN_EXPOSED, &conn->flags)) { in rxrpc_disconnect_client_call()
873 clear_bit(RXRPC_CONN_PROBING_FOR_UPGRADE, &conn->flags); in rxrpc_disconnect_client_call()
875 conn->cache_state = RXRPC_CONN_CLIENT_ACTIVE; in rxrpc_disconnect_client_call()
880 if (list_empty(&conn->waiting_calls)) { in rxrpc_disconnect_client_call()
882 if (!conn->active_chans) { in rxrpc_disconnect_client_call()
883 rxnet->nr_active_client_conns--; in rxrpc_disconnect_client_call()
895 ASSERT(list_empty(&conn->waiting_calls)); in rxrpc_disconnect_client_call()
896 if (!conn->active_chans) in rxrpc_disconnect_client_call()
909 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_disconnect_client_call()
911 spin_unlock(&conn->channel_lock); in rxrpc_disconnect_client_call()
916 /* As no channels remain active, the connection gets deactivated in rxrpc_disconnect_client_call()
919 if (test_bit(RXRPC_CONN_EXPOSED, &conn->flags)) { in rxrpc_disconnect_client_call()
921 conn->idle_timestamp = jiffies; in rxrpc_disconnect_client_call()
922 conn->cache_state = RXRPC_CONN_CLIENT_IDLE; in rxrpc_disconnect_client_call()
923 list_move_tail(&conn->cache_link, &rxnet->idle_client_conns); in rxrpc_disconnect_client_call()
924 if (rxnet->idle_client_conns.next == &conn->cache_link && in rxrpc_disconnect_client_call()
925 !rxnet->kill_all_client_conns) in rxrpc_disconnect_client_call()
929 conn->cache_state = RXRPC_CONN_CLIENT_INACTIVE; in rxrpc_disconnect_client_call()
930 list_del_init(&conn->cache_link); in rxrpc_disconnect_client_call()
942 struct rxrpc_local *local = conn->params.local; in rxrpc_put_one_client_conn()
943 struct rxrpc_net *rxnet = local->rxnet; in rxrpc_put_one_client_conn()
946 trace_rxrpc_client(conn, -1, rxrpc_client_cleanup); in rxrpc_put_one_client_conn()
948 if (test_bit(RXRPC_CONN_IN_CLIENT_CONNS, &conn->flags)) { in rxrpc_put_one_client_conn()
949 spin_lock(&local->client_conns_lock); in rxrpc_put_one_client_conn()
951 &conn->flags)) in rxrpc_put_one_client_conn()
952 rb_erase(&conn->client_node, &local->client_conns); in rxrpc_put_one_client_conn()
953 spin_unlock(&local->client_conns_lock); in rxrpc_put_one_client_conn()
958 ASSERTCMP(conn->cache_state, ==, RXRPC_CONN_CLIENT_INACTIVE); in rxrpc_put_one_client_conn()
960 if (test_bit(RXRPC_CONN_COUNTED, &conn->flags)) { in rxrpc_put_one_client_conn()
961 trace_rxrpc_client(conn, -1, rxrpc_client_uncount); in rxrpc_put_one_client_conn()
962 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_put_one_client_conn()
963 nr_conns = --rxnet->nr_client_conns; in rxrpc_put_one_client_conn()
966 !list_empty(&rxnet->waiting_client_conns)) { in rxrpc_put_one_client_conn()
967 next = list_entry(rxnet->waiting_client_conns.next, in rxrpc_put_one_client_conn()
973 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_put_one_client_conn()
992 unsigned int debug_id = conn->debug_id; in rxrpc_put_client_conn()
996 n = atomic_dec_return(&conn->usage); in rxrpc_put_client_conn()
1007 * Kill the longest-active client connections to make room for new ones.
1012 unsigned int nr_conns = rxnet->nr_client_conns; in rxrpc_cull_active_client_conns()
1024 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_cull_active_client_conns()
1025 nr_active = rxnet->nr_active_client_conns; in rxrpc_cull_active_client_conns()
1028 ASSERT(!list_empty(&rxnet->active_client_conns)); in rxrpc_cull_active_client_conns()
1029 conn = list_entry(rxnet->active_client_conns.next, in rxrpc_cull_active_client_conns()
1031 ASSERTIFCMP(conn->cache_state != RXRPC_CONN_CLIENT_ACTIVE, in rxrpc_cull_active_client_conns()
1032 conn->cache_state, ==, RXRPC_CONN_CLIENT_UPGRADE); in rxrpc_cull_active_client_conns()
1034 if (list_empty(&conn->waiting_calls)) { in rxrpc_cull_active_client_conns()
1035 trace_rxrpc_client(conn, -1, rxrpc_client_to_culled); in rxrpc_cull_active_client_conns()
1036 conn->cache_state = RXRPC_CONN_CLIENT_CULLED; in rxrpc_cull_active_client_conns()
1037 list_del_init(&conn->cache_link); in rxrpc_cull_active_client_conns()
1039 trace_rxrpc_client(conn, -1, rxrpc_client_to_waiting); in rxrpc_cull_active_client_conns()
1040 conn->cache_state = RXRPC_CONN_CLIENT_WAITING; in rxrpc_cull_active_client_conns()
1041 list_move_tail(&conn->cache_link, in rxrpc_cull_active_client_conns()
1042 &rxnet->waiting_client_conns); in rxrpc_cull_active_client_conns()
1045 nr_active--; in rxrpc_cull_active_client_conns()
1048 rxnet->nr_active_client_conns = nr_active; in rxrpc_cull_active_client_conns()
1049 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_cull_active_client_conns()
1059 * considered non-reentrant.
1071 if (list_empty(&rxnet->idle_client_conns)) { in rxrpc_discard_expired_client_conns()
1077 if (!spin_trylock(&rxnet->client_conn_discard_lock)) { in rxrpc_discard_expired_client_conns()
1085 nr_conns = rxnet->nr_client_conns; in rxrpc_discard_expired_client_conns()
1088 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_discard_expired_client_conns()
1090 if (list_empty(&rxnet->idle_client_conns)) in rxrpc_discard_expired_client_conns()
1093 conn = list_entry(rxnet->idle_client_conns.next, in rxrpc_discard_expired_client_conns()
1095 ASSERT(test_bit(RXRPC_CONN_EXPOSED, &conn->flags)); in rxrpc_discard_expired_client_conns()
1097 if (!rxnet->kill_all_client_conns) { in rxrpc_discard_expired_client_conns()
1101 * final-ACK or ABORT retransmission. in rxrpc_discard_expired_client_conns()
1106 if (conn->params.local->service_closed) in rxrpc_discard_expired_client_conns()
1109 conn_expires_at = conn->idle_timestamp + expiry; in rxrpc_discard_expired_client_conns()
1116 trace_rxrpc_client(conn, -1, rxrpc_client_discard); in rxrpc_discard_expired_client_conns()
1117 if (!test_and_clear_bit(RXRPC_CONN_EXPOSED, &conn->flags)) in rxrpc_discard_expired_client_conns()
1119 conn->cache_state = RXRPC_CONN_CLIENT_INACTIVE; in rxrpc_discard_expired_client_conns()
1120 list_del_init(&conn->cache_link); in rxrpc_discard_expired_client_conns()
1122 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_discard_expired_client_conns()
1126 * If someone re-sets the flag and re-gets the ref, that's fine. in rxrpc_discard_expired_client_conns()
1129 nr_conns--; in rxrpc_discard_expired_client_conns()
1136 * We don't worry if the work item is already scheduled - it can look in rxrpc_discard_expired_client_conns()
1141 if (!rxnet->kill_all_client_conns) in rxrpc_discard_expired_client_conns()
1142 timer_reduce(&rxnet->client_conn_reap_timer, in rxrpc_discard_expired_client_conns()
1146 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_discard_expired_client_conns()
1147 spin_unlock(&rxnet->client_conn_discard_lock); in rxrpc_discard_expired_client_conns()
1159 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_destroy_all_client_connections()
1160 rxnet->kill_all_client_conns = true; in rxrpc_destroy_all_client_connections()
1161 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_destroy_all_client_connections()
1163 del_timer_sync(&rxnet->client_conn_reap_timer); in rxrpc_destroy_all_client_connections()
1165 if (!rxrpc_queue_work(&rxnet->client_conn_reaper)) in rxrpc_destroy_all_client_connections()
1177 struct rxrpc_net *rxnet = local->rxnet; in rxrpc_clean_up_local_conns()
1183 spin_lock(&rxnet->client_conn_cache_lock); in rxrpc_clean_up_local_conns()
1184 nr_active = rxnet->nr_active_client_conns; in rxrpc_clean_up_local_conns()
1186 list_for_each_entry_safe(conn, tmp, &rxnet->idle_client_conns, in rxrpc_clean_up_local_conns()
1188 if (conn->params.local == local) { in rxrpc_clean_up_local_conns()
1189 ASSERTCMP(conn->cache_state, ==, RXRPC_CONN_CLIENT_IDLE); in rxrpc_clean_up_local_conns()
1191 trace_rxrpc_client(conn, -1, rxrpc_client_discard); in rxrpc_clean_up_local_conns()
1192 if (!test_and_clear_bit(RXRPC_CONN_EXPOSED, &conn->flags)) in rxrpc_clean_up_local_conns()
1194 conn->cache_state = RXRPC_CONN_CLIENT_INACTIVE; in rxrpc_clean_up_local_conns()
1195 list_move(&conn->cache_link, &graveyard); in rxrpc_clean_up_local_conns()
1196 nr_active--; in rxrpc_clean_up_local_conns()
1200 rxnet->nr_active_client_conns = nr_active; in rxrpc_clean_up_local_conns()
1201 spin_unlock(&rxnet->client_conn_cache_lock); in rxrpc_clean_up_local_conns()
1207 list_del_init(&conn->cache_link); in rxrpc_clean_up_local_conns()