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