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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75#include <asm/uaccess.h>
76#include <asm/system.h>
77#include <linux/bitops.h>
78#include <linux/capability.h>
79#include <linux/cpu.h>
80#include <linux/types.h>
81#include <linux/kernel.h>
82#include <linux/sched.h>
83#include <linux/mutex.h>
84#include <linux/string.h>
85#include <linux/mm.h>
86#include <linux/socket.h>
87#include <linux/sockios.h>
88#include <linux/errno.h>
89#include <linux/interrupt.h>
90#include <linux/if_ether.h>
91#include <linux/netdevice.h>
92#include <linux/etherdevice.h>
93#include <linux/ethtool.h>
94#include <linux/notifier.h>
95#include <linux/skbuff.h>
96#include <net/net_namespace.h>
97#include <net/sock.h>
98#include <linux/rtnetlink.h>
99#include <linux/proc_fs.h>
100#include <linux/seq_file.h>
101#include <linux/stat.h>
102#include <linux/if_bridge.h>
103#include <linux/if_macvlan.h>
104#include <net/dst.h>
105#include <net/pkt_sched.h>
106#include <net/checksum.h>
107#include <linux/highmem.h>
108#include <linux/init.h>
109#include <linux/kmod.h>
110#include <linux/module.h>
111#include <linux/kallsyms.h>
112#include <linux/netpoll.h>
113#include <linux/rcupdate.h>
114#include <linux/delay.h>
115#include <net/wext.h>
116#include <net/iw_handler.h>
117#include <asm/current.h>
118#include <linux/audit.h>
119#include <linux/dmaengine.h>
120#include <linux/err.h>
121#include <linux/ctype.h>
122#include <linux/if_arp.h>
123#include <linux/if_vlan.h>
124#include <linux/ip.h>
125#include <net/ip.h>
126#include <linux/ipv6.h>
127#include <linux/in.h>
128#include <linux/jhash.h>
129#include <linux/random.h>
130
131#include "net-sysfs.h"
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161#define PTYPE_HASH_SIZE (16)
162#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
163
164static DEFINE_SPINLOCK(ptype_lock);
165static struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
166static struct list_head ptype_all __read_mostly;
167
168#ifdef CONFIG_NET_DMA
169struct net_dma {
170 struct dma_client client;
171 spinlock_t lock;
172 cpumask_t channel_mask;
173 struct dma_chan **channels;
174};
175
176static enum dma_state_client
177netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
178 enum dma_state state);
179
180static struct net_dma net_dma = {
181 .client = {
182 .event_callback = netdev_dma_event,
183 },
184};
185#endif
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206DEFINE_RWLOCK(dev_base_lock);
207
208EXPORT_SYMBOL(dev_base_lock);
209
210#define NETDEV_HASHBITS 8
211#define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
212
213static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
214{
215 unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
216 return &net->dev_name_head[hash & ((1 << NETDEV_HASHBITS) - 1)];
217}
218
219static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
220{
221 return &net->dev_index_head[ifindex & ((1 << NETDEV_HASHBITS) - 1)];
222}
223
224
225static int list_netdevice(struct net_device *dev)
226{
227 struct net *net = dev_net(dev);
228
229 ASSERT_RTNL();
230
231 write_lock_bh(&dev_base_lock);
232 list_add_tail(&dev->dev_list, &net->dev_base_head);
233 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
234 hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
235 write_unlock_bh(&dev_base_lock);
236 return 0;
237}
238
239
240static void unlist_netdevice(struct net_device *dev)
241{
242 ASSERT_RTNL();
243
244
245 write_lock_bh(&dev_base_lock);
246 list_del(&dev->dev_list);
247 hlist_del(&dev->name_hlist);
248 hlist_del(&dev->index_hlist);
249 write_unlock_bh(&dev_base_lock);
250}
251
252
253
254
255
256static RAW_NOTIFIER_HEAD(netdev_chain);
257
258
259
260
261
262
263DEFINE_PER_CPU(struct softnet_data, softnet_data);
264
265#ifdef CONFIG_LOCKDEP
266
267
268
269
270static const unsigned short netdev_lock_type[] =
271 {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
272 ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
273 ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
274 ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
275 ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
276 ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
277 ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
278 ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
279 ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
280 ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
281 ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
282 ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
283 ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
284 ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_VOID,
285 ARPHRD_NONE};
286
287static const char *netdev_lock_name[] =
288 {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
289 "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
290 "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
291 "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
292 "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
293 "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
294 "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
295 "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
296 "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
297 "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
298 "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
299 "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
300 "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
301 "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_VOID",
302 "_xmit_NONE"};
303
304static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
305static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
306
307static inline unsigned short netdev_lock_pos(unsigned short dev_type)
308{
309 int i;
310
311 for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
312 if (netdev_lock_type[i] == dev_type)
313 return i;
314
315 return ARRAY_SIZE(netdev_lock_type) - 1;
316}
317
318static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
319 unsigned short dev_type)
320{
321 int i;
322
323 i = netdev_lock_pos(dev_type);
324 lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
325 netdev_lock_name[i]);
326}
327
328static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
329{
330 int i;
331
332 i = netdev_lock_pos(dev->type);
333 lockdep_set_class_and_name(&dev->addr_list_lock,
334 &netdev_addr_lock_key[i],
335 netdev_lock_name[i]);
336}
337#else
338static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
339 unsigned short dev_type)
340{
341}
342static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
343{
344}
345#endif
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382void dev_add_pack(struct packet_type *pt)
383{
384 int hash;
385
386 spin_lock_bh(&ptype_lock);
387 if (pt->type == htons(ETH_P_ALL))
388 list_add_rcu(&pt->list, &ptype_all);
389 else {
390 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
391 list_add_rcu(&pt->list, &ptype_base[hash]);
392 }
393 spin_unlock_bh(&ptype_lock);
394}
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409void __dev_remove_pack(struct packet_type *pt)
410{
411 struct list_head *head;
412 struct packet_type *pt1;
413
414 spin_lock_bh(&ptype_lock);
415
416 if (pt->type == htons(ETH_P_ALL))
417 head = &ptype_all;
418 else
419 head = &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
420
421 list_for_each_entry(pt1, head, list) {
422 if (pt == pt1) {
423 list_del_rcu(&pt->list);
424 goto out;
425 }
426 }
427
428 printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
429out:
430 spin_unlock_bh(&ptype_lock);
431}
432
433
434
435
436
437
438
439
440
441
442
443
444void dev_remove_pack(struct packet_type *pt)
445{
446 __dev_remove_pack(pt);
447
448 synchronize_net();
449}
450
451
452
453
454
455
456
457
458static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
459
460
461
462
463
464
465
466
467
468
469static int netdev_boot_setup_add(char *name, struct ifmap *map)
470{
471 struct netdev_boot_setup *s;
472 int i;
473
474 s = dev_boot_setup;
475 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
476 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
477 memset(s[i].name, 0, sizeof(s[i].name));
478 strlcpy(s[i].name, name, IFNAMSIZ);
479 memcpy(&s[i].map, map, sizeof(s[i].map));
480 break;
481 }
482 }
483
484 return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
485}
486
487
488
489
490
491
492
493
494
495
496int netdev_boot_setup_check(struct net_device *dev)
497{
498 struct netdev_boot_setup *s = dev_boot_setup;
499 int i;
500
501 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
502 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
503 !strcmp(dev->name, s[i].name)) {
504 dev->irq = s[i].map.irq;
505 dev->base_addr = s[i].map.base_addr;
506 dev->mem_start = s[i].map.mem_start;
507 dev->mem_end = s[i].map.mem_end;
508 return 1;
509 }
510 }
511 return 0;
512}
513
514
515
516
517
518
519
520
521
522
523
524
525unsigned long netdev_boot_base(const char *prefix, int unit)
526{
527 const struct netdev_boot_setup *s = dev_boot_setup;
528 char name[IFNAMSIZ];
529 int i;
530
531 sprintf(name, "%s%d", prefix, unit);
532
533
534
535
536
537 if (__dev_get_by_name(&init_net, name))
538 return 1;
539
540 for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
541 if (!strcmp(name, s[i].name))
542 return s[i].map.base_addr;
543 return 0;
544}
545
546
547
548
549int __init netdev_boot_setup(char *str)
550{
551 int ints[5];
552 struct ifmap map;
553
554 str = get_options(str, ARRAY_SIZE(ints), ints);
555 if (!str || !*str)
556 return 0;
557
558
559 memset(&map, 0, sizeof(map));
560 if (ints[0] > 0)
561 map.irq = ints[1];
562 if (ints[0] > 1)
563 map.base_addr = ints[2];
564 if (ints[0] > 2)
565 map.mem_start = ints[3];
566 if (ints[0] > 3)
567 map.mem_end = ints[4];
568
569
570 return netdev_boot_setup_add(str, &map);
571}
572
573__setup("netdev=", netdev_boot_setup);
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593struct net_device *__dev_get_by_name(struct net *net, const char *name)
594{
595 struct hlist_node *p;
596
597 hlist_for_each(p, dev_name_hash(net, name)) {
598 struct net_device *dev
599 = hlist_entry(p, struct net_device, name_hlist);
600 if (!strncmp(dev->name, name, IFNAMSIZ))
601 return dev;
602 }
603 return NULL;
604}
605
606
607
608
609
610
611
612
613
614
615
616
617
618struct net_device *dev_get_by_name(struct net *net, const char *name)
619{
620 struct net_device *dev;
621
622 read_lock(&dev_base_lock);
623 dev = __dev_get_by_name(net, name);
624 if (dev)
625 dev_hold(dev);
626 read_unlock(&dev_base_lock);
627 return dev;
628}
629
630
631
632
633
634
635
636
637
638
639
640
641
642struct net_device *__dev_get_by_index(struct net *net, int ifindex)
643{
644 struct hlist_node *p;
645
646 hlist_for_each(p, dev_index_hash(net, ifindex)) {
647 struct net_device *dev
648 = hlist_entry(p, struct net_device, index_hlist);
649 if (dev->ifindex == ifindex)
650 return dev;
651 }
652 return NULL;
653}
654
655
656
657
658
659
660
661
662
663
664
665
666
667struct net_device *dev_get_by_index(struct net *net, int ifindex)
668{
669 struct net_device *dev;
670
671 read_lock(&dev_base_lock);
672 dev = __dev_get_by_index(net, ifindex);
673 if (dev)
674 dev_hold(dev);
675 read_unlock(&dev_base_lock);
676 return dev;
677}
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
695{
696 struct net_device *dev;
697
698 ASSERT_RTNL();
699
700 for_each_netdev(net, dev)
701 if (dev->type == type &&
702 !memcmp(dev->dev_addr, ha, dev->addr_len))
703 return dev;
704
705 return NULL;
706}
707
708EXPORT_SYMBOL(dev_getbyhwaddr);
709
710struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
711{
712 struct net_device *dev;
713
714 ASSERT_RTNL();
715 for_each_netdev(net, dev)
716 if (dev->type == type)
717 return dev;
718
719 return NULL;
720}
721
722EXPORT_SYMBOL(__dev_getfirstbyhwtype);
723
724struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
725{
726 struct net_device *dev;
727
728 rtnl_lock();
729 dev = __dev_getfirstbyhwtype(net, type);
730 if (dev)
731 dev_hold(dev);
732 rtnl_unlock();
733 return dev;
734}
735
736EXPORT_SYMBOL(dev_getfirstbyhwtype);
737
738
739
740
741
742
743
744
745
746
747
748
749
750struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
751{
752 struct net_device *dev, *ret;
753
754 ret = NULL;
755 read_lock(&dev_base_lock);
756 for_each_netdev(net, dev) {
757 if (((dev->flags ^ if_flags) & mask) == 0) {
758 dev_hold(dev);
759 ret = dev;
760 break;
761 }
762 }
763 read_unlock(&dev_base_lock);
764 return ret;
765}
766
767
768
769
770
771
772
773
774
775int dev_valid_name(const char *name)
776{
777 if (*name == '\0')
778 return 0;
779 if (strlen(name) >= IFNAMSIZ)
780 return 0;
781 if (!strcmp(name, ".") || !strcmp(name, ".."))
782 return 0;
783
784 while (*name) {
785 if (*name == '/' || isspace(*name))
786 return 0;
787 name++;
788 }
789 return 1;
790}
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807static int __dev_alloc_name(struct net *net, const char *name, char *buf)
808{
809 int i = 0;
810 const char *p;
811 const int max_netdevices = 8*PAGE_SIZE;
812 unsigned long *inuse;
813 struct net_device *d;
814
815 p = strnchr(name, IFNAMSIZ-1, '%');
816 if (p) {
817
818
819
820
821
822 if (p[1] != 'd' || strchr(p + 2, '%'))
823 return -EINVAL;
824
825
826 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
827 if (!inuse)
828 return -ENOMEM;
829
830 for_each_netdev(net, d) {
831 if (!sscanf(d->name, name, &i))
832 continue;
833 if (i < 0 || i >= max_netdevices)
834 continue;
835
836
837 snprintf(buf, IFNAMSIZ, name, i);
838 if (!strncmp(buf, d->name, IFNAMSIZ))
839 set_bit(i, inuse);
840 }
841
842 i = find_first_zero_bit(inuse, max_netdevices);
843 free_page((unsigned long) inuse);
844 }
845
846 snprintf(buf, IFNAMSIZ, name, i);
847 if (!__dev_get_by_name(net, buf))
848 return i;
849
850
851
852
853
854 return -ENFILE;
855}
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871int dev_alloc_name(struct net_device *dev, const char *name)
872{
873 char buf[IFNAMSIZ];
874 struct net *net;
875 int ret;
876
877 BUG_ON(!dev_net(dev));
878 net = dev_net(dev);
879 ret = __dev_alloc_name(net, name, buf);
880 if (ret >= 0)
881 strlcpy(dev->name, buf, IFNAMSIZ);
882 return ret;
883}
884
885
886
887
888
889
890
891
892
893
894int dev_change_name(struct net_device *dev, const char *newname)
895{
896 char oldname[IFNAMSIZ];
897 int err = 0;
898 int ret;
899 struct net *net;
900
901 ASSERT_RTNL();
902 BUG_ON(!dev_net(dev));
903
904 net = dev_net(dev);
905 if (dev->flags & IFF_UP)
906 return -EBUSY;
907
908 if (!dev_valid_name(newname))
909 return -EINVAL;
910
911 if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
912 return 0;
913
914 memcpy(oldname, dev->name, IFNAMSIZ);
915
916 if (strchr(newname, '%')) {
917 err = dev_alloc_name(dev, newname);
918 if (err < 0)
919 return err;
920 }
921 else if (__dev_get_by_name(net, newname))
922 return -EEXIST;
923 else
924 strlcpy(dev->name, newname, IFNAMSIZ);
925
926rollback:
927 ret = device_rename(&dev->dev, dev->name);
928 if (ret) {
929 memcpy(dev->name, oldname, IFNAMSIZ);
930 return ret;
931 }
932
933 write_lock_bh(&dev_base_lock);
934 hlist_del(&dev->name_hlist);
935 hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
936 write_unlock_bh(&dev_base_lock);
937
938 ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
939 ret = notifier_to_errno(ret);
940
941 if (ret) {
942 if (err) {
943 printk(KERN_ERR
944 "%s: name change rollback failed: %d.\n",
945 dev->name, ret);
946 } else {
947 err = ret;
948 memcpy(dev->name, oldname, IFNAMSIZ);
949 goto rollback;
950 }
951 }
952
953 return err;
954}
955
956
957
958
959
960
961
962
963
964int dev_set_alias(struct net_device *dev, const char *alias, size_t len)
965{
966 ASSERT_RTNL();
967
968 if (len >= IFALIASZ)
969 return -EINVAL;
970
971 if (!len) {
972 if (dev->ifalias) {
973 kfree(dev->ifalias);
974 dev->ifalias = NULL;
975 }
976 return 0;
977 }
978
979 dev->ifalias = krealloc(dev->ifalias, len+1, GFP_KERNEL);
980 if (!dev->ifalias)
981 return -ENOMEM;
982
983 strlcpy(dev->ifalias, alias, len+1);
984 return len;
985}
986
987
988
989
990
991
992
993
994void netdev_features_change(struct net_device *dev)
995{
996 call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
997}
998EXPORT_SYMBOL(netdev_features_change);
999
1000
1001
1002
1003
1004
1005
1006
1007
1008void netdev_state_change(struct net_device *dev)
1009{
1010 if (dev->flags & IFF_UP) {
1011 call_netdevice_notifiers(NETDEV_CHANGE, dev);
1012 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
1013 }
1014}
1015
1016void netdev_bonding_change(struct net_device *dev)
1017{
1018 call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, dev);
1019}
1020EXPORT_SYMBOL(netdev_bonding_change);
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032void dev_load(struct net *net, const char *name)
1033{
1034 struct net_device *dev;
1035
1036 read_lock(&dev_base_lock);
1037 dev = __dev_get_by_name(net, name);
1038 read_unlock(&dev_base_lock);
1039
1040 if (!dev && capable(CAP_SYS_MODULE))
1041 request_module("%s", name);
1042}
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056int dev_open(struct net_device *dev)
1057{
1058 int ret = 0;
1059
1060 ASSERT_RTNL();
1061
1062
1063
1064
1065
1066 if (dev->flags & IFF_UP)
1067 return 0;
1068
1069
1070
1071
1072 if (!netif_device_present(dev))
1073 return -ENODEV;
1074
1075
1076
1077
1078 set_bit(__LINK_STATE_START, &dev->state);
1079
1080 if (dev->validate_addr)
1081 ret = dev->validate_addr(dev);
1082
1083 if (!ret && dev->open)
1084 ret = dev->open(dev);
1085
1086
1087
1088
1089
1090 if (ret)
1091 clear_bit(__LINK_STATE_START, &dev->state);
1092 else {
1093
1094
1095
1096 dev->flags |= IFF_UP;
1097
1098
1099
1100
1101 dev_set_rx_mode(dev);
1102
1103
1104
1105
1106 dev_activate(dev);
1107
1108
1109
1110
1111 call_netdevice_notifiers(NETDEV_UP, dev);
1112 }
1113
1114 return ret;
1115}
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126int dev_close(struct net_device *dev)
1127{
1128 ASSERT_RTNL();
1129
1130 might_sleep();
1131
1132 if (!(dev->flags & IFF_UP))
1133 return 0;
1134
1135
1136
1137
1138
1139 call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1140
1141 clear_bit(__LINK_STATE_START, &dev->state);
1142
1143
1144
1145
1146
1147
1148
1149 smp_mb__after_clear_bit();
1150
1151 dev_deactivate(dev);
1152
1153
1154
1155
1156
1157
1158
1159
1160 if (dev->stop)
1161 dev->stop(dev);
1162
1163
1164
1165
1166
1167 dev->flags &= ~IFF_UP;
1168
1169
1170
1171
1172 call_netdevice_notifiers(NETDEV_DOWN, dev);
1173
1174 return 0;
1175}
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186void dev_disable_lro(struct net_device *dev)
1187{
1188 if (dev->ethtool_ops && dev->ethtool_ops->get_flags &&
1189 dev->ethtool_ops->set_flags) {
1190 u32 flags = dev->ethtool_ops->get_flags(dev);
1191 if (flags & ETH_FLAG_LRO) {
1192 flags &= ~ETH_FLAG_LRO;
1193 dev->ethtool_ops->set_flags(dev, flags);
1194 }
1195 }
1196 WARN_ON(dev->features & NETIF_F_LRO);
1197}
1198EXPORT_SYMBOL(dev_disable_lro);
1199
1200
1201static int dev_boot_phase = 1;
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222int register_netdevice_notifier(struct notifier_block *nb)
1223{
1224 struct net_device *dev;
1225 struct net_device *last;
1226 struct net *net;
1227 int err;
1228
1229 rtnl_lock();
1230 err = raw_notifier_chain_register(&netdev_chain, nb);
1231 if (err)
1232 goto unlock;
1233 if (dev_boot_phase)
1234 goto unlock;
1235 for_each_net(net) {
1236 for_each_netdev(net, dev) {
1237 err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1238 err = notifier_to_errno(err);
1239 if (err)
1240 goto rollback;
1241
1242 if (!(dev->flags & IFF_UP))
1243 continue;
1244
1245 nb->notifier_call(nb, NETDEV_UP, dev);
1246 }
1247 }
1248
1249unlock:
1250 rtnl_unlock();
1251 return err;
1252
1253rollback:
1254 last = dev;
1255 for_each_net(net) {
1256 for_each_netdev(net, dev) {
1257 if (dev == last)
1258 break;
1259
1260 if (dev->flags & IFF_UP) {
1261 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1262 nb->notifier_call(nb, NETDEV_DOWN, dev);
1263 }
1264 nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1265 }
1266 }
1267
1268 raw_notifier_chain_unregister(&netdev_chain, nb);
1269 goto unlock;
1270}
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282int unregister_netdevice_notifier(struct notifier_block *nb)
1283{
1284 int err;
1285
1286 rtnl_lock();
1287 err = raw_notifier_chain_unregister(&netdev_chain, nb);
1288 rtnl_unlock();
1289 return err;
1290}
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1302{
1303 return raw_notifier_call_chain(&netdev_chain, val, dev);
1304}
1305
1306
1307static atomic_t netstamp_needed = ATOMIC_INIT(0);
1308
1309void net_enable_timestamp(void)
1310{
1311 atomic_inc(&netstamp_needed);
1312}
1313
1314void net_disable_timestamp(void)
1315{
1316 atomic_dec(&netstamp_needed);
1317}
1318
1319static inline void net_timestamp(struct sk_buff *skb)
1320{
1321 if (atomic_read(&netstamp_needed))
1322 __net_timestamp(skb);
1323 else
1324 skb->tstamp.tv64 = 0;
1325}
1326
1327
1328
1329
1330
1331
1332static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1333{
1334 struct packet_type *ptype;
1335
1336 net_timestamp(skb);
1337
1338 rcu_read_lock();
1339 list_for_each_entry_rcu(ptype, &ptype_all, list) {
1340
1341
1342
1343 if ((ptype->dev == dev || !ptype->dev) &&
1344 (ptype->af_packet_priv == NULL ||
1345 (struct sock *)ptype->af_packet_priv != skb->sk)) {
1346 struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1347 if (!skb2)
1348 break;
1349
1350
1351
1352
1353
1354 skb_reset_mac_header(skb2);
1355
1356 if (skb_network_header(skb2) < skb2->data ||
1357 skb2->network_header > skb2->tail) {
1358 if (net_ratelimit())
1359 printk(KERN_CRIT "protocol %04x is "
1360 "buggy, dev %s\n",
1361 skb2->protocol, dev->name);
1362 skb_reset_network_header(skb2);
1363 }
1364
1365 skb2->transport_header = skb2->network_header;
1366 skb2->pkt_type = PACKET_OUTGOING;
1367 ptype->func(skb2, skb->dev, ptype, skb->dev);
1368 }
1369 }
1370 rcu_read_unlock();
1371}
1372
1373
1374static inline void __netif_reschedule(struct Qdisc *q)
1375{
1376 struct softnet_data *sd;
1377 unsigned long flags;
1378
1379 local_irq_save(flags);
1380 sd = &__get_cpu_var(softnet_data);
1381 q->next_sched = sd->output_queue;
1382 sd->output_queue = q;
1383 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1384 local_irq_restore(flags);
1385}
1386
1387void __netif_schedule(struct Qdisc *q)
1388{
1389 if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
1390 __netif_reschedule(q);
1391}
1392EXPORT_SYMBOL(__netif_schedule);
1393
1394void dev_kfree_skb_irq(struct sk_buff *skb)
1395{
1396 if (atomic_dec_and_test(&skb->users)) {
1397 struct softnet_data *sd;
1398 unsigned long flags;
1399
1400 local_irq_save(flags);
1401 sd = &__get_cpu_var(softnet_data);
1402 skb->next = sd->completion_queue;
1403 sd->completion_queue = skb;
1404 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1405 local_irq_restore(flags);
1406 }
1407}
1408EXPORT_SYMBOL(dev_kfree_skb_irq);
1409
1410void dev_kfree_skb_any(struct sk_buff *skb)
1411{
1412 if (in_irq() || irqs_disabled())
1413 dev_kfree_skb_irq(skb);
1414 else
1415 dev_kfree_skb(skb);
1416}
1417EXPORT_SYMBOL(dev_kfree_skb_any);
1418
1419
1420
1421
1422
1423
1424
1425
1426void netif_device_detach(struct net_device *dev)
1427{
1428 if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1429 netif_running(dev)) {
1430 netif_stop_queue(dev);
1431 }
1432}
1433EXPORT_SYMBOL(netif_device_detach);
1434
1435
1436
1437
1438
1439
1440
1441void netif_device_attach(struct net_device *dev)
1442{
1443 if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1444 netif_running(dev)) {
1445 netif_wake_queue(dev);
1446 __netdev_watchdog_up(dev);
1447 }
1448}
1449EXPORT_SYMBOL(netif_device_attach);
1450
1451static bool can_checksum_protocol(unsigned long features, __be16 protocol)
1452{
1453 return ((features & NETIF_F_GEN_CSUM) ||
1454 ((features & NETIF_F_IP_CSUM) &&
1455 protocol == htons(ETH_P_IP)) ||
1456 ((features & NETIF_F_IPV6_CSUM) &&
1457 protocol == htons(ETH_P_IPV6)));
1458}
1459
1460static bool dev_can_checksum(struct net_device *dev, struct sk_buff *skb)
1461{
1462 if (can_checksum_protocol(dev->features, skb->protocol))
1463 return true;
1464
1465 if (skb->protocol == htons(ETH_P_8021Q)) {
1466 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1467 if (can_checksum_protocol(dev->features & dev->vlan_features,
1468 veh->h_vlan_encapsulated_proto))
1469 return true;
1470 }
1471
1472 return false;
1473}
1474
1475
1476
1477
1478
1479int skb_checksum_help(struct sk_buff *skb)
1480{
1481 __wsum csum;
1482 int ret = 0, offset;
1483
1484 if (skb->ip_summed == CHECKSUM_COMPLETE)
1485 goto out_set_summed;
1486
1487 if (unlikely(skb_shinfo(skb)->gso_size)) {
1488
1489 goto out_set_summed;
1490 }
1491
1492 offset = skb->csum_start - skb_headroom(skb);
1493 BUG_ON(offset >= skb_headlen(skb));
1494 csum = skb_checksum(skb, offset, skb->len - offset, 0);
1495
1496 offset += skb->csum_offset;
1497 BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1498
1499 if (skb_cloned(skb) &&
1500 !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1501 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1502 if (ret)
1503 goto out;
1504 }
1505
1506 *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1507out_set_summed:
1508 skb->ip_summed = CHECKSUM_NONE;
1509out:
1510 return ret;
1511}
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1524{
1525 struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1526 struct packet_type *ptype;
1527 __be16 type = skb->protocol;
1528 int err;
1529
1530 BUG_ON(skb_shinfo(skb)->frag_list);
1531
1532 skb_reset_mac_header(skb);
1533 skb->mac_len = skb->network_header - skb->mac_header;
1534 __skb_pull(skb, skb->mac_len);
1535
1536 if (WARN_ON(skb->ip_summed != CHECKSUM_PARTIAL)) {
1537 if (skb_header_cloned(skb) &&
1538 (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1539 return ERR_PTR(err);
1540 }
1541
1542 rcu_read_lock();
1543 list_for_each_entry_rcu(ptype,
1544 &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
1545 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1546 if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1547 err = ptype->gso_send_check(skb);
1548 segs = ERR_PTR(err);
1549 if (err || skb_gso_ok(skb, features))
1550 break;
1551 __skb_push(skb, (skb->data -
1552 skb_network_header(skb)));
1553 }
1554 segs = ptype->gso_segment(skb, features);
1555 break;
1556 }
1557 }
1558 rcu_read_unlock();
1559
1560 __skb_push(skb, skb->data - skb_mac_header(skb));
1561
1562 return segs;
1563}
1564
1565EXPORT_SYMBOL(skb_gso_segment);
1566
1567
1568#ifdef CONFIG_BUG
1569void netdev_rx_csum_fault(struct net_device *dev)
1570{
1571 if (net_ratelimit()) {
1572 printk(KERN_ERR "%s: hw csum failure.\n",
1573 dev ? dev->name : "<unknown>");
1574 dump_stack();
1575 }
1576}
1577EXPORT_SYMBOL(netdev_rx_csum_fault);
1578#endif
1579
1580
1581
1582
1583
1584
1585static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1586{
1587#ifdef CONFIG_HIGHMEM
1588 int i;
1589
1590 if (dev->features & NETIF_F_HIGHDMA)
1591 return 0;
1592
1593 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1594 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1595 return 1;
1596
1597#endif
1598 return 0;
1599}
1600
1601struct dev_gso_cb {
1602 void (*destructor)(struct sk_buff *skb);
1603};
1604
1605#define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1606
1607static void dev_gso_skb_destructor(struct sk_buff *skb)
1608{
1609 struct dev_gso_cb *cb;
1610
1611 do {
1612 struct sk_buff *nskb = skb->next;
1613
1614 skb->next = nskb->next;
1615 nskb->next = NULL;
1616 kfree_skb(nskb);
1617 } while (skb->next);
1618
1619 cb = DEV_GSO_CB(skb);
1620 if (cb->destructor)
1621 cb->destructor(skb);
1622}
1623
1624
1625
1626
1627
1628
1629
1630
1631static int dev_gso_segment(struct sk_buff *skb)
1632{
1633 struct net_device *dev = skb->dev;
1634 struct sk_buff *segs;
1635 int features = dev->features & ~(illegal_highdma(dev, skb) ?
1636 NETIF_F_SG : 0);
1637
1638 segs = skb_gso_segment(skb, features);
1639
1640
1641 if (!segs)
1642 return 0;
1643
1644 if (IS_ERR(segs))
1645 return PTR_ERR(segs);
1646
1647 skb->next = segs;
1648 DEV_GSO_CB(skb)->destructor = skb->destructor;
1649 skb->destructor = dev_gso_skb_destructor;
1650
1651 return 0;
1652}
1653
1654int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
1655 struct netdev_queue *txq)
1656{
1657 if (likely(!skb->next)) {
1658 if (!list_empty(&ptype_all))
1659 dev_queue_xmit_nit(skb, dev);
1660
1661 if (netif_needs_gso(dev, skb)) {
1662 if (unlikely(dev_gso_segment(skb)))
1663 goto out_kfree_skb;
1664 if (skb->next)
1665 goto gso;
1666 }
1667
1668 return dev->hard_start_xmit(skb, dev);
1669 }
1670
1671gso:
1672 do {
1673 struct sk_buff *nskb = skb->next;
1674 int rc;
1675
1676 skb->next = nskb->next;
1677 nskb->next = NULL;
1678 rc = dev->hard_start_xmit(nskb, dev);
1679 if (unlikely(rc)) {
1680 nskb->next = skb->next;
1681 skb->next = nskb;
1682 return rc;
1683 }
1684 if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
1685 return NETDEV_TX_BUSY;
1686 } while (skb->next);
1687
1688 skb->destructor = DEV_GSO_CB(skb)->destructor;
1689
1690out_kfree_skb:
1691 kfree_skb(skb);
1692 return 0;
1693}
1694
1695static u32 simple_tx_hashrnd;
1696static int simple_tx_hashrnd_initialized = 0;
1697
1698static u16 simple_tx_hash(struct net_device *dev, struct sk_buff *skb)
1699{
1700 u32 addr1, addr2, ports;
1701 u32 hash, ihl;
1702 u8 ip_proto = 0;
1703
1704 if (unlikely(!simple_tx_hashrnd_initialized)) {
1705 get_random_bytes(&simple_tx_hashrnd, 4);
1706 simple_tx_hashrnd_initialized = 1;
1707 }
1708
1709 switch (skb->protocol) {
1710 case htons(ETH_P_IP):
1711 if (!(ip_hdr(skb)->frag_off & htons(IP_MF | IP_OFFSET)))
1712 ip_proto = ip_hdr(skb)->protocol;
1713 addr1 = ip_hdr(skb)->saddr;
1714 addr2 = ip_hdr(skb)->daddr;
1715 ihl = ip_hdr(skb)->ihl;
1716 break;
1717 case htons(ETH_P_IPV6):
1718 ip_proto = ipv6_hdr(skb)->nexthdr;
1719 addr1 = ipv6_hdr(skb)->saddr.s6_addr32[3];
1720 addr2 = ipv6_hdr(skb)->daddr.s6_addr32[3];
1721 ihl = (40 >> 2);
1722 break;
1723 default:
1724 return 0;
1725 }
1726
1727
1728 switch (ip_proto) {
1729 case IPPROTO_TCP:
1730 case IPPROTO_UDP:
1731 case IPPROTO_DCCP:
1732 case IPPROTO_ESP:
1733 case IPPROTO_AH:
1734 case IPPROTO_SCTP:
1735 case IPPROTO_UDPLITE:
1736 ports = *((u32 *) (skb_network_header(skb) + (ihl * 4)));
1737 break;
1738
1739 default:
1740 ports = 0;
1741 break;
1742 }
1743
1744 hash = jhash_3words(addr1, addr2, ports, simple_tx_hashrnd);
1745
1746 return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32);
1747}
1748
1749static struct netdev_queue *dev_pick_tx(struct net_device *dev,
1750 struct sk_buff *skb)
1751{
1752 u16 queue_index = 0;
1753
1754 if (dev->select_queue)
1755 queue_index = dev->select_queue(dev, skb);
1756 else if (dev->real_num_tx_queues > 1)
1757 queue_index = simple_tx_hash(dev, skb);
1758
1759 skb_set_queue_mapping(skb, queue_index);
1760 return netdev_get_tx_queue(dev, queue_index);
1761}
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788int dev_queue_xmit(struct sk_buff *skb)
1789{
1790 struct net_device *dev = skb->dev;
1791 struct netdev_queue *txq;
1792 struct Qdisc *q;
1793 int rc = -ENOMEM;
1794
1795
1796 if (netif_needs_gso(dev, skb))
1797 goto gso;
1798
1799 if (skb_shinfo(skb)->frag_list &&
1800 !(dev->features & NETIF_F_FRAGLIST) &&
1801 __skb_linearize(skb))
1802 goto out_kfree_skb;
1803
1804
1805
1806
1807
1808 if (skb_shinfo(skb)->nr_frags &&
1809 (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1810 __skb_linearize(skb))
1811 goto out_kfree_skb;
1812
1813
1814
1815
1816 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1817 skb_set_transport_header(skb, skb->csum_start -
1818 skb_headroom(skb));
1819 if (!dev_can_checksum(dev, skb) && skb_checksum_help(skb))
1820 goto out_kfree_skb;
1821 }
1822
1823gso:
1824
1825
1826
1827 rcu_read_lock_bh();
1828
1829 txq = dev_pick_tx(dev, skb);
1830 q = rcu_dereference(txq->qdisc);
1831
1832#ifdef CONFIG_NET_CLS_ACT
1833 skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1834#endif
1835 if (q->enqueue) {
1836 spinlock_t *root_lock = qdisc_lock(q);
1837
1838 spin_lock(root_lock);
1839
1840 if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
1841 kfree_skb(skb);
1842 rc = NET_XMIT_DROP;
1843 } else {
1844 rc = qdisc_enqueue_root(skb, q);
1845 qdisc_run(q);
1846 }
1847 spin_unlock(root_lock);
1848
1849 goto out;
1850 }
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864 if (dev->flags & IFF_UP) {
1865 int cpu = smp_processor_id();
1866
1867 if (txq->xmit_lock_owner != cpu) {
1868
1869 HARD_TX_LOCK(dev, txq, cpu);
1870
1871 if (!netif_tx_queue_stopped(txq)) {
1872 rc = 0;
1873 if (!dev_hard_start_xmit(skb, dev, txq)) {
1874 HARD_TX_UNLOCK(dev, txq);
1875 goto out;
1876 }
1877 }
1878 HARD_TX_UNLOCK(dev, txq);
1879 if (net_ratelimit())
1880 printk(KERN_CRIT "Virtual device %s asks to "
1881 "queue packet!\n", dev->name);
1882 } else {
1883
1884
1885 if (net_ratelimit())
1886 printk(KERN_CRIT "Dead loop on virtual device "
1887 "%s, fix it urgently!\n", dev->name);
1888 }
1889 }
1890
1891 rc = -ENETDOWN;
1892 rcu_read_unlock_bh();
1893
1894out_kfree_skb:
1895 kfree_skb(skb);
1896 return rc;
1897out:
1898 rcu_read_unlock_bh();
1899 return rc;
1900}
1901
1902
1903
1904
1905
1906
1907int netdev_max_backlog __read_mostly = 1000;
1908int netdev_budget __read_mostly = 300;
1909int weight_p __read_mostly = 64;
1910
1911DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929int netif_rx(struct sk_buff *skb)
1930{
1931 struct softnet_data *queue;
1932 unsigned long flags;
1933
1934
1935 if (netpoll_rx(skb))
1936 return NET_RX_DROP;
1937
1938 if (!skb->tstamp.tv64)
1939 net_timestamp(skb);
1940
1941
1942
1943
1944
1945 local_irq_save(flags);
1946 queue = &__get_cpu_var(softnet_data);
1947
1948 __get_cpu_var(netdev_rx_stat).total++;
1949 if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1950 if (queue->input_pkt_queue.qlen) {
1951enqueue:
1952 __skb_queue_tail(&queue->input_pkt_queue, skb);
1953 local_irq_restore(flags);
1954 return NET_RX_SUCCESS;
1955 }
1956
1957 napi_schedule(&queue->backlog);
1958 goto enqueue;
1959 }
1960
1961 __get_cpu_var(netdev_rx_stat).dropped++;
1962 local_irq_restore(flags);
1963
1964 kfree_skb(skb);
1965 return NET_RX_DROP;
1966}
1967
1968int netif_rx_ni(struct sk_buff *skb)
1969{
1970 int err;
1971
1972 preempt_disable();
1973 err = netif_rx(skb);
1974 if (local_softirq_pending())
1975 do_softirq();
1976 preempt_enable();
1977
1978 return err;
1979}
1980
1981EXPORT_SYMBOL(netif_rx_ni);
1982
1983static void net_tx_action(struct softirq_action *h)
1984{
1985 struct softnet_data *sd = &__get_cpu_var(softnet_data);
1986
1987 if (sd->completion_queue) {
1988 struct sk_buff *clist;
1989
1990 local_irq_disable();
1991 clist = sd->completion_queue;
1992 sd->completion_queue = NULL;
1993 local_irq_enable();
1994
1995 while (clist) {
1996 struct sk_buff *skb = clist;
1997 clist = clist->next;
1998
1999 WARN_ON(atomic_read(&skb->users));
2000 __kfree_skb(skb);
2001 }
2002 }
2003
2004 if (sd->output_queue) {
2005 struct Qdisc *head;
2006
2007 local_irq_disable();
2008 head = sd->output_queue;
2009 sd->output_queue = NULL;
2010 local_irq_enable();
2011
2012 while (head) {
2013 struct Qdisc *q = head;
2014 spinlock_t *root_lock;
2015
2016 head = head->next_sched;
2017
2018 root_lock = qdisc_lock(q);
2019 if (spin_trylock(root_lock)) {
2020 smp_mb__before_clear_bit();
2021 clear_bit(__QDISC_STATE_SCHED,
2022 &q->state);
2023 qdisc_run(q);
2024 spin_unlock(root_lock);
2025 } else {
2026 if (!test_bit(__QDISC_STATE_DEACTIVATED,
2027 &q->state)) {
2028 __netif_reschedule(q);
2029 } else {
2030 smp_mb__before_clear_bit();
2031 clear_bit(__QDISC_STATE_SCHED,
2032 &q->state);
2033 }
2034 }
2035 }
2036 }
2037}
2038
2039static inline int deliver_skb(struct sk_buff *skb,
2040 struct packet_type *pt_prev,
2041 struct net_device *orig_dev)
2042{
2043 atomic_inc(&skb->users);
2044 return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2045}
2046
2047#if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
2048
2049struct net_bridge;
2050struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
2051 unsigned char *addr);
2052void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
2053
2054
2055
2056
2057
2058struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
2059 struct sk_buff *skb) __read_mostly;
2060static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
2061 struct packet_type **pt_prev, int *ret,
2062 struct net_device *orig_dev)
2063{
2064 struct net_bridge_port *port;
2065
2066 if (skb->pkt_type == PACKET_LOOPBACK ||
2067 (port = rcu_dereference(skb->dev->br_port)) == NULL)
2068 return skb;
2069
2070 if (*pt_prev) {
2071 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2072 *pt_prev = NULL;
2073 }
2074
2075 return br_handle_frame_hook(port, skb);
2076}
2077#else
2078#define handle_bridge(skb, pt_prev, ret, orig_dev) (skb)
2079#endif
2080
2081#if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
2082struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *skb) __read_mostly;
2083EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook);
2084
2085static inline struct sk_buff *handle_macvlan(struct sk_buff *skb,
2086 struct packet_type **pt_prev,
2087 int *ret,
2088 struct net_device *orig_dev)
2089{
2090 if (skb->dev->macvlan_port == NULL)
2091 return skb;
2092
2093 if (*pt_prev) {
2094 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2095 *pt_prev = NULL;
2096 }
2097 return macvlan_handle_frame_hook(skb);
2098}
2099#else
2100#define handle_macvlan(skb, pt_prev, ret, orig_dev) (skb)
2101#endif
2102
2103#ifdef CONFIG_NET_CLS_ACT
2104
2105
2106
2107
2108
2109
2110
2111
2112static int ing_filter(struct sk_buff *skb)
2113{
2114 struct net_device *dev = skb->dev;
2115 u32 ttl = G_TC_RTTL(skb->tc_verd);
2116 struct netdev_queue *rxq;
2117 int result = TC_ACT_OK;
2118 struct Qdisc *q;
2119
2120 if (MAX_RED_LOOP < ttl++) {
2121 printk(KERN_WARNING
2122 "Redir loop detected Dropping packet (%d->%d)\n",
2123 skb->iif, dev->ifindex);
2124 return TC_ACT_SHOT;
2125 }
2126
2127 skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
2128 skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
2129
2130 rxq = &dev->rx_queue;
2131
2132 q = rxq->qdisc;
2133 if (q != &noop_qdisc) {
2134 spin_lock(qdisc_lock(q));
2135 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
2136 result = qdisc_enqueue_root(skb, q);
2137 spin_unlock(qdisc_lock(q));
2138 }
2139
2140 return result;
2141}
2142
2143static inline struct sk_buff *handle_ing(struct sk_buff *skb,
2144 struct packet_type **pt_prev,
2145 int *ret, struct net_device *orig_dev)
2146{
2147 if (skb->dev->rx_queue.qdisc == &noop_qdisc)
2148 goto out;
2149
2150 if (*pt_prev) {
2151 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2152 *pt_prev = NULL;
2153 } else {
2154
2155 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
2156 }
2157
2158 switch (ing_filter(skb)) {
2159 case TC_ACT_SHOT:
2160 case TC_ACT_STOLEN:
2161 kfree_skb(skb);
2162 return NULL;
2163 }
2164
2165out:
2166 skb->tc_verd = 0;
2167 return skb;
2168}
2169#endif
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179void netif_nit_deliver(struct sk_buff *skb)
2180{
2181 struct packet_type *ptype;
2182
2183 if (list_empty(&ptype_all))
2184 return;
2185
2186 skb_reset_network_header(skb);
2187 skb_reset_transport_header(skb);
2188 skb->mac_len = skb->network_header - skb->mac_header;
2189
2190 rcu_read_lock();
2191 list_for_each_entry_rcu(ptype, &ptype_all, list) {
2192 if (!ptype->dev || ptype->dev == skb->dev)
2193 deliver_skb(skb, ptype, skb->dev);
2194 }
2195 rcu_read_unlock();
2196}
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213int netif_receive_skb(struct sk_buff *skb)
2214{
2215 struct packet_type *ptype, *pt_prev;
2216 struct net_device *orig_dev;
2217 struct net_device *null_or_orig;
2218 int ret = NET_RX_DROP;
2219 __be16 type;
2220
2221 if (skb->vlan_tci && vlan_hwaccel_do_receive(skb))
2222 return NET_RX_SUCCESS;
2223
2224
2225 if (netpoll_receive_skb(skb))
2226 return NET_RX_DROP;
2227
2228 if (!skb->tstamp.tv64)
2229 net_timestamp(skb);
2230
2231 if (!skb->iif)
2232 skb->iif = skb->dev->ifindex;
2233
2234 null_or_orig = NULL;
2235 orig_dev = skb->dev;
2236 if (orig_dev->master) {
2237 if (skb_bond_should_drop(skb))
2238 null_or_orig = orig_dev;
2239 else
2240 skb->dev = orig_dev->master;
2241 }
2242
2243 __get_cpu_var(netdev_rx_stat).total++;
2244
2245 skb_reset_network_header(skb);
2246 skb_reset_transport_header(skb);
2247 skb->mac_len = skb->network_header - skb->mac_header;
2248
2249 pt_prev = NULL;
2250
2251 rcu_read_lock();
2252
2253
2254 if (!net_alive(dev_net(skb->dev)))
2255 goto out;
2256
2257#ifdef CONFIG_NET_CLS_ACT
2258 if (skb->tc_verd & TC_NCLS) {
2259 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2260 goto ncls;
2261 }
2262#endif
2263
2264 list_for_each_entry_rcu(ptype, &ptype_all, list) {
2265 if (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2266 ptype->dev == orig_dev) {
2267 if (pt_prev)
2268 ret = deliver_skb(skb, pt_prev, orig_dev);
2269 pt_prev = ptype;
2270 }
2271 }
2272
2273#ifdef CONFIG_NET_CLS_ACT
2274 skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2275 if (!skb)
2276 goto out;
2277ncls:
2278#endif
2279
2280 skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2281 if (!skb)
2282 goto out;
2283 skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2284 if (!skb)
2285 goto out;
2286
2287 type = skb->protocol;
2288 list_for_each_entry_rcu(ptype,
2289 &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
2290 if (ptype->type == type &&
2291 (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2292 ptype->dev == orig_dev)) {
2293 if (pt_prev)
2294 ret = deliver_skb(skb, pt_prev, orig_dev);
2295 pt_prev = ptype;
2296 }
2297 }
2298
2299 if (pt_prev) {
2300 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2301 } else {
2302 kfree_skb(skb);
2303
2304
2305
2306 ret = NET_RX_DROP;
2307 }
2308
2309out:
2310 rcu_read_unlock();
2311 return ret;
2312}
2313
2314
2315static void flush_backlog(void *arg)
2316{
2317 struct net_device *dev = arg;
2318 struct softnet_data *queue = &__get_cpu_var(softnet_data);
2319 struct sk_buff *skb, *tmp;
2320
2321 skb_queue_walk_safe(&queue->input_pkt_queue, skb, tmp)
2322 if (skb->dev == dev) {
2323 __skb_unlink(skb, &queue->input_pkt_queue);
2324 kfree_skb(skb);
2325 }
2326}
2327
2328static int process_backlog(struct napi_struct *napi, int quota)
2329{
2330 int work = 0;
2331 struct softnet_data *queue = &__get_cpu_var(softnet_data);
2332 unsigned long start_time = jiffies;
2333
2334 napi->weight = weight_p;
2335 do {
2336 struct sk_buff *skb;
2337
2338 local_irq_disable();
2339 skb = __skb_dequeue(&queue->input_pkt_queue);
2340 if (!skb) {
2341 __napi_complete(napi);
2342 local_irq_enable();
2343 break;
2344 }
2345 local_irq_enable();
2346
2347 netif_receive_skb(skb);
2348 } while (++work < quota && jiffies == start_time);
2349
2350 return work;
2351}
2352
2353
2354
2355
2356
2357
2358
2359void __napi_schedule(struct napi_struct *n)
2360{
2361 unsigned long flags;
2362
2363 local_irq_save(flags);
2364 list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2365 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2366 local_irq_restore(flags);
2367}
2368EXPORT_SYMBOL(__napi_schedule);
2369
2370
2371static void net_rx_action(struct softirq_action *h)
2372{
2373 struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
2374 unsigned long start_time = jiffies;
2375 int budget = netdev_budget;
2376 void *have;
2377
2378 local_irq_disable();
2379
2380 while (!list_empty(list)) {
2381 struct napi_struct *n;
2382 int work, weight;
2383
2384
2385
2386
2387
2388
2389
2390
2391 if (unlikely(budget <= 0 || jiffies != start_time))
2392 goto softnet_break;
2393
2394 local_irq_enable();
2395
2396
2397
2398
2399
2400
2401 n = list_entry(list->next, struct napi_struct, poll_list);
2402
2403 have = netpoll_poll_lock(n);
2404
2405 weight = n->weight;
2406
2407
2408
2409
2410
2411
2412
2413 work = 0;
2414 if (test_bit(NAPI_STATE_SCHED, &n->state))
2415 work = n->poll(n, weight);
2416
2417 WARN_ON_ONCE(work > weight);
2418
2419 budget -= work;
2420
2421 local_irq_disable();
2422
2423
2424
2425
2426
2427
2428 if (unlikely(work == weight)) {
2429 if (unlikely(napi_disable_pending(n)))
2430 __napi_complete(n);
2431 else
2432 list_move_tail(&n->poll_list, list);
2433 }
2434
2435 netpoll_poll_unlock(have);
2436 }
2437out:
2438 local_irq_enable();
2439
2440#ifdef CONFIG_NET_DMA
2441
2442
2443
2444
2445 if (!cpus_empty(net_dma.channel_mask)) {
2446 int chan_idx;
2447 for_each_cpu_mask_nr(chan_idx, net_dma.channel_mask) {
2448 struct dma_chan *chan = net_dma.channels[chan_idx];
2449 if (chan)
2450 dma_async_memcpy_issue_pending(chan);
2451 }
2452 }
2453#endif
2454
2455 return;
2456
2457softnet_break:
2458 __get_cpu_var(netdev_rx_stat).time_squeeze++;
2459 __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2460 goto out;
2461}
2462
2463static gifconf_func_t * gifconf_list [NPROTO];
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2475{
2476 if (family >= NPROTO)
2477 return -EINVAL;
2478 gifconf_list[family] = gifconf;
2479 return 0;
2480}
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494static int dev_ifname(struct net *net, struct ifreq __user *arg)
2495{
2496 struct net_device *dev;
2497 struct ifreq ifr;
2498
2499
2500
2501
2502
2503 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2504 return -EFAULT;
2505
2506 read_lock(&dev_base_lock);
2507 dev = __dev_get_by_index(net, ifr.ifr_ifindex);
2508 if (!dev) {
2509 read_unlock(&dev_base_lock);
2510 return -ENODEV;
2511 }
2512
2513 strcpy(ifr.ifr_name, dev->name);
2514 read_unlock(&dev_base_lock);
2515
2516 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2517 return -EFAULT;
2518 return 0;
2519}
2520
2521
2522
2523
2524
2525
2526
2527static int dev_ifconf(struct net *net, char __user *arg)
2528{
2529 struct ifconf ifc;
2530 struct net_device *dev;
2531 char __user *pos;
2532 int len;
2533 int total;
2534 int i;
2535
2536
2537
2538
2539
2540 if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2541 return -EFAULT;
2542
2543 pos = ifc.ifc_buf;
2544 len = ifc.ifc_len;
2545
2546
2547
2548
2549
2550 total = 0;
2551 for_each_netdev(net, dev) {
2552 for (i = 0; i < NPROTO; i++) {
2553 if (gifconf_list[i]) {
2554 int done;
2555 if (!pos)
2556 done = gifconf_list[i](dev, NULL, 0);
2557 else
2558 done = gifconf_list[i](dev, pos + total,
2559 len - total);
2560 if (done < 0)
2561 return -EFAULT;
2562 total += done;
2563 }
2564 }
2565 }
2566
2567
2568
2569
2570 ifc.ifc_len = total;
2571
2572
2573
2574
2575 return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2576}
2577
2578#ifdef CONFIG_PROC_FS
2579
2580
2581
2582
2583void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2584 __acquires(dev_base_lock)
2585{
2586 struct net *net = seq_file_net(seq);
2587 loff_t off;
2588 struct net_device *dev;
2589
2590 read_lock(&dev_base_lock);
2591 if (!*pos)
2592 return SEQ_START_TOKEN;
2593
2594 off = 1;
2595 for_each_netdev(net, dev)
2596 if (off++ == *pos)
2597 return dev;
2598
2599 return NULL;
2600}
2601
2602void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2603{
2604 struct net *net = seq_file_net(seq);
2605 ++*pos;
2606 return v == SEQ_START_TOKEN ?
2607 first_net_device(net) : next_net_device((struct net_device *)v);
2608}
2609
2610void dev_seq_stop(struct seq_file *seq, void *v)
2611 __releases(dev_base_lock)
2612{
2613 read_unlock(&dev_base_lock);
2614}
2615
2616static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2617{
2618 struct net_device_stats *stats = dev->get_stats(dev);
2619
2620 seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2621 "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2622 dev->name, stats->rx_bytes, stats->rx_packets,
2623 stats->rx_errors,
2624 stats->rx_dropped + stats->rx_missed_errors,
2625 stats->rx_fifo_errors,
2626 stats->rx_length_errors + stats->rx_over_errors +
2627 stats->rx_crc_errors + stats->rx_frame_errors,
2628 stats->rx_compressed, stats->multicast,
2629 stats->tx_bytes, stats->tx_packets,
2630 stats->tx_errors, stats->tx_dropped,
2631 stats->tx_fifo_errors, stats->collisions,
2632 stats->tx_carrier_errors +
2633 stats->tx_aborted_errors +
2634 stats->tx_window_errors +
2635 stats->tx_heartbeat_errors,
2636 stats->tx_compressed);
2637}
2638
2639
2640
2641
2642
2643static int dev_seq_show(struct seq_file *seq, void *v)
2644{
2645 if (v == SEQ_START_TOKEN)
2646 seq_puts(seq, "Inter-| Receive "
2647 " | Transmit\n"
2648 " face |bytes packets errs drop fifo frame "
2649 "compressed multicast|bytes packets errs "
2650 "drop fifo colls carrier compressed\n");
2651 else
2652 dev_seq_printf_stats(seq, v);
2653 return 0;
2654}
2655
2656static struct netif_rx_stats *softnet_get_online(loff_t *pos)
2657{
2658 struct netif_rx_stats *rc = NULL;
2659
2660 while (*pos < nr_cpu_ids)
2661 if (cpu_online(*pos)) {
2662 rc = &per_cpu(netdev_rx_stat, *pos);
2663 break;
2664 } else
2665 ++*pos;
2666 return rc;
2667}
2668
2669static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
2670{
2671 return softnet_get_online(pos);
2672}
2673
2674static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2675{
2676 ++*pos;
2677 return softnet_get_online(pos);
2678}
2679
2680static void softnet_seq_stop(struct seq_file *seq, void *v)
2681{
2682}
2683
2684static int softnet_seq_show(struct seq_file *seq, void *v)
2685{
2686 struct netif_rx_stats *s = v;
2687
2688 seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
2689 s->total, s->dropped, s->time_squeeze, 0,
2690 0, 0, 0, 0,
2691 s->cpu_collision );
2692 return 0;
2693}
2694
2695static const struct seq_operations dev_seq_ops = {
2696 .start = dev_seq_start,
2697 .next = dev_seq_next,
2698 .stop = dev_seq_stop,
2699 .show = dev_seq_show,
2700};
2701
2702static int dev_seq_open(struct inode *inode, struct file *file)
2703{
2704 return seq_open_net(inode, file, &dev_seq_ops,
2705 sizeof(struct seq_net_private));
2706}
2707
2708static const struct file_operations dev_seq_fops = {
2709 .owner = THIS_MODULE,
2710 .open = dev_seq_open,
2711 .read = seq_read,
2712 .llseek = seq_lseek,
2713 .release = seq_release_net,
2714};
2715
2716static const struct seq_operations softnet_seq_ops = {
2717 .start = softnet_seq_start,
2718 .next = softnet_seq_next,
2719 .stop = softnet_seq_stop,
2720 .show = softnet_seq_show,
2721};
2722
2723static int softnet_seq_open(struct inode *inode, struct file *file)
2724{
2725 return seq_open(file, &softnet_seq_ops);
2726}
2727
2728static const struct file_operations softnet_seq_fops = {
2729 .owner = THIS_MODULE,
2730 .open = softnet_seq_open,
2731 .read = seq_read,
2732 .llseek = seq_lseek,
2733 .release = seq_release,
2734};
2735
2736static void *ptype_get_idx(loff_t pos)
2737{
2738 struct packet_type *pt = NULL;
2739 loff_t i = 0;
2740 int t;
2741
2742 list_for_each_entry_rcu(pt, &ptype_all, list) {
2743 if (i == pos)
2744 return pt;
2745 ++i;
2746 }
2747
2748 for (t = 0; t < PTYPE_HASH_SIZE; t++) {
2749 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
2750 if (i == pos)
2751 return pt;
2752 ++i;
2753 }
2754 }
2755 return NULL;
2756}
2757
2758static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
2759 __acquires(RCU)
2760{
2761 rcu_read_lock();
2762 return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
2763}
2764
2765static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2766{
2767 struct packet_type *pt;
2768 struct list_head *nxt;
2769 int hash;
2770
2771 ++*pos;
2772 if (v == SEQ_START_TOKEN)
2773 return ptype_get_idx(0);
2774
2775 pt = v;
2776 nxt = pt->list.next;
2777 if (pt->type == htons(ETH_P_ALL)) {
2778 if (nxt != &ptype_all)
2779 goto found;
2780 hash = 0;
2781 nxt = ptype_base[0].next;
2782 } else
2783 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
2784
2785 while (nxt == &ptype_base[hash]) {
2786 if (++hash >= PTYPE_HASH_SIZE)
2787 return NULL;
2788 nxt = ptype_base[hash].next;
2789 }
2790found:
2791 return list_entry(nxt, struct packet_type, list);
2792}
2793
2794static void ptype_seq_stop(struct seq_file *seq, void *v)
2795 __releases(RCU)
2796{
2797 rcu_read_unlock();
2798}
2799
2800static void ptype_seq_decode(struct seq_file *seq, void *sym)
2801{
2802#ifdef CONFIG_KALLSYMS
2803 unsigned long offset = 0, symsize;
2804 const char *symname;
2805 char *modname;
2806 char namebuf[128];
2807
2808 symname = kallsyms_lookup((unsigned long)sym, &symsize, &offset,
2809 &modname, namebuf);
2810
2811 if (symname) {
2812 char *delim = ":";
2813
2814 if (!modname)
2815 modname = delim = "";
2816 seq_printf(seq, "%s%s%s%s+0x%lx", delim, modname, delim,
2817 symname, offset);
2818 return;
2819 }
2820#endif
2821
2822 seq_printf(seq, "[%p]", sym);
2823}
2824
2825static int ptype_seq_show(struct seq_file *seq, void *v)
2826{
2827 struct packet_type *pt = v;
2828
2829 if (v == SEQ_START_TOKEN)
2830 seq_puts(seq, "Type Device Function\n");
2831 else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
2832 if (pt->type == htons(ETH_P_ALL))
2833 seq_puts(seq, "ALL ");
2834 else
2835 seq_printf(seq, "%04x", ntohs(pt->type));
2836
2837 seq_printf(seq, " %-8s ",
2838 pt->dev ? pt->dev->name : "");
2839 ptype_seq_decode(seq, pt->func);
2840 seq_putc(seq, '\n');
2841 }
2842
2843 return 0;
2844}
2845
2846static const struct seq_operations ptype_seq_ops = {
2847 .start = ptype_seq_start,
2848 .next = ptype_seq_next,
2849 .stop = ptype_seq_stop,
2850 .show = ptype_seq_show,
2851};
2852
2853static int ptype_seq_open(struct inode *inode, struct file *file)
2854{
2855 return seq_open_net(inode, file, &ptype_seq_ops,
2856 sizeof(struct seq_net_private));
2857}
2858
2859static const struct file_operations ptype_seq_fops = {
2860 .owner = THIS_MODULE,
2861 .open = ptype_seq_open,
2862 .read = seq_read,
2863 .llseek = seq_lseek,
2864 .release = seq_release_net,
2865};
2866
2867
2868static int __net_init dev_proc_net_init(struct net *net)
2869{
2870 int rc = -ENOMEM;
2871
2872 if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
2873 goto out;
2874 if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
2875 goto out_dev;
2876 if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
2877 goto out_softnet;
2878
2879 if (wext_proc_init(net))
2880 goto out_ptype;
2881 rc = 0;
2882out:
2883 return rc;
2884out_ptype:
2885 proc_net_remove(net, "ptype");
2886out_softnet:
2887 proc_net_remove(net, "softnet_stat");
2888out_dev:
2889 proc_net_remove(net, "dev");
2890 goto out;
2891}
2892
2893static void __net_exit dev_proc_net_exit(struct net *net)
2894{
2895 wext_proc_exit(net);
2896
2897 proc_net_remove(net, "ptype");
2898 proc_net_remove(net, "softnet_stat");
2899 proc_net_remove(net, "dev");
2900}
2901
2902static struct pernet_operations __net_initdata dev_proc_ops = {
2903 .init = dev_proc_net_init,
2904 .exit = dev_proc_net_exit,
2905};
2906
2907static int __init dev_proc_init(void)
2908{
2909 return register_pernet_subsys(&dev_proc_ops);
2910}
2911#else
2912#define dev_proc_init() 0
2913#endif
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927int netdev_set_master(struct net_device *slave, struct net_device *master)
2928{
2929 struct net_device *old = slave->master;
2930
2931 ASSERT_RTNL();
2932
2933 if (master) {
2934 if (old)
2935 return -EBUSY;
2936 dev_hold(master);
2937 }
2938
2939 slave->master = master;
2940
2941 synchronize_net();
2942
2943 if (old)
2944 dev_put(old);
2945
2946 if (master)
2947 slave->flags |= IFF_SLAVE;
2948 else
2949 slave->flags &= ~IFF_SLAVE;
2950
2951 rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
2952 return 0;
2953}
2954
2955static void dev_change_rx_flags(struct net_device *dev, int flags)
2956{
2957 if (dev->flags & IFF_UP && dev->change_rx_flags)
2958 dev->change_rx_flags(dev, flags);
2959}
2960
2961static int __dev_set_promiscuity(struct net_device *dev, int inc)
2962{
2963 unsigned short old_flags = dev->flags;
2964
2965 ASSERT_RTNL();
2966
2967 dev->flags |= IFF_PROMISC;
2968 dev->promiscuity += inc;
2969 if (dev->promiscuity == 0) {
2970
2971
2972
2973
2974 if (inc < 0)
2975 dev->flags &= ~IFF_PROMISC;
2976 else {
2977 dev->promiscuity -= inc;
2978 printk(KERN_WARNING "%s: promiscuity touches roof, "
2979 "set promiscuity failed, promiscuity feature "
2980 "of device might be broken.\n", dev->name);
2981 return -EOVERFLOW;
2982 }
2983 }
2984 if (dev->flags != old_flags) {
2985 printk(KERN_INFO "device %s %s promiscuous mode\n",
2986 dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
2987 "left");
2988 if (audit_enabled)
2989 audit_log(current->audit_context, GFP_ATOMIC,
2990 AUDIT_ANOM_PROMISCUOUS,
2991 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
2992 dev->name, (dev->flags & IFF_PROMISC),
2993 (old_flags & IFF_PROMISC),
2994 audit_get_loginuid(current),
2995 current->uid, current->gid,
2996 audit_get_sessionid(current));
2997
2998 dev_change_rx_flags(dev, IFF_PROMISC);
2999 }
3000 return 0;
3001}
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014int dev_set_promiscuity(struct net_device *dev, int inc)
3015{
3016 unsigned short old_flags = dev->flags;
3017 int err;
3018
3019 err = __dev_set_promiscuity(dev, inc);
3020 if (err < 0)
3021 return err;
3022 if (dev->flags != old_flags)
3023 dev_set_rx_mode(dev);
3024 return err;
3025}
3026
3027
3028
3029
3030
3031
3032
3033
3034
3035
3036
3037
3038
3039
3040int dev_set_allmulti(struct net_device *dev, int inc)
3041{
3042 unsigned short old_flags = dev->flags;
3043
3044 ASSERT_RTNL();
3045
3046 dev->flags |= IFF_ALLMULTI;
3047 dev->allmulti += inc;
3048 if (dev->allmulti == 0) {
3049
3050
3051
3052
3053 if (inc < 0)
3054 dev->flags &= ~IFF_ALLMULTI;
3055 else {
3056 dev->allmulti -= inc;
3057 printk(KERN_WARNING "%s: allmulti touches roof, "
3058 "set allmulti failed, allmulti feature of "
3059 "device might be broken.\n", dev->name);
3060 return -EOVERFLOW;
3061 }
3062 }
3063 if (dev->flags ^ old_flags) {
3064 dev_change_rx_flags(dev, IFF_ALLMULTI);
3065 dev_set_rx_mode(dev);
3066 }
3067 return 0;
3068}
3069
3070
3071
3072
3073
3074
3075
3076void __dev_set_rx_mode(struct net_device *dev)
3077{
3078
3079 if (!(dev->flags&IFF_UP))
3080 return;
3081
3082 if (!netif_device_present(dev))
3083 return;
3084
3085 if (dev->set_rx_mode)
3086 dev->set_rx_mode(dev);
3087 else {
3088
3089
3090
3091 if (dev->uc_count > 0 && !dev->uc_promisc) {
3092 __dev_set_promiscuity(dev, 1);
3093 dev->uc_promisc = 1;
3094 } else if (dev->uc_count == 0 && dev->uc_promisc) {
3095 __dev_set_promiscuity(dev, -1);
3096 dev->uc_promisc = 0;
3097 }
3098
3099 if (dev->set_multicast_list)
3100 dev->set_multicast_list(dev);
3101 }
3102}
3103
3104void dev_set_rx_mode(struct net_device *dev)
3105{
3106 netif_addr_lock_bh(dev);
3107 __dev_set_rx_mode(dev);
3108 netif_addr_unlock_bh(dev);
3109}
3110
3111int __dev_addr_delete(struct dev_addr_list **list, int *count,
3112 void *addr, int alen, int glbl)
3113{
3114 struct dev_addr_list *da;
3115
3116 for (; (da = *list) != NULL; list = &da->next) {
3117 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3118 alen == da->da_addrlen) {
3119 if (glbl) {
3120 int old_glbl = da->da_gusers;
3121 da->da_gusers = 0;
3122 if (old_glbl == 0)
3123 break;
3124 }
3125 if (--da->da_users)
3126 return 0;
3127
3128 *list = da->next;
3129 kfree(da);
3130 (*count)--;
3131 return 0;
3132 }
3133 }
3134 return -ENOENT;
3135}
3136
3137int __dev_addr_add(struct dev_addr_list **list, int *count,
3138 void *addr, int alen, int glbl)
3139{
3140 struct dev_addr_list *da;
3141
3142 for (da = *list; da != NULL; da = da->next) {
3143 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3144 da->da_addrlen == alen) {
3145 if (glbl) {
3146 int old_glbl = da->da_gusers;
3147 da->da_gusers = 1;
3148 if (old_glbl)
3149 return 0;
3150 }
3151 da->da_users++;
3152 return 0;
3153 }
3154 }
3155
3156 da = kzalloc(sizeof(*da), GFP_ATOMIC);
3157 if (da == NULL)
3158 return -ENOMEM;
3159 memcpy(da->da_addr, addr, alen);
3160 da->da_addrlen = alen;
3161 da->da_users = 1;
3162 da->da_gusers = glbl ? 1 : 0;
3163 da->next = *list;
3164 *list = da;
3165 (*count)++;
3166 return 0;
3167}
3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180int dev_unicast_delete(struct net_device *dev, void *addr, int alen)
3181{
3182 int err;
3183
3184 ASSERT_RTNL();
3185
3186 netif_addr_lock_bh(dev);
3187 err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3188 if (!err)
3189 __dev_set_rx_mode(dev);
3190 netif_addr_unlock_bh(dev);
3191 return err;
3192}
3193EXPORT_SYMBOL(dev_unicast_delete);
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203
3204
3205
3206int dev_unicast_add(struct net_device *dev, void *addr, int alen)
3207{
3208 int err;
3209
3210 ASSERT_RTNL();
3211
3212 netif_addr_lock_bh(dev);
3213 err = __dev_addr_add(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3214 if (!err)
3215 __dev_set_rx_mode(dev);
3216 netif_addr_unlock_bh(dev);
3217 return err;
3218}
3219EXPORT_SYMBOL(dev_unicast_add);
3220
3221int __dev_addr_sync(struct dev_addr_list **to, int *to_count,
3222 struct dev_addr_list **from, int *from_count)
3223{
3224 struct dev_addr_list *da, *next;
3225 int err = 0;
3226
3227 da = *from;
3228 while (da != NULL) {
3229 next = da->next;
3230 if (!da->da_synced) {
3231 err = __dev_addr_add(to, to_count,
3232 da->da_addr, da->da_addrlen, 0);
3233 if (err < 0)
3234 break;
3235 da->da_synced = 1;
3236 da->da_users++;
3237 } else if (da->da_users == 1) {
3238 __dev_addr_delete(to, to_count,
3239 da->da_addr, da->da_addrlen, 0);
3240 __dev_addr_delete(from, from_count,
3241 da->da_addr, da->da_addrlen, 0);
3242 }
3243 da = next;
3244 }
3245 return err;
3246}
3247
3248void __dev_addr_unsync(struct dev_addr_list **to, int *to_count,
3249 struct dev_addr_list **from, int *from_count)
3250{
3251 struct dev_addr_list *da, *next;
3252
3253 da = *from;
3254 while (da != NULL) {
3255 next = da->next;
3256 if (da->da_synced) {
3257 __dev_addr_delete(to, to_count,
3258 da->da_addr, da->da_addrlen, 0);
3259 da->da_synced = 0;
3260 __dev_addr_delete(from, from_count,
3261 da->da_addr, da->da_addrlen, 0);
3262 }
3263 da = next;
3264 }
3265}
3266
3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279int dev_unicast_sync(struct net_device *to, struct net_device *from)
3280{
3281 int err = 0;
3282
3283 netif_addr_lock_bh(to);
3284 err = __dev_addr_sync(&to->uc_list, &to->uc_count,
3285 &from->uc_list, &from->uc_count);
3286 if (!err)
3287 __dev_set_rx_mode(to);
3288 netif_addr_unlock_bh(to);
3289 return err;
3290}
3291EXPORT_SYMBOL(dev_unicast_sync);
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302void dev_unicast_unsync(struct net_device *to, struct net_device *from)
3303{
3304 netif_addr_lock_bh(from);
3305 netif_addr_lock(to);
3306
3307 __dev_addr_unsync(&to->uc_list, &to->uc_count,
3308 &from->uc_list, &from->uc_count);
3309 __dev_set_rx_mode(to);
3310
3311 netif_addr_unlock(to);
3312 netif_addr_unlock_bh(from);
3313}
3314EXPORT_SYMBOL(dev_unicast_unsync);
3315
3316static void __dev_addr_discard(struct dev_addr_list **list)
3317{
3318 struct dev_addr_list *tmp;
3319
3320 while (*list != NULL) {
3321 tmp = *list;
3322 *list = tmp->next;
3323 if (tmp->da_users > tmp->da_gusers)
3324 printk("__dev_addr_discard: address leakage! "
3325 "da_users=%d\n", tmp->da_users);
3326 kfree(tmp);
3327 }
3328}
3329
3330static void dev_addr_discard(struct net_device *dev)
3331{
3332 netif_addr_lock_bh(dev);
3333
3334 __dev_addr_discard(&dev->uc_list);
3335 dev->uc_count = 0;
3336
3337 __dev_addr_discard(&dev->mc_list);
3338 dev->mc_count = 0;
3339
3340 netif_addr_unlock_bh(dev);
3341}
3342
3343
3344
3345
3346
3347
3348
3349unsigned dev_get_flags(const struct net_device *dev)
3350{
3351 unsigned flags;
3352
3353 flags = (dev->flags & ~(IFF_PROMISC |
3354 IFF_ALLMULTI |
3355 IFF_RUNNING |
3356 IFF_LOWER_UP |
3357 IFF_DORMANT)) |
3358 (dev->gflags & (IFF_PROMISC |
3359 IFF_ALLMULTI));
3360
3361 if (netif_running(dev)) {
3362 if (netif_oper_up(dev))
3363 flags |= IFF_RUNNING;
3364 if (netif_carrier_ok(dev))
3365 flags |= IFF_LOWER_UP;
3366 if (netif_dormant(dev))
3367 flags |= IFF_DORMANT;
3368 }
3369
3370 return flags;
3371}
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381int dev_change_flags(struct net_device *dev, unsigned flags)
3382{
3383 int ret, changes;
3384 int old_flags = dev->flags;
3385
3386 ASSERT_RTNL();
3387
3388
3389
3390
3391
3392 dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
3393 IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
3394 IFF_AUTOMEDIA)) |
3395 (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
3396 IFF_ALLMULTI));
3397
3398
3399
3400
3401
3402 if ((old_flags ^ flags) & IFF_MULTICAST)
3403 dev_change_rx_flags(dev, IFF_MULTICAST);
3404
3405 dev_set_rx_mode(dev);
3406
3407
3408
3409
3410
3411
3412
3413 ret = 0;
3414 if ((old_flags ^ flags) & IFF_UP) {
3415 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
3416
3417 if (!ret)
3418 dev_set_rx_mode(dev);
3419 }
3420
3421 if (dev->flags & IFF_UP &&
3422 ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
3423 IFF_VOLATILE)))
3424 call_netdevice_notifiers(NETDEV_CHANGE, dev);
3425
3426 if ((flags ^ dev->gflags) & IFF_PROMISC) {
3427 int inc = (flags & IFF_PROMISC) ? +1 : -1;
3428 dev->gflags ^= IFF_PROMISC;
3429 dev_set_promiscuity(dev, inc);
3430 }
3431
3432
3433
3434
3435
3436 if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
3437 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
3438 dev->gflags ^= IFF_ALLMULTI;
3439 dev_set_allmulti(dev, inc);
3440 }
3441
3442
3443 changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
3444 if (changes)
3445 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
3446
3447 return ret;
3448}
3449
3450
3451
3452
3453
3454
3455
3456
3457int dev_set_mtu(struct net_device *dev, int new_mtu)
3458{
3459 int err;
3460
3461 if (new_mtu == dev->mtu)
3462 return 0;
3463
3464
3465 if (new_mtu < 0)
3466 return -EINVAL;
3467
3468 if (!netif_device_present(dev))
3469 return -ENODEV;
3470
3471 err = 0;
3472 if (dev->change_mtu)
3473 err = dev->change_mtu(dev, new_mtu);
3474 else
3475 dev->mtu = new_mtu;
3476 if (!err && dev->flags & IFF_UP)
3477 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
3478 return err;
3479}
3480
3481
3482
3483
3484
3485
3486
3487
3488int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
3489{
3490 int err;
3491
3492 if (!dev->set_mac_address)
3493 return -EOPNOTSUPP;
3494 if (sa->sa_family != dev->type)
3495 return -EINVAL;
3496 if (!netif_device_present(dev))
3497 return -ENODEV;
3498 err = dev->set_mac_address(dev, sa);
3499 if (!err)
3500 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3501 return err;
3502}
3503
3504
3505
3506
3507static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
3508{
3509 int err;
3510 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3511
3512 if (!dev)
3513 return -ENODEV;
3514
3515 switch (cmd) {
3516 case SIOCGIFFLAGS:
3517 ifr->ifr_flags = dev_get_flags(dev);
3518 return 0;
3519
3520 case SIOCGIFMETRIC:
3521
3522 ifr->ifr_metric = 0;
3523 return 0;
3524
3525 case SIOCGIFMTU:
3526 ifr->ifr_mtu = dev->mtu;
3527 return 0;
3528
3529 case SIOCGIFHWADDR:
3530 if (!dev->addr_len)
3531 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
3532 else
3533 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
3534 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3535 ifr->ifr_hwaddr.sa_family = dev->type;
3536 return 0;
3537
3538 case SIOCGIFSLAVE:
3539 err = -EINVAL;
3540 break;
3541
3542 case SIOCGIFMAP:
3543 ifr->ifr_map.mem_start = dev->mem_start;
3544 ifr->ifr_map.mem_end = dev->mem_end;
3545 ifr->ifr_map.base_addr = dev->base_addr;
3546 ifr->ifr_map.irq = dev->irq;
3547 ifr->ifr_map.dma = dev->dma;
3548 ifr->ifr_map.port = dev->if_port;
3549 return 0;
3550
3551 case SIOCGIFINDEX:
3552 ifr->ifr_ifindex = dev->ifindex;
3553 return 0;
3554
3555 case SIOCGIFTXQLEN:
3556 ifr->ifr_qlen = dev->tx_queue_len;
3557 return 0;
3558
3559 default:
3560
3561
3562
3563 WARN_ON(1);
3564 err = -EINVAL;
3565 break;
3566
3567 }
3568 return err;
3569}
3570
3571
3572
3573
3574static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
3575{
3576 int err;
3577 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3578
3579 if (!dev)
3580 return -ENODEV;
3581
3582 switch (cmd) {
3583 case SIOCSIFFLAGS:
3584 return dev_change_flags(dev, ifr->ifr_flags);
3585
3586 case SIOCSIFMETRIC:
3587
3588 return -EOPNOTSUPP;
3589
3590 case SIOCSIFMTU:
3591 return dev_set_mtu(dev, ifr->ifr_mtu);
3592
3593 case SIOCSIFHWADDR:
3594 return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
3595
3596 case SIOCSIFHWBROADCAST:
3597 if (ifr->ifr_hwaddr.sa_family != dev->type)
3598 return -EINVAL;
3599 memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
3600 min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3601 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3602 return 0;
3603
3604 case SIOCSIFMAP:
3605 if (dev->set_config) {
3606 if (!netif_device_present(dev))
3607 return -ENODEV;
3608 return dev->set_config(dev, &ifr->ifr_map);
3609 }
3610 return -EOPNOTSUPP;
3611
3612 case SIOCADDMULTI:
3613 if ((!dev->set_multicast_list && !dev->set_rx_mode) ||
3614 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3615 return -EINVAL;
3616 if (!netif_device_present(dev))
3617 return -ENODEV;
3618 return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
3619 dev->addr_len, 1);
3620
3621 case SIOCDELMULTI:
3622 if ((!dev->set_multicast_list && !dev->set_rx_mode) ||
3623 ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3624 return -EINVAL;
3625 if (!netif_device_present(dev))
3626 return -ENODEV;
3627 return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
3628 dev->addr_len, 1);
3629
3630 case SIOCSIFTXQLEN:
3631 if (ifr->ifr_qlen < 0)
3632 return -EINVAL;
3633 dev->tx_queue_len = ifr->ifr_qlen;
3634 return 0;
3635
3636 case SIOCSIFNAME:
3637 ifr->ifr_newname[IFNAMSIZ-1] = '\0';
3638 return dev_change_name(dev, ifr->ifr_newname);
3639
3640
3641
3642
3643
3644 default:
3645 if ((cmd >= SIOCDEVPRIVATE &&
3646 cmd <= SIOCDEVPRIVATE + 15) ||
3647 cmd == SIOCBONDENSLAVE ||
3648 cmd == SIOCBONDRELEASE ||
3649 cmd == SIOCBONDSETHWADDR ||
3650 cmd == SIOCBONDSLAVEINFOQUERY ||
3651 cmd == SIOCBONDINFOQUERY ||
3652 cmd == SIOCBONDCHANGEACTIVE ||
3653 cmd == SIOCGMIIPHY ||
3654 cmd == SIOCGMIIREG ||
3655 cmd == SIOCSMIIREG ||
3656 cmd == SIOCBRADDIF ||
3657 cmd == SIOCBRDELIF ||
3658 cmd == SIOCWANDEV) {
3659 err = -EOPNOTSUPP;
3660 if (dev->do_ioctl) {
3661 if (netif_device_present(dev))
3662 err = dev->do_ioctl(dev, ifr,
3663 cmd);
3664 else
3665 err = -ENODEV;
3666 }
3667 } else
3668 err = -EINVAL;
3669
3670 }
3671 return err;
3672}
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
3692{
3693 struct ifreq ifr;
3694 int ret;
3695 char *colon;
3696
3697
3698
3699
3700
3701
3702 if (cmd == SIOCGIFCONF) {
3703 rtnl_lock();
3704 ret = dev_ifconf(net, (char __user *) arg);
3705 rtnl_unlock();
3706 return ret;
3707 }
3708 if (cmd == SIOCGIFNAME)
3709 return dev_ifname(net, (struct ifreq __user *)arg);
3710
3711 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
3712 return -EFAULT;
3713
3714 ifr.ifr_name[IFNAMSIZ-1] = 0;
3715
3716 colon = strchr(ifr.ifr_name, ':');
3717 if (colon)
3718 *colon = 0;
3719
3720
3721
3722
3723
3724 switch (cmd) {
3725
3726
3727
3728
3729
3730
3731 case SIOCGIFFLAGS:
3732 case SIOCGIFMETRIC:
3733 case SIOCGIFMTU:
3734 case SIOCGIFHWADDR:
3735 case SIOCGIFSLAVE:
3736 case SIOCGIFMAP:
3737 case SIOCGIFINDEX:
3738 case SIOCGIFTXQLEN:
3739 dev_load(net, ifr.ifr_name);
3740 read_lock(&dev_base_lock);
3741 ret = dev_ifsioc_locked(net, &ifr, cmd);
3742 read_unlock(&dev_base_lock);
3743 if (!ret) {
3744 if (colon)
3745 *colon = ':';
3746 if (copy_to_user(arg, &ifr,
3747 sizeof(struct ifreq)))
3748 ret = -EFAULT;
3749 }
3750 return ret;
3751
3752 case SIOCETHTOOL:
3753 dev_load(net, ifr.ifr_name);
3754 rtnl_lock();
3755 ret = dev_ethtool(net, &ifr);
3756 rtnl_unlock();
3757 if (!ret) {
3758 if (colon)
3759 *colon = ':';
3760 if (copy_to_user(arg, &ifr,
3761 sizeof(struct ifreq)))
3762 ret = -EFAULT;
3763 }
3764 return ret;
3765
3766
3767
3768
3769
3770
3771
3772 case SIOCGMIIPHY:
3773 case SIOCGMIIREG:
3774 case SIOCSIFNAME:
3775 if (!capable(CAP_NET_ADMIN))
3776 return -EPERM;
3777 dev_load(net, ifr.ifr_name);
3778 rtnl_lock();
3779 ret = dev_ifsioc(net, &ifr, cmd);
3780 rtnl_unlock();
3781 if (!ret) {
3782 if (colon)
3783 *colon = ':';
3784 if (copy_to_user(arg, &ifr,
3785 sizeof(struct ifreq)))
3786 ret = -EFAULT;
3787 }
3788 return ret;
3789
3790
3791
3792
3793
3794
3795
3796 case SIOCSIFFLAGS:
3797 case SIOCSIFMETRIC:
3798 case SIOCSIFMTU:
3799 case SIOCSIFMAP:
3800 case SIOCSIFHWADDR:
3801 case SIOCSIFSLAVE:
3802 case SIOCADDMULTI:
3803 case SIOCDELMULTI:
3804 case SIOCSIFHWBROADCAST:
3805 case SIOCSIFTXQLEN:
3806 case SIOCSMIIREG:
3807 case SIOCBONDENSLAVE:
3808 case SIOCBONDRELEASE:
3809 case SIOCBONDSETHWADDR:
3810 case SIOCBONDCHANGEACTIVE:
3811 case SIOCBRADDIF:
3812 case SIOCBRDELIF:
3813 if (!capable(CAP_NET_ADMIN))
3814 return -EPERM;
3815
3816 case SIOCBONDSLAVEINFOQUERY:
3817 case SIOCBONDINFOQUERY:
3818 dev_load(net, ifr.ifr_name);
3819 rtnl_lock();
3820 ret = dev_ifsioc(net, &ifr, cmd);
3821 rtnl_unlock();
3822 return ret;
3823
3824 case SIOCGIFMEM:
3825
3826
3827 case SIOCSIFMEM:
3828
3829
3830 case SIOCSIFLINK:
3831 return -EINVAL;
3832
3833
3834
3835
3836 default:
3837 if (cmd == SIOCWANDEV ||
3838 (cmd >= SIOCDEVPRIVATE &&
3839 cmd <= SIOCDEVPRIVATE + 15)) {
3840 dev_load(net, ifr.ifr_name);
3841 rtnl_lock();
3842 ret = dev_ifsioc(net, &ifr, cmd);
3843 rtnl_unlock();
3844 if (!ret && copy_to_user(arg, &ifr,
3845 sizeof(struct ifreq)))
3846 ret = -EFAULT;
3847 return ret;
3848 }
3849
3850 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
3851 return wext_handle_ioctl(net, &ifr, cmd, arg);
3852 return -EINVAL;
3853 }
3854}
3855
3856
3857
3858
3859
3860
3861
3862
3863
3864
3865static int dev_new_index(struct net *net)
3866{
3867 static int ifindex;
3868 for (;;) {
3869 if (++ifindex <= 0)
3870 ifindex = 1;
3871 if (!__dev_get_by_index(net, ifindex))
3872 return ifindex;
3873 }
3874}
3875
3876
3877static LIST_HEAD(net_todo_list);
3878
3879static void net_set_todo(struct net_device *dev)
3880{
3881 list_add_tail(&dev->todo_list, &net_todo_list);
3882}
3883
3884static void rollback_registered(struct net_device *dev)
3885{
3886 BUG_ON(dev_boot_phase);
3887 ASSERT_RTNL();
3888
3889
3890 if (dev->reg_state == NETREG_UNINITIALIZED) {
3891 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
3892 "was registered\n", dev->name, dev);
3893
3894 WARN_ON(1);
3895 return;
3896 }
3897
3898 BUG_ON(dev->reg_state != NETREG_REGISTERED);
3899
3900
3901 dev_close(dev);
3902
3903
3904 unlist_netdevice(dev);
3905
3906 dev->reg_state = NETREG_UNREGISTERING;
3907
3908 synchronize_net();
3909
3910
3911 dev_shutdown(dev);
3912
3913
3914
3915
3916
3917 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
3918
3919
3920
3921
3922 dev_addr_discard(dev);
3923
3924 if (dev->uninit)
3925 dev->uninit(dev);
3926
3927
3928 WARN_ON(dev->master);
3929
3930
3931 netdev_unregister_kobject(dev);
3932
3933 synchronize_net();
3934
3935 dev_put(dev);
3936}
3937
3938static void __netdev_init_queue_locks_one(struct net_device *dev,
3939 struct netdev_queue *dev_queue,
3940 void *_unused)
3941{
3942 spin_lock_init(&dev_queue->_xmit_lock);
3943 netdev_set_xmit_lockdep_class(&dev_queue->_xmit_lock, dev->type);
3944 dev_queue->xmit_lock_owner = -1;
3945}
3946
3947static void netdev_init_queue_locks(struct net_device *dev)
3948{
3949 netdev_for_each_tx_queue(dev, __netdev_init_queue_locks_one, NULL);
3950 __netdev_init_queue_locks_one(dev, &dev->rx_queue, NULL);
3951}
3952
3953unsigned long netdev_fix_features(unsigned long features, const char *name)
3954{
3955
3956 if ((features & NETIF_F_SG) &&
3957 !(features & NETIF_F_ALL_CSUM)) {
3958 if (name)
3959 printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no "
3960 "checksum feature.\n", name);
3961 features &= ~NETIF_F_SG;
3962 }
3963
3964
3965 if ((features & NETIF_F_TSO) && !(features & NETIF_F_SG)) {
3966 if (name)
3967 printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no "
3968 "SG feature.\n", name);
3969 features &= ~NETIF_F_TSO;
3970 }
3971
3972 if (features & NETIF_F_UFO) {
3973 if (!(features & NETIF_F_GEN_CSUM)) {
3974 if (name)
3975 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
3976 "since no NETIF_F_HW_CSUM feature.\n",
3977 name);
3978 features &= ~NETIF_F_UFO;
3979 }
3980
3981 if (!(features & NETIF_F_SG)) {
3982 if (name)
3983 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
3984 "since no NETIF_F_SG feature.\n", name);
3985 features &= ~NETIF_F_UFO;
3986 }
3987 }
3988
3989 return features;
3990}
3991EXPORT_SYMBOL(netdev_fix_features);
3992
3993
3994
3995
3996
3997
3998
3999
4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010int register_netdevice(struct net_device *dev)
4011{
4012 struct hlist_head *head;
4013 struct hlist_node *p;
4014 int ret;
4015 struct net *net;
4016
4017 BUG_ON(dev_boot_phase);
4018 ASSERT_RTNL();
4019
4020 might_sleep();
4021
4022
4023 BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
4024 BUG_ON(!dev_net(dev));
4025 net = dev_net(dev);
4026
4027 spin_lock_init(&dev->addr_list_lock);
4028 netdev_set_addr_lockdep_class(dev);
4029 netdev_init_queue_locks(dev);
4030
4031 dev->iflink = -1;
4032
4033
4034 if (dev->init) {
4035 ret = dev->init(dev);
4036 if (ret) {
4037 if (ret > 0)
4038 ret = -EIO;
4039 goto out;
4040 }
4041 }
4042
4043 if (!dev_valid_name(dev->name)) {
4044 ret = -EINVAL;
4045 goto err_uninit;
4046 }
4047
4048 dev->ifindex = dev_new_index(net);
4049 if (dev->iflink == -1)
4050 dev->iflink = dev->ifindex;
4051
4052
4053 head = dev_name_hash(net, dev->name);
4054 hlist_for_each(p, head) {
4055 struct net_device *d
4056 = hlist_entry(p, struct net_device, name_hlist);
4057 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
4058 ret = -EEXIST;
4059 goto err_uninit;
4060 }
4061 }
4062
4063
4064 if ((dev->features & NETIF_F_HW_CSUM) &&
4065 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
4066 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
4067 dev->name);
4068 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4069 }
4070
4071 if ((dev->features & NETIF_F_NO_CSUM) &&
4072 (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
4073 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
4074 dev->name);
4075 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
4076 }
4077
4078 dev->features = netdev_fix_features(dev->features, dev->name);
4079
4080
4081 if (dev->features & NETIF_F_SG)
4082 dev->features |= NETIF_F_GSO;
4083
4084 netdev_initialize_kobject(dev);
4085 ret = netdev_register_kobject(dev);
4086 if (ret)
4087 goto err_uninit;
4088 dev->reg_state = NETREG_REGISTERED;
4089
4090
4091
4092
4093
4094
4095 set_bit(__LINK_STATE_PRESENT, &dev->state);
4096
4097 dev_init_scheduler(dev);
4098 dev_hold(dev);
4099 list_netdevice(dev);
4100
4101
4102 ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
4103 ret = notifier_to_errno(ret);
4104 if (ret) {
4105 rollback_registered(dev);
4106 dev->reg_state = NETREG_UNREGISTERED;
4107 }
4108
4109out:
4110 return ret;
4111
4112err_uninit:
4113 if (dev->uninit)
4114 dev->uninit(dev);
4115 goto out;
4116}
4117
4118
4119
4120
4121
4122
4123
4124
4125
4126
4127
4128
4129
4130
4131int register_netdev(struct net_device *dev)
4132{
4133 int err;
4134
4135 rtnl_lock();
4136
4137
4138
4139
4140
4141 if (strchr(dev->name, '%')) {
4142 err = dev_alloc_name(dev, dev->name);
4143 if (err < 0)
4144 goto out;
4145 }
4146
4147 err = register_netdevice(dev);
4148out:
4149 rtnl_unlock();
4150 return err;
4151}
4152EXPORT_SYMBOL(register_netdev);
4153
4154
4155
4156
4157
4158
4159
4160
4161
4162
4163
4164
4165static void netdev_wait_allrefs(struct net_device *dev)
4166{
4167 unsigned long rebroadcast_time, warning_time;
4168
4169 rebroadcast_time = warning_time = jiffies;
4170 while (atomic_read(&dev->refcnt) != 0) {
4171 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
4172 rtnl_lock();
4173
4174
4175 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4176
4177 if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
4178 &dev->state)) {
4179
4180
4181
4182
4183
4184
4185 linkwatch_run_queue();
4186 }
4187
4188 __rtnl_unlock();
4189
4190 rebroadcast_time = jiffies;
4191 }
4192
4193 msleep(250);
4194
4195 if (time_after(jiffies, warning_time + 10 * HZ)) {
4196 printk(KERN_EMERG "unregister_netdevice: "
4197 "waiting for %s to become free. Usage "
4198 "count = %d\n",
4199 dev->name, atomic_read(&dev->refcnt));
4200 warning_time = jiffies;
4201 }
4202 }
4203}
4204
4205
4206
4207
4208
4209
4210
4211
4212
4213
4214
4215
4216
4217
4218
4219
4220
4221
4222
4223
4224
4225
4226
4227
4228
4229void netdev_run_todo(void)
4230{
4231 struct list_head list;
4232
4233
4234 list_replace_init(&net_todo_list, &list);
4235
4236 __rtnl_unlock();
4237
4238 while (!list_empty(&list)) {
4239 struct net_device *dev
4240 = list_entry(list.next, struct net_device, todo_list);
4241 list_del(&dev->todo_list);
4242
4243 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
4244 printk(KERN_ERR "network todo '%s' but state %d\n",
4245 dev->name, dev->reg_state);
4246 dump_stack();
4247 continue;
4248 }
4249
4250 dev->reg_state = NETREG_UNREGISTERED;
4251
4252 on_each_cpu(flush_backlog, dev, 1);
4253
4254 netdev_wait_allrefs(dev);
4255
4256
4257 BUG_ON(atomic_read(&dev->refcnt));
4258 WARN_ON(dev->ip_ptr);
4259 WARN_ON(dev->ip6_ptr);
4260 WARN_ON(dev->dn_ptr);
4261
4262 if (dev->destructor)
4263 dev->destructor(dev);
4264
4265
4266 kobject_put(&dev->dev.kobj);
4267 }
4268}
4269
4270static struct net_device_stats *internal_stats(struct net_device *dev)
4271{
4272 return &dev->stats;
4273}
4274
4275static void netdev_init_one_queue(struct net_device *dev,
4276 struct netdev_queue *queue,
4277 void *_unused)
4278{
4279 queue->dev = dev;
4280}
4281
4282static void netdev_init_queues(struct net_device *dev)
4283{
4284 netdev_init_one_queue(dev, &dev->rx_queue, NULL);
4285 netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
4286 spin_lock_init(&dev->tx_global_lock);
4287}
4288
4289
4290
4291
4292
4293
4294
4295
4296
4297
4298
4299
4300struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
4301 void (*setup)(struct net_device *), unsigned int queue_count)
4302{
4303 struct netdev_queue *tx;
4304 struct net_device *dev;
4305 size_t alloc_size;
4306 void *p;
4307
4308 BUG_ON(strlen(name) >= sizeof(dev->name));
4309
4310 alloc_size = sizeof(struct net_device);
4311 if (sizeof_priv) {
4312
4313 alloc_size = (alloc_size + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
4314 alloc_size += sizeof_priv;
4315 }
4316
4317 alloc_size += NETDEV_ALIGN_CONST;
4318
4319 p = kzalloc(alloc_size, GFP_KERNEL);
4320 if (!p) {
4321 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
4322 return NULL;
4323 }
4324
4325 tx = kcalloc(queue_count, sizeof(struct netdev_queue), GFP_KERNEL);
4326 if (!tx) {
4327 printk(KERN_ERR "alloc_netdev: Unable to allocate "
4328 "tx qdiscs.\n");
4329 kfree(p);
4330 return NULL;
4331 }
4332
4333 dev = (struct net_device *)
4334 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
4335 dev->padded = (char *)dev - (char *)p;
4336 dev_net_set(dev, &init_net);
4337
4338 dev->_tx = tx;
4339 dev->num_tx_queues = queue_count;
4340 dev->real_num_tx_queues = queue_count;
4341
4342 if (sizeof_priv) {
4343 dev->priv = ((char *)dev +
4344 ((sizeof(struct net_device) + NETDEV_ALIGN_CONST)
4345 & ~NETDEV_ALIGN_CONST));
4346 }
4347
4348 dev->gso_max_size = GSO_MAX_SIZE;
4349
4350 netdev_init_queues(dev);
4351
4352 dev->get_stats = internal_stats;
4353 netpoll_netdev_init(dev);
4354 setup(dev);
4355 strcpy(dev->name, name);
4356 return dev;
4357}
4358EXPORT_SYMBOL(alloc_netdev_mq);
4359
4360
4361
4362
4363
4364
4365
4366
4367
4368void free_netdev(struct net_device *dev)
4369{
4370 release_net(dev_net(dev));
4371
4372 kfree(dev->_tx);
4373
4374
4375 if (dev->reg_state == NETREG_UNINITIALIZED) {
4376 kfree((char *)dev - dev->padded);
4377 return;
4378 }
4379
4380 BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
4381 dev->reg_state = NETREG_RELEASED;
4382
4383
4384 put_device(&dev->dev);
4385}
4386
4387
4388
4389
4390
4391
4392
4393void synchronize_net(void)
4394{
4395 might_sleep();
4396 synchronize_rcu();
4397}
4398
4399
4400
4401
4402
4403
4404
4405
4406
4407
4408
4409
4410void unregister_netdevice(struct net_device *dev)
4411{
4412 ASSERT_RTNL();
4413
4414 rollback_registered(dev);
4415
4416 net_set_todo(dev);
4417}
4418
4419
4420
4421
4422
4423
4424
4425
4426
4427
4428
4429
4430void unregister_netdev(struct net_device *dev)
4431{
4432 rtnl_lock();
4433 unregister_netdevice(dev);
4434 rtnl_unlock();
4435}
4436
4437EXPORT_SYMBOL(unregister_netdev);
4438
4439
4440
4441
4442
4443
4444
4445
4446
4447
4448
4449
4450
4451
4452
4453int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
4454{
4455 char buf[IFNAMSIZ];
4456 const char *destname;
4457 int err;
4458
4459 ASSERT_RTNL();
4460
4461
4462 err = -EINVAL;
4463 if (dev->features & NETIF_F_NETNS_LOCAL)
4464 goto out;
4465
4466
4467 err = -EINVAL;
4468 if (dev->reg_state != NETREG_REGISTERED)
4469 goto out;
4470
4471
4472 err = 0;
4473 if (net_eq(dev_net(dev), net))
4474 goto out;
4475
4476
4477
4478
4479 err = -EEXIST;
4480 destname = dev->name;
4481 if (__dev_get_by_name(net, destname)) {
4482
4483 if (!pat)
4484 goto out;
4485 if (!dev_valid_name(pat))
4486 goto out;
4487 if (strchr(pat, '%')) {
4488 if (__dev_alloc_name(net, pat, buf) < 0)
4489 goto out;
4490 destname = buf;
4491 } else
4492 destname = pat;
4493 if (__dev_get_by_name(net, destname))
4494 goto out;
4495 }
4496
4497
4498
4499
4500
4501
4502 dev_close(dev);
4503
4504
4505 err = -ENODEV;
4506 unlist_netdevice(dev);
4507
4508 synchronize_net();
4509
4510
4511 dev_shutdown(dev);
4512
4513
4514
4515
4516 call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4517
4518
4519
4520
4521 dev_addr_discard(dev);
4522
4523
4524 dev_net_set(dev, net);
4525
4526
4527 if (destname != dev->name)
4528 strcpy(dev->name, destname);
4529
4530
4531 if (__dev_get_by_index(net, dev->ifindex)) {
4532 int iflink = (dev->iflink == dev->ifindex);
4533 dev->ifindex = dev_new_index(net);
4534 if (iflink)
4535 dev->iflink = dev->ifindex;
4536 }
4537
4538
4539 netdev_unregister_kobject(dev);
4540 err = netdev_register_kobject(dev);
4541 WARN_ON(err);
4542
4543
4544 list_netdevice(dev);
4545
4546
4547 call_netdevice_notifiers(NETDEV_REGISTER, dev);
4548
4549 synchronize_net();
4550 err = 0;
4551out:
4552 return err;
4553}
4554
4555static int dev_cpu_callback(struct notifier_block *nfb,
4556 unsigned long action,
4557 void *ocpu)
4558{
4559 struct sk_buff **list_skb;
4560 struct Qdisc **list_net;
4561 struct sk_buff *skb;
4562 unsigned int cpu, oldcpu = (unsigned long)ocpu;
4563 struct softnet_data *sd, *oldsd;
4564
4565 if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
4566 return NOTIFY_OK;
4567
4568 local_irq_disable();
4569 cpu = smp_processor_id();
4570 sd = &per_cpu(softnet_data, cpu);
4571 oldsd = &per_cpu(softnet_data, oldcpu);
4572
4573
4574 list_skb = &sd->completion_queue;
4575 while (*list_skb)
4576 list_skb = &(*list_skb)->next;
4577
4578 *list_skb = oldsd->completion_queue;
4579 oldsd->completion_queue = NULL;
4580
4581
4582 list_net = &sd->output_queue;
4583 while (*list_net)
4584 list_net = &(*list_net)->next_sched;
4585
4586 *list_net = oldsd->output_queue;
4587 oldsd->output_queue = NULL;
4588
4589 raise_softirq_irqoff(NET_TX_SOFTIRQ);
4590 local_irq_enable();
4591
4592
4593 while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
4594 netif_rx(skb);
4595
4596 return NOTIFY_OK;
4597}
4598
4599#ifdef CONFIG_NET_DMA
4600
4601
4602
4603
4604
4605
4606
4607
4608static void net_dma_rebalance(struct net_dma *net_dma)
4609{
4610 unsigned int cpu, i, n, chan_idx;
4611 struct dma_chan *chan;
4612
4613 if (cpus_empty(net_dma->channel_mask)) {
4614 for_each_online_cpu(cpu)
4615 rcu_assign_pointer(per_cpu(softnet_data, cpu).net_dma, NULL);
4616 return;
4617 }
4618
4619 i = 0;
4620 cpu = first_cpu(cpu_online_map);
4621
4622 for_each_cpu_mask_nr(chan_idx, net_dma->channel_mask) {
4623 chan = net_dma->channels[chan_idx];
4624
4625 n = ((num_online_cpus() / cpus_weight(net_dma->channel_mask))
4626 + (i < (num_online_cpus() %
4627 cpus_weight(net_dma->channel_mask)) ? 1 : 0));
4628
4629 while(n) {
4630 per_cpu(softnet_data, cpu).net_dma = chan;
4631 cpu = next_cpu(cpu, cpu_online_map);
4632 n--;
4633 }
4634 i++;
4635 }
4636}
4637
4638
4639
4640
4641
4642
4643
4644static enum dma_state_client
4645netdev_dma_event(struct dma_client *client, struct dma_chan *chan,
4646 enum dma_state state)
4647{
4648 int i, found = 0, pos = -1;
4649 struct net_dma *net_dma =
4650 container_of(client, struct net_dma, client);
4651 enum dma_state_client ack = DMA_DUP;
4652
4653 spin_lock(&net_dma->lock);
4654 switch (state) {
4655 case DMA_RESOURCE_AVAILABLE:
4656 for (i = 0; i < nr_cpu_ids; i++)
4657 if (net_dma->channels[i] == chan) {
4658 found = 1;
4659 break;
4660 } else if (net_dma->channels[i] == NULL && pos < 0)
4661 pos = i;
4662
4663 if (!found && pos >= 0) {
4664 ack = DMA_ACK;
4665 net_dma->channels[pos] = chan;
4666 cpu_set(pos, net_dma->channel_mask);
4667 net_dma_rebalance(net_dma);
4668 }
4669 break;
4670 case DMA_RESOURCE_REMOVED:
4671 for (i = 0; i < nr_cpu_ids; i++)
4672 if (net_dma->channels[i] == chan) {
4673 found = 1;
4674 pos = i;
4675 break;
4676 }
4677
4678 if (found) {
4679 ack = DMA_ACK;
4680 cpu_clear(pos, net_dma->channel_mask);
4681 net_dma->channels[i] = NULL;
4682 net_dma_rebalance(net_dma);
4683 }
4684 break;
4685 default:
4686 break;
4687 }
4688 spin_unlock(&net_dma->lock);
4689
4690 return ack;
4691}
4692
4693
4694
4695
4696static int __init netdev_dma_register(void)
4697{
4698 net_dma.channels = kzalloc(nr_cpu_ids * sizeof(struct net_dma),
4699 GFP_KERNEL);
4700 if (unlikely(!net_dma.channels)) {
4701 printk(KERN_NOTICE
4702 "netdev_dma: no memory for net_dma.channels\n");
4703 return -ENOMEM;
4704 }
4705 spin_lock_init(&net_dma.lock);
4706 dma_cap_set(DMA_MEMCPY, net_dma.client.cap_mask);
4707 dma_async_client_register(&net_dma.client);
4708 dma_async_client_chan_request(&net_dma.client);
4709 return 0;
4710}
4711
4712#else
4713static int __init netdev_dma_register(void) { return -ENODEV; }
4714#endif
4715
4716
4717
4718
4719
4720
4721
4722
4723
4724
4725
4726unsigned long netdev_increment_features(unsigned long all, unsigned long one,
4727 unsigned long mask)
4728{
4729
4730 if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
4731 all ^= NETIF_F_NO_CSUM | (one & NETIF_F_ALL_CSUM);
4732 else if (mask & NETIF_F_ALL_CSUM) {
4733
4734 if (one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM) &&
4735 !(all & NETIF_F_GEN_CSUM)) {
4736 all &= ~NETIF_F_ALL_CSUM;
4737 all |= one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
4738 }
4739
4740
4741 if (one & NETIF_F_GEN_CSUM && !(all & NETIF_F_GEN_CSUM)) {
4742 all &= ~NETIF_F_ALL_CSUM;
4743 all |= NETIF_F_HW_CSUM;
4744 }
4745 }
4746
4747 one |= NETIF_F_ALL_CSUM;
4748
4749 one |= all & NETIF_F_ONE_FOR_ALL;
4750 all &= one | NETIF_F_LLTX | NETIF_F_GSO;
4751 all |= one & mask & NETIF_F_ONE_FOR_ALL;
4752
4753 return all;
4754}
4755EXPORT_SYMBOL(netdev_increment_features);
4756
4757static struct hlist_head *netdev_create_hash(void)
4758{
4759 int i;
4760 struct hlist_head *hash;
4761
4762 hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
4763 if (hash != NULL)
4764 for (i = 0; i < NETDEV_HASHENTRIES; i++)
4765 INIT_HLIST_HEAD(&hash[i]);
4766
4767 return hash;
4768}
4769
4770
4771static int __net_init netdev_init(struct net *net)
4772{
4773 INIT_LIST_HEAD(&net->dev_base_head);
4774
4775 net->dev_name_head = netdev_create_hash();
4776 if (net->dev_name_head == NULL)
4777 goto err_name;
4778
4779 net->dev_index_head = netdev_create_hash();
4780 if (net->dev_index_head == NULL)
4781 goto err_idx;
4782
4783 return 0;
4784
4785err_idx:
4786 kfree(net->dev_name_head);
4787err_name:
4788 return -ENOMEM;
4789}
4790
4791
4792
4793
4794
4795
4796
4797
4798
4799char *netdev_drivername(const struct net_device *dev, char *buffer, int len)
4800{
4801 const struct device_driver *driver;
4802 const struct device *parent;
4803
4804 if (len <= 0 || !buffer)
4805 return buffer;
4806 buffer[0] = 0;
4807
4808 parent = dev->dev.parent;
4809
4810 if (!parent)
4811 return buffer;
4812
4813 driver = parent->driver;
4814 if (driver && driver->name)
4815 strlcpy(buffer, driver->name, len);
4816 return buffer;
4817}
4818
4819static void __net_exit netdev_exit(struct net *net)
4820{
4821 kfree(net->dev_name_head);
4822 kfree(net->dev_index_head);
4823}
4824
4825static struct pernet_operations __net_initdata netdev_net_ops = {
4826 .init = netdev_init,
4827 .exit = netdev_exit,
4828};
4829
4830static void __net_exit default_device_exit(struct net *net)
4831{
4832 struct net_device *dev, *next;
4833
4834
4835
4836
4837 rtnl_lock();
4838 for_each_netdev_safe(net, dev, next) {
4839 int err;
4840 char fb_name[IFNAMSIZ];
4841
4842
4843 if (dev->features & NETIF_F_NETNS_LOCAL)
4844 continue;
4845
4846
4847 snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
4848 err = dev_change_net_namespace(dev, &init_net, fb_name);
4849 if (err) {
4850 printk(KERN_EMERG "%s: failed to move %s to init_net: %d\n",
4851 __func__, dev->name, err);
4852 BUG();
4853 }
4854 }
4855 rtnl_unlock();
4856}
4857
4858static struct pernet_operations __net_initdata default_device_ops = {
4859 .exit = default_device_exit,
4860};
4861
4862
4863
4864
4865
4866
4867
4868
4869
4870
4871
4872
4873static int __init net_dev_init(void)
4874{
4875 int i, rc = -ENOMEM;
4876
4877 BUG_ON(!dev_boot_phase);
4878
4879 if (dev_proc_init())
4880 goto out;
4881
4882 if (netdev_kobject_init())
4883 goto out;
4884
4885 INIT_LIST_HEAD(&ptype_all);
4886 for (i = 0; i < PTYPE_HASH_SIZE; i++)
4887 INIT_LIST_HEAD(&ptype_base[i]);
4888
4889 if (register_pernet_subsys(&netdev_net_ops))
4890 goto out;
4891
4892 if (register_pernet_device(&default_device_ops))
4893 goto out;
4894
4895
4896
4897
4898
4899 for_each_possible_cpu(i) {
4900 struct softnet_data *queue;
4901
4902 queue = &per_cpu(softnet_data, i);
4903 skb_queue_head_init(&queue->input_pkt_queue);
4904 queue->completion_queue = NULL;
4905 INIT_LIST_HEAD(&queue->poll_list);
4906
4907 queue->backlog.poll = process_backlog;
4908 queue->backlog.weight = weight_p;
4909 }
4910
4911 netdev_dma_register();
4912
4913 dev_boot_phase = 0;
4914
4915 open_softirq(NET_TX_SOFTIRQ, net_tx_action);
4916 open_softirq(NET_RX_SOFTIRQ, net_rx_action);
4917
4918 hotcpu_notifier(dev_cpu_callback, 0);
4919 dst_init();
4920 dev_mcast_init();
4921 rc = 0;
4922out:
4923 return rc;
4924}
4925
4926subsys_initcall(net_dev_init);
4927
4928EXPORT_SYMBOL(__dev_get_by_index);
4929EXPORT_SYMBOL(__dev_get_by_name);
4930EXPORT_SYMBOL(__dev_remove_pack);
4931EXPORT_SYMBOL(dev_valid_name);
4932EXPORT_SYMBOL(dev_add_pack);
4933EXPORT_SYMBOL(dev_alloc_name);
4934EXPORT_SYMBOL(dev_close);
4935EXPORT_SYMBOL(dev_get_by_flags);
4936EXPORT_SYMBOL(dev_get_by_index);
4937EXPORT_SYMBOL(dev_get_by_name);
4938EXPORT_SYMBOL(dev_open);
4939EXPORT_SYMBOL(dev_queue_xmit);
4940EXPORT_SYMBOL(dev_remove_pack);
4941EXPORT_SYMBOL(dev_set_allmulti);
4942EXPORT_SYMBOL(dev_set_promiscuity);
4943EXPORT_SYMBOL(dev_change_flags);
4944EXPORT_SYMBOL(dev_set_mtu);
4945EXPORT_SYMBOL(dev_set_mac_address);
4946EXPORT_SYMBOL(free_netdev);
4947EXPORT_SYMBOL(netdev_boot_setup_check);
4948EXPORT_SYMBOL(netdev_set_master);
4949EXPORT_SYMBOL(netdev_state_change);
4950EXPORT_SYMBOL(netif_receive_skb);
4951EXPORT_SYMBOL(netif_rx);
4952EXPORT_SYMBOL(register_gifconf);
4953EXPORT_SYMBOL(register_netdevice);
4954EXPORT_SYMBOL(register_netdevice_notifier);
4955EXPORT_SYMBOL(skb_checksum_help);
4956EXPORT_SYMBOL(synchronize_net);
4957EXPORT_SYMBOL(unregister_netdevice);
4958EXPORT_SYMBOL(unregister_netdevice_notifier);
4959EXPORT_SYMBOL(net_enable_timestamp);
4960EXPORT_SYMBOL(net_disable_timestamp);
4961EXPORT_SYMBOL(dev_get_flags);
4962
4963#if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
4964EXPORT_SYMBOL(br_handle_frame_hook);
4965EXPORT_SYMBOL(br_fdb_get_hook);
4966EXPORT_SYMBOL(br_fdb_put_hook);
4967#endif
4968
4969EXPORT_SYMBOL(dev_load);
4970
4971EXPORT_PER_CPU_SYMBOL(softnet_data);