1 /* Maintain an RxRPC server socket to do AFS communications through
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #include <linux/slab.h>
13 #include <linux/sched/signal.h>
16 #include <net/af_rxrpc.h>
20 struct workqueue_struct *afs_async_calls;
22 static void afs_wake_up_call_waiter(struct sock *, struct rxrpc_call *, unsigned long);
23 static long afs_wait_for_call_to_complete(struct afs_call *, struct afs_addr_cursor *);
24 static void afs_wake_up_async_call(struct sock *, struct rxrpc_call *, unsigned long);
25 static void afs_process_async_call(struct work_struct *);
26 static void afs_rx_new_call(struct sock *, struct rxrpc_call *, unsigned long);
27 static void afs_rx_discard_new_call(struct rxrpc_call *, unsigned long);
28 static int afs_deliver_cm_op_id(struct afs_call *);
30 /* asynchronous incoming call initial processing */
31 static const struct afs_call_type afs_RXCMxxxx = {
33 .deliver = afs_deliver_cm_op_id,
37 * open an RxRPC socket and bind it to be a server for callback notifications
38 * - the socket is left in blocking mode and non-blocking ops use MSG_DONTWAIT
40 int afs_open_socket(struct afs_net *net)
42 struct sockaddr_rxrpc srx;
43 struct socket *socket;
48 ret = sock_create_kern(&init_net, AF_RXRPC, SOCK_DGRAM, PF_INET6, &socket);
52 socket->sk->sk_allocation = GFP_NOFS;
54 /* bind the callback manager's address to make this a server socket */
55 memset(&srx, 0, sizeof(srx));
56 srx.srx_family = AF_RXRPC;
57 srx.srx_service = CM_SERVICE;
58 srx.transport_type = SOCK_DGRAM;
59 srx.transport_len = sizeof(srx.transport.sin6);
60 srx.transport.sin6.sin6_family = AF_INET6;
61 srx.transport.sin6.sin6_port = htons(AFS_CM_PORT);
63 ret = kernel_bind(socket, (struct sockaddr *) &srx, sizeof(srx));
67 rxrpc_kernel_new_call_notification(socket, afs_rx_new_call,
68 afs_rx_discard_new_call);
70 ret = kernel_listen(socket, INT_MAX);
75 afs_charge_preallocation(&net->charge_preallocation_work);
87 * close the RxRPC socket AFS was using
89 void afs_close_socket(struct afs_net *net)
93 kernel_listen(net->socket, 0);
94 flush_workqueue(afs_async_calls);
96 if (net->spare_incoming_call) {
97 afs_put_call(net->spare_incoming_call);
98 net->spare_incoming_call = NULL;
101 _debug("outstanding %u", atomic_read(&net->nr_outstanding_calls));
102 wait_on_atomic_t(&net->nr_outstanding_calls, atomic_t_wait,
103 TASK_UNINTERRUPTIBLE);
104 _debug("no outstanding calls");
106 kernel_sock_shutdown(net->socket, SHUT_RDWR);
107 flush_workqueue(afs_async_calls);
108 sock_release(net->socket);
117 static struct afs_call *afs_alloc_call(struct afs_net *net,
118 const struct afs_call_type *type,
121 struct afs_call *call;
124 call = kzalloc(sizeof(*call), gfp);
130 atomic_set(&call->usage, 1);
131 INIT_WORK(&call->async_work, afs_process_async_call);
132 init_waitqueue_head(&call->waitq);
134 o = atomic_inc_return(&net->nr_outstanding_calls);
135 trace_afs_call(call, afs_call_trace_alloc, 1, o,
136 __builtin_return_address(0));
141 * Dispose of a reference on a call.
143 void afs_put_call(struct afs_call *call)
145 struct afs_net *net = call->net;
146 int n = atomic_dec_return(&call->usage);
147 int o = atomic_read(&net->nr_outstanding_calls);
149 trace_afs_call(call, afs_call_trace_put, n + 1, o,
150 __builtin_return_address(0));
154 ASSERT(!work_pending(&call->async_work));
155 ASSERT(call->type->name != NULL);
158 rxrpc_kernel_end_call(net->socket, call->rxcall);
161 if (call->type->destructor)
162 call->type->destructor(call);
164 afs_put_server(call->net, call->cm_server);
165 afs_put_cb_interest(call->net, call->cbi);
166 kfree(call->request);
169 o = atomic_dec_return(&net->nr_outstanding_calls);
170 trace_afs_call(call, afs_call_trace_free, 0, o,
171 __builtin_return_address(0));
173 wake_up_atomic_t(&net->nr_outstanding_calls);
178 * Queue the call for actual work. Returns 0 unconditionally for convenience.
180 int afs_queue_call_work(struct afs_call *call)
182 int u = atomic_inc_return(&call->usage);
184 trace_afs_call(call, afs_call_trace_work, u,
185 atomic_read(&call->net->nr_outstanding_calls),
186 __builtin_return_address(0));
188 INIT_WORK(&call->work, call->type->work);
190 if (!queue_work(afs_wq, &call->work))
196 * allocate a call with flat request and reply buffers
198 struct afs_call *afs_alloc_flat_call(struct afs_net *net,
199 const struct afs_call_type *type,
200 size_t request_size, size_t reply_max)
202 struct afs_call *call;
204 call = afs_alloc_call(net, type, GFP_NOFS);
209 call->request_size = request_size;
210 call->request = kmalloc(request_size, GFP_NOFS);
216 call->reply_max = reply_max;
217 call->buffer = kmalloc(reply_max, GFP_NOFS);
222 init_waitqueue_head(&call->waitq);
232 * clean up a call with flat buffer
234 void afs_flat_call_destructor(struct afs_call *call)
238 kfree(call->request);
239 call->request = NULL;
244 #define AFS_BVEC_MAX 8
247 * Load the given bvec with the next few pages.
249 static void afs_load_bvec(struct afs_call *call, struct msghdr *msg,
250 struct bio_vec *bv, pgoff_t first, pgoff_t last,
253 struct page *pages[AFS_BVEC_MAX];
254 unsigned int nr, n, i, to, bytes = 0;
256 nr = min_t(pgoff_t, last - first + 1, AFS_BVEC_MAX);
257 n = find_get_pages_contig(call->mapping, first, nr, pages);
258 ASSERTCMP(n, ==, nr);
260 msg->msg_flags |= MSG_MORE;
261 for (i = 0; i < nr; i++) {
263 if (first + i >= last) {
265 msg->msg_flags &= ~MSG_MORE;
267 bv[i].bv_page = pages[i];
268 bv[i].bv_len = to - offset;
269 bv[i].bv_offset = offset;
270 bytes += to - offset;
274 iov_iter_bvec(&msg->msg_iter, WRITE | ITER_BVEC, bv, nr, bytes);
278 * Advance the AFS call state when the RxRPC call ends the transmit phase.
280 static void afs_notify_end_request_tx(struct sock *sock,
281 struct rxrpc_call *rxcall,
282 unsigned long call_user_ID)
284 struct afs_call *call = (struct afs_call *)call_user_ID;
286 if (call->state == AFS_CALL_REQUESTING)
287 call->state = AFS_CALL_AWAIT_REPLY;
291 * attach the data from a bunch of pages on an inode to a call
293 static int afs_send_pages(struct afs_call *call, struct msghdr *msg)
295 struct bio_vec bv[AFS_BVEC_MAX];
296 unsigned int bytes, nr, loop, offset;
297 pgoff_t first = call->first, last = call->last;
300 offset = call->first_offset;
301 call->first_offset = 0;
304 afs_load_bvec(call, msg, bv, first, last, offset);
306 bytes = msg->msg_iter.count;
307 nr = msg->msg_iter.nr_segs;
309 ret = rxrpc_kernel_send_data(call->net->socket, call->rxcall, msg,
310 bytes, afs_notify_end_request_tx);
311 for (loop = 0; loop < nr; loop++)
312 put_page(bv[loop].bv_page);
317 } while (first <= last);
325 long afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call,
326 gfp_t gfp, bool async)
328 struct sockaddr_rxrpc *srx = ac->addr;
329 struct rxrpc_call *rxcall;
336 _enter(",{%pISp},", &srx->transport);
338 ASSERT(call->type != NULL);
339 ASSERT(call->type->name != NULL);
341 _debug("____MAKE %p{%s,%x} [%d]____",
342 call, call->type->name, key_serial(call->key),
343 atomic_read(&call->net->nr_outstanding_calls));
347 /* Work out the length we're going to transmit. This is awkward for
348 * calls such as FS.StoreData where there's an extra injection of data
349 * after the initial fixed part.
351 tx_total_len = call->request_size;
352 if (call->send_pages) {
353 tx_total_len += call->last_to - call->first_offset;
354 tx_total_len += (call->last - call->first) * PAGE_SIZE;
358 rxcall = rxrpc_kernel_begin_call(call->net->socket, srx, call->key,
362 afs_wake_up_async_call :
363 afs_wake_up_call_waiter),
365 if (IS_ERR(rxcall)) {
366 ret = PTR_ERR(rxcall);
367 goto error_kill_call;
370 call->rxcall = rxcall;
372 /* send the request */
373 iov[0].iov_base = call->request;
374 iov[0].iov_len = call->request_size;
378 iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, iov, 1,
380 msg.msg_control = NULL;
381 msg.msg_controllen = 0;
382 msg.msg_flags = MSG_WAITALL | (call->send_pages ? MSG_MORE : 0);
384 /* We have to change the state *before* sending the last packet as
385 * rxrpc might give us the reply before it returns from sending the
386 * request. Further, if the send fails, we may already have been given
387 * a notification and may have collected it.
389 if (!call->send_pages)
390 call->state = AFS_CALL_AWAIT_REPLY;
391 ret = rxrpc_kernel_send_data(call->net->socket, rxcall,
392 &msg, call->request_size,
393 afs_notify_end_request_tx);
397 if (call->send_pages) {
398 ret = afs_send_pages(call, &msg);
403 /* at this point, an async call may no longer exist as it may have
404 * already completed */
408 return afs_wait_for_call_to_complete(call, ac);
411 call->state = AFS_CALL_COMPLETE;
412 if (ret != -ECONNABORTED) {
413 rxrpc_kernel_abort_call(call->net->socket, rxcall,
414 RX_USER_ABORT, ret, "KSD");
417 rxrpc_kernel_recv_data(call->net->socket, rxcall, NULL,
418 0, &offset, false, &call->abort_code,
420 ac->abort_code = call->abort_code;
421 ac->responded = true;
426 _leave(" = %d", ret);
431 * deliver messages to a call
433 static void afs_deliver_to_call(struct afs_call *call)
438 _enter("%s", call->type->name);
440 while (call->state == AFS_CALL_AWAIT_REPLY ||
441 call->state == AFS_CALL_AWAIT_OP_ID ||
442 call->state == AFS_CALL_AWAIT_REQUEST ||
443 call->state == AFS_CALL_AWAIT_ACK
445 if (call->state == AFS_CALL_AWAIT_ACK) {
447 ret = rxrpc_kernel_recv_data(call->net->socket,
449 NULL, 0, &offset, false,
452 trace_afs_recv_data(call, 0, offset, false, ret);
454 if (ret == -EINPROGRESS || ret == -EAGAIN)
456 if (ret == 1 || ret < 0) {
457 call->state = AFS_CALL_COMPLETE;
463 ret = call->type->deliver(call);
466 if (call->state == AFS_CALL_AWAIT_REPLY)
467 call->state = AFS_CALL_COMPLETE;
475 abort_code = RX_CALL_DEAD;
476 rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
477 abort_code, ret, "KNC");
480 abort_code = RXGEN_OPCODE;
481 rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
482 abort_code, ret, "KIV");
488 abort_code = RXGEN_CC_UNMARSHAL;
489 if (call->state != AFS_CALL_AWAIT_REPLY)
490 abort_code = RXGEN_SS_UNMARSHAL;
491 rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
492 abort_code, -EBADMSG, "KUM");
498 if (call->state == AFS_CALL_COMPLETE && call->incoming)
506 call->state = AFS_CALL_COMPLETE;
511 * wait synchronously for a call to complete
513 static long afs_wait_for_call_to_complete(struct afs_call *call,
514 struct afs_addr_cursor *ac)
516 signed long rtt2, timeout;
521 DECLARE_WAITQUEUE(myself, current);
525 rtt = rxrpc_kernel_get_rtt(call->net->socket, call->rxcall);
526 rtt2 = nsecs_to_jiffies64(rtt) * 2;
531 last_life = rxrpc_kernel_check_life(call->net->socket, call->rxcall);
533 add_wait_queue(&call->waitq, &myself);
535 set_current_state(TASK_UNINTERRUPTIBLE);
537 /* deliver any messages that are in the queue */
538 if (call->state < AFS_CALL_COMPLETE && call->need_attention) {
539 call->need_attention = false;
540 __set_current_state(TASK_RUNNING);
541 afs_deliver_to_call(call);
545 if (call->state == AFS_CALL_COMPLETE)
548 life = rxrpc_kernel_check_life(call->net->socket, call->rxcall);
550 life == last_life && signal_pending(current))
553 if (life != last_life) {
558 timeout = schedule_timeout(timeout);
561 remove_wait_queue(&call->waitq, &myself);
562 __set_current_state(TASK_RUNNING);
564 /* Kill off the call if it's still live. */
565 if (call->state < AFS_CALL_COMPLETE) {
566 _debug("call interrupted");
567 if (rxrpc_kernel_abort_call(call->net->socket, call->rxcall,
568 RX_USER_ABORT, -EINTR, "KWI"))
569 call->error = -ERESTARTSYS;
572 ac->abort_code = call->abort_code;
573 ac->error = call->error;
578 if (call->ret_reply0) {
579 ret = (long)call->reply[0];
580 call->reply[0] = NULL;
584 ac->responded = true;
588 _debug("call complete");
590 _leave(" = %p", (void *)ret);
595 * wake up a waiting call
597 static void afs_wake_up_call_waiter(struct sock *sk, struct rxrpc_call *rxcall,
598 unsigned long call_user_ID)
600 struct afs_call *call = (struct afs_call *)call_user_ID;
602 call->need_attention = true;
603 wake_up(&call->waitq);
607 * wake up an asynchronous call
609 static void afs_wake_up_async_call(struct sock *sk, struct rxrpc_call *rxcall,
610 unsigned long call_user_ID)
612 struct afs_call *call = (struct afs_call *)call_user_ID;
615 trace_afs_notify_call(rxcall, call);
616 call->need_attention = true;
618 u = __atomic_add_unless(&call->usage, 1, 0);
620 trace_afs_call(call, afs_call_trace_wake, u,
621 atomic_read(&call->net->nr_outstanding_calls),
622 __builtin_return_address(0));
624 if (!queue_work(afs_async_calls, &call->async_work))
630 * Delete an asynchronous call. The work item carries a ref to the call struct
631 * that we need to release.
633 static void afs_delete_async_call(struct work_struct *work)
635 struct afs_call *call = container_of(work, struct afs_call, async_work);
645 * Perform I/O processing on an asynchronous call. The work item carries a ref
646 * to the call struct that we either need to release or to pass on.
648 static void afs_process_async_call(struct work_struct *work)
650 struct afs_call *call = container_of(work, struct afs_call, async_work);
654 if (call->state < AFS_CALL_COMPLETE && call->need_attention) {
655 call->need_attention = false;
656 afs_deliver_to_call(call);
659 if (call->state == AFS_CALL_COMPLETE) {
660 call->reply[0] = NULL;
662 /* We have two refs to release - one from the alloc and one
663 * queued with the work item - and we can't just deallocate the
664 * call because the work item may be queued again.
666 call->async_work.func = afs_delete_async_call;
667 if (!queue_work(afs_async_calls, &call->async_work))
675 static void afs_rx_attach(struct rxrpc_call *rxcall, unsigned long user_call_ID)
677 struct afs_call *call = (struct afs_call *)user_call_ID;
679 call->rxcall = rxcall;
683 * Charge the incoming call preallocation.
685 void afs_charge_preallocation(struct work_struct *work)
687 struct afs_net *net =
688 container_of(work, struct afs_net, charge_preallocation_work);
689 struct afs_call *call = net->spare_incoming_call;
693 call = afs_alloc_call(net, &afs_RXCMxxxx, GFP_KERNEL);
698 call->state = AFS_CALL_AWAIT_OP_ID;
699 init_waitqueue_head(&call->waitq);
702 if (rxrpc_kernel_charge_accept(net->socket,
703 afs_wake_up_async_call,
710 net->spare_incoming_call = call;
714 * Discard a preallocated call when a socket is shut down.
716 static void afs_rx_discard_new_call(struct rxrpc_call *rxcall,
717 unsigned long user_call_ID)
719 struct afs_call *call = (struct afs_call *)user_call_ID;
726 * Notification of an incoming call.
728 static void afs_rx_new_call(struct sock *sk, struct rxrpc_call *rxcall,
729 unsigned long user_call_ID)
731 struct afs_net *net = afs_sock2net(sk);
733 queue_work(afs_wq, &net->charge_preallocation_work);
737 * Grab the operation ID from an incoming cache manager call. The socket
738 * buffer is discarded on error or if we don't yet have sufficient data.
740 static int afs_deliver_cm_op_id(struct afs_call *call)
744 _enter("{%zu}", call->offset);
746 ASSERTCMP(call->offset, <, 4);
748 /* the operation ID forms the first four bytes of the request data */
749 ret = afs_extract_data(call, &call->tmp, 4, true);
753 call->operation_ID = ntohl(call->tmp);
754 call->state = AFS_CALL_AWAIT_REQUEST;
757 /* ask the cache manager to route the call (it'll change the call type
759 if (!afs_cm_incoming_call(call))
762 trace_afs_cb_call(call);
764 /* pass responsibility for the remainer of this message off to the
765 * cache manager op */
766 return call->type->deliver(call);
770 * Advance the AFS call state when an RxRPC service call ends the transmit
773 static void afs_notify_end_reply_tx(struct sock *sock,
774 struct rxrpc_call *rxcall,
775 unsigned long call_user_ID)
777 struct afs_call *call = (struct afs_call *)call_user_ID;
779 if (call->state == AFS_CALL_REPLYING)
780 call->state = AFS_CALL_AWAIT_ACK;
784 * send an empty reply
786 void afs_send_empty_reply(struct afs_call *call)
788 struct afs_net *net = call->net;
793 rxrpc_kernel_set_tx_length(net->socket, call->rxcall, 0);
797 iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, NULL, 0, 0);
798 msg.msg_control = NULL;
799 msg.msg_controllen = 0;
802 call->state = AFS_CALL_AWAIT_ACK;
803 switch (rxrpc_kernel_send_data(net->socket, call->rxcall, &msg, 0,
804 afs_notify_end_reply_tx)) {
806 _leave(" [replied]");
811 rxrpc_kernel_abort_call(net->socket, call->rxcall,
812 RX_USER_ABORT, -ENOMEM, "KOO");
820 * send a simple reply
822 void afs_send_simple_reply(struct afs_call *call, const void *buf, size_t len)
824 struct afs_net *net = call->net;
831 rxrpc_kernel_set_tx_length(net->socket, call->rxcall, len);
833 iov[0].iov_base = (void *) buf;
834 iov[0].iov_len = len;
837 iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, iov, 1, len);
838 msg.msg_control = NULL;
839 msg.msg_controllen = 0;
842 call->state = AFS_CALL_AWAIT_ACK;
843 n = rxrpc_kernel_send_data(net->socket, call->rxcall, &msg, len,
844 afs_notify_end_reply_tx);
847 _leave(" [replied]");
853 rxrpc_kernel_abort_call(net->socket, call->rxcall,
854 RX_USER_ABORT, -ENOMEM, "KOO");
860 * Extract a piece of data from the received data socket buffers.
862 int afs_extract_data(struct afs_call *call, void *buf, size_t count,
865 struct afs_net *net = call->net;
868 _enter("{%s,%zu},,%zu,%d",
869 call->type->name, call->offset, count, want_more);
871 ASSERTCMP(call->offset, <=, count);
873 ret = rxrpc_kernel_recv_data(net->socket, call->rxcall,
874 buf, count, &call->offset,
875 want_more, &call->abort_code,
877 trace_afs_recv_data(call, count, call->offset, want_more, ret);
878 if (ret == 0 || ret == -EAGAIN)
882 switch (call->state) {
883 case AFS_CALL_AWAIT_REPLY:
884 call->state = AFS_CALL_COMPLETE;
886 case AFS_CALL_AWAIT_REQUEST:
887 call->state = AFS_CALL_REPLYING;
896 call->state = AFS_CALL_COMPLETE;