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 (skwq_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
;
130 _enter("%p,%p,%d", rx
, saddr
, len
);
132 ret
= rxrpc_validate_address(rx
, srx
, len
);
138 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
) {
143 memcpy(&rx
->srx
, srx
, sizeof(rx
->srx
));
145 /* Find or create a local transport endpoint to use */
146 local
= rxrpc_lookup_local(&rx
->srx
);
148 ret
= PTR_ERR(local
);
153 if (srx
->srx_service
) {
154 write_lock_bh(&local
->services_lock
);
155 list_for_each_entry(prx
, &local
->services
, listen_link
) {
156 if (prx
->srx
.srx_service
== srx
->srx_service
)
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
);
277 _enter(",,%x,%lx", key_serial(key
), user_call_ID
);
282 trans
= rxrpc_name_to_transport(sock
, (struct sockaddr
*) srx
,
283 sizeof(*srx
), 0, gfp
);
285 call
= ERR_CAST(trans
);
292 call
= ERR_PTR(-ENOTCONN
);
295 atomic_inc(&trans
->usage
);
302 if (key
&& !key
->payload
.data
[0])
303 key
= NULL
; /* a no-security key */
305 bundle
= rxrpc_get_bundle(rx
, trans
, key
, srx
->srx_service
, gfp
);
306 if (IS_ERR(bundle
)) {
307 call
= ERR_CAST(bundle
);
311 call
= rxrpc_get_client_call(rx
, trans
, bundle
, user_call_ID
, true,
313 rxrpc_put_bundle(trans
, bundle
);
315 rxrpc_put_transport(trans
);
317 release_sock(&rx
->sk
);
318 _leave(" = %p", call
);
321 EXPORT_SYMBOL(rxrpc_kernel_begin_call
);
324 * rxrpc_kernel_end_call - Allow a kernel service to end a call it was using
325 * @call: The call to end
327 * Allow a kernel service to end a call it was using. The call must be
328 * complete before this is called (the call should be aborted if necessary).
330 void rxrpc_kernel_end_call(struct rxrpc_call
*call
)
332 _enter("%d{%d}", call
->debug_id
, atomic_read(&call
->usage
));
333 rxrpc_remove_user_ID(call
->socket
, call
);
334 rxrpc_put_call(call
);
336 EXPORT_SYMBOL(rxrpc_kernel_end_call
);
339 * rxrpc_kernel_intercept_rx_messages - Intercept received RxRPC messages
340 * @sock: The socket to intercept received messages on
341 * @interceptor: The function to pass the messages to
343 * Allow a kernel service to intercept messages heading for the Rx queue on an
344 * RxRPC socket. They get passed to the specified function instead.
345 * @interceptor should free the socket buffers it is given. @interceptor is
346 * called with the socket receive queue spinlock held and softirqs disabled -
347 * this ensures that the messages will be delivered in the right order.
349 void rxrpc_kernel_intercept_rx_messages(struct socket
*sock
,
350 rxrpc_interceptor_t interceptor
)
352 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
355 rx
->interceptor
= interceptor
;
358 EXPORT_SYMBOL(rxrpc_kernel_intercept_rx_messages
);
361 * connect an RxRPC socket
362 * - this just targets it at a specific destination; no actual connection
363 * negotiation takes place
365 static int rxrpc_connect(struct socket
*sock
, struct sockaddr
*addr
,
366 int addr_len
, int flags
)
368 struct sockaddr_rxrpc
*srx
= (struct sockaddr_rxrpc
*) addr
;
369 struct sock
*sk
= sock
->sk
;
370 struct rxrpc_transport
*trans
;
371 struct rxrpc_local
*local
;
372 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
375 _enter("%p,%p,%d,%d", rx
, addr
, addr_len
, flags
);
377 ret
= rxrpc_validate_address(rx
, srx
, addr_len
);
379 _leave(" = %d [bad addr]", ret
);
385 switch (rx
->sk
.sk_state
) {
386 case RXRPC_UNCONNECTED
:
387 /* find a local transport endpoint if we don't have one already */
388 ASSERTCMP(rx
->local
, ==, NULL
);
389 rx
->srx
.srx_family
= AF_RXRPC
;
390 rx
->srx
.srx_service
= 0;
391 rx
->srx
.transport_type
= srx
->transport_type
;
392 rx
->srx
.transport_len
= sizeof(sa_family_t
);
393 rx
->srx
.transport
.family
= srx
->transport
.family
;
394 local
= rxrpc_lookup_local(&rx
->srx
);
396 release_sock(&rx
->sk
);
397 return PTR_ERR(local
);
400 rx
->sk
.sk_state
= RXRPC_CLIENT_BOUND
;
401 case RXRPC_CLIENT_BOUND
:
403 case RXRPC_CLIENT_CONNECTED
:
404 release_sock(&rx
->sk
);
407 release_sock(&rx
->sk
);
408 return -EBUSY
; /* server sockets can't connect as well */
411 trans
= rxrpc_name_to_transport(sock
, addr
, addr_len
, flags
,
414 release_sock(&rx
->sk
);
415 _leave(" = %ld", PTR_ERR(trans
));
416 return PTR_ERR(trans
);
420 rx
->sk
.sk_state
= RXRPC_CLIENT_CONNECTED
;
422 release_sock(&rx
->sk
);
427 * send a message through an RxRPC socket
428 * - in a client this does a number of things:
429 * - finds/sets up a connection for the security specified (if any)
430 * - initiates a call (ID in control data)
431 * - ends the request phase of a call (if MSG_MORE is not set)
432 * - sends a call data packet
433 * - may send an abort (abort code in control data)
435 static int rxrpc_sendmsg(struct socket
*sock
, struct msghdr
*m
, size_t len
)
437 struct rxrpc_transport
*trans
;
438 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
441 _enter(",{%d},,%zu", rx
->sk
.sk_state
, len
);
443 if (m
->msg_flags
& MSG_OOB
)
447 ret
= rxrpc_validate_address(rx
, m
->msg_name
, m
->msg_namelen
);
449 _leave(" = %d [bad addr]", ret
);
459 trans
= rxrpc_name_to_transport(sock
, m
->msg_name
,
460 m
->msg_namelen
, 0, GFP_KERNEL
);
462 ret
= PTR_ERR(trans
);
469 atomic_inc(&trans
->usage
);
472 switch (rx
->sk
.sk_state
) {
473 case RXRPC_SERVER_LISTENING
:
475 ret
= rxrpc_server_sendmsg(rx
, m
, len
);
478 case RXRPC_SERVER_BOUND
:
479 case RXRPC_CLIENT_BOUND
:
484 case RXRPC_CLIENT_CONNECTED
:
485 ret
= rxrpc_client_sendmsg(rx
, trans
, m
, len
);
493 release_sock(&rx
->sk
);
495 rxrpc_put_transport(trans
);
496 _leave(" = %d", ret
);
501 * set RxRPC socket options
503 static int rxrpc_setsockopt(struct socket
*sock
, int level
, int optname
,
504 char __user
*optval
, unsigned int optlen
)
506 struct rxrpc_sock
*rx
= rxrpc_sk(sock
->sk
);
507 unsigned int min_sec_level
;
510 _enter(",%d,%d,,%d", level
, optname
, optlen
);
515 if (level
== SOL_RXRPC
) {
517 case RXRPC_EXCLUSIVE_CONNECTION
:
522 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
524 set_bit(RXRPC_SOCK_EXCLUSIVE_CONN
, &rx
->flags
);
527 case RXRPC_SECURITY_KEY
:
532 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
534 ret
= rxrpc_request_key(rx
, optval
, optlen
);
537 case RXRPC_SECURITY_KEYRING
:
542 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
544 ret
= rxrpc_server_keyring(rx
, optval
, optlen
);
547 case RXRPC_MIN_SECURITY_LEVEL
:
549 if (optlen
!= sizeof(unsigned int))
552 if (rx
->sk
.sk_state
!= RXRPC_UNCONNECTED
)
554 ret
= get_user(min_sec_level
,
555 (unsigned int __user
*) optval
);
559 if (min_sec_level
> RXRPC_SECURITY_MAX
)
561 rx
->min_sec_level
= min_sec_level
;
572 release_sock(&rx
->sk
);
577 * permit an RxRPC socket to be polled
579 static unsigned int rxrpc_poll(struct file
*file
, struct socket
*sock
,
583 struct sock
*sk
= sock
->sk
;
585 sock_poll_wait(file
, sk_sleep(sk
), wait
);
588 /* the socket is readable if there are any messages waiting on the Rx
590 if (!skb_queue_empty(&sk
->sk_receive_queue
))
591 mask
|= POLLIN
| POLLRDNORM
;
593 /* the socket is writable if there is space to add new data to the
594 * socket; there is no guarantee that any particular call in progress
595 * on the socket may have space in the Tx ACK window */
596 if (rxrpc_writable(sk
))
597 mask
|= POLLOUT
| POLLWRNORM
;
603 * create an RxRPC socket
605 static int rxrpc_create(struct net
*net
, struct socket
*sock
, int protocol
,
608 struct rxrpc_sock
*rx
;
611 _enter("%p,%d", sock
, protocol
);
613 if (!net_eq(net
, &init_net
))
614 return -EAFNOSUPPORT
;
616 /* we support transport protocol UDP/UDP6 only */
617 if (protocol
!= PF_INET
)
618 return -EPROTONOSUPPORT
;
620 if (sock
->type
!= SOCK_DGRAM
)
621 return -ESOCKTNOSUPPORT
;
623 sock
->ops
= &rxrpc_rpc_ops
;
624 sock
->state
= SS_UNCONNECTED
;
626 sk
= sk_alloc(net
, PF_RXRPC
, GFP_KERNEL
, &rxrpc_proto
, kern
);
630 sock_init_data(sock
, sk
);
631 sk
->sk_state
= RXRPC_UNCONNECTED
;
632 sk
->sk_write_space
= rxrpc_write_space
;
633 sk
->sk_max_ack_backlog
= sysctl_rxrpc_max_qlen
;
634 sk
->sk_destruct
= rxrpc_sock_destructor
;
637 rx
->proto
= protocol
;
640 INIT_LIST_HEAD(&rx
->listen_link
);
641 INIT_LIST_HEAD(&rx
->secureq
);
642 INIT_LIST_HEAD(&rx
->acceptq
);
643 rwlock_init(&rx
->call_lock
);
644 memset(&rx
->srx
, 0, sizeof(rx
->srx
));
646 _leave(" = 0 [%p]", rx
);
651 * RxRPC socket destructor
653 static void rxrpc_sock_destructor(struct sock
*sk
)
657 rxrpc_purge_queue(&sk
->sk_receive_queue
);
659 WARN_ON(atomic_read(&sk
->sk_wmem_alloc
));
660 WARN_ON(!sk_unhashed(sk
));
661 WARN_ON(sk
->sk_socket
);
663 if (!sock_flag(sk
, SOCK_DEAD
)) {
664 printk("Attempt to release alive rxrpc socket: %p\n", sk
);
670 * release an RxRPC socket
672 static int rxrpc_release_sock(struct sock
*sk
)
674 struct rxrpc_sock
*rx
= rxrpc_sk(sk
);
676 _enter("%p{%d,%d}", sk
, sk
->sk_state
, atomic_read(&sk
->sk_refcnt
));
678 /* declare the socket closed for business */
680 sk
->sk_shutdown
= SHUTDOWN_MASK
;
682 spin_lock_bh(&sk
->sk_receive_queue
.lock
);
683 sk
->sk_state
= RXRPC_CLOSE
;
684 spin_unlock_bh(&sk
->sk_receive_queue
.lock
);
686 ASSERTCMP(rx
->listen_link
.next
, !=, LIST_POISON1
);
688 if (!list_empty(&rx
->listen_link
)) {
689 write_lock_bh(&rx
->local
->services_lock
);
690 list_del(&rx
->listen_link
);
691 write_unlock_bh(&rx
->local
->services_lock
);
694 /* try to flush out this socket */
695 rxrpc_release_calls_on_socket(rx
);
696 flush_workqueue(rxrpc_workqueue
);
697 rxrpc_purge_queue(&sk
->sk_receive_queue
);
700 rxrpc_put_connection(rx
->conn
);
705 rxrpc_put_bundle(rx
->trans
, rx
->bundle
);
709 rxrpc_put_transport(rx
->trans
);
713 rxrpc_put_local(rx
->local
);
719 key_put(rx
->securities
);
720 rx
->securities
= NULL
;
728 * release an RxRPC BSD socket on close() or equivalent
730 static int rxrpc_release(struct socket
*sock
)
732 struct sock
*sk
= sock
->sk
;
734 _enter("%p{%p}", sock
, sk
);
741 return rxrpc_release_sock(sk
);
745 * RxRPC network protocol
747 static const struct proto_ops rxrpc_rpc_ops
= {
749 .owner
= THIS_MODULE
,
750 .release
= rxrpc_release
,
752 .connect
= rxrpc_connect
,
753 .socketpair
= sock_no_socketpair
,
754 .accept
= sock_no_accept
,
755 .getname
= sock_no_getname
,
757 .ioctl
= sock_no_ioctl
,
758 .listen
= rxrpc_listen
,
759 .shutdown
= sock_no_shutdown
,
760 .setsockopt
= rxrpc_setsockopt
,
761 .getsockopt
= sock_no_getsockopt
,
762 .sendmsg
= rxrpc_sendmsg
,
763 .recvmsg
= rxrpc_recvmsg
,
764 .mmap
= sock_no_mmap
,
765 .sendpage
= sock_no_sendpage
,
768 static struct proto rxrpc_proto
= {
770 .owner
= THIS_MODULE
,
771 .obj_size
= sizeof(struct rxrpc_sock
),
772 .max_header
= sizeof(struct rxrpc_wire_header
),
775 static const struct net_proto_family rxrpc_family_ops
= {
777 .create
= rxrpc_create
,
778 .owner
= THIS_MODULE
,
782 * initialise and register the RxRPC protocol
784 static int __init
af_rxrpc_init(void)
788 BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv
) > FIELD_SIZEOF(struct sk_buff
, cb
));
790 rxrpc_epoch
= get_seconds();
793 rxrpc_call_jar
= kmem_cache_create(
794 "rxrpc_call_jar", sizeof(struct rxrpc_call
), 0,
795 SLAB_HWCACHE_ALIGN
, NULL
);
796 if (!rxrpc_call_jar
) {
797 printk(KERN_NOTICE
"RxRPC: Failed to allocate call jar\n");
801 rxrpc_workqueue
= alloc_workqueue("krxrpcd", 0, 1);
802 if (!rxrpc_workqueue
) {
803 printk(KERN_NOTICE
"RxRPC: Failed to allocate work queue\n");
804 goto error_work_queue
;
807 ret
= proto_register(&rxrpc_proto
, 1);
809 printk(KERN_CRIT
"RxRPC: Cannot register protocol\n");
813 ret
= sock_register(&rxrpc_family_ops
);
815 printk(KERN_CRIT
"RxRPC: Cannot register socket family\n");
819 ret
= register_key_type(&key_type_rxrpc
);
821 printk(KERN_CRIT
"RxRPC: Cannot register client key type\n");
825 ret
= register_key_type(&key_type_rxrpc_s
);
827 printk(KERN_CRIT
"RxRPC: Cannot register server key type\n");
828 goto error_key_type_s
;
831 ret
= rxrpc_sysctl_init();
833 printk(KERN_CRIT
"RxRPC: Cannot register sysctls\n");
837 #ifdef CONFIG_PROC_FS
838 proc_create("rxrpc_calls", 0, init_net
.proc_net
, &rxrpc_call_seq_fops
);
839 proc_create("rxrpc_conns", 0, init_net
.proc_net
,
840 &rxrpc_connection_seq_fops
);
845 unregister_key_type(&key_type_rxrpc_s
);
847 unregister_key_type(&key_type_rxrpc
);
849 sock_unregister(PF_RXRPC
);
851 proto_unregister(&rxrpc_proto
);
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 rxrpc_destroy_all_calls();
872 rxrpc_destroy_all_connections();
873 rxrpc_destroy_all_transports();
874 rxrpc_destroy_all_peers();
875 rxrpc_destroy_all_locals();
877 ASSERTCMP(atomic_read(&rxrpc_n_skbs
), ==, 0);
879 _debug("flush scheduled work");
880 flush_workqueue(rxrpc_workqueue
);
881 remove_proc_entry("rxrpc_conns", init_net
.proc_net
);
882 remove_proc_entry("rxrpc_calls", init_net
.proc_net
);
883 destroy_workqueue(rxrpc_workqueue
);
884 kmem_cache_destroy(rxrpc_call_jar
);
888 module_init(af_rxrpc_init
);
889 module_exit(af_rxrpc_exit
);