1 /* AF_RXRPC implementation
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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
25 #include <net/af_rxrpc.h>
26 #define CREATE_TRACE_POINTS
27 #include "ar-internal.h"
29 MODULE_DESCRIPTION("RxRPC network protocol");
30 MODULE_AUTHOR("Red Hat, Inc.");
31 MODULE_LICENSE("GPL");
32 MODULE_ALIAS_NETPROTO(PF_RXRPC);
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");
38 static struct proto rxrpc_proto;
39 static const struct proto_ops rxrpc_rpc_ops;
41 /* local epoch for detecting local-end reset */
44 /* current debugging ID */
45 atomic_t rxrpc_debug_id;
47 /* count of skbs currently in use */
48 atomic_t rxrpc_n_skbs;
50 struct workqueue_struct *rxrpc_workqueue;
52 static void rxrpc_sock_destructor(struct sock *);
55 * see if an RxRPC socket is currently writable
57 static inline int rxrpc_writable(struct sock *sk)
59 return atomic_read(&sk->sk_wmem_alloc) < (size_t) sk->sk_sndbuf;
63 * wait for write bufferage to become available
65 static void rxrpc_write_space(struct sock *sk)
69 if (rxrpc_writable(sk)) {
70 struct socket_wq *wq = rcu_dereference(sk->sk_wq);
72 if (skwq_has_sleeper(wq))
73 wake_up_interruptible(&wq->wait);
74 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
80 * validate an RxRPC address
82 static int rxrpc_validate_address(struct rxrpc_sock *rx,
83 struct sockaddr_rxrpc *srx,
88 if (len < sizeof(struct sockaddr_rxrpc))
91 if (srx->srx_family != AF_RXRPC)
94 if (srx->transport_type != SOCK_DGRAM)
95 return -ESOCKTNOSUPPORT;
97 len -= offsetof(struct sockaddr_rxrpc, transport);
98 if (srx->transport_len < sizeof(sa_family_t) ||
99 srx->transport_len > len)
102 if (srx->transport.family != rx->family)
103 return -EAFNOSUPPORT;
105 switch (srx->transport.family) {
107 if (srx->transport_len < sizeof(struct sockaddr_in))
109 _debug("INET: %x @ %pI4",
110 ntohs(srx->transport.sin.sin_port),
111 &srx->transport.sin.sin_addr);
112 tail = offsetof(struct sockaddr_rxrpc, transport.sin.__pad);
117 return -EAFNOSUPPORT;
121 memset((void *)srx + tail, 0, len - tail);
126 * bind a local address to an RxRPC socket
128 static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len)
130 struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)saddr;
131 struct sock *sk = sock->sk;
132 struct rxrpc_local *local;
133 struct rxrpc_sock *rx = rxrpc_sk(sk), *prx;
136 _enter("%p,%p,%d", rx, saddr, len);
138 ret = rxrpc_validate_address(rx, srx, len);
144 if (rx->sk.sk_state != RXRPC_UNBOUND) {
149 memcpy(&rx->srx, srx, sizeof(rx->srx));
151 local = rxrpc_lookup_local(&rx->srx);
153 ret = PTR_ERR(local);
157 if (rx->srx.srx_service) {
158 write_lock_bh(&local->services_lock);
159 list_for_each_entry(prx, &local->services, listen_link) {
160 if (prx->srx.srx_service == rx->srx.srx_service)
165 list_add_tail(&rx->listen_link, &local->services);
166 write_unlock_bh(&local->services_lock);
168 rx->sk.sk_state = RXRPC_SERVER_BOUND;
171 rx->sk.sk_state = RXRPC_CLIENT_BOUND;
174 release_sock(&rx->sk);
179 write_unlock_bh(&local->services_lock);
180 rxrpc_put_local(local);
183 release_sock(&rx->sk);
185 _leave(" = %d", ret);
190 * set the number of pending calls permitted on a listening socket
192 static int rxrpc_listen(struct socket *sock, int backlog)
194 struct sock *sk = sock->sk;
195 struct rxrpc_sock *rx = rxrpc_sk(sk);
199 _enter("%p,%d", rx, backlog);
203 switch (rx->sk.sk_state) {
205 ret = -EADDRNOTAVAIL;
207 case RXRPC_SERVER_BOUND:
208 ASSERT(rx->local != NULL);
209 max = READ_ONCE(rxrpc_max_backlog);
211 if (backlog == INT_MAX)
213 else if (backlog < 0 || backlog > max)
215 sk->sk_max_ack_backlog = backlog;
216 rx->sk.sk_state = RXRPC_SERVER_LISTENING;
224 release_sock(&rx->sk);
225 _leave(" = %d", ret);
230 * rxrpc_kernel_begin_call - Allow a kernel service to begin a call
231 * @sock: The socket on which to make the call
232 * @srx: The address of the peer to contact
233 * @key: The security context to use (defaults to socket setting)
234 * @user_call_ID: The ID to use
235 * @gfp: The allocation constraints
236 * @notify_rx: Where to send notifications instead of socket queue
238 * Allow a kernel service to begin a call on the nominated socket. This just
239 * sets up all the internal tracking structures and allocates connection and
240 * call IDs as appropriate. The call to be used is returned.
242 * The default socket destination address and security may be overridden by
243 * supplying @srx and @key.
245 struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock,
246 struct sockaddr_rxrpc *srx,
248 unsigned long user_call_ID,
250 rxrpc_notify_rx_t notify_rx)
252 struct rxrpc_conn_parameters cp;
253 struct rxrpc_call *call;
254 struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
257 _enter(",,%x,%lx", key_serial(key), user_call_ID);
259 ret = rxrpc_validate_address(rx, srx, sizeof(*srx));
267 if (key && !key->payload.data[0])
268 key = NULL; /* a no-security key */
270 memset(&cp, 0, sizeof(cp));
271 cp.local = rx->local;
273 cp.security_level = 0;
274 cp.exclusive = false;
275 cp.service_id = srx->srx_service;
276 call = rxrpc_new_client_call(rx, &cp, srx, user_call_ID, gfp);
278 call->notify_rx = notify_rx;
280 release_sock(&rx->sk);
281 _leave(" = %p", call);
284 EXPORT_SYMBOL(rxrpc_kernel_begin_call);
287 * rxrpc_kernel_end_call - Allow a kernel service to end a call it was using
288 * @sock: The socket the call is on
289 * @call: The call to end
291 * Allow a kernel service to end a call it was using. The call must be
292 * complete before this is called (the call should be aborted if necessary).
294 void rxrpc_kernel_end_call(struct socket *sock, struct rxrpc_call *call)
296 _enter("%d{%d}", call->debug_id, atomic_read(&call->usage));
297 rxrpc_remove_user_ID(rxrpc_sk(sock->sk), call);
298 rxrpc_purge_queue(&call->knlrecv_queue);
299 rxrpc_put_call(call, rxrpc_call_put);
301 EXPORT_SYMBOL(rxrpc_kernel_end_call);
304 * rxrpc_kernel_new_call_notification - Get notifications of new calls
305 * @sock: The socket to intercept received messages on
306 * @notify_new_call: Function to be called when new calls appear
308 * Allow a kernel service to be given notifications about new calls.
310 void rxrpc_kernel_new_call_notification(
312 rxrpc_notify_new_call_t notify_new_call)
314 struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
316 rx->notify_new_call = notify_new_call;
318 EXPORT_SYMBOL(rxrpc_kernel_new_call_notification);
321 * connect an RxRPC socket
322 * - this just targets it at a specific destination; no actual connection
323 * negotiation takes place
325 static int rxrpc_connect(struct socket *sock, struct sockaddr *addr,
326 int addr_len, int flags)
328 struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)addr;
329 struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
332 _enter("%p,%p,%d,%d", rx, addr, addr_len, flags);
334 ret = rxrpc_validate_address(rx, srx, addr_len);
336 _leave(" = %d [bad addr]", ret);
343 if (test_bit(RXRPC_SOCK_CONNECTED, &rx->flags))
346 switch (rx->sk.sk_state) {
348 rx->sk.sk_state = RXRPC_CLIENT_UNBOUND;
349 case RXRPC_CLIENT_UNBOUND:
350 case RXRPC_CLIENT_BOUND:
357 rx->connect_srx = *srx;
358 set_bit(RXRPC_SOCK_CONNECTED, &rx->flags);
362 release_sock(&rx->sk);
367 * send a message through an RxRPC socket
368 * - in a client this does a number of things:
369 * - finds/sets up a connection for the security specified (if any)
370 * - initiates a call (ID in control data)
371 * - ends the request phase of a call (if MSG_MORE is not set)
372 * - sends a call data packet
373 * - may send an abort (abort code in control data)
375 static int rxrpc_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
377 struct rxrpc_local *local;
378 struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
381 _enter(",{%d},,%zu", rx->sk.sk_state, len);
383 if (m->msg_flags & MSG_OOB)
387 ret = rxrpc_validate_address(rx, m->msg_name, m->msg_namelen);
389 _leave(" = %d [bad addr]", ret);
396 switch (rx->sk.sk_state) {
398 local = rxrpc_lookup_local(&rx->srx);
400 ret = PTR_ERR(local);
405 rx->sk.sk_state = RXRPC_CLIENT_UNBOUND;
408 case RXRPC_CLIENT_UNBOUND:
409 case RXRPC_CLIENT_BOUND:
411 test_bit(RXRPC_SOCK_CONNECTED, &rx->flags)) {
412 m->msg_name = &rx->connect_srx;
413 m->msg_namelen = sizeof(rx->connect_srx);
415 case RXRPC_SERVER_BOUND:
416 case RXRPC_SERVER_LISTENING:
417 ret = rxrpc_do_sendmsg(rx, m, len);
425 release_sock(&rx->sk);
426 _leave(" = %d", ret);
431 * set RxRPC socket options
433 static int rxrpc_setsockopt(struct socket *sock, int level, int optname,
434 char __user *optval, unsigned int optlen)
436 struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
437 unsigned int min_sec_level;
440 _enter(",%d,%d,,%d", level, optname, optlen);
445 if (level == SOL_RXRPC) {
447 case RXRPC_EXCLUSIVE_CONNECTION:
452 if (rx->sk.sk_state != RXRPC_UNBOUND)
454 rx->exclusive = true;
457 case RXRPC_SECURITY_KEY:
462 if (rx->sk.sk_state != RXRPC_UNBOUND)
464 ret = rxrpc_request_key(rx, optval, optlen);
467 case RXRPC_SECURITY_KEYRING:
472 if (rx->sk.sk_state != RXRPC_UNBOUND)
474 ret = rxrpc_server_keyring(rx, optval, optlen);
477 case RXRPC_MIN_SECURITY_LEVEL:
479 if (optlen != sizeof(unsigned int))
482 if (rx->sk.sk_state != RXRPC_UNBOUND)
484 ret = get_user(min_sec_level,
485 (unsigned int __user *) optval);
489 if (min_sec_level > RXRPC_SECURITY_MAX)
491 rx->min_sec_level = min_sec_level;
502 release_sock(&rx->sk);
507 * permit an RxRPC socket to be polled
509 static unsigned int rxrpc_poll(struct file *file, struct socket *sock,
513 struct sock *sk = sock->sk;
515 sock_poll_wait(file, sk_sleep(sk), wait);
518 /* the socket is readable if there are any messages waiting on the Rx
520 if (!skb_queue_empty(&sk->sk_receive_queue))
521 mask |= POLLIN | POLLRDNORM;
523 /* the socket is writable if there is space to add new data to the
524 * socket; there is no guarantee that any particular call in progress
525 * on the socket may have space in the Tx ACK window */
526 if (rxrpc_writable(sk))
527 mask |= POLLOUT | POLLWRNORM;
533 * create an RxRPC socket
535 static int rxrpc_create(struct net *net, struct socket *sock, int protocol,
538 struct rxrpc_sock *rx;
541 _enter("%p,%d", sock, protocol);
543 if (!net_eq(net, &init_net))
544 return -EAFNOSUPPORT;
546 /* we support transport protocol UDP/UDP6 only */
547 if (protocol != PF_INET)
548 return -EPROTONOSUPPORT;
550 if (sock->type != SOCK_DGRAM)
551 return -ESOCKTNOSUPPORT;
553 sock->ops = &rxrpc_rpc_ops;
554 sock->state = SS_UNCONNECTED;
556 sk = sk_alloc(net, PF_RXRPC, GFP_KERNEL, &rxrpc_proto, kern);
560 sock_init_data(sock, sk);
561 sk->sk_state = RXRPC_UNBOUND;
562 sk->sk_write_space = rxrpc_write_space;
563 sk->sk_max_ack_backlog = 0;
564 sk->sk_destruct = rxrpc_sock_destructor;
567 rx->family = protocol;
570 INIT_LIST_HEAD(&rx->listen_link);
571 INIT_LIST_HEAD(&rx->secureq);
572 INIT_LIST_HEAD(&rx->acceptq);
573 rwlock_init(&rx->call_lock);
574 memset(&rx->srx, 0, sizeof(rx->srx));
576 _leave(" = 0 [%p]", rx);
581 * RxRPC socket destructor
583 static void rxrpc_sock_destructor(struct sock *sk)
587 rxrpc_purge_queue(&sk->sk_receive_queue);
589 WARN_ON(atomic_read(&sk->sk_wmem_alloc));
590 WARN_ON(!sk_unhashed(sk));
591 WARN_ON(sk->sk_socket);
593 if (!sock_flag(sk, SOCK_DEAD)) {
594 printk("Attempt to release alive rxrpc socket: %p\n", sk);
600 * release an RxRPC socket
602 static int rxrpc_release_sock(struct sock *sk)
604 struct rxrpc_sock *rx = rxrpc_sk(sk);
606 _enter("%p{%d,%d}", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
608 /* declare the socket closed for business */
610 sk->sk_shutdown = SHUTDOWN_MASK;
612 spin_lock_bh(&sk->sk_receive_queue.lock);
613 sk->sk_state = RXRPC_CLOSE;
614 spin_unlock_bh(&sk->sk_receive_queue.lock);
616 ASSERTCMP(rx->listen_link.next, !=, LIST_POISON1);
618 if (!list_empty(&rx->listen_link)) {
619 write_lock_bh(&rx->local->services_lock);
620 list_del(&rx->listen_link);
621 write_unlock_bh(&rx->local->services_lock);
624 /* try to flush out this socket */
625 rxrpc_release_calls_on_socket(rx);
626 flush_workqueue(rxrpc_workqueue);
627 rxrpc_purge_queue(&sk->sk_receive_queue);
629 rxrpc_put_local(rx->local);
633 key_put(rx->securities);
634 rx->securities = NULL;
642 * release an RxRPC BSD socket on close() or equivalent
644 static int rxrpc_release(struct socket *sock)
646 struct sock *sk = sock->sk;
648 _enter("%p{%p}", sock, sk);
655 return rxrpc_release_sock(sk);
659 * RxRPC network protocol
661 static const struct proto_ops rxrpc_rpc_ops = {
663 .owner = THIS_MODULE,
664 .release = rxrpc_release,
666 .connect = rxrpc_connect,
667 .socketpair = sock_no_socketpair,
668 .accept = sock_no_accept,
669 .getname = sock_no_getname,
671 .ioctl = sock_no_ioctl,
672 .listen = rxrpc_listen,
673 .shutdown = sock_no_shutdown,
674 .setsockopt = rxrpc_setsockopt,
675 .getsockopt = sock_no_getsockopt,
676 .sendmsg = rxrpc_sendmsg,
677 .recvmsg = rxrpc_recvmsg,
678 .mmap = sock_no_mmap,
679 .sendpage = sock_no_sendpage,
682 static struct proto rxrpc_proto = {
684 .owner = THIS_MODULE,
685 .obj_size = sizeof(struct rxrpc_sock),
686 .max_header = sizeof(struct rxrpc_wire_header),
689 static const struct net_proto_family rxrpc_family_ops = {
691 .create = rxrpc_create,
692 .owner = THIS_MODULE,
696 * initialise and register the RxRPC protocol
698 static int __init af_rxrpc_init(void)
702 BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv) > FIELD_SIZEOF(struct sk_buff, cb));
704 get_random_bytes(&rxrpc_epoch, sizeof(rxrpc_epoch));
705 rxrpc_epoch |= RXRPC_RANDOM_EPOCH;
706 get_random_bytes(&rxrpc_client_conn_ids.cur,
707 sizeof(rxrpc_client_conn_ids.cur));
708 rxrpc_client_conn_ids.cur &= 0x3fffffff;
709 if (rxrpc_client_conn_ids.cur == 0)
710 rxrpc_client_conn_ids.cur = 1;
713 rxrpc_call_jar = kmem_cache_create(
714 "rxrpc_call_jar", sizeof(struct rxrpc_call), 0,
715 SLAB_HWCACHE_ALIGN, NULL);
716 if (!rxrpc_call_jar) {
717 pr_notice("Failed to allocate call jar\n");
721 rxrpc_workqueue = alloc_workqueue("krxrpcd", 0, 1);
722 if (!rxrpc_workqueue) {
723 pr_notice("Failed to allocate work queue\n");
724 goto error_work_queue;
727 ret = rxrpc_init_security();
729 pr_crit("Cannot initialise security\n");
733 ret = proto_register(&rxrpc_proto, 1);
735 pr_crit("Cannot register protocol\n");
739 ret = sock_register(&rxrpc_family_ops);
741 pr_crit("Cannot register socket family\n");
745 ret = register_key_type(&key_type_rxrpc);
747 pr_crit("Cannot register client key type\n");
751 ret = register_key_type(&key_type_rxrpc_s);
753 pr_crit("Cannot register server key type\n");
754 goto error_key_type_s;
757 ret = rxrpc_sysctl_init();
759 pr_crit("Cannot register sysctls\n");
763 #ifdef CONFIG_PROC_FS
764 proc_create("rxrpc_calls", 0, init_net.proc_net, &rxrpc_call_seq_fops);
765 proc_create("rxrpc_conns", 0, init_net.proc_net,
766 &rxrpc_connection_seq_fops);
771 unregister_key_type(&key_type_rxrpc_s);
773 unregister_key_type(&key_type_rxrpc);
775 sock_unregister(PF_RXRPC);
777 proto_unregister(&rxrpc_proto);
779 rxrpc_exit_security();
781 destroy_workqueue(rxrpc_workqueue);
783 kmem_cache_destroy(rxrpc_call_jar);
789 * unregister the RxRPC protocol
791 static void __exit af_rxrpc_exit(void)
795 unregister_key_type(&key_type_rxrpc_s);
796 unregister_key_type(&key_type_rxrpc);
797 sock_unregister(PF_RXRPC);
798 proto_unregister(&rxrpc_proto);
799 rxrpc_destroy_all_calls();
800 rxrpc_destroy_all_connections();
801 ASSERTCMP(atomic_read(&rxrpc_n_skbs), ==, 0);
802 rxrpc_destroy_all_locals();
804 remove_proc_entry("rxrpc_conns", init_net.proc_net);
805 remove_proc_entry("rxrpc_calls", init_net.proc_net);
806 destroy_workqueue(rxrpc_workqueue);
807 rxrpc_exit_security();
808 kmem_cache_destroy(rxrpc_call_jar);
812 module_init(af_rxrpc_init);
813 module_exit(af_rxrpc_exit);