12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
28c3e34a4SDavid Howells /* RxRPC individual remote procedure call handling
38c3e34a4SDavid Howells *
48c3e34a4SDavid Howells * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
58c3e34a4SDavid Howells * Written by David Howells (dhowells@redhat.com)
68c3e34a4SDavid Howells */
78c3e34a4SDavid Howells
88c3e34a4SDavid Howells #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
98c3e34a4SDavid Howells
108c3e34a4SDavid Howells #include <linux/slab.h>
118c3e34a4SDavid Howells #include <linux/module.h>
128c3e34a4SDavid Howells #include <linux/circ_buf.h>
138c3e34a4SDavid Howells #include <linux/spinlock_types.h>
148c3e34a4SDavid Howells #include <net/sock.h>
158c3e34a4SDavid Howells #include <net/af_rxrpc.h>
168c3e34a4SDavid Howells #include "ar-internal.h"
178c3e34a4SDavid Howells
188c3e34a4SDavid Howells const char *const rxrpc_call_states[NR__RXRPC_CALL_STATES] = {
19999b69f8SDavid Howells [RXRPC_CALL_UNINITIALISED] = "Uninit ",
20999b69f8SDavid Howells [RXRPC_CALL_CLIENT_AWAIT_CONN] = "ClWtConn",
218c3e34a4SDavid Howells [RXRPC_CALL_CLIENT_SEND_REQUEST] = "ClSndReq",
228c3e34a4SDavid Howells [RXRPC_CALL_CLIENT_AWAIT_REPLY] = "ClAwtRpl",
238c3e34a4SDavid Howells [RXRPC_CALL_CLIENT_RECV_REPLY] = "ClRcvRpl",
2400e90712SDavid Howells [RXRPC_CALL_SERVER_PREALLOC] = "SvPrealc",
258c3e34a4SDavid Howells [RXRPC_CALL_SERVER_SECURING] = "SvSecure",
268c3e34a4SDavid Howells [RXRPC_CALL_SERVER_RECV_REQUEST] = "SvRcvReq",
278c3e34a4SDavid Howells [RXRPC_CALL_SERVER_ACK_REQUEST] = "SvAckReq",
288c3e34a4SDavid Howells [RXRPC_CALL_SERVER_SEND_REPLY] = "SvSndRpl",
298c3e34a4SDavid Howells [RXRPC_CALL_SERVER_AWAIT_ACK] = "SvAwtACK",
308c3e34a4SDavid Howells [RXRPC_CALL_COMPLETE] = "Complete",
31f5c17aaeSDavid Howells };
32f5c17aaeSDavid Howells
33f5c17aaeSDavid Howells const char *const rxrpc_call_completions[NR__RXRPC_CALL_COMPLETIONS] = {
34f5c17aaeSDavid Howells [RXRPC_CALL_SUCCEEDED] = "Complete",
358c3e34a4SDavid Howells [RXRPC_CALL_REMOTELY_ABORTED] = "RmtAbort",
368c3e34a4SDavid Howells [RXRPC_CALL_LOCALLY_ABORTED] = "LocAbort",
37f5c17aaeSDavid Howells [RXRPC_CALL_LOCAL_ERROR] = "LocError",
388c3e34a4SDavid Howells [RXRPC_CALL_NETWORK_ERROR] = "NetError",
398c3e34a4SDavid Howells };
408c3e34a4SDavid Howells
418c3e34a4SDavid Howells struct kmem_cache *rxrpc_call_jar;
428c3e34a4SDavid Howells
4348380368SPeter Zijlstra static DEFINE_SEMAPHORE(rxrpc_call_limiter, 1000);
4448380368SPeter Zijlstra static DEFINE_SEMAPHORE(rxrpc_kernel_call_limiter, 1000);
45b7a7d674SDavid Howells
rxrpc_poke_call(struct rxrpc_call * call,enum rxrpc_call_poke_trace what)4615f661dcSDavid Howells void rxrpc_poke_call(struct rxrpc_call *call, enum rxrpc_call_poke_trace what)
4715f661dcSDavid Howells {
48f3441d41SDavid Howells struct rxrpc_local *local = call->local;
4915f661dcSDavid Howells bool busy;
5015f661dcSDavid Howells
5103fc55adSDavid Howells if (!test_bit(RXRPC_CALL_DISCONNECTED, &call->flags)) {
5215f661dcSDavid Howells spin_lock_bh(&local->lock);
5315f661dcSDavid Howells busy = !list_empty(&call->attend_link);
5415f661dcSDavid Howells trace_rxrpc_poke_call(call, busy, what);
55a33395abSDavid Howells if (!busy && !rxrpc_try_get_call(call, rxrpc_call_get_poke))
56a33395abSDavid Howells busy = true;
5715f661dcSDavid Howells if (!busy) {
5815f661dcSDavid Howells list_add_tail(&call->attend_link, &local->call_attend_q);
5915f661dcSDavid Howells }
6015f661dcSDavid Howells spin_unlock_bh(&local->lock);
61a33395abSDavid Howells if (!busy)
6215f661dcSDavid Howells rxrpc_wake_up_io_thread(local);
6315f661dcSDavid Howells }
6415f661dcSDavid Howells }
6515f661dcSDavid Howells
rxrpc_call_timer_expired(struct timer_list * t)66e99e88a9SKees Cook static void rxrpc_call_timer_expired(struct timer_list *t)
67248f219cSDavid Howells {
68e99e88a9SKees Cook struct rxrpc_call *call = from_timer(call, t, timer);
69248f219cSDavid Howells
70248f219cSDavid Howells _enter("%d", call->debug_id);
71248f219cSDavid Howells
7296b4059fSDavid Howells if (!__rxrpc_call_is_complete(call)) {
73334dfbfcSDavid Howells trace_rxrpc_timer_expired(call, jiffies);
745e6ef4f1SDavid Howells rxrpc_poke_call(call, rxrpc_call_poke_timer);
75fc7ab6d2SDavid Howells }
76248f219cSDavid Howells }
778c3e34a4SDavid Howells
rxrpc_reduce_call_timer(struct rxrpc_call * call,unsigned long expire_at,unsigned long now,enum rxrpc_timer_trace why)784a7f62f9SDavid Howells void rxrpc_reduce_call_timer(struct rxrpc_call *call,
794a7f62f9SDavid Howells unsigned long expire_at,
804a7f62f9SDavid Howells unsigned long now,
814a7f62f9SDavid Howells enum rxrpc_timer_trace why)
824a7f62f9SDavid Howells {
834a7f62f9SDavid Howells trace_rxrpc_timer(call, why, now);
843feda9d6SDavid Howells timer_reduce(&call->timer, expire_at);
854a7f62f9SDavid Howells }
864a7f62f9SDavid Howells
879faaff59SDavid Howells static struct lock_class_key rxrpc_call_user_mutex_lock_class_key;
888c3e34a4SDavid Howells
893feda9d6SDavid Howells static void rxrpc_destroy_call(struct work_struct *);
903feda9d6SDavid Howells
918c3e34a4SDavid Howells /*
928c3e34a4SDavid Howells * find an extant server call
938c3e34a4SDavid Howells * - called in process context with IRQs enabled
948c3e34a4SDavid Howells */
rxrpc_find_call_by_user_ID(struct rxrpc_sock * rx,unsigned long user_call_ID)958c3e34a4SDavid Howells struct rxrpc_call *rxrpc_find_call_by_user_ID(struct rxrpc_sock *rx,
968c3e34a4SDavid Howells unsigned long user_call_ID)
978c3e34a4SDavid Howells {
988c3e34a4SDavid Howells struct rxrpc_call *call;
998c3e34a4SDavid Howells struct rb_node *p;
1008c3e34a4SDavid Howells
1018c3e34a4SDavid Howells _enter("%p,%lx", rx, user_call_ID);
1028c3e34a4SDavid Howells
1038c3e34a4SDavid Howells read_lock(&rx->call_lock);
1048c3e34a4SDavid Howells
1058c3e34a4SDavid Howells p = rx->calls.rb_node;
1068c3e34a4SDavid Howells while (p) {
1078c3e34a4SDavid Howells call = rb_entry(p, struct rxrpc_call, sock_node);
1088c3e34a4SDavid Howells
1098c3e34a4SDavid Howells if (user_call_ID < call->user_call_ID)
1108c3e34a4SDavid Howells p = p->rb_left;
1118c3e34a4SDavid Howells else if (user_call_ID > call->user_call_ID)
1128c3e34a4SDavid Howells p = p->rb_right;
1138c3e34a4SDavid Howells else
1148c3e34a4SDavid Howells goto found_extant_call;
1158c3e34a4SDavid Howells }
1168c3e34a4SDavid Howells
1178c3e34a4SDavid Howells read_unlock(&rx->call_lock);
1188c3e34a4SDavid Howells _leave(" = NULL");
1198c3e34a4SDavid Howells return NULL;
1208c3e34a4SDavid Howells
1218c3e34a4SDavid Howells found_extant_call:
122cb0fc0c9SDavid Howells rxrpc_get_call(call, rxrpc_call_get_sendmsg);
1238c3e34a4SDavid Howells read_unlock(&rx->call_lock);
124a0575429SDavid Howells _leave(" = %p [%d]", call, refcount_read(&call->ref));
1258c3e34a4SDavid Howells return call;
1268c3e34a4SDavid Howells }
1278c3e34a4SDavid Howells
1288c3e34a4SDavid Howells /*
1298c3e34a4SDavid Howells * allocate a new call
1308c3e34a4SDavid Howells */
rxrpc_alloc_call(struct rxrpc_sock * rx,gfp_t gfp,unsigned int debug_id)131a25e21f0SDavid Howells struct rxrpc_call *rxrpc_alloc_call(struct rxrpc_sock *rx, gfp_t gfp,
132a25e21f0SDavid Howells unsigned int debug_id)
1338c3e34a4SDavid Howells {
1348c3e34a4SDavid Howells struct rxrpc_call *call;
135d3be4d24SDavid Howells struct rxrpc_net *rxnet = rxrpc_net(sock_net(&rx->sk));
1368c3e34a4SDavid Howells
1378c3e34a4SDavid Howells call = kmem_cache_zalloc(rxrpc_call_jar, gfp);
1388c3e34a4SDavid Howells if (!call)
1398c3e34a4SDavid Howells return NULL;
1408c3e34a4SDavid Howells
141540b1c48SDavid Howells mutex_init(&call->user_mutex);
1429faaff59SDavid Howells
1439faaff59SDavid Howells /* Prevent lockdep reporting a deadlock false positive between the afs
1449faaff59SDavid Howells * filesystem and sys_sendmsg() via the mmap sem.
1459faaff59SDavid Howells */
1469faaff59SDavid Howells if (rx->sk.sk_kern_sock)
1479faaff59SDavid Howells lockdep_set_class(&call->user_mutex,
1489faaff59SDavid Howells &rxrpc_call_user_mutex_lock_class_key);
1499faaff59SDavid Howells
150e99e88a9SKees Cook timer_setup(&call->timer, rxrpc_call_timer_expired, 0);
1513feda9d6SDavid Howells INIT_WORK(&call->destroyer, rxrpc_destroy_call);
152999b69f8SDavid Howells INIT_LIST_HEAD(&call->link);
1539d35d880SDavid Howells INIT_LIST_HEAD(&call->wait_link);
1548c3e34a4SDavid Howells INIT_LIST_HEAD(&call->accept_link);
155248f219cSDavid Howells INIT_LIST_HEAD(&call->recvmsg_link);
156248f219cSDavid Howells INIT_LIST_HEAD(&call->sock_link);
15715f661dcSDavid Howells INIT_LIST_HEAD(&call->attend_link);
158cf37b598SDavid Howells INIT_LIST_HEAD(&call->tx_sendmsg);
159a4ea4c47SDavid Howells INIT_LIST_HEAD(&call->tx_buffer);
1605d7edbc9SDavid Howells skb_queue_head_init(&call->recvmsg_queue);
1615d7edbc9SDavid Howells skb_queue_head_init(&call->rx_oos_queue);
16245025bceSDavid Howells init_waitqueue_head(&call->waitq);
16320acbd9aSDavid Howells spin_lock_init(&call->notify_lock);
164a4ea4c47SDavid Howells spin_lock_init(&call->tx_lock);
165a0575429SDavid Howells refcount_set(&call->ref, 1);
166a25e21f0SDavid Howells call->debug_id = debug_id;
167e754eba6SDavid Howells call->tx_total_len = -1;
168a158bdd3SDavid Howells call->next_rx_timo = 20 * HZ;
169a158bdd3SDavid Howells call->next_req_timo = 1 * HZ;
1705bbf9533SDavid Howells call->ackr_window = 1;
1715bbf9533SDavid Howells call->ackr_wtop = 1;
1728c3e34a4SDavid Howells
1738c3e34a4SDavid Howells memset(&call->sock_node, 0xed, sizeof(call->sock_node));
1748c3e34a4SDavid Howells
17575e42126SDavid Howells call->rx_winsize = rxrpc_rx_window_size;
176248f219cSDavid Howells call->tx_winsize = 16;
17757494343SDavid Howells
178fa6dbe25SDavid Howells call->cong_cwnd = RXRPC_MIN_CWND;
179a4ea4c47SDavid Howells call->cong_ssthresh = RXRPC_TX_MAX_WINDOW;
180d3be4d24SDavid Howells
181d3be4d24SDavid Howells call->rxnet = rxnet;
1824700c4d8SDavid Howells call->rtt_avail = RXRPC_CALL_RTT_AVAIL_MASK;
183d3be4d24SDavid Howells atomic_inc(&rxnet->nr_calls);
1848c3e34a4SDavid Howells return call;
1858c3e34a4SDavid Howells }
1868c3e34a4SDavid Howells
1878c3e34a4SDavid Howells /*
188999b69f8SDavid Howells * Allocate a new client call.
1898c3e34a4SDavid Howells */
rxrpc_alloc_client_call(struct rxrpc_sock * rx,struct sockaddr_rxrpc * srx,struct rxrpc_conn_parameters * cp,struct rxrpc_call_params * p,gfp_t gfp,unsigned int debug_id)1909faaff59SDavid Howells static struct rxrpc_call *rxrpc_alloc_client_call(struct rxrpc_sock *rx,
1919faaff59SDavid Howells struct sockaddr_rxrpc *srx,
192f3441d41SDavid Howells struct rxrpc_conn_parameters *cp,
193f3441d41SDavid Howells struct rxrpc_call_params *p,
194a25e21f0SDavid Howells gfp_t gfp,
195a25e21f0SDavid Howells unsigned int debug_id)
1968c3e34a4SDavid Howells {
1978c3e34a4SDavid Howells struct rxrpc_call *call;
19857494343SDavid Howells ktime_t now;
199f3441d41SDavid Howells int ret;
2008c3e34a4SDavid Howells
2018c3e34a4SDavid Howells _enter("");
2028c3e34a4SDavid Howells
203a25e21f0SDavid Howells call = rxrpc_alloc_call(rx, gfp, debug_id);
2048c3e34a4SDavid Howells if (!call)
2058c3e34a4SDavid Howells return ERR_PTR(-ENOMEM);
20657494343SDavid Howells now = ktime_get_real();
20757494343SDavid Howells call->acks_latest_ts = now;
20857494343SDavid Howells call->cong_tstamp = now;
209f3441d41SDavid Howells call->dest_srx = *srx;
210f3441d41SDavid Howells call->interruptibility = p->interruptibility;
211f3441d41SDavid Howells call->tx_total_len = p->tx_total_len;
212f3441d41SDavid Howells call->key = key_get(cp->key);
213f3441d41SDavid Howells call->local = rxrpc_get_local(cp->local, rxrpc_local_get_call);
214fdb99487SDavid Howells call->security_level = cp->security_level;
215f3441d41SDavid Howells if (p->kernel)
216f3441d41SDavid Howells __set_bit(RXRPC_CALL_KERNEL, &call->flags);
217f3441d41SDavid Howells if (cp->upgrade)
218f3441d41SDavid Howells __set_bit(RXRPC_CALL_UPGRADE, &call->flags);
219f3441d41SDavid Howells if (cp->exclusive)
220f3441d41SDavid Howells __set_bit(RXRPC_CALL_EXCLUSIVE, &call->flags);
221f3441d41SDavid Howells
222db099c62SDavid Howells if (p->timeouts.normal)
223db099c62SDavid Howells call->next_rx_timo = min(msecs_to_jiffies(p->timeouts.normal), 1UL);
224db099c62SDavid Howells if (p->timeouts.idle)
225db099c62SDavid Howells call->next_req_timo = min(msecs_to_jiffies(p->timeouts.idle), 1UL);
226db099c62SDavid Howells if (p->timeouts.hard)
227db099c62SDavid Howells call->hard_timo = p->timeouts.hard * HZ;
228db099c62SDavid Howells
229f3441d41SDavid Howells ret = rxrpc_init_client_call_security(call);
230f3441d41SDavid Howells if (ret < 0) {
23196b4059fSDavid Howells rxrpc_prefail_call(call, RXRPC_CALL_LOCAL_ERROR, ret);
232f3441d41SDavid Howells rxrpc_put_call(call, rxrpc_call_put_discard_error);
233f3441d41SDavid Howells return ERR_PTR(ret);
234f3441d41SDavid Howells }
235f3441d41SDavid Howells
23696b4059fSDavid Howells rxrpc_set_call_state(call, RXRPC_CALL_CLIENT_AWAIT_CONN);
23796b4059fSDavid Howells
238f3441d41SDavid Howells trace_rxrpc_call(call->debug_id, refcount_read(&call->ref),
239f3441d41SDavid Howells p->user_call_ID, rxrpc_call_new_client);
240999b69f8SDavid Howells
241999b69f8SDavid Howells _leave(" = %p", call);
242999b69f8SDavid Howells return call;
243999b69f8SDavid Howells }
244999b69f8SDavid Howells
245999b69f8SDavid Howells /*
246248f219cSDavid Howells * Initiate the call ack/resend/expiry timer.
247999b69f8SDavid Howells */
rxrpc_start_call_timer(struct rxrpc_call * call)2489d35d880SDavid Howells void rxrpc_start_call_timer(struct rxrpc_call *call)
249999b69f8SDavid Howells {
250a158bdd3SDavid Howells unsigned long now = jiffies;
251a158bdd3SDavid Howells unsigned long j = now + MAX_JIFFY_OFFSET;
252999b69f8SDavid Howells
253530403d9SDavid Howells call->delay_ack_at = j;
254bd1fdf8cSDavid Howells call->ack_lost_at = j;
255a158bdd3SDavid Howells call->resend_at = j;
256a158bdd3SDavid Howells call->ping_at = j;
2575e6ef4f1SDavid Howells call->keepalive_at = j;
258a158bdd3SDavid Howells call->expect_rx_by = j;
259a158bdd3SDavid Howells call->expect_req_by = j;
260db099c62SDavid Howells call->expect_term_by = j + call->hard_timo;
261a158bdd3SDavid Howells call->timer.expires = now;
2628c3e34a4SDavid Howells }
2638c3e34a4SDavid Howells
2648c3e34a4SDavid Howells /*
265b7a7d674SDavid Howells * Wait for a call slot to become available.
266b7a7d674SDavid Howells */
rxrpc_get_call_slot(struct rxrpc_call_params * p,gfp_t gfp)267b7a7d674SDavid Howells static struct semaphore *rxrpc_get_call_slot(struct rxrpc_call_params *p, gfp_t gfp)
268b7a7d674SDavid Howells {
269b7a7d674SDavid Howells struct semaphore *limiter = &rxrpc_call_limiter;
270b7a7d674SDavid Howells
271b7a7d674SDavid Howells if (p->kernel)
272b7a7d674SDavid Howells limiter = &rxrpc_kernel_call_limiter;
273b7a7d674SDavid Howells if (p->interruptibility == RXRPC_UNINTERRUPTIBLE) {
274b7a7d674SDavid Howells down(limiter);
275b7a7d674SDavid Howells return limiter;
276b7a7d674SDavid Howells }
277b7a7d674SDavid Howells return down_interruptible(limiter) < 0 ? NULL : limiter;
278b7a7d674SDavid Howells }
279b7a7d674SDavid Howells
280b7a7d674SDavid Howells /*
281b7a7d674SDavid Howells * Release a call slot.
282b7a7d674SDavid Howells */
rxrpc_put_call_slot(struct rxrpc_call * call)283b7a7d674SDavid Howells static void rxrpc_put_call_slot(struct rxrpc_call *call)
284b7a7d674SDavid Howells {
285b7a7d674SDavid Howells struct semaphore *limiter = &rxrpc_call_limiter;
286b7a7d674SDavid Howells
287b7a7d674SDavid Howells if (test_bit(RXRPC_CALL_KERNEL, &call->flags))
288b7a7d674SDavid Howells limiter = &rxrpc_kernel_call_limiter;
289b7a7d674SDavid Howells up(limiter);
290b7a7d674SDavid Howells }
291b7a7d674SDavid Howells
292b7a7d674SDavid Howells /*
2939d35d880SDavid Howells * Start the process of connecting a call. We obtain a peer and a connection
2949d35d880SDavid Howells * bundle, but the actual association of a call with a connection is offloaded
2959d35d880SDavid Howells * to the I/O thread to simplify locking.
2969d35d880SDavid Howells */
rxrpc_connect_call(struct rxrpc_call * call,gfp_t gfp)2979d35d880SDavid Howells static int rxrpc_connect_call(struct rxrpc_call *call, gfp_t gfp)
2989d35d880SDavid Howells {
2999d35d880SDavid Howells struct rxrpc_local *local = call->local;
30001644a1fSDavid Howells int ret = -ENOMEM;
3019d35d880SDavid Howells
3029d35d880SDavid Howells _enter("{%d,%lx},", call->debug_id, call->user_call_ID);
3039d35d880SDavid Howells
3049d35d880SDavid Howells call->peer = rxrpc_lookup_peer(local, &call->dest_srx, gfp);
3059d35d880SDavid Howells if (!call->peer)
3069d35d880SDavid Howells goto error;
3079d35d880SDavid Howells
3089d35d880SDavid Howells ret = rxrpc_look_up_bundle(call, gfp);
3099d35d880SDavid Howells if (ret < 0)
3109d35d880SDavid Howells goto error;
3119d35d880SDavid Howells
3129d35d880SDavid Howells trace_rxrpc_client(NULL, -1, rxrpc_client_queue_new_call);
3139d35d880SDavid Howells rxrpc_get_call(call, rxrpc_call_get_io_thread);
3149d35d880SDavid Howells spin_lock(&local->client_call_lock);
3159d35d880SDavid Howells list_add_tail(&call->wait_link, &local->new_client_calls);
3169d35d880SDavid Howells spin_unlock(&local->client_call_lock);
3179d35d880SDavid Howells rxrpc_wake_up_io_thread(local);
3189d35d880SDavid Howells return 0;
3199d35d880SDavid Howells
3209d35d880SDavid Howells error:
3219d35d880SDavid Howells __set_bit(RXRPC_CALL_DISCONNECTED, &call->flags);
3229d35d880SDavid Howells return ret;
3239d35d880SDavid Howells }
3249d35d880SDavid Howells
3259d35d880SDavid Howells /*
326540b1c48SDavid Howells * Set up a call for the given parameters.
327540b1c48SDavid Howells * - Called with the socket lock held, which it must release.
328540b1c48SDavid Howells * - If it returns a call, the call's lock will need releasing by the caller.
3298c3e34a4SDavid Howells */
rxrpc_new_client_call(struct rxrpc_sock * rx,struct rxrpc_conn_parameters * cp,struct sockaddr_rxrpc * srx,struct rxrpc_call_params * p,gfp_t gfp,unsigned int debug_id)3308c3e34a4SDavid Howells struct rxrpc_call *rxrpc_new_client_call(struct rxrpc_sock *rx,
33119ffa01cSDavid Howells struct rxrpc_conn_parameters *cp,
332999b69f8SDavid Howells struct sockaddr_rxrpc *srx,
33348124178SDavid Howells struct rxrpc_call_params *p,
334a25e21f0SDavid Howells gfp_t gfp,
335a25e21f0SDavid Howells unsigned int debug_id)
336540b1c48SDavid Howells __releases(&rx->sk.sk_lock.slock)
33788f2a825SDavid Howells __acquires(&call->user_mutex)
3388c3e34a4SDavid Howells {
3398c3e34a4SDavid Howells struct rxrpc_call *call, *xcall;
340d3be4d24SDavid Howells struct rxrpc_net *rxnet;
341b7a7d674SDavid Howells struct semaphore *limiter;
3428c3e34a4SDavid Howells struct rb_node *parent, **pp;
343999b69f8SDavid Howells int ret;
3448c3e34a4SDavid Howells
34548124178SDavid Howells _enter("%p,%lx", rx, p->user_call_ID);
3468c3e34a4SDavid Howells
347b7a7d674SDavid Howells limiter = rxrpc_get_call_slot(p, gfp);
348b0f571ecSDavid Howells if (!limiter) {
349b0f571ecSDavid Howells release_sock(&rx->sk);
350b7a7d674SDavid Howells return ERR_PTR(-ERESTARTSYS);
351b0f571ecSDavid Howells }
352b7a7d674SDavid Howells
353f3441d41SDavid Howells call = rxrpc_alloc_client_call(rx, srx, cp, p, gfp, debug_id);
3548c3e34a4SDavid Howells if (IS_ERR(call)) {
355540b1c48SDavid Howells release_sock(&rx->sk);
356b7a7d674SDavid Howells up(limiter);
3578c3e34a4SDavid Howells _leave(" = %ld", PTR_ERR(call));
3588c3e34a4SDavid Howells return call;
3598c3e34a4SDavid Howells }
3608c3e34a4SDavid Howells
361540b1c48SDavid Howells /* We need to protect a partially set up call against the user as we
362540b1c48SDavid Howells * will be acting outside the socket lock.
363540b1c48SDavid Howells */
364540b1c48SDavid Howells mutex_lock(&call->user_mutex);
365540b1c48SDavid Howells
366999b69f8SDavid Howells /* Publish the call, even though it is incompletely set up as yet */
3678c3e34a4SDavid Howells write_lock(&rx->call_lock);
3688c3e34a4SDavid Howells
3698c3e34a4SDavid Howells pp = &rx->calls.rb_node;
3708c3e34a4SDavid Howells parent = NULL;
3718c3e34a4SDavid Howells while (*pp) {
3728c3e34a4SDavid Howells parent = *pp;
3738c3e34a4SDavid Howells xcall = rb_entry(parent, struct rxrpc_call, sock_node);
3748c3e34a4SDavid Howells
37548124178SDavid Howells if (p->user_call_ID < xcall->user_call_ID)
3768c3e34a4SDavid Howells pp = &(*pp)->rb_left;
37748124178SDavid Howells else if (p->user_call_ID > xcall->user_call_ID)
3788c3e34a4SDavid Howells pp = &(*pp)->rb_right;
3798c3e34a4SDavid Howells else
380357f5ef6SDavid Howells goto error_dup_user_ID;
3818c3e34a4SDavid Howells }
3828c3e34a4SDavid Howells
383248f219cSDavid Howells rcu_assign_pointer(call->socket, rx);
38448124178SDavid Howells call->user_call_ID = p->user_call_ID;
385357f5ef6SDavid Howells __set_bit(RXRPC_CALL_HAS_USERID, &call->flags);
386cb0fc0c9SDavid Howells rxrpc_get_call(call, rxrpc_call_get_userid);
3878c3e34a4SDavid Howells rb_link_node(&call->sock_node, parent, pp);
3888c3e34a4SDavid Howells rb_insert_color(&call->sock_node, &rx->calls);
389248f219cSDavid Howells list_add(&call->sock_link, &rx->sock_calls);
390248f219cSDavid Howells
3918c3e34a4SDavid Howells write_unlock(&rx->call_lock);
3928c3e34a4SDavid Howells
393d3be4d24SDavid Howells rxnet = call->rxnet;
3943dd9c8b5SDavid Howells spin_lock(&rxnet->call_lock);
395ad25f5cbSDavid Howells list_add_tail_rcu(&call->link, &rxnet->calls);
3963dd9c8b5SDavid Howells spin_unlock(&rxnet->call_lock);
3978c3e34a4SDavid Howells
398540b1c48SDavid Howells /* From this point on, the call is protected by its own lock. */
399540b1c48SDavid Howells release_sock(&rx->sk);
400540b1c48SDavid Howells
401248f219cSDavid Howells /* Set up or get a connection record and set the protocol parameters,
402248f219cSDavid Howells * including channel number and call ID.
403248f219cSDavid Howells */
4041bab27afSDavid Howells ret = rxrpc_connect_call(call, gfp);
405999b69f8SDavid Howells if (ret < 0)
40665550098SDavid Howells goto error_attached_to_socket;
407999b69f8SDavid Howells
4088c3e34a4SDavid Howells _leave(" = %p [new]", call);
4098c3e34a4SDavid Howells return call;
4108c3e34a4SDavid Howells
4118c3e34a4SDavid Howells /* We unexpectedly found the user ID in the list after taking
4128c3e34a4SDavid Howells * the call_lock. This shouldn't happen unless the user races
4138c3e34a4SDavid Howells * with itself and tries to add the same user ID twice at the
4148c3e34a4SDavid Howells * same time in different threads.
4158c3e34a4SDavid Howells */
416357f5ef6SDavid Howells error_dup_user_ID:
4178c3e34a4SDavid Howells write_unlock(&rx->call_lock);
418540b1c48SDavid Howells release_sock(&rx->sk);
41996b4059fSDavid Howells rxrpc_prefail_call(call, RXRPC_CALL_LOCAL_ERROR, -EEXIST);
420cb0fc0c9SDavid Howells trace_rxrpc_call(call->debug_id, refcount_read(&call->ref), 0,
421cb0fc0c9SDavid Howells rxrpc_call_see_userid_exists);
422540b1c48SDavid Howells mutex_unlock(&call->user_mutex);
423cb0fc0c9SDavid Howells rxrpc_put_call(call, rxrpc_call_put_userid_exists);
42465550098SDavid Howells _leave(" = -EEXIST");
42565550098SDavid Howells return ERR_PTR(-EEXIST);
42665550098SDavid Howells
42765550098SDavid Howells /* We got an error, but the call is attached to the socket and is in
4289d35d880SDavid Howells * need of release. However, we might now race with recvmsg() when it
4299d35d880SDavid Howells * completion notifies the socket. Return 0 from sys_sendmsg() and
43065550098SDavid Howells * leave the error to recvmsg() to deal with.
43165550098SDavid Howells */
43265550098SDavid Howells error_attached_to_socket:
433cb0fc0c9SDavid Howells trace_rxrpc_call(call->debug_id, refcount_read(&call->ref), ret,
434cb0fc0c9SDavid Howells rxrpc_call_see_connect_failed);
4359d35d880SDavid Howells rxrpc_set_call_completion(call, RXRPC_CALL_LOCAL_ERROR, 0, ret);
43665550098SDavid Howells _leave(" = c=%08x [err]", call->debug_id);
43765550098SDavid Howells return call;
4388c3e34a4SDavid Howells }
4398c3e34a4SDavid Howells
4408c3e34a4SDavid Howells /*
441248f219cSDavid Howells * Set up an incoming call. call->conn points to the connection.
442248f219cSDavid Howells * This is called in BH context and isn't allowed to fail.
4438c3e34a4SDavid Howells */
rxrpc_incoming_call(struct rxrpc_sock * rx,struct rxrpc_call * call,struct sk_buff * skb)444248f219cSDavid Howells void rxrpc_incoming_call(struct rxrpc_sock *rx,
445248f219cSDavid Howells struct rxrpc_call *call,
44642886ffeSDavid Howells struct sk_buff *skb)
4478c3e34a4SDavid Howells {
448248f219cSDavid Howells struct rxrpc_connection *conn = call->conn;
44942886ffeSDavid Howells struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
450248f219cSDavid Howells u32 chan;
4518c3e34a4SDavid Howells
452248f219cSDavid Howells _enter(",%d", call->conn->debug_id);
4538c3e34a4SDavid Howells
454248f219cSDavid Howells rcu_assign_pointer(call->socket, rx);
455248f219cSDavid Howells call->call_id = sp->hdr.callNumber;
456f3441d41SDavid Howells call->dest_srx.srx_service = sp->hdr.serviceId;
457248f219cSDavid Howells call->cid = sp->hdr.cid;
45857494343SDavid Howells call->cong_tstamp = skb->tstamp;
4598c3e34a4SDavid Howells
460a343b174SDavid Howells __set_bit(RXRPC_CALL_EXPOSED, &call->flags);
46196b4059fSDavid Howells rxrpc_set_call_state(call, RXRPC_CALL_SERVER_SECURING);
462a343b174SDavid Howells
4635e6ef4f1SDavid Howells spin_lock(&conn->state_lock);
4645e6ef4f1SDavid Howells
4655e6ef4f1SDavid Howells switch (conn->state) {
4665e6ef4f1SDavid Howells case RXRPC_CONN_SERVICE_UNSECURED:
4675e6ef4f1SDavid Howells case RXRPC_CONN_SERVICE_CHALLENGING:
46896b4059fSDavid Howells rxrpc_set_call_state(call, RXRPC_CALL_SERVER_SECURING);
4695e6ef4f1SDavid Howells break;
4705e6ef4f1SDavid Howells case RXRPC_CONN_SERVICE:
47196b4059fSDavid Howells rxrpc_set_call_state(call, RXRPC_CALL_SERVER_RECV_REQUEST);
4725e6ef4f1SDavid Howells break;
4735e6ef4f1SDavid Howells
474a00ce28bSDavid Howells case RXRPC_CONN_ABORTED:
47596b4059fSDavid Howells rxrpc_set_call_completion(call, conn->completion,
4765e6ef4f1SDavid Howells conn->abort_code, conn->error);
4775e6ef4f1SDavid Howells break;
4785e6ef4f1SDavid Howells default:
4795e6ef4f1SDavid Howells BUG();
4805e6ef4f1SDavid Howells }
4815e6ef4f1SDavid Howells
4825040011dSDavid Howells rxrpc_get_call(call, rxrpc_call_get_io_thread);
4835040011dSDavid Howells
484248f219cSDavid Howells /* Set the channel for this call. We don't get channel_lock as we're
485248f219cSDavid Howells * only defending against the data_ready handler (which we're called
486248f219cSDavid Howells * from) and the RESPONSE packet parser (which is only really
487248f219cSDavid Howells * interested in call_counter and can cope with a disagreement with the
488248f219cSDavid Howells * call pointer).
4898c3e34a4SDavid Howells */
490248f219cSDavid Howells chan = sp->hdr.cid & RXRPC_CHANNELMASK;
491248f219cSDavid Howells conn->channels[chan].call_counter = call->call_id;
492248f219cSDavid Howells conn->channels[chan].call_id = call->call_id;
4939d35d880SDavid Howells conn->channels[chan].call = call;
4945e6ef4f1SDavid Howells spin_unlock(&conn->state_lock);
4958c3e34a4SDavid Howells
4962cc80086SDavid Howells spin_lock(&conn->peer->lock);
49729fb4ec3SDavid Howells hlist_add_head(&call->error_link, &conn->peer->error_targets);
4982cc80086SDavid Howells spin_unlock(&conn->peer->lock);
4998c3e34a4SDavid Howells
500248f219cSDavid Howells rxrpc_start_call_timer(call);
501248f219cSDavid Howells _leave("");
5028c3e34a4SDavid Howells }
5038c3e34a4SDavid Howells
5048c3e34a4SDavid Howells /*
505e34d4234SDavid Howells * Note the re-emergence of a call.
506e34d4234SDavid Howells */
rxrpc_see_call(struct rxrpc_call * call,enum rxrpc_call_trace why)507cb0fc0c9SDavid Howells void rxrpc_see_call(struct rxrpc_call *call, enum rxrpc_call_trace why)
508e34d4234SDavid Howells {
509e34d4234SDavid Howells if (call) {
510cb0fc0c9SDavid Howells int r = refcount_read(&call->ref);
511e34d4234SDavid Howells
512cb0fc0c9SDavid Howells trace_rxrpc_call(call->debug_id, r, 0, why);
513e34d4234SDavid Howells }
514e34d4234SDavid Howells }
515e34d4234SDavid Howells
rxrpc_try_get_call(struct rxrpc_call * call,enum rxrpc_call_trace why)5165e6ef4f1SDavid Howells struct rxrpc_call *rxrpc_try_get_call(struct rxrpc_call *call,
5175e6ef4f1SDavid Howells enum rxrpc_call_trace why)
5184a7f62f9SDavid Howells {
519cb0fc0c9SDavid Howells int r;
5204a7f62f9SDavid Howells
5215e6ef4f1SDavid Howells if (!call || !__refcount_inc_not_zero(&call->ref, &r))
5225e6ef4f1SDavid Howells return NULL;
523cb0fc0c9SDavid Howells trace_rxrpc_call(call->debug_id, r + 1, 0, why);
5245e6ef4f1SDavid Howells return call;
5254a7f62f9SDavid Howells }
5264a7f62f9SDavid Howells
527e34d4234SDavid Howells /*
528e34d4234SDavid Howells * Note the addition of a ref on a call.
529e34d4234SDavid Howells */
rxrpc_get_call(struct rxrpc_call * call,enum rxrpc_call_trace why)530cb0fc0c9SDavid Howells void rxrpc_get_call(struct rxrpc_call *call, enum rxrpc_call_trace why)
531e34d4234SDavid Howells {
532cb0fc0c9SDavid Howells int r;
533e34d4234SDavid Howells
534cb0fc0c9SDavid Howells __refcount_inc(&call->ref, &r);
535cb0fc0c9SDavid Howells trace_rxrpc_call(call->debug_id, r + 1, 0, why);
536e34d4234SDavid Howells }
537e34d4234SDavid Howells
538e34d4234SDavid Howells /*
539a4ea4c47SDavid Howells * Clean up the Rx skb ring.
540a641fd00SDavid Howells */
rxrpc_cleanup_ring(struct rxrpc_call * call)541a641fd00SDavid Howells static void rxrpc_cleanup_ring(struct rxrpc_call *call)
542a641fd00SDavid Howells {
5432968901dSDavid Howells rxrpc_purge_queue(&call->recvmsg_queue);
5442968901dSDavid Howells rxrpc_purge_queue(&call->rx_oos_queue);
545a641fd00SDavid Howells }
546a641fd00SDavid Howells
547a641fd00SDavid Howells /*
548248f219cSDavid Howells * Detach a call from its owning socket.
5498c3e34a4SDavid Howells */
rxrpc_release_call(struct rxrpc_sock * rx,struct rxrpc_call * call)5508d94aa38SDavid Howells void rxrpc_release_call(struct rxrpc_sock *rx, struct rxrpc_call *call)
5518c3e34a4SDavid Howells {
552248f219cSDavid Howells struct rxrpc_connection *conn = call->conn;
5539d35d880SDavid Howells bool put = false, putu = false;
554248f219cSDavid Howells
555a0575429SDavid Howells _enter("{%d,%d}", call->debug_id, refcount_read(&call->ref));
556248f219cSDavid Howells
557cb0fc0c9SDavid Howells trace_rxrpc_call(call->debug_id, refcount_read(&call->ref),
558cb0fc0c9SDavid Howells call->flags, rxrpc_call_see_release);
5598c3e34a4SDavid Howells
5608c3e34a4SDavid Howells if (test_and_set_bit(RXRPC_CALL_RELEASED, &call->flags))
5618c3e34a4SDavid Howells BUG();
5628c3e34a4SDavid Howells
563b7a7d674SDavid Howells rxrpc_put_call_slot(call);
5648c3e34a4SDavid Howells
565248f219cSDavid Howells /* Make sure we don't get any more notifications */
566223f5901SDavid Howells spin_lock(&rx->recvmsg_lock);
567e653cfe4SDavid Howells
568248f219cSDavid Howells if (!list_empty(&call->recvmsg_link)) {
5698c3e34a4SDavid Howells _debug("unlinking once-pending call %p { e=%lx f=%lx }",
5708c3e34a4SDavid Howells call, call->events, call->flags);
571248f219cSDavid Howells list_del(&call->recvmsg_link);
572248f219cSDavid Howells put = true;
573248f219cSDavid Howells }
574248f219cSDavid Howells
575248f219cSDavid Howells /* list_empty() must return false in rxrpc_notify_socket() */
576248f219cSDavid Howells call->recvmsg_link.next = NULL;
577248f219cSDavid Howells call->recvmsg_link.prev = NULL;
578248f219cSDavid Howells
579223f5901SDavid Howells spin_unlock(&rx->recvmsg_lock);
580248f219cSDavid Howells if (put)
581cb0fc0c9SDavid Howells rxrpc_put_call(call, rxrpc_call_put_unnotify);
582248f219cSDavid Howells
583248f219cSDavid Howells write_lock(&rx->call_lock);
584248f219cSDavid Howells
585248f219cSDavid Howells if (test_and_clear_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
5868c3e34a4SDavid Howells rb_erase(&call->sock_node, &rx->calls);
5878c3e34a4SDavid Howells memset(&call->sock_node, 0xdd, sizeof(call->sock_node));
5889d35d880SDavid Howells putu = true;
5898c3e34a4SDavid Howells }
5908c3e34a4SDavid Howells
591248f219cSDavid Howells list_del(&call->sock_link);
592248f219cSDavid Howells write_unlock(&rx->call_lock);
5938c3e34a4SDavid Howells
594248f219cSDavid Howells _debug("RELEASE CALL %p (%d CONN %p)", call, call->debug_id, conn);
5958c3e34a4SDavid Howells
5969d35d880SDavid Howells if (putu)
5979d35d880SDavid Howells rxrpc_put_call(call, rxrpc_call_put_userid);
5989d35d880SDavid Howells
5998c3e34a4SDavid Howells _leave("");
6008c3e34a4SDavid Howells }
6018c3e34a4SDavid Howells
6028c3e34a4SDavid Howells /*
6038c3e34a4SDavid Howells * release all the calls associated with a socket
6048c3e34a4SDavid Howells */
rxrpc_release_calls_on_socket(struct rxrpc_sock * rx)6058c3e34a4SDavid Howells void rxrpc_release_calls_on_socket(struct rxrpc_sock *rx)
6068c3e34a4SDavid Howells {
6078c3e34a4SDavid Howells struct rxrpc_call *call;
6088c3e34a4SDavid Howells
6098c3e34a4SDavid Howells _enter("%p", rx);
6108c3e34a4SDavid Howells
6110360da6dSDavid Howells while (!list_empty(&rx->to_be_accepted)) {
6120360da6dSDavid Howells call = list_entry(rx->to_be_accepted.next,
6130360da6dSDavid Howells struct rxrpc_call, accept_link);
6140360da6dSDavid Howells list_del(&call->accept_link);
61557af281eSDavid Howells rxrpc_propose_abort(call, RX_CALL_DEAD, -ECONNRESET,
61657af281eSDavid Howells rxrpc_abort_call_sock_release_tba);
617cb0fc0c9SDavid Howells rxrpc_put_call(call, rxrpc_call_put_release_sock_tba);
6180360da6dSDavid Howells }
6190360da6dSDavid Howells
620248f219cSDavid Howells while (!list_empty(&rx->sock_calls)) {
621248f219cSDavid Howells call = list_entry(rx->sock_calls.next,
622248f219cSDavid Howells struct rxrpc_call, sock_link);
623cb0fc0c9SDavid Howells rxrpc_get_call(call, rxrpc_call_get_release_sock);
62457af281eSDavid Howells rxrpc_propose_abort(call, RX_CALL_DEAD, -ECONNRESET,
62557af281eSDavid Howells rxrpc_abort_call_sock_release);
6268d94aa38SDavid Howells rxrpc_release_call(rx, call);
627cb0fc0c9SDavid Howells rxrpc_put_call(call, rxrpc_call_put_release_sock);
6288c3e34a4SDavid Howells }
6298c3e34a4SDavid Howells
6308c3e34a4SDavid Howells _leave("");
6318c3e34a4SDavid Howells }
6328c3e34a4SDavid Howells
6338c3e34a4SDavid Howells /*
6348c3e34a4SDavid Howells * release a call
6358c3e34a4SDavid Howells */
rxrpc_put_call(struct rxrpc_call * call,enum rxrpc_call_trace why)636cb0fc0c9SDavid Howells void rxrpc_put_call(struct rxrpc_call *call, enum rxrpc_call_trace why)
6378c3e34a4SDavid Howells {
638d3be4d24SDavid Howells struct rxrpc_net *rxnet = call->rxnet;
63948c9e0ecSDavid Howells unsigned int debug_id = call->debug_id;
640a0575429SDavid Howells bool dead;
641cb0fc0c9SDavid Howells int r;
642e34d4234SDavid Howells
6438c3e34a4SDavid Howells ASSERT(call != NULL);
6448c3e34a4SDavid Howells
645cb0fc0c9SDavid Howells dead = __refcount_dec_and_test(&call->ref, &r);
646cb0fc0c9SDavid Howells trace_rxrpc_call(debug_id, r - 1, 0, why);
647a0575429SDavid Howells if (dead) {
64896b4059fSDavid Howells ASSERTCMP(__rxrpc_call_state(call), ==, RXRPC_CALL_COMPLETE);
649e34d4234SDavid Howells
6502baec2c3SDavid Howells if (!list_empty(&call->link)) {
6513dd9c8b5SDavid Howells spin_lock(&rxnet->call_lock);
652248f219cSDavid Howells list_del_init(&call->link);
6533dd9c8b5SDavid Howells spin_unlock(&rxnet->call_lock);
6542baec2c3SDavid Howells }
655e34d4234SDavid Howells
6568d94aa38SDavid Howells rxrpc_cleanup_call(call);
657e34d4234SDavid Howells }
6588c3e34a4SDavid Howells }
6598c3e34a4SDavid Howells
6608c3e34a4SDavid Howells /*
6613feda9d6SDavid Howells * Free up the call under RCU.
662dee46364SDavid Howells */
rxrpc_rcu_free_call(struct rcu_head * rcu)6633feda9d6SDavid Howells static void rxrpc_rcu_free_call(struct rcu_head *rcu)
664dee46364SDavid Howells {
6653feda9d6SDavid Howells struct rxrpc_call *call = container_of(rcu, struct rxrpc_call, rcu);
6663feda9d6SDavid Howells struct rxrpc_net *rxnet = READ_ONCE(call->rxnet);
667dee46364SDavid Howells
668dee46364SDavid Howells kmem_cache_free(rxrpc_call_jar, call);
669d3be4d24SDavid Howells if (atomic_dec_and_test(&rxnet->nr_calls))
6705bb053beSLinus Torvalds wake_up_var(&rxnet->nr_calls);
671dee46364SDavid Howells }
672dee46364SDavid Howells
673dee46364SDavid Howells /*
6743feda9d6SDavid Howells * Final call destruction - but must be done in process context.
675963485d4SDavid Howells */
rxrpc_destroy_call(struct work_struct * work)6763feda9d6SDavid Howells static void rxrpc_destroy_call(struct work_struct *work)
677963485d4SDavid Howells {
6783feda9d6SDavid Howells struct rxrpc_call *call = container_of(work, struct rxrpc_call, destroyer);
679a4ea4c47SDavid Howells struct rxrpc_txbuf *txb;
680a4ea4c47SDavid Howells
6813feda9d6SDavid Howells del_timer_sync(&call->timer);
6828c3e34a4SDavid Howells
683024b2511SDavid Howells rxrpc_free_skb(call->cong_last_nack, rxrpc_skb_put_last_nack);
684a641fd00SDavid Howells rxrpc_cleanup_ring(call);
685cf37b598SDavid Howells while ((txb = list_first_entry_or_null(&call->tx_sendmsg,
686cf37b598SDavid Howells struct rxrpc_txbuf, call_link))) {
687cf37b598SDavid Howells list_del(&txb->call_link);
688cf37b598SDavid Howells rxrpc_put_txbuf(txb, rxrpc_txbuf_put_cleaned);
689cf37b598SDavid Howells }
690a4ea4c47SDavid Howells while ((txb = list_first_entry_or_null(&call->tx_buffer,
691a4ea4c47SDavid Howells struct rxrpc_txbuf, call_link))) {
692a4ea4c47SDavid Howells list_del(&txb->call_link);
693a4ea4c47SDavid Howells rxrpc_put_txbuf(txb, rxrpc_txbuf_put_cleaned);
694a4ea4c47SDavid Howells }
6955e6ef4f1SDavid Howells
696a4ea4c47SDavid Howells rxrpc_put_txbuf(call->tx_pending, rxrpc_txbuf_put_cleaned);
6973feda9d6SDavid Howells rxrpc_put_connection(call->conn, rxrpc_conn_put_call);
6981bab27afSDavid Howells rxrpc_deactivate_bundle(call->bundle);
6991bab27afSDavid Howells rxrpc_put_bundle(call->bundle, rxrpc_bundle_put_call);
7003feda9d6SDavid Howells rxrpc_put_peer(call->peer, rxrpc_peer_put_call);
701f3441d41SDavid Howells rxrpc_put_local(call->local, rxrpc_local_put_call);
7023feda9d6SDavid Howells call_rcu(&call->rcu, rxrpc_rcu_free_call);
7033feda9d6SDavid Howells }
7048c3e34a4SDavid Howells
7053feda9d6SDavid Howells /*
7063feda9d6SDavid Howells * clean up a call
7073feda9d6SDavid Howells */
rxrpc_cleanup_call(struct rxrpc_call * call)7083feda9d6SDavid Howells void rxrpc_cleanup_call(struct rxrpc_call *call)
7093feda9d6SDavid Howells {
7103feda9d6SDavid Howells memset(&call->sock_node, 0xcd, sizeof(call->sock_node));
7113feda9d6SDavid Howells
71296b4059fSDavid Howells ASSERTCMP(__rxrpc_call_state(call), ==, RXRPC_CALL_COMPLETE);
7133feda9d6SDavid Howells ASSERT(test_bit(RXRPC_CALL_RELEASED, &call->flags));
7143feda9d6SDavid Howells
7155e6ef4f1SDavid Howells del_timer(&call->timer);
7163feda9d6SDavid Howells
7175e6ef4f1SDavid Howells if (rcu_read_lock_held())
7183feda9d6SDavid Howells /* Can't use the rxrpc workqueue as we need to cancel/flush
7193feda9d6SDavid Howells * something that may be running/waiting there.
7203feda9d6SDavid Howells */
7213feda9d6SDavid Howells schedule_work(&call->destroyer);
7223feda9d6SDavid Howells else
7233feda9d6SDavid Howells rxrpc_destroy_call(&call->destroyer);
7248c3e34a4SDavid Howells }
7258c3e34a4SDavid Howells
7268c3e34a4SDavid Howells /*
7272baec2c3SDavid Howells * Make sure that all calls are gone from a network namespace. To reach this
7282baec2c3SDavid Howells * point, any open UDP sockets in that namespace must have been closed, so any
7292baec2c3SDavid Howells * outstanding calls cannot be doing I/O.
7308c3e34a4SDavid Howells */
rxrpc_destroy_all_calls(struct rxrpc_net * rxnet)7312baec2c3SDavid Howells void rxrpc_destroy_all_calls(struct rxrpc_net *rxnet)
7328c3e34a4SDavid Howells {
7338c3e34a4SDavid Howells struct rxrpc_call *call;
7348c3e34a4SDavid Howells
7358c3e34a4SDavid Howells _enter("");
7368d94aa38SDavid Howells
737b1302342SDavid Howells if (!list_empty(&rxnet->calls)) {
7383dd9c8b5SDavid Howells spin_lock(&rxnet->call_lock);
7398c3e34a4SDavid Howells
7402baec2c3SDavid Howells while (!list_empty(&rxnet->calls)) {
741b1302342SDavid Howells call = list_entry(rxnet->calls.next,
742b1302342SDavid Howells struct rxrpc_call, link);
7438c3e34a4SDavid Howells _debug("Zapping call %p", call);
7448c3e34a4SDavid Howells
745cb0fc0c9SDavid Howells rxrpc_see_call(call, rxrpc_call_see_zap);
7468c3e34a4SDavid Howells list_del_init(&call->link);
7478c3e34a4SDavid Howells
748248f219cSDavid Howells pr_err("Call %p still in use (%d,%s,%lx,%lx)!\n",
749a0575429SDavid Howells call, refcount_read(&call->ref),
75096b4059fSDavid Howells rxrpc_call_states[__rxrpc_call_state(call)],
7518c3e34a4SDavid Howells call->flags, call->events);
7528c3e34a4SDavid Howells
7533dd9c8b5SDavid Howells spin_unlock(&rxnet->call_lock);
7548c3e34a4SDavid Howells cond_resched();
7553dd9c8b5SDavid Howells spin_lock(&rxnet->call_lock);
7568c3e34a4SDavid Howells }
7578c3e34a4SDavid Howells
7583dd9c8b5SDavid Howells spin_unlock(&rxnet->call_lock);
759b1302342SDavid Howells }
760d3be4d24SDavid Howells
761d3be4d24SDavid Howells atomic_dec(&rxnet->nr_calls);
7625bb053beSLinus Torvalds wait_var_event(&rxnet->nr_calls, !atomic_read(&rxnet->nr_calls));
7638c3e34a4SDavid Howells }
764