1 /* AF_RXRPC implementation 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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 13 14 #include <linux/module.h> 15 #include <linux/kernel.h> 16 #include <linux/net.h> 17 #include <linux/slab.h> 18 #include <linux/skbuff.h> 19 #include <linux/random.h> 20 #include <linux/poll.h> 21 #include <linux/proc_fs.h> 22 #include <linux/key-type.h> 23 #include <net/net_namespace.h> 24 #include <net/sock.h> 25 #include <net/af_rxrpc.h> 26 #define CREATE_TRACE_POINTS 27 #include "ar-internal.h" 28 29 MODULE_DESCRIPTION("RxRPC network protocol"); 30 MODULE_AUTHOR("Red Hat, Inc."); 31 MODULE_LICENSE("GPL"); 32 MODULE_ALIAS_NETPROTO(PF_RXRPC); 33 34 unsigned int rxrpc_debug; // = RXRPC_DEBUG_KPROTO; 35 module_param_named(debug, rxrpc_debug, uint, S_IWUSR | S_IRUGO); 36 MODULE_PARM_DESC(debug, "RxRPC debugging mask"); 37 38 static struct proto rxrpc_proto; 39 static const struct proto_ops rxrpc_rpc_ops; 40 41 /* local epoch for detecting local-end reset */ 42 u32 rxrpc_epoch; 43 44 /* current debugging ID */ 45 atomic_t rxrpc_debug_id; 46 47 /* count of skbs currently in use */ 48 atomic_t rxrpc_n_tx_skbs, rxrpc_n_rx_skbs; 49 50 struct workqueue_struct *rxrpc_workqueue; 51 52 static void rxrpc_sock_destructor(struct sock *); 53 54 /* 55 * see if an RxRPC socket is currently writable 56 */ 57 static inline int rxrpc_writable(struct sock *sk) 58 { 59 return atomic_read(&sk->sk_wmem_alloc) < (size_t) sk->sk_sndbuf; 60 } 61 62 /* 63 * wait for write bufferage to become available 64 */ 65 static void rxrpc_write_space(struct sock *sk) 66 { 67 _enter("%p", sk); 68 rcu_read_lock(); 69 if (rxrpc_writable(sk)) { 70 struct socket_wq *wq = rcu_dereference(sk->sk_wq); 71 72 if (skwq_has_sleeper(wq)) 73 wake_up_interruptible(&wq->wait); 74 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT); 75 } 76 rcu_read_unlock(); 77 } 78 79 /* 80 * validate an RxRPC address 81 */ 82 static int rxrpc_validate_address(struct rxrpc_sock *rx, 83 struct sockaddr_rxrpc *srx, 84 int len) 85 { 86 unsigned int tail; 87 88 if (len < sizeof(struct sockaddr_rxrpc)) 89 return -EINVAL; 90 91 if (srx->srx_family != AF_RXRPC) 92 return -EAFNOSUPPORT; 93 94 if (srx->transport_type != SOCK_DGRAM) 95 return -ESOCKTNOSUPPORT; 96 97 len -= offsetof(struct sockaddr_rxrpc, transport); 98 if (srx->transport_len < sizeof(sa_family_t) || 99 srx->transport_len > len) 100 return -EINVAL; 101 102 if (srx->transport.family != rx->family) 103 return -EAFNOSUPPORT; 104 105 switch (srx->transport.family) { 106 case AF_INET: 107 if (srx->transport_len < sizeof(struct sockaddr_in)) 108 return -EINVAL; 109 tail = offsetof(struct sockaddr_rxrpc, transport.sin.__pad); 110 break; 111 112 #ifdef CONFIG_AF_RXRPC_IPV6 113 case AF_INET6: 114 if (srx->transport_len < sizeof(struct sockaddr_in6)) 115 return -EINVAL; 116 tail = offsetof(struct sockaddr_rxrpc, transport) + 117 sizeof(struct sockaddr_in6); 118 break; 119 #endif 120 121 default: 122 return -EAFNOSUPPORT; 123 } 124 125 if (tail < len) 126 memset((void *)srx + tail, 0, len - tail); 127 _debug("INET: %pISp", &srx->transport); 128 return 0; 129 } 130 131 /* 132 * bind a local address to an RxRPC socket 133 */ 134 static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len) 135 { 136 struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)saddr; 137 struct sock *sk = sock->sk; 138 struct rxrpc_local *local; 139 struct rxrpc_sock *rx = rxrpc_sk(sk); 140 u16 service_id = srx->srx_service; 141 int ret; 142 143 _enter("%p,%p,%d", rx, saddr, len); 144 145 ret = rxrpc_validate_address(rx, srx, len); 146 if (ret < 0) 147 goto error; 148 149 lock_sock(&rx->sk); 150 151 if (rx->sk.sk_state != RXRPC_UNBOUND) { 152 ret = -EINVAL; 153 goto error_unlock; 154 } 155 156 memcpy(&rx->srx, srx, sizeof(rx->srx)); 157 158 local = rxrpc_lookup_local(&rx->srx); 159 if (IS_ERR(local)) { 160 ret = PTR_ERR(local); 161 goto error_unlock; 162 } 163 164 if (service_id) { 165 write_lock(&local->services_lock); 166 if (rcu_access_pointer(local->service)) 167 goto service_in_use; 168 rx->local = local; 169 rcu_assign_pointer(local->service, rx); 170 write_unlock(&local->services_lock); 171 172 rx->sk.sk_state = RXRPC_SERVER_BOUND; 173 } else { 174 rx->local = local; 175 rx->sk.sk_state = RXRPC_CLIENT_BOUND; 176 } 177 178 release_sock(&rx->sk); 179 _leave(" = 0"); 180 return 0; 181 182 service_in_use: 183 write_unlock(&local->services_lock); 184 rxrpc_put_local(local); 185 ret = -EADDRINUSE; 186 error_unlock: 187 release_sock(&rx->sk); 188 error: 189 _leave(" = %d", ret); 190 return ret; 191 } 192 193 /* 194 * set the number of pending calls permitted on a listening socket 195 */ 196 static int rxrpc_listen(struct socket *sock, int backlog) 197 { 198 struct sock *sk = sock->sk; 199 struct rxrpc_sock *rx = rxrpc_sk(sk); 200 unsigned int max, old; 201 int ret; 202 203 _enter("%p,%d", rx, backlog); 204 205 lock_sock(&rx->sk); 206 207 switch (rx->sk.sk_state) { 208 case RXRPC_UNBOUND: 209 ret = -EADDRNOTAVAIL; 210 break; 211 case RXRPC_SERVER_BOUND: 212 ASSERT(rx->local != NULL); 213 max = READ_ONCE(rxrpc_max_backlog); 214 ret = -EINVAL; 215 if (backlog == INT_MAX) 216 backlog = max; 217 else if (backlog < 0 || backlog > max) 218 break; 219 old = sk->sk_max_ack_backlog; 220 sk->sk_max_ack_backlog = backlog; 221 ret = rxrpc_service_prealloc(rx, GFP_KERNEL); 222 if (ret == 0) 223 rx->sk.sk_state = RXRPC_SERVER_LISTENING; 224 else 225 sk->sk_max_ack_backlog = old; 226 break; 227 default: 228 ret = -EBUSY; 229 break; 230 } 231 232 release_sock(&rx->sk); 233 _leave(" = %d", ret); 234 return ret; 235 } 236 237 /** 238 * rxrpc_kernel_begin_call - Allow a kernel service to begin a call 239 * @sock: The socket on which to make the call 240 * @srx: The address of the peer to contact 241 * @key: The security context to use (defaults to socket setting) 242 * @user_call_ID: The ID to use 243 * @gfp: The allocation constraints 244 * @notify_rx: Where to send notifications instead of socket queue 245 * 246 * Allow a kernel service to begin a call on the nominated socket. This just 247 * sets up all the internal tracking structures and allocates connection and 248 * call IDs as appropriate. The call to be used is returned. 249 * 250 * The default socket destination address and security may be overridden by 251 * supplying @srx and @key. 252 */ 253 struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock, 254 struct sockaddr_rxrpc *srx, 255 struct key *key, 256 unsigned long user_call_ID, 257 gfp_t gfp, 258 rxrpc_notify_rx_t notify_rx) 259 { 260 struct rxrpc_conn_parameters cp; 261 struct rxrpc_call *call; 262 struct rxrpc_sock *rx = rxrpc_sk(sock->sk); 263 int ret; 264 265 _enter(",,%x,%lx", key_serial(key), user_call_ID); 266 267 ret = rxrpc_validate_address(rx, srx, sizeof(*srx)); 268 if (ret < 0) 269 return ERR_PTR(ret); 270 271 lock_sock(&rx->sk); 272 273 if (!key) 274 key = rx->key; 275 if (key && !key->payload.data[0]) 276 key = NULL; /* a no-security key */ 277 278 memset(&cp, 0, sizeof(cp)); 279 cp.local = rx->local; 280 cp.key = key; 281 cp.security_level = 0; 282 cp.exclusive = false; 283 cp.service_id = srx->srx_service; 284 call = rxrpc_new_client_call(rx, &cp, srx, user_call_ID, gfp); 285 if (!IS_ERR(call)) 286 call->notify_rx = notify_rx; 287 288 release_sock(&rx->sk); 289 _leave(" = %p", call); 290 return call; 291 } 292 EXPORT_SYMBOL(rxrpc_kernel_begin_call); 293 294 /** 295 * rxrpc_kernel_end_call - Allow a kernel service to end a call it was using 296 * @sock: The socket the call is on 297 * @call: The call to end 298 * 299 * Allow a kernel service to end a call it was using. The call must be 300 * complete before this is called (the call should be aborted if necessary). 301 */ 302 void rxrpc_kernel_end_call(struct socket *sock, struct rxrpc_call *call) 303 { 304 _enter("%d{%d}", call->debug_id, atomic_read(&call->usage)); 305 rxrpc_release_call(rxrpc_sk(sock->sk), call); 306 rxrpc_put_call(call, rxrpc_call_put_kernel); 307 } 308 EXPORT_SYMBOL(rxrpc_kernel_end_call); 309 310 /** 311 * rxrpc_kernel_new_call_notification - Get notifications of new calls 312 * @sock: The socket to intercept received messages on 313 * @notify_new_call: Function to be called when new calls appear 314 * @discard_new_call: Function to discard preallocated calls 315 * 316 * Allow a kernel service to be given notifications about new calls. 317 */ 318 void rxrpc_kernel_new_call_notification( 319 struct socket *sock, 320 rxrpc_notify_new_call_t notify_new_call, 321 rxrpc_discard_new_call_t discard_new_call) 322 { 323 struct rxrpc_sock *rx = rxrpc_sk(sock->sk); 324 325 rx->notify_new_call = notify_new_call; 326 rx->discard_new_call = discard_new_call; 327 } 328 EXPORT_SYMBOL(rxrpc_kernel_new_call_notification); 329 330 /* 331 * connect an RxRPC socket 332 * - this just targets it at a specific destination; no actual connection 333 * negotiation takes place 334 */ 335 static int rxrpc_connect(struct socket *sock, struct sockaddr *addr, 336 int addr_len, int flags) 337 { 338 struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)addr; 339 struct rxrpc_sock *rx = rxrpc_sk(sock->sk); 340 int ret; 341 342 _enter("%p,%p,%d,%d", rx, addr, addr_len, flags); 343 344 ret = rxrpc_validate_address(rx, srx, addr_len); 345 if (ret < 0) { 346 _leave(" = %d [bad addr]", ret); 347 return ret; 348 } 349 350 lock_sock(&rx->sk); 351 352 ret = -EISCONN; 353 if (test_bit(RXRPC_SOCK_CONNECTED, &rx->flags)) 354 goto error; 355 356 switch (rx->sk.sk_state) { 357 case RXRPC_UNBOUND: 358 rx->sk.sk_state = RXRPC_CLIENT_UNBOUND; 359 case RXRPC_CLIENT_UNBOUND: 360 case RXRPC_CLIENT_BOUND: 361 break; 362 default: 363 ret = -EBUSY; 364 goto error; 365 } 366 367 rx->connect_srx = *srx; 368 set_bit(RXRPC_SOCK_CONNECTED, &rx->flags); 369 ret = 0; 370 371 error: 372 release_sock(&rx->sk); 373 return ret; 374 } 375 376 /* 377 * send a message through an RxRPC socket 378 * - in a client this does a number of things: 379 * - finds/sets up a connection for the security specified (if any) 380 * - initiates a call (ID in control data) 381 * - ends the request phase of a call (if MSG_MORE is not set) 382 * - sends a call data packet 383 * - may send an abort (abort code in control data) 384 */ 385 static int rxrpc_sendmsg(struct socket *sock, struct msghdr *m, size_t len) 386 { 387 struct rxrpc_local *local; 388 struct rxrpc_sock *rx = rxrpc_sk(sock->sk); 389 int ret; 390 391 _enter(",{%d},,%zu", rx->sk.sk_state, len); 392 393 if (m->msg_flags & MSG_OOB) 394 return -EOPNOTSUPP; 395 396 if (m->msg_name) { 397 ret = rxrpc_validate_address(rx, m->msg_name, m->msg_namelen); 398 if (ret < 0) { 399 _leave(" = %d [bad addr]", ret); 400 return ret; 401 } 402 } 403 404 lock_sock(&rx->sk); 405 406 switch (rx->sk.sk_state) { 407 case RXRPC_UNBOUND: 408 rx->srx.srx_family = AF_RXRPC; 409 rx->srx.srx_service = 0; 410 rx->srx.transport_type = SOCK_DGRAM; 411 rx->srx.transport.family = rx->family; 412 switch (rx->family) { 413 case AF_INET: 414 rx->srx.transport_len = sizeof(struct sockaddr_in); 415 break; 416 #ifdef CONFIG_AF_RXRPC_IPV6 417 case AF_INET6: 418 rx->srx.transport_len = sizeof(struct sockaddr_in6); 419 break; 420 #endif 421 default: 422 ret = -EAFNOSUPPORT; 423 goto error_unlock; 424 } 425 local = rxrpc_lookup_local(&rx->srx); 426 if (IS_ERR(local)) { 427 ret = PTR_ERR(local); 428 goto error_unlock; 429 } 430 431 rx->local = local; 432 rx->sk.sk_state = RXRPC_CLIENT_UNBOUND; 433 /* Fall through */ 434 435 case RXRPC_CLIENT_UNBOUND: 436 case RXRPC_CLIENT_BOUND: 437 if (!m->msg_name && 438 test_bit(RXRPC_SOCK_CONNECTED, &rx->flags)) { 439 m->msg_name = &rx->connect_srx; 440 m->msg_namelen = sizeof(rx->connect_srx); 441 } 442 case RXRPC_SERVER_BOUND: 443 case RXRPC_SERVER_LISTENING: 444 ret = rxrpc_do_sendmsg(rx, m, len); 445 break; 446 default: 447 ret = -EINVAL; 448 break; 449 } 450 451 error_unlock: 452 release_sock(&rx->sk); 453 _leave(" = %d", ret); 454 return ret; 455 } 456 457 /* 458 * set RxRPC socket options 459 */ 460 static int rxrpc_setsockopt(struct socket *sock, int level, int optname, 461 char __user *optval, unsigned int optlen) 462 { 463 struct rxrpc_sock *rx = rxrpc_sk(sock->sk); 464 unsigned int min_sec_level; 465 int ret; 466 467 _enter(",%d,%d,,%d", level, optname, optlen); 468 469 lock_sock(&rx->sk); 470 ret = -EOPNOTSUPP; 471 472 if (level == SOL_RXRPC) { 473 switch (optname) { 474 case RXRPC_EXCLUSIVE_CONNECTION: 475 ret = -EINVAL; 476 if (optlen != 0) 477 goto error; 478 ret = -EISCONN; 479 if (rx->sk.sk_state != RXRPC_UNBOUND) 480 goto error; 481 rx->exclusive = true; 482 goto success; 483 484 case RXRPC_SECURITY_KEY: 485 ret = -EINVAL; 486 if (rx->key) 487 goto error; 488 ret = -EISCONN; 489 if (rx->sk.sk_state != RXRPC_UNBOUND) 490 goto error; 491 ret = rxrpc_request_key(rx, optval, optlen); 492 goto error; 493 494 case RXRPC_SECURITY_KEYRING: 495 ret = -EINVAL; 496 if (rx->key) 497 goto error; 498 ret = -EISCONN; 499 if (rx->sk.sk_state != RXRPC_UNBOUND) 500 goto error; 501 ret = rxrpc_server_keyring(rx, optval, optlen); 502 goto error; 503 504 case RXRPC_MIN_SECURITY_LEVEL: 505 ret = -EINVAL; 506 if (optlen != sizeof(unsigned int)) 507 goto error; 508 ret = -EISCONN; 509 if (rx->sk.sk_state != RXRPC_UNBOUND) 510 goto error; 511 ret = get_user(min_sec_level, 512 (unsigned int __user *) optval); 513 if (ret < 0) 514 goto error; 515 ret = -EINVAL; 516 if (min_sec_level > RXRPC_SECURITY_MAX) 517 goto error; 518 rx->min_sec_level = min_sec_level; 519 goto success; 520 521 default: 522 break; 523 } 524 } 525 526 success: 527 ret = 0; 528 error: 529 release_sock(&rx->sk); 530 return ret; 531 } 532 533 /* 534 * permit an RxRPC socket to be polled 535 */ 536 static unsigned int rxrpc_poll(struct file *file, struct socket *sock, 537 poll_table *wait) 538 { 539 struct sock *sk = sock->sk; 540 struct rxrpc_sock *rx = rxrpc_sk(sk); 541 unsigned int mask; 542 543 sock_poll_wait(file, sk_sleep(sk), wait); 544 mask = 0; 545 546 /* the socket is readable if there are any messages waiting on the Rx 547 * queue */ 548 if (!list_empty(&rx->recvmsg_q)) 549 mask |= POLLIN | POLLRDNORM; 550 551 /* the socket is writable if there is space to add new data to the 552 * socket; there is no guarantee that any particular call in progress 553 * on the socket may have space in the Tx ACK window */ 554 if (rxrpc_writable(sk)) 555 mask |= POLLOUT | POLLWRNORM; 556 557 return mask; 558 } 559 560 /* 561 * create an RxRPC socket 562 */ 563 static int rxrpc_create(struct net *net, struct socket *sock, int protocol, 564 int kern) 565 { 566 struct rxrpc_sock *rx; 567 struct sock *sk; 568 569 _enter("%p,%d", sock, protocol); 570 571 if (!net_eq(net, &init_net)) 572 return -EAFNOSUPPORT; 573 574 /* we support transport protocol UDP/UDP6 only */ 575 if (protocol != PF_INET && 576 IS_ENABLED(CONFIG_AF_RXRPC_IPV6) && protocol != PF_INET6) 577 return -EPROTONOSUPPORT; 578 579 if (sock->type != SOCK_DGRAM) 580 return -ESOCKTNOSUPPORT; 581 582 sock->ops = &rxrpc_rpc_ops; 583 sock->state = SS_UNCONNECTED; 584 585 sk = sk_alloc(net, PF_RXRPC, GFP_KERNEL, &rxrpc_proto, kern); 586 if (!sk) 587 return -ENOMEM; 588 589 sock_init_data(sock, sk); 590 sock_set_flag(sk, SOCK_RCU_FREE); 591 sk->sk_state = RXRPC_UNBOUND; 592 sk->sk_write_space = rxrpc_write_space; 593 sk->sk_max_ack_backlog = 0; 594 sk->sk_destruct = rxrpc_sock_destructor; 595 596 rx = rxrpc_sk(sk); 597 rx->family = protocol; 598 rx->calls = RB_ROOT; 599 600 spin_lock_init(&rx->incoming_lock); 601 INIT_LIST_HEAD(&rx->sock_calls); 602 INIT_LIST_HEAD(&rx->to_be_accepted); 603 INIT_LIST_HEAD(&rx->recvmsg_q); 604 rwlock_init(&rx->recvmsg_lock); 605 rwlock_init(&rx->call_lock); 606 memset(&rx->srx, 0, sizeof(rx->srx)); 607 608 _leave(" = 0 [%p]", rx); 609 return 0; 610 } 611 612 /* 613 * Kill all the calls on a socket and shut it down. 614 */ 615 static int rxrpc_shutdown(struct socket *sock, int flags) 616 { 617 struct sock *sk = sock->sk; 618 struct rxrpc_sock *rx = rxrpc_sk(sk); 619 int ret = 0; 620 621 _enter("%p,%d", sk, flags); 622 623 if (flags != SHUT_RDWR) 624 return -EOPNOTSUPP; 625 if (sk->sk_state == RXRPC_CLOSE) 626 return -ESHUTDOWN; 627 628 lock_sock(sk); 629 630 spin_lock_bh(&sk->sk_receive_queue.lock); 631 if (sk->sk_state < RXRPC_CLOSE) { 632 sk->sk_state = RXRPC_CLOSE; 633 sk->sk_shutdown = SHUTDOWN_MASK; 634 } else { 635 ret = -ESHUTDOWN; 636 } 637 spin_unlock_bh(&sk->sk_receive_queue.lock); 638 639 rxrpc_discard_prealloc(rx); 640 641 release_sock(sk); 642 return ret; 643 } 644 645 /* 646 * RxRPC socket destructor 647 */ 648 static void rxrpc_sock_destructor(struct sock *sk) 649 { 650 _enter("%p", sk); 651 652 rxrpc_purge_queue(&sk->sk_receive_queue); 653 654 WARN_ON(atomic_read(&sk->sk_wmem_alloc)); 655 WARN_ON(!sk_unhashed(sk)); 656 WARN_ON(sk->sk_socket); 657 658 if (!sock_flag(sk, SOCK_DEAD)) { 659 printk("Attempt to release alive rxrpc socket: %p\n", sk); 660 return; 661 } 662 } 663 664 /* 665 * release an RxRPC socket 666 */ 667 static int rxrpc_release_sock(struct sock *sk) 668 { 669 struct rxrpc_sock *rx = rxrpc_sk(sk); 670 671 _enter("%p{%d,%d}", sk, sk->sk_state, atomic_read(&sk->sk_refcnt)); 672 673 /* declare the socket closed for business */ 674 sock_orphan(sk); 675 sk->sk_shutdown = SHUTDOWN_MASK; 676 677 spin_lock_bh(&sk->sk_receive_queue.lock); 678 sk->sk_state = RXRPC_CLOSE; 679 spin_unlock_bh(&sk->sk_receive_queue.lock); 680 681 if (rx->local && rcu_access_pointer(rx->local->service) == rx) { 682 write_lock(&rx->local->services_lock); 683 rcu_assign_pointer(rx->local->service, NULL); 684 write_unlock(&rx->local->services_lock); 685 } 686 687 /* try to flush out this socket */ 688 rxrpc_discard_prealloc(rx); 689 rxrpc_release_calls_on_socket(rx); 690 flush_workqueue(rxrpc_workqueue); 691 rxrpc_purge_queue(&sk->sk_receive_queue); 692 693 rxrpc_put_local(rx->local); 694 rx->local = NULL; 695 key_put(rx->key); 696 rx->key = NULL; 697 key_put(rx->securities); 698 rx->securities = NULL; 699 sock_put(sk); 700 701 _leave(" = 0"); 702 return 0; 703 } 704 705 /* 706 * release an RxRPC BSD socket on close() or equivalent 707 */ 708 static int rxrpc_release(struct socket *sock) 709 { 710 struct sock *sk = sock->sk; 711 712 _enter("%p{%p}", sock, sk); 713 714 if (!sk) 715 return 0; 716 717 sock->sk = NULL; 718 719 return rxrpc_release_sock(sk); 720 } 721 722 /* 723 * RxRPC network protocol 724 */ 725 static const struct proto_ops rxrpc_rpc_ops = { 726 .family = PF_RXRPC, 727 .owner = THIS_MODULE, 728 .release = rxrpc_release, 729 .bind = rxrpc_bind, 730 .connect = rxrpc_connect, 731 .socketpair = sock_no_socketpair, 732 .accept = sock_no_accept, 733 .getname = sock_no_getname, 734 .poll = rxrpc_poll, 735 .ioctl = sock_no_ioctl, 736 .listen = rxrpc_listen, 737 .shutdown = rxrpc_shutdown, 738 .setsockopt = rxrpc_setsockopt, 739 .getsockopt = sock_no_getsockopt, 740 .sendmsg = rxrpc_sendmsg, 741 .recvmsg = rxrpc_recvmsg, 742 .mmap = sock_no_mmap, 743 .sendpage = sock_no_sendpage, 744 }; 745 746 static struct proto rxrpc_proto = { 747 .name = "RXRPC", 748 .owner = THIS_MODULE, 749 .obj_size = sizeof(struct rxrpc_sock), 750 .max_header = sizeof(struct rxrpc_wire_header), 751 }; 752 753 static const struct net_proto_family rxrpc_family_ops = { 754 .family = PF_RXRPC, 755 .create = rxrpc_create, 756 .owner = THIS_MODULE, 757 }; 758 759 /* 760 * initialise and register the RxRPC protocol 761 */ 762 static int __init af_rxrpc_init(void) 763 { 764 int ret = -1; 765 unsigned int tmp; 766 767 BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv) > FIELD_SIZEOF(struct sk_buff, cb)); 768 769 get_random_bytes(&rxrpc_epoch, sizeof(rxrpc_epoch)); 770 rxrpc_epoch |= RXRPC_RANDOM_EPOCH; 771 get_random_bytes(&tmp, sizeof(tmp)); 772 tmp &= 0x3fffffff; 773 if (tmp == 0) 774 tmp = 1; 775 idr_set_cursor(&rxrpc_client_conn_ids, tmp); 776 777 ret = -ENOMEM; 778 rxrpc_call_jar = kmem_cache_create( 779 "rxrpc_call_jar", sizeof(struct rxrpc_call), 0, 780 SLAB_HWCACHE_ALIGN, NULL); 781 if (!rxrpc_call_jar) { 782 pr_notice("Failed to allocate call jar\n"); 783 goto error_call_jar; 784 } 785 786 rxrpc_workqueue = alloc_workqueue("krxrpcd", 0, 1); 787 if (!rxrpc_workqueue) { 788 pr_notice("Failed to allocate work queue\n"); 789 goto error_work_queue; 790 } 791 792 ret = rxrpc_init_security(); 793 if (ret < 0) { 794 pr_crit("Cannot initialise security\n"); 795 goto error_security; 796 } 797 798 ret = proto_register(&rxrpc_proto, 1); 799 if (ret < 0) { 800 pr_crit("Cannot register protocol\n"); 801 goto error_proto; 802 } 803 804 ret = sock_register(&rxrpc_family_ops); 805 if (ret < 0) { 806 pr_crit("Cannot register socket family\n"); 807 goto error_sock; 808 } 809 810 ret = register_key_type(&key_type_rxrpc); 811 if (ret < 0) { 812 pr_crit("Cannot register client key type\n"); 813 goto error_key_type; 814 } 815 816 ret = register_key_type(&key_type_rxrpc_s); 817 if (ret < 0) { 818 pr_crit("Cannot register server key type\n"); 819 goto error_key_type_s; 820 } 821 822 ret = rxrpc_sysctl_init(); 823 if (ret < 0) { 824 pr_crit("Cannot register sysctls\n"); 825 goto error_sysctls; 826 } 827 828 #ifdef CONFIG_PROC_FS 829 proc_create("rxrpc_calls", 0, init_net.proc_net, &rxrpc_call_seq_fops); 830 proc_create("rxrpc_conns", 0, init_net.proc_net, 831 &rxrpc_connection_seq_fops); 832 #endif 833 return 0; 834 835 error_sysctls: 836 unregister_key_type(&key_type_rxrpc_s); 837 error_key_type_s: 838 unregister_key_type(&key_type_rxrpc); 839 error_key_type: 840 sock_unregister(PF_RXRPC); 841 error_sock: 842 proto_unregister(&rxrpc_proto); 843 error_proto: 844 rxrpc_exit_security(); 845 error_security: 846 destroy_workqueue(rxrpc_workqueue); 847 error_work_queue: 848 kmem_cache_destroy(rxrpc_call_jar); 849 error_call_jar: 850 return ret; 851 } 852 853 /* 854 * unregister the RxRPC protocol 855 */ 856 static void __exit af_rxrpc_exit(void) 857 { 858 _enter(""); 859 rxrpc_sysctl_exit(); 860 unregister_key_type(&key_type_rxrpc_s); 861 unregister_key_type(&key_type_rxrpc); 862 sock_unregister(PF_RXRPC); 863 proto_unregister(&rxrpc_proto); 864 rxrpc_destroy_all_calls(); 865 rxrpc_destroy_all_connections(); 866 ASSERTCMP(atomic_read(&rxrpc_n_tx_skbs), ==, 0); 867 ASSERTCMP(atomic_read(&rxrpc_n_rx_skbs), ==, 0); 868 rxrpc_destroy_all_locals(); 869 870 remove_proc_entry("rxrpc_conns", init_net.proc_net); 871 remove_proc_entry("rxrpc_calls", init_net.proc_net); 872 destroy_workqueue(rxrpc_workqueue); 873 rxrpc_exit_security(); 874 kmem_cache_destroy(rxrpc_call_jar); 875 _leave(""); 876 } 877 878 module_init(af_rxrpc_init); 879 module_exit(af_rxrpc_exit); 880