net/cor/common.c

   1 /*
   2  *      Connection oriented routing
   3  *      Copyright (C) 2007-2008 Michael Blizek
   4  *
   5  *      This program is free software; you can redistribute it and/or
   6  *      modify it under the terms of the GNU General Public License
   7  *      as published by the Free Software Foundation; either version 2
   8  *      of the License, or (at your option) any later version.
   9  *
  10  *      This program is distributed in the hope that it will be useful,
  11  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *      GNU General Public License for more details.
  14  *
  15  *      You should have received a copy of the GNU General Public License
  16  *      along with this program; if not, write to the Free Software
  17  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18  *      02110-1301, USA.
  19  */
  20
  21 #include <linux/mutex.h>
  22
  23 #include "cor.h"
  24
  25 DEFINE_MUTEX(cor_bindnodes);
  26 DEFINE_MUTEX(conn_free);
  27
  28 DEFINE_MUTEX(connid_gen);
  29
  30 LIST_HEAD(openports);
  31
  32
  33 struct cell_hdr{
  34         spinlock_t lock;
  35 };
  36
  37 struct kmem_cache *conn_slab;
  38
  39 struct htable connid_table;
  40
  41 struct kmem_cache *bindnode_slab;
  42 struct kmem_cache *connlistener_slab;
  43
  44 void ref_counter_decr(struct ref_counter *cnt)
  45 {
  46         unsigned long iflags;
  47
  48         BUG_ON(0 == cnt);
  49         BUG_ON(0 == cnt->def);
  50
  51         spin_lock_irqsave(&(cnt->lock), iflags);
  52         cnt->refs--;
  53         if (unlikely(cnt->refs == 0)) {
  54                 cnt->def->free(cnt);
  55                 local_irq_restore(iflags);
  56                 return;
  57         }
  58         spin_unlock_irqrestore(&(cnt->lock), iflags);
  59 }
  60
  61 int ref_counter_incr(struct ref_counter *cnt)
  62 {
  63         unsigned long iflags;
  64         int ret = 1;
  65
  66         spin_lock_irqsave(&(cnt->lock), iflags);
  67         ret = 0;
  68         cnt->refs++;
  69         spin_unlock_irqrestore(&(cnt->lock), iflags);
  70
  71         return 0;
  72 }
  73
  74 void ref_counter_init(struct ref_counter *cnt, struct ref_counter_def *def)
  75 {
  76         BUG_ON(0 == cnt);
  77         BUG_ON(0 == def);
  78
  79         spin_lock_init(&(cnt->lock));
  80         cnt->refs = 1;
  81         cnt->def = def;
  82 }
  83
  84
  85 static inline int hdr_size(void)
  86 {
  87         return ((sizeof(struct cell_hdr) + sizeof(void *) - 1) / sizeof(void *)
  88                 ) * sizeof(void *);
  89 }
  90
  91 static inline int elements_per_cell(int cell_size)
  92 {
  93         return (cell_size - hdr_size())/sizeof(void *);
  94 }
  95
  96 static inline struct cell_hdr *cell_addr(struct htable *ht, __u32 id)
  97 {
  98         int idx = (id%ht->htable_size) / (elements_per_cell(ht->cell_size));
  99         return (struct cell_hdr *) (((char *)ht->htable) + ht->cell_size * idx);
 100 }
 101
 102 static inline char **element_addr(struct htable *ht, __u32 id)
 103 {
 104         int idx = (id%ht->htable_size) % (elements_per_cell(ht->cell_size));
 105         return (char **)
 106                         ( ((char *)cell_addr(ht, id)) +
 107                         hdr_size() + idx*sizeof(void *) );
 108 }
 109
 110
 111 static inline char **next_element(struct htable *ht, char *element)
 112 {
 113         return (char **)(element + ht->entry_offset);
 114 }
 115
 116 static inline struct ref_counter *element_refcnt(struct htable *ht, char *element)
 117 {
 118         return (struct ref_counter *)(element + ht->ref_counter_offset);
 119 }
 120
 121
 122 static inline void unlock_element(struct htable *ht, __u32 key)
 123 {
 124         struct cell_hdr *hdr = cell_addr(ht, key);
 125         spin_unlock( &(hdr->lock) );
 126 }
 127
 128
 129 static char **get_element_nounlock(struct htable *ht, __u32 key,
 130                 void *searcheditem)
 131 {
 132         struct cell_hdr *hdr = cell_addr(ht, key);
 133         char **element = element_addr(ht, key);
 134
 135         BUG_ON(0 == element);
 136
 137         spin_lock( &(hdr->lock) );
 138
 139         while (1) {
 140                 if (*element == 0)
 141                         break;
 142                 if (searcheditem != 0 && ht->matches(*element, searcheditem))
 143                         break;
 144                 element = next_element(ht, *element);
 145         }
 146
 147         return element;
 148 }
 149
 150 char *htable_get(struct htable *ht, __u32 key, void *searcheditem)
 151 {
 152         unsigned long iflags;
 153         char *element;
 154
 155         printk(KERN_ERR "get %d", key);
 156
 157         if (ht->htable == 0)
 158                 return 0;
 159
 160         local_irq_save(iflags);
 161         element = *(get_element_nounlock(ht, key, searcheditem));
 162         if (element != 0)
 163                 ref_counter_incr(element_refcnt(ht, element));
 164         unlock_element(ht, key);
 165         local_irq_restore(iflags);
 166
 167         return element;
 168 }
 169
 170 int htable_delete(struct htable *ht, __u32 key,
 171                 void *searcheditem)
 172 {
 173         unsigned long iflags;
 174         char **element;
 175         char **next;
 176         int rc = 0;
 177
 178         printk(KERN_ERR "des %d", key);
 179
 180         if (ht->htable == 0)
 181                 return 1;
 182
 183         local_irq_save(iflags);
 184
 185         element = get_element_nounlock(ht, key, searcheditem);
 186         BUG_ON(0 == element);
 187
 188         if (0 == *element) {
 189                 /* key not in table */
 190                 rc = 1;
 191                 goto out;
 192         }
 193
 194         next = next_element(ht, *element);
 195         ref_counter_decr(element_refcnt(ht, *element));
 196         *element = *next;
 197
 198 out:
 199         unlock_element(ht, key);
 200         local_irq_restore(iflags);
 201
 202         return rc;
 203 }
 204
 205 void htable_insert(struct htable *ht, char *newelement, __u32 key)
 206 {
 207         unsigned long iflags;
 208         char **element;
 209
 210         printk(KERN_ERR "insert %d %d", (int) newelement, key);
 211
 212         if (ht->htable == 0)
 213                 return;
 214
 215         BUG_ON(*next_element(ht, newelement) != 0);
 216         local_irq_save(iflags);
 217
 218         element = get_element_nounlock(ht, key, 0);
 219
 220         BUG_ON(element == 0);
 221         BUG_ON(*element != 0);
 222
 223         *element = newelement;
 224         ref_counter_incr(element_refcnt(ht, newelement));
 225
 226         unlock_element(ht, key);
 227         local_irq_restore(iflags);
 228 }
 229
 230
 231 void htable_init(struct htable *ht, int (*matches)(void *htentry,
 232                 void *searcheditem), __u32 entry_offset, __u32 ref_counter_offset)
 233 {
 234         int num_cells;
 235         int j;
 236
 237         BUG_ON(0 == ht);
 238
 239         ht->htable = kmalloc(PAGE_SIZE, GFP_KERNEL);
 240         if (ht->htable == 0) {
 241                 printk(KERN_CRIT "cor: error allocating htable (out of "
 242                                 "memory?)");
 243                 return;
 244         }
 245         memset(ht->htable, 0, PAGE_SIZE);
 246         ht->cell_size = 256;
 247
 248         num_cells = PAGE_SIZE/ht->cell_size;
 249
 250         for (j=0;j<num_cells;j++) {
 251                 struct cell_hdr *hdr = (struct cell_hdr *)
 252                                 ( ((char *) ht->htable) + j * ht->cell_size );
 253                 spin_lock_init(&(hdr->lock));
 254         }
 255
 256         ht->htable_size = num_cells * elements_per_cell(ht->cell_size);
 257         ht->num_elements = 0;
 258
 259         ht->matches = matches;
 260         ht->entry_offset = entry_offset;
 261         ht->ref_counter_offset = ref_counter_offset;
 262 }
 263
 264 struct conn *get_conn(__u32 conn_id)
 265 {
 266         return (struct conn *) htable_get(&connid_table, conn_id, &conn_id);
 267 }
 268
 269 static int connid_alloc(struct conn *sconn)
 270 {
 271         __u32 conn_id;
 272         int i;
 273
 274         BUG_ON(sconn->sourcetype != SOURCE_IN);
 275
 276         mutex_lock(&connid_gen);
 277         for(i=0;i<16;i++) {
 278                 struct conn *tmp;
 279
 280                 conn_id = 0;
 281                 get_random_bytes((char *) &conn_id, sizeof(conn_id));
 282
 283                 if (conn_id == 0)
 284                         continue;
 285
 286                 tmp = get_conn(conn_id);
 287                 if (tmp != 0) {
 288                         ref_counter_decr(&(tmp->refs));
 289                         continue;
 290                 }
 291
 292                 goto found;
 293         }
 294         mutex_unlock(&connid_gen);
 295
 296         return 1;
 297
 298 found:
 299         sconn->source.in.conn_id = conn_id;
 300         htable_insert(&connid_table, (char *) sconn, conn_id);
 301         mutex_unlock(&connid_gen);
 302         return 0;
 303 }
 304
 305 static void free_conn(struct ref_counter *cnt)
 306 {
 307         struct conn *conn = container_of(cnt, struct conn, refs);
 308
 309         BUG_ON(conn->isreset == 0);
 310
 311         mutex_lock(&conn_free);
 312
 313         if (conn->isreset != 3) {
 314                 conn->reversedir->isreset = 3;
 315                 goto out;
 316         }
 317
 318         if (conn->reversedir != 0) {
 319                 conn->reversedir->reversedir = 0;
 320                 free_conn(&(conn->reversedir->refs));
 321                 conn->reversedir = 0;
 322         }
 323
 324         if (conn->sourcetype == SOURCE_IN) {
 325                 ref_counter_decr(&(conn->source.in.nb->refs));
 326                 conn->source.in.nb = 0;
 327         }
 328
 329         if (conn->targettype == TARGET_OUT) {
 330                 ref_counter_decr(&(conn->target.out.nb->refs));
 331                 conn->target.out.nb = 0;
 332         }
 333
 334         databuf_free(&(conn->buf));
 335
 336         kmem_cache_free(conn_slab, conn);
 337
 338 out:
 339         mutex_unlock(&conn_free);
 340 }
 341
 342 static struct ref_counter_def conn_refcnt = {
 343         .free = free_conn
 344 };
 345
 346 /*
 347  * rconn ==> the connection we received the commend from
 348  * ==> init rconn->target.out + rconn->reversedir->source.in
 349  * rc == 0 ==> ok
 350  * rc == 1 ==> connid allocation failed
 351  */
 352 int conn_init_out(struct conn *rconn, struct neighbor *nb)
 353 {
 354         struct conn *sconn = rconn->reversedir;
 355
 356         BUG_ON(TARGET_UNCONNECTED != rconn->targettype);
 357         BUG_ON(0 == sconn);
 358         BUG_ON(SOURCE_NONE != sconn->sourcetype);
 359
 360         memset(&(rconn->target.out), 0, sizeof(rconn->target.out));
 361         memset(&(sconn->source.in), 0, sizeof(sconn->source.in));
 362
 363         rconn->targettype = TARGET_OUT;
 364         sconn->sourcetype = SOURCE_IN;
 365
 366         rconn->target.out.nb = nb;
 367         sconn->source.in.nb = nb;
 368
 369         skb_queue_head_init(&(sconn->source.in.reorder_queue));
 370
 371         /*
 372          * connid_alloc has to be called last, because packets may be received
 373          * immediately after its execution
 374          */
 375         if (connid_alloc(sconn))
 376                 return 1;
 377
 378         mutex_lock(&(nb->conn_list_lock));
 379         list_add_tail(&(sconn->source.in.nb_list), &(nb->rcv_conn_list));
 380         list_add_tail(&(rconn->target.out.nb_list), &(nb->snd_conn_list));
 381         mutex_unlock(&(nb->conn_list_lock));
 382
 383         /* neighbor lists */
 384         ref_counter_incr(&(rconn->refs));
 385         ref_counter_incr(&(sconn->refs));
 386
 387         return 0;
 388 }
 389
 390 void conn_init_sock_source(struct conn *conn)
 391 {
 392         BUG_ON(conn == 0);
 393
 394         conn->sourcetype = SOURCE_SOCK;
 395
 396         memset(&(conn->source.sock), 0, sizeof(conn->source.sock));
 397
 398         init_waitqueue_head(&(conn->source.sock.wait));
 399 }
 400
 401 void conn_init_sock_target(struct conn *conn)
 402 {
 403         BUG_ON(conn == 0);
 404         conn->targettype = TARGET_SOCK;
 405         init_waitqueue_head(&(conn->target.sock.wait));
 406 }
 407
 408 struct conn* alloc_conn(gfp_t allocflags)
 409 {
 410         struct conn *rconn = 0;
 411         struct conn *sconn = 0;
 412
 413         rconn = kmem_cache_alloc(conn_slab, allocflags);
 414         if (unlikely(0 == rconn))
 415                 goto out_err0;
 416
 417         sconn = kmem_cache_alloc(conn_slab, allocflags);
 418         if (unlikely(0 == sconn))
 419                 goto out_err1;
 420
 421         memset(rconn, 0, sizeof(struct conn));
 422         memset(sconn, 0, sizeof(struct conn));
 423
 424         rconn->reversedir = sconn;
 425         sconn->reversedir = rconn;
 426
 427         ref_counter_init(&(rconn->refs), &conn_refcnt);
 428         ref_counter_init(&(sconn->refs), &conn_refcnt);
 429
 430         mutex_init(&(rconn->rcv_lock));
 431         mutex_init(&(sconn->rcv_lock));
 432
 433         rconn->sockstate = SOCKSTATE_CONN;
 434         sconn->sockstate = SOCKSTATE_CONN;
 435
 436         databuf_init(&(rconn->buf));
 437         databuf_init(&(sconn->buf));
 438
 439         return rconn;
 440
 441 out_err1:
 442         kmem_cache_free(conn_slab, rconn);
 443 out_err0:
 444         return 0;
 445 }
 446
 447 static struct connlistener *get_connlistener(__be64 port)
 448 {
 449         struct list_head *curr = openports.next;
 450
 451         while (curr != &openports) {
 452                 struct bindnode *currnode = ((struct bindnode *)
 453                         (((char *)curr) - offsetof(struct bindnode, lh)));
 454                 if (currnode->port == port) {
 455                         BUG_ON(currnode->owner == 0);
 456                         return currnode->owner;
 457                 }
 458
 459                 curr = curr->next;
 460         }
 461
 462         return 0;
 463 }
 464
 465 void close_port(struct connlistener *listener)
 466 {
 467         mutex_lock(&cor_bindnodes);
 468
 469         if (listener->bn != 0) {
 470                 list_del(&(listener->bn->lh));
 471                 kmem_cache_free(bindnode_slab, listener->bn);
 472                 listener->bn = 0;
 473         }
 474
 475         while (list_empty(&(listener->conn_queue)) == 0) {
 476                 struct conn *rconn = container_of(listener->conn_queue.next,
 477                                 struct conn, source.sock.cl_list);
 478                 rconn->reversedir->isreset = 1;
 479                 reset_conn(rconn);
 480                 list_del(&(rconn->source.sock.cl_list));
 481                 ref_counter_decr(&(rconn->refs));
 482         }
 483
 484         kmem_cache_free(connlistener_slab, listener);
 485
 486         mutex_unlock(&cor_bindnodes);
 487 }
 488
 489 struct connlistener *open_port(__be64 port)
 490 {
 491
 492         struct bindnode *bn = 0;
 493         struct connlistener *listener = 0;
 494
 495         mutex_lock(&cor_bindnodes);
 496         if (get_connlistener(port) != 0)
 497                 goto out;
 498
 499
 500         bn = kmem_cache_alloc(bindnode_slab, GFP_KERNEL);
 501         listener = kmem_cache_alloc(connlistener_slab, GFP_KERNEL);
 502
 503         memset(bn, 0, sizeof(struct bindnode));
 504         memset(listener, 0, sizeof(struct connlistener));
 505
 506         bn->owner = listener;
 507         bn->port = port;
 508
 509         /* refcounter is not actually used */
 510         listener->sockstate = SOCKSTATE_LISTENER;
 511         listener->bn = bn;
 512         mutex_init(&(listener->lock));
 513         INIT_LIST_HEAD(&(listener->conn_queue));
 514         init_waitqueue_head(&(listener->wait));
 515
 516         list_add_tail((struct list_head *) &(bn->lh), &openports);
 517
 518 out:
 519         mutex_unlock(&cor_bindnodes);
 520
 521         return listener;
 522 }
 523
 524 /**
 525  * rc == 0 connected
 526  * rc == 2 port not open
 527  * rc == 3 listener queue full
 528  */
 529 int connect_port(struct conn *rconn, __be64 port)
 530 {
 531
 532         struct connlistener *listener;
 533         int rc = 0;
 534
 535         mutex_lock(&cor_bindnodes);
 536
 537         listener = get_connlistener(port);
 538         if (listener == 0) {
 539                 rc = 2;
 540                 goto out;
 541         }
 542
 543         mutex_lock(&(listener->lock));
 544
 545         if (listener->queue_len >= listener->queue_maxlen) {
 546                 if (listener->queue_maxlen <= 0)
 547                         rc = 2;
 548                 else
 549                         rc = 3;
 550
 551                 goto out2;
 552         }
 553
 554         if (ref_counter_incr(&(rconn->reversedir->refs)))
 555                 BUG();
 556
 557         conn_init_sock_target(rconn);
 558         conn_init_sock_source(rconn->reversedir);
 559
 560         list_add_tail(&(rconn->reversedir->source.sock.cl_list),
 561                         &(listener->conn_queue));
 562         listener->queue_len++;
 563         wake_up_interruptible(&(listener->wait));
 564
 565 out2:
 566         mutex_unlock(&(listener->lock));
 567
 568 out:
 569         mutex_unlock(&cor_bindnodes);
 570         return rc;
 571 }
 572
 573 /**
 574  * rc == 0 connected
 575  * rc == 2 addrtype not found
 576  * rc == 3 addr not found
 577  * rc == 4 ==> connid allocation failed
 578  * rc == 5 ==> control msg alloc failed
 579  */
 580 int connect_neigh(struct conn *rconn,
 581                 __u16 addrtypelen, __u8 *addrtype,
 582                 __u16 addrlen, __u8 *addr)
 583 {
 584         int rc = 0;
 585         struct control_msg_out *cm;
 586         struct neighbor *nb = find_neigh(addrtypelen, addrtype, addrlen, addr);
 587         if (nb == 0)
 588                 return 3;
 589         if (conn_init_out(rconn, nb)) {
 590                 rc = 4;
 591                 goto neigh_refcnt;
 592         }
 593
 594         cm = alloc_control_msg();
 595         if (unlikely(cm == 0)) {
 596                 rc = 5;
 597                 goto neigh_refcnt;
 598         }
 599
 600         send_connect_nb(cm, nb, rconn->reversedir->source.in.conn_id);
 601
 602         if (0) {
 603 neigh_refcnt:
 604                 ref_counter_decr(&(nb->refs));
 605         }
 606
 607         return rc;
 608 }
 609
 610 static void _reset_conn(struct conn *conn)
 611 {
 612         if (conn->isreset == 1)
 613                 goto free;
 614
 615         if (conn->isreset == 2 || conn->isreset == 3)
 616                 return;
 617
 618         if (conn->targettype == TARGET_OUT && conn->target.out.conn_id != 0) {
 619                 struct control_msg_out *cm = alloc_control_msg();
 620                 if (likely(cm != 0))
 621                         send_reset_conn(cm, conn->target.out.nb,
 622                                         conn->target.out.conn_id);
 623         }
 624
 625 free:
 626
 627         if (conn->sourcetype == SOURCE_IN) {
 628                 mutex_lock(&(conn->source.in.nb->conn_list_lock));
 629                 list_del(&(conn->source.in.nb_list));
 630                 mutex_unlock(&(conn->source.in.nb->conn_list_lock));
 631
 632                 ref_counter_decr(&(conn->refs));
 633
 634                 if (conn->source.in.conn_id != 0)
 635                         htable_delete(&connid_table, conn->source.in.conn_id,
 636                                         &(conn->source.in.conn_id));
 637         }
 638
 639         if (conn->targettype == TARGET_OUT) {
 640                 mutex_lock(&(conn->target.out.nb->conn_list_lock));
 641                 list_del(&(conn->target.out.nb_list));
 642                 mutex_unlock(&(conn->target.out.nb->conn_list_lock));
 643                 ref_counter_decr(&(conn->refs));
 644         }
 645
 646         conn->isreset = 2;
 647 }
 648
 649 /* warning: do not hold the rcv_lock while calling this! */
 650 void reset_conn(struct conn *conn)
 651 {
 652         _reset_conn(conn);
 653         _reset_conn(conn->reversedir);
 654 }
 655
 656 static int matches_connid_in(void *htentry, void *searcheditem)
 657 {
 658         struct conn *conn = (struct conn *) htentry;
 659         __u32 conn_id = *((__u32 *) searcheditem);
 660         BUG_ON(conn->sourcetype != SOURCE_IN);
 661         return (conn->source.in.conn_id == conn_id);
 662 }
 663
 664 static int __init cor_common_init(void)
 665 {
 666         int rc;
 667
 668         struct conn c;
 669
 670         printk(KERN_ERR "sizeof conn: %d", sizeof(c));
 671         printk(KERN_ERR "  conn.source: %d", sizeof(c.source));
 672         printk(KERN_ERR "  conn.target: %d", sizeof(c.target));
 673         printk(KERN_ERR "  conn.target.out: %d", sizeof(c.target.out));
 674         printk(KERN_ERR "  conn.target.buf: %d", sizeof(c.buf));
 675
 676         printk(KERN_ERR "  mutex: %d", sizeof(struct mutex));
 677         printk(KERN_ERR "  spinlock: %d", sizeof(spinlock_t));
 678         printk(KERN_ERR "  kref: %d", sizeof(struct kref));
 679
 680
 681         conn_slab = kmem_cache_create("cor_conn", sizeof(struct conn), 8, 0, 0);
 682         htable_init(&connid_table, matches_connid_in,
 683                         offsetof(struct conn, source.in.htab_entry),
 684                         offsetof(struct conn, refs));
 685
 686         bindnode_slab = kmem_cache_create("cor_bindnode",
 687                         sizeof(struct bindnode), 8, 0, 0);
 688         connlistener_slab = kmem_cache_create("cor_connlistener",
 689                         sizeof(struct connlistener), 8, 0, 0);
 690
 691         forward_init();
 692
 693         rc = cor_snd_init();
 694         if (rc != 0)
 695                 return rc;
 696
 697         rc = cor_neighbor_init();
 698         if (rc != 0)
 699                 return rc;
 700
 701         rc = cor_rcv_init();
 702         if (rc != 0)
 703                 return rc;
 704
 705         return 0;
 706 }
 707
 708 module_init(cor_common_init);
 709 MODULE_LICENSE("GPL");