xref: /openbmc/linux/net/rxrpc/af_rxrpc.c (revision 6aa7de05)
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 refcount_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  * @tx_total_len: Total length of data to transmit during the call (or -1)
266  * @gfp: The allocation constraints
267  * @notify_rx: Where to send notifications instead of socket queue
268  *
269  * Allow a kernel service to begin a call on the nominated socket.  This just
270  * sets up all the internal tracking structures and allocates connection and
271  * call IDs as appropriate.  The call to be used is returned.
272  *
273  * The default socket destination address and security may be overridden by
274  * supplying @srx and @key.
275  */
276 struct rxrpc_call *rxrpc_kernel_begin_call(struct socket *sock,
277 					   struct sockaddr_rxrpc *srx,
278 					   struct key *key,
279 					   unsigned long user_call_ID,
280 					   s64 tx_total_len,
281 					   gfp_t gfp,
282 					   rxrpc_notify_rx_t notify_rx)
283 {
284 	struct rxrpc_conn_parameters cp;
285 	struct rxrpc_call *call;
286 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
287 	int ret;
288 
289 	_enter(",,%x,%lx", key_serial(key), user_call_ID);
290 
291 	ret = rxrpc_validate_address(rx, srx, sizeof(*srx));
292 	if (ret < 0)
293 		return ERR_PTR(ret);
294 
295 	lock_sock(&rx->sk);
296 
297 	if (!key)
298 		key = rx->key;
299 	if (key && !key->payload.data[0])
300 		key = NULL; /* a no-security key */
301 
302 	memset(&cp, 0, sizeof(cp));
303 	cp.local		= rx->local;
304 	cp.key			= key;
305 	cp.security_level	= 0;
306 	cp.exclusive		= false;
307 	cp.service_id		= srx->srx_service;
308 	call = rxrpc_new_client_call(rx, &cp, srx, user_call_ID, tx_total_len,
309 				     gfp);
310 	/* The socket has been unlocked. */
311 	if (!IS_ERR(call)) {
312 		call->notify_rx = notify_rx;
313 		mutex_unlock(&call->user_mutex);
314 	}
315 
316 	_leave(" = %p", call);
317 	return call;
318 }
319 EXPORT_SYMBOL(rxrpc_kernel_begin_call);
320 
321 /**
322  * rxrpc_kernel_end_call - Allow a kernel service to end a call it was using
323  * @sock: The socket the call is on
324  * @call: The call to end
325  *
326  * Allow a kernel service to end a call it was using.  The call must be
327  * complete before this is called (the call should be aborted if necessary).
328  */
329 void rxrpc_kernel_end_call(struct socket *sock, struct rxrpc_call *call)
330 {
331 	_enter("%d{%d}", call->debug_id, atomic_read(&call->usage));
332 
333 	mutex_lock(&call->user_mutex);
334 	rxrpc_release_call(rxrpc_sk(sock->sk), call);
335 	mutex_unlock(&call->user_mutex);
336 	rxrpc_put_call(call, rxrpc_call_put_kernel);
337 }
338 EXPORT_SYMBOL(rxrpc_kernel_end_call);
339 
340 /**
341  * rxrpc_kernel_check_call - Check a call's state
342  * @sock: The socket the call is on
343  * @call: The call to check
344  * @_compl: Where to store the completion state
345  * @_abort_code: Where to store any abort code
346  *
347  * Allow a kernel service to query the state of a call and find out the manner
348  * of its termination if it has completed.  Returns -EINPROGRESS if the call is
349  * still going, 0 if the call finished successfully, -ECONNABORTED if the call
350  * was aborted and an appropriate error if the call failed in some other way.
351  */
352 int rxrpc_kernel_check_call(struct socket *sock, struct rxrpc_call *call,
353 			    enum rxrpc_call_completion *_compl, u32 *_abort_code)
354 {
355 	if (call->state != RXRPC_CALL_COMPLETE)
356 		return -EINPROGRESS;
357 	smp_rmb();
358 	*_compl = call->completion;
359 	*_abort_code = call->abort_code;
360 	return call->error;
361 }
362 EXPORT_SYMBOL(rxrpc_kernel_check_call);
363 
364 /**
365  * rxrpc_kernel_retry_call - Allow a kernel service to retry a call
366  * @sock: The socket the call is on
367  * @call: The call to retry
368  * @srx: The address of the peer to contact
369  * @key: The security context to use (defaults to socket setting)
370  *
371  * Allow a kernel service to try resending a client call that failed due to a
372  * network error to a new address.  The Tx queue is maintained intact, thereby
373  * relieving the need to re-encrypt any request data that has already been
374  * buffered.
375  */
376 int rxrpc_kernel_retry_call(struct socket *sock, struct rxrpc_call *call,
377 			    struct sockaddr_rxrpc *srx, struct key *key)
378 {
379 	struct rxrpc_conn_parameters cp;
380 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
381 	int ret;
382 
383 	_enter("%d{%d}", call->debug_id, atomic_read(&call->usage));
384 
385 	if (!key)
386 		key = rx->key;
387 	if (key && !key->payload.data[0])
388 		key = NULL; /* a no-security key */
389 
390 	memset(&cp, 0, sizeof(cp));
391 	cp.local		= rx->local;
392 	cp.key			= key;
393 	cp.security_level	= 0;
394 	cp.exclusive		= false;
395 	cp.service_id		= srx->srx_service;
396 
397 	mutex_lock(&call->user_mutex);
398 
399 	ret = rxrpc_prepare_call_for_retry(rx, call);
400 	if (ret == 0)
401 		ret = rxrpc_retry_client_call(rx, call, &cp, srx, GFP_KERNEL);
402 
403 	mutex_unlock(&call->user_mutex);
404 	_leave(" = %d", ret);
405 	return ret;
406 }
407 EXPORT_SYMBOL(rxrpc_kernel_retry_call);
408 
409 /**
410  * rxrpc_kernel_new_call_notification - Get notifications of new calls
411  * @sock: The socket to intercept received messages on
412  * @notify_new_call: Function to be called when new calls appear
413  * @discard_new_call: Function to discard preallocated calls
414  *
415  * Allow a kernel service to be given notifications about new calls.
416  */
417 void rxrpc_kernel_new_call_notification(
418 	struct socket *sock,
419 	rxrpc_notify_new_call_t notify_new_call,
420 	rxrpc_discard_new_call_t discard_new_call)
421 {
422 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
423 
424 	rx->notify_new_call = notify_new_call;
425 	rx->discard_new_call = discard_new_call;
426 }
427 EXPORT_SYMBOL(rxrpc_kernel_new_call_notification);
428 
429 /*
430  * connect an RxRPC socket
431  * - this just targets it at a specific destination; no actual connection
432  *   negotiation takes place
433  */
434 static int rxrpc_connect(struct socket *sock, struct sockaddr *addr,
435 			 int addr_len, int flags)
436 {
437 	struct sockaddr_rxrpc *srx = (struct sockaddr_rxrpc *)addr;
438 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
439 	int ret;
440 
441 	_enter("%p,%p,%d,%d", rx, addr, addr_len, flags);
442 
443 	ret = rxrpc_validate_address(rx, srx, addr_len);
444 	if (ret < 0) {
445 		_leave(" = %d [bad addr]", ret);
446 		return ret;
447 	}
448 
449 	lock_sock(&rx->sk);
450 
451 	ret = -EISCONN;
452 	if (test_bit(RXRPC_SOCK_CONNECTED, &rx->flags))
453 		goto error;
454 
455 	switch (rx->sk.sk_state) {
456 	case RXRPC_UNBOUND:
457 		rx->sk.sk_state = RXRPC_CLIENT_UNBOUND;
458 	case RXRPC_CLIENT_UNBOUND:
459 	case RXRPC_CLIENT_BOUND:
460 		break;
461 	default:
462 		ret = -EBUSY;
463 		goto error;
464 	}
465 
466 	rx->connect_srx = *srx;
467 	set_bit(RXRPC_SOCK_CONNECTED, &rx->flags);
468 	ret = 0;
469 
470 error:
471 	release_sock(&rx->sk);
472 	return ret;
473 }
474 
475 /*
476  * send a message through an RxRPC socket
477  * - in a client this does a number of things:
478  *   - finds/sets up a connection for the security specified (if any)
479  *   - initiates a call (ID in control data)
480  *   - ends the request phase of a call (if MSG_MORE is not set)
481  *   - sends a call data packet
482  *   - may send an abort (abort code in control data)
483  */
484 static int rxrpc_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
485 {
486 	struct rxrpc_local *local;
487 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
488 	int ret;
489 
490 	_enter(",{%d},,%zu", rx->sk.sk_state, len);
491 
492 	if (m->msg_flags & MSG_OOB)
493 		return -EOPNOTSUPP;
494 
495 	if (m->msg_name) {
496 		ret = rxrpc_validate_address(rx, m->msg_name, m->msg_namelen);
497 		if (ret < 0) {
498 			_leave(" = %d [bad addr]", ret);
499 			return ret;
500 		}
501 	}
502 
503 	lock_sock(&rx->sk);
504 
505 	switch (rx->sk.sk_state) {
506 	case RXRPC_UNBOUND:
507 		rx->srx.srx_family = AF_RXRPC;
508 		rx->srx.srx_service = 0;
509 		rx->srx.transport_type = SOCK_DGRAM;
510 		rx->srx.transport.family = rx->family;
511 		switch (rx->family) {
512 		case AF_INET:
513 			rx->srx.transport_len = sizeof(struct sockaddr_in);
514 			break;
515 #ifdef CONFIG_AF_RXRPC_IPV6
516 		case AF_INET6:
517 			rx->srx.transport_len = sizeof(struct sockaddr_in6);
518 			break;
519 #endif
520 		default:
521 			ret = -EAFNOSUPPORT;
522 			goto error_unlock;
523 		}
524 		local = rxrpc_lookup_local(sock_net(sock->sk), &rx->srx);
525 		if (IS_ERR(local)) {
526 			ret = PTR_ERR(local);
527 			goto error_unlock;
528 		}
529 
530 		rx->local = local;
531 		rx->sk.sk_state = RXRPC_CLIENT_UNBOUND;
532 		/* Fall through */
533 
534 	case RXRPC_CLIENT_UNBOUND:
535 	case RXRPC_CLIENT_BOUND:
536 		if (!m->msg_name &&
537 		    test_bit(RXRPC_SOCK_CONNECTED, &rx->flags)) {
538 			m->msg_name = &rx->connect_srx;
539 			m->msg_namelen = sizeof(rx->connect_srx);
540 		}
541 	case RXRPC_SERVER_BOUND:
542 	case RXRPC_SERVER_LISTENING:
543 		ret = rxrpc_do_sendmsg(rx, m, len);
544 		/* The socket has been unlocked */
545 		goto out;
546 	default:
547 		ret = -EINVAL;
548 		goto error_unlock;
549 	}
550 
551 error_unlock:
552 	release_sock(&rx->sk);
553 out:
554 	_leave(" = %d", ret);
555 	return ret;
556 }
557 
558 /*
559  * set RxRPC socket options
560  */
561 static int rxrpc_setsockopt(struct socket *sock, int level, int optname,
562 			    char __user *optval, unsigned int optlen)
563 {
564 	struct rxrpc_sock *rx = rxrpc_sk(sock->sk);
565 	unsigned int min_sec_level;
566 	u16 service_upgrade[2];
567 	int ret;
568 
569 	_enter(",%d,%d,,%d", level, optname, optlen);
570 
571 	lock_sock(&rx->sk);
572 	ret = -EOPNOTSUPP;
573 
574 	if (level == SOL_RXRPC) {
575 		switch (optname) {
576 		case RXRPC_EXCLUSIVE_CONNECTION:
577 			ret = -EINVAL;
578 			if (optlen != 0)
579 				goto error;
580 			ret = -EISCONN;
581 			if (rx->sk.sk_state != RXRPC_UNBOUND)
582 				goto error;
583 			rx->exclusive = true;
584 			goto success;
585 
586 		case RXRPC_SECURITY_KEY:
587 			ret = -EINVAL;
588 			if (rx->key)
589 				goto error;
590 			ret = -EISCONN;
591 			if (rx->sk.sk_state != RXRPC_UNBOUND)
592 				goto error;
593 			ret = rxrpc_request_key(rx, optval, optlen);
594 			goto error;
595 
596 		case RXRPC_SECURITY_KEYRING:
597 			ret = -EINVAL;
598 			if (rx->key)
599 				goto error;
600 			ret = -EISCONN;
601 			if (rx->sk.sk_state != RXRPC_UNBOUND)
602 				goto error;
603 			ret = rxrpc_server_keyring(rx, optval, optlen);
604 			goto error;
605 
606 		case RXRPC_MIN_SECURITY_LEVEL:
607 			ret = -EINVAL;
608 			if (optlen != sizeof(unsigned int))
609 				goto error;
610 			ret = -EISCONN;
611 			if (rx->sk.sk_state != RXRPC_UNBOUND)
612 				goto error;
613 			ret = get_user(min_sec_level,
614 				       (unsigned int __user *) optval);
615 			if (ret < 0)
616 				goto error;
617 			ret = -EINVAL;
618 			if (min_sec_level > RXRPC_SECURITY_MAX)
619 				goto error;
620 			rx->min_sec_level = min_sec_level;
621 			goto success;
622 
623 		case RXRPC_UPGRADEABLE_SERVICE:
624 			ret = -EINVAL;
625 			if (optlen != sizeof(service_upgrade) ||
626 			    rx->service_upgrade.from != 0)
627 				goto error;
628 			ret = -EISCONN;
629 			if (rx->sk.sk_state != RXRPC_SERVER_BOUND2)
630 				goto error;
631 			ret = -EFAULT;
632 			if (copy_from_user(service_upgrade, optval,
633 					   sizeof(service_upgrade)) != 0)
634 				goto error;
635 			ret = -EINVAL;
636 			if ((service_upgrade[0] != rx->srx.srx_service ||
637 			     service_upgrade[1] != rx->second_service) &&
638 			    (service_upgrade[0] != rx->second_service ||
639 			     service_upgrade[1] != rx->srx.srx_service))
640 				goto error;
641 			rx->service_upgrade.from = service_upgrade[0];
642 			rx->service_upgrade.to = service_upgrade[1];
643 			goto success;
644 
645 		default:
646 			break;
647 		}
648 	}
649 
650 success:
651 	ret = 0;
652 error:
653 	release_sock(&rx->sk);
654 	return ret;
655 }
656 
657 /*
658  * Get socket options.
659  */
660 static int rxrpc_getsockopt(struct socket *sock, int level, int optname,
661 			    char __user *optval, int __user *_optlen)
662 {
663 	int optlen;
664 
665 	if (level != SOL_RXRPC)
666 		return -EOPNOTSUPP;
667 
668 	if (get_user(optlen, _optlen))
669 		return -EFAULT;
670 
671 	switch (optname) {
672 	case RXRPC_SUPPORTED_CMSG:
673 		if (optlen < sizeof(int))
674 			return -ETOOSMALL;
675 		if (put_user(RXRPC__SUPPORTED - 1, (int __user *)optval) ||
676 		    put_user(sizeof(int), _optlen))
677 			return -EFAULT;
678 		return 0;
679 
680 	default:
681 		return -EOPNOTSUPP;
682 	}
683 }
684 
685 /*
686  * permit an RxRPC socket to be polled
687  */
688 static unsigned int rxrpc_poll(struct file *file, struct socket *sock,
689 			       poll_table *wait)
690 {
691 	struct sock *sk = sock->sk;
692 	struct rxrpc_sock *rx = rxrpc_sk(sk);
693 	unsigned int mask;
694 
695 	sock_poll_wait(file, sk_sleep(sk), wait);
696 	mask = 0;
697 
698 	/* the socket is readable if there are any messages waiting on the Rx
699 	 * queue */
700 	if (!list_empty(&rx->recvmsg_q))
701 		mask |= POLLIN | POLLRDNORM;
702 
703 	/* the socket is writable if there is space to add new data to the
704 	 * socket; there is no guarantee that any particular call in progress
705 	 * on the socket may have space in the Tx ACK window */
706 	if (rxrpc_writable(sk))
707 		mask |= POLLOUT | POLLWRNORM;
708 
709 	return mask;
710 }
711 
712 /*
713  * create an RxRPC socket
714  */
715 static int rxrpc_create(struct net *net, struct socket *sock, int protocol,
716 			int kern)
717 {
718 	struct rxrpc_sock *rx;
719 	struct sock *sk;
720 
721 	_enter("%p,%d", sock, protocol);
722 
723 	/* we support transport protocol UDP/UDP6 only */
724 	if (protocol != PF_INET &&
725 	    IS_ENABLED(CONFIG_AF_RXRPC_IPV6) && protocol != PF_INET6)
726 		return -EPROTONOSUPPORT;
727 
728 	if (sock->type != SOCK_DGRAM)
729 		return -ESOCKTNOSUPPORT;
730 
731 	sock->ops = &rxrpc_rpc_ops;
732 	sock->state = SS_UNCONNECTED;
733 
734 	sk = sk_alloc(net, PF_RXRPC, GFP_KERNEL, &rxrpc_proto, kern);
735 	if (!sk)
736 		return -ENOMEM;
737 
738 	sock_init_data(sock, sk);
739 	sock_set_flag(sk, SOCK_RCU_FREE);
740 	sk->sk_state		= RXRPC_UNBOUND;
741 	sk->sk_write_space	= rxrpc_write_space;
742 	sk->sk_max_ack_backlog	= 0;
743 	sk->sk_destruct		= rxrpc_sock_destructor;
744 
745 	rx = rxrpc_sk(sk);
746 	rx->family = protocol;
747 	rx->calls = RB_ROOT;
748 
749 	spin_lock_init(&rx->incoming_lock);
750 	INIT_LIST_HEAD(&rx->sock_calls);
751 	INIT_LIST_HEAD(&rx->to_be_accepted);
752 	INIT_LIST_HEAD(&rx->recvmsg_q);
753 	rwlock_init(&rx->recvmsg_lock);
754 	rwlock_init(&rx->call_lock);
755 	memset(&rx->srx, 0, sizeof(rx->srx));
756 
757 	_leave(" = 0 [%p]", rx);
758 	return 0;
759 }
760 
761 /*
762  * Kill all the calls on a socket and shut it down.
763  */
764 static int rxrpc_shutdown(struct socket *sock, int flags)
765 {
766 	struct sock *sk = sock->sk;
767 	struct rxrpc_sock *rx = rxrpc_sk(sk);
768 	int ret = 0;
769 
770 	_enter("%p,%d", sk, flags);
771 
772 	if (flags != SHUT_RDWR)
773 		return -EOPNOTSUPP;
774 	if (sk->sk_state == RXRPC_CLOSE)
775 		return -ESHUTDOWN;
776 
777 	lock_sock(sk);
778 
779 	spin_lock_bh(&sk->sk_receive_queue.lock);
780 	if (sk->sk_state < RXRPC_CLOSE) {
781 		sk->sk_state = RXRPC_CLOSE;
782 		sk->sk_shutdown = SHUTDOWN_MASK;
783 	} else {
784 		ret = -ESHUTDOWN;
785 	}
786 	spin_unlock_bh(&sk->sk_receive_queue.lock);
787 
788 	rxrpc_discard_prealloc(rx);
789 
790 	release_sock(sk);
791 	return ret;
792 }
793 
794 /*
795  * RxRPC socket destructor
796  */
797 static void rxrpc_sock_destructor(struct sock *sk)
798 {
799 	_enter("%p", sk);
800 
801 	rxrpc_purge_queue(&sk->sk_receive_queue);
802 
803 	WARN_ON(refcount_read(&sk->sk_wmem_alloc));
804 	WARN_ON(!sk_unhashed(sk));
805 	WARN_ON(sk->sk_socket);
806 
807 	if (!sock_flag(sk, SOCK_DEAD)) {
808 		printk("Attempt to release alive rxrpc socket: %p\n", sk);
809 		return;
810 	}
811 }
812 
813 /*
814  * release an RxRPC socket
815  */
816 static int rxrpc_release_sock(struct sock *sk)
817 {
818 	struct rxrpc_sock *rx = rxrpc_sk(sk);
819 
820 	_enter("%p{%d,%d}", sk, sk->sk_state, refcount_read(&sk->sk_refcnt));
821 
822 	/* declare the socket closed for business */
823 	sock_orphan(sk);
824 	sk->sk_shutdown = SHUTDOWN_MASK;
825 
826 	spin_lock_bh(&sk->sk_receive_queue.lock);
827 	sk->sk_state = RXRPC_CLOSE;
828 	spin_unlock_bh(&sk->sk_receive_queue.lock);
829 
830 	if (rx->local && rcu_access_pointer(rx->local->service) == rx) {
831 		write_lock(&rx->local->services_lock);
832 		rcu_assign_pointer(rx->local->service, NULL);
833 		write_unlock(&rx->local->services_lock);
834 	}
835 
836 	/* try to flush out this socket */
837 	rxrpc_discard_prealloc(rx);
838 	rxrpc_release_calls_on_socket(rx);
839 	flush_workqueue(rxrpc_workqueue);
840 	rxrpc_purge_queue(&sk->sk_receive_queue);
841 
842 	rxrpc_put_local(rx->local);
843 	rx->local = NULL;
844 	key_put(rx->key);
845 	rx->key = NULL;
846 	key_put(rx->securities);
847 	rx->securities = NULL;
848 	sock_put(sk);
849 
850 	_leave(" = 0");
851 	return 0;
852 }
853 
854 /*
855  * release an RxRPC BSD socket on close() or equivalent
856  */
857 static int rxrpc_release(struct socket *sock)
858 {
859 	struct sock *sk = sock->sk;
860 
861 	_enter("%p{%p}", sock, sk);
862 
863 	if (!sk)
864 		return 0;
865 
866 	sock->sk = NULL;
867 
868 	return rxrpc_release_sock(sk);
869 }
870 
871 /*
872  * RxRPC network protocol
873  */
874 static const struct proto_ops rxrpc_rpc_ops = {
875 	.family		= PF_RXRPC,
876 	.owner		= THIS_MODULE,
877 	.release	= rxrpc_release,
878 	.bind		= rxrpc_bind,
879 	.connect	= rxrpc_connect,
880 	.socketpair	= sock_no_socketpair,
881 	.accept		= sock_no_accept,
882 	.getname	= sock_no_getname,
883 	.poll		= rxrpc_poll,
884 	.ioctl		= sock_no_ioctl,
885 	.listen		= rxrpc_listen,
886 	.shutdown	= rxrpc_shutdown,
887 	.setsockopt	= rxrpc_setsockopt,
888 	.getsockopt	= rxrpc_getsockopt,
889 	.sendmsg	= rxrpc_sendmsg,
890 	.recvmsg	= rxrpc_recvmsg,
891 	.mmap		= sock_no_mmap,
892 	.sendpage	= sock_no_sendpage,
893 };
894 
895 static struct proto rxrpc_proto = {
896 	.name		= "RXRPC",
897 	.owner		= THIS_MODULE,
898 	.obj_size	= sizeof(struct rxrpc_sock),
899 	.max_header	= sizeof(struct rxrpc_wire_header),
900 };
901 
902 static const struct net_proto_family rxrpc_family_ops = {
903 	.family	= PF_RXRPC,
904 	.create = rxrpc_create,
905 	.owner	= THIS_MODULE,
906 };
907 
908 /*
909  * initialise and register the RxRPC protocol
910  */
911 static int __init af_rxrpc_init(void)
912 {
913 	int ret = -1;
914 	unsigned int tmp;
915 
916 	BUILD_BUG_ON(sizeof(struct rxrpc_skb_priv) > FIELD_SIZEOF(struct sk_buff, cb));
917 
918 	get_random_bytes(&tmp, sizeof(tmp));
919 	tmp &= 0x3fffffff;
920 	if (tmp == 0)
921 		tmp = 1;
922 	idr_set_cursor(&rxrpc_client_conn_ids, tmp);
923 
924 	ret = -ENOMEM;
925 	rxrpc_call_jar = kmem_cache_create(
926 		"rxrpc_call_jar", sizeof(struct rxrpc_call), 0,
927 		SLAB_HWCACHE_ALIGN, NULL);
928 	if (!rxrpc_call_jar) {
929 		pr_notice("Failed to allocate call jar\n");
930 		goto error_call_jar;
931 	}
932 
933 	rxrpc_workqueue = alloc_workqueue("krxrpcd", 0, 1);
934 	if (!rxrpc_workqueue) {
935 		pr_notice("Failed to allocate work queue\n");
936 		goto error_work_queue;
937 	}
938 
939 	ret = rxrpc_init_security();
940 	if (ret < 0) {
941 		pr_crit("Cannot initialise security\n");
942 		goto error_security;
943 	}
944 
945 	ret = register_pernet_subsys(&rxrpc_net_ops);
946 	if (ret)
947 		goto error_pernet;
948 
949 	ret = proto_register(&rxrpc_proto, 1);
950 	if (ret < 0) {
951 		pr_crit("Cannot register protocol\n");
952 		goto error_proto;
953 	}
954 
955 	ret = sock_register(&rxrpc_family_ops);
956 	if (ret < 0) {
957 		pr_crit("Cannot register socket family\n");
958 		goto error_sock;
959 	}
960 
961 	ret = register_key_type(&key_type_rxrpc);
962 	if (ret < 0) {
963 		pr_crit("Cannot register client key type\n");
964 		goto error_key_type;
965 	}
966 
967 	ret = register_key_type(&key_type_rxrpc_s);
968 	if (ret < 0) {
969 		pr_crit("Cannot register server key type\n");
970 		goto error_key_type_s;
971 	}
972 
973 	ret = rxrpc_sysctl_init();
974 	if (ret < 0) {
975 		pr_crit("Cannot register sysctls\n");
976 		goto error_sysctls;
977 	}
978 
979 	return 0;
980 
981 error_sysctls:
982 	unregister_key_type(&key_type_rxrpc_s);
983 error_key_type_s:
984 	unregister_key_type(&key_type_rxrpc);
985 error_key_type:
986 	sock_unregister(PF_RXRPC);
987 error_sock:
988 	proto_unregister(&rxrpc_proto);
989 error_proto:
990 	unregister_pernet_subsys(&rxrpc_net_ops);
991 error_pernet:
992 	rxrpc_exit_security();
993 error_security:
994 	destroy_workqueue(rxrpc_workqueue);
995 error_work_queue:
996 	kmem_cache_destroy(rxrpc_call_jar);
997 error_call_jar:
998 	return ret;
999 }
1000 
1001 /*
1002  * unregister the RxRPC protocol
1003  */
1004 static void __exit af_rxrpc_exit(void)
1005 {
1006 	_enter("");
1007 	rxrpc_sysctl_exit();
1008 	unregister_key_type(&key_type_rxrpc_s);
1009 	unregister_key_type(&key_type_rxrpc);
1010 	sock_unregister(PF_RXRPC);
1011 	proto_unregister(&rxrpc_proto);
1012 	unregister_pernet_subsys(&rxrpc_net_ops);
1013 	ASSERTCMP(atomic_read(&rxrpc_n_tx_skbs), ==, 0);
1014 	ASSERTCMP(atomic_read(&rxrpc_n_rx_skbs), ==, 0);
1015 
1016 	/* Make sure the local and peer records pinned by any dying connections
1017 	 * are released.
1018 	 */
1019 	rcu_barrier();
1020 	rxrpc_destroy_client_conn_ids();
1021 
1022 	destroy_workqueue(rxrpc_workqueue);
1023 	rxrpc_exit_security();
1024 	kmem_cache_destroy(rxrpc_call_jar);
1025 	_leave("");
1026 }
1027 
1028 module_init(af_rxrpc_init);
1029 module_exit(af_rxrpc_exit);
1030