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 /* current debugging ID */
42 atomic_t rxrpc_debug_id
;
44 /* count of skbs currently in use */
45 atomic_t rxrpc_n_tx_skbs
, rxrpc_n_rx_skbs
;
47 struct workqueue_struct
*rxrpc_workqueue
;
49 static void rxrpc_sock_destructor(struct sock
*);
52 * see if an RxRPC socket is currently writable
54 static inline int rxrpc_writable(struct sock
*sk
)
56 return atomic_read(&sk
->sk_wmem_alloc
) < (size_t) sk
->sk_sndbuf
;
60 * wait for write bufferage to become available
62 static void rxrpc_write_space(struct sock
*sk
)
66 if (rxrpc_writable(sk
)) {
67 struct socket_wq
*wq
= rcu_dereference(sk
->sk_wq
);
69 if (skwq_has_sleeper(wq
))
70 wake_up_interruptible(&wq
->wait
);
71 sk_wake_async(sk
, SOCK_WAKE_SPACE
, POLL_OUT
);
77 * validate an RxRPC address
79 static int rxrpc_validate_address(struct rxrpc_sock
*rx
,
80 struct sockaddr_rxrpc
*srx
,
85 if (len
< sizeof(struct sockaddr_rxrpc
))
88 if (srx
->srx_family
!= AF_RXRPC
)
91 if (srx
->transport_type
!= SOCK_DGRAM
)
92 return -ESOCKTNOSUPPORT
;
94 len
-= offsetof(struct sockaddr_rxrpc
, transport
);
95 if (srx
->transport_len
< sizeof(sa_family_t
) ||
96 srx
->transport_len
> len
)
99 if (srx
->transport
.family
!= rx
->family
)
100 return -EAFNOSUPPORT
;
102 switch (srx
->transport
.family
) {
104 if (srx
->transport_len
< sizeof(struct sockaddr_in
))
106 tail
= offsetof(struct sockaddr_rxrpc
, transport
.sin
.__pad
);
109 #ifdef CONFIG_AF_RXRPC_IPV6
111 if (srx
->transport_len
< sizeof(struct sockaddr_in6
))
113 tail
= offsetof(struct sockaddr_rxrpc
, transport
) +
114 sizeof(struct sockaddr_in6
);
119 return -EAFNOSUPPORT
;
123 memset((void *)srx
+ tail
, 0, len
- tail
);
124 _debug("INET: %pISp", &srx
->transport
);
129 * bind a local address to an RxRPC socket
131 static int rxrpc_bind(struct socket
*sock
, struct sockaddr
*saddr
, int len
)
133 struct sockaddr_rxrpc
*srx
= (struct sockaddr_rxrpc
*)saddr
;
134 struct sock
*sk
= sock
->sk
;
135 struct rxrpc_local
*local
;
136 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
137 u16 service_id
= srx
->srx_service
;
140 _enter("%p,%p,%d", rx
, saddr
, len
);
142 ret
= rxrpc_validate_address(rx
, srx
, len
);
148 if (rx
->sk
.sk_state
!= RXRPC_UNBOUND
) {
153 memcpy(&rx
->srx
, srx
, sizeof(rx
->srx
));
155 local
= rxrpc_lookup_local(sock_net(sock
->sk
), &rx
->srx
);
157 ret
= PTR_ERR(local
);
162 write_lock(&local
->services_lock
);
163 if (rcu_access_pointer(local
->service
))
166 rcu_assign_pointer(local
->service
, rx
);
167 write_unlock(&local
->services_lock
);
169 rx
->sk
.sk_state
= RXRPC_SERVER_BOUND
;
172 rx
->sk
.sk_state
= RXRPC_CLIENT_BOUND
;
175 release_sock(&rx
->sk
);
180 write_unlock(&local
->services_lock
);
181 rxrpc_put_local(local
);
184 release_sock(&rx
->sk
);
186 _leave(" = %d", ret
);
191 * set the number of pending calls permitted on a listening socket
193 static int rxrpc_listen(struct socket
*sock
, int backlog
)
195 struct sock
*sk
= sock
->sk
;
196 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
197 unsigned int max
, old
;
200 _enter("%p,%d", rx
, backlog
);
204 switch (rx
->sk
.sk_state
) {
206 ret
= -EADDRNOTAVAIL
;
208 case RXRPC_SERVER_BOUND
:
209 ASSERT(rx
->local
!= NULL
);
210 max
= READ_ONCE(rxrpc_max_backlog
);
212 if (backlog
== INT_MAX
)
214 else if (backlog
< 0 || backlog
> max
)
216 old
= sk
->sk_max_ack_backlog
;
217 sk
->sk_max_ack_backlog
= backlog
;
218 ret
= rxrpc_service_prealloc(rx
, GFP_KERNEL
);
220 rx
->sk
.sk_state
= RXRPC_SERVER_LISTENING
;
222 sk
->sk_max_ack_backlog
= old
;
224 case RXRPC_SERVER_LISTENING
:
226 rx
->sk
.sk_state
= RXRPC_SERVER_LISTEN_DISABLED
;
227 sk
->sk_max_ack_backlog
= 0;
228 rxrpc_discard_prealloc(rx
);
237 release_sock(&rx
->sk
);
238 _leave(" = %d", ret
);
243 * rxrpc_kernel_begin_call - Allow a kernel service to begin a call
244 * @sock: The socket on which to make the call
245 * @srx: The address of the peer to contact
246 * @key: The security context to use (defaults to socket setting)
247 * @user_call_ID: The ID to use
248 * @gfp: The allocation constraints
249 * @notify_rx: Where to send notifications instead of socket queue
251 * Allow a kernel service to begin a call on the nominated socket. This just
252 * sets up all the internal tracking structures and allocates connection and
253 * call IDs as appropriate. The call to be used is returned.
255 * The default socket destination address and security may be overridden by
256 * supplying @srx and @key.
258 struct rxrpc_call
*rxrpc_kernel_begin_call(struct socket
*sock
,
259 struct sockaddr_rxrpc
*srx
,
261 unsigned long user_call_ID
,
263 rxrpc_notify_rx_t notify_rx
)
265 struct rxrpc_conn_parameters cp
;
266 struct rxrpc_call
*call
;
267 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
270 _enter(",,%x,%lx", key_serial(key
), user_call_ID
);
272 ret
= rxrpc_validate_address(rx
, srx
, sizeof(*srx
));
280 if (key
&& !key
->payload
.data
[0])
281 key
= NULL
; /* a no-security key */
283 memset(&cp
, 0, sizeof(cp
));
284 cp
.local
= rx
->local
;
286 cp
.security_level
= 0;
287 cp
.exclusive
= false;
288 cp
.service_id
= srx
->srx_service
;
289 call
= rxrpc_new_client_call(rx
, &cp
, srx
, user_call_ID
, gfp
);
290 /* The socket has been unlocked. */
292 call
->notify_rx
= notify_rx
;
294 mutex_unlock(&call
->user_mutex
);
295 _leave(" = %p", call
);
298 EXPORT_SYMBOL(rxrpc_kernel_begin_call
);
301 * rxrpc_kernel_end_call - Allow a kernel service to end a call it was using
302 * @sock: The socket the call is on
303 * @call: The call to end
305 * Allow a kernel service to end a call it was using. The call must be
306 * complete before this is called (the call should be aborted if necessary).
308 void rxrpc_kernel_end_call(struct socket
*sock
, struct rxrpc_call
*call
)
310 _enter("%d{%d}", call
->debug_id
, atomic_read(&call
->usage
));
312 mutex_lock(&call
->user_mutex
);
313 rxrpc_release_call(rxrpc_sk(sock
->sk
), call
);
314 mutex_unlock(&call
->user_mutex
);
315 rxrpc_put_call(call
, rxrpc_call_put_kernel
);
317 EXPORT_SYMBOL(rxrpc_kernel_end_call
);
320 * rxrpc_kernel_new_call_notification - Get notifications of new calls
321 * @sock: The socket to intercept received messages on
322 * @notify_new_call: Function to be called when new calls appear
323 * @discard_new_call: Function to discard preallocated calls
325 * Allow a kernel service to be given notifications about new calls.
327 void rxrpc_kernel_new_call_notification(
329 rxrpc_notify_new_call_t notify_new_call
,
330 rxrpc_discard_new_call_t discard_new_call
)
332 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
334 rx
->notify_new_call
= notify_new_call
;
335 rx
->discard_new_call
= discard_new_call
;
337 EXPORT_SYMBOL(rxrpc_kernel_new_call_notification
);
340 * connect an RxRPC socket
341 * - this just targets it at a specific destination; no actual connection
342 * negotiation takes place
344 static int rxrpc_connect(struct socket
*sock
, struct sockaddr
*addr
,
345 int addr_len
, int flags
)
347 struct sockaddr_rxrpc
*srx
= (struct sockaddr_rxrpc
*)addr
;
348 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
351 _enter("%p,%p,%d,%d", rx
, addr
, addr_len
, flags
);
353 ret
= rxrpc_validate_address(rx
, srx
, addr_len
);
355 _leave(" = %d [bad addr]", ret
);
362 if (test_bit(RXRPC_SOCK_CONNECTED
, &rx
->flags
))
365 switch (rx
->sk
.sk_state
) {
367 rx
->sk
.sk_state
= RXRPC_CLIENT_UNBOUND
;
368 case RXRPC_CLIENT_UNBOUND
:
369 case RXRPC_CLIENT_BOUND
:
376 rx
->connect_srx
= *srx
;
377 set_bit(RXRPC_SOCK_CONNECTED
, &rx
->flags
);
381 release_sock(&rx
->sk
);
386 * send a message through an RxRPC socket
387 * - in a client this does a number of things:
388 * - finds/sets up a connection for the security specified (if any)
389 * - initiates a call (ID in control data)
390 * - ends the request phase of a call (if MSG_MORE is not set)
391 * - sends a call data packet
392 * - may send an abort (abort code in control data)
394 static int rxrpc_sendmsg(struct socket
*sock
, struct msghdr
*m
, size_t len
)
396 struct rxrpc_local
*local
;
397 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
400 _enter(",{%d},,%zu", rx
->sk
.sk_state
, len
);
402 if (m
->msg_flags
& MSG_OOB
)
406 ret
= rxrpc_validate_address(rx
, m
->msg_name
, m
->msg_namelen
);
408 _leave(" = %d [bad addr]", ret
);
415 switch (rx
->sk
.sk_state
) {
417 rx
->srx
.srx_family
= AF_RXRPC
;
418 rx
->srx
.srx_service
= 0;
419 rx
->srx
.transport_type
= SOCK_DGRAM
;
420 rx
->srx
.transport
.family
= rx
->family
;
421 switch (rx
->family
) {
423 rx
->srx
.transport_len
= sizeof(struct sockaddr_in
);
425 #ifdef CONFIG_AF_RXRPC_IPV6
427 rx
->srx
.transport_len
= sizeof(struct sockaddr_in6
);
434 local
= rxrpc_lookup_local(sock_net(sock
->sk
), &rx
->srx
);
436 ret
= PTR_ERR(local
);
441 rx
->sk
.sk_state
= RXRPC_CLIENT_UNBOUND
;
444 case RXRPC_CLIENT_UNBOUND
:
445 case RXRPC_CLIENT_BOUND
:
447 test_bit(RXRPC_SOCK_CONNECTED
, &rx
->flags
)) {
448 m
->msg_name
= &rx
->connect_srx
;
449 m
->msg_namelen
= sizeof(rx
->connect_srx
);
451 case RXRPC_SERVER_BOUND
:
452 case RXRPC_SERVER_LISTENING
:
453 ret
= rxrpc_do_sendmsg(rx
, m
, len
);
454 /* The socket has been unlocked */
462 release_sock(&rx
->sk
);
464 _leave(" = %d", ret
);
469 * set RxRPC socket options
471 static int rxrpc_setsockopt(struct socket
*sock
, int level
, int optname
,
472 char __user
*optval
, unsigned int optlen
)
474 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
475 unsigned int min_sec_level
;
478 _enter(",%d,%d,,%d", level
, optname
, optlen
);
483 if (level
== SOL_RXRPC
) {
485 case RXRPC_EXCLUSIVE_CONNECTION
:
490 if (rx
->sk
.sk_state
!= RXRPC_UNBOUND
)
492 rx
->exclusive
= true;
495 case RXRPC_SECURITY_KEY
:
500 if (rx
->sk
.sk_state
!= RXRPC_UNBOUND
)
502 ret
= rxrpc_request_key(rx
, optval
, optlen
);
505 case RXRPC_SECURITY_KEYRING
:
510 if (rx
->sk
.sk_state
!= RXRPC_UNBOUND
)
512 ret
= rxrpc_server_keyring(rx
, optval
, optlen
);
515 case RXRPC_MIN_SECURITY_LEVEL
:
517 if (optlen
!= sizeof(unsigned int))
520 if (rx
->sk
.sk_state
!= RXRPC_UNBOUND
)
522 ret
= get_user(min_sec_level
,
523 (unsigned int __user
*) optval
);
527 if (min_sec_level
> RXRPC_SECURITY_MAX
)
529 rx
->min_sec_level
= min_sec_level
;
540 release_sock(&rx
->sk
);
545 * permit an RxRPC socket to be polled
547 static unsigned int rxrpc_poll(struct file
*file
, struct socket
*sock
,
550 struct sock
*sk
= sock
->sk
;
551 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
554 sock_poll_wait(file
, sk_sleep(sk
), wait
);
557 /* the socket is readable if there are any messages waiting on the Rx
559 if (!list_empty(&rx
->recvmsg_q
))
560 mask
|= POLLIN
| POLLRDNORM
;
562 /* the socket is writable if there is space to add new data to the
563 * socket; there is no guarantee that any particular call in progress
564 * on the socket may have space in the Tx ACK window */
565 if (rxrpc_writable(sk
))
566 mask
|= POLLOUT
| POLLWRNORM
;
572 * create an RxRPC socket
574 static int rxrpc_create(struct net
*net
, struct socket
*sock
, int protocol
,
577 struct rxrpc_sock
*rx
;
580 _enter("%p,%d", sock
, protocol
);
582 /* we support transport protocol UDP/UDP6 only */
583 if (protocol
!= PF_INET
&&
584 IS_ENABLED(CONFIG_AF_RXRPC_IPV6
) && protocol
!= PF_INET6
)
585 return -EPROTONOSUPPORT
;
587 if (sock
->type
!= SOCK_DGRAM
)
588 return -ESOCKTNOSUPPORT
;
590 sock
->ops
= &rxrpc_rpc_ops
;
591 sock
->state
= SS_UNCONNECTED
;
593 sk
= sk_alloc(net
, PF_RXRPC
, GFP_KERNEL
, &rxrpc_proto
, kern
);
597 sock_init_data(sock
, sk
);
598 sock_set_flag(sk
, SOCK_RCU_FREE
);
599 sk
->sk_state
= RXRPC_UNBOUND
;
600 sk
->sk_write_space
= rxrpc_write_space
;
601 sk
->sk_max_ack_backlog
= 0;
602 sk
->sk_destruct
= rxrpc_sock_destructor
;
605 rx
->family
= protocol
;
608 spin_lock_init(&rx
->incoming_lock
);
609 INIT_LIST_HEAD(&rx
->sock_calls
);
610 INIT_LIST_HEAD(&rx
->to_be_accepted
);
611 INIT_LIST_HEAD(&rx
->recvmsg_q
);
612 rwlock_init(&rx
->recvmsg_lock
);
613 rwlock_init(&rx
->call_lock
);
614 memset(&rx
->srx
, 0, sizeof(rx
->srx
));
616 _leave(" = 0 [%p]", rx
);
621 * Kill all the calls on a socket and shut it down.
623 static int rxrpc_shutdown(struct socket
*sock
, int flags
)
625 struct sock
*sk
= sock
->sk
;
626 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
629 _enter("%p,%d", sk
, flags
);
631 if (flags
!= SHUT_RDWR
)
633 if (sk
->sk_state
== RXRPC_CLOSE
)
638 spin_lock_bh(&sk
->sk_receive_queue
.lock
);
639 if (sk
->sk_state
< RXRPC_CLOSE
) {
640 sk
->sk_state
= RXRPC_CLOSE
;
641 sk
->sk_shutdown
= SHUTDOWN_MASK
;
645 spin_unlock_bh(&sk
->sk_receive_queue
.lock
);
647 rxrpc_discard_prealloc(rx
);
654 * RxRPC socket destructor
656 static void rxrpc_sock_destructor(struct sock
*sk
)
660 rxrpc_purge_queue(&sk
->sk_receive_queue
);
662 WARN_ON(atomic_read(&sk
->sk_wmem_alloc
));
663 WARN_ON(!sk_unhashed(sk
));
664 WARN_ON(sk
->sk_socket
);
666 if (!sock_flag(sk
, SOCK_DEAD
)) {
667 printk("Attempt to release alive rxrpc socket: %p\n", sk
);
673 * release an RxRPC socket
675 static int rxrpc_release_sock(struct sock
*sk
)
677 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
679 _enter("%p{%d,%d}", sk
, sk
->sk_state
, atomic_read(&sk
->sk_refcnt
));
681 /* declare the socket closed for business */
683 sk
->sk_shutdown
= SHUTDOWN_MASK
;
685 spin_lock_bh(&sk
->sk_receive_queue
.lock
);
686 sk
->sk_state
= RXRPC_CLOSE
;
687 spin_unlock_bh(&sk
->sk_receive_queue
.lock
);
689 if (rx
->local
&& rcu_access_pointer(rx
->local
->service
) == rx
) {
690 write_lock(&rx
->local
->services_lock
);
691 rcu_assign_pointer(rx
->local
->service
, NULL
);
692 write_unlock(&rx
->local
->services_lock
);
695 /* try to flush out this socket */
696 rxrpc_discard_prealloc(rx
);
697 rxrpc_release_calls_on_socket(rx
);
698 flush_workqueue(rxrpc_workqueue
);
699 rxrpc_purge_queue(&sk
->sk_receive_queue
);
701 rxrpc_put_local(rx
->local
);
705 key_put(rx
->securities
);
706 rx
->securities
= NULL
;
714 * release an RxRPC BSD socket on close() or equivalent
716 static int rxrpc_release(struct socket
*sock
)
718 struct sock
*sk
= sock
->sk
;
720 _enter("%p{%p}", sock
, sk
);
727 return rxrpc_release_sock(sk
);
731 * RxRPC network protocol
733 static const struct proto_ops rxrpc_rpc_ops
= {
735 .owner
= THIS_MODULE
,
736 .release
= rxrpc_release
,
738 .connect
= rxrpc_connect
,
739 .socketpair
= sock_no_socketpair
,
740 .accept
= sock_no_accept
,
741 .getname
= sock_no_getname
,
743 .ioctl
= sock_no_ioctl
,
744 .listen
= rxrpc_listen
,
745 .shutdown
= rxrpc_shutdown
,
746 .setsockopt
= rxrpc_setsockopt
,
747 .getsockopt
= sock_no_getsockopt
,
748 .sendmsg
= rxrpc_sendmsg
,
749 .recvmsg
= rxrpc_recvmsg
,
750 .mmap
= sock_no_mmap
,
751 .sendpage
= sock_no_sendpage
,
754 static struct proto rxrpc_proto
= {
756 .owner
= THIS_MODULE
,
757 .obj_size
= sizeof(struct rxrpc_sock
),
758 .max_header
= sizeof(struct rxrpc_wire_header
),
761 static const struct net_proto_family rxrpc_family_ops
= {
763 .create
= rxrpc_create
,
764 .owner
= THIS_MODULE
,
768 * initialise and register the RxRPC protocol
770 static int __init
af_rxrpc_init(void)
775 BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv
) > FIELD_SIZEOF(struct sk_buff
, cb
));
777 get_random_bytes(&tmp
, sizeof(tmp
));
781 idr_set_cursor(&rxrpc_client_conn_ids
, tmp
);
784 rxrpc_call_jar
= kmem_cache_create(
785 "rxrpc_call_jar", sizeof(struct rxrpc_call
), 0,
786 SLAB_HWCACHE_ALIGN
, NULL
);
787 if (!rxrpc_call_jar
) {
788 pr_notice("Failed to allocate call jar\n");
792 rxrpc_workqueue
= alloc_workqueue("krxrpcd", 0, 1);
793 if (!rxrpc_workqueue
) {
794 pr_notice("Failed to allocate work queue\n");
795 goto error_work_queue
;
798 ret
= rxrpc_init_security();
800 pr_crit("Cannot initialise security\n");
804 ret
= register_pernet_subsys(&rxrpc_net_ops
);
808 ret
= proto_register(&rxrpc_proto
, 1);
810 pr_crit("Cannot register protocol\n");
814 ret
= sock_register(&rxrpc_family_ops
);
816 pr_crit("Cannot register socket family\n");
820 ret
= register_key_type(&key_type_rxrpc
);
822 pr_crit("Cannot register client key type\n");
826 ret
= register_key_type(&key_type_rxrpc_s
);
828 pr_crit("Cannot register server key type\n");
829 goto error_key_type_s
;
832 ret
= rxrpc_sysctl_init();
834 pr_crit("Cannot register sysctls\n");
841 unregister_key_type(&key_type_rxrpc_s
);
843 unregister_key_type(&key_type_rxrpc
);
845 sock_unregister(PF_RXRPC
);
847 proto_unregister(&rxrpc_proto
);
849 unregister_pernet_subsys(&rxrpc_net_ops
);
851 rxrpc_exit_security();
853 destroy_workqueue(rxrpc_workqueue
);
855 kmem_cache_destroy(rxrpc_call_jar
);
861 * unregister the RxRPC protocol
863 static void __exit
af_rxrpc_exit(void)
867 unregister_key_type(&key_type_rxrpc_s
);
868 unregister_key_type(&key_type_rxrpc
);
869 sock_unregister(PF_RXRPC
);
870 proto_unregister(&rxrpc_proto
);
871 unregister_pernet_subsys(&rxrpc_net_ops
);
872 ASSERTCMP(atomic_read(&rxrpc_n_tx_skbs
), ==, 0);
873 ASSERTCMP(atomic_read(&rxrpc_n_rx_skbs
), ==, 0);
875 /* Make sure the local and peer records pinned by any dying connections
879 rxrpc_destroy_client_conn_ids();
881 destroy_workqueue(rxrpc_workqueue
);
882 rxrpc_exit_security();
883 kmem_cache_destroy(rxrpc_call_jar
);
887 module_init(af_rxrpc_init
);
888 module_exit(af_rxrpc_exit
);