Lines Matching defs:call
2 /* RxRPC individual remote procedure call handling
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,
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);
83 * find an extant server call
89 struct rxrpc_call *call;
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)
113 rxrpc_get_call(call, rxrpc_call_got);
115 _leave(" = %p [%d]", call, refcount_read(&call->ref));
116 return call;
120 * allocate a new call
125 struct rxrpc_call *call;
128 call = kmem_cache_zalloc(rxrpc_call_jar, gfp);
129 if (!call)
132 call->rxtx_buffer = kcalloc(RXRPC_RXTX_BUFF_SIZE,
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);
148 lockdep_set_class(&call->user_mutex,
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));
172 call->rx_winsize = rxrpc_rx_window_size;
173 call->tx_winsize = 16;
174 call->rx_expect_next = 1;
176 call->cong_cwnd = 2;
177 call->cong_ssthresh = RXRPC_RXTX_BUFF_SIZE - 1;
179 call->rxnet = rxnet;
180 call->rtt_avail = RXRPC_CALL_RTT_AVAIL_MASK;
182 return call;
185 kfree(call->rxtx_buffer);
187 kmem_cache_free(rxrpc_call_jar, call);
192 * Allocate a new client call.
199 struct rxrpc_call *call;
204 call = rxrpc_alloc_call(rx, gfp, debug_id);
205 if (!call)
207 call->state = RXRPC_CALL_CLIENT_AWAIT_CONN;
208 call->service_id = srx->srx_service;
209 call->tx_phase = true;
211 call->acks_latest_ts = now;
212 call->cong_tstamp = now;
214 _leave(" = %p", call);
215 return call;
219 * Initiate the call ack/resend/expiry timer.
221 static void rxrpc_start_call_timer(struct rxrpc_call *call)
226 call->ack_at = j;
227 call->ack_lost_at = j;
228 call->resend_at = j;
229 call->ping_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.
253 * Release a call slot.
255 static void rxrpc_put_call_slot(struct rxrpc_call *call)
259 if (test_bit(RXRPC_CALL_KERNEL, &call->flags))
265 * Set up a call for the given parameters.
267 * - If it returns a call, the call's lock will need releasing by the caller.
276 __acquires(&call->user_mutex)
278 struct rxrpc_call *call, *xcall;
293 call = rxrpc_alloc_client_call(rx, srx, gfp, debug_id);
294 if (IS_ERR(call)) {
297 _leave(" = %ld", PTR_ERR(call));
298 return call;
301 call->interruptibility = p->interruptibility;
302 call->tx_total_len = p->tx_total_len;
303 trace_rxrpc_call(call->debug_id, rxrpc_call_new_client,
304 refcount_read(&call->ref),
307 __set_bit(RXRPC_CALL_KERNEL, &call->flags);
309 /* We need to protect a partially set up call against the user as we
312 mutex_lock(&call->user_mutex);
314 /* Publish the call, even though it is incompletely set up as yet */
331 rcu_assign_pointer(call->socket, rx);
332 call->user_call_ID = p->user_call_ID;
333 __set_bit(RXRPC_CALL_HAS_USERID, &call->flags);
334 rxrpc_get_call(call, rxrpc_call_got_userid);
335 rb_link_node(&call->sock_node, parent, pp);
336 rb_insert_color(&call->sock_node, &rx->calls);
337 list_add(&call->sock_link, &rx->sock_calls);
341 rxnet = call->rxnet;
343 list_add_tail(&call->link, &rxnet->calls);
346 /* From this point on, the call is protected by its own lock. */
350 * including channel number and call ID.
352 ret = rxrpc_connect_call(rx, call, cp, srx, gfp);
356 trace_rxrpc_call(call->debug_id, rxrpc_call_connected,
357 refcount_read(&call->ref), here, NULL);
359 rxrpc_start_call_timer(call);
361 _net("CALL new %d on CONN %d", call->debug_id, call->conn->debug_id);
363 _leave(" = %p [new]", call);
364 return call;
374 __rxrpc_set_call_completion(call, RXRPC_CALL_LOCAL_ERROR,
376 trace_rxrpc_call(call->debug_id, rxrpc_call_error,
377 refcount_read(&call->ref), here, ERR_PTR(-EEXIST));
378 rxrpc_release_call(rx, call);
379 mutex_unlock(&call->user_mutex);
380 rxrpc_put_call(call, rxrpc_call_put);
384 /* We got an error, but the call is attached to the socket and is in
386 * completing the call queues it. Return 0 from sys_sendmsg() and
390 trace_rxrpc_call(call->debug_id, rxrpc_call_error,
391 refcount_read(&call->ref), here, ERR_PTR(ret));
392 set_bit(RXRPC_CALL_DISCONNECTED, &call->flags);
393 __rxrpc_set_call_completion(call, RXRPC_CALL_LOCAL_ERROR,
395 _leave(" = c=%08x [err]", call->debug_id);
396 return call;
400 * Set up an incoming call. call->conn points to the connection.
404 struct rxrpc_call *call,
407 struct rxrpc_connection *conn = call->conn;
411 _enter(",%d", call->conn->debug_id);
413 rcu_assign_pointer(call->socket, rx);
414 call->call_id = sp->hdr.callNumber;
415 call->service_id = sp->hdr.serviceId;
416 call->cid = sp->hdr.cid;
417 call->state = RXRPC_CALL_SERVER_SECURING;
418 call->cong_tstamp = skb->tstamp;
420 /* Set the channel for this call. We don't get channel_lock as we're
424 * call pointer).
427 conn->channels[chan].call_counter = call->call_id;
428 conn->channels[chan].call_id = call->call_id;
429 rcu_assign_pointer(conn->channels[chan].call, call);
432 hlist_add_head_rcu(&call->error_link, &conn->params.peer->error_targets);
435 _net("CALL incoming %d on CONN %d", call->debug_id, call->conn->debug_id);
437 rxrpc_start_call_timer(call);
442 * Queue a call's work processor, getting a ref to pass to the work queue.
444 bool rxrpc_queue_call(struct rxrpc_call *call)
449 if (!__refcount_inc_not_zero(&call->ref, &n))
451 if (rxrpc_queue_work(&call->processor))
452 trace_rxrpc_call(call->debug_id, rxrpc_call_queued, n + 1,
455 rxrpc_put_call(call, rxrpc_call_put_noqueue);
460 * Queue a call's work processor, passing the callers ref to the work queue.
462 bool __rxrpc_queue_call(struct rxrpc_call *call)
465 int n = refcount_read(&call->ref);
467 if (rxrpc_queue_work(&call->processor))
468 trace_rxrpc_call(call->debug_id, rxrpc_call_queued_ref, n,
471 rxrpc_put_call(call, rxrpc_call_put_noqueue);
476 * Note the re-emergence of a call.
478 void rxrpc_see_call(struct rxrpc_call *call)
481 if (call) {
482 int n = refcount_read(&call->ref);
484 trace_rxrpc_call(call->debug_id, rxrpc_call_seen, n,
489 bool rxrpc_try_get_call(struct rxrpc_call *call, enum rxrpc_call_trace op)
494 if (!__refcount_inc_not_zero(&call->ref, &n))
496 trace_rxrpc_call(call->debug_id, op, n + 1, here, NULL);
501 * Note the addition of a ref on a call.
503 void rxrpc_get_call(struct rxrpc_call *call, enum rxrpc_call_trace op)
508 __refcount_inc(&call->ref, &n);
509 trace_rxrpc_call(call->debug_id, op, n + 1, here, NULL);
515 static void rxrpc_cleanup_ring(struct rxrpc_call *call)
520 rxrpc_free_skb(call->rxtx_buffer[i], rxrpc_skb_cleaned);
521 call->rxtx_buffer[i] = NULL;
526 * Detach a call from its owning socket.
528 void rxrpc_release_call(struct rxrpc_sock *rx, struct rxrpc_call *call)
531 struct rxrpc_connection *conn = call->conn;
534 _enter("{%d,%d}", call->debug_id, refcount_read(&call->ref));
536 trace_rxrpc_call(call->debug_id, rxrpc_call_release,
537 refcount_read(&call->ref),
538 here, (const void *)call->flags);
540 ASSERTCMP(call->state, ==, RXRPC_CALL_COMPLETE);
542 spin_lock_bh(&call->lock);
543 if (test_and_set_bit(RXRPC_CALL_RELEASED, &call->flags))
545 spin_unlock_bh(&call->lock);
547 rxrpc_put_call_slot(call);
548 rxrpc_delete_call_timer(call);
553 if (!list_empty(&call->recvmsg_link)) {
554 _debug("unlinking once-pending call %p { e=%lx f=%lx }",
555 call, call->events, call->flags);
556 list_del(&call->recvmsg_link);
561 call->recvmsg_link.next = NULL;
562 call->recvmsg_link.prev = NULL;
566 rxrpc_put_call(call, rxrpc_call_put);
570 if (test_and_clear_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
571 rb_erase(&call->sock_node, &rx->calls);
572 memset(&call->sock_node, 0xdd, sizeof(call->sock_node));
573 rxrpc_put_call(call, rxrpc_call_put_userid);
576 list_del(&call->sock_link);
579 _debug("RELEASE CALL %p (%d CONN %p)", call, call->debug_id, conn);
581 if (conn && !test_bit(RXRPC_CALL_DISCONNECTED, &call->flags))
582 rxrpc_disconnect_call(call);
583 if (call->security)
584 call->security->free_call_crypto(call);
593 struct rxrpc_call *call;
598 call = list_entry(rx->to_be_accepted.next,
600 list_del(&call->accept_link);
601 rxrpc_abort_call("SKR", call, 0, RX_CALL_DEAD, -ECONNRESET);
602 rxrpc_put_call(call, rxrpc_call_put);
606 call = list_entry(rx->sock_calls.next,
608 rxrpc_get_call(call, rxrpc_call_got);
609 rxrpc_abort_call("SKT", call, 0, RX_CALL_DEAD, -ECONNRESET);
610 rxrpc_send_abort_packet(call);
611 rxrpc_release_call(rx, call);
612 rxrpc_put_call(call, rxrpc_call_put);
619 * release a call
621 void rxrpc_put_call(struct rxrpc_call *call, enum rxrpc_call_trace op)
623 struct rxrpc_net *rxnet = call->rxnet;
625 unsigned int debug_id = call->debug_id;
629 ASSERT(call != NULL);
631 dead = __refcount_dec_and_test(&call->ref, &n);
634 _debug("call %d dead", call->debug_id);
635 ASSERTCMP(call->state, ==, RXRPC_CALL_COMPLETE);
637 if (!list_empty(&call->link)) {
639 list_del_init(&call->link);
643 rxrpc_cleanup_call(call);
648 * Final call destruction - but must be done in process context.
652 struct rxrpc_call *call = container_of(work, struct rxrpc_call, processor);
653 struct rxrpc_net *rxnet = call->rxnet;
655 rxrpc_delete_call_timer(call);
657 rxrpc_put_connection(call->conn);
658 rxrpc_put_peer(call->peer);
659 kfree(call->rxtx_buffer);
660 kfree(call->rxtx_annotations);
661 kmem_cache_free(rxrpc_call_jar, call);
667 * Final call destruction under RCU.
671 struct rxrpc_call *call = container_of(rcu, struct rxrpc_call, rcu);
674 INIT_WORK(&call->processor, rxrpc_destroy_call);
675 if (!rxrpc_queue_work(&call->processor))
678 rxrpc_destroy_call(&call->processor);
683 * clean up a call
685 void rxrpc_cleanup_call(struct rxrpc_call *call)
687 _net("DESTROY CALL %d", call->debug_id);
689 memset(&call->sock_node, 0xcd, sizeof(call->sock_node));
691 ASSERTCMP(call->state, ==, RXRPC_CALL_COMPLETE);
692 ASSERT(test_bit(RXRPC_CALL_RELEASED, &call->flags));
694 rxrpc_cleanup_ring(call);
695 rxrpc_free_skb(call->tx_pending, rxrpc_skb_cleaned);
697 call_rcu(&call->rcu, rxrpc_rcu_destroy_call);
707 struct rxrpc_call *call;
715 call = list_entry(rxnet->calls.next,
717 _debug("Zapping call %p", call);
719 rxrpc_see_call(call);
720 list_del_init(&call->link);
723 call, refcount_read(&call->ref),
724 rxrpc_call_states[call->state],
725 call->flags, call->events);