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