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