[PATCH] sysctl: remove insert_at_head from register_sysctl
[linux-2.6.git] / 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_do_timeout(struct rxrpc_connection *conn);
34
35 static void __rxrpc_conn_timeout(rxrpc_timer_t *timer)
36 {
37         struct rxrpc_connection *conn =
38                 list_entry(timer, struct rxrpc_connection, timeout);
39
40         _debug("Rx CONN TIMEOUT [%p{u=%d}]", conn, atomic_read(&conn->usage));
41
42         rxrpc_conn_do_timeout(conn);
43 }
44
45 static const struct rxrpc_timer_ops rxrpc_conn_timer_ops = {
46         .timed_out      = __rxrpc_conn_timeout,
47 };
48
49 /*****************************************************************************/
50 /*
51  * create a new connection record
52  */
53 static inline int __rxrpc_create_connection(struct rxrpc_peer *peer,
54                                             struct rxrpc_connection **_conn)
55 {
56         struct rxrpc_connection *conn;
57
58         _enter("%p",peer);
59
60         /* allocate and initialise a connection record */
61         conn = kzalloc(sizeof(struct rxrpc_connection), GFP_KERNEL);
62         if (!conn) {
63                 _leave(" = -ENOMEM");
64                 return -ENOMEM;
65         }
66
67         atomic_set(&conn->usage, 1);
68
69         INIT_LIST_HEAD(&conn->link);
70         INIT_LIST_HEAD(&conn->id_link);
71         init_waitqueue_head(&conn->chanwait);
72         spin_lock_init(&conn->lock);
73         rxrpc_timer_init(&conn->timeout, &rxrpc_conn_timer_ops);
74
75         do_gettimeofday(&conn->atime);
76         conn->mtu_size = 1024;
77         conn->peer = peer;
78         conn->trans = peer->trans;
79
80         __RXACCT(atomic_inc(&rxrpc_connection_count));
81         *_conn = conn;
82         _leave(" = 0 (%p)", conn);
83
84         return 0;
85 } /* end __rxrpc_create_connection() */
86
87 /*****************************************************************************/
88 /*
89  * create a new connection record for outgoing connections
90  */
91 int rxrpc_create_connection(struct rxrpc_transport *trans,
92                             __be16 port,
93                             __be32 addr,
94                             uint16_t service_id,
95                             void *security,
96                             struct rxrpc_connection **_conn)
97 {
98         struct rxrpc_connection *candidate, *conn;
99         struct rxrpc_peer *peer;
100         struct list_head *_p;
101         __be32 connid;
102         int ret;
103
104         _enter("%p{%hu},%u,%hu", trans, trans->port, ntohs(port), service_id);
105
106         /* get a peer record */
107         ret = rxrpc_peer_lookup(trans, addr, &peer);
108         if (ret < 0) {
109                 _leave(" = %d", ret);
110                 return ret;
111         }
112
113         /* allocate and initialise a connection record */
114         ret = __rxrpc_create_connection(peer, &candidate);
115         if (ret < 0) {
116                 rxrpc_put_peer(peer);
117                 _leave(" = %d", ret);
118                 return ret;
119         }
120
121         /* fill in the specific bits */
122         candidate->addr.sin_family      = AF_INET;
123         candidate->addr.sin_port        = port;
124         candidate->addr.sin_addr.s_addr = addr;
125
126         candidate->in_epoch             = rxrpc_epoch;
127         candidate->out_epoch            = rxrpc_epoch;
128         candidate->in_clientflag        = 0;
129         candidate->out_clientflag       = RXRPC_CLIENT_INITIATED;
130         candidate->service_id           = htons(service_id);
131
132         /* invent a unique connection ID */
133         write_lock(&peer->conn_idlock);
134
135  try_next_id:
136         connid = htonl(peer->conn_idcounter & RXRPC_CIDMASK);
137         peer->conn_idcounter += RXRPC_MAXCALLS;
138
139         list_for_each(_p, &peer->conn_idlist) {
140                 conn = list_entry(_p, struct rxrpc_connection, id_link);
141                 if (connid == conn->conn_id)
142                         goto try_next_id;
143                 if (connid > conn->conn_id)
144                         break;
145         }
146
147         _debug("selected candidate conn ID %x.%u",
148                ntohl(peer->addr.s_addr), ntohl(connid));
149
150         candidate->conn_id = connid;
151         list_add_tail(&candidate->id_link, _p);
152
153         write_unlock(&peer->conn_idlock);
154
155         /* attach to peer */
156         candidate->peer = peer;
157
158         write_lock(&peer->conn_lock);
159
160         /* search the peer's transport graveyard list */
161         spin_lock(&peer->conn_gylock);
162         list_for_each(_p, &peer->conn_graveyard) {
163                 conn = list_entry(_p, struct rxrpc_connection, link);
164                 if (conn->addr.sin_port == candidate->addr.sin_port     &&
165                     conn->security_ix   == candidate->security_ix       &&
166                     conn->service_id    == candidate->service_id        &&
167                     conn->in_clientflag == 0)
168                         goto found_in_graveyard;
169         }
170         spin_unlock(&peer->conn_gylock);
171
172         /* pick the new candidate */
173         _debug("created connection: {%08x} [out]", ntohl(candidate->conn_id));
174         atomic_inc(&peer->conn_count);
175         conn = candidate;
176         candidate = NULL;
177
178  make_active:
179         list_add_tail(&conn->link, &peer->conn_active);
180         write_unlock(&peer->conn_lock);
181
182         if (candidate) {
183                 write_lock(&peer->conn_idlock);
184                 list_del(&candidate->id_link);
185                 write_unlock(&peer->conn_idlock);
186
187                 __RXACCT(atomic_dec(&rxrpc_connection_count));
188                 kfree(candidate);
189         }
190         else {
191                 down_write(&rxrpc_conns_sem);
192                 list_add_tail(&conn->proc_link, &rxrpc_conns);
193                 up_write(&rxrpc_conns_sem);
194         }
195
196         *_conn = conn;
197         _leave(" = 0 (%p)", conn);
198
199         return 0;
200
201         /* handle resurrecting a connection from the graveyard */
202  found_in_graveyard:
203         _debug("resurrecting connection: {%08x} [out]", ntohl(conn->conn_id));
204         rxrpc_get_connection(conn);
205         rxrpc_krxtimod_del_timer(&conn->timeout);
206         list_del_init(&conn->link);
207         spin_unlock(&peer->conn_gylock);
208         goto make_active;
209 } /* end rxrpc_create_connection() */
210
211 /*****************************************************************************/
212 /*
213  * lookup the connection for an incoming packet
214  * - create a new connection record for unrecorded incoming connections
215  */
216 int rxrpc_connection_lookup(struct rxrpc_peer *peer,
217                             struct rxrpc_message *msg,
218                             struct rxrpc_connection **_conn)
219 {
220         struct rxrpc_connection *conn, *candidate = NULL;
221         struct list_head *_p;
222         struct sk_buff *pkt = msg->pkt;
223         int ret, fresh = 0;
224         __be32 x_epoch, x_connid;
225         __be16 x_port, x_servid;
226         __u32 x_secix;
227         u8 x_clflag;
228
229         _enter("%p{{%hu}},%u,%hu",
230                peer,
231                peer->trans->port,
232                ntohs(pkt->h.uh->source),
233                ntohs(msg->hdr.serviceId));
234
235         x_port          = pkt->h.uh->source;
236         x_epoch         = msg->hdr.epoch;
237         x_clflag        = msg->hdr.flags & RXRPC_CLIENT_INITIATED;
238         x_connid        = htonl(ntohl(msg->hdr.cid) & RXRPC_CIDMASK);
239         x_servid        = msg->hdr.serviceId;
240         x_secix         = msg->hdr.securityIndex;
241
242         /* [common case] search the transport's active list first */
243         read_lock(&peer->conn_lock);
244         list_for_each(_p, &peer->conn_active) {
245                 conn = list_entry(_p, struct rxrpc_connection, link);
246                 if (conn->addr.sin_port         == x_port       &&
247                     conn->in_epoch              == x_epoch      &&
248                     conn->conn_id               == x_connid     &&
249                     conn->security_ix           == x_secix      &&
250                     conn->service_id            == x_servid     &&
251                     conn->in_clientflag         == x_clflag)
252                         goto found_active;
253         }
254         read_unlock(&peer->conn_lock);
255
256         /* [uncommon case] not active
257          * - create a candidate for a new record if an inbound connection
258          * - only examine the graveyard for an outbound connection
259          */
260         if (x_clflag) {
261                 ret = __rxrpc_create_connection(peer, &candidate);
262                 if (ret < 0) {
263                         _leave(" = %d", ret);
264                         return ret;
265                 }
266
267                 /* fill in the specifics */
268                 candidate->addr.sin_family      = AF_INET;
269                 candidate->addr.sin_port        = x_port;
270                 candidate->addr.sin_addr.s_addr = pkt->nh.iph->saddr;
271                 candidate->in_epoch             = x_epoch;
272                 candidate->out_epoch            = x_epoch;
273                 candidate->in_clientflag        = RXRPC_CLIENT_INITIATED;
274                 candidate->out_clientflag       = 0;
275                 candidate->conn_id              = x_connid;
276                 candidate->service_id           = x_servid;
277                 candidate->security_ix          = x_secix;
278         }
279
280         /* search the active list again, just in case it appeared whilst we
281          * were busy */
282         write_lock(&peer->conn_lock);
283         list_for_each(_p, &peer->conn_active) {
284                 conn = list_entry(_p, struct rxrpc_connection, link);
285                 if (conn->addr.sin_port         == x_port       &&
286                     conn->in_epoch              == x_epoch      &&
287                     conn->conn_id               == x_connid     &&
288                     conn->security_ix           == x_secix      &&
289                     conn->service_id            == x_servid     &&
290                     conn->in_clientflag         == x_clflag)
291                         goto found_active_second_chance;
292         }
293
294         /* search the transport's graveyard list */
295         spin_lock(&peer->conn_gylock);
296         list_for_each(_p, &peer->conn_graveyard) {
297                 conn = list_entry(_p, struct rxrpc_connection, link);
298                 if (conn->addr.sin_port         == x_port       &&
299                     conn->in_epoch              == x_epoch      &&
300                     conn->conn_id               == x_connid     &&
301                     conn->security_ix           == x_secix      &&
302                     conn->service_id            == x_servid     &&
303                     conn->in_clientflag         == x_clflag)
304                         goto found_in_graveyard;
305         }
306         spin_unlock(&peer->conn_gylock);
307
308         /* outbound connections aren't created here */
309         if (!x_clflag) {
310                 write_unlock(&peer->conn_lock);
311                 _leave(" = -ENOENT");
312                 return -ENOENT;
313         }
314
315         /* we can now add the new candidate to the list */
316         _debug("created connection: {%08x} [in]", ntohl(candidate->conn_id));
317         rxrpc_get_peer(peer);
318         conn = candidate;
319         candidate = NULL;
320         atomic_inc(&peer->conn_count);
321         fresh = 1;
322
323  make_active:
324         list_add_tail(&conn->link, &peer->conn_active);
325
326  success_uwfree:
327         write_unlock(&peer->conn_lock);
328
329         if (candidate) {
330                 write_lock(&peer->conn_idlock);
331                 list_del(&candidate->id_link);
332                 write_unlock(&peer->conn_idlock);
333
334                 __RXACCT(atomic_dec(&rxrpc_connection_count));
335                 kfree(candidate);
336         }
337
338         if (fresh) {
339                 down_write(&rxrpc_conns_sem);
340                 list_add_tail(&conn->proc_link, &rxrpc_conns);
341                 up_write(&rxrpc_conns_sem);
342         }
343
344  success:
345         *_conn = conn;
346         _leave(" = 0 (%p)", conn);
347         return 0;
348
349         /* handle the connection being found in the active list straight off */
350  found_active:
351         rxrpc_get_connection(conn);
352         read_unlock(&peer->conn_lock);
353         goto success;
354
355         /* handle resurrecting a connection from the graveyard */
356  found_in_graveyard:
357         _debug("resurrecting connection: {%08x} [in]", ntohl(conn->conn_id));
358         rxrpc_get_peer(peer);
359         rxrpc_get_connection(conn);
360         rxrpc_krxtimod_del_timer(&conn->timeout);
361         list_del_init(&conn->link);
362         spin_unlock(&peer->conn_gylock);
363         goto make_active;
364
365         /* handle finding the connection on the second time through the active
366          * list */
367  found_active_second_chance:
368         rxrpc_get_connection(conn);
369         goto success_uwfree;
370
371 } /* end rxrpc_connection_lookup() */
372
373 /*****************************************************************************/
374 /*
375  * finish using a connection record
376  * - it will be transferred to the peer's connection graveyard when refcount
377  *   reaches 0
378  */
379 void rxrpc_put_connection(struct rxrpc_connection *conn)
380 {
381         struct rxrpc_peer *peer;
382
383         if (!conn)
384                 return;
385
386         _enter("%p{u=%d p=%hu}",
387                conn, atomic_read(&conn->usage), ntohs(conn->addr.sin_port));
388
389         peer = conn->peer;
390         spin_lock(&peer->conn_gylock);
391
392         /* sanity check */
393         if (atomic_read(&conn->usage) <= 0)
394                 BUG();
395
396         if (likely(!atomic_dec_and_test(&conn->usage))) {
397                 spin_unlock(&peer->conn_gylock);
398                 _leave("");
399                 return;
400         }
401
402         /* move to graveyard queue */
403         _debug("burying connection: {%08x}", ntohl(conn->conn_id));
404         list_move_tail(&conn->link, &peer->conn_graveyard);
405
406         rxrpc_krxtimod_add_timer(&conn->timeout, rxrpc_conn_timeout * HZ);
407
408         spin_unlock(&peer->conn_gylock);
409
410         rxrpc_put_peer(conn->peer);
411
412         _leave(" [killed]");
413 } /* end rxrpc_put_connection() */
414
415 /*****************************************************************************/
416 /*
417  * free a connection record
418  */
419 static void rxrpc_conn_do_timeout(struct rxrpc_connection *conn)
420 {
421         struct rxrpc_peer *peer;
422
423         _enter("%p{u=%d p=%hu}",
424                conn, atomic_read(&conn->usage), ntohs(conn->addr.sin_port));
425
426         peer = conn->peer;
427
428         if (atomic_read(&conn->usage) < 0)
429                 BUG();
430
431         /* remove from graveyard if still dead */
432         spin_lock(&peer->conn_gylock);
433         if (atomic_read(&conn->usage) == 0) {
434                 list_del_init(&conn->link);
435         }
436         else {
437                 conn = NULL;
438         }
439         spin_unlock(&peer->conn_gylock);
440
441         if (!conn) {
442                 _leave("");
443                 return; /* resurrected */
444         }
445
446         _debug("--- Destroying Connection %p{%08x} ---",
447                conn, ntohl(conn->conn_id));
448
449         down_write(&rxrpc_conns_sem);
450         list_del(&conn->proc_link);
451         up_write(&rxrpc_conns_sem);
452
453         write_lock(&peer->conn_idlock);
454         list_del(&conn->id_link);
455         write_unlock(&peer->conn_idlock);
456
457         __RXACCT(atomic_dec(&rxrpc_connection_count));
458         kfree(conn);
459
460         /* if the graveyard is now empty, wake up anyone waiting for that */
461         if (atomic_dec_and_test(&peer->conn_count))
462                 wake_up(&peer->conn_gy_waitq);
463
464         _leave(" [destroyed]");
465 } /* end rxrpc_conn_do_timeout() */
466
467 /*****************************************************************************/
468 /*
469  * clear all connection records from a peer endpoint
470  */
471 void rxrpc_conn_clearall(struct rxrpc_peer *peer)
472 {
473         DECLARE_WAITQUEUE(myself, current);
474
475         struct rxrpc_connection *conn;
476         int err;
477
478         _enter("%p", peer);
479
480         /* there shouldn't be any active conns remaining */
481         if (!list_empty(&peer->conn_active))
482                 BUG();
483
484         /* manually timeout all conns in the graveyard */
485         spin_lock(&peer->conn_gylock);
486         while (!list_empty(&peer->conn_graveyard)) {
487                 conn = list_entry(peer->conn_graveyard.next,
488                                   struct rxrpc_connection, link);
489                 err = rxrpc_krxtimod_del_timer(&conn->timeout);
490                 spin_unlock(&peer->conn_gylock);
491
492                 if (err == 0)
493                         rxrpc_conn_do_timeout(conn);
494
495                 spin_lock(&peer->conn_gylock);
496         }
497         spin_unlock(&peer->conn_gylock);
498
499         /* wait for the the conn graveyard to be completely cleared */
500         set_current_state(TASK_UNINTERRUPTIBLE);
501         add_wait_queue(&peer->conn_gy_waitq, &myself);
502
503         while (atomic_read(&peer->conn_count) != 0) {
504                 schedule();
505                 set_current_state(TASK_UNINTERRUPTIBLE);
506         }
507
508         remove_wait_queue(&peer->conn_gy_waitq, &myself);
509         set_current_state(TASK_RUNNING);
510
511         _leave("");
512 } /* end rxrpc_conn_clearall() */
513
514 /*****************************************************************************/
515 /*
516  * allocate and prepare a message for sending out through the transport
517  * endpoint
518  */
519 int rxrpc_conn_newmsg(struct rxrpc_connection *conn,
520                       struct rxrpc_call *call,
521                       uint8_t type,
522                       int dcount,
523                       struct kvec diov[],
524                       gfp_t alloc_flags,
525                       struct rxrpc_message **_msg)
526 {
527         struct rxrpc_message *msg;
528         int loop;
529
530         _enter("%p{%d},%p,%u", conn, ntohs(conn->addr.sin_port), call, type);
531
532         if (dcount > 3) {
533                 _leave(" = -EINVAL");
534                 return -EINVAL;
535         }
536
537         msg = kzalloc(sizeof(struct rxrpc_message), alloc_flags);
538         if (!msg) {
539                 _leave(" = -ENOMEM");
540                 return -ENOMEM;
541         }
542
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 dst_entry *dst;
677         struct list_head *_p;
678         unsigned cix, seq;
679         int ret = 0;
680
681         _enter("%p,%p,%p", conn, call, msg);
682
683         if (!call) {
684                 cix = ntohl(msg->hdr.cid) & RXRPC_CHANNELMASK;
685
686                 spin_lock(&conn->lock);
687                 call = conn->channels[cix];
688
689                 if (!call || call->call_id != msg->hdr.callNumber) {
690                         spin_unlock(&conn->lock);
691                         rxrpc_trans_immediate_abort(conn->trans, msg, -ENOENT);
692                         goto out;
693                 }
694                 else {
695                         rxrpc_get_call(call);
696                         spin_unlock(&conn->lock);
697                 }
698         }
699         else {
700                 rxrpc_get_call(call);
701         }
702
703         _proto("Received packet %%%u [%u] on call %hu:%u:%u",
704                ntohl(msg->hdr.serial),
705                ntohl(msg->hdr.seq),
706                ntohs(msg->hdr.serviceId),
707                ntohl(conn->conn_id),
708                ntohl(call->call_id));
709
710         call->pkt_rcv_count++;
711
712         dst = msg->pkt->dst;
713         if (dst && dst->dev)
714                 conn->peer->if_mtu =
715                         dst->dev->mtu - dst->dev->hard_header_len;
716
717         /* queue on the call in seq order */
718         rxrpc_get_message(msg);
719         seq = msg->seq;
720
721         spin_lock(&call->lock);
722         list_for_each(_p, &call->rcv_receiveq) {
723                 pmsg = list_entry(_p, struct rxrpc_message, link);
724                 if (pmsg->seq > seq)
725                         break;
726         }
727         list_add_tail(&msg->link, _p);
728
729         /* reset the activity timeout */
730         call->flags |= RXRPC_CALL_RCV_PKT;
731         mod_timer(&call->rcv_timeout,jiffies + rxrpc_call_rcv_timeout * HZ);
732
733         spin_unlock(&call->lock);
734
735         rxrpc_krxiod_queue_call(call);
736
737         rxrpc_put_call(call);
738  out:
739         _leave(" = %d", ret);
740         return ret;
741 } /* end rxrpc_conn_receive_call_packet() */
742
743 /*****************************************************************************/
744 /*
745  * handle an ICMP error being applied to a connection
746  */
747 void rxrpc_conn_handle_error(struct rxrpc_connection *conn,
748                              int local, int errno)
749 {
750         struct rxrpc_call *calls[4];
751         int loop;
752
753         _enter("%p{%d},%d", conn, ntohs(conn->addr.sin_port), errno);
754
755         /* get a ref to all my calls in one go */
756         memset(calls, 0, sizeof(calls));
757         spin_lock(&conn->lock);
758
759         for (loop = 3; loop >= 0; loop--) {
760                 if (conn->channels[loop]) {
761                         calls[loop] = conn->channels[loop];
762                         rxrpc_get_call(calls[loop]);
763                 }
764         }
765
766         spin_unlock(&conn->lock);
767
768         /* now kick them all */
769         for (loop = 3; loop >= 0; loop--) {
770                 if (calls[loop]) {
771                         rxrpc_call_handle_error(calls[loop], local, errno);
772                         rxrpc_put_call(calls[loop]);
773                 }
774         }
775
776         _leave("");
777 } /* end rxrpc_conn_handle_error() */