1
2
3
4
5
6
7
8
9
10
11
12#include <linux/module.h>
13#include <linux/slab.h>
14#include <linux/net.h>
15#include <linux/skbuff.h>
16#include <linux/crypto.h>
17#include <net/sock.h>
18#include <net/af_rxrpc.h>
19#include "ar-internal.h"
20
21
22
23
24unsigned int rxrpc_connection_expiry = 10 * 60;
25
26static void rxrpc_connection_reaper(struct work_struct *work);
27
28LIST_HEAD(rxrpc_connections);
29DEFINE_RWLOCK(rxrpc_connection_lock);
30static DECLARE_DELAYED_WORK(rxrpc_connection_reap, rxrpc_connection_reaper);
31
32
33
34
35static struct rxrpc_conn_bundle *rxrpc_alloc_bundle(gfp_t gfp)
36{
37 struct rxrpc_conn_bundle *bundle;
38
39 _enter("");
40
41 bundle = kzalloc(sizeof(struct rxrpc_conn_bundle), gfp);
42 if (bundle) {
43 INIT_LIST_HEAD(&bundle->unused_conns);
44 INIT_LIST_HEAD(&bundle->avail_conns);
45 INIT_LIST_HEAD(&bundle->busy_conns);
46 init_waitqueue_head(&bundle->chanwait);
47 atomic_set(&bundle->usage, 1);
48 }
49
50 _leave(" = %p", bundle);
51 return bundle;
52}
53
54
55
56
57
58static inline
59int rxrpc_cmp_bundle(const struct rxrpc_conn_bundle *bundle,
60 struct key *key, u16 service_id)
61{
62 return (bundle->service_id - service_id) ?:
63 ((unsigned long)bundle->key - (unsigned long)key);
64}
65
66
67
68
69struct rxrpc_conn_bundle *rxrpc_get_bundle(struct rxrpc_sock *rx,
70 struct rxrpc_transport *trans,
71 struct key *key,
72 u16 service_id,
73 gfp_t gfp)
74{
75 struct rxrpc_conn_bundle *bundle, *candidate;
76 struct rb_node *p, *parent, **pp;
77
78 _enter("%p{%x},%x,%hx,",
79 rx, key_serial(key), trans->debug_id, service_id);
80
81 if (rx->trans == trans && rx->bundle) {
82 atomic_inc(&rx->bundle->usage);
83 return rx->bundle;
84 }
85
86
87
88 spin_lock(&trans->client_lock);
89
90 p = trans->bundles.rb_node;
91 while (p) {
92 bundle = rb_entry(p, struct rxrpc_conn_bundle, node);
93
94 if (rxrpc_cmp_bundle(bundle, key, service_id) < 0)
95 p = p->rb_left;
96 else if (rxrpc_cmp_bundle(bundle, key, service_id) > 0)
97 p = p->rb_right;
98 else
99 goto found_extant_bundle;
100 }
101
102 spin_unlock(&trans->client_lock);
103
104
105
106 candidate = rxrpc_alloc_bundle(gfp);
107 if (!candidate) {
108 _leave(" = -ENOMEM");
109 return ERR_PTR(-ENOMEM);
110 }
111
112 candidate->key = key_get(key);
113 candidate->service_id = service_id;
114
115 spin_lock(&trans->client_lock);
116
117 pp = &trans->bundles.rb_node;
118 parent = NULL;
119 while (*pp) {
120 parent = *pp;
121 bundle = rb_entry(parent, struct rxrpc_conn_bundle, node);
122
123 if (rxrpc_cmp_bundle(bundle, key, service_id) < 0)
124 pp = &(*pp)->rb_left;
125 else if (rxrpc_cmp_bundle(bundle, key, service_id) > 0)
126 pp = &(*pp)->rb_right;
127 else
128 goto found_extant_second;
129 }
130
131
132 bundle = candidate;
133 candidate = NULL;
134
135 rb_link_node(&bundle->node, parent, pp);
136 rb_insert_color(&bundle->node, &trans->bundles);
137 spin_unlock(&trans->client_lock);
138 _net("BUNDLE new on trans %d", trans->debug_id);
139 if (!rx->bundle && rx->sk.sk_state == RXRPC_CLIENT_CONNECTED) {
140 atomic_inc(&bundle->usage);
141 rx->bundle = bundle;
142 }
143 _leave(" = %p [new]", bundle);
144 return bundle;
145
146
147found_extant_bundle:
148 atomic_inc(&bundle->usage);
149 spin_unlock(&trans->client_lock);
150 _net("BUNDLE old on trans %d", trans->debug_id);
151 if (!rx->bundle && rx->sk.sk_state == RXRPC_CLIENT_CONNECTED) {
152 atomic_inc(&bundle->usage);
153 rx->bundle = bundle;
154 }
155 _leave(" = %p [extant %d]", bundle, atomic_read(&bundle->usage));
156 return bundle;
157
158
159found_extant_second:
160 atomic_inc(&bundle->usage);
161 spin_unlock(&trans->client_lock);
162 kfree(candidate);
163 _net("BUNDLE old2 on trans %d", trans->debug_id);
164 if (!rx->bundle && rx->sk.sk_state == RXRPC_CLIENT_CONNECTED) {
165 atomic_inc(&bundle->usage);
166 rx->bundle = bundle;
167 }
168 _leave(" = %p [second %d]", bundle, atomic_read(&bundle->usage));
169 return bundle;
170}
171
172
173
174
175void rxrpc_put_bundle(struct rxrpc_transport *trans,
176 struct rxrpc_conn_bundle *bundle)
177{
178 _enter("%p,%p{%d}",trans, bundle, atomic_read(&bundle->usage));
179
180 if (atomic_dec_and_lock(&bundle->usage, &trans->client_lock)) {
181 _debug("Destroy bundle");
182 rb_erase(&bundle->node, &trans->bundles);
183 spin_unlock(&trans->client_lock);
184 ASSERT(list_empty(&bundle->unused_conns));
185 ASSERT(list_empty(&bundle->avail_conns));
186 ASSERT(list_empty(&bundle->busy_conns));
187 ASSERTCMP(bundle->num_conns, ==, 0);
188 key_put(bundle->key);
189 kfree(bundle);
190 }
191
192 _leave("");
193}
194
195
196
197
198static struct rxrpc_connection *rxrpc_alloc_connection(gfp_t gfp)
199{
200 struct rxrpc_connection *conn;
201
202 _enter("");
203
204 conn = kzalloc(sizeof(struct rxrpc_connection), gfp);
205 if (conn) {
206 INIT_WORK(&conn->processor, &rxrpc_process_connection);
207 INIT_LIST_HEAD(&conn->bundle_link);
208 conn->calls = RB_ROOT;
209 skb_queue_head_init(&conn->rx_queue);
210 conn->security = &rxrpc_no_security;
211 rwlock_init(&conn->lock);
212 spin_lock_init(&conn->state_lock);
213 atomic_set(&conn->usage, 1);
214 conn->debug_id = atomic_inc_return(&rxrpc_debug_id);
215 conn->avail_calls = RXRPC_MAXCALLS;
216 conn->size_align = 4;
217 conn->header_size = sizeof(struct rxrpc_wire_header);
218 }
219
220 _leave(" = %p{%d}", conn, conn ? conn->debug_id : 0);
221 return conn;
222}
223
224
225
226
227
228
229static void rxrpc_assign_connection_id(struct rxrpc_connection *conn)
230{
231 struct rxrpc_connection *xconn;
232 struct rb_node *parent, **p;
233 __be32 epoch;
234 u32 cid;
235
236 _enter("");
237
238 epoch = conn->epoch;
239
240 write_lock_bh(&conn->trans->conn_lock);
241
242 conn->trans->conn_idcounter += RXRPC_CID_INC;
243 if (conn->trans->conn_idcounter < RXRPC_CID_INC)
244 conn->trans->conn_idcounter = RXRPC_CID_INC;
245 cid = conn->trans->conn_idcounter;
246
247attempt_insertion:
248 parent = NULL;
249 p = &conn->trans->client_conns.rb_node;
250
251 while (*p) {
252 parent = *p;
253 xconn = rb_entry(parent, struct rxrpc_connection, node);
254
255 if (epoch < xconn->epoch)
256 p = &(*p)->rb_left;
257 else if (epoch > xconn->epoch)
258 p = &(*p)->rb_right;
259 else if (cid < xconn->cid)
260 p = &(*p)->rb_left;
261 else if (cid > xconn->cid)
262 p = &(*p)->rb_right;
263 else
264 goto id_exists;
265 }
266
267
268
269 rb_link_node(&conn->node, parent, p);
270 rb_insert_color(&conn->node, &conn->trans->client_conns);
271
272 conn->cid = cid;
273 write_unlock_bh(&conn->trans->conn_lock);
274 _leave(" [CID %x]", cid);
275 return;
276
277
278
279id_exists:
280 for (;;) {
281 cid += RXRPC_CID_INC;
282 if (cid < RXRPC_CID_INC) {
283 cid = RXRPC_CID_INC;
284 conn->trans->conn_idcounter = cid;
285 goto attempt_insertion;
286 }
287
288 parent = rb_next(parent);
289 if (!parent)
290 goto attempt_insertion;
291
292 xconn = rb_entry(parent, struct rxrpc_connection, node);
293 if (epoch < xconn->epoch ||
294 cid < xconn->cid)
295 goto attempt_insertion;
296 }
297}
298
299
300
301
302static void rxrpc_add_call_ID_to_conn(struct rxrpc_connection *conn,
303 struct rxrpc_call *call)
304{
305 struct rxrpc_call *xcall;
306 struct rb_node *parent, **p;
307 __be32 call_id;
308
309 write_lock_bh(&conn->lock);
310
311 call_id = call->call_id;
312 p = &conn->calls.rb_node;
313 parent = NULL;
314 while (*p) {
315 parent = *p;
316 xcall = rb_entry(parent, struct rxrpc_call, conn_node);
317
318 if (call_id < xcall->call_id)
319 p = &(*p)->rb_left;
320 else if (call_id > xcall->call_id)
321 p = &(*p)->rb_right;
322 else
323 BUG();
324 }
325
326 rb_link_node(&call->conn_node, parent, p);
327 rb_insert_color(&call->conn_node, &conn->calls);
328
329 write_unlock_bh(&conn->lock);
330}
331
332
333
334
335static int rxrpc_connect_exclusive(struct rxrpc_sock *rx,
336 struct rxrpc_transport *trans,
337 u16 service_id,
338 struct rxrpc_call *call,
339 gfp_t gfp)
340{
341 struct rxrpc_connection *conn;
342 int chan, ret;
343
344 _enter("");
345
346 conn = rx->conn;
347 if (!conn) {
348
349
350 conn = rxrpc_alloc_connection(gfp);
351 if (!conn) {
352 _leave(" = -ENOMEM");
353 return -ENOMEM;
354 }
355
356 conn->trans = trans;
357 conn->bundle = NULL;
358 conn->service_id = service_id;
359 conn->epoch = rxrpc_epoch;
360 conn->in_clientflag = 0;
361 conn->out_clientflag = RXRPC_CLIENT_INITIATED;
362 conn->cid = 0;
363 conn->state = RXRPC_CONN_CLIENT;
364 conn->avail_calls = RXRPC_MAXCALLS - 1;
365 conn->security_level = rx->min_sec_level;
366 conn->key = key_get(rx->key);
367
368 ret = rxrpc_init_client_conn_security(conn);
369 if (ret < 0) {
370 key_put(conn->key);
371 kfree(conn);
372 _leave(" = %d [key]", ret);
373 return ret;
374 }
375
376 write_lock_bh(&rxrpc_connection_lock);
377 list_add_tail(&conn->link, &rxrpc_connections);
378 write_unlock_bh(&rxrpc_connection_lock);
379
380 spin_lock(&trans->client_lock);
381 atomic_inc(&trans->usage);
382
383 _net("CONNECT EXCL new %d on TRANS %d",
384 conn->debug_id, conn->trans->debug_id);
385
386 rxrpc_assign_connection_id(conn);
387 rx->conn = conn;
388 } else {
389 spin_lock(&trans->client_lock);
390 }
391
392
393
394
395
396
397 for (chan = 0; chan < RXRPC_MAXCALLS; chan++)
398 if (!conn->channels[chan])
399 goto found_channel;
400 goto no_free_channels;
401
402found_channel:
403 atomic_inc(&conn->usage);
404 conn->channels[chan] = call;
405 call->conn = conn;
406 call->channel = chan;
407 call->cid = conn->cid | chan;
408 call->call_id = ++conn->call_counter;
409
410 _net("CONNECT client on conn %d chan %d as call %x",
411 conn->debug_id, chan, call->call_id);
412
413 spin_unlock(&trans->client_lock);
414
415 rxrpc_add_call_ID_to_conn(conn, call);
416 _leave(" = 0");
417 return 0;
418
419no_free_channels:
420 spin_unlock(&trans->client_lock);
421 _leave(" = -ENOSR");
422 return -ENOSR;
423}
424
425
426
427
428
429int rxrpc_connect_call(struct rxrpc_sock *rx,
430 struct rxrpc_transport *trans,
431 struct rxrpc_conn_bundle *bundle,
432 struct rxrpc_call *call,
433 gfp_t gfp)
434{
435 struct rxrpc_connection *conn, *candidate;
436 int chan, ret;
437
438 DECLARE_WAITQUEUE(myself, current);
439
440 _enter("%p,%lx,", rx, call->user_call_ID);
441
442 if (test_bit(RXRPC_SOCK_EXCLUSIVE_CONN, &rx->flags))
443 return rxrpc_connect_exclusive(rx, trans, bundle->service_id,
444 call, gfp);
445
446 spin_lock(&trans->client_lock);
447 for (;;) {
448
449 if (!list_empty(&bundle->avail_conns)) {
450 _debug("avail");
451 conn = list_entry(bundle->avail_conns.next,
452 struct rxrpc_connection,
453 bundle_link);
454 if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
455 list_del_init(&conn->bundle_link);
456 bundle->num_conns--;
457 continue;
458 }
459 if (--conn->avail_calls == 0)
460 list_move(&conn->bundle_link,
461 &bundle->busy_conns);
462 ASSERTCMP(conn->avail_calls, <, RXRPC_MAXCALLS);
463 ASSERT(conn->channels[0] == NULL ||
464 conn->channels[1] == NULL ||
465 conn->channels[2] == NULL ||
466 conn->channels[3] == NULL);
467 atomic_inc(&conn->usage);
468 break;
469 }
470
471 if (!list_empty(&bundle->unused_conns)) {
472 _debug("unused");
473 conn = list_entry(bundle->unused_conns.next,
474 struct rxrpc_connection,
475 bundle_link);
476 if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
477 list_del_init(&conn->bundle_link);
478 bundle->num_conns--;
479 continue;
480 }
481 ASSERTCMP(conn->avail_calls, ==, RXRPC_MAXCALLS);
482 conn->avail_calls = RXRPC_MAXCALLS - 1;
483 ASSERT(conn->channels[0] == NULL &&
484 conn->channels[1] == NULL &&
485 conn->channels[2] == NULL &&
486 conn->channels[3] == NULL);
487 atomic_inc(&conn->usage);
488 list_move(&conn->bundle_link, &bundle->avail_conns);
489 break;
490 }
491
492
493 _debug("get new conn [%d]", bundle->num_conns);
494
495 spin_unlock(&trans->client_lock);
496
497 if (signal_pending(current))
498 goto interrupted;
499
500 if (bundle->num_conns >= 20) {
501 _debug("too many conns");
502
503 if (!gfpflags_allow_blocking(gfp)) {
504 _leave(" = -EAGAIN");
505 return -EAGAIN;
506 }
507
508 add_wait_queue(&bundle->chanwait, &myself);
509 for (;;) {
510 set_current_state(TASK_INTERRUPTIBLE);
511 if (bundle->num_conns < 20 ||
512 !list_empty(&bundle->unused_conns) ||
513 !list_empty(&bundle->avail_conns))
514 break;
515 if (signal_pending(current))
516 goto interrupted_dequeue;
517 schedule();
518 }
519 remove_wait_queue(&bundle->chanwait, &myself);
520 __set_current_state(TASK_RUNNING);
521 spin_lock(&trans->client_lock);
522 continue;
523 }
524
525
526
527 candidate = rxrpc_alloc_connection(gfp);
528 if (!candidate) {
529 _leave(" = -ENOMEM");
530 return -ENOMEM;
531 }
532
533 candidate->trans = trans;
534 candidate->bundle = bundle;
535 candidate->service_id = bundle->service_id;
536 candidate->epoch = rxrpc_epoch;
537 candidate->in_clientflag = 0;
538 candidate->out_clientflag = RXRPC_CLIENT_INITIATED;
539 candidate->cid = 0;
540 candidate->state = RXRPC_CONN_CLIENT;
541 candidate->avail_calls = RXRPC_MAXCALLS;
542 candidate->security_level = rx->min_sec_level;
543 candidate->key = key_get(bundle->key);
544
545 ret = rxrpc_init_client_conn_security(candidate);
546 if (ret < 0) {
547 key_put(candidate->key);
548 kfree(candidate);
549 _leave(" = %d [key]", ret);
550 return ret;
551 }
552
553 write_lock_bh(&rxrpc_connection_lock);
554 list_add_tail(&candidate->link, &rxrpc_connections);
555 write_unlock_bh(&rxrpc_connection_lock);
556
557 spin_lock(&trans->client_lock);
558
559 list_add(&candidate->bundle_link, &bundle->unused_conns);
560 bundle->num_conns++;
561 atomic_inc(&bundle->usage);
562 atomic_inc(&trans->usage);
563
564 _net("CONNECT new %d on TRANS %d",
565 candidate->debug_id, candidate->trans->debug_id);
566
567 rxrpc_assign_connection_id(candidate);
568 candidate->security->prime_packet_security(candidate);
569
570
571
572 rxrpc_put_connection(candidate);
573 candidate = NULL;
574 }
575
576
577
578
579
580
581
582 for (chan = 0; chan < RXRPC_MAXCALLS; chan++)
583 if (!conn->channels[chan])
584 goto found_channel;
585 ASSERT(conn->channels[0] == NULL ||
586 conn->channels[1] == NULL ||
587 conn->channels[2] == NULL ||
588 conn->channels[3] == NULL);
589 BUG();
590
591found_channel:
592 conn->channels[chan] = call;
593 call->conn = conn;
594 call->channel = chan;
595 call->cid = conn->cid | chan;
596 call->call_id = ++conn->call_counter;
597
598 _net("CONNECT client on conn %d chan %d as call %x",
599 conn->debug_id, chan, call->call_id);
600
601 ASSERTCMP(conn->avail_calls, <, RXRPC_MAXCALLS);
602 spin_unlock(&trans->client_lock);
603
604 rxrpc_add_call_ID_to_conn(conn, call);
605
606 _leave(" = 0");
607 return 0;
608
609interrupted_dequeue:
610 remove_wait_queue(&bundle->chanwait, &myself);
611 __set_current_state(TASK_RUNNING);
612interrupted:
613 _leave(" = -ERESTARTSYS");
614 return -ERESTARTSYS;
615}
616
617
618
619
620struct rxrpc_connection *
621rxrpc_incoming_connection(struct rxrpc_transport *trans,
622 struct rxrpc_host_header *hdr)
623{
624 struct rxrpc_connection *conn, *candidate = NULL;
625 struct rb_node *p, **pp;
626 const char *new = "old";
627 __be32 epoch;
628 u32 cid;
629
630 _enter("");
631
632 ASSERT(hdr->flags & RXRPC_CLIENT_INITIATED);
633
634 epoch = hdr->epoch;
635 cid = hdr->cid & RXRPC_CIDMASK;
636
637
638 read_lock_bh(&trans->conn_lock);
639
640 p = trans->server_conns.rb_node;
641 while (p) {
642 conn = rb_entry(p, struct rxrpc_connection, node);
643
644 _debug("maybe %x", conn->cid);
645
646 if (epoch < conn->epoch)
647 p = p->rb_left;
648 else if (epoch > conn->epoch)
649 p = p->rb_right;
650 else if (cid < conn->cid)
651 p = p->rb_left;
652 else if (cid > conn->cid)
653 p = p->rb_right;
654 else
655 goto found_extant_connection;
656 }
657 read_unlock_bh(&trans->conn_lock);
658
659
660
661 candidate = rxrpc_alloc_connection(GFP_NOIO);
662 if (!candidate) {
663 _leave(" = -ENOMEM");
664 return ERR_PTR(-ENOMEM);
665 }
666
667 candidate->trans = trans;
668 candidate->epoch = hdr->epoch;
669 candidate->cid = hdr->cid & RXRPC_CIDMASK;
670 candidate->service_id = hdr->serviceId;
671 candidate->security_ix = hdr->securityIndex;
672 candidate->in_clientflag = RXRPC_CLIENT_INITIATED;
673 candidate->out_clientflag = 0;
674 candidate->state = RXRPC_CONN_SERVER;
675 if (candidate->service_id)
676 candidate->state = RXRPC_CONN_SERVER_UNSECURED;
677
678 write_lock_bh(&trans->conn_lock);
679
680 pp = &trans->server_conns.rb_node;
681 p = NULL;
682 while (*pp) {
683 p = *pp;
684 conn = rb_entry(p, struct rxrpc_connection, node);
685
686 if (epoch < conn->epoch)
687 pp = &(*pp)->rb_left;
688 else if (epoch > conn->epoch)
689 pp = &(*pp)->rb_right;
690 else if (cid < conn->cid)
691 pp = &(*pp)->rb_left;
692 else if (cid > conn->cid)
693 pp = &(*pp)->rb_right;
694 else
695 goto found_extant_second;
696 }
697
698
699 conn = candidate;
700 candidate = NULL;
701 rb_link_node(&conn->node, p, pp);
702 rb_insert_color(&conn->node, &trans->server_conns);
703 atomic_inc(&conn->trans->usage);
704
705 write_unlock_bh(&trans->conn_lock);
706
707 write_lock_bh(&rxrpc_connection_lock);
708 list_add_tail(&conn->link, &rxrpc_connections);
709 write_unlock_bh(&rxrpc_connection_lock);
710
711 new = "new";
712
713success:
714 _net("CONNECTION %s %d {%x}", new, conn->debug_id, conn->cid);
715
716 _leave(" = %p {u=%d}", conn, atomic_read(&conn->usage));
717 return conn;
718
719
720found_extant_connection:
721 if (hdr->securityIndex != conn->security_ix) {
722 read_unlock_bh(&trans->conn_lock);
723 goto security_mismatch;
724 }
725 atomic_inc(&conn->usage);
726 read_unlock_bh(&trans->conn_lock);
727 goto success;
728
729
730found_extant_second:
731 if (hdr->securityIndex != conn->security_ix) {
732 write_unlock_bh(&trans->conn_lock);
733 goto security_mismatch;
734 }
735 atomic_inc(&conn->usage);
736 write_unlock_bh(&trans->conn_lock);
737 kfree(candidate);
738 goto success;
739
740security_mismatch:
741 kfree(candidate);
742 _leave(" = -EKEYREJECTED");
743 return ERR_PTR(-EKEYREJECTED);
744}
745
746
747
748
749
750struct rxrpc_connection *rxrpc_find_connection(struct rxrpc_transport *trans,
751 struct rxrpc_host_header *hdr)
752{
753 struct rxrpc_connection *conn;
754 struct rb_node *p;
755 u32 epoch, cid;
756
757 _enter(",{%x,%x}", hdr->cid, hdr->flags);
758
759 read_lock_bh(&trans->conn_lock);
760
761 cid = hdr->cid & RXRPC_CIDMASK;
762 epoch = hdr->epoch;
763
764 if (hdr->flags & RXRPC_CLIENT_INITIATED)
765 p = trans->server_conns.rb_node;
766 else
767 p = trans->client_conns.rb_node;
768
769 while (p) {
770 conn = rb_entry(p, struct rxrpc_connection, node);
771
772 _debug("maybe %x", conn->cid);
773
774 if (epoch < conn->epoch)
775 p = p->rb_left;
776 else if (epoch > conn->epoch)
777 p = p->rb_right;
778 else if (cid < conn->cid)
779 p = p->rb_left;
780 else if (cid > conn->cid)
781 p = p->rb_right;
782 else
783 goto found;
784 }
785
786 read_unlock_bh(&trans->conn_lock);
787 _leave(" = NULL");
788 return NULL;
789
790found:
791 atomic_inc(&conn->usage);
792 read_unlock_bh(&trans->conn_lock);
793 _leave(" = %p", conn);
794 return conn;
795}
796
797
798
799
800void rxrpc_put_connection(struct rxrpc_connection *conn)
801{
802 _enter("%p{u=%d,d=%d}",
803 conn, atomic_read(&conn->usage), conn->debug_id);
804
805 ASSERTCMP(atomic_read(&conn->usage), >, 0);
806
807 conn->put_time = ktime_get_seconds();
808 if (atomic_dec_and_test(&conn->usage)) {
809 _debug("zombie");
810 rxrpc_queue_delayed_work(&rxrpc_connection_reap, 0);
811 }
812
813 _leave("");
814}
815
816
817
818
819static void rxrpc_destroy_connection(struct rxrpc_connection *conn)
820{
821 _enter("%p{%d}", conn, atomic_read(&conn->usage));
822
823 ASSERTCMP(atomic_read(&conn->usage), ==, 0);
824
825 _net("DESTROY CONN %d", conn->debug_id);
826
827 if (conn->bundle)
828 rxrpc_put_bundle(conn->trans, conn->bundle);
829
830 ASSERT(RB_EMPTY_ROOT(&conn->calls));
831 rxrpc_purge_queue(&conn->rx_queue);
832
833 conn->security->clear(conn);
834 key_put(conn->key);
835 key_put(conn->server_key);
836
837 rxrpc_put_transport(conn->trans);
838 kfree(conn);
839 _leave("");
840}
841
842
843
844
845static void rxrpc_connection_reaper(struct work_struct *work)
846{
847 struct rxrpc_connection *conn, *_p;
848 unsigned long now, earliest, reap_time;
849
850 LIST_HEAD(graveyard);
851
852 _enter("");
853
854 now = ktime_get_seconds();
855 earliest = ULONG_MAX;
856
857 write_lock_bh(&rxrpc_connection_lock);
858 list_for_each_entry_safe(conn, _p, &rxrpc_connections, link) {
859 _debug("reap CONN %d { u=%d,t=%ld }",
860 conn->debug_id, atomic_read(&conn->usage),
861 (long) now - (long) conn->put_time);
862
863 if (likely(atomic_read(&conn->usage) > 0))
864 continue;
865
866 spin_lock(&conn->trans->client_lock);
867 write_lock(&conn->trans->conn_lock);
868 reap_time = conn->put_time + rxrpc_connection_expiry;
869
870 if (atomic_read(&conn->usage) > 0) {
871 ;
872 } else if (reap_time <= now) {
873 list_move_tail(&conn->link, &graveyard);
874 if (conn->out_clientflag)
875 rb_erase(&conn->node,
876 &conn->trans->client_conns);
877 else
878 rb_erase(&conn->node,
879 &conn->trans->server_conns);
880 if (conn->bundle) {
881 list_del_init(&conn->bundle_link);
882 conn->bundle->num_conns--;
883 }
884
885 } else if (reap_time < earliest) {
886 earliest = reap_time;
887 }
888
889 write_unlock(&conn->trans->conn_lock);
890 spin_unlock(&conn->trans->client_lock);
891 }
892 write_unlock_bh(&rxrpc_connection_lock);
893
894 if (earliest != ULONG_MAX) {
895 _debug("reschedule reaper %ld", (long) earliest - now);
896 ASSERTCMP(earliest, >, now);
897 rxrpc_queue_delayed_work(&rxrpc_connection_reap,
898 (earliest - now) * HZ);
899 }
900
901
902 while (!list_empty(&graveyard)) {
903 conn = list_entry(graveyard.next, struct rxrpc_connection,
904 link);
905 list_del_init(&conn->link);
906
907 ASSERTCMP(atomic_read(&conn->usage), ==, 0);
908 rxrpc_destroy_connection(conn);
909 }
910
911 _leave("");
912}
913
914
915
916
917
918void __exit rxrpc_destroy_all_connections(void)
919{
920 _enter("");
921
922 rxrpc_connection_expiry = 0;
923 cancel_delayed_work(&rxrpc_connection_reap);
924 rxrpc_queue_delayed_work(&rxrpc_connection_reap, 0);
925
926 _leave("");
927}
928
