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