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