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