Add constants for the ieee 802.15.4 stack
[linux-2.6.git] / net / core / dev.c
1 /*
2  *      NET3    Protocol independent device support routines.
3  *
4  *              This program is free software; you can redistribute it and/or
5  *              modify it under the terms of the GNU General Public License
6  *              as published by the Free Software Foundation; either version
7  *              2 of the License, or (at your option) any later version.
8  *
9  *      Derived from the non IP parts of dev.c 1.0.19
10  *              Authors:        Ross Biro
11  *                              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12  *                              Mark Evans, <evansmp@uhura.aston.ac.uk>
13  *
14  *      Additional Authors:
15  *              Florian la Roche <rzsfl@rz.uni-sb.de>
16  *              Alan Cox <gw4pts@gw4pts.ampr.org>
17  *              David Hinds <dahinds@users.sourceforge.net>
18  *              Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
19  *              Adam Sulmicki <adam@cfar.umd.edu>
20  *              Pekka Riikonen <priikone@poesidon.pspt.fi>
21  *
22  *      Changes:
23  *              D.J. Barrow     :       Fixed bug where dev->refcnt gets set
24  *                                      to 2 if register_netdev gets called
25  *                                      before net_dev_init & also removed a
26  *                                      few lines of code in the process.
27  *              Alan Cox        :       device private ioctl copies fields back.
28  *              Alan Cox        :       Transmit queue code does relevant
29  *                                      stunts to keep the queue safe.
30  *              Alan Cox        :       Fixed double lock.
31  *              Alan Cox        :       Fixed promisc NULL pointer trap
32  *              ????????        :       Support the full private ioctl range
33  *              Alan Cox        :       Moved ioctl permission check into
34  *                                      drivers
35  *              Tim Kordas      :       SIOCADDMULTI/SIOCDELMULTI
36  *              Alan Cox        :       100 backlog just doesn't cut it when
37  *                                      you start doing multicast video 8)
38  *              Alan Cox        :       Rewrote net_bh and list manager.
39  *              Alan Cox        :       Fix ETH_P_ALL echoback lengths.
40  *              Alan Cox        :       Took out transmit every packet pass
41  *                                      Saved a few bytes in the ioctl handler
42  *              Alan Cox        :       Network driver sets packet type before
43  *                                      calling netif_rx. Saves a function
44  *                                      call a packet.
45  *              Alan Cox        :       Hashed net_bh()
46  *              Richard Kooijman:       Timestamp fixes.
47  *              Alan Cox        :       Wrong field in SIOCGIFDSTADDR
48  *              Alan Cox        :       Device lock protection.
49  *              Alan Cox        :       Fixed nasty side effect of device close
50  *                                      changes.
51  *              Rudi Cilibrasi  :       Pass the right thing to
52  *                                      set_mac_address()
53  *              Dave Miller     :       32bit quantity for the device lock to
54  *                                      make it work out on a Sparc.
55  *              Bjorn Ekwall    :       Added KERNELD hack.
56  *              Alan Cox        :       Cleaned up the backlog initialise.
57  *              Craig Metz      :       SIOCGIFCONF fix if space for under
58  *                                      1 device.
59  *          Thomas Bogendoerfer :       Return ENODEV for dev_open, if there
60  *                                      is no device open function.
61  *              Andi Kleen      :       Fix error reporting for SIOCGIFCONF
62  *          Michael Chastain    :       Fix signed/unsigned for SIOCGIFCONF
63  *              Cyrus Durgin    :       Cleaned for KMOD
64  *              Adam Sulmicki   :       Bug Fix : Network Device Unload
65  *                                      A network device unload needs to purge
66  *                                      the backlog queue.
67  *      Paul Rusty Russell      :       SIOCSIFNAME
68  *              Pekka Riikonen  :       Netdev boot-time settings code
69  *              Andrew Morton   :       Make unregister_netdevice wait
70  *                                      indefinitely on dev->refcnt
71  *              J Hadi Salim    :       - Backlog queue sampling
72  *                                      - netif_rx() feedback
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 #include <trace/napi.h>
130
131 #include "net-sysfs.h"
132
133 /* Instead of increasing this, you should create a hash table. */
134 #define MAX_GRO_SKBS 8
135
136 /* This should be increased if a protocol with a bigger head is added. */
137 #define GRO_MAX_HEAD (MAX_HEADER + 128)
138
139 /*
140  *      The list of packet types we will receive (as opposed to discard)
141  *      and the routines to invoke.
142  *
143  *      Why 16. Because with 16 the only overlap we get on a hash of the
144  *      low nibble of the protocol value is RARP/SNAP/X.25.
145  *
146  *      NOTE:  That is no longer true with the addition of VLAN tags.  Not
147  *             sure which should go first, but I bet it won't make much
148  *             difference if we are running VLANs.  The good news is that
149  *             this protocol won't be in the list unless compiled in, so
150  *             the average user (w/out VLANs) will not be adversely affected.
151  *             --BLG
152  *
153  *              0800    IP
154  *              8100    802.1Q VLAN
155  *              0001    802.3
156  *              0002    AX.25
157  *              0004    802.2
158  *              8035    RARP
159  *              0005    SNAP
160  *              0805    X.25
161  *              0806    ARP
162  *              8137    IPX
163  *              0009    Localtalk
164  *              86DD    IPv6
165  */
166
167 #define PTYPE_HASH_SIZE (16)
168 #define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
169
170 static DEFINE_SPINLOCK(ptype_lock);
171 static struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly;
172 static struct list_head ptype_all __read_mostly;        /* Taps */
173
174 /*
175  * The @dev_base_head list is protected by @dev_base_lock and the rtnl
176  * semaphore.
177  *
178  * Pure readers hold dev_base_lock for reading.
179  *
180  * Writers must hold the rtnl semaphore while they loop through the
181  * dev_base_head list, and hold dev_base_lock for writing when they do the
182  * actual updates.  This allows pure readers to access the list even
183  * while a writer is preparing to update it.
184  *
185  * To put it another way, dev_base_lock is held for writing only to
186  * protect against pure readers; the rtnl semaphore provides the
187  * protection against other writers.
188  *
189  * See, for example usages, register_netdevice() and
190  * unregister_netdevice(), which must be called with the rtnl
191  * semaphore held.
192  */
193 DEFINE_RWLOCK(dev_base_lock);
194
195 EXPORT_SYMBOL(dev_base_lock);
196
197 #define NETDEV_HASHBITS 8
198 #define NETDEV_HASHENTRIES (1 << NETDEV_HASHBITS)
199
200 static inline struct hlist_head *dev_name_hash(struct net *net, const char *name)
201 {
202         unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ));
203         return &net->dev_name_head[hash & ((1 << NETDEV_HASHBITS) - 1)];
204 }
205
206 static inline struct hlist_head *dev_index_hash(struct net *net, int ifindex)
207 {
208         return &net->dev_index_head[ifindex & ((1 << NETDEV_HASHBITS) - 1)];
209 }
210
211 /* Device list insertion */
212 static int list_netdevice(struct net_device *dev)
213 {
214         struct net *net = dev_net(dev);
215
216         ASSERT_RTNL();
217
218         write_lock_bh(&dev_base_lock);
219         list_add_tail(&dev->dev_list, &net->dev_base_head);
220         hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
221         hlist_add_head(&dev->index_hlist, dev_index_hash(net, dev->ifindex));
222         write_unlock_bh(&dev_base_lock);
223         return 0;
224 }
225
226 /* Device list removal */
227 static void unlist_netdevice(struct net_device *dev)
228 {
229         ASSERT_RTNL();
230
231         /* Unlink dev from the device chain */
232         write_lock_bh(&dev_base_lock);
233         list_del(&dev->dev_list);
234         hlist_del(&dev->name_hlist);
235         hlist_del(&dev->index_hlist);
236         write_unlock_bh(&dev_base_lock);
237 }
238
239 /*
240  *      Our notifier list
241  */
242
243 static RAW_NOTIFIER_HEAD(netdev_chain);
244
245 /*
246  *      Device drivers call our routines to queue packets here. We empty the
247  *      queue in the local softnet handler.
248  */
249
250 DEFINE_PER_CPU(struct softnet_data, softnet_data);
251
252 #ifdef CONFIG_LOCKDEP
253 /*
254  * register_netdevice() inits txq->_xmit_lock and sets lockdep class
255  * according to dev->type
256  */
257 static const unsigned short netdev_lock_type[] =
258         {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25,
259          ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET,
260          ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM,
261          ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP,
262          ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD,
263          ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25,
264          ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP,
265          ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD,
266          ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI,
267          ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE,
268          ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET,
269          ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL,
270          ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211,
271          ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET,
272          ARPHRD_PHONET_PIPE, ARPHRD_IEEE802154, ARPHRD_IEEE802154_PHY,
273          ARPHRD_VOID, ARPHRD_NONE};
274
275 static const char *netdev_lock_name[] =
276         {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25",
277          "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET",
278          "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM",
279          "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP",
280          "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD",
281          "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25",
282          "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP",
283          "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD",
284          "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI",
285          "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE",
286          "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET",
287          "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL",
288          "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211",
289          "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET",
290          "_xmit_PHONET_PIPE", "_xmit_IEEE802154", "_xmit_IEEE802154_PHY",
291          "_xmit_VOID", "_xmit_NONE"};
292
293 static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)];
294 static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)];
295
296 static inline unsigned short netdev_lock_pos(unsigned short dev_type)
297 {
298         int i;
299
300         for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++)
301                 if (netdev_lock_type[i] == dev_type)
302                         return i;
303         /* the last key is used by default */
304         return ARRAY_SIZE(netdev_lock_type) - 1;
305 }
306
307 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
308                                                  unsigned short dev_type)
309 {
310         int i;
311
312         i = netdev_lock_pos(dev_type);
313         lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i],
314                                    netdev_lock_name[i]);
315 }
316
317 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
318 {
319         int i;
320
321         i = netdev_lock_pos(dev->type);
322         lockdep_set_class_and_name(&dev->addr_list_lock,
323                                    &netdev_addr_lock_key[i],
324                                    netdev_lock_name[i]);
325 }
326 #else
327 static inline void netdev_set_xmit_lockdep_class(spinlock_t *lock,
328                                                  unsigned short dev_type)
329 {
330 }
331 static inline void netdev_set_addr_lockdep_class(struct net_device *dev)
332 {
333 }
334 #endif
335
336 /*******************************************************************************
337
338                 Protocol management and registration routines
339
340 *******************************************************************************/
341
342 /*
343  *      Add a protocol ID to the list. Now that the input handler is
344  *      smarter we can dispense with all the messy stuff that used to be
345  *      here.
346  *
347  *      BEWARE!!! Protocol handlers, mangling input packets,
348  *      MUST BE last in hash buckets and checking protocol handlers
349  *      MUST start from promiscuous ptype_all chain in net_bh.
350  *      It is true now, do not change it.
351  *      Explanation follows: if protocol handler, mangling packet, will
352  *      be the first on list, it is not able to sense, that packet
353  *      is cloned and should be copied-on-write, so that it will
354  *      change it and subsequent readers will get broken packet.
355  *                                                      --ANK (980803)
356  */
357
358 /**
359  *      dev_add_pack - add packet handler
360  *      @pt: packet type declaration
361  *
362  *      Add a protocol handler to the networking stack. The passed &packet_type
363  *      is linked into kernel lists and may not be freed until it has been
364  *      removed from the kernel lists.
365  *
366  *      This call does not sleep therefore it can not
367  *      guarantee all CPU's that are in middle of receiving packets
368  *      will see the new packet type (until the next received packet).
369  */
370
371 void dev_add_pack(struct packet_type *pt)
372 {
373         int hash;
374
375         spin_lock_bh(&ptype_lock);
376         if (pt->type == htons(ETH_P_ALL))
377                 list_add_rcu(&pt->list, &ptype_all);
378         else {
379                 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
380                 list_add_rcu(&pt->list, &ptype_base[hash]);
381         }
382         spin_unlock_bh(&ptype_lock);
383 }
384
385 /**
386  *      __dev_remove_pack        - remove packet handler
387  *      @pt: packet type declaration
388  *
389  *      Remove a protocol handler that was previously added to the kernel
390  *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
391  *      from the kernel lists and can be freed or reused once this function
392  *      returns.
393  *
394  *      The packet type might still be in use by receivers
395  *      and must not be freed until after all the CPU's have gone
396  *      through a quiescent state.
397  */
398 void __dev_remove_pack(struct packet_type *pt)
399 {
400         struct list_head *head;
401         struct packet_type *pt1;
402
403         spin_lock_bh(&ptype_lock);
404
405         if (pt->type == htons(ETH_P_ALL))
406                 head = &ptype_all;
407         else
408                 head = &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
409
410         list_for_each_entry(pt1, head, list) {
411                 if (pt == pt1) {
412                         list_del_rcu(&pt->list);
413                         goto out;
414                 }
415         }
416
417         printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
418 out:
419         spin_unlock_bh(&ptype_lock);
420 }
421 /**
422  *      dev_remove_pack  - remove packet handler
423  *      @pt: packet type declaration
424  *
425  *      Remove a protocol handler that was previously added to the kernel
426  *      protocol handlers by dev_add_pack(). The passed &packet_type is removed
427  *      from the kernel lists and can be freed or reused once this function
428  *      returns.
429  *
430  *      This call sleeps to guarantee that no CPU is looking at the packet
431  *      type after return.
432  */
433 void dev_remove_pack(struct packet_type *pt)
434 {
435         __dev_remove_pack(pt);
436
437         synchronize_net();
438 }
439
440 /******************************************************************************
441
442                       Device Boot-time Settings Routines
443
444 *******************************************************************************/
445
446 /* Boot time configuration table */
447 static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX];
448
449 /**
450  *      netdev_boot_setup_add   - add new setup entry
451  *      @name: name of the device
452  *      @map: configured settings for the device
453  *
454  *      Adds new setup entry to the dev_boot_setup list.  The function
455  *      returns 0 on error and 1 on success.  This is a generic routine to
456  *      all netdevices.
457  */
458 static int netdev_boot_setup_add(char *name, struct ifmap *map)
459 {
460         struct netdev_boot_setup *s;
461         int i;
462
463         s = dev_boot_setup;
464         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
465                 if (s[i].name[0] == '\0' || s[i].name[0] == ' ') {
466                         memset(s[i].name, 0, sizeof(s[i].name));
467                         strlcpy(s[i].name, name, IFNAMSIZ);
468                         memcpy(&s[i].map, map, sizeof(s[i].map));
469                         break;
470                 }
471         }
472
473         return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1;
474 }
475
476 /**
477  *      netdev_boot_setup_check - check boot time settings
478  *      @dev: the netdevice
479  *
480  *      Check boot time settings for the device.
481  *      The found settings are set for the device to be used
482  *      later in the device probing.
483  *      Returns 0 if no settings found, 1 if they are.
484  */
485 int netdev_boot_setup_check(struct net_device *dev)
486 {
487         struct netdev_boot_setup *s = dev_boot_setup;
488         int i;
489
490         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) {
491                 if (s[i].name[0] != '\0' && s[i].name[0] != ' ' &&
492                     !strcmp(dev->name, s[i].name)) {
493                         dev->irq        = s[i].map.irq;
494                         dev->base_addr  = s[i].map.base_addr;
495                         dev->mem_start  = s[i].map.mem_start;
496                         dev->mem_end    = s[i].map.mem_end;
497                         return 1;
498                 }
499         }
500         return 0;
501 }
502
503
504 /**
505  *      netdev_boot_base        - get address from boot time settings
506  *      @prefix: prefix for network device
507  *      @unit: id for network device
508  *
509  *      Check boot time settings for the base address of device.
510  *      The found settings are set for the device to be used
511  *      later in the device probing.
512  *      Returns 0 if no settings found.
513  */
514 unsigned long netdev_boot_base(const char *prefix, int unit)
515 {
516         const struct netdev_boot_setup *s = dev_boot_setup;
517         char name[IFNAMSIZ];
518         int i;
519
520         sprintf(name, "%s%d", prefix, unit);
521
522         /*
523          * If device already registered then return base of 1
524          * to indicate not to probe for this interface
525          */
526         if (__dev_get_by_name(&init_net, name))
527                 return 1;
528
529         for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++)
530                 if (!strcmp(name, s[i].name))
531                         return s[i].map.base_addr;
532         return 0;
533 }
534
535 /*
536  * Saves at boot time configured settings for any netdevice.
537  */
538 int __init netdev_boot_setup(char *str)
539 {
540         int ints[5];
541         struct ifmap map;
542
543         str = get_options(str, ARRAY_SIZE(ints), ints);
544         if (!str || !*str)
545                 return 0;
546
547         /* Save settings */
548         memset(&map, 0, sizeof(map));
549         if (ints[0] > 0)
550                 map.irq = ints[1];
551         if (ints[0] > 1)
552                 map.base_addr = ints[2];
553         if (ints[0] > 2)
554                 map.mem_start = ints[3];
555         if (ints[0] > 3)
556                 map.mem_end = ints[4];
557
558         /* Add new entry to the list */
559         return netdev_boot_setup_add(str, &map);
560 }
561
562 __setup("netdev=", netdev_boot_setup);
563
564 /*******************************************************************************
565
566                             Device Interface Subroutines
567
568 *******************************************************************************/
569
570 /**
571  *      __dev_get_by_name       - find a device by its name
572  *      @net: the applicable net namespace
573  *      @name: name to find
574  *
575  *      Find an interface by name. Must be called under RTNL semaphore
576  *      or @dev_base_lock. If the name is found a pointer to the device
577  *      is returned. If the name is not found then %NULL is returned. The
578  *      reference counters are not incremented so the caller must be
579  *      careful with locks.
580  */
581
582 struct net_device *__dev_get_by_name(struct net *net, const char *name)
583 {
584         struct hlist_node *p;
585
586         hlist_for_each(p, dev_name_hash(net, name)) {
587                 struct net_device *dev
588                         = hlist_entry(p, struct net_device, name_hlist);
589                 if (!strncmp(dev->name, name, IFNAMSIZ))
590                         return dev;
591         }
592         return NULL;
593 }
594
595 /**
596  *      dev_get_by_name         - find a device by its name
597  *      @net: the applicable net namespace
598  *      @name: name to find
599  *
600  *      Find an interface by name. This can be called from any
601  *      context and does its own locking. The returned handle has
602  *      the usage count incremented and the caller must use dev_put() to
603  *      release it when it is no longer needed. %NULL is returned if no
604  *      matching device is found.
605  */
606
607 struct net_device *dev_get_by_name(struct net *net, const char *name)
608 {
609         struct net_device *dev;
610
611         read_lock(&dev_base_lock);
612         dev = __dev_get_by_name(net, name);
613         if (dev)
614                 dev_hold(dev);
615         read_unlock(&dev_base_lock);
616         return dev;
617 }
618
619 /**
620  *      __dev_get_by_index - find a device by its ifindex
621  *      @net: the applicable net namespace
622  *      @ifindex: index of device
623  *
624  *      Search for an interface by index. Returns %NULL if the device
625  *      is not found or a pointer to the device. The device has not
626  *      had its reference counter increased so the caller must be careful
627  *      about locking. The caller must hold either the RTNL semaphore
628  *      or @dev_base_lock.
629  */
630
631 struct net_device *__dev_get_by_index(struct net *net, int ifindex)
632 {
633         struct hlist_node *p;
634
635         hlist_for_each(p, dev_index_hash(net, ifindex)) {
636                 struct net_device *dev
637                         = hlist_entry(p, struct net_device, index_hlist);
638                 if (dev->ifindex == ifindex)
639                         return dev;
640         }
641         return NULL;
642 }
643
644
645 /**
646  *      dev_get_by_index - find a device by its ifindex
647  *      @net: the applicable net namespace
648  *      @ifindex: index of device
649  *
650  *      Search for an interface by index. Returns NULL if the device
651  *      is not found or a pointer to the device. The device returned has
652  *      had a reference added and the pointer is safe until the user calls
653  *      dev_put to indicate they have finished with it.
654  */
655
656 struct net_device *dev_get_by_index(struct net *net, int ifindex)
657 {
658         struct net_device *dev;
659
660         read_lock(&dev_base_lock);
661         dev = __dev_get_by_index(net, ifindex);
662         if (dev)
663                 dev_hold(dev);
664         read_unlock(&dev_base_lock);
665         return dev;
666 }
667
668 /**
669  *      dev_getbyhwaddr - find a device by its hardware address
670  *      @net: the applicable net namespace
671  *      @type: media type of device
672  *      @ha: hardware address
673  *
674  *      Search for an interface by MAC address. Returns NULL if the device
675  *      is not found or a pointer to the device. The caller must hold the
676  *      rtnl semaphore. The returned device has not had its ref count increased
677  *      and the caller must therefore be careful about locking
678  *
679  *      BUGS:
680  *      If the API was consistent this would be __dev_get_by_hwaddr
681  */
682
683 struct net_device *dev_getbyhwaddr(struct net *net, unsigned short type, char *ha)
684 {
685         struct net_device *dev;
686
687         ASSERT_RTNL();
688
689         for_each_netdev(net, dev)
690                 if (dev->type == type &&
691                     !memcmp(dev->dev_addr, ha, dev->addr_len))
692                         return dev;
693
694         return NULL;
695 }
696
697 EXPORT_SYMBOL(dev_getbyhwaddr);
698
699 struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type)
700 {
701         struct net_device *dev;
702
703         ASSERT_RTNL();
704         for_each_netdev(net, dev)
705                 if (dev->type == type)
706                         return dev;
707
708         return NULL;
709 }
710
711 EXPORT_SYMBOL(__dev_getfirstbyhwtype);
712
713 struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type)
714 {
715         struct net_device *dev;
716
717         rtnl_lock();
718         dev = __dev_getfirstbyhwtype(net, type);
719         if (dev)
720                 dev_hold(dev);
721         rtnl_unlock();
722         return dev;
723 }
724
725 EXPORT_SYMBOL(dev_getfirstbyhwtype);
726
727 /**
728  *      dev_get_by_flags - find any device with given flags
729  *      @net: the applicable net namespace
730  *      @if_flags: IFF_* values
731  *      @mask: bitmask of bits in if_flags to check
732  *
733  *      Search for any interface with the given flags. Returns NULL if a device
734  *      is not found or a pointer to the device. The device returned has
735  *      had a reference added and the pointer is safe until the user calls
736  *      dev_put to indicate they have finished with it.
737  */
738
739 struct net_device * dev_get_by_flags(struct net *net, unsigned short if_flags, unsigned short mask)
740 {
741         struct net_device *dev, *ret;
742
743         ret = NULL;
744         read_lock(&dev_base_lock);
745         for_each_netdev(net, dev) {
746                 if (((dev->flags ^ if_flags) & mask) == 0) {
747                         dev_hold(dev);
748                         ret = dev;
749                         break;
750                 }
751         }
752         read_unlock(&dev_base_lock);
753         return ret;
754 }
755
756 /**
757  *      dev_valid_name - check if name is okay for network device
758  *      @name: name string
759  *
760  *      Network device names need to be valid file names to
761  *      to allow sysfs to work.  We also disallow any kind of
762  *      whitespace.
763  */
764 int dev_valid_name(const char *name)
765 {
766         if (*name == '\0')
767                 return 0;
768         if (strlen(name) >= IFNAMSIZ)
769                 return 0;
770         if (!strcmp(name, ".") || !strcmp(name, ".."))
771                 return 0;
772
773         while (*name) {
774                 if (*name == '/' || isspace(*name))
775                         return 0;
776                 name++;
777         }
778         return 1;
779 }
780
781 /**
782  *      __dev_alloc_name - allocate a name for a device
783  *      @net: network namespace to allocate the device name in
784  *      @name: name format string
785  *      @buf:  scratch buffer and result name string
786  *
787  *      Passed a format string - eg "lt%d" it will try and find a suitable
788  *      id. It scans list of devices to build up a free map, then chooses
789  *      the first empty slot. The caller must hold the dev_base or rtnl lock
790  *      while allocating the name and adding the device in order to avoid
791  *      duplicates.
792  *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
793  *      Returns the number of the unit assigned or a negative errno code.
794  */
795
796 static int __dev_alloc_name(struct net *net, const char *name, char *buf)
797 {
798         int i = 0;
799         const char *p;
800         const int max_netdevices = 8*PAGE_SIZE;
801         unsigned long *inuse;
802         struct net_device *d;
803
804         p = strnchr(name, IFNAMSIZ-1, '%');
805         if (p) {
806                 /*
807                  * Verify the string as this thing may have come from
808                  * the user.  There must be either one "%d" and no other "%"
809                  * characters.
810                  */
811                 if (p[1] != 'd' || strchr(p + 2, '%'))
812                         return -EINVAL;
813
814                 /* Use one page as a bit array of possible slots */
815                 inuse = (unsigned long *) get_zeroed_page(GFP_ATOMIC);
816                 if (!inuse)
817                         return -ENOMEM;
818
819                 for_each_netdev(net, d) {
820                         if (!sscanf(d->name, name, &i))
821                                 continue;
822                         if (i < 0 || i >= max_netdevices)
823                                 continue;
824
825                         /*  avoid cases where sscanf is not exact inverse of printf */
826                         snprintf(buf, IFNAMSIZ, name, i);
827                         if (!strncmp(buf, d->name, IFNAMSIZ))
828                                 set_bit(i, inuse);
829                 }
830
831                 i = find_first_zero_bit(inuse, max_netdevices);
832                 free_page((unsigned long) inuse);
833         }
834
835         snprintf(buf, IFNAMSIZ, name, i);
836         if (!__dev_get_by_name(net, buf))
837                 return i;
838
839         /* It is possible to run out of possible slots
840          * when the name is long and there isn't enough space left
841          * for the digits, or if all bits are used.
842          */
843         return -ENFILE;
844 }
845
846 /**
847  *      dev_alloc_name - allocate a name for a device
848  *      @dev: device
849  *      @name: name format string
850  *
851  *      Passed a format string - eg "lt%d" it will try and find a suitable
852  *      id. It scans list of devices to build up a free map, then chooses
853  *      the first empty slot. The caller must hold the dev_base or rtnl lock
854  *      while allocating the name and adding the device in order to avoid
855  *      duplicates.
856  *      Limited to bits_per_byte * page size devices (ie 32K on most platforms).
857  *      Returns the number of the unit assigned or a negative errno code.
858  */
859
860 int dev_alloc_name(struct net_device *dev, const char *name)
861 {
862         char buf[IFNAMSIZ];
863         struct net *net;
864         int ret;
865
866         BUG_ON(!dev_net(dev));
867         net = dev_net(dev);
868         ret = __dev_alloc_name(net, name, buf);
869         if (ret >= 0)
870                 strlcpy(dev->name, buf, IFNAMSIZ);
871         return ret;
872 }
873
874
875 /**
876  *      dev_change_name - change name of a device
877  *      @dev: device
878  *      @newname: name (or format string) must be at least IFNAMSIZ
879  *
880  *      Change name of a device, can pass format strings "eth%d".
881  *      for wildcarding.
882  */
883 int dev_change_name(struct net_device *dev, const char *newname)
884 {
885         char oldname[IFNAMSIZ];
886         int err = 0;
887         int ret;
888         struct net *net;
889
890         ASSERT_RTNL();
891         BUG_ON(!dev_net(dev));
892
893         net = dev_net(dev);
894         if (dev->flags & IFF_UP)
895                 return -EBUSY;
896
897         if (!dev_valid_name(newname))
898                 return -EINVAL;
899
900         if (strncmp(newname, dev->name, IFNAMSIZ) == 0)
901                 return 0;
902
903         memcpy(oldname, dev->name, IFNAMSIZ);
904
905         if (strchr(newname, '%')) {
906                 err = dev_alloc_name(dev, newname);
907                 if (err < 0)
908                         return err;
909         }
910         else if (__dev_get_by_name(net, newname))
911                 return -EEXIST;
912         else
913                 strlcpy(dev->name, newname, IFNAMSIZ);
914
915 rollback:
916         /* For now only devices in the initial network namespace
917          * are in sysfs.
918          */
919         if (net == &init_net) {
920                 ret = device_rename(&dev->dev, dev->name);
921                 if (ret) {
922                         memcpy(dev->name, oldname, IFNAMSIZ);
923                         return ret;
924                 }
925         }
926
927         write_lock_bh(&dev_base_lock);
928         hlist_del(&dev->name_hlist);
929         hlist_add_head(&dev->name_hlist, dev_name_hash(net, dev->name));
930         write_unlock_bh(&dev_base_lock);
931
932         ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev);
933         ret = notifier_to_errno(ret);
934
935         if (ret) {
936                 if (err) {
937                         printk(KERN_ERR
938                                "%s: name change rollback failed: %d.\n",
939                                dev->name, ret);
940                 } else {
941                         err = ret;
942                         memcpy(dev->name, oldname, IFNAMSIZ);
943                         goto rollback;
944                 }
945         }
946
947         return err;
948 }
949
950 /**
951  *      dev_set_alias - change ifalias of a device
952  *      @dev: device
953  *      @alias: name up to IFALIASZ
954  *      @len: limit of bytes to copy from info
955  *
956  *      Set ifalias for a device,
957  */
958 int dev_set_alias(struct net_device *dev, const char *alias, size_t len)
959 {
960         ASSERT_RTNL();
961
962         if (len >= IFALIASZ)
963                 return -EINVAL;
964
965         if (!len) {
966                 if (dev->ifalias) {
967                         kfree(dev->ifalias);
968                         dev->ifalias = NULL;
969                 }
970                 return 0;
971         }
972
973         dev->ifalias = krealloc(dev->ifalias, len+1, GFP_KERNEL);
974         if (!dev->ifalias)
975                 return -ENOMEM;
976
977         strlcpy(dev->ifalias, alias, len+1);
978         return len;
979 }
980
981
982 /**
983  *      netdev_features_change - device changes features
984  *      @dev: device to cause notification
985  *
986  *      Called to indicate a device has changed features.
987  */
988 void netdev_features_change(struct net_device *dev)
989 {
990         call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev);
991 }
992 EXPORT_SYMBOL(netdev_features_change);
993
994 /**
995  *      netdev_state_change - device changes state
996  *      @dev: device to cause notification
997  *
998  *      Called to indicate a device has changed state. This function calls
999  *      the notifier chains for netdev_chain and sends a NEWLINK message
1000  *      to the routing socket.
1001  */
1002 void netdev_state_change(struct net_device *dev)
1003 {
1004         if (dev->flags & IFF_UP) {
1005                 call_netdevice_notifiers(NETDEV_CHANGE, dev);
1006                 rtmsg_ifinfo(RTM_NEWLINK, dev, 0);
1007         }
1008 }
1009
1010 void netdev_bonding_change(struct net_device *dev)
1011 {
1012         call_netdevice_notifiers(NETDEV_BONDING_FAILOVER, dev);
1013 }
1014 EXPORT_SYMBOL(netdev_bonding_change);
1015
1016 /**
1017  *      dev_load        - load a network module
1018  *      @net: the applicable net namespace
1019  *      @name: name of interface
1020  *
1021  *      If a network interface is not present and the process has suitable
1022  *      privileges this function loads the module. If module loading is not
1023  *      available in this kernel then it becomes a nop.
1024  */
1025
1026 void dev_load(struct net *net, const char *name)
1027 {
1028         struct net_device *dev;
1029
1030         read_lock(&dev_base_lock);
1031         dev = __dev_get_by_name(net, name);
1032         read_unlock(&dev_base_lock);
1033
1034         if (!dev && capable(CAP_SYS_MODULE))
1035                 request_module("%s", name);
1036 }
1037
1038 /**
1039  *      dev_open        - prepare an interface for use.
1040  *      @dev:   device to open
1041  *
1042  *      Takes a device from down to up state. The device's private open
1043  *      function is invoked and then the multicast lists are loaded. Finally
1044  *      the device is moved into the up state and a %NETDEV_UP message is
1045  *      sent to the netdev notifier chain.
1046  *
1047  *      Calling this function on an active interface is a nop. On a failure
1048  *      a negative errno code is returned.
1049  */
1050 int dev_open(struct net_device *dev)
1051 {
1052         const struct net_device_ops *ops = dev->netdev_ops;
1053         int ret;
1054
1055         ASSERT_RTNL();
1056
1057         /*
1058          *      Is it already up?
1059          */
1060
1061         if (dev->flags & IFF_UP)
1062                 return 0;
1063
1064         /*
1065          *      Is it even present?
1066          */
1067         if (!netif_device_present(dev))
1068                 return -ENODEV;
1069
1070         ret = call_netdevice_notifiers(NETDEV_PRE_UP, dev);
1071         ret = notifier_to_errno(ret);
1072         if (ret)
1073                 return ret;
1074
1075         /*
1076          *      Call device private open method
1077          */
1078         set_bit(__LINK_STATE_START, &dev->state);
1079
1080         if (ops->ndo_validate_addr)
1081                 ret = ops->ndo_validate_addr(dev);
1082
1083         if (!ret && ops->ndo_open)
1084                 ret = ops->ndo_open(dev);
1085
1086         /*
1087          *      If it went open OK then:
1088          */
1089
1090         if (ret)
1091                 clear_bit(__LINK_STATE_START, &dev->state);
1092         else {
1093                 /*
1094                  *      Set the flags.
1095                  */
1096                 dev->flags |= IFF_UP;
1097
1098                 /*
1099                  *      Enable NET_DMA
1100                  */
1101                 net_dmaengine_get();
1102
1103                 /*
1104                  *      Initialize multicasting status
1105                  */
1106                 dev_set_rx_mode(dev);
1107
1108                 /*
1109                  *      Wakeup transmit queue engine
1110                  */
1111                 dev_activate(dev);
1112
1113                 /*
1114                  *      ... and announce new interface.
1115                  */
1116                 call_netdevice_notifiers(NETDEV_UP, dev);
1117         }
1118
1119         return ret;
1120 }
1121
1122 /**
1123  *      dev_close - shutdown an interface.
1124  *      @dev: device to shutdown
1125  *
1126  *      This function moves an active device into down state. A
1127  *      %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device
1128  *      is then deactivated and finally a %NETDEV_DOWN is sent to the notifier
1129  *      chain.
1130  */
1131 int dev_close(struct net_device *dev)
1132 {
1133         const struct net_device_ops *ops = dev->netdev_ops;
1134         ASSERT_RTNL();
1135
1136         might_sleep();
1137
1138         if (!(dev->flags & IFF_UP))
1139                 return 0;
1140
1141         /*
1142          *      Tell people we are going down, so that they can
1143          *      prepare to death, when device is still operating.
1144          */
1145         call_netdevice_notifiers(NETDEV_GOING_DOWN, dev);
1146
1147         clear_bit(__LINK_STATE_START, &dev->state);
1148
1149         /* Synchronize to scheduled poll. We cannot touch poll list,
1150          * it can be even on different cpu. So just clear netif_running().
1151          *
1152          * dev->stop() will invoke napi_disable() on all of it's
1153          * napi_struct instances on this device.
1154          */
1155         smp_mb__after_clear_bit(); /* Commit netif_running(). */
1156
1157         dev_deactivate(dev);
1158
1159         /*
1160          *      Call the device specific close. This cannot fail.
1161          *      Only if device is UP
1162          *
1163          *      We allow it to be called even after a DETACH hot-plug
1164          *      event.
1165          */
1166         if (ops->ndo_stop)
1167                 ops->ndo_stop(dev);
1168
1169         /*
1170          *      Device is now down.
1171          */
1172
1173         dev->flags &= ~IFF_UP;
1174
1175         /*
1176          * Tell people we are down
1177          */
1178         call_netdevice_notifiers(NETDEV_DOWN, dev);
1179
1180         /*
1181          *      Shutdown NET_DMA
1182          */
1183         net_dmaengine_put();
1184
1185         return 0;
1186 }
1187
1188
1189 /**
1190  *      dev_disable_lro - disable Large Receive Offload on a device
1191  *      @dev: device
1192  *
1193  *      Disable Large Receive Offload (LRO) on a net device.  Must be
1194  *      called under RTNL.  This is needed if received packets may be
1195  *      forwarded to another interface.
1196  */
1197 void dev_disable_lro(struct net_device *dev)
1198 {
1199         if (dev->ethtool_ops && dev->ethtool_ops->get_flags &&
1200             dev->ethtool_ops->set_flags) {
1201                 u32 flags = dev->ethtool_ops->get_flags(dev);
1202                 if (flags & ETH_FLAG_LRO) {
1203                         flags &= ~ETH_FLAG_LRO;
1204                         dev->ethtool_ops->set_flags(dev, flags);
1205                 }
1206         }
1207         WARN_ON(dev->features & NETIF_F_LRO);
1208 }
1209 EXPORT_SYMBOL(dev_disable_lro);
1210
1211
1212 static int dev_boot_phase = 1;
1213
1214 /*
1215  *      Device change register/unregister. These are not inline or static
1216  *      as we export them to the world.
1217  */
1218
1219 /**
1220  *      register_netdevice_notifier - register a network notifier block
1221  *      @nb: notifier
1222  *
1223  *      Register a notifier to be called when network device events occur.
1224  *      The notifier passed is linked into the kernel structures and must
1225  *      not be reused until it has been unregistered. A negative errno code
1226  *      is returned on a failure.
1227  *
1228  *      When registered all registration and up events are replayed
1229  *      to the new notifier to allow device to have a race free
1230  *      view of the network device list.
1231  */
1232
1233 int register_netdevice_notifier(struct notifier_block *nb)
1234 {
1235         struct net_device *dev;
1236         struct net_device *last;
1237         struct net *net;
1238         int err;
1239
1240         rtnl_lock();
1241         err = raw_notifier_chain_register(&netdev_chain, nb);
1242         if (err)
1243                 goto unlock;
1244         if (dev_boot_phase)
1245                 goto unlock;
1246         for_each_net(net) {
1247                 for_each_netdev(net, dev) {
1248                         err = nb->notifier_call(nb, NETDEV_REGISTER, dev);
1249                         err = notifier_to_errno(err);
1250                         if (err)
1251                                 goto rollback;
1252
1253                         if (!(dev->flags & IFF_UP))
1254                                 continue;
1255
1256                         nb->notifier_call(nb, NETDEV_UP, dev);
1257                 }
1258         }
1259
1260 unlock:
1261         rtnl_unlock();
1262         return err;
1263
1264 rollback:
1265         last = dev;
1266         for_each_net(net) {
1267                 for_each_netdev(net, dev) {
1268                         if (dev == last)
1269                                 break;
1270
1271                         if (dev->flags & IFF_UP) {
1272                                 nb->notifier_call(nb, NETDEV_GOING_DOWN, dev);
1273                                 nb->notifier_call(nb, NETDEV_DOWN, dev);
1274                         }
1275                         nb->notifier_call(nb, NETDEV_UNREGISTER, dev);
1276                 }
1277         }
1278
1279         raw_notifier_chain_unregister(&netdev_chain, nb);
1280         goto unlock;
1281 }
1282
1283 /**
1284  *      unregister_netdevice_notifier - unregister a network notifier block
1285  *      @nb: notifier
1286  *
1287  *      Unregister a notifier previously registered by
1288  *      register_netdevice_notifier(). The notifier is unlinked into the
1289  *      kernel structures and may then be reused. A negative errno code
1290  *      is returned on a failure.
1291  */
1292
1293 int unregister_netdevice_notifier(struct notifier_block *nb)
1294 {
1295         int err;
1296
1297         rtnl_lock();
1298         err = raw_notifier_chain_unregister(&netdev_chain, nb);
1299         rtnl_unlock();
1300         return err;
1301 }
1302
1303 /**
1304  *      call_netdevice_notifiers - call all network notifier blocks
1305  *      @val: value passed unmodified to notifier function
1306  *      @dev: net_device pointer passed unmodified to notifier function
1307  *
1308  *      Call all network notifier blocks.  Parameters and return value
1309  *      are as for raw_notifier_call_chain().
1310  */
1311
1312 int call_netdevice_notifiers(unsigned long val, struct net_device *dev)
1313 {
1314         return raw_notifier_call_chain(&netdev_chain, val, dev);
1315 }
1316
1317 /* When > 0 there are consumers of rx skb time stamps */
1318 static atomic_t netstamp_needed = ATOMIC_INIT(0);
1319
1320 void net_enable_timestamp(void)
1321 {
1322         atomic_inc(&netstamp_needed);
1323 }
1324
1325 void net_disable_timestamp(void)
1326 {
1327         atomic_dec(&netstamp_needed);
1328 }
1329
1330 static inline void net_timestamp(struct sk_buff *skb)
1331 {
1332         if (atomic_read(&netstamp_needed))
1333                 __net_timestamp(skb);
1334         else
1335                 skb->tstamp.tv64 = 0;
1336 }
1337
1338 /*
1339  *      Support routine. Sends outgoing frames to any network
1340  *      taps currently in use.
1341  */
1342
1343 static void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev)
1344 {
1345         struct packet_type *ptype;
1346
1347 #ifdef CONFIG_NET_CLS_ACT
1348         if (!(skb->tstamp.tv64 && (G_TC_FROM(skb->tc_verd) & AT_INGRESS)))
1349                 net_timestamp(skb);
1350 #else
1351         net_timestamp(skb);
1352 #endif
1353
1354         rcu_read_lock();
1355         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1356                 /* Never send packets back to the socket
1357                  * they originated from - MvS (miquels@drinkel.ow.org)
1358                  */
1359                 if ((ptype->dev == dev || !ptype->dev) &&
1360                     (ptype->af_packet_priv == NULL ||
1361                      (struct sock *)ptype->af_packet_priv != skb->sk)) {
1362                         struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1363                         if (!skb2)
1364                                 break;
1365
1366                         /* skb->nh should be correctly
1367                            set by sender, so that the second statement is
1368                            just protection against buggy protocols.
1369                          */
1370                         skb_reset_mac_header(skb2);
1371
1372                         if (skb_network_header(skb2) < skb2->data ||
1373                             skb2->network_header > skb2->tail) {
1374                                 if (net_ratelimit())
1375                                         printk(KERN_CRIT "protocol %04x is "
1376                                                "buggy, dev %s\n",
1377                                                skb2->protocol, dev->name);
1378                                 skb_reset_network_header(skb2);
1379                         }
1380
1381                         skb2->transport_header = skb2->network_header;
1382                         skb2->pkt_type = PACKET_OUTGOING;
1383                         ptype->func(skb2, skb->dev, ptype, skb->dev);
1384                 }
1385         }
1386         rcu_read_unlock();
1387 }
1388
1389
1390 static inline void __netif_reschedule(struct Qdisc *q)
1391 {
1392         struct softnet_data *sd;
1393         unsigned long flags;
1394
1395         local_irq_save(flags);
1396         sd = &__get_cpu_var(softnet_data);
1397         q->next_sched = sd->output_queue;
1398         sd->output_queue = q;
1399         raise_softirq_irqoff(NET_TX_SOFTIRQ);
1400         local_irq_restore(flags);
1401 }
1402
1403 void __netif_schedule(struct Qdisc *q)
1404 {
1405         if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
1406                 __netif_reschedule(q);
1407 }
1408 EXPORT_SYMBOL(__netif_schedule);
1409
1410 void dev_kfree_skb_irq(struct sk_buff *skb)
1411 {
1412         if (atomic_dec_and_test(&skb->users)) {
1413                 struct softnet_data *sd;
1414                 unsigned long flags;
1415
1416                 local_irq_save(flags);
1417                 sd = &__get_cpu_var(softnet_data);
1418                 skb->next = sd->completion_queue;
1419                 sd->completion_queue = skb;
1420                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1421                 local_irq_restore(flags);
1422         }
1423 }
1424 EXPORT_SYMBOL(dev_kfree_skb_irq);
1425
1426 void dev_kfree_skb_any(struct sk_buff *skb)
1427 {
1428         if (in_irq() || irqs_disabled())
1429                 dev_kfree_skb_irq(skb);
1430         else
1431                 dev_kfree_skb(skb);
1432 }
1433 EXPORT_SYMBOL(dev_kfree_skb_any);
1434
1435
1436 /**
1437  * netif_device_detach - mark device as removed
1438  * @dev: network device
1439  *
1440  * Mark device as removed from system and therefore no longer available.
1441  */
1442 void netif_device_detach(struct net_device *dev)
1443 {
1444         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1445             netif_running(dev)) {
1446                 netif_tx_stop_all_queues(dev);
1447         }
1448 }
1449 EXPORT_SYMBOL(netif_device_detach);
1450
1451 /**
1452  * netif_device_attach - mark device as attached
1453  * @dev: network device
1454  *
1455  * Mark device as attached from system and restart if needed.
1456  */
1457 void netif_device_attach(struct net_device *dev)
1458 {
1459         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1460             netif_running(dev)) {
1461                 netif_tx_wake_all_queues(dev);
1462                 __netdev_watchdog_up(dev);
1463         }
1464 }
1465 EXPORT_SYMBOL(netif_device_attach);
1466
1467 static bool can_checksum_protocol(unsigned long features, __be16 protocol)
1468 {
1469         return ((features & NETIF_F_GEN_CSUM) ||
1470                 ((features & NETIF_F_IP_CSUM) &&
1471                  protocol == htons(ETH_P_IP)) ||
1472                 ((features & NETIF_F_IPV6_CSUM) &&
1473                  protocol == htons(ETH_P_IPV6)) ||
1474                 ((features & NETIF_F_FCOE_CRC) &&
1475                  protocol == htons(ETH_P_FCOE)));
1476 }
1477
1478 static bool dev_can_checksum(struct net_device *dev, struct sk_buff *skb)
1479 {
1480         if (can_checksum_protocol(dev->features, skb->protocol))
1481                 return true;
1482
1483         if (skb->protocol == htons(ETH_P_8021Q)) {
1484                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1485                 if (can_checksum_protocol(dev->features & dev->vlan_features,
1486                                           veh->h_vlan_encapsulated_proto))
1487                         return true;
1488         }
1489
1490         return false;
1491 }
1492
1493 /*
1494  * Invalidate hardware checksum when packet is to be mangled, and
1495  * complete checksum manually on outgoing path.
1496  */
1497 int skb_checksum_help(struct sk_buff *skb)
1498 {
1499         __wsum csum;
1500         int ret = 0, offset;
1501
1502         if (skb->ip_summed == CHECKSUM_COMPLETE)
1503                 goto out_set_summed;
1504
1505         if (unlikely(skb_shinfo(skb)->gso_size)) {
1506                 /* Let GSO fix up the checksum. */
1507                 goto out_set_summed;
1508         }
1509
1510         offset = skb->csum_start - skb_headroom(skb);
1511         BUG_ON(offset >= skb_headlen(skb));
1512         csum = skb_checksum(skb, offset, skb->len - offset, 0);
1513
1514         offset += skb->csum_offset;
1515         BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1516
1517         if (skb_cloned(skb) &&
1518             !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1519                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1520                 if (ret)
1521                         goto out;
1522         }
1523
1524         *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1525 out_set_summed:
1526         skb->ip_summed = CHECKSUM_NONE;
1527 out:
1528         return ret;
1529 }
1530
1531 /**
1532  *      skb_gso_segment - Perform segmentation on skb.
1533  *      @skb: buffer to segment
1534  *      @features: features for the output path (see dev->features)
1535  *
1536  *      This function segments the given skb and returns a list of segments.
1537  *
1538  *      It may return NULL if the skb requires no segmentation.  This is
1539  *      only possible when GSO is used for verifying header integrity.
1540  */
1541 struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1542 {
1543         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1544         struct packet_type *ptype;
1545         __be16 type = skb->protocol;
1546         int err;
1547
1548         skb_reset_mac_header(skb);
1549         skb->mac_len = skb->network_header - skb->mac_header;
1550         __skb_pull(skb, skb->mac_len);
1551
1552         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1553                 struct net_device *dev = skb->dev;
1554                 struct ethtool_drvinfo info = {};
1555
1556                 if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo)
1557                         dev->ethtool_ops->get_drvinfo(dev, &info);
1558
1559                 WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d "
1560                         "ip_summed=%d",
1561                      info.driver, dev ? dev->features : 0L,
1562                      skb->sk ? skb->sk->sk_route_caps : 0L,
1563                      skb->len, skb->data_len, skb->ip_summed);
1564
1565                 if (skb_header_cloned(skb) &&
1566                     (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1567                         return ERR_PTR(err);
1568         }
1569
1570         rcu_read_lock();
1571         list_for_each_entry_rcu(ptype,
1572                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
1573                 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1574                         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1575                                 err = ptype->gso_send_check(skb);
1576                                 segs = ERR_PTR(err);
1577                                 if (err || skb_gso_ok(skb, features))
1578                                         break;
1579                                 __skb_push(skb, (skb->data -
1580                                                  skb_network_header(skb)));
1581                         }
1582                         segs = ptype->gso_segment(skb, features);
1583                         break;
1584                 }
1585         }
1586         rcu_read_unlock();
1587
1588         __skb_push(skb, skb->data - skb_mac_header(skb));
1589
1590         return segs;
1591 }
1592
1593 EXPORT_SYMBOL(skb_gso_segment);
1594
1595 /* Take action when hardware reception checksum errors are detected. */
1596 #ifdef CONFIG_BUG
1597 void netdev_rx_csum_fault(struct net_device *dev)
1598 {
1599         if (net_ratelimit()) {
1600                 printk(KERN_ERR "%s: hw csum failure.\n",
1601                         dev ? dev->name : "<unknown>");
1602                 dump_stack();
1603         }
1604 }
1605 EXPORT_SYMBOL(netdev_rx_csum_fault);
1606 #endif
1607
1608 /* Actually, we should eliminate this check as soon as we know, that:
1609  * 1. IOMMU is present and allows to map all the memory.
1610  * 2. No high memory really exists on this machine.
1611  */
1612
1613 static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1614 {
1615 #ifdef CONFIG_HIGHMEM
1616         int i;
1617
1618         if (dev->features & NETIF_F_HIGHDMA)
1619                 return 0;
1620
1621         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1622                 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1623                         return 1;
1624
1625 #endif
1626         return 0;
1627 }
1628
1629 struct dev_gso_cb {
1630         void (*destructor)(struct sk_buff *skb);
1631 };
1632
1633 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1634
1635 static void dev_gso_skb_destructor(struct sk_buff *skb)
1636 {
1637         struct dev_gso_cb *cb;
1638
1639         do {
1640                 struct sk_buff *nskb = skb->next;
1641
1642                 skb->next = nskb->next;
1643                 nskb->next = NULL;
1644                 kfree_skb(nskb);
1645         } while (skb->next);
1646
1647         cb = DEV_GSO_CB(skb);
1648         if (cb->destructor)
1649                 cb->destructor(skb);
1650 }
1651
1652 /**
1653  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
1654  *      @skb: buffer to segment
1655  *
1656  *      This function segments the given skb and stores the list of segments
1657  *      in skb->next.
1658  */
1659 static int dev_gso_segment(struct sk_buff *skb)
1660 {
1661         struct net_device *dev = skb->dev;
1662         struct sk_buff *segs;
1663         int features = dev->features & ~(illegal_highdma(dev, skb) ?
1664                                          NETIF_F_SG : 0);
1665
1666         segs = skb_gso_segment(skb, features);
1667
1668         /* Verifying header integrity only. */
1669         if (!segs)
1670                 return 0;
1671
1672         if (IS_ERR(segs))
1673                 return PTR_ERR(segs);
1674
1675         skb->next = segs;
1676         DEV_GSO_CB(skb)->destructor = skb->destructor;
1677         skb->destructor = dev_gso_skb_destructor;
1678
1679         return 0;
1680 }
1681
1682 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
1683                         struct netdev_queue *txq)
1684 {
1685         const struct net_device_ops *ops = dev->netdev_ops;
1686         int rc;
1687
1688         if (likely(!skb->next)) {
1689                 if (!list_empty(&ptype_all))
1690                         dev_queue_xmit_nit(skb, dev);
1691
1692                 if (netif_needs_gso(dev, skb)) {
1693                         if (unlikely(dev_gso_segment(skb)))
1694                                 goto out_kfree_skb;
1695                         if (skb->next)
1696                                 goto gso;
1697                 }
1698
1699                 /*
1700                  * If device doesnt need skb->dst, release it right now while
1701                  * its hot in this cpu cache
1702                  */
1703                 if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
1704                         skb_dst_drop(skb);
1705
1706                 rc = ops->ndo_start_xmit(skb, dev);
1707                 if (rc == 0)
1708                         txq_trans_update(txq);
1709                 /*
1710                  * TODO: if skb_orphan() was called by
1711                  * dev->hard_start_xmit() (for example, the unmodified
1712                  * igb driver does that; bnx2 doesn't), then
1713                  * skb_tx_software_timestamp() will be unable to send
1714                  * back the time stamp.
1715                  *
1716                  * How can this be prevented? Always create another
1717                  * reference to the socket before calling
1718                  * dev->hard_start_xmit()? Prevent that skb_orphan()
1719                  * does anything in dev->hard_start_xmit() by clearing
1720                  * the skb destructor before the call and restoring it
1721                  * afterwards, then doing the skb_orphan() ourselves?
1722                  */
1723                 return rc;
1724         }
1725
1726 gso:
1727         do {
1728                 struct sk_buff *nskb = skb->next;
1729
1730                 skb->next = nskb->next;
1731                 nskb->next = NULL;
1732                 rc = ops->ndo_start_xmit(nskb, dev);
1733                 if (unlikely(rc)) {
1734                         nskb->next = skb->next;
1735                         skb->next = nskb;
1736                         return rc;
1737                 }
1738                 txq_trans_update(txq);
1739                 if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
1740                         return NETDEV_TX_BUSY;
1741         } while (skb->next);
1742
1743         skb->destructor = DEV_GSO_CB(skb)->destructor;
1744
1745 out_kfree_skb:
1746         kfree_skb(skb);
1747         return 0;
1748 }
1749
1750 static u32 skb_tx_hashrnd;
1751
1752 u16 skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb)
1753 {
1754         u32 hash;
1755
1756         if (skb_rx_queue_recorded(skb)) {
1757                 hash = skb_get_rx_queue(skb);
1758                 while (unlikely (hash >= dev->real_num_tx_queues))
1759                         hash -= dev->real_num_tx_queues;
1760                 return hash;
1761         }
1762
1763         if (skb->sk && skb->sk->sk_hash)
1764                 hash = skb->sk->sk_hash;
1765         else
1766                 hash = skb->protocol;
1767
1768         hash = jhash_1word(hash, skb_tx_hashrnd);
1769
1770         return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32);
1771 }
1772 EXPORT_SYMBOL(skb_tx_hash);
1773
1774 static struct netdev_queue *dev_pick_tx(struct net_device *dev,
1775                                         struct sk_buff *skb)
1776 {
1777         const struct net_device_ops *ops = dev->netdev_ops;
1778         u16 queue_index = 0;
1779
1780         if (ops->ndo_select_queue)
1781                 queue_index = ops->ndo_select_queue(dev, skb);
1782         else if (dev->real_num_tx_queues > 1)
1783                 queue_index = skb_tx_hash(dev, skb);
1784
1785         skb_set_queue_mapping(skb, queue_index);
1786         return netdev_get_tx_queue(dev, queue_index);
1787 }
1788
1789 /**
1790  *      dev_queue_xmit - transmit a buffer
1791  *      @skb: buffer to transmit
1792  *
1793  *      Queue a buffer for transmission to a network device. The caller must
1794  *      have set the device and priority and built the buffer before calling
1795  *      this function. The function can be called from an interrupt.
1796  *
1797  *      A negative errno code is returned on a failure. A success does not
1798  *      guarantee the frame will be transmitted as it may be dropped due
1799  *      to congestion or traffic shaping.
1800  *
1801  * -----------------------------------------------------------------------------------
1802  *      I notice this method can also return errors from the queue disciplines,
1803  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
1804  *      be positive.
1805  *
1806  *      Regardless of the return value, the skb is consumed, so it is currently
1807  *      difficult to retry a send to this method.  (You can bump the ref count
1808  *      before sending to hold a reference for retry if you are careful.)
1809  *
1810  *      When calling this method, interrupts MUST be enabled.  This is because
1811  *      the BH enable code must have IRQs enabled so that it will not deadlock.
1812  *          --BLG
1813  */
1814 int dev_queue_xmit(struct sk_buff *skb)
1815 {
1816         struct net_device *dev = skb->dev;
1817         struct netdev_queue *txq;
1818         struct Qdisc *q;
1819         int rc = -ENOMEM;
1820
1821         /* GSO will handle the following emulations directly. */
1822         if (netif_needs_gso(dev, skb))
1823                 goto gso;
1824
1825         if (skb_has_frags(skb) &&
1826             !(dev->features & NETIF_F_FRAGLIST) &&
1827             __skb_linearize(skb))
1828                 goto out_kfree_skb;
1829
1830         /* Fragmented skb is linearized if device does not support SG,
1831          * or if at least one of fragments is in highmem and device
1832          * does not support DMA from it.
1833          */
1834         if (skb_shinfo(skb)->nr_frags &&
1835             (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1836             __skb_linearize(skb))
1837                 goto out_kfree_skb;
1838
1839         /* If packet is not checksummed and device does not support
1840          * checksumming for this protocol, complete checksumming here.
1841          */
1842         if (skb->ip_summed == CHECKSUM_PARTIAL) {
1843                 skb_set_transport_header(skb, skb->csum_start -
1844                                               skb_headroom(skb));
1845                 if (!dev_can_checksum(dev, skb) && skb_checksum_help(skb))
1846                         goto out_kfree_skb;
1847         }
1848
1849 gso:
1850         /* Disable soft irqs for various locks below. Also
1851          * stops preemption for RCU.
1852          */
1853         rcu_read_lock_bh();
1854
1855         txq = dev_pick_tx(dev, skb);
1856         q = rcu_dereference(txq->qdisc);
1857
1858 #ifdef CONFIG_NET_CLS_ACT
1859         skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1860 #endif
1861         if (q->enqueue) {
1862                 spinlock_t *root_lock = qdisc_lock(q);
1863
1864                 spin_lock(root_lock);
1865
1866                 if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
1867                         kfree_skb(skb);
1868                         rc = NET_XMIT_DROP;
1869                 } else {
1870                         rc = qdisc_enqueue_root(skb, q);
1871                         qdisc_run(q);
1872                 }
1873                 spin_unlock(root_lock);
1874
1875                 goto out;
1876         }
1877
1878         /* The device has no queue. Common case for software devices:
1879            loopback, all the sorts of tunnels...
1880
1881            Really, it is unlikely that netif_tx_lock protection is necessary
1882            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
1883            counters.)
1884            However, it is possible, that they rely on protection
1885            made by us here.
1886
1887            Check this and shot the lock. It is not prone from deadlocks.
1888            Either shot noqueue qdisc, it is even simpler 8)
1889          */
1890         if (dev->flags & IFF_UP) {
1891                 int cpu = smp_processor_id(); /* ok because BHs are off */
1892
1893                 if (txq->xmit_lock_owner != cpu) {
1894
1895                         HARD_TX_LOCK(dev, txq, cpu);
1896
1897                         if (!netif_tx_queue_stopped(txq)) {
1898                                 rc = 0;
1899                                 if (!dev_hard_start_xmit(skb, dev, txq)) {
1900                                         HARD_TX_UNLOCK(dev, txq);
1901                                         goto out;
1902                                 }
1903                         }
1904                         HARD_TX_UNLOCK(dev, txq);
1905                         if (net_ratelimit())
1906                                 printk(KERN_CRIT "Virtual device %s asks to "
1907                                        "queue packet!\n", dev->name);
1908                 } else {
1909                         /* Recursion is detected! It is possible,
1910                          * unfortunately */
1911                         if (net_ratelimit())
1912                                 printk(KERN_CRIT "Dead loop on virtual device "
1913                                        "%s, fix it urgently!\n", dev->name);
1914                 }
1915         }
1916
1917         rc = -ENETDOWN;
1918         rcu_read_unlock_bh();
1919
1920 out_kfree_skb:
1921         kfree_skb(skb);
1922         return rc;
1923 out:
1924         rcu_read_unlock_bh();
1925         return rc;
1926 }
1927
1928
1929 /*=======================================================================
1930                         Receiver routines
1931   =======================================================================*/
1932
1933 int netdev_max_backlog __read_mostly = 1000;
1934 int netdev_budget __read_mostly = 300;
1935 int weight_p __read_mostly = 64;            /* old backlog weight */
1936
1937 DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1938
1939
1940 /**
1941  *      netif_rx        -       post buffer to the network code
1942  *      @skb: buffer to post
1943  *
1944  *      This function receives a packet from a device driver and queues it for
1945  *      the upper (protocol) levels to process.  It always succeeds. The buffer
1946  *      may be dropped during processing for congestion control or by the
1947  *      protocol layers.
1948  *
1949  *      return values:
1950  *      NET_RX_SUCCESS  (no congestion)
1951  *      NET_RX_DROP     (packet was dropped)
1952  *
1953  */
1954
1955 int netif_rx(struct sk_buff *skb)
1956 {
1957         struct softnet_data *queue;
1958         unsigned long flags;
1959
1960         /* if netpoll wants it, pretend we never saw it */
1961         if (netpoll_rx(skb))
1962                 return NET_RX_DROP;
1963
1964         if (!skb->tstamp.tv64)
1965                 net_timestamp(skb);
1966
1967         /*
1968          * The code is rearranged so that the path is the most
1969          * short when CPU is congested, but is still operating.
1970          */
1971         local_irq_save(flags);
1972         queue = &__get_cpu_var(softnet_data);
1973
1974         __get_cpu_var(netdev_rx_stat).total++;
1975         if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1976                 if (queue->input_pkt_queue.qlen) {
1977 enqueue:
1978                         __skb_queue_tail(&queue->input_pkt_queue, skb);
1979                         local_irq_restore(flags);
1980                         return NET_RX_SUCCESS;
1981                 }
1982
1983                 napi_schedule(&queue->backlog);
1984                 goto enqueue;
1985         }
1986
1987         __get_cpu_var(netdev_rx_stat).dropped++;
1988         local_irq_restore(flags);
1989
1990         kfree_skb(skb);
1991         return NET_RX_DROP;
1992 }
1993
1994 int netif_rx_ni(struct sk_buff *skb)
1995 {
1996         int err;
1997
1998         preempt_disable();
1999         err = netif_rx(skb);
2000         if (local_softirq_pending())
2001                 do_softirq();
2002         preempt_enable();
2003
2004         return err;
2005 }
2006
2007 EXPORT_SYMBOL(netif_rx_ni);
2008
2009 static void net_tx_action(struct softirq_action *h)
2010 {
2011         struct softnet_data *sd = &__get_cpu_var(softnet_data);
2012
2013         if (sd->completion_queue) {
2014                 struct sk_buff *clist;
2015
2016                 local_irq_disable();
2017                 clist = sd->completion_queue;
2018                 sd->completion_queue = NULL;
2019                 local_irq_enable();
2020
2021                 while (clist) {
2022                         struct sk_buff *skb = clist;
2023                         clist = clist->next;
2024
2025                         WARN_ON(atomic_read(&skb->users));
2026                         __kfree_skb(skb);
2027                 }
2028         }
2029
2030         if (sd->output_queue) {
2031                 struct Qdisc *head;
2032
2033                 local_irq_disable();
2034                 head = sd->output_queue;
2035                 sd->output_queue = NULL;
2036                 local_irq_enable();
2037
2038                 while (head) {
2039                         struct Qdisc *q = head;
2040                         spinlock_t *root_lock;
2041
2042                         head = head->next_sched;
2043
2044                         root_lock = qdisc_lock(q);
2045                         if (spin_trylock(root_lock)) {
2046                                 smp_mb__before_clear_bit();
2047                                 clear_bit(__QDISC_STATE_SCHED,
2048                                           &q->state);
2049                                 qdisc_run(q);
2050                                 spin_unlock(root_lock);
2051                         } else {
2052                                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
2053                                               &q->state)) {
2054                                         __netif_reschedule(q);
2055                                 } else {
2056                                         smp_mb__before_clear_bit();
2057                                         clear_bit(__QDISC_STATE_SCHED,
2058                                                   &q->state);
2059                                 }
2060                         }
2061                 }
2062         }
2063 }
2064
2065 static inline int deliver_skb(struct sk_buff *skb,
2066                               struct packet_type *pt_prev,
2067                               struct net_device *orig_dev)
2068 {
2069         atomic_inc(&skb->users);
2070         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2071 }
2072
2073 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
2074 /* These hooks defined here for ATM */
2075 struct net_bridge;
2076 struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
2077                                                 unsigned char *addr);
2078 void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
2079
2080 /*
2081  * If bridge module is loaded call bridging hook.
2082  *  returns NULL if packet was consumed.
2083  */
2084 struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
2085                                         struct sk_buff *skb) __read_mostly;
2086 static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
2087                                             struct packet_type **pt_prev, int *ret,
2088                                             struct net_device *orig_dev)
2089 {
2090         struct net_bridge_port *port;
2091
2092         if (skb->pkt_type == PACKET_LOOPBACK ||
2093             (port = rcu_dereference(skb->dev->br_port)) == NULL)
2094                 return skb;
2095
2096         if (*pt_prev) {
2097                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2098                 *pt_prev = NULL;
2099         }
2100
2101         return br_handle_frame_hook(port, skb);
2102 }
2103 #else
2104 #define handle_bridge(skb, pt_prev, ret, orig_dev)      (skb)
2105 #endif
2106
2107 #if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
2108 struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *skb) __read_mostly;
2109 EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook);
2110
2111 static inline struct sk_buff *handle_macvlan(struct sk_buff *skb,
2112                                              struct packet_type **pt_prev,
2113                                              int *ret,
2114                                              struct net_device *orig_dev)
2115 {
2116         if (skb->dev->macvlan_port == NULL)
2117                 return skb;
2118
2119         if (*pt_prev) {
2120                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2121                 *pt_prev = NULL;
2122         }
2123         return macvlan_handle_frame_hook(skb);
2124 }
2125 #else
2126 #define handle_macvlan(skb, pt_prev, ret, orig_dev)     (skb)
2127 #endif
2128
2129 #ifdef CONFIG_NET_CLS_ACT
2130 /* TODO: Maybe we should just force sch_ingress to be compiled in
2131  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
2132  * a compare and 2 stores extra right now if we dont have it on
2133  * but have CONFIG_NET_CLS_ACT
2134  * NOTE: This doesnt stop any functionality; if you dont have
2135  * the ingress scheduler, you just cant add policies on ingress.
2136  *
2137  */
2138 static int ing_filter(struct sk_buff *skb)
2139 {
2140         struct net_device *dev = skb->dev;
2141         u32 ttl = G_TC_RTTL(skb->tc_verd);
2142         struct netdev_queue *rxq;
2143         int result = TC_ACT_OK;
2144         struct Qdisc *q;
2145
2146         if (MAX_RED_LOOP < ttl++) {
2147                 printk(KERN_WARNING
2148                        "Redir loop detected Dropping packet (%d->%d)\n",
2149                        skb->iif, dev->ifindex);
2150                 return TC_ACT_SHOT;
2151         }
2152
2153         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
2154         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
2155
2156         rxq = &dev->rx_queue;
2157
2158         q = rxq->qdisc;
2159         if (q != &noop_qdisc) {
2160                 spin_lock(qdisc_lock(q));
2161                 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
2162                         result = qdisc_enqueue_root(skb, q);
2163                 spin_unlock(qdisc_lock(q));
2164         }
2165
2166         return result;
2167 }
2168
2169 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
2170                                          struct packet_type **pt_prev,
2171                                          int *ret, struct net_device *orig_dev)
2172 {
2173         if (skb->dev->rx_queue.qdisc == &noop_qdisc)
2174                 goto out;
2175
2176         if (*pt_prev) {
2177                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2178                 *pt_prev = NULL;
2179         } else {
2180                 /* Huh? Why does turning on AF_PACKET affect this? */
2181                 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
2182         }
2183
2184         switch (ing_filter(skb)) {
2185         case TC_ACT_SHOT:
2186         case TC_ACT_STOLEN:
2187                 kfree_skb(skb);
2188                 return NULL;
2189         }
2190
2191 out:
2192         skb->tc_verd = 0;
2193         return skb;
2194 }
2195 #endif
2196
2197 /*
2198  *      netif_nit_deliver - deliver received packets to network taps
2199  *      @skb: buffer
2200  *
2201  *      This function is used to deliver incoming packets to network
2202  *      taps. It should be used when the normal netif_receive_skb path
2203  *      is bypassed, for example because of VLAN acceleration.
2204  */
2205 void netif_nit_deliver(struct sk_buff *skb)
2206 {
2207         struct packet_type *ptype;
2208
2209         if (list_empty(&ptype_all))
2210                 return;
2211
2212         skb_reset_network_header(skb);
2213         skb_reset_transport_header(skb);
2214         skb->mac_len = skb->network_header - skb->mac_header;
2215
2216         rcu_read_lock();
2217         list_for_each_entry_rcu(ptype, &ptype_all, list) {
2218                 if (!ptype->dev || ptype->dev == skb->dev)
2219                         deliver_skb(skb, ptype, skb->dev);
2220         }
2221         rcu_read_unlock();
2222 }
2223
2224 /**
2225  *      netif_receive_skb - process receive buffer from network
2226  *      @skb: buffer to process
2227  *
2228  *      netif_receive_skb() is the main receive data processing function.
2229  *      It always succeeds. The buffer may be dropped during processing
2230  *      for congestion control or by the protocol layers.
2231  *
2232  *      This function may only be called from softirq context and interrupts
2233  *      should be enabled.
2234  *
2235  *      Return values (usually ignored):
2236  *      NET_RX_SUCCESS: no congestion
2237  *      NET_RX_DROP: packet was dropped
2238  */
2239 int netif_receive_skb(struct sk_buff *skb)
2240 {
2241         struct packet_type *ptype, *pt_prev;
2242         struct net_device *orig_dev;
2243         struct net_device *null_or_orig;
2244         int ret = NET_RX_DROP;
2245         __be16 type;
2246
2247         if (skb->vlan_tci && vlan_hwaccel_do_receive(skb))
2248                 return NET_RX_SUCCESS;
2249
2250         /* if we've gotten here through NAPI, check netpoll */
2251         if (netpoll_receive_skb(skb))
2252                 return NET_RX_DROP;
2253
2254         if (!skb->tstamp.tv64)
2255                 net_timestamp(skb);
2256
2257         if (!skb->iif)
2258                 skb->iif = skb->dev->ifindex;
2259
2260         null_or_orig = NULL;
2261         orig_dev = skb->dev;
2262         if (orig_dev->master) {
2263                 if (skb_bond_should_drop(skb))
2264                         null_or_orig = orig_dev; /* deliver only exact match */
2265                 else
2266                         skb->dev = orig_dev->master;
2267         }
2268
2269         __get_cpu_var(netdev_rx_stat).total++;
2270
2271         skb_reset_network_header(skb);
2272         skb_reset_transport_header(skb);
2273         skb->mac_len = skb->network_header - skb->mac_header;
2274
2275         pt_prev = NULL;
2276
2277         rcu_read_lock();
2278
2279 #ifdef CONFIG_NET_CLS_ACT
2280         if (skb->tc_verd & TC_NCLS) {
2281                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2282                 goto ncls;
2283         }
2284 #endif
2285
2286         list_for_each_entry_rcu(ptype, &ptype_all, list) {
2287                 if (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2288                     ptype->dev == orig_dev) {
2289                         if (pt_prev)
2290                                 ret = deliver_skb(skb, pt_prev, orig_dev);
2291                         pt_prev = ptype;
2292                 }
2293         }
2294
2295 #ifdef CONFIG_NET_CLS_ACT
2296         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2297         if (!skb)
2298                 goto out;
2299 ncls:
2300 #endif
2301
2302         skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2303         if (!skb)
2304                 goto out;
2305         skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2306         if (!skb)
2307                 goto out;
2308
2309         skb_orphan(skb);
2310
2311         type = skb->protocol;
2312         list_for_each_entry_rcu(ptype,
2313                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
2314                 if (ptype->type == type &&
2315                     (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2316                      ptype->dev == orig_dev)) {
2317                         if (pt_prev)
2318                                 ret = deliver_skb(skb, pt_prev, orig_dev);
2319                         pt_prev = ptype;
2320                 }
2321         }
2322
2323         if (pt_prev) {
2324                 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2325         } else {
2326                 kfree_skb(skb);
2327                 /* Jamal, now you will not able to escape explaining
2328                  * me how you were going to use this. :-)
2329                  */
2330                 ret = NET_RX_DROP;
2331         }
2332
2333 out:
2334         rcu_read_unlock();
2335         return ret;
2336 }
2337
2338 /* Network device is going away, flush any packets still pending  */
2339 static void flush_backlog(void *arg)
2340 {
2341         struct net_device *dev = arg;
2342         struct softnet_data *queue = &__get_cpu_var(softnet_data);
2343         struct sk_buff *skb, *tmp;
2344
2345         skb_queue_walk_safe(&queue->input_pkt_queue, skb, tmp)
2346                 if (skb->dev == dev) {
2347                         __skb_unlink(skb, &queue->input_pkt_queue);
2348                         kfree_skb(skb);
2349                 }
2350 }
2351
2352 static int napi_gro_complete(struct sk_buff *skb)
2353 {
2354         struct packet_type *ptype;
2355         __be16 type = skb->protocol;
2356         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
2357         int err = -ENOENT;
2358
2359         if (NAPI_GRO_CB(skb)->count == 1) {
2360                 skb_shinfo(skb)->gso_size = 0;
2361                 goto out;
2362         }
2363
2364         rcu_read_lock();
2365         list_for_each_entry_rcu(ptype, head, list) {
2366                 if (ptype->type != type || ptype->dev || !ptype->gro_complete)
2367                         continue;
2368
2369                 err = ptype->gro_complete(skb);
2370                 break;
2371         }
2372         rcu_read_unlock();
2373
2374         if (err) {
2375                 WARN_ON(&ptype->list == head);
2376                 kfree_skb(skb);
2377                 return NET_RX_SUCCESS;
2378         }
2379
2380 out:
2381         return netif_receive_skb(skb);
2382 }
2383
2384 void napi_gro_flush(struct napi_struct *napi)
2385 {
2386         struct sk_buff *skb, *next;
2387
2388         for (skb = napi->gro_list; skb; skb = next) {
2389                 next = skb->next;
2390                 skb->next = NULL;
2391                 napi_gro_complete(skb);
2392         }
2393
2394         napi->gro_count = 0;
2395         napi->gro_list = NULL;
2396 }
2397 EXPORT_SYMBOL(napi_gro_flush);
2398
2399 int dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
2400 {
2401         struct sk_buff **pp = NULL;
2402         struct packet_type *ptype;
2403         __be16 type = skb->protocol;
2404         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
2405         int same_flow;
2406         int mac_len;
2407         int ret;
2408
2409         if (!(skb->dev->features & NETIF_F_GRO))
2410                 goto normal;
2411
2412         if (skb_is_gso(skb) || skb_has_frags(skb))
2413                 goto normal;
2414
2415         rcu_read_lock();
2416         list_for_each_entry_rcu(ptype, head, list) {
2417                 if (ptype->type != type || ptype->dev || !ptype->gro_receive)
2418                         continue;
2419
2420                 skb_set_network_header(skb, skb_gro_offset(skb));
2421                 mac_len = skb->network_header - skb->mac_header;
2422                 skb->mac_len = mac_len;
2423                 NAPI_GRO_CB(skb)->same_flow = 0;
2424                 NAPI_GRO_CB(skb)->flush = 0;
2425                 NAPI_GRO_CB(skb)->free = 0;
2426
2427                 pp = ptype->gro_receive(&napi->gro_list, skb);
2428                 break;
2429         }
2430         rcu_read_unlock();
2431
2432         if (&ptype->list == head)
2433                 goto normal;
2434
2435         same_flow = NAPI_GRO_CB(skb)->same_flow;
2436         ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;
2437
2438         if (pp) {
2439                 struct sk_buff *nskb = *pp;
2440
2441                 *pp = nskb->next;
2442                 nskb->next = NULL;
2443                 napi_gro_complete(nskb);
2444                 napi->gro_count--;
2445         }
2446
2447         if (same_flow)
2448                 goto ok;
2449
2450         if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
2451                 goto normal;
2452
2453         napi->gro_count++;
2454         NAPI_GRO_CB(skb)->count = 1;
2455         skb_shinfo(skb)->gso_size = skb_gro_len(skb);
2456         skb->next = napi->gro_list;
2457         napi->gro_list = skb;
2458         ret = GRO_HELD;
2459
2460 pull:
2461         if (skb_headlen(skb) < skb_gro_offset(skb)) {
2462                 int grow = skb_gro_offset(skb) - skb_headlen(skb);
2463
2464                 BUG_ON(skb->end - skb->tail < grow);
2465
2466                 memcpy(skb_tail_pointer(skb), NAPI_GRO_CB(skb)->frag0, grow);
2467
2468                 skb->tail += grow;
2469                 skb->data_len -= grow;
2470
2471                 skb_shinfo(skb)->frags[0].page_offset += grow;
2472                 skb_shinfo(skb)->frags[0].size -= grow;
2473
2474                 if (unlikely(!skb_shinfo(skb)->frags[0].size)) {
2475                         put_page(skb_shinfo(skb)->frags[0].page);
2476                         memmove(skb_shinfo(skb)->frags,
2477                                 skb_shinfo(skb)->frags + 1,
2478                                 --skb_shinfo(skb)->nr_frags);
2479                 }
2480         }
2481
2482 ok:
2483         return ret;
2484
2485 normal:
2486         ret = GRO_NORMAL;
2487         goto pull;
2488 }
2489 EXPORT_SYMBOL(dev_gro_receive);
2490
2491 static int __napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
2492 {
2493         struct sk_buff *p;
2494
2495         if (netpoll_rx_on(skb))
2496                 return GRO_NORMAL;
2497
2498         for (p = napi->gro_list; p; p = p->next) {
2499                 NAPI_GRO_CB(p)->same_flow = (p->dev == skb->dev)
2500                         && !compare_ether_header(skb_mac_header(p),
2501                                                  skb_gro_mac_header(skb));
2502                 NAPI_GRO_CB(p)->flush = 0;
2503         }
2504
2505         return dev_gro_receive(napi, skb);
2506 }
2507
2508 int napi_skb_finish(int ret, struct sk_buff *skb)
2509 {
2510         int err = NET_RX_SUCCESS;
2511
2512         switch (ret) {
2513         case GRO_NORMAL:
2514                 return netif_receive_skb(skb);
2515
2516         case GRO_DROP:
2517                 err = NET_RX_DROP;
2518                 /* fall through */
2519
2520         case GRO_MERGED_FREE:
2521                 kfree_skb(skb);
2522                 break;
2523         }
2524
2525         return err;
2526 }
2527 EXPORT_SYMBOL(napi_skb_finish);
2528
2529 void skb_gro_reset_offset(struct sk_buff *skb)
2530 {
2531         NAPI_GRO_CB(skb)->data_offset = 0;
2532         NAPI_GRO_CB(skb)->frag0 = NULL;
2533         NAPI_GRO_CB(skb)->frag0_len = 0;
2534
2535         if (skb->mac_header == skb->tail &&
2536             !PageHighMem(skb_shinfo(skb)->frags[0].page)) {
2537                 NAPI_GRO_CB(skb)->frag0 =
2538                         page_address(skb_shinfo(skb)->frags[0].page) +
2539                         skb_shinfo(skb)->frags[0].page_offset;
2540                 NAPI_GRO_CB(skb)->frag0_len = skb_shinfo(skb)->frags[0].size;
2541         }
2542 }
2543 EXPORT_SYMBOL(skb_gro_reset_offset);
2544
2545 int napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
2546 {
2547         skb_gro_reset_offset(skb);
2548
2549         return napi_skb_finish(__napi_gro_receive(napi, skb), skb);
2550 }
2551 EXPORT_SYMBOL(napi_gro_receive);
2552
2553 void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
2554 {
2555         __skb_pull(skb, skb_headlen(skb));
2556         skb_reserve(skb, NET_IP_ALIGN - skb_headroom(skb));
2557
2558         napi->skb = skb;
2559 }
2560 EXPORT_SYMBOL(napi_reuse_skb);
2561
2562 struct sk_buff *napi_get_frags(struct napi_struct *napi)
2563 {
2564         struct net_device *dev = napi->dev;
2565         struct sk_buff *skb = napi->skb;
2566
2567         if (!skb) {
2568                 skb = netdev_alloc_skb(dev, GRO_MAX_HEAD + NET_IP_ALIGN);
2569                 if (!skb)
2570                         goto out;
2571
2572                 skb_reserve(skb, NET_IP_ALIGN);
2573
2574                 napi->skb = skb;
2575         }
2576
2577 out:
2578         return skb;
2579 }
2580 EXPORT_SYMBOL(napi_get_frags);
2581
2582 int napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb, int ret)
2583 {
2584         int err = NET_RX_SUCCESS;
2585
2586         switch (ret) {
2587         case GRO_NORMAL:
2588         case GRO_HELD:
2589                 skb->protocol = eth_type_trans(skb, napi->dev);
2590
2591                 if (ret == GRO_NORMAL)
2592                         return netif_receive_skb(skb);
2593
2594                 skb_gro_pull(skb, -ETH_HLEN);
2595                 break;
2596
2597         case GRO_DROP:
2598                 err = NET_RX_DROP;
2599                 /* fall through */
2600
2601         case GRO_MERGED_FREE:
2602                 napi_reuse_skb(napi, skb);
2603                 break;
2604         }
2605
2606         return err;
2607 }
2608 EXPORT_SYMBOL(napi_frags_finish);
2609
2610 struct sk_buff *napi_frags_skb(struct napi_struct *napi)
2611 {
2612         struct sk_buff *skb = napi->skb;
2613         struct ethhdr *eth;
2614         unsigned int hlen;
2615         unsigned int off;
2616
2617         napi->skb = NULL;
2618
2619         skb_reset_mac_header(skb);
2620         skb_gro_reset_offset(skb);
2621
2622         off = skb_gro_offset(skb);
2623         hlen = off + sizeof(*eth);
2624         eth = skb_gro_header_fast(skb, off);
2625         if (skb_gro_header_hard(skb, hlen)) {
2626                 eth = skb_gro_header_slow(skb, hlen, off);
2627                 if (unlikely(!eth)) {
2628                         napi_reuse_skb(napi, skb);
2629                         skb = NULL;
2630                         goto out;
2631                 }
2632         }
2633
2634         skb_gro_pull(skb, sizeof(*eth));
2635
2636         /*
2637          * This works because the only protocols we care about don't require
2638          * special handling.  We'll fix it up properly at the end.
2639          */
2640         skb->protocol = eth->h_proto;
2641
2642 out:
2643         return skb;
2644 }
2645 EXPORT_SYMBOL(napi_frags_skb);
2646
2647 int napi_gro_frags(struct napi_struct *napi)
2648 {
2649         struct sk_buff *skb = napi_frags_skb(napi);
2650
2651         if (!skb)
2652                 return NET_RX_DROP;
2653
2654         return napi_frags_finish(napi, skb, __napi_gro_receive(napi, skb));
2655 }
2656 EXPORT_SYMBOL(napi_gro_frags);
2657
2658 static int process_backlog(struct napi_struct *napi, int quota)
2659 {
2660         int work = 0;
2661         struct softnet_data *queue = &__get_cpu_var(softnet_data);
2662         unsigned long start_time = jiffies;
2663
2664         napi->weight = weight_p;
2665         do {
2666                 struct sk_buff *skb;
2667
2668                 local_irq_disable();
2669                 skb = __skb_dequeue(&queue->input_pkt_queue);
2670                 if (!skb) {
2671                         __napi_complete(napi);
2672                         local_irq_enable();
2673                         break;
2674                 }
2675                 local_irq_enable();
2676
2677                 netif_receive_skb(skb);
2678         } while (++work < quota && jiffies == start_time);
2679
2680         return work;
2681 }
2682
2683 /**
2684  * __napi_schedule - schedule for receive
2685  * @n: entry to schedule
2686  *
2687  * The entry's receive function will be scheduled to run
2688  */
2689 void __napi_schedule(struct napi_struct *n)
2690 {
2691         unsigned long flags;
2692
2693         local_irq_save(flags);
2694         list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2695         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2696         local_irq_restore(flags);
2697 }
2698 EXPORT_SYMBOL(__napi_schedule);
2699
2700 void __napi_complete(struct napi_struct *n)
2701 {
2702         BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
2703         BUG_ON(n->gro_list);
2704
2705         list_del(&n->poll_list);
2706         smp_mb__before_clear_bit();
2707         clear_bit(NAPI_STATE_SCHED, &n->state);
2708 }
2709 EXPORT_SYMBOL(__napi_complete);
2710
2711 void napi_complete(struct napi_struct *n)
2712 {
2713         unsigned long flags;
2714
2715         /*
2716          * don't let napi dequeue from the cpu poll list
2717          * just in case its running on a different cpu
2718          */
2719         if (unlikely(test_bit(NAPI_STATE_NPSVC, &n->state)))
2720                 return;
2721
2722         napi_gro_flush(n);
2723         local_irq_save(flags);
2724         __napi_complete(n);
2725         local_irq_restore(flags);
2726 }
2727 EXPORT_SYMBOL(napi_complete);
2728
2729 void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
2730                     int (*poll)(struct napi_struct *, int), int weight)
2731 {
2732         INIT_LIST_HEAD(&napi->poll_list);
2733         napi->gro_count = 0;
2734         napi->gro_list = NULL;
2735         napi->skb = NULL;
2736         napi->poll = poll;
2737         napi->weight = weight;
2738         list_add(&napi->dev_list, &dev->napi_list);
2739         napi->dev = dev;
2740 #ifdef CONFIG_NETPOLL
2741         spin_lock_init(&napi->poll_lock);
2742         napi->poll_owner = -1;
2743 #endif
2744         set_bit(NAPI_STATE_SCHED, &napi->state);
2745 }
2746 EXPORT_SYMBOL(netif_napi_add);
2747
2748 void netif_napi_del(struct napi_struct *napi)
2749 {
2750         struct sk_buff *skb, *next;
2751
2752         list_del_init(&napi->dev_list);
2753         napi_free_frags(napi);
2754
2755         for (skb = napi->gro_list; skb; skb = next) {
2756                 next = skb->next;
2757                 skb->next = NULL;
2758                 kfree_skb(skb);
2759         }
2760
2761         napi->gro_list = NULL;
2762         napi->gro_count = 0;
2763 }
2764 EXPORT_SYMBOL(netif_napi_del);
2765
2766
2767 static void net_rx_action(struct softirq_action *h)
2768 {
2769         struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
2770         unsigned long time_limit = jiffies + 2;
2771         int budget = netdev_budget;
2772         void *have;
2773
2774         local_irq_disable();
2775
2776         while (!list_empty(list)) {
2777                 struct napi_struct *n;
2778                 int work, weight;
2779
2780                 /* If softirq window is exhuasted then punt.
2781                  * Allow this to run for 2 jiffies since which will allow
2782                  * an average latency of 1.5/HZ.
2783                  */
2784                 if (unlikely(budget <= 0 || time_after(jiffies, time_limit)))
2785                         goto softnet_break;
2786
2787                 local_irq_enable();
2788
2789                 /* Even though interrupts have been re-enabled, this
2790                  * access is safe because interrupts can only add new
2791                  * entries to the tail of this list, and only ->poll()
2792                  * calls can remove this head entry from the list.
2793                  */
2794                 n = list_entry(list->next, struct napi_struct, poll_list);
2795
2796                 have = netpoll_poll_lock(n);
2797
2798                 weight = n->weight;
2799
2800                 /* This NAPI_STATE_SCHED test is for avoiding a race
2801                  * with netpoll's poll_napi().  Only the entity which
2802                  * obtains the lock and sees NAPI_STATE_SCHED set will
2803                  * actually make the ->poll() call.  Therefore we avoid
2804                  * accidently calling ->poll() when NAPI is not scheduled.
2805                  */
2806                 work = 0;
2807                 if (test_bit(NAPI_STATE_SCHED, &n->state)) {
2808                         work = n->poll(n, weight);
2809                         trace_napi_poll(n);
2810                 }
2811
2812                 WARN_ON_ONCE(work > weight);
2813
2814                 budget -= work;
2815
2816                 local_irq_disable();
2817
2818                 /* Drivers must not modify the NAPI state if they
2819                  * consume the entire weight.  In such cases this code
2820                  * still "owns" the NAPI instance and therefore can
2821                  * move the instance around on the list at-will.
2822                  */
2823                 if (unlikely(work == weight)) {
2824                         if (unlikely(napi_disable_pending(n)))
2825                                 __napi_complete(n);
2826                         else
2827                                 list_move_tail(&n->poll_list, list);
2828                 }
2829
2830                 netpoll_poll_unlock(have);
2831         }
2832 out:
2833         local_irq_enable();
2834
2835 #ifdef CONFIG_NET_DMA
2836         /*
2837          * There may not be any more sk_buffs coming right now, so push
2838          * any pending DMA copies to hardware
2839          */
2840         dma_issue_pending_all();
2841 #endif
2842
2843         return;
2844
2845 softnet_break:
2846         __get_cpu_var(netdev_rx_stat).time_squeeze++;
2847         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2848         goto out;
2849 }
2850
2851 static gifconf_func_t * gifconf_list [NPROTO];
2852
2853 /**
2854  *      register_gifconf        -       register a SIOCGIF handler
2855  *      @family: Address family
2856  *      @gifconf: Function handler
2857  *
2858  *      Register protocol dependent address dumping routines. The handler
2859  *      that is passed must not be freed or reused until it has been replaced
2860  *      by another handler.
2861  */
2862 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2863 {
2864         if (family >= NPROTO)
2865                 return -EINVAL;
2866         gifconf_list[family] = gifconf;
2867         return 0;
2868 }
2869
2870
2871 /*
2872  *      Map an interface index to its name (SIOCGIFNAME)
2873  */
2874
2875 /*
2876  *      We need this ioctl for efficient implementation of the
2877  *      if_indextoname() function required by the IPv6 API.  Without
2878  *      it, we would have to search all the interfaces to find a
2879  *      match.  --pb
2880  */
2881
2882 static int dev_ifname(struct net *net, struct ifreq __user *arg)
2883 {
2884         struct net_device *dev;
2885         struct ifreq ifr;
2886
2887         /*
2888          *      Fetch the caller's info block.
2889          */
2890
2891         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2892                 return -EFAULT;
2893
2894         read_lock(&dev_base_lock);
2895         dev = __dev_get_by_index(net, ifr.ifr_ifindex);
2896         if (!dev) {
2897                 read_unlock(&dev_base_lock);
2898                 return -ENODEV;
2899         }
2900
2901         strcpy(ifr.ifr_name, dev->name);
2902         read_unlock(&dev_base_lock);
2903
2904         if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2905                 return -EFAULT;
2906         return 0;
2907 }
2908
2909 /*
2910  *      Perform a SIOCGIFCONF call. This structure will change
2911  *      size eventually, and there is nothing I can do about it.
2912  *      Thus we will need a 'compatibility mode'.
2913  */
2914
2915 static int dev_ifconf(struct net *net, char __user *arg)
2916 {
2917         struct ifconf ifc;
2918         struct net_device *dev;
2919         char __user *pos;
2920         int len;
2921         int total;
2922         int i;
2923
2924         /*
2925          *      Fetch the caller's info block.
2926          */
2927
2928         if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2929                 return -EFAULT;
2930
2931         pos = ifc.ifc_buf;
2932         len = ifc.ifc_len;
2933
2934         /*
2935          *      Loop over the interfaces, and write an info block for each.
2936          */
2937
2938         total = 0;
2939         for_each_netdev(net, dev) {
2940                 for (i = 0; i < NPROTO; i++) {
2941                         if (gifconf_list[i]) {
2942                                 int done;
2943                                 if (!pos)
2944                                         done = gifconf_list[i](dev, NULL, 0);
2945                                 else
2946                                         done = gifconf_list[i](dev, pos + total,
2947                                                                len - total);
2948                                 if (done < 0)
2949                                         return -EFAULT;
2950                                 total += done;
2951                         }
2952                 }
2953         }
2954
2955         /*
2956          *      All done.  Write the updated control block back to the caller.
2957          */
2958         ifc.ifc_len = total;
2959
2960         /*
2961          *      Both BSD and Solaris return 0 here, so we do too.
2962          */
2963         return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2964 }
2965
2966 #ifdef CONFIG_PROC_FS
2967 /*
2968  *      This is invoked by the /proc filesystem handler to display a device
2969  *      in detail.
2970  */
2971 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2972         __acquires(dev_base_lock)
2973 {
2974         struct net *net = seq_file_net(seq);
2975         loff_t off;
2976         struct net_device *dev;
2977
2978         read_lock(&dev_base_lock);
2979         if (!*pos)
2980                 return SEQ_START_TOKEN;
2981
2982         off = 1;
2983         for_each_netdev(net, dev)
2984                 if (off++ == *pos)
2985                         return dev;
2986
2987         return NULL;
2988 }
2989
2990 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2991 {
2992         struct net *net = seq_file_net(seq);
2993         ++*pos;
2994         return v == SEQ_START_TOKEN ?
2995                 first_net_device(net) : next_net_device((struct net_device *)v);
2996 }
2997
2998 void dev_seq_stop(struct seq_file *seq, void *v)
2999         __releases(dev_base_lock)
3000 {
3001         read_unlock(&dev_base_lock);
3002 }
3003
3004 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
3005 {
3006         const struct net_device_stats *stats = dev_get_stats(dev);
3007
3008         seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
3009                    "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
3010                    dev->name, stats->rx_bytes, stats->rx_packets,
3011                    stats->rx_errors,
3012                    stats->rx_dropped + stats->rx_missed_errors,
3013                    stats->rx_fifo_errors,
3014                    stats->rx_length_errors + stats->rx_over_errors +
3015                     stats->rx_crc_errors + stats->rx_frame_errors,
3016                    stats->rx_compressed, stats->multicast,
3017                    stats->tx_bytes, stats->tx_packets,
3018                    stats->tx_errors, stats->tx_dropped,
3019                    stats->tx_fifo_errors, stats->collisions,
3020                    stats->tx_carrier_errors +
3021                     stats->tx_aborted_errors +
3022                     stats->tx_window_errors +
3023                     stats->tx_heartbeat_errors,
3024                    stats->tx_compressed);
3025 }
3026
3027 /*
3028  *      Called from the PROCfs module. This now uses the new arbitrary sized
3029  *      /proc/net interface to create /proc/net/dev
3030  */
3031 static int dev_seq_show(struct seq_file *seq, void *v)
3032 {
3033         if (v == SEQ_START_TOKEN)
3034                 seq_puts(seq, "Inter-|   Receive                            "
3035                               "                    |  Transmit\n"
3036                               " face |bytes    packets errs drop fifo frame "
3037                               "compressed multicast|bytes    packets errs "
3038                               "drop fifo colls carrier compressed\n");
3039         else
3040                 dev_seq_printf_stats(seq, v);
3041         return 0;
3042 }
3043
3044 static struct netif_rx_stats *softnet_get_online(loff_t *pos)
3045 {
3046         struct netif_rx_stats *rc = NULL;
3047
3048         while (*pos < nr_cpu_ids)
3049                 if (cpu_online(*pos)) {
3050                         rc = &per_cpu(netdev_rx_stat, *pos);
3051                         break;
3052                 } else
3053                         ++*pos;
3054         return rc;
3055 }
3056
3057 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
3058 {
3059         return softnet_get_online(pos);
3060 }
3061
3062 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3063 {
3064         ++*pos;
3065         return softnet_get_online(pos);
3066 }
3067
3068 static void softnet_seq_stop(struct seq_file *seq, void *v)
3069 {
3070 }
3071
3072 static int softnet_seq_show(struct seq_file *seq, void *v)
3073 {
3074         struct netif_rx_stats *s = v;
3075
3076         seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
3077                    s->total, s->dropped, s->time_squeeze, 0,
3078                    0, 0, 0, 0, /* was fastroute */
3079                    s->cpu_collision );
3080         return 0;
3081 }
3082
3083 static const struct seq_operations dev_seq_ops = {
3084         .start = dev_seq_start,
3085         .next  = dev_seq_next,
3086         .stop  = dev_seq_stop,
3087         .show  = dev_seq_show,
3088 };
3089
3090 static int dev_seq_open(struct inode *inode, struct file *file)
3091 {
3092         return seq_open_net(inode, file, &dev_seq_ops,
3093                             sizeof(struct seq_net_private));
3094 }
3095
3096 static const struct file_operations dev_seq_fops = {
3097         .owner   = THIS_MODULE,
3098         .open    = dev_seq_open,
3099         .read    = seq_read,
3100         .llseek  = seq_lseek,
3101         .release = seq_release_net,
3102 };
3103
3104 static const struct seq_operations softnet_seq_ops = {
3105         .start = softnet_seq_start,
3106         .next  = softnet_seq_next,
3107         .stop  = softnet_seq_stop,
3108         .show  = softnet_seq_show,
3109 };
3110
3111 static int softnet_seq_open(struct inode *inode, struct file *file)
3112 {
3113         return seq_open(file, &softnet_seq_ops);
3114 }
3115
3116 static const struct file_operations softnet_seq_fops = {
3117         .owner   = THIS_MODULE,
3118         .open    = softnet_seq_open,
3119         .read    = seq_read,
3120         .llseek  = seq_lseek,
3121         .release = seq_release,
3122 };
3123
3124 static void *ptype_get_idx(loff_t pos)
3125 {
3126         struct packet_type *pt = NULL;
3127         loff_t i = 0;
3128         int t;
3129
3130         list_for_each_entry_rcu(pt, &ptype_all, list) {
3131                 if (i == pos)
3132                         return pt;
3133                 ++i;
3134         }
3135
3136         for (t = 0; t < PTYPE_HASH_SIZE; t++) {
3137                 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
3138                         if (i == pos)
3139                                 return pt;
3140                         ++i;
3141                 }
3142         }
3143         return NULL;
3144 }
3145
3146 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
3147         __acquires(RCU)
3148 {
3149         rcu_read_lock();
3150         return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
3151 }
3152
3153 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3154 {
3155         struct packet_type *pt;
3156         struct list_head *nxt;
3157         int hash;
3158
3159         ++*pos;
3160         if (v == SEQ_START_TOKEN)
3161                 return ptype_get_idx(0);
3162
3163         pt = v;
3164         nxt = pt->list.next;
3165         if (pt->type == htons(ETH_P_ALL)) {
3166                 if (nxt != &ptype_all)
3167                         goto found;
3168                 hash = 0;
3169                 nxt = ptype_base[0].next;
3170         } else
3171                 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
3172
3173         while (nxt == &ptype_base[hash]) {
3174                 if (++hash >= PTYPE_HASH_SIZE)
3175                         return NULL;
3176                 nxt = ptype_base[hash].next;
3177         }
3178 found:
3179         return list_entry(nxt, struct packet_type, list);
3180 }
3181
3182 static void ptype_seq_stop(struct seq_file *seq, void *v)
3183         __releases(RCU)
3184 {
3185         rcu_read_unlock();
3186 }
3187
3188 static int ptype_seq_show(struct seq_file *seq, void *v)
3189 {
3190         struct packet_type *pt = v;
3191
3192         if (v == SEQ_START_TOKEN)
3193                 seq_puts(seq, "Type Device      Function\n");
3194         else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
3195                 if (pt->type == htons(ETH_P_ALL))
3196                         seq_puts(seq, "ALL ");
3197                 else
3198                         seq_printf(seq, "%04x", ntohs(pt->type));
3199
3200                 seq_printf(seq, " %-8s %pF\n",
3201                            pt->dev ? pt->dev->name : "", pt->func);
3202         }
3203
3204         return 0;
3205 }
3206
3207 static const struct seq_operations ptype_seq_ops = {
3208         .start = ptype_seq_start,
3209         .next  = ptype_seq_next,
3210         .stop  = ptype_seq_stop,
3211         .show  = ptype_seq_show,
3212 };
3213
3214 static int ptype_seq_open(struct inode *inode, struct file *file)
3215 {
3216         return seq_open_net(inode, file, &ptype_seq_ops,
3217                         sizeof(struct seq_net_private));
3218 }
3219
3220 static const struct file_operations ptype_seq_fops = {
3221         .owner   = THIS_MODULE,
3222         .open    = ptype_seq_open,
3223         .read    = seq_read,
3224         .llseek  = seq_lseek,
3225         .release = seq_release_net,
3226 };
3227
3228
3229 static int __net_init dev_proc_net_init(struct net *net)
3230 {
3231         int rc = -ENOMEM;
3232
3233         if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
3234                 goto out;
3235         if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
3236                 goto out_dev;
3237         if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
3238                 goto out_softnet;
3239
3240         if (wext_proc_init(net))
3241                 goto out_ptype;
3242         rc = 0;
3243 out:
3244         return rc;
3245 out_ptype:
3246         proc_net_remove(net, "ptype");
3247 out_softnet:
3248         proc_net_remove(net, "softnet_stat");
3249 out_dev:
3250         proc_net_remove(net, "dev");
3251         goto out;
3252 }
3253
3254 static void __net_exit dev_proc_net_exit(struct net *net)
3255 {
3256         wext_proc_exit(net);
3257
3258         proc_net_remove(net, "ptype");
3259         proc_net_remove(net, "softnet_stat");
3260         proc_net_remove(net, "dev");
3261 }
3262
3263 static struct pernet_operations __net_initdata dev_proc_ops = {
3264         .init = dev_proc_net_init,
3265         .exit = dev_proc_net_exit,
3266 };
3267
3268 static int __init dev_proc_init(void)
3269 {
3270         return register_pernet_subsys(&dev_proc_ops);
3271 }
3272 #else
3273 #define dev_proc_init() 0
3274 #endif  /* CONFIG_PROC_FS */
3275
3276
3277 /**
3278  *      netdev_set_master       -       set up master/slave pair
3279  *      @slave: slave device
3280  *      @master: new master device
3281  *
3282  *      Changes the master device of the slave. Pass %NULL to break the
3283  *      bonding. The caller must hold the RTNL semaphore. On a failure
3284  *      a negative errno code is returned. On success the reference counts
3285  *      are adjusted, %RTM_NEWLINK is sent to the routing socket and the
3286  *      function returns zero.
3287  */
3288 int netdev_set_master(struct net_device *slave, struct net_device *master)
3289 {
3290         struct net_device *old = slave->master;
3291
3292         ASSERT_RTNL();
3293
3294         if (master) {
3295                 if (old)
3296                         return -EBUSY;
3297                 dev_hold(master);
3298         }
3299
3300         slave->master = master;
3301
3302         synchronize_net();
3303
3304         if (old)
3305                 dev_put(old);
3306
3307         if (master)
3308                 slave->flags |= IFF_SLAVE;
3309         else
3310                 slave->flags &= ~IFF_SLAVE;
3311
3312         rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
3313         return 0;
3314 }
3315
3316 static void dev_change_rx_flags(struct net_device *dev, int flags)
3317 {
3318         const struct net_device_ops *ops = dev->netdev_ops;
3319
3320         if ((dev->flags & IFF_UP) && ops->ndo_change_rx_flags)
3321                 ops->ndo_change_rx_flags(dev, flags);
3322 }
3323
3324 static int __dev_set_promiscuity(struct net_device *dev, int inc)
3325 {
3326         unsigned short old_flags = dev->flags;
3327         uid_t uid;
3328         gid_t gid;
3329
3330         ASSERT_RTNL();
3331
3332         dev->flags |= IFF_PROMISC;
3333         dev->promiscuity += inc;
3334         if (dev->promiscuity == 0) {
3335                 /*
3336                  * Avoid overflow.
3337                  * If inc causes overflow, untouch promisc and return error.
3338                  */
3339                 if (inc < 0)
3340                         dev->flags &= ~IFF_PROMISC;
3341                 else {
3342                         dev->promiscuity -= inc;
3343                         printk(KERN_WARNING "%s: promiscuity touches roof, "
3344                                 "set promiscuity failed, promiscuity feature "
3345                                 "of device might be broken.\n", dev->name);
3346                         return -EOVERFLOW;
3347                 }
3348         }
3349         if (dev->flags != old_flags) {
3350                 printk(KERN_INFO "device %s %s promiscuous mode\n",
3351                        dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
3352                                                                "left");
3353                 if (audit_enabled) {
3354                         current_uid_gid(&uid, &gid);
3355                         audit_log(current->audit_context, GFP_ATOMIC,
3356                                 AUDIT_ANOM_PROMISCUOUS,
3357                                 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
3358                                 dev->name, (dev->flags & IFF_PROMISC),
3359                                 (old_flags & IFF_PROMISC),
3360                                 audit_get_loginuid(current),
3361                                 uid, gid,
3362                                 audit_get_sessionid(current));
3363                 }
3364
3365                 dev_change_rx_flags(dev, IFF_PROMISC);
3366         }
3367         return 0;
3368 }
3369
3370 /**
3371  *      dev_set_promiscuity     - update promiscuity count on a device
3372  *      @dev: device
3373  *      @inc: modifier
3374  *
3375  *      Add or remove promiscuity from a device. While the count in the device
3376  *      remains above zero the interface remains promiscuous. Once it hits zero
3377  *      the device reverts back to normal filtering operation. A negative inc
3378  *      value is used to drop promiscuity on the device.
3379  *      Return 0 if successful or a negative errno code on error.
3380  */
3381 int dev_set_promiscuity(struct net_device *dev, int inc)
3382 {
3383         unsigned short old_flags = dev->flags;
3384         int err;
3385
3386         err = __dev_set_promiscuity(dev, inc);
3387         if (err < 0)
3388                 return err;
3389         if (dev->flags != old_flags)
3390                 dev_set_rx_mode(dev);
3391         return err;
3392 }
3393
3394 /**
3395  *      dev_set_allmulti        - update allmulti count on a device
3396  *      @dev: device
3397  *      @inc: modifier
3398  *
3399  *      Add or remove reception of all multicast frames to a device. While the
3400  *      count in the device remains above zero the interface remains listening
3401  *      to all interfaces. Once it hits zero the device reverts back to normal
3402  *      filtering operation. A negative @inc value is used to drop the counter
3403  *      when releasing a resource needing all multicasts.
3404  *      Return 0 if successful or a negative errno code on error.
3405  */
3406
3407 int dev_set_allmulti(struct net_device *dev, int inc)
3408 {
3409         unsigned short old_flags = dev->flags;
3410
3411         ASSERT_RTNL();
3412
3413         dev->flags |= IFF_ALLMULTI;
3414         dev->allmulti += inc;
3415         if (dev->allmulti == 0) {
3416                 /*
3417                  * Avoid overflow.
3418                  * If inc causes overflow, untouch allmulti and return error.
3419                  */
3420                 if (inc < 0)
3421                         dev->flags &= ~IFF_ALLMULTI;
3422                 else {
3423                         dev->allmulti -= inc;
3424                         printk(KERN_WARNING "%s: allmulti touches roof, "
3425                                 "set allmulti failed, allmulti feature of "
3426                                 "device might be broken.\n", dev->name);
3427                         return -EOVERFLOW;
3428                 }
3429         }
3430         if (dev->flags ^ old_flags) {
3431                 dev_change_rx_flags(dev, IFF_ALLMULTI);
3432                 dev_set_rx_mode(dev);
3433         }
3434         return 0;
3435 }
3436
3437 /*
3438  *      Upload unicast and multicast address lists to device and
3439  *      configure RX filtering. When the device doesn't support unicast
3440  *      filtering it is put in promiscuous mode while unicast addresses
3441  *      are present.
3442  */
3443 void __dev_set_rx_mode(struct net_device *dev)
3444 {
3445         const struct net_device_ops *ops = dev->netdev_ops;
3446
3447         /* dev_open will call this function so the list will stay sane. */
3448         if (!(dev->flags&IFF_UP))
3449                 return;
3450
3451         if (!netif_device_present(dev))
3452                 return;
3453
3454         if (ops->ndo_set_rx_mode)
3455                 ops->ndo_set_rx_mode(dev);
3456         else {
3457                 /* Unicast addresses changes may only happen under the rtnl,
3458                  * therefore calling __dev_set_promiscuity here is safe.
3459                  */
3460                 if (dev->uc_count > 0 && !dev->uc_promisc) {
3461                         __dev_set_promiscuity(dev, 1);
3462                         dev->uc_promisc = 1;
3463                 } else if (dev->uc_count == 0 && dev->uc_promisc) {
3464                         __dev_set_promiscuity(dev, -1);
3465                         dev->uc_promisc = 0;
3466                 }
3467
3468                 if (ops->ndo_set_multicast_list)
3469                         ops->ndo_set_multicast_list(dev);
3470         }
3471 }
3472
3473 void dev_set_rx_mode(struct net_device *dev)
3474 {
3475         netif_addr_lock_bh(dev);
3476         __dev_set_rx_mode(dev);
3477         netif_addr_unlock_bh(dev);
3478 }
3479
3480 /* hw addresses list handling functions */
3481
3482 static int __hw_addr_add(struct list_head *list, int *delta,
3483                          unsigned char *addr, int addr_len,
3484                          unsigned char addr_type)
3485 {
3486         struct netdev_hw_addr *ha;
3487         int alloc_size;
3488
3489         if (addr_len > MAX_ADDR_LEN)
3490                 return -EINVAL;
3491
3492         list_for_each_entry(ha, list, list) {
3493                 if (!memcmp(ha->addr, addr, addr_len) &&
3494                     ha->type == addr_type) {
3495                         ha->refcount++;
3496                         return 0;
3497                 }
3498         }
3499
3500
3501         alloc_size = sizeof(*ha);
3502         if (alloc_size < L1_CACHE_BYTES)
3503                 alloc_size = L1_CACHE_BYTES;
3504         ha = kmalloc(alloc_size, GFP_ATOMIC);
3505         if (!ha)
3506                 return -ENOMEM;
3507         memcpy(ha->addr, addr, addr_len);
3508         ha->type = addr_type;
3509         ha->refcount = 1;
3510         ha->synced = false;
3511         list_add_tail_rcu(&ha->list, list);
3512         if (delta)
3513                 (*delta)++;
3514         return 0;
3515 }
3516
3517 static void ha_rcu_free(struct rcu_head *head)
3518 {
3519         struct netdev_hw_addr *ha;
3520
3521         ha = container_of(head, struct netdev_hw_addr, rcu_head);
3522         kfree(ha);
3523 }
3524
3525 static int __hw_addr_del(struct list_head *list, int *delta,
3526                          unsigned char *addr, int addr_len,
3527                          unsigned char addr_type)
3528 {
3529         struct netdev_hw_addr *ha;
3530
3531         list_for_each_entry(ha, list, list) {
3532                 if (!memcmp(ha->addr, addr, addr_len) &&
3533                     (ha->type == addr_type || !addr_type)) {
3534                         if (--ha->refcount)
3535                                 return 0;
3536                         list_del_rcu(&ha->list);
3537                         call_rcu(&ha->rcu_head, ha_rcu_free);
3538                         if (delta)
3539                                 (*delta)--;
3540                         return 0;
3541                 }
3542         }
3543         return -ENOENT;
3544 }
3545
3546 static int __hw_addr_add_multiple(struct list_head *to_list, int *to_delta,
3547                                   struct list_head *from_list, int addr_len,
3548                                   unsigned char addr_type)
3549 {
3550         int err;
3551         struct netdev_hw_addr *ha, *ha2;
3552         unsigned char type;
3553
3554         list_for_each_entry(ha, from_list, list) {
3555                 type = addr_type ? addr_type : ha->type;
3556                 err = __hw_addr_add(to_list, to_delta, ha->addr,
3557                                     addr_len, type);
3558                 if (err)
3559                         goto unroll;
3560         }
3561         return 0;
3562
3563 unroll:
3564         list_for_each_entry(ha2, from_list, list) {
3565                 if (ha2 == ha)
3566                         break;
3567                 type = addr_type ? addr_type : ha2->type;
3568                 __hw_addr_del(to_list, to_delta, ha2->addr,
3569                               addr_len, type);
3570         }
3571         return err;
3572 }
3573
3574 static void __hw_addr_del_multiple(struct list_head *to_list, int *to_delta,
3575                                    struct list_head *from_list, int addr_len,
3576                                    unsigned char addr_type)
3577 {
3578         struct netdev_hw_addr *ha;
3579         unsigned char type;
3580
3581         list_for_each_entry(ha, from_list, list) {
3582                 type = addr_type ? addr_type : ha->type;
3583                 __hw_addr_del(to_list, to_delta, ha->addr,
3584                               addr_len, addr_type);
3585         }
3586 }
3587
3588 static int __hw_addr_sync(struct list_head *to_list, int *to_delta,
3589                           struct list_head *from_list, int *from_delta,
3590                           int addr_len)
3591 {
3592         int err = 0;
3593         struct netdev_hw_addr *ha, *tmp;
3594
3595         list_for_each_entry_safe(ha, tmp, from_list, list) {
3596                 if (!ha->synced) {
3597                         err = __hw_addr_add(to_list, to_delta, ha->addr,
3598                                             addr_len, ha->type);
3599                         if (err)
3600                                 break;
3601                         ha->synced = true;
3602                         ha->refcount++;
3603                 } else if (ha->refcount == 1) {
3604                         __hw_addr_del(to_list, to_delta, ha->addr,
3605                                       addr_len, ha->type);
3606                         __hw_addr_del(from_list, from_delta, ha->addr,
3607                                       addr_len, ha->type);
3608                 }
3609         }
3610         return err;
3611 }
3612
3613 static void __hw_addr_unsync(struct list_head *to_list, int *to_delta,
3614                              struct list_head *from_list, int *from_delta,
3615                              int addr_len)
3616 {
3617         struct netdev_hw_addr *ha, *tmp;
3618
3619         list_for_each_entry_safe(ha, tmp, from_list, list) {
3620                 if (ha->synced) {
3621                         __hw_addr_del(to_list, to_delta, ha->addr,
3622                                       addr_len, ha->type);
3623                         ha->synced = false;
3624                         __hw_addr_del(from_list, from_delta, ha->addr,
3625                                       addr_len, ha->type);
3626                 }
3627         }
3628 }
3629
3630
3631 static void __hw_addr_flush(struct list_head *list)
3632 {
3633         struct netdev_hw_addr *ha, *tmp;
3634
3635         list_for_each_entry_safe(ha, tmp, list, list) {
3636                 list_del_rcu(&ha->list);
3637                 call_rcu(&ha->rcu_head, ha_rcu_free);
3638         }
3639 }
3640
3641 /* Device addresses handling functions */
3642
3643 static void dev_addr_flush(struct net_device *dev)
3644 {
3645         /* rtnl_mutex must be held here */
3646
3647         __hw_addr_flush(&dev->dev_addr_list);
3648         dev->dev_addr = NULL;
3649 }
3650
3651 static int dev_addr_init(struct net_device *dev)
3652 {
3653         unsigned char addr[MAX_ADDR_LEN];
3654         struct netdev_hw_addr *ha;
3655         int err;
3656
3657         /* rtnl_mutex must be held here */
3658
3659         INIT_LIST_HEAD(&dev->dev_addr_list);
3660         memset(addr, 0, sizeof(addr));
3661         err = __hw_addr_add(&dev->dev_addr_list, NULL, addr, sizeof(addr),
3662                             NETDEV_HW_ADDR_T_LAN);
3663         if (!err) {
3664                 /*
3665                  * Get the first (previously created) address from the list
3666                  * and set dev_addr pointer to this location.
3667                  */
3668                 ha = list_first_entry(&dev->dev_addr_list,
3669                                       struct netdev_hw_addr, list);
3670                 dev->dev_addr = ha->addr;
3671         }
3672         return err;
3673 }
3674
3675 /**
3676  *      dev_addr_add    - Add a device address
3677  *      @dev: device
3678  *      @addr: address to add
3679  *      @addr_type: address type
3680  *
3681  *      Add a device address to the device or increase the reference count if
3682  *      it already exists.
3683  *
3684  *      The caller must hold the rtnl_mutex.
3685  */
3686 int dev_addr_add(struct net_device *dev, unsigned char *addr,
3687                  unsigned char addr_type)
3688 {
3689         int err;
3690
3691         ASSERT_RTNL();
3692
3693         err = __hw_addr_add(&dev->dev_addr_list, NULL, addr, dev->addr_len,
3694                             addr_type);
3695         if (!err)
3696                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3697         return err;
3698 }
3699 EXPORT_SYMBOL(dev_addr_add);
3700
3701 /**
3702  *      dev_addr_del    - Release a device address.
3703  *      @dev: device
3704  *      @addr: address to delete
3705  *      @addr_type: address type
3706  *
3707  *      Release reference to a device address and remove it from the device
3708  *      if the reference count drops to zero.
3709  *
3710  *      The caller must hold the rtnl_mutex.
3711  */
3712 int dev_addr_del(struct net_device *dev, unsigned char *addr,
3713                  unsigned char addr_type)
3714 {
3715         int err;
3716         struct netdev_hw_addr *ha;
3717
3718         ASSERT_RTNL();
3719
3720         /*
3721          * We can not remove the first address from the list because
3722          * dev->dev_addr points to that.
3723          */
3724         ha = list_first_entry(&dev->dev_addr_list, struct netdev_hw_addr, list);
3725         if (ha->addr == dev->dev_addr && ha->refcount == 1)
3726                 return -ENOENT;
3727
3728         err = __hw_addr_del(&dev->dev_addr_list, NULL, addr, dev->addr_len,
3729                             addr_type);
3730         if (!err)
3731                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3732         return err;
3733 }
3734 EXPORT_SYMBOL(dev_addr_del);
3735
3736 /**
3737  *      dev_addr_add_multiple   - Add device addresses from another device
3738  *      @to_dev: device to which addresses will be added
3739  *      @from_dev: device from which addresses will be added
3740  *      @addr_type: address type - 0 means type will be used from from_dev
3741  *
3742  *      Add device addresses of the one device to another.
3743  **
3744  *      The caller must hold the rtnl_mutex.
3745  */
3746 int dev_addr_add_multiple(struct net_device *to_dev,
3747                           struct net_device *from_dev,
3748                           unsigned char addr_type)
3749 {
3750         int err;
3751
3752         ASSERT_RTNL();
3753
3754         if (from_dev->addr_len != to_dev->addr_len)
3755                 return -EINVAL;
3756         err = __hw_addr_add_multiple(&to_dev->dev_addr_list, NULL,
3757                                      &from_dev->dev_addr_list,
3758                                      to_dev->addr_len, addr_type);
3759         if (!err)
3760                 call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
3761         return err;
3762 }
3763 EXPORT_SYMBOL(dev_addr_add_multiple);
3764
3765 /**
3766  *      dev_addr_del_multiple   - Delete device addresses by another device
3767  *      @to_dev: device where the addresses will be deleted
3768  *      @from_dev: device by which addresses the addresses will be deleted
3769  *      @addr_type: address type - 0 means type will used from from_dev
3770  *
3771  *      Deletes addresses in to device by the list of addresses in from device.
3772  *
3773  *      The caller must hold the rtnl_mutex.
3774  */
3775 int dev_addr_del_multiple(struct net_device *to_dev,
3776                           struct net_device *from_dev,
3777                           unsigned char addr_type)
3778 {
3779         ASSERT_RTNL();
3780
3781         if (from_dev->addr_len != to_dev->addr_len)
3782                 return -EINVAL;
3783         __hw_addr_del_multiple(&to_dev->dev_addr_list, NULL,
3784                                &from_dev->dev_addr_list,
3785                                to_dev->addr_len, addr_type);
3786         call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
3787         return 0;
3788 }
3789 EXPORT_SYMBOL(dev_addr_del_multiple);
3790
3791 /* unicast and multicast addresses handling functions */
3792
3793 int __dev_addr_delete(struct dev_addr_list **list, int *count,
3794                       void *addr, int alen, int glbl)
3795 {
3796         struct dev_addr_list *da;
3797
3798         for (; (da = *list) != NULL; list = &da->next) {
3799                 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3800                     alen == da->da_addrlen) {
3801                         if (glbl) {
3802                                 int old_glbl = da->da_gusers;
3803                                 da->da_gusers = 0;
3804                                 if (old_glbl == 0)
3805                                         break;
3806                         }
3807                         if (--da->da_users)
3808                                 return 0;
3809
3810                         *list = da->next;
3811                         kfree(da);
3812                         (*count)--;
3813                         return 0;
3814                 }
3815         }
3816         return -ENOENT;
3817 }
3818
3819 int __dev_addr_add(struct dev_addr_list **list, int *count,
3820                    void *addr, int alen, int glbl)
3821 {
3822         struct dev_addr_list *da;
3823
3824         for (da = *list; da != NULL; da = da->next) {
3825                 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3826                     da->da_addrlen == alen) {
3827                         if (glbl) {
3828                                 int old_glbl = da->da_gusers;
3829                                 da->da_gusers = 1;
3830                                 if (old_glbl)
3831                                         return 0;
3832                         }
3833                         da->da_users++;
3834                         return 0;
3835                 }
3836         }
3837
3838         da = kzalloc(sizeof(*da), GFP_ATOMIC);
3839         if (da == NULL)
3840                 return -ENOMEM;
3841         memcpy(da->da_addr, addr, alen);
3842         da->da_addrlen = alen;
3843         da->da_users = 1;
3844         da->da_gusers = glbl ? 1 : 0;
3845         da->next = *list;
3846         *list = da;
3847         (*count)++;
3848         return 0;
3849 }
3850
3851 /**
3852  *      dev_unicast_delete      - Release secondary unicast address.
3853  *      @dev: device
3854  *      @addr: address to delete
3855  *
3856  *      Release reference to a secondary unicast address and remove it
3857  *      from the device if the reference count drops to zero.
3858  *
3859  *      The caller must hold the rtnl_mutex.
3860  */
3861 int dev_unicast_delete(struct net_device *dev, void *addr)
3862 {
3863         int err;
3864
3865         ASSERT_RTNL();
3866
3867         err = __hw_addr_del(&dev->uc_list, &dev->uc_count, addr,
3868                             dev->addr_len, NETDEV_HW_ADDR_T_UNICAST);
3869         if (!err)
3870                 __dev_set_rx_mode(dev);
3871         return err;
3872 }
3873 EXPORT_SYMBOL(dev_unicast_delete);
3874
3875 /**
3876  *      dev_unicast_add         - add a secondary unicast address
3877  *      @dev: device
3878  *      @addr: address to add
3879  *
3880  *      Add a secondary unicast address to the device or increase
3881  *      the reference count if it already exists.
3882  *
3883  *      The caller must hold the rtnl_mutex.
3884  */
3885 int dev_unicast_add(struct net_device *dev, void *addr)
3886 {
3887         int err;
3888
3889         ASSERT_RTNL();
3890
3891         err = __hw_addr_add(&dev->uc_list, &dev->uc_count, addr,
3892                             dev->addr_len, NETDEV_HW_ADDR_T_UNICAST);
3893         if (!err)
3894                 __dev_set_rx_mode(dev);
3895         return err;
3896 }
3897 EXPORT_SYMBOL(dev_unicast_add);
3898
3899 int __dev_addr_sync(struct dev_addr_list **to, int *to_count,
3900                     struct dev_addr_list **from, int *from_count)
3901 {
3902         struct dev_addr_list *da, *next;
3903         int err = 0;
3904
3905         da = *from;
3906         while (da != NULL) {
3907                 next = da->next;
3908                 if (!da->da_synced) {
3909                         err = __dev_addr_add(to, to_count,
3910                                              da->da_addr, da->da_addrlen, 0);
3911                         if (err < 0)
3912                                 break;
3913                         da->da_synced = 1;
3914                         da->da_users++;
3915                 } else if (da->da_users == 1) {
3916                         __dev_addr_delete(to, to_count,
3917                                           da->da_addr, da->da_addrlen, 0);
3918                         __dev_addr_delete(from, from_count,
3919                                           da->da_addr, da->da_addrlen, 0);
3920                 }
3921                 da = next;
3922         }
3923         return err;
3924 }
3925
3926 void __dev_addr_unsync(struct dev_addr_list **to, int *to_count,
3927                        struct dev_addr_list **from, int *from_count)
3928 {
3929         struct dev_addr_list *da, *next;
3930
3931         da = *from;
3932         while (da != NULL) {
3933                 next = da->next;
3934                 if (da->da_synced) {
3935                         __dev_addr_delete(to, to_count,
3936                                           da->da_addr, da->da_addrlen, 0);
3937                         da->da_synced = 0;
3938                         __dev_addr_delete(from, from_count,
3939                                           da->da_addr, da->da_addrlen, 0);
3940                 }
3941                 da = next;
3942         }
3943 }
3944
3945 /**
3946  *      dev_unicast_sync - Synchronize device's unicast list to another device
3947  *      @to: destination device
3948  *      @from: source device
3949  *
3950  *      Add newly added addresses to the destination device and release
3951  *      addresses that have no users left.
3952  *
3953  *      This function is intended to be called from the dev->set_rx_mode
3954  *      function of layered software devices.
3955  */
3956 int dev_unicast_sync(struct net_device *to, struct net_device *from)
3957 {
3958         int err = 0;
3959
3960         ASSERT_RTNL();
3961
3962         if (to->addr_len != from->addr_len)
3963                 return -EINVAL;
3964
3965         err = __hw_addr_sync(&to->uc_list, &to->uc_count,
3966                              &from->uc_list, &from->uc_count, to->addr_len);
3967         if (!err)
3968                 __dev_set_rx_mode(to);
3969         return err;
3970 }
3971 EXPORT_SYMBOL(dev_unicast_sync);
3972
3973 /**
3974  *      dev_unicast_unsync - Remove synchronized addresses from the destination device
3975  *      @to: destination device
3976  *      @from: source device
3977  *
3978  *      Remove all addresses that were added to the destination device by
3979  *      dev_unicast_sync(). This function is intended to be called from the
3980  *      dev->stop function of layered software devices.
3981  */
3982 void dev_unicast_unsync(struct net_device *to, struct net_device *from)
3983 {
3984         ASSERT_RTNL();
3985
3986         if (to->addr_len != from->addr_len)
3987                 return;
3988
3989         __hw_addr_unsync(&to->uc_list, &to->uc_count,
3990                          &from->uc_list, &from->uc_count, to->addr_len);
3991         __dev_set_rx_mode(to);
3992 }
3993 EXPORT_SYMBOL(dev_unicast_unsync);
3994
3995 static void dev_unicast_flush(struct net_device *dev)
3996 {
3997         /* rtnl_mutex must be held here */
3998
3999         __hw_addr_flush(&dev->uc_list);
4000         dev->uc_count = 0;
4001 }
4002
4003 static void dev_unicast_init(struct net_device *dev)
4004 {
4005         /* rtnl_mutex must be held here */
4006
4007         INIT_LIST_HEAD(&dev->uc_list);
4008 }
4009
4010
4011 static void __dev_addr_discard(struct dev_addr_list **list)
4012 {
4013         struct dev_addr_list *tmp;
4014
4015         while (*list != NULL) {
4016                 tmp = *list;
4017                 *list = tmp->next;
4018                 if (tmp->da_users > tmp->da_gusers)
4019                         printk("__dev_addr_discard: address leakage! "
4020                                "da_users=%d\n", tmp->da_users);
4021                 kfree(tmp);
4022         }
4023 }
4024
4025 static void dev_addr_discard(struct net_device *dev)
4026 {
4027         netif_addr_lock_bh(dev);
4028
4029         __dev_addr_discard(&dev->mc_list);
4030         dev->mc_count = 0;
4031
4032         netif_addr_unlock_bh(dev);
4033 }
4034
4035 /**
4036  *      dev_get_flags - get flags reported to userspace
4037  *      @dev: device
4038  *
4039  *      Get the combination of flag bits exported through APIs to userspace.
4040  */
4041 unsigned dev_get_flags(const struct net_device *dev)
4042 {
4043         unsigned flags;
4044
4045         flags = (dev->flags & ~(IFF_PROMISC |
4046                                 IFF_ALLMULTI |
4047                                 IFF_RUNNING |
4048                                 IFF_LOWER_UP |
4049                                 IFF_DORMANT)) |
4050                 (dev->gflags & (IFF_PROMISC |
4051                                 IFF_ALLMULTI));
4052
4053         if (netif_running(dev)) {
4054                 if (netif_oper_up(dev))
4055                         flags |= IFF_RUNNING;
4056                 if (netif_carrier_ok(dev))
4057                         flags |= IFF_LOWER_UP;
4058                 if (netif_dormant(dev))
4059                         flags |= IFF_DORMANT;
4060         }
4061
4062         return flags;
4063 }
4064
4065 /**
4066  *      dev_change_flags - change device settings
4067  *      @dev: device
4068  *      @flags: device state flags
4069  *
4070  *      Change settings on device based state flags. The flags are
4071  *      in the userspace exported format.
4072  */
4073 int dev_change_flags(struct net_device *dev, unsigned flags)
4074 {
4075         int ret, changes;
4076         int old_flags = dev->flags;
4077
4078         ASSERT_RTNL();
4079
4080         /*
4081          *      Set the flags on our device.
4082          */
4083
4084         dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
4085                                IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
4086                                IFF_AUTOMEDIA)) |
4087                      (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
4088                                     IFF_ALLMULTI));
4089
4090         /*
4091          *      Load in the correct multicast list now the flags have changed.
4092          */
4093
4094         if ((old_flags ^ flags) & IFF_MULTICAST)
4095                 dev_change_rx_flags(dev, IFF_MULTICAST);
4096
4097         dev_set_rx_mode(dev);
4098
4099         /*
4100          *      Have we downed the interface. We handle IFF_UP ourselves
4101          *      according to user attempts to set it, rather than blindly
4102          *      setting it.
4103          */
4104
4105         ret = 0;
4106         if ((old_flags ^ flags) & IFF_UP) {     /* Bit is different  ? */
4107                 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
4108
4109                 if (!ret)
4110                         dev_set_rx_mode(dev);
4111         }
4112
4113         if (dev->flags & IFF_UP &&
4114             ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
4115                                           IFF_VOLATILE)))
4116                 call_netdevice_notifiers(NETDEV_CHANGE, dev);
4117
4118         if ((flags ^ dev->gflags) & IFF_PROMISC) {
4119                 int inc = (flags & IFF_PROMISC) ? +1 : -1;
4120                 dev->gflags ^= IFF_PROMISC;
4121                 dev_set_promiscuity(dev, inc);
4122         }
4123
4124         /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
4125            is important. Some (broken) drivers set IFF_PROMISC, when
4126            IFF_ALLMULTI is requested not asking us and not reporting.
4127          */
4128         if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
4129                 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
4130                 dev->gflags ^= IFF_ALLMULTI;
4131                 dev_set_allmulti(dev, inc);
4132         }
4133
4134         /* Exclude state transition flags, already notified */
4135         changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
4136         if (changes)
4137                 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
4138
4139         return ret;
4140 }
4141
4142 /**
4143  *      dev_set_mtu - Change maximum transfer unit
4144  *      @dev: device
4145  *      @new_mtu: new transfer unit
4146  *
4147  *      Change the maximum transfer size of the network device.
4148  */
4149 int dev_set_mtu(struct net_device *dev, int new_mtu)
4150 {
4151         const struct net_device_ops *ops = dev->netdev_ops;
4152         int err;
4153
4154         if (new_mtu == dev->mtu)
4155                 return 0;
4156
4157         /*      MTU must be positive.    */
4158         if (new_mtu < 0)
4159                 return -EINVAL;
4160
4161         if (!netif_device_present(dev))
4162                 return -ENODEV;
4163
4164         err = 0;
4165         if (ops->ndo_change_mtu)
4166                 err = ops->ndo_change_mtu(dev, new_mtu);
4167         else
4168                 dev->mtu = new_mtu;
4169
4170         if (!err && dev->flags & IFF_UP)
4171                 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
4172         return err;
4173 }
4174
4175 /**
4176  *      dev_set_mac_address - Change Media Access Control Address
4177  *      @dev: device
4178  *      @sa: new address
4179  *
4180  *      Change the hardware (MAC) address of the device
4181  */
4182 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
4183 {
4184         const struct net_device_ops *ops = dev->netdev_ops;
4185         int err;
4186
4187         if (!ops->ndo_set_mac_address)
4188                 return -EOPNOTSUPP;
4189         if (sa->sa_family != dev->type)
4190                 return -EINVAL;
4191         if (!netif_device_present(dev))
4192                 return -ENODEV;
4193         err = ops->ndo_set_mac_address(dev, sa);
4194         if (!err)
4195                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
4196         return err;
4197 }
4198
4199 /*
4200  *      Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
4201  */
4202 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
4203 {
4204         int err;
4205         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
4206
4207         if (!dev)
4208                 return -ENODEV;
4209
4210         switch (cmd) {
4211                 case SIOCGIFFLAGS:      /* Get interface flags */
4212                         ifr->ifr_flags = dev_get_flags(dev);
4213                         return 0;
4214
4215                 case SIOCGIFMETRIC:     /* Get the metric on the interface
4216                                            (currently unused) */
4217                         ifr->ifr_metric = 0;
4218                         return 0;
4219
4220                 case SIOCGIFMTU:        /* Get the MTU of a device */
4221                         ifr->ifr_mtu = dev->mtu;
4222                         return 0;
4223
4224                 case SIOCGIFHWADDR:
4225                         if (!dev->addr_len)
4226                                 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
4227                         else
4228                                 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
4229                                        min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
4230                         ifr->ifr_hwaddr.sa_family = dev->type;
4231                         return 0;
4232
4233                 case SIOCGIFSLAVE:
4234                         err = -EINVAL;
4235                         break;
4236
4237                 case SIOCGIFMAP:
4238                         ifr->ifr_map.mem_start = dev->mem_start;
4239                         ifr->ifr_map.mem_end   = dev->mem_end;
4240                         ifr->ifr_map.base_addr = dev->base_addr;
4241                         ifr->ifr_map.irq       = dev->irq;
4242                         ifr->ifr_map.dma       = dev->dma;
4243                         ifr->ifr_map.port      = dev->if_port;
4244                         return 0;
4245
4246                 case SIOCGIFINDEX:
4247                         ifr->ifr_ifindex = dev->ifindex;
4248                         return 0;
4249
4250                 case SIOCGIFTXQLEN:
4251                         ifr->ifr_qlen = dev->tx_queue_len;
4252                         return 0;
4253
4254                 default:
4255                         /* dev_ioctl() should ensure this case
4256                          * is never reached
4257                          */
4258                         WARN_ON(1);
4259                         err = -EINVAL;
4260                         break;
4261
4262         }
4263         return err;
4264 }
4265
4266 /*
4267  *      Perform the SIOCxIFxxx calls, inside rtnl_lock()
4268  */
4269 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
4270 {
4271         int err;
4272         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
4273         const struct net_device_ops *ops;
4274
4275         if (!dev)
4276                 return -ENODEV;
4277
4278         ops = dev->netdev_ops;
4279
4280         switch (cmd) {
4281                 case SIOCSIFFLAGS:      /* Set interface flags */
4282                         return dev_change_flags(dev, ifr->ifr_flags);
4283
4284                 case SIOCSIFMETRIC:     /* Set the metric on the interface
4285                                            (currently unused) */
4286                         return -EOPNOTSUPP;
4287
4288                 case SIOCSIFMTU:        /* Set the MTU of a device */
4289                         return dev_set_mtu(dev, ifr->ifr_mtu);
4290
4291                 case SIOCSIFHWADDR:
4292                         return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
4293
4294                 case SIOCSIFHWBROADCAST:
4295                         if (ifr->ifr_hwaddr.sa_family != dev->type)
4296                                 return -EINVAL;
4297                         memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
4298                                min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
4299                         call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
4300                         return 0;
4301
4302                 case SIOCSIFMAP:
4303                         if (ops->ndo_set_config) {
4304                                 if (!netif_device_present(dev))
4305                                         return -ENODEV;
4306                                 return ops->ndo_set_config(dev, &ifr->ifr_map);
4307                         }
4308                         return -EOPNOTSUPP;
4309
4310                 case SIOCADDMULTI:
4311                         if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
4312                             ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
4313                                 return -EINVAL;
4314                         if (!netif_device_present(dev))
4315                                 return -ENODEV;
4316                         return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
4317                                           dev->addr_len, 1);
4318
4319                 case SIOCDELMULTI:
4320                         if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
4321                             ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
4322                                 return -EINVAL;
4323                         if (!netif_device_present(dev))
4324                                 return -ENODEV;
4325                         return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
4326                                              dev->addr_len, 1);
4327
4328                 case SIOCSIFTXQLEN:
4329                         if (ifr->ifr_qlen < 0)
4330                                 return -EINVAL;
4331                         dev->tx_queue_len = ifr->ifr_qlen;
4332                         return 0;
4333
4334                 case SIOCSIFNAME:
4335                         ifr->ifr_newname[IFNAMSIZ-1] = '\0';
4336                         return dev_change_name(dev, ifr->ifr_newname);
4337
4338                 /*
4339                  *      Unknown or private ioctl
4340                  */
4341
4342                 default:
4343                         if ((cmd >= SIOCDEVPRIVATE &&
4344                             cmd <= SIOCDEVPRIVATE + 15) ||
4345                             cmd == SIOCBONDENSLAVE ||
4346                             cmd == SIOCBONDRELEASE ||
4347                             cmd == SIOCBONDSETHWADDR ||
4348                             cmd == SIOCBONDSLAVEINFOQUERY ||
4349                             cmd == SIOCBONDINFOQUERY ||
4350                             cmd == SIOCBONDCHANGEACTIVE ||
4351                             cmd == SIOCGMIIPHY ||
4352                             cmd == SIOCGMIIREG ||
4353                             cmd == SIOCSMIIREG ||
4354                             cmd == SIOCBRADDIF ||
4355                             cmd == SIOCBRDELIF ||
4356                             cmd == SIOCSHWTSTAMP ||
4357                             cmd == SIOCWANDEV) {
4358                                 err = -EOPNOTSUPP;
4359                                 if (ops->ndo_do_ioctl) {
4360                                         if (netif_device_present(dev))
4361                                                 err = ops->ndo_do_ioctl(dev, ifr, cmd);
4362                                         else
4363                                                 err = -ENODEV;
4364                                 }
4365                         } else
4366                                 err = -EINVAL;
4367
4368         }
4369         return err;
4370 }
4371
4372 /*
4373  *      This function handles all "interface"-type I/O control requests. The actual
4374  *      'doing' part of this is dev_ifsioc above.
4375  */
4376
4377 /**
4378  *      dev_ioctl       -       network device ioctl
4379  *      @net: the applicable net namespace
4380  *      @cmd: command to issue
4381  *      @arg: pointer to a struct ifreq in user space
4382  *
4383  *      Issue ioctl functions to devices. This is normally called by the
4384  *      user space syscall interfaces but can sometimes be useful for
4385  *      other purposes. The return value is the return from the syscall if
4386  *      positive or a negative errno code on error.
4387  */
4388
4389 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
4390 {
4391         struct ifreq ifr;
4392         int ret;
4393         char *colon;
4394
4395         /* One special case: SIOCGIFCONF takes ifconf argument
4396            and requires shared lock, because it sleeps writing
4397            to user space.
4398          */
4399
4400         if (cmd == SIOCGIFCONF) {
4401                 rtnl_lock();
4402                 ret = dev_ifconf(net, (char __user *) arg);
4403                 rtnl_unlock();
4404                 return ret;
4405         }
4406         if (cmd == SIOCGIFNAME)
4407                 return dev_ifname(net, (struct ifreq __user *)arg);
4408
4409         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
4410                 return -EFAULT;
4411
4412         ifr.ifr_name[IFNAMSIZ-1] = 0;
4413
4414         colon = strchr(ifr.ifr_name, ':');
4415         if (colon)
4416                 *colon = 0;
4417
4418         /*
4419          *      See which interface the caller is talking about.
4420          */
4421
4422         switch (cmd) {
4423                 /*
4424                  *      These ioctl calls:
4425                  *      - can be done by all.
4426                  *      - atomic and do not require locking.
4427                  *      - return a value
4428                  */
4429                 case SIOCGIFFLAGS:
4430                 case SIOCGIFMETRIC:
4431                 case SIOCGIFMTU:
4432                 case SIOCGIFHWADDR:
4433                 case SIOCGIFSLAVE:
4434                 case SIOCGIFMAP:
4435                 case SIOCGIFINDEX:
4436                 case SIOCGIFTXQLEN:
4437                         dev_load(net, ifr.ifr_name);
4438                         read_lock(&dev_base_lock);
4439                         ret = dev_ifsioc_locked(net, &ifr, cmd);
4440                         read_unlock(&dev_base_lock);
4441                         if (!ret) {
4442                                 if (colon)
4443                                         *colon = ':';
4444                                 if (copy_to_user(arg, &ifr,
4445                                                  sizeof(struct ifreq)))
4446                                         ret = -EFAULT;
4447                         }
4448                         return ret;
4449
4450                 case SIOCETHTOOL:
4451                         dev_load(net, ifr.ifr_name);
4452                         rtnl_lock();
4453                         ret = dev_ethtool(net, &ifr);
4454                         rtnl_unlock();
4455                         if (!ret) {
4456                                 if (colon)
4457                                         *colon = ':';
4458                                 if (copy_to_user(arg, &ifr,
4459                                                  sizeof(struct ifreq)))
4460                                         ret = -EFAULT;
4461                         }
4462                         return ret;
4463
4464                 /*
4465                  *      These ioctl calls:
4466                  *      - require superuser power.
4467                  *      - require strict serialization.
4468                  *      - return a value
4469                  */
4470                 case SIOCGMIIPHY:
4471                 case SIOCGMIIREG:
4472                 case SIOCSIFNAME:
4473                         if (!capable(CAP_NET_ADMIN))
4474                                 return -EPERM;
4475                         dev_load(net, ifr.ifr_name);
4476                         rtnl_lock();
4477                         ret = dev_ifsioc(net, &ifr, cmd);
4478                         rtnl_unlock();
4479                         if (!ret) {
4480                                 if (colon)
4481                                         *colon = ':';
4482                                 if (copy_to_user(arg, &ifr,
4483                                                  sizeof(struct ifreq)))
4484                                         ret = -EFAULT;
4485                         }
4486                         return ret;
4487
4488                 /*
4489                  *      These ioctl calls:
4490                  *      - require superuser power.
4491                  *      - require strict serialization.
4492                  *      - do not return a value
4493                  */
4494                 case SIOCSIFFLAGS:
4495                 case SIOCSIFMETRIC:
4496                 case SIOCSIFMTU:
4497                 case SIOCSIFMAP:
4498                 case SIOCSIFHWADDR:
4499                 case SIOCSIFSLAVE:
4500                 case SIOCADDMULTI:
4501                 case SIOCDELMULTI:
4502                 case SIOCSIFHWBROADCAST:
4503                 case SIOCSIFTXQLEN:
4504                 case SIOCSMIIREG:
4505                 case SIOCBONDENSLAVE:
4506                 case SIOCBONDRELEASE:
4507                 case SIOCBONDSETHWADDR:
4508                 case SIOCBONDCHANGEACTIVE:
4509                 case SIOCBRADDIF:
4510                 case SIOCBRDELIF:
4511                 case SIOCSHWTSTAMP:
4512                         if (!capable(CAP_NET_ADMIN))
4513                                 return -EPERM;
4514                         /* fall through */
4515                 case SIOCBONDSLAVEINFOQUERY:
4516                 case SIOCBONDINFOQUERY:
4517                         dev_load(net, ifr.ifr_name);
4518                         rtnl_lock();
4519                         ret = dev_ifsioc(net, &ifr, cmd);
4520                         rtnl_unlock();
4521                         return ret;
4522
4523                 case SIOCGIFMEM:
4524                         /* Get the per device memory space. We can add this but
4525                          * currently do not support it */
4526                 case SIOCSIFMEM:
4527                         /* Set the per device memory buffer space.
4528                          * Not applicable in our case */
4529                 case SIOCSIFLINK:
4530                         return -EINVAL;
4531
4532                 /*
4533                  *      Unknown or private ioctl.
4534                  */
4535                 default:
4536                         if (cmd == SIOCWANDEV ||
4537                             (cmd >= SIOCDEVPRIVATE &&
4538                              cmd <= SIOCDEVPRIVATE + 15)) {
4539                                 dev_load(net, ifr.ifr_name);
4540                                 rtnl_lock();
4541                                 ret = dev_ifsioc(net, &ifr, cmd);
4542                                 rtnl_unlock();
4543                                 if (!ret && copy_to_user(arg, &ifr,
4544                                                          sizeof(struct ifreq)))
4545                                         ret = -EFAULT;
4546                                 return ret;
4547                         }
4548                         /* Take care of Wireless Extensions */
4549                         if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
4550                                 return wext_handle_ioctl(net, &ifr, cmd, arg);
4551                         return -EINVAL;
4552         }
4553 }
4554
4555
4556 /**
4557  *      dev_new_index   -       allocate an ifindex
4558  *      @net: the applicable net namespace
4559  *
4560  *      Returns a suitable unique value for a new device interface
4561  *      number.  The caller must hold the rtnl semaphore or the
4562  *      dev_base_lock to be sure it remains unique.
4563  */
4564 static int dev_new_index(struct net *net)
4565 {
4566         static int ifindex;
4567         for (;;) {
4568                 if (++ifindex <= 0)
4569                         ifindex = 1;
4570                 if (!__dev_get_by_index(net, ifindex))
4571                         return ifindex;
4572         }
4573 }
4574
4575 /* Delayed registration/unregisteration */
4576 static LIST_HEAD(net_todo_list);
4577
4578 static void net_set_todo(struct net_device *dev)
4579 {
4580         list_add_tail(&dev->todo_list, &net_todo_list);
4581 }
4582
4583 static void rollback_registered(struct net_device *dev)
4584 {
4585         BUG_ON(dev_boot_phase);
4586         ASSERT_RTNL();
4587
4588         /* Some devices call without registering for initialization unwind. */
4589         if (dev->reg_state == NETREG_UNINITIALIZED) {
4590                 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
4591                                   "was registered\n", dev->name, dev);
4592
4593                 WARN_ON(1);
4594                 return;
4595         }
4596
4597         BUG_ON(dev->reg_state != NETREG_REGISTERED);
4598
4599         /* If device is running, close it first. */
4600         dev_close(dev);
4601
4602         /* And unlink it from device chain. */
4603         unlist_netdevice(dev);
4604
4605         dev->reg_state = NETREG_UNREGISTERING;
4606
4607         synchronize_net();
4608
4609         /* Shutdown queueing discipline. */
4610         dev_shutdown(dev);
4611
4612
4613         /* Notify protocols, that we are about to destroy
4614            this device. They should clean all the things.
4615         */
4616         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4617
4618         /*
4619          *      Flush the unicast and multicast chains
4620          */
4621         dev_unicast_flush(dev);
4622         dev_addr_discard(dev);
4623
4624         if (dev->netdev_ops->ndo_uninit)
4625                 dev->netdev_ops->ndo_uninit(dev);
4626
4627         /* Notifier chain MUST detach us from master device. */
4628         WARN_ON(dev->master);
4629
4630         /* Remove entries from kobject tree */
4631         netdev_unregister_kobject(dev);
4632
4633         synchronize_net();
4634
4635         dev_put(dev);
4636 }
4637
4638 static void __netdev_init_queue_locks_one(struct net_device *dev,
4639                                           struct netdev_queue *dev_queue,
4640                                           void *_unused)
4641 {
4642         spin_lock_init(&dev_queue->_xmit_lock);
4643         netdev_set_xmit_lockdep_class(&dev_queue->_xmit_lock, dev->type);
4644         dev_queue->xmit_lock_owner = -1;
4645 }
4646
4647 static void netdev_init_queue_locks(struct net_device *dev)
4648 {
4649         netdev_for_each_tx_queue(dev, __netdev_init_queue_locks_one, NULL);
4650         __netdev_init_queue_locks_one(dev, &dev->rx_queue, NULL);
4651 }
4652
4653 unsigned long netdev_fix_features(unsigned long features, const char *name)
4654 {
4655         /* Fix illegal SG+CSUM combinations. */
4656         if ((features & NETIF_F_SG) &&
4657             !(features & NETIF_F_ALL_CSUM)) {
4658                 if (name)
4659                         printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no "
4660                                "checksum feature.\n", name);
4661                 features &= ~NETIF_F_SG;
4662         }
4663
4664         /* TSO requires that SG is present as well. */
4665         if ((features & NETIF_F_TSO) && !(features & NETIF_F_SG)) {
4666                 if (name)
4667                         printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no "
4668                                "SG feature.\n", name);
4669                 features &= ~NETIF_F_TSO;
4670         }
4671
4672         if (features & NETIF_F_UFO) {
4673                 if (!(features & NETIF_F_GEN_CSUM)) {
4674                         if (name)
4675                                 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
4676                                        "since no NETIF_F_HW_CSUM feature.\n",
4677                                        name);
4678                         features &= ~NETIF_F_UFO;
4679                 }
4680
4681                 if (!(features & NETIF_F_SG)) {
4682                         if (name)
4683                                 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
4684                                        "since no NETIF_F_SG feature.\n", name);
4685                         features &= ~NETIF_F_UFO;
4686                 }
4687         }
4688
4689         return features;
4690 }
4691 EXPORT_SYMBOL(netdev_fix_features);
4692
4693 /**
4694  *      register_netdevice      - register a network device
4695  *      @dev: device to register
4696  *
4697  *      Take a completed network device structure and add it to the kernel
4698  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4699  *      chain. 0 is returned on success. A negative errno code is returned
4700  *      on a failure to set up the device, or if the name is a duplicate.
4701  *
4702  *      Callers must hold the rtnl semaphore. You may want
4703  *      register_netdev() instead of this.
4704  *
4705  *      BUGS:
4706  *      The locking appears insufficient to guarantee two parallel registers
4707  *      will not get the same name.
4708  */
4709
4710 int register_netdevice(struct net_device *dev)
4711 {
4712         struct hlist_head *head;
4713         struct hlist_node *p;
4714         int ret;
4715         struct net *net = dev_net(dev);
4716
4717         BUG_ON(dev_boot_phase);
4718         ASSERT_RTNL();
4719
4720         might_sleep();
4721
4722         /* When net_device's are persistent, this will be fatal. */
4723         BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
4724         BUG_ON(!net);
4725
4726         spin_lock_init(&dev->addr_list_lock);
4727         netdev_set_addr_lockdep_class(dev);
4728         netdev_init_queue_locks(dev);
4729
4730         dev->iflink = -1;
4731
4732         /* Init, if this function is available */
4733         if (dev->netdev_ops->ndo_init) {
4734                 ret = dev->netdev_ops->ndo_init(dev);
4735                 if (ret) {
4736                         if (ret > 0)
4737                                 ret = -EIO;
4738                         goto out;
4739                 }
4740         }
4741
4742         if (!dev_valid_name(dev->name)) {
4743                 ret = -EINVAL;
4744                 goto err_uninit;
4745         }
4746
4747         dev->ifindex = dev_new_index(net);
4748         if (dev->iflink == -1)
4749                 dev->iflink = dev->ifindex;
4750
4751         /* Check for existence of name */
4752         head = dev_name_hash(net, dev->name);
4753         hlist_for_each(p, head) {
4754                 struct net_device *d
4755                         = hlist_entry(p, struct net_device, name_hlist);
4756                 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
4757                         ret = -EEXIST;
4758                         goto err_uninit;
4759                 }
4760         }
4761
4762         /* Fix illegal checksum combinations */
4763         if ((dev->features & NETIF_F_HW_CSUM) &&
4764             (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
4765                 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
4766                        dev->name);
4767                 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4768         }
4769
4770         if ((dev->features & NETIF_F_NO_CSUM) &&
4771             (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
4772                 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
4773                        dev->name);
4774                 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
4775         }
4776
4777         dev->features = netdev_fix_features(dev->features, dev->name);
4778
4779         /* Enable software GSO if SG is supported. */
4780         if (dev->features & NETIF_F_SG)
4781                 dev->features |= NETIF_F_GSO;
4782
4783         netdev_initialize_kobject(dev);
4784         ret = netdev_register_kobject(dev);
4785         if (ret)
4786                 goto err_uninit;
4787         dev->reg_state = NETREG_REGISTERED;
4788
4789         /*
4790          *      Default initial state at registry is that the
4791          *      device is present.
4792          */
4793
4794         set_bit(__LINK_STATE_PRESENT, &dev->state);
4795
4796         dev_init_scheduler(dev);
4797         dev_hold(dev);
4798         list_netdevice(dev);
4799
4800         /* Notify protocols, that a new device appeared. */
4801         ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
4802         ret = notifier_to_errno(ret);
4803         if (ret) {
4804                 rollback_registered(dev);
4805                 dev->reg_state = NETREG_UNREGISTERED;
4806         }
4807
4808 out:
4809         return ret;
4810
4811 err_uninit:
4812         if (dev->netdev_ops->ndo_uninit)
4813                 dev->netdev_ops->ndo_uninit(dev);
4814         goto out;
4815 }
4816
4817 /**
4818  *      init_dummy_netdev       - init a dummy network device for NAPI
4819  *      @dev: device to init
4820  *
4821  *      This takes a network device structure and initialize the minimum
4822  *      amount of fields so it can be used to schedule NAPI polls without
4823  *      registering a full blown interface. This is to be used by drivers
4824  *      that need to tie several hardware interfaces to a single NAPI
4825  *      poll scheduler due to HW limitations.
4826  */
4827 int init_dummy_netdev(struct net_device *dev)
4828 {
4829         /* Clear everything. Note we don't initialize spinlocks
4830          * are they aren't supposed to be taken by any of the
4831          * NAPI code and this dummy netdev is supposed to be
4832          * only ever used for NAPI polls
4833          */
4834         memset(dev, 0, sizeof(struct net_device));
4835
4836         /* make sure we BUG if trying to hit standard
4837          * register/unregister code path
4838          */
4839         dev->reg_state = NETREG_DUMMY;
4840
4841         /* initialize the ref count */
4842         atomic_set(&dev->refcnt, 1);
4843
4844         /* NAPI wants this */
4845         INIT_LIST_HEAD(&dev->napi_list);
4846
4847         /* a dummy interface is started by default */
4848         set_bit(__LINK_STATE_PRESENT, &dev->state);
4849         set_bit(__LINK_STATE_START, &dev->state);
4850
4851         return 0;
4852 }
4853 EXPORT_SYMBOL_GPL(init_dummy_netdev);
4854
4855
4856 /**
4857  *      register_netdev - register a network device
4858  *      @dev: device to register
4859  *
4860  *      Take a completed network device structure and add it to the kernel
4861  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4862  *      chain. 0 is returned on success. A negative errno code is returned
4863  *      on a failure to set up the device, or if the name is a duplicate.
4864  *
4865  *      This is a wrapper around register_netdevice that takes the rtnl semaphore
4866  *      and expands the device name if you passed a format string to
4867  *      alloc_netdev.
4868  */
4869 int register_netdev(struct net_device *dev)
4870 {
4871         int err;
4872
4873         rtnl_lock();
4874
4875         /*
4876          * If the name is a format string the caller wants us to do a
4877          * name allocation.
4878          */
4879         if (strchr(dev->name, '%')) {
4880                 err = dev_alloc_name(dev, dev->name);
4881                 if (err < 0)
4882                         goto out;
4883         }
4884
4885         err = register_netdevice(dev);
4886 out:
4887         rtnl_unlock();
4888         return err;
4889 }
4890 EXPORT_SYMBOL(register_netdev);
4891
4892 /*
4893  * netdev_wait_allrefs - wait until all references are gone.
4894  *
4895  * This is called when unregistering network devices.
4896  *
4897  * Any protocol or device that holds a reference should register
4898  * for netdevice notification, and cleanup and put back the
4899  * reference if they receive an UNREGISTER event.
4900  * We can get stuck here if buggy protocols don't correctly
4901  * call dev_put.
4902  */
4903 static void netdev_wait_allrefs(struct net_device *dev)
4904 {
4905         unsigned long rebroadcast_time, warning_time;
4906
4907         rebroadcast_time = warning_time = jiffies;
4908         while (atomic_read(&dev->refcnt) != 0) {
4909                 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
4910                         rtnl_lock();
4911
4912                         /* Rebroadcast unregister notification */
4913                         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4914
4915                         if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
4916                                      &dev->state)) {
4917                                 /* We must not have linkwatch events
4918                                  * pending on unregister. If this
4919                                  * happens, we simply run the queue
4920                                  * unscheduled, resulting in a noop
4921                                  * for this device.
4922                                  */
4923                                 linkwatch_run_queue();
4924                         }
4925
4926                         __rtnl_unlock();
4927
4928                         rebroadcast_time = jiffies;
4929                 }
4930
4931                 msleep(250);
4932
4933                 if (time_after(jiffies, warning_time + 10 * HZ)) {
4934                         printk(KERN_EMERG "unregister_netdevice: "
4935                                "waiting for %s to become free. Usage "
4936                                "count = %d\n",
4937                                dev->name, atomic_read(&dev->refcnt));
4938                         warning_time = jiffies;
4939                 }
4940         }
4941 }
4942
4943 /* The sequence is:
4944  *
4945  *      rtnl_lock();
4946  *      ...
4947  *      register_netdevice(x1);
4948  *      register_netdevice(x2);
4949  *      ...
4950  *      unregister_netdevice(y1);
4951  *      unregister_netdevice(y2);
4952  *      ...
4953  *      rtnl_unlock();
4954  *      free_netdev(y1);
4955  *      free_netdev(y2);
4956  *
4957  * We are invoked by rtnl_unlock().
4958  * This allows us to deal with problems:
4959  * 1) We can delete sysfs objects which invoke hotplug
4960  *    without deadlocking with linkwatch via keventd.
4961  * 2) Since we run with the RTNL semaphore not held, we can sleep
4962  *    safely in order to wait for the netdev refcnt to drop to zero.
4963  *
4964  * We must not return until all unregister events added during
4965  * the interval the lock was held have been completed.
4966  */
4967 void netdev_run_todo(void)
4968 {
4969         struct list_head list;
4970
4971         /* Snapshot list, allow later requests */
4972         list_replace_init(&net_todo_list, &list);
4973
4974         __rtnl_unlock();
4975
4976         while (!list_empty(&list)) {
4977                 struct net_device *dev
4978                         = list_entry(list.next, struct net_device, todo_list);
4979                 list_del(&dev->todo_list);
4980
4981                 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
4982                         printk(KERN_ERR "network todo '%s' but state %d\n",
4983                                dev->name, dev->reg_state);
4984                         dump_stack();
4985                         continue;
4986                 }
4987
4988                 dev->reg_state = NETREG_UNREGISTERED;
4989
4990                 on_each_cpu(flush_backlog, dev, 1);
4991
4992                 netdev_wait_allrefs(dev);
4993
4994                 /* paranoia */
4995                 BUG_ON(atomic_read(&dev->refcnt));
4996                 WARN_ON(dev->ip_ptr);
4997                 WARN_ON(dev->ip6_ptr);
4998                 WARN_ON(dev->dn_ptr);
4999
5000                 if (dev->destructor)
5001                         dev->destructor(dev);
5002
5003                 /* Free network device */
5004                 kobject_put(&dev->dev.kobj);
5005         }
5006 }
5007
5008 /**
5009  *      dev_get_stats   - get network device statistics
5010  *      @dev: device to get statistics from
5011  *
5012  *      Get network statistics from device. The device driver may provide
5013  *      its own method by setting dev->netdev_ops->get_stats; otherwise
5014  *      the internal statistics structure is used.
5015  */
5016 const struct net_device_stats *dev_get_stats(struct net_device *dev)
5017 {
5018         const struct net_device_ops *ops = dev->netdev_ops;
5019
5020         if (ops->ndo_get_stats)
5021                 return ops->ndo_get_stats(dev);
5022         else {
5023                 unsigned long tx_bytes = 0, tx_packets = 0, tx_dropped = 0;
5024                 struct net_device_stats *stats = &dev->stats;
5025                 unsigned int i;
5026                 struct netdev_queue *txq;
5027
5028                 for (i = 0; i < dev->num_tx_queues; i++) {
5029                         txq = netdev_get_tx_queue(dev, i);
5030                         tx_bytes   += txq->tx_bytes;
5031                         tx_packets += txq->tx_packets;
5032                         tx_dropped += txq->tx_dropped;
5033                 }
5034                 if (tx_bytes || tx_packets || tx_dropped) {
5035                         stats->tx_bytes   = tx_bytes;
5036                         stats->tx_packets = tx_packets;
5037                         stats->tx_dropped = tx_dropped;
5038                 }
5039                 return stats;
5040         }
5041 }
5042 EXPORT_SYMBOL(dev_get_stats);
5043
5044 static void netdev_init_one_queue(struct net_device *dev,
5045                                   struct netdev_queue *queue,
5046                                   void *_unused)
5047 {
5048         queue->dev = dev;
5049 }
5050
5051 static void netdev_init_queues(struct net_device *dev)
5052 {
5053         netdev_init_one_queue(dev, &dev->rx_queue, NULL);
5054         netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
5055         spin_lock_init(&dev->tx_global_lock);
5056 }
5057
5058 /**
5059  *      alloc_netdev_mq - allocate network device
5060  *      @sizeof_priv:   size of private data to allocate space for
5061  *      @name:          device name format string
5062  *      @setup:         callback to initialize device
5063  *      @queue_count:   the number of subqueues to allocate
5064  *
5065  *      Allocates a struct net_device with private data area for driver use
5066  *      and performs basic initialization.  Also allocates subquue structs
5067  *      for each queue on the device at the end of the netdevice.
5068  */
5069 struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
5070                 void (*setup)(struct net_device *), unsigned int queue_count)
5071 {
5072         struct netdev_queue *tx;
5073         struct net_device *dev;
5074         size_t alloc_size;
5075         struct net_device *p;
5076
5077         BUG_ON(strlen(name) >= sizeof(dev->name));
5078
5079         alloc_size = sizeof(struct net_device);
5080         if (sizeof_priv) {
5081                 /* ensure 32-byte alignment of private area */
5082                 alloc_size = ALIGN(alloc_size, NETDEV_ALIGN);
5083                 alloc_size += sizeof_priv;
5084         }
5085         /* ensure 32-byte alignment of whole construct */
5086         alloc_size += NETDEV_ALIGN - 1;
5087
5088         p = kzalloc(alloc_size, GFP_KERNEL);
5089         if (!p) {
5090                 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
5091                 return NULL;
5092         }
5093
5094         tx = kcalloc(queue_count, sizeof(struct netdev_queue), GFP_KERNEL);
5095         if (!tx) {
5096                 printk(KERN_ERR "alloc_netdev: Unable to allocate "
5097                        "tx qdiscs.\n");
5098                 goto free_p;
5099         }
5100
5101         dev = PTR_ALIGN(p, NETDEV_ALIGN);
5102         dev->padded = (char *)dev - (char *)p;
5103
5104         if (dev_addr_init(dev))
5105                 goto free_tx;
5106
5107         dev_unicast_init(dev);
5108
5109         dev_net_set(dev, &init_net);
5110
5111         dev->_tx = tx;
5112         dev->num_tx_queues = queue_count;
5113         dev->real_num_tx_queues = queue_count;
5114
5115         dev->gso_max_size = GSO_MAX_SIZE;
5116
5117         netdev_init_queues(dev);
5118
5119         INIT_LIST_HEAD(&dev->napi_list);
5120         dev->priv_flags = IFF_XMIT_DST_RELEASE;
5121         setup(dev);
5122         strcpy(dev->name, name);
5123         return dev;
5124
5125 free_tx:
5126         kfree(tx);
5127
5128 free_p:
5129         kfree(p);
5130         return NULL;
5131 }
5132 EXPORT_SYMBOL(alloc_netdev_mq);
5133
5134 /**
5135  *      free_netdev - free network device
5136  *      @dev: device
5137  *
5138  *      This function does the last stage of destroying an allocated device
5139  *      interface. The reference to the device object is released.
5140  *      If this is the last reference then it will be freed.
5141  */
5142 void free_netdev(struct net_device *dev)
5143 {
5144         struct napi_struct *p, *n;
5145
5146         release_net(dev_net(dev));
5147
5148         kfree(dev->_tx);
5149
5150         /* Flush device addresses */
5151         dev_addr_flush(dev);
5152
5153         list_for_each_entry_safe(p, n, &dev->napi_list, dev_list)
5154                 netif_napi_del(p);
5155
5156         /*  Compatibility with error handling in drivers */
5157         if (dev->reg_state == NETREG_UNINITIALIZED) {
5158                 kfree((char *)dev - dev->padded);
5159                 return;
5160         }
5161
5162         BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
5163         dev->reg_state = NETREG_RELEASED;
5164
5165         /* will free via device release */
5166         put_device(&dev->dev);
5167 }
5168
5169 /**
5170  *      synchronize_net -  Synchronize with packet receive processing
5171  *
5172  *      Wait for packets currently being received to be done.
5173  *      Does not block later packets from starting.
5174  */
5175 void synchronize_net(void)
5176 {
5177         might_sleep();
5178         synchronize_rcu();
5179 }
5180
5181 /**
5182  *      unregister_netdevice - remove device from the kernel
5183  *      @dev: device
5184  *
5185  *      This function shuts down a device interface and removes it
5186  *      from the kernel tables.
5187  *
5188  *      Callers must hold the rtnl semaphore.  You may want
5189  *      unregister_netdev() instead of this.
5190  */
5191
5192 void unregister_netdevice(struct net_device *dev)
5193 {
5194         ASSERT_RTNL();
5195
5196         rollback_registered(dev);
5197         /* Finish processing unregister after unlock */
5198         net_set_todo(dev);
5199 }
5200
5201 /**
5202  *      unregister_netdev - remove device from the kernel
5203  *      @dev: device
5204  *
5205  *      This function shuts down a device interface and removes it
5206  *      from the kernel tables.
5207  *
5208  *      This is just a wrapper for unregister_netdevice that takes
5209  *      the rtnl semaphore.  In general you want to use this and not
5210  *      unregister_netdevice.
5211  */
5212 void unregister_netdev(struct net_device *dev)
5213 {
5214         rtnl_lock();
5215         unregister_netdevice(dev);
5216         rtnl_unlock();
5217 }
5218
5219 EXPORT_SYMBOL(unregister_netdev);
5220
5221 /**
5222  *      dev_change_net_namespace - move device to different nethost namespace
5223  *      @dev: device
5224  *      @net: network namespace
5225  *      @pat: If not NULL name pattern to try if the current device name
5226  *            is already taken in the destination network namespace.
5227  *
5228  *      This function shuts down a device interface and moves it
5229  *      to a new network namespace. On success 0 is returned, on
5230  *      a failure a netagive errno code is returned.
5231  *
5232  *      Callers must hold the rtnl semaphore.
5233  */
5234
5235 int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
5236 {
5237         char buf[IFNAMSIZ];
5238         const char *destname;
5239         int err;
5240
5241         ASSERT_RTNL();
5242
5243         /* Don't allow namespace local devices to be moved. */
5244         err = -EINVAL;
5245         if (dev->features & NETIF_F_NETNS_LOCAL)
5246                 goto out;
5247
5248 #ifdef CONFIG_SYSFS
5249         /* Don't allow real devices to be moved when sysfs
5250          * is enabled.
5251          */
5252         err = -EINVAL;
5253         if (dev->dev.parent)
5254                 goto out;
5255 #endif
5256
5257         /* Ensure the device has been registrered */
5258         err = -EINVAL;
5259         if (dev->reg_state != NETREG_REGISTERED)
5260                 goto out;
5261
5262         /* Get out if there is nothing todo */
5263         err = 0;
5264         if (net_eq(dev_net(dev), net))
5265                 goto out;
5266
5267         /* Pick the destination device name, and ensure
5268          * we can use it in the destination network namespace.
5269          */
5270         err = -EEXIST;
5271         destname = dev->name;
5272         if (__dev_get_by_name(net, destname)) {
5273                 /* We get here if we can't use the current device name */
5274                 if (!pat)
5275                         goto out;
5276                 if (!dev_valid_name(pat))
5277                         goto out;
5278                 if (strchr(pat, '%')) {
5279                         if (__dev_alloc_name(net, pat, buf) < 0)
5280                                 goto out;
5281                         destname = buf;
5282                 } else
5283                         destname = pat;
5284                 if (__dev_get_by_name(net, destname))
5285                         goto out;
5286         }
5287
5288         /*
5289          * And now a mini version of register_netdevice unregister_netdevice.
5290          */
5291
5292         /* If device is running close it first. */
5293         dev_close(dev);
5294
5295         /* And unlink it from device chain */
5296         err = -ENODEV;
5297         unlist_netdevice(dev);
5298
5299         synchronize_net();
5300
5301         /* Shutdown queueing discipline. */
5302         dev_shutdown(dev);
5303
5304         /* Notify protocols, that we are about to destroy
5305            this device. They should clean all the things.
5306         */
5307         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
5308
5309         /*
5310          *      Flush the unicast and multicast chains
5311          */
5312         dev_unicast_flush(dev);
5313         dev_addr_discard(dev);
5314
5315         netdev_unregister_kobject(dev);
5316
5317         /* Actually switch the network namespace */
5318         dev_net_set(dev, net);
5319
5320         /* Assign the new device name */
5321         if (destname != dev->name)
5322                 strcpy(dev->name, destname);
5323
5324         /* If there is an ifindex conflict assign a new one */
5325         if (__dev_get_by_index(net, dev->ifindex)) {
5326                 int iflink = (dev->iflink == dev->ifindex);
5327                 dev->ifindex = dev_new_index(net);
5328                 if (iflink)
5329                         dev->iflink = dev->ifindex;
5330         }
5331
5332         /* Fixup kobjects */
5333         err = netdev_register_kobject(dev);
5334         WARN_ON(err);
5335
5336         /* Add the device back in the hashes */
5337         list_netdevice(dev);
5338
5339         /* Notify protocols, that a new device appeared. */
5340         call_netdevice_notifiers(NETDEV_REGISTER, dev);
5341
5342         synchronize_net();
5343         err = 0;
5344 out:
5345         return err;
5346 }
5347
5348 static int dev_cpu_callback(struct notifier_block *nfb,
5349                             unsigned long action,
5350                             void *ocpu)
5351 {
5352         struct sk_buff **list_skb;
5353         struct Qdisc **list_net;
5354         struct sk_buff *skb;
5355         unsigned int cpu, oldcpu = (unsigned long)ocpu;
5356         struct softnet_data *sd, *oldsd;
5357
5358         if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
5359                 return NOTIFY_OK;
5360
5361         local_irq_disable();
5362         cpu = smp_processor_id();
5363         sd = &per_cpu(softnet_data, cpu);
5364         oldsd = &per_cpu(softnet_data, oldcpu);
5365
5366         /* Find end of our completion_queue. */
5367         list_skb = &sd->completion_queue;
5368         while (*list_skb)
5369                 list_skb = &(*list_skb)->next;
5370         /* Append completion queue from offline CPU. */
5371         *list_skb = oldsd->completion_queue;
5372         oldsd->completion_queue = NULL;
5373
5374         /* Find end of our output_queue. */
5375         list_net = &sd->output_queue;
5376         while (*list_net)
5377                 list_net = &(*list_net)->next_sched;
5378         /* Append output queue from offline CPU. */
5379         *list_net = oldsd->output_queue;
5380         oldsd->output_queue = NULL;
5381
5382         raise_softirq_irqoff(NET_TX_SOFTIRQ);
5383         local_irq_enable();
5384
5385         /* Process offline CPU's input_pkt_queue */
5386         while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
5387                 netif_rx(skb);
5388
5389         return NOTIFY_OK;
5390 }
5391
5392
5393 /**
5394  *      netdev_increment_features - increment feature set by one
5395  *      @all: current feature set
5396  *      @one: new feature set
5397  *      @mask: mask feature set
5398  *
5399  *      Computes a new feature set after adding a device with feature set
5400  *      @one to the master device with current feature set @all.  Will not
5401  *      enable anything that is off in @mask. Returns the new feature set.
5402  */
5403 unsigned long netdev_increment_features(unsigned long all, unsigned long one,
5404                                         unsigned long mask)
5405 {
5406         /* If device needs checksumming, downgrade to it. */
5407         if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
5408                 all ^= NETIF_F_NO_CSUM | (one & NETIF_F_ALL_CSUM);
5409         else if (mask & NETIF_F_ALL_CSUM) {
5410                 /* If one device supports v4/v6 checksumming, set for all. */
5411                 if (one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM) &&
5412                     !(all & NETIF_F_GEN_CSUM)) {
5413                         all &= ~NETIF_F_ALL_CSUM;
5414                         all |= one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
5415                 }
5416
5417                 /* If one device supports hw checksumming, set for all. */
5418                 if (one & NETIF_F_GEN_CSUM && !(all & NETIF_F_GEN_CSUM)) {
5419                         all &= ~NETIF_F_ALL_CSUM;
5420                         all |= NETIF_F_HW_CSUM;
5421                 }
5422         }
5423
5424         one |= NETIF_F_ALL_CSUM;
5425
5426         one |= all & NETIF_F_ONE_FOR_ALL;
5427         all &= one | NETIF_F_LLTX | NETIF_F_GSO;
5428         all |= one & mask & NETIF_F_ONE_FOR_ALL;
5429
5430         return all;
5431 }
5432 EXPORT_SYMBOL(netdev_increment_features);
5433
5434 static struct hlist_head *netdev_create_hash(void)
5435 {
5436         int i;
5437         struct hlist_head *hash;
5438
5439         hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
5440         if (hash != NULL)
5441                 for (i = 0; i < NETDEV_HASHENTRIES; i++)
5442                         INIT_HLIST_HEAD(&hash[i]);
5443
5444         return hash;
5445 }
5446
5447 /* Initialize per network namespace state */
5448 static int __net_init netdev_init(struct net *net)
5449 {
5450         INIT_LIST_HEAD(&net->dev_base_head);
5451
5452         net->dev_name_head = netdev_create_hash();
5453         if (net->dev_name_head == NULL)
5454                 goto err_name;
5455
5456         net->dev_index_head = netdev_create_hash();
5457         if (net->dev_index_head == NULL)
5458                 goto err_idx;
5459
5460         return 0;
5461
5462 err_idx:
5463         kfree(net->dev_name_head);
5464 err_name:
5465         return -ENOMEM;
5466 }
5467
5468 /**
5469  *      netdev_drivername - network driver for the device
5470  *      @dev: network device
5471  *      @buffer: buffer for resulting name
5472  *      @len: size of buffer
5473  *
5474  *      Determine network driver for device.
5475  */
5476 char *netdev_drivername(const struct net_device *dev, char *buffer, int len)
5477 {
5478         const struct device_driver *driver;
5479         const struct device *parent;
5480
5481         if (len <= 0 || !buffer)
5482                 return buffer;
5483         buffer[0] = 0;
5484
5485         parent = dev->dev.parent;
5486
5487         if (!parent)
5488                 return buffer;
5489
5490         driver = parent->driver;
5491         if (driver && driver->name)
5492                 strlcpy(buffer, driver->name, len);
5493         return buffer;
5494 }
5495
5496 static void __net_exit netdev_exit(struct net *net)
5497 {
5498         kfree(net->dev_name_head);
5499         kfree(net->dev_index_head);
5500 }
5501
5502 static struct pernet_operations __net_initdata netdev_net_ops = {
5503         .init = netdev_init,
5504         .exit = netdev_exit,
5505 };
5506
5507 static void __net_exit default_device_exit(struct net *net)
5508 {
5509         struct net_device *dev;
5510         /*
5511          * Push all migratable of the network devices back to the
5512          * initial network namespace
5513          */
5514         rtnl_lock();
5515 restart:
5516         for_each_netdev(net, dev) {
5517                 int err;
5518                 char fb_name[IFNAMSIZ];
5519
5520                 /* Ignore unmoveable devices (i.e. loopback) */
5521                 if (dev->features & NETIF_F_NETNS_LOCAL)
5522                         continue;
5523
5524                 /* Delete virtual devices */
5525                 if (dev->rtnl_link_ops && dev->rtnl_link_ops->dellink) {
5526                         dev->rtnl_link_ops->dellink(dev);
5527                         goto restart;
5528                 }
5529
5530                 /* Push remaing network devices to init_net */
5531                 snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
5532                 err = dev_change_net_namespace(dev, &init_net, fb_name);
5533                 if (err) {
5534                         printk(KERN_EMERG "%s: failed to move %s to init_net: %d\n",
5535                                 __func__, dev->name, err);
5536                         BUG();
5537                 }
5538                 goto restart;
5539         }
5540         rtnl_unlock();
5541 }
5542
5543 static struct pernet_operations __net_initdata default_device_ops = {
5544         .exit = default_device_exit,
5545 };
5546
5547 /*
5548  *      Initialize the DEV module. At boot time this walks the device list and
5549  *      unhooks any devices that fail to initialise (normally hardware not
5550  *      present) and leaves us with a valid list of present and active devices.
5551  *
5552  */
5553
5554 /*
5555  *       This is called single threaded during boot, so no need
5556  *       to take the rtnl semaphore.
5557  */
5558 static int __init net_dev_init(void)
5559 {
5560         int i, rc = -ENOMEM;
5561
5562         BUG_ON(!dev_boot_phase);
5563
5564         if (dev_proc_init())
5565                 goto out;
5566
5567         if (netdev_kobject_init())
5568                 goto out;
5569
5570         INIT_LIST_HEAD(&ptype_all);
5571         for (i = 0; i < PTYPE_HASH_SIZE; i++)
5572                 INIT_LIST_HEAD(&ptype_base[i]);
5573
5574         if (register_pernet_subsys(&netdev_net_ops))
5575                 goto out;
5576
5577         /*
5578          *      Initialise the packet receive queues.
5579          */
5580
5581         for_each_possible_cpu(i) {
5582                 struct softnet_data *queue;
5583
5584                 queue = &per_cpu(softnet_data, i);
5585                 skb_queue_head_init(&queue->input_pkt_queue);
5586                 queue->completion_queue = NULL;
5587                 INIT_LIST_HEAD(&queue->poll_list);
5588
5589                 queue->backlog.poll = process_backlog;
5590                 queue->backlog.weight = weight_p;
5591                 queue->backlog.gro_list = NULL;
5592                 queue->backlog.gro_count = 0;
5593         }
5594
5595         dev_boot_phase = 0;
5596
5597         /* The loopback device is special if any other network devices
5598          * is present in a network namespace the loopback device must
5599          * be present. Since we now dynamically allocate and free the
5600          * loopback device ensure this invariant is maintained by
5601          * keeping the loopback device as the first device on the
5602          * list of network devices.  Ensuring the loopback devices
5603          * is the first device that appears and the last network device
5604          * that disappears.
5605          */
5606         if (register_pernet_device(&loopback_net_ops))
5607                 goto out;
5608
5609         if (register_pernet_device(&default_device_ops))
5610                 goto out;
5611
5612         open_softirq(NET_TX_SOFTIRQ, net_tx_action);
5613         open_softirq(NET_RX_SOFTIRQ, net_rx_action);
5614
5615         hotcpu_notifier(dev_cpu_callback, 0);
5616         dst_init();
5617         dev_mcast_init();
5618         rc = 0;
5619 out:
5620         return rc;
5621 }
5622
5623 subsys_initcall(net_dev_init);
5624
5625 static int __init initialize_hashrnd(void)
5626 {
5627         get_random_bytes(&skb_tx_hashrnd, sizeof(skb_tx_hashrnd));
5628         return 0;
5629 }
5630
5631 late_initcall_sync(initialize_hashrnd);
5632
5633 EXPORT_SYMBOL(__dev_get_by_index);
5634 EXPORT_SYMBOL(__dev_get_by_name);
5635 EXPORT_SYMBOL(__dev_remove_pack);
5636 EXPORT_SYMBOL(dev_valid_name);
5637 EXPORT_SYMBOL(dev_add_pack);
5638 EXPORT_SYMBOL(dev_alloc_name);
5639 EXPORT_SYMBOL(dev_close);
5640 EXPORT_SYMBOL(dev_get_by_flags);
5641 EXPORT_SYMBOL(dev_get_by_index);
5642 EXPORT_SYMBOL(dev_get_by_name);
5643 EXPORT_SYMBOL(dev_open);
5644 EXPORT_SYMBOL(dev_queue_xmit);
5645 EXPORT_SYMBOL(dev_remove_pack);
5646 EXPORT_SYMBOL(dev_set_allmulti);
5647 EXPORT_SYMBOL(dev_set_promiscuity);
5648 EXPORT_SYMBOL(dev_change_flags);
5649 EXPORT_SYMBOL(dev_set_mtu);
5650 EXPORT_SYMBOL(dev_set_mac_address);
5651 EXPORT_SYMBOL(free_netdev);
5652 EXPORT_SYMBOL(netdev_boot_setup_check);
5653 EXPORT_SYMBOL(netdev_set_master);
5654 EXPORT_SYMBOL(netdev_state_change);
5655 EXPORT_SYMBOL(netif_receive_skb);
5656 EXPORT_SYMBOL(netif_rx);
5657 EXPORT_SYMBOL(register_gifconf);
5658 EXPORT_SYMBOL(register_netdevice);
5659 EXPORT_SYMBOL(register_netdevice_notifier);
5660 EXPORT_SYMBOL(skb_checksum_help);
5661 EXPORT_SYMBOL(synchronize_net);
5662 EXPORT_SYMBOL(unregister_netdevice);
5663 EXPORT_SYMBOL(unregister_netdevice_notifier);
5664 EXPORT_SYMBOL(net_enable_timestamp);
5665 EXPORT_SYMBOL(net_disable_timestamp);
5666 EXPORT_SYMBOL(dev_get_flags);
5667
5668 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
5669 EXPORT_SYMBOL(br_handle_frame_hook);
5670 EXPORT_SYMBOL(br_fdb_get_hook);
5671 EXPORT_SYMBOL(br_fdb_put_hook);
5672 #endif
5673
5674 EXPORT_SYMBOL(dev_load);
5675
5676 EXPORT_PER_CPU_SYMBOL(softnet_data);