PageRenderTime 42ms CodeModel.GetById 22ms app.highlight 17ms RepoModel.GetById 1ms app.codeStats 0ms

/net/rxrpc/ar-local.c

http://github.com/mirrors/linux
C | 310 lines | 215 code | 54 blank | 41 comment | 20 complexity | 55e4a017d7b5a8fe61d0365c4fbe9469 MD5 | raw file
  1/* AF_RXRPC local endpoint management
  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/slab.h>
 16#include <net/sock.h>
 17#include <net/af_rxrpc.h>
 18#include "ar-internal.h"
 19
 20static LIST_HEAD(rxrpc_locals);
 21DEFINE_RWLOCK(rxrpc_local_lock);
 22static DECLARE_RWSEM(rxrpc_local_sem);
 23static DECLARE_WAIT_QUEUE_HEAD(rxrpc_local_wq);
 24
 25static void rxrpc_destroy_local(struct work_struct *work);
 26
 27/*
 28 * allocate a new local
 29 */
 30static
 31struct rxrpc_local *rxrpc_alloc_local(struct sockaddr_rxrpc *srx)
 32{
 33	struct rxrpc_local *local;
 34
 35	local = kzalloc(sizeof(struct rxrpc_local), GFP_KERNEL);
 36	if (local) {
 37		INIT_WORK(&local->destroyer, &rxrpc_destroy_local);
 38		INIT_WORK(&local->acceptor, &rxrpc_accept_incoming_calls);
 39		INIT_WORK(&local->rejecter, &rxrpc_reject_packets);
 40		INIT_LIST_HEAD(&local->services);
 41		INIT_LIST_HEAD(&local->link);
 42		init_rwsem(&local->defrag_sem);
 43		skb_queue_head_init(&local->accept_queue);
 44		skb_queue_head_init(&local->reject_queue);
 45		spin_lock_init(&local->lock);
 46		rwlock_init(&local->services_lock);
 47		atomic_set(&local->usage, 1);
 48		local->debug_id = atomic_inc_return(&rxrpc_debug_id);
 49		memcpy(&local->srx, srx, sizeof(*srx));
 50	}
 51
 52	_leave(" = %p", local);
 53	return local;
 54}
 55
 56/*
 57 * create the local socket
 58 * - must be called with rxrpc_local_sem writelocked
 59 */
 60static int rxrpc_create_local(struct rxrpc_local *local)
 61{
 62	struct sock *sock;
 63	int ret, opt;
 64
 65	_enter("%p{%d}", local, local->srx.transport_type);
 66
 67	/* create a socket to represent the local endpoint */
 68	ret = sock_create_kern(PF_INET, local->srx.transport_type, IPPROTO_UDP,
 69			       &local->socket);
 70	if (ret < 0) {
 71		_leave(" = %d [socket]", ret);
 72		return ret;
 73	}
 74
 75	/* if a local address was supplied then bind it */
 76	if (local->srx.transport_len > sizeof(sa_family_t)) {
 77		_debug("bind");
 78		ret = kernel_bind(local->socket,
 79				  (struct sockaddr *) &local->srx.transport,
 80				  local->srx.transport_len);
 81		if (ret < 0) {
 82			_debug("bind failed");
 83			goto error;
 84		}
 85	}
 86
 87	/* we want to receive ICMP errors */
 88	opt = 1;
 89	ret = kernel_setsockopt(local->socket, SOL_IP, IP_RECVERR,
 90				(char *) &opt, sizeof(opt));
 91	if (ret < 0) {
 92		_debug("setsockopt failed");
 93		goto error;
 94	}
 95
 96	/* we want to set the don't fragment bit */
 97	opt = IP_PMTUDISC_DO;
 98	ret = kernel_setsockopt(local->socket, SOL_IP, IP_MTU_DISCOVER,
 99				(char *) &opt, sizeof(opt));
100	if (ret < 0) {
101		_debug("setsockopt failed");
102		goto error;
103	}
104
105	write_lock_bh(&rxrpc_local_lock);
106	list_add(&local->link, &rxrpc_locals);
107	write_unlock_bh(&rxrpc_local_lock);
108
109	/* set the socket up */
110	sock = local->socket->sk;
111	sock->sk_user_data	= local;
112	sock->sk_data_ready	= rxrpc_data_ready;
113	sock->sk_error_report	= rxrpc_UDP_error_report;
114	_leave(" = 0");
115	return 0;
116
117error:
118	kernel_sock_shutdown(local->socket, SHUT_RDWR);
119	local->socket->sk->sk_user_data = NULL;
120	sock_release(local->socket);
121	local->socket = NULL;
122
123	_leave(" = %d", ret);
124	return ret;
125}
126
127/*
128 * create a new local endpoint using the specified UDP address
129 */
130struct rxrpc_local *rxrpc_lookup_local(struct sockaddr_rxrpc *srx)
131{
132	struct rxrpc_local *local;
133	int ret;
134
135	_enter("{%d,%u,%pI4+%hu}",
136	       srx->transport_type,
137	       srx->transport.family,
138	       &srx->transport.sin.sin_addr,
139	       ntohs(srx->transport.sin.sin_port));
140
141	down_write(&rxrpc_local_sem);
142
143	/* see if we have a suitable local local endpoint already */
144	read_lock_bh(&rxrpc_local_lock);
145
146	list_for_each_entry(local, &rxrpc_locals, link) {
147		_debug("CMP {%d,%u,%pI4+%hu}",
148		       local->srx.transport_type,
149		       local->srx.transport.family,
150		       &local->srx.transport.sin.sin_addr,
151		       ntohs(local->srx.transport.sin.sin_port));
152
153		if (local->srx.transport_type != srx->transport_type ||
154		    local->srx.transport.family != srx->transport.family)
155			continue;
156
157		switch (srx->transport.family) {
158		case AF_INET:
159			if (local->srx.transport.sin.sin_port !=
160			    srx->transport.sin.sin_port)
161				continue;
162			if (memcmp(&local->srx.transport.sin.sin_addr,
163				   &srx->transport.sin.sin_addr,
164				   sizeof(struct in_addr)) != 0)
165				continue;
166			goto found_local;
167
168		default:
169			BUG();
170		}
171	}
172
173	read_unlock_bh(&rxrpc_local_lock);
174
175	/* we didn't find one, so we need to create one */
176	local = rxrpc_alloc_local(srx);
177	if (!local) {
178		up_write(&rxrpc_local_sem);
179		return ERR_PTR(-ENOMEM);
180	}
181
182	ret = rxrpc_create_local(local);
183	if (ret < 0) {
184		up_write(&rxrpc_local_sem);
185		kfree(local);
186		_leave(" = %d", ret);
187		return ERR_PTR(ret);
188	}
189
190	up_write(&rxrpc_local_sem);
191
192	_net("LOCAL new %d {%d,%u,%pI4+%hu}",
193	     local->debug_id,
194	     local->srx.transport_type,
195	     local->srx.transport.family,
196	     &local->srx.transport.sin.sin_addr,
197	     ntohs(local->srx.transport.sin.sin_port));
198
199	_leave(" = %p [new]", local);
200	return local;
201
202found_local:
203	rxrpc_get_local(local);
204	read_unlock_bh(&rxrpc_local_lock);
205	up_write(&rxrpc_local_sem);
206
207	_net("LOCAL old %d {%d,%u,%pI4+%hu}",
208	     local->debug_id,
209	     local->srx.transport_type,
210	     local->srx.transport.family,
211	     &local->srx.transport.sin.sin_addr,
212	     ntohs(local->srx.transport.sin.sin_port));
213
214	_leave(" = %p [reuse]", local);
215	return local;
216}
217
218/*
219 * release a local endpoint
220 */
221void rxrpc_put_local(struct rxrpc_local *local)
222{
223	_enter("%p{u=%d}", local, atomic_read(&local->usage));
224
225	ASSERTCMP(atomic_read(&local->usage), >, 0);
226
227	/* to prevent a race, the decrement and the dequeue must be effectively
228	 * atomic */
229	write_lock_bh(&rxrpc_local_lock);
230	if (unlikely(atomic_dec_and_test(&local->usage))) {
231		_debug("destroy local");
232		rxrpc_queue_work(&local->destroyer);
233	}
234	write_unlock_bh(&rxrpc_local_lock);
235	_leave("");
236}
237
238/*
239 * destroy a local endpoint
240 */
241static void rxrpc_destroy_local(struct work_struct *work)
242{
243	struct rxrpc_local *local =
244		container_of(work, struct rxrpc_local, destroyer);
245
246	_enter("%p{%d}", local, atomic_read(&local->usage));
247
248	down_write(&rxrpc_local_sem);
249
250	write_lock_bh(&rxrpc_local_lock);
251	if (atomic_read(&local->usage) > 0) {
252		write_unlock_bh(&rxrpc_local_lock);
253		up_read(&rxrpc_local_sem);
254		_leave(" [resurrected]");
255		return;
256	}
257
258	list_del(&local->link);
259	local->socket->sk->sk_user_data = NULL;
260	write_unlock_bh(&rxrpc_local_lock);
261
262	downgrade_write(&rxrpc_local_sem);
263
264	ASSERT(list_empty(&local->services));
265	ASSERT(!work_pending(&local->acceptor));
266	ASSERT(!work_pending(&local->rejecter));
267
268	/* finish cleaning up the local descriptor */
269	rxrpc_purge_queue(&local->accept_queue);
270	rxrpc_purge_queue(&local->reject_queue);
271	kernel_sock_shutdown(local->socket, SHUT_RDWR);
272	sock_release(local->socket);
273
274	up_read(&rxrpc_local_sem);
275
276	_net("DESTROY LOCAL %d", local->debug_id);
277	kfree(local);
278
279	if (list_empty(&rxrpc_locals))
280		wake_up_all(&rxrpc_local_wq);
281
282	_leave("");
283}
284
285/*
286 * preemptively destroy all local local endpoint rather than waiting for
287 * them to be destroyed
288 */
289void __exit rxrpc_destroy_all_locals(void)
290{
291	DECLARE_WAITQUEUE(myself,current);
292
293	_enter("");
294
295	/* we simply have to wait for them to go away */
296	if (!list_empty(&rxrpc_locals)) {
297		set_current_state(TASK_UNINTERRUPTIBLE);
298		add_wait_queue(&rxrpc_local_wq, &myself);
299
300		while (!list_empty(&rxrpc_locals)) {
301			schedule();
302			set_current_state(TASK_UNINTERRUPTIBLE);
303		}
304
305		remove_wait_queue(&rxrpc_local_wq, &myself);
306		set_current_state(TASK_RUNNING);
307	}
308
309	_leave("");
310}