net/atm: move all compat_ioctl handling to atm/ioctl.c
[linux-2.6.git] / net / atm / mpoa_caches.c
1 #include <linux/types.h>
2 #include <linux/atmmpc.h>
3 #include <linux/time.h>
4
5 #include "mpoa_caches.h"
6 #include "mpc.h"
7
8 /*
9  * mpoa_caches.c: Implementation of ingress and egress cache
10  * handling functions
11  */
12
13 #if 0
14 #define dprintk printk    /* debug */
15 #else
16 #define dprintk(format,args...)
17 #endif
18
19 #if 0
20 #define ddprintk printk  /* more debug */
21 #else
22 #define ddprintk(format,args...)
23 #endif
24
25 static in_cache_entry *in_cache_get(__be32 dst_ip,
26                                     struct mpoa_client *client)
27 {
28         in_cache_entry *entry;
29
30         read_lock_bh(&client->ingress_lock);
31         entry = client->in_cache;
32         while(entry != NULL){
33                 if( entry->ctrl_info.in_dst_ip == dst_ip ){
34                         atomic_inc(&entry->use);
35                         read_unlock_bh(&client->ingress_lock);
36                         return entry;
37                 }
38                 entry = entry->next;
39         }
40         read_unlock_bh(&client->ingress_lock);
41
42         return NULL;
43 }
44
45 static in_cache_entry *in_cache_get_with_mask(__be32 dst_ip,
46                                               struct mpoa_client *client,
47                                               __be32 mask)
48 {
49         in_cache_entry *entry;
50
51         read_lock_bh(&client->ingress_lock);
52         entry = client->in_cache;
53         while(entry != NULL){
54                 if((entry->ctrl_info.in_dst_ip & mask)  == (dst_ip & mask )){
55                         atomic_inc(&entry->use);
56                         read_unlock_bh(&client->ingress_lock);
57                         return entry;
58                 }
59                 entry = entry->next;
60         }
61         read_unlock_bh(&client->ingress_lock);
62
63         return NULL;
64
65 }
66
67 static in_cache_entry *in_cache_get_by_vcc(struct atm_vcc *vcc,
68                                            struct mpoa_client *client )
69 {
70         in_cache_entry *entry;
71
72         read_lock_bh(&client->ingress_lock);
73         entry = client->in_cache;
74         while(entry != NULL){
75                 if(entry->shortcut == vcc) {
76                         atomic_inc(&entry->use);
77                         read_unlock_bh(&client->ingress_lock);
78                         return entry;
79                 }
80                 entry = entry->next;
81         }
82         read_unlock_bh(&client->ingress_lock);
83
84         return NULL;
85 }
86
87 static in_cache_entry *in_cache_add_entry(__be32 dst_ip,
88                                           struct mpoa_client *client)
89 {
90         in_cache_entry *entry = kzalloc(sizeof(in_cache_entry), GFP_KERNEL);
91
92         if (entry == NULL) {
93                 printk("mpoa: mpoa_caches.c: new_in_cache_entry: out of memory\n");
94                 return NULL;
95         }
96
97         dprintk("mpoa: mpoa_caches.c: adding an ingress entry, ip = %pI4\n", &dst_ip);
98
99         atomic_set(&entry->use, 1);
100         dprintk("mpoa: mpoa_caches.c: new_in_cache_entry: about to lock\n");
101         write_lock_bh(&client->ingress_lock);
102         entry->next = client->in_cache;
103         entry->prev = NULL;
104         if (client->in_cache != NULL)
105                 client->in_cache->prev = entry;
106         client->in_cache = entry;
107
108         memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN);
109         entry->ctrl_info.in_dst_ip = dst_ip;
110         do_gettimeofday(&(entry->tv));
111         entry->retry_time = client->parameters.mpc_p4;
112         entry->count = 1;
113         entry->entry_state = INGRESS_INVALID;
114         entry->ctrl_info.holding_time = HOLDING_TIME_DEFAULT;
115         atomic_inc(&entry->use);
116
117         write_unlock_bh(&client->ingress_lock);
118         dprintk("mpoa: mpoa_caches.c: new_in_cache_entry: unlocked\n");
119
120         return entry;
121 }
122
123 static int cache_hit(in_cache_entry *entry, struct mpoa_client *mpc)
124 {
125         struct atm_mpoa_qos *qos;
126         struct k_message msg;
127
128         entry->count++;
129         if(entry->entry_state == INGRESS_RESOLVED && entry->shortcut != NULL)
130                 return OPEN;
131
132         if(entry->entry_state == INGRESS_REFRESHING){
133                 if(entry->count > mpc->parameters.mpc_p1){
134                         msg.type = SND_MPOA_RES_RQST;
135                         msg.content.in_info = entry->ctrl_info;
136                         memcpy(msg.MPS_ctrl, mpc->mps_ctrl_addr, ATM_ESA_LEN);
137                         qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
138                         if (qos != NULL) msg.qos = qos->qos;
139                         msg_to_mpoad(&msg, mpc);
140                         do_gettimeofday(&(entry->reply_wait));
141                         entry->entry_state = INGRESS_RESOLVING;
142                 }
143                 if(entry->shortcut != NULL)
144                         return OPEN;
145                 return CLOSED;
146         }
147
148         if(entry->entry_state == INGRESS_RESOLVING && entry->shortcut != NULL)
149                 return OPEN;
150
151         if( entry->count > mpc->parameters.mpc_p1 &&
152             entry->entry_state == INGRESS_INVALID){
153                 dprintk("mpoa: (%s) mpoa_caches.c: threshold exceeded for ip %pI4, sending MPOA res req\n",
154                         mpc->dev->name, &entry->ctrl_info.in_dst_ip);
155                 entry->entry_state = INGRESS_RESOLVING;
156                 msg.type =  SND_MPOA_RES_RQST;
157                 memcpy(msg.MPS_ctrl, mpc->mps_ctrl_addr, ATM_ESA_LEN );
158                 msg.content.in_info = entry->ctrl_info;
159                 qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
160                 if (qos != NULL) msg.qos = qos->qos;
161                 msg_to_mpoad( &msg, mpc);
162                 do_gettimeofday(&(entry->reply_wait));
163         }
164
165         return CLOSED;
166 }
167
168 static void in_cache_put(in_cache_entry *entry)
169 {
170         if (atomic_dec_and_test(&entry->use)) {
171                 memset(entry, 0, sizeof(in_cache_entry));
172                 kfree(entry);
173         }
174
175         return;
176 }
177
178 /*
179  * This should be called with write lock on
180  */
181 static void in_cache_remove_entry(in_cache_entry *entry,
182                                   struct mpoa_client *client)
183 {
184         struct atm_vcc *vcc;
185         struct k_message msg;
186
187         vcc = entry->shortcut;
188         dprintk("mpoa: mpoa_caches.c: removing an ingress entry, ip = %pI4\n",
189                 &entry->ctrl_info.in_dst_ip);
190
191         if (entry->prev != NULL)
192                 entry->prev->next = entry->next;
193         else
194                 client->in_cache = entry->next;
195         if (entry->next != NULL)
196                 entry->next->prev = entry->prev;
197         client->in_ops->put(entry);
198         if(client->in_cache == NULL && client->eg_cache == NULL){
199                 msg.type = STOP_KEEP_ALIVE_SM;
200                 msg_to_mpoad(&msg,client);
201         }
202
203         /* Check if the egress side still uses this VCC */
204         if (vcc != NULL) {
205                 eg_cache_entry *eg_entry = client->eg_ops->get_by_vcc(vcc, client);
206                 if (eg_entry != NULL) {
207                         client->eg_ops->put(eg_entry);
208                         return;
209                 }
210                 vcc_release_async(vcc, -EPIPE);
211         }
212
213         return;
214 }
215
216
217 /* Call this every MPC-p2 seconds... Not exactly correct solution,
218    but an easy one... */
219 static void clear_count_and_expired(struct mpoa_client *client)
220 {
221         in_cache_entry *entry, *next_entry;
222         struct timeval now;
223
224         do_gettimeofday(&now);
225
226         write_lock_bh(&client->ingress_lock);
227         entry = client->in_cache;
228         while(entry != NULL){
229                 entry->count=0;
230                 next_entry = entry->next;
231                 if((now.tv_sec - entry->tv.tv_sec)
232                    > entry->ctrl_info.holding_time){
233                         dprintk("mpoa: mpoa_caches.c: holding time expired, ip = %pI4\n",
234                                 &entry->ctrl_info.in_dst_ip);
235                         client->in_ops->remove_entry(entry, client);
236                 }
237                 entry = next_entry;
238         }
239         write_unlock_bh(&client->ingress_lock);
240
241         return;
242 }
243
244 /* Call this every MPC-p4 seconds. */
245 static void check_resolving_entries(struct mpoa_client *client)
246 {
247
248         struct atm_mpoa_qos *qos;
249         in_cache_entry *entry;
250         struct timeval now;
251         struct k_message msg;
252
253         do_gettimeofday( &now );
254
255         read_lock_bh(&client->ingress_lock);
256         entry = client->in_cache;
257         while( entry != NULL ){
258                 if(entry->entry_state == INGRESS_RESOLVING){
259                         if(now.tv_sec - entry->hold_down.tv_sec < client->parameters.mpc_p6){
260                                 entry = entry->next;                      /* Entry in hold down */
261                                 continue;
262                         }
263                         if( (now.tv_sec - entry->reply_wait.tv_sec) >
264                             entry->retry_time ){
265                                 entry->retry_time = MPC_C1*( entry->retry_time );
266                                 if(entry->retry_time > client->parameters.mpc_p5){
267                                         /* Retry time maximum exceeded, put entry in hold down. */
268                                         do_gettimeofday(&(entry->hold_down));
269                                         entry->retry_time = client->parameters.mpc_p4;
270                                         entry = entry->next;
271                                         continue;
272                                 }
273                                 /* Ask daemon to send a resolution request. */
274                                 memset(&(entry->hold_down),0,sizeof(struct timeval));
275                                 msg.type = SND_MPOA_RES_RTRY;
276                                 memcpy(msg.MPS_ctrl, client->mps_ctrl_addr, ATM_ESA_LEN);
277                                 msg.content.in_info = entry->ctrl_info;
278                                 qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
279                                 if (qos != NULL) msg.qos = qos->qos;
280                                 msg_to_mpoad(&msg, client);
281                                 do_gettimeofday(&(entry->reply_wait));
282                         }
283                 }
284                 entry = entry->next;
285         }
286         read_unlock_bh(&client->ingress_lock);
287 }
288
289 /* Call this every MPC-p5 seconds. */
290 static void refresh_entries(struct mpoa_client *client)
291 {
292         struct timeval now;
293         struct in_cache_entry *entry = client->in_cache;
294
295         ddprintk("mpoa: mpoa_caches.c: refresh_entries\n");
296         do_gettimeofday(&now);
297
298         read_lock_bh(&client->ingress_lock);
299         while( entry != NULL ){
300                 if( entry->entry_state == INGRESS_RESOLVED ){
301                         if(!(entry->refresh_time))
302                                 entry->refresh_time = (2*(entry->ctrl_info.holding_time))/3;
303                         if( (now.tv_sec - entry->reply_wait.tv_sec) > entry->refresh_time ){
304                                 dprintk("mpoa: mpoa_caches.c: refreshing an entry.\n");
305                                 entry->entry_state = INGRESS_REFRESHING;
306
307                         }
308                 }
309                 entry = entry->next;
310         }
311         read_unlock_bh(&client->ingress_lock);
312 }
313
314 static void in_destroy_cache(struct mpoa_client *mpc)
315 {
316         write_lock_irq(&mpc->ingress_lock);
317         while(mpc->in_cache != NULL)
318                 mpc->in_ops->remove_entry(mpc->in_cache, mpc);
319         write_unlock_irq(&mpc->ingress_lock);
320
321         return;
322 }
323
324 static eg_cache_entry *eg_cache_get_by_cache_id(__be32 cache_id, struct mpoa_client *mpc)
325 {
326         eg_cache_entry *entry;
327
328         read_lock_irq(&mpc->egress_lock);
329         entry = mpc->eg_cache;
330         while(entry != NULL){
331                 if(entry->ctrl_info.cache_id == cache_id){
332                         atomic_inc(&entry->use);
333                         read_unlock_irq(&mpc->egress_lock);
334                         return entry;
335                 }
336                 entry = entry->next;
337         }
338         read_unlock_irq(&mpc->egress_lock);
339
340         return NULL;
341 }
342
343 /* This can be called from any context since it saves CPU flags */
344 static eg_cache_entry *eg_cache_get_by_tag(__be32 tag, struct mpoa_client *mpc)
345 {
346         unsigned long flags;
347         eg_cache_entry *entry;
348
349         read_lock_irqsave(&mpc->egress_lock, flags);
350         entry = mpc->eg_cache;
351         while (entry != NULL){
352                 if (entry->ctrl_info.tag == tag) {
353                         atomic_inc(&entry->use);
354                         read_unlock_irqrestore(&mpc->egress_lock, flags);
355                         return entry;
356                 }
357                 entry = entry->next;
358         }
359         read_unlock_irqrestore(&mpc->egress_lock, flags);
360
361         return NULL;
362 }
363
364 /* This can be called from any context since it saves CPU flags */
365 static eg_cache_entry *eg_cache_get_by_vcc(struct atm_vcc *vcc, struct mpoa_client *mpc)
366 {
367         unsigned long flags;
368         eg_cache_entry *entry;
369
370         read_lock_irqsave(&mpc->egress_lock, flags);
371         entry = mpc->eg_cache;
372         while (entry != NULL){
373                 if (entry->shortcut == vcc) {
374                         atomic_inc(&entry->use);
375                         read_unlock_irqrestore(&mpc->egress_lock, flags);
376                         return entry;
377                 }
378                 entry = entry->next;
379         }
380         read_unlock_irqrestore(&mpc->egress_lock, flags);
381
382         return NULL;
383 }
384
385 static eg_cache_entry *eg_cache_get_by_src_ip(__be32 ipaddr, struct mpoa_client *mpc)
386 {
387         eg_cache_entry *entry;
388
389         read_lock_irq(&mpc->egress_lock);
390         entry = mpc->eg_cache;
391         while(entry != NULL){
392                 if(entry->latest_ip_addr == ipaddr) {
393                         atomic_inc(&entry->use);
394                         read_unlock_irq(&mpc->egress_lock);
395                         return entry;
396                 }
397                 entry = entry->next;
398         }
399         read_unlock_irq(&mpc->egress_lock);
400
401         return NULL;
402 }
403
404 static void eg_cache_put(eg_cache_entry *entry)
405 {
406         if (atomic_dec_and_test(&entry->use)) {
407                 memset(entry, 0, sizeof(eg_cache_entry));
408                 kfree(entry);
409         }
410
411         return;
412 }
413
414 /*
415  * This should be called with write lock on
416  */
417 static void eg_cache_remove_entry(eg_cache_entry *entry,
418                                   struct mpoa_client *client)
419 {
420         struct atm_vcc *vcc;
421         struct k_message msg;
422
423         vcc = entry->shortcut;
424         dprintk("mpoa: mpoa_caches.c: removing an egress entry.\n");
425         if (entry->prev != NULL)
426                 entry->prev->next = entry->next;
427         else
428                 client->eg_cache = entry->next;
429         if (entry->next != NULL)
430                 entry->next->prev = entry->prev;
431         client->eg_ops->put(entry);
432         if(client->in_cache == NULL && client->eg_cache == NULL){
433                 msg.type = STOP_KEEP_ALIVE_SM;
434                 msg_to_mpoad(&msg,client);
435         }
436
437         /* Check if the ingress side still uses this VCC */
438         if (vcc != NULL) {
439                 in_cache_entry *in_entry = client->in_ops->get_by_vcc(vcc, client);
440                 if (in_entry != NULL) {
441                         client->in_ops->put(in_entry);
442                         return;
443                 }
444                 vcc_release_async(vcc, -EPIPE);
445         }
446
447         return;
448 }
449
450 static eg_cache_entry *eg_cache_add_entry(struct k_message *msg, struct mpoa_client *client)
451 {
452         eg_cache_entry *entry = kzalloc(sizeof(eg_cache_entry), GFP_KERNEL);
453
454         if (entry == NULL) {
455                 printk("mpoa: mpoa_caches.c: new_eg_cache_entry: out of memory\n");
456                 return NULL;
457         }
458
459         dprintk("mpoa: mpoa_caches.c: adding an egress entry, ip = %pI4, this should be our IP\n",
460                 &msg->content.eg_info.eg_dst_ip);
461
462         atomic_set(&entry->use, 1);
463         dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry: about to lock\n");
464         write_lock_irq(&client->egress_lock);
465         entry->next = client->eg_cache;
466         entry->prev = NULL;
467         if (client->eg_cache != NULL)
468                 client->eg_cache->prev = entry;
469         client->eg_cache = entry;
470
471         memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN);
472         entry->ctrl_info = msg->content.eg_info;
473         do_gettimeofday(&(entry->tv));
474         entry->entry_state = EGRESS_RESOLVED;
475         dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry cache_id %lu\n", ntohl(entry->ctrl_info.cache_id));
476         dprintk("mpoa: mpoa_caches.c: mps_ip = %pI4\n",
477                 &entry->ctrl_info.mps_ip);
478         atomic_inc(&entry->use);
479
480         write_unlock_irq(&client->egress_lock);
481         dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry: unlocked\n");
482
483         return entry;
484 }
485
486 static void update_eg_cache_entry(eg_cache_entry * entry, uint16_t holding_time)
487 {
488         do_gettimeofday(&(entry->tv));
489         entry->entry_state = EGRESS_RESOLVED;
490         entry->ctrl_info.holding_time = holding_time;
491
492         return;
493 }
494
495 static void clear_expired(struct mpoa_client *client)
496 {
497         eg_cache_entry *entry, *next_entry;
498         struct timeval now;
499         struct k_message msg;
500
501         do_gettimeofday(&now);
502
503         write_lock_irq(&client->egress_lock);
504         entry = client->eg_cache;
505         while(entry != NULL){
506                 next_entry = entry->next;
507                 if((now.tv_sec - entry->tv.tv_sec)
508                    > entry->ctrl_info.holding_time){
509                         msg.type = SND_EGRESS_PURGE;
510                         msg.content.eg_info = entry->ctrl_info;
511                         dprintk("mpoa: mpoa_caches.c: egress_cache: holding time expired, cache_id = %lu.\n",ntohl(entry->ctrl_info.cache_id));
512                         msg_to_mpoad(&msg, client);
513                         client->eg_ops->remove_entry(entry, client);
514                 }
515                 entry = next_entry;
516         }
517         write_unlock_irq(&client->egress_lock);
518
519         return;
520 }
521
522 static void eg_destroy_cache(struct mpoa_client *mpc)
523 {
524         write_lock_irq(&mpc->egress_lock);
525         while(mpc->eg_cache != NULL)
526                 mpc->eg_ops->remove_entry(mpc->eg_cache, mpc);
527         write_unlock_irq(&mpc->egress_lock);
528
529         return;
530 }
531
532
533
534 static struct in_cache_ops ingress_ops = {
535         in_cache_add_entry,               /* add_entry       */
536         in_cache_get,                     /* get             */
537         in_cache_get_with_mask,           /* get_with_mask   */
538         in_cache_get_by_vcc,              /* get_by_vcc      */
539         in_cache_put,                     /* put             */
540         in_cache_remove_entry,            /* remove_entry    */
541         cache_hit,                        /* cache_hit       */
542         clear_count_and_expired,          /* clear_count     */
543         check_resolving_entries,          /* check_resolving */
544         refresh_entries,                  /* refresh         */
545         in_destroy_cache                  /* destroy_cache   */
546 };
547
548 static struct eg_cache_ops egress_ops = {
549         eg_cache_add_entry,               /* add_entry        */
550         eg_cache_get_by_cache_id,         /* get_by_cache_id  */
551         eg_cache_get_by_tag,              /* get_by_tag       */
552         eg_cache_get_by_vcc,              /* get_by_vcc       */
553         eg_cache_get_by_src_ip,           /* get_by_src_ip    */
554         eg_cache_put,                     /* put              */
555         eg_cache_remove_entry,            /* remove_entry     */
556         update_eg_cache_entry,            /* update           */
557         clear_expired,                    /* clear_expired    */
558         eg_destroy_cache                  /* destroy_cache    */
559 };
560
561
562 void atm_mpoa_init_cache(struct mpoa_client *mpc)
563 {
564         mpc->in_ops = &ingress_ops;
565         mpc->eg_ops = &egress_ops;
566
567         return;
568 }