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