1 /* Maintain an RxRPC server socket to do AFS communications through 2 * 3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 5 * 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. 10 */ 11 12 #include <linux/slab.h> 13 #include <linux/sched/signal.h> 14 15 #include <net/sock.h> 16 #include <net/af_rxrpc.h> 17 #include "internal.h" 18 #include "afs_cm.h" 19 20 struct workqueue_struct *afs_async_calls; 21 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 *); 29 30 /* asynchronous incoming call initial processing */ 31 static const struct afs_call_type afs_RXCMxxxx = { 32 .name = "CB.xxxx", 33 .deliver = afs_deliver_cm_op_id, 34 }; 35 36 /* 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 39 */ 40 int afs_open_socket(struct afs_net *net) 41 { 42 struct sockaddr_rxrpc srx; 43 struct socket *socket; 44 int ret; 45 46 _enter(""); 47 48 ret = sock_create_kern(&init_net, AF_RXRPC, SOCK_DGRAM, PF_INET6, &socket); 49 if (ret < 0) 50 goto error_1; 51 52 socket->sk->sk_allocation = GFP_NOFS; 53 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); 62 63 ret = kernel_bind(socket, (struct sockaddr *) &srx, sizeof(srx)); 64 if (ret < 0) 65 goto error_2; 66 67 rxrpc_kernel_new_call_notification(socket, afs_rx_new_call, 68 afs_rx_discard_new_call); 69 70 ret = kernel_listen(socket, INT_MAX); 71 if (ret < 0) 72 goto error_2; 73 74 net->socket = socket; 75 afs_charge_preallocation(&net->charge_preallocation_work); 76 _leave(" = 0"); 77 return 0; 78 79 error_2: 80 sock_release(socket); 81 error_1: 82 _leave(" = %d", ret); 83 return ret; 84 } 85 86 /* 87 * close the RxRPC socket AFS was using 88 */ 89 void afs_close_socket(struct afs_net *net) 90 { 91 _enter(""); 92 93 kernel_listen(net->socket, 0); 94 flush_workqueue(afs_async_calls); 95 96 if (net->spare_incoming_call) { 97 afs_put_call(net->spare_incoming_call); 98 net->spare_incoming_call = NULL; 99 } 100 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"); 105 106 kernel_sock_shutdown(net->socket, SHUT_RDWR); 107 flush_workqueue(afs_async_calls); 108 sock_release(net->socket); 109 110 _debug("dework"); 111 _leave(""); 112 } 113 114 /* 115 * Allocate a call. 116 */ 117 static struct afs_call *afs_alloc_call(struct afs_net *net, 118 const struct afs_call_type *type, 119 gfp_t gfp) 120 { 121 struct afs_call *call; 122 int o; 123 124 call = kzalloc(sizeof(*call), gfp); 125 if (!call) 126 return NULL; 127 128 call->type = type; 129 call->net = net; 130 atomic_set(&call->usage, 1); 131 INIT_WORK(&call->async_work, afs_process_async_call); 132 init_waitqueue_head(&call->waitq); 133 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)); 137 return call; 138 } 139 140 /* 141 * Dispose of a reference on a call. 142 */ 143 void afs_put_call(struct afs_call *call) 144 { 145 struct afs_net *net = call->net; 146 int n = atomic_dec_return(&call->usage); 147 int o = atomic_read(&net->nr_outstanding_calls); 148 149 trace_afs_call(call, afs_call_trace_put, n + 1, o, 150 __builtin_return_address(0)); 151 152 ASSERTCMP(n, >=, 0); 153 if (n == 0) { 154 ASSERT(!work_pending(&call->async_work)); 155 ASSERT(call->type->name != NULL); 156 157 if (call->rxcall) { 158 rxrpc_kernel_end_call(net->socket, call->rxcall); 159 call->rxcall = NULL; 160 } 161 if (call->type->destructor) 162 call->type->destructor(call); 163 164 afs_put_server(call->net, call->cm_server); 165 afs_put_cb_interest(call->net, call->cbi); 166 kfree(call->request); 167 kfree(call); 168 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)); 172 if (o == 0) 173 wake_up_atomic_t(&net->nr_outstanding_calls); 174 } 175 } 176 177 /* 178 * Queue the call for actual work. Returns 0 unconditionally for convenience. 179 */ 180 int afs_queue_call_work(struct afs_call *call) 181 { 182 int u = atomic_inc_return(&call->usage); 183 184 trace_afs_call(call, afs_call_trace_work, u, 185 atomic_read(&call->net->nr_outstanding_calls), 186 __builtin_return_address(0)); 187 188 INIT_WORK(&call->work, call->type->work); 189 190 if (!queue_work(afs_wq, &call->work)) 191 afs_put_call(call); 192 return 0; 193 } 194 195 /* 196 * allocate a call with flat request and reply buffers 197 */ 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) 201 { 202 struct afs_call *call; 203 204 call = afs_alloc_call(net, type, GFP_NOFS); 205 if (!call) 206 goto nomem_call; 207 208 if (request_size) { 209 call->request_size = request_size; 210 call->request = kmalloc(request_size, GFP_NOFS); 211 if (!call->request) 212 goto nomem_free; 213 } 214 215 if (reply_max) { 216 call->reply_max = reply_max; 217 call->buffer = kmalloc(reply_max, GFP_NOFS); 218 if (!call->buffer) 219 goto nomem_free; 220 } 221 222 call->operation_ID = type->op; 223 init_waitqueue_head(&call->waitq); 224 return call; 225 226 nomem_free: 227 afs_put_call(call); 228 nomem_call: 229 return NULL; 230 } 231 232 /* 233 * clean up a call with flat buffer 234 */ 235 void afs_flat_call_destructor(struct afs_call *call) 236 { 237 _enter(""); 238 239 kfree(call->request); 240 call->request = NULL; 241 kfree(call->buffer); 242 call->buffer = NULL; 243 } 244 245 #define AFS_BVEC_MAX 8 246 247 /* 248 * Load the given bvec with the next few pages. 249 */ 250 static void afs_load_bvec(struct afs_call *call, struct msghdr *msg, 251 struct bio_vec *bv, pgoff_t first, pgoff_t last, 252 unsigned offset) 253 { 254 struct page *pages[AFS_BVEC_MAX]; 255 unsigned int nr, n, i, to, bytes = 0; 256 257 nr = min_t(pgoff_t, last - first + 1, AFS_BVEC_MAX); 258 n = find_get_pages_contig(call->mapping, first, nr, pages); 259 ASSERTCMP(n, ==, nr); 260 261 msg->msg_flags |= MSG_MORE; 262 for (i = 0; i < nr; i++) { 263 to = PAGE_SIZE; 264 if (first + i >= last) { 265 to = call->last_to; 266 msg->msg_flags &= ~MSG_MORE; 267 } 268 bv[i].bv_page = pages[i]; 269 bv[i].bv_len = to - offset; 270 bv[i].bv_offset = offset; 271 bytes += to - offset; 272 offset = 0; 273 } 274 275 iov_iter_bvec(&msg->msg_iter, WRITE | ITER_BVEC, bv, nr, bytes); 276 } 277 278 /* 279 * Advance the AFS call state when the RxRPC call ends the transmit phase. 280 */ 281 static void afs_notify_end_request_tx(struct sock *sock, 282 struct rxrpc_call *rxcall, 283 unsigned long call_user_ID) 284 { 285 struct afs_call *call = (struct afs_call *)call_user_ID; 286 287 if (call->state == AFS_CALL_REQUESTING) 288 call->state = AFS_CALL_AWAIT_REPLY; 289 } 290 291 /* 292 * attach the data from a bunch of pages on an inode to a call 293 */ 294 static int afs_send_pages(struct afs_call *call, struct msghdr *msg) 295 { 296 struct bio_vec bv[AFS_BVEC_MAX]; 297 unsigned int bytes, nr, loop, offset; 298 pgoff_t first = call->first, last = call->last; 299 int ret; 300 301 offset = call->first_offset; 302 call->first_offset = 0; 303 304 do { 305 afs_load_bvec(call, msg, bv, first, last, offset); 306 trace_afs_send_pages(call, msg, first, last, offset); 307 308 offset = 0; 309 bytes = msg->msg_iter.count; 310 nr = msg->msg_iter.nr_segs; 311 312 ret = rxrpc_kernel_send_data(call->net->socket, call->rxcall, msg, 313 bytes, afs_notify_end_request_tx); 314 for (loop = 0; loop < nr; loop++) 315 put_page(bv[loop].bv_page); 316 if (ret < 0) 317 break; 318 319 first += nr; 320 } while (first <= last); 321 322 trace_afs_sent_pages(call, call->first, last, first, ret); 323 return ret; 324 } 325 326 /* 327 * initiate a call 328 */ 329 long afs_make_call(struct afs_addr_cursor *ac, struct afs_call *call, 330 gfp_t gfp, bool async) 331 { 332 struct sockaddr_rxrpc *srx = ac->addr; 333 struct rxrpc_call *rxcall; 334 struct msghdr msg; 335 struct kvec iov[1]; 336 size_t offset; 337 s64 tx_total_len; 338 int ret; 339 340 _enter(",{%pISp},", &srx->transport); 341 342 ASSERT(call->type != NULL); 343 ASSERT(call->type->name != NULL); 344 345 _debug("____MAKE %p{%s,%x} [%d]____", 346 call, call->type->name, key_serial(call->key), 347 atomic_read(&call->net->nr_outstanding_calls)); 348 349 call->async = async; 350 351 /* Work out the length we're going to transmit. This is awkward for 352 * calls such as FS.StoreData where there's an extra injection of data 353 * after the initial fixed part. 354 */ 355 tx_total_len = call->request_size; 356 if (call->send_pages) { 357 if (call->last == call->first) { 358 tx_total_len += call->last_to - call->first_offset; 359 } else { 360 /* It looks mathematically like you should be able to 361 * combine the following lines with the ones above, but 362 * unsigned arithmetic is fun when it wraps... 363 */ 364 tx_total_len += PAGE_SIZE - call->first_offset; 365 tx_total_len += call->last_to; 366 tx_total_len += (call->last - call->first - 1) * PAGE_SIZE; 367 } 368 } 369 370 /* create a call */ 371 rxcall = rxrpc_kernel_begin_call(call->net->socket, srx, call->key, 372 (unsigned long)call, 373 tx_total_len, gfp, 374 (async ? 375 afs_wake_up_async_call : 376 afs_wake_up_call_waiter), 377 call->upgrade); 378 if (IS_ERR(rxcall)) { 379 ret = PTR_ERR(rxcall); 380 goto error_kill_call; 381 } 382 383 call->rxcall = rxcall; 384 385 /* send the request */ 386 iov[0].iov_base = call->request; 387 iov[0].iov_len = call->request_size; 388 389 msg.msg_name = NULL; 390 msg.msg_namelen = 0; 391 iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, iov, 1, 392 call->request_size); 393 msg.msg_control = NULL; 394 msg.msg_controllen = 0; 395 msg.msg_flags = MSG_WAITALL | (call->send_pages ? MSG_MORE : 0); 396 397 ret = rxrpc_kernel_send_data(call->net->socket, rxcall, 398 &msg, call->request_size, 399 afs_notify_end_request_tx); 400 if (ret < 0) 401 goto error_do_abort; 402 403 if (call->send_pages) { 404 ret = afs_send_pages(call, &msg); 405 if (ret < 0) 406 goto error_do_abort; 407 } 408 409 /* at this point, an async call may no longer exist as it may have 410 * already completed */ 411 if (call->async) 412 return -EINPROGRESS; 413 414 return afs_wait_for_call_to_complete(call, ac); 415 416 error_do_abort: 417 call->state = AFS_CALL_COMPLETE; 418 if (ret != -ECONNABORTED) { 419 rxrpc_kernel_abort_call(call->net->socket, rxcall, 420 RX_USER_ABORT, ret, "KSD"); 421 } else { 422 offset = 0; 423 rxrpc_kernel_recv_data(call->net->socket, rxcall, NULL, 424 0, &offset, false, &call->abort_code, 425 &call->service_id); 426 ac->abort_code = call->abort_code; 427 ac->responded = true; 428 } 429 call->error = ret; 430 trace_afs_call_done(call); 431 error_kill_call: 432 afs_put_call(call); 433 ac->error = ret; 434 _leave(" = %d", ret); 435 return ret; 436 } 437 438 /* 439 * deliver messages to a call 440 */ 441 static void afs_deliver_to_call(struct afs_call *call) 442 { 443 u32 abort_code; 444 int ret; 445 446 _enter("%s", call->type->name); 447 448 while (call->state == AFS_CALL_AWAIT_REPLY || 449 call->state == AFS_CALL_AWAIT_OP_ID || 450 call->state == AFS_CALL_AWAIT_REQUEST || 451 call->state == AFS_CALL_AWAIT_ACK 452 ) { 453 if (call->state == AFS_CALL_AWAIT_ACK) { 454 size_t offset = 0; 455 ret = rxrpc_kernel_recv_data(call->net->socket, 456 call->rxcall, 457 NULL, 0, &offset, false, 458 &call->abort_code, 459 &call->service_id); 460 trace_afs_recv_data(call, 0, offset, false, ret); 461 462 if (ret == -EINPROGRESS || ret == -EAGAIN) 463 return; 464 if (ret < 0) 465 call->error = ret; 466 if (ret < 0 || ret == 1) 467 goto call_complete; 468 return; 469 } 470 471 ret = call->type->deliver(call); 472 switch (ret) { 473 case 0: 474 if (call->state == AFS_CALL_AWAIT_REPLY) 475 goto call_complete; 476 goto done; 477 case -EINPROGRESS: 478 case -EAGAIN: 479 goto out; 480 case -ECONNABORTED: 481 goto save_error; 482 case -ENOTCONN: 483 abort_code = RX_CALL_DEAD; 484 rxrpc_kernel_abort_call(call->net->socket, call->rxcall, 485 abort_code, ret, "KNC"); 486 goto save_error; 487 case -ENOTSUPP: 488 abort_code = RXGEN_OPCODE; 489 rxrpc_kernel_abort_call(call->net->socket, call->rxcall, 490 abort_code, ret, "KIV"); 491 goto save_error; 492 case -ENODATA: 493 case -EBADMSG: 494 case -EMSGSIZE: 495 default: 496 abort_code = RXGEN_CC_UNMARSHAL; 497 if (call->state != AFS_CALL_AWAIT_REPLY) 498 abort_code = RXGEN_SS_UNMARSHAL; 499 rxrpc_kernel_abort_call(call->net->socket, call->rxcall, 500 abort_code, -EBADMSG, "KUM"); 501 goto save_error; 502 } 503 } 504 505 done: 506 if (call->state == AFS_CALL_COMPLETE && call->incoming) 507 afs_put_call(call); 508 out: 509 _leave(""); 510 return; 511 512 save_error: 513 call->error = ret; 514 call_complete: 515 if (call->state != AFS_CALL_COMPLETE) { 516 call->state = AFS_CALL_COMPLETE; 517 trace_afs_call_done(call); 518 } 519 goto done; 520 } 521 522 /* 523 * wait synchronously for a call to complete 524 */ 525 static long afs_wait_for_call_to_complete(struct afs_call *call, 526 struct afs_addr_cursor *ac) 527 { 528 signed long rtt2, timeout; 529 long ret; 530 u64 rtt; 531 u32 life, last_life; 532 533 DECLARE_WAITQUEUE(myself, current); 534 535 _enter(""); 536 537 rtt = rxrpc_kernel_get_rtt(call->net->socket, call->rxcall); 538 rtt2 = nsecs_to_jiffies64(rtt) * 2; 539 if (rtt2 < 2) 540 rtt2 = 2; 541 542 timeout = rtt2; 543 last_life = rxrpc_kernel_check_life(call->net->socket, call->rxcall); 544 545 add_wait_queue(&call->waitq, &myself); 546 for (;;) { 547 set_current_state(TASK_UNINTERRUPTIBLE); 548 549 /* deliver any messages that are in the queue */ 550 if (call->state < AFS_CALL_COMPLETE && call->need_attention) { 551 call->need_attention = false; 552 __set_current_state(TASK_RUNNING); 553 afs_deliver_to_call(call); 554 continue; 555 } 556 557 if (call->state == AFS_CALL_COMPLETE) 558 break; 559 560 life = rxrpc_kernel_check_life(call->net->socket, call->rxcall); 561 if (timeout == 0 && 562 life == last_life && signal_pending(current)) 563 break; 564 565 if (life != last_life) { 566 timeout = rtt2; 567 last_life = life; 568 } 569 570 timeout = schedule_timeout(timeout); 571 } 572 573 remove_wait_queue(&call->waitq, &myself); 574 __set_current_state(TASK_RUNNING); 575 576 /* Kill off the call if it's still live. */ 577 if (call->state < AFS_CALL_COMPLETE) { 578 _debug("call interrupted"); 579 if (rxrpc_kernel_abort_call(call->net->socket, call->rxcall, 580 RX_USER_ABORT, -EINTR, "KWI")) { 581 call->error = -ERESTARTSYS; 582 trace_afs_call_done(call); 583 } 584 } 585 586 ac->abort_code = call->abort_code; 587 ac->error = call->error; 588 589 ret = ac->error; 590 switch (ret) { 591 case 0: 592 if (call->ret_reply0) { 593 ret = (long)call->reply[0]; 594 call->reply[0] = NULL; 595 } 596 /* Fall through */ 597 case -ECONNABORTED: 598 ac->responded = true; 599 break; 600 } 601 602 _debug("call complete"); 603 afs_put_call(call); 604 _leave(" = %p", (void *)ret); 605 return ret; 606 } 607 608 /* 609 * wake up a waiting call 610 */ 611 static void afs_wake_up_call_waiter(struct sock *sk, struct rxrpc_call *rxcall, 612 unsigned long call_user_ID) 613 { 614 struct afs_call *call = (struct afs_call *)call_user_ID; 615 616 call->need_attention = true; 617 wake_up(&call->waitq); 618 } 619 620 /* 621 * wake up an asynchronous call 622 */ 623 static void afs_wake_up_async_call(struct sock *sk, struct rxrpc_call *rxcall, 624 unsigned long call_user_ID) 625 { 626 struct afs_call *call = (struct afs_call *)call_user_ID; 627 int u; 628 629 trace_afs_notify_call(rxcall, call); 630 call->need_attention = true; 631 632 u = __atomic_add_unless(&call->usage, 1, 0); 633 if (u != 0) { 634 trace_afs_call(call, afs_call_trace_wake, u, 635 atomic_read(&call->net->nr_outstanding_calls), 636 __builtin_return_address(0)); 637 638 if (!queue_work(afs_async_calls, &call->async_work)) 639 afs_put_call(call); 640 } 641 } 642 643 /* 644 * Delete an asynchronous call. The work item carries a ref to the call struct 645 * that we need to release. 646 */ 647 static void afs_delete_async_call(struct work_struct *work) 648 { 649 struct afs_call *call = container_of(work, struct afs_call, async_work); 650 651 _enter(""); 652 653 afs_put_call(call); 654 655 _leave(""); 656 } 657 658 /* 659 * Perform I/O processing on an asynchronous call. The work item carries a ref 660 * to the call struct that we either need to release or to pass on. 661 */ 662 static void afs_process_async_call(struct work_struct *work) 663 { 664 struct afs_call *call = container_of(work, struct afs_call, async_work); 665 666 _enter(""); 667 668 if (call->state < AFS_CALL_COMPLETE && call->need_attention) { 669 call->need_attention = false; 670 afs_deliver_to_call(call); 671 } 672 673 if (call->state == AFS_CALL_COMPLETE) { 674 call->reply[0] = NULL; 675 676 /* We have two refs to release - one from the alloc and one 677 * queued with the work item - and we can't just deallocate the 678 * call because the work item may be queued again. 679 */ 680 call->async_work.func = afs_delete_async_call; 681 if (!queue_work(afs_async_calls, &call->async_work)) 682 afs_put_call(call); 683 } 684 685 afs_put_call(call); 686 _leave(""); 687 } 688 689 static void afs_rx_attach(struct rxrpc_call *rxcall, unsigned long user_call_ID) 690 { 691 struct afs_call *call = (struct afs_call *)user_call_ID; 692 693 call->rxcall = rxcall; 694 } 695 696 /* 697 * Charge the incoming call preallocation. 698 */ 699 void afs_charge_preallocation(struct work_struct *work) 700 { 701 struct afs_net *net = 702 container_of(work, struct afs_net, charge_preallocation_work); 703 struct afs_call *call = net->spare_incoming_call; 704 705 for (;;) { 706 if (!call) { 707 call = afs_alloc_call(net, &afs_RXCMxxxx, GFP_KERNEL); 708 if (!call) 709 break; 710 711 call->async = true; 712 call->state = AFS_CALL_AWAIT_OP_ID; 713 init_waitqueue_head(&call->waitq); 714 } 715 716 if (rxrpc_kernel_charge_accept(net->socket, 717 afs_wake_up_async_call, 718 afs_rx_attach, 719 (unsigned long)call, 720 GFP_KERNEL) < 0) 721 break; 722 call = NULL; 723 } 724 net->spare_incoming_call = call; 725 } 726 727 /* 728 * Discard a preallocated call when a socket is shut down. 729 */ 730 static void afs_rx_discard_new_call(struct rxrpc_call *rxcall, 731 unsigned long user_call_ID) 732 { 733 struct afs_call *call = (struct afs_call *)user_call_ID; 734 735 call->rxcall = NULL; 736 afs_put_call(call); 737 } 738 739 /* 740 * Notification of an incoming call. 741 */ 742 static void afs_rx_new_call(struct sock *sk, struct rxrpc_call *rxcall, 743 unsigned long user_call_ID) 744 { 745 struct afs_net *net = afs_sock2net(sk); 746 747 queue_work(afs_wq, &net->charge_preallocation_work); 748 } 749 750 /* 751 * Grab the operation ID from an incoming cache manager call. The socket 752 * buffer is discarded on error or if we don't yet have sufficient data. 753 */ 754 static int afs_deliver_cm_op_id(struct afs_call *call) 755 { 756 int ret; 757 758 _enter("{%zu}", call->offset); 759 760 ASSERTCMP(call->offset, <, 4); 761 762 /* the operation ID forms the first four bytes of the request data */ 763 ret = afs_extract_data(call, &call->tmp, 4, true); 764 if (ret < 0) 765 return ret; 766 767 call->operation_ID = ntohl(call->tmp); 768 call->state = AFS_CALL_AWAIT_REQUEST; 769 call->offset = 0; 770 771 /* ask the cache manager to route the call (it'll change the call type 772 * if successful) */ 773 if (!afs_cm_incoming_call(call)) 774 return -ENOTSUPP; 775 776 trace_afs_cb_call(call); 777 778 /* pass responsibility for the remainer of this message off to the 779 * cache manager op */ 780 return call->type->deliver(call); 781 } 782 783 /* 784 * Advance the AFS call state when an RxRPC service call ends the transmit 785 * phase. 786 */ 787 static void afs_notify_end_reply_tx(struct sock *sock, 788 struct rxrpc_call *rxcall, 789 unsigned long call_user_ID) 790 { 791 struct afs_call *call = (struct afs_call *)call_user_ID; 792 793 if (call->state == AFS_CALL_REPLYING) 794 call->state = AFS_CALL_AWAIT_ACK; 795 } 796 797 /* 798 * send an empty reply 799 */ 800 void afs_send_empty_reply(struct afs_call *call) 801 { 802 struct afs_net *net = call->net; 803 struct msghdr msg; 804 805 _enter(""); 806 807 rxrpc_kernel_set_tx_length(net->socket, call->rxcall, 0); 808 809 msg.msg_name = NULL; 810 msg.msg_namelen = 0; 811 iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, NULL, 0, 0); 812 msg.msg_control = NULL; 813 msg.msg_controllen = 0; 814 msg.msg_flags = 0; 815 816 switch (rxrpc_kernel_send_data(net->socket, call->rxcall, &msg, 0, 817 afs_notify_end_reply_tx)) { 818 case 0: 819 _leave(" [replied]"); 820 return; 821 822 case -ENOMEM: 823 _debug("oom"); 824 rxrpc_kernel_abort_call(net->socket, call->rxcall, 825 RX_USER_ABORT, -ENOMEM, "KOO"); 826 default: 827 _leave(" [error]"); 828 return; 829 } 830 } 831 832 /* 833 * send a simple reply 834 */ 835 void afs_send_simple_reply(struct afs_call *call, const void *buf, size_t len) 836 { 837 struct afs_net *net = call->net; 838 struct msghdr msg; 839 struct kvec iov[1]; 840 int n; 841 842 _enter(""); 843 844 rxrpc_kernel_set_tx_length(net->socket, call->rxcall, len); 845 846 iov[0].iov_base = (void *) buf; 847 iov[0].iov_len = len; 848 msg.msg_name = NULL; 849 msg.msg_namelen = 0; 850 iov_iter_kvec(&msg.msg_iter, WRITE | ITER_KVEC, iov, 1, len); 851 msg.msg_control = NULL; 852 msg.msg_controllen = 0; 853 msg.msg_flags = 0; 854 855 n = rxrpc_kernel_send_data(net->socket, call->rxcall, &msg, len, 856 afs_notify_end_reply_tx); 857 if (n >= 0) { 858 /* Success */ 859 _leave(" [replied]"); 860 return; 861 } 862 863 if (n == -ENOMEM) { 864 _debug("oom"); 865 rxrpc_kernel_abort_call(net->socket, call->rxcall, 866 RX_USER_ABORT, -ENOMEM, "KOO"); 867 } 868 _leave(" [error]"); 869 } 870 871 /* 872 * Extract a piece of data from the received data socket buffers. 873 */ 874 int afs_extract_data(struct afs_call *call, void *buf, size_t count, 875 bool want_more) 876 { 877 struct afs_net *net = call->net; 878 int ret; 879 880 _enter("{%s,%zu},,%zu,%d", 881 call->type->name, call->offset, count, want_more); 882 883 ASSERTCMP(call->offset, <=, count); 884 885 ret = rxrpc_kernel_recv_data(net->socket, call->rxcall, 886 buf, count, &call->offset, 887 want_more, &call->abort_code, 888 &call->service_id); 889 trace_afs_recv_data(call, count, call->offset, want_more, ret); 890 if (ret == 0 || ret == -EAGAIN) 891 return ret; 892 893 if (ret == 1) { 894 switch (call->state) { 895 case AFS_CALL_AWAIT_REPLY: 896 call->state = AFS_CALL_COMPLETE; 897 trace_afs_call_done(call); 898 break; 899 case AFS_CALL_AWAIT_REQUEST: 900 call->state = AFS_CALL_REPLYING; 901 break; 902 default: 903 break; 904 } 905 return 0; 906 } 907 908 call->error = ret; 909 call->state = AFS_CALL_COMPLETE; 910 trace_afs_call_done(call); 911 return ret; 912 } 913