projects / deliverable / linux.git / blob
? search:


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