1 // SPDX-License-Identifier: GPL-2.0-or-later 1
2 /* Client connection-specific management code.
3 *
4 * Copyright (C) 2016, 2020 Red Hat, Inc. All
5 * Written by David Howells (dhowells@redhat.c
6 *
7 * Client connections need to be cached for a
8 * call so as to handle retransmitted DATA pac
9 * receive the final ACK or terminating ABORT
10 *
11 * There are flags of relevance to the cache:
12 *
13 * (2) DONT_REUSE - The connection should be
14 * should not be reused. This is set whe
15 * or a call ID counter overflows.
16 *
17 * The caching state may only be changed if th
18 *
19 * There are two idle client connection expiry
20 * of connections is below the reap threshold,
21 * it's above, we use the fast duration.
22 */
23
24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25
26 #include <linux/slab.h>
27 #include <linux/idr.h>
28 #include <linux/timer.h>
29 #include <linux/sched/signal.h>
30
31 #include "ar-internal.h"
32
33 __read_mostly unsigned int rxrpc_reap_client_c
34 __read_mostly unsigned long rxrpc_conn_idle_cl
35 __read_mostly unsigned long rxrpc_conn_idle_cl
36
37 static void rxrpc_activate_bundle(struct rxrpc
38 {
39 atomic_inc(&bundle->active);
40 }
41
42 /*
43 * Release a connection ID for a client connec
44 */
45 static void rxrpc_put_client_connection_id(str
46 str
47 {
48 idr_remove(&local->conn_ids, conn->pro
49 }
50
51 /*
52 * Destroy the client connection ID tree.
53 */
54 static void rxrpc_destroy_client_conn_ids(stru
55 {
56 struct rxrpc_connection *conn;
57 int id;
58
59 if (!idr_is_empty(&local->conn_ids)) {
60 idr_for_each_entry(&local->con
61 pr_err("AF_RXRPC: Leak
62 conn, refcount_
63 }
64 BUG();
65 }
66
67 idr_destroy(&local->conn_ids);
68 }
69
70 /*
71 * Allocate a connection bundle.
72 */
73 static struct rxrpc_bundle *rxrpc_alloc_bundle
74
75 {
76 static atomic_t rxrpc_bundle_id;
77 struct rxrpc_bundle *bundle;
78
79 bundle = kzalloc(sizeof(*bundle), gfp)
80 if (bundle) {
81 bundle->local = call
82 bundle->peer = rxrp
83 bundle->key = key_
84 bundle->security = call
85 bundle->exclusive = test
86 bundle->upgrade = test
87 bundle->service_id = call
88 bundle->security_level = call
89 bundle->debug_id = atom
90 refcount_set(&bundle->ref, 1);
91 atomic_set(&bundle->active, 1)
92 INIT_LIST_HEAD(&bundle->waitin
93 trace_rxrpc_bundle(bundle->deb
94
95 write_lock(&bundle->local->rxn
96 list_add_tail(&bundle->proc_li
97 write_unlock(&bundle->local->r
98 }
99 return bundle;
100 }
101
102 struct rxrpc_bundle *rxrpc_get_bundle(struct r
103 enum rxr
104 {
105 int r;
106
107 __refcount_inc(&bundle->ref, &r);
108 trace_rxrpc_bundle(bundle->debug_id, r
109 return bundle;
110 }
111
112 static void rxrpc_free_bundle(struct rxrpc_bun
113 {
114 trace_rxrpc_bundle(bundle->debug_id, r
115 rxrpc_bundle_free);
116 write_lock(&bundle->local->rxnet->conn
117 list_del(&bundle->proc_link);
118 write_unlock(&bundle->local->rxnet->co
119 rxrpc_put_peer(bundle->peer, rxrpc_pee
120 key_put(bundle->key);
121 kfree(bundle);
122 }
123
124 void rxrpc_put_bundle(struct rxrpc_bundle *bun
125 {
126 unsigned int id;
127 bool dead;
128 int r;
129
130 if (bundle) {
131 id = bundle->debug_id;
132 dead = __refcount_dec_and_test
133 trace_rxrpc_bundle(id, r - 1,
134 if (dead)
135 rxrpc_free_bundle(bund
136 }
137 }
138
139 /*
140 * Get rid of outstanding client connection pr
141 * endpoint is destroyed.
142 */
143 void rxrpc_purge_client_connections(struct rxr
144 {
145 rxrpc_destroy_client_conn_ids(local);
146 }
147
148 /*
149 * Allocate a client connection.
150 */
151 static struct rxrpc_connection *
152 rxrpc_alloc_client_connection(struct rxrpc_bun
153 {
154 struct rxrpc_connection *conn;
155 struct rxrpc_local *local = bundle->lo
156 struct rxrpc_net *rxnet = local->rxnet
157 int id;
158
159 _enter("");
160
161 conn = rxrpc_alloc_connection(rxnet, G
162 if (!conn)
163 return ERR_PTR(-ENOMEM);
164
165 id = idr_alloc_cyclic(&local->conn_ids
166 GFP_ATOMIC | __G
167 if (id < 0) {
168 kfree(conn);
169 return ERR_PTR(id);
170 }
171
172 refcount_set(&conn->ref, 1);
173 conn->proto.cid = id << RXRPC_
174 conn->proto.epoch = local->rxnet
175 conn->out_clientflag = RXRPC_CLIENT
176 conn->bundle = rxrpc_get_bu
177 conn->local = rxrpc_get_lo
178 conn->peer = rxrpc_get_pe
179 conn->key = key_get(bund
180 conn->security = bundle->secu
181 conn->exclusive = bundle->excl
182 conn->upgrade = bundle->upgr
183 conn->orig_service_id = bundle->serv
184 conn->security_level = bundle->secu
185 conn->state = RXRPC_CONN_C
186 conn->service_id = conn->orig_s
187
188 if (conn->security == &rxrpc_no_securi
189 conn->state = RXRPC_CONN_C
190
191 atomic_inc(&rxnet->nr_conns);
192 write_lock(&rxnet->conn_lock);
193 list_add_tail(&conn->proc_link, &rxnet
194 write_unlock(&rxnet->conn_lock);
195
196 rxrpc_see_connection(conn, rxrpc_conn_
197
198 atomic_inc(&rxnet->nr_client_conns);
199 trace_rxrpc_client(conn, -1, rxrpc_cli
200 return conn;
201 }
202
203 /*
204 * Determine if a connection may be reused.
205 */
206 static bool rxrpc_may_reuse_conn(struct rxrpc_
207 {
208 struct rxrpc_net *rxnet;
209 int id_cursor, id, distance, limit;
210
211 if (!conn)
212 goto dont_reuse;
213
214 rxnet = conn->rxnet;
215 if (test_bit(RXRPC_CONN_DONT_REUSE, &c
216 goto dont_reuse;
217
218 if ((conn->state != RXRPC_CONN_CLIENT_
219 conn->state != RXRPC_CONN_CLIENT)
220 conn->proto.epoch != rxnet->epoch)
221 goto mark_dont_reuse;
222
223 /* The IDR tree gets very expensive on
224 * widely scattered throughout the num
225 * kill off connections that, say, hav
226 * times the maximum number of client
227 * allocation point to try and keep th
228 */
229 id_cursor = idr_get_cursor(&conn->loca
230 id = conn->proto.cid >> RXRPC_CIDSHIFT
231 distance = id - id_cursor;
232 if (distance < 0)
233 distance = -distance;
234 limit = max_t(unsigned long, atomic_re
235 if (distance > limit)
236 goto mark_dont_reuse;
237
238 return true;
239
240 mark_dont_reuse:
241 set_bit(RXRPC_CONN_DONT_REUSE, &conn->
242 dont_reuse:
243 return false;
244 }
245
246 /*
247 * Look up the conn bundle that matches the co
248 * it doesn't yet exist.
249 */
250 int rxrpc_look_up_bundle(struct rxrpc_call *ca
251 {
252 struct rxrpc_bundle *bundle, *candidat
253 struct rxrpc_local *local = call->loca
254 struct rb_node *p, **pp, *parent;
255 long diff;
256 bool upgrade = test_bit(RXRPC_CALL_UPG
257
258 _enter("{%px,%x,%u,%u}",
259 call->peer, key_serial(call->ke
260 upgrade);
261
262 if (test_bit(RXRPC_CALL_EXCLUSIVE, &ca
263 call->bundle = rxrpc_alloc_bun
264 return call->bundle ? 0 : -ENO
265 }
266
267 /* First, see if the bundle is already
268 _debug("search 1");
269 spin_lock(&local->client_bundles_lock)
270 p = local->client_bundles.rb_node;
271 while (p) {
272 bundle = rb_entry(p, struct rx
273
274 #define cmp(X, Y) ((long)(X) - (long)(Y))
275 diff = (cmp(bundle->peer, call
276 cmp(bundle->key, call-
277 cmp(bundle->security_l
278 cmp(bundle->upgrade, u
279 #undef cmp
280 if (diff < 0)
281 p = p->rb_left;
282 else if (diff > 0)
283 p = p->rb_right;
284 else
285 goto found_bundle;
286 }
287 spin_unlock(&local->client_bundles_loc
288 _debug("not found");
289
290 /* It wasn't. We need to add one. */
291 candidate = rxrpc_alloc_bundle(call, g
292 if (!candidate)
293 return -ENOMEM;
294
295 _debug("search 2");
296 spin_lock(&local->client_bundles_lock)
297 pp = &local->client_bundles.rb_node;
298 parent = NULL;
299 while (*pp) {
300 parent = *pp;
301 bundle = rb_entry(parent, stru
302
303 #define cmp(X, Y) ((long)(X) - (long)(Y))
304 diff = (cmp(bundle->peer, call
305 cmp(bundle->key, call-
306 cmp(bundle->security_l
307 cmp(bundle->upgrade, u
308 #undef cmp
309 if (diff < 0)
310 pp = &(*pp)->rb_left;
311 else if (diff > 0)
312 pp = &(*pp)->rb_right;
313 else
314 goto found_bundle_free
315 }
316
317 _debug("new bundle");
318 rb_link_node(&candidate->local_node, p
319 rb_insert_color(&candidate->local_node
320 call->bundle = rxrpc_get_bundle(candid
321 spin_unlock(&local->client_bundles_loc
322 _leave(" = B=%u [new]", call->bundle->
323 return 0;
324
325 found_bundle_free:
326 rxrpc_free_bundle(candidate);
327 found_bundle:
328 call->bundle = rxrpc_get_bundle(bundle
329 rxrpc_activate_bundle(bundle);
330 spin_unlock(&local->client_bundles_loc
331 _leave(" = B=%u [found]", call->bundle
332 return 0;
333 }
334
335 /*
336 * Allocate a new connection and add it into a
337 */
338 static bool rxrpc_add_conn_to_bundle(struct rx
339 unsigned
340 {
341 struct rxrpc_connection *conn, *old;
342 unsigned int shift = slot * RXRPC_MAXC
343 unsigned int i;
344
345 old = bundle->conns[slot];
346 if (old) {
347 bundle->conns[slot] = NULL;
348 bundle->conn_ids[slot] = 0;
349 trace_rxrpc_client(old, -1, rx
350 rxrpc_put_connection(old, rxrp
351 }
352
353 conn = rxrpc_alloc_client_connection(b
354 if (IS_ERR(conn)) {
355 bundle->alloc_error = PTR_ERR(
356 return false;
357 }
358
359 rxrpc_activate_bundle(bundle);
360 conn->bundle_shift = shift;
361 bundle->conns[slot] = conn;
362 bundle->conn_ids[slot] = conn->debug_i
363 for (i = 0; i < RXRPC_MAXCALLS; i++)
364 set_bit(shift + i, &bundle->av
365 return true;
366 }
367
368 /*
369 * Add a connection to a bundle if there are n
370 * connections waiting for extra capacity.
371 */
372 static bool rxrpc_bundle_has_space(struct rxrp
373 {
374 int slot = -1, i, usable;
375
376 _enter("");
377
378 bundle->alloc_error = 0;
379
380 /* See if there are any usable connect
381 usable = 0;
382 for (i = 0; i < ARRAY_SIZE(bundle->con
383 if (rxrpc_may_reuse_conn(bundl
384 usable++;
385 else if (slot == -1)
386 slot = i;
387 }
388
389 if (!usable && bundle->upgrade)
390 bundle->try_upgrade = true;
391
392 if (!usable)
393 goto alloc_conn;
394
395 if (!bundle->avail_chans &&
396 !bundle->try_upgrade &&
397 usable < ARRAY_SIZE(bundle->conns)
398 goto alloc_conn;
399
400 _leave("");
401 return usable;
402
403 alloc_conn:
404 return slot >= 0 ? rxrpc_add_conn_to_b
405 }
406
407 /*
408 * Assign a channel to the call at the front o
409 * We don't increment the callNumber counter u
410 * to the world.
411 */
412 static void rxrpc_activate_one_channel(struct
413 unsigne
414 {
415 struct rxrpc_channel *chan = &conn->ch
416 struct rxrpc_bundle *bundle = conn->bu
417 struct rxrpc_call *call = list_entry(b
418 s
419 u32 call_id = chan->call_counter + 1;
420
421 _enter("C=%x,%u", conn->debug_id, chan
422
423 list_del_init(&call->wait_link);
424
425 trace_rxrpc_client(conn, channel, rxrp
426
427 /* Cancel the final ACK on the previou
428 * as the DATA packet will implicitly
429 */
430 clear_bit(RXRPC_CONN_FINAL_ACK_0 + cha
431 clear_bit(conn->bundle_shift + channel
432
433 rxrpc_see_call(call, rxrpc_call_see_ac
434 call->conn = rxrpc_get_connection
435 call->cid = conn->proto.cid | ch
436 call->call_id = call_id;
437 call->dest_srx.srx_service = conn->ser
438 call->cong_ssthresh = call->peer->cong
439 if (call->cong_cwnd >= call->cong_ssth
440 call->cong_mode = RXRPC_CALL_C
441 else
442 call->cong_mode = RXRPC_CALL_S
443
444 chan->call_id = call_id;
445 chan->call_debug_id = call->debug_
446 chan->call = call;
447
448 rxrpc_see_call(call, rxrpc_call_see_co
449 trace_rxrpc_connect_call(call);
450 call->tx_last_sent = ktime_get_real();
451 rxrpc_start_call_timer(call);
452 rxrpc_set_call_state(call, RXRPC_CALL_
453 wake_up(&call->waitq);
454 }
455
456 /*
457 * Remove a connection from the idle list if i
458 */
459 static void rxrpc_unidle_conn(struct rxrpc_con
460 {
461 if (!list_empty(&conn->cache_link)) {
462 list_del_init(&conn->cache_lin
463 rxrpc_put_connection(conn, rxr
464 }
465 }
466
467 /*
468 * Assign channels and callNumbers to waiting
469 */
470 static void rxrpc_activate_channels(struct rxr
471 {
472 struct rxrpc_connection *conn;
473 unsigned long avail, mask;
474 unsigned int channel, slot;
475
476 trace_rxrpc_client(NULL, -1, rxrpc_cli
477
478 if (bundle->try_upgrade)
479 mask = 1;
480 else
481 mask = ULONG_MAX;
482
483 while (!list_empty(&bundle->waiting_ca
484 avail = bundle->avail_chans &
485 if (!avail)
486 break;
487 channel = __ffs(avail);
488 clear_bit(channel, &bundle->av
489
490 slot = channel / RXRPC_MAXCALL
491 conn = bundle->conns[slot];
492 if (!conn)
493 break;
494
495 if (bundle->try_upgrade)
496 set_bit(RXRPC_CONN_PRO
497 rxrpc_unidle_conn(conn);
498
499 channel &= (RXRPC_MAXCALLS - 1
500 conn->act_chans |= 1 << channe
501 rxrpc_activate_one_channel(con
502 }
503 }
504
505 /*
506 * Connect waiting channels (called from the I
507 */
508 void rxrpc_connect_client_calls(struct rxrpc_l
509 {
510 struct rxrpc_call *call;
511
512 while ((call = list_first_entry_or_nul
513
514 ) {
515 struct rxrpc_bundle *bundle =
516
517 spin_lock(&local->client_call_
518 list_move_tail(&call->wait_lin
519 rxrpc_see_call(call, rxrpc_cal
520 spin_unlock(&local->client_cal
521
522 if (rxrpc_bundle_has_space(bun
523 rxrpc_activate_channel
524 }
525 }
526
527 /*
528 * Note that a call, and thus a connection, is
529 * world.
530 */
531 void rxrpc_expose_client_call(struct rxrpc_cal
532 {
533 unsigned int channel = call->cid & RXR
534 struct rxrpc_connection *conn = call->
535 struct rxrpc_channel *chan = &conn->ch
536
537 if (!test_and_set_bit(RXRPC_CALL_EXPOS
538 /* Mark the call ID as being u
539 * exceeds ~2 billion, we kill
540 * outstanding calls have fini
541 * wrap.
542 */
543 chan->call_counter++;
544 if (chan->call_counter >= INT_
545 set_bit(RXRPC_CONN_DON
546 trace_rxrpc_client(conn, chann
547
548 spin_lock(&call->peer->lock);
549 hlist_add_head(&call->error_li
550 spin_unlock(&call->peer->lock)
551 }
552 }
553
554 /*
555 * Set the reap timer.
556 */
557 static void rxrpc_set_client_reap_timer(struct
558 {
559 if (!local->kill_all_client_conns) {
560 unsigned long now = jiffies;
561 unsigned long reap_at = now +
562
563 if (local->rxnet->live)
564 timer_reduce(&local->c
565 }
566 }
567
568 /*
569 * Disconnect a client call.
570 */
571 void rxrpc_disconnect_client_call(struct rxrpc
572 {
573 struct rxrpc_connection *conn;
574 struct rxrpc_channel *chan = NULL;
575 struct rxrpc_local *local = bundle->lo
576 unsigned int channel;
577 bool may_reuse;
578 u32 cid;
579
580 _enter("c=%x", call->debug_id);
581
582 /* Calls that have never actually been
583 * discarded.
584 */
585 conn = call->conn;
586 if (!conn) {
587 _debug("call is waiting");
588 ASSERTCMP(call->call_id, ==, 0
589 ASSERT(!test_bit(RXRPC_CALL_EX
590 /* May still be on ->new_clien
591 spin_lock(&local->client_call_
592 list_del_init(&call->wait_link
593 spin_unlock(&local->client_cal
594 return;
595 }
596
597 cid = call->cid;
598 channel = cid & RXRPC_CHANNELMASK;
599 chan = &conn->channels[channel];
600 trace_rxrpc_client(conn, channel, rxrp
601
602 if (WARN_ON(chan->call != call))
603 return;
604
605 may_reuse = rxrpc_may_reuse_conn(conn)
606
607 /* If a client call was exposed to the
608 * retransmission.
609 *
610 * We use a barrier here so that the c
611 * read without needing to take a lock
612 *
613 * TODO: Make the incoming packet hand
614 * terminal retransmission without req
615 */
616 if (test_bit(RXRPC_CALL_EXPOSED, &call
617 _debug("exposed %u,%u", call->
618 __rxrpc_disconnect_call(conn,
619
620 if (test_and_clear_bit(RXRPC_C
621 trace_rxrpc_client(con
622 bundle->try_upgrade =
623 if (may_reuse)
624 rxrpc_activate
625 }
626 }
627
628 /* See if we can pass the channel dire
629 if (may_reuse && !list_empty(&bundle->
630 trace_rxrpc_client(conn, chann
631 rxrpc_activate_one_channel(con
632 return;
633 }
634
635 /* Schedule the final ACK to be transm
636 * can be skipped if we find a follow-
637 * of the follow on call will implicit
638 */
639 if (call->completion == RXRPC_CALL_SUC
640 test_bit(RXRPC_CALL_EXPOSED, &call
641 unsigned long final_ack_at = j
642
643 chan->final_ack_at = final_ack
644 smp_wmb(); /* vs rxrpc_process
645 set_bit(RXRPC_CONN_FINAL_ACK_0
646 rxrpc_reduce_conn_timer(conn,
647 }
648
649 /* Deactivate the channel. */
650 chan->call = NULL;
651 set_bit(conn->bundle_shift + channel,
652 conn->act_chans &= ~(1 << channel);
653
654 /* If no channels remain active, then
655 * list for a short while. Give it a
656 * becomes unbundled.
657 */
658 if (!conn->act_chans) {
659 trace_rxrpc_client(conn, chann
660 conn->idle_timestamp = jiffies
661
662 rxrpc_get_connection(conn, rxr
663 list_move_tail(&conn->cache_li
664
665 rxrpc_set_client_reap_timer(lo
666 }
667 }
668
669 /*
670 * Remove a connection from a bundle.
671 */
672 static void rxrpc_unbundle_conn(struct rxrpc_c
673 {
674 struct rxrpc_bundle *bundle = conn->bu
675 unsigned int bindex;
676 int i;
677
678 _enter("C=%x", conn->debug_id);
679
680 if (conn->flags & RXRPC_CONN_FINAL_ACK
681 rxrpc_process_delayed_final_ac
682
683 bindex = conn->bundle_shift / RXRPC_MA
684 if (bundle->conns[bindex] == conn) {
685 _debug("clear slot %u", bindex
686 bundle->conns[bindex] = NULL;
687 bundle->conn_ids[bindex] = 0;
688 for (i = 0; i < RXRPC_MAXCALLS
689 clear_bit(conn->bundle
690 rxrpc_put_client_connection_id
691 rxrpc_deactivate_bundle(bundle
692 rxrpc_put_connection(conn, rxr
693 }
694 }
695
696 /*
697 * Drop the active count on a bundle.
698 */
699 void rxrpc_deactivate_bundle(struct rxrpc_bund
700 {
701 struct rxrpc_local *local;
702 bool need_put = false;
703
704 if (!bundle)
705 return;
706
707 local = bundle->local;
708 if (atomic_dec_and_lock(&bundle->activ
709 if (!bundle->exclusive) {
710 _debug("erase bundle")
711 rb_erase(&bundle->loca
712 need_put = true;
713 }
714
715 spin_unlock(&local->client_bun
716 if (need_put)
717 rxrpc_put_bundle(bundl
718 }
719 }
720
721 /*
722 * Clean up a dead client connection.
723 */
724 void rxrpc_kill_client_conn(struct rxrpc_conne
725 {
726 struct rxrpc_local *local = conn->loca
727 struct rxrpc_net *rxnet = local->rxnet
728
729 _enter("C=%x", conn->debug_id);
730
731 trace_rxrpc_client(conn, -1, rxrpc_cli
732 atomic_dec(&rxnet->nr_client_conns);
733
734 rxrpc_put_client_connection_id(local,
735 }
736
737 /*
738 * Discard expired client connections from the
739 * idle list has been exposed and holds an ext
740 *
741 * This may be called from conn setup or from
742 * considered non-reentrant.
743 */
744 void rxrpc_discard_expired_client_conns(struct
745 {
746 struct rxrpc_connection *conn;
747 unsigned long expiry, conn_expires_at,
748 unsigned int nr_conns;
749
750 _enter("");
751
752 /* We keep an estimate of what the num
753 * we've discarded some so that we don
754 */
755 nr_conns = atomic_read(&local->rxnet->
756
757 next:
758 conn = list_first_entry_or_null(&local
759 struct
760 if (!conn)
761 return;
762
763 if (!local->kill_all_client_conns) {
764 /* If the number of connection
765 * expedite discard by reducin
766 * however, have at least a sh
767 * final-ACK or ABORT retransm
768 */
769 expiry = rxrpc_conn_idle_clien
770 if (nr_conns > rxrpc_reap_clie
771 expiry = rxrpc_conn_id
772 if (conn->local->service_close
773 expiry = rxrpc_closed_
774
775 conn_expires_at = conn->idle_t
776
777 now = jiffies;
778 if (time_after(conn_expires_at
779 goto not_yet_expired;
780 }
781
782 atomic_dec(&conn->active);
783 trace_rxrpc_client(conn, -1, rxrpc_cli
784 list_del_init(&conn->cache_link);
785
786 rxrpc_unbundle_conn(conn);
787 /* Drop the ->cache_link ref */
788 rxrpc_put_connection(conn, rxrpc_conn_
789
790 nr_conns--;
791 goto next;
792
793 not_yet_expired:
794 /* The connection at the front of the
795 * schedule the work item for that poi
796 *
797 * We don't worry if the work item is
798 * after rescheduling itself at a late
799 * then things get messier.
800 */
801 _debug("not yet");
802 if (!local->kill_all_client_conns)
803 timer_reduce(&local->client_co
804
805 _leave("");
806 }
807
808 /*
809 * Clean up the client connections on a local
810 */
811 void rxrpc_clean_up_local_conns(struct rxrpc_l
812 {
813 struct rxrpc_connection *conn;
814
815 _enter("");
816
817 local->kill_all_client_conns = true;
818
819 del_timer_sync(&local->client_conn_rea
820
821 while ((conn = list_first_entry_or_nul
822
823 list_del_init(&conn->cache_lin
824 atomic_dec(&conn->active);
825 trace_rxrpc_client(conn, -1, r
826 rxrpc_unbundle_conn(conn);
827 rxrpc_put_connection(conn, rxr
828 }
829
830 _leave(" [culled]");
831 }
832
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.