[PATCH] scx200_acb: Fix the state machine
[linux-3.10.git] / net / rxrpc / peer.c
1 /* peer.c: Rx RPC peer management
2  *
3  * Copyright (C) 2002 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/sched.h>
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <rxrpc/rxrpc.h>
16 #include <rxrpc/transport.h>
17 #include <rxrpc/peer.h>
18 #include <rxrpc/connection.h>
19 #include <rxrpc/call.h>
20 #include <rxrpc/message.h>
21 #include <linux/udp.h>
22 #include <linux/ip.h>
23 #include <net/sock.h>
24 #include <asm/uaccess.h>
25 #include <asm/div64.h>
26 #include "internal.h"
27
28 __RXACCT_DECL(atomic_t rxrpc_peer_count);
29 LIST_HEAD(rxrpc_peers);
30 DECLARE_RWSEM(rxrpc_peers_sem);
31 unsigned long rxrpc_peer_timeout = 12 * 60 * 60;
32
33 static void rxrpc_peer_do_timeout(struct rxrpc_peer *peer);
34
35 static void __rxrpc_peer_timeout(rxrpc_timer_t *timer)
36 {
37         struct rxrpc_peer *peer =
38                 list_entry(timer, struct rxrpc_peer, timeout);
39
40         _debug("Rx PEER TIMEOUT [%p{u=%d}]", peer, atomic_read(&peer->usage));
41
42         rxrpc_peer_do_timeout(peer);
43 }
44
45 static const struct rxrpc_timer_ops rxrpc_peer_timer_ops = {
46         .timed_out      = __rxrpc_peer_timeout,
47 };
48
49 /*****************************************************************************/
50 /*
51  * create a peer record
52  */
53 static int __rxrpc_create_peer(struct rxrpc_transport *trans, __be32 addr,
54                                struct rxrpc_peer **_peer)
55 {
56         struct rxrpc_peer *peer;
57
58         _enter("%p,%08x", trans, ntohl(addr));
59
60         /* allocate and initialise a peer record */
61         peer = kmalloc(sizeof(struct rxrpc_peer), GFP_KERNEL);
62         if (!peer) {
63                 _leave(" = -ENOMEM");
64                 return -ENOMEM;
65         }
66
67         memset(peer, 0, sizeof(struct rxrpc_peer));
68         atomic_set(&peer->usage, 1);
69
70         INIT_LIST_HEAD(&peer->link);
71         INIT_LIST_HEAD(&peer->proc_link);
72         INIT_LIST_HEAD(&peer->conn_idlist);
73         INIT_LIST_HEAD(&peer->conn_active);
74         INIT_LIST_HEAD(&peer->conn_graveyard);
75         spin_lock_init(&peer->conn_gylock);
76         init_waitqueue_head(&peer->conn_gy_waitq);
77         rwlock_init(&peer->conn_idlock);
78         rwlock_init(&peer->conn_lock);
79         atomic_set(&peer->conn_count, 0);
80         spin_lock_init(&peer->lock);
81         rxrpc_timer_init(&peer->timeout, &rxrpc_peer_timer_ops);
82
83         peer->addr.s_addr = addr;
84
85         peer->trans = trans;
86         peer->ops = trans->peer_ops;
87
88         __RXACCT(atomic_inc(&rxrpc_peer_count));
89         *_peer = peer;
90         _leave(" = 0 (%p)", peer);
91
92         return 0;
93 } /* end __rxrpc_create_peer() */
94
95 /*****************************************************************************/
96 /*
97  * find a peer record on the specified transport
98  * - returns (if successful) with peer record usage incremented
99  * - resurrects it from the graveyard if found there
100  */
101 int rxrpc_peer_lookup(struct rxrpc_transport *trans, __be32 addr,
102                       struct rxrpc_peer **_peer)
103 {
104         struct rxrpc_peer *peer, *candidate = NULL;
105         struct list_head *_p;
106         int ret;
107
108         _enter("%p{%hu},%08x", trans, trans->port, ntohl(addr));
109
110         /* [common case] search the transport's active list first */
111         read_lock(&trans->peer_lock);
112         list_for_each(_p, &trans->peer_active) {
113                 peer = list_entry(_p, struct rxrpc_peer, link);
114                 if (peer->addr.s_addr == addr)
115                         goto found_active;
116         }
117         read_unlock(&trans->peer_lock);
118
119         /* [uncommon case] not active - create a candidate for a new record */
120         ret = __rxrpc_create_peer(trans, addr, &candidate);
121         if (ret < 0) {
122                 _leave(" = %d", ret);
123                 return ret;
124         }
125
126         /* search the active list again, just in case it appeared whilst we
127          * were busy */
128         write_lock(&trans->peer_lock);
129         list_for_each(_p, &trans->peer_active) {
130                 peer = list_entry(_p, struct rxrpc_peer, link);
131                 if (peer->addr.s_addr == addr)
132                         goto found_active_second_chance;
133         }
134
135         /* search the transport's graveyard list */
136         spin_lock(&trans->peer_gylock);
137         list_for_each(_p, &trans->peer_graveyard) {
138                 peer = list_entry(_p, struct rxrpc_peer, link);
139                 if (peer->addr.s_addr == addr)
140                         goto found_in_graveyard;
141         }
142         spin_unlock(&trans->peer_gylock);
143
144         /* we can now add the new candidate to the list
145          * - tell the application layer that this peer has been added
146          */
147         rxrpc_get_transport(trans);
148         peer = candidate;
149         candidate = NULL;
150
151         if (peer->ops && peer->ops->adding) {
152                 ret = peer->ops->adding(peer);
153                 if (ret < 0) {
154                         write_unlock(&trans->peer_lock);
155                         __RXACCT(atomic_dec(&rxrpc_peer_count));
156                         kfree(peer);
157                         rxrpc_put_transport(trans);
158                         _leave(" = %d", ret);
159                         return ret;
160                 }
161         }
162
163         atomic_inc(&trans->peer_count);
164
165  make_active:
166         list_add_tail(&peer->link, &trans->peer_active);
167
168  success_uwfree:
169         write_unlock(&trans->peer_lock);
170
171         if (candidate) {
172                 __RXACCT(atomic_dec(&rxrpc_peer_count));
173                 kfree(candidate);
174         }
175
176         if (list_empty(&peer->proc_link)) {
177                 down_write(&rxrpc_peers_sem);
178                 list_add_tail(&peer->proc_link, &rxrpc_peers);
179                 up_write(&rxrpc_peers_sem);
180         }
181
182  success:
183         *_peer = peer;
184
185         _leave(" = 0 (%p{u=%d cc=%d})",
186                peer,
187                atomic_read(&peer->usage),
188                atomic_read(&peer->conn_count));
189         return 0;
190
191         /* handle the peer being found in the active list straight off */
192  found_active:
193         rxrpc_get_peer(peer);
194         read_unlock(&trans->peer_lock);
195         goto success;
196
197         /* handle resurrecting a peer from the graveyard */
198  found_in_graveyard:
199         rxrpc_get_peer(peer);
200         rxrpc_get_transport(peer->trans);
201         rxrpc_krxtimod_del_timer(&peer->timeout);
202         list_del_init(&peer->link);
203         spin_unlock(&trans->peer_gylock);
204         goto make_active;
205
206         /* handle finding the peer on the second time through the active
207          * list */
208  found_active_second_chance:
209         rxrpc_get_peer(peer);
210         goto success_uwfree;
211
212 } /* end rxrpc_peer_lookup() */
213
214 /*****************************************************************************/
215 /*
216  * finish with a peer record
217  * - it gets sent to the graveyard from where it can be resurrected or timed
218  *   out
219  */
220 void rxrpc_put_peer(struct rxrpc_peer *peer)
221 {
222         struct rxrpc_transport *trans = peer->trans;
223
224         _enter("%p{cc=%d a=%08x}",
225                peer,
226                atomic_read(&peer->conn_count),
227                ntohl(peer->addr.s_addr));
228
229         /* sanity check */
230         if (atomic_read(&peer->usage) <= 0)
231                 BUG();
232
233         write_lock(&trans->peer_lock);
234         spin_lock(&trans->peer_gylock);
235         if (likely(!atomic_dec_and_test(&peer->usage))) {
236                 spin_unlock(&trans->peer_gylock);
237                 write_unlock(&trans->peer_lock);
238                 _leave("");
239                 return;
240         }
241
242         /* move to graveyard queue */
243         list_del(&peer->link);
244         write_unlock(&trans->peer_lock);
245
246         list_add_tail(&peer->link, &trans->peer_graveyard);
247
248         BUG_ON(!list_empty(&peer->conn_active));
249
250         rxrpc_krxtimod_add_timer(&peer->timeout, rxrpc_peer_timeout * HZ);
251
252         spin_unlock(&trans->peer_gylock);
253
254         rxrpc_put_transport(trans);
255
256         _leave(" [killed]");
257 } /* end rxrpc_put_peer() */
258
259 /*****************************************************************************/
260 /*
261  * handle a peer timing out in the graveyard
262  * - called from krxtimod
263  */
264 static void rxrpc_peer_do_timeout(struct rxrpc_peer *peer)
265 {
266         struct rxrpc_transport *trans = peer->trans;
267
268         _enter("%p{u=%d cc=%d a=%08x}",
269                peer,
270                atomic_read(&peer->usage),
271                atomic_read(&peer->conn_count),
272                ntohl(peer->addr.s_addr));
273
274         BUG_ON(atomic_read(&peer->usage) < 0);
275
276         /* remove from graveyard if still dead */
277         spin_lock(&trans->peer_gylock);
278         if (atomic_read(&peer->usage) == 0)
279                 list_del_init(&peer->link);
280         else
281                 peer = NULL;
282         spin_unlock(&trans->peer_gylock);
283
284         if (!peer) {
285                 _leave("");
286                 return; /* resurrected */
287         }
288
289         /* clear all connections on this peer */
290         rxrpc_conn_clearall(peer);
291
292         BUG_ON(!list_empty(&peer->conn_active));
293         BUG_ON(!list_empty(&peer->conn_graveyard));
294
295         /* inform the application layer */
296         if (peer->ops && peer->ops->discarding)
297                 peer->ops->discarding(peer);
298
299         if (!list_empty(&peer->proc_link)) {
300                 down_write(&rxrpc_peers_sem);
301                 list_del(&peer->proc_link);
302                 up_write(&rxrpc_peers_sem);
303         }
304
305         __RXACCT(atomic_dec(&rxrpc_peer_count));
306         kfree(peer);
307
308         /* if the graveyard is now empty, wake up anyone waiting for that */
309         if (atomic_dec_and_test(&trans->peer_count))
310                 wake_up(&trans->peer_gy_waitq);
311
312         _leave(" [destroyed]");
313 } /* end rxrpc_peer_do_timeout() */
314
315 /*****************************************************************************/
316 /*
317  * clear all peer records from a transport endpoint
318  */
319 void rxrpc_peer_clearall(struct rxrpc_transport *trans)
320 {
321         DECLARE_WAITQUEUE(myself,current);
322
323         struct rxrpc_peer *peer;
324         int err;
325
326         _enter("%p",trans);
327
328         /* there shouldn't be any active peers remaining */
329         BUG_ON(!list_empty(&trans->peer_active));
330
331         /* manually timeout all peers in the graveyard */
332         spin_lock(&trans->peer_gylock);
333         while (!list_empty(&trans->peer_graveyard)) {
334                 peer = list_entry(trans->peer_graveyard.next,
335                                   struct rxrpc_peer, link);
336                 _debug("Clearing peer %p\n", peer);
337                 err = rxrpc_krxtimod_del_timer(&peer->timeout);
338                 spin_unlock(&trans->peer_gylock);
339
340                 if (err == 0)
341                         rxrpc_peer_do_timeout(peer);
342
343                 spin_lock(&trans->peer_gylock);
344         }
345         spin_unlock(&trans->peer_gylock);
346
347         /* wait for the the peer graveyard to be completely cleared */
348         set_current_state(TASK_UNINTERRUPTIBLE);
349         add_wait_queue(&trans->peer_gy_waitq, &myself);
350
351         while (atomic_read(&trans->peer_count) != 0) {
352                 schedule();
353                 set_current_state(TASK_UNINTERRUPTIBLE);
354         }
355
356         remove_wait_queue(&trans->peer_gy_waitq, &myself);
357         set_current_state(TASK_RUNNING);
358
359         _leave("");
360 } /* end rxrpc_peer_clearall() */
361
362 /*****************************************************************************/
363 /*
364  * calculate and cache the Round-Trip-Time for a message and its response
365  */
366 void rxrpc_peer_calculate_rtt(struct rxrpc_peer *peer,
367                               struct rxrpc_message *msg,
368                               struct rxrpc_message *resp)
369 {
370         unsigned long long rtt;
371         int loop;
372
373         _enter("%p,%p,%p", peer, msg, resp);
374
375         /* calculate the latest RTT */
376         rtt = resp->stamp.tv_sec - msg->stamp.tv_sec;
377         rtt *= 1000000UL;
378         rtt += resp->stamp.tv_usec - msg->stamp.tv_usec;
379
380         /* add to cache */
381         peer->rtt_cache[peer->rtt_point] = rtt;
382         peer->rtt_point++;
383         peer->rtt_point %= RXRPC_RTT_CACHE_SIZE;
384
385         if (peer->rtt_usage < RXRPC_RTT_CACHE_SIZE)
386                 peer->rtt_usage++;
387
388         /* recalculate RTT */
389         rtt = 0;
390         for (loop = peer->rtt_usage - 1; loop >= 0; loop--)
391                 rtt += peer->rtt_cache[loop];
392
393         do_div(rtt, peer->rtt_usage);
394         peer->rtt = rtt;
395
396         _leave(" RTT=%lu.%lums",
397                (long) (peer->rtt / 1000), (long) (peer->rtt % 1000));
398
399 } /* end rxrpc_peer_calculate_rtt() */