Lines Matching defs: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))
32 if (test_bit(RXRPC_CALL_RELEASED, &call->flags)) {
33 rxrpc_see_call(call, rxrpc_call_see_notify_released);
39 rx = rcu_dereference(call->socket);
42 if (call->notify_rx) {
43 spin_lock_irq(&call->notify_lock);
44 call->notify_rx(sk, call, call->user_call_ID);
45 spin_unlock_irq(&call->notify_lock);
48 if (list_empty(&call->recvmsg_link)) {
49 rxrpc_get_call(call, rxrpc_call_get_notify_socket);
50 list_add_tail(&call->recvmsg_link, &rx->recvmsg_q);
55 _debug("call %ps", sk->sk_data_ready);
66 * Pass a call terminating message to userspace.
68 static int rxrpc_recvmsg_term(struct rxrpc_call *call, struct msghdr *msg)
73 switch (call->completion) {
76 if (rxrpc_is_service_call(call))
80 tmp = call->abort_code;
84 tmp = call->abort_code;
88 tmp = -call->error;
92 tmp = -call->error;
96 pr_err("Invalid terminal call state %u\n", call->completion);
101 trace_rxrpc_recvdata(call, rxrpc_recvmsg_terminal,
102 call->ackr_window - 1,
103 call->rx_pkt_offset, call->rx_pkt_len, ret);
110 static void rxrpc_rotate_rx_window(struct rxrpc_call *call)
115 rxrpc_seq_t old_consumed = call->rx_consumed, tseq;
119 _enter("%d", call->debug_id);
121 skb = skb_dequeue(&call->recvmsg_queue);
130 if (after(tseq, call->rx_consumed))
131 smp_store_release(&call->rx_consumed, tseq);
135 trace_rxrpc_receive(call, last ? rxrpc_receive_rotate_last : rxrpc_receive_rotate,
136 serial, call->rx_consumed);
139 set_bit(RXRPC_CALL_RECVMSG_READ_ALL, &call->flags);
142 acked = atomic_add_return(call->rx_consumed - old_consumed,
143 &call->ackr_nr_consumed);
145 !test_and_set_bit(RXRPC_CALL_RX_IS_IDLE, &call->flags))
146 rxrpc_poke_call(call, rxrpc_call_poke_idle);
159 static int rxrpc_verify_data(struct rxrpc_call *call, struct sk_buff *skb)
164 if (sp->len > call->rx_dec_bsize || !call->rx_dec_buffer) {
169 void *buffer = krealloc(call->rx_dec_buffer, size, GFP_NOFS);
173 call->rx_dec_buffer = buffer;
174 call->rx_dec_bsize = size;
178 if (skb_copy_bits(skb, sp->offset, call->rx_dec_buffer, sp->len) < 0)
181 call->rx_dec_offset = 0;
182 call->rx_dec_len = sp->len;
183 call->rx_dec_seq = sp->hdr.seq;
184 ret = call->security->verify_packet(call, skb);
190 kfree(call->rx_dec_buffer);
191 call->rx_dec_buffer = NULL;
192 call->rx_dec_bsize = 0;
193 call->rx_dec_offset = 0;
194 call->rx_dec_len = 0;
199 * Transcribe a call's user ID to a control message.
201 static int rxrpc_recvmsg_user_id(struct rxrpc_call *call, struct msghdr *msg,
204 if (!test_bit(RXRPC_CALL_HAS_USERID, &call->flags))
208 unsigned int id32 = call->user_call_ID;
213 unsigned long idl = call->user_call_ID;
276 * Deliver messages to a call. This keeps processing packets until the buffer
279 * call has failed it returns -EIO.
281 static int rxrpc_recvmsg_data(struct socket *sock, struct rxrpc_call *call,
293 rx_pkt_offset = call->rx_pkt_offset;
294 rx_pkt_len = call->rx_pkt_len;
296 if (rxrpc_call_has_failed(call)) {
297 seq = call->ackr_window - 1;
302 if (test_bit(RXRPC_CALL_RECVMSG_READ_ALL, &call->flags)) {
303 seq = call->ackr_window - 1;
311 skb = skb_peek(&call->recvmsg_queue);
318 trace_rxrpc_receive(call, rxrpc_receive_front,
324 if (call->rx_dec_seq != sp->hdr.seq ||
325 !call->rx_dec_buffer) {
326 ret2 = rxrpc_verify_data(call, skb);
327 trace_rxrpc_recvdata(call, rxrpc_recvmsg_next, seq,
328 call->rx_dec_offset,
329 call->rx_dec_len, ret2);
337 rx_pkt_offset = call->rx_dec_offset;
338 rx_pkt_len = call->rx_dec_len;
340 trace_rxrpc_recvdata(call, rxrpc_recvmsg_cont, seq,
350 ret2 = copy_to_iter(call->rx_dec_buffer + rx_pkt_offset,
364 trace_rxrpc_recvdata(call, rxrpc_recvmsg_full, seq,
377 skb = skb_peek_next(skb, &call->recvmsg_queue);
380 rxrpc_rotate_rx_window(call);
384 trace_rxrpc_recvdata(call, rxrpc_recvmsg_oobq, seq,
392 call->rx_pkt_offset = rx_pkt_offset;
393 call->rx_pkt_len = rx_pkt_len;
397 trace_rxrpc_recvdata(call, rxrpc_recvmsg_data_return, seq,
400 set_bit(RXRPC_CALL_RX_IS_IDLE, &call->flags);
412 struct rxrpc_call *call;
444 call = NULL;
477 /* Find the next call and dequeue it if we're not just peeking. If we
484 call = list_entry(l, struct rxrpc_call, recvmsg_link);
486 if (!rxrpc_call_is_complete(call) &&
487 skb_queue_empty(&call->recvmsg_queue) &&
489 list_del_init(&call->recvmsg_link);
492 trace_rxrpc_recvmsg(call->debug_id, rxrpc_recvmsg_unqueue, 0);
493 rxrpc_put_call(call, rxrpc_call_put_recvmsg);
497 rxrpc_see_call(call, rxrpc_call_see_recvmsg);
498 if (test_bit(RXRPC_CALL_RELEASED, &call->flags)) {
499 rxrpc_see_call(call, rxrpc_call_see_already_released);
500 list_del_init(&call->recvmsg_link);
503 trace_rxrpc_recvmsg(call->debug_id, rxrpc_recvmsg_unqueue, 0);
504 rxrpc_put_call(call, rxrpc_call_put_recvmsg);
508 list_del_init(&call->recvmsg_link);
510 rxrpc_get_call(call, rxrpc_call_get_recvmsg);
513 call_debug_id = call->debug_id;
516 /* We're going to drop the socket lock, so we need to lock the call
519 if (!mutex_trylock(&call->user_mutex)) {
524 if (mutex_lock_interruptible(&call->user_mutex) < 0)
530 if (test_bit(RXRPC_CALL_RELEASED, &call->flags)) {
531 rxrpc_see_call(call, rxrpc_call_see_already_released);
532 mutex_unlock(&call->user_mutex);
534 rxrpc_put_call(call, rxrpc_call_put_recvmsg);
538 ret = rxrpc_recvmsg_user_id(call, msg, flags);
542 if (msg->msg_name && call->peer) {
543 size_t len = sizeof(call->dest_srx);
545 memcpy(msg->msg_name, &call->dest_srx, len);
549 ret = rxrpc_recvmsg_data(sock, call, msg, &msg->msg_iter, len,
558 if (rxrpc_call_is_complete(call) &&
559 skb_queue_empty(&call->recvmsg_queue))
561 if (rxrpc_call_has_failed(call))
565 !skb_queue_empty(&call->recvmsg_queue))
566 rxrpc_notify_socket(call);
570 rxrpc_purge_queue(&call->recvmsg_queue);
572 ret = rxrpc_recvmsg_term(call, msg);
576 rxrpc_release_call(rx, call);
588 mutex_unlock(&call->user_mutex);
589 rxrpc_put_call(call, rxrpc_call_put_recvmsg);
596 if (list_empty(&call->recvmsg_link)) {
597 list_add(&call->recvmsg_link, &rx->recvmsg_q);
598 rxrpc_see_call(call, rxrpc_call_see_recvmsg_requeue);
600 } else if (list_is_first(&call->recvmsg_link, &rx->recvmsg_q)) {
602 rxrpc_put_call(call, rxrpc_call_see_recvmsg_requeue_first);
604 list_move(&call->recvmsg_link, &rx->recvmsg_q);
606 rxrpc_put_call(call, rxrpc_call_see_recvmsg_requeue_move);
610 rxrpc_put_call(call, rxrpc_call_put_recvmsg_peek_nowait);
622 call = NULL;
628 * @sock: The socket that the call exists on
629 * @call: The call to send data through
637 * state of a call. Note that *@_abort should also be initialised to %0.
646 int rxrpc_kernel_recv_data(struct socket *sock, struct rxrpc_call *call,
653 _enter("{%d},%zu,%d", call->debug_id, *_len, want_more);
655 mutex_lock(&call->user_mutex);
657 ret = rxrpc_recvmsg_data(sock, call, NULL, iter, *_len, 0, &offset);
685 *_service = call->dest_srx.srx_service;
686 mutex_unlock(&call->user_mutex);
691 trace_rxrpc_abort(call->debug_id, rxrpc_recvmsg_short_data,
692 call->cid, call->call_id, call->rx_consumed,
697 trace_rxrpc_abort(call->debug_id, rxrpc_recvmsg_excess_data,
698 call->cid, call->call_id, call->rx_consumed,
703 *_abort = call->abort_code;
704 ret = call->error;
705 if (call->completion == RXRPC_CALL_SUCCEEDED) {