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 #include <linux/module.h>
13 #include <linux/net.h>
14 #include <linux/slab.h>
15 #include <linux/skbuff.h>
16 #include <linux/poll.h>
17 #include <linux/proc_fs.h>
18 #include <linux/key-type.h>
19 #include <net/net_namespace.h>
21 #include <net/af_rxrpc.h>
22 #include "ar-internal.h"
24 MODULE_DESCRIPTION("RxRPC network protocol");
25 MODULE_AUTHOR("Red Hat, Inc.");
26 MODULE_LICENSE("GPL");
27 MODULE_ALIAS_NETPROTO(PF_RXRPC
);
29 unsigned rxrpc_debug
; // = RXRPC_DEBUG_KPROTO;
30 module_param_named(debug
, rxrpc_debug
, uint
, S_IWUSR
| S_IRUGO
);
31 MODULE_PARM_DESC(debug
, "RxRPC debugging mask");
33 static int sysctl_rxrpc_max_qlen __read_mostly
= 10;
35 static struct proto rxrpc_proto
;
36 static const struct proto_ops rxrpc_rpc_ops
;
38 /* local epoch for detecting local-end reset */
41 /* current debugging ID */
42 atomic_t rxrpc_debug_id
;
44 /* count of skbs currently in use */
45 atomic_t rxrpc_n_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
)
65 read_lock(&sk
->sk_callback_lock
);
66 if (rxrpc_writable(sk
)) {
67 if (sk_has_sleeper(sk
))
68 wake_up_interruptible(sk
->sk_sleep
);
69 sk_wake_async(sk
, SOCK_WAKE_SPACE
, POLL_OUT
);
71 read_unlock(&sk
->sk_callback_lock
);
75 * validate an RxRPC address
77 static int rxrpc_validate_address(struct rxrpc_sock
*rx
,
78 struct sockaddr_rxrpc
*srx
,
81 if (len
< sizeof(struct sockaddr_rxrpc
))
84 if (srx
->srx_family
!= AF_RXRPC
)
87 if (srx
->transport_type
!= SOCK_DGRAM
)
88 return -ESOCKTNOSUPPORT
;
90 len
-= offsetof(struct sockaddr_rxrpc
, transport
);
91 if (srx
->transport_len
< sizeof(sa_family_t
) ||
92 srx
->transport_len
> len
)
95 if (srx
->transport
.family
!= rx
->proto
)
98 switch (srx
->transport
.family
) {
100 _debug("INET: %x @ %pI4",
101 ntohs(srx
->transport
.sin
.sin_port
),
102 &srx
->transport
.sin
.sin_addr
);
103 if (srx
->transport_len
> 8)
104 memset((void *)&srx
->transport
+ 8, 0,
105 srx
->transport_len
- 8);
110 return -EAFNOSUPPORT
;
117 * bind a local address to an RxRPC socket
119 static int rxrpc_bind(struct socket
*sock
, struct sockaddr
*saddr
, int len
)
121 struct sockaddr_rxrpc
*srx
= (struct sockaddr_rxrpc
*) saddr
;
122 struct sock
*sk
= sock
->sk
;
123 struct rxrpc_local
*local
;
124 struct rxrpc_sock
*rx
= rxrpc_sk(sk
), *prx
;
128 _enter("%p,%p,%d", rx
, saddr
, len
);
130 ret
= rxrpc_validate_address(rx
, srx
, len
);
136 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
) {
141 memcpy(&rx
->srx
, srx
, sizeof(rx
->srx
));
143 /* find a local transport endpoint if we don't have one already */
144 local
= rxrpc_lookup_local(&rx
->srx
);
146 ret
= PTR_ERR(local
);
151 if (srx
->srx_service
) {
152 service_id
= htons(srx
->srx_service
);
153 write_lock_bh(&local
->services_lock
);
154 list_for_each_entry(prx
, &local
->services
, listen_link
) {
155 if (prx
->service_id
== service_id
)
159 rx
->service_id
= service_id
;
160 list_add_tail(&rx
->listen_link
, &local
->services
);
161 write_unlock_bh(&local
->services_lock
);
163 rx
->sk
.sk_state
= RXRPC_SERVER_BOUND
;
165 rx
->sk
.sk_state
= RXRPC_CLIENT_BOUND
;
168 release_sock(&rx
->sk
);
174 write_unlock_bh(&local
->services_lock
);
176 release_sock(&rx
->sk
);
178 _leave(" = %d", ret
);
183 * set the number of pending calls permitted on a listening socket
185 static int rxrpc_listen(struct socket
*sock
, int backlog
)
187 struct sock
*sk
= sock
->sk
;
188 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
191 _enter("%p,%d", rx
, backlog
);
195 switch (rx
->sk
.sk_state
) {
196 case RXRPC_UNCONNECTED
:
197 ret
= -EADDRNOTAVAIL
;
199 case RXRPC_CLIENT_BOUND
:
200 case RXRPC_CLIENT_CONNECTED
:
204 case RXRPC_SERVER_BOUND
:
205 ASSERT(rx
->local
!= NULL
);
206 sk
->sk_max_ack_backlog
= backlog
;
207 rx
->sk
.sk_state
= RXRPC_SERVER_LISTENING
;
212 release_sock(&rx
->sk
);
213 _leave(" = %d", ret
);
218 * find a transport by address
220 static struct rxrpc_transport
*rxrpc_name_to_transport(struct socket
*sock
,
221 struct sockaddr
*addr
,
222 int addr_len
, int flags
,
225 struct sockaddr_rxrpc
*srx
= (struct sockaddr_rxrpc
*) addr
;
226 struct rxrpc_transport
*trans
;
227 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
228 struct rxrpc_peer
*peer
;
230 _enter("%p,%p,%d,%d", rx
, addr
, addr_len
, flags
);
232 ASSERT(rx
->local
!= NULL
);
233 ASSERT(rx
->sk
.sk_state
> RXRPC_UNCONNECTED
);
235 if (rx
->srx
.transport_type
!= srx
->transport_type
)
236 return ERR_PTR(-ESOCKTNOSUPPORT
);
237 if (rx
->srx
.transport
.family
!= srx
->transport
.family
)
238 return ERR_PTR(-EAFNOSUPPORT
);
240 /* find a remote transport endpoint from the local one */
241 peer
= rxrpc_get_peer(srx
, gfp
);
243 return ERR_CAST(peer
);
245 /* find a transport */
246 trans
= rxrpc_get_transport(rx
->local
, peer
, gfp
);
247 rxrpc_put_peer(peer
);
248 _leave(" = %p", trans
);
253 * rxrpc_kernel_begin_call - Allow a kernel service to begin a call
254 * @sock: The socket on which to make the call
255 * @srx: The address of the peer to contact (defaults to socket setting)
256 * @key: The security context to use (defaults to socket setting)
257 * @user_call_ID: The ID to use
259 * Allow a kernel service to begin a call on the nominated socket. This just
260 * sets up all the internal tracking structures and allocates connection and
261 * call IDs as appropriate. The call to be used is returned.
263 * The default socket destination address and security may be overridden by
264 * supplying @srx and @key.
266 struct rxrpc_call
*rxrpc_kernel_begin_call(struct socket
*sock
,
267 struct sockaddr_rxrpc
*srx
,
269 unsigned long user_call_ID
,
272 struct rxrpc_conn_bundle
*bundle
;
273 struct rxrpc_transport
*trans
;
274 struct rxrpc_call
*call
;
275 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
278 _enter(",,%x,%lx", key_serial(key
), user_call_ID
);
283 trans
= rxrpc_name_to_transport(sock
, (struct sockaddr
*) srx
,
284 sizeof(*srx
), 0, gfp
);
286 call
= ERR_CAST(trans
);
293 call
= ERR_PTR(-ENOTCONN
);
296 atomic_inc(&trans
->usage
);
299 service_id
= rx
->service_id
;
301 service_id
= htons(srx
->srx_service
);
305 if (key
&& !key
->payload
.data
)
306 key
= NULL
; /* a no-security key */
308 bundle
= rxrpc_get_bundle(rx
, trans
, key
, service_id
, gfp
);
309 if (IS_ERR(bundle
)) {
310 call
= ERR_CAST(bundle
);
314 call
= rxrpc_get_client_call(rx
, trans
, bundle
, user_call_ID
, true,
316 rxrpc_put_bundle(trans
, bundle
);
318 rxrpc_put_transport(trans
);
320 release_sock(&rx
->sk
);
321 _leave(" = %p", call
);
325 EXPORT_SYMBOL(rxrpc_kernel_begin_call
);
328 * rxrpc_kernel_end_call - Allow a kernel service to end a call it was using
329 * @call: The call to end
331 * Allow a kernel service to end a call it was using. The call must be
332 * complete before this is called (the call should be aborted if necessary).
334 void rxrpc_kernel_end_call(struct rxrpc_call
*call
)
336 _enter("%d{%d}", call
->debug_id
, atomic_read(&call
->usage
));
337 rxrpc_remove_user_ID(call
->socket
, call
);
338 rxrpc_put_call(call
);
341 EXPORT_SYMBOL(rxrpc_kernel_end_call
);
344 * rxrpc_kernel_intercept_rx_messages - Intercept received RxRPC messages
345 * @sock: The socket to intercept received messages on
346 * @interceptor: The function to pass the messages to
348 * Allow a kernel service to intercept messages heading for the Rx queue on an
349 * RxRPC socket. They get passed to the specified function instead.
350 * @interceptor should free the socket buffers it is given. @interceptor is
351 * called with the socket receive queue spinlock held and softirqs disabled -
352 * this ensures that the messages will be delivered in the right order.
354 void rxrpc_kernel_intercept_rx_messages(struct socket
*sock
,
355 rxrpc_interceptor_t interceptor
)
357 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
360 rx
->interceptor
= interceptor
;
363 EXPORT_SYMBOL(rxrpc_kernel_intercept_rx_messages
);
366 * connect an RxRPC socket
367 * - this just targets it at a specific destination; no actual connection
368 * negotiation takes place
370 static int rxrpc_connect(struct socket
*sock
, struct sockaddr
*addr
,
371 int addr_len
, int flags
)
373 struct sockaddr_rxrpc
*srx
= (struct sockaddr_rxrpc
*) addr
;
374 struct sock
*sk
= sock
->sk
;
375 struct rxrpc_transport
*trans
;
376 struct rxrpc_local
*local
;
377 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
380 _enter("%p,%p,%d,%d", rx
, addr
, addr_len
, flags
);
382 ret
= rxrpc_validate_address(rx
, srx
, addr_len
);
384 _leave(" = %d [bad addr]", ret
);
390 switch (rx
->sk
.sk_state
) {
391 case RXRPC_UNCONNECTED
:
392 /* find a local transport endpoint if we don't have one already */
393 ASSERTCMP(rx
->local
, ==, NULL
);
394 rx
->srx
.srx_family
= AF_RXRPC
;
395 rx
->srx
.srx_service
= 0;
396 rx
->srx
.transport_type
= srx
->transport_type
;
397 rx
->srx
.transport_len
= sizeof(sa_family_t
);
398 rx
->srx
.transport
.family
= srx
->transport
.family
;
399 local
= rxrpc_lookup_local(&rx
->srx
);
401 release_sock(&rx
->sk
);
402 return PTR_ERR(local
);
405 rx
->sk
.sk_state
= RXRPC_CLIENT_BOUND
;
406 case RXRPC_CLIENT_BOUND
:
408 case RXRPC_CLIENT_CONNECTED
:
409 release_sock(&rx
->sk
);
412 release_sock(&rx
->sk
);
413 return -EBUSY
; /* server sockets can't connect as well */
416 trans
= rxrpc_name_to_transport(sock
, addr
, addr_len
, flags
,
419 release_sock(&rx
->sk
);
420 _leave(" = %ld", PTR_ERR(trans
));
421 return PTR_ERR(trans
);
425 rx
->service_id
= htons(srx
->srx_service
);
426 rx
->sk
.sk_state
= RXRPC_CLIENT_CONNECTED
;
428 release_sock(&rx
->sk
);
433 * send a message through an RxRPC socket
434 * - in a client this does a number of things:
435 * - finds/sets up a connection for the security specified (if any)
436 * - initiates a call (ID in control data)
437 * - ends the request phase of a call (if MSG_MORE is not set)
438 * - sends a call data packet
439 * - may send an abort (abort code in control data)
441 static int rxrpc_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
442 struct msghdr
*m
, size_t len
)
444 struct rxrpc_transport
*trans
;
445 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
448 _enter(",{%d},,%zu", rx
->sk
.sk_state
, len
);
450 if (m
->msg_flags
& MSG_OOB
)
454 ret
= rxrpc_validate_address(rx
, m
->msg_name
, m
->msg_namelen
);
456 _leave(" = %d [bad addr]", ret
);
466 trans
= rxrpc_name_to_transport(sock
, m
->msg_name
,
467 m
->msg_namelen
, 0, GFP_KERNEL
);
469 ret
= PTR_ERR(trans
);
476 atomic_inc(&trans
->usage
);
479 switch (rx
->sk
.sk_state
) {
480 case RXRPC_SERVER_LISTENING
:
482 ret
= rxrpc_server_sendmsg(iocb
, rx
, m
, len
);
485 case RXRPC_SERVER_BOUND
:
486 case RXRPC_CLIENT_BOUND
:
491 case RXRPC_CLIENT_CONNECTED
:
492 ret
= rxrpc_client_sendmsg(iocb
, rx
, trans
, m
, len
);
500 release_sock(&rx
->sk
);
502 rxrpc_put_transport(trans
);
503 _leave(" = %d", ret
);
508 * set RxRPC socket options
510 static int rxrpc_setsockopt(struct socket
*sock
, int level
, int optname
,
511 char __user
*optval
, unsigned int optlen
)
513 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
514 unsigned min_sec_level
;
517 _enter(",%d,%d,,%d", level
, optname
, optlen
);
522 if (level
== SOL_RXRPC
) {
524 case RXRPC_EXCLUSIVE_CONNECTION
:
529 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
531 set_bit(RXRPC_SOCK_EXCLUSIVE_CONN
, &rx
->flags
);
534 case RXRPC_SECURITY_KEY
:
539 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
541 ret
= rxrpc_request_key(rx
, optval
, optlen
);
544 case RXRPC_SECURITY_KEYRING
:
549 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
551 ret
= rxrpc_server_keyring(rx
, optval
, optlen
);
554 case RXRPC_MIN_SECURITY_LEVEL
:
556 if (optlen
!= sizeof(unsigned))
559 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
561 ret
= get_user(min_sec_level
,
562 (unsigned __user
*) optval
);
566 if (min_sec_level
> RXRPC_SECURITY_MAX
)
568 rx
->min_sec_level
= min_sec_level
;
579 release_sock(&rx
->sk
);
584 * permit an RxRPC socket to be polled
586 static unsigned int rxrpc_poll(struct file
*file
, struct socket
*sock
,
590 struct sock
*sk
= sock
->sk
;
592 sock_poll_wait(file
, sk
->sk_sleep
, wait
);
595 /* the socket is readable if there are any messages waiting on the Rx
597 if (!skb_queue_empty(&sk
->sk_receive_queue
))
598 mask
|= POLLIN
| POLLRDNORM
;
600 /* the socket is writable if there is space to add new data to the
601 * socket; there is no guarantee that any particular call in progress
602 * on the socket may have space in the Tx ACK window */
603 if (rxrpc_writable(sk
))
604 mask
|= POLLOUT
| POLLWRNORM
;
610 * create an RxRPC socket
612 static int rxrpc_create(struct net
*net
, struct socket
*sock
, int protocol
,
615 struct rxrpc_sock
*rx
;
618 _enter("%p,%d", sock
, protocol
);
620 if (!net_eq(net
, &init_net
))
621 return -EAFNOSUPPORT
;
623 /* we support transport protocol UDP only */
624 if (protocol
!= PF_INET
)
625 return -EPROTONOSUPPORT
;
627 if (sock
->type
!= SOCK_DGRAM
)
628 return -ESOCKTNOSUPPORT
;
630 sock
->ops
= &rxrpc_rpc_ops
;
631 sock
->state
= SS_UNCONNECTED
;
633 sk
= sk_alloc(net
, PF_RXRPC
, GFP_KERNEL
, &rxrpc_proto
);
637 sock_init_data(sock
, sk
);
638 sk
->sk_state
= RXRPC_UNCONNECTED
;
639 sk
->sk_write_space
= rxrpc_write_space
;
640 sk
->sk_max_ack_backlog
= sysctl_rxrpc_max_qlen
;
641 sk
->sk_destruct
= rxrpc_sock_destructor
;
644 rx
->proto
= protocol
;
647 INIT_LIST_HEAD(&rx
->listen_link
);
648 INIT_LIST_HEAD(&rx
->secureq
);
649 INIT_LIST_HEAD(&rx
->acceptq
);
650 rwlock_init(&rx
->call_lock
);
651 memset(&rx
->srx
, 0, sizeof(rx
->srx
));
653 _leave(" = 0 [%p]", rx
);
658 * RxRPC socket destructor
660 static void rxrpc_sock_destructor(struct sock
*sk
)
664 rxrpc_purge_queue(&sk
->sk_receive_queue
);
666 WARN_ON(atomic_read(&sk
->sk_wmem_alloc
));
667 WARN_ON(!sk_unhashed(sk
));
668 WARN_ON(sk
->sk_socket
);
670 if (!sock_flag(sk
, SOCK_DEAD
)) {
671 printk("Attempt to release alive rxrpc socket: %p\n", sk
);
677 * release an RxRPC socket
679 static int rxrpc_release_sock(struct sock
*sk
)
681 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
683 _enter("%p{%d,%d}", sk
, sk
->sk_state
, atomic_read(&sk
->sk_refcnt
));
685 /* declare the socket closed for business */
687 sk
->sk_shutdown
= SHUTDOWN_MASK
;
689 spin_lock_bh(&sk
->sk_receive_queue
.lock
);
690 sk
->sk_state
= RXRPC_CLOSE
;
691 spin_unlock_bh(&sk
->sk_receive_queue
.lock
);
693 ASSERTCMP(rx
->listen_link
.next
, !=, LIST_POISON1
);
695 if (!list_empty(&rx
->listen_link
)) {
696 write_lock_bh(&rx
->local
->services_lock
);
697 list_del(&rx
->listen_link
);
698 write_unlock_bh(&rx
->local
->services_lock
);
701 /* try to flush out this socket */
702 rxrpc_release_calls_on_socket(rx
);
703 flush_workqueue(rxrpc_workqueue
);
704 rxrpc_purge_queue(&sk
->sk_receive_queue
);
707 rxrpc_put_connection(rx
->conn
);
712 rxrpc_put_bundle(rx
->trans
, rx
->bundle
);
716 rxrpc_put_transport(rx
->trans
);
720 rxrpc_put_local(rx
->local
);
726 key_put(rx
->securities
);
727 rx
->securities
= NULL
;
735 * release an RxRPC BSD socket on close() or equivalent
737 static int rxrpc_release(struct socket
*sock
)
739 struct sock
*sk
= sock
->sk
;
741 _enter("%p{%p}", sock
, sk
);
748 return rxrpc_release_sock(sk
);
752 * RxRPC network protocol
754 static const struct proto_ops rxrpc_rpc_ops
= {
756 .owner
= THIS_MODULE
,
757 .release
= rxrpc_release
,
759 .connect
= rxrpc_connect
,
760 .socketpair
= sock_no_socketpair
,
761 .accept
= sock_no_accept
,
762 .getname
= sock_no_getname
,
764 .ioctl
= sock_no_ioctl
,
765 .listen
= rxrpc_listen
,
766 .shutdown
= sock_no_shutdown
,
767 .setsockopt
= rxrpc_setsockopt
,
768 .getsockopt
= sock_no_getsockopt
,
769 .sendmsg
= rxrpc_sendmsg
,
770 .recvmsg
= rxrpc_recvmsg
,
771 .mmap
= sock_no_mmap
,
772 .sendpage
= sock_no_sendpage
,
775 static struct proto rxrpc_proto
= {
777 .owner
= THIS_MODULE
,
778 .obj_size
= sizeof(struct rxrpc_sock
),
779 .max_header
= sizeof(struct rxrpc_header
),
782 static const struct net_proto_family rxrpc_family_ops
= {
784 .create
= rxrpc_create
,
785 .owner
= THIS_MODULE
,
789 * initialise and register the RxRPC protocol
791 static int __init
af_rxrpc_init(void)
793 struct sk_buff
*dummy_skb
;
796 BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv
) > sizeof(dummy_skb
->cb
));
798 rxrpc_epoch
= htonl(get_seconds());
801 rxrpc_call_jar
= kmem_cache_create(
802 "rxrpc_call_jar", sizeof(struct rxrpc_call
), 0,
803 SLAB_HWCACHE_ALIGN
, NULL
);
804 if (!rxrpc_call_jar
) {
805 printk(KERN_NOTICE
"RxRPC: Failed to allocate call jar\n");
809 rxrpc_workqueue
= create_workqueue("krxrpcd");
810 if (!rxrpc_workqueue
) {
811 printk(KERN_NOTICE
"RxRPC: Failed to allocate work queue\n");
812 goto error_work_queue
;
815 ret
= proto_register(&rxrpc_proto
, 1);
817 printk(KERN_CRIT
"RxRPC: Cannot register protocol\n");
821 ret
= sock_register(&rxrpc_family_ops
);
823 printk(KERN_CRIT
"RxRPC: Cannot register socket family\n");
827 ret
= register_key_type(&key_type_rxrpc
);
829 printk(KERN_CRIT
"RxRPC: Cannot register client key type\n");
833 ret
= register_key_type(&key_type_rxrpc_s
);
835 printk(KERN_CRIT
"RxRPC: Cannot register server key type\n");
836 goto error_key_type_s
;
839 #ifdef CONFIG_PROC_FS
840 proc_net_fops_create(&init_net
, "rxrpc_calls", 0, &rxrpc_call_seq_fops
);
841 proc_net_fops_create(&init_net
, "rxrpc_conns", 0, &rxrpc_connection_seq_fops
);
846 unregister_key_type(&key_type_rxrpc
);
848 sock_unregister(PF_RXRPC
);
850 proto_unregister(&rxrpc_proto
);
852 destroy_workqueue(rxrpc_workqueue
);
854 kmem_cache_destroy(rxrpc_call_jar
);
860 * unregister the RxRPC protocol
862 static void __exit
af_rxrpc_exit(void)
865 unregister_key_type(&key_type_rxrpc_s
);
866 unregister_key_type(&key_type_rxrpc
);
867 sock_unregister(PF_RXRPC
);
868 proto_unregister(&rxrpc_proto
);
869 rxrpc_destroy_all_calls();
870 rxrpc_destroy_all_connections();
871 rxrpc_destroy_all_transports();
872 rxrpc_destroy_all_peers();
873 rxrpc_destroy_all_locals();
875 ASSERTCMP(atomic_read(&rxrpc_n_skbs
), ==, 0);
877 _debug("flush scheduled work");
878 flush_workqueue(rxrpc_workqueue
);
879 proc_net_remove(&init_net
, "rxrpc_conns");
880 proc_net_remove(&init_net
, "rxrpc_calls");
881 destroy_workqueue(rxrpc_workqueue
);
882 kmem_cache_destroy(rxrpc_call_jar
);
886 module_init(af_rxrpc_init
);
887 module_exit(af_rxrpc_exit
);