Convert ERR_PTR(PTR_ERR(p)) instances to ERR_CAST(p)
[linux-2.6.git] / net / rxrpc / af_rxrpc.c
1 /* AF_RXRPC implementation
2  *
3  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4  * Written by David Howells (dhowells@redhat.com)
5  *
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.
10  */
11
12 #include <linux/module.h>
13 #include <linux/net.h>
14 #include <linux/skbuff.h>
15 #include <linux/poll.h>
16 #include <linux/proc_fs.h>
17 #include <linux/key-type.h>
18 #include <net/net_namespace.h>
19 #include <net/sock.h>
20 #include <net/af_rxrpc.h>
21 #include "ar-internal.h"
22
23 MODULE_DESCRIPTION("RxRPC network protocol");
24 MODULE_AUTHOR("Red Hat, Inc.");
25 MODULE_LICENSE("GPL");
26 MODULE_ALIAS_NETPROTO(PF_RXRPC);
27
28 unsigned rxrpc_debug; // = RXRPC_DEBUG_KPROTO;
29 module_param_named(debug, rxrpc_debug, uint, S_IWUSR | S_IRUGO);
30 MODULE_PARM_DESC(rxrpc_debug, "RxRPC debugging mask");
31
32 static int sysctl_rxrpc_max_qlen __read_mostly = 10;
33
34 static struct proto rxrpc_proto;
35 static const struct proto_ops rxrpc_rpc_ops;
36
37 /* local epoch for detecting local-end reset */
38 __be32 rxrpc_epoch;
39
40 /* current debugging ID */
41 atomic_t rxrpc_debug_id;
42
43 /* count of skbs currently in use */
44 atomic_t rxrpc_n_skbs;
45
46 struct workqueue_struct *rxrpc_workqueue;
47
48 static void rxrpc_sock_destructor(struct sock *);
49
50 /*
51  * see if an RxRPC socket is currently writable
52  */
53 static inline int rxrpc_writable(struct sock *sk)
54 {
55         return atomic_read(&sk->sk_wmem_alloc) < (size_t) sk->sk_sndbuf;
56 }
57
58 /*
59  * wait for write bufferage to become available
60  */
61 static void rxrpc_write_space(struct sock *sk)
62 {
63         _enter("%p", sk);
64         read_lock(&sk->sk_callback_lock);
65         if (rxrpc_writable(sk)) {
66                 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
67                         wake_up_interruptible(sk->sk_sleep);
68                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
69         }
70         read_unlock(&sk->sk_callback_lock);
71 }
72
73 /*
74  * validate an RxRPC address
75  */
76 static int rxrpc_validate_address(struct rxrpc_sock *rx,
77                                   struct sockaddr_rxrpc *srx,
78                                   int len)
79 {
80         if (len < sizeof(struct sockaddr_rxrpc))
81                 return -EINVAL;
82
83         if (srx->srx_family != AF_RXRPC)
84                 return -EAFNOSUPPORT;
85
86         if (srx->transport_type != SOCK_DGRAM)
87                 return -ESOCKTNOSUPPORT;
88
89         len -= offsetof(struct sockaddr_rxrpc, transport);
90         if (srx->transport_len < sizeof(sa_family_t) ||
91             srx->transport_len > len)
92                 return -EINVAL;
93
94         if (srx->transport.family != rx->proto)
95                 return -EAFNOSUPPORT;
96
97         switch (srx->transport.family) {
98         case AF_INET:
99                 _debug("INET: %x @ %u.%u.%u.%u",
100                        ntohs(srx->transport.sin.sin_port),
101                        NIPQUAD(srx->transport.sin.sin_addr));
102                 if (srx->transport_len > 8)
103                         memset((void *)&srx->transport + 8, 0,
104                                srx->transport_len - 8);
105                 break;
106
107         case AF_INET6:
108         default:
109                 return -EAFNOSUPPORT;
110         }
111
112         return 0;
113 }
114
115 /*
116  * bind a local address to an RxRPC socket
117  */
118 static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len)
119 {
120         struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *) saddr;
121         struct sock *sk = sock->sk;
122         struct rxrpc_local *local;
123         struct rxrpc_sock *rx = rxrpc_sk(sk), *prx;
124         __be16 service_id;
125         int ret;
126
127         _enter("%p,%p,%d", rx, saddr, len);
128
129         ret = rxrpc_validate_address(rx, srx, len);
130         if (ret < 0)
131                 goto error;
132
133         lock_sock(&rx->sk);
134
135         if (rx->sk.sk_state != RXRPC_UNCONNECTED) {
136                 ret = -EINVAL;
137                 goto error_unlock;
138         }
139
140         memcpy(&rx->srx, srx, sizeof(rx->srx));
141
142         /* find a local transport endpoint if we don't have one already */
143         local = rxrpc_lookup_local(&rx->srx);
144         if (IS_ERR(local)) {
145                 ret = PTR_ERR(local);
146                 goto error_unlock;
147         }
148
149         rx->local = local;
150         if (srx->srx_service) {
151                 service_id = htons(srx->srx_service);
152                 write_lock_bh(&local->services_lock);
153                 list_for_each_entry(prx, &local->services, listen_link) {
154                         if (prx->service_id == service_id)
155                                 goto service_in_use;
156                 }
157
158                 rx->service_id = service_id;
159                 list_add_tail(&rx->listen_link, &local->services);
160                 write_unlock_bh(&local->services_lock);
161
162                 rx->sk.sk_state = RXRPC_SERVER_BOUND;
163         } else {
164                 rx->sk.sk_state = RXRPC_CLIENT_BOUND;
165         }
166
167         release_sock(&rx->sk);
168         _leave(" = 0");
169         return 0;
170
171 service_in_use:
172         ret = -EADDRINUSE;
173         write_unlock_bh(&local->services_lock);
174 error_unlock:
175         release_sock(&rx->sk);
176 error:
177         _leave(" = %d", ret);
178         return ret;
179 }
180
181 /*
182  * set the number of pending calls permitted on a listening socket
183  */
184 static int rxrpc_listen(struct socket *sock, int backlog)
185 {
186         struct sock *sk = sock->sk;
187         struct rxrpc_sock *rx = rxrpc_sk(sk);
188         int ret;
189
190         _enter("%p,%d", rx, backlog);
191
192         lock_sock(&rx->sk);
193
194         switch (rx->sk.sk_state) {
195         case RXRPC_UNCONNECTED:
196                 ret = -EADDRNOTAVAIL;
197                 break;
198         case RXRPC_CLIENT_BOUND:
199         case RXRPC_CLIENT_CONNECTED:
200         default:
201                 ret = -EBUSY;
202                 break;
203         case RXRPC_SERVER_BOUND:
204                 ASSERT(rx->local != NULL);
205                 sk->sk_max_ack_backlog = backlog;
206                 rx->sk.sk_state = RXRPC_SERVER_LISTENING;
207                 ret = 0;
208                 break;
209         }
210
211         release_sock(&rx->sk);
212         _leave(" = %d", ret);
213         return ret;
214 }
215
216 /*
217  * find a transport by address
218  */
219 static struct rxrpc_transport *rxrpc_name_to_transport(struct socket *sock,
220                                                        struct sockaddr *addr,
221                                                        int addr_len, int flags,
222                                                        gfp_t gfp)
223 {
224         struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *) addr;
225         struct rxrpc_transport *trans;
226         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
227         struct rxrpc_peer *peer;
228
229         _enter("%p,%p,%d,%d", rx, addr, addr_len, flags);
230
231         ASSERT(rx->local != NULL);
232         ASSERT(rx->sk.sk_state > RXRPC_UNCONNECTED);
233
234         if (rx->srx.transport_type != srx->transport_type)
235                 return ERR_PTR(-ESOCKTNOSUPPORT);
236         if (rx->srx.transport.family != srx->transport.family)
237                 return ERR_PTR(-EAFNOSUPPORT);
238
239         /* find a remote transport endpoint from the local one */
240         peer = rxrpc_get_peer(srx, gfp);
241         if (IS_ERR(peer))
242                 return ERR_CAST(peer);
243
244         /* find a transport */
245         trans = rxrpc_get_transport(rx->local, peer, gfp);
246         rxrpc_put_peer(peer);
247         _leave(" = %p", trans);
248         return trans;
249 }
250
251 /**
252  * rxrpc_kernel_begin_call - Allow a kernel service to begin a call
253  * @sock: The socket on which to make the call
254  * @srx: The address of the peer to contact (defaults to socket setting)
255  * @key: The security context to use (defaults to socket setting)
256  * @user_call_ID: The ID to use
257  *
258  * Allow a kernel service to begin a call on the nominated socket.  This just
259  * sets up all the internal tracking structures and allocates connection and
260  * call IDs as appropriate.  The call to be used is returned.
261  *
262  * The default socket destination address and security may be overridden by
263  * supplying @srx and @key.
264  */
265 struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock,
266                                            struct sockaddr_rxrpc *srx,
267                                            struct key *key,
268                                            unsigned long user_call_ID,
269                                            gfp_t gfp)
270 {
271         struct rxrpc_conn_bundle *bundle;
272         struct rxrpc_transport *trans;
273         struct rxrpc_call *call;
274         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
275         __be16 service_id;
276
277         _enter(",,%x,%lx", key_serial(key), user_call_ID);
278
279         lock_sock(&rx->sk);
280
281         if (srx) {
282                 trans = rxrpc_name_to_transport(sock, (struct sockaddr *) srx,
283                                                 sizeof(*srx), 0, gfp);
284                 if (IS_ERR(trans)) {
285                         call = ERR_CAST(trans);
286                         trans = NULL;
287                         goto out;
288                 }
289         } else {
290                 trans = rx->trans;
291                 if (!trans) {
292                         call = ERR_PTR(-ENOTCONN);
293                         goto out;
294                 }
295                 atomic_inc(&trans->usage);
296         }
297
298         service_id = rx->service_id;
299         if (srx)
300                 service_id = htons(srx->srx_service);
301
302         if (!key)
303                 key = rx->key;
304         if (key && !key->payload.data)
305                 key = NULL; /* a no-security key */
306
307         bundle = rxrpc_get_bundle(rx, trans, key, service_id, gfp);
308         if (IS_ERR(bundle)) {
309                 call = ERR_CAST(bundle);
310                 goto out;
311         }
312
313         call = rxrpc_get_client_call(rx, trans, bundle, user_call_ID, true,
314                                      gfp);
315         rxrpc_put_bundle(trans, bundle);
316 out:
317         rxrpc_put_transport(trans);
318         release_sock(&rx->sk);
319         _leave(" = %p", call);
320         return call;
321 }
322
323 EXPORT_SYMBOL(rxrpc_kernel_begin_call);
324
325 /**
326  * rxrpc_kernel_end_call - Allow a kernel service to end a call it was using
327  * @call: The call to end
328  *
329  * Allow a kernel service to end a call it was using.  The call must be
330  * complete before this is called (the call should be aborted if necessary).
331  */
332 void rxrpc_kernel_end_call(struct rxrpc_call *call)
333 {
334         _enter("%d{%d}", call->debug_id, atomic_read(&call->usage));
335         rxrpc_remove_user_ID(call->socket, call);
336         rxrpc_put_call(call);
337 }
338
339 EXPORT_SYMBOL(rxrpc_kernel_end_call);
340
341 /**
342  * rxrpc_kernel_intercept_rx_messages - Intercept received RxRPC messages
343  * @sock: The socket to intercept received messages on
344  * @interceptor: The function to pass the messages to
345  *
346  * Allow a kernel service to intercept messages heading for the Rx queue on an
347  * RxRPC socket.  They get passed to the specified function instead.
348  * @interceptor should free the socket buffers it is given.  @interceptor is
349  * called with the socket receive queue spinlock held and softirqs disabled -
350  * this ensures that the messages will be delivered in the right order.
351  */
352 void rxrpc_kernel_intercept_rx_messages(struct socket *sock,
353                                         rxrpc_interceptor_t interceptor)
354 {
355         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
356
357         _enter("");
358         rx->interceptor = interceptor;
359 }
360
361 EXPORT_SYMBOL(rxrpc_kernel_intercept_rx_messages);
362
363 /*
364  * connect an RxRPC socket
365  * - this just targets it at a specific destination; no actual connection
366  *   negotiation takes place
367  */
368 static int rxrpc_connect(struct socket *sock, struct sockaddr *addr,
369                          int addr_len, int flags)
370 {
371         struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *) addr;
372         struct sock *sk = sock->sk;
373         struct rxrpc_transport *trans;
374         struct rxrpc_local *local;
375         struct rxrpc_sock *rx = rxrpc_sk(sk);
376         int ret;
377
378         _enter("%p,%p,%d,%d", rx, addr, addr_len, flags);
379
380         ret = rxrpc_validate_address(rx, srx, addr_len);
381         if (ret < 0) {
382                 _leave(" = %d [bad addr]", ret);
383                 return ret;
384         }
385
386         lock_sock(&rx->sk);
387
388         switch (rx->sk.sk_state) {
389         case RXRPC_UNCONNECTED:
390                 /* find a local transport endpoint if we don't have one already */
391                 ASSERTCMP(rx->local, ==, NULL);
392                 rx->srx.srx_family = AF_RXRPC;
393                 rx->srx.srx_service = 0;
394                 rx->srx.transport_type = srx->transport_type;
395                 rx->srx.transport_len = sizeof(sa_family_t);
396                 rx->srx.transport.family = srx->transport.family;
397                 local = rxrpc_lookup_local(&rx->srx);
398                 if (IS_ERR(local)) {
399                         release_sock(&rx->sk);
400                         return PTR_ERR(local);
401                 }
402                 rx->local = local;
403                 rx->sk.sk_state = RXRPC_CLIENT_BOUND;
404         case RXRPC_CLIENT_BOUND:
405                 break;
406         case RXRPC_CLIENT_CONNECTED:
407                 release_sock(&rx->sk);
408                 return -EISCONN;
409         default:
410                 release_sock(&rx->sk);
411                 return -EBUSY; /* server sockets can't connect as well */
412         }
413
414         trans = rxrpc_name_to_transport(sock, addr, addr_len, flags,
415                                         GFP_KERNEL);
416         if (IS_ERR(trans)) {
417                 release_sock(&rx->sk);
418                 _leave(" = %ld", PTR_ERR(trans));
419                 return PTR_ERR(trans);
420         }
421
422         rx->trans = trans;
423         rx->service_id = htons(srx->srx_service);
424         rx->sk.sk_state = RXRPC_CLIENT_CONNECTED;
425
426         release_sock(&rx->sk);
427         return 0;
428 }
429
430 /*
431  * send a message through an RxRPC socket
432  * - in a client this does a number of things:
433  *   - finds/sets up a connection for the security specified (if any)
434  *   - initiates a call (ID in control data)
435  *   - ends the request phase of a call (if MSG_MORE is not set)
436  *   - sends a call data packet
437  *   - may send an abort (abort code in control data)
438  */
439 static int rxrpc_sendmsg(struct kiocb *iocb, struct socket *sock,
440                          struct msghdr *m, size_t len)
441 {
442         struct rxrpc_transport *trans;
443         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
444         int ret;
445
446         _enter(",{%d},,%zu", rx->sk.sk_state, len);
447
448         if (m->msg_flags & MSG_OOB)
449                 return -EOPNOTSUPP;
450
451         if (m->msg_name) {
452                 ret = rxrpc_validate_address(rx, m->msg_name, m->msg_namelen);
453                 if (ret < 0) {
454                         _leave(" = %d [bad addr]", ret);
455                         return ret;
456                 }
457         }
458
459         trans = NULL;
460         lock_sock(&rx->sk);
461
462         if (m->msg_name) {
463                 ret = -EISCONN;
464                 trans = rxrpc_name_to_transport(sock, m->msg_name,
465                                                 m->msg_namelen, 0, GFP_KERNEL);
466                 if (IS_ERR(trans)) {
467                         ret = PTR_ERR(trans);
468                         trans = NULL;
469                         goto out;
470                 }
471         } else {
472                 trans = rx->trans;
473                 if (trans)
474                         atomic_inc(&trans->usage);
475         }
476
477         switch (rx->sk.sk_state) {
478         case RXRPC_SERVER_LISTENING:
479                 if (!m->msg_name) {
480                         ret = rxrpc_server_sendmsg(iocb, rx, m, len);
481                         break;
482                 }
483         case RXRPC_SERVER_BOUND:
484         case RXRPC_CLIENT_BOUND:
485                 if (!m->msg_name) {
486                         ret = -ENOTCONN;
487                         break;
488                 }
489         case RXRPC_CLIENT_CONNECTED:
490                 ret = rxrpc_client_sendmsg(iocb, rx, trans, m, len);
491                 break;
492         default:
493                 ret = -ENOTCONN;
494                 break;
495         }
496
497 out:
498         release_sock(&rx->sk);
499         if (trans)
500                 rxrpc_put_transport(trans);
501         _leave(" = %d", ret);
502         return ret;
503 }
504
505 /*
506  * set RxRPC socket options
507  */
508 static int rxrpc_setsockopt(struct socket *sock, int level, int optname,
509                             char __user *optval, int optlen)
510 {
511         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
512         unsigned min_sec_level;
513         int ret;
514
515         _enter(",%d,%d,,%d", level, optname, optlen);
516
517         lock_sock(&rx->sk);
518         ret = -EOPNOTSUPP;
519
520         if (level == SOL_RXRPC) {
521                 switch (optname) {
522                 case RXRPC_EXCLUSIVE_CONNECTION:
523                         ret = -EINVAL;
524                         if (optlen != 0)
525                                 goto error;
526                         ret = -EISCONN;
527                         if (rx->sk.sk_state != RXRPC_UNCONNECTED)
528                                 goto error;
529                         set_bit(RXRPC_SOCK_EXCLUSIVE_CONN, &rx->flags);
530                         goto success;
531
532                 case RXRPC_SECURITY_KEY:
533                         ret = -EINVAL;
534                         if (rx->key)
535                                 goto error;
536                         ret = -EISCONN;
537                         if (rx->sk.sk_state != RXRPC_UNCONNECTED)
538                                 goto error;
539                         ret = rxrpc_request_key(rx, optval, optlen);
540                         goto error;
541
542                 case RXRPC_SECURITY_KEYRING:
543                         ret = -EINVAL;
544                         if (rx->key)
545                                 goto error;
546                         ret = -EISCONN;
547                         if (rx->sk.sk_state != RXRPC_UNCONNECTED)
548                                 goto error;
549                         ret = rxrpc_server_keyring(rx, optval, optlen);
550                         goto error;
551
552                 case RXRPC_MIN_SECURITY_LEVEL:
553                         ret = -EINVAL;
554                         if (optlen != sizeof(unsigned))
555                                 goto error;
556                         ret = -EISCONN;
557                         if (rx->sk.sk_state != RXRPC_UNCONNECTED)
558                                 goto error;
559                         ret = get_user(min_sec_level,
560                                        (unsigned __user *) optval);
561                         if (ret < 0)
562                                 goto error;
563                         ret = -EINVAL;
564                         if (min_sec_level > RXRPC_SECURITY_MAX)
565                                 goto error;
566                         rx->min_sec_level = min_sec_level;
567                         goto success;
568
569                 default:
570                         break;
571                 }
572         }
573
574 success:
575         ret = 0;
576 error:
577         release_sock(&rx->sk);
578         return ret;
579 }
580
581 /*
582  * permit an RxRPC socket to be polled
583  */
584 static unsigned int rxrpc_poll(struct file *file, struct socket *sock,
585                                poll_table *wait)
586 {
587         unsigned int mask;
588         struct sock *sk = sock->sk;
589
590         poll_wait(file, sk->sk_sleep, wait);
591         mask = 0;
592
593         /* the socket is readable if there are any messages waiting on the Rx
594          * queue */
595         if (!skb_queue_empty(&sk->sk_receive_queue))
596                 mask |= POLLIN | POLLRDNORM;
597
598         /* the socket is writable if there is space to add new data to the
599          * socket; there is no guarantee that any particular call in progress
600          * on the socket may have space in the Tx ACK window */
601         if (rxrpc_writable(sk))
602                 mask |= POLLOUT | POLLWRNORM;
603
604         return mask;
605 }
606
607 /*
608  * create an RxRPC socket
609  */
610 static int rxrpc_create(struct net *net, struct socket *sock, int protocol)
611 {
612         struct rxrpc_sock *rx;
613         struct sock *sk;
614
615         _enter("%p,%d", sock, protocol);
616
617         if (net != &init_net)
618                 return -EAFNOSUPPORT;
619
620         /* we support transport protocol UDP only */
621         if (protocol != PF_INET)
622                 return -EPROTONOSUPPORT;
623
624         if (sock->type != SOCK_DGRAM)
625                 return -ESOCKTNOSUPPORT;
626
627         sock->ops = &rxrpc_rpc_ops;
628         sock->state = SS_UNCONNECTED;
629
630         sk = sk_alloc(net, PF_RXRPC, GFP_KERNEL, &rxrpc_proto);
631         if (!sk)
632                 return -ENOMEM;
633
634         sock_init_data(sock, sk);
635         sk->sk_state            = RXRPC_UNCONNECTED;
636         sk->sk_write_space      = rxrpc_write_space;
637         sk->sk_max_ack_backlog  = sysctl_rxrpc_max_qlen;
638         sk->sk_destruct         = rxrpc_sock_destructor;
639
640         rx = rxrpc_sk(sk);
641         rx->proto = protocol;
642         rx->calls = RB_ROOT;
643
644         INIT_LIST_HEAD(&rx->listen_link);
645         INIT_LIST_HEAD(&rx->secureq);
646         INIT_LIST_HEAD(&rx->acceptq);
647         rwlock_init(&rx->call_lock);
648         memset(&rx->srx, 0, sizeof(rx->srx));
649
650         _leave(" = 0 [%p]", rx);
651         return 0;
652 }
653
654 /*
655  * RxRPC socket destructor
656  */
657 static void rxrpc_sock_destructor(struct sock *sk)
658 {
659         _enter("%p", sk);
660
661         rxrpc_purge_queue(&sk->sk_receive_queue);
662
663         BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
664         BUG_TRAP(sk_unhashed(sk));
665         BUG_TRAP(!sk->sk_socket);
666
667         if (!sock_flag(sk, SOCK_DEAD)) {
668                 printk("Attempt to release alive rxrpc socket: %p\n", sk);
669                 return;
670         }
671 }
672
673 /*
674  * release an RxRPC socket
675  */
676 static int rxrpc_release_sock(struct sock *sk)
677 {
678         struct rxrpc_sock *rx = rxrpc_sk(sk);
679
680         _enter("%p{%d,%d}", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
681
682         /* declare the socket closed for business */
683         sock_orphan(sk);
684         sk->sk_shutdown = SHUTDOWN_MASK;
685
686         spin_lock_bh(&sk->sk_receive_queue.lock);
687         sk->sk_state = RXRPC_CLOSE;
688         spin_unlock_bh(&sk->sk_receive_queue.lock);
689
690         ASSERTCMP(rx->listen_link.next, !=, LIST_POISON1);
691
692         if (!list_empty(&rx->listen_link)) {
693                 write_lock_bh(&rx->local->services_lock);
694                 list_del(&rx->listen_link);
695                 write_unlock_bh(&rx->local->services_lock);
696         }
697
698         /* try to flush out this socket */
699         rxrpc_release_calls_on_socket(rx);
700         flush_workqueue(rxrpc_workqueue);
701         rxrpc_purge_queue(&sk->sk_receive_queue);
702
703         if (rx->conn) {
704                 rxrpc_put_connection(rx->conn);
705                 rx->conn = NULL;
706         }
707
708         if (rx->bundle) {
709                 rxrpc_put_bundle(rx->trans, rx->bundle);
710                 rx->bundle = NULL;
711         }
712         if (rx->trans) {
713                 rxrpc_put_transport(rx->trans);
714                 rx->trans = NULL;
715         }
716         if (rx->local) {
717                 rxrpc_put_local(rx->local);
718                 rx->local = NULL;
719         }
720
721         key_put(rx->key);
722         rx->key = NULL;
723         key_put(rx->securities);
724         rx->securities = NULL;
725         sock_put(sk);
726
727         _leave(" = 0");
728         return 0;
729 }
730
731 /*
732  * release an RxRPC BSD socket on close() or equivalent
733  */
734 static int rxrpc_release(struct socket *sock)
735 {
736         struct sock *sk = sock->sk;
737
738         _enter("%p{%p}", sock, sk);
739
740         if (!sk)
741                 return 0;
742
743         sock->sk = NULL;
744
745         return rxrpc_release_sock(sk);
746 }
747
748 /*
749  * RxRPC network protocol
750  */
751 static const struct proto_ops rxrpc_rpc_ops = {
752         .family         = PF_UNIX,
753         .owner          = THIS_MODULE,
754         .release        = rxrpc_release,
755         .bind           = rxrpc_bind,
756         .connect        = rxrpc_connect,
757         .socketpair     = sock_no_socketpair,
758         .accept         = sock_no_accept,
759         .getname        = sock_no_getname,
760         .poll           = rxrpc_poll,
761         .ioctl          = sock_no_ioctl,
762         .listen         = rxrpc_listen,
763         .shutdown       = sock_no_shutdown,
764         .setsockopt     = rxrpc_setsockopt,
765         .getsockopt     = sock_no_getsockopt,
766         .sendmsg        = rxrpc_sendmsg,
767         .recvmsg        = rxrpc_recvmsg,
768         .mmap           = sock_no_mmap,
769         .sendpage       = sock_no_sendpage,
770 };
771
772 static struct proto rxrpc_proto = {
773         .name           = "RXRPC",
774         .owner          = THIS_MODULE,
775         .obj_size       = sizeof(struct rxrpc_sock),
776         .max_header     = sizeof(struct rxrpc_header),
777 };
778
779 static struct net_proto_family rxrpc_family_ops = {
780         .family = PF_RXRPC,
781         .create = rxrpc_create,
782         .owner  = THIS_MODULE,
783 };
784
785 /*
786  * initialise and register the RxRPC protocol
787  */
788 static int __init af_rxrpc_init(void)
789 {
790         struct sk_buff *dummy_skb;
791         int ret = -1;
792
793         BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv) > sizeof(dummy_skb->cb));
794
795         rxrpc_epoch = htonl(get_seconds());
796
797         ret = -ENOMEM;
798         rxrpc_call_jar = kmem_cache_create(
799                 "rxrpc_call_jar", sizeof(struct rxrpc_call), 0,
800                 SLAB_HWCACHE_ALIGN, NULL);
801         if (!rxrpc_call_jar) {
802                 printk(KERN_NOTICE "RxRPC: Failed to allocate call jar\n");
803                 goto error_call_jar;
804         }
805
806         rxrpc_workqueue = create_workqueue("krxrpcd");
807         if (!rxrpc_workqueue) {
808                 printk(KERN_NOTICE "RxRPC: Failed to allocate work queue\n");
809                 goto error_work_queue;
810         }
811
812         ret = proto_register(&rxrpc_proto, 1);
813         if (ret < 0) {
814                 printk(KERN_CRIT "RxRPC: Cannot register protocol\n");
815                 goto error_proto;
816         }
817
818         ret = sock_register(&rxrpc_family_ops);
819         if (ret < 0) {
820                 printk(KERN_CRIT "RxRPC: Cannot register socket family\n");
821                 goto error_sock;
822         }
823
824         ret = register_key_type(&key_type_rxrpc);
825         if (ret < 0) {
826                 printk(KERN_CRIT "RxRPC: Cannot register client key type\n");
827                 goto error_key_type;
828         }
829
830         ret = register_key_type(&key_type_rxrpc_s);
831         if (ret < 0) {
832                 printk(KERN_CRIT "RxRPC: Cannot register server key type\n");
833                 goto error_key_type_s;
834         }
835
836 #ifdef CONFIG_PROC_FS
837         proc_net_fops_create(&init_net, "rxrpc_calls", 0, &rxrpc_call_seq_fops);
838         proc_net_fops_create(&init_net, "rxrpc_conns", 0, &rxrpc_connection_seq_fops);
839 #endif
840         return 0;
841
842 error_key_type_s:
843         unregister_key_type(&key_type_rxrpc);
844 error_key_type:
845         sock_unregister(PF_RXRPC);
846 error_sock:
847         proto_unregister(&rxrpc_proto);
848 error_proto:
849         destroy_workqueue(rxrpc_workqueue);
850 error_work_queue:
851         kmem_cache_destroy(rxrpc_call_jar);
852 error_call_jar:
853         return ret;
854 }
855
856 /*
857  * unregister the RxRPC protocol
858  */
859 static void __exit af_rxrpc_exit(void)
860 {
861         _enter("");
862         unregister_key_type(&key_type_rxrpc_s);
863         unregister_key_type(&key_type_rxrpc);
864         sock_unregister(PF_RXRPC);
865         proto_unregister(&rxrpc_proto);
866         rxrpc_destroy_all_calls();
867         rxrpc_destroy_all_connections();
868         rxrpc_destroy_all_transports();
869         rxrpc_destroy_all_peers();
870         rxrpc_destroy_all_locals();
871
872         ASSERTCMP(atomic_read(&rxrpc_n_skbs), ==, 0);
873
874         _debug("flush scheduled work");
875         flush_workqueue(rxrpc_workqueue);
876         proc_net_remove(&init_net, "rxrpc_conns");
877         proc_net_remove(&init_net, "rxrpc_calls");
878         destroy_workqueue(rxrpc_workqueue);
879         kmem_cache_destroy(rxrpc_call_jar);
880         _leave("");
881 }
882
883 module_init(af_rxrpc_init);
884 module_exit(af_rxrpc_exit);