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