Lines Matching refs:call
26 /* asynchronous incoming call initial processing */
132 * Allocate a call.
138 struct afs_call *call;
141 call = kzalloc(sizeof(*call), gfp);
142 if (!call)
145 call->type = type;
146 call->net = net;
147 call->debug_id = atomic_inc_return(&rxrpc_debug_id);
148 atomic_set(&call->usage, 1);
149 INIT_WORK(&call->async_work, afs_process_async_call);
150 init_waitqueue_head(&call->waitq);
151 spin_lock_init(&call->state_lock);
152 call->iter = &call->def_iter;
155 trace_afs_call(call, afs_call_trace_alloc, 1, o,
157 return call;
161 * Dispose of a reference on a call.
163 void afs_put_call(struct afs_call *call)
165 struct afs_net *net = call->net;
166 int n = atomic_dec_return(&call->usage);
169 trace_afs_call(call, afs_call_trace_put, n, o,
174 ASSERT(!work_pending(&call->async_work));
175 ASSERT(call->type->name != NULL);
177 if (call->rxcall) {
178 rxrpc_kernel_end_call(net->socket, call->rxcall);
179 call->rxcall = NULL;
181 if (call->type->destructor)
182 call->type->destructor(call);
184 afs_unuse_server_notime(call->net, call->server, afs_server_trace_put_call);
185 afs_put_addrlist(call->alist);
186 kfree(call->request);
188 trace_afs_call(call, afs_call_trace_free, 0, o,
190 kfree(call);
198 static struct afs_call *afs_get_call(struct afs_call *call,
201 int u = atomic_inc_return(&call->usage);
203 trace_afs_call(call, why, u,
204 atomic_read(&call->net->nr_outstanding_calls),
206 return call;
210 * Queue the call for actual work.
212 static void afs_queue_call_work(struct afs_call *call)
214 if (call->type->work) {
215 INIT_WORK(&call->work, call->type->work);
217 afs_get_call(call, afs_call_trace_work);
218 if (!queue_work(afs_wq, &call->work))
219 afs_put_call(call);
224 * allocate a call with flat request and reply buffers
230 struct afs_call *call;
232 call = afs_alloc_call(net, type, GFP_NOFS);
233 if (!call)
237 call->request_size = request_size;
238 call->request = kmalloc(request_size, GFP_NOFS);
239 if (!call->request)
244 call->reply_max = reply_max;
245 call->buffer = kmalloc(reply_max, GFP_NOFS);
246 if (!call->buffer)
250 afs_extract_to_buf(call, call->reply_max);
251 call->operation_ID = type->op;
252 init_waitqueue_head(&call->waitq);
253 return call;
256 afs_put_call(call);
262 * clean up a call with flat buffer
264 void afs_flat_call_destructor(struct afs_call *call)
268 kfree(call->request);
269 call->request = NULL;
270 kfree(call->buffer);
271 call->buffer = NULL;
279 static void afs_load_bvec(struct afs_call *call, struct msghdr *msg,
283 struct afs_operation *op = call->op;
309 * Advance the AFS call state when the RxRPC call ends the transmit phase.
315 struct afs_call *call = (struct afs_call *)call_user_ID;
317 afs_set_call_state(call, AFS_CALL_CL_REQUESTING, AFS_CALL_CL_AWAIT_REPLY);
321 * attach the data from a bunch of pages on an inode to a call
323 static int afs_send_pages(struct afs_call *call, struct msghdr *msg)
325 struct afs_operation *op = call->op;
335 afs_load_bvec(call, msg, bv, first, last, offset);
336 trace_afs_send_pages(call, msg, first, last, offset);
342 ret = rxrpc_kernel_send_data(op->net->socket, call->rxcall, msg,
352 trace_afs_sent_pages(call, op->store.first, last, first, ret);
357 * Initiate a call and synchronously queue up the parameters for dispatch. Any
358 * error is stored into the call struct, which the caller must check for.
360 void afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, gfp_t gfp)
371 ASSERT(call->type != NULL);
372 ASSERT(call->type->name != NULL);
375 call, call->type->name, key_serial(call->key),
376 atomic_read(&call->net->nr_outstanding_calls));
378 call->addr_ix = ac->index;
379 call->alist = afs_get_addrlist(ac->alist);
385 tx_total_len = call->request_size;
386 if (call->send_pages) {
387 struct afs_operation *op = call->op;
402 /* If the call is going to be asynchronous, we need an extra ref for
403 * the call to hold itself so the caller need not hang on to its ref.
405 if (call->async) {
406 afs_get_call(call, afs_call_trace_get);
407 call->drop_ref = true;
410 /* create a call */
411 rxcall = rxrpc_kernel_begin_call(call->net->socket, srx, call->key,
412 (unsigned long)call,
414 (call->async ?
417 call->upgrade,
418 (call->intr ? RXRPC_PREINTERRUPTIBLE :
420 call->debug_id);
423 call->error = ret;
427 call->rxcall = rxcall;
429 if (call->max_lifespan)
430 rxrpc_kernel_set_max_life(call->net->socket, rxcall,
431 call->max_lifespan);
432 call->issue_time = ktime_get_real();
435 iov[0].iov_base = call->request;
436 iov[0].iov_len = call->request_size;
440 iov_iter_kvec(&msg.msg_iter, WRITE, iov, 1, call->request_size);
443 msg.msg_flags = MSG_WAITALL | (call->send_pages ? MSG_MORE : 0);
445 ret = rxrpc_kernel_send_data(call->net->socket, rxcall,
446 &msg, call->request_size,
451 if (call->send_pages) {
452 ret = afs_send_pages(call, &msg);
458 * - and an asynchronous call may already have completed.
460 * afs_wait_for_call_to_complete(call, ac)
467 rxrpc_kernel_abort_call(call->net->socket, rxcall,
471 rxrpc_kernel_recv_data(call->net->socket, rxcall,
473 &call->abort_code, &call->service_id);
474 ac->abort_code = call->abort_code;
477 call->error = ret;
478 trace_afs_call_done(call);
480 if (call->type->done)
481 call->type->done(call);
483 /* We need to dispose of the extra ref we grabbed for an async call.
484 * The call, however, might be queued on afs_async_calls and we need to
487 if (call->rxcall) {
488 rxrpc_kernel_end_call(call->net->socket, call->rxcall);
489 call->rxcall = NULL;
491 if (call->async) {
492 if (cancel_work_sync(&call->async_work))
493 afs_put_call(call);
494 afs_set_call_complete(call, ret, 0);
498 call->state = AFS_CALL_COMPLETE;
503 * deliver messages to a call
505 static void afs_deliver_to_call(struct afs_call *call)
511 _enter("%s", call->type->name);
513 while (state = READ_ONCE(call->state),
520 iov_iter_kvec(&call->def_iter, READ, NULL, 0, 0);
521 ret = rxrpc_kernel_recv_data(call->net->socket,
522 call->rxcall, &call->def_iter,
524 &call->service_id);
525 trace_afs_receive_data(call, &call->def_iter, false, ret);
537 ret = call->type->deliver(call);
538 state = READ_ONCE(call->state);
539 if (ret == 0 && call->unmarshalling_error)
543 afs_queue_call_work(call);
545 if (call->op)
547 &call->op->server->flags);
560 rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
565 call->debug_id, state);
575 rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
580 rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
587 if (call->type->done)
588 call->type->done(call);
596 afs_set_call_complete(call, ret, remote_abort);
602 * Wait synchronously for a call to complete and clean up the call struct.
604 long afs_wait_for_call_to_complete(struct afs_call *call,
614 ret = call->error;
618 add_wait_queue(&call->waitq, &myself);
623 if (!afs_check_call_state(call, AFS_CALL_COMPLETE) &&
624 call->need_attention) {
625 call->need_attention = false;
627 afs_deliver_to_call(call);
631 if (afs_check_call_state(call, AFS_CALL_COMPLETE))
634 if (!rxrpc_kernel_check_life(call->net->socket, call->rxcall)) {
635 /* rxrpc terminated the call. */
643 remove_wait_queue(&call->waitq, &myself);
646 if (!afs_check_call_state(call, AFS_CALL_COMPLETE)) {
648 afs_set_call_complete(call, call->error, call->abort_code);
650 /* Kill off the call if it's still live. */
651 _debug("call interrupted");
652 if (rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
654 afs_set_call_complete(call, -EINTR, 0);
658 spin_lock_bh(&call->state_lock);
659 ac->abort_code = call->abort_code;
660 ac->error = call->error;
661 spin_unlock_bh(&call->state_lock);
666 ret = call->ret0;
667 call->ret0 = 0;
676 _debug("call complete");
677 afs_put_call(call);
683 * wake up a waiting call
688 struct afs_call *call = (struct afs_call *)call_user_ID;
690 call->need_attention = true;
691 wake_up(&call->waitq);
695 * wake up an asynchronous call
700 struct afs_call *call = (struct afs_call *)call_user_ID;
703 trace_afs_notify_call(rxcall, call);
704 call->need_attention = true;
706 u = atomic_fetch_add_unless(&call->usage, 1, 0);
708 trace_afs_call(call, afs_call_trace_wake, u + 1,
709 atomic_read(&call->net->nr_outstanding_calls),
712 if (!queue_work(afs_async_calls, &call->async_work))
713 afs_put_call(call);
718 * Perform I/O processing on an asynchronous call. The work item carries a ref
719 * to the call struct that we either need to release or to pass on.
723 struct afs_call *call = container_of(work, struct afs_call, async_work);
727 if (call->state < AFS_CALL_COMPLETE && call->need_attention) {
728 call->need_attention = false;
729 afs_deliver_to_call(call);
732 afs_put_call(call);
738 struct afs_call *call = (struct afs_call *)user_call_ID;
740 call->rxcall = rxcall;
744 * Charge the incoming call preallocation.
750 struct afs_call *call = net->spare_incoming_call;
753 if (!call) {
754 call = afs_alloc_call(net, &afs_RXCMxxxx, GFP_KERNEL);
755 if (!call)
758 call->drop_ref = true;
759 call->async = true;
760 call->state = AFS_CALL_SV_AWAIT_OP_ID;
761 init_waitqueue_head(&call->waitq);
762 afs_extract_to_tmp(call);
768 (unsigned long)call,
770 call->debug_id) < 0)
772 call = NULL;
774 net->spare_incoming_call = call;
778 * Discard a preallocated call when a socket is shut down.
783 struct afs_call *call = (struct afs_call *)user_call_ID;
785 call->rxcall = NULL;
786 afs_put_call(call);
790 * Notification of an incoming call.
801 * Grab the operation ID from an incoming cache manager call. The socket
804 static int afs_deliver_cm_op_id(struct afs_call *call)
808 _enter("{%zu}", iov_iter_count(call->iter));
811 ret = afs_extract_data(call, true);
815 call->operation_ID = ntohl(call->tmp);
816 afs_set_call_state(call, AFS_CALL_SV_AWAIT_OP_ID, AFS_CALL_SV_AWAIT_REQUEST);
818 /* ask the cache manager to route the call (it'll change the call type
820 if (!afs_cm_incoming_call(call))
823 trace_afs_cb_call(call);
827 return call->type->deliver(call);
831 * Advance the AFS call state when an RxRPC service call ends the transmit
838 struct afs_call *call = (struct afs_call *)call_user_ID;
840 afs_set_call_state(call, AFS_CALL_SV_REPLYING, AFS_CALL_SV_AWAIT_ACK);
846 void afs_send_empty_reply(struct afs_call *call)
848 struct afs_net *net = call->net;
853 rxrpc_kernel_set_tx_length(net->socket, call->rxcall, 0);
862 switch (rxrpc_kernel_send_data(net->socket, call->rxcall, &msg, 0,
870 rxrpc_kernel_abort_call(net->socket, call->rxcall,
882 void afs_send_simple_reply(struct afs_call *call, const void *buf, size_t len)
884 struct afs_net *net = call->net;
891 rxrpc_kernel_set_tx_length(net->socket, call->rxcall, len);
902 n = rxrpc_kernel_send_data(net->socket, call->rxcall, &msg, len,
912 rxrpc_kernel_abort_call(net->socket, call->rxcall,
921 int afs_extract_data(struct afs_call *call, bool want_more)
923 struct afs_net *net = call->net;
924 struct iov_iter *iter = call->iter;
929 _enter("{%s,%zu},%d", call->type->name, iov_iter_count(iter), want_more);
931 ret = rxrpc_kernel_recv_data(net->socket, call->rxcall, iter,
933 &call->service_id);
937 state = READ_ONCE(call->state);
941 afs_set_call_state(call, state, AFS_CALL_CL_PROC_REPLY);
944 afs_set_call_state(call, state, AFS_CALL_SV_REPLYING);
947 kdebug("prem complete %d", call->error);
948 return afs_io_error(call, afs_io_error_extract);
955 afs_set_call_complete(call, ret, remote_abort);
962 noinline int afs_protocol_error(struct afs_call *call,
965 trace_afs_protocol_error(call, cause);
966 if (call)
967 call->unmarshalling_error = true;