Lines Matching refs:call
20 * Post a call for attention by the socket or kernel service. Further
23 void rxrpc_notify_socket(struct rxrpc_call *call)
28 _enter("%d", call->debug_id);
30 if (!list_empty(&call->recvmsg_link))
35 rx = rcu_dereference(call->socket);
38 if (call->notify_rx) {
39 spin_lock_bh(&call->notify_lock);
40 call->notify_rx(sk, call, call->user_call_ID);
41 spin_unlock_bh(&call->notify_lock);
44 if (list_empty(&call->recvmsg_link)) {
45 rxrpc_get_call(call, rxrpc_call_got);
46 list_add_tail(&call->recvmsg_link, &rx->recvmsg_q);
51 _debug("call %ps", sk->sk_data_ready);
62 * Transition a call to the complete state.
64 bool __rxrpc_set_call_completion(struct rxrpc_call *call,
69 if (call->state < RXRPC_CALL_COMPLETE) {
70 call->abort_code = abort_code;
71 call->error = error;
72 call->completion = compl,
73 call->state = RXRPC_CALL_COMPLETE;
74 trace_rxrpc_call_complete(call);
75 wake_up(&call->waitq);
76 rxrpc_notify_socket(call);
82 bool rxrpc_set_call_completion(struct rxrpc_call *call,
89 if (call->state < RXRPC_CALL_COMPLETE) {
90 write_lock_bh(&call->state_lock);
91 ret = __rxrpc_set_call_completion(call, compl, abort_code, error);
92 write_unlock_bh(&call->state_lock);
98 * Record that a call successfully completed.
100 bool __rxrpc_call_completed(struct rxrpc_call *call)
102 return __rxrpc_set_call_completion(call, RXRPC_CALL_SUCCEEDED, 0, 0);
105 bool rxrpc_call_completed(struct rxrpc_call *call)
109 if (call->state < RXRPC_CALL_COMPLETE) {
110 write_lock_bh(&call->state_lock);
111 ret = __rxrpc_call_completed(call);
112 write_unlock_bh(&call->state_lock);
118 * Record that a call is locally aborted.
120 bool __rxrpc_abort_call(const char *why, struct rxrpc_call *call,
123 trace_rxrpc_abort(call->debug_id, why, call->cid, call->call_id, seq,
125 return __rxrpc_set_call_completion(call, RXRPC_CALL_LOCALLY_ABORTED,
129 bool rxrpc_abort_call(const char *why, struct rxrpc_call *call,
134 write_lock_bh(&call->state_lock);
135 ret = __rxrpc_abort_call(why, call, seq, abort_code, error);
136 write_unlock_bh(&call->state_lock);
141 * Pass a call terminating message to userspace.
143 static int rxrpc_recvmsg_term(struct rxrpc_call *call, struct msghdr *msg)
148 switch (call->completion) {
151 if (rxrpc_is_service_call(call))
155 tmp = call->abort_code;
159 tmp = call->abort_code;
163 tmp = -call->error;
167 tmp = -call->error;
171 pr_err("Invalid terminal call state %u\n", call->state);
176 trace_rxrpc_recvmsg(call, rxrpc_recvmsg_terminal, call->rx_hard_ack,
177 call->rx_pkt_offset, call->rx_pkt_len, ret);
184 static void rxrpc_end_rx_phase(struct rxrpc_call *call, rxrpc_serial_t serial)
186 _enter("%d,%s", call->debug_id, rxrpc_call_states[call->state]);
188 trace_rxrpc_receive(call, rxrpc_receive_end, 0, call->rx_top);
189 ASSERTCMP(call->rx_hard_ack, ==, call->rx_top);
191 if (call->state == RXRPC_CALL_CLIENT_RECV_REPLY) {
192 rxrpc_propose_ACK(call, RXRPC_ACK_IDLE, serial, false, true,
194 //rxrpc_send_ack_packet(call, false, NULL);
197 write_lock_bh(&call->state_lock);
199 switch (call->state) {
201 __rxrpc_call_completed(call);
202 write_unlock_bh(&call->state_lock);
206 call->tx_phase = true;
207 call->state = RXRPC_CALL_SERVER_ACK_REQUEST;
208 call->expect_req_by = jiffies + MAX_JIFFY_OFFSET;
209 write_unlock_bh(&call->state_lock);
210 rxrpc_propose_ACK(call, RXRPC_ACK_DELAY, serial, false, true,
214 write_unlock_bh(&call->state_lock);
222 static void rxrpc_rotate_rx_window(struct rxrpc_call *call)
232 _enter("%d", call->debug_id);
234 hard_ack = call->rx_hard_ack;
235 top = smp_load_acquire(&call->rx_top);
240 skb = call->rxtx_buffer[ix];
244 subpacket = call->rxtx_annotations[ix] & RXRPC_RX_ANNO_SUBPACKET;
251 call->rxtx_buffer[ix] = NULL;
252 call->rxtx_annotations[ix] = 0;
254 smp_store_release(&call->rx_hard_ack, hard_ack);
258 trace_rxrpc_receive(call, rxrpc_receive_rotate, serial, hard_ack);
260 rxrpc_end_rx_phase(call, serial);
263 if (atomic_inc_return(&call->ackr_nr_consumed) > 2)
264 rxrpc_propose_ACK(call, RXRPC_ACK_IDLE, serial,
267 if (call->ackr_reason && call->ackr_reason != RXRPC_ACK_DELAY)
268 rxrpc_send_ack_packet(call, false, NULL);
278 static int rxrpc_verify_packet(struct rxrpc_call *call, struct sk_buff *skb,
300 return call->security->verify_packet(call, skb, offset, len,
314 static int rxrpc_locate_data(struct rxrpc_call *call, struct sk_buff *skb,
336 ret = rxrpc_verify_packet(call, skb, annotation, offset, len);
345 call->security->locate_data(call, skb, _offset, _len);
350 * Deliver messages to a call. This keeps processing packets until the buffer
354 static int rxrpc_recvmsg_data(struct socket *sock, struct rxrpc_call *call,
367 if (test_and_clear_bit(RXRPC_CALL_RX_UNDERRUN, &call->flags) &&
368 call->ackr_reason)
369 rxrpc_send_ack_packet(call, false, NULL);
371 rx_pkt_offset = call->rx_pkt_offset;
372 rx_pkt_len = call->rx_pkt_len;
373 rx_pkt_last = call->rx_pkt_last;
375 if (call->state >= RXRPC_CALL_SERVER_ACK_REQUEST) {
376 seq = call->rx_hard_ack;
382 hard_ack = call->rx_hard_ack;
385 while (top = smp_load_acquire(&call->rx_top),
389 skb = call->rxtx_buffer[ix];
391 trace_rxrpc_recvmsg(call, rxrpc_recvmsg_hole, seq,
401 serial += call->rxtx_annotations[ix] & RXRPC_RX_ANNO_SUBPACKET;
402 trace_rxrpc_receive(call, rxrpc_receive_front,
410 ret2 = rxrpc_locate_data(call, skb,
411 &call->rxtx_annotations[ix],
414 trace_rxrpc_recvmsg(call, rxrpc_recvmsg_next, seq,
421 trace_rxrpc_recvmsg(call, rxrpc_recvmsg_cont, seq,
445 trace_rxrpc_recvmsg(call, rxrpc_recvmsg_full, seq,
454 rxrpc_rotate_rx_window(call);
459 ASSERTCMP(seq, ==, READ_ONCE(call->rx_top));
469 call->rx_pkt_offset = rx_pkt_offset;
470 call->rx_pkt_len = rx_pkt_len;
471 call->rx_pkt_last = rx_pkt_last;
474 trace_rxrpc_recvmsg(call, rxrpc_recvmsg_data_return, seq,
477 set_bit(RXRPC_CALL_RX_UNDERRUN, &call->flags);
489 struct rxrpc_call *call;
519 call = NULL;
543 /* Find the next call and dequeue it if we're not just peeking. If we
548 call = list_entry(l, struct rxrpc_call, recvmsg_link);
550 list_del_init(&call->recvmsg_link);
552 rxrpc_get_call(call, rxrpc_call_got);
555 trace_rxrpc_recvmsg(call, rxrpc_recvmsg_dequeue, 0, 0, 0, 0);
557 /* We're going to drop the socket lock, so we need to lock the call
560 if (!mutex_trylock(&call->user_mutex)) {
565 if (mutex_lock_interruptible(&call->user_mutex) < 0)
571 if (test_bit(RXRPC_CALL_RELEASED, &call->flags))
574 if (test_bit(RXRPC_CALL_HAS_USERID, &call->flags)) {
576 unsigned int id32 = call->user_call_ID;
581 unsigned long idl = call->user_call_ID;
590 if (msg->msg_name && call->peer) {
592 size_t len = sizeof(call->peer->srx);
594 memcpy(msg->msg_name, &call->peer->srx, len);
595 srx->srx_service = call->service_id;
599 switch (READ_ONCE(call->state)) {
603 ret = rxrpc_recvmsg_data(sock, call, msg, &msg->msg_iter, len,
608 if (after(call->rx_top, call->rx_hard_ack) &&
609 call->rxtx_buffer[(call->rx_hard_ack + 1) & RXRPC_RXTX_BUFF_MASK])
610 rxrpc_notify_socket(call);
620 if (call->state == RXRPC_CALL_COMPLETE) {
621 ret = rxrpc_recvmsg_term(call, msg);
625 rxrpc_release_call(rx, call);
637 mutex_unlock(&call->user_mutex);
638 rxrpc_put_call(call, rxrpc_call_put);
639 trace_rxrpc_recvmsg(call, rxrpc_recvmsg_return, 0, 0, 0, ret);
645 list_add(&call->recvmsg_link, &rx->recvmsg_q);
647 trace_rxrpc_recvmsg(call, rxrpc_recvmsg_requeue, 0, 0, 0, 0);
649 rxrpc_put_call(call, rxrpc_call_put);
654 trace_rxrpc_recvmsg(call, rxrpc_recvmsg_return, 0, 0, 0, ret);
661 call = NULL;
667 * @sock: The socket that the call exists on
668 * @call: The call to send data through
675 * state of a call. Returns 0 if got what was asked for and there's more
684 int rxrpc_kernel_recv_data(struct socket *sock, struct rxrpc_call *call,
692 call->debug_id, rxrpc_call_states[call->state],
695 ASSERTCMP(call->state, !=, RXRPC_CALL_SERVER_SECURING);
697 mutex_lock(&call->user_mutex);
699 switch (READ_ONCE(call->state)) {
703 ret = rxrpc_recvmsg_data(sock, call, NULL, iter,
737 switch (call->ackr_reason) {
745 rxrpc_send_ack_packet(call, false, NULL);
749 *_service = call->service_id;
750 mutex_unlock(&call->user_mutex);
755 trace_rxrpc_rx_eproto(call, 0, tracepoint_string("short_data"));
759 trace_rxrpc_rx_eproto(call, 0, tracepoint_string("excess_data"));
763 *_abort = call->abort_code;
764 ret = call->error;
765 if (call->completion == RXRPC_CALL_SUCCEEDED) {
776 * @sock: The socket that the call exists on
777 * @call: The call to query
783 bool rxrpc_kernel_get_reply_time(struct socket *sock, struct rxrpc_call *call,
790 mutex_lock(&call->user_mutex);
792 if (READ_ONCE(call->state) != RXRPC_CALL_CLIENT_RECV_REPLY)
795 hard_ack = call->rx_hard_ack;
800 top = smp_load_acquire(&call->rx_top);
804 skb = call->rxtx_buffer[seq & RXRPC_RXTX_BUFF_MASK];
812 mutex_unlock(&call->user_mutex);