This source file includes following definitions.
- eql_init
- eql_open
- eql_close
- eql_ioctl
- eql_slave_xmit
- eql_get_stats
- eql_header
- eql_rebuild_header
- eql_enslave
- eql_emancipate
- eql_g_slave_cfg
- eql_s_slave_cfg
- eql_g_master_cfg
- eql_s_master_cfg
- eql_is_slave
- eql_is_master
- eql_new_slave
- eql_delete_slave
- slave_Bps
- slave_bps
- eql_number_slaves
- eql_is_empty
- eql_is_full
- eql_new_slave_queue
- eql_delete_slave_queue
- eql_insert_slave
- eql_remove_slave
- eql_insert_slave_dev
- eql_remove_slave_dev
- eql_best_slave_dev
- eql_best_slave
- eql_schedule_slaves
- eql_find_slave_dev
- eql_first_slave
- eql_next_slave
- eql_set_best_slave
- eql_lock_slave_queue
- eql_unlock_slave_queue
- eql_is_locked_slave_queue
- eql_timer
- init_module
- cleanup_module
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
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
136
137
138
139
140
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
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
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
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
201
202
203 static void eql_timer(unsigned long param);
204
205
206
207
208
209 int
210 eql_init(struct device *dev)
211 {
212 static unsigned version_printed = 0;
213
214 equalizer_t *eql = 0;
215 int i;
216
217 if ( version_printed++ == 0 && eql_debug > 0)
218 printk(version);
219
220
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
248
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
257 dev->mtu = EQL_DEFAULT_MTU;
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)
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;
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)
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
318
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)
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)
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
396
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)
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,
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,
428 unsigned long raddr, struct sk_buff *skb)
429 {
430 return 0;
431 }
432
433
434
435
436
437
438
439
440 static int
441 eql_enslave(struct device *dev, slaving_request_t *srqp)
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;
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) &&
465 ! eql_is_slave (slave_dev) )
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)
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;
509 slave_dev = dev_get (srq.slave_name);
510
511 if ( eql_is_slave (slave_dev) )
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)
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)
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)
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)
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
661
662
663
664 static inline
665 int
666 eql_is_slave(struct device *dev)
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)
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)
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)
709 {
710 kfree (slave);
711 }
712
713
714 #if 0
715
716 static
717 long
718 slave_Bps(slave_t *slave)
719 {
720 return (slave->priority_Bps);
721 }
722
723 static
724 long
725 slave_bps(slave_t *slave)
726 {
727 return (slave->priority_bps);
728 }
729 #endif
730
731
732 static inline
733 int
734 eql_number_slaves(slave_queue_t *queue)
735 {
736 return queue->num_slaves;
737 }
738
739
740 static inline
741 int
742 eql_is_empty(slave_queue_t *queue)
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)
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)
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)
803 {
804 slave_t *zapped;
805
806
807
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)
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
835
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)
855 {
856 slave_t *prev;
857 slave_t *curr;
858
859 cli ();
860
861 prev = queue->head;
862 curr = queue->head->next;
863 while (curr != slave &&
864 curr->dev != 0 )
865 {
866
867 prev = curr;
868 curr = curr->next;
869 }
870
871 if (curr == slave)
872 {
873 prev->next = curr->next;
874 queue->num_slaves--;
875 sti();
876 return curr;
877 }
878
879 sti ();
880
881 return 0;
882 }
883
884
885 #if 0
886 static
887 int
888 eql_insert_slave_dev(slave_queue_t *queue, struct device *dev)
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)
915 {
916 slave_t *prev;
917 slave_t *curr;
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 curr = prev->next;
928 while (curr != target)
929 {
930 prev = curr;
931 curr = curr->next;
932 }
933 prev->next = curr->next;
934 queue->num_slaves--;
935
936 sti ();
937
938 eql_delete_slave (curr);
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)
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)
964 {
965 return queue->best_slave;
966 }
967
968 static inline
969 void
970 eql_schedule_slaves(slave_queue_t *queue)
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
985 eql_set_best_slave (queue, (slave_t *) 0);
986 return;
987 }
988 else
989 {
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
1001
1002
1003
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
1028 {
1029
1030
1031
1032
1033 slave_corpse = slave;
1034 }
1035 }
1036 }
1037 }
1038
1039 sti ();
1040
1041 eql_set_best_slave (queue, best_slave);
1042 }
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)
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)
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)
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)
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)
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)
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)
1140 {
1141 return test_bit(1, (void *) &queue->lock);
1142 }
1143
1144 static
1145 void
1146 eql_timer(unsigned long param)
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)
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)
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
1219
1220
1221
1222
1223
1224
1225
1226