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_type_trans
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 static unsigned short eql_type_trans (struct sk_buff *skb, 
 153                                       struct device *dev);      /*  */
 154 
 155 /* ioctl() handlers
 156    ---------------- */
 157 static int eql_enslave(struct device *dev,  slaving_request_t *srq); /*  */
 158 static int eql_emancipate(struct device *dev, slaving_request_t *srq); /*  */
 159 
 160 static int eql_g_slave_cfg(struct device *dev, slave_config_t *sc); /*  */
 161 static int eql_s_slave_cfg(struct device *dev, slave_config_t *sc); /*  */
 162 
 163 static int eql_g_master_cfg(struct device *dev, master_config_t *mc); /*  */
 164 static int eql_s_master_cfg(struct device *dev, master_config_t *mc); /*  */
 165 
 166 static inline int eql_is_slave(struct device *dev); /*  */
 167 static inline int eql_is_master(struct device *dev); /*  */
 168 
 169 static slave_t *eql_new_slave(void); /*  */
 170 static void eql_delete_slave(slave_t *slave); /*  */
 171 
 172 /* static long eql_slave_priority(slave_t *slave); -*  */
 173 static inline int eql_number_slaves(slave_queue_t *queue); /*  */
 174 
 175 static inline int eql_is_empty(slave_queue_t *queue); /*  */
 176 static inline int eql_is_full(slave_queue_t *queue); /*  */
 177 
 178 static slave_queue_t *eql_new_slave_queue(struct device *dev); /*  */
 179 static void eql_delete_slave_queue(slave_queue_t *queue); /*  */
 180 
 181 static int eql_insert_slave(slave_queue_t *queue, slave_t *slave); /*  */
 182 static slave_t *eql_remove_slave(slave_queue_t *queue, slave_t *slave); /*  */
 183 
 184 /* static int eql_insert_slave_dev(slave_queue_t *queue, struct device *dev); -*  */
 185 static int eql_remove_slave_dev(slave_queue_t *queue, struct device *dev); /*  */
 186 
 187 static inline struct device *eql_best_slave_dev(slave_queue_t *queue); /*  */
 188 static inline slave_t *eql_best_slave(slave_queue_t *queue); /*  */
 189 static inline slave_t *eql_first_slave(slave_queue_t *queue); /*  */
 190 static inline slave_t *eql_next_slave(slave_queue_t *queue, slave_t *slave); /*  */
 191 
 192 static inline void eql_set_best_slave(slave_queue_t *queue, slave_t *slave); /*  */
 193 static inline void eql_schedule_slaves(slave_queue_t *queue); /*  */
 194 
 195 static slave_t *eql_find_slave_dev(slave_queue_t *queue, struct device *dev); /*  */
 196 
 197 /* static inline eql_lock_slave_queue(slave_queue_t *queue); -*  */
 198 /* static inline eql_unlock_slave_queue(slave_queue_t *queue); -*  */
 199 
 200 static void eql_timer(unsigned long param);     /*  */
 201 
 202 /* struct device * interface functions 
 203    ---------------------------------------------------------
 204    */
 205 
 206 int
 207 eql_init(struct device *dev)
     /*  */
 208 {
 209   static unsigned version_printed = 0;
 210   /* static unsigned num_masters     = 0; */
 211   equalizer_t *eql = 0;
 212   int i;
 213 
 214   if ( version_printed++ == 0 && eql_debug > 0)
 215     printk(version);
 216 
 217   /* Initialize the device structure. */
 218   dev->priv = kmalloc (sizeof (equalizer_t), GFP_KERNEL);
 219   memset (dev->priv, 0, sizeof (equalizer_t));
 220   eql = (equalizer_t *) dev->priv;
 221 
 222   eql->stats = kmalloc (sizeof (struct enet_statistics), GFP_KERNEL);
 223   memset (eql->stats, 0, sizeof (struct enet_statistics));
 224 
 225   init_timer (&eql->timer);
 226   eql->timer.data     = (unsigned long) dev->priv;
 227   eql->timer.expires  = EQL_DEFAULT_RESCHED_IVAL;
 228   eql->timer.function = &eql_timer;
 229   eql->timer_on       = 0;
 230 
 231   dev->open             = eql_open;
 232   dev->stop             = eql_close;
 233   dev->do_ioctl         = eql_ioctl;
 234   dev->hard_start_xmit  = eql_slave_xmit;
 235   dev->get_stats        = eql_get_stats;
 236   
 237   /* Fill in the fields of the device structure with ethernet-generic values.
 238      This should be in a common file instead of per-driver.  */
 239 
 240   for (i = 0; i < DEV_NUMBUFFS; i++)
 241     skb_queue_head_init(&dev->buffs[i]);
 242 
 243   dev->hard_header    = eql_header; 
 244   dev->rebuild_header = eql_rebuild_header;
 245 
 246   /* now we undo some of the things that eth_setup does that we don't like */
 247   dev->mtu        = EQL_DEFAULT_MTU;    /* set to 576 in eql.h */
 248   dev->flags      = IFF_MASTER;
 249 
 250   dev->family     = AF_INET;
 251   dev->pa_addr    = 0;
 252   dev->pa_brdaddr = 0;
 253   dev->pa_mask    = 0;
 254   dev->pa_alen    = sizeof (unsigned long);
 255 
 256   dev->type       = ARPHRD_SLIP;
 257 
 258   return 0;
 259 }
 260 
 261 
 262 static
 263 int
 264 eql_open(struct device *dev)
     /*  */
 265 {
 266   equalizer_t *eql = (equalizer_t *) dev->priv;
 267   slave_queue_t *new_queue;
 268 
 269 #ifdef EQL_DEBUG
 270   if (eql_debug >= 5)
 271     printk ("%s: open\n", dev->name);
 272 #endif
 273 
 274    new_queue = eql_new_slave_queue (dev);
 275     
 276     if (new_queue != 0)
 277       {
 278         new_queue->master_dev = dev;
 279         eql->queue = new_queue;
 280         eql->queue->lock = 0;
 281         eql->min_slaves = 1;
 282         eql->max_slaves = EQL_DEFAULT_MAX_SLAVES; /* 4 usually... */
 283 
 284         printk ("%s: adding timer\n", dev->name);
 285         eql->timer_on = 1;
 286         add_timer (&eql->timer);
 287 
 288         return 0;
 289       }
 290   return 1;
 291 }
 292 
 293 
 294 static
 295 int
 296 eql_close(struct device *dev)
     /*  */
 297 {
 298   equalizer_t *eql = (equalizer_t *) dev->priv;
 299 
 300 #ifdef EQL_DEBUG
 301   if ( eql_debug >= 5)
 302     printk ("%s: close\n", dev->name);
 303 #endif
 304   /* The timer has to be stopped first before we start hacking away
 305      at the data structure it scans every so often... */
 306   printk ("%s: stopping timer\n", dev->name);
 307   eql->timer_on = 0;
 308   del_timer (&eql->timer);
 309 
 310   eql_delete_slave_queue (eql->queue);
 311 
 312   return 0;
 313 }
 314 
 315 
 316 static
 317 int
 318 eql_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
     /*  */
 319 {  
 320   if(!suser() && cmd!=EQL_GETMASTRCFG && cmd!=EQL_GETSLAVECFG)
 321         return -EPERM;
 322   switch (cmd)
 323     {
 324     case EQL_ENSLAVE:
 325       return eql_enslave (dev, (slaving_request_t *) ifr->ifr_data);
 326     case EQL_EMANCIPATE:
 327       return eql_emancipate (dev, (slaving_request_t *) ifr->ifr_data);
 328 
 329     case EQL_GETSLAVECFG:
 330       return eql_g_slave_cfg (dev, (slave_config_t *) ifr->ifr_data);
 331     case EQL_SETSLAVECFG:
 332       return eql_s_slave_cfg (dev, (slave_config_t *) ifr->ifr_data);
 333 
 334     case EQL_GETMASTRCFG:
 335       return eql_g_master_cfg (dev, (master_config_t *) ifr->ifr_data);
 336     case EQL_SETMASTRCFG:
 337       return eql_s_master_cfg (dev, (master_config_t *) ifr->ifr_data);
 338 
 339     default:
 340       return -EOPNOTSUPP;
 341     }
 342 }
 343 
 344 
 345 static
 346 int
 347 eql_slave_xmit(struct sk_buff *skb, struct device *dev)
     /*  */
 348 {
 349   equalizer_t *eql = (equalizer_t *) dev->priv;
 350   struct device *slave_dev = 0;
 351   slave_t *slave;
 352 
 353   if (skb == NULL)
 354     {
 355       return 0;
 356     }
 357 
 358   eql_schedule_slaves (eql->queue);
 359   
 360   slave_dev = eql_best_slave_dev (eql->queue);
 361   slave = eql_best_slave (eql->queue); 
 362 
 363   if ( slave_dev != 0 )
 364     {
 365 #ifdef EQL_DEBUG
 366       if (eql_debug >= 100)
 367         printk ("%s: %d slaves xmitng %ld B %s\n", 
 368                 dev->name, eql_number_slaves (eql->queue), skb->len,
 369                 slave_dev->name);
 370 #endif
 371       
 372       dev_queue_xmit (skb, slave_dev, 1);
 373       eql->stats->tx_packets++;
 374       slave->bytes_queued += skb->len; 
 375     }
 376   else
 377     {
 378       /* The alternative for this is the return 1 and have
 379          dev_queue_xmit just queue it up on the eql's queue. */
 380 
 381       eql->stats->tx_dropped++;
 382       dev_kfree_skb(skb, FREE_WRITE);
 383     }     
 384   return 0;
 385 }
 386 
 387 
 388 static
 389 struct enet_statistics *
 390 eql_get_stats(struct device *dev)
     /*  */
 391 {
 392   equalizer_t *eql = (equalizer_t *) dev->priv;
 393 
 394   return eql->stats;
 395 }
 396 
 397 
 398 static 
 399 int 
 400 eql_header(unsigned char *buff, struct device *dev, 
     /*  */
 401            unsigned short type, void *daddr, void *saddr, 
 402            unsigned len, struct sk_buff *skb)
 403 {
 404   return 0;
 405 }
 406 
 407 
 408 static 
 409 int 
 410 eql_rebuild_header(void *buff, struct device *dev, 
     /*  */
 411                    unsigned long raddr, struct sk_buff *skb)
 412 {
 413   return 0;
 414 }
 415 
 416 
 417 static
 418 unsigned short 
 419 eql_type_trans (struct sk_buff *skb, struct device *dev)
     /*  */
 420 {
 421   return htons (ETH_P_IP);
 422 }
 423 
 424 
 425 /* private ioctl functions
 426    -----------------------------------------------------------------
 427    */
 428 
 429 static int 
 430 eql_enslave(struct device *dev, slaving_request_t *srqp)
     /*  */
 431 {
 432   struct device *master_dev;
 433   struct device *slave_dev;
 434   slaving_request_t srq;
 435 
 436   memcpy_fromfs (&srq, srqp, sizeof (slaving_request_t));
 437 
 438 #ifdef EQL_DEBUG
 439   if (eql_debug >= 20)
 440     printk ("%s: enslave '%s' %ld bps\n", dev->name, 
 441             srq.slave_name, srq.priority);
 442 #endif
 443   
 444   master_dev = dev;             /* for "clarity" */
 445   slave_dev  = dev_get (srq.slave_name);
 446 
 447   if (master_dev != 0 && slave_dev != 0)
 448     {
 449       if (! eql_is_master (slave_dev)  &&   /* slave is not a master */
 450           ! eql_is_slave (slave_dev)      ) /* slave is not already a slave */
 451         {
 452           slave_t *s = eql_new_slave ();
 453           equalizer_t *eql = (equalizer_t *) master_dev->priv;
 454 
 455           s->dev = slave_dev;
 456           s->priority = srq.priority;
 457           s->priority_bps = srq.priority;
 458           s->priority_Bps = srq.priority / 8;
 459 
 460           slave_dev->flags |= IFF_SLAVE;
 461 
 462           eql_insert_slave (eql->queue, s);
 463 
 464           return 0;
 465         }
 466       return -EINVAL;
 467     }
 468   return -EINVAL;
 469 }
 470 
 471 
 472 
 473 static 
 474 int 
 475 eql_emancipate(struct device *dev, slaving_request_t *srqp)
     /*  */
 476 {
 477   struct device *master_dev;
 478   struct device *slave_dev;
 479   slaving_request_t srq;
 480 
 481   memcpy_fromfs (&srq, srqp, sizeof (slaving_request_t));
 482 
 483 #ifdef EQL_DEBUG
 484   if (eql_debug >= 20)
 485     printk ("%s: emancipate `%s`\n", dev->name, srq.slave_name);
 486 #endif
 487 
 488 
 489   master_dev = dev;             /* for "clarity" */
 490   slave_dev  = dev_get (srq.slave_name);
 491 
 492   if ( eql_is_slave (slave_dev) )       /* really is a slave */
 493     {
 494       equalizer_t *eql = (equalizer_t *) master_dev->priv;
 495       slave_dev->flags = slave_dev->flags & ~IFF_SLAVE;
 496 
 497       eql_remove_slave_dev (eql->queue, slave_dev);
 498 
 499       return 0;
 500     }
 501   return -EINVAL;
 502 }
 503 
 504 
 505 static 
 506 int 
 507 eql_g_slave_cfg(struct device *dev, slave_config_t *scp)
     /*  */
 508 {
 509   slave_t *slave;
 510   equalizer_t *eql;
 511   struct device *slave_dev;
 512   slave_config_t sc;
 513 
 514   memcpy_fromfs (&sc, scp, sizeof (slave_config_t));
 515 
 516 #ifdef EQL_DEBUG
 517   if (eql_debug >= 20)
 518     printk ("%s: get config for slave `%s'\n", dev->name, sc.slave_name);
 519 #endif
 520 
 521   eql = (equalizer_t *) dev->priv;
 522   slave_dev = dev_get (sc.slave_name);
 523 
 524   if ( eql_is_slave (slave_dev) )
 525     {
 526       slave = eql_find_slave_dev (eql->queue,  slave_dev);
 527       if (slave != 0)
 528         {
 529           sc.priority = slave->priority;
 530           memcpy_tofs (scp, &sc, sizeof (slave_config_t));
 531           return 0;
 532         }
 533     }
 534   return -EINVAL;
 535 }
 536 
 537 
 538 static 
 539 int 
 540 eql_s_slave_cfg(struct device *dev, slave_config_t *scp)
     /*  */
 541 {
 542   slave_t *slave;
 543   equalizer_t *eql;
 544   struct device *slave_dev;
 545   slave_config_t sc;
 546 
 547 #ifdef EQL_DEBUG
 548   if (eql_debug >= 20)
 549     printk ("%s: set config for slave `%s'\n", dev->name, sc.slave_name);
 550 #endif
 551   
 552   memcpy_fromfs (&sc, scp, sizeof (slave_config_t));
 553 
 554   eql = (equalizer_t *) dev->priv;
 555   slave_dev = dev_get (sc.slave_name);
 556 
 557   if ( eql_is_slave (slave_dev) )
 558     {
 559       slave = eql_find_slave_dev (eql->queue, slave_dev);
 560       if (slave != 0)
 561         {
 562           slave->priority = sc.priority;
 563           slave->priority_bps = sc.priority;
 564           slave->priority_Bps = sc.priority / 8;
 565           return 0;
 566         }
 567     }
 568   return -EINVAL;
 569 }
 570 
 571 
 572 static 
 573 int 
 574 eql_g_master_cfg(struct device *dev, master_config_t *mcp)
     /*  */
 575 {
 576   equalizer_t *eql;
 577   master_config_t mc;
 578 
 579 #if EQL_DEBUG
 580   if (eql_debug >= 20)
 581     printk ("%s: get master config\n", dev->name);
 582 #endif
 583 
 584   if ( eql_is_master (dev) )
 585     {
 586       eql = (equalizer_t *) dev->priv;
 587       mc.max_slaves = eql->max_slaves;
 588       mc.min_slaves = eql->min_slaves;
 589       memcpy_tofs (mcp, &mc, sizeof (master_config_t));
 590       return 0;
 591     }
 592   return -EINVAL;
 593 }
 594 
 595 
 596 static 
 597 int 
 598 eql_s_master_cfg(struct device *dev, master_config_t *mcp)
     /*  */
 599 {
 600   equalizer_t *eql;
 601   master_config_t mc;
 602 
 603 #if EQL_DEBUG
 604   if (eql_debug >= 20)
 605     printk ("%s: set master config\n", dev->name);
 606 #endif
 607 
 608   memcpy_fromfs (&mc, mcp, sizeof (master_config_t));
 609 
 610   if ( eql_is_master (dev) )
 611     {
 612       eql = (equalizer_t *) dev->priv;
 613       eql->max_slaves = mc.max_slaves;
 614       eql->min_slaves = mc.min_slaves;
 615       return 0;
 616     }
 617   return -EINVAL;
 618 }
 619 
 620 /* private device support functions
 621    ------------------------------------------------------------------
 622    */
 623 
 624 static inline
 625 int 
 626 eql_is_slave(struct device *dev)
     /*  */
 627 {
 628   if (dev)
 629     {
 630       if ((dev->flags & IFF_SLAVE) == IFF_SLAVE)
 631         return 1;
 632     }
 633   return 0;
 634 }
 635 
 636 
 637 static inline
 638 int 
 639 eql_is_master(struct device *dev)
     /*  */
 640 {
 641   if (dev)
 642     {
 643       if ((dev->flags & IFF_MASTER) == IFF_MASTER)
 644         return 1;
 645     }
 646   return 0;
 647 }
 648 
 649 
 650 static 
 651 slave_t *
 652 eql_new_slave(void)
     /*  */
 653 {
 654   slave_t *slave;
 655 
 656   slave = (slave_t *) kmalloc (sizeof (slave_t), GFP_KERNEL);
 657   if (slave)
 658     {
 659       memset(slave, 0, sizeof (slave_t));
 660       return slave;
 661     }
 662   return 0;
 663 }
 664 
 665 
 666 static 
 667 void
 668 eql_delete_slave(slave_t *slave)
     /*  */
 669 {
 670   kfree (slave);
 671 }
 672 
 673 
 674 #if 0                           /* not currently used, will be used
 675                                    when we realy use a priority queue */
 676 static
 677 long
 678 slave_Bps(slave_t *slave)
     /*  */
 679 {
 680   return (slave->priority_Bps);
 681 }
 682 
 683 static 
 684 long
 685 slave_bps(slave_t *slave)
     /*  */
 686 {
 687   return (slave->priority_bps);
 688 }
 689 #endif
 690 
 691 
 692 static inline
 693 int 
 694 eql_number_slaves(slave_queue_t *queue)
     /*  */
 695 {
 696   return queue->num_slaves;
 697 }
 698 
 699 
 700 static inline 
 701 int 
 702 eql_is_empty(slave_queue_t *queue)
     /*  */
 703 {
 704   if (eql_number_slaves (queue) == 0)
 705     return 1;
 706   return 0;
 707 }
 708 
 709 
 710 static inline
 711 int 
 712 eql_is_full(slave_queue_t *queue)
     /*  */
 713 {
 714   equalizer_t *eql = (equalizer_t *) queue->master_dev->priv;
 715 
 716   if (eql_number_slaves (queue) == eql->max_slaves)
 717     return 1;
 718   return 0;
 719 }
 720 
 721 
 722 static
 723 slave_queue_t *
 724 eql_new_slave_queue(struct device *dev)
     /*  */
 725 {
 726   slave_queue_t *queue;
 727   slave_t *head_slave;
 728   slave_t *tail_slave;
 729 
 730   queue = (slave_queue_t *) kmalloc (sizeof (slave_queue_t), GFP_KERNEL);
 731   memset (queue, 0, sizeof (slave_queue_t));
 732 
 733   head_slave = eql_new_slave ();
 734   tail_slave = eql_new_slave ();
 735   
 736   if ( head_slave != 0 &&
 737        tail_slave != 0 )
 738     {
 739       head_slave->next = tail_slave;
 740       tail_slave->next = 0;
 741       queue->head = head_slave;
 742       queue->num_slaves = 0;
 743       queue->master_dev = dev;
 744     }
 745   else
 746     {
 747       kfree (queue);
 748       return 0;
 749     }
 750   return queue;
 751 }
 752 
 753 
 754 static
 755 void
 756 eql_delete_slave_queue(slave_queue_t *queue)
     /*  */
 757 { 
 758   slave_t *zapped;
 759 
 760   /* this should only be called when there isn't a timer running that scans
 761      the data periodicaly.. dev_close stops the timer... */
 762 
 763   while ( ! eql_is_empty (queue) )
 764     {
 765       zapped = eql_remove_slave (queue, queue->head->next);
 766       eql_delete_slave (zapped);
 767     }
 768   kfree (queue->head->next);
 769   kfree (queue->head);
 770   kfree (queue);
 771 }
 772 
 773 
 774 static
 775 int
 776 eql_insert_slave(slave_queue_t *queue, slave_t *slave)
     /*  */
 777 {
 778   cli ();
 779 
 780   if ( ! eql_is_full (queue) )
 781     {
 782       slave_t *duplicate_slave = 0;
 783 
 784       duplicate_slave = eql_find_slave_dev (queue, slave->dev);
 785 
 786       if (duplicate_slave != 0)
 787         {
 788 /*        printk ("%s: found a duplicate, killing it and replacing\n",
 789                   queue->master_dev->name); */
 790           eql_delete_slave (eql_remove_slave (queue, duplicate_slave));
 791         }
 792 
 793       slave->next = queue->head->next;
 794       queue->head->next = slave;
 795       queue->num_slaves++;
 796       sti ();
 797       return 0;
 798     }
 799 
 800   sti ();
 801 
 802   return 1;
 803 }
 804 
 805 
 806 static
 807 slave_t *
 808 eql_remove_slave(slave_queue_t *queue, slave_t *slave)
     /*  */
 809 {
 810   slave_t *prev;
 811   slave_t *current;
 812 
 813   cli ();
 814 
 815   prev = queue->head;
 816   current = queue->head->next;
 817   while (current != slave && 
 818          current->dev != 0 )
 819     {
 820 /* printk ("%s: remove_slave; searching...\n", queue->master_dev->name); */
 821       prev = current;
 822       current = current->next;
 823     }
 824 
 825   if (current == slave)
 826     {
 827       prev->next = current->next;
 828       queue->num_slaves--;
 829       return current;
 830     }
 831 
 832   sti ();
 833 
 834   return 0;                     /* not found */
 835 }
 836 
 837 
 838 #if 0
 839 static 
 840 int 
 841 eql_insert_slave_dev(slave_queue_t *queue, struct device *dev)
     /*  */
 842 {
 843   slave_t *slave;
 844 
 845   cli ();
 846 
 847   if ( ! eql_is_full (queue) )
 848     {
 849       slave = eql_new_slave ();
 850       slave->dev = dev;
 851       slave->priority = EQL_DEFAULT_SLAVE_PRIORITY;
 852       slave->priority_bps = EQL_DEFAULT_SLAVE_PRIORITY;
 853       slave->priority_Bps = EQL_DEFAULT_SLAVE_PRIORITY / 8;
 854       slave->next = queue->head->next;
 855       queue->head->next = slave;
 856       sti ();
 857       return 0;
 858     }
 859   sti ();
 860   return 1;
 861 }
 862 #endif
 863 
 864 
 865 static
 866 int
 867 eql_remove_slave_dev(slave_queue_t *queue, struct device *dev)
     /*  */
 868 {
 869   slave_t *prev;
 870   slave_t *current;
 871   slave_t *target;
 872 
 873   target = eql_find_slave_dev (queue, dev);
 874 
 875   if (target != 0)
 876     {
 877       cli ();
 878 
 879       prev = queue->head;
 880       current = prev->next;
 881       while (current != target)
 882         {
 883           prev = current;
 884           current = current->next;
 885         }
 886       prev->next = current->next;
 887       queue->num_slaves--;
 888 
 889       sti ();
 890 
 891       eql_delete_slave (current);
 892       return 0;
 893     }
 894   return 1;
 895 }
 896 
 897 
 898 static inline
 899 struct device *
 900 eql_best_slave_dev(slave_queue_t *queue)
     /*  */
 901 {
 902   if (queue->best_slave != 0)
 903     {
 904       if (queue->best_slave->dev != 0)
 905         return queue->best_slave->dev;
 906       else
 907         return 0;
 908     }
 909   else
 910     return 0;
 911 }
 912 
 913 
 914 static inline
 915 slave_t *
 916 eql_best_slave(slave_queue_t *queue)
     /*  */
 917 {
 918   return queue->best_slave;
 919 }
 920 
 921 static inline
 922 void
 923 eql_schedule_slaves(slave_queue_t *queue)
     /*  */
 924 {
 925   struct device *master_dev = queue->master_dev;
 926   slave_t *best_slave = 0;
 927   slave_t *slave_corpse = 0;
 928 
 929 #ifdef EQL_DEBUG
 930   if (eql_debug >= 100)
 931     printk ("%s: schedule %d slaves\n", 
 932             master_dev->name, eql_number_slaves (queue));
 933 #endif
 934 
 935   if ( eql_is_empty (queue) )
 936     {
 937       /* no slaves to play with */
 938       eql_set_best_slave (queue, (slave_t *) 0);
 939       return;
 940     }
 941   else
 942     {                           /* make a pass to set the best slave */
 943       unsigned long best_load = (unsigned long) ULONG_MAX;
 944       slave_t *slave = 0;
 945       int i;
 946 
 947       cli ();
 948 
 949       for (i = 1, slave = eql_first_slave (queue);
 950            i <= eql_number_slaves (queue);
 951            i++, slave = eql_next_slave (queue, slave))
 952         {
 953           /* go through the slave list once, updating best_slave 
 954              whenever a new best_load is found, whenever a dead
 955              slave is found, it is marked to be pulled out of the 
 956              queue */
 957 
 958           unsigned long slave_load;
 959           unsigned long bytes_queued; 
 960           unsigned long priority_Bps; 
 961           
 962           if (slave != 0)
 963             {
 964               bytes_queued = slave->bytes_queued;
 965               priority_Bps = slave->priority_Bps;    
 966 
 967               if ( slave->dev != 0)
 968                 {
 969                   if ( slave->dev->flags & IFF_UP == IFF_UP )
 970                     {
 971                       slave_load = (ULONG_MAX - (ULONG_MAX / 2)) - 
 972                         (priority_Bps) + bytes_queued * 8;
 973                       
 974                       if (slave_load < best_load)
 975                         {
 976                           best_load = slave_load;
 977                           best_slave = slave;
 978                         }
 979                     }
 980                   else          /* we found a dead slave */
 981                     {
 982                       /* we only bury one slave at a time, if more than
 983                          one slave dies, we will bury him on the next 
 984                          reschedule. slaves don't die all at once that much
 985                          anyway */
 986                       slave_corpse = slave;
 987                     }
 988                 }
 989             }
 990         } /* for */
 991 
 992            sti ();
 993            
 994       eql_set_best_slave (queue, best_slave);
 995     } /* else */
 996 
 997   if (slave_corpse != 0)
 998     {
 999       printk ("eql: scheduler found dead slave, burying...\n");
1000       eql_delete_slave (eql_remove_slave (queue, slave_corpse));
1001     }
1002 
1003   return;
1004 }
1005 
1006 
1007 static
1008 slave_t *
1009 eql_find_slave_dev(slave_queue_t *queue, struct device *dev)
     /*  */
1010 {
1011   slave_t *slave = 0;
1012 
1013   slave = eql_first_slave(queue);
1014 
1015   while (slave != 0 && slave->dev != dev && slave != 0)
1016     {
1017 #if 0
1018       if (slave->dev != 0)
1019         printk ("eql: find_slave_dev; looked at '%s'...\n", slave->dev->name);
1020       else
1021         printk ("eql: find_slave_dev; looked at nothing...\n");
1022 #endif
1023 
1024       slave = slave->next;
1025     }
1026 
1027   return slave;
1028 }
1029 
1030 
1031 static inline
1032 slave_t *
1033 eql_first_slave(slave_queue_t *queue)
     /*  */
1034 {
1035   return queue->head->next;
1036 }
1037 
1038 
1039 static inline
1040 slave_t *
1041 eql_next_slave(slave_queue_t *queue, slave_t *slave)
     /*  */
1042 {
1043   return slave->next;
1044 }
1045 
1046 
1047 static inline
1048 void
1049 eql_set_best_slave(slave_queue_t *queue, slave_t *slave)
     /*  */
1050 {
1051   queue->best_slave = slave;
1052 }
1053 
1054 
1055 #if 0
1056 static inline
1057 int
1058 eql_lock_slave_queue(slave_queue_t *queue)
     /*  */
1059 {
1060   int result = 0;
1061 
1062   printk ("eql: lock == %d\n", queue->lock);
1063   if (queue->lock)
1064     {
1065       printk ("eql: lock_slave-q sleeping for lock\n");
1066       sleep_on (&eql_queue_lock);
1067       printk ("eql: lock_slave-q woken up\n");
1068       queue->lock = 1;
1069     }
1070   queue->lock = 1;
1071   return result;
1072 }
1073 
1074 static inline
1075 int
1076 eql_unlock_slave_queue(slave_queue_t *queue)
     /*  */
1077 {
1078   int result = 0;
1079 
1080   if (queue->lock != 0)
1081     {
1082       queue->lock = 0;
1083       printk ("eql: unlock_slave-q waking up lock waiters\n");
1084       wake_up (&eql_queue_lock);
1085     }
1086   return result;
1087 }
1088 #endif 
1089 
1090 static inline
1091 int
1092 eql_is_locked_slave_queue(slave_queue_t *queue)
     /*  */
1093 {
1094   return test_bit(1, (void *) &queue->lock);
1095 }
1096 
1097 static 
1098 void
1099 eql_timer(unsigned long param)
     /*  */
1100 {
1101   equalizer_t *eql = (equalizer_t *) param;
1102   slave_t *slave;
1103   slave_t *slave_corpse = 0;
1104   int i;
1105 
1106   if ( ! eql_is_empty (eql->queue) )
1107     {
1108       cli ();
1109 
1110       for (i = 1, slave = eql_first_slave (eql->queue);
1111            i <= eql_number_slaves (eql->queue);
1112            i++, slave = eql_next_slave (eql->queue, slave))
1113         {
1114           if (slave != 0)
1115             {
1116               if ( slave->dev->flags & IFF_UP == IFF_UP )
1117                 {
1118                   slave->bytes_queued -= slave->priority_Bps;
1119               
1120                   if (slave->bytes_queued < 0)
1121                     slave->bytes_queued = 0;
1122                 }
1123               else
1124                 {
1125                   slave_corpse = slave;
1126                 }
1127             }
1128         }
1129 
1130       sti ();
1131       
1132       if (slave_corpse != 0)
1133         {
1134           printk ("eql: timer found dead slave, burying...\n");
1135           eql_delete_slave (eql_remove_slave (eql->queue, slave_corpse));
1136         }
1137 
1138     }
1139 
1140   if (eql->timer_on != 0) 
1141     {
1142       eql->timer.expires = EQL_DEFAULT_RESCHED_IVAL;
1143       add_timer (&eql->timer);
1144     }
1145 }
1146 
1147 /*
1148  * Local Variables: 
1149  * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c eql.c"
1150  * version-control: t
1151  * kept-new-versions: 20
1152  * End:
1153  */
/* */
root/drivers/net/eql.c

DEFINITIONS
