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