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