This source file includes following definitions.
- min
- dev_add_pack
- dev_remove_pack
- dev_get
- dev_load
- dev_open
- dev_close
- register_netdevice_notifier
- unregister_netdevice_notifier
- dev_queue_xmit
- netif_rx
- dev_transmit
- in_net_bh
- net_bh
- dev_tint
- dev_ifconf
- sprintf_stats
- dev_get_info
- bad_mask
- dev_ifsioc
- dev_ioctl
- net_dev_init
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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 #include <asm/segment.h>
50 #include <asm/system.h>
51 #include <asm/bitops.h>
52 #include <linux/config.h>
53 #include <linux/types.h>
54 #include <linux/kernel.h>
55 #include <linux/sched.h>
56 #include <linux/string.h>
57 #include <linux/mm.h>
58 #include <linux/socket.h>
59 #include <linux/sockios.h>
60 #include <linux/in.h>
61 #include <linux/errno.h>
62 #include <linux/interrupt.h>
63 #include <linux/if_ether.h>
64 #include <linux/inet.h>
65 #include <linux/netdevice.h>
66 #include <linux/etherdevice.h>
67 #include <linux/notifier.h>
68 #include <net/ip.h>
69 #include <net/route.h>
70 #include <linux/skbuff.h>
71 #include <net/sock.h>
72 #include <net/arp.h>
73 #include <net/slhc.h>
74 #include <linux/proc_fs.h>
75 #include <linux/stat.h>
76 #ifdef CONFIG_NET_ALIAS
77 #include <linux/net_alias.h>
78 #endif
79 #ifdef CONFIG_KERNELD
80 #include <linux/kerneld.h>
81 #endif
82
83
84
85
86
87
88 struct packet_type *ptype_base[16];
89 struct packet_type *ptype_all = NULL;
90
91
92
93
94
95 int dev_lockct=0;
96
97
98
99
100
101 struct notifier_block *netdev_chain=NULL;
102
103
104
105
106
107
108 static struct sk_buff_head backlog;
109
110
111
112
113
114 static int backlog_size = 0;
115
116
117
118
119
120 static __inline__ unsigned long min(unsigned long a, unsigned long b)
121 {
122 return (a < b)? a : b;
123 }
124
125
126
127
128
129
130
131
132
133
134
135
136 static int dev_nit=0;
137
138
139
140
141
142
143
144 void dev_add_pack(struct packet_type *pt)
145 {
146 int hash;
147 if(pt->type==htons(ETH_P_ALL))
148 {
149 dev_nit++;
150 pt->next=ptype_all;
151 ptype_all=pt;
152 }
153 else
154 {
155 hash=ntohs(pt->type)&15;
156 pt->next = ptype_base[hash];
157 ptype_base[hash] = pt;
158 }
159 }
160
161
162
163
164
165
166 void dev_remove_pack(struct packet_type *pt)
167 {
168 struct packet_type **pt1;
169 if(pt->type==htons(ETH_P_ALL))
170 {
171 dev_nit--;
172 pt1=&ptype_all;
173 }
174 else
175 pt1=&ptype_base[ntohs(pt->type)&15];
176 for(; (*pt1)!=NULL; pt1=&((*pt1)->next))
177 {
178 if(pt==(*pt1))
179 {
180 *pt1=pt->next;
181 return;
182 }
183 }
184 printk("dev_remove_pack: %p not found.\n", pt);
185 }
186
187
188
189
190
191
192
193
194
195
196
197 struct device *dev_get(const char *name)
198 {
199 struct device *dev;
200
201 for (dev = dev_base; dev != NULL; dev = dev->next)
202 {
203 if (strcmp(dev->name, name) == 0)
204 return(dev);
205 }
206 return NULL;
207 }
208
209
210
211
212
213 #ifdef CONFIG_KERNELD
214
215 extern __inline__ void dev_load(const char *name)
216 {
217 if(!dev_get(name))
218 request_module(name);
219 }
220
221 #endif
222
223
224
225
226
227 int dev_open(struct device *dev)
228 {
229 int ret = 0;
230
231
232
233
234 if (dev->open)
235 ret = dev->open(dev);
236
237
238
239
240
241 if (ret == 0)
242 {
243 dev->flags |= (IFF_UP | IFF_RUNNING);
244
245
246
247 dev_mc_upload(dev);
248 notifier_call_chain(&netdev_chain, NETDEV_UP, dev);
249 }
250 return(ret);
251 }
252
253
254
255
256
257
258 int dev_close(struct device *dev)
259 {
260 int ct=0;
261
262
263
264
265
266
267 if ((dev->flags & IFF_UP) && dev->stop)
268 dev->stop(dev);
269
270
271
272
273
274 dev->flags&=~(IFF_UP|IFF_RUNNING);
275
276
277
278
279 notifier_call_chain(&netdev_chain, NETDEV_DOWN, dev);
280
281
282
283 dev_mc_discard(dev);
284
285
286
287 dev->pa_addr = 0;
288 dev->pa_dstaddr = 0;
289 dev->pa_brdaddr = 0;
290 dev->pa_mask = 0;
291
292
293
294 while(ct<DEV_NUMBUFFS)
295 {
296 struct sk_buff *skb;
297 while((skb=skb_dequeue(&dev->buffs[ct]))!=NULL)
298 if(skb->free)
299 kfree_skb(skb,FREE_WRITE);
300 ct++;
301 }
302 return(0);
303 }
304
305
306
307
308
309
310
311 int register_netdevice_notifier(struct notifier_block *nb)
312 {
313 return notifier_chain_register(&netdev_chain, nb);
314 }
315
316 int unregister_netdevice_notifier(struct notifier_block *nb)
317 {
318 return notifier_chain_unregister(&netdev_chain,nb);
319 }
320
321
322
323
324
325
326
327
328
329 void dev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
330 {
331 unsigned long flags;
332 struct packet_type *ptype;
333 int where = 0;
334
335
336
337 if(pri>=0 && !skb_device_locked(skb))
338 skb_device_lock(skb);
339 #if CONFIG_SKB_CHECK
340 IS_SKB(skb);
341 #endif
342 skb->dev = dev;
343
344
345
346
347
348
349
350 if (pri < 0)
351 {
352 pri = -pri-1;
353 where = 1;
354 }
355
356 #ifdef CONFIG_NET_DEBUG
357 if (pri >= DEV_NUMBUFFS)
358 {
359 printk("bad priority in dev_queue_xmit.\n");
360 pri = 1;
361 }
362 #endif
363
364
365
366
367
368
369 if (!skb->arp && dev->rebuild_header(skb->data, dev, skb->raddr, skb)) {
370 return;
371 }
372
373
374
375
376
377
378
379
380
381 #ifdef CONFIG_NET_ALIAS
382 if (net_alias_is(dev))
383 skb->dev = dev = net_alias_main_dev(dev);
384 #endif
385
386 save_flags(flags);
387 cli();
388 if (!where)
389
390 {
391
392
393
394
395 if(skb_queue_len(dev->buffs + pri) > dev->tx_queue_len)
396 {
397 dev_kfree_skb(skb, FREE_WRITE);
398 return;
399 }
400 skb_queue_tail(dev->buffs + pri,skb);
401 skb_device_unlock(skb);
402 skb = skb_dequeue(dev->buffs + pri);
403 skb_device_lock(skb);
404 }
405 restore_flags(flags);
406
407
408 if(!where && dev_nit)
409 {
410 skb->stamp=xtime;
411 for (ptype = ptype_all; ptype!=NULL; ptype = ptype->next)
412 {
413
414
415
416 if ((ptype->dev == dev || !ptype->dev) &&
417 ((struct sock *)ptype->data != skb->sk))
418 {
419 struct sk_buff *skb2;
420 if ((skb2 = skb_clone(skb, GFP_ATOMIC)) == NULL)
421 break;
422 skb2->h.raw = skb2->data + dev->hard_header_len;
423 skb2->mac.raw = skb2->data;
424 ptype->func(skb2, skb->dev, ptype);
425 }
426 }
427 }
428 start_bh_atomic();
429 if (dev->hard_start_xmit(skb, dev) == 0) {
430
431
432
433 end_bh_atomic();
434 return;
435 }
436 end_bh_atomic();
437
438
439
440
441
442 cli();
443 skb_device_unlock(skb);
444 skb_queue_head(dev->buffs + pri,skb);
445 restore_flags(flags);
446 }
447
448
449
450
451
452
453
454 void netif_rx(struct sk_buff *skb)
455 {
456 static int dropping = 0;
457
458
459
460
461
462
463
464 skb->sk = NULL;
465 skb->free = 1;
466 if(skb->stamp.tv_sec==0)
467 skb->stamp = xtime;
468
469
470
471
472
473 if (!backlog_size)
474 dropping = 0;
475 else if (backlog_size > 300)
476 dropping = 1;
477
478 if (dropping)
479 {
480 kfree_skb(skb, FREE_READ);
481 return;
482 }
483
484
485
486
487 #if CONFIG_SKB_CHECK
488 IS_SKB(skb);
489 #endif
490 skb_queue_tail(&backlog,skb);
491 backlog_size++;
492
493
494
495
496
497
498 #ifdef CONFIG_NET_RUNONIRQ
499 net_bh();
500 #else
501 mark_bh(NET_BH);
502 #endif
503 return;
504 }
505
506
507
508
509
510 void dev_transmit(void)
511 {
512 struct device *dev;
513
514 for (dev = dev_base; dev != NULL; dev = dev->next)
515 {
516 if (dev->flags != 0 && !dev->tbusy) {
517
518
519
520 dev_tint(dev);
521 }
522 }
523 }
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538 volatile unsigned long in_bh = 0;
539
540 int in_net_bh()
541 {
542 return(in_bh==0?0:1);
543 }
544
545
546
547
548
549
550
551
552
553 void net_bh(void *tmp)
554 {
555 struct sk_buff *skb;
556 struct packet_type *ptype;
557 struct packet_type *pt_prev;
558 unsigned short type;
559
560
561
562
563
564 if (set_bit(1, (void*)&in_bh))
565 return;
566
567
568
569
570
571
572
573
574 dev_transmit();
575
576
577
578
579
580
581
582 cli();
583
584
585
586
587
588 while((skb=skb_dequeue(&backlog))!=NULL)
589 {
590
591
592
593 backlog_size--;
594
595 sti();
596
597
598
599
600
601
602
603
604 skb->h.raw = skb->data;
605
606
607
608
609
610 type = skb->protocol;
611
612
613
614
615
616
617 pt_prev = NULL;
618 for (ptype = ptype_all; ptype!=NULL; ptype=ptype->next)
619 {
620 if(pt_prev)
621 {
622 struct sk_buff *skb2=skb_clone(skb, GFP_ATOMIC);
623 if(skb2)
624 pt_prev->func(skb2,skb->dev, pt_prev);
625 }
626 pt_prev=ptype;
627 }
628
629 for (ptype = ptype_base[ntohs(type)&15]; ptype != NULL; ptype = ptype->next)
630 {
631 if (ptype->type == type && (!ptype->dev || ptype->dev==skb->dev))
632 {
633
634
635
636
637 if(pt_prev)
638 {
639 struct sk_buff *skb2;
640
641 skb2=skb_clone(skb, GFP_ATOMIC);
642
643
644
645
646
647
648 if(skb2)
649 pt_prev->func(skb2, skb->dev, pt_prev);
650 }
651
652 pt_prev=ptype;
653 }
654 }
655
656
657
658
659
660 if(pt_prev)
661 pt_prev->func(skb, skb->dev, pt_prev);
662
663
664
665
666 else
667 kfree_skb(skb, FREE_WRITE);
668
669
670
671
672
673
674 #ifdef CONFIG_XMIT_EVERY
675 dev_transmit();
676 #endif
677 cli();
678 }
679
680
681
682
683
684 in_bh = 0;
685 sti();
686
687
688
689
690
691 dev_transmit();
692 }
693
694
695
696
697
698
699
700 void dev_tint(struct device *dev)
701 {
702 int i;
703 struct sk_buff *skb;
704 unsigned long flags;
705
706
707
708
709
710 #ifdef CONFIG_NET_ALIAS
711 if (net_alias_is(dev)) return;
712 #endif
713 save_flags(flags);
714
715
716
717
718 for(i = 0;i < DEV_NUMBUFFS; i++)
719 {
720
721
722
723
724
725 cli();
726 while((skb=skb_dequeue(&dev->buffs[i]))!=NULL)
727 {
728
729
730
731 skb_device_lock(skb);
732 restore_flags(flags);
733
734
735
736
737 dev_queue_xmit(skb,dev,-i - 1);
738
739
740
741 if (dev->tbusy)
742 return;
743 cli();
744 }
745 }
746 restore_flags(flags);
747 }
748
749
750
751
752
753
754
755
756 static int dev_ifconf(char *arg)
757 {
758 struct ifconf ifc;
759 struct ifreq ifr;
760 struct device *dev;
761 char *pos;
762 int len;
763 int err;
764
765
766
767
768
769 err=verify_area(VERIFY_WRITE, arg, sizeof(struct ifconf));
770 if(err)
771 return err;
772 memcpy_fromfs(&ifc, arg, sizeof(struct ifconf));
773 len = ifc.ifc_len;
774 pos = ifc.ifc_buf;
775
776
777
778
779
780
781 err=verify_area(VERIFY_WRITE,pos,len);
782 if(err)
783 return err;
784
785
786
787
788
789 for (dev = dev_base; dev != NULL; dev = dev->next)
790 {
791 if(!(dev->flags & IFF_UP))
792 continue;
793 memset(&ifr, 0, sizeof(struct ifreq));
794 strcpy(ifr.ifr_name, dev->name);
795 (*(struct sockaddr_in *) &ifr.ifr_addr).sin_family = dev->family;
796 (*(struct sockaddr_in *) &ifr.ifr_addr).sin_addr.s_addr = dev->pa_addr;
797
798
799
800
801
802 if (len < sizeof(struct ifreq))
803 break;
804
805
806
807
808
809 memcpy_tofs(pos, &ifr, sizeof(struct ifreq));
810 pos += sizeof(struct ifreq);
811 len -= sizeof(struct ifreq);
812 }
813
814
815
816
817
818 ifc.ifc_len = (pos - ifc.ifc_buf);
819 ifc.ifc_req = (struct ifreq *) ifc.ifc_buf;
820 memcpy_tofs(arg, &ifc, sizeof(struct ifconf));
821
822
823
824
825
826 return(pos - arg);
827 }
828
829
830
831
832
833
834
835 #ifdef CONFIG_PROC_FS
836 static int sprintf_stats(char *buffer, struct device *dev)
837 {
838 struct enet_statistics *stats = (dev->get_stats ? dev->get_stats(dev): NULL);
839 int size;
840
841 if (stats)
842 size = sprintf(buffer, "%6s:%7d %4d %4d %4d %4d %8d %4d %4d %4d %5d %4d\n",
843 dev->name,
844 stats->rx_packets, stats->rx_errors,
845 stats->rx_dropped + stats->rx_missed_errors,
846 stats->rx_fifo_errors,
847 stats->rx_length_errors + stats->rx_over_errors
848 + stats->rx_crc_errors + stats->rx_frame_errors,
849 stats->tx_packets, stats->tx_errors, stats->tx_dropped,
850 stats->tx_fifo_errors, stats->collisions,
851 stats->tx_carrier_errors + stats->tx_aborted_errors
852 + stats->tx_window_errors + stats->tx_heartbeat_errors);
853 else
854 size = sprintf(buffer, "%6s: No statistics available.\n", dev->name);
855
856 return size;
857 }
858
859
860
861
862
863
864 int dev_get_info(char *buffer, char **start, off_t offset, int length, int dummy)
865 {
866 int len=0;
867 off_t begin=0;
868 off_t pos=0;
869 int size;
870
871 struct device *dev;
872
873
874 size = sprintf(buffer, "Inter-| Receive | Transmit\n"
875 " face |packets errs drop fifo frame|packets errs drop fifo colls carrier\n");
876
877 pos+=size;
878 len+=size;
879
880
881 for (dev = dev_base; dev != NULL; dev = dev->next)
882 {
883 size = sprintf_stats(buffer+len, dev);
884 len+=size;
885 pos=begin+len;
886
887 if(pos<offset)
888 {
889 len=0;
890 begin=pos;
891 }
892 if(pos>offset+length)
893 break;
894 }
895
896 *start=buffer+(offset-begin);
897 len-=(offset-begin);
898 if(len>length)
899 len=length;
900 return len;
901 }
902 #endif
903
904
905
906
907
908
909 static inline int bad_mask(unsigned long mask, unsigned long addr)
910 {
911 if (addr & (mask = ~mask))
912 return 1;
913 mask = ntohl(mask);
914 if (mask & (mask+1))
915 return 1;
916 return 0;
917 }
918
919
920
921
922
923
924
925
926 static int dev_ifsioc(void *arg, unsigned int getset)
927 {
928 struct ifreq ifr;
929 struct device *dev;
930 int ret;
931
932
933
934
935
936 int err=verify_area(VERIFY_WRITE, arg, sizeof(struct ifreq));
937 if(err)
938 return err;
939
940 memcpy_fromfs(&ifr, arg, sizeof(struct ifreq));
941
942
943
944
945
946
947
948
949
950
951
952
953 #ifdef CONFIG_KERNELD
954 dev_load(ifr.ifr_name);
955 #endif
956
957 #ifdef CONFIG_NET_ALIAS
958 if ((dev = net_alias_dev_get(ifr.ifr_name, getset == SIOCSIFADDR, &err, NULL, NULL)) == NULL)
959 return(err);
960 #else
961 if ((dev = dev_get(ifr.ifr_name)) == NULL)
962 return(-ENODEV);
963 #endif
964 switch(getset)
965 {
966 case SIOCGIFFLAGS:
967 ifr.ifr_flags = dev->flags;
968 goto rarok;
969
970 case SIOCSIFFLAGS:
971 {
972 int old_flags = dev->flags;
973
974
975
976
977
978
979 dev_lock_wait();
980
981
982
983
984
985 dev->flags = (ifr.ifr_flags & (
986 IFF_BROADCAST | IFF_DEBUG | IFF_LOOPBACK |
987 IFF_POINTOPOINT | IFF_NOTRAILERS | IFF_RUNNING |
988 IFF_NOARP | IFF_PROMISC | IFF_ALLMULTI | IFF_SLAVE | IFF_MASTER
989 | IFF_MULTICAST)) | (dev->flags & IFF_UP);
990
991
992
993
994 dev_mc_upload(dev);
995
996
997
998
999
1000
1001
1002 if ((old_flags^ifr.ifr_flags)&IFF_UP)
1003 {
1004 if(old_flags&IFF_UP)
1005 ret=dev_close(dev);
1006 else
1007 {
1008 ret=dev_open(dev);
1009 if(ret<0)
1010 dev->flags&=~IFF_UP;
1011 }
1012 }
1013 else
1014 ret=0;
1015
1016
1017
1018
1019 dev_mc_upload(dev);
1020 }
1021 break;
1022
1023 case SIOCGIFADDR:
1024 if(ifr.ifr_addr.sa_family==AF_UNSPEC)
1025 {
1026 memcpy(ifr.ifr_hwaddr.sa_data,dev->dev_addr, MAX_ADDR_LEN);
1027 ifr.ifr_hwaddr.sa_family=dev->type;
1028 goto rarok;
1029 }
1030 else
1031 {
1032 (*(struct sockaddr_in *)
1033 &ifr.ifr_addr).sin_addr.s_addr = dev->pa_addr;
1034 (*(struct sockaddr_in *)
1035 &ifr.ifr_addr).sin_family = dev->family;
1036 (*(struct sockaddr_in *)
1037 &ifr.ifr_addr).sin_port = 0;
1038 }
1039 goto rarok;
1040
1041 case SIOCSIFADDR:
1042
1043
1044
1045
1046
1047
1048 if(ifr.ifr_addr.sa_family==AF_UNSPEC)
1049 {
1050 if(dev->set_mac_address==NULL)
1051 return -EOPNOTSUPP;
1052 ret=dev->set_mac_address(dev,&ifr.ifr_addr);
1053 }
1054 else
1055 {
1056
1057
1058
1059
1060
1061
1062 #ifdef CONFIG_NET_ALIAS
1063 if (net_alias_is(dev))
1064 net_alias_dev_rehash(dev ,&ifr.ifr_addr);
1065 #endif
1066 dev->pa_addr = (*(struct sockaddr_in *)
1067 &ifr.ifr_addr).sin_addr.s_addr;
1068 dev->family = ifr.ifr_addr.sa_family;
1069
1070 #ifdef CONFIG_INET
1071
1072
1073 dev->pa_mask = ip_get_mask(dev->pa_addr);
1074 #endif
1075 dev->pa_brdaddr = dev->pa_addr | ~dev->pa_mask;
1076 ret = 0;
1077 }
1078 break;
1079
1080 case SIOCGIFBRDADDR:
1081 (*(struct sockaddr_in *)
1082 &ifr.ifr_broadaddr).sin_addr.s_addr = dev->pa_brdaddr;
1083 (*(struct sockaddr_in *)
1084 &ifr.ifr_broadaddr).sin_family = dev->family;
1085 (*(struct sockaddr_in *)
1086 &ifr.ifr_broadaddr).sin_port = 0;
1087 goto rarok;
1088
1089 case SIOCSIFBRDADDR:
1090 dev->pa_brdaddr = (*(struct sockaddr_in *)
1091 &ifr.ifr_broadaddr).sin_addr.s_addr;
1092 ret = 0;
1093 break;
1094
1095 case SIOCGIFDSTADDR:
1096 (*(struct sockaddr_in *)
1097 &ifr.ifr_dstaddr).sin_addr.s_addr = dev->pa_dstaddr;
1098 (*(struct sockaddr_in *)
1099 &ifr.ifr_dstaddr).sin_family = dev->family;
1100 (*(struct sockaddr_in *)
1101 &ifr.ifr_dstaddr).sin_port = 0;
1102 goto rarok;
1103
1104 case SIOCSIFDSTADDR:
1105 dev->pa_dstaddr = (*(struct sockaddr_in *)
1106 &ifr.ifr_dstaddr).sin_addr.s_addr;
1107 ret = 0;
1108 break;
1109
1110 case SIOCGIFNETMASK:
1111 (*(struct sockaddr_in *)
1112 &ifr.ifr_netmask).sin_addr.s_addr = dev->pa_mask;
1113 (*(struct sockaddr_in *)
1114 &ifr.ifr_netmask).sin_family = dev->family;
1115 (*(struct sockaddr_in *)
1116 &ifr.ifr_netmask).sin_port = 0;
1117 goto rarok;
1118
1119 case SIOCSIFNETMASK:
1120 {
1121 unsigned long mask = (*(struct sockaddr_in *)
1122 &ifr.ifr_netmask).sin_addr.s_addr;
1123 ret = -EINVAL;
1124
1125
1126
1127 if (bad_mask(mask,0))
1128 break;
1129 dev->pa_mask = mask;
1130 ret = 0;
1131 }
1132 break;
1133
1134 case SIOCGIFMETRIC:
1135
1136 ifr.ifr_metric = dev->metric;
1137 goto rarok;
1138
1139 case SIOCSIFMETRIC:
1140 dev->metric = ifr.ifr_metric;
1141 ret=0;
1142 break;
1143
1144 case SIOCGIFMTU:
1145 ifr.ifr_mtu = dev->mtu;
1146 goto rarok;
1147
1148 case SIOCSIFMTU:
1149
1150
1151
1152
1153
1154 if(ifr.ifr_mtu<68)
1155 return -EINVAL;
1156 dev->mtu = ifr.ifr_mtu;
1157 ret = 0;
1158 break;
1159
1160 case SIOCGIFMEM:
1161
1162 ret = -EINVAL;
1163 break;
1164
1165 case SIOCSIFMEM:
1166 ret = -EINVAL;
1167 break;
1168
1169 case SIOCGIFHWADDR:
1170 memcpy(ifr.ifr_hwaddr.sa_data,dev->dev_addr, MAX_ADDR_LEN);
1171 ifr.ifr_hwaddr.sa_family=dev->type;
1172 goto rarok;
1173
1174 case SIOCSIFHWADDR:
1175 if(dev->set_mac_address==NULL)
1176 return -EOPNOTSUPP;
1177 if(ifr.ifr_hwaddr.sa_family!=dev->type)
1178 return -EINVAL;
1179 ret=dev->set_mac_address(dev,&ifr.ifr_hwaddr);
1180 break;
1181
1182 case SIOCGIFMAP:
1183 ifr.ifr_map.mem_start=dev->mem_start;
1184 ifr.ifr_map.mem_end=dev->mem_end;
1185 ifr.ifr_map.base_addr=dev->base_addr;
1186 ifr.ifr_map.irq=dev->irq;
1187 ifr.ifr_map.dma=dev->dma;
1188 ifr.ifr_map.port=dev->if_port;
1189 goto rarok;
1190
1191 case SIOCSIFMAP:
1192 if(dev->set_config==NULL)
1193 return -EOPNOTSUPP;
1194 return dev->set_config(dev,&ifr.ifr_map);
1195
1196 case SIOCADDMULTI:
1197 if(dev->set_multicast_list==NULL)
1198 return -EINVAL;
1199 if(ifr.ifr_hwaddr.sa_family!=AF_UNSPEC)
1200 return -EINVAL;
1201 dev_mc_add(dev,ifr.ifr_hwaddr.sa_data, dev->addr_len, 1);
1202 return 0;
1203
1204 case SIOCDELMULTI:
1205 if(dev->set_multicast_list==NULL)
1206 return -EINVAL;
1207 if(ifr.ifr_hwaddr.sa_family!=AF_UNSPEC)
1208 return -EINVAL;
1209 dev_mc_delete(dev,ifr.ifr_hwaddr.sa_data,dev->addr_len, 1);
1210 return 0;
1211
1212
1213
1214
1215 default:
1216 if((getset >= SIOCDEVPRIVATE) &&
1217 (getset <= (SIOCDEVPRIVATE + 15))) {
1218 if(dev->do_ioctl==NULL)
1219 return -EOPNOTSUPP;
1220 ret=dev->do_ioctl(dev, &ifr, getset);
1221 memcpy_tofs(arg,&ifr,sizeof(struct ifreq));
1222 break;
1223 }
1224
1225 ret = -EINVAL;
1226 }
1227 return(ret);
1228
1229
1230
1231 rarok:
1232 memcpy_tofs(arg, &ifr, sizeof(struct ifreq));
1233 return 0;
1234 }
1235
1236
1237
1238
1239
1240
1241
1242 int dev_ioctl(unsigned int cmd, void *arg)
1243 {
1244 switch(cmd)
1245 {
1246 case SIOCGIFCONF:
1247 (void) dev_ifconf((char *) arg);
1248 return 0;
1249
1250
1251
1252
1253
1254 case SIOCGIFFLAGS:
1255 case SIOCGIFADDR:
1256 case SIOCGIFDSTADDR:
1257 case SIOCGIFBRDADDR:
1258 case SIOCGIFNETMASK:
1259 case SIOCGIFMETRIC:
1260 case SIOCGIFMTU:
1261 case SIOCGIFMEM:
1262 case SIOCGIFHWADDR:
1263 case SIOCSIFHWADDR:
1264 case SIOCGIFSLAVE:
1265 case SIOCGIFMAP:
1266 return dev_ifsioc(arg, cmd);
1267
1268
1269
1270
1271
1272 case SIOCSIFFLAGS:
1273 case SIOCSIFADDR:
1274 case SIOCSIFDSTADDR:
1275 case SIOCSIFBRDADDR:
1276 case SIOCSIFNETMASK:
1277 case SIOCSIFMETRIC:
1278 case SIOCSIFMTU:
1279 case SIOCSIFMEM:
1280 case SIOCSIFMAP:
1281 case SIOCSIFSLAVE:
1282 case SIOCADDMULTI:
1283 case SIOCDELMULTI:
1284 if (!suser())
1285 return -EPERM;
1286 return dev_ifsioc(arg, cmd);
1287
1288 case SIOCSIFLINK:
1289 return -EINVAL;
1290
1291
1292
1293
1294
1295 default:
1296 if((cmd >= SIOCDEVPRIVATE) &&
1297 (cmd <= (SIOCDEVPRIVATE + 15))) {
1298 return dev_ifsioc(arg, cmd);
1299 }
1300 return -EINVAL;
1301 }
1302 }
1303
1304
1305
1306
1307
1308
1309
1310
1311 extern int lance_init(void);
1312 extern int pi_init(void);
1313 extern int dec21040_init(void);
1314
1315 int net_dev_init(void)
1316 {
1317 struct device *dev, **dp;
1318
1319
1320
1321
1322
1323 skb_queue_head_init(&backlog);
1324
1325
1326
1327
1328
1329
1330 #if defined(CONFIG_LANCE)
1331 lance_init();
1332 #endif
1333 #if defined(CONFIG_PI)
1334 pi_init();
1335 #endif
1336 #if defined(CONFIG_PT)
1337 pt_init();
1338 #endif
1339 #if defined(CONFIG_DEC_ELCP)
1340 dec21040_init();
1341 #endif
1342
1343
1344
1345
1346 #if (defined(CONFIG_SLIP_COMPRESSED) || defined(CONFIG_PPP)) && defined(CONFIG_SLHC_BUILTIN)
1347 slhc_install();
1348 #endif
1349
1350
1351
1352
1353
1354
1355
1356
1357 dp = &dev_base;
1358 while ((dev = *dp) != NULL)
1359 {
1360 int i;
1361 for (i = 0; i < DEV_NUMBUFFS; i++) {
1362 skb_queue_head_init(dev->buffs + i);
1363 }
1364
1365 if (dev->init && dev->init(dev))
1366 {
1367
1368
1369
1370 *dp = dev->next;
1371 }
1372 else
1373 {
1374 dp = &dev->next;
1375 }
1376 }
1377
1378 #ifdef CONFIG_PROC_FS
1379 proc_net_register(&(struct proc_dir_entry) {
1380 PROC_NET_DEV, 3, "dev",
1381 S_IFREG | S_IRUGO, 1, 0, 0,
1382 0, &proc_net_inode_operations,
1383 dev_get_info
1384 });
1385 #endif
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395 #ifdef CONFIG_NET_ALIAS
1396 net_alias_init();
1397 #endif
1398
1399 bh_base[NET_BH].routine = net_bh;
1400 enable_bh(NET_BH);
1401 return 0;
1402 }