kernel/net/rxrpc/ar-call.c

   1 /* RxRPC individual remote procedure call handling
   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/slab.h>
  13 #include <linux/module.h>
  14 #include <linux/circ_buf.h>
  15 #include <linux/hashtable.h>
  16 #include <linux/spinlock_types.h>
  17 #include <net/sock.h>
  18 #include <net/af_rxrpc.h>
  19 #include "ar-internal.h"
  20
  21 /*
  22  * Maximum lifetime of a call (in jiffies).
  23  */
  24 unsigned rxrpc_max_call_lifetime = 60 * HZ;
  25
  26 /*
  27  * Time till dead call expires after last use (in jiffies).
  28  */
  29 unsigned rxrpc_dead_call_expiry = 2 * HZ;
  30
  31 const char *const rxrpc_call_states[] = {
  32         [RXRPC_CALL_CLIENT_SEND_REQUEST]        = "ClSndReq",
  33         [RXRPC_CALL_CLIENT_AWAIT_REPLY]         = "ClAwtRpl",
  34         [RXRPC_CALL_CLIENT_RECV_REPLY]          = "ClRcvRpl",
  35         [RXRPC_CALL_CLIENT_FINAL_ACK]           = "ClFnlACK",
  36         [RXRPC_CALL_SERVER_SECURING]            = "SvSecure",
  37         [RXRPC_CALL_SERVER_ACCEPTING]           = "SvAccept",
  38         [RXRPC_CALL_SERVER_RECV_REQUEST]        = "SvRcvReq",
  39         [RXRPC_CALL_SERVER_ACK_REQUEST]         = "SvAckReq",
  40         [RXRPC_CALL_SERVER_SEND_REPLY]          = "SvSndRpl",
  41         [RXRPC_CALL_SERVER_AWAIT_ACK]           = "SvAwtACK",
  42         [RXRPC_CALL_COMPLETE]                   = "Complete",
  43         [RXRPC_CALL_SERVER_BUSY]                = "SvBusy  ",
  44         [RXRPC_CALL_REMOTELY_ABORTED]           = "RmtAbort",
  45         [RXRPC_CALL_LOCALLY_ABORTED]            = "LocAbort",
  46         [RXRPC_CALL_NETWORK_ERROR]              = "NetError",
  47         [RXRPC_CALL_DEAD]                       = "Dead    ",
  48 };
  49
  50 struct kmem_cache *rxrpc_call_jar;
  51 LIST_HEAD(rxrpc_calls);
  52 DEFINE_RWLOCK(rxrpc_call_lock);
  53
  54 static void rxrpc_destroy_call(struct work_struct *work);
  55 static void rxrpc_call_life_expired(unsigned long _call);
  56 static void rxrpc_dead_call_expired(unsigned long _call);
  57 static void rxrpc_ack_time_expired(unsigned long _call);
  58 static void rxrpc_resend_time_expired(unsigned long _call);
  59
  60 static DEFINE_SPINLOCK(rxrpc_call_hash_lock);
  61 static DEFINE_HASHTABLE(rxrpc_call_hash, 10);
  62
  63 /*
  64  * Hash function for rxrpc_call_hash
  65  */
  66 static unsigned long rxrpc_call_hashfunc(
  67         u8              clientflag,
  68         __be32          cid,
  69         __be32          call_id,
  70         __be32          epoch,
  71         __be16          service_id,
  72         sa_family_t     proto,
  73         void            *localptr,
  74         unsigned int    addr_size,
  75         const u8        *peer_addr)
  76 {
  77         const u16 *p;
  78         unsigned int i;
  79         unsigned long key;
  80         u32 hcid = ntohl(cid);
  81
  82         _enter("");
  83
  84         key = (unsigned long)localptr;
  85         /* We just want to add up the __be32 values, so forcing the
  86          * cast should be okay.
  87          */
  88         key += (__force u32)epoch;
  89         key += (__force u16)service_id;
  90         key += (__force u32)call_id;
  91         key += (hcid & RXRPC_CIDMASK) >> RXRPC_CIDSHIFT;
  92         key += hcid & RXRPC_CHANNELMASK;
  93         key += clientflag;
  94         key += proto;
  95         /* Step through the peer address in 16-bit portions for speed */
  96         for (i = 0, p = (const u16 *)peer_addr; i < addr_size >> 1; i++, p++)
  97                 key += *p;
  98         _leave(" key = 0x%lx", key);
  99         return key;
 100 }
 101
 102 /*
 103  * Add a call to the hashtable
 104  */
 105 static void rxrpc_call_hash_add(struct rxrpc_call *call)
 106 {
 107         unsigned long key;
 108         unsigned int addr_size = 0;
 109
 110         _enter("");
 111         switch (call->proto) {
 112         case AF_INET:
 113                 addr_size = sizeof(call->peer_ip.ipv4_addr);
 114                 break;
 115         case AF_INET6:
 116                 addr_size = sizeof(call->peer_ip.ipv6_addr);
 117                 break;
 118         default:
 119                 break;
 120         }
 121         key = rxrpc_call_hashfunc(call->in_clientflag, call->cid,
 122                                   call->call_id, call->epoch,
 123                                   call->service_id, call->proto,
 124                                   call->conn->trans->local, addr_size,
 125                                   call->peer_ip.ipv6_addr);
 126         /* Store the full key in the call */
 127         call->hash_key = key;
 128         spin_lock(&rxrpc_call_hash_lock);
 129         hash_add_rcu(rxrpc_call_hash, &call->hash_node, key);
 130         spin_unlock(&rxrpc_call_hash_lock);
 131         _leave("");
 132 }
 133
 134 /*
 135  * Remove a call from the hashtable
 136  */
 137 static void rxrpc_call_hash_del(struct rxrpc_call *call)
 138 {
 139         _enter("");
 140         spin_lock(&rxrpc_call_hash_lock);
 141         hash_del_rcu(&call->hash_node);
 142         spin_unlock(&rxrpc_call_hash_lock);
 143         _leave("");
 144 }
 145
 146 /*
 147  * Find a call in the hashtable and return it, or NULL if it
 148  * isn't there.
 149  */
 150 struct rxrpc_call *rxrpc_find_call_hash(
 151         u8              clientflag,
 152         __be32          cid,
 153         __be32          call_id,
 154         __be32          epoch,
 155         __be16          service_id,
 156         void            *localptr,
 157         sa_family_t     proto,
 158         const u8        *peer_addr)
 159 {
 160         unsigned long key;
 161         unsigned int addr_size = 0;
 162         struct rxrpc_call *call = NULL;
 163         struct rxrpc_call *ret = NULL;
 164
 165         _enter("");
 166         switch (proto) {
 167         case AF_INET:
 168                 addr_size = sizeof(call->peer_ip.ipv4_addr);
 169                 break;
 170         case AF_INET6:
 171                 addr_size = sizeof(call->peer_ip.ipv6_addr);
 172                 break;
 173         default:
 174                 break;
 175         }
 176
 177         key = rxrpc_call_hashfunc(clientflag, cid, call_id, epoch,
 178                                   service_id, proto, localptr, addr_size,
 179                                   peer_addr);
 180         hash_for_each_possible_rcu(rxrpc_call_hash, call, hash_node, key) {
 181                 if (call->hash_key == key &&
 182                     call->call_id == call_id &&
 183                     call->cid == cid &&
 184                     call->in_clientflag == clientflag &&
 185                     call->service_id == service_id &&
 186                     call->proto == proto &&
 187                     call->local == localptr &&
 188                     memcmp(call->peer_ip.ipv6_addr, peer_addr,
 189                               addr_size) == 0 &&
 190                     call->epoch == epoch) {
 191                         ret = call;
 192                         break;
 193                 }
 194         }
 195         _leave(" = %p", ret);
 196         return ret;
 197 }
 198
 199 /*
 200  * allocate a new call
 201  */
 202 static struct rxrpc_call *rxrpc_alloc_call(gfp_t gfp)
 203 {
 204         struct rxrpc_call *call;
 205
 206         call = kmem_cache_zalloc(rxrpc_call_jar, gfp);
 207         if (!call)
 208                 return NULL;
 209
 210         call->acks_winsz = 16;
 211         call->acks_window = kmalloc(call->acks_winsz * sizeof(unsigned long),
 212                                     gfp);
 213         if (!call->acks_window) {
 214                 kmem_cache_free(rxrpc_call_jar, call);
 215                 return NULL;
 216         }
 217
 218         setup_timer(&call->lifetimer, &rxrpc_call_life_expired,
 219                     (unsigned long) call);
 220         setup_timer(&call->deadspan, &rxrpc_dead_call_expired,
 221                     (unsigned long) call);
 222         setup_timer(&call->ack_timer, &rxrpc_ack_time_expired,
 223                     (unsigned long) call);
 224         setup_timer(&call->resend_timer, &rxrpc_resend_time_expired,
 225                     (unsigned long) call);
 226         INIT_WORK(&call->destroyer, &rxrpc_destroy_call);
 227         INIT_WORK(&call->processor, &rxrpc_process_call);
 228         INIT_LIST_HEAD(&call->accept_link);
 229         skb_queue_head_init(&call->rx_queue);
 230         skb_queue_head_init(&call->rx_oos_queue);
 231         init_waitqueue_head(&call->tx_waitq);
 232         spin_lock_init(&call->lock);
 233         rwlock_init(&call->state_lock);
 234         atomic_set(&call->usage, 1);
 235         call->debug_id = atomic_inc_return(&rxrpc_debug_id);
 236         call->state = RXRPC_CALL_CLIENT_SEND_REQUEST;
 237
 238         memset(&call->sock_node, 0xed, sizeof(call->sock_node));
 239
 240         call->rx_data_expect = 1;
 241         call->rx_data_eaten = 0;
 242         call->rx_first_oos = 0;
 243         call->ackr_win_top = call->rx_data_eaten + 1 + rxrpc_rx_window_size;
 244         call->creation_jif = jiffies;
 245         return call;
 246 }
 247
 248 /*
 249  * allocate a new client call and attempt to get a connection slot for it
 250  */
 251 static struct rxrpc_call *rxrpc_alloc_client_call(
 252         struct rxrpc_sock *rx,
 253         struct rxrpc_transport *trans,
 254         struct rxrpc_conn_bundle *bundle,
 255         gfp_t gfp)
 256 {
 257         struct rxrpc_call *call;
 258         int ret;
 259
 260         _enter("");
 261
 262         ASSERT(rx != NULL);
 263         ASSERT(trans != NULL);
 264         ASSERT(bundle != NULL);
 265
 266         call = rxrpc_alloc_call(gfp);
 267         if (!call)
 268                 return ERR_PTR(-ENOMEM);
 269
 270         sock_hold(&rx->sk);
 271         call->socket = rx;
 272         call->rx_data_post = 1;
 273
 274         ret = rxrpc_connect_call(rx, trans, bundle, call, gfp);
 275         if (ret < 0) {
 276                 kmem_cache_free(rxrpc_call_jar, call);
 277                 return ERR_PTR(ret);
 278         }
 279
 280         /* Record copies of information for hashtable lookup */
 281         call->proto = rx->proto;
 282         call->local = trans->local;
 283         switch (call->proto) {
 284         case AF_INET:
 285                 call->peer_ip.ipv4_addr =
 286                         trans->peer->srx.transport.sin.sin_addr.s_addr;
 287                 break;
 288         case AF_INET6:
 289                 memcpy(call->peer_ip.ipv6_addr,
 290                        trans->peer->srx.transport.sin6.sin6_addr.in6_u.u6_addr8,
 291                        sizeof(call->peer_ip.ipv6_addr));
 292                 break;
 293         }
 294         call->epoch = call->conn->epoch;
 295         call->service_id = call->conn->service_id;
 296         call->in_clientflag = call->conn->in_clientflag;
 297         /* Add the new call to the hashtable */
 298         rxrpc_call_hash_add(call);
 299
 300         spin_lock(&call->conn->trans->peer->lock);
 301         list_add(&call->error_link, &call->conn->trans->peer->error_targets);
 302         spin_unlock(&call->conn->trans->peer->lock);
 303
 304         call->lifetimer.expires = jiffies + rxrpc_max_call_lifetime;
 305         add_timer(&call->lifetimer);
 306
 307         _leave(" = %p", call);
 308         return call;
 309 }
 310
 311 /*
 312  * set up a call for the given data
 313  * - called in process context with IRQs enabled
 314  */
 315 struct rxrpc_call *rxrpc_get_client_call(struct rxrpc_sock *rx,
 316                                          struct rxrpc_transport *trans,
 317                                          struct rxrpc_conn_bundle *bundle,
 318                                          unsigned long user_call_ID,
 319                                          int create,
 320                                          gfp_t gfp)
 321 {
 322         struct rxrpc_call *call, *candidate;
 323         struct rb_node *p, *parent, **pp;
 324
 325         _enter("%p,%d,%d,%lx,%d",
 326                rx, trans ? trans->debug_id : -1, bundle ? bundle->debug_id : -1,
 327                user_call_ID, create);
 328
 329         /* search the extant calls first for one that matches the specified
 330          * user ID */
 331         read_lock(&rx->call_lock);
 332
 333         p = rx->calls.rb_node;
 334         while (p) {
 335                 call = rb_entry(p, struct rxrpc_call, sock_node);
 336
 337                 if (user_call_ID < call->user_call_ID)
 338                         p = p->rb_left;
 339                 else if (user_call_ID > call->user_call_ID)
 340                         p = p->rb_right;
 341                 else
 342                         goto found_extant_call;
 343         }
 344
 345         read_unlock(&rx->call_lock);
 346
 347         if (!create || !trans)
 348                 return ERR_PTR(-EBADSLT);
 349
 350         /* not yet present - create a candidate for a new record and then
 351          * redo the search */
 352         candidate = rxrpc_alloc_client_call(rx, trans, bundle, gfp);
 353         if (IS_ERR(candidate)) {
 354                 _leave(" = %ld", PTR_ERR(candidate));
 355                 return candidate;
 356         }
 357
 358         candidate->user_call_ID = user_call_ID;
 359         __set_bit(RXRPC_CALL_HAS_USERID, &candidate->flags);
 360
 361         write_lock(&rx->call_lock);
 362
 363         pp = &rx->calls.rb_node;
 364         parent = NULL;
 365         while (*pp) {
 366                 parent = *pp;
 367                 call = rb_entry(parent, struct rxrpc_call, sock_node);
 368
 369                 if (user_call_ID < call->user_call_ID)
 370                         pp = &(*pp)->rb_left;
 371                 else if (user_call_ID > call->user_call_ID)
 372                         pp = &(*pp)->rb_right;
 373                 else
 374                         goto found_extant_second;
 375         }
 376
 377         /* second search also failed; add the new call */
 378         call = candidate;
 379         candidate = NULL;
 380         rxrpc_get_call(call);
 381
 382         rb_link_node(&call->sock_node, parent, pp);
 383         rb_insert_color(&call->sock_node, &rx->calls);
 384         write_unlock(&rx->call_lock);
 385
 386         write_lock_bh(&rxrpc_call_lock);
 387         list_add_tail(&call->link, &rxrpc_calls);
 388         write_unlock_bh(&rxrpc_call_lock);
 389
 390         _net("CALL new %d on CONN %d", call->debug_id, call->conn->debug_id);
 391
 392         _leave(" = %p [new]", call);
 393         return call;
 394
 395         /* we found the call in the list immediately */
 396 found_extant_call:
 397         rxrpc_get_call(call);
 398         read_unlock(&rx->call_lock);
 399         _leave(" = %p [extant %d]", call, atomic_read(&call->usage));
 400         return call;
 401
 402         /* we found the call on the second time through the list */
 403 found_extant_second:
 404         rxrpc_get_call(call);
 405         write_unlock(&rx->call_lock);
 406         rxrpc_put_call(candidate);
 407         _leave(" = %p [second %d]", call, atomic_read(&call->usage));
 408         return call;
 409 }
 410
 411 /*
 412  * set up an incoming call
 413  * - called in process context with IRQs enabled
 414  */
 415 struct rxrpc_call *rxrpc_incoming_call(struct rxrpc_sock *rx,
 416                                        struct rxrpc_connection *conn,
 417                                        struct rxrpc_header *hdr,
 418                                        gfp_t gfp)
 419 {
 420         struct rxrpc_call *call, *candidate;
 421         struct rb_node **p, *parent;
 422         __be32 call_id;
 423
 424         _enter(",%d,,%x", conn->debug_id, gfp);
 425
 426         ASSERT(rx != NULL);
 427
 428         candidate = rxrpc_alloc_call(gfp);
 429         if (!candidate)
 430                 return ERR_PTR(-EBUSY);
 431
 432         candidate->socket = rx;
 433         candidate->conn = conn;
 434         candidate->cid = hdr->cid;
 435         candidate->call_id = hdr->callNumber;
 436         candidate->channel = ntohl(hdr->cid) & RXRPC_CHANNELMASK;
 437         candidate->rx_data_post = 0;
 438         candidate->state = RXRPC_CALL_SERVER_ACCEPTING;
 439         if (conn->security_ix > 0)
 440                 candidate->state = RXRPC_CALL_SERVER_SECURING;
 441
 442         write_lock_bh(&conn->lock);
 443
 444         /* set the channel for this call */
 445         call = conn->channels[candidate->channel];
 446         _debug("channel[%u] is %p", candidate->channel, call);
 447         if (call && call->call_id == hdr->callNumber) {
 448                 /* already set; must've been a duplicate packet */
 449                 _debug("extant call [%d]", call->state);
 450                 ASSERTCMP(call->conn, ==, conn);
 451
 452                 read_lock(&call->state_lock);
 453                 switch (call->state) {
 454                 case RXRPC_CALL_LOCALLY_ABORTED:
 455                         if (!test_and_set_bit(RXRPC_CALL_ABORT, &call->events))
 456                                 rxrpc_queue_call(call);
 457                 case RXRPC_CALL_REMOTELY_ABORTED:
 458                         read_unlock(&call->state_lock);
 459                         goto aborted_call;
 460                 default:
 461                         rxrpc_get_call(call);
 462                         read_unlock(&call->state_lock);
 463                         goto extant_call;
 464                 }
 465         }
 466
 467         if (call) {
 468                 /* it seems the channel is still in use from the previous call
 469                  * - ditch the old binding if its call is now complete */
 470                 _debug("CALL: %u { %s }",
 471                        call->debug_id, rxrpc_call_states[call->state]);
 472
 473                 if (call->state >= RXRPC_CALL_COMPLETE) {
 474                         conn->channels[call->channel] = NULL;
 475                 } else {
 476                         write_unlock_bh(&conn->lock);
 477                         kmem_cache_free(rxrpc_call_jar, candidate);
 478                         _leave(" = -EBUSY");
 479                         return ERR_PTR(-EBUSY);
 480                 }
 481         }
 482
 483         /* check the call number isn't duplicate */
 484         _debug("check dup");
 485         call_id = hdr->callNumber;
 486         p = &conn->calls.rb_node;
 487         parent = NULL;
 488         while (*p) {
 489                 parent = *p;
 490                 call = rb_entry(parent, struct rxrpc_call, conn_node);
 491
 492                 /* The tree is sorted in order of the __be32 value without
 493                  * turning it into host order.
 494                  */
 495                 if ((__force u32)call_id < (__force u32)call->call_id)
 496                         p = &(*p)->rb_left;
 497                 else if ((__force u32)call_id > (__force u32)call->call_id)
 498                         p = &(*p)->rb_right;
 499                 else
 500                         goto old_call;
 501         }
 502
 503         /* make the call available */
 504         _debug("new call");
 505         call = candidate;
 506         candidate = NULL;
 507         rb_link_node(&call->conn_node, parent, p);
 508         rb_insert_color(&call->conn_node, &conn->calls);
 509         conn->channels[call->channel] = call;
 510         sock_hold(&rx->sk);
 511         atomic_inc(&conn->usage);
 512         write_unlock_bh(&conn->lock);
 513
 514         spin_lock(&conn->trans->peer->lock);
 515         list_add(&call->error_link, &conn->trans->peer->error_targets);
 516         spin_unlock(&conn->trans->peer->lock);
 517
 518         write_lock_bh(&rxrpc_call_lock);
 519         list_add_tail(&call->link, &rxrpc_calls);
 520         write_unlock_bh(&rxrpc_call_lock);
 521
 522         /* Record copies of information for hashtable lookup */
 523         call->proto = rx->proto;
 524         call->local = conn->trans->local;
 525         switch (call->proto) {
 526         case AF_INET:
 527                 call->peer_ip.ipv4_addr =
 528                         conn->trans->peer->srx.transport.sin.sin_addr.s_addr;
 529                 break;
 530         case AF_INET6:
 531                 memcpy(call->peer_ip.ipv6_addr,
 532                        conn->trans->peer->srx.transport.sin6.sin6_addr.in6_u.u6_addr8,
 533                        sizeof(call->peer_ip.ipv6_addr));
 534                 break;
 535         default:
 536                 break;
 537         }
 538         call->epoch = conn->epoch;
 539         call->service_id = conn->service_id;
 540         call->in_clientflag = conn->in_clientflag;
 541         /* Add the new call to the hashtable */
 542         rxrpc_call_hash_add(call);
 543
 544         _net("CALL incoming %d on CONN %d", call->debug_id, call->conn->debug_id);
 545
 546         call->lifetimer.expires = jiffies + rxrpc_max_call_lifetime;
 547         add_timer(&call->lifetimer);
 548         _leave(" = %p {%d} [new]", call, call->debug_id);
 549         return call;
 550
 551 extant_call:
 552         write_unlock_bh(&conn->lock);
 553         kmem_cache_free(rxrpc_call_jar, candidate);
 554         _leave(" = %p {%d} [extant]", call, call ? call->debug_id : -1);
 555         return call;
 556
 557 aborted_call:
 558         write_unlock_bh(&conn->lock);
 559         kmem_cache_free(rxrpc_call_jar, candidate);
 560         _leave(" = -ECONNABORTED");
 561         return ERR_PTR(-ECONNABORTED);
 562
 563 old_call:
 564         write_unlock_bh(&conn->lock);
 565         kmem_cache_free(rxrpc_call_jar, candidate);
 566         _leave(" = -ECONNRESET [old]");
 567         return ERR_PTR(-ECONNRESET);
 568 }
 569
 570 /*
 571  * find an extant server call
 572  * - called in process context with IRQs enabled
 573  */
 574 struct rxrpc_call *rxrpc_find_server_call(struct rxrpc_sock *rx,
 575                                           unsigned long user_call_ID)
 576 {
 577         struct rxrpc_call *call;
 578         struct rb_node *p;
 579
 580         _enter("%p,%lx", rx, user_call_ID);
 581
 582         /* search the extant calls for one that matches the specified user
 583          * ID */
 584         read_lock(&rx->call_lock);
 585
 586         p = rx->calls.rb_node;
 587         while (p) {
 588                 call = rb_entry(p, struct rxrpc_call, sock_node);
 589
 590                 if (user_call_ID < call->user_call_ID)
 591                         p = p->rb_left;
 592                 else if (user_call_ID > call->user_call_ID)
 593                         p = p->rb_right;
 594                 else
 595                         goto found_extant_call;
 596         }
 597
 598         read_unlock(&rx->call_lock);
 599         _leave(" = NULL");
 600         return NULL;
 601
 602         /* we found the call in the list immediately */
 603 found_extant_call:
 604         rxrpc_get_call(call);
 605         read_unlock(&rx->call_lock);
 606         _leave(" = %p [%d]", call, atomic_read(&call->usage));
 607         return call;
 608 }
 609
 610 /*
 611  * detach a call from a socket and set up for release
 612  */
 613 void rxrpc_release_call(struct rxrpc_call *call)
 614 {
 615         struct rxrpc_connection *conn = call->conn;
 616         struct rxrpc_sock *rx = call->socket;
 617
 618         _enter("{%d,%d,%d,%d}",
 619                call->debug_id, atomic_read(&call->usage),
 620                atomic_read(&call->ackr_not_idle),
 621                call->rx_first_oos);
 622
 623         spin_lock_bh(&call->lock);
 624         if (test_and_set_bit(RXRPC_CALL_RELEASED, &call->flags))
 625                 BUG();
 626         spin_unlock_bh(&call->lock);
 627
 628         /* dissociate from the socket
 629          * - the socket's ref on the call is passed to the death timer
 630          */
 631         _debug("RELEASE CALL %p (%d CONN %p)", call, call->debug_id, conn);
 632
 633         write_lock_bh(&rx->call_lock);
 634         if (!list_empty(&call->accept_link)) {
 635                 _debug("unlinking once-pending call %p { e=%lx f=%lx }",
 636                        call, call->events, call->flags);
 637                 ASSERT(!test_bit(RXRPC_CALL_HAS_USERID, &call->flags));
 638                 list_del_init(&call->accept_link);
 639                 sk_acceptq_removed(&rx->sk);
 640         } else if (test_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
 641                 rb_erase(&call->sock_node, &rx->calls);
 642                 memset(&call->sock_node, 0xdd, sizeof(call->sock_node));
 643                 clear_bit(RXRPC_CALL_HAS_USERID, &call->flags);
 644         }
 645         write_unlock_bh(&rx->call_lock);
 646
 647         /* free up the channel for reuse */
 648         spin_lock(&conn->trans->client_lock);
 649         write_lock_bh(&conn->lock);
 650         write_lock(&call->state_lock);
 651
 652         if (conn->channels[call->channel] == call)
 653                 conn->channels[call->channel] = NULL;
 654
 655         if (conn->out_clientflag && conn->bundle) {
 656                 conn->avail_calls++;
 657                 switch (conn->avail_calls) {
 658                 case 1:
 659                         list_move_tail(&conn->bundle_link,
 660                                        &conn->bundle->avail_conns);
 661                 case 2 ... RXRPC_MAXCALLS - 1:
 662                         ASSERT(conn->channels[0] == NULL ||
 663                                conn->channels[1] == NULL ||
 664                                conn->channels[2] == NULL ||
 665                                conn->channels[3] == NULL);
 666                         break;
 667                 case RXRPC_MAXCALLS:
 668                         list_move_tail(&conn->bundle_link,
 669                                        &conn->bundle->unused_conns);
 670                         ASSERT(conn->channels[0] == NULL &&
 671                                conn->channels[1] == NULL &&
 672                                conn->channels[2] == NULL &&
 673                                conn->channels[3] == NULL);
 674                         break;
 675                 default:
 676                         printk(KERN_ERR "RxRPC: conn->avail_calls=%d\n",
 677                                conn->avail_calls);
 678                         BUG();
 679                 }
 680         }
 681
 682         spin_unlock(&conn->trans->client_lock);
 683
 684         if (call->state < RXRPC_CALL_COMPLETE &&
 685             call->state != RXRPC_CALL_CLIENT_FINAL_ACK) {
 686                 _debug("+++ ABORTING STATE %d +++\n", call->state);
 687                 call->state = RXRPC_CALL_LOCALLY_ABORTED;
 688                 call->abort_code = RX_CALL_DEAD;
 689                 set_bit(RXRPC_CALL_ABORT, &call->events);
 690                 rxrpc_queue_call(call);
 691         }
 692         write_unlock(&call->state_lock);
 693         write_unlock_bh(&conn->lock);
 694
 695         /* clean up the Rx queue */
 696         if (!skb_queue_empty(&call->rx_queue) ||
 697             !skb_queue_empty(&call->rx_oos_queue)) {
 698                 struct rxrpc_skb_priv *sp;
 699                 struct sk_buff *skb;
 700
 701                 _debug("purge Rx queues");
 702
 703                 spin_lock_bh(&call->lock);
 704                 while ((skb = skb_dequeue(&call->rx_queue)) ||
 705                        (skb = skb_dequeue(&call->rx_oos_queue))) {
 706                         sp = rxrpc_skb(skb);
 707                         if (sp->call) {
 708                                 ASSERTCMP(sp->call, ==, call);
 709                                 rxrpc_put_call(call);
 710                                 sp->call = NULL;
 711                         }
 712                         skb->destructor = NULL;
 713                         spin_unlock_bh(&call->lock);
 714
 715                         _debug("- zap %s %%%u #%u",
 716                                rxrpc_pkts[sp->hdr.type],
 717                                ntohl(sp->hdr.serial),
 718                                ntohl(sp->hdr.seq));
 719                         rxrpc_free_skb(skb);
 720                         spin_lock_bh(&call->lock);
 721                 }
 722                 spin_unlock_bh(&call->lock);
 723
 724                 ASSERTCMP(call->state, !=, RXRPC_CALL_COMPLETE);
 725         }
 726
 727         del_timer_sync(&call->resend_timer);
 728         del_timer_sync(&call->ack_timer);
 729         del_timer_sync(&call->lifetimer);
 730         call->deadspan.expires = jiffies + rxrpc_dead_call_expiry;
 731         add_timer(&call->deadspan);
 732
 733         _leave("");
 734 }
 735
 736 /*
 737  * handle a dead call being ready for reaping
 738  */
 739 static void rxrpc_dead_call_expired(unsigned long _call)
 740 {
 741         struct rxrpc_call *call = (struct rxrpc_call *) _call;
 742
 743         _enter("{%d}", call->debug_id);
 744
 745         write_lock_bh(&call->state_lock);
 746         call->state = RXRPC_CALL_DEAD;
 747         write_unlock_bh(&call->state_lock);
 748         rxrpc_put_call(call);
 749 }
 750
 751 /*
 752  * mark a call as to be released, aborting it if it's still in progress
 753  * - called with softirqs disabled
 754  */
 755 static void rxrpc_mark_call_released(struct rxrpc_call *call)
 756 {
 757         bool sched;
 758
 759         write_lock(&call->state_lock);
 760         if (call->state < RXRPC_CALL_DEAD) {
 761                 sched = false;
 762                 if (call->state < RXRPC_CALL_COMPLETE) {
 763                         _debug("abort call %p", call);
 764                         call->state = RXRPC_CALL_LOCALLY_ABORTED;
 765                         call->abort_code = RX_CALL_DEAD;
 766                         if (!test_and_set_bit(RXRPC_CALL_ABORT, &call->events))
 767                                 sched = true;
 768                 }
 769                 if (!test_and_set_bit(RXRPC_CALL_RELEASE, &call->events))
 770                         sched = true;
 771                 if (sched)
 772                         rxrpc_queue_call(call);
 773         }
 774         write_unlock(&call->state_lock);
 775 }
 776
 777 /*
 778  * release all the calls associated with a socket
 779  */
 780 void rxrpc_release_calls_on_socket(struct rxrpc_sock *rx)
 781 {
 782         struct rxrpc_call *call;
 783         struct rb_node *p;
 784
 785         _enter("%p", rx);
 786
 787         read_lock_bh(&rx->call_lock);
 788
 789         /* mark all the calls as no longer wanting incoming packets */
 790         for (p = rb_first(&rx->calls); p; p = rb_next(p)) {
 791                 call = rb_entry(p, struct rxrpc_call, sock_node);
 792                 rxrpc_mark_call_released(call);
 793         }
 794
 795         /* kill the not-yet-accepted incoming calls */
 796         list_for_each_entry(call, &rx->secureq, accept_link) {
 797                 rxrpc_mark_call_released(call);
 798         }
 799
 800         list_for_each_entry(call, &rx->acceptq, accept_link) {
 801                 rxrpc_mark_call_released(call);
 802         }
 803
 804         read_unlock_bh(&rx->call_lock);
 805         _leave("");
 806 }
 807
 808 /*
 809  * release a call
 810  */
 811 void __rxrpc_put_call(struct rxrpc_call *call)
 812 {
 813         ASSERT(call != NULL);
 814
 815         _enter("%p{u=%d}", call, atomic_read(&call->usage));
 816
 817         ASSERTCMP(atomic_read(&call->usage), >, 0);
 818
 819         if (atomic_dec_and_test(&call->usage)) {
 820                 _debug("call %d dead", call->debug_id);
 821                 ASSERTCMP(call->state, ==, RXRPC_CALL_DEAD);
 822                 rxrpc_queue_work(&call->destroyer);
 823         }
 824         _leave("");
 825 }
 826
 827 /*
 828  * clean up a call
 829  */
 830 static void rxrpc_cleanup_call(struct rxrpc_call *call)
 831 {
 832         _net("DESTROY CALL %d", call->debug_id);
 833
 834         ASSERT(call->socket);
 835
 836         memset(&call->sock_node, 0xcd, sizeof(call->sock_node));
 837
 838         del_timer_sync(&call->lifetimer);
 839         del_timer_sync(&call->deadspan);
 840         del_timer_sync(&call->ack_timer);
 841         del_timer_sync(&call->resend_timer);
 842
 843         ASSERT(test_bit(RXRPC_CALL_RELEASED, &call->flags));
 844         ASSERTCMP(call->events, ==, 0);
 845         if (work_pending(&call->processor)) {
 846                 _debug("defer destroy");
 847                 rxrpc_queue_work(&call->destroyer);
 848                 return;
 849         }
 850
 851         if (call->conn) {
 852                 spin_lock(&call->conn->trans->peer->lock);
 853                 list_del(&call->error_link);
 854                 spin_unlock(&call->conn->trans->peer->lock);
 855
 856                 write_lock_bh(&call->conn->lock);
 857                 rb_erase(&call->conn_node, &call->conn->calls);
 858                 write_unlock_bh(&call->conn->lock);
 859                 rxrpc_put_connection(call->conn);
 860         }
 861
 862         /* Remove the call from the hash */
 863         rxrpc_call_hash_del(call);
 864
 865         if (call->acks_window) {
 866                 _debug("kill Tx window %d",
 867                        CIRC_CNT(call->acks_head, call->acks_tail,
 868                                 call->acks_winsz));
 869                 smp_mb();
 870                 while (CIRC_CNT(call->acks_head, call->acks_tail,
 871                                 call->acks_winsz) > 0) {
 872                         struct rxrpc_skb_priv *sp;
 873                         unsigned long _skb;
 874
 875                         _skb = call->acks_window[call->acks_tail] & ~1;
 876                         sp = rxrpc_skb((struct sk_buff *) _skb);
 877                         _debug("+++ clear Tx %u", ntohl(sp->hdr.seq));
 878                         rxrpc_free_skb((struct sk_buff *) _skb);
 879                         call->acks_tail =
 880                                 (call->acks_tail + 1) & (call->acks_winsz - 1);
 881                 }
 882
 883                 kfree(call->acks_window);
 884         }
 885
 886         rxrpc_free_skb(call->tx_pending);
 887
 888         rxrpc_purge_queue(&call->rx_queue);
 889         ASSERT(skb_queue_empty(&call->rx_oos_queue));
 890         sock_put(&call->socket->sk);
 891         kmem_cache_free(rxrpc_call_jar, call);
 892 }
 893
 894 /*
 895  * destroy a call
 896  */
 897 static void rxrpc_destroy_call(struct work_struct *work)
 898 {
 899         struct rxrpc_call *call =
 900                 container_of(work, struct rxrpc_call, destroyer);
 901
 902         _enter("%p{%d,%d,%p}",
 903                call, atomic_read(&call->usage), call->channel, call->conn);
 904
 905         ASSERTCMP(call->state, ==, RXRPC_CALL_DEAD);
 906
 907         write_lock_bh(&rxrpc_call_lock);
 908         list_del_init(&call->link);
 909         write_unlock_bh(&rxrpc_call_lock);
 910
 911         rxrpc_cleanup_call(call);
 912         _leave("");
 913 }
 914
 915 /*
 916  * preemptively destroy all the call records from a transport endpoint rather
 917  * than waiting for them to time out
 918  */
 919 void __exit rxrpc_destroy_all_calls(void)
 920 {
 921         struct rxrpc_call *call;
 922
 923         _enter("");
 924         write_lock_bh(&rxrpc_call_lock);
 925
 926         while (!list_empty(&rxrpc_calls)) {
 927                 call = list_entry(rxrpc_calls.next, struct rxrpc_call, link);
 928                 _debug("Zapping call %p", call);
 929
 930                 list_del_init(&call->link);
 931
 932                 switch (atomic_read(&call->usage)) {
 933                 case 0:
 934                         ASSERTCMP(call->state, ==, RXRPC_CALL_DEAD);
 935                         break;
 936                 case 1:
 937                         if (del_timer_sync(&call->deadspan) != 0 &&
 938                             call->state != RXRPC_CALL_DEAD)
 939                                 rxrpc_dead_call_expired((unsigned long) call);
 940                         if (call->state != RXRPC_CALL_DEAD)
 941                                 break;
 942                 default:
 943                         printk(KERN_ERR "RXRPC:"
 944                                " Call %p still in use (%d,%d,%s,%lx,%lx)!\n",
 945                                call, atomic_read(&call->usage),
 946                                atomic_read(&call->ackr_not_idle),
 947                                rxrpc_call_states[call->state],
 948                                call->flags, call->events);
 949                         if (!skb_queue_empty(&call->rx_queue))
 950                                 printk(KERN_ERR"RXRPC: Rx queue occupied\n");
 951                         if (!skb_queue_empty(&call->rx_oos_queue))
 952                                 printk(KERN_ERR"RXRPC: OOS queue occupied\n");
 953                         break;
 954                 }
 955
 956                 write_unlock_bh(&rxrpc_call_lock);
 957                 cond_resched();
 958                 write_lock_bh(&rxrpc_call_lock);
 959         }
 960
 961         write_unlock_bh(&rxrpc_call_lock);
 962         _leave("");
 963 }
 964
 965 /*
 966  * handle call lifetime being exceeded
 967  */
 968 static void rxrpc_call_life_expired(unsigned long _call)
 969 {
 970         struct rxrpc_call *call = (struct rxrpc_call *) _call;
 971
 972         if (call->state >= RXRPC_CALL_COMPLETE)
 973                 return;
 974
 975         _enter("{%d}", call->debug_id);
 976         read_lock_bh(&call->state_lock);
 977         if (call->state < RXRPC_CALL_COMPLETE) {
 978                 set_bit(RXRPC_CALL_LIFE_TIMER, &call->events);
 979                 rxrpc_queue_call(call);
 980         }
 981         read_unlock_bh(&call->state_lock);
 982 }
 983
 984 /*
 985  * handle resend timer expiry
 986  * - may not take call->state_lock as this can deadlock against del_timer_sync()
 987  */
 988 static void rxrpc_resend_time_expired(unsigned long _call)
 989 {
 990         struct rxrpc_call *call = (struct rxrpc_call *) _call;
 991
 992         _enter("{%d}", call->debug_id);
 993
 994         if (call->state >= RXRPC_CALL_COMPLETE)
 995                 return;
 996
 997         clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);
 998         if (!test_and_set_bit(RXRPC_CALL_RESEND_TIMER, &call->events))
 999                 rxrpc_queue_call(call);
1000 }
1001
1002 /*
1003  * handle ACK timer expiry
1004  */
1005 static void rxrpc_ack_time_expired(unsigned long _call)
1006 {
1007         struct rxrpc_call *call = (struct rxrpc_call *) _call;
1008
1009         _enter("{%d}", call->debug_id);
1010
1011         if (call->state >= RXRPC_CALL_COMPLETE)
1012                 return;
1013
1014         read_lock_bh(&call->state_lock);
1015         if (call->state < RXRPC_CALL_COMPLETE &&
1016             !test_and_set_bit(RXRPC_CALL_ACK, &call->events))
1017                 rxrpc_queue_call(call);
1018         read_unlock_bh(&call->state_lock);
1019 }