Lines Matching refs:call
28 struct rxrpc_call *call,
106 * abort a call, sending an ABORT packet to the peer
108 static void rxrpc_send_abort(struct rxrpc_call *call, u32 abort_code)
110 write_lock_bh(&call->state_lock);
112 if (call->state <= RXRPC_CALL_COMPLETE) {
113 call->state = RXRPC_CALL_LOCALLY_ABORTED;
114 call->abort_code = abort_code;
115 set_bit(RXRPC_CALL_ABORT, &call->events);
116 del_timer_sync(&call->resend_timer);
117 del_timer_sync(&call->ack_timer);
118 clear_bit(RXRPC_CALL_RESEND_TIMER, &call->events);
119 clear_bit(RXRPC_CALL_ACK, &call->events);
120 clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);
121 rxrpc_queue_call(call);
124 write_unlock_bh(&call->state_lock);
128 * send a message forming part of a client call through an RxRPC socket
138 struct rxrpc_call *call;
171 call = rxrpc_get_client_call(rx, trans, bundle, user_call_ID,
175 if (IS_ERR(call)) {
176 _leave(" = %ld", PTR_ERR(call));
177 return PTR_ERR(call);
181 call->debug_id, call->user_call_ID, call->state, call->conn);
183 if (call->state >= RXRPC_CALL_COMPLETE) {
184 /* it's too late for this call */
187 rxrpc_send_abort(call, abort_code);
190 } else if (call->state != RXRPC_CALL_CLIENT_SEND_REQUEST) {
191 /* request phase complete for this client call */
194 ret = rxrpc_send_data(iocb, rx, call, msg, len);
197 rxrpc_put_call(call);
203 * rxrpc_kernel_send_data - Allow a kernel service to send data on a call
204 * @call: The call to send data through
208 * Allow a kernel service to send data on a call. The call must be in an state
213 int rxrpc_kernel_send_data(struct rxrpc_call *call, struct msghdr *msg,
218 _enter("{%d,%s},", call->debug_id, rxrpc_call_states[call->state]);
223 lock_sock(&call->socket->sk);
226 call->debug_id, call->user_call_ID, call->state, call->conn);
228 if (call->state >= RXRPC_CALL_COMPLETE) {
229 ret = -ESHUTDOWN; /* it's too late for this call */
230 } else if (call->state != RXRPC_CALL_CLIENT_SEND_REQUEST &&
231 call->state != RXRPC_CALL_SERVER_ACK_REQUEST &&
232 call->state != RXRPC_CALL_SERVER_SEND_REPLY) {
233 ret = -EPROTO; /* request phase complete for this client call */
237 ret = rxrpc_send_data(NULL, call->socket, call, msg, len);
241 release_sock(&call->socket->sk);
249 * rxrpc_kernel_abort_call - Allow a kernel service to abort a call
250 * @call: The call to be aborted
253 * Allow a kernel service to abort a call, if it's still in an abortable state.
255 void rxrpc_kernel_abort_call(struct rxrpc_call *call, u32 abort_code)
257 _enter("{%d},%d", call->debug_id, abort_code);
259 lock_sock(&call->socket->sk);
262 call->debug_id, call->user_call_ID, call->state, call->conn);
264 if (call->state < RXRPC_CALL_COMPLETE)
265 rxrpc_send_abort(call, abort_code);
267 release_sock(&call->socket->sk);
281 struct rxrpc_call *call;
294 call = rxrpc_accept_call(rx, user_call_ID);
295 if (IS_ERR(call))
296 return PTR_ERR(call);
297 rxrpc_put_call(call);
301 call = rxrpc_find_server_call(rx, user_call_ID);
302 if (!call)
304 if (call->state >= RXRPC_CALL_COMPLETE) {
311 if (call->state != RXRPC_CALL_CLIENT_SEND_REQUEST &&
312 call->state != RXRPC_CALL_SERVER_ACK_REQUEST &&
313 call->state != RXRPC_CALL_SERVER_SEND_REPLY) {
314 /* Tx phase not yet begun for this call */
319 ret = rxrpc_send_data(iocb, rx, call, msg, len);
323 rxrpc_send_abort(call, abort_code);
330 rxrpc_put_call(call);
403 struct rxrpc_call *call,
410 CIRC_SPACE(call->acks_head, call->acks_tail, call->acks_winsz),
413 add_wait_queue(&call->tx_waitq, &myself);
418 if (CIRC_SPACE(call->acks_head, call->acks_tail,
419 call->acks_winsz) > 0)
431 remove_wait_queue(&call->tx_waitq, &myself);
440 static inline void rxrpc_instant_resend(struct rxrpc_call *call)
442 read_lock_bh(&call->state_lock);
443 if (try_to_del_timer_sync(&call->resend_timer) >= 0) {
444 clear_bit(RXRPC_CALL_RUN_RTIMER, &call->flags);
445 if (call->state < RXRPC_CALL_COMPLETE &&
446 !test_and_set_bit(RXRPC_CALL_RESEND_TIMER, &call->events))
447 rxrpc_queue_call(call);
449 read_unlock_bh(&call->state_lock);
456 static void rxrpc_queue_packet(struct rxrpc_call *call, struct sk_buff *skb,
462 _net("queue skb %p [%d]", skb, call->acks_head);
464 ASSERT(call->acks_window != NULL);
465 call->acks_window[call->acks_head] = (unsigned long) skb;
467 call->acks_head = (call->acks_head + 1) & (call->acks_winsz - 1);
469 if (last || call->state == RXRPC_CALL_SERVER_ACK_REQUEST) {
471 write_lock_bh(&call->state_lock);
472 switch (call->state) {
474 call->state = RXRPC_CALL_CLIENT_AWAIT_REPLY;
477 call->state = RXRPC_CALL_SERVER_SEND_REPLY;
481 call->state = RXRPC_CALL_SERVER_AWAIT_ACK;
486 write_unlock_bh(&call->state_lock);
494 if (!test_and_set_bit(RXRPC_CALL_RUN_RTIMER, &call->flags)) {
496 call->resend_timer.expires = sp->resend_at;
497 add_timer(&call->resend_timer);
501 * we're ACK'ing the request phase of an incoming call */
503 if (try_to_del_timer_sync(&call->ack_timer) >= 0) {
506 ret = rxrpc_send_packet(call->conn->trans, skb);
515 rxrpc_instant_resend(call);
528 struct rxrpc_call *call,
557 skb = call->tx_pending;
558 call->tx_pending = NULL;
574 if (CIRC_SPACE(call->acks_head, call->acks_tail,
575 call->acks_winsz) <= 0) {
579 ret = rxrpc_wait_for_tx_window(rx, call,
585 max = call->conn->trans->peer->maxdata;
586 max -= call->conn->security_size;
587 max &= ~(call->conn->size_align - 1UL);
593 space = chunk + call->conn->size_align;
594 space &= ~(call->conn->size_align - 1UL);
596 size = space + call->conn->header_size;
612 _debug("HS: %u", call->conn->header_size);
613 skb_reserve(skb, call->conn->header_size);
614 skb->len += call->conn->header_size;
664 /* check for the far side aborting the call or a network error
666 if (call->state > RXRPC_CALL_COMPLETE)
671 struct rxrpc_connection *conn = call->conn;
685 seq = atomic_inc_return(&call->sequence);
688 sp->hdr.cid = call->cid;
689 sp->hdr.callNumber = call->call_id;
702 else if (CIRC_SPACE(call->acks_head, call->acks_tail,
703 call->acks_winsz) > 1)
709 call, skb, skb->mark,
716 rxrpc_queue_packet(call, skb, segment == 0 && !more);
725 call->tx_pending = skb;
731 if (call->state == RXRPC_CALL_NETWORK_ERROR)
732 ret = call->conn->trans->peer->net_error;