~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/rxrpc/ar-call.c

Version: ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp