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/kernel.h>
14 #include <linux/net.h>
15 #include <linux/slab.h>
16 #include <linux/skbuff.h>
17 #include <linux/poll.h>
18 #include <linux/proc_fs.h>
19 #include <linux/key-type.h>
20 #include <net/net_namespace.h>
22 #include <net/af_rxrpc.h>
23 #include "ar-internal.h"
25 MODULE_DESCRIPTION("RxRPC network protocol");
26 MODULE_AUTHOR("Red Hat, Inc.");
27 MODULE_LICENSE("GPL");
28 MODULE_ALIAS_NETPROTO(PF_RXRPC
);
30 unsigned int rxrpc_debug
; // = RXRPC_DEBUG_KPROTO;
31 module_param_named(debug
, rxrpc_debug
, uint
, S_IWUSR
| S_IRUGO
);
32 MODULE_PARM_DESC(debug
, "RxRPC debugging mask");
34 static int sysctl_rxrpc_max_qlen __read_mostly
= 10;
36 static struct proto rxrpc_proto
;
37 static const struct proto_ops rxrpc_rpc_ops
;
39 /* local epoch for detecting local-end reset */
42 /* current debugging ID */
43 atomic_t rxrpc_debug_id
;
45 /* count of skbs currently in use */
46 atomic_t rxrpc_n_skbs
;
48 struct workqueue_struct
*rxrpc_workqueue
;
50 static void rxrpc_sock_destructor(struct sock
*);
53 * see if an RxRPC socket is currently writable
55 static inline int rxrpc_writable(struct sock
*sk
)
57 return atomic_read(&sk
->sk_wmem_alloc
) < (size_t) sk
->sk_sndbuf
;
61 * wait for write bufferage to become available
63 static void rxrpc_write_space(struct sock
*sk
)
67 if (rxrpc_writable(sk
)) {
68 struct socket_wq
*wq
= rcu_dereference(sk
->sk_wq
);
70 if (wq_has_sleeper(wq
))
71 wake_up_interruptible(&wq
->wait
);
72 sk_wake_async(sk
, SOCK_WAKE_SPACE
, POLL_OUT
);
78 * validate an RxRPC address
80 static int rxrpc_validate_address(struct rxrpc_sock
*rx
,
81 struct sockaddr_rxrpc
*srx
,
84 if (len
< sizeof(struct sockaddr_rxrpc
))
87 if (srx
->srx_family
!= AF_RXRPC
)
90 if (srx
->transport_type
!= SOCK_DGRAM
)
91 return -ESOCKTNOSUPPORT
;
93 len
-= offsetof(struct sockaddr_rxrpc
, transport
);
94 if (srx
->transport_len
< sizeof(sa_family_t
) ||
95 srx
->transport_len
> len
)
98 if (srx
->transport
.family
!= rx
->proto
)
101 switch (srx
->transport
.family
) {
103 _debug("INET: %x @ %pI4",
104 ntohs(srx
->transport
.sin
.sin_port
),
105 &srx
->transport
.sin
.sin_addr
);
106 if (srx
->transport_len
> 8)
107 memset((void *)&srx
->transport
+ 8, 0,
108 srx
->transport_len
- 8);
113 return -EAFNOSUPPORT
;
120 * bind a local address to an RxRPC socket
122 static int rxrpc_bind(struct socket
*sock
, struct sockaddr
*saddr
, int len
)
124 struct sockaddr_rxrpc
*srx
= (struct sockaddr_rxrpc
*) saddr
;
125 struct sock
*sk
= sock
->sk
;
126 struct rxrpc_local
*local
;
127 struct rxrpc_sock
*rx
= rxrpc_sk(sk
), *prx
;
131 _enter("%p,%p,%d", rx
, saddr
, len
);
133 ret
= rxrpc_validate_address(rx
, srx
, len
);
139 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
) {
144 memcpy(&rx
->srx
, srx
, sizeof(rx
->srx
));
146 /* find a local transport endpoint if we don't have one already */
147 local
= rxrpc_lookup_local(&rx
->srx
);
149 ret
= PTR_ERR(local
);
154 if (srx
->srx_service
) {
155 service_id
= htons(srx
->srx_service
);
156 write_lock_bh(&local
->services_lock
);
157 list_for_each_entry(prx
, &local
->services
, listen_link
) {
158 if (prx
->service_id
== service_id
)
162 rx
->service_id
= service_id
;
163 list_add_tail(&rx
->listen_link
, &local
->services
);
164 write_unlock_bh(&local
->services_lock
);
166 rx
->sk
.sk_state
= RXRPC_SERVER_BOUND
;
168 rx
->sk
.sk_state
= RXRPC_CLIENT_BOUND
;
171 release_sock(&rx
->sk
);
177 write_unlock_bh(&local
->services_lock
);
179 release_sock(&rx
->sk
);
181 _leave(" = %d", ret
);
186 * set the number of pending calls permitted on a listening socket
188 static int rxrpc_listen(struct socket
*sock
, int backlog
)
190 struct sock
*sk
= sock
->sk
;
191 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
194 _enter("%p,%d", rx
, backlog
);
198 switch (rx
->sk
.sk_state
) {
199 case RXRPC_UNCONNECTED
:
200 ret
= -EADDRNOTAVAIL
;
202 case RXRPC_CLIENT_BOUND
:
203 case RXRPC_CLIENT_CONNECTED
:
207 case RXRPC_SERVER_BOUND
:
208 ASSERT(rx
->local
!= NULL
);
209 sk
->sk_max_ack_backlog
= backlog
;
210 rx
->sk
.sk_state
= RXRPC_SERVER_LISTENING
;
215 release_sock(&rx
->sk
);
216 _leave(" = %d", ret
);
221 * find a transport by address
223 static struct rxrpc_transport
*rxrpc_name_to_transport(struct socket
*sock
,
224 struct sockaddr
*addr
,
225 int addr_len
, int flags
,
228 struct sockaddr_rxrpc
*srx
= (struct sockaddr_rxrpc
*) addr
;
229 struct rxrpc_transport
*trans
;
230 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
231 struct rxrpc_peer
*peer
;
233 _enter("%p,%p,%d,%d", rx
, addr
, addr_len
, flags
);
235 ASSERT(rx
->local
!= NULL
);
236 ASSERT(rx
->sk
.sk_state
> RXRPC_UNCONNECTED
);
238 if (rx
->srx
.transport_type
!= srx
->transport_type
)
239 return ERR_PTR(-ESOCKTNOSUPPORT
);
240 if (rx
->srx
.transport
.family
!= srx
->transport
.family
)
241 return ERR_PTR(-EAFNOSUPPORT
);
243 /* find a remote transport endpoint from the local one */
244 peer
= rxrpc_get_peer(srx
, gfp
);
246 return ERR_CAST(peer
);
248 /* find a transport */
249 trans
= rxrpc_get_transport(rx
->local
, peer
, gfp
);
250 rxrpc_put_peer(peer
);
251 _leave(" = %p", trans
);
256 * rxrpc_kernel_begin_call - Allow a kernel service to begin a call
257 * @sock: The socket on which to make the call
258 * @srx: The address of the peer to contact (defaults to socket setting)
259 * @key: The security context to use (defaults to socket setting)
260 * @user_call_ID: The ID to use
262 * Allow a kernel service to begin a call on the nominated socket. This just
263 * sets up all the internal tracking structures and allocates connection and
264 * call IDs as appropriate. The call to be used is returned.
266 * The default socket destination address and security may be overridden by
267 * supplying @srx and @key.
269 struct rxrpc_call
*rxrpc_kernel_begin_call(struct socket
*sock
,
270 struct sockaddr_rxrpc
*srx
,
272 unsigned long user_call_ID
,
275 struct rxrpc_conn_bundle
*bundle
;
276 struct rxrpc_transport
*trans
;
277 struct rxrpc_call
*call
;
278 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
281 _enter(",,%x,%lx", key_serial(key
), user_call_ID
);
286 trans
= rxrpc_name_to_transport(sock
, (struct sockaddr
*) srx
,
287 sizeof(*srx
), 0, gfp
);
289 call
= ERR_CAST(trans
);
296 call
= ERR_PTR(-ENOTCONN
);
299 atomic_inc(&trans
->usage
);
302 service_id
= rx
->service_id
;
304 service_id
= htons(srx
->srx_service
);
308 if (key
&& !key
->payload
.data
)
309 key
= NULL
; /* a no-security key */
311 bundle
= rxrpc_get_bundle(rx
, trans
, key
, service_id
, gfp
);
312 if (IS_ERR(bundle
)) {
313 call
= ERR_CAST(bundle
);
317 call
= rxrpc_get_client_call(rx
, trans
, bundle
, user_call_ID
, true,
319 rxrpc_put_bundle(trans
, bundle
);
321 rxrpc_put_transport(trans
);
323 release_sock(&rx
->sk
);
324 _leave(" = %p", call
);
328 EXPORT_SYMBOL(rxrpc_kernel_begin_call
);
331 * rxrpc_kernel_end_call - Allow a kernel service to end a call it was using
332 * @call: The call to end
334 * Allow a kernel service to end a call it was using. The call must be
335 * complete before this is called (the call should be aborted if necessary).
337 void rxrpc_kernel_end_call(struct rxrpc_call
*call
)
339 _enter("%d{%d}", call
->debug_id
, atomic_read(&call
->usage
));
340 rxrpc_remove_user_ID(call
->socket
, call
);
341 rxrpc_put_call(call
);
344 EXPORT_SYMBOL(rxrpc_kernel_end_call
);
347 * rxrpc_kernel_intercept_rx_messages - Intercept received RxRPC messages
348 * @sock: The socket to intercept received messages on
349 * @interceptor: The function to pass the messages to
351 * Allow a kernel service to intercept messages heading for the Rx queue on an
352 * RxRPC socket. They get passed to the specified function instead.
353 * @interceptor should free the socket buffers it is given. @interceptor is
354 * called with the socket receive queue spinlock held and softirqs disabled -
355 * this ensures that the messages will be delivered in the right order.
357 void rxrpc_kernel_intercept_rx_messages(struct socket
*sock
,
358 rxrpc_interceptor_t interceptor
)
360 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
363 rx
->interceptor
= interceptor
;
366 EXPORT_SYMBOL(rxrpc_kernel_intercept_rx_messages
);
369 * connect an RxRPC socket
370 * - this just targets it at a specific destination; no actual connection
371 * negotiation takes place
373 static int rxrpc_connect(struct socket
*sock
, struct sockaddr
*addr
,
374 int addr_len
, int flags
)
376 struct sockaddr_rxrpc
*srx
= (struct sockaddr_rxrpc
*) addr
;
377 struct sock
*sk
= sock
->sk
;
378 struct rxrpc_transport
*trans
;
379 struct rxrpc_local
*local
;
380 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
383 _enter("%p,%p,%d,%d", rx
, addr
, addr_len
, flags
);
385 ret
= rxrpc_validate_address(rx
, srx
, addr_len
);
387 _leave(" = %d [bad addr]", ret
);
393 switch (rx
->sk
.sk_state
) {
394 case RXRPC_UNCONNECTED
:
395 /* find a local transport endpoint if we don't have one already */
396 ASSERTCMP(rx
->local
, ==, NULL
);
397 rx
->srx
.srx_family
= AF_RXRPC
;
398 rx
->srx
.srx_service
= 0;
399 rx
->srx
.transport_type
= srx
->transport_type
;
400 rx
->srx
.transport_len
= sizeof(sa_family_t
);
401 rx
->srx
.transport
.family
= srx
->transport
.family
;
402 local
= rxrpc_lookup_local(&rx
->srx
);
404 release_sock(&rx
->sk
);
405 return PTR_ERR(local
);
408 rx
->sk
.sk_state
= RXRPC_CLIENT_BOUND
;
409 case RXRPC_CLIENT_BOUND
:
411 case RXRPC_CLIENT_CONNECTED
:
412 release_sock(&rx
->sk
);
415 release_sock(&rx
->sk
);
416 return -EBUSY
; /* server sockets can't connect as well */
419 trans
= rxrpc_name_to_transport(sock
, addr
, addr_len
, flags
,
422 release_sock(&rx
->sk
);
423 _leave(" = %ld", PTR_ERR(trans
));
424 return PTR_ERR(trans
);
428 rx
->service_id
= htons(srx
->srx_service
);
429 rx
->sk
.sk_state
= RXRPC_CLIENT_CONNECTED
;
431 release_sock(&rx
->sk
);
436 * send a message through an RxRPC socket
437 * - in a client this does a number of things:
438 * - finds/sets up a connection for the security specified (if any)
439 * - initiates a call (ID in control data)
440 * - ends the request phase of a call (if MSG_MORE is not set)
441 * - sends a call data packet
442 * - may send an abort (abort code in control data)
444 static int rxrpc_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
445 struct msghdr
*m
, size_t len
)
447 struct rxrpc_transport
*trans
;
448 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
451 _enter(",{%d},,%zu", rx
->sk
.sk_state
, len
);
453 if (m
->msg_flags
& MSG_OOB
)
457 ret
= rxrpc_validate_address(rx
, m
->msg_name
, m
->msg_namelen
);
459 _leave(" = %d [bad addr]", ret
);
469 trans
= rxrpc_name_to_transport(sock
, m
->msg_name
,
470 m
->msg_namelen
, 0, GFP_KERNEL
);
472 ret
= PTR_ERR(trans
);
479 atomic_inc(&trans
->usage
);
482 switch (rx
->sk
.sk_state
) {
483 case RXRPC_SERVER_LISTENING
:
485 ret
= rxrpc_server_sendmsg(iocb
, rx
, m
, len
);
488 case RXRPC_SERVER_BOUND
:
489 case RXRPC_CLIENT_BOUND
:
494 case RXRPC_CLIENT_CONNECTED
:
495 ret
= rxrpc_client_sendmsg(iocb
, rx
, trans
, m
, len
);
503 release_sock(&rx
->sk
);
505 rxrpc_put_transport(trans
);
506 _leave(" = %d", ret
);
511 * set RxRPC socket options
513 static int rxrpc_setsockopt(struct socket
*sock
, int level
, int optname
,
514 char __user
*optval
, unsigned int optlen
)
516 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
517 unsigned int min_sec_level
;
520 _enter(",%d,%d,,%d", level
, optname
, optlen
);
525 if (level
== SOL_RXRPC
) {
527 case RXRPC_EXCLUSIVE_CONNECTION
:
532 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
534 set_bit(RXRPC_SOCK_EXCLUSIVE_CONN
, &rx
->flags
);
537 case RXRPC_SECURITY_KEY
:
542 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
544 ret
= rxrpc_request_key(rx
, optval
, optlen
);
547 case RXRPC_SECURITY_KEYRING
:
552 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
554 ret
= rxrpc_server_keyring(rx
, optval
, optlen
);
557 case RXRPC_MIN_SECURITY_LEVEL
:
559 if (optlen
!= sizeof(unsigned int))
562 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
564 ret
= get_user(min_sec_level
,
565 (unsigned int __user
*) optval
);
569 if (min_sec_level
> RXRPC_SECURITY_MAX
)
571 rx
->min_sec_level
= min_sec_level
;
582 release_sock(&rx
->sk
);
587 * permit an RxRPC socket to be polled
589 static unsigned int rxrpc_poll(struct file
*file
, struct socket
*sock
,
593 struct sock
*sk
= sock
->sk
;
595 sock_poll_wait(file
, sk_sleep(sk
), wait
);
598 /* the socket is readable if there are any messages waiting on the Rx
600 if (!skb_queue_empty(&sk
->sk_receive_queue
))
601 mask
|= POLLIN
| POLLRDNORM
;
603 /* the socket is writable if there is space to add new data to the
604 * socket; there is no guarantee that any particular call in progress
605 * on the socket may have space in the Tx ACK window */
606 if (rxrpc_writable(sk
))
607 mask
|= POLLOUT
| POLLWRNORM
;
613 * create an RxRPC socket
615 static int rxrpc_create(struct net
*net
, struct socket
*sock
, int protocol
,
618 struct rxrpc_sock
*rx
;
621 _enter("%p,%d", sock
, protocol
);
623 if (!net_eq(net
, &init_net
))
624 return -EAFNOSUPPORT
;
626 /* we support transport protocol UDP only */
627 if (protocol
!= PF_INET
)
628 return -EPROTONOSUPPORT
;
630 if (sock
->type
!= SOCK_DGRAM
)
631 return -ESOCKTNOSUPPORT
;
633 sock
->ops
= &rxrpc_rpc_ops
;
634 sock
->state
= SS_UNCONNECTED
;
636 sk
= sk_alloc(net
, PF_RXRPC
, GFP_KERNEL
, &rxrpc_proto
);
640 sock_init_data(sock
, sk
);
641 sk
->sk_state
= RXRPC_UNCONNECTED
;
642 sk
->sk_write_space
= rxrpc_write_space
;
643 sk
->sk_max_ack_backlog
= sysctl_rxrpc_max_qlen
;
644 sk
->sk_destruct
= rxrpc_sock_destructor
;
647 rx
->proto
= protocol
;
650 INIT_LIST_HEAD(&rx
->listen_link
);
651 INIT_LIST_HEAD(&rx
->secureq
);
652 INIT_LIST_HEAD(&rx
->acceptq
);
653 rwlock_init(&rx
->call_lock
);
654 memset(&rx
->srx
, 0, sizeof(rx
->srx
));
656 _leave(" = 0 [%p]", rx
);
661 * RxRPC socket destructor
663 static void rxrpc_sock_destructor(struct sock
*sk
)
667 rxrpc_purge_queue(&sk
->sk_receive_queue
);
669 WARN_ON(atomic_read(&sk
->sk_wmem_alloc
));
670 WARN_ON(!sk_unhashed(sk
));
671 WARN_ON(sk
->sk_socket
);
673 if (!sock_flag(sk
, SOCK_DEAD
)) {
674 printk("Attempt to release alive rxrpc socket: %p\n", sk
);
680 * release an RxRPC socket
682 static int rxrpc_release_sock(struct sock
*sk
)
684 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
686 _enter("%p{%d,%d}", sk
, sk
->sk_state
, atomic_read(&sk
->sk_refcnt
));
688 /* declare the socket closed for business */
690 sk
->sk_shutdown
= SHUTDOWN_MASK
;
692 spin_lock_bh(&sk
->sk_receive_queue
.lock
);
693 sk
->sk_state
= RXRPC_CLOSE
;
694 spin_unlock_bh(&sk
->sk_receive_queue
.lock
);
696 ASSERTCMP(rx
->listen_link
.next
, !=, LIST_POISON1
);
698 if (!list_empty(&rx
->listen_link
)) {
699 write_lock_bh(&rx
->local
->services_lock
);
700 list_del(&rx
->listen_link
);
701 write_unlock_bh(&rx
->local
->services_lock
);
704 /* try to flush out this socket */
705 rxrpc_release_calls_on_socket(rx
);
706 flush_workqueue(rxrpc_workqueue
);
707 rxrpc_purge_queue(&sk
->sk_receive_queue
);
710 rxrpc_put_connection(rx
->conn
);
715 rxrpc_put_bundle(rx
->trans
, rx
->bundle
);
719 rxrpc_put_transport(rx
->trans
);
723 rxrpc_put_local(rx
->local
);
729 key_put(rx
->securities
);
730 rx
->securities
= NULL
;
738 * release an RxRPC BSD socket on close() or equivalent
740 static int rxrpc_release(struct socket
*sock
)
742 struct sock
*sk
= sock
->sk
;
744 _enter("%p{%p}", sock
, sk
);
751 return rxrpc_release_sock(sk
);
755 * RxRPC network protocol
757 static const struct proto_ops rxrpc_rpc_ops
= {
759 .owner
= THIS_MODULE
,
760 .release
= rxrpc_release
,
762 .connect
= rxrpc_connect
,
763 .socketpair
= sock_no_socketpair
,
764 .accept
= sock_no_accept
,
765 .getname
= sock_no_getname
,
767 .ioctl
= sock_no_ioctl
,
768 .listen
= rxrpc_listen
,
769 .shutdown
= sock_no_shutdown
,
770 .setsockopt
= rxrpc_setsockopt
,
771 .getsockopt
= sock_no_getsockopt
,
772 .sendmsg
= rxrpc_sendmsg
,
773 .recvmsg
= rxrpc_recvmsg
,
774 .mmap
= sock_no_mmap
,
775 .sendpage
= sock_no_sendpage
,
778 static struct proto rxrpc_proto
= {
780 .owner
= THIS_MODULE
,
781 .obj_size
= sizeof(struct rxrpc_sock
),
782 .max_header
= sizeof(struct rxrpc_header
),
785 static const struct net_proto_family rxrpc_family_ops
= {
787 .create
= rxrpc_create
,
788 .owner
= THIS_MODULE
,
792 * initialise and register the RxRPC protocol
794 static int __init
af_rxrpc_init(void)
798 BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv
) > FIELD_SIZEOF(struct sk_buff
, cb
));
800 rxrpc_epoch
= htonl(get_seconds());
803 rxrpc_call_jar
= kmem_cache_create(
804 "rxrpc_call_jar", sizeof(struct rxrpc_call
), 0,
805 SLAB_HWCACHE_ALIGN
, NULL
);
806 if (!rxrpc_call_jar
) {
807 printk(KERN_NOTICE
"RxRPC: Failed to allocate call jar\n");
811 rxrpc_workqueue
= alloc_workqueue("krxrpcd", 0, 1);
812 if (!rxrpc_workqueue
) {
813 printk(KERN_NOTICE
"RxRPC: Failed to allocate work queue\n");
814 goto error_work_queue
;
817 ret
= proto_register(&rxrpc_proto
, 1);
819 printk(KERN_CRIT
"RxRPC: Cannot register protocol\n");
823 ret
= sock_register(&rxrpc_family_ops
);
825 printk(KERN_CRIT
"RxRPC: Cannot register socket family\n");
829 ret
= register_key_type(&key_type_rxrpc
);
831 printk(KERN_CRIT
"RxRPC: Cannot register client key type\n");
835 ret
= register_key_type(&key_type_rxrpc_s
);
837 printk(KERN_CRIT
"RxRPC: Cannot register server key type\n");
838 goto error_key_type_s
;
841 #ifdef CONFIG_PROC_FS
842 proc_create("rxrpc_calls", 0, init_net
.proc_net
, &rxrpc_call_seq_fops
);
843 proc_create("rxrpc_conns", 0, init_net
.proc_net
,
844 &rxrpc_connection_seq_fops
);
849 unregister_key_type(&key_type_rxrpc
);
851 sock_unregister(PF_RXRPC
);
853 proto_unregister(&rxrpc_proto
);
855 destroy_workqueue(rxrpc_workqueue
);
857 kmem_cache_destroy(rxrpc_call_jar
);
863 * unregister the RxRPC protocol
865 static void __exit
af_rxrpc_exit(void)
868 unregister_key_type(&key_type_rxrpc_s
);
869 unregister_key_type(&key_type_rxrpc
);
870 sock_unregister(PF_RXRPC
);
871 proto_unregister(&rxrpc_proto
);
872 rxrpc_destroy_all_calls();
873 rxrpc_destroy_all_connections();
874 rxrpc_destroy_all_transports();
875 rxrpc_destroy_all_peers();
876 rxrpc_destroy_all_locals();
878 ASSERTCMP(atomic_read(&rxrpc_n_skbs
), ==, 0);
880 _debug("flush scheduled work");
881 flush_workqueue(rxrpc_workqueue
);
882 remove_proc_entry("rxrpc_conns", init_net
.proc_net
);
883 remove_proc_entry("rxrpc_calls", init_net
.proc_net
);
884 destroy_workqueue(rxrpc_workqueue
);
885 kmem_cache_destroy(rxrpc_call_jar
);
889 module_init(af_rxrpc_init
);
890 module_exit(af_rxrpc_exit
);