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