rxrpc: Provide a getsockopt call to query what cmsgs types are supported
[platform/kernel/linux-exynos.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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/net.h>
17 #include <linux/slab.h>
18 #include <linux/skbuff.h>
19 #include <linux/random.h>
20 #include <linux/poll.h>
21 #include <linux/proc_fs.h>
22 #include <linux/key-type.h>
23 #include <net/net_namespace.h>
24 #include <net/sock.h>
25 #include <net/af_rxrpc.h>
26 #define CREATE_TRACE_POINTS
27 #include "ar-internal.h"
28
29 MODULE_DESCRIPTION("RxRPC network protocol");
30 MODULE_AUTHOR("Red Hat, Inc.");
31 MODULE_LICENSE("GPL");
32 MODULE_ALIAS_NETPROTO(PF_RXRPC);
33
34 unsigned int rxrpc_debug; // = RXRPC_DEBUG_KPROTO;
35 module_param_named(debug, rxrpc_debug, uint, S_IWUSR | S_IRUGO);
36 MODULE_PARM_DESC(debug, "RxRPC debugging mask");
37
38 static struct proto rxrpc_proto;
39 static const struct proto_ops rxrpc_rpc_ops;
40
41 /* current debugging ID */
42 atomic_t rxrpc_debug_id;
43
44 /* count of skbs currently in use */
45 atomic_t rxrpc_n_tx_skbs, rxrpc_n_rx_skbs;
46
47 struct workqueue_struct *rxrpc_workqueue;
48
49 static void rxrpc_sock_destructor(struct sock *);
50
51 /*
52  * see if an RxRPC socket is currently writable
53  */
54 static inline int rxrpc_writable(struct sock *sk)
55 {
56         return atomic_read(&sk->sk_wmem_alloc) < (size_t) sk->sk_sndbuf;
57 }
58
59 /*
60  * wait for write bufferage to become available
61  */
62 static void rxrpc_write_space(struct sock *sk)
63 {
64         _enter("%p", sk);
65         rcu_read_lock();
66         if (rxrpc_writable(sk)) {
67                 struct socket_wq *wq = rcu_dereference(sk->sk_wq);
68
69                 if (skwq_has_sleeper(wq))
70                         wake_up_interruptible(&wq->wait);
71                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
72         }
73         rcu_read_unlock();
74 }
75
76 /*
77  * validate an RxRPC address
78  */
79 static int rxrpc_validate_address(struct rxrpc_sock *rx,
80                                   struct sockaddr_rxrpc *srx,
81                                   int len)
82 {
83         unsigned int tail;
84
85         if (len < sizeof(struct sockaddr_rxrpc))
86                 return -EINVAL;
87
88         if (srx->srx_family != AF_RXRPC)
89                 return -EAFNOSUPPORT;
90
91         if (srx->transport_type != SOCK_DGRAM)
92                 return -ESOCKTNOSUPPORT;
93
94         len -= offsetof(struct sockaddr_rxrpc, transport);
95         if (srx->transport_len < sizeof(sa_family_t) ||
96             srx->transport_len > len)
97                 return -EINVAL;
98
99         if (srx->transport.family != rx->family)
100                 return -EAFNOSUPPORT;
101
102         switch (srx->transport.family) {
103         case AF_INET:
104                 if (srx->transport_len < sizeof(struct sockaddr_in))
105                         return -EINVAL;
106                 tail = offsetof(struct sockaddr_rxrpc, transport.sin.__pad);
107                 break;
108
109 #ifdef CONFIG_AF_RXRPC_IPV6
110         case AF_INET6:
111                 if (srx->transport_len < sizeof(struct sockaddr_in6))
112                         return -EINVAL;
113                 tail = offsetof(struct sockaddr_rxrpc, transport) +
114                         sizeof(struct sockaddr_in6);
115                 break;
116 #endif
117
118         default:
119                 return -EAFNOSUPPORT;
120         }
121
122         if (tail < len)
123                 memset((void *)srx + tail, 0, len - tail);
124         _debug("INET: %pISp", &srx->transport);
125         return 0;
126 }
127
128 /*
129  * bind a local address to an RxRPC socket
130  */
131 static int rxrpc_bind(struct socket *sock, struct sockaddr *saddr, int len)
132 {
133         struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)saddr;
134         struct rxrpc_local *local;
135         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
136         u16 service_id = srx->srx_service;
137         int ret;
138
139         _enter("%p,%p,%d", rx, saddr, len);
140
141         ret = rxrpc_validate_address(rx, srx, len);
142         if (ret < 0)
143                 goto error;
144
145         lock_sock(&rx->sk);
146
147         switch (rx->sk.sk_state) {
148         case RXRPC_UNBOUND:
149                 rx->srx = *srx;
150                 local = rxrpc_lookup_local(sock_net(&rx->sk), &rx->srx);
151                 if (IS_ERR(local)) {
152                         ret = PTR_ERR(local);
153                         goto error_unlock;
154                 }
155
156                 if (service_id) {
157                         write_lock(&local->services_lock);
158                         if (rcu_access_pointer(local->service))
159                                 goto service_in_use;
160                         rx->local = local;
161                         rcu_assign_pointer(local->service, rx);
162                         write_unlock(&local->services_lock);
163
164                         rx->sk.sk_state = RXRPC_SERVER_BOUND;
165                 } else {
166                         rx->local = local;
167                         rx->sk.sk_state = RXRPC_CLIENT_BOUND;
168                 }
169                 break;
170
171         case RXRPC_SERVER_BOUND:
172                 ret = -EINVAL;
173                 if (service_id == 0)
174                         goto error_unlock;
175                 ret = -EADDRINUSE;
176                 if (service_id == rx->srx.srx_service)
177                         goto error_unlock;
178                 ret = -EINVAL;
179                 srx->srx_service = rx->srx.srx_service;
180                 if (memcmp(srx, &rx->srx, sizeof(*srx)) != 0)
181                         goto error_unlock;
182                 rx->second_service = service_id;
183                 rx->sk.sk_state = RXRPC_SERVER_BOUND2;
184                 break;
185
186         default:
187                 ret = -EINVAL;
188                 goto error_unlock;
189         }
190
191         release_sock(&rx->sk);
192         _leave(" = 0");
193         return 0;
194
195 service_in_use:
196         write_unlock(&local->services_lock);
197         rxrpc_put_local(local);
198         ret = -EADDRINUSE;
199 error_unlock:
200         release_sock(&rx->sk);
201 error:
202         _leave(" = %d", ret);
203         return ret;
204 }
205
206 /*
207  * set the number of pending calls permitted on a listening socket
208  */
209 static int rxrpc_listen(struct socket *sock, int backlog)
210 {
211         struct sock *sk = sock->sk;
212         struct rxrpc_sock *rx = rxrpc_sk(sk);
213         unsigned int max, old;
214         int ret;
215
216         _enter("%p,%d", rx, backlog);
217
218         lock_sock(&rx->sk);
219
220         switch (rx->sk.sk_state) {
221         case RXRPC_UNBOUND:
222                 ret = -EADDRNOTAVAIL;
223                 break;
224         case RXRPC_SERVER_BOUND:
225         case RXRPC_SERVER_BOUND2:
226                 ASSERT(rx->local != NULL);
227                 max = READ_ONCE(rxrpc_max_backlog);
228                 ret = -EINVAL;
229                 if (backlog == INT_MAX)
230                         backlog = max;
231                 else if (backlog < 0 || backlog > max)
232                         break;
233                 old = sk->sk_max_ack_backlog;
234                 sk->sk_max_ack_backlog = backlog;
235                 ret = rxrpc_service_prealloc(rx, GFP_KERNEL);
236                 if (ret == 0)
237                         rx->sk.sk_state = RXRPC_SERVER_LISTENING;
238                 else
239                         sk->sk_max_ack_backlog = old;
240                 break;
241         case RXRPC_SERVER_LISTENING:
242                 if (backlog == 0) {
243                         rx->sk.sk_state = RXRPC_SERVER_LISTEN_DISABLED;
244                         sk->sk_max_ack_backlog = 0;
245                         rxrpc_discard_prealloc(rx);
246                         ret = 0;
247                         break;
248                 }
249         default:
250                 ret = -EBUSY;
251                 break;
252         }
253
254         release_sock(&rx->sk);
255         _leave(" = %d", ret);
256         return ret;
257 }
258
259 /**
260  * rxrpc_kernel_begin_call - Allow a kernel service to begin a call
261  * @sock: The socket on which to make the call
262  * @srx: The address of the peer to contact
263  * @key: The security context to use (defaults to socket setting)
264  * @user_call_ID: The ID to use
265  * @gfp: The allocation constraints
266  * @notify_rx: Where to send notifications instead of socket queue
267  *
268  * Allow a kernel service to begin a call on the nominated socket.  This just
269  * sets up all the internal tracking structures and allocates connection and
270  * call IDs as appropriate.  The call to be used is returned.
271  *
272  * The default socket destination address and security may be overridden by
273  * supplying @srx and @key.
274  */
275 struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock,
276                                            struct sockaddr_rxrpc *srx,
277                                            struct key *key,
278                                            unsigned long user_call_ID,
279                                            gfp_t gfp,
280                                            rxrpc_notify_rx_t notify_rx)
281 {
282         struct rxrpc_conn_parameters cp;
283         struct rxrpc_call *call;
284         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
285         int ret;
286
287         _enter(",,%x,%lx", key_serial(key), user_call_ID);
288
289         ret = rxrpc_validate_address(rx, srx, sizeof(*srx));
290         if (ret < 0)
291                 return ERR_PTR(ret);
292
293         lock_sock(&rx->sk);
294
295         if (!key)
296                 key = rx->key;
297         if (key && !key->payload.data[0])
298                 key = NULL; /* a no-security key */
299
300         memset(&cp, 0, sizeof(cp));
301         cp.local                = rx->local;
302         cp.key                  = key;
303         cp.security_level       = 0;
304         cp.exclusive            = false;
305         cp.service_id           = srx->srx_service;
306         call = rxrpc_new_client_call(rx, &cp, srx, user_call_ID, gfp);
307         /* The socket has been unlocked. */
308         if (!IS_ERR(call))
309                 call->notify_rx = notify_rx;
310
311         mutex_unlock(&call->user_mutex);
312         _leave(" = %p", call);
313         return call;
314 }
315 EXPORT_SYMBOL(rxrpc_kernel_begin_call);
316
317 /**
318  * rxrpc_kernel_end_call - Allow a kernel service to end a call it was using
319  * @sock: The socket the call is on
320  * @call: The call to end
321  *
322  * Allow a kernel service to end a call it was using.  The call must be
323  * complete before this is called (the call should be aborted if necessary).
324  */
325 void rxrpc_kernel_end_call(struct socket *sock, struct rxrpc_call *call)
326 {
327         _enter("%d{%d}", call->debug_id, atomic_read(&call->usage));
328
329         mutex_lock(&call->user_mutex);
330         rxrpc_release_call(rxrpc_sk(sock->sk), call);
331         mutex_unlock(&call->user_mutex);
332         rxrpc_put_call(call, rxrpc_call_put_kernel);
333 }
334 EXPORT_SYMBOL(rxrpc_kernel_end_call);
335
336 /**
337  * rxrpc_kernel_new_call_notification - Get notifications of new calls
338  * @sock: The socket to intercept received messages on
339  * @notify_new_call: Function to be called when new calls appear
340  * @discard_new_call: Function to discard preallocated calls
341  *
342  * Allow a kernel service to be given notifications about new calls.
343  */
344 void rxrpc_kernel_new_call_notification(
345         struct socket *sock,
346         rxrpc_notify_new_call_t notify_new_call,
347         rxrpc_discard_new_call_t discard_new_call)
348 {
349         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
350
351         rx->notify_new_call = notify_new_call;
352         rx->discard_new_call = discard_new_call;
353 }
354 EXPORT_SYMBOL(rxrpc_kernel_new_call_notification);
355
356 /*
357  * connect an RxRPC socket
358  * - this just targets it at a specific destination; no actual connection
359  *   negotiation takes place
360  */
361 static int rxrpc_connect(struct socket *sock, struct sockaddr *addr,
362                          int addr_len, int flags)
363 {
364         struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)addr;
365         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
366         int ret;
367
368         _enter("%p,%p,%d,%d", rx, addr, addr_len, flags);
369
370         ret = rxrpc_validate_address(rx, srx, addr_len);
371         if (ret < 0) {
372                 _leave(" = %d [bad addr]", ret);
373                 return ret;
374         }
375
376         lock_sock(&rx->sk);
377
378         ret = -EISCONN;
379         if (test_bit(RXRPC_SOCK_CONNECTED, &rx->flags))
380                 goto error;
381
382         switch (rx->sk.sk_state) {
383         case RXRPC_UNBOUND:
384                 rx->sk.sk_state = RXRPC_CLIENT_UNBOUND;
385         case RXRPC_CLIENT_UNBOUND:
386         case RXRPC_CLIENT_BOUND:
387                 break;
388         default:
389                 ret = -EBUSY;
390                 goto error;
391         }
392
393         rx->connect_srx = *srx;
394         set_bit(RXRPC_SOCK_CONNECTED, &rx->flags);
395         ret = 0;
396
397 error:
398         release_sock(&rx->sk);
399         return ret;
400 }
401
402 /*
403  * send a message through an RxRPC socket
404  * - in a client this does a number of things:
405  *   - finds/sets up a connection for the security specified (if any)
406  *   - initiates a call (ID in control data)
407  *   - ends the request phase of a call (if MSG_MORE is not set)
408  *   - sends a call data packet
409  *   - may send an abort (abort code in control data)
410  */
411 static int rxrpc_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
412 {
413         struct rxrpc_local *local;
414         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
415         int ret;
416
417         _enter(",{%d},,%zu", rx->sk.sk_state, len);
418
419         if (m->msg_flags & MSG_OOB)
420                 return -EOPNOTSUPP;
421
422         if (m->msg_name) {
423                 ret = rxrpc_validate_address(rx, m->msg_name, m->msg_namelen);
424                 if (ret < 0) {
425                         _leave(" = %d [bad addr]", ret);
426                         return ret;
427                 }
428         }
429
430         lock_sock(&rx->sk);
431
432         switch (rx->sk.sk_state) {
433         case RXRPC_UNBOUND:
434                 rx->srx.srx_family = AF_RXRPC;
435                 rx->srx.srx_service = 0;
436                 rx->srx.transport_type = SOCK_DGRAM;
437                 rx->srx.transport.family = rx->family;
438                 switch (rx->family) {
439                 case AF_INET:
440                         rx->srx.transport_len = sizeof(struct sockaddr_in);
441                         break;
442 #ifdef CONFIG_AF_RXRPC_IPV6
443                 case AF_INET6:
444                         rx->srx.transport_len = sizeof(struct sockaddr_in6);
445                         break;
446 #endif
447                 default:
448                         ret = -EAFNOSUPPORT;
449                         goto error_unlock;
450                 }
451                 local = rxrpc_lookup_local(sock_net(sock->sk), &rx->srx);
452                 if (IS_ERR(local)) {
453                         ret = PTR_ERR(local);
454                         goto error_unlock;
455                 }
456
457                 rx->local = local;
458                 rx->sk.sk_state = RXRPC_CLIENT_UNBOUND;
459                 /* Fall through */
460
461         case RXRPC_CLIENT_UNBOUND:
462         case RXRPC_CLIENT_BOUND:
463                 if (!m->msg_name &&
464                     test_bit(RXRPC_SOCK_CONNECTED, &rx->flags)) {
465                         m->msg_name = &rx->connect_srx;
466                         m->msg_namelen = sizeof(rx->connect_srx);
467                 }
468         case RXRPC_SERVER_BOUND:
469         case RXRPC_SERVER_LISTENING:
470                 ret = rxrpc_do_sendmsg(rx, m, len);
471                 /* The socket has been unlocked */
472                 goto out;
473         default:
474                 ret = -EINVAL;
475                 goto error_unlock;
476         }
477
478 error_unlock:
479         release_sock(&rx->sk);
480 out:
481         _leave(" = %d", ret);
482         return ret;
483 }
484
485 /*
486  * set RxRPC socket options
487  */
488 static int rxrpc_setsockopt(struct socket *sock, int level, int optname,
489                             char __user *optval, unsigned int optlen)
490 {
491         struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
492         unsigned int min_sec_level;
493         u16 service_upgrade[2];
494         int ret;
495
496         _enter(",%d,%d,,%d", level, optname, optlen);
497
498         lock_sock(&rx->sk);
499         ret = -EOPNOTSUPP;
500
501         if (level == SOL_RXRPC) {
502                 switch (optname) {
503                 case RXRPC_EXCLUSIVE_CONNECTION:
504                         ret = -EINVAL;
505                         if (optlen != 0)
506                                 goto error;
507                         ret = -EISCONN;
508                         if (rx->sk.sk_state != RXRPC_UNBOUND)
509                                 goto error;
510                         rx->exclusive = true;
511                         goto success;
512
513                 case RXRPC_SECURITY_KEY:
514                         ret = -EINVAL;
515                         if (rx->key)
516                                 goto error;
517                         ret = -EISCONN;
518                         if (rx->sk.sk_state != RXRPC_UNBOUND)
519                                 goto error;
520                         ret = rxrpc_request_key(rx, optval, optlen);
521                         goto error;
522
523                 case RXRPC_SECURITY_KEYRING:
524                         ret = -EINVAL;
525                         if (rx->key)
526                                 goto error;
527                         ret = -EISCONN;
528                         if (rx->sk.sk_state != RXRPC_UNBOUND)
529                                 goto error;
530                         ret = rxrpc_server_keyring(rx, optval, optlen);
531                         goto error;
532
533                 case RXRPC_MIN_SECURITY_LEVEL:
534                         ret = -EINVAL;
535                         if (optlen != sizeof(unsigned int))
536                                 goto error;
537                         ret = -EISCONN;
538                         if (rx->sk.sk_state != RXRPC_UNBOUND)
539                                 goto error;
540                         ret = get_user(min_sec_level,
541                                        (unsigned int __user *) optval);
542                         if (ret < 0)
543                                 goto error;
544                         ret = -EINVAL;
545                         if (min_sec_level > RXRPC_SECURITY_MAX)
546                                 goto error;
547                         rx->min_sec_level = min_sec_level;
548                         goto success;
549
550                 case RXRPC_UPGRADEABLE_SERVICE:
551                         ret = -EINVAL;
552                         if (optlen != sizeof(service_upgrade) ||
553                             rx->service_upgrade.from != 0)
554                                 goto error;
555                         ret = -EISCONN;
556                         if (rx->sk.sk_state != RXRPC_SERVER_BOUND2)
557                                 goto error;
558                         ret = -EFAULT;
559                         if (copy_from_user(service_upgrade, optval,
560                                            sizeof(service_upgrade)) != 0)
561                                 goto error;
562                         ret = -EINVAL;
563                         if ((service_upgrade[0] != rx->srx.srx_service ||
564                              service_upgrade[1] != rx->second_service) &&
565                             (service_upgrade[0] != rx->second_service ||
566                              service_upgrade[1] != rx->srx.srx_service))
567                                 goto error;
568                         rx->service_upgrade.from = service_upgrade[0];
569                         rx->service_upgrade.to = service_upgrade[1];
570                         goto success;
571
572                 default:
573                         break;
574                 }
575         }
576
577 success:
578         ret = 0;
579 error:
580         release_sock(&rx->sk);
581         return ret;
582 }
583
584 /*
585  * Get socket options.
586  */
587 static int rxrpc_getsockopt(struct socket *sock, int level, int optname,
588                             char __user *optval, int __user *_optlen)
589 {
590         int optlen;
591         
592         if (level != SOL_RXRPC)
593                 return -EOPNOTSUPP;
594
595         if (get_user(optlen, _optlen))
596                 return -EFAULT;
597         
598         switch (optname) {
599         case RXRPC_SUPPORTED_CMSG:
600                 if (optlen < sizeof(int))
601                         return -ETOOSMALL;
602                 if (put_user(RXRPC__SUPPORTED - 1, (int __user *)optval) ||
603                     put_user(sizeof(int), _optlen))
604                         return -EFAULT;
605                 return 0;
606                 
607         default:
608                 return -EOPNOTSUPP;
609         }
610 }
611
612 /*
613  * permit an RxRPC socket to be polled
614  */
615 static unsigned int rxrpc_poll(struct file *file, struct socket *sock,
616                                poll_table *wait)
617 {
618         struct sock *sk = sock->sk;
619         struct rxrpc_sock *rx = rxrpc_sk(sk);
620         unsigned int mask;
621
622         sock_poll_wait(file, sk_sleep(sk), wait);
623         mask = 0;
624
625         /* the socket is readable if there are any messages waiting on the Rx
626          * queue */
627         if (!list_empty(&rx->recvmsg_q))
628                 mask |= POLLIN | POLLRDNORM;
629
630         /* the socket is writable if there is space to add new data to the
631          * socket; there is no guarantee that any particular call in progress
632          * on the socket may have space in the Tx ACK window */
633         if (rxrpc_writable(sk))
634                 mask |= POLLOUT | POLLWRNORM;
635
636         return mask;
637 }
638
639 /*
640  * create an RxRPC socket
641  */
642 static int rxrpc_create(struct net *net, struct socket *sock, int protocol,
643                         int kern)
644 {
645         struct rxrpc_sock *rx;
646         struct sock *sk;
647
648         _enter("%p,%d", sock, protocol);
649
650         /* we support transport protocol UDP/UDP6 only */
651         if (protocol != PF_INET &&
652             IS_ENABLED(CONFIG_AF_RXRPC_IPV6) && protocol != PF_INET6)
653                 return -EPROTONOSUPPORT;
654
655         if (sock->type != SOCK_DGRAM)
656                 return -ESOCKTNOSUPPORT;
657
658         sock->ops = &rxrpc_rpc_ops;
659         sock->state = SS_UNCONNECTED;
660
661         sk = sk_alloc(net, PF_RXRPC, GFP_KERNEL, &rxrpc_proto, kern);
662         if (!sk)
663                 return -ENOMEM;
664
665         sock_init_data(sock, sk);
666         sock_set_flag(sk, SOCK_RCU_FREE);
667         sk->sk_state            = RXRPC_UNBOUND;
668         sk->sk_write_space      = rxrpc_write_space;
669         sk->sk_max_ack_backlog  = 0;
670         sk->sk_destruct         = rxrpc_sock_destructor;
671
672         rx = rxrpc_sk(sk);
673         rx->family = protocol;
674         rx->calls = RB_ROOT;
675
676         spin_lock_init(&rx->incoming_lock);
677         INIT_LIST_HEAD(&rx->sock_calls);
678         INIT_LIST_HEAD(&rx->to_be_accepted);
679         INIT_LIST_HEAD(&rx->recvmsg_q);
680         rwlock_init(&rx->recvmsg_lock);
681         rwlock_init(&rx->call_lock);
682         memset(&rx->srx, 0, sizeof(rx->srx));
683
684         _leave(" = 0 [%p]", rx);
685         return 0;
686 }
687
688 /*
689  * Kill all the calls on a socket and shut it down.
690  */
691 static int rxrpc_shutdown(struct socket *sock, int flags)
692 {
693         struct sock *sk = sock->sk;
694         struct rxrpc_sock *rx = rxrpc_sk(sk);
695         int ret = 0;
696
697         _enter("%p,%d", sk, flags);
698
699         if (flags != SHUT_RDWR)
700                 return -EOPNOTSUPP;
701         if (sk->sk_state == RXRPC_CLOSE)
702                 return -ESHUTDOWN;
703
704         lock_sock(sk);
705
706         spin_lock_bh(&sk->sk_receive_queue.lock);
707         if (sk->sk_state < RXRPC_CLOSE) {
708                 sk->sk_state = RXRPC_CLOSE;
709                 sk->sk_shutdown = SHUTDOWN_MASK;
710         } else {
711                 ret = -ESHUTDOWN;
712         }
713         spin_unlock_bh(&sk->sk_receive_queue.lock);
714
715         rxrpc_discard_prealloc(rx);
716
717         release_sock(sk);
718         return ret;
719 }
720
721 /*
722  * RxRPC socket destructor
723  */
724 static void rxrpc_sock_destructor(struct sock *sk)
725 {
726         _enter("%p", sk);
727
728         rxrpc_purge_queue(&sk->sk_receive_queue);
729
730         WARN_ON(atomic_read(&sk->sk_wmem_alloc));
731         WARN_ON(!sk_unhashed(sk));
732         WARN_ON(sk->sk_socket);
733
734         if (!sock_flag(sk, SOCK_DEAD)) {
735                 printk("Attempt to release alive rxrpc socket: %p\n", sk);
736                 return;
737         }
738 }
739
740 /*
741  * release an RxRPC socket
742  */
743 static int rxrpc_release_sock(struct sock *sk)
744 {
745         struct rxrpc_sock *rx = rxrpc_sk(sk);
746
747         _enter("%p{%d,%d}", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
748
749         /* declare the socket closed for business */
750         sock_orphan(sk);
751         sk->sk_shutdown = SHUTDOWN_MASK;
752
753         spin_lock_bh(&sk->sk_receive_queue.lock);
754         sk->sk_state = RXRPC_CLOSE;
755         spin_unlock_bh(&sk->sk_receive_queue.lock);
756
757         if (rx->local && rcu_access_pointer(rx->local->service) == rx) {
758                 write_lock(&rx->local->services_lock);
759                 rcu_assign_pointer(rx->local->service, NULL);
760                 write_unlock(&rx->local->services_lock);
761         }
762
763         /* try to flush out this socket */
764         rxrpc_discard_prealloc(rx);
765         rxrpc_release_calls_on_socket(rx);
766         flush_workqueue(rxrpc_workqueue);
767         rxrpc_purge_queue(&sk->sk_receive_queue);
768
769         rxrpc_put_local(rx->local);
770         rx->local = NULL;
771         key_put(rx->key);
772         rx->key = NULL;
773         key_put(rx->securities);
774         rx->securities = NULL;
775         sock_put(sk);
776
777         _leave(" = 0");
778         return 0;
779 }
780
781 /*
782  * release an RxRPC BSD socket on close() or equivalent
783  */
784 static int rxrpc_release(struct socket *sock)
785 {
786         struct sock *sk = sock->sk;
787
788         _enter("%p{%p}", sock, sk);
789
790         if (!sk)
791                 return 0;
792
793         sock->sk = NULL;
794
795         return rxrpc_release_sock(sk);
796 }
797
798 /*
799  * RxRPC network protocol
800  */
801 static const struct proto_ops rxrpc_rpc_ops = {
802         .family         = PF_RXRPC,
803         .owner          = THIS_MODULE,
804         .release        = rxrpc_release,
805         .bind           = rxrpc_bind,
806         .connect        = rxrpc_connect,
807         .socketpair     = sock_no_socketpair,
808         .accept         = sock_no_accept,
809         .getname        = sock_no_getname,
810         .poll           = rxrpc_poll,
811         .ioctl          = sock_no_ioctl,
812         .listen         = rxrpc_listen,
813         .shutdown       = rxrpc_shutdown,
814         .setsockopt     = rxrpc_setsockopt,
815         .getsockopt     = rxrpc_getsockopt,
816         .sendmsg        = rxrpc_sendmsg,
817         .recvmsg        = rxrpc_recvmsg,
818         .mmap           = sock_no_mmap,
819         .sendpage       = sock_no_sendpage,
820 };
821
822 static struct proto rxrpc_proto = {
823         .name           = "RXRPC",
824         .owner          = THIS_MODULE,
825         .obj_size       = sizeof(struct rxrpc_sock),
826         .max_header     = sizeof(struct rxrpc_wire_header),
827 };
828
829 static const struct net_proto_family rxrpc_family_ops = {
830         .family = PF_RXRPC,
831         .create = rxrpc_create,
832         .owner  = THIS_MODULE,
833 };
834
835 /*
836  * initialise and register the RxRPC protocol
837  */
838 static int __init af_rxrpc_init(void)
839 {
840         int ret = -1;
841         unsigned int tmp;
842
843         BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv) > FIELD_SIZEOF(struct sk_buff, cb));
844
845         get_random_bytes(&tmp, sizeof(tmp));
846         tmp &= 0x3fffffff;
847         if (tmp == 0)
848                 tmp = 1;
849         idr_set_cursor(&rxrpc_client_conn_ids, tmp);
850
851         ret = -ENOMEM;
852         rxrpc_call_jar = kmem_cache_create(
853                 "rxrpc_call_jar", sizeof(struct rxrpc_call), 0,
854                 SLAB_HWCACHE_ALIGN, NULL);
855         if (!rxrpc_call_jar) {
856                 pr_notice("Failed to allocate call jar\n");
857                 goto error_call_jar;
858         }
859
860         rxrpc_workqueue = alloc_workqueue("krxrpcd", 0, 1);
861         if (!rxrpc_workqueue) {
862                 pr_notice("Failed to allocate work queue\n");
863                 goto error_work_queue;
864         }
865
866         ret = rxrpc_init_security();
867         if (ret < 0) {
868                 pr_crit("Cannot initialise security\n");
869                 goto error_security;
870         }
871
872         ret = register_pernet_subsys(&rxrpc_net_ops);
873         if (ret)
874                 goto error_pernet;
875
876         ret = proto_register(&rxrpc_proto, 1);
877         if (ret < 0) {
878                 pr_crit("Cannot register protocol\n");
879                 goto error_proto;
880         }
881
882         ret = sock_register(&rxrpc_family_ops);
883         if (ret < 0) {
884                 pr_crit("Cannot register socket family\n");
885                 goto error_sock;
886         }
887
888         ret = register_key_type(&key_type_rxrpc);
889         if (ret < 0) {
890                 pr_crit("Cannot register client key type\n");
891                 goto error_key_type;
892         }
893
894         ret = register_key_type(&key_type_rxrpc_s);
895         if (ret < 0) {
896                 pr_crit("Cannot register server key type\n");
897                 goto error_key_type_s;
898         }
899
900         ret = rxrpc_sysctl_init();
901         if (ret < 0) {
902                 pr_crit("Cannot register sysctls\n");
903                 goto error_sysctls;
904         }
905
906         return 0;
907
908 error_sysctls:
909         unregister_key_type(&key_type_rxrpc_s);
910 error_key_type_s:
911         unregister_key_type(&key_type_rxrpc);
912 error_key_type:
913         sock_unregister(PF_RXRPC);
914 error_sock:
915         proto_unregister(&rxrpc_proto);
916 error_proto:
917         unregister_pernet_subsys(&rxrpc_net_ops);
918 error_pernet:
919         rxrpc_exit_security();
920 error_security:
921         destroy_workqueue(rxrpc_workqueue);
922 error_work_queue:
923         kmem_cache_destroy(rxrpc_call_jar);
924 error_call_jar:
925         return ret;
926 }
927
928 /*
929  * unregister the RxRPC protocol
930  */
931 static void __exit af_rxrpc_exit(void)
932 {
933         _enter("");
934         rxrpc_sysctl_exit();
935         unregister_key_type(&key_type_rxrpc_s);
936         unregister_key_type(&key_type_rxrpc);
937         sock_unregister(PF_RXRPC);
938         proto_unregister(&rxrpc_proto);
939         unregister_pernet_subsys(&rxrpc_net_ops);
940         ASSERTCMP(atomic_read(&rxrpc_n_tx_skbs), ==, 0);
941         ASSERTCMP(atomic_read(&rxrpc_n_rx_skbs), ==, 0);
942
943         /* Make sure the local and peer records pinned by any dying connections
944          * are released.
945          */
946         rcu_barrier();
947         rxrpc_destroy_client_conn_ids();
948
949         destroy_workqueue(rxrpc_workqueue);
950         rxrpc_exit_security();
951         kmem_cache_destroy(rxrpc_call_jar);
952         _leave("");
953 }
954
955 module_init(af_rxrpc_init);
956 module_exit(af_rxrpc_exit);