net/rxrpc/connection.c

   1 /* connection.c: Rx connection routines
   2  *
   3  * Copyright (C) 2002 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/sched.h>
  13 #include <linux/slab.h>
  14 #include <linux/module.h>
  15 #include <rxrpc/rxrpc.h>
  16 #include <rxrpc/transport.h>
  17 #include <rxrpc/peer.h>
  18 #include <rxrpc/connection.h>
  19 #include <rxrpc/call.h>
  20 #include <rxrpc/message.h>
  21 #include <linux/udp.h>
  22 #include <linux/ip.h>
  23 #include <net/sock.h>
  24 #include <asm/uaccess.h>
  25 #include "internal.h"
  26
  27 __RXACCT_DECL(atomic_t rxrpc_connection_count);
  28
  29 LIST_HEAD(rxrpc_conns);
  30 DECLARE_RWSEM(rxrpc_conns_sem);
  31 unsigned long rxrpc_conn_timeout = 60 * 60;
  32
  33 static void __rxrpc_conn_timeout(rxrpc_timer_t *timer)
  34 {
  35         struct rxrpc_connection *conn =
  36                 list_entry(timer, struct rxrpc_connection, timeout);
  37
  38         _debug("Rx CONN TIMEOUT [%p{u=%d}]", conn, atomic_read(&conn->usage));
  39
  40         rxrpc_conn_do_timeout(conn);
  41 }
  42
  43 static const struct rxrpc_timer_ops rxrpc_conn_timer_ops = {
  44         .timed_out      = __rxrpc_conn_timeout,
  45 };
  46
  47 /*****************************************************************************/
  48 /*
  49  * create a new connection record
  50  */
  51 static inline int __rxrpc_create_connection(struct rxrpc_peer *peer,
  52                                             struct rxrpc_connection **_conn)
  53 {
  54         struct rxrpc_connection *conn;
  55
  56         _enter("%p",peer);
  57
  58         /* allocate and initialise a connection record */
  59         conn = kmalloc(sizeof(struct rxrpc_connection), GFP_KERNEL);
  60         if (!conn) {
  61                 _leave(" = -ENOMEM");
  62                 return -ENOMEM;
  63         }
  64
  65         memset(conn, 0, sizeof(struct rxrpc_connection));
  66         atomic_set(&conn->usage, 1);
  67
  68         INIT_LIST_HEAD(&conn->link);
  69         INIT_LIST_HEAD(&conn->id_link);
  70         init_waitqueue_head(&conn->chanwait);
  71         spin_lock_init(&conn->lock);
  72         rxrpc_timer_init(&conn->timeout, &rxrpc_conn_timer_ops);
  73
  74         do_gettimeofday(&conn->atime);
  75         conn->mtu_size = 1024;
  76         conn->peer = peer;
  77         conn->trans = peer->trans;
  78
  79         __RXACCT(atomic_inc(&rxrpc_connection_count));
  80         *_conn = conn;
  81         _leave(" = 0 (%p)", conn);
  82
  83         return 0;
  84 } /* end __rxrpc_create_connection() */
  85
  86 /*****************************************************************************/
  87 /*
  88  * create a new connection record for outgoing connections
  89  */
  90 int rxrpc_create_connection(struct rxrpc_transport *trans,
  91                             __be16 port,
  92                             __be32 addr,
  93                             uint16_t service_id,
  94                             void *security,
  95                             struct rxrpc_connection **_conn)
  96 {
  97         struct rxrpc_connection *candidate, *conn;
  98         struct rxrpc_peer *peer;
  99         struct list_head *_p;
 100         __be32 connid;
 101         int ret;
 102
 103         _enter("%p{%hu},%u,%hu", trans, trans->port, ntohs(port), service_id);
 104
 105         /* get a peer record */
 106         ret = rxrpc_peer_lookup(trans, addr, &peer);
 107         if (ret < 0) {
 108                 _leave(" = %d", ret);
 109                 return ret;
 110         }
 111
 112         /* allocate and initialise a connection record */
 113         ret = __rxrpc_create_connection(peer, &candidate);
 114         if (ret < 0) {
 115                 rxrpc_put_peer(peer);
 116                 _leave(" = %d", ret);
 117                 return ret;
 118         }
 119
 120         /* fill in the specific bits */
 121         candidate->addr.sin_family      = AF_INET;
 122         candidate->addr.sin_port        = port;
 123         candidate->addr.sin_addr.s_addr = addr;
 124
 125         candidate->in_epoch             = rxrpc_epoch;
 126         candidate->out_epoch            = rxrpc_epoch;
 127         candidate->in_clientflag        = 0;
 128         candidate->out_clientflag       = RXRPC_CLIENT_INITIATED;
 129         candidate->service_id           = htons(service_id);
 130
 131         /* invent a unique connection ID */
 132         write_lock(&peer->conn_idlock);
 133
 134  try_next_id:
 135         connid = htonl(peer->conn_idcounter & RXRPC_CIDMASK);
 136         peer->conn_idcounter += RXRPC_MAXCALLS;
 137
 138         list_for_each(_p, &peer->conn_idlist) {
 139                 conn = list_entry(_p, struct rxrpc_connection, id_link);
 140                 if (connid == conn->conn_id)
 141                         goto try_next_id;
 142                 if (connid > conn->conn_id)
 143                         break;
 144         }
 145
 146         _debug("selected candidate conn ID %x.%u",
 147                ntohl(peer->addr.s_addr), ntohl(connid));
 148
 149         candidate->conn_id = connid;
 150         list_add_tail(&candidate->id_link, _p);
 151
 152         write_unlock(&peer->conn_idlock);
 153
 154         /* attach to peer */
 155         candidate->peer = peer;
 156
 157         write_lock(&peer->conn_lock);
 158
 159         /* search the peer's transport graveyard list */
 160         spin_lock(&peer->conn_gylock);
 161         list_for_each(_p, &peer->conn_graveyard) {
 162                 conn = list_entry(_p, struct rxrpc_connection, link);
 163                 if (conn->addr.sin_port == candidate->addr.sin_port     &&
 164                     conn->security_ix   == candidate->security_ix       &&
 165                     conn->service_id    == candidate->service_id        &&
 166                     conn->in_clientflag == 0)
 167                         goto found_in_graveyard;
 168         }
 169         spin_unlock(&peer->conn_gylock);
 170
 171         /* pick the new candidate */
 172         _debug("created connection: {%08x} [out]", ntohl(candidate->conn_id));
 173         atomic_inc(&peer->conn_count);
 174         conn = candidate;
 175         candidate = NULL;
 176
 177  make_active:
 178         list_add_tail(&conn->link, &peer->conn_active);
 179         write_unlock(&peer->conn_lock);
 180
 181         if (candidate) {
 182                 write_lock(&peer->conn_idlock);
 183                 list_del(&candidate->id_link);
 184                 write_unlock(&peer->conn_idlock);
 185
 186                 __RXACCT(atomic_dec(&rxrpc_connection_count));
 187                 kfree(candidate);
 188         }
 189         else {
 190                 down_write(&rxrpc_conns_sem);
 191                 list_add_tail(&conn->proc_link, &rxrpc_conns);
 192                 up_write(&rxrpc_conns_sem);
 193         }
 194
 195         *_conn = conn;
 196         _leave(" = 0 (%p)", conn);
 197
 198         return 0;
 199
 200         /* handle resurrecting a connection from the graveyard */
 201  found_in_graveyard:
 202         _debug("resurrecting connection: {%08x} [out]", ntohl(conn->conn_id));
 203         rxrpc_get_connection(conn);
 204         rxrpc_krxtimod_del_timer(&conn->timeout);
 205         list_del_init(&conn->link);
 206         spin_unlock(&peer->conn_gylock);
 207         goto make_active;
 208 } /* end rxrpc_create_connection() */
 209
 210 /*****************************************************************************/
 211 /*
 212  * lookup the connection for an incoming packet
 213  * - create a new connection record for unrecorded incoming connections
 214  */
 215 int rxrpc_connection_lookup(struct rxrpc_peer *peer,
 216                             struct rxrpc_message *msg,
 217                             struct rxrpc_connection **_conn)
 218 {
 219         struct rxrpc_connection *conn, *candidate = NULL;
 220         struct list_head *_p;
 221         int ret, fresh = 0;
 222         __be32 x_epoch, x_connid;
 223         __be16 x_port, x_servid;
 224         __u32 x_secix;
 225         u8 x_clflag;
 226
 227         _enter("%p{{%hu}},%u,%hu",
 228                peer,
 229                peer->trans->port,
 230                ntohs(msg->pkt->h.uh->source),
 231                ntohs(msg->hdr.serviceId));
 232
 233         x_port          = msg->pkt->h.uh->source;
 234         x_epoch         = msg->hdr.epoch;
 235         x_clflag        = msg->hdr.flags & RXRPC_CLIENT_INITIATED;
 236         x_connid        = htonl(ntohl(msg->hdr.cid) & RXRPC_CIDMASK);
 237         x_servid        = msg->hdr.serviceId;
 238         x_secix         = msg->hdr.securityIndex;
 239
 240         /* [common case] search the transport's active list first */
 241         read_lock(&peer->conn_lock);
 242         list_for_each(_p, &peer->conn_active) {
 243                 conn = list_entry(_p, struct rxrpc_connection, link);
 244                 if (conn->addr.sin_port         == x_port       &&
 245                     conn->in_epoch              == x_epoch      &&
 246                     conn->conn_id               == x_connid     &&
 247                     conn->security_ix           == x_secix      &&
 248                     conn->service_id            == x_servid     &&
 249                     conn->in_clientflag         == x_clflag)
 250                         goto found_active;
 251         }
 252         read_unlock(&peer->conn_lock);
 253
 254         /* [uncommon case] not active
 255          * - create a candidate for a new record if an inbound connection
 256          * - only examine the graveyard for an outbound connection
 257          */
 258         if (x_clflag) {
 259                 ret = __rxrpc_create_connection(peer, &candidate);
 260                 if (ret < 0) {
 261                         _leave(" = %d", ret);
 262                         return ret;
 263                 }
 264
 265                 /* fill in the specifics */
 266                 candidate->addr.sin_family      = AF_INET;
 267                 candidate->addr.sin_port        = x_port;
 268                 candidate->addr.sin_addr.s_addr = msg->pkt->nh.iph->saddr;
 269                 candidate->in_epoch             = x_epoch;
 270                 candidate->out_epoch            = x_epoch;
 271                 candidate->in_clientflag        = RXRPC_CLIENT_INITIATED;
 272                 candidate->out_clientflag       = 0;
 273                 candidate->conn_id              = x_connid;
 274                 candidate->service_id           = x_servid;
 275                 candidate->security_ix          = x_secix;
 276         }
 277
 278         /* search the active list again, just in case it appeared whilst we
 279          * were busy */
 280         write_lock(&peer->conn_lock);
 281         list_for_each(_p, &peer->conn_active) {
 282                 conn = list_entry(_p, struct rxrpc_connection, link);
 283                 if (conn->addr.sin_port         == x_port       &&
 284                     conn->in_epoch              == x_epoch      &&
 285                     conn->conn_id               == x_connid     &&
 286                     conn->security_ix           == x_secix      &&
 287                     conn->service_id            == x_servid     &&
 288                     conn->in_clientflag         == x_clflag)
 289                         goto found_active_second_chance;
 290         }
 291
 292         /* search the transport's graveyard list */
 293         spin_lock(&peer->conn_gylock);
 294         list_for_each(_p, &peer->conn_graveyard) {
 295                 conn = list_entry(_p, struct rxrpc_connection, link);
 296                 if (conn->addr.sin_port         == x_port       &&
 297                     conn->in_epoch              == x_epoch      &&
 298                     conn->conn_id               == x_connid     &&
 299                     conn->security_ix           == x_secix      &&
 300                     conn->service_id            == x_servid     &&
 301                     conn->in_clientflag         == x_clflag)
 302                         goto found_in_graveyard;
 303         }
 304         spin_unlock(&peer->conn_gylock);
 305
 306         /* outbound connections aren't created here */
 307         if (!x_clflag) {
 308                 write_unlock(&peer->conn_lock);
 309                 _leave(" = -ENOENT");
 310                 return -ENOENT;
 311         }
 312
 313         /* we can now add the new candidate to the list */
 314         _debug("created connection: {%08x} [in]", ntohl(candidate->conn_id));
 315         rxrpc_get_peer(peer);
 316         conn = candidate;
 317         candidate = NULL;
 318         atomic_inc(&peer->conn_count);
 319         fresh = 1;
 320
 321  make_active:
 322         list_add_tail(&conn->link, &peer->conn_active);
 323
 324  success_uwfree:
 325         write_unlock(&peer->conn_lock);
 326
 327         if (candidate) {
 328                 write_lock(&peer->conn_idlock);
 329                 list_del(&candidate->id_link);
 330                 write_unlock(&peer->conn_idlock);
 331
 332                 __RXACCT(atomic_dec(&rxrpc_connection_count));
 333                 kfree(candidate);
 334         }
 335
 336         if (fresh) {
 337                 down_write(&rxrpc_conns_sem);
 338                 list_add_tail(&conn->proc_link, &rxrpc_conns);
 339                 up_write(&rxrpc_conns_sem);
 340         }
 341
 342  success:
 343         *_conn = conn;
 344         _leave(" = 0 (%p)", conn);
 345         return 0;
 346
 347         /* handle the connection being found in the active list straight off */
 348  found_active:
 349         rxrpc_get_connection(conn);
 350         read_unlock(&peer->conn_lock);
 351         goto success;
 352
 353         /* handle resurrecting a connection from the graveyard */
 354  found_in_graveyard:
 355         _debug("resurrecting connection: {%08x} [in]", ntohl(conn->conn_id));
 356         rxrpc_get_peer(peer);
 357         rxrpc_get_connection(conn);
 358         rxrpc_krxtimod_del_timer(&conn->timeout);
 359         list_del_init(&conn->link);
 360         spin_unlock(&peer->conn_gylock);
 361         goto make_active;
 362
 363         /* handle finding the connection on the second time through the active
 364          * list */
 365  found_active_second_chance:
 366         rxrpc_get_connection(conn);
 367         goto success_uwfree;
 368
 369 } /* end rxrpc_connection_lookup() */
 370
 371 /*****************************************************************************/
 372 /*
 373  * finish using a connection record
 374  * - it will be transferred to the peer's connection graveyard when refcount
 375  *   reaches 0
 376  */
 377 void rxrpc_put_connection(struct rxrpc_connection *conn)
 378 {
 379         struct rxrpc_peer *peer;
 380
 381         if (!conn)
 382                 return;
 383
 384         _enter("%p{u=%d p=%hu}",
 385                conn, atomic_read(&conn->usage), ntohs(conn->addr.sin_port));
 386
 387         peer = conn->peer;
 388         spin_lock(&peer->conn_gylock);
 389
 390         /* sanity check */
 391         if (atomic_read(&conn->usage) <= 0)
 392                 BUG();
 393
 394         if (likely(!atomic_dec_and_test(&conn->usage))) {
 395                 spin_unlock(&peer->conn_gylock);
 396                 _leave("");
 397                 return;
 398         }
 399
 400         /* move to graveyard queue */
 401         _debug("burying connection: {%08x}", ntohl(conn->conn_id));
 402         list_del(&conn->link);
 403         list_add_tail(&conn->link, &peer->conn_graveyard);
 404
 405         rxrpc_krxtimod_add_timer(&conn->timeout, rxrpc_conn_timeout * HZ);
 406
 407         spin_unlock(&peer->conn_gylock);
 408
 409         rxrpc_put_peer(conn->peer);
 410
 411         _leave(" [killed]");
 412 } /* end rxrpc_put_connection() */
 413
 414 /*****************************************************************************/
 415 /*
 416  * free a connection record
 417  */
 418 void rxrpc_conn_do_timeout(struct rxrpc_connection *conn)
 419 {
 420         struct rxrpc_peer *peer;
 421
 422         _enter("%p{u=%d p=%hu}",
 423                conn, atomic_read(&conn->usage), ntohs(conn->addr.sin_port));
 424
 425         peer = conn->peer;
 426
 427         if (atomic_read(&conn->usage) < 0)
 428                 BUG();
 429
 430         /* remove from graveyard if still dead */
 431         spin_lock(&peer->conn_gylock);
 432         if (atomic_read(&conn->usage) == 0) {
 433                 list_del_init(&conn->link);
 434         }
 435         else {
 436                 conn = NULL;
 437         }
 438         spin_unlock(&peer->conn_gylock);
 439
 440         if (!conn) {
 441                 _leave("");
 442                 return; /* resurrected */
 443         }
 444
 445         _debug("--- Destroying Connection %p{%08x} ---",
 446                conn, ntohl(conn->conn_id));
 447
 448         down_write(&rxrpc_conns_sem);
 449         list_del(&conn->proc_link);
 450         up_write(&rxrpc_conns_sem);
 451
 452         write_lock(&peer->conn_idlock);
 453         list_del(&conn->id_link);
 454         write_unlock(&peer->conn_idlock);
 455
 456         __RXACCT(atomic_dec(&rxrpc_connection_count));
 457         kfree(conn);
 458
 459         /* if the graveyard is now empty, wake up anyone waiting for that */
 460         if (atomic_dec_and_test(&peer->conn_count))
 461                 wake_up(&peer->conn_gy_waitq);
 462
 463         _leave(" [destroyed]");
 464 } /* end rxrpc_conn_do_timeout() */
 465
 466 /*****************************************************************************/
 467 /*
 468  * clear all connection records from a peer endpoint
 469  */
 470 void rxrpc_conn_clearall(struct rxrpc_peer *peer)
 471 {
 472         DECLARE_WAITQUEUE(myself, current);
 473
 474         struct rxrpc_connection *conn;
 475         int err;
 476
 477         _enter("%p", peer);
 478
 479         /* there shouldn't be any active conns remaining */
 480         if (!list_empty(&peer->conn_active))
 481                 BUG();
 482
 483         /* manually timeout all conns in the graveyard */
 484         spin_lock(&peer->conn_gylock);
 485         while (!list_empty(&peer->conn_graveyard)) {
 486                 conn = list_entry(peer->conn_graveyard.next,
 487                                   struct rxrpc_connection, link);
 488                 err = rxrpc_krxtimod_del_timer(&conn->timeout);
 489                 spin_unlock(&peer->conn_gylock);
 490
 491                 if (err == 0)
 492                         rxrpc_conn_do_timeout(conn);
 493
 494                 spin_lock(&peer->conn_gylock);
 495         }
 496         spin_unlock(&peer->conn_gylock);
 497
 498         /* wait for the the conn graveyard to be completely cleared */
 499         set_current_state(TASK_UNINTERRUPTIBLE);
 500         add_wait_queue(&peer->conn_gy_waitq, &myself);
 501
 502         while (atomic_read(&peer->conn_count) != 0) {
 503                 schedule();
 504                 set_current_state(TASK_UNINTERRUPTIBLE);
 505         }
 506
 507         remove_wait_queue(&peer->conn_gy_waitq, &myself);
 508         set_current_state(TASK_RUNNING);
 509
 510         _leave("");
 511 } /* end rxrpc_conn_clearall() */
 512
 513 /*****************************************************************************/
 514 /*
 515  * allocate and prepare a message for sending out through the transport
 516  * endpoint
 517  */
 518 int rxrpc_conn_newmsg(struct rxrpc_connection *conn,
 519                       struct rxrpc_call *call,
 520                       uint8_t type,
 521                       int dcount,
 522                       struct kvec diov[],
 523                       int alloc_flags,
 524                       struct rxrpc_message **_msg)
 525 {
 526         struct rxrpc_message *msg;
 527         int loop;
 528
 529         _enter("%p{%d},%p,%u", conn, ntohs(conn->addr.sin_port), call, type);
 530
 531         if (dcount > 3) {
 532                 _leave(" = -EINVAL");
 533                 return -EINVAL;
 534         }
 535
 536         msg = kmalloc(sizeof(struct rxrpc_message), alloc_flags);
 537         if (!msg) {
 538                 _leave(" = -ENOMEM");
 539                 return -ENOMEM;
 540         }
 541
 542         memset(msg, 0, sizeof(*msg));
 543         atomic_set(&msg->usage, 1);
 544
 545         INIT_LIST_HEAD(&msg->link);
 546
 547         msg->state = RXRPC_MSG_PREPARED;
 548
 549         msg->hdr.epoch          = conn->out_epoch;
 550         msg->hdr.cid            = conn->conn_id | (call ? call->chan_ix : 0);
 551         msg->hdr.callNumber     = call ? call->call_id : 0;
 552         msg->hdr.type           = type;
 553         msg->hdr.flags          = conn->out_clientflag;
 554         msg->hdr.securityIndex  = conn->security_ix;
 555         msg->hdr.serviceId      = conn->service_id;
 556
 557         /* generate sequence numbers for data packets */
 558         if (call) {
 559                 switch (type) {
 560                 case RXRPC_PACKET_TYPE_DATA:
 561                         msg->seq = ++call->snd_seq_count;
 562                         msg->hdr.seq = htonl(msg->seq);
 563                         break;
 564                 case RXRPC_PACKET_TYPE_ACK:
 565                         /* ACK sequence numbers are complicated. The following
 566                          * may be wrong:
 567                          * - jumbo packet ACKs should have a seq number
 568                          * - normal ACKs should not
 569                          */
 570                 default:
 571                         break;
 572                 }
 573         }
 574
 575         msg->dcount = dcount + 1;
 576         msg->dsize = sizeof(msg->hdr);
 577         msg->data[0].iov_len = sizeof(msg->hdr);
 578         msg->data[0].iov_base = &msg->hdr;
 579
 580         for (loop=0; loop < dcount; loop++) {
 581                 msg->dsize += diov[loop].iov_len;
 582                 msg->data[loop+1].iov_len  = diov[loop].iov_len;
 583                 msg->data[loop+1].iov_base = diov[loop].iov_base;
 584         }
 585
 586         __RXACCT(atomic_inc(&rxrpc_message_count));
 587         *_msg = msg;
 588         _leave(" = 0 (%p) #%d", msg, atomic_read(&rxrpc_message_count));
 589         return 0;
 590 } /* end rxrpc_conn_newmsg() */
 591
 592 /*****************************************************************************/
 593 /*
 594  * free a message
 595  */
 596 void __rxrpc_put_message(struct rxrpc_message *msg)
 597 {
 598         int loop;
 599
 600         _enter("%p #%d", msg, atomic_read(&rxrpc_message_count));
 601
 602         if (msg->pkt)
 603                 kfree_skb(msg->pkt);
 604         rxrpc_put_connection(msg->conn);
 605
 606         for (loop = 0; loop < 8; loop++)
 607                 if (test_bit(loop, &msg->dfree))
 608                         kfree(msg->data[loop].iov_base);
 609
 610         __RXACCT(atomic_dec(&rxrpc_message_count));
 611         kfree(msg);
 612
 613         _leave("");
 614 } /* end __rxrpc_put_message() */
 615
 616 /*****************************************************************************/
 617 /*
 618  * send a message out through the transport endpoint
 619  */
 620 int rxrpc_conn_sendmsg(struct rxrpc_connection *conn,
 621                        struct rxrpc_message *msg)
 622 {
 623         struct msghdr msghdr;
 624         int ret;
 625
 626         _enter("%p{%d}", conn, ntohs(conn->addr.sin_port));
 627
 628         /* fill in some fields in the header */
 629         spin_lock(&conn->lock);
 630         msg->hdr.serial = htonl(++conn->serial_counter);
 631         msg->rttdone = 0;
 632         spin_unlock(&conn->lock);
 633
 634         /* set up the message to be transmitted */
 635         msghdr.msg_name         = &conn->addr;
 636         msghdr.msg_namelen      = sizeof(conn->addr);
 637         msghdr.msg_control      = NULL;
 638         msghdr.msg_controllen   = 0;
 639         msghdr.msg_flags        = MSG_CONFIRM | MSG_DONTWAIT;
 640
 641         _net("Sending message type %d of %Zd bytes to %08x:%d",
 642              msg->hdr.type,
 643              msg->dsize,
 644              ntohl(conn->addr.sin_addr.s_addr),
 645              ntohs(conn->addr.sin_port));
 646
 647         /* send the message */
 648         ret = kernel_sendmsg(conn->trans->socket, &msghdr,
 649                              msg->data, msg->dcount, msg->dsize);
 650         if (ret < 0) {
 651                 msg->state = RXRPC_MSG_ERROR;
 652         } else {
 653                 msg->state = RXRPC_MSG_SENT;
 654                 ret = 0;
 655
 656                 spin_lock(&conn->lock);
 657                 do_gettimeofday(&conn->atime);
 658                 msg->stamp = conn->atime;
 659                 spin_unlock(&conn->lock);
 660         }
 661
 662         _leave(" = %d", ret);
 663
 664         return ret;
 665 } /* end rxrpc_conn_sendmsg() */
 666
 667 /*****************************************************************************/
 668 /*
 669  * deal with a subsequent call packet
 670  */
 671 int rxrpc_conn_receive_call_packet(struct rxrpc_connection *conn,
 672                                    struct rxrpc_call *call,
 673                                    struct rxrpc_message *msg)
 674 {
 675         struct rxrpc_message *pmsg;
 676         struct list_head *_p;
 677         unsigned cix, seq;
 678         int ret = 0;
 679
 680         _enter("%p,%p,%p", conn, call, msg);
 681
 682         if (!call) {
 683                 cix = ntohl(msg->hdr.cid) & RXRPC_CHANNELMASK;
 684
 685                 spin_lock(&conn->lock);
 686                 call = conn->channels[cix];
 687
 688                 if (!call || call->call_id != msg->hdr.callNumber) {
 689                         spin_unlock(&conn->lock);
 690                         rxrpc_trans_immediate_abort(conn->trans, msg, -ENOENT);
 691                         goto out;
 692                 }
 693                 else {
 694                         rxrpc_get_call(call);
 695                         spin_unlock(&conn->lock);
 696                 }
 697         }
 698         else {
 699                 rxrpc_get_call(call);
 700         }
 701
 702         _proto("Received packet %%%u [%u] on call %hu:%u:%u",
 703                ntohl(msg->hdr.serial),
 704                ntohl(msg->hdr.seq),
 705                ntohs(msg->hdr.serviceId),
 706                ntohl(conn->conn_id),
 707                ntohl(call->call_id));
 708
 709         call->pkt_rcv_count++;
 710
 711         if (msg->pkt->dst && msg->pkt->dst->dev)
 712                 conn->peer->if_mtu =
 713                         msg->pkt->dst->dev->mtu -
 714                         msg->pkt->dst->dev->hard_header_len;
 715
 716         /* queue on the call in seq order */
 717         rxrpc_get_message(msg);
 718         seq = msg->seq;
 719
 720         spin_lock(&call->lock);
 721         list_for_each(_p, &call->rcv_receiveq) {
 722                 pmsg = list_entry(_p, struct rxrpc_message, link);
 723                 if (pmsg->seq > seq)
 724                         break;
 725         }
 726         list_add_tail(&msg->link, _p);
 727
 728         /* reset the activity timeout */
 729         call->flags |= RXRPC_CALL_RCV_PKT;
 730         mod_timer(&call->rcv_timeout,jiffies + rxrpc_call_rcv_timeout * HZ);
 731
 732         spin_unlock(&call->lock);
 733
 734         rxrpc_krxiod_queue_call(call);
 735
 736         rxrpc_put_call(call);
 737  out:
 738         _leave(" = %d", ret);
 739         return ret;
 740 } /* end rxrpc_conn_receive_call_packet() */
 741
 742 /*****************************************************************************/
 743 /*
 744  * handle an ICMP error being applied to a connection
 745  */
 746 void rxrpc_conn_handle_error(struct rxrpc_connection *conn,
 747                              int local, int errno)
 748 {
 749         struct rxrpc_call *calls[4];
 750         int loop;
 751
 752         _enter("%p{%d},%d", conn, ntohs(conn->addr.sin_port), errno);
 753
 754         /* get a ref to all my calls in one go */
 755         memset(calls, 0, sizeof(calls));
 756         spin_lock(&conn->lock);
 757
 758         for (loop = 3; loop >= 0; loop--) {
 759                 if (conn->channels[loop]) {
 760                         calls[loop] = conn->channels[loop];
 761                         rxrpc_get_call(calls[loop]);
 762                 }
 763         }
 764
 765         spin_unlock(&conn->lock);
 766
 767         /* now kick them all */
 768         for (loop = 3; loop >= 0; loop--) {
 769                 if (calls[loop]) {
 770                         rxrpc_call_handle_error(calls[loop], local, errno);
 771                         rxrpc_put_call(calls[loop]);
 772                 }
 773         }
 774
 775         _leave("");
 776 } /* end rxrpc_conn_handle_error() */