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