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

TOMOYO Linux Cross Reference
Linux/net/rxrpc/call_object.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ 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.75 ] ~ [ 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 #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 const char *const rxrpc_call_states[NR__RXRPC_CALL_STATES] = {
 23         [RXRPC_CALL_UNINITIALISED]              = "Uninit  ",
 24         [RXRPC_CALL_CLIENT_AWAIT_CONN]          = "ClWtConn",
 25         [RXRPC_CALL_CLIENT_SEND_REQUEST]        = "ClSndReq",
 26         [RXRPC_CALL_CLIENT_AWAIT_REPLY]         = "ClAwtRpl",
 27         [RXRPC_CALL_CLIENT_RECV_REPLY]          = "ClRcvRpl",
 28         [RXRPC_CALL_SERVER_PREALLOC]            = "SvPrealc",
 29         [RXRPC_CALL_SERVER_SECURING]            = "SvSecure",
 30         [RXRPC_CALL_SERVER_ACCEPTING]           = "SvAccept",
 31         [RXRPC_CALL_SERVER_RECV_REQUEST]        = "SvRcvReq",
 32         [RXRPC_CALL_SERVER_ACK_REQUEST]         = "SvAckReq",
 33         [RXRPC_CALL_SERVER_SEND_REPLY]          = "SvSndRpl",
 34         [RXRPC_CALL_SERVER_AWAIT_ACK]           = "SvAwtACK",
 35         [RXRPC_CALL_COMPLETE]                   = "Complete",
 36 };
 37 
 38 const char *const rxrpc_call_completions[NR__RXRPC_CALL_COMPLETIONS] = {
 39         [RXRPC_CALL_SUCCEEDED]                  = "Complete",
 40         [RXRPC_CALL_REMOTELY_ABORTED]           = "RmtAbort",
 41         [RXRPC_CALL_LOCALLY_ABORTED]            = "LocAbort",
 42         [RXRPC_CALL_LOCAL_ERROR]                = "LocError",
 43         [RXRPC_CALL_NETWORK_ERROR]              = "NetError",
 44 };
 45 
 46 const char rxrpc_call_traces[rxrpc_call__nr_trace][4] = {
 47         [rxrpc_call_new_client]         = "NWc",
 48         [rxrpc_call_new_service]        = "NWs",
 49         [rxrpc_call_queued]             = "QUE",
 50         [rxrpc_call_queued_ref]         = "QUR",
 51         [rxrpc_call_connected]          = "CON",
 52         [rxrpc_call_release]            = "RLS",
 53         [rxrpc_call_seen]               = "SEE",
 54         [rxrpc_call_got]                = "GOT",
 55         [rxrpc_call_got_userid]         = "Gus",
 56         [rxrpc_call_got_kernel]         = "Gke",
 57         [rxrpc_call_put]                = "PUT",
 58         [rxrpc_call_put_userid]         = "Pus",
 59         [rxrpc_call_put_kernel]         = "Pke",
 60         [rxrpc_call_put_noqueue]        = "PNQ",
 61         [rxrpc_call_error]              = "*E*",
 62 };
 63 
 64 struct kmem_cache *rxrpc_call_jar;
 65 LIST_HEAD(rxrpc_calls);
 66 DEFINE_RWLOCK(rxrpc_call_lock);
 67 
 68 static void rxrpc_call_timer_expired(unsigned long _call)
 69 {
 70         struct rxrpc_call *call = (struct rxrpc_call *)_call;
 71 
 72         _enter("%d", call->debug_id);
 73 
 74         if (call->state < RXRPC_CALL_COMPLETE)
 75                 rxrpc_set_timer(call, rxrpc_timer_expired, ktime_get_real());
 76 }
 77 
 78 /*
 79  * find an extant server call
 80  * - called in process context with IRQs enabled
 81  */
 82 struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *rx,
 83                                               unsigned long user_call_ID)
 84 {
 85         struct rxrpc_call *call;
 86         struct rb_node *p;
 87 
 88         _enter("%p,%lx", rx, user_call_ID);
 89 
 90         read_lock(&rx->call_lock);
 91 
 92         p = rx->calls.rb_node;
 93         while (p) {
 94                 call = rb_entry(p, struct rxrpc_call, sock_node);
 95 
 96                 if (user_call_ID < call->user_call_ID)
 97                         p = p->rb_left;
 98                 else if (user_call_ID > call->user_call_ID)
 99                         p = p->rb_right;
100                 else
101                         goto found_extant_call;
102         }
103 
104         read_unlock(&rx->call_lock);
105         _leave(" = NULL");
106         return NULL;
107 
108 found_extant_call:
109         rxrpc_get_call(call, rxrpc_call_got);
110         read_unlock(&rx->call_lock);
111         _leave(" = %p [%d]", call, atomic_read(&call->usage));
112         return call;
113 }
114 
115 /*
116  * allocate a new call
117  */
118 struct rxrpc_call *rxrpc_alloc_call(gfp_t gfp)
119 {
120         struct rxrpc_call *call;
121 
122         call = kmem_cache_zalloc(rxrpc_call_jar, gfp);
123         if (!call)
124                 return NULL;
125 
126         call->rxtx_buffer = kcalloc(RXRPC_RXTX_BUFF_SIZE,
127                                     sizeof(struct sk_buff *),
128                                     gfp);
129         if (!call->rxtx_buffer)
130                 goto nomem;
131 
132         call->rxtx_annotations = kcalloc(RXRPC_RXTX_BUFF_SIZE, sizeof(u8), gfp);
133         if (!call->rxtx_annotations)
134                 goto nomem_2;
135 
136         setup_timer(&call->timer, rxrpc_call_timer_expired,
137                     (unsigned long)call);
138         INIT_WORK(&call->processor, &rxrpc_process_call);
139         INIT_LIST_HEAD(&call->link);
140         INIT_LIST_HEAD(&call->chan_wait_link);
141         INIT_LIST_HEAD(&call->accept_link);
142         INIT_LIST_HEAD(&call->recvmsg_link);
143         INIT_LIST_HEAD(&call->sock_link);
144         init_waitqueue_head(&call->waitq);
145         spin_lock_init(&call->lock);
146         rwlock_init(&call->state_lock);
147         atomic_set(&call->usage, 1);
148         call->debug_id = atomic_inc_return(&rxrpc_debug_id);
149 
150         memset(&call->sock_node, 0xed, sizeof(call->sock_node));
151 
152         /* Leave space in the ring to handle a maxed-out jumbo packet */
153         call->rx_winsize = rxrpc_rx_window_size;
154         call->tx_winsize = 16;
155         call->rx_expect_next = 1;
156 
157         if (RXRPC_TX_SMSS > 2190)
158                 call->cong_cwnd = 2;
159         else if (RXRPC_TX_SMSS > 1095)
160                 call->cong_cwnd = 3;
161         else
162                 call->cong_cwnd = 4;
163         call->cong_ssthresh = RXRPC_RXTX_BUFF_SIZE - 1;
164         return call;
165 
166 nomem_2:
167         kfree(call->rxtx_buffer);
168 nomem:
169         kmem_cache_free(rxrpc_call_jar, call);
170         return NULL;
171 }
172 
173 /*
174  * Allocate a new client call.
175  */
176 static struct rxrpc_call *rxrpc_alloc_client_call(struct sockaddr_rxrpc *srx,
177                                                   gfp_t gfp)
178 {
179         struct rxrpc_call *call;
180         ktime_t now;
181 
182         _enter("");
183 
184         call = rxrpc_alloc_call(gfp);
185         if (!call)
186                 return ERR_PTR(-ENOMEM);
187         call->state = RXRPC_CALL_CLIENT_AWAIT_CONN;
188         call->service_id = srx->srx_service;
189         call->tx_phase = true;
190         now = ktime_get_real();
191         call->acks_latest_ts = now;
192         call->cong_tstamp = now;
193 
194         _leave(" = %p", call);
195         return call;
196 }
197 
198 /*
199  * Initiate the call ack/resend/expiry timer.
200  */
201 static void rxrpc_start_call_timer(struct rxrpc_call *call)
202 {
203         ktime_t now = ktime_get_real(), expire_at;
204 
205         expire_at = ktime_add_ms(now, rxrpc_max_call_lifetime);
206         call->expire_at = expire_at;
207         call->ack_at = expire_at;
208         call->ping_at = expire_at;
209         call->resend_at = expire_at;
210         call->timer.expires = jiffies + LONG_MAX / 2;
211         rxrpc_set_timer(call, rxrpc_timer_begin, now);
212 }
213 
214 /*
215  * set up a call for the given data
216  * - called in process context with IRQs enabled
217  */
218 struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx,
219                                          struct rxrpc_conn_parameters *cp,
220                                          struct sockaddr_rxrpc *srx,
221                                          unsigned long user_call_ID,
222                                          gfp_t gfp)
223 {
224         struct rxrpc_call *call, *xcall;
225         struct rb_node *parent, **pp;
226         const void *here = __builtin_return_address(0);
227         int ret;
228 
229         _enter("%p,%lx", rx, user_call_ID);
230 
231         call = rxrpc_alloc_client_call(srx, gfp);
232         if (IS_ERR(call)) {
233                 _leave(" = %ld", PTR_ERR(call));
234                 return call;
235         }
236 
237         trace_rxrpc_call(call, rxrpc_call_new_client, atomic_read(&call->usage),
238                          here, (const void *)user_call_ID);
239 
240         /* Publish the call, even though it is incompletely set up as yet */
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 error_dup_user_ID;
255         }
256 
257         rcu_assign_pointer(call->socket, rx);
258         call->user_call_ID = user_call_ID;
259         __set_bit(RXRPC_CALL_HAS_USERID, &call->flags);
260         rxrpc_get_call(call, rxrpc_call_got_userid);
261         rb_link_node(&call->sock_node, parent, pp);
262         rb_insert_color(&call->sock_node, &rx->calls);
263         list_add(&call->sock_link, &rx->sock_calls);
264 
265         write_unlock(&rx->call_lock);
266 
267         write_lock(&rxrpc_call_lock);
268         list_add_tail(&call->link, &rxrpc_calls);
269         write_unlock(&rxrpc_call_lock);
270 
271         /* Set up or get a connection record and set the protocol parameters,
272          * including channel number and call ID.
273          */
274         ret = rxrpc_connect_call(call, cp, srx, gfp);
275         if (ret < 0)
276                 goto error;
277 
278         trace_rxrpc_call(call, rxrpc_call_connected, atomic_read(&call->usage),
279                          here, NULL);
280 
281         spin_lock_bh(&call->conn->params.peer->lock);
282         hlist_add_head(&call->error_link,
283                        &call->conn->params.peer->error_targets);
284         spin_unlock_bh(&call->conn->params.peer->lock);
285 
286         rxrpc_start_call_timer(call);
287 
288         _net("CALL new %d on CONN %d", call->debug_id, call->conn->debug_id);
289 
290         _leave(" = %p [new]", call);
291         return call;
292 
293         /* We unexpectedly found the user ID in the list after taking
294          * the call_lock.  This shouldn't happen unless the user races
295          * with itself and tries to add the same user ID twice at the
296          * same time in different threads.
297          */
298 error_dup_user_ID:
299         write_unlock(&rx->call_lock);
300         ret = -EEXIST;
301 
302 error:
303         __rxrpc_set_call_completion(call, RXRPC_CALL_LOCAL_ERROR,
304                                     RX_CALL_DEAD, ret);
305         trace_rxrpc_call(call, rxrpc_call_error, atomic_read(&call->usage),
306                          here, ERR_PTR(ret));
307         rxrpc_release_call(rx, call);
308         rxrpc_put_call(call, rxrpc_call_put);
309         _leave(" = %d", ret);
310         return ERR_PTR(ret);
311 }
312 
313 /*
314  * Set up an incoming call.  call->conn points to the connection.
315  * This is called in BH context and isn't allowed to fail.
316  */
317 void rxrpc_incoming_call(struct rxrpc_sock *rx,
318                          struct rxrpc_call *call,
319                          struct sk_buff *skb)
320 {
321         struct rxrpc_connection *conn = call->conn;
322         struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
323         u32 chan;
324 
325         _enter(",%d", call->conn->debug_id);
326 
327         rcu_assign_pointer(call->socket, rx);
328         call->call_id           = sp->hdr.callNumber;
329         call->service_id        = sp->hdr.serviceId;
330         call->cid               = sp->hdr.cid;
331         call->state             = RXRPC_CALL_SERVER_ACCEPTING;
332         if (sp->hdr.securityIndex > 0)
333                 call->state     = RXRPC_CALL_SERVER_SECURING;
334         call->cong_tstamp       = skb->tstamp;
335 
336         /* Set the channel for this call.  We don't get channel_lock as we're
337          * only defending against the data_ready handler (which we're called
338          * from) and the RESPONSE packet parser (which is only really
339          * interested in call_counter and can cope with a disagreement with the
340          * call pointer).
341          */
342         chan = sp->hdr.cid & RXRPC_CHANNELMASK;
343         conn->channels[chan].call_counter = call->call_id;
344         conn->channels[chan].call_id = call->call_id;
345         rcu_assign_pointer(conn->channels[chan].call, call);
346 
347         spin_lock(&conn->params.peer->lock);
348         hlist_add_head(&call->error_link, &conn->params.peer->error_targets);
349         spin_unlock(&conn->params.peer->lock);
350 
351         _net("CALL incoming %d on CONN %d", call->debug_id, call->conn->debug_id);
352 
353         rxrpc_start_call_timer(call);
354         _leave("");
355 }
356 
357 /*
358  * Queue a call's work processor, getting a ref to pass to the work queue.
359  */
360 bool rxrpc_queue_call(struct rxrpc_call *call)
361 {
362         const void *here = __builtin_return_address(0);
363         int n = __atomic_add_unless(&call->usage, 1, 0);
364         if (n == 0)
365                 return false;
366         if (rxrpc_queue_work(&call->processor))
367                 trace_rxrpc_call(call, rxrpc_call_queued, n + 1, here, NULL);
368         else
369                 rxrpc_put_call(call, rxrpc_call_put_noqueue);
370         return true;
371 }
372 
373 /*
374  * Queue a call's work processor, passing the callers ref to the work queue.
375  */
376 bool __rxrpc_queue_call(struct rxrpc_call *call)
377 {
378         const void *here = __builtin_return_address(0);
379         int n = atomic_read(&call->usage);
380         ASSERTCMP(n, >=, 1);
381         if (rxrpc_queue_work(&call->processor))
382                 trace_rxrpc_call(call, rxrpc_call_queued_ref, n, here, NULL);
383         else
384                 rxrpc_put_call(call, rxrpc_call_put_noqueue);
385         return true;
386 }
387 
388 /*
389  * Note the re-emergence of a call.
390  */
391 void rxrpc_see_call(struct rxrpc_call *call)
392 {
393         const void *here = __builtin_return_address(0);
394         if (call) {
395                 int n = atomic_read(&call->usage);
396 
397                 trace_rxrpc_call(call, rxrpc_call_seen, n, here, NULL);
398         }
399 }
400 
401 /*
402  * Note the addition of a ref on a call.
403  */
404 void rxrpc_get_call(struct rxrpc_call *call, enum rxrpc_call_trace op)
405 {
406         const void *here = __builtin_return_address(0);
407         int n = atomic_inc_return(&call->usage);
408 
409         trace_rxrpc_call(call, op, n, here, NULL);
410 }
411 
412 /*
413  * Detach a call from its owning socket.
414  */
415 void rxrpc_release_call(struct rxrpc_sock *rx, struct rxrpc_call *call)
416 {
417         const void *here = __builtin_return_address(0);
418         struct rxrpc_connection *conn = call->conn;
419         bool put = false;
420         int i;
421 
422         _enter("{%d,%d}", call->debug_id, atomic_read(&call->usage));
423 
424         trace_rxrpc_call(call, rxrpc_call_release, atomic_read(&call->usage),
425                          here, (const void *)call->flags);
426 
427         ASSERTCMP(call->state, ==, RXRPC_CALL_COMPLETE);
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         del_timer_sync(&call->timer);
435 
436         /* Make sure we don't get any more notifications */
437         write_lock_bh(&rx->recvmsg_lock);
438 
439         if (!list_empty(&call->recvmsg_link)) {
440                 _debug("unlinking once-pending call %p { e=%lx f=%lx }",
441                        call, call->events, call->flags);
442                 list_del(&call->recvmsg_link);
443                 put = true;
444         }
445 
446         /* list_empty() must return false in rxrpc_notify_socket() */
447         call->recvmsg_link.next = NULL;
448         call->recvmsg_link.prev = NULL;
449 
450         write_unlock_bh(&rx->recvmsg_lock);
451         if (put)
452                 rxrpc_put_call(call, rxrpc_call_put);
453 
454         write_lock(&rx->call_lock);
455 
456         if (test_and_clear_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
457                 rb_erase(&call->sock_node, &rx->calls);
458                 memset(&call->sock_node, 0xdd, sizeof(call->sock_node));
459                 rxrpc_put_call(call, rxrpc_call_put_userid);
460         }
461 
462         list_del(&call->sock_link);
463         write_unlock(&rx->call_lock);
464 
465         _debug("RELEASE CALL %p (%d CONN %p)", call, call->debug_id, conn);
466 
467         if (conn)
468                 rxrpc_disconnect_call(call);
469 
470         for (i = 0; i < RXRPC_RXTX_BUFF_SIZE; i++) {
471                 rxrpc_free_skb(call->rxtx_buffer[i],
472                                (call->tx_phase ? rxrpc_skb_tx_cleaned :
473                                 rxrpc_skb_rx_cleaned));
474                 call->rxtx_buffer[i] = NULL;
475         }
476 
477         _leave("");
478 }
479 
480 /*
481  * release all the calls associated with a socket
482  */
483 void rxrpc_release_calls_on_socket(struct rxrpc_sock *rx)
484 {
485         struct rxrpc_call *call;
486 
487         _enter("%p", rx);
488 
489         while (!list_empty(&rx->to_be_accepted)) {
490                 call = list_entry(rx->to_be_accepted.next,
491                                   struct rxrpc_call, accept_link);
492                 list_del(&call->accept_link);
493                 rxrpc_abort_call("SKR", call, 0, RX_CALL_DEAD, ECONNRESET);
494                 rxrpc_put_call(call, rxrpc_call_put);
495         }
496 
497         while (!list_empty(&rx->sock_calls)) {
498                 call = list_entry(rx->sock_calls.next,
499                                   struct rxrpc_call, sock_link);
500                 rxrpc_get_call(call, rxrpc_call_got);
501                 rxrpc_abort_call("SKT", call, 0, RX_CALL_DEAD, ECONNRESET);
502                 rxrpc_send_abort_packet(call);
503                 rxrpc_release_call(rx, call);
504                 rxrpc_put_call(call, rxrpc_call_put);
505         }
506 
507         _leave("");
508 }
509 
510 /*
511  * release a call
512  */
513 void rxrpc_put_call(struct rxrpc_call *call, enum rxrpc_call_trace op)
514 {
515         const void *here = __builtin_return_address(0);
516         int n;
517 
518         ASSERT(call != NULL);
519 
520         n = atomic_dec_return(&call->usage);
521         trace_rxrpc_call(call, op, n, here, NULL);
522         ASSERTCMP(n, >=, 0);
523         if (n == 0) {
524                 _debug("call %d dead", call->debug_id);
525                 ASSERTCMP(call->state, ==, RXRPC_CALL_COMPLETE);
526 
527                 write_lock(&rxrpc_call_lock);
528                 list_del_init(&call->link);
529                 write_unlock(&rxrpc_call_lock);
530 
531                 rxrpc_cleanup_call(call);
532         }
533 }
534 
535 /*
536  * Final call destruction under RCU.
537  */
538 static void rxrpc_rcu_destroy_call(struct rcu_head *rcu)
539 {
540         struct rxrpc_call *call = container_of(rcu, struct rxrpc_call, rcu);
541 
542         rxrpc_put_peer(call->peer);
543         kfree(call->rxtx_buffer);
544         kfree(call->rxtx_annotations);
545         kmem_cache_free(rxrpc_call_jar, call);
546 }
547 
548 /*
549  * clean up a call
550  */
551 void rxrpc_cleanup_call(struct rxrpc_call *call)
552 {
553         int i;
554 
555         _net("DESTROY CALL %d", call->debug_id);
556 
557         memset(&call->sock_node, 0xcd, sizeof(call->sock_node));
558 
559         del_timer_sync(&call->timer);
560 
561         ASSERTCMP(call->state, ==, RXRPC_CALL_COMPLETE);
562         ASSERT(test_bit(RXRPC_CALL_RELEASED, &call->flags));
563         ASSERTCMP(call->conn, ==, NULL);
564 
565         /* Clean up the Rx/Tx buffer */
566         for (i = 0; i < RXRPC_RXTX_BUFF_SIZE; i++)
567                 rxrpc_free_skb(call->rxtx_buffer[i],
568                                (call->tx_phase ? rxrpc_skb_tx_cleaned :
569                                 rxrpc_skb_rx_cleaned));
570 
571         rxrpc_free_skb(call->tx_pending, rxrpc_skb_tx_cleaned);
572 
573         call_rcu(&call->rcu, rxrpc_rcu_destroy_call);
574 }
575 
576 /*
577  * Make sure that all calls are gone.
578  */
579 void __exit rxrpc_destroy_all_calls(void)
580 {
581         struct rxrpc_call *call;
582 
583         _enter("");
584 
585         if (list_empty(&rxrpc_calls))
586                 return;
587 
588         write_lock(&rxrpc_call_lock);
589 
590         while (!list_empty(&rxrpc_calls)) {
591                 call = list_entry(rxrpc_calls.next, struct rxrpc_call, link);
592                 _debug("Zapping call %p", call);
593 
594                 rxrpc_see_call(call);
595                 list_del_init(&call->link);
596 
597                 pr_err("Call %p still in use (%d,%s,%lx,%lx)!\n",
598                        call, atomic_read(&call->usage),
599                        rxrpc_call_states[call->state],
600                        call->flags, call->events);
601 
602                 write_unlock(&rxrpc_call_lock);
603                 cond_resched();
604                 write_lock(&rxrpc_call_lock);
605         }
606 
607         write_unlock(&rxrpc_call_lock);
608 }
609 

~ [ 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