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