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