Merge branch 'fix/misc' into for-linus
[linux-2.6] / 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         net_timestamp(skb);
1340
1341         rcu_read_lock();
1342         list_for_each_entry_rcu(ptype, &ptype_all, list) {
1343                 /* Never send packets back to the socket
1344                  * they originated from - MvS (miquels@drinkel.ow.org)
1345                  */
1346                 if ((ptype->dev == dev || !ptype->dev) &&
1347                     (ptype->af_packet_priv == NULL ||
1348                      (struct sock *)ptype->af_packet_priv != skb->sk)) {
1349                         struct sk_buff *skb2= skb_clone(skb, GFP_ATOMIC);
1350                         if (!skb2)
1351                                 break;
1352
1353                         /* skb->nh should be correctly
1354                            set by sender, so that the second statement is
1355                            just protection against buggy protocols.
1356                          */
1357                         skb_reset_mac_header(skb2);
1358
1359                         if (skb_network_header(skb2) < skb2->data ||
1360                             skb2->network_header > skb2->tail) {
1361                                 if (net_ratelimit())
1362                                         printk(KERN_CRIT "protocol %04x is "
1363                                                "buggy, dev %s\n",
1364                                                skb2->protocol, dev->name);
1365                                 skb_reset_network_header(skb2);
1366                         }
1367
1368                         skb2->transport_header = skb2->network_header;
1369                         skb2->pkt_type = PACKET_OUTGOING;
1370                         ptype->func(skb2, skb->dev, ptype, skb->dev);
1371                 }
1372         }
1373         rcu_read_unlock();
1374 }
1375
1376
1377 static inline void __netif_reschedule(struct Qdisc *q)
1378 {
1379         struct softnet_data *sd;
1380         unsigned long flags;
1381
1382         local_irq_save(flags);
1383         sd = &__get_cpu_var(softnet_data);
1384         q->next_sched = sd->output_queue;
1385         sd->output_queue = q;
1386         raise_softirq_irqoff(NET_TX_SOFTIRQ);
1387         local_irq_restore(flags);
1388 }
1389
1390 void __netif_schedule(struct Qdisc *q)
1391 {
1392         if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state))
1393                 __netif_reschedule(q);
1394 }
1395 EXPORT_SYMBOL(__netif_schedule);
1396
1397 void dev_kfree_skb_irq(struct sk_buff *skb)
1398 {
1399         if (atomic_dec_and_test(&skb->users)) {
1400                 struct softnet_data *sd;
1401                 unsigned long flags;
1402
1403                 local_irq_save(flags);
1404                 sd = &__get_cpu_var(softnet_data);
1405                 skb->next = sd->completion_queue;
1406                 sd->completion_queue = skb;
1407                 raise_softirq_irqoff(NET_TX_SOFTIRQ);
1408                 local_irq_restore(flags);
1409         }
1410 }
1411 EXPORT_SYMBOL(dev_kfree_skb_irq);
1412
1413 void dev_kfree_skb_any(struct sk_buff *skb)
1414 {
1415         if (in_irq() || irqs_disabled())
1416                 dev_kfree_skb_irq(skb);
1417         else
1418                 dev_kfree_skb(skb);
1419 }
1420 EXPORT_SYMBOL(dev_kfree_skb_any);
1421
1422
1423 /**
1424  * netif_device_detach - mark device as removed
1425  * @dev: network device
1426  *
1427  * Mark device as removed from system and therefore no longer available.
1428  */
1429 void netif_device_detach(struct net_device *dev)
1430 {
1431         if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) &&
1432             netif_running(dev)) {
1433                 netif_tx_stop_all_queues(dev);
1434         }
1435 }
1436 EXPORT_SYMBOL(netif_device_detach);
1437
1438 /**
1439  * netif_device_attach - mark device as attached
1440  * @dev: network device
1441  *
1442  * Mark device as attached from system and restart if needed.
1443  */
1444 void netif_device_attach(struct net_device *dev)
1445 {
1446         if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) &&
1447             netif_running(dev)) {
1448                 netif_tx_wake_all_queues(dev);
1449                 __netdev_watchdog_up(dev);
1450         }
1451 }
1452 EXPORT_SYMBOL(netif_device_attach);
1453
1454 static bool can_checksum_protocol(unsigned long features, __be16 protocol)
1455 {
1456         return ((features & NETIF_F_GEN_CSUM) ||
1457                 ((features & NETIF_F_IP_CSUM) &&
1458                  protocol == htons(ETH_P_IP)) ||
1459                 ((features & NETIF_F_IPV6_CSUM) &&
1460                  protocol == htons(ETH_P_IPV6)) ||
1461                 ((features & NETIF_F_FCOE_CRC) &&
1462                  protocol == htons(ETH_P_FCOE)));
1463 }
1464
1465 static bool dev_can_checksum(struct net_device *dev, struct sk_buff *skb)
1466 {
1467         if (can_checksum_protocol(dev->features, skb->protocol))
1468                 return true;
1469
1470         if (skb->protocol == htons(ETH_P_8021Q)) {
1471                 struct vlan_ethhdr *veh = (struct vlan_ethhdr *)skb->data;
1472                 if (can_checksum_protocol(dev->features & dev->vlan_features,
1473                                           veh->h_vlan_encapsulated_proto))
1474                         return true;
1475         }
1476
1477         return false;
1478 }
1479
1480 /*
1481  * Invalidate hardware checksum when packet is to be mangled, and
1482  * complete checksum manually on outgoing path.
1483  */
1484 int skb_checksum_help(struct sk_buff *skb)
1485 {
1486         __wsum csum;
1487         int ret = 0, offset;
1488
1489         if (skb->ip_summed == CHECKSUM_COMPLETE)
1490                 goto out_set_summed;
1491
1492         if (unlikely(skb_shinfo(skb)->gso_size)) {
1493                 /* Let GSO fix up the checksum. */
1494                 goto out_set_summed;
1495         }
1496
1497         offset = skb->csum_start - skb_headroom(skb);
1498         BUG_ON(offset >= skb_headlen(skb));
1499         csum = skb_checksum(skb, offset, skb->len - offset, 0);
1500
1501         offset += skb->csum_offset;
1502         BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb));
1503
1504         if (skb_cloned(skb) &&
1505             !skb_clone_writable(skb, offset + sizeof(__sum16))) {
1506                 ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
1507                 if (ret)
1508                         goto out;
1509         }
1510
1511         *(__sum16 *)(skb->data + offset) = csum_fold(csum);
1512 out_set_summed:
1513         skb->ip_summed = CHECKSUM_NONE;
1514 out:
1515         return ret;
1516 }
1517
1518 /**
1519  *      skb_gso_segment - Perform segmentation on skb.
1520  *      @skb: buffer to segment
1521  *      @features: features for the output path (see dev->features)
1522  *
1523  *      This function segments the given skb and returns a list of segments.
1524  *
1525  *      It may return NULL if the skb requires no segmentation.  This is
1526  *      only possible when GSO is used for verifying header integrity.
1527  */
1528 struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
1529 {
1530         struct sk_buff *segs = ERR_PTR(-EPROTONOSUPPORT);
1531         struct packet_type *ptype;
1532         __be16 type = skb->protocol;
1533         int err;
1534
1535         skb_reset_mac_header(skb);
1536         skb->mac_len = skb->network_header - skb->mac_header;
1537         __skb_pull(skb, skb->mac_len);
1538
1539         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1540                 struct net_device *dev = skb->dev;
1541                 struct ethtool_drvinfo info = {};
1542
1543                 if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo)
1544                         dev->ethtool_ops->get_drvinfo(dev, &info);
1545
1546                 WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d "
1547                         "ip_summed=%d",
1548                      info.driver, dev ? dev->features : 0L,
1549                      skb->sk ? skb->sk->sk_route_caps : 0L,
1550                      skb->len, skb->data_len, skb->ip_summed);
1551
1552                 if (skb_header_cloned(skb) &&
1553                     (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC)))
1554                         return ERR_PTR(err);
1555         }
1556
1557         rcu_read_lock();
1558         list_for_each_entry_rcu(ptype,
1559                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
1560                 if (ptype->type == type && !ptype->dev && ptype->gso_segment) {
1561                         if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) {
1562                                 err = ptype->gso_send_check(skb);
1563                                 segs = ERR_PTR(err);
1564                                 if (err || skb_gso_ok(skb, features))
1565                                         break;
1566                                 __skb_push(skb, (skb->data -
1567                                                  skb_network_header(skb)));
1568                         }
1569                         segs = ptype->gso_segment(skb, features);
1570                         break;
1571                 }
1572         }
1573         rcu_read_unlock();
1574
1575         __skb_push(skb, skb->data - skb_mac_header(skb));
1576
1577         return segs;
1578 }
1579
1580 EXPORT_SYMBOL(skb_gso_segment);
1581
1582 /* Take action when hardware reception checksum errors are detected. */
1583 #ifdef CONFIG_BUG
1584 void netdev_rx_csum_fault(struct net_device *dev)
1585 {
1586         if (net_ratelimit()) {
1587                 printk(KERN_ERR "%s: hw csum failure.\n",
1588                         dev ? dev->name : "<unknown>");
1589                 dump_stack();
1590         }
1591 }
1592 EXPORT_SYMBOL(netdev_rx_csum_fault);
1593 #endif
1594
1595 /* Actually, we should eliminate this check as soon as we know, that:
1596  * 1. IOMMU is present and allows to map all the memory.
1597  * 2. No high memory really exists on this machine.
1598  */
1599
1600 static inline int illegal_highdma(struct net_device *dev, struct sk_buff *skb)
1601 {
1602 #ifdef CONFIG_HIGHMEM
1603         int i;
1604
1605         if (dev->features & NETIF_F_HIGHDMA)
1606                 return 0;
1607
1608         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
1609                 if (PageHighMem(skb_shinfo(skb)->frags[i].page))
1610                         return 1;
1611
1612 #endif
1613         return 0;
1614 }
1615
1616 struct dev_gso_cb {
1617         void (*destructor)(struct sk_buff *skb);
1618 };
1619
1620 #define DEV_GSO_CB(skb) ((struct dev_gso_cb *)(skb)->cb)
1621
1622 static void dev_gso_skb_destructor(struct sk_buff *skb)
1623 {
1624         struct dev_gso_cb *cb;
1625
1626         do {
1627                 struct sk_buff *nskb = skb->next;
1628
1629                 skb->next = nskb->next;
1630                 nskb->next = NULL;
1631                 kfree_skb(nskb);
1632         } while (skb->next);
1633
1634         cb = DEV_GSO_CB(skb);
1635         if (cb->destructor)
1636                 cb->destructor(skb);
1637 }
1638
1639 /**
1640  *      dev_gso_segment - Perform emulated hardware segmentation on skb.
1641  *      @skb: buffer to segment
1642  *
1643  *      This function segments the given skb and stores the list of segments
1644  *      in skb->next.
1645  */
1646 static int dev_gso_segment(struct sk_buff *skb)
1647 {
1648         struct net_device *dev = skb->dev;
1649         struct sk_buff *segs;
1650         int features = dev->features & ~(illegal_highdma(dev, skb) ?
1651                                          NETIF_F_SG : 0);
1652
1653         segs = skb_gso_segment(skb, features);
1654
1655         /* Verifying header integrity only. */
1656         if (!segs)
1657                 return 0;
1658
1659         if (IS_ERR(segs))
1660                 return PTR_ERR(segs);
1661
1662         skb->next = segs;
1663         DEV_GSO_CB(skb)->destructor = skb->destructor;
1664         skb->destructor = dev_gso_skb_destructor;
1665
1666         return 0;
1667 }
1668
1669 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
1670                         struct netdev_queue *txq)
1671 {
1672         const struct net_device_ops *ops = dev->netdev_ops;
1673         int rc;
1674
1675         if (likely(!skb->next)) {
1676                 if (!list_empty(&ptype_all))
1677                         dev_queue_xmit_nit(skb, dev);
1678
1679                 if (netif_needs_gso(dev, skb)) {
1680                         if (unlikely(dev_gso_segment(skb)))
1681                                 goto out_kfree_skb;
1682                         if (skb->next)
1683                                 goto gso;
1684                 }
1685
1686                 rc = ops->ndo_start_xmit(skb, dev);
1687                 /*
1688                  * TODO: if skb_orphan() was called by
1689                  * dev->hard_start_xmit() (for example, the unmodified
1690                  * igb driver does that; bnx2 doesn't), then
1691                  * skb_tx_software_timestamp() will be unable to send
1692                  * back the time stamp.
1693                  *
1694                  * How can this be prevented? Always create another
1695                  * reference to the socket before calling
1696                  * dev->hard_start_xmit()? Prevent that skb_orphan()
1697                  * does anything in dev->hard_start_xmit() by clearing
1698                  * the skb destructor before the call and restoring it
1699                  * afterwards, then doing the skb_orphan() ourselves?
1700                  */
1701                 return rc;
1702         }
1703
1704 gso:
1705         do {
1706                 struct sk_buff *nskb = skb->next;
1707
1708                 skb->next = nskb->next;
1709                 nskb->next = NULL;
1710                 rc = ops->ndo_start_xmit(nskb, dev);
1711                 if (unlikely(rc)) {
1712                         nskb->next = skb->next;
1713                         skb->next = nskb;
1714                         return rc;
1715                 }
1716                 if (unlikely(netif_tx_queue_stopped(txq) && skb->next))
1717                         return NETDEV_TX_BUSY;
1718         } while (skb->next);
1719
1720         skb->destructor = DEV_GSO_CB(skb)->destructor;
1721
1722 out_kfree_skb:
1723         kfree_skb(skb);
1724         return 0;
1725 }
1726
1727 static u32 skb_tx_hashrnd;
1728
1729 u16 skb_tx_hash(const struct net_device *dev, const struct sk_buff *skb)
1730 {
1731         u32 hash;
1732
1733         if (skb_rx_queue_recorded(skb)) {
1734                 hash = skb_get_rx_queue(skb);
1735         } else if (skb->sk && skb->sk->sk_hash) {
1736                 hash = skb->sk->sk_hash;
1737         } else
1738                 hash = skb->protocol;
1739
1740         hash = jhash_1word(hash, skb_tx_hashrnd);
1741
1742         return (u16) (((u64) hash * dev->real_num_tx_queues) >> 32);
1743 }
1744 EXPORT_SYMBOL(skb_tx_hash);
1745
1746 static struct netdev_queue *dev_pick_tx(struct net_device *dev,
1747                                         struct sk_buff *skb)
1748 {
1749         const struct net_device_ops *ops = dev->netdev_ops;
1750         u16 queue_index = 0;
1751
1752         if (ops->ndo_select_queue)
1753                 queue_index = ops->ndo_select_queue(dev, skb);
1754         else if (dev->real_num_tx_queues > 1)
1755                 queue_index = skb_tx_hash(dev, skb);
1756
1757         skb_set_queue_mapping(skb, queue_index);
1758         return netdev_get_tx_queue(dev, queue_index);
1759 }
1760
1761 /**
1762  *      dev_queue_xmit - transmit a buffer
1763  *      @skb: buffer to transmit
1764  *
1765  *      Queue a buffer for transmission to a network device. The caller must
1766  *      have set the device and priority and built the buffer before calling
1767  *      this function. The function can be called from an interrupt.
1768  *
1769  *      A negative errno code is returned on a failure. A success does not
1770  *      guarantee the frame will be transmitted as it may be dropped due
1771  *      to congestion or traffic shaping.
1772  *
1773  * -----------------------------------------------------------------------------------
1774  *      I notice this method can also return errors from the queue disciplines,
1775  *      including NET_XMIT_DROP, which is a positive value.  So, errors can also
1776  *      be positive.
1777  *
1778  *      Regardless of the return value, the skb is consumed, so it is currently
1779  *      difficult to retry a send to this method.  (You can bump the ref count
1780  *      before sending to hold a reference for retry if you are careful.)
1781  *
1782  *      When calling this method, interrupts MUST be enabled.  This is because
1783  *      the BH enable code must have IRQs enabled so that it will not deadlock.
1784  *          --BLG
1785  */
1786 int dev_queue_xmit(struct sk_buff *skb)
1787 {
1788         struct net_device *dev = skb->dev;
1789         struct netdev_queue *txq;
1790         struct Qdisc *q;
1791         int rc = -ENOMEM;
1792
1793         /* GSO will handle the following emulations directly. */
1794         if (netif_needs_gso(dev, skb))
1795                 goto gso;
1796
1797         if (skb_shinfo(skb)->frag_list &&
1798             !(dev->features & NETIF_F_FRAGLIST) &&
1799             __skb_linearize(skb))
1800                 goto out_kfree_skb;
1801
1802         /* Fragmented skb is linearized if device does not support SG,
1803          * or if at least one of fragments is in highmem and device
1804          * does not support DMA from it.
1805          */
1806         if (skb_shinfo(skb)->nr_frags &&
1807             (!(dev->features & NETIF_F_SG) || illegal_highdma(dev, skb)) &&
1808             __skb_linearize(skb))
1809                 goto out_kfree_skb;
1810
1811         /* If packet is not checksummed and device does not support
1812          * checksumming for this protocol, complete checksumming here.
1813          */
1814         if (skb->ip_summed == CHECKSUM_PARTIAL) {
1815                 skb_set_transport_header(skb, skb->csum_start -
1816                                               skb_headroom(skb));
1817                 if (!dev_can_checksum(dev, skb) && skb_checksum_help(skb))
1818                         goto out_kfree_skb;
1819         }
1820
1821 gso:
1822         /* Disable soft irqs for various locks below. Also
1823          * stops preemption for RCU.
1824          */
1825         rcu_read_lock_bh();
1826
1827         txq = dev_pick_tx(dev, skb);
1828         q = rcu_dereference(txq->qdisc);
1829
1830 #ifdef CONFIG_NET_CLS_ACT
1831         skb->tc_verd = SET_TC_AT(skb->tc_verd,AT_EGRESS);
1832 #endif
1833         if (q->enqueue) {
1834                 spinlock_t *root_lock = qdisc_lock(q);
1835
1836                 spin_lock(root_lock);
1837
1838                 if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
1839                         kfree_skb(skb);
1840                         rc = NET_XMIT_DROP;
1841                 } else {
1842                         rc = qdisc_enqueue_root(skb, q);
1843                         qdisc_run(q);
1844                 }
1845                 spin_unlock(root_lock);
1846
1847                 goto out;
1848         }
1849
1850         /* The device has no queue. Common case for software devices:
1851            loopback, all the sorts of tunnels...
1852
1853            Really, it is unlikely that netif_tx_lock protection is necessary
1854            here.  (f.e. loopback and IP tunnels are clean ignoring statistics
1855            counters.)
1856            However, it is possible, that they rely on protection
1857            made by us here.
1858
1859            Check this and shot the lock. It is not prone from deadlocks.
1860            Either shot noqueue qdisc, it is even simpler 8)
1861          */
1862         if (dev->flags & IFF_UP) {
1863                 int cpu = smp_processor_id(); /* ok because BHs are off */
1864
1865                 if (txq->xmit_lock_owner != cpu) {
1866
1867                         HARD_TX_LOCK(dev, txq, cpu);
1868
1869                         if (!netif_tx_queue_stopped(txq)) {
1870                                 rc = 0;
1871                                 if (!dev_hard_start_xmit(skb, dev, txq)) {
1872                                         HARD_TX_UNLOCK(dev, txq);
1873                                         goto out;
1874                                 }
1875                         }
1876                         HARD_TX_UNLOCK(dev, txq);
1877                         if (net_ratelimit())
1878                                 printk(KERN_CRIT "Virtual device %s asks to "
1879                                        "queue packet!\n", dev->name);
1880                 } else {
1881                         /* Recursion is detected! It is possible,
1882                          * unfortunately */
1883                         if (net_ratelimit())
1884                                 printk(KERN_CRIT "Dead loop on virtual device "
1885                                        "%s, fix it urgently!\n", dev->name);
1886                 }
1887         }
1888
1889         rc = -ENETDOWN;
1890         rcu_read_unlock_bh();
1891
1892 out_kfree_skb:
1893         kfree_skb(skb);
1894         return rc;
1895 out:
1896         rcu_read_unlock_bh();
1897         return rc;
1898 }
1899
1900
1901 /*=======================================================================
1902                         Receiver routines
1903   =======================================================================*/
1904
1905 int netdev_max_backlog __read_mostly = 1000;
1906 int netdev_budget __read_mostly = 300;
1907 int weight_p __read_mostly = 64;            /* old backlog weight */
1908
1909 DEFINE_PER_CPU(struct netif_rx_stats, netdev_rx_stat) = { 0, };
1910
1911
1912 /**
1913  *      netif_rx        -       post buffer to the network code
1914  *      @skb: buffer to post
1915  *
1916  *      This function receives a packet from a device driver and queues it for
1917  *      the upper (protocol) levels to process.  It always succeeds. The buffer
1918  *      may be dropped during processing for congestion control or by the
1919  *      protocol layers.
1920  *
1921  *      return values:
1922  *      NET_RX_SUCCESS  (no congestion)
1923  *      NET_RX_DROP     (packet was dropped)
1924  *
1925  */
1926
1927 int netif_rx(struct sk_buff *skb)
1928 {
1929         struct softnet_data *queue;
1930         unsigned long flags;
1931
1932         /* if netpoll wants it, pretend we never saw it */
1933         if (netpoll_rx(skb))
1934                 return NET_RX_DROP;
1935
1936         if (!skb->tstamp.tv64)
1937                 net_timestamp(skb);
1938
1939         /*
1940          * The code is rearranged so that the path is the most
1941          * short when CPU is congested, but is still operating.
1942          */
1943         local_irq_save(flags);
1944         queue = &__get_cpu_var(softnet_data);
1945
1946         __get_cpu_var(netdev_rx_stat).total++;
1947         if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
1948                 if (queue->input_pkt_queue.qlen) {
1949 enqueue:
1950                         __skb_queue_tail(&queue->input_pkt_queue, skb);
1951                         local_irq_restore(flags);
1952                         return NET_RX_SUCCESS;
1953                 }
1954
1955                 napi_schedule(&queue->backlog);
1956                 goto enqueue;
1957         }
1958
1959         __get_cpu_var(netdev_rx_stat).dropped++;
1960         local_irq_restore(flags);
1961
1962         kfree_skb(skb);
1963         return NET_RX_DROP;
1964 }
1965
1966 int netif_rx_ni(struct sk_buff *skb)
1967 {
1968         int err;
1969
1970         preempt_disable();
1971         err = netif_rx(skb);
1972         if (local_softirq_pending())
1973                 do_softirq();
1974         preempt_enable();
1975
1976         return err;
1977 }
1978
1979 EXPORT_SYMBOL(netif_rx_ni);
1980
1981 static void net_tx_action(struct softirq_action *h)
1982 {
1983         struct softnet_data *sd = &__get_cpu_var(softnet_data);
1984
1985         if (sd->completion_queue) {
1986                 struct sk_buff *clist;
1987
1988                 local_irq_disable();
1989                 clist = sd->completion_queue;
1990                 sd->completion_queue = NULL;
1991                 local_irq_enable();
1992
1993                 while (clist) {
1994                         struct sk_buff *skb = clist;
1995                         clist = clist->next;
1996
1997                         WARN_ON(atomic_read(&skb->users));
1998                         __kfree_skb(skb);
1999                 }
2000         }
2001
2002         if (sd->output_queue) {
2003                 struct Qdisc *head;
2004
2005                 local_irq_disable();
2006                 head = sd->output_queue;
2007                 sd->output_queue = NULL;
2008                 local_irq_enable();
2009
2010                 while (head) {
2011                         struct Qdisc *q = head;
2012                         spinlock_t *root_lock;
2013
2014                         head = head->next_sched;
2015
2016                         root_lock = qdisc_lock(q);
2017                         if (spin_trylock(root_lock)) {
2018                                 smp_mb__before_clear_bit();
2019                                 clear_bit(__QDISC_STATE_SCHED,
2020                                           &q->state);
2021                                 qdisc_run(q);
2022                                 spin_unlock(root_lock);
2023                         } else {
2024                                 if (!test_bit(__QDISC_STATE_DEACTIVATED,
2025                                               &q->state)) {
2026                                         __netif_reschedule(q);
2027                                 } else {
2028                                         smp_mb__before_clear_bit();
2029                                         clear_bit(__QDISC_STATE_SCHED,
2030                                                   &q->state);
2031                                 }
2032                         }
2033                 }
2034         }
2035 }
2036
2037 static inline int deliver_skb(struct sk_buff *skb,
2038                               struct packet_type *pt_prev,
2039                               struct net_device *orig_dev)
2040 {
2041         atomic_inc(&skb->users);
2042         return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2043 }
2044
2045 #if defined(CONFIG_BRIDGE) || defined (CONFIG_BRIDGE_MODULE)
2046 /* These hooks defined here for ATM */
2047 struct net_bridge;
2048 struct net_bridge_fdb_entry *(*br_fdb_get_hook)(struct net_bridge *br,
2049                                                 unsigned char *addr);
2050 void (*br_fdb_put_hook)(struct net_bridge_fdb_entry *ent) __read_mostly;
2051
2052 /*
2053  * If bridge module is loaded call bridging hook.
2054  *  returns NULL if packet was consumed.
2055  */
2056 struct sk_buff *(*br_handle_frame_hook)(struct net_bridge_port *p,
2057                                         struct sk_buff *skb) __read_mostly;
2058 static inline struct sk_buff *handle_bridge(struct sk_buff *skb,
2059                                             struct packet_type **pt_prev, int *ret,
2060                                             struct net_device *orig_dev)
2061 {
2062         struct net_bridge_port *port;
2063
2064         if (skb->pkt_type == PACKET_LOOPBACK ||
2065             (port = rcu_dereference(skb->dev->br_port)) == NULL)
2066                 return skb;
2067
2068         if (*pt_prev) {
2069                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2070                 *pt_prev = NULL;
2071         }
2072
2073         return br_handle_frame_hook(port, skb);
2074 }
2075 #else
2076 #define handle_bridge(skb, pt_prev, ret, orig_dev)      (skb)
2077 #endif
2078
2079 #if defined(CONFIG_MACVLAN) || defined(CONFIG_MACVLAN_MODULE)
2080 struct sk_buff *(*macvlan_handle_frame_hook)(struct sk_buff *skb) __read_mostly;
2081 EXPORT_SYMBOL_GPL(macvlan_handle_frame_hook);
2082
2083 static inline struct sk_buff *handle_macvlan(struct sk_buff *skb,
2084                                              struct packet_type **pt_prev,
2085                                              int *ret,
2086                                              struct net_device *orig_dev)
2087 {
2088         if (skb->dev->macvlan_port == NULL)
2089                 return skb;
2090
2091         if (*pt_prev) {
2092                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2093                 *pt_prev = NULL;
2094         }
2095         return macvlan_handle_frame_hook(skb);
2096 }
2097 #else
2098 #define handle_macvlan(skb, pt_prev, ret, orig_dev)     (skb)
2099 #endif
2100
2101 #ifdef CONFIG_NET_CLS_ACT
2102 /* TODO: Maybe we should just force sch_ingress to be compiled in
2103  * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions
2104  * a compare and 2 stores extra right now if we dont have it on
2105  * but have CONFIG_NET_CLS_ACT
2106  * NOTE: This doesnt stop any functionality; if you dont have
2107  * the ingress scheduler, you just cant add policies on ingress.
2108  *
2109  */
2110 static int ing_filter(struct sk_buff *skb)
2111 {
2112         struct net_device *dev = skb->dev;
2113         u32 ttl = G_TC_RTTL(skb->tc_verd);
2114         struct netdev_queue *rxq;
2115         int result = TC_ACT_OK;
2116         struct Qdisc *q;
2117
2118         if (MAX_RED_LOOP < ttl++) {
2119                 printk(KERN_WARNING
2120                        "Redir loop detected Dropping packet (%d->%d)\n",
2121                        skb->iif, dev->ifindex);
2122                 return TC_ACT_SHOT;
2123         }
2124
2125         skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl);
2126         skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS);
2127
2128         rxq = &dev->rx_queue;
2129
2130         q = rxq->qdisc;
2131         if (q != &noop_qdisc) {
2132                 spin_lock(qdisc_lock(q));
2133                 if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)))
2134                         result = qdisc_enqueue_root(skb, q);
2135                 spin_unlock(qdisc_lock(q));
2136         }
2137
2138         return result;
2139 }
2140
2141 static inline struct sk_buff *handle_ing(struct sk_buff *skb,
2142                                          struct packet_type **pt_prev,
2143                                          int *ret, struct net_device *orig_dev)
2144 {
2145         if (skb->dev->rx_queue.qdisc == &noop_qdisc)
2146                 goto out;
2147
2148         if (*pt_prev) {
2149                 *ret = deliver_skb(skb, *pt_prev, orig_dev);
2150                 *pt_prev = NULL;
2151         } else {
2152                 /* Huh? Why does turning on AF_PACKET affect this? */
2153                 skb->tc_verd = SET_TC_OK2MUNGE(skb->tc_verd);
2154         }
2155
2156         switch (ing_filter(skb)) {
2157         case TC_ACT_SHOT:
2158         case TC_ACT_STOLEN:
2159                 kfree_skb(skb);
2160                 return NULL;
2161         }
2162
2163 out:
2164         skb->tc_verd = 0;
2165         return skb;
2166 }
2167 #endif
2168
2169 /*
2170  *      netif_nit_deliver - deliver received packets to network taps
2171  *      @skb: buffer
2172  *
2173  *      This function is used to deliver incoming packets to network
2174  *      taps. It should be used when the normal netif_receive_skb path
2175  *      is bypassed, for example because of VLAN acceleration.
2176  */
2177 void netif_nit_deliver(struct sk_buff *skb)
2178 {
2179         struct packet_type *ptype;
2180
2181         if (list_empty(&ptype_all))
2182                 return;
2183
2184         skb_reset_network_header(skb);
2185         skb_reset_transport_header(skb);
2186         skb->mac_len = skb->network_header - skb->mac_header;
2187
2188         rcu_read_lock();
2189         list_for_each_entry_rcu(ptype, &ptype_all, list) {
2190                 if (!ptype->dev || ptype->dev == skb->dev)
2191                         deliver_skb(skb, ptype, skb->dev);
2192         }
2193         rcu_read_unlock();
2194 }
2195
2196 /**
2197  *      netif_receive_skb - process receive buffer from network
2198  *      @skb: buffer to process
2199  *
2200  *      netif_receive_skb() is the main receive data processing function.
2201  *      It always succeeds. The buffer may be dropped during processing
2202  *      for congestion control or by the protocol layers.
2203  *
2204  *      This function may only be called from softirq context and interrupts
2205  *      should be enabled.
2206  *
2207  *      Return values (usually ignored):
2208  *      NET_RX_SUCCESS: no congestion
2209  *      NET_RX_DROP: packet was dropped
2210  */
2211 int netif_receive_skb(struct sk_buff *skb)
2212 {
2213         struct packet_type *ptype, *pt_prev;
2214         struct net_device *orig_dev;
2215         struct net_device *null_or_orig;
2216         int ret = NET_RX_DROP;
2217         __be16 type;
2218
2219         if (skb->vlan_tci && vlan_hwaccel_do_receive(skb))
2220                 return NET_RX_SUCCESS;
2221
2222         /* if we've gotten here through NAPI, check netpoll */
2223         if (netpoll_receive_skb(skb))
2224                 return NET_RX_DROP;
2225
2226         if (!skb->tstamp.tv64)
2227                 net_timestamp(skb);
2228
2229         if (!skb->iif)
2230                 skb->iif = skb->dev->ifindex;
2231
2232         null_or_orig = NULL;
2233         orig_dev = skb->dev;
2234         if (orig_dev->master) {
2235                 if (skb_bond_should_drop(skb))
2236                         null_or_orig = orig_dev; /* deliver only exact match */
2237                 else
2238                         skb->dev = orig_dev->master;
2239         }
2240
2241         __get_cpu_var(netdev_rx_stat).total++;
2242
2243         skb_reset_network_header(skb);
2244         skb_reset_transport_header(skb);
2245         skb->mac_len = skb->network_header - skb->mac_header;
2246
2247         pt_prev = NULL;
2248
2249         rcu_read_lock();
2250
2251 #ifdef CONFIG_NET_CLS_ACT
2252         if (skb->tc_verd & TC_NCLS) {
2253                 skb->tc_verd = CLR_TC_NCLS(skb->tc_verd);
2254                 goto ncls;
2255         }
2256 #endif
2257
2258         list_for_each_entry_rcu(ptype, &ptype_all, list) {
2259                 if (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2260                     ptype->dev == orig_dev) {
2261                         if (pt_prev)
2262                                 ret = deliver_skb(skb, pt_prev, orig_dev);
2263                         pt_prev = ptype;
2264                 }
2265         }
2266
2267 #ifdef CONFIG_NET_CLS_ACT
2268         skb = handle_ing(skb, &pt_prev, &ret, orig_dev);
2269         if (!skb)
2270                 goto out;
2271 ncls:
2272 #endif
2273
2274         skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
2275         if (!skb)
2276                 goto out;
2277         skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
2278         if (!skb)
2279                 goto out;
2280
2281         skb_orphan(skb);
2282
2283         type = skb->protocol;
2284         list_for_each_entry_rcu(ptype,
2285                         &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
2286                 if (ptype->type == type &&
2287                     (ptype->dev == null_or_orig || ptype->dev == skb->dev ||
2288                      ptype->dev == orig_dev)) {
2289                         if (pt_prev)
2290                                 ret = deliver_skb(skb, pt_prev, orig_dev);
2291                         pt_prev = ptype;
2292                 }
2293         }
2294
2295         if (pt_prev) {
2296                 ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
2297         } else {
2298                 kfree_skb(skb);
2299                 /* Jamal, now you will not able to escape explaining
2300                  * me how you were going to use this. :-)
2301                  */
2302                 ret = NET_RX_DROP;
2303         }
2304
2305 out:
2306         rcu_read_unlock();
2307         return ret;
2308 }
2309
2310 /* Network device is going away, flush any packets still pending  */
2311 static void flush_backlog(void *arg)
2312 {
2313         struct net_device *dev = arg;
2314         struct softnet_data *queue = &__get_cpu_var(softnet_data);
2315         struct sk_buff *skb, *tmp;
2316
2317         skb_queue_walk_safe(&queue->input_pkt_queue, skb, tmp)
2318                 if (skb->dev == dev) {
2319                         __skb_unlink(skb, &queue->input_pkt_queue);
2320                         kfree_skb(skb);
2321                 }
2322 }
2323
2324 static int napi_gro_complete(struct sk_buff *skb)
2325 {
2326         struct packet_type *ptype;
2327         __be16 type = skb->protocol;
2328         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
2329         int err = -ENOENT;
2330
2331         if (NAPI_GRO_CB(skb)->count == 1) {
2332                 skb_shinfo(skb)->gso_size = 0;
2333                 goto out;
2334         }
2335
2336         rcu_read_lock();
2337         list_for_each_entry_rcu(ptype, head, list) {
2338                 if (ptype->type != type || ptype->dev || !ptype->gro_complete)
2339                         continue;
2340
2341                 err = ptype->gro_complete(skb);
2342                 break;
2343         }
2344         rcu_read_unlock();
2345
2346         if (err) {
2347                 WARN_ON(&ptype->list == head);
2348                 kfree_skb(skb);
2349                 return NET_RX_SUCCESS;
2350         }
2351
2352 out:
2353         return netif_receive_skb(skb);
2354 }
2355
2356 void napi_gro_flush(struct napi_struct *napi)
2357 {
2358         struct sk_buff *skb, *next;
2359
2360         for (skb = napi->gro_list; skb; skb = next) {
2361                 next = skb->next;
2362                 skb->next = NULL;
2363                 napi_gro_complete(skb);
2364         }
2365
2366         napi->gro_count = 0;
2367         napi->gro_list = NULL;
2368 }
2369 EXPORT_SYMBOL(napi_gro_flush);
2370
2371 void *skb_gro_header(struct sk_buff *skb, unsigned int hlen)
2372 {
2373         unsigned int offset = skb_gro_offset(skb);
2374
2375         hlen += offset;
2376         if (hlen <= skb_headlen(skb))
2377                 return skb->data + offset;
2378
2379         if (unlikely(!skb_shinfo(skb)->nr_frags ||
2380                      skb_shinfo(skb)->frags[0].size <=
2381                      hlen - skb_headlen(skb) ||
2382                      PageHighMem(skb_shinfo(skb)->frags[0].page)))
2383                 return pskb_may_pull(skb, hlen) ? skb->data + offset : NULL;
2384
2385         return page_address(skb_shinfo(skb)->frags[0].page) +
2386                skb_shinfo(skb)->frags[0].page_offset +
2387                offset - skb_headlen(skb);
2388 }
2389 EXPORT_SYMBOL(skb_gro_header);
2390
2391 int dev_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
2392 {
2393         struct sk_buff **pp = NULL;
2394         struct packet_type *ptype;
2395         __be16 type = skb->protocol;
2396         struct list_head *head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK];
2397         int same_flow;
2398         int mac_len;
2399         int ret;
2400
2401         if (!(skb->dev->features & NETIF_F_GRO))
2402                 goto normal;
2403
2404         if (skb_is_gso(skb) || skb_shinfo(skb)->frag_list)
2405                 goto normal;
2406
2407         rcu_read_lock();
2408         list_for_each_entry_rcu(ptype, head, list) {
2409                 if (ptype->type != type || ptype->dev || !ptype->gro_receive)
2410                         continue;
2411
2412                 skb_set_network_header(skb, skb_gro_offset(skb));
2413                 mac_len = skb->network_header - skb->mac_header;
2414                 skb->mac_len = mac_len;
2415                 NAPI_GRO_CB(skb)->same_flow = 0;
2416                 NAPI_GRO_CB(skb)->flush = 0;
2417                 NAPI_GRO_CB(skb)->free = 0;
2418
2419                 pp = ptype->gro_receive(&napi->gro_list, skb);
2420                 break;
2421         }
2422         rcu_read_unlock();
2423
2424         if (&ptype->list == head)
2425                 goto normal;
2426
2427         same_flow = NAPI_GRO_CB(skb)->same_flow;
2428         ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED;
2429
2430         if (pp) {
2431                 struct sk_buff *nskb = *pp;
2432
2433                 *pp = nskb->next;
2434                 nskb->next = NULL;
2435                 napi_gro_complete(nskb);
2436                 napi->gro_count--;
2437         }
2438
2439         if (same_flow)
2440                 goto ok;
2441
2442         if (NAPI_GRO_CB(skb)->flush || napi->gro_count >= MAX_GRO_SKBS)
2443                 goto normal;
2444
2445         napi->gro_count++;
2446         NAPI_GRO_CB(skb)->count = 1;
2447         skb_shinfo(skb)->gso_size = skb_gro_len(skb);
2448         skb->next = napi->gro_list;
2449         napi->gro_list = skb;
2450         ret = GRO_HELD;
2451
2452 pull:
2453         if (unlikely(!pskb_may_pull(skb, skb_gro_offset(skb)))) {
2454                 if (napi->gro_list == skb)
2455                         napi->gro_list = skb->next;
2456                 ret = GRO_DROP;
2457         }
2458
2459 ok:
2460         return ret;
2461
2462 normal:
2463         ret = GRO_NORMAL;
2464         goto pull;
2465 }
2466 EXPORT_SYMBOL(dev_gro_receive);
2467
2468 static int __napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
2469 {
2470         struct sk_buff *p;
2471
2472         if (netpoll_rx_on(skb))
2473                 return GRO_NORMAL;
2474
2475         for (p = napi->gro_list; p; p = p->next) {
2476                 NAPI_GRO_CB(p)->same_flow = (p->dev == skb->dev)
2477                         && !compare_ether_header(skb_mac_header(p),
2478                                                  skb_gro_mac_header(skb));
2479                 NAPI_GRO_CB(p)->flush = 0;
2480         }
2481
2482         return dev_gro_receive(napi, skb);
2483 }
2484
2485 int napi_skb_finish(int ret, struct sk_buff *skb)
2486 {
2487         int err = NET_RX_SUCCESS;
2488
2489         switch (ret) {
2490         case GRO_NORMAL:
2491                 return netif_receive_skb(skb);
2492
2493         case GRO_DROP:
2494                 err = NET_RX_DROP;
2495                 /* fall through */
2496
2497         case GRO_MERGED_FREE:
2498                 kfree_skb(skb);
2499                 break;
2500         }
2501
2502         return err;
2503 }
2504 EXPORT_SYMBOL(napi_skb_finish);
2505
2506 int napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
2507 {
2508         skb_gro_reset_offset(skb);
2509
2510         return napi_skb_finish(__napi_gro_receive(napi, skb), skb);
2511 }
2512 EXPORT_SYMBOL(napi_gro_receive);
2513
2514 void napi_reuse_skb(struct napi_struct *napi, struct sk_buff *skb)
2515 {
2516         __skb_pull(skb, skb_headlen(skb));
2517         skb_reserve(skb, NET_IP_ALIGN - skb_headroom(skb));
2518
2519         napi->skb = skb;
2520 }
2521 EXPORT_SYMBOL(napi_reuse_skb);
2522
2523 struct sk_buff *napi_fraginfo_skb(struct napi_struct *napi,
2524                                   struct napi_gro_fraginfo *info)
2525 {
2526         struct net_device *dev = napi->dev;
2527         struct sk_buff *skb = napi->skb;
2528         struct ethhdr *eth;
2529         skb_frag_t *frag;
2530         int i;
2531
2532         napi->skb = NULL;
2533
2534         if (!skb) {
2535                 skb = netdev_alloc_skb(dev, GRO_MAX_HEAD + NET_IP_ALIGN);
2536                 if (!skb)
2537                         goto out;
2538
2539                 skb_reserve(skb, NET_IP_ALIGN);
2540         }
2541
2542         BUG_ON(info->nr_frags > MAX_SKB_FRAGS);
2543         frag = &info->frags[info->nr_frags - 1];
2544
2545         for (i = skb_shinfo(skb)->nr_frags; i < info->nr_frags; i++) {
2546                 skb_fill_page_desc(skb, i, frag->page, frag->page_offset,
2547                                    frag->size);
2548                 frag++;
2549         }
2550         skb_shinfo(skb)->nr_frags = info->nr_frags;
2551
2552         skb->data_len = info->len;
2553         skb->len += info->len;
2554         skb->truesize += info->len;
2555
2556         skb_reset_mac_header(skb);
2557         skb_gro_reset_offset(skb);
2558
2559         eth = skb_gro_header(skb, sizeof(*eth));
2560         if (!eth) {
2561                 napi_reuse_skb(napi, skb);
2562                 skb = NULL;
2563                 goto out;
2564         }
2565
2566         skb_gro_pull(skb, sizeof(*eth));
2567
2568         /*
2569          * This works because the only protocols we care about don't require
2570          * special handling.  We'll fix it up properly at the end.
2571          */
2572         skb->protocol = eth->h_proto;
2573
2574         skb->ip_summed = info->ip_summed;
2575         skb->csum = info->csum;
2576
2577 out:
2578         return skb;
2579 }
2580 EXPORT_SYMBOL(napi_fraginfo_skb);
2581
2582 int napi_frags_finish(struct napi_struct *napi, struct sk_buff *skb, int ret)
2583 {
2584         int err = NET_RX_SUCCESS;
2585
2586         switch (ret) {
2587         case GRO_NORMAL:
2588         case GRO_HELD:
2589                 skb->protocol = eth_type_trans(skb, napi->dev);
2590
2591                 if (ret == GRO_NORMAL)
2592                         return netif_receive_skb(skb);
2593
2594                 skb_gro_pull(skb, -ETH_HLEN);
2595                 break;
2596
2597         case GRO_DROP:
2598                 err = NET_RX_DROP;
2599                 /* fall through */
2600
2601         case GRO_MERGED_FREE:
2602                 napi_reuse_skb(napi, skb);
2603                 break;
2604         }
2605
2606         return err;
2607 }
2608 EXPORT_SYMBOL(napi_frags_finish);
2609
2610 int napi_gro_frags(struct napi_struct *napi, struct napi_gro_fraginfo *info)
2611 {
2612         struct sk_buff *skb = napi_fraginfo_skb(napi, info);
2613
2614         if (!skb)
2615                 return NET_RX_DROP;
2616
2617         return napi_frags_finish(napi, skb, __napi_gro_receive(napi, skb));
2618 }
2619 EXPORT_SYMBOL(napi_gro_frags);
2620
2621 static int process_backlog(struct napi_struct *napi, int quota)
2622 {
2623         int work = 0;
2624         struct softnet_data *queue = &__get_cpu_var(softnet_data);
2625         unsigned long start_time = jiffies;
2626
2627         napi->weight = weight_p;
2628         do {
2629                 struct sk_buff *skb;
2630
2631                 local_irq_disable();
2632                 skb = __skb_dequeue(&queue->input_pkt_queue);
2633                 if (!skb) {
2634                         __napi_complete(napi);
2635                         local_irq_enable();
2636                         break;
2637                 }
2638                 local_irq_enable();
2639
2640                 netif_receive_skb(skb);
2641         } while (++work < quota && jiffies == start_time);
2642
2643         return work;
2644 }
2645
2646 /**
2647  * __napi_schedule - schedule for receive
2648  * @n: entry to schedule
2649  *
2650  * The entry's receive function will be scheduled to run
2651  */
2652 void __napi_schedule(struct napi_struct *n)
2653 {
2654         unsigned long flags;
2655
2656         local_irq_save(flags);
2657         list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list);
2658         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2659         local_irq_restore(flags);
2660 }
2661 EXPORT_SYMBOL(__napi_schedule);
2662
2663 void __napi_complete(struct napi_struct *n)
2664 {
2665         BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
2666         BUG_ON(n->gro_list);
2667
2668         list_del(&n->poll_list);
2669         smp_mb__before_clear_bit();
2670         clear_bit(NAPI_STATE_SCHED, &n->state);
2671 }
2672 EXPORT_SYMBOL(__napi_complete);
2673
2674 void napi_complete(struct napi_struct *n)
2675 {
2676         unsigned long flags;
2677
2678         /*
2679          * don't let napi dequeue from the cpu poll list
2680          * just in case its running on a different cpu
2681          */
2682         if (unlikely(test_bit(NAPI_STATE_NPSVC, &n->state)))
2683                 return;
2684
2685         napi_gro_flush(n);
2686         local_irq_save(flags);
2687         __napi_complete(n);
2688         local_irq_restore(flags);
2689 }
2690 EXPORT_SYMBOL(napi_complete);
2691
2692 void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
2693                     int (*poll)(struct napi_struct *, int), int weight)
2694 {
2695         INIT_LIST_HEAD(&napi->poll_list);
2696         napi->gro_count = 0;
2697         napi->gro_list = NULL;
2698         napi->skb = NULL;
2699         napi->poll = poll;
2700         napi->weight = weight;
2701         list_add(&napi->dev_list, &dev->napi_list);
2702         napi->dev = dev;
2703 #ifdef CONFIG_NETPOLL
2704         spin_lock_init(&napi->poll_lock);
2705         napi->poll_owner = -1;
2706 #endif
2707         set_bit(NAPI_STATE_SCHED, &napi->state);
2708 }
2709 EXPORT_SYMBOL(netif_napi_add);
2710
2711 void netif_napi_del(struct napi_struct *napi)
2712 {
2713         struct sk_buff *skb, *next;
2714
2715         list_del_init(&napi->dev_list);
2716         kfree_skb(napi->skb);
2717
2718         for (skb = napi->gro_list; skb; skb = next) {
2719                 next = skb->next;
2720                 skb->next = NULL;
2721                 kfree_skb(skb);
2722         }
2723
2724         napi->gro_list = NULL;
2725         napi->gro_count = 0;
2726 }
2727 EXPORT_SYMBOL(netif_napi_del);
2728
2729
2730 static void net_rx_action(struct softirq_action *h)
2731 {
2732         struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
2733         unsigned long time_limit = jiffies + 2;
2734         int budget = netdev_budget;
2735         void *have;
2736
2737         local_irq_disable();
2738
2739         while (!list_empty(list)) {
2740                 struct napi_struct *n;
2741                 int work, weight;
2742
2743                 /* If softirq window is exhuasted then punt.
2744                  * Allow this to run for 2 jiffies since which will allow
2745                  * an average latency of 1.5/HZ.
2746                  */
2747                 if (unlikely(budget <= 0 || time_after(jiffies, time_limit)))
2748                         goto softnet_break;
2749
2750                 local_irq_enable();
2751
2752                 /* Even though interrupts have been re-enabled, this
2753                  * access is safe because interrupts can only add new
2754                  * entries to the tail of this list, and only ->poll()
2755                  * calls can remove this head entry from the list.
2756                  */
2757                 n = list_entry(list->next, struct napi_struct, poll_list);
2758
2759                 have = netpoll_poll_lock(n);
2760
2761                 weight = n->weight;
2762
2763                 /* This NAPI_STATE_SCHED test is for avoiding a race
2764                  * with netpoll's poll_napi().  Only the entity which
2765                  * obtains the lock and sees NAPI_STATE_SCHED set will
2766                  * actually make the ->poll() call.  Therefore we avoid
2767                  * accidently calling ->poll() when NAPI is not scheduled.
2768                  */
2769                 work = 0;
2770                 if (test_bit(NAPI_STATE_SCHED, &n->state))
2771                         work = n->poll(n, weight);
2772
2773                 WARN_ON_ONCE(work > weight);
2774
2775                 budget -= work;
2776
2777                 local_irq_disable();
2778
2779                 /* Drivers must not modify the NAPI state if they
2780                  * consume the entire weight.  In such cases this code
2781                  * still "owns" the NAPI instance and therefore can
2782                  * move the instance around on the list at-will.
2783                  */
2784                 if (unlikely(work == weight)) {
2785                         if (unlikely(napi_disable_pending(n)))
2786                                 __napi_complete(n);
2787                         else
2788                                 list_move_tail(&n->poll_list, list);
2789                 }
2790
2791                 netpoll_poll_unlock(have);
2792         }
2793 out:
2794         local_irq_enable();
2795
2796 #ifdef CONFIG_NET_DMA
2797         /*
2798          * There may not be any more sk_buffs coming right now, so push
2799          * any pending DMA copies to hardware
2800          */
2801         dma_issue_pending_all();
2802 #endif
2803
2804         return;
2805
2806 softnet_break:
2807         __get_cpu_var(netdev_rx_stat).time_squeeze++;
2808         __raise_softirq_irqoff(NET_RX_SOFTIRQ);
2809         goto out;
2810 }
2811
2812 static gifconf_func_t * gifconf_list [NPROTO];
2813
2814 /**
2815  *      register_gifconf        -       register a SIOCGIF handler
2816  *      @family: Address family
2817  *      @gifconf: Function handler
2818  *
2819  *      Register protocol dependent address dumping routines. The handler
2820  *      that is passed must not be freed or reused until it has been replaced
2821  *      by another handler.
2822  */
2823 int register_gifconf(unsigned int family, gifconf_func_t * gifconf)
2824 {
2825         if (family >= NPROTO)
2826                 return -EINVAL;
2827         gifconf_list[family] = gifconf;
2828         return 0;
2829 }
2830
2831
2832 /*
2833  *      Map an interface index to its name (SIOCGIFNAME)
2834  */
2835
2836 /*
2837  *      We need this ioctl for efficient implementation of the
2838  *      if_indextoname() function required by the IPv6 API.  Without
2839  *      it, we would have to search all the interfaces to find a
2840  *      match.  --pb
2841  */
2842
2843 static int dev_ifname(struct net *net, struct ifreq __user *arg)
2844 {
2845         struct net_device *dev;
2846         struct ifreq ifr;
2847
2848         /*
2849          *      Fetch the caller's info block.
2850          */
2851
2852         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
2853                 return -EFAULT;
2854
2855         read_lock(&dev_base_lock);
2856         dev = __dev_get_by_index(net, ifr.ifr_ifindex);
2857         if (!dev) {
2858                 read_unlock(&dev_base_lock);
2859                 return -ENODEV;
2860         }
2861
2862         strcpy(ifr.ifr_name, dev->name);
2863         read_unlock(&dev_base_lock);
2864
2865         if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
2866                 return -EFAULT;
2867         return 0;
2868 }
2869
2870 /*
2871  *      Perform a SIOCGIFCONF call. This structure will change
2872  *      size eventually, and there is nothing I can do about it.
2873  *      Thus we will need a 'compatibility mode'.
2874  */
2875
2876 static int dev_ifconf(struct net *net, char __user *arg)
2877 {
2878         struct ifconf ifc;
2879         struct net_device *dev;
2880         char __user *pos;
2881         int len;
2882         int total;
2883         int i;
2884
2885         /*
2886          *      Fetch the caller's info block.
2887          */
2888
2889         if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
2890                 return -EFAULT;
2891
2892         pos = ifc.ifc_buf;
2893         len = ifc.ifc_len;
2894
2895         /*
2896          *      Loop over the interfaces, and write an info block for each.
2897          */
2898
2899         total = 0;
2900         for_each_netdev(net, dev) {
2901                 for (i = 0; i < NPROTO; i++) {
2902                         if (gifconf_list[i]) {
2903                                 int done;
2904                                 if (!pos)
2905                                         done = gifconf_list[i](dev, NULL, 0);
2906                                 else
2907                                         done = gifconf_list[i](dev, pos + total,
2908                                                                len - total);
2909                                 if (done < 0)
2910                                         return -EFAULT;
2911                                 total += done;
2912                         }
2913                 }
2914         }
2915
2916         /*
2917          *      All done.  Write the updated control block back to the caller.
2918          */
2919         ifc.ifc_len = total;
2920
2921         /*
2922          *      Both BSD and Solaris return 0 here, so we do too.
2923          */
2924         return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
2925 }
2926
2927 #ifdef CONFIG_PROC_FS
2928 /*
2929  *      This is invoked by the /proc filesystem handler to display a device
2930  *      in detail.
2931  */
2932 void *dev_seq_start(struct seq_file *seq, loff_t *pos)
2933         __acquires(dev_base_lock)
2934 {
2935         struct net *net = seq_file_net(seq);
2936         loff_t off;
2937         struct net_device *dev;
2938
2939         read_lock(&dev_base_lock);
2940         if (!*pos)
2941                 return SEQ_START_TOKEN;
2942
2943         off = 1;
2944         for_each_netdev(net, dev)
2945                 if (off++ == *pos)
2946                         return dev;
2947
2948         return NULL;
2949 }
2950
2951 void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2952 {
2953         struct net *net = seq_file_net(seq);
2954         ++*pos;
2955         return v == SEQ_START_TOKEN ?
2956                 first_net_device(net) : next_net_device((struct net_device *)v);
2957 }
2958
2959 void dev_seq_stop(struct seq_file *seq, void *v)
2960         __releases(dev_base_lock)
2961 {
2962         read_unlock(&dev_base_lock);
2963 }
2964
2965 static void dev_seq_printf_stats(struct seq_file *seq, struct net_device *dev)
2966 {
2967         const struct net_device_stats *stats = dev_get_stats(dev);
2968
2969         seq_printf(seq, "%6s:%8lu %7lu %4lu %4lu %4lu %5lu %10lu %9lu "
2970                    "%8lu %7lu %4lu %4lu %4lu %5lu %7lu %10lu\n",
2971                    dev->name, stats->rx_bytes, stats->rx_packets,
2972                    stats->rx_errors,
2973                    stats->rx_dropped + stats->rx_missed_errors,
2974                    stats->rx_fifo_errors,
2975                    stats->rx_length_errors + stats->rx_over_errors +
2976                     stats->rx_crc_errors + stats->rx_frame_errors,
2977                    stats->rx_compressed, stats->multicast,
2978                    stats->tx_bytes, stats->tx_packets,
2979                    stats->tx_errors, stats->tx_dropped,
2980                    stats->tx_fifo_errors, stats->collisions,
2981                    stats->tx_carrier_errors +
2982                     stats->tx_aborted_errors +
2983                     stats->tx_window_errors +
2984                     stats->tx_heartbeat_errors,
2985                    stats->tx_compressed);
2986 }
2987
2988 /*
2989  *      Called from the PROCfs module. This now uses the new arbitrary sized
2990  *      /proc/net interface to create /proc/net/dev
2991  */
2992 static int dev_seq_show(struct seq_file *seq, void *v)
2993 {
2994         if (v == SEQ_START_TOKEN)
2995                 seq_puts(seq, "Inter-|   Receive                            "
2996                               "                    |  Transmit\n"
2997                               " face |bytes    packets errs drop fifo frame "
2998                               "compressed multicast|bytes    packets errs "
2999                               "drop fifo colls carrier compressed\n");
3000         else
3001                 dev_seq_printf_stats(seq, v);
3002         return 0;
3003 }
3004
3005 static struct netif_rx_stats *softnet_get_online(loff_t *pos)
3006 {
3007         struct netif_rx_stats *rc = NULL;
3008
3009         while (*pos < nr_cpu_ids)
3010                 if (cpu_online(*pos)) {
3011                         rc = &per_cpu(netdev_rx_stat, *pos);
3012                         break;
3013                 } else
3014                         ++*pos;
3015         return rc;
3016 }
3017
3018 static void *softnet_seq_start(struct seq_file *seq, loff_t *pos)
3019 {
3020         return softnet_get_online(pos);
3021 }
3022
3023 static void *softnet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3024 {
3025         ++*pos;
3026         return softnet_get_online(pos);
3027 }
3028
3029 static void softnet_seq_stop(struct seq_file *seq, void *v)
3030 {
3031 }
3032
3033 static int softnet_seq_show(struct seq_file *seq, void *v)
3034 {
3035         struct netif_rx_stats *s = v;
3036
3037         seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x\n",
3038                    s->total, s->dropped, s->time_squeeze, 0,
3039                    0, 0, 0, 0, /* was fastroute */
3040                    s->cpu_collision );
3041         return 0;
3042 }
3043
3044 static const struct seq_operations dev_seq_ops = {
3045         .start = dev_seq_start,
3046         .next  = dev_seq_next,
3047         .stop  = dev_seq_stop,
3048         .show  = dev_seq_show,
3049 };
3050
3051 static int dev_seq_open(struct inode *inode, struct file *file)
3052 {
3053         return seq_open_net(inode, file, &dev_seq_ops,
3054                             sizeof(struct seq_net_private));
3055 }
3056
3057 static const struct file_operations dev_seq_fops = {
3058         .owner   = THIS_MODULE,
3059         .open    = dev_seq_open,
3060         .read    = seq_read,
3061         .llseek  = seq_lseek,
3062         .release = seq_release_net,
3063 };
3064
3065 static const struct seq_operations softnet_seq_ops = {
3066         .start = softnet_seq_start,
3067         .next  = softnet_seq_next,
3068         .stop  = softnet_seq_stop,
3069         .show  = softnet_seq_show,
3070 };
3071
3072 static int softnet_seq_open(struct inode *inode, struct file *file)
3073 {
3074         return seq_open(file, &softnet_seq_ops);
3075 }
3076
3077 static const struct file_operations softnet_seq_fops = {
3078         .owner   = THIS_MODULE,
3079         .open    = softnet_seq_open,
3080         .read    = seq_read,
3081         .llseek  = seq_lseek,
3082         .release = seq_release,
3083 };
3084
3085 static void *ptype_get_idx(loff_t pos)
3086 {
3087         struct packet_type *pt = NULL;
3088         loff_t i = 0;
3089         int t;
3090
3091         list_for_each_entry_rcu(pt, &ptype_all, list) {
3092                 if (i == pos)
3093                         return pt;
3094                 ++i;
3095         }
3096
3097         for (t = 0; t < PTYPE_HASH_SIZE; t++) {
3098                 list_for_each_entry_rcu(pt, &ptype_base[t], list) {
3099                         if (i == pos)
3100                                 return pt;
3101                         ++i;
3102                 }
3103         }
3104         return NULL;
3105 }
3106
3107 static void *ptype_seq_start(struct seq_file *seq, loff_t *pos)
3108         __acquires(RCU)
3109 {
3110         rcu_read_lock();
3111         return *pos ? ptype_get_idx(*pos - 1) : SEQ_START_TOKEN;
3112 }
3113
3114 static void *ptype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3115 {
3116         struct packet_type *pt;
3117         struct list_head *nxt;
3118         int hash;
3119
3120         ++*pos;
3121         if (v == SEQ_START_TOKEN)
3122                 return ptype_get_idx(0);
3123
3124         pt = v;
3125         nxt = pt->list.next;
3126         if (pt->type == htons(ETH_P_ALL)) {
3127                 if (nxt != &ptype_all)
3128                         goto found;
3129                 hash = 0;
3130                 nxt = ptype_base[0].next;
3131         } else
3132                 hash = ntohs(pt->type) & PTYPE_HASH_MASK;
3133
3134         while (nxt == &ptype_base[hash]) {
3135                 if (++hash >= PTYPE_HASH_SIZE)
3136                         return NULL;
3137                 nxt = ptype_base[hash].next;
3138         }
3139 found:
3140         return list_entry(nxt, struct packet_type, list);
3141 }
3142
3143 static void ptype_seq_stop(struct seq_file *seq, void *v)
3144         __releases(RCU)
3145 {
3146         rcu_read_unlock();
3147 }
3148
3149 static int ptype_seq_show(struct seq_file *seq, void *v)
3150 {
3151         struct packet_type *pt = v;
3152
3153         if (v == SEQ_START_TOKEN)
3154                 seq_puts(seq, "Type Device      Function\n");
3155         else if (pt->dev == NULL || dev_net(pt->dev) == seq_file_net(seq)) {
3156                 if (pt->type == htons(ETH_P_ALL))
3157                         seq_puts(seq, "ALL ");
3158                 else
3159                         seq_printf(seq, "%04x", ntohs(pt->type));
3160
3161                 seq_printf(seq, " %-8s %pF\n",
3162                            pt->dev ? pt->dev->name : "", pt->func);
3163         }
3164
3165         return 0;
3166 }
3167
3168 static const struct seq_operations ptype_seq_ops = {
3169         .start = ptype_seq_start,
3170         .next  = ptype_seq_next,
3171         .stop  = ptype_seq_stop,
3172         .show  = ptype_seq_show,
3173 };
3174
3175 static int ptype_seq_open(struct inode *inode, struct file *file)
3176 {
3177         return seq_open_net(inode, file, &ptype_seq_ops,
3178                         sizeof(struct seq_net_private));
3179 }
3180
3181 static const struct file_operations ptype_seq_fops = {
3182         .owner   = THIS_MODULE,
3183         .open    = ptype_seq_open,
3184         .read    = seq_read,
3185         .llseek  = seq_lseek,
3186         .release = seq_release_net,
3187 };
3188
3189
3190 static int __net_init dev_proc_net_init(struct net *net)
3191 {
3192         int rc = -ENOMEM;
3193
3194         if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops))
3195                 goto out;
3196         if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops))
3197                 goto out_dev;
3198         if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops))
3199                 goto out_softnet;
3200
3201         if (wext_proc_init(net))
3202                 goto out_ptype;
3203         rc = 0;
3204 out:
3205         return rc;
3206 out_ptype:
3207         proc_net_remove(net, "ptype");
3208 out_softnet:
3209         proc_net_remove(net, "softnet_stat");
3210 out_dev:
3211         proc_net_remove(net, "dev");
3212         goto out;
3213 }
3214
3215 static void __net_exit dev_proc_net_exit(struct net *net)
3216 {
3217         wext_proc_exit(net);
3218
3219         proc_net_remove(net, "ptype");
3220         proc_net_remove(net, "softnet_stat");
3221         proc_net_remove(net, "dev");
3222 }
3223
3224 static struct pernet_operations __net_initdata dev_proc_ops = {
3225         .init = dev_proc_net_init,
3226         .exit = dev_proc_net_exit,
3227 };
3228
3229 static int __init dev_proc_init(void)
3230 {
3231         return register_pernet_subsys(&dev_proc_ops);
3232 }
3233 #else
3234 #define dev_proc_init() 0
3235 #endif  /* CONFIG_PROC_FS */
3236
3237
3238 /**
3239  *      netdev_set_master       -       set up master/slave pair
3240  *      @slave: slave device
3241  *      @master: new master device
3242  *
3243  *      Changes the master device of the slave. Pass %NULL to break the
3244  *      bonding. The caller must hold the RTNL semaphore. On a failure
3245  *      a negative errno code is returned. On success the reference counts
3246  *      are adjusted, %RTM_NEWLINK is sent to the routing socket and the
3247  *      function returns zero.
3248  */
3249 int netdev_set_master(struct net_device *slave, struct net_device *master)
3250 {
3251         struct net_device *old = slave->master;
3252
3253         ASSERT_RTNL();
3254
3255         if (master) {
3256                 if (old)
3257                         return -EBUSY;
3258                 dev_hold(master);
3259         }
3260
3261         slave->master = master;
3262
3263         synchronize_net();
3264
3265         if (old)
3266                 dev_put(old);
3267
3268         if (master)
3269                 slave->flags |= IFF_SLAVE;
3270         else
3271                 slave->flags &= ~IFF_SLAVE;
3272
3273         rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE);
3274         return 0;
3275 }
3276
3277 static void dev_change_rx_flags(struct net_device *dev, int flags)
3278 {
3279         const struct net_device_ops *ops = dev->netdev_ops;
3280
3281         if ((dev->flags & IFF_UP) && ops->ndo_change_rx_flags)
3282                 ops->ndo_change_rx_flags(dev, flags);
3283 }
3284
3285 static int __dev_set_promiscuity(struct net_device *dev, int inc)
3286 {
3287         unsigned short old_flags = dev->flags;
3288         uid_t uid;
3289         gid_t gid;
3290
3291         ASSERT_RTNL();
3292
3293         dev->flags |= IFF_PROMISC;
3294         dev->promiscuity += inc;
3295         if (dev->promiscuity == 0) {
3296                 /*
3297                  * Avoid overflow.
3298                  * If inc causes overflow, untouch promisc and return error.
3299                  */
3300                 if (inc < 0)
3301                         dev->flags &= ~IFF_PROMISC;
3302                 else {
3303                         dev->promiscuity -= inc;
3304                         printk(KERN_WARNING "%s: promiscuity touches roof, "
3305                                 "set promiscuity failed, promiscuity feature "
3306                                 "of device might be broken.\n", dev->name);
3307                         return -EOVERFLOW;
3308                 }
3309         }
3310         if (dev->flags != old_flags) {
3311                 printk(KERN_INFO "device %s %s promiscuous mode\n",
3312                        dev->name, (dev->flags & IFF_PROMISC) ? "entered" :
3313                                                                "left");
3314                 if (audit_enabled) {
3315                         current_uid_gid(&uid, &gid);
3316                         audit_log(current->audit_context, GFP_ATOMIC,
3317                                 AUDIT_ANOM_PROMISCUOUS,
3318                                 "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u",
3319                                 dev->name, (dev->flags & IFF_PROMISC),
3320                                 (old_flags & IFF_PROMISC),
3321                                 audit_get_loginuid(current),
3322                                 uid, gid,
3323                                 audit_get_sessionid(current));
3324                 }
3325
3326                 dev_change_rx_flags(dev, IFF_PROMISC);
3327         }
3328         return 0;
3329 }
3330
3331 /**
3332  *      dev_set_promiscuity     - update promiscuity count on a device
3333  *      @dev: device
3334  *      @inc: modifier
3335  *
3336  *      Add or remove promiscuity from a device. While the count in the device
3337  *      remains above zero the interface remains promiscuous. Once it hits zero
3338  *      the device reverts back to normal filtering operation. A negative inc
3339  *      value is used to drop promiscuity on the device.
3340  *      Return 0 if successful or a negative errno code on error.
3341  */
3342 int dev_set_promiscuity(struct net_device *dev, int inc)
3343 {
3344         unsigned short old_flags = dev->flags;
3345         int err;
3346
3347         err = __dev_set_promiscuity(dev, inc);
3348         if (err < 0)
3349                 return err;
3350         if (dev->flags != old_flags)
3351                 dev_set_rx_mode(dev);
3352         return err;
3353 }
3354
3355 /**
3356  *      dev_set_allmulti        - update allmulti count on a device
3357  *      @dev: device
3358  *      @inc: modifier
3359  *
3360  *      Add or remove reception of all multicast frames to a device. While the
3361  *      count in the device remains above zero the interface remains listening
3362  *      to all interfaces. Once it hits zero the device reverts back to normal
3363  *      filtering operation. A negative @inc value is used to drop the counter
3364  *      when releasing a resource needing all multicasts.
3365  *      Return 0 if successful or a negative errno code on error.
3366  */
3367
3368 int dev_set_allmulti(struct net_device *dev, int inc)
3369 {
3370         unsigned short old_flags = dev->flags;
3371
3372         ASSERT_RTNL();
3373
3374         dev->flags |= IFF_ALLMULTI;
3375         dev->allmulti += inc;
3376         if (dev->allmulti == 0) {
3377                 /*
3378                  * Avoid overflow.
3379                  * If inc causes overflow, untouch allmulti and return error.
3380                  */
3381                 if (inc < 0)
3382                         dev->flags &= ~IFF_ALLMULTI;
3383                 else {
3384                         dev->allmulti -= inc;
3385                         printk(KERN_WARNING "%s: allmulti touches roof, "
3386                                 "set allmulti failed, allmulti feature of "
3387                                 "device might be broken.\n", dev->name);
3388                         return -EOVERFLOW;
3389                 }
3390         }
3391         if (dev->flags ^ old_flags) {
3392                 dev_change_rx_flags(dev, IFF_ALLMULTI);
3393                 dev_set_rx_mode(dev);
3394         }
3395         return 0;
3396 }
3397
3398 /*
3399  *      Upload unicast and multicast address lists to device and
3400  *      configure RX filtering. When the device doesn't support unicast
3401  *      filtering it is put in promiscuous mode while unicast addresses
3402  *      are present.
3403  */
3404 void __dev_set_rx_mode(struct net_device *dev)
3405 {
3406         const struct net_device_ops *ops = dev->netdev_ops;
3407
3408         /* dev_open will call this function so the list will stay sane. */
3409         if (!(dev->flags&IFF_UP))
3410                 return;
3411
3412         if (!netif_device_present(dev))
3413                 return;
3414
3415         if (ops->ndo_set_rx_mode)
3416                 ops->ndo_set_rx_mode(dev);
3417         else {
3418                 /* Unicast addresses changes may only happen under the rtnl,
3419                  * therefore calling __dev_set_promiscuity here is safe.
3420                  */
3421                 if (dev->uc_count > 0 && !dev->uc_promisc) {
3422                         __dev_set_promiscuity(dev, 1);
3423                         dev->uc_promisc = 1;
3424                 } else if (dev->uc_count == 0 && dev->uc_promisc) {
3425                         __dev_set_promiscuity(dev, -1);
3426                         dev->uc_promisc = 0;
3427                 }
3428
3429                 if (ops->ndo_set_multicast_list)
3430                         ops->ndo_set_multicast_list(dev);
3431         }
3432 }
3433
3434 void dev_set_rx_mode(struct net_device *dev)
3435 {
3436         netif_addr_lock_bh(dev);
3437         __dev_set_rx_mode(dev);
3438         netif_addr_unlock_bh(dev);
3439 }
3440
3441 int __dev_addr_delete(struct dev_addr_list **list, int *count,
3442                       void *addr, int alen, int glbl)
3443 {
3444         struct dev_addr_list *da;
3445
3446         for (; (da = *list) != NULL; list = &da->next) {
3447                 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3448                     alen == da->da_addrlen) {
3449                         if (glbl) {
3450                                 int old_glbl = da->da_gusers;
3451                                 da->da_gusers = 0;
3452                                 if (old_glbl == 0)
3453                                         break;
3454                         }
3455                         if (--da->da_users)
3456                                 return 0;
3457
3458                         *list = da->next;
3459                         kfree(da);
3460                         (*count)--;
3461                         return 0;
3462                 }
3463         }
3464         return -ENOENT;
3465 }
3466
3467 int __dev_addr_add(struct dev_addr_list **list, int *count,
3468                    void *addr, int alen, int glbl)
3469 {
3470         struct dev_addr_list *da;
3471
3472         for (da = *list; da != NULL; da = da->next) {
3473                 if (memcmp(da->da_addr, addr, da->da_addrlen) == 0 &&
3474                     da->da_addrlen == alen) {
3475                         if (glbl) {
3476                                 int old_glbl = da->da_gusers;
3477                                 da->da_gusers = 1;
3478                                 if (old_glbl)
3479                                         return 0;
3480                         }
3481                         da->da_users++;
3482                         return 0;
3483                 }
3484         }
3485
3486         da = kzalloc(sizeof(*da), GFP_ATOMIC);
3487         if (da == NULL)
3488                 return -ENOMEM;
3489         memcpy(da->da_addr, addr, alen);
3490         da->da_addrlen = alen;
3491         da->da_users = 1;
3492         da->da_gusers = glbl ? 1 : 0;
3493         da->next = *list;
3494         *list = da;
3495         (*count)++;
3496         return 0;
3497 }
3498
3499 /**
3500  *      dev_unicast_delete      - Release secondary unicast address.
3501  *      @dev: device
3502  *      @addr: address to delete
3503  *      @alen: length of @addr
3504  *
3505  *      Release reference to a secondary unicast address and remove it
3506  *      from the device if the reference count drops to zero.
3507  *
3508  *      The caller must hold the rtnl_mutex.
3509  */
3510 int dev_unicast_delete(struct net_device *dev, void *addr, int alen)
3511 {
3512         int err;
3513
3514         ASSERT_RTNL();
3515
3516         netif_addr_lock_bh(dev);
3517         err = __dev_addr_delete(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3518         if (!err)
3519                 __dev_set_rx_mode(dev);
3520         netif_addr_unlock_bh(dev);
3521         return err;
3522 }
3523 EXPORT_SYMBOL(dev_unicast_delete);
3524
3525 /**
3526  *      dev_unicast_add         - add a secondary unicast address
3527  *      @dev: device
3528  *      @addr: address to add
3529  *      @alen: length of @addr
3530  *
3531  *      Add a secondary unicast address to the device or increase
3532  *      the reference count if it already exists.
3533  *
3534  *      The caller must hold the rtnl_mutex.
3535  */
3536 int dev_unicast_add(struct net_device *dev, void *addr, int alen)
3537 {
3538         int err;
3539
3540         ASSERT_RTNL();
3541
3542         netif_addr_lock_bh(dev);
3543         err = __dev_addr_add(&dev->uc_list, &dev->uc_count, addr, alen, 0);
3544         if (!err)
3545                 __dev_set_rx_mode(dev);
3546         netif_addr_unlock_bh(dev);
3547         return err;
3548 }
3549 EXPORT_SYMBOL(dev_unicast_add);
3550
3551 int __dev_addr_sync(struct dev_addr_list **to, int *to_count,
3552                     struct dev_addr_list **from, int *from_count)
3553 {
3554         struct dev_addr_list *da, *next;
3555         int err = 0;
3556
3557         da = *from;
3558         while (da != NULL) {
3559                 next = da->next;
3560                 if (!da->da_synced) {
3561                         err = __dev_addr_add(to, to_count,
3562                                              da->da_addr, da->da_addrlen, 0);
3563                         if (err < 0)
3564                                 break;
3565                         da->da_synced = 1;
3566                         da->da_users++;
3567                 } else if (da->da_users == 1) {
3568                         __dev_addr_delete(to, to_count,
3569                                           da->da_addr, da->da_addrlen, 0);
3570                         __dev_addr_delete(from, from_count,
3571                                           da->da_addr, da->da_addrlen, 0);
3572                 }
3573                 da = next;
3574         }
3575         return err;
3576 }
3577
3578 void __dev_addr_unsync(struct dev_addr_list **to, int *to_count,
3579                        struct dev_addr_list **from, int *from_count)
3580 {
3581         struct dev_addr_list *da, *next;
3582
3583         da = *from;
3584         while (da != NULL) {
3585                 next = da->next;
3586                 if (da->da_synced) {
3587                         __dev_addr_delete(to, to_count,
3588                                           da->da_addr, da->da_addrlen, 0);
3589                         da->da_synced = 0;
3590                         __dev_addr_delete(from, from_count,
3591                                           da->da_addr, da->da_addrlen, 0);
3592                 }
3593                 da = next;
3594         }
3595 }
3596
3597 /**
3598  *      dev_unicast_sync - Synchronize device's unicast list to another device
3599  *      @to: destination device
3600  *      @from: source device
3601  *
3602  *      Add newly added addresses to the destination device and release
3603  *      addresses that have no users left. The source device must be
3604  *      locked by netif_tx_lock_bh.
3605  *
3606  *      This function is intended to be called from the dev->set_rx_mode
3607  *      function of layered software devices.
3608  */
3609 int dev_unicast_sync(struct net_device *to, struct net_device *from)
3610 {
3611         int err = 0;
3612
3613         netif_addr_lock_bh(to);
3614         err = __dev_addr_sync(&to->uc_list, &to->uc_count,
3615                               &from->uc_list, &from->uc_count);
3616         if (!err)
3617                 __dev_set_rx_mode(to);
3618         netif_addr_unlock_bh(to);
3619         return err;
3620 }
3621 EXPORT_SYMBOL(dev_unicast_sync);
3622
3623 /**
3624  *      dev_unicast_unsync - Remove synchronized addresses from the destination device
3625  *      @to: destination device
3626  *      @from: source device
3627  *
3628  *      Remove all addresses that were added to the destination device by
3629  *      dev_unicast_sync(). This function is intended to be called from the
3630  *      dev->stop function of layered software devices.
3631  */
3632 void dev_unicast_unsync(struct net_device *to, struct net_device *from)
3633 {
3634         netif_addr_lock_bh(from);
3635         netif_addr_lock(to);
3636
3637         __dev_addr_unsync(&to->uc_list, &to->uc_count,
3638                           &from->uc_list, &from->uc_count);
3639         __dev_set_rx_mode(to);
3640
3641         netif_addr_unlock(to);
3642         netif_addr_unlock_bh(from);
3643 }
3644 EXPORT_SYMBOL(dev_unicast_unsync);
3645
3646 static void __dev_addr_discard(struct dev_addr_list **list)
3647 {
3648         struct dev_addr_list *tmp;
3649
3650         while (*list != NULL) {
3651                 tmp = *list;
3652                 *list = tmp->next;
3653                 if (tmp->da_users > tmp->da_gusers)
3654                         printk("__dev_addr_discard: address leakage! "
3655                                "da_users=%d\n", tmp->da_users);
3656                 kfree(tmp);
3657         }
3658 }
3659
3660 static void dev_addr_discard(struct net_device *dev)
3661 {
3662         netif_addr_lock_bh(dev);
3663
3664         __dev_addr_discard(&dev->uc_list);
3665         dev->uc_count = 0;
3666
3667         __dev_addr_discard(&dev->mc_list);
3668         dev->mc_count = 0;
3669
3670         netif_addr_unlock_bh(dev);
3671 }
3672
3673 /**
3674  *      dev_get_flags - get flags reported to userspace
3675  *      @dev: device
3676  *
3677  *      Get the combination of flag bits exported through APIs to userspace.
3678  */
3679 unsigned dev_get_flags(const struct net_device *dev)
3680 {
3681         unsigned flags;
3682
3683         flags = (dev->flags & ~(IFF_PROMISC |
3684                                 IFF_ALLMULTI |
3685                                 IFF_RUNNING |
3686                                 IFF_LOWER_UP |
3687                                 IFF_DORMANT)) |
3688                 (dev->gflags & (IFF_PROMISC |
3689                                 IFF_ALLMULTI));
3690
3691         if (netif_running(dev)) {
3692                 if (netif_oper_up(dev))
3693                         flags |= IFF_RUNNING;
3694                 if (netif_carrier_ok(dev))
3695                         flags |= IFF_LOWER_UP;
3696                 if (netif_dormant(dev))
3697                         flags |= IFF_DORMANT;
3698         }
3699
3700         return flags;
3701 }
3702
3703 /**
3704  *      dev_change_flags - change device settings
3705  *      @dev: device
3706  *      @flags: device state flags
3707  *
3708  *      Change settings on device based state flags. The flags are
3709  *      in the userspace exported format.
3710  */
3711 int dev_change_flags(struct net_device *dev, unsigned flags)
3712 {
3713         int ret, changes;
3714         int old_flags = dev->flags;
3715
3716         ASSERT_RTNL();
3717
3718         /*
3719          *      Set the flags on our device.
3720          */
3721
3722         dev->flags = (flags & (IFF_DEBUG | IFF_NOTRAILERS | IFF_NOARP |
3723                                IFF_DYNAMIC | IFF_MULTICAST | IFF_PORTSEL |
3724                                IFF_AUTOMEDIA)) |
3725                      (dev->flags & (IFF_UP | IFF_VOLATILE | IFF_PROMISC |
3726                                     IFF_ALLMULTI));
3727
3728         /*
3729          *      Load in the correct multicast list now the flags have changed.
3730          */
3731
3732         if ((old_flags ^ flags) & IFF_MULTICAST)
3733                 dev_change_rx_flags(dev, IFF_MULTICAST);
3734
3735         dev_set_rx_mode(dev);
3736
3737         /*
3738          *      Have we downed the interface. We handle IFF_UP ourselves
3739          *      according to user attempts to set it, rather than blindly
3740          *      setting it.
3741          */
3742
3743         ret = 0;
3744         if ((old_flags ^ flags) & IFF_UP) {     /* Bit is different  ? */
3745                 ret = ((old_flags & IFF_UP) ? dev_close : dev_open)(dev);
3746
3747                 if (!ret)
3748                         dev_set_rx_mode(dev);
3749         }
3750
3751         if (dev->flags & IFF_UP &&
3752             ((old_flags ^ dev->flags) &~ (IFF_UP | IFF_PROMISC | IFF_ALLMULTI |
3753                                           IFF_VOLATILE)))
3754                 call_netdevice_notifiers(NETDEV_CHANGE, dev);
3755
3756         if ((flags ^ dev->gflags) & IFF_PROMISC) {
3757                 int inc = (flags & IFF_PROMISC) ? +1 : -1;
3758                 dev->gflags ^= IFF_PROMISC;
3759                 dev_set_promiscuity(dev, inc);
3760         }
3761
3762         /* NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI
3763            is important. Some (broken) drivers set IFF_PROMISC, when
3764            IFF_ALLMULTI is requested not asking us and not reporting.
3765          */
3766         if ((flags ^ dev->gflags) & IFF_ALLMULTI) {
3767                 int inc = (flags & IFF_ALLMULTI) ? +1 : -1;
3768                 dev->gflags ^= IFF_ALLMULTI;
3769                 dev_set_allmulti(dev, inc);
3770         }
3771
3772         /* Exclude state transition flags, already notified */
3773         changes = (old_flags ^ dev->flags) & ~(IFF_UP | IFF_RUNNING);
3774         if (changes)
3775                 rtmsg_ifinfo(RTM_NEWLINK, dev, changes);
3776
3777         return ret;
3778 }
3779
3780 /**
3781  *      dev_set_mtu - Change maximum transfer unit
3782  *      @dev: device
3783  *      @new_mtu: new transfer unit
3784  *
3785  *      Change the maximum transfer size of the network device.
3786  */
3787 int dev_set_mtu(struct net_device *dev, int new_mtu)
3788 {
3789         const struct net_device_ops *ops = dev->netdev_ops;
3790         int err;
3791
3792         if (new_mtu == dev->mtu)
3793                 return 0;
3794
3795         /*      MTU must be positive.    */
3796         if (new_mtu < 0)
3797                 return -EINVAL;
3798
3799         if (!netif_device_present(dev))
3800                 return -ENODEV;
3801
3802         err = 0;
3803         if (ops->ndo_change_mtu)
3804                 err = ops->ndo_change_mtu(dev, new_mtu);
3805         else
3806                 dev->mtu = new_mtu;
3807
3808         if (!err && dev->flags & IFF_UP)
3809                 call_netdevice_notifiers(NETDEV_CHANGEMTU, dev);
3810         return err;
3811 }
3812
3813 /**
3814  *      dev_set_mac_address - Change Media Access Control Address
3815  *      @dev: device
3816  *      @sa: new address
3817  *
3818  *      Change the hardware (MAC) address of the device
3819  */
3820 int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa)
3821 {
3822         const struct net_device_ops *ops = dev->netdev_ops;
3823         int err;
3824
3825         if (!ops->ndo_set_mac_address)
3826                 return -EOPNOTSUPP;
3827         if (sa->sa_family != dev->type)
3828                 return -EINVAL;
3829         if (!netif_device_present(dev))
3830                 return -ENODEV;
3831         err = ops->ndo_set_mac_address(dev, sa);
3832         if (!err)
3833                 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3834         return err;
3835 }
3836
3837 /*
3838  *      Perform the SIOCxIFxxx calls, inside read_lock(dev_base_lock)
3839  */
3840 static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
3841 {
3842         int err;
3843         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3844
3845         if (!dev)
3846                 return -ENODEV;
3847
3848         switch (cmd) {
3849                 case SIOCGIFFLAGS:      /* Get interface flags */
3850                         ifr->ifr_flags = dev_get_flags(dev);
3851                         return 0;
3852
3853                 case SIOCGIFMETRIC:     /* Get the metric on the interface
3854                                            (currently unused) */
3855                         ifr->ifr_metric = 0;
3856                         return 0;
3857
3858                 case SIOCGIFMTU:        /* Get the MTU of a device */
3859                         ifr->ifr_mtu = dev->mtu;
3860                         return 0;
3861
3862                 case SIOCGIFHWADDR:
3863                         if (!dev->addr_len)
3864                                 memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
3865                         else
3866                                 memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
3867                                        min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3868                         ifr->ifr_hwaddr.sa_family = dev->type;
3869                         return 0;
3870
3871                 case SIOCGIFSLAVE:
3872                         err = -EINVAL;
3873                         break;
3874
3875                 case SIOCGIFMAP:
3876                         ifr->ifr_map.mem_start = dev->mem_start;
3877                         ifr->ifr_map.mem_end   = dev->mem_end;
3878                         ifr->ifr_map.base_addr = dev->base_addr;
3879                         ifr->ifr_map.irq       = dev->irq;
3880                         ifr->ifr_map.dma       = dev->dma;
3881                         ifr->ifr_map.port      = dev->if_port;
3882                         return 0;
3883
3884                 case SIOCGIFINDEX:
3885                         ifr->ifr_ifindex = dev->ifindex;
3886                         return 0;
3887
3888                 case SIOCGIFTXQLEN:
3889                         ifr->ifr_qlen = dev->tx_queue_len;
3890                         return 0;
3891
3892                 default:
3893                         /* dev_ioctl() should ensure this case
3894                          * is never reached
3895                          */
3896                         WARN_ON(1);
3897                         err = -EINVAL;
3898                         break;
3899
3900         }
3901         return err;
3902 }
3903
3904 /*
3905  *      Perform the SIOCxIFxxx calls, inside rtnl_lock()
3906  */
3907 static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
3908 {
3909         int err;
3910         struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
3911         const struct net_device_ops *ops;
3912
3913         if (!dev)
3914                 return -ENODEV;
3915
3916         ops = dev->netdev_ops;
3917
3918         switch (cmd) {
3919                 case SIOCSIFFLAGS:      /* Set interface flags */
3920                         return dev_change_flags(dev, ifr->ifr_flags);
3921
3922                 case SIOCSIFMETRIC:     /* Set the metric on the interface
3923                                            (currently unused) */
3924                         return -EOPNOTSUPP;
3925
3926                 case SIOCSIFMTU:        /* Set the MTU of a device */
3927                         return dev_set_mtu(dev, ifr->ifr_mtu);
3928
3929                 case SIOCSIFHWADDR:
3930                         return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
3931
3932                 case SIOCSIFHWBROADCAST:
3933                         if (ifr->ifr_hwaddr.sa_family != dev->type)
3934                                 return -EINVAL;
3935                         memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
3936                                min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
3937                         call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
3938                         return 0;
3939
3940                 case SIOCSIFMAP:
3941                         if (ops->ndo_set_config) {
3942                                 if (!netif_device_present(dev))
3943                                         return -ENODEV;
3944                                 return ops->ndo_set_config(dev, &ifr->ifr_map);
3945                         }
3946                         return -EOPNOTSUPP;
3947
3948                 case SIOCADDMULTI:
3949                         if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
3950                             ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3951                                 return -EINVAL;
3952                         if (!netif_device_present(dev))
3953                                 return -ENODEV;
3954                         return dev_mc_add(dev, ifr->ifr_hwaddr.sa_data,
3955                                           dev->addr_len, 1);
3956
3957                 case SIOCDELMULTI:
3958                         if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) ||
3959                             ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
3960                                 return -EINVAL;
3961                         if (!netif_device_present(dev))
3962                                 return -ENODEV;
3963                         return dev_mc_delete(dev, ifr->ifr_hwaddr.sa_data,
3964                                              dev->addr_len, 1);
3965
3966                 case SIOCSIFTXQLEN:
3967                         if (ifr->ifr_qlen < 0)
3968                                 return -EINVAL;
3969                         dev->tx_queue_len = ifr->ifr_qlen;
3970                         return 0;
3971
3972                 case SIOCSIFNAME:
3973                         ifr->ifr_newname[IFNAMSIZ-1] = '\0';
3974                         return dev_change_name(dev, ifr->ifr_newname);
3975
3976                 /*
3977                  *      Unknown or private ioctl
3978                  */
3979
3980                 default:
3981                         if ((cmd >= SIOCDEVPRIVATE &&
3982                             cmd <= SIOCDEVPRIVATE + 15) ||
3983                             cmd == SIOCBONDENSLAVE ||
3984                             cmd == SIOCBONDRELEASE ||
3985                             cmd == SIOCBONDSETHWADDR ||
3986                             cmd == SIOCBONDSLAVEINFOQUERY ||
3987                             cmd == SIOCBONDINFOQUERY ||
3988                             cmd == SIOCBONDCHANGEACTIVE ||
3989                             cmd == SIOCGMIIPHY ||
3990                             cmd == SIOCGMIIREG ||
3991                             cmd == SIOCSMIIREG ||
3992                             cmd == SIOCBRADDIF ||
3993                             cmd == SIOCBRDELIF ||
3994                             cmd == SIOCSHWTSTAMP ||
3995                             cmd == SIOCWANDEV) {
3996                                 err = -EOPNOTSUPP;
3997                                 if (ops->ndo_do_ioctl) {
3998                                         if (netif_device_present(dev))
3999                                                 err = ops->ndo_do_ioctl(dev, ifr, cmd);
4000                                         else
4001                                                 err = -ENODEV;
4002                                 }
4003                         } else
4004                                 err = -EINVAL;
4005
4006         }
4007         return err;
4008 }
4009
4010 /*
4011  *      This function handles all "interface"-type I/O control requests. The actual
4012  *      'doing' part of this is dev_ifsioc above.
4013  */
4014
4015 /**
4016  *      dev_ioctl       -       network device ioctl
4017  *      @net: the applicable net namespace
4018  *      @cmd: command to issue
4019  *      @arg: pointer to a struct ifreq in user space
4020  *
4021  *      Issue ioctl functions to devices. This is normally called by the
4022  *      user space syscall interfaces but can sometimes be useful for
4023  *      other purposes. The return value is the return from the syscall if
4024  *      positive or a negative errno code on error.
4025  */
4026
4027 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
4028 {
4029         struct ifreq ifr;
4030         int ret;
4031         char *colon;
4032
4033         /* One special case: SIOCGIFCONF takes ifconf argument
4034            and requires shared lock, because it sleeps writing
4035            to user space.
4036          */
4037
4038         if (cmd == SIOCGIFCONF) {
4039                 rtnl_lock();
4040                 ret = dev_ifconf(net, (char __user *) arg);
4041                 rtnl_unlock();
4042                 return ret;
4043         }
4044         if (cmd == SIOCGIFNAME)
4045                 return dev_ifname(net, (struct ifreq __user *)arg);
4046
4047         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
4048                 return -EFAULT;
4049
4050         ifr.ifr_name[IFNAMSIZ-1] = 0;
4051
4052         colon = strchr(ifr.ifr_name, ':');
4053         if (colon)
4054                 *colon = 0;
4055
4056         /*
4057          *      See which interface the caller is talking about.
4058          */
4059
4060         switch (cmd) {
4061                 /*
4062                  *      These ioctl calls:
4063                  *      - can be done by all.
4064                  *      - atomic and do not require locking.
4065                  *      - return a value
4066                  */
4067                 case SIOCGIFFLAGS:
4068                 case SIOCGIFMETRIC:
4069                 case SIOCGIFMTU:
4070                 case SIOCGIFHWADDR:
4071                 case SIOCGIFSLAVE:
4072                 case SIOCGIFMAP:
4073                 case SIOCGIFINDEX:
4074                 case SIOCGIFTXQLEN:
4075                         dev_load(net, ifr.ifr_name);
4076                         read_lock(&dev_base_lock);
4077                         ret = dev_ifsioc_locked(net, &ifr, cmd);
4078                         read_unlock(&dev_base_lock);
4079                         if (!ret) {
4080                                 if (colon)
4081                                         *colon = ':';
4082                                 if (copy_to_user(arg, &ifr,
4083                                                  sizeof(struct ifreq)))
4084                                         ret = -EFAULT;
4085                         }
4086                         return ret;
4087
4088                 case SIOCETHTOOL:
4089                         dev_load(net, ifr.ifr_name);
4090                         rtnl_lock();
4091                         ret = dev_ethtool(net, &ifr);
4092                         rtnl_unlock();
4093                         if (!ret) {
4094                                 if (colon)
4095                                         *colon = ':';
4096                                 if (copy_to_user(arg, &ifr,
4097                                                  sizeof(struct ifreq)))
4098                                         ret = -EFAULT;
4099                         }
4100                         return ret;
4101
4102                 /*
4103                  *      These ioctl calls:
4104                  *      - require superuser power.
4105                  *      - require strict serialization.
4106                  *      - return a value
4107                  */
4108                 case SIOCGMIIPHY:
4109                 case SIOCGMIIREG:
4110                 case SIOCSIFNAME:
4111                         if (!capable(CAP_NET_ADMIN))
4112                                 return -EPERM;
4113                         dev_load(net, ifr.ifr_name);
4114                         rtnl_lock();
4115                         ret = dev_ifsioc(net, &ifr, cmd);
4116                         rtnl_unlock();
4117                         if (!ret) {
4118                                 if (colon)
4119                                         *colon = ':';
4120                                 if (copy_to_user(arg, &ifr,
4121                                                  sizeof(struct ifreq)))
4122                                         ret = -EFAULT;
4123                         }
4124                         return ret;
4125
4126                 /*
4127                  *      These ioctl calls:
4128                  *      - require superuser power.
4129                  *      - require strict serialization.
4130                  *      - do not return a value
4131                  */
4132                 case SIOCSIFFLAGS:
4133                 case SIOCSIFMETRIC:
4134                 case SIOCSIFMTU:
4135                 case SIOCSIFMAP:
4136                 case SIOCSIFHWADDR:
4137                 case SIOCSIFSLAVE:
4138                 case SIOCADDMULTI:
4139                 case SIOCDELMULTI:
4140                 case SIOCSIFHWBROADCAST:
4141                 case SIOCSIFTXQLEN:
4142                 case SIOCSMIIREG:
4143                 case SIOCBONDENSLAVE:
4144                 case SIOCBONDRELEASE:
4145                 case SIOCBONDSETHWADDR:
4146                 case SIOCBONDCHANGEACTIVE:
4147                 case SIOCBRADDIF:
4148                 case SIOCBRDELIF:
4149                 case SIOCSHWTSTAMP:
4150                         if (!capable(CAP_NET_ADMIN))
4151                                 return -EPERM;
4152                         /* fall through */
4153                 case SIOCBONDSLAVEINFOQUERY:
4154                 case SIOCBONDINFOQUERY:
4155                         dev_load(net, ifr.ifr_name);
4156                         rtnl_lock();
4157                         ret = dev_ifsioc(net, &ifr, cmd);
4158                         rtnl_unlock();
4159                         return ret;
4160
4161                 case SIOCGIFMEM:
4162                         /* Get the per device memory space. We can add this but
4163                          * currently do not support it */
4164                 case SIOCSIFMEM:
4165                         /* Set the per device memory buffer space.
4166                          * Not applicable in our case */
4167                 case SIOCSIFLINK:
4168                         return -EINVAL;
4169
4170                 /*
4171                  *      Unknown or private ioctl.
4172                  */
4173                 default:
4174                         if (cmd == SIOCWANDEV ||
4175                             (cmd >= SIOCDEVPRIVATE &&
4176                              cmd <= SIOCDEVPRIVATE + 15)) {
4177                                 dev_load(net, ifr.ifr_name);
4178                                 rtnl_lock();
4179                                 ret = dev_ifsioc(net, &ifr, cmd);
4180                                 rtnl_unlock();
4181                                 if (!ret && copy_to_user(arg, &ifr,
4182                                                          sizeof(struct ifreq)))
4183                                         ret = -EFAULT;
4184                                 return ret;
4185                         }
4186                         /* Take care of Wireless Extensions */
4187                         if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
4188                                 return wext_handle_ioctl(net, &ifr, cmd, arg);
4189                         return -EINVAL;
4190         }
4191 }
4192
4193
4194 /**
4195  *      dev_new_index   -       allocate an ifindex
4196  *      @net: the applicable net namespace
4197  *
4198  *      Returns a suitable unique value for a new device interface
4199  *      number.  The caller must hold the rtnl semaphore or the
4200  *      dev_base_lock to be sure it remains unique.
4201  */
4202 static int dev_new_index(struct net *net)
4203 {
4204         static int ifindex;
4205         for (;;) {
4206                 if (++ifindex <= 0)
4207                         ifindex = 1;
4208                 if (!__dev_get_by_index(net, ifindex))
4209                         return ifindex;
4210         }
4211 }
4212
4213 /* Delayed registration/unregisteration */
4214 static LIST_HEAD(net_todo_list);
4215
4216 static void net_set_todo(struct net_device *dev)
4217 {
4218         list_add_tail(&dev->todo_list, &net_todo_list);
4219 }
4220
4221 static void rollback_registered(struct net_device *dev)
4222 {
4223         BUG_ON(dev_boot_phase);
4224         ASSERT_RTNL();
4225
4226         /* Some devices call without registering for initialization unwind. */
4227         if (dev->reg_state == NETREG_UNINITIALIZED) {
4228                 printk(KERN_DEBUG "unregister_netdevice: device %s/%p never "
4229                                   "was registered\n", dev->name, dev);
4230
4231                 WARN_ON(1);
4232                 return;
4233         }
4234
4235         BUG_ON(dev->reg_state != NETREG_REGISTERED);
4236
4237         /* If device is running, close it first. */
4238         dev_close(dev);
4239
4240         /* And unlink it from device chain. */
4241         unlist_netdevice(dev);
4242
4243         dev->reg_state = NETREG_UNREGISTERING;
4244
4245         synchronize_net();
4246
4247         /* Shutdown queueing discipline. */
4248         dev_shutdown(dev);
4249
4250
4251         /* Notify protocols, that we are about to destroy
4252            this device. They should clean all the things.
4253         */
4254         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4255
4256         /*
4257          *      Flush the unicast and multicast chains
4258          */
4259         dev_addr_discard(dev);
4260
4261         if (dev->netdev_ops->ndo_uninit)
4262                 dev->netdev_ops->ndo_uninit(dev);
4263
4264         /* Notifier chain MUST detach us from master device. */
4265         WARN_ON(dev->master);
4266
4267         /* Remove entries from kobject tree */
4268         netdev_unregister_kobject(dev);
4269
4270         synchronize_net();
4271
4272         dev_put(dev);
4273 }
4274
4275 static void __netdev_init_queue_locks_one(struct net_device *dev,
4276                                           struct netdev_queue *dev_queue,
4277                                           void *_unused)
4278 {
4279         spin_lock_init(&dev_queue->_xmit_lock);
4280         netdev_set_xmit_lockdep_class(&dev_queue->_xmit_lock, dev->type);
4281         dev_queue->xmit_lock_owner = -1;
4282 }
4283
4284 static void netdev_init_queue_locks(struct net_device *dev)
4285 {
4286         netdev_for_each_tx_queue(dev, __netdev_init_queue_locks_one, NULL);
4287         __netdev_init_queue_locks_one(dev, &dev->rx_queue, NULL);
4288 }
4289
4290 unsigned long netdev_fix_features(unsigned long features, const char *name)
4291 {
4292         /* Fix illegal SG+CSUM combinations. */
4293         if ((features & NETIF_F_SG) &&
4294             !(features & NETIF_F_ALL_CSUM)) {
4295                 if (name)
4296                         printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no "
4297                                "checksum feature.\n", name);
4298                 features &= ~NETIF_F_SG;
4299         }
4300
4301         /* TSO requires that SG is present as well. */
4302         if ((features & NETIF_F_TSO) && !(features & NETIF_F_SG)) {
4303                 if (name)
4304                         printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no "
4305                                "SG feature.\n", name);
4306                 features &= ~NETIF_F_TSO;
4307         }
4308
4309         if (features & NETIF_F_UFO) {
4310                 if (!(features & NETIF_F_GEN_CSUM)) {
4311                         if (name)
4312                                 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
4313                                        "since no NETIF_F_HW_CSUM feature.\n",
4314                                        name);
4315                         features &= ~NETIF_F_UFO;
4316                 }
4317
4318                 if (!(features & NETIF_F_SG)) {
4319                         if (name)
4320                                 printk(KERN_ERR "%s: Dropping NETIF_F_UFO "
4321                                        "since no NETIF_F_SG feature.\n", name);
4322                         features &= ~NETIF_F_UFO;
4323                 }
4324         }
4325
4326         return features;
4327 }
4328 EXPORT_SYMBOL(netdev_fix_features);
4329
4330 /* Some devices need to (re-)set their netdev_ops inside
4331  * ->init() or similar.  If that happens, we have to setup
4332  * the compat pointers again.
4333  */
4334 void netdev_resync_ops(struct net_device *dev)
4335 {
4336 #ifdef CONFIG_COMPAT_NET_DEV_OPS
4337         const struct net_device_ops *ops = dev->netdev_ops;
4338
4339         dev->init = ops->ndo_init;
4340         dev->uninit = ops->ndo_uninit;
4341         dev->open = ops->ndo_open;
4342         dev->change_rx_flags = ops->ndo_change_rx_flags;
4343         dev->set_rx_mode = ops->ndo_set_rx_mode;
4344         dev->set_multicast_list = ops->ndo_set_multicast_list;
4345         dev->set_mac_address = ops->ndo_set_mac_address;
4346         dev->validate_addr = ops->ndo_validate_addr;
4347         dev->do_ioctl = ops->ndo_do_ioctl;
4348         dev->set_config = ops->ndo_set_config;
4349         dev->change_mtu = ops->ndo_change_mtu;
4350         dev->neigh_setup = ops->ndo_neigh_setup;
4351         dev->tx_timeout = ops->ndo_tx_timeout;
4352         dev->get_stats = ops->ndo_get_stats;
4353         dev->vlan_rx_register = ops->ndo_vlan_rx_register;
4354         dev->vlan_rx_add_vid = ops->ndo_vlan_rx_add_vid;
4355         dev->vlan_rx_kill_vid = ops->ndo_vlan_rx_kill_vid;
4356 #ifdef CONFIG_NET_POLL_CONTROLLER
4357         dev->poll_controller = ops->ndo_poll_controller;
4358 #endif
4359 #endif
4360 }
4361 EXPORT_SYMBOL(netdev_resync_ops);
4362
4363 /**
4364  *      register_netdevice      - register a network device
4365  *      @dev: device to register
4366  *
4367  *      Take a completed network device structure and add it to the kernel
4368  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4369  *      chain. 0 is returned on success. A negative errno code is returned
4370  *      on a failure to set up the device, or if the name is a duplicate.
4371  *
4372  *      Callers must hold the rtnl semaphore. You may want
4373  *      register_netdev() instead of this.
4374  *
4375  *      BUGS:
4376  *      The locking appears insufficient to guarantee two parallel registers
4377  *      will not get the same name.
4378  */
4379
4380 int register_netdevice(struct net_device *dev)
4381 {
4382         struct hlist_head *head;
4383         struct hlist_node *p;
4384         int ret;
4385         struct net *net = dev_net(dev);
4386
4387         BUG_ON(dev_boot_phase);
4388         ASSERT_RTNL();
4389
4390         might_sleep();
4391
4392         /* When net_device's are persistent, this will be fatal. */
4393         BUG_ON(dev->reg_state != NETREG_UNINITIALIZED);
4394         BUG_ON(!net);
4395
4396         spin_lock_init(&dev->addr_list_lock);
4397         netdev_set_addr_lockdep_class(dev);
4398         netdev_init_queue_locks(dev);
4399
4400         dev->iflink = -1;
4401
4402 #ifdef CONFIG_COMPAT_NET_DEV_OPS
4403         /* Netdevice_ops API compatiability support.
4404          * This is temporary until all network devices are converted.
4405          */
4406         if (dev->netdev_ops) {
4407                 netdev_resync_ops(dev);
4408         } else {
4409                 char drivername[64];
4410                 pr_info("%s (%s): not using net_device_ops yet\n",
4411                         dev->name, netdev_drivername(dev, drivername, 64));
4412
4413                 /* This works only because net_device_ops and the
4414                    compatiablity structure are the same. */
4415                 dev->netdev_ops = (void *) &(dev->init);
4416         }
4417 #endif
4418
4419         /* Init, if this function is available */
4420         if (dev->netdev_ops->ndo_init) {
4421                 ret = dev->netdev_ops->ndo_init(dev);
4422                 if (ret) {
4423                         if (ret > 0)
4424                                 ret = -EIO;
4425                         goto out;
4426                 }
4427         }
4428
4429         if (!dev_valid_name(dev->name)) {
4430                 ret = -EINVAL;
4431                 goto err_uninit;
4432         }
4433
4434         dev->ifindex = dev_new_index(net);
4435         if (dev->iflink == -1)
4436                 dev->iflink = dev->ifindex;
4437
4438         /* Check for existence of name */
4439         head = dev_name_hash(net, dev->name);
4440         hlist_for_each(p, head) {
4441                 struct net_device *d
4442                         = hlist_entry(p, struct net_device, name_hlist);
4443                 if (!strncmp(d->name, dev->name, IFNAMSIZ)) {
4444                         ret = -EEXIST;
4445                         goto err_uninit;
4446                 }
4447         }
4448
4449         /* Fix illegal checksum combinations */
4450         if ((dev->features & NETIF_F_HW_CSUM) &&
4451             (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
4452                 printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n",
4453                        dev->name);
4454                 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
4455         }
4456
4457         if ((dev->features & NETIF_F_NO_CSUM) &&
4458             (dev->features & (NETIF_F_HW_CSUM|NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))) {
4459                 printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n",
4460                        dev->name);
4461                 dev->features &= ~(NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM|NETIF_F_HW_CSUM);
4462         }
4463
4464         dev->features = netdev_fix_features(dev->features, dev->name);
4465
4466         /* Enable software GSO if SG is supported. */
4467         if (dev->features & NETIF_F_SG)
4468                 dev->features |= NETIF_F_GSO;
4469
4470         netdev_initialize_kobject(dev);
4471         ret = netdev_register_kobject(dev);
4472         if (ret)
4473                 goto err_uninit;
4474         dev->reg_state = NETREG_REGISTERED;
4475
4476         /*
4477          *      Default initial state at registry is that the
4478          *      device is present.
4479          */
4480
4481         set_bit(__LINK_STATE_PRESENT, &dev->state);
4482
4483         dev_init_scheduler(dev);
4484         dev_hold(dev);
4485         list_netdevice(dev);
4486
4487         /* Notify protocols, that a new device appeared. */
4488         ret = call_netdevice_notifiers(NETDEV_REGISTER, dev);
4489         ret = notifier_to_errno(ret);
4490         if (ret) {
4491                 rollback_registered(dev);
4492                 dev->reg_state = NETREG_UNREGISTERED;
4493         }
4494
4495 out:
4496         return ret;
4497
4498 err_uninit:
4499         if (dev->netdev_ops->ndo_uninit)
4500                 dev->netdev_ops->ndo_uninit(dev);
4501         goto out;
4502 }
4503
4504 /**
4505  *      init_dummy_netdev       - init a dummy network device for NAPI
4506  *      @dev: device to init
4507  *
4508  *      This takes a network device structure and initialize the minimum
4509  *      amount of fields so it can be used to schedule NAPI polls without
4510  *      registering a full blown interface. This is to be used by drivers
4511  *      that need to tie several hardware interfaces to a single NAPI
4512  *      poll scheduler due to HW limitations.
4513  */
4514 int init_dummy_netdev(struct net_device *dev)
4515 {
4516         /* Clear everything. Note we don't initialize spinlocks
4517          * are they aren't supposed to be taken by any of the
4518          * NAPI code and this dummy netdev is supposed to be
4519          * only ever used for NAPI polls
4520          */
4521         memset(dev, 0, sizeof(struct net_device));
4522
4523         /* make sure we BUG if trying to hit standard
4524          * register/unregister code path
4525          */
4526         dev->reg_state = NETREG_DUMMY;
4527
4528         /* initialize the ref count */
4529         atomic_set(&dev->refcnt, 1);
4530
4531         /* NAPI wants this */
4532         INIT_LIST_HEAD(&dev->napi_list);
4533
4534         /* a dummy interface is started by default */
4535         set_bit(__LINK_STATE_PRESENT, &dev->state);
4536         set_bit(__LINK_STATE_START, &dev->state);
4537
4538         return 0;
4539 }
4540 EXPORT_SYMBOL_GPL(init_dummy_netdev);
4541
4542
4543 /**
4544  *      register_netdev - register a network device
4545  *      @dev: device to register
4546  *
4547  *      Take a completed network device structure and add it to the kernel
4548  *      interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier
4549  *      chain. 0 is returned on success. A negative errno code is returned
4550  *      on a failure to set up the device, or if the name is a duplicate.
4551  *
4552  *      This is a wrapper around register_netdevice that takes the rtnl semaphore
4553  *      and expands the device name if you passed a format string to
4554  *      alloc_netdev.
4555  */
4556 int register_netdev(struct net_device *dev)
4557 {
4558         int err;
4559
4560         rtnl_lock();
4561
4562         /*
4563          * If the name is a format string the caller wants us to do a
4564          * name allocation.
4565          */
4566         if (strchr(dev->name, '%')) {
4567                 err = dev_alloc_name(dev, dev->name);
4568                 if (err < 0)
4569                         goto out;
4570         }
4571
4572         err = register_netdevice(dev);
4573 out:
4574         rtnl_unlock();
4575         return err;
4576 }
4577 EXPORT_SYMBOL(register_netdev);
4578
4579 /*
4580  * netdev_wait_allrefs - wait until all references are gone.
4581  *
4582  * This is called when unregistering network devices.
4583  *
4584  * Any protocol or device that holds a reference should register
4585  * for netdevice notification, and cleanup and put back the
4586  * reference if they receive an UNREGISTER event.
4587  * We can get stuck here if buggy protocols don't correctly
4588  * call dev_put.
4589  */
4590 static void netdev_wait_allrefs(struct net_device *dev)
4591 {
4592         unsigned long rebroadcast_time, warning_time;
4593
4594         rebroadcast_time = warning_time = jiffies;
4595         while (atomic_read(&dev->refcnt) != 0) {
4596                 if (time_after(jiffies, rebroadcast_time + 1 * HZ)) {
4597                         rtnl_lock();
4598
4599                         /* Rebroadcast unregister notification */
4600                         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4601
4602                         if (test_bit(__LINK_STATE_LINKWATCH_PENDING,
4603                                      &dev->state)) {
4604                                 /* We must not have linkwatch events
4605                                  * pending on unregister. If this
4606                                  * happens, we simply run the queue
4607                                  * unscheduled, resulting in a noop
4608                                  * for this device.
4609                                  */
4610                                 linkwatch_run_queue();
4611                         }
4612
4613                         __rtnl_unlock();
4614
4615                         rebroadcast_time = jiffies;
4616                 }
4617
4618                 msleep(250);
4619
4620                 if (time_after(jiffies, warning_time + 10 * HZ)) {
4621                         printk(KERN_EMERG "unregister_netdevice: "
4622                                "waiting for %s to become free. Usage "
4623                                "count = %d\n",
4624                                dev->name, atomic_read(&dev->refcnt));
4625                         warning_time = jiffies;
4626                 }
4627         }
4628 }
4629
4630 /* The sequence is:
4631  *
4632  *      rtnl_lock();
4633  *      ...
4634  *      register_netdevice(x1);
4635  *      register_netdevice(x2);
4636  *      ...
4637  *      unregister_netdevice(y1);
4638  *      unregister_netdevice(y2);
4639  *      ...
4640  *      rtnl_unlock();
4641  *      free_netdev(y1);
4642  *      free_netdev(y2);
4643  *
4644  * We are invoked by rtnl_unlock().
4645  * This allows us to deal with problems:
4646  * 1) We can delete sysfs objects which invoke hotplug
4647  *    without deadlocking with linkwatch via keventd.
4648  * 2) Since we run with the RTNL semaphore not held, we can sleep
4649  *    safely in order to wait for the netdev refcnt to drop to zero.
4650  *
4651  * We must not return until all unregister events added during
4652  * the interval the lock was held have been completed.
4653  */
4654 void netdev_run_todo(void)
4655 {
4656         struct list_head list;
4657
4658         /* Snapshot list, allow later requests */
4659         list_replace_init(&net_todo_list, &list);
4660
4661         __rtnl_unlock();
4662
4663         while (!list_empty(&list)) {
4664                 struct net_device *dev
4665                         = list_entry(list.next, struct net_device, todo_list);
4666                 list_del(&dev->todo_list);
4667
4668                 if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) {
4669                         printk(KERN_ERR "network todo '%s' but state %d\n",
4670                                dev->name, dev->reg_state);
4671                         dump_stack();
4672                         continue;
4673                 }
4674
4675                 dev->reg_state = NETREG_UNREGISTERED;
4676
4677                 on_each_cpu(flush_backlog, dev, 1);
4678
4679                 netdev_wait_allrefs(dev);
4680
4681                 /* paranoia */
4682                 BUG_ON(atomic_read(&dev->refcnt));
4683                 WARN_ON(dev->ip_ptr);
4684                 WARN_ON(dev->ip6_ptr);
4685                 WARN_ON(dev->dn_ptr);
4686
4687                 if (dev->destructor)
4688                         dev->destructor(dev);
4689
4690                 /* Free network device */
4691                 kobject_put(&dev->dev.kobj);
4692         }
4693 }
4694
4695 /**
4696  *      dev_get_stats   - get network device statistics
4697  *      @dev: device to get statistics from
4698  *
4699  *      Get network statistics from device. The device driver may provide
4700  *      its own method by setting dev->netdev_ops->get_stats; otherwise
4701  *      the internal statistics structure is used.
4702  */
4703 const struct net_device_stats *dev_get_stats(struct net_device *dev)
4704  {
4705         const struct net_device_ops *ops = dev->netdev_ops;
4706
4707         if (ops->ndo_get_stats)
4708                 return ops->ndo_get_stats(dev);
4709         else
4710                 return &dev->stats;
4711 }
4712 EXPORT_SYMBOL(dev_get_stats);
4713
4714 static void netdev_init_one_queue(struct net_device *dev,
4715                                   struct netdev_queue *queue,
4716                                   void *_unused)
4717 {
4718         queue->dev = dev;
4719 }
4720
4721 static void netdev_init_queues(struct net_device *dev)
4722 {
4723         netdev_init_one_queue(dev, &dev->rx_queue, NULL);
4724         netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL);
4725         spin_lock_init(&dev->tx_global_lock);
4726 }
4727
4728 /**
4729  *      alloc_netdev_mq - allocate network device
4730  *      @sizeof_priv:   size of private data to allocate space for
4731  *      @name:          device name format string
4732  *      @setup:         callback to initialize device
4733  *      @queue_count:   the number of subqueues to allocate
4734  *
4735  *      Allocates a struct net_device with private data area for driver use
4736  *      and performs basic initialization.  Also allocates subquue structs
4737  *      for each queue on the device at the end of the netdevice.
4738  */
4739 struct net_device *alloc_netdev_mq(int sizeof_priv, const char *name,
4740                 void (*setup)(struct net_device *), unsigned int queue_count)
4741 {
4742         struct netdev_queue *tx;
4743         struct net_device *dev;
4744         size_t alloc_size;
4745         void *p;
4746
4747         BUG_ON(strlen(name) >= sizeof(dev->name));
4748
4749         alloc_size = sizeof(struct net_device);
4750         if (sizeof_priv) {
4751                 /* ensure 32-byte alignment of private area */
4752                 alloc_size = (alloc_size + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST;
4753                 alloc_size += sizeof_priv;
4754         }
4755         /* ensure 32-byte alignment of whole construct */
4756         alloc_size += NETDEV_ALIGN_CONST;
4757
4758         p = kzalloc(alloc_size, GFP_KERNEL);
4759         if (!p) {
4760                 printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n");
4761                 return NULL;
4762         }
4763
4764         tx = kcalloc(queue_count, sizeof(struct netdev_queue), GFP_KERNEL);
4765         if (!tx) {
4766                 printk(KERN_ERR "alloc_netdev: Unable to allocate "
4767                        "tx qdiscs.\n");
4768                 kfree(p);
4769                 return NULL;
4770         }
4771
4772         dev = (struct net_device *)
4773                 (((long)p + NETDEV_ALIGN_CONST) & ~NETDEV_ALIGN_CONST);
4774         dev->padded = (char *)dev - (char *)p;
4775         dev_net_set(dev, &init_net);
4776
4777         dev->_tx = tx;
4778         dev->num_tx_queues = queue_count;
4779         dev->real_num_tx_queues = queue_count;
4780
4781         dev->gso_max_size = GSO_MAX_SIZE;
4782
4783         netdev_init_queues(dev);
4784
4785         INIT_LIST_HEAD(&dev->napi_list);
4786         setup(dev);
4787         strcpy(dev->name, name);
4788         return dev;
4789 }
4790 EXPORT_SYMBOL(alloc_netdev_mq);
4791
4792 /**
4793  *      free_netdev - free network device
4794  *      @dev: device
4795  *
4796  *      This function does the last stage of destroying an allocated device
4797  *      interface. The reference to the device object is released.
4798  *      If this is the last reference then it will be freed.
4799  */
4800 void free_netdev(struct net_device *dev)
4801 {
4802         struct napi_struct *p, *n;
4803
4804         release_net(dev_net(dev));
4805
4806         kfree(dev->_tx);
4807
4808         list_for_each_entry_safe(p, n, &dev->napi_list, dev_list)
4809                 netif_napi_del(p);
4810
4811         /*  Compatibility with error handling in drivers */
4812         if (dev->reg_state == NETREG_UNINITIALIZED) {
4813                 kfree((char *)dev - dev->padded);
4814                 return;
4815         }
4816
4817         BUG_ON(dev->reg_state != NETREG_UNREGISTERED);
4818         dev->reg_state = NETREG_RELEASED;
4819
4820         /* will free via device release */
4821         put_device(&dev->dev);
4822 }
4823
4824 /**
4825  *      synchronize_net -  Synchronize with packet receive processing
4826  *
4827  *      Wait for packets currently being received to be done.
4828  *      Does not block later packets from starting.
4829  */
4830 void synchronize_net(void)
4831 {
4832         might_sleep();
4833         synchronize_rcu();
4834 }
4835
4836 /**
4837  *      unregister_netdevice - remove device from the kernel
4838  *      @dev: device
4839  *
4840  *      This function shuts down a device interface and removes it
4841  *      from the kernel tables.
4842  *
4843  *      Callers must hold the rtnl semaphore.  You may want
4844  *      unregister_netdev() instead of this.
4845  */
4846
4847 void unregister_netdevice(struct net_device *dev)
4848 {
4849         ASSERT_RTNL();
4850
4851         rollback_registered(dev);
4852         /* Finish processing unregister after unlock */
4853         net_set_todo(dev);
4854 }
4855
4856 /**
4857  *      unregister_netdev - remove device from the kernel
4858  *      @dev: device
4859  *
4860  *      This function shuts down a device interface and removes it
4861  *      from the kernel tables.
4862  *
4863  *      This is just a wrapper for unregister_netdevice that takes
4864  *      the rtnl semaphore.  In general you want to use this and not
4865  *      unregister_netdevice.
4866  */
4867 void unregister_netdev(struct net_device *dev)
4868 {
4869         rtnl_lock();
4870         unregister_netdevice(dev);
4871         rtnl_unlock();
4872 }
4873
4874 EXPORT_SYMBOL(unregister_netdev);
4875
4876 /**
4877  *      dev_change_net_namespace - move device to different nethost namespace
4878  *      @dev: device
4879  *      @net: network namespace
4880  *      @pat: If not NULL name pattern to try if the current device name
4881  *            is already taken in the destination network namespace.
4882  *
4883  *      This function shuts down a device interface and moves it
4884  *      to a new network namespace. On success 0 is returned, on
4885  *      a failure a netagive errno code is returned.
4886  *
4887  *      Callers must hold the rtnl semaphore.
4888  */
4889
4890 int dev_change_net_namespace(struct net_device *dev, struct net *net, const char *pat)
4891 {
4892         char buf[IFNAMSIZ];
4893         const char *destname;
4894         int err;
4895
4896         ASSERT_RTNL();
4897
4898         /* Don't allow namespace local devices to be moved. */
4899         err = -EINVAL;
4900         if (dev->features & NETIF_F_NETNS_LOCAL)
4901                 goto out;
4902
4903 #ifdef CONFIG_SYSFS
4904         /* Don't allow real devices to be moved when sysfs
4905          * is enabled.
4906          */
4907         err = -EINVAL;
4908         if (dev->dev.parent)
4909                 goto out;
4910 #endif
4911
4912         /* Ensure the device has been registrered */
4913         err = -EINVAL;
4914         if (dev->reg_state != NETREG_REGISTERED)
4915                 goto out;
4916
4917         /* Get out if there is nothing todo */
4918         err = 0;
4919         if (net_eq(dev_net(dev), net))
4920                 goto out;
4921
4922         /* Pick the destination device name, and ensure
4923          * we can use it in the destination network namespace.
4924          */
4925         err = -EEXIST;
4926         destname = dev->name;
4927         if (__dev_get_by_name(net, destname)) {
4928                 /* We get here if we can't use the current device name */
4929                 if (!pat)
4930                         goto out;
4931                 if (!dev_valid_name(pat))
4932                         goto out;
4933                 if (strchr(pat, '%')) {
4934                         if (__dev_alloc_name(net, pat, buf) < 0)
4935                                 goto out;
4936                         destname = buf;
4937                 } else
4938                         destname = pat;
4939                 if (__dev_get_by_name(net, destname))
4940                         goto out;
4941         }
4942
4943         /*
4944          * And now a mini version of register_netdevice unregister_netdevice.
4945          */
4946
4947         /* If device is running close it first. */
4948         dev_close(dev);
4949
4950         /* And unlink it from device chain */
4951         err = -ENODEV;
4952         unlist_netdevice(dev);
4953
4954         synchronize_net();
4955
4956         /* Shutdown queueing discipline. */
4957         dev_shutdown(dev);
4958
4959         /* Notify protocols, that we are about to destroy
4960            this device. They should clean all the things.
4961         */
4962         call_netdevice_notifiers(NETDEV_UNREGISTER, dev);
4963
4964         /*
4965          *      Flush the unicast and multicast chains
4966          */
4967         dev_addr_discard(dev);
4968
4969         netdev_unregister_kobject(dev);
4970
4971         /* Actually switch the network namespace */
4972         dev_net_set(dev, net);
4973
4974         /* Assign the new device name */
4975         if (destname != dev->name)
4976                 strcpy(dev->name, destname);
4977
4978         /* If there is an ifindex conflict assign a new one */
4979         if (__dev_get_by_index(net, dev->ifindex)) {
4980                 int iflink = (dev->iflink == dev->ifindex);
4981                 dev->ifindex = dev_new_index(net);
4982                 if (iflink)
4983                         dev->iflink = dev->ifindex;
4984         }
4985
4986         /* Fixup kobjects */
4987         err = netdev_register_kobject(dev);
4988         WARN_ON(err);
4989
4990         /* Add the device back in the hashes */
4991         list_netdevice(dev);
4992
4993         /* Notify protocols, that a new device appeared. */
4994         call_netdevice_notifiers(NETDEV_REGISTER, dev);
4995
4996         synchronize_net();
4997         err = 0;
4998 out:
4999         return err;
5000 }
5001
5002 static int dev_cpu_callback(struct notifier_block *nfb,
5003                             unsigned long action,
5004                             void *ocpu)
5005 {
5006         struct sk_buff **list_skb;
5007         struct Qdisc **list_net;
5008         struct sk_buff *skb;
5009         unsigned int cpu, oldcpu = (unsigned long)ocpu;
5010         struct softnet_data *sd, *oldsd;
5011
5012         if (action != CPU_DEAD && action != CPU_DEAD_FROZEN)
5013                 return NOTIFY_OK;
5014
5015         local_irq_disable();
5016         cpu = smp_processor_id();
5017         sd = &per_cpu(softnet_data, cpu);
5018         oldsd = &per_cpu(softnet_data, oldcpu);
5019
5020         /* Find end of our completion_queue. */
5021         list_skb = &sd->completion_queue;
5022         while (*list_skb)
5023                 list_skb = &(*list_skb)->next;
5024         /* Append completion queue from offline CPU. */
5025         *list_skb = oldsd->completion_queue;
5026         oldsd->completion_queue = NULL;
5027
5028         /* Find end of our output_queue. */
5029         list_net = &sd->output_queue;
5030         while (*list_net)
5031                 list_net = &(*list_net)->next_sched;
5032         /* Append output queue from offline CPU. */
5033         *list_net = oldsd->output_queue;
5034         oldsd->output_queue = NULL;
5035
5036         raise_softirq_irqoff(NET_TX_SOFTIRQ);
5037         local_irq_enable();
5038
5039         /* Process offline CPU's input_pkt_queue */
5040         while ((skb = __skb_dequeue(&oldsd->input_pkt_queue)))
5041                 netif_rx(skb);
5042
5043         return NOTIFY_OK;
5044 }
5045
5046
5047 /**
5048  *      netdev_increment_features - increment feature set by one
5049  *      @all: current feature set
5050  *      @one: new feature set
5051  *      @mask: mask feature set
5052  *
5053  *      Computes a new feature set after adding a device with feature set
5054  *      @one to the master device with current feature set @all.  Will not
5055  *      enable anything that is off in @mask. Returns the new feature set.
5056  */
5057 unsigned long netdev_increment_features(unsigned long all, unsigned long one,
5058                                         unsigned long mask)
5059 {
5060         /* If device needs checksumming, downgrade to it. */
5061         if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM))
5062                 all ^= NETIF_F_NO_CSUM | (one & NETIF_F_ALL_CSUM);
5063         else if (mask & NETIF_F_ALL_CSUM) {
5064                 /* If one device supports v4/v6 checksumming, set for all. */
5065                 if (one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM) &&
5066                     !(all & NETIF_F_GEN_CSUM)) {
5067                         all &= ~NETIF_F_ALL_CSUM;
5068                         all |= one & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
5069                 }
5070
5071                 /* If one device supports hw checksumming, set for all. */
5072                 if (one & NETIF_F_GEN_CSUM && !(all & NETIF_F_GEN_CSUM)) {
5073                         all &= ~NETIF_F_ALL_CSUM;
5074                         all |= NETIF_F_HW_CSUM;
5075                 }
5076         }
5077
5078         one |= NETIF_F_ALL_CSUM;
5079
5080         one |= all & NETIF_F_ONE_FOR_ALL;
5081         all &= one | NETIF_F_LLTX | NETIF_F_GSO;
5082         all |= one & mask & NETIF_F_ONE_FOR_ALL;
5083
5084         return all;
5085 }
5086 EXPORT_SYMBOL(netdev_increment_features);
5087
5088 static struct hlist_head *netdev_create_hash(void)
5089 {
5090         int i;
5091         struct hlist_head *hash;
5092
5093         hash = kmalloc(sizeof(*hash) * NETDEV_HASHENTRIES, GFP_KERNEL);
5094         if (hash != NULL)
5095                 for (i = 0; i < NETDEV_HASHENTRIES; i++)
5096                         INIT_HLIST_HEAD(&hash[i]);
5097
5098         return hash;
5099 }
5100
5101 /* Initialize per network namespace state */
5102 static int __net_init netdev_init(struct net *net)
5103 {
5104         INIT_LIST_HEAD(&net->dev_base_head);
5105
5106         net->dev_name_head = netdev_create_hash();
5107         if (net->dev_name_head == NULL)
5108                 goto err_name;
5109
5110         net->dev_index_head = netdev_create_hash();
5111         if (net->dev_index_head == NULL)
5112                 goto err_idx;
5113
5114         return 0;
5115
5116 err_idx:
5117         kfree(net->dev_name_head);
5118 err_name:
5119         return -ENOMEM;
5120 }
5121
5122 /**
5123  *      netdev_drivername - network driver for the device
5124  *      @dev: network device
5125  *      @buffer: buffer for resulting name
5126  *      @len: size of buffer
5127  *
5128  *      Determine network driver for device.
5129  */
5130 char *netdev_drivername(const struct net_device *dev, char *buffer, int len)
5131 {
5132         const struct device_driver *driver;
5133         const struct device *parent;
5134
5135         if (len <= 0 || !buffer)
5136                 return buffer;
5137         buffer[0] = 0;
5138
5139         parent = dev->dev.parent;
5140
5141         if (!parent)
5142                 return buffer;
5143
5144         driver = parent->driver;
5145         if (driver && driver->name)
5146                 strlcpy(buffer, driver->name, len);
5147         return buffer;
5148 }
5149
5150 static void __net_exit netdev_exit(struct net *net)
5151 {
5152         kfree(net->dev_name_head);
5153         kfree(net->dev_index_head);
5154 }
5155
5156 static struct pernet_operations __net_initdata netdev_net_ops = {
5157         .init = netdev_init,
5158         .exit = netdev_exit,
5159 };
5160
5161 static void __net_exit default_device_exit(struct net *net)
5162 {
5163         struct net_device *dev;
5164         /*
5165          * Push all migratable of the network devices back to the
5166          * initial network namespace
5167          */
5168         rtnl_lock();
5169 restart:
5170         for_each_netdev(net, dev) {
5171                 int err;
5172                 char fb_name[IFNAMSIZ];
5173
5174                 /* Ignore unmoveable devices (i.e. loopback) */
5175                 if (dev->features & NETIF_F_NETNS_LOCAL)
5176                         continue;
5177
5178                 /* Delete virtual devices */
5179                 if (dev->rtnl_link_ops && dev->rtnl_link_ops->dellink) {
5180                         dev->rtnl_link_ops->dellink(dev);
5181                         goto restart;
5182                 }
5183
5184                 /* Push remaing network devices to init_net */
5185                 snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex);
5186                 err = dev_change_net_namespace(dev, &init_net, fb_name);
5187                 if (err) {
5188                         printk(KERN_EMERG "%s: failed to move %s to init_net: %d\n",
5189                                 __func__, dev->name, err);
5190                         BUG();
5191                 }
5192                 goto restart;
5193         }
5194         rtnl_unlock();
5195 }
5196
5197 static struct pernet_operations __net_initdata default_device_ops = {
5198         .exit = default_device_exit,
5199 };
5200
5201 /*
5202  *      Initialize the DEV module. At boot time this walks the device list and
5203  *      unhooks any devices that fail to initialise (normally hardware not
5204  *      present) and leaves us with a valid list of present and active devices.
5205  *
5206  */
5207
5208 /*
5209  *       This is called single threaded during boot, so no need
5210  *       to take the rtnl semaphore.
5211  */
5212 static int __init net_dev_init(void)
5213 {
5214         int i, rc = -ENOMEM;
5215
5216         BUG_ON(!dev_boot_phase);
5217
5218         if (dev_proc_init())
5219                 goto out;
5220
5221         if (netdev_kobject_init())
5222                 goto out;
5223
5224         INIT_LIST_HEAD(&ptype_all);
5225         for (i = 0; i < PTYPE_HASH_SIZE; i++)
5226                 INIT_LIST_HEAD(&ptype_base[i]);
5227
5228         if (register_pernet_subsys(&netdev_net_ops))
5229                 goto out;
5230
5231         /*
5232          *      Initialise the packet receive queues.
5233          */
5234
5235         for_each_possible_cpu(i) {
5236                 struct softnet_data *queue;
5237
5238                 queue = &per_cpu(softnet_data, i);
5239                 skb_queue_head_init(&queue->input_pkt_queue);
5240                 queue->completion_queue = NULL;
5241                 INIT_LIST_HEAD(&queue->poll_list);
5242
5243                 queue->backlog.poll = process_backlog;
5244                 queue->backlog.weight = weight_p;
5245                 queue->backlog.gro_list = NULL;
5246                 queue->backlog.gro_count = 0;
5247         }
5248
5249         dev_boot_phase = 0;
5250
5251         /* The loopback device is special if any other network devices
5252          * is present in a network namespace the loopback device must
5253          * be present. Since we now dynamically allocate and free the
5254          * loopback device ensure this invariant is maintained by
5255          * keeping the loopback device as the first device on the
5256          * list of network devices.  Ensuring the loopback devices
5257          * is the first device that appears and the last network device
5258          * that disappears.
5259          */
5260         if (register_pernet_device(&loopback_net_ops))
5261                 goto out;
5262
5263         if (register_pernet_device(&default_device_ops))
5264                 goto out;
5265
5266         open_softirq(NET_TX_SOFTIRQ, net_tx_action);
5267         open_softirq(NET_RX_SOFTIRQ, net_rx_action);
5268
5269         hotcpu_notifier(dev_cpu_callback, 0);
5270         dst_init();
5271         dev_mcast_init();
5272         rc = 0;
5273 out:
5274         return rc;
5275 }
5276
5277 subsys_initcall(net_dev_init);
5278
5279 static int __init initialize_hashrnd(void)
5280 {
5281         get_random_bytes(&skb_tx_hashrnd, sizeof(skb_tx_hashrnd));
5282         return 0;
5283 }
5284
5285 late_initcall_sync(initialize_hashrnd);
5286
5287 EXPORT_SYMBOL(__dev_get_by_index);
5288 EXPORT_SYMBOL(__dev_get_by_name);
5289 EXPORT_SYMBOL(__dev_remove_pack);
5290 EXPORT_SYMBOL(dev_valid_name);
5291 EXPORT_SYMBOL(dev_add_pack);
5292 EXPORT_SYMBOL(dev_alloc_name);
5293 EXPORT_SYMBOL(dev_close);
5294 EXPORT_SYMBOL(dev_get_by_flags);
5295 EXPORT_SYMBOL(dev_get_by_index);
5296 EXPORT_SYMBOL(dev_get_by_name);
5297 EXPORT_SYMBOL(dev_open);
5298 EXPORT_SYMBOL(dev_queue_xmit);
5299 EXPORT_SYMBOL(dev_remove_pack);
5300 EXPORT_SYMBOL(dev_set_allmulti);
5301 EXPORT_SYMBOL(dev_set_promiscuity);
5302 EXPORT_SYMBOL(dev_change_flags);
5303 EXPORT_SYMBOL(dev_set_mtu);
5304 EXPORT_SYMBOL(dev_set_mac_address);
5305 EXPORT_SYMBOL(free_netdev);
5306 EXPORT_SYMBOL(netdev_boot_setup_check);
5307 EXPORT_SYMBOL(netdev_set_master);
5308 EXPORT_SYMBOL(netdev_state_change);
5309 EXPORT_SYMBOL(netif_receive_skb);
5310 EXPORT_SYMBOL(netif_rx);
5311 EXPORT_SYMBOL(register_gifconf);
5312 EXPORT_SYMBOL(register_netdevice);
5313 EXPORT_SYMBOL(register_netdevice_notifier);
5314 EXPORT_SYMBOL(skb_checksum_help);
5315 EXPORT_SYMBOL(synchronize_net);
5316 EXPORT_SYMBOL(unregister_netdevice);
5317 EXPORT_SYMBOL(unregister_netdevice_notifier);
5318 EXPORT_SYMBOL(net_enable_timestamp);
5319 EXPORT_SYMBOL(net_disable_timestamp);
5320 EXPORT_SYMBOL(dev_get_flags);
5321
5322 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE)
5323 EXPORT_SYMBOL(br_handle_frame_hook);
5324 EXPORT_SYMBOL(br_fdb_get_hook);
5325 EXPORT_SYMBOL(br_fdb_put_hook);
5326 #endif
5327
5328 EXPORT_SYMBOL(dev_load);
5329
5330 EXPORT_PER_CPU_SYMBOL(softnet_data);