[ATM]: Use kmemdup & kzalloc where applicable
[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 = %u.%u.%u.%u\n", NIPQUAD(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 %u.%u.%u.%u, sending MPOA res req\n", mpc->dev->name, NIPQUAD(entry->ctrl_info.in_dst_ip));
154                 entry->entry_state = INGRESS_RESOLVING;
155                 msg.type =  SND_MPOA_RES_RQST;
156                 memcpy(msg.MPS_ctrl, mpc->mps_ctrl_addr, ATM_ESA_LEN );
157                 msg.content.in_info = entry->ctrl_info;
158                 qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
159                 if (qos != NULL) msg.qos = qos->qos;
160                 msg_to_mpoad( &msg, mpc);
161                 do_gettimeofday(&(entry->reply_wait));
162         }
163
164         return CLOSED;
165 }
166
167 static void in_cache_put(in_cache_entry *entry)
168 {
169         if (atomic_dec_and_test(&entry->use)) {
170                 memset(entry, 0, sizeof(in_cache_entry));
171                 kfree(entry);
172         }
173
174         return;
175 }
176
177 /*
178  * This should be called with write lock on
179  */
180 static void in_cache_remove_entry(in_cache_entry *entry,
181                                   struct mpoa_client *client)
182 {
183         struct atm_vcc *vcc;
184         struct k_message msg;
185
186         vcc = entry->shortcut;
187         dprintk("mpoa: mpoa_caches.c: removing an ingress entry, ip = %u.%u.%u.%u\n",NIPQUAD(entry->ctrl_info.in_dst_ip));
188
189         if (entry->prev != NULL)
190                 entry->prev->next = entry->next;
191         else
192                 client->in_cache = entry->next;
193         if (entry->next != NULL)
194                 entry->next->prev = entry->prev;
195         client->in_ops->put(entry);
196         if(client->in_cache == NULL && client->eg_cache == NULL){
197                 msg.type = STOP_KEEP_ALIVE_SM;
198                 msg_to_mpoad(&msg,client);
199         }
200
201         /* Check if the egress side still uses this VCC */
202         if (vcc != NULL) {
203                 eg_cache_entry *eg_entry = client->eg_ops->get_by_vcc(vcc, client);
204                 if (eg_entry != NULL) {
205                         client->eg_ops->put(eg_entry);
206                         return;
207                 }
208                 vcc_release_async(vcc, -EPIPE);
209         }
210
211         return;
212 }
213
214
215 /* Call this every MPC-p2 seconds... Not exactly correct solution,
216    but an easy one... */
217 static void clear_count_and_expired(struct mpoa_client *client)
218 {
219         in_cache_entry *entry, *next_entry;
220         struct timeval now;
221
222         do_gettimeofday(&now);
223
224         write_lock_bh(&client->ingress_lock);
225         entry = client->in_cache;
226         while(entry != NULL){
227                 entry->count=0;
228                 next_entry = entry->next;
229                 if((now.tv_sec - entry->tv.tv_sec)
230                    > entry->ctrl_info.holding_time){
231                         dprintk("mpoa: mpoa_caches.c: holding time expired, ip = %u.%u.%u.%u\n", NIPQUAD(entry->ctrl_info.in_dst_ip));
232                         client->in_ops->remove_entry(entry, client);
233                 }
234                 entry = next_entry;
235         }
236         write_unlock_bh(&client->ingress_lock);
237
238         return;
239 }
240
241 /* Call this every MPC-p4 seconds. */
242 static void check_resolving_entries(struct mpoa_client *client)
243 {
244
245         struct atm_mpoa_qos *qos;
246         in_cache_entry *entry;
247         struct timeval now;
248         struct k_message msg;
249
250         do_gettimeofday( &now );
251
252         read_lock_bh(&client->ingress_lock);
253         entry = client->in_cache;
254         while( entry != NULL ){
255                 if(entry->entry_state == INGRESS_RESOLVING){
256                         if(now.tv_sec - entry->hold_down.tv_sec < client->parameters.mpc_p6){
257                                 entry = entry->next;                      /* Entry in hold down */
258                                 continue;
259                         }
260                         if( (now.tv_sec - entry->reply_wait.tv_sec) >
261                             entry->retry_time ){
262                                 entry->retry_time = MPC_C1*( entry->retry_time );
263                                 if(entry->retry_time > client->parameters.mpc_p5){
264                                         /* Retry time maximum exceeded, put entry in hold down. */
265                                         do_gettimeofday(&(entry->hold_down));
266                                         entry->retry_time = client->parameters.mpc_p4;
267                                         entry = entry->next;
268                                         continue;
269                                 }
270                                 /* Ask daemon to send a resolution request. */
271                                 memset(&(entry->hold_down),0,sizeof(struct timeval));
272                                 msg.type = SND_MPOA_RES_RTRY;
273                                 memcpy(msg.MPS_ctrl, client->mps_ctrl_addr, ATM_ESA_LEN);
274                                 msg.content.in_info = entry->ctrl_info;
275                                 qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
276                                 if (qos != NULL) msg.qos = qos->qos;
277                                 msg_to_mpoad(&msg, client);
278                                 do_gettimeofday(&(entry->reply_wait));
279                         }
280                 }
281                 entry = entry->next;
282         }
283         read_unlock_bh(&client->ingress_lock);
284 }
285
286 /* Call this every MPC-p5 seconds. */
287 static void refresh_entries(struct mpoa_client *client)
288 {
289         struct timeval now;
290         struct in_cache_entry *entry = client->in_cache;
291
292         ddprintk("mpoa: mpoa_caches.c: refresh_entries\n");
293         do_gettimeofday(&now);
294
295         read_lock_bh(&client->ingress_lock);
296         while( entry != NULL ){
297                 if( entry->entry_state == INGRESS_RESOLVED ){
298                         if(!(entry->refresh_time))
299                                 entry->refresh_time = (2*(entry->ctrl_info.holding_time))/3;
300                         if( (now.tv_sec - entry->reply_wait.tv_sec) > entry->refresh_time ){
301                                 dprintk("mpoa: mpoa_caches.c: refreshing an entry.\n");
302                                 entry->entry_state = INGRESS_REFRESHING;
303
304                         }
305                 }
306                 entry = entry->next;
307         }
308         read_unlock_bh(&client->ingress_lock);
309 }
310
311 static void in_destroy_cache(struct mpoa_client *mpc)
312 {
313         write_lock_irq(&mpc->ingress_lock);
314         while(mpc->in_cache != NULL)
315                 mpc->in_ops->remove_entry(mpc->in_cache, mpc);
316         write_unlock_irq(&mpc->ingress_lock);
317
318         return;
319 }
320
321 static eg_cache_entry *eg_cache_get_by_cache_id(__be32 cache_id, struct mpoa_client *mpc)
322 {
323         eg_cache_entry *entry;
324
325         read_lock_irq(&mpc->egress_lock);
326         entry = mpc->eg_cache;
327         while(entry != NULL){
328                 if(entry->ctrl_info.cache_id == cache_id){
329                         atomic_inc(&entry->use);
330                         read_unlock_irq(&mpc->egress_lock);
331                         return entry;
332                 }
333                 entry = entry->next;
334         }
335         read_unlock_irq(&mpc->egress_lock);
336
337         return NULL;
338 }
339
340 /* This can be called from any context since it saves CPU flags */
341 static eg_cache_entry *eg_cache_get_by_tag(__be32 tag, struct mpoa_client *mpc)
342 {
343         unsigned long flags;
344         eg_cache_entry *entry;
345
346         read_lock_irqsave(&mpc->egress_lock, flags);
347         entry = mpc->eg_cache;
348         while (entry != NULL){
349                 if (entry->ctrl_info.tag == tag) {
350                         atomic_inc(&entry->use);
351                         read_unlock_irqrestore(&mpc->egress_lock, flags);
352                         return entry;
353                 }
354                 entry = entry->next;
355         }
356         read_unlock_irqrestore(&mpc->egress_lock, flags);
357
358         return NULL;
359 }
360
361 /* This can be called from any context since it saves CPU flags */
362 static eg_cache_entry *eg_cache_get_by_vcc(struct atm_vcc *vcc, struct mpoa_client *mpc)
363 {
364         unsigned long flags;
365         eg_cache_entry *entry;
366
367         read_lock_irqsave(&mpc->egress_lock, flags);
368         entry = mpc->eg_cache;
369         while (entry != NULL){
370                 if (entry->shortcut == vcc) {
371                         atomic_inc(&entry->use);
372                         read_unlock_irqrestore(&mpc->egress_lock, flags);
373                         return entry;
374                 }
375                 entry = entry->next;
376         }
377         read_unlock_irqrestore(&mpc->egress_lock, flags);
378
379         return NULL;
380 }
381
382 static eg_cache_entry *eg_cache_get_by_src_ip(__be32 ipaddr, struct mpoa_client *mpc)
383 {
384         eg_cache_entry *entry;
385
386         read_lock_irq(&mpc->egress_lock);
387         entry = mpc->eg_cache;
388         while(entry != NULL){
389                 if(entry->latest_ip_addr == ipaddr) {
390                         atomic_inc(&entry->use);
391                         read_unlock_irq(&mpc->egress_lock);
392                         return entry;
393                 }
394                 entry = entry->next;
395         }
396         read_unlock_irq(&mpc->egress_lock);
397
398         return NULL;
399 }
400
401 static void eg_cache_put(eg_cache_entry *entry)
402 {
403         if (atomic_dec_and_test(&entry->use)) {
404                 memset(entry, 0, sizeof(eg_cache_entry));
405                 kfree(entry);
406         }
407
408         return;
409 }
410
411 /*
412  * This should be called with write lock on
413  */
414 static void eg_cache_remove_entry(eg_cache_entry *entry,
415                                   struct mpoa_client *client)
416 {
417         struct atm_vcc *vcc;
418         struct k_message msg;
419
420         vcc = entry->shortcut;
421         dprintk("mpoa: mpoa_caches.c: removing an egress entry.\n");
422         if (entry->prev != NULL)
423                 entry->prev->next = entry->next;
424         else
425                 client->eg_cache = entry->next;
426         if (entry->next != NULL)
427                 entry->next->prev = entry->prev;
428         client->eg_ops->put(entry);
429         if(client->in_cache == NULL && client->eg_cache == NULL){
430                 msg.type = STOP_KEEP_ALIVE_SM;
431                 msg_to_mpoad(&msg,client);
432         }
433
434         /* Check if the ingress side still uses this VCC */
435         if (vcc != NULL) {
436                 in_cache_entry *in_entry = client->in_ops->get_by_vcc(vcc, client);
437                 if (in_entry != NULL) {
438                         client->in_ops->put(in_entry);
439                         return;
440                 }
441                 vcc_release_async(vcc, -EPIPE);
442         }
443
444         return;
445 }
446
447 static eg_cache_entry *eg_cache_add_entry(struct k_message *msg, struct mpoa_client *client)
448 {
449         eg_cache_entry *entry = kzalloc(sizeof(eg_cache_entry), GFP_KERNEL);
450
451         if (entry == NULL) {
452                 printk("mpoa: mpoa_caches.c: new_eg_cache_entry: out of memory\n");
453                 return NULL;
454         }
455
456         dprintk("mpoa: mpoa_caches.c: adding an egress entry, ip = %u.%u.%u.%u, this should be our IP\n", NIPQUAD(msg->content.eg_info.eg_dst_ip));
457
458         atomic_set(&entry->use, 1);
459         dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry: about to lock\n");
460         write_lock_irq(&client->egress_lock);
461         entry->next = client->eg_cache;
462         entry->prev = NULL;
463         if (client->eg_cache != NULL)
464                 client->eg_cache->prev = entry;
465         client->eg_cache = entry;
466
467         memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN);
468         entry->ctrl_info = msg->content.eg_info;
469         do_gettimeofday(&(entry->tv));
470         entry->entry_state = EGRESS_RESOLVED;
471         dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry cache_id %lu\n", ntohl(entry->ctrl_info.cache_id));
472         dprintk("mpoa: mpoa_caches.c: mps_ip = %u.%u.%u.%u\n",
473                 NIPQUAD(entry->ctrl_info.mps_ip));
474         atomic_inc(&entry->use);
475
476         write_unlock_irq(&client->egress_lock);
477         dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry: unlocked\n");
478
479         return entry;
480 }
481
482 static void update_eg_cache_entry(eg_cache_entry * entry, uint16_t holding_time)
483 {
484         do_gettimeofday(&(entry->tv));
485         entry->entry_state = EGRESS_RESOLVED;
486         entry->ctrl_info.holding_time = holding_time;
487
488         return;
489 }
490
491 static void clear_expired(struct mpoa_client *client)
492 {
493         eg_cache_entry *entry, *next_entry;
494         struct timeval now;
495         struct k_message msg;
496
497         do_gettimeofday(&now);
498
499         write_lock_irq(&client->egress_lock);
500         entry = client->eg_cache;
501         while(entry != NULL){
502                 next_entry = entry->next;
503                 if((now.tv_sec - entry->tv.tv_sec)
504                    > entry->ctrl_info.holding_time){
505                         msg.type = SND_EGRESS_PURGE;
506                         msg.content.eg_info = entry->ctrl_info;
507                         dprintk("mpoa: mpoa_caches.c: egress_cache: holding time expired, cache_id = %lu.\n",ntohl(entry->ctrl_info.cache_id));
508                         msg_to_mpoad(&msg, client);
509                         client->eg_ops->remove_entry(entry, client);
510                 }
511                 entry = next_entry;
512         }
513         write_unlock_irq(&client->egress_lock);
514
515         return;
516 }
517
518 static void eg_destroy_cache(struct mpoa_client *mpc)
519 {
520         write_lock_irq(&mpc->egress_lock);
521         while(mpc->eg_cache != NULL)
522                 mpc->eg_ops->remove_entry(mpc->eg_cache, mpc);
523         write_unlock_irq(&mpc->egress_lock);
524
525         return;
526 }
527
528
529
530 static struct in_cache_ops ingress_ops = {
531         in_cache_add_entry,               /* add_entry       */
532         in_cache_get,                     /* get             */
533         in_cache_get_with_mask,           /* get_with_mask   */
534         in_cache_get_by_vcc,              /* get_by_vcc      */
535         in_cache_put,                     /* put             */
536         in_cache_remove_entry,            /* remove_entry    */
537         cache_hit,                        /* cache_hit       */
538         clear_count_and_expired,          /* clear_count     */
539         check_resolving_entries,          /* check_resolving */
540         refresh_entries,                  /* refresh         */
541         in_destroy_cache                  /* destroy_cache   */
542 };
543
544 static struct eg_cache_ops egress_ops = {
545         eg_cache_add_entry,               /* add_entry        */
546         eg_cache_get_by_cache_id,         /* get_by_cache_id  */
547         eg_cache_get_by_tag,              /* get_by_tag       */
548         eg_cache_get_by_vcc,              /* get_by_vcc       */
549         eg_cache_get_by_src_ip,           /* get_by_src_ip    */
550         eg_cache_put,                     /* put              */
551         eg_cache_remove_entry,            /* remove_entry     */
552         update_eg_cache_entry,            /* update           */
553         clear_expired,                    /* clear_expired    */
554         eg_destroy_cache                  /* destroy_cache    */
555 };
556
557
558 void atm_mpoa_init_cache(struct mpoa_client *mpc)
559 {
560         mpc->in_ops = &ingress_ops;
561         mpc->eg_ops = &egress_ops;
562
563         return;
564 }