1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* RxRPC individual remote procedure call handling
4 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 #include <linux/slab.h>
11 #include <linux/module.h>
12 #include <linux/circ_buf.h>
13 #include <linux/spinlock_types.h>
15 #include <net/af_rxrpc.h>
16 #include "ar-internal.h"
18 const char *const rxrpc_call_states
[NR__RXRPC_CALL_STATES
] = {
19 [RXRPC_CALL_UNINITIALISED
] = "Uninit ",
20 [RXRPC_CALL_CLIENT_AWAIT_CONN
] = "ClWtConn",
21 [RXRPC_CALL_CLIENT_SEND_REQUEST
] = "ClSndReq",
22 [RXRPC_CALL_CLIENT_AWAIT_REPLY
] = "ClAwtRpl",
23 [RXRPC_CALL_CLIENT_RECV_REPLY
] = "ClRcvRpl",
24 [RXRPC_CALL_SERVER_PREALLOC
] = "SvPrealc",
25 [RXRPC_CALL_SERVER_SECURING
] = "SvSecure",
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",
33 const char *const rxrpc_call_completions
[NR__RXRPC_CALL_COMPLETIONS
] = {
34 [RXRPC_CALL_SUCCEEDED
] = "Complete",
35 [RXRPC_CALL_REMOTELY_ABORTED
] = "RmtAbort",
36 [RXRPC_CALL_LOCALLY_ABORTED
] = "LocAbort",
37 [RXRPC_CALL_LOCAL_ERROR
] = "LocError",
38 [RXRPC_CALL_NETWORK_ERROR
] = "NetError",
41 struct kmem_cache
*rxrpc_call_jar
;
43 static struct semaphore rxrpc_call_limiter
=
44 __SEMAPHORE_INITIALIZER(rxrpc_call_limiter
, 1000);
45 static struct semaphore rxrpc_kernel_call_limiter
=
46 __SEMAPHORE_INITIALIZER(rxrpc_kernel_call_limiter
, 1000);
48 static void rxrpc_call_timer_expired(struct timer_list
*t
)
50 struct rxrpc_call
*call
= from_timer(call
, t
, timer
);
52 _enter("%d", call
->debug_id
);
54 if (call
->state
< RXRPC_CALL_COMPLETE
) {
55 trace_rxrpc_timer(call
, rxrpc_timer_expired
, jiffies
);
56 __rxrpc_queue_call(call
);
58 rxrpc_put_call(call
, rxrpc_call_put
);
62 void rxrpc_reduce_call_timer(struct rxrpc_call
*call
,
63 unsigned long expire_at
,
65 enum rxrpc_timer_trace why
)
67 if (rxrpc_try_get_call(call
, rxrpc_call_got_timer
)) {
68 trace_rxrpc_timer(call
, why
, now
);
69 if (timer_reduce(&call
->timer
, expire_at
))
70 rxrpc_put_call(call
, rxrpc_call_put_notimer
);
74 void rxrpc_delete_call_timer(struct rxrpc_call
*call
)
76 if (del_timer_sync(&call
->timer
))
77 rxrpc_put_call(call
, rxrpc_call_put_timer
);
80 static struct lock_class_key rxrpc_call_user_mutex_lock_class_key
;
83 * find an extant server call
84 * - called in process context with IRQs enabled
86 struct rxrpc_call
*rxrpc_find_call_by_user_ID(struct rxrpc_sock
*rx
,
87 unsigned long user_call_ID
)
89 struct rxrpc_call
*call
;
92 _enter("%p,%lx", rx
, user_call_ID
);
94 read_lock(&rx
->call_lock
);
96 p
= rx
->calls
.rb_node
;
98 call
= rb_entry(p
, struct rxrpc_call
, sock_node
);
100 if (user_call_ID
< call
->user_call_ID
)
102 else if (user_call_ID
> call
->user_call_ID
)
105 goto found_extant_call
;
108 read_unlock(&rx
->call_lock
);
113 rxrpc_get_call(call
, rxrpc_call_got
);
114 read_unlock(&rx
->call_lock
);
115 _leave(" = %p [%d]", call
, refcount_read(&call
->ref
));
120 * allocate a new call
122 struct rxrpc_call
*rxrpc_alloc_call(struct rxrpc_sock
*rx
, gfp_t gfp
,
123 unsigned int debug_id
)
125 struct rxrpc_call
*call
;
126 struct rxrpc_net
*rxnet
= rxrpc_net(sock_net(&rx
->sk
));
128 call
= kmem_cache_zalloc(rxrpc_call_jar
, gfp
);
132 call
->rxtx_buffer
= kcalloc(RXRPC_RXTX_BUFF_SIZE
,
133 sizeof(struct sk_buff
*),
135 if (!call
->rxtx_buffer
)
138 call
->rxtx_annotations
= kcalloc(RXRPC_RXTX_BUFF_SIZE
, sizeof(u8
), gfp
);
139 if (!call
->rxtx_annotations
)
142 mutex_init(&call
->user_mutex
);
144 /* Prevent lockdep reporting a deadlock false positive between the afs
145 * filesystem and sys_sendmsg() via the mmap sem.
147 if (rx
->sk
.sk_kern_sock
)
148 lockdep_set_class(&call
->user_mutex
,
149 &rxrpc_call_user_mutex_lock_class_key
);
151 timer_setup(&call
->timer
, rxrpc_call_timer_expired
, 0);
152 INIT_WORK(&call
->processor
, &rxrpc_process_call
);
153 INIT_LIST_HEAD(&call
->link
);
154 INIT_LIST_HEAD(&call
->chan_wait_link
);
155 INIT_LIST_HEAD(&call
->accept_link
);
156 INIT_LIST_HEAD(&call
->recvmsg_link
);
157 INIT_LIST_HEAD(&call
->sock_link
);
158 init_waitqueue_head(&call
->waitq
);
159 spin_lock_init(&call
->lock
);
160 spin_lock_init(&call
->notify_lock
);
161 spin_lock_init(&call
->input_lock
);
162 rwlock_init(&call
->state_lock
);
163 refcount_set(&call
->ref
, 1);
164 call
->debug_id
= debug_id
;
165 call
->tx_total_len
= -1;
166 call
->next_rx_timo
= 20 * HZ
;
167 call
->next_req_timo
= 1 * HZ
;
169 memset(&call
->sock_node
, 0xed, sizeof(call
->sock_node
));
171 /* Leave space in the ring to handle a maxed-out jumbo packet */
172 call
->rx_winsize
= rxrpc_rx_window_size
;
173 call
->tx_winsize
= 16;
174 call
->rx_expect_next
= 1;
177 call
->cong_ssthresh
= RXRPC_RXTX_BUFF_SIZE
- 1;
180 call
->rtt_avail
= RXRPC_CALL_RTT_AVAIL_MASK
;
181 atomic_inc(&rxnet
->nr_calls
);
185 kfree(call
->rxtx_buffer
);
187 kmem_cache_free(rxrpc_call_jar
, call
);
192 * Allocate a new client call.
194 static struct rxrpc_call
*rxrpc_alloc_client_call(struct rxrpc_sock
*rx
,
195 struct sockaddr_rxrpc
*srx
,
197 unsigned int debug_id
)
199 struct rxrpc_call
*call
;
204 call
= rxrpc_alloc_call(rx
, gfp
, debug_id
);
206 return ERR_PTR(-ENOMEM
);
207 call
->state
= RXRPC_CALL_CLIENT_AWAIT_CONN
;
208 call
->service_id
= srx
->srx_service
;
209 call
->tx_phase
= true;
210 now
= ktime_get_real();
211 call
->acks_latest_ts
= now
;
212 call
->cong_tstamp
= now
;
214 _leave(" = %p", call
);
219 * Initiate the call ack/resend/expiry timer.
221 static void rxrpc_start_call_timer(struct rxrpc_call
*call
)
223 unsigned long now
= jiffies
;
224 unsigned long j
= now
+ MAX_JIFFY_OFFSET
;
227 call
->ack_lost_at
= j
;
230 call
->expect_rx_by
= j
;
231 call
->expect_req_by
= j
;
232 call
->expect_term_by
= j
;
233 call
->timer
.expires
= now
;
237 * Wait for a call slot to become available.
239 static struct semaphore
*rxrpc_get_call_slot(struct rxrpc_call_params
*p
, gfp_t gfp
)
241 struct semaphore
*limiter
= &rxrpc_call_limiter
;
244 limiter
= &rxrpc_kernel_call_limiter
;
245 if (p
->interruptibility
== RXRPC_UNINTERRUPTIBLE
) {
249 return down_interruptible(limiter
) < 0 ? NULL
: limiter
;
253 * Release a call slot.
255 static void rxrpc_put_call_slot(struct rxrpc_call
*call
)
257 struct semaphore
*limiter
= &rxrpc_call_limiter
;
259 if (test_bit(RXRPC_CALL_KERNEL
, &call
->flags
))
260 limiter
= &rxrpc_kernel_call_limiter
;
265 * Set up a call for the given parameters.
266 * - Called with the socket lock held, which it must release.
267 * - If it returns a call, the call's lock will need releasing by the caller.
269 struct rxrpc_call
*rxrpc_new_client_call(struct rxrpc_sock
*rx
,
270 struct rxrpc_conn_parameters
*cp
,
271 struct sockaddr_rxrpc
*srx
,
272 struct rxrpc_call_params
*p
,
274 unsigned int debug_id
)
275 __releases(&rx
->sk
.sk_lock
.slock
)
276 __acquires(&call
->user_mutex
)
278 struct rxrpc_call
*call
, *xcall
;
279 struct rxrpc_net
*rxnet
;
280 struct semaphore
*limiter
;
281 struct rb_node
*parent
, **pp
;
282 const void *here
= __builtin_return_address(0);
285 _enter("%p,%lx", rx
, p
->user_call_ID
);
287 limiter
= rxrpc_get_call_slot(p
, gfp
);
289 return ERR_PTR(-ERESTARTSYS
);
291 call
= rxrpc_alloc_client_call(rx
, srx
, gfp
, debug_id
);
293 release_sock(&rx
->sk
);
295 _leave(" = %ld", PTR_ERR(call
));
299 call
->interruptibility
= p
->interruptibility
;
300 call
->tx_total_len
= p
->tx_total_len
;
301 trace_rxrpc_call(call
->debug_id
, rxrpc_call_new_client
,
302 refcount_read(&call
->ref
),
303 here
, (const void *)p
->user_call_ID
);
305 __set_bit(RXRPC_CALL_KERNEL
, &call
->flags
);
307 /* We need to protect a partially set up call against the user as we
308 * will be acting outside the socket lock.
310 mutex_lock(&call
->user_mutex
);
312 /* Publish the call, even though it is incompletely set up as yet */
313 write_lock(&rx
->call_lock
);
315 pp
= &rx
->calls
.rb_node
;
319 xcall
= rb_entry(parent
, struct rxrpc_call
, sock_node
);
321 if (p
->user_call_ID
< xcall
->user_call_ID
)
322 pp
= &(*pp
)->rb_left
;
323 else if (p
->user_call_ID
> xcall
->user_call_ID
)
324 pp
= &(*pp
)->rb_right
;
326 goto error_dup_user_ID
;
329 rcu_assign_pointer(call
->socket
, rx
);
330 call
->user_call_ID
= p
->user_call_ID
;
331 __set_bit(RXRPC_CALL_HAS_USERID
, &call
->flags
);
332 rxrpc_get_call(call
, rxrpc_call_got_userid
);
333 rb_link_node(&call
->sock_node
, parent
, pp
);
334 rb_insert_color(&call
->sock_node
, &rx
->calls
);
335 list_add(&call
->sock_link
, &rx
->sock_calls
);
337 write_unlock(&rx
->call_lock
);
340 spin_lock_bh(&rxnet
->call_lock
);
341 list_add_tail_rcu(&call
->link
, &rxnet
->calls
);
342 spin_unlock_bh(&rxnet
->call_lock
);
344 /* From this point on, the call is protected by its own lock. */
345 release_sock(&rx
->sk
);
347 /* Set up or get a connection record and set the protocol parameters,
348 * including channel number and call ID.
350 ret
= rxrpc_connect_call(rx
, call
, cp
, srx
, gfp
);
352 goto error_attached_to_socket
;
354 trace_rxrpc_call(call
->debug_id
, rxrpc_call_connected
,
355 refcount_read(&call
->ref
), here
, NULL
);
357 rxrpc_start_call_timer(call
);
359 _net("CALL new %d on CONN %d", call
->debug_id
, call
->conn
->debug_id
);
361 _leave(" = %p [new]", call
);
364 /* We unexpectedly found the user ID in the list after taking
365 * the call_lock. This shouldn't happen unless the user races
366 * with itself and tries to add the same user ID twice at the
367 * same time in different threads.
370 write_unlock(&rx
->call_lock
);
371 release_sock(&rx
->sk
);
372 __rxrpc_set_call_completion(call
, RXRPC_CALL_LOCAL_ERROR
,
373 RX_CALL_DEAD
, -EEXIST
);
374 trace_rxrpc_call(call
->debug_id
, rxrpc_call_error
,
375 refcount_read(&call
->ref
), here
, ERR_PTR(-EEXIST
));
376 rxrpc_release_call(rx
, call
);
377 mutex_unlock(&call
->user_mutex
);
378 rxrpc_put_call(call
, rxrpc_call_put
);
379 _leave(" = -EEXIST");
380 return ERR_PTR(-EEXIST
);
382 /* We got an error, but the call is attached to the socket and is in
383 * need of release. However, we might now race with recvmsg() when
384 * completing the call queues it. Return 0 from sys_sendmsg() and
385 * leave the error to recvmsg() to deal with.
387 error_attached_to_socket
:
388 trace_rxrpc_call(call
->debug_id
, rxrpc_call_error
,
389 refcount_read(&call
->ref
), here
, ERR_PTR(ret
));
390 set_bit(RXRPC_CALL_DISCONNECTED
, &call
->flags
);
391 __rxrpc_set_call_completion(call
, RXRPC_CALL_LOCAL_ERROR
,
393 _leave(" = c=%08x [err]", call
->debug_id
);
398 * Set up an incoming call. call->conn points to the connection.
399 * This is called in BH context and isn't allowed to fail.
401 void rxrpc_incoming_call(struct rxrpc_sock
*rx
,
402 struct rxrpc_call
*call
,
405 struct rxrpc_connection
*conn
= call
->conn
;
406 struct rxrpc_skb_priv
*sp
= rxrpc_skb(skb
);
409 _enter(",%d", call
->conn
->debug_id
);
411 rcu_assign_pointer(call
->socket
, rx
);
412 call
->call_id
= sp
->hdr
.callNumber
;
413 call
->service_id
= sp
->hdr
.serviceId
;
414 call
->cid
= sp
->hdr
.cid
;
415 call
->state
= RXRPC_CALL_SERVER_SECURING
;
416 call
->cong_tstamp
= skb
->tstamp
;
418 /* Set the channel for this call. We don't get channel_lock as we're
419 * only defending against the data_ready handler (which we're called
420 * from) and the RESPONSE packet parser (which is only really
421 * interested in call_counter and can cope with a disagreement with the
424 chan
= sp
->hdr
.cid
& RXRPC_CHANNELMASK
;
425 conn
->channels
[chan
].call_counter
= call
->call_id
;
426 conn
->channels
[chan
].call_id
= call
->call_id
;
427 rcu_assign_pointer(conn
->channels
[chan
].call
, call
);
429 spin_lock(&conn
->params
.peer
->lock
);
430 hlist_add_head_rcu(&call
->error_link
, &conn
->params
.peer
->error_targets
);
431 spin_unlock(&conn
->params
.peer
->lock
);
433 _net("CALL incoming %d on CONN %d", call
->debug_id
, call
->conn
->debug_id
);
435 rxrpc_start_call_timer(call
);
440 * Queue a call's work processor, getting a ref to pass to the work queue.
442 bool rxrpc_queue_call(struct rxrpc_call
*call
)
444 const void *here
= __builtin_return_address(0);
447 if (!__refcount_inc_not_zero(&call
->ref
, &n
))
449 if (rxrpc_queue_work(&call
->processor
))
450 trace_rxrpc_call(call
->debug_id
, rxrpc_call_queued
, n
+ 1,
453 rxrpc_put_call(call
, rxrpc_call_put_noqueue
);
458 * Queue a call's work processor, passing the callers ref to the work queue.
460 bool __rxrpc_queue_call(struct rxrpc_call
*call
)
462 const void *here
= __builtin_return_address(0);
463 int n
= refcount_read(&call
->ref
);
465 if (rxrpc_queue_work(&call
->processor
))
466 trace_rxrpc_call(call
->debug_id
, rxrpc_call_queued_ref
, n
,
469 rxrpc_put_call(call
, rxrpc_call_put_noqueue
);
474 * Note the re-emergence of a call.
476 void rxrpc_see_call(struct rxrpc_call
*call
)
478 const void *here
= __builtin_return_address(0);
480 int n
= refcount_read(&call
->ref
);
482 trace_rxrpc_call(call
->debug_id
, rxrpc_call_seen
, n
,
487 bool rxrpc_try_get_call(struct rxrpc_call
*call
, enum rxrpc_call_trace op
)
489 const void *here
= __builtin_return_address(0);
492 if (!__refcount_inc_not_zero(&call
->ref
, &n
))
494 trace_rxrpc_call(call
->debug_id
, op
, n
+ 1, here
, NULL
);
499 * Note the addition of a ref on a call.
501 void rxrpc_get_call(struct rxrpc_call
*call
, enum rxrpc_call_trace op
)
503 const void *here
= __builtin_return_address(0);
506 __refcount_inc(&call
->ref
, &n
);
507 trace_rxrpc_call(call
->debug_id
, op
, n
+ 1, here
, NULL
);
511 * Clean up the RxTx skb ring.
513 static void rxrpc_cleanup_ring(struct rxrpc_call
*call
)
517 for (i
= 0; i
< RXRPC_RXTX_BUFF_SIZE
; i
++) {
518 rxrpc_free_skb(call
->rxtx_buffer
[i
], rxrpc_skb_cleaned
);
519 call
->rxtx_buffer
[i
] = NULL
;
524 * Detach a call from its owning socket.
526 void rxrpc_release_call(struct rxrpc_sock
*rx
, struct rxrpc_call
*call
)
528 const void *here
= __builtin_return_address(0);
529 struct rxrpc_connection
*conn
= call
->conn
;
532 _enter("{%d,%d}", call
->debug_id
, refcount_read(&call
->ref
));
534 trace_rxrpc_call(call
->debug_id
, rxrpc_call_release
,
535 refcount_read(&call
->ref
),
536 here
, (const void *)call
->flags
);
538 ASSERTCMP(call
->state
, ==, RXRPC_CALL_COMPLETE
);
540 spin_lock_bh(&call
->lock
);
541 if (test_and_set_bit(RXRPC_CALL_RELEASED
, &call
->flags
))
543 spin_unlock_bh(&call
->lock
);
545 rxrpc_put_call_slot(call
);
546 rxrpc_delete_call_timer(call
);
548 /* Make sure we don't get any more notifications */
549 write_lock_bh(&rx
->recvmsg_lock
);
551 if (!list_empty(&call
->recvmsg_link
)) {
552 _debug("unlinking once-pending call %p { e=%lx f=%lx }",
553 call
, call
->events
, call
->flags
);
554 list_del(&call
->recvmsg_link
);
558 /* list_empty() must return false in rxrpc_notify_socket() */
559 call
->recvmsg_link
.next
= NULL
;
560 call
->recvmsg_link
.prev
= NULL
;
562 write_unlock_bh(&rx
->recvmsg_lock
);
564 rxrpc_put_call(call
, rxrpc_call_put
);
566 write_lock(&rx
->call_lock
);
568 if (test_and_clear_bit(RXRPC_CALL_HAS_USERID
, &call
->flags
)) {
569 rb_erase(&call
->sock_node
, &rx
->calls
);
570 memset(&call
->sock_node
, 0xdd, sizeof(call
->sock_node
));
571 rxrpc_put_call(call
, rxrpc_call_put_userid
);
574 list_del(&call
->sock_link
);
575 write_unlock(&rx
->call_lock
);
577 _debug("RELEASE CALL %p (%d CONN %p)", call
, call
->debug_id
, conn
);
579 if (conn
&& !test_bit(RXRPC_CALL_DISCONNECTED
, &call
->flags
))
580 rxrpc_disconnect_call(call
);
582 call
->security
->free_call_crypto(call
);
587 * release all the calls associated with a socket
589 void rxrpc_release_calls_on_socket(struct rxrpc_sock
*rx
)
591 struct rxrpc_call
*call
;
595 while (!list_empty(&rx
->to_be_accepted
)) {
596 call
= list_entry(rx
->to_be_accepted
.next
,
597 struct rxrpc_call
, accept_link
);
598 list_del(&call
->accept_link
);
599 rxrpc_abort_call("SKR", call
, 0, RX_CALL_DEAD
, -ECONNRESET
);
600 rxrpc_put_call(call
, rxrpc_call_put
);
603 while (!list_empty(&rx
->sock_calls
)) {
604 call
= list_entry(rx
->sock_calls
.next
,
605 struct rxrpc_call
, sock_link
);
606 rxrpc_get_call(call
, rxrpc_call_got
);
607 rxrpc_abort_call("SKT", call
, 0, RX_CALL_DEAD
, -ECONNRESET
);
608 rxrpc_send_abort_packet(call
);
609 rxrpc_release_call(rx
, call
);
610 rxrpc_put_call(call
, rxrpc_call_put
);
619 void rxrpc_put_call(struct rxrpc_call
*call
, enum rxrpc_call_trace op
)
621 struct rxrpc_net
*rxnet
= call
->rxnet
;
622 const void *here
= __builtin_return_address(0);
623 unsigned int debug_id
= call
->debug_id
;
627 ASSERT(call
!= NULL
);
629 dead
= __refcount_dec_and_test(&call
->ref
, &n
);
630 trace_rxrpc_call(debug_id
, op
, n
, here
, NULL
);
632 _debug("call %d dead", call
->debug_id
);
633 ASSERTCMP(call
->state
, ==, RXRPC_CALL_COMPLETE
);
635 if (!list_empty(&call
->link
)) {
636 spin_lock_bh(&rxnet
->call_lock
);
637 list_del_init(&call
->link
);
638 spin_unlock_bh(&rxnet
->call_lock
);
641 rxrpc_cleanup_call(call
);
646 * Final call destruction - but must be done in process context.
648 static void rxrpc_destroy_call(struct work_struct
*work
)
650 struct rxrpc_call
*call
= container_of(work
, struct rxrpc_call
, processor
);
651 struct rxrpc_net
*rxnet
= call
->rxnet
;
653 rxrpc_delete_call_timer(call
);
655 rxrpc_put_connection(call
->conn
);
656 rxrpc_put_peer(call
->peer
);
657 kfree(call
->rxtx_buffer
);
658 kfree(call
->rxtx_annotations
);
659 kmem_cache_free(rxrpc_call_jar
, call
);
660 if (atomic_dec_and_test(&rxnet
->nr_calls
))
661 wake_up_var(&rxnet
->nr_calls
);
665 * Final call destruction under RCU.
667 static void rxrpc_rcu_destroy_call(struct rcu_head
*rcu
)
669 struct rxrpc_call
*call
= container_of(rcu
, struct rxrpc_call
, rcu
);
672 INIT_WORK(&call
->processor
, rxrpc_destroy_call
);
673 if (!rxrpc_queue_work(&call
->processor
))
676 rxrpc_destroy_call(&call
->processor
);
683 void rxrpc_cleanup_call(struct rxrpc_call
*call
)
685 _net("DESTROY CALL %d", call
->debug_id
);
687 memset(&call
->sock_node
, 0xcd, sizeof(call
->sock_node
));
689 ASSERTCMP(call
->state
, ==, RXRPC_CALL_COMPLETE
);
690 ASSERT(test_bit(RXRPC_CALL_RELEASED
, &call
->flags
));
692 rxrpc_cleanup_ring(call
);
693 rxrpc_free_skb(call
->tx_pending
, rxrpc_skb_cleaned
);
695 call_rcu(&call
->rcu
, rxrpc_rcu_destroy_call
);
699 * Make sure that all calls are gone from a network namespace. To reach this
700 * point, any open UDP sockets in that namespace must have been closed, so any
701 * outstanding calls cannot be doing I/O.
703 void rxrpc_destroy_all_calls(struct rxrpc_net
*rxnet
)
705 struct rxrpc_call
*call
;
709 if (!list_empty(&rxnet
->calls
)) {
710 spin_lock_bh(&rxnet
->call_lock
);
712 while (!list_empty(&rxnet
->calls
)) {
713 call
= list_entry(rxnet
->calls
.next
,
714 struct rxrpc_call
, link
);
715 _debug("Zapping call %p", call
);
717 rxrpc_see_call(call
);
718 list_del_init(&call
->link
);
720 pr_err("Call %p still in use (%d,%s,%lx,%lx)!\n",
721 call
, refcount_read(&call
->ref
),
722 rxrpc_call_states
[call
->state
],
723 call
->flags
, call
->events
);
725 spin_unlock_bh(&rxnet
->call_lock
);
727 spin_lock_bh(&rxnet
->call_lock
);
730 spin_unlock_bh(&rxnet
->call_lock
);
733 atomic_dec(&rxnet
->nr_calls
);
734 wait_var_event(&rxnet
->nr_calls
, !atomic_read(&rxnet
->nr_calls
));