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