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