drivers/net/eql.c

/* */
This source file includes following definitions.
eql_init
eql_open
eql_close
eql_ioctl
eql_slave_xmit
eql_get_stats
eql_header
eql_rebuild_header
eql_enslave
eql_emancipate
eql_g_slave_cfg
eql_s_slave_cfg
eql_g_master_cfg
eql_s_master_cfg
eql_is_slave
eql_is_master
eql_new_slave
eql_delete_slave
slave_Bps
slave_bps
eql_number_slaves
eql_is_empty
eql_is_full
eql_new_slave_queue
eql_delete_slave_queue
eql_insert_slave
eql_remove_slave
eql_insert_slave_dev
eql_remove_slave_dev
eql_best_slave_dev
eql_best_slave
eql_schedule_slaves
eql_find_slave_dev
eql_first_slave
eql_next_slave
eql_set_best_slave
eql_lock_slave_queue
eql_unlock_slave_queue
eql_is_locked_slave_queue
eql_timer
   1 /*
   2  * Equalizer Load-balancer for serial network interfaces.
   3  *
   4  * (c) Copyright 1995 Simon "Guru Aleph-Null" Janes
   5  * NCM: Network and Communications Mangement, Inc.
   6  *
   7  *
   8  *      This software may be used and distributed according to the terms
   9  *      of the GNU Public License, incorporated herein by reference.
  10  * 
  11  * The author may be reached as simon@ncm.com, or C/O
  12  *    NCM
  13  *    Attn: Simon Janes
  14  *    6803 Whittier Ave
  15  *    McLean VA 22101
  16  *    Phone: 1-703-847-0040 ext 103
  17  */
  18 
  19 static char *version = 
  20         "Equalizer: $Revision: 3.12 $ $Date: 1995/01/19 $ Simon Janes (simon@ncm.com)\n";
  21 
  22 #include <linux/config.h>
  23 
  24 /*
  25  * Sources:
  26  *   skeleton.c by Donald Becker.
  27  * Inspirations:
  28  *   The Harried and Overworked Alan Cox
  29  * Conspiracies:
  30  *   The Alan Cox and Arisian plot to get someone else to do the code, which
  31  *   turned out to be me.
  32  */
  33 
  34 /*
  35  * $Log: eql.c,v $
  36  * Revision 3.12  1995/03/22  21:07:51  anarchy
  37  * Added suser() checks on configuration.
  38  * Moved header file.
  39  *
  40  * Revision 3.11  1995/01/19  23:14:31  guru
  41  *                    slave_load = (ULONG_MAX - (ULONG_MAX / 2)) -
  42  *                      (priority_Bps) + bytes_queued * 8;
  43  *
  44  * Revision 3.10  1995/01/19  23:07:53  guru
  45  * back to
  46  *                    slave_load = (ULONG_MAX - (ULONG_MAX / 2)) -
  47  *                      (priority_Bps) + bytes_queued;
  48  *
  49  * Revision 3.9  1995/01/19  22:38:20  guru
  50  *                    slave_load = (ULONG_MAX - (ULONG_MAX / 2)) -
  51  *                      (priority_Bps) + bytes_queued * 4;
  52  *
  53  * Revision 3.8  1995/01/19  22:30:55  guru
  54  *       slave_load = (ULONG_MAX - (ULONG_MAX / 2)) -
  55  *                      (priority_Bps) + bytes_queued * 2;
  56  *
  57  * Revision 3.7  1995/01/19  21:52:35  guru
  58  * printk's trimmed out.
  59  *
  60  * Revision 3.6  1995/01/19  21:49:56  guru
  61  * This is working pretty well. I gained 1 K/s in speed.. now its just
  62  * robustness and printk's to be diked out.
  63  *
  64  * Revision 3.5  1995/01/18  22:29:59  guru
  65  * still crashes the kernel when the lock_wait thing is woken up.
  66  *
  67  * Revision 3.4  1995/01/18  21:59:47  guru
  68  * Broken set-bit locking snapshot
  69  *
  70  * Revision 3.3  1995/01/17  22:09:18  guru
  71  * infinite sleep in a lock somewhere..
  72  *
  73  * Revision 3.2  1995/01/15  16:46:06  guru
  74  * Log trimmed of non-pertinant 1.x branch messages
  75  *
  76  * Revision 3.1  1995/01/15  14:41:45  guru
  77  * New Scheduler and timer stuff...
  78  *
  79  * Revision 1.15  1995/01/15  14:29:02  guru
  80  * Will make 1.14 (now 1.15) the 3.0 branch, and the 1.12 the 2.0 branch, the one
  81  * with the dumber scheduler
  82  *
  83  * Revision 1.14  1995/01/15  02:37:08  guru
  84  * shock.. the kept-new-versions could have zonked working
  85  * stuff.. shudder
  86  *
  87  * Revision 1.13  1995/01/15  02:36:31  guru
  88  * big changes
  89  *
  90  *      scheduler was torn out and replaced with something smarter
  91  *
  92  *      global names not prefixed with eql_ were renamed to protect
  93  *      against namespace collisions
  94  *
  95  *      a few more abstract interfaces were added to facilitate any
  96  *      potential change of datastructure.  the driver is still using
  97  *      a linked list of slaves.  going to a heap would be a bit of
  98  *      an overkill.
  99  *
 100  *      this compiles fine with no warnings.
 101  *
 102  *      the locking mechanism and timer stuff must be written however,
 103  *      this version will not work otherwise
 104  *
 105  */
 106 
 107 #include <linux/kernel.h>
 108 #include <linux/sched.h>
 109 #include <linux/types.h>
 110 #include <linux/fcntl.h>
 111 #include <linux/interrupt.h>
 112 #include <linux/ptrace.h>
 113 #include <linux/ioport.h>
 114 #include <linux/in.h>
 115 #include <linux/malloc.h>
 116 #include <linux/string.h>
 117 #include <asm/system.h>
 118 #include <asm/bitops.h>
 119 #include <asm/io.h>
 120 #include <asm/dma.h>
 121 #include <linux/errno.h>              
 122 
 123 #include <linux/netdevice.h>
 124 #include <linux/if.h>
 125 #include <linux/timer.h>
 126 
 127 #include <linux/if_eql.h>
 128 
 129 #ifndef EQL_DEBUG
 130 /* #undef EQL_DEBUG      -* print nothing at all, not even a boot-banner */
 131 /* #define EQL_DEBUG 1   -* print only the boot-banner */
 132 /* #define EQL_DEBUG 5   -* print major function entries */
 133 /* #define EQL_DEBUG 20  -* print subfunction entries */
 134 /* #define EQL_DEBUG 50  -* print utility entries */
 135 /* #define EQL_DEBUG 100 -* print voluminous function entries */
 136 #define EQL_DEBUG 1
 137 #endif
 138 static unsigned int eql_debug = EQL_DEBUG;
 139 
 140 int        eql_init(struct device *dev); /*  */
 141 static int eql_open(struct device *dev); /*  */
 142 static int eql_close(struct device *dev); /*  */
 143 static int eql_ioctl(struct device *dev, struct ifreq *ifr, int cmd); /*  */
 144 static int eql_slave_xmit(struct sk_buff *skb, struct device *dev); /*  */
 145 
 146 static struct enet_statistics *eql_get_stats(struct device *dev); /*  */
 147 static int eql_header(unsigned char *buff, struct device *dev, 
 148                       unsigned short type, void *daddr, void *saddr, 
 149                       unsigned len, struct sk_buff *skb); /*  */
 150 static int eql_rebuild_header(void *buff, struct device *dev, 
 151                               unsigned long raddr, struct sk_buff *skb); /*  */
 152 
 153 /* ioctl() handlers
 154    ---------------- */
 155 static int eql_enslave(struct device *dev,  slaving_request_t *srq); /*  */
 156 static int eql_emancipate(struct device *dev, slaving_request_t *srq); /*  */
 157 
 158 static int eql_g_slave_cfg(struct device *dev, slave_config_t *sc); /*  */
 159 static int eql_s_slave_cfg(struct device *dev, slave_config_t *sc); /*  */
 160 
 161 static int eql_g_master_cfg(struct device *dev, master_config_t *mc); /*  */
 162 static int eql_s_master_cfg(struct device *dev, master_config_t *mc); /*  */
 163 
 164 static inline int eql_is_slave(struct device *dev); /*  */
 165 static inline int eql_is_master(struct device *dev); /*  */
 166 
 167 static slave_t *eql_new_slave(void); /*  */
 168 static void eql_delete_slave(slave_t *slave); /*  */
 169 
 170 /* static long eql_slave_priority(slave_t *slave); -*  */
 171 static inline int eql_number_slaves(slave_queue_t *queue); /*  */
 172 
 173 static inline int eql_is_empty(slave_queue_t *queue); /*  */
 174 static inline int eql_is_full(slave_queue_t *queue); /*  */
 175 
 176 static slave_queue_t *eql_new_slave_queue(struct device *dev); /*  */
 177 static void eql_delete_slave_queue(slave_queue_t *queue); /*  */
 178 
 179 static int eql_insert_slave(slave_queue_t *queue, slave_t *slave); /*  */
 180 static slave_t *eql_remove_slave(slave_queue_t *queue, slave_t *slave); /*  */
 181 
 182 /* static int eql_insert_slave_dev(slave_queue_t *queue, struct device *dev); -*  */
 183 static int eql_remove_slave_dev(slave_queue_t *queue, struct device *dev); /*  */
 184 
 185 static inline struct device *eql_best_slave_dev(slave_queue_t *queue); /*  */
 186 static inline slave_t *eql_best_slave(slave_queue_t *queue); /*  */
 187 static inline slave_t *eql_first_slave(slave_queue_t *queue); /*  */
 188 static inline slave_t *eql_next_slave(slave_queue_t *queue, slave_t *slave); /*  */
 189 
 190 static inline void eql_set_best_slave(slave_queue_t *queue, slave_t *slave); /*  */
 191 static inline void eql_schedule_slaves(slave_queue_t *queue); /*  */
 192 
 193 static slave_t *eql_find_slave_dev(slave_queue_t *queue, struct device *dev); /*  */
 194 
 195 /* static inline eql_lock_slave_queue(slave_queue_t *queue); -*  */
 196 /* static inline eql_unlock_slave_queue(slave_queue_t *queue); -*  */
 197 
 198 static void eql_timer(unsigned long param);     /*  */
 199 
 200 /* struct device * interface functions 
 201    ---------------------------------------------------------
 202    */
 203 
 204 int
 205 eql_init(struct device *dev)
     /*  */
 206 {
 207   static unsigned version_printed = 0;
 208   /* static unsigned num_masters     = 0; */
 209   equalizer_t *eql = 0;
 210   int i;
 211 
 212   if ( version_printed++ == 0 && eql_debug > 0)
 213     printk(version);
 214 
 215   /* Initialize the device structure. */
 216   dev->priv = kmalloc (sizeof (equalizer_t), GFP_KERNEL);
 217   memset (dev->priv, 0, sizeof (equalizer_t));
 218   eql = (equalizer_t *) dev->priv;
 219 
 220   eql->stats = kmalloc (sizeof (struct enet_statistics), GFP_KERNEL);
 221   memset (eql->stats, 0, sizeof (struct enet_statistics));
 222 
 223   init_timer (&eql->timer);
 224   eql->timer.data     = (unsigned long) dev->priv;
 225   eql->timer.expires  = EQL_DEFAULT_RESCHED_IVAL;
 226   eql->timer.function = &eql_timer;
 227   eql->timer_on       = 0;
 228 
 229   dev->open             = eql_open;
 230   dev->stop             = eql_close;
 231   dev->do_ioctl         = eql_ioctl;
 232   dev->hard_start_xmit  = eql_slave_xmit;
 233   dev->get_stats        = eql_get_stats;
 234   
 235   /* Fill in the fields of the device structure with ethernet-generic values.
 236      This should be in a common file instead of per-driver.  */
 237 
 238   for (i = 0; i < DEV_NUMBUFFS; i++)
 239     skb_queue_head_init(&dev->buffs[i]);
 240 
 241   dev->hard_header    = eql_header; 
 242   dev->rebuild_header = eql_rebuild_header;
 243 
 244   /* now we undo some of the things that eth_setup does that we don't like */
 245   dev->mtu        = EQL_DEFAULT_MTU;    /* set to 576 in eql.h */
 246   dev->flags      = IFF_MASTER;
 247 
 248   dev->family     = AF_INET;
 249   dev->pa_addr    = 0;
 250   dev->pa_brdaddr = 0;
 251   dev->pa_mask    = 0;
 252   dev->pa_alen    = sizeof (unsigned long);
 253 
 254   dev->type       = ARPHRD_SLIP;
 255 
 256   return 0;
 257 }
 258 
 259 
 260 static
 261 int
 262 eql_open(struct device *dev)
     /*  */
 263 {
 264   equalizer_t *eql = (equalizer_t *) dev->priv;
 265   slave_queue_t *new_queue;
 266 
 267 #ifdef EQL_DEBUG
 268   if (eql_debug >= 5)
 269     printk ("%s: open\n", dev->name);
 270 #endif
 271 
 272    new_queue = eql_new_slave_queue (dev);
 273     
 274     if (new_queue != 0)
 275       {
 276         new_queue->master_dev = dev;
 277         eql->queue = new_queue;
 278         eql->queue->lock = 0;
 279         eql->min_slaves = 1;
 280         eql->max_slaves = EQL_DEFAULT_MAX_SLAVES; /* 4 usually... */
 281 
 282         printk ("%s: adding timer\n", dev->name);
 283         eql->timer_on = 1;
 284         add_timer (&eql->timer);
 285 
 286         return 0;
 287       }
 288   return 1;
 289 }
 290 
 291 
 292 static
 293 int
 294 eql_close(struct device *dev)
     /*  */
 295 {
 296   equalizer_t *eql = (equalizer_t *) dev->priv;
 297 
 298 #ifdef EQL_DEBUG
 299   if ( eql_debug >= 5)
 300     printk ("%s: close\n", dev->name);
 301 #endif
 302   /* The timer has to be stopped first before we start hacking away
 303      at the data structure it scans every so often... */
 304   printk ("%s: stopping timer\n", dev->name);
 305   eql->timer_on = 0;
 306   del_timer (&eql->timer);
 307 
 308   eql_delete_slave_queue (eql->queue);
 309 
 310   return 0;
 311 }
 312 
 313 
 314 static
 315 int
 316 eql_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
     /*  */
 317 {  
 318   if(!suser() && cmd!=EQL_GETMASTRCFG && cmd!=EQL_GETSLAVECFG)
 319         return -EPERM;
 320   switch (cmd)
 321     {
 322     case EQL_ENSLAVE:
 323       return eql_enslave (dev, (slaving_request_t *) ifr->ifr_data);
 324     case EQL_EMANCIPATE:
 325       return eql_emancipate (dev, (slaving_request_t *) ifr->ifr_data);
 326 
 327     case EQL_GETSLAVECFG:
 328       return eql_g_slave_cfg (dev, (slave_config_t *) ifr->ifr_data);
 329     case EQL_SETSLAVECFG:
 330       return eql_s_slave_cfg (dev, (slave_config_t *) ifr->ifr_data);
 331 
 332     case EQL_GETMASTRCFG:
 333       return eql_g_master_cfg (dev, (master_config_t *) ifr->ifr_data);
 334     case EQL_SETMASTRCFG:
 335       return eql_s_master_cfg (dev, (master_config_t *) ifr->ifr_data);
 336 
 337     default:
 338       return -EOPNOTSUPP;
 339     }
 340 }
 341 
 342 
 343 static
 344 int
 345 eql_slave_xmit(struct sk_buff *skb, struct device *dev)
     /*  */
 346 {
 347   equalizer_t *eql = (equalizer_t *) dev->priv;
 348   struct device *slave_dev = 0;
 349   slave_t *slave;
 350 
 351   if (skb == NULL)
 352     {
 353       return 0;
 354     }
 355 
 356   eql_schedule_slaves (eql->queue);
 357   
 358   slave_dev = eql_best_slave_dev (eql->queue);
 359   slave = eql_best_slave (eql->queue); 
 360 
 361   if ( slave_dev != 0 )
 362     {
 363 #ifdef EQL_DEBUG
 364       if (eql_debug >= 100)
 365         printk ("%s: %d slaves xmitng %ld B %s\n", 
 366                 dev->name, eql_number_slaves (eql->queue), skb->len,
 367                 slave_dev->name);
 368 #endif
 369       
 370       dev_queue_xmit (skb, slave_dev, 1);
 371       eql->stats->tx_packets++;
 372       slave->bytes_queued += skb->len; 
 373     }
 374   else
 375     {
 376       /* The alternative for this is the return 1 and have
 377          dev_queue_xmit just queue it up on the eql's queue. */
 378 
 379       eql->stats->tx_dropped++;
 380       dev_kfree_skb(skb, FREE_WRITE);
 381     }     
 382   return 0;
 383 }
 384 
 385 
 386 static
 387 struct enet_statistics *
 388 eql_get_stats(struct device *dev)
     /*  */
 389 {
 390   equalizer_t *eql = (equalizer_t *) dev->priv;
 391 
 392   return eql->stats;
 393 }
 394 
 395 
 396 static 
 397 int 
 398 eql_header(unsigned char *buff, struct device *dev, 
     /*  */
 399            unsigned short type, void *daddr, void *saddr, 
 400            unsigned len, struct sk_buff *skb)
 401 {
 402   return 0;
 403 }
 404 
 405 
 406 static 
 407 int 
 408 eql_rebuild_header(void *buff, struct device *dev, 
     /*  */
 409                    unsigned long raddr, struct sk_buff *skb)
 410 {
 411   return 0;
 412 }
 413 
 414 
 415 
 416 
 417 /* private ioctl functions
 418    -----------------------------------------------------------------
 419    */
 420 
 421 static int 
 422 eql_enslave(struct device *dev, slaving_request_t *srqp)
     /*  */
 423 {
 424   struct device *master_dev;
 425   struct device *slave_dev;
 426   slaving_request_t srq;
 427 
 428   memcpy_fromfs (&srq, srqp, sizeof (slaving_request_t));
 429 
 430 #ifdef EQL_DEBUG
 431   if (eql_debug >= 20)
 432     printk ("%s: enslave '%s' %ld bps\n", dev->name, 
 433             srq.slave_name, srq.priority);
 434 #endif
 435   
 436   master_dev = dev;             /* for "clarity" */
 437   slave_dev  = dev_get (srq.slave_name);
 438 
 439   if (master_dev != 0 && slave_dev != 0)
 440     {
 441       if (! eql_is_master (slave_dev)  &&   /* slave is not a master */
 442           ! eql_is_slave (slave_dev)      ) /* slave is not already a slave */
 443         {
 444           slave_t *s = eql_new_slave ();
 445           equalizer_t *eql = (equalizer_t *) master_dev->priv;
 446 
 447           s->dev = slave_dev;
 448           s->priority = srq.priority;
 449           s->priority_bps = srq.priority;
 450           s->priority_Bps = srq.priority / 8;
 451 
 452           slave_dev->flags |= IFF_SLAVE;
 453 
 454           eql_insert_slave (eql->queue, s);
 455 
 456           return 0;
 457         }
 458       return -EINVAL;
 459     }
 460   return -EINVAL;
 461 }
 462 
 463 
 464 
 465 static 
 466 int 
 467 eql_emancipate(struct device *dev, slaving_request_t *srqp)
     /*  */
 468 {
 469   struct device *master_dev;
 470   struct device *slave_dev;
 471   slaving_request_t srq;
 472 
 473   memcpy_fromfs (&srq, srqp, sizeof (slaving_request_t));
 474 
 475 #ifdef EQL_DEBUG
 476   if (eql_debug >= 20)
 477     printk ("%s: emancipate `%s`\n", dev->name, srq.slave_name);
 478 #endif
 479 
 480 
 481   master_dev = dev;             /* for "clarity" */
 482   slave_dev  = dev_get (srq.slave_name);
 483 
 484   if ( eql_is_slave (slave_dev) )       /* really is a slave */
 485     {
 486       equalizer_t *eql = (equalizer_t *) master_dev->priv;
 487       slave_dev->flags = slave_dev->flags & ~IFF_SLAVE;
 488 
 489       eql_remove_slave_dev (eql->queue, slave_dev);
 490 
 491       return 0;
 492     }
 493   return -EINVAL;
 494 }
 495 
 496 
 497 static 
 498 int 
 499 eql_g_slave_cfg(struct device *dev, slave_config_t *scp)
     /*  */
 500 {
 501   slave_t *slave;
 502   equalizer_t *eql;
 503   struct device *slave_dev;
 504   slave_config_t sc;
 505 
 506   memcpy_fromfs (&sc, scp, sizeof (slave_config_t));
 507 
 508 #ifdef EQL_DEBUG
 509   if (eql_debug >= 20)
 510     printk ("%s: get config for slave `%s'\n", dev->name, sc.slave_name);
 511 #endif
 512 
 513   eql = (equalizer_t *) dev->priv;
 514   slave_dev = dev_get (sc.slave_name);
 515 
 516   if ( eql_is_slave (slave_dev) )
 517     {
 518       slave = eql_find_slave_dev (eql->queue,  slave_dev);
 519       if (slave != 0)
 520         {
 521           sc.priority = slave->priority;
 522           memcpy_tofs (scp, &sc, sizeof (slave_config_t));
 523           return 0;
 524         }
 525     }
 526   return -EINVAL;
 527 }
 528 
 529 
 530 static 
 531 int 
 532 eql_s_slave_cfg(struct device *dev, slave_config_t *scp)
     /*  */
 533 {
 534   slave_t *slave;
 535   equalizer_t *eql;
 536   struct device *slave_dev;
 537   slave_config_t sc;
 538 
 539 #ifdef EQL_DEBUG
 540   if (eql_debug >= 20)
 541     printk ("%s: set config for slave `%s'\n", dev->name, sc.slave_name);
 542 #endif
 543   
 544   memcpy_fromfs (&sc, scp, sizeof (slave_config_t));
 545 
 546   eql = (equalizer_t *) dev->priv;
 547   slave_dev = dev_get (sc.slave_name);
 548 
 549   if ( eql_is_slave (slave_dev) )
 550     {
 551       slave = eql_find_slave_dev (eql->queue, slave_dev);
 552       if (slave != 0)
 553         {
 554           slave->priority = sc.priority;
 555           slave->priority_bps = sc.priority;
 556           slave->priority_Bps = sc.priority / 8;
 557           return 0;
 558         }
 559     }
 560   return -EINVAL;
 561 }
 562 
 563 
 564 static 
 565 int 
 566 eql_g_master_cfg(struct device *dev, master_config_t *mcp)
     /*  */
 567 {
 568   equalizer_t *eql;
 569   master_config_t mc;
 570 
 571 #if EQL_DEBUG
 572   if (eql_debug >= 20)
 573     printk ("%s: get master config\n", dev->name);
 574 #endif
 575 
 576   if ( eql_is_master (dev) )
 577     {
 578       eql = (equalizer_t *) dev->priv;
 579       mc.max_slaves = eql->max_slaves;
 580       mc.min_slaves = eql->min_slaves;
 581       memcpy_tofs (mcp, &mc, sizeof (master_config_t));
 582       return 0;
 583     }
 584   return -EINVAL;
 585 }
 586 
 587 
 588 static 
 589 int 
 590 eql_s_master_cfg(struct device *dev, master_config_t *mcp)
     /*  */
 591 {
 592   equalizer_t *eql;
 593   master_config_t mc;
 594 
 595 #if EQL_DEBUG
 596   if (eql_debug >= 20)
 597     printk ("%s: set master config\n", dev->name);
 598 #endif
 599 
 600   memcpy_fromfs (&mc, mcp, sizeof (master_config_t));
 601 
 602   if ( eql_is_master (dev) )
 603     {
 604       eql = (equalizer_t *) dev->priv;
 605       eql->max_slaves = mc.max_slaves;
 606       eql->min_slaves = mc.min_slaves;
 607       return 0;
 608     }
 609   return -EINVAL;
 610 }
 611 
 612 /* private device support functions
 613    ------------------------------------------------------------------
 614    */
 615 
 616 static inline
 617 int 
 618 eql_is_slave(struct device *dev)
     /*  */
 619 {
 620   if (dev)
 621     {
 622       if ((dev->flags & IFF_SLAVE) == IFF_SLAVE)
 623         return 1;
 624     }
 625   return 0;
 626 }
 627 
 628 
 629 static inline
 630 int 
 631 eql_is_master(struct device *dev)
     /*  */
 632 {
 633   if (dev)
 634     {
 635       if ((dev->flags & IFF_MASTER) == IFF_MASTER)
 636         return 1;
 637     }
 638   return 0;
 639 }
 640 
 641 
 642 static 
 643 slave_t *
 644 eql_new_slave(void)
     /*  */
 645 {
 646   slave_t *slave;
 647 
 648   slave = (slave_t *) kmalloc (sizeof (slave_t), GFP_KERNEL);
 649   if (slave)
 650     {
 651       memset(slave, 0, sizeof (slave_t));
 652       return slave;
 653     }
 654   return 0;
 655 }
 656 
 657 
 658 static 
 659 void
 660 eql_delete_slave(slave_t *slave)
     /*  */
 661 {
 662   kfree (slave);
 663 }
 664 
 665 
 666 #if 0                           /* not currently used, will be used
 667                                    when we realy use a priority queue */
 668 static
 669 long
 670 slave_Bps(slave_t *slave)
     /*  */
 671 {
 672   return (slave->priority_Bps);
 673 }
 674 
 675 static 
 676 long
 677 slave_bps(slave_t *slave)
     /*  */
 678 {
 679   return (slave->priority_bps);
 680 }
 681 #endif
 682 
 683 
 684 static inline
 685 int 
 686 eql_number_slaves(slave_queue_t *queue)
     /*  */
 687 {
 688   return queue->num_slaves;
 689 }
 690 
 691 
 692 static inline 
 693 int 
 694 eql_is_empty(slave_queue_t *queue)
     /*  */
 695 {
 696   if (eql_number_slaves (queue) == 0)
 697     return 1;
 698   return 0;
 699 }
 700 
 701 
 702 static inline
 703 int 
 704 eql_is_full(slave_queue_t *queue)
     /*  */
 705 {
 706   equalizer_t *eql = (equalizer_t *) queue->master_dev->priv;
 707 
 708   if (eql_number_slaves (queue) == eql->max_slaves)
 709     return 1;
 710   return 0;
 711 }
 712 
 713 
 714 static
 715 slave_queue_t *
 716 eql_new_slave_queue(struct device *dev)
     /*  */
 717 {
 718   slave_queue_t *queue;
 719   slave_t *head_slave;
 720   slave_t *tail_slave;
 721 
 722   queue = (slave_queue_t *) kmalloc (sizeof (slave_queue_t), GFP_KERNEL);
 723   memset (queue, 0, sizeof (slave_queue_t));
 724 
 725   head_slave = eql_new_slave ();
 726   tail_slave = eql_new_slave ();
 727   
 728   if ( head_slave != 0 &&
 729        tail_slave != 0 )
 730     {
 731       head_slave->next = tail_slave;
 732       tail_slave->next = 0;
 733       queue->head = head_slave;
 734       queue->num_slaves = 0;
 735       queue->master_dev = dev;
 736     }
 737   else
 738     {
 739       kfree (queue);
 740       return 0;
 741     }
 742   return queue;
 743 }
 744 
 745 
 746 static
 747 void
 748 eql_delete_slave_queue(slave_queue_t *queue)
     /*  */
 749 { 
 750   slave_t *zapped;
 751 
 752   /* this should only be called when there isn't a timer running that scans
 753      the data periodicaly.. dev_close stops the timer... */
 754 
 755   while ( ! eql_is_empty (queue) )
 756     {
 757       zapped = eql_remove_slave (queue, queue->head->next);
 758       eql_delete_slave (zapped);
 759     }
 760   kfree (queue->head->next);
 761   kfree (queue->head);
 762   kfree (queue);
 763 }
 764 
 765 
 766 static
 767 int
 768 eql_insert_slave(slave_queue_t *queue, slave_t *slave)
     /*  */
 769 {
 770   cli ();
 771 
 772   if ( ! eql_is_full (queue) )
 773     {
 774       slave_t *duplicate_slave = 0;
 775 
 776       duplicate_slave = eql_find_slave_dev (queue, slave->dev);
 777 
 778       if (duplicate_slave != 0)
 779         {
 780 /*        printk ("%s: found a duplicate, killing it and replacing\n",
 781                   queue->master_dev->name); */
 782           eql_delete_slave (eql_remove_slave (queue, duplicate_slave));
 783         }
 784 
 785       slave->next = queue->head->next;
 786       queue->head->next = slave;
 787       queue->num_slaves++;
 788       sti ();
 789       return 0;
 790     }
 791 
 792   sti ();
 793 
 794   return 1;
 795 }
 796 
 797 
 798 static
 799 slave_t *
 800 eql_remove_slave(slave_queue_t *queue, slave_t *slave)
     /*  */
 801 {
 802   slave_t *prev;
 803   slave_t *current;
 804 
 805   cli ();
 806 
 807   prev = queue->head;
 808   current = queue->head->next;
 809   while (current != slave && 
 810          current->dev != 0 )
 811     {
 812 /* printk ("%s: remove_slave; searching...\n", queue->master_dev->name); */
 813       prev = current;
 814       current = current->next;
 815     }
 816 
 817   if (current == slave)
 818     {
 819       prev->next = current->next;
 820       queue->num_slaves--;
 821       return current;
 822     }
 823 
 824   sti ();
 825 
 826   return 0;                     /* not found */
 827 }
 828 
 829 
 830 #if 0
 831 static 
 832 int 
 833 eql_insert_slave_dev(slave_queue_t *queue, struct device *dev)
     /*  */
 834 {
 835   slave_t *slave;
 836 
 837   cli ();
 838 
 839   if ( ! eql_is_full (queue) )
 840     {
 841       slave = eql_new_slave ();
 842       slave->dev = dev;
 843       slave->priority = EQL_DEFAULT_SLAVE_PRIORITY;
 844       slave->priority_bps = EQL_DEFAULT_SLAVE_PRIORITY;
 845       slave->priority_Bps = EQL_DEFAULT_SLAVE_PRIORITY / 8;
 846       slave->next = queue->head->next;
 847       queue->head->next = slave;
 848       sti ();
 849       return 0;
 850     }
 851   sti ();
 852   return 1;
 853 }
 854 #endif
 855 
 856 
 857 static
 858 int
 859 eql_remove_slave_dev(slave_queue_t *queue, struct device *dev)
     /*  */
 860 {
 861   slave_t *prev;
 862   slave_t *current;
 863   slave_t *target;
 864 
 865   target = eql_find_slave_dev (queue, dev);
 866 
 867   if (target != 0)
 868     {
 869       cli ();
 870 
 871       prev = queue->head;
 872       current = prev->next;
 873       while (current != target)
 874         {
 875           prev = current;
 876           current = current->next;
 877         }
 878       prev->next = current->next;
 879       queue->num_slaves--;
 880 
 881       sti ();
 882 
 883       eql_delete_slave (current);
 884       return 0;
 885     }
 886   return 1;
 887 }
 888 
 889 
 890 static inline
 891 struct device *
 892 eql_best_slave_dev(slave_queue_t *queue)
     /*  */
 893 {
 894   if (queue->best_slave != 0)
 895     {
 896       if (queue->best_slave->dev != 0)
 897         return queue->best_slave->dev;
 898       else
 899         return 0;
 900     }
 901   else
 902     return 0;
 903 }
 904 
 905 
 906 static inline
 907 slave_t *
 908 eql_best_slave(slave_queue_t *queue)
     /*  */
 909 {
 910   return queue->best_slave;
 911 }
 912 
 913 static inline
 914 void
 915 eql_schedule_slaves(slave_queue_t *queue)
     /*  */
 916 {
 917   struct device *master_dev = queue->master_dev;
 918   slave_t *best_slave = 0;
 919   slave_t *slave_corpse = 0;
 920 
 921 #ifdef EQL_DEBUG
 922   if (eql_debug >= 100)
 923     printk ("%s: schedule %d slaves\n", 
 924             master_dev->name, eql_number_slaves (queue));
 925 #endif
 926 
 927   if ( eql_is_empty (queue) )
 928     {
 929       /* no slaves to play with */
 930       eql_set_best_slave (queue, (slave_t *) 0);
 931       return;
 932     }
 933   else
 934     {                           /* make a pass to set the best slave */
 935       unsigned long best_load = (unsigned long) ULONG_MAX;
 936       slave_t *slave = 0;
 937       int i;
 938 
 939       cli ();
 940 
 941       for (i = 1, slave = eql_first_slave (queue);
 942            i <= eql_number_slaves (queue);
 943            i++, slave = eql_next_slave (queue, slave))
 944         {
 945           /* go through the slave list once, updating best_slave 
 946              whenever a new best_load is found, whenever a dead
 947              slave is found, it is marked to be pulled out of the 
 948              queue */
 949 
 950           unsigned long slave_load;
 951           unsigned long bytes_queued; 
 952           unsigned long priority_Bps; 
 953           
 954           if (slave != 0)
 955             {
 956               bytes_queued = slave->bytes_queued;
 957               priority_Bps = slave->priority_Bps;    
 958 
 959               if ( slave->dev != 0)
 960                 {
 961                   if ((slave->dev->flags & IFF_UP) == IFF_UP )
 962                     {
 963                       slave_load = (ULONG_MAX - (ULONG_MAX / 2)) - 
 964                         (priority_Bps) + bytes_queued * 8;
 965                       
 966                       if (slave_load < best_load)
 967                         {
 968                           best_load = slave_load;
 969                           best_slave = slave;
 970                         }
 971                     }
 972                   else          /* we found a dead slave */
 973                     {
 974                       /* we only bury one slave at a time, if more than
 975                          one slave dies, we will bury him on the next 
 976                          reschedule. slaves don't die all at once that much
 977                          anyway */
 978                       slave_corpse = slave;
 979                     }
 980                 }
 981             }
 982         } /* for */
 983 
 984            sti ();
 985            
 986       eql_set_best_slave (queue, best_slave);
 987     } /* else */
 988 
 989   if (slave_corpse != 0)
 990     {
 991       printk ("eql: scheduler found dead slave, burying...\n");
 992       eql_delete_slave (eql_remove_slave (queue, slave_corpse));
 993     }
 994 
 995   return;
 996 }
 997 
 998 
 999 static
1000 slave_t *
1001 eql_find_slave_dev(slave_queue_t *queue, struct device *dev)
     /*  */
1002 {
1003   slave_t *slave = 0;
1004 
1005   slave = eql_first_slave(queue);
1006 
1007   while (slave != 0 && slave->dev != dev && slave != 0)
1008     {
1009 #if 0
1010       if (slave->dev != 0)
1011         printk ("eql: find_slave_dev; looked at '%s'...\n", slave->dev->name);
1012       else
1013         printk ("eql: find_slave_dev; looked at nothing...\n");
1014 #endif
1015 
1016       slave = slave->next;
1017     }
1018 
1019   return slave;
1020 }
1021 
1022 
1023 static inline
1024 slave_t *
1025 eql_first_slave(slave_queue_t *queue)
     /*  */
1026 {
1027   return queue->head->next;
1028 }
1029 
1030 
1031 static inline
1032 slave_t *
1033 eql_next_slave(slave_queue_t *queue, slave_t *slave)
     /*  */
1034 {
1035   return slave->next;
1036 }
1037 
1038 
1039 static inline
1040 void
1041 eql_set_best_slave(slave_queue_t *queue, slave_t *slave)
     /*  */
1042 {
1043   queue->best_slave = slave;
1044 }
1045 
1046 
1047 #if 0
1048 static inline
1049 int
1050 eql_lock_slave_queue(slave_queue_t *queue)
     /*  */
1051 {
1052   int result = 0;
1053 
1054   printk ("eql: lock == %d\n", queue->lock);
1055   if (queue->lock)
1056     {
1057       printk ("eql: lock_slave-q sleeping for lock\n");
1058       sleep_on (&eql_queue_lock);
1059       printk ("eql: lock_slave-q woken up\n");
1060       queue->lock = 1;
1061     }
1062   queue->lock = 1;
1063   return result;
1064 }
1065 
1066 static inline
1067 int
1068 eql_unlock_slave_queue(slave_queue_t *queue)
     /*  */
1069 {
1070   int result = 0;
1071 
1072   if (queue->lock != 0)
1073     {
1074       queue->lock = 0;
1075       printk ("eql: unlock_slave-q waking up lock waiters\n");
1076       wake_up (&eql_queue_lock);
1077     }
1078   return result;
1079 }
1080 #endif 
1081 
1082 static inline
1083 int
1084 eql_is_locked_slave_queue(slave_queue_t *queue)
     /*  */
1085 {
1086   return test_bit(1, (void *) &queue->lock);
1087 }
1088 
1089 static 
1090 void
1091 eql_timer(unsigned long param)
     /*  */
1092 {
1093   equalizer_t *eql = (equalizer_t *) param;
1094   slave_t *slave;
1095   slave_t *slave_corpse = 0;
1096   int i;
1097 
1098   if ( ! eql_is_empty (eql->queue) )
1099     {
1100       cli ();
1101 
1102       for (i = 1, slave = eql_first_slave (eql->queue);
1103            i <= eql_number_slaves (eql->queue);
1104            i++, slave = eql_next_slave (eql->queue, slave))
1105         {
1106           if (slave != 0)
1107             {
1108               if ((slave->dev->flags & IFF_UP) == IFF_UP )
1109                 {
1110                   slave->bytes_queued -= slave->priority_Bps;
1111               
1112                   if (slave->bytes_queued < 0)
1113                     slave->bytes_queued = 0;
1114                 }
1115               else
1116                 {
1117                   slave_corpse = slave;
1118                 }
1119             }
1120         }
1121 
1122       sti ();
1123       
1124       if (slave_corpse != 0)
1125         {
1126           printk ("eql: timer found dead slave, burying...\n");
1127           eql_delete_slave (eql_remove_slave (eql->queue, slave_corpse));
1128         }
1129 
1130     }
1131 
1132   if (eql->timer_on != 0) 
1133     {
1134       eql->timer.expires = EQL_DEFAULT_RESCHED_IVAL;
1135       add_timer (&eql->timer);
1136     }
1137 }
1138 
1139 /*
1140  * Local Variables: 
1141  * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c eql.c"
1142  * version-control: t
1143  * kept-new-versions: 20
1144  * End:
1145  */
/* */
root/drivers/net/eql.c

DEFINITIONS
