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