root/drivers/net/eql.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. eql_init
  2. eql_open
  3. eql_close
  4. eql_ioctl
  5. eql_slave_xmit
  6. eql_get_stats
  7. eql_header
  8. eql_rebuild_header
  9. eql_enslave
  10. eql_emancipate
  11. eql_g_slave_cfg
  12. eql_s_slave_cfg
  13. eql_g_master_cfg
  14. eql_s_master_cfg
  15. eql_is_slave
  16. eql_is_master
  17. eql_new_slave
  18. eql_delete_slave
  19. slave_Bps
  20. slave_bps
  21. eql_number_slaves
  22. eql_is_empty
  23. eql_is_full
  24. eql_new_slave_queue
  25. eql_delete_slave_queue
  26. eql_insert_slave
  27. eql_remove_slave
  28. eql_insert_slave_dev
  29. eql_remove_slave_dev
  30. eql_best_slave_dev
  31. eql_best_slave
  32. eql_schedule_slaves
  33. eql_find_slave_dev
  34. eql_first_slave
  35. eql_next_slave
  36. eql_set_best_slave
  37. eql_lock_slave_queue
  38. eql_unlock_slave_queue
  39. eql_is_locked_slave_queue
  40. eql_timer
  41. init_module
  42. cleanup_module

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

/* [previous][next][first][last][top][bottom][index][help] */