1 /* RxRPC virtual connection handler
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
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>
18 #include <net/af_rxrpc.h>
19 #include "ar-internal.h"
22 * Time till a connection expires after last use (in seconds).
24 unsigned int rxrpc_connection_expiry = 10 * 60;
26 static void rxrpc_connection_reaper(struct work_struct *work);
28 LIST_HEAD(rxrpc_connections);
29 DEFINE_RWLOCK(rxrpc_connection_lock);
30 static DECLARE_DELAYED_WORK(rxrpc_connection_reap, rxrpc_connection_reaper);
33 * allocate a new client connection bundle
35 static struct rxrpc_conn_bundle *rxrpc_alloc_bundle(gfp_t gfp)
37 struct rxrpc_conn_bundle *bundle;
41 bundle = kzalloc(sizeof(struct rxrpc_conn_bundle), gfp);
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);
50 _leave(" = %p", bundle);
55 * compare bundle parameters with what we're looking for
56 * - return -ve, 0 or +ve
59 int rxrpc_cmp_bundle(const struct rxrpc_conn_bundle *bundle,
60 struct key *key, u16 service_id)
62 return (bundle->service_id - service_id) ?:
63 ((unsigned long)bundle->key - (unsigned long)key);
67 * get bundle of client connections that a client socket can make use of
69 struct rxrpc_conn_bundle *rxrpc_get_bundle(struct rxrpc_sock *rx,
70 struct rxrpc_transport *trans,
75 struct rxrpc_conn_bundle *bundle, *candidate;
76 struct rb_node *p, *parent, **pp;
78 _enter("%p{%x},%x,%hx,",
79 rx, key_serial(key), trans->debug_id, service_id);
81 if (rx->trans == trans && rx->bundle) {
82 atomic_inc(&rx->bundle->usage);
86 /* search the extant bundles first for one that matches the specified
88 spin_lock(&trans->client_lock);
90 p = trans->bundles.rb_node;
92 bundle = rb_entry(p, struct rxrpc_conn_bundle, node);
94 if (rxrpc_cmp_bundle(bundle, key, service_id) < 0)
96 else if (rxrpc_cmp_bundle(bundle, key, service_id) > 0)
99 goto found_extant_bundle;
102 spin_unlock(&trans->client_lock);
104 /* not yet present - create a candidate for a new record and then
106 candidate = rxrpc_alloc_bundle(gfp);
108 _leave(" = -ENOMEM");
109 return ERR_PTR(-ENOMEM);
112 candidate->key = key_get(key);
113 candidate->service_id = service_id;
115 spin_lock(&trans->client_lock);
117 pp = &trans->bundles.rb_node;
121 bundle = rb_entry(parent, struct rxrpc_conn_bundle, node);
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;
128 goto found_extant_second;
131 /* second search also failed; add the new bundle */
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);
143 _leave(" = %p [new]", bundle);
146 /* we found the bundle in the list immediately */
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);
155 _leave(" = %p [extant %d]", bundle, atomic_read(&bundle->usage));
158 /* we found the bundle on the second time through the list */
160 atomic_inc(&bundle->usage);
161 spin_unlock(&trans->client_lock);
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);
168 _leave(" = %p [second %d]", bundle, atomic_read(&bundle->usage));
175 void rxrpc_put_bundle(struct rxrpc_transport *trans,
176 struct rxrpc_conn_bundle *bundle)
178 _enter("%p,%p{%d}",trans, bundle, atomic_read(&bundle->usage));
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);
196 * allocate a new connection
198 static struct rxrpc_connection *rxrpc_alloc_connection(gfp_t gfp)
200 struct rxrpc_connection *conn;
204 conn = kzalloc(sizeof(struct rxrpc_connection), gfp);
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 rwlock_init(&conn->lock);
211 spin_lock_init(&conn->state_lock);
212 atomic_set(&conn->usage, 1);
213 conn->debug_id = atomic_inc_return(&rxrpc_debug_id);
214 conn->avail_calls = RXRPC_MAXCALLS;
215 conn->size_align = 4;
216 conn->header_size = sizeof(struct rxrpc_wire_header);
219 _leave(" = %p{%d}", conn, conn ? conn->debug_id : 0);
224 * assign a connection ID to a connection and add it to the transport's
225 * connection lookup tree
226 * - called with transport client lock held
228 static void rxrpc_assign_connection_id(struct rxrpc_connection *conn)
230 struct rxrpc_connection *xconn;
231 struct rb_node *parent, **p;
239 write_lock_bh(&conn->trans->conn_lock);
241 conn->trans->conn_idcounter += RXRPC_CID_INC;
242 if (conn->trans->conn_idcounter < RXRPC_CID_INC)
243 conn->trans->conn_idcounter = RXRPC_CID_INC;
244 cid = conn->trans->conn_idcounter;
248 p = &conn->trans->client_conns.rb_node;
252 xconn = rb_entry(parent, struct rxrpc_connection, node);
254 if (epoch < xconn->epoch)
256 else if (epoch > xconn->epoch)
258 else if (cid < xconn->cid)
260 else if (cid > xconn->cid)
266 /* we've found a suitable hole - arrange for this connection to occupy
268 rb_link_node(&conn->node, parent, p);
269 rb_insert_color(&conn->node, &conn->trans->client_conns);
272 write_unlock_bh(&conn->trans->conn_lock);
273 _leave(" [CID %x]", cid);
276 /* we found a connection with the proposed ID - walk the tree from that
277 * point looking for the next unused ID */
280 cid += RXRPC_CID_INC;
281 if (cid < RXRPC_CID_INC) {
283 conn->trans->conn_idcounter = cid;
284 goto attempt_insertion;
287 parent = rb_next(parent);
289 goto attempt_insertion;
291 xconn = rb_entry(parent, struct rxrpc_connection, node);
292 if (epoch < xconn->epoch ||
294 goto attempt_insertion;
299 * add a call to a connection's call-by-ID tree
301 static void rxrpc_add_call_ID_to_conn(struct rxrpc_connection *conn,
302 struct rxrpc_call *call)
304 struct rxrpc_call *xcall;
305 struct rb_node *parent, **p;
308 write_lock_bh(&conn->lock);
310 call_id = call->call_id;
311 p = &conn->calls.rb_node;
315 xcall = rb_entry(parent, struct rxrpc_call, conn_node);
317 if (call_id < xcall->call_id)
319 else if (call_id > xcall->call_id)
325 rb_link_node(&call->conn_node, parent, p);
326 rb_insert_color(&call->conn_node, &conn->calls);
328 write_unlock_bh(&conn->lock);
332 * connect a call on an exclusive connection
334 static int rxrpc_connect_exclusive(struct rxrpc_sock *rx,
335 struct rxrpc_transport *trans,
337 struct rxrpc_call *call,
340 struct rxrpc_connection *conn;
347 /* not yet present - create a candidate for a new connection
348 * and then redo the check */
349 conn = rxrpc_alloc_connection(gfp);
351 _leave(" = -ENOMEM");
357 conn->service_id = service_id;
358 conn->epoch = rxrpc_epoch;
359 conn->in_clientflag = 0;
360 conn->out_clientflag = RXRPC_CLIENT_INITIATED;
362 conn->state = RXRPC_CONN_CLIENT;
363 conn->avail_calls = RXRPC_MAXCALLS - 1;
364 conn->security_level = rx->min_sec_level;
365 conn->key = key_get(rx->key);
367 ret = rxrpc_init_client_conn_security(conn);
371 _leave(" = %d [key]", ret);
375 write_lock_bh(&rxrpc_connection_lock);
376 list_add_tail(&conn->link, &rxrpc_connections);
377 write_unlock_bh(&rxrpc_connection_lock);
379 spin_lock(&trans->client_lock);
380 atomic_inc(&trans->usage);
382 _net("CONNECT EXCL new %d on TRANS %d",
383 conn->debug_id, conn->trans->debug_id);
385 rxrpc_assign_connection_id(conn);
388 spin_lock(&trans->client_lock);
391 /* we've got a connection with a free channel and we can now attach the
393 * - we're holding the transport's client lock
394 * - we're holding a reference on the connection
396 for (chan = 0; chan < RXRPC_MAXCALLS; chan++)
397 if (!conn->channels[chan])
399 goto no_free_channels;
402 atomic_inc(&conn->usage);
403 conn->channels[chan] = call;
405 call->channel = chan;
406 call->cid = conn->cid | chan;
407 call->call_id = ++conn->call_counter;
409 _net("CONNECT client on conn %d chan %d as call %x",
410 conn->debug_id, chan, call->call_id);
412 spin_unlock(&trans->client_lock);
414 rxrpc_add_call_ID_to_conn(conn, call);
419 spin_unlock(&trans->client_lock);
425 * find a connection for a call
426 * - called in process context with IRQs enabled
428 int rxrpc_connect_call(struct rxrpc_sock *rx,
429 struct rxrpc_transport *trans,
430 struct rxrpc_conn_bundle *bundle,
431 struct rxrpc_call *call,
434 struct rxrpc_connection *conn, *candidate;
437 DECLARE_WAITQUEUE(myself, current);
439 _enter("%p,%lx,", rx, call->user_call_ID);
441 if (test_bit(RXRPC_SOCK_EXCLUSIVE_CONN, &rx->flags))
442 return rxrpc_connect_exclusive(rx, trans, bundle->service_id,
445 spin_lock(&trans->client_lock);
447 /* see if the bundle has a call slot available */
448 if (!list_empty(&bundle->avail_conns)) {
450 conn = list_entry(bundle->avail_conns.next,
451 struct rxrpc_connection,
453 if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
454 list_del_init(&conn->bundle_link);
458 if (--conn->avail_calls == 0)
459 list_move(&conn->bundle_link,
460 &bundle->busy_conns);
461 ASSERTCMP(conn->avail_calls, <, RXRPC_MAXCALLS);
462 ASSERT(conn->channels[0] == NULL ||
463 conn->channels[1] == NULL ||
464 conn->channels[2] == NULL ||
465 conn->channels[3] == NULL);
466 atomic_inc(&conn->usage);
470 if (!list_empty(&bundle->unused_conns)) {
472 conn = list_entry(bundle->unused_conns.next,
473 struct rxrpc_connection,
475 if (conn->state >= RXRPC_CONN_REMOTELY_ABORTED) {
476 list_del_init(&conn->bundle_link);
480 ASSERTCMP(conn->avail_calls, ==, RXRPC_MAXCALLS);
481 conn->avail_calls = RXRPC_MAXCALLS - 1;
482 ASSERT(conn->channels[0] == NULL &&
483 conn->channels[1] == NULL &&
484 conn->channels[2] == NULL &&
485 conn->channels[3] == NULL);
486 atomic_inc(&conn->usage);
487 list_move(&conn->bundle_link, &bundle->avail_conns);
491 /* need to allocate a new connection */
492 _debug("get new conn [%d]", bundle->num_conns);
494 spin_unlock(&trans->client_lock);
496 if (signal_pending(current))
499 if (bundle->num_conns >= 20) {
500 _debug("too many conns");
502 if (!gfpflags_allow_blocking(gfp)) {
503 _leave(" = -EAGAIN");
507 add_wait_queue(&bundle->chanwait, &myself);
509 set_current_state(TASK_INTERRUPTIBLE);
510 if (bundle->num_conns < 20 ||
511 !list_empty(&bundle->unused_conns) ||
512 !list_empty(&bundle->avail_conns))
514 if (signal_pending(current))
515 goto interrupted_dequeue;
518 remove_wait_queue(&bundle->chanwait, &myself);
519 __set_current_state(TASK_RUNNING);
520 spin_lock(&trans->client_lock);
524 /* not yet present - create a candidate for a new connection and then
526 candidate = rxrpc_alloc_connection(gfp);
528 _leave(" = -ENOMEM");
532 candidate->trans = trans;
533 candidate->bundle = bundle;
534 candidate->service_id = bundle->service_id;
535 candidate->epoch = rxrpc_epoch;
536 candidate->in_clientflag = 0;
537 candidate->out_clientflag = RXRPC_CLIENT_INITIATED;
539 candidate->state = RXRPC_CONN_CLIENT;
540 candidate->avail_calls = RXRPC_MAXCALLS;
541 candidate->security_level = rx->min_sec_level;
542 candidate->key = key_get(bundle->key);
544 ret = rxrpc_init_client_conn_security(candidate);
546 key_put(candidate->key);
548 _leave(" = %d [key]", ret);
552 write_lock_bh(&rxrpc_connection_lock);
553 list_add_tail(&candidate->link, &rxrpc_connections);
554 write_unlock_bh(&rxrpc_connection_lock);
556 spin_lock(&trans->client_lock);
558 list_add(&candidate->bundle_link, &bundle->unused_conns);
560 atomic_inc(&bundle->usage);
561 atomic_inc(&trans->usage);
563 _net("CONNECT new %d on TRANS %d",
564 candidate->debug_id, candidate->trans->debug_id);
566 rxrpc_assign_connection_id(candidate);
567 if (candidate->security)
568 candidate->security->prime_packet_security(candidate);
570 /* leave the candidate lurking in zombie mode attached to the
571 * bundle until we're ready for it */
572 rxrpc_put_connection(candidate);
576 /* we've got a connection with a free channel and we can now attach the
578 * - we're holding the transport's client lock
579 * - we're holding a reference on the connection
580 * - we're holding a reference on the bundle
582 for (chan = 0; chan < RXRPC_MAXCALLS; chan++)
583 if (!conn->channels[chan])
585 ASSERT(conn->channels[0] == NULL ||
586 conn->channels[1] == NULL ||
587 conn->channels[2] == NULL ||
588 conn->channels[3] == NULL);
592 conn->channels[chan] = call;
594 call->channel = chan;
595 call->cid = conn->cid | chan;
596 call->call_id = ++conn->call_counter;
598 _net("CONNECT client on conn %d chan %d as call %x",
599 conn->debug_id, chan, call->call_id);
601 ASSERTCMP(conn->avail_calls, <, RXRPC_MAXCALLS);
602 spin_unlock(&trans->client_lock);
604 rxrpc_add_call_ID_to_conn(conn, call);
610 remove_wait_queue(&bundle->chanwait, &myself);
611 __set_current_state(TASK_RUNNING);
613 _leave(" = -ERESTARTSYS");
618 * get a record of an incoming connection
620 struct rxrpc_connection *
621 rxrpc_incoming_connection(struct rxrpc_transport *trans,
622 struct rxrpc_host_header *hdr,
625 struct rxrpc_connection *conn, *candidate = NULL;
626 struct rb_node *p, **pp;
627 const char *new = "old";
633 ASSERT(hdr->flags & RXRPC_CLIENT_INITIATED);
636 cid = hdr->cid & RXRPC_CIDMASK;
638 /* search the connection list first */
639 read_lock_bh(&trans->conn_lock);
641 p = trans->server_conns.rb_node;
643 conn = rb_entry(p, struct rxrpc_connection, node);
645 _debug("maybe %x", conn->cid);
647 if (epoch < conn->epoch)
649 else if (epoch > conn->epoch)
651 else if (cid < conn->cid)
653 else if (cid > conn->cid)
656 goto found_extant_connection;
658 read_unlock_bh(&trans->conn_lock);
660 /* not yet present - create a candidate for a new record and then
662 candidate = rxrpc_alloc_connection(gfp);
664 _leave(" = -ENOMEM");
665 return ERR_PTR(-ENOMEM);
668 candidate->trans = trans;
669 candidate->epoch = hdr->epoch;
670 candidate->cid = hdr->cid & RXRPC_CIDMASK;
671 candidate->service_id = hdr->serviceId;
672 candidate->security_ix = hdr->securityIndex;
673 candidate->in_clientflag = RXRPC_CLIENT_INITIATED;
674 candidate->out_clientflag = 0;
675 candidate->state = RXRPC_CONN_SERVER;
676 if (candidate->service_id)
677 candidate->state = RXRPC_CONN_SERVER_UNSECURED;
679 write_lock_bh(&trans->conn_lock);
681 pp = &trans->server_conns.rb_node;
685 conn = rb_entry(p, struct rxrpc_connection, node);
687 if (epoch < conn->epoch)
688 pp = &(*pp)->rb_left;
689 else if (epoch > conn->epoch)
690 pp = &(*pp)->rb_right;
691 else if (cid < conn->cid)
692 pp = &(*pp)->rb_left;
693 else if (cid > conn->cid)
694 pp = &(*pp)->rb_right;
696 goto found_extant_second;
699 /* we can now add the new candidate to the list */
702 rb_link_node(&conn->node, p, pp);
703 rb_insert_color(&conn->node, &trans->server_conns);
704 atomic_inc(&conn->trans->usage);
706 write_unlock_bh(&trans->conn_lock);
708 write_lock_bh(&rxrpc_connection_lock);
709 list_add_tail(&conn->link, &rxrpc_connections);
710 write_unlock_bh(&rxrpc_connection_lock);
715 _net("CONNECTION %s %d {%x}", new, conn->debug_id, conn->cid);
717 _leave(" = %p {u=%d}", conn, atomic_read(&conn->usage));
720 /* we found the connection in the list immediately */
721 found_extant_connection:
722 if (hdr->securityIndex != conn->security_ix) {
723 read_unlock_bh(&trans->conn_lock);
724 goto security_mismatch;
726 atomic_inc(&conn->usage);
727 read_unlock_bh(&trans->conn_lock);
730 /* we found the connection on the second time through the list */
732 if (hdr->securityIndex != conn->security_ix) {
733 write_unlock_bh(&trans->conn_lock);
734 goto security_mismatch;
736 atomic_inc(&conn->usage);
737 write_unlock_bh(&trans->conn_lock);
743 _leave(" = -EKEYREJECTED");
744 return ERR_PTR(-EKEYREJECTED);
748 * find a connection based on transport and RxRPC connection ID for an incoming
751 struct rxrpc_connection *rxrpc_find_connection(struct rxrpc_transport *trans,
752 struct rxrpc_host_header *hdr)
754 struct rxrpc_connection *conn;
758 _enter(",{%x,%x}", hdr->cid, hdr->flags);
760 read_lock_bh(&trans->conn_lock);
762 cid = hdr->cid & RXRPC_CIDMASK;
765 if (hdr->flags & RXRPC_CLIENT_INITIATED)
766 p = trans->server_conns.rb_node;
768 p = trans->client_conns.rb_node;
771 conn = rb_entry(p, struct rxrpc_connection, node);
773 _debug("maybe %x", conn->cid);
775 if (epoch < conn->epoch)
777 else if (epoch > conn->epoch)
779 else if (cid < conn->cid)
781 else if (cid > conn->cid)
787 read_unlock_bh(&trans->conn_lock);
792 atomic_inc(&conn->usage);
793 read_unlock_bh(&trans->conn_lock);
794 _leave(" = %p", conn);
799 * release a virtual connection
801 void rxrpc_put_connection(struct rxrpc_connection *conn)
803 _enter("%p{u=%d,d=%d}",
804 conn, atomic_read(&conn->usage), conn->debug_id);
806 ASSERTCMP(atomic_read(&conn->usage), >, 0);
808 conn->put_time = ktime_get_seconds();
809 if (atomic_dec_and_test(&conn->usage)) {
811 rxrpc_queue_delayed_work(&rxrpc_connection_reap, 0);
818 * destroy a virtual connection
820 static void rxrpc_destroy_connection(struct rxrpc_connection *conn)
822 _enter("%p{%d}", conn, atomic_read(&conn->usage));
824 ASSERTCMP(atomic_read(&conn->usage), ==, 0);
826 _net("DESTROY CONN %d", conn->debug_id);
829 rxrpc_put_bundle(conn->trans, conn->bundle);
831 ASSERT(RB_EMPTY_ROOT(&conn->calls));
832 rxrpc_purge_queue(&conn->rx_queue);
834 rxrpc_clear_conn_security(conn);
835 rxrpc_put_transport(conn->trans);
841 * reap dead connections
843 static void rxrpc_connection_reaper(struct work_struct *work)
845 struct rxrpc_connection *conn, *_p;
846 unsigned long now, earliest, reap_time;
848 LIST_HEAD(graveyard);
852 now = ktime_get_seconds();
853 earliest = ULONG_MAX;
855 write_lock_bh(&rxrpc_connection_lock);
856 list_for_each_entry_safe(conn, _p, &rxrpc_connections, link) {
857 _debug("reap CONN %d { u=%d,t=%ld }",
858 conn->debug_id, atomic_read(&conn->usage),
859 (long) now - (long) conn->put_time);
861 if (likely(atomic_read(&conn->usage) > 0))
864 spin_lock(&conn->trans->client_lock);
865 write_lock(&conn->trans->conn_lock);
866 reap_time = conn->put_time + rxrpc_connection_expiry;
868 if (atomic_read(&conn->usage) > 0) {
870 } else if (reap_time <= now) {
871 list_move_tail(&conn->link, &graveyard);
872 if (conn->out_clientflag)
873 rb_erase(&conn->node,
874 &conn->trans->client_conns);
876 rb_erase(&conn->node,
877 &conn->trans->server_conns);
879 list_del_init(&conn->bundle_link);
880 conn->bundle->num_conns--;
883 } else if (reap_time < earliest) {
884 earliest = reap_time;
887 write_unlock(&conn->trans->conn_lock);
888 spin_unlock(&conn->trans->client_lock);
890 write_unlock_bh(&rxrpc_connection_lock);
892 if (earliest != ULONG_MAX) {
893 _debug("reschedule reaper %ld", (long) earliest - now);
894 ASSERTCMP(earliest, >, now);
895 rxrpc_queue_delayed_work(&rxrpc_connection_reap,
896 (earliest - now) * HZ);
899 /* then destroy all those pulled out */
900 while (!list_empty(&graveyard)) {
901 conn = list_entry(graveyard.next, struct rxrpc_connection,
903 list_del_init(&conn->link);
905 ASSERTCMP(atomic_read(&conn->usage), ==, 0);
906 rxrpc_destroy_connection(conn);
913 * preemptively destroy all the connection records rather than waiting for them
916 void __exit rxrpc_destroy_all_connections(void)
920 rxrpc_connection_expiry = 0;
921 cancel_delayed_work(&rxrpc_connection_reap);
922 rxrpc_queue_delayed_work(&rxrpc_connection_reap, 0);