Root/
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 | |
20 | static LIST_HEAD(rxrpc_locals); |
21 | DEFINE_RWLOCK(rxrpc_local_lock); |
22 | static DECLARE_RWSEM(rxrpc_local_sem); |
23 | static DECLARE_WAIT_QUEUE_HEAD(rxrpc_local_wq); |
24 | |
25 | static void rxrpc_destroy_local(struct work_struct *work); |
26 | |
27 | /* |
28 | * allocate a new local |
29 | */ |
30 | static |
31 | struct 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 | */ |
60 | static 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 | |
117 | error: |
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 | */ |
130 | struct 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 | |
202 | found_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 | */ |
221 | void 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 | */ |
241 | static 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 | */ |
289 | void __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 | } |
311 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9