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