net/rxrpc/ar-connection.c

   1 /* RxRPC virtual connection handler
   2  *
   3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   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.
  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  * Time till a connection expires after last use (in seconds).
  23  */
  24 unsigned int rxrpc_connection_expiry = 10 * 60;
  25
  26 static void rxrpc_connection_reaper(struct work_struct *work);
  27
  28 LIST_HEAD(rxrpc_connections);
  29 DEFINE_RWLOCK(rxrpc_connection_lock);
  30 static DECLARE_DELAYED_WORK(rxrpc_connection_reap, rxrpc_connection_reaper);
  31
  32 /*
  33  * allocate a new client connection bundle
  34  */
  35 static 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  * compare bundle parameters with what we're looking for
  56  * - return -ve, 0 or +ve
  57  */
  58 static inline
  59 int 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  * get bundle of client connections that a client socket can make use of
  68  */
  69 struct 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         /* search the extant bundles first for one that matches the specified
  87          * user ID */
  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         /* not yet present - create a candidate for a new record and then
 105          * redo the search */
 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         /* second search also failed; add the new bundle */
 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         /* we found the bundle in the list immediately */
 147 found_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         /* we found the bundle on the second time through the list */
 159 found_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  * release a bundle
 174  */
 175 void 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  * allocate a new connection
 197  */
 198 static 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  * assign a connection ID to a connection and add it to the transport's
 226  * connection lookup tree
 227  * - called with transport client lock held
 228  */
 229 static 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
 247 attempt_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         /* we've found a suitable hole - arrange for this connection to occupy
 268          * it */
 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         /* we found a connection with the proposed ID - walk the tree from that
 278          * point looking for the next unused ID */
 279 id_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  * add a call to a connection's call-by-ID tree
 301  */
 302 static 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  * connect a call on an exclusive connection
 334  */
 335 static 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                 /* not yet present - create a candidate for a new connection
 349                  * and then redo the check */
 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         /* we've got a connection with a free channel and we can now attach the
 393          * call to it
 394          * - we're holding the transport's client lock
 395          * - we're holding a reference on the connection
 396          */
 397         for (chan = 0; chan < RXRPC_MAXCALLS; chan++)
 398                 if (!conn->channels[chan])
 399                         goto found_channel;
 400         goto no_free_channels;
 401
 402 found_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
 419 no_free_channels:
 420         spin_unlock(&trans->client_lock);
 421         _leave(" = -ENOSR");
 422         return -ENOSR;
 423 }
 424
 425 /*
 426  * find a connection for a call
 427  * - called in process context with IRQs enabled
 428  */
 429 int 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                 /* see if the bundle has a call slot available */
 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                 /* need to allocate a new connection */
 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                 /* not yet present - create a candidate for a new connection and then
 526                  * redo the check */
 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                 /* leave the candidate lurking in zombie mode attached to the
 571                  * bundle until we're ready for it */
 572                 rxrpc_put_connection(candidate);
 573                 candidate = NULL;
 574         }
 575
 576         /* we've got a connection with a free channel and we can now attach the
 577          * call to it
 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
 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
 591 found_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
 609 interrupted_dequeue:
 610         remove_wait_queue(&bundle->chanwait, &myself);
 611         __set_current_state(TASK_RUNNING);
 612 interrupted:
 613         _leave(" = -ERESTARTSYS");
 614         return -ERESTARTSYS;
 615 }
 616
 617 /*
 618  * get a record of an incoming connection
 619  */
 620 struct rxrpc_connection *
 621 rxrpc_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         /* search the connection list first */
 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         /* not yet present - create a candidate for a new record and then
 660          * redo the search */
 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         /* we can now add the new candidate to the list */
 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
 713 success:
 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         /* we found the connection in the list immediately */
 720 found_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         /* we found the connection on the second time through the list */
 730 found_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
 740 security_mismatch:
 741         kfree(candidate);
 742         _leave(" = -EKEYREJECTED");
 743         return ERR_PTR(-EKEYREJECTED);
 744 }
 745
 746 /*
 747  * find a connection based on transport and RxRPC connection ID for an incoming
 748  * packet
 749  */
 750 struct 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
 790 found:
 791         atomic_inc(&conn->usage);
 792         read_unlock_bh(&trans->conn_lock);
 793         _leave(" = %p", conn);
 794         return conn;
 795 }
 796
 797 /*
 798  * release a virtual connection
 799  */
 800 void 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  * destroy a virtual connection
 818  */
 819 static 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  * reap dead connections
 844  */
 845 static 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         /* then destroy all those pulled out */
 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  * preemptively destroy all the connection records rather than waiting for them
 916  * to time out
 917  */
 918 void __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 }